Player.h

/*
 * Copyright (c) 2016-2022 Vera Visions LLC.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
 
noref .vector v_angle;
 
class
ncPlayer:ncSpectator
{
public:
    void ncPlayer(void);
 
    virtual void PlayGesture(float gestureAnim, float overrideTime);
    
    virtual void ProcessInput(void);
    virtual void PreFrame(void);
    virtual void PostFrame(void);
    
    virtual void Physics_Fall(float);
    virtual void Physics_Crouch(void);
    virtual void Physics_Prone(void);
    virtual void Physics_Jump(void);
    virtual void Physics_CheckJump(float);
    virtual void Physics_SetViewParms(void);
    virtual void Physics_WaterJump(void);
    virtual void Physics_WaterMove(void);
    virtual float Physics_MaxSpeed(void);
    virtual void Physics_InputPreMove(void);
    virtual void Physics_InputPostMove(void);
    virtual void Physics_Run(void);
    virtual void Physics_InputSprint(void);
    
    virtual bool IsFakeSpectator(void);
    virtual bool IsRealSpectator(void);
    virtual bool IsDead(void);
    virtual bool IsPlayer(void);
    virtual void SharedInputFrame(void);
 
    virtual bool CanSprint(void);
    virtual bool CanProne(void);
    virtual bool CanCrouch(void);
    virtual bool CanLean(void);
    
    virtual void UpdatePlayerAnimation(float);
 
    virtual void Damage(entity, entity, ncDict, float, vector, vector);
    virtual bool CanPickupEntity(ncEntity toPickUp, float massLimit, float sizeLimit);
 
#ifdef CLIENT
    virtual void OnRemoveEntity(void);
    virtual void ReceiveEntity(float,float);
    virtual void _ReceiveComplete(float, float);
    virtual void PredictPreFrame(void);
    virtual void PredictPostFrame(void);
    virtual void ClientInputFrame(void);
 
    virtual vector CalculateLean(vector);
    virtual void UpdateAliveCam(void);
 
    virtual void UpdatePlayerJaw(float);
 
    virtual void UpdatePlayerAttachments(bool);
 
    virtual float predraw(void);
    virtual void postdraw(void);
 
#endif
 
    virtual void Spawned(void);
 
#ifdef SERVER
    /* overrides */
    virtual void Save(float);
    virtual void Restore(string,string);
    virtual void Respawn(void);
    virtual void EvaluateEntity(void);
    virtual float SendEntity(entity,float);
    virtual void Death(entity, entity, int, vector, vector, int);
    virtual void ServerInputFrame(void);
    virtual void Input(entity, string, string);
 
    virtual float OptimiseChangedFlags(entity,float);
 
    virtual void MakePlayer(void);
    virtual void MakeTempSpectator(void);
    virtual void MakeSpectator(void);
 
    virtual void InputUse_Down(void);
    virtual void InputUse_Up(void);
 
    /* Returns whether we're able to pick up an entity in the game with +use. If `true` you can then use PickupEntity() to attach it to the player. */
    virtual bool  CanPickupEntity(ncEntity, float, float);
    /* Will attach an entity to the player. It's position will continously update in front of the player camera, but in XR modes it may be attached to one of the hands instead.*/
    nonvirtual void PickupEntity(ncEntity);
 
#endif
 
    nonvirtual float WeaponAnimTime(void);
 
    virtual void Footsteps_Update(void);
 
private:
    nonvirtual void _UpdatePMoveVars(void);
 
#ifdef CLIENT
    NETWORKED_INT(m_weaponAnimSequence)
    NETWORKED_FLOAT(vehicle_entnum)
 
    float clsndindex_idle;
#endif
 
#ifdef SERVER
    float m_weaponCookingTime;
