535 lines
12 KiB
Plaintext
535 lines
12 KiB
Plaintext
/*
|
|
* 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.
|
|
*/
|
|
|
|
/*QUAKED func_button (0 .5 .8) ? SF_BTT_NOMOVE x x x x SF_BTT_TOGGLE SF_BTT_SPARKS x SF_BTT_TOUCH_ONLY
|
|
A brush entity which can be used either by touching, interaction (via a games'
|
|
use-key/button or other targetting methods.
|
|
It will then travel, similar to a door to a specified direction.
|
|
Once it's fully pushed in, it'll trigger its targets, then return back to its
|
|
original position.
|
|
|
|
-------- KEYS --------
|
|
"targetname" : Name
|
|
"target" : Target when triggered.
|
|
"killtarget" : Target to kill when triggered.
|
|
"speed" : Movement speed of the door in game-units per second.
|
|
"lip" : How many units remain visible when fully pushed in.
|
|
"snd_pressed" : The sound shader name to play when pressed down.
|
|
"snd_unpressed" : The sound shader name to play when the button becomes raised.
|
|
"wait" : Time to wait in seconds before the button becomes raised.
|
|
"delay" : Delay until the Target gets triggered.
|
|
"sounds" : Obsolete legacy key for HL/Q1 style buttons to decide which sounds to play.
|
|
"health" : Amount of damage this button takes before it triggers. Will reset.
|
|
|
|
-------- OUTPUTS --------
|
|
"OnDamaged" : Fired when the button is damaged.
|
|
"OnPressed" : Fired when the button is pressed.
|
|
"OnUseLocked" : Fired when the button is used while locked.
|
|
"OnIn" : Fired when the button reaches the in/pressed position.
|
|
"OnOut" : Fired when the button reaches the out/released position.
|
|
|
|
-------- SPAWNFLAGS --------
|
|
SF_BTT_NOMOVE : Don't move when it's activated.
|
|
SF_BTT_TOGGLE : Don't move back to the raised state automatically.
|
|
SF_BTT_SPARKS : Spawn decorative sparks when used.
|
|
SF_BTT_TOUCH_ONLY : Disable 'use' key/button. Only collision will activate it.
|
|
|
|
-------- TRIVIA --------
|
|
This entity was introduced in Quake (1996).
|
|
*/
|
|
|
|
enumflags
|
|
{
|
|
SF_BTT_NOMOVE,
|
|
SF_BTT_RESERVED1,
|
|
SF_BTT_RESERVED2,
|
|
SF_BTT_RESERVED3,
|
|
SF_BTT_RESERVED4,
|
|
SF_BTT_TOGGLE,
|
|
SF_BTT_SPARKS,
|
|
SF_BTT_RESERVED5,
|
|
SF_BTT_TOUCH_ONLY
|
|
};
|
|
|
|
enum
|
|
{
|
|
STATE_RAISED,
|
|
STATE_LOWERED,
|
|
STATE_UP,
|
|
STATE_DOWN
|
|
};
|
|
|
|
enum
|
|
{
|
|
FRAME_OFF,
|
|
FRAME_ON
|
|
};
|
|
|
|
class
|
|
func_button:NSSurfacePropEntity
|
|
{
|
|
int m_iState;
|
|
float m_flSpeed;
|
|
float m_flLip;
|
|
float m_flNextTrigger;
|
|
float m_flWait;
|
|
float m_flDelay;
|
|
vector m_vecPos1;
|
|
vector m_vecPos2;
|
|
vector m_vecDest;
|
|
vector m_vecMoveDir;
|
|
string m_strSndPressed;
|
|
string m_strSndUnpressed;
|
|
|
|
bool m_bCanTouch;
|
|
|
|
/* input/output */
|
|
string m_strOnPressed;
|
|
string m_strOnDamaged;
|
|
string m_strOnUseLocked;
|
|
string m_strOnIn;
|
|
string m_strOnOut;
|
|
|
|
public:
|
|
void func_button(void);
|
|
|
|
virtual void Save(float);
|
|
virtual void Restore(string,string);
|
|
virtual void SpawnKey(string,string);
|
|
virtual void Spawned(void);
|
|
virtual void Respawn(void);
|
|
virtual void Arrived(void);
|
|
virtual void Returned(void);
|
|
virtual void MoveBack(void);
|
|
virtual void MoveAway(void);
|
|
virtual void Touch(entity);
|
|
virtual void Blocked(entity);
|
|
virtual void Trigger(entity,int);
|
|
virtual void DeathTrigger(void);
|
|
virtual void PlayerUse(void);
|
|
virtual void SetMovementDirection(void);
|
|
virtual void MoveToDestination(vector, void(void));
|
|
};
|
|
|
|
void
|
|
func_button::func_button(void)
|
|
{
|
|
m_iState = 0i;
|
|
m_flSpeed = 0.0f;
|
|
m_flLip = 0.0f;
|
|
m_flNextTrigger = 0.0f;
|
|
m_flWait = 4.0f;
|
|
m_flDelay = 0.0f;
|
|
m_vecPos1 = [0.0f, 0.0f, 0.0f];
|
|
m_vecPos2 = [0.0f, 0.0f, 0.0f];
|
|
m_vecDest = [0.0f, 0.0f, 0.0f];
|
|
m_vecMoveDir = [0.0f, 0.0f, 0.0f];
|
|
m_strSndPressed = __NULL__;
|
|
m_strSndUnpressed = __NULL__;
|
|
m_bCanTouch = false;
|
|
m_strOnPressed = __NULL__;
|
|
m_strOnDamaged = __NULL__;
|
|
m_strOnUseLocked = __NULL__;
|
|
m_strOnIn = __NULL__;
|
|
m_strOnOut = __NULL__;
|
|
}
|
|
|
|
void
|
|
func_button::Save(float handle)
|
|
{
|
|
super::Save(handle);
|
|
SaveInt(handle, "m_iState", m_iState);
|
|
SaveFloat(handle, "m_flSpeed", m_flSpeed);
|
|
SaveFloat(handle, "m_flLip", m_flLip);
|
|
SaveFloat(handle, "m_flNextTrigger", m_flNextTrigger);
|
|
SaveFloat(handle, "m_flWait", m_flWait);
|
|
SaveFloat(handle, "m_flDelay", m_flDelay);
|
|
SaveVector(handle, "m_vecPos1", m_vecPos1);
|
|
SaveVector(handle, "m_vecPos2", m_vecPos2);
|
|
SaveVector(handle, "m_vecDest", m_vecDest);
|
|
SaveVector(handle, "m_vecMoveDir", m_vecMoveDir);
|
|
SaveString(handle, "m_strSndPressed", m_strSndPressed);
|
|
SaveString(handle, "m_strSndUnpressed", m_strSndUnpressed);
|
|
SaveString(handle, "m_strOnPressed", m_strOnPressed);
|
|
SaveString(handle, "m_strOnDamaged", m_strOnDamaged);
|
|
SaveString(handle, "m_strOnUseLocked", m_strOnUseLocked);
|
|
SaveString(handle, "m_strOnIn", m_strOnIn);
|
|
SaveString(handle, "m_strOnOut", m_strOnOut);
|
|
SaveBool(handle, "m_bCanTouch", m_bCanTouch);
|
|
}
|
|
|
|
void
|
|
func_button::Restore(string strKey, string strValue)
|
|
{
|
|
switch (strKey) {
|
|
case "m_iState":
|
|
m_iState = ReadInt(strValue);
|
|
break;
|
|
case "m_flSpeed":
|
|
m_flSpeed = ReadFloat(strValue);
|
|
break;
|
|
case "m_flLip":
|
|
m_flLip = ReadFloat(strValue);
|
|
break;
|
|
case "m_flNextTrigger":
|
|
m_flNextTrigger = ReadFloat(strValue);
|
|
break;
|
|
case "m_flWait":
|
|
m_flWait = ReadFloat(strValue);
|
|
break;
|
|
case "m_flDelay":
|
|
m_flDelay = ReadFloat(strValue);
|
|
break;
|
|
case "m_vecPos1":
|
|
m_vecPos1 = ReadVector(strValue);
|
|
break;
|
|
case "m_vecPos2":
|
|
m_vecPos2 = ReadVector(strValue);
|
|
break;
|
|
case "m_vecDest":
|
|
m_vecDest = ReadVector(strValue);
|
|
break;
|
|
case "m_vecMoveDir":
|
|
m_vecMoveDir = ReadVector(strValue);
|
|
break;
|
|
case "m_strSndPressed":
|
|
m_strSndPressed = ReadString(strValue);
|
|
break;
|
|
case "m_strSndUnpressed":
|
|
m_strSndUnpressed = ReadString(strValue);
|
|
break;
|
|
case "m_strOnPressed":
|
|
m_strOnPressed = ReadString(strValue);
|
|
break;
|
|
case "m_strOnDamaged":
|
|
m_strOnDamaged = ReadString(strValue);
|
|
break;
|
|
case "m_strOnUseLocked":
|
|
m_strOnUseLocked = ReadString(strValue);
|
|
break;
|
|
case "m_strOnIn":
|
|
m_strOnIn = ReadString(strValue);
|
|
break;
|
|
case "m_strOnOut":
|
|
m_strOnOut = ReadString(strValue);
|
|
break;
|
|
case "m_bCanTouch":
|
|
m_bCanTouch = ReadBool(strValue);
|
|
break;
|
|
default:
|
|
super::Restore(strKey, strValue);
|
|
}
|
|
}
|
|
|
|
void
|
|
func_button::SpawnKey(string strKey, string strValue)
|
|
{
|
|
switch (strKey) {
|
|
case "message":
|
|
message = strValue;
|
|
break;
|
|
case "speed":
|
|
m_flSpeed = stof(strValue);
|
|
break;
|
|
case "lip":
|
|
m_flLip = stof(strValue);
|
|
break;
|
|
case "snd_pressed":
|
|
m_strSndPressed = strValue;
|
|
break;
|
|
case "snd_unpressed":
|
|
m_strSndUnpressed = strValue;
|
|
break;
|
|
case "wait":
|
|
m_flWait = stof(strValue);
|
|
break;
|
|
/* input/output */
|
|
case "OnPressed":
|
|
m_strOnPressed = PrepareOutput(m_strOnPressed, strValue);
|
|
break;
|
|
case "OnDamaged":
|
|
m_strOnDamaged = PrepareOutput(m_strOnDamaged, strValue);
|
|
break;
|
|
case "OnUseLocked":
|
|
m_strOnUseLocked = PrepareOutput(m_strOnUseLocked, strValue);
|
|
break;
|
|
case "OnIn":
|
|
m_strOnIn = PrepareOutput(m_strOnIn, strValue);
|
|
break;
|
|
case "OnOut":
|
|
m_strOnOut = PrepareOutput(m_strOnOut, strValue);
|
|
break;
|
|
/* compatibility */
|
|
case "sounds":
|
|
m_strSndPressed = sprintf("func_button.hlsfx_%i", stoi(strValue) + 1i);
|
|
break;
|
|
default:
|
|
super::SpawnKey(strKey, strValue);
|
|
}
|
|
}
|
|
|
|
void
|
|
func_button::Spawned(void)
|
|
{
|
|
super::Spawned();
|
|
|
|
/* sounds */
|
|
Sound_Precache(m_strSndPressed);
|
|
Sound_Precache(m_strSndUnpressed);
|
|
|
|
/* input/output */
|
|
if (m_strOnPressed)
|
|
m_strOnPressed = CreateOutput(m_strOnPressed);
|
|
if (m_strOnDamaged)
|
|
m_strOnDamaged = CreateOutput(m_strOnDamaged);
|
|
if (m_strOnUseLocked)
|
|
m_strOnUseLocked = CreateOutput(m_strOnUseLocked);
|
|
if (m_strOnIn)
|
|
m_strOnIn = CreateOutput(m_strOnIn);
|
|
if (m_strOnOut)
|
|
m_strOnOut = CreateOutput(m_strOnOut);
|
|
}
|
|
|
|
void
|
|
func_button::Respawn(void)
|
|
{
|
|
RestoreAngles();
|
|
SetMovementDirection();
|
|
ClearAngles();
|
|
|
|
SetSolid(SOLID_BSP);
|
|
SetMovetype(MOVETYPE_PUSH);
|
|
SetOrigin(GetSpawnOrigin());
|
|
SetModel(GetSpawnModel());
|
|
|
|
ClearVelocity();
|
|
ReleaseThink();
|
|
SetHealth(GetSpawnHealth());
|
|
|
|
if (health > 0) {
|
|
takedamage = DAMAGE_YES;
|
|
Death = DeathTrigger;
|
|
}
|
|
|
|
if (!m_flSpeed) {
|
|
m_flSpeed = 100;
|
|
}
|
|
|
|
m_vecPos1 = GetSpawnOrigin();
|
|
|
|
if (HasSpawnFlags(SF_BTT_NOMOVE)) {
|
|
m_vecPos2 = m_vecPos1;
|
|
} else {
|
|
m_vecPos2 = (m_vecPos1 + m_vecMoveDir * (fabs(m_vecMoveDir * size) - m_flLip));
|
|
}
|
|
|
|
m_iValue = 0;
|
|
m_iState = STATE_LOWERED;
|
|
}
|
|
|
|
void
|
|
func_button::Arrived(void)
|
|
{
|
|
SetOrigin(m_vecDest);
|
|
ClearVelocity();
|
|
ReleaseThink();
|
|
m_bCanTouch = true;
|
|
|
|
UseOutput(this, m_strOnIn);
|
|
m_iState = STATE_RAISED;
|
|
|
|
if (HasSpawnFlags(SF_BTT_TOGGLE) == true) {
|
|
return;
|
|
}
|
|
|
|
if (m_flWait != -1) {
|
|
ScheduleThink(MoveBack, m_flWait);
|
|
}
|
|
}
|
|
|
|
void
|
|
func_button::Returned(void)
|
|
{
|
|
UseOutput(this, m_strOnOut);
|
|
SetOrigin(m_vecDest);
|
|
ClearVelocity();
|
|
ReleaseThink();
|
|
SetFrame(FRAME_OFF);
|
|
m_bCanTouch = true;
|
|
m_iState = STATE_LOWERED;
|
|
}
|
|
|
|
void
|
|
func_button::MoveBack(void)
|
|
{
|
|
m_bCanTouch = false;
|
|
m_iState = STATE_DOWN;
|
|
m_iValue = 0;
|
|
|
|
if (m_strSndUnpressed) {
|
|
Sound_Play(this, CHAN_VOICE, m_strSndUnpressed);
|
|
}
|
|
|
|
if (m_vecPos2 != m_vecPos1) {
|
|
MoveToDestination (m_vecPos1, Returned);
|
|
} else {
|
|
Returned();
|
|
}
|
|
}
|
|
|
|
void
|
|
func_button::MoveAway(void)
|
|
{
|
|
if (m_iState == STATE_UP) {
|
|
return;
|
|
}
|
|
|
|
m_bCanTouch = false;
|
|
m_iState = STATE_UP;
|
|
|
|
if (m_vecPos2 != m_vecPos1) {
|
|
MoveToDestination(m_vecPos2, Arrived);
|
|
} else {
|
|
Arrived();
|
|
}
|
|
|
|
m_iValue = 1;
|
|
SetFrame(FRAME_ON);
|
|
}
|
|
|
|
/* TODO: Handle state */
|
|
void
|
|
func_button::Trigger(entity act, int state)
|
|
{
|
|
if (GetMaster() == FALSE)
|
|
return;
|
|
|
|
UseOutput(act, m_strOnUseLocked);
|
|
|
|
if (m_flNextTrigger > time) {
|
|
return;
|
|
}
|
|
|
|
m_flNextTrigger = time + m_flWait;
|
|
|
|
if ((m_iState == STATE_UP) || (m_iState == STATE_RAISED)){
|
|
if (m_flWait != -1) {
|
|
MoveBack();
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (m_strSndPressed)
|
|
Sound_Play(this, CHAN_VOICE, m_strSndPressed);
|
|
|
|
MoveAway();
|
|
|
|
UseOutput(act, m_strOnPressed);
|
|
UseTargets(act, TRIG_TOGGLE, m_flDelay);
|
|
|
|
if (message)
|
|
env_message_single(act, message);
|
|
|
|
SetHealth(GetSpawnHealth());
|
|
}
|
|
|
|
void
|
|
func_button::DeathTrigger(void)
|
|
{
|
|
Trigger(g_dmg_eAttacker, TRIG_TOGGLE);
|
|
}
|
|
|
|
void
|
|
func_button::Touch(entity eToucher)
|
|
{
|
|
if (HasSpawnFlags(SF_BTT_TOUCH_ONLY) == false) {
|
|
return;
|
|
}
|
|
|
|
if (m_bCanTouch == false)
|
|
return;
|
|
|
|
if (eToucher.movetype == MOVETYPE_WALK) {
|
|
Trigger(eToucher, TRIG_TOGGLE);
|
|
}
|
|
}
|
|
|
|
void
|
|
func_button::PlayerUse(void)
|
|
{
|
|
if (HasSpawnFlags(SF_BTT_TOUCH_ONLY)) {
|
|
return;
|
|
}
|
|
Trigger(eActivator, TRIG_TOGGLE);
|
|
}
|
|
|
|
void
|
|
func_button::Blocked(entity eBlocker)
|
|
{
|
|
if (m_flWait >= 0) {
|
|
if (m_iState == STATE_DOWN) {
|
|
MoveAway();
|
|
} else {
|
|
MoveBack();
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
func_button::SetMovementDirection(void)
|
|
{
|
|
if (GetSpawnAngles() == [0,-1,0]) {
|
|
m_vecMoveDir = [0,0,1];
|
|
} else if (GetSpawnAngles() == [0,-2,0]) {
|
|
m_vecMoveDir = [0,0,-1];
|
|
} else {
|
|
makevectors(GetSpawnAngles());
|
|
m_vecMoveDir = v_forward;
|
|
}
|
|
}
|
|
|
|
void
|
|
func_button::MoveToDestination(vector vecDest, void(void) func)
|
|
{
|
|
vector vecDifference;
|
|
float flTravel, fTravelTime;
|
|
|
|
if (!m_flSpeed) {
|
|
objerror("No speed defined for moving entity! Will not divide by zero.");
|
|
}
|
|
|
|
m_vecDest = vecDest;
|
|
|
|
if (vecDest == origin) {
|
|
ClearVelocity();
|
|
ScheduleThink(func, 0.0f);
|
|
return;
|
|
}
|
|
|
|
vecDifference = (vecDest - origin);
|
|
flTravel = vlen(vecDifference);
|
|
fTravelTime = (flTravel / m_flSpeed);
|
|
|
|
if (fTravelTime < 0.1) {
|
|
ClearVelocity();
|
|
ScheduleThink(func, 0.0f);
|
|
return;
|
|
}
|
|
|
|
ScheduleThink(func, fTravelTime);
|
|
SetVelocity(vecDifference * (1 / fTravelTime));
|
|
}
|