subs.qc

/*  Copyright (C) 1996-1997  Id Software, Inc.

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

    See file, 'COPYING', for details.
*/

void(string) bcenterprint;
void(float, string, float, float) bsound;

void() SUB_Null = {};

void(entity attacker, float damage) SUB_null_pain = {};

void() SUB_Remove = { remove(self); };


/*
QuakeEd only writes a single float for angles(bad idea), so up and down are
just constant angles.
*/
void() SetMovedir =
{
    if (self.angles == '0 -1 0')
        self.movedir = '0 0 1';
    else if (self.angles == '0 -2 0')
        self.movedir = '0 0 -1';
    else
    {
        makevectors(self.angles);
        self.movedir = v_forward;
    }

    self.angles = '0 0 0';
};

/*
 * Initialize sounds for triggers
 */
void() InitTriggerSound = {
    if (self.sounds == 1) {
        self.noise = "misc/secret.wav";
    } else if (self.sounds == 2) {
        self.noise = "misc/talk.wav";
    } else if (self.sounds == 3) {
        self.noise = "misc/trigger1.wav";
    }

    if (self.noise && self.noise != "") {
        precache_sound(self.noise);
    }
}

/*
================
InitTrigger
================
*/
void() InitTrigger =
{
    InitTriggerSound();

// trigger angles are used for one-way touches.  An angle of 0 is assumed
// to mean no restrictions, so use a yaw of 360 instead.
    if (self.angles != '0 0 0')
        SetMovedir();
    self.solid = SOLID_TRIGGER;
    setmodel(self, self.model); // set size and link into world
    self.movetype = MOVETYPE_NONE;
    self.modelindex = 0;
    self.model = "";
};

/*
=============
SUB_CalcMove

calculate self.velocity and self.nextthink to reach dest from
self.origin traveling at speed
===============
*/
void(entity ent, vector tdest, float tspeed, void() func) SUB_CalcMoveEnt =
{
    entity stemp;
    stemp = self;
    self = ent;

    SUB_CalcMove(tdest, tspeed, func);
    self = stemp;
};

void(vector tdest, float tspeed, void() func) SUB_CalcMove =
{
    float my_time;
    vector vdestdelta;
    float len, traveltime;

    if (!tspeed)
        objerror("No speed is defined!");

    if (self.movetype == MOVETYPE_PUSH) {
        my_time = self.ltime;
    } else {
        my_time = time;
    }

    self.think1 = func;
    self.finaldest = tdest;
    self.think = SUB_CalcMoveDone;

    if (tdest == self.origin)
    {
        self.velocity = '0 0 0';
        self.nextthink = my_time + 0.1;
        return;
    }

// set destdelta to the vector needed to move
    vdestdelta = tdest - self.origin;

// calculate length of vector
    len = vlen(vdestdelta);

// divide by speed to get time to reach dest
    traveltime = len / tspeed;

    if (traveltime < 0.1)
    {
        self.velocity = '0 0 0';
        self.nextthink = my_time + 0.1;
        return;
    }

// set nextthink to trigger a think when dest is reached
    self.nextthink = my_time + traveltime;

// scale the destdelta vector by the time spent traveling to get velocity
    self.velocity = vdestdelta * (1/traveltime); // qcc won't take vec/float
};

/*
============
After moving, set origin to exact final destination
============
*/
void()  SUB_CalcMoveDone =
{
    setorigin(self, self.finaldest);
    self.velocity = '0 0 0';
    self.nextthink = -1;
    if (self.think1)
        self.think1();
};


/*
=============
SUB_CalcAngleMove

calculate self.avelocity and self.nextthink to reach destangle from
self.angles rotating

The calling function should make sure self.think is valid
===============
*/
void(entity ent, vector destangle, float tspeed, void() func) SUB_CalcAngleMoveEnt =
{
    entity stemp;
    stemp = self;
    self = ent;
    SUB_CalcAngleMove(destangle, tspeed, func);
    self = stemp;
};

