door.qc File Reference

#include "door.qh"
#include "door_rotating.qh"

Include dependency graph for door.qc:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	door_blocked (entity this, entity blocker)
bool	door_check_keys (entity door, entity player)
void	door_damage (entity this, entity inflictor, entity attacker, float damage, int deathtype,.entity weaponentity, vector hitloc, vector force)
void	door_generic_plat_blocked (entity this, entity blocker)
void	door_go_down (entity this)
void	door_go_up (entity this, entity actor, entity trigger)
void	door_hit_bottom (entity this)
void	door_hit_top (entity this)
void	door_init_keys (entity this)
void	door_init_shared (entity this)
void	door_init_startopen (entity this)
void	door_link ()
void	door_reset (entity this)
float	door_send (entity this, entity to, float sf)
void	door_spawnfield (entity this, vector fmins, vector fmaxs)
void	door_touch (entity this, entity toucher)
void	door_trigger_touch (entity this, entity toucher)
void	door_use (entity this, entity actor, entity trigger)
void	LinkDoors (entity this)
bool	LinkDoors_isconnected (entity e1, entity e2, entity pass)
entity	LinkDoors_nextent (entity cur, entity near, entity pass)
	spawnfunc (func_door)

Variables
float	door_finished

Function Documentation

door_blocked()

void door_blocked	(	entity	this,
		entity	blocker )

Definition at line 28 of file door.qc.

{
    bool reverse = false;
    if((this.spawnflags & DOOR_CRUSH)
        && !Q3COMPAT_COMMON
#ifdef SVQC
        && (blocker.takedamage != DAMAGE_NO)
#elif defined(CSQC)
        && !IS_DEAD(blocker)
#endif
    )
    { // KIll Kill Kill!!
#ifdef SVQC
        Damage (blocker, this, this, 10000, DEATH_HURTTRIGGER.m_id, DMG_NOWEP, blocker.origin, '0 0 0');
#endif
    }
    else
    {
#ifdef SVQC
        if (this.dmg && blocker.takedamage != DAMAGE_NO)    // Shall we bite?
            Damage (blocker, this, this, this.dmg, DEATH_HURTTRIGGER.m_id, DMG_NOWEP, blocker.origin, '0 0 0');
#endif
 
        // don't change direction for dead or dying stuff
        if (!IS_DEAD(blocker)
#ifdef SVQC
            && blocker.takedamage != DAMAGE_NO
#endif
            && this.wait >= 0
            && !(Q3COMPAT_COMMON && (this.spawnflags & Q3_DOOR_CRUSHER))
        )
        {
            if (this.state == STATE_DOWN)
            {
                if (this.classname == "door")
                    door_go_up(this, NULL, NULL);
                else
                    door_rotating_go_up(this, blocker);
            }
            else
            {
                if (this.classname == "door")
                    door_go_down(this);
                else
                    door_rotating_go_down(this);
            }
            reverse = true;
        }
#ifdef SVQC
        else
        {
            //gib dying stuff just to make sure
            if (this.dmg && blocker.takedamage != DAMAGE_NO && IS_DEAD(blocker))    // Shall we bite?
                Damage (blocker, this, this, 10000, DEATH_HURTTRIGGER.m_id, DMG_NOWEP, blocker.origin, '0 0 0');
        }
#endif
    }
    // if we didn't change direction and are using a non-linear movement controller, we must pause it
    if (!reverse && this.classname == "door" && this.move_controller)
        SUB_CalcMovePause(this);
}

References classname, Damage(), DAMAGE_NO, dmg, DMG_NOWEP, DOOR_CRUSH, door_go_down(), door_go_up(), door_rotating_go_down(), door_rotating_go_up(), entity(), IS_DEAD, move_controller, NULL, Q3_DOOR_CRUSHER, Q3COMPAT_COMMON, spawnflags, state, STATE_DOWN, and SUB_CalcMovePause().

Referenced by spawnfunc(), and spawnfunc().

door_check_keys()

bool door_check_keys	(	entity	door,
		entity	player )

