m_boss31.java

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

    public final static int FRAME_walk21 = 183;

    public final static int FRAME_walk22 = 184;

    public final static int FRAME_walk23 = 185;

    public final static int FRAME_walk24 = 186;

    public final static int FRAME_walk25 = 187;

    public final static float MODEL_SCALE = 1.000000f;

    /*
     * ==============================================================================
     * 
     * jorg
     * 
     * ==============================================================================
     */

    static int sound_pain1;

    static int sound_pain2;

    static int sound_pain3;

    static int sound_idle;

    static int sound_death;

    static int sound_search1;

    static int sound_search2;

    static int sound_search3;

    static int sound_attack1;

    static int sound_attack2;

    static int sound_firegun;

    static int sound_step_left;

    static int sound_step_right;

    static int sound_death_hit;

    /*
     * static EntThinkAdapter xxx = new EntThinkAdapter() { public boolean
     * think(edict_t self) { return true; } };
     */

    static EntThinkAdapter jorg_search = new EntThinkAdapter() {
    	public String getID() { return "jorg_search"; }
        public boolean think(edict_t self) {
            float r;

            r = Lib.random();

            if (r <= 0.3)
                GameBase.gi.sound(self, Defines.CHAN_VOICE, sound_search1, 1,
                        Defines.ATTN_NORM, 0);
            else if (r <= 0.6)
                GameBase.gi.sound(self, Defines.CHAN_VOICE, sound_search2, 1,
                        Defines.ATTN_NORM, 0);
            else
                GameBase.gi.sound(self, Defines.CHAN_VOICE, sound_search3, 1,
                        Defines.ATTN_NORM, 0);
            return true;
        }
    };

    static EntThinkAdapter jorg_idle = new EntThinkAdapter() {
    	public String getID() { return "jorg_idle"; }
        public boolean think(edict_t self) {
            GameBase.gi.sound(self, Defines.CHAN_VOICE, sound_idle, 1,
                    Defines.ATTN_NORM, 0);
            return true;
        }
    };

    static EntThinkAdapter jorg_death_hit = new EntThinkAdapter() {
    	public String getID() { return "jorg_death_hit"; }
        public boolean think(edict_t self) {
            GameBase.gi.sound(self, Defines.CHAN_BODY, sound_death_hit, 1,
                    Defines.ATTN_NORM, 0);
            return true;
        }
    };

    static EntThinkAdapter jorg_step_left = new EntThinkAdapter() {
    	public String getID() { return "jorg_step_left"; }
        public boolean think(edict_t self) {
            GameBase.gi.sound(self, Defines.CHAN_BODY, sound_step_left, 1,
                    Defines.ATTN_NORM, 0);
            return true;
        }
    };

    static EntThinkAdapter jorg_step_right = new EntThinkAdapter() {
    	public String getID() { return "jorg_step_right"; }
        public boolean think(edict_t self) {
            GameBase.gi.sound(self, Defines.CHAN_BODY, sound_step_right, 1,
                    Defines.ATTN_NORM, 0);
            return true;
        }
    };

    static EntThinkAdapter jorg_stand = new EntThinkAdapter() {
    	public String getID() { return "jorg_stand"; }
        public boolean think(edict_t self) {
            self.monsterinfo.currentmove = jorg_move_stand;
            return true;
        }
    };

    static EntThinkAdapter jorg_reattack1 = new EntThinkAdapter() {
    	public String getID() { return "jorg_reattack1"; }
        public boolean think(edict_t self) {
            if (GameUtil.visible(self, self.enemy))
                if (Lib.random() < 0.9)
                    self.monsterinfo.currentmove = jorg_move_attack1;
                else {
                    self.s.sound = 0;
                    self.monsterinfo.currentmove = jorg_move_end_attack1;
                }
            else {
                self.s.sound = 0;
                self.monsterinfo.currentmove = jorg_move_end_attack1;
            }
            return true;
        }
    };

    static EntThinkAdapter jorg_attack1 = new EntThinkAdapter() {
    	public String getID() { return "jorg_attack1"; }
        public boolean think(edict_t self) {
            self.monsterinfo.currentmove = jorg_move_attack1;
            return true;
        }
    };

    static EntPainAdapter jorg_pain = new EntPainAdapter() {
    	public String getID() { return "jorg_pain"; }
        public void pain(edict_t self, edict_t other, float kick, int damage) {
            if (self.health < (self.max_health / 2))
                self.s.skinnum = 1;

            self.s.sound = 0;

            if (GameBase.level.time < self.pain_debounce_time)
                return;

            // Lessen the chance of him going into his pain frames if he takes
            // little damage
            if (damage <= 40)
                if (Lib.random() <= 0.6)
                    return;

            /*
             * If he's entering his attack1 or using attack1, lessen the chance
             * of him going into pain
             */

            if ((self.s.frame >= FRAME_attak101)
                    && (self.s.frame <= FRAME_attak108))
                if (Lib.random() <= 0.005)
                    return;

            if ((self.s.frame >= FRAME_attak109)
                    && (self.s.frame <= FRAME_attak114))
                if (Lib.random() <= 0.00005)
                    return;

            if ((self.s.frame >= FRAME_attak201)
                    && (self.s.frame <= FRAME_attak208))
                if (Lib.random() <= 0.005)
                    return;

            self.pain_debounce_time = GameBase.level.time + 3;
            if (GameBase.skill.value == 3)
                return; // no pain anims in nightmare

            if (damage <= 50) {
                GameBase.gi.sound(self, Defines.CHAN_VOICE, sound_pain1, 1,
                        Defines.ATTN_NORM, 0);
                self.monsterinfo.currentmove = jorg_move_pain1;
            } else if (damage <= 100) {
                GameBase.gi.sound(self, Defines.CHAN_VOICE, sound_pain2, 1,
                        Defines.ATTN_NORM, 0);
                self.monsterinfo.currentmove = jorg_move_pain2;
            } else {
                if (Lib.random() <= 0.3) {
                    GameBase.gi.sound(self, Defines.CHAN_VOICE, sound_pain3, 1,
                            Defines.ATTN_NORM, 0);
                    self.monsterinfo.currentmove = jorg_move_pain3;
                }
            }

        }
    };

    static EntThinkAdapter jorgBFG = new EntThinkAdapter() {
    	public String getID() { return "jorgBFG"; }
        public boolean think(edict_t self) {
            float[] forward = { 0, 0, 0 }, right = { 0, 0, 0 };

            float[] start = { 0, 0, 0 };
            float[] dir = { 0, 0, 0 };
            float[] vec = { 0, 0, 0 };

            Math3D.AngleVectors(self.s.angles, forward, right, null);
            Math3D.G_ProjectSource(self.s.origin,
                    M_Flash.monster_flash_offset[Defines.MZ2_JORG_BFG_1],
                    forward, right, start);

            Math3D.VectorCopy(self.enemy.s.origin, vec);
            vec[2] += self.enemy.viewheight;
            Math3D.VectorSubtract(vec, start, dir);
            Math3D.VectorNormalize(dir);
            GameBase.gi.sound(self, Defines.CHAN_VOICE, sound_attack2, 1,
                    Defines.ATTN_NORM, 0);
            /*
             * void monster_fire_bfg (edict_t self, float [] start, float []
             * aimdir, int damage, int speed, int kick, float damage_radius, int
             * flashtype)
             */
            Monster.monster_fire_bfg(self, start, dir, 50, 300, 100, 200,
                    Defines.MZ2_JORG_BFG_1);
            return true;
        }
    };

    static EntThinkAdapter jorg_firebullet_right = new EntThinkAdapter() {
    	public String getID() { return "jorg_firebullet_right"; }
        public boolean think(edict_t self) {
            float[] forward = { 0, 0, 0 }, right = { 0, 0, 0 }, target = { 0,
                    0, 0 };
            float[] start = { 0, 0, 0 };

            Math3D.AngleVectors(self.s.angles, forward, right, null);
            Math3D
                    .G_ProjectSource(
                            self.s.origin,
                            M_Flash.monster_flash_offset[Defines.MZ2_JORG_MACHINEGUN_R1],
                            forward, right, start);

            Math3D.VectorMA(self.enemy.s.origin, -0.2f, self.enemy.velocity,
                    target);
            target[2] += self.enemy.viewheight;
            Math3D.VectorSubtract(target, start, forward);
            Math3D.VectorNormalize(forward);

            Monster.monster_fire_bullet(self, start, forward, 6, 4,
                    Defines.DEFAULT_BULLET_HSPREAD,
                    Defines.DEFAULT_BULLET_VSPREAD,
                    Defines.MZ2_JORG_MACHINEGUN_R1);
            return true;
        }
    };

    static EntThinkAdapter jorg_firebullet_left = new EntThinkAdapter() {
    	public String getID() { return "jorg_firebullet_left"; }
        public boolean think(edict_t self) {
            float[] forward = { 0, 0, 0 }, right = { 0, 0, 0 }, target = { 0,
                    0, 0 };
            float[] start = { 0, 0, 0 };

            Math3D.AngleVectors(self.s.angles, forward, right, null);
            Math3D
                    .G_ProjectSource(
                            self.s.origin,
                            M_Flash.monster_flash_offset[Defines.MZ2_JORG_MACHINEGUN_L1],
                            forward, right, start);

            Math3D.VectorMA(self.enemy.s.origin, -0.2f, self.enemy.velocity,
                    target);
            target[2] += self.enemy.viewheight;
            Math3D.VectorSubtract(target, start, forward);
            Math3D.VectorNormalize(forward);

            Monster.monster_fire_bullet(self, start, forward, 6, 4,
                    Defines.DEFAULT_BULLET_HSPREAD,
                    Defines.DEFAULT_BULLET_VSPREAD,
                    Defines.MZ2_JORG_MACHINEGUN_L1);
            return true;
        }
    };

    static EntThinkAdapter jorg_firebullet = new EntThinkAdapter() {
    	public String getID() { return "jorg_firebullet"; }
        public boolean think(edict_t self) {
            jorg_firebullet_left.think(self);
            jorg_firebullet_right.think(self);
            return true;
        }
    };

    static EntThinkAdapter jorg_attack = new EntThinkAdapter() {
    	public String getID() { return "jorg_attack"; }
        public boolean think(edict_t self) {
            float[] vec = { 0, 0, 0 };
            float range = 0;

            Math3D.VectorSubtract(self.enemy.s.origin, self.s.origin, vec);
            range = Math3D.VectorLength(vec);

            if (Lib.random() <= 0.75) {
                GameBase.gi.sound(self, Defines.CHAN_VOICE, sound_attack1, 1,
                        Defines.ATTN_NORM, 0);
                self.s.sound = GameBase.gi.soundindex("boss3/w_loop.wav");
                self.monsterinfo.currentmove = jorg_move_start_attack1;
            } else {
                GameBase.gi.sound(self, Defines.CHAN_VOICE, sound_attack2, 1,
                        Defines.ATTN_NORM, 0);
                self.monsterinfo.currentmove = jorg_move_attack2;
            }
            return true;
        }
    };

    /** Was disabled. RST. */
    static EntThinkAdapter jorg_dead = new EntThinkAdapter() {
    	public String getID() { return "jorg_dead"; }
        public boolean think(edict_t self) {
            /*
             * edict_t tempent;
             * 
             * //VectorSet (self.mins, -16, -16, -24); //VectorSet (self.maxs,
             * 16, 16, -8); // Jorg is on modelindex2. Do not clear him.
             * VectorSet( self.mins, -60, -60, 0); VectorSet(self.maxs, 60, 60,
             * 72); self.movetype= MOVETYPE_TOSS; self.nextthink= 0;
             * gi.linkentity(self);
             * 
             * tempent= G_Spawn(); VectorCopy(self.s.origin, tempent.s.origin);
             * VectorCopy(self.s.angles, tempent.s.angles); tempent.killtarget=
             * self.killtarget; tempent.target= self.target; tempent.activator=
             * self.enemy; self.killtarget= 0; self.target= 0;
             * SP_monster_makron(tempent);
             *  
             */
            return true;
        }
    };

    static EntDieAdapter jorg_die = new EntDieAdapter() {
    	public String getID() { return "jorg_die"; }
        public void die(edict_t self, edict_t inflictor, edict_t attacker,
                int damage, float[] point) {
            GameBase.gi.sound(self, Defines.CHAN_VOICE, sound_death, 1,
                    Defines.ATTN_NORM, 0);
            self.deadflag = Defines.DEAD_DEAD;
            self.takedamage = Defines.DAMAGE_NO;
            self.s.sound = 0;
            self.count = 0;
            self.monsterinfo.currentmove = jorg_move_death;
            return;
        }
    };

    static EntThinkAdapter Jorg_CheckAttack = new EntThinkAdapter() {
    	public String getID() { return "Jorg_CheckAttack"; }
        public boolean think(edict_t self) {
            float[] spot1 = { 0, 0, 0 }, spot2 = { 0, 0, 0 };
            float[] temp = { 0, 0, 0 };
            float chance;
            trace_t tr;
            boolean enemy_infront;
            int enemy_range;
            float enemy_yaw;

            if (self.enemy.health > 0) {
                // see if any entities are in the way of the shot
                Math3D.VectorCopy(self.s.origin, spot1);
                spot1[2] += self.viewheight;
                Math3D.VectorCopy(self.enemy.s.origin, spot2);
                spot2[2] += self.enemy.viewheight;

                tr = GameBase.gi.trace(spot1, null, null, spot2, self,
                        Defines.CONTENTS_SOLID | Defines.CONTENTS_MONSTER
                                | Defines.CONTENTS_SLIME
                                | Defines.CONTENTS_LAVA);

                // do we have a clear shot?
                if (tr.ent != self.enemy)
                    return false;
            }

            enemy_infront = GameUtil.infront(self, self.enemy);
            enemy_range = GameUtil.range(self, self.enemy);
            Math3D.VectorSubtract(self.enemy.s.origin, self.s.origin, temp);
            enemy_yaw = Math3D.vectoyaw(temp);

            self.ideal_yaw = enemy_yaw;

            // melee attack
            if (enemy_range == Defines.RANGE_MELEE) {
                if (self.monsterinfo.melee != null)
                    self.monsterinfo.attack_state = Defines.AS_MELEE;
                else
                    self.monsterinfo.attack_state = Defines.AS_MISSILE;
                return true;
            }