|
public static LinkEdict ( |
||
| ent | ||
| touch_triggers | bool | |
| Результат | void | |
/*
* ===============
* PF_droptofloor
*
* void() droptofloor
* ===============
*/
static void PF_droptofloor()
{
edict_t ent = Server.ProgToEdict(Progs.GlobalStruct.self);
Vector3 org, mins, maxs;
Mathlib.Copy(ref ent.v.origin, out org);
Mathlib.Copy(ref ent.v.mins, out mins);
Mathlib.Copy(ref ent.v.maxs, out maxs);
Vector3 end = org;
end.Z -= 256;
trace_t trace = Server.Move(ref org, ref mins, ref maxs, ref end, 0, ent);
if (trace.fraction == 1 || trace.allsolid)
{
ReturnFloat(0);
}
else
{
Mathlib.Copy(ref trace.endpos, out ent.v.origin);
Server.LinkEdict(ent, false);
ent.v.flags = (int)ent.v.flags | EdictFlags.FL_ONGROUND;
ent.v.groundentity = Server.EdictToProg(trace.ent);
ReturnFloat(1);
}
}
/// <summary>
/// PF_setorigin
/// This is the only valid way to move an object without using the physics of the world (setting velocity and waiting).
/// Directly changing origin will not set internal links correctly, so clipping would be messed up.
/// This should be called when an object is spawned, and then only if it is teleported.
/// setorigin (entity, origin)
/// </summary>
static unsafe void PF_setorigin()
{
edict_t e = GetEdict(OFS.OFS_PARM0);
float * org = GetVector(OFS.OFS_PARM1);
Copy(org, ref e.v.origin);
Server.LinkEdict(e, false);
}
/// <summary>
/// Host_Loadgame_f
/// </summary>
private static void Loadgame_f()
{
if (Cmd.Source != cmd_source_t.src_command)
{
return;
}
if (Cmd.Argc != 2)
{
Con.Print("load <savename> : load a game\n");
return;
}
Client.cls.demonum = -1; // stop demo loop in case this fails
string name = Path.ChangeExtension(Path.Combine(Common.GameDir, Cmd.Argv(1)), ".sav");
// we can't call SCR_BeginLoadingPlaque, because too much stack space has
// been used. The menu calls it before stuffing loadgame command
// SCR_BeginLoadingPlaque ();
Con.Print("Loading game from {0}...\n", name);
FileStream fs = Sys.FileOpenRead(name);
if (fs == null)
{
Con.Print("ERROR: couldn't open.\n");
return;
}
using (StreamReader reader = new StreamReader(fs, Encoding.ASCII))
{
string line = reader.ReadLine();
int version = Common.atoi(line);
if (version != SAVEGAME_VERSION)
{
Con.Print("Savegame is version {0}, not {1}\n", version, SAVEGAME_VERSION);
return;
}
line = reader.ReadLine();
float[] spawn_parms = new float[Server.NUM_SPAWN_PARMS];
for (int i = 0; i < spawn_parms.Length; i++)
{
line = reader.ReadLine();
spawn_parms[i] = Common.atof(line);
}
// this silliness is so we can load 1.06 save files, which have float skill values
line = reader.ReadLine();
float tfloat = Common.atof(line);
Host.CurrentSkill = (int)(tfloat + 0.1);
Cvar.Set("skill", (float)Host.CurrentSkill);
string mapname = reader.ReadLine();
line = reader.ReadLine();
float time = Common.atof(line);
Client.Disconnect_f();
Server.SpawnServer(mapname);
if (!Server.sv.active)
{
Con.Print("Couldn't load map\n");
return;
}
Server.sv.paused = true; // pause until all clients connect
Server.sv.loadgame = true;
// load the light styles
for (int i = 0; i < QDef.MAX_LIGHTSTYLES; i++)
{
line = reader.ReadLine();
Server.sv.lightstyles[i] = line;
}
// load the edicts out of the savegame file
int entnum = -1; // -1 is the globals
StringBuilder sb = new StringBuilder(32768);
while (!reader.EndOfStream)
{
line = reader.ReadLine();
if (line == null)
{
Sys.Error("EOF without closing brace");
}
sb.AppendLine(line);
int idx = line.IndexOf('}');
if (idx != -1)
{
int length = 1 + sb.Length - (line.Length - idx);
string data = Common.Parse(sb.ToString(0, length));
if (String.IsNullOrEmpty(Common.Token))
{
break; // end of file
}
if (Common.Token != "{")
{
Sys.Error("First token isn't a brace");
}
if (entnum == -1)
{
// parse the global vars
Progs.ParseGlobals(data);
}
else
{
// parse an edict
edict_t ent = Server.EdictNum(entnum);
ent.Clear();
Progs.ParseEdict(data, ent);
// link it into the bsp tree
if (!ent.free)
{
Server.LinkEdict(ent, false);
}
}
entnum++;
sb.Remove(0, length);
}
}
Server.sv.num_edicts = entnum;
Server.sv.time = time;
for (int i = 0; i < Server.NUM_SPAWN_PARMS; i++)
{
Server.svs.clients[0].spawn_parms[i] = spawn_parms[i];
}
}
if (Client.cls.state != cactive_t.ca_dedicated)
{
Client.EstablishConnection("local");
Reconnect_f();
}
}
static void SetMinMaxSize(edict_t e, ref Vector3 min, ref Vector3 max, bool rotate)
{
if (min.X > max.X || min.Y > max.Y || min.Z > max.Z)
{
Progs.RunError("backwards mins/maxs");
}
rotate = false; // FIXME: implement rotation properly again
Vector3 rmin = min, rmax = max;
if (!rotate)
{
//rmin = min;
//rmax = max;
}
else
{
// find min / max for rotations
//angles = e.v.angles;
//a = angles[1] / 180 * M_PI;
//xvector[0] = cos(a);
//xvector[1] = sin(a);
//yvector[0] = -sin(a);
//yvector[1] = cos(a);
//VectorCopy(min, bounds[0]);
//VectorCopy(max, bounds[1]);
//rmin[0] = rmin[1] = rmin[2] = 9999;
//rmax[0] = rmax[1] = rmax[2] = -9999;
//for (i = 0; i <= 1; i++)
//{
// base[0] = bounds[i][0];
// for (j = 0; j <= 1; j++)
// {
// base[1] = bounds[j][1];
// for (k = 0; k <= 1; k++)
// {
// base[2] = bounds[k][2];
// // transform the point
// transformed[0] = xvector[0] * base[0] + yvector[0] * base[1];
// transformed[1] = xvector[1] * base[0] + yvector[1] * base[1];
// transformed[2] = base[2];
// for (l = 0; l < 3; l++)
// {
// if (transformed[l] < rmin[l])
// rmin[l] = transformed[l];
// if (transformed[l] > rmax[l])
// rmax[l] = transformed[l];
// }
// }
// }
//}
}
// set derived values
Mathlib.Copy(ref rmin, out e.v.mins);
Mathlib.Copy(ref rmax, out e.v.maxs);
Vector3 s = max - min;
Mathlib.Copy(ref s, out e.v.size);
Server.LinkEdict(e, false);
}