Yardım SetTransform Type değeri hatası Assertion failed

  • Konuyu açan Konuyu açan Happy Way
  • Açılış Tarihi Açılış Tarihi
  • Yanıt Yanıt 2
  • Gösterim Gösterim 122
Konu sahibi bu konuda soru soruyor. Sorusu ile ilgili bilgisi olanların yanıtlamasını bekliyor.
Happy Way

Happy Way

Yardımsever Üye
Yardımsever Üye
MT Üye
Mesaj
416
Çözümler
33
Beğeni
133
Puan
869
Ticaret Puanı
0
Aşağıdaki kod bloğunda type değeri normal aralığı 1-23 olması gerekirken 256 geliyor bunu nasıl çözebilirim statemanager.cpp dosyasında

256 değeri pencereyi aşağıya aldığım zaman geliyor ön plandayken olması gereken değerler dönüyor 1-2-3-4-5-6 gibi.
Kod:
Genişlet Daralt Kopyala 
void CStateManager::SetTransform(D3DTRANSFORMSTATETYPE Type, const D3DMATRIX* pMatrix)
{
   
    if (m_bScene)
    {
        m_lpD3DDev->SetTransform(Type, pMatrix);
    }
    else
    {
        // Type değişkeninin değerini yazdır
        if (Type == 256)
        {
            std::cout << "SetTransform called with Type: " << D3DTS_VIEW << ": ||  " << Type << std::endl;
            return;
        }
        assert(D3DTS_VIEW == Type || D3DTS_PROJECTION == Type || D3DTS_WORLD == Type);
    }
    // Tür dönüşümü yaparak hatayı düzelt
    m_CurrentState.m_Matrices[Type] = *reinterpret_cast<const D3DXMATRIX*>(pMatrix);


}


Aşağıdaki client minimize durumunda iken effect birikmesi fixi bu işlemi yaptıktan sonra debug olarak oyuna girdiğimde yukarıdaki sorun olusuyor release modunda sorun yok ama debugta bu 256 değeri dönüp yukarıdaki satırda hata veriyor. Bu sistemden yaptığına eminim sorun nerde olabilir ?
Kod:
Genişlet Daralt Kopyala 
PythonApplication.cpp aratırılır.
C++:
if (!canRender)

Koşulunun içine eklenir.
C++:
RenderSpecial();

Yani şu şekilde olmalı.
C++:
        if (!canRender){
            RenderSpecial();
            SkipRenderBuffering(3000);
        }

Her hangi uygun bir yere eklenir.
C++:
void CPythonApplication::RenderSpecial(){
    m_kEftMgr.Update();
    m_kChrMgr.Render();
    m_pyItem.Render();
    m_FlyingManager.Render();
}

PythonApplication.h uygun bir yere eklenir.
C++:
void RenderSpecial();
 
Son düzenleme:
Tarihe göre sırala Oy skoruna göre sırala
ETKA YAZILIM demiş ki:
burdan sökebilirsiniz

PythonApplication.cpp:
Genişlet Daralt Kopyala 
#include "StdAfx.h"
#include "../eterBase/Error.h"
#include "../eterlib/Camera.h"
#include "../eterlib/AttributeInstance.h"
#include "../gamelib/AreaTerrain.h"
#include "../EterGrnLib/Material.h"
#include "../CWebBrowser/CWebBrowser.h"

#include "resource.h"
#include "PythonApplication.h"
#include "PythonCharacterManager.h"

#include "ProcessScanner.h"

#include "HackShield.h"
#include "NProtectGameGuard.h"
#include "WiseLogicXTrap.h"
#include "CheckLatestFiles.h"
#ifdef ENABLE_SWITCHBOT
#include "PythonSwitchbot.h"
#endif

extern void GrannyCreateSharedDeformBuffer();
extern void GrannyDestroySharedDeformBuffer();

float MIN_FOG = 2400.0f;
double g_specularSpd=0.007f;

CPythonApplication * CPythonApplication::ms_pInstance;

float c_fDefaultCameraRotateSpeed = 1.5f;
float c_fDefaultCameraPitchSpeed = 1.5f;
float c_fDefaultCameraZoomSpeed = 0.05f;

CPythonApplication::CPythonApplication() :
m_bCursorVisible(TRUE),
m_bLiarCursorOn(false),
m_iCursorMode(CURSOR_MODE_HARDWARE),
m_isWindowed(false),
m_isFrameSkipDisable(false),
m_poMouseHandler(NULL),
m_dwUpdateFPS(0),
m_dwRenderFPS(0),
m_fAveRenderTime(0.0f),
m_dwFaceCount(0),
m_fGlobalTime(0.0f),
m_fGlobalElapsedTime(0.0f),
m_dwLButtonDownTime(0),
m_dwLastIdleTime(0)
{
#ifndef _DEBUG
    SetEterExceptionHandler();
#endif

    CTimer::Instance().UseCustomTime();
    m_dwWidth = 800;
    m_dwHeight = 600;

    ms_pInstance = this;
    m_isWindowFullScreenEnable = FALSE;

    m_v3CenterPosition = D3DXVECTOR3(0.0f, 0.0f, 0.0f);
    m_dwStartLocalTime = ELTimer_GetMSec();
    m_tServerTime = 0;
    m_tLocalStartTime = 0;
#ifdef DISCORD_API
    m_tAppStartTime = 0;
#endif
    m_iPort = 0;
    m_iFPS = 60;

    m_isActivateWnd = false;
    m_isMinimizedWnd = true;

    m_fRotationSpeed = 0.0f;
    m_fPitchSpeed = 0.0f;
    m_fZoomSpeed = 0.0f;

    m_fFaceSpd=0.0f;

    m_dwFaceAccCount=0;
    m_dwFaceAccTime=0;

    m_dwFaceSpdSum=0;
    m_dwFaceSpdCount=0;

    m_FlyingManager.SetMapManagerPtr(&m_pyBackground);

    m_iCursorNum = CURSOR_SHAPE_NORMAL;
    m_iContinuousCursorNum = CURSOR_SHAPE_NORMAL;

    m_isSpecialCameraMode = FALSE;
    m_fCameraRotateSpeed = c_fDefaultCameraRotateSpeed;
    m_fCameraPitchSpeed = c_fDefaultCameraPitchSpeed;
    m_fCameraZoomSpeed = c_fDefaultCameraZoomSpeed;

    m_iCameraMode = CAMERA_MODE_NORMAL;
    m_fBlendCameraStartTime = 0.0f;
    m_fBlendCameraBlendTime = 0.0f;

    m_iForceSightRange = -1;
#ifdef AUTO_HUNTING
    m_bUseAutoLogin = false;
#endif

    CCameraManager::Instance().AddCamera(EVENT_CAMERA_NUMBER);
}

CPythonApplication::~CPythonApplication()
{
}

void CPythonApplication::GetMousePosition(POINT* ppt)
{
    CMSApplication::GetMousePosition(ppt);
}

void CPythonApplication::SetMinFog(float fMinFog)
{
    MIN_FOG = fMinFog;
}

