g_local.pas

delphi编的不错的贪吃蛇

    max_grenades,
    max_cells,
    max_slugs: integer;

    weapon,
    lastweapon: gitem_p;

    power_cubes,     // used for tracking the cubes in coop games
    score: integer;  // for calculating total unit score in coop games

{$ifndef CTF}
    game_helpchanged,
    helpchanged: integer;

    spectator: qboolean; // client is a spectator
{$endif}
  end;
  TClientPersistant = client_persistant_t;
  PClientPersistant = client_persistant_p;
  client_persistant_at = array[0..MaxInt div sizeof(client_persistant_t)-1] of client_persistant_t;
  client_persistant_a = ^client_persistant_at;

{$ifdef CTF}
  // TAKEN FROM g_ctf.h
  ghost_p = ^ghost_t;
  pghost_s = ghost_p;
  ghost_s = record
    netname: Array[0..15] of char;
    number: Integer;

    // stats
    deaths,
    kills,
    caps,
    basedef,
    carrierdef: Integer;

    code: Integer; // ghost code
    team: Integer; // team
    score: Integer; // frags at time of disconnect
    ent: edict_p;
  end;
  ghost_t = ghost_s;
  pghost_t = ghost_p;
  ghost_at = array[0..0] of ghost_t;
  ghost_a = ^ghost_at;
  TGhost = ghost_t;
  PGhost = ghost_p;
  TGhostArray = ghost_at;
  PGhostArray = ghost_a;
{$endif}

// client data that stays across deathmatch respawns
  client_respawn_p = ^client_respawn_t;
  pclient_respawn_t = client_respawn_p;
  client_respawn_t = record
    coop_respawn: client_persistant_t; // what to set client->pers to on a respawn
    enterframe,	     // level.framenum the client entered the game
    score: integer;  // frags, etc
{$ifdef CTF}
//ZOID
    ctf_team, // CTF team
    ctf_state: Integer;
    ctf_lasthurtcarrier,
    ctf_lastreturnedflag,
    ctf_flagsince,
    ctf_lastfraggedcarrier: Single;
    id_state: qboolean;
    lastidtime: Single;
    voted, // for elections
    ready,
    admin: qboolean;
    ghost: ghost_p; // for ghost codes
//ZOID
{$endif}
    cmd_angles: vec3_t;  // angles sent over in the last command

{$ifndef CTF}
    spectator: qboolean; // client is a spectator
{$else}
    game_helpchanged: Integer;
    helpchanged: Integer;
{$endif}
  end;
  TClientRespawn = client_respawn_t;
  PClientRespawn = client_respawn_p;
  client_respawn_at = array[0..MaxInt div sizeof(client_respawn_t)-1] of client_respawn_t;
  client_respawn_a = ^client_respawn_at;
  TClientRespawnArray = client_respawn_at;
  PClientRespawnArray = client_respawn_a;


// CAK - TAKEN FROM q_shared.h
// pmove_state_t is the information necessary for client side movement
// prediction
  pmtype_p = ^pmtype_t;
  ppmtype_t = pmtype_p;
  pmtype_t = (
    // can accelerate and turn
    PM_NORMAL,
    PM_SPECTATOR,
    // no acceleration or turning
    PM_DEAD,
    PM_GIB, // different bounding box
    PM_FREEZE
  );
  TPMType = pmtype_t;
  PPMType = pmtype_p;
  pmtype_at = array[0..MaxInt div sizeof(pmtype_t)-1] of pmtype_t;
  pmtype_a = ^pmtype_at;
  TPMTypeArray = pmtype_at;
  PPMTypeArray = pmtype_a;


  // CAK - TAKEN FROM q_shared.h
  pmove_state_p = ^pmove_state_t;
  ppmove_state_t = pmove_state_p;
  pmove_state_t = record
    pm_type: pmtype_t;

    origin: array[0..2] of smallint; // 12.3
    velocity: array[0..2] of smallint; // 12.3
    pm_flags: byte; // ducked, jump_held, etc
    pm_time: byte; // each unit = 8 ms
    gravity: smallint;
    delta_angles: array[0..2] of smallint; // add to command angles to get view direction
                                           // changed by spawns, rotating objects, and teleporters
  end;
  TPMoveState = pmove_state_t;
  PPMoveState = pmove_state_p;
  pmove_state_at = array[0..MaxInt div sizeof(pmove_state_t)-1] of pmove_state_t;
  pmove_state_a = ^pmove_state_at;
  TPMoveStateArray = pmove_state_at;
  PPMoveStateArray = pmove_state_a;

  // CAK - TAKEN FROM q_shared.h
  player_state_p = ^player_state_t;
  pplayer_state_t = player_state_p;
  player_state_t = record
    pmove: pmove_state_t; // for prediction

    // these fields do not need to be communicated bit-precise

    viewangles: vec3_t; // for fixed views
    viewoffset: vec3_t; // add to pmovestate->origin
    kick_angles: vec3_t; // add to view direction to get render angles
			  // set by weapon kicks, pain effects, etc
    gunangles: vec3_t;
    gunoffset: vec3_t;
    gunindex: Integer;
    gunframe: Integer;

    blend: Array[0..3] of single; // rgba full screen effect

    fov: single; // horizontal field of view

    rdflags: Integer; // refdef flags

    stats: Array[0..MAX_STATS-1] of smallint; // fast status bar updates
  end;
  TPlayerState = player_state_t;
  PPlayerState = player_state_p;
  player_state_at = array[0..MaxInt div sizeof(player_state_t)-1] of player_state_t;
  player_state_a = ^player_state_at;
  TPlayerStateArray = player_state_at;
  PPlayerStateArray = player_state_a;

