258 lines
8.0 KiB
C++
258 lines
8.0 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: A base class for model-based doors. The exact movement required to
|
|
// open or close the door is not dictated by this class, only
|
|
//that the door has open, closed, opening, and closing states.
|
|
//
|
|
// Doors must satisfy these requirements:
|
|
//
|
|
// - Derived classes must support being opened by NPCs.
|
|
// - Never autoclose in the face of a player.
|
|
// - Never close into an NPC.
|
|
//
|
|
//=============================================================================//
|
|
|
|
#ifndef BASEPROPDOOR_H
|
|
#define BASEPROPDOOR_H
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "entityoutput.h"
|
|
#include "locksounds.h"
|
|
#include "props.h"
|
|
|
|
extern ConVar g_debug_doors;
|
|
|
|
struct opendata_t {
|
|
Vector vecStandPos; // Where the NPC should stand.
|
|
Vector vecFaceDir; // What direction the NPC should face.
|
|
Activity eActivity; // What activity the NPC should play.
|
|
};
|
|
|
|
abstract_class CBasePropDoor : public CDynamicProp {
|
|
public:
|
|
DECLARE_CLASS(CBasePropDoor, CDynamicProp);
|
|
DECLARE_SERVERCLASS();
|
|
|
|
CBasePropDoor(void);
|
|
|
|
void Spawn();
|
|
void Precache();
|
|
void Activate();
|
|
int ObjectCaps();
|
|
|
|
void HandleAnimEvent(animevent_t * pEvent);
|
|
|
|
// Base class services.
|
|
// Do not make the functions in this block virtual!!
|
|
// {
|
|
inline bool IsDoorOpen();
|
|
inline bool IsDoorAjar();
|
|
inline bool IsDoorOpening();
|
|
inline bool IsDoorClosed();
|
|
inline bool IsDoorClosing();
|
|
inline bool IsDoorLocked();
|
|
inline bool IsDoorBlocked() const;
|
|
inline bool IsNPCOpening(CAI_BaseNPC * pNPC);
|
|
inline bool IsPlayerOpening();
|
|
inline bool IsOpener(CBaseEntity * pEnt);
|
|
|
|
bool NPCOpenDoor(CAI_BaseNPC * pNPC);
|
|
bool TestCollision(const Ray_t &ray, unsigned int mask, trace_t &trace);
|
|
// }
|
|
|
|
// Implement these in your leaf class.
|
|
// {
|
|
virtual bool DoorCanClose(bool bAutoClose) { return true; }
|
|
virtual bool DoorCanOpen(void) { return true; }
|
|
|
|
virtual void GetNPCOpenData(CAI_BaseNPC * pNPC, opendata_t & opendata) = 0;
|
|
virtual float GetOpenInterval(void) = 0;
|
|
// }
|
|
|
|
protected:
|
|
enum DoorState_t {
|
|
DOOR_STATE_CLOSED = 0,
|
|
DOOR_STATE_OPENING,
|
|
DOOR_STATE_OPEN,
|
|
DOOR_STATE_CLOSING,
|
|
DOOR_STATE_AJAR,
|
|
};
|
|
|
|
// dvs: FIXME: make these private
|
|
void DoorClose();
|
|
|
|
CBasePropDoor *GetMaster(void) { return m_hMaster; }
|
|
bool HasSlaves(void) { return (m_hDoorList.Count() > 0); }
|
|
|
|
inline void SetDoorState(DoorState_t eDoorState);
|
|
|
|
float m_flAutoReturnDelay; // How many seconds to wait before automatically
|
|
// closing, -1 never closes automatically.
|
|
CUtlVector<CHandle<CBasePropDoor> >
|
|
m_hDoorList; // List of doors linked to us
|
|
|
|
inline CBaseEntity *GetActivator();
|
|
|
|
private:
|
|
// Implement these in your leaf class.
|
|
// {
|
|
// Called when the door becomes fully open.
|
|
virtual void OnDoorOpened() {}
|
|
|
|
// Called when the door becomes fully closed.
|
|
virtual void OnDoorClosed() {}
|
|
|
|
// Called to tell the door to start opening.
|
|
virtual void BeginOpening(CBaseEntity * pOpenAwayFrom) = 0;
|
|
|
|
// Called to tell the door to start closing.
|
|
virtual void BeginClosing(void) = 0;
|
|
|
|
// Called when blocked to tell the door to stop moving.
|
|
virtual void DoorStop(void) = 0;
|
|
|
|
// Called when blocked to tell the door to continue moving.
|
|
virtual void DoorResume(void) = 0;
|
|
|
|
// Called to send the door instantly to its spawn positions.
|
|
virtual void DoorTeleportToSpawnPosition() = 0;
|
|
// }
|
|
|
|
private:
|
|
// Main entry points for the door base behaviors.
|
|
// Do not make the functions in this block virtual!!
|
|
// {
|
|
bool DoorActivate();
|
|
void DoorOpen(CBaseEntity * pOpenAwayFrom);
|
|
void OpenIfUnlocked(CBaseEntity * pActivator, CBaseEntity * pOpenAwayFrom);
|
|
|
|
void DoorOpenMoveDone();
|
|
void DoorCloseMoveDone();
|
|
void DoorAutoCloseThink();
|
|
|
|
void Lock();
|
|
void Unlock();
|
|
|
|
void Use(CBaseEntity * pActivator, CBaseEntity * pCaller, USE_TYPE useType,
|
|
float value);
|
|
void OnUse(CBaseEntity * pActivator, CBaseEntity * pCaller,
|
|
USE_TYPE useType, float value);
|
|
|
|
inline bool WillAutoReturn() { return m_flAutoReturnDelay != -1; }
|
|
|
|
void StartBlocked(CBaseEntity * pOther);
|
|
void OnStartBlocked(CBaseEntity * pOther);
|
|
void MasterStartBlocked(CBaseEntity * pOther);
|
|
|
|
void Blocked(CBaseEntity * pOther);
|
|
void EndBlocked(void);
|
|
void OnEndBlocked(void);
|
|
|
|
void UpdateAreaPortals(bool bOpen);
|
|
|
|
// Input handlers
|
|
void InputClose(inputdata_t & inputdata);
|
|
void InputLock(inputdata_t & inputdata);
|
|
void InputOpen(inputdata_t & inputdata);
|
|
void InputOpenAwayFrom(inputdata_t & inputdata);
|
|
void InputToggle(inputdata_t & inputdata);
|
|
void InputUnlock(inputdata_t & inputdata);
|
|
|
|
void SetDoorBlocker(CBaseEntity * pBlocker);
|
|
|
|
void SetMaster(CBasePropDoor * pMaster) { m_hMaster = pMaster; }
|
|
|
|
void CalcDoorSounds();
|
|
// }
|
|
|
|
int m_nHardwareType;
|
|
|
|
DoorState_t m_eDoorState; // Holds whether the door is open, closed,
|
|
// opening, or closing.
|
|
|
|
locksound_t
|
|
m_ls; // The sounds the door plays when being locked, unlocked, etc.
|
|
EHANDLE m_hActivator;
|
|
|
|
bool m_bLocked; // True if the door is locked.
|
|
EHANDLE m_hBlocker; // Entity blocking the door currently
|
|
bool m_bFirstBlocked; // Marker for being the first door (in a group) to be
|
|
// blocked (needed for motion control)
|
|
|
|
bool m_bForceClosed; // True if this door must close no matter what.
|
|
|
|
string_t m_SoundMoving;
|
|
string_t m_SoundOpen;
|
|
string_t m_SoundClose;
|
|
|
|
// dvs: FIXME: can we remove m_flSpeed from CBaseEntity?
|
|
// float m_flSpeed; // Rotation speed when opening or closing in degrees
|
|
// per second.
|
|
|
|
DECLARE_DATADESC();
|
|
|
|
string_t m_SlaveName;
|
|
|
|
CHandle<CBasePropDoor> m_hMaster;
|
|
|
|
static void RegisterPrivateActivities();
|
|
|
|
// Outputs
|
|
COutputEvent m_OnBlockedClosing; // Triggered when the door becomes blocked
|
|
// while closing.
|
|
COutputEvent m_OnBlockedOpening; // Triggered when the door becomes blocked
|
|
// while opening.
|
|
COutputEvent m_OnUnblockedClosing; // Triggered when the door becomes
|
|
// unblocked while closing.
|
|
COutputEvent m_OnUnblockedOpening; // Triggered when the door becomes
|
|
// unblocked while opening.
|
|
COutputEvent m_OnFullyClosed; // Triggered when the door reaches the fully
|
|
// closed position.
|
|
COutputEvent m_OnFullyOpen; // Triggered when the door reaches the fully
|
|
// open position.
|
|
COutputEvent m_OnClose; // Triggered when the door is told to close.
|
|
COutputEvent m_OnOpen; // Triggered when the door is told to open.
|
|
COutputEvent
|
|
m_OnLockedUse; // Triggered when the user tries to open a locked door.
|
|
};
|
|
|
|
void CBasePropDoor::SetDoorState(DoorState_t eDoorState) {
|
|
m_eDoorState = eDoorState;
|
|
}
|
|
|
|
bool CBasePropDoor::IsDoorOpen() { return m_eDoorState == DOOR_STATE_OPEN; }
|
|
|
|
bool CBasePropDoor::IsDoorAjar() { return (m_eDoorState == DOOR_STATE_AJAR); }
|
|
|
|
bool CBasePropDoor::IsDoorOpening() {
|
|
return m_eDoorState == DOOR_STATE_OPENING;
|
|
}
|
|
|
|
bool CBasePropDoor::IsDoorClosed() { return m_eDoorState == DOOR_STATE_CLOSED; }
|
|
|
|
bool CBasePropDoor::IsDoorClosing() {
|
|
return m_eDoorState == DOOR_STATE_CLOSING;
|
|
}
|
|
|
|
bool CBasePropDoor::IsDoorLocked() { return m_bLocked; }
|
|
|
|
CBaseEntity *CBasePropDoor::GetActivator() { return m_hActivator; }
|
|
|
|
bool CBasePropDoor::IsDoorBlocked() const { return (m_hBlocker != NULL); }
|
|
|
|
bool CBasePropDoor::IsNPCOpening(CAI_BaseNPC *pNPC) {
|
|
return (pNPC == (CAI_BaseNPC *)GetActivator());
|
|
}
|
|
|
|
inline bool CBasePropDoor::IsPlayerOpening() {
|
|
return (GetActivator() && GetActivator()->IsPlayer());
|
|
}
|
|
|
|
inline bool CBasePropDoor::IsOpener(CBaseEntity *pEnt) {
|
|
return (GetActivator() == pEnt);
|
|
}
|
|
|
|
#endif // BASEPROPDOOR_H
|