pr_cmds.c

quake1 dos源代码最新版本

	else
	{
// 2000-05-02 NVS SVC by Maddes  end
		MSG_WriteShort (WriteDest(), G_EDICTNUM(OFS_PARM1));
	}			// 2000-05-02 NVS SVC by Maddes
}

// 2001-09-16 New BuiltIn Function: WriteFloat() by Maddes  start
/*
PF_WriteFloat

void (float to, float f) WriteFloat
*/
void PF_WriteFloat (void)
{
	if (sv.nvs_msgwrites)
	{
		NVS_WriteFloat (G_FLOAT(OFS_PARM0), G_FLOAT(OFS_PARM1), NULL);
	}
	else
	{
		MSG_WriteFloat (WriteDest(), G_FLOAT(OFS_PARM1));
	}
}
// 2001-09-16 New BuiltIn Function: WriteFloat() by Maddes  end

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

int SV_ModelIndex (char *name);

void PF_makestatic (void)
{
	edict_t	*ent;
	int		i;

	ent = G_EDICT(OFS_PARM0);

	MSG_WriteByte (&sv.signon,svc_spawnstatic);

	MSG_WriteByte (&sv.signon, SV_ModelIndex(pr_strings + ent->v.model));

	MSG_WriteByte (&sv.signon, ent->v.frame);
	MSG_WriteByte (&sv.signon, ent->v.colormap);
	MSG_WriteByte (&sv.signon, ent->v.skin);
	for (i=0 ; i<3 ; i++)
	{
		MSG_WriteCoord(&sv.signon, ent->v.origin[i]);
		MSG_WriteAngle(&sv.signon, ent->v.angles[i]);
	}

// throw the entity away now
	ED_Free (ent);
}

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

/*
==============
PF_setspawnparms
==============
*/
void PF_setspawnparms (void)
{
	edict_t	*ent;
	int		i;
	client_t	*client;

	ent = G_EDICT(OFS_PARM0);
	i = NUM_FOR_EDICT(ent);
	if (i < 1 || i > svs.maxclients)
		PR_RunError ("Entity is not a client");

	// copy spawn parms out of the client_t
	client = svs.clients + (i-1);

	for (i=0 ; i< NUM_SPAWN_PARMS ; i++)
		(&pr_global_struct->parm1)[i] = client->spawn_parms[i];
}

/*
==============
PF_changelevel
==============
*/
void PF_changelevel (void)
{
#ifdef QUAKE2
	char	*s1, *s2;

	if (svs.changelevel_issued)
		return;
	svs.changelevel_issued = true;

	s1 = G_STRING(OFS_PARM0);
	s2 = G_STRING(OFS_PARM1);

	if ((int)pr_global_struct->serverflags & (SFL_NEW_UNIT | SFL_NEW_EPISODE))
		Cbuf_AddText (va("changelevel %s %s\n",s1, s2));
	else
		Cbuf_AddText (va("changelevel2 %s %s\n",s1, s2));
#else
	char	*s;

// make sure we don't issue two changelevels
	if (svs.changelevel_issued)
		return;
	svs.changelevel_issued = true;

	s = G_STRING(OFS_PARM0);
	Cbuf_AddText (va("changelevel %s\n",s));
#endif
}


#ifdef QUAKE2

#define	CONTENT_WATER	-3
#define CONTENT_SLIME	-4
#define CONTENT_LAVA	-5

#define FL_IMMUNE_WATER	131072
#define	FL_IMMUNE_SLIME	262144
#define FL_IMMUNE_LAVA	524288

#define	CHAN_VOICE	2
#define	CHAN_BODY	4

#define	ATTN_NORM	1

