cl_newfx.pas

delphi编的不错的贪吃蛇

end;

{.$DEFINE CORKSCREW}
{.$DEFINE DOUBLE_SCREW}
{$DEFINE RINGS}
{.$DEFINE SPRAY}

{$IFDEF CORKSCREW}

procedure CL_Heatbeam(const start, end_: vec3_t);
var
  move, vec: vec3_t;
  len: Single;
  j, k: Integer;
  p: cparticle_p;
  right, up: vec3_t;
  i: Integer;
  d, c, s: Single;
  dir: vec3_t;
  ltime: Single;
  step: Integer;
begin
  step := 5;
  VectorCopy(start, move);
  VectorSubtract(end_, start, vec);
  len := VectorNormalize(vec);

  //	MakeNormalVectors (vec, right, up);
  VectorCopy(cl.v_right, right);
  VectorCopy(cl.v_up, up);
  VectorMA(move, -1, right, move);
  VectorMA(move, -1, up, move);

  VectorScale(vec, step, vec);
  ltime := cl.time / 1000.0;

  //	for i := 0 to len - 1 do
  i := 0;
  while (i < len) do
  begin
    d := i * 0.1 - fmod(ltime, 16.0) * M_PI;
    c := cos(d) / 1.75;
    s := sin(d) / 1.75;
{$IFDEF DOUBLE_SCREW}
    k := -1;
    while (k < 2) do
    begin
{$ELSE}
    k := 1;
{$ENDIF}
    if (free_particles = nil) then
      Exit;

    p := free_particles;
    free_particles := p^.next;
    p^.next := active_particles;
    active_particles := p;

    p^.time := cl.time;
    VectorClear(p^.accel);

    p^.alpha := 0.5;
    //		p^.alphavel := -1.0 / (1+frand()*0.2);
      // only last one frame!
    p^.alphavel := INSTANT_PARTICLE;
    //		p^.color := $74 + (rand() and 7);
   //			p^.color := 223 - (rand() and 7);
    p^.color := 223;
    //			p^.color := 240;

       // trim it so it looks like it's starting at the origin
    if (i < 10) then
    begin
      VectorScale(right, c * (i / 10.0) * k, dir);
      VectorMA(dir, s * (i / 10.0) * k, up, dir);
    end
    else
    begin
      VectorScale(right, c * k, dir);
      VectorMA(dir, s * k, up, dir);
    end;

    for j := 0 to 2 do
    begin
      p^.org[j] := move[j] + dir[j] * 3;
      //			p^.vel[j] := dir[j]*6;
      p^.vel[j] := 0;
    end;
{$IFDEF DOUBLE_SCREW}
    k := k + 2;
  end;
{$ENDIF}
  VectorAdd(move, vec, move);

  i := i + step;
end;
end;
{$ENDIF}
{$IFDEF RINGS}
//procedure CL_Heatbeam (vec3_t start, vec3_t end)

procedure CL_Heatbeam(const start, forward_: vec3_t);
var
  move: vec3_t;
  vec: vec3_t;
  len: Single;
  j: Integer;
  p: cparticle_p;
  right, up: vec3_t;
  i: Single;
  c, s: Single;
  dir: vec3_t;
  ltime: Single;
  step, rstep: Single;
  start_pt: Single;
  rot: Single;
  variance: Single;
  end_: vec3_t;
