Annotation of quake2/client/cl_fx.c, revision 1.1.1.2

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

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.