void CPythonApplication::SetFrameSkip(bool isEnable)
{
    if (isEnable)
        m_isFrameSkipDisable=false;
    else
        m_isFrameSkipDisable=true;
}

void CPythonApplication::NotifyHack(const char* c_szFormat, ...)
{
    char szBuf[1024];

    va_list args;
    va_start(args, c_szFormat);
    _vsnprintf(szBuf, sizeof(szBuf), c_szFormat, args);
    va_end(args);
    m_pyNetworkStream.NotifyHack(szBuf);
}

void CPythonApplication::GetInfo(UINT eInfo, std::string* pstInfo)
{
    switch (eInfo)
    {
    case INFO_ACTOR:
        m_kChrMgr.GetInfo(pstInfo);
        break;
    case INFO_EFFECT:
        m_kEftMgr.GetInfo(pstInfo);
        break;
    case INFO_ITEM:
        m_pyItem.GetInfo(pstInfo);
        break;
    case INFO_TEXTTAIL:
        m_pyTextTail.GetInfo(pstInfo);
        break;
    }
}

void CPythonApplication::Abort()
{
    TraceError("============================================================================================================");
    TraceError("Abort!!!!\n\n");

    PostQuitMessage(0);
}

void CPythonApplication::Exit()
{
    PostQuitMessage(0);
}

bool PERF_CHECKER_RENDER_GAME = false;

void CPythonApplication::RenderGame()
{
    if (!PERF_CHECKER_RENDER_GAME)
    {
#ifdef ENABLE_MODEL_RENDER_TARGET
        m_kRenderTargetManager.RenderBackgrounds();
#endif
        float fAspect=m_kWndMgr.GetAspect();
        float fFarClip=m_pyBackground.GetFarClip();

        m_pyGraphic.SetPerspective(30.0f, fAspect, 100.0, fFarClip);

        CCullingManager::Instance().Process();

        m_kChrMgr.Deform();
        // m_kEftMgr.Update();
#ifdef ENABLE_MODEL_RENDER_TARGET
        m_kRenderTargetManager.DeformModels();
#endif
        m_pyBackground.RenderCharacterShadowToTexture();

        m_pyGraphic.SetGameRenderState();
        m_pyGraphic.PushState();

        {
            long lx, ly;
            m_kWndMgr.GetMousePosition(lx, ly);
            m_pyGraphic.SetCursorPosition(lx, ly);
        }

        m_pyBackground.RenderSky();

        m_pyBackground.RenderBeforeLensFlare();

        m_pyBackground.RenderCloud();

        m_pyBackground.BeginEnvironment();
        m_pyBackground.Render();

        m_pyBackground.SetCharacterDirLight();
        m_kChrMgr.Render();
#ifdef ENABLE_MODEL_RENDER_TARGET
        m_kRenderTargetManager.RenderModels();
#endif
        m_pyBackground.SetBackgroundDirLight();
        m_pyBackground.RenderWater();
        m_pyBackground.RenderSnow();
        m_pyBackground.RenderEffect();

        m_pyBackground.EndEnvironment();

        m_kEftMgr.Render();
        m_pyItem.Render();
#ifdef ENABLE_NEW_SHOP_IN_CITIES
        m_pyOfflineshop.RenderEntities();
#endif
        m_FlyingManager.Render();

        m_pyBackground.BeginEnvironment();
        m_pyBackground.RenderPCBlocker();
        m_pyBackground.EndEnvironment();
#ifdef ENABLE_NEW_SHOP_IN_CITIES
    m_pyOfflineshop.RenderEntities();
#endif
        m_pyBackground.RenderAfterLensFlare();

        return;
    }

    //if (GetAsyncKeyState(VK_Z))
    //    STATEMANAGER.SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME);

    DWORD t1=ELTimer_GetMSec();
    m_kChrMgr.Deform();
    DWORD t2=ELTimer_GetMSec();
    // m_kEftMgr.Update();
    DWORD t3=ELTimer_GetMSec();
    m_pyBackground.RenderCharacterShadowToTexture();
    DWORD t4=ELTimer_GetMSec();

    m_pyGraphic.SetGameRenderState();
    m_pyGraphic.PushState();

    float fAspect=m_kWndMgr.GetAspect();
    float fFarClip=m_pyBackground.GetFarClip();

    m_pyGraphic.SetPerspective(30.0f, fAspect, 100.0, fFarClip);

    DWORD t5=ELTimer_GetMSec();

    CCullingManager::Instance().Process();

    DWORD t6=ELTimer_GetMSec();

    {
        long lx, ly;
        m_kWndMgr.GetMousePosition(lx, ly);
        m_pyGraphic.SetCursorPosition(lx, ly);
    }

    m_pyBackground.RenderSky();
    DWORD t7=ELTimer_GetMSec(); //orjinal kod
    m_kEftMgr.Update(); // eklendi
    m_pyBackground.RenderBeforeLensFlare();
    DWORD t8=ELTimer_GetMSec();
    m_pyBackground.RenderCloud();
    DWORD t9=ELTimer_GetMSec();
    m_pyBackground.BeginEnvironment();
    m_pyBackground.Render();

    m_pyBackground.SetCharacterDirLight();
    DWORD t10=ELTimer_GetMSec();
    m_kChrMgr.Render();
    DWORD t11=ELTimer_GetMSec();

    m_pyBackground.SetBackgroundDirLight();
    m_pyBackground.RenderWater();
    DWORD t12=ELTimer_GetMSec();
    m_pyBackground.RenderEffect();
    DWORD t13=ELTimer_GetMSec();
    m_pyBackground.EndEnvironment();
    m_kEftMgr.Render();
    DWORD t14=ELTimer_GetMSec();
    m_pyItem.Render();
    DWORD t15=ELTimer_GetMSec();
    m_FlyingManager.Render();
    DWORD t16=ELTimer_GetMSec();
    m_pyBackground.BeginEnvironment();
    m_pyBackground.RenderPCBlocker();
    m_pyBackground.EndEnvironment();
    DWORD t17=ELTimer_GetMSec();
    m_pyBackground.RenderAfterLensFlare();
    DWORD t18=ELTimer_GetMSec();
    DWORD tEnd=ELTimer_GetMSec();

    if (GetAsyncKeyState(VK_Z))
        STATEMANAGER.SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);

    if (tEnd-t1<3)
        return;

    static FILE* fp=fopen("perf_game_render.txt", "w");

    fprintf(fp, "GR.Total %d (Time %d)\n", tEnd-t1, ELTimer_GetMSec());
    fprintf(fp, "GR.DFM %d\n", t2-t1);
    fprintf(fp, "GR.EFT.UP %d\n", t3-t2);
    fprintf(fp, "GR.SHW %d\n", t4-t3);
    fprintf(fp, "GR.STT %d\n", t5-t4);
    fprintf(fp, "GR.CLL %d\n", t6-t5);
    fprintf(fp, "GR.BG.SKY %d\n", t7-t6);
    fprintf(fp, "GR.BG.LEN %d\n", t8-t7);
    fprintf(fp, "GR.BG.CLD %d\n", t9-t8);
    fprintf(fp, "GR.BG.MAIN %d\n", t10-t9);
    fprintf(fp, "GR.CHR %d\n",    t11-t10);
    fprintf(fp, "GR.BG.WTR %d\n", t12-t11);
    fprintf(fp, "GR.BG.EFT %d\n", t13-t12);
    fprintf(fp, "GR.EFT %d\n", t14-t13);
    fprintf(fp, "GR.ITM %d\n", t15-t14);
    fprintf(fp, "GR.FLY %d\n", t16-t15);
    fprintf(fp, "GR.BG.BLK %d\n", t17-t16);
    fprintf(fp, "GR.BG.LEN %d\n", t18-t17);


    fflush(fp);
}

