qf
/
quakeforge
mirror of https://git.code.sf.net/p/quake/quakeforge
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

total nukage of #ifdef QUAKE2 (R_DarkFieldParticles is present, just unused)

This commit is contained in:
Bill Currie 2001-08-27 23:21:09 +00:00
parent 330044ec72
commit a9d6bc9a30
15 changed files with 4 additions and 1138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/r_dynamic.h
View File

@ -49,9 +49,7 @@ void R_RunParticleEffect (vec3_t org, int color, int count);
void R_RunPuffEffect (vec3_t org, particle_effect_t type, byte count);
void R_RunSpikeEffect (vec3_t org, particle_effect_t type);
#ifdef QUAKE2
void R_DarkFieldParticles (struct entity_s *ent);
#endif
void R_EntityParticles (struct entity_s *ent);
void R_BlobExplosion (vec3_t org);
void R_ParticleExplosion (vec3_t org);

2
libs/video/renderer/r_part.c
View File

@ -43,7 +43,6 @@ vec3_t r_pright, r_pup, r_ppn;
int r_numparticles;
#ifdef QUAKE2
void
R_DarkFieldParticles (entity_t *ent)
{
@ -82,7 +81,6 @@ R_DarkFieldParticles (entity_t *ent)
VectorScale (dir, vel, p->vel);
}
}
#endif
#define NUMVERTEXNORMALS 162
extern float r_avertexnormals[NUMVERTEXNORMALS][3];

9
nq/include/client.h
View File

@ -52,9 +52,6 @@ typedef struct usercmd_s
float forwardmove;
float sidemove;
float upmove;
#ifdef QUAKE2
byte lightlevel;
#endif
} usercmd_t;
typedef struct
@ -222,12 +219,6 @@ typedef struct
// frag scoreboard
scoreboard_t *scores; // [cl.maxclients]
#ifdef QUAKE2
// light level at player's position including dlights this is sent back to the
// server each frame architectually ugly but it works
int light_level;
#endif
} client_state_t;

4
nq/include/protocol.h
View File

@ -169,10 +169,6 @@
#define TE_TELEPORT 11
#define TE_BLOOD 12
#define TE_LIGHTNINGBLOOD 13
#ifdef QUAKE2
#define TE_IMPLOSION 14
#define TE_RAILTRAIL 15
#endif
#define TE_EXPLOSION2 16
// PGM 01/21/97
#define TE_BEAM 17

31
nq/include/server.h
View File

@ -70,9 +70,6 @@ typedef struct
double lastchecktime;
char name[64]; // map name
#ifdef QUAKE2
char startspot[64];
#endif
char modelname[64]; // maps/<name>.bsp, for model_precache[0]
struct model_s *worldmodel;
const char *model_precache[MAX_MODELS]; // NULL terminated
@ -148,10 +145,6 @@ typedef struct client_s
#define MOVETYPE_NOCLIP 8
#define MOVETYPE_FLYMISSILE 9 // extra size to monsters
#define MOVETYPE_BOUNCE 10
#ifdef QUAKE2
#define MOVETYPE_BOUNCEMISSILE 11 // bounce w/o gravity
#define MOVETYPE_FOLLOW 12 // track movement of aiment
#endif
// edict->solid values
#define SOLID_NOT 0 // no interaction with other objects
@ -184,10 +177,6 @@ typedef struct client_s
#define FL_PARTIALGROUND 1024 // not all corners are valid
#define FL_WATERJUMP 2048 // player jumping out of water
#define FL_JUMPRELEASED 4096 // for jump debouncing
#ifdef QUAKE2
#define FL_FLASHLIGHT 8192
#define FL_ARCHIVE_OVERRIDE 1048576
#endif
// entity effects
@ -195,28 +184,12 @@ typedef struct client_s
#define EF_MUZZLEFLASH 2
#define EF_BRIGHTLIGHT 4
#define EF_DIMLIGHT 8
#ifdef QUAKE2
#define EF_DARKLIGHT 16
#define EF_DARKFIELD 32
#define EF_LIGHT 64
#define EF_NODRAW 128
#endif
#define SPAWNFLAG_NOT_EASY 256
#define SPAWNFLAG_NOT_MEDIUM 512
#define SPAWNFLAG_NOT_HARD 1024
#define SPAWNFLAG_NOT_DEATHMATCH 2048
#ifdef QUAKE2
// server flags
#define SFL_EPISODE_1 1
#define SFL_EPISODE_2 2
#define SFL_EPISODE_3 4
#define SFL_EPISODE_4 8
#define SFL_NEW_UNIT 16
#define SFL_NEW_EPISODE 32
#define SFL_CROSS_TRIGGERS 65280
#endif
//============================================================================
@ -290,11 +263,7 @@ void SV_MoveToGoal (progs_t *pr);
void SV_CheckForNewClients (void);
void SV_RunClients (void);
void SV_SaveSpawnparms ();
#ifdef QUAKE2
void SV_SpawnServer (const char *server, const char *startspot);
#else
void SV_SpawnServer (const char *server);
#endif
void SV_LoadProgs (void);
void SV_Progs_Init (void);

6
nq/source/cl_input.c
View File

@ -604,12 +604,6 @@ CL_SendMove (usercmd_t *cmd)
MSG_WriteByte (&buf, in_impulse);
in_impulse = 0;
#ifdef QUAKE2
// light level
//
MSG_WriteByte (&buf, cmd->lightlevel);
#endif
// deliver the message
//
if (cls.demoplayback)

23
nq/source/cl_main.c
View File