{$ifdef CTF}
//TAKEN FROM ctf\p_menu.h
  pmenu_p = ^pmenu_t;

  pmenuhnd_p = ^pmenuhnd_t;
  pmenuhnd_s = record
    entries: pmenu_p;
	 //TODO: This is giving me problems: struct pmenu_s *entries;
	 //I think that it should be an array of pmenu_s
    cur: Integer;
    num: Integer;
    arg: Pointer;
  end;
  pmenuhnd_t = pmenuhnd_s;
  pmenuhnd_at = Array[0..0] of pmenuhnd_t;
  pmenuhnd_a = ^pmenuhnd_at;
  TPMenuHnd = pmenuhnd_t;
  PPMenuHnd = pmenuhnd_p;
  TPMenuHndArray = pmenuhnd_at;
  PPMenuHndArray = pmenuhnd_a;

  SelectFunc_t = procedure(ent: edict_p; hnd: pmenuhnd_p); cdecl;

  ppmenu_s = pmenu_p;
  pmenu_s = record
    text: PChar;
    align: Integer;
    SelectFunc: SelectFunc_t;
  end;
  pmenu_t = pmenu_s;
  pmenu_at = Array[0..0] of pmenu_t;
  pmenu_a = ^pmenu_at;
  TPMenu = pmenu_t;
  PPMenu = pmenu_p;
  TPMenuArray = pmenu_at;
  PPMenuArray = pmenu_a;
{$endif}

// this structure is cleared on each PutClientInServer(),
// except for 'client->pers'
  pgclient_s = gclient_p;
  gclient_s = record
    // known to server
    ps: player_state_t;	// communicated by server to clients
    ping: integer;

    // private to game
    pers: client_persistant_t;
    resp: client_respawn_t;
    old_pmove: pmove_state_t; // for detecting out-of-pmove changes

    showscores,	   // set layout stat
{$ifdef CTF}
//ZOID
    inmenu: qboolean; // in menu
    menu: pmenuhnd_p; // current menu
//ZOID
{$endif}
    showinventory, // set layout stat
    showhelp,
    showhelpicon: qboolean;

    ammo_index: integer;

    buttons,
    oldbuttons,
    latched_buttons: integer;

    weapon_thunk: qboolean;

    newweapon: gitem_p;

    // sum up damage over an entire frame, so
    // shotgun blasts give a single big kick
    damage_armor,		// damage absorbed by armor
    damage_parmor,		// damage absorbed by power armor
    damage_blood,		// damage taken out of health
    damage_knockback: integer;	// impact damage
    damage_from: vec3_t;       	// origin for vector calculation

    killer_yaw: Single;	// when dead, look at killer

    weaponstate: weaponstate_t;
    kick_angles: vec3_t;  // weapon kicks
    kick_origin: vec3_t;
    v_dmg_roll, v_dmg_pitch, v_dmg_time, // damage kicks
    fall_time, fall_value,  // for view drop on fall
    damage_alpha,
    bonus_alpha: single;
    damage_blend,
    v_angle: vec3_t; // aiming direction
    bobtime: Single;   // so off-ground doesn't change it
    oldviewangles: vec3_t;
    oldvelocity: vec3_t;

    next_drown_time: Single;
    old_waterlevel,
    breather_sound: integer;

    machinegun_shots: integer;	// for weapon raising

    // animation vars
    anim_end,
    anim_priority: integer;
    anim_duck,
    anim_run: qboolean;

    // powerup timers
    quad_framenum,
    invincible_framenum,
    breather_framenum,
    enviro_framenum: single;

    grenade_blew_up: qboolean;
    grenade_time: single;
    silencer_shots,
    weapon_sound: integer;

    pickup_msg_time: Single;

    flood_locktill: single;  // locked from talking
    flood_when: array[0..9] of single;	// when messages were said
    flood_whenhead: integer;  // head pointer for when said

    respawn_time: single;  // can respawn when time > this


