Сегодня исполняется 10 лет с момента выхода S.T.A.L.K.E.R.: Тень Чернобыля

// CustomFlyer.cpp: implementation of the CCustomFlyer class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Flyer.h"
#include "../CameraLook.h"
#include "CameraFirstEye.h"
#include "../environment.h"
#include "../skeletoncustom.h"

#define    FLY_ACCEL        10.0f
#define    YAW_ACCEL        0.75f
#define RUN_COEF        4.0f
#define MAX_CAM_YAW        1.75f

#define FRICTION_AIR    1.75f
#define FRICTION_WALL    5.f
#define FRICTION_GROUND    10.f
//#define AIR_RESIST        (1.f-0.01f)

#define MIN_CRASH_SPEED    15.f
#define MAX_CRASH_SPEED    30.f

IC float sign(float t) { return (t>=0)?1.f:-1.f; }
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CFlyer::CFlyer() : inherited()
{

    m_PhysicMovementControl->SetCrashSpeeds    (MIN_CRASH_SPEED,MAX_CRASH_SPEED);
    m_PhysicMovementControl->SetParent        (this);
    m_PhysicMovementControl->SetMass        (2000);
    m_PhysicMovementControl->SetApplyGravity(FALSE);
    m_PhysicMovementControl->SetFriction    (FRICTION_AIR,FRICTION_WALL,FRICTION_GROUND);

    cameras[efcFrontView]    = xr_new<CCameraFirstEye>    (this, pSettings, "heli_front_cam", true);
    cameras[efcLookAt]        = xr_new<CCameraLook>        (this, pSettings, "heli_look_cam", false);
    cameras[efcFreeLook]    = xr_new<CCameraLook>        (this, pSettings, "heli_free_cam", false);
    cam_active                = efcFrontView;

    eState        = fsWork;

    new_mstate    = 0;
    cur_mstate    = 0;

    mYaw        = 0;
    mYawVelocity= 0;

//    vOldVel.set(0,0,0);

//    Device.seqRender.Add    (this);
}

CFlyer::~CFlyer()
{
//    Device.seqRender.Remove    (this);

    for (int i=0; i<efcMaxCam; ++i) xr_delete(cameras[i]);
}

void CFlyer::Load(LPCSTR section)
{
    Msg("Loading flyer: %s",section);
    inherited::Load(ini,section);

    Fbox aabb;
    aabb.set                (CFORM()->GetBBox());
//    m_PhysicMovementControl->SetBox            (aabb);
    Fvector vfC,vfE;
    vfE.set                    (1.f,.25f,1.f);
    vfC.set                    (0.f,.2f,0.f);
    m_PhysicMovementControl->SetFoots        (vfC,vfE);
    m_PhysicMovementControl->CalcMaximumVelocity(mMaxAirVelocity,FLY_ACCEL*RUN_COEF,FRICTION_AIR);
    m_PhysicMovementControl->CalcMaximumVelocity(mMaxYawVelocity,YAW_ACCEL*RUN_COEF,FRICTION_AIR);
//    R_ASSERT    (Visual()->Type==MT_SKELETON);
//    smart_cast<CKinematics*>    (Visual())->PlayCycle("work");
}

void CFlyer::UpdateState(){
    // проверить живой или нет
    eState                    = (1)?fsWork:fsDead;
}

void CFlyer::CheckControls(Fvector &vControlAccel, float& fYawAccel)
{
    // control accel
    vControlAccel.set(0,0,0);
    fYawAccel = 0;
    
    // update player accel
    if (cur_mstate&mcUp)        vControlAccel.y =  1;
    if (cur_mstate&mcDown)        vControlAccel.y = -1;

    if (cur_mstate&mcFwd)        vControlAccel.z =  1;
    if (cur_mstate&mcBack)        vControlAccel.z = -1;
    if (cur_mstate&mcLStrafe)    vControlAccel.x = -1;
    if (cur_mstate&mcRStrafe)    vControlAccel.x =  1;
    if (cur_mstate&mcLeft)        fYawAccel        = -1;
    if (cur_mstate&mcRight)        fYawAccel        = 1;

    if ((cam_active==efcFrontView)&&(fYawAccel==0)){
        CCameraBase* cam = cameras[efcFrontView];
        float val = cam->CheckLimYaw();
        float sgn = sign(val);
        if ((val>-.05f)&&(val<0.05f)) val = 0;
        fYawAccel = val;//sgn*val*val;
    }
//    fMouseYawMoving *= 0.8f;
    
    vControlAccel.normalize_safe();
    vControlAccel.mul            (FLY_ACCEL);
    fYawAccel                    *= YAW_ACCEL;
    if (isAccelerated())    {
        vControlAccel.mul        (RUN_COEF);
        fYawAccel                *= RUN_COEF;
    }
    if (m_PhysicMovementControl->Environment()==CMovementControl::peOnGround){
        vControlAccel.x*=0.1f;
        vControlAccel.z*=0.1f;
        fYawAccel*=0.1f;
    }

    vControlAccel.y *= 0.75f;
    //if (_abs(vControlAccel.y)>EPS_L) vControlAccel.y -= psGravity*.25f;
}

