cl_fx.pas

delphi编的不错的贪吃蛇

    len := len - dec;

    if (free_particles = nil) then
      exit;
    p := free_particles;
    free_particles := p.next;
    p.next := active_particles;
    active_particles := p;
    VectorClear(p.accel);

    p.time := cl.time;

    p.alpha := 1.0;
    p.alphavel := -1.0 / (0.3 + frand() * 0.2);
    p.color := $E0;
    for j := 0 to 2 do
    begin
      p.org[j] := move[j] + crand();
      p.vel[j] := crand() * 5;
      p.accel[j] := 0;
    end;

    VectorAdd(move, vec, move);
  end;
end;

(*
===============
CL_QuadTrail

===============
*)

procedure CL_QuadTrail(const start, end_: vec3_t);
var
  move, vec: vec3_t;
  len: single;
  j: integer;
  p: cparticle_p;
  dec: integer;
begin
  VectorCopy(start, move);
  VectorSubtract(end_, start, vec);
  len := VectorNormalize(vec);

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

  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;
    active_particles := p;
    VectorClear(p.accel);

    p.time := cl.time;

    p.alpha := 1.0;
    p.alphavel := -1.0 / (0.8 + frand() * 0.2);
    p.color := 115;
    for j := 0 to 2 do
    begin
      p.org[j] := move[j] + crand() * 16;
      p.vel[j] := crand() * 5;
      p.accel[j] := 0;
    end;

    VectorAdd(move, vec, move);
  end;
end;

(*
===============
CL_FlagTrail

===============
*)

procedure CL_FlagTrail(const start, end_: vec3_t; color: single);
var
  move: vec3_t;
  vec: vec3_t;
  len: single;
  j: integer;
  p: cparticle_p;
  dec_: integer;
begin
  VectorCopy(start, move);
  VectorSubtract(end_, start, vec);
  len := VectorNormalize(vec);

  dec_ := 5;
  VectorScale(vec, 5, vec);

  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;
    active_particles := p;
    VectorClear(p.accel);

    p.time := cl.time;

    p.alpha := 1.0;
    p.alphavel := -1.0 / (0.8 + frand() * 0.2);
    p.color := color;
    for j := 0 to 2 do
    begin
      p.org[j] := move[j] + crand() * 16;
      p.vel[j] := crand() * 5;
      p.accel[j] := 0;
    end;

    VectorAdd(move, vec, move);
  end;
end;

(*
===============
CL_DiminishingTrail

===============
*)

procedure CL_DiminishingTrail(const start, end_: vec3_t; old: centity_p; flags: integer);
var
  move_: vec3_t;
  vec: vec3_t;
  len: single;
  j: integer;
  p: cparticle_p;
  dec_,
    orgscale,
    velscale: single;
begin
  VectorCopy(start, move_);
  VectorSubtract(end_, start, vec);
  len := VectorNormalize(vec);

  dec_ := 0.5;
  VectorScale(vec, dec_, vec);

  if (old.trailcount > 900) then
  begin
    orgscale := 4;
    velscale := 15;
  end
  else if (old.trailcount > 800) then
  begin
    orgscale := 2;
    velscale := 10;
  end
  else
  begin
    orgscale := 1;
    velscale := 5;
  end;

  while (len > 0) do
  begin
    len := len - dec_;

    if (free_particles = nil) then
      exit;

    // drop less particles as it flies
    if ((rand() and 1023) < old.trailcount) then
    begin
      p := free_particles;
      free_particles := p.next;
      p.next := active_particles;
      active_particles := p;
      VectorClear(p.accel);

      p.time := cl.time;

      if (flags and EF_GIB <> 0) then
      begin
        p.alpha := 1.0;
        p.alphavel := -1.0 / (1 + frand() * 0.4);
        p.color := $E8 + (rand() and 7);
        for j := 0 to 2 do
        begin
          p.org[j] := move_[j] + crand() * orgscale;
          p.vel[j] := crand() * velscale;
          p.accel[j] := 0;
        end;
        p.vel[2] := p.vel[2] - PARTICLE_GRAVITY;
      end
      else if (flags and EF_GREENGIB <> 0) then
      begin
        p.alpha := 1.0;
        p.alphavel := -1.0 / (1 + frand() * 0.4);
        p.color := $DB + (rand() and 7);
        for j := 0 to 2 do
        begin
          p.org[j] := move_[j] + crand() * orgscale;
          p.vel[j] := crand() * velscale;
          p.accel[j] := 0;
        end;
        p.vel[2] := p.vel[2] - PARTICLE_GRAVITY;
      end
      else
      begin
        p.alpha := 1.0;
        p.alphavel := -1.0 / (1 + frand() * 0.2);
        p.color := 4 + (rand() and 7);
        for j := 0 to 2 do
        begin
          p.org[j] := move_[j] + crand() * orgscale;
          p.vel[j] := crand() * velscale;
        end;
        p.accel[2] := 20;
      end;
    end;

    old.trailcount := old.trailcount - 5;
    if (old.trailcount < 100) then
      old.trailcount := 100;
    VectorAdd(move_, vec, move_);
  end;
