cl_tent.pas

雷神之锤2(Quake2)Delphi源码

  // magnitude := MSG_ReadShort (net_message);
  // color := r & $ff;
    color := $e0;
    magnitude := 60;
    CL_ParticleSteamEffect (pos, dir, color, cnt, magnitude);
    S_StartSound (@pos,  0, 0, cl_sfx_lashit, 1, ATTN_NORM, 0);
   end;

   TE_STEAM: CL_ParseSteam();

   TE_BUBBLETRAIL2: begin
  // cnt := MSG_ReadByte (net_message);
    cnt := 8;
    MSG_ReadPos (net_message, pos);
    MSG_ReadPos (net_message, pos2);
    CL_BubbleTrail2 (pos, pos2, cnt);
    S_StartSound (@pos,  0, 0, cl_sfx_lashit, 1, ATTN_NORM, 0);
   end;

   TE_MOREBLOOD: begin
    MSG_ReadPos (net_message, pos);
    MSG_ReadDir (net_message, dir);
    CL_ParticleEffect (pos, dir, $e8, 250);
   end;

   TE_CHAINFIST_SMOKE: begin
    dir[0]:=0; dir[1]:=0; dir[2]:=1;
    MSG_ReadPos(net_message, pos);
    CL_ParticleSmokeEffect (pos, dir, 0, 20, 20);
   end;

   TE_ELECTRIC_SPARKS: begin
    MSG_ReadPos (net_message, pos);
    MSG_ReadDir (net_message, dir);
  // CL_ParticleEffect (pos, dir, 109, 40);
    CL_ParticleEffect (pos, dir, $75, 40);
    //FIXME : replace or remove this sound
    S_StartSound (@pos, 0, 0, cl_sfx_lashit, 1, ATTN_NORM, 0);
   end;

   TE_TRACKER_EXPLOSION: begin
    MSG_ReadPos (net_message, pos);
    CL_ColorFlash (pos, 0, 150, -1, -1, -1);
    CL_ColorExplosionParticles (pos, 0, 1);
  // CL_Tracker_Explode (pos);
    S_StartSound (@pos, 0, 0, cl_sfx_disrexp, 1, ATTN_NORM, 0);
   end;

   TE_TELEPORT_EFFECT, TE_DBALL_GOAL: begin
    MSG_ReadPos (net_message, pos);
    CL_TeleportParticles (pos);
   end;

   TE_WIDOWBEAMOUT: CL_ParseWidow ();
   TE_NUKEBLAST: CL_ParseNuke ();

   TE_WIDOWSPLASH: begin
    MSG_ReadPos (net_message, pos);
    CL_WidowSplash (pos);
   end;
  //PGM
  //=======
   else Com_Error (ERR_DROP, 'CL_ParseTEnt: bad type');
  end;
end;

{
=========
CL_AddBeams
=========
}

procedure CL_AddBeams;
var
  i, j: Integer;
  b: Beam_p;
  Dist, Org: Vec3_t;
  d: Single;
  Ent: Entity_t;
  Yaw, Pitch, Forward_, Len, Steps, Model_length: Single;