Definition at line 159 of file door.qc.

{
    if(door.owner)
        door = door.owner;
 
    // no key needed
    if(!door.itemkeys)
        return true;
 
    // this door require a key
    // only a player can have a key
    if(!IS_PLAYER(player))
        return false;
 
    entity store = player;
#ifdef SVQC
    store = PS(player);
#endif
    int valid = (door.itemkeys & store.itemkeys);
    door.itemkeys &= ~valid; // only some of the needed keys were given
 
    if(!door.itemkeys)
    {
#ifdef SVQC
        play2(player, door.noise);
        Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_DOOR_UNLOCKED);
#endif
        return true;
    }
 
    if(!valid)
    {
#ifdef SVQC
        if(player.key_door_messagetime <= time)
        {
            play2(player, door.noise3);
            Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_DOOR_LOCKED_NEED, item_keys_keylist(door.itemkeys));
            player.key_door_messagetime = time + 2;
        }
#endif
        return false;
    }
 
    // door needs keys the player doesn't have
#ifdef SVQC
    if(player.key_door_messagetime <= time)
    {
        play2(player, door.noise3);
        Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_DOOR_LOCKED_ALSONEED, item_keys_keylist(door.itemkeys));
        player.key_door_messagetime = time + 2;
    }
#endif
 
    return false;
}

References entity(), IS_PLAYER, item_keys_keylist(), play2(), PS, Send_Notification(), and time.

Referenced by door_trigger_touch().

door_damage()

void door_damage	(	entity	this,
		entity	inflictor,
		entity	attacker,
		float	damage,
		int	deathtype,
		.entity	weaponentity,
		vector	hitloc,
		vector	force )

Definition at line 264 of file door.qc.

{
    if(this.spawnflags & NOSPLASH)
        if(!(DEATH_ISSPECIAL(deathtype)) && (deathtype & HITTYPE_SPLASH))
            return;
    TakeResource(this, RES_HEALTH, damage);
 
    if (this.itemkeys)
    {
        // don't allow opening doors through damage if keys are required
        return;
    }
 
    if (GetResource(this, RES_HEALTH) <= 0)
    {
        SetResourceExplicit(this.owner, RES_HEALTH, this.owner.max_health);
        this.owner.takedamage = DAMAGE_NO;  // will be reset upon return
        door_use(this.owner, attacker, NULL);
    }
}

References DAMAGE_NO, DEATH_ISSPECIAL, door_use(), entity(), GetResource(), HITTYPE_SPLASH, itemkeys, NOSPLASH, NULL, owner, SetResourceExplicit(), spawnflags, TakeResource(), and vector.

Referenced by door_init_shared().

door_generic_plat_blocked()

void door_generic_plat_blocked	(	entity	this,
		entity	blocker )

Definition at line 318 of file door.qc.

{
    if((this.spawnflags & DOOR_CRUSH) && (blocker.takedamage != DAMAGE_NO)) { // Kill Kill Kill!!
#ifdef SVQC
        Damage (blocker, this, this, 10000, DEATH_HURTTRIGGER.m_id, DMG_NOWEP, blocker.origin, '0 0 0');
#endif
    }
    else
    {
 
#ifdef SVQC
        if((this.dmg) && (blocker.takedamage == DAMAGE_YES))    // Shall we bite?
            Damage (blocker, this, this, this.dmg, DEATH_HURTTRIGGER.m_id, DMG_NOWEP, blocker.origin, '0 0 0');
#endif
 
         //Dont chamge direction for dead or dying stuff
        if(IS_DEAD(blocker) && (blocker.takedamage == DAMAGE_NO))
        {
            if (this.wait >= 0)
            {
                if (this.state == STATE_DOWN)
                    door_rotating_go_up (this, blocker);
                else
                    door_rotating_go_down (this);
            }
        }
#ifdef SVQC
        else
        {
            //gib dying stuff just to make sure
            if((this.dmg) && (blocker.takedamage != DAMAGE_NO))    // Shall we bite?
                Damage (blocker, this, this, 10000, DEATH_HURTTRIGGER.m_id, DMG_NOWEP, blocker.origin, '0 0 0');
        }
#endif
    }
}

