1389 lines
27 KiB
Plaintext
1389 lines
27 KiB
Plaintext
/*
|
|
* Copyright (c) 2016-2024 Vera Visions LLC.
|
|
*
|
|
* Permission to use, copy, modify, and distribute this software for any
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
* copyright notice and this permission notice appear in all copies.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
* WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
|
|
* IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
|
|
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|
|
|
|
static bool
|
|
droptofloorwrapper(entity foo)
|
|
{
|
|
bool result;
|
|
entity old_self = self;
|
|
self = foo;
|
|
result = droptofloor();
|
|
self = old_self;
|
|
return result;
|
|
}
|
|
|
|
void
|
|
NSEntity::NSEntity(void)
|
|
{
|
|
identity = 1;
|
|
m_flSpawnTime = time;
|
|
m_vecEditorColor = [1,1,1];
|
|
}
|
|
|
|
void
|
|
NSEntity::Spawned(void)
|
|
{
|
|
super::Spawned();
|
|
|
|
m_oldAngle = angles;
|
|
m_oldOrigin = origin;
|
|
m_oldModel = Util_FixModel(model);
|
|
m_oldSolid = solid;
|
|
|
|
#ifdef SERVER
|
|
m_oldstrTarget = target;
|
|
|
|
if (m_oldModel && m_oldModel != "") {
|
|
precache_model(GetSpawnModel());
|
|
}
|
|
|
|
if (m_strOnTrigger) {
|
|
m_strOnTrigger = CreateOutput(m_strOnTrigger);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
float
|
|
NSEntity::EntIndex(void)
|
|
{
|
|
return (num_for_edict(this));
|
|
}
|
|
|
|
bool
|
|
NSEntity::DropToFloor(void)
|
|
{
|
|
return droptofloorwrapper(this);
|
|
}
|
|
|
|
vector
|
|
NSEntity::GetForward(void)
|
|
{
|
|
return anglesToForward(angles);
|
|
}
|
|
|
|
vector
|
|
NSEntity::GetRight(void)
|
|
{
|
|
return anglesToRight(angles);
|
|
}
|
|
|
|
vector
|
|
NSEntity::GetUp(void)
|
|
{
|
|
return anglesToUp(angles);
|
|
}
|
|
|
|
vector
|
|
NSEntity::WorldSpaceCenter(void)
|
|
{
|
|
return (absmin + (0.5 * (absmax - absmin)));
|
|
}
|
|
|
|
float
|
|
NSEntity::WaterLevel(void)
|
|
{
|
|
return (waterlevel);
|
|
}
|
|
|
|
bool
|
|
NSEntity::VisibleVec(vector org)
|
|
{
|
|
vector flDelta;
|
|
float flFoV;
|
|
|
|
flDelta = vectorNormalize(org - origin);
|
|
flFoV = flDelta * GetForward();
|
|
|
|
if (flFoV > 0.3f) {
|
|
traceline(origin, org, TRUE, this);
|
|
if (trace_fraction == 1.0f) {
|
|
return (true);
|
|
}
|
|
}
|
|
return (false);
|
|
}
|
|
|
|
bool
|
|
NSEntity::Visible(entity ent)
|
|
{
|
|
/* is it in our field of view? */
|
|
if (DistanceFromYaw(ent.origin) > 0.3f) {
|
|
traceline(origin, ent.origin, MOVE_NORMAL, this);
|
|
|
|
if (trace_fraction == 1.0f || trace_ent == ent) {
|
|
print(sprintf("%s can see %s\n", classname, ent.classname));
|
|
return (true);
|
|
}
|
|
}
|
|
|
|
print(sprintf("%s can not see %s\n", classname, ent.classname));
|
|
return (false);
|
|
}
|
|
|
|
float
|
|
NSEntity::DistanceFromYaw(vector targetPos)
|
|
{
|
|
return vectorNormalize(targetPos - origin) * GetForward();
|
|
}
|
|
|
|
bool
|
|
NSEntity::HasSpawnFlags(float sf)
|
|
{
|
|
return (spawnflags & sf) ? (true) : (false);
|
|
}
|
|
|
|
bool
|
|
NSEntity::IsOnGround(void)
|
|
{
|
|
return (flags & FL_ONGROUND) ? (true) : (false);
|
|
}
|
|
|
|
bool
|
|
NSEntity::IsSolid(void)
|
|
{
|
|
return (solid != SOLID_NOT) ? (true) : (false);
|
|
}
|
|
|
|
entity
|
|
NSEntity::GetGroundEntity(void)
|
|
{
|
|
return (groundentity);
|
|
}
|
|
|
|
bool
|
|
NSEntity::CreatedByMap(void)
|
|
{
|
|
return (_mapspawned);
|
|
}
|
|
|
|
#ifdef CLIENT
|
|
void
|
|
NSEntity::RendererRestarted(void)
|
|
{
|
|
|
|
}
|
|
|
|
void
|
|
NSEntity::ReceiveEntity(float flNew, float flChanged)
|
|
{
|
|
READENTITY_COORD(origin[0], BASEFL_CHANGED_ORIGIN_X)
|
|
READENTITY_COORD(origin[1], BASEFL_CHANGED_ORIGIN_Y)
|
|
READENTITY_COORD(origin[2], BASEFL_CHANGED_ORIGIN_Z)
|
|
READENTITY_ANGLE(angles[0], BASEFL_CHANGED_ANGLES_X)
|
|
READENTITY_ANGLE(angles[1], BASEFL_CHANGED_ANGLES_Y)
|
|
READENTITY_ANGLE(angles[2], BASEFL_CHANGED_ANGLES_Z)
|
|
READENTITY_SHORT(modelindex, BASEFL_CHANGED_MODELINDEX)
|
|
READENTITY_BYTE(solid, BASEFL_CHANGED_SOLID)
|
|
READENTITY_BYTE(movetype, BASEFL_CHANGED_FLAGS)
|
|
READENTITY_INT(flags, BASEFL_CHANGED_FLAGS)
|
|
READENTITY_INT(vv_flags, BASEFL_CHANGED_FLAGS)
|
|
READENTITY_COORD(mins[0], BASEFL_CHANGED_SIZE)
|
|
READENTITY_COORD(mins[1], BASEFL_CHANGED_SIZE)
|
|
READENTITY_COORD(mins[2], BASEFL_CHANGED_SIZE)
|
|
READENTITY_COORD(maxs[0], BASEFL_CHANGED_SIZE)
|
|
READENTITY_COORD(maxs[1], BASEFL_CHANGED_SIZE)
|
|
READENTITY_COORD(maxs[2], BASEFL_CHANGED_SIZE)
|
|
READENTITY_BYTE(frame, BASEFL_CHANGED_FRAME)
|
|
READENTITY_FLOAT(skin, BASEFL_CHANGED_SKIN)
|
|
READENTITY_FLOAT(effects, BASEFL_CHANGED_EFFECTS)
|
|
READENTITY_FLOAT(scale, BASEFL_CHANGED_SCALE)
|
|
READENTITY_COORD(velocity[0], BASEFL_CHANGED_VELOCITY_X)
|
|
READENTITY_COORD(velocity[1], BASEFL_CHANGED_VELOCITY_Y)
|
|
READENTITY_COORD(velocity[2], BASEFL_CHANGED_VELOCITY_Z)
|
|
READENTITY_COORD(avelocity[0], BASEFL_CHANGED_ANGULARVELOCITY)
|
|
READENTITY_COORD(avelocity[1], BASEFL_CHANGED_ANGULARVELOCITY)
|
|
READENTITY_COORD(avelocity[2], BASEFL_CHANGED_ANGULARVELOCITY)
|
|
|
|
drawmask = (modelindex != 0) ? MASK_ENGINE : 0;
|
|
|
|
if (scale == 0.0f)
|
|
scale = 1.0f;
|
|
|
|
if (flChanged & BASEFL_CHANGED_SIZE)
|
|
setsize(this, mins, maxs);
|
|
}
|
|
|
|
void
|
|
NSEntity::postdraw(void)
|
|
{
|
|
}
|
|
|
|
|
|
#else
|
|
void
|
|
NSEntity::DebugDraw(void)
|
|
{
|
|
DebugBox(GetOrigin(), GetMins(), GetMaxs(), m_vecEditorColor, 0.75f);
|
|
}
|
|
|
|
/* Make sure StartFrame calls this */
|
|
float
|
|
NSEntity::SendEntity(entity ePEnt, float flChanged)
|
|
{
|
|
if (!modelindex)
|
|
return (0);
|
|
|
|
if (clienttype(ePEnt) != CLIENTTYPE_REAL)
|
|
return (0);
|
|
|
|
if (alpha == 0.0f)
|
|
return (0);
|
|
|
|
WriteByte(MSG_ENTITY, ENT_ENTITY);
|
|
|
|
/* optimisation */
|
|
{
|
|
/* we'll never network these if we aren't moving. */
|
|
if (movetype == MOVETYPE_NONE) {
|
|
flChanged &= ~BASEFL_CHANGED_VELOCITY_X;
|
|
flChanged &= ~BASEFL_CHANGED_VELOCITY_Y;
|
|
flChanged &= ~BASEFL_CHANGED_VELOCITY_Z;
|
|
flChanged &= ~BASEFL_CHANGED_ANGULARVELOCITY;
|
|
}
|
|
|
|
if (m_bIsBrush == true) {
|
|
flChanged &= ~BASEFL_CHANGED_FLAGS;
|
|
flChanged &= ~BASEFL_CHANGED_SCALE;
|
|
}
|
|
}
|
|
|
|
/* broadcast how much data is expected to be read */
|
|
WriteFloat(MSG_ENTITY, flChanged);
|
|
|
|
SENDENTITY_COORD(origin[0], BASEFL_CHANGED_ORIGIN_X)
|
|
SENDENTITY_COORD(origin[1], BASEFL_CHANGED_ORIGIN_Y)
|
|
SENDENTITY_COORD(origin[2], BASEFL_CHANGED_ORIGIN_Z)
|
|
SENDENTITY_ANGLE(angles[0], BASEFL_CHANGED_ANGLES_X)
|
|
SENDENTITY_ANGLE(angles[1], BASEFL_CHANGED_ANGLES_Y)
|
|
SENDENTITY_ANGLE(angles[2], BASEFL_CHANGED_ANGLES_Z)
|
|
SENDENTITY_SHORT(modelindex, BASEFL_CHANGED_MODELINDEX)
|
|
SENDENTITY_BYTE(solid, BASEFL_CHANGED_SOLID)
|
|
SENDENTITY_BYTE(movetype, BASEFL_CHANGED_FLAGS)
|
|
SENDENTITY_INT(flags, BASEFL_CHANGED_FLAGS)
|
|
SENDENTITY_INT(vv_flags, BASEFL_CHANGED_FLAGS)
|
|
SENDENTITY_COORD(mins[0], BASEFL_CHANGED_SIZE)
|
|
SENDENTITY_COORD(mins[1], BASEFL_CHANGED_SIZE)
|
|
SENDENTITY_COORD(mins[2], BASEFL_CHANGED_SIZE)
|
|
SENDENTITY_COORD(maxs[0], BASEFL_CHANGED_SIZE)
|
|
SENDENTITY_COORD(maxs[1], BASEFL_CHANGED_SIZE)
|
|
SENDENTITY_COORD(maxs[2], BASEFL_CHANGED_SIZE)
|
|
SENDENTITY_BYTE(frame, BASEFL_CHANGED_FRAME)
|
|
SENDENTITY_FLOAT(skin, BASEFL_CHANGED_SKIN)
|
|
SENDENTITY_FLOAT(effects, BASEFL_CHANGED_EFFECTS)
|
|
SENDENTITY_FLOAT(scale, BASEFL_CHANGED_SCALE)
|
|
SENDENTITY_COORD(velocity[0], BASEFL_CHANGED_VELOCITY_X)
|
|
SENDENTITY_COORD(velocity[1], BASEFL_CHANGED_VELOCITY_Y)
|
|
SENDENTITY_COORD(velocity[2], BASEFL_CHANGED_VELOCITY_Z)
|
|
SENDENTITY_COORD(avelocity[0], BASEFL_CHANGED_ANGULARVELOCITY)
|
|
SENDENTITY_COORD(avelocity[1], BASEFL_CHANGED_ANGULARVELOCITY)
|
|
SENDENTITY_COORD(avelocity[2], BASEFL_CHANGED_ANGULARVELOCITY)
|
|
return (1);
|
|
}
|
|
|
|
void
|
|
NSEntity::EvaluateEntity(void)
|
|
{
|
|
EVALUATE_VECTOR(origin, 0, BASEFL_CHANGED_ORIGIN_X)
|
|
EVALUATE_VECTOR(origin, 1, BASEFL_CHANGED_ORIGIN_Y)
|
|
EVALUATE_VECTOR(origin, 2, BASEFL_CHANGED_ORIGIN_Z)
|
|
EVALUATE_VECTOR(angles, 0, BASEFL_CHANGED_ANGLES_X)
|
|
EVALUATE_VECTOR(angles, 1, BASEFL_CHANGED_ANGLES_Y)
|
|
EVALUATE_VECTOR(angles, 2, BASEFL_CHANGED_ANGLES_Z)
|
|
EVALUATE_FIELD(modelindex, BASEFL_CHANGED_MODELINDEX)
|
|
EVALUATE_FIELD(solid, BASEFL_CHANGED_SOLID)
|
|
EVALUATE_FIELD(movetype, BASEFL_CHANGED_FLAGS)
|
|
EVALUATE_FIELD(flags, BASEFL_CHANGED_FLAGS)
|
|
EVALUATE_FIELD(vv_flags, BASEFL_CHANGED_FLAGS)
|
|
EVALUATE_VECTOR(mins, 0, BASEFL_CHANGED_SIZE)
|
|
EVALUATE_VECTOR(mins, 1, BASEFL_CHANGED_SIZE)
|
|
EVALUATE_VECTOR(mins, 2, BASEFL_CHANGED_SIZE)
|
|
EVALUATE_VECTOR(maxs, 0, BASEFL_CHANGED_SIZE)
|
|
EVALUATE_VECTOR(maxs, 1, BASEFL_CHANGED_SIZE)
|
|
EVALUATE_VECTOR(maxs, 2, BASEFL_CHANGED_SIZE)
|
|
EVALUATE_FIELD(frame, BASEFL_CHANGED_FRAME)
|
|
EVALUATE_FIELD(skin, BASEFL_CHANGED_SKIN)
|
|
EVALUATE_FIELD(effects, BASEFL_CHANGED_EFFECTS)
|
|
EVALUATE_FIELD(scale, BASEFL_CHANGED_SCALE)
|
|
EVALUATE_VECTOR(velocity, 0, BASEFL_CHANGED_VELOCITY_X)
|
|
EVALUATE_VECTOR(velocity, 1, BASEFL_CHANGED_VELOCITY_Y)
|
|
EVALUATE_VECTOR(velocity, 2, BASEFL_CHANGED_VELOCITY_Z)
|
|
EVALUATE_VECTOR(avelocity, 0, BASEFL_CHANGED_ANGULARVELOCITY)
|
|
EVALUATE_VECTOR(avelocity, 1, BASEFL_CHANGED_ANGULARVELOCITY)
|
|
EVALUATE_VECTOR(avelocity, 2, BASEFL_CHANGED_ANGULARVELOCITY)
|
|
}
|
|
|
|
/* Make sure StartFrame calls this */
|
|
void
|
|
NSEntity::ParentUpdate(void)
|
|
{
|
|
EvaluateEntity();
|
|
|
|
frame1time += frametime;
|
|
|
|
/* handle end-touch */
|
|
if (m_beingTouched == true)
|
|
if (m_flTouchTime < GetTime()) {
|
|
EndTouch(m_eTouchLast);
|
|
m_beingTouched = false;
|
|
m_eTouchLast = __NULL__;
|
|
}
|
|
}
|
|
|
|
entity
|
|
NSEntity::GetParent(void)
|
|
{
|
|
return tag_entity;
|
|
}
|
|
|
|
void
|
|
NSEntity::SetParent(string name)
|
|
{
|
|
tag_entity = find(world, ::targetname, m_parent);
|
|
}
|
|
|
|
void
|
|
NSEntity::SetParentAttachment(string name)
|
|
{
|
|
if (name != "origin") {
|
|
tag_index = gettagindex(tag_entity, name);
|
|
} else {
|
|
tag_index = 0;
|
|
}
|
|
}
|
|
|
|
void
|
|
NSEntity::ClearParent(void)
|
|
{
|
|
tag_entity = world;
|
|
tag_index = 0;
|
|
}
|
|
|
|
void
|
|
NSEntity::RestoreAngles(void)
|
|
{
|
|
angles = GetSpawnAngles();
|
|
}
|
|
|
|
void
|
|
NSEntity::ClearAngles(void)
|
|
{
|
|
angles = [0, 0, 0];
|
|
}
|
|
|
|
void
|
|
NSEntity::ForceNetworkUpdate(void)
|
|
{
|
|
SendFlags = -1;
|
|
}
|
|
|
|
void
|
|
NSEntity::UseBy(entity ourActivator)
|
|
{
|
|
if (PlayerUse) {
|
|
eActivator = (NSEntity)ourActivator;
|
|
PlayerUse();
|
|
}
|
|
}
|
|
#endif
|
|
|
|
void
|
|
NSEntity::SetEffects(float newEffects)
|
|
{
|
|
effects = newEffects;
|
|
}
|
|
|
|
void
|
|
NSEntity::SetFrame(float newFrame)
|
|
{
|
|
if (newFrame == frame)
|
|
return;
|
|
|
|
frame = newFrame;
|
|
frame1time = 0.0f;
|
|
|
|
|
|
#ifdef SERVER
|
|
/* check if an event callback exists */
|
|
{
|
|
int eDefEvents;
|
|
string ourName;
|
|
|
|
if (modelframecount(modelindex) > 0) {
|
|
ourName = frametoname(modelindex, frame);
|
|
} else {
|
|
return;
|
|
}
|
|
|
|
eDefEvents = tokenize(m_strModelEventCB);
|
|
|
|
for (int i = 0; i < eDefEvents; i+=3) {
|
|
string testName = argv(i+0);
|
|
string testInput = argv(i+1);
|
|
string testData = argv(i+2);
|
|
|
|
if (ourName == testName) {
|
|
if (testData != "")
|
|
Input(this, testInput, testData);
|
|
else
|
|
Input(this, testInput, ""); /* no parms passed. */
|
|
|
|
tokenize(m_strModelEventCB); /* ensure argv() is 'rewound'... */
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void
|
|
NSEntity::SetSkin(float newSkin)
|
|
{
|
|
skin = newSkin;
|
|
}
|
|
|
|
void
|
|
NSEntity::SetOwner(entity newOwner)
|
|
{
|
|
owner = newOwner;
|
|
}
|
|
|
|
void
|
|
NSEntity::SetVelocity(vector vecNew)
|
|
{
|
|
velocity = vecNew;
|
|
}
|
|
|
|
void
|
|
NSEntity::SetTouch(void ()newTouch)
|
|
{
|
|
touch = newTouch;
|
|
}
|
|
|
|
/* we want to really use those set functions because they'll notify of any
|
|
* networking related changes. otherwise we'll have to keep track of copies
|
|
* that get updated every frame */
|
|
void
|
|
NSEntity::SetSendFlags(float flSendFlags)
|
|
{
|
|
#ifdef SERVER
|
|
SendFlags |= flSendFlags;
|
|
#endif
|
|
}
|
|
|
|
void
|
|
NSEntity::SetMovetype(float newMovetype)
|
|
{
|
|
movetype = newMovetype;
|
|
}
|
|
|
|
void
|
|
NSEntity::SetGravity(float newGrav)
|
|
{
|
|
gravity = newGrav;
|
|
}
|
|
|
|
void
|
|
NSEntity::SetSolid(float newSolid)
|
|
{
|
|
solid = newSolid;
|
|
}
|
|
|
|
void
|
|
NSEntity::SetScale(float newScale)
|
|
{
|
|
if (newScale == scale)
|
|
return;
|
|
|
|
scale = newScale;
|
|
setsize(this, m_vecMins * scale, m_vecMaxs * scale);
|
|
}
|
|
|
|
void
|
|
NSEntity::UpdateBounds(void)
|
|
{
|
|
vector newMins, newMaxs;
|
|
float flScale = 1.0f;
|
|
|
|
newMins = m_vecMins;
|
|
newMaxs = m_vecMaxs;
|
|
|
|
/* avoid useless computation */
|
|
if (angles !=[0, 0, 0]) {
|
|
/* adjust bbox according to rotation */
|
|
vector vecCorner[8];
|
|
|
|
newMins = newMaxs =[0, 0, 0];
|
|
for (int i = 0; i < 8; i++) {
|
|
vecCorner[i][0] = (i & 1) ? m_vecMins[0] : m_vecMaxs[0];
|
|
vecCorner[i][1] = (i & 2) ? m_vecMins[1] : m_vecMaxs[1];
|
|
vecCorner[i][2] = (i & 4) ? m_vecMins[2] : m_vecMaxs[2];
|
|
vecCorner[i] += origin;
|
|
vecCorner[i] = rotateAroundPoint(vecCorner[i], origin, angles[1]);
|
|
vecCorner[i] -= origin;
|
|
|
|
if (!(vecCorner[i][0] <= newMaxs[0]))
|
|
newMaxs[0] = vecCorner[i][0];
|
|
if (!(vecCorner[i][1] <= newMaxs[1]))
|
|
newMaxs[1] = vecCorner[i][1];
|
|
if (!(vecCorner[i][2] <= newMaxs[2]))
|
|
newMaxs[2] = vecCorner[i][2];
|
|
|
|
if (!(vecCorner[i][0] >= newMins[0]))
|
|
newMins[0] = vecCorner[i][0];
|
|
if (!(vecCorner[i][1] >= newMins[1]))
|
|
newMins[1] = vecCorner[i][1];
|
|
if (!(vecCorner[i][2] >= newMins[2]))
|
|
newMins[2] = vecCorner[i][2];
|
|
}
|
|
}
|
|
|
|
/* 0.0 is never valid, if you want it to disappear do something else */
|
|
if (scale != 0.0)
|
|
flScale = scale;
|
|
|
|
setsize(this, newMins * flScale, newMaxs * flScale);
|
|
}
|
|
|
|
void
|
|
NSEntity::SetAngles(vector newAngles)
|
|
{
|
|
angles = newAngles;
|
|
}
|
|
|
|
void
|
|
NSEntity::SetAngularVelocity(vector newAvel)
|
|
{
|
|
avelocity = newAvel;
|
|
}
|
|
|
|
void
|
|
NSEntity::SetSize(vector newMins, vector newMaxs)
|
|
{
|
|
float flScale = 1.0f;
|
|
|
|
m_vecMins = newMins;
|
|
m_vecMaxs = newMaxs;
|
|
|
|
/* 0.0 is never valid, if you want it to disappear do something else */
|
|
if (scale != 0.0f)
|
|
flScale = scale;
|
|
|
|
setsize(this, newMins * flScale, newMaxs * flScale);
|
|
}
|
|
|
|
void
|
|
NSEntity::SetOrigin(vector newOrigin) {
|
|
setorigin(this, newOrigin);
|
|
}
|
|
|
|
void
|
|
NSEntity::SetModel(string newModel) {
|
|
m_bIsBrush = substring(newModel, 0, 1) == "*" ? true : false;
|
|
model = newModel;
|
|
setmodel(this, newModel);
|
|
|
|
/* mins/maxs have been updated by setmodel */
|
|
SetSize(mins, maxs);
|
|
}
|
|
void
|
|
NSEntity::SetModelindex(float newModelIndex) {
|
|
if (newModelIndex == modelindex)
|
|
return;
|
|
|
|
modelindex = newModelIndex;
|
|
SetSize(mins, maxs);
|
|
|
|
}
|
|
|
|
void
|
|
NSEntity::AddAngularVelocity(vector addVel)
|
|
{
|
|
avelocity += addVel;
|
|
}
|
|
|
|
void
|
|
NSEntity::AddVelocity(vector addVel)
|
|
{
|
|
velocity += addVel;
|
|
}
|
|
|
|
void
|
|
NSEntity::AddEffects(float fl) {
|
|
effects |= fl;
|
|
}
|
|
|
|
void
|
|
NSEntity::RemoveEffects(float fl) {
|
|
effects &= ~fl;
|
|
}
|
|
|
|
|
|
void
|
|
NSEntity::AddFlags(float fl) {
|
|
flags |= fl;
|
|
}
|
|
|
|
void
|
|
NSEntity::RemoveFlags(float fl) {
|
|
flags &= ~fl;
|
|
}
|
|
|
|
|
|
void
|
|
NSEntity::AddVFlags(float fl) {
|
|
vv_flags |= fl;
|
|
}
|
|
|
|
void
|
|
NSEntity::RemoveVFlags(float fl) {
|
|
vv_flags &= ~fl;
|
|
}
|
|
|
|
void
|
|
NSEntity::TurnTo(float targetAngle) {
|
|
angles[1] = targetAngle;
|
|
}
|
|
|
|
void
|
|
NSEntity::TurnToPos(vector targetPos) {
|
|
angles = vectorToAngles(targetPos - WorldSpaceCenter());
|
|
}
|
|
|
|
void
|
|
NSEntity::SetThink(void (void) func) {
|
|
think = func;
|
|
}
|
|
|
|
void
|
|
NSEntity::SetNextThink(float fl) {
|
|
float flTime = GetTime() + fl;
|
|
|
|
/* HACK: to make sure things happen post-spawn */
|
|
if (flTime == 0.0f)
|
|
flTime = 0.001f;
|
|
|
|
if (flTime >= 0)
|
|
nextthink = flTime;
|
|
else
|
|
EntError("%s sets bogus nextthink value %f", classname, flTime);
|
|
}
|
|
|
|
void
|
|
NSEntity::ScheduleThink(void (void) func, float fl) {
|
|
SetThink(func);
|
|
SetNextThink(fl);
|
|
}
|
|
|
|
vector
|
|
NSEntity::GetSpawnOrigin(void) {
|
|
return (m_oldOrigin);
|
|
}
|
|
|
|
vector
|
|
NSEntity::GetSpawnAngles(void) {
|
|
return (m_oldAngle);
|
|
}
|
|
|
|
string
|
|
NSEntity::GetSpawnModel(void) {
|
|
return (m_oldModel);
|
|
}
|
|
|
|
float
|
|
NSEntity::GetEffects(void) {
|
|
return (effects);
|
|
}
|
|
|
|
float
|
|
NSEntity::GetFrame(void) {
|
|
return (frame);
|
|
}
|
|
|
|
float
|
|
NSEntity::GetSkin(void) {
|
|
return (skin);
|
|
}
|
|
|
|
float
|
|
NSEntity::GetScale(void) {
|
|
return (scale);
|
|
}
|
|
|
|
entity
|
|
NSEntity::GetOwner(void) {
|
|
return (owner);
|
|
}
|
|
|
|
vector
|
|
NSEntity::GetVelocity(void) {
|
|
return (velocity);
|
|
}
|
|
|
|
float
|
|
NSEntity::GetSolid(void) {
|
|
return (solid);
|
|
}
|
|
|
|
string
|
|
NSEntity::GetModel(void)
|
|
{
|
|
return (model);
|
|
}
|
|
|
|
float
|
|
NSEntity::GetModelindex(void)
|
|
{
|
|
return (modelindex);
|
|
}
|
|
|
|
float
|
|
NSEntity::GetMovetype(void)
|
|
{
|
|
return (movetype);
|
|
}
|
|
|
|
float
|
|
NSEntity::GetGravity(void)
|
|
{
|
|
return (gravity);
|
|
}
|
|
|
|
vector
|
|
NSEntity::GetAngles(void)
|
|
{
|
|
return (angles);
|
|
}
|
|
|
|
vector
|
|
NSEntity::GetAngularVelocity(void)
|
|
{
|
|
return (avelocity);
|
|
}
|
|
|
|
vector
|
|
NSEntity::GetOrigin(void)
|
|
{
|
|
return (origin);
|
|
}
|
|
|
|
vector
|
|
NSEntity::GetMins(void)
|
|
{
|
|
return (mins);
|
|
}
|
|
|
|
vector
|
|
NSEntity::GetMaxs(void)
|
|
{
|
|
return (maxs);
|
|
}
|
|
|
|
vector
|
|
NSEntity::GetRealMins(void)
|
|
{
|
|
return (m_vecMins);
|
|
}
|
|
|
|
vector
|
|
NSEntity::GetRealMaxs(void)
|
|
{
|
|
return (m_vecMaxs);
|
|
}
|
|
|
|
vector
|
|
NSEntity::GetAbsoluteMins(void)
|
|
{
|
|
return (absmin);
|
|
}
|
|
|
|
vector
|
|
NSEntity::GetAbsoluteMaxs(void)
|
|
{
|
|
return (absmax);
|
|
}
|
|
|
|
float
|
|
NSEntity::GetFlags(void)
|
|
{
|
|
return (flags);
|
|
}
|
|
|
|
float
|
|
NSEntity::GetVFlags(void)
|
|
{
|
|
return (vv_flags);
|
|
}
|
|
|
|
bool
|
|
NSEntity::HasFlags(float bits)
|
|
{
|
|
return (flags & bits) ? (true) : (false);
|
|
}
|
|
|
|
bool
|
|
NSEntity::HasVFlags(float bits)
|
|
{
|
|
return (vv_flags & bits) ? (true) : (false);
|
|
}
|
|
|
|
float
|
|
NSEntity::GetNextThinkTime(void)
|
|
{
|
|
return (nextthink);
|
|
}
|
|
|
|
bool
|
|
NSEntity::IsThinking(void)
|
|
{
|
|
return (nextthink > GetTime()) ? (true) : (false);
|
|
}
|
|
|
|
void
|
|
NSEntity::ReleaseThink(void)
|
|
{
|
|
think = __NULL__;
|
|
nextthink = 0.0f;
|
|
}
|
|
|
|
void
|
|
NSEntity::ThinkBusy(float busyTime)
|
|
{
|
|
static void ThinkBusy_Done(void) {
|
|
/* Guess we're done here... */
|
|
}
|
|
ScheduleThink(ThinkBusy_Done, busyTime);
|
|
}
|
|
|
|
void
|
|
NSEntity::ClearVelocity(void)
|
|
{
|
|
velocity = avelocity = [0.0f, 0.0f, 0.0f];
|
|
}
|
|
|
|
#ifdef SERVER
|
|
void
|
|
NSEntity::Respawn(void)
|
|
{
|
|
super::Respawn();
|
|
SetSolid(m_oldSolid);
|
|
SetAngles(GetSpawnAngles());
|
|
SetOrigin(GetSpawnOrigin());
|
|
SetModel(GetSpawnModel());
|
|
}
|
|
|
|
void
|
|
NSEntity::Save(float handle)
|
|
{
|
|
super::Save(handle);
|
|
SaveEntity(handle, "tag_entity", tag_entity);
|
|
SaveFloat(handle, "tag_index", tag_index);
|
|
SaveFloat(handle, "pvsflags", pvsflags);
|
|
SaveBool(handle, "_mapspawned", _mapspawned);
|
|
SaveFloat(handle, "scale", scale);
|
|
SaveFloat(handle, "vv_flags", vv_flags);
|
|
SaveFloat(handle, "friction", friction);
|
|
SaveVector(handle, "m_vecMins", m_vecMins);
|
|
SaveVector(handle, "m_vecMaxs", m_vecMaxs);
|
|
SaveVector(handle, "m_oldOrigin", m_oldOrigin);
|
|
SaveVector(handle, "m_oldAngle", m_oldAngle);
|
|
SaveString(handle, "m_oldModel", m_oldModel);
|
|
SaveFloat(handle, "m_oldSolid", m_oldSolid);
|
|
SaveFloat(handle, "m_flTouchTime", m_flTouchTime);
|
|
SaveBool(handle, "m_beingTouched", m_beingTouched);
|
|
SaveEntity(handle, "m_eTouchLast", m_eTouchLast);
|
|
SaveVector(handle, "m_vecEditorColor", m_vecEditorColor);
|
|
}
|
|
|
|
void
|
|
NSEntity::Restore(string strKey, string strValue)
|
|
{
|
|
switch (strKey) {
|
|
case "tag_entity":
|
|
tag_entity = ReadEntity(strValue);
|
|
break;
|
|
case "tag_index":
|
|
tag_index = ReadFloat(strValue);
|
|
break;
|
|
case "pvsflags":
|
|
pvsflags = ReadFloat(strValue);
|
|
break;
|
|
case "_mapspawned":
|
|
_mapspawned = ReadBool(strValue);
|
|
break;
|
|
case "scale":
|
|
scale = ReadFloat(strValue);
|
|
break;
|
|
case "vv_flags":
|
|
vv_flags = ReadFloat(strValue);
|
|
break;
|
|
case "friction":
|
|
friction = ReadFloat(strValue);
|
|
break;
|
|
case "m_vecMins":
|
|
m_vecMins = ReadVector(strValue);
|
|
break;
|
|
case "m_vecMaxs":
|
|
m_vecMaxs = ReadVector(strValue);
|
|
break;
|
|
case "m_oldOrigin":
|
|
m_oldOrigin = ReadVector(strValue);
|
|
break;
|
|
case "m_oldAngle":
|
|
m_oldAngle = ReadVector(strValue);
|
|
break;
|
|
case "m_oldModel":
|
|
m_oldModel = ReadString(strValue);
|
|
break;
|
|
case "m_oldSolid":
|
|
m_oldSolid = ReadFloat(strValue);
|
|
break;
|
|
case "m_flTouchTime":
|
|
m_flTouchTime = ReadFloat(strValue);
|
|
break;
|
|
case "m_beingTouched":
|
|
m_beingTouched = ReadBool(strValue);
|
|
break;
|
|
case "m_eTouchLast":
|
|
m_eTouchLast = ReadEntity(strValue);
|
|
break;
|
|
case "m_vecEditorColor":
|
|
m_vecEditorColor = ReadVector(strValue);
|
|
break;
|
|
default:
|
|
super::Restore(strKey, strValue);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
NSEntity::Input(entity eAct, string strInput, string strData)
|
|
{
|
|
switch (strInput) {
|
|
case "Kill":
|
|
Destroy();
|
|
break;
|
|
case "KillHierarchy":
|
|
/* this works because ents are basically just entnums */
|
|
for (entity e = world; (e = findfloat(e, ::owner, this));) {
|
|
NSEntity ent = (NSEntity) e;
|
|
|
|
ent.Destroy();
|
|
}
|
|
Destroy();
|
|
break;
|
|
case "SetParent":
|
|
SetParent(strData);
|
|
break;
|
|
case "SetParentAttachment":
|
|
SetParentAttachment(strData);
|
|
break;
|
|
case "ClearParent":
|
|
ClearParent();
|
|
break;
|
|
case "Use":
|
|
eActivator = (NSEntity)eAct;
|
|
|
|
if (PlayerUse)
|
|
PlayerUse();
|
|
break;
|
|
case "SpawnDef":
|
|
break;
|
|
case "SpawnProjectileDef":
|
|
if (EntityDef_HasSpawnClass(strData)) {
|
|
NSProjectile_SpawnDefAttachment(strData, this, 0);
|
|
} else {
|
|
float rangedDmg = Skill_GetDefValue(EntityDef_GetKeyValue(strData, "damage"));
|
|
TraceAttack_FireBullets(1, origin + view_ofs, rangedDmg, [0.01,0.01], 0);
|
|
}
|
|
break;
|
|
case "StartSoundDef":
|
|
StartSoundDef(strData, CHAN_VOICE, true);
|
|
break;
|
|
case "AddVelocity":
|
|
vector velAdd = stov(strData);
|
|
velocity += GetForward() * velAdd[0];
|
|
velocity += GetRight() * velAdd[1];
|
|
velocity += GetUp() * velAdd[2];
|
|
break;
|
|
case "Shockwave":
|
|
int c = tokenize(strData);
|
|
|
|
WriteByte(MSG_MULTICAST, SVC_CGAMEPACKET);
|
|
WriteByte(MSG_MULTICAST, EV_BEAMCYLINDER);
|
|
WriteCoord(MSG_MULTICAST, origin[0]);
|
|
WriteCoord(MSG_MULTICAST, origin[1]);
|
|
WriteCoord(MSG_MULTICAST, origin[2]);
|
|
WriteCoord(MSG_MULTICAST, angles[0]);
|
|
WriteCoord(MSG_MULTICAST, stof(argv(1)));
|
|
WriteCoord(MSG_MULTICAST, angles[2]);
|
|
WriteShort(MSG_MULTICAST, getmodelindex(argv(0)));
|
|
WriteByte(MSG_MULTICAST, stof(argv(2)));
|
|
WriteByte(MSG_MULTICAST, stof(argv(3)));
|
|
WriteByte(MSG_MULTICAST, stof(argv(4)));
|
|
WriteByte(MSG_MULTICAST, stof(argv(5)));
|
|
WriteByte(MSG_MULTICAST, stof(argv(6)));
|
|
WriteByte(MSG_MULTICAST, stof(argv(7)));
|
|
WriteByte(MSG_MULTICAST, stof(argv(8)));
|
|
WriteByte(MSG_MULTICAST, stof(argv(9)));
|
|
WriteByte(MSG_MULTICAST, stof(argv(10)));
|
|
WriteByte(MSG_MULTICAST, stof(argv(11)));
|
|
|
|
msg_entity = this;
|
|
multicast(origin, MULTICAST_PVS);
|
|
break;
|
|
case "SetOrigin":
|
|
SetOrigin(stov(strData));
|
|
break;
|
|
case "SetSpawnOrigin":
|
|
m_oldOrigin = stov(strData);
|
|
break;
|
|
case "SetEditorColor":
|
|
m_vecEditorColor = ReadVector(strData);
|
|
break;
|
|
case "Respawn":
|
|
Respawn();
|
|
break;
|
|
default:
|
|
NSTrigger::Input(eAct, strInput, strData);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
void
|
|
NSEntity::SpawnKey(string strKey, string strValue)
|
|
{
|
|
bool tempCheck = false;
|
|
/* we do re-read a lot of the builtin fields in case we want to set
|
|
defaults. just in case anybody is wondering. */
|
|
switch (strKey) {
|
|
case "spawnflags":
|
|
spawnflags = ReadFloat(strValue);
|
|
break;
|
|
case "origin":
|
|
origin = ReadVector(strValue);
|
|
break;
|
|
case "model":
|
|
model = ReadString(strValue);
|
|
break;
|
|
case "angles":
|
|
angles = ReadVector(strValue);
|
|
break;
|
|
case "angle":
|
|
angles[1] = ReadFloat(strValue);
|
|
break;
|
|
case "solid":
|
|
solid = ReadFloat(strValue);
|
|
break;
|
|
case "friction":
|
|
friction = ReadFloat(strValue);
|
|
break;
|
|
case "editor_color":
|
|
m_vecEditorColor = ReadVector(strValue);
|
|
break;
|
|
#ifdef SERVER
|
|
case "health":
|
|
health = ReadFloat(strValue);
|
|
break;
|
|
case "movewith":
|
|
case "parentname":
|
|
SetParent(ReadString(strValue));
|
|
break;
|
|
case "ignorepvs":
|
|
tempCheck = ReadBool(strValue);
|
|
|
|
if (tempCheck == true)
|
|
pvsflags = PVSF_IGNOREPVS;
|
|
else
|
|
pvsflags &= ~PVSF_IGNOREPVS;
|
|
|
|
break;
|
|
#endif
|
|
case "editor_mins":
|
|
case "editor_maxs":
|
|
case "editor_usage":
|
|
case "editor_model":
|
|
case "_minlight":
|
|
break;
|
|
default:
|
|
super::SpawnKey(strKey, strValue);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
NSEntity::OnRemoveEntity(void)
|
|
{
|
|
}
|
|
|
|
void
|
|
NSEntity::Destroy(void)
|
|
{
|
|
removed = 1; /* mark this as cleanly removed */
|
|
OnRemoveEntity();
|
|
customphysics = __NULL__;
|
|
modelindex = 0;
|
|
solid = 0;
|
|
movetype = 0;
|
|
classname = 0;
|
|
ScheduleThink(Util_Destroy, 0.0f);
|
|
}
|
|
|
|
void
|
|
NSEntity::Show(void)
|
|
{
|
|
effects &= ~EF_NODRAW;
|
|
}
|
|
|
|
void
|
|
NSEntity::Hide(void)
|
|
{
|
|
effects |= EF_NODRAW;
|
|
}
|
|
|
|
bool
|
|
NSEntity::IsHidden(void)
|
|
{
|
|
return (effects & EF_NODRAW) ? true : false;
|
|
}
|
|
|
|
void
|
|
NSEntity::Disappear(void)
|
|
{
|
|
modelindex = (0);
|
|
SetSolid(SOLID_NOT);
|
|
}
|
|
|
|
void
|
|
NSEntity::MakeStatic(void)
|
|
{
|
|
makestatic(this);
|
|
}
|
|
|
|
bool
|
|
NSEntity::CanSpawn(bool clientSide)
|
|
{
|
|
return !(clientSide);
|
|
}
|
|
|
|
bool
|
|
NSEntity::WithinBounds(entity check)
|
|
{
|
|
if not (check.absmin[0] >= absmin[0] && check.absmax[0] <= absmax[0])
|
|
return (false);
|
|
if not (check.absmin[1] >= absmin[1] && check.absmax[1] <= absmax[1])
|
|
return (false);
|
|
if not (check.absmin[2] >= absmin[2] && check.absmax[2] <= absmax[2])
|
|
return (false);
|
|
|
|
return (true);
|
|
}
|
|
|
|
bool
|
|
NSEntity::IntersectsWith(entity check)
|
|
{
|
|
if not (check.origin[0] >= absmin[0] && check.origin[0] <= absmax[0])
|
|
return (false);
|
|
if not (check.origin[1] >= absmin[1] && check.origin[1] <= absmax[1])
|
|
return (false);
|
|
if not (check.origin[2] >= absmin[2] && check.origin[2] <= absmax[2])
|
|
return (false);
|
|
|
|
return (true);
|
|
}
|
|
|
|
bool
|
|
NSEntity::StartSound(string strSample, float channel, float flags, bool broadcast)
|
|
{
|
|
if not (whichpack(strcat("sound/", strSample)))
|
|
return (false);
|
|
|
|
if (broadcast) {
|
|
sound(this, channel, strSample, 1.0f, ATTN_NORM, 0, SOUNDFLAG_FOLLOW);
|
|
} else {
|
|
#ifdef SERVER
|
|
msg_entity = this;
|
|
sound(this, channel, strSample, 1.0f, ATTN_NORM, 0, SOUNDFLAG_UNICAST | SOUNDFLAG_FOLLOW);
|
|
msg_entity = __NULL__;
|
|
#else
|
|
sound(this, channel, strSample, 1.0f, ATTN_NORM, 0, SOUNDFLAG_FOLLOW);
|
|
#endif
|
|
}
|
|
|
|
SndEntLog("%s (chan: %d bcast: %d) (%v)", strSample, channel, broadcast, origin);
|
|
|
|
return (true);
|
|
}
|
|
|
|
bool
|
|
NSEntity::StartSoundDef(string strSample, float channel, bool broadcast)
|
|
{
|
|
SndEntLog("%s (chan: %d bcast: %d)", strSample, channel, broadcast);
|
|
Sound_Play(this, channel, strSample);
|
|
return (true);
|
|
}
|
|
|
|
void
|
|
NSEntity::StopSound(float channel, bool broadcast)
|
|
{
|
|
if (broadcast) {
|
|
Sound_Stop(this, channel);
|
|
} else {
|
|
#ifdef SERVER
|
|
msg_entity = this;
|
|
sound(this, channel, "common/null.wav", 1.0f, ATTN_NORM, 100, SOUNDFLAG_UNICAST | SOUNDFLAG_FOLLOW, 0 );
|
|
msg_entity = __NULL__;
|
|
#else
|
|
Sound_Stop(this, channel);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
vector
|
|
NSEntity::NearestWallPointForRadius(float radius)
|
|
{
|
|
vector vecRadius = [radius, radius, radius];
|
|
tracebox(origin, -vecRadius, vecRadius, origin, MOVE_EVERYTHING, this);
|
|
return (trace_fraction <= 1.0) ? trace_endpos : origin;
|
|
}
|
|
|
|
void
|
|
NSEntity::HandleThink(void)
|
|
{
|
|
/* support for think/nextthink */
|
|
if (think && nextthink > 0.0f) {
|
|
if (nextthink < time) {
|
|
nextthink = 0.0f;
|
|
think();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool
|
|
NSEntity::IsFacing(entity target)
|
|
{
|
|
vector vecDiff = vectorNormalize(target.origin - origin);
|
|
return ((vecDiff * GetForward()) > 0) ? true : false;
|
|
}
|
|
|
|
bool
|
|
NSEntity::IsFacingPosition(vector targetPos)
|
|
{
|
|
vector vecDiff = vectorNormalize(targetPos - origin);
|
|
return ((vecDiff * GetForward()) > 0) ? true : false;
|
|
}
|
|
|
|
float
|
|
NSEntity::GetSpawnAge(void)
|
|
{
|
|
return (time - m_flSpawnTime);
|
|
}
|
|
|
|
float
|
|
NSEntity::GetSpawnTime(void)
|
|
{
|
|
return (m_flSpawnTime);
|
|
}
|
|
|
|
void
|
|
NSEntity::Transport(vector new_pos, vector new_ang)
|
|
{
|
|
float flSpeed = length(this.GetVelocity());
|
|
SetVelocity(anglesToForward(new_ang) * flSpeed);
|
|
|
|
SetOrigin(new_pos);
|
|
SetAngles(new_ang);
|
|
|
|
#ifdef SERVER
|
|
if (flags & FL_CLIENT)
|
|
Client_FixAngle(this, new_ang);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
NSEntity::Relink(void)
|
|
{
|
|
setorigin(this, origin);
|
|
}
|
|
|
|
vector
|
|
NSEntity::GetNearbySpot(void)
|
|
{
|
|
vector testPos;
|
|
float minDist = maxs[0];
|
|
vector fwdDir, rightDir, upDir;
|
|
|
|
fwdDir = anglesToForward([0,0,0]);
|
|
rightDir = anglesToRight([0,0,0]);
|
|
upDir = anglesToUp([0,0,0]);
|
|
|
|
/* space in front? */
|
|
testPos = GetOrigin() + fwdDir * minDist;
|
|
tracebox(testPos, mins, maxs, testPos, MOVE_NORMAL, this);
|
|
|
|
if (trace_fraction == 1.0f)
|
|
return testPos;
|
|
|
|
/* behind? */
|
|
testPos = GetOrigin() - fwdDir * minDist;
|
|
tracebox(testPos, mins, maxs, testPos, MOVE_NORMAL, this);
|
|
|
|
if (trace_fraction == 1.0f)
|
|
return testPos;
|
|
|
|
/* left? */
|
|
testPos = GetOrigin() - rightDir * minDist;
|
|
tracebox(testPos, mins, maxs, testPos, MOVE_NORMAL, this);
|
|
|
|
if (trace_fraction == 1.0f)
|
|
return testPos;
|
|
|
|
/* right? */
|
|
testPos = GetOrigin() + rightDir * minDist;
|
|
tracebox(testPos, mins, maxs, testPos, MOVE_NORMAL, this);
|
|
|
|
if (trace_fraction == 1.0f)
|
|
return testPos;
|
|
|
|
/* front left? */
|
|
testPos = GetOrigin() + fwdDir * minDist - rightDir * minDist;
|
|
tracebox(testPos, mins, maxs, testPos, MOVE_NORMAL, this);
|
|
|
|
if (trace_fraction == 1.0f)
|
|
return testPos;
|
|
|
|
/* front right? */
|
|
testPos = GetOrigin() + fwdDir * minDist + rightDir * minDist;
|
|
tracebox(testPos, mins, maxs, testPos, MOVE_NORMAL, this);
|
|
|
|
if (trace_fraction == 1.0f)
|
|
return testPos;
|
|
|
|
/* back left? */
|
|
testPos = GetOrigin() - fwdDir * minDist - rightDir * minDist;
|
|
tracebox(testPos, mins, maxs, testPos, MOVE_NORMAL, this);
|
|
|
|
if (trace_fraction == 1.0f)
|
|
return testPos;
|
|
|
|
/* back right? */
|
|
testPos = GetOrigin() - fwdDir * minDist + rightDir * minDist;
|
|
tracebox(testPos, mins, maxs, testPos, MOVE_NORMAL, this);
|
|
|
|
if (trace_fraction == 1.0f)
|
|
return testPos;
|
|
|
|
return g_vec_null;
|
|
}
|