p_client.pas

delphi编的不错的贪吃蛇

                           message := 'feels';
                           message2 := '"s pain';
                         end;
        MOD_TELEFRAG:   begin
                          message := 'tried to invade';
                          message2 := '"s personal space';
                        end;
{$IFDEF CTF}  //onlyCTF
//ZOID
        MOD_GRAPPLE:    begin
                          message := 'was caught by';
                          message2 := '"s grapple';
                        end;
//ZOID
{$ENDIF}
      end;//case

      if (message) then
      begin
        gi.bprintf (PRINT_MEDIUM, '%s %s %s%s\n', self.client.pers.netname, message, attacker.client.pers.netname, message2);
        if (deathmatch.value) then
          if (ff)
          then attacker->client->resp.score--;
          else attacker->client->resp.score++;
        Exit;
      end;
    end;//if
  end;//if

  gi.bprintf (PRINT_MEDIUM, '%s died.\n', self.client.pers.netname);
  if (deathmatch.value) then
    self->client->resp.score--;
end;//procedure (GAME <> CTF)

//Y: ???
void Touch_Item (edict_t *ent, edict_t *other, cplane_t *plane, csurface_t *surf);

// (GAME=CTF)
procedure TossClientWeapon (edict_t *self);
var
	gitem_t		*item;
	edict_t		*drop;
  quad   : qboolean;
  spread : float;
begin
  if (!deathmatch.value) then
    Exit;

  item := self.client.pers.weapon;
  if (! self.client.pers.inventory[self.client.ammo_index] ) then
    item = NULL;
  if (item && (strcmp (item.pickup_name, 'Blaster') == 0)) then
    item = NULL;

  if (!((int)(dmflags.value) & DF_QUAD_DROP))
  then quad := false
  else quad := (self.client.quad_framenum > (level.framenum + 10));

  if (item AND quad)
  then spread := 22.5
  else spread := 0.0;

  if (item) then
  begin
    self.client.v_angle[YAW] := self.client.v_angle[YAW] - spread;
    drop := Drop_Item (self, item);
    self.client.v_angle[YAW] := self.client.v_angle[YAW] + spread;
    drop.spawnflags := DROPPED_PLAYER_ITEM;
  end;

  if (quad) then
  begin
    self.client.v_angle[YAW] := self.client.v_angle[YAW] + spread;
    drop := Drop_Item (self, FindItemByClassname ('item_quad'));
    self.client.v_angle[YAW] := self.client.v_angle[YAW] - spread;
    drop.spawnflags := drop.spawnflags OR DROPPED_PLAYER_ITEM;

    drop.touch := Touch_Item;
    drop.nextthink := level.time + (self.client.quad_framenum - level.framenum) * FRAMETIME;
    drop.think := G_FreeEdict;
  end;
end;//procedure (GAME=CTF)


{*
==================
LookAtKiller
==================
*}
// (GAME=CTF)
procedure LookAtKiller (edict_t *self, edict_t *inflictor, edict_t *attacker);
var
  dir : vec3_t;
begin
  if (attacker) AND (attacker <> world) AND (attacker <> self)
  then VectorSubtract (attacker.s.origin, self.s.origin, dir)
  else
    if (inflictor) AND (inflictor <> world) AND (inflictor <> self)
    then VectorSubtract (inflictor.s.origin, self.s.origin, dir)
    else begin
      self.client.killer_yaw := self.s.angles[YAW];
      Exit;
    end;

  if (dir[0])
  then self.client.killer_yaw := 180/M_PI*atan2(dir[1], dir[0])
  else begin
    self.client.killer_yaw := 0;
    if (dir[1] > 0)
    then self.client.killer_yaw := 90
    else
      if (dir[1] < 0) then
        self.client.killer_yaw := -90;
  end;
  if (self.client.killer_yaw < 0) then
    self.client.killer_yaw := self.client.killer_yaw + 360;
end;//procedure (GAME=CTF)


{*
==================
player_die
==================
*}
// (GAME <> CTF)
procedure player_die (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point);
var
  n : integer;
        static int i;

begin
  VectorClear (self.avelocity);

  self.takedamage := DAMAGE_YES;
  self.movetype := MOVETYPE_TOSS;

  self.s.modelindex2 := 0;	// remove linked weapon model