void CPythonApplication::UpdateGame()
{
    DWORD t1=ELTimer_GetMSec();
    POINT ptMouse;
    GetMousePosition(&ptMouse);

    CGraphicTextInstance::Hyperlink_UpdateMousePos(ptMouse.x, ptMouse.y);

    DWORD t2=ELTimer_GetMSec();

    //if (m_isActivateWnd)
    {
        CScreen s;
        float fAspect = UI::CWindowManager::Instance().GetAspect();
        float fFarClip = CPythonBackground::Instance().GetFarClip();

        s.SetPerspective(30.0f,fAspect, 100.0f, fFarClip);
        s.BuildViewFrustum();
    }
#ifdef ENABLE_MODEL_RENDER_TARGET
    m_kRenderTargetManager.UpdateModels();
#endif
    DWORD t3=ELTimer_GetMSec();
    TPixelPosition kPPosMainActor;
    m_pyPlayer.NEW_GetMainActorPosition(&kPPosMainActor);

    DWORD t4=ELTimer_GetMSec();
    m_pyBackground.Update(kPPosMainActor.x, kPPosMainActor.y, kPPosMainActor.z);

    DWORD t5=ELTimer_GetMSec();
    m_GameEventManager.SetCenterPosition(kPPosMainActor.x, kPPosMainActor.y, kPPosMainActor.z);
    m_GameEventManager.Update();

    DWORD t6=ELTimer_GetMSec();
    m_kChrMgr.Update();
    DWORD t7=ELTimer_GetMSec(); //orjinal kod
    m_kEftMgr.Update(); // eklendi
    m_kEftMgr.UpdateSound();
    DWORD t8=ELTimer_GetMSec();
    m_FlyingManager.Update();
    DWORD t9=ELTimer_GetMSec();
    m_pyItem.Update(ptMouse);
    DWORD t10=ELTimer_GetMSec();
    m_pyPlayer.Update();
    DWORD t11=ELTimer_GetMSec();

    m_pyPlayer.NEW_GetMainActorPosition(&kPPosMainActor);
    SetCenterPosition(kPPosMainActor.x, kPPosMainActor.y, kPPosMainActor.z);
    DWORD t12=ELTimer_GetMSec();

    if (PERF_CHECKER_RENDER_GAME)
    {
        if (t12-t1>5)
        {
            static FILE* fp=fopen("perf_game_update.txt", "w");

            fprintf(fp, "GU.Total %d (Time %d)\n", t12-t1, ELTimer_GetMSec());
            fprintf(fp, "GU.GMP %d\n", t2-t1);
            fprintf(fp, "GU.SCR %d\n", t3-t2);
            fprintf(fp, "GU.MPS %d\n", t4-t3);
            fprintf(fp, "GU.BG %d\n", t5-t4);
            fprintf(fp, "GU.GEM %d\n", t6-t5);
            fprintf(fp, "GU.CHR %d\n", t7-t6);
            fprintf(fp, "GU.EFT %d\n", t8-t7);
            fprintf(fp, "GU.FLY %d\n", t9-t8);
            fprintf(fp, "GU.ITM %d\n", t10-t9);
            fprintf(fp, "GU.PLR %d\n", t11-t10);
            fprintf(fp, "GU.POS %d\n", t12-t11);
            fflush(fp);
        }
    }
}

void CPythonApplication::SkipRenderBuffering(DWORD dwSleepMSec)
{
    m_dwBufSleepSkipTime=ELTimer_GetMSec()+dwSleepMSec;
}