void PF_WaterMove (void)
{
	edict_t		*self;
	int			flags;
	int			waterlevel;
	int			watertype;
	float		drownlevel;
	float		damage = 0.0;

	self = PROG_TO_EDICT(pr_global_struct->self);

	if (self->v.movetype == MOVETYPE_NOCLIP)
	{
		self->v.air_finished = sv.time + 12;
		G_FLOAT(OFS_RETURN) = damage;
		return;
	}

	if (self->v.health < 0)
	{
		G_FLOAT(OFS_RETURN) = damage;
		return;
	}

	if (self->v.deadflag == DEAD_NO)
		drownlevel = 3;
	else
		drownlevel = 1;

	flags = (int)self->v.flags;
	waterlevel = (int)self->v.waterlevel;
	watertype = (int)self->v.watertype;

	if (!(flags & (FL_IMMUNE_WATER + FL_GODMODE)))
		if (((flags & FL_SWIM) && (waterlevel < drownlevel)) || (waterlevel >= drownlevel))
		{
			if (self->v.air_finished < sv.time)
				if (self->v.pain_finished < sv.time)
				{
					self->v.dmg = self->v.dmg + 2;
					if (self->v.dmg > 15)
						self->v.dmg = 10;
//					T_Damage (self, world, world, self.dmg, 0, FALSE);
					damage = self->v.dmg;
					self->v.pain_finished = sv.time + 1.0;
				}
		}
		else
		{
			if (self->v.air_finished < sv.time)
//				sound (self, CHAN_VOICE, "player/gasp2.wav", 1, ATTN_NORM);
				SV_StartSound (self, CHAN_VOICE, "player/gasp2.wav", 255, ATTN_NORM);
			else if (self->v.air_finished < sv.time + 9)
//				sound (self, CHAN_VOICE, "player/gasp1.wav", 1, ATTN_NORM);
				SV_StartSound (self, CHAN_VOICE, "player/gasp1.wav", 255, ATTN_NORM);
			self->v.air_finished = sv.time + 12.0;
			self->v.dmg = 2;
		}

	if (!waterlevel)
	{
		if (flags & FL_INWATER)
		{
			// play leave water sound
//			sound (self, CHAN_BODY, "misc/outwater.wav", 1, ATTN_NORM);
			SV_StartSound (self, CHAN_BODY, "misc/outwater.wav", 255, ATTN_NORM);
			self->v.flags = (float)(flags &~FL_INWATER);
		}
		self->v.air_finished = sv.time + 12.0;
		G_FLOAT(OFS_RETURN) = damage;
		return;
	}

	if (watertype == CONTENT_LAVA)
	{	// do damage
		if (!(flags & (FL_IMMUNE_LAVA + FL_GODMODE)))
			if (self->v.dmgtime < sv.time)
			{
				if (self->v.radsuit_finished < sv.time)
					self->v.dmgtime = sv.time + 0.2;
				else
					self->v.dmgtime = sv.time + 1.0;
//				T_Damage (self, world, world, 10*self.waterlevel, 0, TRUE);
				damage = (float)(10*waterlevel);
			}
	}
	else if (watertype == CONTENT_SLIME)
	{	// do damage
		if (!(flags & (FL_IMMUNE_SLIME + FL_GODMODE)))
			if (self->v.dmgtime < sv.time && self->v.radsuit_finished < sv.time)
			{
				self->v.dmgtime = sv.time + 1.0;
//				T_Damage (self, world, world, 4*self.waterlevel, 0, TRUE);
				damage = (float)(4*waterlevel);
			}
	}

	if ( !(flags & FL_INWATER) )
	{

// player enter water sound
		if (watertype == CONTENT_LAVA)
//			sound (self, CHAN_BODY, "player/inlava.wav", 1, ATTN_NORM);
			SV_StartSound (self, CHAN_BODY, "player/inlava.wav", 255, ATTN_NORM);
		if (watertype == CONTENT_WATER)
//			sound (self, CHAN_BODY, "player/inh2o.wav", 1, ATTN_NORM);
			SV_StartSound (self, CHAN_BODY, "player/inh2o.wav", 255, ATTN_NORM);
		if (watertype == CONTENT_SLIME)
//			sound (self, CHAN_BODY, "player/slimbrn2.wav", 1, ATTN_NORM);
			SV_StartSound (self, CHAN_BODY, "player/slimbrn2.wav", 255, ATTN_NORM);

		self->v.flags = (float)(flags | FL_INWATER);
		self->v.dmgtime = 0;
	}

	if (! (flags & FL_WATERJUMP) )
	{
//		self.velocity = self.velocity - 0.8*self.waterlevel*frametime*self.velocity;
		VectorMA (self->v.velocity, -0.8 * self->v.waterlevel * host_frametime, self->v.velocity, self->v.velocity);
	}

	G_FLOAT(OFS_RETURN) = damage;
}
#endif	// 2001-09-16 Quake 2 builtin functions by id/Maddes

void PF_sin (void)
{
	G_FLOAT(OFS_RETURN) = sin(G_FLOAT(OFS_PARM0));
}

void PF_cos (void)
{
	G_FLOAT(OFS_RETURN) = cos(G_FLOAT(OFS_PARM0));
}

void PF_sqrt (void)
{
	G_FLOAT(OFS_RETURN) = sqrt(G_FLOAT(OFS_PARM0));
}
//#endif	// 2001-09-16 Quake 2 builtin functions by id/Maddes