References Damage(), DAMAGE_NO, DAMAGE_YES, dmg, DMG_NOWEP, DOOR_CRUSH, door_rotating_go_down(), door_rotating_go_up(), entity(), IS_DEAD, spawnflags, state, STATE_DOWN, and wait.

door_go_down()

void door_go_down

(

entity

this

)

Definition at line 114 of file door.qc.

{
    if (this.noise2 != "")
        _sound (this, CH_TRIGGER_SINGLE, this.noise2, VOL_BASE, ATTEN_NORM);
    if (this.max_health)
    {
        this.takedamage = DAMAGE_YES;
        SetResourceExplicit(this, RES_HEALTH, this.max_health);
    }
 
    this.state = STATE_DOWN;
    SUB_CalcMove (this, this.pos1, TSPEED_LINEAR, this.speed, door_hit_bottom);
}

References _sound, ATTEN_NORM, CH_TRIGGER_SINGLE, DAMAGE_YES, door_hit_bottom(), entity(), max_health, noise2, pos1, SetResourceExplicit(), speed, state, STATE_DOWN, SUB_CalcMove(), takedamage, TSPEED_LINEAR, and VOL_BASE.

Referenced by door_blocked(), door_hit_top(), and door_use().

door_go_up()

void door_go_up	(	entity	this,
		entity	actor,
		entity	trigger )

Definition at line 128 of file door.qc.

{
    if (this.state == STATE_UP)
        return;     // already going up
 
    if (this.state == STATE_TOP)
    {   // reset top wait time
        this.nextthink = this.ltime + this.wait;
        return;
    }
 
    if (this.noise2 != "")
        _sound (this, CH_TRIGGER_SINGLE, this.noise2, VOL_BASE, ATTEN_NORM);
    this.state = STATE_UP;
    SUB_CalcMove (this, this.pos2, TSPEED_LINEAR, this.speed, door_hit_top);
 
    string oldmessage = this.message;
    this.message = "";
    SUB_UseTargets(this, actor, trigger);
    this.message = oldmessage;
}

References _sound, ATTEN_NORM, CH_TRIGGER_SINGLE, door_hit_top(), entity(), ltime, message, nextthink, noise2, pos2, speed, state, STATE_TOP, STATE_UP, SUB_CalcMove(), SUB_UseTargets(), TSPEED_LINEAR, VOL_BASE, and wait.

Referenced by door_blocked(), and door_use().

door_hit_bottom()

void door_hit_bottom

(

entity

this

)

Definition at line 107 of file door.qc.

{
    if (this.noise1 != "")
        _sound (this, CH_TRIGGER_SINGLE, this.noise1, VOL_BASE, ATTEN_NORM);
    this.state = STATE_BOTTOM;
}

References _sound, ATTEN_NORM, CH_TRIGGER_SINGLE, entity(), noise1, state, STATE_BOTTOM, and VOL_BASE.

Referenced by door_go_down().

door_hit_top()

void door_hit_top

(

entity

this

)

Definition at line 90 of file door.qc.

{
    if (this.noise1 != "")
        _sound (this, CH_TRIGGER_SINGLE, this.noise1, VOL_BASE, ATTEN_NORM);
    this.state = STATE_TOP;
    if (this.spawnflags & DOOR_TOGGLE)
        return;     // don't come down automatically
    if (this.classname == "door")
    {
        setthink(this, door_go_down);
    } else
    {
        setthink(this, door_rotating_go_down);
    }
    this.nextthink = this.ltime + this.wait;
}

References _sound, ATTEN_NORM, CH_TRIGGER_SINGLE, classname, door_go_down(), door_rotating_go_down(), DOOR_TOGGLE, entity(), ltime, nextthink, noise1, setthink, spawnflags, state, STATE_TOP, VOL_BASE, and wait.

Referenced by door_go_up().

door_init_keys()

void door_init_keys

(

entity

this

)

Definition at line 627 of file door.qc.

