First-person perspective in Metin2 by Gemini Pro

pythonplayer.cpp

like

bool CPythonPlayer::__GetPickedGroundPos(TPixelPosition* pkPPosPicked)
{
    CPythonBackground& rkBG=CPythonBackground::Instance();

    TPixelPosition kPPosPicked;
    if (rkBG.GetPickingPoint(pkPPosPicked))
    {
        pkPPosPicked->y=-pkPPosPicked->y;
        return true;
    }

    return false;
}






#include "../eterlib/Camera.h"
#include "PythonChat.h"



// #include "PythonChat.h" // Sohbet penceresine mesaj göndermek için gerekli



// #include "../gamelib/Camera.h"
// #include "PythonChat.h"

void CPythonPlayer::ToggleFPSMode()
{
    m_isFPSMode = !m_isFPSMode;

    if (auto* pMainInst = CPythonCharacterManager::Instance().GetMainInstancePtr(); pMainInst)
    {
        if (auto* pGraphic = pMainInst->GetGraphicThingInstancePtr(); pGraphic)
        {
            if (auto* pCamera = CCameraManager::Instance().GetCurrentCamera(); pCamera)
            {
                // 1. Kameraya modu bildiriyoruz (Motorun ayarları bozmasını engeller)
                pCamera->SetFPSMode(m_isFPSMode);

                if (m_isFPSMode)
                {
                    pGraphic->Hide();
               
                    // Artık kilitli olduğu için bu komutlar kalıcı olacak
                    pCamera->SetTargetHeight(CAMERA_TARGET_FACE);
                    pCamera->SetDistance(1.0f);
               
                    float currentPitch = pCamera->GetPitch();
                    pCamera->Pitch(10.0f - currentPitch);
               
                    CPythonChat::Instance().AppendChat(CHAT_TYPE_INFO, "FPS Modu: Aktif (Goz Hizasi)");
                }
                else
                {
                    pGraphic->Show();
               
                    // Kilit kalktığı için normal değerlere dönmesine izin veriyoruz
                    pCamera->SetTargetHeight(CAMERA_TARGET_STANDARD);
                    pCamera->SetDistance(2500.0f);
               
                    float currentPitch = pCamera->GetPitch();
                    pCamera->Pitch(30.0f - currentPitch);
               
                    CPythonChat::Instance().AppendChat(CHAT_TYPE_INFO, "FPS Modu: Kapali (Ucuncu Sahis)");
                }
            }
        }
    }
}


pyhonplayer.h

    protected:
        float                    MOVABLE_GROUND_DISTANCE;

    private:
        std::map<DWORD, DWORD> m_kMap_dwAffectIndexToSkillIndex;
   
   
   
   
public:
    // ... (Mevcut kodlar) ...

    // C++20 [[nodiscard]] ve constexpr kullanımı
    void ToggleFPSMode();
    [[nodiscard]] constexpr bool IsFPSMode() const noexcept { return m_isFPSMode; }

private:
    // ... (Mevcut kodlar) ...
 
    // C++20 varsayılan üye başlatma
    bool m_isFPSMode{ false };
   
   
   
   
   
};

extern const int c_iFastestSendingCount;
extern const int c_iSlowestSendingCount;


pythonapplicitaonevent

void CPythonApplication::OnKeyDown(int iIndex)
{
    UI::CWindowManager& rkWndMgr=UI::CWindowManager::Instance();

    if (DIK_ESCAPE == iIndex)
    {
#if defined(ENABLE_LOADING_PERFORMANCE) && defined(__ALLOW_ESCAPE_LOADING__)
        CPythonNetworkStream& rkInstance = CPythonNetworkStream::Instance();
        if (rkInstance.DirectEnterMode_IsSet() || rkInstance.IsLoadingPhase())
        {
            rkInstance.LogOutGame();
            return;
        }
#endif
        rkWndMgr.RunPressEscapeKey();
    }



// DIK_V, klavyedeki V tuşunun DirectInput karşılığıdır.
    if (iIndex == DIK_K)
    {
        CPythonPlayer::Instance().ToggleFPSMode();
    }





    rkWndMgr.RunKeyDown(iIndex);
}