begin
  // update beams
  for i := 0 to MAX_BEAMS - 1 do
  begin
    b := @cl_beams[i];
    if (b^.model = nil) or (b^.endtime < cl.time) then
      continue;

    // if coming from the player, update the start position
    if b^.entity = (cl.playernum + 1) then
    begin // entity 0 is the world
      VectorCopy(vec3_t(cl.refdef.vieworg), b.start);
      b^.Start[2] := b^.Start[2] - 22; // adjust for view height
    end;
    VectorAdd(b^.start, b^.offset, org);

    // calculate pitch and yaw
    VectorSubtract(b^.end_, org, dist);

    if (dist[1] = 0) and (dist[0] = 0) then
    begin
      yaw := 0;
      if (dist[2] > 0) then
        pitch := 90
      else
        pitch := 270;
    end
    else
    begin
      // PMM - fixed to correct for pitch of 0
      if (dist[0] <> 0) then
        // was yaw := (atan2(dist[1], dist[0]) * 180 / M_PI)
        yaw := (ArcTan2(dist[1], dist[0]) * 180 / M_PI)
      else if (dist[1] > 0) then
        yaw := 90
      else
        yaw := 270;
      if (yaw < 0) then
        Yaw := Yaw + 360;

      forward_ := sqrt(Sqr(dist[0]) + Sqr(dist[1]));
      pitch := (ArcTan(dist[2] / forward_) * -180.0 / M_PI);
      if (pitch < 0) then
        Pitch := Pitch + 360;
    end;

    // add new entities for the beams
    d := VectorNormalize(dist);

    FillChar(ent, sizeof(ent), 0);
    if (b.model = cl_mod_lightning) then
    begin
      model_length := 35.0;
      d := d - 20; // correction so it doesn't end in middle of tesla
    end
    else
      model_length := 30.0;

    steps := ceil(d / model_length);
    len := (d - model_length) / (steps - 1);

    // PMM - special case for lightning model .. if the real length is shorter than the model,
    // flip it around & draw it from the end to the start.  This prevents the model from going
    // through the tesla mine (instead it goes through the target)
    if (b.model = cl_mod_lightning) and (d <= model_length) then
    begin
      // Com_Printf ('special case'#10);
      VectorCopy(b^.end_, vec3_t(ent.origin));
      // offset to push beam outside of tesla model (negative because dist is from end to start
      // for this beam)
    // for j := 0 to 2 do
    //  ent.origin[j] := ent.origin[j] - (dist[j]*10.0);
      ent.model := b.model;
      ent.flags := RF_FULLBRIGHT;
      ent.angles[0] := pitch;
      ent.angles[1] := yaw;
      ent.angles[2] := random(360);
      V_AddEntity(@ent);
      exit;
    end;
    while (d > 0) do
    begin
      VectorCopy(org, vec3_t(ent.origin));
      ent.model := b.model;
      if (b.model = cl_mod_lightning) then
      begin
        ent.flags := RF_FULLBRIGHT;
        ent.angles[0] := -pitch;
        ent.angles[1] := yaw + 180.0;
        ent.angles[2] := rand() mod 360;
      end
      else
      begin
        ent.angles[0] := pitch;
        ent.angles[1] := yaw;
        ent.angles[2] := rand() mod 360;
      end;

      // Com_Printf('B: %d ^. %d'#10, b.entity, b.dest_entity);
      V_AddEntity(@ent);

      for j := 0 to 2 do
        org[j] := org[j] + (Dist[j] * len);
      d := d - model_length;
    end;
  end;
end;

{
//				Com_Printf ('Endpoint:  %f %f %f'#10, b.end[0], b.end[1], b.end[2]);
//				Com_Printf ('Pred View Angles:  %f %f %f'#10, cl.predicted_angles[0], cl.predicted_angles[1], cl.predicted_angles[2]);
//				Com_Printf ('Act View Angles: %f %f %f'#10, cl.refdef.viewangles[0], cl.refdef.viewangles[1], cl.refdef.viewangles[2]);
//				VectorCopy (cl.predicted_origin, b.start);
//				b.start[2] += 22;	// adjust for view height
//				if (fabs(cl.refdef.vieworg[2] - b.start[2]) >= 10) begin
//					b.start[2] := cl.refdef.vieworg[2];
//				end;

//				Com_Printf ('Time:  %d %d %f'#10, cl.time, cls.realtime, cls.frametime);
}

// extern cvar_t *hand;

{
=========
ROGUE - draw player locked beams
CL_AddPlayerBeams
=========
}
procedure CL_AddPlayerBeams ;
var i, j: Integer;
 b: Beam_p;
 Dist, Org, F, R, U, Len: Vec3_t;
 d: Single;
 Framenum: Integer;
 Ent: entity_t;
 Yaw, Pitch, Forward_, Len_, Steps, Model_length: Single;
 Hand_Multiplier: Single;
 Oldframe: frame_p;
 PS, OPS: player_State_p;
