playerweapon.java

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

            int pause_frames[] = { 0 };
            int fire_frames[] = { 6, 7, 8, 9, 10, 11, 0 };

            Weapon_Generic(ent, 5, 20, 49, 53, pause_frames, fire_frames,
                    Weapon_HyperBlaster_Fire);
            return true;
        }
    };

    public static EntThinkAdapter Weapon_Machinegun = new EntThinkAdapter() {
    	public String getID() { return "Weapon_Machinegun"; }
        public boolean think(edict_t ent) {

            int pause_frames[] = { 23, 45, 0 };
            int fire_frames[] = { 4, 5, 0 };

            Weapon_Generic(ent, 3, 5, 45, 49, pause_frames, fire_frames,
                    Machinegun_Fire);
            return true;
        }
    };

    public static EntThinkAdapter Weapon_Chaingun = new EntThinkAdapter() {
    	public String getID() { return "Weapon_Chaingun"; }
        public boolean think(edict_t ent) {

            int pause_frames[] = { 38, 43, 51, 61, 0 };
            int fire_frames[] = { 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
                    17, 18, 19, 20, 21, 0 };

            Weapon_Generic(ent, 4, 31, 61, 64, pause_frames, fire_frames,
                    Chaingun_Fire);
            return true;
        }
    };

    /*
     * ======================================================================
     * 
     * SHOTGUN / SUPERSHOTGUN
     * 
     * ======================================================================
     */

    public static EntThinkAdapter weapon_shotgun_fire = new EntThinkAdapter() {
    	public String getID() { return "weapon_shotgun_fire"; }

        public boolean think(edict_t ent) {

            float[] start = { 0, 0, 0 };
            float[] forward = { 0, 0, 0 }, right = { 0, 0, 0 };
            float[] offset = { 0, 0, 0 };
            int damage = 4;
            int kick = 8;

            if (ent.client.ps.gunframe == 9) {
                ent.client.ps.gunframe++;
                return true;
            }

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

            Math3D.VectorScale(forward, -2, ent.client.kick_origin);
            ent.client.kick_angles[0] = -2;

            Math3D.VectorSet(offset, 0, 8, ent.viewheight - 8);
            P_ProjectSource(ent.client, ent.s.origin, offset, forward, right,
                    start);

            if (is_quad) {
                damage *= 4;
                kick *= 4;
            }

            if (GameBase.deathmatch.value != 0)
                GameWeapon.fire_shotgun(ent, start, forward, damage, kick, 500, 500,
                        Defines.DEFAULT_DEATHMATCH_SHOTGUN_COUNT,
                        Defines.MOD_SHOTGUN);
            else
                GameWeapon.fire_shotgun(ent, start, forward, damage, kick, 500, 500,
                        Defines.DEFAULT_SHOTGUN_COUNT, Defines.MOD_SHOTGUN);

            // send muzzle flash
            GameBase.gi.WriteByte(Defines.svc_muzzleflash);

            GameBase.gi.WriteShort(ent.index);
            GameBase.gi.WriteByte(Defines.MZ_SHOTGUN | is_silenced);
            GameBase.gi.multicast(ent.s.origin, Defines.MULTICAST_PVS);

            ent.client.ps.gunframe++;
            PlayerWeapon.PlayerNoise(ent, start, Defines.PNOISE_WEAPON);

            if (0 == ((int) GameBase.dmflags.value & Defines.DF_INFINITE_AMMO))
                ent.client.pers.inventory[ent.client.ammo_index]--;

            return true;
        }
    };

    public static EntThinkAdapter Weapon_Shotgun = new EntThinkAdapter() {
    	public String getID() { return "Weapon_Shotgun"; }
        public boolean think(edict_t ent) {
            int pause_frames[] = { 22, 28, 34, 0 };
            int fire_frames[] = { 8, 9, 0 };

            Weapon_Generic(ent, 7, 18, 36, 39, pause_frames, fire_frames,
                    weapon_shotgun_fire);
            return true;
        }
    };

    public static EntThinkAdapter weapon_supershotgun_fire = new EntThinkAdapter() {
    	public String getID() { return "weapon_supershotgun_fire"; }

        public boolean think(edict_t ent) {

            float[] start = { 0, 0, 0 };
            float[] forward = { 0, 0, 0 }, right = { 0, 0, 0 };
            float[] offset = { 0, 0, 0 };
            float[] v = { 0, 0, 0 };
            int damage = 6;
            int kick = 12;

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

            Math3D.VectorScale(forward, -2, ent.client.kick_origin);
            ent.client.kick_angles[0] = -2;

            Math3D.VectorSet(offset, 0, 8, ent.viewheight - 8);
            P_ProjectSource(ent.client, ent.s.origin, offset, forward, right,
                    start);

            if (is_quad) {
                damage *= 4;
                kick *= 4;
            }

            v[Defines.PITCH] = ent.client.v_angle[Defines.PITCH];
            v[Defines.YAW] = ent.client.v_angle[Defines.YAW] - 5;
            v[Defines.ROLL] = ent.client.v_angle[Defines.ROLL];
            Math3D.AngleVectors(v, forward, null, null);
            GameWeapon.fire_shotgun(ent, start, forward, damage, kick,
                    Defines.DEFAULT_SHOTGUN_HSPREAD,
                    Defines.DEFAULT_SHOTGUN_VSPREAD,
                    Defines.DEFAULT_SSHOTGUN_COUNT / 2, Defines.MOD_SSHOTGUN);
            v[Defines.YAW] = ent.client.v_angle[Defines.YAW] + 5;
            Math3D.AngleVectors(v, forward, null, null);
            GameWeapon.fire_shotgun(ent, start, forward, damage, kick,
                    Defines.DEFAULT_SHOTGUN_HSPREAD,
                    Defines.DEFAULT_SHOTGUN_VSPREAD,
                    Defines.DEFAULT_SSHOTGUN_COUNT / 2, Defines.MOD_SSHOTGUN);

            // send muzzle flash
            GameBase.gi.WriteByte(Defines.svc_muzzleflash);

            GameBase.gi.WriteShort(ent.index);
            GameBase.gi.WriteByte(Defines.MZ_SSHOTGUN | is_silenced);
            GameBase.gi.multicast(ent.s.origin, Defines.MULTICAST_PVS);

            ent.client.ps.gunframe++;
            PlayerWeapon.PlayerNoise(ent, start, Defines.PNOISE_WEAPON);

            if (0 == ((int) GameBase.dmflags.value & Defines.DF_INFINITE_AMMO))
                ent.client.pers.inventory[ent.client.ammo_index] -= 2;

            return true;
        }
    };

    public static EntThinkAdapter Weapon_SuperShotgun = new EntThinkAdapter() {
    	public String getID() { return "Weapon_SuperShotgun"; }
        public boolean think(edict_t ent) {

            int pause_frames[] = { 29, 42, 57, 0 };
            int fire_frames[] = { 7, 0 };

            Weapon_Generic(ent, 6, 17, 57, 61, pause_frames, fire_frames,
                    weapon_supershotgun_fire);
            return true;
        }
    };

    /*
     * ======================================================================
     * 
     * RAILGUN
     * 
     * ======================================================================
     */
    public static EntThinkAdapter weapon_railgun_fire = new EntThinkAdapter() {
    	public String getID() { return "weapon_railgun_fire"; }

        public boolean think(edict_t ent) {

            float[] start = { 0, 0, 0 };
            float[] forward = { 0, 0, 0 }, right = { 0, 0, 0 };
            float[] offset = { 0, 0, 0 };
            int damage;
            int kick;

            if (GameBase.deathmatch.value != 0) { // normal damage is too
                // extreme in dm
                damage = 100;
                kick = 200;
            } else {
                damage = 150;
                kick = 250;
            }

            if (is_quad) {
                damage *= 4;
                kick *= 4;
            }

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

            Math3D.VectorScale(forward, -3, ent.client.kick_origin);
            ent.client.kick_angles[0] = -3;

            Math3D.VectorSet(offset, 0, 7, ent.viewheight - 8);
            P_ProjectSource(ent.client, ent.s.origin, offset, forward, right,
                    start);
            GameWeapon.fire_rail(ent, start, forward, damage, kick);

            // send muzzle flash
            GameBase.gi.WriteByte(Defines.svc_muzzleflash);

            GameBase.gi.WriteShort(ent.index);
            GameBase.gi.WriteByte(Defines.MZ_RAILGUN | is_silenced);
            GameBase.gi.multicast(ent.s.origin, Defines.MULTICAST_PVS);

            ent.client.ps.gunframe++;
            PlayerWeapon.PlayerNoise(ent, start, Defines.PNOISE_WEAPON);

            if (0 == ((int) GameBase.dmflags.value & Defines.DF_INFINITE_AMMO))
                ent.client.pers.inventory[ent.client.ammo_index]--;

            return true;
        }
    };

    public static EntThinkAdapter Weapon_Railgun = new EntThinkAdapter() {
    	public String getID() { return "Weapon_Railgun"; }

        public boolean think(edict_t ent) {

            int pause_frames[] = { 56, 0 };
            int fire_frames[] = { 4, 0 };
            Weapon_Generic(ent, 3, 18, 56, 61, pause_frames, fire_frames,
                    weapon_railgun_fire);
            return true;
        }
    };

    /*
     * ======================================================================
     * 
     * BFG10K
     * 
     * ======================================================================
     */

    public static EntThinkAdapter weapon_bfg_fire = new EntThinkAdapter() {
    	public String getID() { return "weapon_bfg_fire"; }

        public boolean think(edict_t ent) {

            float[] offset = { 0, 0, 0 }, start = { 0, 0, 0 };
            float[] forward = { 0, 0, 0 }, right = { 0, 0, 0 };
            int damage;
            float damage_radius = 1000;

            if (GameBase.deathmatch.value != 0)
                damage = 200;
            else
                damage = 500;

            if (ent.client.ps.gunframe == 9) {
                // send muzzle flash
                GameBase.gi.WriteByte(Defines.svc_muzzleflash);

                GameBase.gi.WriteShort(ent.index);
                GameBase.gi.WriteByte(Defines.MZ_BFG | is_silenced);
                GameBase.gi.multicast(ent.s.origin, Defines.MULTICAST_PVS);

                ent.client.ps.gunframe++;

                PlayerWeapon.PlayerNoise(ent, start, Defines.PNOISE_WEAPON);
                return true;
            }

            // cells can go down during windup (from power armor hits), so
            // check again and abort firing if we don't have enough now
            if (ent.client.pers.inventory[ent.client.ammo_index] < 50) {
                ent.client.ps.gunframe++;
                return true;
            }

            if (is_quad)
                damage *= 4;

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

            Math3D.VectorScale(forward, -2, ent.client.kick_origin);

            // make a big pitch kick with an inverse fall
            ent.client.v_dmg_pitch = -40;
            ent.client.v_dmg_roll = Lib.crandom() * 8;
            ent.client.v_dmg_time = GameBase.level.time + Defines.DAMAGE_TIME;

            Math3D.VectorSet(offset, 8, 8, ent.viewheight - 8);
            P_ProjectSource(ent.client, ent.s.origin, offset, forward, right,
                    start);
            GameWeapon.fire_bfg(ent, start, forward, damage, 400, damage_radius);

            ent.client.ps.gunframe++;

            PlayerWeapon.PlayerNoise(ent, start, Defines.PNOISE_WEAPON);

            if (0 == ((int) GameBase.dmflags.value & Defines.DF_INFINITE_AMMO))
                ent.client.pers.inventory[ent.client.ammo_index] -= 50;

            return true;
        }
    };

    public static EntThinkAdapter Weapon_BFG = new EntThinkAdapter() {
    	public String getID() { return "Weapon_BFG"; }
        public boolean think(edict_t ent) {

            Weapon_Generic(ent, 8, 32, 55, 58, pause_frames, fire_frames,
                    weapon_bfg_fire);
            return true;
        }
    };

    public static boolean is_quad;

    public static byte is_silenced;


    /*
     * ================ 
     * Use_Weapon
     * 
     * Make the weapon ready if there is ammo 
     * ================
     */
    public static ItemUseAdapter Use_Weapon = new ItemUseAdapter() {
    	public String getID() { return "Use_Weapon"; }

        public void use(edict_t ent, gitem_t item) {
            int ammo_index;
            gitem_t ammo_item;

            // see if we're already using it
            if (item == ent.client.pers.weapon)
                return;

            if (item.ammo != null && 0 == GameBase.g_select_empty.value
                    && 0 == (item.flags & Defines.IT_AMMO)) {
                
                ammo_item = GameItems.FindItem(item.ammo);
                ammo_index = GameItems.ITEM_INDEX(ammo_item);

                if (0 == ent.client.pers.inventory[ammo_index]) {
                    GameBase.gi.cprintf(ent, Defines.PRINT_HIGH, "No "
                            + ammo_item.pickup_name + " for "
                            + item.pickup_name + ".\n");
                    return;
                }

                if (ent.client.pers.inventory[ammo_index] < item.quantity) {
                    GameBase.gi.cprintf(ent, Defines.PRINT_HIGH, "Not enough "
                            + ammo_item.pickup_name + " for "
                            + item.pickup_name + ".\n");
                    return;
                }