API tools faq
paste
Advertisement
Guest User

pythonplayerinput.cpp

a guest
Dec 12th, 2019
146
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 23.72 KB | None | 0 0
raw download clone embed print report
  1. #include "StdAfx.h"
  2. #include "PythonPlayer.h"
  3. #include "PythonPlayerEventHandler.h"
  4. #include "PythonApplication.h"
  5. #include "../eterlib/Camera.h"
  6. #include "../eterbase/Timer.h"
  7.  
  8. const int c_iFastestSendingCount = 3;
  9. const int c_iSlowestSendingCount = 3;
  10. const float c_fFastestSendingDelay = 1.0f / float(c_iFastestSendingCount);
  11. const float c_fSlowestSendingDelay = 1.0f / float(c_iSlowestSendingCount);
  12. const float c_fRotatingStepTime = 0.5f;
  13.  
  14. const float c_fComboDistance = 250.0f;
  15. const float c_fClickDistance = 300.0f;
  16.  
  17. DWORD CPythonPlayer::__GetPickableDistance()
  18. {
  19.     CInstanceBase * pkInstMain = NEW_GetMainActorPtr();
  20.     if (pkInstMain)
  21.         if (pkInstMain->IsMountingHorse())
  22.             return 500;
  23.  
  24.     return 300;
  25. }
  26.  
  27. void CPythonPlayer::PickCloseMoney()
  28. {
  29.     CInstanceBase * pkInstMain = NEW_GetMainActorPtr();
  30.     if (!pkInstMain)
  31.         return;
  32.  
  33.     TPixelPosition kPPosMain;
  34.     pkInstMain->NEW_GetPixelPosition(&kPPosMain);
  35.  
  36.     DWORD dwItemID;
  37.     CPythonItem& rkItem=CPythonItem::Instance();
  38.     if (!rkItem.GetCloseMoney(kPPosMain, &dwItemID, __GetPickableDistance()))
  39.         return;
  40.  
  41.     SendClickItemPacket(dwItemID);
  42. }
  43.  
  44. void CPythonPlayer::PickCloseItem()
  45. {
  46.     CInstanceBase * pkInstMain = NEW_GetMainActorPtr();
  47.     if (!pkInstMain)
  48.         return;
  49.  
  50.     TPixelPosition kPPosMain;
  51.     pkInstMain->NEW_GetPixelPosition(&kPPosMain);
  52.  
  53.     DWORD dwItemID;
  54.     CPythonItem& rkItem=CPythonItem::Instance();
  55.     if (!rkItem.GetCloseItem(kPPosMain, &dwItemID, __GetPickableDistance()))
  56.         return;
  57.  
  58.     SendClickItemPacket(dwItemID);
  59. }
  60.  
  61. void CPythonPlayer::PickCloseItemVector()
  62. {
  63.     CInstanceBase * pkInstMain = NEW_GetMainActorPtr();
  64.     if (!pkInstMain)
  65.         return;
  66.  
  67.     TPixelPosition kPPosMain;
  68.     pkInstMain->NEW_GetPixelPosition(&kPPosMain);
  69.  
  70.     std::vector<DWORD> itemVidList;
  71.    
  72.     CPythonItem& rkItem=CPythonItem::Instance();
  73.     if (!rkItem.GetCloseItemVector(pkInstMain->GetNameString(), kPPosMain, itemVidList))
  74.         return;
  75.    
  76.     if(itemVidList.empty())
  77.         return;
  78.    
  79.     for(int i = 0; i < itemVidList.size(); i++)
  80.         SendClickItemPacket(itemVidList[i]);
  81. }
  82.  
  83. bool CPythonPlayer::__IsTarget()
  84. {
  85.     return 0 != __GetTargetVID();
  86. }
  87.  
  88. bool CPythonPlayer::__IsSameTargetVID(DWORD dwVID)
  89. {
  90.     return dwVID == __GetTargetVID();
  91. }
  92.  
  93. DWORD CPythonPlayer::__GetTargetVID()
  94. {
  95.     return m_dwTargetVID;
  96. }
  97.  
  98. DWORD CPythonPlayer::GetTargetVID()
  99. {
  100.     return __GetTargetVID();
  101. }
  102.  
  103.  
  104. CInstanceBase* CPythonPlayer::__GetTargetActorPtr()
  105. {
  106.     return NEW_FindActorPtr(__GetTargetVID());
  107. }
  108.  
  109. void CPythonPlayer::__SetTargetVID(DWORD dwVID)
  110. {
  111.     m_dwTargetVID=dwVID;
  112. }
  113.  
  114. void CPythonPlayer::__ClearTarget()
  115. {
  116.     if (!__IsTarget())
  117.         return;
  118.  
  119.     CInstanceBase * pkInstMain = NEW_GetMainActorPtr();
  120.     if (!pkInstMain)
  121.         return;
  122.  
  123.     pkInstMain->ClearFlyTargetInstance();
  124.  
  125.     CInstanceBase * pTargetedInstance = __GetTargetActorPtr();
  126.     if (pTargetedInstance)
  127.         pTargetedInstance->OnUntargeted();
  128.  
  129.     __SetTargetVID(0);
  130.  
  131.     CPythonNetworkStream::Instance().SendTargetPacket(0);
  132. }
  133.  
  134. void CPythonPlayer::SetTarget(DWORD dwVID, BOOL bForceChange)
  135. {
  136.     CInstanceBase * pkInstMain = NEW_GetMainActorPtr();
  137.     if (!pkInstMain)
  138.         return;
  139.  
  140.     // 2004. 07. 07. [levites] - 스킬 사용중 타겟이 바뀌는 문제 해결을 위한 코드
  141.     if (!pkInstMain->CanChangeTarget())
  142.     {
  143.         return;
  144.     }
  145.  
  146.     DWORD dwCurrentTime = CTimer::Instance().GetCurrentMillisecond();
  147.  
  148.     if (__IsSameTargetVID(dwVID))
  149.     {
  150.         if (dwVID==pkInstMain->GetVirtualID())
  151.         {
  152.             __SetTargetVID(0);
  153.            
  154.             pkInstMain->OnUntargeted();
  155.             pkInstMain->ClearFlyTargetInstance();
  156.             CPythonNetworkStream::Instance().SendTargetPacket(0);
  157.             return;
  158.         }
  159.         m_dwTargetEndTime = dwCurrentTime + 1000;
  160.         return;
  161.     }
  162.  
  163.     if (bForceChange)
  164.     {
  165.         m_dwTargetEndTime = dwCurrentTime + 2000;
  166.     }
  167.     else
  168.     {
  169.         if (m_dwTargetEndTime > dwCurrentTime)
  170.         {
  171.             return;
  172.         }
  173.  
  174.         m_dwTargetEndTime = dwCurrentTime + 1000;
  175.     }
  176.  
  177.     if (__IsTarget())
  178.     {
  179.         CInstanceBase * pTargetedInstance = __GetTargetActorPtr();
  180.         if (pTargetedInstance)
  181.             pTargetedInstance->OnUntargeted();
  182.     }
  183.    
  184.  
  185.     CInstanceBase * pkInstTarget = CPythonCharacterManager::Instance().GetInstancePtr(dwVID);
  186.     if (pkInstTarget)
  187.     {
  188.         if (pkInstMain->IsTargetableInstance(*pkInstTarget))
  189.         {
  190.             __SetTargetVID(dwVID);
  191.            
  192.             pkInstTarget->OnTargeted();
  193.             pkInstMain->SetFlyTargetInstance(*pkInstTarget);
  194.             pkInstMain->GetGraphicThingInstanceRef().SetFlyEventHandler(CPythonPlayerEventHandler::GetSingleton().GetNormalBowAttackFlyEventHandler(pkInstMain, pkInstTarget));
  195.             CPythonNetworkStream::Instance().SendTargetPacket(dwVID);
  196.  
  197.             return;
  198.         }
  199.     }
  200.  
  201.     __SetTargetVID(0);
  202.    
  203.     pkInstMain->ClearFlyTargetInstance();
  204.     CPythonNetworkStream::Instance().SendTargetPacket(0);
  205.    
  206. }
  207.  
  208. bool CPythonPlayer::__ChangeTargetToPickedInstance()
  209. {
  210.     DWORD dwVID;
  211.     if (!CPythonCharacterManager::Instance().OLD_GetPickedInstanceVID(&dwVID))
  212.         return false;
  213.  
  214.     SetTarget(dwVID);
  215.     return true;
  216. }
  217.  
  218. CInstanceBase * CPythonPlayer::__GetSkillTargetInstancePtr(CPythonSkill::TSkillData& rkSkillData)
  219. {
  220.     if (rkSkillData.IsNeedCorpse())
  221.         return __GetDeadTargetInstancePtr();
  222.  
  223.     return __GetAliveTargetInstancePtr();
  224. }
  225.  
  226. CInstanceBase * CPythonPlayer::__GetDeadTargetInstancePtr()
  227. {
  228.     if (!__IsTarget())
  229.         return NULL;
  230.  
  231.     CInstanceBase * pkInstTarget = __GetTargetActorPtr();
  232.  
  233.     if (!pkInstTarget)
  234.         return NULL;
  235.  
  236.     if (!pkInstTarget->IsDead())
  237.         return NULL;
  238.  
  239.     return pkInstTarget;
  240. }
  241.  
  242. CInstanceBase * CPythonPlayer::__GetAliveTargetInstancePtr()
  243. {
  244.     if (!__IsTarget())
  245.         return NULL;
  246.  
  247.     CInstanceBase * pkInstTarget = __GetTargetActorPtr();
  248.  
  249.     if (!pkInstTarget)
  250.         return NULL;
  251.  
  252.     if (pkInstTarget->IsDead())
  253.         return NULL;
  254.  
  255.     return pkInstTarget;
  256. }
  257.  
  258.  
  259. void CPythonPlayer::OpenCharacterMenu(DWORD dwVictimActorID)
  260. {
  261.     CInstanceBase * pkInstMain = CPythonPlayer::Instance().NEW_GetMainActorPtr();
  262.     if (!pkInstMain)
  263.         return;
  264.  
  265.     CInstanceBase * pkInstTarget = CPythonCharacterManager::Instance().GetInstancePtr(dwVictimActorID);
  266.     if (!pkInstTarget)
  267.         return;
  268.  
  269.     if (!pkInstTarget->IsPC() && !pkInstTarget->IsBuilding())
  270.         return;
  271.  
  272. //  if (pkInstMain == pkInstTarget)
  273. //      return;
  274.  
  275.     PyCallClassMemberFunc(m_ppyGameWindow, "SetPCTargetBoard", Py_BuildValue("(is)", pkInstTarget->GetVirtualID(), pkInstTarget->GetNameString()));
  276. }
  277.  
  278. void CPythonPlayer::__OnClickItem(CInstanceBase& rkInstMain, DWORD dwItemID)
  279. {
  280. }
  281.  
  282. void CPythonPlayer::__OnClickActor(CInstanceBase& rkInstMain, DWORD dwPickedActorID, bool isAuto)
  283. {
  284.     // 만약 스킬을 써서 접근중이라면..
  285.     if (MODE_USE_SKILL == m_eReservedMode)
  286.     {
  287.         // 같은 캐릭터를 클릭 했으면 리턴
  288.         if (__GetTargetVID() == dwPickedActorID)
  289.             return;
  290.  
  291.         // 2005.03.25.levites
  292.         // 탄환격을 쓰고 달려가는중 공격할 수 있는 다른 타겟을 클릭하면
  293.         if (__CheckDashAffect(rkInstMain))
  294.         {
  295.             m_dwVIDReserved = dwPickedActorID;
  296.             return;
  297.         }
  298.     }
  299.  
  300.     __ClearReservedAction();
  301.  
  302.     CInstanceBase* pkInstVictim=NEW_FindActorPtr(dwPickedActorID);
  303.     CInstanceBase& rkInstVictim=*pkInstVictim;
  304.     if (!pkInstVictim)
  305.         return;
  306.    
  307.     // 2005.01.28.myevan
  308.     // 초급말 상태에서는 공격이 안되나 NPC 클릭이되어야함
  309.     if (rkInstMain.IsAttackableInstance(*pkInstVictim))
  310.         if (!__CanAttack())
  311.             return;
  312.  
  313.     if (!rkInstMain.NEW_IsClickableDistanceDestInstance(rkInstVictim))
  314.     {
  315.         __ReserveClickActor(dwPickedActorID);
  316.         return;
  317.     }
  318.  
  319.     if (rkInstVictim.IsNPC())
  320.     {
  321.         __SendClickActorPacket(rkInstVictim);
  322.     }
  323.  
  324.     rkInstMain.NEW_Stop();
  325.     return;
  326. }
  327.  
  328. void CPythonPlayer::__OnPressActor(CInstanceBase& rkInstMain, DWORD dwPickedActorID, bool isAuto)
  329. {
  330.     // 만약 스킬을 써서 접근중이라면..
  331.     if (MODE_USE_SKILL == m_eReservedMode)
  332.     {
  333.         // 같은 캐릭터를 클릭 했으면 리턴
  334.         if (__GetTargetVID() == dwPickedActorID)
  335.             return;
  336.  
  337.         // 2005.03.25.levites
  338.         // 탄환격을 쓰고 달려가는중 공격할 수 있는 다른 타겟을 클릭하면
  339.         if (__CheckDashAffect(rkInstMain))
  340.         {
  341.             m_dwVIDReserved = dwPickedActorID;
  342.             return;
  343.         }
  344.     }
  345.  
  346.     __ChangeTargetToPickedInstance();
  347.     __ClearReservedAction();
  348.  
  349.     if (!__CanAttack())
  350.         return;
  351.  
  352.     CInstanceBase* pkInstVictim=NEW_FindActorPtr(dwPickedActorID);
  353.     if (!pkInstVictim)
  354.         return;
  355.  
  356.     CInstanceBase& rkInstVictim=*pkInstVictim;
  357.  
  358.     if (isAuto)
  359.     {
  360.         // 2004.10.21.myevan.공격가능한 상대만 자동 공격
  361.         if (rkInstMain.IsAttackableInstance(rkInstVictim))
  362.             __SetAutoAttackTargetActorID(rkInstVictim.GetVirtualID());
  363.     }
  364.  
  365.     if (rkInstMain.IsBowMode())
  366.     {
  367.         if (rkInstMain.IsAttackableInstance(rkInstVictim))
  368.             if (!__CanShot(rkInstMain, rkInstVictim))
  369.                 return;
  370.     }
  371.  
  372.     if (!rkInstMain.NEW_IsClickableDistanceDestInstance(rkInstVictim))
  373.     {
  374.         __ReserveClickActor(dwPickedActorID);
  375.         return;
  376.     }
  377.  
  378.     if (!rkInstMain.IsAttackableInstance(rkInstVictim))
  379.     {
  380.         return;
  381.     }
  382.  
  383.     CPythonPlayerEventHandler& rkPlayerEventHandler=CPythonPlayerEventHandler::GetSingleton();
  384.     rkInstMain.NEW_AttackToDestInstanceDirection(rkInstVictim, rkPlayerEventHandler.GetNormalBowAttackFlyEventHandler(&rkInstMain, &rkInstVictim));
  385. }
  386.  
  387. void CPythonPlayer::__OnPressItem(CInstanceBase& rkInstMain, DWORD dwPickedItemID)
  388. {
  389.     static DWORD s_dwLastPickItemID=0;
  390.  
  391.     if (s_dwLastPickItemID==dwPickedItemID)
  392.     {
  393.         Logn(1, "CPythonPlayer::__OnPressItem - ALREADY PICKED ITEM");
  394.         return;
  395.     }
  396.  
  397.     __ClearReservedAction();
  398.     __ClearAutoAttackTargetActorID();
  399.  
  400.     CPythonItem& rkItem=CPythonItem::Instance();
  401.  
  402.     TPixelPosition kPPosPickedItem;
  403.     if (!rkItem.GetGroundItemPosition(dwPickedItemID, &kPPosPickedItem))
  404.         return;
  405.  
  406.     if (!rkInstMain.NEW_IsClickableDistanceDestPixelPosition(kPPosPickedItem))
  407.     {
  408.         __ReserveClickItem(dwPickedItemID);
  409.         return;
  410.     }
  411.  
  412.     rkInstMain.NEW_Stop();
  413.     SendClickItemPacket(dwPickedItemID);
  414. }
  415.  
  416. void CPythonPlayer::__OnClickGround(CInstanceBase& rkInstMain, const TPixelPosition& c_rkPPosPickedGround)
  417. {
  418.     if (!__IsMovableGroundDistance(rkInstMain, c_rkPPosPickedGround))
  419.         return;
  420.  
  421.     if (rkInstMain.NEW_MoveToDestPixelPositionDirection(c_rkPPosPickedGround))
  422.         __ShowPickedEffect(c_rkPPosPickedGround);
  423. }
  424.  
  425. void CPythonPlayer::SetMovableGroundDistance(float fDistance)
  426. {
  427.     MOVABLE_GROUND_DISTANCE=fDistance;
  428. }
  429.  
  430. bool CPythonPlayer::__IsMovableGroundDistance(CInstanceBase& rkInstMain, const TPixelPosition& c_rkPPosPickedGround)
  431. {  
  432.     float fDistance=rkInstMain.NEW_GetDistanceFromDestPixelPosition(c_rkPPosPickedGround); 
  433.  
  434.     if (fDistance<MOVABLE_GROUND_DISTANCE)
  435.         return false;
  436.  
  437.     //Tracef("IsMovableGroundDistance(%f)\n", fDistance);
  438.     return true;
  439. }
  440.  
  441. void CPythonPlayer::__OnPressGround(CInstanceBase& rkInstMain, const TPixelPosition& c_rkPPosPickedGround)
  442. {
  443.     __ClearReservedAction();
  444.     __ClearAutoAttackTargetActorID();
  445.  
  446.     if (NEW_CancelFishing())
  447.         return;
  448.  
  449.     if (!__IsMovableGroundDistance(rkInstMain, c_rkPPosPickedGround))
  450.         return;
  451.  
  452.     if (!rkInstMain.NEW_MoveToDestPixelPositionDirection(c_rkPPosPickedGround))
  453.     {
  454.         __ReserveClickGround(c_rkPPosPickedGround);
  455.         return;
  456.     }
  457. }
  458.  
  459. void CPythonPlayer::__OnPressScreen(CInstanceBase& rkInstMain)
  460. {
  461.     __ClearReservedAction();
  462.  
  463.     NEW_MoveToMouseScreenDirection();
  464. }
  465.  
  466.  
  467. bool CPythonPlayer::NEW_MoveToDirection(float fDirRot)
  468. {
  469.     // PrivateShop
  470.     if (IsOpenPrivateShop())
  471.         return true;
  472.  
  473.     __ClearReservedAction();
  474.  
  475.     CInstanceBase* pkInstMain=NEW_GetMainActorPtr();
  476.     if (!pkInstMain)
  477.         return false;
  478.  
  479.     if (pkInstMain->isLock())
  480.         if (!pkInstMain->IsUsingMovingSkill())
  481.             return true;
  482.  
  483.     CCamera* pkCmrCur=CCameraManager::Instance().GetCurrentCamera();
  484.     if (pkCmrCur)
  485.     {
  486.         float fCmrCurRot=CameraRotationToCharacterRotation(pkCmrCur->GetRoll());
  487.  
  488.         // 현재
  489.         if (m_isCmrRot)
  490.         {
  491.             float fSigDirRot=fDirRot;
  492.             if (fSigDirRot>180.0f)
  493.                 fSigDirRot=fSigDirRot-360.0f;
  494.  
  495.             float fRotRat=fSigDirRot;
  496.             if (fRotRat>90.0f)
  497.                 fRotRat=(180.0f-fRotRat);
  498.             else if (fRotRat<-90.0f)
  499.                 fRotRat=(-180.0f-fRotRat);
  500.  
  501.             float fElapsedTime = CPythonApplication::Instance().GetGlobalElapsedTime();
  502.  
  503.             float fRotDeg = -m_fCmrRotSpd * fElapsedTime * fRotRat / 90.0f;
  504.             pkCmrCur->Roll(fRotDeg);
  505.         }
  506.  
  507.         fDirRot=fmod(360.0f + fCmrCurRot + fDirRot, 360.0f);
  508.     }
  509.  
  510.     pkInstMain->NEW_MoveToDirection(fDirRot);
  511.  
  512.     return true;
  513. }
  514.  
  515. void CPythonPlayer::NEW_Stop()
  516. {
  517.     CInstanceBase* pkInstMain=NEW_GetMainActorPtr();
  518.     if (!pkInstMain)
  519.         return;
  520.  
  521.     pkInstMain->NEW_Stop();
  522.     m_isLeft = FALSE;
  523.     m_isRight = FALSE;
  524.     m_isUp = FALSE;
  525.     m_isDown = FALSE;
  526. }
  527.  
  528. bool CPythonPlayer::NEW_CancelFishing()
  529. {
  530.     CInstanceBase* pkInstMain = NEW_GetMainActorPtr();
  531.     if (!pkInstMain)
  532.         return false;
  533.  
  534.     if (pkInstMain->IsFishing())
  535.     {
  536.         static DWORD s_dwLastCancelTime = 0;
  537.         if (CTimer::Instance().GetCurrentMillisecond() < s_dwLastCancelTime + 500)
  538.             return false;
  539.  
  540.         CPythonNetworkStream::Instance().SendFishingPacket(0);
  541.         s_dwLastCancelTime = CTimer::Instance().GetCurrentMillisecond();
  542.         return true;
  543.     }
  544.  
  545.     return false;
  546. }
  547.  
  548. void CPythonPlayer::NEW_Fishing()
  549. {
  550.     CInstanceBase* pkInstMain = NEW_GetMainActorPtr();
  551.     if (!pkInstMain)
  552.         return;
  553.  
  554.     if (pkInstMain->IsFishing())
  555.     {
  556.         CPythonNetworkStream::Instance().SendFishingPacket(0);
  557.     }
  558.     else
  559.     {
  560.         if (pkInstMain->CanFishing())
  561.         {
  562.             int irot;
  563.             if (pkInstMain->GetFishingRot(&irot))
  564.                 CPythonNetworkStream::Instance().SendFishingPacket(irot);
  565.             else
  566.             {
  567.                 PyCallClassMemberFunc(m_ppyGameWindow, "OnFishingWrongPlace", Py_BuildValue("()"));
  568.             }
  569.         }
  570.     }
  571. }
  572.  
  573. void CPythonPlayer::NEW_Attack()
  574. {
  575.     // PrivateShop
  576.     if (IsOpenPrivateShop())
  577.         return;
  578.  
  579.     if (!__CanAttack())
  580.         return;
  581.  
  582.     CInstanceBase* pkInstMain = NEW_GetMainActorPtr();
  583.     if (!pkInstMain)
  584.         return;
  585.  
  586.     if (pkInstMain->IsBowMode())
  587.     {
  588.         //CPythonPlayerEventHandler& rkPlayerEventHandler=CPythonPlayerEventHandler::GetSingleton();
  589.  
  590.         CInstanceBase * pkInstTarget = __GetAliveTargetInstancePtr();
  591.         if (!pkInstTarget)
  592.         {
  593.             __ChangeTargetToPickedInstance();
  594.             pkInstTarget = __GetAliveTargetInstancePtr();
  595.         }
  596.  
  597.         if (pkInstTarget)
  598.         {
  599.             if (!__CanShot(*pkInstMain, *pkInstTarget))
  600.                 return;
  601.  
  602.             if (!pkInstMain->NEW_IsClickableDistanceDestInstance(*pkInstTarget))
  603.             {
  604.                 __ReserveClickActor(pkInstTarget->GetVirtualID());
  605.                 return;
  606.             }
  607.  
  608.             if (pkInstMain->IsAttackableInstance(*pkInstTarget))
  609.             {
  610.                 pkInstMain->NEW_LookAtDestInstance(*pkInstTarget);
  611.                 pkInstMain->NEW_AttackToDestInstanceDirection(*pkInstTarget);
  612.             }
  613.         }
  614.         else
  615.         {
  616.             PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotUseSkill", Py_BuildValue("(is)", GetMainCharacterIndex(), "NEED_TARGET"));
  617.             return;
  618.         }
  619.     }
  620.     else if (m_isDirKey)
  621.     {
  622.         float fDirRot=0.0f;
  623.         NEW_GetMultiKeyDirRotation(m_isLeft, m_isRight, m_isUp, m_isDown, &fDirRot);
  624.  
  625.         CCamera* pkCmrCur=CCameraManager::Instance().GetCurrentCamera();
  626.         if (pkCmrCur)
  627.         {
  628.             float fCmrCurRot=CameraRotationToCharacterRotation(pkCmrCur->GetRoll());
  629.  
  630.             fDirRot=fmod(360.0f + fCmrCurRot + fDirRot, 360.0f);
  631.         }
  632.  
  633.         pkInstMain->NEW_Attack(fDirRot);
  634.     }
  635.     else
  636.     {
  637.         //!@# 말에 탄 상태에서 맨손 공격은 지원되지 않는다 - [levites]
  638.         if (pkInstMain->IsMountingHorse())
  639.         {
  640.             if (pkInstMain->IsHandMode())
  641.                 return;
  642.         }
  643.  
  644.         pkInstMain->NEW_Attack();
  645.     }
  646. }
  647.  
  648. bool CPythonPlayer::NEW_IsEmptyReservedDelayTime(float fElapsedTime)
  649. {
  650.     m_fReservedDelayTime -= fElapsedTime;
  651.  
  652.     if (m_fReservedDelayTime <= 0.0f)
  653.     {
  654.         m_fReservedDelayTime = 0.0f;
  655.         return true;
  656.     }
  657.  
  658.     return false;
  659. }
  660.  
  661.  
  662. void CPythonPlayer::NEW_SetAutoCameraRotationSpeed(float fRotSpd)
  663. {
  664.     m_fCmrRotSpd=fRotSpd;
  665. }
  666.  
  667. void CPythonPlayer::NEW_ResetCameraRotation()
  668. {
  669.     CCamera* pkCmrCur=CCameraManager::Instance().GetCurrentCamera();
  670.     CPythonApplication & rkApp = CPythonApplication::Instance();
  671.  
  672.     pkCmrCur->EndDrag();
  673.  
  674.     rkApp.SetCursorNum(CPythonApplication::NORMAL);
  675.     if ( CPythonApplication::CURSOR_MODE_HARDWARE == rkApp.GetCursorMode())
  676.         rkApp.SetCursorVisible(TRUE);
  677. }
  678.  
  679.  
  680. bool CPythonPlayer::__CanShot(CInstanceBase& rkInstMain, CInstanceBase& rkInstTarget)
  681. {
  682.     if (!__HasEnoughArrow())
  683.     {
  684.         PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotShot", Py_BuildValue("(is)", GetMainCharacterIndex(), "EMPTY_ARROW"));
  685.         return false;
  686.     }
  687.  
  688.     if (rkInstMain.IsInSafe())
  689.     {
  690.         PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotShot", Py_BuildValue("(is)", GetMainCharacterIndex(), "IN_SAFE"));
  691.         return false;
  692.     }
  693.  
  694.     if (rkInstTarget.IsInSafe())
  695.     {
  696.         PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotShot", Py_BuildValue("(is)", GetMainCharacterIndex(), "DEST_IN_SAFE"));
  697.         return false;
  698.     }  
  699.  
  700.     return true;
  701. }
  702.  
  703. bool CPythonPlayer::__CanChangeTarget()
  704. {
  705.     CInstanceBase* pkInstMain=NEW_GetMainActorPtr();
  706.     if (!pkInstMain)
  707.         return false;
  708.  
  709.     return pkInstMain->CanChangeTarget();
  710. }
  711.  
  712. bool CPythonPlayer::__CanMove()
  713. {
  714.     if (__IsProcessingEmotion())
  715.     {
  716.         return false;
  717.     }
  718.  
  719.     CInstanceBase* pkInstMain=NEW_GetMainActorPtr();
  720.     if (!pkInstMain)
  721.         return false;
  722.  
  723.     if (!pkInstMain->CanMove())
  724.     {
  725.         if (!pkInstMain->IsUsingMovingSkill())
  726.             return false;
  727.     }
  728.  
  729.     return true;
  730. }
  731. /*
  732. bool CPythonPlayer::__OLD_CanMove()
  733. {
  734.     if (__IsProcessingEmotion())
  735.     {
  736.         return false;
  737.     }
  738.  
  739.     CInstanceBase* pkInstMain=NEW_GetMainActorPtr();
  740.     if (!pkInstMain)
  741.         return false;
  742.  
  743.     if (pkInstMain->IsDead())
  744.         return false;
  745.  
  746.     if (pkInstMain->IsStun())
  747.         return false;
  748.  
  749.     if (pkInstMain->isLock())
  750.         return false;
  751.  
  752.     if (pkInstMain->IsParalysis())
  753.         return false;
  754.  
  755.     return true;
  756. }
  757. */
  758.  
  759. bool CPythonPlayer::__CanAttack()
  760. {
  761.     if (__IsProcessingEmotion())
  762.     {
  763.         return false;
  764.     }
  765.  
  766.     if (IsOpenPrivateShop())
  767.         return false;
  768.  
  769.     if (IsObserverMode())
  770.         return false;
  771.  
  772.     CInstanceBase* pkInstMain=NEW_GetMainActorPtr();
  773.     if (!pkInstMain)
  774.         return false;
  775.    
  776.     // Fix me
  777.     // 뉴마운트 25레벨 이상 35레벨 미만인 경우 중급 마운트를 타고 공격못하도록 하드 코딩...
  778.     // 나중에 시간 나면 can attack 체크를 서버에서 해주자...
  779.     // ㅡ_ㅡ unique 슬롯에 차는 탈것은 이 조건이랑 관계없이 공격할 수 있어야 한다 ㅡ_ㅡ
  780.     // ㅡ_ㅡ 뉴마운트만 이 체크를 하게 함... ㅡ_ㅡ_ㅡ_ㅡ_ㅡ
  781.     if (pkInstMain->IsMountingHorse() && pkInstMain->IsNewMount() && (GetSkillGrade(109) < 1 && GetSkillLevel(109) < 11))
  782.     {
  783.         return false;
  784.     }
  785.  
  786.     return pkInstMain->CanAttack();
  787. }
  788.  
  789. void CPythonPlayer::NEW_GetMultiKeyDirRotation(bool isLeft, bool isRight, bool isUp, bool isDown, float* pfDirRot)
  790. {
  791.     float fScrX=0.0f;
  792.     float fScrY=0.0f;
  793.  
  794.     if (isLeft)
  795.         fScrX=0.0f;
  796.     else if (isRight)
  797.         fScrX=1.0f;
  798.     else
  799.         fScrX=0.5f;
  800.  
  801.     if (isUp)
  802.         fScrY=0.0f;
  803.     else if (isDown)
  804.         fScrY=1.0f;
  805.     else
  806.         fScrY=0.5f;
  807.  
  808.     NEW_GetMouseDirRotation(fScrX, fScrY, pfDirRot);
  809. }
  810.  
  811. void CPythonPlayer::NEW_GetMouseDirRotation(float fScrX, float fScrY, float* pfDirRot)
  812. {
  813.     long lWidth = UI::CWindowManager::Instance().GetScreenWidth();
  814.     long lHeight = UI::CWindowManager::Instance().GetScreenHeight();
  815.     int nScrPosX=lWidth*fScrX;
  816.     int nScrPosY=lHeight*fScrY;
  817.     int nScrWidth=lWidth;
  818.     int nScrHeight=lHeight;
  819.     int nScrCenterX=nScrWidth/2;
  820.     int nScrCenterY=nScrHeight/2;
  821.  
  822.     float finputRotation = GetDegreeFromPosition(nScrPosX, nScrPosY, nScrCenterX, nScrCenterY);
  823.     *pfDirRot=finputRotation;
  824. }
  825.  
  826.  
  827. float CPythonPlayer::GetDegreeFromPosition(int ix, int iy, int iHalfWidth, int iHalfHeight)
  828. {
  829.     D3DXVECTOR3 vtDir(float(ix - iHalfWidth), float(iy - iHalfHeight), 0.0f);
  830.     D3DXVec3Normalize(&vtDir, &vtDir);
  831.  
  832.     D3DXVECTOR3 vtStan(0, -1, 0);
  833.     float ret = D3DXToDegree(acosf(D3DXVec3Dot(&vtDir, &vtStan)));
  834.  
  835.     if (vtDir.x < 0.0f)
  836.         ret = 360.0f - ret;
  837.  
  838.     return 360.0f - ret;
  839. }
  840.  
  841. void CPythonPlayer::__ClearReservedAction()
  842. {
  843.     m_eReservedMode=MODE_NONE;
  844. }
  845.  
  846. void CPythonPlayer::__ReserveClickItem(DWORD dwItemID)
  847. {
  848.     m_eReservedMode=MODE_CLICK_ITEM;
  849.     m_dwIIDReserved=dwItemID;
  850. }
  851.  
  852. void CPythonPlayer::__ReserveClickActor(DWORD dwActorID)
  853. {
  854.     m_eReservedMode=MODE_CLICK_ACTOR;
  855.     m_dwVIDReserved=dwActorID;
  856. }
  857.  
  858. void CPythonPlayer::__ReserveClickGround(const TPixelPosition& c_rkPPosPickedGround)
  859. {
  860.     m_eReservedMode=MODE_CLICK_POSITION;
  861.     m_kPPosReserved=c_rkPPosPickedGround;
  862.     m_fReservedDelayTime=0.1f;
  863. }
  864.  
  865. bool CPythonPlayer::__IsReservedUseSkill(DWORD dwSkillSlotIndex)
  866. {
  867.     if (MODE_USE_SKILL!=m_eReservedMode)
  868.         return false;
  869.  
  870.     if (m_dwSkillSlotIndexReserved!=dwSkillSlotIndex)
  871.         return false;
  872.    
  873.     return true;
  874. }
  875.  
  876. void CPythonPlayer::__ReserveUseSkill(DWORD dwActorID, DWORD dwSkillSlotIndex, DWORD dwRange)
  877. {
  878.     m_eReservedMode=MODE_USE_SKILL;
  879.     m_dwVIDReserved=dwActorID;
  880.     m_dwSkillSlotIndexReserved=dwSkillSlotIndex;
  881.     m_dwSkillRangeReserved=dwRange;
  882.  
  883.     // NOTE : 아슬아슬하게 거리가 꼬이는 문제가 있어서 약간 느슨하게..
  884.     if (m_dwSkillRangeReserved > 100)
  885.         m_dwSkillRangeReserved -= 10;
  886. }
  887.  
  888. void CPythonPlayer::__ClearAutoAttackTargetActorID()
  889. {
  890.     __SetAutoAttackTargetActorID(0);
  891. }
  892.  
  893. void CPythonPlayer::__SetAutoAttackTargetActorID(DWORD dwVID)
  894. {
  895.     m_dwAutoAttackTargetVID = dwVID;
  896. }
  897.  
  898.  
  899. void CPythonPlayer::__ReserveProcess_ClickActor()
  900. {
  901.     CInstanceBase* pkInstMain = NEW_GetMainActorPtr();
  902.     CInstanceBase* pkInstReserved = NEW_FindActorPtr(m_dwVIDReserved);
  903.     if (!pkInstMain || !pkInstReserved)
  904.     {
  905.         __ClearReservedAction();
  906.         return;
  907.     }
  908.  
  909.     if (!pkInstMain->NEW_IsClickableDistanceDestInstance(*pkInstReserved))
  910.     {
  911.         pkInstMain->NEW_MoveToDestInstanceDirection(*pkInstReserved);
  912.         return;
  913.     }
  914.  
  915.     if (!pkInstMain->IsAttackableInstance(*pkInstReserved))
  916.     {
  917.         pkInstMain->NEW_Stop();
  918.         __SendClickActorPacket(*pkInstReserved);
  919.         __ClearReservedAction();
  920.         return;
  921.     }
  922.  
  923.     if (pkInstReserved->IsDead())
  924.     {
  925.         __ClearReservedAction();
  926.         return;
  927.     }
  928.  
  929.     if (pkInstMain->IsInSafe())
  930.     {
  931.         PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotAttack", Py_BuildValue("(is)", GetMainCharacterIndex(), "IN_SAFE"));
  932.         pkInstMain->NEW_Stop();
  933.         __ClearReservedAction();
  934.         return;
  935.     }
  936.  
  937.     if (pkInstReserved->IsInSafe())
  938.     {
  939.         PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotAttack", Py_BuildValue("(is)", GetMainCharacterIndex(), "DEST_IN_SAFE"));
  940.         pkInstMain->NEW_Stop();
  941.         __ClearReservedAction();
  942.         return;
  943.     }
  944.  
  945.     // 탄환격 쓰고 달려가는 도중에는 공격하지 않는다.
  946.     if (__CheckDashAffect(*pkInstMain))
  947.     {
  948.         return;
  949.     }
  950.  
  951.     /////
  952.  
  953.     if (pkInstMain->IsBowMode())
  954.     {
  955.         if (!__HasEnoughArrow())
  956.         {
  957.             PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotShot", Py_BuildValue("(is)", GetMainCharacterIndex(), "EMPTY_ARROW"));
  958.             pkInstMain->NEW_Stop();
  959.             __ClearReservedAction();
  960.             return;
  961.         }
  962.     }
  963.  
  964.     if (pkInstReserved->GetVirtualID() != GetTargetVID())
  965.     {
  966.         SetTarget(pkInstReserved->GetVirtualID());
  967.     }
  968.  
  969.     pkInstMain->NEW_AttackToDestInstanceDirection(*pkInstReserved);
  970.     __ClearReservedAction();
  971. }
  972. /*
  973. CInstanceBase* pkInstReserved=NEW_FindActorPtr(m_dwVIDReserved);
  974. if (pkInstReserved)
  975. {
  976.     if (pkInstMain->NEW_IsClickableDistanceDestInstance(*pkInstReserved))
  977.     {
  978.         if (pkInstMain->IsAttackableInstance(*pkInstReserved) )
  979.         {
  980.             if (!pkInstReserved->IsDead())
  981.             {
  982.                 if (pkInstMain->IsInSafe())
  983.                 {
  984.                     PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotAttack", Py_BuildValue("(is)", GetMainCharacterIndex(), "IN_SAFE"));
  985.                     pkInstMain->NEW_Stop();
  986.                 }
  987.                 else if (pkInstReserved->IsInSafe())
  988.                 {
  989.                     PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotAttack", Py_BuildValue("(is)", GetMainCharacterIndex(), "DEST_IN_SAFE"));
  990.                     pkInstMain->NEW_Stop();
  991.                 }
  992.                 else
  993.                 {
  994.                     if (pkInstMain->IsBowMode())
  995.                     {
  996.                         if (!__HasEnoughArrow())
  997.                         {
  998.                             PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotShot", Py_BuildValue("(is)", GetMainCharacterIndex(), "EMPTY_ARROW"));
  999.                             pkInstMain->NEW_Stop();
  1000.                             __ClearReservedAction();
  1001.                             break;
  1002.                         }
  1003.                     }
  1004.  
  1005.                     if (pkInstReserved->GetVirtualID() != GetTargetVID())
  1006.                     {
  1007.                         SetTarget(pkInstReserved->GetVirtualID());
  1008.                     }
  1009.  
  1010.                     pkInstMain->NEW_AttackToDestInstanceDirection(*pkInstReserved);
  1011.                 }
  1012.             }
  1013.         }
  1014.         else
  1015.         {
  1016.             __SendClickActorPacket(*pkInstReserved);
  1017.  
  1018.             pkInstMain->NEW_Stop();
  1019.         }
  1020.  
  1021.         __ClearReservedAction();
  1022.     }
  1023.     else
  1024.     {
  1025.         //Tracen("ReservedMode: MOVE");
  1026.         pkInstMain->NEW_MoveToDestInstanceDirection(*pkInstReserved);
  1027.     }
  1028. }
  1029. else
  1030. {
  1031.     __ClearReservedAction();
  1032. }
  1033. */
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!