server.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	client_t
struct	csqcentityframedb_t
struct	server_floodaddress_t
struct	server_static_t
struct	server_t

Macros
#define	DAMAGE_AIM   2
#define	DAMAGE_NO   0
#define	DAMAGE_YES   1
#define	DEAD_DEAD   2
#define	DEAD_DYING   1
#define	DEAD_NO   0
#define	FL_CLIENT   8
#define	FL_CONVEYOR   4
#define	FL_FLY   1
#define	FL_GODMODE   64
#define	FL_INWATER   16
#define	FL_ITEM   256
#define	FL_JUMPRELEASED   4096
	for jump debouncing
#define	FL_MONSTER   32
	movement is smoothed on the client side by step based interpolation
#define	FL_NOTARGET   128
#define	FL_ONGROUND   512
#define	FL_PARTIALGROUND   1024
	not all corners are valid
#define	FL_SWIM   2
#define	FL_WATERJUMP   2048
	player jumping out of water
#define	MAX_CONNECTFLOODADDRESSES   16
#define	MAX_GETSTATUSFLOODADDRESSES   128
#define	MOVETYPE_ANGLECLIP   2
#define	MOVETYPE_ANGLENOCLIP   1
#define	MOVETYPE_BOUNCE   10
#define	MOVETYPE_BOUNCEMISSILE   11
	bounce w/o gravity
#define	MOVETYPE_FAKEPUSH   13
	tenebrae's push that doesn't push
#define	MOVETYPE_FLY   5
#define	MOVETYPE_FLY_WORLDONLY   33
	like MOVETYPE_FLY, but uses MOVE_WORLDONLY for all its traces; objects of this movetype better be SOLID_NOT or SOLID_TRIGGER please, or else...
#define	MOVETYPE_FLYMISSILE   9
	extra size to monsters
#define	MOVETYPE_FOLLOW   12
	track movement of aiment
#define	MOVETYPE_NOCLIP   8
#define	MOVETYPE_NONE   0
	never moves
#define	MOVETYPE_PHYSICS   32
	indicates this object is physics controlled
#define	MOVETYPE_PUSH   7
	no clip to world, push and crush
#define	MOVETYPE_STEP   4
	gravity, special edge handling, special step based client side interpolation
#define	MOVETYPE_TOSS   6
	gravity
#define	MOVETYPE_USER_FIRST   128
	user defined movetypes
#define	MOVETYPE_USER_LAST   191
#define	MOVETYPE_WALK   3
	gravity
#define	NUM_CSQCENTITIES_PER_FRAME   256
#define	NUM_CSQCENTITYDB_FRAMES   256
#define	NUM_SPAWN_PARMS   16
#define	SOLID_BBOX   2
	touch on edge, block
#define	SOLID_BSP   4
	bsp clip, touch on edge, block
#define	SOLID_CORPSE   5
	same as SOLID_BBOX, except it behaves as SOLID_NOT against SOLID_SLIDEBOX objects (players/monsters)
#define	SOLID_NOT   0
	no interaction with other objects
#define	SOLID_PHYSICS_BOX   32
	physics object (mins, maxs, mass, origin, axis_forward, axis_left, axis_up, velocity, spinvelocity)
#define	SOLID_PHYSICS_CAPSULE   34
	physics object (mins, maxs, mass, origin, axis_forward, axis_left, axis_up, velocity, spinvelocity)
#define	SOLID_PHYSICS_CYLINDER   36
	physics object (mins, maxs, mass, origin, axis_forward, axis_left, axis_up, velocity, spinvelocity)
#define	SOLID_PHYSICS_SPHERE   33
	physics object (mins, maxs, mass, origin, axis_forward, axis_left, axis_up, velocity, spinvelocity)
#define	SOLID_PHYSICS_TRIMESH   35
	physics object (mins, maxs, mass, origin, axis_forward, axis_left, axis_up, velocity, spinvelocity)
#define	SOLID_SLIDEBOX   3
	touch on edge, but not an onground
#define	SOLID_TRIGGER   1
	touch on edge, but not blocking
#define	SPAWNFLAG_NOT_DEATHMATCH   2048
#define	SPAWNFLAG_NOT_EASY   256
#define	SPAWNFLAG_NOT_HARD   1024
#define	SPAWNFLAG_NOT_MEDIUM   512
#define	SV_LockThreadMutex()
#define	SV_UnlockThreadMutex()

Enumerations
enum	server_state_t { ss_loading , ss_active }

Functions
void	SV_AddCameraEyes (void)
void	SV_AddUpdates (void)
void	SV_ApplyClientMove (void)
void	SV_Begin_f (cmd_state_t *cmd)
void	SV_BroadcastPrint (const char *msg)
void	SV_BroadcastPrintf (const char *fmt,...) DP_FUNC_PRINTF(1)
qbool	SV_CanSeeBox (int numsamples, vec_t eyejitter, vec_t enlarge, vec_t entboxexpand, vec3_t eye, vec3_t entboxmins, vec3_t entboxmaxs)
qbool	SV_CheckBottom (prvm_edict_t *ent)
void	SV_CheckVelocity (prvm_edict_t *ent)
void	SV_ClientCommands (const char *fmt,...) DP_FUNC_PRINTF(1)
void	SV_ClientPrint (const char *msg)
void	SV_ClientPrintf (const char *fmt,...) DP_FUNC_PRINTF(1)
void	SV_ConnectClient (int clientnum, netconn_t *netconnection)
void	SV_DropClient (qbool leaving, const char *reason,...)
int	SV_EntitiesInBox (const vec3_t mins, const vec3_t maxs, int maxedicts, prvm_edict_t **resultedicts)
void	SV_FlushBroadcastMessages (void)
double	SV_Frame (double time)
int	SV_GenericHitSuperContentsMask (const prvm_edict_t *edict)
	calculates hitsupercontentsmask for a generic qc entity
void	SV_GetEntityMatrix (prvm_prog_t *prog, prvm_edict_t *ent, matrix4x4_t *out, qbool viewmatrix)
model_t *	SV_GetModelByIndex (int modelindex)
model_t *	SV_GetModelFromEdict (prvm_edict_t *ed)
int	SV_GetPitchSign (prvm_prog_t *prog, prvm_edict_t *ent)
void	SV_Init (void)
void	SV_InitOperatorCommands (void)
int	SV_IsLocalServer (void)
void	SV_LinkEdict (prvm_edict_t *ent)
void	SV_LinkEdict_TouchAreaGrid (prvm_edict_t *ent)
void	SV_LinkEdict_TouchAreaGrid_Call (prvm_edict_t *touch, prvm_edict_t *ent)
void	SV_Loadgame_f (cmd_state_t *cmd)
void	SV_MarkWriteEntityStateToClient (entity_state_t *s, client_t *client)
int	SV_ModelIndex (const char *s, int precachemode)
qbool	SV_movestep (prvm_edict_t *ent, vec3_t move, qbool relink, qbool noenemy, qbool settrace)
void	SV_Name (int clientnum)
int	SV_ParticleEffectIndex (const char *name)
void	SV_Physics (void)
void	SV_Physics_ClientMove (void)
qbool	SV_PlayerCheckGround (prvm_edict_t *ent)
void	SV_PlayerPhysics (void)
int	SV_PointSuperContents (const vec3_t point)
void	SV_PreSpawn_f (cmd_state_t *cmd)
void	SV_ReadClientMessage (void)
void	SV_Savegame_f (cmd_state_t *cmd)
void	SV_Savegame_to (prvm_prog_t *prog, const char *name)
void	SV_SaveSpawnparms (void)
void	SV_SendClientMessages (void)
void	SV_SendServerinfo (client_t *client)
void	SV_SetIdealPitch (void)
void	SV_SetupVM (void)
void	SV_Shutdown (void)
int	SV_SoundIndex (const char *s, int precachemode)
void	SV_Spawn_f (cmd_state_t *cmd)
void	SV_SpawnServer (const char *map)
void	SV_StartEffect (vec3_t org, int modelindex, int startframe, int framecount, int framerate)
void	SV_StartParticle (vec3_t org, vec3_t dir, int color, int count)
void	SV_StartPointSound (vec3_t origin, const char *sample, int volume, float attenuation, float speed)
void	SV_StartSound (prvm_edict_t *entity, int channel, const char *sample, int volume, float attenuation, qbool reliable, float speed)
void	SV_StartThread (void)
void	SV_StopThread (void)
const char *	SV_TimingReport (char *buf, size_t buflen)
	for output in SV_Status_f
trace_t	SV_TraceBox (const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int type, prvm_edict_t *passedict, int hitsupercontentsmask, int skipsupercontentsmask, int skipmaterialflagsmask, float extend)
	traces a box move against worldmodel and all entities in the specified area
trace_t	SV_TraceLine (const vec3_t start, const vec3_t end, int type, prvm_edict_t *passedict, int hitsupercontentsmask, int skipsupercontentsmask, int skipmaterialflagsmask, float extend)
trace_t	SV_TracePoint (const vec3_t start, int type, prvm_edict_t *passedict, int hitsupercontentsmask, int skipsupercontentsmask, int skipmaterialflagsmask)
qbool	SV_VM_ConsoleCommand (const char *text, size_t textlen)
void	SV_WriteClientdataToMessage (client_t *client, prvm_edict_t *ent, sizebuf_t *msg, int *stats)
void	SV_WriteEntitiesToClient (client_t *client, prvm_edict_t *clent, sizebuf_t *msg, int maxsize)
void	VM_CustomStats_Clear (void)
void	VM_SV_MoveToGoal (prvm_prog_t *prog)
void	VM_SV_UpdateCustomStats (client_t *client, prvm_edict_t *ent, sizebuf_t *msg, int *stats)

Variables
cvar_t	coop
cvar_t	deathmatch
cvar_t	fraglimit
cvar_t	gamecfg
client_t *	host_client
cvar_t	host_limitlocal
cvar_t	host_timescale
cvar_t	noexit
cvar_t	nomonsters
cvar_t	pausable
cvar_t	pr_checkextension
cvar_t	samelevel
cvar_t	saved1
cvar_t	saved2
cvar_t	saved3
cvar_t	saved4
cvar_t	savedgamecfg
cvar_t	scratch1
cvar_t	scratch2
cvar_t	scratch3
cvar_t	scratch4
cvar_t	skill
server_t	sv
	local server
cvar_t	sv_accelerate
cvar_t	sv_aim
cvar_t	sv_airaccel_qw
cvar_t	sv_airaccel_sideways_friction
cvar_t	sv_airaccelerate
cvar_t	sv_aircontrol
cvar_t	sv_aircontrol_penalty
cvar_t	sv_aircontrol_power
cvar_t	sv_airspeedlimit_nonqw
cvar_t	sv_airstopaccelerate
cvar_t	sv_airstrafeaccel_qw
cvar_t	sv_airstrafeaccelerate
cvar_t	sv_allowdownloads
cvar_t	sv_allowdownloads_archive
cvar_t	sv_allowdownloads_config
cvar_t	sv_allowdownloads_dlcache
cvar_t	sv_allowdownloads_inarchive
cvar_t	sv_areadebug
cvar_t	sv_areagrid_link_SOLID_NOT
cvar_t	sv_areagrid_mingridsize
cvar_t	sv_checkforpacketsduringsleep
cvar_t	sv_clmovement_enable
cvar_t	sv_clmovement_inputtimeout
cvar_t	sv_clmovement_maxnetfps
cvar_t	sv_clmovement_minping
cvar_t	sv_clmovement_minping_disabletime
cvar_t	sv_cullentities_nevercullbmodels
cvar_t	sv_cullentities_pvs
cvar_t	sv_cullentities_stats
cvar_t	sv_cullentities_trace
cvar_t	sv_cullentities_trace_delay
cvar_t	sv_cullentities_trace_enlarge
cvar_t	sv_cullentities_trace_prediction
cvar_t	sv_cullentities_trace_samples
cvar_t	sv_cullentities_trace_samples_extra
cvar_t	sv_debugmove
cvar_t	sv_echobprint
cvar_t	sv_edgefriction
cvar_t	sv_entpatch
cvar_t	sv_freezenonclients
cvar_t	sv_friction
cvar_t	sv_gameplayfix_blowupfallenzombies
cvar_t	sv_gameplayfix_consistentplayerprethink
cvar_t	sv_gameplayfix_delayprojectiles
cvar_t	sv_gameplayfix_downtracesupportsongroundflag
cvar_t	sv_gameplayfix_droptofloorstartsolid
cvar_t	sv_gameplayfix_droptofloorstartsolid_nudgetocorrect
cvar_t	sv_gameplayfix_easierwaterjump
cvar_t	sv_gameplayfix_findradiusdistancetobox
cvar_t	sv_gameplayfix_fixedcheckwatertransition
cvar_t	sv_gameplayfix_gravityunaffectedbyticrate
cvar_t	sv_gameplayfix_grenadebouncedownslopes
cvar_t	sv_gameplayfix_impactbeforeonground
cvar_t	sv_gameplayfix_multiplethinksperframe
cvar_t	sv_gameplayfix_noairborncorpse
cvar_t	sv_gameplayfix_noairborncorpse_allowsuspendeditems
cvar_t	sv_gameplayfix_nogravityonground
cvar_t	sv_gameplayfix_nosquashentities
cvar_t	sv_gameplayfix_nostepmoveonsteepslopes
cvar_t	sv_gameplayfix_nudgeoutofsolid
cvar_t	sv_gameplayfix_nudgeoutofsolid_separation
cvar_t	sv_gameplayfix_q1bsptracelinereportstexture
cvar_t	sv_gameplayfix_q2airaccelerate
cvar_t	sv_gameplayfix_setmodelrealbox
cvar_t	sv_gameplayfix_slidemoveprojectiles
cvar_t	sv_gameplayfix_stepdown
cvar_t	sv_gameplayfix_stepmultipletimes
cvar_t	sv_gameplayfix_swiminbmodels
cvar_t	sv_gameplayfix_unstickentities
cvar_t	sv_gameplayfix_unstickplayers
cvar_t	sv_gameplayfix_upwardvelocityclearsongroundflag
cvar_t	sv_gravity
cvar_t	sv_idealpitchscale
cvar_t	sv_jumpstep
cvar_t	sv_jumpvelocity
cvar_t	sv_legacy_bbox_expand
cvar_t	sv_maxairspeed
cvar_t	sv_maxairstrafespeed
cvar_t	sv_maxrate
cvar_t	sv_maxspeed
cvar_t	sv_maxvelocity
mempool_t *	sv_mempool
cvar_t	sv_nostep
cvar_t	sv_playerphysicsqc
cvar_t	sv_progs
cvar_t	sv_protocolname
cvar_t	sv_random_seed
cvar_t	sv_sound_land
cvar_t	sv_sound_watersplash
cvar_t	sv_stepheight
cvar_t	sv_stopspeed
cvar_t	sv_wallfriction
cvar_t	sv_wateraccelerate
cvar_t	sv_waterfriction
server_static_t	svs
	persistant server info
cvar_t	sys_ticrate
cvar_t	teamplay
cvar_t	temp1
cvar_t	timelimit

Macro Definition Documentation

DAMAGE_AIM

#define DAMAGE_AIM   2

Definition at line 354 of file server.h.

Referenced by VM_SV_aim().

DAMAGE_NO

#define DAMAGE_NO   0

Definition at line 352 of file server.h.

DAMAGE_YES

#define DAMAGE_YES   1

Definition at line 353 of file server.h.

DEAD_DEAD

#define DEAD_DEAD   2

Definition at line 350 of file server.h.

DEAD_DYING

#define DEAD_DYING   1

Definition at line 349 of file server.h.

DEAD_NO

#define DEAD_NO   0

Definition at line 348 of file server.h.

FL_CLIENT

#define FL_CLIENT   8

Definition at line 360 of file server.h.

FL_CONVEYOR

#define FL_CONVEYOR   4

Definition at line 359 of file server.h.

FL_FLY

#define FL_FLY   1

Definition at line 357 of file server.h.

Referenced by CL_movestep(), SV_movestep(), SV_Physics_Step(), VM_CL_walkmove(), VM_SV_MoveToGoal(), and VM_SV_walkmove().

FL_GODMODE

#define FL_GODMODE   64

Definition at line 363 of file server.h.

Referenced by SV_DisableCheats_c(), and SV_God_f().

FL_INWATER

#define FL_INWATER   16

Definition at line 361 of file server.h.

FL_ITEM

#define FL_ITEM   256

Definition at line 365 of file server.h.

Referenced by SV_LinkEdict().

FL_JUMPRELEASED

#define FL_JUMPRELEASED   4096

for jump debouncing

Definition at line 369 of file server.h.

FL_MONSTER

#define FL_MONSTER   32

movement is smoothed on the client side by step based interpolation

Definition at line 362 of file server.h.

Referenced by CL_GenericHitSuperContentsMask(), CL_TraceBox(), CL_TraceLine(), CL_TracePoint(), SV_GenericHitSuperContentsMask(), SV_PrepareEntityForSending(), SV_TraceBox(), SV_TraceLine(), and SV_TracePoint().

FL_NOTARGET

#define FL_NOTARGET   128

Definition at line 364 of file server.h.

Referenced by SV_DisableCheats_c(), SV_Notarget_f(), and VM_SV_newcheckclient().

FL_ONGROUND

#define FL_ONGROUND   512

Definition at line 366 of file server.h.

Referenced by SV_FlyMove(), SV_Physics_Step(), SV_Physics_Toss(), SV_PlayerPhysics(), SV_PushEntity(), SV_PushMove(), SV_SetIdealPitch(), SV_WalkMove(), SV_WriteClientdataToMessage(), VM_CL_droptofloor(), VM_CL_walkmove(), VM_SV_droptofloor(), VM_SV_MoveToGoal(), and VM_SV_walkmove().

FL_PARTIALGROUND

#define FL_PARTIALGROUND   1024

not all corners are valid

Definition at line 367 of file server.h.

Referenced by CL_movestep(), SV_FixCheckBottom(), and SV_movestep().

FL_SWIM

#define FL_SWIM   2

Definition at line 358 of file server.h.

Referenced by CL_movestep(), SV_movestep(), SV_Physics_Step(), VM_CL_walkmove(), VM_SV_MoveToGoal(), and VM_SV_walkmove().

FL_WATERJUMP

#define FL_WATERJUMP   2048

player jumping out of water

Definition at line 368 of file server.h.

Referenced by SV_FlyMove(), SV_PlayerPhysics(), and SV_WalkMove().

MAX_CONNECTFLOODADDRESSES

#define MAX_CONNECTFLOODADDRESSES   16

Definition at line 54 of file server.h.

MAX_GETSTATUSFLOODADDRESSES

#define MAX_GETSTATUSFLOODADDRESSES   128

Definition at line 55 of file server.h.

MOVETYPE_ANGLECLIP

#define MOVETYPE_ANGLECLIP   2

Definition at line 314 of file server.h.

MOVETYPE_ANGLENOCLIP

#define MOVETYPE_ANGLENOCLIP   1

Definition at line 313 of file server.h.

MOVETYPE_BOUNCE

#define MOVETYPE_BOUNCE   10

Definition at line 322 of file server.h.

Referenced by SV_Physics_ClientEntity(), SV_Physics_ClientEntity_NoThink(), SV_Physics_Entity(), and SV_Physics_Toss().

MOVETYPE_BOUNCEMISSILE

#define MOVETYPE_BOUNCEMISSILE   11

bounce w/o gravity

Definition at line 323 of file server.h.

Referenced by SV_Physics_ClientEntity(), SV_Physics_ClientEntity_NoThink(), SV_Physics_Entity(), and SV_Physics_Toss().

MOVETYPE_FAKEPUSH

#define MOVETYPE_FAKEPUSH   13

tenebrae's push that doesn't push

Definition at line 325 of file server.h.

Referenced by SV_Physics_ClientEntity(), SV_Physics_ClientEntity_NoThink(), SV_Physics_Entity(), and SV_PushMove().

MOVETYPE_FLY

#define MOVETYPE_FLY   5

Definition at line 317 of file server.h.

Referenced by SV_DisableCheats_c(), SV_Fly_f(), SV_Physics_ClientEntity(), SV_Physics_ClientEntity_NoThink(), SV_Physics_Entity(), SV_Physics_Toss(), and SV_WalkMove().

MOVETYPE_FLY_WORLDONLY

#define MOVETYPE_FLY_WORLDONLY   33

like MOVETYPE_FLY, but uses MOVE_WORLDONLY for all its traces; objects of this movetype better be SOLID_NOT or SOLID_TRIGGER please, or else...

Definition at line 327 of file server.h.

Referenced by PHYS_TestEntityPosition(), SV_Physics_ClientEntity(), SV_Physics_ClientEntity_NoThink(), SV_Physics_Entity(), SV_PushEntity(), SV_PushMove(), and SV_WalkMove().

MOVETYPE_FLYMISSILE

#define MOVETYPE_FLYMISSILE   9

extra size to monsters

Definition at line 321 of file server.h.

Referenced by SV_Physics_ClientEntity(), SV_Physics_ClientEntity_NoThink(), SV_Physics_Entity(), SV_PushEntity(), and SV_WalkMove().

MOVETYPE_FOLLOW

#define MOVETYPE_FOLLOW   12

track movement of aiment

Definition at line 324 of file server.h.

Referenced by SV_Physics_ClientEntity(), SV_Physics_ClientEntity_NoThink(), SV_Physics_Entity(), and SV_PushMove().

MOVETYPE_NOCLIP

#define MOVETYPE_NOCLIP   8

Definition at line 320 of file server.h.

Referenced by SV_AirMove(), SV_DisableCheats_c(), SV_Noclip_f(), SV_Physics_ClientEntity(), SV_Physics_ClientEntity_NoThink(), SV_Physics_Entity(), SV_PlayerPhysics(), and SV_PushMove().

MOVETYPE_NONE

#define MOVETYPE_NONE   0

never moves

Definition at line 312 of file server.h.

Referenced by SV_Physics_ClientEntity(), SV_Physics_ClientEntity_NoThink(), SV_Physics_Entity(), SV_PlayerPhysics(), and SV_PushMove().

MOVETYPE_PHYSICS

#define MOVETYPE_PHYSICS   32

indicates this object is physics controlled

Definition at line 326 of file server.h.

Referenced by SV_LinkEdict(), SV_Physics_ClientEntity(), SV_Physics_ClientEntity_NoThink(), SV_Physics_Entity(), SV_PushMove(), VM_physics_addforce(), VM_physics_addtorque(), and VM_physics_enable().

MOVETYPE_PUSH

#define MOVETYPE_PUSH   7

no clip to world, push and crush

Definition at line 319 of file server.h.

Referenced by SV_Physics_ClientEntity(), SV_Physics_ClientEntity_NoThink(), SV_Physics_Entity(), SV_PushMove(), and SV_SpawnServer().

MOVETYPE_STEP

#define MOVETYPE_STEP   4

gravity, special edge handling, special step based client side interpolation

Definition at line 316 of file server.h.

Referenced by SV_Physics_ClientEntity(), SV_Physics_ClientEntity_NoThink(), SV_Physics_Entity(), SV_PrepareEntityForSending(), and SVVM_count_edicts().

MOVETYPE_TOSS

#define MOVETYPE_TOSS   6

gravity

Definition at line 318 of file server.h.

Referenced by SV_Physics_ClientEntity(), SV_Physics_ClientEntity_NoThink(), SV_Physics_Entity(), and SV_Physics_Toss().

MOVETYPE_USER_FIRST

#define MOVETYPE_USER_FIRST   128

user defined movetypes

Definition at line 328 of file server.h.

Referenced by SV_Physics_ClientEntity(), SV_Physics_ClientEntity_NoThink(), and SV_Physics_Entity().

MOVETYPE_USER_LAST

#define MOVETYPE_USER_LAST   191

Definition at line 329 of file server.h.

Referenced by SV_Physics_ClientEntity(), SV_Physics_ClientEntity_NoThink(), and SV_Physics_Entity().

MOVETYPE_WALK

#define MOVETYPE_WALK   3

gravity

Definition at line 315 of file server.h.

Referenced by SV_AirMove(), SV_DisableCheats_c(), SV_ExecuteClientMoves(), SV_Fly_f(), SV_Noclip_f(), SV_Physics_ClientEntity(), SV_Physics_ClientEntity_NoThink(), SV_Physics_Entity(), SV_PushMove(), and SV_WalkMove().

NUM_CSQCENTITIES_PER_FRAME

#define NUM_CSQCENTITIES_PER_FRAME   256

Definition at line 171 of file server.h.

Referenced by EntityFrameCSQC_WriteFrame().

NUM_CSQCENTITYDB_FRAMES

#define NUM_CSQCENTITYDB_FRAMES   256

Definition at line 254 of file server.h.

Referenced by EntityFrameCSQC_AllocFrame(), EntityFrameCSQC_DeallocFrame(), EntityFrameCSQC_LostFrame(), and SV_SendServerinfo().

NUM_SPAWN_PARMS

#define NUM_SPAWN_PARMS   16

Definition at line 180 of file server.h.

Referenced by SV_ConnectClient(), SV_Loadgame_f(), SV_Savegame_to(), SV_SaveSpawnparms(), SV_Spawn_f(), SV_SpawnServer(), and VM_SV_setspawnparms().

SOLID_BBOX

#define SOLID_BBOX   2

touch on edge, block

Definition at line 334 of file server.h.

Referenced by CL_TraceBox(), CL_TraceLine(), CL_TracePoint(), R_DrawEntityBBoxes_Callback(), SV_PushMove(), SV_TraceBox(), SV_TraceLine(), and SV_TracePoint().

SOLID_BSP

#define SOLID_BSP   4

bsp clip, touch on edge, block

Definition at line 336 of file server.h.

Referenced by CL_Cache_TraceLineSurfaces(), CL_LinkEdict(), CL_TraceBox(), CL_TraceLine(), CL_TracePoint(), CL_VM_Init(), R_DrawEntityBBoxes_Callback(), SV_CanSeeBox(), SV_LinkEdict(), SV_Physics_Toss(), SV_PointSuperContents(), SV_PushMove(), SV_SpawnServer(), SV_TraceBox(), SV_TraceLine(), and SV_TracePoint().

SOLID_CORPSE

#define SOLID_CORPSE   5

same as SOLID_BBOX, except it behaves as SOLID_NOT against SOLID_SLIDEBOX objects (players/monsters)

Definition at line 338 of file server.h.

Referenced by CL_GenericHitSuperContentsMask(), CL_TraceBox(), CL_TraceLine(), CL_TracePoint(), R_DrawEntityBBoxes_Callback(), SV_GenericHitSuperContentsMask(), SV_PushMove(), SV_TraceBox(), SV_TraceLine(), and SV_TracePoint().

SOLID_NOT

#define SOLID_NOT   0

no interaction with other objects

Definition at line 332 of file server.h.

Referenced by R_DrawEntityBBoxes_Callback(), SV_Impact(), SV_LinkEdict_TouchAreaGrid(), SV_PushEntity(), SV_PushMove(), SV_WalkMove(), VM_CL_findradius(), VM_SV_findradius(), and World_LinkEdict().

SOLID_PHYSICS_BOX

#define SOLID_PHYSICS_BOX   32

physics object (mins, maxs, mass, origin, axis_forward, axis_left, axis_up, velocity, spinvelocity)

Definition at line 341 of file server.h.

SOLID_PHYSICS_CAPSULE

#define SOLID_PHYSICS_CAPSULE   34

physics object (mins, maxs, mass, origin, axis_forward, axis_left, axis_up, velocity, spinvelocity)

Definition at line 343 of file server.h.

SOLID_PHYSICS_CYLINDER

#define SOLID_PHYSICS_CYLINDER   36

physics object (mins, maxs, mass, origin, axis_forward, axis_left, axis_up, velocity, spinvelocity)

Definition at line 345 of file server.h.

SOLID_PHYSICS_SPHERE

#define SOLID_PHYSICS_SPHERE   33

physics object (mins, maxs, mass, origin, axis_forward, axis_left, axis_up, velocity, spinvelocity)

Definition at line 342 of file server.h.

SOLID_PHYSICS_TRIMESH

#define SOLID_PHYSICS_TRIMESH   35

physics object (mins, maxs, mass, origin, axis_forward, axis_left, axis_up, velocity, spinvelocity)

Definition at line 344 of file server.h.

SOLID_SLIDEBOX

#define SOLID_SLIDEBOX   3

touch on edge, but not an onground

Definition at line 335 of file server.h.

Referenced by CL_GenericHitSuperContentsMask(), R_DrawEntityBBoxes_Callback(), SV_GenericHitSuperContentsMask(), and SV_PushMove().

SOLID_TRIGGER

#define SOLID_TRIGGER   1

touch on edge, but not blocking

Definition at line 333 of file server.h.

Referenced by CL_GenericHitSuperContentsMask(), R_DrawEntityBBoxes_Callback(), SV_FlyMove(), SV_GenericHitSuperContentsMask(), SV_LinkEdict_TouchAreaGrid(), SV_PushEntity(), SV_PushMove(), and SV_WalkMove().

SPAWNFLAG_NOT_DEATHMATCH

#define SPAWNFLAG_NOT_DEATHMATCH   2048

Definition at line 374 of file server.h.

Referenced by SVVM_load_edict().

SPAWNFLAG_NOT_EASY

#define SPAWNFLAG_NOT_EASY   256

Definition at line 371 of file server.h.

Referenced by SVVM_load_edict().

SPAWNFLAG_NOT_HARD

#define SPAWNFLAG_NOT_HARD   1024

Definition at line 373 of file server.h.

Referenced by SVVM_load_edict().

SPAWNFLAG_NOT_MEDIUM

#define SPAWNFLAG_NOT_MEDIUM   512

Definition at line 372 of file server.h.

Referenced by SVVM_load_edict().

SV_LockThreadMutex

#define SV_LockThreadMutex

(

)

Value:

(void)(svs.threaded ? Thread_LockMutex(svs.threadmutex) : 0)

Definition at line 606 of file server.h.

Referenced by Cbuf_Frame(), Crypto_KeyGen_f(), Crypto_KeyGen_Finished(), NetConn_OpenClientPorts(), NetConn_OpenServerPorts(), SV_Shutdown(), and SV_ThreadFunc().

SV_UnlockThreadMutex

#define SV_UnlockThreadMutex

(

)

Value:

(void)(svs.threaded ? Thread_UnlockMutex(svs.threadmutex) : 0)

Definition at line 607 of file server.h.

Referenced by Cbuf_Frame(), Crypto_KeyGen_f(), Crypto_KeyGen_Finished(), NetConn_OpenClientPorts(), NetConn_OpenServerPorts(), SV_Shutdown(), and SV_ThreadFunc().

Enumeration Type Documentation

server_state_t

enum server_state_t

Enumerator
ss_loading
ss_active

Definition at line 52 of file server.h.

{ss_loading, ss_active} server_state_t;

Function Documentation

SV_AddCameraEyes()

void SV_AddCameraEyes

(

void

)

Definition at line 1063 of file sv_send.c.

{
}

Referenced by SV_WriteEntitiesToClient().

SV_AddUpdates()

void SV_AddUpdates

(

void

)

SV_ApplyClientMove()

void SV_ApplyClientMove

(

void

)

Definition at line 893 of file sv_user.c.

{
    prvm_prog_t *prog = SVVM_prog;
    usercmd_t *move = &host_client->cmd;
    int j, movementloss, packetloss;
 
    if (!move->receivetime)
        return;
 
    // note: a move can be applied multiple times if the client packets are
    // not coming as often as the physics is executed, and the move must be
    // applied before running qc each time because the id1 qc had a bug where
    // it clears self.button2 in PlayerJump, causing pogostick behavior if
    // moves are not applied every time before calling qc
    move->applied = true;
 
    // set the edict fields
    PRVM_serveredictfloat(host_client->edict, button0) = move->buttons & 1;
    PRVM_serveredictfloat(host_client->edict, button2) = (move->buttons & 2)>>1;
    if (move->impulse)
        PRVM_serveredictfloat(host_client->edict, impulse) = move->impulse;
    // only send the impulse to qc once
    move->impulse = 0;
 
    movementloss = packetloss = 0;
    if(host_client->netconnection)
    {
        for (j = 0;j < NETGRAPH_PACKETS;j++)
            if (host_client->netconnection->incoming_netgraph[j].unreliablebytes == NETGRAPH_LOSTPACKET)
                packetloss++;
        for (j = 0;j < NETGRAPH_PACKETS;j++)
            if (host_client->movement_count[j] < 0)
                movementloss++;
    }
 
    VectorCopy(move->viewangles, PRVM_serveredictvector(host_client->edict, v_angle));
    PRVM_serveredictfloat(host_client->edict, button3) = ((move->buttons >> 2) & 1);
    PRVM_serveredictfloat(host_client->edict, button4) = ((move->buttons >> 3) & 1);
    PRVM_serveredictfloat(host_client->edict, button5) = ((move->buttons >> 4) & 1);
    PRVM_serveredictfloat(host_client->edict, button6) = ((move->buttons >> 5) & 1);
    PRVM_serveredictfloat(host_client->edict, button7) = ((move->buttons >> 6) & 1);
    PRVM_serveredictfloat(host_client->edict, button8) = ((move->buttons >> 7) & 1);
    PRVM_serveredictfloat(host_client->edict, button9) = ((move->buttons >> 11) & 1);
    PRVM_serveredictfloat(host_client->edict, button10) = ((move->buttons >> 12) & 1);
    PRVM_serveredictfloat(host_client->edict, button11) = ((move->buttons >> 13) & 1);
    PRVM_serveredictfloat(host_client->edict, button12) = ((move->buttons >> 14) & 1);
    PRVM_serveredictfloat(host_client->edict, button13) = ((move->buttons >> 15) & 1);
    PRVM_serveredictfloat(host_client->edict, button14) = ((move->buttons >> 16) & 1);
    PRVM_serveredictfloat(host_client->edict, button15) = ((move->buttons >> 17) & 1);
    PRVM_serveredictfloat(host_client->edict, button16) = ((move->buttons >> 18) & 1);
    PRVM_serveredictfloat(host_client->edict, buttonuse) = ((move->buttons >> 8) & 1);
    PRVM_serveredictfloat(host_client->edict, buttonchat) = ((move->buttons >> 9) & 1);
    PRVM_serveredictfloat(host_client->edict, cursor_active) = ((move->buttons >> 10) & 1);
    VectorSet(PRVM_serveredictvector(host_client->edict, movement), move->forwardmove, move->sidemove, move->upmove);
    VectorCopy(move->cursor_screen, PRVM_serveredictvector(host_client->edict, cursor_screen));
    VectorCopy(move->cursor_start, PRVM_serveredictvector(host_client->edict, cursor_trace_start));
    VectorCopy(move->cursor_impact, PRVM_serveredictvector(host_client->edict, cursor_trace_endpos));
    PRVM_serveredictedict(host_client->edict, cursor_trace_ent) = PRVM_EDICT_TO_PROG(PRVM_EDICT_NUM(move->cursor_entitynumber));
    PRVM_serveredictfloat(host_client->edict, ping) = host_client->ping * 1000.0;
    PRVM_serveredictfloat(host_client->edict, ping_packetloss) = packetloss / (float) NETGRAPH_PACKETS;
    PRVM_serveredictfloat(host_client->edict, ping_movementloss) = movementloss / (float) NETGRAPH_PACKETS;
}

References usercmd_t::applied, button0, button10, button11, button12, button13, button14, button15, button16, button2, button3, button4, button5, button6, button7, button8, button9, buttonchat, usercmd_t::buttons, buttonuse, client_t::cmd, cursor_active, usercmd_t::cursor_entitynumber, usercmd_t::cursor_impact, cursor_screen, usercmd_t::cursor_screen, usercmd_t::cursor_start, cursor_trace_endpos, cursor_trace_ent, cursor_trace_start, client_t::edict, float, usercmd_t::forwardmove, host_client, impulse, usercmd_t::impulse, netconn_t::incoming_netgraph, movement, client_t::movement_count, client_t::netconnection, NETGRAPH_LOSTPACKET, NETGRAPH_PACKETS, client_t::ping, ping, ping_movementloss, ping_packetloss, PRVM_EDICT_NUM, PRVM_EDICT_TO_PROG, PRVM_serveredictedict, PRVM_serveredictfloat, PRVM_serveredictvector, usercmd_t::receivetime, usercmd_t::sidemove, SVVM_prog, netgraphitem_t::unreliablebytes, usercmd_t::upmove, v_angle, VectorCopy, VectorSet, and usercmd_t::viewangles.

Referenced by SV_PlayerPhysics().

SV_Begin_f()

void SV_Begin_f

(

cmd_state_t *

cmd

)

Definition at line 204 of file sv_user.c.

{
    if (!host_client->spawned)
    {
        Con_Print("Begin not valid -- not yet spawned\n");
        return;
    }
    if (host_client->begun)
    {
        Con_Print("Begin not valid -- already begun\n");
        return;
    }
    host_client->begun = true;
 
    // LadyHavoc: note: this code also exists in SV_DropClient
    if (sv.loadgame)
    {
        int i;
        for (i = 0;i < svs.maxclients;i++)
            if (svs.clients[i].active && !svs.clients[i].spawned)
                break;
        if (i == svs.maxclients)
        {
            Con_Printf("Loaded game, everyone rejoined - unpausing\n");
            sv.paused = sv.loadgame = false; // we're basically done with loading now
        }
    }
}

References client_t::begun, server_static_t::clients, Con_Print(), Con_Printf(), host_client, i, server_t::loadgame, server_static_t::maxclients, server_t::paused, client_t::spawned, sv, and svs.

Referenced by SV_InitOperatorCommands().

SV_BroadcastPrint()

void SV_BroadcastPrint

(

const char *

msg

)

Definition at line 91 of file sv_send.c.

{
    int i;
    client_t *client;
 
    for (i = 0, client = svs.clients;i < svs.maxclients;i++, client++)
    {
        if (client->active && client->netconnection)
        {
            MSG_WriteByte(&client->netconnection->message, svc_print);
            MSG_WriteString(&client->netconnection->message, msg);
        }
    }
 
    if (sv_echobprint.integer && !host_isclient.integer)
        Con_Print(msg);
}

References client_t::active, server_static_t::clients, Con_Print(), host_isclient, i, cvar_t::integer, server_static_t::maxclients, netconn_t::message, MSG_WriteByte(), MSG_WriteString(), client_t::netconnection, sv_echobprint, svc_print, and svs.

Referenced by SV_BroadcastPrintf(), and VM_bprint().

SV_BroadcastPrintf()

void SV_BroadcastPrintf	(	const char *	fmt,
			... )

Definition at line 116 of file sv_send.c.

{
    va_list argptr;
    char msg[MAX_INPUTLINE];
 
    va_start(argptr,fmt);
    dpvsnprintf(msg,sizeof(msg),fmt,argptr);
    va_end(argptr);
 
    SV_BroadcastPrint(msg);
}

References dpvsnprintf(), MAX_INPUTLINE, and SV_BroadcastPrint().

Referenced by Cvar_SetQuick_Internal(), SV_DropClient(), SV_Frame(), SV_Name(), and SV_Pause_f().

SV_CanSeeBox()

qbool SV_CanSeeBox	(	int	numsamples,
		vec_t	eyejitter,
		vec_t	enlarge,
		vec_t	entboxexpand,
		vec3_t	eye,
		vec3_t	entboxmins,
		vec3_t	entboxmaxs )

Definition at line 723 of file sv_send.c.

{
    prvm_prog_t *prog = SVVM_prog;
    float pitchsign;
    float alpha;
    float starttransformed[3], endtransformed[3];
    float boxminstransformed[3], boxmaxstransformed[3];
    float localboxcenter[3], localboxextents[3], localboxmins[3], localboxmaxs[3];
    int blocked = 0;
    int traceindex;
    int originalnumtouchedicts;
    int numtouchedicts = 0;
    int touchindex;
    matrix4x4_t matrix, imatrix;
    model_t *model;
    prvm_edict_t *touch;
    static prvm_edict_t *touchedicts[MAX_EDICTS];
    vec3_t eyemins, eyemaxs, start;
    vec3_t boxmins, boxmaxs;
    vec3_t clipboxmins, clipboxmaxs;
    vec3_t endpoints[MAX_LINEOFSIGHTTRACES];
 
    numtraces = min(numtraces, MAX_LINEOFSIGHTTRACES);
 
    // jitter the eye location within this box
    eyemins[0] = eye[0] - eyejitter;
    eyemaxs[0] = eye[0] + eyejitter;
    eyemins[1] = eye[1] - eyejitter;
    eyemaxs[1] = eye[1] + eyejitter;
    eyemins[2] = eye[2] - eyejitter;
    eyemaxs[2] = eye[2] + eyejitter;
    // expand the box a little
    boxmins[0] = (enlarge+1) * entboxmins[0] - enlarge * entboxmaxs[0] - entboxexpand;
    boxmaxs[0] = (enlarge+1) * entboxmaxs[0] - enlarge * entboxmins[0] + entboxexpand;
    boxmins[1] = (enlarge+1) * entboxmins[1] - enlarge * entboxmaxs[1] - entboxexpand;
    boxmaxs[1] = (enlarge+1) * entboxmaxs[1] - enlarge * entboxmins[1] + entboxexpand;
    boxmins[2] = (enlarge+1) * entboxmins[2] - enlarge * entboxmaxs[2] - entboxexpand;
    boxmaxs[2] = (enlarge+1) * entboxmaxs[2] - enlarge * entboxmins[2] + entboxexpand;
 
    VectorMAM(0.5f, boxmins, 0.5f, boxmaxs, endpoints[0]);
    for (traceindex = 1;traceindex < numtraces;traceindex++)
        VectorSet(endpoints[traceindex], lhrandom(boxmins[0], boxmaxs[0]), lhrandom(boxmins[1], boxmaxs[1]), lhrandom(boxmins[2], boxmaxs[2]));
 
    // calculate sweep box for the entire swarm of traces
    VectorCopy(eyemins, clipboxmins);
    VectorCopy(eyemaxs, clipboxmaxs);
    for (traceindex = 0;traceindex < numtraces;traceindex++)
    {
        clipboxmins[0] = min(clipboxmins[0], endpoints[traceindex][0]);
        clipboxmins[1] = min(clipboxmins[1], endpoints[traceindex][1]);
        clipboxmins[2] = min(clipboxmins[2], endpoints[traceindex][2]);
        clipboxmaxs[0] = max(clipboxmaxs[0], endpoints[traceindex][0]);
        clipboxmaxs[1] = max(clipboxmaxs[1], endpoints[traceindex][1]);
        clipboxmaxs[2] = max(clipboxmaxs[2], endpoints[traceindex][2]);
    }
 
    // get the list of entities in the sweep box
    if (sv_cullentities_trace_entityocclusion.integer)
        numtouchedicts = SV_EntitiesInBox(clipboxmins, clipboxmaxs, MAX_EDICTS, touchedicts);
    if (numtouchedicts > MAX_EDICTS)
    {
        // this never happens
        Con_Printf("SV_EntitiesInBox returned %i edicts, max was %i\n", numtouchedicts, MAX_EDICTS);
        numtouchedicts = MAX_EDICTS;
    }
    // iterate the entities found in the sweep box and filter them
    originalnumtouchedicts = numtouchedicts;
    numtouchedicts = 0;
    for (touchindex = 0;touchindex < originalnumtouchedicts;touchindex++)
    {
        touch = touchedicts[touchindex];
        if (PRVM_serveredictfloat(touch, solid) != SOLID_BSP)
            continue;
        model = SV_GetModelFromEdict(touch);
        if (!model || !model->brush.TraceLineOfSight)
            continue;
        // skip obviously transparent entities
        alpha = PRVM_serveredictfloat(touch, alpha);
        if (alpha && alpha < 1)
            continue;
        if ((int)PRVM_serveredictfloat(touch, effects) & EF_ADDITIVE)
            continue;
        touchedicts[numtouchedicts++] = touch;
    }
 
    // now that we have a filtered list of "interesting" entities, fire each
    // ray against all of them, this gives us an early-out case when something
    // is visible (which it often is)
 
    for (traceindex = 0;traceindex < numtraces;traceindex++)
    {
        VectorSet(start, lhrandom(eyemins[0], eyemaxs[0]), lhrandom(eyemins[1], eyemaxs[1]), lhrandom(eyemins[2], eyemaxs[2]));
        // check world occlusion
        if (sv.worldmodel && sv.worldmodel->brush.TraceLineOfSight)
            if (!sv.worldmodel->brush.TraceLineOfSight(sv.worldmodel, start, endpoints[traceindex], boxmins, boxmaxs))
                continue;
        for (touchindex = 0;touchindex < numtouchedicts;touchindex++)
        {
            touch = touchedicts[touchindex];
            model = SV_GetModelFromEdict(touch);
            if(model && model->brush.TraceLineOfSight)
            {
                // get the entity matrix
                pitchsign = SV_GetPitchSign(prog, touch);
                Matrix4x4_CreateFromQuakeEntity(&matrix, PRVM_serveredictvector(touch, origin)[0], PRVM_serveredictvector(touch, origin)[1], PRVM_serveredictvector(touch, origin)[2], pitchsign * PRVM_serveredictvector(touch, angles)[0], PRVM_serveredictvector(touch, angles)[1], PRVM_serveredictvector(touch, angles)[2], 1);
                Matrix4x4_Invert_Simple(&imatrix, &matrix);
                // see if the ray hits this entity
                Matrix4x4_Transform(&imatrix, start, starttransformed);
                Matrix4x4_Transform(&imatrix, endpoints[traceindex], endtransformed);
                Matrix4x4_Transform(&imatrix, boxmins, boxminstransformed);
                Matrix4x4_Transform(&imatrix, boxmaxs, boxmaxstransformed);
                // transform the AABB to local space
                VectorMAM(0.5f, boxminstransformed, 0.5f, boxmaxstransformed, localboxcenter);
                localboxextents[0] = fabs(boxmaxstransformed[0] - localboxcenter[0]);
                localboxextents[1] = fabs(boxmaxstransformed[1] - localboxcenter[1]);
                localboxextents[2] = fabs(boxmaxstransformed[2] - localboxcenter[2]);
                localboxmins[0] = localboxcenter[0] - localboxextents[0];
                localboxmins[1] = localboxcenter[1] - localboxextents[1];
                localboxmins[2] = localboxcenter[2] - localboxextents[2];
                localboxmaxs[0] = localboxcenter[0] + localboxextents[0];
                localboxmaxs[1] = localboxcenter[1] + localboxextents[1];
                localboxmaxs[2] = localboxcenter[2] + localboxextents[2];
                if (!model->brush.TraceLineOfSight(model, starttransformed, endtransformed, localboxmins, localboxmaxs))
                {
                    blocked++;
                    break;
                }
            }
        }
        // check if the ray was blocked
        if (touchindex < numtouchedicts)
            continue;
        // return if the ray was not blocked
        return true;
    }
 
    // no rays survived
    return false;
}

References alpha, angles, Con_Printf(), EF_ADDITIVE, effects, fabs(), cvar_t::integer, lhrandom, Matrix4x4_CreateFromQuakeEntity(), Matrix4x4_Invert_Simple(), Matrix4x4_Transform(), max, MAX_EDICTS, MAX_LINEOFSIGHTTRACES, min, model, origin, PRVM_serveredictfloat, PRVM_serveredictvector, solid, SOLID_BSP, sv, sv_cullentities_trace_entityocclusion, SV_EntitiesInBox(), SV_GetModelFromEdict(), SV_GetPitchSign(), SVVM_prog, VectorCopy, VectorMAM, VectorSet, and server_t::worldmodel.

Referenced by SV_MarkWriteEntityStateToClient(), and SV_WriteEntitiesToClient().

SV_CheckBottom()

qbool SV_CheckBottom

(

prvm_edict_t *

ent

)

Definition at line 36 of file sv_move.c.

{
    prvm_prog_t *prog = SVVM_prog;
    vec3_t  mins, maxs, start, stop;
    trace_t trace;
    int     x, y;
    float   mid, bottom;
 
    VectorAdd (PRVM_serveredictvector(ent, origin), PRVM_serveredictvector(ent, mins), mins);
    VectorAdd (PRVM_serveredictvector(ent, origin), PRVM_serveredictvector(ent, maxs), maxs);
 
// if all of the points under the corners are solid world, don't bother
// with the tougher checks
// the corners must be within 16 of the midpoint
    start[2] = mins[2] - 1;
    for (x=0 ; x<=1 ; x++)
        for (y=0 ; y<=1 ; y++)
        {
            start[0] = x ? maxs[0] : mins[0];
            start[1] = y ? maxs[1] : mins[1];
            if (!(SV_PointSuperContents(start) & (SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY)))
                goto realcheck;
        }
 
    c_yes++;
    return true;        // we got out easy
 
realcheck:
    c_no++;
//
// check it for real...
//
    start[2] = mins[2];
 
// the midpoint must be within 16 of the bottom
    start[0] = stop[0] = (mins[0] + maxs[0])*0.5;
    start[1] = stop[1] = (mins[1] + maxs[1])*0.5;
    stop[2] = start[2] - 2*sv_stepheight.value;
    trace = SV_TraceLine(start, stop, MOVE_NOMONSTERS, ent, SV_GenericHitSuperContentsMask(ent), 0, 0, collision_extendmovelength.value);
 
    if (trace.fraction == 1.0)
        return false;
    mid = bottom = trace.endpos[2];
 
// the corners must be within 16 of the midpoint
    for (x=0 ; x<=1 ; x++)
        for (y=0 ; y<=1 ; y++)
        {
            start[0] = stop[0] = x ? maxs[0] : mins[0];
            start[1] = stop[1] = y ? maxs[1] : mins[1];
 
            trace = SV_TraceLine(start, stop, MOVE_NOMONSTERS, ent, SV_GenericHitSuperContentsMask(ent), 0, 0, collision_extendmovelength.value);
 
            if (trace.fraction != 1.0 && trace.endpos[2] > bottom)
                bottom = trace.endpos[2];
            if (trace.fraction == 1.0 || mid - trace.endpos[2] > sv_stepheight.value)
                return false;
        }
 
    c_yes++;
    return true;
}

References c_no, c_yes, collision_extendmovelength, trace_t::endpos, trace_t::fraction, maxs, mins, MOVE_NOMONSTERS, origin, PRVM_serveredictvector, SUPERCONTENTS_BODY, SUPERCONTENTS_SOLID, SV_GenericHitSuperContentsMask(), SV_PointSuperContents(), sv_stepheight, SV_TraceLine(), SVVM_prog, cvar_t::value, VectorAdd, x, and y.

Referenced by SV_movestep(), SV_NewChaseDir(), and VM_SV_checkbottom().

SV_CheckVelocity()

void SV_CheckVelocity

(

prvm_edict_t *

ent

)

Definition at line 965 of file sv_phys.c.

{
    prvm_prog_t *prog = SVVM_prog;
    int i;
    float wishspeed;
 
//
// bound velocity
//
    for (i=0 ; i<3 ; i++)
    {
        if (isnan(PRVM_serveredictvector(ent, velocity)[i]))
        {
            Con_Printf("Got a NaN velocity on entity #%i (%s)\n", PRVM_NUM_FOR_EDICT(ent), PRVM_GetString(prog, PRVM_serveredictstring(ent, classname)));
            PRVM_serveredictvector(ent, velocity)[i] = 0;
        }
        if (isnan(PRVM_serveredictvector(ent, origin)[i]))
        {
            Con_Printf("Got a NaN origin on entity #%i (%s)\n", PRVM_NUM_FOR_EDICT(ent), PRVM_GetString(prog, PRVM_serveredictstring(ent, classname)));
            PRVM_serveredictvector(ent, origin)[i] = 0;
        }
    }
 
    // LadyHavoc: a hack to ensure that the (rather silly) id1 quakec
    // player_run/player_stand1 does not horribly malfunction if the
    // velocity becomes a denormalized float
    if (VectorLength2(PRVM_serveredictvector(ent, velocity)) < 0.0000001)
        VectorClear(PRVM_serveredictvector(ent, velocity));
 
    // LadyHavoc: max velocity fix, inspired by Maddes's source fixes, but this is faster
    wishspeed = DotProduct(PRVM_serveredictvector(ent, velocity), PRVM_serveredictvector(ent, velocity));
    if (wishspeed > sv_maxvelocity.value * sv_maxvelocity.value)
    {
        wishspeed = sv_maxvelocity.value / sqrt(wishspeed);
        PRVM_serveredictvector(ent, velocity)[0] *= wishspeed;
        PRVM_serveredictvector(ent, velocity)[1] *= wishspeed;
        PRVM_serveredictvector(ent, velocity)[2] *= wishspeed;
    }
}

References classname, Con_Printf(), DotProduct, i, origin, PRVM_GetString(), PRVM_NUM_FOR_EDICT, PRVM_serveredictstring, PRVM_serveredictvector, sqrt(), sv_maxvelocity, SVVM_prog, cvar_t::value, VectorClear, VectorLength2, velocity, and wishspeed.

Referenced by SV_Physics_ClientEntity(), SV_Physics_ClientEntity_PostThink(), SV_Physics_ClientEntity_PreThink(), SV_Physics_ClientMove(), SV_Physics_Step(), SV_Physics_Toss(), SV_PlayerPhysics(), SV_Trace_Toss(), and SV_WalkMove().

SV_ClientCommands()

void SV_ClientCommands	(	const char *	fmt,
			... )

Definition at line 135 of file sv_send.c.

{
    va_list argptr;
    char string[MAX_INPUTLINE];
 
    if (!host_client->netconnection)
        return;
 
    va_start(argptr,fmt);
    dpvsnprintf(string, sizeof(string), fmt, argptr);
    va_end(argptr);
 
    MSG_WriteByte(&host_client->netconnection->message, svc_stufftext);
    MSG_WriteString(&host_client->netconnection->message, string);
}

References dpvsnprintf(), host_client, MAX_INPUTLINE, netconn_t::message, MSG_WriteByte(), MSG_WriteString(), client_t::netconnection, and svc_stufftext.

Referenced by Curl_SendRequirements(), SV_Download_f(), SV_ReadClientMessage(), SV_SendCvar_f(), and VM_SV_stuffcmd().

SV_ClientPrint()

void SV_ClientPrint

(

const char *

msg

)

Definition at line 55 of file sv_send.c.

{
    if (host_client->netconnection)
    {
        MSG_WriteByte(&host_client->netconnection->message, svc_print);
        MSG_WriteString(&host_client->netconnection->message, msg);
    }
}

References host_client, netconn_t::message, MSG_WriteByte(), MSG_WriteString(), client_t::netconnection, and svc_print.

Referenced by SV_ClientPrintf(), SV_Fly_f(), SV_God_f(), SV_Kill_f(), SV_Noclip_f(), SV_Notarget_f(), SV_Say(), and SV_Tell_f().

SV_ClientPrintf()

void SV_ClientPrintf	(	const char *	fmt,
			... )

Definition at line 72 of file sv_send.c.

{
    va_list argptr;
    char msg[MAX_INPUTLINE];
 
    va_start(argptr,fmt);
    dpvsnprintf(msg,sizeof(msg),fmt,argptr);
    va_end(argptr);
 
    SV_ClientPrint(msg);
}

References dpvsnprintf(), MAX_INPUTLINE, and SV_ClientPrint().

Referenced by Cmd_SV_Callback(), SV_Download_f(), SV_DropClient(), SV_Ent_Create_f(), SV_Ent_Remove_All_f(), SV_Ent_Remove_f(), SV_Name_f(), SV_Pause_f(), SV_Ping_f(), and SV_Status_f().

SV_ConnectClient()

void SV_ConnectClient	(	int	clientnum,
		netconn_t *	netconnection )

Definition at line 936 of file sv_main.c.

{
    prvm_prog_t *prog = SVVM_prog;
    client_t        *client;
    int             i;
 
    client = svs.clients + clientnum;
 
// set up the client_t
    if (sv.loadgame)
    {
        float backupparms[NUM_SPAWN_PARMS];
        memcpy(backupparms, client->spawn_parms, sizeof(backupparms));
        memset(client, 0, sizeof(*client));
        memcpy(client->spawn_parms, backupparms, sizeof(backupparms));
    }
    else
        memset(client, 0, sizeof(*client));
    client->active = true;
    client->netconnection = netconnection;
 
    Con_DPrintf("Client %s connected\n", client->netconnection ? client->netconnection->address : "botclient");
 
    if(client->netconnection && client->netconnection->crypto.authenticated)
    {
        Con_Printf("%s connection to %s has been established: client is %s@%s%.*s, I am %.*s@%s%.*s\n",
                client->netconnection->crypto.use_aes ? "Encrypted" : "Authenticated",
                client->netconnection->address,
                client->netconnection->crypto.client_idfp[0] ? client->netconnection->crypto.client_idfp : "-",
                (client->netconnection->crypto.client_issigned || !client->netconnection->crypto.client_keyfp[0]) ? "" : "~",
                crypto_keyfp_recommended_length, client->netconnection->crypto.client_keyfp[0] ? client->netconnection->crypto.client_keyfp : "-",
                crypto_keyfp_recommended_length, client->netconnection->crypto.server_idfp[0] ? client->netconnection->crypto.server_idfp : "-",
                (client->netconnection->crypto.server_issigned || !client->netconnection->crypto.server_keyfp[0]) ? "" : "~",
                crypto_keyfp_recommended_length, client->netconnection->crypto.server_keyfp[0] ? client->netconnection->crypto.server_keyfp : "-"
                );
    }
 
    dp_strlcpy(client->name, "unconnected", sizeof(client->name));
    dp_strlcpy(client->old_name, "unconnected", sizeof(client->old_name));
    client->prespawned = false;
    client->spawned = false;
    client->begun = false;
    client->edict = PRVM_EDICT_NUM(clientnum+1);
    if (client->netconnection)
        client->netconnection->message.allowoverflow = true;        // we can catch it
    // prepare the unreliable message buffer
    client->unreliablemsg.data = client->unreliablemsg_data;
    client->unreliablemsg.maxsize = sizeof(client->unreliablemsg_data);
    // updated by receiving "rate" command from client, this is also the default if not using a DP client
    client->rate = 1000000000;
    client->connecttime = host.realtime;
 
    if (!sv.loadgame)
    {
        // call the progs to get default spawn parms for the new client
        // set self to world to intentionally cause errors with broken SetNewParms code in some mods
        PRVM_serverglobalfloat(time) = sv.time;
        PRVM_serverglobaledict(self) = 0;
        prog->ExecuteProgram(prog, PRVM_serverfunction(SetNewParms), "QC function SetNewParms is missing");
        for (i=0 ; i<NUM_SPAWN_PARMS ; i++)
            client->spawn_parms[i] = (&PRVM_serverglobalfloat(parm1))[i];
 
        // set up the entity for this client (including .colormap, .team, etc)
        PRVM_ED_ClearEdict(prog, client->edict);
    }
 
    // don't call SendServerinfo for a fresh botclient because its fields have
    // not been set up by the qc yet
    if (client->netconnection)
        SV_SendServerinfo (client);
    else
        client->prespawned = client->spawned = client->begun = true;
}

References client_t::active, netconn_t::address, sizebuf_t::allowoverflow, crypto_t::authenticated, client_t::begun, crypto_t::client_idfp, crypto_t::client_issigned, crypto_t::client_keyfp, server_static_t::clients, Con_DPrintf(), Con_Printf(), client_t::connecttime, netconn_t::crypto, crypto_keyfp_recommended_length, sizebuf_t::data, dp_strlcpy, client_t::edict, prvm_prog_t::ExecuteProgram, host, i, server_t::loadgame, sizebuf_t::maxsize, netconn_t::message, client_t::name, client_t::netconnection, NUM_SPAWN_PARMS, client_t::old_name, parm1, client_t::prespawned, PRVM_ED_ClearEdict(), PRVM_EDICT_NUM, PRVM_serverfunction, PRVM_serverglobaledict, PRVM_serverglobalfloat, client_t::rate, host_static_t::realtime, self, crypto_t::server_idfp, crypto_t::server_issigned, crypto_t::server_keyfp, client_t::spawn_parms, client_t::spawned, sv, SV_SendServerinfo(), svs, SVVM_prog, server_t::time, time, client_t::unreliablemsg, client_t::unreliablemsg_data, and crypto_t::use_aes.

Referenced by NetConn_ServerParsePacket(), and VM_SV_spawnclient().

SV_DropClient()

void SV_DropClient	(	qbool	leaving,
		const char *	reason,
			... )

Definition at line 1018 of file sv_main.c.

{
    prvm_prog_t *prog = SVVM_prog;
    int i;
 
    va_list argptr;
    char reason[512] = "";
 
    Con_Printf("Client \"%s\" dropped", host_client->name);
 
    if(fmt)
    {
        va_start(argptr, fmt);
        dpvsnprintf(reason, sizeof(reason), fmt, argptr);
        va_end(argptr);
 
        Con_Printf(" (%s)\n", reason);
    }
    else
    {
        Con_Printf(" \n");
    }
 
    SV_StopDemoRecording(host_client);
 
    // make sure edict is not corrupt (from a level change for example)
    host_client->edict = PRVM_EDICT_NUM(host_client - svs.clients + 1);
 
    if (host_client->netconnection)
    {
        // tell the client to be gone
        if (!leaving)
        {
            // LadyHavoc: no opportunity for resending, so use unreliable 3 times
            unsigned char bufdata[520]; // Disconnect reason string can be 512 characters
            sizebuf_t buf;
            memset(&buf, 0, sizeof(buf));
            buf.data = bufdata;
            buf.maxsize = sizeof(bufdata);
            MSG_WriteByte(&buf, svc_disconnect);
            if(fmt)
            {
                if(sv.protocol == PROTOCOL_DARKPLACES8)
                    MSG_WriteString(&buf, reason);
                else
                    SV_ClientPrintf("%s\n", reason);
            }
            NetConn_SendUnreliableMessage(host_client->netconnection, &buf, sv.protocol, 10000, 0, false);
            NetConn_SendUnreliableMessage(host_client->netconnection, &buf, sv.protocol, 10000, 0, false);
            NetConn_SendUnreliableMessage(host_client->netconnection, &buf, sv.protocol, 10000, 0, false);
        }
    }
 
    // call qc ClientDisconnect function
    // LadyHavoc: don't call QC if server is dead (avoids recursive
    // Host_Error in some mods when they run out of edicts)
    if (host_client->clientconnectcalled && sv.active && host_client->edict)
    {
        // call the prog function for removing a client
        // this will set the body to a dead frame, among other things
        int saveSelf = PRVM_serverglobaledict(self);
        host_client->clientconnectcalled = false;
        PRVM_serverglobalfloat(time) = sv.time;
        PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(host_client->edict);
        prog->ExecuteProgram(prog, PRVM_serverfunction(ClientDisconnect), "QC function ClientDisconnect is missing");
        PRVM_serverglobaledict(self) = saveSelf;
    }
 
    if (host_client->netconnection)
    {
        // break the net connection
        NetConn_Close(host_client->netconnection);
        host_client->netconnection = NULL;
 
        if(fmt)
            SV_BroadcastPrintf("\003^3%s left the game (%s)\n", host_client->name, reason);
        else
            SV_BroadcastPrintf("\003^3%s left the game\n", host_client->name);
    }
 
    // if a download is active, close it
    if (host_client->download_file)
    {
        Con_DPrintf("Download of %s aborted when %s dropped\n", host_client->download_name, host_client->name);
        FS_Close(host_client->download_file);
        host_client->download_file = NULL;
        host_client->download_name[0] = 0;
        host_client->download_expectedposition = 0;
        host_client->download_started = false;
    }
 
    // remove leaving player from scoreboard
    host_client->name[0] = 0;
    host_client->colors = 0;
    host_client->frags = 0;
    // send notification to all clients
    // get number of client manually just to make sure we get it right...
    i = host_client - svs.clients;
    MSG_WriteByte (&sv.reliable_datagram, svc_updatename);
    MSG_WriteByte (&sv.reliable_datagram, i);
    MSG_WriteString (&sv.reliable_datagram, host_client->name);
    MSG_WriteByte (&sv.reliable_datagram, svc_updatecolors);
    MSG_WriteByte (&sv.reliable_datagram, i);
    MSG_WriteByte (&sv.reliable_datagram, host_client->colors);
    MSG_WriteByte (&sv.reliable_datagram, svc_updatefrags);
    MSG_WriteByte (&sv.reliable_datagram, i);
    MSG_WriteShort (&sv.reliable_datagram, host_client->frags);
 
    // free the client now
    if (host_client->entitydatabase)
        EntityFrame_FreeDatabase(host_client->entitydatabase);
    if (host_client->entitydatabase4)
        EntityFrame4_FreeDatabase(host_client->entitydatabase4);
    if (host_client->entitydatabase5)
        EntityFrame5_FreeDatabase(host_client->entitydatabase5);
 
    if (sv.active)
    {
        // clear a fields that matter to DP_SV_CLIENTNAME and DP_SV_CLIENTCOLORS, and also frags
        PRVM_ED_ClearEdict(prog, host_client->edict);
    }
 
    // clear the client struct (this sets active to false)
    memset(host_client, 0, sizeof(*host_client));
 
    // update server listing on the master because player count changed
    // (which the master uses for filtering empty/full servers)
    NetConn_Heartbeat(1);
 
    if (sv.loadgame)
    {
        for (i = 0;i < svs.maxclients;i++)
            if (svs.clients[i].active && !svs.clients[i].spawned)
                break;
        if (i == svs.maxclients)
        {
            Con_Printf("Loaded game, everyone rejoined - unpausing\n");
            sv.paused = sv.loadgame = false; // we're basically done with loading now
        }
    }
}

References server_t::active, buf, client_t::clientconnectcalled, server_static_t::clients, client_t::colors, Con_DPrintf(), Con_Printf(), client_t::download_expectedposition, client_t::download_file, client_t::download_name, client_t::download_started, dpvsnprintf(), client_t::edict, client_t::entitydatabase, client_t::entitydatabase4, client_t::entitydatabase5, EntityFrame4_FreeDatabase(), EntityFrame5_FreeDatabase(), EntityFrame_FreeDatabase(), prvm_prog_t::ExecuteProgram, client_t::frags, FS_Close(), host_client, i, server_t::loadgame, server_static_t::maxclients, MSG_WriteByte(), MSG_WriteShort(), MSG_WriteString(), client_t::name, NetConn_Close(), NetConn_Heartbeat(), NetConn_SendUnreliableMessage(), client_t::netconnection, NULL, server_t::paused, server_t::protocol, PROTOCOL_DARKPLACES8, PRVM_ED_ClearEdict(), PRVM_EDICT_NUM, PRVM_EDICT_TO_PROG, PRVM_serverfunction, PRVM_serverglobaledict, PRVM_serverglobalfloat, server_t::reliable_datagram, self, sv, SV_BroadcastPrintf(), SV_ClientPrintf(), SV_StopDemoRecording(), svc_disconnect, svc_updatecolors, svc_updatefrags, svc_updatename, svs, SVVM_prog, server_t::time, and time.

Referenced by SV_CheckTimeouts(), SV_Kick_f(), SV_ReadClientMessage(), SV_SendClientMessages(), SV_Shutdown(), Sys_Error(), and VM_SV_dropclient().

SV_EntitiesInBox()

int SV_EntitiesInBox	(	const vec3_t	mins,
		const vec3_t	maxs,
		int	maxedicts,
		prvm_edict_t **	resultedicts )

Definition at line 673 of file sv_phys.c.

{
    prvm_prog_t *prog = SVVM_prog;
    vec3_t paddedmins, paddedmaxs;
    if (maxedicts < 1 || resultedicts == NULL)
        return 0;
    // LadyHavoc: discovered this actually causes its own bugs (dm6 teleporters being too close to info_teleport_destination)
    //VectorSet(paddedmins, mins[0] - 10, mins[1] - 10, mins[2] - 1);
    //VectorSet(paddedmaxs, maxs[0] + 10, maxs[1] + 10, maxs[2] + 1);
    VectorCopy(mins, paddedmins);
    VectorCopy(maxs, paddedmaxs);
    if (sv_areadebug.integer)
    {
        int numresultedicts = 0;
        int edictindex;
        prvm_edict_t *ed;
        for (edictindex = 1;edictindex < prog->num_edicts;edictindex++)
        {
            ed = PRVM_EDICT_NUM(edictindex);
            if (!ed->free && BoxesOverlap(PRVM_serveredictvector(ed, absmin), PRVM_serveredictvector(ed, absmax), paddedmins, paddedmaxs))
            {
                resultedicts[numresultedicts++] = ed;
                if (numresultedicts == maxedicts)
                    break;
            }
        }
        return numresultedicts;
    }
    else
        return World_EntitiesInBox(&sv.world, paddedmins, paddedmaxs, maxedicts, resultedicts);
}

References absmax, absmin, BoxesOverlap, prvm_edict_t::free, cvar_t::integer, maxs, mins, NULL, prvm_prog_t::num_edicts, PRVM_EDICT_NUM, PRVM_serveredictvector, sv, sv_areadebug, SVVM_prog, VectorCopy, server_t::world, and World_EntitiesInBox().

Referenced by SV_CanSeeBox(), SV_LinkEdict_TouchAreaGrid(), SV_PointSuperContents(), SV_PushMove(), SV_TraceBox(), SV_TraceLine(), SV_TracePoint(), VM_SV_findbox(), and VM_SV_findradius().

SV_FlushBroadcastMessages()

void SV_FlushBroadcastMessages

(

void

)

Definition at line 1371 of file sv_send.c.

{
    int i;
    client_t *client;
    if (sv.datagram.cursize <= 0)
        return;
    for (i = 0, client = svs.clients;i < svs.maxclients;i++, client++)
    {
        if (!client->begun || !client->netconnection || client->unreliablemsg.cursize + sv.datagram.cursize > client->unreliablemsg.maxsize || client->unreliablemsg_splitpoints >= (int)(sizeof(client->unreliablemsg_splitpoint)/sizeof(client->unreliablemsg_splitpoint[0])))
            continue;
        SZ_Write(&client->unreliablemsg, sv.datagram.data, sv.datagram.cursize);
        client->unreliablemsg_splitpoint[client->unreliablemsg_splitpoints++] = client->unreliablemsg.cursize;
    }
    SZ_Clear(&sv.datagram);
}

References client_t::begun, server_static_t::clients, sizebuf_t::cursize, sizebuf_t::data, server_t::datagram, i, server_static_t::maxclients, sizebuf_t::maxsize, client_t::netconnection, sv, svs, SZ_Clear(), SZ_Write(), client_t::unreliablemsg, client_t::unreliablemsg_splitpoint, and client_t::unreliablemsg_splitpoints.

Referenced by CLVM_ExecuteProgram(), SV_SendClientMessages(), SV_StartEffect(), SV_StartParticle(), SV_StartPointSound(), SV_StartSound(), SVVM_ExecuteProgram(), VM_SV_pointparticles(), VM_SV_te_beam(), VM_SV_te_blood(), VM_SV_te_bloodshower(), VM_SV_te_customflash(), VM_SV_te_explosion(), VM_SV_te_explosion2(), VM_SV_te_explosionquad(), VM_SV_te_explosionrgb(), VM_SV_te_flamejet(), VM_SV_te_gunshot(), VM_SV_te_gunshotquad(), VM_SV_te_knightspike(), VM_SV_te_lavasplash(), VM_SV_te_lightning1(), VM_SV_te_lightning2(), VM_SV_te_lightning3(), VM_SV_te_particlecube(), VM_SV_te_particlerain(), VM_SV_te_particlesnow(), VM_SV_te_plasmaburn(), VM_SV_te_smallflash(), VM_SV_te_spark(), VM_SV_te_spike(), VM_SV_te_spikequad(), VM_SV_te_superspike(), VM_SV_te_superspikequad(), VM_SV_te_tarexplosion(), VM_SV_te_teleport(), VM_SV_te_wizspike(), and VM_SV_trailparticles().

SV_Frame()

double SV_Frame

(

double

time

)

Definition at line 2527 of file sv_main.c.

{
    static double sv_timer;
    int i;
    char vabuf[1024];
    qbool reporting = false;
 
    // reset timer after level change
    if (host.framecount == sv.spawnframe || host.framecount == sv.spawnframe + 1)
        sv_timer = time = host.sleeptime = 0;
 
    if (!svs.threaded)
    {
        prvm_prog_t *prog = SVVM_prog;
 
        sv.perf_acc_sleeptime += host.sleeptime;
        sv.perf_acc_realtime += time;
 
        if (sv_lagreporting_always.integer)
            reporting = true;
        // bones_was_here: intermission_running isn't declared in dpdefs, but it's used by
        // id1 Quake, all Quake mods (afaict), Nexuiz and Xonotic.
        else if (cls.state == ca_dedicated && !PRVM_serverglobalfloat(intermission_running))
        {
            // Report lag if there's players, so they know it wasn't the network or their machine
            for (i = 0; i < svs.maxclients; ++i)
            {
                if (svs.clients[i].begun && svs.clients[i].netconnection)
                {
                    reporting = true;
                    break;
                }
            }
        }
 
        if(sv.perf_acc_realtime > 5)
        {
            sv.perf_cpuload = 1 - sv.perf_acc_sleeptime / sv.perf_acc_realtime;
            sv.perf_lost = sv.perf_acc_lost / sv.perf_acc_realtime;
 
            if(sv.perf_acc_offset_samples > 0)
            {
                sv.perf_offset_max = sv.perf_acc_offset_max;
                sv.perf_offset_avg = sv.perf_acc_offset / sv.perf_acc_offset_samples;
                sv.perf_offset_sdev = sv.perf_acc_offset_squared / sv.perf_acc_offset_samples - sv.perf_offset_avg * sv.perf_offset_avg;
                sv.perf_offset_sdev = sv.perf_offset_sdev > 0 ? sqrt(sv.perf_offset_sdev) : 0;
            }
 
            if (sv.perf_lost > 0 && reporting)
                SV_BroadcastPrintf(CON_WARN "Server lag report: %s\n", SV_TimingReport(vabuf, sizeof(vabuf)));
 
            sv.perf_acc_realtime = sv.perf_acc_sleeptime =
            sv.perf_acc_lost = sv.perf_acc_offset =
            sv.perf_acc_offset_squared = sv.perf_acc_offset_max =
            sv.perf_acc_offset_samples = 0;
        }
 
        /*
         * Receive packets on each main loop iteration, as the main loop may
         * be undersleeping due to select() detecting a new packet
         */
        if (sv.active)
        {
            NetConn_ServerFrame();
            SV_CheckTimeouts();
        }
    }
 
    /*
     * If the accumulator hasn't become positive, don't
     * run the frame. Everything that happens before this
     * point will happen even if we're sleeping this frame.
     */
    if((sv_timer += time) < 0)
        return sv_timer;
 
    // limit the frametime steps to no more than 100ms each
    if (sv_timer > 0.1)
    {
        if (!svs.threaded)
            sv.perf_acc_lost += (sv_timer - 0.1);
        sv_timer = 0.1;
    }
 
    if (sv.active && sv_timer > 0 && !svs.threaded)
    {
        /*
         * Execute one or more server frames, with an upper limit on how much
         * execution time to spend on server frames to avoid freezing the game if
         * the server is overloaded. This execution time limit means the game will
         * slow down if the server is taking too long.
         */
        int framecount, framelimit = 1;
        double advancetime, aborttime = 0;
        float offset;
        prvm_prog_t *prog = SVVM_prog;
 
        // run the world state
        // don't allow simulation to run too fast or too slow or logic glitches can occur
 
        // stop running server frames if the wall time reaches this value
        if (sys_ticrate.value <= 0)
            advancetime = sv_timer;
        else
        {
            advancetime = sys_ticrate.value;
            // listen servers can run multiple server frames per client frame
            if (sv_maxphysicsframesperserverframe.integer > 0)
                framelimit = sv_maxphysicsframesperserverframe.integer;
            aborttime = Sys_DirtyTime() + 0.1;
        }
 
        if(host_timescale.value > 0 && host_timescale.value < 1)
            advancetime = min(advancetime, 0.1 / host_timescale.value);
        else
            advancetime = min(advancetime, 0.1);
 
        if(advancetime > 0)
        {
            offset = Sys_DirtyTime() - host.dirtytime;
            if (offset < 0 || offset >= 1800)
                offset = 0;
 
            offset += sv_timer;
            ++sv.perf_acc_offset_samples;
            sv.perf_acc_offset += offset;
            sv.perf_acc_offset_squared += offset * offset;
 
            if(sv.perf_acc_offset_max < offset)
                sv.perf_acc_offset_max = offset;
        }
 
        // only advance time if not paused
        // the game also pauses in singleplayer when menu or console is used
        sv.frametime = advancetime * host_timescale.value;
        if (host_framerate.value)
            sv.frametime = host_framerate.value;
        if (sv.paused || host.paused)
            sv.frametime = 0;
 
        for (framecount = 0; framecount < framelimit && sv_timer > 0; framecount++)
        {
            sv_timer -= advancetime;
 
            // move things around and think unless paused
            if (sv.frametime)
                SV_Physics();
 
            // if this server frame took too long, break out of the loop
            if (framelimit > 1 && Sys_DirtyTime() >= aborttime)
                break;
        }
 
        if (framecount > 1 && sv_lagreporting_strict.integer && reporting)
            SV_BroadcastPrintf(CON_WARN "Server lag report: caught up %.1fms by running %d extra frames\n", advancetime * (framecount - 1) * 1000, framecount - 1);
 
        R_TimeReport("serverphysics");
 
        // send all messages to the clients
        SV_SendClientMessages();
 
        if (sv.paused == 1 && host.realtime > sv.pausedstart && sv.pausedstart > 0) {
            prog->globals.fp[OFS_PARM0] = host.realtime - sv.pausedstart;
            PRVM_serverglobalfloat(time) = sv.time;
            prog->ExecuteProgram(prog, PRVM_serverfunction(SV_PausedTic), "QC function SV_PausedTic is missing");
        }
 
        // send an heartbeat if enough time has passed since the last one
        NetConn_Heartbeat(0);
        R_TimeReport("servernetwork");
    }
    else
    {
        // don't let r_speeds display jump around
        R_TimeReport("serverphysics");
        R_TimeReport("servernetwork");
    }
 
    // if there is some time remaining from this frame, reset the timer
    if (sv_timer >= 0)
    {
        if (!svs.threaded)
            sv.perf_acc_lost += sv_timer;
        sv_timer = 0;
    }
 
    return sv_timer;
}

References server_t::active, ca_dedicated, server_static_t::clients, cls, CON_WARN, host_static_t::dirtytime, prvm_prog_t::ExecuteProgram, prvm_prog_t::fp, host_static_t::framecount, server_t::frametime, prvm_prog_t::globals, host, host_framerate, host_timescale, i, cvar_t::integer, server_static_t::maxclients, min, NetConn_Heartbeat(), NetConn_ServerFrame(), offset, OFS_PARM0, host_static_t::paused, server_t::paused, server_t::pausedstart, server_t::perf_acc_lost, server_t::perf_acc_offset, server_t::perf_acc_offset_max, server_t::perf_acc_offset_samples, server_t::perf_acc_offset_squared, server_t::perf_acc_realtime, server_t::perf_acc_sleeptime, server_t::perf_cpuload, server_t::perf_lost, server_t::perf_offset_avg, server_t::perf_offset_max, server_t::perf_offset_sdev, PRVM_serverfunction, PRVM_serverglobalfloat, R_TimeReport(), host_static_t::realtime, host_static_t::sleeptime, server_t::spawnframe, sqrt(), client_static_t::state, sv, SV_BroadcastPrintf(), SV_CheckTimeouts(), sv_lagreporting_always, sv_lagreporting_strict, sv_maxphysicsframesperserverframe, SV_Physics(), SV_SendClientMessages(), SV_TimingReport(), svs, SVVM_prog, Sys_DirtyTime(), sys_ticrate, server_static_t::threaded, server_t::time, time, and cvar_t::value.

Referenced by Host_Frame().

SV_GenericHitSuperContentsMask()

int SV_GenericHitSuperContentsMask

(

const prvm_edict_t *

edict

)

calculates hitsupercontentsmask for a generic qc entity

Definition at line 73 of file sv_phys.c.

{
    prvm_prog_t *prog = SVVM_prog;
    if (passedict)
    {
        int dphitcontentsmask = (int)PRVM_serveredictfloat(passedict, dphitcontentsmask);
        if (dphitcontentsmask)
            return dphitcontentsmask;
        else if (PRVM_serveredictfloat(passedict, solid) == SOLID_SLIDEBOX)
        {
            if ((int)PRVM_serveredictfloat(passedict, flags) & FL_MONSTER)
                return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_MONSTERCLIP;
            else
                return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP;
        }
        else if (PRVM_serveredictfloat(passedict, solid) == SOLID_CORPSE)
            return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY;
        else if (PRVM_serveredictfloat(passedict, solid) == SOLID_TRIGGER)
            return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY;
        else
            return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_CORPSE;
    }
    else
        return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_CORPSE;
}

References dphitcontentsmask, FL_MONSTER, flags, int(), PRVM_serveredictfloat, solid, SOLID_CORPSE, SOLID_SLIDEBOX, SOLID_TRIGGER, SUPERCONTENTS_BODY, SUPERCONTENTS_CORPSE, SUPERCONTENTS_MONSTERCLIP, SUPERCONTENTS_PLAYERCLIP, SUPERCONTENTS_SOLID, and SVVM_prog.

Referenced by PHYS_NudgeOutOfSolid(), PHYS_TestEntityPosition(), SV_CheckBottom(), SV_movestep(), SV_NudgeOutOfSolid_PivotIsKnownGood(), SV_Physics_Step(), SV_PushEntity(), SV_PushMove(), SV_Trace_Toss(), SV_UserFriction(), SV_WalkMove(), VM_SV_tracebox(), and VM_SV_traceline().

SV_GetEntityMatrix()

void SV_GetEntityMatrix	(	prvm_prog_t *	prog,
		prvm_edict_t *	ent,
		matrix4x4_t *	out,
		qbool	viewmatrix )

Definition at line 2518 of file svvm_cmds.c.

{
    float scale;
    float pitchsign = 1;
 
    scale = PRVM_serveredictfloat(ent, scale);
    if (!scale)
        scale = 1.0f;
    
    if (viewmatrix)
        Matrix4x4_CreateFromQuakeEntity(out, PRVM_serveredictvector(ent, origin)[0], PRVM_serveredictvector(ent, origin)[1], PRVM_serveredictvector(ent, origin)[2] + PRVM_serveredictvector(ent, view_ofs)[2], PRVM_serveredictvector(ent, v_angle)[0], PRVM_serveredictvector(ent, v_angle)[1], PRVM_serveredictvector(ent, v_angle)[2], scale * cl_viewmodel_scale.value);
    else
    {
        pitchsign = SV_GetPitchSign(prog, ent);
        Matrix4x4_CreateFromQuakeEntity(out, PRVM_serveredictvector(ent, origin)[0], PRVM_serveredictvector(ent, origin)[1], PRVM_serveredictvector(ent, origin)[2], pitchsign * PRVM_serveredictvector(ent, angles)[0], PRVM_serveredictvector(ent, angles)[1], PRVM_serveredictvector(ent, angles)[2], scale);
    }
}

References angles, cl_viewmodel_scale, Matrix4x4_CreateFromQuakeEntity(), origin, PRVM_serveredictfloat, PRVM_serveredictvector, scale, SV_GetPitchSign(), v_angle, cvar_t::value, and view_ofs.

Referenced by getmatrix(), SV_Ent_Create_f(), SV_Ent_Remove_f(), and SV_GetTagMatrix().

SV_GetModelByIndex()

model_t * SV_GetModelByIndex

(

int

modelindex

)

Definition at line 1607 of file sv_main.c.

{
    return (modelindex > 0 && modelindex < MAX_MODELS) ? sv.models[modelindex] : NULL;
}

References MAX_MODELS, modelindex, server_t::models, NULL, and sv.

Referenced by EntityState5_WriteUpdate(), SV_GetTagIndex(), SV_GetTagMatrix(), SV_LinkEdict(), SV_MarkWriteEntityStateToClient(), SV_PrepareEntityForSending(), SV_PushMove(), VM_SV_frameduration(), VM_SV_frameforname(), VM_SV_setmodel(), VM_SV_setmodelindex(), VM_SV_skel_build(), and VM_SV_skel_create().

SV_GetModelFromEdict()

model_t * SV_GetModelFromEdict

(

prvm_edict_t *

ed

)

Definition at line 1612 of file sv_main.c.

{
    prvm_prog_t *prog = SVVM_prog;
    int modelindex;
    if (!ed || ed->free)
        return NULL;
    modelindex = (int)PRVM_serveredictfloat(ed, modelindex);
    return (modelindex > 0 && modelindex < MAX_MODELS) ? sv.models[modelindex] : NULL;
}

References prvm_edict_t::free, int(), MAX_MODELS, modelindex, server_t::models, NULL, PRVM_serveredictfloat, sv, and SVVM_prog.

Referenced by getmodel(), SV_CanSeeBox(), SV_GetEntityLocalTagMatrix(), SV_GetExtendedTagInfo(), SV_GetPitchSign(), SV_PointSuperContents(), SV_PushMove(), SV_TraceBox(), SV_TraceLine(), SV_TracePoint(), VM_SV_gettagindex(), VM_SV_gettaginfo(), and VM_SV_setattachment().

SV_GetPitchSign()

int SV_GetPitchSign	(	prvm_prog_t *	prog,
		prvm_edict_t *	ent )

Definition at line 47 of file sv_phys.c.

{
    model_t *model;
    if (
            (model = SV_GetModelFromEdict(ent))
            ?
            model->type == mod_alias
            :
            (
             (((unsigned char)PRVM_serveredictfloat(ent, pflags)) & PFLAGS_FULLDYNAMIC)
             ||
             ((gamemode == GAME_TENEBRAE) && ((unsigned int)PRVM_serveredictfloat(ent, effects) & (16 | 32)))
            )
       )
        return -1;
    return 1;
}

References effects, GAME_TENEBRAE, gamemode, mod_alias, model, pflags, PFLAGS_FULLDYNAMIC, PRVM_serveredictfloat, and SV_GetModelFromEdict().

Referenced by SV_CanSeeBox(), SV_GetEntityMatrix(), SV_TraceBox(), SV_TraceLine(), and SV_TracePoint().

SV_Init()

void SV_Init

(

void

)

Definition at line 504 of file sv_main.c.

{
    // init the csqc progs cvars, since they are updated/used by the server code
    // TODO: fix this since this is a quick hack to make some of [515]'s broken code run ;) [9/13/2006 Black]
    extern cvar_t csqc_progname;    //[515]: csqc crc check and right csprogs name according to progs.dat
    extern cvar_t csqc_progcrc;
    extern cvar_t csqc_progsize;
    extern cvar_t csqc_usedemoprogs;
 
    Cvar_RegisterVariable(&sv_worldmessage);
    Cvar_RegisterVariable(&sv_worldname);
    Cvar_RegisterVariable(&sv_worldnamenoextension);
    Cvar_RegisterVariable(&sv_worldbasename);
 
    Cvar_RegisterVariable (&csqc_progname);
    Cvar_RegisterVariable (&csqc_progcrc);
    Cvar_RegisterVariable (&csqc_progsize);
    Cvar_RegisterVariable (&csqc_usedemoprogs);
 
    Cmd_AddCommand(CF_SHARED, "sv_saveentfile", SV_SaveEntFile_f, "save map entities to .ent file (to allow external editing)");
    Cmd_AddCommand(CF_SHARED, "sv_areastats", SV_AreaStats_f, "prints statistics on entity culling during collision traces");
    Cmd_AddCommand(CF_CLIENT | CF_SERVER_FROM_CLIENT, "sv_startdownload", SV_StartDownload_f, "begins sending a file to the client (network protocol use only)");
    Cmd_AddCommand(CF_CLIENT | CF_SERVER_FROM_CLIENT, "download", SV_Download_f, "downloads a specified file from the server");
 
    Cvar_RegisterVariable (&sv_disablenotify);
    Cvar_RegisterVariable (&coop);
    Cvar_RegisterVariable (&deathmatch);
    Cvar_RegisterVariable (&fraglimit);
    Cvar_RegisterVariable (&gamecfg);
    Cvar_RegisterVariable (&noexit);
    Cvar_RegisterVariable (&nomonsters);
    Cvar_RegisterVariable (&pausable);
    Cvar_RegisterVariable (&pr_checkextension);
    Cvar_RegisterVariable (&samelevel);
    Cvar_RegisterVariable (&skill);
    Cvar_RegisterVariable (&host_timescale);
    Cvar_RegisterCallback (&host_timescale, Host_Timescale_c);
    Cvar_RegisterVirtual (&host_timescale, "slowmo");
    Cvar_RegisterVirtual (&host_timescale, "timescale");
    Cvar_RegisterVariable (&sv_accelerate);
    Cvar_RegisterVariable (&sv_aim);
    Cvar_RegisterVariable (&sv_airaccel_qw);
    Cvar_RegisterVariable (&sv_airaccel_qw_stretchfactor);
    Cvar_RegisterVariable (&sv_airaccel_sideways_friction);
    Cvar_RegisterVariable (&sv_airaccelerate);
    Cvar_RegisterVariable (&sv_airstopaccelerate);
    Cvar_RegisterVariable (&sv_airstrafeaccelerate);
    Cvar_RegisterVariable (&sv_maxairstrafespeed);
    Cvar_RegisterVariable (&sv_airstrafeaccel_qw);
    Cvar_RegisterVariable (&sv_airspeedlimit_nonqw);
    Cvar_RegisterVariable (&sv_aircontrol);
    Cvar_RegisterVariable (&sv_aircontrol_power);
    Cvar_RegisterVariable (&sv_aircontrol_penalty);
    Cvar_RegisterVariable (&sv_allowdownloads);
    Cvar_RegisterVariable (&sv_allowdownloads_archive);
    Cvar_RegisterVariable (&sv_allowdownloads_config);
    Cvar_RegisterVariable (&sv_allowdownloads_dlcache);
    Cvar_RegisterVariable (&sv_allowdownloads_inarchive);
    Cvar_RegisterVariable (&sv_areagrid_link_SOLID_NOT);
    Cvar_RegisterVariable (&sv_areagrid_mingridsize);
    Cvar_RegisterVariable (&sv_checkforpacketsduringsleep);
    Cvar_RegisterVariable (&sv_clmovement_enable);
    Cvar_RegisterVariable (&sv_clmovement_minping);
    Cvar_RegisterVariable (&sv_clmovement_minping_disabletime);
    Cvar_RegisterVariable (&sv_clmovement_inputtimeout);
    Cvar_RegisterVariable (&sv_cullentities_nevercullbmodels);
    Cvar_RegisterVariable (&sv_cullentities_pvs);
    Cvar_RegisterVariable (&sv_cullentities_stats);
    Cvar_RegisterVariable (&sv_cullentities_trace);
    Cvar_RegisterVariable (&sv_cullentities_trace_delay);
    Cvar_RegisterVariable (&sv_cullentities_trace_delay_players);
    Cvar_RegisterVariable (&sv_cullentities_trace_enlarge);
    Cvar_RegisterVariable (&sv_cullentities_trace_expand);
    Cvar_RegisterVariable (&sv_cullentities_trace_eyejitter);
    Cvar_RegisterVariable (&sv_cullentities_trace_entityocclusion);
    Cvar_RegisterVariable (&sv_cullentities_trace_prediction);
    Cvar_RegisterVariable (&sv_cullentities_trace_prediction_time);
    Cvar_RegisterVariable (&sv_cullentities_trace_samples);
    Cvar_RegisterVariable (&sv_cullentities_trace_samples_extra);
    Cvar_RegisterVariable (&sv_cullentities_trace_samples_players);
    Cvar_RegisterVariable (&sv_cullentities_trace_spectators);
    Cvar_RegisterVariable (&sv_debugmove);
    Cvar_RegisterVariable (&sv_dedicated);
    Cvar_RegisterVariable (&sv_echobprint);
    Cvar_RegisterVariable (&sv_edgefriction);
    Cvar_RegisterVariable (&sv_entpatch);
    Cvar_RegisterVariable (&sv_freezenonclients);
    Cvar_RegisterVariable (&sv_friction);
    Cvar_RegisterVariable (&sv_gameplayfix_blowupfallenzombies);
    Cvar_RegisterVariable (&sv_gameplayfix_consistentplayerprethink);
    Cvar_RegisterVariable (&sv_gameplayfix_delayprojectiles);
    Cvar_RegisterVariable (&sv_gameplayfix_droptofloorstartsolid);
    Cvar_RegisterVariable (&sv_gameplayfix_droptofloorstartsolid_nudgetocorrect);
    Cvar_RegisterVariable (&sv_gameplayfix_easierwaterjump);
    Cvar_RegisterVariable (&sv_gameplayfix_findradiusdistancetobox);
    Cvar_RegisterVariable (&sv_gameplayfix_gravityunaffectedbyticrate);
    Cvar_RegisterVariable (&sv_gameplayfix_grenadebouncedownslopes);
    Cvar_RegisterVariable (&sv_gameplayfix_impactbeforeonground);
    Cvar_RegisterVariable (&sv_gameplayfix_multiplethinksperframe);
    Cvar_RegisterVariable (&sv_gameplayfix_noairborncorpse);
    Cvar_RegisterVariable (&sv_gameplayfix_noairborncorpse_allowsuspendeditems);
    Cvar_RegisterVariable (&sv_gameplayfix_nudgeoutofsolid);
    Cvar_RegisterVariable (&sv_gameplayfix_nudgeoutofsolid_separation);
    Cvar_RegisterVariable (&sv_gameplayfix_q2airaccelerate);
    Cvar_RegisterVariable (&sv_gameplayfix_nogravityonground);
    Cvar_RegisterVariable (&sv_gameplayfix_setmodelrealbox);
    Cvar_RegisterVariable (&sv_gameplayfix_slidemoveprojectiles);
    Cvar_RegisterVariable (&sv_gameplayfix_stepdown);
    Cvar_RegisterVariable (&sv_gameplayfix_stepmultipletimes);
    Cvar_RegisterVariable (&sv_gameplayfix_nostepmoveonsteepslopes);
    Cvar_RegisterVariable (&sv_gameplayfix_swiminbmodels);
    Cvar_RegisterVariable (&sv_gameplayfix_upwardvelocityclearsongroundflag);
    Cvar_RegisterVariable (&sv_gameplayfix_downtracesupportsongroundflag);
    Cvar_RegisterVariable (&sv_gameplayfix_q1bsptracelinereportstexture);
    Cvar_RegisterVariable (&sv_gameplayfix_unstickplayers);
    Cvar_RegisterVariable (&sv_gameplayfix_unstickentities);
    Cvar_RegisterVariable (&sv_gameplayfix_fixedcheckwatertransition);
    Cvar_RegisterVariable (&sv_gameplayfix_nosquashentities);
    Cvar_RegisterVariable (&sv_qcstats);
    Cvar_RegisterVariable (&sv_gravity);
    Cvar_RegisterVariable (&sv_init_frame_count);
    Cvar_RegisterVariable (&sv_idealpitchscale);
    Cvar_RegisterVariable (&sv_jumpstep);
    Cvar_RegisterVariable (&sv_jumpvelocity);
    Cvar_RegisterVariable (&sv_legacy_bbox_expand);
    Cvar_RegisterVariable (&sv_maxairspeed);
    Cvar_RegisterVariable (&sv_maxrate);
    Cvar_RegisterVariable (&sv_maxspeed);
    Cvar_RegisterVariable (&sv_maxvelocity);
    Cvar_RegisterVariable (&sv_nostep);
    Cvar_RegisterVariable (&sv_playerphysicsqc);
    Cvar_RegisterVariable (&sv_progs);
    Cvar_RegisterVariable (&sv_protocolname);
    Cvar_RegisterVariable (&sv_random_seed);
    Cvar_RegisterVariable (&host_limitlocal);
    Cvar_RegisterVirtual(&host_limitlocal, "sv_ratelimitlocalplayer");
    Cvar_RegisterVariable (&sv_sound_land);
    Cvar_RegisterVariable (&sv_sound_watersplash);
    Cvar_RegisterVariable (&sv_stepheight);
    Cvar_RegisterVariable (&sv_stopspeed);
    Cvar_RegisterVariable (&sv_wallfriction);
    Cvar_RegisterVariable (&sv_wateraccelerate);
    Cvar_RegisterVariable (&sv_waterfriction);
    Cvar_RegisterVariable (&sv_warsowbunny_airforwardaccel);
    Cvar_RegisterVariable (&sv_warsowbunny_accel);
    Cvar_RegisterVariable (&sv_warsowbunny_topspeed);
    Cvar_RegisterVariable (&sv_warsowbunny_turnaccel);
    Cvar_RegisterVariable (&sv_warsowbunny_backtosideratio);
    Cvar_RegisterVariable (&sv_onlycsqcnetworking);
    Cvar_RegisterVariable (&sv_areadebug);
 
    Cvar_RegisterVariable (&sys_ticrate);
    Cvar_RegisterVariable (&sv_maxphysicsframesperserverframe);
    Cvar_RegisterVariable (&sv_lagreporting_always);
    Cvar_RegisterVariable (&sv_lagreporting_strict);
    Cvar_RegisterVariable (&sv_threaded);
 
    Cvar_RegisterVariable (&teamplay);
    Cvar_RegisterVariable (&timelimit);
 
    Cvar_RegisterVariable (&sv_rollangle);
    Cvar_RegisterVariable (&sv_rollspeed);
 
    Cvar_RegisterVariable (&saved1);
    Cvar_RegisterVariable (&saved2);
    Cvar_RegisterVariable (&saved3);
    Cvar_RegisterVariable (&saved4);
    Cvar_RegisterVariable (&savedgamecfg);
    Cvar_RegisterVariable (&scratch1);
    Cvar_RegisterVariable (&scratch2);
    Cvar_RegisterVariable (&scratch3);
    Cvar_RegisterVariable (&scratch4);
    Cvar_RegisterVariable (&temp1);
 
    // LadyHavoc: Nehahra uses these to pass data around cutscene demos
    Cvar_RegisterVariable (&nehx00);
    Cvar_RegisterVariable (&nehx01);
    Cvar_RegisterVariable (&nehx02);
    Cvar_RegisterVariable (&nehx03);
    Cvar_RegisterVariable (&nehx04);
    Cvar_RegisterVariable (&nehx05);
    Cvar_RegisterVariable (&nehx06);
    Cvar_RegisterVariable (&nehx07);
    Cvar_RegisterVariable (&nehx08);
    Cvar_RegisterVariable (&nehx09);
    Cvar_RegisterVariable (&nehx10);
    Cvar_RegisterVariable (&nehx11);
    Cvar_RegisterVariable (&nehx12);
    Cvar_RegisterVariable (&nehx13);
    Cvar_RegisterVariable (&nehx14);
    Cvar_RegisterVariable (&nehx15);
    Cvar_RegisterVariable (&nehx16);
    Cvar_RegisterVariable (&nehx17);
    Cvar_RegisterVariable (&nehx18);
    Cvar_RegisterVariable (&nehx19);
    Cvar_RegisterVariable (&cutscene); // for Nehahra but useful to other mods as well
 
    Cvar_RegisterVariable (&sv_autodemo_perclient);
    Cvar_RegisterVariable (&sv_autodemo_perclient_nameformat);
    Cvar_RegisterVariable (&sv_autodemo_perclient_discardable);
 
    Cvar_RegisterVariable (&halflifebsp);
    Cvar_RegisterVariable (&sv_mapformat_is_quake2);
    Cvar_RegisterVariable (&sv_mapformat_is_quake3);
 
    Cvar_RegisterVariable (&sv_writepicture_quality);
 
    Cvar_RegisterVariable (&sv_sendentities_csqc_randomize_order);
 
    SV_InitOperatorCommands();
    host.hook.SV_Shutdown = SV_Shutdown;
 
    sv_mempool = Mem_AllocPool("server", 0, NULL);
 
    SV_ServerOptions();
    Cvar_Callback(&sv_netport);
}

References CF_CLIENT, CF_SERVER_FROM_CLIENT, CF_SHARED, Cmd_AddCommand(), coop, csqc_progcrc, csqc_progname, csqc_progsize, csqc_usedemoprogs, cutscene, Cvar_Callback(), Cvar_RegisterCallback(), Cvar_RegisterVariable(), Cvar_RegisterVirtual(), deathmatch, fraglimit, gamecfg, halflifebsp, host_static_t::hook, host, host_limitlocal, host_timescale, Host_Timescale_c(), Mem_AllocPool, nehx00, nehx01, nehx02, nehx03, nehx04, nehx05, nehx06, nehx07, nehx08, nehx09, nehx10, nehx11, nehx12, nehx13, nehx14, nehx15, nehx16, nehx17, nehx18, nehx19, noexit, nomonsters, NULL, pausable, pr_checkextension, samelevel, saved1, saved2, saved3, saved4, savedgamecfg, scratch1, scratch2, scratch3, scratch4, skill, sv_accelerate, sv_aim, sv_airaccel_qw, sv_airaccel_qw_stretchfactor, sv_airaccel_sideways_friction, sv_airaccelerate, sv_aircontrol, sv_aircontrol_penalty, sv_aircontrol_power, sv_airspeedlimit_nonqw, sv_airstopaccelerate, sv_airstrafeaccel_qw, sv_airstrafeaccelerate, sv_allowdownloads, sv_allowdownloads_archive, sv_allowdownloads_config, sv_allowdownloads_dlcache, sv_allowdownloads_inarchive, sv_areadebug, sv_areagrid_link_SOLID_NOT, sv_areagrid_mingridsize, SV_AreaStats_f(), sv_autodemo_perclient, sv_autodemo_perclient_discardable, sv_autodemo_perclient_nameformat, sv_checkforpacketsduringsleep, sv_clmovement_enable, sv_clmovement_inputtimeout, sv_clmovement_minping, sv_clmovement_minping_disabletime, sv_cullentities_nevercullbmodels, sv_cullentities_pvs, sv_cullentities_stats, sv_cullentities_trace, sv_cullentities_trace_delay, sv_cullentities_trace_delay_players, sv_cullentities_trace_enlarge, sv_cullentities_trace_entityocclusion, sv_cullentities_trace_expand, sv_cullentities_trace_eyejitter, sv_cullentities_trace_prediction, sv_cullentities_trace_prediction_time, sv_cullentities_trace_samples, sv_cullentities_trace_samples_extra, sv_cullentities_trace_samples_players, sv_cullentities_trace_spectators, sv_debugmove, sv_dedicated, sv_disablenotify, SV_Download_f(), sv_echobprint, sv_edgefriction, sv_entpatch, sv_freezenonclients, sv_friction, sv_gameplayfix_blowupfallenzombies, sv_gameplayfix_consistentplayerprethink, sv_gameplayfix_delayprojectiles, sv_gameplayfix_downtracesupportsongroundflag, sv_gameplayfix_droptofloorstartsolid, sv_gameplayfix_droptofloorstartsolid_nudgetocorrect, sv_gameplayfix_easierwaterjump, sv_gameplayfix_findradiusdistancetobox, sv_gameplayfix_fixedcheckwatertransition, sv_gameplayfix_gravityunaffectedbyticrate, sv_gameplayfix_grenadebouncedownslopes, sv_gameplayfix_impactbeforeonground, sv_gameplayfix_multiplethinksperframe, sv_gameplayfix_noairborncorpse, sv_gameplayfix_noairborncorpse_allowsuspendeditems, sv_gameplayfix_nogravityonground, sv_gameplayfix_nosquashentities, sv_gameplayfix_nostepmoveonsteepslopes, sv_gameplayfix_nudgeoutofsolid, sv_gameplayfix_nudgeoutofsolid_separation, sv_gameplayfix_q1bsptracelinereportstexture, sv_gameplayfix_q2airaccelerate, sv_gameplayfix_setmodelrealbox, sv_gameplayfix_slidemoveprojectiles, sv_gameplayfix_stepdown, sv_gameplayfix_stepmultipletimes, sv_gameplayfix_swiminbmodels, sv_gameplayfix_unstickentities, sv_gameplayfix_unstickplayers, sv_gameplayfix_upwardvelocityclearsongroundflag, sv_gravity, sv_idealpitchscale, sv_init_frame_count, SV_InitOperatorCommands(), sv_jumpstep, sv_jumpvelocity, sv_lagreporting_always, sv_lagreporting_strict, sv_legacy_bbox_expand, sv_mapformat_is_quake2, sv_mapformat_is_quake3, sv_maxairspeed, sv_maxairstrafespeed, sv_maxphysicsframesperserverframe, sv_maxrate, sv_maxspeed, sv_maxvelocity, sv_mempool, sv_netport, sv_nostep, sv_onlycsqcnetworking, sv_playerphysicsqc, sv_progs, sv_protocolname, sv_qcstats, sv_random_seed, sv_rollangle, sv_rollspeed, SV_SaveEntFile_f(), sv_sendentities_csqc_randomize_order, SV_ServerOptions(), host_static_t::SV_Shutdown, SV_Shutdown(), sv_sound_land, sv_sound_watersplash, SV_StartDownload_f(), sv_stepheight, sv_stopspeed, sv_threaded, sv_wallfriction, sv_warsowbunny_accel, sv_warsowbunny_airforwardaccel, sv_warsowbunny_backtosideratio, sv_warsowbunny_topspeed, sv_warsowbunny_turnaccel, sv_wateraccelerate, sv_waterfriction, sv_worldbasename, sv_worldmessage, sv_worldname, sv_worldnamenoextension, sv_writepicture_quality, sys_ticrate, teamplay, temp1, and timelimit.

Referenced by Host_Init().

SV_InitOperatorCommands()

void SV_InitOperatorCommands

(

void

)

Definition at line 1640 of file sv_ccmds.c.

{
    Cvar_RegisterVariable(&sv_cheats);
    Cvar_RegisterCallback(&sv_cheats, SV_DisableCheats_c);
    Cvar_RegisterVariable(&sv_adminnick);
    Cvar_RegisterVariable(&sv_status_privacy);
    Cvar_RegisterVariable(&sv_status_show_qcstatus);
    Cvar_RegisterVariable(&sv_namechangetimer);
    
    Cmd_AddCommand(CF_SERVER | CF_SERVER_FROM_CLIENT, "status", SV_Status_f, "print server status information");
    Cmd_AddCommand(CF_SHARED, "map", SV_Map_f, "kick everyone off the server and start a new level");
    Cmd_AddCommand(CF_SHARED, "restart", SV_Restart_f, "restart current level");
    Cmd_AddCommand(CF_SHARED, "changelevel", SV_Changelevel_f, "change to another level, bringing along all connected clients (or start a new level if none is loaded)");
    Cmd_AddCommand(CF_SHARED | CF_SERVER_FROM_CLIENT, "say", SV_Say_f, "send a chat message to everyone on the server");
    Cmd_AddCommand(CF_SERVER_FROM_CLIENT, "say_team", SV_Say_Team_f, "send a chat message to your team on the server");
    Cmd_AddCommand(CF_SHARED | CF_SERVER_FROM_CLIENT, "tell", SV_Tell_f, "send a chat message to only one person on the server");
    Cmd_AddCommand(CF_SERVER | CF_SERVER_FROM_CLIENT, "pause", SV_Pause_f, "pause the game (if the server allows pausing)");
    Cmd_AddCommand(CF_SHARED, "kick", SV_Kick_f, "kick a player off the server by number or name");
    Cmd_AddCommand(CF_SHARED | CF_SERVER_FROM_CLIENT, "ping", SV_Ping_f, "print ping times of all players on the server");
    Cmd_AddCommand(CF_SERVER, "load", SV_Loadgame_f, "load a saved game file");
    Cmd_AddCommand(CF_SERVER, "save", SV_Savegame_f, "save the game to a file");
    Cmd_AddCommand(CF_SHARED, "viewmodel", SV_Viewmodel_f, "change model of viewthing entity in current level");
    Cmd_AddCommand(CF_SHARED, "viewframe", SV_Viewframe_f, "change animation frame of viewthing entity in current level");
    Cmd_AddCommand(CF_SHARED, "viewnext", SV_Viewnext_f, "change to next animation frame of viewthing entity in current level");
    Cmd_AddCommand(CF_SHARED, "viewprev", SV_Viewprev_f, "change to previous animation frame of viewthing entity in current level");
    Cmd_AddCommand(CF_SHARED, "maxplayers", SV_MaxPlayers_f, "sets limit on how many players (or bots) may be connected to the server at once");
    host.hook.SV_SendCvar = SV_SendCvar_f;
 
    // commands that do not have automatic forwarding from cmd_local, these are internal details of the network protocol and not of interest to users (if they know what they are doing they can still use a generic "cmd prespawn" or similar)
    Cmd_AddCommand(CF_SERVER_FROM_CLIENT, "prespawn", SV_PreSpawn_f, "internal use - signon 1 (client acknowledges that server information has been received)");
    Cmd_AddCommand(CF_SERVER_FROM_CLIENT, "spawn", SV_Spawn_f, "internal use - signon 2 (client has sent player information, and is asking server to send scoreboard rankings)");
    Cmd_AddCommand(CF_SERVER_FROM_CLIENT, "begin", SV_Begin_f, "internal use - signon 3 (client asks server to start sending entities, and will go to signon 4 (playing) when the first entity update is received)");
    Cmd_AddCommand(CF_SERVER_FROM_CLIENT, "pings", SV_Pings_f, "internal use - command sent by clients to request updated ping and packetloss of players on scoreboard (originally from QW, but also used on NQ servers)");
 
    Cmd_AddCommand(CF_CHEAT | CF_SERVER_FROM_CLIENT, "god", SV_God_f, "god mode (invulnerability)");
    Cmd_AddCommand(CF_CHEAT | CF_SERVER_FROM_CLIENT, "notarget", SV_Notarget_f, "notarget mode (monsters do not see you)");
    Cmd_AddCommand(CF_CHEAT | CF_SERVER_FROM_CLIENT, "fly", SV_Fly_f, "fly mode (flight)");
    Cmd_AddCommand(CF_CHEAT | CF_SERVER_FROM_CLIENT, "noclip", SV_Noclip_f, "noclip mode (flight without collisions, move through walls)");
    Cmd_AddCommand(CF_CHEAT | CF_SERVER_FROM_CLIENT, "give", SV_Give_f, "alter inventory");
    Cmd_AddCommand(CF_SERVER_FROM_CLIENT, "kill", SV_Kill_f, "die instantly");
    
    Cmd_AddCommand(CF_USERINFO, "color", SV_Color_f, "change your player shirt and pants colors");
    Cmd_AddCommand(CF_USERINFO, "name", SV_Name_f, "change your player name");
    Cmd_AddCommand(CF_USERINFO, "rate", SV_Rate_f, "change your network connection speed");
    Cmd_AddCommand(CF_USERINFO, "rate_burstsize", SV_Rate_BurstSize_f, "change your network connection speed");
    Cmd_AddCommand(CF_USERINFO, "pmodel", SV_PModel_f, "(Nehahra-only) change your player model choice");
    Cmd_AddCommand(CF_USERINFO, "playermodel", SV_Playermodel_f, "change your player model");
    Cmd_AddCommand(CF_USERINFO, "playerskin", SV_Playerskin_f, "change your player skin number");
 
    Cmd_AddCommand(CF_CHEAT | CF_SERVER_FROM_CLIENT, "ent_create", SV_Ent_Create_f, "Creates an entity at the specified coordinate, of the specified classname. If executed from a server, origin has to be specified manually.");
    Cmd_AddCommand(CF_CHEAT | CF_SERVER_FROM_CLIENT, "ent_remove_all", SV_Ent_Remove_All_f, "Removes all entities of the specified classname");
    Cmd_AddCommand(CF_CHEAT | CF_SERVER_FROM_CLIENT, "ent_remove", SV_Ent_Remove_f, "Removes an entity by number, or the entity you're aiming at");
}

References CF_CHEAT, CF_SERVER, CF_SERVER_FROM_CLIENT, CF_SHARED, CF_USERINFO, Cmd_AddCommand(), Cvar_RegisterCallback(), Cvar_RegisterVariable(), host_static_t::hook, host, sv_adminnick, SV_Begin_f(), SV_Changelevel_f(), sv_cheats, SV_Color_f(), SV_DisableCheats_c(), SV_Ent_Create_f(), SV_Ent_Remove_All_f(), SV_Ent_Remove_f(), SV_Fly_f(), SV_Give_f(), SV_God_f(), SV_Kick_f(), SV_Kill_f(), SV_Loadgame_f(), SV_Map_f(), SV_MaxPlayers_f(), SV_Name_f(), sv_namechangetimer, SV_Noclip_f(), SV_Notarget_f(), SV_Pause_f(), SV_Ping_f(), SV_Pings_f(), SV_Playermodel_f(), SV_Playerskin_f(), SV_PModel_f(), SV_PreSpawn_f(), SV_Rate_BurstSize_f(), SV_Rate_f(), SV_Restart_f(), SV_Savegame_f(), SV_Say_f(), SV_Say_Team_f(), host_static_t::SV_SendCvar, SV_SendCvar_f(), SV_Spawn_f(), SV_Status_f(), sv_status_privacy, sv_status_show_qcstatus, SV_Tell_f(), SV_Viewframe_f(), SV_Viewmodel_f(), SV_Viewnext_f(), and SV_Viewprev_f().

Referenced by SV_Init().

SV_IsLocalServer()

int SV_IsLocalServer

(

void

)

Definition at line 1783 of file sv_main.c.

{
    return (host_isclient.integer && sv.active ? svs.maxclients : 0);
}

References server_t::active, host_isclient, cvar_t::integer, server_static_t::maxclients, sv, and svs.

Referenced by SV_Savegame_f().

SV_LinkEdict()

void SV_LinkEdict

(

prvm_edict_t *

ent

)

Needs to be called any time an entity changes origin, mins, maxs, or solid sets ent->v.absmin and ent->v.absmax call TouchAreaGrid as well to fire triggers that overlap the box

Definition at line 804 of file sv_phys.c.

{
    prvm_prog_t *prog = SVVM_prog;
    model_t *model;
    vec3_t mins, maxs, entmins, entmaxs, entangles;
    int modelindex;
 
    if (ent == prog->edicts)
        return;     // don't add the world
 
    if (ent->free)
        return;
 
    modelindex = (int)PRVM_serveredictfloat(ent, modelindex);
    if (modelindex < 0 || modelindex >= MAX_MODELS)
    {
        Con_Printf("edict %i: SOLID_BSP with invalid modelindex!\n", PRVM_NUM_FOR_EDICT(ent));
        modelindex = 0;
    }
    model = SV_GetModelByIndex(modelindex);
 
    VM_GenerateFrameGroupBlend(prog, ent->priv.server->framegroupblend, ent);
    VM_FrameBlendFromFrameGroupBlend(ent->priv.server->frameblend, ent->priv.server->framegroupblend, model, sv.time);
    VM_UpdateEdictSkeleton(prog, ent, model, ent->priv.server->frameblend);
 
// set the abs box
 
    if (PRVM_serveredictfloat(ent, movetype) == MOVETYPE_PHYSICS)
    {
        // TODO maybe should do this for rotating SOLID_BSP too? Would behave better with rotating doors
        // TODO special handling for spheres?
        VectorCopy(PRVM_serveredictvector(ent, mins), entmins);
        VectorCopy(PRVM_serveredictvector(ent, maxs), entmaxs);
        VectorCopy(PRVM_serveredictvector(ent, angles), entangles);
        RotateBBox(entmins, entmaxs, entangles, mins, maxs);
        VectorAdd(PRVM_serveredictvector(ent, origin), mins, mins);
        VectorAdd(PRVM_serveredictvector(ent, origin), maxs, maxs);
    }
    else if (PRVM_serveredictfloat(ent, solid) == SOLID_BSP)
    {
        if (model != NULL)
        {
            if (!model->TraceBox)
                Con_DPrintf("edict %i: SOLID_BSP with non-collidable model\n", PRVM_NUM_FOR_EDICT(ent));
 
            if (PRVM_serveredictvector(ent, angles)[0] || PRVM_serveredictvector(ent, angles)[2] || PRVM_serveredictvector(ent, avelocity)[0] || PRVM_serveredictvector(ent, avelocity)[2])
            {
                VectorAdd(PRVM_serveredictvector(ent, origin), model->rotatedmins, mins);
                VectorAdd(PRVM_serveredictvector(ent, origin), model->rotatedmaxs, maxs);
            }
            else if (PRVM_serveredictvector(ent, angles)[1] || PRVM_serveredictvector(ent, avelocity)[1])
            {
                VectorAdd(PRVM_serveredictvector(ent, origin), model->yawmins, mins);
                VectorAdd(PRVM_serveredictvector(ent, origin), model->yawmaxs, maxs);
            }
            else
            {
                VectorAdd(PRVM_serveredictvector(ent, origin), model->normalmins, mins);
                VectorAdd(PRVM_serveredictvector(ent, origin), model->normalmaxs, maxs);
            }
        }
        else
        {
            // SOLID_BSP with no model is valid, mainly because some QC setup code does so temporarily
            VectorAdd(PRVM_serveredictvector(ent, origin), PRVM_serveredictvector(ent, mins), mins);
            VectorAdd(PRVM_serveredictvector(ent, origin), PRVM_serveredictvector(ent, maxs), maxs);
        }
    }
    else
    {
        VectorAdd(PRVM_serveredictvector(ent, origin), PRVM_serveredictvector(ent, mins), mins);
        VectorAdd(PRVM_serveredictvector(ent, origin), PRVM_serveredictvector(ent, maxs), maxs);
    }
 
    if (sv_legacy_bbox_expand.integer)
    {
        if ((int)PRVM_serveredictfloat(ent, flags) & FL_ITEM)
        {
            // to make items easier to pick up and allow them to be grabbed off
            // of shelves, the abs sizes are expanded
            mins[0] -= 15;
            mins[1] -= 15;
            mins[2] -= 1;
            maxs[0] += 15;
            maxs[1] += 15;
            maxs[2] += 1;
        }
        else
        {
            // because movement is clipped an epsilon away from an actual edge,
            // we must fully check even when bounding boxes don't quite touch
            mins[0] -= 1;
            mins[1] -= 1;
            mins[2] -= 1;
            maxs[0] += 1;
            maxs[1] += 1;
            maxs[2] += 1;
        }
    }
 
    VectorCopy(mins, PRVM_serveredictvector(ent, absmin));
    VectorCopy(maxs, PRVM_serveredictvector(ent, absmax));
 
    World_LinkEdict(&sv.world, ent, mins, maxs, sv_areagrid_link_SOLID_NOT.integer);
}

References absmax, absmin, angles, avelocity, Con_DPrintf(), Con_Printf(), prvm_prog_t::edicts, FL_ITEM, flags, prvm_edict_t::free, int(), cvar_t::integer, MAX_MODELS, maxs, mins, model, modelindex, movetype, MOVETYPE_PHYSICS, NULL, origin, prvm_edict_t::priv, PRVM_NUM_FOR_EDICT, PRVM_serveredictfloat, PRVM_serveredictvector, RotateBBox(), prvm_edict_t::server, solid, SOLID_BSP, sv, sv_areagrid_link_SOLID_NOT, SV_GetModelByIndex(), sv_legacy_bbox_expand, SVVM_prog, server_t::time, VectorAdd, VectorCopy, VM_FrameBlendFromFrameGroupBlend(), VM_GenerateFrameGroupBlend(), VM_UpdateEdictSkeleton(), server_t::world, and World_LinkEdict().

Referenced by PRVM_ED_LoadFromFile(), SetMinMaxSize(), SV_Ent_Create_f(), SV_Loadgame_f(), SV_movestep(), SV_Physics_ClientEntity(), SV_Physics_Entity(), SV_Physics_Follow(), SV_Physics_Step(), SV_PushEntity(), SV_PushMove(), SV_StepDirection(), SV_WalkMove(), SVVM_end_increase_edicts(), VM_nudgeoutofsolid(), VM_SV_copyentity(), VM_SV_droptofloor(), and VM_SV_setorigin().

SV_LinkEdict_TouchAreaGrid()

void SV_LinkEdict_TouchAreaGrid

(

prvm_edict_t *

ent

)

Definition at line 727 of file sv_phys.c.

{
    prvm_prog_t *prog = SVVM_prog;
    int i, numtouchedicts, old_self, old_other;
    prvm_edict_t *touch;
    static prvm_edict_t *touchedicts[MAX_EDICTS];
 
    if (ent == prog->edicts)
        return;     // don't add the world
 
    if (ent->free)
        return;
 
    if (PRVM_serveredictfloat(ent, solid) == SOLID_NOT)
        return;
 
    // build a list of edicts to touch, because the link loop can be corrupted
    // by IncreaseEdicts called during touch functions
    numtouchedicts = SV_EntitiesInBox(ent->priv.server->areamins, ent->priv.server->areamaxs, MAX_EDICTS, touchedicts);
    if (numtouchedicts > MAX_EDICTS)
    {
        // this never happens
        Con_Printf("SV_EntitiesInBox returned %i edicts, max was %i\n", numtouchedicts, MAX_EDICTS);
        numtouchedicts = MAX_EDICTS;
    }
 
    old_self = PRVM_serverglobaledict(self);
    old_other = PRVM_serverglobaledict(other);
    for (i = 0;i < numtouchedicts;i++)
    {
        touch = touchedicts[i];
        if (touch != ent && (int)PRVM_serveredictfloat(touch, solid) == SOLID_TRIGGER && PRVM_serveredictfunction(touch, touch))
        {
            SV_LinkEdict_TouchAreaGrid_Call(touch, ent);
        }
    }
    PRVM_serverglobaledict(self) = old_self;
    PRVM_serverglobaledict(other) = old_other;
}

References Con_Printf(), prvm_prog_t::edicts, prvm_edict_t::free, i, MAX_EDICTS, other, prvm_edict_t::priv, PRVM_serveredictfloat, PRVM_serveredictfunction, PRVM_serverglobaledict, self, prvm_edict_t::server, solid, SOLID_NOT, SOLID_TRIGGER, SV_EntitiesInBox(), SV_LinkEdict_TouchAreaGrid_Call(), and SVVM_prog.

Referenced by SV_movestep(), SV_Physics(), SV_Physics_ClientEntity(), SV_Physics_Entity(), SV_Physics_Step(), SV_PushEntity(), SV_PushMove(), SV_StepDirection(), and SV_WalkMove().

SV_LinkEdict_TouchAreaGrid_Call()

void SV_LinkEdict_TouchAreaGrid_Call	(	prvm_edict_t *	touch,
		prvm_edict_t *	ent )

Definition at line 705 of file sv_phys.c.

{
    prvm_prog_t *prog = SVVM_prog;
    PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(touch);
    PRVM_serverglobaledict(other) = PRVM_EDICT_TO_PROG(ent);
    PRVM_serverglobalfloat(time) = sv.time;
    PRVM_serverglobalfloat(trace_allsolid) = false;
    PRVM_serverglobalfloat(trace_startsolid) = false;
    PRVM_serverglobalfloat(trace_fraction) = 1;
    PRVM_serverglobalfloat(trace_inwater) = false;
    PRVM_serverglobalfloat(trace_inopen) = true;
    VectorCopy (PRVM_serveredictvector(touch, origin), PRVM_serverglobalvector(trace_endpos));
    VectorSet (PRVM_serverglobalvector(trace_plane_normal), 0, 0, 1);
    PRVM_serverglobalfloat(trace_plane_dist) = 0;
    PRVM_serverglobaledict(trace_ent) = PRVM_EDICT_TO_PROG(ent);
    PRVM_serverglobalfloat(trace_dpstartcontents) = 0;
    PRVM_serverglobalfloat(trace_dphitcontents) = 0;
    PRVM_serverglobalfloat(trace_dphitq3surfaceflags) = 0;
    PRVM_serverglobalstring(trace_dphittexturename) = 0;
    prog->ExecuteProgram(prog, PRVM_serveredictfunction(touch, touch), "QC function self.touch is missing");
}

References prvm_prog_t::ExecuteProgram, origin, other, PRVM_EDICT_TO_PROG, PRVM_serveredictfunction, PRVM_serveredictvector, PRVM_serverglobaledict, PRVM_serverglobalfloat, PRVM_serverglobalstring, PRVM_serverglobalvector, self, sv, SVVM_prog, server_t::time, time, trace_allsolid, trace_dphitcontents, trace_dphitq3surfaceflags, trace_dphittexturename, trace_dpstartcontents, trace_endpos, trace_ent, trace_fraction, trace_inopen, trace_inwater, trace_plane_dist, trace_plane_normal, trace_startsolid, VectorCopy, and VectorSet.

Referenced by SV_LinkEdict_TouchAreaGrid().

SV_Loadgame_f()

void SV_Loadgame_f

(

cmd_state_t *

cmd

)

Definition at line 240 of file sv_save.c.

{
    prvm_prog_t *prog = SVVM_prog;
    char filename[MAX_QPATH];
    char mapname[MAX_QPATH];
    float time;
    const char *start;
    const char *end;
    const char *t;
    char *text;
    prvm_edict_t *ent;
    int i, k, numbuffers;
    int entnum;
    int version;
    float spawn_parms[NUM_SPAWN_PARMS];
    prvm_stringbuffer_t *stringbuffer;
 
    if (Cmd_Argc(cmd) != 2)
    {
        Con_Print("load <savename> : load a game\n");
        return;
    }
 
    dp_strlcpy (filename, Cmd_Argv(cmd, 1), sizeof(filename));
    FS_DefaultExtension (filename, ".sav", sizeof (filename));
 
    Con_Printf("Loading game from %s...\n", filename);
 
    if(host.hook.Disconnect)
        host.hook.Disconnect(false, NULL);
 
    if(host.hook.ToggleMenu)
        host.hook.ToggleMenu();
 
    cls.demonum = -1;       // stop demo loop in case this fails
 
    t = text = (char *)FS_LoadFile (filename, tempmempool, false, NULL);
    if (!text)
    {
        Con_Print(CON_ERROR "ERROR: couldn't open.\n");
        return;
    }
 
    if(developer_entityparsing.integer)
        Con_Printf("SV_Loadgame_f: loading version\n");
 
    // version
    COM_ParseToken_Simple(&t, false, false, true);
    version = atoi(com_token);
    if (version != SAVEGAME_VERSION)
    {
        Mem_Free(text);
        Con_Printf(CON_ERROR "Savegame is version %i, not %i\n", version, SAVEGAME_VERSION);
        return;
    }
 
    if(developer_entityparsing.integer)
        Con_Printf("SV_Loadgame_f: loading description\n");
 
    // description
    COM_ParseToken_Simple(&t, false, false, true);
 
    for (i = 0;i < NUM_SPAWN_PARMS;i++)
    {
        COM_ParseToken_Simple(&t, false, false, true);
        spawn_parms[i] = atof(com_token);
    }
    // skill
    COM_ParseToken_Simple(&t, false, false, true);
// this silliness is so we can load 1.06 save files, which have float skill values
    current_skill = (int)(atof(com_token) + 0.5);
    Cvar_SetValueQuick(&skill, (float)current_skill);
 
    if(developer_entityparsing.integer)
        Con_Printf("SV_Loadgame_f: loading mapname\n");
 
    // mapname
    COM_ParseToken_Simple(&t, false, false, true);
    dp_strlcpy (mapname, com_token, sizeof(mapname));
 
    if(developer_entityparsing.integer)
        Con_Printf("SV_Loadgame_f: loading time\n");
 
    // time
    COM_ParseToken_Simple(&t, false, false, true);
    time = atof(com_token);
 
    if(developer_entityparsing.integer)
        Con_Printf("SV_Loadgame_f: spawning server\n");
 
    SV_SpawnServer (mapname);
    if (!sv.active)
    {
        Mem_Free(text);
        Con_Printf(CON_ERROR "Couldn't load map \"%s\"\n", mapname);
        return;
    }
    sv.paused = true;       // pause until all clients connect
    sv.loadgame = true;
 
    if(developer_entityparsing.integer)
        Con_Printf("SV_Loadgame_f: loading light styles\n");
 
// load the light styles
 
    // -1 is the globals
    entnum = -1;
 
    for (i = 0;i < MAX_LIGHTSTYLES;i++)
    {
        // light style
        start = t;
        COM_ParseToken_Simple(&t, false, false, true);
        // if this is a 64 lightstyle savegame produced by Quake, stop now
        // we have to check this because darkplaces may save more than 64
        if (com_token[0] == '{')
        {
            t = start;
            break;
        }
        dp_strlcpy(sv.lightstyles[i], com_token, sizeof(sv.lightstyles[i]));
    }
 
    if(developer_entityparsing.integer)
        Con_Printf("SV_Loadgame_f: skipping until globals\n");
 
    // now skip everything before the first opening brace
    // (this is for forward compatibility, so that older versions (at
    // least ones with this fix) can load savegames with extra data before the
    // first brace, as might be produced by a later engine version)
    for (;;)
    {
        start = t;
        if (!COM_ParseToken_Simple(&t, false, false, true))
            break;
        if (com_token[0] == '{')
        {
            t = start;
            break;
        }
    }
 
    // unlink all entities
    World_UnlinkAll(&sv.world);
 
// load the edicts out of the savegame file
    end = t;
    for (;;)
    {
        start = t;
        while (COM_ParseToken_Simple(&t, false, false, true))
            if (!strcmp(com_token, "}"))
                break;
        if (!COM_ParseToken_Simple(&start, false, false, true))
        {
            // end of file
            break;
        }
        if (strcmp(com_token,"{"))
        {
            Mem_Free(text);
            Host_Error ("%s: first token isn't a brace", __func__);
        }
 
        if (entnum == -1)
        {
            if(developer_entityparsing.integer)
                Con_Printf("SV_Loadgame_f: loading globals\n");
 
            // parse the global vars
            PRVM_ED_ParseGlobals (prog, start);
 
            // restore the autocvar globals
            Cvar_UpdateAllAutoCvars(prog->console_cmd->cvars);
        }
        else
        {
            // parse an edict
            if (entnum >= MAX_EDICTS)
            {
                Mem_Free(text);
                Host_Error("%s: too many edicts in save file (reached MAX_EDICTS %i)", __func__, MAX_EDICTS);
            }
            while (entnum >= prog->max_edicts)
                PRVM_MEM_IncreaseEdicts(prog);
            ent = PRVM_EDICT_NUM(entnum);
            memset(ent->fields.fp, 0, prog->entityfields * sizeof(prvm_vec_t));
            ent->free = false;
 
            if(developer_entityparsing.integer)
                Con_Printf("SV_Loadgame_f: loading edict %d\n", entnum);
 
            PRVM_ED_ParseEdict (prog, start, ent, true);
 
            // link it into the bsp tree
            if (!ent->free)
                SV_LinkEdict(ent);
        }
 
        end = t;
        entnum++;
    }
 
    prog->num_edicts = entnum;
    sv.time = time;
 
    for (i = 0;i < NUM_SPAWN_PARMS;i++)
        svs.clients[0].spawn_parms[i] = spawn_parms[i];
 
    if(developer_entityparsing.integer)
        Con_Printf("SV_Loadgame_f: skipping until extended data\n");
 
    // read extended data if present
    // the extended data is stored inside a /* */ comment block, which the
    // parser intentionally skips, so we have to check for it manually here
    if(end)
    {
        while (*end == '\r' || *end == '\n')
            end++;
        if (end[0] == '/' && end[1] == '*' && (end[2] == '\r' || end[2] == '\n'))
        {
            if(developer_entityparsing.integer)
                Con_Printf("SV_Loadgame_f: loading extended data\n");
 
            Con_Printf("Loading extended DarkPlaces savegame\n");
            t = end + 2;
            memset(sv.lightstyles[0], 0, sizeof(sv.lightstyles));
            memset(sv.model_precache[0], 0, sizeof(sv.model_precache));
            memset(sv.sound_precache[0], 0, sizeof(sv.sound_precache));
            BufStr_Flush(prog);
 
            while (COM_ParseToken_Simple(&t, false, false, true))
            {
                if (!strcmp(com_token, "sv.lightstyles"))
                {
                    COM_ParseToken_Simple(&t, false, false, true);
                    i = atoi(com_token);
                    COM_ParseToken_Simple(&t, false, false, true);
                    if (i >= 0 && i < MAX_LIGHTSTYLES)
                        dp_strlcpy(sv.lightstyles[i], com_token, sizeof(sv.lightstyles[i]));
                    else
                        Con_Printf(CON_WARN "unsupported lightstyle %i \"%s\"\n", i, com_token);
                }
                else if (!strcmp(com_token, "sv.model_precache"))
                {
                    COM_ParseToken_Simple(&t, false, false, true);
                    i = atoi(com_token);
                    COM_ParseToken_Simple(&t, false, false, true);
                    if (i >= 0 && i < MAX_MODELS)
                    {
                        dp_strlcpy(sv.model_precache[i], com_token, sizeof(sv.model_precache[i]));
                        sv.models[i] = Mod_ForName (sv.model_precache[i], true, false, sv.model_precache[i][0] == '*' ? sv.worldname : NULL);
                    }
                    else
                        Con_Printf(CON_WARN "unsupported model %i \"%s\"\n", i, com_token);
                }
                else if (!strcmp(com_token, "sv.sound_precache"))
                {
                    COM_ParseToken_Simple(&t, false, false, true);
                    i = atoi(com_token);
                    COM_ParseToken_Simple(&t, false, false, true);
                    if (i >= 0 && i < MAX_SOUNDS)
                        dp_strlcpy(sv.sound_precache[i], com_token, sizeof(sv.sound_precache[i]));
                    else
                        Con_Printf(CON_WARN "unsupported sound %i \"%s\"\n", i, com_token);
                }
                else if (!strcmp(com_token, "sv.buffer"))
                {
                    if (COM_ParseToken_Simple(&t, false, false, true))
                    {
                        i = atoi(com_token);
                        if (i >= 0)
                        {
                            k = STRINGBUFFER_SAVED;
                            if (COM_ParseToken_Simple(&t, false, false, true))
                                k |= atoi(com_token);
                            if (!BufStr_FindCreateReplace(prog, i, k, "string"))
                                Con_Printf(CON_ERROR "failed to create stringbuffer %i\n", i);
                        }
                        else
                            Con_Printf(CON_WARN "unsupported stringbuffer index %i \"%s\"\n", i, com_token);
                    }
                    else
                        Con_Printf(CON_WARN "unexpected end of line when parsing sv.buffer (expected buffer index)\n");
                }
                else if (!strcmp(com_token, "sv.bufstr"))
                {
                    if (!COM_ParseToken_Simple(&t, false, false, true))
                        Con_Printf(CON_WARN "unexpected end of line when parsing sv.bufstr\n");
                    else
                    {
                        i = atoi(com_token);
                        stringbuffer = BufStr_FindCreateReplace(prog, i, STRINGBUFFER_SAVED, "string");
                        if (stringbuffer)
                        {
                            if (COM_ParseToken_Simple(&t, false, false, true))
                            {
                                k = atoi(com_token);
                                if (COM_ParseToken_Simple(&t, false, false, true))
                                    BufStr_Set(prog, stringbuffer, k, com_token);
                                else
                                    Con_Printf(CON_WARN "unexpected end of line when parsing sv.bufstr (expected string)\n");
                            }
                            else
                                Con_Printf(CON_WARN "unexpected end of line when parsing sv.bufstr (expected strindex)\n");
                        }
                        else
                            Con_Printf(CON_ERROR "failed to create stringbuffer %i \"%s\"\n", i, com_token);
                    }
                }   
                // skip any trailing text or unrecognized commands
                while (COM_ParseToken_Simple(&t, true, false, true) && strcmp(com_token, "\n"))
                    ;
            }
        }
    }
    Mem_Free(text);
 
    // remove all temporary flagged string buffers (ones created with BufStr_FindCreateReplace)
    numbuffers = (int)Mem_ExpandableArray_IndexRange(&prog->stringbuffersarray);
    for (i = 0; i < numbuffers; i++)
    {
        if ( (stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, i)) )
            if (stringbuffer->flags & STRINGBUFFER_TEMP)
                BufStr_Del(prog, stringbuffer);
    }
 
    if(developer_entityparsing.integer)
        Con_Printf("SV_Loadgame_f: finished\n");
 
    // make sure we're connected to loopback
    if(sv.active && host.hook.ConnectLocal)
        host.hook.ConnectLocal();
}

References server_t::active, BufStr_Del(), BufStr_FindCreateReplace(), BufStr_Flush(), BufStr_Set(), server_static_t::clients, cls, cmd(), Cmd_Argc(), Cmd_Argv(), COM_ParseToken_Simple(), com_token, CON_ERROR, Con_Print(), Con_Printf(), CON_WARN, host_static_t::ConnectLocal, prvm_prog_t::console_cmd, current_skill, Cvar_SetValueQuick(), Cvar_UpdateAllAutoCvars(), client_static_t::demonum, developer_entityparsing, host_static_t::Disconnect, dp_strlcpy, prvm_prog_t::entityfields, entnum, prvm_edict_t::fields, prvm_stringbuffer_t::flags, prvm_edict_t::fp, prvm_edict_t::free, FS_DefaultExtension(), FS_LoadFile(), host_static_t::hook, host, Host_Error(), i, int(), cvar_t::integer, server_t::lightstyles, server_t::loadgame, mapname, MAX_EDICTS, prvm_prog_t::max_edicts, MAX_LIGHTSTYLES, MAX_MODELS, MAX_QPATH, MAX_SOUNDS, Mem_ExpandableArray_IndexRange(), Mem_ExpandableArray_RecordAtIndex(), Mem_Free, Mod_ForName(), server_t::model_precache, server_t::models, NULL, prvm_prog_t::num_edicts, NUM_SPAWN_PARMS, server_t::paused, PRVM_ED_ParseEdict(), PRVM_ED_ParseGlobals(), PRVM_EDICT_NUM, PRVM_MEM_IncreaseEdicts(), SAVEGAME_VERSION, skill, server_t::sound_precache, STRINGBUFFER_SAVED, STRINGBUFFER_TEMP, prvm_prog_t::stringbuffersarray, sv, SV_LinkEdict(), SV_SpawnServer(), svs, SVVM_prog, tempmempool, server_t::time, time, host_static_t::ToggleMenu, version, server_t::world, World_UnlinkAll(), and server_t::worldname.

Referenced by SV_InitOperatorCommands().

SV_MarkWriteEntityStateToClient()

void SV_MarkWriteEntityStateToClient	(	entity_state_t *	s,
		client_t *	client )

Definition at line 863 of file sv_send.c.

{
    prvm_prog_t *prog = SVVM_prog;
    int isbmodel;
    model_t *model;
    prvm_edict_t *ed;
    if (sv.sententitiesconsideration[s->number] == sv.sententitiesmark)
        return;
    sv.sententitiesconsideration[s->number] = sv.sententitiesmark;
    sv.writeentitiestoclient_stats_totalentities++;
 
    if (s->customizeentityforclient)
    {
        PRVM_serverglobalfloat(time) = sv.time;
        PRVM_serverglobaledict(self) = s->number;
        PRVM_serverglobaledict(other) = sv.writeentitiestoclient_cliententitynumber;
        prog->ExecuteProgram(prog, s->customizeentityforclient, "customizeentityforclient: NULL function");
        if(!PRVM_G_FLOAT(OFS_RETURN) || !SV_PrepareEntityForSending(PRVM_EDICT_NUM(s->number), s, s->number))
            return;
    }
 
    // never reject player
    if (s->number != sv.writeentitiestoclient_cliententitynumber)
    {
        // check various rejection conditions
        if (s->nodrawtoclient == sv.writeentitiestoclient_cliententitynumber)
            return;
        if (s->drawonlytoclient && s->drawonlytoclient != sv.writeentitiestoclient_cliententitynumber)
            return;
        if (s->effects & EF_NODRAW)
            return;
        // LadyHavoc: only send entities with a model or important effects
        if (!s->modelindex && s->specialvisibilityradius == 0)
            return;
 
        isbmodel = (model = SV_GetModelByIndex(s->modelindex)) != NULL && model->name[0] == '*';
        // viewmodels don't have visibility checking
        if (s->viewmodelforclient)
        {
            if (s->viewmodelforclient != sv.writeentitiestoclient_cliententitynumber)
                return;
        }
        else if (s->tagentity)
        {
            // tag attached entities simply check their parent
            if (!sv.sendentitiesindex[s->tagentity])
                return;
            SV_MarkWriteEntityStateToClient(sv.sendentitiesindex[s->tagentity], client);
            if (sv.sententities[s->tagentity] != sv.sententitiesmark)
                return;
        }
        // always send world submodels in newer protocols because they don't
        // generate much traffic (in old protocols they hog bandwidth)
        // but only if sv_cullentities_nevercullbmodels is off
        else if (!(s->effects & EF_NODEPTHTEST) && (!isbmodel || !sv_cullentities_nevercullbmodels.integer || sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE))
        {
            // entity has survived every check so far, check if visible
            ed = PRVM_EDICT_NUM(s->number);
 
            // if not touching a visible leaf
            if (sv_cullentities_pvs.integer && !r_novis.integer && !r_trippy.integer && sv.writeentitiestoclient_pvs)
            {
                if (ed->priv.server->pvs_numclusters < 0)
                {
                    // entity too big for clusters list
                    if (sv.worldmodel && sv.worldmodel->brush.BoxTouchingPVS && !sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, sv.writeentitiestoclient_pvs, ed->priv.server->cullmins, ed->priv.server->cullmaxs))
                    {
                        sv.writeentitiestoclient_stats_culled_pvs++;
                        return;
                    }
                }
                else
                {
                    int i;
                    // check cached clusters list
                    for (i = 0;i < ed->priv.server->pvs_numclusters;i++)
                        if (CHECKPVSBIT(sv.writeentitiestoclient_pvs, ed->priv.server->pvs_clusterlist[i]))
                            break;
                    if (i == ed->priv.server->pvs_numclusters)
                    {
                        sv.writeentitiestoclient_stats_culled_pvs++;
                        return;
                    }
                }
            }
 
            // or not seen by random tracelines
            if (sv_cullentities_trace.integer && !isbmodel && sv.worldmodel && sv.worldmodel->brush.TraceLineOfSight && !r_trippy.integer && (client->frags != -666 || sv_cullentities_trace_spectators.integer))
            {
                int samples =
                    s->number <= svs.maxclients
                        ? sv_cullentities_trace_samples_players.integer
                        :
                    s->specialvisibilityradius
                        ? sv_cullentities_trace_samples_extra.integer
                        : sv_cullentities_trace_samples.integer;
 
                if(samples > 0)
                {
                    int eyeindex;
                    for (eyeindex = 0;eyeindex < sv.writeentitiestoclient_numeyes;eyeindex++)
                        if(SV_CanSeeBox(samples, sv_cullentities_trace_eyejitter.value, sv_cullentities_trace_enlarge.value, sv_cullentities_trace_expand.value, sv.writeentitiestoclient_eyes[eyeindex], ed->priv.server->cullmins, ed->priv.server->cullmaxs))
                            break;
                    if(eyeindex < sv.writeentitiestoclient_numeyes)
                        svs.clients[sv.writeentitiestoclient_clientnumber].visibletime[s->number] =
                            host.realtime + (
                                s->number <= svs.maxclients
                                    ? sv_cullentities_trace_delay_players.value
                                    : sv_cullentities_trace_delay.value
                            );
                    else if ((float)host.realtime > svs.clients[sv.writeentitiestoclient_clientnumber].visibletime[s->number])
                    {
                        sv.writeentitiestoclient_stats_culled_trace++;
                        return;
                    }
                }
            }
        }
    }
 
    // this just marks it for sending
    // FIXME: it would be more efficient to send here, but the entity
    // compressor isn't that flexible
    sv.writeentitiestoclient_stats_visibleentities++;
    sv.sententities[s->number] = sv.sententitiesmark;
}

References CHECKPVSBIT, server_static_t::clients, entity_state_t::customizeentityforclient, entity_state_t::drawonlytoclient, EF_NODEPTHTEST, EF_NODRAW, entity_state_t::effects, prvm_prog_t::ExecuteProgram, client_t::frags, host, i, cvar_t::integer, server_static_t::maxclients, model, entity_state_t::modelindex, entity_state_t::nodrawtoclient, NULL, entity_state_t::number, OFS_RETURN, other, prvm_edict_t::priv, server_t::protocol, PROTOCOL_NEHAHRAMOVIE, PROTOCOL_QUAKE, PROTOCOL_QUAKEDP, PRVM_EDICT_NUM, PRVM_G_FLOAT, PRVM_serverglobaledict, PRVM_serverglobalfloat, r_novis, r_trippy, host_static_t::realtime, samples, self, server_t::sendentitiesindex, server_t::sententities, server_t::sententitiesconsideration, server_t::sententitiesmark, prvm_edict_t::server, entity_state_t::specialvisibilityradius, sv, SV_CanSeeBox(), sv_cullentities_nevercullbmodels, sv_cullentities_pvs, sv_cullentities_trace, sv_cullentities_trace_delay, sv_cullentities_trace_delay_players, sv_cullentities_trace_enlarge, sv_cullentities_trace_expand, sv_cullentities_trace_eyejitter, sv_cullentities_trace_samples, sv_cullentities_trace_samples_extra, sv_cullentities_trace_samples_players, sv_cullentities_trace_spectators, SV_GetModelByIndex(), SV_MarkWriteEntityStateToClient(), SV_PrepareEntityForSending(), svs, SVVM_prog, entity_state_t::tagentity, server_t::time, time, cvar_t::value, entity_state_t::viewmodelforclient, server_t::worldmodel, server_t::writeentitiestoclient_cliententitynumber, server_t::writeentitiestoclient_clientnumber, server_t::writeentitiestoclient_eyes, server_t::writeentitiestoclient_numeyes, server_t::writeentitiestoclient_pvs, server_t::writeentitiestoclient_stats_culled_pvs, server_t::writeentitiestoclient_stats_culled_trace, server_t::writeentitiestoclient_stats_totalentities, and server_t::writeentitiestoclient_stats_visibleentities.

Referenced by SV_MarkWriteEntityStateToClient(), and SV_WriteEntitiesToClient().

SV_ModelIndex()

int SV_ModelIndex	(	const char *	s,
		int	precachemode )

Definition at line 1411 of file sv_main.c.

{
    int i, limit = ((sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE) ? 256 : MAX_MODELS);
    char filename[MAX_QPATH];
    if (!s || !*s)
        return 0;
    // testing
    //if (precachemode == 2)
    //  return 0;
    dp_strlcpy(filename, s, sizeof(filename));
    for (i = 2;i < limit;i++)
    {
        if (!sv.model_precache[i][0])
        {
            if (precachemode)
            {
                if (sv.state != ss_loading && (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3 || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4 || sv.protocol == PROTOCOL_DARKPLACES5))
                {
                    Con_Printf("SV_ModelIndex(\"%s\"): precache_model can only be done in spawn functions\n", filename);
                    return 0;
                }
                if (precachemode == 1)
                    Con_Printf("SV_ModelIndex(\"%s\"): not precached (fix your code), precaching anyway\n", filename);
                dp_strlcpy(sv.model_precache[i], filename, sizeof(sv.model_precache[i]));
                if (sv.state == ss_loading)
                {
                    // running from SV_SpawnServer which is launched from the client console command interpreter
                    sv.models[i] = Mod_ForName (sv.model_precache[i], true, false, s[0] == '*' ? sv.worldname : NULL);
                }
                else
                {
                    if (svs.threaded)
                    {
                        // this is running on the server thread, we can't load a model here (it would crash on renderer calls), so only look it up, the svc_precache will cause it to be loaded when it reaches the client
                        sv.models[i] = Mod_FindName (sv.model_precache[i], s[0] == '*' ? sv.worldname : NULL);
                    }
                    else
                    {
                        // running single threaded, so we can load the model here
                        sv.models[i] = Mod_ForName (sv.model_precache[i], true, false, s[0] == '*' ? sv.worldname : NULL);
                    }
                    MSG_WriteByte(&sv.reliable_datagram, svc_precache);
                    MSG_WriteShort(&sv.reliable_datagram, i);
                    MSG_WriteString(&sv.reliable_datagram, filename);
                }
                return i;
            }
            Con_Printf("SV_ModelIndex(\"%s\"): not precached\n", filename);
            return 0;
        }
        if (!strcmp(sv.model_precache[i], filename))
            return i;
    }
    Con_Printf("SV_ModelIndex(\"%s\"): i (%i) == MAX_MODELS (%i)\n", filename, i, MAX_MODELS);
    return 0;
}

References Con_Printf(), dp_strlcpy, i, MAX_MODELS, MAX_QPATH, Mod_FindName(), Mod_ForName(), server_t::model_precache, server_t::models, MSG_WriteByte(), MSG_WriteShort(), MSG_WriteString(), NULL, server_t::protocol, PROTOCOL_DARKPLACES1, PROTOCOL_DARKPLACES2, PROTOCOL_DARKPLACES3, PROTOCOL_DARKPLACES4, PROTOCOL_DARKPLACES5, PROTOCOL_NEHAHRABJP, PROTOCOL_NEHAHRABJP2, PROTOCOL_NEHAHRABJP3, PROTOCOL_NEHAHRAMOVIE, PROTOCOL_QUAKE, PROTOCOL_QUAKEDP, server_t::reliable_datagram, ss_loading, server_t::state, sv, svc_precache, svs, server_static_t::threaded, and server_t::worldname.

Referenced by SV_CreateBaseline(), SV_WriteClientdataToMessage(), VM_SV_effect(), VM_SV_precache_model(), and VM_SV_setmodel().

SV_movestep()

qbool SV_movestep	(	prvm_edict_t *	ent,
		vec3_t	move,
		qbool	relink,
		qbool	noenemy,
		qbool	settrace )

Definition at line 109 of file sv_move.c.

{
    prvm_prog_t *prog = SVVM_prog;
    float       dz;
    vec3_t      oldorg, neworg, end, traceendpos, entorigin, entmins, entmaxs;
    trace_t     trace;
    int         i;
    prvm_edict_t        *enemy;
 
// try the move
    VectorCopy (PRVM_serveredictvector(ent, origin), oldorg);
    VectorAdd (PRVM_serveredictvector(ent, origin), move, neworg);
    VectorCopy(PRVM_serveredictvector(ent, mins), entmins);
    VectorCopy(PRVM_serveredictvector(ent, maxs), entmaxs);
 
// flying monsters don't step up
    if ( (int)PRVM_serveredictfloat(ent, flags) & (FL_SWIM | FL_FLY) )
    {
    // try one move with vertical motion, then one without
        for (i=0 ; i<2 ; i++)
        {
            VectorAdd (PRVM_serveredictvector(ent, origin), move, neworg);
            if (noenemy)
                enemy = prog->edicts;
            else
            {
                enemy = PRVM_PROG_TO_EDICT(PRVM_serveredictedict(ent, enemy));
                if (i == 0 && enemy != prog->edicts)
                {
                    dz = PRVM_serveredictvector(ent, origin)[2] - PRVM_serveredictvector(enemy, origin)[2];
                    if (dz > 40)
                        neworg[2] -= 8;
                    if (dz < 30)
                        neworg[2] += 8;
                }
            }
            VectorCopy(PRVM_serveredictvector(ent, origin), entorigin);
            trace = SV_TraceBox(entorigin, entmins, entmaxs, neworg, MOVE_NORMAL, ent, SV_GenericHitSuperContentsMask(ent), 0, 0, collision_extendmovelength.value);
 
            if (trace.fraction == 1)
            {
                VectorCopy(trace.endpos, traceendpos);
                if (((int)PRVM_serveredictfloat(ent, flags) & FL_SWIM) && !(SV_PointSuperContents(traceendpos) & SUPERCONTENTS_LIQUIDSMASK))
                    return false;   // swim monster left water
 
                VectorCopy (traceendpos, PRVM_serveredictvector(ent, origin));
                if (relink)
                {
                    SV_LinkEdict(ent);
                    SV_LinkEdict_TouchAreaGrid(ent);
                }
                return true;
            }
 
            if (enemy == prog->edicts)
                break;
        }
 
        return false;
    }
 
// push down from a step height above the wished position
    neworg[2] += sv_stepheight.value;
    VectorCopy (neworg, end);
    end[2] -= sv_stepheight.value*2;
 
    trace = SV_TraceBox(neworg, entmins, entmaxs, end, MOVE_NORMAL, ent, SV_GenericHitSuperContentsMask(ent), 0, 0, collision_extendmovelength.value);
 
    if (trace.startsolid)
    {
        neworg[2] -= sv_stepheight.value;
        trace = SV_TraceBox(neworg, entmins, entmaxs, end, MOVE_NORMAL, ent, SV_GenericHitSuperContentsMask(ent), 0, 0, collision_extendmovelength.value);
        if (trace.startsolid)
            return false;
    }
    if (trace.fraction == 1)
    {
    // if monster had the ground pulled out, go ahead and fall
        if ( (int)PRVM_serveredictfloat(ent, flags) & FL_PARTIALGROUND )
        {
            VectorAdd (PRVM_serveredictvector(ent, origin), move, PRVM_serveredictvector(ent, origin));
            if (relink)
            {
                SV_LinkEdict(ent);
                SV_LinkEdict_TouchAreaGrid(ent);
            }
            PRVM_serveredictfloat(ent, flags) = (int)PRVM_serveredictfloat(ent, flags) & ~FL_ONGROUND;
            return true;
        }
 
        return false;       // walked off an edge
    }
 
// check point traces down for dangling corners
    VectorCopy (trace.endpos, PRVM_serveredictvector(ent, origin));
 
    if (!SV_CheckBottom (ent))
    {
        if ( (int)PRVM_serveredictfloat(ent, flags) & FL_PARTIALGROUND )
        {   // entity had floor mostly pulled out from underneath it
            // and is trying to correct
            if (relink)
            {
                SV_LinkEdict(ent);
                SV_LinkEdict_TouchAreaGrid(ent);
            }
            return true;
        }
        VectorCopy (oldorg, PRVM_serveredictvector(ent, origin));
        return false;
    }
 
    if ( (int)PRVM_serveredictfloat(ent, flags) & FL_PARTIALGROUND )
        PRVM_serveredictfloat(ent, flags) = (int)PRVM_serveredictfloat(ent, flags) & ~FL_PARTIALGROUND;
 
// gameplayfix: check if reached pretty steep plane and bail
    if ( ! ( (int)PRVM_serveredictfloat(ent, flags) & (FL_SWIM | FL_FLY) ) && sv_gameplayfix_nostepmoveonsteepslopes.integer )
    {
        if (trace.plane.normal[ 2 ] < 0.5)
        {
            VectorCopy (oldorg, PRVM_serveredictvector(ent, origin));
            return false;
        }
    }
 
    PRVM_serveredictedict(ent, groundentity) = PRVM_EDICT_TO_PROG(trace.ent);
 
// the move is ok
    if (relink)
    {
        SV_LinkEdict(ent);
        SV_LinkEdict_TouchAreaGrid(ent);
    }
    return true;
}

References collision_extendmovelength, prvm_prog_t::edicts, trace_t::endpos, enemy, trace_t::ent, FL_FLY, FL_PARTIALGROUND, FL_SWIM, flags, trace_t::fraction, groundentity, i, int(), cvar_t::integer, maxs, mins, MOVE_NORMAL, plane_t::normal, origin, trace_t::plane, PRVM_EDICT_TO_PROG, PRVM_PROG_TO_EDICT, PRVM_serveredictedict, PRVM_serveredictfloat, PRVM_serveredictvector, trace_t::startsolid, SUPERCONTENTS_LIQUIDSMASK, SV_CheckBottom(), sv_gameplayfix_nostepmoveonsteepslopes, SV_GenericHitSuperContentsMask(), SV_LinkEdict(), SV_LinkEdict_TouchAreaGrid(), SV_PointSuperContents(), sv_stepheight, SV_TraceBox(), SVVM_prog, cvar_t::value, VectorAdd, and VectorCopy.

Referenced by SV_StepDirection(), and VM_SV_walkmove().

SV_Name()

void SV_Name

(

int

clientnum

)

Definition at line 868 of file sv_ccmds.c.

{
    prvm_prog_t *prog = SVVM_prog;
    PRVM_serveredictstring(host_client->edict, netname) = PRVM_SetEngineString(prog, host_client->name);
    if (strcmp(host_client->old_name, host_client->name))
    {
        if (host_client->begun && host_client->netconnection)
            SV_BroadcastPrintf("\003%s ^7changed name to ^3%s\n", host_client->old_name, host_client->name);
        dp_strlcpy(host_client->old_name, host_client->name, sizeof(host_client->old_name));
        // send notification to all clients
        MSG_WriteByte (&sv.reliable_datagram, svc_updatename);
        MSG_WriteByte (&sv.reliable_datagram, clientnum);
        MSG_WriteString (&sv.reliable_datagram, host_client->name);
        SV_WriteNetnameIntoDemo(host_client);
    }   
}

References client_t::begun, dp_strlcpy, client_t::edict, host_client, MSG_WriteByte(), MSG_WriteString(), client_t::name, client_t::netconnection, netname, client_t::old_name, PRVM_serveredictstring, PRVM_SetEngineString(), server_t::reliable_datagram, sv, SV_BroadcastPrintf(), SV_WriteNetnameIntoDemo(), svc_updatename, and SVVM_prog.

Referenced by SV_Name_f(), and SV_UpdateToReliableMessages().

SV_ParticleEffectIndex()

int SV_ParticleEffectIndex

(

const char *

name

)

Definition at line 1522 of file sv_main.c.

{
    int i, argc, linenumber, effectnameindex;
    int filepass;
    fs_offset_t filesize;
    unsigned char *filedata;
    const char *text;
    const char *textstart;
    //const char *textend;
    char argv[16][1024];
    char filename[MAX_QPATH];
    if (!sv.particleeffectnamesloaded)
    {
        sv.particleeffectnamesloaded = true;
        memset(sv.particleeffectname, 0, sizeof(sv.particleeffectname));
        for (i = 0;i < EFFECT_TOTAL;i++)
            dp_strlcpy(sv.particleeffectname[i], standardeffectnames[i], sizeof(sv.particleeffectname[i]));
        for (filepass = 0;;filepass++)
        {
            if (filepass == 0)
                dpsnprintf(filename, sizeof(filename), "effectinfo.txt");
            else if (filepass == 1)
                dpsnprintf(filename, sizeof(filename), "%s_effectinfo.txt", sv.worldnamenoextension);
            else
                break;
            filedata = FS_LoadFile(filename, tempmempool, true, &filesize);
            if (!filedata)
                continue;
            textstart = (const char *)filedata;
            //textend = (const char *)filedata + filesize;
            text = textstart;
            for (linenumber = 1;;linenumber++)
            {
                argc = 0;
                for (;;)
                {
                    if (!COM_ParseToken_Simple(&text, true, false, true) || !strcmp(com_token, "\n"))
                        break;
                    if (argc < 16)
                    {
                        dp_strlcpy(argv[argc], com_token, sizeof(argv[argc]));
                        argc++;
                    }
                }
                if (com_token[0] == 0)
                    break; // if the loop exited and it's not a \n, it's EOF
                if (argc < 1)
                    continue;
                if (!strcmp(argv[0], "effect"))
                {
                    if (argc == 2)
                    {
                        for (effectnameindex = 1;effectnameindex < MAX_PARTICLEEFFECTNAME;effectnameindex++)
                        {
                            if (sv.particleeffectname[effectnameindex][0])
                            {
                                if (!strcmp(sv.particleeffectname[effectnameindex], argv[1]))
                                    break;
                            }
                            else
                            {
                                dp_strlcpy(sv.particleeffectname[effectnameindex], argv[1], sizeof(sv.particleeffectname[effectnameindex]));
                                break;
                            }
                        }
                        // if we run out of names, abort
                        if (effectnameindex == MAX_PARTICLEEFFECTNAME)
                        {
                            Con_Printf("%s:%i: too many effects!\n", filename, linenumber);
                            break;
                        }
                    }
                }
            }
            Mem_Free(filedata);
        }
    }
    // search for the name
    for (effectnameindex = 1;effectnameindex < MAX_PARTICLEEFFECTNAME && sv.particleeffectname[effectnameindex][0];effectnameindex++)
        if (!strcmp(sv.particleeffectname[effectnameindex], name))
            return effectnameindex;
    // return 0 if we couldn't find it
    return 0;
}

References argv(), COM_ParseToken_Simple(), com_token, Con_Printf(), dp_strlcpy, dpsnprintf(), EFFECT_TOTAL, FS_LoadFile(), i, MAX_PARTICLEEFFECTNAME, MAX_QPATH, Mem_Free, name, server_t::particleeffectname, server_t::particleeffectnamesloaded, standardeffectnames, sv, tempmempool, and server_t::worldnamenoextension.

Referenced by VM_SV_particleeffectnum().

SV_Physics()

void SV_Physics

(

void

)

Definition at line 3013 of file sv_phys.c.

{
    prvm_prog_t *prog = SVVM_prog;
    int i;
    prvm_edict_t *ent;
 
    // free memory for resources that are no longer referenced
    PRVM_GarbageCollection(prog);
 
// let the progs know that a new frame has started
    PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(prog->edicts);
    PRVM_serverglobaledict(other) = PRVM_EDICT_TO_PROG(prog->edicts);
    PRVM_serverglobalfloat(time) = sv.time;
    PRVM_serverglobalfloat(frametime) = sv.frametime;
    prog->ExecuteProgram(prog, PRVM_serverfunction(StartFrame), "QC function StartFrame is missing");
 
#ifdef USEODE
    // run physics engine
    World_Physics_Frame(&sv.world, sv.frametime, sv_gravity.value);
#endif
 
//
// treat each object in turn
//
 
    // if force_retouch, relink all the entities
    if (PRVM_serverglobalfloat(force_retouch) > 0)
        for (i = 1, ent = PRVM_EDICT_NUM(i);i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
            if (!ent->free)
                SV_LinkEdict_TouchAreaGrid(ent); // force retouch even for stationary
 
    if (sv_gameplayfix_consistentplayerprethink.integer)
    {
        // run physics on the client entities in 3 stages
        for (i = 1, ent = PRVM_EDICT_NUM(i), host_client = svs.clients;i <= svs.maxclients;i++, ent = PRVM_NEXT_EDICT(ent), host_client++)
            if (!ent->free)
                SV_Physics_ClientEntity_PreThink(ent);
 
        for (i = 1, ent = PRVM_EDICT_NUM(i), host_client = svs.clients;i <= svs.maxclients;i++, ent = PRVM_NEXT_EDICT(ent), host_client++)
            if (!ent->free)
                SV_Physics_ClientEntity(ent);
 
        for (i = 1, ent = PRVM_EDICT_NUM(i), host_client = svs.clients;i <= svs.maxclients;i++, ent = PRVM_NEXT_EDICT(ent), host_client++)
            if (!ent->free)
                SV_Physics_ClientEntity_PostThink(ent);
    }
    else
    {
        // run physics on the client entities
        for (i = 1, ent = PRVM_EDICT_NUM(i), host_client = svs.clients;i <= svs.maxclients;i++, ent = PRVM_NEXT_EDICT(ent), host_client++)
        {
            if (!ent->free)
            {
                SV_Physics_ClientEntity_PreThink(ent);
                SV_Physics_ClientEntity(ent);
                SV_Physics_ClientEntity_PostThink(ent);
            }
        }
    }
 
    // run physics on all the non-client entities
    if (!sv_freezenonclients.integer)
    {
        for (;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
            if (!ent->free)
                SV_Physics_Entity(ent);
        // make a second pass to see if any ents spawned this frame and make
        // sure they run their move/think
        if (sv_gameplayfix_delayprojectiles.integer < 0)
            for (i = svs.maxclients + 1, ent = PRVM_EDICT_NUM(i);i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
                if (!ent->priv.server->move && !ent->free)
                    SV_Physics_Entity(ent);
    }
 
    if (PRVM_serverglobalfloat(force_retouch) > 0)
        PRVM_serverglobalfloat(force_retouch) = max(0, PRVM_serverglobalfloat(force_retouch) - 1);
 
    // LadyHavoc: endframe support
    if (PRVM_serverfunction(EndFrame))
    {
        PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(prog->edicts);
        PRVM_serverglobaledict(other) = PRVM_EDICT_TO_PROG(prog->edicts);
        PRVM_serverglobalfloat(time) = sv.time;
        prog->ExecuteProgram(prog, PRVM_serverfunction(EndFrame), "QC function EndFrame is missing");
    }
 
    // decrement prog->num_edicts if the highest number entities died
    for (;PRVM_ED_CanAlloc(prog, PRVM_EDICT_NUM(prog->num_edicts - 1));prog->num_edicts--);
 
    if (!sv_freezenonclients.integer)
        sv.time += sv.frametime;
}

References server_static_t::clients, prvm_prog_t::edicts, prvm_prog_t::ExecuteProgram, force_retouch, frametime, server_t::frametime, prvm_edict_t::free, host_client, i, cvar_t::integer, max, server_static_t::maxclients, prvm_prog_t::num_edicts, other, PRVM_ED_CanAlloc(), PRVM_EDICT_NUM, PRVM_EDICT_TO_PROG, PRVM_GarbageCollection(), PRVM_NEXT_EDICT, PRVM_serverfunction, PRVM_serverglobaledict, PRVM_serverglobalfloat, self, sv, sv_freezenonclients, sv_gameplayfix_consistentplayerprethink, sv_gameplayfix_delayprojectiles, sv_gravity, SV_LinkEdict_TouchAreaGrid(), SV_Physics_ClientEntity(), SV_Physics_ClientEntity_PostThink(), SV_Physics_ClientEntity_PreThink(), SV_Physics_Entity(), svs, SVVM_prog, server_t::time, time, cvar_t::value, server_t::world, and World_Physics_Frame().

Referenced by SV_Frame(), SV_SpawnServer(), and SV_ThreadFunc().

SV_Physics_ClientMove()

void SV_Physics_ClientMove

(

void

)

Definition at line 2810 of file sv_phys.c.

{
    prvm_prog_t *prog = SVVM_prog;
    prvm_edict_t *ent;
    ent = host_client->edict;
 
    // call player physics, this needs the proper frametime
    PRVM_serverglobalfloat(frametime) = sv.frametime;
    SV_PlayerPhysics();
 
    // call standard client pre-think, with frametime = 0
    PRVM_serverglobalfloat(time) = sv.time;
    PRVM_serverglobalfloat(frametime) = 0;
    PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(ent);
    prog->ExecuteProgram(prog, PRVM_serverfunction(PlayerPreThink), "QC function PlayerPreThink is missing");
    PRVM_serverglobalfloat(frametime) = sv.frametime;
 
    // make sure the velocity is sane (not a NaN)
    SV_CheckVelocity(ent);
 
    // perform movetype behaviour
    // note: will always be MOVETYPE_WALK if disableclientprediction = 0
    SV_Physics_ClientEntity_NoThink (ent);
 
    // call standard player post-think, with frametime = 0
    PRVM_serverglobalfloat(time) = sv.time;
    PRVM_serverglobalfloat(frametime) = 0;
    PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(ent);
    prog->ExecuteProgram(prog, PRVM_serverfunction(PlayerPostThink), "QC function PlayerPostThink is missing");
    PRVM_serverglobalfloat(frametime) = sv.frametime;
 
    if(PRVM_serveredictfloat(ent, fixangle))
    {
        // angle fixing was requested by physics code...
        // so store the current angles for later use
        VectorCopy(PRVM_serveredictvector(ent, angles), host_client->fixangle_angles);
        host_client->fixangle_angles_set = true;
 
        // and clear fixangle for the next frame
        PRVM_serveredictfloat(ent, fixangle) = 0;
    }
}

References angles, client_t::edict, prvm_prog_t::ExecuteProgram, fixangle, client_t::fixangle_angles, client_t::fixangle_angles_set, frametime, server_t::frametime, host_client, PRVM_EDICT_TO_PROG, PRVM_serveredictfloat, PRVM_serveredictvector, PRVM_serverfunction, PRVM_serverglobaledict, PRVM_serverglobalfloat, self, sv, SV_CheckVelocity(), SV_Physics_ClientEntity_NoThink(), SV_PlayerPhysics(), SVVM_prog, server_t::time, time, and VectorCopy.

Referenced by SV_ExecuteClientMoves().

SV_PlayerCheckGround()

qbool SV_PlayerCheckGround

(

prvm_edict_t *

ent

)

SV_PlayerPhysics()

void SV_PlayerPhysics

(

void

)

Definition at line 571 of file sv_user.c.

{
    prvm_prog_t *prog = SVVM_prog;
    vec3_t v_angle, angles, velocity;
 
    //Con_Printf("clientthink for %ims\n", (int) (sv.frametime * 1000));
 
    SV_ApplyClientMove();
    // make sure the velocity is sane (not a NaN)
    SV_CheckVelocity(host_client->edict);
 
    // LadyHavoc: QuakeC replacement for SV_PlayerPhysics (player movement)
    if (PRVM_serverfunction(SV_PlayerPhysics) && sv_playerphysicsqc.integer)
    {
        PRVM_serverglobalfloat(time) = sv.time;
        PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(host_client->edict);
        prog->ExecuteProgram(prog, PRVM_serverfunction(SV_PlayerPhysics), "QC function SV_PlayerPhysics is missing");
        SV_CheckVelocity(host_client->edict);
        return;
    }
 
    if (PRVM_serveredictfloat(host_client->edict, movetype) == MOVETYPE_NONE)
        return;
 
    onground = ((int)PRVM_serveredictfloat(host_client->edict, flags) & FL_ONGROUND) != 0;
 
    DropPunchAngle ();
 
    // if dead, behave differently
    if (PRVM_serveredictfloat(host_client->edict, health) <= 0)
        return;
 
    usercmd = host_client->cmd;
 
    // angles
    // show 1/3 the pitch angle and all the roll angle
    VectorAdd (PRVM_serveredictvector(host_client->edict, v_angle), PRVM_serveredictvector(host_client->edict, punchangle), v_angle);
    VectorCopy(PRVM_serveredictvector(host_client->edict, angles), angles);
    VectorCopy(PRVM_serveredictvector(host_client->edict, velocity), velocity);
    PRVM_serveredictvector(host_client->edict, angles)[ROLL] = Com_CalcRoll (angles, velocity, sv_rollangle.value, sv_rollspeed.value)*4;
    if (!PRVM_serveredictfloat(host_client->edict, fixangle))
    {
        PRVM_serveredictvector(host_client->edict, angles)[PITCH] = -v_angle[PITCH]/3;
        PRVM_serveredictvector(host_client->edict, angles)[YAW] = v_angle[YAW];
    }
 
    if ( (int)PRVM_serveredictfloat(host_client->edict, flags) & FL_WATERJUMP )
    {
        SV_WaterJump ();
        SV_CheckVelocity(host_client->edict);
        return;
    }
 
    // walk
    if ((PRVM_serveredictfloat(host_client->edict, waterlevel) >= 2) && (PRVM_serveredictfloat(host_client->edict, movetype) != MOVETYPE_NOCLIP))
    {
        SV_WaterMove ();
        SV_CheckVelocity(host_client->edict);
        return;
    }
 
    SV_AirMove ();
    SV_CheckVelocity(host_client->edict);
}

References angles, client_t::cmd, Com_CalcRoll(), DropPunchAngle(), client_t::edict, prvm_prog_t::ExecuteProgram, fixangle, FL_ONGROUND, FL_WATERJUMP, flags, health, host_client, int(), cvar_t::integer, movetype, MOVETYPE_NOCLIP, MOVETYPE_NONE, onground, PITCH, PRVM_EDICT_TO_PROG, PRVM_serveredictfloat, PRVM_serveredictvector, PRVM_serverfunction, PRVM_serverglobaledict, PRVM_serverglobalfloat, punchangle, ROLL, self, sv, SV_AirMove(), SV_ApplyClientMove(), SV_CheckVelocity(), SV_PlayerPhysics(), sv_playerphysicsqc, sv_rollangle, sv_rollspeed, SV_WaterJump(), SV_WaterMove(), SVVM_prog, server_t::time, time, usercmd, v_angle, cvar_t::value, VectorAdd, VectorCopy, velocity, waterlevel, and YAW.

Referenced by SV_Physics_ClientEntity_PreThink(), SV_Physics_ClientMove(), and SV_PlayerPhysics().

SV_PointSuperContents()

int SV_PointSuperContents

(

const vec3_t

point

)

Definition at line 611 of file sv_phys.c.

{
    prvm_prog_t *prog = SVVM_prog;
    int supercontents = 0;
    int i;
    prvm_edict_t *touch;
    vec3_t transformed;
    // matrices to transform into/out of other entity's space
    matrix4x4_t matrix, imatrix;
    // model of other entity
    model_t *model;
    int frame;
    // list of entities to test for collisions
    int numtouchedicts;
    static prvm_edict_t *touchedicts[MAX_EDICTS];
 
    // get world supercontents at this point
    if (sv.worldmodel && sv.worldmodel->PointSuperContents)
        supercontents = sv.worldmodel->PointSuperContents(sv.worldmodel, 0, point);
 
    // if sv_gameplayfix_swiminbmodels is off we're done
    if (!sv_gameplayfix_swiminbmodels.integer)
        return supercontents;
 
    // get list of entities at this point
    numtouchedicts = SV_EntitiesInBox(point, point, MAX_EDICTS, touchedicts);
    if (numtouchedicts > MAX_EDICTS)
    {
        // this never happens
        Con_Printf("SV_EntitiesInBox returned %i edicts, max was %i\n", numtouchedicts, MAX_EDICTS);
        numtouchedicts = MAX_EDICTS;
    }
    for (i = 0;i < numtouchedicts;i++)
    {
        touch = touchedicts[i];
 
        // we only care about SOLID_BSP for pointcontents
        if (PRVM_serveredictfloat(touch, solid) != SOLID_BSP)
            continue;
 
        // might interact, so do an exact clip
        model = SV_GetModelFromEdict(touch);
        if (!model || !model->PointSuperContents)
            continue;
        Matrix4x4_CreateFromQuakeEntity(&matrix, PRVM_serveredictvector(touch, origin)[0], PRVM_serveredictvector(touch, origin)[1], PRVM_serveredictvector(touch, origin)[2], PRVM_serveredictvector(touch, angles)[0], PRVM_serveredictvector(touch, angles)[1], PRVM_serveredictvector(touch, angles)[2], 1);
        Matrix4x4_Invert_Simple(&imatrix, &matrix);
        Matrix4x4_Transform(&imatrix, point, transformed);
        frame = (int)PRVM_serveredictfloat(touch, frame);
        supercontents |= model->PointSuperContents(model, bound(0, frame, (model->numframes - 1)), transformed);
    }
 
    return supercontents;
}

References angles, bound, Con_Printf(), frame, i, int(), cvar_t::integer, Matrix4x4_CreateFromQuakeEntity(), Matrix4x4_Invert_Simple(), Matrix4x4_Transform(), MAX_EDICTS, model, origin, PRVM_serveredictfloat, PRVM_serveredictvector, solid, SOLID_BSP, sv, SV_EntitiesInBox(), sv_gameplayfix_swiminbmodels, SV_GetModelFromEdict(), SVVM_prog, and server_t::worldmodel.

Referenced by PHYS_TestEntityPosition(), SV_CheckBottom(), SV_CheckWater(), SV_CheckWaterTransition(), SV_movestep(), and VM_SV_pointcontents().

SV_PreSpawn_f()

void SV_PreSpawn_f

(

cmd_state_t *

cmd

)

Definition at line 36 of file sv_user.c.

{
    if (host_client->prespawned)
    {
        Con_Print("prespawn not valid -- already prespawned\n");
        return;
    }
    host_client->prespawned = true;
 
    if (host_client->netconnection)
    {
        SZ_Write (&host_client->netconnection->message, sv.signon.data, sv.signon.cursize);
        MSG_WriteByte (&host_client->netconnection->message, svc_signonnum);
        MSG_WriteByte (&host_client->netconnection->message, 2);
        host_client->sendsignon = 0;        // enable unlimited sends again
    }
 
    // reset the name change timer because the client will send name soon
    host_client->nametime = 0;
}

References Con_Print(), sizebuf_t::cursize, sizebuf_t::data, host_client, netconn_t::message, MSG_WriteByte(), client_t::nametime, client_t::netconnection, client_t::prespawned, client_t::sendsignon, server_t::signon, sv, svc_signonnum, and SZ_Write().

Referenced by SV_InitOperatorCommands().

SV_ReadClientMessage()

void SV_ReadClientMessage

(

void

)

Definition at line 985 of file sv_user.c.

{
    prvm_prog_t *prog = SVVM_prog;
    int netcmd, num, start;
    char *s, *p, *q;
    size_t slen;
 
    if(sv_autodemo_perclient.integer >= 2)
        SV_WriteDemoMessage(host_client, &(host_client->netconnection->message), true);
 
    //MSG_BeginReading ();
    sv_numreadmoves = 0;
 
    for(;;)
    {
        if (!host_client->active)
        {
            // a command caused an error
            SV_DropClient (false, "Connection closing");
            return;
        }
 
        if (sv_message.badread)
        {
            Con_Print("SV_ReadClientMessage: badread\n");
            SV_DropClient (false, "An internal server error occurred");
            return;
        }
 
        netcmd = MSG_ReadByte(&sv_message);
        if (netcmd == -1)
        {
            // end of message
            // apply the moves that were read this frame
            SV_ExecuteClientMoves();
            break;
        }
 
        switch (netcmd)
        {
        default:
            Con_Printf("SV_ReadClientMessage: unknown command char %i (at offset 0x%x)\n", netcmd, sv_message.readcount);
            if (developer_networking.integer)
                Com_HexDumpToConsole(sv_message.data, sv_message.cursize);
            SV_DropClient (false, "Unknown message sent to the server");
            return;
 
        case clc_nop:
            break;
 
        case clc_stringcmd:
            // allow reliable messages now as the client is done with initial loading
            if (host_client->sendsignon == 2)
                host_client->sendsignon = 0;
            slen = MSG_ReadString_len(&sv_message, sv_readstring, sizeof(sv_readstring));
            s = sv_readstring;
            q = NULL;
            for(p = s; *p; ++p) switch(*p)
            {
                case 10:
                case 13:
                    if(!q)
                        q = p;
                    break;
                default:
                    if(q)
                        goto clc_stringcmd_invalid; // newline seen, THEN something else -> possible exploit
                    break;
            }
            if(q)
                *q = 0;
            if (strncasecmp(s, "spawn", 5) == 0
             || strncasecmp(s, "begin", 5) == 0
             || strncasecmp(s, "prespawn", 8) == 0)
                Cmd_ExecuteString(cmd_serverfromclient, s, slen, src_client, true);
            else if (PRVM_serverfunction(SV_ParseClientCommand))
            {
                int restorevm_tempstringsbuf_cursize;
                restorevm_tempstringsbuf_cursize = prog->tempstringsbuf.cursize;
                PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(prog, s, slen);
                PRVM_serverglobalfloat(time) = sv.time;
                PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(host_client->edict);
                prog->ExecuteProgram(prog, PRVM_serverfunction(SV_ParseClientCommand), "QC function SV_ParseClientCommand is missing");
                prog->tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize;
            }
            else
                Cmd_ExecuteString(cmd_serverfromclient, s, slen, src_client, true);
            break;
 
clc_stringcmd_invalid:
            Con_Printf("Received invalid stringcmd from %s\n", host_client->name);
            if(developer.integer > 0)
                Com_HexDumpToConsole((unsigned char *) s, (int)strlen(s));
            break;
 
        case clc_disconnect:
            SV_DropClient (true, sv.protocol == PROTOCOL_DARKPLACES8
                           ? MSG_ReadString(&sv_message, sv_readstring, sizeof(sv_readstring))
                           : "Disconnect by user"); // client wants to disconnect
            return;
 
        case clc_move:
            SV_ReadClientMove();
            break;
 
        case clc_ackdownloaddata:
            start = MSG_ReadLong(&sv_message);
            num = MSG_ReadShort(&sv_message);
            if (host_client->download_file && host_client->download_started)
            {
                if (host_client->download_expectedposition == start)
                {
                    int size = (int)FS_FileSize(host_client->download_file);
                    // a data block was successfully received by the client,
                    // update the expected position on the next data block
                    host_client->download_expectedposition = start + num;
                    // if this was the last data block of the file, it's done
                    if (host_client->download_expectedposition >= FS_FileSize(host_client->download_file))
                    {
                        // tell the client that the download finished
                        // we need to calculate the crc now
                        //
                        // note: at this point the OS probably has the file
                        // entirely in memory, so this is a faster operation
                        // now than it was when the download started.
                        //
                        // it is also preferable to do this at the end of the
                        // download rather than the start because it reduces
                        // potential for Denial Of Service attacks against the
                        // server.
                        int crc;
                        unsigned char *temp;
                        FS_Seek(host_client->download_file, 0, SEEK_SET);
                        temp = (unsigned char *) Mem_Alloc(tempmempool, size);
                        FS_Read(host_client->download_file, temp, size);
                        crc = CRC_Block(temp, size);
                        Mem_Free(temp);
                        // calculated crc, send the file info to the client
                        // (so that it can verify the data)
                        SV_ClientCommands("\ncl_downloadfinished %i %i %s\n", size, crc, host_client->download_name);
                        Con_DPrintf("Download of %s by %s has finished\n", host_client->download_name, host_client->name);
                        FS_Close(host_client->download_file);
                        host_client->download_file = NULL;
                        host_client->download_name[0] = 0;
                        host_client->download_expectedposition = 0;
                        host_client->download_started = false;
                    }
                }
                else
                {
                    // a data block was lost, reset to the expected position
                    // and resume sending from there
                    FS_Seek(host_client->download_file, host_client->download_expectedposition, SEEK_SET);
                }
            }
            break;
 
        case clc_ackframe:
            if (sv_message.badread) Con_Printf("SV_ReadClientMessage: badread at %s:%i\n", __FILE__, __LINE__);
            num = MSG_ReadLong(&sv_message);
            if (sv_message.badread) Con_Printf("SV_ReadClientMessage: badread at %s:%i\n", __FILE__, __LINE__);
            if (developer_networkentities.integer >= 10)
                Con_Printf("recv clc_ackframe %i\n", num);
            // if the client hasn't progressed through signons yet,
            // ignore any clc_ackframes we get (they're probably from the
            // previous level)
            if (host_client->begun && host_client->latestframenum < num)
            {
                int i;
                for (i = host_client->latestframenum + 1;i < num;i++)
                    if (!SV_FrameLost(i))
                        break;
                SV_FrameAck(num);
                host_client->latestframenum = num;
            }
            break;
        }
    }
}

References client_t::active, sizebuf_t::badread, client_t::begun, clc_ackdownloaddata, clc_ackframe, clc_disconnect, clc_move, clc_nop, clc_stringcmd, Cmd_ExecuteString(), cmd_serverfromclient, Com_HexDumpToConsole(), Con_DPrintf(), Con_Print(), Con_Printf(), CRC_Block(), sizebuf_t::cursize, sizebuf_t::data, developer, developer_networkentities, developer_networking, client_t::download_expectedposition, client_t::download_file, client_t::download_name, client_t::download_started, client_t::edict, prvm_prog_t::ExecuteProgram, FS_Close(), FS_FileSize(), FS_Read(), FS_Seek(), host_client, i, int(), cvar_t::integer, client_t::latestframenum, Mem_Alloc, Mem_Free, netconn_t::message, MSG_ReadByte, MSG_ReadLong, MSG_ReadShort, MSG_ReadString(), MSG_ReadString_len(), client_t::name, client_t::netconnection, NULL, OFS_PARM0, server_t::protocol, PROTOCOL_DARKPLACES8, PRVM_EDICT_TO_PROG, PRVM_G_INT, PRVM_serverfunction, PRVM_serverglobaledict, PRVM_serverglobalfloat, PRVM_SetTempString(), sizebuf_t::readcount, self, client_t::sendsignon, size, src_client, strlen(), sv, sv_autodemo_perclient, SV_ClientCommands(), SV_DropClient(), SV_ExecuteClientMoves(), SV_FrameAck(), SV_FrameLost(), sv_message, sv_numreadmoves, SV_ReadClientMove(), sv_readstring, SV_WriteDemoMessage(), SVVM_prog, tempmempool, prvm_prog_t::tempstringsbuf, server_t::time, and time.

Referenced by NetConn_ServerParsePacket().

SV_Savegame_f()

void SV_Savegame_f

(

cmd_state_t *

cmd

)

Definition at line 188 of file sv_save.c.

{
    prvm_prog_t *prog = SVVM_prog;
    char    name[MAX_QPATH];
 
    if (!sv.active)
    {
        Con_Print(CON_ERROR "Can't save - no server running.\n");
        return;
    }
 
    if (Cmd_Argc(cmd) != 2)
    {
        Con_Print("save <savename> : save a game\n");
        return;
    }
 
    if (strstr(Cmd_Argv(cmd, 1), ".."))
    {
        Con_Print(CON_ERROR "Relative pathnames are not allowed.\n");
        return;
    }
 
    for (int i = 0; i < svs.maxclients; ++i)
        if (svs.clients[i].active && PRVM_serveredictfloat(svs.clients[i].edict, deadflag))
        {
            Con_Print(CON_ERROR "Can't savegame with a dead player\n");
            return;
        }
 
    // bones_was_here: intermission_running isn't declared in dpdefs, but it's used by
    // id1 Quake, all Quake mods (afaict), Nexuiz and Xonotic.
    if (PRVM_serverglobalfloat(intermission_running))
    {
        Con_Print(CON_ERROR "Can't save in intermission.\n");
        return;
    }
 
    if (SV_IsLocalServer() != 1)
        Con_Print(CON_WARN "Warning: saving a multiplayer game may have strange results when restored (to properly resume, all players must join in the same player slots and then the game can be reloaded).\n");
 
    dp_strlcpy (name, Cmd_Argv(cmd, 1), sizeof (name));
    FS_DefaultExtension (name, ".sav", sizeof (name));
 
    SV_Savegame_to(prog, name);
}

References server_t::active, server_static_t::clients, cmd(), Cmd_Argc(), Cmd_Argv(), CON_ERROR, Con_Print(), CON_WARN, deadflag, dp_strlcpy, FS_DefaultExtension(), i, MAX_QPATH, server_static_t::maxclients, name, PRVM_serveredictfloat, PRVM_serverglobalfloat, sv, SV_IsLocalServer(), SV_Savegame_to(), svs, and SVVM_prog.

Referenced by SV_InitOperatorCommands().

SV_Savegame_to()

void SV_Savegame_to	(	prvm_prog_t *	prog,
		const char *	name )

Definition at line 35 of file sv_save.c.

{
    qfile_t *f;
    int     i, k, l, numbuffers, lightstyles = 64;
    char    comment[SAVEGAME_COMMENT_LENGTH+1];
    char    line[MAX_INPUTLINE];
    qbool isserver;
    char    *s;
 
    // first we have to figure out if this can be saved in 64 lightstyles
    // (for Quake compatibility)
    for (i=64 ; i<MAX_LIGHTSTYLES ; i++)
        if (sv.lightstyles[i][0])
            lightstyles = i+1;
 
    isserver = prog == SVVM_prog;
 
    Con_Printf("Saving game to %s...\n", name);
    f = FS_OpenRealFile(name, "wb", false);
    if (!f)
    {
        Con_Print(CON_ERROR "ERROR: couldn't open.\n");
        return;
    }
 
    FS_Printf(f, "%i\n", SAVEGAME_VERSION);
 
    memset(comment, 0, sizeof(comment));
    if(isserver)
        dpsnprintf(comment, sizeof(comment), "%-21.21s kills:%3i/%3i", PRVM_GetString(prog, PRVM_serveredictstring(prog->edicts, message)), (int)PRVM_serverglobalfloat(killed_monsters), (int)PRVM_serverglobalfloat(total_monsters));
    else
        dpsnprintf(comment, sizeof(comment), "(crash dump of %s progs)", prog->name);
    // convert space to _ to make stdio happy
    // LadyHavoc: convert control characters to _ as well
    for (i=0 ; i<SAVEGAME_COMMENT_LENGTH ; i++)
        if (ISWHITESPACEORCONTROL(comment[i]))
            comment[i] = '_';
    comment[SAVEGAME_COMMENT_LENGTH] = '\0';
 
    FS_Printf(f, "%s\n", comment);
    if(isserver)
    {
        for (i=0 ; i<NUM_SPAWN_PARMS ; i++)
            FS_Printf(f, "%f\n", svs.clients[0].spawn_parms[i]);
        FS_Printf(f, "%d\n", current_skill);
        FS_Printf(f, "%s\n", sv.worldbasename);
        FS_Printf(f, "%f\n",sv.time);
    }
    else
    {
        for (i=0 ; i<NUM_SPAWN_PARMS ; i++)
            FS_Printf(f, "(dummy)\n");
        FS_Printf(f, "%d\n", 0);
        FS_Printf(f, "%s\n", "(dummy)");
        FS_Printf(f, "%f\n", host.realtime);
    }
 
    // write the light styles
    for (i=0 ; i<lightstyles ; i++)
    {
        if (isserver && sv.lightstyles[i][0])
            FS_Printf(f, "%s\n", sv.lightstyles[i]);
        else
            FS_Print(f,"m\n");
    }
 
    PRVM_ED_WriteGlobals (prog, f);
    for (i=0 ; i<prog->num_edicts ; i++)
    {
        FS_Printf(f,"// edict %d\n", i);
        //Con_Printf("edict %d...\n", i);
        PRVM_ED_Write (prog, f, PRVM_EDICT_NUM(i));
    }
 
#if 1
    FS_Printf(f,"/*\n");
    FS_Printf(f,"// DarkPlaces extended savegame\n");
    // darkplaces extension - extra lightstyles, support for color lightstyles
    for (i=0 ; i<MAX_LIGHTSTYLES ; i++)
        if (isserver && sv.lightstyles[i][0])
            FS_Printf(f, "sv.lightstyles %i %s\n", i, sv.lightstyles[i]);
 
    // darkplaces extension - model precaches
    for (i=1 ; i<MAX_MODELS ; i++)
        if (sv.model_precache[i][0])
            FS_Printf(f,"sv.model_precache %i %s\n", i, sv.model_precache[i]);
 
    // darkplaces extension - sound precaches
    for (i=1 ; i<MAX_SOUNDS ; i++)
        if (sv.sound_precache[i][0])
            FS_Printf(f,"sv.sound_precache %i %s\n", i, sv.sound_precache[i]);
 
    // darkplaces extension - save buffers
    numbuffers = (int)Mem_ExpandableArray_IndexRange(&prog->stringbuffersarray);
    for (i = 0; i < numbuffers; i++)
    {
        prvm_stringbuffer_t *stringbuffer = (prvm_stringbuffer_t*) Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, i);
        if(stringbuffer && (stringbuffer->flags & STRINGBUFFER_SAVED))
        {
            FS_Printf(f,"sv.buffer %i %i \"string\"\n", i, stringbuffer->flags & STRINGBUFFER_QCFLAGS);
            for(k = 0; k < stringbuffer->num_strings; k++)
            {
                if (!stringbuffer->strings[k])
                    continue;
                // Parse the string a bit to turn special characters
                // (like newline, specifically) into escape codes
                s = stringbuffer->strings[k];
                for (l = 0;l < (int)sizeof(line) - 2 && *s;)
                {   
                    if (*s == '\n')
                    {
                        line[l++] = '\\';
                        line[l++] = 'n';
                    }
                    else if (*s == '\r')
                    {
                        line[l++] = '\\';
                        line[l++] = 'r';
                    }
                    else if (*s == '\\')
                    {
                        line[l++] = '\\';
                        line[l++] = '\\';
                    }
                    else if (*s == '"')
                    {
                        line[l++] = '\\';
                        line[l++] = '"';
                    }
                    else
                        line[l++] = *s;
                    s++;
                }
                line[l] = '\0';
                FS_Printf(f,"sv.bufstr %i %i \"%s\"\n", i, k, line);
            }
        }
    }
    FS_Printf(f,"*/\n");
#endif
 
    FS_Close (f);
#ifdef __EMSCRIPTEN__
    js_syncFS(false);
#endif
    Con_Print("done.\n");
}

References server_static_t::clients, CON_ERROR, Con_Print(), Con_Printf(), current_skill, dpsnprintf(), prvm_prog_t::edicts, f, prvm_stringbuffer_t::flags, FS_Close(), FS_OpenRealFile(), FS_Print(), FS_Printf(), host, i, int(), isserver(), ISWHITESPACEORCONTROL, killed_monsters, server_t::lightstyles, MAX_INPUTLINE, MAX_LIGHTSTYLES, MAX_MODELS, MAX_SOUNDS, Mem_ExpandableArray_IndexRange(), Mem_ExpandableArray_RecordAtIndex(), message, server_t::model_precache, name, prvm_prog_t::name, prvm_prog_t::num_edicts, NUM_SPAWN_PARMS, prvm_stringbuffer_t::num_strings, PRVM_ED_Write(), PRVM_ED_WriteGlobals(), PRVM_EDICT_NUM, PRVM_GetString(), PRVM_serveredictstring, PRVM_serverglobalfloat, host_static_t::realtime, SAVEGAME_COMMENT_LENGTH, SAVEGAME_VERSION, server_t::sound_precache, STRINGBUFFER_QCFLAGS, STRINGBUFFER_SAVED, prvm_prog_t::stringbuffersarray, prvm_stringbuffer_t::strings, sv, svs, SVVM_prog, server_t::time, total_monsters, and server_t::worldbasename.

Referenced by PRVM_Breakpoint(), PRVM_Crash(), and SV_Savegame_f().

SV_SaveSpawnparms()

void SV_SaveSpawnparms

(

void

)

Definition at line 1761 of file sv_main.c.

{
    prvm_prog_t *prog = SVVM_prog;
    int     i, j;
 
    svs.serverflags = (int)PRVM_serverglobalfloat(serverflags);
 
    for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
    {
        if (!host_client->active)
            continue;
 
    // call the progs to get default spawn parms for the new client
        PRVM_serverglobalfloat(time) = sv.time;
        PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(host_client->edict);
        prog->ExecuteProgram(prog, PRVM_serverfunction(SetChangeParms), "QC function SetChangeParms is missing");
        for (j=0 ; j<NUM_SPAWN_PARMS ; j++)
            host_client->spawn_parms[j] = (&PRVM_serverglobalfloat(parm1))[j];
    }
}

References client_t::active, server_static_t::clients, client_t::edict, prvm_prog_t::ExecuteProgram, host_client, i, int(), server_static_t::maxclients, NUM_SPAWN_PARMS, parm1, PRVM_EDICT_TO_PROG, PRVM_serverfunction, PRVM_serverglobaledict, PRVM_serverglobalfloat, self, server_static_t::serverflags, serverflags, client_t::spawn_parms, sv, svs, SVVM_prog, server_t::time, and time.

Referenced by SV_Changelevel_f().

SV_SendClientMessages()

void SV_SendClientMessages

(

void

)

Definition at line 1697 of file sv_send.c.

{
    int i, prepared = false;
 
    if (sv.protocol == PROTOCOL_QUAKEWORLD)
        Sys_Error("SV_SendClientMessages: no quakeworld support\n");
 
    SV_FlushBroadcastMessages();
 
// update frags, names, etc
    SV_UpdateToReliableMessages();
 
// build individual updates
    for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
    {
        if (!host_client->active)
            continue;
        if (!host_client->netconnection)
            continue;
 
        if (host_client->netconnection->message.overflowed)
        {
            SV_DropClient (true, "Buffer overflow in net message"); // if the message couldn't send, kick off
            continue;
        }
 
        if (!prepared)
        {
            prepared = true;
            // only prepare entities once per frame
            SV_PrepareEntitiesForSending();
        }
        SV_SendClientDatagram(host_client);
    }
 
// clear muzzle flashes
    SV_CleanupEnts();
}

References client_t::active, server_static_t::clients, host_client, i, server_static_t::maxclients, netconn_t::message, client_t::netconnection, sizebuf_t::overflowed, server_t::protocol, PROTOCOL_QUAKEWORLD, sv, SV_CleanupEnts(), SV_DropClient(), SV_FlushBroadcastMessages(), SV_PrepareEntitiesForSending(), SV_SendClientDatagram(), SV_UpdateToReliableMessages(), svs, and Sys_Error().

Referenced by SV_Frame(), and SV_ThreadFunc().

SV_SendServerinfo()

void SV_SendServerinfo

(

client_t *

client

)

Definition at line 749 of file sv_main.c.

{
    prvm_prog_t *prog = SVVM_prog;
    int i;
    char message[128];
    char vabuf[1024];
 
    // we know that this client has a netconnection and thus is not a bot
 
    // edicts get reallocated on level changes, so we need to update it here
    client->edict = PRVM_EDICT_NUM((client - svs.clients) + 1);
 
    // clear cached stuff that depends on the level
    client->weaponmodel[0] = 0;
    client->weaponmodelindex = 0;
 
    // LadyHavoc: clear entityframe tracking
    client->latestframenum = 0;
 
    // initialize the movetime, so a speedhack can't make use of the time before this client joined
    client->cmd.time = sv.time;
 
    if (client->entitydatabase)
        EntityFrame_FreeDatabase(client->entitydatabase);
    if (client->entitydatabase4)
        EntityFrame4_FreeDatabase(client->entitydatabase4);
    if (client->entitydatabase5)
        EntityFrame5_FreeDatabase(client->entitydatabase5);
 
    memset(client->stats, 0, sizeof(client->stats));
    memset(client->statsdeltabits, 0, sizeof(client->statsdeltabits));
 
    if (sv.protocol != PROTOCOL_QUAKE && sv.protocol != PROTOCOL_QUAKEDP && sv.protocol != PROTOCOL_NEHAHRAMOVIE && sv.protocol != PROTOCOL_NEHAHRABJP && sv.protocol != PROTOCOL_NEHAHRABJP2 && sv.protocol != PROTOCOL_NEHAHRABJP3)
    {
        if (sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3)
            client->entitydatabase = EntityFrame_AllocDatabase(sv_mempool);
        else if (sv.protocol == PROTOCOL_DARKPLACES4)
            client->entitydatabase4 = EntityFrame4_AllocDatabase(sv_mempool);
        else
            client->entitydatabase5 = EntityFrame5_AllocDatabase(sv_mempool);
    }
 
    // reset csqc entity versions
    for (i = 0;i < prog->max_edicts;i++)
    {
        client->csqcentityscope[i] = 0;
        client->csqcentitysendflags[i] = 0xFFFFFF;
    }
    for (i = 0;i < NUM_CSQCENTITYDB_FRAMES;i++)
    {
        client->csqcentityframehistory[i].num = 0;
        client->csqcentityframehistory[i].framenum = -1;
    }
    client->csqcnumedicts = 0;
    client->csqcentityframehistory_next = 0;
 
    SZ_Clear (&client->netconnection->message);
    MSG_WriteByte (&client->netconnection->message, svc_print);
    dpsnprintf (message, sizeof (message), "\nServer: %s (progs %i crc)\n", engineversion, prog->filecrc);
    MSG_WriteString (&client->netconnection->message,message);
 
    SV_StopDemoRecording(client); // to split up demos into different files
    if(sv_autodemo_perclient.integer)
    {
        char demofile[MAX_OSPATH];
        char ipaddress[MAX_QPATH];
        char timestring[128];
        size_t j;
 
        // start a new demo file
        LHNETADDRESS_ToString(&(client->netconnection->peeraddress), ipaddress, sizeof(ipaddress), true);
        for(j = 0; ipaddress[j]; ++j)
            if(!isalnum(ipaddress[j]))
                ipaddress[j] = '-';
        Sys_TimeString(timestring, sizeof(timestring), sv_autodemo_perclient_nameformat.string);
        dpsnprintf(demofile, sizeof(demofile), "%s_%s_%d_%s.dem", timestring,
                sv.worldbasename, PRVM_NUM_FOR_EDICT(client->edict), ipaddress);
 
        SV_StartDemoRecording(client, demofile, -1);
    }
 
    //[515]: init csprogs according to version of svprogs, check the crc, etc.
    if (sv.csqc_progname[0])
    {
        Con_DPrintf("sending csqc info to client (\"%s\" with size %i and crc %i)\n", sv.csqc_progname, sv.csqc_progsize, sv.csqc_progcrc);
        MSG_WriteByte (&client->netconnection->message, svc_stufftext);
        MSG_WriteString (&client->netconnection->message, va(vabuf, sizeof(vabuf), "csqc_progname %s\n", sv.csqc_progname));
        MSG_WriteByte (&client->netconnection->message, svc_stufftext);
        MSG_WriteString (&client->netconnection->message, va(vabuf, sizeof(vabuf), "csqc_progsize %i\n", sv.csqc_progsize));
        MSG_WriteByte (&client->netconnection->message, svc_stufftext);
        MSG_WriteString (&client->netconnection->message, va(vabuf, sizeof(vabuf), "csqc_progcrc %i\n", sv.csqc_progcrc));
 
        if(client->sv_demo_file != NULL)
        {
            int k;
            static char buf[NET_MAXMESSAGE];
            sizebuf_t sb;
 
            sb.data = (unsigned char *) buf;
            sb.maxsize = sizeof(buf);
            k = 0;
            while(MakeDownloadPacket(sv.csqc_progname, svs.csqc_progdata, sv.csqc_progsize, sv.csqc_progcrc, k++, &sb, sv.protocol))
                SV_WriteDemoMessage(client, &sb, false);
        }
 
        //[515]: init stufftext string (it is sent before svc_serverinfo)
        if (PRVM_GetString(prog, PRVM_serverglobalstring(SV_InitCmd)))
        {
            MSG_WriteByte (&client->netconnection->message, svc_stufftext);
            MSG_WriteString (&client->netconnection->message, va(vabuf, sizeof(vabuf), "%s\n", PRVM_GetString(prog, PRVM_serverglobalstring(SV_InitCmd))));
        }
    }
 
    //if (sv_allowdownloads.integer)
    // always send the info that the server supports the protocol, even if downloads are forbidden
    // only because of that, the CSQC exception can work
    {
        MSG_WriteByte (&client->netconnection->message, svc_stufftext);
        MSG_WriteString (&client->netconnection->message, "cl_serverextension_download 2\n");
    }
 
    // send at this time so it's guaranteed to get executed at the right time
    {
        client_t *save;
        save = host_client;
        host_client = client;
        Curl_SendRequirements();
        host_client = save;
    }
 
    MSG_WriteByte (&client->netconnection->message, svc_serverinfo);
    MSG_WriteLong (&client->netconnection->message, Protocol_NumberForEnum(sv.protocol));
    MSG_WriteByte (&client->netconnection->message, svs.maxclients);
 
    if (!coop.integer && deathmatch.integer)
        MSG_WriteByte (&client->netconnection->message, GAME_DEATHMATCH);
    else
        MSG_WriteByte (&client->netconnection->message, GAME_COOP);
 
    MSG_WriteString (&client->netconnection->message,PRVM_GetString(prog, PRVM_serveredictstring(prog->edicts, message)));
 
    for (i = 1;i < MAX_MODELS && sv.model_precache[i][0];i++)
        MSG_WriteString (&client->netconnection->message, sv.model_precache[i]);
    MSG_WriteByte (&client->netconnection->message, 0);
 
    for (i = 1;i < MAX_SOUNDS && sv.sound_precache[i][0];i++)
        MSG_WriteString (&client->netconnection->message, sv.sound_precache[i]);
    MSG_WriteByte (&client->netconnection->message, 0);
 
// send music
    MSG_WriteByte (&client->netconnection->message, svc_cdtrack);
    MSG_WriteByte (&client->netconnection->message, (int)PRVM_serveredictfloat(prog->edicts, sounds));
    MSG_WriteByte (&client->netconnection->message, (int)PRVM_serveredictfloat(prog->edicts, sounds));
 
// set view
// store this in clientcamera, too
    client->clientcamera = PRVM_NUM_FOR_EDICT(client->edict);
    MSG_WriteByte (&client->netconnection->message, svc_setview);
    MSG_WriteShort (&client->netconnection->message, client->clientcamera);
 
    MSG_WriteByte (&client->netconnection->message, svc_signonnum);
    MSG_WriteByte (&client->netconnection->message, 1);
 
    client->prespawned = false;     // need prespawn, spawn, etc
    client->spawned = false;        // need prespawn, spawn, etc
    client->begun = false;          // need prespawn, spawn, etc
    client->sendsignon = 1;         // send this message, and increment to 2, 2 will be set to 0 by the prespawn command
 
    // clear movement info until client enters the new level properly
    memset(&client->cmd, 0, sizeof(client->cmd));
    client->movesequence = 0;
    client->movement_highestsequence_seen = 0;
    memset(&client->movement_count, 0, sizeof(client->movement_count));
    client->ping = 0;
 
    // allow the client some time to send his keepalives, even if map loading took ages
    client->netconnection->timeout = host.realtime + net_connecttimeout.value;
}

References client_t::begun, buf, client_t::clientcamera, server_static_t::clients, client_t::cmd, Con_DPrintf(), coop, server_t::csqc_progcrc, server_static_t::csqc_progdata, server_t::csqc_progname, server_t::csqc_progsize, client_t::csqcentityframehistory, client_t::csqcentityframehistory_next, client_t::csqcentityscope, client_t::csqcentitysendflags, client_t::csqcnumedicts, Curl_SendRequirements(), sizebuf_t::data, deathmatch, dpsnprintf(), client_t::edict, prvm_prog_t::edicts, engineversion, client_t::entitydatabase, client_t::entitydatabase4, client_t::entitydatabase5, EntityFrame4_AllocDatabase(), EntityFrame4_FreeDatabase(), EntityFrame5_AllocDatabase(), EntityFrame5_FreeDatabase(), EntityFrame_AllocDatabase(), EntityFrame_FreeDatabase(), prvm_prog_t::filecrc, csqcentityframedb_t::framenum, GAME_COOP, GAME_DEATHMATCH, host, host_client, i, cvar_t::integer, client_t::latestframenum, LHNETADDRESS_ToString(), MakeDownloadPacket(), prvm_prog_t::max_edicts, MAX_MODELS, MAX_OSPATH, MAX_QPATH, MAX_SOUNDS, server_static_t::maxclients, sizebuf_t::maxsize, message, netconn_t::message, server_t::model_precache, client_t::movement_count, client_t::movement_highestsequence_seen, client_t::movesequence, MSG_WriteByte(), MSG_WriteLong(), MSG_WriteShort(), MSG_WriteString(), net_connecttimeout, NET_MAXMESSAGE, client_t::netconnection, NULL, csqcentityframedb_t::num, NUM_CSQCENTITYDB_FRAMES, netconn_t::peeraddress, client_t::ping, client_t::prespawned, server_t::protocol, PROTOCOL_DARKPLACES1, PROTOCOL_DARKPLACES2, PROTOCOL_DARKPLACES3, PROTOCOL_DARKPLACES4, PROTOCOL_NEHAHRABJP, PROTOCOL_NEHAHRABJP2, PROTOCOL_NEHAHRABJP3, PROTOCOL_NEHAHRAMOVIE, Protocol_NumberForEnum(), PROTOCOL_QUAKE, PROTOCOL_QUAKEDP, PRVM_EDICT_NUM, PRVM_GetString(), PRVM_NUM_FOR_EDICT, PRVM_serveredictfloat, PRVM_serveredictstring, PRVM_serverglobalstring, host_static_t::realtime, client_t::sendsignon, server_t::sound_precache, sounds, client_t::spawned, client_t::stats, client_t::statsdeltabits, cvar_t::string, sv, sv_autodemo_perclient, sv_autodemo_perclient_nameformat, client_t::sv_demo_file, sv_mempool, SV_StartDemoRecording(), SV_StopDemoRecording(), SV_WriteDemoMessage(), svc_cdtrack, svc_print, svc_serverinfo, svc_setview, svc_signonnum, svc_stufftext, svs, SVVM_prog, Sys_TimeString(), SZ_Clear(), server_t::time, usercmd_t::time, netconn_t::timeout, va(), cvar_t::value, client_t::weaponmodel, client_t::weaponmodelindex, and server_t::worldbasename.

Referenced by NetConn_ServerParsePacket(), SV_ConnectClient(), and SV_SpawnServer().

SV_SetIdealPitch()

void SV_SetIdealPitch

(

void

)

Definition at line 239 of file sv_user.c.

{
    prvm_prog_t *prog = SVVM_prog;
    float   angleval, sinval, cosval, step, dir;
    trace_t tr;
    vec3_t  top, bottom;
    float   z[MAX_FORWARD];
    int     i, j;
    int     steps;
 
    if (!((int)PRVM_serveredictfloat(host_client->edict, flags) & FL_ONGROUND))
        return;
 
    angleval = PRVM_serveredictvector(host_client->edict, angles)[YAW] * M_PI*2 / 360;
    sinval = sin(angleval);
    cosval = cos(angleval);
 
    for (i=0 ; i<MAX_FORWARD ; i++)
    {
        top[0] = PRVM_serveredictvector(host_client->edict, origin)[0] + cosval*(i+3)*12;
        top[1] = PRVM_serveredictvector(host_client->edict, origin)[1] + sinval*(i+3)*12;
        top[2] = PRVM_serveredictvector(host_client->edict, origin)[2] + PRVM_serveredictvector(host_client->edict, view_ofs)[2];
 
        bottom[0] = top[0];
        bottom[1] = top[1];
        bottom[2] = top[2] - 160;
 
        tr = SV_TraceLine(top, bottom, MOVE_NOMONSTERS, host_client->edict, SUPERCONTENTS_SOLID, 0, 0, collision_extendmovelength.value);
        // if looking at a wall, leave ideal the way is was
        if (tr.startsolid)
            return;
 
        // near a dropoff
        if (tr.fraction == 1)
            return;
 
        z[i] = top[2] + tr.fraction*(bottom[2]-top[2]);
    }
 
    dir = 0;
    steps = 0;
    for (j=1 ; j<i ; j++)
    {
        step = z[j] - z[j-1];
        if (step > -ON_EPSILON && step < ON_EPSILON)
            continue;
 
        // mixed changes
        if (dir && ( step-dir > ON_EPSILON || step-dir < -ON_EPSILON ) )
            return;
 
        steps++;
        dir = step;
    }
 
    if (!dir)
    {
        PRVM_serveredictfloat(host_client->edict, idealpitch) = 0;
        return;
    }
 
    if (steps < 2)
        return;
    PRVM_serveredictfloat(host_client->edict, idealpitch) = -dir * sv_idealpitchscale.value;
}

References angles, collision_extendmovelength, cos(), dir, client_t::edict, FL_ONGROUND, flags, trace_t::fraction, host_client, i, idealpitch, M_PI, MAX_FORWARD, MOVE_NOMONSTERS, ON_EPSILON, origin, PRVM_serveredictfloat, PRVM_serveredictvector, sin(), trace_t::startsolid, SUPERCONTENTS_SOLID, sv_idealpitchscale, SV_TraceLine(), SVVM_prog, cvar_t::value, view_ofs, YAW, and z.

Referenced by SV_WriteClientdataToMessage().

SV_SetupVM()

void SV_SetupVM

(

void

)

SV_Shutdown()

void SV_Shutdown

(

void

)

Definition at line 2128 of file sv_main.c.

{
    int i;
 
    SV_LockThreadMutex();
 
    if (!sv.active)
        goto end;
 
    Con_DPrintf("SV_Shutdown\n");
 
    NetConn_Heartbeat(2);
    NetConn_Heartbeat(2);
 
    // make sure all the clients know we're disconnecting
    for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
        if (host_client->active)
            SV_DropClient(false, "Server shutting down"); // server shutdown
 
    SV_VM_Shutdown(true);
 
    NetConn_CloseServerPorts();
 
    sv.active = false;
//
// clear structures
//
    memset(&sv, 0, sizeof(sv));
    memset(svs.clients, 0, svs.maxclients*sizeof(client_t));
end:
    SV_UnlockThreadMutex();
}

References client_t::active, server_t::active, server_static_t::clients, Con_DPrintf(), host_client, i, server_static_t::maxclients, NetConn_CloseServerPorts(), NetConn_Heartbeat(), sv, SV_DropClient(), SV_LockThreadMutex, SV_UnlockThreadMutex, SV_VM_Shutdown(), and svs.

Referenced by PRVM_Crash(), SV_Init(), SV_Map_f(), and SV_VM_Shutdown().

SV_SoundIndex()

int SV_SoundIndex	(	const char *	s,
		int	precachemode )

Definition at line 1474 of file sv_main.c.

{
    int i, limit = ((sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP) ? 256 : MAX_SOUNDS);
    char filename[MAX_QPATH];
    if (!s || !*s)
        return 0;
    // testing
    //if (precachemode == 2)
    //  return 0;
    dp_strlcpy(filename, s, sizeof(filename));
    for (i = 1;i < limit;i++)
    {
        if (!sv.sound_precache[i][0])
        {
            if (precachemode)
            {
                if (sv.state != ss_loading && (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3 || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4 || sv.protocol == PROTOCOL_DARKPLACES5))
                {
                    Con_Printf("SV_SoundIndex(\"%s\"): precache_sound can only be done in spawn functions\n", filename);
                    return 0;
                }
                if (precachemode == 1)
                    Con_Printf("SV_SoundIndex(\"%s\"): not precached (fix your code), precaching anyway\n", filename);
                dp_strlcpy(sv.sound_precache[i], filename, sizeof(sv.sound_precache[i]));
                if (sv.state != ss_loading)
                {
                    MSG_WriteByte(&sv.reliable_datagram, svc_precache);
                    MSG_WriteShort(&sv.reliable_datagram, i + 32768);
                    MSG_WriteString(&sv.reliable_datagram, filename);
                }
                return i;
            }
            Con_Printf("SV_SoundIndex(\"%s\"): not precached\n", filename);
            return 0;
        }
        if (!strcmp(sv.sound_precache[i], filename))
            return i;
    }
    Con_Printf("SV_SoundIndex(\"%s\"): i (%i) == MAX_SOUNDS (%i)\n", filename, i, MAX_SOUNDS);
    return 0;
}

References Con_Printf(), dp_strlcpy, i, MAX_QPATH, MAX_SOUNDS, MSG_WriteByte(), MSG_WriteShort(), MSG_WriteString(), server_t::protocol, PROTOCOL_DARKPLACES1, PROTOCOL_DARKPLACES2, PROTOCOL_DARKPLACES3, PROTOCOL_DARKPLACES4, PROTOCOL_DARKPLACES5, PROTOCOL_NEHAHRABJP, PROTOCOL_NEHAHRABJP2, PROTOCOL_NEHAHRABJP3, PROTOCOL_NEHAHRAMOVIE, PROTOCOL_QUAKE, PROTOCOL_QUAKEDP, server_t::reliable_datagram, server_t::sound_precache, ss_loading, server_t::state, sv, and svc_precache.

Referenced by SV_StartPointSound(), SV_StartSound(), VM_SV_ambientsound(), and VM_SV_precache_sound().

SV_Spawn_f()

void SV_Spawn_f

(

cmd_state_t *

cmd

)

Definition at line 62 of file sv_user.c.

{
    prvm_prog_t *prog = SVVM_prog;
    int i;
    client_t *client;
    int stats[MAX_CL_STATS];
 
    if (!host_client->prespawned)
    {
        Con_Print("Spawn not valid -- not yet prespawned\n");
        return;
    }
    if (host_client->spawned)
    {
        Con_Print("Spawn not valid -- already spawned\n");
        return;
    }
    host_client->spawned = true;
 
    // reset name change timer again because they might want to change name
    // again in the first 5 seconds after connecting
    host_client->nametime = 0;
 
    // LadyHavoc: moved this above the QC calls at FrikaC's request
    // LadyHavoc: commented this out
    //if (host_client->netconnection)
    //  SZ_Clear (&host_client->netconnection->message);
 
    // run the entrance script
    if (sv.loadgame)
    {
        // loaded games are fully initialized already
        if (PRVM_serverfunction(RestoreGame))
        {
            Con_DPrint("Calling RestoreGame\n");
            PRVM_serverglobalfloat(time) = sv.time;
            PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(host_client->edict);
            prog->ExecuteProgram(prog, PRVM_serverfunction(RestoreGame), "QC function RestoreGame is missing");
        }
    }
    else
    {
        //Con_Printf("SV_Spawn_f: host_client->edict->netname = %s, host_client->edict->netname = %s, host_client->name = %s\n", PRVM_GetString(PRVM_serveredictstring(host_client->edict, netname)), PRVM_GetString(PRVM_serveredictstring(host_client->edict, netname)), host_client->name);
 
        // copy spawn parms out of the client_t
        for (i=0 ; i< NUM_SPAWN_PARMS ; i++)
            (&PRVM_serverglobalfloat(parm1))[i] = host_client->spawn_parms[i];
 
        // call the spawn function
        host_client->clientconnectcalled = true;
        PRVM_serverglobalfloat(time) = sv.time;
        PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(host_client->edict);
        prog->ExecuteProgram(prog, PRVM_serverfunction(ClientConnect), "QC function ClientConnect is missing");
 
        Con_Printf("%s connected\n", host_client->name);
 
        PRVM_serverglobalfloat(time) = sv.time;
        prog->ExecuteProgram(prog, PRVM_serverfunction(PutClientInServer), "QC function PutClientInServer is missing");
    }
 
    if (!host_client->netconnection)
        return;
 
    // send time of update
    MSG_WriteByte (&host_client->netconnection->message, svc_time);
    MSG_WriteFloat (&host_client->netconnection->message, sv.time);
 
    // send all current names, colors, and frag counts
    for (i = 0, client = svs.clients;i < svs.maxclients;i++, client++)
    {
        if (!client->active)
            continue;
        MSG_WriteByte (&host_client->netconnection->message, svc_updatename);
        MSG_WriteByte (&host_client->netconnection->message, i);
        MSG_WriteString (&host_client->netconnection->message, client->name);
        MSG_WriteByte (&host_client->netconnection->message, svc_updatefrags);
        MSG_WriteByte (&host_client->netconnection->message, i);
        MSG_WriteShort (&host_client->netconnection->message, client->frags);
        MSG_WriteByte (&host_client->netconnection->message, svc_updatecolors);
        MSG_WriteByte (&host_client->netconnection->message, i);
        MSG_WriteByte (&host_client->netconnection->message, client->colors);
    }
 
    // send all current light styles
    for (i=0 ; i<MAX_LIGHTSTYLES ; i++)
    {
        if (sv.lightstyles[i][0])
        {
            MSG_WriteByte (&host_client->netconnection->message, svc_lightstyle);
            MSG_WriteByte (&host_client->netconnection->message, (char)i);
            MSG_WriteString (&host_client->netconnection->message, sv.lightstyles[i]);
        }
    }
 
    // send some stats
    MSG_WriteByte (&host_client->netconnection->message, svc_updatestat);
    MSG_WriteByte (&host_client->netconnection->message, STAT_TOTALSECRETS);
    MSG_WriteLong (&host_client->netconnection->message, (int)PRVM_serverglobalfloat(total_secrets));
 
    MSG_WriteByte (&host_client->netconnection->message, svc_updatestat);
    MSG_WriteByte (&host_client->netconnection->message, STAT_TOTALMONSTERS);
    MSG_WriteLong (&host_client->netconnection->message, (int)PRVM_serverglobalfloat(total_monsters));
 
    MSG_WriteByte (&host_client->netconnection->message, svc_updatestat);
    MSG_WriteByte (&host_client->netconnection->message, STAT_SECRETS);
    MSG_WriteLong (&host_client->netconnection->message, (int)PRVM_serverglobalfloat(found_secrets));
 
    MSG_WriteByte (&host_client->netconnection->message, svc_updatestat);
    MSG_WriteByte (&host_client->netconnection->message, STAT_MONSTERS);
    MSG_WriteLong (&host_client->netconnection->message, (int)PRVM_serverglobalfloat(killed_monsters));
 
    // send a fixangle
    // Never send a roll angle, because savegames can catch the server
    // in a state where it is expecting the client to correct the angle
    // and it won't happen if the game was just loaded, so you wind up
    // with a permanent head tilt
    if (sv.loadgame)
    {
        MSG_WriteByte (&host_client->netconnection->message, svc_setangle);
        MSG_WriteAngle (&host_client->netconnection->message, PRVM_serveredictvector(host_client->edict, v_angle)[0], sv.protocol);
        MSG_WriteAngle (&host_client->netconnection->message, PRVM_serveredictvector(host_client->edict, v_angle)[1], sv.protocol);
        MSG_WriteAngle (&host_client->netconnection->message, 0, sv.protocol);
    }
    else
    {
        MSG_WriteByte (&host_client->netconnection->message, svc_setangle);
        MSG_WriteAngle (&host_client->netconnection->message, PRVM_serveredictvector(host_client->edict, angles)[0], sv.protocol);
        MSG_WriteAngle (&host_client->netconnection->message, PRVM_serveredictvector(host_client->edict, angles)[1], sv.protocol);
        MSG_WriteAngle (&host_client->netconnection->message, 0, sv.protocol);
    }
 
    SV_WriteClientdataToMessage (host_client, host_client->edict, &host_client->netconnection->message, stats);
 
    MSG_WriteByte (&host_client->netconnection->message, svc_signonnum);
    MSG_WriteByte (&host_client->netconnection->message, 3);
}

References client_t::active, angles, client_t::clientconnectcalled, server_static_t::clients, client_t::colors, Con_DPrint(), Con_Print(), Con_Printf(), client_t::edict, prvm_prog_t::ExecuteProgram, found_secrets, client_t::frags, host_client, i, killed_monsters, server_t::lightstyles, server_t::loadgame, MAX_CL_STATS, MAX_LIGHTSTYLES, server_static_t::maxclients, netconn_t::message, MSG_WriteAngle(), MSG_WriteByte(), MSG_WriteFloat(), MSG_WriteLong(), MSG_WriteShort(), MSG_WriteString(), client_t::name, client_t::nametime, client_t::netconnection, NUM_SPAWN_PARMS, parm1, client_t::prespawned, server_t::protocol, PRVM_EDICT_TO_PROG, PRVM_serveredictvector, PRVM_serverfunction, PRVM_serverglobaledict, PRVM_serverglobalfloat, self, client_t::spawn_parms, client_t::spawned, STAT_MONSTERS, STAT_SECRETS, STAT_TOTALMONSTERS, STAT_TOTALSECRETS, sv, SV_WriteClientdataToMessage(), svc_lightstyle, svc_setangle, svc_signonnum, svc_time, svc_updatecolors, svc_updatefrags, svc_updatename, svc_updatestat, svs, SVVM_prog, server_t::time, time, total_monsters, total_secrets, and v_angle.

Referenced by SV_InitOperatorCommands().

SV_SpawnServer()

void SV_SpawnServer

(

const char *

map

)

Definition at line 1811 of file sv_main.c.

{
    prvm_prog_t *prog = SVVM_prog;
    prvm_edict_t *ent;
    int i;
    char *entities;
    model_t *worldmodel;
    char modelname[sizeof(sv.worldname)];
    const char *canonicalname;
    char vabuf[1024];
 
    Con_Printf("SpawnServer: %s\n", map);
 
    dpsnprintf (modelname, sizeof(modelname), "maps/%s.bsp", map);
 
    if (!(canonicalname = FS_FileExists(modelname)))
    {
        dpsnprintf (modelname, sizeof(modelname), "maps/%s", map);
        if (!(canonicalname = FS_FileExists(modelname)))
        {
            Con_Printf(CON_ERROR "SpawnServer: no map file named %s.bsp\n", modelname);
            return;
        }
    }
    // if it's not in a pak canonicalname will be the same pointer as modelname
    // if it's in a pak canonicalname may differ by case
    if (modelname != canonicalname)
        dp_strlcpy(modelname, canonicalname, sizeof(modelname));
 
//  SV_LockThreadMutex();
 
    if(!host_isclient.integer)
        Sys_MakeProcessNice();
    else
    {
        SCR_BeginLoadingPlaque(false);
        S_StopAllSounds();
    }
 
    if(sv.active)
        SV_VM_Shutdown(false);
 
    // free q3 shaders so that any newly downloaded shaders will be active
    Mod_FreeQ3Shaders();
 
    worldmodel = Mod_ForName(modelname, false, developer.integer > 0, NULL);
    if (!worldmodel || !worldmodel->TraceBox)
    {
        Con_Printf(CON_ERROR "Couldn't load map %s\n", modelname);
 
        if(!host_isclient.integer)
            Sys_MakeProcessMean();
 
//      SV_UnlockThreadMutex();
 
        return;
    }
 
    Collision_Cache_Reset(true);
 
    // let's not have any servers with no name
    if (hostname.string[0] == 0)
        Cvar_SetQuick(&hostname, "UNNAMED");
    scr_centertime_off = 0;
 
    svs.changelevel_issued = false;     // now safe to issue another
 
    // make the map a required file for clients
    Curl_ClearRequirements();
    Curl_RequireFile(modelname);
 
//
// tell all connected clients that we are going to a new level
//
    if (sv.active)
    {
        client_t *client;
        for (i = 0, client = svs.clients;i < svs.maxclients;i++, client++)
        {
            if (client->netconnection)
            {
                MSG_WriteByte(&client->netconnection->message, svc_stufftext);
                MSG_WriteString(&client->netconnection->message, "reconnect\n");
            }
        }
    }
    else
    {
        // open server port
        NetConn_OpenServerPorts(true);
    }
 
//
// make cvars consistant
//
    if (coop.integer)
        Cvar_SetValueQuick(&deathmatch, 0);
    // LadyHavoc: it can be useful to have skills outside the range 0-3...
    //current_skill = bound(0, (int)(skill.value + 0.5), 3);
    //Cvar_SetValue ("skill", (float)current_skill);
    current_skill = (int)(skill.value + 0.5);
 
//
// set up the new server
//
    memset (&sv, 0, sizeof(sv));
 
    // tell SV_Frame() to reset its timers
    sv.spawnframe = host.framecount;
 
    // if running a local client, make sure it doesn't try to access the last
    // level's data which is no longer valiud
    cls.signon = 0;
 
    Cvar_SetValueQuick(&halflifebsp, worldmodel->brush.ishlbsp);
    Cvar_SetValueQuick(&sv_mapformat_is_quake2, worldmodel->brush.isq2bsp);
    Cvar_SetValueQuick(&sv_mapformat_is_quake3, worldmodel->brush.isq3bsp);
 
    if(*sv_random_seed.string)
    {
        srand(sv_random_seed.integer);
        Con_Printf(CON_WARN "NOTE: random seed is %d; use for debugging/benchmarking only!\nUnset sv_random_seed to get real random numbers again.\n", sv_random_seed.integer);
    }
 
    SV_VM_Setup();
 
    sv.active = true;
 
    // set level base name variables for later use
    dp_strlcpy(sv.worldname, modelname, sizeof(sv.worldname));
    FS_StripExtension(sv.worldname, sv.worldnamenoextension, sizeof(sv.worldnamenoextension));
    dp_strlcpy(sv.worldbasename, !strncasecmp(sv.worldnamenoextension, "maps/", 5) ? sv.worldnamenoextension + 5 : sv.worldnamenoextension, sizeof(sv.worldbasename));
//  dp_strlcpy(sv.name, sv.worldbasename, sizeof (sv.name)); // TODO can we just remove this now?
    //Cvar_SetQuick(&sv_worldmessage, sv.worldmessage); // set later after QC is spawned
    Cvar_SetQuick(&sv_worldname, sv.worldname);
    Cvar_SetQuick(&sv_worldnamenoextension, sv.worldnamenoextension);
    Cvar_SetQuick(&sv_worldbasename, sv.worldbasename);
 
    sv.protocol = Protocol_EnumForName(sv_protocolname.string);
    if (sv.protocol == PROTOCOL_UNKNOWN)
    {
        char buffer[1024];
        Protocol_Names(buffer, sizeof(buffer));
        Con_Printf(CON_ERROR "Unknown sv_protocolname \"%s\", valid values are:\n%s\n", sv_protocolname.string, buffer);
        sv.protocol = PROTOCOL_QUAKE;
    }
 
// load progs to get entity field count
    //PR_LoadProgs ( sv_progs.string );
 
    sv.datagram.maxsize = sizeof(sv.datagram_buf);
    sv.datagram.cursize = 0;
    sv.datagram.data = sv.datagram_buf;
 
    sv.reliable_datagram.maxsize = sizeof(sv.reliable_datagram_buf);
    sv.reliable_datagram.cursize = 0;
    sv.reliable_datagram.data = sv.reliable_datagram_buf;
 
    sv.signon.maxsize = sizeof(sv.signon_buf);
    sv.signon.cursize = 0;
    sv.signon.data = sv.signon_buf;
 
// leave slots at start for clients only
    //prog->num_edicts = svs.maxclients+1;
 
    sv.state = ss_loading;
    prog->allowworldwrites = true;
    sv.paused = false;
 
    sv.time = 1.0;
 
    Mod_ClearUsed();
    worldmodel->used = true;
 
    sv.worldmodel = worldmodel;
    sv.models[1] = sv.worldmodel;
 
//
// clear world interaction links
//
    World_SetSize(&sv.world, sv.worldname, sv.worldmodel->normalmins, sv.worldmodel->normalmaxs, prog);
    World_Start(&sv.world);
 
    dp_strlcpy(sv.sound_precache[0], "", sizeof(sv.sound_precache[0]));
 
    dp_strlcpy(sv.model_precache[0], "", sizeof(sv.model_precache[0]));
    dp_strlcpy(sv.model_precache[1], sv.worldname, sizeof(sv.model_precache[1]));
    for (i = 1;i < sv.worldmodel->brush.numsubmodels && i+1 < MAX_MODELS;i++)
    {
        dpsnprintf(sv.model_precache[i+1], sizeof(sv.model_precache[i+1]), "*%i", i);
        sv.models[i+1] = Mod_ForName (sv.model_precache[i+1], false, false, sv.worldname);
    }
    if(i < sv.worldmodel->brush.numsubmodels)
        Con_Printf(CON_WARN "Too many submodels (MAX_MODELS is %i)\n", MAX_MODELS);
 
//
// load the rest of the entities
//
    // AK possible hack since num_edicts is still 0
    ent = PRVM_EDICT_NUM(0);
    memset (ent->fields.fp, 0, prog->entityfields * sizeof(prvm_vec_t));
    ent->free = false;
    PRVM_serveredictstring(ent, model) = PRVM_SetEngineString(prog, sv.worldname);
    PRVM_serveredictfloat(ent, modelindex) = 1;     // world model
    PRVM_serveredictfloat(ent, solid) = SOLID_BSP;
    PRVM_serveredictfloat(ent, movetype) = MOVETYPE_PUSH;
    VectorCopy(sv.world.mins, PRVM_serveredictvector(ent, mins));
    VectorCopy(sv.world.maxs, PRVM_serveredictvector(ent, maxs));
    VectorCopy(sv.world.mins, PRVM_serveredictvector(ent, absmin));
    VectorCopy(sv.world.maxs, PRVM_serveredictvector(ent, absmax));
 
    if (coop.value)
        PRVM_serverglobalfloat(coop) = coop.integer;
    else
        PRVM_serverglobalfloat(deathmatch) = deathmatch.integer;
 
    PRVM_serverglobalstring(mapname) = PRVM_SetEngineString(prog, sv.worldbasename);
 
// serverflags are for cross level information (sigils)
    PRVM_serverglobalfloat(serverflags) = svs.serverflags;
 
    // we need to reset the spawned flag on all connected clients here so that
    // their thinks don't run during startup (before PutClientInServer)
    // we also need to set up the client entities now
    // and we need to set the ->edict pointers to point into the progs edicts
    for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
    {
        host_client->begun = false;
        host_client->edict = PRVM_EDICT_NUM(i + 1);
        PRVM_ED_ClearEdict(prog, host_client->edict);
    }
 
    // load replacement entity file if found
    if (sv_entpatch.integer && (entities = (char *)FS_LoadFile(va(vabuf, sizeof(vabuf), "%s.ent", sv.worldnamenoextension), tempmempool, true, NULL)))
    {
        Con_Printf("Loaded %s.ent\n", sv.worldnamenoextension);
        PRVM_ED_LoadFromFile(prog, entities);
        Mem_Free(entities);
    }
    else
        PRVM_ED_LoadFromFile(prog, sv.worldmodel->brush.entities);
 
 
    // LadyHavoc: clear world angles (to fix e3m3.bsp)
    VectorClear(PRVM_serveredictvector(prog->edicts, angles));
 
// all setup is completed, any further precache statements are errors
//  sv.state = ss_active; // LadyHavoc: workaround for svc_precache bug
    prog->allowworldwrites = false;
 
// run two frames to allow everything to settle
    sv.time = 1.0001;
    for (i = 0;i < sv_init_frame_count.integer;i++)
    {
        sv.frametime = 0.1;
        SV_Physics ();
    }
 
    // Once all init frames have been run, we consider svqc code fully initialized.
    prog->inittime = host.realtime;
 
    if(!host_isclient.integer)
        Mod_PurgeUnused();
 
// create a baseline for more efficient communications
    if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
        SV_CreateBaseline ();
 
    sv.state = ss_active; // LadyHavoc: workaround for svc_precache bug
 
// send serverinfo to all connected clients, and set up botclients coming back from a level change
    for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
    {
        host_client->clientconnectcalled = false; // do NOT call ClientDisconnect if he drops before ClientConnect!
        if (!host_client->active)
            continue;
        if (host_client->netconnection)
            SV_SendServerinfo(host_client);
        else
        {
            int j;
            // if client is a botclient coming from a level change, we need to
            // set up client info that normally requires networking
 
            // copy spawn parms out of the client_t
            for (j=0 ; j< NUM_SPAWN_PARMS ; j++)
                (&PRVM_serverglobalfloat(parm1))[j] = host_client->spawn_parms[j];
 
            // call the spawn function
            host_client->clientconnectcalled = true;
            PRVM_serverglobalfloat(time) = sv.time;
            PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(host_client->edict);
            prog->ExecuteProgram(prog, PRVM_serverfunction(ClientConnect), "QC function ClientConnect is missing");
            prog->ExecuteProgram(prog, PRVM_serverfunction(PutClientInServer), "QC function PutClientInServer is missing");
            host_client->begun = true;
        }
    }
 
    // update the map title cvar (not related to filename)
    Cvar_SetQuick(&sv_worldmessage, PRVM_GetString(prog, PRVM_serveredictstring(prog->edicts, message)));
 
    Con_Printf("Server spawned.\n");
    NetConn_Heartbeat (2);
 
    if(!host_isclient.integer)
        Sys_MakeProcessMean();
 
//  SV_UnlockThreadMutex();
}

References absmax, absmin, client_t::active, server_t::active, prvm_prog_t::allowworldwrites, angles, client_t::begun, model_t::brush, buffer, server_static_t::changelevel_issued, client_t::clientconnectcalled, server_static_t::clients, cls, Collision_Cache_Reset(), CON_ERROR, Con_Printf(), CON_WARN, coop, Curl_ClearRequirements(), Curl_RequireFile(), current_skill, sizebuf_t::cursize, Cvar_SetQuick(), Cvar_SetValueQuick(), sizebuf_t::data, server_t::datagram, server_t::datagram_buf, deathmatch, developer, dp_strlcpy, dpsnprintf(), client_t::edict, prvm_prog_t::edicts, prvm_prog_t::entityfields, prvm_prog_t::ExecuteProgram, prvm_edict_t::fields, prvm_edict_t::fp, host_static_t::framecount, server_t::frametime, prvm_edict_t::free, FS_FileExists(), FS_LoadFile(), FS_StripExtension(), halflifebsp, host, host_client, host_isclient, hostname, i, prvm_prog_t::inittime, int(), cvar_t::integer, model_brush_t::ishlbsp, model_brush_t::isq2bsp, model_brush_t::isq3bsp, mapname, MAX_MODELS, server_static_t::maxclients, maxs, world_t::maxs, sizebuf_t::maxsize, Mem_Free, message, netconn_t::message, mins, world_t::mins, Mod_ClearUsed(), Mod_ForName(), Mod_FreeQ3Shaders(), Mod_PurgeUnused(), model, server_t::model_precache, modelindex, server_t::models, movetype, MOVETYPE_PUSH, MSG_WriteByte(), MSG_WriteString(), NetConn_Heartbeat(), NetConn_OpenServerPorts(), client_t::netconnection, NULL, NUM_SPAWN_PARMS, parm1, server_t::paused, server_t::protocol, Protocol_EnumForName(), Protocol_Names(), PROTOCOL_NEHAHRABJP, PROTOCOL_NEHAHRABJP2, PROTOCOL_NEHAHRABJP3, PROTOCOL_NEHAHRAMOVIE, PROTOCOL_QUAKE, PROTOCOL_QUAKEDP, PROTOCOL_UNKNOWN, PRVM_ED_ClearEdict(), PRVM_ED_LoadFromFile(), PRVM_EDICT_NUM, PRVM_EDICT_TO_PROG, PRVM_GetString(), PRVM_serveredictfloat, PRVM_serveredictstring, PRVM_serveredictvector, PRVM_serverfunction, PRVM_serverglobaledict, PRVM_serverglobalfloat, PRVM_serverglobalstring, PRVM_SetEngineString(), host_static_t::realtime, server_t::reliable_datagram, server_t::reliable_datagram_buf, S_StopAllSounds(), SCR_BeginLoadingPlaque(), scr_centertime_off, self, server_static_t::serverflags, serverflags, client_static_t::signon, server_t::signon, server_t::signon_buf, skill, solid, SOLID_BSP, server_t::sound_precache, client_t::spawn_parms, server_t::spawnframe, ss_active, ss_loading, server_t::state, cvar_t::string, sv, SV_CreateBaseline(), sv_entpatch, sv_init_frame_count, sv_mapformat_is_quake2, sv_mapformat_is_quake3, SV_Physics(), sv_protocolname, sv_random_seed, SV_SendServerinfo(), SV_VM_Setup(), SV_VM_Shutdown(), sv_worldbasename, sv_worldmessage, sv_worldname, sv_worldnamenoextension, svc_stufftext, svs, SVVM_prog, Sys_MakeProcessMean(), Sys_MakeProcessNice(), tempmempool, server_t::time, time, model_t::TraceBox, model_t::used, va(), cvar_t::value, VectorClear, VectorCopy, server_t::world, World_SetSize(), World_Start(), server_t::worldbasename, server_t::worldmodel, server_t::worldname, and server_t::worldnamenoextension.

Referenced by SV_Changelevel_f(), SV_Loadgame_f(), SV_Map_f(), and SV_Restart_f().

SV_StartEffect()

void SV_StartEffect	(	vec3_t	org,
		int	modelindex,
		int	startframe,
		int	framecount,
		int	framerate )

Definition at line 182 of file sv_send.c.

{
    if (modelindex >= 256 || startframe >= 256)
    {
        if (sv.datagram.cursize > MAX_PACKETFRAGMENT-19)
            return;
        MSG_WriteByte (&sv.datagram, svc_effect2);
        MSG_WriteCoord (&sv.datagram, org[0], sv.protocol);
        MSG_WriteCoord (&sv.datagram, org[1], sv.protocol);
        MSG_WriteCoord (&sv.datagram, org[2], sv.protocol);
        MSG_WriteShort (&sv.datagram, modelindex);
        MSG_WriteShort (&sv.datagram, startframe);
        MSG_WriteByte (&sv.datagram, framecount);
        MSG_WriteByte (&sv.datagram, framerate);
    }
    else
    {
        if (sv.datagram.cursize > MAX_PACKETFRAGMENT-17)
            return;
        MSG_WriteByte (&sv.datagram, svc_effect);
        MSG_WriteCoord (&sv.datagram, org[0], sv.protocol);
        MSG_WriteCoord (&sv.datagram, org[1], sv.protocol);
        MSG_WriteCoord (&sv.datagram, org[2], sv.protocol);
        MSG_WriteByte (&sv.datagram, modelindex);
        MSG_WriteByte (&sv.datagram, startframe);
        MSG_WriteByte (&sv.datagram, framecount);
        MSG_WriteByte (&sv.datagram, framerate);
    }
    SV_FlushBroadcastMessages();
}

References sizebuf_t::cursize, server_t::datagram, MAX_PACKETFRAGMENT, modelindex, MSG_WriteByte(), MSG_WriteCoord(), MSG_WriteShort(), server_t::protocol, sv, SV_FlushBroadcastMessages(), svc_effect, and svc_effect2.

Referenced by VM_SV_effect().

SV_StartParticle()

void SV_StartParticle	(	vec3_t	org,
		vec3_t	dir,
		int	color,
		int	count )

Definition at line 158 of file sv_send.c.

{
    int i;
 
    if (sv.datagram.cursize > MAX_PACKETFRAGMENT-18)
        return;
    MSG_WriteByte (&sv.datagram, svc_particle);
    MSG_WriteCoord (&sv.datagram, org[0], sv.protocol);
    MSG_WriteCoord (&sv.datagram, org[1], sv.protocol);
    MSG_WriteCoord (&sv.datagram, org[2], sv.protocol);
    for (i=0 ; i<3 ; i++)
        MSG_WriteChar (&sv.datagram, (int)bound(-128, dir[i]*16, 127));
    MSG_WriteByte (&sv.datagram, count);
    MSG_WriteByte (&sv.datagram, color);
    SV_FlushBroadcastMessages();
}

References bound, color, count, sizebuf_t::cursize, server_t::datagram, dir, i, MAX_PACKETFRAGMENT, MSG_WriteByte(), MSG_WriteChar(), MSG_WriteCoord(), server_t::protocol, sv, SV_FlushBroadcastMessages(), and svc_particle.

Referenced by VM_SV_particle().

SV_StartPointSound()

void SV_StartPointSound	(	vec3_t	origin,
		const char *	sample,
		int	volume,
		float	attenuation,
		float	speed )

Definition at line 320 of file sv_send.c.

{
    int sound_num, field_mask, i, speed4000;
 
    if (nvolume < 0 || nvolume > 255)
    {
        Con_Printf ("SV_StartPointSound: volume = %i\n", nvolume);
        return;
    }
 
    if (attenuation < 0 || attenuation > 4)
    {
        Con_Printf ("SV_StartPointSound: attenuation = %f\n", attenuation);
        return;
    }
 
    if (sv.datagram.cursize > MAX_PACKETFRAGMENT-21)
        return;
 
    // find precache number for sound
    sound_num = SV_SoundIndex(sample, 1);
    if (!sound_num)
        return;
 
    speed4000 = (int)(speed * 40.0f);
    field_mask = 0;
    if (nvolume != DEFAULT_SOUND_PACKET_VOLUME)
        field_mask |= SND_VOLUME;
    if (attenuation != DEFAULT_SOUND_PACKET_ATTENUATION)
        field_mask |= SND_ATTENUATION;
    if (sound_num >= 256)
        field_mask |= SND_LARGESOUND;
    if (speed4000 && speed4000 != 4000)
        field_mask |= SND_SPEEDUSHORT4000;
 
// directed messages go only to the entity they are targeted on
    MSG_WriteByte (&sv.datagram, svc_sound);
    MSG_WriteByte (&sv.datagram, field_mask);
    if (field_mask & SND_VOLUME)
        MSG_WriteByte (&sv.datagram, nvolume);
    if (field_mask & SND_ATTENUATION)
        MSG_WriteByte (&sv.datagram, (int)(attenuation*64));
    if (field_mask & SND_SPEEDUSHORT4000)
        MSG_WriteShort (&sv.datagram, speed4000);
    // Always write entnum 0 for the world entity
    MSG_WriteShort (&sv.datagram, (0<<3) | 0);
    if (field_mask & SND_LARGESOUND)
        MSG_WriteShort (&sv.datagram, sound_num);
    else
        MSG_WriteByte (&sv.datagram, sound_num);
    for (i = 0;i < 3;i++)
        MSG_WriteCoord (&sv.datagram, origin[i], sv.protocol);
    SV_FlushBroadcastMessages();
}

References Con_Printf(), sizebuf_t::cursize, server_t::datagram, DEFAULT_SOUND_PACKET_ATTENUATION, DEFAULT_SOUND_PACKET_VOLUME, i, int(), MAX_PACKETFRAGMENT, MSG_WriteByte(), MSG_WriteCoord(), MSG_WriteShort(), origin, server_t::protocol, SND_ATTENUATION, SND_LARGESOUND, SND_SPEEDUSHORT4000, SND_VOLUME, sv, SV_FlushBroadcastMessages(), SV_SoundIndex(), and svc_sound.

Referenced by VM_SV_pointsound().

SV_StartSound()

void SV_StartSound	(	prvm_edict_t *	entity,
		int	channel,
		const char *	sample,
		int	volume,
		float	attenuation,
		qbool	reliable,
		float	speed )

Definition at line 228 of file sv_send.c.

{
    prvm_prog_t *prog = SVVM_prog;
    sizebuf_t *dest;
    int sound_num, field_mask, i, ent, speed4000;
 
    dest = (reliable ? &sv.reliable_datagram : &sv.datagram);
 
    if (nvolume < 0 || nvolume > 255)
    {
        Con_Printf ("SV_StartSound: volume = %i\n", nvolume);
        return;
    }
 
    if (attenuation < 0 || attenuation > 4)
    {
        Con_Printf ("SV_StartSound: attenuation = %f\n", attenuation);
        return;
    }
 
    if (!IS_CHAN(channel))
    {
        Con_Printf ("SV_StartSound: channel = %i\n", channel);
        return;
    }
 
    channel = CHAN_ENGINE2NET(channel);
 
    if (sv.datagram.cursize > MAX_PACKETFRAGMENT-21)
        return;
 
// find precache number for sound
    sound_num = SV_SoundIndex(sample, 1);
    if (!sound_num)
        return;
 
    ent = PRVM_NUM_FOR_EDICT(entity);
 
    speed4000 = (int)floor(speed * 4000.0f + 0.5f);
    field_mask = 0;
    if (nvolume != DEFAULT_SOUND_PACKET_VOLUME)
        field_mask |= SND_VOLUME;
    if (attenuation != DEFAULT_SOUND_PACKET_ATTENUATION)
        field_mask |= SND_ATTENUATION;
    if (speed4000 && speed4000 != 4000)
        field_mask |= SND_SPEEDUSHORT4000;
    if (ent >= 8192 || channel < 0 || channel > 7)
        field_mask |= SND_LARGEENTITY;
    if (sound_num >= 256)
        field_mask |= SND_LARGESOUND;
 
// directed messages go only to the entity they are targeted on
    MSG_WriteByte (dest, svc_sound);
    MSG_WriteByte (dest, field_mask);
    if (field_mask & SND_VOLUME)
        MSG_WriteByte (dest, nvolume);
    if (field_mask & SND_ATTENUATION)
        MSG_WriteByte (dest, (int)(attenuation*64));
    if (field_mask & SND_SPEEDUSHORT4000)
        MSG_WriteShort (dest, speed4000);
    if (field_mask & SND_LARGEENTITY)
    {
        MSG_WriteShort (dest, ent);
        MSG_WriteChar (dest, channel);
    }
    else
        MSG_WriteShort (dest, (ent<<3) | channel);
    if ((field_mask & SND_LARGESOUND) || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
        MSG_WriteShort (dest, sound_num);
    else
        MSG_WriteByte (dest, sound_num);
    for (i = 0;i < 3;i++)
        MSG_WriteCoord (dest, PRVM_serveredictvector(entity, origin)[i]+0.5*(PRVM_serveredictvector(entity, mins)[i]+PRVM_serveredictvector(entity, maxs)[i]), sv.protocol);
 
    // TODO do we have to do anything here when dest is &sv.reliable_datagram?
    if(!reliable)
        SV_FlushBroadcastMessages();
}

References CHAN_ENGINE2NET, Con_Printf(), sizebuf_t::cursize, server_t::datagram, DEFAULT_SOUND_PACKET_ATTENUATION, DEFAULT_SOUND_PACKET_VOLUME, entity(), floor(), i, int(), IS_CHAN, MAX_PACKETFRAGMENT, maxs, mins, MSG_WriteByte(), MSG_WriteChar(), MSG_WriteCoord(), MSG_WriteShort(), origin, server_t::protocol, PROTOCOL_NEHAHRABJP2, PROTOCOL_NEHAHRABJP3, PRVM_NUM_FOR_EDICT, PRVM_serveredictvector, server_t::reliable_datagram, SND_ATTENUATION, SND_LARGEENTITY, SND_LARGESOUND, SND_SPEEDUSHORT4000, SND_VOLUME, sv, SV_FlushBroadcastMessages(), SV_SoundIndex(), svc_sound, and SVVM_prog.

Referenced by SV_CheckWaterTransition(), SV_Physics_Step(), and VM_SV_sound().

SV_StartThread()

void SV_StartThread

(

void

)

Definition at line 2850 of file sv_main.c.

{
    if (!sv_threaded.integer || !Thread_HasThreads())
        return;
    svs.threaded = true;
    svs.threadstop = false;
    svs.threadmutex = Thread_CreateMutex();
    svs.thread = Thread_CreateThread(SV_ThreadFunc, NULL);
}

References cvar_t::integer, NULL, sv_threaded, SV_ThreadFunc(), svs, server_static_t::thread, Thread_CreateMutex, Thread_CreateThread, Thread_HasThreads(), server_static_t::threaded, server_static_t::threadmutex, and server_static_t::threadstop.

Referenced by Host_Init().

SV_StopThread()

void SV_StopThread

(

void

)

Definition at line 2860 of file sv_main.c.

{
    if (!svs.threaded)
        return;
    svs.threadstop = true;
    Thread_WaitThread(svs.thread, 0);
    Thread_DestroyMutex(svs.threadmutex);
    svs.threaded = false;
}

References svs, server_static_t::thread, Thread_DestroyMutex, Thread_WaitThread, server_static_t::threaded, server_static_t::threadmutex, and server_static_t::threadstop.

Referenced by Host_Shutdown().

SV_TimingReport()

const char * SV_TimingReport	(	char *	buf,
		size_t	buflen )

for output in SV_Status_f

Definition at line 2521 of file sv_main.c.

{
    return va(buf, buflen, "%.1f%% CPU, %.2f%% lost, offset avg %.1fms, max %.1fms, sdev %.1fms", sv.perf_cpuload * 100, sv.perf_lost * 100, sv.perf_offset_avg * 1000, sv.perf_offset_max * 1000, sv.perf_offset_sdev * 1000);
}

References buf, server_t::perf_cpuload, server_t::perf_lost, server_t::perf_offset_avg, server_t::perf_offset_max, server_t::perf_offset_sdev, sv, and va().

Referenced by SV_Frame(), SV_Status_f(), and SV_ThreadFunc().

SV_TraceBox()

trace_t SV_TraceBox	(	const vec3_t	start,
		const vec3_t	mins,
		const vec3_t	maxs,
		const vec3_t	end,
		int	type,
		prvm_edict_t *	passedict,
		int	hitsupercontentsmask,
		int	skipsupercontentsmask,
		int	skipmaterialflagsmask,
		float	extend )

traces a box move against worldmodel and all entities in the specified area

Definition at line 414 of file sv_phys.c.

{
    prvm_prog_t *prog = SVVM_prog;
    vec3_t hullmins, hullmaxs;
    int i, bodysupercontents;
    int passedictprog;
    float pitchsign = 1;
    qbool pointtrace;
    prvm_edict_t *traceowner, *touch;
    trace_t trace;
    // temporary storage because prvm_vec_t may differ from vec_t
    vec3_t touchmins, touchmaxs;
    // bounding box of entire move area
    vec3_t clipboxmins, clipboxmaxs;
    // size of the moving object
    vec3_t clipmins, clipmaxs;
    // size when clipping against monsters
    vec3_t clipmins2, clipmaxs2;
    // start and end origin of move
    vec3_t clipstart, clipend;
    // trace results
    trace_t cliptrace;
    // matrices to transform into/out of other entity's space
    matrix4x4_t matrix, imatrix;
    // model of other entity
    model_t *model;
    // list of entities to test for collisions
    int numtouchedicts;
    static prvm_edict_t *touchedicts[MAX_EDICTS];
    int clipgroup;
    if (VectorCompare(mins, maxs))
    {
        vec3_t shiftstart, shiftend;
        VectorAdd(start, mins, shiftstart);
        VectorAdd(end, mins, shiftend);
        if (VectorCompare(start, end))
            trace = SV_TracePoint(shiftstart, type, passedict, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask);
        else
            trace = SV_TraceLine(shiftstart, shiftend, type, passedict, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask, extend);
        VectorSubtract(trace.endpos, mins, trace.endpos);
        return trace;
    }
 
    VectorCopy(start, clipstart);
    VectorCopy(end, clipend);
    VectorCopy(mins, clipmins);
    VectorCopy(maxs, clipmaxs);
    VectorCopy(mins, clipmins2);
    VectorCopy(maxs, clipmaxs2);
#if COLLISIONPARANOID >= 3
    Con_Printf("move(%f %f %f,%f %f %f)", clipstart[0], clipstart[1], clipstart[2], clipend[0], clipend[1], clipend[2]);
#endif
 
    // clip to world
    Collision_ClipToWorld(&cliptrace, sv.worldmodel, clipstart, clipmins, clipmaxs, clipend, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask, extend);
    cliptrace.worldstartsolid = cliptrace.bmodelstartsolid = cliptrace.startsolid;
    if (cliptrace.startsolid || cliptrace.fraction < 1)
        cliptrace.ent = prog->edicts;
    if (type == MOVE_WORLDONLY)
        goto finished;
 
    if (type == MOVE_MISSILE)
    {
        // LadyHavoc: modified this, was = -15, now -= 15
        for (i = 0;i < 3;i++)
        {
            clipmins2[i] -= 15;
            clipmaxs2[i] += 15;
        }
    }
 
    // get adjusted box for bmodel collisions if the world is q1bsp or hlbsp
    if (sv.worldmodel && sv.worldmodel->brush.RoundUpToHullSize)
        sv.worldmodel->brush.RoundUpToHullSize(sv.worldmodel, clipmins, clipmaxs, hullmins, hullmaxs);
    else
    {
        VectorCopy(clipmins, hullmins);
        VectorCopy(clipmaxs, hullmaxs);
    }
 
    // create the bounding box of the entire move
    for (i = 0;i < 3;i++)
    {
        clipboxmins[i] = min(clipstart[i], cliptrace.endpos[i]) + min(hullmins[i], clipmins2[i]) - 1;
        clipboxmaxs[i] = max(clipstart[i], cliptrace.endpos[i]) + max(hullmaxs[i], clipmaxs2[i]) + 1;
    }
 
    // debug override to test against everything
    if (sv_debugmove.integer)
    {
        clipboxmins[0] = clipboxmins[1] = clipboxmins[2] = (vec_t)-999999999;
        clipboxmaxs[0] = clipboxmaxs[1] = clipboxmaxs[2] =  (vec_t)999999999;
    }
 
    // if the passedict is world, make it NULL (to avoid two checks each time)
    if (passedict == prog->edicts)
        passedict = NULL;
    // precalculate prog value for passedict for comparisons
    passedictprog = PRVM_EDICT_TO_PROG(passedict);
    // figure out whether this is a point trace for comparisons
    pointtrace = VectorCompare(clipmins, clipmaxs);
    // precalculate passedict's owner edict pointer for comparisons
    traceowner = passedict ? PRVM_PROG_TO_EDICT(PRVM_serveredictedict(passedict, owner)) : 0;
 
    clipgroup = passedict ? (int)PRVM_serveredictfloat(passedict, clipgroup) : 0;
 
    // clip to entities
    // because this uses World_EntitiestoBox, we know all entity boxes overlap
    // the clip region, so we can skip culling checks in the loop below
    numtouchedicts = SV_EntitiesInBox(clipboxmins, clipboxmaxs, MAX_EDICTS, touchedicts);
    if (numtouchedicts > MAX_EDICTS)
    {
        // this never happens
        Con_Printf("SV_EntitiesInBox returned %i edicts, max was %i\n", numtouchedicts, MAX_EDICTS);
        numtouchedicts = MAX_EDICTS;
    }
    for (i = 0;i < numtouchedicts;i++)
    {
        touch = touchedicts[i];
 
        if (PRVM_serveredictfloat(touch, solid) < SOLID_BBOX)
            continue;
        if (type == MOVE_NOMONSTERS && PRVM_serveredictfloat(touch, solid) != SOLID_BSP)
            continue;
 
        if (passedict)
        {
            // don't clip against self
            if (passedict == touch)
                continue;
            // don't clip owned entities against owner
            if (traceowner == touch)
                continue;
            // don't clip owner against owned entities
            if (passedictprog == PRVM_serveredictedict(touch, owner))
                continue;
            // don't clip against any entities in the same clipgroup (DP_RM_CLIPGROUP)
            if (clipgroup && clipgroup == (int)PRVM_serveredictfloat(touch, clipgroup))
                continue;
            // don't clip points against points (they can't collide)
            if (pointtrace && VectorCompare(PRVM_serveredictvector(touch, mins), PRVM_serveredictvector(touch, maxs)) && (type != MOVE_MISSILE || !((int)PRVM_serveredictfloat(touch, flags) & FL_MONSTER)))
                continue;
        }
 
        bodysupercontents = PRVM_serveredictfloat(touch, solid) == SOLID_CORPSE ? SUPERCONTENTS_CORPSE : SUPERCONTENTS_BODY;
 
        // might interact, so do an exact clip
        model = NULL;
        if ((int) PRVM_serveredictfloat(touch, solid) == SOLID_BSP || type == MOVE_HITMODEL)
        {
            model = SV_GetModelFromEdict(touch);
            pitchsign = SV_GetPitchSign(prog, touch);
        }
        if (model)
            Matrix4x4_CreateFromQuakeEntity(&matrix, PRVM_serveredictvector(touch, origin)[0], PRVM_serveredictvector(touch, origin)[1], PRVM_serveredictvector(touch, origin)[2], pitchsign * PRVM_serveredictvector(touch, angles)[0], PRVM_serveredictvector(touch, angles)[1], PRVM_serveredictvector(touch, angles)[2], 1);
        else
            Matrix4x4_CreateTranslate(&matrix, PRVM_serveredictvector(touch, origin)[0], PRVM_serveredictvector(touch, origin)[1], PRVM_serveredictvector(touch, origin)[2]);
        Matrix4x4_Invert_Simple(&imatrix, &matrix);
        VM_GenerateFrameGroupBlend(prog, touch->priv.server->framegroupblend, touch);
        VM_FrameBlendFromFrameGroupBlend(touch->priv.server->frameblend, touch->priv.server->framegroupblend, model, sv.time);
        VM_UpdateEdictSkeleton(prog, touch, model, touch->priv.server->frameblend);
        VectorCopy(PRVM_serveredictvector(touch, mins), touchmins);
        VectorCopy(PRVM_serveredictvector(touch, maxs), touchmaxs);
        if (type == MOVE_MISSILE && (int)PRVM_serveredictfloat(touch, flags) & FL_MONSTER)
            Collision_ClipToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, touchmins, touchmaxs, bodysupercontents, &matrix, &imatrix, clipstart, clipmins2, clipmaxs2, clipend, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask, extend);
        else
            Collision_ClipToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, touchmins, touchmaxs, bodysupercontents, &matrix, &imatrix, clipstart, clipmins, clipmaxs, clipend, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask, extend);
 
        Collision_CombineTraces(&cliptrace, &trace, (void *)touch, PRVM_serveredictfloat(touch, solid) == SOLID_BSP);
    }
 
finished:
    return cliptrace;
}

References angles, trace_t::bmodelstartsolid, clipgroup, Collision_ClipToGenericEntity(), Collision_ClipToWorld(), Collision_CombineTraces(), Con_Printf(), prvm_prog_t::edicts, trace_t::endpos, trace_t::ent, FL_MONSTER, flags, trace_t::fraction, i, int(), cvar_t::integer, Matrix4x4_CreateFromQuakeEntity(), Matrix4x4_CreateTranslate(), Matrix4x4_Invert_Simple(), max, MAX_EDICTS, maxs, min, mins, model, MOVE_HITMODEL, MOVE_MISSILE, MOVE_NOMONSTERS, MOVE_WORLDONLY, NULL, origin, owner, prvm_edict_t::priv, PRVM_EDICT_TO_PROG, PRVM_PROG_TO_EDICT, PRVM_serveredictedict, PRVM_serveredictfloat, PRVM_serveredictvector, prvm_edict_t::server, solid, SOLID_BBOX, SOLID_BSP, SOLID_CORPSE, trace_t::startsolid, SUPERCONTENTS_BODY, SUPERCONTENTS_CORPSE, sv, sv_debugmove, SV_EntitiesInBox(), SV_GetModelFromEdict(), SV_GetPitchSign(), SV_TraceLine(), SV_TracePoint(), SVVM_prog, server_t::time, type, VectorAdd, VectorCompare, VectorCopy, VectorSubtract, VM_FrameBlendFromFrameGroupBlend(), VM_GenerateFrameGroupBlend(), VM_UpdateEdictSkeleton(), server_t::worldmodel, and trace_t::worldstartsolid.

Referenced by PHYS_TraceBox(), SV_movestep(), SV_NudgeOutOfSolid_PivotIsKnownGood(), SV_PushEntity(), SV_Trace_Toss(), SV_WalkMove(), VM_SV_droptofloor(), and VM_SV_tracebox().

SV_TraceLine()

trace_t SV_TraceLine	(	const vec3_t	start,
		const vec3_t	end,
		int	type,
		prvm_edict_t *	passedict,
		int	hitsupercontentsmask,
		int	skipsupercontentsmask,
		int	skipmaterialflagsmask,
		float	extend )

Definition at line 256 of file sv_phys.c.

{
    prvm_prog_t *prog = SVVM_prog;
    int i, bodysupercontents;
    int passedictprog;
    float pitchsign = 1;
    prvm_edict_t *traceowner, *touch;
    trace_t trace;
    // temporary storage because prvm_vec_t may differ from vec_t
    vec3_t touchmins, touchmaxs;
    // bounding box of entire move area
    vec3_t clipboxmins, clipboxmaxs;
    // size when clipping against monsters
    vec3_t clipmins2, clipmaxs2;
    // start and end origin of move
    vec3_t clipstart, clipend;
    // trace results
    trace_t cliptrace;
    // matrices to transform into/out of other entity's space
    matrix4x4_t matrix, imatrix;
    // model of other entity
    model_t *model;
    // list of entities to test for collisions
    int numtouchedicts;
    static prvm_edict_t *touchedicts[MAX_EDICTS];
    int clipgroup;
    if (VectorCompare(start, end))
        return SV_TracePoint(start, type, passedict, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask);
 
    //return SV_TraceBox(start, vec3_origin, vec3_origin, end, type, passedict, hitsupercontentsmask);
 
    VectorCopy(start, clipstart);
    VectorCopy(end, clipend);
    VectorClear(clipmins2);
    VectorClear(clipmaxs2);
#if COLLISIONPARANOID >= 3
    Con_Printf("move(%f %f %f,%f %f %f)", clipstart[0], clipstart[1], clipstart[2], clipend[0], clipend[1], clipend[2]);
#endif
 
    // clip to world
    Collision_ClipLineToWorld(&cliptrace, sv.worldmodel, clipstart, clipend, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask, extend, false);
    cliptrace.worldstartsolid = cliptrace.bmodelstartsolid = cliptrace.startsolid;
    if (cliptrace.startsolid || cliptrace.fraction < 1)
        cliptrace.ent = prog->edicts;
    if (type == MOVE_WORLDONLY)
        goto finished;
 
    if (type == MOVE_MISSILE)
    {
        // LadyHavoc: modified this, was = -15, now -= 15
        for (i = 0;i < 3;i++)
        {
            clipmins2[i] -= 15;
            clipmaxs2[i] += 15;
        }
    }
 
    // create the bounding box of the entire move
    for (i = 0;i < 3;i++)
    {
        clipboxmins[i] = min(clipstart[i], cliptrace.endpos[i]) + clipmins2[i] - 1;
        clipboxmaxs[i] = max(clipstart[i], cliptrace.endpos[i]) + clipmaxs2[i] + 1;
    }
 
    // debug override to test against everything
    if (sv_debugmove.integer)
    {
        clipboxmins[0] = clipboxmins[1] = clipboxmins[2] = (vec_t)-999999999;
        clipboxmaxs[0] = clipboxmaxs[1] = clipboxmaxs[2] =  (vec_t)999999999;
    }
 
    // if the passedict is world, make it NULL (to avoid two checks each time)
    if (passedict == prog->edicts)
        passedict = NULL;
    // precalculate prog value for passedict for comparisons
    passedictprog = PRVM_EDICT_TO_PROG(passedict);
    // precalculate passedict's owner edict pointer for comparisons
    traceowner = passedict ? PRVM_PROG_TO_EDICT(PRVM_serveredictedict(passedict, owner)) : 0;
 
    clipgroup = passedict ? (int)PRVM_serveredictfloat(passedict, clipgroup) : 0;
 
    // clip to entities
    // because this uses World_EntitiestoBox, we know all entity boxes overlap
    // the clip region, so we can skip culling checks in the loop below
    numtouchedicts = SV_EntitiesInBox(clipboxmins, clipboxmaxs, MAX_EDICTS, touchedicts);
    if (numtouchedicts > MAX_EDICTS)
    {
        // this never happens
        Con_Printf("SV_EntitiesInBox returned %i edicts, max was %i\n", numtouchedicts, MAX_EDICTS);
        numtouchedicts = MAX_EDICTS;
    }
    for (i = 0;i < numtouchedicts;i++)
    {
        touch = touchedicts[i];
 
        if (PRVM_serveredictfloat(touch, solid) < SOLID_BBOX)
            continue;
        if (type == MOVE_NOMONSTERS && PRVM_serveredictfloat(touch, solid) != SOLID_BSP)
            continue;
 
        if (passedict)
        {
            // don't clip against self
            if (passedict == touch)
                continue;
            // don't clip owned entities against owner
            if (traceowner == touch)
                continue;
            // don't clip owner against owned entities
            if (passedictprog == PRVM_serveredictedict(touch, owner))
                continue;
            // don't clip against any entities in the same clipgroup (DP_RM_CLIPGROUP)
            if (clipgroup && clipgroup == (int)PRVM_serveredictfloat(touch, clipgroup))
                continue;
            // don't clip points against points (they can't collide)
            if (VectorCompare(PRVM_serveredictvector(touch, mins), PRVM_serveredictvector(touch, maxs)) && (type != MOVE_MISSILE || !((int)PRVM_serveredictfloat(touch, flags) & FL_MONSTER)))
                continue;
        }
 
        bodysupercontents = PRVM_serveredictfloat(touch, solid) == SOLID_CORPSE ? SUPERCONTENTS_CORPSE : SUPERCONTENTS_BODY;
 
        // might interact, so do an exact clip
        model = NULL;
        if ((int) PRVM_serveredictfloat(touch, solid) == SOLID_BSP || type == MOVE_HITMODEL)
        {
            model = SV_GetModelFromEdict(touch);
            pitchsign = SV_GetPitchSign(prog, touch);
        }
        if (model)
            Matrix4x4_CreateFromQuakeEntity(&matrix, PRVM_serveredictvector(touch, origin)[0], PRVM_serveredictvector(touch, origin)[1], PRVM_serveredictvector(touch, origin)[2], pitchsign * PRVM_serveredictvector(touch, angles)[0], PRVM_serveredictvector(touch, angles)[1], PRVM_serveredictvector(touch, angles)[2], 1);
        else
            Matrix4x4_CreateTranslate(&matrix, PRVM_serveredictvector(touch, origin)[0], PRVM_serveredictvector(touch, origin)[1], PRVM_serveredictvector(touch, origin)[2]);
        Matrix4x4_Invert_Simple(&imatrix, &matrix);
        VM_GenerateFrameGroupBlend(prog, touch->priv.server->framegroupblend, touch);
        VM_FrameBlendFromFrameGroupBlend(touch->priv.server->frameblend, touch->priv.server->framegroupblend, model, sv.time);
        VM_UpdateEdictSkeleton(prog, touch, model, touch->priv.server->frameblend);
        VectorCopy(PRVM_serveredictvector(touch, mins), touchmins);
        VectorCopy(PRVM_serveredictvector(touch, maxs), touchmaxs);
        if (type == MOVE_MISSILE && (int)PRVM_serveredictfloat(touch, flags) & FL_MONSTER)
            Collision_ClipToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, touchmins, touchmaxs, bodysupercontents, &matrix, &imatrix, clipstart, clipmins2, clipmaxs2, clipend, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask, extend);
        else
            Collision_ClipLineToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, touchmins, touchmaxs, bodysupercontents, &matrix, &imatrix, clipstart, clipend, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask, extend, false);
 
        Collision_CombineTraces(&cliptrace, &trace, (void *)touch, PRVM_serveredictfloat(touch, solid) == SOLID_BSP);
    }
 
finished:
    return cliptrace;
}

References angles, trace_t::bmodelstartsolid, clipgroup, Collision_ClipLineToGenericEntity(), Collision_ClipLineToWorld(), Collision_ClipToGenericEntity(), Collision_CombineTraces(), Con_Printf(), prvm_prog_t::edicts, trace_t::endpos, trace_t::ent, FL_MONSTER, flags, trace_t::fraction, i, int(), cvar_t::integer, Matrix4x4_CreateFromQuakeEntity(), Matrix4x4_CreateTranslate(), Matrix4x4_Invert_Simple(), max, MAX_EDICTS, maxs, min, mins, model, MOVE_HITMODEL, MOVE_MISSILE, MOVE_NOMONSTERS, MOVE_WORLDONLY, NULL, origin, owner, prvm_edict_t::priv, PRVM_EDICT_TO_PROG, PRVM_PROG_TO_EDICT, PRVM_serveredictedict, PRVM_serveredictfloat, PRVM_serveredictvector, prvm_edict_t::server, solid, SOLID_BBOX, SOLID_BSP, SOLID_CORPSE, trace_t::startsolid, SUPERCONTENTS_BODY, SUPERCONTENTS_CORPSE, sv, sv_debugmove, SV_EntitiesInBox(), SV_GetModelFromEdict(), SV_GetPitchSign(), SV_TracePoint(), SVVM_prog, server_t::time, type, VectorClear, VectorCompare, VectorCopy, VM_FrameBlendFromFrameGroupBlend(), VM_GenerateFrameGroupBlend(), VM_UpdateEdictSkeleton(), server_t::worldmodel, and trace_t::worldstartsolid.

Referenced by Sbar_ShowFPS(), SV_CheckBottom(), SV_Ent_Create_f(), SV_Ent_Remove_f(), SV_SetIdealPitch(), SV_TraceBox(), SV_UserFriction(), VM_SV_aim(), VM_SV_droptofloor(), and VM_SV_traceline().

SV_TracePoint()

trace_t SV_TracePoint	(	const vec3_t	start,
		int	type,
		prvm_edict_t *	passedict,
		int	hitsupercontentsmask,
		int	skipsupercontentsmask,
		int	skipmaterialflagsmask )

Definition at line 104 of file sv_phys.c.

{
    prvm_prog_t *prog = SVVM_prog;
    int i, bodysupercontents;
    int passedictprog;
    float pitchsign = 1;
    prvm_edict_t *traceowner, *touch;
    trace_t trace;
    // temporary storage because prvm_vec_t may differ from vec_t
    vec3_t touchmins, touchmaxs;
    // bounding box of entire move area
    vec3_t clipboxmins, clipboxmaxs;
    // size when clipping against monsters
    vec3_t clipmins2, clipmaxs2;
    // start and end origin of move
    vec3_t clipstart;
    // trace results
    trace_t cliptrace;
    // matrices to transform into/out of other entity's space
    matrix4x4_t matrix, imatrix;
    // model of other entity
    model_t *model;
    // list of entities to test for collisions
    int numtouchedicts;
    static prvm_edict_t *touchedicts[MAX_EDICTS];
    int clipgroup;
 
    //return SV_TraceBox(start, vec3_origin, vec3_origin, end, type, passedict, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask);
 
    VectorCopy(start, clipstart);
    VectorClear(clipmins2);
    VectorClear(clipmaxs2);
#if COLLISIONPARANOID >= 3
    Con_Printf("move(%f %f %f)", clipstart[0], clipstart[1], clipstart[2]);
#endif
 
    // clip to world
    Collision_ClipPointToWorld(&cliptrace, sv.worldmodel, clipstart, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask);
    cliptrace.worldstartsolid = cliptrace.bmodelstartsolid = cliptrace.startsolid;
    if (cliptrace.startsolid || cliptrace.fraction < 1)
        cliptrace.ent = prog->edicts;
    if (type == MOVE_WORLDONLY)
        goto finished;
 
    if (type == MOVE_MISSILE)
    {
        // LadyHavoc: modified this, was = -15, now -= 15
        for (i = 0;i < 3;i++)
        {
            clipmins2[i] -= 15;
            clipmaxs2[i] += 15;
        }
    }
 
    // create the bounding box of the entire move
    for (i = 0;i < 3;i++)
    {
        clipboxmins[i] = min(clipstart[i], cliptrace.endpos[i]) + clipmins2[i] - 1;
        clipboxmaxs[i] = max(clipstart[i], cliptrace.endpos[i]) + clipmaxs2[i] + 1;
    }
 
    // debug override to test against everything
    if (sv_debugmove.integer)
    {
        clipboxmins[0] = clipboxmins[1] = clipboxmins[2] = (vec_t)-999999999;
        clipboxmaxs[0] = clipboxmaxs[1] = clipboxmaxs[2] =  (vec_t)999999999;
    }
 
    // if the passedict is world, make it NULL (to avoid two checks each time)
    if (passedict == prog->edicts)
        passedict = NULL;
    // precalculate prog value for passedict for comparisons
    passedictprog = PRVM_EDICT_TO_PROG(passedict);
    // precalculate passedict's owner edict pointer for comparisons
    traceowner = passedict ? PRVM_PROG_TO_EDICT(PRVM_serveredictedict(passedict, owner)) : 0;
 
    clipgroup = passedict ? (int)PRVM_serveredictfloat(passedict, clipgroup) : 0;
 
    // clip to entities
    // because this uses World_EntitiestoBox, we know all entity boxes overlap
    // the clip region, so we can skip culling checks in the loop below
    numtouchedicts = SV_EntitiesInBox(clipboxmins, clipboxmaxs, MAX_EDICTS, touchedicts);
    if (numtouchedicts > MAX_EDICTS)
    {
        // this never happens
        Con_Printf("SV_EntitiesInBox returned %i edicts, max was %i\n", numtouchedicts, MAX_EDICTS);
        numtouchedicts = MAX_EDICTS;
    }
    for (i = 0;i < numtouchedicts;i++)
    {
        touch = touchedicts[i];
 
        if (PRVM_serveredictfloat(touch, solid) < SOLID_BBOX)
            continue;
        if (type == MOVE_NOMONSTERS && PRVM_serveredictfloat(touch, solid) != SOLID_BSP)
            continue;
 
        if (passedict)
        {
            // don't clip against self
            if (passedict == touch)
                continue;
            // don't clip owned entities against owner
            if (traceowner == touch)
                continue;
            // don't clip owner against owned entities
            if (passedictprog == PRVM_serveredictedict(touch, owner))
                continue;
            // don't clip against any entities in the same clipgroup (DP_RM_CLIPGROUP)
            if (clipgroup && clipgroup == (int)PRVM_serveredictfloat(touch, clipgroup))
                continue;
            // don't clip points against points (they can't collide)
            if (VectorCompare(PRVM_serveredictvector(touch, mins), PRVM_serveredictvector(touch, maxs)) && (type != MOVE_MISSILE || !((int)PRVM_serveredictfloat(touch, flags) & FL_MONSTER)))
                continue;
        }
 
        bodysupercontents = PRVM_serveredictfloat(touch, solid) == SOLID_CORPSE ? SUPERCONTENTS_CORPSE : SUPERCONTENTS_BODY;
 
        // might interact, so do an exact clip
        model = NULL;
        if ((int) PRVM_serveredictfloat(touch, solid) == SOLID_BSP || type == MOVE_HITMODEL)
        {
            model = SV_GetModelFromEdict(touch);
            pitchsign = SV_GetPitchSign(prog, touch);
        }
        if (model)
            Matrix4x4_CreateFromQuakeEntity(&matrix, PRVM_serveredictvector(touch, origin)[0], PRVM_serveredictvector(touch, origin)[1], PRVM_serveredictvector(touch, origin)[2], pitchsign * PRVM_serveredictvector(touch, angles)[0], PRVM_serveredictvector(touch, angles)[1], PRVM_serveredictvector(touch, angles)[2], 1);
        else
            Matrix4x4_CreateTranslate(&matrix, PRVM_serveredictvector(touch, origin)[0], PRVM_serveredictvector(touch, origin)[1], PRVM_serveredictvector(touch, origin)[2]);
        Matrix4x4_Invert_Simple(&imatrix, &matrix);
        VM_GenerateFrameGroupBlend(prog, touch->priv.server->framegroupblend, touch);
        VM_FrameBlendFromFrameGroupBlend(touch->priv.server->frameblend, touch->priv.server->framegroupblend, model, sv.time);
        VM_UpdateEdictSkeleton(prog, touch, model, touch->priv.server->frameblend);
        VectorCopy(PRVM_serveredictvector(touch, mins), touchmins);
        VectorCopy(PRVM_serveredictvector(touch, maxs), touchmaxs);
        if (type == MOVE_MISSILE && (int)PRVM_serveredictfloat(touch, flags) & FL_MONSTER)
            Collision_ClipToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, touchmins, touchmaxs, bodysupercontents, &matrix, &imatrix, clipstart, clipmins2, clipmaxs2, clipstart, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask, 0.0f);
        else
            Collision_ClipPointToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, touchmins, touchmaxs, bodysupercontents, &matrix, &imatrix, clipstart, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask);
 
        Collision_CombineTraces(&cliptrace, &trace, (void *)touch, PRVM_serveredictfloat(touch, solid) == SOLID_BSP);
    }
 
finished:
    return cliptrace;
}

References angles, trace_t::bmodelstartsolid, clipgroup, Collision_ClipPointToGenericEntity(), Collision_ClipPointToWorld(), Collision_ClipToGenericEntity(), Collision_CombineTraces(), Con_Printf(), prvm_prog_t::edicts, trace_t::endpos, trace_t::ent, FL_MONSTER, flags, trace_t::fraction, i, int(), cvar_t::integer, Matrix4x4_CreateFromQuakeEntity(), Matrix4x4_CreateTranslate(), Matrix4x4_Invert_Simple(), max, MAX_EDICTS, maxs, min, mins, model, MOVE_HITMODEL, MOVE_MISSILE, MOVE_NOMONSTERS, MOVE_WORLDONLY, NULL, origin, owner, prvm_edict_t::priv, PRVM_EDICT_TO_PROG, PRVM_PROG_TO_EDICT, PRVM_serveredictedict, PRVM_serveredictfloat, PRVM_serveredictvector, prvm_edict_t::server, solid, SOLID_BBOX, SOLID_BSP, SOLID_CORPSE, trace_t::startsolid, SUPERCONTENTS_BODY, SUPERCONTENTS_CORPSE, sv, sv_debugmove, SV_EntitiesInBox(), SV_GetModelFromEdict(), SV_GetPitchSign(), SVVM_prog, server_t::time, type, VectorClear, VectorCompare, VectorCopy, VM_FrameBlendFromFrameGroupBlend(), VM_GenerateFrameGroupBlend(), VM_UpdateEdictSkeleton(), server_t::worldmodel, and trace_t::worldstartsolid.

Referenced by SV_TraceBox(), and SV_TraceLine().

SV_VM_ConsoleCommand()

qbool SV_VM_ConsoleCommand	(	const char *	text,
		size_t	textlen )

Definition at line 2927 of file svvm_cmds.c.

{
    prvm_prog_t *prog = SVVM_prog;
    return PRVM_ConsoleCommand(prog, text, textlen, &prog->funcoffsets.ConsoleCmd, true, PRVM_EDICT_TO_PROG(sv.world.prog->edicts), sv.time, "QC function ConsoleCmd is missing");
}

References prvm_prog_t::funcoffsets, world_t::prog, PRVM_ConsoleCommand(), PRVM_EDICT_TO_PROG, sv, SVVM_prog, server_t::time, and server_t::world.

Referenced by Cmd_CL_Callback(), and Cmd_SV_Callback().

SV_WriteClientdataToMessage()

void SV_WriteClientdataToMessage	(	client_t *	client,
		prvm_edict_t *	ent,
		sizebuf_t *	msg,
		int *	stats )

Definition at line 1091 of file sv_send.c.

{
    prvm_prog_t *prog = SVVM_prog;
    int     bits;
    int     i;
    prvm_edict_t    *other;
    int     items;
    vec3_t  punchvector;
    int     viewzoom;
    const char *s;
    float   *statsf = (float *)stats;
    float gravity;
 
//
// send a damage message
//
    if (PRVM_serveredictfloat(ent, dmg_take) || PRVM_serveredictfloat(ent, dmg_save))
    {
        other = PRVM_PROG_TO_EDICT(PRVM_serveredictedict(ent, dmg_inflictor));
        MSG_WriteByte (msg, svc_damage);
        MSG_WriteByte (msg, (int)PRVM_serveredictfloat(ent, dmg_save));
        MSG_WriteByte (msg, (int)PRVM_serveredictfloat(ent, dmg_take));
        for (i=0 ; i<3 ; i++)
            MSG_WriteCoord (msg, PRVM_serveredictvector(other, origin)[i] + 0.5*(PRVM_serveredictvector(other, mins)[i] + PRVM_serveredictvector(other, maxs)[i]), sv.protocol);
 
        PRVM_serveredictfloat(ent, dmg_take) = 0;
        PRVM_serveredictfloat(ent, dmg_save) = 0;
    }
 
//
// send the current viewpos offset from the view entity
//
    SV_SetIdealPitch ();        // how much to look up / down ideally
 
// a fixangle might get lost in a dropped packet.  Oh well.
    if(PRVM_serveredictfloat(ent, fixangle))
    {
        // angle fixing was requested by global thinking code...
        // so store the current angles for later use
        VectorCopy(PRVM_serveredictvector(ent, angles), host_client->fixangle_angles);
        host_client->fixangle_angles_set = true;
 
        // and clear fixangle for the next frame
        PRVM_serveredictfloat(ent, fixangle) = 0;
    }
 
    if (host_client->fixangle_angles_set)
    {
        MSG_WriteByte (msg, svc_setangle);
        for (i=0 ; i < 3 ; i++)
            MSG_WriteAngle (msg, host_client->fixangle_angles[i], sv.protocol);
        host_client->fixangle_angles_set = false;
    }
 
    // the runes are in serverflags, pack them into the items value, also pack
    // in the items2 value for mission pack huds
    // (used only in the mission packs, which do not use serverflags)
    items = (int)PRVM_serveredictfloat(ent, items)
        | (((int)PRVM_serveredictfloat(ent, items2) & ((1<<9)-1)) << 23)
        | (((int)PRVM_serverglobalfloat(serverflags) & ((1<<4)-1)) << 28);
 
    VectorCopy(PRVM_serveredictvector(ent, punchvector), punchvector);
 
    // cache weapon model name and index in client struct to save time
    // (this search can be almost 1% of cpu time!)
    s = PRVM_GetString(prog, PRVM_serveredictstring(ent, weaponmodel));
    if (strcmp(s, client->weaponmodel))
    {
        dp_strlcpy(client->weaponmodel, s, sizeof(client->weaponmodel));
        client->weaponmodelindex = SV_ModelIndex(s, 1);
    }
 
    viewzoom = (int)(PRVM_serveredictfloat(ent, viewzoom) * 255.0f);
    if (viewzoom == 0)
        viewzoom = 255;
 
    bits = 0;
 
    if ((int)PRVM_serveredictfloat(ent, flags) & FL_ONGROUND)
        bits |= SU_ONGROUND;
    if (PRVM_serveredictfloat(ent, waterlevel) >= 2)
        bits |= SU_INWATER;
    if (PRVM_serveredictfloat(ent, idealpitch))
        bits |= SU_IDEALPITCH;
 
    for (i=0 ; i<3 ; i++)
    {
        if (PRVM_serveredictvector(ent, punchangle)[i])
            bits |= (SU_PUNCH1<<i);
        if (sv.protocol != PROTOCOL_QUAKE && sv.protocol != PROTOCOL_QUAKEDP && sv.protocol != PROTOCOL_NEHAHRAMOVIE && sv.protocol != PROTOCOL_NEHAHRABJP && sv.protocol != PROTOCOL_NEHAHRABJP2 && sv.protocol != PROTOCOL_NEHAHRABJP3)
            if (punchvector[i])
                bits |= (SU_PUNCHVEC1<<i);
        if (PRVM_serveredictvector(ent, velocity)[i])
            bits |= (SU_VELOCITY1<<i);
    }
 
    gravity = PRVM_serveredictfloat(ent, gravity);if (!gravity) gravity = 1.0f;
 
    memset(stats, 0, sizeof(int[MAX_CL_STATS]));
    stats[STAT_VIEWHEIGHT] = (int)PRVM_serveredictvector(ent, view_ofs)[2];
    stats[STAT_ITEMS] = items;
    stats[STAT_WEAPONFRAME] = (int)PRVM_serveredictfloat(ent, weaponframe);
    stats[STAT_ARMOR] = (int)PRVM_serveredictfloat(ent, armorvalue);
    stats[STAT_WEAPON] = client->weaponmodelindex;
    stats[STAT_HEALTH] = (int)PRVM_serveredictfloat(ent, health);
    stats[STAT_AMMO] = (int)PRVM_serveredictfloat(ent, currentammo);
    stats[STAT_SHELLS] = (int)PRVM_serveredictfloat(ent, ammo_shells);
    stats[STAT_NAILS] = (int)PRVM_serveredictfloat(ent, ammo_nails);
    stats[STAT_ROCKETS] = (int)PRVM_serveredictfloat(ent, ammo_rockets);
    stats[STAT_CELLS] = (int)PRVM_serveredictfloat(ent, ammo_cells);
    stats[STAT_ACTIVEWEAPON] = (int)PRVM_serveredictfloat(ent, weapon);
    stats[STAT_VIEWZOOM] = viewzoom;
    stats[STAT_TOTALSECRETS] = (int)PRVM_serverglobalfloat(total_secrets);
    stats[STAT_TOTALMONSTERS] = (int)PRVM_serverglobalfloat(total_monsters);
    // the QC bumps these itself by sending svc_'s, so we have to keep them
    // zero or they'll be corrected by the engine
    //stats[STAT_SECRETS] = PRVM_serverglobalfloat(found_secrets);
    //stats[STAT_MONSTERS] = PRVM_serverglobalfloat(killed_monsters);
 
    if(!sv_qcstats.integer)
    {
        statsf[STAT_MOVEVARS_AIRACCEL_QW_STRETCHFACTOR] = sv_airaccel_qw_stretchfactor.value;
        statsf[STAT_MOVEVARS_AIRCONTROL_PENALTY] = sv_aircontrol_penalty.value;
        statsf[STAT_MOVEVARS_AIRSPEEDLIMIT_NONQW] = sv_airspeedlimit_nonqw.value;       
        statsf[STAT_MOVEVARS_AIRSTRAFEACCEL_QW] = sv_airstrafeaccel_qw.value;
        statsf[STAT_MOVEVARS_AIRCONTROL_POWER] = sv_aircontrol_power.value;
        // movement settings for prediction
        // note: these are not sent in protocols with lower MAX_CL_STATS limits
        stats[STAT_MOVEFLAGS] = MOVEFLAG_VALID
            | (sv_gameplayfix_q2airaccelerate.integer ? MOVEFLAG_Q2AIRACCELERATE : 0)
            | (sv_gameplayfix_nogravityonground.integer ? MOVEFLAG_NOGRAVITYONGROUND : 0)
            | (sv_gameplayfix_gravityunaffectedbyticrate.integer ? MOVEFLAG_GRAVITYUNAFFECTEDBYTICRATE : 0)
        ;
        statsf[STAT_MOVEVARS_WARSOWBUNNY_AIRFORWARDACCEL] = sv_warsowbunny_airforwardaccel.value;
        statsf[STAT_MOVEVARS_WARSOWBUNNY_ACCEL] = sv_warsowbunny_accel.value;
        statsf[STAT_MOVEVARS_WARSOWBUNNY_TOPSPEED] = sv_warsowbunny_topspeed.value;
        statsf[STAT_MOVEVARS_WARSOWBUNNY_TURNACCEL] = sv_warsowbunny_turnaccel.value;
        statsf[STAT_MOVEVARS_WARSOWBUNNY_BACKTOSIDERATIO] = sv_warsowbunny_backtosideratio.value;
        statsf[STAT_MOVEVARS_AIRSTOPACCELERATE] = sv_airstopaccelerate.value;
        statsf[STAT_MOVEVARS_AIRSTRAFEACCELERATE] = sv_airstrafeaccelerate.value;
        statsf[STAT_MOVEVARS_MAXAIRSTRAFESPEED] = sv_maxairstrafespeed.value;
        statsf[STAT_MOVEVARS_AIRCONTROL] = sv_aircontrol.value;
        statsf[STAT_FRAGLIMIT] = fraglimit.value;
        statsf[STAT_TIMELIMIT] = timelimit.value;
        statsf[STAT_MOVEVARS_FRICTION] = sv_friction.value; 
        statsf[STAT_MOVEVARS_WATERFRICTION] = sv_waterfriction.value >= 0 ? sv_waterfriction.value : sv_friction.value;
        statsf[STAT_MOVEVARS_TICRATE] = sys_ticrate.value;
        statsf[STAT_MOVEVARS_TIMESCALE] = host_timescale.value;
        statsf[STAT_MOVEVARS_GRAVITY] = sv_gravity.value;
        statsf[STAT_MOVEVARS_STOPSPEED] = sv_stopspeed.value;
        statsf[STAT_MOVEVARS_MAXSPEED] = sv_maxspeed.value;
        statsf[STAT_MOVEVARS_SPECTATORMAXSPEED] = sv_maxspeed.value; // FIXME: QW has a separate cvar for this
        statsf[STAT_MOVEVARS_ACCELERATE] = sv_accelerate.value;
        statsf[STAT_MOVEVARS_AIRACCELERATE] = sv_airaccelerate.value >= 0 ? sv_airaccelerate.value : sv_accelerate.value;
        statsf[STAT_MOVEVARS_WATERACCELERATE] = sv_wateraccelerate.value >= 0 ? sv_wateraccelerate.value : sv_accelerate.value;
        statsf[STAT_MOVEVARS_ENTGRAVITY] = gravity;
        statsf[STAT_MOVEVARS_JUMPVELOCITY] = sv_jumpvelocity.value;
        statsf[STAT_MOVEVARS_EDGEFRICTION] = sv_edgefriction.value;
        statsf[STAT_MOVEVARS_MAXAIRSPEED] = sv_maxairspeed.value;
        statsf[STAT_MOVEVARS_STEPHEIGHT] = sv_stepheight.value;
        statsf[STAT_MOVEVARS_AIRACCEL_QW] = sv_airaccel_qw.value;
        statsf[STAT_MOVEVARS_AIRACCEL_SIDEWAYS_FRICTION] = sv_airaccel_sideways_friction.value;
    }
 
    if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3 || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4 || sv.protocol == PROTOCOL_DARKPLACES5)
    {
        if (stats[STAT_VIEWHEIGHT] != DEFAULT_VIEWHEIGHT) bits |= SU_VIEWHEIGHT;
        bits |= SU_ITEMS;
        if (stats[STAT_WEAPONFRAME]) bits |= SU_WEAPONFRAME;
        if (stats[STAT_ARMOR]) bits |= SU_ARMOR;
        bits |= SU_WEAPON;
        // FIXME: which protocols support this?  does PROTOCOL_DARKPLACES3 support viewzoom?
        if (sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4 || sv.protocol == PROTOCOL_DARKPLACES5)
            if (viewzoom != 255)
                bits |= SU_VIEWZOOM;
    }
 
    if (bits >= 65536)
        bits |= SU_EXTEND1;
    if (bits >= 16777216)
        bits |= SU_EXTEND2;
 
    // send the data
    MSG_WriteByte (msg, svc_clientdata);
    MSG_WriteShort (msg, bits);
    if (bits & SU_EXTEND1)
        MSG_WriteByte(msg, bits >> 16);
    if (bits & SU_EXTEND2)
        MSG_WriteByte(msg, bits >> 24);
 
    if (bits & SU_VIEWHEIGHT)
        MSG_WriteChar (msg, stats[STAT_VIEWHEIGHT]);
 
    if (bits & SU_IDEALPITCH)
        MSG_WriteChar (msg, (int)PRVM_serveredictfloat(ent, idealpitch));
 
    for (i=0 ; i<3 ; i++)
    {
        if (bits & (SU_PUNCH1<<i))
        {
            if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
                MSG_WriteChar(msg, (int)PRVM_serveredictvector(ent, punchangle)[i]);
            else
                MSG_WriteAngle16i(msg, PRVM_serveredictvector(ent, punchangle)[i]);
        }
        if (bits & (SU_PUNCHVEC1<<i))
        {
            if (sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
                MSG_WriteCoord16i(msg, punchvector[i]);
            else
                MSG_WriteCoord32f(msg, punchvector[i]);
        }
        if (bits & (SU_VELOCITY1<<i))
        {
            if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3 || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
                MSG_WriteChar(msg, (int)(PRVM_serveredictvector(ent, velocity)[i] * (1.0f / 16.0f)));
            else
                MSG_WriteCoord32f(msg, PRVM_serveredictvector(ent, velocity)[i]);
        }
    }
 
    if (bits & SU_ITEMS)
        MSG_WriteLong (msg, stats[STAT_ITEMS]);
 
    if (sv.protocol == PROTOCOL_DARKPLACES5)
    {
        if (bits & SU_WEAPONFRAME)
            MSG_WriteShort (msg, stats[STAT_WEAPONFRAME]);
        if (bits & SU_ARMOR)
            MSG_WriteShort (msg, stats[STAT_ARMOR]);
        if (bits & SU_WEAPON)
            MSG_WriteShort (msg, stats[STAT_WEAPON]);
        MSG_WriteShort (msg, stats[STAT_HEALTH]);
        MSG_WriteShort (msg, stats[STAT_AMMO]);
        MSG_WriteShort (msg, stats[STAT_SHELLS]);
        MSG_WriteShort (msg, stats[STAT_NAILS]);
        MSG_WriteShort (msg, stats[STAT_ROCKETS]);
        MSG_WriteShort (msg, stats[STAT_CELLS]);
        MSG_WriteShort (msg, stats[STAT_ACTIVEWEAPON]);
        if (bits & SU_VIEWZOOM)
            MSG_WriteShort (msg, bound(0, stats[STAT_VIEWZOOM], 65535));
    }
    else if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3 || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
    {
        if (bits & SU_WEAPONFRAME)
            MSG_WriteByte (msg, stats[STAT_WEAPONFRAME]);
        if (bits & SU_ARMOR)
            MSG_WriteByte (msg, stats[STAT_ARMOR]);
        if (bits & SU_WEAPON)
        {
            if (sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
                MSG_WriteShort (msg, stats[STAT_WEAPON]);
            else
                MSG_WriteByte (msg, stats[STAT_WEAPON]);
        }
        MSG_WriteShort (msg, stats[STAT_HEALTH]);
        MSG_WriteByte (msg, stats[STAT_AMMO]);
        MSG_WriteByte (msg, stats[STAT_SHELLS]);
        MSG_WriteByte (msg, stats[STAT_NAILS]);
        MSG_WriteByte (msg, stats[STAT_ROCKETS]);
        MSG_WriteByte (msg, stats[STAT_CELLS]);
        if (gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE || gamemode == GAME_QUOTH || IS_OLDNEXUIZ_DERIVED(gamemode))
        {
            for (i = 0;i < 32;i++)
                if (stats[STAT_ACTIVEWEAPON] & (1<<i))
                    break;
            MSG_WriteByte (msg, i);
        }
        else
            MSG_WriteByte (msg, stats[STAT_ACTIVEWEAPON]);
        if (bits & SU_VIEWZOOM)
        {
            if (sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
                MSG_WriteByte (msg, bound(0, stats[STAT_VIEWZOOM], 255));
            else
                MSG_WriteShort (msg, bound(0, stats[STAT_VIEWZOOM], 65535));
        }
    }
}

References ammo_cells, ammo_nails, ammo_rockets, ammo_shells, angles, armorvalue, bound, currentammo, DEFAULT_VIEWHEIGHT, dmg_inflictor, dmg_save, dmg_take, dp_strlcpy, fixangle, client_t::fixangle_angles, client_t::fixangle_angles_set, FL_ONGROUND, flags, fraglimit, GAME_HIPNOTIC, GAME_QUOTH, GAME_ROGUE, gamemode, health, host_client, host_timescale, i, idealpitch, int(), cvar_t::integer, IS_OLDNEXUIZ_DERIVED, items, MAX_CL_STATS, maxs, mins, MOVEFLAG_GRAVITYUNAFFECTEDBYTICRATE, MOVEFLAG_NOGRAVITYONGROUND, MOVEFLAG_Q2AIRACCELERATE, MOVEFLAG_VALID, MSG_WriteAngle(), MSG_WriteAngle16i(), MSG_WriteByte(), MSG_WriteChar(), MSG_WriteCoord(), MSG_WriteCoord16i(), MSG_WriteCoord32f(), MSG_WriteLong(), MSG_WriteShort(), origin, other, server_t::protocol, PROTOCOL_DARKPLACES1, PROTOCOL_DARKPLACES2, PROTOCOL_DARKPLACES3, PROTOCOL_DARKPLACES4, PROTOCOL_DARKPLACES5, PROTOCOL_NEHAHRABJP, PROTOCOL_NEHAHRABJP2, PROTOCOL_NEHAHRABJP3, PROTOCOL_NEHAHRAMOVIE, PROTOCOL_QUAKE, PROTOCOL_QUAKEDP, PRVM_GetString(), PRVM_PROG_TO_EDICT, PRVM_serveredictedict, PRVM_serveredictfloat, PRVM_serveredictstring, PRVM_serveredictvector, PRVM_serverglobalfloat, punchangle, punchvector, serverflags, STAT_ACTIVEWEAPON, STAT_AMMO, STAT_ARMOR, STAT_CELLS, STAT_FRAGLIMIT, STAT_HEALTH, STAT_ITEMS, STAT_MOVEFLAGS, STAT_MOVEVARS_ACCELERATE, STAT_MOVEVARS_AIRACCEL_QW, STAT_MOVEVARS_AIRACCEL_QW_STRETCHFACTOR, STAT_MOVEVARS_AIRACCEL_SIDEWAYS_FRICTION, STAT_MOVEVARS_AIRACCELERATE, STAT_MOVEVARS_AIRCONTROL, STAT_MOVEVARS_AIRCONTROL_PENALTY, STAT_MOVEVARS_AIRCONTROL_POWER, STAT_MOVEVARS_AIRSPEEDLIMIT_NONQW, STAT_MOVEVARS_AIRSTOPACCELERATE, STAT_MOVEVARS_AIRSTRAFEACCEL_QW, STAT_MOVEVARS_AIRSTRAFEACCELERATE, STAT_MOVEVARS_EDGEFRICTION, STAT_MOVEVARS_ENTGRAVITY, STAT_MOVEVARS_FRICTION, STAT_MOVEVARS_GRAVITY, STAT_MOVEVARS_JUMPVELOCITY, STAT_MOVEVARS_MAXAIRSPEED, STAT_MOVEVARS_MAXAIRSTRAFESPEED, STAT_MOVEVARS_MAXSPEED, STAT_MOVEVARS_SPECTATORMAXSPEED, STAT_MOVEVARS_STEPHEIGHT, STAT_MOVEVARS_STOPSPEED, STAT_MOVEVARS_TICRATE, STAT_MOVEVARS_TIMESCALE, STAT_MOVEVARS_WARSOWBUNNY_ACCEL, STAT_MOVEVARS_WARSOWBUNNY_AIRFORWARDACCEL, STAT_MOVEVARS_WARSOWBUNNY_BACKTOSIDERATIO, STAT_MOVEVARS_WARSOWBUNNY_TOPSPEED, STAT_MOVEVARS_WARSOWBUNNY_TURNACCEL, STAT_MOVEVARS_WATERACCELERATE, STAT_MOVEVARS_WATERFRICTION, STAT_NAILS, STAT_ROCKETS, STAT_SHELLS, STAT_TIMELIMIT, STAT_TOTALMONSTERS, STAT_TOTALSECRETS, STAT_VIEWHEIGHT, STAT_VIEWZOOM, STAT_WEAPON, STAT_WEAPONFRAME, SU_ARMOR, SU_EXTEND1, SU_EXTEND2, SU_IDEALPITCH, SU_INWATER, SU_ITEMS, SU_ONGROUND, SU_PUNCH1, SU_PUNCHVEC1, SU_VELOCITY1, SU_VIEWHEIGHT, SU_VIEWZOOM, SU_WEAPON, SU_WEAPONFRAME, sv, sv_accelerate, sv_airaccel_qw, sv_airaccel_qw_stretchfactor, sv_airaccel_sideways_friction, sv_airaccelerate, sv_aircontrol, sv_aircontrol_penalty, sv_aircontrol_power, sv_airspeedlimit_nonqw, sv_airstopaccelerate, sv_airstrafeaccel_qw, sv_airstrafeaccelerate, sv_edgefriction, sv_friction, sv_gameplayfix_gravityunaffectedbyticrate, sv_gameplayfix_nogravityonground, sv_gameplayfix_q2airaccelerate, sv_gravity, sv_jumpvelocity, sv_maxairspeed, sv_maxairstrafespeed, sv_maxspeed, SV_ModelIndex(), sv_qcstats, SV_SetIdealPitch(), sv_stepheight, sv_stopspeed, sv_warsowbunny_accel, sv_warsowbunny_airforwardaccel, sv_warsowbunny_backtosideratio, sv_warsowbunny_topspeed, sv_warsowbunny_turnaccel, sv_wateraccelerate, sv_waterfriction, svc_clientdata, svc_damage, svc_setangle, SVVM_prog, sys_ticrate, timelimit, total_monsters, total_secrets, cvar_t::value, VectorCopy, velocity, view_ofs, viewzoom, waterlevel, weapon, weaponframe, client_t::weaponmodel, weaponmodel, and client_t::weaponmodelindex.

Referenced by SV_SendClientDatagram(), and SV_Spawn_f().

SV_WriteEntitiesToClient()

void SV_WriteEntitiesToClient	(	client_t *	client,
		prvm_edict_t *	clent,
		sizebuf_t *	msg,
		int	maxsize )

Definition at line 337 of file sv_ents.c.

{
    prvm_prog_t *prog = SVVM_prog;
    qbool need_empty = false;
    int i, numsendstates, numcsqcsendstates;
    entity_state_t *s;
    prvm_edict_t *camera;
    qbool success;
    vec3_t eye;
 
    // if there isn't enough space to accomplish anything, skip it
    if (msg->cursize + 25 > maxsize)
        return;
 
    sv.writeentitiestoclient_msg = msg;
    sv.writeentitiestoclient_clientnumber = client - svs.clients;
 
    sv.writeentitiestoclient_stats_culled_pvs = 0;
    sv.writeentitiestoclient_stats_culled_trace = 0;
    sv.writeentitiestoclient_stats_visibleentities = 0;
    sv.writeentitiestoclient_stats_totalentities = 0;
    sv.writeentitiestoclient_numeyes = 0;
 
    // get eye location
    sv.writeentitiestoclient_cliententitynumber = PRVM_EDICT_TO_PROG(clent); // LadyHavoc: for comparison purposes
    camera = PRVM_EDICT_NUM( client->clientcamera );
    VectorAdd(PRVM_serveredictvector(camera, origin), PRVM_serveredictvector(clent, view_ofs), eye);
    // get the PVS values for the eye location, later FatPVS calls will merge
    if (sv.worldmodel && sv.worldmodel->brush.FatPVS)
        sv.worldmodel->brush.FatPVS(sv.worldmodel, eye, 8, &sv.writeentitiestoclient_pvs, sv_mempool, false);
    else
        sv.writeentitiestoclient_pvs = NULL;
 
    // add the eye to a list for SV_CanSeeBox tests
    VectorCopy(eye, sv.writeentitiestoclient_eyes[sv.writeentitiestoclient_numeyes]);
    sv.writeentitiestoclient_numeyes++;
 
    // calculate predicted eye origin for SV_CanSeeBox tests
    if (sv_cullentities_trace_prediction.integer)
    {
        vec_t predtime = bound(0, host_client->ping, sv_cullentities_trace_prediction_time.value);
        vec3_t predeye;
        VectorMA(eye, predtime, PRVM_serveredictvector(camera, velocity), predeye);
        if (SV_CanSeeBox(1, 0, 0, 0, eye, predeye, predeye))
        {
            VectorCopy(predeye, sv.writeentitiestoclient_eyes[sv.writeentitiestoclient_numeyes]);
            sv.writeentitiestoclient_numeyes++;
        }
        //if (!sv.writeentitiestoclient_useprediction)
        //  Con_DPrintf("Trying to walk into solid in a pingtime... not predicting for culling\n");
    }
 
    SV_AddCameraEyes();
 
    // build PVS from the new eyes
    if (sv.worldmodel && sv.worldmodel->brush.FatPVS)
        for(i = 1; i < sv.writeentitiestoclient_numeyes; ++i)
            sv.worldmodel->brush.FatPVS(sv.worldmodel, sv.writeentitiestoclient_eyes[i], 8, &sv.writeentitiestoclient_pvs, sv_mempool, sv.writeentitiestoclient_pvs != NULL);
 
    sv.sententitiesmark++;
 
    for (i = 0;i < sv.numsendentities;i++)
        SV_MarkWriteEntityStateToClient(sv.sendentities + i, client);
 
    numsendstates = 0;
    numcsqcsendstates = 0;
    for (i = 0;i < sv.numsendentities;i++)
    {
        s = &sv.sendentities[i];
        if (sv.sententities[s->number] == sv.sententitiesmark)
        {
            if(s->active == ACTIVE_NETWORK)
            {
                if (s->exteriormodelforclient)
                {
                    if (s->exteriormodelforclient == sv.writeentitiestoclient_cliententitynumber)
                        s->flags |= RENDER_EXTERIORMODEL;
                    else
                        s->flags &= ~RENDER_EXTERIORMODEL;
                }
                sv.writeentitiestoclient_sendstates[numsendstates++] = s;
            }
            else if(sv.sendentities[i].active == ACTIVE_SHARED)
                sv.writeentitiestoclient_csqcsendstates[numcsqcsendstates++] = s->number;
            else
                Con_Printf("entity %d is in sv.sendentities and marked, but not active, please breakpoint me\n", s->number);
        }
    }
 
    if (sv_cullentities_stats.integer)
        Con_Printf("client \"%s\" entities: %d total, %d visible, %d culled by: %d pvs %d trace\n", client->name, sv.writeentitiestoclient_stats_totalentities, sv.writeentitiestoclient_stats_visibleentities, sv.writeentitiestoclient_stats_culled_pvs + sv.writeentitiestoclient_stats_culled_trace, sv.writeentitiestoclient_stats_culled_pvs, sv.writeentitiestoclient_stats_culled_trace);
 
    if(client->entitydatabase5)
        need_empty = EntityFrameCSQC_WriteFrame(msg, maxsize, numcsqcsendstates, sv.writeentitiestoclient_csqcsendstates, client->entitydatabase5->latestframenum + 1);
    else
        EntityFrameCSQC_WriteFrame(msg, maxsize, numcsqcsendstates, sv.writeentitiestoclient_csqcsendstates, 0);
 
    // force every 16th frame to be not empty (or cl_movement replay takes
    // too long)
    // BTW, this should normally not kick in any more due to the check
    // below, except if the client stopped sending movement frames
    if(client->num_skippedentityframes >= 16)
        need_empty = true;
 
    // help cl_movement a bit more
    if(client->movesequence != client->lastmovesequence)
        need_empty = true;
    client->lastmovesequence = client->movesequence;
 
    if (client->entitydatabase5)
        success = EntityFrame5_WriteFrame(msg, maxsize, client->entitydatabase5, numsendstates, sv.writeentitiestoclient_sendstates, client - svs.clients + 1, client->movesequence, need_empty);
    else if (client->entitydatabase4)
    {
        success = EntityFrame4_WriteFrame(msg, maxsize, client->entitydatabase4, numsendstates, sv.writeentitiestoclient_sendstates);
        Protocol_WriteStatsReliable();
    }
    else if (client->entitydatabase)
    {
        success = EntityFrame_WriteFrame(msg, maxsize, client->entitydatabase, numsendstates, sv.writeentitiestoclient_sendstates, client - svs.clients + 1);
        Protocol_WriteStatsReliable();
    }
    else
    {
        success = EntityFrameQuake_WriteFrame(msg, maxsize, numsendstates, sv.writeentitiestoclient_sendstates);
        Protocol_WriteStatsReliable();
    }
 
    if(success)
        client->num_skippedentityframes = 0;
    else
        ++client->num_skippedentityframes;
}

References entity_state_t::active, ACTIVE_NETWORK, ACTIVE_SHARED, bound, client_t::clientcamera, server_static_t::clients, Con_Printf(), sizebuf_t::cursize, client_t::entitydatabase, client_t::entitydatabase4, client_t::entitydatabase5, EntityFrame4_WriteFrame(), EntityFrame5_WriteFrame(), EntityFrame_WriteFrame(), EntityFrameCSQC_WriteFrame(), EntityFrameQuake_WriteFrame(), entity_state_t::exteriormodelforclient, entity_state_t::flags, host_client, i, cvar_t::integer, client_t::lastmovesequence, entityframe5_database_t::latestframenum, client_t::movesequence, client_t::name, NULL, client_t::num_skippedentityframes, entity_state_t::number, server_t::numsendentities, origin, client_t::ping, Protocol_WriteStatsReliable(), PRVM_EDICT_NUM, PRVM_EDICT_TO_PROG, PRVM_serveredictvector, RENDER_EXTERIORMODEL, server_t::sendentities, server_t::sententities, server_t::sententitiesmark, sv, SV_AddCameraEyes(), SV_CanSeeBox(), sv_cullentities_stats, sv_cullentities_trace_prediction, sv_cullentities_trace_prediction_time, SV_MarkWriteEntityStateToClient(), sv_mempool, svs, SVVM_prog, cvar_t::value, VectorAdd, VectorCopy, VectorMA, velocity, view_ofs, server_t::worldmodel, server_t::writeentitiestoclient_cliententitynumber, server_t::writeentitiestoclient_clientnumber, server_t::writeentitiestoclient_csqcsendstates, server_t::writeentitiestoclient_eyes, server_t::writeentitiestoclient_msg, server_t::writeentitiestoclient_numeyes, server_t::writeentitiestoclient_pvs, server_t::writeentitiestoclient_sendstates, server_t::writeentitiestoclient_stats_culled_pvs, server_t::writeentitiestoclient_stats_culled_trace, server_t::writeentitiestoclient_stats_totalentities, and server_t::writeentitiestoclient_stats_visibleentities.

Referenced by SV_SendClientDatagram().

VM_CustomStats_Clear()

void VM_CustomStats_Clear

(

void

)

Definition at line 1717 of file svvm_cmds.c.

{
    memset(vm_customstats, 0, sizeof(vm_customstats));
    vm_customstats_last = -1;
}

References vm_customstats, and vm_customstats_last.

Referenced by SV_VM_Setup().

VM_SV_MoveToGoal()

void VM_SV_MoveToGoal

(

prvm_prog_t *

prog

)

Definition at line 420 of file sv_move.c.

{
    prvm_edict_t        *ent, *goal;
    float       dist;
 
    VM_SAFEPARMCOUNT(1, VM_SV_MoveToGoal);
 
    ent = PRVM_PROG_TO_EDICT(PRVM_serverglobaledict(self));
    goal = PRVM_PROG_TO_EDICT(PRVM_serveredictedict(ent, goalentity));
    dist = PRVM_G_FLOAT(OFS_PARM0);
 
    if ( !( (int)PRVM_serveredictfloat(ent, flags) & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )
    {
        PRVM_G_FLOAT(OFS_RETURN) = 0;
        return;
    }
 
// if the next step hits the enemy, return immediately
    if ( PRVM_PROG_TO_EDICT(PRVM_serveredictedict(ent, enemy)) != prog->edicts &&  SV_CloseEnough (ent, goal, dist) )
        return;
 
// bump around...
    if ( (rand()&3)==1 ||
    !SV_StepDirection (ent, PRVM_serveredictfloat(ent, ideal_yaw), dist))
    {
        SV_NewChaseDir (ent, goal, dist);
    }
}

References prvm_prog_t::edicts, enemy, FL_FLY, FL_ONGROUND, FL_SWIM, flags, goalentity, ideal_yaw, OFS_PARM0, OFS_RETURN, PRVM_G_FLOAT, PRVM_PROG_TO_EDICT, PRVM_serveredictedict, PRVM_serveredictfloat, PRVM_serverglobaledict, self, SV_CloseEnough(), SV_NewChaseDir(), SV_StepDirection(), VM_SAFEPARMCOUNT, and VM_SV_MoveToGoal().

Referenced by VM_SV_MoveToGoal().

VM_SV_UpdateCustomStats()

void VM_SV_UpdateCustomStats	(	client_t *	client,
		prvm_edict_t *	ent,
		sizebuf_t *	msg,
		int *	stats )

Definition at line 1723 of file svvm_cmds.c.

{
    prvm_prog_t *prog = SVVM_prog;
    int         i;
    char        s[17];
    union {
        int i;
        float f;
    } u;
 
    for(i=MIN_VM_STAT; i<=vm_customstats_last ;i++)
    {
        if(!vm_customstats[i].type)
            continue;
        switch(vm_customstats[i].type)
        {
        //string as 16 bytes
        case 1:
            memset(s, 0, 17);
            dp_strlcpy(s, PRVM_E_STRING(ent, vm_customstats[i].fieldoffset), 16);
            stats[i] = s[ 0] + s[ 1] * 256 + s[ 2] * 65536 + s[ 3] * 16777216;
            stats[i+1] = s[ 4] + s[ 5] * 256 + s[ 6] * 65536 + s[ 7] * 16777216;
            stats[i+2] = s[ 8] + s[ 9] * 256 + s[10] * 65536 + s[11] * 16777216;
            stats[i+3] = s[12] + s[13] * 256 + s[14] * 65536 + s[15] * 16777216;
            break;
        //float field sent as-is
        case 8:
            // can't directly use PRVM_E_INT on the field because it may be PRVM_64 and a double is not the representation we want to send
            u.f = PRVM_E_FLOAT(ent, vm_customstats[i].fieldoffset);
            stats[i] = u.i;
            break;
        //integer value of float field
        case 2:
            stats[i] = (int)PRVM_E_FLOAT(ent, vm_customstats[i].fieldoffset);
            break;
        default:
            break;
        }
    }
}

References dp_strlcpy, f, i, int(), MIN_VM_STAT, PRVM_E_FLOAT, PRVM_E_STRING, SVVM_prog, type, vm_customstats, and vm_customstats_last.

Referenced by SV_SendClientDatagram().

Variable Documentation

coop

cvar_t coop

extern

Definition at line 30 of file progsdefs.qc.

Referenced by CL_VM_UpdateCoopDeathmatchGlobals(), M_GameOptions_Draw(), M_NetStart_Change(), SV_Init(), SV_SendServerinfo(), SV_ServerOptions(), SV_SpawnServer(), and SV_VM_Setup().

deathmatch

cvar_t deathmatch

extern

Definition at line 29 of file progsdefs.qc.

Referenced by CL_VM_UpdateCoopDeathmatchGlobals(), M_GameOptions_Draw(), M_NetStart_Change(), SV_Init(), SV_MaxPlayers_f(), SV_SendServerinfo(), SV_ServerOptions(), SV_SpawnServer(), SV_VM_Setup(), and SVVM_load_edict().

fraglimit

cvar_t fraglimit

extern

Definition at line 45 of file sv_main.c.

{CF_SERVER | CF_NOTIFY, "fraglimit","0", "ends level if this many frags is reached by any player"};

Referenced by M_GameOptions_Draw(), M_NetStart_Change(), SV_Init(), and SV_WriteClientdataToMessage().

gamecfg

cvar_t gamecfg

extern

Definition at line 46 of file sv_main.c.

{CF_SERVER, "gamecfg", "0", "unused cvar in quake, can be used by mods"};

Referenced by SV_Init().

host_client

client_t* host_client

extern

Definition at line 29 of file sv_main.c.

Referenced by Cmd_ExecuteString(), Download_CheckExtensions(), DropPunchAngle(), EntityFrame5_LostFrame(), EntityFrame5_WriteFrame(), NetConn_ServerParsePacket(), Protocol_UpdateClientStats(), Protocol_WriteStatsReliable(), RCon_Execute(), SV_Accelerate(), SV_AirAccelerate(), SV_AirMove(), SV_ApplyClientMove(), SV_Begin_f(), SV_CheckTimeouts(), SV_ClientCommands(), SV_ClientPrint(), SV_Color_f(), SV_Download_f(), SV_DropClient(), SV_Ent_Create_f(), SV_Ent_Remove_f(), SV_ExecuteClientMoves(), SV_Fly_f(), SV_FrameAck(), SV_FrameLost(), SV_Give_f(), SV_God_f(), SV_Kick_f(), SV_Kill_f(), SV_Name(), SV_Name_f(), SV_Noclip_f(), SV_Notarget_f(), SV_Pause_f(), SV_Physics(), SV_Physics_ClientEntity(), SV_Physics_ClientEntity_PostThink(), SV_Physics_ClientEntity_PreThink(), SV_Physics_ClientMove(), SV_Pings_f(), SV_Playermodel_f(), SV_PlayerPhysics(), SV_Playerskin_f(), SV_PModel_f(), SV_PreSpawn_f(), SV_Rate_BurstSize_f(), SV_Rate_f(), SV_ReadClientMessage(), SV_ReadClientMove(), SV_SaveSpawnparms(), SV_Say(), SV_SendClientDatagram(), SV_SendClientMessages(), SV_SendCvar_f(), SV_SendServerinfo(), SV_SetIdealPitch(), SV_Shutdown(), SV_Spawn_f(), SV_SpawnServer(), SV_StartDownload_f(), SV_Status_f(), SV_Tell_f(), SV_ThreadFunc(), SV_UpdateToReliableMessages(), SV_UserFriction(), SV_WaterJump(), SV_WaterMove(), SV_WriteClientdataToMessage(), SV_WriteEntitiesToClient(), Sys_Error(), VM_SV_clientcommand(), VM_SV_dropclient(), and VM_SV_stuffcmd().

host_limitlocal

cvar_t host_limitlocal

extern

Definition at line 150 of file sv_main.c.

{CF_SERVER, "host_limitlocal", "0", "whether to apply rate limiting to the local player in a listen server (only useful for testing)"};

Referenced by SV_Init(), and SV_SendClientDatagram().

host_timescale

cvar_t host_timescale

extern

Definition at line 53 of file sv_main.c.

{CF_CLIENT | CF_SERVER, "host_timescale", "1.0", "controls game speed, 0.5 is half speed, 2 is double speed"};

Referenced by SV_Frame(), SV_Init(), and SV_ThreadFunc().

noexit

cvar_t noexit

extern

Definition at line 47 of file sv_main.c.

{CF_SERVER | CF_NOTIFY, "noexit","0", "kills anyone attempting to use an exit"};

Referenced by SV_Init().

nomonsters

cvar_t nomonsters

extern

Definition at line 48 of file sv_main.c.

{CF_SERVER, "nomonsters", "0", "unused cvar in quake, can be used by mods"};

Referenced by SV_Init().

pausable

cvar_t pausable

extern

Definition at line 49 of file sv_main.c.

{CF_SERVER, "pausable","1", "allow players to pause or not (otherwise, only the server admin can)"};

Referenced by SV_Init(), and SV_Pause_f().

pr_checkextension

cvar_t pr_checkextension

extern

Definition at line 50 of file sv_main.c.

{CF_SERVER | CF_READONLY, "pr_checkextension", "1", "indicates to QuakeC that the standard quakec extensions system is available (if 0, quakec should not attempt to use extensions)"};

Referenced by SV_Init().

samelevel

cvar_t samelevel

extern

Definition at line 51 of file sv_main.c.

{CF_SERVER | CF_NOTIFY, "samelevel","0", "repeats same level if level ends (due to timelimit or someone hitting an exit)"};

Referenced by SV_Init().

saved1

cvar_t saved1

extern

Definition at line 178 of file sv_main.c.

{CF_SERVER | CF_ARCHIVE, "saved1", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};

Referenced by SV_Init().

saved2

cvar_t saved2

extern

Definition at line 179 of file sv_main.c.

{CF_SERVER | CF_ARCHIVE, "saved2", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};

Referenced by SV_Init().

saved3

cvar_t saved3

extern

Definition at line 180 of file sv_main.c.

{CF_SERVER | CF_ARCHIVE, "saved3", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};

Referenced by SV_Init().

saved4

cvar_t saved4

extern

Definition at line 181 of file sv_main.c.

{CF_SERVER | CF_ARCHIVE, "saved4", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};

Referenced by SV_Init().

savedgamecfg

cvar_t savedgamecfg

extern

Definition at line 182 of file sv_main.c.

{CF_SERVER | CF_ARCHIVE, "savedgamecfg", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};

Referenced by SV_Init().

scratch1

cvar_t scratch1

extern

Definition at line 183 of file sv_main.c.

{CF_SERVER, "scratch1", "0", "unused cvar in quake, can be used by mods"};

Referenced by SV_Init().

scratch2

cvar_t scratch2

extern

Definition at line 184 of file sv_main.c.

{CF_SERVER,"scratch2", "0", "unused cvar in quake, can be used by mods"};

Referenced by SV_Init().

scratch3

cvar_t scratch3

extern

Definition at line 185 of file sv_main.c.

{CF_SERVER, "scratch3", "0", "unused cvar in quake, can be used by mods"};

Referenced by SV_Init().

scratch4

cvar_t scratch4

extern

Definition at line 186 of file sv_main.c.

{CF_SERVER, "scratch4", "0", "unused cvar in quake, can be used by mods"};

Referenced by SV_Init().

skill

cvar_t skill

extern

Definition at line 52 of file sv_main.c.

{CF_SERVER, "skill","1", "difficulty level of game, affects monster layouts in levels, 0 = easy, 1 = normal, 2 = hard, 3 = nightmare (same layout as hard but monsters fire twice)"};

Referenced by M_GameOptions_Draw(), M_NetStart_Change(), SV_Init(), SV_Loadgame_f(), and SV_SpawnServer().

sv

server_t sv

extern

local server

Definition at line 223 of file sv_main.c.

Referenced by CL_BeginDownloads(), CL_KeepaliveMessage(), CL_ParseServerInfo(), CL_Startdemos_f(), Cvar_SetQuick_Internal(), DropPunchAngle(), droptofloor_bsp_failcond(), EntityFrame5_WriteFrame(), EntityFrameCSQC_WriteFrame(), EntityFrameQuake_WriteFrame(), EntityState5_WriteUpdate(), EntityState_WriteFields(), FS_GameDir_f(), Host_Frame(), Host_Init(), M_GameOptions_Key(), M_Main_Key(), M_Menu_Main_f(), M_Menu_Save_f(), M_SinglePlayer_Key(), M_Transfusion_Skill_Key(), ModList_Enable(), Net_Heartbeat_f(), NetConn_BuildStatusResponse(), NetConn_ClientFrame(), NetConn_Close(), NetConn_Heartbeat(), NetConn_IsLocalGame(), NetConn_ServerParsePacket(), NetConn_sv_netport_Callback(), PHYS_NudgeOutOfSolid(), PHYS_TestEntityPosition(), PrintStats(), Protocol_WriteStatsReliable(), PRVM_ED_CallPostspawnFunction(), PRVM_ED_CallPrespawnFunction(), PRVM_ED_CallSpawnFunction(), PRVM_GarbageCollection(), QW_CL_RequestNextDownload(), R_DrawDebugModel(), Sbar_ShowFPS(), SCR_DrawNetGraph(), SCR_SetUpToDrawConsole(), SV_Accelerate(), SV_AirAccelerate(), SV_AirMove(), SV_AreaStats_f(), SV_Begin_f(), SV_CanSeeBox(), SV_Changelevel_f(), SV_CheckContentsTransition(), SV_Color_f(), SV_ConnectClient(), SV_CreateBaseline(), SV_Download_f(), SV_DropClient(), SV_EntitiesInBox(), SV_ExecuteClientMoves(), SV_FlushBroadcastMessages(), SV_Frame(), SV_GetEntityLocalTagMatrix(), SV_GetModelByIndex(), SV_GetModelFromEdict(), SV_GetTagMatrix(), SV_Gravity(), SV_Impact(), SV_IsLocalServer(), SV_Kick_f(), SV_Kill_f(), SV_LinkEdict(), SV_LinkEdict_TouchAreaGrid_Call(), SV_Loadgame_f(), SV_Map_f(), SV_MarkWriteEntityStateToClient(), SV_MaxPlayers_f(), SV_ModelIndex(), SV_Name(), SV_ParticleEffectIndex(), SV_Pause_f(), SV_Physics(), SV_Physics_ClientEntity(), SV_Physics_ClientEntity_NoThink(), SV_Physics_ClientEntity_PostThink(), SV_Physics_ClientEntity_PreThink(), SV_Physics_ClientMove(), SV_Physics_Entity(), SV_Physics_Pusher(), SV_Physics_Step(), SV_Physics_Toss(), SV_Ping_f(), SV_Pings_f(), SV_PlayerPhysics(), SV_PointSuperContents(), SV_Prepare_CSQC(), SV_PrepareEntitiesForSending(), SV_PrepareEntityForSending(), SV_PreSpawn_f(), SV_PushMove(), SV_ReadClientMessage(), SV_ReadClientMove(), SV_Restart_f(), SV_RunThink(), SV_SaveEntFile_f(), SV_Savegame_f(), SV_Savegame_to(), SV_SaveSpawnparms(), SV_SendClientDatagram(), SV_SendClientMessages(), SV_SendCvar_f(), SV_SendServerinfo(), SV_Shutdown(), SV_SoundIndex(), SV_Spawn_f(), SV_SpawnServer(), SV_StartEffect(), SV_StartParticle(), SV_StartPointSound(), SV_StartSound(), SV_Status_f(), SV_ThreadFunc(), SV_TimingReport(), SV_TraceBox(), SV_TraceLine(), SV_TracePoint(), SV_UpdateToReliableMessages(), SV_UserFriction(), SV_Viewframe_f(), SV_Viewmodel_f(), SV_Viewnext_f(), SV_Viewprev_f(), SV_VM_ConsoleCommand(), SV_VM_Setup(), SV_VM_Shutdown(), SV_WalkMove(), SV_WaterJump(), SV_WaterMove(), SV_WriteClientdataToMessage(), SV_WriteEntitiesToClient(), SVVM_begin_increase_edicts(), SVVM_free_edict(), SVVM_reset_cmd(), Sys_Error(), VM_bprint(), VM_changelevel(), VM_isserver(), VM_M_WriteAngle(), VM_M_WriteCoord(), VM_M_WriteDest(), VM_sprint(), VM_SV_ambientsound(), VM_SV_checkclient(), VM_SV_checkpvs(), VM_SV_droptofloor(), VM_SV_getlight(), VM_SV_gettaginfo(), VM_SV_lightstyle(), VM_SV_makestatic(), VM_SV_modelnameforindex(), VM_SV_newcheckclient(), VM_SV_pointparticles(), VM_SV_setcolor(), VM_SV_setmodel(), VM_SV_setmodelindex(), VM_SV_setpause(), VM_SV_skel_build(), VM_SV_te_beam(), VM_SV_te_blood(), VM_SV_te_bloodshower(), VM_SV_te_customflash(), VM_SV_te_explosion(), VM_SV_te_explosion2(), VM_SV_te_explosionquad(), VM_SV_te_explosionrgb(), VM_SV_te_flamejet(), VM_SV_te_gunshot(), VM_SV_te_gunshotquad(), VM_SV_te_knightspike(), VM_SV_te_lavasplash(), VM_SV_te_lightning1(), VM_SV_te_lightning2(), VM_SV_te_lightning3(), VM_SV_te_particlecube(), VM_SV_te_particlerain(), VM_SV_te_particlesnow(), VM_SV_te_plasmaburn(), VM_SV_te_smallflash(), VM_SV_te_spark(), VM_SV_te_spike(), VM_SV_te_spikequad(), VM_SV_te_superspike(), VM_SV_te_superspikequad(), VM_SV_te_tarexplosion(), VM_SV_te_teleport(), VM_SV_te_wizspike(), VM_SV_trailparticles(), VM_SV_WriteAngle(), VM_SV_WriteCoord(), and WriteDest().

sv_accelerate

cvar_t sv_accelerate

extern

Definition at line 55 of file sv_main.c.

{CF_SERVER, "sv_accelerate", "10", "rate at which a player accelerates to sv_maxspeed"};

Referenced by SV_Accelerate(), SV_AirAccelerate(), SV_Init(), SV_WaterMove(), and SV_WriteClientdataToMessage().

sv_aim

cvar_t sv_aim

extern

Definition at line 56 of file sv_main.c.

{CF_SERVER | CF_ARCHIVE, "sv_aim", "2", "maximum cosine angle for quake's vertical autoaim, a value above 1 completely disables the autoaim, quake used 0.93"};

Referenced by SV_Init(), and VM_SV_aim().

sv_airaccel_qw

cvar_t sv_airaccel_qw

extern

Definition at line 57 of file sv_main.c.

{CF_SERVER, "sv_airaccel_qw", "1", "ratio of QW-style air control as opposed to simple acceleration; when < 0, the speed is clamped against the maximum allowed forward speed after the move"};

Referenced by SV_Init(), and SV_WriteClientdataToMessage().

sv_airaccel_sideways_friction

cvar_t sv_airaccel_sideways_friction

extern

Definition at line 59 of file sv_main.c.

{CF_SERVER, "sv_airaccel_sideways_friction", "", "anti-sideways movement stabilization (reduces speed gain when zigzagging); when < 0, only so much friction is applied that braking (by accelerating backwards) cannot be stronger"};

Referenced by SV_Init(), and SV_WriteClientdataToMessage().

sv_airaccelerate

cvar_t sv_airaccelerate

extern

Definition at line 60 of file sv_main.c.

{CF_SERVER, "sv_airaccelerate", "-1", "rate at which a player accelerates to sv_maxairspeed while in the air, if less than 0 the sv_accelerate variable is used instead"};

Referenced by SV_AirAccelerate(), SV_Init(), and SV_WriteClientdataToMessage().

sv_aircontrol

cvar_t sv_aircontrol

extern

Definition at line 66 of file sv_main.c.

{CF_SERVER, "sv_aircontrol", "0", "CPMA-style air control"};

Referenced by SV_Init(), and SV_WriteClientdataToMessage().

sv_aircontrol_penalty

cvar_t sv_aircontrol_penalty

extern

Definition at line 68 of file sv_main.c.

{CF_SERVER, "sv_aircontrol_penalty", "0", "deceleration while using CPMA-style air control"};

Referenced by SV_Init(), and SV_WriteClientdataToMessage().

sv_aircontrol_power

cvar_t sv_aircontrol_power

extern

Definition at line 67 of file sv_main.c.

{CF_SERVER, "sv_aircontrol_power", "2", "CPMA-style air control exponent"};

Referenced by SV_Init(), and SV_WriteClientdataToMessage().

sv_airspeedlimit_nonqw

cvar_t sv_airspeedlimit_nonqw

extern

Definition at line 62 of file sv_main.c.

{CF_SERVER, "sv_airspeedlimit_nonqw", "0", "when set, this is a soft speed limit while in air when using airaccel_qw not equal to 1"};

Referenced by SV_Init(), and SV_WriteClientdataToMessage().

sv_airstopaccelerate

cvar_t sv_airstopaccelerate

extern

Definition at line 61 of file sv_main.c.

{CF_SERVER, "sv_airstopaccelerate", "0", "when set, replacement for sv_airaccelerate when moving backwards"};

Referenced by SV_Init(), and SV_WriteClientdataToMessage().

sv_airstrafeaccel_qw

cvar_t sv_airstrafeaccel_qw

extern

Definition at line 65 of file sv_main.c.

{CF_SERVER, "sv_airstrafeaccel_qw", "0", "when set, replacement for sv_airaccel_qw when just strafing"};

Referenced by SV_Init(), and SV_WriteClientdataToMessage().

sv_airstrafeaccelerate

cvar_t sv_airstrafeaccelerate

extern

Definition at line 63 of file sv_main.c.

{CF_SERVER, "sv_airstrafeaccelerate", "0", "when set, replacement for sv_airaccelerate when just strafing"};

Referenced by SV_Init(), and SV_WriteClientdataToMessage().

sv_allowdownloads

cvar_t sv_allowdownloads

extern

Definition at line 69 of file sv_main.c.

{CF_SERVER, "sv_allowdownloads", "1", "whether to allow clients to download files from the server (does not affect http downloads)"};

Referenced by SV_Download_f(), and SV_Init().

sv_allowdownloads_archive

cvar_t sv_allowdownloads_archive

extern

Definition at line 70 of file sv_main.c.

{CF_SERVER, "sv_allowdownloads_archive", "0", "whether to allow downloads of archives (pak/pk3)"};

Referenced by SV_Download_f(), and SV_Init().

sv_allowdownloads_config

cvar_t sv_allowdownloads_config

extern

Definition at line 71 of file sv_main.c.

{CF_SERVER, "sv_allowdownloads_config", "0", "whether to allow downloads of config files (cfg)"};

Referenced by SV_Download_f(), and SV_Init().

sv_allowdownloads_dlcache

cvar_t sv_allowdownloads_dlcache

extern

Definition at line 72 of file sv_main.c.

{CF_SERVER, "sv_allowdownloads_dlcache", "0", "whether to allow downloads of dlcache files (dlcache/)"};

Referenced by SV_Download_f(), and SV_Init().

sv_allowdownloads_inarchive

cvar_t sv_allowdownloads_inarchive

extern

Definition at line 73 of file sv_main.c.

{CF_SERVER, "sv_allowdownloads_inarchive", "0", "whether to allow downloads from archives (pak/pk3)"};

Referenced by SV_Download_f(), and SV_Init().

sv_areadebug

cvar_t sv_areadebug

extern

Definition at line 164 of file sv_main.c.

{CF_SERVER, "sv_areadebug", "0", "disables physics culling for debugging purposes (only for development)"};

Referenced by SV_EntitiesInBox(), and SV_Init().

sv_areagrid_link_SOLID_NOT

cvar_t sv_areagrid_link_SOLID_NOT

extern

Definition at line 74 of file sv_main.c.

{CF_SERVER | CF_NOTIFY, "sv_areagrid_link_SOLID_NOT", "1", "set to 0 to prevent SOLID_NOT entities from being linked to the area grid, and unlink any that are already linked (in the code paths that would otherwise link them), for better performance"};

Referenced by SV_Init(), and SV_LinkEdict().

sv_areagrid_mingridsize

cvar_t sv_areagrid_mingridsize

extern

Definition at line 75 of file sv_main.c.

{CF_SERVER | CF_NOTIFY, "sv_areagrid_mingridsize", "128", "minimum areagrid cell size, smaller values work better for lots of small objects, higher values for large objects"};

Referenced by SV_Init(), and World_SetSize().

sv_checkforpacketsduringsleep

cvar_t sv_checkforpacketsduringsleep

extern

Definition at line 76 of file sv_main.c.

{CF_SERVER, "sv_checkforpacketsduringsleep", "0", "uses select() function to wait between frames which can be interrupted by packets being received, instead of Sleep()/usleep()/SDL_Sleep() functions which do not check for packets"};

Referenced by SV_Init(), and Sys_Sleep().

sv_clmovement_enable

cvar_t sv_clmovement_enable

extern

Definition at line 77 of file sv_main.c.

{CF_SERVER, "sv_clmovement_enable", "1", "whether to allow clients to use cl_movement prediction, which can cause choppy movement on the server which may annoy other players"};

Referenced by SV_ExecuteClientMoves(), and SV_Init().

sv_clmovement_inputtimeout

cvar_t sv_clmovement_inputtimeout

extern

Definition at line 80 of file sv_main.c.

{CF_SERVER, "sv_clmovement_inputtimeout", "0.1", "when a client does not send input for this many seconds (max 0.1), force them to move anyway (unlike QuakeWorld)"};

Referenced by SV_ExecuteClientMoves(), and SV_Init().

sv_clmovement_maxnetfps

cvar_t sv_clmovement_maxnetfps

extern

sv_clmovement_minping

cvar_t sv_clmovement_minping

extern

Definition at line 78 of file sv_main.c.

{CF_SERVER, "sv_clmovement_minping", "0", "if client ping is below this time in milliseconds, then their ability to use cl_movement prediction is disabled for a while (as they don't need it)"};

Referenced by SV_ExecuteClientMoves(), and SV_Init().

sv_clmovement_minping_disabletime

cvar_t sv_clmovement_minping_disabletime

extern

Definition at line 79 of file sv_main.c.

{CF_SERVER, "sv_clmovement_minping_disabletime", "1000", "when client falls below minping, disable their prediction for this many milliseconds (should be at least 1000 or else their prediction may turn on/off frequently)"};

Referenced by SV_ExecuteClientMoves(), and SV_Init().

sv_cullentities_nevercullbmodels

cvar_t sv_cullentities_nevercullbmodels

extern

Definition at line 81 of file sv_main.c.

{CF_SERVER, "sv_cullentities_nevercullbmodels", "0", "if enabled the clients are always notified of moving doors and lifts and other submodels of world (warning: eats a lot of network bandwidth on some levels!)"};

Referenced by SV_Init(), and SV_MarkWriteEntityStateToClient().

sv_cullentities_pvs

cvar_t sv_cullentities_pvs

extern

Definition at line 82 of file sv_main.c.

{CF_SERVER, "sv_cullentities_pvs", "1", "fast but loose culling of hidden entities"};

Referenced by SV_Init(), and SV_MarkWriteEntityStateToClient().

sv_cullentities_stats

cvar_t sv_cullentities_stats

extern

Definition at line 83 of file sv_main.c.

{CF_SERVER, "sv_cullentities_stats", "0", "displays stats on network entities culled by various methods for each client"};

Referenced by SV_Init(), and SV_WriteEntitiesToClient().

sv_cullentities_trace

cvar_t sv_cullentities_trace

extern

Definition at line 84 of file sv_main.c.

{CF_SERVER, "sv_cullentities_trace", "0", "somewhat slow but very tight culling of hidden entities, minimizes network traffic and makes wallhack cheats useless"};

Referenced by SV_Init(), and SV_MarkWriteEntityStateToClient().

sv_cullentities_trace_delay

cvar_t sv_cullentities_trace_delay

extern

Definition at line 85 of file sv_main.c.

{CF_SERVER, "sv_cullentities_trace_delay", "1", "number of seconds until the entity gets actually culled (also applies to portal camera eyes even if sv_cullentities_trace is 0)"};

Referenced by SV_Init(), and SV_MarkWriteEntityStateToClient().

sv_cullentities_trace_enlarge

cvar_t sv_cullentities_trace_enlarge

extern

Definition at line 87 of file sv_main.c.

{CF_SERVER, "sv_cullentities_trace_enlarge", "0", "box enlargement for entity culling (also applies to portal camera eyes even if sv_cullentities_trace is 0)"};

Referenced by SV_Init(), and SV_MarkWriteEntityStateToClient().

sv_cullentities_trace_prediction

cvar_t sv_cullentities_trace_prediction

extern

Definition at line 90 of file sv_main.c.

{CF_SERVER, "sv_cullentities_trace_prediction", "1", "also trace from the predicted player position"};

Referenced by SV_Init(), and SV_WriteEntitiesToClient().

sv_cullentities_trace_samples

cvar_t sv_cullentities_trace_samples

extern

Definition at line 93 of file sv_main.c.

{CF_SERVER, "sv_cullentities_trace_samples", "2", "number of samples to test for entity culling"};

Referenced by SV_Init(), and SV_MarkWriteEntityStateToClient().

sv_cullentities_trace_samples_extra

cvar_t sv_cullentities_trace_samples_extra

extern

Definition at line 94 of file sv_main.c.

{CF_SERVER, "sv_cullentities_trace_samples_extra", "2", "number of samples to test for entity culling when the entity affects its surroundings by e.g. dlight (also applies to portal camera eyes even if sv_cullentities_trace is 0)"};

Referenced by SV_Init(), and SV_MarkWriteEntityStateToClient().

sv_debugmove

cvar_t sv_debugmove

extern

Definition at line 97 of file sv_main.c.

{CF_SERVER | CF_NOTIFY, "sv_debugmove", "0", "disables collision detection optimizations for debugging purposes"};

Referenced by CL_TraceBox(), CL_TraceLine(), CL_TracePoint(), SV_Init(), SV_TraceBox(), SV_TraceLine(), and SV_TracePoint().

sv_echobprint

cvar_t sv_echobprint

extern

Definition at line 99 of file sv_main.c.

{CF_SERVER | CF_ARCHIVE, "sv_echobprint", "1", "prints gamecode bprint() calls to server console"};

Referenced by SV_BroadcastPrint(), and SV_Init().

sv_edgefriction

cvar_t sv_edgefriction

extern

Definition at line 100 of file sv_main.c.

{CF_SERVER, "edgefriction", "1", "how much you slow down when nearing a ledge you might fall off, multiplier of sv_friction (Quake used 2, QuakeWorld used 1 due to a bug in physics code)"};

Referenced by SV_Init(), SV_UserFriction(), and SV_WriteClientdataToMessage().

sv_entpatch

cvar_t sv_entpatch

extern

Definition at line 101 of file sv_main.c.

{CF_SERVER, "sv_entpatch", "1", "enables loading of .ent files to override entities in the bsp (for example Threewave CTF server pack contains .ent patch files enabling play of CTF on id1 maps)"};

Referenced by SV_Init(), and SV_SpawnServer().

sv_freezenonclients

cvar_t sv_freezenonclients

extern

Definition at line 102 of file sv_main.c.

{CF_SERVER | CF_NOTIFY, "sv_freezenonclients", "0", "freezes time, except for players, allowing you to walk around and take screenshots of explosions"};

Referenced by SV_Init(), and SV_Physics().

sv_friction

cvar_t sv_friction

extern

Definition at line 103 of file sv_main.c.

{CF_SERVER | CF_NOTIFY, "sv_friction","4", "how fast you slow down"};

Referenced by SV_Init(), SV_UserFriction(), SV_WaterMove(), and SV_WriteClientdataToMessage().

sv_gameplayfix_blowupfallenzombies

cvar_t sv_gameplayfix_blowupfallenzombies

extern

Definition at line 104 of file sv_main.c.

{CF_SERVER, "sv_gameplayfix_blowupfallenzombies", "1", "causes findradius to detect SOLID_NOT entities such as zombies and corpses on the floor, allowing splash damage to apply to them"};

Referenced by SV_Init(), VM_CL_findradius(), and VM_SV_findradius().

sv_gameplayfix_consistentplayerprethink

cvar_t sv_gameplayfix_consistentplayerprethink

extern

Definition at line 105 of file sv_main.c.

{CF_SERVER, "sv_gameplayfix_consistentplayerprethink", "0", "improves fairness in multiplayer by running all PlayerPreThink functions (which fire weapons) before performing physics, then running all PlayerPostThink functions"};

Referenced by SV_Init(), and SV_Physics().

sv_gameplayfix_delayprojectiles

cvar_t sv_gameplayfix_delayprojectiles

extern

Definition at line 106 of file sv_main.c.

{CF_SERVER, "sv_gameplayfix_delayprojectiles", "1", "causes entities to not move on the same frame they are spawned, meaning that projectiles wait until the next frame to perform their first move, giving proper interpolation and rocket trails, but making weapons harder to use at low framerates"};

Referenced by SV_Init(), SV_Physics(), and SV_Physics_Entity().

sv_gameplayfix_downtracesupportsongroundflag

cvar_t sv_gameplayfix_downtracesupportsongroundflag

extern

Definition at line 128 of file sv_main.c.

{CF_SERVER, "sv_gameplayfix_downtracesupportsongroundflag", "1", "prevents very short moves from clearing onground (which may make the player stick to the floor at high netfps), fixes groundentity not being set when walking onto a mover with sv_gameplayfix_nogravityonground"};

Referenced by SV_Init(), and SV_WalkMove().

sv_gameplayfix_droptofloorstartsolid

cvar_t sv_gameplayfix_droptofloorstartsolid

extern

Definition at line 107 of file sv_main.c.

{CF_SERVER, "sv_gameplayfix_droptofloorstartsolid", "1", "prevents items and monsters that start in a solid area from falling out of the level (makes droptofloor treat trace_startsolid as an acceptable outcome)"};

Referenced by SV_Init(), and VM_SV_droptofloor().

sv_gameplayfix_droptofloorstartsolid_nudgetocorrect

cvar_t sv_gameplayfix_droptofloorstartsolid_nudgetocorrect

extern

Definition at line 108 of file sv_main.c.

{CF_SERVER, "sv_gameplayfix_droptofloorstartsolid_nudgetocorrect", "1", "tries to nudge stuck items and monsters out of walls before droptofloor is performed"};

Referenced by SV_Init(), and VM_SV_droptofloor().

sv_gameplayfix_easierwaterjump

cvar_t sv_gameplayfix_easierwaterjump

extern

Definition at line 109 of file sv_main.c.

{CF_SERVER, "sv_gameplayfix_easierwaterjump", "1", "changes water jumping to make it easier to get out of water (exactly like in QuakeWorld)"};

Referenced by SV_FlyMove(), and SV_Init().

sv_gameplayfix_findradiusdistancetobox

cvar_t sv_gameplayfix_findradiusdistancetobox

extern

Definition at line 110 of file sv_main.c.

{CF_SERVER, "sv_gameplayfix_findradiusdistancetobox", "1", "causes findradius to check the distance to the corner of a box rather than the center of the box, makes findradius detect bmodels such as very large doors that would otherwise be unaffected by splash damage"};

Referenced by SV_Init(), VM_CL_findradius(), and VM_SV_findradius().

sv_gameplayfix_fixedcheckwatertransition

cvar_t sv_gameplayfix_fixedcheckwatertransition

extern

Definition at line 132 of file sv_main.c.

{CF_SERVER, "sv_gameplayfix_fixedcheckwatertransition", "1", "fix two very stupid bugs in SV_CheckWaterTransition when watertype is CONTENTS_EMPTY (the bugs causes waterlevel to be 1 on first frame, -1 on second frame - the fix makes it 0 on both frames)"};

Referenced by SV_CheckWaterTransition(), and SV_Init().

sv_gameplayfix_gravityunaffectedbyticrate

cvar_t sv_gameplayfix_gravityunaffectedbyticrate

extern

Definition at line 111 of file sv_main.c.

{CF_SERVER, "sv_gameplayfix_gravityunaffectedbyticrate", "0", "fix some ticrate issues in physics."};

Referenced by SV_FlyMove(), SV_Init(), and SV_WriteClientdataToMessage().

sv_gameplayfix_grenadebouncedownslopes

cvar_t sv_gameplayfix_grenadebouncedownslopes

extern

Definition at line 112 of file sv_main.c.

{CF_SERVER, "sv_gameplayfix_grenadebouncedownslopes", "1", "prevents MOVETYPE_BOUNCE (grenades) from getting stuck when fired down a downward sloping surface"};

Referenced by SV_Init(), and SV_Physics_Toss().

sv_gameplayfix_impactbeforeonground

cvar_t sv_gameplayfix_impactbeforeonground

extern

Definition at line 113 of file sv_main.c.

{CF_SERVER, "sv_gameplayfix_impactbeforeonground", "0", "enables a bug from old DP versions in which entity .touch functions are called before FL_ONGROUND is set when a collision is detected in SV_FlyMove() (used by MOVETYPE_WALK and MOVETYPE_STEP), Quake 1.5 and Combat+ mods require this, it breaks id1 fiends"};

Referenced by SV_FlyMove(), and SV_Init().

sv_gameplayfix_multiplethinksperframe

cvar_t sv_gameplayfix_multiplethinksperframe

extern

Definition at line 114 of file sv_main.c.

{CF_SERVER, "sv_gameplayfix_multiplethinksperframe", "1", "allows entities to think more often than the server framerate, primarily useful for very high fire rate weapons"};

Referenced by SV_Init(), and SV_RunThink().

sv_gameplayfix_noairborncorpse

cvar_t sv_gameplayfix_noairborncorpse

extern

Definition at line 115 of file sv_main.c.

{CF_SERVER, "sv_gameplayfix_noairborncorpse", "1", "causes entities (corpses, items, etc) sitting ontop of moving entities (players) to fall when the moving entity (player) is no longer supporting them"};

Referenced by SV_Init(), and SV_Physics_Toss().

sv_gameplayfix_noairborncorpse_allowsuspendeditems

cvar_t sv_gameplayfix_noairborncorpse_allowsuspendeditems

extern

Definition at line 116 of file sv_main.c.

{CF_SERVER, "sv_gameplayfix_noairborncorpse_allowsuspendeditems", "1", "causes entities sitting ontop of objects that are instantaneously remove to float in midair (special hack to allow a common level design trick for floating items)"};

Referenced by SV_Init(), and SV_Physics_Toss().

sv_gameplayfix_nogravityonground

cvar_t sv_gameplayfix_nogravityonground

extern

Definition at line 120 of file sv_main.c.

{CF_SERVER, "sv_gameplayfix_nogravityonground", "0", "turn off gravity when on ground (to get rid of sliding)"};

Referenced by SV_FlyMove(), SV_Init(), and SV_WriteClientdataToMessage().

sv_gameplayfix_nosquashentities

cvar_t sv_gameplayfix_nosquashentities

extern

Definition at line 133 of file sv_main.c.

{CF_SERVER, "sv_gameplayfix_nosquashentities", "0", "Entity hitboxes will not be resized or disabled when they are crushed by movers, and will continue to be affected by movers."};

Referenced by SV_Init(), and SV_PushMove().

sv_gameplayfix_nostepmoveonsteepslopes

cvar_t sv_gameplayfix_nostepmoveonsteepslopes

extern

Definition at line 125 of file sv_main.c.

{CF_SERVER, "sv_gameplayfix_nostepmoveonsteepslopes", "0", "crude fix which prevents MOVETYPE_STEP (not swimming or flying) to move on slopes whose angle is bigger than 45 degree"};

Referenced by SV_Init(), and SV_movestep().

sv_gameplayfix_nudgeoutofsolid

cvar_t sv_gameplayfix_nudgeoutofsolid

extern

Definition at line 117 of file sv_main.c.

{CF_SERVER, "sv_gameplayfix_nudgeoutofsolid", "0", "attempts to fix physics errors where an object ended up in solid for some reason, smarter than sv_gameplayfix_unstick* except on Q1BSP with mod_q1bsp_polygoncollisions disabled (there it falls back to the unsticking method)"};

Referenced by SV_Init(), and SV_UnstickEntity().

sv_gameplayfix_nudgeoutofsolid_separation

cvar_t sv_gameplayfix_nudgeoutofsolid_separation

extern

Definition at line 118 of file sv_main.c.

{CF_SERVER, "sv_gameplayfix_nudgeoutofsolid_separation", "0.03125", "keep objects this distance apart to prevent collision issues on seams"};

Referenced by PHYS_NudgeOutOfSolid(), SV_Init(), and SV_UnstickEntity().

sv_gameplayfix_q1bsptracelinereportstexture

cvar_t sv_gameplayfix_q1bsptracelinereportstexture

extern

Definition at line 129 of file sv_main.c.

{CF_SERVER, "sv_gameplayfix_q1bsptracelinereportstexture", "1", "enables mods to get accurate trace_texture results on q1bsp by using a surface-hitting traceline implementation rather than the standard solidbsp method, q3bsp always reports texture accurately"};

Referenced by Mod_Q1BSP_TraceLine(), and SV_Init().

sv_gameplayfix_q2airaccelerate

cvar_t sv_gameplayfix_q2airaccelerate

extern

Definition at line 119 of file sv_main.c.

{CF_SERVER, "sv_gameplayfix_q2airaccelerate", "0", "Quake2-style air acceleration"};

Referenced by SV_WriteClientdataToMessage().

sv_gameplayfix_setmodelrealbox

cvar_t sv_gameplayfix_setmodelrealbox

extern

Definition at line 121 of file sv_main.c.

{CF_SERVER, "sv_gameplayfix_setmodelrealbox", "1", "fixes a bug in Quake that made setmodel always set the entity box to ('-16 -16 -16', '16 16 16') rather than properly checking the model box, breaks some poorly coded mods"};

Referenced by SV_Init(), VM_SV_setmodel(), and VM_SV_setmodelindex().

sv_gameplayfix_slidemoveprojectiles

cvar_t sv_gameplayfix_slidemoveprojectiles

extern

Definition at line 122 of file sv_main.c.

{CF_SERVER, "sv_gameplayfix_slidemoveprojectiles", "1", "allows MOVETYPE_FLY/FLYMISSILE/TOSS/BOUNCE/BOUNCEMISSILE entities to finish their move in a frame even if they hit something, fixes 'gravity accumulation' bug for grenades on steep slopes"};

Referenced by SV_Init(), and SV_Physics_Toss().

sv_gameplayfix_stepdown

cvar_t sv_gameplayfix_stepdown

extern

Definition at line 123 of file sv_main.c.

{CF_SERVER, "sv_gameplayfix_stepdown", "0", "attempts to step down stairs, not just up them (prevents the familiar thud..thud..thud.. when running down stairs and slopes)"};

Referenced by SV_Init(), and SV_WalkMove().

sv_gameplayfix_stepmultipletimes

cvar_t sv_gameplayfix_stepmultipletimes

extern

Definition at line 124 of file sv_main.c.

{CF_SERVER, "sv_gameplayfix_stepmultipletimes", "0", "applies step-up onto a ledge more than once in a single frame, when running quickly up stairs"};

Referenced by SV_Init(), and SV_WalkMove().

sv_gameplayfix_swiminbmodels

cvar_t sv_gameplayfix_swiminbmodels

extern

Definition at line 126 of file sv_main.c.

{CF_SERVER, "sv_gameplayfix_swiminbmodels", "1", "causes pointcontents (used to determine if you are in a liquid) to check bmodel entities as well as the world model, so you can swim around in (possibly moving) water bmodel entities"};

Referenced by SV_Init(), and SV_PointSuperContents().

sv_gameplayfix_unstickentities

cvar_t sv_gameplayfix_unstickentities

extern

Definition at line 131 of file sv_main.c.

{CF_SERVER, "sv_gameplayfix_unstickentities", "0", "hack to check if entities are crossing world collision hull and try to move them to the right position. Quake didn't do this so maps shouldn't depend on it."};

Referenced by SV_Init(), and SV_UnstickEntity().

sv_gameplayfix_unstickplayers

cvar_t sv_gameplayfix_unstickplayers

extern

Definition at line 130 of file sv_main.c.

{CF_SERVER, "sv_gameplayfix_unstickplayers", "1", "big hack to try and fix the rare case of MOVETYPE_WALK entities getting stuck in the world clipping hull. Quake did something similar."};

Referenced by SV_Init(), and SV_UnstickEntity().

sv_gameplayfix_upwardvelocityclearsongroundflag

cvar_t sv_gameplayfix_upwardvelocityclearsongroundflag

extern

Definition at line 127 of file sv_main.c.

{CF_SERVER, "sv_gameplayfix_upwardvelocityclearsongroundflag", "1", "prevents monsters, items, and most other objects from being stuck to the floor when pushed around by damage, and other situations in mods"};

Referenced by SV_Init(), SV_Physics_Step(), and SV_Physics_Toss().

sv_gravity

cvar_t sv_gravity

extern

Definition at line 134 of file sv_main.c.

{CF_SERVER | CF_NOTIFY, "sv_gravity","800", "how fast you fall (512 = roughly earth gravity)"};

Referenced by CL_UpdateMoveVars(), SV_Gravity(), SV_Init(), SV_Physics(), SV_Physics_Step(), SV_Physics_Toss(), SV_Trace_Toss(), and SV_WriteClientdataToMessage().

sv_idealpitchscale

cvar_t sv_idealpitchscale

extern

Definition at line 136 of file sv_main.c.

{CF_SERVER, "sv_idealpitchscale","0.8", "how much to look up/down slopes and stairs when not using freelook"};

Referenced by SV_Init(), and SV_SetIdealPitch().

sv_jumpstep

cvar_t sv_jumpstep

extern

Definition at line 137 of file sv_main.c.

{CF_SERVER | CF_NOTIFY, "sv_jumpstep", "0", "whether you can step up while jumping"};

Referenced by SV_Init(), and SV_WalkMove().

sv_jumpvelocity

cvar_t sv_jumpvelocity

extern

Definition at line 138 of file sv_main.c.

{CF_SERVER, "sv_jumpvelocity", "270", "cvar that can be used by QuakeC code for jump velocity"};

Referenced by SV_Init(), and SV_WriteClientdataToMessage().

sv_legacy_bbox_expand

cvar_t sv_legacy_bbox_expand

extern

Definition at line 139 of file sv_main.c.

{CF_SERVER, "sv_legacy_bbox_expand", "1", "before linking an entity to the area grid, decrease its mins and increase its maxs by '1 1 1', or '15 15 1' if it has flag FL_ITEM (this is the Quake/QuakeWorld behaviour); disable to make SVQC bboxes consistent with CSQC which never does this expansion"};

Referenced by SV_Init(), and SV_LinkEdict().

sv_maxairspeed

cvar_t sv_maxairspeed

extern

Definition at line 140 of file sv_main.c.

{CF_SERVER, "sv_maxairspeed", "30", "maximum speed a player can accelerate to when airborn (note that it is possible to completely stop by moving the opposite direction)"};

Referenced by SV_AirAccelerate(), SV_Init(), and SV_WriteClientdataToMessage().

sv_maxairstrafespeed

cvar_t sv_maxairstrafespeed

extern

Definition at line 64 of file sv_main.c.

{CF_SERVER, "sv_maxairstrafespeed", "0", "when set, replacement for sv_maxairspeed when just strafing"};

Referenced by SV_Init(), and SV_WriteClientdataToMessage().

sv_maxrate

cvar_t sv_maxrate

extern

Definition at line 141 of file sv_main.c.

{CF_SERVER | CF_ARCHIVE | CF_NOTIFY, "sv_maxrate", "1000000", "upper limit on client rate cvar, should reflect your network connection quality"};

Referenced by M_GameOptions_Draw(), M_NetStart_Change(), SV_Init(), and SV_SendClientDatagram().

sv_maxspeed

cvar_t sv_maxspeed

extern

Definition at line 142 of file sv_main.c.

{CF_SERVER | CF_NOTIFY, "sv_maxspeed", "320", "maximum speed a player can accelerate to when on ground (can be exceeded by tricks)"};

Referenced by SV_AirMove(), SV_Init(), SV_WaterMove(), and SV_WriteClientdataToMessage().

sv_maxvelocity

cvar_t sv_maxvelocity

extern

Definition at line 143 of file sv_main.c.

{CF_SERVER | CF_NOTIFY, "sv_maxvelocity","2000", "universal speed limit on all entities"};

Referenced by SV_CheckVelocity(), and SV_Init().

sv_mempool

mempool_t* sv_mempool

extern

Definition at line 226 of file sv_main.c.

Referenced by EntityFrame5_ExpandEdicts(), SV_Init(), SV_Map_f(), SV_Prepare_CSQC(), SV_SendServerinfo(), SV_ServerOptions(), SV_WriteEntitiesToClient(), VM_SV_checkpvs(), and VM_SV_newcheckclient().

sv_nostep

cvar_t sv_nostep

extern

Definition at line 144 of file sv_main.c.

{CF_SERVER | CF_NOTIFY, "sv_nostep","0", "prevents MOVETYPE_STEP entities (monsters) from moving"};

Referenced by SV_Init(), and SV_WalkMove().

sv_playerphysicsqc

cvar_t sv_playerphysicsqc

extern

Definition at line 145 of file sv_main.c.

{CF_SERVER | CF_NOTIFY, "sv_playerphysicsqc", "1", "enables QuakeC function to override player physics"};

Referenced by SV_Init(), and SV_PlayerPhysics().

sv_progs

cvar_t sv_progs

extern

Definition at line 146 of file sv_main.c.

{CF_SERVER, "sv_progs", "progs.dat", "selects which quakec progs.dat file to run" };

Referenced by SV_Init(), and SV_VM_Setup().

sv_protocolname

cvar_t sv_protocolname

extern

Definition at line 147 of file sv_main.c.

{CF_SERVER, "sv_protocolname", "DP7", "selects network protocol to host for (values include QUAKE, QUAKEDP, NEHAHRAMOVIE, DP1 and up)"};

Referenced by SV_Init(), and SV_SpawnServer().

sv_random_seed

cvar_t sv_random_seed

extern

Definition at line 149 of file sv_main.c.

{CF_SERVER, "sv_random_seed", "", "random seed; when set, on every map start this random seed is used to initialize the random number generator. Don't touch it unless for benchmarking or debugging"};

Referenced by Host_Frame(), SV_Init(), and SV_SpawnServer().

sv_sound_land

cvar_t sv_sound_land

extern

Definition at line 151 of file sv_main.c.

{CF_SERVER, "sv_sound_land", "demon/dland2.wav", "sound to play when MOVETYPE_STEP entity hits the ground at high speed (empty cvar disables the sound)"};

Referenced by SV_Init(), and SV_Physics_Step().

sv_sound_watersplash

cvar_t sv_sound_watersplash

extern

Definition at line 152 of file sv_main.c.

{CF_SERVER, "sv_sound_watersplash", "misc/h2ohit1.wav", "sound to play when MOVETYPE_FLY/TOSS/BOUNCE/STEP entity enters or leaves water (empty cvar disables the sound)"};

Referenced by SV_CheckWaterTransition(), and SV_Init().

sv_stepheight

cvar_t sv_stepheight

extern

Definition at line 153 of file sv_main.c.

{CF_SERVER | CF_NOTIFY, "sv_stepheight", "18", "how high you can step up (TW_SV_STEPCONTROL extension)"};

Referenced by CL_CheckBottom(), CL_movestep(), SV_CheckBottom(), SV_Init(), SV_movestep(), SV_WalkMove(), SV_WriteClientdataToMessage(), and VM_CL_checkbottom().

sv_stopspeed

cvar_t sv_stopspeed

extern

Definition at line 154 of file sv_main.c.

{CF_SERVER | CF_NOTIFY, "sv_stopspeed","100", "how fast you come to a complete stop"};

Referenced by SV_Init(), SV_UserFriction(), and SV_WriteClientdataToMessage().

sv_wallfriction

cvar_t sv_wallfriction

extern

Definition at line 155 of file sv_main.c.

{CF_SERVER | CF_NOTIFY, "sv_wallfriction", "1", "how much you slow down when sliding along a wall"};

Referenced by SV_Init(), and SV_WalkMove().

sv_wateraccelerate

cvar_t sv_wateraccelerate

extern

Definition at line 156 of file sv_main.c.

{CF_SERVER, "sv_wateraccelerate", "-1", "rate at which a player accelerates to sv_maxspeed while in water, if less than 0 the sv_accelerate variable is used instead"};

Referenced by SV_Init(), SV_WaterMove(), and SV_WriteClientdataToMessage().

sv_waterfriction

cvar_t sv_waterfriction

extern

Definition at line 157 of file sv_main.c.

{CF_SERVER | CF_NOTIFY, "sv_waterfriction","-1", "how fast you slow down in water, if less than 0 the sv_friction variable is used instead"};

Referenced by SV_Init(), SV_WaterMove(), and SV_WriteClientdataToMessage().

svs

server_static_t svs

extern

persistant server info

Definition at line 224 of file sv_main.c.

Referenced by Cvar_SetQuick_Internal(), EntityFrameCSQC_WriteFrame(), EntityState5_Priority(), EntityState5_WriteUpdate(), Host_Frame(), Host_Shutdown(), M_Menu_GameOptions_f(), NetConn_BuildStatusResponse(), NetConn_Heartbeat(), NetConn_ServerParsePacket(), SCR_DrawNetGraph(), SV_Begin_f(), SV_BroadcastPrint(), SV_CheckTimeouts(), SV_Color_f(), SV_ConnectClient(), SV_CreateBaseline(), SV_DisableCheats_c(), SV_Download_f(), SV_DropClient(), SV_Ent_Remove_f(), SV_FlushBroadcastMessages(), SV_Frame(), SV_IsLocalServer(), SV_Kick_f(), SV_Loadgame_f(), SV_Map_f(), SV_MarkWriteEntityStateToClient(), SV_MaxPlayers_f(), SV_ModelIndex(), SV_Name_f(), SV_Physics(), SV_Ping_f(), SV_Pings_f(), SV_Prepare_CSQC(), SV_PrepareEntityForSending(), SV_Savegame_f(), SV_Savegame_to(), SV_SaveSpawnparms(), SV_Say(), SV_SendClientMessages(), SV_SendCvar_f(), SV_SendServerinfo(), SV_ServerOptions(), SV_Shutdown(), SV_Spawn_f(), SV_SpawnServer(), SV_StartThread(), SV_Status_f(), SV_StopThread(), SV_Tell_f(), SV_ThreadFunc(), SV_UnstickEntity(), SV_UpdateToReliableMessages(), SV_VM_Setup(), SV_WriteEntitiesToClient(), SVVM_free_edict(), SVVM_init_edict(), Sys_Error(), VM_changelevel(), VM_clientcount(), VM_M_WriteDest(), VM_sprint(), VM_SV_centerprint(), VM_SV_clientcommand(), VM_SV_clienttype(), VM_SV_dropclient(), VM_SV_lightstyle(), VM_SV_newcheckclient(), VM_SV_serverkey(), VM_SV_setcolor(), VM_SV_setspawnparms(), VM_SV_spawnclient(), VM_SV_sprint(), VM_SV_stuffcmd(), and WriteDest().

sys_ticrate

cvar_t sys_ticrate

extern

Definition at line 166 of file sv_main.c.

{CF_SERVER | CF_ARCHIVE, "sys_ticrate","0.01388889", "how long a server frame is in seconds, 0.05 is 20fps server rate, 0.1 is 10fps (can not be set higher than 0.1), 0 runs as many server frames as possible (makes games against bots a little smoother, overwhelms network players), 1/72 matches QuakeWorld physics"};

Referenced by SV_ExecuteClientMoves(), SV_Frame(), SV_Init(), SV_SendClientDatagram(), SV_ThreadFunc(), and SV_WriteClientdataToMessage().

teamplay

cvar_t teamplay

extern

Definition at line 31 of file progsdefs.qc.

Referenced by M_GameOptions_Draw(), M_NetStart_Change(), NetConn_BuildStatusResponse(), Sbar_DrawFace(), Sbar_IsTeammatch(), SV_Init(), SV_Say(), SV_VM_Setup(), and VM_SV_aim().

temp1

cvar_t temp1

extern

Definition at line 187 of file sv_main.c.

{CF_SERVER, "temp1","0", "general cvar for mods to use, in stock id1 this selects which death animation to use on players (0 = random death, other values select specific death scenes)"};

Referenced by SV_Init().

timelimit

cvar_t timelimit

extern

Definition at line 173 of file sv_main.c.

{CF_SERVER | CF_NOTIFY, "timelimit","0", "ends level at this time (in minutes)"};

Referenced by M_GameOptions_Draw(), M_NetStart_Change(), SV_Init(), and SV_WriteClientdataToMessage().