@ -591,10 +591,6 @@ CL_RelinkEntities (void)
if (ent->effects & EF_BRIGHTFIELD)
R_EntityParticles (ent);
#ifdef QUAKE2
if (ent->effects & EF_DARKFIELD)
R_DarkFieldParticles (ent);
#endif
if (ent->effects & EF_MUZZLEFLASH) {
vec3_t fv, rv, uv;
@ -626,21 +622,6 @@ CL_RelinkEntities (void)
if (ent->effects & EF_DIMLIGHT)
CL_NewDlight (i, ent->origin[0], ent->origin[1], ent->origin[2],
200 + (rand () & 31), 0.001, 0);
#ifdef QUAKE2
if (ent->effects & EF_DARKLIGHT) {
dl = R_AllocDlight (i);
VectorCopy (ent->origin, dl->origin);
dl->radius = 200.0 + (rand () & 31);
dl->die = cl.time + 0.001;
dl->dark = true;
}
if (ent->effects & EF_LIGHT) {
dl = R_AllocDlight (i);
VectorCopy (ent->origin, dl->origin);
dl->radius = 200;
dl->die = cl.time + 0.001;
}
#endif
if (VectorDistance_fast(ent->msg_origins[1], ent->origin) > (256*256))
VectorCopy (ent ->origin, ent->msg_origins[1]);
if (ent->model->flags & EF_ROCKET) {
@ -668,10 +649,6 @@ CL_RelinkEntities (void)
if (i == cl.viewentity && !chase_active->int_val) {
continue;
}
#ifdef QUAKE2
if (ent->effects & EF_NODRAW)
continue;
#endif
if ((_ent = R_NewEntity ()))
*_ent = ent;
}

43
nq/source/cl_tent.c
View File

@ -79,10 +79,6 @@ sfx_t *cl_sfx_ric1;
sfx_t *cl_sfx_ric2;
sfx_t *cl_sfx_ric3;
sfx_t *cl_sfx_r_exp3;
#ifdef QUAKE2
sfx_t *cl_sfx_imp;
sfx_t *cl_sfx_rail;
#endif
model_t *cl_mod_bolt;
model_t *cl_mod_bolt2;
@ -120,10 +116,6 @@ CL_TEnts_Init (void)
cl_sfx_ric2 = S_PrecacheSound ("weapons/ric2.wav");
cl_sfx_ric3 = S_PrecacheSound ("weapons/ric3.wav");
cl_sfx_r_exp3 = S_PrecacheSound ("weapons/r_exp3.wav");
#ifdef QUAKE2
cl_sfx_imp = S_PrecacheSound ("shambler/sattck1.wav");
cl_sfx_rail = S_PrecacheSound ("weapons/lstart.wav");
#endif
cl_mod_bolt = Mod_ForName ("progs/bolt.mdl", true);
cl_mod_bolt2 = Mod_ForName ("progs/bolt2.mdl", true);
@ -237,9 +229,6 @@ CL_ParseTEnt (void)
{
byte type;
vec3_t pos;
#ifdef QUAKE2
vec3_t endpos;
#endif
dlight_t *dl;
int rnd;
int colorStart, colorLength;
@ -410,38 +399,6 @@ CL_ParseTEnt (void)
R_RunPuffEffect (pos, prot_to_rend[type], cnt);
break;
#ifdef QUAKE2
case TE_IMPLOSION:
pos[0] = MSG_ReadCoord (net_message);
pos[1] = MSG_ReadCoord (net_message);
pos[2] = MSG_ReadCoord (net_message);
S_StartSound (-1, 0, cl_sfx_imp, pos, 1, 1);
break;
case TE_RAILTRAIL:
pos[0] = MSG_ReadCoord (net_message);
pos[1] = MSG_ReadCoord (net_message);
pos[2] = MSG_ReadCoord (net_message);
endpos[0] = MSG_ReadCoord (net_message);
endpos[1] = MSG_ReadCoord (net_message);
endpos[2] = MSG_ReadCoord (net_message);
S_StartSound (-1, 0, cl_sfx_rail, pos, 1, 1);
S_StartSound (-1, 1, cl_sfx_r_exp3, endpos, 1, 1);
/* Need updating to new Particle API
R_RocketTrail (pos, endpos, 0 + 128);
R_ParticleExplosion (endpos);
*/
dl = R_AllocDlight (-1);
VectorCopy (endpos, dl->origin);
dl->radius = 350;
dl->die = cl.time + 0.5;
dl->decay = 300;
dl->color[0] = 0.86;
dl->color[1] = 0.31;
dl->color[2] = 0.24;
break;
#endif
default:
Sys_Error ("CL_ParseTEnt: bad type");
}

244
nq/source/host_cmd.c
View File

@ -297,11 +297,7 @@ Host_Map_f (void)
svs.serverflags = 0; // haven't completed an episode yet
strcpy (name, Cmd_Argv (1));
#ifdef QUAKE2
SV_SpawnServer (name, NULL);
#else
SV_SpawnServer (name);
#endif
if (!sv.active)
return;
@ -327,31 +323,6 @@ Goes to a new map, taking all clients along
void
Host_Changelevel_f (void)
{
#ifdef QUAKE2
char level[MAX_QPATH];
char _startspot[MAX_QPATH];
char *startspot;
if (Cmd_Argc () < 2) {
Con_Printf ("changelevel <levelname> : continue game on a new level\n");
return;
}
if (!sv.active || cls.demoplayback) {
Con_Printf ("Only the server may changelevel\n");
return;
}
strcpy (level, Cmd_Argv (1));
if (Cmd_Argc () == 2)
startspot = NULL;
else {
strcpy (_startspot, Cmd_Argv (2));
startspot = _startspot;
}
SV_SaveSpawnparms ();
SV_SpawnServer (level, startspot);
#else
char level[MAX_QPATH];
if (Cmd_Argc () != 2) {
@ -365,7 +336,6 @@ Host_Changelevel_f (void)
SV_SaveSpawnparms ();
strcpy (level, Cmd_Argv (1));
SV_SpawnServer (level);
#endif
}
/*
@ -380,10 +350,6 @@ Host_Restart_f (void)
{
char mapname[MAX_QPATH];
#ifdef QUAKE2
char startspot[MAX_QPATH];
#endif
if (cls.demoplayback || !sv.active)
return;
@ -392,12 +358,7 @@ Host_Restart_f (void)
strcpy (mapname, sv.name); // must copy out, because it gets
// cleared
// in sv_spawnserver
#ifdef QUAKE2
strcpy (startspot, sv.startspot);
SV_SpawnServer (mapname, startspot);
#else
SV_SpawnServer (mapname);
#endif
}
/*
@ -627,12 +588,6 @@ Host_Loadgame_f (void)
current_skill = (int) (tfloat + 0.1);
Cvar_SetValue (skill, (float) current_skill);
#ifdef QUAKE2
Cvar_SetValue (deathmatch, 0);
Cvar_SetValue (coop, 0);
Cvar_SetValue (teamplay, 0);
#endif
Qgets (f, buf, sizeof (buf));
sscanf (buf, "%s\n", mapname);
Qgets (f, buf, sizeof (buf));
@ -640,11 +595,7 @@ Host_Loadgame_f (void)
CL_Disconnect_f ();
#ifdef QUAKE2
SV_SpawnServer (mapname, NULL);
#else
SV_SpawnServer (mapname);
#endif
if (!sv.active) {
Con_Printf ("Couldn't load map\n");
return;
@ -715,198 +666,6 @@ Host_Loadgame_f (void)
}
}
#ifdef QUAKE2
void
SaveGamestate ()
{
char name[256];
VFile *f;
int i;
char comment[SAVEGAME_COMMENT_LENGTH + 1];
edict_t *ent;
snprintf (name, sizeof (name), "%s/%s.gip", com_gamedir, sv.name);
Con_Printf ("Saving game to %s...\n", name);
f = Qopen (name, "w");
if (!f) {
Con_Printf ("ERROR: couldn't open.\n");
return;
}
Qprintf (f, "%i\n", SAVEGAME_VERSION);
Host_SavegameComment (comment);
Qprintf (f, "%s\n", comment);
// for (i=0 ; i<NUM_SPAWN_PARMS ; i++)
// Qprintf (f, "%f\n", svs.clients->spawn_parms[i]);
Qprintf (f, "%f\n", skill->value);
Qprintf (f, "%s\n", sv.name);
Qprintf (f, "%f\n", sv.time);
// write the light styles
for (i = 0; i < MAX_LIGHTSTYLES; i++) {
if (sv.lightstyles[i])
Qprintf (f, "%s\n", sv.lightstyles[i]);
else
Qprintf (f, "m\n");
}
for (i = svs.maxclients + 1; i < sv.num_edicts; i++) {
ent = EDICT_NUM (i);
if ((int) SVfloat (ent, flags) & FL_ARCHIVE_OVERRIDE)
continue;
Qprintf (f, "%i\n", i);
ED_Write (f, ent);
Qflush (f);
}
Qclose (f);
Con_Printf ("done.\n");
}
int
LoadGamestate (char *level, char *startspot)
{
char name[MAX_OSPATH];
VFile *f;
char mapname[MAX_QPATH];
float time, sk;
char str[32768], *start;
int i, r;
edict_t *ent;
int entnum;
int version;
// float spawn_parms[NUM_SPAWN_PARMS];
snprintf (name, sizeof (name), "%s/%s.gip", com_gamedir, level);
Con_Printf ("Loading game from %s...\n", name);
f = Qopen (name, "r");
if (!f) {
Con_Printf ("ERROR: couldn't open.\n");
return -1;
}
Qgets (f, buf, sizeof (buf));
sscanf (buf, "%i\n", &version);
if (version != SAVEGAME_VERSION) {
Qclose (f);
Con_Printf ("Savegame is version %i, not %i\n", version,
SAVEGAME_VERSION);
return -1;
}
Qgets (f, buf, sizeof (buf));
sscanf (buf, "%s\n", str);
// for (i=0 ; i<NUM_SPAWN_PARMS ; i++)
// fscanf (f, "%f\n", &spawn_parms[i]);
Qgets (f, buf, sizeof (buf));
sscanf (buf, "%f\n", &sk);
Cvar_SetValue (skill, sk);
Qgets (f, buf, sizeof (buf));
sscanf (buf, "%s\n", mapname);
Qgets (f, buf, sizeof (buf));
sscanf (buf, "%f\n", &time);
SV_SpawnServer (mapname, startspot);
if (!sv.active) {
Con_Printf ("Couldn't load map\n");
return -1;
}
// load the light styles
for (i = 0; i < MAX_LIGHTSTYLES; i++) {
Qgets (f, buf, sizeof (buf));
sscanf (buf, "%s\n", str);
sv.lightstyles[i] = Hunk_Alloc (strlen (str) + 1);
strcpy (sv.lightstyles[i], str);
}
// load the edicts out of the savegame file
while (!feof (f)) {
Qgets (f, buf, sizeof (buf));
sscanf (buf, "%i\n", &entnum);
for (i = 0; i < sizeof (str) - 1; i++) {
r = fgetc (f);
if (r == EOF || !r)
break;
str[i] = r;
if (r == '}') {
i++;
break;
}
}
if (i == sizeof (str) - 1)
Sys_Error ("Loadgame buffer overflow");
str[i] = 0;
start = str;
start = COM_Parse (str);
if (!com_token[0])
break; // end of file
if (strcmp (com_token, "{"))
Sys_Error ("First token isn't a brace");
// parse an edict
ent = EDICT_NUM (entnum);
memset (&ent->v, 0, progs->entityfields * 4);
ent->free = false;
ED_ParseEdict (start, ent);
// link it into the bsp tree
if (!ent->free)
SV_LinkEdict (ent, false);
}
// sv.num_edicts = entnum;
sv.time = time;
Qclose (f);
// for (i=0 ; i<NUM_SPAWN_PARMS ; i++)
// svs.clients->spawn_parms[i] = spawn_parms[i];
return 0;
}
// changing levels within a unit
void
Host_Changelevel2_f (void)
{
char level[MAX_QPATH];
char _startspot[MAX_QPATH];
char *startspot;
if (Cmd_Argc () < 2) {
Con_Printf
("changelevel2 <levelname> : continue game on a new level in the unit\n");
return;
}
if (!sv.active || cls.demoplayback) {
Con_Printf ("Only the server may changelevel\n");
return;
}
strcpy (level, Cmd_Argv (1));
if (Cmd_Argc () == 2)
startspot = NULL;
else {
strcpy (_startspot, Cmd_Argv (2));
startspot = _startspot;
}
SV_SaveSpawnparms ();
// save the current level's state
SaveGamestate ();
// try to restore the new level
if (LoadGamestate (level, startspot))
SV_SpawnServer (level, startspot);
}
#endif
//============================================================================
@ -1766,9 +1525,6 @@ Host_InitCommands (void)
Cmd_AddCommand ("map", Host_Map_f, "No Description");
Cmd_AddCommand ("restart", Host_Restart_f, "No Description");
Cmd_AddCommand ("changelevel", Host_Changelevel_f, "No Description");
#ifdef QUAKE2
Cmd_AddCommand ("changelevel2", Host_Changelevel2_f, "No Description");
#endif
Cmd_AddCommand ("connect", Host_Connect_f, "No Description");
Cmd_AddCommand ("reconnect", Host_Reconnect_f, "No Description");
Cmd_AddCommand ("name", Host_Name_f, "No Description");

260
nq/source/pr_cmds.c
View File

@ -481,37 +481,6 @@ PF_traceline (progs_t *pr)
}
#ifdef QUAKE2
extern trace_t SV_Trace_Toss (edict_t *ent, edict_t *ignore);
void
PF_TraceToss (progs_t *pr)
{
trace_t trace;
edict_t *ent;
edict_t *ignore;
ent = G_EDICT (pr, OFS_PARM0);
ignore = G_EDICT (pr, OFS_PARM1);
trace = SV_Trace_Toss (ent, ignore);
*sv_globals.trace_allsolid = trace.allsolid;
*sv_globals.trace_startsolid = trace.startsolid;
*sv_globals.trace_fraction = trace.fraction;
*sv_globals.trace_inwater = trace.inwater;
*sv_globals.trace_inopen = trace.inopen;
VectorCopy (trace.endpos, *sv_globals.trace_endpos);
VectorCopy (trace.plane.normal, *sv_globals.trace_plane_normal);
*sv_globals.trace_plane_dist = trace.plane.dist;
if (trace.ent)
*sv_globals.trace_ent = EDICT_TO_PROG (pr, trace.ent);
else
*sv_globals.trace_ent = EDICT_TO_PROG (pr, sv.edicts);
}
#endif
/*
PF_checkpos
@ -714,16 +683,6 @@ PF_findradius (progs_t *pr)
}
#ifdef QUAKE2
void
PF_etos (progs_t *pr)
{
snprintf (pr_string_temp, sizeof (pr_string_temp), "entity %i",
G_EDICTNUM (pr, OFS_PARM0));
G_INT (pr, OFS_RETURN) = PR_SetString (pr, pr_string_temp);
}
#endif
void
PF_Spawn (progs_t *pr)
{
@ -1052,42 +1011,6 @@ PF_changeyaw (progs_t *pr)
SVvector (ent, angles)[1] = anglemod (current + move);
}
#ifdef QUAKE2
/*
PF_changepitch
*/
void
PF_changepitch (progs_t *pr)
{
edict_t *ent;
float ideal, current, move, speed;
ent = G_EDICT (pr, OFS_PARM0);
current = anglemod (SVvector (ent, angles)[0]);
ideal = SVfloat (ent, idealpitch);
speed = SVfloat (ent, pitch_speed);
if (current == ideal)
return;
move = ideal - current;
if (ideal > current) {
if (move >= 180)
move = move - 360;
} else {
if (move <= -180)
move = move + 360;
}
if (move > 0) {
if (move > speed)
move = speed;
} else {
if (move < -speed)
move = -speed;
}
SVvector (ent, angles)[0] = anglemod (current + move);
}
#endif
/*
===============================================================================
@ -1240,22 +1163,6 @@ PF_setspawnparms (progs_t *pr)
void
PF_changelevel (progs_t *pr)
{
#ifdef QUAKE2
char *s1, *s2;
if (svs.changelevel_issued)
return;
svs.changelevel_issued = true;
s1 = G_STRING (pr, OFS_PARM0);
s2 = G_STRING (pr, OFS_PARM1);
if ((int) *sv_globals.
serverflags & (SFL_NEW_UNIT | SFL_NEW_EPISODE))
Cbuf_AddText (va ("changelevel %s %s\n", s1, s2));
else
Cbuf_AddText (va ("changelevel2 %s %s\n", s1, s2));
#else
char *s;
// make sure we don't issue two changelevels
@ -1265,166 +1172,9 @@ PF_changelevel (progs_t *pr)
s = G_STRING (pr, OFS_PARM0);
Cbuf_AddText (va ("changelevel %s\n", s));
#endif
}
#ifdef QUAKE2
#define CONTENT_WATER -3
#define CONTENT_SLIME -4
#define CONTENT_LAVA -5
#define FL_IMMUNE_WATER 131072
#define FL_IMMUNE_SLIME 262144
#define FL_IMMUNE_LAVA 524288
#define CHAN_VOICE 2
#define CHAN_BODY 4
#define ATTN_NORM 1
void
PF_WaterMove (progs_t *pr)
{
edict_t *self;
int flags;
int waterlevel;
int watertype;
float drownlevel;
float damage = 0.0;
self = PROG_TO_EDICT (pr, *sv_globals.self);
if (SVfloat (self, movetype) == MOVETYPE_NOCLIP) {
SVfloat (self, air_finished) = sv.time + 12;
G_FLOAT (pr, OFS_RETURN) = damage;
return;
}
if (SVfloat (self, health) < 0) {
G_FLOAT (pr, OFS_RETURN) = damage;
return;
}
if (SVfloat (self, deadflag) == DEAD_NO)
drownlevel = 3;
else
drownlevel = 1;
flags = (int) SVfloat (self, flags);
waterlevel = (int) SVfloat (self, waterlevel);
watertype = (int) SVfloat (self, watertype);
if (!(flags & (FL_IMMUNE_WATER + FL_GODMODE)))
if (((flags & FL_SWIM) && (waterlevel < drownlevel))
|| (waterlevel >= drownlevel)) {
if (SVfloat (self, air_finished) < sv.time)
if (SVfloat (self, pain_finished) < sv.time) {
SVfloat (self, dmg) = SVfloat (self, dmg) + 2;
if (SVfloat (self, dmg) > 15)
SVfloat (self, dmg) = 10;
// T_Damage (self, world, world, self.dmg, 0, FALSE);
damage = SVfloat (self, dmg);
SVfloat (self, pain_finished) = sv.time + 1.0;
}
} else {
if (SVfloat (self, air_finished) < sv.time)
// sound (self, CHAN_VOICE, "player/gasp2.wav", 1, ATTN_NORM);
SV_StartSound (self, CHAN_VOICE, "player/gasp2.wav", 255,
ATTN_NORM);
else if (SVfloat (self, air_finished) < sv.time + 9)
// sound (self, CHAN_VOICE, "player/gasp1.wav", 1, ATTN_NORM);
SV_StartSound (self, CHAN_VOICE, "player/gasp1.wav", 255,
ATTN_NORM);
SVfloat (self, air_finished) = sv.time + 12.0;
SVfloat (self, dmg) = 2;
}
if (!waterlevel) {
if (flags & FL_INWATER) {
// play leave water sound
// sound (self, CHAN_BODY, "misc/outwater.wav", 1, ATTN_NORM);
SV_StartSound (self, CHAN_BODY, "misc/outwater.wav", 255,
ATTN_NORM);
SVfloat (self, flags) = (float) (flags & ~FL_INWATER);
}
SVfloat (self, air_finished) = sv.time + 12.0;
G_FLOAT (pr, OFS_RETURN) = damage;
return;
}
if (watertype == CONTENT_LAVA) { // do damage
if (!(flags & (FL_IMMUNE_LAVA + FL_GODMODE)))
if (SVfloat (self, dmgtime) < sv.time) {
if (SVfloat (self, radsuit_finished) < sv.time)
SVfloat (self, dmgtime) = sv.time + 0.2;
else
SVfloat (self, dmgtime) = sv.time + 1.0;
// T_Damage (self, world, world, 10*self.waterlevel, 0, TRUE);
damage = (float) (10 * waterlevel);
}
} else if (watertype == CONTENT_SLIME) { // do damage
if (!(flags & (FL_IMMUNE_SLIME + FL_GODMODE)))
if (SVfloat (self, dmgtime) < sv.time
&& SVfloat (self, radsuit_finished) < sv.time) {
SVfloat (self, dmgtime) = sv.time + 1.0;
// T_Damage (self, world, world, 4*self.waterlevel, 0, TRUE);
damage = (float) (4 * waterlevel);
}
}
if (!(flags & FL_INWATER)) {
// player enter water sound
if (watertype == CONTENT_LAVA)
// sound (self, CHAN_BODY, "player/inlava.wav", 1, ATTN_NORM);
SV_StartSound (self, CHAN_BODY, "player/inlava.wav", 255,
ATTN_NORM);
if (watertype == CONTENT_WATER)
// sound (self, CHAN_BODY, "player/inh2o.wav", 1, ATTN_NORM);
SV_StartSound (self, CHAN_BODY, "player/inh2o.wav", 255, ATTN_NORM);
if (watertype == CONTENT_SLIME)
// sound (self, CHAN_BODY, "player/slimbrn2.wav", 1, ATTN_NORM);
SV_StartSound (self, CHAN_BODY, "player/slimbrn2.wav", 255,
ATTN_NORM);
SVfloat (self, flags) = (float) (flags | FL_INWATER);
SVfloat (self, dmgtime) = 0;
}
if (!(flags & FL_WATERJUMP)) {
// self.velocity = self.velocity - 0.8*self.waterlevel*frametime*self.velocity;
VectorMA (SVvector (self, velocity),
-0.8 * SVfloat (self, waterlevel) * host_frametime,
SVvector (self, velocity), SVvector (self, velocity));
}
G_FLOAT (pr, OFS_RETURN) = damage;
}
void
PF_sin (progs_t *pr)
{
G_FLOAT (pr, OFS_RETURN) = sin (G_FLOAT (pr, OFS_PARM0));
}
void
PF_cos (progs_t *pr)
{
G_FLOAT (pr, OFS_RETURN) = cos (G_FLOAT (pr, OFS_PARM0));
}
void
PF_sqrt (progs_t *pr)
{
G_FLOAT (pr, OFS_RETURN) = sqrt (G_FLOAT (pr, OFS_PARM0));
}
#endif
#define MAX_PF_HULLS 64 // FIXME make dynamic?
clip_hull_t *pf_hull_list[MAX_PF_HULLS];
@ -1654,16 +1404,6 @@ SV_PR_Cmds_Init ()
PR_AddBuiltin (&sv_pr_state, "writestring", PF_WriteString, 58); // void(float to, string s) WriteString = #58
PR_AddBuiltin (&sv_pr_state, "writeentity", PF_WriteEntity, 59); // void(float to, entity s) WriteEntity = #59
#ifdef QUAKE2
/* PF_sin,
PF_cos,
PF_sqrt,
PF_changepitch,
PF_TraceToss,
PF_etos,
PF_WaterMove, */
#endif
PR_AddBuiltin (&sv_pr_state, "movetogoal", SV_MoveToGoal, 67); // void(float step) movetogoal = #67
PR_AddBuiltin (&sv_pr_state, "precache_file", PF_precache_file, 68); // string(string s) precache_file = #68
PR_AddBuiltin (&sv_pr_state, "makestatic", PF_makestatic, 69); // void(entity e) makestatic = #69

30
nq/source/sv_main.c
View File

@ -393,12 +393,6 @@ SV_WriteEntitiesToClient (edict_t *clent, sizebuf_t *msg)
// send over all entities (excpet the client) that touch the pvs
ent = NEXT_EDICT (&sv_pr_state, sv.edicts);
for (e = 1; e < sv.num_edicts; e++, ent = NEXT_EDICT (&sv_pr_state, ent)) {
#ifdef QUAKE2
// don't send if flagged for NODRAW and there are no lighting effects
if (SVfloat (ent, effects) == EF_NODRAW)
continue;
#endif
// ignore if not touching a PV leaf
if (ent != clent) // clent is ALLWAYS sent
{
@ -520,10 +514,7 @@ SV_WriteClientdataToMessage (edict_t *ent, sizebuf_t *msg)
{
int bits, items, i;
edict_t *other;
#ifndef QUAKE2
pr_type_t *val;
#endif
// send a damage message
if (SVfloat (ent, dmg_take) || SVfloat (ent, dmg_save)) {
@ -561,9 +552,6 @@ SV_WriteClientdataToMessage (edict_t *ent, sizebuf_t *msg)
// stuff the sigil bits into the high bits of items for sbar, or else
// mix in items2
#ifdef QUAKE2
items = (int) SVfloat (ent, items) | ((int) SVfloat (ent, items2) << 23);
#else
val = GetEdictFieldValue (&sv_pr_state, ent, "items2");
if (val)
@ -571,7 +559,6 @@ SV_WriteClientdataToMessage (edict_t *ent, sizebuf_t *msg)
else
items = (int) SVfloat (ent, items) | ((int) *sv_globals.serverflags <<
28);
#endif
bits |= SU_ITEMS;
@ -886,11 +873,7 @@ SV_SendReconnect (void)
NET_SendToAll (&msg, 5);
if (cls.state != ca_dedicated)
#ifdef QUAKE2
Cbuf_InsertText ("reconnect\n");
#else
Cmd_ExecuteString ("reconnect\n", src_command);
#endif
}
/*
@ -929,13 +912,8 @@ extern float scr_centertime_off;
This is called at the start of each level
*/
#ifdef QUAKE2
void
SV_SpawnServer (const char *server, const char *startspot)
#else
void
SV_SpawnServer (const char *server)
#endif
{
int i;
edict_t *ent;
@ -970,10 +948,6 @@ SV_SpawnServer (const char *server)
memset (&sv, 0, sizeof (sv));
strcpy (sv.name, server);
#ifdef QUAKE2
if (startspot)
strcpy (sv.startspot, startspot);
#endif
// load progs to get entity field count
SV_LoadProgs ();
@ -1049,10 +1023,6 @@ SV_SpawnServer (const char *server)
*sv_globals.deathmatch = deathmatch->int_val;
*sv_globals.mapname = PR_SetString (&sv_pr_state, sv.name);
#ifdef QUAKE2
*sv_globals.startspot =
PR_SetString (&sv_pr_state, sv.startspot);
#endif
// serverflags are for cross level information (sigils)
*sv_globals.serverflags = svs.serverflags;

436
nq/source/sv_phys.c
View File

@ -60,10 +60,6 @@ cvar_t *sv_gravity;
cvar_t *sv_maxvelocity;
cvar_t *sv_nostep;
#ifdef QUAKE2
static vec3_t vec_origin = { 0.0, 0.0, 0.0 };
#endif
#define MOVE_EPSILON 0.01
void SV_Physics_Toss (edict_t *ent);
@ -83,9 +79,6 @@ SV_CheckAllEnts (void)
continue;
if (SVfloat (check, movetype) == MOVETYPE_PUSH
|| SVfloat (check, movetype) == MOVETYPE_NONE
#ifdef QUAKE2
|| SVfloat (check, movetype) == MOVETYPE_FOLLOW
#endif
|| SVfloat (check, movetype) == MOVETYPE_NOCLIP)
continue;
@ -343,12 +336,6 @@ SV_AddGravity (edict_t *ent)
{
float ent_gravity;
#ifdef QUAKE2
if (SVfloat (ent, gravity))
ent_gravity = SVfloat (ent, gravity);
else
ent_gravity = 1.0;
#else
pr_type_t *val;
val = GetEdictFieldValue (&sv_pr_state, ent, "gravity");
@ -356,7 +343,6 @@ SV_AddGravity (edict_t *ent)
ent_gravity = val->float_var;
else
ent_gravity = 1.0;
#endif
SVvector (ent, velocity)[2] -= ent_gravity * sv_gravity->value * host_frametime;
}
@ -433,9 +419,6 @@ SV_PushMove (edict_t *pusher, float movetime)
continue;
if (SVfloat (check, movetype) == MOVETYPE_PUSH
|| SVfloat (check, movetype) == MOVETYPE_NONE
#ifdef QUAKE2
|| SVfloat (check, movetype) == MOVETYPE_FOLLOW
#endif
|| SVfloat (check, movetype) == MOVETYPE_NOCLIP)
continue;
@ -510,136 +493,6 @@ SV_PushMove (edict_t *pusher, float movetime)
}
#ifdef QUAKE2
void
SV_PushRotate (edict_t *pusher, float movetime)
{
int i, e;
edict_t *check, *block;
vec3_t move, a, amove;
vec3_t entorig, pushorig;
int num_moved;
edict_t *moved_edict[MAX_EDICTS];
vec3_t moved_from[MAX_EDICTS];
vec3_t org, org2;
vec3_t forward, right, up;
if (!SVfloat (pusher, avelocity)[0] && !SVfloat (pusher, avelocity)[1]
&& !SVfloat (pusher, avelocity)[2]) {
SVfloat (pusher, ltime) += movetime;
return;
}
for (i = 0; i < 3; i++)
amove[i] = SVfloat (pusher, avelocity)[i] * movetime;
VectorSubtract (vec3_origin, amove, a);
AngleVectors (a, forward, right, up);
VectorCopy (SVfloat (pusher, angles), pushorig);
// move the pusher to it's final position
VectorAdd (SVfloat (pusher, angles), amove, SVfloat (pusher, angles));
SVfloat (pusher, ltime) += movetime;
SV_LinkEdict (pusher, false);
// see if any solid entities are inside the final position
num_moved = 0;
check = NEXT_EDICT (&sv_pr_state, sv.edicts);
for (e = 1; e < sv.num_edicts;
e++, check = NEXT_EDICT (&sv_pr_state, check)) {
if (check->free)
continue;
if (SVfloat (check, movetype) == MOVETYPE_PUSH
|| SVfloat (check, movetype) == MOVETYPE_NONE
|| SVfloat (check, movetype) == MOVETYPE_FOLLOW
|| SVfloat (check, movetype) == MOVETYPE_NOCLIP) continue;
// if the entity is standing on the pusher, it will definately be moved
if (!(((int) SVfloat (check, flags) & FL_ONGROUND)
&& PROG_TO_EDICT (&sv_pr_state,
SVfloat (check, groundentity)) == pusher)) {
if (SVfloat (check, absmin)[0] >= SVfloat (pusher, absmax)[0]
|| SVfloat (check, absmin)[1] >= SVfloat (pusher, absmax)[1]
|| SVfloat (check, absmin)[2] >= SVfloat (pusher, absmax)[2]
|| SVfloat (check, absmax)[0] <= SVfloat (pusher, absmin)[0]
|| SVfloat (check, absmax)[1] <= SVfloat (pusher, absmin)[1]
|| SVfloat (check, absmax)[2] <= SVfloat (pusher, absmin)[2])
continue;
// see if the ent's bbox is inside the pusher's final position
if (!SV_TestEntityPosition (check))
continue;
}
// remove the onground flag for non-players
if (SVfloat (check, movetype) != MOVETYPE_WALK)
SVfloat (check, flags) = (int) SVfloat (check, flags) &
~FL_ONGROUND;
VectorCopy (SVfloat (check, origin), entorig);
VectorCopy (SVfloat (check, origin), moved_from[num_moved]);
moved_edict[num_moved] = check;
num_moved++;
// calculate destination position
VectorSubtract (SVfloat (check, origin), SVfloat (pusher, origin),
org);
org2[0] = DotProduct (org, forward);
org2[1] = -DotProduct (org, right);
org2[2] = DotProduct (org, up);
VectorSubtract (org2, org, move);
// try moving the contacted entity
SVfloat (pusher, solid) = SOLID_NOT;
SV_PushEntity (check, move);
SVfloat (pusher, solid) = SOLID_BSP;
// if it is still inside the pusher, block
block = SV_TestEntityPosition (check);
if (block) { // fail the move
if (SVfloat (check, mins)[0] == SVfloat (check, maxs)[0])
continue;
if (SVfloat (check, solid) == SOLID_NOT || SVfloat (check, solid)
== SOLID_TRIGGER) { // corpse
SVfloat (check, mins)[0] = SVfloat (check, mins)[1] = 0;
VectorCopy (SVfloat (check, mins), SVfloat (check, maxs));
continue;
}
VectorCopy (entorig, SVfloat (check, origin));
SV_LinkEdict (check, true);
VectorCopy (pushorig, SVfloat (pusher, angles));
SV_LinkEdict (pusher, false);
SVfloat (pusher, ltime) -= movetime;
// if the pusher has a "blocked" function, call it
// otherwise, just stay in place until the obstacle is gone
if (SVfloat (pusher, blocked)) {
*sv_globals.self =
EDICT_TO_PROG (&sv_pr_state, pusher);
*sv_globals.other =
EDICT_TO_PROG (&sv_pr_state, check);
PR_ExecuteProgram (&sv_pr_state, SVfloat (pusher, blocked));
}
// move back any entities we already moved
for (i = 0; i < num_moved; i++) {
VectorCopy (moved_from[i], moved_edict[i]->v.v.origin);
VectorSubtract (moved_edict[i]->v.v.angles, amove,
moved_edict[i]->v.v.angles);
SV_LinkEdict (moved_edict[i], false);
}
return;
} else {
VectorAdd (SVfloat (check, angles), amove, SVfloat (check,
angles));
}
}
}
#endif
void
SV_Physics_Pusher (edict_t *ent)
{
@ -656,14 +509,8 @@ SV_Physics_Pusher (edict_t *ent)
movetime = host_frametime;
if (movetime) {
#ifdef QUAKE2
if (SVfloat (ent, avelocity)[0] || SVfloat (ent, avelocity)[1]
|| SVfloat (ent, avelocity)[2])
SV_PushRotate (ent, movetime);
else
#endif
SV_PushMove (ent, movetime); // advances SVfloat (ent, ltime)
// if not blocked
SV_PushMove (ent, movetime); // advances SVfloat (ent, ltime)
// if not blocked
}
if (thinktime > oldltime && thinktime <= SVfloat (ent, ltime)) {
@ -729,10 +576,6 @@ SV_CheckWater (edict_t *ent)
int cont;
vec3_t point;
#ifdef QUAKE2
int truecont;
#endif
point[0] = SVvector (ent, origin)[0];
point[1] = SVvector (ent, origin)[1];
point[2] = SVvector (ent, origin)[2] + SVvector (ent, mins)[2] + 1;
@ -741,9 +584,6 @@ SV_CheckWater (edict_t *ent)
SVfloat (ent, watertype) = CONTENTS_EMPTY;
cont = SV_PointContents (point);
if (cont <= CONTENTS_WATER) {
#ifdef QUAKE2
truecont = SV_TruePointContents (point);
#endif
SVfloat (ent, watertype) = cont;
SVfloat (ent, waterlevel) = 1;
point[2] = SVvector (ent, origin)[2] + (SVvector (ent, mins)[2] +
@ -756,24 +596,6 @@ SV_CheckWater (edict_t *ent)
if (cont <= CONTENTS_WATER)
SVfloat (ent, waterlevel) = 3;
}
#ifdef QUAKE2
if (truecont <= CONTENTS_CURRENT_0 && truecont >=
CONTENTS_CURRENT_DOWN) {
static vec3_t current_table[] = {
{1, 0, 0},
{0, 1, 0},
{-1, 0, 0},
{0, -1, 0},
{0, 0, 1},
{0, 0, -1}
};
VectorMA (SVfloat (ent, basevelocity), 150.0 *
SVfloat (ent, waterlevel) / 3.0,
current_table[CONTENTS_CURRENT_0 - truecont],
SVfloat (ent, basevelocity));
}
#endif
}
return SVfloat (ent, waterlevel) > 1;
@ -1001,16 +823,7 @@ SV_Physics_Client (edict_t *ent, int num)
FL_WATERJUMP))
SV_AddGravity (ent);
SV_CheckStuck (ent);
#ifdef QUAKE2
VectorAdd (SVfloat (ent, velocity), SVfloat (ent, basevelocity),
SVfloat (ent, velocity));
#endif
SV_WalkMove (ent);
#ifdef QUAKE2
VectorSubtract (SVfloat (ent, velocity), SVfloat (ent, basevelocity),
SVfloat (ent, velocity));
#endif
break;
case MOVETYPE_TOSS:
@ -1057,23 +870,6 @@ SV_Physics_None (edict_t *ent)
SV_RunThink (ent);
}
#ifdef QUAKE2
/*
SV_Physics_Follow
Entities that are "stuck" to another entity
*/
void
SV_Physics_Follow (edict_t *ent)
{
// regular thinking
SV_RunThink (ent);
VectorAdd (PROG_TO_EDICT (&sv_pr_state, SVfloat (ent, aiment))->v.v.origin,
SVfloat (ent, v_angle), SVfloat (ent, origin));
SV_LinkEdict (ent, true);
}
#endif
/*
SV_Physics_Noclip
@ -1101,16 +897,7 @@ SV_CheckWaterTransition (edict_t *ent)
{
int cont;
#ifdef QUAKE2
vec3_t point;
point[0] = SVvector (ent, origin)[0];
point[1] = SVvector (ent, origin)[1];
point[2] = SVvector (ent, origin)[2] + SVvector (ent, mins)[2] + 1;
cont = SV_PointContents (point);
#else
cont = SV_PointContents (SVvector (ent, origin));
#endif
if (!SVfloat (ent, watertype)) { // just spawned here
SVfloat (ent, watertype) = cont;
@ -1147,39 +934,10 @@ SV_Physics_Toss (edict_t *ent)
trace_t trace;
vec3_t move;
#ifdef QUAKE2
edict_t *groundentity;
groundentity = PROG_TO_EDICT (&sv_pr_state, SVentity (ent, groundentity));
if ((int) SVfloat (groundentity, flags) & FL_CONVEYOR)
VectorScale (SVfloat (groundentity, movedir),
SVfloat (groundentity, speed),
SVfloat (ent, basevelocity));
else
VectorCopy (vec_origin, SVfloat (ent, basevelocity));
SV_CheckWater (ent);
#endif
// regular thinking
if (!SV_RunThink (ent))
return;
#ifdef QUAKE2
if (SVfloat (ent, velocity)[2] > 0)
SVfloat (ent, flags) = (int) SVfloat (ent, flags) & ~FL_ONGROUND;
if (((int) SVfloat (ent, flags) & FL_ONGROUND))
//@@
if (VectorCompare (SVfloat (ent, basevelocity), vec_origin))
return;
SV_CheckVelocity (ent);
// add gravity
if (!((int) SVfloat (ent, flags) & FL_ONGROUND)
&& SVfloat (ent, movetype) != MOVETYPE_FLY
&& SVfloat (ent, movetype) != MOVETYPE_BOUNCEMISSILE
&& SVfloat (ent, movetype) != MOVETYPE_FLYMISSILE) SV_AddGravity (ent);
#else
// if onground, return without moving
if (((int) SVfloat (ent, flags) & FL_ONGROUND))
return;
@ -1189,23 +947,14 @@ SV_Physics_Toss (edict_t *ent)
// add gravity
if (SVfloat (ent, movetype) != MOVETYPE_FLY
&& SVfloat (ent, movetype) != MOVETYPE_FLYMISSILE) SV_AddGravity (ent);
#endif
// move angles
VectorMA (SVvector (ent, angles), host_frametime,
SVvector (ent, avelocity), SVvector (ent, angles));
// move origin
#ifdef QUAKE2
VectorAdd (SVvector (ent, velocity), SVvector (ent, basevelocity),
SVvector (ent, velocity));
#endif
VectorScale (SVvector (ent, velocity), host_frametime, move);
trace = SV_PushEntity (ent, move);
#ifdef QUAKE2
VectorSubtract (SVvector (ent, velocity), SVvector (ent, basevelocity),
SVvector (ent, velocity));
#endif
if (trace.fraction == 1)
return;
if (ent->free)
@ -1213,10 +962,6 @@ SV_Physics_Toss (edict_t *ent)
if (SVfloat (ent, movetype) == MOVETYPE_BOUNCE)
backoff = 1.5;
#ifdef QUAKE2
else if (SVfloat (ent, movetype) == MOVETYPE_BOUNCEMISSILE)
backoff = 2.0;
#endif
else
backoff = 1;
@ -1225,14 +970,8 @@ SV_Physics_Toss (edict_t *ent)
// stop if on ground
if (trace.plane.normal[2] > 0.7) {
#ifdef QUAKE2
if (SVvector (ent, velocity)[2] < 60
|| (SVfloat (ent, movetype) != MOVETYPE_BOUNCE
&& SVfloat (ent, movetype) != MOVETYPE_BOUNCEMISSILE))
#else
if (SVvector (ent, velocity)[2] < 60 || SVfloat (ent, movetype) !=
MOVETYPE_BOUNCE)
#endif
if (SVvector (ent, velocity)[2] < 60 || SVfloat (ent, movetype) !=
MOVETYPE_BOUNCE)
{
SVfloat (ent, flags) = (int) SVfloat (ent, flags) | FL_ONGROUND;
SVentity (ent, groundentity) = EDICT_TO_PROG (&sv_pr_state,
@ -1256,110 +995,6 @@ SV_Physics_Toss (edict_t *ent)
This is also used for objects that have become still on the ground, but
will fall if the floor is pulled out from under them.
*/
#ifdef QUAKE2
void
SV_Physics_Step (edict_t *ent)
{
float control, friction, speed, newspeed;
float *vel;
edict_t *groundentity;
qboolean wasonground, inwater;
qboolean hitsound = false;
groundentity = PROG_TO_EDICT (&sv_pr_state, SVfloat (ent, groundentity));
if ((int) SVfloat (groundentity, flags) & FL_CONVEYOR)
VectorScale (SVfloat (groundentity, movedir),
SVfloat (groundentity, speed),
SVfloat (ent, basevelocity));
else
VectorCopy (vec_origin, SVfloat (ent, basevelocity));
//@@
*sv_globals.time = sv.time;
*sv_globals.self = EDICT_TO_PROG (&sv_pr_state, ent);
PF_WaterMove (&sv_pr_state);
SV_CheckVelocity (ent);
wasonground = (int) SVfloat (ent, flags) & FL_ONGROUND;
// SVfloat (ent, flags) = (int)SVfloat (ent, flags) & ~FL_ONGROUND;
// add gravity except:
// flying monsters and swimming monsters who are in the water
inwater = SV_CheckWater (ent);
if (!wasonground)
if (!((int) SVfloat (ent, flags) & FL_FLY))
if (!(((int) SVfloat (ent, flags) & FL_SWIM)
&& (SVfloat (ent, waterlevel) > 0))) {
if (SVfloat (ent, velocity)[2] < sv_gravity->value * -0.1)
hitsound = true;
if (!inwater)
SV_AddGravity (ent);
}
if (!VectorCompare (SVfloat (ent, velocity), vec_origin)
|| !VectorCompare (SVfloat (ent, basevelocity), vec_origin)) {
SVfloat (ent, flags) = (int) SVfloat (ent, flags) & ~FL_ONGROUND;
// apply friction
// let dead monsters who aren't completely onground slide
if (wasonground)
if (!(SVfloat (ent, health) <= 0.0 && !SV_CheckBottom (ent))) {
vel = SVfloat (ent, velocity);
speed = sqrt (vel[0] * vel[0] + vel[1] * vel[1]);
if (speed) {
friction = sv_friction->value;
control = speed <sv_stopspeed->value ?
sv_stopspeed->value : speed;
newspeed = speed - host_frametime * control * friction;
if (newspeed < 0)
newspeed = 0;
newspeed /= speed;
vel[0] = vel[0] * newspeed;
vel[1] = vel[1] * newspeed;
}
}
VectorAdd (SVfloat (ent, velocity), SVfloat (ent, basevelocity),
SVfloat (ent, velocity));
SV_FlyMove (ent, host_frametime, NULL);
VectorSubtract (SVfloat (ent, velocity), SVfloat (ent, basevelocity),
SVfloat (ent, velocity));
// determine if it's on solid ground at all
{
int x, y;
vec3_t mins, maxs, point;
VectorAdd (SVfloat (ent, origin), SVfloat (ent, mins), mins);
VectorAdd (SVfloat (ent, origin), SVfloat (ent, maxs), maxs);
point[2] = mins[2] - 1;
for (x = 0; x <= 1; x++)
for (y = 0; y <= 1; y++) {
point[0] = x ? maxs[0] : mins[0];
point[1] = y ? maxs[1] : mins[1];
if (SV_PointContents (point) == CONTENTS_SOLID) {
SVfloat (ent, flags) = (int) SVfloat (ent, flags) |
FL_ONGROUND;
break;
}
}
}
SV_LinkEdict (ent, true);
if ((int) SVfloat (ent, flags) & FL_ONGROUND)
if (!wasonground)
if (hitsound)
SV_StartSound (ent, 0, "demon/dland2.wav", 255, 1);
}
// regular thinking
SV_RunThink (ent);
SV_CheckWaterTransition (ent);
}
#else
void
SV_Physics_Step (edict_t *ent)
{
@ -1388,7 +1023,6 @@ SV_Physics_Step (edict_t *ent)
SV_CheckWaterTransition (ent);
}
#endif
void
SV_Physics (void)
@ -1422,19 +1056,12 @@ SV_Physics (void)
SV_Physics_Pusher (ent);
else if (SVfloat (ent, movetype) == MOVETYPE_NONE)
SV_Physics_None (ent);
#ifdef QUAKE2
else if (SVfloat (ent, movetype) == MOVETYPE_FOLLOW)
SV_Physics_Follow (ent);
#endif
else if (SVfloat (ent, movetype) == MOVETYPE_NOCLIP)
SV_Physics_Noclip (ent);
else if (SVfloat (ent, movetype) == MOVETYPE_STEP)
SV_Physics_Step (ent);
else if (SVfloat (ent, movetype) == MOVETYPE_TOSS
|| SVfloat (ent, movetype) == MOVETYPE_BOUNCE
#ifdef QUAKE2
|| SVfloat (ent, movetype) == MOVETYPE_BOUNCEMISSILE
#endif
|| SVfloat (ent, movetype) == MOVETYPE_FLY
|| SVfloat (ent, movetype) == MOVETYPE_FLYMISSILE)
SV_Physics_Toss (ent);
@ -1448,58 +1075,3 @@ SV_Physics (void)
sv.time += host_frametime;
}
#ifdef QUAKE2
trace_t
SV_Trace_Toss (edict_t *ent, edict_t *ignore)
{
double save_frametime;
vec3_t end, move;
edict_t tempent, *tent;
trace_t trace;
// extern particle_t *active_particles, *free_particles;
// particle_t *p;
save_frametime = host_frametime;
host_frametime = 0.05;
memcpy (&tempent, ent, sizeof (edict_t));
tent = &tempent;
while (1) {
SV_CheckVelocity (tent);
SV_AddGravity (tent);
VectorMA (SVfloat (tent, angles), host_frametime,
SVfloat (tent, avelocity), SVfloat (tent, angles));
VectorScale (SVfloat (tent, velocity), host_frametime, move);
VectorAdd (SVfloat (tent, origin), move, end);
trace =
SV_Move (SVfloat (tent, origin), SVfloat (tent, mins), SVfloat (tent, maxs), end,
MOVE_NORMAL, tent);
VectorCopy (trace.endpos, SVfloat (tent, origin));
// p = free_particles;
// if (p)
// {
// free_particles = p->next;
// p->next = active_particles;
// active_particles = p;
//
// p->die = 256;
// p->color = 15;
// p->type = pt_static;
// VectorCopy (vec3_origin, p->vel);
// VectorCopy (SVfloat (tent, origin), p->org);
// }
if (trace.ent)
if (trace.ent != ignore)
break;
}
// p->color = 224;
host_frametime = save_frametime;
return trace;
}
#endif

5
nq/source/sv_user.c
View File

@ -437,11 +437,6 @@ SV_ReadClientMove (usercmd_t *move)
i = MSG_ReadByte (net_message);
if (i)
SVfloat (host_client->edict, impulse) = i;
#ifdef QUAKE2
// read light level
SVfloat (host_client->edict, light_level) = MSG_ReadByte (net_message);
#endif
}
/*

4
qw/include/protocol.h
View File

@ -244,10 +244,6 @@
#define TE_TELEPORT 11
#define TE_BLOOD 12
#define TE_LIGHTNINGBLOOD 13
#ifdef QUAKE2
#define TE_IMPLOSION 14
#define TE_RAILTRAIL 15
#endif
#define TE_EXPLOSION2 16
// PGM 01/21/97
#define TE_BEAM 17

43
qw/source/cl_tent.c
View File

@ -83,10 +83,6 @@ sfx_t *cl_sfx_ric1;
sfx_t *cl_sfx_ric2;
sfx_t *cl_sfx_ric3;
sfx_t *cl_sfx_r_exp3;
#ifdef QUAKE2
sfx_t *cl_sfx_imp;
sfx_t *cl_sfx_rail;
#endif
model_t *cl_mod_bolt;
model_t *cl_mod_bolt2;
@ -124,10 +120,6 @@ CL_TEnts_Init (void)
cl_sfx_ric2 = S_PrecacheSound ("weapons/ric2.wav");
cl_sfx_ric3 = S_PrecacheSound ("weapons/ric3.wav");
cl_sfx_r_exp3 = S_PrecacheSound ("weapons/r_exp3.wav");
#ifdef QUAKE2
cl_sfx_imp = S_PrecacheSound ("shambler/sattck1.wav");
cl_sfx_rail = S_PrecacheSound ("weapons/lstart.wav");
#endif
cl_mod_bolt = Mod_ForName ("progs/bolt.mdl", true);
cl_mod_bolt2 = Mod_ForName ("progs/bolt2.mdl", true);
@ -243,9 +235,6 @@ CL_ParseTEnt (void)
{
byte type;
vec3_t pos;
#ifdef QUAKE2
vec3_t endpos;
#endif
dlight_t *dl;
int rnd;
int colorStart, colorLength;
@ -404,38 +393,6 @@ CL_ParseTEnt (void)
R_RunPuffEffect (pos, prot_to_rend[type], cnt);
break;
#ifdef QUAKE2
case TE_IMPLOSION:
pos[0] = MSG_ReadCoord (net_message);
pos[1] = MSG_ReadCoord (net_message);
pos[2] = MSG_ReadCoord (net_message);
S_StartSound (-1, 0, cl_sfx_imp, pos, 1, 1);
break;
case TE_RAILTRAIL:
pos[0] = MSG_ReadCoord (net_message);
pos[1] = MSG_ReadCoord (net_message);
pos[2] = MSG_ReadCoord (net_message);
endpos[0] = MSG_ReadCoord (net_message);
endpos[1] = MSG_ReadCoord (net_message);
endpos[2] = MSG_ReadCoord (net_message);
S_StartSound (-1, 0, cl_sfx_rail, pos, 1, 1);
S_StartSound (-1, 1, cl_sfx_r_exp3, endpos, 1, 1);
/* Need updating to new Particle API
R_RocketTrail (pos, endpos, 0 + 128);
R_ParticleExplosion (endpos);
*/
dl = R_AllocDlight (-1);
VectorCopy (endpos, dl->origin);
dl->radius = 350;
dl->die = cl.time + 0.5;
dl->decay = 300;
dl->color[0] = 0.86;
dl->color[1] = 0.31;
dl->color[2] = 0.24;
break;
#endif
default:
Sys_Error ("CL_ParseTEnt: bad type");
}