| public static VectorMA ( v3f &a, float scale, v3f &b, v3f &c ) : void | ||
| a | v3f | |
| scale | float | |
| b | v3f | |
| c | v3f | |
| return | void | |
/// <summary>
/// SV_Physics_Noclip
/// A moving object that doesn't obey physics
/// </summary>
static void Physics_Noclip(edict_t ent)
{
// regular thinking
if (!RunThink(ent))
{
return;
}
Mathlib.VectorMA(ref ent.v.angles, (float)Host.FrameTime, ref ent.v.avelocity, out ent.v.angles);
Mathlib.VectorMA(ref ent.v.origin, (float)Host.FrameTime, ref ent.v.velocity, out ent.v.origin);
LinkEdict(ent, false);
}
/// <summary>
/// SV_FlyMove
/// The basic solid body movement clip that slides along multiple planes
/// Returns the clipflags if the velocity was modified (hit something solid)
/// 1 = floor
/// 2 = wall / step
/// 4 = dead stop
/// If steptrace is not NULL, the trace of any vertical wall hit will be stored
/// </summary>
static int FlyMove(edict_t ent, float time, trace_t steptrace)
{
v3f original_velocity = ent.v.velocity;
v3f primal_velocity = ent.v.velocity;
int numbumps = 4;
int blocked = 0;
Vector3[] planes = new Vector3[MAX_CLIP_PLANES];
int numplanes = 0;
float time_left = time;
for (int bumpcount = 0; bumpcount < numbumps; bumpcount++)
{
if (ent.v.velocity.IsEmpty)
{
break;
}
v3f end;
Mathlib.VectorMA(ref ent.v.origin, time_left, ref ent.v.velocity, out end);
trace_t trace = Move(ref ent.v.origin, ref ent.v.mins, ref ent.v.maxs, ref end, 0, ent);
if (trace.allsolid)
{ // entity is trapped in another solid
ent.v.velocity = default(v3f);
return(3);
}
if (trace.fraction > 0)
{ // actually covered some distance
Mathlib.Copy(ref trace.endpos, out ent.v.origin);
original_velocity = ent.v.velocity;
numplanes = 0;
}
if (trace.fraction == 1)
{
break; // moved the entire distance
}
if (trace.ent == null)
{
Sys.Error("SV_FlyMove: !trace.ent");
}
if (trace.plane.normal.Z > 0.7)
{
blocked |= 1; // floor
if (trace.ent.v.solid == Solids.SOLID_BSP)
{
ent.v.flags = (int)ent.v.flags | EdictFlags.FL_ONGROUND;
ent.v.groundentity = EdictToProg(trace.ent);
}
}
if (trace.plane.normal.Z == 0)
{
blocked |= 2; // step
if (steptrace != null)
{
steptrace.CopyFrom(trace); // save for player extrafriction
}
}
//
// run the impact function
//
Impact(ent, trace.ent);
if (ent.free)
{
break; // removed by the impact function
}
time_left -= time_left * trace.fraction;
// cliped to another plane
if (numplanes >= MAX_CLIP_PLANES)
{
// this shouldn't really happen
ent.v.velocity = default(v3f);
return(3);
}
planes[numplanes] = trace.plane.normal;
numplanes++;
//
// modify original_velocity so it parallels all of the clip planes
//
v3f new_velocity = default(v3f);
int i, j;
for (i = 0; i < numplanes; i++)
{
ClipVelocity(ref original_velocity, ref planes[i], out new_velocity, 1);
for (j = 0; j < numplanes; j++)
{
if (j != i)
{
float dot = new_velocity.x * planes[j].X + new_velocity.y * planes[j].Y + new_velocity.z * planes[j].Z;
if (dot < 0)
{
break; // not ok
}
}
}
if (j == numplanes)
{
break;
}
}
if (i != numplanes)
{
// go along this plane
ent.v.velocity = new_velocity;
}
else
{
// go along the crease
if (numplanes != 2)
{
ent.v.velocity = default(v3f);
return(7);
}
Vector3 dir = Vector3.Cross(planes[0], planes[1]);
float d = dir.X * ent.v.velocity.x + dir.Y * ent.v.velocity.y + dir.Z * ent.v.velocity.z;
Mathlib.Copy(ref dir, out ent.v.velocity);
Mathlib.VectorScale(ref ent.v.velocity, d, out ent.v.velocity);
}
//
// if original velocity is against the original velocity, stop dead
// to avoid tiny occilations in sloping corners
//
if (Mathlib.DotProduct(ref ent.v.velocity, ref primal_velocity) <= 0)
{
ent.v.velocity = default(v3f);
return(blocked);
}
}
return(blocked);
}
/// <summary>
/// SV_Physics_Client
/// Player character actions
/// </summary>
static void Physics_Client(edict_t ent, int num)
{
if (!svs.clients[num - 1].active)
{
return; // unconnected slot
}
//
// call standard client pre-think
//
Progs.GlobalStruct.time = (float)sv.time;
Progs.GlobalStruct.self = EdictToProg(ent);
Progs.Execute(Progs.GlobalStruct.PlayerPreThink);
//
// do a move
//
CheckVelocity(ent);
//
// decide which move function to call
//
switch ((int)ent.v.movetype)
{
case Movetypes.MOVETYPE_NONE:
if (!RunThink(ent))
{
return;
}
break;
case Movetypes.MOVETYPE_WALK:
if (!RunThink(ent))
{
return;
}
if (!CheckWater(ent) && ((int)ent.v.flags & EdictFlags.FL_WATERJUMP) == 0)
{
AddGravity(ent);
}
CheckStuck(ent);
WalkMove(ent);
break;
case Movetypes.MOVETYPE_TOSS:
case Movetypes.MOVETYPE_BOUNCE:
Physics_Toss(ent);
break;
case Movetypes.MOVETYPE_FLY:
if (!RunThink(ent))
{
return;
}
FlyMove(ent, (float)Host.FrameTime, null);
break;
case Movetypes.MOVETYPE_NOCLIP:
if (!RunThink(ent))
{
return;
}
Mathlib.VectorMA(ref ent.v.origin, (float)Host.FrameTime, ref ent.v.velocity, out ent.v.origin);
break;
default:
Sys.Error("SV_Physics_client: bad movetype {0}", (int)ent.v.movetype);
break;
}
//
// call standard player post-think
//
LinkEdict(ent, true);
Progs.GlobalStruct.time = (float)sv.time;
Progs.GlobalStruct.self = EdictToProg(ent);
Progs.Execute(Progs.GlobalStruct.PlayerPostThink);
}
/// <summary>
/// SV_Physics_Toss
/// Toss, bounce, and fly movement. When onground, do nothing.
/// </summary>
private static void Physics_Toss(edict_t ent)
{
// regular thinking
if (!RunThink(ent))
{
return;
}
// if onground, return without moving
if (((int)ent.v.flags & EdictFlags.FL_ONGROUND) != 0)
{
return;
}
CheckVelocity(ent);
// add gravity
if (ent.v.movetype != Movetypes.MOVETYPE_FLY && ent.v.movetype != Movetypes.MOVETYPE_FLYMISSILE)
{
AddGravity(ent);
}
// move angles
Mathlib.VectorMA(ref ent.v.angles, (float)Host.FrameTime, ref ent.v.avelocity, out ent.v.angles);
// move origin
v3f move;
Mathlib.VectorScale(ref ent.v.velocity, (float)Host.FrameTime, out move);
trace_t trace = PushEntity(ent, ref move);
if (trace.fraction == 1)
{
return;
}
if (ent.free)
{
return;
}
float backoff;
if (ent.v.movetype == Movetypes.MOVETYPE_BOUNCE)
{
backoff = 1.5f;
}
else
{
backoff = 1;
}
ClipVelocity(ref ent.v.velocity, ref trace.plane.normal, out ent.v.velocity, backoff);
// stop if on ground
if (trace.plane.normal.Z > 0.7f)
{
if (ent.v.velocity.z < 60 || ent.v.movetype != Movetypes.MOVETYPE_BOUNCE)
{
ent.v.flags = (int)ent.v.flags | EdictFlags.FL_ONGROUND;
ent.v.groundentity = EdictToProg(trace.ent);
ent.v.velocity = default(v3f);
ent.v.avelocity = default(v3f);
}
}
// check for in water
CheckWaterTransition(ent);
}
/// <summary>
/// SV_StartSound
/// Each entity can have eight independant sound sources, like voice,
/// weapon, feet, etc.
///
/// Channel 0 is an auto-allocate channel, the others override anything
/// allready running on that entity/channel pair.
///
/// An attenuation of 0 will play full volume everywhere in the level.
/// Larger attenuations will drop off. (max 4 attenuation)
/// </summary>
public static void StartSound(edict_t entity, int channel, string sample, int volume, float attenuation)
{
if (volume < 0 || volume > 255)
{
Sys.Error("SV_StartSound: volume = {0}", volume);
}
if (attenuation < 0 || attenuation > 4)
{
Sys.Error("SV_StartSound: attenuation = {0}", attenuation);
}
if (channel < 0 || channel > 7)
{
Sys.Error("SV_StartSound: channel = {0}", channel);
}
if (sv.datagram.Length > QDef.MAX_DATAGRAM - 16)
{
return;
}
// find precache number for sound
int sound_num;
for (sound_num = 1; sound_num < QDef.MAX_SOUNDS && sv.sound_precache[sound_num] != null; sound_num++)
{
if (sample == sv.sound_precache[sound_num])
{
break;
}
}
if (sound_num == QDef.MAX_SOUNDS || String.IsNullOrEmpty(sv.sound_precache[sound_num]))
{
Con.Print("SV_StartSound: {0} not precacheed\n", sample);
return;
}
int ent = NumForEdict(entity);
channel = (ent << 3) | channel;
int field_mask = 0;
if (volume != Sound.DEFAULT_SOUND_PACKET_VOLUME)
{
field_mask |= Protocol.SND_VOLUME;
}
if (attenuation != Sound.DEFAULT_SOUND_PACKET_ATTENUATION)
{
field_mask |= Protocol.SND_ATTENUATION;
}
// directed messages go only to the entity the are targeted on
sv.datagram.WriteByte(Protocol.svc_sound);
sv.datagram.WriteByte(field_mask);
if ((field_mask & Protocol.SND_VOLUME) != 0)
{
sv.datagram.WriteByte(volume);
}
if ((field_mask & Protocol.SND_ATTENUATION) != 0)
{
sv.datagram.WriteByte((int)(attenuation * 64));
}
sv.datagram.WriteShort(channel);
sv.datagram.WriteByte(sound_num);
v3f v;
Mathlib.VectorAdd(ref entity.v.mins, ref entity.v.maxs, out v);
Mathlib.VectorMA(ref entity.v.origin, 0.5f, ref v, out v);
sv.datagram.WriteCoord(v.x);
sv.datagram.WriteCoord(v.y);
sv.datagram.WriteCoord(v.z);
}
/*
* =============
* 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);
}
}
