cl_tent.pas

delphi编的不错的贪吃蛇

{$ALIGN ON}{$MINENUMSIZE 4}
{----------------------------------------------------------------------------}
{                                                                            }
{ File(s): client\cl_tent.c                                                  }
{                                                                            }
{ Initial conversion by : Juha Hartikainen ([e-mail])             }
{ Initial conversion on : 02-Jun-2002                                        }
{                                                                            }
{ This File contains part of convertion of Quake2 source to ObjectPascal.    }
{ More information about this project can be found at:                       }
{ http://www.sulaco.co.za/quake2/                                            }
{                                                                            }
{ Copyright (C) 1997-2001 Id Software, Inc.                                  }
{                                                                            }
{ This program is free software; you can redistribute it and/or              }
{ modify it under the terms of the GNU General Public License                }
{ as published by the Free Software Foundation; either version 2             }
{ of the License, or (at your option) any later version.                     }
{                                                                            }
{ This program is distributed in the hope that it will be useful,            }
{ but WITHOUT ANY WARRANTY; without even the implied warranty of             }
{ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.                       }
{                                                                            }
{ See the GNU General Public License for more details.                       }
{                                                                            }
{----------------------------------------------------------------------------}
// cl_tent.c -- client side temporary entities
unit cl_tent;

interface

uses
  client,
  ref,
  {$IFDEF WIN32}
  Windows,
  vid_dll,
  {$ELSE}
  vid_so,
  {$ENDIF}
  Cpas,
  Math,
  Common,
  q_shared,
  snd_dma,
  snd_loc;

type
  ExpType_t = (ex_free, ex_explosion, ex_misc, ex_flash, ex_mflash, ex_poly, ex_poly2);

  explosion_p = ^explosion_t;
  explosion_t = record
    type_: ExpType_t;
    ent: Entity_t;

    Frames: Integer;
    Light: Single;
    LightColor: vec3_t;
    Start: Single;
    BaseFrame: Integer;
  end;

const
  MAX_EXPLOSIONS = 32;

var
  cl_explosions: array[0..MAX_EXPLOSIONS - 1] of explosion_t;

const
  MAX_BEAMS = 32;

type
  beam_p = ^beam_t;
  beam_t = record
    Entity, Dest_Entity: Integer;
    Model: Model_p;
    EndTime: Integer;
    Offset, Start, End_: vec3_t;
  end;

var
  cl_beams, cl_playerbeams: array[0..MAX_BEAMS - 1] of beam_t;
  //PMM - added this [cl_playerbeams] for player-linked beams.  Currently only used by the plasma beam

const
  MAX_LASERS = 32;

type
  laser_p = ^laser_t;
  laser_t = record
    Ent: entity_t;
    EndTime: Integer;
  end;

var
  cl_lasers: array[0..MAX_LASERS - 1] of laser_t;

  //ROGUE
  cl_sustains: array[0..MAX_SUSTAINS - 1] of cl_sustain_t;
  //ROGUE

var
  cl_sfx_ric1, cl_sfx_ric2, cl_sfx_ric3,
    cl_sfx_lashit,
    cl_sfx_spark5, cl_sfx_spark6, cl_sfx_spark7,
    cl_sfx_railg,
    cl_sfx_rockexp, cl_sfx_grenexp, cl_sfx_watrexp,
    // RAFAEL
  cl_sfx_plasexp: sfx_p;
  cl_sfx_footsteps: array[0..3] of sfx_p;

  cl_mod_explode, cl_mod_smoke, cl_mod_flash,
    cl_mod_parasite_segment,
    cl_mod_grapple_cable,
    cl_mod_parasite_tip,
    cl_mod_explo4, cl_mod_bfg_explo,
    cl_mod_powerscreen,
    // RAFAEL
  cl_mod_plasmaexplo: model_p;

  //ROGUE
  cl_sfx_lightning, cl_sfx_disrexp: sfx_p;
  cl_mod_lightning, cl_mod_heatbeam,
    cl_mod_monster_heatbeam,
    cl_mod_explo4_big: model_p;
  //ROGUE

procedure CL_RegisterTEntModels;
procedure CL_AddTEnts;
procedure CL_ClearTEnts;
procedure CL_SmokeAndFlash(const Origin: vec3_t);
procedure CL_RegisterTEntSounds;
procedure CL_ParseTEnt;

implementation

uses
  net_chan,
  cl_fx,
  cl_view,
  cl_newfx,
  cl_main;

{
=========
CL_RegisterTEntSounds
=========
}

procedure CL_RegisterTEntSounds;
var
  i: Integer;
  Name: array[0..MAX_QPATH - 1] of char;
begin

  // PMM - version stuff
  //Com_Printf ('%s'#10, ROGUE_VERSION_STRING);
  // PMM
  cl_sfx_ric1 := S_RegisterSound('world/ric1.wav');
  cl_sfx_ric2 := S_RegisterSound('world/ric2.wav');
  cl_sfx_ric3 := S_RegisterSound('world/ric3.wav');
  cl_sfx_lashit := S_RegisterSound('weapons/lashit.wav');
  cl_sfx_spark5 := S_RegisterSound('world/spark5.wav');
  cl_sfx_spark6 := S_RegisterSound('world/spark6.wav');
  cl_sfx_spark7 := S_RegisterSound('world/spark7.wav');
  cl_sfx_railg := S_RegisterSound('weapons/railgf1a.wav');
  cl_sfx_rockexp := S_RegisterSound('weapons/rocklx1a.wav');
  cl_sfx_grenexp := S_RegisterSound('weapons/grenlx1a.wav');
  cl_sfx_watrexp := S_RegisterSound('weapons/xpld_wat.wav');
  // RAFAEL
  // cl_sfx_plasexp := S_RegisterSound ('weapons/plasexpl.wav');
  S_RegisterSound('player/land1.wav');

  S_RegisterSound('player/fall2.wav');
  S_RegisterSound('player/fall1.wav');

  for i := 0 to 3 do
  begin
    Com_sprintf(name, sizeof(name), 'player/step%d.wav', [i + 1]);
    cl_sfx_footsteps[i] := S_RegisterSound(name);
  end;

  //PGM
  cl_sfx_lightning := S_RegisterSound('weapons/tesla.wav');
  cl_sfx_disrexp := S_RegisterSound('weapons/disrupthit.wav');
  // version stuff
  //sprintf (name, 'weapons/sound%d.wav', ROGUE_VERSION_ID);
  //if (name[0] = 'w')
  // name[0] := 'W';
  //PGM
end;

{
=========
CL_RegisterTEntModels
=========
}

procedure CL_RegisterTEntModels;
begin
  cl_mod_explode := re.RegisterModel('models/objects/explode/tris.md2');
  cl_mod_smoke := re.RegisterModel('models/objects/smoke/tris.md2');
  cl_mod_flash := re.RegisterModel('models/objects/flash/tris.md2');
  cl_mod_parasite_segment := re.RegisterModel('models/monsters/parasite/segment/tris.md2');
  cl_mod_grapple_cable := re.RegisterModel('models/ctf/segment/tris.md2');
  cl_mod_parasite_tip := re.RegisterModel('models/monsters/parasite/tip/tris.md2');
  cl_mod_explo4 := re.RegisterModel('models/objects/r_explode/tris.md2');
  cl_mod_bfg_explo := re.RegisterModel('sprites/s_bfg2.sp2');
  cl_mod_powerscreen := re.RegisterModel('models/items/armor/effect/tris.md2');

  re.RegisterModel('models/objects/laser/tris.md2');
  re.RegisterModel('models/objects/grenade2/tris.md2');
  re.RegisterModel('models/weapons/v_machn/tris.md2');
  re.RegisterModel('models/weapons/v_handgr/tris.md2');
  re.RegisterModel('models/weapons/v_shotg2/tris.md2');
  re.RegisterModel('models/objects/gibs/bone/tris.md2');
  re.RegisterModel('models/objects/gibs/sm_meat/tris.md2');
  re.RegisterModel('models/objects/gibs/bone2/tris.md2');
  // RAFAEL
  // re.RegisterModel ('models/objects/blaser/tris.md2');

  re.RegisterPic('w_machinegun');
  re.RegisterPic('a_bullets');
  re.RegisterPic('i_health');
  re.RegisterPic('a_grenades');

  //ROGUE
  cl_mod_explo4_big := re.RegisterModel('models/objects/r_explode2/tris.md2');
  cl_mod_lightning := re.RegisterModel('models/proj/lightning/tris.md2');
  cl_mod_heatbeam := re.RegisterModel('models/proj/beam/tris.md2');
  cl_mod_monster_heatbeam := re.RegisterModel('models/proj/widowbeam/tris.md2');
  //ROGUE
end;

{
=========
CL_ClearTEnts
=========
}

procedure CL_ClearTEnts;
begin
  // it's possible to eliminate the def and use only the memset instruction ..by FAB
  {$IFDEF WIN32}
  ZeroMemory(@cl_beams, sizeof(cl_beams));
  ZeroMemory(@cl_explosions, sizeof(cl_explosions));
  ZeroMemory(@cl_lasers, sizeof(cl_lasers));
  {$ELSE}
  memset (@cl_beams, 0, sizeof(cl_beams));
  memset (@cl_explosions, 0, sizeof(cl_explosions));
  memset (@cl_lasers, 0, sizeof(cl_lasers));
  {$ENDIF}

  //ROGUE
  {$IFDEF WIN32}
  ZeroMemory(@cl_playerbeams, sizeof(cl_playerbeams));
  ZeroMemory(@cl_sustains, sizeof(cl_sustains));
  {$ELSE}
  memset (@cl_playerbeams, 0, sizeof(cl_playerbeams));
  memset (@cl_sustains, 0, sizeof(cl_sustains));
  {$ENDIF}
  //ROGUE}
end;

{
=========
CL_AllocExplosion
=========
}

function CL_AllocExplosion: Explosion_p;
var
  i, time, index: Integer;
begin
  for i := 0 to MAX_EXPLOSIONS - 1 do
  begin
    if (cl_explosions[i].type_ = ex_free) then
    begin
      FillChar(cl_explosions[i], SizeOf(cl_explosions[i]), 0);
      Result := @cl_explosions[i];
      Exit;
    end;
  end;
  // find the oldest explosion
  time := cl.time;
  index := 0;

  for i := 0 to MAX_EXPLOSIONS - 1 do
    if (cl_explosions[i].start < time) then
    begin
      time := Round(cl_explosions[i].start);
      index := i;
    end;
  FillChar(cl_explosions[index], SizeOf(cl_explosions[index]), 0);
  Result := @cl_explosions[index];
end;

{
=========
CL_SmokeAndFlash
=========
}

procedure CL_SmokeAndFlash(const Origin: vec3_t);
var
  ex: Explosion_p;
begin
  ex := CL_AllocExplosion();
  VectorCopy(origin, vec3_t(ex^.ent.origin));
  ex^.type_ := ex_misc;
  ex^.frames := 4;
  ex^.ent.flags := RF_TRANSLUCENT;
  ex^.start := cl.frame.servertime - 100;
  ex^.ent.model := cl_mod_smoke;

  ex := CL_AllocExplosion();
  VectorCopy(origin, vec3_t(ex^.ent.origin));
  ex^.type_ := ex_flash;
  ex^.ent.flags := RF_FULLBRIGHT;
  ex^.frames := 2;
  ex^.start := cl.frame.servertime - 100;
  ex^.ent.model := cl_mod_flash;
end;

{
=========
CL_ParseParticles
=========
}

procedure CL_ParseParticles;
var
  Color, Count: Integer;
  Pos, Dir: vec3_t;
begin
  MSG_ReadPos(net_message, pos);
  MSG_ReadDir(net_message, dir);

  color := MSG_ReadByte(net_message);
  count := MSG_ReadByte(net_message);

  CL_ParticleEffect(pos, dir, color, count);
end;

{
=========
CL_ParseBeam / CL_ParseBeam2
=========
}

function CL_ParseBeam(Model: Model_p): Integer;
var
  ent: Integer;
  start, end_: vec3_t;
  b: beam_p;
  i: Integer;
begin
  ent := MSG_ReadShort(net_message);

  MSG_ReadPos(net_message, start);
  MSG_ReadPos(net_message, end_);

  // override any beam with the same entity
  b := @cl_beams;
  for i := 0 to MAX_BEAMS - 1 do
  begin
    if (b^.entity = ent) then
    begin
      b^.entity := ent;
      b^.model := model;
      b^.endtime := cl.time + 200;
      VectorCopy(start, b^.start);
      VectorCopy(end_, b^.end_);
      VectorClear(b^.offset);
      Result := ent;
      Exit;
    end;
    Inc(b);
  end;
  // find a free beam
  b := @cl_beams;
  for i := 0 to MAX_BEAMS - 1 do
  begin
    if (b^.model = nil) or (b^.endtime < cl.time) then
    begin
      b^.entity := ent;
      b^.model := model;
      b^.endtime := cl.time + 200;
      VectorCopy(start, b^.start);
      VectorCopy(end_, b^.end_);
      VectorClear(b^.offset);
      Result := ent;
      Exit;
    end;
    Inc(b);
  end;
  Com_Printf('beam list overflow!'#10);
  Result := ent;
end;

function CL_ParseBeam2(Model: Model_p): Integer;
var
  ent: Integer;
  start, end_, offset: vec3_t;
  b: beam_p;
  i: Integer;
begin
  ent := MSG_ReadShort(net_message);

  MSG_ReadPos(net_message, start);
  MSG_ReadPos(net_message, end_);
  MSG_ReadPos(net_message, offset);

  //	Com_Printf ("end- %f %f %f\n", end[0], end[1], end[2]);

  // override any beam with the same entity

  b := @cl_beams;
  for i := 0 to MAX_BEAMS - 1 do
  begin
    if (b^.entity = ent) then
    begin
      b^.entity := ent;
      b^.model := model;
      b^.endtime := cl.time + 200;
      VectorCopy(start, b^.start);
      VectorCopy(end_, b^.end_);
      VectorCopy(offset, b^.offset);
      Result := ent;
      Exit;
    end;
    Inc(b);
  end;
  // find a free beam
  b := @cl_beams;
  for i := 0 to MAX_BEAMS - 1 do
  begin
    if (b^.model = nil) or (b^.endtime < cl.time) then
    begin
      b^.entity := ent;
      b^.model := model;
      b^.endtime := cl.time + 200;
      VectorCopy(start, b^.start);
      VectorCopy(end_, b^.end_);
      VectorCopy(offset, b^.offset);
      Result := ent;
      Exit;