API tools faq
paste
Guest User

Untitled

a guest
Oct 7th, 2018
256
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 70.45 KB | None | 0 0
raw download clone embed print report
  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"
  10.  
  11. #include "../eterlib/StateManager.h"
  12. #include "../gamelib/ItemManager.h"
  13.  
  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 = 300.0f;
  19.  
  20.  
  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. }
  34.  
  35. //////////////////////////////////////////////////////////////////////////////////////
  36.  
  37.  
  38. CInstanceBase::SHORSE::SHORSE()
  39. {
  40. __Initialize();
  41. }
  42.  
  43. CInstanceBase::SHORSE::~SHORSE()
  44. {
  45. assert(m_pkActor==NULL);
  46. }
  47.  
  48. void CInstanceBase::SHORSE::__Initialize()
  49. {
  50. m_isMounting=false;
  51. m_pkActor=NULL;
  52. }
  53.  
  54. void CInstanceBase::SHORSE::SetAttackSpeed(UINT uAtkSpd)
  55. {
  56. if (!IsMounting())
  57. return;
  58.  
  59. CActorInstance& rkActor=GetActorRef();
  60. rkActor.SetAttackSpeed(uAtkSpd/100.0f);
  61. }
  62.  
  63. void CInstanceBase::SHORSE::SetMoveSpeed(UINT uMovSpd)
  64. {
  65. if (!IsMounting())
  66. return;
  67.  
  68. CActorInstance& rkActor=GetActorRef();
  69. rkActor.SetMoveSpeed(uMovSpd/100.0f);
  70. }
  71.  
  72. void CInstanceBase::SHORSE::Create(const TPixelPosition& c_rkPPos, UINT eRace, UINT eHitEffect)
  73. {
  74. assert(NULL==m_pkActor && "CInstanceBase::SHORSE::Create - ALREADY MOUNT");
  75.  
  76. m_pkActor=new CActorInstance;
  77.  
  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. }
  86.  
  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();
  96.  
  97. rkActor.SetCurPixelPosition(c_rkPPos);
  98.  
  99. m_isMounting=true;
  100. }
  101.  
  102. void CInstanceBase::SHORSE::Destroy()
  103. {
  104. if (m_pkActor)
  105. {
  106. m_pkActor->Destroy();
  107. delete m_pkActor;
  108. }
  109.  
  110. __Initialize();
  111. }
  112.  
  113. CActorInstance& CInstanceBase::SHORSE::GetActorRef()
  114. {
  115. assert(NULL!=m_pkActor && "CInstanceBase::SHORSE::GetActorRef");
  116. return *m_pkActor;
  117. }
  118.  
  119. CActorInstance* CInstanceBase::SHORSE::GetActorPtr()
  120. {
  121. return m_pkActor;
  122. }
  123.  
  124. bool CInstanceBase::SHORSE::IsNewMount()
  125. {
  126. if (!m_pkActor)
  127. return false;
  128.  
  129. return false;
  130. }
  131.  
  132. bool CInstanceBase::SHORSE::CanUseSkill()
  133. {
  134. return true;
  135. }
  136.  
  137. bool CInstanceBase::SHORSE::CanAttack()
  138. {
  139. return true;
  140. }
  141.  
  142. bool CInstanceBase::SHORSE::IsMounting()
  143. {
  144. return m_isMounting;
  145. }
  146.  
  147. void CInstanceBase::SHORSE::Deform()
  148. {
  149. if (!IsMounting())
  150. return;
  151.  
  152. CActorInstance& rkActor=GetActorRef();
  153. rkActor.INSTANCEBASE_Deform();
  154. }
  155.  
  156. void CInstanceBase::SHORSE::Render()
  157. {
  158. if (!IsMounting())
  159. return;
  160.  
  161. CActorInstance& rkActor=GetActorRef();
  162. rkActor.Render();
  163. }
  164.  
  165. void CInstanceBase::__AttachHorseSaddle()
  166. {
  167. if (!IsMountingHorse())
  168. return;
  169. m_kHorse.m_pkActor->AttachModelInstance(CRaceData::PART_MAIN, "saddle", m_GraphicThingInstance, CRaceData::PART_MAIN);
  170. }
  171.  
  172. void CInstanceBase::__DetachHorseSaddle()
  173. {
  174. if (!IsMountingHorse())
  175. return;
  176. m_kHorse.m_pkActor->DetachModelInstance(CRaceData::PART_MAIN, m_GraphicThingInstance, CRaceData::PART_MAIN);
  177. }
  178.  
  179. //////////////////////////////////////////////////////////////////////////////////////
  180.  
  181. void CInstanceBase::BlockMovement()
  182. {
  183. m_GraphicThingInstance.BlockMovement();
  184. }
  185.  
  186. bool CInstanceBase::IsBlockObject(const CGraphicObjectInstance& c_rkBGObj)
  187. {
  188. return m_GraphicThingInstance.IsBlockObject(c_rkBGObj);
  189. }
  190.  
  191. bool CInstanceBase::AvoidObject(const CGraphicObjectInstance& c_rkBGObj)
  192. {
  193. return m_GraphicThingInstance.AvoidObject(c_rkBGObj);
  194. }
  195.  
  196. ///////////////////////////////////////////////////////////////////////////////////
  197.  
  198. bool __ArmorVnumToShape(int iVnum, DWORD * pdwShape)
  199. {
  200. *pdwShape = iVnum;
  201.  
  202. /////////////////////////////////////////
  203.  
  204. if (0 == iVnum || 1 == iVnum)
  205. return false;
  206.  
  207. if (!USE_ARMOR_SPECULAR)
  208. return false;
  209.  
  210. CItemData * pItemData;
  211. if (!CItemManager::Instance().GetItemDataPointer(iVnum, &pItemData))
  212. return false;
  213.  
  214. enum
  215. {
  216. SHAPE_VALUE_SLOT_INDEX = 3,
  217. };
  218.  
  219. *pdwShape = pItemData->GetValue(SHAPE_VALUE_SLOT_INDEX);
  220.  
  221. return true;
  222. }
  223.  
  224. // 2004.07.05.myevan.궁신탄영 끼이는 문제
  225. class CActorInstanceBackground : public IBackground
  226. {
  227. public:
  228. CActorInstanceBackground() {}
  229. virtual ~CActorInstanceBackground() {}
  230. bool IsBlock(int x, int y)
  231. {
  232. CPythonBackground& rkBG=CPythonBackground::Instance();
  233. return rkBG.isAttrOn(x, y, CTerrainImpl::ATTRIBUTE_BLOCK);
  234. }
  235. };
  236.  
  237. static CActorInstanceBackground gs_kActorInstBG;
  238.  
  239. bool CInstanceBase::LessRenderOrder(CInstanceBase* pkInst)
  240. {
  241. int nMainAlpha=(__GetAlphaValue() < 1.0f) ? 1 : 0;
  242. int nTestAlpha=(pkInst->__GetAlphaValue() < 1.0f) ? 1 : 0;
  243. if (nMainAlpha < nTestAlpha)
  244. return true;
  245. if (nMainAlpha > nTestAlpha)
  246. return false;
  247.  
  248. if (GetRace()<pkInst->GetRace())
  249. return true;
  250. if (GetRace()>pkInst->GetRace())
  251. return false;
  252.  
  253. if (GetShape()<pkInst->GetShape())
  254. return true;
  255.  
  256. if (GetShape()>pkInst->GetShape())
  257. return false;
  258.  
  259. UINT uLeftLODLevel=__LessRenderOrder_GetLODLevel();
  260. UINT uRightLODLevel=pkInst->__LessRenderOrder_GetLODLevel();
  261. if (uLeftLODLevel<uRightLODLevel)
  262. return true;
  263. if (uLeftLODLevel>uRightLODLevel)
  264. return false;
  265.  
  266. if (m_awPart[CRaceData::PART_WEAPON]<pkInst->m_awPart[CRaceData::PART_WEAPON])
  267. return true;
  268.  
  269. return false;
  270. }
  271.  
  272. UINT CInstanceBase::__LessRenderOrder_GetLODLevel()
  273. {
  274. CGrannyLODController* pLODCtrl=m_GraphicThingInstance.GetLODControllerPointer(0);
  275. if (!pLODCtrl)
  276. return 0;
  277.  
  278. return pLODCtrl->GetLODLevel();
  279. }
  280.  
  281. bool CInstanceBase::__Background_GetWaterHeight(const TPixelPosition& c_rkPPos, float* pfHeight)
  282. {
  283. long lHeight;
  284. if (!CPythonBackground::Instance().GetWaterHeight(int(c_rkPPos.x), int(c_rkPPos.y), &lHeight))
  285. return false;
  286.  
  287. *pfHeight = float(lHeight);
  288.  
  289. return true;
  290. }
  291.  
  292. bool CInstanceBase::__Background_IsWaterPixelPosition(const TPixelPosition& c_rkPPos)
  293. {
  294. return CPythonBackground::Instance().isAttrOn(c_rkPPos.x, c_rkPPos.y, CTerrainImpl::ATTRIBUTE_WATER);
  295. }
  296.  
  297. const float PC_DUST_RANGE = 2000.0f;
  298. const float NPC_DUST_RANGE = 1000.0f;
  299.  
  300. DWORD CInstanceBase::ms_dwUpdateCounter=0;
  301. DWORD CInstanceBase::ms_dwRenderCounter=0;
  302. DWORD CInstanceBase::ms_dwDeformCounter=0;
  303.  
  304. CDynamicPool<CInstanceBase> CInstanceBase::ms_kPool;
  305.  
  306. bool CInstanceBase::__IsInDustRange()
  307. {
  308. if (!__IsExistMainInstance())
  309. return false;
  310.  
  311. CInstanceBase* pkInstMain=__GetMainInstancePtr();
  312.  
  313. float fDistance=NEW_GetDistanceFromDestInstance(*pkInstMain);
  314.  
  315. if (IsPC())
  316. {
  317. if (fDistance<=PC_DUST_RANGE)
  318. return true;
  319. }
  320.  
  321. if (fDistance<=NPC_DUST_RANGE)
  322. return true;
  323.  
  324. return false;
  325. }
  326.  
  327. void CInstanceBase::__EnableSkipCollision()
  328. {
  329. if (__IsMainInstance())
  330. {
  331. TraceError("CInstanceBase::__EnableSkipCollision - 자신은 충돌검사스킵이 되면 안된다!!");
  332. return;
  333. }
  334. m_GraphicThingInstance.EnableSkipCollision();
  335. }
  336.  
  337. void CInstanceBase::__DisableSkipCollision()
  338. {
  339. m_GraphicThingInstance.DisableSkipCollision();
  340. }
  341.  
  342. DWORD CInstanceBase::__GetShadowMapColor(float x, float y)
  343. {
  344. CPythonBackground& rkBG=CPythonBackground::Instance();
  345. return rkBG.GetShadowMapColor(x, y);
  346. }
  347.  
  348. float CInstanceBase::__GetBackgroundHeight(float x, float y)
  349. {
  350. CPythonBackground& rkBG=CPythonBackground::Instance();
  351. return rkBG.GetHeight(x, y);
  352. }
  353.  
  354. #ifdef __MOVIE_MODE__
  355.  
  356. BOOL CInstanceBase::IsMovieMode()
  357. {
  358. if (IsAffect(AFFECT_INVISIBILITY))
  359. return true;
  360.  
  361. return false;
  362. }
  363.  
  364. #endif
  365.  
  366. BOOL CInstanceBase::IsInvisibility()
  367. {
  368. if (IsAffect(AFFECT_INVISIBILITY))
  369. return true;
  370.  
  371. return false;
  372. }
  373.  
  374. BOOL CInstanceBase::IsParalysis()
  375. {
  376. return m_GraphicThingInstance.IsParalysis();
  377. }
  378.  
  379. BOOL CInstanceBase::IsGameMaster()
  380. {
  381. if (m_kAffectFlagContainer.IsSet(AFFECT_YMIR))
  382. return true;
  383. return false;
  384. }
  385.  
  386.  
  387. BOOL CInstanceBase::IsSameEmpire(CInstanceBase& rkInstDst)
  388. {
  389. if (0 == rkInstDst.m_dwEmpireID)
  390. return TRUE;
  391.  
  392. if (IsGameMaster())
  393. return TRUE;
  394.  
  395. if (rkInstDst.IsGameMaster())
  396. return TRUE;
  397.  
  398. if (rkInstDst.m_dwEmpireID==m_dwEmpireID)
  399. return TRUE;
  400.  
  401. return FALSE;
  402. }
  403.  
  404. DWORD CInstanceBase::GetEmpireID()
  405. {
  406. return m_dwEmpireID;
  407. }
  408.  
  409. DWORD CInstanceBase::GetGuildID()
  410. {
  411. return m_dwGuildID;
  412. }
  413.  
  414. #ifdef ENABLE_TITLE_SYSTEM
  415. int CInstanceBase::GetTitleID()
  416. {
  417. return m_iTitleID;
  418. }
  419. #endif
  420.  
  421. int CInstanceBase::GetAlignment()
  422. {
  423. return m_sAlignment;
  424. }
  425.  
  426. UINT CInstanceBase::GetAlignmentGrade()
  427. {
  428. if (m_sAlignment >= 12000)
  429. return 0;
  430. else if (m_sAlignment >= 8000)
  431. return 1;
  432. else if (m_sAlignment >= 4000)
  433. return 2;
  434. else if (m_sAlignment >= 1000)
  435. return 3;
  436. else if (m_sAlignment >= 0)
  437. return 4;
  438. else if (m_sAlignment > -4000)
  439. return 5;
  440. else if (m_sAlignment > -8000)
  441. return 6;
  442. else if (m_sAlignment > -12000)
  443. return 7;
  444.  
  445. return 8;
  446. }
  447.  
  448. int CInstanceBase::GetAlignmentType()
  449. {
  450. switch (GetAlignmentGrade())
  451. {
  452. case 0:
  453. case 1:
  454. case 2:
  455. case 3:
  456. {
  457. return ALIGNMENT_TYPE_WHITE;
  458. break;
  459. }
  460.  
  461. case 5:
  462. case 6:
  463. case 7:
  464. case 8:
  465. {
  466. return ALIGNMENT_TYPE_DARK;
  467. break;
  468. }
  469. }
  470.  
  471. return ALIGNMENT_TYPE_NORMAL;
  472. }
  473.  
  474. BYTE CInstanceBase::GetPKMode()
  475. {
  476. return m_byPKMode;
  477. }
  478.  
  479. bool CInstanceBase::IsKiller()
  480. {
  481. return m_isKiller;
  482. }
  483.  
  484. bool CInstanceBase::IsPartyMember()
  485. {
  486. return m_isPartyMember;
  487. }
  488.  
  489. BOOL CInstanceBase::IsInSafe()
  490. {
  491. const TPixelPosition& c_rkPPosCur=m_GraphicThingInstance.NEW_GetCurPixelPositionRef();
  492. if (CPythonBackground::Instance().isAttrOn(c_rkPPosCur.x, c_rkPPosCur.y, CTerrainImpl::ATTRIBUTE_BANPK))
  493. return TRUE;
  494.  
  495. return FALSE;
  496. }
  497.  
  498. float CInstanceBase::CalculateDistanceSq3d(const TPixelPosition& c_rkPPosDst)
  499. {
  500. const TPixelPosition& c_rkPPosSrc=m_GraphicThingInstance.NEW_GetCurPixelPositionRef();
  501. return SPixelPosition_CalculateDistanceSq3d(c_rkPPosSrc, c_rkPPosDst);
  502. }
  503.  
  504. void CInstanceBase::OnSelected()
  505. {
  506. #ifdef __MOVIE_MODE__
  507. if (!__IsExistMainInstance())
  508. return;
  509. #endif
  510.  
  511. if (IsStoneDoor())
  512. return;
  513.  
  514. if (IsDead())
  515. return;
  516.  
  517. __AttachSelectEffect();
  518. }
  519.  
  520. void CInstanceBase::OnUnselected()
  521. {
  522. __DetachSelectEffect();
  523. }
  524.  
  525. void CInstanceBase::OnTargeted()
  526. {
  527. #ifdef __MOVIE_MODE__
  528. if (!__IsExistMainInstance())
  529. return;
  530. #endif
  531.  
  532. if (IsStoneDoor())
  533. return;
  534.  
  535. if (IsDead())
  536. return;
  537.  
  538. __AttachTargetEffect();
  539. }
  540.  
  541. void CInstanceBase::OnUntargeted()
  542. {
  543. __DetachTargetEffect();
  544. }
  545.  
  546. void CInstanceBase::DestroySystem()
  547. {
  548. ms_kPool.Clear();
  549. }
  550.  
  551. void CInstanceBase::CreateSystem(UINT uCapacity)
  552. {
  553. ms_kPool.Create(uCapacity);
  554.  
  555. memset(ms_adwCRCAffectEffect, 0, sizeof(ms_adwCRCAffectEffect));
  556.  
  557. ms_fDustGap=250.0f;
  558. ms_fHorseDustGap=500.0f;
  559. }
  560.  
  561. CInstanceBase* CInstanceBase::New()
  562. {
  563. return ms_kPool.Alloc();
  564. }
  565.  
  566. void CInstanceBase::Delete(CInstanceBase* pkInst)
  567. {
  568. pkInst->Destroy();
  569. ms_kPool.Free(pkInst);
  570. }
  571.  
  572. void CInstanceBase::SetMainInstance()
  573. {
  574. CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
  575.  
  576. DWORD dwVID=GetVirtualID();
  577. rkChrMgr.SetMainInstance(dwVID);
  578.  
  579. m_GraphicThingInstance.SetMainInstance();
  580. }
  581.  
  582. CInstanceBase* CInstanceBase::__GetMainInstancePtr()
  583. {
  584. CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
  585. return rkChrMgr.GetMainInstancePtr();
  586. }
  587.  
  588. void CInstanceBase::__ClearMainInstance()
  589. {
  590. CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
  591. rkChrMgr.ClearMainInstance();
  592. }
  593.  
  594. /* 실제 플레이어 캐릭터인지 조사.*/
  595. bool CInstanceBase::__IsMainInstance()
  596. {
  597. if (this==__GetMainInstancePtr())
  598. return true;
  599.  
  600. return false;
  601. }
  602.  
  603. bool CInstanceBase::__IsExistMainInstance()
  604. {
  605. if(__GetMainInstancePtr())
  606. return true;
  607. else
  608. return false;
  609. }
  610.  
  611. bool CInstanceBase::__MainCanSeeHiddenThing()
  612. {
  613. return false;
  614. // CInstanceBase * pInstance = __GetMainInstancePtr();
  615. // return pInstance->IsAffect(AFFECT_GAMJI);
  616. }
  617.  
  618. float CInstanceBase::__GetBowRange()
  619. {
  620. float fRange = 2500.0f - 100.0f;
  621.  
  622. if (__IsMainInstance())
  623. {
  624. IAbstractPlayer& rPlayer=IAbstractPlayer::GetSingleton();
  625. fRange += float(rPlayer.GetStatus(POINT_BOW_DISTANCE));
  626. }
  627.  
  628. return fRange;
  629. }
  630.  
  631. CInstanceBase* CInstanceBase::__FindInstancePtr(DWORD dwVID)
  632. {
  633. CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
  634. return rkChrMgr.GetInstancePtr(dwVID);
  635. }
  636.  
  637. bool CInstanceBase::__FindRaceType(DWORD dwRace, BYTE* pbType)
  638. {
  639. CPythonNonPlayer& rkNonPlayer=CPythonNonPlayer::Instance();
  640. return rkNonPlayer.GetInstanceType(dwRace, pbType);
  641. }
  642.  
  643. bool CInstanceBase::Create(const SCreateData& c_rkCreateData)
  644. {
  645. IAbstractApplication::GetSingleton().SkipRenderBuffering(300);
  646.  
  647. SetInstanceType(c_rkCreateData.m_bType);
  648.  
  649.  
  650. if (!SetRace(c_rkCreateData.m_dwRace))
  651. return false;
  652.  
  653. if(c_rkCreateData.m_dwRace == 34041 || c_rkCreateData.m_dwRace == 34045 || c_rkCreateData.m_dwRace == 34049 || c_rkCreateData.m_dwRace == 34053)
  654. {
  655. if(c_rkCreateData.m_dwLevel >= 81)
  656. SetRace(c_rkCreateData.m_dwRace+1);
  657. }
  658.  
  659. SetVirtualID(c_rkCreateData.m_dwVID);
  660.  
  661. if (c_rkCreateData.m_isMain)
  662. SetMainInstance();
  663.  
  664. if (IsGuildWall())
  665. {
  666. unsigned center_x;
  667. unsigned center_y;
  668.  
  669. c_rkCreateData.m_kAffectFlags.ConvertToPosition(&center_x, &center_y);
  670.  
  671. float center_z = __GetBackgroundHeight(center_x, center_y);
  672. NEW_SetPixelPosition(TPixelPosition(float(c_rkCreateData.m_lPosX), float(c_rkCreateData.m_lPosY), center_z));
  673. }
  674. else
  675. {
  676. SCRIPT_SetPixelPosition(float(c_rkCreateData.m_lPosX), float(c_rkCreateData.m_lPosY));
  677. }
  678.  
  679. if (0 != c_rkCreateData.m_dwMountVnum)
  680. MountHorse(c_rkCreateData.m_dwMountVnum);
  681.  
  682. SetArmor(c_rkCreateData.m_dwArmor);
  683.  
  684. if (IsPC())
  685. {
  686. SetHair(c_rkCreateData.m_dwHair);
  687. SetSash(c_rkCreateData.m_dwSash);
  688. SetWeapon(c_rkCreateData.m_dwWeapon);
  689. }
  690.  
  691. __Create_SetName(c_rkCreateData);
  692.  
  693. m_dwLevel = c_rkCreateData.m_dwLevel;
  694. m_dwGuildID = c_rkCreateData.m_dwGuildID;
  695. m_dwEmpireID = c_rkCreateData.m_dwEmpireID;
  696.  
  697. SetVirtualNumber(c_rkCreateData.m_dwRace);
  698. SetRotation(c_rkCreateData.m_fRot);
  699.  
  700. SetAlignment(c_rkCreateData.m_sAlignment);
  701. SetsTitle(c_rkCreateData.m_iTitleID);
  702. SetLevelText(c_rkCreateData.m_dwLevel);
  703. SetPKMode(c_rkCreateData.m_byPKMode);
  704.  
  705. SetMoveSpeed(c_rkCreateData.m_dwMovSpd);
  706. SetAttackSpeed(c_rkCreateData.m_dwAtkSpd);
  707.  
  708. if(m_dwRace == 34041 ||m_dwRace == 34045 || m_dwRace == 34049 ||m_dwRace == 34053)
  709. {
  710. float scale = c_rkCreateData.m_dwLevel * 0.005f + 0.75f;
  711. m_GraphicThingInstance.SetScale(scale, scale, scale);
  712. }
  713. else
  714. m_GraphicThingInstance.SetScale(1.0f,1.0f,1.0f);
  715.  
  716. // NOTE : Dress 를 입고 있으면 Alpha 를 넣지 않는다.
  717. if (!IsWearingDress())
  718. {
  719. // NOTE : 반드시 Affect 셋팅 윗쪽에 있어야 함
  720. m_GraphicThingInstance.SetAlphaValue(0.0f);
  721. m_GraphicThingInstance.BlendAlphaValue(1.0f, 0.5f);
  722. }
  723.  
  724. if (!IsGuildWall())
  725. {
  726. SetAffectFlagContainer(c_rkCreateData.m_kAffectFlags);
  727. }
  728.  
  729. // NOTE : 반드시 Affect 셋팅 후에 해야 함
  730. AttachTextTail();
  731. RefreshTextTail();
  732.  
  733. if (c_rkCreateData.m_dwStateFlags & ADD_CHARACTER_STATE_SPAWN)
  734. {
  735. if (IsAffect(AFFECT_SPAWN))
  736. __AttachEffect(EFFECT_SPAWN_APPEAR);
  737.  
  738. if (IsPC())
  739. {
  740. Refresh(CRaceMotionData::NAME_WAIT, true);
  741. }
  742. else
  743. {
  744. Refresh(CRaceMotionData::NAME_SPAWN, false);
  745. }
  746. }
  747. else
  748. {
  749. Refresh(CRaceMotionData::NAME_WAIT, true);
  750. }
  751.  
  752. __AttachEmpireEffect(c_rkCreateData.m_dwEmpireID);
  753.  
  754. RegisterBoundingSphere();
  755.  
  756. if (c_rkCreateData.m_dwStateFlags & ADD_CHARACTER_STATE_DEAD)
  757. m_GraphicThingInstance.DieEnd();
  758.  
  759. SetStateFlags(c_rkCreateData.m_dwStateFlags);
  760.  
  761. m_GraphicThingInstance.SetBattleHitEffect(ms_adwCRCAffectEffect[EFFECT_HIT]);
  762.  
  763. if (!IsPC())
  764. {
  765. DWORD dwBodyColor = CPythonNonPlayer::Instance().GetMonsterColor(c_rkCreateData.m_dwRace);
  766. if (0 != dwBodyColor)
  767. {
  768. SetModulateRenderMode();
  769. SetAddColor(dwBodyColor);
  770. }
  771. }
  772.  
  773. __AttachHorseSaddle();
  774.  
  775. // 길드 심볼을 위한 임시 코드, 적정 위치를 찾는 중
  776. const int c_iGuildSymbolRace = 14200;
  777. if (c_iGuildSymbolRace == GetRace())
  778. {
  779. std::string strFileName = GetGuildSymbolFileName(m_dwGuildID);
  780. if (IsFile(strFileName.c_str()))
  781. m_GraphicThingInstance.ChangeMaterial(strFileName.c_str());
  782. }
  783.  
  784. return true;
  785. }
  786.  
  787.  
  788. void CInstanceBase::__Create_SetName(const SCreateData& c_rkCreateData)
  789. {
  790. if (IsGoto())
  791. {
  792. SetNameString("", 0);
  793. return;
  794. }
  795. if (IsWarp())
  796. {
  797. __Create_SetWarpName(c_rkCreateData);
  798. return;
  799. }
  800.  
  801. SetNameString(c_rkCreateData.m_stName.c_str(), c_rkCreateData.m_stName.length());
  802. }
  803.  
  804. void CInstanceBase::__Create_SetWarpName(const SCreateData& c_rkCreateData)
  805. {
  806. const char * c_szName;
  807. if (CPythonNonPlayer::Instance().GetName(c_rkCreateData.m_dwRace, &c_szName))
  808. {
  809. std::string strName = c_szName;
  810. int iFindingPos = strName.find_first_of(" ", 0);
  811. if (iFindingPos > 0)
  812. {
  813. strName.resize(iFindingPos);
  814. }
  815. SetNameString(strName.c_str(), strName.length());
  816. }
  817. else
  818. {
  819. SetNameString(c_rkCreateData.m_stName.c_str(), c_rkCreateData.m_stName.length());
  820. }
  821. }
  822.  
  823. void CInstanceBase::SetNameString(const char* c_szName, int len)
  824. {
  825. m_stName.assign(c_szName, len);
  826. }
  827.  
  828.  
  829. bool CInstanceBase::SetRace(DWORD eRace)
  830. {
  831. m_dwRace = eRace;
  832.  
  833. if (!m_GraphicThingInstance.SetRace(eRace))
  834. return false;
  835.  
  836. if (!__FindRaceType(m_dwRace, &m_eRaceType))
  837. m_eRaceType=CActorInstance::TYPE_PC;
  838.  
  839. return true;
  840. }
  841.  
  842. BOOL CInstanceBase::__IsChangableWeapon(int iWeaponID)
  843. {
  844. // 드레스 입고 있을때는 부케외의 장비는 나오지 않게..
  845. if (IsWearingDress())
  846. {
  847. const int c_iBouquets[] =
  848. {
  849. 50201, // Bouquet for Assassin
  850. 50202, // Bouquet for Shaman
  851. 50203,
  852. 50204,
  853. 0, // #0000545: [M2CN] 웨딩 드레스와 장비 착용 문제
  854. };
  855.  
  856. for (int i = 0; c_iBouquets[i] != 0; ++i)
  857. if (iWeaponID == c_iBouquets[i])
  858. return true;
  859.  
  860. return false;
  861. }
  862. else
  863. return true;
  864. }
  865.  
  866. BOOL CInstanceBase::IsWearingDress()
  867. {
  868. const int c_iWeddingDressShape = 201;
  869. return c_iWeddingDressShape == m_eShape;
  870. }
  871.  
  872. BOOL CInstanceBase::IsHoldingPickAxe()
  873. {
  874. const int c_iPickAxeStart = 29101;
  875. const int c_iPickAxeEnd = 29110;
  876. return m_awPart[CRaceData::PART_WEAPON] >= c_iPickAxeStart && m_awPart[CRaceData::PART_WEAPON] <= c_iPickAxeEnd;
  877. }
  878.  
  879. BOOL CInstanceBase::IsNewMount()
  880. {
  881. return m_kHorse.IsNewMount();
  882. }
  883.  
  884. BOOL CInstanceBase::IsMountingHorse()
  885. {
  886. return m_kHorse.IsMounting();
  887. }
  888.  
  889. void CInstanceBase::MountHorse(UINT eRace)
  890. {
  891. m_kHorse.Destroy();
  892. m_kHorse.Create(m_GraphicThingInstance.NEW_GetCurPixelPositionRef(), eRace, ms_adwCRCAffectEffect[EFFECT_HIT]);
  893.  
  894. SetMotionMode(CRaceMotionData::MODE_HORSE);
  895. SetRotationSpeed(c_fDefaultHorseRotationSpeed);
  896.  
  897. m_GraphicThingInstance.MountHorse(m_kHorse.GetActorPtr());
  898. m_GraphicThingInstance.Stop();
  899. m_GraphicThingInstance.RefreshActorInstance();
  900. }
  901.  
  902. void CInstanceBase::DismountHorse()
  903. {
  904. m_kHorse.Destroy();
  905. }
  906.  
  907. void CInstanceBase::GetInfo(std::string* pstInfo)
  908. {
  909. char szInfo[256];
  910. sprintf(szInfo, "Inst - UC %d, RC %d Pool - %d ",
  911. ms_dwUpdateCounter,
  912. ms_dwRenderCounter,
  913. ms_kPool.GetCapacity()
  914. );
  915.  
  916. pstInfo->append(szInfo);
  917. }
  918.  
  919. void CInstanceBase::ResetPerformanceCounter()
  920. {
  921. ms_dwUpdateCounter=0;
  922. ms_dwRenderCounter=0;
  923. ms_dwDeformCounter=0;
  924. }
  925.  
  926. bool CInstanceBase::NEW_IsLastPixelPosition()
  927. {
  928. return m_GraphicThingInstance.IsPushing();
  929. }
  930.  
  931. const TPixelPosition& CInstanceBase::NEW_GetLastPixelPositionRef()
  932. {
  933. return m_GraphicThingInstance.NEW_GetLastPixelPositionRef();
  934. }
  935.  
  936. void CInstanceBase::NEW_SetDstPixelPositionZ(FLOAT z)
  937. {
  938. m_GraphicThingInstance.NEW_SetDstPixelPositionZ(z);
  939. }
  940.  
  941. void CInstanceBase::NEW_SetDstPixelPosition(const TPixelPosition& c_rkPPosDst)
  942. {
  943. m_GraphicThingInstance.NEW_SetDstPixelPosition(c_rkPPosDst);
  944. }
  945.  
  946. void CInstanceBase::NEW_SetSrcPixelPosition(const TPixelPosition& c_rkPPosSrc)
  947. {
  948. m_GraphicThingInstance.NEW_SetSrcPixelPosition(c_rkPPosSrc);
  949. }
  950.  
  951. const TPixelPosition& CInstanceBase::NEW_GetCurPixelPositionRef()
  952. {
  953. return m_GraphicThingInstance.NEW_GetCurPixelPositionRef();
  954. }
  955.  
  956. const TPixelPosition& CInstanceBase::NEW_GetDstPixelPositionRef()
  957. {
  958. return m_GraphicThingInstance.NEW_GetDstPixelPositionRef();
  959. }
  960.  
  961. const TPixelPosition& CInstanceBase::NEW_GetSrcPixelPositionRef()
  962. {
  963. return m_GraphicThingInstance.NEW_GetSrcPixelPositionRef();
  964. }
  965.  
  966. /////////////////////////////////////////////////////////////////////////////////////////////////
  967. void CInstanceBase::OnSyncing()
  968. {
  969. m_GraphicThingInstance.__OnSyncing();
  970. }
  971.  
  972. void CInstanceBase::OnWaiting()
  973. {
  974. m_GraphicThingInstance.__OnWaiting();
  975. }
  976.  
  977. void CInstanceBase::OnMoving()
  978. {
  979. m_GraphicThingInstance.__OnMoving();
  980. }
  981.  
  982. void CInstanceBase::ChangeGuild(DWORD dwGuildID)
  983. {
  984. m_dwGuildID=dwGuildID;
  985.  
  986. DetachTextTail();
  987. AttachTextTail();
  988. RefreshTextTail();
  989. }
  990.  
  991. DWORD CInstanceBase::GetPart(CRaceData::EParts part)
  992. {
  993. assert(part >= 0 && part < CRaceData::PART_MAX_NUM);
  994. return m_awPart[part];
  995. }
  996.  
  997. DWORD CInstanceBase::GetShape()
  998. {
  999. return m_eShape;
  1000. }
  1001.  
  1002. bool CInstanceBase::CanAct()
  1003. {
  1004. return m_GraphicThingInstance.CanAct();
  1005. }
  1006.  
  1007. bool CInstanceBase::CanMove()
  1008. {
  1009. return m_GraphicThingInstance.CanMove();
  1010. }
  1011.  
  1012. bool CInstanceBase::CanUseSkill()
  1013. {
  1014. if (IsPoly())
  1015. return false;
  1016.  
  1017. if (IsWearingDress())
  1018. return false;
  1019.  
  1020. if (IsHoldingPickAxe())
  1021. return false;
  1022.  
  1023. if (!m_kHorse.CanUseSkill())
  1024. return false;
  1025.  
  1026. if (!m_GraphicThingInstance.CanUseSkill())
  1027. return false;
  1028.  
  1029. return true;
  1030. }
  1031.  
  1032. bool CInstanceBase::CanAttack()
  1033. {
  1034. if (!m_kHorse.CanAttack())
  1035. return false;
  1036.  
  1037. if (IsWearingDress())
  1038. return false;
  1039.  
  1040. if (IsHoldingPickAxe())
  1041. return false;
  1042.  
  1043. return m_GraphicThingInstance.CanAttack();
  1044. }
  1045.  
  1046.  
  1047.  
  1048. bool CInstanceBase::CanFishing()
  1049. {
  1050. return m_GraphicThingInstance.CanFishing();
  1051. }
  1052.  
  1053.  
  1054. BOOL CInstanceBase::IsBowMode()
  1055. {
  1056. return m_GraphicThingInstance.IsBowMode();
  1057. }
  1058.  
  1059. BOOL CInstanceBase::IsHandMode()
  1060. {
  1061. return m_GraphicThingInstance.IsHandMode();
  1062. }
  1063.  
  1064. BOOL CInstanceBase::IsFishingMode()
  1065. {
  1066. if (CRaceMotionData::MODE_FISHING == m_GraphicThingInstance.GetMotionMode())
  1067. return true;
  1068.  
  1069. return false;
  1070. }
  1071.  
  1072. BOOL CInstanceBase::IsFishing()
  1073. {
  1074. return m_GraphicThingInstance.IsFishing();
  1075. }
  1076.  
  1077. BOOL CInstanceBase::IsDead()
  1078. {
  1079. return m_GraphicThingInstance.IsDead();
  1080. }
  1081.  
  1082. BOOL CInstanceBase::IsStun()
  1083. {
  1084. return m_GraphicThingInstance.IsStun();
  1085. }
  1086.  
  1087. BOOL CInstanceBase::IsSleep()
  1088. {
  1089. return m_GraphicThingInstance.IsSleep();
  1090. }
  1091.  
  1092.  
  1093. BOOL CInstanceBase::__IsSyncing()
  1094. {
  1095. return m_GraphicThingInstance.__IsSyncing();
  1096. }
  1097.  
  1098.  
  1099.  
  1100. void CInstanceBase::NEW_SetOwner(DWORD dwVIDOwner)
  1101. {
  1102. m_GraphicThingInstance.SetOwner(dwVIDOwner);
  1103. }
  1104.  
  1105. float CInstanceBase::GetLocalTime()
  1106. {
  1107. return m_GraphicThingInstance.GetLocalTime();
  1108. }
  1109.  
  1110.  
  1111. void CInstanceBase::PushUDPState(DWORD dwCmdTime, const TPixelPosition& c_rkPPosDst, float fDstRot, UINT eFunc, UINT uArg)
  1112. {
  1113. }
  1114.  
  1115. DWORD ELTimer_GetServerFrameMSec();
  1116.  
  1117. void CInstanceBase::PushTCPStateExpanded(DWORD dwCmdTime, const TPixelPosition& c_rkPPosDst, float fDstRot, UINT eFunc, UINT uArg, UINT uTargetVID)
  1118. {
  1119. SCommand kCmdNew;
  1120. kCmdNew.m_kPPosDst = c_rkPPosDst;
  1121. kCmdNew.m_dwChkTime = dwCmdTime+100;
  1122. kCmdNew.m_dwCmdTime = dwCmdTime;
  1123. kCmdNew.m_fDstRot = fDstRot;
  1124. kCmdNew.m_eFunc = eFunc;
  1125. kCmdNew.m_uArg = uArg;
  1126. kCmdNew.m_uTargetVID = uTargetVID;
  1127. m_kQue_kCmdNew.push_back(kCmdNew);
  1128. }
  1129.  
  1130. void CInstanceBase::PushTCPState(DWORD dwCmdTime, const TPixelPosition& c_rkPPosDst, float fDstRot, UINT eFunc, UINT uArg)
  1131. {
  1132. if (__IsMainInstance())
  1133. {
  1134. //assert(!"CInstanceBase::PushTCPState 플레이어 자신에게 이동패킷은 오면 안된다!");
  1135. TraceError("CInstanceBase::PushTCPState 플레이어 자신에게 이동패킷은 오면 안된다!");
  1136. return;
  1137. }
  1138.  
  1139. int nNetworkGap=ELTimer_GetServerFrameMSec()-dwCmdTime;
  1140.  
  1141. m_nAverageNetworkGap=(m_nAverageNetworkGap*70+nNetworkGap*30)/100;
  1142.  
  1143. /*
  1144. if (m_dwBaseCmdTime == 0)
  1145. {
  1146. m_dwBaseChkTime = ELTimer_GetFrameMSec()-nNetworkGap;
  1147. m_dwBaseCmdTime = dwCmdTime;
  1148.  
  1149. Tracenf("VID[%d] 네트웍갭 [%d]", GetVirtualID(), nNetworkGap);
  1150. }
  1151. */
  1152.  
  1153. //m_dwBaseChkTime-m_dwBaseCmdTime+ELTimer_GetServerMSec();
  1154.  
  1155. SCommand kCmdNew;
  1156. kCmdNew.m_kPPosDst = c_rkPPosDst;
  1157. kCmdNew.m_dwChkTime = dwCmdTime+m_nAverageNetworkGap;//m_dwBaseChkTime + (dwCmdTime - m_dwBaseCmdTime);// + nNetworkGap;
  1158. kCmdNew.m_dwCmdTime = dwCmdTime;
  1159. kCmdNew.m_fDstRot = fDstRot;
  1160. kCmdNew.m_eFunc = eFunc;
  1161. kCmdNew.m_uArg = uArg;
  1162. m_kQue_kCmdNew.push_back(kCmdNew);
  1163.  
  1164. //int nApplyGap=kCmdNew.m_dwChkTime-ELTimer_GetServerFrameMSec();
  1165.  
  1166. //if (nApplyGap<-500 || nApplyGap>500)
  1167. // Tracenf("VID[%d] NAME[%s] 네트웍갭 [cur:%d ave:%d] 작동시간 (%d)", GetVirtualID(), GetNameString(), nNetworkGap, m_nAverageNetworkGap, nApplyGap);
  1168. }
  1169.  
  1170. /*
  1171. CInstanceBase::TStateQueue::iterator CInstanceBase::FindSameState(TStateQueue& rkQuekStt, DWORD dwCmdTime, UINT eFunc, UINT uArg)
  1172. {
  1173. TStateQueue::iterator i=rkQuekStt.begin();
  1174. while (rkQuekStt.end()!=i)
  1175. {
  1176. SState& rkSttEach=*i;
  1177. if (rkSttEach.m_dwCmdTime==dwCmdTime)
  1178. if (rkSttEach.m_eFunc==eFunc)
  1179. if (rkSttEach.m_uArg==uArg)
  1180. break;
  1181. ++i;
  1182. }
  1183.  
  1184. return i;
  1185. }
  1186. */
  1187.  
  1188. BOOL CInstanceBase::__CanProcessNetworkStatePacket()
  1189. {
  1190. if (m_GraphicThingInstance.IsDead())
  1191. return FALSE;
  1192. if (m_GraphicThingInstance.IsKnockDown())
  1193. return FALSE;
  1194. if (m_GraphicThingInstance.IsUsingSkill())
  1195. if (!m_GraphicThingInstance.CanCancelSkill())
  1196. return FALSE;
  1197.  
  1198. return TRUE;
  1199. }
  1200.  
  1201. BOOL CInstanceBase::__IsEnableTCPProcess(UINT eCurFunc)
  1202. {
  1203. if (m_GraphicThingInstance.IsActEmotion())
  1204. {
  1205. return FALSE;
  1206. }
  1207.  
  1208. if (!m_bEnableTCPState)
  1209. {
  1210. if (FUNC_EMOTION != eCurFunc)
  1211. {
  1212. return FALSE;
  1213. }
  1214. }
  1215.  
  1216. return TRUE;
  1217. }
  1218.  
  1219. void CInstanceBase::StateProcess()
  1220. {
  1221. while (1)
  1222. {
  1223. if (m_kQue_kCmdNew.empty())
  1224. return;
  1225.  
  1226. DWORD dwDstChkTime = m_kQue_kCmdNew.front().m_dwChkTime;
  1227. DWORD dwCurChkTime = ELTimer_GetServerFrameMSec();
  1228.  
  1229. if (dwCurChkTime < dwDstChkTime)
  1230. return;
  1231.  
  1232. SCommand kCmdTop = m_kQue_kCmdNew.front();
  1233. m_kQue_kCmdNew.pop_front();
  1234.  
  1235. TPixelPosition kPPosDst = kCmdTop.m_kPPosDst;
  1236. //DWORD dwCmdTime = kCmdTop.m_dwCmdTime;
  1237. FLOAT fRotDst = kCmdTop.m_fDstRot;
  1238. UINT eFunc = kCmdTop.m_eFunc;
  1239. UINT uArg = kCmdTop.m_uArg;
  1240. UINT uVID = GetVirtualID();
  1241. UINT uTargetVID = kCmdTop.m_uTargetVID;
  1242.  
  1243. TPixelPosition kPPosCur;
  1244. NEW_GetPixelPosition(&kPPosCur);
  1245.  
  1246. /*
  1247. if (IsPC())
  1248. Tracenf("%d cmd: vid=%d[%s] func=%d arg=%d curPos=(%f, %f) dstPos=(%f, %f) rot=%f (time %d)",
  1249. ELTimer_GetMSec(),
  1250. uVID, m_stName.c_str(), eFunc, uArg,
  1251. kPPosCur.x, kPPosCur.y,
  1252. kPPosDst.x, kPPosDst.y, fRotDst, dwCmdTime-m_dwBaseCmdTime);
  1253. */
  1254.  
  1255. TPixelPosition kPPosDir = kPPosDst - kPPosCur;
  1256. float fDirLen = (float)sqrt(kPPosDir.x * kPPosDir.x + kPPosDir.y * kPPosDir.y);
  1257.  
  1258. //Tracenf("거리 %f", fDirLen);
  1259.  
  1260. if (!__CanProcessNetworkStatePacket())
  1261. {
  1262. Lognf(0, "vid=%d 움직일 수 없는 상태라 스킵 IsDead=%d, IsKnockDown=%d", uVID, m_GraphicThingInstance.IsDead(), m_GraphicThingInstance.IsKnockDown());
  1263. return;
  1264. }
  1265.  
  1266. if (!__IsEnableTCPProcess(eFunc))
  1267. {
  1268. return;
  1269. }
  1270.  
  1271. switch (eFunc)
  1272. {
  1273. case FUNC_WAIT:
  1274. {
  1275. //Tracenf("%s (%f, %f) -> (%f, %f) 남은거리 %f", GetNameString(), kPPosCur.x, kPPosCur.y, kPPosDst.x, kPPosDst.y, fDirLen);
  1276. if (fDirLen > 1.0f)
  1277. {
  1278. //NEW_GetSrcPixelPositionRef() = kPPosCur;
  1279. //NEW_GetDstPixelPositionRef() = kPPosDst;
  1280. NEW_SetSrcPixelPosition(kPPosCur);
  1281. NEW_SetDstPixelPosition(kPPosDst);
  1282.  
  1283. __EnableSkipCollision();
  1284.  
  1285. m_fDstRot = fRotDst;
  1286. m_isGoing = TRUE;
  1287.  
  1288. m_kMovAfterFunc.eFunc = FUNC_WAIT;
  1289.  
  1290. if (!IsWalking())
  1291. StartWalking();
  1292.  
  1293. //Tracen("목표정지");
  1294. }
  1295. else
  1296. {
  1297. //Tracen("현재 정지");
  1298.  
  1299. m_isGoing = FALSE;
  1300.  
  1301. if (!IsWaiting())
  1302. EndWalking();
  1303.  
  1304. SCRIPT_SetPixelPosition(kPPosDst.x, kPPosDst.y);
  1305. SetAdvancingRotation(fRotDst);
  1306. SetRotation(fRotDst);
  1307. }
  1308. break;
  1309. }
  1310.  
  1311. case FUNC_MOVE:
  1312. {
  1313. //NEW_GetSrcPixelPositionRef() = kPPosCur;
  1314. //NEW_GetDstPixelPositionRef() = kPPosDst;
  1315. NEW_SetSrcPixelPosition(kPPosCur);
  1316. NEW_SetDstPixelPosition(kPPosDst);
  1317. m_fDstRot = fRotDst;
  1318. m_isGoing = TRUE;
  1319. __EnableSkipCollision();
  1320. //m_isSyncMov = TRUE;
  1321.  
  1322. m_kMovAfterFunc.eFunc = FUNC_MOVE;
  1323.  
  1324. if (!IsWalking())
  1325. {
  1326. //Tracen("걷고 있지 않아 걷기 시작");
  1327. StartWalking();
  1328. }
  1329. else
  1330. {
  1331. //Tracen("이미 걷는중 ");
  1332. }
  1333. break;
  1334. }
  1335.  
  1336. case FUNC_COMBO:
  1337. {
  1338. if (fDirLen >= 50.0f)
  1339. {
  1340. NEW_SetSrcPixelPosition(kPPosCur);
  1341. NEW_SetDstPixelPosition(kPPosDst);
  1342. m_fDstRot=fRotDst;
  1343. m_isGoing = TRUE;
  1344. __EnableSkipCollision();
  1345.  
  1346. m_kMovAfterFunc.eFunc = FUNC_COMBO;
  1347. m_kMovAfterFunc.uArg = uArg;
  1348.  
  1349. if (!IsWalking())
  1350. StartWalking();
  1351. }
  1352. else
  1353. {
  1354. //Tracen("대기 공격 정지");
  1355.  
  1356. m_isGoing = FALSE;
  1357.  
  1358. if (IsWalking())
  1359. EndWalking();
  1360.  
  1361. SCRIPT_SetPixelPosition(kPPosDst.x, kPPosDst.y);
  1362. RunComboAttack(fRotDst, uArg);
  1363. }
  1364. break;
  1365. }
  1366.  
  1367. case FUNC_ATTACK:
  1368. {
  1369. if (fDirLen>=50.0f)
  1370. {
  1371. //NEW_GetSrcPixelPositionRef() = kPPosCur;
  1372. //NEW_GetDstPixelPositionRef() = kPPosDst;
  1373. NEW_SetSrcPixelPosition(kPPosCur);
  1374. NEW_SetDstPixelPosition(kPPosDst);
  1375. m_fDstRot = fRotDst;
  1376. m_isGoing = TRUE;
  1377. __EnableSkipCollision();
  1378. //m_isSyncMov = TRUE;
  1379.  
  1380. m_kMovAfterFunc.eFunc = FUNC_ATTACK;
  1381.  
  1382. if (!IsWalking())
  1383. StartWalking();
  1384.  
  1385. //Tracen("너무 멀어서 이동 후 공격");
  1386. }
  1387. else
  1388. {
  1389. //Tracen("노말 공격 정지");
  1390.  
  1391. m_isGoing = FALSE;
  1392.  
  1393. if (IsWalking())
  1394. EndWalking();
  1395.  
  1396. SCRIPT_SetPixelPosition(kPPosDst.x, kPPosDst.y);
  1397. BlendRotation(fRotDst);
  1398.  
  1399. RunNormalAttack(fRotDst);
  1400.  
  1401. //Tracen("가깝기 때문에 워프 공격");
  1402. }
  1403. break;
  1404. }
  1405.  
  1406. case FUNC_MOB_SKILL:
  1407. {
  1408. if (fDirLen >= 50.0f)
  1409. {
  1410. NEW_SetSrcPixelPosition(kPPosCur);
  1411. NEW_SetDstPixelPosition(kPPosDst);
  1412. m_fDstRot = fRotDst;
  1413. m_isGoing = TRUE;
  1414. __EnableSkipCollision();
  1415.  
  1416. m_kMovAfterFunc.eFunc = FUNC_MOB_SKILL;
  1417. m_kMovAfterFunc.uArg = uArg;
  1418.  
  1419. if (!IsWalking())
  1420. StartWalking();
  1421. }
  1422. else
  1423. {
  1424. m_isGoing = FALSE;
  1425.  
  1426. if (IsWalking())
  1427. EndWalking();
  1428.  
  1429. SCRIPT_SetPixelPosition(kPPosDst.x, kPPosDst.y);
  1430. BlendRotation(fRotDst);
  1431.  
  1432. m_GraphicThingInstance.InterceptOnceMotion(CRaceMotionData::NAME_SPECIAL_1 + uArg);
  1433. }
  1434. break;
  1435. }
  1436.  
  1437. case FUNC_EMOTION:
  1438. {
  1439. if (fDirLen>100.0f)
  1440. {
  1441. NEW_SetSrcPixelPosition(kPPosCur);
  1442. NEW_SetDstPixelPosition(kPPosDst);
  1443. m_fDstRot = fRotDst;
  1444. m_isGoing = TRUE;
  1445.  
  1446. if (__IsMainInstance())
  1447. __EnableSkipCollision();
  1448.  
  1449. m_kMovAfterFunc.eFunc = FUNC_EMOTION;
  1450. m_kMovAfterFunc.uArg = uArg;
  1451. m_kMovAfterFunc.uArgExpanded = uTargetVID;
  1452. m_kMovAfterFunc.kPosDst = kPPosDst;
  1453.  
  1454. if (!IsWalking())
  1455. StartWalking();
  1456. }
  1457. else
  1458. {
  1459. __ProcessFunctionEmotion(uArg, uTargetVID, kPPosDst);
  1460. }
  1461. break;
  1462. }
  1463.  
  1464. default:
  1465. {
  1466. if (eFunc & FUNC_SKILL)
  1467. {
  1468. if (fDirLen >= 50.0f)
  1469. {
  1470. //NEW_GetSrcPixelPositionRef() = kPPosCur;
  1471. //NEW_GetDstPixelPositionRef() = kPPosDst;
  1472. NEW_SetSrcPixelPosition(kPPosCur);
  1473. NEW_SetDstPixelPosition(kPPosDst);
  1474. m_fDstRot = fRotDst;
  1475. m_isGoing = TRUE;
  1476. //m_isSyncMov = TRUE;
  1477. __EnableSkipCollision();
  1478.  
  1479. m_kMovAfterFunc.eFunc = eFunc;
  1480. m_kMovAfterFunc.uArg = uArg;
  1481.  
  1482. if (!IsWalking())
  1483. StartWalking();
  1484.  
  1485. //Tracen("너무 멀어서 이동 후 공격");
  1486. }
  1487. else
  1488. {
  1489. //Tracen("스킬 정지");
  1490.  
  1491. m_isGoing = FALSE;
  1492.  
  1493. if (IsWalking())
  1494. EndWalking();
  1495.  
  1496. SCRIPT_SetPixelPosition(kPPosDst.x, kPPosDst.y);
  1497. SetAdvancingRotation(fRotDst);
  1498. SetRotation(fRotDst);
  1499.  
  1500. NEW_UseSkill(0, eFunc & 0x7f, uArg&0x0f, (uArg>>4) ? true : false);
  1501. //Tracen("가깝기 때문에 워프 공격");
  1502. }
  1503. }
  1504. break;
  1505. }
  1506. }
  1507. }
  1508. }
  1509.  
  1510.  
  1511. void CInstanceBase::MovementProcess()
  1512. {
  1513. TPixelPosition kPPosCur;
  1514. NEW_GetPixelPosition(&kPPosCur);
  1515.  
  1516. // 렌더링 좌표계이므로 y를 -화해서 더한다.
  1517.  
  1518. TPixelPosition kPPosNext;
  1519. {
  1520. const D3DXVECTOR3 & c_rkV3Mov = m_GraphicThingInstance.GetMovementVectorRef();
  1521.  
  1522. kPPosNext.x = kPPosCur.x + (+c_rkV3Mov.x);
  1523. kPPosNext.y = kPPosCur.y + (-c_rkV3Mov.y);
  1524. kPPosNext.z = kPPosCur.z + (+c_rkV3Mov.z);
  1525. }
  1526.  
  1527. TPixelPosition kPPosDeltaSC = kPPosCur - NEW_GetSrcPixelPositionRef();
  1528. TPixelPosition kPPosDeltaSN = kPPosNext - NEW_GetSrcPixelPositionRef();
  1529. TPixelPosition kPPosDeltaSD = NEW_GetDstPixelPositionRef() - NEW_GetSrcPixelPositionRef();
  1530.  
  1531. float fCurLen = sqrtf(kPPosDeltaSC.x * kPPosDeltaSC.x + kPPosDeltaSC.y * kPPosDeltaSC.y);
  1532. float fNextLen = sqrtf(kPPosDeltaSN.x * kPPosDeltaSN.x + kPPosDeltaSN.y * kPPosDeltaSN.y);
  1533. float fTotalLen = sqrtf(kPPosDeltaSD.x * kPPosDeltaSD.x + kPPosDeltaSD.y * kPPosDeltaSD.y);
  1534. float fRestLen = fTotalLen - fCurLen;
  1535.  
  1536. if (__IsMainInstance())
  1537. {
  1538. if (m_isGoing && IsWalking())
  1539. {
  1540. float fDstRot = NEW_GetAdvancingRotationFromPixelPosition(NEW_GetSrcPixelPositionRef(), NEW_GetDstPixelPositionRef());
  1541.  
  1542. SetAdvancingRotation(fDstRot);
  1543.  
  1544. if (fRestLen<=0.0)
  1545. {
  1546. if (IsWalking())
  1547. EndWalking();
  1548.  
  1549. //Tracen("목표 도달 정지");
  1550.  
  1551. m_isGoing = FALSE;
  1552.  
  1553. BlockMovement();
  1554.  
  1555. if (FUNC_EMOTION == m_kMovAfterFunc.eFunc)
  1556. {
  1557. DWORD dwMotionNumber = m_kMovAfterFunc.uArg;
  1558. DWORD dwTargetVID = m_kMovAfterFunc.uArgExpanded;
  1559. __ProcessFunctionEmotion(dwMotionNumber, dwTargetVID, m_kMovAfterFunc.kPosDst);
  1560. m_kMovAfterFunc.eFunc = FUNC_WAIT;
  1561. return;
  1562. }
  1563. }
  1564. }
  1565. }
  1566. else
  1567. {
  1568. if (m_isGoing && IsWalking())
  1569. {
  1570. float fDstRot = NEW_GetAdvancingRotationFromPixelPosition(NEW_GetSrcPixelPositionRef(), NEW_GetDstPixelPositionRef());
  1571.  
  1572. SetAdvancingRotation(fDstRot);
  1573.  
  1574. // 만약 렌턴시가 늦어 너무 많이 이동했다면..
  1575. if (fRestLen < -100.0f)
  1576. {
  1577. NEW_SetSrcPixelPosition(kPPosCur);
  1578.  
  1579. float fDstRot = NEW_GetAdvancingRotationFromPixelPosition(kPPosCur, NEW_GetDstPixelPositionRef());
  1580. SetAdvancingRotation(fDstRot);
  1581. //Tracenf("VID %d 오버 방향설정 (%f, %f) %f rest %f", GetVirtualID(), kPPosCur.x, kPPosCur.y, fDstRot, fRestLen);
  1582.  
  1583. // 이동중이라면 다음번에 멈추게 한다
  1584. if (FUNC_MOVE == m_kMovAfterFunc.eFunc)
  1585. {
  1586. m_kMovAfterFunc.eFunc = FUNC_WAIT;
  1587. }
  1588. }
  1589. // 도착했다면...
  1590. else if (fCurLen <= fTotalLen && fTotalLen <= fNextLen)
  1591. {
  1592. if (m_GraphicThingInstance.IsDead() || m_GraphicThingInstance.IsKnockDown())
  1593. {
  1594. __DisableSkipCollision();
  1595.  
  1596. //Tracen("사망 상태라 동작 스킵");
  1597.  
  1598. m_isGoing = FALSE;
  1599.  
  1600. //Tracen("행동 불능 상태라 이후 동작 스킵");
  1601. }
  1602. else
  1603. {
  1604. switch (m_kMovAfterFunc.eFunc)
  1605. {
  1606. case FUNC_ATTACK:
  1607. {
  1608. if (IsWalking())
  1609. EndWalking();
  1610.  
  1611. __DisableSkipCollision();
  1612. m_isGoing = FALSE;
  1613.  
  1614. BlockMovement();
  1615. SCRIPT_SetPixelPosition(NEW_GetDstPixelPositionRef().x, NEW_GetDstPixelPositionRef().y);
  1616. SetAdvancingRotation(m_fDstRot);
  1617. SetRotation(m_fDstRot);
  1618.  
  1619. RunNormalAttack(m_fDstRot);
  1620. break;
  1621. }
  1622.  
  1623. case FUNC_COMBO:
  1624. {
  1625. if (IsWalking())
  1626. EndWalking();
  1627.  
  1628. __DisableSkipCollision();
  1629. m_isGoing = FALSE;
  1630.  
  1631. BlockMovement();
  1632. SCRIPT_SetPixelPosition(NEW_GetDstPixelPositionRef().x, NEW_GetDstPixelPositionRef().y);
  1633. RunComboAttack(m_fDstRot, m_kMovAfterFunc.uArg);
  1634. break;
  1635. }
  1636.  
  1637. case FUNC_EMOTION:
  1638. {
  1639. m_isGoing = FALSE;
  1640. m_kMovAfterFunc.eFunc = FUNC_WAIT;
  1641. __DisableSkipCollision();
  1642. BlockMovement();
  1643.  
  1644. DWORD dwMotionNumber = m_kMovAfterFunc.uArg;
  1645. DWORD dwTargetVID = m_kMovAfterFunc.uArgExpanded;
  1646. __ProcessFunctionEmotion(dwMotionNumber, dwTargetVID, m_kMovAfterFunc.kPosDst);
  1647. break;
  1648. }
  1649.  
  1650. case FUNC_MOVE:
  1651. {
  1652. break;
  1653. }
  1654.  
  1655. case FUNC_MOB_SKILL:
  1656. {
  1657. if (IsWalking())
  1658. EndWalking();
  1659.  
  1660. __DisableSkipCollision();
  1661. m_isGoing = FALSE;
  1662.  
  1663. BlockMovement();
  1664. SCRIPT_SetPixelPosition(NEW_GetDstPixelPositionRef().x, NEW_GetDstPixelPositionRef().y);
  1665. SetAdvancingRotation(m_fDstRot);
  1666. SetRotation(m_fDstRot);
  1667.  
  1668. m_GraphicThingInstance.InterceptOnceMotion(CRaceMotionData::NAME_SPECIAL_1 + m_kMovAfterFunc.uArg);
  1669. break;
  1670. }
  1671.  
  1672. default:
  1673. {
  1674. if (m_kMovAfterFunc.eFunc & FUNC_SKILL)
  1675. {
  1676. SetAdvancingRotation(m_fDstRot);
  1677. BlendRotation(m_fDstRot);
  1678. NEW_UseSkill(0, m_kMovAfterFunc.eFunc & 0x7f, m_kMovAfterFunc.uArg&0x0f, (m_kMovAfterFunc.uArg>>4) ? true : false);
  1679. }
  1680. else
  1681. {
  1682. //Tracenf("VID %d 스킬 공격 (%f, %f) rot %f", GetVirtualID(), NEW_GetDstPixelPositionRef().x, NEW_GetDstPixelPositionRef().y, m_fDstRot);
  1683.  
  1684. __DisableSkipCollision();
  1685. m_isGoing = FALSE;
  1686.  
  1687. BlockMovement();
  1688. SCRIPT_SetPixelPosition(NEW_GetDstPixelPositionRef().x, NEW_GetDstPixelPositionRef().y);
  1689. SetAdvancingRotation(m_fDstRot);
  1690. BlendRotation(m_fDstRot);
  1691. if (!IsWaiting())
  1692. {
  1693. EndWalking();
  1694. }
  1695.  
  1696. //Tracenf("VID %d 정지 (%f, %f) rot %f IsWalking %d", GetVirtualID(), NEW_GetDstPixelPositionRef().x, NEW_GetDstPixelPositionRef().y, m_fDstRot, IsWalking());
  1697. }
  1698. break;
  1699. }
  1700. }
  1701.  
  1702. }
  1703. }
  1704.  
  1705. }
  1706. }
  1707.  
  1708. if (IsWalking() || m_GraphicThingInstance.IsUsingMovingSkill())
  1709. {
  1710. float fRotation = m_GraphicThingInstance.GetRotation();
  1711. float fAdvancingRotation = m_GraphicThingInstance.GetAdvancingRotation();
  1712. int iDirection = GetRotatingDirection(fRotation, fAdvancingRotation);
  1713.  
  1714. if (DEGREE_DIRECTION_SAME != m_iRotatingDirection)
  1715. {
  1716. if (DEGREE_DIRECTION_LEFT == iDirection)
  1717. {
  1718. fRotation = fmodf(fRotation + m_fRotSpd*m_GraphicThingInstance.GetSecondElapsed(), 360.0f);
  1719. }
  1720. else if (DEGREE_DIRECTION_RIGHT == iDirection)
  1721. {
  1722. fRotation = fmodf(fRotation - m_fRotSpd*m_GraphicThingInstance.GetSecondElapsed() + 360.0f, 360.0f);
  1723. }
  1724.  
  1725. if (m_iRotatingDirection != GetRotatingDirection(fRotation, fAdvancingRotation))
  1726. {
  1727. m_iRotatingDirection = DEGREE_DIRECTION_SAME;
  1728. fRotation = fAdvancingRotation;
  1729. }
  1730.  
  1731. m_GraphicThingInstance.SetRotation(fRotation);
  1732. }
  1733.  
  1734. if (__IsInDustRange())
  1735. {
  1736. float fDustDistance = NEW_GetDistanceFromDestPixelPosition(m_kPPosDust);
  1737. if (IsMountingHorse())
  1738. {
  1739. if (fDustDistance > ms_fHorseDustGap)
  1740. {
  1741. NEW_GetPixelPosition(&m_kPPosDust);
  1742. __AttachEffect(EFFECT_HORSE_DUST);
  1743. }
  1744. }
  1745. else
  1746. {
  1747. if (fDustDistance > ms_fDustGap)
  1748. {
  1749. NEW_GetPixelPosition(&m_kPPosDust);
  1750. __AttachEffect(EFFECT_DUST);
  1751. }
  1752. }
  1753. }
  1754. }
  1755. }
  1756.  
  1757. void CInstanceBase::__ProcessFunctionEmotion(DWORD dwMotionNumber, DWORD dwTargetVID, const TPixelPosition & c_rkPosDst)
  1758. {
  1759. if (IsWalking())
  1760. EndWalkingWithoutBlending();
  1761.  
  1762. __EnableChangingTCPState();
  1763. SCRIPT_SetPixelPosition(c_rkPosDst.x, c_rkPosDst.y);
  1764.  
  1765. CInstanceBase * pTargetInstance = CPythonCharacterManager::Instance().GetInstancePtr(dwTargetVID);
  1766. if (pTargetInstance)
  1767. {
  1768. pTargetInstance->__EnableChangingTCPState();
  1769.  
  1770. if (pTargetInstance->IsWalking())
  1771. pTargetInstance->EndWalkingWithoutBlending();
  1772.  
  1773. WORD wMotionNumber1 = HIWORD(dwMotionNumber);
  1774. WORD wMotionNumber2 = LOWORD(dwMotionNumber);
  1775.  
  1776. int src_job = RaceToJob(GetRace());
  1777. int dst_job = RaceToJob(pTargetInstance->GetRace());
  1778.  
  1779. NEW_LookAtDestInstance(*pTargetInstance);
  1780. m_GraphicThingInstance.InterceptOnceMotion(wMotionNumber1 + dst_job);
  1781. m_GraphicThingInstance.SetRotation(m_GraphicThingInstance.GetTargetRotation());
  1782. m_GraphicThingInstance.SetAdvancingRotation(m_GraphicThingInstance.GetTargetRotation());
  1783.  
  1784. pTargetInstance->NEW_LookAtDestInstance(*this);
  1785. pTargetInstance->m_GraphicThingInstance.InterceptOnceMotion(wMotionNumber2 + src_job);
  1786. pTargetInstance->m_GraphicThingInstance.SetRotation(pTargetInstance->m_GraphicThingInstance.GetTargetRotation());
  1787. pTargetInstance->m_GraphicThingInstance.SetAdvancingRotation(pTargetInstance->m_GraphicThingInstance.GetTargetRotation());
  1788.  
  1789. if (pTargetInstance->__IsMainInstance())
  1790. {
  1791. IAbstractPlayer & rPlayer=IAbstractPlayer::GetSingleton();
  1792. rPlayer.EndEmotionProcess();
  1793. }
  1794. }
  1795.  
  1796. if (__IsMainInstance())
  1797. {
  1798. IAbstractPlayer & rPlayer=IAbstractPlayer::GetSingleton();
  1799. rPlayer.EndEmotionProcess();
  1800. }
  1801. }
  1802.  
  1803. ///////////////////////////////////////////////////////////////////////////////////////////////////
  1804. // Update & Deform & Render
  1805.  
  1806. int g_iAccumulationTime = 0;
  1807.  
  1808. void CInstanceBase::Update()
  1809. {
  1810. ++ms_dwUpdateCounter;
  1811.  
  1812. StateProcess();
  1813. m_GraphicThingInstance.PhysicsProcess();
  1814. m_GraphicThingInstance.RotationProcess();
  1815. m_GraphicThingInstance.ComboProcess();
  1816. m_GraphicThingInstance.AccumulationMovement();
  1817.  
  1818. if (m_GraphicThingInstance.IsMovement())
  1819. {
  1820. TPixelPosition kPPosCur;
  1821. NEW_GetPixelPosition(&kPPosCur);
  1822.  
  1823. DWORD dwCurTime=ELTimer_GetFrameMSec();
  1824. //if (m_dwNextUpdateHeightTime<dwCurTime)
  1825. {
  1826. m_dwNextUpdateHeightTime=dwCurTime;
  1827. kPPosCur.z = __GetBackgroundHeight(kPPosCur.x, kPPosCur.y);
  1828. NEW_SetPixelPosition(kPPosCur);
  1829. }
  1830.  
  1831. // SetMaterialColor
  1832. {
  1833. DWORD dwMtrlColor=__GetShadowMapColor(kPPosCur.x, kPPosCur.y);
  1834. m_GraphicThingInstance.SetMaterialColor(dwMtrlColor);
  1835. }
  1836. }
  1837.  
  1838. m_GraphicThingInstance.UpdateAdvancingPointInstance();
  1839.  
  1840. AttackProcess();
  1841. MovementProcess();
  1842.  
  1843. m_GraphicThingInstance.MotionProcess(IsPC());
  1844. if (IsMountingHorse())
  1845. {
  1846. m_kHorse.m_pkActor->HORSE_MotionProcess(FALSE);
  1847. }
  1848.  
  1849. __ComboProcess();
  1850.  
  1851. ProcessDamage();
  1852.  
  1853. }
  1854.  
  1855. void CInstanceBase::Transform()
  1856. {
  1857. if (__IsSyncing())
  1858. {
  1859. //OnSyncing();
  1860. }
  1861. else
  1862. {
  1863. if (IsWalking() || m_GraphicThingInstance.IsUsingMovingSkill())
  1864. {
  1865. const D3DXVECTOR3& c_rv3Movment=m_GraphicThingInstance.GetMovementVectorRef();
  1866.  
  1867. float len=(c_rv3Movment.x*c_rv3Movment.x)+(c_rv3Movment.y*c_rv3Movment.y);
  1868. if (len>1.0f)
  1869. OnMoving();
  1870. else
  1871. OnWaiting();
  1872. }
  1873. }
  1874.  
  1875. m_GraphicThingInstance.INSTANCEBASE_Transform();
  1876. }
  1877.  
  1878.  
  1879. void CInstanceBase::Deform()
  1880. {
  1881. // 2004.07.17.levites.isShow를 ViewFrustumCheck로 변경
  1882. if (!__CanRender())
  1883. return;
  1884.  
  1885. ++ms_dwDeformCounter;
  1886.  
  1887. m_GraphicThingInstance.INSTANCEBASE_Deform();
  1888.  
  1889. m_kHorse.Deform();
  1890. }
  1891.  
  1892. void CInstanceBase::RenderTrace()
  1893. {
  1894. if (!__CanRender())
  1895. return;
  1896.  
  1897. m_GraphicThingInstance.RenderTrace();
  1898. }
  1899.  
  1900.  
  1901.  
  1902.  
  1903. void CInstanceBase::Render()
  1904. {
  1905. // 2004.07.17.levites.isShow를 ViewFrustumCheck로 변경
  1906. if (!__CanRender())
  1907. return;
  1908.  
  1909. ++ms_dwRenderCounter;
  1910.  
  1911. m_kHorse.Render();
  1912. m_GraphicThingInstance.Render();
  1913.  
  1914. if (CActorInstance::IsDirLine())
  1915. {
  1916. if (NEW_GetDstPixelPositionRef().x != 0.0f)
  1917. {
  1918. static CScreen s_kScreen;
  1919.  
  1920. STATEMANAGER.SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_DIFFUSE);
  1921. STATEMANAGER.SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
  1922. STATEMANAGER.SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
  1923. STATEMANAGER.SaveRenderState(D3DRS_ZENABLE, FALSE);
  1924. STATEMANAGER.SetRenderState(D3DRS_FOGENABLE, FALSE);
  1925. STATEMANAGER.SetRenderState(D3DRS_LIGHTING, FALSE);
  1926.  
  1927. TPixelPosition px;
  1928. m_GraphicThingInstance.GetPixelPosition(&px);
  1929. D3DXVECTOR3 kD3DVt3Cur(px.x, px.y, px.z);
  1930. //D3DXVECTOR3 kD3DVt3Cur(NEW_GetSrcPixelPositionRef().x, -NEW_GetSrcPixelPositionRef().y, NEW_GetSrcPixelPositionRef().z);
  1931. D3DXVECTOR3 kD3DVt3Dest(NEW_GetDstPixelPositionRef().x, -NEW_GetDstPixelPositionRef().y, NEW_GetDstPixelPositionRef().z);
  1932.  
  1933. //printf("%s %f\n", GetNameString(), kD3DVt3Cur.y - kD3DVt3Dest.y);
  1934. //float fdx = NEW_GetDstPixelPositionRef().x - NEW_GetSrcPixelPositionRef().x;
  1935. //float fdy = NEW_GetDstPixelPositionRef().y - NEW_GetSrcPixelPositionRef().y;
  1936.  
  1937. s_kScreen.SetDiffuseColor(0.0f, 0.0f, 1.0f);
  1938. s_kScreen.RenderLine3d(kD3DVt3Cur.x, kD3DVt3Cur.y, px.z, kD3DVt3Dest.x, kD3DVt3Dest.y, px.z);
  1939. STATEMANAGER.RestoreRenderState(D3DRS_ZENABLE);
  1940. STATEMANAGER.SetRenderState(D3DRS_FOGENABLE, TRUE);
  1941. STATEMANAGER.SetRenderState(D3DRS_LIGHTING, TRUE);
  1942. }
  1943. }
  1944. }
  1945.  
  1946. void CInstanceBase::RenderToShadowMap()
  1947. {
  1948. if (IsDoor())
  1949. return;
  1950.  
  1951. if (IsBuilding())
  1952. return;
  1953.  
  1954. if (!__CanRender())
  1955. return;
  1956.  
  1957. if (!__IsExistMainInstance())
  1958. return;
  1959.  
  1960. CInstanceBase* pkInstMain=__GetMainInstancePtr();
  1961.  
  1962. const float SHADOW_APPLY_DISTANCE = 2500.0f;
  1963.  
  1964. float fDistance=NEW_GetDistanceFromDestInstance(*pkInstMain);
  1965. if (fDistance>=SHADOW_APPLY_DISTANCE)
  1966. return;
  1967.  
  1968. m_GraphicThingInstance.RenderToShadowMap();
  1969. }
  1970.  
  1971. void CInstanceBase::RenderCollision()
  1972. {
  1973. m_GraphicThingInstance.RenderCollisionData();
  1974. }
  1975.  
  1976. ///////////////////////////////////////////////////////////////////////////////////////////////////
  1977. // Setting & Getting Data
  1978.  
  1979. void CInstanceBase::SetVirtualID(DWORD dwVirtualID)
  1980. {
  1981. m_GraphicThingInstance.SetVirtualID(dwVirtualID);
  1982. }
  1983.  
  1984. void CInstanceBase::SetVirtualNumber(DWORD dwVirtualNumber)
  1985. {
  1986. m_dwVirtualNumber = dwVirtualNumber;
  1987. }
  1988.  
  1989. void CInstanceBase::SetInstanceType(int iInstanceType)
  1990. {
  1991. m_GraphicThingInstance.SetActorType(iInstanceType);
  1992. }
  1993.  
  1994. void CInstanceBase::SetAlignment(short sAlignment)
  1995. {
  1996. m_sAlignment = sAlignment;
  1997. RefreshTextTailTitle();
  1998. }
  1999.  
  2000. #ifdef ENABLE_TITLE_SYSTEM
  2001. void CInstanceBase::SetsTitle(int iTitle)
  2002. {
  2003. m_iTitleID = iTitle;
  2004. RefreshTextTailTitle();
  2005. }
  2006. #endif
  2007.  
  2008. void CInstanceBase::SetLevelText(int sLevel)
  2009. {
  2010. m_dwLevel = sLevel;
  2011. UpdateTextTailLevel(sLevel);
  2012. }
  2013.  
  2014. void CInstanceBase::SetPKMode(BYTE byPKMode)
  2015. {
  2016. if (m_byPKMode == byPKMode)
  2017. return;
  2018.  
  2019. m_byPKMode = byPKMode;
  2020.  
  2021. if (__IsMainInstance())
  2022. {
  2023. IAbstractPlayer& rPlayer=IAbstractPlayer::GetSingleton();
  2024. rPlayer.NotifyChangePKMode();
  2025. }
  2026. }
  2027.  
  2028. void CInstanceBase::SetKiller(bool bFlag)
  2029. {
  2030. if (m_isKiller == bFlag)
  2031. return;
  2032.  
  2033. m_isKiller = bFlag;
  2034. RefreshTextTail();
  2035. }
  2036.  
  2037. void CInstanceBase::SetPartyMemberFlag(bool bFlag)
  2038. {
  2039. m_isPartyMember = bFlag;
  2040. }
  2041.  
  2042. void CInstanceBase::SetStateFlags(DWORD dwStateFlags)
  2043. {
  2044. if (dwStateFlags & ADD_CHARACTER_STATE_KILLER)
  2045. SetKiller(TRUE);
  2046. else
  2047. SetKiller(FALSE);
  2048.  
  2049. if (dwStateFlags & ADD_CHARACTER_STATE_PARTY)
  2050. SetPartyMemberFlag(TRUE);
  2051. else
  2052. SetPartyMemberFlag(FALSE);
  2053. }
  2054.  
  2055. void CInstanceBase::SetComboType(UINT uComboType)
  2056. {
  2057. m_GraphicThingInstance.SetComboType(uComboType);
  2058. }
  2059.  
  2060. const char * CInstanceBase::GetNameString()
  2061. {
  2062. return m_stName.c_str();
  2063. }
  2064.  
  2065. DWORD CInstanceBase::GetLevel()
  2066. {
  2067. return m_dwLevel;
  2068. }
  2069.  
  2070. DWORD CInstanceBase::GetRace()
  2071. {
  2072. return m_dwRace;
  2073. }
  2074.  
  2075.  
  2076. bool CInstanceBase::IsConflictAlignmentInstance(CInstanceBase& rkInstVictim)
  2077. {
  2078. if (PK_MODE_PROTECT == rkInstVictim.GetPKMode())
  2079. return false;
  2080.  
  2081. switch (GetAlignmentType())
  2082. {
  2083. case ALIGNMENT_TYPE_NORMAL:
  2084. case ALIGNMENT_TYPE_WHITE:
  2085. if (ALIGNMENT_TYPE_DARK == rkInstVictim.GetAlignmentType())
  2086. return true;
  2087. break;
  2088. case ALIGNMENT_TYPE_DARK:
  2089. if (GetAlignmentType() != rkInstVictim.GetAlignmentType())
  2090. return true;
  2091. break;
  2092. }
  2093.  
  2094. return false;
  2095. }
  2096.  
  2097. void CInstanceBase::SetDuelMode(DWORD type)
  2098. {
  2099. m_dwDuelMode = type;
  2100. }
  2101.  
  2102. DWORD CInstanceBase::GetDuelMode()
  2103. {
  2104. return m_dwDuelMode;
  2105. }
  2106.  
  2107. bool CInstanceBase::IsAttackableInstance(CInstanceBase& rkInstVictim)
  2108. {
  2109. if (__IsMainInstance())
  2110. {
  2111. CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
  2112. if(rkPlayer.IsObserverMode())
  2113. return false;
  2114. }
  2115.  
  2116. if (GetVirtualID() == rkInstVictim.GetVirtualID())
  2117. return false;
  2118.  
  2119. if (IsStone())
  2120. {
  2121. if (rkInstVictim.IsPC())
  2122. return true;
  2123. }
  2124. else if (IsPC())
  2125. {
  2126. if (rkInstVictim.IsStone())
  2127. return true;
  2128.  
  2129. if (rkInstVictim.IsPC())
  2130. {
  2131. if (GetDuelMode())
  2132. {
  2133. switch(GetDuelMode())
  2134. {
  2135. case DUEL_CANNOTATTACK:
  2136. return false;
  2137. case DUEL_START:
  2138. if(__FindDUELKey(GetVirtualID(),rkInstVictim.GetVirtualID()))
  2139. return true;
  2140. else
  2141. return false;
  2142. }
  2143. }
  2144. if (PK_MODE_GUILD == GetPKMode())
  2145. if (GetGuildID() == rkInstVictim.GetGuildID())
  2146. return false;
  2147.  
  2148. if (rkInstVictim.IsKiller())
  2149. if (!IAbstractPlayer::GetSingleton().IsSamePartyMember(GetVirtualID(), rkInstVictim.GetVirtualID()))
  2150. return true;
  2151.  
  2152. if (PK_MODE_PROTECT != GetPKMode())
  2153. {
  2154. if (PK_MODE_FREE == GetPKMode())
  2155. {
  2156. if (PK_MODE_PROTECT != rkInstVictim.GetPKMode())
  2157. if (!IAbstractPlayer::GetSingleton().IsSamePartyMember(GetVirtualID(), rkInstVictim.GetVirtualID()))
  2158. return true;
  2159. }
  2160. if (PK_MODE_GUILD == GetPKMode())
  2161. {
  2162. if (PK_MODE_PROTECT != rkInstVictim.GetPKMode())
  2163. if (!IAbstractPlayer::GetSingleton().IsSamePartyMember(GetVirtualID(), rkInstVictim.GetVirtualID()))
  2164. if (GetGuildID() != rkInstVictim.GetGuildID())
  2165. return true;
  2166. }
  2167. }
  2168.  
  2169. if (IsSameEmpire(rkInstVictim))
  2170. {
  2171. if (IsPVPInstance(rkInstVictim))
  2172. return true;
  2173.  
  2174. if (PK_MODE_REVENGE == GetPKMode())
  2175. if (!IAbstractPlayer::GetSingleton().IsSamePartyMember(GetVirtualID(), rkInstVictim.GetVirtualID()))
  2176. if (IsConflictAlignmentInstance(rkInstVictim))
  2177. return true;
  2178. }
  2179. else
  2180. {
  2181. return true;
  2182. }
  2183. }
  2184.  
  2185. if (rkInstVictim.IsEnemy())
  2186. return true;
  2187.  
  2188. if (rkInstVictim.IsWoodenDoor())
  2189. return true;
  2190. }
  2191. else if (IsEnemy())
  2192. {
  2193. if (rkInstVictim.IsPC())
  2194. return true;
  2195.  
  2196. if (rkInstVictim.IsBuilding())
  2197. return true;
  2198.  
  2199. }
  2200. else if (IsPoly())
  2201. {
  2202. if (rkInstVictim.IsPC())
  2203. return true;
  2204.  
  2205. if (rkInstVictim.IsEnemy())
  2206. return true;
  2207. }
  2208. return false;
  2209. }
  2210.  
  2211. bool CInstanceBase::IsTargetableInstance(CInstanceBase& rkInstVictim)
  2212. {
  2213. return rkInstVictim.CanPickInstance();
  2214. }
  2215.  
  2216. // 2004. 07. 07. [levites] - 스킬 사용중 타겟이 바뀌는 문제 해결을 위한 코드
  2217. bool CInstanceBase::CanChangeTarget()
  2218. {
  2219. return m_GraphicThingInstance.CanChangeTarget();
  2220. }
  2221.  
  2222. // 2004.07.17.levites.isShow를 ViewFrustumCheck로 변경
  2223. bool CInstanceBase::CanPickInstance()
  2224. {
  2225. if (!__IsInViewFrustum())
  2226. return false;
  2227.  
  2228. if (IsDoor())
  2229. {
  2230. if (IsDead())
  2231. return false;
  2232. }
  2233.  
  2234. if (IsPC())
  2235. {
  2236. if (IsAffect(AFFECT_EUNHYEONG))
  2237. {
  2238. if (!__MainCanSeeHiddenThing())
  2239. return false;
  2240. }
  2241. if (IsAffect(AFFECT_REVIVE_INVISIBILITY))
  2242. return false;
  2243. if (IsAffect(AFFECT_INVISIBILITY))
  2244. return false;
  2245. }
  2246.  
  2247. if (IsDead())
  2248. return false;
  2249.  
  2250. return true;
  2251. }
  2252.  
  2253. bool CInstanceBase::CanViewTargetHP(CInstanceBase& rkInstVictim)
  2254. {
  2255. if (rkInstVictim.IsStone())
  2256. return true;
  2257. if (rkInstVictim.IsWoodenDoor())
  2258. return true;
  2259. if (rkInstVictim.IsEnemy())
  2260. return true;
  2261. if (rkInstVictim.IsPC())
  2262. return true;
  2263.  
  2264. return false;
  2265. }
  2266.  
  2267. BOOL CInstanceBase::IsPoly()
  2268. {
  2269. return m_GraphicThingInstance.IsPoly();
  2270. }
  2271.  
  2272. BOOL CInstanceBase::IsPC()
  2273. {
  2274. return m_GraphicThingInstance.IsPC();
  2275. }
  2276.  
  2277. BOOL CInstanceBase::IsNPC()
  2278. {
  2279. return m_GraphicThingInstance.IsNPC();
  2280. }
  2281.  
  2282. BOOL CInstanceBase::IsNewPet()
  2283. {
  2284. return m_GraphicThingInstance.IsNewPet();
  2285. }
  2286.  
  2287. BOOL CInstanceBase::IsEnemy()
  2288. {
  2289. return m_GraphicThingInstance.IsEnemy();
  2290. }
  2291.  
  2292. BOOL CInstanceBase::IsStone()
  2293. {
  2294. return m_GraphicThingInstance.IsStone();
  2295. }
  2296.  
  2297.  
  2298. BOOL CInstanceBase::IsGuildWall() //IsBuilding 길드건물전체 IsGuildWall은 담장벽만(문은 제외)
  2299. {
  2300. return IsWall(m_dwRace);
  2301. }
  2302.  
  2303.  
  2304. BOOL CInstanceBase::IsResource()
  2305. {
  2306. switch (m_dwVirtualNumber)
  2307. {
  2308. case 20047:
  2309. case 20048:
  2310. case 20049:
  2311. case 20050:
  2312. case 20051:
  2313. case 20052:
  2314. case 20053:
  2315. case 20054:
  2316. case 20055:
  2317. case 20056:
  2318. case 20057:
  2319. case 20058:
  2320. case 20059:
  2321. case 30301:
  2322. case 30302:
  2323. case 30303:
  2324. case 30304:
  2325. case 30305:
  2326. return TRUE;
  2327. }
  2328.  
  2329. return FALSE;
  2330. }
  2331.  
  2332. BOOL CInstanceBase::IsWarp()
  2333. {
  2334. return m_GraphicThingInstance.IsWarp();
  2335. }
  2336.  
  2337. BOOL CInstanceBase::IsGoto()
  2338. {
  2339. return m_GraphicThingInstance.IsGoto();
  2340. }
  2341.  
  2342. BOOL CInstanceBase::IsObject()
  2343. {
  2344. return m_GraphicThingInstance.IsObject();
  2345. }
  2346.  
  2347. BOOL CInstanceBase::IsBuilding()
  2348. {
  2349. return m_GraphicThingInstance.IsBuilding();
  2350. }
  2351.  
  2352. BOOL CInstanceBase::IsDoor()
  2353. {
  2354. return m_GraphicThingInstance.IsDoor();
  2355. }
  2356.  
  2357. BOOL CInstanceBase::IsWoodenDoor()
  2358. {
  2359. if (m_GraphicThingInstance.IsDoor())
  2360. {
  2361. int vnum = GetVirtualNumber();
  2362. if (vnum == 13000) // 나무문
  2363. return true;
  2364. else if (vnum >= 30111 && vnum <= 30119) // 사귀문
  2365. return true;
  2366. else
  2367. return false;
  2368. }
  2369. else
  2370. {
  2371. return false;
  2372. }
  2373. }
  2374.  
  2375. BOOL CInstanceBase::IsStoneDoor()
  2376. {
  2377. return m_GraphicThingInstance.IsDoor() && 13001 == GetVirtualNumber();
  2378. }
  2379.  
  2380. BOOL CInstanceBase::IsFlag()
  2381. {
  2382. if (GetRace() == 20035)
  2383. return TRUE;
  2384. if (GetRace() == 20036)
  2385. return TRUE;
  2386. if (GetRace() == 20037)
  2387. return TRUE;
  2388.  
  2389. return FALSE;
  2390. }
  2391.  
  2392. BOOL CInstanceBase::IsForceVisible()
  2393. {
  2394. if (IsAffect(AFFECT_SHOW_ALWAYS))
  2395. return TRUE;
  2396.  
  2397. if (IsObject() || IsBuilding() || IsDoor() )
  2398. return TRUE;
  2399.  
  2400. return FALSE;
  2401. }
  2402.  
  2403. int CInstanceBase::GetInstanceType()
  2404. {
  2405. return m_GraphicThingInstance.GetActorType();
  2406. }
  2407.  
  2408. DWORD CInstanceBase::GetVirtualID()
  2409. {
  2410. return m_GraphicThingInstance.GetVirtualID();
  2411. }
  2412.  
  2413. DWORD CInstanceBase::GetVirtualNumber()
  2414. {
  2415. return m_dwVirtualNumber;
  2416. }
  2417.  
  2418. // 2004.07.17.levites.isShow를 ViewFrustumCheck로 변경
  2419. bool CInstanceBase::__IsInViewFrustum()
  2420. {
  2421. return m_GraphicThingInstance.isShow();
  2422. }
  2423.  
  2424. bool CInstanceBase::__CanRender()
  2425. {
  2426. if (!__IsInViewFrustum())
  2427. return false;
  2428. if (IsAffect(AFFECT_INVISIBILITY))
  2429. return false;
  2430.  
  2431. return true;
  2432. }
  2433.  
  2434.  
  2435. ///////////////////////////////////////////////////////////////////////////////////////////////////
  2436. // Graphic Control
  2437.  
  2438. bool CInstanceBase::IntersectBoundingBox()
  2439. {
  2440. float u, v, t;
  2441. return m_GraphicThingInstance.Intersect(&u, &v, &t);
  2442. }
  2443.  
  2444. bool CInstanceBase::IntersectDefendingSphere()
  2445. {
  2446. return m_GraphicThingInstance.IntersectDefendingSphere();
  2447. }
  2448.  
  2449. float CInstanceBase::GetDistance(CInstanceBase * pkTargetInst)
  2450. {
  2451. TPixelPosition TargetPixelPosition;
  2452. pkTargetInst->m_GraphicThingInstance.GetPixelPosition(&TargetPixelPosition);
  2453. return GetDistance(TargetPixelPosition);
  2454. }
  2455.  
  2456. float CInstanceBase::GetDistance(const TPixelPosition & c_rPixelPosition)
  2457. {
  2458. TPixelPosition PixelPosition;
  2459. m_GraphicThingInstance.GetPixelPosition(&PixelPosition);
  2460.  
  2461. float fdx = PixelPosition.x - c_rPixelPosition.x;
  2462. float fdy = PixelPosition.y - c_rPixelPosition.y;
  2463.  
  2464. return sqrtf((fdx*fdx) + (fdy*fdy));
  2465. }
  2466.  
  2467. CActorInstance& CInstanceBase::GetGraphicThingInstanceRef()
  2468. {
  2469. return m_GraphicThingInstance;
  2470. }
  2471.  
  2472. CActorInstance* CInstanceBase::GetGraphicThingInstancePtr()
  2473. {
  2474. return &m_GraphicThingInstance;
  2475. }
  2476.  
  2477. void CInstanceBase::RefreshActorInstance()
  2478. {
  2479. m_GraphicThingInstance.RefreshActorInstance();
  2480. }
  2481.  
  2482. void CInstanceBase::Refresh(DWORD dwMotIndex, bool isLoop)
  2483. {
  2484. RefreshState(dwMotIndex, isLoop);
  2485. }
  2486.  
  2487. void CInstanceBase::RestoreRenderMode()
  2488. {
  2489. m_GraphicThingInstance.RestoreRenderMode();
  2490. }
  2491.  
  2492. void CInstanceBase::SetAddRenderMode()
  2493. {
  2494. m_GraphicThingInstance.SetAddRenderMode();
  2495. }
  2496.  
  2497. void CInstanceBase::SetModulateRenderMode()
  2498. {
  2499. m_GraphicThingInstance.SetModulateRenderMode();
  2500. }
  2501.  
  2502. void CInstanceBase::SetRenderMode(int iRenderMode)
  2503. {
  2504. m_GraphicThingInstance.SetRenderMode(iRenderMode);
  2505. }
  2506.  
  2507. void CInstanceBase::SetAddColor(const D3DXCOLOR & c_rColor)
  2508. {
  2509. m_GraphicThingInstance.SetAddColor(c_rColor);
  2510. }
  2511.  
  2512. void CInstanceBase::__SetBlendRenderingMode()
  2513. {
  2514. m_GraphicThingInstance.SetBlendRenderMode();
  2515. }
  2516.  
  2517. void CInstanceBase::__SetAlphaValue(float fAlpha)
  2518. {
  2519. m_GraphicThingInstance.SetAlphaValue(fAlpha);
  2520. }
  2521.  
  2522. float CInstanceBase::__GetAlphaValue()
  2523. {
  2524. return m_GraphicThingInstance.GetAlphaValue();
  2525. }
  2526.  
  2527. ///////////////////////////////////////////////////////////////////////////////////////////////////
  2528. // Part
  2529.  
  2530. void CInstanceBase::SetHair(DWORD eHair)
  2531. {
  2532. if (!HAIR_COLOR_ENABLE)
  2533. return;
  2534.  
  2535. if (IsPC()==false)
  2536. return;
  2537. m_awPart[CRaceData::PART_HAIR] = eHair;
  2538. m_GraphicThingInstance.SetHair(eHair);
  2539. }
  2540.  
  2541. void CInstanceBase::ChangeHair(DWORD eHair)
  2542. {
  2543. if (!HAIR_COLOR_ENABLE)
  2544. return;
  2545.  
  2546. if (IsPC()==false)
  2547. return;
  2548.  
  2549. if (GetPart(CRaceData::PART_HAIR)==eHair)
  2550. return;
  2551.  
  2552. SetHair(eHair);
  2553.  
  2554. //int type = m_GraphicThingInstance.GetMotionMode();
  2555.  
  2556. RefreshState(CRaceMotionData::NAME_WAIT, true);
  2557. //RefreshState(type, true);
  2558. }
  2559.  
  2560. void CInstanceBase::SetArmor(DWORD dwArmor)
  2561. {
  2562. DWORD dwShape;
  2563. if (__ArmorVnumToShape(dwArmor, &dwShape))
  2564. {
  2565. CItemData * pItemData;
  2566. if (CItemManager::Instance().GetItemDataPointer(dwArmor, &pItemData))
  2567. {
  2568. float fSpecularPower=pItemData->GetSpecularPowerf();
  2569. SetShape(dwShape, fSpecularPower);
  2570. __GetRefinedEffect(pItemData);
  2571. return;
  2572. }
  2573. else
  2574. __ClearArmorRefineEffect();
  2575. }
  2576.  
  2577. SetShape(dwArmor);
  2578. }
  2579.  
  2580. #ifdef ENABLE_SASH_SYSTEM
  2581. void CInstanceBase::SetSash(DWORD dwSash)
  2582. {
  2583. if (!IsPC())
  2584. return;
  2585.  
  2586. if (IsPoly())
  2587. return;
  2588.  
  2589. dwSash += 85000;
  2590. ClearSashEffect();
  2591.  
  2592. float fSpecular = 65.0f;
  2593. if (dwSash > 86000)
  2594. {
  2595. dwSash -= 1000;
  2596. fSpecular += 35;
  2597.  
  2598. m_dwSashEffect = EFFECT_REFINED + EFFECT_SASH;
  2599. __EffectContainer_AttachEffect(m_dwSashEffect);
  2600. }
  2601.  
  2602. fSpecular /= 100.0f;
  2603. m_awPart[CRaceData::PART_SASH] = dwSash;
  2604.  
  2605. CItemData * pItemData;
  2606. if (!CItemManager::Instance().GetItemDataPointer(dwSash, &pItemData))
  2607. return;
  2608.  
  2609. m_GraphicThingInstance.AttachSash(pItemData, fSpecular);
  2610. #ifdef ENABLE_OBJ_SCALLING
  2611. DWORD dwRace = GetRace(), dwPos = RaceToJob(dwRace), dwSex = RaceToSex(dwRace);
  2612. dwPos += 1;
  2613. if (dwSex == 0)
  2614. dwPos += 5;
  2615.  
  2616. float fScaleX, fScaleY, fScaleZ, fPositionX, fPositionY, fPositionZ;
  2617. if (pItemData->GetItemScale(dwPos, fScaleX, fScaleY, fScaleZ, fPositionX, fPositionY, fPositionZ))
  2618. {
  2619. m_GraphicThingInstance.SetScale(fScaleX, fScaleY, fScaleZ, true);
  2620. if (m_kHorse.IsMounting())
  2621. fPositionZ += 10.0f;
  2622.  
  2623. m_GraphicThingInstance.SetScalePosition(fPositionX, fPositionY, fPositionZ);
  2624. }
  2625. #endif
  2626. }
  2627.  
  2628. void CInstanceBase::ChangeSash(DWORD dwSash)
  2629. {
  2630. if (!IsPC())
  2631. return;
  2632.  
  2633. SetSash(dwSash);
  2634. }
  2635.  
  2636. void CInstanceBase::ClearSashEffect()
  2637. {
  2638. if (!m_dwSashEffect)
  2639. return;
  2640.  
  2641. __EffectContainer_DetachEffect(m_dwSashEffect);
  2642. m_dwSashEffect = 0;
  2643. }
  2644. #endif
  2645.  
  2646. void CInstanceBase::SetShape(DWORD eShape, float fSpecular)
  2647. {
  2648. if (IsPoly())
  2649. {
  2650. m_GraphicThingInstance.SetShape(0);
  2651. }
  2652. else
  2653. {
  2654. m_GraphicThingInstance.SetShape(eShape, fSpecular);
  2655. }
  2656.  
  2657. m_eShape = eShape;
  2658. }
  2659.  
  2660.  
  2661.  
  2662. DWORD CInstanceBase::GetWeaponType()
  2663. {
  2664. DWORD dwWeapon = GetPart(CRaceData::PART_WEAPON);
  2665. CItemData * pItemData;
  2666. if (!CItemManager::Instance().GetItemDataPointer(dwWeapon, &pItemData))
  2667. return CItemData::WEAPON_NONE;
  2668.  
  2669. if (pItemData->GetType() == CItemData::ITEM_TYPE_COSTUME)
  2670. return pItemData->GetWeaponType() - CItemData::COSTUME_WEAPON_SWORD;
  2671.  
  2672. return pItemData->GetWeaponType();
  2673. }
  2674.  
  2675. /*
  2676. void CInstanceBase::SetParts(const WORD * c_pParts)
  2677. {
  2678. if (IsPoly())
  2679. return;
  2680.  
  2681. if (__IsShapeAnimalWear())
  2682. return;
  2683.  
  2684. UINT eWeapon=c_pParts[CRaceData::PART_WEAPON];
  2685.  
  2686. if (__IsChangableWeapon(eWeapon) == false)
  2687. eWeapon = 0;
  2688.  
  2689. if (eWeapon != m_GraphicThingInstance.GetPartItemID(CRaceData::PART_WEAPON))
  2690. {
  2691. m_GraphicThingInstance.AttachPart(CRaceData::PART_MAIN, CRaceData::PART_WEAPON, eWeapon);
  2692. m_awPart[CRaceData::PART_WEAPON] = eWeapon;
  2693. }
  2694.  
  2695. __AttachHorseSaddle();
  2696. }
  2697. */
  2698.  
  2699. void CInstanceBase::__ClearWeaponRefineEffect()
  2700. {
  2701. if (m_swordRefineEffectRight)
  2702. {
  2703. __DetachEffect(m_swordRefineEffectRight);
  2704. m_swordRefineEffectRight = 0;
  2705. }
  2706. if (m_swordRefineEffectLeft)
  2707. {
  2708. __DetachEffect(m_swordRefineEffectLeft);
  2709. m_swordRefineEffectLeft = 0;
  2710. }
  2711. }
  2712.  
  2713. void CInstanceBase::__ClearArmorRefineEffect()
  2714. {
  2715. if (m_armorRefineEffect)
  2716. {
  2717. __DetachEffect(m_armorRefineEffect);
  2718. m_armorRefineEffect = 0;
  2719. }
  2720. }
  2721.  
  2722. UINT CInstanceBase::__GetRefinedEffect(CItemData* pItem)
  2723. {
  2724. DWORD refine = max(pItem->GetRefine() + pItem->GetSocketCount(),CItemData::ITEM_SOCKET_MAX_NUM) - CItemData::ITEM_SOCKET_MAX_NUM;
  2725. switch (pItem->GetType())
  2726. {
  2727. case CItemData::ITEM_TYPE_WEAPON:
  2728. __ClearWeaponRefineEffect();
  2729. if (refine < 7) //현재 제련도 7 이상만 이펙트가 있습니다.
  2730. return 0;
  2731. switch(pItem->GetSubType())
  2732. {
  2733. case CItemData::COSTUME_WEAPON_DAGGER:
  2734. case CItemData::WEAPON_DAGGER:
  2735. m_swordRefineEffectRight = EFFECT_REFINED+EFFECT_SMALLSWORD_REFINED7+refine-7;
  2736. m_swordRefineEffectLeft = EFFECT_REFINED+EFFECT_SMALLSWORD_REFINED7_LEFT+refine-7;
  2737. break;
  2738. case CItemData::COSTUME_WEAPON_FAN:
  2739. case CItemData::WEAPON_FAN:
  2740. m_swordRefineEffectRight = EFFECT_REFINED+EFFECT_FANBELL_REFINED7+refine-7;
  2741. break;
  2742. case CItemData::COSTUME_WEAPON_BELL:
  2743. case CItemData::WEAPON_ARROW:
  2744. case CItemData::WEAPON_BELL:
  2745. m_swordRefineEffectRight = EFFECT_REFINED+EFFECT_SMALLSWORD_REFINED7+refine-7;
  2746. break;
  2747. case CItemData::COSTUME_WEAPON_BOW:
  2748. case CItemData::WEAPON_BOW:
  2749. m_swordRefineEffectRight = EFFECT_REFINED+EFFECT_BOW_REFINED7+refine-7;
  2750. break;
  2751. default:
  2752. m_swordRefineEffectRight = EFFECT_REFINED+EFFECT_SWORD_REFINED7+refine-7;
  2753. }
  2754. if (m_swordRefineEffectRight)
  2755. m_swordRefineEffectRight = __AttachEffect(m_swordRefineEffectRight);
  2756. if (m_swordRefineEffectLeft)
  2757. m_swordRefineEffectLeft = __AttachEffect(m_swordRefineEffectLeft);
  2758. break;
  2759. case CItemData::ITEM_TYPE_ARMOR:
  2760. __ClearArmorRefineEffect();
  2761.  
  2762. // 갑옷 특화 이펙트
  2763. if (pItem->GetSubType() == CItemData::ARMOR_BODY)
  2764. {
  2765. DWORD vnum = pItem->GetIndex();
  2766.  
  2767. if (12010 <= vnum && vnum <= 12049)
  2768. {
  2769. __AttachEffect(EFFECT_REFINED+EFFECT_BODYARMOR_SPECIAL);
  2770. __AttachEffect(EFFECT_REFINED+EFFECT_BODYARMOR_SPECIAL2);
  2771. }
  2772. }
  2773. #ifdef VERSION_162_ENABLED
  2774. if (20760 <= vnum && vnum <= 20959)
  2775. {
  2776. __AttachEffect(EFFECT_REFINED + EFFECT_BODYARMOR_SPECIAL3);
  2777. break;
  2778. }
  2779. #endif
  2780.  
  2781. if (refine < 7) //현재 제련도 7 이상만 이펙트가 있습니다.
  2782. return 0;
  2783.  
  2784. if (pItem->GetSubType() == CItemData::ARMOR_BODY)
  2785. {
  2786. m_armorRefineEffect = EFFECT_REFINED+EFFECT_BODYARMOR_REFINED7+refine-7;
  2787. __AttachEffect(m_armorRefineEffect);
  2788. }
  2789. break;
  2790. }
  2791. return 0;
  2792. }
  2793.  
  2794. bool CInstanceBase::SetWeapon(DWORD eWeapon)
  2795. {
  2796. if (IsPoly())
  2797. return false;
  2798.  
  2799. if (__IsShapeAnimalWear())
  2800. return false;
  2801.  
  2802. if (__IsChangableWeapon(eWeapon) == false)
  2803. eWeapon = 0;
  2804.  
  2805. m_GraphicThingInstance.AttachWeapon(eWeapon);
  2806. m_awPart[CRaceData::PART_WEAPON] = eWeapon;
  2807.  
  2808. //Weapon Effect
  2809. CItemData * pItemData;
  2810. if (CItemManager::Instance().GetItemDataPointer(eWeapon, &pItemData))
  2811. __GetRefinedEffect(pItemData);
  2812. else
  2813. __ClearWeaponRefineEffect();
  2814.  
  2815. return true;
  2816. }
  2817.  
  2818. void CInstanceBase::ChangeWeapon(DWORD eWeapon)
  2819. {
  2820. if (eWeapon == m_GraphicThingInstance.GetPartItemID(CRaceData::PART_WEAPON))
  2821. return;
  2822.  
  2823. if (SetWeapon(eWeapon))
  2824. RefreshState(CRaceMotionData::NAME_WAIT, true);
  2825. }
  2826.  
  2827. bool CInstanceBase::ChangeArmor(DWORD dwArmor)
  2828. {
  2829. DWORD eShape;
  2830. __ArmorVnumToShape(dwArmor, &eShape);
  2831.  
  2832. if (GetShape()==eShape)
  2833. return false;
  2834.  
  2835. CAffectFlagContainer kAffectFlagContainer;
  2836. kAffectFlagContainer.CopyInstance(m_kAffectFlagContainer);
  2837.  
  2838. DWORD dwVID = GetVirtualID();
  2839. DWORD dwRace = GetRace();
  2840. DWORD eHair = GetPart(CRaceData::PART_HAIR);
  2841. DWORD dwSash = GetPart(CRaceData::PART_SASH);
  2842. DWORD eWeapon = GetPart(CRaceData::PART_WEAPON);
  2843. float fRot = GetRotation();
  2844. float fAdvRot = GetAdvancingRotation();
  2845.  
  2846. if (IsWalking())
  2847. EndWalking();
  2848.  
  2849. // 2004.07.25.myevan.이펙트 안 붙는 문제
  2850. //////////////////////////////////////////////////////
  2851. __ClearAffects();
  2852. //////////////////////////////////////////////////////
  2853.  
  2854. if (!SetRace(dwRace))
  2855. {
  2856. TraceError("CPythonCharacterManager::ChangeArmor - SetRace VID[%d] Race[%d] ERROR", dwVID, dwRace);
  2857. return false;
  2858. }
  2859.  
  2860. SetArmor(dwArmor);
  2861. SetHair(eHair);
  2862. SetSash(dwSash);
  2863. SetWeapon(eWeapon);
  2864.  
  2865. SetRotation(fRot);
  2866. SetAdvancingRotation(fAdvRot);
  2867.  
  2868. __AttachHorseSaddle();
  2869.  
  2870. RefreshState(CRaceMotionData::NAME_WAIT, TRUE);
  2871.  
  2872. // 2004.07.25.myevan.이펙트 안 붙는 문제
  2873. /////////////////////////////////////////////////
  2874. SetAffectFlagContainer(kAffectFlagContainer);
  2875. /////////////////////////////////////////////////
  2876.  
  2877. CActorInstance::IEventHandler& rkEventHandler=GetEventHandlerRef();
  2878. rkEventHandler.OnChangeShape();
  2879.  
  2880. return true;
  2881. }
  2882.  
  2883. bool CInstanceBase::__IsShapeAnimalWear()
  2884. {
  2885. if (100 == GetShape() ||
  2886. 101 == GetShape() ||
  2887. 102 == GetShape() ||
  2888. 103 == GetShape())
  2889. return true;
  2890.  
  2891. return false;
  2892. }
  2893.  
  2894. DWORD CInstanceBase::__GetRaceType()
  2895. {
  2896. return m_eRaceType;
  2897. }
  2898.  
  2899.  
  2900. void CInstanceBase::RefreshState(DWORD dwMotIndex, bool isLoop)
  2901. {
  2902. DWORD dwPartItemID = m_GraphicThingInstance.GetPartItemID(CRaceData::PART_WEAPON);
  2903.  
  2904. BYTE byItemType = 0xff;
  2905. BYTE bySubType = 0xff;
  2906.  
  2907. CItemManager & rkItemMgr = CItemManager::Instance();
  2908. CItemData * pItemData;
  2909.  
  2910. if (rkItemMgr.GetItemDataPointer(dwPartItemID, &pItemData))
  2911. {
  2912. byItemType = pItemData->GetType();
  2913. bySubType = pItemData->GetWeaponType();
  2914. }
  2915.  
  2916. if (IsPoly())
  2917. {
  2918. SetMotionMode(CRaceMotionData::MODE_GENERAL);
  2919. }
  2920. else if (IsWearingDress())
  2921. {
  2922. SetMotionMode(CRaceMotionData::MODE_WEDDING_DRESS);
  2923. }
  2924. else if (IsHoldingPickAxe())
  2925. {
  2926. if (m_kHorse.IsMounting())
  2927. {
  2928. SetMotionMode(CRaceMotionData::MODE_HORSE);
  2929. }
  2930. else
  2931. {
  2932. SetMotionMode(CRaceMotionData::MODE_GENERAL);
  2933. }
  2934. }
  2935. else if (CItemData::ITEM_TYPE_ROD == byItemType)
  2936. {
  2937. if (m_kHorse.IsMounting())
  2938. {
  2939. SetMotionMode(CRaceMotionData::MODE_HORSE);
  2940. }
  2941. else
  2942. {
  2943. SetMotionMode(CRaceMotionData::MODE_FISHING);
  2944. }
  2945. }
  2946. else if (m_kHorse.IsMounting())
  2947. {
  2948. switch (bySubType)
  2949. {
  2950. case CItemData::COSTUME_WEAPON_SWORD:
  2951. case CItemData::WEAPON_SWORD:
  2952. SetMotionMode(CRaceMotionData::MODE_HORSE_ONEHAND_SWORD);
  2953. break;
  2954.  
  2955. case CItemData::COSTUME_WEAPON_TWO_HANDED:
  2956. case CItemData::WEAPON_TWO_HANDED:
  2957. SetMotionMode(CRaceMotionData::MODE_HORSE_TWOHAND_SWORD); // Only Warrior
  2958. break;
  2959.  
  2960. case CItemData::COSTUME_WEAPON_DAGGER:
  2961. case CItemData::WEAPON_DAGGER:
  2962. SetMotionMode(CRaceMotionData::MODE_HORSE_DUALHAND_SWORD); // Only Assassin
  2963. break;
  2964.  
  2965. case CItemData::COSTUME_WEAPON_FAN:
  2966. case CItemData::WEAPON_FAN:
  2967. SetMotionMode(CRaceMotionData::MODE_HORSE_FAN); // Only Shaman
  2968. break;
  2969.  
  2970. case CItemData::COSTUME_WEAPON_BELL:
  2971. case CItemData::WEAPON_BELL:
  2972. SetMotionMode(CRaceMotionData::MODE_HORSE_BELL); // Only Shaman
  2973. break;
  2974.  
  2975. case CItemData::COSTUME_WEAPON_BOW:
  2976. case CItemData::WEAPON_BOW:
  2977. SetMotionMode(CRaceMotionData::MODE_HORSE_BOW); // Only Shaman
  2978. break;
  2979.  
  2980. default:
  2981. SetMotionMode(CRaceMotionData::MODE_HORSE);
  2982. break;
  2983. }
  2984. }
  2985. else
  2986. {
  2987. switch (bySubType)
  2988. {
  2989. case CItemData::COSTUME_WEAPON_SWORD:
  2990. case CItemData::WEAPON_SWORD:
  2991. SetMotionMode(CRaceMotionData::MODE_ONEHAND_SWORD);
  2992. break;
  2993.  
  2994. case CItemData::COSTUME_WEAPON_TWO_HANDED:
  2995. case CItemData::WEAPON_TWO_HANDED:
  2996. SetMotionMode(CRaceMotionData::MODE_TWOHAND_SWORD); // Only Warrior
  2997. break;
  2998.  
  2999. case CItemData::COSTUME_WEAPON_DAGGER:
  3000. case CItemData::WEAPON_DAGGER:
  3001. SetMotionMode(CRaceMotionData::MODE_DUALHAND_SWORD); // Only Assassin
  3002. break;
  3003.  
  3004. case CItemData::COSTUME_WEAPON_BOW:
  3005. case CItemData::WEAPON_BOW:
  3006. SetMotionMode(CRaceMotionData::MODE_BOW); // Only Assassin
  3007. break;
  3008.  
  3009. case CItemData::COSTUME_WEAPON_FAN:
  3010. case CItemData::WEAPON_FAN:
  3011. SetMotionMode(CRaceMotionData::MODE_FAN); // Only Shaman
  3012. break;
  3013.  
  3014. case CItemData::COSTUME_WEAPON_BELL:
  3015. case CItemData::WEAPON_BELL:
  3016. SetMotionMode(CRaceMotionData::MODE_BELL); // Only Shaman
  3017. break;
  3018.  
  3019. case CItemData::WEAPON_ARROW:
  3020. default:
  3021. SetMotionMode(CRaceMotionData::MODE_GENERAL);
  3022. break;
  3023. }
  3024. }
  3025.  
  3026. if (isLoop)
  3027. m_GraphicThingInstance.InterceptLoopMotion(dwMotIndex);
  3028. else
  3029. m_GraphicThingInstance.InterceptOnceMotion(dwMotIndex);
  3030.  
  3031. RefreshActorInstance();
  3032. }
  3033.  
  3034. ///////////////////////////////////////////////////////////////////////////////////////////////////
  3035. // Device
  3036.  
  3037. void CInstanceBase::RegisterBoundingSphere()
  3038. {
  3039. // Stone 일 경우 DeforomNoSkin 을 하면
  3040. // 낙하하는 애니메이션 같은 경우 애니메이션이
  3041. // 바운드 박스에 영향을 미쳐 컬링이 제대로 이루어지지 않는다.
  3042. if (!IsStone())
  3043. {
  3044. m_GraphicThingInstance.DeformNoSkin();
  3045. }
  3046.  
  3047. m_GraphicThingInstance.RegisterBoundingSphere();
  3048. }
  3049.  
  3050. bool CInstanceBase::CreateDeviceObjects()
  3051. {
  3052. return m_GraphicThingInstance.CreateDeviceObjects();
  3053. }
  3054.  
  3055. void CInstanceBase::DestroyDeviceObjects()
  3056. {
  3057. m_GraphicThingInstance.DestroyDeviceObjects();
  3058. }
  3059.  
  3060. void CInstanceBase::Destroy()
  3061. {
  3062. DetachTextTail();
  3063.  
  3064. DismountHorse();
  3065.  
  3066. m_kQue_kCmdNew.clear();
  3067.  
  3068. __EffectContainer_Destroy();
  3069. __StoneSmoke_Destroy();
  3070.  
  3071. if (__IsMainInstance())
  3072. __ClearMainInstance();
  3073.  
  3074. m_GraphicThingInstance.Destroy();
  3075.  
  3076. __Initialize();
  3077. }
  3078.  
  3079. void CInstanceBase::__InitializeRotationSpeed()
  3080. {
  3081. SetRotationSpeed(c_fDefaultRotationSpeed);
  3082. }
  3083.  
  3084. void CInstanceBase::__Warrior_Initialize()
  3085. {
  3086. m_kWarrior.m_dwGeomgyeongEffect=0;
  3087. }
  3088.  
  3089. void CInstanceBase::__Initialize()
  3090. {
  3091. __Warrior_Initialize();
  3092. __StoneSmoke_Inialize();
  3093. __EffectContainer_Initialize();
  3094. __InitializeRotationSpeed();
  3095.  
  3096. SetEventHandler(CActorInstance::IEventHandler::GetEmptyPtr());
  3097.  
  3098. m_kAffectFlagContainer.Clear();
  3099.  
  3100. m_dwLevel = 0;
  3101. m_dwGuildID = 0;
  3102. m_dwEmpireID = 0;
  3103.  
  3104. m_eType = 0;
  3105. m_eRaceType = 0;
  3106. m_eShape = 0;
  3107. m_dwRace = 0;
  3108. m_dwVirtualNumber = 0;
  3109.  
  3110. m_dwBaseCmdTime=0;
  3111. m_dwBaseChkTime=0;
  3112. m_dwSkipTime=0;
  3113.  
  3114. m_GraphicThingInstance.Initialize();
  3115.  
  3116. m_dwAdvActorVID=0;
  3117. m_dwLastDmgActorVID=0;
  3118.  
  3119. m_nAverageNetworkGap=0;
  3120. m_dwNextUpdateHeightTime=0;
  3121.  
  3122. // Moving by keyboard
  3123. m_iRotatingDirection = DEGREE_DIRECTION_SAME;
  3124.  
  3125. // Moving by mouse
  3126. m_isTextTail = FALSE;
  3127. m_isGoing = FALSE;
  3128. NEW_SetSrcPixelPosition(TPixelPosition(0, 0, 0));
  3129. NEW_SetDstPixelPosition(TPixelPosition(0, 0, 0));
  3130.  
  3131. m_kPPosDust = TPixelPosition(0, 0, 0);
  3132.  
  3133.  
  3134. m_kQue_kCmdNew.clear();
  3135.  
  3136. m_dwLastComboIndex = 0;
  3137.  
  3138. m_swordRefineEffectRight = 0;
  3139. m_swordRefineEffectLeft = 0;
  3140. m_armorRefineEffect = 0;
  3141. m_dwSashEffect = 0;
  3142.  
  3143. m_sAlignment = 0;
  3144. m_iTitleID = 0;
  3145. m_byPKMode = 0;
  3146. m_isKiller = false;
  3147. m_isPartyMember = false;
  3148.  
  3149. m_bEnableTCPState = TRUE;
  3150.  
  3151. m_stName = "";
  3152.  
  3153. memset(m_awPart, 0, sizeof(m_awPart));
  3154. memset(m_adwCRCAffectEffect, 0, sizeof(m_adwCRCAffectEffect));
  3155. //memset(m_adwCRCEmoticonEffect, 0, sizeof(m_adwCRCEmoticonEffect));
  3156. memset(&m_kMovAfterFunc, 0, sizeof(m_kMovAfterFunc));
  3157.  
  3158. m_bDamageEffectType = false;
  3159. m_dwDuelMode = DUEL_NONE;
  3160. m_dwEmoticonTime = 0;
  3161. }
  3162.  
  3163. CInstanceBase::CInstanceBase()
  3164. {
  3165. __Initialize();
  3166. }
  3167.  
  3168. CInstanceBase::~CInstanceBase()
  3169. {
  3170. Destroy();
  3171. }
  3172.  
  3173.  
  3174. void CInstanceBase::GetBoundBox(D3DXVECTOR3 * vtMin, D3DXVECTOR3 * vtMax)
  3175. {
  3176. m_GraphicThingInstance.GetBoundBox(vtMin, vtMax);
  3177. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!