void(vector destangle, float tspeed, void() func) SUB_CalcAngleMove =
{
    float my_time;
    vector destdelta;
    float len, traveltime;

    if (!tspeed)
        objerror("No speed is defined!");

    if (self.movetype == MOVETYPE_PUSH) {
        my_time = self.ltime;
    } else {
        my_time = time;
    }

    self.think = SUB_CalcAngleMoveDone;
    self.finalangle = destangle;
    self.think1 = func;

    if (destangle == self.angles) {
        self.avelocity = '0 0 0';
        self.nextthink = my_time + 0.1;
        return;
    }

// set destdelta to the vector needed to move
    destdelta = destangle - self.angles;

// calculate length ofvector
    len = vlen(destdelta);

// divide by speed to get time to reach dest
    traveltime = len / tspeed;

    if (traveltime < 0.1) {
        self.velocity = '0 0 0';
        self.nextthink = my_time + 0.1;
        return;
    }

// set nextthink to trigger a think when dest is reached
    self.nextthink = my_time + traveltime;

// scale the destdelta vector by the time spent traveling to get velocity
    self.avelocity = destdelta * (1 / traveltime);
};

/*
============
After rotating, set angle to exact final angle
============
*/
void() SUB_CalcAngleMoveDone =
{
    self.angles = self.finalangle;
    self.avelocity = '0 0 0';
    self.nextthink = -1;
    if (self.think1)
        self.think1();
};


//=============================================================================

void() DelayThink =
{
    activator = self.enemy;
    SUB_UseTargets();
    remove(self);
};

void() SUB_UseTrigger = {
    if (self.noise != "")
        sound(self, CHAN_VOICE, self.noise, 1, ATTN_NORM);
    SUB_UseTargets();
};

static void(string target) FireTargetImmediate = {
    entity t, stemp, otemp, act;

    if (target != "") {
        act = activator;
        t = world;

        do {
            t = find(t, targetname, target);

            if (!t) {
                return;
            }

            stemp = self;
            otemp = other;
            self = t;
            other = stemp;

            if (self.use != SUB_Null && self.use) {
                self.io_received = other.io_send;
                self.use();
            }

            self = stemp;
            other = otemp;
            activator = act;
        } while (1);
    }
};

/*
==============================
SUB_UseTargets

the global "activator" should be set to the entity that initiated the firing.

If self.delay is set, a DelayedUse entity will be created that will actually
do the SUB_UseTargets after that many seconds have passed.

Centerprints any self.message to the activator.

Removes all entities with a targetname that match self.killtarget,
and removes them, so some events can remove other triggers.

Search for(string)targetname in all entities that
match(string)self.target and call their .use function

==============================
*/
void() SUB_UseTargets =
{
    entity t;
//
// check for a delay
//
    if (self.delay)
    {
    // create a temp object to fire at a later time
        t = spawn();
        t.io_send = self.io_send;
        t.classname = "DelayedUse";
        t.nextthink = time + self.delay;
        t.think = DelayThink;
        t.enemy = activator;
        t.message = self.message;
        t.killtarget = self.killtarget;
        t.target = self.target;
        t.target2 = self.target2;
        t.gflags = self.gflags;
        return;
    }


//
// print the message
//
    if (self.gflags & GFL_BROADCAST) {
        bcenterprint(self.message);
        if (!self.noise) {
            bsound(CHAN_VOICE, "misc/talk.wav", 1, ATTN_NORM);
        }
    } else if (activator.classname == "player" && self.message != "") {
        centerprint(activator, self.message);
        if (self.noise == "")
            sound(activator, CHAN_VOICE, "misc/talk.wav", 1, ATTN_NORM);
    }

//
// kill the killtagets
//
    if (self.killtarget != "")
    {
        t = nextent(world);

        while (t) {
            t = find(t, targetname, self.killtarget);
            if (t) {
                remove(t);
            }
        } 
    }

//
// fire targets
//
    FireTargetImmediate(self.target);
    FireTargetImmediate(self.target2);
};


/*

in nightmare mode, all attack_finished times become 0
some monsters refire twice automatically

*/

void(float normal) SUB_AttackFinished =
{
    self.cnt = 0; // refire count for nightmare
    self.attack_finished = time + normal;
};

float(entity targ) visible;

void(void() thinkst) SUB_CheckRefire =
{
    if (skill != 3)
        return;
    if (self.cnt == 1)
        return;
    if (!visible(self.enemy))
        return;
    self.cnt = 1;
    self.think = thinkst;
};

// after touch event, check if entity is on top of other
float() OnTopOf = {
    float delta = self.absmin_z - other.absmax_z;
    
    if (delta <= 0 && delta > -5) {
        return TRUE;
    } else {
        return FALSE;
    }
}