end;

procedure MakeNormalVectors(var forward_, right, up: vec3_t);
var
  d: single;
begin
  // this rotate and negat guarantees a vector
  // not colinear with the original
  right[1] := -forward_[0];
  right[2] := forward_[1];
  right[0] := forward_[2];

  d := DotProduct(right, forward_);
  VectorMA(right, -d, forward_, right);
  VectorNormalize(right);
  CrossProduct(right, forward_, up);
end;

(*
===============
CL_RocketTrail

===============
*)

procedure CL_RocketTrail(const start, end_: vec3_t; old: centity_p);
var
  move, vec: vec3_t;
  len: single;
  j: integer;
  p: cparticle_p;
  dec: single;
begin
  // smoke
  CL_DiminishingTrail(start, end_, old, EF_ROCKET);

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

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

  while (len > 0) do
  begin
    len := len - dec;

    if (free_particles = nil) then
      exit;

    if ((rand() and 7) = 0) then
    begin
      p := free_particles;
      free_particles := p.next;
      p.next := active_particles;
      active_particles := p;

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

      p.alpha := 1.0;
      p.alphavel := -1.0 / (1 + frand() * 0.2);
      p.color := $DC + (rand() and 3);
      for j := 0 to 2 do
      begin
        p.org[j] := move[j] + crand() * 5;
        p.vel[j] := crand() * 20;
      end;
      p.accel[2] := -PARTICLE_GRAVITY;
    end;
    VectorAdd(move, vec, move);
  end;
end;

(*
===============
CL_RailTrail

===============
*)

procedure CL_RailTrail(const start, end_: vec3_t);
var
  move, vec: vec3_t;
  len: single;
  j: integer;
  p: cparticle_p;
  dec: single;
  right, up: vec3_t;
  i: integer;
  d, c, s: single;
  dir: vec3_t;
  clr: byte;
begin
  clr := $74;
  VectorCopy(start, move);
  VectorSubtract(end_, start, vec);
  len := VectorNormalize(vec);

  MakeNormalVectors(vec, right, up);

  for i := 0 to round(len) - 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;
    VectorClear(p.accel);

    d := i * 0.1;
    c := cos(d);
    s := sin(d);

    VectorScale(right, c, dir);
    VectorMA(dir, s, up, dir);

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

    VectorAdd(move, vec, move);
  end;

  dec := 0.75;
  VectorScale(vec, dec, vec);
  VectorCopy(start, move);

  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;
    active_particles := p;

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

    p.alpha := 1.0;
    p.alphavel := -1.0 / (0.6 + frand() * 0.2);
    p.color := $0 + rand() and 15;

    for j := 0 to 2 do
    begin
      p.org[j] := move[j] + crand() * 3;
      p.vel[j] := crand() * 3;
      p.accel[j] := 0;
    end;

    VectorAdd(move, vec, move);
  end;
end;

// RAFAEL
(*
===============
CL_IonripperTrail
===============
*)

procedure CL_IonripperTrail(const start, ent: vec3_t);
var
  move, vec: vec3_t;
  len: single;
  j: integer;
  p: cparticle_p;
  dec: integer;
  left: integer;
begin
  left := 0;
  VectorCopy(start, move);
  VectorSubtract(ent, start, vec);
  len := VectorNormalize(vec);

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

  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;
    active_particles := p;
    VectorClear(p.accel);

    p.time := cl.time;
    p.alpha := 0.5;
    p.alphavel := -1.0 / (0.3 + frand() * 0.2);
    p.color := $E4 + (rand() and 3);

    for j := 0 to 2 do
    begin
      p.org[j] := move[j];
      p.accel[j] := 0;
    end;
    if (left <> 0) then
    begin
      left := 0;
      p.vel[0] := 10;
    end
    else
    begin
      left := 1;
      p.vel[0] := -10;
    end;

    p.vel[1] := 0;
    p.vel[2] := 0;

    VectorAdd(move, vec, move);
  end;
end;

(*
===============
CL_BubbleTrail

===============
*)

procedure CL_BubbleTrail(const start, end_: vec3_t);
var
  move, vec: vec3_t;
  len: single;
  i, j: integer;
  p: cparticle_p;
  dec: integer;
begin
  VectorCopy(start, move);
  VectorSubtract(end_, start, vec);
  len := VectorNormalize(vec);

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

  i := 0;
  while (i < len) do
  begin
    if (free_particles = nil) then
      exit;

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

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

    p.alpha := 1.0;
    p.alphavel := -1.0 / (1 + frand() * 0.2);
    p.color := 4 + (rand() and 7);
    for j := 0 to 2 do
    begin
      p.org[j] := move[j] + crand() * 2;
      p.vel[j] := crand() * 5;
    end;
    p.vel[2] := p.vel[2] + 6;

    VectorAdd(move, vec, move);
    i := i + dec;
  end;
end;

(*
===============
CL_FlyParticles
===============
*)