begin
  //PMM
  if (hand <> nil) then begin
   if (hand^.value = 2) then hand_multiplier := 0
   else if (hand^.value = 1) then hand_multiplier := -1
   else hand_multiplier := 1;
  end else hand_multiplier := 1;
  //PMM

  // update beams
  for i := 0 to MAX_BEAMS - 1 do begin
   b := @cl_playerbeams[i];
   if (b^.model = nil) or (b^.endtime < cl.time) then
     continue;

   if(cl_mod_heatbeam <> nil) and (b.model = cl_mod_heatbeam) then begin
    // if coming from the player, update the start position
    if b.entity = (cl.playernum+1) then begin	// entity 0 is the world
     // set up gun position
     // code straight out of CL_AddViewWeapon
     ps := @cl.frame.playerstate;
     j := (cl.frame.serverframe - 1) and UPDATE_MASK;
     oldframe := @cl.frames[j];
     if (oldframe^.serverframe <> cl.frame.serverframe-1) or (not oldframe^.valid) then
      oldframe := @cl.frame;		// previous frame was dropped or involid
     ops := @oldframe^.playerstate;
     for j := 0 to 2 do
      b.start[j] := cl.refdef.vieworg[j] + ops^.gunoffset[j]
         + cl.lerpfrac * (ps^.gunoffset[j] - ops^.gunoffset[j]);
     VectorMA (b.start, (hand_multiplier * b.offset[0]), cl.v_right, org);
     VectorMA (     org, b.offset[1], cl.v_forward, org);
     VectorMA (     org, b.offset[2], cl.v_up, org);
     if (hand <> nil) and (hand^.value = 2) then
      VectorMA (org, -1, cl.v_up, org);
     // FIXME - take these out when final
     VectorCopy (cl.v_right, r);
     VectorCopy (cl.v_forward, f);
     VectorCopy (cl.v_up, u);
    end else VectorCopy (b.start, org);
   end else begin
    // if coming from the player, update the start position
    if b.entity = (cl.playernum+1) then begin	// entity 0 is the world
     VectorCopy (vec3_t(cl.refdef.vieworg), b.start);
     b.start[2] := b.start[2] - 22;	// adjust for view height
    end;
    VectorAdd (b.start, b.offset, org);
   end;

   // calculate pitch and yaw
   VectorSubtract (b.end_, org, dist);

  //PMM
   if(cl_mod_heatbeam <> nil) and (b.model = cl_mod_heatbeam) and (b.entity = (cl.playernum+1)) then begin
    len_ := VectorLength (dist);
    VectorScale (f, len_, dist);
    VectorMA (dist, (hand_multiplier * b.offset[0]), r, dist);
    VectorMA (dist, b.offset[1], f, dist);
    VectorMA (dist, b.offset[2], u, dist);
    if (hand <> nil) and (hand^.value = 2) then
     VectorMA (org, -1, cl.v_up, org);
   end;
  //PMM

   if (dist[1] = 0) and (dist[0] = 0) then begin
    yaw := 0;
    if (dist[2] > 0) then
      pitch := 90
    else
      pitch := 270;
   end else begin
    // PMM - fixed to correct for pitch of 0
    if (dist[0] <> 0) then
     // was yaw := (atan2(dist[1], dist[0]) * 180 / M_PI)
     yaw := (ArcTan2(dist[1], dist[0]) * 180 / M_PI)
    else if (dist[1] > 0) then yaw := 90
    else yaw := 270;
    if (yaw < 0) then Yaw := Yaw + 360;

    forward_ := sqrt(Sqr(dist[0]) + Sqr(dist[1]));
    pitch := (ArcTan(dist[2] / forward_) * -180.0 / M_PI);
    if (pitch < 0) then Pitch := Pitch + 360;
   end;

   if (cl_mod_heatbeam <> nil) and (b.model = cl_mod_heatbeam) then begin
    if b.entity <> (cl.playernum+1) then begin
     Framenum := 2;
  //  Com_Printf ('Third person\n');
     ent.angles[0] := -pitch;
     ent.angles[1] := yaw + 180.0;
     ent.angles[2] := 0;
  //  Com_Printf ('%f %f - %f %f %f\n', -pitch, yaw+180.0, b.offset[0], b.offset[1], b.offset[2]);
     AngleVectors(vec3_t(ent.angles), @f, @r, @u);

     // if it's a non-origin offset, it's a player, so use the hardcoded player offset
     if 0 = VectorCompare (b.offset, vec3_origin) then begin
      VectorMA (org, -(b.offset[0])+1, r, org);
      VectorMA (org, -(b.offset[1]), f, org);
      VectorMA (org, -(b.offset[2])-10, u, org);
     end else begin
      // if it's a monster, do the particle effect
      CL_MonsterPlasma_Shell(b.start);
     end;
    end else begin
     framenum := 1;
    end;
   end;

   // if it's the heatbeam, draw the particle effect
   if (cl_mod_heatbeam <> nil) and (b.model = cl_mod_heatbeam) and (b.entity = (cl.playernum+1)) then begin
    CL_Heatbeam (org, dist);
   end;

   // add new entities for the beams
   d := VectorNormalize(dist);

   FillChar(ent, sizeof(ent), 0);
   if (b.model = cl_mod_heatbeam) then begin
     model_length := 32.0
   end else if (b.model = cl_mod_lightning) then begin
    model_length := 35.0;
    d := d - 20.0;  // correction so it doesn't end in middle of tesla
   end else model_length := 30.0;
   steps := ceil(d/model_length);
   len_ := (d-model_length)/(steps-1);

   // PMM - special case for lightning model .. if the real length is shorter than the model,
   // flip it around & draw it from the end to the start.  This prevents the model from going
   // through the tesla mine (instead it goes through the target)
   if (b.model = cl_mod_lightning) and (d <= model_length) then begin
  // Com_Printf ('special case\n');
    VectorCopy (b.end_, vec3_t(ent.origin));
    // offset to push beam outside of tesla model (negative because dist is from end to start
    // for this beam)
  // for j := 0 to 2 do
  //  ent.origin[j] := ent.origin[j] - dist[j]*10.0;
    ent.model := b.model;
    ent.flags := RF_FULLBRIGHT;
    ent.angles[0] := pitch;
    ent.angles[1] := yaw;
    ent.angles[2] := random(360);
    V_AddEntity (@ent);
    exit;
   end;
   while (d > 0) do begin
    VectorCopy (org, vec3_t(ent.origin));
    ent.model := b.model;
    if(cl_mod_heatbeam <> nil) and (b.model = cl_mod_heatbeam) then begin
  //  ent.flags := RF_FULLBRIGHT or RF_TRANSLUCENT;
  //  ent.alpha := 0.3;
     ent.flags := RF_FULLBRIGHT;
     ent.angles[0] := -pitch;
     ent.angles[1] := yaw + 180.0;
     ent.angles[2] := (cl.time) mod 360;
  //  ent.angles[2] := rand()%360;
     ent.frame := framenum;
    end else if (b.model = cl_mod_lightning) then begin
     ent.flags := RF_FULLBRIGHT;
     ent.angles[0] := -pitch;
     ent.angles[1] := yaw + 180.0;
     ent.angles[2] := rand() mod 360;
    end else begin
     ent.angles[0] := pitch;
     ent.angles[1] := yaw;
     ent.angles[2] := rand() mod 360;
    end;

  //  Com_Printf('B: %d ^. %d\n', b.entity, b.dest_entity);
    V_AddEntity (@ent);

    for j := 0 to 2 do
     org[j] := org[j] + dist[j]*len_;
    d := d - model_length;
   end;
  end;
