mirror of
https://github.com/openmoh/openmohaa.git
synced 2025-04-29 06:07:57 +03:00
647 lines
19 KiB
C++
647 lines
19 KiB
C++
/*
|
|
===========================================================================
|
|
Copyright (C) 2023 the OpenMoHAA team
|
|
|
|
This file is part of OpenMoHAA source code.
|
|
|
|
OpenMoHAA source code is free software; you can redistribute it
|
|
and/or modify it under the terms of the GNU General Public License as
|
|
published by the Free Software Foundation; either version 2 of the License,
|
|
or (at your option) any later version.
|
|
|
|
OpenMoHAA source code is distributed in the hope that it will be
|
|
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with OpenMoHAA source code; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
===========================================================================
|
|
*/
|
|
|
|
// g_vmove.cpp : Vehicle movement code
|
|
//
|
|
|
|
#include "g_local.h"
|
|
#include "entity.h"
|
|
#include "movegrid.h"
|
|
|
|
typedef struct {
|
|
qboolean validGroundTrace;
|
|
float previous_origin[3];
|
|
float previous_velocity[3];
|
|
} vml_t;
|
|
|
|
vmove_t *vm;
|
|
vml_t vml;
|
|
|
|
void VM_ClipVelocity(float *in, float *normal, float *out, float overbounce)
|
|
{
|
|
float backoff;
|
|
float dir_z;
|
|
float normal2[3];
|
|
|
|
if (normal[2] >= 0.70f) {
|
|
if (in[0] == 0.0f && in[1] == 0.0f) {
|
|
VectorClear(out);
|
|
return;
|
|
}
|
|
|
|
normal2[0] = in[0] + DotProduct2D(in, normal);
|
|
normal2[1] = in[1] + DotProduct2D(in, normal);
|
|
normal2[2] = normal[2] * DotProduct2D(in, in);
|
|
|
|
VectorNormalize(normal2);
|
|
|
|
dir_z = -normal2[2];
|
|
|
|
out[0] = in[0];
|
|
out[1] = in[1];
|
|
out[2] = DotProduct2D(in, normal2) / dir_z;
|
|
} else {
|
|
backoff = DotProduct(in, normal);
|
|
|
|
if (backoff < 0) {
|
|
backoff *= overbounce;
|
|
} else {
|
|
backoff /= overbounce;
|
|
}
|
|
|
|
out[0] = in[0] - normal[0] * backoff;
|
|
out[1] = in[1] - normal[1] * backoff;
|
|
out[2] = in[2] - normal[2] * backoff;
|
|
}
|
|
}
|
|
|
|
void VM_AddTouchEnt(int entityNum)
|
|
{
|
|
int i;
|
|
|
|
if (entityNum == ENTITYNUM_NONE || entityNum == ENTITYNUM_WORLD) {
|
|
return;
|
|
}
|
|
|
|
if (vm->numtouch > 32) {
|
|
return;
|
|
}
|
|
|
|
// see if it is already added
|
|
for (i = 0; i < vm->numtouch; i++) {
|
|
if (vm->touchents[i] == entityNum) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
// add it
|
|
vm->touchents[vm->numtouch] = entityNum;
|
|
vm->numtouch++;
|
|
}
|
|
|
|
qboolean VM_SlideMove(qboolean gravity)
|
|
{
|
|
int bumpcount;
|
|
vec3_t dir;
|
|
float d;
|
|
int numplanes;
|
|
vec3_t planes[5];
|
|
vec3_t clipVelocity;
|
|
int i;
|
|
int j;
|
|
int k;
|
|
trace_t trace;
|
|
vec3_t end;
|
|
float time_left;
|
|
vec3_t endVelocity;
|
|
vec3_t endClipVelocity;
|
|
|
|
VectorCopy(vm->vs->velocity, endVelocity);
|
|
|
|
if (gravity) {
|
|
endVelocity[2] = vm->vs->velocity[2] - vm->frametime * sv_gravity->integer;
|
|
vm->vs->velocity[2] = (vm->vs->velocity[2] + endVelocity[2]) * 0.5;
|
|
if (vm->vs->groundPlane) {
|
|
VM_ClipVelocity(vm->vs->velocity, vm->vs->groundTrace.plane.normal, vm->vs->velocity, OVERCLIP);
|
|
}
|
|
}
|
|
|
|
time_left = vm->frametime;
|
|
|
|
if (vm->vs->groundPlane) {
|
|
numplanes = 1;
|
|
VectorCopy(vm->vs->groundTrace.plane.normal, planes[0]);
|
|
} else {
|
|
numplanes = 0;
|
|
}
|
|
|
|
// never turn against original velocity
|
|
VectorNormalize2(vm->vs->velocity, planes[numplanes]);
|
|
numplanes++;
|
|
|
|
for (bumpcount = 0; bumpcount < 4; bumpcount++) {
|
|
// calculate position we are trying to move to
|
|
VectorMA(vm->vs->origin, time_left, vm->vs->velocity, end);
|
|
|
|
// see if we can make it there
|
|
gi.trace(&trace, vm->vs->origin, vm->mins, vm->maxs, end, vm->vs->entityNum, vm->tracemask, qtrue, qfalse);
|
|
|
|
if (trace.allsolid) {
|
|
if (vm->vs->velocity[0] || vm->vs->velocity[1]) {
|
|
if (vm->vs->groundPlane) {
|
|
VectorCopy(vm->vs->velocity, dir);
|
|
VectorNegate(dir, dir);
|
|
VectorNormalize(dir);
|
|
|
|
if (!vm->vs->hit_obstacle) {
|
|
vm->vs->hit_obstacle = qtrue;
|
|
VectorCopy(vm->vs->origin, vm->vs->hit_origin);
|
|
}
|
|
|
|
VectorAdd(vm->vs->obstacle_normal, dir, vm->vs->obstacle_normal);
|
|
}
|
|
|
|
VectorClear(vm->vs->velocity);
|
|
VM_AddTouchEnt(trace.entityNum);
|
|
return qtrue;
|
|
}
|
|
|
|
vm->vs->velocity[2] = 0;
|
|
bumpcount = 0;
|
|
break;
|
|
}
|
|
|
|
if (trace.fraction > 0) {
|
|
// actually covered some distance
|
|
VectorCopy(trace.endpos, vm->vs->origin);
|
|
}
|
|
|
|
if (trace.fraction == 1) {
|
|
break;
|
|
}
|
|
|
|
if (trace.plane.normal[2] >= 0.7f) {
|
|
memcpy(&vm->vs->groundTrace, &trace, sizeof(vm->vs->groundTrace));
|
|
vml.validGroundTrace = qtrue;
|
|
} else if (trace.plane.normal[2] > -0.999f) {
|
|
if (vm->vs->groundPlane) {
|
|
if (!vm->vs->hit_obstacle) {
|
|
vm->vs->hit_obstacle = qtrue;
|
|
VectorCopy(vm->vs->origin, vm->vs->hit_origin);
|
|
}
|
|
|
|
VectorAdd(vm->vs->obstacle_normal, trace.plane.normal, vm->vs->obstacle_normal);
|
|
}
|
|
}
|
|
|
|
// save entity for contact
|
|
VM_AddTouchEnt(trace.entityNum);
|
|
|
|
time_left -= time_left * trace.fraction;
|
|
|
|
if (numplanes >= MAX_CLIP_PLANES) {
|
|
VectorClear(vm->vs->velocity);
|
|
return qtrue;
|
|
}
|
|
|
|
//
|
|
// if this is the same plane we hit before, nudge velocity
|
|
// out along it, which fixes some epsilon issues with
|
|
// non-axial planes
|
|
//
|
|
for (i = 0; i < numplanes; i++) {
|
|
if (DotProduct(trace.plane.normal, planes[i]) > 0.99) {
|
|
VectorAdd(trace.plane.normal, vm->vs->velocity, vm->vs->velocity);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (i >= numplanes) {
|
|
//
|
|
// modify velocity so it parallels all of the clip planes
|
|
//
|
|
VectorCopy(trace.plane.normal, planes[numplanes]);
|
|
numplanes++;
|
|
|
|
// find a plane that it enters
|
|
for (i = 0; i < numplanes; i++) {
|
|
if (DotProduct(vm->vs->velocity, planes[i]) >= 0.1) {
|
|
continue; // move doesn't interact with the plane
|
|
}
|
|
|
|
// slide along the plane
|
|
VM_ClipVelocity(vm->vs->velocity, planes[i], clipVelocity, OVERCLIP);
|
|
VM_ClipVelocity(endVelocity, planes[i], endClipVelocity, OVERCLIP);
|
|
|
|
// see if there is a second plane that the new move enters
|
|
for (j = 0; j < numplanes; j++) {
|
|
if (j == i) {
|
|
continue;
|
|
}
|
|
|
|
// slide along the plane
|
|
VM_ClipVelocity(vm->vs->velocity, planes[j], clipVelocity, OVERCLIP);
|
|
VM_ClipVelocity(endVelocity, planes[j], endClipVelocity, OVERCLIP);
|
|
|
|
if (DotProduct(clipVelocity, planes[j]) >= 0.0f) {
|
|
continue; // move doesn't interact with the plane
|
|
}
|
|
|
|
// slide the original velocity along the crease
|
|
CrossProduct(planes[i], planes[j], dir);
|
|
VectorNormalize(dir);
|
|
d = DotProduct(dir, vm->vs->velocity);
|
|
VectorScale(dir, d, clipVelocity);
|
|
d = DotProduct(dir, endVelocity);
|
|
VectorScale(dir, d, endClipVelocity);
|
|
|
|
// see if there is a third plane the the new move enters
|
|
for (k = 0; k < numplanes; k++) {
|
|
if (k == i || k == j) {
|
|
continue;
|
|
}
|
|
|
|
if (DotProduct(clipVelocity, planes[k]) >= 0.1f) {
|
|
continue; // move doesn't interact with the plane
|
|
}
|
|
|
|
// stop dead at a tripple plane interaction
|
|
VectorClear(vm->vs->velocity);
|
|
return qtrue;
|
|
}
|
|
}
|
|
|
|
// if we have fixed all interactions, try another move
|
|
VectorCopy(clipVelocity, vm->vs->velocity);
|
|
VectorCopy(endClipVelocity, endVelocity);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (gravity) {
|
|
VectorCopy(endVelocity, vm->vs->velocity);
|
|
}
|
|
|
|
return bumpcount != 0;
|
|
}
|
|
|
|
static void VM_GroundTraceInternal2(void);
|
|
|
|
void VM_GroundTraceInternal(void)
|
|
{
|
|
if (vm->vs->groundTrace.fraction == 1) {
|
|
vm->vs->groundEntityNum = ENTITYNUM_NONE;
|
|
vm->vs->groundPlane = qfalse;
|
|
vm->vs->walking = qfalse;
|
|
return;
|
|
}
|
|
|
|
if (vm->vs->velocity[2] > 0.0f && DotProduct(vm->vs->velocity, vm->vs->groundTrace.plane.normal) > 10.0f) {
|
|
vm->vs->groundEntityNum = ENTITYNUM_NONE;
|
|
vm->vs->groundPlane = qfalse;
|
|
vm->vs->walking = qfalse;
|
|
return;
|
|
}
|
|
|
|
// slopes that are too steep will not be considered onground
|
|
if (vm->vs->groundTrace.plane.normal[2] < MIN_WALK_NORMAL) {
|
|
vec3_t oldvel;
|
|
float d;
|
|
|
|
VectorCopy(vm->vs->velocity, oldvel);
|
|
VectorSet(vm->vs->velocity, 0, 0, -1.0f / vm->frametime);
|
|
VM_SlideMove(qfalse);
|
|
|
|
d = VectorLength(vm->vs->velocity);
|
|
VectorCopy(oldvel, vm->vs->velocity);
|
|
|
|
if (d > (0.1f / vm->frametime)) {
|
|
vm->vs->groundEntityNum = ENTITYNUM_NONE;
|
|
vm->vs->groundPlane = qtrue;
|
|
vm->vs->walking = qfalse;
|
|
return;
|
|
}
|
|
}
|
|
|
|
vm->vs->groundPlane = qtrue;
|
|
vm->vs->walking = qtrue;
|
|
vm->vs->groundEntityNum = vm->vs->groundTrace.entityNum;
|
|
|
|
VM_AddTouchEnt(vm->vs->groundTrace.entityNum);
|
|
}
|
|
|
|
void VM_GroundTraceInternal2(void)
|
|
{
|
|
if (vm->vs->groundTrace.fraction == 1.0f) {
|
|
vm->vs->groundEntityNum = ENTITYNUM_NONE;
|
|
vm->vs->groundPlane = qfalse;
|
|
vm->vs->walking = qfalse;
|
|
return;
|
|
}
|
|
|
|
if (vm->vs->velocity[2] > 0.0f && DotProduct(vm->vs->velocity, vm->vs->groundTrace.plane.normal) > 10.0f) {
|
|
vm->vs->groundEntityNum = ENTITYNUM_NONE;
|
|
vm->vs->groundPlane = qfalse;
|
|
vm->vs->walking = qfalse;
|
|
return;
|
|
}
|
|
|
|
// slopes that are too steep will not be considered onground
|
|
if (vm->vs->groundTrace.plane.normal[2] < MIN_WALK_NORMAL) {
|
|
vec3_t oldvel;
|
|
float d;
|
|
|
|
VectorCopy(vm->vs->velocity, oldvel);
|
|
VectorSet(vm->vs->velocity, 0, 0, -1.0f / vm->frametime);
|
|
VM_SlideMove(qfalse);
|
|
|
|
d = VectorLength(vm->vs->velocity);
|
|
VectorCopy(oldvel, vm->vs->velocity);
|
|
|
|
if (d > (0.1f / vm->frametime)) {
|
|
vm->vs->groundEntityNum = ENTITYNUM_NONE;
|
|
vm->vs->groundPlane = qtrue;
|
|
vm->vs->walking = qfalse;
|
|
return;
|
|
}
|
|
}
|
|
|
|
vm->vs->groundPlane = qtrue;
|
|
vm->vs->walking = qtrue;
|
|
vm->vs->groundEntityNum = vm->vs->groundTrace.entityNum;
|
|
}
|
|
|
|
void VM_GroundTrace(void)
|
|
{
|
|
float point[3];
|
|
|
|
point[0] = vm->vs->origin[0];
|
|
point[1] = vm->vs->origin[1];
|
|
point[2] = vm->vs->origin[2] - 0.25f;
|
|
|
|
gi.trace(
|
|
&vm->vs->groundTrace, vm->vs->origin, vm->mins, vm->maxs, point, vm->vs->entityNum, vm->tracemask, qtrue, qfalse
|
|
);
|
|
VM_GroundTraceInternal();
|
|
}
|
|
|
|
void VM_StepSlideMove(void)
|
|
{
|
|
vec3_t start_o;
|
|
vec3_t start_v;
|
|
vec3_t nostep_o;
|
|
vec3_t nostep_v;
|
|
trace_t trace;
|
|
qboolean bWasOnGoodGround;
|
|
vec3_t up;
|
|
vec3_t down;
|
|
qboolean start_hit_wall;
|
|
vec3_t start_wall_normal;
|
|
qboolean first_hit_wall;
|
|
vec3_t first_wall_normal;
|
|
vec3_t start_hit_origin;
|
|
vec3_t first_hit_origin;
|
|
trace_t nostep_groundTrace;
|
|
|
|
VectorCopy(vm->vs->origin, start_o);
|
|
VectorCopy(vm->vs->velocity, start_v);
|
|
start_hit_wall = vm->vs->hit_obstacle;
|
|
VectorCopy(vm->vs->hit_origin, start_hit_origin);
|
|
VectorCopy(vm->vs->obstacle_normal, start_wall_normal);
|
|
|
|
if (VM_SlideMove(vm->vs->useGravity) == 0) {
|
|
if (vml.validGroundTrace) {
|
|
VM_GroundTraceInternal();
|
|
} else {
|
|
VM_GroundTrace();
|
|
}
|
|
return;
|
|
}
|
|
|
|
VectorCopy(start_o, down);
|
|
down[2] -= STEPSIZE;
|
|
gi.trace(&trace, start_o, vm->mins, vm->maxs, down, vm->vs->entityNum, vm->tracemask, qtrue, qfalse);
|
|
VectorSet(up, 0, 0, 1);
|
|
|
|
// never step up when you still have up velocity
|
|
if (vm->vs->velocity[2] > 0 && (trace.fraction == 1.0f || DotProduct(trace.plane.normal, up) < MIN_WALK_NORMAL)) {
|
|
if (vml.validGroundTrace) {
|
|
VM_GroundTraceInternal();
|
|
} else {
|
|
VM_GroundTrace();
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (vm->vs->groundPlane && vm->vs->groundTrace.plane.normal[2] >= MIN_WALK_NORMAL) {
|
|
bWasOnGoodGround = qtrue;
|
|
} else {
|
|
bWasOnGoodGround = qfalse;
|
|
}
|
|
|
|
VectorCopy(vm->vs->origin, nostep_o);
|
|
VectorCopy(vm->vs->velocity, nostep_v);
|
|
memcpy(&nostep_groundTrace, &vm->vs->groundTrace, sizeof(trace_t));
|
|
|
|
VectorCopy(start_o, vm->vs->origin);
|
|
VectorCopy(start_v, vm->vs->velocity);
|
|
|
|
first_hit_wall = vm->vs->hit_obstacle;
|
|
VectorCopy(vm->vs->hit_origin, first_hit_origin);
|
|
VectorCopy(vm->vs->obstacle_normal, first_wall_normal);
|
|
|
|
vm->vs->hit_obstacle = start_hit_wall;
|
|
VectorCopy(start_hit_origin, vm->vs->hit_origin);
|
|
VectorCopy(start_wall_normal, vm->vs->obstacle_normal);
|
|
VM_SlideMove(qtrue);
|
|
|
|
VectorCopy(vm->vs->origin, down);
|
|
down[2] -= STEPSIZE * 2;
|
|
|
|
// test the player position if they were a stepheight higher
|
|
gi.trace(&trace, vm->vs->origin, vm->mins, vm->maxs, down, vm->vs->entityNum, vm->tracemask, qtrue, qfalse);
|
|
if (trace.entityNum != ENTITYNUM_WORLD && trace.entityNum != ENTITYNUM_WORLD) {
|
|
VectorCopy(nostep_o, vm->vs->origin);
|
|
VectorCopy(nostep_v, vm->vs->velocity);
|
|
memcpy(&vm->vs->groundTrace, &nostep_groundTrace, sizeof(vm->vs->groundTrace));
|
|
vm->vs->hit_obstacle = first_hit_wall;
|
|
VectorCopy(first_hit_origin, vm->vs->hit_origin);
|
|
VectorCopy(first_wall_normal, vm->vs->obstacle_normal);
|
|
|
|
if (vml.validGroundTrace) {
|
|
VM_GroundTraceInternal();
|
|
} else {
|
|
VM_GroundTrace();
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (!trace.allsolid) {
|
|
memcpy(&vm->vs->groundTrace, &trace, sizeof(vm->vs->groundTrace));
|
|
vml.validGroundTrace = qtrue;
|
|
|
|
if (bWasOnGoodGround && trace.fraction < 1 && trace.plane.normal[2] < MIN_WALK_NORMAL) {
|
|
VectorCopy(nostep_o, vm->vs->origin);
|
|
VectorCopy(nostep_v, vm->vs->velocity);
|
|
|
|
if (first_hit_wall) {
|
|
vm->vs->hit_obstacle = first_hit_wall;
|
|
VectorCopy(first_hit_origin, vm->vs->hit_origin);
|
|
VectorCopy(first_wall_normal, vm->vs->obstacle_normal);
|
|
}
|
|
|
|
VM_GroundTraceInternal();
|
|
return;
|
|
}
|
|
|
|
VectorCopy(trace.endpos, vm->vs->origin);
|
|
}
|
|
|
|
if (trace.fraction < 1) {
|
|
VM_ClipVelocity(vm->vs->velocity, trace.plane.normal, vm->vs->velocity, OVERCLIP);
|
|
}
|
|
|
|
if (vml.validGroundTrace) {
|
|
VM_GroundTraceInternal();
|
|
} else {
|
|
VM_GroundTrace();
|
|
}
|
|
}
|
|
|
|
void VM_Friction(void)
|
|
{
|
|
vec3_t vec;
|
|
float *vel;
|
|
float speed, newspeed, control;
|
|
float drop;
|
|
|
|
vel = vm->vs->velocity;
|
|
|
|
VectorCopy(vel, vec);
|
|
if (vm->vs->walking) {
|
|
// ignore slope movement
|
|
vec[2] = 0;
|
|
}
|
|
|
|
speed = VectorLength(vec);
|
|
if (speed < 1) {
|
|
// allow sinking underwater
|
|
vel[0] = 0;
|
|
vel[1] = 0;
|
|
|
|
return;
|
|
}
|
|
|
|
drop = 0;
|
|
|
|
if (vm->vs->walking) {
|
|
control = (speed < 50.0f) ? 50.0f : speed;
|
|
|
|
// if getting knocked back, no friction
|
|
drop += control * 6.0f * vm->frametime;
|
|
}
|
|
|
|
// scale the velocity
|
|
newspeed = speed - drop;
|
|
if (newspeed < 0) {
|
|
newspeed = 0;
|
|
}
|
|
|
|
newspeed /= speed;
|
|
|
|
vel[0] = vel[0] * newspeed;
|
|
vel[1] = vel[1] * newspeed;
|
|
vel[2] = vel[2] * newspeed;
|
|
}
|
|
|
|
void VM_ClipVelocity2D(float *in, float *normal, float *out, float overbounce)
|
|
{
|
|
float backoff;
|
|
float dir_z;
|
|
float normal2[3];
|
|
|
|
if (normal[2] >= 0.70f) {
|
|
if (in[0] == 0.0f && in[1] == 0.0f) {
|
|
VectorClear(out);
|
|
return;
|
|
}
|
|
|
|
normal2[0] = in[0] + DotProduct2D(in, normal);
|
|
normal2[1] = in[1] + DotProduct2D(in, normal);
|
|
normal2[2] = normal[2] * DotProduct2D(in, in);
|
|
|
|
VectorNormalize(normal2);
|
|
|
|
dir_z = -normal2[2];
|
|
|
|
out[0] = in[0];
|
|
out[1] = in[1];
|
|
out[2] = DotProduct2D(in, normal2) / -normal2[2];
|
|
} else {
|
|
backoff = DotProduct2D(in, normal);
|
|
|
|
if (backoff < 0) {
|
|
backoff *= overbounce;
|
|
} else {
|
|
backoff /= overbounce;
|
|
}
|
|
|
|
out[0] = in[0] - normal[0] * backoff;
|
|
out[1] = in[1] - normal[1] * backoff;
|
|
out[2] = -(backoff * normal[2]);
|
|
}
|
|
}
|
|
|
|
void VmoveSingle(vmove_t *vmove)
|
|
{
|
|
float point[3];
|
|
trace_t trace;
|
|
bool walking;
|
|
|
|
vm = vmove;
|
|
|
|
vmove->numtouch = 0;
|
|
vmove->vs->hit_obstacle = false;
|
|
VectorCopy(vec_origin, vmove->vs->obstacle_normal);
|
|
|
|
memset(&vml, 0, sizeof(vml_t));
|
|
|
|
VectorCopy(vmove->vs->origin, vml.previous_origin);
|
|
VectorCopy(vmove->vs->velocity, vml.previous_velocity);
|
|
|
|
VM_GroundTraceInternal2();
|
|
|
|
walking = vm->vs->walking;
|
|
if (walking) {
|
|
float wishdir[3];
|
|
|
|
VM_Friction();
|
|
VM_ClipVelocity2D(vm->vs->desired_dir, vm->vs->groundTrace.plane.normal, wishdir, OVERCLIP);
|
|
VectorNormalize(wishdir);
|
|
|
|
vm->vs->velocity[0] = vm->desired_speed * wishdir[0];
|
|
vm->vs->velocity[1] = vm->desired_speed * wishdir[1];
|
|
|
|
if (!vm->vs->velocity[0] && !vm->vs->velocity[1]) {
|
|
VM_GroundTrace();
|
|
return;
|
|
}
|
|
} else if (vm->vs->groundPlane) {
|
|
VM_ClipVelocity(vm->vs->velocity, vm->vs->groundTrace.plane.normal, vm->vs->velocity, OVERCLIP);
|
|
}
|
|
|
|
VM_StepSlideMove();
|
|
|
|
if (!vm->vs->walking && (walking || (vml.previous_velocity[2] >= 0.0f && vm->vs->velocity[2] <= 0.0f))) {
|
|
point[0] = vm->vs->origin[0];
|
|
point[1] = vm->vs->origin[1];
|
|
point[2] = vm->vs->origin[2] - 18;
|
|
|
|
gi.trace(&trace, vm->vs->origin, vm->mins, vm->maxs, point, vm->vs->entityNum, vm->tracemask, qtrue, qfalse);
|
|
|
|
if (trace.fraction < 1 && !trace.allsolid) {
|
|
VectorCopy(trace.endpos, vm->vs->origin);
|
|
VM_GroundTrace();
|
|
}
|
|
}
|
|
}
|