path: root/src/jake2/server/SV.java

/*
 * SV.java
 * Copyright (C) 2003
 * 
 * $Id: SV.java,v 1.10 2004-09-22 19:22:12 salomo Exp $
 */
/*
 Copyright (C) 1997-2001 Id Software, Inc.

 This program 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.

 This program 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 this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

 */
package jake2.server;

import jake2.Defines;
import jake2.Globals;
import jake2.client.M;
import jake2.game.GameBase;
import jake2.game.edict_t;
import jake2.game.pushed_t;
import jake2.game.trace_t;
import jake2.qcommon.Com;
import jake2.util.Lib;
import jake2.util.Math3D;

/**
 * SV
 */
public final class SV {

    ///////////////////////////////////////
    public static edict_t[] SV_TestEntityPosition(edict_t ent) {
        trace_t trace;
        int mask;

        if (ent.clipmask != 0)
            mask = ent.clipmask;
        else
            mask = Defines.MASK_SOLID;

        trace = GameBase.gi.trace(ent.s.origin, ent.mins, ent.maxs,
                ent.s.origin, ent, mask);

        if (trace.startsolid)
            return GameBase.g_edicts;

        return null;
    }

    ///////////////////////////////////////
    public static void SV_CheckVelocity(edict_t ent) {
        int i;

        //
        //	   bound velocity
        //
        for (i = 0; i < 3; i++) {
            if (ent.velocity[i] > GameBase.sv_maxvelocity.value)
                ent.velocity[i] = GameBase.sv_maxvelocity.value;
            else if (ent.velocity[i] < -GameBase.sv_maxvelocity.value)
                ent.velocity[i] = -GameBase.sv_maxvelocity.value;
        }
    }

    /**
     * Runs thinking code for this frame if necessary.
     */
    public static boolean SV_RunThink(edict_t ent) {
        float thinktime;

        thinktime = ent.nextthink;
        if (thinktime <= 0)
            return true;
        if (thinktime > GameBase.level.time + 0.001)
            return true;

        ent.nextthink = 0;

        if (ent.think == null)
            Com.Error(Defines.ERR_FATAL, "NULL ent.think");

        ent.think.think(ent);

        return false;
    }

    /**
     * Two entities have touched, so run their touch functions.
     */
    public static void SV_Impact(edict_t e1, trace_t trace) {
        edict_t e2;

        e2 = trace.ent;

        if (e1.touch != null && e1.solid != Defines.SOLID_NOT)
            e1.touch.touch(e1, e2, trace.plane, trace.surface);

        if (e2.touch != null && e2.solid != Defines.SOLID_NOT)
            e2.touch.touch(e2, e1, GameBase.dummyplane, null);
    }