{
    // Quake 1 and QL keys compatibility
    if (this.spawnflags & SPAWNFLAGS_GOLD_KEY)
        this.itemkeys |= BIT(0);
    if (this.spawnflags & SPAWNFLAGS_SILVER_KEY)
        this.itemkeys |= BIT(1);
}

References BIT, entity(), itemkeys, spawnflags, SPAWNFLAGS_GOLD_KEY, and SPAWNFLAGS_SILVER_KEY.

Referenced by door_reset(), and spawnfunc().

door_init_shared()

void door_init_shared

(

entity

this

)

Definition at line 666 of file door.qc.

{
    this.max_health = GetResource(this, RES_HEALTH);
 
    // unlock sound
    if(this.noise == "")
    {
        this.noise = "misc/talk.wav";
    }
    // door still locked sound
    if(this.noise3 == "")
    {
        this.noise3 = "misc/talk.wav";
    }
    precache_sound(this.noise);
    precache_sound(this.noise3);
 
    if((this.dmg || (this.spawnflags & DOOR_CRUSH)) && (this.message == ""))
    {
        this.message = "was squished";
    }
    if((this.dmg || (this.spawnflags & DOOR_CRUSH)) && (this.message2 == ""))
    {
        this.message2 = "was squished by";
    }
 
    // TODO: other soundpacks
    if (this.sounds > 0 || q3compat)
    {
        // Doors in Q3 always have sounds (they're hard coded)
        this.noise2 = "plats/medplat1.wav";
        this.noise1 = "plats/medplat2.wav";
    }
 
    if (q3compat)
    {
        // CPMA adds these fields for overriding the Q3 default sounds
        string s = GetField_fullspawndata(this, "sound_start", true);
        string e = GetField_fullspawndata(this, "sound_end", true);
 
        // Quake Live adds these ones, because of course it had to be different from CPMA
        if (!s) s = GetField_fullspawndata(this, "startsound", true);
        if (!e) e = GetField_fullspawndata(this, "endsound", true);
 
        if (s)
            this.noise2 = strzone(s);
        else
        {
            // PK3s supporting Q3A sometimes include custom sounds at Q3 default paths
            s = "sound/movers/doors/dr1_strt.wav";
            if (FindFileInMapPack(s))
                this.noise2 = s;
        }
 
        if (e)
            this.noise1 = strzone(e);
        else
        {
            e = "sound/movers/doors/dr1_end.wav";
            if (FindFileInMapPack(e))
                this.noise1 = e;
        }
    }
 
    // sound when door stops moving
    if(this.noise1 && this.noise1 != "")
    {
        precache_sound(this.noise1);
    }
    // sound when door is moving
    if(this.noise2 && this.noise2 != "")
    {
        precache_sound(this.noise2);
    }
 
    if(autocvar_sv_doors_always_open)
    {
        this.wait = -1;
    }
    else if (!this.wait)
    {
        this.wait = q3compat ? 2 : 3;
    }
 
    if (!this.lip)
    {
        this.lip = 8;
    }
 
    this.state = STATE_BOTTOM;
 
    if (GetResource(this, RES_HEALTH) || (q3compat && this.targetname == ""))
    {
        //this.canteamdamage = true; // TODO
        this.takedamage = DAMAGE_YES;
        this.event_damage = door_damage;
    }
 
    if (this.items)
    {
        this.wait = -1;
    }
}

References autocvar_sv_doors_always_open, DAMAGE_YES, dmg, DOOR_CRUSH, door_damage(), entity(), FindFileInMapPack(), GetField_fullspawndata(), GetResource(), items, lip, max_health, message, message2, noise, noise1, noise2, noise3, precache_sound(), q3compat, sounds, spawnflags, state, STATE_BOTTOM, strzone(), takedamage, targetname, and wait.

Referenced by spawnfunc(), and spawnfunc().

door_init_startopen()

void door_init_startopen

(

entity

this

)

Definition at line 637 of file door.qc.