begin
  step := 32.0;
  VectorMA(start, 4096, forward_, end_);

  VectorCopy(start, move);
  VectorSubtract(end_, start, vec);
  len := VectorNormalize(vec);

  // FIXME - pmm - these might end up using old values?
 //	MakeNormalVectors (vec, right, up);
  VectorCopy(cl.v_right, right);
  VectorCopy(cl.v_up, up);
  if (vidref_val = VIDREF_GL) then
  begin                                 // GL mode
    VectorMA(move, -0.5, right, move);
    VectorMA(move, -0.5, up, move);
  end;
  // otherwise assume SOFT

  ltime := cl.time / 1000.0;
  start_pt := fmod(ltime * 96.0, step);
  VectorMA(move, start_pt, vec, move);

  VectorScale(vec, step, vec);

  //	Com_Printf ("%f"#10, ltime);
  rstep := M_PI / 10.0;
  i := start_pt;
  while (i < len) do
  begin
    if (i > step * 5) then              // don't bother after the 5th ring
      break;

    rot := 0.0;
    while (rot < M_PI * 2) do
    begin

      if (free_particles = nil) then
        Exit;

      p := free_particles;
      free_particles := p^.next;
      p^.next := active_particles;
      active_particles := p;

      p^.time := cl.time;
      VectorClear(p^.accel);
      //			rot := rot + fmod(ltime, 12.0)*M_PI;
      //			c := cos(rot)/2.0;
      //			s := sin(rot)/2.0;
      //			variance := 0.4 + ((float)rand()/(float)RAND_MAX) *0.2;
      variance := 0.5;
      c := cos(rot) * variance;
      s := sin(rot) * variance;

      // trim it so it looks like it's starting at the origin
      if (i < 10) then
      begin
        VectorScale(right, c * (i / 10.0), dir);
        VectorMA(dir, s * (i / 10.0), up, dir);
      end
      else
      begin
        VectorScale(right, c, dir);
        VectorMA(dir, s, up, dir);
      end;

      p^.alpha := 0.5;
      //		p^.alphavel := -1.0 / (1+frand()*0.2);
      p^.alphavel := -1000.0;
      //		p^.color := 0x74 + (rand()&7);
      p^.color := 223 - (rand() and 7);
      for j := 0 to 2 do
      begin
        p^.org[j] := move[j] + dir[j] * 3;
        //			p^.vel[j] := dir[j]*6;
        p^.vel[j] := 0;
      end;

      rot := rot + rstep;
    end;
    VectorAdd(move, vec, move);

    i := i + step;
  end;
end;
{$ENDIF}
{$IFDEF SPRAY}

procedure CL_Heatbeam(const start, end_: vec3_t);
var
  move: vec3_t;
  vec: vec3_t;
  len: Single;
  j: Integer;
  p: cparticle_p;
  forward_, right, up: vec3_t;
  i: Integer;
  d, c, s: Single;
  dir: vec3_t;
  ltime: SIngle;
  step, rstep: Single;
  start_pt: Single;
  rot: Single;
begin
  step := 32.0;
  VectorCopy(start, move);
  VectorSubtract(end_, start, vec);
  len := VectorNormalize(vec);

  //	MakeNormalVectors (vec, right, up);
  VectorCopy(cl.v_forward, forward_);
  VectorCopy(cl.v_right, right);
  VectorCopy(cl.v_up, up);
  VectorMA(move, -0.5, right, move);
  VectorMA(move, -0.5, up, move);

  for i := 0 to 7 do
  begin
    if (free_particles = nil) then
      Exit;

    p := free_particles;
    free_particles := p^.next;
    p^.next := active_particles;
    active_particles := p;

    p^.time := cl.time;
    VectorClear(p^.accel);

    d := crand() * M_PI;
    c := cos(d) * 30;
    s := sin(d) * 30;

    p^.alpha := 1.0;
    p^.alphavel := -5.0 / (1 + frand());
    p^.color := 223 - (rand() and 7);

    for j := 0 to 2 do
    begin
      p^.org[j] := move[j];
    end;
    VectorScale(vec, 450, p^.vel);
    VectorMA(p^.vel, c, right, p^.vel);
    VectorMA(p^.vel, s, up, p^.vel);
  end;
  // Sly 30-Jun-2002 This section was commented in the original source
  (*

   ltime = (float) cl.time/1000.0;
   start_pt = fmod(ltime*16.0,step);
   VectorMA (move, start_pt, vec, move);

   VectorScale (vec, step, vec);

  //	Com_Printf ("%f"#10, ltime);
   rstep = M_PI/12.0;
   for (i=start_pt ; i<len ; i+=step)
   begin
    if (i>step*5) // don't bother after the 5th ring
     break;

    for (rot = 0; rot < M_PI*2; rot += rstep)
    begin
     if (!free_particles)
      return;

     p = free_particles;
     free_particles = p^.next;
     p^.next = active_particles;
     active_particles = p;

     p^.time = cl.time;
     VectorClear (p^.accel);
  //			rot+= fmod(ltime, 12.0)*M_PI;
  //			c = cos(rot)/2.0;
  //			s = sin(rot)/2.0;
     c = cos(rot)/1.5;
     s = sin(rot)/1.5;

     // trim it so it looks like it's starting at the origin
     if (i < 10)
     begin
      VectorScale (right, c*(i/10.0), dir);
      VectorMA (dir, s*(i/10.0), up, dir);
     end;
     else
     begin
      VectorScale (right, c, dir);
      VectorMA (dir, s, up, dir);
     end;

     p^.alpha = 0.5;
   //		p^.alphavel = -1.0 / (1+frand()*0.2);
     p^.alphavel = -1000.0;
   //		p^.color = 0x74 + (rand()&7);
     p^.color = 223 - (rand()&7);
     for (j=0 ; j<3 ; j++)
     begin
      p^.org[j] = move[j] + dir[j]*3;
   //			p^.vel[j] = dir[j]*6;
      p^.vel[j] = 0;
     end;
    end;
    VectorAdd (move, vec, move);
   end;
  *)
