/*
======================
SV_StepDirection
Turns to the movement direction, and walks the current distance if
facing it.
======================
*/
qboolean SV_StepDirection (edict_t *ent, float yaw, float dist)
{
vec3_t move, oldorigin;
float delta;
ent->ideal_yaw = yaw;
M_ChangeYaw (ent);
yaw = yaw*M_PI*2 / 360;
move[0] = cos(yaw)*dist;
move[1] = sin(yaw)*dist;
move[2] = 0;
VectorCopy (ent->s.origin, oldorigin);
if (SV_movestep (ent, move, false))
{
delta = ent->s.angles[YAW] - ent->ideal_yaw;
if (delta > 45 && delta < 315)
{ // not turned far enough, so don't take the step
VectorCopy (oldorigin, ent->s.origin);
}
gi.linkentity (ent);
G_TouchTriggers (ent);
return true;
}
gi.linkentity (ent);
G_TouchTriggers (ent);
return false;
}
qboolean SV_StepDirection (edict_t *ent, float yaw, float dist)
{
vec3_t move, oldorigin;
float delta;
ent->v.ideal_yaw = yaw;
PF_changeyaw();
yaw = yaw*Q_PI*2 / 360;
move[0] = cosf(yaw)*dist;
move[1] = sinf(yaw)*dist;
move[2] = 0;
VectorCopy (ent->v.origin, oldorigin);
if (SV_movestep (ent, move, FALSE))
{
delta = ent->v.angles[YAW] - ent->v.ideal_yaw;
if (delta > 45 && delta < 315)
{ // not turned far enough, so don't take the step
VectorCopy (oldorigin, ent->v.origin);
}
SV_LinkEdict (ent, TRUE);
return TRUE;
}
SV_LinkEdict (ent, TRUE);
return FALSE;
}
qboolean SV_StepDirection (edict_t *ent, float yaw, float dist)
{
vec3_t move, oldorigin;
float delta;
qboolean set_trace_plane;
ent->v.ideal_yaw = yaw;
PF_changeyaw();
yaw = yaw*M_PI*2 / 360;
move[0] = cos(yaw)*dist;
move[1] = sin(yaw)*dist;
move[2] = 0;//FIXME: Make wallcrawlers and flying monsters use this!
VectorCopy (ent->v.origin, oldorigin);
if((int)ent->v.flags & FL_SET_TRACE)
set_trace_plane = true;
else
set_trace_plane = false;
if (SV_movestep (ent, move, false, false, set_trace_plane))
{
delta = ent->v.angles[YAW] - ent->v.ideal_yaw;
if (delta > 45 && delta < 315)
{ // not turned far enough, so don't take the step
VectorCopy (oldorigin, ent->v.origin);
}
SV_LinkEdict (ent, true);
return true;
}
SV_LinkEdict (ent, true);
return false;
}
/*
===============
M_walkmove
===============
*/
qboolean M_walkmove (edict_t *ent, float yaw, float dist)
{
vec3_t move;
qboolean rval;
// qboolean changezval = false;
if (ent->svflags & SVF_MONSTER && dist >= 28)
dist = 28;
// gi.dprintf ("%s: tried to move %5.2f\n", ent->classname, dist);
if (!ent->groundentity && !(ent->flags & (FL_FLY|FL_SWIM)))
return false;
yaw = yaw*M_PI*2 / 360;
move[0] = cos(yaw)*dist;
move[1] = sin(yaw)*dist;
move[2] = 0;
/*
if (ent->maxs[2] == DUCKING_MAX_Z)
{
ent->maxs[2] = 8;//4; // Ridah, as requested
changezval = true;
}
*/
rval = SV_movestep(ent, move, true);
/*
if (changezval)
{
ent->maxs[2] = DUCKING_MAX_Z;
}
*/
return rval;
}
qboolean SV_FlyDirection(edict_t *ent, vec3_t move) {
int ret;
ret = SV_movestep(ent, move, 0);
SV_LinkEdict(ent, 1);
return(ret);
}
/*
===============
M_walkmove
===============
*/
bool M_walkmove(edict_t *ent, float yaw, float dist)
{
vec3_t move;
if (!ent->groundentity && !(ent->flags & (FL_FLY | FL_SWIM)))
return false;
yaw = DEG2RAD(yaw);
move[0] = cos(yaw) * dist;
move[1] = sin(yaw) * dist;
move[2] = 0;
return SV_movestep(ent, move, true);
}
/*
===============
M_walkmove
===============
*/
qboolean M_walkmove (edict_t *ent, float yaw, float dist)
{
vec3_t move;
if (!ent->groundentity && !(ent->flags & (FL_FLY|FL_SWIM)))
return qfalse;
yaw = yaw*M_PI*2 / 360;
move[0] = cos(yaw)*dist;
move[1] = sin(yaw)*dist;
move[2] = 0;
return SV_movestep(ent, move, qtrue);
}
qboolean SV_StepDirection(edict_t *ent, float yaw, float dist) {
int ret;
vec3_t move;
yaw = yaw * M_PI * 2.0 / 360.0;
move[0] = cos(yaw) * dist;
move[1] = sin(yaw) * dist;
move[2] = 0;
ret = SV_movestep(ent, move, 0);
SV_LinkEdict(ent, 1);
return(ret);
}
/*
===============
M_walkmove
===============
*/
qboolean M_walkmove (edict_t *ent, float yaw, float dist)
{
vec3_t move;
// PMM
qboolean retval;
if (!ent->groundentity && !(ent->flags & (FL_FLY|FL_SWIM)))
return false;
yaw = yaw*M_PI*2 / 360;
move[0] = cos(yaw)*dist;
move[1] = sin(yaw)*dist;
move[2] = 0;
// PMM
retval = SV_movestep(ent, move, true);
ent->monsterinfo.aiflags &= ~AI_BLOCKED;
return retval;
// pmm
}
/*
======================
SV_StepDirection
Turns to the movement direction, and walks the current distance if
facing it.
======================
*/
qboolean SV_StepDirection (edict_t *ent, float yaw, float dist)
{
vec3_t move, oldorigin;
float delta;
if(!ent->inuse) return true; // PGM g_touchtrigger free problem
ent->ideal_yaw = yaw;
M_ChangeYaw (ent);
yaw = yaw*M_PI*2 / 360;
move[0] = cos(yaw)*dist;
move[1] = sin(yaw)*dist;
move[2] = 0;
VectorCopy (ent->s.origin, oldorigin);
if (SV_movestep (ent, move, false))
{
ent->monsterinfo.aiflags &= ~AI_BLOCKED;
if(!ent->inuse) return true; // PGM g_touchtrigger free problem
delta = ent->s.angles[YAW] - ent->ideal_yaw;
if (strncmp(ent->classname, "monster_widow", 13))
{
if (delta > 45 && delta < 315)
{ // not turned far enough, so don't take the step
VectorCopy (oldorigin, ent->s.origin);
}
}
gi.linkentity (ent);
G_TouchTriggers (ent);
return true;
}
gi.linkentity (ent);
G_TouchTriggers (ent);
return false;
}
void barrel_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
{
float ratio;
vec3_t v;
vec3_t move;
float yaw, dist;
if (other->groundentity == self || !other->client)
return;
ratio = (float)other->mass / (float)self->mass;
VectorSubtract (self->s.origin, other->s.origin, v);
yaw = vectoyaw(v);
dist = 20 * ratio * FRAMETIME;
yaw = yaw*M_PI*2 / 360;
move[0] = cos(yaw)*dist;
move[1] = sin(yaw)*dist;
move[2] = 0;
SV_movestep(self, move, true);
}
/*
======================
SV_StepDirection
Turns to the movement direction, and walks the current distance if
facing it.
======================
*/
qboolean SV_StepDirection (edict_t *ent, float yaw, float dist, qboolean try_smallstep)
{
vec3_t move, oldorigin;
//float delta;
float old_dist;
// dist = dist);
//gi.dprintf("SV_StepDirection\n");
old_dist = dist;
ent->ideal_yaw = yaw;
M_ChangeYaw (ent);
if (!dist || fabs(dist) < 1)
return true;
yaw = yaw*M_PI*2 / 360;
VectorCopy (ent->s.origin, oldorigin);
// loop until we can move successfully
while ((int)dist != 0)
{
move[0] = cos(yaw)*dist;
move[1] = sin(yaw)*dist;
move[2] = 0;
if (SV_movestep (ent, move, false))
{
/*
delta = ent->s.angles[YAW] - ent->ideal_yaw;
if (delta > 45 && delta < 315)
{ // not turned far enough, so don't take the step
VectorCopy (oldorigin, ent->s.origin);
gi.dprintf("not turned far enough!\n");
}
*/
gi.linkentity (ent);
G_TouchTriggers (ent);
/*
if (old_dist != dist)
gi.dprintf("took a smaller step of %d instead of %d\n", (int)dist, (int)old_dist);
else
gi.dprintf("moved full distance\n");
*/
return true;
}
if (!try_smallstep)
break;
if (dist > 0)
dist--;
else
dist++;
}
gi.linkentity (ent);
G_TouchTriggers (ent);
//gi.dprintf("%d: %s can't walk forward!\n", level.framenum, V_GetMonsterName(ent));
return false;
}
/*
===============
M_walkmove
===============
*/
qboolean M_walkmove (edict_t *ent, float yaw, float dist)
{
float original_yaw=yaw;//GHz
vec3_t move;
if (!ent->groundentity && !(ent->flags & (FL_FLY|FL_SWIM)))
return false;
yaw = yaw*M_PI*2 / 360;
move[0] = cos(yaw)*dist;
move[1] = sin(yaw)*dist;
move[2] = 0;
if (IsABoss(ent) || ent->mtype == P_TANK)
{
//return M_Move(ent, move, true);
if (!M_Move(ent, move, true))
{
float angle1, angle2, delta1, delta2, cl_yaw, ideal_yaw, mult;
vec3_t start, end, angles, right;
trace_t tr;
// get monster angles
AngleVectors(ent->s.angles, NULL, right, NULL);
//vectoangles(forward, forward);
vectoangles(right, right);
// get client yaw (FIXME: use mons yaw instead?)
cl_yaw = ent->s.angles[YAW];
AngleCheck(&cl_yaw);
// trace from monster to wall
VectorCopy(ent->s.origin, start);
VectorMA(start, 64, move, end);
tr = gi.trace(start, ent->mins, ent->maxs, end, ent, MASK_SHOT);
// get monster angles in relation to wall
VectorCopy(tr.plane.normal, angles);
vectoangles(angles, angles);
// monster is moving sideways, so use sideways vector instead
if ((int)original_yaw==(int)right[YAW])
{
cl_yaw = right[YAW];
AngleCheck(&cl_yaw);
}
// delta between monster yaw and wall yaw should be no more than 90 degrees
// else, turn wall angles around 180 degrees
if (fabs(cl_yaw-angles[YAW]) > 90)
angles[YAW]+=180;
ValidateAngles(angles);
// possible escape angle 1
angle1 = angles[YAW]+90;
AngleCheck(&angle1);
delta1 = fabs(angle1-cl_yaw);
// possible escape angle 2
angle2 = angles[YAW]-90;
AngleCheck(&angle2);
delta2 = fabs(angle2-cl_yaw);
// take the shorter route
if (delta1 > delta2)
{
ideal_yaw = angle2;
mult = 1.0-delta2/90.0;
}
else
{
ideal_yaw = angle1;
mult = 1.0-delta1/90.0;
}
// go full speed if we are turned at least half way towards ideal yaw
if (mult >= 0.5)
mult = 1.0;
// modify speed
dist*=mult;
// recalculate with new heading
yaw = ideal_yaw*M_PI*2 / 360;
move[0] = cos(yaw)*dist;
move[1] = sin(yaw)*dist;
move[2] = 0;
//gi.dprintf("can't walk wall@%.1f you@%.1f ideal@%.1f\n", angles[YAW], cl_yaw, ideal_yaw);
return M_Move(ent, move, true);
}
return true;
}
else if (level.time > ent->holdtime) // stay in-place for medic healing
return SV_movestep(ent, move, true);
else
return false;
}
