Compiling error: local function definitions are illegal?

[SaskxD]

Im compiling and everytime i get this error on this line :x...can anybody help me please so much?

#include "r3dPCH.h"
#include "r3d.h"
 
#include "r3dBackgroundTaskDispatcher.h"
 
#include "d3dfont.h"
 
#include "GameCommon.h"
#include "Gameplay_Params.h"
 
#include "UI\HUD_TPSGame.h"
#include "ObjectsCode/AI/AI_Player.h"
#include "ObjectsCode/AI/AI_PlayerAnim.h"
#include "ObjectsCode/Gameplay/BasePlayerSpawnPoint.h"
#include "ObjectsCode/weapons/WeaponArmory.h"
 
#include "APIScaleformGfx.h"
 
#include "multiplayer/ClientGameLogic.h"
 
#include "HUDCameraEffects.h"
 
#include "UI\HUDDisplay.h"
#include "UI\HUDPause.h"
#include "UI\HUDAttachments.h"
#include "UI\HUDActionUI.h"
#include "UI\HUDGeneralStore.h"
#include "UI\HUDVault.h"
 
#include "..\GameEngine\gameobjects\obj_Vehicle.h"
 
#include "rendering/Deffered/D3DMiscFunctions.h"
 
extern float GameFOV;
 
HUDDisplay*    hudMain = NULL;
HUDPause*    hudPause = NULL;
HUDAttachments*    hudAttm = NULL;
HUDActionUI*    hudActionUI = NULL;
HUDGeneralStore* hudGeneralStore = NULL;
HUDVault* hudVault = NULL;
 
#define VEHICLE_CINEMATIC_MODE 0
 
void TPSGameHUD_AddHitEffect(GameObject* from)
{
    obj_Player* pl = gClientLogic().localPlayer_;
    if(!pl) return;
    if(pl->bDead) return;
 
    pl->BloodEffect = 3.0f;
}
 
 
 
TPSGameHUD::TPSGameHUD()
{
    FPS_Acceleration.Assign(0,0,0);
    FPS_vViewOrig.Assign(0,0,0);
    FPS_ViewAngle.Assign(0,0,0);
    FPS_vVision.Assign(0,0,0);
    FPS_vRight.Assign(0,0,0);
    FPS_vUp.Assign(0,0,0);
    FPS_vForw.Assign(0,0,0);
    cameraRayLen = 20000.0f;
}
 
TPSGameHUD::~TPSGameHUD()
{
}
 
static bool TPSGameHud_Inited;
void TPSGameHUD_OnStartGame()
{
    const GBGameInfo& ginfo = gClientLogic().m_gameInfo;
 
    hudMain = new HUDDisplay();
    hudPause = new HUDPause();
    hudActionUI = new HUDActionUI();
    hudAttm = new HUDAttachments();
    hudGeneralStore = new HUDGeneralStore();
    hudVault = new HUDVault();
 
    hudMain->Init();
    hudPause->Init();
    hudActionUI->Init();
    hudAttm->Init();
    hudGeneralStore->Init();
    hudVault->Init();
 
    Mouse->Hide(true);
    // lock mouse to a window when playing a game
    d_mouse_window_lock->SetBool(true);
    Mouse->SetRange(r3dRenderer->HLibWin);
 
 
    extern int g_CCBlackWhite;
    extern float g_fCCBlackWhitePwr;
    g_CCBlackWhite = false;
    g_fCCBlackWhitePwr = 0.0f;
 
    TPSGameHud_Inited = true;
}
 
void TPSGameHUD :: DestroyPure()
{
    if(TPSGameHud_Inited)
    {
        TPSGameHud_Inited = false;
 
        hudPause->Unload();
        hudMain->Unload();
        hudActionUI->Unload();
        hudAttm->Unload();
        hudGeneralStore->Unload();
        hudVault->Unload();
 
        SAFE_DELETE(hudMain);
        SAFE_DELETE(hudPause);
        SAFE_DELETE(hudActionUI);
        SAFE_DELETE(hudAttm);
        SAFE_DELETE(hudGeneralStore);
        SAFE_DELETE(hudVault);
    }
}
 
void TPSGameHUD :: SetCameraDir (r3dPoint3D vPos )
{
 
}
 
r3dPoint3D TPSGameHUD :: GetCameraDir () const
{
    return r3dVector(1,0,0);
}
 
 
extern    PlayerStateVars_s TPSHudCameras[3][PLAYER_NUM_STATES];
extern    Playerstate_e ActiveCameraRigID;
extern    PlayerStateVars_s ActiveCameraRig;
 
extern     Playerstate_e CurrentState;
extern     PlayerStateVars_s CurrentRig;
extern     PlayerStateVars_s SourceRig;
extern     PlayerStateVars_s TargetRig;
extern     float LerpValue;
extern    r3dPoint3D TPSHudCameraTarget;
 
extern  float    TPSCameraPointToAdj[3];
extern  float   TPSCameraPointToAdjCrouch[3];
 
void TPSGameHUD :: InitPure()
{
    // reinit hud rigs based on camera mode
    CurrentRig = TPSHudCameras[g_camera_mode->GetInt()][PLAYER_IDLE];
    SourceRig  = CurrentRig;
    TargetRig  = CurrentRig;
}
 
 
// camPos = current camera pos. target = player's head pos
bool CheckCameraCollision(r3dPoint3D& camPos, const r3dPoint3D& target, bool checkCamera)
{
    R3DPROFILE_FUNCTION("CheckCameraCollision");
 
    r3dPoint3D origCamPos = camPos;
    int LoopBreaker = 0;
 
    r3dPoint3D motion = (camPos - target);
    float motionLen = motion.Length();
    int MaxLoopBreaker = 10;
    if(motionLen > 0.1f)
    {
        motion.Normalize();
        MaxLoopBreaker = int(ceilf(motionLen/0.05f));
 
        PxSphereGeometry camSphere(0.3f);
        PxTransform camPose(PxVec3(target.x, target.y, target.z), PxQuat(0,0,0,1));
 
        PxSweepHit sweepResults[32];
        bool blockingHit;
        PxSceneQueryFilterData filter(PxFilterData(COLLIDABLE_PLAYER_COLLIDABLE_MASK, 0, 0, 0), PxSceneQueryFilterFlag::eSTATIC|PxSceneQueryFilterFlag::eDYNAMIC);
        while(int numRes=g_pPhysicsWorld->PhysXScene->sweepMultiple(camSphere, camPose, PxVec3(motion.x, motion.y, motion.z), motionLen, PxSceneQueryFlag::eINITIAL_OVERLAP|PxSceneQueryFlag::eNORMAL, sweepResults, 32, blockingHit, filter) && LoopBreaker<MaxLoopBreaker)
        {
            if(numRes == -1)
            {
                r3d_assert(false);
                break;
            }
            /* PxVec3 collNormal = PxVec3(0,0,0);
            for(int i=0; i<numRes; ++i)
            {
            collNormal += sweepResults[i].normal;
            }
 
            collNormal.normalize();*/
 
            //r3dPoint3D tmp(collNormal.x, collNormal.y, collNormal.z);
            r3dPoint3D tmp = -motion;
            tmp.Normalize();
            camPos += tmp * 0.05f;
 
            LoopBreaker++;
 
            motion = (camPos - target);
            motionLen = motion.Length();
            if(motionLen < 0.005f)
            {
                LoopBreaker = MaxLoopBreaker;
                break;
            }
            motion.Normalize();
        }
    }
 
    if(checkCamera)
    {
        extern bool g_CameraInsidePlayer;
        if((camPos - target).Length() < 0.6f)
            g_CameraInsidePlayer = true;
        else
            g_CameraInsidePlayer = false;
 
        if(g_camera_mode->GetInt()==2) // in FPS mode this check not needed
            g_CameraInsidePlayer = false;
    }
 
    return (LoopBreaker == MaxLoopBreaker);
}
 