{$ifdef CTF}
//ZOID
    ctf_grapple: pointer; // entity of grapple
    ctf_grapplestate: integer; // true if pulling
    ctf_grapplereleasetime: Single; // time of grapple release
    ctf_regentime: Single;          // regen tech
    ctf_techsndtime: Single;
    ctf_lasttechmsg: Single;
{$endif}
    chase_target: edict_p;  // player we are chasing
    update_chase: qboolean; // need to update chase info?
{$ifdef CTF}
    menutime: single; // time to update menu
    menudirty: qboolean;
//ZOID
{$endif}
  end;
  gclient_t = gclient_s;
  _gclient_s = gclient_s;
  pgclient_t = gclient_p;
  p_gclient_s = gclient_p;
  TGClient = gclient_t;
  PGClient = gclient_p;
  gclient_at = array[0..MaxInt div sizeof(gclient_t)-1] of gclient_t;
  gclient_a = ^gclient_at;
  TGClientArray = gclient_at;
  PGClientArray = gclient_a;

// CAK - TAKEN FROM q_shared.h
// entity_state_t->event values
// ertity events are for effects that take place reletive
// to an existing entities origin.  Very network efficient.
// All muzzle flashes really should be converted to events...
//  entity_event_p = g_local.entity_event_p;
//  entity_event_t = g_local.entity_event_t;
  entity_event_p = ^entity_event_t;
  entity_event_t = (
    EV_NONE,
    EV_ITEM_RESPAWN,
    EV_FOOTSTEP,
    EV_FALLSHORT,
    EV_FALL,
    EV_FALLFAR,
    EV_PLAYER_TELEPORT,
    EV_OTHER_TELEPORT
  );

// CAK - TAKEN FROM q_shared.h
// entity_state_t is the information conveyed from the server
// in an update message about entities that the client will
// need to render in some way
  entity_state_p = ^entity_state_t;
  pentity_state_s = entity_state_p;
  entity_state_s = record
    number: integer; // edict index

    origin: vec3_t;
    angles: vec3_t;
    old_origin: vec3_t; // for lerping
    modelindex: Integer;
    modelindex2,modelindex3,modelindex4: Integer; // weapons, CTF flags, etc
    frame: Integer;
    skinnum: Integer;
    effects: Cardinal; // PGM - we're filling it, so it needs to be unsigned
    renderfx: Integer;
    solid: Integer; // for client side prediction, 8*(bits 0-4) is x/y radius
                    // 8*(bits 5-9) is z down distance, 8(bits10-15) is z up
                    // gi.linkentity sets this properly
    sound: Integer;  // for looping sounds, to guarantee shutoff
    event: entity_event_t; // CAK - was int
                    // impulse events -- muzzle flashes, footsteps, etc
                    // events only go out for a single frame, they
                    // are automatically cleared each frame
  end;
  entity_state_t = entity_state_s;
  pentity_state_t = entity_state_p;
  TEntityState = entity_state_t;
  PEntityState = entity_state_p;
  entity_state_at = array[0..MaxInt div sizeof(entity_state_t)-1] of entity_state_t;
  entity_state_a = ^entity_state_at;
  TEntityStateArray = entity_state_at;
  PEntityStateArray = entity_state_a;

// CAK - TAKEN FROM game.h
// link_t is only used for entity area links now
  link_p = ^link_t;
  plink_s = link_p;
  link_s = record
    prev, next : link_p;
  end;
  link_t = link_s;
  plink_t = link_p;
  TLink = link_t;
  PLink = link_p;
  link_at = array[0..MaxInt div sizeof(link_t)-1] of link_t;
  link_a = ^link_at;
  TLinkArray = link_at;
  PLinkArray = link_a;

// CAK - TAKEN FROM game.h
// edict->solid values
  solid_p = ^solid_t;
  psolid_t = solid_p;
  solid_t = (
    SOLID_NOT,			// no interaction with other objects
    SOLID_TRIGGER,		// only touch when inside, after moving
    SOLID_BBOX,			// touch on edge
    SOLID_BSP			// bsp clip, touch on edge
  );
  TSolid = solid_t;
  PSolid = solid_p;
  solid_at = array[0..MaxInt div sizeof(solid_t)-1] of solid_t;
  solid_a = ^solid_at;
  TSolidArray = solid_at;
  PSolidArray = solid_a;