void CFlyer::SetAnimation( )
{
}

#define BANK_FACTOR 1.25f
void CFlyer::Update(u32 DT)
{
    if (!bEnabled) return;

    float dt        = float(DT)/1000.f;

    // enabled & disabled motion state on current frame
    cur_mstate        = new_mstate;

    // update controls
    Fvector vControlAccel;
    float    fYawAccel;
    CheckControls    (vControlAccel,fYawAccel);

    // prepare safe translate object
    Fvector            accel;
    /*
    switch(m_PhysicMovementControl->Environment())
    {
        case CMovementControl::peInAir:        pApp->pFont->Out(-1.f,0.5f,"Env: air");        break;
        case CMovementControl::peAtWall:    pApp->pFont->Out(-1.f,0.5f,"Env: wall");    break;
        case CMovementControl::peOnGround:    pApp->pFont->Out(-1.f,0.5f,"Env: ground");    break;
        default: NODEFAULT;
    }
    */

    // rotation
    mYaw            = mYaw + mYawVelocity*dt + fYawAccel*dt*dt*0.5f;
    mYawVelocity    = mYawVelocity + fYawAccel*dt;
    mYawVelocity    -= dt*mYawVelocity*m_PhysicMovementControl->GetCurrentFriction();

    Fvector D,N;
    D.set(_sin(mYaw),0.f,_cos(mYaw));
    N.set(0,1,0);
    mRotate.rotation(D,N);

    // movement
    mRotate.transform_dir(accel, vControlAccel);

    m_PhysicMovementControl->SetPosition(Position());
    m_PhysicMovementControl->Calculate    (accel,mYawVelocity,0,dt,false);
    m_PhysicMovementControl->GetPosition(Position());

//---------------------------------------------------------
// рассчитаем крен
//---------------------------------------------------------
    const Fvector& VM = m_PhysicMovementControl->GetVelocity();
    Fvector        V;
//    V.set        (vOldVel);
//    V.inertion    (VM,0.999f);
//    vOldVel.set    (VM);
    Fmatrix        M;
    M.transpose    (mRotate);
    M.transform_dir(V,VM);

//    pApp->pFont->Out(-1,0.8f,"Vel: %.2f, %.2f, %.2f",V.x,V.y,V.z);

    // рассчитаем возможный крен по скорости
    V.div        (mMaxAirVelocity*2.f*BANK_FACTOR);
    Fmatrix        Rbank;
    Fquaternion Q;

    // рассчитаем крен по повороту
    float bank = mYawVelocity/(mMaxYawVelocity*BANK_FACTOR);
    bank*=_abs        (V.z*4.f);
    bank+=V.x;

    // повернем модель
    Q.rotationYawPitchRoll(bank,0,-(V.z));
    Rbank.rotation    (Q);
    mRotate.mulB_43    (Rbank);

    // crop yaw angle
    if (mYaw>PI_MUL_2){
        mYaw-=PI_MUL_2;
        cameras[efcLookAt]->yaw-=PI_MUL_2;
    }
    if (mYaw<-PI_MUL_2){
        mYaw+=PI_MUL_2;
        cameras[efcLookAt]->yaw+=PI_MUL_2;
    }

    // look camera delay computing
    float vm = V.magnitude()*BANK_FACTOR*2; clamp(vm,0.f,1.f);
    {
        float Yo, k, Ay, z, f;
        Yo    = cameras[efcLookAt]->yaw;
        z    = 1.6f;
        f    = 1.2f+vm;
        k    = PI_MUL_2*f;
        Ay    = (mYaw-Yo)*k*k - Vy*k*z;
        cameras[efcLookAt]->yaw = Yo + Vy*dt + Ay*dt*dt*0.5f;
        Vy    = 0.99f*Vy + Ay*dt;
    }

//---------------------------------------------------------
    // test nearest object
//    Fvector C; float R;
//    m_PhysicMovementControl->GetBoundingSphere(C,R);
//    g_pGameLevel->ObjectSpace.TestNearestObject(CFORM(), C, R);

    // check state
    UpdateState            ();

    // Check ground-contact
    if (m_PhysicMovementControl->gcontact_Was) {
    }

    // update motions
    SetAnimation        ();


    UpdateTransform        ();
//    smart_cast<CKinematics*>(Visual())->Update();

    inherited::Update    (DT);

    if (IsMyCamera()) UpdateCamera();

    // HUD update

//    pApp->pFont->Out(-1,0.88f,"Fly P: %.3f, %.3f, %.3f",Position().x,Position().y,Position().z);
//    pApp->pFont->Out(-1,0.93f,"Fly D: %.3f, %.3f, %.3f",mRotate.k.x,mRotate.k.y,mRotate.k.z);
}