void PF_Fixme (void)
{
	PR_RunError ("unimplemented builtin");	// 2001-09-14 Enhanced BuiltIn Function System (EBFS) by Maddes
}

// 2001-09-14 Enhanced BuiltIn Function System (EBFS) by Maddes  start
/*
=================
PF_builtin_find

float builtin_find (string)
=================
*/
void PF_builtin_find (void)
{
	int		j;
	float	funcno;
	char	*funcname;

	funcno = 0;
	funcname = G_STRING(OFS_PARM0);

	// search function name
	for ( j=1 ; j < pr_ebfs_numbuiltins ; j++)
	{
		if ((pr_ebfs_builtins[j].funcname) && (!(Q_strcasecmp(funcname,pr_ebfs_builtins[j].funcname))))
		{
			break;	// found
		}
	}

	if (j < pr_ebfs_numbuiltins)
	{
		funcno = pr_ebfs_builtins[j].funcno;
	}

	G_FLOAT(OFS_RETURN) = funcno;
}
// 2001-09-14 Enhanced BuiltIn Function System (EBFS) by Maddes  end

// 2001-09-16 New BuiltIn Function: cmd_find() by Maddes  start
/*
=================
PF_cmd_find

float cmd_find (string)
=================
*/
void PF_cmd_find (void)
{
	char	*cmdname;
	float	result;

	cmdname = G_STRING(OFS_PARM0);

	result = Cmd_Exists (cmdname);

	G_FLOAT(OFS_RETURN) = result;
}
// 2001-09-16 New BuiltIn Function: cmd_find() by Maddes  end

// 2001-09-16 New BuiltIn Function: cvar_find() by Maddes  start
/*
=================
PF_cvar_find

float cvar_find (string)
=================
*/
void PF_cvar_find (void)
{
	char	*varname;
	float	result;

	varname = G_STRING(OFS_PARM0);

	result = 0;
	if (Cvar_FindVar (varname))
	{
		result = 1;
	}

	G_FLOAT(OFS_RETURN) = result;
}
// 2001-09-16 New BuiltIn Function: cvar_find() by Maddes  end

// 2001-09-16 New BuiltIn Function: cvar_string() by Maddes  start
/*
=================
PF_cvar_string

string cvar_string (string)
=================
*/
void PF_cvar_string (void)
{
	char	*varname;
	cvar_t	*var;

	varname = G_STRING(OFS_PARM0);
	var = Cvar_FindVar (varname);
	if (!var)
	{
		Con_DPrintf ("Cvar_String: variable \"%s\" not found\n", varname);	// 2001-09-09 Made 'Cvar not found' a developer message by Maddes
		G_INT(OFS_RETURN) = OFS_NULL;
	}
	else
	{
		G_INT(OFS_RETURN) = var->string - pr_strings;
	}
}
// 2001-09-16 New BuiltIn Function: cvar_string() by Maddes  end

// 2001-09-18 New BuiltIn Function: cvar_create() by Maddes  start
#define CVAR_QC_NONE		0		//cvar has no flags
#define CVAR_QC_ARCHIVE		1		//cvar will be stored in config.cfg
#define CVAR_QC_ROM			2		//cvar is readonly
#define CVAR_QC_NOTIFY		4		//cvar changes will be broadcasted to all players
#define CVAR_QC_SERVERINFO	8		//cvar will be send to clients (net_dgrm.c)
#define CVAR_QC_USERINFO	16		//cvar will be send to server (QW-like)

/*
=================
PF_cvar_create

void cvar_create (string, string, float)
=================
*/
void PF_cvar_create (void)
{
	char	*varname;
	int		qc_flags;
	int		flags;
	cvar_t	*var;

	varname = G_STRING(OFS_PARM0);
	qc_flags = G_FLOAT(OFS_PARM2);

	// convert QC flags to engine flags
	flags = CVAR_NONE;
	if (qc_flags & CVAR_QC_ARCHIVE)
	{
		flags |= CVAR_ARCHIVE;
	}
	if (qc_flags & CVAR_QC_ROM)
	{
		flags |= CVAR_ROM;
	}
	if (qc_flags & CVAR_QC_NOTIFY)
	{
		flags |= CVAR_NOTIFY;
	}
	if (qc_flags & CVAR_QC_SERVERINFO)
	{
		flags |= CVAR_SERVERINFO;
	}
	if (qc_flags & CVAR_QC_USERINFO)
	{
		flags |= CVAR_QC_USERINFO;
	}
	flags |= CVAR_PROGS_CREATED;

	var = Cvar_FindVar (varname);
	if (!var)
	{
		var = Cvar_Get (varname, G_STRING(OFS_PARM1), flags);
		return;
	}

	if (!(var->flags & (CVAR_USER_CREATED|CVAR_PROGS_CREATED)))
	{
		Con_DPrintf ("Cvar_Create: variable \"%s\" is not progs or user created\n", var->name);
		return;
	}

	// always throw out flags
	if (!(flags & CVAR_ROM))	// keep ARCHIVE flag if not ROM
	{
		flags |= var->flags & CVAR_ARCHIVE;
	}
	var->flags = flags;
}
// 2001-09-18 New BuiltIn Function: cvar_create() by Maddes  end