    public static int SV_FlyMove(edict_t ent, float time, int mask) {
        edict_t hit;
        int bumpcount, numbumps;
        float[] dir = { 0.0f, 0.0f, 0.0f };
        float d;
        int numplanes;
        float[][] planes = new float[GameBase.MAX_CLIP_PLANES][3];
        float[] primal_velocity = { 0.0f, 0.0f, 0.0f };
        float[] original_velocity = { 0.0f, 0.0f, 0.0f };
        float[] new_velocity = { 0.0f, 0.0f, 0.0f };
        int i, j;
        trace_t trace;
        float[] end = { 0.0f, 0.0f, 0.0f };
        float time_left;
        int blocked;

        numbumps = 4;

        blocked = 0;
        Math3D.VectorCopy(ent.velocity, original_velocity);
        Math3D.VectorCopy(ent.velocity, primal_velocity);
        numplanes = 0;

        time_left = time;

        ent.groundentity = null;
        for (bumpcount = 0; bumpcount < numbumps; bumpcount++) {
            for (i = 0; i < 3; i++)
                end[i] = ent.s.origin[i] + time_left * ent.velocity[i];

            trace = GameBase.gi.trace(ent.s.origin, ent.mins, ent.maxs, end,
                    ent, mask);

            if (trace.allsolid) { // entity is trapped in another solid
                Math3D.VectorCopy(Globals.vec3_origin, ent.velocity);
                return 3;
            }

            if (trace.fraction > 0) { // actually covered some distance
                Math3D.VectorCopy(trace.endpos, ent.s.origin);
                Math3D.VectorCopy(ent.velocity, original_velocity);
                numplanes = 0;
            }

            if (trace.fraction == 1)
                break; // moved the entire distance

            hit = trace.ent;

            if (trace.plane.normal[2] > 0.7) {
                blocked |= 1; // floor
                if (hit.solid == Defines.SOLID_BSP) {
                    ent.groundentity = hit;
                    ent.groundentity_linkcount = hit.linkcount;
                }
            }
            if (trace.plane.normal[2] == 0.0f) {
                blocked |= 2; // step
            }

            //
            //	   run the impact function
            //
            SV_Impact(ent, trace);
            if (!ent.inuse)
                break; // removed by the impact function

            time_left -= time_left * trace.fraction;

            // cliped to another plane
            if (numplanes >= GameBase.MAX_CLIP_PLANES) { // this shouldn't
                                                         // really happen
                Math3D.VectorCopy(Globals.vec3_origin, ent.velocity);
                return 3;
            }

            Math3D.VectorCopy(trace.plane.normal, planes[numplanes]);
            numplanes++;

            //
            //	   modify original_velocity so it parallels all of the clip planes
            //
            for (i = 0; i < numplanes; i++) {
                GameBase.ClipVelocity(original_velocity, planes[i],
                        new_velocity, 1);

                for (j = 0; j < numplanes; j++)
                    if ((j != i)
                            && Math3D.VectorCompare(planes[i], planes[j]) == 0.0f) {
                        if (Math3D.DotProduct(new_velocity, planes[j]) < 0)
                            break; // not ok
                    }
                if (j == numplanes)
                    break;
            }

            if (i != numplanes) { // go along this plane
                Math3D.VectorCopy(new_velocity, ent.velocity);
            } else { // go along the crease
                if (numplanes != 2) {
                    //					gi.dprintf ("clip velocity, numplanes ==
                    // %i\n",numplanes);
                    Math3D.VectorCopy(Globals.vec3_origin, ent.velocity);
                    return 7;
                }
                Math3D.CrossProduct(planes[0], planes[1], dir);
                d = Math3D.DotProduct(dir, ent.velocity);
                Math3D.VectorScale(dir, d, ent.velocity);
            }

            //
            //	   if original velocity is against the original velocity, stop dead
            //	   to avoid tiny occilations in sloping corners
            //
            if (Math3D.DotProduct(ent.velocity, primal_velocity) <= 0) {
                Math3D.VectorCopy(Globals.vec3_origin, ent.velocity);
                return blocked;
            }
        }

        return blocked;
    }

    /*
     * ============ SV_AddGravity
     * 
     * ============
     */
    public static void SV_AddGravity(edict_t ent) {
        ent.velocity[2] -= ent.gravity * GameBase.sv_gravity.value
                * Defines.FRAMETIME;
    }

    /**
     * Does not change the entities velocity at all
     */
    public static trace_t SV_PushEntity(edict_t ent, float[] push) {
        trace_t trace;
        float[] start = { 0, 0, 0 };
        float[] end = { 0, 0, 0 };
        int mask;

        Math3D.VectorCopy(ent.s.origin, start);
        Math3D.VectorAdd(start, push, end);

        // FIXME: test this
        // a goto statement was replaced.
        boolean retry = false;

        do {
            if (ent.clipmask != 0)
                mask = ent.clipmask;
            else
                mask = Defines.MASK_SOLID;

            trace = GameBase.gi
                    .trace(start, ent.mins, ent.maxs, end, ent, mask);

            Math3D.VectorCopy(trace.endpos, ent.s.origin);
            GameBase.gi.linkentity(ent);

            retry = false;
            if (trace.fraction != 1.0) {
                SV_Impact(ent, trace);

                // if the pushed entity went away and the pusher is still there
                if (!trace.ent.inuse && ent.inuse) {
                    // move the pusher back and try again
                    Math3D.VectorCopy(start, ent.s.origin);
                    GameBase.gi.linkentity(ent);
                    //goto retry;
                    retry = true;
                }
            }
        } while (retry);

        if (ent.inuse)
            GameBase.G_TouchTriggers(ent);

        return trace;
    }

