|
public static Move ( Vector3 &start, Vector3 &mins, Vector3 &maxs, Vector3 &end, int type, |
||
| start | Vector3 | |
| mins | Vector3 | |
| maxs | Vector3 | |
| end | Vector3 | |
| type | int | |
| passedict | ||
| return | ||
/*
* =================
* PF_traceline
*
* Used for use tracing and shot targeting
* Traces are blocked by bbox and exact bsp entityes, and also slide box entities
* if the tryents flag is set.
*
* traceline (vector1, vector2, tryents)
* =================
*/
static unsafe void PF_traceline()
{
float * v1 = GetVector(OFS.OFS_PARM0);
float * v2 = GetVector(OFS.OFS_PARM1);
int nomonsters = (int)GetFloat(OFS.OFS_PARM2);
edict_t ent = GetEdict(OFS.OFS_PARM3);
Vector3 vec1, vec2;
Copy(v1, out vec1);
Copy(v2, out vec2);
trace_t trace = Server.Move(ref vec1, ref Common.ZeroVector, ref Common.ZeroVector, ref vec2, nomonsters, ent);
Progs.GlobalStruct.trace_allsolid = trace.allsolid ? 1 : 0;
Progs.GlobalStruct.trace_startsolid = trace.startsolid ? 1 : 0;
Progs.GlobalStruct.trace_fraction = trace.fraction;
Progs.GlobalStruct.trace_inwater = trace.inwater ? 1 : 0;
Progs.GlobalStruct.trace_inopen = trace.inopen ? 1 : 0;
Mathlib.Copy(ref trace.endpos, out Progs.GlobalStruct.trace_endpos);
Mathlib.Copy(ref trace.plane.normal, out Progs.GlobalStruct.trace_plane_normal);
Progs.GlobalStruct.trace_plane_dist = trace.plane.dist;
if (trace.ent != null)
{
Progs.GlobalStruct.trace_ent = Server.EdictToProg(trace.ent);
}
else
{
Progs.GlobalStruct.trace_ent = Server.EdictToProg(Server.sv.edicts[0]);
}
}
/*
* ===============
* 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);
}
}
/*
* =============
* PF_aim
*
* Pick a vector for the player to shoot along
* vector aim(entity, missilespeed)
* =============
*/
static void PF_aim()
{
edict_t ent = GetEdict(OFS.OFS_PARM0);
float speed = GetFloat(OFS.OFS_PARM1);
Vector3 start = Common.ToVector(ref ent.v.origin);
start.Z += 20;
// try sending a trace straight
Vector3 dir;
Mathlib.Copy(ref Progs.GlobalStruct.v_forward, out dir);
Vector3 end = start + dir * 2048;
trace_t tr = Server.Move(ref start, ref Common.ZeroVector, ref Common.ZeroVector, ref end, 0, ent);
if (tr.ent != null && tr.ent.v.takedamage == Damages.DAMAGE_AIM &&
(Host.TeamPlay == 0 || ent.v.team <= 0 || ent.v.team != tr.ent.v.team))
{
ReturnVector(ref Progs.GlobalStruct.v_forward);
return;
}
// try all possible entities
Vector3 bestdir = dir;
float bestdist = Server.Aim;
edict_t bestent = null;
for (int i = 1; i < Server.sv.num_edicts; i++)
{
edict_t check = Server.sv.edicts[i];
if (check.v.takedamage != Damages.DAMAGE_AIM)
{
continue;
}
if (check == ent)
{
continue;
}
if (Host.TeamPlay != 0 && ent.v.team > 0 && ent.v.team == check.v.team)
{
continue; // don't aim at teammate
}
v3f tmp;
Mathlib.VectorAdd(ref check.v.mins, ref check.v.maxs, out tmp);
Mathlib.VectorMA(ref check.v.origin, 0.5f, ref tmp, out tmp);
Mathlib.Copy(ref tmp, out end);
dir = end - start;
Mathlib.Normalize(ref dir);
float dist = Vector3.Dot(dir, Common.ToVector(ref Progs.GlobalStruct.v_forward));
if (dist < bestdist)
{
continue; // to far to turn
}
tr = Server.Move(ref start, ref Common.ZeroVector, ref Common.ZeroVector, ref end, 0, ent);
if (tr.ent == check)
{ // can shoot at this one
bestdist = dist;
bestent = check;
}
}
if (bestent != null)
{
v3f dir2, end2;
Mathlib.VectorSubtract(ref bestent.v.origin, ref ent.v.origin, out dir2);
float dist = Mathlib.DotProduct(ref dir2, ref Progs.GlobalStruct.v_forward);
Mathlib.VectorScale(ref Progs.GlobalStruct.v_forward, dist, out end2);
end2.z = dir2.z;
Mathlib.Normalize(ref end2);
ReturnVector(ref end2);
}
else
{
ReturnVector(ref bestdir);
}
}