// 2001-09-18 New BuiltIn Function: cvar_free() by Maddes  start
/*
=================
PF_cvar_free

void cvar_free (string)
=================
*/
void PF_cvar_free (void)
{
	char	*varname;
	cvar_t	*var;

	varname = G_STRING(OFS_PARM0);
	var = Cvar_FindVar (varname);
	if (!var)
	{
		Con_DPrintf ("Cvar_Free: variable \"%s\" not found\n", varname);	// 2001-09-09 Made 'Cvar not found' a developer message by Maddes
		return;
	}

	if (!(var->flags & (CVAR_USER_CREATED|CVAR_PROGS_CREATED)))
	{
		Con_DPrintf ("Cvar_Free: variable \"%s\" is not progs or user created\n", var->name);
		return;
	}

	var = Cvar_Free (var);
}
// 2001-09-18 New BuiltIn Function: cvar_free() by Maddes  end

// 2001-09-25 New BuiltIn Function: etof() by Maddes  start
/*
=================
PF_etof

float etof (entity)
=================
*/
void PF_etof (void)
{
	G_FLOAT(OFS_RETURN) = G_EDICTNUM(OFS_PARM0);
}
// 2001-09-25 New BuiltIn Function: etof() by Maddes  end

// 2001-09-25 New BuiltIn Function: ftoe() by Maddes  start
/*
=================
PF_ftoe

entity ftoe (float)
=================
*/
void PF_ftoe (void)
{
	edict_t		*e;

	e = EDICT_NUM(G_FLOAT(OFS_PARM0));
	RETURN_EDICT(e);
}
// 2001-09-25 New BuiltIn Function: ftoe() by Maddes  end

// 2001-09-20 QuakeC string manipulation by FrikaC/Maddes  start
// 2001-09-20 QuakeC string zone by Maddes  start
/*
=================
PF_allocate_zone_progstrings
=================
*/
void PF_allocate_zone_progstrings (void)
{
	int	zonesize_progstrings;

	Cvar_Set(pr_zone_min_strings, pr_zone_min_strings->string);	// do rangecheck
	zonesize_progstrings = pr_zone_min_strings->value * 1024;
	zone_progstrings = Hunk_AllocName (zonesize_progstrings, "qcstrings");	// note only 8 chars copied
	Z_ClearZone (zone_progstrings, zonesize_progstrings);
}
// 2001-09-20 QuakeC string zone by Maddes  end

/*
=================
PF_strzone

string strzone (string)
=================
*/
void PF_strzone (void)
{
	char *m, *p;

// 2001-09-20 QuakeC string zone by Maddes  start
	if (!zone_progstrings)
	{
		PF_allocate_zone_progstrings();
	}
// 2001-09-20 QuakeC string zone by Maddes  end

	m = G_STRING(OFS_PARM0);
	p = Z_Malloc(zone_progstrings, strlen(m) + 1);	// 2001-09-20 QuakeC string zone by Maddes
	strcpy(p, m);

	G_INT(OFS_RETURN) = p - pr_strings;
}

/*
=================
PF_strunzone

string strunzone (string)
=================
*/
void PF_strunzone (void)
{
// 2001-09-20 QuakeC string zone by Maddes  start
	if (!zone_progstrings)
	{
		PF_allocate_zone_progstrings();
	}
// 2001-09-20 QuakeC string zone by Maddes  end

	Z_Free(zone_progstrings, G_STRING(OFS_PARM0));	// 2001-09-20 QuakeC string zone by Maddes
	G_INT(OFS_PARM0) = OFS_NULL; // empty the def
};

/*
=================
PF_strlen

float strlen (string)
=================
*/
void PF_strlen (void)
{
	char *p = G_STRING(OFS_PARM0);
	G_FLOAT(OFS_RETURN) = strlen(p);
}

/*
=================
PF_strcat

string strcat (string, string)
=================
*/