    /*
     * ============ SV_Push
     * 
     * Objects need to be moved back on a failed push, otherwise riders would
     * continue to slide. ============
     */
    public static boolean SV_Push(edict_t pusher, float[] move, float[] amove) {
        int i, e;
        edict_t check, block[];
        float[] mins = { 0, 0, 0 };
        float[] maxs = { 0, 0, 0 };
        pushed_t p;
        float[] org = { 0, 0, 0 };
        float[] org2 = { 0, 0, 0 };
        float[] move2 = { 0, 0, 0 };
        float[] forward = { 0, 0, 0 };
        float[] right = { 0, 0, 0 };
        float[] up = { 0, 0, 0 };

        // clamp the move to 1/8 units, so the position will
        // be accurate for client side prediction
        for (i = 0; i < 3; i++) {
            float temp;
            temp = move[i] * 8.0f;
            if (temp > 0.0)
                temp += 0.5;
            else
                temp -= 0.5;
            move[i] = 0.125f * (int) temp;
        }

        // find the bounding box
        for (i = 0; i < 3; i++) {
            mins[i] = pusher.absmin[i] + move[i];
            maxs[i] = pusher.absmax[i] + move[i];
        }

        //	   we need this for pushing things later
        Math3D.VectorSubtract(Globals.vec3_origin, amove, org);
        Math3D.AngleVectors(org, forward, right, up);

        //	   save the pusher's original position
        GameBase.pushed[GameBase.pushed_p].ent = pusher;
        Math3D.VectorCopy(pusher.s.origin,
                GameBase.pushed[GameBase.pushed_p].origin);
        Math3D.VectorCopy(pusher.s.angles,
                GameBase.pushed[GameBase.pushed_p].angles);

        if (pusher.client != null)
            GameBase.pushed[GameBase.pushed_p].deltayaw = pusher.client.ps.pmove.delta_angles[Defines.YAW];

        GameBase.pushed_p++;

        //	   move the pusher to it's final position
        Math3D.VectorAdd(pusher.s.origin, move, pusher.s.origin);
        Math3D.VectorAdd(pusher.s.angles, amove, pusher.s.angles);
        GameBase.gi.linkentity(pusher);

        //	   see if any solid entities are inside the final position

        //check= g_edicts + 1;
        for (e = 1; e < GameBase.num_edicts; e++) {
            check = GameBase.g_edicts[e];
            if (!check.inuse)
                continue;
            if (check.movetype == Defines.MOVETYPE_PUSH
                    || check.movetype == Defines.MOVETYPE_STOP
                    || check.movetype == Defines.MOVETYPE_NONE
                    || check.movetype == Defines.MOVETYPE_NOCLIP)
                continue;

            if (check.area.prev == null)
                continue; // not linked in anywhere

            // if the entity is standing on the pusher, it will definitely be
            // moved
            if (check.groundentity != pusher) {
                // see if the ent needs to be tested
                if (check.absmin[0] >= maxs[0] || check.absmin[1] >= maxs[1]
                        || check.absmin[2] >= maxs[2]
                        || check.absmax[0] <= mins[0]
                        || check.absmax[1] <= mins[1]
                        || check.absmax[2] <= mins[2])
                    continue;

                // see if the ent's bbox is inside the pusher's final position
                if (SV_TestEntityPosition(check) == null)
                    continue;
            }

            if ((pusher.movetype == Defines.MOVETYPE_PUSH)
                    || (check.groundentity == pusher)) {
                // move this entity
                GameBase.pushed[GameBase.pushed_p].ent = check;
                Math3D.VectorCopy(check.s.origin,
                        GameBase.pushed[GameBase.pushed_p].origin);
                Math3D.VectorCopy(check.s.angles,
                        GameBase.pushed[GameBase.pushed_p].angles);
                GameBase.pushed_p++;

                // try moving the contacted entity
                Math3D.VectorAdd(check.s.origin, move, check.s.origin);
                if (check.client != null) { // FIXME: doesn't rotate monsters?
                    check.client.ps.pmove.delta_angles[Defines.YAW] += amove[Defines.YAW];
                }

                // figure movement due to the pusher's amove
                Math3D.VectorSubtract(check.s.origin, pusher.s.origin, org);
                org2[0] = Math3D.DotProduct(org, forward);
                org2[1] = -Math3D.DotProduct(org, right);
                org2[2] = Math3D.DotProduct(org, up);
                Math3D.VectorSubtract(org2, org, move2);
                Math3D.VectorAdd(check.s.origin, move2, check.s.origin);

                // may have pushed them off an edge
                if (check.groundentity != pusher)
                    check.groundentity = null;

                block = SV_TestEntityPosition(check);
                if (block == null) { // pushed ok
                    GameBase.gi.linkentity(check);
                    // impact?
                    continue;
                }

                // if it is ok to leave in the old position, do it
                // this is only relevent for riding entities, not pushed
                // FIXME: this doesn't acount for rotation
                Math3D.VectorSubtract(check.s.origin, move, check.s.origin);
                block = SV_TestEntityPosition(check);

                if (block == null) {
                    GameBase.pushed_p--;
                    continue;
                }
            }

            // save off the obstacle so we can call the block function
            GameBase.obstacle = check;

            // move back any entities we already moved
            // go backwards, so if the same entity was pushed
            // twice, it goes back to the original position
            for (int ip = GameBase.pushed_p - 1; ip >= 0; ip--) {
                p = GameBase.pushed[ip];
                Math3D.VectorCopy(p.origin, p.ent.s.origin);
                Math3D.VectorCopy(p.angles, p.ent.s.angles);
                if (p.ent.client != null) {
                    p.ent.client.ps.pmove.delta_angles[Defines.YAW] = (short) p.deltayaw;
                }
                GameBase.gi.linkentity(p.ent);
            }
            return false;
        }

        //	  FIXME: is there a better way to handle this?
        // see if anything we moved has touched a trigger
        for (int ip = GameBase.pushed_p - 1; ip >= 0; ip--)
            GameBase.G_TouchTriggers(GameBase.pushed[ip].ent);

        return true;
    }