bool CPythonApplication::Process()
{
#if defined(CHECK_LATEST_DATA_FILES)
    if (CheckLatestFiles_PollEvent())
        return false;
#endif
#ifdef USE_AHNLAB_HACKSHIELD
    if (HackShield_PollEvent())
        return false;
#endif
#ifdef XTRAP_CLIENT_ENABLE
    XTrap_PollEvent();
#endif
    ELTimer_SetFrameMSec();

    //     m_Profiler.Clear();
    DWORD dwStart = ELTimer_GetMSec();

    ///////////////////////////////////////////////////////////////////////////////////////////////////
    static DWORD    s_dwUpdateFrameCount = 0;
    static DWORD    s_dwRenderFrameCount = 0;
    static DWORD    s_dwFaceCount = 0;
    static UINT        s_uiLoad = 0;
    static DWORD    s_dwCheckTime = ELTimer_GetMSec();

    if (ELTimer_GetMSec() - s_dwCheckTime > 1000)
    {
        m_dwUpdateFPS        = s_dwUpdateFrameCount;
        m_dwRenderFPS        = s_dwRenderFrameCount;
        m_dwLoad            = s_uiLoad;

        m_dwFaceCount        = s_dwFaceCount / max(1, s_dwRenderFrameCount);

        s_dwCheckTime        = ELTimer_GetMSec();

        s_uiLoad = s_dwFaceCount = s_dwUpdateFrameCount = s_dwRenderFrameCount = 0;

#ifdef DISCORD_API
        m_discordApi.Update();
#endif

    }

    // Update Time
    static BOOL s_bFrameSkip = false;
    static UINT s_uiNextFrameTime = ELTimer_GetMSec();

#ifdef __PERFORMANCE_CHECK__
    DWORD dwUpdateTime1=ELTimer_GetMSec();
#endif
    CTimer& rkTimer=CTimer::Instance();
    rkTimer.Advance();

    m_fGlobalTime = rkTimer.GetCurrentSecond();
    m_fGlobalElapsedTime = rkTimer.GetElapsedSecond();

    UINT uiFrameTime = rkTimer.GetElapsedMilliecond();
    s_uiNextFrameTime += uiFrameTime;

    DWORD updatestart = ELTimer_GetMSec();
#ifdef __PERFORMANCE_CHECK__
    DWORD dwUpdateTime2=ELTimer_GetMSec();
#endif
    // Network I/O
    m_pyNetworkStream.Process();
    //m_pyNetworkDatagram.Process();

    m_kGuildMarkUploader.Process();

#ifdef USE_NPROTECT_GAMEGUARD
    if (GameGuard_IsError())
        return false;
#endif

    m_kGuildMarkDownloader.Process();
    m_kAccountConnector.Process();

#ifdef __PERFORMANCE_CHECK__
    DWORD dwUpdateTime3=ELTimer_GetMSec();
#endif
    //////////////////////
    // Input Process
    // Keyboard
    UpdateKeyboard();
#ifdef __PERFORMANCE_CHECK__
    DWORD dwUpdateTime4=ELTimer_GetMSec();
#endif
    // Mouse
    POINT Point;
    if (GetCursorPos(&Point))
    {
        ScreenToClient(m_hWnd, &Point);
        OnMouseMove(Point.x, Point.y);
    }
    //////////////////////
#ifdef __PERFORMANCE_CHECK__
    DWORD dwUpdateTime5=ELTimer_GetMSec();
#endif
    //if (m_isActivateWnd)
    __UpdateCamera();
#ifdef __PERFORMANCE_CHECK__
    DWORD dwUpdateTime6=ELTimer_GetMSec();
#endif
    // Update Game Playing
    CResourceManager::Instance().Update();
#ifdef __PERFORMANCE_CHECK__
    DWORD dwUpdateTime7=ELTimer_GetMSec();
#endif
    OnCameraUpdate();
#ifdef __PERFORMANCE_CHECK__
    DWORD dwUpdateTime8=ELTimer_GetMSec();
#endif
    OnMouseUpdate();
#ifdef __PERFORMANCE_CHECK__
    DWORD dwUpdateTime9=ELTimer_GetMSec();
#endif
    OnUIUpdate();

#ifdef __PERFORMANCE_CHECK__
    DWORD dwUpdateTime10=ELTimer_GetMSec();

    if (dwUpdateTime10-dwUpdateTime1>10)
    {
        static FILE* fp=fopen("perf_app_update.txt", "w");

        fprintf(fp, "AU.Total %d (Time %d)\n", dwUpdateTime9-dwUpdateTime1, ELTimer_GetMSec());
        fprintf(fp, "AU.TU %d\n", dwUpdateTime2-dwUpdateTime1);
        fprintf(fp, "AU.NU %d\n", dwUpdateTime3-dwUpdateTime2);
        fprintf(fp, "AU.KU %d\n", dwUpdateTime4-dwUpdateTime3);
        fprintf(fp, "AU.MP %d\n", dwUpdateTime5-dwUpdateTime4);
        fprintf(fp, "AU.CP %d\n", dwUpdateTime6-dwUpdateTime5);
        fprintf(fp, "AU.RU %d\n", dwUpdateTime7-dwUpdateTime6);
        fprintf(fp, "AU.CU %d\n", dwUpdateTime8-dwUpdateTime7);
        fprintf(fp, "AU.MU %d\n", dwUpdateTime9-dwUpdateTime8);
        fprintf(fp, "AU.UU %d\n", dwUpdateTime10-dwUpdateTime9);
        fprintf(fp, "----------------------------------\n");
        fflush(fp);
    }
#endif

    m_dwCurUpdateTime = ELTimer_GetMSec() - updatestart;

    DWORD dwCurrentTime = ELTimer_GetMSec();
    BOOL  bCurrentLateUpdate = FALSE;

    s_bFrameSkip = false;

    if (dwCurrentTime > s_uiNextFrameTime)
    {
        int dt = dwCurrentTime - s_uiNextFrameTime;
        int nAdjustTime = ((float)dt / (float)uiFrameTime) * uiFrameTime;

        if ( dt >= 500 )
        {
            s_uiNextFrameTime += nAdjustTime;
            printf("FrameSkip Adjusting... %d\n",nAdjustTime);
            CTimer::Instance().Adjust(nAdjustTime);
        }

        s_bFrameSkip = true;
        bCurrentLateUpdate = TRUE;
    }

    //s_bFrameSkip = false;

    //if (dwCurrentTime > s_uiNextFrameTime)
    //{
    //    int dt = dwCurrentTime - s_uiNextFrameTime;

    //    //if (dt >= 500 || m_dwCurUpdateTime > s_uiNextFrameTime)

    //    if (dt >= 500 || m_dwCurUpdateTime > s_uiNextFrameTime)
    //    {
    //        s_uiNextFrameTime += dt / uiFrameTime * uiFrameTime;
    //        CTimer::Instance().Adjust((dt / uiFrameTime) * uiFrameTime);
    //        s_bFrameSkip = true;
    //    }
    //}

    if (m_isFrameSkipDisable)
        s_bFrameSkip = false;

#ifdef __VTUNE__
    s_bFrameSkip = false;
#endif

    if (!s_bFrameSkip)
    {
        //        static double pos=0.0f;
        //        CGrannyMaterial::TranslateSpecularMatrix(fabs(sin(pos)*0.005), fabs(cos(pos)*0.005), 0.0f);
        //        pos+=0.01f;

        CGrannyMaterial::TranslateSpecularMatrix(g_specularSpd, g_specularSpd, 0.0f);

        DWORD dwRenderStartTime = ELTimer_GetMSec();

        bool canRender = true;

        if (m_isMinimizedWnd)
        {
            canRender = false;
        }
        else
        {
#ifdef ENABLE_FIX_MOBS_LAG
            if (DEVICE_STATE_OK != CheckDeviceState())
#else
            if (m_pyGraphic.IsLostDevice())
#endif
            {
                CPythonBackground& rkBG = CPythonBackground::Instance();
#ifdef ENABLE_FIX_MOBS_LAG
                canRender = false;
#else
                rkBG.ReleaseCharacterShadowTexture();
#endif

#ifdef ENABLE_MODEL_RENDER_TARGET
                CRenderTargetManager::Instance().ReleaseRenderTargetTextures();
                if (m_pyGraphic.RestoreDevice())
                {
                    CRenderTargetManager::Instance().CreateRenderTargetTextures();
                    rkBG.CreateCharacterShadowTexture();
            }
#else
                if (m_pyGraphic.RestoreDevice())
                    rkBG.CreateCharacterShadowTexture();
#endif

                // if (m_pyGraphic.RestoreDevice())
                    // rkBG.CreateCharacterShadowTexture();
                else
                    canRender = false;
            }
        }

        if (!IsActive())
        {
            SkipRenderBuffering(3000);
        }

        if (!canRender)
        {
            SkipRenderBuffering(3000);
        }
        else
        {
            // RestoreLostDevice
            CCullingManager::Instance().Update();
            if (m_pyGraphic.Begin())
            {

                m_pyGraphic.ClearDepthBuffer();

#ifdef _DEBUG
                m_pyGraphic.SetClearColor(0.3f, 0.3f, 0.3f);
                m_pyGraphic.Clear();
#endif

                /////////////////////
                // Interface
                m_pyGraphic.SetInterfaceRenderState();

                OnUIRender();
                OnMouseRender();
                /////////////////////

                m_pyGraphic.End();

                //DWORD t1 = ELTimer_GetMSec();
                m_pyGraphic.Show();
                //DWORD t2 = ELTimer_GetMSec();

                DWORD dwRenderEndTime = ELTimer_GetMSec();

                static DWORD s_dwRenderCheckTime = dwRenderEndTime;
                static DWORD s_dwRenderRangeTime = 0;
                static DWORD s_dwRenderRangeFrame = 0;

                m_dwCurRenderTime = dwRenderEndTime - dwRenderStartTime;
                s_dwRenderRangeTime += m_dwCurRenderTime;
                ++s_dwRenderRangeFrame;

                if (dwRenderEndTime-s_dwRenderCheckTime>1000)
                {
                    m_fAveRenderTime=float(double(s_dwRenderRangeTime)/double(s_dwRenderRangeFrame));

                    s_dwRenderCheckTime=ELTimer_GetMSec();
                    s_dwRenderRangeTime=0;
                    s_dwRenderRangeFrame=0;
                }

                DWORD dwCurFaceCount=m_pyGraphic.GetFaceCount();
                m_pyGraphic.ResetFaceCount();
                s_dwFaceCount += dwCurFaceCount;

                if (dwCurFaceCount > 5000)
                {
                    if (dwRenderEndTime > m_dwBufSleepSkipTime)
                    {
                        static float s_fBufRenderTime = 0.0f;

                        float fCurRenderTime = m_dwCurRenderTime;

                        if (fCurRenderTime > s_fBufRenderTime)
                        {
                            float fRatio = fMAX(0.5f, (fCurRenderTime - s_fBufRenderTime) / 30.0f);
                            s_fBufRenderTime = (s_fBufRenderTime * (100.0f - fRatio) + (fCurRenderTime + 5) * fRatio) / 100.0f;
                        }
                        else
                        {
                            float fRatio = 0.5f;
                            s_fBufRenderTime = (s_fBufRenderTime * (100.0f - fRatio) + fCurRenderTime * fRatio) / 100.0f;
                        }

                        if (s_fBufRenderTime > 100.0f)
                            s_fBufRenderTime = 100.0f;

                        DWORD dwBufRenderTime = s_fBufRenderTime;

                        if (m_isWindowed)
                        {
                            if (dwBufRenderTime>58)
                                dwBufRenderTime=64;
                            else if (dwBufRenderTime>42)
                                dwBufRenderTime=48;
                            else if (dwBufRenderTime>26)
                                dwBufRenderTime=32;
                            else if (dwBufRenderTime>10)
                                dwBufRenderTime=16;
                            else
                                dwBufRenderTime=8;
                        }

                        //if (m_dwCurRenderTime<dwBufRenderTime)
                        //    Sleep(dwBufRenderTime-m_dwCurRenderTime);

                        m_fAveRenderTime=s_fBufRenderTime;
                    }

                    m_dwFaceAccCount += dwCurFaceCount;
                    m_dwFaceAccTime += m_dwCurRenderTime;

                    m_fFaceSpd=(m_dwFaceAccCount/m_dwFaceAccTime);

                    if (-1 == m_iForceSightRange)
                    {
                        static float s_fAveRenderTime = 16.0f;
                        float fRatio=0.3f;
                        s_fAveRenderTime=(s_fAveRenderTime*(100.0f-fRatio)+max(16.0f, m_dwCurRenderTime)*fRatio)/100.0f;


                        float fFar=25600.0f;
                        float fNear=MIN_FOG;
                        double dbAvePow=double(1000.0f/s_fAveRenderTime);
                        double dbMaxPow=60.0;
                        float fDistance=max(fNear+(fFar-fNear)*(dbAvePow)/dbMaxPow, fNear);
                        m_pyBackground.SetViewDistanceSet(0, fDistance);
                    }
                    else
                    {
                        m_pyBackground.SetViewDistanceSet(0, float(m_iForceSightRange));
                    }
                }
                else
                {
                    m_pyBackground.SetViewDistanceSet(0, 25600.0f);
                }

                ++s_dwRenderFrameCount;
            }
        }
    }

    int rest = s_uiNextFrameTime - ELTimer_GetMSec();

    if (rest > 0 && !bCurrentLateUpdate )
    {
        s_uiLoad -= rest;
        Sleep(rest);
    }

    ++s_dwUpdateFrameCount;

    s_uiLoad += ELTimer_GetMSec() - dwStart;
    //m_Profiler.ProfileByScreen();
    return true;
}

