diff options
Diffstat (limited to 'src/jake2/game/GameBase.java')
| -rw-r--r-- | src/jake2/game/GameBase.java | 824 |
1 files changed, 824 insertions, 0 deletions
diff --git a/src/jake2/game/GameBase.java b/src/jake2/game/GameBase.java new file mode 100644 index 0000000..317da9b --- /dev/null +++ b/src/jake2/game/GameBase.java @@ -0,0 +1,824 @@ +/* +Copyright (C) 1997-2001 Id Software, Inc. + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either version 2 +of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + +See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +*/ + +// Created on 30.11.2003 by RST. +// $Id: GameBase.java,v 1.1 2004-07-07 19:58:56 hzi Exp $ + +/** Father of all Objects. */ + +package jake2.game; + +import java.util.StringTokenizer; + +import jake2.*; +import jake2.client.*; +import jake2.qcommon.Com; +import jake2.server.*; +import jake2.util.*; + +public class GameBase extends Globals { + public static game_locals_t game = new game_locals_t(); + public static level_locals_t level = new level_locals_t(); + public static game_import_t gi = new game_import_t(); + public static game_export_t globals = new game_export_t(); + public static spawn_temp_t st = new spawn_temp_t(); + + public static int sm_meat_index; + public static int snd_fry; + public static int meansOfDeath; + + public static edict_t g_edicts[] = new edict_t[MAX_EDICTS]; + static { + for (int n = 0; n < MAX_EDICTS; n++) + g_edicts[n] = new edict_t(n); + } + + public static cvar_t deathmatch = new cvar_t(); + public static cvar_t coop = new cvar_t(); + public static cvar_t dmflags = new cvar_t(); + public static cvar_t skill; // = new cvar_t(); + public static cvar_t fraglimit = new cvar_t(); + public static cvar_t timelimit = new cvar_t(); + public static cvar_t password = new cvar_t(); + public static cvar_t spectator_password = new cvar_t(); + public static cvar_t needpass = new cvar_t(); + public static cvar_t maxclients = new cvar_t(); + public static cvar_t maxspectators = new cvar_t(); + public static cvar_t maxentities = new cvar_t(); + public static cvar_t g_select_empty = new cvar_t(); + public static cvar_t dedicated = new cvar_t(); + + public static cvar_t filterban = new cvar_t(); + + public static cvar_t sv_maxvelocity = new cvar_t(); + public static cvar_t sv_gravity = new cvar_t(); + + public static cvar_t sv_rollspeed = new cvar_t(); + public static cvar_t sv_rollangle = new cvar_t(); + public static cvar_t gun_x = new cvar_t(); + public static cvar_t gun_y = new cvar_t(); + public static cvar_t gun_z = new cvar_t(); + + public static cvar_t run_pitch = new cvar_t(); + public static cvar_t run_roll = new cvar_t(); + public static cvar_t bob_up = new cvar_t(); + public static cvar_t bob_pitch = new cvar_t(); + public static cvar_t bob_roll = new cvar_t(); + + public static cvar_t sv_cheats = new cvar_t(); + + public static cvar_t flood_msgs = new cvar_t(); + public static cvar_t flood_persecond = new cvar_t(); + public static cvar_t flood_waitdelay = new cvar_t(); + + public static cvar_t sv_maplist = new cvar_t(); + + public final static float STOP_EPSILON = 0.1f; + + static field_t fields_ent[] = + new field_t[] { + new field_t("classname", F_LSTRING), + new field_t("model", F_LSTRING), + new field_t("spawnflags", F_INT), + new field_t("speed", F_FLOAT), + new field_t("accel", F_FLOAT), + new field_t("decel", F_FLOAT), + new field_t("target", F_LSTRING), + new field_t("targetname", F_LSTRING), + new field_t("pathtarget", F_LSTRING), + new field_t("deathtarget", F_LSTRING), + new field_t("killtarget", F_LSTRING), + new field_t("combattarget", F_LSTRING), + new field_t("message", F_LSTRING), + new field_t("team", F_LSTRING), + new field_t("wait", F_FLOAT), + new field_t("delay", F_FLOAT), + new field_t("random", F_FLOAT), + new field_t("move_origin", F_VECTOR), + new field_t("move_angles", F_VECTOR), + new field_t("style", F_INT), + new field_t("count", F_INT), + new field_t("health", F_INT), + new field_t("sounds", F_INT), + new field_t("light", F_IGNORE), + new field_t("dmg", F_INT), + new field_t("mass", F_INT), + new field_t("volume", F_FLOAT), + new field_t("attenuation", F_FLOAT), + new field_t("map", F_LSTRING), + new field_t("origin", F_VECTOR), + new field_t("angles", F_VECTOR), + new field_t("angle", F_ANGLEHACK), + new field_t("goalentity", F_EDICT, FFL_NOSPAWN), + new field_t("movetarget", F_EDICT, FFL_NOSPAWN), + new field_t("enemy", F_EDICT, FFL_NOSPAWN), + new field_t("oldenemy", F_EDICT, FFL_NOSPAWN), + new field_t("activator", F_EDICT, FFL_NOSPAWN), + new field_t("groundentity", F_EDICT, FFL_NOSPAWN), + new field_t("teamchain", F_EDICT, FFL_NOSPAWN), + new field_t("teammaster", F_EDICT, FFL_NOSPAWN), + new field_t("owner", F_EDICT, FFL_NOSPAWN), + new field_t("mynoise", F_EDICT, FFL_NOSPAWN), + new field_t("mynoise2", F_EDICT, FFL_NOSPAWN), + new field_t("target_ent", F_EDICT, FFL_NOSPAWN), + new field_t("chain", F_EDICT, FFL_NOSPAWN), + new field_t("prethink", F_FUNCTION, FFL_NOSPAWN), + new field_t("think", F_FUNCTION, FFL_NOSPAWN), + new field_t("blocked", F_FUNCTION, FFL_NOSPAWN), + new field_t("touch", F_FUNCTION, FFL_NOSPAWN), + new field_t("use", F_FUNCTION, FFL_NOSPAWN), + new field_t("pain", F_FUNCTION, FFL_NOSPAWN), + new field_t("die", F_FUNCTION, FFL_NOSPAWN), + new field_t("stand", F_FUNCTION, FFL_NOSPAWN), + new field_t("idle", F_FUNCTION, FFL_NOSPAWN), + new field_t("search", F_FUNCTION, FFL_NOSPAWN), + new field_t("walk", F_FUNCTION, FFL_NOSPAWN), + new field_t("run", F_FUNCTION, FFL_NOSPAWN), + new field_t("dodge", F_FUNCTION, FFL_NOSPAWN), + new field_t("attack", F_FUNCTION, FFL_NOSPAWN), + new field_t("melee", F_FUNCTION, FFL_NOSPAWN), + new field_t("sight", F_FUNCTION, FFL_NOSPAWN), + new field_t("checkattack", F_FUNCTION, FFL_NOSPAWN), + new field_t("currentmove", F_MMOVE, FFL_NOSPAWN), + new field_t("endfunc", F_FUNCTION, FFL_NOSPAWN), + new field_t("item", F_ITEM) + //need for item field in edict struct, FFL_SPAWNTEMP item will be skipped on saves + }; + + // temp spawn vars -- only valid when the spawn function is called + static field_t fields_st[] = + { + new field_t("lip", F_INT, FFL_SPAWNTEMP), + new field_t("distance", F_INT, FFL_SPAWNTEMP), + new field_t("height", F_INT, FFL_SPAWNTEMP), + new field_t("noise", F_LSTRING, FFL_SPAWNTEMP), + new field_t("pausetime", F_FLOAT, FFL_SPAWNTEMP), + new field_t("item", F_LSTRING, FFL_SPAWNTEMP), + new field_t("gravity", F_LSTRING, FFL_SPAWNTEMP), + new field_t("sky", F_LSTRING, FFL_SPAWNTEMP), + new field_t("skyrotate", F_FLOAT, FFL_SPAWNTEMP), + new field_t("skyaxis", F_VECTOR, FFL_SPAWNTEMP), + new field_t("minyaw", F_FLOAT, FFL_SPAWNTEMP), + new field_t("maxyaw", F_FLOAT, FFL_SPAWNTEMP), + new field_t("minpitch", F_FLOAT, FFL_SPAWNTEMP), + new field_t("maxpitch", F_FLOAT, FFL_SPAWNTEMP), + new field_t("nextmap", F_LSTRING, FFL_SPAWNTEMP), + }; + + /** + * Slide off of the impacting object + * returns the blocked flags (1 = floor, 2 = step / wall). + */ + public static int ClipVelocity(float[] in, float[] normal, float[] out, float overbounce) { + float backoff; + float change; + int i, blocked; + + blocked = 0; + if (normal[2] > 0) + blocked |= 1; // floor + if (normal[2] == 0.0f) + blocked |= 2; // step + + backoff = Math3D.DotProduct(in, normal) * overbounce; + + for (i = 0; i < 3; i++) { + change = normal[i] * backoff; + out[i] = in[i] - change; + if (out[i] > -STOP_EPSILON && out[i] < STOP_EPSILON) + out[i] = 0; + } + + return blocked; + } + + /** + SV_FlyMove + + The basic solid body movement clip that slides along multiple planes + Returns the clipflags if the velocity was modified (hit something solid) + 1 = floor + 2 = wall / step + 4 = dead stop + */ + public final static int MAX_CLIP_PLANES = 5; + + /* + ============= + G_Find + + Searches all active entities for the next one that holds + the matching string at fieldofs (use the FOFS() macro) in the structure. + + Searches beginning at the edict after from, or the beginning if null + null will be returned if the end of the list is reached. + + ============= + */ + + /** + * Finds an edict. + * Call with null as from parameter to search from array beginning. + */ + + public static EdictIterator G_Find(EdictIterator from, EdictFindFilter eff, String s) { + + if (from == null) + from = new EdictIterator(0); + else + from.i++; + + for (; from.i < globals.num_edicts; from.i++) { + from.o = g_edicts[from.i]; + if (from.o.classname == null) { + Com.Printf("edict with classname = null" + from.o.index); + } + + if (!from.o.inuse) + continue; + + if (eff.matches(from.o, s)) + return from; + } + + return null; + } + + // comfort version (rst) + public static edict_t G_FindEdict(EdictIterator from, EdictFindFilter eff, String s) { + EdictIterator ei = G_Find(from, eff, s); + if (ei == null) + return null; + else + return ei.o; + } + + /** + * Returns entities that have origins within a spherical area. + */ + public static EdictIterator findradius(EdictIterator from, float[] org, float rad) { + float[] eorg = { 0, 0, 0 }; + int j; + + if (from == null) + from = new EdictIterator(0); + else + from.i++; + + for (; from.i < globals.num_edicts; from.i++) { + from.o = g_edicts[from.i]; + if (!from.o.inuse) + continue; + + if (from.o.solid == SOLID_NOT) + continue; + + for (j = 0; j < 3; j++) + eorg[j] = org[j] - (from.o.s.origin[j] + (from.o.mins[j] + from.o.maxs[j]) * 0.5f); + + if (Math3D.VectorLength(eorg) > rad) + continue; + return from; + } + + return null; + } + + /** + * Searches all active entities for the next one that holds + * the matching string at fieldofs (use the FOFS() macro) in the structure. + * + * Searches beginning at the edict after from, or the beginning if null + * null will be returned if the end of the list is reached. + */ + + public static int MAXCHOICES = 8; + + public static edict_t G_PickTarget(String targetname) { + int num_choices = 0; + edict_t choice[] = new edict_t[MAXCHOICES]; + + if (targetname == null) { + gi.dprintf("G_PickTarget called with null targetname\n"); + return null; + } + + EdictIterator es = null; + + while ((es = G_Find(es, findByTarget, targetname)) != null) { + choice[num_choices++] = es.o; + if (num_choices == MAXCHOICES) + break; + } + + if (num_choices == 0) { + gi.dprintf("G_PickTarget: target " + targetname + " not found\n"); + return null; + } + + return choice[Lib.rand() % num_choices]; + } + + public static float[] VEC_UP = { 0, -1, 0 }; + public static float[] MOVEDIR_UP = { 0, 0, 1 }; + public static float[] VEC_DOWN = { 0, -2, 0 }; + public static float[] MOVEDIR_DOWN = { 0, 0, -1 }; + + public static void G_SetMovedir(float[] angles, float[] movedir) { + if (Math3D.VectorCompare(angles, VEC_UP) != 0) { + Math3D.VectorCopy(MOVEDIR_UP, movedir); + } + else if (Math3D.VectorCompare(angles, VEC_DOWN) != 0) { + Math3D.VectorCopy(MOVEDIR_DOWN, movedir); + } + else { + Math3D.AngleVectors(angles, movedir, null, null); + } + + Math3D.VectorClear(angles); + } + + public static String G_CopyString(String in) { + return new String(in); + } + + /* + ============ + G_TouchTriggers + + ============ + */ + public static void G_TouchTriggers(edict_t ent) { + int i, num; + edict_t touch[] = new edict_t[MAX_EDICTS], hit; + + // dead things don't activate triggers! + if ((ent.client != null || (ent.svflags & SVF_MONSTER) != 0) && (ent.health <= 0)) + return; + + num = gi.BoxEdicts(ent.absmin, ent.absmax, touch, MAX_EDICTS, AREA_TRIGGERS); + + // be careful, it is possible to have an entity in this + // list removed before we get to it (killtriggered) + for (i = 0; i < num; i++) { + hit = touch[i]; + if (!hit.inuse) + continue; + + if (hit.touch == null) + continue; + + hit.touch.touch(hit, ent, null, null); + } + } + + public static pushed_t pushed[] = new pushed_t[MAX_EDICTS]; + public static int pushed_p; + + public static edict_t obstacle; + + /* + ============= + M_CheckBottom + + Returns false if any part of the bottom of the entity is off an edge that + is not a staircase. + + ============= + */ + public static int c_yes, c_no; + + public static int STEPSIZE = 18; + + // ============================================================================ + /* + ================ + G_RunEntity + + ================ + */ + public static void G_RunEntity(edict_t ent) { + if (ent.prethink != null) + ent.prethink.think(ent); + + switch ((int) ent.movetype) { + case MOVETYPE_PUSH : + case MOVETYPE_STOP : + SV.SV_Physics_Pusher(ent); + break; + case MOVETYPE_NONE : + SV.SV_Physics_None(ent); + break; + case MOVETYPE_NOCLIP : + SV.SV_Physics_Noclip(ent); + break; + case MOVETYPE_STEP : + SV.SV_Physics_Step(ent); + break; + case MOVETYPE_TOSS : + case MOVETYPE_BOUNCE : + case MOVETYPE_FLY : + case MOVETYPE_FLYMISSILE : + SV.SV_Physics_Toss(ent); + break; + default : + gi.error("SV_Physics: bad movetype " + (int) ent.movetype); + } + } + + /* + ================ + SV_NewChaseDir + + ================ + */ + public static int DI_NODIR = -1; + public static void assert1(boolean cond) { + if (!cond) { + + try { + + int a[] = null; + int b = a[0]; + } + catch (Exception e) { + System.err.println("assertion failed!"); + e.printStackTrace(); + } + + } + } + + public static void ClearBounds(float[] mins, float[] maxs) { + mins[0] = mins[1] = mins[2] = 99999; + maxs[0] = maxs[1] = maxs[2] = -99999; + } + + public static void AddPointToBounds(float[] v, float[] mins, float[] maxs) { + int i; + float val; + + for (i = 0; i < 3; i++) { + val = v[i]; + if (val < mins[i]) + mins[i] = val; + if (val > maxs[i]) + maxs[i] = val; + } + } + + public static EdictFindFilter findByTarget = new EdictFindFilter() { + public boolean matches(edict_t e, String s) { + if (e.targetname == null) + return false; + return e.targetname.equalsIgnoreCase(s); + } + }; + + public static EdictFindFilter findByClass = new EdictFindFilter() { + public boolean matches(edict_t e, String s) { + return e.classname.equalsIgnoreCase(s); + } + }; + + //=================================================================== + + public static void ShutdownGame() { + gi.dprintf("==== ShutdownGame ====\n"); + + //gi.FreeTags (TAG_LEVEL); + //gi.FreeTags (TAG_GAME); + } + + //====================================================================== + + /* + ================= + ClientEndServerFrames + ================= + */ + public static void ClientEndServerFrames() { + int i; + edict_t ent; + + // calc the player views now that all pushing + // and damage has been added + for (i = 0; i < maxclients.value; i++) { + ent = g_edicts[1 + i]; + if (!ent.inuse || null == ent.client) + continue; + Game.ClientEndServerFrame(ent); + } + + } + + /* + ================= + CreateTargetChangeLevel + + Returns the created target changelevel + ================= + */ + public static edict_t CreateTargetChangeLevel(String map) { + edict_t ent; + + ent = Game.G_Spawn(); + ent.classname = "target_changelevel"; + level.nextmap = map; + ent.map = level.nextmap; + return ent; + } + + /* + ================= + EndDMLevel + + The timelimit or fraglimit has been exceeded + ================= + */ + public static void EndDMLevel() { + edict_t ent; + //char * s, * t, * f; + //static const char * seps = " ,\n\r"; + String s, t, f; + String seps = " ,\n\r"; + + // stay on same level flag + if (((int) dmflags.value & DF_SAME_LEVEL) != 0) { + Game.BeginIntermission(CreateTargetChangeLevel(level.mapname)); + return; + } + + // see if it's in the map list + if (sv_maplist.string.length() > 0) { + s = sv_maplist.string; + f = null; + StringTokenizer tk = new StringTokenizer(s, seps); + t = tk.nextToken(); + //t = strtok(s, seps); + while (t != null) { + if (Q_stricmp(t, level.mapname) == 0) { + // it's in the list, go to the next one + t = tk.nextToken(); + if (t == null) { // end of list, go to first one + if (f == null) // there isn't a first one, same level + Game.BeginIntermission(CreateTargetChangeLevel(level.mapname)); + else + Game.BeginIntermission(CreateTargetChangeLevel(f)); + } + else + Game.BeginIntermission(CreateTargetChangeLevel(t)); + return; + } + if (f == null) + f = t; + t = tk.nextToken(); + } + + } + + if (level.nextmap.length() > 0) // go to a specific map + Game.BeginIntermission(CreateTargetChangeLevel(level.nextmap)); + else { // search for a changelevel + EdictIterator edit = null; + edit = G_Find(edit, findByClass, "target_changelevel"); + if (edit == null) { // the map designer didn't include a changelevel, + // so create a fake ent that goes back to the same level + Game.BeginIntermission(CreateTargetChangeLevel(level.mapname)); + return; + } + ent = edit.o; + Game.BeginIntermission(ent); + } + } + + /* + ================= + CheckNeedPass + ================= + */ + public static void CheckNeedPass() { + int need; + + // if password or spectator_password has changed, update needpass + // as needed + if (password.modified || spectator_password.modified) { + password.modified = spectator_password.modified = false; + + need = 0; + + if ((password.string.length() > 0) && 0 != Q_stricmp(password.string, "none")) + need |= 1; + if ((spectator_password.string.length() > 0) && 0 != Q_stricmp(spectator_password.string, "none")) + need |= 2; + + gi.cvar_set("needpass", "" + need); + } + } + + /* + ================= + CheckDMRules + ================= + */ + public static void CheckDMRules() { + int i; + gclient_t cl; + + if (level.intermissiontime != 0) + return; + + if (0 == deathmatch.value) + return; + + if (timelimit.value != 0) { + if (level.time >= timelimit.value * 60) { + gi.bprintf(PRINT_HIGH, "Timelimit hit.\n"); + EndDMLevel(); + return; + } + } + + if (fraglimit.value != 0) { + for (i = 0; i < maxclients.value; i++) { + cl = game.clients[i]; + if (!g_edicts[i + 1].inuse) + continue; + + if (cl.resp.score >= fraglimit.value) { + gi.bprintf(PRINT_HIGH, "Fraglimit hit.\n"); + EndDMLevel(); + return; + } + } + } + } + + /* + ============= + ExitLevel + ============= + */ + public static void ExitLevel() { + int i; + edict_t ent; + //char command[256]; + String command; + + command = "gamemap \"" + level.changemap + "\"\n"; + gi.AddCommandString(command); + level.changemap = null; + level.exitintermission = false; + level.intermissiontime = 0; + ClientEndServerFrames(); + + // clear some things before going to next level + for (i = 0; i < maxclients.value; i++) { + ent = g_edicts[1 + i]; + if (!ent.inuse) + continue; + if (ent.health > ent.client.pers.max_health) + ent.health = ent.client.pers.max_health; + } + + } + + /* + ================ + G_RunFrame + + Advances the world by 0.1 seconds + ================ + */ + public static void G_RunFrame() { + int i; + edict_t ent; + + level.framenum++; + level.time = level.framenum * FRAMETIME; + + // choose a client for monsters to target this frame + Game.AI_SetSightClient(); + + // exit intermissions + + if (level.exitintermission) { + ExitLevel(); + return; + } + + // + // treat each object in turn + // even the world gets a chance to think + // + + for (i = 0; i < globals.num_edicts; i++) { + ent = g_edicts[i]; + if (!ent.inuse) + continue; + + level.current_entity = ent; + + VectorCopy(ent.s.origin, ent.s.old_origin); + + // if the ground entity moved, make sure we are still on it + if ((ent.groundentity != null) && (ent.groundentity.linkcount != ent.groundentity_linkcount)) { + ent.groundentity = null; + if (0 == (ent.flags & (FL_SWIM | FL_FLY)) && (ent.svflags & SVF_MONSTER) != 0) { + M.M_CheckGround(ent); + } + } + + if (i > 0 && i <= maxclients.value) { + Game.ClientBeginServerFrame(ent); + continue; + } + + //TODO: RST: disabled for debugging + //if (ent.classname.startsWith("trigger") )//|| ent.classname.startsWith("monster")) + //G_RunEntity(ent); + + if (ent == g_edicts[307]) + G_RunEntity(ent); + else if (ent == g_edicts[1]) + G_RunEntity(ent); + + else if (true) + if (ent.classname.startsWith("monster_soldier") + || ent.classname.startsWith("target") + || ent.classname.startsWith( + "misc_explo") //ent.classname.startsWith("func_door") + ) //|| ent.classname.startsWith("monster")) + G_RunEntity(ent); + + } + + // see if it is time to end a deathmatch + CheckDMRules(); + + // see if needpass needs updated + CheckNeedPass(); + + // build the playerstate_t structures for all players + ClientEndServerFrames(); + } + + /* + ================= + GetGameAPI + + Returns a pointer to the structure with all entry points + and global variables + ================= + */ + + public static game_export_t GetGameApi(game_import_t imp) { + gi = imp; + + gi.pointcontents = new pmove_t.PointContentsAdapter() { + public int pointcontents(float[] o) { + return SV_WORLD.SV_PointContents(o); + } + }; + + globals.apiversion = GAME_API_VERSION; + /* + globals.Init = InitGame; + globals.Shutdown = ShutdownGame; + globals.SpawnEntities = SpawnEntities; + + globals.WriteGame = WriteGame; + globals.ReadGame = ReadGame; + globals.WriteLevel = WriteLevel; + globals.ReadLevel = ReadLevel; + + globals.ClientThink = ClientThink; + globals.ClientConnect = ClientConnect; + globals.ClientUserinfoChanged = ClientUserinfoChanged; + globals.ClientDisconnect = ClientDisconnect; + globals.ClientBegin = ClientBegin; + globals.ClientCommand = ClientCommand; + globals.RunFrame = G_RunFrame; + globals.ServerCommand = ServerCommand; + */ + + return globals; + } +}
\ No newline at end of file |