{
    setorigin(this, this.pos2);
    this.pos2 = this.pos1;
    this.pos1 = this.origin;
 
#ifdef SVQC
    this.SendFlags |= SF_TRIGGER_UPDATE;
#endif
}

References entity(), origin, pos1, pos2, SendFlags, and SF_TRIGGER_UPDATE.

Referenced by spawnfunc().

door_link()

void door_link

(

)

Definition at line 622 of file door.qc.

{
    //Net_LinkEntity(this, false, 0, door_send);
}

Referenced by LinkDoors().

door_reset()

void door_reset

(

entity

this

)

Definition at line 648 of file door.qc.

{
    setorigin(this, this.pos1);
    this.velocity = '0 0 0';
    this.state = STATE_BOTTOM;
    this.active = ACTIVE_ACTIVE;
    setthink(this, func_null);
    this.nextthink = 0;
 
#ifdef SVQC
    this.SendFlags |= SF_TRIGGER_RESET;
    door_init_keys(this);
#endif
}

References active, ACTIVE_ACTIVE, door_init_keys(), entity(), func_null(), nextthink, pos1, SendFlags, setthink, SF_TRIGGER_RESET, state, STATE_BOTTOM, and velocity.

Referenced by spawnfunc().

door_send()

float door_send	(	entity	this,
		entity	to,
		float	sf )

Definition at line 580 of file door.qc.

{
    WriteHeader(MSG_ENTITY, ENT_CLIENT_DOOR);
    WriteByte(MSG_ENTITY, sf);
 
    if(sf & SF_TRIGGER_INIT)
    {
        WriteString(MSG_ENTITY, this.classname);
        WriteByte(MSG_ENTITY, this.spawnflags);
 
        WriteString(MSG_ENTITY, this.model);
 
        trigger_common_write(this, true);
 
        WriteVector(MSG_ENTITY, this.pos1);
        WriteVector(MSG_ENTITY, this.pos2);
 
        WriteVector(MSG_ENTITY, this.size);
 
        WriteShort(MSG_ENTITY, this.wait);
        WriteShort(MSG_ENTITY, this.speed);
        WriteByte(MSG_ENTITY, this.lip);
        WriteByte(MSG_ENTITY, this.state);
        WriteCoord(MSG_ENTITY, this.ltime);
    }
 
    if(sf & SF_TRIGGER_RESET)
    {
        // client makes use of this, we do not
    }
 
    if(sf & SF_TRIGGER_UPDATE)
    {
        WriteVector(MSG_ENTITY, this.origin);
 
        WriteVector(MSG_ENTITY, this.pos1);
        WriteVector(MSG_ENTITY, this.pos2);
    }
 
    return true;
}

References classname, entity(), lip, ltime, model, MSG_ENTITY, origin, pos1, pos2, SF_TRIGGER_INIT, SF_TRIGGER_RESET, SF_TRIGGER_UPDATE, size, spawnflags, speed, state, trigger_common_write(), wait, WriteByte(), WriteCoord(), WriteHeader, WriteShort(), and WriteString().

door_spawnfield()

void door_spawnfield	(	entity	this,
		vector	fmins,
		vector	fmaxs )

Definition at line 400 of file door.qc.

{
    entity  trigger;
    vector  t1 = fmins, t2 = fmaxs;
 
    trigger = new(doortriggerfield);
    set_movetype(trigger, MOVETYPE_NONE);
    trigger.solid = SOLID_TRIGGER;
    trigger.owner = this;
#ifdef SVQC
    settouch(trigger, door_trigger_touch);
#endif
 
    setsize (trigger, t1 - '60 60 8', t2 + '60 60 8');
}

References door_trigger_touch(), entity(), MOVETYPE_NONE, set_movetype(), settouch, SOLID_TRIGGER, and vector.

Referenced by LinkDoors().

door_touch()

void door_touch	(	entity	this,
		entity	toucher )

Definition at line 295 of file door.qc.