void CPythonApplication::UpdateClientRect()
{
    RECT rcApp;
    GetClientRect(&rcApp);
    OnSizeChange(rcApp.right - rcApp.left, rcApp.bottom - rcApp.top);
}

void CPythonApplication::SetMouseHandler(PyObject* poMouseHandler)
{
    m_poMouseHandler = poMouseHandler;
}

int CPythonApplication::CheckDeviceState()
{
    CGraphicDevice::EDeviceState e_deviceState = m_grpDevice.GetDeviceState();

    switch (e_deviceState)
    {
    case CGraphicDevice::DEVICESTATE_NULL:
        return DEVICE_STATE_FALSE;

    case CGraphicDevice::DEVICESTATE_BROKEN:
        return DEVICE_STATE_SKIP;
#ifdef ENABLE_FIX_MOBS_LAG
    case CGraphicDevice::DEVICESTATE_NEEDS_RESET:
        m_pyBackground.ReleaseCharacterShadowTexture();
#ifdef ENABLE_MODEL_RENDER_TARGET
        CRenderTargetManager::Instance().ReleaseRenderTargetTextures();
#endif
        Trace("DEVICESTATE_NEEDS_RESET - attempting");
        if (!m_grpDevice.Reset())
        {
            return DEVICE_STATE_SKIP;
        }
#ifdef ENABLE_MODEL_RENDER_TARGET
        CRenderTargetManager::Instance().CreateRenderTargetTextures();
#endif
        m_pyBackground.CreateCharacterShadowTexture();

        break;

    case CGraphicDevice::DEVICESTATE_OK: break;
    default:;
#else
    case CGraphicDevice::DEVICESTATE_NEEDS_RESET:
        if (!m_grpDevice.Reset())
            return DEVICE_STATE_SKIP;

        break;
#endif

    }

    return DEVICE_STATE_OK;
}

