public virtual void Read(QuakeFile f)
{
userinfo = f.ReadString();
netname = f.ReadString();
hand = f.ReadInt32();
connected = f.ReadInt32() != 0;
health = f.ReadInt32();
max_health = f.ReadInt32();
savedFlags = f.ReadInt32();
selected_item = f.ReadInt32();
for (int n = 0; n < Defines.MAX_ITEMS; n++)
{
inventory[n] = f.ReadInt32();
}
max_bullets = f.ReadInt32();
max_shells = f.ReadInt32();
max_rockets = f.ReadInt32();
max_grenades = f.ReadInt32();
max_cells = f.ReadInt32();
max_slugs = f.ReadInt32();
weapon = f.ReadItem();
lastweapon = f.ReadItem();
power_cubes = f.ReadInt32();
score = f.ReadInt32();
game_helpchanged = f.ReadInt32();
helpchanged = f.ReadInt32();
spectator = f.ReadInt32() != 0;
}
public static void SV_WriteLevelFile( )
{
String name;
QuakeFile f;
Com.DPrintf("SV_WriteLevelFile()\\n");
name = FS.Gamedir() + "/save/current/" + SV_INIT.sv.name + ".sv2";
try
{
f = new QuakeFile(name, FileAccess.ReadWrite);
for (var i = 0; i < Defines.MAX_CONFIGSTRINGS; i++)
{
f.Write(SV_INIT.sv.configstrings[i]);
}
CM.CM_WritePortalState(f);
f.Dispose();
}
catch (Exception e)
{
Com.Printf("Failed to open " + name + "\\n");
e.PrintStackTrace();
}
name = FS.Gamedir() + "/save/current/" + SV_INIT.sv.name + ".sav";
GameSave.WriteLevel(name);
}
public virtual void Read(QuakeFile f)
{
framenum = f.ReadInt32();
time = f.ReadSingle();
level_name = f.ReadString();
mapname = f.ReadString();
nextmap = f.ReadString();
intermissiontime = f.ReadSingle();
changemap = f.ReadString();
exitintermission = f.ReadBoolean();
intermission_origin = f.ReadVector();
intermission_angle = f.ReadVector();
sight_client = f.ReadEdictRef();
sight_entity = f.ReadEdictRef();
sight_entity_framenum = f.ReadInt32();
sound_entity = f.ReadEdictRef();
sound_entity_framenum = f.ReadInt32();
sound2_entity = f.ReadEdictRef();
sound2_entity_framenum = f.ReadInt32();
pic_health = f.ReadInt32();
total_secrets = f.ReadInt32();
found_secrets = f.ReadInt32();
total_goals = f.ReadInt32();
found_goals = f.ReadInt32();
total_monsters = f.ReadInt32();
killed_monsters = f.ReadInt32();
current_entity = f.ReadEdictRef();
body_que = f.ReadInt32();
power_cubes = f.ReadInt32();
if (f.ReadInt32() != 4711)
{
System.Diagnostics.Debug.WriteLine("error in reading level_locals.");
}
}
public static void WriteLevel(String filename)
{
try
{
Int32 i;
edict_t ent;
QuakeFile f;
f = new QuakeFile(filename, FileAccess.ReadWrite);
if (f == null)
{
GameBase.gi.Error("Couldn't open for writing: " + filename);
}
GameBase.level.Write(f);
for (i = 0; i < GameBase.num_edicts; i++)
{
ent = GameBase.g_edicts[i];
if (!ent.inuse)
{
continue;
}
f.Write(i);
ent.Write(f);
}
i = -1;
f.Write(-1);
f.Dispose();
}
catch (Exception e)
{
e.PrintStackTrace();
}
}
public virtual void Load(QuakeFile f)
{
pmove.Load(f);
viewangles[0] = f.ReadSingle();
viewangles[1] = f.ReadSingle();
viewangles[2] = f.ReadSingle();
viewoffset[0] = f.ReadSingle();
viewoffset[1] = f.ReadSingle();
viewoffset[2] = f.ReadSingle();
kick_angles[0] = f.ReadSingle();
kick_angles[1] = f.ReadSingle();
kick_angles[2] = f.ReadSingle();
gunangles[0] = f.ReadSingle();
gunangles[1] = f.ReadSingle();
gunangles[2] = f.ReadSingle();
gunoffset[0] = f.ReadSingle();
gunoffset[1] = f.ReadSingle();
gunoffset[2] = f.ReadSingle();
gunindex = f.ReadInt32();
gunframe = f.ReadInt32();
blend[0] = f.ReadSingle();
blend[1] = f.ReadSingle();
blend[2] = f.ReadSingle();
blend[3] = f.ReadSingle();
fov = f.ReadSingle();
rdflags = f.ReadInt32();
for (int n = 0; n < Defines.MAX_STATS; n++)
{
stats[n] = f.ReadInt16();
}
}
public static void SV_ReadLevelFile( )
{
String name;
QuakeFile f;
Com.DPrintf("SV_ReadLevelFile()\\n");
name = FS.Gamedir() + "/save/current/" + SV_INIT.sv.name + ".sv2";
try
{
f = new QuakeFile(name, FileAccess.Read);
for (var n = 0; n < Defines.MAX_CONFIGSTRINGS; n++)
{
SV_INIT.sv.configstrings[n] = f.ReadString();
}
CM.CM_ReadPortalState(f);
f.Close();
}
catch (IOException e1)
{
Com.Printf("Failed to open " + name + "\\n");
e1.PrintStackTrace();
}
name = FS.Gamedir() + "/save/current/" + SV_INIT.sv.name + ".sav";
GameSave.ReadLevel(name);
}
public virtual void Write(QuakeFile f)
{
f.Write(currentmove != null);
if (currentmove != null)
{
currentmove.Write(f);
}
f.Write(aiflags);
f.Write(nextframe);
f.Write(scale);
f.WriteAdapter(stand);
f.WriteAdapter(idle);
f.WriteAdapter(search);
f.WriteAdapter(walk);
f.WriteAdapter(run);
f.WriteAdapter(dodge);
f.WriteAdapter(attack);
f.WriteAdapter(melee);
f.WriteAdapter(sight);
f.WriteAdapter(checkattack);
f.Write(pausetime);
f.Write(attack_finished);
f.WriteVector(saved_goal);
f.Write(search_time);
f.Write(trail_time);
f.WriteVector(last_sighting);
f.Write(attack_state);
f.Write(lefty);
f.Write(idle_time);
f.Write(linkcount);
f.Write(power_armor_power);
f.Write(power_armor_type);
}
public virtual void Write(QuakeFile f)
{
pmove.Write(f);
f.Write(viewangles[0]);
f.Write(viewangles[1]);
f.Write(viewangles[2]);
f.Write(viewoffset[0]);
f.Write(viewoffset[1]);
f.Write(viewoffset[2]);
f.Write(kick_angles[0]);
f.Write(kick_angles[1]);
f.Write(kick_angles[2]);
f.Write(gunangles[0]);
f.Write(gunangles[1]);
f.Write(gunangles[2]);
f.Write(gunoffset[0]);
f.Write(gunoffset[1]);
f.Write(gunoffset[2]);
f.Write(gunindex);
f.Write(gunframe);
f.Write(blend[0]);
f.Write(blend[1]);
f.Write(blend[2]);
f.Write(blend[3]);
f.Write(fov);
f.Write(rdflags);
for (int n = 0; n < Defines.MAX_STATS; n++)
{
f.Write(stats[n]);
}
}
public static void WriteGame(String filename, Boolean autosave)
{
try
{
QuakeFile f;
if (!autosave)
{
PlayerClient.SaveClientData();
}
f = new QuakeFile(filename, FileAccess.ReadWrite);
if (f == null)
{
GameBase.gi.Error("Couldn't write to " + filename);
}
GameBase.game.autosaved = autosave;
GameBase.game.Write(f);
GameBase.game.autosaved = false;
for (var i = 0; i < GameBase.game.maxclients; i++)
{
GameBase.game.clients[i].Write(f);
}
f.Dispose();
}
catch (Exception e)
{
e.PrintStackTrace();
}
}
public virtual void Write(QuakeFile f)
{
f.Write(framenum);
f.Write(time);
f.Write(level_name);
f.Write(mapname);
f.Write(nextmap);
f.Write(intermissiontime);
f.Write(changemap);
f.Write(exitintermission);
f.WriteVector(intermission_origin);
f.WriteVector(intermission_angle);
f.WriteEdictRef(sight_client);
f.WriteEdictRef(sight_entity);
f.Write(sight_entity_framenum);
f.WriteEdictRef(sound_entity);
f.Write(sound_entity_framenum);
f.WriteEdictRef(sound2_entity);
f.Write(sound2_entity_framenum);
f.Write(pic_health);
f.Write(total_secrets);
f.Write(found_secrets);
f.Write(total_goals);
f.Write(found_goals);
f.Write(total_monsters);
f.Write(killed_monsters);
f.WriteEdictRef(current_entity);
f.Write(body_que);
f.Write(power_cubes);
f.Write(4711);
}
public virtual void Write(QuakeFile f)
{
f.Write(userinfo);
f.Write(netname);
f.Write(hand);
f.Write(connected ? 1 : 0);
f.Write(health);
f.Write(max_health);
f.Write(savedFlags);
f.Write(selected_item);
for (int n = 0; n < Defines.MAX_ITEMS; n++)
{
f.Write(inventory[n]);
}
f.Write(max_bullets);
f.Write(max_shells);
f.Write(max_rockets);
f.Write(max_grenades);
f.Write(max_cells);
f.Write(max_slugs);
f.WriteItem(weapon);
f.WriteItem(lastweapon);
f.Write(power_cubes);
f.Write(score);
f.Write(game_helpchanged);
f.Write(helpchanged);
f.Write(spectator ? 1 : 0);
}
public static void ReadLevel(String filename)
{
try
{
edict_t ent;
QuakeFile f = new QuakeFile(filename, FileAccess.Read);
if (f == null)
{
GameBase.gi.Error("Couldn't read level file " + filename);
}
CreateEdicts();
GameBase.num_edicts = ( Int32 )GameBase.maxclients.value + 1;
GameBase.level.Read(f);
while (true)
{
var entnum = f.ReadInt32();
if (entnum == -1)
{
break;
}
if (entnum >= GameBase.num_edicts)
{
GameBase.num_edicts = entnum + 1;
}
ent = GameBase.g_edicts[entnum];
ent.Read(f);
ent.Cleararealinks();
GameBase.gi.Linkentity(ent);
}
f.Dispose();
for (var i = 0; i < GameBase.maxclients.value; i++)
{
ent = GameBase.g_edicts[i + 1];
ent.client = GameBase.game.clients[i];
ent.client.pers.connected = false;
}
for (var i = 0; i < GameBase.num_edicts; i++)
{
ent = GameBase.g_edicts[i];
if (!ent.inuse)
{
continue;
}
if (ent.classname != null)
{
if (Lib.Strcmp(ent.classname, "target_crosslevel_target") == 0)
{
ent.nextthink = GameBase.level.time + ent.delay;
}
}
}
}
catch (Exception e)
{
e.PrintStackTrace();
}
}
public static void SV_WriteServerFile(Boolean autosave)
{
QuakeFile f;
cvar_t var;
String filename, name, string_renamed, comment;
Com.DPrintf("SV_WriteServerFile(" + (autosave ? "true" : "false") + ")\\n");
filename = FS.Gamedir() + "/save/current/server.ssv";
try
{
f = new QuakeFile(filename, FileAccess.ReadWrite);
if (!autosave)
{
var now = DateTime.Now;
comment = Com.Sprintf("%2i:%2i %2i/%2i ", now.Hour, now.Minute, now.Month + 1, now.Day);
comment += SV_INIT.sv.configstrings[Defines.CS_NAME];
}
else
{
comment = "ENTERING " + SV_INIT.sv.configstrings[Defines.CS_NAME];
}
f.Write(comment);
f.Write(SV_INIT.svs.mapcmd);
for (var = Globals.cvar_vars; var != null; var = var.next)
{
if (0 == (var.flags & Defines.CVAR_LATCH))
{
continue;
}
if (var.name.Length >= Defines.MAX_OSPATH - 1 || var.string_renamed.Length >= 128 - 1)
{
Com.Printf("Cvar too long: " + var.name + " = " + var.string_renamed + "\\n");
continue;
}
name = var.name;
string_renamed = var.string_renamed;
try
{
f.Write(name);
f.Write(string_renamed);
}
catch (IOException e2)
{
}
}
f.Write(( String )null);
f.Dispose();
}
catch (Exception e)
{
Com.Printf("Couldn't write " + filename + "\\n");
}
filename = FS.Gamedir() + "/save/current/game.ssv";
GameSave.WriteGame(filename, autosave);
}
public virtual void Read(QuakeFile f)
{
coop_respawn.Read(f);
enterframe = f.ReadInt32();
score = f.ReadInt32();
cmd_angles[0] = f.ReadSingle();
cmd_angles[1] = f.ReadSingle();
cmd_angles[2] = f.ReadSingle();
spectator = f.ReadInt32() != 0;
}
public virtual void Write(QuakeFile f)
{
coop_respawn.Write(f);
f.Write(enterframe);
f.Write(score);
f.Write(cmd_angles[0]);
f.Write(cmd_angles[1]);
f.Write(cmd_angles[2]);
f.Write(spectator ? 1 : 0);
}
public virtual void Write(QuakeFile f)
{
f.Write(DateTime.Now.ToString());
f.Write(helpmessage1);
f.Write(helpmessage2);
f.Write(helpchanged);
f.Write(spawnpoint);
f.Write(maxclients);
f.Write(maxentities);
f.Write(serverflags);
f.Write(num_items);
f.Write(autosaved ? 1 : 0);
f.Write(1928);
}
public virtual void Read(QuakeFile f)
{
firstframe = f.ReadInt32();
lastframe = f.ReadInt32();
int len = f.ReadInt32();
frame = new mframe_t[len];
for (int n = 0; n < len; n++)
{
frame[n] = new mframe_t();
frame[n].Read(f);
}
endfunc = (EntThinkAdapter)f.ReadAdapter();
}
public static void WriteBindings(QuakeFile f)
{
for (int i = 0; i < 256; i++)
{
if (keybindings[i] != null && keybindings[i].Length > 0)
{
try
{
f.Write("bind " + KeynumToString(i) + " \\\"" + keybindings[i] + "\\\"\\n");
}
catch (IOException e)
{
}
}
}
}
public virtual void Load(QuakeFile f)
{
pm_type = f.ReadInt32();
origin[0] = f.ReadInt16();
origin[1] = f.ReadInt16();
origin[2] = f.ReadInt16();
velocity[0] = f.ReadInt16();
velocity[1] = f.ReadInt16();
velocity[2] = f.ReadInt16();
pm_flags = f.ReadByte();
pm_time = f.ReadByte();
gravity = f.ReadInt16();
f.ReadInt16();
delta_angles[0] = f.ReadInt16();
delta_angles[1] = f.ReadInt16();
delta_angles[2] = f.ReadInt16();
}
public virtual void Write(QuakeFile f)
{
f.Write(pm_type);
f.Write(origin[0]);
f.Write(origin[1]);
f.Write(origin[2]);
f.Write(velocity[0]);
f.Write(velocity[1]);
f.Write(velocity[2]);
f.Write(pm_flags);
f.Write(pm_time);
f.Write(gravity);
f.Write(( short )0);
f.Write(delta_angles[0]);
f.Write(delta_angles[1]);
f.Write(delta_angles[2]);
}
public static Boolean CheckOrDownloadFile(String filename)
{
if (filename.IndexOf("..") != -1)
{
Com.Printf("Refusing to download a path with ..\\n");
return(true);
}
if (FS.FileLength(filename) > 0)
{
return(true);
}
Globals.cls.downloadname = filename;
Globals.cls.downloadtempname = Com.StripExtension(Globals.cls.downloadname);
Globals.cls.downloadtempname += ".tmp";
var name = DownloadFileName(Globals.cls.downloadtempname);
QuakeFile fp = new QuakeFile(name, FileAccess.ReadWrite);
if (fp != null)
{
Int64 len = 0;
try
{
len = fp.Length;
}
catch (IOException e)
{
}
Globals.cls.download = fp;
Com.Printf("Resuming " + Globals.cls.downloadname + "\\n");
MSG.WriteByte(Globals.cls.netchan.message, Defines.clc_stringcmd);
MSG.WriteString(Globals.cls.netchan.message, "download " + Globals.cls.downloadname + " " + len);
}
else
{
Com.Printf("Downloading " + Globals.cls.downloadname + "\\n");
MSG.WriteByte(Globals.cls.netchan.message, Defines.clc_stringcmd);
MSG.WriteString(Globals.cls.netchan.message, "download " + Globals.cls.downloadname);
}
Globals.cls.downloadnumber++;
return(false);
}
public virtual void Load(QuakeFile f)
{
string date = f.ReadString();
helpmessage1 = f.ReadString();
helpmessage2 = f.ReadString();
helpchanged = f.ReadInt32();
spawnpoint = f.ReadString();
maxclients = f.ReadInt32();
maxentities = f.ReadInt32();
serverflags = f.ReadInt32();
num_items = f.ReadInt32();
autosaved = f.ReadInt32() != 0;
if (f.ReadInt32() != 1928)
{
Com.DPrintf("error in loading game_locals, 1928\\n");
}
}
public virtual void Write(QuakeFile f)
{
f.WriteEdictRef(surrounding_ent);
f.WriteVector(origin);
f.WriteVector(angles);
f.WriteVector(old_origin);
f.Write(modelindex);
f.Write(modelindex2);
f.Write(modelindex3);
f.Write(modelindex4);
f.Write(frame);
f.Write(skinnum);
f.Write(effects);
f.Write(renderfx);
f.Write(solid);
f.Write(sound);
f.Write(event_renamed);
}
public virtual void Read(QuakeFile f)
{
surrounding_ent = f.ReadEdictRef();
origin = f.ReadVector();
angles = f.ReadVector();
old_origin = f.ReadVector();
modelindex = f.ReadInt32();
modelindex2 = f.ReadInt32();
modelindex3 = f.ReadInt32();
modelindex4 = f.ReadInt32();
frame = f.ReadInt32();
skinnum = f.ReadInt32();
effects = f.ReadInt32();
renderfx = f.ReadInt32();
solid = f.ReadInt32();
sound = f.ReadInt32();
event_renamed = f.ReadInt32();
}
public virtual void Write(QuakeFile f)
{
f.Write(firstframe);
f.Write(lastframe);
if (frame == null)
{
f.Write(-1);
}
else
{
f.Write(frame.Length);
for (int n = 0; n < frame.Length; n++)
{
frame[n].Write(f);
}
}
f.WriteAdapter(endfunc);
}
public static void SV_Loadgame_f( )
{
if (Cmd.Argc() != 2)
{
Com.Printf("USAGE: loadgame <directory>\\n");
return;
}
Com.Printf("Loading game...\\n");
var dir = Cmd.Argv(1);
if ((dir.IndexOf("..") > -1) || (dir.IndexOf("/") > -1) || (dir.IndexOf("\\\\") > -1))
{
Com.Printf("Bad savedir.\\n");
}
var name = FS.Gamedir() + "/save/" + Cmd.Argv(1) + "/server.ssv";
QuakeFile f;
try
{
f = new QuakeFile(name, FileAccess.Read);
}
catch (FileNotFoundException e)
{
Com.Printf("No such savegame: " + name + "\\n");
return;
}
try
{
f.Dispose();
}
catch (IOException e1)
{
e1.PrintStackTrace();
}
SV_CopySaveGame(Cmd.Argv(1), "current");
SV_ReadServerFile();
SV_INIT.sv.state = Defines.ss_dead;
SV_INIT.SV_Map(false, SV_INIT.svs.mapcmd, true);
}
static void SVCmd_WriteIP_f( )
{
QuakeFile f;
String name;
Byte[] b;
Int32 i;
cvar_t game;
game = GameBase.gi.Cvar_f("game", "", 0);
if (game.string_renamed == null)
{
name = Defines.GAMEVERSION + "/listip.cfg";
}
else
{
name = game.string_renamed + "/listip.cfg";
}
GameBase.gi.Cprintf(null, Defines.PRINT_HIGH, "Writing " + name + ".\\n");
f = new QuakeFile(name, FileAccess.ReadWrite); //Lib.Fopen(name, "rw");
if (f == null)
{
GameBase.gi.Cprintf(null, Defines.PRINT_HIGH, "Couldn't open " + name + "\\n");
return;
}
try
{
f.Write("set filterban " + ( Int32 )GameBase.filterban.value + "\\n");
for (i = 0; i < numipfilters; i++)
{
b = Lib.GetIntBytes(ipfilters[i].compare);
f.Write("sv addip " + (b[0] & 0xff) + "." + (b[1] & 0xff) + "." + (b[2] & 0xff) + "." + (b[3] & 0xff) + "\\n");
}
}
catch (IOException e)
{
Com.Printf("IOError in SVCmd_WriteIP_f:" + e);
}
f.Dispose();
}
public static void ReadGame(String filename)
{
QuakeFile f = null;
try
{
f = new QuakeFile(filename, FileAccess.Read);
CreateEdicts();
GameBase.game.Load(f);
for (var i = 0; i < GameBase.game.maxclients; i++)
{
GameBase.game.clients[i] = new gclient_t(i);
GameBase.game.clients[i].Read(f);
}
f.Close();
}
catch (Exception e)
{
e.PrintStackTrace();
}
}
public static void WriteVariables(String path)
{
cvar_t var;
QuakeFile f;
String buffer;
f = new QuakeFile(path, System.IO.FileAccess.ReadWrite);
if (f == null)
{
return;
}
try
{
f.Seek(f.Length);
}
catch (Exception e1)
{
f.Dispose();
return;
}
for (var = cvar_vars; var != null; var = var.next)
{
if ((var.flags & CVAR_ARCHIVE) != 0)
{
buffer = "set " + var.name + " \\\"" + var.string_renamed + "\\\"\\n";
try
{
f.Write(buffer);
}
catch (Exception e)
{
}
}
}
f.Dispose();
}
public virtual void Read(QuakeFile f)
{
start_origin = f.ReadVector();
start_angles = f.ReadVector();
end_origin = f.ReadVector();
end_angles = f.ReadVector();
sound_start = f.ReadInt32();
sound_middle = f.ReadInt32();
sound_end = f.ReadInt32();
accel = f.ReadSingle();
speed = f.ReadSingle();
decel = f.ReadSingle();
distance = f.ReadSingle();
wait = f.ReadSingle();
state = f.ReadInt32();
dir = f.ReadVector();
current_speed = f.ReadSingle();
move_speed = f.ReadSingle();
next_speed = f.ReadSingle();
remaining_distance = f.ReadSingle();
decel_distance = f.ReadSingle();
endfunc = ( EntThinkAdapter )f.ReadAdapter();
}