{
    if (!IS_PLAYER(toucher))
        return;
    if (this.owner.door_finished > time)
        return;
#ifdef SVQC
    if (this.owner.active != ACTIVE_ACTIVE)
        return;
#endif
 
    this.owner.door_finished = time + 2;
 
#ifdef SVQC
    if (!(this.owner.dmg) && (this.owner.message != ""))
    {
        if (IS_CLIENT(toucher))
            centerprint(toucher, this.owner.message);
        play2(toucher, this.owner.noise);
    }
#endif
}

References ACTIVE_ACTIVE, centerprint(), entity(), IS_CLIENT, IS_PLAYER, owner, play2(), time, and toucher.

Referenced by spawnfunc(), and spawnfunc().

door_trigger_touch()

void door_trigger_touch	(	entity	this,
		entity	toucher )

Definition at line 363 of file door.qc.

{
    if (GetResource(toucher, RES_HEALTH) < 1)
#ifdef SVQC
        if (!((toucher.iscreature || (toucher.flags & FL_PROJECTILE)) && !IS_DEAD(toucher)))
#elif defined(CSQC)
        if(!((IS_CLIENT(toucher) || toucher.classname == "ENT_CLIENT_PROJECTILE") && !IS_DEAD(toucher)))
#endif
            return;
#ifdef SVQC
    if (this.owner.active != ACTIVE_ACTIVE)
        return;
#endif
 
    if (this.owner.state == STATE_UP)
        return;
 
    // check if door is locked
    if (!door_check_keys(this, toucher))
        return;
 
    if (this.owner.state == STATE_TOP)
    {
        if (this.owner.nextthink < this.owner.ltime + this.owner.wait)
        {
            entity e = this.owner;
            do {
                e.nextthink = e.ltime + e.wait;
                e = e.enemy;
            } while (e != this.owner);
        }
        return;
    }
 
    door_use(this.owner, toucher, NULL);
}

References ACTIVE_ACTIVE, door_check_keys(), door_use(), entity(), FL_PROJECTILE, GetResource(), IS_CLIENT, IS_DEAD, NULL, owner, STATE_TOP, STATE_UP, and toucher.

Referenced by door_spawnfield().

door_use()

void door_use	(	entity	this,
		entity	actor,
		entity	trigger )

Definition at line 215 of file door.qc.

{
    //dprint("door_use (model: ");dprint(this.model);dprint(")\n");
 
    if (!this.owner)
        return;
    if (this.owner.active != ACTIVE_ACTIVE)
        return;
    this = this.owner;
 
    if (this.spawnflags & DOOR_TOGGLE)
    {
        if (this.state == STATE_UP || this.state == STATE_TOP)
        {
            entity e = this;
            do {
                if (e.classname == "door") {
                    door_go_down(e);
                } else {
                    door_rotating_go_down(e);
                }
                e = e.enemy;
            } while ((e != this) && (e != NULL));
            return;
        }
    }
 
// trigger all paired doors
    entity e = this;
    do {
        if (e.classname == "door") {
            door_go_up(e, actor, trigger);
        } else {
            // if the BIDIR spawnflag (==2) is set and the trigger has set trigger_reverse, reverse the opening direction
            if ((e.spawnflags & DOOR_ROTATING_BIDIR) && trigger.trigger_reverse!=0 && e.lip != 666 && e.state == STATE_BOTTOM) {
                e.lip = 666; // e.lip is used to remember reverse opening direction for door_rotating
                e.pos2 = '0 0 0' - e.pos2;
            }
            // if BIDIR_IN_DOWN (==8) is set, prevent the door from reoping during closing if it is triggered from the wrong side
            if (!((e.spawnflags & DOOR_ROTATING_BIDIR) &&  (e.spawnflags & DOOR_ROTATING_BIDIR_IN_DOWN) && e.state == STATE_DOWN
                && (((e.lip == 666) && (trigger.trigger_reverse == 0)) || ((e.lip != 666) && (trigger.trigger_reverse != 0)))))
            {
                door_rotating_go_up(e, trigger);
            }
        }
        e = e.enemy;
    } while ((e != this) && (e != NULL));
}