camera.h

    private:
        void ProcessTerrainCollision();
        void ProcessBuildingCollision();
   
   
   
public:
        // C++20 Standartlarında FPS Modu Tanımlamaları
        void SetFPSMode(bool isFPS);
        [[nodiscard]] constexpr bool IsFPSMode() const noexcept { return m_isFPSMode; }
   
   
   

private:
        bool m_bProcessTerrainCollision;
        bool m_isFPSMode{ false }; // C++20 varsayılan üye başlatma (default member initialization)

        static float CAMERA_MIN_DISTANCE;
        static float CAMERA_MAX_DISTANCE;
};



camera.cpp

void CCamera::Roll(const float fRollDelta)
{
//    if (IsLock())
//        return;

    RotateEyeAroundTarget(0.0f, fRollDelta);
}

void CCamera::SetDistance(const float fdistance)
{
    // FPS modundaysak motorun gönderdiği mesafeyi reddet, 1.0f'e kilitle
    if (m_isFPSMode)
    {
        Zoom(1.0f / m_fDistance);
        return;
    }

    Zoom(fdistance / m_fDistance);
}


#include "StdAfx.h"
#include "../eterBase/Utils.h"
#include "Camera.h"

const float c_fDefaultResistance = 0.3f;

CCameraManager aCameraManager;    // CCameraManager Instance




void CCamera::SetFPSMode(bool isFPS)
{
    m_isFPSMode = isFPS;
}






void CCamera::SetCameraMaxDistance(float fMax)
{
    CAMERA_MAX_DISTANCE = fMax;
}

float CCamera::GetTargetHeight()
{
    return m_fTarget_;
}

void CCamera::SetTargetHeight(float fTarget)
{
    // FPS modundaysak motorun gönderdiği yüksekliği reddet, yüz hizasına kilitle
    if (m_isFPSMode)
    {
        m_fTarget_ = CAMERA_TARGET_FACE;
        return;
    }
 
    m_fTarget_ = fTarget;
}


cameraproreduce


void CCamera::Update()
{
//     ProcessBuildingCollision();

    RotateEyeAroundTarget(m_v3AngularVelocity.z, m_v3AngularVelocity.x);

    float fNewDistance=fMAX(CAMERA_MIN_DISTANCE, fMIN( CAMERA_MAX_DISTANCE, GetDistance() - m_v3AngularVelocity.y ) );
    SetDistance(fNewDistance);

    if (m_bProcessTerrainCollision)
         ProcessTerrainCollision();

    m_v3AngularVelocity *= 0.5f;
    if (fabs(m_v3AngularVelocity.x) < 1.0f)
        m_v3AngularVelocity.x = 0.0f;
    if (fabs(m_v3AngularVelocity.y) < 1.0f)
        m_v3AngularVelocity.y = 0.0f;
    if (fabs(m_v3AngularVelocity.z) < 1.0f)
        m_v3AngularVelocity.z = 0.0f;

    const float CAMERA_MOVABLE_DISTANCE = CAMERA_MAX_DISTANCE - CAMERA_MIN_DISTANCE;
    const float CAMERA_TARGET_DELTA = CAMERA_TARGET_FACE - CAMERA_TARGET_STANDARD;
    float fCameraCurMovableDistance=CAMERA_MAX_DISTANCE - GetDistance();
    float fNewTargetHeight = CAMERA_TARGET_STANDARD + CAMERA_TARGET_DELTA * fCameraCurMovableDistance / CAMERA_MOVABLE_DISTANCE;

    SetTargetHeight(fNewTargetHeight);

    // Cinematic
#ifdef __20040725_CAMERA_WORK__
    m_MovementPosition += m_MovementSpeed;

    if (0.0f != m_MovementPosition.m_fViewDir)
        MoveFront(m_MovementPosition.m_fViewDir);
    if (0.0f != m_MovementPosition.m_fCrossDir)
        MoveAlongCross(m_MovementPosition.m_fCrossDir);
    if (0.0f != m_MovementPosition.m_fUpDir)
        MoveVertical(m_MovementPosition.m_fUpDir);
#endif
}