end;

{
=========
CL_AddExplosions
=========
}

procedure CL_AddExplosions;
var
  Ent: Entity_p;
  i, f: Integer;
  Ex: Explosion_p;
  Frac: Single;
begin
  FillChar(ent, sizeof(ent), 0);

  for i := 0 to MAX_EXPLOSIONS - 1 do
  begin
    ex := @cl_explosions[i];
    if (ex.type_ = ex_free) then
      continue;
    Frac := (cl.time - ex.start) / 100.0;
    f := floor(frac);

    ent := @ex.ent;

    case ex.type_ of
      ex_mflash: if (f >= ex.frames - 1) then
          ex.type_ := ex_free;
      ex_misc:
        if (f >= ex.frames - 1) then
          ex.type_ := ex_free
        else
          ent^.alpha := 1.0 - frac / (ex.frames - 1);
      ex_flash:
        if (f >= 1) then
          ex.type_ := ex_free
        else
          ent^.alpha := 1.0;
      ex_poly:
        begin
          if (f >= ex.frames - 1) then
            ex.type_ := ex_free
          else
          begin
            ent^.alpha := (16.0 - f) / 16.0;

            if (f < 10) then
            begin
              ent^.skinnum := (f shr 1);
              if (ent^.skinnum < 0) then
                ent^.skinnum := 0;
            end
            else
            begin
              ent^.flags := ent^.flags or RF_TRANSLUCENT;
              if (f < 13) then
                ent^.skinnum := 5
              else
                ent^.skinnum := 6;
            end;
          end;
        end;
      ex_poly2:
        if (f >= ex.frames - 1) then
          ex.type_ := ex_free
        else
        begin
          ent^.alpha := (5.0 - f) / 5.0;
          ent^.skinnum := 0;
          ent^.flags := ent^.flags or RF_TRANSLUCENT;
        end;
    end;

    if (ex.type_ = ex_free) then
      continue;
    if (ex.light <> 0) then
      V_AddLight(vec3_t(ent^.origin), ex.light * ent^.alpha, ex.lightcolor[0], ex.lightcolor[1], ex.lightcolor[2]);

    VectorCopy(vec3_t(ent^.origin), vec3_t(ent^.oldorigin));

    if (f < 0) then
      f := 0;
    ent^.frame := ex.baseframe + f + 1;
    ent^.oldframe := ex.baseframe + f;
    ent^.backlerp := 1.0 - cl.lerpfrac;

    V_AddEntity(ent);
  end;
end;

{
=========
CL_AddLasers
=========
}

procedure CL_AddLasers;
var
  l: Laser_p;
  i: Integer;
begin
  for i := 0 to MAX_LASERS - 1 do
  begin
    l := @cl_lasers[i];
    if (l^.endtime >= cl.time) then
      V_AddEntity(@l^.ent);
  end;
end;

{ PMM - CL_Sustains }

procedure CL_ProcessSustain();
var
  s: cl_sustain_p;
  i: Integer;
begin
  for i := 0 to MAX_SUSTAINS - 1 do
  begin
    s := @cl_sustains[i];
    if (s.id <> 0) then
      if ((s.endtime >= cl.time) and (cl.time >= s.nextthink)) then
      begin
        // Com_Printf ('think %d %d %d'#10, cl.time, s^.nextthink, s^.thinkinterval);
        s.think(s);
      end
      else if (s.endtime < cl.time) then
        s.id := 0;
  end;
end;

{
=========
CL_AddTEnts
=========
}

procedure CL_AddTEnts;
begin
  CL_AddBeams();
  // PMM - draw plasma beams
  CL_AddPlayerBeams();
  CL_AddExplosions();
  CL_AddLasers();
  // PMM - set up sustain
  CL_ProcessSustain();
end;

end.