    /*
     * ================ SV_Physics_Pusher
     * 
     * Bmodel objects don't interact with each other, but push all box objects
     * ================
     */
    public static void SV_Physics_Pusher(edict_t ent) {
        float[] move = { 0, 0, 0 };
        float[] amove = { 0, 0, 0 };
        edict_t part, mv;

        // if not a team captain, so movement will be handled elsewhere
        if ((ent.flags & Defines.FL_TEAMSLAVE) != 0)
            return;

        // make sure all team slaves can move before commiting
        // any moves or calling any think functions
        // if the move is blocked, all moved objects will be backed out
        //	  retry:
        GameBase.pushed_p = 0;
        for (part = ent; part != null; part = part.teamchain) {
            if (part.velocity[0] != 0 || part.velocity[1] != 0
                    || part.velocity[2] != 0 || part.avelocity[0] != 0
                    || part.avelocity[1] != 0 || part.avelocity[2] != 0) { // object
                                                                           // is
                                                                           // moving
                Math3D.VectorScale(part.velocity, Defines.FRAMETIME, move);
                Math3D.VectorScale(part.avelocity, Defines.FRAMETIME, amove);

                if (!SV_Push(part, move, amove))
                    break; // move was blocked
            }
        }
        if (GameBase.pushed_p > Defines.MAX_EDICTS)
            SV_GAME.PF_error(Defines.ERR_FATAL,
                    "pushed_p > &pushed[MAX_EDICTS], memory corrupted");

        if (part != null) {
            // the move failed, bump all nextthink times and back out moves
            for (mv = ent; mv != null; mv = mv.teamchain) {
                if (mv.nextthink > 0)
                    mv.nextthink += Defines.FRAMETIME;
            }

            // if the pusher has a "blocked" function, call it
            // otherwise, just stay in place until the obstacle is gone
            if (part.blocked != null)
                part.blocked.blocked(part, GameBase.obstacle);
        } else { // the move succeeded, so call all think functions
            for (part = ent; part != null; part = part.teamchain) {
                SV_RunThink(part);
            }
        }
    }

    //	  ==================================================================

    /*
     * ============= SV_Physics_None
     * 
     * Non moving objects can only think =============
     */
    public static void SV_Physics_None(edict_t ent) {
        //	   regular thinking
        SV_RunThink(ent);
    }

    /*
     * ============= SV_Physics_Noclip
     * 
     * A moving object that doesn't obey physics =============
     */
    public static void SV_Physics_Noclip(edict_t ent) {
        //	   regular thinking
        if (!SV_RunThink(ent))
            return;

        Math3D.VectorMA(ent.s.angles, Defines.FRAMETIME, ent.avelocity,
                ent.s.angles);
        Math3D.VectorMA(ent.s.origin, Defines.FRAMETIME, ent.velocity,
                ent.s.origin);

        GameBase.gi.linkentity(ent);
    }

    /*
     * ==============================================================================
     * 
     * TOSS / BOUNCE
     * 
     * ==============================================================================
     */