{$IFDEF CTF}  //onlyCTF
//ZOID
  self.s.modelindex3 := 0;        // remove linked ctf flag
//ZOID
{$ENDIF}

  self.s.angles[0] := 0;
  self.s.angles[2] := 0;

  self.s.sound := 0;
  self.client.weapon_sound := 0;

  self.maxs[2] := -8;

//idsoft	self->solid = SOLID_NOT;
  self.svflags := self.svflags OR SVF_DEADMONSTER;

  if (!self.deadflag) then
  begin
    self.client.respawn_time := level.time + 1.0;
    LookAtKiller (self, inflictor, attacker);
    self.client.ps.pmove.pm_type := PM_DEAD;
    ClientObituary (self, inflictor, attacker);

{$IFDEF CTF}  //onlyCTF
//ZOID
    // if at start and same team, clear
    if (ctf->value && meansOfDeath == MOD_TELEFRAG) AND
       (self.client.resp.ctf_state < 2) AND
       (self.client.resp.ctf_team = attacker.client.resp.ctf_team) then
    begin
      attacker->client->resp.score--;
      self.client.resp.ctf_state := 0;
    end;

    CTFFragBonuses(self, inflictor, attacker);
//ZOID
{$ENDIF}

    TossClientWeapon (self);

{$IFDEF CTF}
//ZOID
    CTFPlayerResetGrapple(self);
    CTFDeadDropFlag(self);
    CTFDeadDropTech(self);
//ZOID
    if (deathmatch->value && !self->client->showscores) then
      Cmd_Help_f (self);              // show scores
{$ELSE}
    if (deathmatch,value) then
      Cmd_Help_f (self);		// show scores

    // clear inventory
    // this is kind of ugly, but it's how we want to handle keys in coop
    for n:=0 to game.num_items-1 do
    begin
      if (coop->value && itemlist[n].flags & IT_KEY) then
        self.client.resp.coop_respawn.inventory[n] := self.client.pers.inventory[n];
      self.client.pers.inventory[n] := 0;
    end;//for
{$ENDIF}
  end;//if

  // remove powerups
  self.client.quad_framenum := 0;
  self.client.invincible_framenum := 0;
  self.client.breather_framenum := 0;
  self.client.enviro_framenum := 0;

{$IFDEF CTF}
  // clear inventory
  memset(self->client->pers.inventory, 0, sizeof(self->client->pers.inventory));
{$ELSE}
  self.flags := self.flags AND (NOT FL_POWER_ARMOR);
{$ENDIF}

  if (self.health < -40)
  then begin
    // gib
    gi.sound (self, CHAN_BODY, gi.soundindex ('misc/udeath.wav'), 1, ATTN_NORM, 0);
    for n:=0 to 3 do
      ThrowGib (self, 'models/objects/gibs/sm_meat/tris.md2', damage, GIB_ORGANIC);
    ThrowClientHead (self, damage);

{$IFDEF CTF}  //onlyCTF
//ZOID
    self.client.anim_priority := ANIM_DEATH;
    self.client.anim_end := 0;
//ZOID
{$ENDIF}

    self.takedamage := DAMAGE_NO;
  end
  else begin
    // normal death
    if (!self.deadflag) then
    begin
//Y      i = (i+1)%3;
      i := (i+1) MOD 3;
      // start a death animation
      self.client.anim_priority := ANIM_DEATH;
      if (self->client->ps.pmove.pm_flags & PMF_DUCKED)
      then begin
        self.s.frame := FRAME_crdeath1-1;
        self.client.anim_end := FRAME_crdeath5;
      end
      else begin
        Case i of
          0: begin
               self.s.frame := FRAME_death101-1;
               self.client.anim_end := FRAME_death106;
             end;
          1: begin
               self.s.frame := FRAME_death201-1;
               self.client.anim_end := FRAME_death206;
             end;
          2: begin
               self.s.frame := FRAME_death301-1;
               self.client.anim_end := FRAME_death308;
             end;
        end;//case
      end;
      gi.sound (self, CHAN_VOICE, gi.soundindex(va('*death%i.wav', (rand()%4)+1)), 1, ATTN_NORM, 0);
    end;
  end;//else

  self.deadflag := DEAD_DEAD;

  gi.linkentity (self);
end;//procedure (GAME <> CTF)


//=======================================================================

