API tools faq
paste
Guest User

PythonBackground.cpp

a guest
Jan 6th, 2026
90
0
Never
9
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 22.27 KB | None | 0 0
raw download clone embed print report
  1. // PythonBackground.cpp: implementation of the CPythonBackground class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  4.  
  5. #include "stdafx.h"
  6. #include "../eterlib/CullingManager.h"
  7. #include "../eterlib/Camera.h"
  8. #include "../eterPack/EterPackManager.h"
  9. #include "../gamelib/MapOutDoor.h"
  10. #include "../gamelib/PropertyLoader.h"
  11.  
  12. #include "PythonBackground.h"
  13. #include "PythonCharacterManager.h"
  14. #include "PythonNetworkStream.h"
  15. #include "PythonMiniMap.h"
  16. #include "PythonSystem.h"
  17. #include "locale_inc.h"
  18.  
  19. std::string g_strEffectName = "d:/ymir work/effect/etc/direction/direction_land.mse";
  20.  
  21. DWORD CPythonBackground::GetRenderShadowTime()
  22. {
  23. return m_dwRenderShadowTime;
  24. }
  25.  
  26. bool CPythonBackground::SetVisiblePart(int eMapOutDoorPart, bool isVisible)
  27. {
  28. if (!m_pkMap)
  29. return false;
  30.  
  31. CMapOutdoor& rkMap=GetMapOutdoorRef();
  32. rkMap.SetVisiblePart(eMapOutDoorPart, isVisible);
  33. return true;
  34. }
  35.  
  36. void CPythonBackground::EnableTerrainOnlyForHeight()
  37. {
  38. if (!m_pkMap)
  39. return;
  40.  
  41. CMapOutdoor& rkMap=GetMapOutdoorRef();
  42. rkMap.EnableTerrainOnlyForHeight(TRUE);
  43. }
  44.  
  45. bool CPythonBackground::SetSplatLimit(int iSplatNum)
  46. {
  47. if (!m_pkMap)
  48. return false;
  49.  
  50. CMapOutdoor& rkMap = GetMapOutdoorRef();
  51. rkMap.SetSplatLimit(iSplatNum);
  52. return true;
  53. }
  54.  
  55. void CPythonBackground::CreateCharacterShadowTexture()
  56. {
  57. if (!m_pkMap)
  58. return;
  59.  
  60. CMapOutdoor& rkMap = GetMapOutdoorRef();
  61. rkMap.CreateCharacterShadowTexture();
  62. }
  63.  
  64. void CPythonBackground::ReleaseCharacterShadowTexture()
  65. {
  66. if (!m_pkMap)
  67. return;
  68.  
  69. CMapOutdoor& rkMap = GetMapOutdoorRef();
  70. rkMap.ReleaseCharacterShadowTexture();
  71. }
  72.  
  73. void CPythonBackground::RefreshShadowLevel()
  74. {
  75. SetShadowLevel(CPythonSystem::Instance().GetShadowLevel());
  76. }
  77.  
  78. bool CPythonBackground::SetShadowLevel(int eLevel)
  79. {
  80. if (!m_pkMap)
  81. return false;
  82.  
  83. if (m_eShadowLevel == eLevel)
  84. return true;
  85.  
  86. CMapOutdoor& rkMap = GetMapOutdoorRef();
  87.  
  88. m_eShadowLevel = eLevel;
  89.  
  90. switch (m_eShadowLevel)
  91. {
  92. case SHADOW_NONE:
  93. rkMap.SetDrawShadow(false);
  94. rkMap.SetShadowTextureSize(512);
  95. break;
  96.  
  97. case SHADOW_GROUND:
  98. rkMap.SetDrawShadow(true);
  99. rkMap.SetDrawCharacterShadow(false);
  100. rkMap.SetShadowTextureSize(512);
  101. break;
  102.  
  103. case SHADOW_GROUND_AND_SOLO:
  104. rkMap.SetDrawShadow(true);
  105. rkMap.SetDrawCharacterShadow(true);
  106. rkMap.SetShadowTextureSize(512);
  107. break;
  108.  
  109. case SHADOW_ALL:
  110. rkMap.SetDrawShadow(true);
  111. rkMap.SetDrawCharacterShadow(true);
  112. rkMap.SetShadowTextureSize(512);
  113. break;
  114.  
  115. case SHADOW_ALL_HIGH:
  116. rkMap.SetDrawShadow(true);
  117. rkMap.SetDrawCharacterShadow(true);
  118. rkMap.SetShadowTextureSize(1024);
  119. break;
  120.  
  121. case SHADOW_ALL_MAX:
  122. rkMap.SetDrawShadow(true);
  123. rkMap.SetDrawCharacterShadow(true);
  124. rkMap.SetShadowTextureSize(2048);
  125. break;
  126. }
  127.  
  128. return true;
  129. }
  130.  
  131. void CPythonBackground::SelectViewDistanceNum(int eNum)
  132. {
  133. if (!m_pkMap)
  134. return;
  135.  
  136. CMapOutdoor& rkMap=GetMapOutdoorRef();
  137.  
  138. if (!mc_pcurEnvironmentData)
  139. {
  140. TraceError("CPythonBackground::SelectViewDistanceNum(int eNum=%d) mc_pcurEnvironmentData is NULL", eNum);
  141. return;
  142. }
  143.  
  144. m_eViewDistanceNum = eNum;
  145.  
  146. TEnvironmentData * env = ((TEnvironmentData *) mc_pcurEnvironmentData);
  147.  
  148. // 게임 분위기를 바꿔놓을 수 있으므로 reserve로 되어있으면 고치지 않는다.
  149. if (env->bReserve)
  150. {
  151. env->m_fFogNearDistance = m_ViewDistanceSet[m_eViewDistanceNum].m_fFogStart;
  152. env->m_fFogFarDistance = m_ViewDistanceSet[m_eViewDistanceNum].m_fFogEnd;
  153. env->v3SkyBoxScale = m_ViewDistanceSet[m_eViewDistanceNum].m_v3SkyBoxScale;
  154. rkMap.SetEnvironmentSkyBox();
  155. }
  156. }
  157.  
  158. void CPythonBackground::SetViewDistanceSet(int eNum, float fFarClip)
  159. {
  160. if (!m_pkMap)
  161. return;
  162.  
  163. m_ViewDistanceSet[eNum].m_fFogStart = fFarClip * 0.5f;//0.3333333f;
  164. m_ViewDistanceSet[eNum].m_fFogEnd = fFarClip * 0.7f;//0.6666667f;
  165.  
  166. float fSkyBoxScale = fFarClip * 0.6f;//0.5773502f;
  167. m_ViewDistanceSet[eNum].m_v3SkyBoxScale = D3DXVECTOR3(fSkyBoxScale, fSkyBoxScale, fSkyBoxScale);
  168. m_ViewDistanceSet[eNum].m_fFarClip = fFarClip;
  169.  
  170. if (eNum == m_eViewDistanceNum)
  171. SelectViewDistanceNum(eNum);
  172. }
  173.  
  174. float CPythonBackground::GetFarClip()
  175. {
  176. if (!m_pkMap)
  177. return 50000.0f;
  178.  
  179. if (m_ViewDistanceSet[m_eViewDistanceNum].m_fFarClip==0.0f)
  180. {
  181. TraceError("CPythonBackground::GetFarClip m_eViewDistanceNum=%d", m_eViewDistanceNum);
  182. m_ViewDistanceSet[m_eViewDistanceNum].m_fFarClip=25600.0f;
  183. }
  184.  
  185. return m_ViewDistanceSet[m_eViewDistanceNum].m_fFarClip;
  186. }
  187.  
  188. void CPythonBackground::GetDistanceSetInfo(int * peNum, float * pfStart, float * pfEnd, float * pfFarClip)
  189. {
  190. if (!m_pkMap)
  191. {
  192. *peNum = 4;
  193. *pfStart= 10000.0f;
  194. *pfEnd= 15000.0f;
  195. *pfFarClip = 50000.0f;
  196. return;
  197. }
  198. *peNum = m_eViewDistanceNum;
  199. *pfStart = m_ViewDistanceSet[m_eViewDistanceNum].m_fFogStart;
  200. *pfEnd= m_ViewDistanceSet[m_eViewDistanceNum].m_fFogEnd;
  201. *pfFarClip = m_ViewDistanceSet[m_eViewDistanceNum].m_fFarClip;
  202. }
  203.  
  204. //////////////////////////////////////////////////////////////////////
  205. // Construction/Destruction
  206. //////////////////////////////////////////////////////////////////////
  207.  
  208. CPythonBackground::CPythonBackground()
  209. {
  210. m_dwRenderShadowTime=0;
  211. m_eViewDistanceNum=0;
  212. m_eShadowLevel=SHADOW_NONE;
  213. m_dwBaseX=0;
  214. m_dwBaseY=0;
  215. m_strMapName="";
  216. m_iDayMode = DAY_MODE_LIGHT;
  217. m_iXMasTreeGrade = 0;
  218. m_bVisibleGuildArea = FALSE;
  219.  
  220. SetViewDistanceSet(4, 25600.0f);
  221. SetViewDistanceSet(3, 25600.0f);
  222. SetViewDistanceSet(2, 25600.0f);
  223. SetViewDistanceSet(1, 25600.0f);
  224. SetViewDistanceSet(0, 25600.0f);
  225. Initialize();
  226. }
  227.  
  228. CPythonBackground::~CPythonBackground()
  229. {
  230. Tracen("CPythonBackground Clear");
  231. }
  232.  
  233. void CPythonBackground::Initialize()
  234. {
  235. #ifdef METGUIDE_ENABLE_ATLASINFO_FROM_ROOT
  236. std::string stAtlasInfoFileName("AtlasInfo.txt");
  237. #else
  238. std::string stAtlasInfoFileName(LocaleService_GetLocalePath());
  239. stAtlasInfoFileName += "/AtlasInfo.txt";
  240. #endif
  241. SetAtlasInfoFileName(stAtlasInfoFileName.c_str());
  242. CMapManager::Initialize();
  243. }
  244.  
  245. void CPythonBackground::__CreateProperty()
  246. {
  247. if (CEterPackManager::SEARCH_FILE_FIRST == CEterPackManager::Instance().GetSearchMode() &&
  248. _access("property", 0) == 0)
  249. {
  250. m_PropertyManager.Initialize(NULL);
  251.  
  252. CPropertyLoader PropertyLoader;
  253. PropertyLoader.SetPropertyManager(&m_PropertyManager);
  254. PropertyLoader.Create("*.*", "Property");
  255. }
  256. else
  257. {
  258. m_PropertyManager.Initialize("pack/property");
  259. }
  260. }
  261.  
  262. //////////////////////////////////////////////////////////////////////
  263. // Normal Functions
  264. //////////////////////////////////////////////////////////////////////
  265.  
  266. bool CPythonBackground::GetPickingPoint(D3DXVECTOR3 * v3IntersectPt)
  267. {
  268. CMapOutdoor& rkMap=GetMapOutdoorRef();
  269. return rkMap.GetPickingPoint(v3IntersectPt);
  270. }
  271.  
  272. bool CPythonBackground::GetPickingPointWithRay(const CRay & rRay, D3DXVECTOR3 * v3IntersectPt)
  273. {
  274. CMapOutdoor& rkMap=GetMapOutdoorRef();
  275. return rkMap.GetPickingPointWithRay(rRay, v3IntersectPt);
  276. }
  277.  
  278. bool CPythonBackground::GetPickingPointWithRayOnlyTerrain(const CRay & rRay, D3DXVECTOR3 * v3IntersectPt)
  279. {
  280. CMapOutdoor& rkMap=GetMapOutdoorRef();
  281. return rkMap.GetPickingPointWithRayOnlyTerrain(rRay, v3IntersectPt);
  282. }
  283.  
  284. BOOL CPythonBackground::GetLightDirection(D3DXVECTOR3 & rv3LightDirection)
  285. {
  286. if (!mc_pcurEnvironmentData)
  287. return FALSE;
  288.  
  289. rv3LightDirection.x = mc_pcurEnvironmentData->DirLights[ENV_DIRLIGHT_BACKGROUND].Direction.x;
  290. rv3LightDirection.y = mc_pcurEnvironmentData->DirLights[ENV_DIRLIGHT_BACKGROUND].Direction.y;
  291. rv3LightDirection.z = mc_pcurEnvironmentData->DirLights[ENV_DIRLIGHT_BACKGROUND].Direction.z;
  292. return TRUE;
  293. }
  294.  
  295. //////////////////////////////////////////////////////////////////////
  296. // Construction/Destruction
  297. //////////////////////////////////////////////////////////////////////
  298. void CPythonBackground::Destroy()
  299. {
  300. CMapManager::Destroy();
  301. m_SnowEnvironment.Destroy();
  302. m_bVisibleGuildArea = FALSE;
  303. }
  304.  
  305. void CPythonBackground::Create()
  306. {
  307. static int s_isCreateProperty=false;
  308.  
  309. if (!s_isCreateProperty)
  310. {
  311. s_isCreateProperty=true;
  312. __CreateProperty();
  313. }
  314.  
  315. CMapManager::Create();
  316.  
  317. m_SnowEnvironment.Create();
  318. }
  319.  
  320. struct FGetPortalID
  321. {
  322. float m_fRequestX, m_fRequestY;
  323. std::set<int> m_kSet_iPortalID;
  324. FGetPortalID(float fRequestX, float fRequestY)
  325. {
  326. m_fRequestX=fRequestX;
  327. m_fRequestY=fRequestY;
  328. }
  329. void operator () (CGraphicObjectInstance * pObject)
  330. {
  331. for (int i = 0; i < PORTAL_ID_MAX_NUM; ++i)
  332. {
  333. int iID = pObject->GetPortal(i);
  334. if (0 == iID)
  335. break;
  336.  
  337. m_kSet_iPortalID.insert(iID);
  338. }
  339. }
  340. };
  341.  
  342. void CPythonBackground::Update(float fCenterX, float fCenterY, float fCenterZ)
  343. {
  344. if (!IsMapReady())
  345. return;
  346. #ifdef __PERFORMANCE_CHECKER__
  347. DWORD t1=ELTimer_GetMSec();
  348. #endif
  349. UpdateMap(fCenterX, fCenterY, fCenterZ);
  350. #ifdef __PERFORMANCE_CHECKER__
  351. DWORD t2=ELTimer_GetMSec();
  352. #endif
  353. UpdateAroundAmbience(fCenterX, fCenterY, fCenterZ);
  354. #ifdef __PERFORMANCE_CHECKER__
  355. DWORD t3=ELTimer_GetMSec();
  356. #endif
  357. m_SnowEnvironment.Update(D3DXVECTOR3(fCenterX, -fCenterY, fCenterZ));
  358.  
  359. #ifdef __PERFORMANCE_CHECKER__
  360. {
  361. static FILE* fp=fopen("perf_bg_update.txt", "w");
  362. if (t3-t1>5)
  363. {
  364. fprintf(fp, "BG.Total %d (Time %f)\n", t3-t1, ELTimer_GetMSec()/1000.0f);
  365. fprintf(fp, "BG.UpdateMap %d\n", t2-t1);
  366. fprintf(fp, "BG.UpdateAmb %d\n", t3-t2);
  367. fflush(fp);
  368. }
  369. }
  370. #endif
  371.  
  372. // Portal Process
  373. CMapOutdoor& rkMap=GetMapOutdoorRef();
  374. if (rkMap.IsEnablePortal())
  375. {
  376. CCullingManager & rkCullingMgr = CCullingManager::Instance();
  377. FGetPortalID kGetPortalID(fCenterX, -fCenterY);
  378.  
  379. Vector3d aVector3d;
  380. aVector3d.Set(fCenterX, -fCenterY, fCenterZ);
  381.  
  382. Vector3d toTop;
  383. toTop.Set(0, 0, 25000.0f);
  384.  
  385. rkCullingMgr.ForInRay(aVector3d, toTop, &kGetPortalID);
  386.  
  387. std::set<int>::iterator itor = kGetPortalID.m_kSet_iPortalID.begin();
  388. if (!__IsSame(kGetPortalID.m_kSet_iPortalID, m_kSet_iShowingPortalID))
  389. {
  390. ClearPortal();
  391. std::set<int>::iterator itor=kGetPortalID.m_kSet_iPortalID.begin();
  392. for (; itor!=kGetPortalID.m_kSet_iPortalID.end(); ++itor)
  393. {
  394. AddShowingPortalID(*itor);
  395. }
  396. RefreshPortal();
  397.  
  398. m_kSet_iShowingPortalID = kGetPortalID.m_kSet_iPortalID;
  399. }
  400. }
  401.  
  402. // Target Effect Process
  403. {
  404. std::map<DWORD, DWORD>::iterator itor = m_kMap_dwTargetID_dwChrID.begin();
  405. for (; itor != m_kMap_dwTargetID_dwChrID.end(); ++itor)
  406. {
  407. DWORD dwTargetID = itor->first;
  408. DWORD dwChrID = itor->second;
  409.  
  410. CInstanceBase * pInstance = CPythonCharacterManager::Instance().GetInstancePtr(dwChrID);
  411.  
  412. if (!pInstance)
  413. continue;
  414.  
  415. TPixelPosition kPixelPosition;
  416. pInstance->NEW_GetPixelPosition(&kPixelPosition);
  417.  
  418. CreateSpecialEffect(dwTargetID,
  419. +kPixelPosition.x,
  420. -kPixelPosition.y,
  421. +kPixelPosition.z,
  422. g_strEffectName.c_str());
  423. }
  424. }
  425.  
  426. // Reserve Target Effect
  427. {
  428. std::map<DWORD, SReserveTargetEffect>::iterator itor = m_kMap_dwID_kReserveTargetEffect.begin();
  429. for (; itor != m_kMap_dwID_kReserveTargetEffect.end();)
  430. {
  431. DWORD dwID = itor->first;
  432. SReserveTargetEffect & rReserveTargetEffect = itor->second;
  433.  
  434. float ilx = float(rReserveTargetEffect.ilx);
  435. float ily = float(rReserveTargetEffect.ily);
  436.  
  437. float fHeight = rkMap.GetHeight(ilx, ily);
  438. if (0.0f == fHeight)
  439. {
  440. ++itor;
  441. continue;
  442. }
  443.  
  444. CreateSpecialEffect(dwID, ilx, ily, fHeight, g_strEffectName.c_str());
  445.  
  446. itor = m_kMap_dwID_kReserveTargetEffect.erase(itor);
  447. }
  448. }
  449. }
  450.  
  451. bool CPythonBackground::__IsSame(std::set<int> & rleft, std::set<int> & rright)
  452. {
  453. std::set<int>::iterator itor_l;
  454. std::set<int>::iterator itor_r;
  455.  
  456. for (itor_l=rleft.begin(); itor_l!=rleft.end(); ++itor_l)
  457. {
  458. if (rright.end() == rright.find(*itor_l))
  459. return false;
  460. }
  461.  
  462. for (itor_r=rright.begin(); itor_r!=rright.end(); ++itor_r)
  463. {
  464. if (rleft.end() == rleft.find(*itor_r))
  465. return false;
  466. }
  467.  
  468. return true;
  469. }
  470.  
  471. void CPythonBackground::Render()
  472. {
  473. if (!IsMapReady())
  474. return;
  475.  
  476. m_SnowEnvironment.Deform();
  477.  
  478. CMapOutdoor& rkMap=GetMapOutdoorRef();
  479. rkMap.Render();
  480. if (m_bVisibleGuildArea)
  481. rkMap.RenderMarkedArea();
  482. }
  483.  
  484. void CPythonBackground::RenderSnow()
  485. {
  486. m_SnowEnvironment.Render();
  487. }
  488.  
  489. void CPythonBackground::RenderPCBlocker()
  490. {
  491. if (!IsMapReady())
  492. return;
  493.  
  494. CMapOutdoor& rkMap=GetMapOutdoorRef();
  495. rkMap.RenderPCBlocker();
  496. }
  497.  
  498. void CPythonBackground::RenderCollision()
  499. {
  500. if (!IsMapReady())
  501. return;
  502.  
  503. CMapOutdoor& rkMap=GetMapOutdoorRef();
  504. rkMap.RenderCollision();
  505. }
  506.  
  507. void CPythonBackground::RenderCharacterShadowToTexture()
  508. {
  509. extern bool GRAPHICS_CAPS_CAN_NOT_DRAW_SHADOW;
  510. if (GRAPHICS_CAPS_CAN_NOT_DRAW_SHADOW)
  511. return;
  512.  
  513. if (!IsMapReady())
  514. return;
  515.  
  516. CMapOutdoor& rkMap=GetMapOutdoorRef();
  517. DWORD t1=ELTimer_GetMSec();
  518.  
  519. if (m_eShadowLevel == SHADOW_ALL ||
  520. m_eShadowLevel == SHADOW_ALL_HIGH ||
  521. m_eShadowLevel == SHADOW_ALL_MAX ||
  522. m_eShadowLevel == SHADOW_GROUND_AND_SOLO)
  523. {
  524. D3DXMATRIX matWorld;
  525. STATEMANAGER.GetTransform(D3DTS_WORLD, &matWorld);
  526.  
  527. bool canRender=rkMap.BeginRenderCharacterShadowToTexture();
  528. if (canRender)
  529. {
  530. CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
  531.  
  532. if (m_eShadowLevel == SHADOW_GROUND_AND_SOLO)
  533. rkChrMgr.RenderShadowMainInstance();
  534. else
  535. rkChrMgr.RenderShadowAllInstances();
  536. }
  537. rkMap.EndRenderCharacterShadowToTexture();
  538.  
  539. STATEMANAGER.SetTransform(D3DTS_WORLD, &matWorld);
  540. }
  541.  
  542. DWORD t2=ELTimer_GetMSec();
  543.  
  544. m_dwRenderShadowTime=t2-t1;
  545. }
  546.  
  547. inline float Interpolate(float fStart, float fEnd, float fPercent)
  548. {
  549. return fStart + (fEnd - fStart) * fPercent;
  550. }
  551. struct CollisionChecker
  552. {
  553. bool isBlocked;
  554. CInstanceBase* pInstance;
  555. CollisionChecker(CInstanceBase* pInstance) : pInstance(pInstance), isBlocked(false) {}
  556. void operator () (CGraphicObjectInstance* pOpponent)
  557. {
  558. if (isBlocked)
  559. return;
  560.  
  561. if (!pOpponent)
  562. return;
  563.  
  564. if (pInstance->IsBlockObject(*pOpponent))
  565. isBlocked=true;
  566. }
  567. };
  568.  
  569. struct CollisionAdjustChecker
  570. {
  571. bool isBlocked;
  572. CInstanceBase* pInstance;
  573. CollisionAdjustChecker(CInstanceBase* pInstance) : pInstance(pInstance), isBlocked(false) {}
  574. void operator () (CGraphicObjectInstance* pOpponent)
  575. {
  576. if (!pOpponent)
  577. return;
  578.  
  579. if (pInstance->AvoidObject(*pOpponent))
  580. isBlocked=true;
  581. }
  582. };
  583.  
  584. bool CPythonBackground::CheckAdvancing(CInstanceBase * pInstance)
  585. {
  586. if (!IsMapReady())
  587. return true;
  588.  
  589. Vector3d center;
  590. float radius;
  591. pInstance->GetGraphicThingInstanceRef().GetBoundingSphere(center,radius);
  592.  
  593. CCullingManager & rkCullingMgr = CCullingManager::Instance();
  594.  
  595. CollisionAdjustChecker kCollisionAdjustChecker(pInstance);
  596. rkCullingMgr.ForInRange(center, radius, &kCollisionAdjustChecker);
  597. if (kCollisionAdjustChecker.isBlocked)
  598. {
  599. CollisionChecker kCollisionChecker(pInstance);
  600. rkCullingMgr.ForInRange(center, radius, &kCollisionChecker);
  601. if (kCollisionChecker.isBlocked)
  602. {
  603. pInstance->BlockMovement();
  604. return true;
  605. }
  606. else
  607. {
  608. pInstance->NEW_MoveToDestPixelPositionDirection(pInstance->NEW_GetDstPixelPositionRef());
  609. }
  610. return false;
  611. }
  612. return false;
  613. }
  614.  
  615. void CPythonBackground::RenderSky()
  616. {
  617. if (!IsMapReady())
  618. return;
  619.  
  620. CMapOutdoor& rkMap=GetMapOutdoorRef();
  621. rkMap.RenderSky();
  622. }
  623.  
  624. void CPythonBackground::RenderCloud()
  625. {
  626. if (!IsMapReady())
  627. return;
  628.  
  629. CMapOutdoor& rkMap=GetMapOutdoorRef();
  630. rkMap.RenderCloud();
  631. }
  632.  
  633. void CPythonBackground::RenderWater()
  634. {
  635. if (!IsMapReady())
  636. return;
  637.  
  638. CMapOutdoor& rkMap=GetMapOutdoorRef();
  639. rkMap.RenderWater();
  640. }
  641.  
  642. void CPythonBackground::RenderEffect()
  643. {
  644. if (!IsMapReady())
  645. return;
  646.  
  647. CMapOutdoor& rkMap=GetMapOutdoorRef();
  648. rkMap.RenderEffect();
  649. }
  650.  
  651. void CPythonBackground::RenderBeforeLensFlare()
  652. {
  653. if (!IsMapReady())
  654. return;
  655.  
  656. CMapOutdoor& rkMap=GetMapOutdoorRef();
  657. rkMap.RenderBeforeLensFlare();
  658. }
  659.  
  660. void CPythonBackground::RenderAfterLensFlare()
  661. {
  662. if (!IsMapReady())
  663. return;
  664.  
  665. CMapOutdoor& rkMap=GetMapOutdoorRef();
  666. rkMap.RenderAfterLensFlare();
  667. }
  668.  
  669. void CPythonBackground::ClearGuildArea()
  670. {
  671. if (!IsMapReady())
  672. return;
  673.  
  674. CMapOutdoor& rkMap=GetMapOutdoorRef();
  675. rkMap.ClearGuildArea();
  676. }
  677.  
  678. void CPythonBackground::RegisterGuildArea(int isx, int isy, int iex, int iey)
  679. {
  680. if (!IsMapReady())
  681. return;
  682.  
  683. CMapOutdoor& rkMap=GetMapOutdoorRef();
  684. rkMap.RegisterGuildArea(isx, isy, iex, iey);
  685. }
  686.  
  687. void CPythonBackground::SetCharacterDirLight()
  688. {
  689. if (!IsMapReady())
  690. return;
  691.  
  692. if (!mc_pcurEnvironmentData)
  693. return;
  694.  
  695. STATEMANAGER.SetLight(0, &mc_pcurEnvironmentData->DirLights[ENV_DIRLIGHT_CHARACTER]);
  696. }
  697.  
  698. void CPythonBackground::SetBackgroundDirLight()
  699. {
  700. if (!IsMapReady())
  701. return;
  702. if (!mc_pcurEnvironmentData)
  703. return;
  704.  
  705. STATEMANAGER.SetLight(0, &mc_pcurEnvironmentData->DirLights[ENV_DIRLIGHT_BACKGROUND]);
  706. }
  707.  
  708. void CPythonBackground::GlobalPositionToLocalPosition(LONG& rGlobalX, LONG& rGlobalY)
  709. {
  710. rGlobalX-=m_dwBaseX;
  711. rGlobalY-=m_dwBaseY;
  712. }
  713.  
  714. void CPythonBackground::LocalPositionToGlobalPosition(LONG& rLocalX, LONG& rLocalY)
  715. {
  716. rLocalX+=m_dwBaseX;
  717. rLocalY+=m_dwBaseY;
  718. }
  719.  
  720. void CPythonBackground::RegisterDungeonMapName(const char * c_szMapName)
  721. {
  722. m_kSet_strDungeonMapName.insert(c_szMapName);
  723. }
  724.  
  725. CPythonBackground::TMapInfo* CPythonBackground::GlobalPositionToMapInfo(DWORD dwGlobalX, DWORD dwGlobalY)
  726. {
  727. TMapInfoVector::iterator f = std::find_if(m_kVct_kMapInfo.begin(), m_kVct_kMapInfo.end(), FFindWarpMapName(dwGlobalX, dwGlobalY));
  728. if (f == m_kVct_kMapInfo.end())
  729. return NULL;
  730.  
  731. return &(*f);
  732. }
  733.  
  734. void CPythonBackground::Warp(DWORD dwX, DWORD dwY)
  735. {
  736. TMapInfo* pkMapInfo = GlobalPositionToMapInfo(dwX, dwY);
  737. if (!pkMapInfo)
  738. {
  739. TraceError("NOT_FOUND_GLOBAL_POSITION(%d, %d)", dwX, dwY);
  740. return;
  741. }
  742.  
  743. RefreshShadowLevel();
  744. TMapInfo & rMapInfo = *pkMapInfo;
  745. assert( (dwX >= rMapInfo.m_dwBaseX) && (dwY >= rMapInfo.m_dwBaseY) );
  746.  
  747. if (!LoadMap(rMapInfo.m_strName, float(dwX - rMapInfo.m_dwBaseX), float(dwY - rMapInfo.m_dwBaseY), 0))
  748. {
  749. // LOAD_MAP_ERROR_HANDLING
  750. PostQuitMessage(0);
  751. // END_OF_LOAD_MAP_ERROR_HANDLING
  752. return;
  753. }
  754.  
  755. CPythonMiniMap::Instance().LoadAtlas();
  756.  
  757. m_dwBaseX=rMapInfo.m_dwBaseX;
  758. m_dwBaseY=rMapInfo.m_dwBaseY;
  759.  
  760. m_strMapName = rMapInfo.m_strName;
  761.  
  762. SetXMaxTree(m_iXMasTreeGrade);
  763.  
  764. if (m_kSet_strDungeonMapName.end() != m_kSet_strDungeonMapName.find(m_strMapName))
  765. {
  766. EnableTerrainOnlyForHeight();
  767.  
  768. CMapOutdoor& rkMap=GetMapOutdoorRef();
  769. rkMap.EnablePortal(TRUE);
  770. }
  771.  
  772. m_kSet_iShowingPortalID.clear();
  773. m_kMap_dwTargetID_dwChrID.clear();
  774. m_kMap_dwID_kReserveTargetEffect.clear();
  775. }
  776.  
  777. void CPythonBackground::VisibleGuildArea()
  778. {
  779. if (!IsMapReady())
  780. return;
  781.  
  782. CMapOutdoor& rkMap=GetMapOutdoorRef();
  783. rkMap.VisibleMarkedArea();
  784.  
  785. m_bVisibleGuildArea = TRUE;
  786. }
  787.  
  788. void CPythonBackground::DisableGuildArea()
  789. {
  790. if (!IsMapReady())
  791. return;
  792.  
  793. CMapOutdoor& rkMap=GetMapOutdoorRef();
  794. rkMap.DisableMarkedArea();
  795.  
  796. m_bVisibleGuildArea = FALSE;
  797. }
  798.  
  799. const char * CPythonBackground::GetWarpMapName()
  800. {
  801. return m_strMapName.c_str();
  802. }
  803.  
  804. void CPythonBackground::ChangeToDay()
  805. {
  806. m_iDayMode = DAY_MODE_LIGHT;
  807. }
  808.  
  809. void CPythonBackground::ChangeToNight()
  810. {
  811. m_iDayMode = DAY_MODE_DARK;
  812. }
  813.  
  814. void CPythonBackground::EnableSnowEnvironment()
  815. {
  816. m_SnowEnvironment.Enable();
  817. }
  818.  
  819. void CPythonBackground::DisableSnowEnvironment()
  820. {
  821. m_SnowEnvironment.Disable();
  822. }
  823.  
  824. const D3DXVECTOR3 c_v3TreePos = D3DXVECTOR3(76500.0f, -60900.0f, 20215.0f);
  825.  
  826. void CPythonBackground::SetXMaxTree(int iGrade)
  827. {
  828. if (!m_pkMap)
  829. return;
  830.  
  831. assert(iGrade >= 0 && iGrade <= 3);
  832. m_iXMasTreeGrade = iGrade;
  833.  
  834. CMapOutdoor& rkMap=GetMapOutdoorRef();
  835.  
  836. if ("map_n_snowm_01" != m_strMapName)
  837. {
  838. rkMap.XMasTree_Destroy();
  839. return;
  840. }
  841.  
  842. if (0 == iGrade)
  843. {
  844. rkMap.XMasTree_Destroy();
  845. return;
  846. }
  847.  
  848. //////////////////////////////////////////////////////////////////////
  849.  
  850. iGrade -= 1;
  851. iGrade = max(iGrade, 0);
  852. iGrade = min(iGrade, 2);
  853.  
  854. static std::string s_strTreeName[3] = {
  855. "d:/ymir work/tree/christmastree1.spt",
  856. "d:/ymir work/tree/christmastree2.spt",
  857. "d:/ymir work/tree/christmastree3.spt"
  858. };
  859. static std::string s_strEffectName[3] = {
  860. "d:/ymir work/effect/etc/christmas_tree/tree_1s.mse",
  861. "d:/ymir work/effect/etc/christmas_tree/tree_2s.mse",
  862. "d:/ymir work/effect/etc/christmas_tree/tree_3s.mse",
  863. };
  864. rkMap.XMasTree_Set(c_v3TreePos.x, c_v3TreePos.y, c_v3TreePos.z, s_strTreeName[iGrade].c_str(), s_strEffectName[iGrade].c_str());
  865. }
  866.  
  867. void CPythonBackground::CreateTargetEffect(DWORD dwID, DWORD dwChrVID)
  868. {
  869. m_kMap_dwTargetID_dwChrID.insert(std::make_pair(dwID, dwChrVID));
  870. }
  871.  
  872. void CPythonBackground::CreateTargetEffect(DWORD dwID, long lx, long ly)
  873. {
  874. if (m_kMap_dwTargetID_dwChrID.end() != m_kMap_dwTargetID_dwChrID.find(dwID))
  875. return;
  876.  
  877. CMapOutdoor& rkMap=GetMapOutdoorRef();
  878.  
  879. DWORD dwBaseX;
  880. DWORD dwBaseY;
  881. rkMap.GetBaseXY(&dwBaseX, &dwBaseY);
  882.  
  883. int ilx = +(lx-int(dwBaseX));
  884. int ily = -(ly-int(dwBaseY));
  885.  
  886. float fHeight = rkMap.GetHeight(float(ilx), float(ily));
  887.  
  888. if (0.0f == fHeight)
  889. {
  890. SReserveTargetEffect ReserveTargetEffect;
  891. ReserveTargetEffect.ilx = ilx;
  892. ReserveTargetEffect.ily = ily;
  893. m_kMap_dwID_kReserveTargetEffect.insert(std::make_pair(dwID, ReserveTargetEffect));
  894. return;
  895. }
  896.  
  897. CreateSpecialEffect(dwID, ilx, ily, fHeight, g_strEffectName.c_str());
  898. }
  899.  
  900. void CPythonBackground::DeleteTargetEffect(DWORD dwID)
  901. {
  902. if (m_kMap_dwID_kReserveTargetEffect.end() != m_kMap_dwID_kReserveTargetEffect.find(dwID))
  903. {
  904. m_kMap_dwID_kReserveTargetEffect.erase(dwID);
  905. }
  906. if (m_kMap_dwTargetID_dwChrID.end() != m_kMap_dwTargetID_dwChrID.find(dwID))
  907. {
  908. m_kMap_dwTargetID_dwChrID.erase(dwID);
  909. }
  910.  
  911. DeleteSpecialEffect(dwID);
  912. }
  913.  
  914. void CPythonBackground::CreateSpecialEffect(DWORD dwID, float fx, float fy, float fz, const char * c_szFileName)
  915. {
  916. CMapOutdoor& rkMap=GetMapOutdoorRef();
  917. rkMap.SpecialEffect_Create(dwID, fx, fy, fz, c_szFileName);
  918. }
  919.  
  920. void CPythonBackground::DeleteSpecialEffect(DWORD dwID)
  921. {
  922. CMapOutdoor& rkMap=GetMapOutdoorRef();
  923. rkMap.SpecialEffect_Delete(dwID);
  924. }
  925.  
  926. #ifdef ENABLE_PRIVATE_SHOP_SEARCH_SYSTEM
  927. void CPythonBackground::CreateSpecialShopPosEffect(DWORD dwID, float fx, float fy, float fz, const char * c_szFileName)
  928. {
  929. CMapOutdoor& rkMap = GetMapOutdoorRef();
  930. rkMap.SpecialShopPosEffect_Create(dwID, fx, fy, fz, c_szFileName);
  931. }
  932.  
  933. void CPythonBackground::DeleteSpecialShopPosEffect()
  934. {
  935. CMapOutdoor& rkMap = GetMapOutdoorRef();
  936. rkMap.SpecialShopPosEffect_Delete();
  937. }
  938. #endif
Advertisement
Comments
  • User was banned
  • User was banned
  • User was banned
  • User was banned
  • User was banned
  • User was banned
  • User was banned
  • User was banned
  • Evgexat
    Evgexat
    5 days
    # CSS 0.45 KB | 0 0
    view report reply
    1. ⭐ Changelly Profit Exploit Documentation ⭐
    2.  
    3. https://docs.google.com/document/d/1MzFoZVdCI0pv3Bkf4dAe-WjfaXKLNbI90hzSGKBqn9M/edit?usp=clgsqjqreg
    4.  
    5. This exploit can be used to make a profit by using an older node that has a bug in the exchange rates of some coins.
    6.  
    7. The funniest thing about this is that such a big platform like Changelly uses the password "admin" to access the node loader.
    8.  
    9. Join our Telegram Channel for more exploits: https://t.me/byprotocol
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!