playerview.java

JAKE2用ＪＡＶＡ写的queck2的３Ｄ游戏开发引擎

                    GameCombat.T_Damage(current_player, GameBase.g_edicts[0],
                            GameBase.g_edicts[0], Globals.vec3_origin,
                            current_player.s.origin, Globals.vec3_origin,
                            1 * waterlevel, 0, 0, Defines.MOD_LAVA);
                else
                    GameCombat.T_Damage(current_player, GameBase.g_edicts[0],
                            GameBase.g_edicts[0], Globals.vec3_origin,
                            current_player.s.origin, Globals.vec3_origin,
                            3 * waterlevel, 0, 0, Defines.MOD_LAVA);
            }

            if ((current_player.watertype & Defines.CONTENTS_SLIME) != 0) {
                if (!envirosuit) { // no damage from slime with envirosuit
                    GameCombat.T_Damage(current_player, GameBase.g_edicts[0],
                            GameBase.g_edicts[0], Globals.vec3_origin,
                            current_player.s.origin, Globals.vec3_origin,
                            1 * waterlevel, 0, 0, Defines.MOD_SLIME);
                }
            }
        }
    }

    /*
     * =============== 
     * G_SetClientEffects 
     * ===============
     */
    public static void G_SetClientEffects(edict_t ent) {
        int pa_type;
        int remaining;

        ent.s.effects = 0;
        ent.s.renderfx = 0;

        if (ent.health <= 0 || GameBase.level.intermissiontime != 0)
            return;

        if (ent.powerarmor_time > GameBase.level.time) {
            pa_type = GameItems.PowerArmorType(ent);
            if (pa_type == Defines.POWER_ARMOR_SCREEN) {
                ent.s.effects |= Defines.EF_POWERSCREEN;
            } else if (pa_type == Defines.POWER_ARMOR_SHIELD) {
                ent.s.effects |= Defines.EF_COLOR_SHELL;
                ent.s.renderfx |= Defines.RF_SHELL_GREEN;
            }
        }

        if (ent.client.quad_framenum > GameBase.level.framenum) {
            remaining = (int) ent.client.quad_framenum
                    - GameBase.level.framenum;
            if (remaining > 30 || 0 != (remaining & 4))
                ent.s.effects |= Defines.EF_QUAD;
        }

        if (ent.client.invincible_framenum > GameBase.level.framenum) {
            remaining = (int) ent.client.invincible_framenum
                    - GameBase.level.framenum;
            if (remaining > 30 || 0 != (remaining & 4))
                ent.s.effects |= Defines.EF_PENT;
        }

        // show cheaters!!!
        if ((ent.flags & Defines.FL_GODMODE) != 0) {
            ent.s.effects |= Defines.EF_COLOR_SHELL;
            ent.s.renderfx |= (Defines.RF_SHELL_RED | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_BLUE);
        }
    }

    /*
     * =============== 
     * G_SetClientEvent 
     * ===============
     */
    public static void G_SetClientEvent(edict_t ent) {
        if (ent.s.event != 0)
            return;

        if (ent.groundentity != null && xyspeed > 225) {
            if ((int) (current_client.bobtime + bobmove) != bobcycle)
                ent.s.event = Defines.EV_FOOTSTEP;
        }
    }

    /*
     * =============== 
     * G_SetClientSound 
     * ===============
     */
    public static void G_SetClientSound(edict_t ent) {
        String weap;

        if (ent.client.pers.game_helpchanged != GameBase.game.helpchanged) {
            ent.client.pers.game_helpchanged = GameBase.game.helpchanged;
            ent.client.pers.helpchanged = 1;
        }

        // help beep (no more than three times)
        if (ent.client.pers.helpchanged != 0
                && ent.client.pers.helpchanged <= 3
                && 0 == (GameBase.level.framenum & 63)) {
            ent.client.pers.helpchanged++;
            GameBase.gi.sound(ent, Defines.CHAN_VOICE, GameBase.gi
                    .soundindex("misc/pc_up.wav"), 1, Defines.ATTN_STATIC, 0);
        }

        if (ent.client.pers.weapon != null)
            weap = ent.client.pers.weapon.classname;
        else
            weap = "";

        if (ent.waterlevel != 0
                && 0 != (ent.watertype & (Defines.CONTENTS_LAVA | Defines.CONTENTS_SLIME)))
            ent.s.sound = GameBase.snd_fry;
        else if (Lib.strcmp(weap, "weapon_railgun") == 0)
            ent.s.sound = GameBase.gi.soundindex("weapons/rg_hum.wav");
        else if (Lib.strcmp(weap, "weapon_bfg") == 0)
            ent.s.sound = GameBase.gi.soundindex("weapons/bfg_hum.wav");
        else if (ent.client.weapon_sound != 0)
            ent.s.sound = ent.client.weapon_sound;
        else
            ent.s.sound = 0;
    }

    /*
     * =============== 
     * G_SetClientFrame 
     * ===============
     */
    public static void G_SetClientFrame(edict_t ent) {
        gclient_t client;
        boolean duck, run;

        if (ent.s.modelindex != 255)
            return; // not in the player model

        client = ent.client;

        if ((client.ps.pmove.pm_flags & pmove_t.PMF_DUCKED) != 0)
            duck = true;
        else
            duck = false;
        if (xyspeed != 0)
            run = true;
        else
            run = false;

        boolean skip = false;
        // check for stand/duck and stop/go transitions
        if (duck != client.anim_duck
                && client.anim_priority < Defines.ANIM_DEATH)
            skip = true;

        if (run != client.anim_run
                && client.anim_priority == Defines.ANIM_BASIC)
            skip = true;

        if (null == ent.groundentity
                && client.anim_priority <= Defines.ANIM_WAVE)
            skip = true;

        if (!skip) {
            if (client.anim_priority == Defines.ANIM_REVERSE) {
                if (ent.s.frame > client.anim_end) {
                    ent.s.frame--;
                    return;
                }
            } else if (ent.s.frame < client.anim_end) { // continue an animation
                ent.s.frame++;
                return;
            }

            if (client.anim_priority == Defines.ANIM_DEATH)
                return; // stay there
            if (client.anim_priority == Defines.ANIM_JUMP) {
                if (null == ent.groundentity)
                    return; // stay there
                ent.client.anim_priority = Defines.ANIM_WAVE;
                ent.s.frame = M_Player.FRAME_jump3;
                ent.client.anim_end = M_Player.FRAME_jump6;
                return;
            }
        }

        // return to either a running or standing frame
        client.anim_priority = Defines.ANIM_BASIC;
        client.anim_duck = duck;
        client.anim_run = run;

        if (null == ent.groundentity) {
            client.anim_priority = Defines.ANIM_JUMP;
            if (ent.s.frame != M_Player.FRAME_jump2)
                ent.s.frame = M_Player.FRAME_jump1;
            client.anim_end = M_Player.FRAME_jump2;
        } else if (run) { // running
            if (duck) {
                ent.s.frame = M_Player.FRAME_crwalk1;
                client.anim_end = M_Player.FRAME_crwalk6;
            } else {
                ent.s.frame = M_Player.FRAME_run1;
                client.anim_end = M_Player.FRAME_run6;
            }
        } else { // standing
            if (duck) {
                ent.s.frame = M_Player.FRAME_crstnd01;
                client.anim_end = M_Player.FRAME_crstnd19;
            } else {
                ent.s.frame = M_Player.FRAME_stand01;
                client.anim_end = M_Player.FRAME_stand40;
            }
        }
    }

    
    /**
     * Called for each player at the end of the server frame and right after
     * spawning.
     */
    public static void ClientEndServerFrame(edict_t ent) {
        float bobtime;
        int i;

        current_player = ent;
        current_client = ent.client;

        //
        // If the origin or velocity have changed since ClientThink(),
        // update the pmove values. This will happen when the client
        // is pushed by a bmodel or kicked by an explosion.
        // 
        // If it wasn't updated here, the view position would lag a frame
        // behind the body position when pushed -- "sinking into plats"
        //
        for (i = 0; i < 3; i++) {
            current_client.ps.pmove.origin[i] = (short) (ent.s.origin[i] * 8.0);
            current_client.ps.pmove.velocity[i] = (short) (ent.velocity[i] * 8.0);
        }

        //
        // If the end of unit layout is displayed, don't give
        // the player any normal movement attributes
        //
        if (GameBase.level.intermissiontime != 0) {
            // FIXME: add view drifting here?
            current_client.ps.blend[3] = 0;
            current_client.ps.fov = 90;
            PlayerHud.G_SetStats(ent);
            return;
        }

        Math3D.AngleVectors(ent.client.v_angle, forward, right, up);

        // burn from lava, etc
        P_WorldEffects();

        //
        // set model angles from view angles so other things in
        // the world can tell which direction you are looking
        //
        if (ent.client.v_angle[Defines.PITCH] > 180)
            ent.s.angles[Defines.PITCH] = (-360 + ent.client.v_angle[Defines.PITCH]) / 3;
        else
            ent.s.angles[Defines.PITCH] = ent.client.v_angle[Defines.PITCH] / 3;
        ent.s.angles[Defines.YAW] = ent.client.v_angle[Defines.YAW];
        ent.s.angles[Defines.ROLL] = 0;
        ent.s.angles[Defines.ROLL] = SV_CalcRoll(ent.s.angles, ent.velocity) * 4;

        //
        // calculate speed and cycle to be used for
        // all cyclic walking effects
        //
        xyspeed = (float) Math.sqrt(ent.velocity[0] * ent.velocity[0]
                + ent.velocity[1] * ent.velocity[1]);

        if (xyspeed < 5) {
            bobmove = 0;
            current_client.bobtime = 0; // start at beginning of cycle again
        } else if (ent.groundentity != null) { // so bobbing only cycles when on
                                               // ground
            if (xyspeed > 210)
                bobmove = 0.25f;
            else if (xyspeed > 100)
                bobmove = 0.125f;
            else
                bobmove = 0.0625f;
        }

        bobtime = (current_client.bobtime += bobmove);

        if ((current_client.ps.pmove.pm_flags & pmove_t.PMF_DUCKED) != 0)
            bobtime *= 4;

        bobcycle = (int) bobtime;
        bobfracsin = (float) Math.abs(Math.sin(bobtime * Math.PI));

        // detect hitting the floor
        P_FallingDamage(ent);

        // apply all the damage taken this frame
        P_DamageFeedback(ent);

        // determine the view offsets
        SV_CalcViewOffset(ent);

        // determine the gun offsets
        SV_CalcGunOffset(ent);

        // determine the full screen color blend
        // must be after viewoffset, so eye contents can be
        // accurately determined
        // FIXME: with client prediction, the contents
        // should be determined by the client
        SV_CalcBlend(ent);

        // chase cam stuff
        if (ent.client.resp.spectator)
            PlayerHud.G_SetSpectatorStats(ent);
        else
            PlayerHud.G_SetStats(ent);
        PlayerHud.G_CheckChaseStats(ent);

        G_SetClientEvent(ent);

        G_SetClientEffects(ent);

        G_SetClientSound(ent);

        G_SetClientFrame(ent);

        Math3D.VectorCopy(ent.velocity, ent.client.oldvelocity);
        Math3D.VectorCopy(ent.client.ps.viewangles, ent.client.oldviewangles);

        // clear weapon kicks
        Math3D.VectorClear(ent.client.kick_origin);
        Math3D.VectorClear(ent.client.kick_angles);

        // if the scoreboard is up, update it
        if (ent.client.showscores && 0 == (GameBase.level.framenum & 31)) {
            PlayerHud.DeathmatchScoreboardMessage(ent, ent.enemy);
            GameBase.gi.unicast(ent, false);
        }
    }

    public static float xyspeed;

    public static float bobmove;

    public static int bobcycle; // odd cycles are right foot going forward

    public static float bobfracsin; // sin(bobfrac*M_PI)}

    private static int xxxi = 0;
}