float g_shootCameraShakeTimer = 0.0f;
void Get_Camera_Bob(r3dPoint3D& camBob, r3dPoint3D& camUp, const obj_Player* player)
{
    r3d_assert(player);
    camBob.Assign(0,0,0);
    camUp.Assign(0,1,0);
 
    static float accumul = 0.0f;
    accumul += r3dGetFrameTime()*1.0f*u_GetRandom(0.75f, 1.25f);
 
 
    // only use this in FPS, but calculate out here.
 
    float wave = r3dSin(accumul) * g_shootCameraShakeTimer;
    if(g_shootCameraShakeTimer>0)
    {
        g_shootCameraShakeTimer = R3D_MAX(g_shootCameraShakeTimer-r3dGetFrameTime()*3.f, 0.0f);
    }
 
    if(g_camera_mode->GetInt()==2)
    {
        r3dPoint3D up(0,1,0);
        r3dPoint3D rightVector = player->m_vVision.Cross( up );
        up.RotateAroundVector(rightVector, wave*20.0f );
 
        camUp = up;
 
        float mStepDist = 0.1f;
        r3dPoint3D mCurPos = player->GetPosition();
        mCurPos -= player->oldstate.Position;
        float len = mCurPos.Length();
 
        //BP ok, make step distance the lenth of the anim
        // then len, is the current frame converted to percent :)
        std::vector<r3dAnimation::r3dAnimInfo>::iterator it;
        float curframe = 0;
        float numframe = 0;
        for(it = player->uberAnim_->anim.AnimTracks.begin(); it != player->uberAnim_->anim.AnimTracks.end(); ++it) 
        {
            r3dAnimation::r3dAnimInfo &ai = *it;
            if(!(ai.dwStatus & ANIMSTATUS_Playing)) 
                continue;
            if(!(ai.dwStatus & ANIMSTATUS_Paused)) 
            {
                if(ai.pAnim && ai.pAnim->NumFrames < 60)
                {
                    curframe = ai.fCurFrame;
                    numframe = (float)ai.pAnim->NumFrames;
                    break;
                }
            }
        }
        if(player->PlayerState == PLAYER_MOVE_SPRINT)
            mStepDist *=2;
 
        float mWave = 0;
        bool rightlean = true;
        if(numframe > 0)
        {
            mWave = curframe / numframe; 
 
            // want to go 0-1-0 at 0,50,100
            // want to go 0-1-0-(-1)-0 at 0,25,50,75,100
             if(mWave >= 0.5f)
            {    
                mWave -= 0.5f;
                rightlean = false; 
            } else 
            {
                rightlean = true; 
 
            }
 
             mWave *=2;
            // if greater than .5, subtract .5 to make 0.5
            // now go back down to zero if > .5
            if(mWave >= 0.5f)
                mWave = 1.0f - mWave;
            mWave *=2;
        }
 
        float boba = 0.1f;
        float rolla = 0.2f;
 
        // in aim mode no bob
        switch ( player->PlayerState)
        {
        case PLAYER_MOVE_WALK_AIM:
            // crouch mode no bob
        case PLAYER_MOVE_CROUCH: // intentional fallthrough
        case PLAYER_MOVE_CROUCH_AIM:// intentional fallthrough
        case PLAYER_MOVE_PRONE: // intentional fallthrough
        case PLAYER_PRONE_AIM:// intentional fallthrough
        case PLAYER_PRONE_IDLE:// intentional fallthrough
        case PLAYER_IDLE:// intentional fallthrough
        case PLAYER_IDLEAIM:// intentional fallthrough
            // no bob if turn in place or idle
            {
                mWave = 0; 
                boba = 0.0f;
            }
            break;
        // lower bob on low speed
        case PLAYER_MOVE_RUN:
            {
                boba *= .6f; // yeah this doesn't do anything, it's here in case we want to tweak it. 
                rolla = 1;
            }
            break;
        case PLAYER_MOVE_SPRINT:
 
            {
                boba *=1.0f; 
                rolla = 2;
            }
            break;
        }
 
        //boba = 0; // disable bob
        camBob.y = boba * sin(mWave * R3D_PI_2);
 
        r3dPoint3D p(0,1,0);
 
        float _angle = sin(mWave * R3D_PI_2 ) * rolla;
        if(_angle < 0)
            _angle += 360.0f;
        else if(_angle > 360.0f)
            _angle -=360.0f;
 
        if ( rightlean == false ) 
        {
            _angle = -(_angle);
        }
 
        p.RotateAroundZ(_angle);
        p.Normalize();
 
        // this currently will half the camUp's lean.  But the system works with this. 
        camUp = camUp + p;
        camUp.Normalize();
    }
 
    return;
 
}
 
static bool g_CameraPointToAdj_HasAdjustedVec = false;
static r3dPoint3D g_CameraPointToAdj_adjVec(0,0,0);
static r3dPoint3D g_CameraPointToAdj_nextAdjVec(0,0,0);
 
float        g_CameraLeftSideSource = -0.7f;
float        g_CameraLeftSideTarget = 1.0f;
float        g_CameraLeftSideLerp = 1.0f;
 
float        getCameraLeftSide()
{
    return R3D_LERP(g_CameraLeftSideSource, g_CameraLeftSideTarget, g_CameraLeftSideLerp);
}
 
void        updateCameraLeftSide()
{
    if(g_CameraLeftSideLerp < 1.0f)
        g_CameraLeftSideLerp = R3D_CLAMP(g_CameraLeftSideLerp+r3dGetFrameTime()*5.0f, 0.0f, 1.0f);
}
 
r3dPoint3D getAdjustedPointTo(obj_Player* pl, const r3dPoint3D& PointTo, const r3dPoint3D& CamPos)
{
    if(g_camera_mode->GetInt()==2)
        return R3D_ZERO_VECTOR;
 
    static r3dPoint3D currentLookAt(0,0,0);
    static float      currentLookAtDist = 0.0f;
    if(LerpValue == 1.0f)
    {
        //r3dOutToLog("Lerp finished\n");
        g_CameraPointToAdj_adjVec = g_CameraPointToAdj_nextAdjVec;
    }
    else if(!g_CameraPointToAdj_HasAdjustedVec)
    {
        {
            r3dPoint3D dir;
            if(pl->m_isInScope || g_camera_mode->GetInt() != 1 )
                r3dScreenTo3D(r3dRenderer->ScreenW2, r3dRenderer->ScreenH2, &dir);
            else
                r3dScreenTo3D(r3dRenderer->ScreenW2, r3dRenderer->ScreenH*0.32f, &dir);
 
            PxRaycastHit hit;
            PxSceneQueryFilterData filter(PxFilterData(COLLIDABLE_STATIC_MASK|(1<<PHYSCOLL_NETWORKPLAYER), 0, 0, 0), PxSceneQueryFilterFlag::eSTATIC|PxSceneQueryFilterFlag::eDYNAMIC);
            if(g_pPhysicsWorld->raycastSingle(PxVec3(gCam.x, gCam.y, gCam.z), PxVec3(dir.x, dir.y, dir.z), 2000.0f, PxSceneQueryFlag::eIMPACT|PxSceneQueryFlag::eDISTANCE, hit, filter))
            {
                currentLookAt.Assign(hit.impact.x, hit.impact.y, hit.impact.z);
                currentLookAtDist = hit.distance;
            }
            else
            {
                currentLookAt = CamPos + dir * 1000.0f;
                currentLookAtDist = 1000.0f;
            }
        }
 
 
        g_CameraPointToAdj_HasAdjustedVec = true;
        r3dPoint3D DestCamPos = pl->GetPosition();
        r3dPoint3D offset;
        if(pl->hasScopeMode())
        {
            offset =  r3dPoint3D( 0, (pl->getPlayerHeightForCamera() +  TargetRig.ScopePosition.Y), 0 );
            offset += pl->GetvRight() * TargetRig.ScopePosition.X;
            offset += pl->m_vVision * (TargetRig.ScopePosition.Z);
        }
        else
        {
            offset =  r3dPoint3D( 0, (pl->getPlayerHeightForCamera() +  TargetRig.Position.Y), 0 );
            offset += pl->GetvRight() * TargetRig.Position.X * getCameraLeftSide();
            offset += pl->m_vVision * (TargetRig.Position.Z);
        }
 
        DestCamPos += offset;
 
        r3dPoint3D playerPosHead = pl->GetPosition(); playerPosHead.y += pl->getPlayerHeightForCamera();
        CheckCameraCollision(DestCamPos, playerPosHead, false);
 
        r3dPoint3D curViewVec = PointTo - CamPos;
        curViewVec.Normalize();
 
        r3dPoint3D destViewVec = PointTo - DestCamPos;
        destViewVec.Normalize();
 
        r3dPoint3D curLookAt = currentLookAt;
        if(!pl->hasScopeMode() &&  g_camera_mode->GetInt() == 1 ) // we only need this offset in offcenter mode.
        {
            float fHeight = currentLookAtDist * tan(R3D_DEG2RAD(TargetRig.FOV) * 0.5f);
            curLookAt.y -= fHeight * 0.35f;
        }
        r3dPoint3D destViewVec2 = curLookAt - DestCamPos;
        destViewVec2.Normalize();
 
       /* float d1 = pl->m_vVision.Dot(destViewVec);
        float d2 = pl->m_vVision.Dot(destViewVec2);
        if(!pl->hasScopeMode())
            if(d2 < 0.99f)
                destViewVec2 = destViewVec;*/
 
        //r3dOutToLog("Lerp=%.2f, pl_state=%d, aiming=%d\n", LerpValue, pl->PlayerState, pl->m_isAiming);
 
        static bool wasAiming = false;
        if(pl->m_isAiming)
        {
            if(!wasAiming)
            {
                wasAiming = true;
                if(currentLookAtDist < 5.0f && pl->hasScopeMode())
                    g_CameraPointToAdj_nextAdjVec = r3dPoint3D(0,0.25f,0);
                else
                    g_CameraPointToAdj_nextAdjVec = destViewVec2 - destViewVec;
            }
        }
        else
        {
            wasAiming = false;
            g_CameraPointToAdj_nextAdjVec = r3dPoint3D(0,0,0);
        }
 
        //r3dOutToLog("(%d): %.2f, %.2f\n", pl->m_isAiming, d1, d2);
        //r3dOutToLog("switching (%d): %.2f, %.2f, %.2f; %.2f\n", pl->m_isAiming, g_CameraPointToAdj_nextAdjVec.x, g_CameraPointToAdj_nextAdjVec.y, g_CameraPointToAdj_nextAdjVec.z, currentLookAtDist);
        //r3dOutToLog("vec: %.2f, %.2f, %.2f; %.2f, %.2f, %.2f\n", destViewVec.x, destViewVec.y, destViewVec.z, destViewVec2.x, destViewVec2.y, destViewVec2.z);
    }
 
    return R3D_LERP(g_CameraPointToAdj_adjVec, g_CameraPointToAdj_nextAdjVec, LerpValue);
}
 