end;
{$ENDIF}

(*
===============
CL_ParticleSteamEffect

Puffs with velocity along direction, with some randomness thrown in
===============
*)

procedure CL_ParticleSteamEffect(var org, dir: vec3_t; color, count, magnitude: Integer);
var
  i, j: Integer;
  p: cparticle_p;
  d: Single;
  r, u: vec3_t;
begin
  //	vectoangles2 (dir, angle_dir);
  //	AngleVectors (angle_dir, f, r, u);

  MakeNormalVectors(dir, r, u);

  for i := 0 to count - 1 do
  begin
    if (free_particles = nil) then
      Exit;
    p := free_particles;
    free_particles := p^.next;
    p^.next := active_particles;
    active_particles := p;

    p^.time := cl.time;
    p^.color := color + (rand() and 7);

    for j := 0 to 2 do
    begin
      p^.org[j] := org[j] + magnitude * 0.1 * crand();
      //			p^.vel[j] := dir[j]*magnitude;
    end;
    VectorScale(dir, magnitude, p^.vel);
    d := crand() * magnitude / 3;
    VectorMA(p^.vel, d, r, p^.vel);
    d := crand() * magnitude / 3;
    VectorMA(p^.vel, d, u, p^.vel);

    p^.accel[0] := 0;
    p^.accel[1] := 0;
    p^.accel[2] := -PARTICLE_GRAVITY / 2;
    p^.alpha := 1.0;

    p^.alphavel := -1.0 / (0.5 + frand() * 0.3);
  end;
end;

procedure CL_ParticleSteamEffect2(self: cl_sustain_p);
//vec3_t org, vec3_t dir, int color, int count, int magnitude)
var
  i, j: Integer;
  p: cparticle_p;
  d: Single;
  r, u: vec3_t;
  dir: vec3_t;
begin
  //	vectoangles2 (dir, angle_dir);
  //	AngleVectors (angle_dir, f, r, u);

  VectorCopy(self^.dir, dir);
  MakeNormalVectors(dir, r, u);

  for i := 0 to self^.count - 1 do
  begin
    if (free_particles = nil) then
      Exit;
    p := free_particles;
    free_particles := p^.next;
    p^.next := active_particles;
    active_particles := p;

    p^.time := cl.time;
    p^.color := self^.color + (rand() and 7);

    for j := 0 to 2 do
    begin
      p^.org[j] := self^.org[j] + self^.magnitude * 0.1 * crand();
      //			p^.vel[j] := dir[j]*magnitude;
    end;
    VectorScale(dir, self^.magnitude, p^.vel);
    d := crand() * self^.magnitude / 3;
    VectorMA(p^.vel, d, r, p^.vel);
    d := crand() * self^.magnitude / 3;
    VectorMA(p^.vel, d, u, p^.vel);

    p^.accel[0] := 0;
    p^.accel[1] := 0;
    p^.accel[2] := -PARTICLE_GRAVITY / 2;
    p^.alpha := 1.0;

    p^.alphavel := -1.0 / (0.5 + frand() * 0.3);
  end;
  self^.nextthink := self^.nextthink + self^.thinkinterval;
end;

(*
===============
CL_TrackerTrail
===============
*)

procedure CL_TrackerTrail(const start, end_: vec3_t; particleColor: Integer);
var
  move: vec3_t;
  vec: vec3_t;
  forward_, right, up, angle_dir: vec3_t;
  len: Single;
  j: Integer;
  p: cparticle_p;
  dec: Integer;
  dist: Single;
begin
  VectorCopy(start, move);
  VectorSubtract(end_, start, vec);
  len := VectorNormalize(vec);

  VectorCopy(vec, forward_);
  vectoangles2(forward_, angle_dir);
  AngleVectors(angle_dir, @forward_, @right, @up);

  dec := 3;
  VectorScale(vec, 3, vec);

  // FIXME: this is a really silly way to have a loop
  while (len > 0) do
  begin
    len := len - dec;

    if (free_particles = nil) then
      Exit;
    p := free_particles;
    free_particles := p^.next;
    p^.next := active_particles;