    /*
     * ============= SV_Physics_Toss
     * 
     * Toss, bounce, and fly movement. When onground, do nothing. =============
     */
    public static void SV_Physics_Toss(edict_t ent) {

        trace_t trace;
        float[] move = { 0, 0, 0 };
        float backoff;
        edict_t slave;
        boolean wasinwater;
        boolean isinwater;
        float[] old_origin = { 0, 0, 0 };

        //	   regular thinking
        SV_RunThink(ent);

        // if not a team captain, so movement will be handled elsewhere
        if ((ent.flags & Defines.FL_TEAMSLAVE) != 0)
            return;

        if (ent.velocity[2] > 0)
            ent.groundentity = null;

        //	check for the groundentity going away
        if (ent.groundentity != null)
            if (!ent.groundentity.inuse)
                ent.groundentity = null;

        //	   if onground, return without moving
        if (ent.groundentity != null)
            return;

        Math3D.VectorCopy(ent.s.origin, old_origin);

        SV_CheckVelocity(ent);

        //	   add gravity
        if (ent.movetype != Defines.MOVETYPE_FLY
                && ent.movetype != Defines.MOVETYPE_FLYMISSILE)
            SV_AddGravity(ent);

        //	   move angles
        Math3D.VectorMA(ent.s.angles, Defines.FRAMETIME, ent.avelocity,
                ent.s.angles);

        //	   move origin
        Math3D.VectorScale(ent.velocity, Defines.FRAMETIME, move);
        trace = SV_PushEntity(ent, move);
        if (!ent.inuse)
            return;

        if (trace.fraction < 1) {
            if (ent.movetype == Defines.MOVETYPE_BOUNCE)
                backoff = 1.5f;
            else
                backoff = 1;

            GameBase.ClipVelocity(ent.velocity, trace.plane.normal,
                    ent.velocity, backoff);

            // stop if on ground
            if (trace.plane.normal[2] > 0.7) {
                if (ent.velocity[2] < 60
                        || ent.movetype != Defines.MOVETYPE_BOUNCE) {
                    ent.groundentity = trace.ent;
                    ent.groundentity_linkcount = trace.ent.linkcount;
                    Math3D.VectorCopy(Globals.vec3_origin, ent.velocity);
                    Math3D.VectorCopy(Globals.vec3_origin, ent.avelocity);
                }
            }

            //			if (ent.touch)
            //				ent.touch (ent, trace.ent, &trace.plane, trace.surface);
        }

        //	   check for water transition
        wasinwater = (ent.watertype & Defines.MASK_WATER) != 0;
        ent.watertype = GameBase.gi.pointcontents.pointcontents(ent.s.origin);
        isinwater = (ent.watertype & Defines.MASK_WATER) != 0;

        if (isinwater)
            ent.waterlevel = 1;
        else
            ent.waterlevel = 0;

        if (!wasinwater && isinwater)
            GameBase.gi.positioned_sound(old_origin, ent, Defines.CHAN_AUTO,
                    GameBase.gi.soundindex("misc/h2ohit1.wav"), 1, 1, 0);
        else if (wasinwater && !isinwater)
            GameBase.gi.positioned_sound(ent.s.origin, ent, Defines.CHAN_AUTO,
                    GameBase.gi.soundindex("misc/h2ohit1.wav"), 1, 1, 0);

        //	   move teamslaves
        for (slave = ent.teamchain; slave != null; slave = slave.teamchain) {
            Math3D.VectorCopy(ent.s.origin, slave.s.origin);
            GameBase.gi.linkentity(slave);
        }
    }

    /*
     * ===============================================================================
     * 
     * STEPPING MOVEMENT
     * 
     * ===============================================================================
     */

    /*
     * ============= SV_Physics_Step
     * 
     * Monsters freefall when they don't have a ground entity, otherwise all
     * movement is done with discrete steps.
     * 
     * This is also used for objects that have become still on the ground, but
     * will fall if the floor is pulled out from under them. FIXME: is this
     * true? =============
     */

    //	  FIXME: hacked in for E3 demo
    public static void SV_AddRotationalFriction(edict_t ent) {
        int n;
        float adjustment;

        Math3D.VectorMA(ent.s.angles, Defines.FRAMETIME, ent.avelocity,
                ent.s.angles);
        adjustment = Defines.FRAMETIME * Defines.sv_stopspeed
                * Defines.sv_friction;
        for (n = 0; n < 3; n++) {
            if (ent.avelocity[n] > 0) {
                ent.avelocity[n] -= adjustment;
                if (ent.avelocity[n] < 0)
                    ent.avelocity[n] = 0;
            } else {
                ent.avelocity[n] += adjustment;
                if (ent.avelocity[n] > 0)
                    ent.avelocity[n] = 0;
            }
        }
    }