References ACTIVE_ACTIVE, door_go_down(), door_go_up(), DOOR_ROTATING_BIDIR, DOOR_ROTATING_BIDIR_IN_DOWN, door_rotating_go_down(), door_rotating_go_up(), DOOR_TOGGLE, entity(), NULL, owner, spawnflags, state, STATE_BOTTOM, STATE_DOWN, STATE_TOP, and STATE_UP.

Referenced by door_damage(), door_trigger_touch(), spawnfunc(), and spawnfunc().

LinkDoors()

void LinkDoors

(

entity

this

)

Definition at line 453 of file door.qc.

{
    entity  t;
    vector  cmins, cmaxs;
 
#ifdef SVQC
    door_link();
#endif
 
    if (this.enemy)
        return;     // already linked by another door
 
    // Q3 door linking is done for teamed doors only and is not affected by spawnflags or bmodel proximity
    if ((!Q3COMPAT_COMMON && (this.spawnflags & DOOR_DONT_LINK)) || (Q3COMPAT_COMMON && !this.team))
    {
        this.owner = this.enemy = this;
 
        if (GetResource(this, RES_HEALTH))
            return;
        if(this.targetname && this.targetname != "")
            return;
        if (this.items)
            return;
 
        door_spawnfield(this, this.absmin, this.absmax);
 
        return;     // don't want to link this door
    }
 
    FindConnectedComponent(this, enemy, LinkDoors_nextent, LinkDoors_isconnected, this);
 
    // set owner, and make a loop of the chain
    LOG_TRACE("LinkDoors: linking doors:");
    for(t = this; ; t = t.enemy)
    {
        LOG_TRACE(" ", etos(t));
        t.owner = this;
        if(t.enemy == NULL)
        {
            t.enemy = this;
            break;
        }
    }
    LOG_TRACE("");
 
    // collect health, targetname, message, size
    cmins = this.absmin;
    cmaxs = this.absmax;
    for(t = this; ; t = t.enemy)
    {
        if(GetResource(t, RES_HEALTH) && !GetResource(this, RES_HEALTH))
            SetResourceExplicit(this, RES_HEALTH, GetResource(t, RES_HEALTH));
        if((t.targetname != "") && (this.targetname == ""))
            this.targetname = t.targetname;
        if((t.message != "") && (this.message == ""))
            this.message = t.message;
        if (t.absmin_x < cmins_x)
            cmins_x = t.absmin_x;
        if (t.absmin_y < cmins_y)
            cmins_y = t.absmin_y;
        if (t.absmin_z < cmins_z)
            cmins_z = t.absmin_z;
        if (t.absmax_x > cmaxs_x)
            cmaxs_x = t.absmax_x;
        if (t.absmax_y > cmaxs_y)
            cmaxs_y = t.absmax_y;
        if (t.absmax_z > cmaxs_z)
            cmaxs_z = t.absmax_z;
        if(t.enemy == this)
            break;
    }
 
    // distribute health, targetname, message
    for(t = this; t; t = t.enemy)
    {
        SetResourceExplicit(t, RES_HEALTH, GetResource(this, RES_HEALTH));
        t.targetname = this.targetname;
        t.message = this.message;
        if(t.enemy == this)
            break;
    }
 
    // shootable, or triggered doors just needed the owner/enemy links,
    // they don't spawn a field
 
    if (GetResource(this, RES_HEALTH))
        return;
    if(this.targetname && this.targetname != "")
        return;
    if (this.items)
        return;
 
    door_spawnfield(this, cmins, cmaxs);
}

References absmax, absmin, DOOR_DONT_LINK, door_link(), door_spawnfield(), enemy, entity(), etos(), FindConnectedComponent(), GetResource(), items, LinkDoors_isconnected(), LinkDoors_nextent(), LOG_TRACE, message, NULL, owner, Q3COMPAT_COMMON, SetResourceExplicit(), spawnflags, targetname, team, and vector.

Referenced by spawnfunc(), and spawnfunc().

LinkDoors_isconnected()

bool LinkDoors_isconnected	(	entity	e1,
		entity	e2,
		entity	pass )

Definition at line 434 of file door.qc.