extern float DepthOfField_NearStart;
extern float DepthOfField_NearEnd;
extern float DepthOfField_FarStart;
extern float DepthOfField_FarEnd;
extern int _FAR_DOF;
extern int _NEAR_DOF;
extern int LevelDOF;
 
// runs in actual game
int spectator_observingPlrIdx = 0;
r3dPoint3D spectator_cameraPos(0,0,0);
void TPSGameHUD :: SetCameraPure ( r3dCamera &Cam)
{
#ifndef FINAL_BUILD
    if(d_video_spectator_mode->GetBool() || d_observer_mode->GetBool())
    {
        r3dPoint3D CamPos = FPS_Position;
        CamPos.Y += 1.8f;
        r3dPoint3D ViewPos = CamPos + FPS_vVision*10.0f;
 
        Cam.FOV = r_video_fov->GetFloat();
        Cam.SetPosition( CamPos );
        Cam.PointTo(ViewPos);
 
        LevelDOF = r_video_DOF_enable->GetBool();
        _NEAR_DOF = 1;
        _FAR_DOF = 1;
        DepthOfField_NearStart = r_video_nearDOF_start->GetFloat();
        DepthOfField_NearEnd = r_video_nearDOF_end->GetFloat();
        DepthOfField_FarStart = r_video_farDOF_start->GetFloat();
        DepthOfField_FarEnd = r_video_farDOF_end->GetFloat();
 
        return;
    }
#endif
 
    const ClientGameLogic& CGL = gClientLogic();
    obj_Player* pl = CGL.localPlayer_;
    if(pl == 0)
    {
        return;
    }
 
    extern bool SetCameraPlayerVehicle(const obj_Player* pl, r3dCamera &Cam);
    if(SetCameraPlayerVehicle(pl, Cam))
    {
        FPS_Position = Cam;
        return;
    }
 
 
    // dead camera
    if(pl->bDead)
    {
        r3dPoint3D camPos, camPointTo;
        bool do_camera = false;
        bool check_cam_collision = true;
        {
            static r3dPoint3D oldPlayerPos(0,0,0);
            static r3dPoint3D camPosOffset(0,0,0);
            camPointTo = pl->GetPosition();
 
            // find a cam position
            if(!oldPlayerPos.AlmostEqual(pl->GetPosition())) // make sure to do that check only once
            {
                oldPlayerPos = pl->GetPosition();
                r3dPoint3D possible_cam_offset[4] = {r3dPoint3D(-3, 5, -3), r3dPoint3D(3, 5, -3), r3dPoint3D(-3, 5, 3), r3dPoint3D(3, 5, 3)};
                int found=-1;
                for(int i=0; i<4; ++i)
                {
                    r3dPoint3D raydir = ((pl->GetPosition()+possible_cam_offset[i]) - camPointTo);
                    float rayLen = raydir.Length();
                    if(rayLen > 0)
                    {
                        raydir.Normalize();
                        PxRaycastHit hit;
                        PxSceneQueryFilterData filter(PxFilterData(COLLIDABLE_STATIC_MASK, 0, 0, 0), PxSceneQueryFilterFlag::eSTATIC);
                        if(!g_pPhysicsWorld->raycastSingle(PxVec3(camPointTo.x, camPointTo.y, camPointTo.z), PxVec3(raydir.x, raydir.y, raydir.z), rayLen, PxSceneQueryFlag::eIMPACT, hit, filter))
                        {
                            found = i;
                            break;
                        }
                    }
                }
                if(found!=-1)
                {
                    camPosOffset = possible_cam_offset[found];
                }
                else
                {
                    camPosOffset = r3dPoint3D(-0.1f, 5, -0.1f);
                }
            }
 
            camPos = pl->GetPosition() + camPosOffset; 
            do_camera = true;
            check_cam_collision = false;
        }
 
        if(do_camera)
        {
            extern int g_CCBlackWhite;
            extern float g_fCCBlackWhitePwr;
            g_CCBlackWhite = 1;
            g_fCCBlackWhitePwr = R3D_CLAMP((r3dGetTime() - pl->TimeOfDeath)/2.0f, 0.0f, 1.0f); // go to black and white while look at our dead body
 
            // check for collision
            if(check_cam_collision)
                CheckCameraCollision(camPos, camPointTo, false);
 
            Cam.FOV = 60;
            Cam.SetPosition( camPos );
            Cam.PointTo( camPointTo );
            FPS_Position = Cam;
            return;
        }
    }
 
    if(pl->bDead && hudAttm->isActive())
        hudAttm->Deactivate();
 
    if(hudPause->isActive())
        return;
    if(hudAttm->isActive())
        return;
    if(hudGeneralStore->isActive())
        return;
    if(hudVault->isActive())
        return;
 
    int mMX=Mouse->m_MouseMoveX, mMY=Mouse->m_MouseMoveY;
    if(g_vertical_look->GetBool()) // invert mouse
        mMY = -mMY;
 
    GameFOV = CurrentRig.FOV;
 
    float CharacterHeight = pl->getPlayerHeightForCamera();
    r3dPoint3D CamPos = pl->GetPosition();
    CamPos.Y +=  (CharacterHeight+  CurrentRig.Position.Y);
    updateCameraLeftSide();
    CamPos += pl->GetvRight() * CurrentRig.Position.X * getCameraLeftSide();
    CamPos += pl->m_vVision * CurrentRig.Position.Z;
 
    r3dPoint3D playerPos = pl->GetPosition();
    r3dPoint3D playerPosHead = playerPos; playerPosHead.y += CharacterHeight;
    r3dPoint3D PointTo = playerPos;
    PointTo.Y += (CharacterHeight + TPSHudCameraTarget.Y);
    PointTo += pl->GetvRight() * TPSHudCameraTarget.X;
 
    // check for collision
    {
        r3dPoint3D savedCamPos = CamPos;
        if(CheckCameraCollision(CamPos, playerPosHead, true) && (pl->PlayerState == PLAYER_MOVE_CROUCH || pl->PlayerState == PLAYER_MOVE_CROUCH_AIM || pl->PlayerState == PLAYER_MOVE_PRONE || pl->PlayerState == PLAYER_PRONE_AIM || pl->PlayerState == PLAYER_PRONE_IDLE)) 
        {
            CamPos = savedCamPos;
            playerPosHead = playerPos;
            playerPosHead.y += CharacterHeight-0.8f;
            CheckCameraCollision(CamPos, playerPosHead, true);
        }
    }
 
    PointTo += (pl->m_vVision) * 50;//cameraRayLen;//CurrentRig.Target.Z;
 
    r3dPoint3D adjPointTo(0,0,0);
    adjPointTo = getAdjustedPointTo(pl, PointTo, CamPos);
 
    r3dPoint3D camBob, camUp;
    Get_Camera_Bob(camBob, camUp, pl);
 
    Cam.FOV = GameFOV;
    Cam.SetPosition( CamPos + camBob );
    Cam.PointTo(PointTo + camBob);
    Cam.vUP = camUp;
 
    Cam.vPointTo += adjPointTo;
 
#ifndef FINAL_BUILD
    if( g_pHUDCameraEffects )
    {
        g_pHUDCameraEffects->Update( &Cam, CamPos ) ;
    }
#endif
 
    FPS_Position = Cam;
}  
 
