diff --git a/src/Makefile b/src/Makefile index bf8416bc7..8bdb69424 100644 --- a/src/Makefile +++ b/src/Makefile @@ -496,6 +496,7 @@ OBJS:=$(i_main_o) \ $(OBJDIR)/hu_stuff.o \ $(OBJDIR)/y_inter.o \ $(OBJDIR)/st_stuff.o \ + $(OBJDIR)/k_director.o \ $(OBJDIR)/k_kart.o \ $(OBJDIR)/m_aatree.o \ $(OBJDIR)/m_anigif.o \ diff --git a/src/d_netcmd.c b/src/d_netcmd.c index 7030d29b2..b9c385857 100644 --- a/src/d_netcmd.c +++ b/src/d_netcmd.c @@ -554,6 +554,9 @@ consvar_t cv_perfstats = {"perfstats", "Off", CV_CALL, perfstats_cons_t, PS_Perf consvar_t cv_ps_thinkframe_page = {"ps_thinkframe_page", "1", CV_CALL, CV_Natural, PS_ThinkFrame_Page_OnChange, 0, NULL, NULL, 0, 0, NULL}; +consvar_t cv_director = {"director", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; + + static CV_PossibleValue_t ps_samplesize_cons_t[] = { {1, "MIN"}, {1000, "MAX"}, {0, NULL}}; consvar_t cv_ps_samplesize = {"ps_samplesize", "1", CV_CALL, ps_samplesize_cons_t, PS_SampleSize_OnChange, 0, NULL, NULL, 0, 0, NULL}; @@ -979,6 +982,9 @@ void D_RegisterClientCommands(void) CV_RegisterVar(&cv_showtrackaddon); CV_RegisterVar(&cv_showviewpointtext); + CV_RegisterVar(&cv_director); + + CV_RegisterVar(&cv_luaimmersion); CV_RegisterVar(&cv_fakelocalskin); diff --git a/src/d_netcmd.h b/src/d_netcmd.h index b02b68f00..e3d306315 100644 --- a/src/d_netcmd.h +++ b/src/d_netcmd.h @@ -201,6 +201,9 @@ extern consvar_t cv_ps_thinkframe_page; extern consvar_t cv_ps_samplesize; extern consvar_t cv_ps_descriptor; +extern consvar_t cv_director; + + extern consvar_t cv_showtrackaddon; extern consvar_t cv_showspecstuff; diff --git a/src/k_director.c b/src/k_director.c new file mode 100644 index 000000000..0c2cef1d3 --- /dev/null +++ b/src/k_director.c @@ -0,0 +1,371 @@ +// SONIC ROBO BLAST 2 KART +//----------------------------------------------------------------------------- +/// \file k_director.c +/// \brief SRB2kart automatic spectator camera. + +//#include "k_kart.h" +#include "doomdef.h" +#include "g_game.h" +#include "v_video.h" +#include "k_director.h" +#include "d_netcmd.h" +#include "p_local.h" + +#define SWITCHTIME TICRATE * 5 // cooldown between unforced switches +#define BOREDOMTIME 3 * TICRATE / 2 // how long until players considered far apart? +#define TRANSFERTIME TICRATE // how long to delay reaction shots? +#define BREAKAWAYDIST 4000 // how *far* until players considered far apart? +#define WALKBACKDIST 600 // how close should a trailing player be before we switch? +#define PINCHDIST 30000 // how close should the leader be to be considered "end of race"? + +struct directorinfo directorinfo; + +static fixed_t P_ScaleFromMap(fixed_t n, fixed_t scale) +{ + return FixedMul(n, FixedDiv(scale, mapobjectscale)); +} + +void K_InitDirector(void) +{ + INT32 playernum; + + directorinfo.cooldown = SWITCHTIME; + directorinfo.freeze = 0; + directorinfo.attacker = 0; + directorinfo.maxdist = 0; + + for (playernum = 0; playernum < MAXPLAYERS; playernum++) + { + directorinfo.sortedplayers[playernum] = -1; + directorinfo.gap[playernum] = INT32_MAX; + directorinfo.boredom[playernum] = 0; + } +} + +/*static fixed_t K_GetFinishGap(INT32 leader, INT32 follower) +{ + fixed_t dista = players[follower].distancetofinish; + fixed_t distb = players[leader].distancetofinish; + + if (players[follower].position < players[leader].position) + { + return distb - dista; + } + else + { + return dista - distb; + } +}*/ + +static fixed_t K_GetDistanceToFinish(player_t player) +{ + mobj_t *mo; + fixed_t dist = 0; + int maxMoveCount = -1; + int maxAngle = -1; + + if (!(mapheaderinfo[gamemap - 1]->levelflags & LF_SECTIONRACE)) + { + for (mo = waypointcap; mo != NULL; mo = mo->tracer) + { + if (mo->spawnpoint->angle != 0) + continue; + + dist = P_AproxDistance(P_AproxDistance(mo->x - player.mo->x, + mo->y - player.mo->y), + mo->z - player.mo->z) / FRACUNIT; + + break; + } + } + else + { + for (mo = waypointcap; mo != NULL; mo = mo->tracer) + { + if (mo->movecount > maxMoveCount) + maxMoveCount = mo->movecount; + if (mo->spawnpoint->angle > maxAngle) + maxAngle = mo->spawnpoint->angle; + + if (!(mo->movecount == maxMoveCount && mo->spawnpoint->angle == maxAngle)) // sprint maps finishline waypoint is the one with highest movecount AND angle + continue; + + dist = P_AproxDistance(P_AproxDistance(mo->x - player.mo->x, + mo->y - player.mo->y), + mo->z - player.mo->z) / FRACUNIT; + + break; + } + } + + CONS_Printf("dist %d \n", dist); + CONS_Printf("last movecount %d \n", maxMoveCount); + CONS_Printf("last angle %d \n", maxAngle); + + return dist; +} + +static fixed_t K_GetFinishGap(INT32 leader, INT32 follower) +{ + fixed_t dista = K_GetDistanceToFinish(players[follower]); + fixed_t distb = K_GetDistanceToFinish(players[leader]); + + CONS_Printf("dista %d \n", dista); + CONS_Printf("distb %d \n", distb); + + if (players[follower].kartstuff[k_position] < players[leader].kartstuff[k_position]) + { + return distb - dista; + } + else + { + return dista - distb; + } +} + +static void K_UpdateDirectorPositions(void) +{ + INT32 playernum; + INT32 position; + player_t* target; + + memset(directorinfo.sortedplayers, -1, sizeof(directorinfo.sortedplayers)); + + for (playernum = 0; playernum < MAXPLAYERS; playernum++) + { + target = &players[playernum]; + + if (playeringame[playernum] && !target->spectator && target->kartstuff[k_position] > 0) + { + directorinfo.sortedplayers[target->kartstuff[k_position] - 1] = playernum; + } + } + + for (position = 0; position < MAXPLAYERS - 1; position++) + { + directorinfo.gap[position] = INT32_MAX; + + if (directorinfo.sortedplayers[position] == -1 || directorinfo.sortedplayers[position + 1] == -1) + { + continue; + } + + directorinfo.gap[position] = P_ScaleFromMap(K_GetFinishGap(directorinfo.sortedplayers[position], directorinfo.sortedplayers[position + 1]), FRACUNIT); + + if (directorinfo.gap[position] >= BREAKAWAYDIST) + { + directorinfo.boredom[position] = min(BOREDOMTIME * 2, directorinfo.boredom[position] + 1); + } + else if (directorinfo.boredom[position] > 0) + { + directorinfo.boredom[position]--; + } + } + + directorinfo.maxdist = P_ScaleFromMap(K_GetDistanceToFinish(players[directorinfo.sortedplayers[0]]), FRACUNIT); +} + +static boolean K_CanSwitchDirector(void) +{ + /*INT32 *displayplayerp = &displayplayers[0]; + + if (players[*displayplayerp].trickpanel > 0) + { + return false; + }*/ + + if (directorinfo.cooldown > 0) + { + return false; + } + + return true; +} + +static void K_DirectorSwitch(INT32 player, boolean force) +{ + if (P_IsDisplayPlayer(&players[player])) + { + return; + } + + if (players[player].exiting) + { + return; + } + + if (!force && !K_CanSwitchDirector()) + { + return; + } + + G_ResetView(1, player, true); + directorinfo.cooldown = SWITCHTIME; +} + +static void K_DirectorForceSwitch(INT32 player, INT32 time) +{ + if (players[player].exiting) + { + return; + } + + directorinfo.attacker = player; + directorinfo.freeze = time; +} + +void K_DirectorFollowAttack(player_t *player, mobj_t *inflictor, mobj_t *source) +{ + if (!P_IsDisplayPlayer(player)) + { + return; + } + + if (inflictor && inflictor->player) + { + K_DirectorForceSwitch(inflictor->player - players, TRANSFERTIME); + } + else if (source && source->player) + { + K_DirectorForceSwitch(source->player - players, TRANSFERTIME); + } +} + +/*void K_DrawDirectorDebugger(void) +{ + INT32 position; + INT32 leader; + INT32 follower; + INT32 ytxt; + + if (!cv_kartdebugdirector.value) + { + return; + } + + V_DrawThinString(10, 0, V_70TRANS, va("PLACE")); + V_DrawThinString(40, 0, V_70TRANS, va("CONF?")); + V_DrawThinString(80, 0, V_70TRANS, va("GAP")); + V_DrawThinString(120, 0, V_70TRANS, va("BORED")); + V_DrawThinString(150, 0, V_70TRANS, va("COOLDOWN: %d", directorinfo.cooldown)); + V_DrawThinString(230, 0, V_70TRANS, va("MAXDIST: %d", directorinfo.maxdist)); + + for (position = 0; position < MAXPLAYERS - 1; position++) + { + ytxt = 10 * (position + 1); + leader = directorinfo.sortedplayers[position]; + follower = directorinfo.sortedplayers[position + 1]; + + if (leader == -1 || follower == -1) + break; + + V_DrawThinString(10, ytxt, V_70TRANS, va("%d", position)); + V_DrawThinString(20, ytxt, V_70TRANS, va("%d", position + 1)); + + if (players[leader].positiondelay) + { + V_DrawThinString(40, ytxt, V_70TRANS, va("NG")); + } + + V_DrawThinString(80, ytxt, V_70TRANS, va("%d", directorinfo.gap[position])); + + if (directorinfo.boredom[position] >= BOREDOMTIME) + { + V_DrawThinString(120, ytxt, V_70TRANS, va("BORED")); + } + else + { + V_DrawThinString(120, ytxt, V_70TRANS, va("%d", directorinfo.boredom[position])); + } + + V_DrawThinString(150, ytxt, V_70TRANS, va("%s", player_names[leader])); + V_DrawThinString(230, ytxt, V_70TRANS, va("%s", player_names[follower])); + } +}*/ + +void K_UpdateDirector(void) +{ + INT32 *displayplayerp = &displayplayers[0]; + INT32 targetposition; + + if (!cv_director.value) + { + return; + } + + K_UpdateDirectorPositions(); + + if (directorinfo.cooldown > 0) { + directorinfo.cooldown--; + } + + // handle pending forced switches + if (directorinfo.freeze > 0) + { + if (!(--directorinfo.freeze)) + K_DirectorSwitch(directorinfo.attacker, true); + + return; + } + + // if there's only one player left in the list, just switch to that player + if (directorinfo.sortedplayers[0] != -1 && directorinfo.sortedplayers[1] == -1) + { + K_DirectorSwitch(directorinfo.sortedplayers[0], false); + return; + } + + // aaight, time to walk through the standings to find the first interesting pair + // NB: targetposition/sortedplayers is 0-indexed, aiming at the "back half" of a given pair by default. + // we adjust for this when comparing to player->position or when looking at the leading player, Don't Freak Out + for (targetposition = 1; targetposition < MAXPLAYERS; targetposition++) + { + INT32 target; + + // you are out of players, try again + if (directorinfo.sortedplayers[targetposition] == -1) + { + break; + } + + // pair too far apart? try the next one + if (directorinfo.boredom[targetposition - 1] >= BOREDOMTIME) + { + continue; + } + + // pair finished? try the next one + if (players[directorinfo.sortedplayers[targetposition]].exiting) + { + continue; + } + + // don't risk switching away from forward pairs at race end, might miss something! + if (directorinfo.maxdist > PINCHDIST) + { + // if the "next" player is close enough, they should be able to see everyone fine! + // walk back through the standings to find a vantage that gets everyone in frame. + // (also creates a pretty cool effect w/ overtakes at speed) + while (targetposition < MAXPLAYERS && directorinfo.gap[targetposition] < WALKBACKDIST) + { + targetposition++; + } + } + + target = directorinfo.sortedplayers[targetposition]; + + // if we're certain the back half of the pair is actually in this position, try to switch + if (*displayplayerp != target /*&& !players[target].positiondelay*/) + { + K_DirectorSwitch(target, false); + } + + // even if we're not certain, if we're certain we're watching the WRONG player, try to switch + if (players[*displayplayerp].kartstuff[k_position] != targetposition+1 /*&& !players[target].positiondelay*/) + { + K_DirectorSwitch(target, false); + } + + break; + } +} diff --git a/src/k_director.h b/src/k_director.h new file mode 100644 index 000000000..db19fbe8b --- /dev/null +++ b/src/k_director.h @@ -0,0 +1,21 @@ +// SONIC ROBO BLAST 2 KART +//----------------------------------------------------------------------------- +/// \file k_director.h +/// \brief SRB2kart automatic spectator camera. + +extern struct directorinfo +{ + tic_t cooldown; // how long has it been since we last switched? + tic_t freeze; // when nonzero, fixed switch pending, freeze logic! + INT32 attacker; // who to switch to when freeze delay elapses + INT32 maxdist; // how far is the closest player from finishing? + + INT32 sortedplayers[MAXPLAYERS]; // position-1 goes in, player index comes out. + INT32 gap[MAXPLAYERS]; // gap between a given position and their closest pursuer + INT32 boredom[MAXPLAYERS]; // how long has a given position had no credible attackers? +} directorinfo; + +void K_InitDirector(void); +void K_UpdateDirector(void); +void K_DrawDirectorDebugger(void); +void K_DirectorFollowAttack(player_t *player, mobj_t *inflictor, mobj_t *source); \ No newline at end of file diff --git a/src/k_kart.c b/src/k_kart.c index 028fec21c..81e49cf12 100644 --- a/src/k_kart.c +++ b/src/k_kart.c @@ -31,6 +31,7 @@ #include "z_zone.h" #include "m_misc.h" #include "m_cond.h" +#include "k_director.h" #include "k_kart.h" #include "f_finale.h" #include "lua_hud.h" // For Lua hud checks @@ -2237,6 +2238,7 @@ void K_SpinPlayer(player_t *player, mobj_t *source, INT32 type, mobj_t *inflicto // PS: Inflictor is unused for all purposes here and is actually only ever relevant to Lua. It may be nil too. boolean force = false; // Used to check if Lua ShouldSpin should get us damaged reguardless of flashtics or heck knows what. UINT8 shouldForce = LUAh_ShouldSpin(player, inflictor, source); + if (P_MobjWasRemoved(player->mo)) return; // mobj was removed (in theory that shouldn't happen) if (shouldForce == 1) @@ -2244,6 +2246,8 @@ void K_SpinPlayer(player_t *player, mobj_t *source, INT32 type, mobj_t *inflicto else if (shouldForce == 2) return; + K_DirectorFollowAttack(player, inflictor, source); + if (!trapitem && G_BattleGametype()) { if (K_IsPlayerWanted(player)) @@ -2494,6 +2498,8 @@ void K_ExplodePlayer(player_t *player, mobj_t *source, mobj_t *inflictor) // A b else if (shouldForce == 2) return; + K_DirectorFollowAttack(player, inflictor, source); + if (G_BattleGametype()) { if (K_IsPlayerWanted(player)) diff --git a/src/p_setup.c b/src/p_setup.c index 19ff75a37..3f0219ca0 100644 --- a/src/p_setup.c +++ b/src/p_setup.c @@ -83,6 +83,7 @@ #include "p_slopes.h" // SRB2Kart +#include "k_director.h" // K_InitDirector #include "k_kart.h" // @@ -2964,6 +2965,8 @@ boolean P_SetupLevel(boolean skipprecip, boolean reloadinggamestate) G_BeginRecording(); //this has to move here, since dedicated servers dont run got_mapcmd } + K_InitDirector(); + wantedcalcdelay = wantedfrequency*2; indirectitemcooldown = 0; hyubgone = 0; diff --git a/src/p_tick.c b/src/p_tick.c index 3bbc219ca..4a345e141 100644 --- a/src/p_tick.c +++ b/src/p_tick.c @@ -23,6 +23,7 @@ #include "m_random.h" #include "lua_script.h" #include "lua_hook.h" +#include "k_director.h" #include "k_kart.h" #include "i_system.h" #include "r_main.h" @@ -829,6 +830,8 @@ void P_Ticker(boolean run) PS_STOP_TIMING(ps_lua_postthinkframe_time); } + K_UpdateDirector(); + // Always move the camera. for (i = 0; i <= splitscreen; i++) {