2019-08-31 19:18:15 -07:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2016-2019 Marco Hladik <marco@icculus.org>
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
2018-12-30 17:00:38 -08:00
|
|
|
|
2019-09-06 20:37:06 -07:00
|
|
|
/*QUAKED func_breakable (0 .5 .8) ? SF_TRIGGER SF_TOUCH SF_PRESSURE
|
|
|
|
"targetname" Name
|
|
|
|
"target" Target when triggered.
|
|
|
|
"killtarget" Target to kill when triggered.
|
|
|
|
"material" Material it's made of.
|
|
|
|
"delay" Delay in seconds of when it breaks under pressure.
|
|
|
|
"explodemagnitude" Strength of the explosion.
|
|
|
|
|
|
|
|
Brush volume that can break into lots of little pieces.
|
|
|
|
|
|
|
|
When SF_TOUCH is set, it'll break when an entity runs into it at high
|
|
|
|
velocities (damage is speed in units * 0.01).
|
|
|
|
|
|
|
|
When SF_PRESSURE is set, it'll collapse once someone is standing on top of it.
|
|
|
|
At that point the "delay" key will decide after how many seconds the object
|
|
|
|
breaks.
|
|
|
|
|
|
|
|
The strength of the explosion decides the radius (magnitude * 2.5) and the
|
|
|
|
maximum damage the explosion will do (you have to stand in the center for that).
|
2018-12-30 17:00:38 -08:00
|
|
|
*/
|
|
|
|
|
|
|
|
enumflags
|
|
|
|
{
|
|
|
|
SF_TRIGGER,
|
|
|
|
SF_TOUCH,
|
|
|
|
SF_PRESSURE
|
|
|
|
};
|
|
|
|
|
2019-01-04 17:02:12 -08:00
|
|
|
class func_breakable:CBaseTrigger
|
2018-12-30 17:00:38 -08:00
|
|
|
{
|
|
|
|
float m_iMaterial;
|
2019-01-02 17:26:39 -08:00
|
|
|
float m_flDelay;
|
2019-01-10 02:16:04 -08:00
|
|
|
float m_flExplodeMag;
|
2019-01-02 17:26:39 -08:00
|
|
|
/*entity m_pressAttacker;
|
|
|
|
int m_pressType;
|
|
|
|
int m_pressDamage;*/
|
|
|
|
|
2019-01-03 20:56:14 -08:00
|
|
|
void() func_breakable;
|
|
|
|
virtual void() Respawn;
|
2019-03-19 12:01:24 -07:00
|
|
|
virtual void() Explode;
|
2018-12-30 17:00:38 -08:00
|
|
|
virtual void() Trigger;
|
2019-01-02 17:26:39 -08:00
|
|
|
virtual void() PlayerTouch;
|
|
|
|
/*virtual void() PressureDeath;*/
|
2019-01-04 17:02:12 -08:00
|
|
|
virtual void(entity eAttacker, int iType, int iDamage) vPain;
|
|
|
|
virtual void(entity eAttacker, int iType, int iDamage) vDeath;
|
2018-12-30 17:00:38 -08:00
|
|
|
};
|
|
|
|
|
2019-01-04 17:02:12 -08:00
|
|
|
void func_breakable::vPain (entity attacker, int type, int damage)
|
2018-12-30 17:00:38 -08:00
|
|
|
{
|
2019-01-02 17:26:39 -08:00
|
|
|
if (spawnflags & SF_TRIGGER) {
|
|
|
|
return;
|
2018-12-30 17:00:38 -08:00
|
|
|
}
|
|
|
|
if (serverkeyfloat("*bspversion") != 30) {
|
|
|
|
return;
|
|
|
|
}
|
2019-01-04 17:02:12 -08:00
|
|
|
|
|
|
|
switch (m_iMaterial) {
|
2018-12-30 17:00:38 -08:00
|
|
|
case MATERIAL_GLASS:
|
|
|
|
case MATERIAL_COMPUTER:
|
|
|
|
case MATERIAL_GLASS_UNBREAKABLE:
|
2019-01-04 17:02:12 -08:00
|
|
|
sound(self, CHAN_VOICE, sprintf("debris/glass%d.wav", random(1, 4)), 1.0, ATTN_NORM);
|
2018-12-30 17:00:38 -08:00
|
|
|
break;
|
|
|
|
case MATERIAL_WOOD:
|
2019-01-04 17:02:12 -08:00
|
|
|
sound(self, CHAN_VOICE, sprintf("debris/wood%d.wav", random(1, 4)), 1.0, ATTN_NORM);
|
2018-12-30 17:00:38 -08:00
|
|
|
break;
|
|
|
|
case MATERIAL_METAL:
|
2019-01-04 17:02:12 -08:00
|
|
|
sound(self, CHAN_VOICE, sprintf("debris/metal%d.wav", random(1, 4)), 1.0, ATTN_NORM);
|
2018-12-30 17:00:38 -08:00
|
|
|
break;
|
|
|
|
case MATERIAL_FLESH:
|
2019-01-04 17:02:12 -08:00
|
|
|
float fRand = floor(random(1, 8));
|
2019-01-02 17:26:39 -08:00
|
|
|
/* There never was a flesh4.wav */
|
2019-01-04 17:02:12 -08:00
|
|
|
if (fRand == 4) {
|
2018-12-30 17:00:38 -08:00
|
|
|
fRand = 5;
|
|
|
|
}
|
2019-01-04 17:02:12 -08:00
|
|
|
sound(self, CHAN_VOICE, sprintf("debris/flesh%d.wav", fRand), 1.0, ATTN_NORM);
|
2018-12-30 17:00:38 -08:00
|
|
|
break;
|
|
|
|
case MATERIAL_CINDER:
|
|
|
|
case MATERIAL_ROCK:
|
2019-01-04 17:02:12 -08:00
|
|
|
sound(self, CHAN_VOICE, sprintf("debris/concrete%d.wav", random(1, 4)), 1.0, ATTN_NORM);
|
2018-12-30 17:00:38 -08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-19 12:01:24 -07:00
|
|
|
|
|
|
|
void func_breakable::Explode(void)
|
|
|
|
{
|
|
|
|
vector vWorldPos;
|
|
|
|
vWorldPos[0] = absmin[0] + ( 0.5 * ( absmax[0] - absmin[0] ) );
|
|
|
|
vWorldPos[1] = absmin[1] + ( 0.5 * ( absmax[1] - absmin[1] ) );
|
|
|
|
vWorldPos[2] = absmin[2] + ( 0.5 * ( absmax[2] - absmin[2] ) );
|
|
|
|
Effect_BreakModel(20, absmin, absmax, '0 0 0', m_iMaterial);
|
|
|
|
Effect_CreateExplosion(vWorldPos);
|
|
|
|
Damage_Radius(vWorldPos, this, m_flExplodeMag, m_flExplodeMag * 2.5f, TRUE);
|
|
|
|
CBaseTrigger::UseTargets();
|
|
|
|
CBaseEntity::Hide();
|
|
|
|
}
|
|
|
|
|
2019-01-04 17:02:12 -08:00
|
|
|
void func_breakable::vDeath (entity attacker, int type, int damage)
|
2018-12-30 17:00:38 -08:00
|
|
|
{
|
2019-01-02 17:26:39 -08:00
|
|
|
if (m_iMaterial == MATERIAL_GLASS_UNBREAKABLE) {
|
|
|
|
return;
|
|
|
|
}
|
2018-12-30 17:00:38 -08:00
|
|
|
health = 0;
|
2019-03-11 17:22:50 -07:00
|
|
|
|
|
|
|
print(sprintf("BREAK: %v [x] %v [=] %d\n", mins, maxs, vlen(mins - maxs)));
|
2019-01-10 02:16:04 -08:00
|
|
|
|
2019-03-19 12:01:24 -07:00
|
|
|
/* This may seem totally absurd. That's because it is. It's very
|
|
|
|
* unreliable but exploding breakables in close proximity it WILL cause
|
|
|
|
* an OVERFLOW because we'll be busy running through thousands
|
|
|
|
* of entities in total when one breakable damages another in a frame.
|
|
|
|
* The only way around this is to set a hard-coded limit of loops per
|
|
|
|
* frame and that would break functionality. */
|
2019-01-10 02:16:04 -08:00
|
|
|
if (m_flExplodeMag) {
|
2019-03-19 12:01:24 -07:00
|
|
|
think = Explode;
|
|
|
|
nextthink = time + random(0.0,0.5);
|
|
|
|
} else {
|
|
|
|
Effect_BreakModel(20, absmin, absmax, '0 0 0', m_iMaterial);
|
|
|
|
CBaseTrigger::UseTargets();
|
|
|
|
CBaseEntity::Hide();
|
2019-01-10 02:16:04 -08:00
|
|
|
}
|
2018-12-30 17:00:38 -08:00
|
|
|
}
|
|
|
|
|
2019-01-04 17:02:12 -08:00
|
|
|
void func_breakable::Trigger(void)
|
2018-12-30 17:00:38 -08:00
|
|
|
{
|
2019-01-04 17:02:12 -08:00
|
|
|
func_breakable::vDeath(world, 0, 0);
|
2018-12-30 17:00:38 -08:00
|
|
|
}
|
|
|
|
|
2019-01-04 17:02:12 -08:00
|
|
|
/*void func_breakable::PressureDeath(void)
|
2019-01-02 17:26:39 -08:00
|
|
|
{
|
|
|
|
func_breakable::vDeath(m_pressAttacker, m_pressType, m_pressDamage);
|
|
|
|
}*/
|
|
|
|
|
2019-01-04 17:02:12 -08:00
|
|
|
void func_breakable::PlayerTouch(void)
|
2018-12-30 17:00:38 -08:00
|
|
|
{
|
2019-01-04 17:02:12 -08:00
|
|
|
if (other.classname == classname) {
|
2018-12-30 17:00:38 -08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-01-02 17:26:39 -08:00
|
|
|
if (spawnflags & SF_TOUCH) {
|
|
|
|
int fDamage = (float)(vlen(other.velocity) * 0.01f);
|
|
|
|
|
|
|
|
if (fDamage >= health) {
|
|
|
|
touch = __NULL__;
|
2019-09-16 17:29:00 -07:00
|
|
|
Damage_Apply(this, other, fDamage, absmin, FALSE, 0);
|
2019-01-02 17:26:39 -08:00
|
|
|
|
|
|
|
if ((m_iMaterial == MATERIAL_GLASS) || (m_iMaterial == MATERIAL_COMPUTER)) {
|
2019-09-16 17:29:00 -07:00
|
|
|
Damage_Apply(other, this, fDamage / 4, other.origin, FALSE, 0);
|
2019-01-02 17:26:39 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-13 14:03:57 -07:00
|
|
|
if ((spawnflags & SF_PRESSURE) && (other.absmin[2] >= maxs[2] - 2)) {
|
2019-01-03 20:56:14 -08:00
|
|
|
touch = __NULL__;
|
2019-01-02 17:26:39 -08:00
|
|
|
think = Trigger;
|
|
|
|
|
|
|
|
if (m_flDelay == 0) {
|
|
|
|
m_flDelay = 0.1f;
|
2018-12-30 17:00:38 -08:00
|
|
|
}
|
2019-01-02 17:26:39 -08:00
|
|
|
|
|
|
|
nextthink = time + m_flDelay;
|
2018-12-30 17:00:38 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-02 17:26:39 -08:00
|
|
|
|
2019-01-04 17:02:12 -08:00
|
|
|
void func_breakable::Respawn(void)
|
2019-01-02 17:26:39 -08:00
|
|
|
{
|
2019-01-04 17:02:12 -08:00
|
|
|
precache_model(m_oldModel);
|
|
|
|
angles = [0,0,0];
|
|
|
|
movetype = MOVETYPE_NONE;
|
|
|
|
solid = SOLID_BSP;
|
2019-01-03 20:56:14 -08:00
|
|
|
setmodel(this, m_oldModel);
|
2019-01-04 17:02:12 -08:00
|
|
|
setorigin(this, m_oldOrigin);
|
2019-01-02 17:26:39 -08:00
|
|
|
touch = PlayerTouch;
|
2019-01-03 20:56:14 -08:00
|
|
|
think = __NULL__;
|
|
|
|
|
2019-01-04 17:02:12 -08:00
|
|
|
if (spawnflags & SF_TRIGGER) {
|
2019-01-02 17:26:39 -08:00
|
|
|
takedamage = DAMAGE_NO;
|
|
|
|
} else {
|
|
|
|
takedamage = DAMAGE_YES;
|
|
|
|
}
|
|
|
|
|
|
|
|
health = m_oldHealth;
|
|
|
|
|
2019-01-04 17:02:12 -08:00
|
|
|
if (!health) {
|
2019-01-02 17:26:39 -08:00
|
|
|
health = 15;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-04 17:02:12 -08:00
|
|
|
void func_breakable::func_breakable(void)
|
2018-12-30 17:00:38 -08:00
|
|
|
{
|
|
|
|
CBaseEntity::CBaseEntity();
|
2019-01-02 17:26:39 -08:00
|
|
|
func_breakable::Respawn();
|
2018-12-30 17:00:38 -08:00
|
|
|
|
2019-01-04 17:02:12 -08:00
|
|
|
for (int i = 1; i < (tokenize(__fullspawndata) - 1); i += 2) {
|
|
|
|
switch (argv(i)) {
|
2018-12-30 17:00:38 -08:00
|
|
|
case "material":
|
2019-01-04 17:02:12 -08:00
|
|
|
m_iMaterial = stof(argv(i + 1));
|
2019-01-02 17:26:39 -08:00
|
|
|
break;
|
|
|
|
case "delay":
|
2019-01-04 17:02:12 -08:00
|
|
|
m_flDelay = stof(argv(i + 1));
|
2018-12-30 17:00:38 -08:00
|
|
|
break;
|
2019-01-10 02:16:04 -08:00
|
|
|
case "explodemagnitude":
|
|
|
|
m_flExplodeMag = stof(argv(i+1));
|
|
|
|
break;
|
2018-12-30 17:00:38 -08:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|