#ifdef DEBUG
void CFlyer::OnRender    ()
{
    if (!bDebug)        return;
    m_PhysicMovementControl->dbg_Draw    ();
}
#endif

// CustomFlyer.h: interface for the CCustomFlyer class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_FLYER_H__06360CF2_1B3F_4F82_814D_F7BF5E4F601C__INCLUDED_)
#define AFX_FLYER_H__06360CF2_1B3F_4F82_814D_F7BF5E4F601C__INCLUDED_
#pragma once

#include "entity.h"
#include "actor_flags.h"

// refs
class CCameraBase;

class CFlyer : public CEntity
{
    enum EMoveCommand{
        mcFwd        = 0x0001,
        mcBack        = 0x0002,
        mcLStrafe    = 0x0004,
        mcRStrafe    = 0x0008,
        mcUp        = 0x0010,
        mcDown        = 0x0020,
        mcAccel        = 0x0100,
        mcLeft        = 0x0200,
        mcRight        = 0x0400
    };
    enum EFlyerCameras {
        efcFrontView    = 0,
        efcLookAt,
        efcFreeLook,
        efcMaxCam
    };
    enum EFlyerState{
        fsWork,
        fsDead
    };

private:
    typedef CEntity        inherited;
private:
    
    // State machine
    EFlyerState            eState;                                // +644
    u32                    new_mstate, cur_mstate;                // +648, +652

    float                mYaw;                                // +656
    float                mYawVelocity;                        // +660
    float                mMaxYawVelocity;                    // +664

    float                mMaxAirVelocity;                    // +668
    IC BOOL                isAccelerated    ()    {
        if (cur_mstate&mcAccel) return psActorFlags.test(AF_ALWAYSRUN)?FALSE:TRUE;
        else                    return psActorFlags.test(AF_ALWAYSRUN)?TRUE :FALSE;
    }

    // Cameras
    CCameraBase*        cameras[efcMaxCam];                    // +672
    EFlyerCameras        cam_active;                            // +684
    void                ChangeCamStyle        (EFlyerCameras style);

    void                UpdateState            ();
    void                UpdateCamera        ();
    void                SetAnimation        ();
    void                CheckControls        (Fvector &vControlAccel, float& fYawAccel);
public:
                        CFlyer                ();
    virtual                ~CFlyer                ();

    virtual void        Load                (LPCSTR section);

    // Fire control
    virtual void        g_fireParams        (const CHudItem* /**pHudItem/**/, Fvector& /**P/**/, Fvector& /**D/**/) {};

    virtual void        HitSignal            ( int /**iHitAmount/**/, Fvector& /**vLocalDir/**/, CEntity* /**E/**/, s16 /**element/**/){;}

    virtual void        Update                ( u32 DT );

    virtual void        IR_onMouseMove            (int x, int y);
    virtual void        IR_OnKeyboardPress        (int dik);
    virtual void        IR_OnKeyboardRelease    (int dik);
    virtual void        IR_OnKeyboardHold        (int dik);

#ifdef DEBUG
    virtual void        OnRender            ();
#endif
};

#endif // !defined(AFX_FLYER_H__06360CF2_1B3F_4F82_814D_F7BF5E4F601C__INCLUDED_)