bool CPythonApplication::CreateDevice(int width, int height, int Windowed, int bit /* = 32*/, int frequency /* = 0*/)
{
    int iRet;

    m_grpDevice.InitBackBufferCount(2);
    m_grpDevice.RegisterWarningString(CGraphicDevice::CREATE_BAD_DRIVER, ApplicationStringTable_GetStringz(IDS_WARN_BAD_DRIVER, "WARN_BAD_DRIVER"));
    m_grpDevice.RegisterWarningString(CGraphicDevice::CREATE_NO_TNL, ApplicationStringTable_GetStringz(IDS_WARN_NO_TNL, "WARN_NO_TNL"));

    iRet = m_grpDevice.Create(GetWindowHandle(), width, height, Windowed ? true : false, bit,frequency);

    switch (iRet)
    {
    case CGraphicDevice::CREATE_OK:
        return true;

    case CGraphicDevice::CREATE_REFRESHRATE:
        return true;

    case CGraphicDevice::CREATE_ENUM:
    case CGraphicDevice::CREATE_DETECT:
        SET_EXCEPTION(CREATE_NO_APPROPRIATE_DEVICE);
        TraceError("CreateDevice: Enum & Detect failed");
        return false;

    case CGraphicDevice::CREATE_NO_DIRECTX:
        //PyErr_SetString(PyExc_RuntimeError, "DirectX 8.1 or greater required to run game");
        SET_EXCEPTION(CREATE_NO_DIRECTX);
        TraceError("CreateDevice: DirectX 8.1 or greater required to run game");
        return false;

    case CGraphicDevice::CREATE_DEVICE:
        //PyErr_SetString(PyExc_RuntimeError, "GraphicDevice create failed");
        SET_EXCEPTION(CREATE_DEVICE);
        TraceError("CreateDevice: GraphicDevice create failed");
        return false;

    case CGraphicDevice::CREATE_FORMAT:
        SET_EXCEPTION(CREATE_FORMAT);
        TraceError("CreateDevice: Change the screen format");
        return false;

        /*case CGraphicDevice::CREATE_GET_ADAPTER_DISPLAY_MODE:
        //PyErr_SetString(PyExc_RuntimeError, "GetAdapterDisplayMode failed");
        SET_EXCEPTION(CREATE_GET_ADAPTER_DISPLAY_MODE);
        TraceError("CreateDevice: GetAdapterDisplayMode failed");
        return false;*/

    case CGraphicDevice::CREATE_GET_DEVICE_CAPS:
        PyErr_SetString(PyExc_RuntimeError, "GetDevCaps failed");
        TraceError("CreateDevice: GetDevCaps failed");
        return false;

    case CGraphicDevice::CREATE_GET_DEVICE_CAPS2:
        PyErr_SetString(PyExc_RuntimeError, "GetDevCaps2 failed");
        TraceError("CreateDevice: GetDevCaps2 failed");
        return false;

    default:
        if (iRet & CGraphicDevice::CREATE_OK)
        {
            //if (iRet & CGraphicDevice::CREATE_BAD_DRIVER)
            //{
            //    LogBox(ApplicationStringTable_GetStringz(IDS_WARN_BAD_DRIVER), NULL, GetWindowHandle());
            //}
            if (iRet & CGraphicDevice::CREATE_NO_TNL)
            {
                CGrannyLODController::SetMinLODMode(true);
                //LogBox(ApplicationStringTable_GetStringz(IDS_WARN_NO_TNL), NULL, GetWindowHandle());
            }
            return true;
        }

        //PyErr_SetString(PyExc_RuntimeError, "Unknown Error!");
        SET_EXCEPTION(UNKNOWN_ERROR);
        TraceError("CreateDevice: Unknown Error!");
        return false;
    }
}

void CPythonApplication::Loop()
{
    while (1)
    {
        if (IsMessage())
        {
            if (!MessageProcess())
                break;
        }
        else
        {
            if (!Process())
                break;

            m_dwLastIdleTime=ELTimer_GetMSec();
        }
    }
}

#define ENABLE_LOAD_ITEM_LIST_FROM_ROOT
// SUPPORT_NEW_KOREA_SERVER
bool LoadLocaleData(const char* localePath)
{
    NANOBEGIN
        CPythonNonPlayer&    rkNPCMgr    = CPythonNonPlayer::Instance();
    CItemManager&        rkItemMgr    = CItemManager::Instance();
    CPythonSkill&        rkSkillMgr    = CPythonSkill::Instance();
#ifdef ENABLE_NEW_PET_SYSTEM
    CPythonSkillPet& rkSkillPetMgr = CPythonSkillPet::Instance();
#endif
    CPythonNetworkStream& rkNetStream = CPythonNetworkStream::Instance();

    char szItemList[256];
    char szItemProto[256];
    char szItemDesc[256];
#ifdef ENABLE_SHINING_SYSTEM
    char szShiningTable[256];
#endif
#ifdef ENABLE_NEW_PET_SYSTEM
    char szSkillPetFileName[256];
#endif
    char szMobProto[256];
    char szSkillDescFileName[256];
    char szSkillTableFileName[256];
    char szInsultList[256];
#ifdef ENABLE_LOAD_ITEM_LIST_FROM_ROOT
    snprintf(szItemList,    sizeof(szItemList) ,    "item_list.txt");
#else
    snprintf(szItemList,    sizeof(szItemList) ,    "%s/item_list.txt",    localePath);
#endif
    snprintf(szItemProto,    sizeof(szItemProto),    "%s/item_proto",    localePath);
    snprintf(szItemDesc,    sizeof(szItemDesc),    "%s/itemdesc.txt",    localePath);
#ifdef ENABLE_SHINING_SYSTEM
    snprintf(szShiningTable, sizeof(szShiningTable), "%s/shining_table.txt", localePath);
#endif
#ifdef ENABLE_NEW_PET_SYSTEM
    snprintf(szSkillPetFileName, sizeof(szSkillPetFileName), "%s/pet_skill.txt", localePath);
#endif
    snprintf(szMobProto,    sizeof(szMobProto),    "%s/mob_proto",        localePath);
    snprintf(szSkillDescFileName, sizeof(szSkillDescFileName),    "%s/SkillDesc.txt", localePath);
    snprintf(szSkillTableFileName, sizeof(szSkillTableFileName),    "%s/SkillTable.txt", localePath);
    snprintf(szInsultList,    sizeof(szInsultList),    "%s/insult.txt", localePath);

    rkNPCMgr.Destroy();
    rkItemMgr.Destroy();
    rkSkillMgr.Destroy();
#ifdef ENABLE_NEW_PET_SYSTEM
    rkSkillPetMgr.Destroy();
#endif

    if (!rkItemMgr.LoadItemList(szItemList))
    {
        TraceError("LoadLocaleData - LoadItemList(%s) Error", szItemList);
    }

    if (!rkItemMgr.LoadItemTable(szItemProto))
    {
        TraceError("LoadLocaleData - LoadItemProto(%s) Error", szItemProto);
        return false;
    }

    if (!rkItemMgr.LoadItemDesc(szItemDesc))
    {
        Tracenf("LoadLocaleData - LoadItemDesc(%s) Error", szItemDesc);
    }

#ifdef ENABLE_SHINING_SYSTEM
    if (!rkItemMgr.LoadShiningTable(szShiningTable))
    {
        Tracenf("LoadLocaleData - LoadShiningTable(%s) Error", szShiningTable);
    }
#endif

    if (!rkNPCMgr.LoadNonPlayerData(szMobProto))
    {
        TraceError("LoadLocaleData - LoadMobProto(%s) Error", szMobProto);
        return false;
    }

    if (!rkSkillMgr.RegisterSkillDesc(szSkillDescFileName))
    {
        TraceError("LoadLocaleData - RegisterSkillDesc(%s) Error", szMobProto);
        return false;
    }

#ifdef ENABLE_NEW_PET_SYSTEM
    if (!rkSkillPetMgr.RegisterSkillPet(szSkillPetFileName))
    {
        TraceError("LoadLocaleData - RegisterSkillPet(%s) Error", szSkillPetFileName);
        return false;
    }
#endif

    if (!rkSkillMgr.RegisterSkillTable(szSkillTableFileName))
    {
        TraceError("LoadLocaleData - RegisterSkillTable(%s) Error", szMobProto);
        return false;
    }

    if (!rkNetStream.LoadInsultList(szInsultList))
    {
        Tracenf("CPythonApplication - CPythonNetworkStream::LoadInsultList(%s)", szInsultList);
    }

#ifdef ENABLE_NPC_WEAR_ITEM
    if (!rkNPCMgr.LoadNPCWear("locale/common/npc_wear.txt"))
    {
        Tracenf("CPythonApplication - CPythonNonPlayer::LoadNPCWear()");
    }
#endif

    if (LocaleService_IsYMIR())
    {
        char szEmpireTextConvFile[256];
        for (DWORD dwEmpireID=1; dwEmpireID<=3; ++dwEmpireID)
        {
            sprintf(szEmpireTextConvFile, "%s/lang%d.cvt", localePath, dwEmpireID);
            if (!rkNetStream.LoadConvertTable(dwEmpireID, szEmpireTextConvFile))
            {
                TraceError("LoadLocaleData - CPythonNetworkStream::LoadConvertTable(%d, %s) FAILURE", dwEmpireID, szEmpireTextConvFile);
            }
        }
    }

#ifdef ENABLE_ACCE_SYSTEM
    char szItemScale[256]{};
    // snprintf(szItemScale, sizeof(szItemScale), "acce/item_scale.txt");
    snprintf(szItemScale, sizeof(szItemScale), "locale/tr/item_scale.txt");

    if (!rkItemMgr.LoadItemScale(szItemScale))
    {
        Tracenf("LoadLocaleData: error while loading %s.", szItemScale);
        return false;
    }
#endif

    NANOEND
        return true;
}
// END_OF_SUPPORT_NEW_KOREA_SERVER

