m_boss2.java

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

    public final static int FRAME_death31 = 161;

    public final static int FRAME_death32 = 162;

    public final static int FRAME_death33 = 163;

    public final static int FRAME_death34 = 164;

    public final static int FRAME_death35 = 165;

    public final static int FRAME_death36 = 166;

    public final static int FRAME_death37 = 167;

    public final static int FRAME_death38 = 168;

    public final static int FRAME_death39 = 169;

    public final static int FRAME_death40 = 170;

    public final static int FRAME_death41 = 171;

    public final static int FRAME_death42 = 172;

    public final static int FRAME_death43 = 173;

    public final static int FRAME_death44 = 174;

    public final static int FRAME_death45 = 175;

    public final static int FRAME_death46 = 176;

    public final static int FRAME_death47 = 177;

    public final static int FRAME_death48 = 178;

    public final static int FRAME_death49 = 179;

    public final static int FRAME_death50 = 180;

    public final static float MODEL_SCALE = 1.000000f;

    static int sound_pain1;

    static int sound_pain2;

    static int sound_pain3;

    static int sound_death;

    static int sound_search1;

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

    static EntThinkAdapter boss2_run = new EntThinkAdapter() {
    	public String getID() { return "boss2_run"; }
        public boolean think(edict_t self) {
            if ((self.monsterinfo.aiflags & Defines.AI_STAND_GROUND) != 0)
                self.monsterinfo.currentmove = boss2_move_stand;
            else
                self.monsterinfo.currentmove = boss2_move_run;
            return true;
        }
    };

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

            self.monsterinfo.currentmove = boss2_move_walk;
            return true;
        }
    };

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

            float range;

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

            if (range <= 125) {
                self.monsterinfo.currentmove = boss2_move_attack_pre_mg;
            } else {
                if (Lib.random() <= 0.6)
                    self.monsterinfo.currentmove = boss2_move_attack_pre_mg;
                else
                    self.monsterinfo.currentmove = boss2_move_attack_rocket;
            }
            return true;
        }
    };

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

    static EntThinkAdapter boss2_reattack_mg = new EntThinkAdapter() {
    	public String getID() { return "boss2_reattack_mg"; }
        public boolean think(edict_t self) {
            if (GameUtil.infront(self, self.enemy))
                if (Lib.random() <= 0.7)
                    self.monsterinfo.currentmove = boss2_move_attack_mg;
                else
                    self.monsterinfo.currentmove = boss2_move_attack_post_mg;
            else
                self.monsterinfo.currentmove = boss2_move_attack_post_mg;
            return true;
        }
    };

    static EntPainAdapter boss2_pain = new EntPainAdapter() {
    	public String getID() { return "boss2_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;

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

            self.pain_debounce_time = GameBase.level.time + 3;
            //	   American wanted these at no attenuation
            if (damage < 10) {
                GameBase.gi.sound(self, Defines.CHAN_VOICE, sound_pain3, 1,
                        Defines.ATTN_NONE, 0);
                self.monsterinfo.currentmove = boss2_move_pain_light;
            } else if (damage < 30) {
                GameBase.gi.sound(self, Defines.CHAN_VOICE, sound_pain1, 1,
                        Defines.ATTN_NONE, 0);
                self.monsterinfo.currentmove = boss2_move_pain_light;
            } else {
                GameBase.gi.sound(self, Defines.CHAN_VOICE, sound_pain2, 1,
                        Defines.ATTN_NONE, 0);
                self.monsterinfo.currentmove = boss2_move_pain_heavy;
            }
        }
    };

    static EntThinkAdapter boss2_dead = new EntThinkAdapter() {
    	public String getID() { return "boss2_dead"; }
        public boolean think(edict_t self) {
            Math3D.VectorSet(self.mins, -56, -56, 0);
            Math3D.VectorSet(self.maxs, 56, 56, 80);
            self.movetype = Defines.MOVETYPE_TOSS;
            self.svflags |= Defines.SVF_DEADMONSTER;
            self.nextthink = 0;
            GameBase.gi.linkentity(self);
            return true;
        }
    };

    static EntDieAdapter boss2_die = new EntDieAdapter() {
    	public String getID() { return "boss2_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_NONE, 0);
            self.deadflag = Defines.DEAD_DEAD;
            self.takedamage = Defines.DAMAGE_NO;
            self.count = 0;
            self.monsterinfo.currentmove = boss2_move_death;

        }
    };

    static EntThinkAdapter Boss2_CheckAttack = new EntThinkAdapter() {
    	public String getID() { return "Boss2_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;
            }

            //	   missile attack
            if (self.monsterinfo.attack == null)
                return false;

            if (GameBase.level.time < self.monsterinfo.attack_finished)
                return false;

            if (enemy_range == Defines.RANGE_FAR)
                return false;

            if ((self.monsterinfo.aiflags & Defines.AI_STAND_GROUND) != 0) {
                chance = 0.4f;
            } else if (enemy_range == Defines.RANGE_MELEE) {
                chance = 0.8f;
            } else if (enemy_range == Defines.RANGE_NEAR) {
                chance = 0.8f;
            } else if (enemy_range == Defines.RANGE_MID) {
                chance = 0.8f;
            } else {
                return false;
            }

            if (Lib.random() < chance) {
                self.monsterinfo.attack_state = Defines.AS_MISSILE;
                self.monsterinfo.attack_finished = GameBase.level.time + 2
                        * Lib.random();
                return true;
            }

            if ((self.flags & Defines.FL_FLY) != 0) {
                if (Lib.random() < 0.3)
                    self.monsterinfo.attack_state = Defines.AS_SLIDING;
                else
                    self.monsterinfo.attack_state = Defines.AS_STRAIGHT;
            }

            return false;
        }
    };

    static EntThinkAdapter boss2_search = new EntThinkAdapter() {
    	public String getID() { return "boss2_search"; }
        public boolean think(edict_t self) {
            if (Lib.random() < 0.5)
                GameBase.gi.sound(self, Defines.CHAN_VOICE, sound_search1, 1,
                        Defines.ATTN_NONE, 0);
            return true;
        }
    };

    static EntThinkAdapter Boss2Rocket = new EntThinkAdapter() {
    	public String getID() { return "Boss2Rocket"; }
        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);

            //	  1
            Math3D.G_ProjectSource(self.s.origin,
                    M_Flash.monster_flash_offset[Defines.MZ2_BOSS2_ROCKET_1],
                    forward, right, start);
            Math3D.VectorCopy(self.enemy.s.origin, vec);
            vec[2] += self.enemy.viewheight;
            Math3D.VectorSubtract(vec, start, dir);
            Math3D.VectorNormalize(dir);
            Monster.monster_fire_rocket(self, start, dir, 50, 500,
                    Defines.MZ2_BOSS2_ROCKET_1);

            //	  2
            Math3D.G_ProjectSource(self.s.origin,
                    M_Flash.monster_flash_offset[Defines.MZ2_BOSS2_ROCKET_2],
                    forward, right, start);
            Math3D.VectorCopy(self.enemy.s.origin, vec);
            vec[2] += self.enemy.viewheight;
            Math3D.VectorSubtract(vec, start, dir);
            Math3D.VectorNormalize(dir);
            Monster.monster_fire_rocket(self, start, dir, 50, 500,
                    Defines.MZ2_BOSS2_ROCKET_2);

            //	  3
            Math3D.G_ProjectSource(self.s.origin,
                    M_Flash.monster_flash_offset[Defines.MZ2_BOSS2_ROCKET_3],
                    forward, right, start);
            Math3D.VectorCopy(self.enemy.s.origin, vec);
            vec[2] += self.enemy.viewheight;
            Math3D.VectorSubtract(vec, start, dir);
            Math3D.VectorNormalize(dir);
            Monster.monster_fire_rocket(self, start, dir, 50, 500,
                    Defines.MZ2_BOSS2_ROCKET_3);

            //	  4
            Math3D.G_ProjectSource(self.s.origin,
                    M_Flash.monster_flash_offset[Defines.MZ2_BOSS2_ROCKET_4],
                    forward, right, start);
            Math3D.VectorCopy(self.enemy.s.origin, vec);
            vec[2] += self.enemy.viewheight;
            Math3D.VectorSubtract(vec, start, dir);
            Math3D.VectorNormalize(dir);
            Monster.monster_fire_rocket(self, start, dir, 50, 500,
                    Defines.MZ2_BOSS2_ROCKET_4);
            return true;
        }
    };

    static EntThinkAdapter boss2_firebullet_right = new EntThinkAdapter() {
    	public String getID() { return "boss2_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_BOSS2_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_BOSS2_MACHINEGUN_R1);

            return true;
        }
    };

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