    public static void SV_Physics_Step(edict_t ent) {
        boolean wasonground;
        boolean hitsound = false;
        float vel[];
        float speed, newspeed, control;
        float friction;
        edict_t groundentity;
        int mask;

        // airborn monsters should always check for ground
        if (ent.groundentity == null)
            M.M_CheckGround(ent);

        groundentity = ent.groundentity;

        SV_CheckVelocity(ent);

        if (groundentity != null)
            wasonground = true;
        else
            wasonground = false;

        if (ent.avelocity[0] != 0 || ent.avelocity[1] != 0
                || ent.avelocity[2] != 0)
            SV_AddRotationalFriction(ent);

        // add gravity except:
        //   flying monsters
        //   swimming monsters who are in the water
        if (!wasonground)
            if (0 == (ent.flags & Defines.FL_FLY))
                if (!((ent.flags & Defines.FL_SWIM) != 0 && (ent.waterlevel > 2))) {
                    if (ent.velocity[2] < GameBase.sv_gravity.value * -0.1)
                        hitsound = true;
                    if (ent.waterlevel == 0)
                        SV_AddGravity(ent);
                }

        // friction for flying monsters that have been given vertical velocity
        if ((ent.flags & Defines.FL_FLY) != 0 && (ent.velocity[2] != 0)) {
            speed = Math.abs(ent.velocity[2]);
            control = speed < Defines.sv_stopspeed ? Defines.sv_stopspeed
                    : speed;
            friction = Defines.sv_friction / 3;
            newspeed = speed - (Defines.FRAMETIME * control * friction);
            if (newspeed < 0)
                newspeed = 0;
            newspeed /= speed;
            ent.velocity[2] *= newspeed;
        }

        // friction for flying monsters that have been given vertical velocity
        if ((ent.flags & Defines.FL_SWIM) != 0 && (ent.velocity[2] != 0)) {
            speed = Math.abs(ent.velocity[2]);
            control = speed < Defines.sv_stopspeed ? Defines.sv_stopspeed
                    : speed;
            newspeed = speed
                    - (Defines.FRAMETIME * control * Defines.sv_waterfriction * ent.waterlevel);
            if (newspeed < 0)
                newspeed = 0;
            newspeed /= speed;
            ent.velocity[2] *= newspeed;
        }

        if (ent.velocity[2] != 0 || ent.velocity[1] != 0
                || ent.velocity[0] != 0) {
            // apply friction
            // let dead monsters who aren't completely onground slide
            if ((wasonground)
                    || 0 != (ent.flags & (Defines.FL_SWIM | Defines.FL_FLY)))
                if (!(ent.health <= 0.0 && !M.M_CheckBottom(ent))) {
                    vel = ent.velocity;
                    speed = (float) Math
                            .sqrt(vel[0] * vel[0] + vel[1] * vel[1]);
                    if (speed != 0) {
                        friction = Defines.sv_friction;

                        control = speed < Defines.sv_stopspeed ? Defines.sv_stopspeed
                                : speed;
                        newspeed = speed - Defines.FRAMETIME * control
                                * friction;

                        if (newspeed < 0)
                            newspeed = 0;
                        newspeed /= speed;

                        vel[0] *= newspeed;
                        vel[1] *= newspeed;
                    }
                }

            if ((ent.svflags & Defines.SVF_MONSTER) != 0)
                mask = Defines.MASK_MONSTERSOLID;
            else
                mask = Defines.MASK_SOLID;

            SV_FlyMove(ent, Defines.FRAMETIME, mask);

            GameBase.gi.linkentity(ent);
            GameBase.G_TouchTriggers(ent);
            if (!ent.inuse)
                return;

            if (ent.groundentity != null)
                if (!wasonground)
                    if (hitsound)
                        GameBase.gi.sound(ent, 0, GameBase.gi
                                .soundindex("world/land.wav"), 1, 1, 0);
        }

        // regular thinking
        SV_RunThink(ent);
    }