{*
==============
InitClientPersistant

This is only called when the game first initializes in single player,
but is called after each death and level change in deathmatch
==============
*}
// (GAME <> CTF)
procedure InitClientPersistant (gclient_t *client);
var
	gitem_t		*item;
begin
  memset (&client->pers, 0, sizeof(client->pers));

  item := FindItem('Blaster');
  client.pers.selected_item := ITEM_INDEX(item);
  client.pers.inventory[client.pers.selected_item] := 1;

  client.pers.weapon := item;

{$IFDEF CTF}  //onlyCTF
//ZOID
  client.pers.lastweapon := item;

  item := FindItem('Grapple');
  client.pers.inventory[ITEM_INDEX(item)] := 1;
//ZOID
{$ENDIF}

  client.pers.health	   := 100;
  client.pers.max_health   := 100;

  client.pers.max_bullets  := 200;
  client.pers.max_shells   := 100;
  client.pers.max_rockets  := 50;
  client.pers.max_grenades := 50;
  client.pers.max_cells    := 200;
  client.pers.max_slugs    := 50;

  client.pers.connected := true;
end;//procedure (GAME <> CTF)

// (GAME <> CTF)
procedure InitClientResp (gclient_t *client);
begin
{$IFDEF CTF}  //onlyCTF
//ZOID
  int ctf_team = client->resp.ctf_team;
  qboolean id_state = client->resp.id_state;
//ZOID
{$ENDIF}

  memset (&client->resp, 0, sizeof(client->resp));

{$IFDEF CTF}  //onlyCTF
//ZOID
  client.resp.ctf_team := ctf_team;
  client.resp.id_state := id_state;
//ZOID
{$ENDIF}

  client.resp.enterframe := level.framenum;
  client.resp.coop_respawn := client.pers;

{$IFDEF CTF}  //onlyCTF
//ZOID
  if (ctf->value && client->resp.ctf_team < CTF_TEAM1) then
    CTFAssignTeam(client);
//ZOID
{$ENDIF}
end;//procedure (GAME <> CTF)


{*
==================
SaveClientData

Some information that should be persistant, like health,
is still stored in the edict structure, so it needs to
be mirrored out to the client structure before all the
edicts are wiped.
==================
*}
// (GAME <> CTF)
procedure SaveClientData;
var
  i : integer;
	edict_t	*ent;
begin
  for i:=0 to game.maxclients-1 do
  begin
    ent = &g_edicts[1+i];
    if (!ent.inuse) then
      Continue;
    game.clients[i].pers.health := ent.health;
    game.clients[i].pers.max_health := ent.max_health;

{$IFDEF CTF}
    game.clients[i].pers.powerArmorActive := (ent.flags AND FL_POWER_ARMOR);
{$ELSE}
    game.clients[i].pers.savedFlags := (ent.flags AND (FL_GODMODE OR FL_NOTARGET OR FL_POWER_ARMOR));
{$ENDIF}

    if (coop.value) then
      game.clients[i].pers.score := ent.client.resp.score;
  end;//for
end;//procedure (GAME <> CTF)

// (GAME <> CTF)
procedure FetchClientEntData (edict_t *ent);
begin
  ent.health := ent.client.pers.health;
  ent.max_health := ent.client.pers.max_health;

{$IFDEF CTF}
  if (ent.client.pers.powerArmorActive) then
    ent.flags := ent.flags OR FL_POWER_ARMOR;
{$ELSE}
  ent.flags := ent.flags OR ent.client.pers.savedFlags;
{$ENDIF}

  if (coop.value) then
    ent.client.resp.score := ent.client.pers.score;
end;//procedure (GAME <> CTF)


{*
=======================================================================

  SelectSpawnPoint

=======================================================================
*}

{*
================
PlayersRangeFromSpot

Returns the distance to the nearest player from the given spot
================
*}
// (GAME=CTF)
function PlayersRangeFromSpot (edict_t *spot) : float;
var
	edict_t	*player;
  bestplayerdistance,
  playerdistance     : float;
  v : vec3_t;
  n : integer;
begin
  bestplayerdistance = 9999999;

  for n:=1 to maxclients.value do
  begin
    player = &g_edicts[n];

    if (!player.inuse) then
      Continue;

    if (player.health <= 0) then
      Continue;

    VectorSubtract (spot.s.origin, player.s.origin, v);