#include "stdafx.h"
#include "Flyer.h"
#include "../CameraBase.h"

void CFlyer::UpdateCamera()
{
    Fvector point, dangle;
    
    // get calc eye point 90% from player height
    Fvector                        R;
    m_PhysicMovementControl->Box().getsize        (R);
    point.set                    (0.f,R.y*0.55f,0.9f);
    XFORM().transform_tiny    (point);

    dangle.set(0,0,0);
    switch (cam_active){
    case efcFrontView:    break;
    case efcLookAt:        break;
    case efcFreeLook:    break;
    default: NODEFAULT;
    }
    CCameraBase* C                = cameras[cam_active];
    C->Update                    (point,dangle);
    g_pGameLevel->Cameras().Update    (C);
}

void CFlyer::ChangeCamStyle    (EFlyerCameras style){
    CCameraBase* old_cam = cameras[cam_active];
    cam_active = style;
    CCameraBase* new_cam = cameras[cam_active];
    old_cam->onDeactivate();
    new_cam->onActivate(old_cam);
    switch(cam_active){
    case efcFrontView:    bVisible = true;     new_cam->yaw=0;    break;
    case efcLookAt:        bVisible = true;    break;
    case efcFreeLook:    bVisible = true;    break;
    }
}

#include "stdafx.h"
#include "flyer.h"
#include "../xr_input.h"
#include "../CameraBase.h"


void CFlyer::IR_OnKeyboardPress(int cmd){
    if (eState==fsDead) return;
    switch(cmd){
    case kACCEL:    new_mstate |= mcAccel;        break;
    case kR_STRAFE:    new_mstate |= mcRStrafe;    break;
    case kL_STRAFE:    new_mstate |= mcLStrafe;    break;
    case kFWD:        new_mstate |= mcFwd;        break;
    case kBACK:        new_mstate |= mcBack;        break;
    case kJUMP:        new_mstate |= mcUp;            break;
    case kCROUCH:    new_mstate |= mcDown;        break;
    case kLEFT:        new_mstate |= mcLeft;        break;
    case kRIGHT:    new_mstate |= mcRight;        break;
//    case kFIRE:        FireStart();                break;
    case kCAM_1:    ChangeCamStyle(efcFrontView);break;
    case kCAM_2:    ChangeCamStyle(efcLookAt);    break;
    case kCAM_3:    ChangeCamStyle(efcFreeLook);break;
    }
}

void CFlyer::IR_OnKeyboardRelease(int cmd){
    switch(cmd){
    case kACCEL:    new_mstate &=~mcAccel;        break;
    case kR_STRAFE:    new_mstate &=~mcRStrafe;    break;
    case kL_STRAFE:    new_mstate &=~mcLStrafe;    break;
    case kFWD:        new_mstate &=~mcFwd;        break;
    case kBACK:        new_mstate &=~mcBack;        break;
    case kJUMP:        new_mstate &=~mcUp;            break;
    case kCROUCH:    new_mstate &=~mcDown;        break;
    case kLEFT:        new_mstate &=~mcLeft;        break;
    case kRIGHT:    new_mstate &=~mcRight;        break;
//    case kFIRE:        FireEnd();                    break;
    }
}

void CFlyer::IR_OnKeyboardHold(int cmd){
    if (eState==fsDead) return;
    switch(cmd){
    case kCAM_ZOOM_IN:
    case kCAM_ZOOM_OUT:
    case kUP:
    case kDOWN:
        cameras[cam_active]->Move(cmd);
        break;
    case kLEFT:
    case kRIGHT:
//        if (cam_active==efcFreeLook)
//            cameras[cam_active]->Move(cmd);
        break;

    }
}

void CFlyer::IR_onMouseMove(int dx, int dy)
{
    float scale        = psMouseSens * psMouseSensScale/50.f;
    if (efcLookAt!=cam_active)
        if (dx){
            float d = float(dx)*scale;
            cameras[cam_active]->Move((d<0)?kLEFT:kRIGHT, _abs(d));
//            fMouseYawMoving = 1.f;
        }
    if (dy){
        float d = ((psMouseInvert.test(1))?-1:1)*float(dy)*scale*MouseHWScale;
        cameras[cam_active]->Move((d>0)?kUP:kDOWN, _abs(d));
    }
}