speed.qc

Go to the documentation of this file.

#include "speed.qh"
 
// bones_was_here: TODO implement subscript support for vectors in gmqcc
// or _something_ so code like this can be cheaper...
#define ARRAY_AS_VECTOR(a) vec3((a)[0], (a)[1], (a)[2])
#define VECTOR_TO_ARRAY(a, e) { vector v = (e); (a)[0] = v.x; (a)[1] = v.y; (a)[2] = v.z; }
vector target_speed_calculatevelocity(entity this, float speed, entity pushed_entity)
{
    bool is_percentage = boolean(this.spawnflags & SPEED_PERCENTAGE);
    bool is_add = boolean(this.spawnflags & SPEED_ADD);
    bool is_launcher = boolean(this.spawnflags & SPEED_LAUNCHER);
 
    bool is_positive[3];
    is_positive[0] = boolean(this.spawnflags & SPEED_POSITIVE_X);
    is_positive[1] = boolean(this.spawnflags & SPEED_POSITIVE_Y);
    is_positive[2] = boolean(this.spawnflags & SPEED_POSITIVE_Z);
 
    bool is_negative[3];
    is_negative[0] = boolean(this.spawnflags & SPEED_NEGATIVE_X);
    is_negative[1] = boolean(this.spawnflags & SPEED_NEGATIVE_Y);
    is_negative[2] = boolean(this.spawnflags & SPEED_NEGATIVE_Z);
 
    // speed cannot be negative except when subtracting
    if(!is_add)
    {
        speed = max(speed, 0);
    }
 
    float pushvel[3];
    VECTOR_TO_ARRAY(pushvel, pushed_entity.velocity)
 
    for(int i = 0; i < 3; ++i)
    {
        // launcher can only be either positive or negative not both
        if(is_launcher && is_positive[i] && is_negative[i])
        {
            is_positive[i] = is_negative[i] = false;
        }
 
        // ignore this direction
        if(!is_positive[i] && !is_negative[i])
        {
            pushvel[i] = 0;
        }
    }
 
    float oldspeed = vlen(ARRAY_AS_VECTOR(pushvel));
 
    // the speed field is used to specify the percentage of the current speed
    if(is_percentage)
    {
        speed = oldspeed * speed / 100;
    }
 
    float launcherspeed = 0;
 
    // do this properly when not playing a Q3 map, do not put this in the loop
    if(!STAT(Q3COMPAT, pushed_entity))
    {
        launcherspeed += speed;
 
        // add the add speed in the same variable
        // as it goes in the same direction
        if(is_add) launcherspeed += oldspeed;
    }
 
    for(int i = 0; i < 3; ++i)
    {
        if(((pushvel[i] != 0) || is_launcher) && (is_positive[i] != is_negative[i]))
        {
            if(is_launcher)
            {
                // every direction weighs the same amount on launchers
                // movedir does not matter
                pushvel[i] = 1;
 
                // this does not belong inside the loop
                // only simulate this bug when playing a Q3 map
                if(STAT(Q3COMPAT, pushed_entity))
                {
                    launcherspeed += speed;
 
                    // add the add speed in the same variable
                    // as it goes in the same direction
                    if(is_add) launcherspeed += oldspeed;
                }
            }
 
            if(is_positive[i])
            {
                pushvel[i] = copysign(pushvel[i], 1);
            }
            else if(is_negative[i])
            {
                pushvel[i] = copysign(pushvel[i], -1);
            }
        }
    }
 
    float oldvel[3];
    VECTOR_TO_ARRAY(oldvel, pushed_entity.velocity)
 
    if(is_launcher)
    {
        // launcher will always launch you in the correct direction
        // even if speed is set to a negative value, fabs() is correct
        VECTOR_TO_ARRAY(pushvel, normalize(ARRAY_AS_VECTOR(pushvel)) * fabs(launcherspeed))
    }
    else
    {
        if(!is_add)
            VECTOR_TO_ARRAY(pushvel, normalize(ARRAY_AS_VECTOR(pushvel)) * speed)
        else
            VECTOR_TO_ARRAY(pushvel, normalize(ARRAY_AS_VECTOR(pushvel)) * speed + ARRAY_AS_VECTOR(oldvel))
    }
 
    for(int i = 0; i < 3; ++i)
    {
        // preserve unaffected directions
        if(!is_positive[i] && !is_negative[i])
        {
            pushvel[i] = oldvel[i];
        }
    }
 
    return ARRAY_AS_VECTOR(pushvel);
}
#undef ARRAY_AS_VECTOR
#undef VECTOR_TO_ARRAY
 
REGISTER_NET_LINKED(ENT_CLIENT_TARGET_SPEED)
 
void target_speed_use(entity this, entity actor, entity trigger)
{
    if(this.active != ACTIVE_ACTIVE)
        return;
 
    actor.velocity = target_speed_calculatevelocity(this, this.speed, actor);
}
 
void target_speed_reset(entity this)
{
    this.active = ACTIVE_ACTIVE;
}
 
#ifdef SVQC
void target_speed_link(entity this);
 
/*
 * ENTITY PARAMETERS:
 *
 *   targetname:  Activating trigger points to this.
 *   speed:       Speed value to set (default: 100).
 */
spawnfunc(target_speed)
{
    this.active = ACTIVE_ACTIVE;
    this.setactive = generic_netlinked_setactive;
    this.use = target_speed_use;
    this.reset = target_speed_reset;
 
    // support a 0 speed setting AND a default
    string s = GetField_fullspawndata(this, "speed", false);
    if (!s || s == "")
        this.speed = 100;
 
    target_speed_link(this);
}
 
bool target_speed_send(entity this, entity to, float sf)
{
    WriteHeader(MSG_ENTITY, ENT_CLIENT_TARGET_SPEED);
 
    WriteShort(MSG_ENTITY, this.spawnflags);
    WriteByte(MSG_ENTITY, this.active);
    WriteString(MSG_ENTITY, this.targetname);
    WriteCoord(MSG_ENTITY, this.speed);
 
    return true;
}
 
void target_speed_link(entity this)
{
    Net_LinkEntity(this, false, 0, target_speed_send);
}
 
#elif defined(CSQC)
 
void target_speed_remove(entity this)
{
    strfree(this.targetname);
}
 
NET_HANDLE(ENT_CLIENT_TARGET_SPEED, bool isnew)
{
    this.spawnflags = ReadShort();
    this.active = ReadByte();
    this.targetname = strzone(ReadString());
    this.speed = ReadCoord();
 
    this.use = target_speed_use;
    this.entremove = target_speed_remove;
 
    return true;
}
#endif