gametarget.java

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

                GameUtil.G_FreeEdict(self);
            }
            return true;
        }
    };

    /**
     * QUAKED target_laser (0 .5 .8) (-8 -8 -8) (8 8 8) START_ON RED GREEN BLUE
     * YELLOW ORANGE FAT When triggered, fires a laser. You can either set a
     * target or a direction.
     */
    public static EntThinkAdapter target_laser_think = new EntThinkAdapter() {
    	public String getID() { return "target_laser_think"; }
        public boolean think(edict_t self) {

            edict_t ignore;
            float[] start = { 0, 0, 0 };
            float[] end = { 0, 0, 0 };
            trace_t tr;
            float[] point = { 0, 0, 0 };
            float[] last_movedir = { 0, 0, 0 };
            int count;

            if ((self.spawnflags & 0x80000000) != 0)
                count = 8;
            else
                count = 4;

            if (self.enemy != null) {
                Math3D.VectorCopy(self.movedir, last_movedir);
                Math3D.VectorMA(self.enemy.absmin, 0.5f, self.enemy.size, point);
                Math3D.VectorSubtract(point, self.s.origin, self.movedir);
                Math3D.VectorNormalize(self.movedir);
                if (!Math3D.VectorEquals(self.movedir, last_movedir))
                    self.spawnflags |= 0x80000000;
            }

            ignore = self;
            Math3D.VectorCopy(self.s.origin, start);
            Math3D.VectorMA(start, 2048, self.movedir, end);
            while (true) {
                tr = GameBase.gi.trace(start, null, null, end, ignore,
                        Defines.CONTENTS_SOLID | Defines.CONTENTS_MONSTER
                                | Defines.CONTENTS_DEADMONSTER);

                if (tr.ent == null)
                    break;

                // hurt it if we can
                if ((tr.ent.takedamage != 0)
                        && 0 == (tr.ent.flags & Defines.FL_IMMUNE_LASER))
                    GameCombat.T_Damage(tr.ent, self, self.activator,
                            self.movedir, tr.endpos, Globals.vec3_origin,
                            self.dmg, 1, Defines.DAMAGE_ENERGY,
                            Defines.MOD_TARGET_LASER);

                // if we hit something that's not a monster or player or is
                // immune to lasers, we're done
                if (0 == (tr.ent.svflags & Defines.SVF_MONSTER)
                        && (null == tr.ent.client)) {
                    if ((self.spawnflags & 0x80000000) != 0) {
                        self.spawnflags &= ~0x80000000;
                        GameBase.gi.WriteByte(Defines.svc_temp_entity);
                        GameBase.gi.WriteByte(Defines.TE_LASER_SPARKS);
                        GameBase.gi.WriteByte(count);
                        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);
            }

            Math3D.VectorCopy(tr.endpos, self.s.old_origin);

            self.nextthink = GameBase.level.time + Defines.FRAMETIME;
            return true;
        }
    };

    public static EntUseAdapter target_laser_use = new EntUseAdapter() {
    	public String getID() { return "target_laser_use"; }

        public void use(edict_t self, edict_t other, edict_t activator) {
            self.activator = activator;
            if ((self.spawnflags & 1) != 0)
                target_laser_off(self);
            else
                target_laser_on(self);
        }
    };

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

            self.movetype = Defines.MOVETYPE_NONE;
            self.solid = Defines.SOLID_NOT;
            self.s.renderfx |= Defines.RF_BEAM | Defines.RF_TRANSLUCENT;
            self.s.modelindex = 1; // must be non-zero

            // set the beam diameter
            if ((self.spawnflags & 64) != 0)
                self.s.frame = 16;
            else
                self.s.frame = 4;

            // set the color
            if ((self.spawnflags & 2) != 0)
                self.s.skinnum = 0xf2f2f0f0;
            else if ((self.spawnflags & 4) != 0)
                self.s.skinnum = 0xd0d1d2d3;
            else if ((self.spawnflags & 8) != 0)
                self.s.skinnum = 0xf3f3f1f1;
            else if ((self.spawnflags & 16) != 0)
                self.s.skinnum = 0xdcdddedf;
            else if ((self.spawnflags & 32) != 0)
                self.s.skinnum = 0xe0e1e2e3;

            if (null == self.enemy) {
                if (self.target != null) {
                    EdictIterator edit = GameBase.G_Find(null, GameBase.findByTarget,
                            self.target);
                    if (edit == null)
                        GameBase.gi.dprintf(self.classname + " at "
                                + Lib.vtos(self.s.origin) + ": " + self.target
                                + " is a bad target\n");
                    self.enemy = edit.o;
                } else {
                    GameBase.G_SetMovedir(self.s.angles, self.movedir);
                }
            }
            self.use = target_laser_use;
            self.think = target_laser_think;

            if (0 == self.dmg)
                self.dmg = 1;

            Math3D.VectorSet(self.mins, -8, -8, -8);
            Math3D.VectorSet(self.maxs, 8, 8, 8);
            GameBase.gi.linkentity(self);

            if ((self.spawnflags & 1) != 0)
                target_laser_on(self);
            else
                target_laser_off(self);
            return true;
        }
    };

    /**
     * QUAKED target_lightramp (0 .5 .8) (-8 -8 -8) (8 8 8) TOGGLE speed How
     * many seconds the ramping will take message two letters; starting
     * lightlevel and ending lightlevel
     */

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

            char tmp[] = {(char) ('a' + (int) (self.movedir[0] + (GameBase.level.time - self.timestamp)
                    / Defines.FRAMETIME * self.movedir[2]))};
            
            GameBase.gi.configstring(Defines.CS_LIGHTS + self.enemy.style,
                    new String(tmp));

            if ((GameBase.level.time - self.timestamp) < self.speed) {
                self.nextthink = GameBase.level.time + Defines.FRAMETIME;
            } else if ((self.spawnflags & 1) != 0) {
                char temp;

                temp = (char) self.movedir[0];
                self.movedir[0] = self.movedir[1];
                self.movedir[1] = temp;
                self.movedir[2] *= -1;
            }

            return true;
        }
    };

    static EntUseAdapter target_lightramp_use = new EntUseAdapter() {
    	public String getID() { return "target_lightramp_use"; }
        public void use(edict_t self, edict_t other, edict_t activator) {
            if (self.enemy == null) {
                edict_t e;

                // check all the targets
                e = null;
                EdictIterator es = null;

                while (true) {
                    es = GameBase
                            .G_Find(es, GameBase.findByTarget, self.target);
                    
                    if (es == null)
                        break;
                    
                    e = es.o;

                    if (Lib.strcmp(e.classname, "light") != 0) {
                        GameBase.gi.dprintf(self.classname + " at "
                                + Lib.vtos(self.s.origin));
                        GameBase.gi.dprintf("target " + self.target + " ("
                                + e.classname + " at " + Lib.vtos(e.s.origin)
                                + ") is not a light\n");
                    } else {
                        self.enemy = e;
                    }
                }

                if (null == self.enemy) {
                    GameBase.gi.dprintf(self.classname + " target "
                            + self.target + " not found at "
                            + Lib.vtos(self.s.origin) + "\n");
                    GameUtil.G_FreeEdict(self);
                    return;
                }
            }

            self.timestamp = GameBase.level.time;
            target_lightramp_think.think(self);
        }
    };

    /**
     * QUAKED target_earthquake (1 0 0) (-8 -8 -8) (8 8 8) When triggered, this
     * initiates a level-wide earthquake. All players and monsters are affected.
     * "speed" severity of the quake (default:200) "count" duration of the quake
     * (default:5)
     */

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

            int i;
            edict_t e;

            if (self.last_move_time < GameBase.level.time) {
                GameBase.gi.positioned_sound(self.s.origin, self,
                        Defines.CHAN_AUTO, self.noise_index, 1.0f,
                        Defines.ATTN_NONE, 0);
                self.last_move_time = GameBase.level.time + 0.5f;
            }

            for (i = 1; i < GameBase.num_edicts; i++) {
                e = GameBase.g_edicts[i];

                if (!e.inuse)
                    continue;
                if (null == e.client)
                    continue;
                if (null == e.groundentity)
                    continue;

                e.groundentity = null;
                e.velocity[0] += Lib.crandom() * 150;
                e.velocity[1] += Lib.crandom() * 150;
                e.velocity[2] = self.speed * (100.0f / e.mass);
            }

            if (GameBase.level.time < self.timestamp)
                self.nextthink = GameBase.level.time + Defines.FRAMETIME;

            return true;
        }
    };

    static EntUseAdapter target_earthquake_use = new EntUseAdapter() {
    	public String getID() { return "target_earthquake_use"; }
        public void use(edict_t self, edict_t other, edict_t activator) {
            self.timestamp = GameBase.level.time + self.count;
            self.nextthink = GameBase.level.time + Defines.FRAMETIME;
            self.activator = activator;
            self.last_move_time = 0;
        }
    };
}