net.qc File Reference

#include "net.qh"
#include "nades.qh"
#include <client/view.qh>

Include dependency graph for net.qc:

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

Go to the source code of this file.

Functions
	NET_HANDLE (Nade_Orb, bool isNew)
void	orb_draw (entity this)
void	orb_draw2d (entity this)
bool	orb_send (entity this, entity to, int sf)
void	orb_setup (entity orb)

Function Documentation

NET_HANDLE()

NET_HANDLE	(	Nade_Orb	,
		bool	isNew )

Definition at line 80 of file net.qc.

{
    Net_Accept(Nade_Orb);
 
    int sf = ReadByte();
    this.colormod = ReadRegistered(Nades).m_color;
    setorigin(this, ReadVector());
    this.ltime = ReadFloat();
    //this.ltime = time + ReadByte() / 10.0;
    this.lifetime = (sf & SF_NADEORB_LIFETIME_FLOAT)
        ? ReadFloat()
        : (ReadByte() + 1) * 0.125;
    this.radius = (sf & SF_NADEORB_RADIUS_FLOAT)
        ? ReadFloat()
        : (ReadByte() + 1) * 5;
 
    if (isNew)
        orb_setup(this);
    return true;
}

References colormod, lifetime, ltime, orb_setup(), radius, ReadByte(), ReadFloat, ReadRegistered, ReadVector, SF_NADEORB_LIFETIME_FLOAT, and SF_NADEORB_RADIUS_FLOAT.

orb_draw()

void orb_draw

(

entity

this

)

Definition at line 10 of file net.qc.

{
    float age = time - (this.ltime - this.lifetime);
    float dt = time - this.update_time;
    this.update_time = time;
 
    if (dt > 0)
    {
        this.avelocity *= 24 ** (dt / this.lifetime); // speed up, frametime independent
        this.angles += dt * this.avelocity;
    }
    if (age > 0)
    {
        this.scale = this.radius * (age >= this.animstate_endtime
            ? 1
            : (this.height * age * (age - this.animstate_endtime * 2))); // increases at decreasing pace up to .radius, as age -> .animstate_endtime
        this.alpha = sqrt(1 - age / this.lifetime); // slowly fade out
    }
}

References alpha, angles, animstate_endtime, avelocity, entity(), height, lifetime, ltime, radius, scale, sqrt(), time, and update_time.

Referenced by orb_setup().

orb_draw2d()

void orb_draw2d

(

entity

this

)

Definition at line 30 of file net.qc.

{
    static float orb_drawtime; // last drawn orb frame, to counter overlapping orbs
    if (time <= orb_drawtime)
        return;
 
    if (boxesoverlap(view_origin - '1 1 1', view_origin + '1 1 1', this.absmin, this.absmax)) // nade orbs actually act as a cube
    {
        orb_drawtime = time; // prevent rendering more than one of these per frame!
        float orb_alpha = this.alpha * 0.6;
        drawfill('0 0 0', vec2(vid_conwidth, vid_conheight), this.colormod, autocvar_hud_colorflash_alpha * orb_alpha, DRAWFLAG_ADDITIVE);
    }
}

References absmax, absmin, alpha, autocvar_hud_colorflash_alpha, boxesoverlap(), colormod, drawfill, DRAWFLAG_ADDITIVE, entity(), time, vec2, vid_conheight, vid_conwidth, and view_origin.

Referenced by orb_setup().

orb_send()

bool orb_send	(	entity	this,
		entity	to,
		int	sf )

Definition at line 102 of file net.qc.

{
    sf = 0;
    float byte_lifetime = this.lifetime * 8 - 1; // range: 0.125..32 in increments of 0.125
    if (byte_lifetime < 0 || byte_lifetime >= BIT(8) || byte_lifetime != floor(byte_lifetime))
        sf |= SF_NADEORB_LIFETIME_FLOAT;
    float byte_radius = this.radius * 0.2 - 1; // range: 5..1280 in increments of 5
    if (byte_radius < 0 || byte_radius >= BIT(8) || byte_radius != floor(byte_radius))
        sf |= SF_NADEORB_RADIUS_FLOAT;
 
    WriteHeader(MSG_ENTITY, Nade_Orb);
    WriteByte(MSG_ENTITY, sf);
    WriteRegistered(Nades, MSG_ENTITY, REGISTRY_GET(Nades, STAT(NADE_BONUS_TYPE, this)));
    WriteVector(MSG_ENTITY, this.origin);
    WriteFloat(MSG_ENTITY, this.ltime);
    //WriteByte(MSG_ENTITY, (this.ltime - time) * 10.0 + 0.5); // round time delta to a 1/10th of a second
    if (sf & SF_NADEORB_LIFETIME_FLOAT)
        WriteFloat(MSG_ENTITY, this.lifetime);
    else
        WriteByte(MSG_ENTITY, rint(byte_lifetime));
    if (sf & SF_NADEORB_RADIUS_FLOAT)
        WriteFloat(MSG_ENTITY, this.radius);
    else
        WriteByte(MSG_ENTITY, rint(byte_radius));
 
    return true;
}

References BIT, entity(), floor(), lifetime, ltime, MSG_ENTITY, origin, radius, REGISTRY_GET, rint(), SF_NADEORB_LIFETIME_FLOAT, SF_NADEORB_RADIUS_FLOAT, STAT, WriteByte(), WriteHeader, and WriteRegistered.

Referenced by nades_spawn_orb().

orb_setup()

void orb_setup

(

entity

orb

)

Definition at line 44 of file net.qc.

{
    orb.update_time = time; // used to calculate dt
    orb.animstate_endtime = 0.25 * min(orb.lifetime, 1); // when the orb will stop expanding
    orb.height = -4 * (2 * orb.animstate_endtime) ** -2; // amplitude used in scaling calculation
 
    setmodel(orb, MDL_NADE_ORB);
    orb.skin = 1;
 
    float model_radius = orb.maxs.x;
    vector size = '0.5 0.5 0.5' * orb.radius;
    setsize(orb, -size, size);
    orb.radius *= 0.6 / model_radius;
 
    orb.draw = orb_draw;
    orb.draw2d = orb_draw2d;
    IL_PUSH(g_drawables, orb);
    IL_PUSH(g_drawables_2d, orb);
    SetResourceExplicit(orb, RES_HEALTH, 255);
    set_movetype(orb, MOVETYPE_NONE);
    orb.solid = SOLID_NOT;
    orb.drawmask = MASK_NORMAL;
    orb.renderflags |= RF_ADDITIVE;
    orb.scale = 0.01;
    float spin_dir = 2*M_PI * random();
    orb.avelocity = '6 0 0' * sin(spin_dir) + '0 0 6' * cos(spin_dir);
 
    float age = time - (orb.ltime - orb.lifetime);
    if (age > 0)
        orb.avelocity *= 24 ** (age / orb.lifetime);
}

References cos(), entity(), g_drawables, g_drawables_2d, IL_PUSH(), M_PI, MASK_NORMAL, min(), MOVETYPE_NONE, orb_draw(), orb_draw2d(), random(), RF_ADDITIVE, set_movetype(), setmodel, SetResourceExplicit(), sin(), size, SOLID_NOT, time, and vector.

Referenced by NET_HANDLE().