    /*
     * ============= SV_movestep
     * 
     * Called by monster program code. The move will be adjusted for slopes and
     * stairs, but if the move isn't possible, no move is done, false is
     * returned, and pr_global_struct.trace_normal is set to the normal of the
     * blocking wall =============
     */
    //	  FIXME since we need to test end position contents here, can we avoid
    // doing
    //	  it again later in catagorize position?
    public static boolean SV_movestep(edict_t ent, float[] move, boolean relink) {
        float dz;
        float[] oldorg = { 0, 0, 0 };
        float[] neworg = { 0, 0, 0 };
        float[] end = { 0, 0, 0 };

        trace_t trace = null; // = new trace_t();
        int i;
        float stepsize;
        float[] test = { 0, 0, 0 };
        int contents;

        //	   try the move
        Math3D.VectorCopy(ent.s.origin, oldorg);
        Math3D.VectorAdd(ent.s.origin, move, neworg);

        //	   flying monsters don't step up
        if ((ent.flags & (Defines.FL_SWIM | Defines.FL_FLY)) != 0) {
            // try one move with vertical motion, then one without
            for (i = 0; i < 2; i++) {
                Math3D.VectorAdd(ent.s.origin, move, neworg);
                if (i == 0 && ent.enemy != null) {
                    if (ent.goalentity == null)
                        ent.goalentity = ent.enemy;
                    dz = ent.s.origin[2] - ent.goalentity.s.origin[2];
                    if (ent.goalentity.client != null) {
                        if (dz > 40)
                            neworg[2] -= 8;
                        if (!((ent.flags & Defines.FL_SWIM) != 0 && (ent.waterlevel < 2)))
                            if (dz < 30)
                                neworg[2] += 8;
                    } else {
                        if (dz > 8)
                            neworg[2] -= 8;
                        else if (dz > 0)
                            neworg[2] -= dz;
                        else if (dz < -8)
                            neworg[2] += 8;
                        else
                            neworg[2] += dz;
                    }
                }
                trace = GameBase.gi.trace(ent.s.origin, ent.mins, ent.maxs,
                        neworg, ent, Defines.MASK_MONSTERSOLID);

                // fly monsters don't enter water voluntarily
                if ((ent.flags & Defines.FL_FLY) != 0) {
                    if (ent.waterlevel == 0) {
                        test[0] = trace.endpos[0];
                        test[1] = trace.endpos[1];
                        test[2] = trace.endpos[2] + ent.mins[2] + 1;
                        contents = GameBase.gi.pointcontents
                                .pointcontents(test);
                        if ((contents & Defines.MASK_WATER) != 0)
                            return false;
                    }
                }

                // swim monsters don't exit water voluntarily
                if ((ent.flags & Defines.FL_SWIM) != 0) {
                    if (ent.waterlevel < 2) {
                        test[0] = trace.endpos[0];
                        test[1] = trace.endpos[1];
                        test[2] = trace.endpos[2] + ent.mins[2] + 1;
                        contents = GameBase.gi.pointcontents
                                .pointcontents(test);
                        if ((contents & Defines.MASK_WATER) == 0)
                            return false;
                    }
                }

                if (trace.fraction == 1) {
                    Math3D.VectorCopy(trace.endpos, ent.s.origin);
                    if (relink) {
                        GameBase.gi.linkentity(ent);
                        GameBase.G_TouchTriggers(ent);
                    }
                    return true;
                }

                if (ent.enemy == null)
                    break;
            }

            return false;
        }

        //	   push down from a step height above the wished position
        if ((ent.monsterinfo.aiflags & Defines.AI_NOSTEP) == 0)
            stepsize = GameBase.STEPSIZE;
        else
            stepsize = 1;

        neworg[2] += stepsize;
        Math3D.VectorCopy(neworg, end);
        end[2] -= stepsize * 2;

        trace = GameBase.gi.trace(neworg, ent.mins, ent.maxs, end, ent,
                Defines.MASK_MONSTERSOLID);

        if (trace.allsolid)
            return false;

        if (trace.startsolid) {
            neworg[2] -= stepsize;
            trace = GameBase.gi.trace(neworg, ent.mins, ent.maxs, end, ent,
                    Defines.MASK_MONSTERSOLID);
            if (trace.allsolid || trace.startsolid)
                return false;
        }

        // don't go in to water
        if (ent.waterlevel == 0) {
            test[0] = trace.endpos[0];
            test[1] = trace.endpos[1];
            test[2] = trace.endpos[2] + ent.mins[2] + 1;
            contents = GameBase.gi.pointcontents.pointcontents(test);

            if ((contents & Defines.MASK_WATER) != 0)
                return false;
        }

        if (trace.fraction == 1) {
            // if monster had the ground pulled out, go ahead and fall
            if ((ent.flags & Defines.FL_PARTIALGROUND) != 0) {
                Math3D.VectorAdd(ent.s.origin, move, ent.s.origin);
                if (relink) {
                    GameBase.gi.linkentity(ent);
                    GameBase.G_TouchTriggers(ent);
                }
                ent.groundentity = null;
                return true;
            }

            return false; // walked off an edge
        }

        //	   check point traces down for dangling corners
        Math3D.VectorCopy(trace.endpos, ent.s.origin);

        if (!M.M_CheckBottom(ent)) {
            if ((ent.flags & Defines.FL_PARTIALGROUND) != 0) {
                // entity had floor mostly pulled out from underneath it
                // and is trying to correct
                if (relink) {
                    GameBase.gi.linkentity(ent);
                    GameBase.G_TouchTriggers(ent);
                }
                return true;
            }
            Math3D.VectorCopy(oldorg, ent.s.origin);
            return false;
        }

        if ((ent.flags & Defines.FL_PARTIALGROUND) != 0) {
            ent.flags &= ~Defines.FL_PARTIALGROUND;
        }
        ent.groundentity = trace.ent;
        ent.groundentity_linkcount = trace.ent.linkcount;

        //	   the move is ok
        if (relink) {
            GameBase.gi.linkentity(ent);
            GameBase.G_TouchTriggers(ent);
        }
        return true;
    }

