![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cl_fx.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake II] / quake2 / client|
Return to cl_fx.c CVS log | Up to [Quake II] / quake2 / client |
1.1 root 1: // cl_fx.c -- entity effects parsing and management
2: #include "client.h"
3: void CL_LogoutEffect (vec3_t org, int type);
4: void CL_ItemRespawnParticles (vec3_t org);
5: static vec3_t avelocities [NUMVERTEXNORMALS];
6:
7: extern struct model_s *cl_mod_smoke;
8: extern struct model_s *cl_mod_flash;
9: /*
10: ==============================================================
11: LIGHT STYLE MANAGEMENT
12: ==============================================================
13: */
14: typedef struct
15: {
16: int length;
17: float value[3];
18: float map[MAX_QPATH];
19: } clightstyle_t;
20: clightstyle_t cl_lightstyle[MAX_LIGHTSTYLES];
21: int lastofs;
22: /*
23: ================
24: CL_ClearLightStyles
25: ================
26: */
27: void CL_ClearLightStyles (void)
28: {
29: memset (cl_lightstyle, 0, sizeof(cl_lightstyle));
30: lastofs = -1;
31: }
32: /*
33: ================
34: CL_RunLightStyles
35: ================
36: */
37: void CL_RunLightStyles (void)
38: {
39: int ofs;
40: int i;
41: clightstyle_t *ls;
42: ofs = cl.time / 100;
43: if (ofs == lastofs)
44: return;
45: lastofs = ofs;
46: for (i=0,ls=cl_lightstyle ; i<MAX_LIGHTSTYLES ; i++, ls++)
47: {
48: if (!ls->length)
49: {
50: ls->value[0] = ls->value[1] = ls->value[2] = 1.0;
51: continue;
52: }
53: if (ls->length == 1)
54: ls->value[0] = ls->value[1] = ls->value[2] = ls->map[0];
55: else
56: ls->value[0] = ls->value[1] = ls->value[2] = ls->map[ofs%ls->length];
57: }
58: }
59: void CL_SetLightstyle (int i)
60: {
61: char *s;
62: int j, k;
63: s = cl.configstrings[i+CS_LIGHTS];
64: j = strlen (s);
65: if (j >= MAX_QPATH)
66: Com_Error (ERR_DROP, "svc_lightstyle length=%i", j);
67: cl_lightstyle[i].length = j;
68: for (k=0 ; k<j ; k++)
69: cl_lightstyle[i].map[k] = (float)(s[k]-'a')/(float)('m'-'a');
70: }
71: /*
72: ================
73: CL_AddLightStyles
74: ================
75: */
76: void CL_AddLightStyles (void)
77: {
78: int i;
79: clightstyle_t *ls;
80: for (i=0,ls=cl_lightstyle ; i<MAX_LIGHTSTYLES ; i++, ls++)
81: V_AddLightStyle (i, ls->value[0], ls->value[1], ls->value[2]);
82: }
83: /*
84: ==============================================================
85: DLIGHT MANAGEMENT
86: ==============================================================
87: */
88: cdlight_t cl_dlights[MAX_DLIGHTS];
89: /*
90: ================
91: CL_ClearDlights
92: ================
93: */
94: void CL_ClearDlights (void)
95: {
96: memset (cl_dlights, 0, sizeof(cl_dlights));
97: }
98: /*
99: ===============
100: CL_AllocDlight
101: ===============
102: */
103: cdlight_t *CL_AllocDlight (int key)
104: {
105: int i;
106: cdlight_t *dl;
107: // first look for an exact key match
108: if (key)
109: {
110: dl = cl_dlights;
111: for (i=0 ; i<MAX_DLIGHTS ; i++, dl++)
112: {
113: if (dl->key == key)
114: {
115: memset (dl, 0, sizeof(*dl));
116: dl->key = key;
117: return dl;
118: }
119: }
120: }
121: // then look for anything else
122: dl = cl_dlights;
123: for (i=0 ; i<MAX_DLIGHTS ; i++, dl++)
124: {
125: if (dl->die < cl.time)
126: {
127: memset (dl, 0, sizeof(*dl));
128: dl->key = key;
129: return dl;
130: }
131: }
132: dl = &cl_dlights[0];
133: memset (dl, 0, sizeof(*dl));
134: dl->key = key;
135: return dl;
136: }
137: /*
138: ===============
139: CL_NewDlight
140: ===============
141: */
142: void CL_NewDlight (int key, float x, float y, float z, float radius, float time)
143: {
144: cdlight_t *dl;
145: dl = CL_AllocDlight (key);
146: dl->origin[0] = x;
147: dl->origin[1] = y;
148: dl->origin[2] = z;
149: dl->radius = radius;
150: dl->die = cl.time + time;
151: }
152: /*
153: ===============
154: CL_RunDLights
155: ===============
156: */
157: void CL_RunDLights (void)
158: {
159: int i;
160: cdlight_t *dl;
161: dl = cl_dlights;
162: for (i=0 ; i<MAX_DLIGHTS ; i++, dl++)
163: {
164: if (!dl->radius)
165: continue;
166:
167: if (dl->die < cl.time)
168: {
169: dl->radius = 0;
170: return;
171: }
172: dl->radius -= cls.frametime*dl->decay;
173: if (dl->radius < 0)
174: dl->radius = 0;
175: }
176: }
177: /*
178: ==============
179: CL_ParseMuzzleFlash
180: ==============
181: */
182: void CL_ParseMuzzleFlash (void)
183: {
184: vec3_t fv, rv;
185: cdlight_t *dl;
186: int i, weapon;
187: centity_t *pl;
188: int silenced;
189: float volume;
190: char soundname[64];
191: i = MSG_ReadShort (&net_message);
192: if (i < 1 || i >= MAX_EDICTS)
193: Com_Error (ERR_DROP, "CL_ParseMuzzleFlash: bad entity");
194:
195: weapon = MSG_ReadByte (&net_message);
196: silenced = weapon & MZ_SILENCED;
197: weapon &= ~MZ_SILENCED;
198: pl = &cl_entities[i];
199: dl = CL_AllocDlight (i);
200: VectorCopy (pl->current.origin, dl->origin);
201: AngleVectors (pl->current.angles, fv, rv, NULL);
202: VectorMA (dl->origin, 18, fv, dl->origin);
203: VectorMA (dl->origin, 16, rv, dl->origin);
204: if (silenced)
205: dl->radius = 100 + (rand()&31);
206: else
207: dl->radius = 200 + (rand()&31);
208: dl->minlight = 32;
209: dl->die = cl.time; // + 0.1;
210: if (silenced)
211: volume = 0.2;
212: else
213: volume = 1;
214: switch (weapon)
215: {
216: case MZ_BLASTER:
217: dl->color[0] = 1;dl->color[1] = 1;dl->color[2] = 0;
218: S_StartSound (NULL, i, CHAN_WEAPON, S_RegisterSound("weapons/blastf1a.wav"), volume, ATTN_NORM, 0);
219: break;
220: case MZ_HYPERBLASTER:
221: dl->color[0] = 1;dl->color[1] = 1;dl->color[2] = 0;
222: S_StartSound (NULL, i, CHAN_WEAPON, S_RegisterSound("weapons/hyprbf1a.wav"), volume, ATTN_NORM, 0);
223: break;
224: case MZ_MACHINEGUN:
225: dl->color[0] = 1;dl->color[1] = 1;dl->color[2] = 0;
226: Com_sprintf(soundname, sizeof(soundname), "weapons/machgf%ib.wav", (rand() % 5) + 1);
227: S_StartSound (NULL, i, CHAN_WEAPON, S_RegisterSound(soundname), volume, ATTN_NORM, 0);
228: break;
229: case MZ_SHOTGUN:
230: dl->color[0] = 1;dl->color[1] = 1;dl->color[2] = 0;
231: S_StartSound (NULL, i, CHAN_WEAPON, S_RegisterSound("weapons/shotgf1b.wav"), volume, ATTN_NORM, 0);
232: S_StartSound (NULL, i, CHAN_AUTO, S_RegisterSound("weapons/shotgr1b.wav"), volume, ATTN_NORM, 0.1);
233: break;
234: case MZ_SSHOTGUN:
235: dl->color[0] = 1;dl->color[1] = 1;dl->color[2] = 0;
236: S_StartSound (NULL, i, CHAN_WEAPON, S_RegisterSound("weapons/sshotf1b.wav"), volume, ATTN_NORM, 0);
237: break;
238: case MZ_CHAINGUN1:
239: dl->radius = 200 + (rand()&31);
240: dl->color[0] = 1;dl->color[1] = 0.25;dl->color[2] = 0;
241: Com_sprintf(soundname, sizeof(soundname), "weapons/machgf%ib.wav", (rand() % 5) + 1);
242: S_StartSound (NULL, i, CHAN_WEAPON, S_RegisterSound(soundname), volume, ATTN_NORM, 0);
243: break;
244: case MZ_CHAINGUN2:
245: dl->radius = 225 + (rand()&31);
246: dl->color[0] = 1;dl->color[1] = 0.5;dl->color[2] = 0;
247: dl->die = cl.time + 0.1; // long delay
248: Com_sprintf(soundname, sizeof(soundname), "weapons/machgf%ib.wav", (rand() % 5) + 1);
249: S_StartSound (NULL, i, CHAN_WEAPON, S_RegisterSound(soundname), volume, ATTN_NORM, 0);
250: Com_sprintf(soundname, sizeof(soundname), "weapons/machgf%ib.wav", (rand() % 5) + 1);
251: S_StartSound (NULL, i, CHAN_WEAPON, S_RegisterSound(soundname), volume, ATTN_NORM, 0.05);
252: break;
253: case MZ_CHAINGUN3:
254: dl->radius = 250 + (rand()&31);
255: dl->color[0] = 1;dl->color[1] = 1;dl->color[2] = 0;
256: dl->die = cl.time + 0.1; // long delay
257: Com_sprintf(soundname, sizeof(soundname), "weapons/machgf%ib.wav", (rand() % 5) + 1);
258: S_StartSound (NULL, i, CHAN_WEAPON, S_RegisterSound(soundname), volume, ATTN_NORM, 0);
259: Com_sprintf(soundname, sizeof(soundname), "weapons/machgf%ib.wav", (rand() % 5) + 1);
260: S_StartSound (NULL, i, CHAN_WEAPON, S_RegisterSound(soundname), volume, ATTN_NORM, 0.033);
261: Com_sprintf(soundname, sizeof(soundname), "weapons/machgf%ib.wav", (rand() % 5) + 1);
262: S_StartSound (NULL, i, CHAN_WEAPON, S_RegisterSound(soundname), volume, ATTN_NORM, 0.066);
263: break;
264: case MZ_RAILGUN:
265: dl->color[0] = 0.5;dl->color[1] = 0.5;dl->color[2] = 1.0;
266: S_StartSound (NULL, i, CHAN_WEAPON, S_RegisterSound("weapons/railgf1a.wav"), volume, ATTN_NORM, 0);
267: break;
268: case MZ_ROCKET:
269: dl->color[0] = 1;dl->color[1] = 0.5;dl->color[2] = 0.2;
270: S_StartSound (NULL, i, CHAN_WEAPON, S_RegisterSound("weapons/rocklf1a.wav"), volume, ATTN_NORM, 0);
271: S_StartSound (NULL, i, CHAN_AUTO, S_RegisterSound("weapons/rocklr1b.wav"), volume, ATTN_NORM, 0.1);
272: break;
273: case MZ_GRENADE:
274: dl->color[0] = 1;dl->color[1] = 0.5;dl->color[2] = 0;
275: S_StartSound (NULL, i, CHAN_WEAPON, S_RegisterSound("weapons/grenlf1a.wav"), volume, ATTN_NORM, 0);
276: S_StartSound (NULL, i, CHAN_AUTO, S_RegisterSound("weapons/grenlr1b.wav"), volume, ATTN_NORM, 0.1);
277: break;
278: case MZ_BFG:
279: dl->color[0] = 0;dl->color[1] = 1;dl->color[2] = 0;
280: S_StartSound (NULL, i, CHAN_WEAPON, S_RegisterSound("weapons/bfg__f1y.wav"), volume, ATTN_NORM, 0);
281: break;
282: case MZ_LOGIN:
283: dl->color[0] = 0;dl->color[1] = 1; dl->color[2] = 0;
284: dl->die = cl.time + 1.0;
285: S_StartSound (NULL, i, CHAN_WEAPON, S_RegisterSound("weapons/grenlf1a.wav"), 1, ATTN_NORM, 0);
286: CL_LogoutEffect (pl->current.origin, weapon);
287: break;
288: case MZ_LOGOUT:
289: dl->color[0] = 1;dl->color[1] = 0; dl->color[2] = 0;
290: dl->die = cl.time + 1.0;
291: S_StartSound (NULL, i, CHAN_WEAPON, S_RegisterSound("weapons/grenlf1a.wav"), 1, ATTN_NORM, 0);
292: CL_LogoutEffect (pl->current.origin, weapon);
293: break;
294: case MZ_RESPAWN:
295: dl->color[0] = 1;dl->color[1] = 1; dl->color[2] = 0;
296: dl->die = cl.time + 1.0;
297: S_StartSound (NULL, i, CHAN_WEAPON, S_RegisterSound("weapons/grenlf1a.wav"), 1, ATTN_NORM, 0);
298: CL_LogoutEffect (pl->current.origin, weapon);
299: break;
300: }
301: }
302: /*
303: ==============
304: CL_ParseMuzzleFlash2
305: ==============
306: */
307: void CL_ParseMuzzleFlash2 (void)
308: {
309: int ent;
310: vec3_t origin;
311: int flash_number;
312: cdlight_t *dl;
313: vec3_t forward, right;
314: char soundname[64];
315: ent = MSG_ReadShort (&net_message);
316: if (ent < 1 || ent >= MAX_EDICTS)
317: Com_Error (ERR_DROP, "CL_ParseMuzzleFlash2: bad entity");
318: flash_number = MSG_ReadByte (&net_message);
319: // locate the origin
320: AngleVectors (cl_entities[ent].current.angles, forward, right, NULL);
321: origin[0] = cl_entities[ent].current.origin[0] + forward[0] * monster_flash_offset[flash_number][0] + right[0] * monster_flash_offset[flash_number][1];
322: origin[1] = cl_entities[ent].current.origin[1] + forward[1] * monster_flash_offset[flash_number][0] + right[1] * monster_flash_offset[flash_number][1];
323: origin[2] = cl_entities[ent].current.origin[2] + forward[2] * monster_flash_offset[flash_number][0] + right[2] * monster_flash_offset[flash_number][1] + monster_flash_offset[flash_number][2];
324: dl = CL_AllocDlight (ent);
325: VectorCopy (origin, dl->origin);
326: dl->radius = 200 + (rand()&31);
327: dl->minlight = 32;
328: dl->die = cl.time; // + 0.1;
329: switch (flash_number)
330: {
331: case MZ2_INFANTRY_MACHINEGUN_1:
332: case MZ2_INFANTRY_MACHINEGUN_2:
333: case MZ2_INFANTRY_MACHINEGUN_3:
334: case MZ2_INFANTRY_MACHINEGUN_4:
335: case MZ2_INFANTRY_MACHINEGUN_5:
336: case MZ2_INFANTRY_MACHINEGUN_6:
337: case MZ2_INFANTRY_MACHINEGUN_7:
338: case MZ2_INFANTRY_MACHINEGUN_8:
339: case MZ2_INFANTRY_MACHINEGUN_9:
340: case MZ2_INFANTRY_MACHINEGUN_10:
341: case MZ2_INFANTRY_MACHINEGUN_11:
342: case MZ2_INFANTRY_MACHINEGUN_12:
343: case MZ2_INFANTRY_MACHINEGUN_13:
344: dl->color[0] = 1;dl->color[1] = 1;dl->color[2] = 0;
345: CL_ParticleEffect (origin, vec3_origin, 0, 40);
346: CL_SmokeAndFlash(origin);
347: S_StartSound (NULL, ent, CHAN_WEAPON, S_RegisterSound("infantry/infatck1.wav"), 1, ATTN_NORM, 0);
348: break;
349: case MZ2_SOLDIER_MACHINEGUN_1:
350: case MZ2_SOLDIER_MACHINEGUN_2:
351: case MZ2_SOLDIER_MACHINEGUN_3:
352: case MZ2_SOLDIER_MACHINEGUN_4:
353: case MZ2_SOLDIER_MACHINEGUN_5:
354: case MZ2_SOLDIER_MACHINEGUN_6:
355: case MZ2_SOLDIER_MACHINEGUN_7:
356: case MZ2_SOLDIER_MACHINEGUN_8:
357: dl->color[0] = 1;dl->color[1] = 1;dl->color[2] = 0;
358: CL_ParticleEffect (origin, vec3_origin, 0, 40);
359: CL_SmokeAndFlash(origin);
360: S_StartSound (NULL, ent, CHAN_WEAPON, S_RegisterSound("soldier/solatck3.wav"), 1, ATTN_NORM, 0);
361: break;
362: case MZ2_GUNNER_MACHINEGUN_1:
363: case MZ2_GUNNER_MACHINEGUN_2:
364: case MZ2_GUNNER_MACHINEGUN_3:
365: case MZ2_GUNNER_MACHINEGUN_4:
366: case MZ2_GUNNER_MACHINEGUN_5:
367: case MZ2_GUNNER_MACHINEGUN_6:
368: case MZ2_GUNNER_MACHINEGUN_7:
369: case MZ2_GUNNER_MACHINEGUN_8:
370: dl->color[0] = 1;dl->color[1] = 1;dl->color[2] = 0;
371: CL_ParticleEffect (origin, vec3_origin, 0, 40);
372: CL_SmokeAndFlash(origin);
373: S_StartSound (NULL, ent, CHAN_WEAPON, S_RegisterSound("gunner/gunatck2.wav"), 1, ATTN_NORM, 0);
374: break;
375: case MZ2_ACTOR_MACHINEGUN_1:
376: case MZ2_SUPERTANK_MACHINEGUN_1:
377: case MZ2_SUPERTANK_MACHINEGUN_2:
378: case MZ2_SUPERTANK_MACHINEGUN_3:
379: case MZ2_SUPERTANK_MACHINEGUN_4:
380: case MZ2_SUPERTANK_MACHINEGUN_5:
381: case MZ2_SUPERTANK_MACHINEGUN_6:
382: dl->color[0] = 1;dl->color[1] = 1;dl->color[2] = 0;
383:
384: CL_ParticleEffect (origin, vec3_origin, 0, 40);
385: CL_SmokeAndFlash(origin);
386: S_StartSound (NULL, ent, CHAN_WEAPON, S_RegisterSound("infantry/infatck1.wav"), 1, ATTN_NORM, 0);
387: break;
388:
389: case MZ2_BOSS2_MACHINEGUN_L1:
390: case MZ2_BOSS2_MACHINEGUN_L2:
391: case MZ2_BOSS2_MACHINEGUN_L3:
392: case MZ2_BOSS2_MACHINEGUN_L4:
393: case MZ2_BOSS2_MACHINEGUN_L5:
394: dl->color[0] = 1;dl->color[1] = 1;dl->color[2] = 0;
395: CL_ParticleEffect (origin, vec3_origin, 0, 40);
396: CL_SmokeAndFlash(origin);
397: S_StartSound (NULL, ent, CHAN_WEAPON, S_RegisterSound("infantry/infatck1.wav"), 1, ATTN_NONE, 0);
398: break;
399: case MZ2_SOLDIER_BLASTER_1:
400: case MZ2_SOLDIER_BLASTER_2:
401: case MZ2_SOLDIER_BLASTER_3:
402: case MZ2_SOLDIER_BLASTER_4:
403: case MZ2_SOLDIER_BLASTER_5:
404: case MZ2_SOLDIER_BLASTER_6:
405: case MZ2_SOLDIER_BLASTER_7:
406: case MZ2_SOLDIER_BLASTER_8:
407: dl->color[0] = 1;dl->color[1] = 1;dl->color[2] = 0;
408: S_StartSound (NULL, ent, CHAN_WEAPON, S_RegisterSound("soldier/solatck2.wav"), 1, ATTN_NORM, 0);
409: break;
410: case MZ2_FLYER_BLASTER_1:
411: case MZ2_FLYER_BLASTER_2:
412: dl->color[0] = 1;dl->color[1] = 1;dl->color[2] = 0;
413: S_StartSound (NULL, ent, CHAN_WEAPON, S_RegisterSound("flyer/flyatck3.wav"), 1, ATTN_NORM, 0);
414: break;
415: case MZ2_MEDIC_BLASTER_1:
416: dl->color[0] = 1;dl->color[1] = 1;dl->color[2] = 0;
417: S_StartSound (NULL, ent, CHAN_WEAPON, S_RegisterSound("medic/medatck1.wav"), 1, ATTN_NORM, 0);
418: break;
419:
420: case MZ2_HOVER_BLASTER_1:
421: dl->color[0] = 1;dl->color[1] = 1;dl->color[2] = 0;
422: S_StartSound (NULL, ent, CHAN_WEAPON, S_RegisterSound("hover/hovatck1.wav"), 1, ATTN_NORM, 0);
423: break;
424:
425: case MZ2_FLOAT_BLASTER_1:
426: dl->color[0] = 1;dl->color[1] = 1;dl->color[2] = 0;
427: S_StartSound (NULL, ent, CHAN_WEAPON, S_RegisterSound("floater/fltatck1.wav"), 1, ATTN_NORM, 0);
428: break;
429: case MZ2_SOLDIER_SHOTGUN_1:
430: case MZ2_SOLDIER_SHOTGUN_2:
431: case MZ2_SOLDIER_SHOTGUN_3:
432: case MZ2_SOLDIER_SHOTGUN_4:
433: case MZ2_SOLDIER_SHOTGUN_5:
434: case MZ2_SOLDIER_SHOTGUN_6:
435: case MZ2_SOLDIER_SHOTGUN_7:
436: case MZ2_SOLDIER_SHOTGUN_8:
437: dl->color[0] = 1;dl->color[1] = 1;dl->color[2] = 0;
438: CL_SmokeAndFlash(origin);
439: S_StartSound (NULL, ent, CHAN_WEAPON, S_RegisterSound("soldier/solatck1.wav"), 1, ATTN_NORM, 0);
440: break;
441: case MZ2_TANK_BLASTER_1:
442: case MZ2_TANK_BLASTER_2:
443: case MZ2_TANK_BLASTER_3:
444: dl->color[0] = 1;dl->color[1] = 1;dl->color[2] = 0;
445: S_StartSound (NULL, ent, CHAN_WEAPON, S_RegisterSound("tank/tnkatck3.wav"), 1, ATTN_NORM, 0);
446: break;
447: case MZ2_TANK_MACHINEGUN_1:
448: case MZ2_TANK_MACHINEGUN_2:
449: case MZ2_TANK_MACHINEGUN_3:
450: case MZ2_TANK_MACHINEGUN_4:
451: case MZ2_TANK_MACHINEGUN_5:
452: case MZ2_TANK_MACHINEGUN_6:
453: case MZ2_TANK_MACHINEGUN_7:
454: case MZ2_TANK_MACHINEGUN_8:
455: case MZ2_TANK_MACHINEGUN_9:
456: case MZ2_TANK_MACHINEGUN_10:
457: case MZ2_TANK_MACHINEGUN_11:
458: case MZ2_TANK_MACHINEGUN_12:
459: case MZ2_TANK_MACHINEGUN_13:
460: case MZ2_TANK_MACHINEGUN_14:
461: case MZ2_TANK_MACHINEGUN_15:
462: case MZ2_TANK_MACHINEGUN_16:
463: case MZ2_TANK_MACHINEGUN_17:
464: case MZ2_TANK_MACHINEGUN_18:
465: case MZ2_TANK_MACHINEGUN_19:
466: dl->color[0] = 1;dl->color[1] = 1;dl->color[2] = 0;
467: CL_ParticleEffect (origin, vec3_origin, 0, 40);
468: CL_SmokeAndFlash(origin);
469: Com_sprintf(soundname, sizeof(soundname), "tank/tnkatk2%c.wav", 'a' + rand() % 5);
470: S_StartSound (NULL, ent, CHAN_WEAPON, S_RegisterSound(soundname), 1, ATTN_NORM, 0);
471: break;
472: case MZ2_CHICK_ROCKET_1:
473: dl->color[0] = 1;dl->color[1] = 0.5;dl->color[2] = 0.2;
474: S_StartSound (NULL, ent, CHAN_WEAPON, S_RegisterSound("chick/chkatck2.wav"), 1, ATTN_NORM, 0);
475: break;
476: case MZ2_TANK_ROCKET_1:
477: case MZ2_TANK_ROCKET_2:
478: case MZ2_TANK_ROCKET_3:
479: dl->color[0] = 1;dl->color[1] = 0.5;dl->color[2] = 0.2;
480: S_StartSound (NULL, ent, CHAN_WEAPON, S_RegisterSound("tank/tnkatck1.wav"), 1, ATTN_NORM, 0);
481: break;
482: case MZ2_SUPERTANK_ROCKET_1:
483: case MZ2_SUPERTANK_ROCKET_2:
484: case MZ2_SUPERTANK_ROCKET_3:
485: case MZ2_BOSS2_ROCKET_1:
486: case MZ2_BOSS2_ROCKET_2:
487: case MZ2_BOSS2_ROCKET_3:
488: case MZ2_BOSS2_ROCKET_4:
489: dl->color[0] = 1;dl->color[1] = 0.5;dl->color[2] = 0.2;
490: S_StartSound (NULL, ent, CHAN_WEAPON, S_RegisterSound("tank/rocket.wav"), 1, ATTN_NORM, 0);
491: break;
492: case MZ2_GUNNER_GRENADE_1:
493: case MZ2_GUNNER_GRENADE_2:
494: case MZ2_GUNNER_GRENADE_3:
495: case MZ2_GUNNER_GRENADE_4:
496: dl->color[0] = 1;dl->color[1] = 0.5;dl->color[2] = 0;
497: S_StartSound (NULL, ent, CHAN_WEAPON, S_RegisterSound("gunner/gunatck3.wav"), 1, ATTN_NORM, 0);
498: break;
499: case MZ2_GLADIATOR_RAILGUN_1:
500: dl->color[0] = 0.5;dl->color[1] = 0.5;dl->color[2] = 1.0;
501: break;
502:
503: // --- Xian's shit starts ---
504: case MZ2_MAKRON_BFG:
505: dl->color[0] = 0.5;dl->color[1] = 1 ;dl->color[2] = 0.5;
506: //S_StartSound (NULL, ent, CHAN_WEAPON, S_RegisterSound("makron/bfg_fire.wav"), 1, ATTN_NORM, 0);
507: break;
508:
509: case MZ2_MAKRON_BLASTER_1:
510: case MZ2_MAKRON_BLASTER_2:
511: case MZ2_MAKRON_BLASTER_3:
512: case MZ2_MAKRON_BLASTER_4:
513: case MZ2_MAKRON_BLASTER_5:
514: case MZ2_MAKRON_BLASTER_6:
515: case MZ2_MAKRON_BLASTER_7:
516: case MZ2_MAKRON_BLASTER_8:
517: case MZ2_MAKRON_BLASTER_9:
518: case MZ2_MAKRON_BLASTER_10:
519: case MZ2_MAKRON_BLASTER_11:
520: case MZ2_MAKRON_BLASTER_12:
521: case MZ2_MAKRON_BLASTER_13:
522: case MZ2_MAKRON_BLASTER_14:
523: case MZ2_MAKRON_BLASTER_15:
524: case MZ2_MAKRON_BLASTER_16:
525: case MZ2_MAKRON_BLASTER_17:
526: dl->color[0] = 1;dl->color[1] = 1;dl->color[2] = 0;
527: S_StartSound (NULL, ent, CHAN_WEAPON, S_RegisterSound("makron/blaster.wav"), 1, ATTN_NORM, 0);
528: break;
529:
530: case MZ2_JORG_MACHINEGUN_L1:
531: case MZ2_JORG_MACHINEGUN_L2:
532: case MZ2_JORG_MACHINEGUN_L3:
533: case MZ2_JORG_MACHINEGUN_L4:
534: case MZ2_JORG_MACHINEGUN_L5:
535: case MZ2_JORG_MACHINEGUN_L6:
536: dl->color[0] = 1;dl->color[1] = 1;dl->color[2] = 0;
537: CL_ParticleEffect (origin, vec3_origin, 0, 40);
538: CL_SmokeAndFlash(origin);
539: S_StartSound (NULL, ent, CHAN_WEAPON, S_RegisterSound("boss3/xfire.wav"), 1, ATTN_NORM, 0);
540: break;
541:
542: case MZ2_JORG_MACHINEGUN_R1:
543: case MZ2_JORG_MACHINEGUN_R2:
544: case MZ2_JORG_MACHINEGUN_R3:
545: case MZ2_JORG_MACHINEGUN_R4:
546: case MZ2_JORG_MACHINEGUN_R5:
547: case MZ2_JORG_MACHINEGUN_R6:
548: dl->color[0] = 1;dl->color[1] = 1;dl->color[2] = 0;
549: CL_ParticleEffect (origin, vec3_origin, 0, 40);
550: CL_SmokeAndFlash(origin);
551: break;
552:
553: case MZ2_JORG_BFG_1:
554: dl->color[0] = 0.5;dl->color[1] = 1 ;dl->color[2] = 0.5;
555: break;
556:
557: case MZ2_BOSS2_MACHINEGUN_R1:
558: case MZ2_BOSS2_MACHINEGUN_R2:
559: case MZ2_BOSS2_MACHINEGUN_R3:
560: case MZ2_BOSS2_MACHINEGUN_R4:
561: case MZ2_BOSS2_MACHINEGUN_R5:
562: dl->color[0] = 1;dl->color[1] = 1;dl->color[2] = 0;
563:
564: CL_ParticleEffect (origin, vec3_origin, 0, 40);
565: CL_SmokeAndFlash(origin);
566: break;
567:
568:
569:
570: // --- Xian's shit ends ---
571: }
572: }
573: /*
574: ===============
575: CL_AddDLights
576: ===============
577: */
578: void CL_AddDLights (void)
579: {
580: int i;
581: cdlight_t *dl;
582: dl = cl_dlights;
583: for (i=0 ; i<MAX_DLIGHTS ; i++, dl++)
584: {
585: if (!dl->radius)
586: continue;
587: V_AddLight (dl->origin, dl->radius,
588: dl->color[0], dl->color[1], dl->color[2]);
589: }
590: }
591: /*
592: ==============================================================
593: PARTICLE MANAGEMENT
594: ==============================================================
595: */
596: typedef struct particle_s
597: {
598: struct particle_s *next;
599: float time;
600: vec3_t org;
601: vec3_t vel;
602: vec3_t accel;
603: float color;
604: float colorvel;
605: float alpha;
606: float alphavel;
607: } cparticle_t;
608: #define PARTICLE_GRAVITY 40
609: cparticle_t *active_particles, *free_particles;
610: cparticle_t particles[MAX_PARTICLES];
611: int cl_numparticles = MAX_PARTICLES;
612: /*
613: ===============
614: CL_ClearParticles
615: ===============
616: */
617: void CL_ClearParticles (void)
618: {
619: int i;
620:
621: free_particles = &particles[0];
622: active_particles = NULL;
623: for (i=0 ;i<cl_numparticles ; i++)
624: particles[i].next = &particles[i+1];
625: particles[cl_numparticles-1].next = NULL;
626: }
627: /*
628: ===============
629: CL_ParticleEffect
630: Wall impact puffs
631: ===============
632: */
633: void CL_ParticleEffect (vec3_t org, vec3_t dir, int color, int count)
634: {
635: int i, j;
636: cparticle_t *p;
637: float d;
638: for (i=0 ; i<count ; i++)
639: {
640: if (!free_particles)
641: return;
642: p = free_particles;
643: free_particles = p->next;
644: p->next = active_particles;
645: active_particles = p;
646: p->time = cl.time;
647: p->color = color + (rand()&7);
648: d = rand()&31;
649: for (j=0 ; j<3 ; j++)
650: {
651: p->org[j] = org[j] + ((rand()&7)-4) + d*dir[j];
652: p->vel[j] = crand()*20;
653: }
654: p->accel[0] = p->accel[1] = 0;
655: p->accel[2] = -PARTICLE_GRAVITY;
656: p->alpha = 1.0;
657: p->alphavel = -1.0 / (0.5 + frand()*0.3);
658: }
659: }
660: /*
661: ===============
662: CL_ParticleEffect2
663: ===============
664: */
665: void CL_ParticleEffect2 (vec3_t org, vec3_t dir, int color, int count)
666: {
667: int i, j;
668: cparticle_t *p;
669: float d;
670:
671: for (i=0 ; i<count ; i++)
672: {
673: if (!free_particles)
674: return;
675: p = free_particles;
676: free_particles = p->next;
677: p->next = active_particles;
678: active_particles = p;
679:
680: p->time = cl.time;
681: p->color = color;
682:
683: d = rand()&7;
684: for (j=0 ; j<3 ; j++)
685: {
686: p->org[j] = org[j] + ((rand()&7)-4) + d*dir[j];
687: p->vel[j] = crand()*20;
688: }
689:
690: p->accel[0] = p->accel[1] = 0;
691: p->accel[2] = -PARTICLE_GRAVITY;
692: p->alpha = 1.0;
693:
694: p->alphavel = -1.0 / (0.5 + frand()*0.3);
695: }
696: }
697:
698: /*
699: ===============
700: CL_TeleporterParticles
701: ===============
702: */
703: void CL_TeleporterParticles (entity_state_t *ent)
704: {
705: int i, j;
706: cparticle_t *p;
707:
708: for (i=0 ; i<8 ; i++)
709: {
710: if (!free_particles)
711: return;
712: p = free_particles;
713: free_particles = p->next;
714: p->next = active_particles;
715: active_particles = p;
716:
717: p->time = cl.time;
718: p->color = 0xdb;
719:
720: for (j=0 ; j<2 ; j++)
721: {
722: p->org[j] = ent->origin[j] - 16 + (rand()&31);
723: p->vel[j] = crand()*14;
724: }
725:
726: p->org[2] = ent->origin[2] - 8 + (rand()&7);
727: p->vel[2] = 80 + (rand()&7);
728:
729: p->accel[0] = p->accel[1] = 0;
730: p->accel[2] = -PARTICLE_GRAVITY;
731: p->alpha = 1.0;
732:
733: p->alphavel = -0.5;
734: }
735: }
736:
737: /*
738: ===============
739: CL_LogoutEffect
740: ===============
741: */
742: void CL_LogoutEffect (vec3_t org, int type)
743: {
744: int i, j;
745: cparticle_t *p;
746: for (i=0 ; i<500 ; i++)
747: {
748: if (!free_particles)
749: return;
750: p = free_particles;
751: free_particles = p->next;
752: p->next = active_particles;
753: active_particles = p;
754: p->time = cl.time;
755: if (type == MZ_LOGIN)
756: p->color = 0xd0 + (rand()&7); // green
757: else if (type == MZ_LOGOUT)
758: p->color = 0x40 + (rand()&7); // red
759: else
760: p->color = 0xe0 + (rand()&7); // yellow
761: p->org[0] = org[0] - 16 + frand()*32;
762: p->org[1] = org[1] - 16 + frand()*32;
763: p->org[2] = org[2] - 24 + frand()*56;
764: for (j=0 ; j<3 ; j++)
765: p->vel[j] = crand()*20;
766: p->accel[0] = p->accel[1] = 0;
767: p->accel[2] = -PARTICLE_GRAVITY;
768: p->alpha = 1.0;
769: p->alphavel = -1.0 / (1.0 + frand()*0.3);
770: }
771: }
772: /*
773: ===============
774: CL_ItemRespawnParticles
775: ===============
776: */
777: void CL_ItemRespawnParticles (vec3_t org)
778: {
779: int i, j;
780: cparticle_t *p;
781: for (i=0 ; i<64 ; i++)
782: {
783: if (!free_particles)
784: return;
785: p = free_particles;
786: free_particles = p->next;
787: p->next = active_particles;
788: active_particles = p;
789: p->time = cl.time;
790: p->color = 0xd4 + (rand()&3); // green
791: p->org[0] = org[0] + crand()*8;
792: p->org[1] = org[1] + crand()*8;
793: p->org[2] = org[2] + crand()*8;
794: for (j=0 ; j<3 ; j++)
795: p->vel[j] = crand()*8;
796: p->accel[0] = p->accel[1] = 0;
797: p->accel[2] = -PARTICLE_GRAVITY*0.2;
798: p->alpha = 1.0;
799: p->alphavel = -1.0 / (1.0 + frand()*0.3);
800: }
801: }
802: /*
803: ===============
804: CL_ExplosionParticles
805: ===============
806: */
807: void CL_ExplosionParticles (vec3_t org)
808: {
809: int i, j;
810: cparticle_t *p;
811:
812: for (i=0 ; i<256 ; i++)
813: {
814: if (!free_particles)
815: return;
816: p = free_particles;
817: free_particles = p->next;
818: p->next = active_particles;
819: active_particles = p;
820:
821: p->time = cl.time;
822: p->color = 0xe0 + (rand()&7);
823:
824: for (j=0 ; j<3 ; j++)
825: {
826: p->org[j] = org[j] + ((rand()%32)-16);
827: p->vel[j] = (rand()%384)-192;
828: }
829:
830: p->accel[0] = p->accel[1] = 0;
831: p->accel[2] = -PARTICLE_GRAVITY;
832: p->alpha = 1.0;
833:
834: p->alphavel = -0.8 / (0.5 + frand()*0.3);
835: }
836: }
837:
838:
839: /*
840: ===============
841: CL_BigTeleportParticles
842: ===============
843: */
844: void CL_BigTeleportParticles (vec3_t org)
845: {
846: int i;
847: cparticle_t *p;
848: float angle, dist;
849: static int colortable[4] = {2*8,13*8,21*8,18*8};
850:
851: for (i=0 ; i<4096 ; i++)
852: {
853: if (!free_particles)
854: return;
855: p = free_particles;
856: free_particles = p->next;
857: p->next = active_particles;
858: active_particles = p;
859:
860: p->time = cl.time;
861:
862: p->color = colortable[rand()&3];
863:
864: angle = M_PI*2*(rand()&1023)/1023.0;
865: dist = rand()&31;
866: p->org[0] = org[0] + cos(angle)*dist;
867: p->vel[0] = cos(angle)*(70+(rand()&63));
868: p->accel[0] = -cos(angle)*100;
869:
870: p->org[1] = org[1] + sin(angle)*dist;
871: p->vel[1] = sin(angle)*(70+(rand()&63));
872: p->accel[1] = -sin(angle)*100;
873:
874: p->org[2] = org[2] + 8 + (rand()%90);
875: p->vel[2] = -100 + (rand()&31);
876: p->accel[2] = PARTICLE_GRAVITY*4;
877: p->alpha = 1.0;
878:
879: p->alphavel = -0.3 / (0.5 + frand()*0.3);
880: }
881: }
882:
883:
884: /*
885: ===============
886: CL_BlasterParticles
887: Wall impact puffs
888: ===============
889: */
890: void CL_BlasterParticles (vec3_t org, vec3_t dir)
891: {
892: int i, j;
893: cparticle_t *p;
894: float d;
895: int count;
896: count = 40;
897: for (i=0 ; i<count ; i++)
898: {
899: if (!free_particles)
900: return;
901: p = free_particles;
902: free_particles = p->next;
903: p->next = active_particles;
904: active_particles = p;
905: p->time = cl.time;
906: p->color = 0xe0 + (rand()&7);
907: d = rand()&15;
908: for (j=0 ; j<3 ; j++)
909: {
910: p->org[j] = org[j] + ((rand()&7)-4) + d*dir[j];
911: p->vel[j] = dir[j] * 30 + crand()*40;
912: }
913: p->accel[0] = p->accel[1] = 0;
914: p->accel[2] = -PARTICLE_GRAVITY;
915: p->alpha = 1.0;
916: p->alphavel = -1.0 / (0.5 + frand()*0.3);
917: }
918: }
919: /*
920: ===============
921: CL_BlasterTrail
922: ===============
923: */
924: void CL_BlasterTrail (vec3_t start, vec3_t end)
925: {
926: vec3_t move;
927: vec3_t vec;
928: float len;
929: int j;
930: cparticle_t *p;
931: int dec;
932: VectorCopy (start, move);
933: VectorSubtract (end, start, vec);
934: len = VectorNormalize (vec);
935: dec = 5;
936: VectorScale (vec, 5, vec);
937: // FIXME: this is a really silly way to have a loop
938: while (len > 0)
939: {
940: len -= dec;
941: if (!free_particles)
942: return;
943: p = free_particles;
944: free_particles = p->next;
945: p->next = active_particles;
946: active_particles = p;
947: VectorClear (p->accel);
948:
949: p->time = cl.time;
950: p->alpha = 1.0;
951: p->alphavel = -1.0 / (0.3+frand()*0.2);
952: p->color = 0xe0;
953: for (j=0 ; j<3 ; j++)
954: {
955: p->org[j] = move[j] + crand();
956: p->vel[j] = crand()*5;
957: p->accel[j] = 0;
958: }
959: VectorAdd (move, vec, move);
960: }
961: }
962: /*
963: ===============
964: CL_QuadTrail
965:
966: ===============
967: */
968: void CL_QuadTrail (vec3_t start, vec3_t end)
969: {
970: vec3_t move;
971: vec3_t vec;
972: float len;
973: int j;
974: cparticle_t *p;
975: int dec;
976:
977: VectorCopy (start, move);
978: VectorSubtract (end, start, vec);
979: len = VectorNormalize (vec);
980:
981: dec = 5;
982: VectorScale (vec, 5, vec);
983:
984: while (len > 0)
985: {
986: len -= dec;
987:
988: if (!free_particles)
989: return;
990: p = free_particles;
991: free_particles = p->next;
992: p->next = active_particles;
993: active_particles = p;
994: VectorClear (p->accel);
995:
996: p->time = cl.time;
997:
998: p->alpha = 1.0;
999: p->alphavel = -1.0 / (0.8+frand()*0.2);
1000: p->color = 115;
1001: for (j=0 ; j<3 ; j++)
1002: {
1003: p->org[j] = move[j] + crand()*16;
1004: p->vel[j] = crand()*5;
1005: p->accel[j] = 0;
1006: }
1007:
1008: VectorAdd (move, vec, move);
1009: }
1010: }
1011:
1012: /*
1013: ===============
1014: CL_FlagTrail
1015:
1016: ===============
1017: */
1018: void CL_FlagTrail (vec3_t start, vec3_t end, float color)
1019: {
1020: vec3_t move;
1021: vec3_t vec;
1022: float len;
1023: int j;
1024: cparticle_t *p;
1025: int dec;
1026:
1027: VectorCopy (start, move);
1028: VectorSubtract (end, start, vec);
1029: len = VectorNormalize (vec);
1030:
1031: dec = 5;
1032: VectorScale (vec, 5, vec);
1033:
1034: while (len > 0)
1035: {
1036: len -= dec;
1037:
1038: if (!free_particles)
1039: return;
1040: p = free_particles;
1041: free_particles = p->next;
1042: p->next = active_particles;
1043: active_particles = p;
1044: VectorClear (p->accel);
1045:
1046: p->time = cl.time;
1047:
1048: p->alpha = 1.0;
1049: p->alphavel = -1.0 / (0.8+frand()*0.2);
1050: p->color = color;
1051: for (j=0 ; j<3 ; j++)
1052: {
1053: p->org[j] = move[j] + crand()*16;
1054: p->vel[j] = crand()*5;
1055: p->accel[j] = 0;
1056: }
1057:
1058: VectorAdd (move, vec, move);
1059: }
1060: }
1061:
1062: /*
1063: ===============
1064: CL_DiminishingTrail
1065: ===============
1066: */
1067: void CL_DiminishingTrail (vec3_t start, vec3_t end, centity_t *old, int flags)
1068: {
1069: vec3_t move;
1070: vec3_t vec;
1071: float len;
1072: int j;
1073: cparticle_t *p;
1074: float dec;
1075: float orgscale;
1076: float velscale;
1077: VectorCopy (start, move);
1078: VectorSubtract (end, start, vec);
1079: len = VectorNormalize (vec);
1080: dec = 0.5;
1081: VectorScale (vec, dec, vec);
1082: if (old->trailcount > 900)
1083: {
1084: orgscale = 4;
1085: velscale = 15;
1086: }
1087: else if (old->trailcount > 800)
1088: {
1089: orgscale = 2;
1090: velscale = 10;
1091: }
1092: else
1093: {
1094: orgscale = 1;
1095: velscale = 5;
1096: }
1097: while (len > 0)
1098: {
1099: len -= dec;
1100: if (!free_particles)
1101: return;
1102: // drop less particles as it flies
1103: if ((rand()&1023) < old->trailcount)
1104: {
1105: p = free_particles;
1106: free_particles = p->next;
1107: p->next = active_particles;
1108: active_particles = p;
1109: VectorClear (p->accel);
1110:
1111: p->time = cl.time;
1112: if (flags & EF_GIB)
1113: {
1114: p->alpha = 1.0;
1115: p->alphavel = -1.0 / (1+frand()*0.4);
1116: p->color = 0xe8 + (rand()&7);
1117: for (j=0 ; j<3 ; j++)
1118: {
1119: p->org[j] = move[j] + crand()*orgscale;
1120: p->vel[j] = crand()*velscale;
1121: p->accel[j] = 0;
1122: }
1123: p->vel[2] -= PARTICLE_GRAVITY;
1124: }
1125: else if (flags & EF_GREENGIB)
1126: {
1127: p->alpha = 1.0;
1128: p->alphavel = -1.0 / (1+frand()*0.4);
1129: p->color = 0xd0 + (rand()&7);
1130: for (j=0; j< 3; j++)
1131: {
1132: p->org[j] = move[j] + crand()*orgscale;
1133: p->vel[j] = crand()*velscale;
1134: p->accel[j] = 0;
1135: }
1136: p->vel[2] -= PARTICLE_GRAVITY;
1137: }
1138: else
1139: {
1140: p->alpha = 1.0;
1141: p->alphavel = -1.0 / (1+frand()*0.2);
1142: p->color = 4 + (rand()&7);
1143: for (j=0 ; j<3 ; j++)
1144: {
1145: p->org[j] = move[j] + crand()*orgscale;
1146: p->vel[j] = crand()*velscale;
1147: }
1148: p->accel[2] = 20;
1149: }
1150: }
1151: old->trailcount -= 5;
1152: if (old->trailcount < 100)
1153: old->trailcount = 100;
1154: VectorAdd (move, vec, move);
1155: }
1156: }
1157: void MakeNormalVectors (vec3_t forward, vec3_t right, vec3_t up)
1158: {
1159: float d;
1160: // this rotate and negat guarantees a vector
1161: // not colinear with the original
1162: right[1] = -forward[0];
1163: right[2] = forward[1];
1164: right[0] = forward[2];
1165: d = DotProduct (right, forward);
1166: VectorMA (right, -d, forward, right);
1167: VectorNormalize (right);
1168: CrossProduct (right, forward, up);
1169: }
1170: /*
1171: ===============
1172: CL_RocketTrail
1173: ===============
1174: */
1175: void CL_RocketTrail (vec3_t start, vec3_t end, centity_t *old)
1176: {
1177: vec3_t move;
1178: vec3_t vec;
1179: float len;
1180: int j;
1181: cparticle_t *p;
1182: float dec;
1183: // smoke
1184: CL_DiminishingTrail (start, end, old, EF_ROCKET);
1185: // fire
1186: VectorCopy (start, move);
1187: VectorSubtract (end, start, vec);
1188: len = VectorNormalize (vec);
1189: dec = 1;
1190: VectorScale (vec, dec, vec);
1191: while (len > 0)
1192: {
1193: len -= dec;
1194: if (!free_particles)
1195: return;
1196: if ( (rand()&7) == 0)
1197: {
1198: p = free_particles;
1199: free_particles = p->next;
1200: p->next = active_particles;
1201: active_particles = p;
1202:
1203: VectorClear (p->accel);
1204: p->time = cl.time;
1205: p->alpha = 1.0;
1206: p->alphavel = -1.0 / (1+frand()*0.2);
1207: p->color = 0xdc + (rand()&3);
1208: for (j=0 ; j<3 ; j++)
1209: {
1210: p->org[j] = move[j] + crand()*5;
1211: p->vel[j] = crand()*20;
1212: }
1213: p->accel[2] = -PARTICLE_GRAVITY;
1214: }
1215: VectorAdd (move, vec, move);
1216: }
1217: }
1218: /*
1219: ===============
1220: CL_RailTrail
1221: ===============
1222: */
1223: void CL_RailTrail (vec3_t start, vec3_t end)
1224: {
1225: vec3_t move;
1226: vec3_t vec;
1227: float len;
1228: int j;
1229: cparticle_t *p;
1230: float dec;
1231: vec3_t right, up;
1232: int i;
1233: float d, c, s;
1234: vec3_t dir;
1235: VectorCopy (start, move);
1236: VectorSubtract (end, start, vec);
1237: len = VectorNormalize (vec);
1238: MakeNormalVectors (vec, right, up);
1239: for (i=0 ; i<len ; i++)
1240: {
1241: if (!free_particles)
1242: return;
1243: p = free_particles;
1244: free_particles = p->next;
1245: p->next = active_particles;
1246: active_particles = p;
1247:
1248: p->time = cl.time;
1249: VectorClear (p->accel);
1250: d = i * 0.1;
1251: c = cos(d);
1252: s = sin(d);
1253: VectorScale (right, c, dir);
1254: VectorMA (dir, s, up, dir);
1255: p->alpha = 1.0;
1256: p->alphavel = -1.0 / (1+frand()*0.2);
1257: p->color = 0x74 + (rand()&7);
1258: for (j=0 ; j<3 ; j++)
1259: {
1260: p->org[j] = move[j] + dir[j]*3;
1261: p->vel[j] = dir[j]*6;
1262: }
1263: VectorAdd (move, vec, move);
1264: }
1265: dec = 0.75;
1266: VectorScale (vec, dec, vec);
1267: VectorCopy (start, move);
1268: while (len > 0)
1269: {
1270: len -= dec;
1271: if (!free_particles)
1272: return;
1273: p = free_particles;
1274: free_particles = p->next;
1275: p->next = active_particles;
1276: active_particles = p;
1277: p->time = cl.time;
1278: VectorClear (p->accel);
1279: p->alpha = 1.0;
1280: p->alphavel = -1.0 / (0.6+frand()*0.2);
1281: p->color = 0x0 + rand()&15;
1282: for (j=0 ; j<3 ; j++)
1283: {
1284: p->org[j] = move[j] + crand()*3;
1285: p->vel[j] = crand()*3;
1286: p->accel[j] = 0;
1287: }
1288: VectorAdd (move, vec, move);
1289: }
1290: }
1291:
1292: /*
1293: ===============
1294: CL_PlasmaTrail
1295:
1296: ===============
1297: */
1298: void CL_PlasmaTrail (vec3_t start, vec3_t end)
1299: {
1300: vec3_t move;
1301: vec3_t vec;
1302: float len;
1303: int j;
1304: cparticle_t *p;
1305: float dec;
1306: vec3_t right, up;
1307: int i;
1308: float d, c, s;
1309: vec3_t dir;
1310: float dacnt=1;
1311:
1312: VectorCopy (start, move);
1313: VectorSubtract (end, start, vec);
1314: len = VectorNormalize (vec);
1315:
1316: MakeNormalVectors (vec, right, up);
1317:
1318: for (i=0 ; i<len ; i++)
1319: {
1320: if (!free_particles)
1321: return;
1322:
1323: p = free_particles;
1324: free_particles = p->next;
1325: p->next = active_particles;
1326: active_particles = p;
1327:
1328: p->time = cl.time;
1329: VectorClear (p->accel);
1330:
1331: d = i * 0.1;
1332:
1333: c = sin(d) * sin(d);
1334: s = cos(d);
1335:
1336: VectorScale (right, c, dir);
1337: VectorMA (dir, s, up, dir);
1338:
1339: p->alpha = 1.0;
1340: p->alphavel = -1.0 / (1+frand()*0.2);
1341: p->color = 0xd0 + (rand()&7);
1342:
1343: dacnt+=0.1;
1344: if (dacnt > 4)
1345: dacnt=1;
1346:
1347: for (j=0 ; j<3 ; j++)
1348: {
1349: p->org[j] = move[j] + dir[j]*dacnt;
1350: p->vel[j] = dir[j];
1351: }
1352:
1353: VectorAdd (move, vec, move);
1354: }
1355:
1356: dec = 0.75;
1357: VectorScale (vec, dec, vec);
1358: VectorCopy (start, move);
1359:
1360: while (len > 0)
1361: {
1362: len -= dec;
1363:
1364: if (crand() > 0.98 && len > 8)
1365: {
1366: if (!free_particles)
1367: return;
1368: p = free_particles;
1369: free_particles = p->next;
1370: p->next = active_particles;
1371: active_particles = p;
1372:
1373: p->time = cl.time;
1374: VectorClear (p->accel);
1375:
1376: p->alpha = 1.0;
1377: p->alphavel = -1.0 / (0.6+frand()*0.2);
1378:
1379: p->color = 0xd0 + (rand()&7);
1380:
1381: for (j=0 ; j<3 ; j++)
1382: {
1383: p->org[j] = move[j] + crand()*3;
1384: p->vel[j] = crand()*3;
1385: p->accel[j] = 0;
1386: }
1387: }
1388: VectorAdd (move, vec, move);
1389: }
1390:
1391: }
1392:
1393: /*
1394: ===============
1395: CL_BoomerTrail
1396:
1397: ===============
1398: */
1399:
1400: void CL_BoomerTrail (vec3_t start, vec3_t end)
1401: {
1402: vec3_t move;
1403: vec3_t vec;
1404: float len;
1405: int j;
1406: cparticle_t *p;
1407: int dec;
1408: int left = 0;
1409:
1410: VectorCopy (start, move);
1411: VectorSubtract (end, start, vec);
1412: len = VectorNormalize (vec);
1413:
1414: dec = 5;
1415: VectorScale (vec, 5, vec);
1416:
1417: while (len > 0)
1418: {
1419: len -= dec;
1420:
1421: if (!free_particles)
1422: return;
1423: p = free_particles;
1424: free_particles = p->next;
1425: p->next = active_particles;
1426: active_particles = p;
1427: VectorClear (p->accel);
1428:
1429: p->time = cl.time;
1430: p->alpha = 0.5;
1431: p->alphavel = -1.0 / (0.3 + frand()*0.2);
1432: p->color = 0xe4 + (rand()&3);
1433: for (j=0; j<3; j++)
1434: {
1435: p->org[j] = move[j];
1436: p->accel[j] = 0;
1437: }
1438: if (left)
1439: {
1440: left = 0;
1441: p->vel[0] = 10;
1442: }
1443: else
1444: {
1445: left = 1;
1446: p->vel[0] = -10;
1447: }
1448:
1449: p->vel[1]=0;
1450: p->vel[2]=0;
1451:
1452: VectorAdd (move, vec, move);
1453: }
1454:
1455: }
1456:
1457: /*
1458: ===============
1459: CL_BubbleTrail
1460: ===============
1461: */
1462: void CL_BubbleTrail (vec3_t start, vec3_t end)
1463: {
1464: vec3_t move;
1465: vec3_t vec;
1466: float len;
1467: int i, j;
1468: cparticle_t *p;
1469: float dec;
1470: VectorCopy (start, move);
1471: VectorSubtract (end, start, vec);
1472: len = VectorNormalize (vec);
1473: dec = 32;
1474: VectorScale (vec, dec, vec);
1475: for (i=0 ; i<len ; i+=dec)
1476: {
1477: if (!free_particles)
1478: return;
1479: p = free_particles;
1480: free_particles = p->next;
1481: p->next = active_particles;
1482: active_particles = p;
1483: VectorClear (p->accel);
1484: p->time = cl.time;
1485: p->alpha = 1.0;
1486: p->alphavel = -1.0 / (1+frand()*0.2);
1487: p->color = 4 + (rand()&7);
1488: for (j=0 ; j<3 ; j++)
1489: {
1490: p->org[j] = move[j] + crand()*2;
1491: p->vel[j] = crand()*5;
1492: }
1493: p->vel[2] += 6;
1494: VectorAdd (move, vec, move);
1495: }
1496: }
1497: /*
1498: ===============
1499: CL_FlyParticles
1500: ===============
1501: */
1502: #define BEAMLENGTH 16
1503: void CL_FlyParticles (vec3_t origin, int count)
1504: {
1505: int i;
1506: cparticle_t *p;
1507: float angle;
1508: float sr, sp, sy, cr, cp, cy;
1509: vec3_t forward;
1510: float dist = 64;
1511: float ltime;
1512:
1513: if (count > NUMVERTEXNORMALS)
1514: count = NUMVERTEXNORMALS;
1515: if (!avelocities[0][0])
1516: {
1517: for (i=0 ; i<NUMVERTEXNORMALS*3 ; i++)
1518: avelocities[0][i] = (rand()&255) * 0.01;
1519: }
1520: ltime = (float)cl.time / 1000.0;
1521: for (i=0 ; i<count ; i+=2)
1522: {
1523: angle = ltime * avelocities[i][0];
1524: sy = sin(angle);
1525: cy = cos(angle);
1526: angle = ltime * avelocities[i][1];
1527: sp = sin(angle);
1528: cp = cos(angle);
1529: angle = ltime * avelocities[i][2];
1530: sr = sin(angle);
1531: cr = cos(angle);
1532:
1533: forward[0] = cp*cy;
1534: forward[1] = cp*sy;
1535: forward[2] = -sp;
1536: if (!free_particles)
1537: return;
1538: p = free_particles;
1539: free_particles = p->next;
1540: p->next = active_particles;
1541: active_particles = p;
1542: p->time = cl.time;
1543: dist = sin(ltime + i)*64;
1544: p->org[0] = origin[0] + bytedirs[i][0]*dist + forward[0]*BEAMLENGTH;
1545: p->org[1] = origin[1] + bytedirs[i][1]*dist + forward[1]*BEAMLENGTH;
1546: p->org[2] = origin[2] + bytedirs[i][2]*dist + forward[2]*BEAMLENGTH;
1547: VectorClear (p->vel);
1548: VectorClear (p->accel);
1549: p->color = 0;
1550: p->colorvel = 0;
1551: p->alpha = 1;
1552: p->alphavel = -100;
1553: }
1554: }
1555: void CL_FlyEffect (centity_t *ent, vec3_t origin)
1556: {
1557: int n;
1558: int count;
1559: int starttime;
1560:
1561: if (ent->fly_stoptime < cl.time)
1562: {
1563: starttime = cl.time;
1564: ent->fly_stoptime = cl.time + 60000;
1565: }
1566: else
1567: {
1568: starttime = ent->fly_stoptime - 60000;
1569: }
1570:
1571: n = cl.time - starttime;
1572: if (n < 20000)
1573: count = n * 162 / 20000.0;
1574: else
1575: {
1576: n = ent->fly_stoptime - cl.time;
1577: if (n < 20000)
1578: count = n * 162 / 20000.0;
1579: else
1580: count = 162;
1581: }
1582:
1583: CL_FlyParticles (origin, count);
1584: }
1585: /*
1586: ===============
1587: CL_BfgParticles
1588: ===============
1589: */
1590: #define BEAMLENGTH 16
1591: void CL_BfgParticles (entity_t *ent)
1592: {
1593: int i;
1594: cparticle_t *p;
1595: float angle;
1596: float sr, sp, sy, cr, cp, cy;
1597: vec3_t forward;
1598: float dist = 64;
1599: vec3_t v;
1600: float ltime;
1601:
1602: if (!avelocities[0][0])
1603: {
1604: for (i=0 ; i<NUMVERTEXNORMALS*3 ; i++)
1605: avelocities[0][i] = (rand()&255) * 0.01;
1606: }
1607: ltime = (float)cl.time / 1000.0;
1608: for (i=0 ; i<NUMVERTEXNORMALS ; i++)
1609: {
1610: angle = ltime * avelocities[i][0];
1611: sy = sin(angle);
1612: cy = cos(angle);
1613: angle = ltime * avelocities[i][1];
1614: sp = sin(angle);
1615: cp = cos(angle);
1616: angle = ltime * avelocities[i][2];
1617: sr = sin(angle);
1618: cr = cos(angle);
1619:
1620: forward[0] = cp*cy;
1621: forward[1] = cp*sy;
1622: forward[2] = -sp;
1623: if (!free_particles)
1624: return;
1625: p = free_particles;
1626: free_particles = p->next;
1627: p->next = active_particles;
1628: active_particles = p;
1629: p->time = cl.time;
1630: dist = sin(ltime + i)*64;
1631: p->org[0] = ent->origin[0] + bytedirs[i][0]*dist + forward[0]*BEAMLENGTH;
1632: p->org[1] = ent->origin[1] + bytedirs[i][1]*dist + forward[1]*BEAMLENGTH;
1633: p->org[2] = ent->origin[2] + bytedirs[i][2]*dist + forward[2]*BEAMLENGTH;
1634: VectorClear (p->vel);
1635: VectorClear (p->accel);
1636: VectorSubtract (p->org, ent->origin, v);
1637: dist = VectorLength(v) / 90.0;
1638: p->color = floor (0xd0 + dist * 7);
1639: p->colorvel = 0;
1640: p->alpha = 1.0 - dist;
1641: p->alphavel = -100;
1642: }
1643: }
1644: /*
1645: ===============
1646: CL_BFGExplosionParticles
1647: ===============
1648: */
1649: //FIXME combined with CL_ExplosionParticles
1650: void CL_BFGExplosionParticles (vec3_t org)
1651: {
1652: int i, j;
1653: cparticle_t *p;
1654:
1655: for (i=0 ; i<256 ; i++)
1656: {
1657: if (!free_particles)
1658: return;
1659: p = free_particles;
1660: free_particles = p->next;
1661: p->next = active_particles;
1662: active_particles = p;
1663:
1664: p->time = cl.time;
1665: p->color = 0xd0 + (rand()&7);
1666:
1667: for (j=0 ; j<3 ; j++)
1668: {
1669: p->org[j] = org[j] + ((rand()%32)-16);
1670: p->vel[j] = (rand()%384)-192;
1671: }
1672:
1673: p->accel[0] = p->accel[1] = 0;
1674: p->accel[2] = -PARTICLE_GRAVITY;
1675: p->alpha = 1.0;
1676:
1677: p->alphavel = -0.8 / (0.5 + frand()*0.3);
1678: }
1679: }
1680:
1681: /*
1682: ===============
1683: CL_TeleportParticles
1684:
1685: ===============
1686: */
1687: void CL_TeleportParticles (vec3_t org)
1688: {
1689: int i, j, k;
1690: cparticle_t *p;
1691: float vel;
1692: vec3_t dir;
1693:
1694: for (i=-16 ; i<=16 ; i+=4)
1695: for (j=-16 ; j<=16 ; j+=4)
1696: for (k=-16 ; k<=32 ; k+=4)
1697: {
1698: if (!free_particles)
1699: return;
1700: p = free_particles;
1701: free_particles = p->next;
1702: p->next = active_particles;
1703: active_particles = p;
1704:
1705: p->time = cl.time;
1706: p->color = 7 + (rand()&7);
1707:
1708: p->alpha = 1.0;
1709: p->alphavel = -1.0 / (0.3 + (rand()&7) * 0.02);
1710:
1711: p->org[0] = org[0] + i + (rand()&3);
1712: p->org[1] = org[1] + j + (rand()&3);
1713: p->org[2] = org[2] + k + (rand()&3);
1714:
1715: dir[0] = j*8;
1716: dir[1] = i*8;
1717: dir[2] = k*8;
1718:
1719: VectorNormalize (dir);
1720: vel = 50 + (rand()&63);
1721: VectorScale (dir, vel, p->vel);
1722:
1723: p->accel[0] = p->accel[1] = 0;
1724: p->accel[2] = -PARTICLE_GRAVITY;
1725: }
1726: }
1727:
1728: /*
1729: ===============
1730: CL_AddParticles
1731: ===============
1732: */
1733: void CL_AddParticles (void)
1734: {
1735: cparticle_t *p, *next;
1736: float alpha;
1737: float time, time2;
1738: vec3_t org;
1739: int color;
1740: cparticle_t *active, *tail;
1741: active = NULL;
1742: tail = NULL;
1743: for (p=active_particles ; p ; p=next)
1744: {
1745: next = p->next;
1746: time = (cl.time - p->time)*0.001;
1747: alpha = p->alpha + time*p->alphavel;
1748: if (alpha <= 0)
1749: { // faded out
1750: p->next = free_particles;
1751: free_particles = p;
1752: continue;
1753: }
1754: p->next = NULL;
1755: if (!tail)
1756: active = tail = p;
1757: else
1758: {
1759: tail->next = p;
1760: tail = p;
1761: }
1762: if (alpha > 1.0)
1763: alpha = 1;
1764: color = p->color;
1765: time2 = time*time;
1766: org[0] = p->org[0] + p->vel[0]*time + p->accel[0]*time2;
1767: org[1] = p->org[1] + p->vel[1]*time + p->accel[1]*time2;
1768: org[2] = p->org[2] + p->vel[2]*time + p->accel[2]*time2;
1769: V_AddParticle (org, color, alpha);
1770: }
1771: active_particles = active;
1772: }
1773:
1774:
1775: /*
1776: ==============
1777: CL_EntityEvent
1778:
1779: An entity has just been parsed that has an event value
1780:
1781: the female events are there for backwards compatability
1782: ==============
1783: */
1784: extern struct sfx_s *cl_sfx_footsteps[4];
1785:
1786: void CL_EntityEvent (entity_state_t *ent)
1787: {
1788: switch (ent->event)
1789: {
1790: case EV_ITEM_RESPAWN:
1791: S_StartSound (NULL, ent->number, CHAN_WEAPON, S_RegisterSound("items/respawn1.wav"), 1, ATTN_IDLE, 0);
1792: CL_ItemRespawnParticles (ent->origin);
1793: break;
1794: case EV_PLAYER_TELEPORT:
1795: S_StartSound (NULL, ent->number, CHAN_WEAPON, S_RegisterSound("misc/tele1.wav"), 1, ATTN_IDLE, 0);
1796: CL_TeleportParticles (ent->origin);
1797: break;
1798: case EV_FOOTSTEP:
1799: if (cl_footsteps->value)
1800: S_StartSound (NULL, ent->number, CHAN_BODY, cl_sfx_footsteps[rand()&3], 1, ATTN_NORM, 0);
1801: break;
1802: case EV_FALLSHORT:
1803: S_StartSound (NULL, ent->number, CHAN_AUTO, S_RegisterSound ("player/land1.wav"), 1, ATTN_NORM, 0);
1804: break;
1805: case EV_FALL:
1806: S_StartSound (NULL, ent->number, CHAN_AUTO, S_RegisterSound ("*fall2.wav"), 1, ATTN_NORM, 0);
1807: break;
1808: case EV_FALLFAR:
1809: S_StartSound (NULL, ent->number, CHAN_AUTO, S_RegisterSound ("*fall1.wav"), 1, ATTN_NORM, 0);
1810: break;
1811: }
1812: }
1813:
1814:
1815: /*
1816: ==============
1817: CL_ClearEffects
1818:
1819: ==============
1820: */
1821: void CL_ClearEffects (void)
1822: {
1823: CL_ClearParticles ();
1824: CL_ClearDlights ();
1825: CL_ClearLightStyles ();
1826: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.