gameweapon.java

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

                    .soundindex("weapons/bfg__x1b.wav"), 1, Defines.ATTN_NORM,
                    0);
            self.solid = Defines.SOLID_NOT;
            self.touch = null;
            Math3D.VectorMA(self.s.origin, -1 * Defines.FRAMETIME,
                    self.velocity, self.s.origin);
            Math3D.VectorClear(self.velocity);
            self.s.modelindex = GameBase.gi.modelindex("sprites/s_bfg3.sp2");
            self.s.frame = 0;
            self.s.sound = 0;
            self.s.effects &= ~Defines.EF_ANIM_ALLFAST;
            self.think = bfg_explode;
            self.nextthink = GameBase.level.time + Defines.FRAMETIME;
            self.enemy = other;
    
            GameBase.gi.WriteByte(Defines.svc_temp_entity);
            GameBase.gi.WriteByte(Defines.TE_BFG_BIGEXPLOSION);
            GameBase.gi.WritePosition(self.s.origin);
            GameBase.gi.multicast(self.s.origin, Defines.MULTICAST_PVS);
        }
    };
    
    static EntThinkAdapter bfg_think = new EntThinkAdapter() {
    	public String getID() { return "bfg_think"; }
        public boolean think(edict_t self) {
            edict_t ent;
            edict_t ignore;
            float[] point = { 0, 0, 0 };
            float[] dir = { 0, 0, 0 };
            float[] start = { 0, 0, 0 };
            float[] end = { 0, 0, 0 };
            int dmg;
            trace_t tr;
    
            if (GameBase.deathmatch.value != 0)
                dmg = 5;
            else
                dmg = 10;
    
            EdictIterator edit = null;
            while ((edit = GameBase.findradius(edit, self.s.origin, 256)) != null) {
                ent = edit.o;
    
                if (ent == self)
                    continue;
    
                if (ent == self.owner)
                    continue;
    
                if (ent.takedamage == 0)
                    continue;
    
                if (0 == (ent.svflags & Defines.SVF_MONSTER)
                        && (null == ent.client)
                        && (Lib.strcmp(ent.classname, "misc_explobox") != 0))
                    continue;
    
                Math3D.VectorMA(ent.absmin, 0.5f, ent.size, point);
    
                Math3D.VectorSubtract(point, self.s.origin, dir);
                Math3D.VectorNormalize(dir);
    
                ignore = self;
                Math3D.VectorCopy(self.s.origin, start);
                Math3D.VectorMA(start, 2048, dir, end);
                while (true) {
                    tr = GameBase.gi.trace(start, null, null, end, ignore,
                            Defines.CONTENTS_SOLID | Defines.CONTENTS_MONSTER
                                    | Defines.CONTENTS_DEADMONSTER);
    
                    if (null == tr.ent)
                        break;
    
                    // hurt it if we can
                    if ((tr.ent.takedamage != 0)
                            && 0 == (tr.ent.flags & Defines.FL_IMMUNE_LASER)
                            && (tr.ent != self.owner))
                        GameCombat.T_Damage(tr.ent, self, self.owner, dir,
                                tr.endpos, Globals.vec3_origin, dmg, 1,
                                Defines.DAMAGE_ENERGY, Defines.MOD_BFG_LASER);
    
                    // if we hit something that's not a monster or player we're
                    // done
                    if (0 == (tr.ent.svflags & Defines.SVF_MONSTER)
                            && (null == tr.ent.client)) {
                        GameBase.gi.WriteByte(Defines.svc_temp_entity);
                        GameBase.gi.WriteByte(Defines.TE_LASER_SPARKS);
                        GameBase.gi.WriteByte(4);
                        GameBase.gi.WritePosition(tr.endpos);
                        GameBase.gi.WriteDir(tr.plane.normal);
                        GameBase.gi.WriteByte(self.s.skinnum);
                        GameBase.gi.multicast(tr.endpos, Defines.MULTICAST_PVS);
                        break;
                    }
    
                    ignore = tr.ent;
                    Math3D.VectorCopy(tr.endpos, start);
                }
    
                GameBase.gi.WriteByte(Defines.svc_temp_entity);
                GameBase.gi.WriteByte(Defines.TE_BFG_LASER);
                GameBase.gi.WritePosition(self.s.origin);
                GameBase.gi.WritePosition(tr.endpos);
                GameBase.gi.multicast(self.s.origin, Defines.MULTICAST_PHS);
            }
    
            self.nextthink = GameBase.level.time + Defines.FRAMETIME;
            return true;
        }
    };

    /*
     * ================= 
     * check_dodge
     * 
     * This is a support routine used when a client is firing a non-instant
     * attack weapon. It checks to see if a monster's dodge function should be
     * called. 
     * =================
     */
    static void check_dodge(edict_t self, float[] start, float[] dir, int speed) {
        float[] end = { 0, 0, 0 };
        float[] v = { 0, 0, 0 };
        trace_t tr;
        float eta;
    
        // easy mode only ducks one quarter the time
        if (GameBase.skill.value == 0) {
            if (Lib.random() > 0.25)
                return;
        }
        Math3D.VectorMA(start, 8192, dir, end);
        tr = GameBase.gi.trace(start, null, null, end, self, Defines.MASK_SHOT);
        if ((tr.ent != null) && (tr.ent.svflags & Defines.SVF_MONSTER) != 0
                && (tr.ent.health > 0) && (null != tr.ent.monsterinfo.dodge)
                && GameUtil.infront(tr.ent, self)) {
            Math3D.VectorSubtract(tr.endpos, start, v);
            eta = (Math3D.VectorLength(v) - tr.ent.maxs[0]) / speed;
            tr.ent.monsterinfo.dodge.dodge(tr.ent, self, eta);
        }
    }

    /*
     * ================= 
     * fire_hit
     * 
     * Used for all impact (hit/punch/slash) attacks 
     * =================
     */
    public static boolean fire_hit(edict_t self, float[] aim, int damage,
            int kick) {
        trace_t tr;
        float[] forward = { 0, 0, 0 }, right = { 0, 0, 0 }, up = { 0, 0, 0 };
        float[] v = { 0, 0, 0 };
        float[] point = { 0, 0, 0 };
        float range;
        float[] dir = { 0, 0, 0 };
    
        //see if enemy is in range
        Math3D.VectorSubtract(self.enemy.s.origin, self.s.origin, dir);
        range = Math3D.VectorLength(dir);
        if (range > aim[0])
            return false;
    
        if (aim[1] > self.mins[0] && aim[1] < self.maxs[0]) {
            // the hit is straight on so back the range up to the edge of their
            // bbox
            range -= self.enemy.maxs[0];
        } else {
            // this is a side hit so adjust the "right" value out to the edge of
            // their bbox
            if (aim[1] < 0)
                aim[1] = self.enemy.mins[0];
            else
                aim[1] = self.enemy.maxs[0];
        }
    
        Math3D.VectorMA(self.s.origin, range, dir, point);
    
        tr = GameBase.gi.trace(self.s.origin, null, null, point, self,
                Defines.MASK_SHOT);
        if (tr.fraction < 1) {
            if (0 == tr.ent.takedamage)
                return false;
            // if it will hit any client/monster then hit the one we wanted to
            // hit
            if ((tr.ent.svflags & Defines.SVF_MONSTER) != 0
                    || (tr.ent.client != null))
                tr.ent = self.enemy;
        }
    
        Math3D.AngleVectors(self.s.angles, forward, right, up);
        Math3D.VectorMA(self.s.origin, range, forward, point);
        Math3D.VectorMA(point, aim[1], right, point);
        Math3D.VectorMA(point, aim[2], up, point);
        Math3D.VectorSubtract(point, self.enemy.s.origin, dir);
    
        // do the damage
        GameCombat.T_Damage(tr.ent, self, self, dir, point, Globals.vec3_origin,
                damage, kick / 2, Defines.DAMAGE_NO_KNOCKBACK, Defines.MOD_HIT);
    
        if (0 == (tr.ent.svflags & Defines.SVF_MONSTER)
                && (null == tr.ent.client))
            return false;
    
        // do our special form of knockback here
        Math3D.VectorMA(self.enemy.absmin, 0.5f, self.enemy.size, v);
        Math3D.VectorSubtract(v, point, v);
        Math3D.VectorNormalize(v);
        Math3D.VectorMA(self.enemy.velocity, kick, v, self.enemy.velocity);
        if (self.enemy.velocity[2] > 0)
            self.enemy.groundentity = null;
        return true;
    }

    /*
     * ================= 
     * fire_lead
     * 
     * This is an internal support routine used for bullet/pellet based weapons.
     * =================
     */
    public static void fire_lead(edict_t self, float[] start, float[] aimdir,
            int damage, int kick, int te_impact, int hspread, int vspread,
            int mod) {
        trace_t tr;
        float[] dir = { 0, 0, 0 };
        float[] forward = { 0, 0, 0 }, right = { 0, 0, 0 }, up = { 0, 0, 0 };
        float[] end = { 0, 0, 0 };
        float r;
        float u;
        float[] water_start = { 0, 0, 0 };
        boolean water = false;
        int content_mask = Defines.MASK_SHOT | Defines.MASK_WATER;
    
        tr = GameBase.gi.trace(self.s.origin, null, null, start, self,
                Defines.MASK_SHOT);
        if (!(tr.fraction < 1.0)) {
            Math3D.vectoangles(aimdir, dir);
            Math3D.AngleVectors(dir, forward, right, up);
    
            r = Lib.crandom() * hspread;
            u = Lib.crandom() * vspread;
            Math3D.VectorMA(start, 8192, forward, end);
            Math3D.VectorMA(end, r, right, end);
            Math3D.VectorMA(end, u, up, end);
    
            if ((GameBase.gi.pointcontents.pointcontents(start) & Defines.MASK_WATER) != 0) {
                water = true;
                Math3D.VectorCopy(start, water_start);
                content_mask &= ~Defines.MASK_WATER;
            }
    
            tr = GameBase.gi.trace(start, null, null, end, self, content_mask);
    
            // see if we hit water
            if ((tr.contents & Defines.MASK_WATER) != 0) {
                int color;
    
                water = true;
                Math3D.VectorCopy(tr.endpos, water_start);
    
                if (!Math3D.VectorEquals(start, tr.endpos)) {
                    if ((tr.contents & Defines.CONTENTS_WATER) != 0) {
                        if (Lib.strcmp(tr.surface.name, "*brwater") == 0)
                            color = Defines.SPLASH_BROWN_WATER;
                        else
                            color = Defines.SPLASH_BLUE_WATER;
                    } else if ((tr.contents & Defines.CONTENTS_SLIME) != 0)
                        color = Defines.SPLASH_SLIME;
                    else if ((tr.contents & Defines.CONTENTS_LAVA) != 0)
                        color = Defines.SPLASH_LAVA;
                    else
                        color = Defines.SPLASH_UNKNOWN;
    
                    if (color != Defines.SPLASH_UNKNOWN) {
                        GameBase.gi.WriteByte(Defines.svc_temp_entity);
                        GameBase.gi.WriteByte(Defines.TE_SPLASH);
                        GameBase.gi.WriteByte(8);
                        GameBase.gi.WritePosition(tr.endpos);
                        GameBase.gi.WriteDir(tr.plane.normal);
                        GameBase.gi.WriteByte(color);
                        GameBase.gi.multicast(tr.endpos, Defines.MULTICAST_PVS);
                    }
    
                    // change bullet's course when it enters water
                    Math3D.VectorSubtract(end, start, dir);
                    Math3D.vectoangles(dir, dir);
                    Math3D.AngleVectors(dir, forward, right, up);
                    r = Lib.crandom() * hspread * 2;
                    u = Lib.crandom() * vspread * 2;
                    Math3D.VectorMA(water_start, 8192, forward, end);
                    Math3D.VectorMA(end, r, right, end);
                    Math3D.VectorMA(end, u, up, end);
                }
    
                // re-trace ignoring water this time
                tr = GameBase.gi.trace(water_start, null, null, end, self,
                        Defines.MASK_SHOT);
            }
        }
    
        // send gun puff / flash
        if (!((tr.surface != null) && 0 != (tr.surface.flags & Defines.SURF_SKY))) {
            if (tr.fraction < 1.0) {
                if (tr.ent.takedamage != 0) {
                    GameCombat.T_Damage(tr.ent, self, self, aimdir, tr.endpos,
                            tr.plane.normal, damage, kick,
                            Defines.DAMAGE_BULLET, mod);
                } else {
                    if (!"sky".equals(tr.surface.name)) {
                        GameBase.gi.WriteByte(Defines.svc_temp_entity);
                        GameBase.gi.WriteByte(te_impact);
                        GameBase.gi.WritePosition(tr.endpos);
                        GameBase.gi.WriteDir(tr.plane.normal);
                        GameBase.gi.multicast(tr.endpos, Defines.MULTICAST_PVS);
    
                        if (self.client != null)
                            PlayerWeapon.PlayerNoise(self, tr.endpos,
                                    Defines.PNOISE_IMPACT);
                    }
                }
            }
        }
    
        // if went through water, determine where the end and make a bubble
        // trail
        if (water) {