    /*
     * ====================== SV_StepDirection
     * 
     * Turns to the movement direction, and walks the current distance if facing
     * it.
     * 
     * ======================
     */
    public static boolean SV_StepDirection(edict_t ent, float yaw, float dist) {
        float[] move = { 0, 0, 0 };
        float[] oldorigin = { 0, 0, 0 };
        float delta;

        ent.ideal_yaw = yaw;
        M.M_ChangeYaw(ent);

        yaw = (float) (yaw * Math.PI * 2 / 360);
        move[0] = (float) Math.cos(yaw) * dist;
        move[1] = (float) Math.sin(yaw) * dist;
        move[2] = 0;

        Math3D.VectorCopy(ent.s.origin, oldorigin);
        if (SV_movestep(ent, move, false)) {
            delta = ent.s.angles[Defines.YAW] - ent.ideal_yaw;
            if (delta > 45 && delta < 315) { // not turned far enough, so don't
                                             // take the step
                Math3D.VectorCopy(oldorigin, ent.s.origin);
            }
            GameBase.gi.linkentity(ent);
            GameBase.G_TouchTriggers(ent);
            return true;
        }
        GameBase.gi.linkentity(ent);
        GameBase.G_TouchTriggers(ent);
        return false;
    }

    /*
     * ====================== SV_FixCheckBottom
     * 
     * ======================
     */
    public static void SV_FixCheckBottom(edict_t ent) {
        ent.flags |= Defines.FL_PARTIALGROUND;
    }

    public static void SV_NewChaseDir(edict_t actor, edict_t enemy, float dist) {
        float deltax, deltay;
        float d[] = { 0, 0, 0 };
        float tdir, olddir, turnaround;

        //FIXME: how did we get here with no enemy
        if (enemy == null) {
            Com.DPrintf("SV_NewChaseDir without enemy!\n");
            return;
        }
        olddir = Math3D.anglemod((int) (actor.ideal_yaw / 45) * 45);
        turnaround = Math3D.anglemod(olddir - 180);

        deltax = enemy.s.origin[0] - actor.s.origin[0];
        deltay = enemy.s.origin[1] - actor.s.origin[1];
        if (deltax > 10)
            d[1] = 0;
        else if (deltax < -10)
            d[1] = 180;
        else
            d[1] = GameBase.DI_NODIR;
        if (deltay < -10)
            d[2] = 270;
        else if (deltay > 10)
            d[2] = 90;
        else
            d[2] = GameBase.DI_NODIR;

        //	   try direct route
        if (d[1] != GameBase.DI_NODIR && d[2] != GameBase.DI_NODIR) {
            if (d[1] == 0)
                tdir = d[2] == 90 ? 45 : 315;
            else
                tdir = d[2] == 90 ? 135 : 215;

            if (tdir != turnaround && SV_StepDirection(actor, tdir, dist))
                return;
        }

        //	   try other directions
        if (((Lib.rand() & 3) & 1) != 0 || Math.abs(deltay) > Math.abs(deltax)) {
            tdir = d[1];
            d[1] = d[2];
            d[2] = tdir;
        }

        if (d[1] != GameBase.DI_NODIR && d[1] != turnaround
                && SV_StepDirection(actor, d[1], dist))
            return;

        if (d[2] != GameBase.DI_NODIR && d[2] != turnaround
                && SV_StepDirection(actor, d[2], dist))
            return;

        /* there is no direct path to the player, so pick another direction */

        if (olddir != GameBase.DI_NODIR
                && SV_StepDirection(actor, olddir, dist))
            return;

        if ((Lib.rand() & 1) != 0) /* randomly determine direction of search */{
            for (tdir = 0; tdir <= 315; tdir += 45)
                if (tdir != turnaround && SV_StepDirection(actor, tdir, dist))
                    return;
        } else {
            for (tdir = 315; tdir >= 0; tdir -= 45)
                if (tdir != turnaround && SV_StepDirection(actor, tdir, dist))
                    return;
        }

        if (turnaround != GameBase.DI_NODIR
                && SV_StepDirection(actor, turnaround, dist))
            return;

        actor.ideal_yaw = olddir; // can't move

        //	   if a bridge was pulled out from underneath a monster, it may not have
        //	   a valid standing position at all

        if (!M.M_CheckBottom(actor))
            SV_FixCheckBottom(actor);
    }

    /*
     * ====================== SV_CloseEnough
     * 
     * ======================
     *///ok
    public static boolean SV_CloseEnough(edict_t ent, edict_t goal, float dist) {
        int i;

        for (i = 0; i < 3; i++) {
            if (goal.absmin[i] > ent.absmax[i] + dist)
                return false;
            if (goal.absmax[i] < ent.absmin[i] - dist)
                return false;
        }
        return true;
    }
}