static void DrawMenus()
{
#ifndef FINAL_BUILD
    if(d_video_spectator_mode->GetBool() && !d_observer_mode->GetBool()) // no UI in spectator mode
        return;
    if(d_disable_game_hud->GetBool())
        return;
#endif
 
#if 0
    typedef std::vector<std::string> stringlist_t;
    extern stringlist_t currentMovies ;
 
    typedef std::vector< float > floats ;
    extern floats movieDurations ;
 
    char buff[ 512 ] ;
    sprintf( buff, "%d - Num Drawcalls", r3dRenderer->Stats.NumDraws );
 
    currentMovies.push_back( buff );
    movieDurations.push_back( 0.1f );
 
    typedef std::vector< int > sorties ;
    static sorties ss ;
 
    ss.resize( movieDurations.size() );
 
    for( int i = 0, e = movieDurations.size(); i < e; i ++ )
    {
        ss[ i ] = i ;
    }
 
    for( int i = 0, e = movieDurations.size(); i < e; i ++ )
    {
        for( int j = 0, e = movieDurations.size() - 1 ; j < e; j ++ )
        {
            if( movieDurations[ ss[ j ] ] > movieDurations[ ss[ j + 1 ] ] )
            {
                std::swap( ss[ j ], ss[ j + 1 ] );
            }
        }
    }
 
    r3dSetFiltering( R3D_POINT );
 
    r3dRenderer->pd3ddev->SetRenderState( D3DRS_ALPHATESTENABLE,     FALSE );
    r3dRenderer->pd3ddev->SetRenderState( D3DRS_ALPHAREF,            1 );
 
    r3dRenderer->SetMaterial(NULL);
    r3dRenderer->SetRenderingMode(R3D_BLEND_ALPHA);
 
    for( int i = 0, e = (int)currentMovies.size(); i < e; i ++ )
    {
        Font_Label->PrintF(r3dRenderer->ScreenW - 330, r3dRenderer->ScreenH-e*22 - 220 + i*22,r3dColor(255,255,255), "%.1f - %s", movieDurations[ ss[ i ] ] * 1000.f, currentMovies[ ss[ i ] ].c_str() );
    }
 
    currentMovies.clear();
    movieDurations.clear();
 
    r3dRenderer->pd3ddev->SetRenderState( D3DRS_ALPHATESTENABLE,     FALSE );
    r3dRenderer->pd3ddev->SetRenderState( D3DRS_ALPHAREF,            1 );
 
    r3dRenderer->SetRenderingMode(R3D_BLEND_ALPHA | R3D_BLEND_NZ);
#endif
 
    if(!win::bSuspended && !hudMain->isChatInputActive() && !hudMain->isPlayersListVisible()) 
    {
        bool showHudPause = Keyboard->WasPressed(kbsEsc) || InputMappingMngr->wasPressed(r3dInputMappingMngr::KS_SWITCH_MINIMAP) || InputMappingMngr->wasPressed(r3dInputMappingMngr::KS_INVENTORY);
        if(showHudPause && !hudAttm->isActive() && !hudGeneralStore->isActive() && !hudVault->isActive())
        {
            if(!hudPause->isActive())
            {
                hudPause->Activate();
                if(InputMappingMngr->wasPressed(r3dInputMappingMngr::KS_SWITCH_MINIMAP))
                    hudPause->showMap();
                else if(InputMappingMngr->wasPressed(r3dInputMappingMngr::KS_INVENTORY))
                    hudPause->showInventory();
            }
            else
                hudPause->Deactivate();
        }
 
        bool showAttachment = InputMappingMngr->wasPressed(r3dInputMappingMngr::KS_SHOW_ATTACHMENTS);
        if(showAttachment)
        {
            if(!hudAttm->isActive())
            {
                hudAttm->Activate();
            }
            else
                hudAttm->Deactivate();
        }
 
        if(hudAttm->isActive() && Keyboard->WasPressed(kbsEsc))
            hudAttm->Deactivate();
 
        if(hudGeneralStore->isActive() && Keyboard->WasPressed(kbsEsc))
            hudGeneralStore->Deactivate();
 
        if(hudVault->isActive() && Keyboard->WasPressed(kbsEsc))
            hudVault->Deactivate();
    }
 
    if(hudPause->isActive())
    {
        r3dMouse::Show(); // make sure that mouse is visible
 
        R3DPROFILE_START( "hudPause->" );
 
        hudPause->Update();
        hudPause->Draw();
 
        R3DPROFILE_END( "hudPause->" );
 
        return;
    }
 
    if(hudAttm->isActive())
    {
        r3dMouse::Show(); // make sure that mouse is visible
 
        R3DPROFILE_START( "hudAttm->" );
 
        hudAttm->Update();
        hudAttm->Draw();
 
        R3DPROFILE_END( "hudAttm->" );
 
        return;
    }
 
    if(hudGeneralStore->isActive())
    {
        r3dMouse::Show(); // make sure that mouse is visible
 
        R3DPROFILE_START( "hudGeneralStore->" );
 
        hudGeneralStore->Update();
        hudGeneralStore->Draw();
 
        R3DPROFILE_END( "hudGeneralStore->" );
 
        return;
    }
 
    if(hudVault->isActive())
    {
        r3dMouse::Show(); // make sure that mouse is visible
 
        R3DPROFILE_START( "hudVault->" );
 
        hudVault->Update();
        hudVault->Draw();
 
        R3DPROFILE_END( "hudVault->" );
 
        return;
    }
 
    if(hudActionUI->isActive())
    {
        R3DPROFILE_START( "hudActionUI->" );
        hudActionUI->Update();
        hudActionUI->Draw();
        R3DPROFILE_END( "hudActionUI->" );
    }
 
 
    bool ChatWindowSwitch = InputMappingMngr->wasReleased(r3dInputMappingMngr::KS_CHAT);
 
    const ClientGameLogic& CGL = gClientLogic();
    const obj_Player* pl = CGL.localPlayer_; // can be null
    if(pl == NULL) // no player, we need to show respawn menu and let player enter game
    {
    }
    else
    {
        // check for respawn screen
        if(pl->bDead) 
        {
        }
        else
        {
        }
 
        if(ChatWindowSwitch && hudMain && !hudMain->isChatInputActive())
        {
            hudMain->showChatInput();
        }
 
        if(hudMain)
        {
            if(InputMappingMngr->wasReleased(r3dInputMappingMngr::KS_CHAT_CHANNEL1))
                hudMain->setChatChannel(0);
            if(InputMappingMngr->wasReleased(r3dInputMappingMngr::KS_CHAT_CHANNEL2))
                hudMain->setChatChannel(1);
            if(InputMappingMngr->wasReleased(r3dInputMappingMngr::KS_CHAT_CHANNEL3))
                hudMain->setChatChannel(2);
        }
 
        if(hudMain && !hudMain->isChatInputActive())
        {
            bool showPlayerList = InputMappingMngr->wasPressed(r3dInputMappingMngr::KS_SHOW_PLAYERS);
            if(showPlayerList)
            {
                if (!hudMain->isPlayersListVisible())
                {
                    hudMain->clearPlayersList();
                    int index = 0;
                    for(int i=0; i<R3D_ARRAYSIZE(CGL.playerNames); i++)
                    {
                        if(CGL.playerNames[i].Gamertag[0])
                        {
                            hudMain->addPlayerToList(index++, CGL.playerNames[i].Gamertag, CGL.playerNames[i].plrRep, CGL.playerNames[i].isLegend, CGL.playerNames[i].isDev, false, false);
                        }
                    }
                    hudMain->showPlayersList(1);
                    r3dMouse::Show();
                }
                else
                {
                    hudMain->showPlayersList(0);
                    r3dMouse::Hide();
                }
            }
 
            if(hudMain->isPlayersListVisible() && Keyboard->WasPressed(kbsEsc))
            {
                    hudMain->showPlayersList(0);
                    r3dMouse::Hide();
            }
        }
 
        // render flash UI for objects
 
        R3DPROFILE_START( "GameWorld().Draw(rsDrawFlashUI)" );
        GameWorld().Draw(rsDrawFlashUI);
        R3DPROFILE_END( "GameWorld().Draw(rsDrawFlashUI)" );
 
        {
            {
                R3DPROFILE_START( "hudMain->" );
 
                hudMain->Update();
                hudMain->Draw();
 
                R3DPROFILE_END( "hudMain->" );
            }
 
            // issue d3d cheat check on some frames (will stop issuing anti cheat if caught cheat)
            // wait 5 minute before doing check. after that, do check every other 2-5 minutes
            if(!pl->bDead && (r3dGetTime() - pl->TimeOfLastRespawn)>300.0f && !hudAttm->isActive() &&
                !hudPause->isActive() && !hudActionUI->isActive() && !hudGeneralStore->isActive() &&
                !hudVault->isActive())
            {
                static float nextCheck = r3dGetTime() + u_GetRandom(120.0f, 300.0f);
                if(r3dGetTime() > nextCheck)
                {
                    issueD3DAntiCheatCodepath( ANTICHEAT_WALLHACK );
                    nextCheck = r3dGetTime() + u_GetRandom(120.0f, 300.0f);
                }
//                 static float nextCheck2 = r3dGetTime() + u_GetRandom(300.0f, 600.0f);
//                 if(r3dGetTime() > nextCheck2)
//                 {
//                     issueD3DAntiCheatCodepath( ANTICHEAT_SCREEN_HELPERS2 );
//                     nextCheck2 = r3dGetTime() + u_GetRandom(300.0f, 600.0f);
//                 }
            }
        }
 
        if(hudMain && (hudMain->isChatInputActive() || hudMain->isPlayersListVisible())) // also checks for write note, so do not hide mouse
            return;
 
        // draw main hud with hidden mouse
        // this call is FREE if mouse was hidden already
        // [denis]: do not remove for now, this is minor hack for situation when app was started inactive. 
        // [pavel]: that fucks up controls, when big map is on screen, or scoreboard is, you shouldn't be able to move character, as in that mode you are actually using mouse
        //            if app was started inactive, just press M twice and that's it. 
        // [pavel]: ok, that should fix a problem. If non of modal windows are active, then hide mouse.
        if(!win::bSuspended && !g_cursor_mode->GetInt())
            r3dMouse::Hide();
    }
}
 