#endif
 
    NETWORKED_FLOAT(health)
    NETWORKED_FLOAT(sndindex_idle)
 
    /* animation */
    NETWORKED_FLOAT(anim_top)
    NETWORKED_FLOAT(anim_top_time)
    NETWORKED_FLOAT(anim_top_delay)
    NETWORKED_FLOAT(anim_bottom)
    NETWORKED_FLOAT(anim_bottom_time)
 
    NETWORKED_FLOAT_N(colormap)
    NETWORKED_FLOAT_N(gflags)
    NETWORKED_FLOAT(viewzoom)
    NETWORKED_VECTOR_N(view_ofs)
    NETWORKED_FLOAT_N(vw_index)
    NETWORKED_VECTOR_N(m_pmoveBaseVelocity)
    NETWORKED_VECTOR_N(v_angle)
    NETWORKED_FLOAT_N(gravity)
    NETWORKED_FLOAT_N(friction)
    NETWORKED_FLOAT(speedmod)
 
    NETWORKED_VECTOR_N(m_pmoveLadderNormal)
 
    NETWORKED_FLOAT(m_timeUntilNextAttack)
    NETWORKED_FLOAT(m_timeUntilNextIdle)
    NETWORKED_FLOAT(m_timeUntilReloaded)
    NETWORKED_FLOAT(m_timeSinceJump)
    NETWORKED_FLOAT(m_timeSinceTeleport)
    NETWORKED_VECTOR(m_punchAngle)
    NETWORKED_VECTOR(m_punchVelocity)
 
    NETWORKED_INT(m_weaponAnimSequence)
    NETWORKED_FLOAT(m_weaponAnimTime)
 
    /* We can't use the default .items field, because FTE will assume
     * effects of some bits. Such as invisibility, quad, etc. 
     * also, modders probably want 32 bits for items. */
    NETWORKED_FLOAT_N(activeweapon)
    ncItem m_itemList_net;
    int m_ammoTypes_net[MAX_AMMO_TYPES];
 
    /* vehicle info */
    NETWORKED_ENT(vehicle)
    NETWORKED_VECTOR(m_pmoveHookVelocity)
 
#ifdef CLIENT
    int sequence;
 
    /* external weapon model */
    ncRenderableEntity p_model;
    int p_hand_bone;
    int p_model_bone;
    float lastweapon;
#endif
    ncPMoveVars m_pmoveVars;
 
#ifdef SERVER
    int voted;
    int step;
    float m_timeUntilNextFootstep;
 
    int m_underwaterDamageDealt;
    float m_timeUnderwater;
    float m_timeUntilNextPainSFX;
 
    entity last_used;
 
    float pb_angle_delta;
    float pb_player_delta;
    vector pb_last_angles;
 
    int m_friendlyFireDamageDealt;
#endif
 
    entity m_holdingEntity;
    NETWORKED_FLOAT(m_animBackend)
 
 
 
    virtual void Event_DrawWeapon(void);
    virtual void Event_FireWeapon(void);
    virtual void Event_ReloadWeaponStart(void);
    virtual void Event_ReloadWeapon(void);
    virtual void Event_ReloadWeaponEnd(void);
    virtual void Event_HolsterWeapon(void);
 
    nonvirtual void UpdatePlayerAnimation_Skeletal(float timelength);
    nonvirtual void UpdatePlayerAnimation_Goose(float timelength);
    nonvirtual void UpdatePlayerAnimation_Valve(float timelength);
};
 
/* all potential SendFlags bits we can possibly send */
enumflags
{
    PLAYER_MODELINDEX,
    PLAYER_ORIGIN,
    PLAYER_ANGLES,
    PLAYER_VELOCITY,
    PLAYER_FLAGS,
    PLAYER_WEAPON,
    PLAYER_ITEMS,
    PLAYER_HEALTH,
    PLAYER_SIZE,
    PLAYER_MOVETYPE,
    PLAYER_PUNCHANGLE,
    PLAYER_VIEWZOOM,
    PLAYER_TIMINGS,
    PLAYER_VEHICLE,
    PLAYER_SPECTATE,
    PLAYER_AMMOTYPES,
    PLAYER_WEAPONFRAME,
    PLAYER_TOPFRAME,
    PLAYER_BOTTOMFRAME,
    PLAYER_CUSTOMFIELDSTART,
};
 
.bool _isPlayer;