2019-08-31 19:18:15 -07:00
|
|
|
/*
|
2024-03-02 00:40:08 -08:00
|
|
|
* Copyright (c) 2016-2024 Vera Visions LLC.
|
2019-08-31 19:18:15 -07:00
|
|
|
*
|
|
|
|
* 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.
|
2022-07-07 09:10:14 -07:00
|
|
|
*/
|
2018-12-30 17:00:38 -08:00
|
|
|
|
2022-08-07 14:12:55 -07:00
|
|
|
void
|
|
|
|
NSTrigger::NSTrigger(void)
|
|
|
|
{
|
2022-08-31 15:18:06 -07:00
|
|
|
blocked = _BlockedHandler;
|
|
|
|
touch = _TouchHandler;
|
|
|
|
|
2022-08-07 14:12:55 -07:00
|
|
|
#ifdef SERVER
|
|
|
|
m_oldstrTarget = __NULL__;
|
2022-08-10 14:24:06 -07:00
|
|
|
m_strGlobalState = __NULL__;
|
2022-08-07 14:12:55 -07:00
|
|
|
m_strKillTarget = __NULL__;
|
|
|
|
m_strMessage = __NULL__;
|
|
|
|
m_strMaster = __NULL__;
|
2022-08-10 14:24:06 -07:00
|
|
|
m_iUseType = 0i;
|
2022-08-31 15:18:06 -07:00
|
|
|
team = 0;
|
2022-08-10 14:24:06 -07:00
|
|
|
m_iValue = 0i;
|
|
|
|
m_flDelay = 0.0f;
|
2023-11-17 18:54:46 -08:00
|
|
|
m_bStartDisabled = false;
|
|
|
|
m_bEnabled = true;
|
|
|
|
m_bIsModern = false;
|
2022-08-07 14:12:55 -07:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2021-10-19 16:18:36 -07:00
|
|
|
#ifdef SERVER
|
2024-03-02 00:40:08 -08:00
|
|
|
void
|
|
|
|
NSTrigger::Respawn(void)
|
|
|
|
{
|
|
|
|
super::Respawn();
|
|
|
|
SetTriggerTarget( m_oldstrTarget );
|
|
|
|
}
|
2023-09-27 12:57:25 -07:00
|
|
|
|
|
|
|
bool
|
|
|
|
NSTrigger::CanBeTriggeredBy(entity testEnt)
|
|
|
|
{
|
|
|
|
/* easy way out */
|
|
|
|
if (spawnflags & TOUCHFILTER_EVERYTHING)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
/* filters */
|
|
|
|
if (!(spawnflags & TOUCHFILTER_CLIENTS) && (testEnt.flags & FL_CLIENT))
|
|
|
|
return false;
|
|
|
|
if (!(spawnflags & TOUCHFILTER_NPCS) && (testEnt.flags & FL_MONSTER))
|
|
|
|
return false;
|
|
|
|
if (!(spawnflags & TOUCHFILTER_PUSHABLE) && (testEnt.classname == "func_pushable"))
|
|
|
|
return false;
|
|
|
|
if (!(spawnflags & TOUCHFILTER_PHYSICS) && (testEnt.isPhysics == true))
|
|
|
|
return false;
|
|
|
|
if (!(spawnflags & TOUCHFILTER_FRIENDLIES) && (testEnt.flags & FL_MONSTER) && (testEnt.m_iAlliance == 0))
|
|
|
|
return false;
|
|
|
|
if (!(spawnflags & TOUCHFILTER_CLIENTSINVEHICLES) && (testEnt.flags & FL_CLIENT) && (testEnt.flags & FL_INVEHICLE))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
|
|
|
if (!spawnflags & TOUCHFILTER_CLIENTSNOTINVEHICLES) {
|
|
|
|
return false;
|
|
|
|
if (!spawnflags &TRIGTELE_DEBRIS) && )
|
|
|
|
return false;
|
|
|
|
if (!spawnflags &TRIGTELE_NPCSINVEHICLES) && )
|
|
|
|
return false;
|
|
|
|
if (!spawnflags &TRIGTELE_NOBOTS) && )
|
|
|
|
return false;
|
|
|
|
*/
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2020-09-20 01:43:13 -07:00
|
|
|
/* legacy trigger architecture */
|
|
|
|
void
|
2022-12-14 16:51:16 -08:00
|
|
|
NSTrigger::Trigger(entity act, triggermode_t state)
|
2020-09-20 01:43:13 -07:00
|
|
|
{
|
2024-03-05 22:48:00 -08:00
|
|
|
EntWarning("%S triggered by %S with no consequence", targetname, act.classname);
|
2020-09-20 01:43:13 -07:00
|
|
|
}
|
2018-12-30 17:00:38 -08:00
|
|
|
|
2020-04-12 06:50:42 -07:00
|
|
|
void
|
2024-03-02 00:40:08 -08:00
|
|
|
NSTrigger::UseTargets(entity act, int state, float triggerDelay)
|
2018-12-30 17:00:38 -08:00
|
|
|
{
|
2020-09-21 09:10:31 -07:00
|
|
|
static void Entities_UseTargets_Think(void) {
|
2021-10-19 16:18:36 -07:00
|
|
|
NSTrigger::UseTargets(self.owner, self.health, 0.0f);
|
2020-09-21 09:10:31 -07:00
|
|
|
remove(self);
|
2018-12-30 17:00:38 -08:00
|
|
|
}
|
|
|
|
|
2024-03-02 00:40:08 -08:00
|
|
|
if (!m_strKillTarget && !target)
|
2023-09-27 12:57:25 -07:00
|
|
|
return;
|
|
|
|
|
2024-03-02 00:40:08 -08:00
|
|
|
if (triggerDelay > 0.0f) {
|
|
|
|
EntLog("Scheduling trigger of %S in %f seconds.", target, triggerDelay);
|
2021-10-19 16:18:36 -07:00
|
|
|
NSTrigger eTimer = spawn(NSTrigger);
|
2024-03-04 18:42:48 -08:00
|
|
|
eTimer.netname = sprintf("%s_%d_target_trigger", classname, num_for_edict(this));
|
2020-09-21 09:10:31 -07:00
|
|
|
eTimer.owner = act;
|
|
|
|
eTimer.think = Entities_UseTargets_Think;
|
|
|
|
eTimer.target = target;
|
2024-03-02 00:40:08 -08:00
|
|
|
eTimer.nextthink = time + triggerDelay;
|
2020-09-21 09:10:31 -07:00
|
|
|
eTimer.health = state; /* ugly */
|
2024-03-04 18:42:48 -08:00
|
|
|
|
|
|
|
if (m_strKillTarget) {
|
|
|
|
EntLog("Will kill %S before that happens.", m_strKillTarget);
|
|
|
|
}
|
|
|
|
eTimer.m_strKillTarget = m_strKillTarget;
|
|
|
|
eTimer.m_strMessage = m_strMessage;
|
2020-04-03 05:09:17 -07:00
|
|
|
} else {
|
2022-06-22 13:08:37 -07:00
|
|
|
if (m_strMessage) {
|
|
|
|
env_message_single(act, m_strMessage);
|
|
|
|
}
|
|
|
|
|
2024-03-05 08:19:56 -08:00
|
|
|
if (target && target != "" && target != targetname)
|
2020-09-21 09:10:31 -07:00
|
|
|
for (entity f = world; (f = find(f, ::targetname, target));) {
|
2021-10-19 16:18:36 -07:00
|
|
|
NSTrigger trigger = (NSTrigger)f;
|
2020-03-03 13:45:30 -08:00
|
|
|
|
2024-03-02 00:40:08 -08:00
|
|
|
EntLog("Triggering %s %S, activator %S (%d)", \
|
|
|
|
f.classname, trigger.targetname, \
|
|
|
|
act.classname, num_for_edict(act));
|
2020-09-21 09:10:31 -07:00
|
|
|
|
|
|
|
if (trigger.Trigger != __NULL__) {
|
|
|
|
trigger.Trigger(act, state);
|
|
|
|
}
|
2018-12-30 17:00:38 -08:00
|
|
|
}
|
|
|
|
|
2021-10-22 16:00:15 -07:00
|
|
|
if (m_strKillTarget && m_strKillTarget != "") {
|
2023-09-19 22:01:36 -07:00
|
|
|
NSEntity eKill = (NSEntity)find(world, ::targetname, m_strKillTarget);
|
2024-03-02 00:40:08 -08:00
|
|
|
EntLog("Killtargeting %S", m_strKillTarget);
|
|
|
|
|
2020-09-21 09:10:31 -07:00
|
|
|
if (eKill) {
|
2023-09-19 22:01:36 -07:00
|
|
|
eKill.Destroy();
|
2020-09-21 09:10:31 -07:00
|
|
|
}
|
|
|
|
}
|
2020-08-07 05:07:38 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-08-26 15:39:00 -07:00
|
|
|
void
|
|
|
|
NSTrigger::SetTriggerTarget(string name)
|
|
|
|
{
|
|
|
|
target = name;
|
|
|
|
}
|
|
|
|
|
2020-04-12 06:50:42 -07:00
|
|
|
int
|
2023-10-30 16:37:45 -07:00
|
|
|
NSTrigger::GetValue(entity queryingEntity)
|
2018-12-30 17:00:38 -08:00
|
|
|
{
|
2020-08-07 05:07:38 -07:00
|
|
|
return m_iValue;
|
2018-12-30 17:00:38 -08:00
|
|
|
}
|
|
|
|
|
2022-08-10 14:24:06 -07:00
|
|
|
globalstate_t
|
2022-01-10 23:48:14 -08:00
|
|
|
NSTrigger::GetGlobalValue(string strName)
|
|
|
|
{
|
|
|
|
for (int i = 0; i < (tokenize(cvar_string(CENVGLOBAL_CVAR))); i += 2) {
|
|
|
|
if (argv(i) == strName) {
|
2022-08-10 14:24:06 -07:00
|
|
|
return stof(argv(i+1));
|
2022-01-10 23:48:14 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2020-04-12 06:50:42 -07:00
|
|
|
int
|
2023-10-30 16:37:45 -07:00
|
|
|
NSTrigger::GetMaster(entity queryingEntity)
|
2019-09-09 13:05:32 -07:00
|
|
|
{
|
2021-10-19 16:18:36 -07:00
|
|
|
NSTrigger t;
|
2019-09-09 13:05:32 -07:00
|
|
|
|
|
|
|
/* default to success */
|
|
|
|
if (!m_strMaster) {
|
2022-05-11 12:49:04 -07:00
|
|
|
/*NSLog("^2%s::^3GetMaster^7: No master, return success",
|
2022-07-19 15:22:15 -07:00
|
|
|
classname));*/
|
2021-05-10 02:33:31 -07:00
|
|
|
return (1);
|
2019-09-09 13:05:32 -07:00
|
|
|
}
|
|
|
|
|
2022-01-10 23:48:14 -08:00
|
|
|
t = (NSTrigger)find(world, ::targetname, m_strMaster);
|
2019-09-09 13:05:32 -07:00
|
|
|
|
|
|
|
/* we couldn't find it, so let's not even bother going further */
|
|
|
|
if (!t) {
|
2024-03-02 00:40:08 -08:00
|
|
|
/*NSLog("^2%s::^3GetMaster^7: Invalid master (%s), return success",
|
|
|
|
classname, m_strMaster);*/
|
2021-05-10 02:33:31 -07:00
|
|
|
return (1);
|
2019-09-09 13:05:32 -07:00
|
|
|
}
|
|
|
|
|
2024-03-02 00:40:08 -08:00
|
|
|
/*
|
2023-10-30 16:37:45 -07:00
|
|
|
if (t.GetValue(queryingEntity) == 1)
|
2022-05-11 12:49:04 -07:00
|
|
|
NSLog("^2%s::^3GetMaster^7: %s learns %s ^2POSITIVE",
|
2022-12-21 17:09:35 -08:00
|
|
|
classname, targetname, m_strMaster);
|
2020-08-07 05:07:38 -07:00
|
|
|
else
|
2022-05-11 12:49:04 -07:00
|
|
|
NSLog("^2%s::^3GetMaster^7: %s learns %s ^1NEGATIVE",
|
2022-12-21 17:09:35 -08:00
|
|
|
classname, targetname, m_strMaster);
|
2024-03-02 00:40:08 -08:00
|
|
|
*/
|
|
|
|
|
2023-10-30 16:37:45 -07:00
|
|
|
return t.GetValue(queryingEntity);
|
2019-09-09 13:05:32 -07:00
|
|
|
}
|
|
|
|
|
2022-08-26 15:39:00 -07:00
|
|
|
string
|
|
|
|
NSTrigger::GetTriggerTarget(void)
|
|
|
|
{
|
|
|
|
return target;
|
|
|
|
}
|
|
|
|
|
2023-10-03 11:02:47 -07:00
|
|
|
entity
|
|
|
|
NSTrigger::GetTargetEntity(void)
|
|
|
|
{
|
|
|
|
if (HasTriggerTarget() == false)
|
|
|
|
return __NULL__;
|
|
|
|
|
|
|
|
return find(world, ::targetname, target);
|
|
|
|
}
|
|
|
|
|
2022-08-26 15:39:00 -07:00
|
|
|
bool
|
|
|
|
NSTrigger::HasTriggerTarget(void)
|
|
|
|
{
|
|
|
|
if not (target)
|
|
|
|
return false;
|
2023-09-27 12:57:25 -07:00
|
|
|
if (target == "")
|
|
|
|
return false;
|
2022-08-26 15:39:00 -07:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
NSTrigger::HasTargetname(void)
|
|
|
|
{
|
|
|
|
if not (targetname)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-10-22 11:51:51 -07:00
|
|
|
void
|
|
|
|
NSTrigger::Save(float handle)
|
|
|
|
{
|
|
|
|
super::Save(handle);
|
2022-08-10 14:24:06 -07:00
|
|
|
SaveString(handle, "m_oldstrTarget", m_oldstrTarget);
|
|
|
|
SaveString(handle, "m_strGlobalState", m_strGlobalState);
|
|
|
|
SaveString(handle, "m_strKillTarget", m_strKillTarget);
|
|
|
|
SaveString(handle, "m_strMessage", m_strMessage);
|
|
|
|
SaveString(handle, "m_strMaster", m_strMaster);
|
|
|
|
SaveInt(handle, "m_iUseType", m_iUseType);
|
2022-08-31 15:18:06 -07:00
|
|
|
SaveFloat(handle, "team", team);
|
2022-08-10 14:24:06 -07:00
|
|
|
SaveInt(handle, "m_iValue", m_iValue);
|
|
|
|
SaveFloat(handle, "m_flDelay", m_flDelay);
|
2023-09-28 18:38:16 -07:00
|
|
|
SaveString(handle, "m_strGlobalName", m_strGlobalName);
|
2023-11-17 18:54:46 -08:00
|
|
|
SaveBool(handle, "m_bStartDisabled", m_bStartDisabled);
|
|
|
|
SaveBool(handle, "m_bEnabled", m_bEnabled);
|
|
|
|
SaveBool(handle, "m_bIsModern", m_bIsModern);
|
2021-10-22 11:51:51 -07:00
|
|
|
}
|
|
|
|
void
|
|
|
|
NSTrigger::Restore(string strKey, string strValue)
|
|
|
|
{
|
|
|
|
switch (strKey) {
|
2022-08-10 14:24:06 -07:00
|
|
|
case "m_oldstrTarget":
|
|
|
|
m_oldstrTarget = ReadString(strValue);
|
2021-10-22 16:00:15 -07:00
|
|
|
break;
|
2022-08-10 14:24:06 -07:00
|
|
|
case "m_strGlobalState":
|
|
|
|
m_strGlobalState = ReadString(strValue);
|
|
|
|
break;
|
|
|
|
case "m_strKillTarget":
|
2021-10-22 16:00:15 -07:00
|
|
|
m_strKillTarget = ReadString(strValue);
|
2021-10-22 11:51:51 -07:00
|
|
|
break;
|
2022-08-10 14:24:06 -07:00
|
|
|
case "m_strMessage":
|
2021-10-22 16:00:15 -07:00
|
|
|
m_strMessage = ReadString(strValue);
|
2021-10-22 11:51:51 -07:00
|
|
|
break;
|
2022-08-10 14:24:06 -07:00
|
|
|
case "m_strMaster":
|
2021-10-22 16:00:15 -07:00
|
|
|
m_strMaster = ReadString(strValue);
|
2021-10-22 11:51:51 -07:00
|
|
|
break;
|
2022-08-10 14:24:06 -07:00
|
|
|
case "m_iUseType":
|
|
|
|
m_iUseType = ReadInt(strValue);
|
|
|
|
break;
|
2022-08-31 15:18:06 -07:00
|
|
|
case "team":
|
|
|
|
team = ReadFloat(strValue);
|
2021-10-22 11:51:51 -07:00
|
|
|
break;
|
2022-08-10 14:24:06 -07:00
|
|
|
case "m_iValue":
|
|
|
|
m_iValue = ReadInt(strValue);
|
|
|
|
break;
|
|
|
|
case "m_flDelay":
|
2021-10-22 16:00:15 -07:00
|
|
|
m_flDelay = ReadFloat(strValue);
|
2021-10-22 11:51:51 -07:00
|
|
|
break;
|
2023-09-28 18:38:16 -07:00
|
|
|
case "m_strGlobalName":
|
|
|
|
m_strGlobalName = ReadString(strValue);
|
|
|
|
break;
|
2023-11-17 18:54:46 -08:00
|
|
|
case "m_bStartDisabled":
|
|
|
|
m_bStartDisabled = ReadBool(strValue);
|
|
|
|
break;
|
|
|
|
case "m_bEnabled":
|
|
|
|
m_bEnabled = ReadBool(strValue);
|
|
|
|
break;
|
|
|
|
case "m_bIsModern":
|
|
|
|
m_bIsModern = ReadBool(strValue);
|
|
|
|
break;
|
2021-10-22 11:51:51 -07:00
|
|
|
default:
|
|
|
|
super::Restore(strKey, strValue);
|
|
|
|
}
|
|
|
|
}
|
2022-07-19 15:49:35 -07:00
|
|
|
|
2022-03-26 23:26:28 -07:00
|
|
|
void
|
|
|
|
NSTrigger::Input(entity eAct, string strInput, string strData)
|
|
|
|
{
|
|
|
|
switch (strInput) {
|
|
|
|
case "Trigger":
|
|
|
|
Trigger(eAct, TRIG_TOGGLE);
|
|
|
|
break;
|
2023-11-17 18:54:46 -08:00
|
|
|
case "Enable":
|
|
|
|
m_bEnabled = true;
|
|
|
|
break;
|
|
|
|
case "Disable":
|
|
|
|
m_bEnabled = false;
|
|
|
|
break;
|
|
|
|
case "Toggle":
|
|
|
|
m_bEnabled = (m_bEnabled) ? false : true;
|
|
|
|
break;
|
2022-03-26 23:26:28 -07:00
|
|
|
default:
|
|
|
|
super:: Input(eAct, strInput, strData);
|
|
|
|
}
|
|
|
|
}
|
2022-10-14 13:08:47 -07:00
|
|
|
|
|
|
|
void
|
|
|
|
NSTrigger::SetTeam(float new_team)
|
|
|
|
{
|
|
|
|
team = new_team;
|
2022-12-30 13:54:28 -08:00
|
|
|
|
|
|
|
/* update the InfoKey too if it's a client entity */
|
|
|
|
if (flags & FL_CLIENT) {
|
|
|
|
NSClient client = (NSClient)this;
|
|
|
|
client.SetInfoKey("*team", sprintf("%d", new_team));
|
|
|
|
}
|
2022-10-14 13:08:47 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
float
|
|
|
|
NSTrigger::GetTeam(void)
|
|
|
|
{
|
|
|
|
return (team);
|
|
|
|
}
|
2021-10-23 03:40:35 -07:00
|
|
|
#endif
|
2021-10-22 11:51:51 -07:00
|
|
|
|
2020-04-12 06:50:42 -07:00
|
|
|
void
|
2021-10-19 16:18:36 -07:00
|
|
|
NSTrigger::SpawnKey(string strKey, string strValue)
|
2020-09-08 16:56:46 -07:00
|
|
|
{
|
|
|
|
switch (strKey) {
|
2021-10-23 03:40:35 -07:00
|
|
|
#ifdef SERVER
|
2020-09-08 16:56:46 -07:00
|
|
|
case "killtarget":
|
2023-10-03 11:02:47 -07:00
|
|
|
m_strKillTarget = ReadString(strValue);
|
2020-09-08 16:56:46 -07:00
|
|
|
break;
|
|
|
|
case "message":
|
2023-10-03 11:02:47 -07:00
|
|
|
m_strMessage = ReadString(strValue);
|
2020-09-08 16:56:46 -07:00
|
|
|
break;
|
|
|
|
case "master":
|
2023-10-03 11:02:47 -07:00
|
|
|
m_strMaster = ReadString(strValue);
|
2020-09-08 16:56:46 -07:00
|
|
|
break;
|
|
|
|
case "team_no":
|
2023-10-03 11:02:47 -07:00
|
|
|
team_no = ReadFloat(strValue);
|
2020-09-08 16:56:46 -07:00
|
|
|
break;
|
2020-09-18 05:55:13 -07:00
|
|
|
case "delay":
|
2023-10-03 11:02:47 -07:00
|
|
|
m_flDelay = ReadFloat(strValue);
|
2020-09-18 05:55:13 -07:00
|
|
|
break;
|
2022-08-10 14:24:06 -07:00
|
|
|
case "globalstate":
|
2023-10-03 11:02:47 -07:00
|
|
|
m_strGlobalState = ReadString(strValue);
|
2022-08-10 14:24:06 -07:00
|
|
|
break;
|
2023-09-28 18:38:16 -07:00
|
|
|
case "globalname":
|
2023-10-03 11:02:47 -07:00
|
|
|
m_strGlobalName = ReadString(strValue);
|
2023-09-28 18:38:16 -07:00
|
|
|
break;
|
2023-11-17 18:54:46 -08:00
|
|
|
case "StartDisabled":
|
|
|
|
m_bStartDisabled = ReadBool(strValue);
|
|
|
|
m_bIsModern = true;
|
|
|
|
break;
|
2021-10-23 03:40:35 -07:00
|
|
|
#endif
|
2020-09-08 16:56:46 -07:00
|
|
|
default:
|
2023-09-28 18:38:16 -07:00
|
|
|
super::SpawnKey(strKey, strValue);
|
2020-09-08 16:56:46 -07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2022-08-31 15:18:06 -07:00
|
|
|
|
|
|
|
void
|
|
|
|
NSTrigger::Blocked(entity eBlocker)
|
|
|
|
{
|
|
|
|
/* To be handled by sub-classes */
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
NSTrigger::_BlockedHandler(void)
|
|
|
|
{
|
|
|
|
Blocked(other);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
NSTrigger::Touch(entity eToucher)
|
|
|
|
{
|
|
|
|
/* To be handled by sub-classes */
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
NSTrigger::StartTouch(entity eToucher)
|
|
|
|
{
|
|
|
|
/* To be handled by sub-classes */
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
NSTrigger::EndTouch(entity eToucher)
|
|
|
|
{
|
|
|
|
/* To be handled by sub-classes */
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
NSTrigger::_TouchHandler(void)
|
|
|
|
{
|
|
|
|
#ifdef SERVER
|
|
|
|
if (g_grMode.IsTeamplay())
|
2023-06-28 14:18:51 -07:00
|
|
|
if (team_no > 0i)
|
|
|
|
if (other.team != team_no) {
|
2022-08-31 15:18:06 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2023-09-27 12:57:25 -07:00
|
|
|
|
2022-08-31 15:18:06 -07:00
|
|
|
/* start touch in case we haven't */
|
|
|
|
if (m_beingTouched != true)
|
|
|
|
StartTouch(other);
|
|
|
|
|
|
|
|
Touch(other);
|
|
|
|
|
|
|
|
m_flTouchTime = GetTime();
|
|
|
|
m_beingTouched = true;
|
|
|
|
m_eTouchLast = other;
|
|
|
|
}
|