void TPSGameHUD :: Draw()
{
    if(!TPSGameHud_Inited) r3dError("!TPSGameHud_Inited");
 
    assert(bInited);
    if ( !bInited ) return;
 
    R3DPROFILE_D3DSTART( D3DPROFILE_SCALEFORM ) ;
 
    r3dSetFiltering( R3D_POINT );
 
    r3dRenderer->pd3ddev->SetRenderState( D3DRS_ALPHATESTENABLE,     FALSE );
    r3dRenderer->pd3ddev->SetRenderState( D3DRS_ALPHAREF,            1 );
 
    r3dRenderer->SetMaterial(NULL);
    r3dRenderer->SetRenderingMode(R3D_BLEND_ALPHA | R3D_BLEND_NZ);
 
    DrawMenus();
 
    R3DPROFILE_D3DEND( D3DPROFILE_SCALEFORM ) ;
 
    return;  
}
 
bool SetCameraPlayerVehicle(const obj_Player* pl, r3dCamera &Cam)
{
    static bool wasDrivenByPlayer = false;
#if VEHICLES_ENABLED
    if ( g_pPhysicsWorld && g_pPhysicsWorld->m_VehicleManager->GetDrivenCar() && d_drive_vehicles->GetBool() == true )
    {
        obj_Vehicle* vehicle = g_pPhysicsWorld->m_VehicleManager->getRealDrivenVehicle();
        if( vehicle ) 
        {
#if    VEHICLE_CINEMATIC_MODE
            r3dVector CamPos = vehicle->GetPosition();
            CamPos += r3dPoint3D( 0, ( 5 ), 0 );
 
            int mMX=Mouse->m_MouseMoveX, mMY=Mouse->m_MouseMoveY;
            float  glb_MouseSensAdj = CurrentRig.MouseSensetivity * g_mouse_sensitivity->GetFloat();    
 
            static float camangle = 0;
            camangle += float(-mMX) * glb_MouseSensAdj;
 
            if(camangle > 360.0f ) camangle = camangle - 360.0f;
            if(camangle < 0.0f )   camangle = camangle + 360.0f;
 
            D3DXMATRIX mr;
            D3DXMatrixRotationYawPitchRoll(&mr, R3D_DEG2RAD(-camangle), 0.0f, 0);
            r3dVector vehicleForwardVector = r3dVector(mr ._31, mr ._32, mr ._33);
 
            CamPos += -vehicleForwardVector * 8 ;
 
            Cam.SetPosition(CamPos);
            Cam.PointTo( CamPos + vehicleForwardVector * 3 + r3dVector ( 0, -1, 0) );
            Cam.vUP = r3dPoint3D(0, 1, 0);
#else 
            g_pPhysicsWorld->m_VehicleManager->ConfigureCamera(Cam);
#endif
            wasDrivenByPlayer = true;
        }
        else
        {
            wasDrivenByPlayer = false;
        }
    }
    else
    {
        wasDrivenByPlayer = false;
    }
#endif 
    return wasDrivenByPlayer;
 
}
 
static float g_lastAimAnimTime = -1.f;
 
