playerview.java

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

            ent.client.ps.gunangles[i] += 0.2 * delta;
        }

        // gun height
        Math3D.VectorClear(ent.client.ps.gunoffset);
        //	ent.ps.gunorigin[2] += bob;

        // gun_x / gun_y / gun_z are development tools
        for (i = 0; i < 3; i++) {
            ent.client.ps.gunoffset[i] += forward[i] * (GameBase.gun_y.value);
            ent.client.ps.gunoffset[i] += right[i] * GameBase.gun_x.value;
            ent.client.ps.gunoffset[i] += up[i] * (-GameBase.gun_z.value);
        }
    }

    /**
     * Adds a blending effect to the clients view.
     */
    public static void SV_AddBlend(float r, float g, float b, float a,
            float v_blend[]) {
        float a2, a3;

        if (a <= 0)
            return;
        a2 = v_blend[3] + (1 - v_blend[3]) * a; // new total alpha
        a3 = v_blend[3] / a2; // fraction of color from old

        v_blend[0] = v_blend[0] * a3 + r * (1 - a3);
        v_blend[1] = v_blend[1] * a3 + g * (1 - a3);
        v_blend[2] = v_blend[2] * a3 + b * (1 - a3);
        v_blend[3] = a2;
    }

    /**
     * Calculates the blending color according to the players environment.
     */
    public static void SV_CalcBlend(edict_t ent) {
        int contents;
        float[] vieworg = { 0, 0, 0 };
        int remaining;

        ent.client.ps.blend[0] = ent.client.ps.blend[1] = ent.client.ps.blend[2] = ent.client.ps.blend[3] = 0;

        // add for contents
        Math3D.VectorAdd(ent.s.origin, ent.client.ps.viewoffset, vieworg);
        contents = GameBase.gi.pointcontents.pointcontents(vieworg);
        if ((contents & (Defines.CONTENTS_LAVA | Defines.CONTENTS_SLIME | Defines.CONTENTS_WATER)) != 0)
            ent.client.ps.rdflags |= Defines.RDF_UNDERWATER;
        else
            ent.client.ps.rdflags &= ~Defines.RDF_UNDERWATER;

        if ((contents & (Defines.CONTENTS_SOLID | Defines.CONTENTS_LAVA)) != 0)
            SV_AddBlend(1.0f, 0.3f, 0.0f, 0.6f, ent.client.ps.blend);
        else if ((contents & Defines.CONTENTS_SLIME) != 0)
            SV_AddBlend(0.0f, 0.1f, 0.05f, 0.6f, ent.client.ps.blend);
        else if ((contents & Defines.CONTENTS_WATER) != 0)
            SV_AddBlend(0.5f, 0.3f, 0.2f, 0.4f, ent.client.ps.blend);

        // add for powerups
        if (ent.client.quad_framenum > GameBase.level.framenum) {
            remaining = (int) (ent.client.quad_framenum - GameBase.level.framenum);
            if (remaining == 30) // beginning to fade
                GameBase.gi.sound(ent, Defines.CHAN_ITEM, 
                	GameBase.gi.soundindex("items/damage2.wav"), 1, Defines.ATTN_NORM, 0);
            if (remaining > 30 || (remaining & 4) != 0)
                SV_AddBlend(0, 0, 1, 0.08f, ent.client.ps.blend);
        } else if (ent.client.invincible_framenum > GameBase.level.framenum) {
            remaining = (int) ent.client.invincible_framenum - GameBase.level.framenum;
            if (remaining == 30) // beginning to fade
                GameBase.gi.sound(ent, Defines.CHAN_ITEM, 
                	GameBase.gi.soundindex("items/protect2.wav"), 1, Defines.ATTN_NORM, 0);
            if (remaining > 30 || (remaining & 4) != 0)
                SV_AddBlend(1, 1, 0, 0.08f, ent.client.ps.blend);
        } else if (ent.client.enviro_framenum > GameBase.level.framenum) {
            remaining = (int) ent.client.enviro_framenum
                    - GameBase.level.framenum;
            if (remaining == 30) // beginning to fade
                GameBase.gi.sound(ent, Defines.CHAN_ITEM, 
                		GameBase.gi.soundindex("items/airout.wav"), 1, Defines.ATTN_NORM, 0);
            if (remaining > 30 || (remaining & 4) != 0)
                SV_AddBlend(0, 1, 0, 0.08f, ent.client.ps.blend);
        } else if (ent.client.breather_framenum > GameBase.level.framenum) {
            remaining = (int) ent.client.breather_framenum
                    - GameBase.level.framenum;
            if (remaining == 30) // beginning to fade
                GameBase.gi.sound(ent, Defines.CHAN_ITEM, GameBase.gi
                        .soundindex("items/airout.wav"), 1, Defines.ATTN_NORM,
                        0);
            if (remaining > 30 || (remaining & 4) != 0)
                SV_AddBlend(0.4f, 1, 0.4f, 0.04f, ent.client.ps.blend);
        }

        // add for damage
        if (ent.client.damage_alpha > 0)
            SV_AddBlend(ent.client.damage_blend[0], ent.client.damage_blend[1],
                    ent.client.damage_blend[2], ent.client.damage_alpha,
                    ent.client.ps.blend);

        if (ent.client.bonus_alpha > 0)
            SV_AddBlend(0.85f, 0.7f, 0.3f, ent.client.bonus_alpha,
                    ent.client.ps.blend);

        // drop the damage value
        ent.client.damage_alpha -= 0.06;
        if (ent.client.damage_alpha < 0)
            ent.client.damage_alpha = 0;

        // drop the bonus value
        ent.client.bonus_alpha -= 0.1;
        if (ent.client.bonus_alpha < 0)
            ent.client.bonus_alpha = 0;
    }

    /**
     * Calculates damage and effect when a player falls down.
     */
    public static void P_FallingDamage(edict_t ent) {
        float delta;
        int damage;
        float[] dir = { 0, 0, 0 };

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

        if (ent.movetype == Defines.MOVETYPE_NOCLIP)
            return;

        if ((ent.client.oldvelocity[2] < 0)
                && (ent.velocity[2] > ent.client.oldvelocity[2])
                && (null == ent.groundentity)) {
            delta = ent.client.oldvelocity[2];
        } else {
            if (ent.groundentity == null)
                return;
            delta = ent.velocity[2] - ent.client.oldvelocity[2];
        }
        delta = delta * delta * 0.0001f;

        // never take falling damage if completely underwater
        if (ent.waterlevel == 3)
            return;
        if (ent.waterlevel == 2)
            delta *= 0.25;
        if (ent.waterlevel == 1)
            delta *= 0.5;

        if (delta < 1)
            return;

        if (delta < 15) {
            ent.s.event = Defines.EV_FOOTSTEP;
            return;
        }

        ent.client.fall_value = delta * 0.5f;
        if (ent.client.fall_value > 40)
            ent.client.fall_value = 40;
        ent.client.fall_time = GameBase.level.time + Defines.FALL_TIME;

        if (delta > 30) {
            if (ent.health > 0) {
                if (delta >= 55)
                    ent.s.event = Defines.EV_FALLFAR;
                else
                    ent.s.event = Defines.EV_FALL;
            }
            ent.pain_debounce_time = GameBase.level.time; // no normal pain
                                                          // sound
            damage = (int) ((delta - 30) / 2);
            if (damage < 1)
                damage = 1;
            Math3D.VectorSet(dir, 0, 0, 1);

            if (GameBase.deathmatch.value == 0
                    || 0 == ((int) GameBase.dmflags.value & Defines.DF_NO_FALLING))
                GameCombat.T_Damage(ent, GameBase.g_edicts[0],
                        GameBase.g_edicts[0], dir, ent.s.origin,
                        Globals.vec3_origin, damage, 0, 0, Defines.MOD_FALLING);
        } else {
            ent.s.event = Defines.EV_FALLSHORT;
            return;
        }
    }

    /**
     * General effect handling for a player.
     */
    public static void P_WorldEffects() {
        boolean breather;
        boolean envirosuit;
        int waterlevel, old_waterlevel;

        if (current_player.movetype == Defines.MOVETYPE_NOCLIP) {
            current_player.air_finished = GameBase.level.time + 12; // don't
                                                                    // need air
            return;
        }

        waterlevel = current_player.waterlevel;
        old_waterlevel = current_client.old_waterlevel;
        current_client.old_waterlevel = waterlevel;

        breather = current_client.breather_framenum > GameBase.level.framenum;
        envirosuit = current_client.enviro_framenum > GameBase.level.framenum;

        //
        // if just entered a water volume, play a sound
        //
        if (old_waterlevel == 0 && waterlevel != 0) {
            PlayerWeapon.PlayerNoise(current_player, current_player.s.origin,
                    Defines.PNOISE_SELF);
            if ((current_player.watertype & Defines.CONTENTS_LAVA) != 0)
                GameBase.gi.sound(current_player, Defines.CHAN_BODY,
                        GameBase.gi.soundindex("player/lava_in.wav"), 1,
                        Defines.ATTN_NORM, 0);
            else if ((current_player.watertype & Defines.CONTENTS_SLIME) != 0)
                GameBase.gi.sound(current_player, Defines.CHAN_BODY,
                        GameBase.gi.soundindex("player/watr_in.wav"), 1,
                        Defines.ATTN_NORM, 0);
            else if ((current_player.watertype & Defines.CONTENTS_WATER) != 0)
                GameBase.gi.sound(current_player, Defines.CHAN_BODY,
                        GameBase.gi.soundindex("player/watr_in.wav"), 1,
                        Defines.ATTN_NORM, 0);
            current_player.flags |= Defines.FL_INWATER;

            // clear damage_debounce, so the pain sound will play immediately
            current_player.damage_debounce_time = GameBase.level.time - 1;
        }

        //
        // if just completely exited a water volume, play a sound
        //
        if (old_waterlevel != 0 && waterlevel == 0) {
            PlayerWeapon.PlayerNoise(current_player, current_player.s.origin,
                    Defines.PNOISE_SELF);
            GameBase.gi
                    .sound(current_player, Defines.CHAN_BODY, GameBase.gi
                            .soundindex("player/watr_out.wav"), 1,
                            Defines.ATTN_NORM, 0);
            current_player.flags &= ~Defines.FL_INWATER;
        }

        //
        // check for head just going under water
        //
        if (old_waterlevel != 3 && waterlevel == 3) {
            GameBase.gi.sound(current_player, Defines.CHAN_BODY, GameBase.gi
                    .soundindex("player/watr_un.wav"), 1, Defines.ATTN_NORM, 0);
        }

        //
        // check for head just coming out of water
        //
        if (old_waterlevel == 3 && waterlevel != 3) {
            if (current_player.air_finished < GameBase.level.time) { // gasp for
                                                                     // air
                GameBase.gi.sound(current_player, Defines.CHAN_VOICE,
                        GameBase.gi.soundindex("player/gasp1.wav"), 1,
                        Defines.ATTN_NORM, 0);
                PlayerWeapon.PlayerNoise(current_player, current_player.s.origin,
                        Defines.PNOISE_SELF);
            } else if (current_player.air_finished < GameBase.level.time + 11) { // just
                                                                                 // break
                                                                                 // surface
                GameBase.gi.sound(current_player, Defines.CHAN_VOICE,
                        GameBase.gi.soundindex("player/gasp2.wav"), 1,
                        Defines.ATTN_NORM, 0);
            }
        }

        //
        // check for drowning
        //
        if (waterlevel == 3) {
            // breather or envirosuit give air
            if (breather || envirosuit) {
                current_player.air_finished = GameBase.level.time + 10;

                if (((int) (current_client.breather_framenum - GameBase.level.framenum) % 25) == 0) {
                    if (current_client.breather_sound == 0)
                        GameBase.gi.sound(current_player, Defines.CHAN_AUTO,
                                GameBase.gi.soundindex("player/u_breath1.wav"),
                                1, Defines.ATTN_NORM, 0);
                    else
                        GameBase.gi.sound(current_player, Defines.CHAN_AUTO,
                                GameBase.gi.soundindex("player/u_breath2.wav"),
                                1, Defines.ATTN_NORM, 0);
                    current_client.breather_sound ^= 1;
                    PlayerWeapon.PlayerNoise(current_player,
                            current_player.s.origin, Defines.PNOISE_SELF);
                    //FIXME: release a bubble?
                }
            }

            // if out of air, start drowning
            if (current_player.air_finished < GameBase.level.time) { // drown!
                if (current_player.client.next_drown_time < GameBase.level.time
                        && current_player.health > 0) {
                    current_player.client.next_drown_time = GameBase.level.time + 1;

                    // take more damage the longer underwater
                    current_player.dmg += 2;
                    if (current_player.dmg > 15)
                        current_player.dmg = 15;

                    // play a gurp sound instead of a normal pain sound
                    if (current_player.health <= current_player.dmg)
                        GameBase.gi.sound(current_player, Defines.CHAN_VOICE,
                                GameBase.gi.soundindex("player/drown1.wav"), 1,
                                Defines.ATTN_NORM, 0);
                    else if ((Lib.rand() & 1) != 0)
                        GameBase.gi.sound(current_player, Defines.CHAN_VOICE,
                                GameBase.gi.soundindex("*gurp1.wav"), 1,
                                Defines.ATTN_NORM, 0);
                    else
                        GameBase.gi.sound(current_player, Defines.CHAN_VOICE,
                                GameBase.gi.soundindex("*gurp2.wav"), 1,
                                Defines.ATTN_NORM, 0);

                    current_player.pain_debounce_time = GameBase.level.time;

                    GameCombat.T_Damage(current_player, GameBase.g_edicts[0],
                            GameBase.g_edicts[0], Globals.vec3_origin,
                            current_player.s.origin, Globals.vec3_origin,
                            current_player.dmg, 0, Defines.DAMAGE_NO_ARMOR,
                            Defines.MOD_WATER);
                }
            }
        } else {
            current_player.air_finished = GameBase.level.time + 12;
            current_player.dmg = 2;
        }

        //
        // check for sizzle damage
        //
        if (waterlevel != 0
                && 0 != (current_player.watertype & (Defines.CONTENTS_LAVA | Defines.CONTENTS_SLIME))) {
            if ((current_player.watertype & Defines.CONTENTS_LAVA) != 0) {
                if (current_player.health > 0
                        && current_player.pain_debounce_time <= GameBase.level.time
                        && current_client.invincible_framenum < GameBase.level.framenum) {
                    if ((Lib.rand() & 1) != 0)
                        GameBase.gi.sound(current_player, Defines.CHAN_VOICE,
                                GameBase.gi.soundindex("player/burn1.wav"), 1,
                                Defines.ATTN_NORM, 0);
                    else
                        GameBase.gi.sound(current_player, Defines.CHAN_VOICE,
                                GameBase.gi.soundindex("player/burn2.wav"), 1,
                                Defines.ATTN_NORM, 0);
                    current_player.pain_debounce_time = GameBase.level.time + 1;
                }

                if (envirosuit) // take 1/3 damage with envirosuit