{
    if(Q3COMPAT_COMMON)
        return e1.team == e2.team;
 
    float DELTA = 4;
    if((e1.absmin_x > e2.absmax_x + DELTA)
    || (e1.absmin_y > e2.absmax_y + DELTA)
    || (e1.absmin_z > e2.absmax_z + DELTA)
    || (e2.absmin_x > e1.absmax_x + DELTA)
    || (e2.absmin_y > e1.absmax_y + DELTA)
    || (e2.absmin_z > e1.absmax_z + DELTA)
    ) { return false; }
    return true;
}

References entity(), pass, and Q3COMPAT_COMMON.

Referenced by LinkDoors().

LinkDoors_nextent()

entity LinkDoors_nextent	(	entity	cur,
		entity	near,
		entity	pass )

Definition at line 425 of file door.qc.

{
    while ((cur = find(cur, classname, pass.classname))
    && ((!Q3COMPAT_COMMON && (cur.spawnflags & DOOR_DONT_LINK)) || cur.enemy))
    {
    }
    return cur;
}

References classname, DOOR_DONT_LINK, entity(), find(), pass, and Q3COMPAT_COMMON.

Referenced by LinkDoors().

spawnfunc()

spawnfunc

(

func_door

)

Definition at line 771 of file door.qc.

{
    door_init_keys(this);
 
    SetMovedir(this);
 
    if (!InitMovingBrushTrigger(this))
        return;
    this.effects |= EF_LOWPRECISION;
    this.classname = "door";
 
    setblocked(this, door_blocked);
    this.use = door_use;
    this.active = ACTIVE_ACTIVE;
 
    if(this.spawnflags & DOOR_NONSOLID)
        this.solid = SOLID_NOT;
 
    // DOOR_START_OPEN is to allow an entity to be lighted in the closed position
    // but spawn in the open position
    // the tuba door on xoylent requires the delayed init
    if (this.spawnflags & DOOR_START_OPEN)
        InitializeEntity(this, door_init_startopen, INITPRIO_SETLOCATION);
 
    door_init_shared(this);
 
    this.pos1 = this.origin;
    vector absmovedir;
    absmovedir.x = fabs(this.movedir.x);
    absmovedir.y = fabs(this.movedir.y);
    absmovedir.z = fabs(this.movedir.z);
    this.pos2 = this.pos1 + this.movedir * (absmovedir * this.size - this.lip);
 
    if(autocvar_sv_doors_always_open)
    {
        this.speed = max(750, this.speed);
    }
    else if (!this.speed)
    {
        if (q3compat)
            this.speed = 400;
        else
            this.speed = 100;
    }
 
    if (q3compat)
    {
        if (!this.dmg)
            this.dmg = 2;
 
        if (!this.team)
        {
            string t = GetField_fullspawndata(this, "team", false);
            // bones_was_here: same hack as used to support teamed items on Q3 maps
            if (t) this.team = crc16(false, t);
        }
    }
 
    settouch(this, door_touch);
 
    // LinkDoors can't be done until all of the doors have been spawned, so
    // the sizes can be detected properly.
    InitializeEntity(this, LinkDoors, INITPRIO_LINKDOORS);
 
    this.reset = door_reset;
}

References active, ACTIVE_ACTIVE, autocvar_sv_doors_always_open, classname, dmg, door_blocked(), door_init_keys(), door_init_shared(), door_init_startopen(), DOOR_NONSOLID, door_reset(), DOOR_START_OPEN, door_touch(), door_use(), EF_LOWPRECISION, effects, fabs(), GetField_fullspawndata(), InitializeEntity(), InitMovingBrushTrigger(), INITPRIO_LINKDOORS, INITPRIO_SETLOCATION, LinkDoors(), lip, max(), movedir, origin, pos1, pos2, q3compat, setblocked, SetMovedir(), settouch, size, solid, SOLID_NOT, spawnflags, speed, team, use, and vector.

Variable Documentation

door_finished

float door_finished

Definition at line 285 of file door.qc.

Referenced by secret_blocked(), and secret_touch().