void ProcessPlayerMovement(obj_Player* pl, bool editor_debug )
{
    r3d_assert(pl->NetworkLocal);
 
    // check fire weapon should be called all the time, as it will reset weapon fire in case if you are sitting on the menu, etc
    {
        R3DPROFILE_FUNCTION("update fire");
        pl->CheckFireWeapon();
    }
 
    if(InputMappingMngr->wasPressed(r3dInputMappingMngr::KS_SWITCH_FPS_TPS) && !(hudAttm && hudAttm->isActive()) && !(hudMain && hudMain->isChatInputActive()) && !Mouse->GetMouseVisibility() && !pl->bSwim)
    {
        pl->switchFPS_TPS();
    }
 
 
    if (pl->bSwim && g_camera_mode->GetInt() == 2)
    {
pl->switchFPS_TPS();
    }
 
 
    if (pl->bSwim && g_camera_mode->GetInt() == 2)
    {
pl->switchFPS_TPS();
    }
 
    r3dPoint3D prevAccel = pl->InputAcceleration;
    pl->InputAcceleration.Assign(0, 0, 0);
 
    static int shiftWasPressed = 0;
    float movingSpeed = pl->plr_local_moving_speed * (1.0f/r3dGetFrameTime());
 
    // query mouse distance, so it will not be accumulated
    int mMX=Mouse->m_MouseMoveX, mMY=Mouse->m_MouseMoveY;
    if(g_vertical_look->GetBool()) // invert mouse
        mMY = -mMY;
 
    bool disablePlayerRotation = false;
    bool disablePlayerMovement = false;
    if(Mouse->GetMouseVisibility() || (hudMain && hudMain->isChatInputActive())) // do not update player if we are in menu control mode!
    {    
        disablePlayerMovement = true;
        disablePlayerRotation = true;
    }
    if(pl->bDead)
        return;
 
    const Weapon* wpn = pl->m_Weapons[pl->m_SelectedWeapon];
 
    if(!Mouse->GetMouseVisibility()
        && wpn)
    {
 
        // vehicles
        if(InputMappingMngr->wasPressed(r3dInputMappingMngr::KS_INTERACT) )
        {
#if VEHICLES_ENABLED
            obj_Vehicle* target_Vehicle = pl->canEnterVehicle();
 
            if( pl->isInVehicle() ) {
                pl->exitVehicle();
            }
            else if ( target_Vehicle  ) // now we're going to try to use vehicles (otherwise UAV characters can't use vehicles).
            {
                pl->enterVehicle( target_Vehicle );
            }
#endif
        }
    }
 
    if(pl->m_isFinishedAiming && !pl->m_isInScope)
    {
        if(Keyboard->WasPressed(kbsLeftShift))
        {
            R3D_SWAP(g_CameraLeftSideSource, g_CameraLeftSideTarget);
            g_CameraLeftSideLerp = 0.0f;
        }
    }
 
    bool  aiming      = pl->m_isAiming;
    int   playerState = aiming ? PLAYER_IDLEAIM : PLAYER_IDLE;
 
    if( g_lastAimAnimTime < 0 )
        g_lastAimAnimTime = r3dGetTime();
 
    float newAimTime = r3dGetTime();
    float deltaAimTime = newAimTime - g_lastAimAnimTime;
    g_lastAimAnimTime = newAimTime;
 
    const float AIM_LERP_SPEED = 8.0f;
 
    if( aiming )
    {
        r_grass_zoom_coef->SetFloat( R3D_LERP( r_grass_zoom_coef->GetFloat(), 2.0f, AIM_LERP_SPEED * deltaAimTime ) );
    }
    else
    {
        r_grass_zoom_coef->SetFloat( R3D_LERP( r_grass_zoom_coef->GetFloat(), 1.0f, AIM_LERP_SPEED * deltaAimTime ) );
    }
 
    if(!(g_camera_mode->GetInt()==2 && pl->NetworkLocal))
    {
        if(pl->IsJumpActive()) 
        {
            // in jump, keep current state  (so strafe will stay, for example) and disable movement
            playerState = pl->PlayerState;
        }
    }
 
    // not able to sprint with equipped RPG
    bool disableSprint = false;
    r3dAnimation::r3dAnimInfo* animInfo = pl->uberAnim_->anim.GetTrack(pl->uberAnim_->grenadeThrowTrackID);
    if(!(pl->uberAnim_->grenadePinPullTrackID==CUberAnim::INVALID_TRACK_ID && !(animInfo && (animInfo->GetStatus()&ANIMSTATUS_Playing))))
        disableSprint = true;
 
    if(pl->CurLoadout.Health < 10.0f)
        disableSprint = true;
 
    // check if player can straighten up, in case if there is something above his head he will not be able to stop crouching
    bool force_crouch = false;
    if(pl->bCrouch)
    {
        PxBoxGeometry bbox(0.2f, 0.9f, 0.2f);
        PxTransform pose(PxVec3(pl->GetPosition().x, pl->GetPosition().y+1.1f, pl->GetPosition().z), PxQuat(0,0,0,1));
        PxSceneQueryFilterData filter(PxFilterData(COLLIDABLE_STATIC_MASK, 0, 0, 0), PxSceneQueryFilterFlag::eSTATIC);
        PxShape* shape;
        force_crouch = g_pPhysicsWorld->PhysXScene->overlapAny(bbox, pose, shape, filter);
    }
    bool crouching = pl->bCrouch;
    if(pl->fHeightAboveGround < 0.5f)
    {
        if(g_toggle_crouch->GetBool())
        {
            if(InputMappingMngr->wasPressed(r3dInputMappingMngr::KS_CROUCH) || Gamepad->WasReleased(gpB))
                crouching = !crouching;
        }
        else
            crouching = InputMappingMngr->isPressed(r3dInputMappingMngr::KS_CROUCH) || Gamepad->IsPressed(gpB);
    }
    else
        crouching = false;
 
    if(disablePlayerMovement)
        crouching = false;
 
    if(force_crouch)
        crouching = true;
 
    if(crouching) 
        playerState = aiming ? PLAYER_MOVE_CROUCH_AIM : PLAYER_MOVE_CROUCH;
 
    // check if player can straighten up, in case if there is something above his head he will not be able to stop proning
    bool force_prone = false;
    if(pl->bProne)
    {
        PxBoxGeometry bbox(0.2f, 0.9f, 0.2f);
        PxTransform pose(PxVec3(pl->GetPosition().x, pl->GetPosition().y+1.1f, pl->GetPosition().z), PxQuat(0,0,0,1));
        PxSceneQueryFilterData filter(PxFilterData(COLLIDABLE_STATIC_MASK, 0, 0, 0), PxSceneQueryFilterFlag::eSTATIC);
        PxShape* shape;
        force_prone = g_pPhysicsWorld->PhysXScene->overlapAny(bbox, pose, shape, filter);
    }
    bool wasProning = pl->bProne;
    bool proning = pl->bProne;
    if(pl->fHeightAboveGround < 0.5f)
    {
        if(InputMappingMngr->wasPressed(r3dInputMappingMngr::KS_PRONE) && !disablePlayerMovement)
            proning = !proning;
    }
    else
        proning = false;
 
    if(force_prone)
        proning = true;
 
    {
        extern float getWaterDepthAtPos(const r3dPoint3D& pos);
        float waterDepth = getWaterDepthAtPos(pl->GetPosition());
        if(waterDepth > 1.4f)
        {
            proning = false;
            crouching = false;
        }
 
    if(proning) 
    {
        if(!wasProning)
            playerState = PLAYER_PRONE_DOWN;
        else if(wasProning && pl->PlayerState == PLAYER_PRONE_DOWN) // check if we are still playing anim
        {
            bool stillPlayingAnim = false;
            std::vector<r3dAnimation::r3dAnimInfo>::iterator it;
            for(it=pl->uberAnim_->anim.AnimTracks.begin(); it!=pl->uberAnim_->anim.AnimTracks.end(); ++it) 
            {
                const r3dAnimation::r3dAnimInfo& ai = *it;
                if(ai.pAnim->iAnimId == pl->uberAnim_->data_->aid_.prone_down_weapon || ai.pAnim->iAnimId == pl->uberAnim_->data_->aid_.prone_down_noweapon)
                {
                    if(!(ai.dwStatus & ANIMSTATUS_Finished))
                        stillPlayingAnim = true;
                    break;
                }
            }
            if(stillPlayingAnim)
                playerState = PLAYER_PRONE_DOWN;
            else
                playerState = aiming ? PLAYER_PRONE_AIM : PLAYER_PRONE_IDLE;
        }
        else
            playerState = aiming ? PLAYER_PRONE_AIM : PLAYER_PRONE_IDLE;
    }
    else
    {
        if(wasProning)
            playerState = PLAYER_PRONE_UP;
        else if(pl->PlayerState == PLAYER_PRONE_UP) // check if we are still playing anim
        {
            bool stillPlayingAnim = false;
            std::vector<r3dAnimation::r3dAnimInfo>::iterator it;
            for(it=pl->uberAnim_->anim.AnimTracks.begin(); it!=pl->uberAnim_->anim.AnimTracks.end(); ++it) 
            {
                const r3dAnimation::r3dAnimInfo& ai = *it;
                if(ai.pAnim->iAnimId == pl->uberAnim_->data_->aid_.prone_up_weapon || ai.pAnim->iAnimId == pl->uberAnim_->data_->aid_.prone_up_noweapon)
                {
                    if(!(ai.dwStatus & ANIMSTATUS_Finished))
                        stillPlayingAnim = true;
                    break;
                }
            }
            if(stillPlayingAnim)
                playerState = PLAYER_PRONE_UP;
        }
    }
 
    if(playerState == PLAYER_PRONE_UP || playerState == PLAYER_PRONE_DOWN)
    {
        disablePlayerMovement = true;
        disablePlayerRotation = true;
    }
 
    if(proning && aiming)
        disablePlayerMovement = true;
 
    VMPROTECT_BeginMutation("ProcessPlayerMovement_Accel");    
    {
 
        r3dPoint3D accelaration(0,0,0);
        if(!disablePlayerMovement)
        {
            // if facing a wall and cannot sprint - stop sprint
            bool canSprint = (shiftWasPressed<3) || (shiftWasPressed>=3 && movingSpeed > 1.0f);
            if(InputMappingMngr->isPressed(r3dInputMappingMngr::KS_SPRINT) || Gamepad->IsPressed(gpLeftShoulder))
                shiftWasPressed++;
            else
                shiftWasPressed = 0;
 
            if(aiming || pl->m_isHoldingBreath) // cannot spring and aim. also, in default key binding spring and hold breath are on the same key
                shiftWasPressed = 0;
 
            // due to animation, firstly check left and right movement, so that if you move diagonally we will play moving forward animation
            float thumbX, thumbY;
            Gamepad->GetLeftThumb(thumbX, thumbY);
            if(InputMappingMngr->isPressed(r3dInputMappingMngr::KS_MOVE_LEFT)) 
            {
                accelaration += (aiming)?r3dPoint3D(-GPP->AI_WALK_SPEED*GPP->AI_BASE_MOD_SIDE,0,0):r3dPoint3D(-GPP->AI_RUN_SPEED*GPP->AI_BASE_MOD_SIDE,0,0);
            }
            else if(InputMappingMngr->isPressed(r3dInputMappingMngr::KS_MOVE_RIGHT)) 
            {
                accelaration += (aiming)?r3dPoint3D(GPP->AI_WALK_SPEED*GPP->AI_BASE_MOD_SIDE,0,0):r3dPoint3D(GPP->AI_RUN_SPEED*GPP->AI_BASE_MOD_SIDE,0,0);
            }
            else if(thumbX!=0.0f)
            {
                accelaration += (aiming)?r3dPoint3D(GPP->AI_WALK_SPEED*GPP->AI_BASE_MOD_SIDE*thumbX,0,0):r3dPoint3D(GPP->AI_RUN_SPEED*GPP->AI_BASE_MOD_SIDE*thumbX,0,0);
            }
 
            //r3dOutToLog("sprint: %d, canSprint: %d, speed: %.3f\n", (int)shiftWasPressed, (int)canSprint, movingSpeed);
            if(shiftWasPressed && canSprint /*&& pl->bOnGround*/ && !crouching && !proning && !disableSprint && (pl->m_Stamina>0.0f) && pl->m_StaminaPenaltyTime<=0 && !pl->bSwim && waterDepth < 1.2f) 
            {
                playerState = PLAYER_MOVE_SPRINT;
                accelaration *= 0.5f; // half side movement when sprinting
                accelaration += r3dPoint3D(0,0,GPP->AI_SPRINT_SPEED);
                accelaration  = accelaration.NormalizeTo() * GPP->AI_SPRINT_SPEED;
            }
            else
            {
                if(InputMappingMngr->isPressed(r3dInputMappingMngr::KS_MOVE_FORWARD) || shiftWasPressed) 
                {
                    float spd = GPP->AI_BASE_MOD_FORWARD * (aiming ? GPP->AI_WALK_SPEED : GPP->AI_RUN_SPEED);
                    accelaration += r3dPoint3D(0,0,spd);
                    accelaration  = accelaration.NormalizeTo() * spd;
                }
                else if(InputMappingMngr->isPressed(r3dInputMappingMngr::KS_MOVE_BACKWARD))
                {
                    float spd = GPP->AI_BASE_MOD_BACKWARD * (aiming ? GPP->AI_WALK_SPEED : GPP->AI_RUN_SPEED);
                    accelaration += r3dPoint3D(0,0,-spd);
                    accelaration  = accelaration.NormalizeTo() * spd;
                }
                else if(thumbY!=0.0f)
                {
                    if(thumbY>0)
                        accelaration += (aiming)?r3dPoint3D(0,0,GPP->AI_WALK_SPEED*GPP->AI_BASE_MOD_FORWARD*thumbY):r3dPoint3D(0,0,GPP->AI_RUN_SPEED*GPP->AI_BASE_MOD_FORWARD*thumbY);
                    else
                        accelaration += (aiming)?r3dPoint3D(0,0,GPP->AI_WALK_SPEED*GPP->AI_BASE_MOD_BACKWARD*thumbY):r3dPoint3D(0,0,GPP->AI_RUN_SPEED*GPP->AI_BASE_MOD_BACKWARD*thumbY);
                }
 
 
                if(waterDepth > 1.4f)
        {
            pl->bSwim = true;
                if(shiftWasPressed && canSprint && (pl->m_Stamina>0.0f) && pl->m_StaminaPenaltyTime<=0) 
            {
                pl->bSwimShift = true;
                accelaration *= 1.5f; // half side movement when sprinting
                playerState = PLAYER_SWIM_F;
            }
                else
                {
pl->bSwimShift = false;
                }
        }
        else if (pl->bSwim && waterDepth < 1.2f)
        {
pl->bSwim = false;
        }
 
 
                                if (!pl->bSwim) // AomBE : Fix Bugs Stamina
                {
                    pl->bSwimShift = false;
                }
                    pl->SyncAnimation(true);
            }
 
if (pl->bSwim && !pl->bSwimShift)
{
playerState = PLAYER_SWIM_M;
}
else if (!pl->bSwim)
            {
            // set walk/run state
            if(playerState != PLAYER_MOVE_SPRINT && !crouching && !proning && (accelaration.x || accelaration.z))
                playerState = aiming ? PLAYER_MOVE_WALK_AIM : PLAYER_MOVE_RUN;
            // set prone walk state
            if(playerState != PLAYER_MOVE_SPRINT && !crouching && proning && (accelaration.x || accelaration.z))
                playerState = aiming ? PLAYER_PRONE_AIM : PLAYER_MOVE_PRONE;
            }
 
                            if((playerState == PLAYER_MOVE_RUN || playerState == PLAYER_MOVE_SPRINT) && (r3dGetTime() < pl->m_SpeedBoostTime))
            {
                accelaration *= pl->m_SpeedBoost;
            }
 
#ifndef FINAL_BUILD
            if(gUserProfile.ProfileData.isDevAccount && Keyboard->IsPressed(kbsLeftAlt))
                accelaration *= 5.0f;
#endif
 
            //         STORE_CATEGORIES equippedItemCat = wpn ? wpn->getCategory() : storecat_INVALID;;
            //         if(equippedItemCat == storecat_SUPPORT || equippedItemCat == storecat_MG)
            //             accelaration *= 0.8f; // 20% slow down
        }
 
 
        if(pl->CurLoadout.Health < GPP->c_fSpeedMultiplier_LowHealthLevel)
            accelaration *= GPP->c_fSpeedMultiplier_LowHealthValue;
        if(pl->CurLoadout.Thirst > GPP->c_fSpeedMultiplier_HighThirstLevel)
            accelaration *= GPP->c_fSpeedMultiplier_HighThirstValue;
        if(pl->CurLoadout.Hunger > GPP->c_fSpeedMultiplier_HighHungerLevel)
            accelaration *= GPP->c_fSpeedMultiplier_HighHungerValue;
 
        if(crouching)
            accelaration *= 0.4f;
        if(proning)
            accelaration *= 0.2f;
 
        /*if(pl->IsJumpActive()) // don't allow to change direction when jumping
        pl->InputAcceleration = prevAccel;
        else*/
        pl->InputAcceleration = accelaration;
 
        // process jump after assigning InputAcceleration, so that we can predict where player will jump
        if(!disablePlayerMovement)
        {
            if(pl->bOnGround && (InputMappingMngr->wasPressed(r3dInputMappingMngr::KS_JUMP)||Gamepad->WasPressed(gpA)) 
                && !crouching 
                && !proning
                && !pl->IsJumpActive()
                && prevAccel.z >= 0 /* prevent jump backward*/
                )
            {
                pl->StartJump();
            }
 
        }
 
        if(!editor_debug)
            pl->PlayerState   = playerState;
 
        pl->PlayerMoveDir = CUberData::GetMoveDirFromAcceleration(pl->InputAcceleration);
 
    } VMPROTECT_End();    
 
    // adjust player physx controller size
    // TODO: we need to adjust size only when animation blending was finished! ask Denis how.
    if(crouching != pl->bCrouch || proning!=pl->bProne)
    {
        // GetPosition()/SetPosition() to keep player on the ground.
        // because capsule controller height offset will be changed in AdjustControllerSize()
        r3dPoint3D pos = pl->PhysicsObject->GetPosition();
        if(crouching || proning)
            pl->PhysicsObject->AdjustControllerSize(0.3f, 0.2f, 0.4f);
        else
            pl->PhysicsObject->AdjustControllerSize(0.3f, 1.1f, 0.85f);
        pl->PhysicsObject->SetPosition(pos + r3dPoint3D(0, 0.01f, 0));
    }
 
    pl->bCrouch = crouching;
    pl->bProne = proning;
 
    ActiveCameraRigID = (Playerstate_e)pl->PlayerState;
    ActiveCameraRig   = TPSHudCameras[g_camera_mode->GetInt()][ActiveCameraRigID];
 
    // use this to update the camera from the options. 
    static int currentCameraMode = g_camera_mode->GetInt();
 
    // if we arn't in the correct view mode currently.   And we are not doing a aim zoom, or the previous lerp is done. 
    if ( ( CurrentState != pl->PlayerState || currentCameraMode != g_camera_mode->GetInt()) && (LerpValue >= 1.0f || ( !pl->m_isAiming) ) )
    {
        currentCameraMode = g_camera_mode->GetInt();
        //set new target
        SourceRig = CurrentRig;
        TargetRig = ActiveCameraRig;
 
        if(SourceRig.Position.AlmostEqual(TargetRig.Position) && SourceRig.ScopePosition.AlmostEqual(TargetRig.ScopePosition))
        {
            // workaround for a quickscoping and firing at the same time and causing a camera to tilt up.
            if((TPSHudCameras[g_camera_mode->GetInt()][CurrentState].allowScope && !TargetRig.allowScope) || (!TPSHudCameras[g_camera_mode->GetInt()][CurrentState].allowScope && TargetRig.allowScope))
            {
                g_CameraPointToAdj_HasAdjustedVec = false;
            }
        }
        else
        {
            g_CameraPointToAdj_adjVec = R3D_LERP(g_CameraPointToAdj_adjVec, g_CameraPointToAdj_nextAdjVec, LerpValue);
            g_CameraPointToAdj_HasAdjustedVec = false;
        }
 
        LerpValue = 0;
 
        CurrentState = (Playerstate_e)pl->PlayerState;    
    }
    else
    {
        // just lerp
        if (LerpValue < 1.0f)
        {
            float lerpMOD = 1.0f;
            STORE_CATEGORIES equippedItemCat = wpn ? wpn->getCategory() : storecat_INVALID;;
            if(TargetRig.allowScope) // slow down aiming for those categories
                if(equippedItemCat == storecat_MG)
                    lerpMOD = 0.5f;
 
            LerpValue += r3dGetFrameTime()*6.5f*lerpMOD;
            if (LerpValue >1.0f) LerpValue = 1.0f;
 
            CurrentRig.Lerp(pl, SourceRig, TargetRig, LerpValue);
        }
        else
            CurrentRig.Lerp(pl, SourceRig, TargetRig, 1.0f);
    }
 
    if(!disablePlayerRotation)
    {
        float  glb_MouseSensAdj = CurrentRig.MouseSensetivity * g_mouse_sensitivity->GetFloat();    
        //  Mouse controls are here
 
        float mmoveX = float(-mMX) * glb_MouseSensAdj;
        float mmoveY = float(-mMY) * glb_MouseSensAdj;
 
        // fight only vertical recoil, apply adjustment leftover to viewvector
        if(pl->RecoilViewModTarget.y > 0.01f && mmoveY < 0) {
            pl->RecoilViewModTarget.y += mmoveY;
            if(pl->RecoilViewModTarget.y < 0) {
                mmoveY = pl->RecoilViewModTarget.y;
                pl->RecoilViewModTarget.y = 0;
            } else {
                mmoveY = 0;
            }
        }
 
        pl->ViewAngle.x += mmoveX;
        pl->ViewAngle.y += mmoveY;
 
        if(Gamepad->IsConnected()) // overwrite mouse
        {
            float X, Y;
            Gamepad->GetRightThumb(X, Y);
            pl->ViewAngle.x += float(-X) * glb_MouseSensAdj * r_gamepad_view_sens->GetFloat();
            pl->ViewAngle.y += float(Y) * glb_MouseSensAdj * r_gamepad_view_sens->GetFloat() * (g_vertical_look->GetBool()?-1.0f:1.0f);
        }
 
        if(pl->ViewAngle.x > 360.0f ) pl->ViewAngle.x = pl->ViewAngle.x - 360.0f;
        if(pl->ViewAngle.x < 0.0f )   pl->ViewAngle.x = pl->ViewAngle.x + 360.0f;
 
        // Player can't look too high!
        if(pl->ViewAngle.y > CurrentRig.LookUpLimit )  pl->ViewAngle.y = CurrentRig.LookUpLimit;
        if(pl->ViewAngle.y < CurrentRig.LookDownLimit) pl->ViewAngle.y = CurrentRig.LookDownLimit;
 
        // set player rotation (except when planting mines)
        pl->m_fPlayerRotationTarget = -pl->ViewAngle.x;
 
        // calculate player vision
        r3dVector FinalViewAngle = pl->ViewAngle + pl->RecoilViewMod + pl->SniperViewMod;
        if(FinalViewAngle.x > 360.0f ) FinalViewAngle.x = FinalViewAngle.x - 360.0f;
        if(FinalViewAngle.x < 0.0f )   FinalViewAngle.x = FinalViewAngle.x + 360.0f;
        // Player can't look too high!
        if(FinalViewAngle.y > CurrentRig.LookUpLimit )  FinalViewAngle.y = CurrentRig.LookUpLimit;
        if(FinalViewAngle.y < CurrentRig.LookDownLimit) FinalViewAngle.y = CurrentRig.LookDownLimit;
 
        D3DXMATRIX mr;
        D3DXMatrixRotationYawPitchRoll(&mr, R3D_DEG2RAD(-FinalViewAngle.x), R3D_DEG2RAD(-FinalViewAngle.y), 0);
        pl->m_vVision  = r3dVector(mr._31, mr._32, mr._33);
    }
 
    if (TargetRig.FXFunc) TargetRig.FXFunc(LerpValue);
 
    pl->UpdateLocalPlayerMovement();
}
 
//----------------------------------------------------------------
void TPSGameHUD :: Process()
{
    if(g_cursor_mode->GetInt());
    {
        imgui_Update();
        imgui2_Update();
    }
 
    {
        r3dSetAsyncLoading( 1 );
    }
 
    obj_Player* pl = gClientLogic().localPlayer_;
    if(!pl) return;
  }
 
#ifndef FINAL_BUILD
 
    bool allow_specator_mode = true;
    if(Keyboard->WasPressed(kbsF8) && allow_specator_mode)
    {
        d_video_spectator_mode->SetBool(!d_video_spectator_mode->GetBool());
        static float DOF_NS=0, DOF_NE=0, DOF_FS=0, DOF_FE=0;
        static int DOF_N=0, DOF_F=0, DOF_ENABLE=0;
        if(d_video_spectator_mode->GetBool())
        {
            FPS_vViewOrig.Assign(pl->ViewAngle);
            // save
            DOF_NS=DepthOfField_NearStart;
            DOF_NE=DepthOfField_NearEnd;
            DOF_FS=DepthOfField_FarStart;
            DOF_FE=DepthOfField_FarEnd;
            DOF_N=_NEAR_DOF;
            DOF_F=_FAR_DOF;
            DOF_ENABLE=LevelDOF;
        }
        else
        {
            // restore
            DepthOfField_NearStart=DOF_NS;
            DepthOfField_NearEnd=DOF_NE;
            DepthOfField_FarStart=DOF_FS;
            DepthOfField_FarEnd=DOF_FE;
            _NEAR_DOF=DOF_N;
            _FAR_DOF=DOF_F;
            LevelDOF=DOF_ENABLE;
        }
    }
 
    bool allow_observer_mode = true;
    allow_observer_mode = false;
 
    if(Keyboard->WasPressed(kbsF9) && allow_observer_mode)
    {
        d_observer_mode->SetBool(!d_observer_mode->GetBool());
        if(d_observer_mode->GetBool())
        {
            FPS_vViewOrig.Assign(pl->ViewAngle);
        }
    }
 
    if(d_video_spectator_mode->GetBool() || d_observer_mode->GetBool())
    {
        FPS_Acceleration.Assign(0, 0, 0);
 
        float  glb_MouseSensAdj = g_mouse_sensitivity->GetFloat();    
        // camera view
        if(Gamepad->IsConnected())
        {
            float X, Y;
            Gamepad->GetRightThumb(X, Y);
            FPS_vViewOrig.x += float(-X) * r_gamepad_view_sens->GetFloat();
            FPS_vViewOrig.y += float(Y) * r_gamepad_view_sens->GetFloat() * (g_vertical_look->GetBool()?-1.0f:1.0f);
        }
        else // mouse fallback
        {
            int mMX=Mouse->m_MouseMoveX, mMY=Mouse->m_MouseMoveY;
 
            FPS_vViewOrig.x += float(-mMX) * glb_MouseSensAdj;
            FPS_vViewOrig.y += float(-mMY) * glb_MouseSensAdj * (g_vertical_look->GetBool()?-1.0f:1.0f);
        }
 
        if(FPS_vViewOrig.y > 85)  FPS_vViewOrig.y = 85;
        if(FPS_vViewOrig.y < -85) FPS_vViewOrig.y = -85;
 
        FPS_ViewAngle = FPS_vViewOrig;
 
        if(FPS_ViewAngle.y > 360 ) FPS_ViewAngle.y = FPS_ViewAngle.y - 360;
        if(FPS_ViewAngle.y < 0 )   FPS_ViewAngle.y = FPS_ViewAngle.y + 360;
 
 
        D3DXMATRIX mr;
 
        D3DXMatrixIdentity(&mr);
        D3DXMatrixRotationYawPitchRoll(&mr, R3D_DEG2RAD(-FPS_ViewAngle.x), R3D_DEG2RAD(-FPS_ViewAngle.y), 0);
 
        FPS_vVision  = r3dVector(mr._31, mr._32, mr._33);
 
        D3DXMatrixIdentity(&mr);
        D3DXMatrixRotationYawPitchRoll(&mr, R3D_DEG2RAD(-FPS_ViewAngle.x), 0, 0);
        FPS_vRight = r3dVector(mr._11, mr._12, mr._13);
        FPS_vUp    = r3dVector(0, 1, 0);
        FPS_vForw  = r3dVector(mr._31, mr._32, mr._33);
 
        FPS_vForw.Normalize();
        FPS_vRight.Normalize();
        FPS_vVision.Normalize();
 
        // walk
        extern float __EditorWalkSpeed;
        float fSpeed = __EditorWalkSpeed;
 
        float mult = 1;
        if(Keyboard->IsPressed(kbsLeftShift)) mult = d_spectator_fast_move_mul->GetFloat();
        if(Keyboard->IsPressed(kbsLeftControl)) mult = d_spectator_slow_move_mul->GetFloat();
 
        if(Keyboard->IsPressed(kbsW)) FPS_Acceleration.Z = fSpeed;
        if(Keyboard->IsPressed(kbsS)) FPS_Acceleration.Z = -fSpeed * 0.7f;
        if(Keyboard->IsPressed(kbsA)) FPS_Acceleration.X = -fSpeed * 0.7f;
        if(Keyboard->IsPressed(kbsD)) FPS_Acceleration.X = fSpeed * 0.7f;
        if(Keyboard->IsPressed(kbsQ)) FPS_Position.Y    += SRV_WORLD_SCALE(1.0f)* r3dGetFrameTime() * mult;
        if(Keyboard->IsPressed(kbsE)) FPS_Position.Y    -= SRV_WORLD_SCALE(1.0f)* r3dGetFrameTime() * mult;
 
        if(Gamepad->IsConnected())
        {
            float RX, RY, TL, TR;
            Gamepad->GetLeftThumb(RX, RY);
            Gamepad->GetTrigger(TL, TR);
 
            FPS_Acceleration.Z = -RY*r_gamepad_move_speed->GetFloat();
            FPS_Acceleration.Z = RY*r_gamepad_move_speed->GetFloat();
            FPS_Acceleration.X = -RX*r_gamepad_move_speed->GetFloat();
            FPS_Acceleration.X = RX*r_gamepad_move_speed->GetFloat();
            FPS_Position.Y    += r3dGetFrameTime() * TR * r_gamepad_move_speed->GetFloat();
            FPS_Position.Y    -= r3dGetFrameTime() * TL * r_gamepad_move_speed->GetFloat();
        }
 
        FPS_Position += FPS_vVision * FPS_Acceleration.Z * r3dGetFrameTime() * mult;
        FPS_Position += FPS_vRight * FPS_Acceleration.X * r3dGetFrameTime() *mult;
 
        return;
    }
#endif
    ProcessPlayerMovement(pl, false);
}

There is the full code help me please guys :D

[weaknessforcats]

I'm not saying this is the problem. But it is a problem anyhow:

if(g_cursor_mode->GetInt()); <<<<<!!!!
     {
         imgui_Update();
         imgui2_Update();
     }
 

That semi-colon terminates your if statement leaving these function calls in an anonymous code block:

{
         imgui_Update();
         imgui2_Update();
     }
 

so they get called if the if is true or false.

The "local functions" means you have a function definition inside another function definition. Like the semi-colon above, a missing or mismatched brace somewhere can do this. Be sure all your braces are matched correctly. This includes all your header files.