qcsrc/client/particles.qc

   1 .float dphitcontentsmask;
   2
   3 .float cnt; // effect number
   4 .vector velocity; // particle velocity
   5 .float waterlevel; // direction jitter
   6 .float count; // count multiplier
   7 .float impulse; // density
   8 .string noise; // sound
   9 .float atten;
  10 .float volume;
  11 .float absolute; // 1 = count per second is absolute, 2 = only spawn at toggle
  12 .vector movedir; // trace direction
  13
  14 void Draw_PointParticles()
  15 {
  16         float n, i, fail;
  17         vector p;
  18         vector sz;
  19         vector o;
  20         o = self.origin;
  21         sz = self.maxs - self.mins;
  22         n = BGMScript(self);
  23         if(self.absolute == 2)
  24         {
  25                 if(n >= 0)
  26                         n = self.just_toggled ? self.impulse : 0;
  27                 else
  28                         n = self.impulse * drawframetime;
  29         }
  30         else
  31         {
  32                 n *= self.impulse * drawframetime;
  33                 if(self.just_toggled)
  34                         if(n < 1)
  35                                 n = 1;
  36         }
  37         if(n == 0)
  38                 return;
  39         fail = 0;
  40         for(i = random(); i <= n && fail <= 64*n; ++i)
  41         {
  42                 p = o + self.mins;
  43                 p_x += random() * sz_x;
  44                 p_y += random() * sz_y;
  45                 p_z += random() * sz_z;
  46                 if(WarpZoneLib_BoxTouchesBrush(p, p, self, world))
  47                 {
  48                         if(self.movedir != '0 0 0')
  49                         {
  50                                 traceline(p, p + normalize(self.movedir) * 4096, 0, world);
  51                                 p = trace_endpos;
  52                                 pointparticles(self.cnt, p, trace_plane_normal * vlen(self.movedir) + self.velocity + randomvec() * self.waterlevel, self.count);
  53                         }
  54                         else
  55                         {
  56                                 pointparticles(self.cnt, p, self.velocity + randomvec() * self.waterlevel, self.count);
  57                         }
  58                         if(self.noise != "")
  59                         {
  60                                 setorigin(self, p);
  61                                 sound(self, CH_AMBIENT, self.noise, VOL_BASE * self.volume, self.atten);
  62                         }
  63                         self.just_toggled = 0;
  64                 }
  65                 else if(self.absolute)
  66                 {
  67                         ++fail;
  68                         --i;
  69                 }
  70         }
  71         setorigin(self, o);
  72 }
  73
  74 void Ent_PointParticles_Remove()
  75 {
  76         if(self.noise)
  77                 strunzone(self.noise);
  78         self.noise = string_null;
  79         if(self.bgmscript)
  80                 strunzone(self.bgmscript);
  81         self.bgmscript = string_null;
  82 }
  83
  84 void Ent_PointParticles()
  85 {
  86         float f, i;
  87         vector v;
  88         f = ReadByte();
  89         if(f & 2)
  90         {
  91                 i = ReadCoord(); // density (<0: point, >0: volume)
  92                 if(i && !self.impulse && self.cnt) // self.cnt check is so it only happens if the ent already existed
  93                         self.just_toggled = 1;
  94                 self.impulse = i;
  95         }
  96         if(f & 4)
  97         {
  98                 self.origin_x = ReadCoord();
  99                 self.origin_y = ReadCoord();
 100                 self.origin_z = ReadCoord();
 101         }
 102         if(f & 1)
 103         {
 104                 self.modelindex = ReadShort();
 105                 if(f & 0x80)
 106                 {
 107                         if(self.modelindex)
 108                         {
 109                                 self.mins_x = ReadCoord();
 110                                 self.mins_y = ReadCoord();
 111                                 self.mins_z = ReadCoord();
 112                                 self.maxs_x = ReadCoord();
 113                                 self.maxs_y = ReadCoord();
 114                                 self.maxs_z = ReadCoord();
 115                         }
 116                         else
 117                         {
 118                                 self.mins    = '0 0 0';
 119                                 self.maxs_x = ReadCoord();
 120                                 self.maxs_y = ReadCoord();
 121                                 self.maxs_z = ReadCoord();
 122                         }
 123                 }
 124                 else
 125                 {
 126                         self.mins = self.maxs = '0 0 0';
 127                 }
 128
 129                 self.cnt = ReadShort(); // effect number
 130
 131                 if(f & 0x20)
 132                 {
 133                         self.velocity = decompressShortVector(ReadShort());
 134                         self.movedir = decompressShortVector(ReadShort());
 135                 }
 136                 else
 137                 {
 138                         self.velocity = self.movedir = '0 0 0';
 139                 }
 140                 if(f & 0x40)
 141                 {
 142                         self.waterlevel = ReadShort() / 16.0;
 143                         self.count = ReadByte() / 16.0;
 144                 }
 145                 else
 146                 {
 147                         self.waterlevel = 0;
 148                         self.count = 1;
 149                 }
 150                 if(self.noise)
 151                         strunzone(self.noise);
 152                 if(self.bgmscript)
 153                         strunzone(self.bgmscript);
 154                 self.noise = strzone(ReadString());
 155                 if(self.noise != "")
 156                 {
 157                         self.atten = ReadByte() / 64.0;
 158                         self.volume = ReadByte() / 255.0;
 159                 }
 160                 self.bgmscript = strzone(ReadString());
 161                 if(self.bgmscript != "")
 162                 {
 163                         self.bgmscriptattack = ReadByte() / 64.0;
 164                         self.bgmscriptdecay = ReadByte() / 64.0;
 165                         self.bgmscriptsustain = ReadByte() / 255.0;
 166                         self.bgmscriptrelease = ReadByte() / 64.0;
 167                 }
 168                 BGMScript_InitEntity(self);
 169         }
 170
 171         if(f & 2)
 172         {
 173                 self.absolute = (self.impulse >= 0);
 174                 if(!self.absolute)
 175                 {
 176                         v = self.maxs - self.mins;
 177                         self.impulse *= -v_x * v_y * v_z / 262144; // relative: particles per 64^3 cube
 178                 }
 179         }
 180
 181         if(f & 0x10)
 182                 self.absolute = 2;
 183
 184         setorigin(self, self.origin);
 185         setsize(self, self.mins, self.maxs);
 186         self.solid = SOLID_NOT;
 187         self.draw = Draw_PointParticles;
 188         self.entremove = Ent_PointParticles_Remove;
 189 }
 190
 191 .float glow_color; // palette index
 192 void Draw_Rain()
 193 {
 194     te_particlerain(self.origin + self.mins, self.origin + self.maxs, self.velocity, floor(self.count * drawframetime + random()), self.glow_color);
 195 }
 196
 197 void Draw_Snow()
 198 {
 199     te_particlesnow(self.origin + self.mins, self.origin + self.maxs, self.velocity, floor(self.count * drawframetime + random()), self.glow_color);
 200 }
 201
 202 void Ent_RainOrSnow()
 203 {
 204         self.impulse = ReadByte(); // Rain, Snow, or Whatever
 205         self.origin_x = ReadCoord();
 206         self.origin_y = ReadCoord();
 207         self.origin_z = ReadCoord();
 208         self.maxs_x = ReadCoord();
 209         self.maxs_y = ReadCoord();
 210         self.maxs_z = ReadCoord();
 211         self.velocity = decompressShortVector(ReadShort());
 212         self.count = ReadShort() * 10;
 213         self.glow_color = ReadByte(); // color
 214
 215         self.mins    = -0.5 * self.maxs;
 216         self.maxs    =  0.5 * self.maxs;
 217         self.origin  = self.origin - self.mins;
 218
 219         setorigin(self, self.origin);
 220         setsize(self, self.mins, self.maxs);
 221         self.solid = SOLID_NOT;
 222         if(self.impulse)
 223                 self.draw = Draw_Rain;
 224         else
 225                 self.draw = Draw_Snow;
 226 }
 227
 228 void Net_ReadVortexBeamParticle()
 229 {
 230         vector shotorg, endpos;
 231         float charge;
 232         shotorg_x = ReadCoord(); shotorg_y = ReadCoord(); shotorg_z = ReadCoord();
 233         endpos_x = ReadCoord(); endpos_y = ReadCoord(); endpos_z = ReadCoord();
 234         charge = ReadByte() / 255.0;
 235
 236         pointparticles(particleeffectnum("nex_muzzleflash"), shotorg, normalize(endpos - shotorg) * 1000, 1);
 237
 238         //draw either the old v2.3 beam or the new beam
 239         charge = sqrt(charge); // divide evenly among trail spacing and alpha
 240         particles_alphamin = particles_alphamax = particles_fade = charge;
 241
 242         if (autocvar_cl_particles_oldnexbeam && (getstati(STAT_ALLOW_OLDNEXBEAM) || isdemo()))
 243                 WarpZone_TrailParticles_WithMultiplier(world, particleeffectnum("TE_TEI_G3"), shotorg, endpos, 1, PARTICLES_USEALPHA | PARTICLES_USEFADE);
 244         else
 245                 WarpZone_TrailParticles_WithMultiplier(world, particleeffectnum("nex_beam"), shotorg, endpos, 1, PARTICLES_USEALPHA | PARTICLES_USEFADE);
 246 }
 247
 248 .vector sw_shotorg;
 249 .vector sw_endpos;
 250 .float sw_spread_max;
 251 .float sw_spread_min;
 252 .float sw_time;
 253
 254 void Draw_Shockwave()
 255 {
 256         float a = bound(0, (0.5 - ((time - self.sw_time) / 0.4)), 0.5);
 257
 258         if(!a) { remove(self); }
 259
 260         vector deviation, angle;
 261
 262         vector sw_color = getcsqcplayercolor(self.sv_entnum); // GetTeamRGB(GetPlayerColor(self.sv_entnum));
 263
 264         vector first_min_end = '0 0 0', prev_min_end = '0 0 0', new_min_end = '0 0 0';
 265         vector first_max_end = '0 0 0', prev_max_end = '0 0 0', new_max_end = '0 0 0';
 266
 267         float new_max_dist, new_min_dist;
 268
 269         vector shotdir = normalize(self.sw_endpos - self.sw_shotorg);
 270         vectorvectors(shotdir);
 271         vector right = v_right;
 272         vector up = v_up;
 273
 274         float counter, dist_before_normal = 200, shots = 20;
 275
 276         vector min_end = ((self.sw_shotorg + (shotdir * dist_before_normal)) + (up * self.sw_spread_min));
 277         vector max_end = (self.sw_endpos + (up * self.sw_spread_max));
 278
 279         float spread_to_min = vlen(normalize(min_end - self.sw_shotorg) - shotdir);
 280         float spread_to_max = vlen(normalize(max_end - min_end) - shotdir);
 281
 282         for(counter = 0; counter < shots; ++counter)
 283         {
 284                 // perfect circle effect lines
 285                 angle = '0 0 0';
 286                 makevectors('0 360 0' * (0.75 + (counter - 0.5) / shots));
 287                 angle_y = v_forward_x;
 288                 angle_z = v_forward_y;
 289
 290                 // first do the spread_to_min effect
 291                 deviation = angle * spread_to_min;
 292                 deviation = ((shotdir + (right * deviation_y) + (up * deviation_z)));
 293                 new_min_dist = dist_before_normal;
 294                 new_min_end = (self.sw_shotorg + (deviation * new_min_dist));
 295                 //te_lightning2(world, new_min_end, self.sw_shotorg);
 296
 297                 // then calculate spread_to_max effect
 298                 deviation = angle * spread_to_max;
 299                 deviation = ((shotdir + (right * deviation_y) + (up * deviation_z)));
 300                 new_max_dist = vlen(new_min_end - self.sw_endpos);
 301                 new_max_end = (new_min_end + (deviation * new_max_dist));
 302                 //te_lightning2(world, new_end, prev_min_end);
 303
 304
 305                 if(counter == 0)
 306                 {
 307                         first_min_end = new_min_end;
 308                         first_max_end = new_max_end;
 309                 }
 310
 311                 if(counter >= 1)
 312                 {
 313                         R_BeginPolygon("", DRAWFLAG_NORMAL);
 314                         R_PolygonVertex(prev_min_end, '0 0 0', sw_color, a);
 315                         R_PolygonVertex(new_min_end, '0 0 0', sw_color, a);
 316                         R_PolygonVertex(self.sw_shotorg, '0 0 0', sw_color, a);
 317                         R_EndPolygon();
 318
 319                         R_BeginPolygon("", DRAWFLAG_NORMAL);
 320                         R_PolygonVertex(new_min_end, '0 0 0', sw_color, a);
 321                         R_PolygonVertex(prev_min_end, '0 0 0', sw_color, a);
 322                         R_PolygonVertex(prev_max_end, '0 0 0', sw_color, a);
 323                         R_PolygonVertex(new_max_end, '0 0 0', sw_color, a);
 324                         R_EndPolygon();
 325                 }
 326
 327                 prev_min_end = new_min_end;
 328                 prev_max_end = new_max_end;
 329
 330                 if((counter + 1) == shots)
 331                 {
 332                         R_BeginPolygon("", DRAWFLAG_NORMAL);
 333                         R_PolygonVertex(prev_min_end, '0 0 0', sw_color, a);
 334                         R_PolygonVertex(first_min_end, '0 0 0', sw_color, a);
 335                         R_PolygonVertex(self.sw_shotorg, '0 0 0', sw_color, a);
 336                         R_EndPolygon();
 337
 338                         R_BeginPolygon("", DRAWFLAG_NORMAL);
 339                         R_PolygonVertex(first_min_end, '0 0 0', sw_color, a);
 340                         R_PolygonVertex(prev_min_end, '0 0 0', sw_color, a);
 341                         R_PolygonVertex(prev_max_end, '0 0 0', sw_color, a);
 342                         R_PolygonVertex(first_max_end, '0 0 0', sw_color, a);
 343                         R_EndPolygon();
 344                 }
 345         }
 346 }
 347
 348 void Net_ReadShockwaveParticle()
 349 {
 350         entity shockwave;
 351         shockwave = spawn();
 352         shockwave.draw = Draw_Shockwave;
 353
 354         shockwave.sw_shotorg_x = ReadCoord(); shockwave.sw_shotorg_y = ReadCoord(); shockwave.sw_shotorg_z = ReadCoord();
 355         shockwave.sw_endpos_x  = ReadCoord(); shockwave.sw_endpos_y  = ReadCoord(); shockwave.sw_endpos_z  = ReadCoord();
 356
 357         shockwave.sw_spread_max = ReadByte();
 358         shockwave.sw_spread_min = ReadByte();
 359
 360         shockwave.sv_entnum = ReadByte();
 361
 362         shockwave.sw_time = time;
 363 }
 364
 365 .vector beam_color;
 366 .float beam_alpha;
 367 .float beam_thickness;
 368 .float beam_traileffect;
 369 .float beam_hiteffect;
 370 .float beam_muzzleflash;
 371 //.string beam_muzzlemodel;
 372 //.vector beam_muzzlecolor; // todo: should we just use beam_color?
 373 .string beam_image;
 374
 375 .float beam_usevieworigin;
 376 .float beam_initialized;
 377 .float beam_maxangle;
 378 .float beam_range;
 379 .float beam_returnspeed;
 380 .vector beam_shotorigin;
 381 .vector beam_dir;
 382 void Draw_ArcBeam()
 383 {
 384         if(self.teleport_time)
 385         if(time > self.teleport_time)
 386         {
 387                 sound(self, CH_SHOTS_SINGLE, "misc/null.wav", VOL_BASE, ATTEN_NORM); // safeguard
 388                 self.teleport_time = 0;
 389         }
 390
 391         InterpolateOrigin_Do();
 392
 393         // origin = beam starting origin
 394         // v_angle = wanted/aim direction
 395         // angles = current direction of beam
 396
 397         vector start_pos;
 398         vector wantdir; //= view_forward;
 399         vector beamdir; //= self.beam_dir;
 400
 401         if(self.beam_usevieworigin)
 402         {
 403                 // find where we are aiming
 404                 makevectors(view_angles);
 405
 406                 // decide upon start position
 407                 if(self.beam_usevieworigin == 2)
 408                         { start_pos = view_origin; }
 409                 else
 410                         { start_pos = self.origin; }
 411
 412                 // trace forward with an estimation
 413                 WarpZone_TraceLine(start_pos, start_pos + view_forward * self.beam_range, MOVE_NOMONSTERS, self);
 414
 415                 // untransform in case our trace went through a warpzone
 416                 vector vf, vr, vu;
 417                 vf = view_forward;
 418                 vr = view_right;
 419                 vu = view_up;
 420                 vector shothitpos = WarpZone_UnTransformOrigin(WarpZone_trace_transform, trace_endpos); // warpzone support
 421                 view_forward = vf;
 422                 view_right = vr;
 423                 view_up = vu;
 424
 425                 // un-adjust trueaim if shotend is too close
 426                 if(vlen(shothitpos - view_origin) < g_trueaim_minrange)
 427                         shothitpos = view_origin + (view_forward * g_trueaim_minrange);
 428
 429                 // move shot origin to the actual gun muzzle origin
 430                 vector origin_offset = view_forward * self.beam_shotorigin_x + view_right * -self.beam_shotorigin_y + view_up * self.beam_shotorigin_z;
 431                 start_pos = start_pos + origin_offset;
 432
 433                 // calculate the aim direction now
 434                 wantdir = normalize(shothitpos - start_pos);
 435
 436                 if(!self.beam_initialized)
 437                 {
 438                         self.beam_dir = wantdir;
 439                         self.beam_initialized = TRUE;
 440                 }
 441
 442                 if(self.beam_dir != wantdir)
 443                 {
 444                         float angle = ceil(vlen(wantdir - self.beam_dir) * RAD2DEG);
 445                         float anglelimit;
 446                         if(angle && (angle > self.beam_maxangle))
 447                         {
 448                                 // if the angle is greater than maxangle, force the blendfactor to make this the maximum factor
 449                                 anglelimit = min(self.beam_maxangle / angle, 1);
 450                         }
 451                         else
 452                         {
 453                                 // the radius is not too far yet, no worries :D
 454                                 anglelimit = 1;
 455                         }
 456
 457                         // calculate how much we're going to move the end of the beam to the want position
 458                         float blendfactor = bound(0, anglelimit * (1 - (self.beam_returnspeed * frametime)), 1);
 459                         self.beam_dir = normalize((wantdir * (1 - blendfactor)) + (self.beam_dir * blendfactor));
 460                 }
 461
 462                 // finally, set the beam direction which the rest of the code will refer to
 463                 beamdir = self.beam_dir;
 464         }
 465         else
 466         {
 467                 // set the values from the provided info from the networked entity
 468                 start_pos = self.origin;
 469                 wantdir = self.v_angle;
 470                 beamdir = self.angles;
 471         }
 472
 473         setorigin(self, start_pos);
 474
 475         vector beam_endpos_estimate = (start_pos + (beamdir * self.beam_range));
 476
 477         float segments = 20; // todo: calculate this in a similar way to server does
 478         float maxthickness = self.beam_thickness;
 479
 480         vector thickdir = normalize(cross(beamdir, view_origin - start_pos));
 481
 482         vector last_origin = start_pos;
 483
 484         float lastthickness = 0;
 485
 486         vector last_top = start_pos + (thickdir * lastthickness);
 487         vector last_bottom = start_pos - (thickdir * lastthickness);
 488
 489         vector hitorigin = start_pos;
 490
 491         /*
 492         _len = vlen(self.origin - self.move_origin);
 493         _dir = normalize(self.move_origin - self.origin);
 494
 495         if(self.total_damages < time)
 496         {
 497                 boxparticles(self.traileffect, self, self.origin, self.origin + _dir * -64, _dir * -_len , _dir * -_len, 1, PARTICLES_USEALPHA);
 498                 boxparticles(self.lip, self, self.move_origin, self.move_origin + _dir * -64, _dir * -200 , _dir * -200, 1, PARTICLES_USEALPHA);
 499                 self.total_damages = time + 0.1;
 500         }
 501         */
 502
 503
 504         float i;
 505         for(i = 1; i <= segments; ++i)
 506         {
 507                 // calculate this on every segment to ensure that we always reach the full length of the attack
 508                 float segmentblend = (i/segments);
 509                 float segmentdist = vlen(beam_endpos_estimate - last_origin) * (i/segments);
 510
 511                 vector new_dir = normalize( (wantdir * (1 - segmentblend)) + (normalize(beam_endpos_estimate - last_origin) * segmentblend) );
 512                 vector new_origin = last_origin + (new_dir * segmentdist);
 513
 514                 WarpZone_TraceLine(
 515                         last_origin,
 516                         new_origin,
 517                         MOVE_NORMAL,
 518                         self
 519                 );
 520
 521                 // draw segment
 522                 if(trace_fraction != 1)
 523                 {
 524                         // calculate our own hit origin as trace_endpos tends to jump around annoyingly (to player origin?)
 525                         hitorigin = last_origin + (new_dir * segmentdist * trace_fraction);
 526                 }
 527                 else
 528                 {
 529                         hitorigin = new_origin;
 530                 }
 531
 532                 #if 0
 533                 float falloff = ExponentialFalloff(
 534                         WEP_CVAR(arc, beam_falloff_mindist),
 535                         WEP_CVAR(arc, beam_falloff_maxdist),
 536                         WEP_CVAR(arc, beam_falloff_halflifedist),
 537                         vlen(WarpZone_UnTransformOrigin(WarpZone_trace_transform, hitorigin) - start_pos)
 538                 );
 539                 #else
 540                 //float falloff = 1;
 541                 #endif
 542
 543                 vector top    = hitorigin + (thickdir * self.beam_thickness);
 544                 vector bottom = hitorigin - (thickdir * self.beam_thickness);
 545
 546                 R_BeginPolygon(self.beam_image, DRAWFLAG_NORMAL); // DRAWFLAG_ADDITIVE
 547                 R_PolygonVertex(top,         '0 0.5 0' + ('0 0.5 0' * (self.beam_thickness / maxthickness)), self.beam_color, self.beam_alpha);
 548                 R_PolygonVertex(last_top,    '0 0.5 0' + ('0 0.5 0' * (lastthickness / maxthickness)), self.beam_color, self.beam_alpha);
 549                 R_PolygonVertex(last_bottom, '0 0.5 0' * (1 - (lastthickness / maxthickness)),         self.beam_color, self.beam_alpha);
 550                 R_PolygonVertex(bottom,      '0 0.5 0' * (1 - (self.beam_thickness / maxthickness)),         self.beam_color, self.beam_alpha);
 551                 R_EndPolygon();
 552
 553                 // check if we're going to proceed with drawing
 554                 if(trace_fraction != 1)
 555                 {
 556                         // we're done with drawing this frame
 557                         break;
 558                 }
 559                 else
 560                 {
 561                         // continue onto the next segment
 562                         last_origin = new_origin;
 563                         last_top = top;
 564                         last_bottom = bottom;
 565                         lastthickness = self.beam_thickness;
 566                 }
 567         }
 568
 569         if(self.beam_hiteffect)
 570         {
 571                 pointparticles(self.beam_hiteffect, hitorigin, beamdir * -1, frametime * 2);
 572         }
 573         if(self.beam_muzzleflash)
 574         {
 575                 pointparticles(self.beam_muzzleflash, start_pos + wantdir * 20, wantdir * 1000, frametime * 0.1);
 576         }
 577 }
 578
 579 void Remove_ArcBeam(void)
 580 {
 581         sound(self, CH_SHOTS_SINGLE, "misc/null.wav", VOL_BASE, ATTEN_NORM);
 582 }
 583
 584 void Ent_ReadArcBeam(float isnew)
 585 {
 586         float sf = ReadByte();
 587
 588         // self.iflags = IFLAG_ORIGIN | IFLAG_ANGLES | IFLAG_V_ANGLE; // why doesn't this work?
 589         self.iflags = IFLAG_ORIGIN;
 590
 591         InterpolateOrigin_Undo();
 592
 593         if(sf & 1) // settings information
 594         {
 595                 self.beam_maxangle = ReadShort();
 596                 self.beam_range = ReadCoord();
 597                 self.beam_returnspeed = ReadShort();
 598         }
 599
 600         if(sf & 2) // starting location
 601         {
 602                 self.origin_x = ReadCoord();
 603                 self.origin_y = ReadCoord();
 604                 self.origin_z = ReadCoord();
 605                 setorigin(self, self.origin);
 606                 self.beam_usevieworigin = 0;
 607                 //WriteCoord(MSG_ENTITY, WEP_CVAR(arc, beam_range));
 608         }
 609         else // infer the location from player location
 610         {
 611                 if(autocvar_chase_active) // use player origin so that third person display still works
 612                 {
 613                         self.beam_usevieworigin = 1;
 614                         self.origin = getplayerorigin(player_localnum) + ('0 0 1' * getstati(STAT_VIEWHEIGHT));
 615                 }
 616                 else // use view origin
 617                 {
 618                         self.beam_usevieworigin = 2;
 619                         self.origin = view_origin; // note that this is only necessary for the sound to be properly located
 620                 }
 621                 setorigin(self, self.origin);
 622         }
 623
 624         if(sf & 4) // want/aim direction
 625         {
 626                 self.v_angle_x = ReadCoord();
 627                 self.v_angle_y = ReadCoord();
 628                 self.v_angle_z = ReadCoord();
 629         }
 630
 631         if(sf & 8) // beam direction
 632         {
 633                 self.angles_x = ReadCoord();
 634                 self.angles_y = ReadCoord();
 635                 self.angles_z = ReadCoord();
 636         }
 637
 638         if(sf & 16) // beam type
 639         {
 640                 self.beam_type = ReadByte();
 641                 switch(self.beam_type)
 642                 {
 643                         case ARC_BT_MISS:
 644                         {
 645                                 self.beam_color = '-1 -1 1';
 646                                 self.beam_alpha = 0.5;
 647                                 self.beam_thickness = 8;
 648                                 self.beam_traileffect = FALSE;
 649                                 self.beam_hiteffect = particleeffectnum("electro_lightning");
 650                                 self.beam_muzzleflash = FALSE; //particleeffectnum("nex_muzzleflash");
 651                                 //self.beam_muzzlemodel = "models/uziflash.md3";
 652                                 //self.beam_muzzlecolor = '-1 -1 1';
 653                                 self.beam_image = "particles/lgbeam";
 654                                 break;
 655                         }
 656                         case ARC_BT_WALL: // grenadelauncher_muzzleflash healray_muzzleflash
 657                         {
 658                                 self.beam_color = '0.5 0.5 1';
 659                                 self.beam_alpha = 0.5;
 660                                 self.beam_thickness = 8;
 661                                 self.beam_traileffect = FALSE;
 662                                 self.beam_hiteffect = particleeffectnum("electro_lightning");
 663                                 self.beam_muzzleflash = FALSE; // particleeffectnum("grenadelauncher_muzzleflash");
 664                                 //self.beam_muzzlemodel = "models/uziflash.md3";
 665                                 //self.beam_muzzlecolor = '-1 -1 1';
 666                                 self.beam_image = "particles/lgbeam";
 667                                 break;
 668                         }
 669                         case ARC_BT_HEAL:
 670                         {
 671                                 self.beam_color = '0 1 0';
 672                                 self.beam_alpha = 0.5;
 673                                 self.beam_thickness = 8;
 674                                 self.beam_traileffect = FALSE;
 675                                 self.beam_hiteffect = particleeffectnum("healray_impact");
 676                                 self.beam_muzzleflash = FALSE; //particleeffectnum("nex_muzzleflash");
 677                                 //self.beam_muzzlemodel = "models/uziflash.md3";
 678                                 //self.beam_muzzlecolor = '-1 -1 1';
 679                                 self.beam_image = "particles/lgbeam";
 680                                 break;
 681                         }
 682                         case ARC_BT_HIT:
 683                         {
 684                                 self.beam_color = '1 0 1';
 685                                 self.beam_alpha = 0.5;
 686                                 self.beam_thickness = 8;
 687                                 self.beam_traileffect = FALSE;
 688                                 self.beam_hiteffect = particleeffectnum("electro_lightning");
 689                                 self.beam_muzzleflash = FALSE; //particleeffectnum("nex_muzzleflash");
 690                                 //self.beam_muzzlemodel = "models/uziflash.md3";
 691                                 //self.beam_muzzlecolor = '-1 -1 1';
 692                                 self.beam_image = "particles/lgbeam";
 693                                 break;
 694                         }
 695                         case ARC_BT_BURST_MISS:
 696                         {
 697                                 self.beam_color = '-1 -1 1';
 698                                 self.beam_alpha = 0.5;
 699                                 self.beam_thickness = 14;
 700                                 self.beam_traileffect = FALSE;
 701                                 self.beam_hiteffect = particleeffectnum("electro_lightning");
 702                                 self.beam_muzzleflash = FALSE; //particleeffectnum("nex_muzzleflash");
 703                                 //self.beam_muzzlemodel = "models/uziflash.md3";
 704                                 //self.beam_muzzlecolor = '-1 -1 1';
 705                                 self.beam_image = "particles/lgbeam";
 706                                 break;
 707                         }
 708                         case ARC_BT_BURST_WALL:
 709                         {
 710                                 self.beam_color = '0.5 0.5 1';
 711                                 self.beam_alpha = 0.5;
 712                                 self.beam_thickness = 14;
 713                                 self.beam_traileffect = FALSE;
 714                                 self.beam_hiteffect = particleeffectnum("electro_lightning");
 715                                 self.beam_muzzleflash = FALSE; //particleeffectnum("nex_muzzleflash");
 716                                 //self.beam_muzzlemodel = "models/uziflash.md3";
 717                                 //self.beam_muzzlecolor = '-1 -1 1';
 718                                 self.beam_image = "particles/lgbeam";
 719                                 break;
 720                         }
 721                         case ARC_BT_BURST_HEAL:
 722                         {
 723                                 self.beam_color = '0 1 0';
 724                                 self.beam_alpha = 0.5;
 725                                 self.beam_thickness = 14;
 726                                 self.beam_traileffect = FALSE;
 727                                 self.beam_hiteffect = particleeffectnum("electro_lightning");
 728                                 self.beam_muzzleflash = FALSE; //particleeffectnum("nex_muzzleflash");
 729                                 //self.beam_muzzlemodel = "models/uziflash.md3";
 730                                 //self.beam_muzzlecolor = '-1 -1 1';
 731                                 self.beam_image = "particles/lgbeam";
 732                                 break;
 733                         }
 734                         case ARC_BT_BURST_HIT:
 735                         {
 736                                 self.beam_color = '1 0 1';
 737                                 self.beam_alpha = 0.5;
 738                                 self.beam_thickness = 14;
 739                                 self.beam_traileffect = FALSE;
 740                                 self.beam_hiteffect = particleeffectnum("electro_lightning");
 741                                 self.beam_muzzleflash = FALSE; //particleeffectnum("nex_muzzleflash");
 742                                 //self.beam_muzzlemodel = "models/uziflash.md3";
 743                                 //self.beam_muzzlecolor = '-1 -1 1';
 744                                 self.beam_image = "particles/lgbeam";
 745                                 break;
 746                         }
 747
 748                         // shouldn't be possible, but lets make it colorful if it does :D
 749                         default:
 750                         {
 751                                 self.beam_color = randomvec();
 752                                 self.beam_alpha = 1;
 753                                 self.beam_thickness = 8;
 754                                 self.beam_traileffect = FALSE;
 755                                 self.beam_hiteffect = FALSE;
 756                                 self.beam_muzzleflash = FALSE; //particleeffectnum("nex_muzzleflash");
 757                                 //self.beam_muzzlemodel = "models/uziflash.md3";
 758                                 //self.beam_muzzlecolor = '-1 -1 1';
 759                                 self.beam_image = "particles/lgbeam";
 760                                 break;
 761                         }
 762                 }
 763         }
 764
 765         InterpolateOrigin_Note();
 766
 767         if(isnew || !self.teleport_time)
 768         {
 769                 // calculate shot origin offset from gun alignment
 770                 float gunalign = autocvar_cl_gunalign;
 771                 if(gunalign != 1 && gunalign != 2 && gunalign != 4)
 772                         gunalign = 3; // default value
 773                 --gunalign;
 774
 775                 self.beam_shotorigin = arc_shotorigin[gunalign];
 776
 777                 // set other main attributes of the beam
 778                 self.draw = Draw_ArcBeam;
 779                 self.entremove = Remove_ArcBeam;
 780                 sound(self, CH_SHOTS_SINGLE, "weapons/lgbeam_fly.wav", VOL_BASE, ATTEN_NORM);
 781         }
 782
 783         self.teleport_time = time + 10;
 784
 785         #if 0
 786         printf(
 787                 "Ent_ReadArcBeam(%d): sf = %d, start = %s, want = %s, dir = %s, type = %d\n",
 788                 isnew,
 789                 sf,
 790                 vtos(self.beam_start),
 791                 vtos(self.v_angle),
 792                 vtos(self.angles),
 793                 self.beam_type
 794         );
 795         #endif
 796 }
 797