unsigned __GetWindowMode(bool windowed)
{
    if (windowed)
        return WS_OVERLAPPED | WS_CAPTION |   WS_SYSMENU | WS_MINIMIZEBOX;

    return WS_POPUP;
}

bool CPythonApplication::Create(PyObject * poSelf, const char * c_szName, int width, int height, int Windowed)
{
    NANOBEGIN
        Windowed = CPythonSystem::Instance().IsWindowed() ? 1 : 0;

    bool bAnotherWindow = false;

    if (FindWindow(NULL, c_szName))
        bAnotherWindow = true;

    m_dwWidth = width;
    m_dwHeight = height;

    // Window
    UINT WindowMode = __GetWindowMode(Windowed ? true : false);

    if (!CMSWindow::Create(c_szName, 4, 0, WindowMode, ::LoadIcon( GetInstance(), MAKEINTRESOURCE( IDI_METIN2 ) ), IDC_CURSOR_NORMAL))
    {
        //PyErr_SetString(PyExc_RuntimeError, "CMSWindow::Create failed");
        TraceError("CMSWindow::Create failed");
        SET_EXCEPTION(CREATE_WINDOW);
        return false;
    }

#ifdef USE_NPROTECT_GAMEGUARD
    if (!GameGuard_Run(CMSWindow::GetWindowHandle()))
        return false;
#endif
#ifdef XTRAP_CLIENT_ENABLE
    if (!XTrap_CheckInit())
        return false;
#endif

    if (m_pySystem.IsUseDefaultIME())
    {
        CPythonIME::Instance().UseDefaultIME();
    }

    if (!m_pySystem.IsWindowed() && (m_pySystem.IsUseDefaultIME() || LocaleService_IsEUROPE()))
    {
        m_isWindowed = false;
        m_isWindowFullScreenEnable = TRUE;
        __SetFullScreenWindow(GetWindowHandle(), width, height, m_pySystem.GetBPP());

        Windowed = true;
    }
    else
    {
        AdjustSize(m_pySystem.GetWidth(), m_pySystem.GetHeight());

        if (Windowed)
        {
            m_isWindowed = true;

            if (bAnotherWindow)
            {
                RECT rc;

                GetClientRect(&rc);

                int windowWidth = rc.right - rc.left;
                int windowHeight = (rc.bottom - rc.top);

                CMSApplication::SetPosition(GetScreenWidth() - windowWidth, GetScreenHeight() - 60 - windowHeight);
            }
        }
        else
        {
            m_isWindowed = false;
            SetPosition(0, 0);
        }
    }

    NANOEND
        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

        // Cursor
        if (!CreateCursors())
        {
            //PyErr_SetString(PyExc_RuntimeError, "CMSWindow::Cursors Create Error");
            TraceError("CMSWindow::Cursors Create Error");
            SET_EXCEPTION("CREATE_CURSOR");
            return false;
        }

        if (!m_pySystem.IsNoSoundCard())
        {
            // Sound
            if (!m_SoundManager.Create())
            {
                //        LogBox(ApplicationStringTable_GetStringz(IDS_WARN_NO_SOUND_DEVICE));
            }
        }

        extern bool GRAPHICS_CAPS_SOFTWARE_TILING;

        if (!m_pySystem.IsAutoTiling())
            GRAPHICS_CAPS_SOFTWARE_TILING = m_pySystem.IsSoftwareTiling();

        // Device
        if (!CreateDevice(m_pySystem.GetWidth(), m_pySystem.GetHeight(), Windowed, m_pySystem.GetBPP(), m_pySystem.GetFrequency()))
            return false;

        GrannyCreateSharedDeformBuffer();

        if (m_pySystem.IsAutoTiling())
        {
            if (m_grpDevice.IsFastTNL())
            {
                m_pyBackground.ReserveSoftwareTilingEnable(false);
            }
            else
            {
                m_pyBackground.ReserveSoftwareTilingEnable(true);
            }
        }
        else
        {
            m_pyBackground.ReserveSoftwareTilingEnable(m_pySystem.IsSoftwareTiling());
        }

        SetVisibleMode(true);

        if (m_isWindowFullScreenEnable) //m_pySystem.IsUseDefaultIME() && !m_pySystem.IsWindowed())
        {
            SetWindowPos(GetWindowHandle(), HWND_TOP, 0, 0, width, height, SWP_SHOWWINDOW);
        }

        if (!InitializeKeyboard(GetWindowHandle()))
            return false;

        m_pySystem.GetDisplaySettings();

        // Mouse
        if (m_pySystem.IsSoftwareCursor())
            SetCursorMode(CURSOR_MODE_SOFTWARE);
        else
            SetCursorMode(CURSOR_MODE_HARDWARE);

        // Network
        if (!m_netDevice.Create())
        {
            //PyErr_SetString(PyExc_RuntimeError, "NetDevice::Create failed");
            TraceError("NetDevice::Create failed");
            SET_EXCEPTION("CREATE_NETWORK");
            return false;
        }

        if (!m_grpDevice.IsFastTNL())
            CGrannyLODController::SetMinLODMode(true);

        m_pyItem.Create();

        // Other Modules
        DefaultFont_Startup();

        CPythonIME::Instance().Create(GetWindowHandle());
        CPythonIME::Instance().SetText("", 0);
        CPythonTextTail::Instance().Initialize();
#ifdef DISCORD_API
        m_tAppStartTime = time(0);
        m_discordApi.Initialize();
#endif
        // Light Manager
        m_LightManager.Initialize();

        CGraphicImageInstance::CreateSystem(32);

        STICKYKEYS sStickKeys;
        memset(&sStickKeys, 0, sizeof(sStickKeys));
        sStickKeys.cbSize = sizeof(sStickKeys);
        SystemParametersInfo( SPI_GETSTICKYKEYS, sizeof(sStickKeys), &sStickKeys, 0 );
        m_dwStickyKeysFlag = sStickKeys.dwFlags;

        sStickKeys.dwFlags &= ~(SKF_AVAILABLE|SKF_HOTKEYACTIVE);
        SystemParametersInfo( SPI_SETSTICKYKEYS, sizeof(sStickKeys), &sStickKeys, 0 );

        // SphereMap
        CGrannyMaterial::CreateSphereMap(0, "d:/ymir work/special/spheremap.jpg");
        CGrannyMaterial::CreateSphereMap(1, "d:/ymir work/special/spheremap01.jpg");
        return true;
}