// CAK - TAKEN FROM q_shared.h
// plane_t structure
// !!!  if this is changed, it must be changed in asm code too !!!
  cplane_p = ^cplane_t;
  pcplane_s = cplane_p;
  cplane_s = record
    normal: vec3_t;
    dist: single;
    _type: byte; // for fast side tests
    signbits: byte; // signx + (signyshl1) + (signzshl1)
    pad: array[0..1] of byte;
  end;
  cplane_t = cplane_s;
  pcplane_t = cplane_p;
  TCPlane = cplane_t;
  PCPlane = cplane_p;
  cplane_at = array[0..MaxInt div sizeof(cplane_t)-1] of cplane_t;
  cplane_a = ^cplane_at;
  TCPlaneArray = cplane_at;
  PCPlaneArray = cplane_a;

// CAK - TAKEN FROM q_shared.h
  csurface_p = ^csurface_t;
  pcsurface_s = csurface_p;
  csurface_s = record
    name: array[0..15] of char;
    flags: Integer;
    value: Integer;
  end;
  csurface_t = csurface_s;
  pcsurface_t = csurface_p;
  TCSurface = csurface_t;
  PCSurface = csurface_p;
  csurface_at = array[0..MaxInt div sizeof(csurface_t)-1] of csurface_t;
  csurface_a = ^csurface_at;
  TCSurfaceArray = csurface_at;
  PCSurfaceArray = csurface_a;


  Proc_2edictt_cplanet_csurfacet = Procedure(self, other: edict_p;
                                                  plane: cplane_p; surf: csurface_p); cdecl;
  Proc_3edictt = Procedure (self, other, activator: edict_p); cdecl;
  Proc_2edictt_single_int = Procedure(self, other: edict_p;
                                          kick: single; damage: integer); cdecl;
  Proc_3edictt_int_vec3t = Procedure(self, inflictor, attacker: edict_p;
                                          damage: integer; point: vec3_t); cdecl;

  pedict_s = edict_p;
  edict_s = record
    s: entity_state_t;
    client: gclient_p;	// NULL if not a player
                        // the server expects the first part
                        // of gclient_s to be a player_state_t
                        // but the rest of it is opaque

    inuse: qboolean;
    linkcount: integer;

    // FIXME: move these fields to a server private sv_entity_t
    area: link_t; // linked to a division node or leaf

    num_clusters: integer;		// if -1, use headnode instead
    clusternums: array[0..MAX_ENT_CLUSTERS - 1] of integer;
    headnode: integer;			// unused if num_clusters != -1
    areanum, areanum2: integer;

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

    svflags :integer;
    mins, maxs: vec3_t;
    absmin, absmax, size: vec3_t;
    solid: solid_t;
    clipmask: integer;
    owner: edict_p;


    // DO NOT MODIFY ANYTHING ABOVE THIS, THE SERVER
    // EXPECTS THE FIELDS IN THAT ORDER!

    //================================
    movetype: movetype_t; // CAK - was Integer
    flags: integer;

    model: PChar;
    freetime: single; // sv.time when the object was freed

    //
    // only used locally in game, not by server
    //
    _message,
    classname: Pchar;
    spawnflags: integer;

    timestamp: Single;

    angle: Single; // set in qe3, -1 = up, -2 = down
    target,
    targetname,
    killtarget,
    team,
    pathtarget,
    deathtarget,
    combattarget: PChar;
    target_ent: edict_p;

    speed, accel, decel: Single;
    movedir: vec3_t;
    pos1, pos2: vec3_t;

    velocity: vec3_t;
    avelocity: vec3_t;
    mass: integer;
    air_finished,
    gravity: Single; // per entity gravity multiplier (1.0 is normal)
                     // use for lowgrav artifact, flares

    goalentity: edict_p;
    movetarget: edict_p;
    yaw_speed,
    ideal_yaw: Single;

    nextthink: single;
    prethink: Proc_Pedictt;
    think: Proc_Pedictt;
    blocked: Proc_2Pedictt;	//move to moveinfo?
    touch: Proc_2edictt_cplanet_csurfacet;
    use: Proc_3edictt;
    pain: Proc_2edictt_single_int;
    die: Proc_3edictt_int_vec3t;

    touch_debounce_time, // are all these legit?  do we need more/less of them?
    pain_debounce_time,
    damage_debounce_time,
    fly_sound_debounce_time, //move to clientinfo