pmove.java

Jake2是一个Java 3D游戏引擎.

        float[] end = { 0, 0, 0 };
        trace_t trace;

        pm.viewheight = 22;

        // friction

        speed = Math3D.VectorLength(pml.velocity);
        if (speed < 1) {
            Math3D.VectorCopy(Globals.vec3_origin, pml.velocity);
        } else {
            drop = 0;

            friction = pm_friction * 1.5f; // extra friction
            control = speed < pm_stopspeed ? pm_stopspeed : speed;
            drop += control * friction * pml.frametime;

            // scale the velocity
            newspeed = speed - drop;
            if (newspeed < 0)
                newspeed = 0;
            newspeed /= speed;

            Math3D.VectorScale(pml.velocity, newspeed, pml.velocity);
        }

        // accelerate
        fmove = pm.cmd.forwardmove;
        smove = pm.cmd.sidemove;

        Math3D.VectorNormalize(pml.forward);
        Math3D.VectorNormalize(pml.right);

        for (i = 0; i < 3; i++)
            wishvel[i] = pml.forward[i] * fmove + pml.right[i]
                    * smove;
        wishvel[2] += pm.cmd.upmove;

        Math3D.VectorCopy(wishvel, wishdir);
        wishspeed = Math3D.VectorNormalize(wishdir);

        // clamp to server defined max speed
        if (wishspeed > pm_maxspeed) {
            Math3D.VectorScale(wishvel, pm_maxspeed / wishspeed, wishvel);
            wishspeed = pm_maxspeed;
        }

        currentspeed = Math3D.DotProduct(pml.velocity, wishdir);
        addspeed = wishspeed - currentspeed;
        if (addspeed <= 0)
            return;
        accelspeed = pm_accelerate * pml.frametime * wishspeed;
        if (accelspeed > addspeed)
            accelspeed = addspeed;

        for (i = 0; i < 3; i++)
            pml.velocity[i] += accelspeed * wishdir[i];

        if (doclip) {
            for (i = 0; i < 3; i++)
                end[i] = pml.origin[i] + pml.frametime * pml.velocity[i];

            trace = pm.trace.trace(pml.origin, pm.mins, pm.maxs, end);

            Math3D.VectorCopy(trace.endpos, pml.origin);
        } else {
            // move
            Math3D.VectorMA(pml.origin, pml.frametime, pml.velocity, pml.origin);
        }
    }

    /**
     * Sets mins, maxs, and pm.viewheight.
     */
    public static void PM_CheckDuck() {
        trace_t trace;

        pm.mins[0] = -16;
        pm.mins[1] = -16;

        pm.maxs[0] = 16;
        pm.maxs[1] = 16;

        if (pm.s.pm_type == Defines.PM_GIB) {
            pm.mins[2] = 0;
            pm.maxs[2] = 16;
            pm.viewheight = 8;
            return;
        }

        pm.mins[2] = -24;

        if (pm.s.pm_type == Defines.PM_DEAD) {
            pm.s.pm_flags |= pmove_t.PMF_DUCKED;
        } else if (pm.cmd.upmove < 0 && (pm.s.pm_flags & pmove_t.PMF_ON_GROUND) != 0) { // duck
            pm.s.pm_flags |= pmove_t.PMF_DUCKED;
        } else { // stand up if possible
            if ((pm.s.pm_flags & pmove_t.PMF_DUCKED) != 0) {
                // try to stand up
                pm.maxs[2] = 32;
                trace = pm.trace.trace(pml.origin, pm.mins, pm.maxs, pml.origin);
                if (!trace.allsolid)
                    pm.s.pm_flags &= ~pmove_t.PMF_DUCKED;
            }
        }

        if ((pm.s.pm_flags & pmove_t.PMF_DUCKED) != 0) {
            pm.maxs[2] = 4;
            pm.viewheight = -2;
        } else {
            pm.maxs[2] = 32;
            pm.viewheight = 22;
        }
    }

    /**
     * Dead bodies have extra friction.
     */
    public static void PM_DeadMove() {
        float forward;

        if (null == pm.groundentity)
            return;

        // extra friction
        forward = Math3D.VectorLength(pml.velocity);
        forward -= 20;
        if (forward <= 0) {
            Math3D.VectorClear(pml.velocity);
        } else {
            Math3D.VectorNormalize(pml.velocity);
            Math3D.VectorScale(pml.velocity, forward, pml.velocity);
        }
    }

    public static boolean PM_GoodPosition() {
        trace_t trace;
        float[] origin = { 0, 0, 0 }, end = { 0, 0, 0 };
        int i;

        if (pm.s.pm_type == Defines.PM_SPECTATOR)
            return true;

        for (i = 0; i < 3; i++)
            origin[i] = end[i] = pm.s.origin[i] * 0.125f;
        trace = pm.trace.trace(origin, pm.mins, pm.maxs, end);

        return !trace.allsolid;
    }

    /**
     * On exit, the origin will have a value that is pre-quantized to the 0.125
     * precision of the network channel and in a valid position.
     */

    public static void PM_SnapPosition() {
        int sign[] = { 0, 0, 0 };
        int i, j, bits;
        short base[] = { 0, 0, 0 };

        // snap velocity to eigths
        for (i = 0; i < 3; i++)
            pm.s.velocity[i] = (short) (pml.velocity[i] * 8);

        for (i = 0; i < 3; i++) {
            if (pml.origin[i] >= 0)
                sign[i] = 1;
            else
                sign[i] = -1;
            pm.s.origin[i] = (short) (pml.origin[i] * 8);
            if (pm.s.origin[i] * 0.125 == pml.origin[i])
                sign[i] = 0;
        }
        Math3D.VectorCopy(pm.s.origin, base);

        // try all combinations
        for (j = 0; j < 8; j++) {
            bits = jitterbits[j];
            Math3D.VectorCopy(base, pm.s.origin);
            for (i = 0; i < 3; i++)
                if ((bits & (1 << i)) != 0)
                    pm.s.origin[i] += sign[i];

            if (PM_GoodPosition())
                return;
        }

        // go back to the last position
        Math3D.VectorCopy(pml.previous_origin, pm.s.origin);
        // Com.DPrintf("using previous_origin\n");
    }

    /** 
     * Snaps the origin of the player move to 0.125 grid.
     */
    public static void PM_InitialSnapPosition() {
        int x, y, z;
        short base[] = { 0, 0, 0 };

        Math3D.VectorCopy(pm.s.origin, base);

        for (z = 0; z < 3; z++) {
            pm.s.origin[2] = (short) (base[2] + offset[z]);
            for (y = 0; y < 3; y++) {
                pm.s.origin[1] = (short) (base[1] + offset[y]);
                for (x = 0; x < 3; x++) {
                    pm.s.origin[0] = (short) (base[0] + offset[x]);
                    if (PM_GoodPosition()) {
                        pml.origin[0] = pm.s.origin[0] * 0.125f;
                        pml.origin[1] = pm.s.origin[1] * 0.125f;
                        pml.origin[2] = pm.s.origin[2] * 0.125f;
                        Math3D.VectorCopy(pm.s.origin,
                                pml.previous_origin);
                        return;
                    }
                }
            }
        }

        Com.DPrintf("Bad InitialSnapPosition\n");
    }

    /**
     * PM_ClampAngles.
     */
    public static void PM_ClampAngles() {
        short temp;
        int i;

        if ((pm.s.pm_flags & pmove_t.PMF_TIME_TELEPORT) != 0) {
            pm.viewangles[Defines.YAW] = Math3D
                    .SHORT2ANGLE(pm.cmd.angles[Defines.YAW]
                            + pm.s.delta_angles[Defines.YAW]);
            pm.viewangles[Defines.PITCH] = 0;
            pm.viewangles[Defines.ROLL] = 0;
        } else {
            // circularly clamp the angles with deltas
            for (i = 0; i < 3; i++) {
                temp = (short) (pm.cmd.angles[i] + pm.s.delta_angles[i]);
                pm.viewangles[i] = Math3D.SHORT2ANGLE(temp);
            }

            // don't let the player look up or down more than 90 degrees
            if (pm.viewangles[Defines.PITCH] > 89 && pm.viewangles[Defines.PITCH] < 180)
                pm.viewangles[Defines.PITCH] = 89;
            else if (pm.viewangles[Defines.PITCH] < 271 && pm.viewangles[Defines.PITCH] >= 180)
                pm.viewangles[Defines.PITCH] = 271;
        }
        Math3D.AngleVectors(pm.viewangles, pml.forward, pml.right, pml.up);
    }

    /**
     * Can be called by either the server or the client.
     */
    public static void Pmove(pmove_t pmove) {
        pm = pmove;

        // clear results
        pm.numtouch = 0;
        Math3D.VectorClear(pm.viewangles);
        pm.viewheight = 0;
        pm.groundentity = null;
        pm.watertype = 0;
        pm.waterlevel = 0;

        pml.groundsurface = null;
        pml.groundcontents = 0;

        // convert origin and velocity to float values
        pml.origin[0] = pm.s.origin[0] * 0.125f;
        pml.origin[1] = pm.s.origin[1] * 0.125f;
        pml.origin[2] = pm.s.origin[2] * 0.125f;

        pml.velocity[0] = pm.s.velocity[0] * 0.125f;
        pml.velocity[1] = pm.s.velocity[1] * 0.125f;
        pml.velocity[2] = pm.s.velocity[2] * 0.125f;

        // save old org in case we get stuck
        Math3D.VectorCopy(pm.s.origin, pml.previous_origin);

        pml.frametime = (pm.cmd.msec & 0xFF) * 0.001f;

        PM_ClampAngles();

        if (pm.s.pm_type == Defines.PM_SPECTATOR) {
            PM_FlyMove(false);
            PM_SnapPosition();
            return;
        }

        if (pm.s.pm_type >= Defines.PM_DEAD) {
            pm.cmd.forwardmove = 0;
            pm.cmd.sidemove = 0;
            pm.cmd.upmove = 0;
        }

        if (pm.s.pm_type == Defines.PM_FREEZE)
            return; // no movement at all

        // set mins, maxs, and viewheight
        PM_CheckDuck();

        if (pm.snapinitial)
            PM_InitialSnapPosition();

        // set groundentity, watertype, and waterlevel
        PM_CatagorizePosition();

        if (pm.s.pm_type == Defines.PM_DEAD)
            PM_DeadMove();

        PM_CheckSpecialMovement();

        // drop timing counter
        if (pm.s.pm_time != 0) {
            int msec;

            // TOD o bugfix cwei
            msec = pm.cmd.msec >>> 3;
            if (msec == 0)
                msec = 1;
            if (msec >= (pm.s.pm_time & 0xFF)) {
                pm.s.pm_flags &= ~(pmove_t.PMF_TIME_WATERJUMP
                        | pmove_t.PMF_TIME_LAND | pmove_t.PMF_TIME_TELEPORT);
                pm.s.pm_time = 0;
            } else
                pm.s.pm_time = (byte) ((pm.s.pm_time & 0xFF) - msec);
        }

        if ((pm.s.pm_flags & pmove_t.PMF_TIME_TELEPORT) != 0) {
        	// teleport pause stays exaclty in place
        } else if ((pm.s.pm_flags & pmove_t.PMF_TIME_WATERJUMP) != 0) {
        	// waterjump has no control, but falls 
            pml.velocity[2] -= pm.s.gravity * pml.frametime;
            if (pml.velocity[2] < 0) { 
            	// cancel as soon as we are falling down again
                pm.s.pm_flags &= ~(pmove_t.PMF_TIME_WATERJUMP
                        | pmove_t.PMF_TIME_LAND | pmove_t.PMF_TIME_TELEPORT);
                pm.s.pm_time = 0;
            }

            PM_StepSlideMove();
        } else {
            PM_CheckJump();

            PM_Friction();

            if (pm.waterlevel >= 2)
                PM_WaterMove();
            else {
                float[] angles = { 0, 0, 0 };

                Math3D.VectorCopy(pm.viewangles, angles);
                
                if (angles[Defines.PITCH] > 180)
                    angles[Defines.PITCH] = angles[Defines.PITCH] - 360;
                
                angles[Defines.PITCH] /= 3;

                Math3D.AngleVectors(angles, pml.forward, pml.right, pml.up);

                PM_AirMove();
            }
        }

        // set groundentity, watertype, and waterlevel for final spot
        PM_CatagorizePosition();
        PM_SnapPosition();
    }
}