void CPythonApplication::SetGlobalCenterPosition(LONG x, LONG y)
{
    CPythonBackground& rkBG=CPythonBackground::Instance();
    rkBG.GlobalPositionToLocalPosition(x, y);

    float z = CPythonBackground::Instance().GetHeight(x, y);

    CPythonApplication::Instance().SetCenterPosition(x, y, z);
}

void CPythonApplication::SetCenterPosition(float fx, float fy, float fz)
{
    m_v3CenterPosition.x = +fx;
    m_v3CenterPosition.y = -fy;
    m_v3CenterPosition.z = +fz;
}

void CPythonApplication::GetCenterPosition(TPixelPosition * pPixelPosition)
{
    pPixelPosition->x = +m_v3CenterPosition.x;
    pPixelPosition->y = -m_v3CenterPosition.y;
    pPixelPosition->z = +m_v3CenterPosition.z;
}


void CPythonApplication::SetServerTime(time_t tTime)
{
    m_dwStartLocalTime    = ELTimer_GetMSec();
    m_tServerTime        = tTime;
    m_tLocalStartTime    = time(0);
}

time_t CPythonApplication::GetServerTime()
{
    return (ELTimer_GetMSec() - m_dwStartLocalTime) + m_tServerTime;
}

time_t CPythonApplication::GetServerTimeStamp()
{
    return (time(0) - m_tLocalStartTime) + m_tServerTime;
}

float CPythonApplication::GetGlobalTime()
{
    return m_fGlobalTime;
}

float CPythonApplication::GetGlobalElapsedTime()
{
    return m_fGlobalElapsedTime;
}

void CPythonApplication::SetFPS(int iFPS)
{
    m_iFPS = iFPS;
}

int CPythonApplication::GetWidth()
{
    return m_dwWidth;
}

int CPythonApplication::GetHeight()
{
    return m_dwHeight;
}

void CPythonApplication::SetConnectData(const char * c_szIP, int iPort)
{
    m_strIP = c_szIP;
    m_iPort = iPort;
}

void CPythonApplication::GetConnectData(std::string & rstIP, int & riPort)
{
    rstIP    = m_strIP;
    riPort    = m_iPort;
}

void CPythonApplication::EnableSpecialCameraMode()
{
    m_isSpecialCameraMode = TRUE;
}

void CPythonApplication::SetCameraSpeed(int iPercentage)
{
    m_fCameraRotateSpeed = c_fDefaultCameraRotateSpeed * float(iPercentage) / 100.0f;
    m_fCameraPitchSpeed = c_fDefaultCameraPitchSpeed * float(iPercentage) / 100.0f;
    m_fCameraZoomSpeed = c_fDefaultCameraZoomSpeed * float(iPercentage) / 100.0f;
}

void CPythonApplication::SetForceSightRange(int iRange)
{
    m_iForceSightRange = iRange;
}

void CPythonApplication::Clear()
{
    m_pySystem.Clear();
}

void CPythonApplication::Destroy()
{
    WebBrowser_Destroy();

    // SphereMap
    CGrannyMaterial::DestroySphereMap();

    m_kWndMgr.Destroy();

    CPythonSystem::Instance().SaveConfig();
#ifdef ENABLE_MODEL_RENDER_TARGET
    m_kRenderTargetManager.Destroy();
#endif
    DestroyCollisionInstanceSystem();

    m_pySystem.SaveInterfaceStatus();

    m_pyEventManager.Destroy();
    m_FlyingManager.Destroy();

    m_pyMiniMap.Destroy();

    m_pyChat.Destroy();
    m_kChrMgr.Destroy();
    m_pyTextTail.Destroy();
    m_RaceManager.Destroy();

    m_pyItem.Destroy();
    m_kItemMgr.Destroy();

    m_pyBackground.Destroy();

    m_kEftMgr.Destroy();
    m_LightManager.Destroy();

    // DEFAULT_FONT
    DefaultFont_Cleanup();
    // END_OF_DEFAULT_FONT

    GrannyDestroySharedDeformBuffer();

    m_pyGraphic.Destroy();
    //m_pyNetworkDatagram.Destroy();

  m_pyRes.Destroy();

    m_kGuildMarkDownloader.Disconnect();

    CGrannyModelInstance::DestroySystem();
    CGraphicImageInstance::DestroySystem();

#ifdef DISCORD_API
    m_discordApi.Shutdown();
#endif

    m_SoundManager.Destroy();
    m_grpDevice.Destroy();

    //CSpeedTreeForestDirectX8::Instance().Clear();

    CAttributeInstance::DestroySystem();
    CTextFileLoader::DestroySystem();
    DestroyCursors();

    CMSApplication::Destroy();

    STICKYKEYS sStickKeys;
    memset(&sStickKeys, 0, sizeof(sStickKeys));
    sStickKeys.cbSize = sizeof(sStickKeys);
    sStickKeys.dwFlags = m_dwStickyKeysFlag;
    SystemParametersInfo( SPI_SETSTICKYKEYS, sizeof(sStickKeys), &sStickKeys, 0 );
}
Hepsini görmek için tıklayın...
Bu dosyalarda bahsettiğim olayı göremedim
 
Upvote 0 Downvote
pardon yanlıs atmısım :) kusuruma bakmayın atıyorum
 
Upvote 0 Downvote

Benzer konular

orhanha4rd
Yardım Failed to item data syserr
Yanıt
6
Gösterim
627
orhanha4rd
orhanha4rd
esenkara88
Yardım Failed to connect to 127.0.0.1:15000 with Hedef makine etkin olarak reddettiinden balantı kurulamadı
Yanıt
0
Gösterim
209
esenkara88
esenkara88
orhanha4rd
  • Kilitli
  • Çözüldü
Çözüldü ch1 core1 syser
Yanıt
4
Gösterim
684
orhanha4rd
orhanha4rd
K
Yardım Game Src Paketleme Hatası Alıyorum
Yanıt
8
Gösterim
2K
iMeR
iMeR
cerooor
  • Kilitli
  • Çözüldü
Çözüldü socket_connect: HOST 127.0.0.1:15900, could not connect.
Yanıt
11
Gösterim
986
cerooor
cerooor
Geri
Üst