raven/hexen2
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
hexen2/H2MP/code/R_PART.C

2336 lines
49 KiB
C
Raw Normal View History

as released 2000-11-10
2000-11-10 00:00:00 +00:00
/*
* $Header: /H2 Mission Pack/R_PART.C 54 4/01/98 6:43p Jmonroe $
*/
#include "quakedef.h"
#include "r_local.h"
#define SFL_FLUFFY 1 // All largish flakes
#define SFL_MIXED 2 // Mixed flakes
#define SFL_HALF_BRIGHT 4 // All flakes start darker
#define SFL_NO_MELT 8 // Flakes don't melt when his surface, just go away
#define SFL_IN_BOUNDS 16 // Flakes cannot leave the bounds of their box
#define SFL_NO_TRANS 32 // All flakes start non-translucent
#define SFL_64 64
#define SFL_128 128
#define MAX_PARTICLES 7000 // default max # of particles at one
// time
#define ABSOLUTE_MIN_PARTICLES 512 // no fewer than this no matter what's
// on the command line
int ramp1[8] = { 416,416+2,416+4,416+6,416+8,416+10,416+12,416+14};
int ramp2[8] = { 384+4,384+6,384+8,384+10,384+12,384+13,384+14,384+15};
int ramp3[8] = {0x6d, 0x6b, 6, 5, 4, 3};
int ramp4[16] = { 416,416+1,416+2,416+3,416+4,416+5,416+6,416+7,416+8,416+9,416+10,416+11,416+12,416+13,416+14,416+15};
int ramp5[16] = { 400,400+1,400+2,400+3,400+4,400+5,400+6,400+7,400+8,400+9,400+10,400+11,400+12,400+13,400+14,400+15};
int ramp6[16] = { 256,256+1,256+2,256+3,256+4,256+5,256+6,256+7,256+8,256+9,256+10,256+11,256+12,256+13,256+14,256+15};
int ramp7[16] = { 384,384+1,384+2,384+3,384+4,384+5,384+6,384+7,384+8,384+9,384+10,384+11,384+12,384+13,384+14,384+15};
int ramp8[16] = {175, 174, 173, 172, 171, 170, 169, 168, 167, 166, 13, 14, 15, 16, 17, 18};
//int ramp9[16] = { 272,272+1,272+2,272+3,272+4,272+5,272+6,272+7,272+8,272+9,272+10,272+11,272+12,272+13,272+14,272+15};
int ramp9[16] = { 416,416+1,416+2,416+3,416+4,416+5,416+6,416+7,416+8,416+9,416+10,416+11,416+12,416+13,416+14,416+15};
int ramp10[16] = { 432,432+1,432+2,432+3,432+4,432+5,432+6,432+7,432+8,432+9,432+10,432+11,432+12,432+13,432+14,432+15};
int ramp11[8] = { 424,424+1,424+2,424+3,424+4,424+5,424+6,424+7};
int ramp12[8] = { 136,137,138,139,140,141,142,143};
byte *transTable;
byte MyTable[256];
particle_t *active_particles, *free_particles;
particle_t *particles;
int r_numparticles;
vec3_t r_pright, r_pup, r_ppn;
static vec3_t rider_origin;
cvar_t leak_color = {"leak_color","251", true};
cvar_t snow_flurry= {"snow_flurry","1", true};
cvar_t snow_active= {"snow_active","1", true};
static particle_t *AllocParticle(void);
void R_RunParticleEffect2 (vec3_t org, vec3_t dmin, vec3_t dmax, int color, int effect, int count);
void R_RunParticleEffect3 (vec3_t org, vec3_t box, int color, int effect, int count);
void R_RunParticleEffect4 (vec3_t org, float radius, int color, int effect, int count);
/*
void R_LeakColor_f(void)
{
int newLeakColor;
newLeakColor = atoi (Cmd_Argv(1));
if (newLeakColor < 0 || newLeakColor > 255)
{
Con_Printf ("Leak color is out of range!\n");
return;
}
Cvar_SetValue ("leak_color", (float)newLeakColor);
Con_Printf ("Leak color is %d\n", newLeakColor);
}
*/
/*
===============
R_InitParticles
===============
*/
void R_InitParticles (void)
{
int i;
FILE *f;
i = COM_CheckParm ("-particles");
MyTable[0] = 254;
if (i)
{
r_numparticles = (int)(atoi(com_argv[i+1]));
if (r_numparticles < ABSOLUTE_MIN_PARTICLES)
r_numparticles = ABSOLUTE_MIN_PARTICLES;
}
else
{
r_numparticles = MAX_PARTICLES;
}
particles = (particle_t *)
Hunk_AllocName (r_numparticles * sizeof(particle_t), "particles");
Cvar_RegisterVariable (&leak_color);
//JFM: snow test
Cvar_RegisterVariable (&snow_flurry);
Cvar_RegisterVariable (&snow_active);
transTable = (byte *)malloc(65536);
if (!transTable)
Sys_Error ("Couldn't load gfx/tinttab.lmp");
COM_FOpenFile ("gfx/tinttab.lmp", &f, false);
if (f)
{
fread(transTable,1,65536,f);
fclose(f);
}
}
#ifdef QUAKE2RJ
void R_DarkFieldParticles (entity_t *ent)
{
int i, j, k;
particle_t *p;
float vel;
vec3_t dir;
vec3_t org;
org[0] = ent->origin[0];
org[1] = ent->origin[1];
org[2] = ent->origin[2];
for (i=-16 ; i<16 ; i+=8)
for (j=-16 ; j<16 ; j+=8)
for (k=0 ; k<32 ; k+=8)
{
p = AllocParticle();
if (!p)
return;
p->die = cl.time + 0.2 + (rand()&7) * 0.02;
p->color = 150 + rand()%6;
p->type = pt_slowgrav;
dir[0] = j*8;
dir[1] = i*8;
dir[2] = k*8;
p->org[0] = org[0] + i + (rand()&3);
p->org[1] = org[1] + j + (rand()&3);
p->org[2] = org[2] + k + (rand()&3);
VectorNormalize (dir);
vel = 50 + (rand()&63);
VectorScale (dir, vel, p->vel);
}
}
#endif
//==========================================================================
//
// AllocParticle
//
//==========================================================================
static particle_t *AllocParticle(void)
{
particle_t *p;
if(!free_particles)
{
return NULL;
}
p = free_particles;
free_particles = p->next;
p->next = active_particles;
active_particles = p;
return p;
}
/*
===============
R_EntityParticles
===============
*/
/*
#define NUMVERTEXNORMALS 162
extern float r_avertexnormals[NUMVERTEXNORMALS][3];
vec3_t avelocities[NUMVERTEXNORMALS];
float beamlength = 16;
//vec3_t avelocity = {23, 7, 3};
//float partstep = 0.01;
//float timescale = 0.01;
void R_EntityParticles (entity_t *ent)
{
int count;
int i;
particle_t *p;
float angle;
float sr, sp, sy, cr, cp, cy;
vec3_t forward;
float dist;
dist = 64;
count = 50;
if (!avelocities[0][0])
{
for (i=0 ; i<NUMVERTEXNORMALS*3 ; i++)
avelocities[0][i] = (rand()&255) * 0.01;
}
for (i=0 ; i<NUMVERTEXNORMALS ; i++)
{
angle = cl.time * avelocities[i][0];
sy = sin(angle);
cy = cos(angle);
angle = cl.time * avelocities[i][1];
sp = sin(angle);
cp = cos(angle);
angle = cl.time * avelocities[i][2];
sr = sin(angle);
cr = cos(angle);
forward[0] = cp*cy;
forward[1] = cp*sy;
forward[2] = -sp;
p = AllocParticle();
if (!p)
return;
p->die = cl.time + 0.01;
p->color = 0x6f;
p->type = pt_fireball;//pt_explode;
p->org[0] = ent->origin[0] + r_avertexnormals[i][0]*dist + forward[0]*beamlength;
p->org[1] = ent->origin[1] + r_avertexnormals[i][1]*dist + forward[1]*beamlength;
p->org[2] = ent->origin[2] + r_avertexnormals[i][2]*dist + forward[2]*beamlength;
}
}
*/
/*
===============
R_ClearParticles
===============
*/
void R_ClearParticles (void)
{
int i;
free_particles = &particles[0];
active_particles = NULL;
if (!r_numparticles)
return;
for (i=0 ;i<r_numparticles ; i++)
particles[i].next = &particles[i+1];
particles[r_numparticles-1].next = NULL;
}
void R_ReadPointFile_f (void)
{
FILE *f;
vec3_t org;
int r;
int c;
particle_t *p;
char name[MAX_OSPATH];
byte color;
color = (byte)Cvar_VariableValue("leak_color");
sprintf (name,"maps/%s.pts", sv.name);
COM_FOpenFile (name, &f, false);
if (!f)
{
Con_Printf ("couldn't open %s\n", name);
return;
}
Con_Printf ("Reading %s...\n", name);
c = 0;
for ( ;; )
{
r = fscanf (f,"%f %f %f\n", &org[0], &org[1], &org[2]);
if (r != 3)
break;
c++;
p = AllocParticle();
if (!p)
{
Con_Printf ("Not enough free particles\n");
break;
}
p->die = 99999;
p->color = color; // (-c)&15;
p->type = pt_static;
VectorCopy (vec3_origin, p->vel);
VectorCopy (org, p->org);
}
fclose (f);
Con_Printf ("%i points read\n", c);
}
/*
===============
R_ParseParticleEffect
Parse an effect out of the server message
===============
*/
void R_ParseParticleEffect (void)
{
vec3_t org, dir;
int i, count, msgcount, color;
for (i=0 ; i<3 ; i++)
org[i] = MSG_ReadCoord ();
for (i=0 ; i<3 ; i++)
dir[i] = MSG_ReadChar () * (1.0/16);
msgcount = MSG_ReadByte ();
color = MSG_ReadByte ();
if (msgcount == 255)
count = 1024;
else
count = msgcount;
R_RunParticleEffect (org, dir, color, count);
}
/*
===============
R_ParseParticleEffect2
Parse an effect out of the server message
===============
*/
void R_ParseParticleEffect2 (void)
{
vec3_t org, dmin, dmax;
int i, msgcount, color, effect;
for (i=0 ; i<3 ; i++)
org[i] = MSG_ReadCoord ();
for (i=0 ; i<3 ; i++)
dmin[i] = MSG_ReadFloat ();
for (i=0 ; i<3 ; i++)
dmax[i] = MSG_ReadFloat ();
color = MSG_ReadShort ();
msgcount = MSG_ReadByte ();
effect = MSG_ReadByte ();
R_RunParticleEffect2 (org, dmin, dmax, color, effect, msgcount);
}
/*
===============
R_ParseParticleEffect3
Parse an effect out of the server message
===============
*/
void R_ParseParticleEffect3 (void)
{
vec3_t org, box;
int i, msgcount, color, effect;
for (i=0 ; i<3 ; i++)
org[i] = MSG_ReadCoord ();
for (i=0 ; i<3 ; i++)
box[i] = MSG_ReadByte ();
color = MSG_ReadShort ();
msgcount = MSG_ReadByte ();
effect = MSG_ReadByte ();
R_RunParticleEffect3 (org, box, color, effect, msgcount);
}
/*
===============
R_ParseParticleEffect4
Parse an effect out of the server message
===============
*/
void R_ParseParticleEffect4 (void)
{
vec3_t org;
int i, msgcount, color, effect;
float radius;
for (i=0 ; i<3 ; i++)
org[i] = MSG_ReadCoord ();
radius = MSG_ReadByte();
color = MSG_ReadShort ();
msgcount = MSG_ReadByte ();
effect = MSG_ReadByte ();
R_RunParticleEffect4 (org, radius, color, effect, msgcount);
}
/*
===============
R_ParticleExplosion
===============
*/
void R_ParticleExplosion (vec3_t org)
{
int i, j;
particle_t *p;
for (i=0 ; i<1024 ; i++)
{
p = AllocParticle();
if (!p)
return;
p->die = cl.time + 5;
p->color = ramp1[0];
p->ramp = rand()&3;
if (i & 1)
{
p->type = pt_explode;
for (j=0 ; j<3 ; j++)
{
p->org[j] = org[j] + ((rand()&31)-16);
p->vel[j] = (rand()&511)-256;
}
}
else
{
p->type = pt_explode2;
for (j=0 ; j<3 ; j++)
{
p->org[j] = org[j] + ((rand()&31)-16);
p->vel[j] = (rand()&511)-256;
}
}
}
}
/*
===============
R_ParticleExplosion2
===============
*/
/*
void R_ParticleExplosion2 (vec3_t org, int colorStart, int colorLength)
{
int i, j;
particle_t *p;
int colorMod = 0;
for (i=0; i<512; i++)
{
p = AllocParticle();
if (!p)
return;
p->die = cl.time + 0.3;
p->color = colorStart + (colorMod % colorLength);
colorMod++;
p->type = pt_blob;
for (j=0 ; j<3 ; j++)
{
p->org[j] = org[j] + ((rand()&31)-16);
p->vel[j] = (rand()&511)-256;
}
}
}
*/
/*
===============
R_BlobExplosion
tar
===============
*/
/*
void R_BlobExplosion (vec3_t org)
{
int i, j;
particle_t *p;
for (i=0 ; i<1024 ; i++)
{
p = AllocParticle();
if (!p)
return;
p->die = cl.time + 1 + (rand()&8)*0.05;
if (i & 1)
{
p->type = pt_blob;
p->color = 66 + rand()%6;
for (j=0 ; j<3 ; j++)
{
p->org[j] = org[j] + ((rand()&31)-16);
p->vel[j] = (rand()&511)-256;
}
}
else
{
p->type = pt_blob2;
p->color = 150 + rand()%6;
for (j=0 ; j<3 ; j++)
{
p->org[j] = org[j] + ((rand()&31)-16);
p->vel[j] = (rand()&511)-256;
}
}
}
}
*/
/*
===============
R_RunParticleEffect
===============
*/
void R_RunParticleEffect (vec3_t org, vec3_t dir, int color, int count)
{
int i, j;
particle_t *p;
for (i=0 ; i<count ; i++)
{
p = AllocParticle();
if (!p)
return;
if (count == 1024)
{ // rocket explosion
p->die = cl.time + 5;
p->color = ramp1[0];
p->ramp = rand()&3;
if (i & 1)
{
p->type = pt_explode;
for (j=0 ; j<3 ; j++)
{
p->org[j] = org[j] + ((rand()&31)-16);
p->vel[j] = (rand()&511)-256;
}
}
else
{
p->type = pt_explode2;
for (j=0 ; j<3 ; j++)
{
p->org[j] = org[j] + ((rand()&31)-16);
p->vel[j] = (rand()&511)-256;
}
}
}
else
{
p->die = cl.time + 0.1*(rand()%5);
// p->color = (color&~7) + (rand()&7);
// p->color = 265 + (rand() % 9);
p->color = 256 + 16 + 12 + (rand() & 3);
p->type = pt_slowgrav;
for (j=0 ; j<3 ; j++)
{
p->org[j] = org[j] + ((rand()&15)-8);
p->vel[j] = dir[j]*15;// + (rand()%300)-150;
}
}
}
}
/*
===============
R_RunParticleEffect2
===============
*/
void R_RunParticleEffect2 (vec3_t org, vec3_t dmin, vec3_t dmax, int color, int effect, int count)
{
int i, j;
particle_t *p;
float num;
for (i=0 ; i<count ; i++)
{
p = AllocParticle();
if (!p)
return;
// p->die = cl.time + 0.1*(rand()%5);
p->die = cl.time + 2;//0.1*(rand()%5);
p->color = color;
p->type = effect;
p->ramp = 0;
for (j=0 ; j<3 ; j++)
{
num = rand()*(1.0/RAND_MAX);//(rand ()&0x7fff) / ((float)0x7fff);
p->org[j] = org[j] + ((rand()&8)-4); //added randomness to org
p->vel[j] = dmin[j] + ((dmax[j] - dmin[j]) * num);
}
}
}
/*
===============
R_RunParticleEffect3
===============
*/
void R_RunParticleEffect3 (vec3_t org, vec3_t box, int color, int effect, int count)
{
int i, j;
particle_t *p;
float num;
for (i=0 ; i<count ; i++)
{
p = AllocParticle();
if (!p)
return;
// p->die = cl.time + 0.1*(rand()%5);
p->die = cl.time + 2;//0.1*(rand()%5);
p->color = color;
p->type = effect;
p->ramp = 0;
for (j=0 ; j<3 ; j++)
{
num = rand()*(1.0/RAND_MAX);//(rand ()&0x7fff) / ((float)0x7fff);
p->org[j] = org[j] + ((rand()&15)-8);
p->vel[j] = (box[j] * num * 2) - box[j];
}
}
}
/*
===============
R_RunParticleEffect4
===============
*/
void R_RunParticleEffect4 (vec3_t org, float radius, int color, int effect, int count)
{
int i, j;
particle_t *p;
float num;
for (i=0 ; i<count ; i++)
{
p = AllocParticle();
if (!p)
{
return;
}
// p->die = cl.time + 0.1*(rand()%5);
p->die = cl.time + 2;//0.1*(rand()%5);
p->color = color;
p->type = effect;
p->ramp = 0;
for (j=0 ; j<3 ; j++)
{
num = rand()*(1.0/RAND_MAX);//(rand ()&0x7fff) / ((float)0x7fff);
p->org[j] = org[j] + ((rand()&15)-8);
p->vel[j] = (radius * num * 2) - radius;
}
}
}
/*
===============
R_LavaSplash
===============
*/
void R_LavaSplash (vec3_t org)
{
int i, j, k;
particle_t *p;
float vel;
vec3_t dir;
for (i=-16 ; i<16 ; i++)
for (j=-16 ; j<16 ; j++)
for (k=0 ; k<1 ; k++)
{
p = AllocParticle();
if (!p)
return;
p->die = cl.time + 2 + (rand()&31) * 0.02;
p->color = 224 + (rand()&7);
p->type = pt_slowgrav;
dir[0] = j*8 + (rand()&7);
dir[1] = i*8 + (rand()&7);
dir[2] = 256;
p->org[0] = org[0] + dir[0];
p->org[1] = org[1] + dir[1];
p->org[2] = org[2] + (rand()&63);
VectorNormalize (dir);
vel = 50 + (rand()&63);
VectorScale (dir, vel, p->vel);
}
}
/*
===============
R_TeleportSplash
===============
*/
void R_TeleportSplash (vec3_t org)
{
int i, j, k;
particle_t *p;
float vel;
vec3_t dir;
for (i=-16 ; i<16 ; i+=4)
for (j=-16 ; j<16 ; j+=4)
for (k=-24 ; k<32 ; k+=4)
{
p = AllocParticle();
if (!p)
return;
p->die = cl.time + 0.2 + (rand()&7) * 0.02;
p->color = 7 + (rand()&7);
p->type = pt_slowgrav;
dir[0] = j*8;
dir[1] = i*8;
dir[2] = k*8;
p->org[0] = org[0] + i + (rand()&3);
p->org[1] = org[1] + j + (rand()&3);
p->org[2] = org[2] + k + (rand()&3);
VectorNormalize (dir);
vel = 50 + (rand()&63);
VectorScale (dir, vel, p->vel);
}
}
/*
===============
R_RunQuakeEffect
===============
*/
void R_RunQuakeEffect (vec3_t org, float distance)
{
int i, j;
particle_t *p;
float num,num2;
for (i=0 ; i<100 ; i++)
{
p = AllocParticle();
if (!p)
return;
p->die = cl.time + 0.3*(rand()%5);
p->color = (rand() &3) + ((rand() % 3)*16) + (13 * 16) + 256 + 11;
p->type = pt_quake;
p->ramp = 0;
num = rand()*(1.0/RAND_MAX);//(rand ()&0x7fff) / ((float)0x7fff);
num2 = distance * num;
num = rand()*(1.0/RAND_MAX);//(rand ()&0x7fff) / ((float)0x7fff);
p->org[0] = org[0] + cos(num * 2 * M_PI)*num2;
p->org[1] = org[1] + sin(num * 2 * M_PI)*num2;
num = rand()*(1.0/RAND_MAX);//(rand ()&0x7fff) / ((float)0x7fff);
p->org[2] = org[2] + 15*num;
p->org[2] = org[2];
num = rand()*(1.0/RAND_MAX);//(rand ()&0x7fff) / ((float)0x7fff);
p->vel[0] = (num * 40) - 20;
num = rand()*(1.0/RAND_MAX);//(rand ()&0x7fff) / ((float)0x7fff);
p->vel[1] = (num * 40) - 20;
num = rand()*(1.0/RAND_MAX);//(rand ()&0x7fff) / ((float)0x7fff);
p->vel[2] = 65*num + 80;
}
}
//==========================================================================
//
// R_SunStaffTrail
//
//==========================================================================
void R_SunStaffTrail(vec3_t source, vec3_t dest)
{
int i;
vec3_t vec, dist;
float length, size;
particle_t *p;
VectorSubtract(dest, source, vec);
length = VectorNormalize(vec);
dist[0] = vec[0];
dist[1] = vec[1];
dist[2] = vec[2];
size = 10;
while(length > 0)
{
length -= size;
if((p = AllocParticle()) == NULL)
{
return;
}
p->die = cl.time+2;
p->ramp = rand()&3;
p->color = ramp6[(int)(p->ramp)];
p->type = pt_spit;
for(i = 0; i < 3; i++)
{
p->org[i] = source[i] + ((rand()&3)-2);
}
p->vel[0] = (rand()%10)-5;
p->vel[1] = (rand()%10)-5;
p->vel[2] = (rand()%10);
VectorAdd(source, dist, source);
}
}
void RiderParticle(int count, vec3_t origin)
{
int i, j;
particle_t *p;
float num;
float radius,angle;
VectorCopy(origin, rider_origin);
for (i=0 ; i<count ; i++)
{
p = AllocParticle();
if (!p)
return;
p->die = cl.time + 4;
p->color = 256+16+15;
p->type = pt_rd;
p->ramp = 0;
VectorCopy(origin,p->org);
//num = (rand ()&0x7fff) / ((float)0x7fff);
angle = (rand() % 360) / (2 * M_PI);
radius = 300 + rand() & 255;
p->org[0] += sin(angle) * radius;
p->org[1] += cos(angle) * radius;
p->org[2] += (rand() & 255) - 30;
p->vel[0] = (rand() & 255) - 127;
p->vel[1] = (rand() & 255) - 127;
p->vel[2] = (rand() & 255) - 127;
}
}
void GravityWellParticle(int count, vec3_t origin, int color)
{
int i, j;
particle_t *p;
float num;
float radius,angle;
VectorCopy(origin, rider_origin);
for (i=0 ; i<count ; i++)
{
p = AllocParticle();
if (!p)
return;
p->die = cl.time + 4;
p->color = color + (rand() & 15);
p->type = pt_gravwell;
p->ramp = 0;
VectorCopy(origin,p->org);
angle = (rand() % 360) / (2 * M_PI);
radius = 300 + rand() & 255;
p->org[0] += sin(angle) * radius;
p->org[1] += cos(angle) * radius;
p->org[2] += (rand() & 255) - 30;
p->vel[0] = (rand() & 255) - 127;
p->vel[1] = (rand() & 255) - 127;
p->vel[2] = (rand() & 255) - 127;
}
}
//==========================================================================
//
// R_RocketTrail
//
//==========================================================================
void R_RocketTrail (vec3_t start, vec3_t end, int type)
{
vec3_t vec, dist;
float len,size,lifetime;
int j;
particle_t *p;
static int tracercount;
VectorSubtract (end, start, vec);
len = VectorNormalize (vec);
dist[0] = vec[0];
dist[1] = vec[1];
dist[2] = vec[2];
size = 1;
lifetime = 2;
switch(type)
{
case 9: // Spit
break;
case 8: // Ice
size *= 5*3;
dist[0] *= 5*3;
dist[1] *= 5*3;
dist[2] *= 5*3;
break;
case rt_acidball: // Ice
size=5;
lifetime = .8;
break;
default:
size = 3;
dist[0] *= 3;
dist[1] *= 3;
dist[2] *= 3;
break;
}
while (len > 0)
{
len -= size;
p = AllocParticle();
if (!p)
return;
VectorCopy (vec3_origin, p->vel);
p->die = cl.time + lifetime;
switch(type)
{
case rt_rocket_trail: // rocket trail
p->ramp = (rand()&3);
p->color = ramp3[(int)p->ramp];
p->type = pt_fire;
for (j=0 ; j<3 ; j++)
p->org[j] = start[j] + ((rand()%6)-3);
break;
case rt_smoke: // smoke smoke
p->ramp = (rand()&3) + 2;
p->color = ramp3[(int)p->ramp];
p->type = pt_fire;
for (j=0 ; j<3 ; j++)
p->org[j] = start[j] + ((rand()%6)-3);
break;
case rt_blood: // blood
p->type = pt_slowgrav;
p->color = 134 + (rand()&7);
for (j=0 ; j<3 ; j++)
p->org[j] = start[j] + ((rand()%6)-3);
break;
case rt_tracer:;
case rt_tracer2:;// tracer
p->die = cl.time + 0.5;
p->type = pt_static;
if (type == 3)
p->color = 130 + (rand() & 6);
// p->color = 243 + (rand() & 3);
else
p->color = 230 + ((tracercount&4)<<1);
tracercount++;
VectorCopy (start, p->org);
if (tracercount & 1)
{
p->vel[0] = 30*vec[1];
p->vel[1] = 30*-vec[0];
}
else
{
p->vel[0] = 30*-vec[1];
p->vel[1] = 30*vec[0];
}
break;
case rt_slight_blood:// slight blood
p->type = pt_slowgrav;
p->color = 134 + (rand()&7);
for (j=0 ; j<3 ; j++)
p->org[j] = start[j] + ((rand()%6)-3);
len -= size;
break;
case rt_bloodshot:// bloodshot trail
p->type = pt_darken;
p->color = 136 + (rand()&5);
for (j=0 ; j<3 ; j++)
p->org[j] = start[j] + ((rand()&3)-2);
len -= size;
break;
case rt_voor_trail:// voor trail
p->color = 9*16 + 8 + (rand()&3);
p->type = pt_static;
p->die = cl.time + 0.3;
for (j=0 ; j<3 ; j++)
p->org[j] = start[j] + ((rand()&15)-8);
break;
case rt_fireball: // Fireball
p->ramp = rand()&3;
p->color = ramp4[(int)(p->ramp)];
p->type = pt_fireball;
for (j=0 ; j<3 ; j++)
p->org[j] = start[j] + ((rand()&3)-2);
p->org[2] += 2; // compensate for model
p->vel[0] = (rand() % 200) - 100;
p->vel[1] = (rand() % 200) - 100;
p->vel[2] = (rand() % 200) - 100;
break;
case rt_acidball: // Acid ball
p->ramp = rand()&3;
p->color = ramp10[(int)(p->ramp)];
p->type = pt_acidball;
p->die = cl.time + 0.5;
for (j=0 ; j<3 ; j++)
p->org[j] = start[j] + ((rand()&3)-2);
p->org[2] += 2; // compensate for model
p->vel[0] = (rand() % 40) - 20;
p->vel[1] = (rand() % 40) - 20;
p->vel[2] = (rand() % 40) - 20;
break;
case rt_ice: // Ice
p->ramp = rand()&3;
p->color = ramp5[(int)(p->ramp)];
p->type = pt_ice;
for (j=0 ; j<3 ; j++)
p->org[j] = start[j] + ((rand()&3)-2);
p->org[2] += 2; // compensate for model
p->vel[0] = (rand() % 16) - 8;
p->vel[1] = (rand() % 16) - 8;
p->vel[2] = (rand() % 20) - 40;
break;
case rt_spit: // Spit
p->ramp = rand()&3;
p->color = ramp6[(int)(p->ramp)];
p->type = pt_spit;
for (j=0 ; j<3 ; j++)
p->org[j] = start[j] + ((rand()&3)-2);
p->org[2] += 2; // compensate for model
p->vel[0] = (rand() % 10) - 5;
p->vel[1] = (rand() % 10) - 5;
p->vel[2] = (rand() % 10);
break;
case rt_spell: // Spell
p->ramp = rand()&3;
p->color = ramp6[(int)(p->ramp)];
p->type = pt_spell;
for (j=0 ; j<3 ; j++)
p->org[j] = start[j] + ((rand()&3)-2);
p->vel[0] = (rand() % 10) - 5;
p->vel[1] = (rand() % 10) - 5;
p->vel[2] = (rand() % 10);
p->vel[0] = vec[0]*-10;
p->vel[1] = vec[1]*-10;
p->vel[2] = vec[2]*-10;
break;
case rt_vorpal: // vorpal missile
p->type = pt_vorpal;
p->color = 44 + (rand()&3) + 256;
for (j=0 ; j<2 ; j++)
p->org[j] = start[j] + ((rand()%48)-24);
p->org[2] = start[2] + ((rand()&15)-8);
break;
case rt_setstaff: // set staff
p->type = pt_setstaff;
p->color = ramp9[0];
p->ramp = rand()&3;
for (j=0 ; j<2 ; j++)
p->org[j] = start[j] + ((rand()%6)-3);
p->org[2] = start[2] + ((rand()%10)-5);
p->vel[0] = (rand() &7) - 4;
p->vel[1] = (rand() &7) - 4;
break;
case rt_magicmissile: // magic missile
p->type = pt_magicmissile;
p->color = 148 + (rand()&11);
p->ramp = rand()&3;
for (j=0 ; j<2 ; j++)
p->org[j] = start[j] + ((rand()%48)-24);
p->org[2] = start[2] + ((rand()%48)-24);
p->vel[2] = -((rand()&15)+8);
break;
case rt_boneshard: // bone shard
p->type = pt_boneshard;
p->color = 368 + (rand()&16);
for (j=0 ; j<2 ; j++)
p->org[j] = start[j] + ((rand()%48)-24);
p->org[2] = start[2] + ((rand()%48)-24);
p->vel[2] = -((rand()&15)+8);
break;
case rt_scarab: // scarab staff
p->type = pt_scarab;
p->color = 250 + (rand()&3);
for (j=0 ; j<3 ; j++)
p->org[j] = start[j] + (rand()&7);
p->vel[2] = -(rand()&7);
break;
}
VectorAdd (start, dist, start);
}
}
/*
===============
R_RainEffect
===============
*/
void R_RainEffect (vec3_t org,vec3_t e_size,int x_dir, int y_dir,int color,int count)
{
int i,holdint;
particle_t *p;
float z_time;
for (i=0 ; i<count ; i++)
{
p = AllocParticle();
if (!p)
return;
p->vel[0] = x_dir; //X and Y motion
p->vel[1] = y_dir;
p->vel[2] = -((rand()% 956)) ;
if (p->vel[2] > -256)
{
p->vel[2] += -256;
}
z_time = -(e_size[2]/p->vel[2]);
p->color = color;
p->die = cl.time + z_time;
p->ramp = (rand()&3);
//p->veer = veer;
p->type = pt_rain;
holdint=e_size[0];
p->org[0] = org[0] + (rand() % holdint);
holdint=e_size[1];
p->org[1] = org[1] + (rand() % holdint);
p->org[2] = org[2];
}
}
/*
===============
R_SnowEffect
MG
===============
*/
void R_SnowEffect (vec3_t org1,vec3_t org2,int flags,vec3_t alldir,int count)
{
int i,j,holdint;
particle_t *p;
mleaf_t *l;
count *= Cvar_VariableValue("snow_active");
for (i=0 ; i<count ; i++)
{
p = AllocParticle();
if (!p)
return;
p->vel[0] = alldir[0]; //X and Y motion
p->vel[1] = alldir[1];
p->vel[2] = alldir[2] * ((rand() & 15) + 7)/10;
p->flags = flags;
#ifdef GLQUAKE
if(rand()&0x7f<=1)//have a console variable 'happy_snow' that makes all snowflakes happy snow!
p->count = 69; //happy snow!
else if(flags & SFL_FLUFFY || (flags&SFL_MIXED && (rand()&3)))
p->count = (rand()&31)+10;//From 10 to 41 scale, will be divided
else
p->count = 10;
#else
if(flags & SFL_FLUFFY || (flags&SFL_MIXED && (rand()&3)))
p->count = (rand()&3)+2;//From 2 to 5 extra
else
p->count = 1; //Only one particle
#endif
if(flags&SFL_HALF_BRIGHT)//Start darker
p->color = 26 + (rand()%5);
else
p->color = 18 + (rand()%12);
if(!(flags&SFL_NO_TRANS))//Start translucent
p->color += 256;
p->die = cl.time + 7;
p->ramp = (rand()&3);
//p->veer = veer;
p->type = pt_snow;
holdint=org2[0] - org1[0];
p->org[0] = org1[0] + (rand() % holdint);
holdint=org2[1] - org1[1];
p->org[1] = org1[1] + (rand() % holdint);
p->org[2] = org2[2];
j=50;
l = Mod_PointInLeaf (p->org, cl.worldmodel);
// while(SV_PointContents(p->org)!=CONTENTS_EMPTY && j<50)
while(l->contents!=CONTENTS_EMPTY && j)
{//Make sure it doesn't start in a solid
holdint=org2[0] - org1[0];
p->org[0] = org1[0] + (rand() % holdint);
holdint=org2[1] - org1[1];
p->org[1] = org1[1] + (rand() % holdint);
j--;//No infinite loops
l = Mod_PointInLeaf (p->org, cl.worldmodel);
}
if(l->contents!=CONTENTS_EMPTY)
Sys_Error ("Snow entity top plane is not in an empty area (sorry!)");
VectorCopy(org1,p->min_org);
VectorCopy(org2,p->max_org);
}
}
/*
===============
R_ColoredParticleExplosion
===============
*/
void R_ColoredParticleExplosion (vec3_t org,int color,int radius,int counter)
{
int i, j;
particle_t *p;
for (i=0 ; i<counter ; i++)
{
p = AllocParticle();
if (!p)
return;
p->die = cl.time + 3;
p->color = color;
p->ramp = (rand()&3);
if (i & 1)
{
p->type = pt_c_explode;
for (j=0 ; j<3 ; j++)
{
p->org[j] = org[j] + ((rand()%(radius*2))-radius);
p->vel[j] = (rand()&511)-256;
}
}
else
{
p->type = pt_c_explode2;
for (j=0 ; j<3 ; j++)
{
p->org[j] = org[j] + ((rand()%(radius*2))-radius);
p->vel[j] = (rand()&511)-256;
}
}
}
}
/*
===============
R_DrawParticles
===============
*/
extern cvar_t sv_gravity;
void R_DrawParticles (void)
{
particle_t *p, *kill;
int i;
float vel0, vel1, vel2;
vec3_t save_org;
#ifdef GLQUAKE
float scale;
GL_Bind(particletexture);
glEnable (GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glBegin (GL_TRIANGLES);
VectorScale (vup, 1.5, r_pup);
VectorScale (vright, 1.5, r_pright);
#else
VectorScale (vright, xscaleshrink, r_pright);
VectorScale (vup, yscaleshrink, r_pup);
VectorCopy (vpn, r_ppn);
#endif
for ( ;; )
{
kill = active_particles;
if (kill && kill->die < cl.time)
{
active_particles = kill->next;
kill->next = free_particles;
free_particles = kill;
continue;
}
break;
}
for (p=active_particles ; p ; p=p->next)
{
for ( ;; )
{
kill = p->next;
if (kill && kill->die < cl.time)
{
p->next = kill->next;
kill->next = free_particles;
free_particles = kill;
continue;
}
break;
}
if (p->type==pt_rain)
{
#ifdef GLQUAKE
// hack a scale up to keep particles from disapearing
scale = (p->org[0] - r_origin[0])*vpn[0] + (p->org[1] - r_origin[1])*vpn[1]
+ (p->org[2] - r_origin[2])*vpn[2];
if (scale < 20)
scale = 1;
else
scale = 1 + scale * 0.004;
if (p->color <= 255)
glColor3ubv ((byte *)&d_8to24table[(int)p->color]);
else
glColor4ubv ((byte *)&d_8to24TranslucentTable[(int)p->color-256]);
//fixme: need rain texture
glTexCoord2f (1,0);
glVertex3fv (p->org);
glTexCoord2f (1,0.5);
glVertex3f (p->org[0] + r_pup[0]*scale, p->org[1] + r_pup[1]*scale, p->org[2] + r_pup[2]*scale);
glTexCoord2f (0.5,0);
glVertex3f (p->org[0] + r_pright[0]*scale, p->org[1] + r_pright[1]*scale, p->org[2] + r_pright[2]*scale);
#else
VectorCopy(p->org,save_org);
vel0 = p->vel[0]*.001;
vel1 = p->vel[1]*.001;
vel2 = p->vel[2]*.001;
for(i=0;i<4;i++)
{
D_DrawParticle(p);
p->org[0] += vel0;
p->org[1] += vel1;
p->org[2] += vel2;
}
D_DrawParticle(p);
VectorCopy(save_org,p->org);//Restore origin
#endif
}
else if (p->type==pt_snow)
{
#ifdef GLQUAKE
//IDEA: Put a snowflake texture on two-sided poly
//texture comes from glrmisc.c: R_InitParticleTexture
scale = (p->org[0] - r_origin[0])*vpn[0] + (p->org[1] - r_origin[1])*vpn[1]
+ (p->org[2] - r_origin[2])*vpn[2];
if (scale < 20)
scale = p->count/10;
else
scale = p->count/10 + scale * 0.004;
if (p->color <= 255)
glColor3ubv ((byte *)&d_8to24table[(int)p->color]);
else
glColor4ubv ((byte *)&d_8to24TranslucentTable[(int)p->color-256]);
if(p->count>=69)
glTexCoord2f (1,1);//happy snow!- bottom right
else if(p->count>=40)
glTexCoord2f (0,0); //normal snow - top left
else if(p->count>=30)
glTexCoord2f (0,1); //bottom left
else
glTexCoord2f (1,0); //top right
glVertex3fv (p->org);
if(p->count>=69)
glTexCoord2f (1,.18);//top right
else if(p->count>=40)
glTexCoord2f (.815,0);//top right
else if(p->count>=30)
glTexCoord2f (0.5,1);//bottom middle
else
glTexCoord2f (1,0.5);//middle right
glVertex3f (p->org[0] + r_pup[0]*scale, p->org[1] + r_pup[1]*scale, p->org[2] + r_pup[2]*scale);
if(p->count>=69)
glTexCoord2f (.18,1);//bottom left
else if(p->count>=40)
glTexCoord2f (0,.815);//bottom left
else if(p->count>=30)
glTexCoord2f (0,0.5);//left middle
else
glTexCoord2f (0.5,0);//middle top
glVertex3f (p->org[0] + r_pright[0]*scale, p->org[1] + r_pright[1]*scale, p->org[2] + r_pright[2]*scale);
#else
VectorCopy(p->org,save_org);
D_DrawParticle (p);
for(i=1;i<p->count;i++)
{
switch(i)
{//FIXME: More translucency on outside particles?
// case 0: //original
// break;
case 1: //One to right
p->org[0] = save_org[0] + vright[0];
p->org[1] = save_org[1] + vright[1];
p->org[2] = save_org[2] + vright[2];
break;
case 2: //One above
p->org[0] = save_org[0] + vup[0];
p->org[1] = save_org[1] + vup[1];
p->org[2] = save_org[2] + vup[2];
break;
case 3: //One to left
p->org[0] = save_org[0] - vright[0];
p->org[1] = save_org[1] - vright[1];
p->org[2] = save_org[2] - vright[2];
break;
case 4: //One below
p->org[0] = save_org[0] - vup[0];
p->org[1] = save_org[1] - vup[1];
p->org[2] = save_org[2] - vup[2];
break;
default:
Con_Printf ("count too big!\n");
break;
}
D_DrawParticle (p);
}
VectorCopy(save_org,p->org);//Restore origin
#endif
}
else
{
#ifdef GLQUAKE
// hack a scale up to keep particles from disapearing
scale = (p->org[0] - r_origin[0])*vpn[0] + (p->org[1] - r_origin[1])*vpn[1]
+ (p->org[2] - r_origin[2])*vpn[2];
if (scale < 20)
scale = 1;
else
scale = 1 + scale * 0.004;
if (p->color <= 255)
glColor3ubv ((byte *)&d_8to24table[(int)p->color]);
else
glColor4ubv ((byte *)&d_8to24TranslucentTable[(int)p->color-256]);
glTexCoord2f (1,0);
glVertex3fv (p->org);
glTexCoord2f (1,0.5);
glVertex3f (p->org[0] + r_pup[0]*scale, p->org[1] + r_pup[1]*scale, p->org[2] + r_pup[2]*scale);
glTexCoord2f (0.5,0);
glVertex3f (p->org[0] + r_pright[0]*scale, p->org[1] + r_pright[1]*scale, p->org[2] + r_pright[2]*scale);
#else
D_DrawParticle (p);
#endif
}
}
#ifdef GLQUAKE
glEnd ();
glDisable (GL_BLEND);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
#endif
}
void R_UpdateParticles (void)
{
particle_t *p, *kill;
float grav,grav2,percent,speed;
int i,j;
qboolean in_solid;
float time2, time3, time4;
float time1;
float dvel;
float frametime;
float vel0, vel1, vel2;
float colindex;
vec3_t diff,save_org;
if (cls.state == ca_disconnected)
return;
frametime = cl.time - cl.oldtime;
// Con_Printf("%10.5f\n",frametime);
time4 = frametime * 20;
time3 = frametime * 15;
time2 = frametime * 10;
time1 = frametime * 5;
grav = frametime * sv_gravity.value * 0.05;
grav2 = frametime * sv_gravity.value * 0.025;
dvel = 4*frametime;
percent = (frametime / HX_FRAME_TIME);
for ( ;; )
{
kill = active_particles;
if (kill && kill->die < cl.time)
{
active_particles = kill->next;
kill->next = free_particles;
free_particles = kill;
continue;
}
break;
}
for (p=active_particles ; p ; p=p->next)
{
for ( ;; )
{
kill = p->next;
if (kill && kill->die < cl.time)
{
p->next = kill->next;
kill->next = free_particles;
free_particles = kill;
continue;
}
break;
}
if (p->type==pt_rain)
{
vel0 = p->vel[0]*.001;
vel1 = p->vel[1]*.001;
vel2 = p->vel[2]*.001;
for(i=0;i<4;i++)
{
p->org[0] += vel0;
p->org[1] += vel1;
p->org[2] += vel2;
}
p->org[0] += p->vel[0]*(frametime-.004);
p->org[1] += p->vel[1]*(frametime-.004);
p->org[2] += p->vel[2]*(frametime-.004);
}
else if (p->type==pt_snow)
{
if(p->vel[0]==0&&p->vel[1]==0&&p->vel[2]==0)
{//Stopped moving
if(p->color==256+31)//Most translucent white
{//Go away
p->die=-1;
}
else
{//Count fifty and fade in translucency once each time
p->ramp+=1;
if(p->ramp>=7)
{
p->color+=1;//Get more translucent
p->ramp=0;
}
}
}
else
{//FIXME: If flake going fast enough, can go through, do a check in increments ot 10, max?
//if not in_bounds Get length of diff, add in increments of 4 & check solid
mleaf_t *l;
if (Cvar_VariableValue("snow_flurry")==1)
if(rand()&31)
{//Add flurry movement
float snow_speed;
vec3_t save_vel;
snow_speed = p->vel[0] * p->vel[0] + p->vel[1] * p->vel[1] + p->vel[2]*p->vel[2];
snow_speed = sqrt(snow_speed);
VectorCopy(p->vel,save_vel);
save_vel[0] += ( (rand()*(2.0/RAND_MAX)) - 1)*30;
save_vel[1] += ( (rand()*(2.0/RAND_MAX)) - 1)*30;
if((rand()&7)||p->vel[2]>10)
save_vel[2] += ( (rand()*(2.0/RAND_MAX)) - 1)*30;
VectorNormalize(save_vel);
VectorScale(save_vel,snow_speed,p->vel);//retain speed but use new dir
}
/* VectorScale(p->vel,frametime,diff);
speed = VectorNormalize(diff);
in_solid=false;
if(!(p->flags&SFL_IN_BOUNDS))
{//Not cut off by bounds
if(speed>=8)
{//Moving more than 8 pixels this turn
for(i=4;i<speed;i+=4)
{//Check for solid in increments of 4
VectorScale(diff,i,save_org);
VectorAdd(p->org,save_org,save_org);
// if(SV_PointContents(save_org)!=CONTENTS_EMPTY)
l = Mod_PointInLeaf (save_org, cl.worldmodel);
if (l->contents!=CONTENTS_EMPTY)
{
in_solid=true;
VectorCopy(save_org,p->org);
break;
}
}
}
}
*/
// if(!in_solid)
{
VectorScale(p->vel,frametime,diff);
VectorAdd(p->org,diff,p->org);
}
if(p->flags&SFL_IN_BOUNDS)
{//Always stay inside the boundry!
if(p->org[0]<p->min_org[0]||p->org[0]>p->max_org[0]||
p->org[1]<p->min_org[1]||p->org[1]>p->max_org[1]||
p->org[2]<p->min_org[2]||p->org[2]>p->max_org[2])
{
p->die=-1;
}
}
else
{
//IF hit solid, go to last position, no velocity, fade out.
l = Mod_PointInLeaf (p->org, cl.worldmodel);
if(l->contents!=CONTENTS_EMPTY) //||in_solid==true
{
if(p->flags&SFL_NO_MELT)
{//Don't melt, just die
p->die=-1;
}
else
{//still have small prob of snow melting on emitter
VectorScale(diff,0.2,p->vel);
i=6;
while(l->contents!=CONTENTS_EMPTY )
{
p->org[0] -= p->vel[0];
p->org[1] -= p->vel[1];
p->org[2] -= p->vel[2];
i--;//no infinite loops
if (!i)
{
p->die=-1; //should never happen now!
break;
}
l = Mod_PointInLeaf (p->org, cl.worldmodel);
}
p->vel[0]=p->vel[1]=p->vel[2]=0;
p->ramp=0;
}
}
}
}
}
else
{
p->org[0] += p->vel[0]*frametime;
p->org[1] += p->vel[1]*frametime;
p->org[2] += p->vel[2]*frametime;
}
switch (p->type)
{
case pt_static:
break;
case pt_fire:
p->ramp += time1;
if ((int)p->ramp >= 6)
{
p->die = -1;
}
else
{
p->color = ramp3[(int)p->ramp];
}
p->vel[2] += grav;
break;
case pt_explode:
p->ramp += time2;
if ((int)p->ramp >=8)
{
p->die = -1;
}
else
{
p->color = ramp1[(int)p->ramp];
}
for (i=0 ; i<3 ; i++)
{
p->vel[i] += p->vel[i]*dvel;
}
p->vel[2] -= grav;
break;
case pt_explode2:
p->ramp += time3;
if ((int)p->ramp >=8)
{
p->die = -1;
}
else
{
p->color = ramp2[(int)p->ramp];
}
for (i=0 ; i<3 ; i++)
{
p->vel[i] -= p->vel[i]*frametime;
}
p->vel[2] -= grav;
break;
case pt_c_explode:
p->ramp += time2;
if ((int)p->ramp >=8)
{
p->die = -1;
}
else if (time2)
{
p->color--;
}
for (i=0 ; i<3 ; i++)
{
p->vel[i] += p->vel[i]*dvel;
}
p->vel[2] -= grav;
break;
case pt_c_explode2:
p->ramp += time3;
if ((int)p->ramp >=8)
{
p->die = -1;
}
else if (time3)
{
p->color -= 2;
}
for (i=0 ; i<3 ; i++)
{
p->vel[i] -= p->vel[i]*frametime;
}
p->vel[2] -= grav;
break;
/* //jfm:not used
case pt_blob:
for (i=0 ; i<3 ; i++)
{
p->vel[i] += p->vel[i]*dvel;
}
p->vel[2] -= grav;
break;
case pt_blob2:
for (i=0 ; i<2 ; i++)
{
p->vel[i] -= p->vel[i]*dvel;
}
p->vel[2] -= grav;
break;
*/
case pt_grav:
#ifdef QUAKE2
p->vel[2] -= grav * 20;
break;
#endif
case pt_slowgrav:
p->vel[2] -= grav;
break;
case pt_fastgrav:
p->vel[2] -= grav*4;
break;
case pt_rain:
break;
case pt_snow:
break;
case pt_fireball:
p->ramp += time3;
if ((int)p->ramp >= 16)
{
p->die = -1;
}
else
{
p->color = ramp4[(int)p->ramp];
}
break;
case pt_acidball:
p->ramp += time4*1.4;
if ((int)p->ramp >= 23)
{
p->die = -1;
}
else if ((int)p->ramp >= 15)
{
p->color = ramp11[(int)p->ramp - 15];
}
else
{
p->color = ramp10[(int)p->ramp];
}
p->vel[2] -= grav;
break;
case pt_spit:
p->ramp += time3;
if ((int)p->ramp >= 16)
{
p->die = -1;
}
else
{
p->color = ramp6[(int)p->ramp];
}
// p->vel[2] += grav*2;
break;
case pt_ice:
p->ramp += time4;
if ((int)p->ramp >= 16)
{
p->die = -1;
}
else
{
p->color = ramp5[(int)p->ramp];
}
p->vel[2] -= grav;
break;
case pt_spell:
p->ramp += time2;
if ((int)p->ramp >= 16)
{
p->die = -1;
}
else
{
p->color = ramp7[(int)p->ramp];
}
// p->vel[2] += grav*2;
break;
case pt_test:
p->vel[2] += 1.3;
p->ramp += time3;
if ((int)p->ramp >= 13 || ((int)p->ramp > 10 && (int)p->vel[2] < 20) )
{
p->die = -1;
}
else
{
p->color = ramp8[(int)p->ramp];
}
break;
case pt_quake:
p->vel[0] *= 1.05;
p->vel[1] *= 1.05;
p->vel[2] -= grav*4;
break;
case pt_rd:
if (!frametime)
{
break;
}
p->ramp += percent;
if ((int)p->ramp > 50)
{
p->ramp = 50;
p->die = -1;
}
p->color = 256+16+16 - (p->ramp/(50/16));
VectorSubtract(rider_origin, p->org, diff);
/* p->org[0] += diff[0] * p->ramp / 80;
p->org[1] += diff[1] * p->ramp / 80;
p->org[2] += diff[2] * p->ramp / 80;
*/
vel0 = 1 / (51 - p->ramp);
p->org[0] += diff[0] * vel0;
p->org[1] += diff[1] * vel0;
p->org[2] += diff[2] * vel0;
break;
case pt_gravwell:
if (!frametime)
{
break;
}
p->ramp += percent;
if ((int)p->ramp > 35)
{
p->ramp = 35;
p->die = -1;
}
VectorSubtract(rider_origin, p->org, diff);
/* p->org[0] += diff[0] * p->ramp / 80;
p->org[1] += diff[1] * p->ramp / 80;
p->org[2] += diff[2] * p->ramp / 80;
*/
vel0 = 1 / (36 - p->ramp);
p->org[0] += diff[0] * vel0;
p->org[1] += diff[1] * vel0;
p->org[2] += diff[2] * vel0;
break;
case pt_vorpal:
--p->color;
if ((int)p->color <= 37 + 256)
{
p->die = -1;
}
break;
case pt_setstaff:
p->ramp += time1;
if ((int)p->ramp >= 16)
{
p->die = -1;
}
else
{
p->color = ramp9[(int)p->ramp];
}
p->vel[0] *= 1.08 * percent;
p->vel[1] *= 1.08 * percent;
p->vel[2] -= grav2;
break;
case pt_redfire:
p->ramp += frametime*3;
if ((int)p->ramp >= 8)
{
p->die = -1;
}
else
{
p->color = ramp12[(int)p->ramp]+256;
}
p->vel[0] *= .9;
p->vel[1] *= .9;
p->vel[2] += grav/2;
break;
case pt_magicmissile:
--p->color;
if ((int)p->color < 149)
{
p->color = 149;
}
p->ramp += time1;
if ((int)p->ramp > 16)
{
p->die = -1;
}
break;
case pt_boneshard:
--p->color;
if ((int)p->color < 368)
{
p->die = -1;
}
break;
case pt_scarab:
--p->color;
if ((int)p->color < 250)
{
p->die = -1;
}
break;
case pt_darken:
p->vel[2] -= grav; //Also gravity
--p->color;
colindex=0;
while(colindex<224)
{
if(colindex==192 || colindex == 200)
{
colindex+=8;
}
else
{
colindex+=16;
}
if (p->color==colindex)
{
p->die = -1;
}
}
break;
}
}
}
/*
* $Log: /H2 Mission Pack/R_PART.C $
*
* 54 4/01/98 6:43p Jmonroe
* fixed boundschecker errors
*
* 53 3/30/98 10:57a Jmonroe
*
* 52 3/13/98 3:59p Jmonroe
*
* 51 3/10/98 12:21a Mgummelt
*
* 50 3/09/98 11:24p Mgummelt
*
* 49 3/09/98 9:40p Mgummelt
*
* 48 3/06/98 6:10p Jweier
*
* 47 3/06/98 2:41p Jmonroe
* fixed ricks goof, just took out the extra call
*
* 46 3/06/98 2:14p Jmonroe
*
* 45 3/05/98 7:54p Jmonroe
* fixed startRain, optimized particle struct
*
* 44 3/05/98 2:56p Rjohnson
* Fixed rain
*
* 43 3/04/98 4:24p Mgummelt
*
* 42 3/02/98 11:04p Jmonroe
* changed start sound back to byte, added stopsound, put in a hack fix
* for touchtriggers area getting removed
*
* 41 3/01/98 8:20p Jmonroe
* removed the slow "quake" version of common functions
*
* 40 2/27/98 5:17p Mgummelt
*
* 39 2/26/98 5:10p Mgummelt
*
* 38 2/25/98 10:42p Mgummelt
*
* 37 2/25/98 9:38p Jweier
*
* 36 2/13/98 4:49p Jmonroe
* added variable snow
*
* 35 2/11/98 5:19p Jmonroe
*
* 34 2/11/98 12:57p Jmonroe
*
* 33 2/10/98 11:04a Jmonroe
* added snow_active and snow_flurry to test out snow speeds.
*
* 32 2/09/98 5:11p Jweier
*
* 31 2/08/98 5:26p Mgummelt
*
* 30 2/08/98 4:28p Mgummelt
*
* 29 2/06/98 7:06p Mgummelt
*
* 28 2/06/98 4:47p Mgummelt
*
* 27 2/06/98 11:57a Mgummelt
*
* 26 2/05/98 11:25p Jweier
*
* 25 2/02/98 10:28a Mgummelt
*
* 24 1/29/98 6:34p Mgummelt
*
* 23 1/28/98 12:23p Jmonroe
* reduced snow flury chance
*
* 22 1/26/98 4:39p Plipo
*
* 21 1/22/98 9:03p Jmonroe
* many more speed improvements in software snow
*
* 20 1/22/98 5:44p Jmonroe
* removed the div in snow flury
*
* 19 1/20/98 5:55p Jmonroe
* speed up on snow.
* still can do more by reducing flurry algo complexity
*
* 18 1/15/98 10:04p Jmonroe
* added stub mpack menu stuff
*
* 17 1/15/98 6:37p Jmonroe
*
* 16 1/15/98 1:20p Jmonroe
* enlarged the snowflake
*
* 15 1/15/98 12:04p Jmonroe
*
* 14 1/15/98 12:02p Jmonroe
* added snowflake texture
*
* 13 1/14/98 5:43p Mgummelt
*
* 40 9/19/97 8:47a Rlove
*
* 39 9/18/97 2:34p Rlove
*
* 38 9/18/97 12:44p Rlove
*
* 37 9/17/97 1:27p Rlove
*
* 36 9/17/97 11:11a Rlove
*
* 35 8/31/97 3:45p Rjohnson
* Memory changes
*
* 34 8/26/97 8:17a Rjohnson
* Just a few changes
*
* 33 8/08/97 3:50p Rlove
* Changed blood particles to match our pallette
*
* 32 8/05/97 11:47a Rlove
* Changed the color for the rt_tracer particle
*
* 31 7/30/97 1:50p Rjohnson
* Fix for particle explosion
*
* 30 7/15/97 4:09p Rjohnson
* New particle effect
*
* 29 6/12/97 9:02a Rlove
* New vorpal particle effect
*
* 28 6/02/97 3:42p Gmctaggart
* GL Catchup
*
* 27 5/30/97 11:42a Rjohnson
* Added new effect type for the rider's death
*
* 26 5/23/97 3:05p Rjohnson
* Update to effects / particle types
*
* 25 5/23/97 2:46p Bgokey
*
* 24 5/23/97 12:23p Bgokey
*
* 23 5/20/97 11:19a Bgokey
*
* 22 4/28/97 2:50p Rlove
* Little change to rain
*
* 21 4/28/97 11:58a Mgummelt
*
* 20 4/22/97 3:50p Rjohnson
* Added some more particle commands to cut back on the networking
*
* 19 4/18/97 5:40p Rjohnson
* Fixed a bug - wasn't clearing out the ramp value for particle2effect
*
* 18 4/17/97 5:39p Rjohnson
* Added a test particle type
*
* 17 4/04/97 4:10p Rjohnson
* Added proper transparent particles for the gl version
*
* 16 3/12/97 10:58p Rjohnson
* Revised the particle2 hexen-c command to allow a range for the velocity
* - shouldn't be as taxing on the network to get better effects
*
* 15 3/07/97 2:12p Rjohnson
* Id Updates
*
* 14 3/07/97 12:06p Rjohnson
* Added new spell particle effect
*
* 13 2/20/97 12:13p Rjohnson
* Code fixes for id update
*
* 12 2/18/97 3:32p Rjohnson
* Id Updates
*
* 11 1/02/97 11:16a Rjohnson
* Christmas work - added adaptive time, game delays, negative light,
* particle effects, etc
*
* 10 12/11/96 10:44a Rjohnson
* Added the new ice particle effect
*
* 9 12/09/96 12:27p Rjohnson
* Modifications to the fireball as well as fixed how particles are
* distributes through a frame
*
* 8 12/06/96 2:00p Rjohnson
* New particle type for the fireball
*
* 7 11/20/96 2:10p Rjohnson
* Added transparency to the particles, made the particles that spit out
* when you attack the wall transparent as well.
*
* 6 11/19/96 11:40a Rlove
* Particle explosion entity
*
* 5 11/15/96 8:03a Rlove
* No longer get rain particles coming down in a solid block.
*
* 4 11/14/96 3:33p Rjohnson
* Added the "leak_color" console variable - allows them to specify the
* color of the particles for the leaks
*/
Reference in a new issue Copy permalink