cl_parse.pas

雷神之锤2(Quake2)Delphi源码

==================
*)
procedure CL_ParseBaseline ();
var
	es: entity_state_p;
	bits: Integer;
	newnum: Integer;
	nilstate: entity_state_t;
begin
	FillChar (nilstate, sizeof(nilstate), 0);

	newnum := CL_ParseEntityBits (@bits);
	es := @cl_entities[newnum].baseline;
	CL_ParseDelta (@nilstate, es, newnum, bits);
end;


(*
================
CL_LoadClientinfo

================
*)
procedure CL_LoadClientinfo (ci: clientinfo_p; s: pchar);
var
	i: Integer;
	t: PChar;
	model_name: array[0..MAX_QPATH-1] of char;
	skin_name: array[0..MAX_QPATH-1] of char;
	model_filename: array[0..MAX_QPATH-1] of char;
	skin_filename: array[0..MAX_QPATH-1] of char;
	weapon_filename: array[0..MAX_QPATH-1] of char;
begin
	strncpy(ci^.cinfo, s, sizeof(ci^.cinfo));
	ci^.cinfo[sizeof(ci^.cinfo)-1] := #0;

	// isolate the player's name
	strncpy(ci^.name, s, sizeof(ci^.name));
	ci^.name[sizeof(ci^.name)-1] := #0;
	t := strstr (s, '\');
	if (t <> nil) then begin
		ci^.name[t-s] := #0;
		s := t+1;
	end;

	if (cl_noskins^.value<>0) or (s^ = #0) then begin
		Com_sprintf (model_filename, sizeof(model_filename), 'players/male/tris.md2', []);
		Com_sprintf (weapon_filename, sizeof(weapon_filename), 'players/male/weapon.md2', []);
		Com_sprintf (skin_filename, sizeof(skin_filename), 'players/male/grunt.pcx', []);
		Com_sprintf (ci^.iconname, sizeof(ci^.iconname), '/players/male/grunt_i.pcx', []);
		ci^.model := re.RegisterModel (model_filename);
		FillChar(ci^.weaponmodel, sizeof(ci^.weaponmodel), 0);
		ci^.weaponmodel[0] := re.RegisterModel (weapon_filename);
		ci^.skin := re.RegisterSkin (skin_filename);
		ci^.icon := re.RegisterPic (ci^.iconname);
	end
	else
	begin
		// isolate the model name
		strcpy (model_name, s);
		t := strstr(model_name, '/');
		if (t = nil) then
			t := strstr(model_name, '\');
		if (t = nil) then
			t := model_name;
		t^ := #0;

		// isolate the skin name
		strcpy (skin_name, s + strlen(model_name) + 1);

		// model file
		Com_sprintf (model_filename, sizeof(model_filename), 'players/%s/tris.md2', [model_name]);
		ci^.model := re.RegisterModel (model_filename);
		if (ci^.model = nil) then begin
			strcpy(model_name, 'male');
			Com_sprintf (model_filename, sizeof(model_filename), 'players/male/tris.md2', []);
			ci^.model := re.RegisterModel (model_filename);
		end;

		// skin file
		Com_sprintf (skin_filename, sizeof(skin_filename), 'players/%s/%s.pcx', [model_name, skin_name]);
		ci^.skin := re.RegisterSkin (skin_filename);

		// if we don't have the skin and the model wasn't male,
		// see if the male has it (this is for CTF's skins)
 		if (ci^.skin=nil) and (Q_stricmp(model_name, 'male')<>0) then begin
			// change model to male
			strcpy(model_name, 'male');
			Com_sprintf (model_filename, sizeof(model_filename), 'players/male/tris.md2', []);
			ci^.model := re.RegisterModel (model_filename);

			// see if the skin exists for the male model
			Com_sprintf (skin_filename, sizeof(skin_filename), 'players/%s/%s.pcx', [model_name, skin_name]);
			ci^.skin := re.RegisterSkin (skin_filename);
		end;

		// if we still don't have a skin, it means that the male model didn't have
		// it, so default to grunt
		if (ci^.skin = nil) then begin
			// see if the skin exists for the male model
			Com_sprintf (skin_filename, sizeof(skin_filename), 'players/%s/grunt.pcx', [model_name, skin_name]);
			ci^.skin := re.RegisterSkin (skin_filename);
		end;

		// weapon file
		for i := 0 to num_cl_weaponmodels-1 do begin
			Com_sprintf (weapon_filename, sizeof(weapon_filename), 'players/%s/%s', [model_name, cl_weaponmodels[i]]);
			ci^.weaponmodel[i] := re.RegisterModel(weapon_filename);
			if (ci^.weaponmodel[i]=nil) and (strcmp(model_name, 'cyborg') = 0) then begin
				// try male
				Com_sprintf (weapon_filename, sizeof(weapon_filename), 'players/male/%s', [cl_weaponmodels[i]]);
				ci^.weaponmodel[i] := re.RegisterModel(weapon_filename);
			end;
			if (cl_vwep^.value = 0) then
				break; // only one when vwep is off
		end;

		// icon file
		Com_sprintf (ci^.iconname, sizeof(ci^.iconname), '/players/%s/%s_i.pcx', [model_name, skin_name]);
		ci^.icon := re.RegisterPic (ci^.iconname);
	end;

	// must have loaded all data types to be valud
	if (ci^.skin<>nil) or (ci^.icon<>nil) or (ci^.model<>nil) or (ci^.weaponmodel[0]<>nil) then begin
		ci^.skin := nil;
		ci^.icon := nil;
		ci^.model := nil;
		ci^.weaponmodel[0] := nil;
	end;
end;

(*
================
CL_ParseClientinfo

Load the skin, icon, and model for a client
================
*)
procedure CL_ParseClientinfo (player: Integer);
var
	s: pchar;
	ci: clientinfo_p;
begin
	s := cl.configstrings[player+CS_PLAYERSKINS];

	ci := @cl.clientinfo[player];

	CL_LoadClientinfo (ci, s);
end;


(*
================
CL_ParseConfigString
================
*)
procedure CL_ParseConfigString ();
var
	i: Integer;
	s: PChar;
	olds: array[0..MAX_QPATH-1] of char;
begin
	i := MSG_ReadShort (net_message);
	if (i < 0) or (i >= MAX_CONFIGSTRINGS) then
		Com_Error (ERR_DROP, 'configstring > MAX_CONFIGSTRINGS');
	s := MSG_ReadString(net_message);

	strncpy (olds, cl.configstrings[i], sizeof(olds));
	olds[sizeof(olds) - 1] := #0;

	strcpy (cl.configstrings[i], s);

	// do something apropriate

	if (i >= CS_LIGHTS) and (i < CS_LIGHTS+MAX_LIGHTSTYLES) then
		CL_SetLightstyle (i - CS_LIGHTS)
	else if (i = CS_CDTRACK) then begin
		if (cl.refresh_prepped) then
			CDAudio_Play (StrToInt(cl.configstrings[CS_CDTRACK]), true);
	end
	else if (i >= CS_MODELS) and (i < CS_MODELS+MAX_MODELS) then begin
		if (cl.refresh_prepped) then begin
			cl.model_draw[i-CS_MODELS] := re.RegisterModel (cl.configstrings[i]);
			if (cl.configstrings[i][0] = '*') then
				cl.model_clip[i-CS_MODELS] := CM_InlineModel (cl.configstrings[i])
			else
				cl.model_clip[i-CS_MODELS] := nil;
    end;
	end
	else if (i >= CS_SOUNDS) and (i < CS_SOUNDS+MAX_MODELS) then begin
		if (cl.refresh_prepped) then
			cl.sound_precache[i-CS_SOUNDS] := S_RegisterSound (cl.configstrings[i]);
	end
	else if (i >= CS_IMAGES) and (i < CS_IMAGES+MAX_MODELS) then begin
		if (cl.refresh_prepped) then
			cl.image_precache[i-CS_IMAGES] := re.RegisterPic (cl.configstrings[i]);
	end
	else if (i >= CS_PLAYERSKINS) and (i < CS_PLAYERSKINS+MAX_CLIENTS) then begin
		if (cl.refresh_prepped) and (strcmp(olds, s)<>0) then
			CL_ParseClientinfo (i-CS_PLAYERSKINS);
	end;
end;


(*
=====================================================================

ACTION MESSAGES

=====================================================================
*)

(*
==================
CL_ParseStartSoundPacket
==================
*)
procedure CL_ParseStartSoundPacket();
var
  pos_v: vec3_t;
	pos: PSingle;
  channel, ent: Integer;
  sound_num: Integer;
  volume: Single;
  attenuation: Single;
	flags: Integer;
	ofs: Single;
begin
	flags := MSG_ReadByte (net_message);
	sound_num := MSG_ReadByte (net_message);

  if (flags and SND_VOLUME<>0) then
		volume := MSG_ReadByte (net_message) / 255.0
	else
		volume := DEFAULT_SOUND_PACKET_VOLUME;

  if (flags and SND_ATTENUATION<>0) then
		attenuation := MSG_ReadByte (net_message) / 64.0
	else
		attenuation := DEFAULT_SOUND_PACKET_ATTENUATION;

  if (flags and SND_OFFSET<>0) then
		ofs := MSG_ReadByte (net_message) / 1000.0
	else
		ofs := 0;

	if (flags and SND_ENT<>0) then begin
		// entity reletive
		channel := MSG_ReadShort(net_message);
		ent := channel shr 3;
		if (ent > MAX_EDICTS) then
			Com_Error (ERR_DROP,'CL_ParseStartSoundPacket: ent = %i', [ent]);

		channel := channel and 7;
	end
	else
	begin
		ent := 0;
		channel := 0;
	end;

	if (flags and SND_POS<>0) then begin
		// positioned in space
	  MSG_ReadPos (net_message, pos_v);

		pos := @pos_v;
	end
	else	// use entity number
		pos := nil;

	if (cl.sound_precache[sound_num] = nil) then
		exit;

	S_StartSound (@pos, ent, channel, cl.sound_precache[sound_num], volume, attenuation, ofs);
end;


procedure SHOWNET(s: pchar);
begin
	if (cl_shownet^.value>=2) then
		Com_Printf ('%3d:%s'#10, [net_message.readcount-1, s]);
end;

(*
=====================
CL_ParseServerMessage
=====================
*)
procedure CL_ParseServerMessage ();
var
	cmd: Integer;
	s: PChar;
	i: Integer;
begin
//
// if recording demos, copy the message out
//
	if (cl_shownet^.value = 1) then
		Com_Printf ('%i ', [net_message.cursize])
	else if (cl_shownet^.value >= 2) then
		Com_Printf ('------------------'#10);


//
// parse the message
//
	while (true) do begin
		if (net_message.readcount > net_message.cursize) then begin
			Com_Error (ERR_DROP, 'CL_ParseServerMessage: Bad server message');
			break;
		end;

		cmd := MSG_ReadByte (net_message);

		if (cmd = -1) then begin
			SHOWNET('END OF MESSAGE');
			break;
		end;

		if (cl_shownet^.value>=2) then begin
			if (svc_strings[cmd] = nil) then
				Com_Printf ('%3d:BAD CMD %d'#10, [net_message.readcount-1,cmd])
			else
				SHOWNET(svc_strings[cmd]);
		end;

	// other commands
		case svc_ops_e(cmd) of

		svc_nop:
//			Com_Printf ("svc_nop\n");
    ;
		svc_disconnect:
			Com_Error (ERR_DISCONNECT, 'Server disconnected'#10);

		svc_reconnect:
     begin
			Com_Printf ('Server disconnected, reconnecting'#10);
			if (cls.download > 0) then begin
				//ZOID, close download
				FileClose (cls.download);
				cls.download := 0;
			end;
			cls.state := ca_connecting;
			cls.connect_time := -99999;	// CL_CheckForResend() will fire immediately
		 end;

		svc_print:
     begin
			i := MSG_ReadByte (net_message);
			if (i = PRINT_CHAT) then begin
				S_StartLocalSound ('misc/talk.wav');
				con.ormask := 128;
			end;
			Com_Printf ('%s', [MSG_ReadString (net_message)]);
			con.ormask := 0;
		 end;

		svc_centerprint:   
			SCR_CenterPrint (MSG_ReadString (net_message));

		svc_stufftext:
     begin
			s := MSG_ReadString (net_message);
			Com_DPrintf ('stufftext: %s'#10, [s]);
			Cbuf_AddText (s);
		 end;

		svc_serverdata:
     begin
			Cbuf_Execute ();		// make sure any stuffed commands are done
			CL_ParseServerData ();
		 end;

		svc_configstring:
			CL_ParseConfigString ();

		svc_sound:
			CL_ParseStartSoundPacket();

		svc_spawnbaseline:
			CL_ParseBaseline ();

		svc_temp_entity:
			CL_ParseTEnt ();

		svc_muzzleflash:
			CL_ParseMuzzleFlash ();

		svc_muzzleflash2:
			CL_ParseMuzzleFlash2 ();

		svc_download:
			CL_ParseDownload ();

		svc_frame:
			CL_ParseFrame ();

		svc_inventory:
			CL_ParseInventory ();

		svc_layout:
     begin
			s := MSG_ReadString (net_message);
			strncpy (cl.layout, s, sizeof(cl.layout)-1);
     end;
		svc_playerinfo,
		svc_packetentities,
		svc_deltapacketentities:
			Com_Error (ERR_DROP, 'Out of place frame data');
    else begin
			Com_Error (ERR_DROP, 'CL_ParseServerMessage: Illegible server message'#10);
    end;
    end;
	end;

	CL_AddNetgraph ();

	//
	// we don't know if it is ok to save a demo message until
	// after we have parsed the frame
	//
	if (cls.demorecording) and (not cls.demowaiting) then
		CL_WriteDemoMessage ();

end;


end.