diff options
Diffstat (limited to 'sourcemod')
209 files changed, 60469 insertions, 0 deletions
diff --git a/sourcemod/scripting/distbugfix.sp b/sourcemod/scripting/distbugfix.sp new file mode 100644 index 0000000..d1854b5 --- /dev/null +++ b/sourcemod/scripting/distbugfix.sp @@ -0,0 +1,1592 @@ + +#include <sourcemod> +#include <sdktools> +#include <sdkhooks> +#include <clientprefs> +#include <colors> + +#pragma newdecls required +#pragma semicolon 1 + +#if defined DEBUG +#define DEBUG_CHAT(%1) PrintToChat(%1); +#define DEBUG_CHATALL(%1) PrintToChatAll(%1); +#define DEBUG_CONSOLE(%1) PrintToConsole(%1); +#else +#define DEBUG_CHAT(%1) +#define DEBUG_CHATALL(%1) +#define DEBUG_CONSOLE(%1) +#endif + +#include <gamechaos> +#include <distbugfix> + +char g_jumpTypes[JumpType][] = { + "NONE", + "LJ", + "WJ", + "LAJ", + "BH", + "CBH", +}; + +stock char g_szStrafeType[StrafeType][] = { + "$", // STRAFETYPE_OVERLAP + ".", // STRAFETYPE_NONE + + "â–ˆ", // STRAFETYPE_LEFT + "#", // STRAFETYPE_OVERLAP_LEFT + "H", // STRAFETYPE_NONE_LEFT + + "â–ˆ", // STRAFETYPE_RIGHT + "#", // STRAFETYPE_OVERLAP_RIGHT + "H", // STRAFETYPE_NONE_RIGHT +}; + +stock char g_szStrafeTypeColour[][] = { + "<font color='#FF00FF'>|", // overlap + "<font color='#000000'>|", // none + "<font color='#FFFFFF'>|", // left + "<font color='#00BFBF'>|", // overlap_left + "<font color='#408040'>|", // none_left + "<font color='#FFFFFF'>|", // right + "<font color='#00BFBF'>|", // overlap_right + "<font color='#408040'>|", // none_right +}; + +stock bool g_jumpTypePrintable[JumpType] = { + false, // JUMPTYPE_NONE, + + true, // longjump + true, // weirdjump + true, // ladderjump + true, // bunnyhop + true, // ducked bunnyhop +}; + +stock char g_jumpDirString[JumpDir][] = { + "Forwards", + "Backwards", + "Sideways", + "Sideways" +}; + +stock int g_jumpDirForwardButton[JumpDir] = { + IN_FORWARD, + IN_BACK, + IN_MOVELEFT, + IN_MOVERIGHT, +}; + +stock int g_jumpDirLeftButton[JumpDir] = { + IN_MOVELEFT, + IN_MOVERIGHT, + IN_BACK, + IN_FORWARD, +}; + +stock int g_jumpDirRightButton[JumpDir] = { + IN_MOVERIGHT, + IN_MOVELEFT, + IN_FORWARD, + IN_BACK, +}; + +bool g_lateLoad; + +PlayerData g_pd[MAXPLAYERS + 1]; +PlayerData g_failstatPD[MAXPLAYERS + 1]; +int g_beamSprite; + +ConVar g_airaccelerate; +ConVar g_gravity; +ConVar g_maxvelocity; + +ConVar g_jumpRange[JumpType][2]; + +#include "distbugfix/clientprefs.sp" + +public Plugin myinfo = +{ + name = "Distance Bug Fix", + author = "GameChaos", + description = "Fixes longjump distance bug", + version = DISTBUG_VERSION, + url = "https://bitbucket.org/GameChaos/distbug/src" +}; + +public APLRes AskPluginLoad2(Handle myself, bool late, char[] error, int err_max) +{ + g_lateLoad = late; + + return APLRes_Success; +} + +public void OnPluginStart() +{ + RegConsoleCmd("sm_distbug", Command_Distbug, "Toggle distbug on/off."); + RegConsoleCmd("sm_distbugversion", Command_Distbugversion, "Print distbug version."); + + RegConsoleCmd("sm_distbugbeam", CommandBeam, "Toggle jump beam."); + RegConsoleCmd("sm_distbugveerbeam", CommandVeerbeam, "Toggle veer beam."); + RegConsoleCmd("sm_distbughudgraph", CommandHudgraph, "Toggle hud strafe graph."); + RegConsoleCmd("sm_strafestats", CommandStrafestats, "Toggle distbug strafestats."); + RegConsoleCmd("sm_distbugstrafegraph", CommandStrafegraph, "Toggle console strafe graph."); + RegConsoleCmd("sm_distbugadvchat", CommandAdvchat, "Toggle advanced chat stats."); + RegConsoleCmd("sm_distbughelp", CommandHelp, "Distbug command list."); + + g_airaccelerate = FindConVar("sv_airaccelerate"); + g_gravity = FindConVar("sv_gravity"); + g_maxvelocity = FindConVar("sv_maxvelocity"); + + g_jumpRange[JUMPTYPE_LJ][0] = CreateConVar("distbug_lj_min_dist", "210.0"); + g_jumpRange[JUMPTYPE_LJ][1] = CreateConVar("distbug_lj_max_dist", "310.0"); + + g_jumpRange[JUMPTYPE_WJ][0] = CreateConVar("distbug_wj_min_dist", "210.0"); + g_jumpRange[JUMPTYPE_WJ][1] = CreateConVar("distbug_wj_max_dist", "390.0"); + + g_jumpRange[JUMPTYPE_LAJ][0] = CreateConVar("distbug_laj_min_dist", "70.0"); + g_jumpRange[JUMPTYPE_LAJ][1] = CreateConVar("distbug_laj_max_dist", "250.0"); + + g_jumpRange[JUMPTYPE_BH][0] = CreateConVar("distbug_bh_min_dist", "210.0"); + g_jumpRange[JUMPTYPE_BH][1] = CreateConVar("distbug_bh_max_dist", "390.0"); + + g_jumpRange[JUMPTYPE_CBH][0] = CreateConVar("distbug_cbh_min_dist", "200.0"); + g_jumpRange[JUMPTYPE_CBH][1] = CreateConVar("distbug_cbh_max_dist", "390.0"); + + AutoExecConfig(.name = DISTBUG_CONFIG_NAME); + + HookEvent("player_jump", Event_PlayerJump); + + OnPluginStart_Clientprefs(); + if (g_lateLoad) + { + for (int client = 0; client <= MaxClients; client++) + { + if (GCIsValidClient(client)) + { + OnClientPutInServer(client); + OnClientCookiesCached(client); + } + } + } +} + +public void OnMapStart() +{ + g_beamSprite = PrecacheModel("materials/sprites/laserbeam.vmt"); +} + +public void OnClientPutInServer(int client) +{ + SDKHook(client, SDKHook_PostThinkPost, PlayerPostThink); + g_pd[client].tickCount = 0; +} + +public void OnClientCookiesCached(int client) +{ + OnClientCookiesCached_Clientprefs(client); +} + +public void Event_PlayerJump(Event event, const char[] name, bool dontBroadcast) +{ + int client = GetClientOfUserId(event.GetInt("userid")); + if (!IsSettingEnabled(client, SETTINGS_DISTBUG_ENABLED)) + { + return; + } + + if (GCIsValidClient(client, true)) + { + bool duckbhop = !!(g_pd[client].flags & FL_DUCKING); + float groundOffset = g_pd[client].position[2] - g_pd[client].lastGroundPos[2]; + JumpType jumpType = JUMPTYPE_NONE; + if (g_pd[client].framesOnGround <= MAX_BHOP_FRAMES) + { + if (g_pd[client].lastGroundPosWalkedOff && groundOffset < 0.0) + { + jumpType = JUMPTYPE_WJ; + } + else + { + if (duckbhop) + { + jumpType = JUMPTYPE_CBH; + } + else + { + jumpType = JUMPTYPE_BH; + } + } + } + else + { + jumpType = JUMPTYPE_LJ; + } + + if (jumpType != JUMPTYPE_NONE) + { + OnPlayerJumped(client, g_pd[client], jumpType); + } + + g_pd[client].lastGroundPos = g_pd[client].lastPosition; + g_pd[client].lastGroundPosWalkedOff = false; + } +} + +public Action Command_Distbugversion(int client, int args) +{ + ReplyToCommand(client, "Distbugfix version: %s", DISTBUG_VERSION); + return Plugin_Handled; +} + +public Action Command_Distbug(int client, int args) +{ + ToggleSetting(client, SETTINGS_DISTBUG_ENABLED); + CPrintToChat(client, "%s Distbug has been %s", CHAT_PREFIX, + IsSettingEnabled(client, SETTINGS_DISTBUG_ENABLED) ? "enabled." : "disabled."); + + return Plugin_Handled; +} + +public Action CommandBeam(int client, int args) +{ + ToggleSetting(client, SETTINGS_SHOW_JUMP_BEAM); + CPrintToChat(client, "%s Jump beam has been %s", CHAT_PREFIX, + IsSettingEnabled(client, SETTINGS_SHOW_JUMP_BEAM) ? "enabled." : "disabled."); + + return Plugin_Handled; +} + +public Action CommandVeerbeam(int client, int args) +{ + ToggleSetting(client, SETTINGS_SHOW_VEER_BEAM); + CPrintToChat(client, "%s Veer beam has been %s", CHAT_PREFIX, + IsSettingEnabled(client, SETTINGS_SHOW_VEER_BEAM) ? "enabled." : "disabled."); + + return Plugin_Handled; +} + +public Action CommandHudgraph(int client, int args) +{ + ToggleSetting(client, SETTINGS_SHOW_HUD_GRAPH); + CPrintToChat(client, "%s Hud stats have been %s", CHAT_PREFIX, + IsSettingEnabled(client, SETTINGS_SHOW_HUD_GRAPH) ? "enabled." : "disabled."); + + return Plugin_Handled; +} + +public Action CommandStrafestats(int client, int args) +{ + ToggleSetting(client, SETTINGS_DISABLE_STRAFE_STATS); + CPrintToChat(client, "%s Strafe stats have been %s", CHAT_PREFIX, + IsSettingEnabled(client, SETTINGS_DISABLE_STRAFE_STATS) ? "disabled." : "enabled."); + + return Plugin_Handled; +} + +public Action CommandStrafegraph(int client, int args) +{ + ToggleSetting(client, SETTINGS_DISABLE_STRAFE_GRAPH); + CPrintToChat(client, "%s Console strafe graph has been %s", CHAT_PREFIX, + IsSettingEnabled(client, SETTINGS_DISABLE_STRAFE_GRAPH) ? "disabled." : "enabled."); + + return Plugin_Handled; +} + +public Action CommandAdvchat(int client, int args) +{ + ToggleSetting(client, SETTINGS_ADV_CHAT_STATS); + CPrintToChat(client, "%s Advanced chat stats have been %s", CHAT_PREFIX, + IsSettingEnabled(client, SETTINGS_ADV_CHAT_STATS) ? "enabled." : "disabled."); + + return Plugin_Handled; +} + +public Action CommandHelp(int client, int args) +{ + CPrintToChat(client, "%s Look in the console for a list of distbug commands!", CHAT_PREFIX); + PrintToConsole(client, "%s", "Distbug command list:\n" ...\ + "sm_distbug - Toggle distbug on/off.\n" ...\ + "sm_distbugversion - Print distbug version.\n" ...\ + "sm_distbugbeam - Toggle jump beam.\n" ...\ + "sm_distbugveerbeam - Toggle veer beam.\n" ...\ + "sm_distbughudgraph - Toggle hud strafe graph.\n" ...\ + "sm_strafestats - Toggle distbug strafestats.\n" ...\ + "sm_distbugstrafegraph - Toggle console strafe graph.\n" ...\ + "sm_distbugadvchat - Toggle advanced chat stats.\n" ...\ + "sm_distbughelp - Distbug command list.\n"); + return Plugin_Handled; +} + +public Action OnPlayerRunCmd(int client, int& buttons, int& impulse, float vel[3], float angles[3], int& weapon, int& subtype, int& cmdnum, int& tickcount, int& seed, int mouse[2]) +{ + if (!GCIsValidClient(client, true)) + { + return Plugin_Continue; + } + + if (!IsSettingEnabled(client, SETTINGS_DISTBUG_ENABLED)) + { + return Plugin_Continue; + } + + g_pd[client].lastSidemove = g_pd[client].sidemove; + g_pd[client].lastForwardmove = g_pd[client].forwardmove; + g_pd[client].sidemove = vel[1]; + g_pd[client].forwardmove = vel[0]; + + return Plugin_Continue; +} + +public void PlayerPostThink(int client) +{ + if (!GCIsValidClient(client, true)) + { + return; + } + + int flags = GetEntityFlags(client); + g_pd[client].lastButtons = g_pd[client].buttons; + g_pd[client].buttons = GetClientButtons(client); + g_pd[client].lastFlags = g_pd[client].flags; + g_pd[client].flags = flags; + g_pd[client].lastPosition = g_pd[client].position; + g_pd[client].lastAngles = g_pd[client].angles; + g_pd[client].lastVelocity = g_pd[client].velocity; + GetClientAbsOrigin(client, g_pd[client].position); + GetClientEyeAngles(client, g_pd[client].angles); + GCGetClientVelocity(client, g_pd[client].velocity); + GetEntPropVector(client, Prop_Send, "m_vecLadderNormal", g_pd[client].ladderNormal); + + if (flags & FL_ONGROUND) + { + g_pd[client].framesInAir = 0; + g_pd[client].framesOnGround++; + } + else if (g_pd[client].movetype != MOVETYPE_LADDER) + { + g_pd[client].framesInAir++; + g_pd[client].framesOnGround = 0; + } + + g_pd[client].lastMovetype = g_pd[client].movetype; + g_pd[client].movetype = GetEntityMoveType(client); + g_pd[client].stamina = GCGetClientStamina(client); + g_pd[client].lastStamina = g_pd[client].stamina; + g_pd[client].gravity = GetEntityGravity(client); + + // LJ stuff + if (IsSettingEnabled(client, SETTINGS_DISTBUG_ENABLED)) + { + if (g_pd[client].framesInAir == 1) + { + if (!GCVectorsEqual(g_pd[client].lastGroundPos, g_pd[client].lastPosition)) + { + g_pd[client].lastGroundPos = g_pd[client].lastPosition; + g_pd[client].lastGroundPosWalkedOff = true; + } + } + + bool forwardReleased = (g_pd[client].lastButtons & g_jumpDirForwardButton[g_pd[client].jumpDir]) + && !(g_pd[client].buttons & g_jumpDirForwardButton[g_pd[client].jumpDir]); + if (forwardReleased) + { + g_pd[client].fwdReleaseFrame = g_pd[client].tickCount; + } + + if (!g_pd[client].trackingJump + && g_pd[client].movetype == MOVETYPE_WALK + && g_pd[client].lastMovetype == MOVETYPE_LADDER) + { + OnPlayerJumped(client, g_pd[client], JUMPTYPE_LAJ); + } + + if (g_pd[client].framesOnGround == 1) + { + TrackJump(g_pd[client], g_failstatPD[client]); + OnPlayerLanded(client, g_pd[client], g_failstatPD[client]); + } + + if (g_pd[client].trackingJump) + { + TrackJump(g_pd[client], g_failstatPD[client]); + } + } + g_pd[client].tickCount++; + + +#if defined(DEBUG) + SetHudTextParams(-1.0, 0.2, 0.02, 255, 255, 255, 255, 0, 0.0, 0.0, 0.0); + ShowHudText(client, -1, "pos: %f %f %f", g_pd[client].position[0], g_pd[client].position[1], g_pd[client].position[2]); +#endif +} + +bool IsSpectating(int spectator, int target) +{ + if (spectator != target && GCIsValidClient(spectator)) + { + int specMode = GetEntProp(spectator, Prop_Send, "m_iObserverMode"); + if (specMode == 4 || specMode == 5) + { + if (GetEntPropEnt(spectator, Prop_Send, "m_hObserverTarget") == target) + { + return true; + } + } + } + return false; +} + +void ClientAndSpecsPrintChat(int client, const char[] format, any ...) +{ + static char message[1024]; + VFormat(message, sizeof(message), format, 3); + CPrintToChat(client, "%s", message); + + for (int spec = 1; spec <= MaxClients; spec++) + { + if (IsSpectating(spec, client) && IsSettingEnabled(spec, SETTINGS_DISTBUG_ENABLED)) + { + CPrintToChat(spec, "%s", message); + } + } +} + +void ClientAndSpecsPrintConsole(int client, const char[] format, any ...) +{ + static char message[1024]; + VFormat(message, sizeof(message), format, 3); + PrintToConsole(client, "%s", message); + + for (int spec = 1; spec < MAXPLAYERS; spec++) + { + if (IsSpectating(spec, client) && IsSettingEnabled(spec, SETTINGS_DISTBUG_ENABLED)) + { + PrintToConsole(spec, "%s", message); + } + } +} + +void ResetJump(PlayerData pd) +{ + // NOTE: only resets things that need to be reset + for (int i = 0; i < 3; i++) + { + pd.jumpPos[i] = 0.0; + pd.landPos[i] = 0.0; + } + pd.trackingJump = false; + pd.failedJump = false; + pd.jumpGotFailstats = false; + + // Jump data + // pd.jumpType = JUMPTYPE_NONE; + // NOTE: don't reset jumpType or lastJumpType + pd.jumpMaxspeed = 0.0; + pd.jumpSync = 0.0; + pd.jumpEdge = 0.0; + pd.jumpBlockDist = 0.0; + pd.jumpHeight = 0.0; + pd.jumpAirtime = 0; + pd.jumpOverlap = 0; + pd.jumpDeadair = 0; + pd.jumpAirpath = 0.0; + + pd.strafeCount = 0; + for (int i = 0; i < MAX_STRAFES; i++) + { + pd.strafeSync[i] = 0.0; + pd.strafeGain[i] = 0.0; + pd.strafeLoss[i] = 0.0; + pd.strafeMax[i] = 0.0; + pd.strafeAirtime[i] = 0; + pd.strafeOverlap[i] = 0; + pd.strafeDeadair[i] = 0; + pd.strafeAvgGain[i] = 0.0; + pd.strafeAvgEfficiency[i] = 0.0; + pd.strafeAvgEfficiencyCount[i] = 0; + pd.strafeMaxEfficiency[i] = GC_FLOAT_NEGATIVE_INFINITY; + } +} + +bool IsWishspeedMovingLeft(float forwardspeed, float sidespeed, JumpDir jumpDir) +{ + if (jumpDir == JUMPDIR_FORWARDS) + { + return sidespeed < 0.0; + } + else if (jumpDir == JUMPDIR_BACKWARDS) + { + return sidespeed > 0.0; + } + else if (jumpDir == JUMPDIR_LEFT) + { + return forwardspeed < 0.0; + } + // else if (jumpDir == JUMPDIR_RIGHT) + return forwardspeed > 0.0; +} + +bool IsWishspeedMovingRight(float forwardspeed, float sidespeed, JumpDir jumpDir) +{ + if (jumpDir == JUMPDIR_FORWARDS) + { + return sidespeed > 0.0; + } + else if (jumpDir == JUMPDIR_BACKWARDS) + { + return sidespeed < 0.0; + } + else if (jumpDir == JUMPDIR_LEFT) + { + return forwardspeed > 0.0; + } + // else if (jumpDir == JUMPDIR_RIGHT) + return forwardspeed < 0.0; +} + +bool IsNewStrafe(PlayerData pd) +{ + if (pd.jumpDir == JUMPDIR_FORWARDS || pd.jumpDir == JUMPDIR_BACKWARDS) + { + return ((pd.sidemove > 0.0 && pd.lastSidemove <= 0.0) + || (pd.sidemove < 0.0 && pd.lastSidemove >= 0.0)) + && pd.jumpAirtime != 1; + } + // else if (pd.jumpDir == JUMPDIR_LEFT || pd.jumpDir == JUMPDIR_RIGHT) + return ((pd.forwardmove > 0.0 && pd.lastForwardmove <= 0.0) + || (pd.forwardmove < 0.0 && pd.lastForwardmove >= 0.0)) + && pd.jumpAirtime != 1; +} + +void TrackJump(PlayerData pd, PlayerData failstatPD) +{ +#if defined(DEBUG) + SetHudTextParams(-1.0, 0.2, 0.02, 255, 255, 255, 255, 0, 0.0, 0.0, 0.0); + ShowHudText(1, -1, "FOG: %i\njumpAirtime: %i\ntrackingJump: %i", pd.framesOnGround, pd.jumpAirtime, pd.trackingJump); +#endif + + if (pd.framesOnGround > MAX_BHOP_FRAMES + && pd.jumpAirtime && pd.trackingJump) + { + ResetJump(pd); + } + + if (pd.jumpType == JUMPTYPE_NONE + || !g_jumpTypePrintable[pd.jumpType]) + { + pd.trackingJump = false; + return; + } + + if (pd.movetype != MOVETYPE_WALK + && pd.movetype != MOVETYPE_LADDER) + { + ResetJump(pd); + } + + float frametime = GetTickInterval(); + // crusty teleport detection + { + float posDelta[3]; + SubtractVectors(pd.position, pd.lastPosition, posDelta); + + float moveLength = GetVectorLength(posDelta); + // NOTE: 1.73205081 * sv_maxvelocity is the max velocity magnitude you can get. + if (moveLength > g_maxvelocity.FloatValue * 1.73205081 * frametime) + { + ResetJump(pd); + return; + } + } + + int beamIndex = pd.jumpAirtime; + if (beamIndex < MAX_JUMP_FRAMES) + { + pd.jumpBeamX[beamIndex] = pd.position[0]; + pd.jumpBeamY[beamIndex] = pd.position[1]; + pd.jumpBeamColour[beamIndex] = JUMPBEAM_NEUTRAL; + } + pd.jumpAirtime++; + + + float speed = GCGetVectorLength2D(pd.velocity); + if (speed > pd.jumpMaxspeed) + { + pd.jumpMaxspeed = speed; + } + + float lastSpeed = GCGetVectorLength2D(pd.lastVelocity); + if (speed > lastSpeed) + { + pd.jumpSync++; + if (beamIndex < MAX_JUMP_FRAMES) + { + pd.jumpBeamColour[beamIndex] = JUMPBEAM_GAIN; + } + } + else if (speed < lastSpeed && beamIndex < MAX_JUMP_FRAMES) + { + pd.jumpBeamColour[beamIndex] = JUMPBEAM_LOSS; + } + + if (pd.flags & FL_DUCKING && beamIndex < MAX_JUMP_FRAMES) + { + pd.jumpBeamColour[beamIndex] = JUMPBEAM_DUCK; + } + + float height = pd.position[2] - pd.jumpPos[2]; + if (height > pd.jumpHeight) + { + pd.jumpHeight = height; + } + + if (IsOverlapping(pd.buttons, pd.jumpDir)) + { + pd.jumpOverlap++; + } + + if (IsDeadAirtime(pd.buttons, pd.jumpDir)) + { + pd.jumpDeadair++; + } + + // strafestats! + if (pd.strafeCount + 1 < MAX_STRAFES) + { + if (IsNewStrafe(pd)) + { + pd.strafeCount++; + } + + int strafe = pd.strafeCount; + + pd.strafeAirtime[strafe]++; + + if (speed > lastSpeed) + { + pd.strafeSync[strafe] += 1.0; + pd.strafeGain[strafe] += speed - lastSpeed; + } + else if (speed < lastSpeed) + { + pd.strafeLoss[strafe] += lastSpeed - speed; + } + + if (speed > pd.strafeMax[strafe]) + { + pd.strafeMax[strafe] = speed; + } + + if (IsOverlapping(pd.buttons, pd.jumpDir)) + { + pd.strafeOverlap[strafe]++; + } + + if (IsDeadAirtime(pd.buttons, pd.jumpDir)) + { + pd.strafeDeadair[strafe]++; + } + + // efficiency! + { + float maxWishspeed = 30.0; + float airaccelerate = g_airaccelerate.FloatValue; + // NOTE: Assume 250 maxspeed cos this is KZ! + float maxspeed = 250.0; + if (pd.flags & FL_DUCKING) + { + maxspeed *= 0.34; + } + else if (pd.buttons & IN_SPEED) + { + maxspeed *= 0.52; + } + + if (pd.lastStamina > 0) + { + float speedScale = GCFloatClamp(1.0 - pd.lastStamina / 100.0, 0.0, 1.0); + speedScale *= speedScale; + maxspeed *= speedScale; + } + + // calculate zvel 1 tick before pd.lastVelocity and during movement processing + float zvel = pd.lastVelocity[2] + (g_gravity.FloatValue * frametime * 0.5 * pd.gravity); + if (zvel > 0.0 && zvel <= 140.0) + { + maxspeed *= 0.25; + } + + float yawdiff = FloatAbs(GCNormaliseYaw(pd.angles[1] - pd.lastAngles[1])); + float perfectYawDiff = yawdiff; + if (lastSpeed > 0.0) + { + float accelspeed = airaccelerate * maxspeed * frametime; + if (accelspeed > maxWishspeed) + { + accelspeed = maxWishspeed; + } + if (lastSpeed >= maxWishspeed) + { + perfectYawDiff = RadToDeg(ArcSine(accelspeed / lastSpeed)); + } + else + { + perfectYawDiff = 0.0; + } + } + float efficiency = 100.0; + if (perfectYawDiff != 0.0) + { + efficiency = (yawdiff - perfectYawDiff) / perfectYawDiff * 100.0 + 100.0; + } + + pd.strafeAvgEfficiency[strafe] += efficiency; + pd.strafeAvgEfficiencyCount[strafe]++; + if (efficiency > pd.strafeMaxEfficiency[strafe]) + { + pd.strafeMaxEfficiency[strafe] = efficiency; + } + + DEBUG_CONSOLE(1, "%i\t%f\t%f\t%f\t%f\t%f", strafe, (yawdiff - perfectYawDiff), pd.sidemove, yawdiff, perfectYawDiff, speed) + } + } + + // strafe type and mouse graph + if (pd.jumpAirtime - 1 < MAX_JUMP_FRAMES) + { + StrafeType strafeType = STRAFETYPE_NONE; + + bool moveLeft = !!(pd.buttons & g_jumpDirLeftButton[pd.jumpDir]); + bool moveRight = !!(pd.buttons & g_jumpDirRightButton[pd.jumpDir]); + + bool velLeft = IsWishspeedMovingLeft(pd.forwardmove, pd.sidemove, pd.jumpDir); + bool velRight = IsWishspeedMovingRight(pd.forwardmove, pd.sidemove, pd.jumpDir); + bool velIsZero = !velLeft && !velRight; + + if (moveLeft && !moveRight && velLeft) + { + strafeType = STRAFETYPE_LEFT; + } + else if (moveRight && !moveLeft && velRight) + { + strafeType = STRAFETYPE_RIGHT; + } + else if (moveRight && !moveLeft && velRight) + { + strafeType = STRAFETYPE_LEFT; + } + else if (moveRight && moveLeft && velIsZero) + { + strafeType = STRAFETYPE_OVERLAP; + } + else if (moveRight && moveLeft && velLeft) + { + strafeType = STRAFETYPE_OVERLAP_LEFT; + } + else if (moveRight && moveLeft && velRight) + { + strafeType = STRAFETYPE_OVERLAP_RIGHT; + } + else if (!moveRight && !moveLeft && velIsZero) + { + strafeType = STRAFETYPE_NONE; + } + else if (!moveRight && !moveLeft && velLeft) + { + strafeType = STRAFETYPE_NONE_LEFT; + } + else if (!moveRight && !moveLeft && velRight) + { + strafeType = STRAFETYPE_NONE_RIGHT; + } + + pd.strafeGraph[pd.jumpAirtime - 1] = strafeType; + float yawDiff = GCNormaliseYaw(pd.angles[1] - pd.lastAngles[1]); + // Offset index by 2 to align mouse movement with button presses. + int yawIndex = GCIntMax(pd.jumpAirtime - 2, 0); + pd.mouseGraph[yawIndex] = yawDiff; + } + // check for failstat after jump tracking is done + float duckedPos[3]; + duckedPos = pd.position; + if (!(pd.flags & FL_DUCKING)) + { + duckedPos[2] += 9.0; + } + + // only save failed jump if we're at the fail threshold + if ((pd.position[2] < pd.jumpPos[2]) + && (pd.position[2] > pd.jumpPos[2] + (pd.velocity[2] * frametime))) + { + pd.jumpGotFailstats = true; + failstatPD = pd; + } + + // airpath. + // NOTE: Track airpath after failstatPD has been saved, so + // we don't track the last frame of failstats. That should + // happen inside of FinishTrackingJump, because we need the real landing position. + if (!pd.framesOnGround) + { + // NOTE: there's a special case for landing frame. + float delta[3]; + SubtractVectors(pd.position, pd.lastPosition, delta); + pd.jumpAirpath += GCGetVectorLength2D(delta); + } +} + +void OnPlayerFailstat(int client, PlayerData pd) +{ + if (!pd.jumpGotFailstats) + { + ResetJump(pd); + return; + } + + pd.failedJump = true; + + // undo half the gravity + float gravity = g_gravity.FloatValue * pd.gravity; + float frametime = GetTickInterval(); + float fixedVelocity[3]; + fixedVelocity = pd.velocity; + fixedVelocity[2] += gravity * 0.5 * frametime; + + // fix incorrect distance when ducking / unducking at the right time + float lastPosition[3]; + lastPosition = pd.lastPosition; + bool lastDucking = !!(pd.lastFlags & FL_DUCKING); + bool ducking = !!(pd.flags & FL_DUCKING); + if (!lastDucking && ducking) + { + lastPosition[2] += 9.0; + } + else if (lastDucking && !ducking) + { + lastPosition[2] -= 9.0; + } + + GetRealLandingOrigin(pd.jumpPos[2], lastPosition, fixedVelocity, pd.landPos); + pd.jumpDistance = GCGetVectorDistance2D(pd.jumpPos, pd.landPos); + if (pd.jumpType != JUMPTYPE_LAJ) + { + pd.jumpDistance += 32.0; + } + + FinishTrackingJump(client, pd); + PrintStats(client, pd); + ResetJump(pd); +} + +void OnPlayerJumped(int client, PlayerData pd, JumpType jumpType) +{ + pd.lastJumpType = pd.jumpType; + ResetJump(pd); + pd.jumpType = jumpType; + if (g_jumpTypePrintable[jumpType]) + { + pd.trackingJump = true; + } + + pd.prespeedFog = pd.framesOnGround; + pd.prespeedStamina = pd.stamina; + + // DEBUG_CHAT(1, "jump type: %s last jump type: %s", g_jumpTypes[jumpType], g_jumpTypes[pd.lastJumpType]) + + // jump direction + float speed = GCGetVectorLength2D(pd.velocity); + pd.jumpDir = JUMPDIR_FORWARDS; + // NOTE: Ladderjump pres can be super wild and can generate random + // jump directions, so default to forward for ladderjumps. + if (speed > 50.0 && pd.jumpType != JUMPTYPE_LAJ) + { + float velDir = RadToDeg(ArcTangent2(pd.velocity[1], pd.velocity[0])); + float dir = GCNormaliseYaw(pd.angles[1] - velDir); + + if (GCIsFloatInRange(dir, 45.0, 135.0)) + { + pd.jumpDir = JUMPDIR_RIGHT; + } + if (GCIsFloatInRange(dir, -135.0, -45.0)) + { + pd.jumpDir = JUMPDIR_LEFT; + } + else if (dir > 135.0 || dir < -135.0) + { + pd.jumpDir = JUMPDIR_BACKWARDS; + } + } + + if (jumpType != JUMPTYPE_LAJ) + { + pd.jumpFrame = pd.tickCount; + pd.jumpPos = pd.position; + pd.jumpAngles = pd.angles; + + DEBUG_CHAT(client, "jumppos z: %f", pd.jumpPos[2]) + + pd.jumpPrespeed = GCGetVectorLength2D(pd.velocity); + + pd.jumpGroundZ = pd.jumpPos[2]; + float ground[3]; + if (GCTraceGround(client, pd.jumpPos, ground)) + { + pd.jumpGroundZ = ground[2]; + } + else + { + DEBUG_CHATALL("AAAAAAAAAAAAA") + } + } + else + { + // NOTE: for ladderjump set prespeed and stamina to values that don't get shown + pd.prespeedFog = -1; + pd.prespeedStamina = 0.0; + pd.jumpFrame = pd.tickCount - 1; + pd.jumpPos = pd.lastPosition; + pd.jumpAngles = pd.lastAngles; + + pd.jumpPrespeed = GCGetVectorLength2D(pd.lastVelocity); + + // find ladder top + + float traceOrigin[3]; + // 10 units is the furthest away from the ladder surface you can get while still being on the ladder + traceOrigin[0] = pd.jumpPos[0] - 10.0 * pd.ladderNormal[0]; + traceOrigin[1] = pd.jumpPos[1] - 10.0 * pd.ladderNormal[1]; + traceOrigin[2] = pd.jumpPos[2] + 400.0 * GetTickInterval(); // ~400 ups is the fastest vertical speed on ladders + + float traceEnd[3]; + traceEnd = traceOrigin; + traceEnd[2] = pd.jumpPos[2] - 400.0 * GetTickInterval(); + + float mins[3]; + GetClientMins(client, mins); + + float maxs[3]; + GetClientMaxs(client, maxs); + + TR_TraceHullFilter(traceOrigin, traceEnd, mins, maxs, CONTENTS_LADDER, GCTraceEntityFilterPlayer); + + pd.jumpGroundZ = pd.jumpPos[2]; + if (TR_DidHit()) + { + float result[3]; + TR_GetEndPosition(result); + pd.jumpGroundZ = result[2]; + } + } +} + +void OnPlayerLanded(int client, PlayerData pd, PlayerData failstatPD) +{ + pd.landedDucked = !!(pd.flags & FL_DUCKING); + + if (!pd.trackingJump + || pd.jumpType == JUMPTYPE_NONE + || !g_jumpTypePrintable[pd.jumpType]) + { + ResetJump(pd); + return; + } + + if (pd.jumpType != JUMPTYPE_LAJ) + { + float roughOffset = pd.position[2] - pd.jumpPos[2]; + if (0.0 < roughOffset > 2.0) + { + ResetJump(pd); + return; + } + } + + { + float landGround[3]; + GCTraceGround(client, pd.position, landGround); + pd.landGroundZ = landGround[2]; + } + + float offsetTolerance = 0.0001; + if (!GCIsRoughlyEqual(pd.jumpGroundZ, pd.landGroundZ, offsetTolerance) && pd.jumpGotFailstats) + { + OnPlayerFailstat(client, failstatPD); + return; + } + + float landOrigin[3]; + float gravity = g_gravity.FloatValue * pd.gravity; + float frametime = GetTickInterval(); + float fixedVelocity[3]; + float airOrigin[3]; + + // fix incorrect landing position + float lastPosition[3]; + lastPosition = pd.lastPosition; + bool lastDucking = !!(pd.lastFlags & FL_DUCKING); + bool ducking = !!(pd.flags & FL_DUCKING); + if (!lastDucking && ducking) + { + lastPosition[2] += 9.0; + } + else if (lastDucking && !ducking) + { + lastPosition[2] -= 9.0; + } + + bool isBugged = pd.lastPosition[2] - pd.landGroundZ < 2.0; + if (isBugged) + { + fixedVelocity = pd.velocity; + // NOTE: The 0.5 here removes half the gravity in a tick, because + // in pmove code half the gravity is applied before movement calculation and the other half after it's finished. + // We're trying to fix a bug that happens in the middle of movement code. + fixedVelocity[2] = pd.lastVelocity[2] - gravity * 0.5 * frametime; + airOrigin = lastPosition; + } + else + { + // NOTE: calculate current frame's z velocity + float tempVel[3]; + tempVel = pd.velocity; + tempVel[2] = pd.lastVelocity[2] - gravity * 0.5 * frametime; + // NOTE: calculate velocity after the current frame. + fixedVelocity = tempVel; + fixedVelocity[2] -= gravity * frametime; + + airOrigin = pd.position; + } + + GetRealLandingOrigin(pd.landGroundZ, airOrigin, fixedVelocity, landOrigin); + pd.landPos = landOrigin; + + pd.jumpDistance = (GCGetVectorDistance2D(pd.jumpPos, pd.landPos)); + if (pd.jumpType != JUMPTYPE_LAJ) + { + pd.jumpDistance += 32.0; + } + + if (GCIsFloatInRange(pd.jumpDistance, + g_jumpRange[pd.jumpType][0].FloatValue, + g_jumpRange[pd.jumpType][1].FloatValue)) + { + FinishTrackingJump(client, pd); + + PrintStats(client, pd); + } + else + { + DEBUG_CHAT(client, "bad jump distance %f", pd.jumpDistance) + } + ResetJump(pd); +} + +void FinishTrackingJump(int client, PlayerData pd) +{ + // finish up stats: + float xAxisVeer = FloatAbs(pd.landPos[0] - pd.jumpPos[0]); + float yAxisVeer = FloatAbs(pd.landPos[1] - pd.jumpPos[1]); + pd.jumpVeer = GCFloatMin(xAxisVeer, yAxisVeer); + + pd.jumpFwdRelease = pd.fwdReleaseFrame - pd.jumpFrame; + pd.jumpSync = (pd.jumpSync / float(pd.jumpAirtime) * 100.0); + + for (int strafe; strafe < pd.strafeCount + 1; strafe++) + { + // average gain + pd.strafeAvgGain[strafe] = (pd.strafeGain[strafe] / pd.strafeAirtime[strafe]); + + // efficiency! + if (pd.strafeAvgEfficiencyCount[strafe]) + { + pd.strafeAvgEfficiency[strafe] /= float(pd.strafeAvgEfficiencyCount[strafe]); + } + else + { + pd.strafeAvgEfficiency[strafe] = GC_FLOAT_NAN; + } + + // sync + + if (pd.strafeAirtime[strafe] != 0.0) + { + pd.strafeSync[strafe] = (pd.strafeSync[strafe] / float(pd.strafeAirtime[strafe]) * 100.0); + } + else + { + pd.strafeSync[strafe] = 0.0; + } + } + + // airpath! + { + float delta[3]; + SubtractVectors(pd.landPos, pd.lastPosition, delta); + pd.jumpAirpath += GCGetVectorLength2D(delta); + if (pd.jumpType != JUMPTYPE_LAJ) + { + pd.jumpAirpath = (pd.jumpAirpath / (pd.jumpDistance - 32.0)); + } + else + { + pd.jumpAirpath = (pd.jumpAirpath / (pd.jumpDistance)); + } + } + + pd.jumpBlockDist = -1.0; + pd.jumpLandEdge = -9999.9; + pd.jumpEdge = -1.0; + // Calculate block distance and jumpoff edge + if (pd.jumpType != JUMPTYPE_LAJ) + { + int blockAxis = FloatAbs(pd.landPos[1] - pd.jumpPos[1]) > FloatAbs(pd.landPos[0] - pd.jumpPos[0]); + int blockDir = FloatSign(pd.jumpPos[blockAxis] - pd.landPos[blockAxis]); + + float jumpOrigin[3]; + float landOrigin[3]; + jumpOrigin = pd.jumpPos; + landOrigin = pd.landPos; + // move origins 2 units down, so we can touch the side of the lj blocks + jumpOrigin[2] -= 2.0; + landOrigin[2] -= 2.0; + + // extend land origin, so if we fail within 16 units of the block we can still get the block distance. + landOrigin[blockAxis] -= float(blockDir) * 16.0; + + float tempPos[3]; + tempPos = landOrigin; + tempPos[blockAxis] += (jumpOrigin[blockAxis] - landOrigin[blockAxis]) / 2.0; + + float jumpEdge[3]; + GCTraceBlock(tempPos, jumpOrigin, jumpEdge); + + tempPos = jumpOrigin; + tempPos[blockAxis] += (landOrigin[blockAxis] - jumpOrigin[blockAxis]) / 2.0; + + bool block; + float landEdge[3]; + block = GCTraceBlock(tempPos, landOrigin, landEdge); + + if (block) + { + pd.jumpBlockDist = (FloatAbs(landEdge[blockAxis] - jumpEdge[blockAxis]) + 32.0); + pd.jumpLandEdge = ((landEdge[blockAxis] - pd.landPos[blockAxis]) * float(blockDir)); + } + + if (jumpEdge[blockAxis] - tempPos[blockAxis] != 0.0) + { + pd.jumpEdge = FloatAbs(jumpOrigin[blockAxis] - jumpEdge[blockAxis]); + } + } + else + { + int blockAxis = FloatAbs(pd.landPos[1] - pd.jumpPos[1]) > FloatAbs(pd.landPos[0] - pd.jumpPos[0]); + int blockDir = FloatSign(pd.jumpPos[blockAxis] - pd.landPos[blockAxis]); + + // find ladder front + + float traceOrigin[3]; + // 10 units is the furthest away from the ladder surface you can get while still being on the ladder + traceOrigin[0] = pd.jumpPos[0]; + traceOrigin[1] = pd.jumpPos[1]; + traceOrigin[2] = pd.jumpPos[2] - 400.0 * GetTickInterval(); // ~400 ups is the fastest vertical speed on ladders + + // leave enough room to trace the front of the ladder + traceOrigin[blockAxis] += blockDir * 40.0; + + float traceEnd[3]; + traceEnd = traceOrigin; + traceEnd[blockAxis] -= blockDir * 50.0; + + float mins[3]; + GetClientMins(client, mins); + + float maxs[3]; + GetClientMaxs(client, maxs); + maxs[2] = mins[2]; + + TR_TraceHullFilter(traceOrigin, traceEnd, mins, maxs, CONTENTS_LADDER, GCTraceEntityFilterPlayer); + + float jumpEdge[3]; + if (TR_DidHit()) + { + TR_GetEndPosition(jumpEdge); + DEBUG_CHAT(1, "ladder front: %f %f %f", jumpEdge[0], jumpEdge[1], jumpEdge[2]) + + float jumpOrigin[3]; + float landOrigin[3]; + jumpOrigin = pd.jumpPos; + landOrigin = pd.landPos; + // move origins 2 units down, so we can touch the side of the lj blocks + jumpOrigin[2] -= 2.0; + landOrigin[2] -= 2.0; + + // extend land origin, so if we fail within 16 units of the block we can still get the block distance. + landOrigin[blockAxis] -= float(blockDir) * 16.0; + + float tempPos[3]; + tempPos = jumpOrigin; + tempPos[blockAxis] += (landOrigin[blockAxis] - jumpOrigin[blockAxis]) / 2.0; + + float landEdge[3]; + bool land = GCTraceBlock(tempPos, landOrigin, landEdge); + DEBUG_CHAT(1, "tracing from %f %f %f to %f %f %f", tempPos[0], tempPos[1], tempPos[2], landOrigin[0], landOrigin[1], landOrigin[2]) + + if (land) + { + pd.jumpBlockDist = (FloatAbs(landEdge[blockAxis] - jumpEdge[blockAxis])); + pd.jumpLandEdge = ((landEdge[blockAxis] - pd.landPos[blockAxis]) * float(blockDir)); + } + + pd.jumpEdge = FloatAbs(jumpOrigin[blockAxis] - jumpEdge[blockAxis]); + } + } + + // jumpoff angle! + { + float airpathDir[3]; + SubtractVectors(pd.landPos, pd.jumpPos, airpathDir); + NormalizeVector(airpathDir, airpathDir); + + float airpathAngles[3]; + GetVectorAngles(airpathDir, airpathAngles); + float airpathYaw = GCNormaliseYaw(airpathAngles[1]); + + pd.jumpJumpoffAngle = GCNormaliseYaw(airpathYaw - pd.jumpAngles[1]); + } +} + +void PrintStats(int client, PlayerData pd) +{ + // beams! + if (IsSettingEnabled(client, SETTINGS_SHOW_VEER_BEAM)) + { + float beamEnd[3]; + beamEnd[0] = pd.landPos[0]; + beamEnd[1] = pd.jumpPos[1]; + beamEnd[2] = pd.landPos[2]; + float jumpPos[3]; + float landPos[3]; + for (int i = 0; i < 3; i++) + { + jumpPos[i] = pd.jumpPos[i]; + landPos[i] = pd.landPos[i]; + } + + GCTE_SetupBeamPoints(.start = jumpPos, .end = landPos, .modelIndex = g_beamSprite, + .life = 5.0, .width = 1.0, .endWidth = 1.0, .colour = {255, 255, 255, 95}); + TE_SendToClient(client); + + // x axis + GCTE_SetupBeamPoints(.start = jumpPos, .end = beamEnd, .modelIndex = g_beamSprite, + .life = 5.0, .width = 1.0, .endWidth = 1.0, .colour = {255, 0, 255, 95}); + TE_SendToClient(client); + // y axis + GCTE_SetupBeamPoints(.start = landPos, .end = beamEnd, .modelIndex = g_beamSprite, + .life = 5.0, .width = 1.0, .endWidth = 1.0, .colour = {0, 255, 0, 95}); + TE_SendToClient(client); + } + + if (IsSettingEnabled(client, SETTINGS_SHOW_JUMP_BEAM)) + { + float beamPos[3]; + float lastBeamPos[3]; + beamPos[0] = pd.jumpPos[0]; + beamPos[1] = pd.jumpPos[1]; + beamPos[2] = pd.jumpPos[2]; + for (int i = 1; i < pd.jumpAirtime; i++) + { + lastBeamPos = beamPos; + beamPos[0] = pd.jumpBeamX[i]; + beamPos[1] = pd.jumpBeamY[i]; + + int colour[4] = {255, 191, 0, 255}; + if (pd.jumpBeamColour[i] == JUMPBEAM_LOSS) + { + colour = {255, 0, 255, 255}; + } + else if (pd.jumpBeamColour[i] == JUMPBEAM_GAIN) + { + colour = {0, 127, 0, 255}; + } + else if (pd.jumpBeamColour[i] == JUMPBEAM_DUCK) + { + colour = {0, 31, 127, 255}; + } + + GCTE_SetupBeamPoints(.start = lastBeamPos, .end = beamPos, .modelIndex = g_beamSprite, + .life = 5.0, .width = 1.0, .endWidth = 1.0, .colour = colour); + TE_SendToClient(client); + } + } + + char fwdRelease[32] = ""; + if (pd.jumpFwdRelease == 0) + { + FormatEx(fwdRelease, sizeof(fwdRelease), "Fwd: {gr}0"); + } + else if (GCIntAbs(pd.jumpFwdRelease) > 16) + { + FormatEx(fwdRelease, sizeof(fwdRelease), "Fwd: {dr}No"); + } + else if (pd.jumpFwdRelease > 0) + { + FormatEx(fwdRelease, sizeof(fwdRelease), "Fwd: {dr}+%i", pd.jumpFwdRelease); + } + else + { + FormatEx(fwdRelease, sizeof(fwdRelease), "Fwd: {sb}%i", pd.jumpFwdRelease); + } + + char edge[32] = ""; + char chatEdge[32] = ""; + bool hasEdge = false; + if (pd.jumpEdge >= 0.0 && pd.jumpEdge < MAX_EDGE) + { + FormatEx(edge, sizeof(edge), "Edge: %.4f", pd.jumpEdge); + FormatEx(chatEdge, sizeof(chatEdge), "Edge: {l}%.2f{g}", pd.jumpEdge); + hasEdge = true; + } + + char block[32] = ""; + char chatBlock[32] = ""; + bool hasBlock = false; + if (GCIsFloatInRange(pd.jumpBlockDist, + g_jumpRange[pd.jumpType][0].FloatValue, + g_jumpRange[pd.jumpType][1].FloatValue)) + { + FormatEx(block, sizeof(block), "Block: %i", RoundFloat(pd.jumpBlockDist)); + FormatEx(chatBlock, sizeof(chatBlock), "({l}%i{g})", RoundFloat(pd.jumpBlockDist)); + hasBlock = true; + } + + char landEdge[32] = ""; + bool hasLandEdge = false; + if (FloatAbs(pd.jumpLandEdge) < MAX_EDGE) + { + FormatEx(landEdge, sizeof(landEdge), "Land Edge: %.4f", pd.jumpLandEdge); + hasLandEdge = true; + } + + char fog[32]; + bool hasFOG = false; + if (pd.prespeedFog <= MAX_BHOP_FRAMES && pd.prespeedFog >= 0) + { + FormatEx(fog, sizeof(fog), "FOG: %i", pd.prespeedFog); + hasFOG = true; + } + + char stamina[32]; + bool hasStamina = false; + if (pd.prespeedStamina != 0.0) + { + FormatEx(stamina, sizeof(stamina), "Stamina: %.1f", pd.prespeedStamina); + hasStamina = true; + } + + char offset[32]; + bool hasOffset = false; + if (pd.jumpGroundZ != pd.jumpPos[2]) + { + FormatEx(offset, sizeof(offset), "Ground offset: %.4f", pd.jumpPos[2] - pd.jumpGroundZ); + hasOffset = true; + } + + + //ClientAndSpecsPrintChat(client, "%s", chatStats); + + // TODO: remove jump direction from ladderjumps + char consoleStats[1024]; + FormatEx(consoleStats, sizeof(consoleStats), "\n"...CONSOLE_PREFIX..." %s%s: %.5f [%s%s%s%sVeer: %.4f | %s | Sync: %.2f | Max: %.3f]\n"...\ + "[%s%sPre: %.4f | OL/DA: %i/%i | Jumpoff Angle: %.3f | Airpath: %.4f]\n"...\ + "[Strafes: %i | Airtime: %i | Jump Direction: %s | %s%sHeight: %.4f%s%s%s%s]", + pd.failedJump ? "FAILED " : "", + g_jumpTypes[pd.jumpType], + pd.jumpDistance, + block, + hasBlock ? " | " : "", + edge, + hasEdge ? " | " : "", + pd.jumpVeer, + fwdRelease, + pd.jumpSync, + pd.jumpMaxspeed, + + landEdge, + hasLandEdge ? " | " : "", + pd.jumpPrespeed, + pd.jumpOverlap, + pd.jumpDeadair, + pd.jumpJumpoffAngle, + pd.jumpAirpath, + + pd.strafeCount + 1, + pd.jumpAirtime, + g_jumpDirString[pd.jumpDir], + fog, + hasFOG ? " | " : "", + pd.jumpHeight, + hasOffset ? " | " : "", + offset, + hasStamina ? " | " : "", + stamina + ); + + CRemoveTags(consoleStats, sizeof(consoleStats)); + ClientAndSpecsPrintConsole(client, consoleStats); + + if (!IsSettingEnabled(client, SETTINGS_DISABLE_STRAFE_STATS)) + { + ClientAndSpecsPrintConsole(client, " #. Sync Gain Loss Max Air OL DA AvgGain Avg efficiency, (max efficiency)"); + for (int strafe; strafe <= pd.strafeCount && strafe < MAX_STRAFES; strafe++) + { + ClientAndSpecsPrintConsole(client, "%2i. %5.1f%% %6.2f %6.2f %5.1f %3i %3i %3i %3.2f %3i%% (%3i%%)", + strafe + 1, + pd.strafeSync[strafe], + pd.strafeGain[strafe], + pd.strafeLoss[strafe], + pd.strafeMax[strafe], + pd.strafeAirtime[strafe], + pd.strafeOverlap[strafe], + pd.strafeDeadair[strafe], + pd.strafeAvgGain[strafe], + RoundFloat(pd.strafeAvgEfficiency[strafe]), + RoundFloat(pd.strafeMaxEfficiency[strafe]) + ); + } + } + + // hud text + char strafeLeft[512] = ""; + int slIndex; + char strafeRight[512] = ""; + int srIndex; + char mouseLeft[512] = ""; + int mlIndex; + char mouseRight[512] = ""; + int mrIndex; + + char hudStrafeLeft[4096] = ""; + int hslIndex; + char hudStrafeRight[4096] = ""; + int hsrIndex; + char hudMouse[4096] = ""; + int hmIndex; + + char mouseChars[][] = { + "â–„", + "â–ˆ" + }; + char mouseColours[][] = { + "<font color='#FFBF00'>|", + "<font color='#000000'>|", + "<font color='#003FFF'>|" + }; + float mouseSpeedScale = 1.0 / (512.0 * GetTickInterval()); + // nonsensical default values, so that the first comparison check fails + StrafeType lastStrafeTypeLeft = STRAFETYPE_NONE_RIGHT + STRAFETYPE_NONE_RIGHT; + StrafeType lastStrafeTypeRight = STRAFETYPE_NONE_RIGHT + STRAFETYPE_NONE_RIGHT; + int lastMouseIndex = 9999; + for (int i = 0; i < pd.jumpAirtime && i < MAX_JUMP_FRAMES; i++) + { + StrafeType strafeTypeLeft = pd.strafeGraph[i]; + StrafeType strafeTypeRight = pd.strafeGraph[i]; + + if (strafeTypeLeft == STRAFETYPE_RIGHT + || strafeTypeLeft == STRAFETYPE_NONE_RIGHT + || strafeTypeLeft == STRAFETYPE_OVERLAP_RIGHT) + { + strafeTypeLeft = STRAFETYPE_NONE; + } + + if (strafeTypeRight == STRAFETYPE_LEFT + || strafeTypeRight == STRAFETYPE_NONE_LEFT + || strafeTypeRight == STRAFETYPE_OVERLAP_LEFT) + { + strafeTypeRight = STRAFETYPE_NONE; + } + + slIndex += strcopy(strafeLeft[slIndex], sizeof(strafeLeft) - slIndex, g_szStrafeType[strafeTypeLeft]); + srIndex += strcopy(strafeRight[srIndex], sizeof(strafeRight) - srIndex, g_szStrafeType[strafeTypeRight]); + + int charIndex = GCIntMin(RoundToFloor(FloatAbs(pd.mouseGraph[i]) * mouseSpeedScale), 1); + if (pd.mouseGraph[i] == 0.0) + { + mouseLeft[mlIndex++] = '.'; + mouseRight[mrIndex++] = '.'; + } + else if (pd.mouseGraph[i] < 0.0) + { + mouseLeft[mlIndex++] = '.'; + mrIndex += strcopy(mouseRight[mrIndex], sizeof(mouseRight) - mrIndex, mouseChars[charIndex]); + } + else if (pd.mouseGraph[i] > 0.0) + { + mlIndex += strcopy(mouseLeft[mlIndex], sizeof(mouseLeft) - mlIndex, mouseChars[charIndex]); + mouseRight[mrIndex++] = '.'; + } + + if (i == 0) + { + hslIndex += strcopy(hudStrafeLeft, sizeof(hudStrafeLeft), "<font color='#FFFFFF'>L: "); + hsrIndex += strcopy(hudStrafeRight, sizeof(hudStrafeRight), "<font color='#FFFFFF'>R: "); + hmIndex += strcopy(hudMouse, sizeof(hudMouse), "<font color='#FFFFFF'>M: "); + } + + if (lastStrafeTypeLeft != strafeTypeLeft) + { + hslIndex += strcopy(hudStrafeLeft[hslIndex], sizeof(hudStrafeLeft) - hslIndex, g_szStrafeTypeColour[strafeTypeLeft]); + } + else + { + hudStrafeLeft[hslIndex++] = '|'; + } + + if (lastStrafeTypeRight != strafeTypeRight) + { + hsrIndex += strcopy(hudStrafeRight[hsrIndex], sizeof(hudStrafeRight) - hsrIndex, g_szStrafeTypeColour[strafeTypeRight]); + } + else + { + hudStrafeRight[hsrIndex++] = '|'; + } + + int mouseIndex = FloatSign(pd.mouseGraph[i]) + 1; + if (mouseIndex != lastMouseIndex) + { + hmIndex += strcopy(hudMouse[hmIndex], sizeof(hudMouse) - hmIndex, mouseColours[mouseIndex]); + } + else + { + hudMouse[hmIndex++] = '|'; + } + + lastStrafeTypeLeft = strafeTypeLeft; + lastStrafeTypeRight = strafeTypeRight; + lastMouseIndex = mouseIndex; + } + + mouseLeft[mlIndex] = '\0'; + mouseRight[mrIndex] = '\0'; + hudStrafeLeft[hslIndex] = '\0'; + hudStrafeRight[hsrIndex] = '\0'; + hudMouse[hmIndex] = '\0'; + + bool showHudGraph = IsSettingEnabled(client, SETTINGS_SHOW_HUD_GRAPH); + if (showHudGraph) + { + // worst case scenario is roughly 11000 characters :D + char strafeGraph[11000]; + FormatEx(strafeGraph, sizeof(strafeGraph), "<u><span class='fontSize-s'>%s<br>%s<br>%s", hudStrafeLeft, hudStrafeRight, hudMouse); + + // TODO: sometimes just after a previous panel has faded out a new panel can't be shown, fix! + ShowPanel(client, 3, strafeGraph); + } + if (!IsSettingEnabled(client, SETTINGS_DISABLE_STRAFE_GRAPH)) + { + ClientAndSpecsPrintConsole(client, "\nStrafe keys:\nL: %s\nR: %s", strafeLeft, strafeRight); + ClientAndSpecsPrintConsole(client, "Mouse movement:\nL: %s\nR: %s\n\n", mouseLeft, mouseRight); + } +} diff --git a/sourcemod/scripting/distbugfix/clientprefs.sp b/sourcemod/scripting/distbugfix/clientprefs.sp new file mode 100644 index 0000000..bee4681 --- /dev/null +++ b/sourcemod/scripting/distbugfix/clientprefs.sp @@ -0,0 +1,51 @@ + + +static Handle distbugCookie; +static int settings[MAXPLAYERS + 1]; + +void OnPluginStart_Clientprefs() +{ + distbugCookie = RegClientCookie("distbugfix_cookie_v2", "cookie for distbugfix", CookieAccess_Private); + if (distbugCookie == INVALID_HANDLE) + { + SetFailState("Couldn't create distbug cookie."); + } +} + +void OnClientCookiesCached_Clientprefs(int client) +{ + char buffer[MAX_COOKIE_SIZE]; + GetClientCookie(client, distbugCookie, buffer, sizeof(buffer)); + + settings[client] = StringToInt(buffer); +} + +void SaveClientCookies(int client) +{ + if (!GCIsValidClient(client) || !AreClientCookiesCached(client)) + { + return; + } + + char buffer[MAX_COOKIE_SIZE]; + IntToString(settings[client], buffer, sizeof(buffer)); + SetClientCookie(client, distbugCookie, buffer); +} + +bool IsSettingEnabled(int client, int setting) +{ + if (GCIsValidClient(client)) + { + return !!(settings[client] & setting); + } + return false; +} + +void ToggleSetting(int client, int setting) +{ + if (GCIsValidClient(client)) + { + settings[client] ^= setting; + SaveClientCookies(client); + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-anticheat.sp b/sourcemod/scripting/gokz-anticheat.sp new file mode 100644 index 0000000..9925eca --- /dev/null +++ b/sourcemod/scripting/gokz-anticheat.sp @@ -0,0 +1,318 @@ +#include <sourcemod> + +#include <dhooks> + +#include <movementapi> +#include <gokz/anticheat> +#include <gokz/core> + +#include <autoexecconfig> + +#undef REQUIRE_EXTENSIONS +#undef REQUIRE_PLUGIN +#include <gokz/localdb> +#include <sourcebanspp> +#include <updater> + +#pragma newdecls required +#pragma semicolon 1 + + + +public Plugin myinfo = +{ + name = "GOKZ Anti-Cheat", + author = "DanZay", + description = "Detects basic player movement cheats", + version = GOKZ_VERSION, + url = GOKZ_SOURCE_URL +}; + +#define UPDATER_URL GOKZ_UPDATER_BASE_URL..."gokz-anticheat.txt" + +bool gB_GOKZLocalDB; +bool gB_SourceBansPP; +bool gB_SourceBans; +bool gB_GOKZGlobal; + +Handle gH_DHooks_OnTeleport; + +int gI_CmdNum[MAXPLAYERS + 1]; +int gI_LastOriginTeleportCmdNum[MAXPLAYERS + 1]; + +int gI_ButtonCount[MAXPLAYERS + 1]; +int gI_ButtonsIndex[MAXPLAYERS + 1]; +int gI_Buttons[MAXPLAYERS + 1][AC_MAX_BUTTON_SAMPLES]; + +int gI_BhopCount[MAXPLAYERS + 1]; +int gI_BhopIndex[MAXPLAYERS + 1]; +int gI_BhopLastTakeoffCmdnum[MAXPLAYERS + 1]; +int gI_BhopLastRecordedBhopCmdnum[MAXPLAYERS + 1]; +bool gB_BhopHitPerf[MAXPLAYERS + 1][AC_MAX_BHOP_SAMPLES]; +int gI_BhopPreJumpInputs[MAXPLAYERS + 1][AC_MAX_BHOP_SAMPLES]; +int gI_BhopPostJumpInputs[MAXPLAYERS + 1][AC_MAX_BHOP_SAMPLES]; +bool gB_BhopPostJumpInputsPending[MAXPLAYERS + 1]; +bool gB_LastLandingWasValid[MAXPLAYERS + 1]; +bool gB_BindExceptionPending[MAXPLAYERS + 1]; +bool gB_BindExceptionPostPending[MAXPLAYERS + 1]; + +ConVar gCV_gokz_autoban; +ConVar gCV_gokz_autoban_duration_bhop_hack; +ConVar gCV_gokz_autoban_duration_bhop_macro; +ConVar gCV_sv_autobunnyhopping; + +#include "gokz-anticheat/api.sp" +#include "gokz-anticheat/bhop_tracking.sp" +#include "gokz-anticheat/commands.sp" + + + +// =====[ PLUGIN EVENTS ]===== + +public APLRes AskPluginLoad2(Handle myself, bool late, char[] error, int err_max) +{ + CreateNatives(); + RegPluginLibrary("gokz-anticheat"); + return APLRes_Success; +} + +public void OnPluginStart() +{ + LoadTranslations("common.phrases"); + LoadTranslations("gokz-common.phrases"); + LoadTranslations("gokz-anticheat.phrases"); + + CreateConVars(); + CreateGlobalForwards(); + HookEvents(); + RegisterCommands(); +} + +public void OnAllPluginsLoaded() +{ + if (LibraryExists("updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + gB_GOKZLocalDB = LibraryExists("gokz-localdb"); + gB_SourceBansPP = LibraryExists("sourcebans++"); + gB_SourceBans = LibraryExists("sourcebans"); + gB_GOKZGlobal = LibraryExists("gokz-global"); + + for (int client = 1; client <= MaxClients; client++) + { + if (IsClientInGame(client)) + { + OnClientPutInServer(client); + } + } +} + +public void OnLibraryAdded(const char[] name) +{ + if (StrEqual(name, "updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + gB_GOKZLocalDB = gB_GOKZLocalDB || StrEqual(name, "gokz-localdb"); + gB_SourceBansPP = gB_SourceBansPP || StrEqual(name, "sourcebans++"); + gB_SourceBans = gB_SourceBans || StrEqual(name, "sourcebans"); + gB_GOKZGlobal = gB_GOKZGlobal || StrEqual(name, "gokz-global"); +} + +public void OnLibraryRemoved(const char[] name) +{ + gB_GOKZLocalDB = gB_GOKZLocalDB && !StrEqual(name, "gokz-localdb"); + gB_SourceBansPP = gB_SourceBansPP && !StrEqual(name, "sourcebans++"); + gB_SourceBans = gB_SourceBans && !StrEqual(name, "sourcebans"); + gB_GOKZGlobal = gB_GOKZGlobal && !StrEqual(name, "gokz-global"); +} + + + +// =====[ CLIENT EVENTS ]===== + +public void OnClientPutInServer(int client) +{ + OnClientPutInServer_BhopTracking(client); + HookClientEvents(client); +} + +public Action OnPlayerRunCmd(int client, int &buttons, int &impulse, float vel[3], float angles[3], int &weapon, int &subtype, int &cmdnum, int &tickcount, int &seed, int mouse[2]) +{ + gI_CmdNum[client] = cmdnum; + return Plugin_Continue; +} + +public void OnPlayerRunCmdPost(int client, int buttons, int impulse, const float vel[3], const float angles[3], int weapon, int subtype, int cmdnum, int tickcount, int seed, const int mouse[2]) +{ + if (!IsPlayerAlive(client) || IsFakeClient(client)) + { + return; + } + + OnPlayerRunCmdPost_BhopTracking(client, buttons, cmdnum); +} + +public MRESReturn DHooks_OnTeleport(int client, Handle params) +{ + // Parameter 1 not null means origin affected + gI_LastOriginTeleportCmdNum[client] = !DHookIsNullParam(params, 1) ? gI_CmdNum[client] : gI_LastOriginTeleportCmdNum[client]; + + // Parameter 3 not null means velocity affected + //gI_LastVelocityTeleportCmdNum[client] = !DHookIsNullParam(params, 3) ? gI_CmdNum[client] : gI_LastVelocityTeleportCmdNum[client]; + + return MRES_Ignored; +} + +public void GOKZ_OnFirstSpawn(int client) +{ + GOKZ_PrintToChat(client, false, "%t", "Anti-Cheat Warning"); +} + +public void GOKZ_AC_OnPlayerSuspected(int client, ACReason reason, const char[] notes, const char[] stats) +{ + LogSuspicion(client, reason, notes, stats); +} + + + +// =====[ PUBLIC ]===== + +void SuspectPlayer(int client, ACReason reason, const char[] notes, const char[] stats) +{ + Call_OnPlayerSuspected(client, reason, notes, stats); + + if (gB_GOKZLocalDB) + { + GOKZ_DB_SetCheater(client, true); + } + + if (gCV_gokz_autoban.BoolValue) + { + BanSuspect(client, reason); + } +} + + + +// =====[ PRIVATE ]===== + +static void CreateConVars() +{ + AutoExecConfig_SetFile("gokz-anticheat", "sourcemod/gokz"); + AutoExecConfig_SetCreateFile(true); + + gCV_gokz_autoban = AutoExecConfig_CreateConVar( + "gokz_autoban", + "1", + "Whether to autoban players when they are suspected of cheating.", + _, + true, + 0.0, + true, + 1.0); + + gCV_gokz_autoban_duration_bhop_hack = AutoExecConfig_CreateConVar( + "gokz_autoban_duration_bhop_hack", + "0", + "Duration of anticheat autobans for bunnyhop hacking in minutes (0 for permanent).", + _, + true, + 0.0); + + gCV_gokz_autoban_duration_bhop_macro = AutoExecConfig_CreateConVar( + "gokz_autoban_duration_bhop_macro", + "43200", // 30 days + "Duration of anticheat autobans for bunnyhop macroing in minutes (0 for permanent).", + _, + true, + 0.0); + + AutoExecConfig_ExecuteFile(); + AutoExecConfig_CleanFile(); + + gCV_sv_autobunnyhopping = FindConVar("sv_autobunnyhopping"); +} + +static void HookEvents() +{ + GameData gameData = new GameData("sdktools.games"); + int offset; + + // Setup DHooks OnTeleport for players + offset = gameData.GetOffset("Teleport"); + gH_DHooks_OnTeleport = DHookCreate(offset, HookType_Entity, ReturnType_Void, ThisPointer_CBaseEntity, DHooks_OnTeleport); + DHookAddParam(gH_DHooks_OnTeleport, HookParamType_VectorPtr); + DHookAddParam(gH_DHooks_OnTeleport, HookParamType_ObjectPtr); + DHookAddParam(gH_DHooks_OnTeleport, HookParamType_VectorPtr); + DHookAddParam(gH_DHooks_OnTeleport, HookParamType_Bool); + + delete gameData; +} + +static void HookClientEvents(int client) +{ + DHookEntity(gH_DHooks_OnTeleport, true, client); +} + +static void LogSuspicion(int client, ACReason reason, const char[] notes, const char[] stats) +{ + char logPath[PLATFORM_MAX_PATH]; + BuildPath(Path_SM, logPath, sizeof(logPath), AC_LOG_PATH); + + switch (reason) + { + case ACReason_BhopHack:LogToFileEx(logPath, "%L was suspected of bhop hacking. Notes - %s, Stats - %s", client, notes, stats); + case ACReason_BhopMacro:LogToFileEx(logPath, "%L was suspected of bhop macroing. Notes - %s, Stats - %s", client, notes, stats); + } +} + +static void BanSuspect(int client, ACReason reason) +{ + char banMessage[128]; + char redirectString[64] = "Contact the server administrator for more info"; + + if (gB_GOKZGlobal) + { + redirectString = "Visit http://rules.global-api.com/ for more info"; + } + + switch (reason) + { + case ACReason_BhopHack: + { + FormatEx(banMessage, sizeof(banMessage), "You have been banned for using a %s.\n%s", "bhop hack", redirectString); + AutoBanClient( + client, + gCV_gokz_autoban_duration_bhop_hack.IntValue, + "gokz-anticheat - Bhop hacking", + banMessage); + } + case ACReason_BhopMacro: + { + FormatEx(banMessage, sizeof(banMessage), "You have been banned for using a %s.\n%s", "bhop macro", redirectString); + AutoBanClient( + client, + gCV_gokz_autoban_duration_bhop_macro.IntValue, + "gokz-anticheat - Bhop macroing", + banMessage); + } + } +} + +static void AutoBanClient(int client, int minutes, const char[] reason, const char[] kickMessage) +{ + if (gB_SourceBansPP) + { + SBPP_BanPlayer(0, client, minutes, reason); + } + else if (gB_SourceBans) + { + SBBanPlayer(0, client, minutes, reason); + } + else + { + BanClient(client, minutes, BANFLAG_AUTO, reason, kickMessage, "gokz-anticheat", 0); + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-anticheat/api.sp b/sourcemod/scripting/gokz-anticheat/api.sp new file mode 100644 index 0000000..7f99724 --- /dev/null +++ b/sourcemod/scripting/gokz-anticheat/api.sp @@ -0,0 +1,174 @@ +static GlobalForward H_OnPlayerSuspected; + + + +// =====[ FORWARDS ]===== + +void CreateGlobalForwards() +{ + H_OnPlayerSuspected = new GlobalForward("GOKZ_AC_OnPlayerSuspected", ET_Ignore, Param_Cell, Param_Cell, Param_String, Param_String); +} + +void Call_OnPlayerSuspected(int client, ACReason reason, const char[] notes, const char[] stats) +{ + Call_StartForward(H_OnPlayerSuspected); + Call_PushCell(client); + Call_PushCell(reason); + Call_PushString(notes); + Call_PushString(stats); + Call_Finish(); +} + + + +// =====[ NATIVES ]===== + +void CreateNatives() +{ + CreateNative("GOKZ_AC_GetSampleSize", Native_GetSampleSize); + CreateNative("GOKZ_AC_GetHitPerf", Native_GetHitPerf); + CreateNative("GOKZ_AC_GetPerfCount", Native_GetPerfCount); + CreateNative("GOKZ_AC_GetPerfRatio", Native_GetPerfRatio); + CreateNative("GOKZ_AC_GetJumpInputs", Native_GetJumpInputs); + CreateNative("GOKZ_AC_GetAverageJumpInputs", Native_GetAverageJumpInputs); + CreateNative("GOKZ_AC_GetPreJumpInputs", Native_GetPreJumpInputs); + CreateNative("GOKZ_AC_GetPostJumpInputs", Native_GetPostJumpInputs); +} + +public int Native_GetSampleSize(Handle plugin, int numParams) +{ + int client = GetNativeCell(1); + return IntMin(gI_BhopCount[client], AC_MAX_BHOP_SAMPLES); +} + +public int Native_GetHitPerf(Handle plugin, int numParams) +{ + int client = GetNativeCell(1); + int sampleSize = IntMin(GOKZ_AC_GetSampleSize(client), GetNativeCell(3)); + + if (sampleSize == 0) + { + return 0; + } + + bool[] perfs = new bool[sampleSize]; + SortByRecent(gB_BhopHitPerf[client], AC_MAX_BHOP_SAMPLES, perfs, sampleSize, gI_BhopIndex[client]); + SetNativeArray(2, perfs, sampleSize); + return sampleSize; +} + +public int Native_GetPerfCount(Handle plugin, int numParams) +{ + int client = GetNativeCell(1); + int sampleSize = IntMin(GOKZ_AC_GetSampleSize(client), GetNativeCell(2)); + + if (sampleSize == 0) + { + return 0; + } + + bool[] perfs = new bool[sampleSize]; + GOKZ_AC_GetHitPerf(client, perfs, sampleSize); + + int perfCount = 0; + for (int i = 0; i < sampleSize; i++) + { + if (perfs[i]) + { + perfCount++; + } + } + return perfCount; +} + +public int Native_GetPerfRatio(Handle plugin, int numParams) +{ + int client = GetNativeCell(1); + int sampleSize = IntMin(GOKZ_AC_GetSampleSize(client), GetNativeCell(2)); + + if (sampleSize == 0) + { + return view_as<int>(0.0); + } + + int perfCount = GOKZ_AC_GetPerfCount(client, sampleSize); + return view_as<int>(float(perfCount) / float(sampleSize)); +} + +public int Native_GetJumpInputs(Handle plugin, int numParams) +{ + int client = GetNativeCell(1); + int sampleSize = IntMin(GOKZ_AC_GetSampleSize(client), GetNativeCell(3)); + + if (sampleSize == 0) + { + return 0; + } + + int[] preJumpInputs = new int[sampleSize]; + SortByRecent(gI_BhopPreJumpInputs[client], AC_MAX_BHOP_SAMPLES, preJumpInputs, sampleSize, gI_BhopIndex[client]); + int[] postJumpInputs = new int[sampleSize]; + SortByRecent(gI_BhopPostJumpInputs[client], AC_MAX_BHOP_SAMPLES, postJumpInputs, sampleSize, gI_BhopIndex[client]); + + int[] jumpInputs = new int[sampleSize]; + for (int i = 0; i < sampleSize; i++) + { + jumpInputs[i] = preJumpInputs[i] + postJumpInputs[i]; + } + + SetNativeArray(2, jumpInputs, sampleSize); + return sampleSize; +} + +public int Native_GetAverageJumpInputs(Handle plugin, int numParams) +{ + int client = GetNativeCell(1); + int sampleSize = IntMin(GOKZ_AC_GetSampleSize(client), GetNativeCell(2)); + + if (sampleSize == 0) + { + return view_as<int>(0.0); + } + + int[] jumpInputs = new int[sampleSize]; + GOKZ_AC_GetJumpInputs(client, jumpInputs, sampleSize); + + int jumpInputCount = 0; + for (int i = 0; i < sampleSize; i++) + { + jumpInputCount += jumpInputs[i]; + } + return view_as<int>(float(jumpInputCount) / float(sampleSize)); +} + +public int Native_GetPreJumpInputs(Handle plugin, int numParams) +{ + int client = GetNativeCell(1); + int sampleSize = IntMin(GOKZ_AC_GetSampleSize(client), GetNativeCell(3)); + + if (sampleSize == 0) + { + return 0; + } + + int[] preJumpInputs = new int[sampleSize]; + SortByRecent(gI_BhopPreJumpInputs[client], AC_MAX_BHOP_SAMPLES, preJumpInputs, sampleSize, gI_BhopIndex[client]); + SetNativeArray(2, preJumpInputs, sampleSize); + return sampleSize; +} + +public int Native_GetPostJumpInputs(Handle plugin, int numParams) +{ + int client = GetNativeCell(1); + int sampleSize = IntMin(GOKZ_AC_GetSampleSize(client), GetNativeCell(3)); + + if (sampleSize == 0) + { + return 0; + } + + int[] postJumpInputs = new int[sampleSize]; + SortByRecent(gI_BhopPostJumpInputs[client], AC_MAX_BHOP_SAMPLES, postJumpInputs, sampleSize, gI_BhopIndex[client]); + SetNativeArray(2, postJumpInputs, sampleSize); + return sampleSize; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-anticheat/bhop_tracking.sp b/sourcemod/scripting/gokz-anticheat/bhop_tracking.sp new file mode 100644 index 0000000..5607b07 --- /dev/null +++ b/sourcemod/scripting/gokz-anticheat/bhop_tracking.sp @@ -0,0 +1,336 @@ +/* + Track player's jump inputs and whether they hit perfect + bunnyhops for a number of their recent bunnyhops. +*/ + + + +// =====[ PUBLIC ]===== + +void PrintBhopCheckToChat(int client, int target) +{ + GOKZ_PrintToChat(client, true, + "{lime}%N {grey}[{lime}%d%%%% {grey}%t | {lime}%.2f {grey}%t]", + target, + RoundFloat(GOKZ_AC_GetPerfRatio(target, 20) * 100.0), + "Perfs", + GOKZ_AC_GetAverageJumpInputs(target, 20), + "Average"); + GOKZ_PrintToChat(client, false, + " {grey}%t - %s", + "Pattern", + GenerateScrollPattern(target, 20)); +} + +void PrintBhopCheckToConsole(int client, int target) +{ + PrintToConsole(client, + "%N [%d%% %t | %.2f %t]\n %t - %s", + target, + RoundFloat(GOKZ_AC_GetPerfRatio(target, 20) * 100.0), + "Perfs", + GOKZ_AC_GetAverageJumpInputs(target, 20), + "Average", + "Pattern", + GenerateScrollPattern(target, 20, false)); +} + +// Generate 'scroll pattern' +char[] GenerateScrollPattern(int client, int sampleSize = AC_MAX_BHOP_SAMPLES, bool colours = true) +{ + char report[512]; + int maxIndex = IntMin(gI_BhopCount[client], sampleSize); + bool[] perfs = new bool[maxIndex]; + GOKZ_AC_GetHitPerf(client, perfs, maxIndex); + int[] jumpInputs = new int[maxIndex]; + GOKZ_AC_GetJumpInputs(client, jumpInputs, maxIndex); + + for (int i = 0; i < maxIndex; i++) + { + if (colours) + { + Format(report, sizeof(report), "%s%s%d ", + report, + perfs[i] ? "{green}" : "{default}", + jumpInputs[i]); + } + else + { + Format(report, sizeof(report), "%s%d%s ", + report, + jumpInputs[i], + perfs[i] ? "*" : ""); + } + } + + TrimString(report); + + return report; +} + +// Generate 'scroll pattern' report showing pre and post inputs instead +char[] GenerateScrollPatternEx(int client, int sampleSize = AC_MAX_BHOP_SAMPLES) +{ + char report[512]; + int maxIndex = IntMin(gI_BhopCount[client], sampleSize); + bool[] perfs = new bool[maxIndex]; + GOKZ_AC_GetHitPerf(client, perfs, maxIndex); + int[] jumpInputs = new int[maxIndex]; + GOKZ_AC_GetJumpInputs(client, jumpInputs, maxIndex); + int[] preJumpInputs = new int[maxIndex]; + GOKZ_AC_GetPreJumpInputs(client, preJumpInputs, maxIndex); + int[] postJumpInputs = new int[maxIndex]; + GOKZ_AC_GetPostJumpInputs(client, postJumpInputs, maxIndex); + + for (int i = 0; i < maxIndex; i++) + { + Format(report, sizeof(report), "%s(%d%s%d)", + report, + preJumpInputs[i], + perfs[i] ? "*" : " ", + postJumpInputs[i]); + } + + TrimString(report); + + return report; +} + + + +// =====[ EVENTS ]===== + +void OnClientPutInServer_BhopTracking(int client) +{ + ResetBhopStats(client); +} + +void OnPlayerRunCmdPost_BhopTracking(int client, int buttons, int cmdnum) +{ + if (gCV_sv_autobunnyhopping.BoolValue) + { + return; + } + + int nextIndex = NextIndex(gI_BhopIndex[client], AC_MAX_BHOP_SAMPLES); + + // Record buttons BEFORE checking for bhop + RecordButtons(client, buttons); + + // If bhop was last tick, then record the pre bhop inputs. + // Require two times the button sample size since the last + // takeoff to avoid pre and post bhop input overlap. + if (HitBhop(client, cmdnum) + && cmdnum >= gI_BhopLastTakeoffCmdnum[client] + AC_MAX_BUTTON_SAMPLES * 2 + && gB_LastLandingWasValid[client]) + { + gB_BhopHitPerf[client][nextIndex] = Movement_GetHitPerf(client); + gI_BhopPreJumpInputs[client][nextIndex] = CountJumpInputs(client); + gI_BhopLastRecordedBhopCmdnum[client] = cmdnum; + gB_BhopPostJumpInputsPending[client] = true; + gB_BindExceptionPending[client] = false; + gB_BindExceptionPostPending[client] = false; + } + + // Bind exception + if (gB_BindExceptionPending[client] && cmdnum > Movement_GetLandingCmdNum(client) + AC_MAX_BHOP_GROUND_TICKS) + { + gB_BhopHitPerf[client][nextIndex] = false; + gI_BhopPreJumpInputs[client][nextIndex] = -1; // Special value for binded jumps + gI_BhopLastRecordedBhopCmdnum[client] = cmdnum; + gB_BhopPostJumpInputsPending[client] = true; + gB_BindExceptionPending[client] = false; + gB_BindExceptionPostPending[client] = true; + } + + // Record post bhop inputs once enough ticks have passed + if (gB_BhopPostJumpInputsPending[client] && cmdnum == gI_BhopLastRecordedBhopCmdnum[client] + AC_MAX_BUTTON_SAMPLES) + { + gI_BhopPostJumpInputs[client][nextIndex] = CountJumpInputs(client); + gB_BhopPostJumpInputsPending[client] = false; + gI_BhopIndex[client] = nextIndex; + gI_BhopCount[client]++; + CheckForBhopMacro(client); + gB_BindExceptionPostPending[client] = false; + } + + // Record last jump takeoff time + if (JustJumped(client, cmdnum)) + { + gI_BhopLastTakeoffCmdnum[client] = cmdnum; + gB_BindExceptionPending[client] = false; + if (gB_BindExceptionPostPending[client]) + { + gB_BhopPostJumpInputsPending[client] = false; + gB_BindExceptionPostPending[client] = false; + } + } + + if (JustLanded(client, cmdnum)) + { + // These conditions exist to reduce false positives. + + // Telehopping is when the player bunnyhops out of a teleport that has a + // destination very close to the ground. This will, more than usual, + // result in a perfect bunnyhop. This is alleviated by checking if the + // player's origin was affected by a teleport last tick. + + // When a player is pressing up against a slope but not ascending it (e.g. + // palm trees on kz_adv_cursedjourney), they will switch between on ground + // and off ground frequently, which means that if they manage to jump, the + // jump will be recorded as a perfect bunnyhop. To ignore this, we check + // the jump is more than 1 tick duration. + + gB_LastLandingWasValid[client] = cmdnum - gI_LastOriginTeleportCmdNum[client] > 1 + && cmdnum - Movement_GetTakeoffCmdNum(client) > 1; + + // You can still crouch-bind VNL jumps and some people just don't know that + // it doesn't work with the other modes in GOKZ. This can cause false positives + // if the player uses the bind for bhops and mostly presses it too early or + // exactly on time rather than too late. This is supposed to reduce those by + // detecting jumps where you don't get a bhop and have exactly one jump input + // before landing and none after landing. We require the one input to be right + // before the jump to make it a lot harder to fake a binded jump when doing + // a regular longjump. + gB_BindExceptionPending[client] = (CountJumpInputs(client, AC_BINDEXCEPTION_SAMPLES) == 1 && CountJumpInputs(client, AC_MAX_BUTTON_SAMPLES) == 1); + gB_BindExceptionPostPending[client] = false; + } +} + + + +// =====[ PRIVATE ]===== + +static void CheckForBhopMacro(int client) +{ + if (GOKZ_AC_GetPerfCount(client, 19) == 19) + { + SuspectPlayer(client, ACReason_BhopHack, "High perf ratio", GenerateBhopBanStats(client, 19)); + } + else if (GOKZ_AC_GetPerfCount(client, 30) >= 28) + { + SuspectPlayer(client, ACReason_BhopHack, "High perf ratio", GenerateBhopBanStats(client, 30)); + } + else if (GOKZ_AC_GetPerfCount(client, 20) >= 16 && GOKZ_AC_GetAverageJumpInputs(client, 20) <= 2.0 + EPSILON) + { + SuspectPlayer(client, ACReason_BhopHack, "1's or 2's scroll pattern", GenerateBhopBanStats(client, 20)); + } + else if (gI_BhopCount[client] >= 20 && GOKZ_AC_GetPerfCount(client, 20) >= 8 + && GOKZ_AC_GetAverageJumpInputs(client, 20) >= 19.0 - EPSILON) + { + SuspectPlayer(client, ACReason_BhopMacro, "High scroll pattern", GenerateBhopBanStats(client, 20)); + } + else if (GOKZ_AC_GetPerfCount(client, 30) >= 10 && CheckForRepeatingJumpInputsCount(client, 25, 30) >= 14) + { + SuspectPlayer(client, ACReason_BhopMacro, "Repeating scroll pattern", GenerateBhopBanStats(client, 30)); + } +} + +static char[] GenerateBhopBanStats(int client, int sampleSize) +{ + char stats[512]; + FormatEx(stats, sizeof(stats), + "Perfs: %d/%d, Average: %.2f, Scroll pattern: %s", + GOKZ_AC_GetPerfCount(client, sampleSize), + IntMin(gI_BhopCount[client], sampleSize), + GOKZ_AC_GetAverageJumpInputs(client, sampleSize), + GenerateScrollPatternEx(client, sampleSize)); + return stats; +} + +/** + * Returns -1, or the repeating input count if there if there is + * an input count that repeats for more than the provided ratio. + * + * @param client Client index. + * @param threshold Minimum frequency to be considered 'repeating'. + * @param sampleSize Maximum recent bhop samples to include in calculation. + * @return The repeating input, or else -1. + */ +static int CheckForRepeatingJumpInputsCount(int client, int threshold, int sampleSize = AC_MAX_BHOP_SAMPLES) +{ + int maxIndex = IntMin(gI_BhopCount[client], sampleSize); + int[] jumpInputs = new int[maxIndex]; + GOKZ_AC_GetJumpInputs(client, jumpInputs, maxIndex); + int maxJumpInputs = AC_MAX_BUTTON_SAMPLES + 1; + int[] jumpInputsFrequency = new int[maxJumpInputs]; + + // Count up all the in jump patterns + for (int i = 0; i < maxIndex; i++) + { + // -1 is a binded jump, those are excluded + if (jumpInputs[i] != -1) + { + jumpInputsFrequency[jumpInputs[i]]++; + } + } + + // Returns i if the given number of the sample size has the same jump input count + for (int i = 1; i < maxJumpInputs; i++) + { + if (jumpInputsFrequency[i] >= threshold) + { + return i; + } + } + + return -1; // -1 if no repeating jump input found +} + +// Reset the tracked bhop stats of the client +static void ResetBhopStats(int client) +{ + gI_ButtonCount[client] = 0; + gI_ButtonsIndex[client] = 0; + gI_BhopCount[client] = 0; + gI_BhopIndex[client] = 0; + gI_BhopLastTakeoffCmdnum[client] = 0; + gI_BhopLastRecordedBhopCmdnum[client] = 0; + gB_BhopPostJumpInputsPending[client] = false; + gB_LastLandingWasValid[client] = false; + gB_BindExceptionPending[client] = false; + gB_BindExceptionPostPending[client] = false; +} + +// Returns true if ther was a jump last tick and was within a number of ticks after landing +static bool HitBhop(int client, int cmdnum) +{ + return JustJumped(client, cmdnum) && Movement_GetTakeoffCmdNum(client) - Movement_GetLandingCmdNum(client) <= AC_MAX_BHOP_GROUND_TICKS; +} + +static bool JustJumped(int client, int cmdnum) +{ + return Movement_GetJumped(client) && Movement_GetTakeoffCmdNum(client) == cmdnum; +} + +static bool JustLanded(int client, int cmdnum) +{ + return Movement_GetLandingCmdNum(client) == cmdnum; +} + +// Records current button inputs +static void RecordButtons(int client, int buttons) +{ + gI_ButtonsIndex[client] = NextIndex(gI_ButtonsIndex[client], AC_MAX_BUTTON_SAMPLES); + gI_Buttons[client][gI_ButtonsIndex[client]] = buttons; + gI_ButtonCount[client]++; +} + +// Counts the number of times buttons went from !IN_JUMP to IN_JUMP +static int CountJumpInputs(int client, int sampleSize = AC_MAX_BUTTON_SAMPLES) +{ + int[] recentButtons = new int[sampleSize]; + SortByRecent(gI_Buttons[client], AC_MAX_BUTTON_SAMPLES, recentButtons, sampleSize, gI_ButtonsIndex[client]); + int maxIndex = IntMin(gI_ButtonCount[client], sampleSize); + int jumps = 0; + + for (int i = 0; i < maxIndex - 1; i++) + { + // If buttons went from !IN_JUMP to IN_JUMP + if (!(recentButtons[i + 1] & IN_JUMP) && recentButtons[i] & IN_JUMP) + { + jumps++; + } + } + return jumps; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-anticheat/commands.sp b/sourcemod/scripting/gokz-anticheat/commands.sp new file mode 100644 index 0000000..a1fbe2e --- /dev/null +++ b/sourcemod/scripting/gokz-anticheat/commands.sp @@ -0,0 +1,76 @@ +void RegisterCommands() +{ + RegAdminCmd("sm_bhopcheck", CommandBhopCheck, ADMFLAG_ROOT, "[KZ] Show bunnyhop stats report including perf ratio and scroll pattern."); +} + +public Action CommandBhopCheck(int client, int args) +{ + if (args == 0) + { + if (GOKZ_AC_GetSampleSize(client) == 0) + { + GOKZ_PrintToChat(client, true, "%t", "Not Enough Bhops (Self)"); + } + else + { + PrintBhopCheckToChat(client, client); + } + return Plugin_Handled; + } + + char arg[65]; + GetCmdArg(1, arg, sizeof(arg)); + char targetName[MAX_TARGET_LENGTH]; + int targetList[MAXPLAYERS], targetCount; + bool tnIsML; + + if ((targetCount = ProcessTargetString( + arg, + client, + targetList, + MAXPLAYERS, + COMMAND_FILTER_NO_IMMUNITY | COMMAND_FILTER_NO_BOTS, + targetName, + sizeof(targetName), + tnIsML)) <= 0) + { + ReplyToTargetError(client, targetCount); + return Plugin_Handled; + } + + if (targetCount >= 2) + { + GOKZ_PrintToChat(client, true, "%t", "See Console"); + for (int i = 0; i < targetCount; i++) + { + if (GOKZ_AC_GetSampleSize(targetList[i]) == 0) + { + PrintToConsole(client, "%t", "Not Enough Bhops (Console)", targetList[i]); + } + else + { + PrintBhopCheckToConsole(client, targetList[i]); + } + } + } + else + { + if (GOKZ_AC_GetSampleSize(targetList[0]) == 0) + { + if (targetList[0] == client) + { + GOKZ_PrintToChat(client, true, "%t", "Not Enough Bhops (Self)"); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Not Enough Bhops", targetList[0]); + } + } + else + { + PrintBhopCheckToChat(client, targetList[0]); + } + } + + return Plugin_Handled; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-chat.sp b/sourcemod/scripting/gokz-chat.sp new file mode 100644 index 0000000..38820f8 --- /dev/null +++ b/sourcemod/scripting/gokz-chat.sp @@ -0,0 +1,309 @@ +#include <sourcemod> + +#include <cstrike> + +#include <gokz/core> + +#include <autoexecconfig> +#include <morecolors> + +#undef REQUIRE_EXTENSIONS +#undef REQUIRE_PLUGIN +#include <basecomm> +#include <updater> + +#pragma newdecls required +#pragma semicolon 1 + + + +public Plugin myinfo = +{ + name = "GOKZ Chat", + author = "DanZay", + description = "Handles client-triggered chat messages", + version = GOKZ_VERSION, + url = GOKZ_SOURCE_URL +}; + +#define UPDATER_URL GOKZ_UPDATER_BASE_URL..."gokz-chat.txt" + +bool gB_BaseComm; +char gC_PlayerTags[MAXPLAYERS + 1][32]; +char gC_PlayerTagColors[MAXPLAYERS + 1][16]; + +ConVar gCV_gokz_chat_processing; +ConVar gCV_gokz_connection_messages; + + + +// =====[ PLUGIN EVENTS ]===== + +public APLRes AskPluginLoad2(Handle myself, bool late, char[] error, int err_max) +{ + CreateNatives(); + RegPluginLibrary("gokz-chat"); + return APLRes_Success; +} + +public void OnPluginStart() +{ + LoadTranslations("gokz-chat.phrases"); + + CreateConVars(); + HookEvents(); + + OnPluginStart_BlockRadio(); + OnPluginStart_BlockChatWheel(); +} + +public void OnAllPluginsLoaded() +{ + if (LibraryExists("updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + gB_BaseComm = LibraryExists("basecomm"); +} + +public void OnLibraryAdded(const char[] name) +{ + if (StrEqual(name, "updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + gB_BaseComm = gB_BaseComm || StrEqual(name, "basecomm"); +} + +public void OnLibraryRemoved(const char[] name) +{ + gB_BaseComm = gB_BaseComm && !StrEqual(name, "basecomm"); +} + + + +// =====[ CLIENT EVENTS ]===== + +public Action OnClientSayCommand(int client, const char[] command, const char[] sArgs) +{ + if (client > 0 && gCV_gokz_chat_processing.BoolValue && IsClientInGame(client)) + { + OnClientSayCommand_ChatProcessing(client, command, sArgs); + return Plugin_Handled; + } + return Plugin_Continue; +} + +public void OnClientConnected(int client) +{ + gC_PlayerTags[client][0] = '\0'; + gC_PlayerTagColors[client][0] = '\0'; +} + +public void OnClientPutInServer(int client) +{ + PrintConnectMessage(client); +} + +public Action OnPlayerDisconnect(Event event, const char[] name, bool dontBroadcast) // player_disconnect pre hook +{ + event.BroadcastDisabled = true; // Block disconnection messages + int client = GetClientOfUserId(event.GetInt("userid")); + if (IsValidClient(client)) + { + PrintDisconnectMessage(client, event); + } + return Plugin_Continue; +} + +public Action OnPlayerJoinTeam(Event event, const char[] name, bool dontBroadcast) // player_team pre hook +{ + event.SetBool("silent", true); // Block join team messages + return Plugin_Continue; +} + + + +// =====[ GENERAL ]===== + +void CreateConVars() +{ + AutoExecConfig_SetFile("gokz-chat", "sourcemod/gokz"); + AutoExecConfig_SetCreateFile(true); + + gCV_gokz_chat_processing = AutoExecConfig_CreateConVar("gokz_chat_processing", "1", "Whether GOKZ processes player chat messages.", _, true, 0.0, true, 1.0); + gCV_gokz_connection_messages = AutoExecConfig_CreateConVar("gokz_connection_messages", "1", "Whether GOKZ handles connection and disconnection messages.", _, true, 0.0, true, 1.0); + + AutoExecConfig_ExecuteFile(); + AutoExecConfig_CleanFile(); +} + +void HookEvents() +{ + HookEvent("player_disconnect", OnPlayerDisconnect, EventHookMode_Pre); + HookEvent("player_team", OnPlayerJoinTeam, EventHookMode_Pre); +} + + + +// =====[ CHAT PROCESSING ]===== + +void OnClientSayCommand_ChatProcessing(int client, const char[] command, const char[] message) +{ + if (gB_BaseComm && BaseComm_IsClientGagged(client) + || UsedBaseChat(client, command, message)) + { + return; + } + + // Resend messages that may have been a command with capital letters + if ((message[0] == '!' || message[0] == '/') && IsCharUpper(message[1])) + { + char loweredMessage[128]; + String_ToLower(message, loweredMessage, sizeof(loweredMessage)); + FakeClientCommand(client, "say %s", loweredMessage); + return; + } + + char sanitisedMessage[128]; + strcopy(sanitisedMessage, sizeof(sanitisedMessage), message); + SanitiseChatInput(sanitisedMessage, sizeof(sanitisedMessage)); + + char sanitisedName[MAX_NAME_LENGTH]; + GetClientName(client, sanitisedName, sizeof(sanitisedName)); + SanitiseChatInput(sanitisedName, sizeof(sanitisedName)); + + if (TrimString(sanitisedMessage) == 0) + { + return; + } + + if (IsSpectating(client)) + { + GOKZ_PrintToChatAll(false, "{default}* %s%s{lime}%s{default} : %s", + gC_PlayerTagColors[client], gC_PlayerTags[client], sanitisedName, sanitisedMessage); + PrintToConsoleAll("* %s%s : %s", gC_PlayerTags[client], sanitisedName, sanitisedMessage); + PrintToServer("* %s%s : %s", gC_PlayerTags[client], sanitisedName, sanitisedMessage); + } + else + { + GOKZ_PrintToChatAll(false, "%s%s{lime}%s{default} : %s", + gC_PlayerTagColors[client], gC_PlayerTags[client], sanitisedName, sanitisedMessage); + PrintToConsoleAll("%s%s : %s", gC_PlayerTags[client], sanitisedName, sanitisedMessage); + PrintToServer("%s%s : %s", gC_PlayerTags[client], sanitisedName, sanitisedMessage); + } +} + +bool UsedBaseChat(int client, const char[] command, const char[] message) +{ + // Assuming base chat is in use, check if message will get processed by basechat + if (message[0] != '@') + { + return false; + } + + if (strcmp(command, "say_team", false) == 0) + { + return true; + } + else if (strcmp(command, "say", false) == 0 && CheckCommandAccess(client, "sm_say", ADMFLAG_CHAT)) + { + return true; + } + + return false; +} + +void SanitiseChatInput(char[] message, int maxlength) +{ + Color_StripFromChatText(message, message, maxlength); + //CRemoveColors(message, maxlength); + // Chat gets double formatted, so replace '%' with '%%%%' to end up with '%' + ReplaceString(message, maxlength, "%", "%%%%"); +} + + + +// =====[ CONNECTION MESSAGES ]===== + +void PrintConnectMessage(int client) +{ + if (!gCV_gokz_connection_messages.BoolValue || IsFakeClient(client)) + { + return; + } + + GOKZ_PrintToChatAll(false, "%t", "Client Connection Message", client); +} + +void PrintDisconnectMessage(int client, Event event) // Hooked to player_disconnect event +{ + if (!gCV_gokz_connection_messages.BoolValue || IsFakeClient(client)) + { + return; + } + + char reason[128]; + event.GetString("reason", reason, sizeof(reason)); + GOKZ_PrintToChatAll(false, "%t", "Client Disconnection Message", client, reason); +} + + + +// =====[ BLOCK RADIO AND CHATWHEEL]===== + +static char radioCommands[][] = +{ + "coverme", "takepoint", "holdpos", "regroup", "followme", "takingfire", "go", + "fallback", "sticktog", "getinpos", "stormfront", "report", "roger", "enemyspot", + "needbackup", "sectorclear", "inposition", "reportingin", "getout", "negative", + "enemydown", "compliment", "thanks", "cheer", "go_a", "go_b", "sorry", "needrop" +}; + +public void OnPluginStart_BlockRadio() +{ + for (int i = 0; i < sizeof(radioCommands); i++) + { + AddCommandListener(CommandBlock, radioCommands[i]); + } +} + +public void OnPluginStart_BlockChatWheel() +{ + AddCommandListener(CommandBlock, "playerchatwheel"); + AddCommandListener(CommandBlock, "chatwheel_ping"); +} + +public Action CommandBlock(int client, const char[] command, int argc) +{ + return Plugin_Handled; +} + + + +// =====[ NATIVES ]===== + +void CreateNatives() +{ + CreateNative("GOKZ_CH_SetChatTag", Native_SetChatTag); +} + +public int Native_SetChatTag(Handle plugin, int numParams) +{ + int client = GetNativeCell(1); + + char str[64]; + GetNativeString(2, str, sizeof(str)); + if (str[0] == '\0') + { + // To prevent the space after the mode + FormatEx(gC_PlayerTags[client], sizeof(gC_PlayerTags[]), "[%s] ", gC_ModeNamesShort[GOKZ_GetCoreOption(client, Option_Mode)]); + } + else + { + FormatEx(gC_PlayerTags[client], sizeof(gC_PlayerTags[]), "[%s %s] ", gC_ModeNamesShort[GOKZ_GetCoreOption(client, Option_Mode)], str); + } + + GetNativeString(3, gC_PlayerTagColors[client], sizeof(gC_PlayerTagColors[])); + return 0; +} diff --git a/sourcemod/scripting/gokz-core.sp b/sourcemod/scripting/gokz-core.sp new file mode 100644 index 0000000..897403f --- /dev/null +++ b/sourcemod/scripting/gokz-core.sp @@ -0,0 +1,543 @@ +#include <sourcemod> + +#include <clientprefs> +#include <cstrike> +#include <dhooks> +#include <regex> +#include <sdkhooks> +#include <sdktools> + +#include <gokz/core> +#include <movementapi> + +#include <autoexecconfig> +#include <sourcemod-colors> + +#undef REQUIRE_EXTENSIONS +#undef REQUIRE_PLUGIN +#include <updater> + +#include <gokz/kzplayer> +#include <gokz/jumpstats> + +#pragma newdecls required +#pragma semicolon 1 + + + +public Plugin myinfo = +{ + name = "GOKZ Core", + author = "DanZay", + description = "Core plugin of the GOKZ plugin set", + version = GOKZ_VERSION, + url = GOKZ_SOURCE_URL +}; + +#define UPDATER_URL GOKZ_UPDATER_BASE_URL..."gokz-core.txt" + +Handle gH_ThisPlugin; +Handle gH_DHooks_OnTeleport; +Handle gH_DHooks_SetModel; + +int gI_CmdNum[MAXPLAYERS + 1]; +int gI_TickCount[MAXPLAYERS + 1]; +bool gB_OldOnGround[MAXPLAYERS + 1]; +int gI_OldButtons[MAXPLAYERS + 1]; +int gI_TeleportCmdNum[MAXPLAYERS + 1]; +bool gB_OriginTeleported[MAXPLAYERS + 1]; +bool gB_VelocityTeleported[MAXPLAYERS + 1]; +bool gB_LateLoad; + +ConVar gCV_gokz_chat_prefix; +ConVar gCV_sv_full_alltalk; + +#include "gokz-core/commands.sp" +#include "gokz-core/modes.sp" +#include "gokz-core/misc.sp" +#include "gokz-core/options.sp" +#include "gokz-core/teleports.sp" +#include "gokz-core/triggerfix.sp" +#include "gokz-core/demofix.sp" +#include "gokz-core/teamnumfix.sp" + +#include "gokz-core/map/buttons.sp" +#include "gokz-core/map/triggers.sp" +#include "gokz-core/map/mapfile.sp" +#include "gokz-core/map/prefix.sp" +#include "gokz-core/map/starts.sp" +#include "gokz-core/map/zones.sp" +#include "gokz-core/map/end.sp" + +#include "gokz-core/menus/mode_menu.sp" +#include "gokz-core/menus/options_menu.sp" + +#include "gokz-core/timer/pause.sp" +#include "gokz-core/timer/timer.sp" +#include "gokz-core/timer/virtual_buttons.sp" + +#include "gokz-core/forwards.sp" +#include "gokz-core/natives.sp" + + + +// =====[ PLUGIN EVENTS ]===== + +public APLRes AskPluginLoad2(Handle myself, bool late, char[] error, int err_max) +{ + if (GetEngineVersion() != Engine_CSGO) + { + SetFailState("GOKZ only supports CS:GO servers."); + } + + gH_ThisPlugin = myself; + gB_LateLoad = late; + + CreateNatives(); + RegPluginLibrary("gokz-core"); + return APLRes_Success; +} + +public void OnPluginStart() +{ + LoadTranslations("common.phrases"); + LoadTranslations("gokz-common.phrases"); + LoadTranslations("gokz-core.phrases"); + + CreateGlobalForwards(); + CreateConVars(); + HookEvents(); + RegisterCommands(); + + OnPluginStart_MapTriggers(); + OnPluginStart_MapButtons(); + OnPluginStart_MapStarts(); + OnPluginStart_MapEnd(); + OnPluginStart_MapZones(); + OnPluginStart_Options(); + OnPluginStart_Triggerfix(); + OnPluginStart_Demofix(); + OnPluginStart_MapFile(); + OnPluginStart_TeamNumber(); +} + +public void OnAllPluginsLoaded() +{ + if (LibraryExists("updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + + OnAllPluginsLoaded_Modes(); + OnAllPluginsLoaded_OptionsMenu(); + + for (int client = 1; client <= MaxClients; client++) + { + if (IsClientInGame(client)) + { + OnClientPutInServer(client); + } + if (AreClientCookiesCached(client)) + { + OnClientCookiesCached(client); + } + } +} + +public void OnLibraryAdded(const char[] name) +{ + if (StrEqual(name, "updater")) + { + Updater_AddPlugin(UPDATER_URL); + } +} + + + +// =====[ CLIENT EVENTS ]===== + +public void OnClientPutInServer(int client) +{ + OnClientPutInServer_Timer(client); + OnClientPutInServer_Pause(client); + OnClientPutInServer_Teleports(client); + OnClientPutInServer_JoinTeam(client); + OnClientPutInServer_FirstSpawn(client); + OnClientPutInServer_VirtualButtons(client); + OnClientPutInServer_Options(client); + OnClientPutInServer_MapTriggers(client); + OnClientPutInServer_Triggerfix(client); + OnClientPutInServer_Noclip(client); + OnClientPutInServer_Turnbinds(client); + HookClientEvents(client); +} + +public void OnClientDisconnect(int client) +{ + OnClientDisconnect_Timer(client); + OnClientDisconnect_ValidJump(client); +} + +public Action OnPlayerRunCmd(int client, int &buttons, int &impulse, float vel[3], float angles[3], int &weapon, int &subtype, int &cmdnum, int &tickcount, int &seed, int mouse[2]) +{ + gI_CmdNum[client] = cmdnum; + gI_TickCount[client] = tickcount; + OnPlayerRunCmd_Triggerfix(client); + OnPlayerRunCmd_MapTriggers(client, buttons); + OnPlayerRunCmd_Turnbinds(client, buttons, tickcount, angles); + return Plugin_Continue; +} + +public void OnPlayerRunCmdPost(int client, int buttons, int impulse, const float vel[3], const float angles[3], int weapon, int subtype, int cmdnum, int tickcount, int seed, const int mouse[2]) +{ + if (!IsValidClient(client)) + { + return; + } + + OnPlayerRunCmdPost_VirtualButtons(client, buttons, cmdnum); // Emulate buttons first + OnPlayerRunCmdPost_Timer(client); // This should be first after emulating buttons + OnPlayerRunCmdPost_ValidJump(client); + UpdateTrackingVariables(client, cmdnum, buttons); // This should be last +} + +public void OnClientCookiesCached(int client) +{ + OnClientCookiesCached_Options(client); +} + +public void OnPlayerSpawn(Event event, const char[] name, bool dontBroadcast) // player_spawn post hook +{ + int client = GetClientOfUserId(event.GetInt("userid")); + if (IsValidClient(client)) + { + OnPlayerSpawn_MapTriggers(client); + OnPlayerSpawn_Modes(client); + OnPlayerSpawn_Pause(client); + OnPlayerSpawn_ValidJump(client); + OnPlayerSpawn_FirstSpawn(client); + OnPlayerSpawn_GodMode(client); + OnPlayerSpawn_PlayerCollision(client); + } +} + +public Action OnPlayerJoinTeam(Event event, const char[] name, bool dontBroadcast) +{ + int client = GetClientOfUserId(event.GetInt("userid")); + if (IsValidClient(client)) + { + OnPlayerJoinTeam_TeamNumber(event, client); + } + return Plugin_Continue; +} + +public Action OnPlayerDeath(Event event, const char[] name, bool dontBroadcast) // player_death pre hook +{ + int client = GetClientOfUserId(event.GetInt("userid")); + if (IsValidClient(client)) + { + OnPlayerDeath_Timer(client); + OnPlayerDeath_ValidJump(client); + OnPlayerDeath_TeamNumber(client); + } + return Plugin_Continue; +} + +public void OnPlayerJump(Event event, const char[] name, bool dontBroadcast) +{ + int client = GetClientOfUserId(event.GetInt("userid")); + OnPlayerJump_Triggers(client); +} + +public MRESReturn DHooks_OnTeleport(int client, Handle params) +{ + gB_OriginTeleported[client] = !DHookIsNullParam(params, 1); // Origin affected + gB_VelocityTeleported[client] = !DHookIsNullParam(params, 3); // Velocity affected + OnTeleport_ValidJump(client); + OnTeleport_DelayVirtualButtons(client); + return MRES_Ignored; +} + +public MRESReturn DHooks_OnSetModel(int client, Handle params) +{ + OnSetModel_PlayerCollision(client); + return MRES_Handled; +} + +public void OnCSPlayerSpawnPost(int client) +{ + if (GetEntPropEnt(client, Prop_Send, "m_hGroundEntity") == -1) + { + SetEntityFlags(client, GetEntityFlags(client) & ~FL_ONGROUND); + } +} + +public void OnClientPreThinkPost(int client) +{ + OnClientPreThinkPost_UseButtons(client); +} + +public void Movement_OnChangeMovetype(int client, MoveType oldMovetype, MoveType newMovetype) +{ + OnChangeMovetype_Timer(client, newMovetype); + OnChangeMovetype_Pause(client, newMovetype); + OnChangeMovetype_ValidJump(client, oldMovetype, newMovetype); + OnChangeMovetype_MapTriggers(client, newMovetype); +} + +public void Movement_OnStartTouchGround(int client) +{ + OnStartTouchGround_MapZones(client); + OnStartTouchGround_MapTriggers(client); +} + +public void Movement_OnStopTouchGround(int client, bool jumped, bool ladderJump, bool jumpbug) +{ + OnStopTouchGround_ValidJump(client, jumped, ladderJump, jumpbug); + OnStopTouchGround_MapTriggers(client); +} + +public void GOKZ_OnTimerStart_Post(int client, int course) +{ + OnTimerStart_JoinTeam(client); + OnTimerStart_Pause(client); + OnTimerStart_Teleports(client); +} + +public void GOKZ_OnTeleportToStart_Post(int client) +{ + OnTeleportToStart_Timer(client); +} + +public void GOKZ_OnCountedTeleport_Post(int client) +{ + OnCountedTeleport_VirtualButtons(client); +} + +public void GOKZ_OnOptionChanged(int client, const char[] option, any newValue) +{ + Option coreOption; + if (!GOKZ_IsCoreOption(option, coreOption)) + { + return; + } + + OnOptionChanged_Options(client, coreOption, newValue); + OnOptionChanged_Timer(client, coreOption); + OnOptionChanged_Mode(client, coreOption); +} + +public void GOKZ_OnJoinTeam(int client, int team) +{ + OnJoinTeam_Pause(client, team); +} + + + +// =====[ OTHER EVENTS ]===== + +public void OnMapStart() +{ + OnMapStart_MapTriggers(); + OnMapStart_KZConfig(); + OnMapStart_Options(); + OnMapStart_Prefix(); + OnMapStart_CourseRegister(); + OnMapStart_MapStarts(); + OnMapStart_MapEnd(); + OnMapStart_VirtualButtons(); + OnMapStart_FixMissingSpawns(); + OnMapStart_Checkpoints(); + OnMapStart_TeamNumber(); + OnMapStart_Demofix(); +} + +public void OnMapEnd() +{ + OnMapEnd_Demofix(); +} + +public void OnGameFrame() +{ + OnGameFrame_TeamNumber(); + OnGameFrame_Triggerfix(); +} + +public void OnConfigsExecuted() +{ + OnConfigsExecuted_TimeLimit(); + OnConfigsExecuted_OptionsMenu(); +} + +public Action OnNormalSound(int clients[MAXPLAYERS], int &numClients, char sample[PLATFORM_MAX_PATH], int &entity, int &channel, float &volume, int &level, int &pitch, int &flags, char soundEntry[PLATFORM_MAX_PATH], int &seed) +{ + if (OnNormalSound_StopSounds(entity) == Plugin_Handled) + { + return Plugin_Handled; + } + return Plugin_Continue; +} + +public void OnEntityCreated(int entity, const char[] classname) +{ + // Don't react to player related entities + if (StrEqual(classname, "predicted_viewmodel") || StrEqual(classname, "item_assaultsuit") + || StrEqual(classname, "cs_bot") || StrEqual(classname, "player") + || StrContains(classname, "weapon") != -1) + { + return; + } + SDKHook(entity, SDKHook_Spawn, OnEntitySpawned); + SDKHook(entity, SDKHook_SpawnPost, OnEntitySpawnedPost); + OnEntityCreated_Triggerfix(entity, classname); +} + +public void OnEntitySpawned(int entity) +{ + OnEntitySpawned_MapTriggers(entity); + OnEntitySpawned_MapButtons(entity); + OnEntitySpawned_MapStarts(entity); + OnEntitySpawned_MapZones(entity); +} + +public void OnEntitySpawnedPost(int entity) +{ + OnEntitySpawnedPost_MapStarts(entity); + OnEntitySpawnedPost_MapEnd(entity); +} + +public void OnClientConnected(int client) +{ + OnClientConnected_Triggerfix(client); +} + +public void OnRoundStart(Event event, const char[] name, bool dontBroadcast) // round_start post no copy hook +{ + if (event == INVALID_HANDLE) + { + OnRoundStart_Timer(); + OnRoundStart_ForceAllTalk(); + OnRoundStart_Demofix(); + return; + } + else + { + char objective[64]; + event.GetString("objective", objective, sizeof(objective)); + /* + External plugins that record GOTV demos can call round_start event to fix demo corruption, + which happens to stop the players' timer. GOKZ should only react on real round start events only. + */ + if (IsRealObjective(objective)) + { + OnRoundStart_Timer(); + OnRoundStart_ForceAllTalk(); + OnRoundStart_Demofix(); + } + } +} + +public Action CS_OnTerminateRound(float &delay, CSRoundEndReason &reason) +{ + return Plugin_Handled; +} + +public void GOKZ_OnModeUnloaded(int mode) +{ + OnModeUnloaded_Options(mode); +} + +public void GOKZ_OnOptionsMenuCreated(TopMenu topMenu) +{ + OnOptionsMenuCreated_OptionsMenu(); +} + +public void GOKZ_OnOptionsMenuReady(TopMenu topMenu) +{ + OnOptionsMenuReady_OptionsMenu(); +} + + + +// =====[ PRIVATE ]===== + +static void CreateConVars() +{ + AutoExecConfig_SetFile("gokz-core", "sourcemod/gokz"); + AutoExecConfig_SetCreateFile(true); + + gCV_gokz_chat_prefix = AutoExecConfig_CreateConVar("gokz_chat_prefix", "{green}KZ {grey}| ", "Chat prefix used for GOKZ messages."); + + AutoExecConfig_ExecuteFile(); + AutoExecConfig_CleanFile(); + + gCV_sv_full_alltalk = FindConVar("sv_full_alltalk"); + + // Remove unwanted flags from constantly changed mode convars - replication is done manually in mode plugins + for (int i = 0; i < MODECVAR_COUNT; i++) + { + FindConVar(gC_ModeCVars[i]).Flags &= ~FCVAR_NOTIFY; + FindConVar(gC_ModeCVars[i]).Flags &= ~FCVAR_REPLICATED; + } +} + +static void HookEvents() +{ + AddCommandsListeners(); + + HookEvent("player_spawn", OnPlayerSpawn, EventHookMode_Post); + HookEvent("player_team", OnPlayerJoinTeam, EventHookMode_Pre); + HookEvent("player_death", OnPlayerDeath, EventHookMode_Pre); + HookEvent("player_jump", OnPlayerJump); + HookEvent("round_start", OnRoundStart, EventHookMode_PostNoCopy); + AddNormalSoundHook(OnNormalSound); + + GameData gameData = new GameData("sdktools.games"); + int offset; + + // Setup DHooks OnTeleport for players + offset = gameData.GetOffset("Teleport"); + gH_DHooks_OnTeleport = DHookCreate(offset, HookType_Entity, ReturnType_Void, ThisPointer_CBaseEntity, DHooks_OnTeleport); + DHookAddParam(gH_DHooks_OnTeleport, HookParamType_VectorPtr); + DHookAddParam(gH_DHooks_OnTeleport, HookParamType_ObjectPtr); + DHookAddParam(gH_DHooks_OnTeleport, HookParamType_VectorPtr); + DHookAddParam(gH_DHooks_OnTeleport, HookParamType_Bool); + + gameData = new GameData("sdktools.games/engine.csgo"); + offset = gameData.GetOffset("SetEntityModel"); + gH_DHooks_SetModel = DHookCreate(offset, HookType_Entity, ReturnType_Void, ThisPointer_CBaseEntity, DHooks_OnSetModel); + DHookAddParam(gH_DHooks_SetModel, HookParamType_CharPtr); + + delete gameData; +} + +static void HookClientEvents(int client) +{ + DHookEntity(gH_DHooks_OnTeleport, true, client); + DHookEntity(gH_DHooks_SetModel, true, client); + SDKHook(client, SDKHook_SpawnPost, OnCSPlayerSpawnPost); + SDKHook(client, SDKHook_PreThinkPost, OnClientPreThinkPost); +} + +static void UpdateTrackingVariables(int client, int cmdnum, int buttons) +{ + if (IsPlayerAlive(client)) + { + gB_OldOnGround[client] = Movement_GetOnGround(client); + } + + gI_OldButtons[client] = buttons; + + if (gB_OriginTeleported[client] || gB_VelocityTeleported[client]) + { + gI_TeleportCmdNum[client] = cmdnum; + } + gB_OriginTeleported[client] = false; + gB_VelocityTeleported[client] = false; +} + +static bool IsRealObjective(char[] objective) +{ + return StrEqual(objective, "PRISON ESCAPE") || StrEqual(objective, "DEATHMATCH") + || StrEqual(objective, "BOMB TARGET") || StrEqual(objective, "HOSTAGE RESCUE"); +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-core/commands.sp b/sourcemod/scripting/gokz-core/commands.sp new file mode 100644 index 0000000..6aba82c --- /dev/null +++ b/sourcemod/scripting/gokz-core/commands.sp @@ -0,0 +1,385 @@ +void RegisterCommands() +{ + RegConsoleCmd("sm_options", CommandOptions, "[KZ] Open the options menu."); + RegConsoleCmd("sm_o", CommandOptions, "[KZ] Open the options menu."); + RegConsoleCmd("sm_checkpoint", CommandMakeCheckpoint, "[KZ] Set a checkpoint."); + RegConsoleCmd("sm_gocheck", CommandTeleportToCheckpoint, "[KZ] Teleport to your current checkpoint."); + RegConsoleCmd("sm_prev", CommandPrevCheckpoint, "[KZ] Go back a checkpoint."); + RegConsoleCmd("sm_next", CommandNextCheckpoint, "[KZ] Go forward a checkpoint."); + RegConsoleCmd("sm_undo", CommandUndoTeleport, "[KZ] Undo teleport."); + RegConsoleCmd("sm_start", CommandTeleportToStart, "[KZ] Teleport to the start."); + RegConsoleCmd("sm_searchstart", CommandSearchStart, "[KZ] Teleport to the start zone/button of a specified course."); + RegConsoleCmd("sm_end", CommandTeleportToEnd, "[KZ] Teleport to the end."); + RegConsoleCmd("sm_restart", CommandTeleportToStart, "[KZ] Teleport to your start position."); + RegConsoleCmd("sm_r", CommandTeleportToStart, "[KZ] Teleport to your start position."); + RegConsoleCmd("sm_setstartpos", CommandSetStartPos, "[KZ] Set your custom start position to your current position."); + RegConsoleCmd("sm_ssp", CommandSetStartPos, "[KZ] Set your custom start position to your current position."); + RegConsoleCmd("sm_clearstartpos", CommandClearStartPos, "[KZ] Clear your custom start position."); + RegConsoleCmd("sm_csp", CommandClearStartPos, "[KZ] Clear your custom start position."); + RegConsoleCmd("sm_main", CommandMain, "[KZ] Teleport to the start of the main course."); + RegConsoleCmd("sm_m", CommandMain, "[KZ] Teleport to the start of the main course."); + RegConsoleCmd("sm_bonus", CommandBonus, "[KZ] Teleport to the start of a bonus. Usage: `!bonus <#bonus>"); + RegConsoleCmd("sm_b", CommandBonus, "[KZ] Teleport to the start of a bonus. Usage: `!b <#bonus>"); + RegConsoleCmd("sm_pause", CommandTogglePause, "[KZ] Toggle pausing your timer and stopping you in your position."); + RegConsoleCmd("sm_resume", CommandTogglePause, "[KZ] Toggle pausing your timer and stopping you in your position."); + RegConsoleCmd("sm_stop", CommandStopTimer, "[KZ] Stop your timer."); + RegConsoleCmd("sm_virtualbuttonindicators", CommandToggleVirtualButtonIndicators, "[KZ] Toggle virtual button indicators."); + RegConsoleCmd("sm_vbi", CommandToggleVirtualButtonIndicators, "[KZ] Toggle virtual button indicators."); + RegConsoleCmd("sm_virtualbuttons", CommandToggleVirtualButtonsLock, "[KZ] Toggle locking virtual buttons, preventing them from being moved."); + RegConsoleCmd("sm_vb", CommandToggleVirtualButtonsLock, "[KZ] Toggle locking virtual buttons, preventing them from being moved."); + RegConsoleCmd("sm_mode", CommandMode, "[KZ] Open the movement mode selection menu."); + RegConsoleCmd("sm_vanilla", CommandVanilla, "[KZ] Switch to the Vanilla mode."); + RegConsoleCmd("sm_vnl", CommandVanilla, "[KZ] Switch to the Vanilla mode."); + RegConsoleCmd("sm_v", CommandVanilla, "[KZ] Switch to the Vanilla mode."); + RegConsoleCmd("sm_simplekz", CommandSimpleKZ, "[KZ] Switch to the SimpleKZ mode."); + RegConsoleCmd("sm_skz", CommandSimpleKZ, "[KZ] Switch to the SimpleKZ mode."); + RegConsoleCmd("sm_s", CommandSimpleKZ, "[KZ] Switch to the SimpleKZ mode."); + RegConsoleCmd("sm_kztimer", CommandKZTimer, "[KZ] Switch to the KZTimer mode."); + RegConsoleCmd("sm_kzt", CommandKZTimer, "[KZ] Switch to the KZTimer mode."); + RegConsoleCmd("sm_k", CommandKZTimer, "[KZ] Switch to the KZTimer mode."); + RegConsoleCmd("sm_nc", CommandToggleNoclip, "[KZ] Toggle noclip."); + RegConsoleCmd("+noclip", CommandEnableNoclip, "[KZ] Noclip on."); + RegConsoleCmd("-noclip", CommandDisableNoclip, "[KZ] Noclip off."); + RegConsoleCmd("sm_ncnt", CommandToggleNoclipNotrigger, "[KZ] Toggle noclip-notrigger."); + RegConsoleCmd("+noclipnt", CommandEnableNoclipNotrigger, "[KZ] Noclip-notrigger on."); + RegConsoleCmd("-noclipnt", CommandDisableNoclipNotrigger, "[KZ] Noclip-notrigger off."); + RegConsoleCmd("sm_sg", CommandNubSafeGuard, "[KZ] Toggle NUB safeguard."); + RegConsoleCmd("sm_safe", CommandNubSafeGuard, "[KZ] Toggle NUB safeguard."); + RegConsoleCmd("sm_safeguard", CommandNubSafeGuard, "[KZ] Toggle NUB safeguard."); + RegConsoleCmd("sm_pro", CommandProSafeGuard, "[KZ] Toggle PRO safeguard."); + RegConsoleCmd("kill", CommandKill); + RegConsoleCmd("killvector", CommandKill); + RegConsoleCmd("explode", CommandKill); + RegConsoleCmd("explodevector", CommandKill); +} + +void AddCommandsListeners() +{ + AddCommandListener(CommandJoinTeam, "jointeam"); +} + +bool SwitchToModeIfAvailable(int client, int mode) +{ + if (!GOKZ_GetModeLoaded(mode)) + { + GOKZ_PrintToChat(client, true, "%t", "Mode Not Available", gC_ModeNames[mode]); + return false; + } + else + { + // Safeguard Check + if (GOKZ_GetCoreOption(client, Option_Safeguard) > Safeguard_Disabled && GOKZ_GetTimerRunning(client) && GOKZ_GetValidTimer(client)) + { + GOKZ_PrintToChat(client, true, "%t", "Safeguard - Blocked"); + GOKZ_PlayErrorSound(client); + return false; + } + GOKZ_SetCoreOption(client, Option_Mode, mode); + return true; + } +} + +public Action CommandKill(int client, int args) +{ + if (IsPlayerAlive(client) && GOKZ_GetCoreOption(client, Option_Safeguard) > Safeguard_Disabled && GOKZ_GetTimerRunning(client) && GOKZ_GetValidTimer(client)) + { + GOKZ_PrintToChat(client, true, "%t", "Safeguard - Blocked"); + GOKZ_PlayErrorSound(client); + return Plugin_Handled; + } + return Plugin_Continue; +} + +public Action CommandOptions(int client, int args) +{ + DisplayOptionsMenu(client); + return Plugin_Handled; +} + +public Action CommandJoinTeam(int client, const char[] command, int argc) +{ + char teamString[4]; + GetCmdArgString(teamString, sizeof(teamString)); + int team = StringToInt(teamString); + + if (team == CS_TEAM_SPECTATOR) + { + if (!GOKZ_GetPaused(client) && !GOKZ_GetCanPause(client)) + { + SendFakeTeamEvent(client); + return Plugin_Handled; + } + } + else if (IsPlayerAlive(client) && GOKZ_GetCoreOption(client, Option_Safeguard) > Safeguard_Disabled && GOKZ_GetTimerRunning(client) && GOKZ_GetValidTimer(client)) + { + GOKZ_PrintToChat(client, true, "%t", "Safeguard - Blocked"); + GOKZ_PlayErrorSound(client); + SendFakeTeamEvent(client); + return Plugin_Handled; + } + GOKZ_JoinTeam(client, team); + return Plugin_Handled; +} + +public Action CommandMakeCheckpoint(int client, int args) +{ + GOKZ_MakeCheckpoint(client); + return Plugin_Handled; +} + +public Action CommandTeleportToCheckpoint(int client, int args) +{ + GOKZ_TeleportToCheckpoint(client); + return Plugin_Handled; +} + +public Action CommandPrevCheckpoint(int client, int args) +{ + GOKZ_PrevCheckpoint(client); + return Plugin_Handled; +} + +public Action CommandNextCheckpoint(int client, int args) +{ + GOKZ_NextCheckpoint(client); + return Plugin_Handled; +} + +public Action CommandUndoTeleport(int client, int args) +{ + GOKZ_UndoTeleport(client); + return Plugin_Handled; +} + +public Action CommandTeleportToStart(int client, int args) +{ + GOKZ_TeleportToStart(client); + return Plugin_Handled; +} + +public Action CommandSearchStart(int client, int args) +{ + if (args == 0) + { + GOKZ_TeleportToSearchStart(client, GetCurrentCourse(client)); + return Plugin_Handled; + } + else + { + char argCourse[4]; + GetCmdArg(1, argCourse, sizeof(argCourse)); + int course = StringToInt(argCourse); + if (GOKZ_IsValidCourse(course, false)) + { + GOKZ_TeleportToSearchStart(client, course); + } + else if (StrEqual(argCourse, "main", false) || course == 0) + { + GOKZ_TeleportToSearchStart(client, 0); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Invalid Course Number", argCourse); + } + } + return Plugin_Handled; +} + +public Action CommandTeleportToEnd(int client, int args) +{ + if (args == 0) + { + GOKZ_TeleportToEnd(client, GetCurrentCourse(client)); + } + else + { + char argCourse[4]; + GetCmdArg(1, argCourse, sizeof(argCourse)); + int course = StringToInt(argCourse); + if (GOKZ_IsValidCourse(course, false)) + { + GOKZ_TeleportToEnd(client, course); + } + else if (StrEqual(argCourse, "main", false) || course == 0) + { + GOKZ_TeleportToEnd(client, 0); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Invalid Course Number", argCourse); + } + } + return Plugin_Handled; +} + +public Action CommandSetStartPos(int client, int args) +{ + SetStartPositionToCurrent(client, StartPositionType_Custom); + + GOKZ_PrintToChat(client, true, "%t", "Set Custom Start Position"); + if (GOKZ_GetCoreOption(client, Option_CheckpointSounds) == CheckpointSounds_Enabled) + { + GOKZ_EmitSoundToClient(client, GOKZ_SOUND_CHECKPOINT, _, "Set Start Position"); + } + + return Plugin_Handled; +} + +public Action CommandClearStartPos(int client, int args) +{ + if (ClearCustomStartPosition(client)) + { + GOKZ_PrintToChat(client, true, "%t", "Cleared Custom Start Position"); + } + + return Plugin_Handled; +} + +public Action CommandMain(int client, int args) +{ + TeleportToCourseStart(client, 0); + return Plugin_Handled; +} + +public Action CommandBonus(int client, int args) +{ + if (args == 0) + { // Go to Bonus 1 + TeleportToCourseStart(client, 1); + } + else + { // Go to specified Bonus # + char argBonus[4]; + GetCmdArg(1, argBonus, sizeof(argBonus)); + int bonus = StringToInt(argBonus); + if (GOKZ_IsValidCourse(bonus, true)) + { + TeleportToCourseStart(client, bonus); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Invalid Bonus Number", argBonus); + } + } + return Plugin_Handled; +} + +public Action CommandTogglePause(int client, int args) +{ + if (!IsPlayerAlive(client)) + { + GOKZ_RespawnPlayer(client); + } + else + { + TogglePause(client); + } + return Plugin_Handled; +} + +public Action CommandStopTimer(int client, int args) +{ + if (TimerStop(client)) + { + GOKZ_PrintToChat(client, true, "%t", "Timer Stopped"); + } + return Plugin_Handled; +} + +public Action CommandToggleVirtualButtonIndicators(int client, int args) +{ + if (GOKZ_GetCoreOption(client, Option_VirtualButtonIndicators) == VirtualButtonIndicators_Disabled) + { + GOKZ_SetCoreOption(client, Option_VirtualButtonIndicators, VirtualButtonIndicators_Enabled); + } + else + { + GOKZ_SetCoreOption(client, Option_VirtualButtonIndicators, VirtualButtonIndicators_Disabled); + } + return Plugin_Handled; +} + +public Action CommandToggleVirtualButtonsLock(int client, int args) +{ + if (ToggleVirtualButtonsLock(client)) + { + GOKZ_PrintToChat(client, true, "%t", "Locked Virtual Buttons"); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Unlocked Virtual Buttons"); + } + return Plugin_Handled; +} + +public Action CommandMode(int client, int args) +{ + DisplayModeMenu(client); + return Plugin_Handled; +} + +public Action CommandVanilla(int client, int args) +{ + SwitchToModeIfAvailable(client, Mode_Vanilla); + return Plugin_Handled; +} + +public Action CommandSimpleKZ(int client, int args) +{ + SwitchToModeIfAvailable(client, Mode_SimpleKZ); + return Plugin_Handled; +} + +public Action CommandKZTimer(int client, int args) +{ + SwitchToModeIfAvailable(client, Mode_KZTimer); + return Plugin_Handled; +} + +public Action CommandToggleNoclip(int client, int args) +{ + ToggleNoclip(client); + return Plugin_Handled; +} + +public Action CommandEnableNoclip(int client, int args) +{ + EnableNoclip(client); + return Plugin_Handled; +} + +public Action CommandDisableNoclip(int client, int args) +{ + DisableNoclip(client); + return Plugin_Handled; +} + +public Action CommandToggleNoclipNotrigger(int client, int args) +{ + ToggleNoclipNotrigger(client); + return Plugin_Handled; +} + +public Action CommandEnableNoclipNotrigger(int client, int args) +{ + EnableNoclipNotrigger(client); + return Plugin_Handled; +} + +public Action CommandDisableNoclipNotrigger(int client, int args) +{ + DisableNoclipNotrigger(client); + return Plugin_Handled; +} + +public Action CommandNubSafeGuard(int client, int args) +{ + ToggleNubSafeGuard(client); + return Plugin_Handled; +} + +public Action CommandProSafeGuard(int client, int args) +{ + ToggleProSafeGuard(client); + return Plugin_Handled; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-core/demofix.sp b/sourcemod/scripting/gokz-core/demofix.sp new file mode 100644 index 0000000..84a9307 --- /dev/null +++ b/sourcemod/scripting/gokz-core/demofix.sp @@ -0,0 +1,110 @@ +static ConVar CV_EnableDemofix; +static Handle H_DemofixTimer; +static bool mapRunning; + +void OnPluginStart_Demofix() +{ + AddCommandListener(Command_Demorestart, "demorestart"); + CV_EnableDemofix = AutoExecConfig_CreateConVar("gokz_demofix", "1", "Whether GOKZ applies demo record fix to server. (0 = Disabled, 1 = Update warmup period once, 2 = Regularly reset warmup period)", _, true, 0.0, true, 2.0); + CV_EnableDemofix.AddChangeHook(OnDemofixConVarChanged); + // If the map is tweaking the warmup value, we need to rerun the fix again. + FindConVar("mp_warmuptime").AddChangeHook(OnDemofixConVarChanged); + // We assume that the map is already loaded on late load. + if (gB_LateLoad) + { + mapRunning = true; + } +} + +void OnMapStart_Demofix() +{ + mapRunning = true; +} + +void OnMapEnd_Demofix() +{ + mapRunning = false; +} + +void OnRoundStart_Demofix() +{ + DoDemoFix(); +} + +public Action Command_Demorestart(int client, const char[] command, int argc) +{ + FixRecord(client); + return Plugin_Continue; +} + +static void FixRecord(int client) +{ + // For some reasons, demo playback speed is absolute trash without a round_start event. + // So whenever the client starts recording a demo, we create the event and send it to them. + Event e = CreateEvent("round_start", true); + int timelimit = FindConVar("mp_timelimit").IntValue; + e.SetInt("timelimit", timelimit); + e.SetInt("fraglimit", 0); + e.SetString("objective", "demofix"); + + e.FireToClient(client); + delete e; +} + +public void OnDemofixConVarChanged(ConVar convar, const char[] oldValue, const char[] newValue) +{ + DoDemoFix(); +} + +public Action Timer_EnableDemoRecord(Handle timer) +{ + EnableDemoRecord(); + return Plugin_Continue; +} + +static void DoDemoFix() +{ + if (H_DemofixTimer != null) + { + delete H_DemofixTimer; + } + // Setting the cvar value to 1 can avoid clogging the demo file and slightly increase performance. + switch (CV_EnableDemofix.IntValue) + { + case 0: + { + if (!mapRunning) + { + return; + } + + GameRules_SetProp("m_bWarmupPeriod", 0); + } + case 1: + { + // Set warmup time to 2^31-1, effectively forever + if (FindConVar("mp_warmuptime").IntValue != 2147483647) + { + FindConVar("mp_warmuptime").SetInt(2147483647); + } + EnableDemoRecord(); + } + case 2: + { + H_DemofixTimer = CreateTimer(1.0, Timer_EnableDemoRecord, _, TIMER_REPEAT); + } + } +} + +static void EnableDemoRecord() +{ + // Enable warmup to allow demo recording + // m_fWarmupPeriodEnd is set in the past to hide the timer UI + if (!mapRunning) + { + return; + } + GameRules_SetProp("m_bWarmupPeriod", 1); + GameRules_SetPropFloat("m_fWarmupPeriodStart", GetGameTime() - 1.0); + GameRules_SetPropFloat("m_fWarmupPeriodEnd", GetGameTime() - 1.0); +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-core/forwards.sp b/sourcemod/scripting/gokz-core/forwards.sp new file mode 100644 index 0000000..efb064f --- /dev/null +++ b/sourcemod/scripting/gokz-core/forwards.sp @@ -0,0 +1,401 @@ +static GlobalForward H_OnOptionsLoaded; +static GlobalForward H_OnOptionChanged; +static GlobalForward H_OnTimerStart; +static GlobalForward H_OnTimerStart_Post; +static GlobalForward H_OnTimerEnd; +static GlobalForward H_OnTimerEnd_Post; +static GlobalForward H_OnTimerEndMessage; +static GlobalForward H_OnTimerStopped; +static GlobalForward H_OnPause; +static GlobalForward H_OnPause_Post; +static GlobalForward H_OnResume; +static GlobalForward H_OnResume_Post; +static GlobalForward H_OnMakeCheckpoint; +static GlobalForward H_OnMakeCheckpoint_Post; +static GlobalForward H_OnTeleportToCheckpoint; +static GlobalForward H_OnTeleportToCheckpoint_Post; +static GlobalForward H_OnTeleport; +static GlobalForward H_OnPrevCheckpoint; +static GlobalForward H_OnPrevCheckpoint_Post; +static GlobalForward H_OnNextCheckpoint; +static GlobalForward H_OnNextCheckpoint_Post; +static GlobalForward H_OnTeleportToStart; +static GlobalForward H_OnTeleportToStart_Post; +static GlobalForward H_OnTeleportToEnd; +static GlobalForward H_OnTeleportToEnd_Post; +static GlobalForward H_OnUndoTeleport; +static GlobalForward H_OnUndoTeleport_Post; +static GlobalForward H_OnCountedTeleport_Post; +static GlobalForward H_OnStartPositionSet_Post; +static GlobalForward H_OnJumpValidated; +static GlobalForward H_OnJumpInvalidated; +static GlobalForward H_OnJoinTeam; +static GlobalForward H_OnFirstSpawn; +static GlobalForward H_OnModeLoaded; +static GlobalForward H_OnModeUnloaded; +static GlobalForward H_OnTimerNativeCalledExternally; +static GlobalForward H_OnOptionsMenuCreated; +static GlobalForward H_OnOptionsMenuReady; +static GlobalForward H_OnCourseRegistered; +static GlobalForward H_OnRunInvalidated; +static GlobalForward H_OnEmitSoundToClient; + +void CreateGlobalForwards() +{ + H_OnOptionsLoaded = new GlobalForward("GOKZ_OnOptionsLoaded", ET_Ignore, Param_Cell); + H_OnOptionChanged = new GlobalForward("GOKZ_OnOptionChanged", ET_Ignore, Param_Cell, Param_String, Param_Cell); + H_OnTimerStart = new GlobalForward("GOKZ_OnTimerStart", ET_Hook, Param_Cell, Param_Cell); + H_OnTimerStart_Post = new GlobalForward("GOKZ_OnTimerStart_Post", ET_Ignore, Param_Cell, Param_Cell); + H_OnTimerEnd = new GlobalForward("GOKZ_OnTimerEnd", ET_Hook, Param_Cell, Param_Cell, Param_Float, Param_Cell); + H_OnTimerEnd_Post = new GlobalForward("GOKZ_OnTimerEnd_Post", ET_Ignore, Param_Cell, Param_Cell, Param_Float, Param_Cell); + H_OnTimerEndMessage = new GlobalForward("GOKZ_OnTimerEndMessage", ET_Hook, Param_Cell, Param_Cell, Param_Float, Param_Cell); + H_OnTimerStopped = new GlobalForward("GOKZ_OnTimerStopped", ET_Ignore, Param_Cell); + H_OnPause = new GlobalForward("GOKZ_OnPause", ET_Hook, Param_Cell); + H_OnPause_Post = new GlobalForward("GOKZ_OnPause_Post", ET_Ignore, Param_Cell); + H_OnResume = new GlobalForward("GOKZ_OnResume", ET_Hook, Param_Cell); + H_OnResume_Post = new GlobalForward("GOKZ_OnResume_Post", ET_Ignore, Param_Cell); + H_OnMakeCheckpoint = new GlobalForward("GOKZ_OnMakeCheckpoint", ET_Hook, Param_Cell); + H_OnMakeCheckpoint_Post = new GlobalForward("GOKZ_OnMakeCheckpoint_Post", ET_Ignore, Param_Cell); + H_OnTeleportToCheckpoint = new GlobalForward("GOKZ_OnTeleportToCheckpoint", ET_Hook, Param_Cell); + H_OnTeleportToCheckpoint_Post = new GlobalForward("GOKZ_OnTeleportToCheckpoint_Post", ET_Ignore, Param_Cell); + H_OnTeleport = new GlobalForward("GOKZ_OnTeleport", ET_Hook, Param_Cell); + H_OnPrevCheckpoint = new GlobalForward("GOKZ_OnPrevCheckpoint", ET_Hook, Param_Cell); + H_OnPrevCheckpoint_Post = new GlobalForward("GOKZ_OnPrevCheckpoint_Post", ET_Ignore, Param_Cell); + H_OnNextCheckpoint = new GlobalForward("GOKZ_OnNextCheckpoint", ET_Hook, Param_Cell); + H_OnNextCheckpoint_Post = new GlobalForward("GOKZ_OnNextCheckpoint_Post", ET_Ignore, Param_Cell); + H_OnTeleportToStart = new GlobalForward("GOKZ_OnTeleportToStart", ET_Hook, Param_Cell, Param_Cell); + H_OnTeleportToStart_Post = new GlobalForward("GOKZ_OnTeleportToStart_Post", ET_Ignore, Param_Cell, Param_Cell); + H_OnTeleportToEnd = new GlobalForward("GOKZ_OnTeleportToEnd", ET_Hook, Param_Cell, Param_Cell); + H_OnTeleportToEnd_Post = new GlobalForward("GOKZ_OnTeleportToEnd_Post", ET_Ignore, Param_Cell, Param_Cell); + H_OnUndoTeleport = new GlobalForward("GOKZ_OnUndoTeleport", ET_Hook, Param_Cell); + H_OnUndoTeleport_Post = new GlobalForward("GOKZ_OnUndoTeleport_Post", ET_Ignore, Param_Cell); + H_OnStartPositionSet_Post = new GlobalForward("GOKZ_OnStartPositionSet_Post", ET_Ignore, Param_Cell, Param_Cell, Param_Array, Param_Array); + H_OnCountedTeleport_Post = new GlobalForward("GOKZ_OnCountedTeleport_Post", ET_Ignore, Param_Cell); + H_OnJumpValidated = new GlobalForward("GOKZ_OnJumpValidated", ET_Ignore, Param_Cell, Param_Cell, Param_Cell, Param_Cell); + H_OnJumpInvalidated = new GlobalForward("GOKZ_OnJumpInvalidated", ET_Ignore, Param_Cell); + H_OnJoinTeam = new GlobalForward("GOKZ_OnJoinTeam", ET_Ignore, Param_Cell, Param_Cell); + H_OnFirstSpawn = new GlobalForward("GOKZ_OnFirstSpawn", ET_Ignore, Param_Cell); + H_OnModeLoaded = new GlobalForward("GOKZ_OnModeLoaded", ET_Ignore, Param_Cell); + H_OnModeUnloaded = new GlobalForward("GOKZ_OnModeUnloaded", ET_Ignore, Param_Cell); + H_OnTimerNativeCalledExternally = new GlobalForward("GOKZ_OnTimerNativeCalledExternally", ET_Event, Param_Cell, Param_Cell); + H_OnOptionsMenuCreated = new GlobalForward("GOKZ_OnOptionsMenuCreated", ET_Ignore, Param_Cell); + H_OnOptionsMenuReady = new GlobalForward("GOKZ_OnOptionsMenuReady", ET_Ignore, Param_Cell); + H_OnCourseRegistered = new GlobalForward("GOKZ_OnCourseRegistered", ET_Ignore, Param_Cell); + H_OnRunInvalidated = new GlobalForward("GOKZ_OnRunInvalidated", ET_Ignore, Param_Cell); + H_OnEmitSoundToClient = new GlobalForward("GOKZ_OnEmitSoundToClient", ET_Hook, Param_Cell, Param_String, Param_FloatByRef, Param_String); +} + +void Call_GOKZ_OnOptionsLoaded(int client) +{ + Call_StartForward(H_OnOptionsLoaded); + Call_PushCell(client); + Call_Finish(); +} + +void Call_GOKZ_OnOptionChanged(int client, const char[] option, int optionValue) +{ + Call_StartForward(H_OnOptionChanged); + Call_PushCell(client); + Call_PushString(option); + Call_PushCell(optionValue); + Call_Finish(); +} + +void Call_GOKZ_OnTimerStart(int client, int course, Action &result) +{ + Call_StartForward(H_OnTimerStart); + Call_PushCell(client); + Call_PushCell(course); + Call_Finish(result); +} + +void Call_GOKZ_OnTimerStart_Post(int client, int course) +{ + Call_StartForward(H_OnTimerStart_Post); + Call_PushCell(client); + Call_PushCell(course); + Call_Finish(); +} + +void Call_GOKZ_OnTimerEnd(int client, int course, float time, int teleportsUsed, Action &result) +{ + Call_StartForward(H_OnTimerEnd); + Call_PushCell(client); + Call_PushCell(course); + Call_PushFloat(time); + Call_PushCell(teleportsUsed); + Call_Finish(result); +} + +void Call_GOKZ_OnTimerEnd_Post(int client, int course, float time, int teleportsUsed) +{ + Call_StartForward(H_OnTimerEnd_Post); + Call_PushCell(client); + Call_PushCell(course); + Call_PushFloat(time); + Call_PushCell(teleportsUsed); + Call_Finish(); +} + +void Call_GOKZ_OnTimerEndMessage(int client, int course, float time, int teleportsUsed, Action &result) +{ + Call_StartForward(H_OnTimerEndMessage); + Call_PushCell(client); + Call_PushCell(course); + Call_PushFloat(time); + Call_PushCell(teleportsUsed); + Call_Finish(result); +} + +void Call_GOKZ_OnTimerStopped(int client) +{ + Call_StartForward(H_OnTimerStopped); + Call_PushCell(client); + Call_Finish(); +} + +void Call_GOKZ_OnPause(int client, Action &result) +{ + Call_StartForward(H_OnPause); + Call_PushCell(client); + Call_Finish(result); +} + +void Call_GOKZ_OnPause_Post(int client) +{ + Call_StartForward(H_OnPause_Post); + Call_PushCell(client); + Call_Finish(); +} + +void Call_GOKZ_OnResume(int client, Action &result) +{ + Call_StartForward(H_OnResume); + Call_PushCell(client); + Call_Finish(result); +} + +void Call_GOKZ_OnResume_Post(int client) +{ + Call_StartForward(H_OnResume_Post); + Call_PushCell(client); + Call_Finish(); +} + +void Call_GOKZ_OnMakeCheckpoint(int client, Action &result) +{ + Call_StartForward(H_OnMakeCheckpoint); + Call_PushCell(client); + Call_Finish(result); +} + +void Call_GOKZ_OnMakeCheckpoint_Post(int client) +{ + Call_StartForward(H_OnMakeCheckpoint_Post); + Call_PushCell(client); + Call_Finish(); +} + +void Call_GOKZ_OnTeleportToCheckpoint(int client, Action &result) +{ + Call_StartForward(H_OnTeleportToCheckpoint); + Call_PushCell(client); + Call_Finish(result); +} + +void Call_GOKZ_OnTeleportToCheckpoint_Post(int client) +{ + Call_StartForward(H_OnTeleportToCheckpoint_Post); + Call_PushCell(client); + Call_Finish(); +} + +void Call_GOKZ_OnTeleport(int client) +{ + Call_StartForward(H_OnTeleport); + Call_PushCell(client); + Call_Finish(); +} + +void Call_GOKZ_OnPrevCheckpoint(int client, Action &result) +{ + Call_StartForward(H_OnPrevCheckpoint); + Call_PushCell(client); + Call_Finish(result); +} + +void Call_GOKZ_OnPrevCheckpoint_Post(int client) +{ + Call_StartForward(H_OnPrevCheckpoint_Post); + Call_PushCell(client); + Call_Finish(); +} + +void Call_GOKZ_OnNextCheckpoint(int client, Action &result) +{ + Call_StartForward(H_OnNextCheckpoint); + Call_PushCell(client); + Call_Finish(result); +} + +void Call_GOKZ_OnNextCheckpoint_Post(int client) +{ + Call_StartForward(H_OnNextCheckpoint_Post); + Call_PushCell(client); + Call_Finish(); +} + +void Call_GOKZ_OnTeleportToStart(int client, int course, Action &result) +{ + Call_StartForward(H_OnTeleportToStart); + Call_PushCell(client); + Call_PushCell(course); + Call_Finish(result); +} + +void Call_GOKZ_OnTeleportToStart_Post(int client, int course) +{ + Call_StartForward(H_OnTeleportToStart_Post); + Call_PushCell(client); + Call_PushCell(course); + Call_Finish(); +} + +void Call_GOKZ_OnTeleportToEnd(int client, int course, Action &result) +{ + Call_StartForward(H_OnTeleportToEnd); + Call_PushCell(client); + Call_PushCell(course); + Call_Finish(result); +} + +void Call_GOKZ_OnTeleportToEnd_Post(int client, int course) +{ + Call_StartForward(H_OnTeleportToEnd_Post); + Call_PushCell(client); + Call_PushCell(course); + Call_Finish(); +} + +void Call_GOKZ_OnUndoTeleport(int client, Action &result) +{ + Call_StartForward(H_OnUndoTeleport); + Call_PushCell(client); + Call_Finish(result); +} + +void Call_GOKZ_OnUndoTeleport_Post(int client) +{ + Call_StartForward(H_OnUndoTeleport_Post); + Call_PushCell(client); + Call_Finish(); +} + +void Call_GOKZ_OnCountedTeleport_Post(int client) +{ + Call_StartForward(H_OnCountedTeleport_Post); + Call_PushCell(client); + Call_Finish(); +} + +void Call_GOKZ_OnStartPositionSet_Post(int client, StartPositionType type, const float origin[3], const float angles[3]) +{ + Call_StartForward(H_OnStartPositionSet_Post); + Call_PushCell(client); + Call_PushCell(type); + Call_PushArray(origin, 3); + Call_PushArray(angles, 3); + Call_Finish(); +} + +void Call_GOKZ_OnJumpValidated(int client, bool jumped, bool ladderJump, bool jumpbug) +{ + Call_StartForward(H_OnJumpValidated); + Call_PushCell(client); + Call_PushCell(jumped); + Call_PushCell(ladderJump); + Call_PushCell(jumpbug); + Call_Finish(); +} + +void Call_GOKZ_OnJumpInvalidated(int client) +{ + Call_StartForward(H_OnJumpInvalidated); + Call_PushCell(client); + Call_Finish(); +} + +void Call_GOKZ_OnJoinTeam(int client, int team) +{ + Call_StartForward(H_OnJoinTeam); + Call_PushCell(client); + Call_PushCell(team); + Call_Finish(); +} + +void Call_GOKZ_OnFirstSpawn(int client) +{ + Call_StartForward(H_OnFirstSpawn); + Call_PushCell(client); + Call_Finish(); +} + +void Call_GOKZ_OnModeLoaded(int mode) +{ + Call_StartForward(H_OnModeLoaded); + Call_PushCell(mode); + Call_Finish(); +} + +void Call_GOKZ_OnModeUnloaded(int mode) +{ + Call_StartForward(H_OnModeUnloaded); + Call_PushCell(mode); + Call_Finish(); +} + +void Call_GOKZ_OnTimerNativeCalledExternally(Handle plugin, int client, Action &result) +{ + Call_StartForward(H_OnTimerNativeCalledExternally); + Call_PushCell(plugin); + Call_PushCell(client); + Call_Finish(result); +} + +void Call_GOKZ_OnOptionsMenuCreated(TopMenu topMenu) +{ + Call_StartForward(H_OnOptionsMenuCreated); + Call_PushCell(topMenu); + Call_Finish(); +} + +void Call_GOKZ_OnOptionsMenuReady(TopMenu topMenu) +{ + Call_StartForward(H_OnOptionsMenuReady); + Call_PushCell(topMenu); + Call_Finish(); +} + +void Call_GOKZ_OnCourseRegistered(int course) +{ + Call_StartForward(H_OnCourseRegistered); + Call_PushCell(course); + Call_Finish(); +} + +void Call_GOKZ_OnRunInvalidated(int client) +{ + Call_StartForward(H_OnRunInvalidated); + Call_PushCell(client); + Call_Finish(); +} + +void Call_GOKZ_OnEmitSoundToClient(int client, const char[] sample, float &volume, const char[] description, Action &result) +{ + Call_StartForward(H_OnEmitSoundToClient); + Call_PushCell(client); + Call_PushString(sample); + Call_PushFloatRef(volume); + Call_PushString(description); + Call_Finish(result); +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-core/map/buttons.sp b/sourcemod/scripting/gokz-core/map/buttons.sp new file mode 100644 index 0000000..8923fbd --- /dev/null +++ b/sourcemod/scripting/gokz-core/map/buttons.sp @@ -0,0 +1,138 @@ +/* + Hooks between specifically named func_buttons and GOKZ. +*/ + + + +static Regex RE_BonusStartButton; +static Regex RE_BonusEndButton; + + + +// =====[ EVENTS ]===== + +void OnPluginStart_MapButtons() +{ + RE_BonusStartButton = CompileRegex(GOKZ_BONUS_START_BUTTON_NAME_REGEX); + RE_BonusEndButton = CompileRegex(GOKZ_BONUS_END_BUTTON_NAME_REGEX); +} + +void OnEntitySpawned_MapButtons(int entity) +{ + char buffer[32]; + + GetEntityClassname(entity, buffer, sizeof(buffer)); + if (!StrEqual("func_button", buffer, false)) + { + return; + } + + if (GetEntityName(entity, buffer, sizeof(buffer)) == 0) + { + return; + } + + int course = 0; + if (StrEqual(GOKZ_START_BUTTON_NAME, buffer, false)) + { + HookSingleEntityOutput(entity, "OnPressed", OnStartButtonPress); + RegisterCourseStart(course); + } + else if (StrEqual(GOKZ_END_BUTTON_NAME, buffer, false)) + { + HookSingleEntityOutput(entity, "OnPressed", OnEndButtonPress); + RegisterCourseEnd(course); + } + else if ((course = GetStartButtonBonusNumber(entity)) != -1) + { + HookSingleEntityOutput(entity, "OnPressed", OnBonusStartButtonPress); + RegisterCourseStart(course); + } + else if ((course = GetEndButtonBonusNumber(entity)) != -1) + { + HookSingleEntityOutput(entity, "OnPressed", OnBonusEndButtonPress); + RegisterCourseEnd(course); + } +} + +public void OnStartButtonPress(const char[] name, int caller, int activator, float delay) +{ + if (!IsValidEntity(caller) || !IsValidClient(activator)) + { + return; + } + + ProcessStartButtonPress(activator, 0); +} + +public void OnEndButtonPress(const char[] name, int caller, int activator, float delay) +{ + if (!IsValidEntity(caller) || !IsValidClient(activator)) + { + return; + } + + ProcessEndButtonPress(activator, 0); +} + +public void OnBonusStartButtonPress(const char[] name, int caller, int activator, float delay) +{ + if (!IsValidEntity(caller) || !IsValidClient(activator)) + { + return; + } + + int course = GetStartButtonBonusNumber(caller); + if (!GOKZ_IsValidCourse(course, true)) + { + return; + } + + ProcessStartButtonPress(activator, course); +} + +public void OnBonusEndButtonPress(const char[] name, int caller, int activator, float delay) +{ + if (!IsValidEntity(caller) || !IsValidClient(activator)) + { + return; + } + + int course = GetEndButtonBonusNumber(caller); + if (!GOKZ_IsValidCourse(course, true)) + { + return; + } + + ProcessEndButtonPress(activator, course); +} + + + +// =====[ PRIVATE ]===== + +static void ProcessStartButtonPress(int client, int course) +{ + if (GOKZ_StartTimer(client, course)) + { + // Only calling on success is intended behaviour (and prevents virtual button exploits) + OnStartButtonPress_Teleports(client, course); + OnStartButtonPress_VirtualButtons(client, course); + } +} + +static void ProcessEndButtonPress(int client, int course) +{ + GOKZ_EndTimer(client, course); + OnEndButtonPress_VirtualButtons(client, course); +} + +static int GetStartButtonBonusNumber(int entity) +{ + return GOKZ_MatchIntFromEntityName(entity, RE_BonusStartButton, 1); +} + +static int GetEndButtonBonusNumber(int entity) +{ + return GOKZ_MatchIntFromEntityName(entity, RE_BonusEndButton, 1); +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-core/map/end.sp b/sourcemod/scripting/gokz-core/map/end.sp new file mode 100644 index 0000000..d119084 --- /dev/null +++ b/sourcemod/scripting/gokz-core/map/end.sp @@ -0,0 +1,155 @@ +/* + Hooks between specifically named end destinations and GOKZ +*/ + + + +static Regex RE_BonusEndButton; +static Regex RE_BonusEndZone; +static CourseTimerType endType[GOKZ_MAX_COURSES]; +static float endOrigin[GOKZ_MAX_COURSES][3]; +static float endAngles[GOKZ_MAX_COURSES][3]; + + + +// =====[ EVENTS ]===== + +void OnPluginStart_MapEnd() +{ + RE_BonusEndButton = CompileRegex(GOKZ_BONUS_END_BUTTON_NAME_REGEX); + RE_BonusEndZone = CompileRegex(GOKZ_BONUS_END_ZONE_NAME_REGEX); +} + +void OnEntitySpawnedPost_MapEnd(int entity) +{ + char buffer[32]; + + GetEntityClassname(entity, buffer, sizeof(buffer)); + + if (StrEqual("trigger_multiple", buffer, false)) + { + bool isEndZone; + if (GetEntityName(entity, buffer, sizeof(buffer)) != 0) + { + if (StrEqual(GOKZ_END_ZONE_NAME, buffer, false)) + { + isEndZone = true; + StoreEnd(0, entity, CourseTimerType_ZoneNew); + } + else if (GetEndZoneBonusNumber(entity) != -1) + { + int course = GetEndZoneBonusNumber(entity); + if (GOKZ_IsValidCourse(course, true)) + { + isEndZone = true; + StoreEnd(course, entity, CourseTimerType_ZoneNew); + } + } + } + if (!isEndZone) + { + TimerButtonTrigger trigger; + if (IsTimerButtonTrigger(entity, trigger) && !trigger.isStartTimer) + { + StoreEnd(trigger.course, entity, CourseTimerType_ZoneLegacy); + } + } + } + else if (StrEqual("func_button", buffer, false)) + { + bool isEndButton; + if (GetEntityName(entity, buffer, sizeof(buffer)) != 0) + { + if (StrEqual(GOKZ_END_BUTTON_NAME, buffer, false)) + { + isEndButton = true; + StoreEnd(0, entity, CourseTimerType_Button); + } + else + { + int course = GetEndButtonBonusNumber(entity); + if (GOKZ_IsValidCourse(course, true)) + { + isEndButton = true; + StoreEnd(course, entity, CourseTimerType_Button); + } + } + } + if (!isEndButton) + { + TimerButtonTrigger trigger; + if (IsTimerButtonTrigger(entity, trigger) && !trigger.isStartTimer) + { + StoreEnd(trigger.course, entity, CourseTimerType_Button); + } + } + } +} + +void OnMapStart_MapEnd() +{ + for (int course = 0; course < GOKZ_MAX_COURSES; course++) + { + endType[course] = CourseTimerType_None; + } +} + +bool GetMapEndPosition(int course, float origin[3], float angles[3]) +{ + if (endType[course] == CourseTimerType_None) + { + return false; + } + + origin = endOrigin[course]; + angles = endAngles[course]; + + return true; +} + + + +// =====[ PRIVATE ]===== + +static void StoreEnd(int course, int entity, CourseTimerType type) +{ + // If StoreEnd is called, then there is at least an end position (even though it might not be a valid one) + if (endType[course] < CourseTimerType_Default) + { + endType[course] = CourseTimerType_Default; + } + + // Real zone is always better than "fake" zones which are better than buttons + // as the buttons found in a map with fake zones aren't meant to be visible. + if (endType[course] >= type) + { + return; + } + + float origin[3], distFromCenter[3]; + GetEntityPositions(entity, origin, endOrigin[course], endAngles[course], distFromCenter); + + // If it is a button or the center of the center of the zone is invalid + if (type == CourseTimerType_Button || !IsSpawnValid(endOrigin[course])) + { + // Attempt with various positions around the entity, pick the first valid one. + if (!FindValidPositionAroundTimerEntity(entity, endOrigin[course], endAngles[course], type == CourseTimerType_Button)) + { + endOrigin[course][2] -= 64.0; // Move the origin down so the eye position is directly on top of the button/zone. + return; + } + } + + // Only update the CourseTimerType if a valid position is found. + endType[course] = type; +} + +static int GetEndButtonBonusNumber(int entity) +{ + return GOKZ_MatchIntFromEntityName(entity, RE_BonusEndButton, 1); +} + +static int GetEndZoneBonusNumber(int entity) +{ + return GOKZ_MatchIntFromEntityName(entity, RE_BonusEndZone, 1); +} diff --git a/sourcemod/scripting/gokz-core/map/mapfile.sp b/sourcemod/scripting/gokz-core/map/mapfile.sp new file mode 100644 index 0000000..db60e7e --- /dev/null +++ b/sourcemod/scripting/gokz-core/map/mapfile.sp @@ -0,0 +1,502 @@ +/* + Mapping API + + Reads data from the current map file. +*/ + +static Regex RE_BonusStartButton; +static Regex RE_BonusEndButton; + +// NOTE: 4 megabyte array for entity lump reading. +static char gEntityLump[4194304]; + +// =====[ PUBLIC ]===== + +void EntlumpParse(StringMap antiBhopTriggers, StringMap teleportTriggers, StringMap timerButtonTriggers, int &mappingApiVersion) +{ + char mapPath[512]; + GetCurrentMap(mapPath, sizeof(mapPath)); + Format(mapPath, sizeof(mapPath), "maps/%s.bsp", mapPath); + + // https://developer.valvesoftware.com/wiki/Source_BSP_File_Format + + File file = OpenFile(mapPath, "rb"); + if (file != INVALID_HANDLE) + { + int identifier; + file.ReadInt32(identifier); + + if (identifier == GOKZ_BSP_HEADER_IDENTIFIER) + { + // skip version number + file.Seek(4, SEEK_CUR); + + // the entity lump info is the first lump in the array, so we don't need to seek any further. + int offset; + int length; + file.ReadInt32(offset); + file.ReadInt32(length); + + // jump to the start of the entity lump + file.Seek(offset, SEEK_SET); + + int charactersRead = file.ReadString(gEntityLump, sizeof(gEntityLump), length); + delete file; + if (charactersRead >= sizeof(gEntityLump) - 1) + { + PushMappingApiError("ERROR: Entity lump: The map's entity lump is too big! Reduce the amount of entities in your map."); + return; + } + gEntityLump[length] = '\0'; + + int index = 0; + + StringMap entity = new StringMap(); + bool gotWorldSpawn = false; + while (EntlumpParseEntity(entity, gEntityLump, index)) + { + char classname[128]; + char targetName[GOKZ_ENTLUMP_MAX_VALUE]; + entity.GetString("classname", classname, sizeof(classname)); + + if (!gotWorldSpawn && StrEqual("worldspawn", classname, false)) + { + gotWorldSpawn = true; + char versionString[32]; + if (entity.GetString("climb_mapping_api_version", versionString, sizeof(versionString))) + { + if (StringToIntEx(versionString, mappingApiVersion) == 0) + { + PushMappingApiError("ERROR: Entity lump: Couldn't parse Mapping API version from map properties: \"%s\".", versionString); + mappingApiVersion = GOKZ_MAPPING_API_VERSION_NONE; + } + } + else + { + // map doesn't have a mapping api version. + mappingApiVersion = GOKZ_MAPPING_API_VERSION_NONE; + } + } + else if (StrEqual("trigger_multiple", classname, false)) + { + TriggerType triggerType; + if (!gotWorldSpawn || mappingApiVersion != GOKZ_MAPPING_API_VERSION_NONE) + { + if (entity.GetString("targetname", targetName, sizeof(targetName))) + { + // get trigger properties if applicable + triggerType = GetTriggerType(targetName); + if (triggerType == TriggerType_Antibhop) + { + AntiBhopTrigger trigger; + if (GetAntiBhopTriggerEntityProperties(trigger, entity)) + { + char key[32]; + IntToString(trigger.hammerID, key, sizeof(key)); + antiBhopTriggers.SetArray(key, trigger, sizeof(trigger)); + } + } + else if (triggerType == TriggerType_Teleport) + { + TeleportTrigger trigger; + if (GetTeleportTriggerEntityProperties(trigger, entity)) + { + char key[32]; + IntToString(trigger.hammerID, key, sizeof(key)); + teleportTriggers.SetArray(key, trigger, sizeof(trigger)); + } + } + } + } + + // Tracking legacy timer triggers that press the timer buttons upon triggered. + if (triggerType == TriggerType_Invalid) + { + char touchOutput[128]; + ArrayList value; + + if (entity.GetString("OnStartTouch", touchOutput, sizeof(touchOutput))) + { + TimerButtonTriggerCheck(touchOutput, sizeof(touchOutput), entity, timerButtonTriggers); + } + else if (entity.GetValue("OnStartTouch", value)) // If there are multiple outputs, we have to check for all of them. + { + for (int i = 0; i < value.Length; i++) + { + value.GetString(i, touchOutput, sizeof(touchOutput)); + TimerButtonTriggerCheck(touchOutput, sizeof(touchOutput), entity, timerButtonTriggers); + } + } + } + } + else if (StrEqual("func_button", classname, false)) + { + char pressOutput[128]; + ArrayList value; + + if (entity.GetString("OnPressed", pressOutput, sizeof(pressOutput))) + { + TimerButtonTriggerCheck(pressOutput, sizeof(pressOutput), entity, timerButtonTriggers); + } + else if (entity.GetValue("OnPressed", value)) // If there are multiple outputs, we have to check for all of them. + { + for (int i = 0; i < value.Length; i++) + { + value.GetString(i, pressOutput, sizeof(pressOutput)); + TimerButtonTriggerCheck(pressOutput, sizeof(pressOutput), entity, timerButtonTriggers); + } + } + } + // clear for next loop + entity.Clear(); + } + delete entity; + } + delete file; + } + else + { + // TODO: do something more elegant + SetFailState("Catastrophic extreme hyperfailure! Mapping API Couldn't open the map file for reading! %s. The map file might be gone or another program is using it.", mapPath); + } +} + + +// =====[ EVENTS ]===== + +void OnPluginStart_MapFile() +{ + char buffer[64]; + char press[8]; + FormatEx(press, sizeof(press), "%s%s", CHAR_ESCAPE, "Press"); + + buffer = GOKZ_BONUS_START_BUTTON_NAME_REGEX; + ReplaceStringEx(buffer, sizeof(buffer), "$", ""); + StrCat(buffer, sizeof(buffer), press); + RE_BonusStartButton = CompileRegex(buffer); + + buffer = GOKZ_BONUS_END_BUTTON_NAME_REGEX; + ReplaceStringEx(buffer, sizeof(buffer), "$", ""); + StrCat(buffer, sizeof(buffer), press); + RE_BonusEndButton = CompileRegex(buffer); +} + + +// =====[ PRIVATE ]===== + +static void EntlumpSkipAllWhiteSpace(char[] entityLump, int &index) +{ + while (IsCharSpace(entityLump[index]) && entityLump[index] != '\0') + { + index++; + } +} + +static int EntlumpGetString(char[] result, int maxLength, int copyCount, char[] entityLump, int entlumpIndex) +{ + int finalLength; + for (int i = 0; i < maxLength - 1 && i < copyCount; i++) + { + if (entityLump[entlumpIndex + i] == '\0') + { + break; + } + result[i] = entityLump[entlumpIndex + i]; + finalLength++; + } + + result[finalLength] = '\0'; + return finalLength; +} + +static EntlumpToken EntlumpGetToken(char[] entityLump, int &entlumpIndex) +{ + EntlumpToken result; + + EntlumpSkipAllWhiteSpace(entityLump, entlumpIndex); + + switch (entityLump[entlumpIndex]) + { + case '{': + { + result.type = EntlumpTokenType_OpenBrace; + EntlumpGetString(result.string, sizeof(result.string), 1, entityLump, entlumpIndex); + entlumpIndex++; + } + case '}': + { + result.type = EntlumpTokenType_CloseBrace; + EntlumpGetString(result.string, sizeof(result.string), 1, entityLump, entlumpIndex); + entlumpIndex++; + } + case '\0': + { + result.type = EntlumpTokenType_EndOfStream; + EntlumpGetString(result.string, sizeof(result.string), 1, entityLump, entlumpIndex); + entlumpIndex++; + } + case '\"': + { + result.type = EntlumpTokenType_Identifier; + int identifierLen; + entlumpIndex++; + for (int i = 0; i < sizeof(result.string) - 1; i++) + { + // NOTE: Unterminated strings can probably never happen, since the map has to be + // loaded by the game first and the engine will fail the load before we get to it. + if (entityLump[entlumpIndex + i] == '\0') + { + result.type = EntlumpTokenType_Unknown; + break; + } + if (entityLump[entlumpIndex + i] == '\"') + { + break; + } + result.string[i] = entityLump[entlumpIndex + i]; + identifierLen++; + } + + entlumpIndex += identifierLen + 1; // +1 to skip over last quotation mark + result.string[identifierLen] = '\0'; + } + default: + { + result.type = EntlumpTokenType_Unknown; + result.string[0] = entityLump[entlumpIndex]; + result.string[1] = '\0'; + } + } + + return result; +} + +static bool EntlumpParseEntity(StringMap result, char[] entityLump, int &entlumpIndex) +{ + EntlumpToken token; + token = EntlumpGetToken(entityLump, entlumpIndex); + if (token.type == EntlumpTokenType_EndOfStream) + { + return false; + } + + // NOTE: The following errors will very very likely never happen, since the entity lump has to be + // loaded by the game first and the engine will fail the load before we get to it. + // But if there's an obscure bug in this code, then we'll know!!! + for (;;) + { + token = EntlumpGetToken(entityLump, entlumpIndex); + switch (token.type) + { + case EntlumpTokenType_OpenBrace: + { + continue; + } + case EntlumpTokenType_Identifier: + { + EntlumpToken valueToken; + valueToken = EntlumpGetToken(entityLump, entlumpIndex); + if (valueToken.type == EntlumpTokenType_Identifier) + { + char tempString[GOKZ_ENTLUMP_MAX_VALUE]; + ArrayList values; + if (result.GetString(token.string, tempString, sizeof(tempString))) + { + result.Remove(token.string); + values = new ArrayList(ByteCountToCells(GOKZ_ENTLUMP_MAX_VALUE)); + values.PushString(tempString); + values.PushString(valueToken.string); + result.SetValue(token.string, values); + } + else if (result.GetValue(token.string, values)) + { + values.PushString(valueToken.string); + } + else + { + result.SetString(token.string, valueToken.string); + } + } + else + { + PushMappingApiError("ERROR: Entity lump: Unexpected token \"%s\".", valueToken.string); + return false; + } + } + case EntlumpTokenType_CloseBrace: + { + break; + } + case EntlumpTokenType_EndOfStream: + { + PushMappingApiError("ERROR: Entity lump: Unexpected end of entity lump! Entity lump parsing failed."); + return false; + } + default: + { + PushMappingApiError("ERROR: Entity lump: Invalid token \"%s\". Entity lump parsing failed.", token.string); + return false; + } + } + } + + return true; +} + +static bool GetHammerIDFromEntityStringMap(int &result, StringMap entity) +{ + char hammerID[32]; + if (!entity.GetString("hammerid", hammerID, sizeof(hammerID)) + || StringToIntEx(hammerID, result) == 0) + { + // if we don't have the hammer id, then we can't match the entity to an existing one! + char origin[64]; + entity.GetString("origin", origin, sizeof(origin)); + PushMappingApiError("ERROR: Failed to parse \"hammerid\" keyvalue on trigger! \"%i\" origin: %s.", result, origin); + return false; + } + return true; +} + +static bool GetAntiBhopTriggerEntityProperties(AntiBhopTrigger result, StringMap entity) +{ + if (!GetHammerIDFromEntityStringMap(result.hammerID, entity)) + { + return false; + } + + char time[32]; + if (!entity.GetString("climb_anti_bhop_time", time, sizeof(time)) + || StringToFloatEx(time, result.time) == 0) + { + result.time = GOKZ_ANTI_BHOP_TRIGGER_DEFAULT_DELAY; + } + + return true; +} + +static bool GetTeleportTriggerEntityProperties(TeleportTrigger result, StringMap entity) +{ + if (!GetHammerIDFromEntityStringMap(result.hammerID, entity)) + { + return false; + } + + char buffer[64]; + if (!entity.GetString("climb_teleport_type", buffer, sizeof(buffer)) + || StringToIntEx(buffer, view_as<int>(result.type)) == 0) + { + result.type = GOKZ_TELEPORT_TRIGGER_DEFAULT_TYPE; + } + + if (!entity.GetString("climb_teleport_destination", result.tpDestination, sizeof(result.tpDestination))) + { + // We don't want triggers without destinations dangling about, so we need to tell everyone about it!!! + PushMappingApiError("ERROR: Could not find \"climb_teleport_destination\" keyvalue on a climb_teleport trigger! hammer id \"%i\".", + result.hammerID); + return false; + } + + if (!entity.GetString("climb_teleport_delay", buffer, sizeof(buffer)) + || StringToFloatEx(buffer, result.delay) == 0) + { + result.delay = GOKZ_TELEPORT_TRIGGER_DEFAULT_DELAY; + } + + if (!entity.GetString("climb_teleport_use_dest_angles", buffer, sizeof(buffer)) + || StringToIntEx(buffer, result.useDestAngles) == 0) + { + result.useDestAngles = GOKZ_TELEPORT_TRIGGER_DEFAULT_USE_DEST_ANGLES; + } + + if (!entity.GetString("climb_teleport_reset_speed", buffer, sizeof(buffer)) + || StringToIntEx(buffer, result.resetSpeed) == 0) + { + result.resetSpeed = GOKZ_TELEPORT_TRIGGER_DEFAULT_RESET_SPEED; + } + + if (!entity.GetString("climb_teleport_reorient_player", buffer, sizeof(buffer)) + || StringToIntEx(buffer, result.reorientPlayer) == 0) + { + result.reorientPlayer = GOKZ_TELEPORT_TRIGGER_DEFAULT_REORIENT_PLAYER; + } + + if (!entity.GetString("climb_teleport_relative", buffer, sizeof(buffer)) + || StringToIntEx(buffer, result.relativeDestination) == 0) + { + result.relativeDestination = GOKZ_TELEPORT_TRIGGER_DEFAULT_RELATIVE_DESTINATION; + } + + // NOTE: Clamping + if (IsBhopTrigger(result.type)) + { + result.delay = FloatMax(result.delay, GOKZ_TELEPORT_TRIGGER_BHOP_MIN_DELAY); + } + else + { + result.delay = FloatMax(result.delay, 0.0); + } + + return true; +} + +static void TimerButtonTriggerCheck(char[] touchOutput, int size, StringMap entity, StringMap timerButtonTriggers) +{ + int course = 0; + char startOutput[128]; + char endOutput[128]; + FormatEx(startOutput, sizeof(startOutput), "%s%s%s", GOKZ_START_BUTTON_NAME, CHAR_ESCAPE, "Press"); + FormatEx(endOutput, sizeof(endOutput), "%s%s%s", GOKZ_END_BUTTON_NAME, CHAR_ESCAPE, "Press"); + if (StrContains(touchOutput, startOutput, false) != -1) + { + TimerButtonTrigger trigger; + if (GetHammerIDFromEntityStringMap(trigger.hammerID, entity)) + { + trigger.course = 0; + trigger.isStartTimer = true; + } + char key[32]; + IntToString(trigger.hammerID, key, sizeof(key)); + timerButtonTriggers.SetArray(key, trigger, sizeof(trigger)); + } + else if (StrContains(touchOutput, endOutput, false) != -1) + { + TimerButtonTrigger trigger; + if (GetHammerIDFromEntityStringMap(trigger.hammerID, entity)) + { + trigger.course = 0; + trigger.isStartTimer = false; + } + char key[32]; + IntToString(trigger.hammerID, key, sizeof(key)); + timerButtonTriggers.SetArray(key, trigger, sizeof(trigger)); + } + else if (RE_BonusStartButton.Match(touchOutput) > 0) + { + RE_BonusStartButton.GetSubString(1, touchOutput, sizeof(size)); + course = StringToInt(touchOutput); + TimerButtonTrigger trigger; + if (GetHammerIDFromEntityStringMap(trigger.hammerID, entity)) + { + trigger.course = course; + trigger.isStartTimer = true; + } + char key[32]; + IntToString(trigger.hammerID, key, sizeof(key)); + timerButtonTriggers.SetArray(key, trigger, sizeof(trigger)); + } + else if (RE_BonusEndButton.Match(touchOutput) > 0) + { + RE_BonusEndButton.GetSubString(1, touchOutput, sizeof(size)); + course = StringToInt(touchOutput); + TimerButtonTrigger trigger; + if (GetHammerIDFromEntityStringMap(trigger.hammerID, entity)) + { + trigger.course = course; + trigger.isStartTimer = false; + } + char key[32]; + IntToString(trigger.hammerID, key, sizeof(key)); + timerButtonTriggers.SetArray(key, trigger, sizeof(trigger)); + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-core/map/prefix.sp b/sourcemod/scripting/gokz-core/map/prefix.sp new file mode 100644 index 0000000..3ecbf89 --- /dev/null +++ b/sourcemod/scripting/gokz-core/map/prefix.sp @@ -0,0 +1,48 @@ +/* + Mapping API - Prefix + + Detects the map's prefix. +*/ + + + +static int currentMapPrefix; + + + +// =====[ PUBLIC ]===== + +int GetCurrentMapPrefix() +{ + return currentMapPrefix; +} + + + +// =====[ LISTENERS ]===== + +void OnMapStart_Prefix() +{ + char map[PLATFORM_MAX_PATH], mapPrefix[PLATFORM_MAX_PATH]; + GetCurrentMapDisplayName(map, sizeof(map)); + + // Get all characters before the first '_' character + for (int i = 0; i < sizeof(mapPrefix); i++) + { + if (map[i] == '\0' || map[i] == '_') + { + break; + } + + mapPrefix[i] = map[i]; + } + + if (StrEqual(mapPrefix[0], "kzpro", false)) + { + currentMapPrefix = MapPrefix_KZPro; + } + else + { + currentMapPrefix = MapPrefix_Other; + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-core/map/starts.sp b/sourcemod/scripting/gokz-core/map/starts.sp new file mode 100644 index 0000000..94d5b33 --- /dev/null +++ b/sourcemod/scripting/gokz-core/map/starts.sp @@ -0,0 +1,219 @@ +/* + Hooks between start destinations and GOKZ. +*/ + + + +static Regex RE_BonusStart; +static bool startExists[GOKZ_MAX_COURSES]; +static float startOrigin[GOKZ_MAX_COURSES][3]; +static float startAngles[GOKZ_MAX_COURSES][3]; + +// Used for SearchStart +static Regex RE_BonusStartButton; +static Regex RE_BonusStartZone; +static CourseTimerType startType[GOKZ_MAX_COURSES]; +static float searchStartOrigin[GOKZ_MAX_COURSES][3]; +static float searchStartAngles[GOKZ_MAX_COURSES][3]; + +// =====[ EVENTS ]===== + +void OnPluginStart_MapStarts() +{ + RE_BonusStart = CompileRegex(GOKZ_BONUS_START_NAME_REGEX); + RE_BonusStartButton = CompileRegex(GOKZ_BONUS_START_BUTTON_NAME_REGEX); + RE_BonusStartZone = CompileRegex(GOKZ_BONUS_START_ZONE_NAME_REGEX); +} + +void OnEntitySpawned_MapStarts(int entity) +{ + char buffer[32]; + + GetEntityClassname(entity, buffer, sizeof(buffer)); + if (!StrEqual("info_teleport_destination", buffer, false)) + { + return; + } + + if (GetEntityName(entity, buffer, sizeof(buffer)) == 0) + { + return; + } + + if (StrEqual(GOKZ_START_NAME, buffer, false)) + { + StoreStart(0, entity); + } + else + { + int course = GetStartBonusNumber(entity); + if (GOKZ_IsValidCourse(course, true)) + { + StoreStart(course, entity); + } + } +} + +void OnEntitySpawnedPost_MapStarts(int entity) +{ + char buffer[32]; + GetEntityClassname(entity, buffer, sizeof(buffer)); + + if (StrEqual("trigger_multiple", buffer, false)) + { + bool isStartZone; + if (GetEntityName(entity, buffer, sizeof(buffer)) != 0) + { + if (StrEqual(GOKZ_START_ZONE_NAME, buffer, false)) + { + isStartZone = true; + StoreSearchStart(0, entity, CourseTimerType_ZoneNew); + } + else if (GetStartZoneBonusNumber(entity) != -1) + { + int course = GetStartZoneBonusNumber(entity); + if (GOKZ_IsValidCourse(course, true)) + { + isStartZone = true; + StoreSearchStart(course, entity, CourseTimerType_ZoneNew); + } + } + } + if (!isStartZone) + { + TimerButtonTrigger trigger; + if (IsTimerButtonTrigger(entity, trigger) && trigger.isStartTimer) + { + StoreSearchStart(trigger.course, entity, CourseTimerType_ZoneLegacy); + } + } + + } + else if (StrEqual("func_button", buffer, false)) + { + bool isStartButton; + if (GetEntityName(entity, buffer, sizeof(buffer)) != 0) + { + if (StrEqual(GOKZ_START_BUTTON_NAME, buffer, false)) + { + isStartButton = true; + StoreSearchStart(0, entity, CourseTimerType_Button); + } + else + { + int course = GetStartButtonBonusNumber(entity); + if (GOKZ_IsValidCourse(course, true)) + { + isStartButton = true; + StoreSearchStart(course, entity, CourseTimerType_Button); + } + } + } + if (!isStartButton) + { + TimerButtonTrigger trigger; + if (IsTimerButtonTrigger(entity, trigger) && trigger.isStartTimer) + { + StoreSearchStart(trigger.course, entity, CourseTimerType_Button); + } + } + } +} + +void OnMapStart_MapStarts() +{ + for (int course = 0; course < GOKZ_MAX_COURSES; course++) + { + startExists[course] = false; + startType[course] = CourseTimerType_None; + } +} + +bool GetMapStartPosition(int course, float origin[3], float angles[3]) +{ + if (!startExists[course]) + { + return false; + } + + origin = startOrigin[course]; + angles = startAngles[course]; + + return true; +} + +bool GetSearchStartPosition(int course, float origin[3], float angles[3]) +{ + if (startType[course] == CourseTimerType_None) + { + return false; + } + + origin = searchStartOrigin[course]; + angles = searchStartAngles[course]; + + return true; +} + +// =====[ PRIVATE ]===== + +static void StoreStart(int course, int entity) +{ + float origin[3], angles[3]; + GetEntPropVector(entity, Prop_Send, "m_vecOrigin", origin); + GetEntPropVector(entity, Prop_Data, "m_angRotation", angles); + angles[2] = 0.0; // Roll should always be 0.0 + + startExists[course] = true; + startOrigin[course] = origin; + startAngles[course] = angles; +} + +static void StoreSearchStart(int course, int entity, CourseTimerType type) +{ + // If StoreSearchStart is called, then there is at least an end position (even though it might not be a valid one) + if (startType[course] < CourseTimerType_Default) + { + startType[course] = CourseTimerType_Default; + } + + // Real zone is always better than "fake" zones which are better than buttons + // as the buttons found in a map with fake zones aren't meant to be visible. + if (startType[course] >= type) + { + return; + } + + float origin[3], distFromCenter[3]; + GetEntityPositions(entity, origin, searchStartOrigin[course], searchStartAngles[course], distFromCenter); + + // If it is a button or the center of the center of the zone is invalid + if (type == CourseTimerType_Button || !IsSpawnValid(searchStartOrigin[course])) + { + // Attempt with various positions around the entity, pick the first valid one. + if (!FindValidPositionAroundTimerEntity(entity, searchStartOrigin[course], searchStartAngles[course], type == CourseTimerType_Button)) + { + searchStartOrigin[course][2] -= 64.0; // Move the origin down so the eye position is directly on top of the button/zone. + return; + } + } + + // Only update the CourseTimerType if a valid position is found. + startType[course] = type; +} + + +static int GetStartBonusNumber(int entity) +{ + return GOKZ_MatchIntFromEntityName(entity, RE_BonusStart, 1); +} + +static int GetStartButtonBonusNumber(int entity) +{ + return GOKZ_MatchIntFromEntityName(entity, RE_BonusStartButton, 1); +} + +static int GetStartZoneBonusNumber(int entity) +{ + return GOKZ_MatchIntFromEntityName(entity, RE_BonusStartZone, 1); +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-core/map/triggers.sp b/sourcemod/scripting/gokz-core/map/triggers.sp new file mode 100644 index 0000000..2444493 --- /dev/null +++ b/sourcemod/scripting/gokz-core/map/triggers.sp @@ -0,0 +1,855 @@ +/* + Mapping API - Triggers + + Implements trigger related features. +*/ + + + +static float lastTrigMultiTouchTime[MAXPLAYERS + 1]; +static float lastTrigTeleTouchTime[MAXPLAYERS + 1]; +static float lastTouchGroundOrLadderTime[MAXPLAYERS + 1]; +static int lastTouchSingleBhopEntRef[MAXPLAYERS + 1]; +static ArrayList lastTouchSequentialBhopEntRefs[MAXPLAYERS + 1]; +static int triggerTouchCount[MAXPLAYERS + 1]; +static int antiCpTriggerTouchCount[MAXPLAYERS + 1]; +static int antiPauseTriggerTouchCount[MAXPLAYERS + 1]; +static int antiJumpstatTriggerTouchCount[MAXPLAYERS + 1]; +static int mapMappingApiVersion = GOKZ_MAPPING_API_VERSION_NONE; +static int bhopTouchCount[MAXPLAYERS + 1]; +static bool jumpedThisTick[MAXPLAYERS + 1]; +static float jumpOrigin[MAXPLAYERS + 1][3]; +static float jumpVelocity[MAXPLAYERS + 1][3]; +static ArrayList triggerTouchList[MAXPLAYERS + 1]; // arraylist of TouchedTrigger that the player is currently touching. this array won't ever get long (unless the mapper does something weird). +static StringMap triggerTouchCounts[MAXPLAYERS + 1]; // stringmap of int touch counts with key being a string of the entity reference. +static StringMap antiBhopTriggers; // stringmap of AntiBhopTrigger with key being a string of the m_iHammerID entprop. +static StringMap teleportTriggers; // stringmap of TeleportTrigger with key being a string of the m_iHammerID entprop. +static StringMap timerButtonTriggers; // stringmap of legacy timer zone triggers with key being a string of the m_iHammerID entprop. +static ArrayList parseErrorStrings; + + + +// =====[ PUBLIC ]===== + +bool BhopTriggersJustTouched(int client) +{ + // NOTE: This is slightly incorrect since we touch triggers in the air, but + // it doesn't matter since we can't checkpoint in the air. + if (bhopTouchCount[client] > 0) + { + return true; + } + // GetEngineTime return changes between calls. We only call it once at the beginning. + float engineTime = GetEngineTime(); + // If the player touches a teleport trigger, increase the delay required + if (engineTime - lastTouchGroundOrLadderTime[client] < GOKZ_MULT_NO_CHECKPOINT_TIME // Just touched ground or ladder + && engineTime - lastTrigMultiTouchTime[client] < GOKZ_MULT_NO_CHECKPOINT_TIME // Just touched trigger_multiple + || engineTime - lastTrigTeleTouchTime[client] < GOKZ_BHOP_NO_CHECKPOINT_TIME) // Just touched trigger_teleport + { + return true; + } + + return Movement_GetMovetype(client) == MOVETYPE_LADDER + && triggerTouchCount[client] > 0 + && engineTime - lastTrigTeleTouchTime[client] < GOKZ_LADDER_NO_CHECKPOINT_TIME; +} + +bool AntiCpTriggerIsTouched(int client) +{ + return antiCpTriggerTouchCount[client] > 0; +} + +bool AntiPauseTriggerIsTouched(int client) +{ + return antiPauseTriggerTouchCount[client] > 0; +} + +void PushMappingApiError(char[] format, any ...) +{ + char error[GOKZ_MAX_MAPTRIGGERS_ERROR_LENGTH]; + VFormat(error, sizeof(error), format, 2); + parseErrorStrings.PushString(error); +} + +TriggerType GetTriggerType(char[] targetName) +{ + TriggerType result = TriggerType_Invalid; + + if (StrEqual(targetName, GOKZ_ANTI_BHOP_TRIGGER_NAME)) + { + result = TriggerType_Antibhop; + } + else if (StrEqual(targetName, GOKZ_TELEPORT_TRIGGER_NAME)) + { + result = TriggerType_Teleport; + } + + return result; +} + +bool IsBhopTrigger(TeleportType type) +{ + return type == TeleportType_MultiBhop + || type == TeleportType_SingleBhop + || type == TeleportType_SequentialBhop; +} + +bool IsTimerButtonTrigger(int entity, TimerButtonTrigger trigger) +{ + char hammerID[32]; + bool gotHammerID = GetEntityHammerIDString(entity, hammerID, sizeof(hammerID)); + if (gotHammerID && timerButtonTriggers.GetArray(hammerID, trigger, sizeof(trigger))) + { + return true; + } + return false; +} + +// =====[ EVENTS ]===== + +void OnPluginStart_MapTriggers() +{ + parseErrorStrings = new ArrayList(ByteCountToCells(GOKZ_MAX_MAPTRIGGERS_ERROR_LENGTH)); + antiBhopTriggers = new StringMap(); + teleportTriggers = new StringMap(); + timerButtonTriggers = new StringMap(); +} + +void OnMapStart_MapTriggers() +{ + parseErrorStrings.Clear(); + antiBhopTriggers.Clear(); + teleportTriggers.Clear(); + timerButtonTriggers.Clear(); + mapMappingApiVersion = GOKZ_MAPPING_API_VERSION_NONE; + EntlumpParse(antiBhopTriggers, teleportTriggers, timerButtonTriggers, mapMappingApiVersion); + + if (mapMappingApiVersion > GOKZ_MAPPING_API_VERSION) + { + SetFailState("Map's mapping api version is too big! Maximum supported version is %i, but map has %i. If you're not on the latest GOKZ version, then update!", + GOKZ_MAPPING_API_VERSION, mapMappingApiVersion); + } +} + +void OnClientPutInServer_MapTriggers(int client) +{ + triggerTouchCount[client] = 0; + antiCpTriggerTouchCount[client] = 0; + antiPauseTriggerTouchCount[client] = 0; + antiJumpstatTriggerTouchCount[client] = 0; + + if (triggerTouchList[client] == null) + { + triggerTouchList[client] = new ArrayList(sizeof(TouchedTrigger)); + } + else + { + triggerTouchList[client].Clear(); + } + + if (triggerTouchCounts[client] == null) + { + triggerTouchCounts[client] = new StringMap(); + } + else + { + triggerTouchCounts[client].Clear(); + } + + bhopTouchCount[client] = 0; + + if (lastTouchSequentialBhopEntRefs[client] == null) + { + lastTouchSequentialBhopEntRefs[client] = new ArrayList(); + } + else + { + lastTouchSequentialBhopEntRefs[client].Clear(); + } +} + +void OnPlayerRunCmd_MapTriggers(int client, int &buttons) +{ + int flags = GetEntityFlags(client); + MoveType moveType = GetEntityMoveType(client); + + // if the player isn't touching any bhop triggers on ground/a ladder, then + // reset the singlebhop and sequential bhop state. + if ((flags & FL_ONGROUND || moveType == MOVETYPE_LADDER) + && bhopTouchCount[client] == 0) + { + ResetBhopState(client); + } + + if (antiJumpstatTriggerTouchCount[client] > 0) + { + if (GetFeatureStatus(FeatureType_Native, "GOKZ_JS_InvalidateJump") == FeatureStatus_Available) + { + GOKZ_JS_InvalidateJump(client); + } + } + + // Check if we're touching any triggers and act accordingly. + // NOTE: Read through the touch list in reverse order, so some + // trigger behaviours will be better. Trust me! + int triggerTouchListLength = triggerTouchList[client].Length; + for (int i = triggerTouchListLength - 1; i >= 0; i--) + { + TouchedTrigger touched; + triggerTouchList[client].GetArray(i, touched); + + if (touched.triggerType == TriggerType_Antibhop) + { + TouchAntibhopTrigger(client, touched, buttons, flags); + } + else if (touched.triggerType == TriggerType_Teleport) + { + // Sometimes due to lag or whatever, the player can be + // teleported twice by the same trigger. This fixes that. + if (TouchTeleportTrigger(client, touched, flags)) + { + RemoveTriggerFromTouchList(client, EntRefToEntIndex(touched.entRef)); + i--; + triggerTouchListLength--; + } + } + } + jumpedThisTick[client] = false; +} + +void OnPlayerSpawn_MapTriggers(int client) +{ + // Print trigger errors every time a player spawns so that + // mappers and testers can very easily spot mistakes in names + // and get them fixed asap. + if (parseErrorStrings.Length > 0) + { + char errStart[] = "ERROR: Errors detected when trying to load triggers!"; + CPrintToChat(client, "{red}%s", errStart); + PrintToConsole(client, "\n%s", errStart); + + int length = parseErrorStrings.Length; + for (int err = 0; err < length; err++) + { + char error[GOKZ_MAX_MAPTRIGGERS_ERROR_LENGTH]; + parseErrorStrings.GetString(err, error, sizeof(error)); + CPrintToChat(client, "{red}%s", error); + PrintToConsole(client, error); + } + CPrintToChat(client, "{red}If the errors get clipped off in the chat, then look in your developer console!\n"); + } +} + +public void OnPlayerJump_Triggers(int client) +{ + jumpedThisTick[client] = true; + GetClientAbsOrigin(client, jumpOrigin[client]); + Movement_GetVelocity(client, jumpVelocity[client]); +} + +void OnEntitySpawned_MapTriggers(int entity) +{ + char classname[32]; + GetEntityClassname(entity, classname, sizeof(classname)); + char name[64]; + GetEntityName(entity, name, sizeof(name)); + + bool triggerMultiple = StrEqual("trigger_multiple", classname); + if (triggerMultiple) + { + char hammerID[32]; + bool gotHammerID = GetEntityHammerIDString(entity, hammerID, sizeof(hammerID)); + + if (StrEqual(GOKZ_TELEPORT_TRIGGER_NAME, name)) + { + TeleportTrigger teleportTrigger; + if (gotHammerID && teleportTriggers.GetArray(hammerID, teleportTrigger, sizeof(teleportTrigger))) + { + HookSingleEntityOutput(entity, "OnStartTouch", OnTeleportTrigTouchStart_MapTriggers); + HookSingleEntityOutput(entity, "OnEndTouch", OnTeleportTrigTouchEnd_MapTriggers); + } + else + { + PushMappingApiError("ERROR: Couldn't match teleport trigger's Hammer ID %s with any Hammer ID from the map.", hammerID); + } + } + else if (StrEqual(GOKZ_ANTI_BHOP_TRIGGER_NAME, name)) + { + AntiBhopTrigger antiBhopTrigger; + if (gotHammerID && antiBhopTriggers.GetArray(hammerID, antiBhopTrigger, sizeof(antiBhopTrigger))) + { + HookSingleEntityOutput(entity, "OnStartTouch", OnAntiBhopTrigTouchStart_MapTriggers); + HookSingleEntityOutput(entity, "OnEndTouch", OnAntiBhopTrigTouchEnd_MapTriggers); + } + else + { + PushMappingApiError("ERROR: Couldn't match antibhop trigger's Hammer ID %s with any Hammer ID from the map.", hammerID); + } + } + else if (StrEqual(GOKZ_BHOP_RESET_TRIGGER_NAME, name)) + { + HookSingleEntityOutput(entity, "OnStartTouch", OnBhopResetTouchStart_MapTriggers); + } + else if (StrEqual(GOKZ_ANTI_CP_TRIGGER_NAME, name, false)) + { + HookSingleEntityOutput(entity, "OnStartTouch", OnAntiCpTrigTouchStart_MapTriggers); + HookSingleEntityOutput(entity, "OnEndTouch", OnAntiCpTrigTouchEnd_MapTriggers); + } + else if (StrEqual(GOKZ_ANTI_PAUSE_TRIGGER_NAME, name, false)) + { + HookSingleEntityOutput(entity, "OnStartTouch", OnAntiPauseTrigTouchStart_MapTriggers); + HookSingleEntityOutput(entity, "OnEndTouch", OnAntiPauseTrigTouchEnd_MapTriggers); + } + else if (StrEqual(GOKZ_ANTI_JUMPSTAT_TRIGGER_NAME, name, false)) + { + HookSingleEntityOutput(entity, "OnStartTouch", OnAntiJumpstatTrigTouchStart_MapTriggers); + HookSingleEntityOutput(entity, "OnEndTouch", OnAntiJumpstatTrigTouchEnd_MapTriggers); + } + else + { + // NOTE: SDKHook touch hooks bypass trigger filters. We want that only with + // non mapping api triggers because it prevents checkpointing on bhop blocks. + SDKHook(entity, SDKHook_StartTouchPost, OnTrigMultTouchStart_MapTriggers); + SDKHook(entity, SDKHook_EndTouchPost, OnTrigMultTouchEnd_MapTriggers); + } + } + else if (StrEqual("trigger_teleport", classname)) + { + SDKHook(entity, SDKHook_StartTouchPost, OnTrigTeleTouchStart_MapTriggers); + SDKHook(entity, SDKHook_EndTouchPost, OnTrigTeleTouchEnd_MapTriggers); + } +} + +public void OnAntiBhopTrigTouchStart_MapTriggers(const char[] output, int entity, int other, float delay) +{ + if (!IsValidClient(other)) + { + return; + } + + int touchCount = IncrementTriggerTouchCount(other, entity); + if (touchCount <= 0) + { + // The trigger has fired a matching endtouch output before + // the starttouch output, so ignore it. + return; + } + + if (jumpedThisTick[other]) + { + TeleportEntity(other, jumpOrigin[other], NULL_VECTOR, jumpVelocity[other]); + } + + AddTriggerToTouchList(other, entity, TriggerType_Antibhop); +} + +public void OnAntiBhopTrigTouchEnd_MapTriggers(const char[] output, int entity, int other, float delay) +{ + if (!IsValidClient(other)) + { + return; + } + + DecrementTriggerTouchCount(other, entity); + RemoveTriggerFromTouchList(other, entity); +} + +public void OnTeleportTrigTouchStart_MapTriggers(const char[] output, int entity, int other, float delay) +{ + if (!IsValidClient(other)) + { + return; + } + + int touchCount = IncrementTriggerTouchCount(other, entity); + if (touchCount <= 0) + { + // The trigger has fired a matching endtouch output before + // the starttouch output, so ignore it. + return; + } + + char key[32]; + GetEntityHammerIDString(entity, key, sizeof(key)); + TeleportTrigger trigger; + if (teleportTriggers.GetArray(key, trigger, sizeof(trigger)) + && IsBhopTrigger(trigger.type)) + { + bhopTouchCount[other]++; + } + + AddTriggerToTouchList(other, entity, TriggerType_Teleport); +} + +public void OnTeleportTrigTouchEnd_MapTriggers(const char[] output, int entity, int other, float delay) +{ + if (!IsValidClient(other)) + { + return; + } + + DecrementTriggerTouchCount(other, entity); + + char key[32]; + GetEntityHammerIDString(entity, key, sizeof(key)); + TeleportTrigger trigger; + if (teleportTriggers.GetArray(key, trigger, sizeof(trigger)) + && IsBhopTrigger(trigger.type)) + { + bhopTouchCount[other]--; + } + + RemoveTriggerFromTouchList(other, entity); +} + +public void OnBhopResetTouchStart_MapTriggers(const char[] output, int entity, int other, float delay) +{ + if (!IsValidClient(other)) + { + return; + } + + ResetBhopState(other); +} + +public void OnAntiCpTrigTouchStart_MapTriggers(const char[] output, int entity, int other, float delay) +{ + if (!IsValidClient(other)) + { + return; + } + + antiCpTriggerTouchCount[other]++; +} + +public void OnAntiCpTrigTouchEnd_MapTriggers(const char[] output, int entity, int other, float delay) +{ + if (!IsValidClient(other)) + { + return; + } + + antiCpTriggerTouchCount[other]--; +} + +public void OnAntiPauseTrigTouchStart_MapTriggers(const char[] output, int entity, int other, float delay) +{ + if (!IsValidClient(other)) + { + return; + } + + antiPauseTriggerTouchCount[other]++; +} + +public void OnAntiPauseTrigTouchEnd_MapTriggers(const char[] output, int entity, int other, float delay) +{ + if (!IsValidClient(other)) + { + return; + } + + antiPauseTriggerTouchCount[other]--; +} + +public void OnAntiJumpstatTrigTouchStart_MapTriggers(const char[] output, int entity, int other, float delay) +{ + if (!IsValidClient(other)) + { + return; + } + + antiJumpstatTriggerTouchCount[other]++; +} + +public void OnAntiJumpstatTrigTouchEnd_MapTriggers(const char[] output, int entity, int other, float delay) +{ + if (!IsValidClient(other)) + { + return; + } + + antiJumpstatTriggerTouchCount[other]--; +} + +public void OnTrigMultTouchStart_MapTriggers(int entity, int other) +{ + if (!IsValidClient(other)) + { + return; + } + + lastTrigMultiTouchTime[other] = GetEngineTime(); + triggerTouchCount[other]++; +} + +public void OnTrigMultTouchEnd_MapTriggers(int entity, int other) +{ + if (!IsValidClient(other)) + { + return; + } + + triggerTouchCount[other]--; +} + +public void OnTrigTeleTouchStart_MapTriggers(int entity, int other) +{ + if (!IsValidClient(other)) + { + return; + } + + lastTrigTeleTouchTime[other] = GetEngineTime(); + triggerTouchCount[other]++; +} + +public void OnTrigTeleTouchEnd_MapTriggers(int entity, int other) +{ + if (!IsValidClient(other)) + { + return; + } + + triggerTouchCount[other]--; +} + +void OnStartTouchGround_MapTriggers(int client) +{ + lastTouchGroundOrLadderTime[client] = GetEngineTime(); + + for (int i = 0; i < triggerTouchList[client].Length; i++) + { + TouchedTrigger touched; + triggerTouchList[client].GetArray(i, touched); + // set the touched tick to the tick that the player touches the ground. + touched.groundTouchTick = gI_TickCount[client]; + triggerTouchList[client].SetArray(i, touched); + } +} + +void OnStopTouchGround_MapTriggers(int client) +{ + for (int i = 0; i < triggerTouchList[client].Length; i++) + { + TouchedTrigger touched; + triggerTouchList[client].GetArray(i, touched); + + if (touched.triggerType == TriggerType_Teleport) + { + char key[32]; + GetEntityHammerIDString(touched.entRef, key, sizeof(key)); + TeleportTrigger trigger; + // set last touched triggers for single and sequential bhop. + if (teleportTriggers.GetArray(key, trigger, sizeof(trigger)) + && IsBhopTrigger(trigger.type)) + { + if (trigger.type == TeleportType_SequentialBhop) + { + lastTouchSequentialBhopEntRefs[client].Push(touched.entRef); + } + // NOTE: For singlebhops, we don't care which type of bhop we last touched, because + // otherwise jumping back and forth between a multibhop and a singlebhop wouldn't work. + if (i == 0 && IsBhopTrigger(trigger.type)) + { + // We only want to set this once in this loop. + lastTouchSingleBhopEntRef[client] = touched.entRef; + } + } + } + } +} + +void OnChangeMovetype_MapTriggers(int client, MoveType newMovetype) +{ + if (newMovetype == MOVETYPE_LADDER) + { + lastTouchGroundOrLadderTime[client] = GetEngineTime(); + } +} + + + +// =====[ PRIVATE ]===== + +static void AddTriggerToTouchList(int client, int trigger, TriggerType triggerType) +{ + int triggerEntRef = EntIndexToEntRef(trigger); + + TouchedTrigger touched; + touched.triggerType = triggerType; + touched.entRef = triggerEntRef; + touched.startTouchTick = gI_TickCount[client]; + touched.groundTouchTick = -1; + if (GetEntityFlags(client) & FL_ONGROUND) + { + touched.groundTouchTick = gI_TickCount[client]; + } + + triggerTouchList[client].PushArray(touched); +} + +static void RemoveTriggerFromTouchList(int client, int trigger) +{ + int triggerEntRef = EntIndexToEntRef(trigger); + for (int i = 0; i < triggerTouchList[client].Length; i++) + { + TouchedTrigger touched; + triggerTouchList[client].GetArray(i, touched); + if (touched.entRef == triggerEntRef) + { + triggerTouchList[client].Erase(i); + break; + } + } +} + +static int IncrementTriggerTouchCount(int client, int trigger) +{ + int entref = EntIndexToEntRef(trigger); + char szEntref[64]; + FormatEx(szEntref, sizeof(szEntref), "%i", entref); + + int value = 0; + triggerTouchCounts[client].GetValue(szEntref, value); + + value += 1; + triggerTouchCounts[client].SetValue(szEntref, value); + + return value; +} + +static void DecrementTriggerTouchCount(int client, int trigger) +{ + int entref = EntIndexToEntRef(trigger); + char szEntref[64]; + FormatEx(szEntref, sizeof(szEntref), "%i", entref); + + int value = 0; + triggerTouchCounts[client].GetValue(szEntref, value); + + value -= 1; + triggerTouchCounts[client].SetValue(szEntref, value); +} + +static void TouchAntibhopTrigger(int client, TouchedTrigger touched, int &newButtons, int flags) +{ + if (!(flags & FL_ONGROUND)) + { + // Disable jump when the player is in the air. + // This is a very simple way to fix jumpbugging antibhop triggers. + newButtons &= ~IN_JUMP; + return; + } + + if (touched.groundTouchTick == -1) + { + // The player hasn't touched the ground inside this trigger yet. + return; + } + + char key[32]; + GetEntityHammerIDString(touched.entRef, key, sizeof(key)); + AntiBhopTrigger trigger; + if (antiBhopTriggers.GetArray(key, trigger, sizeof(trigger))) + { + float touchTime = CalculateGroundTouchTime(client, touched); + if (trigger.time == 0.0 || touchTime <= trigger.time) + { + // disable jump + newButtons &= ~IN_JUMP; + } + } +} + +static bool TouchTeleportTrigger(int client, TouchedTrigger touched, int flags) +{ + bool shouldTeleport = false; + + char key[32]; + GetEntityHammerIDString(touched.entRef, key, sizeof(key)); + TeleportTrigger trigger; + if (!teleportTriggers.GetArray(key, trigger, sizeof(trigger))) + { + // Couldn't get the teleport trigger from the trigger array for some reason. + return shouldTeleport; + } + + bool isBhopTrigger = IsBhopTrigger(trigger.type); + // NOTE: Player hasn't touched the ground inside this trigger yet. + if (touched.groundTouchTick == -1 && isBhopTrigger) + { + return shouldTeleport; + } + + float destOrigin[3]; + float destAngles[3]; + bool gotDestOrigin; + bool gotDestAngles; + int destinationEnt = GetTeleportDestinationAndOrientation(trigger.tpDestination, destOrigin, destAngles, gotDestOrigin, gotDestAngles); + + float triggerOrigin[3]; + bool gotTriggerOrigin = GetEntityAbsOrigin(touched.entRef, triggerOrigin); + + // NOTE: We only use the trigger's origin if we're using a relative destination, so if + // we're not using a relative destination and don't have it, then it's fine. + if (!IsValidEntity(destinationEnt) || !gotDestOrigin + || (!gotTriggerOrigin && trigger.relativeDestination)) + { + PrintToConsole(client, "[KZ] Invalid teleport destination \"%s\" on trigger with hammerID %i.", trigger.tpDestination, trigger.hammerID); + return shouldTeleport; + } + + // NOTE: Find out if we should actually teleport. + if (isBhopTrigger && (flags & FL_ONGROUND)) + { + float touchTime = CalculateGroundTouchTime(client, touched); + if (touchTime > trigger.delay) + { + shouldTeleport = true; + } + else if (trigger.type == TeleportType_SingleBhop) + { + shouldTeleport = lastTouchSingleBhopEntRef[client] == touched.entRef; + } + else if (trigger.type == TeleportType_SequentialBhop) + { + int length = lastTouchSequentialBhopEntRefs[client].Length; + for (int j = 0; j < length; j++) + { + int entRef = lastTouchSequentialBhopEntRefs[client].Get(j); + if (entRef == touched.entRef) + { + shouldTeleport = true; + break; + } + } + } + } + else if (trigger.type == TeleportType_Normal) + { + float touchTime = CalculateStartTouchTime(client, touched); + shouldTeleport = touchTime > trigger.delay || (trigger.delay == 0.0); + } + + if (!shouldTeleport) + { + return shouldTeleport; + } + + bool shouldReorientPlayer = trigger.reorientPlayer + && gotDestAngles && (destAngles[1] != 0.0); + + float zAxis[3]; + zAxis = view_as<float>({0.0, 0.0, 1.0}); + + // NOTE: Work out finalOrigin. + float finalOrigin[3]; + if (trigger.relativeDestination) + { + float playerOrigin[3]; + Movement_GetOrigin(client, playerOrigin); + + float playerOffsetFromTrigger[3]; + SubtractVectors(playerOrigin, triggerOrigin, playerOffsetFromTrigger); + + if (shouldReorientPlayer) + { + // NOTE: rotate player offset by the destination trigger's yaw. + RotateVectorAxis(playerOffsetFromTrigger, zAxis, DegToRad(destAngles[1]), playerOffsetFromTrigger); + } + + AddVectors(destOrigin, playerOffsetFromTrigger, finalOrigin); + } + else + { + finalOrigin = destOrigin; + } + + // NOTE: Work out finalPlayerAngles. + float finalPlayerAngles[3]; + Movement_GetEyeAngles(client, finalPlayerAngles); + if (shouldReorientPlayer) + { + finalPlayerAngles[1] -= destAngles[1]; + + float velocity[3]; + Movement_GetVelocity(client, velocity); + + // NOTE: rotate velocity by the destination trigger's yaw. + RotateVectorAxis(velocity, zAxis, DegToRad(destAngles[1]), velocity); + Movement_SetVelocity(client, velocity); + } + else if (!trigger.reorientPlayer && trigger.useDestAngles) + { + finalPlayerAngles = destAngles; + } + + if (shouldTeleport) + { + TeleportPlayer(client, finalOrigin, finalPlayerAngles, gotDestAngles && trigger.useDestAngles, trigger.resetSpeed); + } + + return shouldTeleport; +} + +static float CalculateGroundTouchTime(int client, TouchedTrigger touched) +{ + float result = float(gI_TickCount[client] - touched.groundTouchTick) * GetTickInterval(); + return result; +} + +static float CalculateStartTouchTime(int client, TouchedTrigger touched) +{ + float result = float(gI_TickCount[client] - touched.startTouchTick) * GetTickInterval(); + return result; +} + +static void ResetBhopState(int client) +{ + lastTouchSingleBhopEntRef[client] = INVALID_ENT_REFERENCE; + lastTouchSequentialBhopEntRefs[client].Clear(); +} + +static bool GetEntityHammerIDString(int entity, char[] buffer, int maxLength) +{ + if (!IsValidEntity(entity)) + { + return false; + } + + if (!HasEntProp(entity, Prop_Data, "m_iHammerID")) + { + return false; + } + + int hammerID = GetEntProp(entity, Prop_Data, "m_iHammerID"); + IntToString(hammerID, buffer, maxLength); + + return true; +} + +// NOTE: returns an entity reference (possibly invalid). +static int GetTeleportDestinationAndOrientation(char[] targetName, float origin[3], float angles[3] = NULL_VECTOR, bool &gotOrigin = false, bool &gotAngles = false) +{ + // NOTE: We're not caching the teleport destination because it could change. + int destination = GOKZFindEntityByName(targetName, .ignorePlayers = true); + if (!IsValidEntity(destination)) + { + return destination; + } + + gotOrigin = GetEntityAbsOrigin(destination, origin); + + if (HasEntProp(destination, Prop_Data, "m_angAbsRotation")) + { + GetEntPropVector(destination, Prop_Data, "m_angAbsRotation", angles); + gotAngles = true; + } + else + { + gotAngles = false; + } + + return destination; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-core/map/zones.sp b/sourcemod/scripting/gokz-core/map/zones.sp new file mode 100644 index 0000000..684e42d --- /dev/null +++ b/sourcemod/scripting/gokz-core/map/zones.sp @@ -0,0 +1,183 @@ +/* + Hooks between specifically named trigger_multiples and GOKZ. +*/ + + + +static Regex RE_BonusStartZone; +static Regex RE_BonusEndZone; +static bool touchedGroundSinceTouchingStartZone[MAXPLAYERS + 1]; + + + +// =====[ EVENTS ]===== + +void OnPluginStart_MapZones() +{ + RE_BonusStartZone = CompileRegex(GOKZ_BONUS_START_ZONE_NAME_REGEX); + RE_BonusEndZone = CompileRegex(GOKZ_BONUS_END_ZONE_NAME_REGEX); +} + +void OnStartTouchGround_MapZones(int client) +{ + touchedGroundSinceTouchingStartZone[client] = true; +} + +void OnEntitySpawned_MapZones(int entity) +{ + char buffer[32]; + + GetEntityClassname(entity, buffer, sizeof(buffer)); + if (!StrEqual("trigger_multiple", buffer, false)) + { + return; + } + + if (GetEntityName(entity, buffer, sizeof(buffer)) == 0) + { + return; + } + + int course = 0; + if (StrEqual(GOKZ_START_ZONE_NAME, buffer, false)) + { + HookSingleEntityOutput(entity, "OnStartTouch", OnStartZoneStartTouch); + HookSingleEntityOutput(entity, "OnEndTouch", OnStartZoneEndTouch); + RegisterCourseStart(course); + } + else if (StrEqual(GOKZ_END_ZONE_NAME, buffer, false)) + { + HookSingleEntityOutput(entity, "OnStartTouch", OnEndZoneStartTouch); + RegisterCourseEnd(course); + } + else if ((course = GetStartZoneBonusNumber(entity)) != -1) + { + HookSingleEntityOutput(entity, "OnStartTouch", OnBonusStartZoneStartTouch); + HookSingleEntityOutput(entity, "OnEndTouch", OnBonusStartZoneEndTouch); + RegisterCourseStart(course); + } + else if ((course = GetEndZoneBonusNumber(entity)) != -1) + { + HookSingleEntityOutput(entity, "OnStartTouch", OnBonusEndZoneStartTouch); + RegisterCourseEnd(course); + } +} + +public void OnStartZoneStartTouch(const char[] name, int caller, int activator, float delay) +{ + if (!IsValidEntity(caller) || !IsValidClient(activator)) + { + return; + } + + ProcessStartZoneStartTouch(activator, 0); +} + +public void OnStartZoneEndTouch(const char[] name, int caller, int activator, float delay) +{ + if (!IsValidEntity(caller) || !IsValidClient(activator)) + { + return; + } + + ProcessStartZoneEndTouch(activator, 0); +} + +public void OnEndZoneStartTouch(const char[] name, int caller, int activator, float delay) +{ + if (!IsValidEntity(caller) || !IsValidClient(activator)) + { + return; + } + + ProcessEndZoneStartTouch(activator, 0); +} + +public void OnBonusStartZoneStartTouch(const char[] name, int caller, int activator, float delay) +{ + if (!IsValidEntity(caller) || !IsValidClient(activator)) + { + return; + } + + int course = GetStartZoneBonusNumber(caller); + if (!GOKZ_IsValidCourse(course, true)) + { + return; + } + + ProcessStartZoneStartTouch(activator, course); +} + +public void OnBonusStartZoneEndTouch(const char[] name, int caller, int activator, float delay) +{ + if (!IsValidEntity(caller) || !IsValidClient(activator)) + { + return; + } + + int course = GetStartZoneBonusNumber(caller); + if (!GOKZ_IsValidCourse(course, true)) + { + return; + } + + ProcessStartZoneEndTouch(activator, course); +} + +public void OnBonusEndZoneStartTouch(const char[] name, int caller, int activator, float delay) +{ + if (!IsValidEntity(caller) || !IsValidClient(activator)) + { + return; + } + + int course = GetEndZoneBonusNumber(caller); + if (!GOKZ_IsValidCourse(course, true)) + { + return; + } + + ProcessEndZoneStartTouch(activator, course); +} + + + +// =====[ PRIVATE ]===== + +static void ProcessStartZoneStartTouch(int client, int course) +{ + touchedGroundSinceTouchingStartZone[client] = Movement_GetOnGround(client); + + GOKZ_StopTimer(client, false); + SetCurrentCourse(client, course); + + OnStartZoneStartTouch_Teleports(client, course); +} + +static void ProcessStartZoneEndTouch(int client, int course) +{ + if (!touchedGroundSinceTouchingStartZone[client]) + { + return; + } + + GOKZ_StartTimer(client, course, true); + GOKZ_ResetVirtualButtonPosition(client, true); +} + +static void ProcessEndZoneStartTouch(int client, int course) +{ + GOKZ_EndTimer(client, course); + GOKZ_ResetVirtualButtonPosition(client, false); +} + +static int GetStartZoneBonusNumber(int entity) +{ + return GOKZ_MatchIntFromEntityName(entity, RE_BonusStartZone, 1); +} + +static int GetEndZoneBonusNumber(int entity) +{ + return GOKZ_MatchIntFromEntityName(entity, RE_BonusEndZone, 1); +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-core/menus/mode_menu.sp b/sourcemod/scripting/gokz-core/menus/mode_menu.sp new file mode 100644 index 0000000..934d29c --- /dev/null +++ b/sourcemod/scripting/gokz-core/menus/mode_menu.sp @@ -0,0 +1,40 @@ +/* + Lets players choose their mode. +*/ + + + +// =====[ PUBLIC ]===== + +void DisplayModeMenu(int client) +{ + Menu menu = new Menu(MenuHandler_Mode); + menu.SetTitle("%T", "Mode Menu - Title", client); + GOKZ_MenuAddModeItems(client, menu, true); + menu.Display(client, MENU_TIME_FOREVER); +} + + + +// =====[ EVENTS ]===== + +public int MenuHandler_Mode(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + GOKZ_SetCoreOption(param1, Option_Mode, param2); + if (GetCameFromOptionsMenu(param1)) + { + DisplayOptionsMenu(param1, TopMenuPosition_LastCategory); + } + } + else if (action == MenuAction_Cancel && GetCameFromOptionsMenu(param1)) + { + DisplayOptionsMenu(param1, TopMenuPosition_LastCategory); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-core/menus/options_menu.sp b/sourcemod/scripting/gokz-core/menus/options_menu.sp new file mode 100644 index 0000000..240ee81 --- /dev/null +++ b/sourcemod/scripting/gokz-core/menus/options_menu.sp @@ -0,0 +1,174 @@ +/* + TopMenu that allows users to browse categories of options. + + Adds core options to the general category where players + can cycle the value of each core option. +*/ + + + +static TopMenu optionsMenu; +static TopMenuObject catGeneral; +static TopMenuObject itemsGeneral[OPTION_COUNT]; +static bool cameFromOptionsMenu[MAXPLAYERS + 1]; + + + +// =====[ PUBLIC ]===== + +void DisplayOptionsMenu(int client, TopMenuPosition position = TopMenuPosition_Start) +{ + optionsMenu.Display(client, position); + cameFromOptionsMenu[client] = false; +} + +TopMenu GetOptionsTopMenu() +{ + return optionsMenu; +} + +bool GetCameFromOptionsMenu(int client) +{ + return cameFromOptionsMenu[client]; +} + + + +// =====[ LISTENERS ]===== + +void OnAllPluginsLoaded_OptionsMenu() +{ + optionsMenu = new TopMenu(TopMenuHandler_Options); + Call_GOKZ_OnOptionsMenuCreated(optionsMenu); + Call_GOKZ_OnOptionsMenuReady(optionsMenu); +} + +void OnConfigsExecuted_OptionsMenu() +{ + SortOptionsMenu(); +} + +void OnOptionsMenuCreated_OptionsMenu() +{ + catGeneral = optionsMenu.AddCategory(GENERAL_OPTION_CATEGORY, TopMenuHandler_Options); +} + +void OnOptionsMenuReady_OptionsMenu() +{ + for (int option = 0; option < view_as<int>(OPTION_COUNT); option++) + { + if (option == view_as<int>(Option_Style)) + { + continue; // TODO Currently hard-coded to skip style + } + itemsGeneral[option] = optionsMenu.AddItem(gC_CoreOptionNames[option], TopMenuHandler_General, catGeneral); + } +} + + + +// =====[ HANDLER ]===== + +public void TopMenuHandler_Options(TopMenu topmenu, TopMenuAction action, TopMenuObject topobj_id, int param, char[] buffer, int maxlength) +{ + if (action == TopMenuAction_DisplayOption || action == TopMenuAction_DisplayTitle) + { + if (topobj_id == INVALID_TOPMENUOBJECT) + { + Format(buffer, maxlength, "%T", "Options Menu - Title", param); + } + else if (topobj_id == catGeneral) + { + Format(buffer, maxlength, "%T", "Options Menu - General", param); + } + } +} + +public void TopMenuHandler_General(TopMenu topmenu, TopMenuAction action, TopMenuObject topobj_id, int param, char[] buffer, int maxlength) +{ + Option option = OPTION_INVALID; + for (int i = 0; i < view_as<int>(OPTION_COUNT); i++) + { + if (topobj_id == itemsGeneral[i]) + { + option = view_as<Option>(i); + break; + } + } + + if (option == OPTION_INVALID) + { + return; + } + + if (action == TopMenuAction_DisplayOption) + { + switch (option) + { + case Option_Mode: + { + FormatEx(buffer, maxlength, "%T - %s", + gC_CoreOptionPhrases[option], param, + gC_ModeNames[GOKZ_GetCoreOption(param, option)]); + } + case Option_TimerButtonZoneType: + { + FormatEx(buffer, maxlength, "%T - %T", + gC_CoreOptionPhrases[option], param, + gC_TimerButtonZoneTypePhrases[GOKZ_GetCoreOption(param, option)], param); + } + case Option_Safeguard: + { + FormatEx(buffer, maxlength, "%T - %T", + gC_CoreOptionPhrases[option], param, + gC_SafeGuardPhrases[GOKZ_GetCoreOption(param, option)], param); + } + default:FormatToggleableOptionDisplay(param, option, buffer, maxlength); + } + } + else if (action == TopMenuAction_SelectOption) + { + switch (option) + { + case Option_Mode: + { + cameFromOptionsMenu[param] = true; + DisplayModeMenu(param); + } + default: + { + GOKZ_CycleCoreOption(param, option); + optionsMenu.Display(param, TopMenuPosition_LastCategory); + } + } + } +} + + + +// =====[ PRIVATE ]===== + +static void SortOptionsMenu() +{ + char error[256]; + if (!optionsMenu.LoadConfig(GOKZ_CFG_OPTIONS_SORTING, error, sizeof(error))) + { + LogError("Failed to load file: \"%s\". Error: %s", GOKZ_CFG_OPTIONS_SORTING, error); + } +} + +static void FormatToggleableOptionDisplay(int client, Option option, char[] buffer, int maxlength) +{ + if (GOKZ_GetCoreOption(client, option) == 0) + { + FormatEx(buffer, maxlength, "%T - %T", + gC_CoreOptionPhrases[option], client, + "Options Menu - Disabled", client); + } + else + { + FormatEx(buffer, maxlength, "%T - %T", + gC_CoreOptionPhrases[option], client, + "Options Menu - Enabled", client); + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-core/misc.sp b/sourcemod/scripting/gokz-core/misc.sp new file mode 100644 index 0000000..a117880 --- /dev/null +++ b/sourcemod/scripting/gokz-core/misc.sp @@ -0,0 +1,803 @@ +/* + Small features that aren't worth splitting into their own file. +*/ + + + +// =====[ GOKZ.CFG ]===== + +void OnMapStart_KZConfig() +{ + char gokzCfgFullPath[PLATFORM_MAX_PATH]; + FormatEx(gokzCfgFullPath, sizeof(gokzCfgFullPath), "cfg/%s", GOKZ_CFG_SERVER); + + if (FileExists(gokzCfgFullPath)) + { + ServerCommand("exec %s", GOKZ_CFG_SERVER); + } + else + { + SetFailState("Failed to load file: \"%s\". Check that it exists.", gokzCfgFullPath); + } +} + + + +// =====[ GODMODE ]===== + +void OnPlayerSpawn_GodMode(int client) +{ + // Stop players from taking damage + SetEntProp(client, Prop_Data, "m_takedamage", 0); + SetEntityFlags(client, GetEntityFlags(client) | FL_GODMODE); +} + + + +// =====[ NOCLIP ]===== + +int noclipReleaseTime[MAXPLAYERS + 1]; + +void ToggleNoclip(int client) +{ + if (Movement_GetMovetype(client) != MOVETYPE_NOCLIP) + { + EnableNoclip(client); + } + else + { + DisableNoclip(client); + } +} + +void EnableNoclip(int client) +{ + if (IsValidClient(client) && IsPlayerAlive(client)) + { + if (GOKZ_GetCoreOption(client, Option_Safeguard) > Safeguard_Disabled && GOKZ_GetTimerRunning(client) && GOKZ_GetValidTimer(client)) + { + GOKZ_PrintToChat(client, true, "%t", "Safeguard - Blocked"); + GOKZ_PlayErrorSound(client); + return; + } + Movement_SetMovetype(client, MOVETYPE_NOCLIP); + GOKZ_StopTimer(client); + } +} + +void DisableNoclip(int client) +{ + if (IsValidClient(client) && IsPlayerAlive(client) && Movement_GetMovetype(client) == MOVETYPE_NOCLIP) + { + noclipReleaseTime[client] = GetGameTickCount(); + Movement_SetMovetype(client, MOVETYPE_WALK); + SetEntProp(client, Prop_Send, "m_CollisionGroup", GOKZ_COLLISION_GROUP_STANDARD); + + // Prevents an exploit that would let you noclip out of start zones + RemoveNoclipGroundFlag(client); + } +} + +void ToggleNoclipNotrigger(int client) +{ + if (Movement_GetMovetype(client) != MOVETYPE_NOCLIP) + { + EnableNoclipNotrigger(client); + } + else + { + DisableNoclipNotrigger(client); + } +} + +void EnableNoclipNotrigger(int client) +{ + if (IsValidClient(client) && IsPlayerAlive(client)) + { + if (GOKZ_GetCoreOption(client, Option_Safeguard) > Safeguard_Disabled && GOKZ_GetTimerRunning(client) && GOKZ_GetValidTimer(client)) + { + GOKZ_PrintToChat(client, true, "%t", "Safeguard - Blocked"); + GOKZ_PlayErrorSound(client); + return; + } + Movement_SetMovetype(client, MOVETYPE_NOCLIP); + SetEntProp(client, Prop_Send, "m_CollisionGroup", GOKZ_COLLISION_GROUP_NOTRIGGER); + GOKZ_StopTimer(client); + } +} + +void DisableNoclipNotrigger(int client) +{ + if (IsValidClient(client) && IsPlayerAlive(client) && Movement_GetMovetype(client) == MOVETYPE_NOCLIP) + { + noclipReleaseTime[client] = GetGameTickCount(); + Movement_SetMovetype(client, MOVETYPE_WALK); + SetEntProp(client, Prop_Send, "m_CollisionGroup", GOKZ_COLLISION_GROUP_STANDARD); + + // Prevents an exploit that would let you noclip out of start zones + RemoveNoclipGroundFlag(client); + } +} + +void RemoveNoclipGroundFlag(int client) +{ + float startPosition[3], endPosition[3]; + GetClientAbsOrigin(client, startPosition); + endPosition = startPosition; + endPosition[2] = startPosition[2] - 2.0; + Handle trace = TR_TraceHullFilterEx( + startPosition, + endPosition, + view_as<float>( { -16.0, -16.0, 0.0 } ), + view_as<float>( { 16.0, 16.0, 72.0 } ), + MASK_PLAYERSOLID, + TraceEntityFilterPlayers, + client); + + if (!TR_DidHit(trace)) + { + SetEntityFlags(client, GetEntityFlags(client) & ~FL_ONGROUND); + } + delete trace; +} + +bool JustNoclipped(int client) +{ + return GetGameTickCount() - noclipReleaseTime[client] <= GOKZ_TIMER_START_NOCLIP_TICKS; +} + +void OnClientPutInServer_Noclip(int client) +{ + noclipReleaseTime[client] = 0; +} + +// =====[ TURNBINDS ]===== + +static int turnbindsLastLeftStart[MAXPLAYERS + 1]; +static int turnbindsLastRightStart[MAXPLAYERS + 1]; +static float turnbindsLastValidYaw[MAXPLAYERS + 1]; +static int turnbindsOldButtons[MAXPLAYERS + 1]; + +void OnClientPutInServer_Turnbinds(int client) +{ + turnbindsLastLeftStart[client] = 0; + turnbindsLastRightStart[client] = 0; +} +// Ensures that there is a minimum time between starting to turnbind in one direction +// and then starting to turnbind in the other direction +void OnPlayerRunCmd_Turnbinds(int client, int buttons, int tickcount, float angles[3]) +{ + if (IsFakeClient(client)) + { + return; + } + if (buttons & IN_LEFT && tickcount < turnbindsLastRightStart[client] + RoundToNearest(GOKZ_TURNBIND_COOLDOWN / GetTickInterval())) + { + angles[1] = turnbindsLastValidYaw[client]; + TeleportEntity(client, NULL_VECTOR, angles, NULL_VECTOR); + buttons = 0; + } + else if (buttons & IN_RIGHT && tickcount < turnbindsLastLeftStart[client] + RoundToNearest(GOKZ_TURNBIND_COOLDOWN / GetTickInterval())) + { + angles[1] = turnbindsLastValidYaw[client]; + TeleportEntity(client, NULL_VECTOR, angles, NULL_VECTOR); + buttons = 0; + } + else + { + turnbindsLastValidYaw[client] = angles[1]; + + if (!(turnbindsOldButtons[client] & IN_LEFT) && (buttons & IN_LEFT)) + { + turnbindsLastLeftStart[client] = tickcount; + } + + if (!(turnbindsOldButtons[client] & IN_RIGHT) && (buttons & IN_RIGHT)) + { + turnbindsLastRightStart[client] = tickcount; + } + + turnbindsOldButtons[client] = buttons; + } +} + + + +// =====[ PLAYER COLLISION ]===== + +void OnPlayerSpawn_PlayerCollision(int client) +{ + // Let players go through other players + SetEntProp(client, Prop_Send, "m_CollisionGroup", GOKZ_COLLISION_GROUP_STANDARD); +} + +void OnSetModel_PlayerCollision(int client) +{ + // Fix custom models temporarily changing player collisions + SetEntPropVector(client, Prop_Data, "m_vecMins", PLAYER_MINS); + if (GetEntityFlags(client) & FL_DUCKING == 0) + { + SetEntPropVector(client, Prop_Data, "m_vecMaxs", PLAYER_MAXS); + } + else + { + SetEntPropVector(client, Prop_Data, "m_vecMaxs", PLAYER_MAXS_DUCKED); + } +} + + +// =====[ FORCE SV_FULL_ALLTALK 1 ]===== + +void OnRoundStart_ForceAllTalk() +{ + gCV_sv_full_alltalk.BoolValue = true; +} + + + +// =====[ ERROR SOUNDS ]===== + +#define SOUND_ERROR "buttons/button10.wav" + +void PlayErrorSound(int client) +{ + if (GOKZ_GetCoreOption(client, Option_ErrorSounds) == ErrorSounds_Enabled) + { + GOKZ_EmitSoundToClient(client, SOUND_ERROR, _, "Error"); + } +} + + + +// =====[ STOP SOUNDS ]===== + +Action OnNormalSound_StopSounds(int entity) +{ + char className[20]; + GetEntityClassname(entity, className, sizeof(className)); + if (StrEqual(className, "func_button", false)) + { + return Plugin_Handled; // No sounds directly from func_button + } + return Plugin_Continue; +} + + + +// =====[ JOIN TEAM HANDLING ]===== + +static bool hasSavedPosition[MAXPLAYERS + 1]; +static float savedOrigin[MAXPLAYERS + 1][3]; +static float savedAngles[MAXPLAYERS + 1][3]; +static bool savedOnLadder[MAXPLAYERS + 1]; + +void OnClientPutInServer_JoinTeam(int client) +{ + // Automatically put the player on a team if he doesn't choose one. + // The mp_force_pick_time convar is the built in way to do this, but that obviously + // does not call GOKZ_JoinTeam which includes a fix for spawning in the void when + // there is no valid spawns available. + CreateTimer(12.0, Timer_ForceJoinTeam, GetClientUserId(client), TIMER_FLAG_NO_MAPCHANGE); + + hasSavedPosition[client] = false; +} + +public Action Timer_ForceJoinTeam(Handle timer, int userid) +{ + int client = GetClientOfUserId(userid); + if (IsValidClient(client)) + { + int team = GetClientTeam(client); + if (team == CS_TEAM_NONE) + { + GOKZ_JoinTeam(client, CS_TEAM_SPECTATOR, false); + } + } + return Plugin_Stop; +} + +void OnTimerStart_JoinTeam(int client) +{ + hasSavedPosition[client] = false; +} + +void JoinTeam(int client, int newTeam, bool restorePos, bool forceBroadcast = false) +{ + KZPlayer player = KZPlayer(client); + int currentTeam = GetClientTeam(client); + + // Don't use CS_TEAM_NONE + if (newTeam == CS_TEAM_NONE) + { + newTeam = CS_TEAM_SPECTATOR; + } + + if (newTeam == CS_TEAM_SPECTATOR && currentTeam != CS_TEAM_SPECTATOR) + { + if (currentTeam != CS_TEAM_NONE) + { + player.GetOrigin(savedOrigin[client]); + player.GetEyeAngles(savedAngles[client]); + savedOnLadder[client] = player.Movetype == MOVETYPE_LADDER; + hasSavedPosition[client] = true; + } + + if (!player.Paused && !player.CanPause) + { + player.StopTimer(); + } + ChangeClientTeam(client, CS_TEAM_SPECTATOR); + Call_GOKZ_OnJoinTeam(client, newTeam); + } + else if (newTeam == CS_TEAM_CT && currentTeam != CS_TEAM_CT + || newTeam == CS_TEAM_T && currentTeam != CS_TEAM_T) + { + ForcePlayerSuicide(client); + CS_SwitchTeam(client, newTeam); + CS_RespawnPlayer(client); + if (restorePos && hasSavedPosition[client]) + { + TeleportPlayer(client, savedOrigin[client], savedAngles[client]); + if (savedOnLadder[client]) + { + player.Movetype = MOVETYPE_LADDER; + } + } + else + { + player.StopTimer(); + // Just joining a team alone can put you into weird invalid spawns. + // Need to teleport the player to a valid one. + float spawnOrigin[3]; + float spawnAngles[3]; + GetValidSpawn(spawnOrigin, spawnAngles); + TeleportPlayer(client, spawnOrigin, spawnAngles); + } + hasSavedPosition[client] = false; + Call_GOKZ_OnJoinTeam(client, newTeam); + } + else if (forceBroadcast) + { + Call_GOKZ_OnJoinTeam(client, newTeam); + } +} + +void SendFakeTeamEvent(int client) +{ + // Send a fake event to close the team menu + Event event = CreateEvent("player_team"); + event.SetInt("userid", GetClientUserId(client)); + event.FireToClient(client); + event.Cancel(); +} + +// =====[ VALID JUMP TRACKING ]===== + +/* + Valid jump tracking is intended to detect when the player + has performed a normal jump that hasn't been affected by + (unexpected) teleports or other cases that may result in + the player becoming airborne, such as spawning. + + There are ways to trick the plugin, but it is rather + unlikely to happen during normal gameplay. +*/ + +static bool validJump[MAXPLAYERS + 1]; +static float validJumpTeleportOrigin[MAXPLAYERS + 1][3]; +static int lastInvalidatedTick[MAXPLAYERS + 1]; +bool GetValidJump(int client) +{ + return validJump[client]; +} + +static void InvalidateJump(int client) +{ + lastInvalidatedTick[client] = GetGameTickCount(); + if (validJump[client]) + { + validJump[client] = false; + Call_GOKZ_OnJumpInvalidated(client); + } +} + +void OnStopTouchGround_ValidJump(int client, bool jumped, bool ladderJump, bool jumpbug) +{ + if (Movement_GetMovetype(client) == MOVETYPE_WALK && lastInvalidatedTick[client] != GetGameTickCount()) + { + validJump[client] = true; + Call_GOKZ_OnJumpValidated(client, jumped, ladderJump, jumpbug); + } + else + { + InvalidateJump(client); + } +} + +void OnPlayerRunCmdPost_ValidJump(int client) +{ + if (gB_VelocityTeleported[client] || gB_OriginTeleported[client]) + { + InvalidateJump(client); + } +} + +void OnChangeMovetype_ValidJump(int client, MoveType oldMovetype, MoveType newMovetype) +{ + if (oldMovetype == MOVETYPE_LADDER && newMovetype == MOVETYPE_WALK && lastInvalidatedTick[client] != GetGameTickCount()) // Ladderjump + { + validJump[client] = true; + Call_GOKZ_OnJumpValidated(client, false, true, false); + } + else + { + InvalidateJump(client); + } +} + +void OnClientDisconnect_ValidJump(int client) +{ + InvalidateJump(client); +} + +void OnPlayerSpawn_ValidJump(int client) +{ + // That should definitely be out of bounds + CopyVector({ 40000.0, 40000.0, 40000.0 }, validJumpTeleportOrigin[client]); + InvalidateJump(client); +} + +void OnPlayerDeath_ValidJump(int client) +{ + InvalidateJump(client); +} + +void OnValidOriginChange_ValidJump(int client, const float origin[3]) +{ + CopyVector(origin, validJumpTeleportOrigin[client]); +} + +void OnTeleport_ValidJump(int client) +{ + float origin[3]; + Movement_GetOrigin(client, origin); + if (gB_OriginTeleported[client] && GetVectorDistance(validJumpTeleportOrigin[client], origin, true) <= EPSILON) + { + gB_OriginTeleported[client] = false; + CopyVector({ 40000.0, 40000.0, 40000.0 }, validJumpTeleportOrigin[client]); + return; + } + + if (gB_OriginTeleported[client]) + { + InvalidateJump(client); + Call_GOKZ_OnTeleport(client); + } + + if (gB_VelocityTeleported[client]) + { + InvalidateJump(client); + } +} + + + +// =====[ FIRST SPAWN ]===== + +static bool hasSpawned[MAXPLAYERS + 1]; + +void OnClientPutInServer_FirstSpawn(int client) +{ + hasSpawned[client] = false; +} + +void OnPlayerSpawn_FirstSpawn(int client) +{ + int team = GetClientTeam(client); + if (!hasSpawned[client] && (team == CS_TEAM_CT || team == CS_TEAM_T)) + { + hasSpawned[client] = true; + Call_GOKZ_OnFirstSpawn(client); + } +} + + + +// =====[ TIME LIMIT ]===== + +void OnConfigsExecuted_TimeLimit() +{ + CreateTimer(1.0, Timer_TimeLimit, _, TIMER_REPEAT); +} + +public Action Timer_TimeLimit(Handle timer) +{ + int timelimit; + if (!GetMapTimeLimit(timelimit) || timelimit == 0) + { + return Plugin_Continue; + } + + int timeleft; + // Check for less than -1 in case we miss 0 - ignore -1 because that means infinite time limit + if (GetMapTimeLeft(timeleft) && (timeleft == 0 || timeleft < -1)) + { + CreateTimer(5.0, Timer_EndRound); // End the round after a delay or it won't end the map + return Plugin_Stop; + } + + return Plugin_Continue; +} + +public Action Timer_EndRound(Handle timer) +{ + CS_TerminateRound(1.0, CSRoundEnd_Draw, true); + return Plugin_Continue; +} + + + +// =====[ COURSE REGISTER ]===== + +static bool startRegistered[GOKZ_MAX_COURSES]; +static bool endRegistered[GOKZ_MAX_COURSES]; +static bool courseRegistered[GOKZ_MAX_COURSES]; + +bool GetCourseRegistered(int course) +{ + return courseRegistered[course]; +} + +void RegisterCourseStart(int course) +{ + startRegistered[course] = true; + TryRegisterCourse(course); +} + +void RegisterCourseEnd(int course) +{ + endRegistered[course] = true; + TryRegisterCourse(course); +} + +void OnMapStart_CourseRegister() +{ + for (int course = 0; course < GOKZ_MAX_COURSES; course++) + { + courseRegistered[course] = false; + } +} + +static void TryRegisterCourse(int course) +{ + if (!courseRegistered[course] && startRegistered[course] && endRegistered[course]) + { + courseRegistered[course] = true; + Call_GOKZ_OnCourseRegistered(course); + } +} + + + +// =====[ SPAWN FIXES ]===== + +void OnMapStart_FixMissingSpawns() +{ + int tSpawn = FindEntityByClassname(-1, "info_player_terrorist"); + int ctSpawn = FindEntityByClassname(-1, "info_player_counterterrorist"); + + if (tSpawn == -1 && ctSpawn == -1) + { + LogMessage("Couldn't fix spawns because none exist."); + return; + } + + if (tSpawn == -1 || ctSpawn == -1) + { + float origin[3], angles[3]; + GetValidSpawn(origin, angles); + + int newSpawn = CreateEntityByName((tSpawn == -1) ? "info_player_terrorist" : "info_player_counterterrorist"); + if (DispatchSpawn(newSpawn)) + { + TeleportEntity(newSpawn, origin, angles, NULL_VECTOR); + } + } +} + +// =====[ BUTTONS ]===== + +void OnClientPreThinkPost_UseButtons(int client) +{ + if (GOKZ_GetCoreOption(client, Option_ButtonThroughPlayers) == ButtonThroughPlayers_Enabled && GetEntProp(client, Prop_Data, "m_afButtonPressed") & IN_USE) + { + int entity = FindUseEntity(client); + if (entity != -1) + { + AcceptEntityInput(entity, "Use", client, client, 1); + } + } +} + +static int FindUseEntity(int client) +{ + float fwd[3]; + float angles[3]; + GetClientEyeAngles(client, angles); + GetAngleVectors(angles, fwd, NULL_VECTOR, NULL_VECTOR); + + Handle trace; + + float eyeOrigin[3]; + GetClientEyePosition(client, eyeOrigin); + int useableContents = (MASK_NPCSOLID_BRUSHONLY | MASK_OPAQUE_AND_NPCS) & ~CONTENTS_OPAQUE; + + float endpos[3]; + + // Check if +use trace collide with a player first, so we don't activate any button twice + trace = TR_TraceRayFilterEx(eyeOrigin, angles, useableContents, RayType_Infinite, TRFOtherPlayersOnly, client); + if (TR_DidHit(trace)) + { + int ent = TR_GetEntityIndex(trace); + if (ent < 1 || ent > MaxClients) + { + return -1; + } + // Search for a button behind it. + trace = TR_TraceRayFilterEx(eyeOrigin, angles, useableContents, RayType_Infinite, TraceEntityFilterPlayers); + if (TR_DidHit(trace)) + { + char buffer[20]; + ent = TR_GetEntityIndex(trace); + // Make sure that it is a button, and this button activates when pressed. + // If it is not a button, check its parent to see if it is a button. + bool isButton; + while (ent != -1) + { + GetEntityClassname(ent, buffer, sizeof(buffer)); + if (StrEqual("func_button", buffer, false) && GetEntProp(ent, Prop_Data, "m_spawnflags") & SF_BUTTON_USE_ACTIVATES) + { + isButton = true; + break; + } + else + { + ent = GetEntPropEnt(ent, Prop_Data, "m_hMoveParent"); + } + } + if (isButton) + { + TR_GetEndPosition(endpos, trace); + float delta[3]; + for (int i = 0; i < 2; i++) + { + delta[i] = endpos[i] - eyeOrigin[i]; + } + // Z distance is treated differently. + float m_vecMins[3]; + float m_vecMaxs[3]; + float m_vecOrigin[3]; + GetEntPropVector(ent, Prop_Send, "m_vecOrigin", m_vecOrigin); + GetEntPropVector(ent, Prop_Send, "m_vecMins", m_vecMins); + GetEntPropVector(ent, Prop_Send, "m_vecMaxs", m_vecMaxs); + + delta[2] = IntervalDistance(endpos[2], m_vecOrigin[2] + m_vecMins[2], m_vecOrigin[2] + m_vecMaxs[2]); + if (GetVectorLength(delta) < 80.0) + { + return ent; + } + } + } + } + + int nearestEntity; + float nearestPoint[3]; + float nearestDist = FLOAT_MAX; + ArrayList entities = new ArrayList(); + TR_EnumerateEntitiesSphere(eyeOrigin, 80.0, 1<<5, AddEntities, entities); + for (int i = 0; i < entities.Length; i++) + { + char buffer[64]; + int ent = entities.Get(i); + GetEntityClassname(ent, buffer, sizeof(buffer)); + // Check if the entity is a button and it is pressable. + if (StrEqual("func_button", buffer, false) && GetEntProp(ent, Prop_Data, "m_spawnflags") & SF_BUTTON_USE_ACTIVATES) + { + float point[3]; + CalcNearestPoint(ent, eyeOrigin, point); + + float dir[3]; + for (int j = 0; j < 3; j++) + { + dir[j] = point[j] - eyeOrigin[2]; + } + // Check the maximum angle the player can be away from the button. + float minimumDot = GetEntPropFloat(ent, Prop_Send, "m_flUseLookAtAngle"); + NormalizeVector(dir, dir); + float dot = GetVectorDotProduct(dir, fwd); + if (dot < minimumDot) + { + continue; + } + + float dist = CalcDistanceToLine(point, eyeOrigin, fwd); + if (dist < nearestDist) + { + trace = TR_TraceRayFilterEx(eyeOrigin, point, useableContents, RayType_EndPoint, TraceEntityFilterPlayers); + if (TR_GetFraction(trace) == 1.0 || TR_GetEntityIndex(trace) == ent) + { + CopyVector(point, nearestPoint); + nearestDist = dist; + nearestEntity = ent; + } + } + } + } + // We found the closest button, but we still need to check if there is a player in front of it or not. + // In the case that there isn't a player inbetween, we don't return the entity index, because that button will be pressed by the game function anyway. + // If there is, we will press two buttons at once, the "right" button found by this function and the "wrong" button that we only happen to press because + // there is a player in the way. + + trace = TR_TraceRayFilterEx(eyeOrigin, nearestPoint, useableContents, RayType_EndPoint, TRFOtherPlayersOnly); + if (TR_DidHit(trace)) + { + return nearestEntity; + } + return -1; +} + +public bool AddEntities(int entity, ArrayList entities) +{ + entities.Push(entity); + return true; +} + +static float IntervalDistance(float x, float x0, float x1) +{ + if (x0 > x1) + { + float tmp = x0; + x0 = x1; + x1 = tmp; + } + if (x < x0) + { + return x0 - x; + } + else if (x > x1) + { + return x - x1; + } + return 0.0; +} +// TraceRay filter for other players exclusively. +public bool TRFOtherPlayersOnly(int entity, int contentmask, int client) +{ + return (0 < entity <= MaxClients) && (entity != client); +} + +// =====[ SAFE MODE ]===== + +void ToggleNubSafeGuard(int client) +{ + if (GOKZ_GetCoreOption(client, Option_Safeguard) == Safeguard_EnabledNUB) + { + GOKZ_SetCoreOption(client, Option_Safeguard, Safeguard_Disabled); + } + else + { + GOKZ_SetCoreOption(client, Option_Safeguard, Safeguard_EnabledNUB); + } +} + +void ToggleProSafeGuard(int client) +{ + if (GOKZ_GetCoreOption(client, Option_Safeguard) == Safeguard_EnabledPRO) + { + GOKZ_SetCoreOption(client, Option_Safeguard, Safeguard_Disabled); + } + else + { + GOKZ_SetCoreOption(client, Option_Safeguard, Safeguard_EnabledPRO); + } +} diff --git a/sourcemod/scripting/gokz-core/modes.sp b/sourcemod/scripting/gokz-core/modes.sp new file mode 100644 index 0000000..ce6f8ae --- /dev/null +++ b/sourcemod/scripting/gokz-core/modes.sp @@ -0,0 +1,106 @@ +static bool modeLoaded[MODE_COUNT]; +static int modeVersion[MODE_COUNT]; +static bool GOKZHitPerf[MAXPLAYERS + 1]; +static float GOKZTakeoffSpeed[MAXPLAYERS + 1]; + + + +// =====[ PUBLIC ]===== + +bool GetModeLoaded(int mode) +{ + return modeLoaded[mode]; +} + +int GetModeVersion(int mode) +{ + return modeLoaded[mode] ? modeVersion[mode] : -1; +} + +void SetModeLoaded(int mode, bool loaded, int version = -1) +{ + if (!modeLoaded[mode] && loaded) + { + modeLoaded[mode] = true; + modeVersion[mode] = version; + Call_GOKZ_OnModeLoaded(mode); + } + else if (modeLoaded[mode] && !loaded) + { + modeLoaded[mode] = false; + Call_GOKZ_OnModeUnloaded(mode); + } +} + +int GetLoadedModeCount() +{ + int count = 0; + for (int mode = 0; mode < MODE_COUNT; mode++) + { + if (modeLoaded[mode]) + { + count++; + } + } + return count; +} + +int GetALoadedMode() +{ + for (int mode = 0; mode < MODE_COUNT; mode++) + { + if (GOKZ_GetModeLoaded(mode)) + { + return mode; + } + } + return -1; // Uh-oh +} + +bool GetGOKZHitPerf(int client) +{ + return GOKZHitPerf[client]; +} + +void SetGOKZHitPerf(int client, bool hitPerf) +{ + GOKZHitPerf[client] = hitPerf; +} + +float GetGOKZTakeoffSpeed(int client) +{ + return GOKZTakeoffSpeed[client]; +} + +void SetGOKZTakeoffSpeed(int client, float takeoffSpeed) +{ + GOKZTakeoffSpeed[client] = takeoffSpeed; +} + + + +// =====[ EVENTS ]===== + +void OnAllPluginsLoaded_Modes() +{ + if (GetLoadedModeCount() <= 0) + { + SetFailState("At least one GOKZ mode plugin is required."); + } +} + +void OnPlayerSpawn_Modes(int client) +{ + GOKZHitPerf[client] = false; + GOKZTakeoffSpeed[client] = 0.0; +} + +void OnOptionChanged_Mode(int client, Option option) +{ + if (option == Option_Mode) + { + // Remove speed when switching modes + Movement_SetVelocityModifier(client, 1.0); + Movement_SetVelocity(client, view_as<float>( { 0.0, 0.0, 0.0 } )); + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-core/natives.sp b/sourcemod/scripting/gokz-core/natives.sp new file mode 100644 index 0000000..319810c --- /dev/null +++ b/sourcemod/scripting/gokz-core/natives.sp @@ -0,0 +1,647 @@ +void CreateNatives() +{ + CreateNative("GOKZ_GetModeLoaded", Native_GetModeLoaded); + CreateNative("GOKZ_GetModeVersion", Native_GetModeVersion); + CreateNative("GOKZ_SetModeLoaded", Native_SetModeLoaded); + CreateNative("GOKZ_GetLoadedModeCount", Native_GetLoadedModeCount); + CreateNative("GOKZ_SetMode", Native_SetMode); + CreateNative("GOKZ_PrintToChat", Native_PrintToChat); + CreateNative("GOKZ_PrintToChatAndLog", Native_PrintToChatAndLog); + CreateNative("GOKZ_GetOptionsTopMenu", Native_GetOptionsTopMenu); + CreateNative("GOKZ_GetCourseRegistered", Native_GetCourseRegistered); + + CreateNative("GOKZ_StartTimer", Native_StartTimer); + CreateNative("GOKZ_EndTimer", Native_EndTimer); + CreateNative("GOKZ_StopTimer", Native_StopTimer); + CreateNative("GOKZ_StopTimerAll", Native_StopTimerAll); + CreateNative("GOKZ_TeleportToStart", Native_TeleportToStart); + CreateNative("GOKZ_TeleportToSearchStart", Native_TeleportToSearchStart); + CreateNative("GOKZ_GetVirtualButtonPosition", Native_GetVirtualButtonPosition); + CreateNative("GOKZ_SetVirtualButtonPosition", Native_SetVirtualButtonPosition); + CreateNative("GOKZ_ResetVirtualButtonPosition", Native_ResetVirtualButtonPosition); + CreateNative("GOKZ_LockVirtualButtons", Native_LockVirtualButtons); + CreateNative("GOKZ_GetStartPosition", Native_GetStartPosition); + CreateNative("GOKZ_SetStartPosition", Native_SetStartPosition); + CreateNative("GOKZ_TeleportToEnd", Native_TeleportToEnd); + CreateNative("GOKZ_GetStartPositionType", Native_GetStartPositionType); + CreateNative("GOKZ_SetStartPositionToMapStart", Native_SetStartPositionToMapStart); + CreateNative("GOKZ_MakeCheckpoint", Native_MakeCheckpoint); + CreateNative("GOKZ_GetCanMakeCheckpoint", Native_GetCanMakeCheckpoint); + CreateNative("GOKZ_TeleportToCheckpoint", Native_TeleportToCheckpoint); + CreateNative("GOKZ_GetCanTeleportToCheckpoint", Native_GetCanTeleportToCheckpoint); + CreateNative("GOKZ_PrevCheckpoint", Native_PrevCheckpoint); + CreateNative("GOKZ_GetCanPrevCheckpoint", Native_GetCanPrevCheckpoint); + CreateNative("GOKZ_NextCheckpoint", Native_NextCheckpoint); + CreateNative("GOKZ_GetCanNextCheckpoint", Native_GetCanNextCheckpoint); + CreateNative("GOKZ_UndoTeleport", Native_UndoTeleport); + CreateNative("GOKZ_GetCanUndoTeleport", Native_GetCanUndoTeleport); + CreateNative("GOKZ_Pause", Native_Pause); + CreateNative("GOKZ_GetCanPause", Native_GetCanPause); + CreateNative("GOKZ_Resume", Native_Resume); + CreateNative("GOKZ_GetCanResume", Native_GetCanResume); + CreateNative("GOKZ_TogglePause", Native_TogglePause); + CreateNative("GOKZ_GetCanTeleportToStart", Native_GetCanTeleportToStart); + CreateNative("GOKZ_GetCanTeleportToEnd", Native_GetCanTeleportToEnd); + CreateNative("GOKZ_PlayErrorSound", Native_PlayErrorSound); + CreateNative("GOKZ_SetValidJumpOrigin", Native_SetValidJumpOrigin); + + CreateNative("GOKZ_GetTimerRunning", Native_GetTimerRunning); + CreateNative("GOKZ_GetValidTimer", Native_GetValidTimer); + CreateNative("GOKZ_GetCourse", Native_GetCourse); + CreateNative("GOKZ_SetCourse", Native_SetCourse); + CreateNative("GOKZ_GetPaused", Native_GetPaused); + CreateNative("GOKZ_GetTime", Native_GetTime); + CreateNative("GOKZ_SetTime", Native_SetTime); + CreateNative("GOKZ_InvalidateRun", Native_InvalidateRun); + CreateNative("GOKZ_GetCheckpointCount", Native_GetCheckpointCount); + CreateNative("GOKZ_SetCheckpointCount", Native_SetCheckpointCount); + CreateNative("GOKZ_GetCheckpointData", Native_GetCheckpointData); + CreateNative("GOKZ_SetCheckpointData", Native_SetCheckpointData); + CreateNative("GOKZ_GetUndoTeleportData", Native_GetUndoTeleportData); + CreateNative("GOKZ_SetUndoTeleportData", Native_SetUndoTeleportData); + CreateNative("GOKZ_GetTeleportCount", Native_GetTeleportCount); + CreateNative("GOKZ_SetTeleportCount", Native_SetTeleportCount); + CreateNative("GOKZ_RegisterOption", Native_RegisterOption); + CreateNative("GOKZ_GetOptionProp", Native_GetOptionProp); + CreateNative("GOKZ_SetOptionProp", Native_SetOptionProp); + CreateNative("GOKZ_GetOption", Native_GetOption); + CreateNative("GOKZ_SetOption", Native_SetOption); + CreateNative("GOKZ_GetHitPerf", Native_GetHitPerf); + CreateNative("GOKZ_SetHitPerf", Native_SetHitPerf); + CreateNative("GOKZ_GetTakeoffSpeed", Native_GetTakeoffSpeed); + CreateNative("GOKZ_SetTakeoffSpeed", Native_SetTakeoffSpeed); + CreateNative("GOKZ_GetValidJump", Native_GetValidJump); + CreateNative("GOKZ_JoinTeam", Native_JoinTeam); + + CreateNative("GOKZ_EmitSoundToClient", Native_EmitSoundToClient); +} + +public int Native_GetModeLoaded(Handle plugin, int numParams) +{ + return view_as<int>(GetModeLoaded(GetNativeCell(1))); +} + +public int Native_GetModeVersion(Handle plugin, int numParams) +{ + return view_as<int>(GetModeVersion(GetNativeCell(1))); +} + +public int Native_SetModeLoaded(Handle plugin, int numParams) +{ + SetModeLoaded(GetNativeCell(1), GetNativeCell(2), GetNativeCell(3)); + return 0; +} + +public int Native_GetLoadedModeCount(Handle plugin, int numParams) +{ + return GetLoadedModeCount(); +} + +public int Native_SetMode(Handle plugin, int numParams) +{ + return view_as<bool>(SwitchToModeIfAvailable(GetNativeCell(1),GetNativeCell(2))); +} + +public int Native_PrintToChatAndLog(Handle plugin, int numParams) +{ + NativeHelper_PrintToChatOrLog(true); + return 0; +} + +public int Native_PrintToChat(Handle plugin, int numParams) +{ + NativeHelper_PrintToChatOrLog(false); + return 0; +} + +static int NativeHelper_PrintToChatOrLog(bool alwaysLog) +{ + int client = GetNativeCell(1); + bool addPrefix = GetNativeCell(2); + + char buffer[1024]; + SetGlobalTransTarget(client); + FormatNativeString(0, 3, 4, sizeof(buffer), _, buffer); + + // The console (client 0) gets a special treatment + if (client == 0 || (!IsValidClient(client) && !IsClientSourceTV(client)) || alwaysLog) + { + // Strip colors + // We can't regex-replace, so I'm quite sure that's the most efficient way. + // It's also not perfectly safe, we will just assume you never have curly + // braces without a color in beween. + char colorlessBuffer[1024]; + FormatEx(colorlessBuffer, sizeof(colorlessBuffer), "%L: ", client); + int iIn = 0, iOut = strlen(colorlessBuffer); + do + { + if (buffer[iIn] == '{') + { + for (; buffer[iIn] != '}' && iIn < sizeof(buffer) - 2; iIn++){} + if (iIn >= sizeof(buffer) - 2) + { + break; + } + iIn++; + continue; + } + + colorlessBuffer[iOut] = buffer[iIn]; + iIn++; + iOut++; + } while (buffer[iIn] != '\0' && iIn < sizeof(buffer) - 1 && iOut < sizeof(colorlessBuffer) - 1); + colorlessBuffer[iOut] = '\0'; + LogMessage(colorlessBuffer); + } + + if (client != 0) + { + if (addPrefix) + { + char prefix[64]; + gCV_gokz_chat_prefix.GetString(prefix, sizeof(prefix)); + Format(buffer, sizeof(buffer), "%s%s", prefix, buffer); + } + + CPrintToChat(client, "%s", buffer); + } + return 0; +} + +public int Native_GetOptionsTopMenu(Handle plugin, int numParams) +{ + return view_as<int>(GetOptionsTopMenu()); +} + +public int Native_GetCourseRegistered(Handle plugin, int numParams) +{ + return view_as<int>(GetCourseRegistered(GetNativeCell(1))); +} + +public int Native_StartTimer(Handle plugin, int numParams) +{ + if (BlockedExternallyCalledTimerNative(plugin, GetNativeCell(1))) + { + return view_as<int>(false); + } + + return view_as<int>(TimerStart(GetNativeCell(1), GetNativeCell(2), GetNativeCell(3))); +} + +public int Native_EndTimer(Handle plugin, int numParams) +{ + if (BlockedExternallyCalledTimerNative(plugin, GetNativeCell(1))) + { + return view_as<int>(false); + } + + return view_as<int>(TimerEnd(GetNativeCell(1), GetNativeCell(2))); +} + +public int Native_StopTimer(Handle plugin, int numParams) +{ + return view_as<int>(TimerStop(GetNativeCell(1), GetNativeCell(2))); +} + +public int Native_StopTimerAll(Handle plugin, int numParams) +{ + TimerStopAll(GetNativeCell(1)); + return 0; +} + +public int Native_TeleportToStart(Handle plugin, int numParams) +{ + TeleportToStart(GetNativeCell(1)); + return 0; +} + +public int Native_TeleportToSearchStart(Handle plugin, int numParams) +{ + TeleportToSearchStart(GetNativeCell(1), GetNativeCell(2)); + return 0; +} + +public int Native_GetVirtualButtonPosition(Handle plugin, int numParams) +{ + int course; + float position[3]; + + course = GetVirtualButtonPosition(GetNativeCell(1), position, GetNativeCell(3)); + SetNativeArray(2, position, sizeof(position)); + + return course; +} + +public int Native_SetVirtualButtonPosition(Handle plugin, int numParams) +{ + float position[3]; + + GetNativeArray(2, position, sizeof(position)); + SetVirtualButtonPosition(GetNativeCell(1), position, GetNativeCell(3), view_as<bool>(GetNativeCell(4))); + return 0; +} + +public int Native_ResetVirtualButtonPosition(Handle plugin, int numParams) +{ + ResetVirtualButtonPosition(GetNativeCell(1), GetNativeCell(2)); + return 0; +} + +public int Native_LockVirtualButtons(Handle plugin, int numParams) +{ + LockVirtualButtons(GetNativeCell(1)); + return 0; +} + +public int Native_GetStartPosition(Handle plugin, int numParams) +{ + StartPositionType type; + float position[3], angles[3]; + + type = GetStartPosition(GetNativeCell(1), position, angles); + SetNativeArray(2, position, sizeof(position)); + SetNativeArray(3, angles, sizeof(angles)); + + return view_as<int>(type); +} + +public int Native_SetStartPosition(Handle plugin, int numParams) +{ + float position[3], angles[3]; + + GetNativeArray(3, position, sizeof(position)); + GetNativeArray(4, angles, sizeof(angles)); + SetStartPosition(GetNativeCell(1), GetNativeCell(2), position, angles); + return 0; +} + +public int Native_TeleportToEnd(Handle plugin, int numParams) +{ + TeleportToEnd(GetNativeCell(1), GetNativeCell(2)); + return 0; +} + +public int Native_GetStartPositionType(Handle plugin, int numParams) +{ + return view_as<int>(GetStartPositionType(GetNativeCell(1))); +} + +public int Native_SetStartPositionToMapStart(Handle plugin, int numParams) +{ + return SetStartPositionToMapStart(GetNativeCell(1), GetNativeCell(2)); +} + +public int Native_MakeCheckpoint(Handle plugin, int numParams) +{ + MakeCheckpoint(GetNativeCell(1)); + return 0; +} + +public int Native_GetCanMakeCheckpoint(Handle plugin, int numParams) +{ + return CanMakeCheckpoint(GetNativeCell(1)); +} + +public int Native_TeleportToCheckpoint(Handle plugin, int numParams) +{ + TeleportToCheckpoint(GetNativeCell(1)); + return 0; +} + +public int Native_GetCanTeleportToCheckpoint(Handle plugin, int numParams) +{ + return CanTeleportToCheckpoint(GetNativeCell(1)); +} + +public int Native_PrevCheckpoint(Handle plugin, int numParams) +{ + PrevCheckpoint(GetNativeCell(1)); + return 0; +} + +public int Native_GetCanPrevCheckpoint(Handle plugin, int numParams) +{ + return CanPrevCheckpoint(GetNativeCell(1)); +} + +public int Native_NextCheckpoint(Handle plugin, int numParams) +{ + NextCheckpoint(GetNativeCell(1)); + return 0; +} + +public int Native_GetCanNextCheckpoint(Handle plugin, int numParams) +{ + return CanNextCheckpoint(GetNativeCell(1)); +} + +public int Native_UndoTeleport(Handle plugin, int numParams) +{ + UndoTeleport(GetNativeCell(1)); + return 0; +} + +public int Native_GetCanUndoTeleport(Handle plugin, int numParams) +{ + return CanUndoTeleport(GetNativeCell(1)); +} + +public int Native_Pause(Handle plugin, int numParams) +{ + Pause(GetNativeCell(1)); + return 0; +} + +public int Native_GetCanPause(Handle plugin, int numParams) +{ + return CanPause(GetNativeCell(1)); +} + +public int Native_Resume(Handle plugin, int numParams) +{ + Resume(GetNativeCell(1)); + return 0; +} + +public int Native_GetCanResume(Handle plugin, int numParams) +{ + return CanResume(GetNativeCell(1)); +} + +public int Native_TogglePause(Handle plugin, int numParams) +{ + TogglePause(GetNativeCell(1)); + return 0; +} + +public int Native_GetCanTeleportToStart(Handle plugin, int numParams) +{ + return CanTeleportToStart(GetNativeCell(1)); +} + +public int Native_GetCanTeleportToEnd(Handle plugin, int numParams) +{ + return CanTeleportToEnd(GetNativeCell(1)); +} + +public int Native_PlayErrorSound(Handle plugin, int numParams) +{ + PlayErrorSound(GetNativeCell(1)); + return 0; +} + +public int Native_SetValidJumpOrigin(Handle plugin, int numParams) +{ + int client = GetNativeCell(1); + float origin[3]; + GetNativeArray(2, origin, sizeof(origin)); + + // The order is important here! + OnValidOriginChange_ValidJump(client, origin); + + // Using Movement_SetOrigin instead causes considerable lag for spectators + SetEntPropVector(client, Prop_Data, "m_vecAbsOrigin", origin); + return 0; +} + +public int Native_GetTimerRunning(Handle plugin, int numParams) +{ + return view_as<int>(GetTimerRunning(GetNativeCell(1))); +} + +public int Native_GetValidTimer(Handle plugin, int numParams) +{ + return view_as<int>(GetValidTimer(GetNativeCell(1))); +} + +public int Native_GetCourse(Handle plugin, int numParams) +{ + return GetCurrentCourse(GetNativeCell(1)); +} + +public int Native_SetCourse(Handle plugin, int numParams) +{ + if (BlockedExternallyCalledTimerNative(plugin, GetNativeCell(1))) + { + return view_as<int>(false); + } + SetCurrentCourse(GetNativeCell(1), GetNativeCell(2)); + return view_as<int>(false); +} + +public int Native_GetPaused(Handle plugin, int numParams) +{ + return view_as<int>(GetPaused(GetNativeCell(1))); +} + +public int Native_GetTime(Handle plugin, int numParams) +{ + return view_as<int>(GetCurrentTime(GetNativeCell(1))); +} + +public int Native_SetTime(Handle plugin, int numParams) +{ + if (BlockedExternallyCalledTimerNative(plugin, GetNativeCell(1))) + { + return view_as<int>(false); + } + + SetCurrentTime(GetNativeCell(1), view_as<float>(GetNativeCell(2))); + return view_as<int>(true); +} + +public int Native_InvalidateRun(Handle plugin, int numParams) +{ + InvalidateRun(GetNativeCell(1)); + return view_as<int>(true); +} + +public int Native_GetCheckpointCount(Handle plugin, int numParams) +{ + return GetCheckpointCount(GetNativeCell(1)); +} + +public int Native_SetCheckpointCount(Handle plugin, int numParams) +{ + if (BlockedExternallyCalledTimerNative(plugin, GetNativeCell(1))) + { + return view_as<int>(false); + } + SetCheckpointCount(GetNativeCell(1), GetNativeCell(2)); + return view_as<int>(true); +} + +public int Native_GetCheckpointData(Handle plugin, int numParams) +{ + ArrayList temp = GetCheckpointData(GetNativeCell(1)); + Handle cps = CloneHandle(temp, plugin); + delete temp; + return view_as<int>(cps); +} + +public int Native_SetCheckpointData(Handle plugin, int numParams) +{ + if (BlockedExternallyCalledTimerNative(plugin, GetNativeCell(1))) + { + return view_as<int>(false); + } + return SetCheckpointData(GetNativeCell(1), view_as<ArrayList>(GetNativeCell(2)), GetNativeCell(3)); +} + +public int Native_GetUndoTeleportData(Handle plugin, int numParams) +{ + ArrayList temp = GetUndoTeleportData(GetNativeCell(1)); + Handle utd = CloneHandle(temp, plugin); + delete temp; + return view_as<int>(utd); +} + +public int Native_SetUndoTeleportData(Handle plugin, int numParams) +{ + if (BlockedExternallyCalledTimerNative(plugin, GetNativeCell(1))) + { + return view_as<int>(false); + } + return SetUndoTeleportData(GetNativeCell(1), view_as<ArrayList>(GetNativeCell(2)), GetNativeCell(3)); +} + +public int Native_GetTeleportCount(Handle plugin, int numParams) +{ + return GetTeleportCount(GetNativeCell(1)); +} + +public int Native_SetTeleportCount(Handle plugin, int numParams) +{ + if (BlockedExternallyCalledTimerNative(plugin, GetNativeCell(1))) + { + return view_as<int>(false); + } + + SetTeleportCount(GetNativeCell(1), GetNativeCell(2)); + return view_as<int>(true); +} + +public int Native_RegisterOption(Handle plugin, int numParams) +{ + char name[GOKZ_OPTION_MAX_NAME_LENGTH]; + GetNativeString(1, name, sizeof(name)); + char description[255]; + GetNativeString(2, description, sizeof(description)); + return view_as<int>(RegisterOption(name, description, GetNativeCell(3), GetNativeCell(4), GetNativeCell(5), GetNativeCell(6))); +} + +public int Native_GetOptionProp(Handle plugin, int numParams) +{ + char option[GOKZ_OPTION_MAX_NAME_LENGTH]; + GetNativeString(1, option, sizeof(option)); + OptionProp prop = GetNativeCell(2); + any value = GetOptionProp(option, prop); + + // Return clone of Handle if called by another plugin + if (prop == OptionProp_Cookie && plugin != gH_ThisPlugin) + { + value = CloneHandle(value, plugin); + } + + return value; +} + +public int Native_SetOptionProp(Handle plugin, int numParams) +{ + char option[GOKZ_OPTION_MAX_NAME_LENGTH]; + GetNativeString(1, option, sizeof(option)); + OptionProp prop = GetNativeCell(2); + return SetOptionProp(option, prop, GetNativeCell(3)); +} + +public int Native_GetOption(Handle plugin, int numParams) +{ + char option[GOKZ_OPTION_MAX_NAME_LENGTH]; + GetNativeString(2, option, sizeof(option)); + return view_as<int>(GetOption(GetNativeCell(1), option)); +} + +public int Native_SetOption(Handle plugin, int numParams) +{ + char option[GOKZ_OPTION_MAX_NAME_LENGTH]; + GetNativeString(2, option, sizeof(option)); + return view_as<int>(SetOption(GetNativeCell(1), option, GetNativeCell(3))); +} + +public int Native_GetHitPerf(Handle plugin, int numParams) +{ + return view_as<int>(GetGOKZHitPerf(GetNativeCell(1))); +} + +public int Native_SetHitPerf(Handle plugin, int numParams) +{ + SetGOKZHitPerf(GetNativeCell(1), view_as<bool>(GetNativeCell(2))); + return 0; +} + +public int Native_GetTakeoffSpeed(Handle plugin, int numParams) +{ + return view_as<int>(GetGOKZTakeoffSpeed(GetNativeCell(1))); +} + +public int Native_SetTakeoffSpeed(Handle plugin, int numParams) +{ + SetGOKZTakeoffSpeed(GetNativeCell(1), view_as<float>(GetNativeCell(2))); + return 0; +} + +public int Native_GetValidJump(Handle plugin, int numParams) +{ + return view_as<int>(GetValidJump(GetNativeCell(1))); +} + +public int Native_JoinTeam(Handle plugin, int numParams) +{ + JoinTeam(GetNativeCell(1), GetNativeCell(2), GetNativeCell(3), GetNativeCell(4)); + return 0; +} + +public int Native_EmitSoundToClient(Handle plugin, int numParams) +{ + int client = GetNativeCell(1); + + char sample[PLATFORM_MAX_PATH]; + GetNativeString(2, sample, sizeof(sample)); + + float volume = GetNativeCell(3); + float newVolume = volume; + + char description[64]; + GetNativeString(4, description, sizeof(description)); + + Action result; + + Call_GOKZ_OnEmitSoundToClient(client, sample, newVolume, description, result); + if (result == Plugin_Stop) + { + return 0; + } + if (result == Plugin_Changed) + { + EmitSoundToClient(client, sample, _, _, _, _, newVolume); + return 0; + } + EmitSoundToClient(client, sample, _, _, _, _, volume); + return 0; +} + +// =====[ PRIVATE ]===== + +static bool BlockedExternallyCalledTimerNative(Handle plugin, int client) +{ + if (plugin != gH_ThisPlugin) + { + Action result; + Call_GOKZ_OnTimerNativeCalledExternally(plugin, client, result); + if (result != Plugin_Continue) + { + return true; + } + } + return false; +} diff --git a/sourcemod/scripting/gokz-core/options.sp b/sourcemod/scripting/gokz-core/options.sp new file mode 100644 index 0000000..6daef13 --- /dev/null +++ b/sourcemod/scripting/gokz-core/options.sp @@ -0,0 +1,438 @@ +static StringMap optionData; +static StringMap optionDescriptions; + + + +// =====[ PUBLIC ]===== + +bool RegisterOption(const char[] name, const char[] description, OptionType type, any defaultValue, any minValue, any maxValue) +{ + if (!IsValueInRange(type, defaultValue, minValue, maxValue)) + { + LogError("Failed to register option \"%s\" due to invalid default value and value range.", name); + return false; + } + + if (strlen(name) > GOKZ_OPTION_MAX_NAME_LENGTH - 1) + { + LogError("Failed to register option \"%s\" because its name is too long.", name); + return false; + } + + if (strlen(name) > GOKZ_OPTION_MAX_NAME_LENGTH - 1) + { + LogError("Failed to register option \"%s\" because its description is too long.", name); + return false; + } + + ArrayList data; + Cookie cookie; + if (IsRegisteredOption(name)) + { + optionData.GetValue(name, data); + cookie = GetOptionProp(name, OptionProp_Cookie); + } + else + { + data = new ArrayList(1, view_as<int>(OPTIONPROP_COUNT)); + cookie = new Cookie(name, description, CookieAccess_Private); + } + + data.Set(view_as<int>(OptionProp_Cookie), cookie); + data.Set(view_as<int>(OptionProp_Type), type); + data.Set(view_as<int>(OptionProp_DefaultValue), defaultValue); + data.Set(view_as<int>(OptionProp_MinValue), minValue); + data.Set(view_as<int>(OptionProp_MaxValue), maxValue); + + optionData.SetValue(name, data, true); + optionDescriptions.SetString(name, description, true); + + // Support late-loading/registering + for (int client = 1; client <= MaxClients; client++) + { + if (AreClientCookiesCached(client)) + { + LoadOption(client, name); + } + } + + return true; +} + +any GetOptionProp(const char[] option, OptionProp prop) +{ + ArrayList data; + if (!optionData.GetValue(option, data)) + { + LogError("Failed to get option property of unregistered option \"%s\".", option); + return -1; + } + + return data.Get(view_as<int>(prop)); +} + +bool SetOptionProp(const char[] option, OptionProp prop, any newValue) +{ + ArrayList data; + if (!optionData.GetValue(option, data)) + { + LogError("Failed to set property of unregistered option \"%s\".", option); + return false; + } + + if (prop == OptionProp_Cookie) + { + LogError("Failed to set cookie of option \"%s\" as it is read-only."); + return false; + } + + OptionType type = GetOptionProp(option, OptionProp_Type); + any defaultValue = GetOptionProp(option, OptionProp_DefaultValue); + any minValue = GetOptionProp(option, OptionProp_MinValue); + any maxValue = GetOptionProp(option, OptionProp_MaxValue); + + switch (prop) + { + case OptionProp_DefaultValue: + { + if (!IsValueInRange(type, newValue, minValue, maxValue)) + { + LogError("Failed to set default value of option \"%s\" due to invalid default value and value range.", option); + return false; + } + } + case OptionProp_MinValue: + { + if (!IsValueInRange(type, defaultValue, newValue, maxValue)) + { + LogError("Failed to set minimum value of option \"%s\" due to invalid default value and value range.", option); + return false; + } + } + case OptionProp_MaxValue: + { + if (!IsValueInRange(type, defaultValue, minValue, newValue)) + { + LogError("Failed to set maximum value of option \"%s\" due to invalid default value and value range.", option); + return false; + } + } + } + + data.Set(view_as<int>(prop), newValue); + return optionData.SetValue(option, data, true); +} + +any GetOption(int client, const char[] option) +{ + if (!IsRegisteredOption(option)) + { + LogError("Failed to get value of unregistered option \"%s\".", option); + return -1; + } + + Cookie cookie = GetOptionProp(option, OptionProp_Cookie); + OptionType type = GetOptionProp(option, OptionProp_Type); + char value[100]; + cookie.Get(client, value, sizeof(value)); + + if (type == OptionType_Float) + { + return StringToFloat(value); + } + else //if (type == OptionType_Int) + { + return StringToInt(value); + } +} + +bool SetOption(int client, const char[] option, any newValue) +{ + if (!IsRegisteredOption(option)) + { + LogError("Failed to set value of unregistered option \"%s\".", option); + return false; + } + + if (GetOption(client, option) == newValue) + { + return true; + } + + OptionType type = GetOptionProp(option, OptionProp_Type); + any minValue = GetOptionProp(option, OptionProp_MinValue); + any maxValue = GetOptionProp(option, OptionProp_MaxValue); + + if (!IsValueInRange(type, newValue, minValue, maxValue)) + { + LogError("Failed to set value of option \"%s\" because desired value was outside registered value range.", option); + return false; + } + + char newValueString[100]; + if (type == OptionType_Float) + { + FloatToString(newValue, newValueString, sizeof(newValueString)); + } + else //if (type == OptionType_Int) + { + IntToString(newValue, newValueString, sizeof(newValueString)); + } + + Cookie cookie = GetOptionProp(option, OptionProp_Cookie); + cookie.Set(client, newValueString); + + if (IsClientInGame(client)) + { + Call_GOKZ_OnOptionChanged(client, option, newValue); + } + + return true; +} + +bool IsRegisteredOption(const char[] option) +{ + int dummy; + return optionData.GetValue(option, dummy); +} + + + +// =====[ EVENTS ]===== + +void OnPluginStart_Options() +{ + optionData = new StringMap(); + optionDescriptions = new StringMap(); + RegisterOptions(); +} + +void OnClientCookiesCached_Options(int client) +{ + StringMapSnapshot optionDataSnapshot = optionData.Snapshot(); + char option[GOKZ_OPTION_MAX_NAME_LENGTH]; + + for (int i = 0; i < optionDataSnapshot.Length; i++) + { + optionDataSnapshot.GetKey(i, option, sizeof(option)); + LoadOption(client, option); + } + + delete optionDataSnapshot; + + Call_GOKZ_OnOptionsLoaded(client); +} + +void OnClientPutInServer_Options(int client) +{ + if (!GetModeLoaded(GOKZ_GetCoreOption(client, Option_Mode))) + { + GOKZ_SetCoreOption(client, Option_Mode, GetALoadedMode()); + } +} + +void OnOptionChanged_Options(int client, Option option, int newValue) +{ + if (option == Option_Mode && !GetModeLoaded(newValue)) + { + GOKZ_PrintToChat(client, true, "%t", "Mode Not Available", newValue); + GOKZ_SetCoreOption(client, Option_Mode, GetALoadedMode()); + } + else + { + PrintOptionChangeMessage(client, option, newValue); + } +} + +void OnModeUnloaded_Options(int mode) +{ + for (int client = 1; client <= MaxClients; client++) + { + if (IsClientInGame(client) && GOKZ_GetCoreOption(client, Option_Mode) == mode) + { + GOKZ_SetCoreOption(client, Option_Mode, GetALoadedMode()); + } + } +} + +void OnMapStart_Options() +{ + LoadDefaultOptions(); +} + + + +// =====[ PRIVATE ]===== + +static void RegisterOptions() +{ + for (Option option; option < OPTION_COUNT; option++) + { + RegisterOption(gC_CoreOptionNames[option], gC_CoreOptionDescriptions[option], + OptionType_Int, gI_CoreOptionDefaults[option], 0, gI_CoreOptionCounts[option] - 1); + } +} + +static bool IsValueInRange(OptionType type, any value, any minValue, any maxValue) +{ + if (type == OptionType_Float) + { + return FloatCompare(minValue, value) <= 0 && FloatCompare(value, maxValue) <= 0; + } + else //if (type == OptionType_Int) + { + return minValue <= value && value <= maxValue; + } +} + +static void LoadOption(int client, const char[] option) +{ + char valueString[100]; + Cookie cookie = GetOptionProp(option, OptionProp_Cookie); + cookie.Get(client, valueString, sizeof(valueString)); + + // If there's no stored value for the option, set it to default + if (valueString[0] == '\0') + { + SetOption(client, option, GetOptionProp(option, OptionProp_DefaultValue)); + return; + } + + OptionType type = GetOptionProp(option, OptionProp_Type); + any minValue = GetOptionProp(option, OptionProp_MinValue); + any maxValue = GetOptionProp(option, OptionProp_MaxValue); + any value; + + // If stored option isn't a valid float or integer, or is out of range, set it to default + if (type == OptionType_Float && StringToFloatEx(valueString, value) == 0) + { + SetOption(client, option, GetOptionProp(option, OptionProp_DefaultValue)); + } + else if (type == OptionType_Int && StringToIntEx(valueString, value) == 0) + { + SetOption(client, option, GetOptionProp(option, OptionProp_DefaultValue)); + } + else if (!IsValueInRange(type, value, minValue, maxValue)) + { + SetOption(client, option, GetOptionProp(option, OptionProp_DefaultValue)); + } +} + +// Load default optionData from a config file, creating one and adding optionData if necessary +static void LoadDefaultOptions() +{ + KeyValues oldKV = new KeyValues(GOKZ_CFG_OPTIONS_ROOT); + + if (FileExists(GOKZ_CFG_OPTIONS) && !oldKV.ImportFromFile(GOKZ_CFG_OPTIONS)) + { + LogError("Failed to load file: \"%s\".", GOKZ_CFG_OPTIONS); + delete oldKV; + return; + } + + KeyValues newKV = new KeyValues(GOKZ_CFG_OPTIONS_ROOT); // This one will be sorted by option name + StringMapSnapshot optionDataSnapshot = optionData.Snapshot(); + ArrayList optionDataSnapshotArray = new ArrayList(ByteCountToCells(GOKZ_OPTION_MAX_NAME_LENGTH), 0); + char option[GOKZ_OPTION_MAX_NAME_LENGTH]; + char optionDescription[GOKZ_OPTION_MAX_DESC_LENGTH]; + + // Sort the optionData by name + for (int i = 0; i < optionDataSnapshot.Length; i++) + { + optionDataSnapshot.GetKey(i, option, sizeof(option)); + optionDataSnapshotArray.PushString(option); + } + SortADTArray(optionDataSnapshotArray, Sort_Ascending, Sort_String); + + // Get the values from the KeyValues, otherwise set them + for (int i = 0; i < optionDataSnapshotArray.Length; i++) + { + oldKV.Rewind(); + newKV.Rewind(); + optionDataSnapshotArray.GetString(i, option, sizeof(option)); + optionDescriptions.GetString(option, optionDescription, sizeof(optionDescription)); + + newKV.JumpToKey(option, true); + newKV.SetString(GOKZ_CFG_OPTIONS_DESCRIPTION, optionDescription); + + OptionType type = GetOptionProp(option, OptionProp_Type); + if (type == OptionType_Float) + { + if (oldKV.JumpToKey(option, false) && oldKV.JumpToKey(GOKZ_CFG_OPTIONS_DEFAULT, false)) + { + oldKV.GoBack(); + newKV.SetFloat(GOKZ_CFG_OPTIONS_DEFAULT, oldKV.GetFloat(GOKZ_CFG_OPTIONS_DEFAULT)); + SetOptionProp(option, OptionProp_DefaultValue, oldKV.GetFloat(GOKZ_CFG_OPTIONS_DEFAULT)); + } + else + { + newKV.SetFloat(GOKZ_CFG_OPTIONS_DEFAULT, GetOptionProp(option, OptionProp_DefaultValue)); + } + } + else if (type == OptionType_Int) + { + if (oldKV.JumpToKey(option, false) && oldKV.JumpToKey(GOKZ_CFG_OPTIONS_DEFAULT, false)) + { + oldKV.GoBack(); + newKV.SetNum(GOKZ_CFG_OPTIONS_DEFAULT, oldKV.GetNum(GOKZ_CFG_OPTIONS_DEFAULT)); + SetOptionProp(option, OptionProp_DefaultValue, oldKV.GetNum(GOKZ_CFG_OPTIONS_DEFAULT)); + } + else + { + newKV.SetNum(GOKZ_CFG_OPTIONS_DEFAULT, GetOptionProp(option, OptionProp_DefaultValue)); + } + } + } + + newKV.Rewind(); + newKV.ExportToFile(GOKZ_CFG_OPTIONS); + + delete oldKV; + delete newKV; + delete optionDataSnapshot; + delete optionDataSnapshotArray; +} + +static void PrintOptionChangeMessage(int client, Option option, int newValue) +{ + // NOTE: Not all optionData have a message for when they are changed. + switch (option) + { + case Option_Mode: + { + GOKZ_PrintToChat(client, true, "%t", "Switched Mode", gC_ModeNames[newValue]); + } + case Option_VirtualButtonIndicators: + { + switch (newValue) + { + case VirtualButtonIndicators_Disabled: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Virtual Button Indicators - Disable"); + } + case VirtualButtonIndicators_Enabled: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Virtual Button Indicators - Enable"); + } + } + } + case Option_Safeguard: + { + switch (newValue) + { + case Safeguard_Disabled: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Safeguard - Disable"); + } + case Safeguard_EnabledNUB: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Safeguard - Enable (NUB)"); + } + case Safeguard_EnabledPRO: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Safeguard - Enable (PRO)"); + } + } + } + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-core/teamnumfix.sp b/sourcemod/scripting/gokz-core/teamnumfix.sp new file mode 100644 index 0000000..0c5d81d --- /dev/null +++ b/sourcemod/scripting/gokz-core/teamnumfix.sp @@ -0,0 +1,68 @@ +static Handle H_RemovePlayer; +static int teamEntID[4]; +static int oldTeam[MAXPLAYERS + 1]; +static int realTeam[MAXPLAYERS + 1]; + +void OnPluginStart_TeamNumber() +{ + GameData gamedataConf = LoadGameConfigFile("gokz-core.games"); + if (gamedataConf == null) + { + SetFailState("Failed to load gokz-core gamedata"); + } + + StartPrepSDKCall(SDKCall_Entity); + PrepSDKCall_SetVirtual(gamedataConf.GetOffset("CCSTeam::RemovePlayer")); + PrepSDKCall_AddParameter(SDKType_CBasePlayer, SDKPass_Pointer); + H_RemovePlayer = EndPrepSDKCall(); + if (H_RemovePlayer == INVALID_HANDLE) + { + SetFailState("Unable to prepare SDKCall for CCSTeam::RemovePlayer!"); + } +} + +void OnMapStart_TeamNumber() +{ + // Fetch the entity ID of team entities and store them. + int team = FindEntityByClassname(MaxClients + 1, "cs_team_manager"); + while (team != -1) + { + int teamNum = GetEntProp(team, Prop_Send, "m_iTeamNum"); + teamEntID[teamNum] = team; + team = FindEntityByClassname(team, "cs_team_manager"); + } +} + +void OnGameFrame_TeamNumber() +{ + for (int client = 1; client <= MaxClients; client++) + { + if (!IsClientInGame(client) || !IsPlayerAlive(client)) + { + continue; + } + int team = GetEntProp(client, Prop_Data, "m_iTeamNum"); + // If the entprop changed, remove the player from the old team, but make sure it's a valid team first + if (team != oldTeam[client] && oldTeam[client] < 4 && oldTeam[client] > 0) + { + SDKCall(H_RemovePlayer, teamEntID[oldTeam[client]], client); + } + oldTeam[client] = team; + } +} + +void OnPlayerJoinTeam_TeamNumber(Event event, int client) +{ + // If the old team value is invalid, fix it. + if (event.GetInt("oldteam") > 4 || event.GetInt("oldteam") < 0) + { + event.SetInt("oldteam", 0); + } + realTeam[client] = event.GetInt("team"); +} + +void OnPlayerDeath_TeamNumber(int client) +{ + // Switch the client's team to a valid team to prevent crashes. + CS_SwitchTeam(client, realTeam[client]); +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-core/teleports.sp b/sourcemod/scripting/gokz-core/teleports.sp new file mode 100644 index 0000000..764fc6e --- /dev/null +++ b/sourcemod/scripting/gokz-core/teleports.sp @@ -0,0 +1,917 @@ +/* + Checkpoints and teleporting, including ability to go back + to previous checkpoint, go to next checkpoint, and undo. +*/ + + +static ArrayList checkpoints[MAXPLAYERS + 1]; +static int checkpointCount[MAXPLAYERS + 1]; +static int checkpointIndex[MAXPLAYERS + 1]; +static int checkpointIndexStart[MAXPLAYERS + 1]; +static int checkpointIndexEnd[MAXPLAYERS + 1]; +static int teleportCount[MAXPLAYERS + 1]; +static StartPositionType startType[MAXPLAYERS + 1]; +static StartPositionType nonCustomStartType[MAXPLAYERS + 1]; +static float nonCustomStartOrigin[MAXPLAYERS + 1][3]; +static float nonCustomStartAngles[MAXPLAYERS + 1][3]; +static float customStartOrigin[MAXPLAYERS + 1][3]; +static float customStartAngles[MAXPLAYERS + 1][3]; +static float endOrigin[MAXPLAYERS + 1][3]; +static float endAngles[MAXPLAYERS + 1][3]; +static UndoTeleportData undoTeleportData[MAXPLAYERS + 1]; +static float lastRestartAttemptTime[MAXPLAYERS + 1]; + +// =====[ PUBLIC ]===== + +int GetCheckpointCount(int client) +{ + return checkpointCount[client]; +} + +void SetCheckpointCount(int client, int cpCount) +{ + checkpointCount[client] = cpCount; +} + +int GetTeleportCount(int client) +{ + return teleportCount[client]; +} + +void SetTeleportCount(int client, int tpCount) +{ + teleportCount[client] = tpCount; +} + +// CHECKPOINT + +void OnMapStart_Checkpoints() +{ + for (int client = 0; client < MAXPLAYERS + 1; client++) + { + if (checkpoints[client] != INVALID_HANDLE) + { + delete checkpoints[client]; + } + checkpoints[client] = new ArrayList(sizeof(Checkpoint)); + } +} + +void MakeCheckpoint(int client) +{ + if (!CanMakeCheckpoint(client, true)) + { + return; + } + + // Call Pre Forward + Action result; + Call_GOKZ_OnMakeCheckpoint(client, result); + if (result != Plugin_Continue) + { + return; + } + + // Make Checkpoint + checkpointCount[client]++; + Checkpoint cp; + cp.Create(client); + + if (checkpoints[client] == INVALID_HANDLE) + { + checkpoints[client] = new ArrayList(sizeof(Checkpoint)); + } + + checkpointIndex[client] = NextIndex(checkpointIndex[client], GOKZ_MAX_CHECKPOINTS); + checkpointIndexEnd[client] = checkpointIndex[client]; + // The list has yet to be filled up, do PushArray instead of SetArray + if (checkpoints[client].Length < GOKZ_MAX_CHECKPOINTS && checkpointIndex[client] == checkpoints[client].Length) + { + checkpoints[client].PushArray(cp); + // Initialize start and end index for the first checkpoint + if (checkpoints[client].Length == 1) + { + checkpointIndexStart[client] = 0; + checkpointIndexEnd[client] = 0; + } + } + else + { + checkpoints[client].SetArray(checkpointIndex[client], cp); + // The new checkpoint has overridden the oldest checkpoint, move the start index by one. + if (checkpointIndexEnd[client] == checkpointIndexStart[client]) + { + checkpointIndexStart[client] = NextIndex(checkpointIndexStart[client], GOKZ_MAX_CHECKPOINTS); + } + } + + + if (GOKZ_GetCoreOption(client, Option_CheckpointSounds) == CheckpointSounds_Enabled) + { + GOKZ_EmitSoundToClient(client, GOKZ_SOUND_CHECKPOINT, _, "Checkpoint"); + } + if (GOKZ_GetCoreOption(client, Option_CheckpointMessages) == CheckpointMessages_Enabled) + { + GOKZ_PrintToChat(client, true, "%t", "Make Checkpoint", checkpointCount[client]); + } + + if (!GetTimerRunning(client) && AntiCpTriggerIsTouched(client)) + { + GOKZ_PrintToChat(client, true, "%t", "Anti Checkpoint Area Warning"); + } + + // Call Post Forward + Call_GOKZ_OnMakeCheckpoint_Post(client); +} + +bool CanMakeCheckpoint(int client, bool showError = false) +{ + if (!IsPlayerAlive(client)) + { + if (showError) + { + GOKZ_PrintToChat(client, true, "%t", "Must Be Alive"); + GOKZ_PlayErrorSound(client); + } + return false; + } + if (GetTimerRunning(client) && AntiCpTriggerIsTouched(client)) + { + if (showError) + { + GOKZ_PrintToChat(client, true, "%t", "Can't Checkpoint (Anti Checkpoint Area)"); + GOKZ_PlayErrorSound(client); + } + return false; + } + if (!Movement_GetOnGround(client) && Movement_GetMovetype(client) != MOVETYPE_LADDER) + { + if (showError) + { + GOKZ_PrintToChat(client, true, "%t", "Can't Checkpoint (Midair)"); + GOKZ_PlayErrorSound(client); + } + return false; + } + if (BhopTriggersJustTouched(client)) + { + if (showError) + { + GOKZ_PrintToChat(client, true, "%t", "Can't Checkpoint (Just Landed)"); + GOKZ_PlayErrorSound(client); + } + return false; + } + return true; +} + +ArrayList GetCheckpointData(int client) +{ + // Don't clone the entire thing, return an ordered list of checkpoints. + // Doing this should be cleaner, saves memory and should be faster than a full Clone(). + ArrayList checkpointData = new ArrayList(sizeof(Checkpoint)); + if (checkpointIndex[client] == -1) + { + // No checkpoint was made, return empty ArrayList + return checkpointData; + } + for (int i = checkpointIndexStart[client]; i != checkpointIndexEnd[client]; i = NextIndex(i, GOKZ_MAX_CHECKPOINTS)) + { + Checkpoint cp; + checkpoints[client].GetArray(i, cp); + checkpointData.PushArray(cp); + } + return checkpointData; +} + +bool SetCheckpointData(int client, ArrayList cps, int version) +{ + if (version != GOKZ_CHECKPOINT_VERSION) + { + return false; + } + // cps is assumed to be ordered. + if (cps != INVALID_HANDLE) + { + delete checkpoints[client]; + checkpoints[client] = cps.Clone(); + if (cps.Length == 0) + { + checkpointIndexStart[client] = -1; + checkpointIndexEnd[client] = -1; + } + else + { + checkpointIndexStart[client] = 0; + checkpointIndexEnd[client] = checkpoints[client].Length - 1; + } + checkpointIndex[client] = checkpointIndexEnd[client]; + return true; + } + return false; +} + +ArrayList GetUndoTeleportData(int client) +{ + // Enum structs cannot be sent directly over natives, we put it in an ArrayList of one instead. + // We use another struct instead of reusing Checkpoint so normal checkpoints don't use more memory than needed. + ArrayList undoTeleportDataArray = new ArrayList(sizeof(UndoTeleportData)); + undoTeleportDataArray.PushArray(undoTeleportData[client]); + return undoTeleportDataArray; +} + +bool SetUndoTeleportData(int client, ArrayList undoTeleportDataArray, int version) +{ + if (version != GOKZ_CHECKPOINT_VERSION) + { + return false; + } + if (undoTeleportDataArray != INVALID_HANDLE && undoTeleportDataArray.Length == 1) + { + undoTeleportDataArray.GetArray(0, undoTeleportData[client], sizeof(UndoTeleportData)); + return true; + } + return false; +} +// TELEPORT + +void TeleportToCheckpoint(int client) +{ + if (!CanTeleportToCheckpoint(client, true)) + { + return; + } + + // Call Pre Forward + Action result; + Call_GOKZ_OnTeleportToCheckpoint(client, result); + if (result != Plugin_Continue) + { + return; + } + + CheckpointTeleportDo(client); + + // Call Post Forward + Call_GOKZ_OnTeleportToCheckpoint_Post(client); +} + +bool CanTeleportToCheckpoint(int client, bool showError = false) +{ + // Safeguard Check + if (GOKZ_GetCoreOption(client, Option_Safeguard) == Safeguard_EnabledPRO && GOKZ_GetTimerRunning(client) && GOKZ_GetValidTimer(client) && GOKZ_GetTeleportCount(client) == 0) + { + if (showError) + { + GOKZ_PrintToChat(client, true, "%t", "Safeguard - Blocked"); + GOKZ_PlayErrorSound(client); + } + return false; + } + if (GetCurrentMapPrefix() == MapPrefix_KZPro && GetTimerRunning(client)) + { + if (showError) + { + GOKZ_PrintToChat(client, true, "%t", "Can't Teleport (Map)"); + GOKZ_PlayErrorSound(client); + } + return false; + } + if (checkpoints[client] == INVALID_HANDLE || checkpoints[client].Length <= 0) + { + if (showError) + { + GOKZ_PrintToChat(client, true, "%t", "Can't Teleport (No Checkpoints)"); + GOKZ_PlayErrorSound(client); + } + return false; + } + return true; +} + + +// PREV CP + +void PrevCheckpoint(int client) +{ + if (!CanPrevCheckpoint(client, true)) + { + return; + } + + // Call Pre Forward + Action result; + Call_GOKZ_OnPrevCheckpoint(client, result); + if (result != Plugin_Continue) + { + return; + } + + checkpointIndex[client] = PrevIndex(checkpointIndex[client], GOKZ_MAX_CHECKPOINTS); + CheckpointTeleportDo(client); + + // Call Post Forward + Call_GOKZ_OnPrevCheckpoint_Post(client); +} + +bool CanPrevCheckpoint(int client, bool showError = false) +{ + // Safeguard Check + if (GOKZ_GetCoreOption(client, Option_Safeguard) == Safeguard_EnabledPRO && GOKZ_GetTimerRunning(client) && GOKZ_GetValidTimer(client)) + { + if (showError) + { + GOKZ_PrintToChat(client, true, "%t", "Safeguard - Blocked"); + GOKZ_PlayErrorSound(client); + } + return false; + } + if (GetCurrentMapPrefix() == MapPrefix_KZPro && GetTimerRunning(client)) + { + if (showError) + { + GOKZ_PrintToChat(client, true, "%t", "Can't Teleport (Map)"); + GOKZ_PlayErrorSound(client); + } + return false; + } + if (checkpointIndex[client] == checkpointIndexStart[client]) + { + if (showError) + { + GOKZ_PrintToChat(client, true, "%t", "Can't Prev CP (No Checkpoints)"); + GOKZ_PlayErrorSound(client); + } + return false; + } + return true; +} + + +// NEXT CP + +void NextCheckpoint(int client) +{ + if (!CanNextCheckpoint(client, true)) + { + return; + } + + // Call Pre Forward + Action result; + Call_GOKZ_OnNextCheckpoint(client, result); + if (result != Plugin_Continue) + { + return; + } + checkpointIndex[client] = NextIndex(checkpointIndex[client], GOKZ_MAX_CHECKPOINTS); + CheckpointTeleportDo(client); + + // Call Post Forward + Call_GOKZ_OnNextCheckpoint_Post(client); +} + +bool CanNextCheckpoint(int client, bool showError = false) +{ + if (GetCurrentMapPrefix() == MapPrefix_KZPro && GetTimerRunning(client)) + { + if (showError) + { + GOKZ_PrintToChat(client, true, "%t", "Can't Teleport (Map)"); + GOKZ_PlayErrorSound(client); + } + return false; + } + if (checkpointIndex[client] == checkpointIndexEnd[client]) + { + if (showError) + { + GOKZ_PrintToChat(client, true, "%t", "Can't Next CP (No Checkpoints)"); + GOKZ_PlayErrorSound(client); + } + return false; + } + return true; +} + + +// RESTART & RESPAWN + +bool CanTeleportToStart(int client, bool showError = false) +{ + // Safeguard Check + if (GOKZ_GetCoreOption(client, Option_Safeguard) > Safeguard_Disabled && GOKZ_GetTimerRunning(client) && GOKZ_GetValidTimer(client)) + { + float currentTime = GetEngineTime(); + float timeSinceLastAttempt = currentTime - lastRestartAttemptTime[client]; + float cooldown; + // If the client restarts for the first time or the last attempt is too long ago, restart the cooldown. + if (lastRestartAttemptTime[client] == 0.0 || timeSinceLastAttempt > GOKZ_SAFEGUARD_RESTART_MAX_DELAY) + { + lastRestartAttemptTime[client] = currentTime; + cooldown = GOKZ_SAFEGUARD_RESTART_MIN_DELAY; + } + else + { + cooldown = GOKZ_SAFEGUARD_RESTART_MIN_DELAY - timeSinceLastAttempt; + } + if (cooldown <= 0.0) + { + lastRestartAttemptTime[client] = 0.0; + return true; + } + if (showError) + { + GOKZ_PrintToChat(client, true, "%t", "Safeguard - Blocked (Temp)", cooldown); + GOKZ_PlayErrorSound(client); + } + return false; + } + return true; +} + +void TeleportToStart(int client) +{ + if (!CanTeleportToStart(client, true)) + { + return; + } + + // Call Pre Forward + Action result; + Call_GOKZ_OnTeleportToStart(client, GetCurrentCourse(client), result); + if (result != Plugin_Continue) + { + return; + } + + // Teleport to Start + if (startType[client] == StartPositionType_Spawn) + { + GOKZ_RespawnPlayer(client, .restorePos = false); + // Respawning alone does not guarantee a valid spawn. + float spawnOrigin[3]; + float spawnAngles[3]; + GetValidSpawn(spawnOrigin, spawnAngles); + TeleportPlayer(client, spawnOrigin, spawnAngles); + } + else if (startType[client] == StartPositionType_Custom) + { + TeleportDo(client, customStartOrigin[client], customStartAngles[client]); + } + else + { + TeleportDo(client, nonCustomStartOrigin[client], nonCustomStartAngles[client]); + } + + if (startType[client] != StartPositionType_MapButton + && (!InRangeOfVirtualStart(client) || !CanReachVirtualStart(client))) + { + GOKZ_StopTimer(client, false); + } + + // Call Post Forward + Call_GOKZ_OnTeleportToStart_Post(client, GetCurrentCourse(client)); +} + +void TeleportToSearchStart(int client, int course) +{ + if (!CanTeleportToStart(client, true)) + { + return; + } + + // Call Pre Forward + Action result; + Call_GOKZ_OnTeleportToStart(client, course, result); + if (result != Plugin_Continue) + { + return; + } + + float origin[3], angles[3]; + if (!GetSearchStartPosition(course, origin, angles)) + { + if (course == 0) + { + GOKZ_PrintToChat(client, true, "%t", "No Start Found"); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "No Start Found (Bonus)", course); + } + return; + } + GOKZ_StopTimer(client, false); + + TeleportDo(client, origin, angles); + // Call Post Forward + Call_GOKZ_OnTeleportToStart_Post(client, course); +} + +StartPositionType GetStartPosition(int client, float position[3], float angles[3]) +{ + if (startType[client] == StartPositionType_Custom) + { + position = customStartOrigin[client]; + angles = customStartAngles[client]; + } + else if (startType[client] != StartPositionType_Spawn) + { + position = nonCustomStartOrigin[client]; + angles = nonCustomStartAngles[client]; + } + + return startType[client]; +} + +bool TeleportToCourseStart(int client, int course) +{ + if (!CanTeleportToStart(client, true)) + { + return false; + } + + // Call Pre Forward + Action result; + Call_GOKZ_OnTeleportToStart(client, course, result); + if (result != Plugin_Continue) + { + return false; + } + float origin[3], angles[3]; + + if (!GetMapStartPosition(course, origin, angles)) + { + if (!GetSearchStartPosition(course, origin, angles)) + { + if (course == 0) + { + GOKZ_PrintToChat(client, true, "%t", "No Start Found"); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "No Start Found (Bonus)", course); + } + return false; + } + } + + GOKZ_StopTimer(client); + + TeleportDo(client, origin, angles); + + // Call Post Forward + Call_GOKZ_OnTeleportToStart_Post(client, course); + return true; +} + +StartPositionType GetStartPositionType(int client) +{ + return startType[client]; +} + +// Note: Use ClearStartPosition to switch off StartPositionType_Custom +void SetStartPosition(int client, StartPositionType type, const float origin[3] = NULL_VECTOR, const float angles[3] = NULL_VECTOR) +{ + if (type == StartPositionType_Custom) + { + startType[client] = StartPositionType_Custom; + + if (!IsNullVector(origin)) + { + customStartOrigin[client] = origin; + } + + if (!IsNullVector(angles)) + { + customStartAngles[client] = angles; + } + + // Call Post Forward + Call_GOKZ_OnStartPositionSet_Post(client, startType[client], customStartOrigin[client], customStartAngles[client]); + } + else + { + nonCustomStartType[client] = type; + + if (!IsNullVector(origin)) + { + nonCustomStartOrigin[client] = origin; + } + + if (!IsNullVector(angles)) + { + nonCustomStartAngles[client] = angles; + } + + if (startType[client] != StartPositionType_Custom) + { + startType[client] = type; + + // Call Post Forward + Call_GOKZ_OnStartPositionSet_Post(client, startType[client], nonCustomStartOrigin[client], nonCustomStartAngles[client]); + } + } +} + +void SetStartPositionToCurrent(int client, StartPositionType type) +{ + float origin[3], angles[3]; + Movement_GetOrigin(client, origin); + Movement_GetEyeAngles(client, angles); + + SetStartPosition(client, type, origin, angles); +} + +bool SetStartPositionToMapStart(int client, int course) +{ + float origin[3], angles[3]; + + if (!GetMapStartPosition(course, origin, angles)) + { + return false; + } + + SetStartPosition(client, StartPositionType_MapStart, origin, angles); + + return true; +} + +bool ClearCustomStartPosition(int client) +{ + if (GetStartPositionType(client) != StartPositionType_Custom) + { + return false; + } + + startType[client] = nonCustomStartType[client]; + + // Call Post Forward + Call_GOKZ_OnStartPositionSet_Post(client, startType[client], nonCustomStartOrigin[client], nonCustomStartAngles[client]); + + return true; +} + + +// TELEPORT TO END + +bool CanTeleportToEnd(int client, bool showError = false) +{ + // Safeguard Check + if (GOKZ_GetCoreOption(client, Option_Safeguard) > Safeguard_Disabled && GOKZ_GetTimerRunning(client) && GOKZ_GetValidTimer(client)) + { + if (showError) + { + GOKZ_PrintToChat(client, true, "%t", "Safeguard - Blocked"); + GOKZ_PlayErrorSound(client); + } + return false; + } + return true; +} + +void TeleportToEnd(int client, int course) +{ + if (!CanTeleportToEnd(client, true)) + { + return; + } + + // Call Pre Forward + Action result; + Call_GOKZ_OnTeleportToEnd(client, course, result); + if (result != Plugin_Continue) + { + return; + } + + GOKZ_StopTimer(client, false); + + if (!GetMapEndPosition(course, endOrigin[client], endAngles[client])) + { + if (course == 0) + { + GOKZ_PrintToChat(client, true, "%t", "No End Found"); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "No End Found (Bonus)", course); + } + return; + } + TeleportDo(client, endOrigin[client], endAngles[client]); + + // Call Post Forward + Call_GOKZ_OnTeleportToEnd_Post(client, course); +} + +void SetEndPosition(int client, const float origin[3] = NULL_VECTOR, const float angles[3] = NULL_VECTOR) +{ + if (!IsNullVector(origin)) + { + endOrigin[client] = origin; + } + if (!IsNullVector(angles)) + { + endAngles[client] = angles; + } +} + +bool SetEndPositionToMapEnd(int client, int course) +{ + float origin[3], angles[3]; + + if (!GetMapEndPosition(course, origin, angles)) + { + return false; + } + + SetEndPosition(client, origin, angles); + + return true; +} + + +// UNDO TP + +void UndoTeleport(int client) +{ + if (!CanUndoTeleport(client, true)) + { + return; + } + + // Call Pre Forward + Action result; + Call_GOKZ_OnUndoTeleport(client, result); + if (result != Plugin_Continue) + { + return; + } + + // Undo Teleport + TeleportDo(client, undoTeleportData[client].origin, undoTeleportData[client].angles); + + // Call Post Forward + Call_GOKZ_OnUndoTeleport_Post(client); +} + +bool CanUndoTeleport(int client, bool showError = false) +{ + if (teleportCount[client] <= 0) + { + if (showError) + { + GOKZ_PrintToChat(client, true, "%t", "Can't Undo (No Teleports)"); + GOKZ_PlayErrorSound(client); + } + return false; + } + if (!undoTeleportData[client].lastTeleportOnGround) + { + if (showError) + { + GOKZ_PrintToChat(client, true, "%t", "Can't Undo (TP Was Midair)"); + GOKZ_PlayErrorSound(client); + } + return false; + } + if (undoTeleportData[client].lastTeleportInBhopTrigger) + { + if (showError) + { + GOKZ_PrintToChat(client, true, "%t", "Can't Undo (Just Landed)"); + GOKZ_PlayErrorSound(client); + } + return false; + } + if (undoTeleportData[client].lastTeleportInAntiCpTrigger) + { + if (showError) + { + GOKZ_PrintToChat(client, true, "%t", "Can't Undo (AntiCp)"); + GOKZ_PlayErrorSound(client); + } + return false; + } + return true; +} + + + +// =====[ EVENTS ]===== + +void OnClientPutInServer_Teleports(int client) +{ + checkpointCount[client] = 0; + checkpointIndex[client] = -1; + checkpointIndexStart[client] = -1; + checkpointIndexEnd[client] = -1; + teleportCount[client] = 0; + startType[client] = StartPositionType_Spawn; + nonCustomStartType[client] = StartPositionType_Spawn; + lastRestartAttemptTime[client] = 0.0; + if (checkpoints[client] != INVALID_HANDLE) + { + checkpoints[client].Clear(); + } + // Set start and end position to main course if we know of it + SetStartPositionToMapStart(client, 0); + SetEndPositionToMapEnd(client, 0); + +} + +void OnTimerStart_Teleports(int client) +{ + checkpointCount[client] = 0; + checkpointIndex[client] = -1; + checkpointIndexStart[client] = -1; + checkpointIndexEnd[client] = -1; + teleportCount[client] = 0; + checkpoints[client].Clear(); +} + +void OnStartButtonPress_Teleports(int client, int course) +{ + SetStartPositionToCurrent(client, StartPositionType_MapButton); + SetEndPositionToMapEnd(client, course); +} + +void OnVirtualStartButtonPress_Teleports(int client) +{ + SetStartPositionToCurrent(client, StartPositionType_MapButton); +} + +void OnStartZoneStartTouch_Teleports(int client, int course) +{ + SetStartPositionToMapStart(client, course); + SetEndPositionToMapEnd(client, course); +} + + + +// =====[ PRIVATE ]===== + +static int PrevIndex(int current, int maximum) +{ + int prev = current - 1; + if (prev < 0) + { + return maximum - 1; + } + return prev; +} + +static void TeleportDo(int client, const float destOrigin[3], const float destAngles[3]) +{ + if (!IsPlayerAlive(client)) + { + GOKZ_RespawnPlayer(client); + } + + // Store information about where player is teleporting from + undoTeleportData[client].Init(client, BhopTriggersJustTouched(client), Movement_GetOnGround(client), AntiCpTriggerIsTouched(client)); + + teleportCount[client]++; + TeleportPlayer(client, destOrigin, destAngles); + // TeleportPlayer needs to be done before undo TP data can be fully updated. + undoTeleportData[client].Update(); + if (GOKZ_GetCoreOption(client, Option_TeleportSounds) == TeleportSounds_Enabled) + { + GOKZ_EmitSoundToClient(client, GOKZ_SOUND_TELEPORT, _, "Teleport"); + } + + // Call Post Foward + Call_GOKZ_OnCountedTeleport_Post(client); +} + +static void CheckpointTeleportDo(int client) +{ + Checkpoint cp; + checkpoints[client].GetArray(checkpointIndex[client], cp); + + TeleportDo(client, cp.origin, cp.angles); + if (cp.groundEnt != INVALID_ENT_REFERENCE) + { + SetEntPropEnt(client, Prop_Data, "m_hGroundEntity", cp.groundEnt); + SetEntityFlags(client, GetEntityFlags(client) | FL_ONGROUND); + } + // Handle ladder stuff + if (cp.onLadder) + { + SetEntPropVector(client, Prop_Send, "m_vecLadderNormal", cp.ladderNormal); + if (!GOKZ_GetPaused(client)) + { + Movement_SetMovetype(client, MOVETYPE_LADDER); + } + else + { + SetPausedOnLadder(client, true); + } + } + else if (GOKZ_GetPaused(client)) + { + SetPausedOnLadder(client, false); + } +} diff --git a/sourcemod/scripting/gokz-core/timer/pause.sp b/sourcemod/scripting/gokz-core/timer/pause.sp new file mode 100644 index 0000000..92ab1fb --- /dev/null +++ b/sourcemod/scripting/gokz-core/timer/pause.sp @@ -0,0 +1,257 @@ +static bool paused[MAXPLAYERS + 1]; +static bool pausedOnLadder[MAXPLAYERS + 1]; +static float lastPauseTime[MAXPLAYERS + 1]; +static bool hasPausedInThisRun[MAXPLAYERS + 1]; +static float lastResumeTime[MAXPLAYERS + 1]; +static bool hasResumedInThisRun[MAXPLAYERS + 1]; +static float lastDuckValue[MAXPLAYERS + 1]; +static float lastStaminaValue[MAXPLAYERS + 1]; + + + +// =====[ PUBLIC ]===== + +bool GetPaused(int client) +{ + return paused[client]; +} + +void SetPausedOnLadder(int client, bool onLadder) +{ + pausedOnLadder[client] = onLadder; +} + +void Pause(int client) +{ + if (!CanPause(client, true)) + { + return; + } + + // Call Pre Forward + Action result; + Call_GOKZ_OnPause(client, result); + if (result != Plugin_Continue) + { + GOKZ_PrintToChat(client, true, "%t", "Can't Pause (Generic)"); + GOKZ_PlayErrorSound(client); + return; + } + + // Pause + paused[client] = true; + pausedOnLadder[client] = Movement_GetMovetype(client) == MOVETYPE_LADDER; + lastDuckValue[client] = Movement_GetDuckSpeed(client); + lastStaminaValue[client] = GetEntPropFloat(client, Prop_Send, "m_flStamina"); + Movement_SetVelocity(client, view_as<float>( { 0.0, 0.0, 0.0 } )); + Movement_SetMovetype(client, MOVETYPE_NONE); + if (GetTimerRunning(client)) + { + hasPausedInThisRun[client] = true; + lastPauseTime[client] = GetEngineTime(); + } + + // Call Post Forward + Call_GOKZ_OnPause_Post(client); +} + +bool CanPause(int client, bool showError = false) +{ + if (paused[client]) + { + return false; + } + + if (GetTimerRunning(client)) + { + if (hasResumedInThisRun[client] + && GetEngineTime() - lastResumeTime[client] < GOKZ_PAUSE_COOLDOWN) + { + if (showError) + { + GOKZ_PrintToChat(client, true, "%t", "Can't Pause (Just Resumed)"); + GOKZ_PlayErrorSound(client); + } + return false; + } + else if (!Movement_GetOnGround(client) + && !(Movement_GetSpeed(client) == 0 && Movement_GetVerticalVelocity(client) == 0)) + { + if (showError) + { + GOKZ_PrintToChat(client, true, "%t", "Can't Pause (Midair)"); + GOKZ_PlayErrorSound(client); + } + return false; + } + else if (BhopTriggersJustTouched(client)) + { + if (showError) + { + GOKZ_PrintToChat(client, true, "%t", "Can't Pause (Just Landed)"); + GOKZ_PlayErrorSound(client); + } + return false; + } + else if (AntiPauseTriggerIsTouched(client)) + { + if (showError) + { + GOKZ_PrintToChat(client, true, "%t", "Can't Pause (Anti Pause Area)"); + GOKZ_PlayErrorSound(client); + } + return false; + } + } + + return true; +} + +void Resume(int client, bool force = false) +{ + if (!paused[client]) + { + return; + } + if (!force && !CanResume(client, true)) + { + return; + } + + // Call Pre Forward + Action result; + Call_GOKZ_OnResume(client, result); + if (result != Plugin_Continue) + { + GOKZ_PrintToChat(client, true, "%t", "Can't Resume (Generic)"); + GOKZ_PlayErrorSound(client); + return; + } + + // Resume + if (pausedOnLadder[client]) + { + Movement_SetMovetype(client, MOVETYPE_LADDER); + } + else + { + Movement_SetMovetype(client, MOVETYPE_WALK); + } + + // Prevent noclip exploit + SetEntProp(client, Prop_Send, "m_CollisionGroup", GOKZ_COLLISION_GROUP_STANDARD); + paused[client] = false; + if (GetTimerRunning(client)) + { + hasResumedInThisRun[client] = true; + lastResumeTime[client] = GetEngineTime(); + } + Movement_SetDuckSpeed(client, lastDuckValue[client]); + SetEntPropFloat(client, Prop_Send, "m_flStamina", lastStaminaValue[client]); + + // Call Post Forward + Call_GOKZ_OnResume_Post(client); +} + +bool CanResume(int client, bool showError = false) +{ + if (GetTimerRunning(client) && hasPausedInThisRun[client] + && GetEngineTime() - lastPauseTime[client] < GOKZ_PAUSE_COOLDOWN) + { + if (showError) + { + GOKZ_PrintToChat(client, true, "%t", "Can't Resume (Just Paused)"); + GOKZ_PlayErrorSound(client); + } + return false; + } + return true; +} + +void TogglePause(int client) +{ + if (paused[client]) + { + Resume(client); + } + else + { + Pause(client); + } +} + + + +// =====[ EVENTS ]===== + +void OnClientPutInServer_Pause(int client) +{ + paused[client] = false; +} + +void OnTimerStart_Pause(int client) +{ + hasPausedInThisRun[client] = false; + hasResumedInThisRun[client] = false; + Resume(client, true); +} + +void OnChangeMovetype_Pause(int client, MoveType newMovetype) +{ + // Check if player has escaped MOVETYPE_NONE + if (!paused[client] || newMovetype == MOVETYPE_NONE) + { + return; + } + + // Player has escaped MOVETYPE_NONE, so resume + paused[client] = false; + if (GetTimerRunning(client)) + { + hasResumedInThisRun[client] = true; + lastResumeTime[client] = GetEngineTime(); + } + + // Call Post Forward + Call_GOKZ_OnResume_Post(client); +} + +void OnPlayerSpawn_Pause(int client) +{ + if (!paused[client]) + { + return; + } + + // Player has left paused state by spawning in, so resume + paused[client] = false; + if (GetTimerRunning(client)) + { + hasResumedInThisRun[client] = true; + lastResumeTime[client] = GetEngineTime(); + } + + Movement_SetDuckSpeed(client, lastDuckValue[client]); + SetEntPropFloat(client, Prop_Send, "m_flStamina", lastStaminaValue[client]); + + // Call Post Forward + Call_GOKZ_OnResume_Post(client); +} + +void OnJoinTeam_Pause(int client, int team) +{ + // Only handle joining spectators. Joining other teams is handled by OnPlayerSpawn. + if (team == CS_TEAM_SPECTATOR) + { + paused[client] = true; + + if (GetTimerRunning(client)) + { + hasPausedInThisRun[client] = true; + lastPauseTime[client] = GetEngineTime(); + } + + // Call Post Forward + Call_GOKZ_OnPause_Post(client); + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-core/timer/timer.sp b/sourcemod/scripting/gokz-core/timer/timer.sp new file mode 100644 index 0000000..f6696ac --- /dev/null +++ b/sourcemod/scripting/gokz-core/timer/timer.sp @@ -0,0 +1,368 @@ +static bool timerRunning[MAXPLAYERS + 1]; +static float currentTime[MAXPLAYERS + 1]; +static int currentCourse[MAXPLAYERS + 1]; +static float lastEndTime[MAXPLAYERS + 1]; +static float lastFalseEndTime[MAXPLAYERS + 1]; +static float lastStartSoundTime[MAXPLAYERS + 1]; +static int lastStartMode[MAXPLAYERS + 1]; +static bool validTime[MAXPLAYERS + 1]; + + +// =====[ PUBLIC ]===== + +bool GetTimerRunning(int client) +{ + return timerRunning[client]; +} + +bool GetValidTimer(int client) +{ + return validTime[client]; +} + +float GetCurrentTime(int client) +{ + return currentTime[client]; +} + +void SetCurrentTime(int client, float time) +{ + currentTime[client] = time; + // The timer should be running if time is not negative. + timerRunning[client] = time >= 0.0; +} + +int GetCurrentCourse(int client) +{ + return currentCourse[client]; +} + +void SetCurrentCourse(int client, int course) +{ + currentCourse[client] = course; +} + +int GetCurrentTimeType(int client) +{ + if (GetTeleportCount(client) == 0) + { + return TimeType_Pro; + } + return TimeType_Nub; +} + +bool TimerStart(int client, int course, bool allowMidair = false, bool playSound = true) +{ + if (!IsPlayerAlive(client) + || JustStartedTimer(client) + || JustTeleported(client) + || JustNoclipped(client) + || !IsPlayerValidMoveType(client) + || !allowMidair && (!Movement_GetOnGround(client) || JustLanded(client)) + || allowMidair && !Movement_GetOnGround(client) && (!GOKZ_GetValidJump(client) || GOKZ_GetHitPerf(client)) + || (GOKZ_GetTimerRunning(client) && GOKZ_GetCourse(client) != course)) + { + return false; + } + + // Call Pre Forward + Action result; + Call_GOKZ_OnTimerStart(client, course, result); + if (result != Plugin_Continue) + { + return false; + } + + // Prevent noclip exploit + SetEntProp(client, Prop_Send, "m_CollisionGroup", GOKZ_COLLISION_GROUP_STANDARD); + + // Start Timer + currentTime[client] = 0.0; + timerRunning[client] = true; + currentCourse[client] = course; + lastStartMode[client] = GOKZ_GetCoreOption(client, Option_Mode); + validTime[client] = true; + if (playSound) + { + PlayTimerStartSound(client); + } + + // Call Post Forward + Call_GOKZ_OnTimerStart_Post(client, course); + + return true; +} + +bool TimerEnd(int client, int course) +{ + if (!IsPlayerAlive(client)) + { + return false; + } + + if (!timerRunning[client] || course != currentCourse[client]) + { + PlayTimerFalseEndSound(client); + lastFalseEndTime[client] = GetGameTime(); + return false; + } + + float time = GetCurrentTime(client); + int teleportsUsed = GetTeleportCount(client); + + // Call Pre Forward + Action result; + Call_GOKZ_OnTimerEnd(client, course, time, teleportsUsed, result); + if (result != Plugin_Continue) + { + return false; + } + + if (!validTime[client]) + { + PlayTimerFalseEndSound(client); + lastFalseEndTime[client] = GetGameTime(); + TimerStop(client, false); + return false; + } + // End Timer + timerRunning[client] = false; + lastEndTime[client] = GetGameTime(); + PlayTimerEndSound(client); + + if (!IsFakeClient(client)) + { + // Print end timer message + Call_GOKZ_OnTimerEndMessage(client, course, time, teleportsUsed, result); + if (result == Plugin_Continue) + { + PrintEndTimeString(client); + } + } + + // Call Post Forward + Call_GOKZ_OnTimerEnd_Post(client, course, time, teleportsUsed); + + return true; +} + +bool TimerStop(int client, bool playSound = true) +{ + if (!timerRunning[client]) + { + return false; + } + + timerRunning[client] = false; + if (playSound) + { + PlayTimerStopSound(client); + } + + Call_GOKZ_OnTimerStopped(client); + + return true; +} + +void TimerStopAll(bool playSound = true) +{ + for (int client = 1; client <= MaxClients; client++) + { + if (IsValidClient(client)) + { + TimerStop(client, playSound); + } + } +} + +void PlayTimerStartSound(int client) +{ + if (GetGameTime() - lastStartSoundTime[client] > GOKZ_TIMER_SOUND_COOLDOWN) + { + GOKZ_EmitSoundToClient(client, gC_ModeStartSounds[GOKZ_GetCoreOption(client, Option_Mode)], _, "Timer Start"); + GOKZ_EmitSoundToClientSpectators(client, gC_ModeStartSounds[GOKZ_GetCoreOption(client, Option_Mode)], _, "Timer Start"); + lastStartSoundTime[client] = GetGameTime(); + } +} + +void InvalidateRun(int client) +{ + if (validTime[client]) + { + validTime[client] = false; + Call_GOKZ_OnRunInvalidated(client); + } +} + +// =====[ EVENTS ]===== + +void OnClientPutInServer_Timer(int client) +{ + timerRunning[client] = false; + currentTime[client] = 0.0; + currentCourse[client] = 0; + lastEndTime[client] = 0.0; + lastFalseEndTime[client] = 0.0; + lastStartSoundTime[client] = 0.0; + lastStartMode[client] = MODE_COUNT; // So it won't equal any mode +} + +void OnPlayerRunCmdPost_Timer(int client) +{ + if (IsPlayerAlive(client) && GetTimerRunning(client) && !GetPaused(client)) + { + currentTime[client] += GetTickInterval(); + } +} + +void OnChangeMovetype_Timer(int client, MoveType newMovetype) +{ + if (!IsValidMovetype(newMovetype)) + { + if (TimerStop(client)) + { + GOKZ_PrintToChat(client, true, "%t", "Timer Stopped (Noclipped)"); + } + } +} + +void OnTeleportToStart_Timer(int client) +{ + if (GetCurrentMapPrefix() == MapPrefix_KZPro) + { + TimerStop(client, false); + } +} + +void OnClientDisconnect_Timer(int client) +{ + TimerStop(client); +} + +void OnPlayerDeath_Timer(int client) +{ + TimerStop(client); +} + +void OnOptionChanged_Timer(int client, Option option) +{ + if (option == Option_Mode) + { + if (TimerStop(client)) + { + GOKZ_PrintToChat(client, true, "%t", "Timer Stopped (Changed Mode)"); + } + } +} + +void OnRoundStart_Timer() +{ + TimerStopAll(); +} + + + +// =====[ PRIVATE ]===== + +static bool IsPlayerValidMoveType(int client) +{ + return IsValidMovetype(Movement_GetMovetype(client)); +} + +static bool IsValidMovetype(MoveType movetype) +{ + return movetype == MOVETYPE_WALK + || movetype == MOVETYPE_LADDER + || movetype == MOVETYPE_NONE + || movetype == MOVETYPE_OBSERVER; +} + +static bool JustTeleported(int client) +{ + return gB_OriginTeleported[client] || gB_VelocityTeleported[client] + || gI_CmdNum[client] - gI_TeleportCmdNum[client] <= GOKZ_TIMER_START_GROUND_TICKS; +} + +static bool JustLanded(int client) +{ + return !gB_OldOnGround[client] + || gI_CmdNum[client] - Movement_GetLandingCmdNum(client) <= GOKZ_TIMER_START_NO_TELEPORT_TICKS; +} + +static bool JustStartedTimer(int client) +{ + return timerRunning[client] && GetCurrentTime(client) < EPSILON; +} + +static bool JustEndedTimer(int client) +{ + return GetGameTime() - lastEndTime[client] < 1.0; +} + +static void PlayTimerEndSound(int client) +{ + GOKZ_EmitSoundToClient(client, gC_ModeEndSounds[GOKZ_GetCoreOption(client, Option_Mode)], _, "Timer End"); + GOKZ_EmitSoundToClientSpectators(client, gC_ModeEndSounds[GOKZ_GetCoreOption(client, Option_Mode)], _, "Timer End"); +} + +static void PlayTimerFalseEndSound(int client) +{ + if (!JustEndedTimer(client) + && (GetGameTime() - lastFalseEndTime[client]) > GOKZ_TIMER_SOUND_COOLDOWN) + { + GOKZ_EmitSoundToClient(client, gC_ModeFalseEndSounds[GOKZ_GetCoreOption(client, Option_Mode)], _, "Timer False End"); + GOKZ_EmitSoundToClientSpectators(client, gC_ModeFalseEndSounds[GOKZ_GetCoreOption(client, Option_Mode)], _, "Timer False End"); + } +} + +static void PlayTimerStopSound(int client) +{ + GOKZ_EmitSoundToClient(client, GOKZ_SOUND_TIMER_STOP, _, "Timer Stop"); + GOKZ_EmitSoundToClientSpectators(client, GOKZ_SOUND_TIMER_STOP, _, "Timer Stop"); +} + +static void PrintEndTimeString(int client) +{ + if (GetCurrentCourse(client) == 0) + { + switch (GetCurrentTimeType(client)) + { + case TimeType_Nub: + { + GOKZ_PrintToChatAll(true, "%t", "Beat Map (NUB)", + client, + GOKZ_FormatTime(GetCurrentTime(client)), + gC_ModeNamesShort[GOKZ_GetCoreOption(client, Option_Mode)]); + } + case TimeType_Pro: + { + GOKZ_PrintToChatAll(true, "%t", "Beat Map (PRO)", + client, + GOKZ_FormatTime(GetCurrentTime(client)), + gC_ModeNamesShort[GOKZ_GetCoreOption(client, Option_Mode)]); + } + } + } + else + { + switch (GetCurrentTimeType(client)) + { + case TimeType_Nub: + { + GOKZ_PrintToChatAll(true, "%t", "Beat Bonus (NUB)", + client, + currentCourse[client], + GOKZ_FormatTime(GetCurrentTime(client)), + gC_ModeNamesShort[GOKZ_GetCoreOption(client, Option_Mode)]); + } + case TimeType_Pro: + { + GOKZ_PrintToChatAll(true, "%t", "Beat Bonus (PRO)", + client, + currentCourse[client], + GOKZ_FormatTime(GetCurrentTime(client)), + gC_ModeNamesShort[GOKZ_GetCoreOption(client, Option_Mode)]); + } + } + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-core/timer/virtual_buttons.sp b/sourcemod/scripting/gokz-core/timer/virtual_buttons.sp new file mode 100644 index 0000000..aa88a9d --- /dev/null +++ b/sourcemod/scripting/gokz-core/timer/virtual_buttons.sp @@ -0,0 +1,322 @@ +/* + Most commonly referred to in the KZ community as timer tech. + Lets players press 'virtual' start and end buttons without looking. +*/ + + + +static int beamSprite; +static int haloSprite; +static float lastUsePressTime[MAXPLAYERS + 1]; +static int lastTeleportTick[MAXPLAYERS + 1]; +static bool startedTimerLastTick[MAXPLAYERS + 1]; +static bool onlyNaturalButtonPressed[MAXPLAYERS + 1]; +static int startTimerButtonPressTick[MAXPLAYERS + 1]; +static bool hasEndedTimerSincePressingUse[MAXPLAYERS + 1]; +static bool hasTeleportedSincePressingUse[MAXPLAYERS + 1]; +static bool hasVirtualStartButton[MAXPLAYERS + 1]; +static bool hasVirtualEndButton[MAXPLAYERS + 1]; +static bool wasInEndZone[MAXPLAYERS + 1]; +static float virtualStartOrigin[MAXPLAYERS + 1][3]; +static float virtualEndOrigin[MAXPLAYERS + 1][3]; +static int virtualStartCourse[MAXPLAYERS + 1]; +static int virtualEndCourse[MAXPLAYERS + 1]; +static bool virtualButtonsLocked[MAXPLAYERS + 1]; + + + +// =====[ PUBLIC ]===== + +bool GetHasVirtualStartButton(int client) +{ + return hasVirtualStartButton[client]; +} + +bool GetHasVirtualEndButton(int client) +{ + return hasVirtualEndButton[client]; +} + +bool ToggleVirtualButtonsLock(int client) +{ + virtualButtonsLocked[client] = !virtualButtonsLocked[client]; + return virtualButtonsLocked[client]; +} + +void LockVirtualButtons(int client) +{ + virtualButtonsLocked[client] = true; +} + +int GetVirtualButtonPosition(int client, float position[3], bool isStart) +{ + if (isStart && hasVirtualStartButton[client]) + { + position = virtualStartOrigin[client]; + return virtualStartCourse[client]; + } + else if (!isStart && hasVirtualEndButton[client]) + { + position = virtualEndOrigin[client]; + return virtualEndCourse[client]; + } + + return -1; +} + +void SetVirtualButtonPosition(int client, float position[3], int course, bool isStart) +{ + if (isStart) + { + virtualStartCourse[client] = course; + virtualStartOrigin[client] = position; + hasVirtualStartButton[client] = true; + } + else + { + virtualEndCourse[client] = course; + virtualEndOrigin[client] = position; + hasVirtualEndButton[client] = true; + } +} + +void ResetVirtualButtonPosition(int client, bool isStart) +{ + if (isStart) + { + virtualStartCourse[client] = -1; + virtualStartOrigin[client] = {0.0, 0.0, 0.0}; + hasVirtualStartButton[client] = false; + } + else + { + virtualEndCourse[client] = -1; + virtualEndOrigin[client] = {0.0, 0.0, 0.0}; + hasVirtualEndButton[client] = false; + } +} + +// =====[ EVENTS ]===== + +void OnMapStart_VirtualButtons() +{ + beamSprite = PrecacheModel("materials/sprites/laserbeam.vmt"); + haloSprite = PrecacheModel("materials/sprites/glow01.vmt"); +} + +void OnClientPutInServer_VirtualButtons(int client) +{ + startedTimerLastTick[client] = false; + hasVirtualEndButton[client] = false; + hasVirtualStartButton[client] = false; + virtualButtonsLocked[client] = false; + onlyNaturalButtonPressed[client] = false; + wasInEndZone[client] = false; + startTimerButtonPressTick[client] = 0; +} + +void OnStartButtonPress_VirtualButtons(int client, int course) +{ + if (!virtualButtonsLocked[client] && + lastTeleportTick[client] + GOKZ_TIMER_START_NO_TELEPORT_TICKS < GetGameTickCount()) + { + Movement_GetOrigin(client, virtualStartOrigin[client]); + virtualStartCourse[client] = course; + hasVirtualStartButton[client] = true; + startTimerButtonPressTick[client] = GetGameTickCount(); + } +} + +void OnEndButtonPress_VirtualButtons(int client, int course) +{ + // Prevent setting end virtual button to where it would usually be unreachable + if (IsPlayerStuck(client)) + { + return; + } + + if (!virtualButtonsLocked[client] && + lastTeleportTick[client] + GOKZ_TIMER_START_NO_TELEPORT_TICKS < GetGameTickCount()) + { + Movement_GetOrigin(client, virtualEndOrigin[client]); + virtualEndCourse[client] = course; + hasVirtualEndButton[client] = true; + } +} + +void OnPlayerRunCmdPost_VirtualButtons(int client, int buttons, int cmdnum) +{ + CheckForAndHandleUsage(client, buttons); + UpdateIndicators(client, cmdnum); +} + +void OnCountedTeleport_VirtualButtons(int client) +{ + hasTeleportedSincePressingUse[client] = true; +} + +void OnTeleport_DelayVirtualButtons(int client) +{ + lastTeleportTick[client] = GetGameTickCount(); +} + + + +// =====[ PRIVATE ]===== + +static void CheckForAndHandleUsage(int client, int buttons) +{ + if (buttons & IN_USE && !(gI_OldButtons[client] & IN_USE)) + { + lastUsePressTime[client] = GetGameTime(); + hasEndedTimerSincePressingUse[client] = false; + hasTeleportedSincePressingUse[client] = false; + onlyNaturalButtonPressed[client] = startTimerButtonPressTick[client] == GetGameTickCount(); + } + + bool useCheck = PassesUseCheck(client); + + // Start button + if ((useCheck || GOKZ_GetCoreOption(client, Option_TimerButtonZoneType) == TimerButtonZoneType_BothZones) + && GetHasVirtualStartButton(client) && InRangeOfVirtualStart(client) && CanReachVirtualStart(client)) + { + if (TimerStart(client, virtualStartCourse[client], .playSound = false)) + { + startedTimerLastTick[client] = true; + OnVirtualStartButtonPress_Teleports(client); + } + } + else if (startedTimerLastTick[client]) + { + // Without that check you get two sounds when pressing the natural timer button + if (!onlyNaturalButtonPressed[client]) + { + PlayTimerStartSound(client); + } + onlyNaturalButtonPressed[client] = false; + startedTimerLastTick[client] = false; + } + + // End button + if ((useCheck || GOKZ_GetCoreOption(client, Option_TimerButtonZoneType) != TimerButtonZoneType_BothButtons) + && GetHasVirtualEndButton(client) && InRangeOfVirtualEnd(client) && CanReachVirtualEnd(client)) + { + if (!wasInEndZone[client]) + { + TimerEnd(client, virtualEndCourse[client]); + hasEndedTimerSincePressingUse[client] = true; // False end counts as well + wasInEndZone[client] = true; + } + } + else + { + wasInEndZone[client] = false; + } +} + +static bool PassesUseCheck(int client) +{ + if (GetGameTime() - lastUsePressTime[client] < GOKZ_VIRTUAL_BUTTON_USE_DETECTION_TIME + EPSILON + && !hasEndedTimerSincePressingUse[client] + && !hasTeleportedSincePressingUse[client]) + { + return true; + } + + return false; +} + +bool InRangeOfVirtualStart(int client) +{ + return InRangeOfButton(client, virtualStartOrigin[client]); +} + +static bool InRangeOfVirtualEnd(int client) +{ + return InRangeOfButton(client, virtualEndOrigin[client]); +} + +static bool InRangeOfButton(int client, const float buttonOrigin[3]) +{ + float origin[3]; + Movement_GetOrigin(client, origin); + float distanceToButton = GetVectorDistance(origin, buttonOrigin); + return distanceToButton <= gF_ModeVirtualButtonRanges[GOKZ_GetCoreOption(client, Option_Mode)]; +} + +bool CanReachVirtualStart(int client) +{ + return CanReachButton(client, virtualStartOrigin[client]); +} + +static bool CanReachVirtualEnd(int client) +{ + return CanReachButton(client, virtualEndOrigin[client]); +} + +static bool CanReachButton(int client, const float buttonOrigin[3]) +{ + float origin[3]; + Movement_GetOrigin(client, origin); + Handle trace = TR_TraceRayFilterEx(origin, buttonOrigin, MASK_PLAYERSOLID, RayType_EndPoint, TraceEntityFilterPlayers); + bool didHit = TR_DidHit(trace); + delete trace; + return !didHit; +} + + + +// ===== [ INDICATOR ] ===== + +static void UpdateIndicators(int client, int cmdnum) +{ + if (cmdnum % 128 != 0 || !IsPlayerAlive(client) + || GOKZ_GetCoreOption(client, Option_VirtualButtonIndicators) == VirtualButtonIndicators_Disabled) + { + return; + } + + if (hasVirtualStartButton[client]) + { + DrawIndicator(client, virtualStartOrigin[client], { 0, 255, 0, 255 } ); + } + + if (hasVirtualEndButton[client]) + { + DrawIndicator(client, virtualEndOrigin[client], { 255, 0, 0, 255 } ); + } +} + +static void DrawIndicator(int client, const float origin[3], const int colour[4]) +{ + float radius = gF_ModeVirtualButtonRanges[GOKZ_GetCoreOption(client, Option_Mode)]; + if (radius <= EPSILON) // Don't draw circle of radius 0 + { + return; + } + + float x, y, start[3], end[3]; + + // Create the start position for the first part of the beam + start[0] = origin[0] + radius; + start[1] = origin[1]; + start[2] = origin[2]; + + for (int i = 1; i <= 31; i++) // Circle is broken into 31 segments + { + float angle = 2 * PI / 31 * i; + x = radius * Cosine(angle); + y = radius * Sine(angle); + + end[0] = origin[0] + x; + end[1] = origin[1] + y; + end[2] = origin[2]; + + TE_SetupBeamPoints(start, end, beamSprite, haloSprite, 0, 0, 0.97, 0.2, 0.2, 0, 0.0, colour, 0); + TE_SendToClient(client); + + start[0] = end[0]; + start[1] = end[1]; + start[2] = end[2]; + } +} diff --git a/sourcemod/scripting/gokz-core/triggerfix.sp b/sourcemod/scripting/gokz-core/triggerfix.sp new file mode 100644 index 0000000..424928d --- /dev/null +++ b/sourcemod/scripting/gokz-core/triggerfix.sp @@ -0,0 +1,622 @@ + + +// Credits: +// RNGFix made by rio https://github.com/jason-e/rngfix + + +// Engine constants, NOT settings (do not change) +#define LAND_HEIGHT 2.0 // Maximum height above ground at which you can "land" +#define MIN_STANDABLE_ZNRM 0.7 // Minimum surface normal Z component of a walkable surface + +static int processMovementTicks[MAXPLAYERS+1]; +static float playerFrameTime[MAXPLAYERS+1]; + +static bool touchingTrigger[MAXPLAYERS+1][2048]; +static int triggerTouchFired[MAXPLAYERS+1][2048]; +static int lastGroundEnt[MAXPLAYERS + 1]; +static bool duckedLastTick[MAXPLAYERS + 1]; +static bool mapTeleportedSequentialTicks[MAXPLAYERS+1]; +static bool jumpBugged[MAXPLAYERS + 1]; +static float jumpBugOrigin[MAXPLAYERS + 1][3]; + +static ConVar cvGravity; + +static Handle acceptInputHookPre; +static Handle processMovementHookPre; +static Address serverGameEnts; +static Handle markEntitiesAsTouching; +static Handle passesTriggerFilters; + +public void OnPluginStart_Triggerfix() +{ + HookEvent("player_jump", Event_PlayerJump); + + cvGravity = FindConVar("sv_gravity"); + if (cvGravity == null) + { + SetFailState("Could not find sv_gravity"); + } + + GameData gamedataConf = LoadGameConfigFile("gokz-core.games"); + if (gamedataConf == null) + { + SetFailState("Failed to load gokz-core gamedata"); + } + + // PassesTriggerFilters + StartPrepSDKCall(SDKCall_Entity); + if (!PrepSDKCall_SetFromConf(gamedataConf, SDKConf_Virtual, "CBaseTrigger::PassesTriggerFilters")) + { + SetFailState("Failed to get CBaseTrigger::PassesTriggerFilters offset"); + } + PrepSDKCall_SetReturnInfo(SDKType_Bool, SDKPass_Plain); + PrepSDKCall_AddParameter(SDKType_CBaseEntity, SDKPass_Pointer); + passesTriggerFilters = EndPrepSDKCall(); + + if (passesTriggerFilters == null) SetFailState("Unable to prepare SDKCall for CBaseTrigger::PassesTriggerFilters"); + + // CreateInterface + // Thanks SlidyBat and ici + StartPrepSDKCall(SDKCall_Static); + if (!PrepSDKCall_SetFromConf(gamedataConf, SDKConf_Signature, "CreateInterface")) + { + SetFailState("Failed to get CreateInterface"); + } + PrepSDKCall_AddParameter(SDKType_String, SDKPass_Pointer); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Pointer, VDECODE_FLAG_ALLOWNULL); + PrepSDKCall_SetReturnInfo(SDKType_PlainOldData, SDKPass_Plain); + Handle CreateInterface = EndPrepSDKCall(); + + if (CreateInterface == null) + { + SetFailState("Unable to prepare SDKCall for CreateInterface"); + } + + char interfaceName[64]; + + // ProcessMovement + if (!GameConfGetKeyValue(gamedataConf, "IGameMovement", interfaceName, sizeof(interfaceName))) + { + SetFailState("Failed to get IGameMovement interface name"); + } + Address IGameMovement = SDKCall(CreateInterface, interfaceName, 0); + if (!IGameMovement) + { + SetFailState("Failed to get IGameMovement pointer"); + } + + int offset = GameConfGetOffset(gamedataConf, "ProcessMovement"); + if (offset == -1) + { + SetFailState("Failed to get ProcessMovement offset"); + } + + processMovementHookPre = DHookCreate(offset, HookType_Raw, ReturnType_Void, ThisPointer_Ignore, DHook_ProcessMovementPre); + DHookAddParam(processMovementHookPre, HookParamType_CBaseEntity); + DHookAddParam(processMovementHookPre, HookParamType_ObjectPtr); + DHookRaw(processMovementHookPre, false, IGameMovement); + + // MarkEntitiesAsTouching + if (!GameConfGetKeyValue(gamedataConf, "IServerGameEnts", interfaceName, sizeof(interfaceName))) + { + SetFailState("Failed to get IServerGameEnts interface name"); + } + serverGameEnts = SDKCall(CreateInterface, interfaceName, 0); + if (!serverGameEnts) + { + SetFailState("Failed to get IServerGameEnts pointer"); + } + + StartPrepSDKCall(SDKCall_Raw); + if (!PrepSDKCall_SetFromConf(gamedataConf, SDKConf_Virtual, "IServerGameEnts::MarkEntitiesAsTouching")) + { + SetFailState("Failed to get IServerGameEnts::MarkEntitiesAsTouching offset"); + } + PrepSDKCall_AddParameter(SDKType_Edict, SDKPass_Pointer); + PrepSDKCall_AddParameter(SDKType_Edict, SDKPass_Pointer); + markEntitiesAsTouching = EndPrepSDKCall(); + + if (markEntitiesAsTouching == null) + { + SetFailState("Unable to prepare SDKCall for IServerGameEnts::MarkEntitiesAsTouching"); + } + + gamedataConf = LoadGameConfigFile("sdktools.games/engine.csgo"); + offset = gamedataConf.GetOffset("AcceptInput"); + if (offset == -1) + { + SetFailState("Failed to get AcceptInput offset"); + } + + acceptInputHookPre = DHookCreate(offset, HookType_Entity, ReturnType_Bool, ThisPointer_CBaseEntity, DHooks_AcceptInput); + DHookAddParam(acceptInputHookPre, HookParamType_CharPtr); + DHookAddParam(acceptInputHookPre, HookParamType_CBaseEntity); + DHookAddParam(acceptInputHookPre, HookParamType_CBaseEntity); + //varaint_t is a union of 12 (float[3]) plus two int type params 12 + 8 = 20 + DHookAddParam(acceptInputHookPre, HookParamType_Object, 20, DHookPass_ByVal|DHookPass_ODTOR|DHookPass_OCTOR|DHookPass_OASSIGNOP); + DHookAddParam(acceptInputHookPre, HookParamType_Int); + + delete CreateInterface; + delete gamedataConf; + + if (gB_LateLoad) + { + for (int client = 1; client <= MaxClients; client++) + { + if (IsClientInGame(client)) OnClientPutInServer(client); + } + + char classname[64]; + for (int entity = MaxClients+1; entity < sizeof(touchingTrigger[]); entity++) + { + if (!IsValidEntity(entity)) continue; + GetEntPropString(entity, Prop_Data, "m_iClassname", classname, sizeof(classname)); + HookTrigger(entity, classname); + } + } +} + +public void OnEntityCreated_Triggerfix(int entity, const char[] classname) +{ + if (entity >= sizeof(touchingTrigger[])) + { + return; + } + HookTrigger(entity, classname); +} + +public void OnClientConnected_Triggerfix(int client) +{ + processMovementTicks[client] = 0; + for (int i = 0; i < sizeof(touchingTrigger[]); i++) + { + touchingTrigger[client][i] = false; + triggerTouchFired[client][i] = 0; + } +} + +public void OnClientPutInServer_Triggerfix(int client) +{ + SDKHook(client, SDKHook_PostThink, Hook_PlayerPostThink); + DHookEntity(acceptInputHookPre, false, client); +} + +public void OnGameFrame_Triggerfix() +{ + // Loop through all the players and make sure that triggers that are supposed to be fired but weren't now + // get fired properly. + // This must be run OUTSIDE of usercmd, because sometimes usercmd gets delayed heavily. + for (int client = 1; client <= MaxClients; client++) + { + if (IsValidClient(client) && IsPlayerAlive(client) && !CheckWater(client) && + (GetEntityMoveType(client) == MOVETYPE_WALK || GetEntityMoveType(client) == MOVETYPE_LADDER)) + { + DoTriggerFix(client); + + // Reset the Touch tracking. + // We save a bit of performance by putting this inside the loop + // Even if triggerTouchFired is not correct, touchingTrigger still is. + // That should prevent DoTriggerFix from activating the wrong triggers. + // Plus, players respawn where they previously are as well with a timer on, + // so this should not be a big problem. + for (int trigger = 0; trigger < sizeof(triggerTouchFired[]); trigger++) + { + triggerTouchFired[client][trigger] = 0; + } + } + } +} + +void OnPlayerRunCmd_Triggerfix(int client) +{ + // Reset the Touch tracking. + // While this is mostly unnecessary, it can also happen that the server runs multiple ticks of player movement at once, + // therefore the triggers need to be checked again. + for (int trigger = 0; trigger < sizeof(triggerTouchFired[]); trigger++) + { + triggerTouchFired[client][trigger] = 0; + } +} + +static void Event_PlayerJump(Event event, const char[] name, bool dontBroadcast) +{ + int client = GetClientOfUserId(event.GetInt("userid")); + + jumpBugged[client] = !!lastGroundEnt[client]; + if (jumpBugged[client]) + { + GetClientAbsOrigin(client, jumpBugOrigin[client]); + // if player's origin is still in the ducking position then adjust for that. + if (duckedLastTick[client] && !Movement_GetDucking(client)) + { + jumpBugOrigin[client][2] -= 9.0; + } + } +} + +static Action Hook_TriggerStartTouch(int entity, int other) +{ + if (1 <= other <= MaxClients) + { + touchingTrigger[other][entity] = true; + } + + return Plugin_Continue; +} + +static Action Hook_TriggerEndTouch(int entity, int other) +{ + if (1 <= other <= MaxClients) + { + touchingTrigger[other][entity] = false; + } + return Plugin_Continue; +} + +static Action Hook_TriggerTouch(int entity, int other) +{ + if (1 <= other <= MaxClients) + { + triggerTouchFired[other][entity]++; + } + return Plugin_Continue; +} + +static MRESReturn DHook_ProcessMovementPre(Handle hParams) +{ + int client = DHookGetParam(hParams, 1); + + processMovementTicks[client]++; + playerFrameTime[client] = GetTickInterval() * GetEntPropFloat(client, Prop_Data, "m_flLaggedMovementValue"); + mapTeleportedSequentialTicks[client] = false; + + if (IsPlayerAlive(client)) + { + if (GetEntityMoveType(client) == MOVETYPE_WALK + && !CheckWater(client)) + { + lastGroundEnt[client] = GetEntPropEnt(client, Prop_Data, "m_hGroundEntity"); + } + duckedLastTick[client] = Movement_GetDucking(client); + } + + return MRES_Ignored; +} + +static MRESReturn DHooks_AcceptInput(int client, DHookReturn hReturn, DHookParam hParams) +{ + if (!IsValidClient(client) || !IsPlayerAlive(client) || CheckWater(client) || + (GetEntityMoveType(client) != MOVETYPE_WALK && GetEntityMoveType(client) != MOVETYPE_LADDER)) + { + return MRES_Ignored; + } + + // Get args + static char param[64]; + static char command[64]; + DHookGetParamString(hParams, 1, command, sizeof(command)); + if (StrEqual(command, "AddOutput")) + { + DHookGetParamObjectPtrString(hParams, 4, 0, ObjectValueType_String, param, sizeof(param)); + char kv[16]; + SplitString(param, " ", kv, sizeof(kv)); + // KVs are case insensitive. + // Any of these inputs can change the filter behavior. + if (StrEqual(kv[0], "targetname", false) || StrEqual(kv[0], "teamnumber", false) || StrEqual(kv[0], "classname", false) || StrEqual(command, "ResponseContext", false)) + { + DoTriggerFix(client, true); + } + } + else if (StrEqual(command, "AddContext") || StrEqual(command, "RemoveContext") || StrEqual(command, "ClearContext")) + { + DoTriggerFix(client, true); + } + return MRES_Ignored; +} + +static bool DoTriggerFix(int client, bool filterFix = false) +{ + // Adapted from DoTriggerjumpFix right below. + float landingMins[3], landingMaxs[3]; + float origin[3]; + + GetEntPropVector(client, Prop_Data, "m_vecAbsOrigin", origin); + GetEntPropVector(client, Prop_Data, "m_vecMins", landingMins); + GetEntPropVector(client, Prop_Data, "m_vecMaxs", landingMaxs); + + ArrayList triggers = new ArrayList(); + // Get a list of triggers that we are touching now. + + TR_EnumerateEntitiesHull(origin, origin, landingMins, landingMaxs, true, AddTrigger, triggers); + + bool didSomething = false; + + for (int i = 0; i < triggers.Length; i++) + { + int trigger = triggers.Get(i); + if (!touchingTrigger[client][trigger]) + { + // Normally this wouldn't happen, because the trigger should be colliding with the player's hull if it gets here. + continue; + } + char className[64]; + GetEntityClassname(trigger, className, sizeof(className)); + if (StrEqual(className, "trigger_push")) + { + // Completely ignore push triggers. + continue; + } + if (filterFix && SDKCall(passesTriggerFilters, trigger, client) && triggerTouchFired[client][trigger] < GOKZ_MAX_RETOUCH_TRIGGER_COUNT) + { + // MarkEntitiesAsTouching always fires the Touch function even if it was already fired this tick. + SDKCall(markEntitiesAsTouching, serverGameEnts, client, trigger); + + // Player properties might be changed right after this so it will need to be triggered again. + // Triggers changing this filter will loop onto itself infintely so we need to avoid that. + triggerTouchFired[client][trigger]++; + didSomething = true; + } + else if (!triggerTouchFired[client][trigger]) + { + // If the player is still touching the trigger on this tick, and Touch was not called for whatever reason + // in the last tick, we make sure that it is called now. + SDKCall(markEntitiesAsTouching, serverGameEnts, client, trigger); + triggerTouchFired[client][trigger]++; + didSomething = true; + } + } + + delete triggers; + + return didSomething; +} + +static bool DoTriggerjumpFix(int client, const float landingPoint[3], const float landingMins[3], const float landingMaxs[3]) +{ + // It's possible to land above a trigger but also in another trigger_teleport, have the teleport move you to + // another location, and then the trigger jumping fix wouldn't fire the other trigger you technically landed above, + // but I can't imagine a mapper would ever actually stack triggers like that. + + float origin[3]; + GetEntPropVector(client, Prop_Data, "m_vecAbsOrigin", origin); + + float landingMaxsBelow[3]; + landingMaxsBelow[0] = landingMaxs[0]; + landingMaxsBelow[1] = landingMaxs[1]; + landingMaxsBelow[2] = origin[2] - landingPoint[2]; + + ArrayList triggers = new ArrayList(); + + // Find triggers that are between us and the ground (using the bounding box quadrant we landed with if applicable). + // This will fail on triggers thinner than 0.03125 unit thick, but it's highly unlikely that a mapper would put a trigger that thin. + TR_EnumerateEntitiesHull(landingPoint, landingPoint, landingMins, landingMaxsBelow, true, AddTrigger, triggers); + + bool didSomething = false; + + for (int i = 0; i < triggers.Length; i++) + { + int trigger = triggers.Get(i); + + // MarkEntitiesAsTouching always fires the Touch function even if it was already fired this tick. + // In case that could cause side-effects, manually keep track of triggers we are actually touching + // and don't re-touch them. + if (touchingTrigger[client][trigger]) + { + continue; + } + + SDKCall(markEntitiesAsTouching, serverGameEnts, client, trigger); + didSomething = true; + } + + delete triggers; + + return didSomething; +} + +// PostThink works a little better than a ProcessMovement post hook because we need to wait for ProcessImpacts (trigger activation) +static void Hook_PlayerPostThink(int client) +{ + if (!IsPlayerAlive(client) + || GetEntityMoveType(client) != MOVETYPE_WALK + || CheckWater(client)) + { + return; + } + + bool landed = (GetEntPropEnt(client, Prop_Data, "m_hGroundEntity") != -1 + && lastGroundEnt[client] == -1) + || jumpBugged[client]; + + float landingMins[3], landingMaxs[3], landingPoint[3]; + + // Get info about the ground we landed on (if we need to do landing fixes). + if (landed) + { + float origin[3], nrm[3], velocity[3]; + GetEntPropVector(client, Prop_Data, "m_vecAbsOrigin", origin); + GetEntPropVector(client, Prop_Data, "m_vecVelocity", velocity); + + if (jumpBugged[client]) + { + origin = jumpBugOrigin[client]; + } + + GetEntPropVector(client, Prop_Data, "m_vecMins", landingMins); + GetEntPropVector(client, Prop_Data, "m_vecMaxs", landingMaxs); + + float originBelow[3]; + originBelow[0] = origin[0]; + originBelow[1] = origin[1]; + originBelow[2] = origin[2] - LAND_HEIGHT; + + TR_TraceHullFilter(origin, originBelow, landingMins, landingMaxs, MASK_PLAYERSOLID, PlayerFilter); + + if (!TR_DidHit()) + { + // This should never happen, since we know we are on the ground. + landed = false; + } + else + { + TR_GetPlaneNormal(null, nrm); + + if (nrm[2] < MIN_STANDABLE_ZNRM) + { + // This is rare, and how the incline fix should behave isn't entirely clear because maybe we should + // collide with multiple faces at once in this case, but let's just get the ground we officially + // landed on and use that for our ground normal. + + // landingMins and landingMaxs will contain the final values used to find the ground after returning. + if (TracePlayerBBoxForGround(origin, originBelow, landingMins, landingMaxs)) + { + TR_GetPlaneNormal(null, nrm); + } + else + { + // This should also never happen. + landed = false; + } + } + + TR_GetEndPosition(landingPoint); + } + } + + // reset it here because we don't need it again + jumpBugged[client] = false; + + // Must use TR_DidHit because if the unduck origin is closer than 0.03125 units from the ground, + // the trace fraction would return 0.0. + if (landed && TR_DidHit()) + { + DoTriggerjumpFix(client, landingPoint, landingMins, landingMaxs); + // Check if a trigger we just touched put us in the air (probably due to a teleport). + if (GetEntityFlags(client) & FL_ONGROUND == 0) + { + landed = false; + } + } +} + +static bool PlayerFilter(int entity, int mask) +{ + return !(1 <= entity <= MaxClients); +} + +static void HookTrigger(int entity, const char[] classname) +{ + if (StrContains(classname, "trigger_") != -1) + { + SDKHook(entity, SDKHook_StartTouchPost, Hook_TriggerStartTouch); + SDKHook(entity, SDKHook_EndTouchPost, Hook_TriggerEndTouch); + SDKHook(entity, SDKHook_TouchPost, Hook_TriggerTouch); + } +} + +static bool CheckWater(int client) +{ + // The cached water level is updated multiple times per tick, including after movement happens, + // so we can just check the cached value here. + return GetEntProp(client, Prop_Data, "m_nWaterLevel") > 1; +} + +public bool AddTrigger(int entity, ArrayList triggers) +{ + TR_ClipCurrentRayToEntity(MASK_ALL, entity); + if (TR_DidHit()) + { + triggers.Push(entity); + } + + return true; +} + +static bool TracePlayerBBoxForGround(const float origin[3], const float originBelow[3], float mins[3], float maxs[3]) +{ + // See CGameMovement::TracePlayerBBoxForGround() + + float origMins[3], origMaxs[3]; + origMins = mins; + origMaxs = maxs; + + float nrm[3]; + + mins = origMins; + + // -x -y + maxs[0] = origMaxs[0] > 0.0 ? 0.0 : origMaxs[0]; + maxs[1] = origMaxs[1] > 0.0 ? 0.0 : origMaxs[1]; + maxs[2] = origMaxs[2]; + + TR_TraceHullFilter(origin, originBelow, mins, maxs, MASK_PLAYERSOLID, PlayerFilter); + + if (TR_DidHit()) + { + TR_GetPlaneNormal(null, nrm); + if (nrm[2] >= MIN_STANDABLE_ZNRM) + { + return true; + } + } + + // +x +y + mins[0] = origMins[0] < 0.0 ? 0.0 : origMins[0]; + mins[1] = origMins[1] < 0.0 ? 0.0 : origMins[1]; + mins[2] = origMins[2]; + + maxs = origMaxs; + + TR_TraceHullFilter(origin, originBelow, mins, maxs, MASK_PLAYERSOLID, PlayerFilter); + + if (TR_DidHit()) + { + TR_GetPlaneNormal(null, nrm); + if (nrm[2] >= MIN_STANDABLE_ZNRM) + { + return true; + } + } + + // -x +y + mins[0] = origMins[0]; + mins[1] = origMins[1] < 0.0 ? 0.0 : origMins[1]; + mins[2] = origMins[2]; + + maxs[0] = origMaxs[0] > 0.0 ? 0.0 : origMaxs[0]; + maxs[1] = origMaxs[1]; + maxs[2] = origMaxs[2]; + + TR_TraceHullFilter(origin, originBelow, mins, maxs, MASK_PLAYERSOLID, PlayerFilter); + + if (TR_DidHit()) + { + TR_GetPlaneNormal(null, nrm); + if (nrm[2] >= MIN_STANDABLE_ZNRM) + { + return true; + } + } + + // +x -y + mins[0] = origMins[0] < 0.0 ? 0.0 : origMins[0]; + mins[1] = origMins[1]; + mins[2] = origMins[2]; + + maxs[0] = origMaxs[0]; + maxs[1] = origMaxs[1] > 0.0 ? 0.0 : origMaxs[1]; + maxs[2] = origMaxs[2]; + + TR_TraceHullFilter(origin, originBelow, mins, maxs, MASK_PLAYERSOLID, PlayerFilter); + + if (TR_DidHit()) + { + TR_GetPlaneNormal(null, nrm); + if (nrm[2] >= MIN_STANDABLE_ZNRM) + { + return true; + } + } + + return false; +} diff --git a/sourcemod/scripting/gokz-errorboxfixer.sp b/sourcemod/scripting/gokz-errorboxfixer.sp new file mode 100644 index 0000000..fd3f76a --- /dev/null +++ b/sourcemod/scripting/gokz-errorboxfixer.sp @@ -0,0 +1,89 @@ +#include <sourcemod> +#include <sdktools> + +#include <gokz> + +#undef REQUIRE_PLUGIN +#include <updater> + +#pragma newdecls required +#pragma semicolon 1 + +public Plugin myinfo = +{ + name = "GOKZ KZErrorBoxFixer", + author = "1NutWunDeR", + description = "Adds missing models for KZ maps", + version = GOKZ_VERSION, + url = GOKZ_SOURCE_URL +}; + +#define UPDATER_URL GOKZ_UPDATER_BASE_URL..."gokz-errorboxfixer.txt" + +public void OnAllPluginsLoaded() +{ + if (LibraryExists("updater")) + { + Updater_AddPlugin(UPDATER_URL); + } +} + +public void OnLibraryAdded(const char[] name) +{ + if (StrEqual(name, "updater")) + { + Updater_AddPlugin(UPDATER_URL); + } +} + +public void OnMapStart() +{ + AddFileToDownloadsTable("models/kzmod/buttons/stand_button.vtf"); + AddFileToDownloadsTable("models/kzmod/buttons/stand_button.vmt"); + AddFileToDownloadsTable("models/kzmod/buttons/stand_button_normal.vtf"); + AddFileToDownloadsTable("models/kzmod/buttons/standing_button.mdl"); + AddFileToDownloadsTable("models/kzmod/buttons/standing_button.dx90.vtx"); + AddFileToDownloadsTable("models/kzmod/buttons/standing_button.phy"); + AddFileToDownloadsTable("models/kzmod/buttons/standing_button.vvd"); + AddFileToDownloadsTable("models/kzmod/buttons/stone_button.mdl"); + AddFileToDownloadsTable("models/kzmod/buttons/stone_button.dx90.vtx"); + AddFileToDownloadsTable("models/kzmod/buttons/stone_button.phy"); + AddFileToDownloadsTable("models/kzmod/buttons/stone_button.vvd"); + AddFileToDownloadsTable("models/props_wasteland/pipecluster002a.mdl"); + AddFileToDownloadsTable("models/props_wasteland/pipecluster002a.dx90.vtx"); + AddFileToDownloadsTable("models/props_wasteland/pipecluster002a.phy"); + AddFileToDownloadsTable("models/props_wasteland/pipecluster002a.vvd"); + AddFileToDownloadsTable("materials/kzmod/starttimersign.vmt"); + AddFileToDownloadsTable("materials/kzmod/starttimersign.vtf"); + AddFileToDownloadsTable("materials/kzmod/stoptimersign.vmt"); + AddFileToDownloadsTable("materials/kzmod/stoptimersign.vtf"); + AddFileToDownloadsTable("models/props/switch001.mdl"); + AddFileToDownloadsTable("models/props/switch001.vvd"); + AddFileToDownloadsTable("models/props/switch001.phy"); + AddFileToDownloadsTable("models/props/switch001.vtx"); + AddFileToDownloadsTable("models/props/switch001.dx90.vtx"); + AddFileToDownloadsTable("materials/models/props/switch.vmt"); + AddFileToDownloadsTable("materials/models/props/switch.vtf"); + AddFileToDownloadsTable("materials/models/props/switch001.vmt"); + AddFileToDownloadsTable("materials/models/props/switch001.vtf"); + AddFileToDownloadsTable("materials/models/props/switch001_normal.vmt"); + AddFileToDownloadsTable("materials/models/props/switch001_normal.vtf"); + AddFileToDownloadsTable("materials/models/props/switch001_lightwarp.vmt"); + AddFileToDownloadsTable("materials/models/props/switch001_lightwarp.vtf"); + AddFileToDownloadsTable("materials/models/props/switch001_exponent.vmt"); + AddFileToDownloadsTable("materials/models/props/switch001_exponent.vtf"); + AddFileToDownloadsTable("materials/models/props/startkztimer.vmt"); + AddFileToDownloadsTable("materials/models/props/startkztimer.vtf"); + AddFileToDownloadsTable("materials/models/props/stopkztimer.vmt"); + AddFileToDownloadsTable("materials/models/props/stopkztimer.vtf"); + + PrecacheModel("models/kzmod/buttons/stand_button.vmt", true); + PrecacheModel("models/props_wasteland/pipecluster002a.mdl", true); + PrecacheModel("models/kzmod/buttons/standing_button.mdl", true); + PrecacheModel("models/kzmod/buttons/stone_button.mdl", true); + PrecacheModel("materials/kzmod/starttimersign.vmt", true); + PrecacheModel("materials/kzmod/stoptimersign.vmt", true); + PrecacheModel("models/props/switch001.mdl", true); + PrecacheModel("materials/models/props/startkztimer.vmt", true); + PrecacheModel("materials/models/props/stopkztimer.vmt", true); +} diff --git a/sourcemod/scripting/gokz-global.sp b/sourcemod/scripting/gokz-global.sp new file mode 100644 index 0000000..79f8b6a --- /dev/null +++ b/sourcemod/scripting/gokz-global.sp @@ -0,0 +1,740 @@ +#include <sourcemod> + +#include <sdktools> + +#include <GlobalAPI> +#include <gokz/anticheat> +#include <gokz/core> +#include <gokz/global> +#include <gokz/replays> +#include <gokz/momsurffix> + +#include <autoexecconfig> + +#undef REQUIRE_EXTENSIONS +#undef REQUIRE_PLUGIN +#include <gokz/localdb> +#include <gokz/localranks> +#include <updater> + +#include <gokz/kzplayer> + +#pragma newdecls required +#pragma semicolon 1 + + + +public Plugin myinfo = +{ + name = "GOKZ Global", + author = "DanZay", + description = "Provides centralised records and bans via GlobalAPI", + version = GOKZ_VERSION, + url = GOKZ_SOURCE_URL +}; + +#define UPDATER_URL GOKZ_UPDATER_BASE_URL..."gokz-global.txt" + +bool gB_GOKZLocalDB; + +bool gB_APIKeyCheck; +bool gB_ModeCheck[MODE_COUNT]; +bool gB_BannedCommandsCheck; +char gC_CurrentMap[64]; +int gI_CurrentMapFileSize; +bool gB_InValidRun[MAXPLAYERS + 1]; +bool gB_GloballyVerified[MAXPLAYERS + 1]; +bool gB_EnforcerOnFreshMap; +bool gB_JustLateLoaded; +int gI_FPSMax[MAXPLAYERS + 1]; +bool gB_waitingForFPSKick[MAXPLAYERS + 1]; +bool gB_MapValidated; +int gI_MapID; +int gI_MapFileSize; +int gI_MapTier; + +ConVar gCV_gokz_settings_enforcer; +ConVar gCV_gokz_warn_for_non_global_map; +ConVar gCV_EnforcedCVar[ENFORCEDCVAR_COUNT]; + +#include "gokz-global/api.sp" +#include "gokz-global/ban_player.sp" +#include "gokz-global/commands.sp" +#include "gokz-global/maptop_menu.sp" +#include "gokz-global/print_records.sp" +#include "gokz-global/send_run.sp" +#include "gokz-global/points.sp" + + + +// =====[ PLUGIN EVENTS ]===== + +public APLRes AskPluginLoad2(Handle myself, bool late, char[] error, int err_max) +{ + CreateNatives(); + RegPluginLibrary("gokz-global"); + gB_JustLateLoaded = late; + return APLRes_Success; +} + +public void OnPluginStart() +{ + if (FloatAbs(1.0 / GetTickInterval() - 128.0) > EPSILON) + { + SetFailState("gokz-global currently only supports 128 tickrate servers."); + } + if (FindCommandLineParam("-insecure") || FindCommandLineParam("-tools")) + { + SetFailState("gokz-global currently only supports VAC-secured servers."); + } + LoadTranslations("gokz-common.phrases"); + LoadTranslations("gokz-global.phrases"); + + gB_APIKeyCheck = false; + gB_MapValidated = false; + gI_MapID = -1; + gI_MapFileSize = -1; + gI_MapTier = -1; + + for (int mode = 0; mode < MODE_COUNT; mode++) + { + gB_ModeCheck[mode] = false; + } + + CreateConVars(); + CreateGlobalForwards(); + RegisterCommands(); +} + +public void OnAllPluginsLoaded() +{ + if (LibraryExists("updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + gB_GOKZLocalDB = LibraryExists("gokz-localdb"); + + for (int client = 1; client <= MaxClients; client++) + { + if (IsClientInGame(client)) + { + OnClientPutInServer(client); + } + } +} + +public void OnLibraryAdded(const char[] name) +{ + if (StrEqual(name, "updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + gB_GOKZLocalDB = gB_GOKZLocalDB || StrEqual(name, "gokz-localdb"); +} + +public void OnLibraryRemoved(const char[] name) +{ + gB_GOKZLocalDB = gB_GOKZLocalDB && !StrEqual(name, "gokz-localdb"); +} + +Action IntegrityChecks(Handle timer) +{ + for (int client = 1; client <= MaxClients; client++) + { + if (IsValidClient(client) && !IsFakeClient(client)) + { + QueryClientConVar(client, "fps_max", FPSCheck, client); + QueryClientConVar(client, "m_yaw", MYAWCheck, client); + } + } + + for (int i = 0; i < BANNEDPLUGINCOMMAND_COUNT; i++) + { + if (CommandExists(gC_BannedPluginCommands[i])) + { + Handle bannedIterator = GetPluginIterator(); + char pluginName[128]; + bool foundPlugin = false; + while (MorePlugins(bannedIterator)) + { + Handle bannedPlugin = ReadPlugin(bannedIterator); + GetPluginInfo(bannedPlugin, PlInfo_Name, pluginName, sizeof(pluginName)); + if (StrEqual(pluginName, gC_BannedPlugins[i])) + { + char pluginPath[128]; + GetPluginFilename(bannedPlugin, pluginPath, sizeof(pluginPath)); + ServerCommand("sm plugins unload %s", pluginPath); + char disabledPath[256], enabledPath[256], pluginFile[4][128]; + int subfolders = ExplodeString(pluginPath, "/", pluginFile, sizeof(pluginFile), sizeof(pluginFile[])); + BuildPath(Path_SM, disabledPath, sizeof(disabledPath), "plugins/disabled/%s", pluginFile[subfolders - 1]); + BuildPath(Path_SM, enabledPath, sizeof(enabledPath), "plugins/%s", pluginPath); + RenameFile(disabledPath, enabledPath); + LogError("[KZ] %s cannot be loaded at the same time as gokz-global. %s has been disabled.", pluginName, pluginName); + delete bannedPlugin; + foundPlugin = true; + break; + } + delete bannedPlugin; + } + if (!foundPlugin && gB_BannedCommandsCheck) + { + gB_BannedCommandsCheck = false; + LogError("You can't have a plugin which implements the %s command. Please disable it and reload the map.", gC_BannedPluginCommands[i]); + } + delete bannedIterator; + } + } + + return Plugin_Handled; +} + +public void FPSCheck(QueryCookie cookie, int client, ConVarQueryResult result, const char[] cvarName, const char[] cvarValue, any value) +{ + if (IsValidClient(client) && !IsFakeClient(client)) + { + gI_FPSMax[client] = StringToInt(cvarValue); + if (gI_FPSMax[client] > 0 && gI_FPSMax[client] < GL_FPS_MAX_MIN_VALUE) + { + if (!gB_waitingForFPSKick[client]) + { + gB_waitingForFPSKick[client] = true; + CreateTimer(GL_FPS_MAX_KICK_TIMEOUT, FPSKickPlayer, GetClientUserId(client), TIMER_FLAG_NO_MAPCHANGE); + GOKZ_PrintToChat(client, true, "%t", "Warn Player fps_max"); + if (GOKZ_GetTimerRunning(client)) + { + GOKZ_StopTimer(client, true); + } + else + { + GOKZ_EmitSoundToClient(client, GOKZ_SOUND_TIMER_STOP, _, "Timer Stop"); + } + } + } + else + { + gB_waitingForFPSKick[client] = false; + } + } +} + +public void MYAWCheck(QueryCookie cookie, int client, ConVarQueryResult result, const char[] cvarName, const char[] cvarValue, any value) +{ + if (IsValidClient(client) && !IsFakeClient(client) && StringToFloat(cvarValue) > GL_MYAW_MAX_VALUE) + { + KickClient(client, "%T", "Kick Player m_yaw", client); + } +} + +Action FPSKickPlayer(Handle timer, int userid) +{ + int client = GetClientOfUserId(userid); + if (IsValidClient(client) && !IsFakeClient(client) && gB_waitingForFPSKick[client]) + { + KickClient(client, "%T", "Kick Player fps_max", client); + } + + return Plugin_Handled; +} + + + +// =====[ CLIENT EVENTS ]===== + +public void OnClientPutInServer(int client) +{ + gB_GloballyVerified[client] = false; + gB_waitingForFPSKick[client] = false; + OnClientPutInServer_PrintRecords(client); +} + +// OnClientAuthorized is apparently too early +public void OnClientPostAdminCheck(int client) +{ + ResetPoints(client); + + if (GlobalAPI_IsInit() && !IsFakeClient(client)) + { + CheckClientGlobalBan(client); + UpdatePoints(client); + } +} + +public void GlobalAPI_OnInitialized() +{ + SetupAPI(); +} + + +public Action GOKZ_OnTimerStart(int client, int course) +{ + KZPlayer player = KZPlayer(client); + int mode = player.Mode; + + // We check the timer running to prevent spam when standing inside VB. + if (gCV_gokz_warn_for_non_global_map.BoolValue + && GlobalAPI_HasAPIKey() + && !GlobalsEnabled(mode) + && !GOKZ_GetTimerRunning(client)) + { + GOKZ_PrintToChat(client, true, "%t", "Warn Player Not Global Run"); + } + + return Plugin_Continue; +} + +public void GOKZ_OnTimerStart_Post(int client, int course) +{ + KZPlayer player = KZPlayer(client); + int mode = player.Mode; + gB_InValidRun[client] = GlobalsEnabled(mode); +} + +public void GOKZ_OnTimerEnd_Post(int client, int course, float time, int teleportsUsed) +{ + if (gB_GloballyVerified[client] && gB_InValidRun[client]) + { + SendTime(client, course, time, teleportsUsed); + } +} + +public Action GOKZ_RP_OnReplaySaved(int client, int replayType, const char[] map, int course, int timeType, float time, const char[] filePath, bool tempReplay) +{ + if (gB_GloballyVerified[client] && gB_InValidRun[client]) + { + OnReplaySaved_SendReplay(client, replayType, map, course, timeType, time, filePath, tempReplay); + return Plugin_Handled; + } + return Plugin_Continue; +} + +public void GOKZ_OnRunInvalidated(int client) +{ + gB_InValidRun[client] = false; +} + +public void GOKZ_GL_OnNewTopTime(int client, int course, int mode, int timeType, int rank, int rankOverall, float runTime) +{ + AnnounceNewTopTime(client, course, mode, timeType, rank, rankOverall); +} + +public void GOKZ_AC_OnPlayerSuspected(int client, ACReason reason, const char[] notes, const char[] stats) +{ + if (!gB_GloballyVerified[client]) + { + return; + } + + GlobalBanPlayer(client, reason, notes, stats); + gB_GloballyVerified[client] = false; +} + + + +// =====[ OTHER EVENTS ]===== + +public void OnMapStart() +{ + LoadSounds(); + + GetCurrentMapDisplayName(gC_CurrentMap, sizeof(gC_CurrentMap)); + gI_CurrentMapFileSize = GetCurrentMapFileSize(); + + gB_BannedCommandsCheck = true; + + // Prevent just reloading the plugin after messing with the map + if (gB_JustLateLoaded) + { + gB_JustLateLoaded = false; + } + else + { + gB_EnforcerOnFreshMap = true; + } + + // In case of late loading + if (GlobalAPI_IsInit()) + { + GlobalAPI_OnInitialized(); + } + + // Setup a timer to monitor server/client integrity + CreateTimer(1.0, IntegrityChecks, INVALID_HANDLE, TIMER_FLAG_NO_MAPCHANGE | TIMER_REPEAT); +} + +public void OnMapEnd() +{ + // So it doesn't get carried over to the next map + gI_MapID = -1; + for (int client = 1; client < MaxClients; client++) + { + ResetMapPoints(client); + } +} + +public void GOKZ_OnOptionChanged(int client, const char[] option, any newValue) +{ + if (StrEqual(option, gC_CoreOptionNames[Option_Mode]) + && GlobalAPI_IsInit()) + { + UpdatePoints(client); + } +} + +public void GOKZ_OnModeUnloaded(int mode) +{ + gB_ModeCheck[mode] = false; +} + +public Action GOKZ_OnTimerNativeCalledExternally(Handle plugin, int client) +{ + char pluginName[64]; + GetPluginInfo(plugin, PlInfo_Name, pluginName, sizeof(pluginName)); + if (GOKZ_GetTimerRunning(client) && GOKZ_GetValidTimer(client)) + { + LogMessage("Invalidated %N's run as gokz-core native was called by \"%s\"", client, pluginName); + } + GOKZ_InvalidateRun(client); + return Plugin_Continue; +} + + + +// =====[ PUBLIC ]===== + +bool GlobalsEnabled(int mode) +{ + return gB_APIKeyCheck && gB_BannedCommandsCheck && gCV_gokz_settings_enforcer.BoolValue && gB_EnforcerOnFreshMap && MapCheck() && gB_ModeCheck[mode]; +} + +bool MapCheck() +{ + return gB_MapValidated + && gI_MapID > 0 + && gI_MapFileSize == gI_CurrentMapFileSize; +} + +void PrintGlobalCheckToChat(int client) +{ + GOKZ_PrintToChat(client, true, "%t", "Global Check Header"); + GOKZ_PrintToChat(client, false, "%t", "Global Check", + gB_APIKeyCheck ? "{green}✓" : "{darkred}X", + gB_BannedCommandsCheck ? "{green}✓" : "{darkred}X", + gCV_gokz_settings_enforcer.BoolValue && gB_EnforcerOnFreshMap ? "{green}✓" : "{darkred}X", + MapCheck() ? "{green}✓" : "{darkred}X", + gB_GloballyVerified[client] ? "{green}✓" : "{darkred}X"); + + char modeCheck[256]; + FormatEx(modeCheck, sizeof(modeCheck), "{purple}%s %s", gC_ModeNames[0], gB_ModeCheck[0] ? "{green}✓" : "{darkred}X"); + for (int i = 1; i < MODE_COUNT; i++) + { + FormatEx(modeCheck, sizeof(modeCheck), "%s {grey}| {purple}%s %s", modeCheck, gC_ModeNames[i], gB_ModeCheck[i] ? "{green}✓" : "{darkred}X"); + } + GOKZ_PrintToChat(client, false, "%s", modeCheck); +} + +void AnnounceNewTopTime(int client, int course, int mode, int timeType, int rank, int rankOverall) +{ + bool newRecord = false; + + if (timeType == TimeType_Nub && rankOverall != 0) + { + if (rankOverall == 1) + { + if (course == 0) + { + GOKZ_PrintToChatAll(true, "%t", "New Global Record (NUB)", client, gC_ModeNamesShort[mode]); + } + else + { + GOKZ_PrintToChatAll(true, "%t", "New Global Bonus Record (NUB)", client, course, gC_ModeNamesShort[mode]); + } + newRecord = true; + } + else + { + if (course == 0) + { + GOKZ_PrintToChatAll(true, "%t", "New Global Top Time (NUB)", client, rankOverall, gC_ModeNamesShort[mode]); + } + else + { + GOKZ_PrintToChatAll(true, "%t", "New Global Top Bonus Time (NUB)", client, rankOverall, course, gC_ModeNamesShort[mode]); + } + } + } + else if (timeType == TimeType_Pro) + { + if (rankOverall != 0) + { + if (rankOverall == 1) + { + if (course == 0) + { + GOKZ_PrintToChatAll(true, "%t", "New Global Record (NUB)", client, gC_ModeNamesShort[mode]); + } + else + { + GOKZ_PrintToChatAll(true, "%t", "New Global Bonus Record (NUB)", client, course, gC_ModeNamesShort[mode]); + } + newRecord = true; + } + else + { + if (course == 0) + { + GOKZ_PrintToChatAll(true, "%t", "New Global Top Time (NUB)", client, rankOverall, gC_ModeNamesShort[mode]); + } + else + { + GOKZ_PrintToChatAll(true, "%t", "New Global Top Bonus Time (NUB)", client, rankOverall, course, gC_ModeNamesShort[mode]); + } + } + } + + if (rank == 1) + { + if (course == 0) + { + GOKZ_PrintToChatAll(true, "%t", "New Global Record (PRO)", client, gC_ModeNamesShort[mode]); + } + else + { + GOKZ_PrintToChatAll(true, "%t", "New Global Bonus Record (PRO)", client, course, gC_ModeNamesShort[mode]); + } + newRecord = true; + } + else + { + if (course == 0) + { + GOKZ_PrintToChatAll(true, "%t", "New Global Top Time (PRO)", client, rank, gC_ModeNamesShort[mode]); + } + else + { + GOKZ_PrintToChatAll(true, "%t", "New Global Top Bonus Time (PRO)", client, rank, course, gC_ModeNamesShort[mode]); + } + } + } + + if (newRecord) + { + PlayBeatRecordSound(); + } +} + +void PlayBeatRecordSound() +{ + GOKZ_EmitSoundToAll(GL_SOUND_NEW_RECORD, _, "World Record"); +} + + + +// =====[ PRIVATE ]===== + +static void CreateConVars() +{ + AutoExecConfig_SetFile("gokz-global", "sourcemod/gokz"); + AutoExecConfig_SetCreateFile(true); + + gCV_gokz_settings_enforcer = AutoExecConfig_CreateConVar("gokz_settings_enforcer", "1", "Whether GOKZ enforces convars required for global records.", _, true, 0.0, true, 1.0); + gCV_gokz_warn_for_non_global_map = AutoExecConfig_CreateConVar("gokz_warn_for_non_global_map", "1", "Whether or not GOKZ should warn players if the global check does not pass.", _, true, 0.0, true, 1.0); + gCV_gokz_settings_enforcer.AddChangeHook(OnConVarChanged); + + AutoExecConfig_ExecuteFile(); + AutoExecConfig_CleanFile(); + + for (int i = 0; i < ENFORCEDCVAR_COUNT; i++) + { + gCV_EnforcedCVar[i] = FindConVar(gC_EnforcedCVars[i]); + gCV_EnforcedCVar[i].FloatValue = gF_EnforcedCVarValues[i]; + gCV_EnforcedCVar[i].AddChangeHook(OnEnforcedConVarChanged); + } +} + +public void OnConVarChanged(ConVar convar, const char[] oldValue, const char[] newValue) +{ + if (convar == gCV_gokz_settings_enforcer) + { + if (gCV_gokz_settings_enforcer.BoolValue) + { + for (int i = 0; i < ENFORCEDCVAR_COUNT; i++) + { + gCV_EnforcedCVar[i].FloatValue = gF_EnforcedCVarValues[i]; + } + } + else + { + for (int client = 1; client <= MaxClients; client++) + { + gB_InValidRun[client] = false; + } + + // You have to change map before you can re-activate that + gB_EnforcerOnFreshMap = false; + } + } +} + +public void OnEnforcedConVarChanged(ConVar convar, const char[] oldValue, const char[] newValue) +{ + if (gCV_gokz_settings_enforcer.BoolValue) + { + for (int i = 0; i < ENFORCEDCVAR_COUNT; i++) + { + if (convar == gCV_EnforcedCVar[i]) + { + gCV_EnforcedCVar[i].FloatValue = gF_EnforcedCVarValues[i]; + return; + } + } + } +} + +static void SetupAPI() +{ + GlobalAPI_GetAuthStatus(GetAuthStatusCallback); + GlobalAPI_GetModes(GetModeInfoCallback); + GlobalAPI_GetMapByName(GetMapCallback, _, gC_CurrentMap); + + for (int client = 1; client <= MaxClients; client++) + { + if (IsValidClient(client) && !IsFakeClient(client)) + { + CheckClientGlobalBan(client); + } + } +} + +public int GetAuthStatusCallback(JSON_Object auth_json, GlobalAPIRequestData request) +{ + if (request.Failure) + { + LogError("Failed to check API key with Global API."); + return 0; + } + + APIAuth auth = view_as<APIAuth>(auth_json); + if (!auth.IsValid) + { + LogError("Global API key was found to be missing or invalid."); + } + gB_APIKeyCheck = auth.IsValid; + return 0; +} + +public int GetModeInfoCallback(JSON_Object modes, GlobalAPIRequestData request) +{ + if (request.Failure) + { + LogError("Failed to check mode versions with Global API."); + return 0; + } + + if (!modes.IsArray) + { + LogError("GlobalAPI returned a malformed response while looking up the modes."); + return 0; + } + + for (int i = 0; i < modes.Length; i++) + { + APIMode mode = view_as<APIMode>(modes.GetObjectIndexed(i)); + int mode_id = GOKZ_GL_FromGlobalMode(view_as<GlobalMode>(mode.Id)); + if (mode_id == -1) + { + LogError("GlobalAPI returned a malformed mode."); + } + else if (mode.LatestVersion <= GOKZ_GetModeVersion(mode_id)) + { + gB_ModeCheck[mode_id] = true; + } + else + { + char desc[128]; + + gB_ModeCheck[mode_id] = false; + mode.GetLatestVersionDesc(desc, sizeof(desc)); + LogError("Global API requires %s mode version %d (%s). You have version %d (%s).", + gC_ModeNames[mode_id], mode.LatestVersion, desc, GOKZ_GetModeVersion(mode_id), GOKZ_VERSION); + } + } + return 0; +} + +public int GetMapCallback(JSON_Object map_json, GlobalAPIRequestData request) +{ + if (request.Failure || map_json == INVALID_HANDLE) + { + LogError("Failed to get map info."); + return 0; + } + + APIMap map = view_as<APIMap>(map_json); + + gB_MapValidated = map.IsValidated; + gI_MapID = map.Id; + gI_MapFileSize = map.Filesize; + gI_MapTier = map.Difficulty; + + // We don't do that earlier cause we need the map ID + for (int client = 1; client <= MaxClients; client++) + { + if (IsValidClient(client) && IsClientAuthorized(client) && !IsFakeClient(client)) + { + UpdatePoints(client); + } + } + return 0; +} + +void CheckClientGlobalBan(int client) +{ + char steamid[32]; + GetClientAuthId(client, AuthId_Steam2, steamid, sizeof(steamid)); + GlobalAPI_GetPlayerBySteamId(CheckClientGlobalBan_Callback, client, steamid); +} + +public void CheckClientGlobalBan_Callback(JSON_Object player_json, GlobalAPIRequestData request, int client) +{ + if (!IsValidClient(client)) + { + return; + } + + if (request.Failure) + { + LogError("Failed to get ban info."); + return; + } + + char client_steamid[32], response_steamid[32]; + GetClientAuthId(client, AuthId_Steam2, client_steamid, sizeof(client_steamid)); + + if (!player_json.IsArray || player_json.Length != 1) + { + LogError("Got malformed reply when querying steamid %s", client_steamid); + return; + } + + APIPlayer player = view_as<APIPlayer>(player_json.GetObjectIndexed(0)); + player.GetSteamId(response_steamid, sizeof(response_steamid)); + if (!StrEqual(client_steamid, response_steamid)) + { + return; + } + + gB_GloballyVerified[client] = !player.IsBanned; + + if (player.IsBanned && gB_GOKZLocalDB) + { + GOKZ_DB_SetCheater(client, true); + } +} + +static void LoadSounds() +{ + char downloadPath[PLATFORM_MAX_PATH]; + FormatEx(downloadPath, sizeof(downloadPath), "sound/%s", GL_SOUND_NEW_RECORD); + AddFileToDownloadsTable(downloadPath); + PrecacheSound(GL_SOUND_NEW_RECORD, true); +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-global/api.sp b/sourcemod/scripting/gokz-global/api.sp new file mode 100644 index 0000000..23caa15 --- /dev/null +++ b/sourcemod/scripting/gokz-global/api.sp @@ -0,0 +1,142 @@ +static GlobalForward H_OnNewTopTime; +static GlobalForward H_OnPointsUpdated; + + + +// =====[ FORWARDS ]===== + +void CreateGlobalForwards() +{ + H_OnNewTopTime = new GlobalForward("GOKZ_GL_OnNewTopTime", ET_Ignore, Param_Cell, Param_Cell, Param_Cell, Param_Cell, Param_Cell, Param_Cell, Param_Float); + H_OnPointsUpdated = new GlobalForward("GOKZ_GL_OnPointsUpdated", ET_Ignore, Param_Cell, Param_Cell); +} + +void Call_OnNewTopTime(int client, int course, int mode, int timeType, int rank, int rankOverall, float time) +{ + Call_StartForward(H_OnNewTopTime); + Call_PushCell(client); + Call_PushCell(course); + Call_PushCell(mode); + Call_PushCell(timeType); + Call_PushCell(rank); + Call_PushCell(rankOverall); + Call_PushFloat(time); + Call_Finish(); +} + +void Call_OnPointsUpdated(int client, int mode) +{ + Call_StartForward(H_OnPointsUpdated); + Call_PushCell(client); + Call_PushCell(mode); + Call_Finish(); +} + + + +// =====[ NATIVES ]===== + +void CreateNatives() +{ + CreateNative("GOKZ_GL_PrintRecords", Native_PrintRecords); + CreateNative("GOKZ_GL_DisplayMapTopMenu", Native_DisplayMapTopMenu); + CreateNative("GOKZ_GL_GetPoints", Native_GetPoints); + CreateNative("GOKZ_GL_GetMapPoints", Native_GetMapPoints); + CreateNative("GOKZ_GL_GetRankPoints", Native_GetRankPoints); + CreateNative("GOKZ_GL_GetFinishes", Native_GetFinishes); + CreateNative("GOKZ_GL_UpdatePoints", Native_UpdatePoints); + CreateNative("GOKZ_GL_GetAPIKeyValid", Native_GetAPIKeyValid); + CreateNative("GOKZ_GL_GetPluginsValid", Native_GetPluginsValid); + CreateNative("GOKZ_GL_GetSettingsEnforcerValid", Native_GetSettingsEnforcerValid); + CreateNative("GOKZ_GL_GetMapValid", Native_GetMapValid); + CreateNative("GOKZ_GL_GetPlayerValid", Native_GetPlayerValid); +} + +public int Native_PrintRecords(Handle plugin, int numParams) +{ + char map[33], steamid[32]; + GetNativeString(2, map, sizeof(map)); + GetNativeString(5, steamid, sizeof(steamid)); + + if (StrEqual(map, "")) + { + PrintRecords(GetNativeCell(1), gC_CurrentMap, GetNativeCell(3), GetNativeCell(4), steamid); + } + else + { + PrintRecords(GetNativeCell(1), map, GetNativeCell(3), GetNativeCell(4), steamid); + } + return 0; +} + +public int Native_DisplayMapTopMenu(Handle plugin, int numParams) +{ + char pluginName[32]; + GetPluginFilename(plugin, pluginName, sizeof(pluginName)); + bool localRanksCall = StrEqual(pluginName, "gokz-localranks.smx", false); + + char map[33]; + GetNativeString(2, map, sizeof(map)); + + if (StrEqual(map, "")) + { + DisplayMapTopSubmenu(GetNativeCell(1), gC_CurrentMap, GetNativeCell(3), GetNativeCell(4), GetNativeCell(5), localRanksCall); + } + else + { + DisplayMapTopSubmenu(GetNativeCell(1), map, GetNativeCell(3), GetNativeCell(4), GetNativeCell(5), localRanksCall); + } + return 0; +} + +public int Native_GetPoints(Handle plugin, int numParams) +{ + return GetPoints(GetNativeCell(1), GetNativeCell(2), GetNativeCell(3)); +} + +public int Native_GetMapPoints(Handle plugin, int numParams) +{ + return GetMapPoints(GetNativeCell(1), GetNativeCell(2), GetNativeCell(3)); +} + +public int Native_GetRankPoints(Handle plugin, int numParams) +{ + return GetRankPoints(GetNativeCell(1), GetNativeCell(2)); +} + +public int Native_GetFinishes(Handle plugin, int numParams) +{ + return GetFinishes(GetNativeCell(1), GetNativeCell(2), GetNativeCell(3)); +} + +public int Native_UpdatePoints(Handle plugin, int numParams) +{ + // We're gonna always force an update here, cause otherwise the call doesn't really make sense + UpdatePoints(GetNativeCell(1), true, GetNativeCell(2)); + return 0; +} + +public int Native_GetAPIKeyValid(Handle plugin, int numParams) +{ + return view_as<int>(gB_APIKeyCheck); +} + +public int Native_GetPluginsValid(Handle plugin, int numParams) +{ + return view_as<int>(gB_BannedCommandsCheck); +} + +public int Native_GetSettingsEnforcerValid(Handle plugin, int numParams) +{ + return view_as<int>(gCV_gokz_settings_enforcer.BoolValue && gB_EnforcerOnFreshMap); +} + +public int Native_GetMapValid(Handle plugin, int numParams) +{ + return view_as<int>(MapCheck()); +} + +public int Native_GetPlayerValid(Handle plugin, int numParams) +{ + return view_as<int>(gB_GloballyVerified[GetNativeCell(1)]); +} diff --git a/sourcemod/scripting/gokz-global/ban_player.sp b/sourcemod/scripting/gokz-global/ban_player.sp new file mode 100644 index 0000000..835d9e5 --- /dev/null +++ b/sourcemod/scripting/gokz-global/ban_player.sp @@ -0,0 +1,42 @@ +/* + Globally ban players when they are suspected by gokz-anticheat. +*/ + + + +// =====[ PUBLIC ]===== + +void GlobalBanPlayer(int client, ACReason reason, const char[] notes, const char[] stats) +{ + char playerName[MAX_NAME_LENGTH], steamid[32], ip[32]; + + GetClientName(client, playerName, sizeof(playerName)); + GetClientAuthId(client, AuthId_Steam2, steamid, sizeof(steamid)); + GetClientIP(client, ip, sizeof(ip)); + + DataPack dp = new DataPack(); + dp.WriteString(playerName); + dp.WriteString(steamid); + + switch (reason) + { + case ACReason_BhopHack:GlobalAPI_CreateBan(BanPlayerCallback, dp, steamid, "bhop_hack", stats, notes, ip); + case ACReason_BhopMacro:GlobalAPI_CreateBan(BanPlayerCallback, dp, steamid, "bhop_macro", stats, notes, ip); + } +} + +public int BanPlayerCallback(JSON_Object response, GlobalAPIRequestData request, DataPack dp) +{ + char playerName[MAX_NAME_LENGTH], steamid[32]; + + dp.Reset(); + dp.ReadString(playerName, sizeof(playerName)); + dp.ReadString(steamid, sizeof(steamid)); + delete dp; + + if (request.Failure) + { + LogError("Failed to globally ban %s (%s).", playerName, steamid); + } + return 0; +} diff --git a/sourcemod/scripting/gokz-global/commands.sp b/sourcemod/scripting/gokz-global/commands.sp new file mode 100644 index 0000000..8ee7c32 --- /dev/null +++ b/sourcemod/scripting/gokz-global/commands.sp @@ -0,0 +1,169 @@ +void RegisterCommands() +{ + RegConsoleCmd("sm_globalcheck", CommandGlobalCheck, "[KZ] Show whether global records are currently enabled in chat."); + RegConsoleCmd("sm_gc", CommandGlobalCheck, "[KZ] Show whether global records are currently enabled in chat."); + RegConsoleCmd("sm_tier", CommandTier, "[KZ] Show the map's tier in chat."); + RegConsoleCmd("sm_gpb", CommandPrintPBs, "[KZ] Show main course global personal best in chat. Usage: !gpb <map>"); + RegConsoleCmd("sm_gr", CommandPrintRecords, "[KZ] Show main course global record times in chat. Usage: !gr <map>"); + RegConsoleCmd("sm_gwr", CommandPrintRecords, "[KZ] Show main course global record times in chat. Usage: !gwr <map>"); + RegConsoleCmd("sm_gbpb", CommandPrintBonusPBs, "[KZ] Show bonus global personal best in chat. Usage: !gbpb <#bonus> <map>"); + RegConsoleCmd("sm_gbr", CommandPrintBonusRecords, "[KZ] Show bonus global record times in chat. Usage: !bgr <#bonus> <map>"); + RegConsoleCmd("sm_gbwr", CommandPrintBonusRecords, "[KZ] Show bonus global record times in chat. Usage: !bgwr <#bonus> <map>"); + RegConsoleCmd("sm_gmaptop", CommandMapTop, "[KZ] Open a menu showing the top global main course times of a map. Usage: !gmaptop <map>"); + RegConsoleCmd("sm_gbmaptop", CommandBonusMapTop, "[KZ] Open a menu showing the top global bonus times of a map. Usage: !gbmaptop <#bonus> <map>"); +} + +public Action CommandGlobalCheck(int client, int args) +{ + PrintGlobalCheckToChat(client); + return Plugin_Handled; +} + +public Action CommandTier(int client, int args) +{ + if (gI_MapTier != -1) + { + GOKZ_PrintToChat(client, true, "%t", "Map Tier", gC_CurrentMap, gI_MapTier); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Map Tier (Unknown)", gC_CurrentMap); + } + return Plugin_Handled; +} + +public Action CommandPrintPBs(int client, int args) +{ + char steamid[32]; + GetClientAuthId(client, AuthId_Steam2, steamid, sizeof(steamid)); + return CommandPrintRecordsHelper(client, args, steamid); +} + +public Action CommandPrintRecords(int client, int args) +{ + return CommandPrintRecordsHelper(client, args); +} + +static Action CommandPrintRecordsHelper(int client, int args, const char[] steamid = DEFAULT_STRING) +{ + KZPlayer player = KZPlayer(client); + int mode = player.Mode; + + if (args == 0) + { // Print record times for current map and their current mode + PrintRecords(client, gC_CurrentMap, 0, mode, steamid); + } + else if (args >= 1) + { // Print record times for specified map and their current mode + char argMap[33]; + GetCmdArg(1, argMap, sizeof(argMap)); + PrintRecords(client, argMap, 0, mode, steamid); + } + return Plugin_Handled; +} + +public Action CommandPrintBonusPBs(int client, int args) +{ + char steamid[32]; + GetClientAuthId(client, AuthId_Steam2, steamid, sizeof(steamid)); + return CommandPrintBonusRecordsHelper(client, args, steamid); +} + +public Action CommandPrintBonusRecords(int client, int args) +{ + return CommandPrintBonusRecordsHelper(client, args); +} + +static Action CommandPrintBonusRecordsHelper(int client, int args, const char[] steamid = DEFAULT_STRING) +{ + KZPlayer player = KZPlayer(client); + int mode = player.Mode; + + if (args == 0) + { // Print Bonus 1 record times for current map and their current mode + PrintRecords(client, gC_CurrentMap, 1, mode, steamid); + } + else if (args == 1) + { // Print specified Bonus # record times for current map and their current mode + char argBonus[4]; + GetCmdArg(1, argBonus, sizeof(argBonus)); + int bonus = StringToInt(argBonus); + if (GOKZ_IsValidCourse(bonus, true)) + { + PrintRecords(client, gC_CurrentMap, bonus, mode, steamid); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Invalid Bonus Number", argBonus); + } + } + else if (args >= 2) + { // Print specified Bonus # record times for specified map and their current mode + char argBonus[4], argMap[33]; + GetCmdArg(1, argBonus, sizeof(argBonus)); + GetCmdArg(2, argMap, sizeof(argMap)); + int bonus = StringToInt(argBonus); + if (GOKZ_IsValidCourse(bonus, true)) + { + PrintRecords(client, argMap, bonus, mode, steamid); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Invalid Bonus Number", argBonus); + } + } + return Plugin_Handled; +} + +public Action CommandMapTop(int client, int args) +{ + if (args <= 0) + { // Open global map top for current map + DisplayMapTopModeMenu(client, gC_CurrentMap, 0); + } + else if (args >= 1) + { // Open global map top for specified map + char argMap[64]; + GetCmdArg(1, argMap, sizeof(argMap)); + DisplayMapTopModeMenu(client, argMap, 0); + } + return Plugin_Handled; +} + +public Action CommandBonusMapTop(int client, int args) +{ + if (args == 0) + { // Open global Bonus 1 top for current map + DisplayMapTopModeMenu(client, gC_CurrentMap, 1); + } + else if (args == 1) + { // Open specified global Bonus # top for current map + char argBonus[4]; + GetCmdArg(1, argBonus, sizeof(argBonus)); + int bonus = StringToInt(argBonus); + if (GOKZ_IsValidCourse(bonus, true)) + { + DisplayMapTopModeMenu(client, gC_CurrentMap, bonus); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Invalid Bonus Number", argBonus); + } + } + else if (args >= 2) + { // Open specified global Bonus # top for specified map + char argBonus[4], argMap[33]; + GetCmdArg(1, argBonus, sizeof(argBonus)); + GetCmdArg(2, argMap, sizeof(argMap)); + int bonus = StringToInt(argBonus); + if (GOKZ_IsValidCourse(bonus, true)) + { + DisplayMapTopModeMenu(client, argMap, bonus); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Invalid Bonus Number", argBonus); + } + } + return Plugin_Handled; +} diff --git a/sourcemod/scripting/gokz-global/maptop_menu.sp b/sourcemod/scripting/gokz-global/maptop_menu.sp new file mode 100644 index 0000000..0c71346 --- /dev/null +++ b/sourcemod/scripting/gokz-global/maptop_menu.sp @@ -0,0 +1,249 @@ +/* + Menu with the top global times for a map course and mode. +*/ + +static bool cameFromLocalRanks[MAXPLAYERS + 1]; +static char mapTopMap[MAXPLAYERS + 1][64]; +static int mapTopCourse[MAXPLAYERS + 1]; +static int mapTopMode[MAXPLAYERS + 1]; + + + +// =====[ PUBLIC ]===== + +void DisplayMapTopModeMenu(int client, const char[] map, int course) +{ + FormatEx(mapTopMap[client], sizeof(mapTopMap[]), map); + mapTopCourse[client] = course; + + Menu menu = new Menu(MenuHandler_MapTopModeMenu); + MapTopModeMenuSetTitle(client, menu); + GOKZ_MenuAddModeItems(client, menu, false); + menu.Display(client, MENU_TIME_FOREVER); +} + +void DisplayMapTopMenu(int client, const char[] map, int course, int mode) +{ + FormatEx(mapTopMap[client], sizeof(mapTopMap[]), map); + mapTopCourse[client] = course; + mapTopMode[client] = mode; + + Menu menu = new Menu(MenuHandler_MapTopMenu); + MapTopMenuSetTitle(client, menu); + MapTopMenuAddItems(client, menu); + menu.Display(client, MENU_TIME_FOREVER); +} + +void DisplayMapTopSubmenu(int client, const char[] map, int course, int mode, int timeType, bool fromLocalRanks = false) +{ + char modeStr[32]; + + cameFromLocalRanks[client] = fromLocalRanks; + + DataPack dp = new DataPack(); + dp.WriteCell(GetClientUserId(client)); + dp.WriteCell(timeType); + + FormatEx(mapTopMap[client], sizeof(mapTopMap[]), map); + mapTopCourse[client] = course; + mapTopMode[client] = mode; + GOKZ_GL_GetModeString(mode, modeStr, sizeof(modeStr)); + + // TODO Hard coded 128 tick + // TODO Hard coded cap at top 20 + // TODO Not true NUB yet + GlobalAPI_GetRecordsTop(DisplayMapTopSubmenuCallback, dp, _, _, _, map, 128, course, modeStr, + timeType == TimeType_Nub ? DEFAULT_BOOL : false, _, 0, 20); +} + + + +// =====[ EVENTS ]===== + +public int MenuHandler_MapTopModeMenu(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + // param1 = client, param2 = mode + DisplayMapTopMenu(param1, mapTopMap[param1], mapTopCourse[param1], param2); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + +public int MenuHandler_MapTopMenu(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + char info[8]; + menu.GetItem(param2, info, sizeof(info)); + int timeType = StringToInt(info); + DisplayMapTopSubmenu(param1, mapTopMap[param1], mapTopCourse[param1], mapTopMode[param1], timeType); + } + if (action == MenuAction_Cancel && param2 == MenuCancel_Exit) + { + DisplayMapTopModeMenu(param1, mapTopMap[param1], mapTopCourse[param1]); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + +public int MenuHandler_MapTopSubmenu(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Cancel && param2 == MenuCancel_Exit) + { + if (cameFromLocalRanks[param1]) + { + GOKZ_LR_ReopenMapTopMenu(param1); + } + else + { + DisplayMapTopMenu(param1, mapTopMap[param1], mapTopCourse[param1], mapTopMode[param1]); + } + } + if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + + + +// =====[ PRIVATE ]===== + +static void MapTopModeMenuSetTitle(int client, Menu menu) +{ + if (mapTopCourse[client] == 0) + { + menu.SetTitle("%T", "Global Map Top Mode Menu - Title", client, mapTopMap[client]); + } + else + { + menu.SetTitle("%T", "Global Map Top Mode Menu - Title (Bonus)", client, mapTopMap[client], mapTopCourse[client]); + } +} + +static void MapTopMenuSetTitle(int client, Menu menu) +{ + if (mapTopCourse[client] == 0) + { + menu.SetTitle("%T", "Global Map Top Menu - Title", client, mapTopMap[client], gC_ModeNames[mapTopMode[client]]); + } + else + { + menu.SetTitle("%T", "Global Map Top Menu - Title (Bonus)", client, mapTopMap[client], mapTopCourse[client], gC_ModeNames[mapTopMode[client]]); + } +} + +static void MapTopMenuAddItems(int client, Menu menu) +{ + char display[32]; + for (int i = 0; i < TIMETYPE_COUNT; i++) + { + FormatEx(display, sizeof(display), "%T", "Global Map Top Menu - Top", client, gC_TimeTypeNames[i]); + menu.AddItem(IntToStringEx(i), display); + } +} + +public int DisplayMapTopSubmenuCallback(JSON_Object top, GlobalAPIRequestData request, DataPack dp) +{ + dp.Reset(); + int client = GetClientOfUserId(dp.ReadCell()); + int timeType = dp.ReadCell(); + delete dp; + + if (request.Failure) + { + LogError("Failed to get top records with Global API."); + return 0; + } + + if (!top.IsArray) + { + LogError("GlobalAPI returned a malformed response while looking up the top records."); + return 0; + } + + if (!IsValidClient(client)) + { + return 0; + } + + Menu menu = new Menu(MenuHandler_MapTopSubmenu); + if (mapTopCourse[client] == 0) + { + menu.SetTitle("%T", "Global Map Top Submenu - Title", client, + gC_TimeTypeNames[timeType], mapTopMap[client], gC_ModeNames[mapTopMode[client]]); + } + else + { + menu.SetTitle("%T", "Global Map Top Submenu - Title (Bonus)", client, + gC_TimeTypeNames[timeType], mapTopMap[client], mapTopCourse[client], gC_ModeNames[mapTopMode[client]]); + } + + if (MapTopSubmenuAddItems(menu, top, timeType) == 0) + { // If no records found + if (timeType == TimeType_Pro) + { + GOKZ_PrintToChat(client, true, "%t", "No Global Times Found (PRO)"); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "No Global Times Found"); + } + + if (cameFromLocalRanks[client]) + { + GOKZ_LR_ReopenMapTopMenu(client); + } + else + { + DisplayMapTopMenu(client, mapTopMap[client], mapTopCourse[client], mapTopMode[client]); + } + } + else + { + menu.Pagination = 5; + menu.Display(client, MENU_TIME_FOREVER); + } + return 0; +} + +// Returns number of record times added to the menu +static int MapTopSubmenuAddItems(Menu menu, JSON_Object records, int timeType) +{ + char playerName[MAX_NAME_LENGTH]; + char display[128]; + + for (int i = 0; i < records.Length; i++) + { + APIRecord record = view_as<APIRecord>(records.GetObjectIndexed(i)); + + record.GetPlayerName(playerName, sizeof(playerName)); + + switch (timeType) + { + case TimeType_Nub: + { + FormatEx(display, sizeof(display), "#%-2d %11s %3d TP %s", + i + 1, GOKZ_FormatTime(record.Time), record.Teleports, playerName); + } + case TimeType_Pro: + { + FormatEx(display, sizeof(display), "#%-2d %11s %s", + i + 1, GOKZ_FormatTime(record.Time), playerName); + } + } + + menu.AddItem("", display, ITEMDRAW_DISABLED); + } + + return records.Length; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-global/points.sp b/sourcemod/scripting/gokz-global/points.sp new file mode 100644 index 0000000..7758318 --- /dev/null +++ b/sourcemod/scripting/gokz-global/points.sp @@ -0,0 +1,147 @@ + +int pointsTotal[MAXPLAYERS + 1][MODE_COUNT][TIMETYPE_COUNT]; +int finishes[MAXPLAYERS + 1][MODE_COUNT][TIMETYPE_COUNT]; +int pointsMap[MAXPLAYERS + 1][MODE_COUNT][TIMETYPE_COUNT]; +int requestsInProgress[MAXPLAYERS + 1]; + + + +void ResetPoints(int client) +{ + for (int mode = 0; mode < MODE_COUNT; mode++) + { + for (int type = 0; type < TIMETYPE_COUNT; type++) + { + pointsTotal[client][mode][type] = -1; + finishes[client][mode][type] = -1; + pointsMap[client][mode][type] = -1; + } + } + requestsInProgress[client] = 0; +} + +void ResetMapPoints(int client) +{ + for (int mode = 0; mode < MODE_COUNT; mode++) + { + for (int type = 0; type < TIMETYPE_COUNT; type++) + { + pointsMap[client][mode][type] = -1; + } + } + requestsInProgress[client] = 0; +} + +int GetRankPoints(int client, int mode) +{ + return pointsTotal[client][mode][TimeType_Nub]; +} + +int GetPoints(int client, int mode, int timeType) +{ + return pointsTotal[client][mode][timeType]; +} + +int GetMapPoints(int client, int mode, int timeType) +{ + return pointsMap[client][mode][timeType]; +} + +int GetFinishes(int client, int mode, int timeType) +{ + return finishes[client][mode][timeType]; +} + +// Note: This only gets 128 tick records +void UpdatePoints(int client, bool force = false, int mode = -1) +{ + if (requestsInProgress[client] != 0) + { + return; + } + + if (mode == -1) + { + mode = GOKZ_GetCoreOption(client, Option_Mode); + } + + if (!force || pointsTotal[client][mode][TimeType_Nub] == -1) + { + GetPlayerRanks(client, mode, TimeType_Nub); + GetPlayerRanks(client, mode, TimeType_Pro); + requestsInProgress[client] += 2; + } + + if (gI_MapID != -1 && (!force || pointsMap[client][mode][TimeType_Nub] == -1)) + { + GetPlayerRanks(client, mode, TimeType_Nub, gI_MapID); + GetPlayerRanks(client, mode, TimeType_Pro, gI_MapID); + requestsInProgress[client] += 2; + } +} + +static void GetPlayerRanks(int client, int mode, int timeType, int mapID = DEFAULT_INT) +{ + char steamid[21]; + int modes[1], mapIDs[1]; + + modes[0] = view_as<int>(GOKZ_GL_GetGlobalMode(mode)); + mapIDs[0] = mapID; + GetClientAuthId(client, AuthId_SteamID64, steamid, sizeof(steamid)); + + DataPack dp = new DataPack(); + dp.WriteCell(GetClientUserId(client)); + dp.WriteCell(mode); + dp.WriteCell(timeType); + dp.WriteCell(mapID == DEFAULT_INT); + GlobalAPI_GetPlayerRanks(UpdatePointsCallback, dp, _, _, _, _, steamid, _, _, + mapIDs, mapID == DEFAULT_INT ? DEFAULT_INT : 1, { 0 }, 1, + modes, 1, { 128 }, 1, timeType == TimeType_Nub ? DEFAULT_BOOL : false, _, _); +} + +static void UpdatePointsCallback(JSON_Object ranks, GlobalAPIRequestData request, DataPack dp) +{ + dp.Reset(); + int client = GetClientOfUserId(dp.ReadCell()); + int mode = dp.ReadCell(); + int timeType = dp.ReadCell(); + bool isTotal = dp.ReadCell(); + delete dp; + + requestsInProgress[client]--; + + if (client == 0) + { + return; + } + + int points, totalFinishes; + if (request.Failure || !ranks.IsArray || ranks.Length == 0) + { + points = 0; + totalFinishes = 0; + } + else + { + APIPlayerRank rank = view_as<APIPlayerRank>(ranks.GetObjectIndexed(0)); + // points = timeType == TimeType_Nub ? rank.PointsOverall : rank.Points; + points = points == -1 ? 0 : rank.Points; + totalFinishes = rank.Finishes == -1 ? 0 : rank.Finishes; + } + + if (isTotal) + { + pointsTotal[client][mode][timeType] = points; + finishes[client][mode][timeType] = totalFinishes; + } + else + { + pointsMap[client][mode][timeType] = points; + } + + // We always do that cause not all of the requests might have failed + if (requestsInProgress[client] == 0) + { + Call_OnPointsUpdated(client, mode); + } +} diff --git a/sourcemod/scripting/gokz-global/print_records.sp b/sourcemod/scripting/gokz-global/print_records.sp new file mode 100644 index 0000000..3966ed5 --- /dev/null +++ b/sourcemod/scripting/gokz-global/print_records.sp @@ -0,0 +1,190 @@ +/* + Prints the global record times for a map course and mode. +*/ + + +static bool inProgress[MAXPLAYERS + 1]; +static bool waitingForOtherCallback[MAXPLAYERS + 1]; +static bool isPBQuery[MAXPLAYERS + 1]; +static char printRecordsMap[MAXPLAYERS + 1][64]; +static int printRecordsCourse[MAXPLAYERS + 1]; +static int printRecordsMode[MAXPLAYERS + 1]; +static bool printRecordsTimeExists[MAXPLAYERS + 1][TIMETYPE_COUNT]; +static float printRecordsTimes[MAXPLAYERS + 1][TIMETYPE_COUNT]; +static char printRecordsPlayerNames[MAXPLAYERS + 1][TIMETYPE_COUNT][MAX_NAME_LENGTH]; + + + +// =====[ PUBLIC ]===== + +void PrintRecords(int client, const char[] map, int course, int mode, const char[] steamid = DEFAULT_STRING) +{ + char mode_str[32]; + + if (inProgress[client]) + { + GOKZ_PrintToChat(client, true, "%t", "Please Wait Before Using Command Again"); + return; + } + + GOKZ_GL_GetModeString(mode, mode_str, sizeof(mode_str)); + + DataPack dpNUB = CreateDataPack(); + dpNUB.WriteCell(GetClientUserId(client)); + dpNUB.WriteCell(TimeType_Nub); + GlobalAPI_GetRecordsTop(PrintRecordsCallback, dpNUB, steamid, _, _, map, 128, course, mode_str, _, _, 0, 1); + + DataPack dpPRO = CreateDataPack(); + dpPRO.WriteCell(GetClientUserId(client)); + dpPRO.WriteCell(TimeType_Pro); + GlobalAPI_GetRecordsTop(PrintRecordsCallback, dpPRO, steamid, _, _, map, 128, course, mode_str, false, _, 0, 1); + + inProgress[client] = true; + waitingForOtherCallback[client] = true; + isPBQuery[client] = !StrEqual(steamid, DEFAULT_STRING); + FormatEx(printRecordsMap[client], sizeof(printRecordsMap[]), map); + printRecordsCourse[client] = course; + printRecordsMode[client] = mode; +} + +public int PrintRecordsCallback(JSON_Object records, GlobalAPIRequestData request, DataPack dp) +{ + dp.Reset(); + int client = GetClientOfUserId(dp.ReadCell()); + int timeType = dp.ReadCell(); + delete dp; + + if (request.Failure) + { + LogError("Failed to retrieve record from the Global API for printing."); + return 0; + } + + if (!IsValidClient(client)) + { + return 0; + } + + if (records.Length <= 0) + { + printRecordsTimeExists[client][timeType] = false; + } + else + { + APIRecord record = view_as<APIRecord>(records.GetObjectIndexed(0)); + printRecordsTimeExists[client][timeType] = true; + printRecordsTimes[client][timeType] = record.Time; + record.GetPlayerName(printRecordsPlayerNames[client][timeType], sizeof(printRecordsPlayerNames[][])); + } + + if (!waitingForOtherCallback[client]) + { + if (isPBQuery[client]) + { + PrintPBsFinally(client); + } + else + { + PrintRecordsFinally(client); + } + inProgress[client] = false; + } + else + { + waitingForOtherCallback[client] = false; + } + return 0; +} + + + +// =====[ EVENTS ]===== + +void OnClientPutInServer_PrintRecords(int client) +{ + inProgress[client] = false; +} + + + +// =====[ PRIVATE ]===== + +static void PrintPBsFinally(int client) +{ + // Print GPB header to chat + if (printRecordsCourse[client] == 0) + { + GOKZ_PrintToChat(client, true, "%t", "GPB Header", + printRecordsMap[client], + gC_ModeNamesShort[printRecordsMode[client]]); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "GPB Header (Bonus)", + printRecordsMap[client], + printRecordsCourse[client], + gC_ModeNamesShort[printRecordsMode[client]]); + } + + // Print GPB times to chat + if (!printRecordsTimeExists[client][TimeType_Nub]) + { + GOKZ_PrintToChat(client, false, "%t", "No Global Times Found"); + } + else if (!printRecordsTimeExists[client][TimeType_Pro]) + { + GOKZ_PrintToChat(client, false, "%t", "GPB Time - NUB", + GOKZ_FormatTime(printRecordsTimes[client][TimeType_Nub]), + printRecordsPlayerNames[client][TimeType_Nub]); + GOKZ_PrintToChat(client, false, "%t", "GPB Time - No PRO Time"); + } + else + { + GOKZ_PrintToChat(client, false, "%t", "GPB Time - NUB", + GOKZ_FormatTime(printRecordsTimes[client][TimeType_Nub]), + printRecordsPlayerNames[client][TimeType_Nub]); + GOKZ_PrintToChat(client, false, "%t", "GPB Time - PRO", + GOKZ_FormatTime(printRecordsTimes[client][TimeType_Pro]), + printRecordsPlayerNames[client][TimeType_Pro]); + } +} + +static void PrintRecordsFinally(int client) +{ + // Print GWR header to chat + if (printRecordsCourse[client] == 0) + { + GOKZ_PrintToChat(client, true, "%t", "GWR Header", + printRecordsMap[client], + gC_ModeNamesShort[printRecordsMode[client]]); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "GWR Header (Bonus)", + printRecordsMap[client], + printRecordsCourse[client], + gC_ModeNamesShort[printRecordsMode[client]]); + } + + // Print GWR times to chat + if (!printRecordsTimeExists[client][TimeType_Nub]) + { + GOKZ_PrintToChat(client, false, "%t", "No Global Times Found"); + } + else if (!printRecordsTimeExists[client][TimeType_Pro]) + { + GOKZ_PrintToChat(client, false, "%t", "GWR Time - NUB", + GOKZ_FormatTime(printRecordsTimes[client][TimeType_Nub]), + printRecordsPlayerNames[client][TimeType_Nub]); + GOKZ_PrintToChat(client, false, "%t", "GWR Time - No PRO Time"); + } + else + { + GOKZ_PrintToChat(client, false, "%t", "GWR Time - NUB", + GOKZ_FormatTime(printRecordsTimes[client][TimeType_Nub]), + printRecordsPlayerNames[client][TimeType_Nub]); + GOKZ_PrintToChat(client, false, "%t", "GWR Time - PRO", + GOKZ_FormatTime(printRecordsTimes[client][TimeType_Pro]), + printRecordsPlayerNames[client][TimeType_Pro]); + } +} diff --git a/sourcemod/scripting/gokz-global/send_run.sp b/sourcemod/scripting/gokz-global/send_run.sp new file mode 100644 index 0000000..f560958 --- /dev/null +++ b/sourcemod/scripting/gokz-global/send_run.sp @@ -0,0 +1,143 @@ +/* + Sends a run to the global API and delete the replay if it is a temporary replay. +*/ + + + +char storedReplayPath[MAXPLAYERS + 1][512]; +int lastRecordId[MAXPLAYERS + 1], storedCourse[MAXPLAYERS + 1], storedTimeType[MAXPLAYERS + 1], storedUserId[MAXPLAYERS + 1]; +float storedTime[MAXPLAYERS + 1]; +bool deleteRecord[MAXPLAYERS + 1]; + +// =====[ PUBLIC ]===== + +void SendTime(int client, int course, float time, int teleportsUsed) +{ + char steamid[32], modeStr[32]; + KZPlayer player = KZPlayer(client); + int mode = player.Mode; + + if (GlobalsEnabled(mode)) + { + DataPack dp = CreateDataPack(); + dp.WriteCell(GetClientUserId(client)); + dp.WriteCell(course); + dp.WriteCell(mode); + dp.WriteCell(GOKZ_GetTimeTypeEx(teleportsUsed)); + dp.WriteFloat(time); + + GetClientAuthId(client, AuthId_Steam2, steamid, sizeof(steamid)); + GOKZ_GL_GetModeString(mode, modeStr, sizeof(modeStr)); + GlobalAPI_CreateRecord(SendTimeCallback, dp, steamid, gI_MapID, modeStr, course, 128, teleportsUsed, time); + } +} + +public int SendTimeCallback(JSON_Object response, GlobalAPIRequestData request, DataPack dp) +{ + dp.Reset(); + int userID = dp.ReadCell(); + int client = GetClientOfUserId(userID); + int course = dp.ReadCell(); + int mode = dp.ReadCell(); + int timeType = dp.ReadCell(); + float time = dp.ReadFloat(); + delete dp; + + if (!IsValidClient(client)) + { + return 0; + } + + if (request.Failure) + { + LogError("Failed to send a time to the global API."); + return 0; + } + + int top_place = response.GetInt("top_100"); + int top_overall_place = response.GetInt("top_100_overall"); + + if (top_place > 0) + { + Call_OnNewTopTime(client, course, mode, timeType, top_place, top_overall_place, time); + } + + // Don't like doing this here, but seems to be the most efficient place + UpdatePoints(client, true); + + // Check if we can send the replay + lastRecordId[client] = response.GetInt("record_id"); + if (IsReplayReadyToSend(client, course, timeType, time)) + { + SendReplay(client); + } + else + { + storedUserId[client] = userID; + storedCourse[client] = course; + storedTimeType[client] = timeType; + storedTime[client] = time; + } + return 0; +} + +public void OnReplaySaved_SendReplay(int client, int replayType, const char[] map, int course, int timeType, float time, const char[] filePath, bool tempReplay) +{ + strcopy(storedReplayPath[client], sizeof(storedReplayPath[]), filePath); + if (IsReplayReadyToSend(client, course, timeType, time)) + { + SendReplay(client); + } + else + { + lastRecordId[client] = -1; + storedUserId[client] = GetClientUserId(client); + storedCourse[client] = course; + storedTimeType[client] = timeType; + storedTime[client] = time; + deleteRecord[client] = tempReplay; + } +} + +bool IsReplayReadyToSend(int client, int course, int timeType, float time) +{ + // Not an error, just not ready yet + if (lastRecordId[client] == -1 || storedReplayPath[client][0] == '\0') + { + return false; + } + + if (storedUserId[client] == GetClientUserId(client) && storedCourse[client] == course + && storedTimeType[client] == timeType && storedTime[client] == time) + { + return true; + } + else + { + LogError("Failed to upload replay to the global API. Record mismatch."); + return false; + } +} + +public void SendReplay(int client) +{ + DataPack dp = new DataPack(); + dp.WriteString(deleteRecord[client] ? storedReplayPath[client] : ""); + GlobalAPI_CreateReplayForRecordId(SendReplayCallback, dp, lastRecordId[client], storedReplayPath[client]); + lastRecordId[client] = -1; + storedReplayPath[client] = ""; +} + +public int SendReplayCallback(JSON_Object response, GlobalAPIRequestData request, DataPack dp) +{ + // Delete the temporary replay file if needed. + dp.Reset(); + char replayPath[PLATFORM_MAX_PATH]; + dp.ReadString(replayPath, sizeof(replayPath)); + if (replayPath[0] != '\0') + { + DeleteFile(replayPath); + } + delete dp; + return 0; +} diff --git a/sourcemod/scripting/gokz-goto.sp b/sourcemod/scripting/gokz-goto.sp new file mode 100644 index 0000000..7dd67cb --- /dev/null +++ b/sourcemod/scripting/gokz-goto.sp @@ -0,0 +1,231 @@ +#include <sourcemod> + +#include <cstrike> +#include <sdktools> + +#include <gokz/core> + +#undef REQUIRE_EXTENSIONS +#undef REQUIRE_PLUGIN +#include <updater> + +#pragma newdecls required +#pragma semicolon 1 + + + +public Plugin myinfo = +{ + name = "GOKZ Goto", + author = "DanZay", + description = "Allows players to teleport to another player", + version = GOKZ_VERSION, + url = GOKZ_SOURCE_URL +}; + +#define UPDATER_URL GOKZ_UPDATER_BASE_URL..."gokz-goto.txt" + + + +// =====[ PLUGIN EVENTS ]===== + +public APLRes AskPluginLoad2(Handle myself, bool late, char[] error, int err_max) +{ + RegPluginLibrary("gokz-goto"); + return APLRes_Success; +} + +public void OnPluginStart() +{ + LoadTranslations("common.phrases"); + LoadTranslations("gokz-common.phrases"); + LoadTranslations("gokz-goto.phrases"); + + RegisterCommands(); +} + +public void OnAllPluginsLoaded() +{ + if (LibraryExists("updater")) + { + Updater_AddPlugin(UPDATER_URL); + } +} + +public void OnLibraryAdded(const char[] name) +{ + if (StrEqual(name, "updater")) + { + Updater_AddPlugin(UPDATER_URL); + } +} + + + +// =====[ GOTO ]===== + +// Returns whether teleport to target was successful +bool GotoPlayer(int client, int target, bool printMessage = true) +{ + if (GOKZ_GetCoreOption(client, Option_Safeguard) > Safeguard_Disabled && GOKZ_GetTimerRunning(client) && GOKZ_GetValidTimer(client)) + { + if (printMessage) + { + GOKZ_PrintToChat(client, true, "%t", "Safeguard - Blocked"); + GOKZ_PlayErrorSound(client); + } + return false; + } + if (target == client) + { + if (printMessage) + { + GOKZ_PrintToChat(client, true, "%t", "Goto Failure (Not Yourself)"); + GOKZ_PlayErrorSound(client); + } + return false; + } + if (!IsPlayerAlive(target)) + { + if (printMessage) + { + GOKZ_PrintToChat(client, true, "%t", "Goto Failure (Dead)"); + GOKZ_PlayErrorSound(client); + } + return false; + } + + float targetOrigin[3]; + float targetAngles[3]; + + Movement_GetOrigin(target, targetOrigin); + Movement_GetEyeAngles(target, targetAngles); + + if (!IsPlayerAlive(client)) + { + GOKZ_RespawnPlayer(client); + } + + TeleportPlayer(client, targetOrigin, targetAngles); + + GOKZ_PrintToChat(client, true, "%t", "Goto Success", target); + + if (GOKZ_GetTimerRunning(client)) + { + GOKZ_PrintToChat(client, true, "%t", "Timer Stopped (Goto)"); + GOKZ_StopTimer(client); + } + + return true; +} + + + +// =====[ GOTO MENU ]===== + +int DisplayGotoMenu(int client) +{ + Menu menu = new Menu(MenuHandler_Goto); + menu.SetTitle("%T", "Goto Menu - Title", client); + int menuItems = GotoMenuAddItems(client, menu); + if (menuItems == 0) + { + delete menu; + } + else + { + menu.Display(client, MENU_TIME_FOREVER); + } + return menuItems; +} + +public int MenuHandler_Goto(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + char info[16]; + menu.GetItem(param2, info, sizeof(info)); + int target = GetClientOfUserId(StringToInt(info)); + + if (!IsValidClient(target)) + { + GOKZ_PrintToChat(param1, true, "%t", "Player No Longer Valid"); + GOKZ_PlayErrorSound(param1); + DisplayGotoMenu(param1); + } + else if (!GotoPlayer(param1, target)) + { + DisplayGotoMenu(param1); + } + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + +// Returns number of items added to the menu +int GotoMenuAddItems(int client, Menu menu) +{ + char display[MAX_NAME_LENGTH + 4]; + int targetCount = 0; + + for (int i = 1; i <= MaxClients; i++) + { + if (!IsClientInGame(i) || !IsPlayerAlive(i) || i == client) + { + continue; + } + + if (IsFakeClient(i)) + { + FormatEx(display, sizeof(display), "BOT %N", i); + } + else + { + FormatEx(display, sizeof(display), "%N", i); + } + + menu.AddItem(IntToStringEx(GetClientUserId(i)), display, ITEMDRAW_DEFAULT); + targetCount++; + } + + return targetCount; +} + + + +// =====[ COMMANDS ]===== + +void RegisterCommands() +{ + RegConsoleCmd("sm_goto", CommandGoto, "[KZ] Teleport to another player. Usage: !goto <player>"); +} + +public Action CommandGoto(int client, int args) +{ + // If no arguments, display the goto menu + if (args < 1) + { + if (DisplayGotoMenu(client) == 0) + { + // No targets, so show error + GOKZ_PrintToChat(client, true, "%t", "No Players Found"); + GOKZ_PlayErrorSound(client); + } + } + // Otherwise try to teleport to the specified player + else + { + char specifiedPlayer[MAX_NAME_LENGTH]; + GetCmdArg(1, specifiedPlayer, sizeof(specifiedPlayer)); + + int target = FindTarget(client, specifiedPlayer, false, false); + if (target != -1) + { + GotoPlayer(client, target); + } + } + return Plugin_Handled; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-hud.sp b/sourcemod/scripting/gokz-hud.sp new file mode 100644 index 0000000..e9db12a --- /dev/null +++ b/sourcemod/scripting/gokz-hud.sp @@ -0,0 +1,334 @@ +#include <sourcemod> + +#include <sdkhooks> +#include <gokz/core> +#include <gokz/hud> + +#undef REQUIRE_EXTENSIONS +#undef REQUIRE_PLUGIN +#include <gokz/racing> +#include <gokz/replays> +#include <updater> + +#include <gokz/kzplayer> + +#pragma newdecls required +#pragma semicolon 1 + + + +public Plugin myinfo = +{ + name = "GOKZ HUD", + author = "DanZay", + description = "Provides HUD and UI features", + version = GOKZ_VERSION, + url = GOKZ_SOURCE_URL +}; + +#define UPDATER_URL GOKZ_UPDATER_BASE_URL..."gokz-hud.txt" + +bool gB_GOKZRacing; +bool gB_GOKZReplays; +bool gB_MenuShowing[MAXPLAYERS + 1]; +int gI_ObserverTarget[MAXPLAYERS + 1]; +bool gB_JBTakeoff[MAXPLAYERS + 1]; +bool gB_FastUpdateRate[MAXPLAYERS + 1]; +int gI_DynamicMenu[MAXPLAYERS + 1]; + +#include "gokz-hud/spectate_text.sp" +#include "gokz-hud/commands.sp" +#include "gokz-hud/hide_weapon.sp" +#include "gokz-hud/info_panel.sp" +#include "gokz-hud/menu.sp" +#include "gokz-hud/options.sp" +#include "gokz-hud/options_menu.sp" +#include "gokz-hud/racing_text.sp" +#include "gokz-hud/speed_text.sp" +#include "gokz-hud/timer_text.sp" +#include "gokz-hud/tp_menu.sp" +#include "gokz-hud/natives.sp" + +// =====[ PLUGIN EVENTS ]===== + +public APLRes AskPluginLoad2(Handle myself, bool late, char[] error, int err_max) +{ + CreateNatives(); + RegPluginLibrary("gokz-hud"); + return APLRes_Success; +} + +public void OnPluginStart() +{ + LoadTranslations("gokz-common.phrases"); + LoadTranslations("gokz-hud.phrases"); + + HookEvents(); + RegisterCommands(); + + UpdateSpecList(); + OnPluginStart_RacingText(); + OnPluginStart_SpeedText(); + OnPluginStart_TimerText(); +} + +public void OnPluginEnd() +{ + OnPluginEnd_Menu(); +} + +public void OnAllPluginsLoaded() +{ + if (LibraryExists("updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + + TopMenu topMenu; + if (LibraryExists("gokz-core") && ((topMenu = GOKZ_GetOptionsTopMenu()) != null)) + { + GOKZ_OnOptionsMenuReady(topMenu); + } + + gB_GOKZRacing = LibraryExists("gokz-racing"); + gB_GOKZReplays = LibraryExists("gokz-replays"); + for (int client = 1; client <= MaxClients; client++) + { + if (IsClientInGame(client)) + { + OnClientPutInServer(client); + } + } +} + +public void OnLibraryAdded(const char[] name) +{ + if (StrEqual(name, "updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + + gB_GOKZRacing = gB_GOKZRacing || StrEqual(name, "gokz-racing"); + gB_GOKZReplays = gB_GOKZReplays || StrEqual(name, "gokz-replays"); +} + +public void OnLibraryRemoved(const char[] name) +{ + gB_GOKZRacing = gB_GOKZRacing && !StrEqual(name, "gokz-racing"); + gB_GOKZReplays = gB_GOKZReplays && !StrEqual(name, "gokz-replays"); +} + + + +// =====[ CLIENT EVENTS ]===== + +public void OnClientDisconnect(int client) +{ + gI_ObserverTarget[client] = -1; +} + +public void OnClientPutInServer(int client) +{ + SDKHook(client, SDKHook_PostThinkPost, OnPlayerPostThinkPost); +} + +public void OnPlayerPostThinkPost(int client) +{ + KZPlayer player = KZPlayer(client); + gB_JBTakeoff[client] = (gB_JBTakeoff[client] && !player.OnGround && !player.OnLadder && !player.Noclipping) || Movement_GetJumpbugged(client); +} + +public void OnPlayerRunCmdPost(int client, int buttons, int impulse, const float vel[3], const float angles[3], int weapon, int subtype, int cmdnum, int tickcount, int seed, const int mouse[2]) +{ + if (!IsValidClient(client)) + { + return; + } + + HUDInfo info; + KZPlayer player = KZPlayer(client); + KZPlayer targetPlayer = KZPlayer(player.ObserverTarget); + + // Bots don't need to have their HUD drawn + if (player.Fake) + { + return; + } + + if (player.Alive) + { + SetHUDInfo(player, info, cmdnum); + } + else if (targetPlayer.ID != -1 && !targetPlayer.Fake) + { + SetHUDInfo(targetPlayer, info, cmdnum); + } + else if (targetPlayer.ID != -1 && gB_GOKZReplays) + { + GOKZ_RP_GetPlaybackInfo(targetPlayer.ID, info); + } + else + { + return; + } + + if (!IsValidClient(info.ID)) + { + return; + } + + OnPlayerRunCmdPost_InfoPanel(client, cmdnum, info); + OnPlayerRunCmdPost_RacingText(client, cmdnum); + OnPlayerRunCmdPost_SpeedText(client, cmdnum, info); + OnPlayerRunCmdPost_TimerText(client, cmdnum, info); + OnPlayerRunCmdPost_TPMenu(client, cmdnum, info); +} + +public void OnPlayerSpawn(Event event, const char[] name, bool dontBroadcast) // player_spawn post hook +{ + int client = GetClientOfUserId(event.GetInt("userid")); + if (IsValidClient(client)) + { + OnPlayerSpawn_HideWeapon(client); + OnPlayerSpawn_Menu(client); + } +} + +public Action OnPlayerDeath(Event event, const char[] name, bool dontBroadcast) // player_death pre hook +{ + event.BroadcastDisabled = true; // Block death notices + return Plugin_Continue; +} + +public void GOKZ_OnJoinTeam(int client, int team) +{ + OnJoinTeam_Menu(client); +} + +public void GOKZ_OnTimerStart_Post(int client, int course) +{ + OnTimerStart_Menu(client); +} + +public void GOKZ_OnTimerEnd_Post(int client, int course, float time, int teleportsUsed) +{ + OnTimerEnd_TimerText(client); + OnTimerEnd_Menu(client); +} + +public void GOKZ_OnTimerStopped(int client) +{ + OnTimerStopped_TimerText(client); + OnTimerStopped_Menu(client); +} + +public void GOKZ_OnPause_Post(int client) +{ + OnPause_Menu(client); +} + +public void GOKZ_OnResume_Post(int client) +{ + OnResume_Menu(client); +} + +public void GOKZ_OnMakeCheckpoint_Post(int client) +{ + OnMakeCheckpoint_Menu(client); +} + +public void GOKZ_OnCountedTeleport_Post(int client) +{ + OnCountedTeleport_Menu(client); +} + +public void GOKZ_OnStartPositionSet_Post(int client, StartPositionType type, const float origin[3], const float angles[3]) +{ + OnStartPositionSet_Menu(client); +} + +public void GOKZ_OnOptionChanged(int client, const char[] option, any newValue) +{ + any hudOption; + if (GOKZ_HUD_IsHUDOption(option, hudOption)) + { + OnOptionChanged_SpeedText(client, hudOption); + OnOptionChanged_TimerText(client, hudOption); + OnOptionChanged_Menu(client, hudOption); + OnOptionChanged_HideWeapon(client, hudOption); + OnOptionChanged_Options(client, hudOption, newValue); + if (hudOption == HUDOption_UpdateRate) + { + gB_FastUpdateRate[client] = GOKZ_HUD_GetOption(client, HUDOption_UpdateRate) == UpdateRate_Fast; + } + else if (hudOption == HUDOption_DynamicMenu) + { + gI_DynamicMenu[client] = GOKZ_HUD_GetOption(client, HUDOption_DynamicMenu); + } + } +} + +public void GOKZ_OnOptionsLoaded(int client) +{ + gB_FastUpdateRate[client] = GOKZ_HUD_GetOption(client, HUDOption_UpdateRate) == UpdateRate_Fast; + gI_DynamicMenu[client] = GOKZ_HUD_GetOption(client, HUDOption_DynamicMenu); +} + +// =====[ OTHER EVENTS ]===== + +public void OnGameFrame() +{ + // Cache the spectator list every few ticks. + if (GetGameTickCount() % 4 == 0) + { + UpdateSpecList(); + } +} + +public void GOKZ_OnOptionsMenuCreated(TopMenu topMenu) +{ + OnOptionsMenuCreated_OptionsMenu(topMenu); +} + +public void GOKZ_OnOptionsMenuReady(TopMenu topMenu) +{ + OnOptionsMenuReady_Options(); + OnOptionsMenuReady_OptionsMenu(topMenu); +} + +public void GOKZ_RC_OnRaceInfoChanged(int raceID, RaceInfo prop, int oldValue, int newValue) +{ + OnRaceInfoChanged_RacingText(raceID, prop, newValue); +} + + + +// =====[ PRIVATE ]===== + +static void HookEvents() +{ + HookEvent("player_spawn", OnPlayerSpawn, EventHookMode_Post); + HookEvent("player_death", OnPlayerDeath, EventHookMode_Pre); +} + +static void SetHUDInfo(KZPlayer player, HUDInfo info, int cmdnum) +{ + info.TimerRunning = player.TimerRunning; + info.TimeType = player.TimeType; + info.Time = player.Time; + info.Paused = player.Paused; + info.OnGround = player.OnGround; + info.OnLadder = player.OnLadder; + info.Noclipping = player.Noclipping; + info.Ducking = Movement_GetDucking(player.ID); + info.HitBhop = (Movement_GetJumped(player.ID) && Movement_GetTakeoffCmdNum(player.ID) == cmdnum) && Movement_GetTakeoffCmdNum(player.ID) - Movement_GetLandingCmdNum(player.ID) <= HUD_MAX_BHOP_GROUND_TICKS; + info.Speed = player.Speed; + info.ID = player.ID; + info.Jumped = player.Jumped; + info.HitPerf = player.GOKZHitPerf; + info.HitJB = gB_JBTakeoff[info.ID]; + info.TakeoffSpeed = player.GOKZTakeoffSpeed; + info.IsTakeoff = Movement_GetTakeoffCmdNum(player.ID) == cmdnum; + info.Buttons = player.Buttons; + info.CurrentTeleport = player.TeleportCount; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-hud/commands.sp b/sourcemod/scripting/gokz-hud/commands.sp new file mode 100644 index 0000000..fc5ed4e --- /dev/null +++ b/sourcemod/scripting/gokz-hud/commands.sp @@ -0,0 +1,116 @@ +void RegisterCommands() +{ + RegConsoleCmd("sm_menu", CommandMenu, "[KZ] Toggle the simple teleport menu."); + RegConsoleCmd("sm_cpmenu", CommandMenu, "[KZ] Toggle the simple teleport menu."); + RegConsoleCmd("sm_adv", CommandToggleAdvancedMenu, "[KZ] Toggle the advanced teleport menu."); + RegConsoleCmd("sm_panel", CommandToggleInfoPanel, "[KZ] Toggle visibility of the centre information panel."); + RegConsoleCmd("sm_timerstyle", CommandToggleTimerStyle, "[KZ] Toggle the style of the timer text."); + RegConsoleCmd("sm_timertype", CommandToggleTimerType, "[KZ] Toggle visibility of your time type."); + RegConsoleCmd("sm_speed", CommandToggleSpeed, "[KZ] Toggle visibility of your speed and jump pre-speed."); + RegConsoleCmd("sm_hideweapon", CommandToggleShowWeapon, "[KZ] Toggle visibility of your weapon."); +} + +public Action CommandMenu(int client, int args) +{ + if (GOKZ_HUD_GetOption(client, HUDOption_TPMenu) != TPMenu_Disabled) + { + GOKZ_HUD_SetOption(client, HUDOption_TPMenu, TPMenu_Disabled); + } + else + { + GOKZ_HUD_SetOption(client, HUDOption_TPMenu, TPMenu_Simple); + } + return Plugin_Handled; +} + +public Action CommandToggleAdvancedMenu(int client, int args) +{ + if (GOKZ_HUD_GetOption(client, HUDOption_TPMenu) != TPMenu_Advanced) + { + GOKZ_HUD_SetOption(client, HUDOption_TPMenu, TPMenu_Advanced); + } + else + { + GOKZ_HUD_SetOption(client, HUDOption_TPMenu, TPMenu_Simple); + } + return Plugin_Handled; +} + +public Action CommandToggleInfoPanel(int client, int args) +{ + if (GOKZ_HUD_GetOption(client, HUDOption_InfoPanel) == InfoPanel_Disabled) + { + GOKZ_HUD_SetOption(client, HUDOption_InfoPanel, InfoPanel_Enabled); + } + else + { + GOKZ_HUD_SetOption(client, HUDOption_InfoPanel, InfoPanel_Disabled); + } + return Plugin_Handled; +} + +public Action CommandToggleTimerStyle(int client, int args) +{ + if (GOKZ_HUD_GetOption(client, HUDOption_TimerStyle) == TimerStyle_Standard) + { + GOKZ_HUD_SetOption(client, HUDOption_TimerStyle, TimerStyle_Precise); + } + else + { + GOKZ_HUD_SetOption(client, HUDOption_TimerStyle, TimerStyle_Standard); + } + return Plugin_Handled; +} + +public Action CommandToggleTimerType(int client, int args) +{ + if (GOKZ_HUD_GetOption(client, HUDOption_TimerType) == TimerType_Disabled) + { + GOKZ_HUD_SetOption(client, HUDOption_TimerType, TimerType_Enabled); + } + else + { + GOKZ_HUD_SetOption(client, HUDOption_TimerType, TimerType_Disabled); + } + return Plugin_Handled; +} + +public Action CommandToggleSpeed(int client, int args) +{ + int speedText = GOKZ_HUD_GetOption(client, HUDOption_SpeedText); + int infoPanel = GOKZ_HUD_GetOption(client, HUDOption_InfoPanel); + + if (speedText == SpeedText_Disabled) + { + if (infoPanel == InfoPanel_Enabled) + { + GOKZ_HUD_SetOption(client, HUDOption_SpeedText, SpeedText_InfoPanel); + } + else + { + GOKZ_HUD_SetOption(client, HUDOption_SpeedText, SpeedText_Bottom); + } + } + else if (infoPanel == InfoPanel_Disabled && speedText == SpeedText_InfoPanel) + { + GOKZ_HUD_SetOption(client, HUDOption_SpeedText, SpeedText_Bottom); + } + else + { + GOKZ_HUD_SetOption(client, HUDOption_SpeedText, SpeedText_Disabled); + } + return Plugin_Handled; +} + +public Action CommandToggleShowWeapon(int client, int args) +{ + if (GOKZ_HUD_GetOption(client, HUDOption_ShowWeapon) == ShowWeapon_Disabled) + { + GOKZ_HUD_SetOption(client, HUDOption_ShowWeapon, ShowWeapon_Enabled); + } + else + { + GOKZ_HUD_SetOption(client, HUDOption_ShowWeapon, ShowWeapon_Disabled); + } + return Plugin_Handled; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-hud/hide_weapon.sp b/sourcemod/scripting/gokz-hud/hide_weapon.sp new file mode 100644 index 0000000..b290d8f --- /dev/null +++ b/sourcemod/scripting/gokz-hud/hide_weapon.sp @@ -0,0 +1,30 @@ +/* + Hides weapon view model. +*/ + + + +// =====[ EVENTS ]===== + +void OnPlayerSpawn_HideWeapon(int client) +{ + UpdateHideWeapon(client); +} + +void OnOptionChanged_HideWeapon(int client, HUDOption option) +{ + if (option == HUDOption_ShowWeapon) + { + UpdateHideWeapon(client); + } +} + + + +// =====[ PRIVATE ]===== + +static void UpdateHideWeapon(int client) +{ + SetEntProp(client, Prop_Send, "m_bDrawViewmodel", + GOKZ_HUD_GetOption(client, HUDOption_ShowWeapon) == ShowWeapon_Enabled); +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-hud/info_panel.sp b/sourcemod/scripting/gokz-hud/info_panel.sp new file mode 100644 index 0000000..3563404 --- /dev/null +++ b/sourcemod/scripting/gokz-hud/info_panel.sp @@ -0,0 +1,307 @@ +/* + Displays information using hint text. + + This is manually refreshed whenever player has taken off so that they see + their pre-speed as soon as possible, improving responsiveness. +*/ + + + +static bool infoPanelDuckPressedLast[MAXPLAYERS + 1]; +static bool infoPanelOnGroundLast[MAXPLAYERS + 1]; +static bool infoPanelShowDuckString[MAXPLAYERS + 1]; + + +// =====[ PUBLIC ]===== + +bool IsDrawingInfoPanel(int client) +{ + KZPlayer player = KZPlayer(client); + return player.InfoPanel != InfoPanel_Disabled + && !NothingEnabledInInfoPanel(player); +} + + + +// =====[ EVENTS ]===== + +void OnPlayerRunCmdPost_InfoPanel(int client, int cmdnum, HUDInfo info) +{ + int updateSpeed = gB_FastUpdateRate[client] ? 1 : 10; + if (cmdnum % updateSpeed == 0 || info.IsTakeoff) + { + UpdateInfoPanel(client, info); + } + infoPanelOnGroundLast[info.ID] = info.OnGround; + infoPanelDuckPressedLast[info.ID] = info.Ducking; +} + + + +// =====[ PRIVATE ]===== + +static void UpdateInfoPanel(int client, HUDInfo info) +{ + KZPlayer player = KZPlayer(client); + + if (player.Fake || !IsDrawingInfoPanel(player.ID)) + { + return; + } + char infoPanelText[512]; + FormatEx(infoPanelText, sizeof(infoPanelText), GetInfoPanel(player, info)); + if (infoPanelText[0] != '\0') + { + PrintCSGOHUDText(player.ID, infoPanelText); + } +} + +static bool NothingEnabledInInfoPanel(KZPlayer player) +{ + bool noTimerText = player.TimerText != TimerText_InfoPanel; + bool noSpeedText = player.SpeedText != SpeedText_InfoPanel || player.Paused; + bool noKeys = player.ShowKeys == ShowKeys_Disabled + || player.ShowKeys == ShowKeys_Spectating && player.Alive; + return noTimerText && noSpeedText && noKeys; +} + +static char[] GetInfoPanel(KZPlayer player, HUDInfo info) +{ + char infoPanelText[512]; + FormatEx(infoPanelText, sizeof(infoPanelText), + "%s%s%s%s", + GetSpectatorString(player, info), + GetTimeString(player, info), + GetSpeedString(player, info), + GetKeysString(player, info)); + if (infoPanelText[0] == '\0') + { + return infoPanelText; + } + else + { + Format(infoPanelText, sizeof(infoPanelText), "<font color='#ffffff08'>%s", infoPanelText); + } + TrimString(infoPanelText); + return infoPanelText; +} + +static char[] GetSpectatorString(KZPlayer player, HUDInfo info) +{ + char spectatorString[255]; + if (player.SpecListPosition != SpecListPosition_InfoPanel || player.ShowSpectators == ShowSpecs_Disabled) + { + return spectatorString; + } + // Only return something if the player is alive or observing someone else + if (player.Alive || player.ObserverTarget != -1) + { + FormatEx(spectatorString, sizeof(spectatorString), "%s", FormatSpectatorTextForInfoPanel(player, KZPlayer(info.ID))); + } + return spectatorString; +} + +static char[] GetTimeString(KZPlayer player, HUDInfo info) +{ + char timeString[128]; + if (player.TimerText != TimerText_InfoPanel) + { + timeString = ""; + } + else if (info.TimerRunning) + { + if (player.GetHUDOption(HUDOption_TimerType) == TimerType_Enabled) + { + switch (info.TimeType) + { + case TimeType_Nub: + { + FormatEx(timeString, sizeof(timeString), + "%T: <font color='#ead18a'>%s</font> %s\n", + "Info Panel Text - Time", player.ID, + GOKZ_HUD_FormatTime(player.ID, info.Time), + GetPausedString(player, info)); + } + case TimeType_Pro: + { + FormatEx(timeString, sizeof(timeString), + "%T: <font color='#b5d4ee'>%s</font> %s\n", + "Info Panel Text - Time", player.ID, + GOKZ_HUD_FormatTime(player.ID, info.Time), + GetPausedString(player, info)); + } + } + } + else + { + FormatEx(timeString, sizeof(timeString), + "%T: <font color='#ffffff'>%s</font> %s\n", + "Info Panel Text - Time", player.ID, + GOKZ_HUD_FormatTime(player.ID, info.Time), + GetPausedString(player, info)); + } + } + else + { + FormatEx(timeString, sizeof(timeString), + "%T: <font color='#ea4141'>%T</font> %s\n", + "Info Panel Text - Time", player.ID, + "Info Panel Text - Stopped", player.ID, + GetPausedString(player, info)); + } + return timeString; +} + +static char[] GetPausedString(KZPlayer player, HUDInfo info) +{ + char pausedString[64]; + if (info.Paused) + { + FormatEx(pausedString, sizeof(pausedString), + "(<font color='#ffffff'>%T</font>)", + "Info Panel Text - PAUSED", player.ID); + } + else + { + pausedString = ""; + } + return pausedString; +} + +static char[] GetSpeedString(KZPlayer player, HUDInfo info) +{ + char speedString[128]; + if (player.SpeedText != SpeedText_InfoPanel || info.Paused) + { + speedString = ""; + } + else + { + if (info.OnGround || info.OnLadder || info.Noclipping) + { + FormatEx(speedString, sizeof(speedString), + "%T: <font color='#ffffff'>%.0f</font> u/s\n", + "Info Panel Text - Speed", player.ID, + RoundToPowerOfTen(info.Speed, -2)); + infoPanelShowDuckString[info.ID] = false; + } + else + { + if (GOKZ_HUD_GetOption(player.ID, HUDOption_DeadstrafeColor) == DeadstrafeColor_Enabled + && Movement_GetVerticalVelocity(info.ID) > 0.0 && Movement_GetVerticalVelocity(info.ID) < 140.0) + { + FormatEx(speedString, sizeof(speedString), + "%T: <font color='#ff2020'>%.0f</font> %s\n", + "Info Panel Text - Speed", player.ID, + RoundToPowerOfTen(info.Speed, -2), + GetTakeoffString(info)); + } + else + { + FormatEx(speedString, sizeof(speedString), + "%T: <font color='#ffffff'>%.0f</font> %s\n", + "Info Panel Text - Speed", player.ID, + RoundToPowerOfTen(info.Speed, -2), + GetTakeoffString(info)); + } + } + } + return speedString; +} + +static char[] GetTakeoffString(HUDInfo info) +{ + char takeoffString[96], duckString[32]; + + if (infoPanelShowDuckString[info.ID] + || (infoPanelOnGroundLast[info.ID] + && !info.HitBhop + && info.IsTakeoff + && info.Jumped + && info.Ducking + && (infoPanelDuckPressedLast[info.ID] || GOKZ_GetCoreOption(info.ID, Option_Mode) == Mode_Vanilla))) + { + duckString = " <font color='#71eeb8'>C</font>"; + infoPanelShowDuckString[info.ID] = true; + } + else + { + duckString = ""; + infoPanelShowDuckString[info.ID] = false; + } + + if (info.HitJB) + { + FormatEx(takeoffString, sizeof(takeoffString), + "(<font color='#ffff20'>%.0f</font>)%s", + RoundToPowerOfTen(info.TakeoffSpeed, -2), + duckString); + } + else if (info.HitPerf) + { + FormatEx(takeoffString, sizeof(takeoffString), + "(<font color='#40ff40'>%.0f</font>)%s", + RoundToPowerOfTen(info.TakeoffSpeed, -2), + duckString); + } + else + { + FormatEx(takeoffString, sizeof(takeoffString), + "(<font color='#ffffff'>%.0f</font>)%s", + RoundToPowerOfTen(info.TakeoffSpeed, -2), + duckString); + } + return takeoffString; +} + +static char[] GetKeysString(KZPlayer player, HUDInfo info) +{ + char keysString[64]; + if (player.ShowKeys == ShowKeys_Disabled) + { + keysString = ""; + } + else if (player.ShowKeys == ShowKeys_Spectating && player.Alive) + { + keysString = ""; + } + else + { + int buttons = info.Buttons; + FormatEx(keysString, sizeof(keysString), + "%T: <font color='#ffffff'>%c %c %c %c %c %c</font>\n", + "Info Panel Text - Keys", player.ID, + buttons & IN_MOVELEFT ? 'A' : '_', + buttons & IN_FORWARD ? 'W' : '_', + buttons & IN_BACK ? 'S' : '_', + buttons & IN_MOVERIGHT ? 'D' : '_', + buttons & IN_DUCK ? 'C' : '_', + buttons & IN_JUMP ? 'J' : '_'); + } + return keysString; +} + +// Credits to Franc1sco (https://github.com/Franc1sco/FixHintColorMessages) +void PrintCSGOHUDText(int client, const char[] format) +{ + char buff[HUD_MAX_HINT_SIZE]; + Format(buff, sizeof(buff), "</font>%s", format); + + for (int i = strlen(buff); i < sizeof(buff) - 1; i++) + { + buff[i] = ' '; + } + + buff[sizeof(buff) - 1] = '\0'; + + Protobuf pb = view_as<Protobuf>(StartMessageOne("TextMsg", client, USERMSG_BLOCKHOOKS)); + pb.SetInt("msg_dst", 4); + pb.AddString("params", "#SFUI_ContractKillStart"); + pb.AddString("params", buff); + pb.AddString("params", NULL_STRING); + pb.AddString("params", NULL_STRING); + pb.AddString("params", NULL_STRING); + pb.AddString("params", NULL_STRING); + + EndMessage(); +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-hud/menu.sp b/sourcemod/scripting/gokz-hud/menu.sp new file mode 100644 index 0000000..4b7259e --- /dev/null +++ b/sourcemod/scripting/gokz-hud/menu.sp @@ -0,0 +1,96 @@ +/* + Tracks whether a GOKZ HUD menu or panel element is being shown to the client. +*/ + + + +// Update the TP menu i.e. item text, item disabled/enabled +void CancelGOKZHUDMenu(int client) +{ + // Only cancel the menu if we know it's the TP menu + if (gB_MenuShowing[client]) + { + CancelClientMenu(client); + } +} + + + +// =====[ EVENTS ]===== + +void OnPlayerSpawn_Menu(int client) +{ + CancelGOKZHUDMenu(client); +} + +void OnOptionChanged_Menu(int client, HUDOption option) +{ + if (option == HUDOption_TPMenu || option == HUDOption_TimerText) + { + CancelGOKZHUDMenu(client); + } +} + +void OnTimerStart_Menu(int client) +{ + // Prevent the menu from getting cancelled every tick if player use start timer button zone. + if (GOKZ_GetTime(client) > 0.0) + { + CancelGOKZHUDMenu(client); + } +} + +void OnTimerEnd_Menu(int client) +{ + CancelGOKZHUDMenu(client); +} + +void OnTimerStopped_Menu(int client) +{ + CancelGOKZHUDMenu(client); +} + +void OnPause_Menu(int client) +{ + CancelGOKZHUDMenu(client); +} + +void OnResume_Menu(int client) +{ + CancelGOKZHUDMenu(client); +} + +void OnMakeCheckpoint_Menu(int client) +{ + CancelGOKZHUDMenu(client); +} + +void OnCountedTeleport_Menu(int client) +{ + CancelGOKZHUDMenu(client); +} + +void OnJoinTeam_Menu(int client) +{ + CancelGOKZHUDMenu(client); +} + +void OnStartPositionSet_Menu(int client) +{ + // Prevent the menu from getting cancelled every tick if player use start timer button zone. + if (GOKZ_GetTime(client) > 0.0) + { + CancelGOKZHUDMenu(client); + } +} + +void OnPluginEnd_Menu() +{ + for (int client = 1; client <= MaxClients; client++) + { + if (IsValidClient(client)) + { + CancelGOKZHUDMenu(client); + } + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-hud/natives.sp b/sourcemod/scripting/gokz-hud/natives.sp new file mode 100644 index 0000000..bb877e2 --- /dev/null +++ b/sourcemod/scripting/gokz-hud/natives.sp @@ -0,0 +1,33 @@ +void CreateNatives() +{ + CreateNative("GOKZ_HUD_ForceUpdateTPMenu", Native_ForceUpdateTPMenu); + CreateNative("GOKZ_HUD_GetMenuShowing", Native_GetMenuShowing); + CreateNative("GOKZ_HUD_SetMenuShowing", Native_SetMenuShowing); + CreateNative("GOKZ_HUD_GetMenuSpectatorText", Native_GetSpectatorText); +} + +public int Native_ForceUpdateTPMenu(Handle plugin, int numParams) +{ + SetForceUpdateTPMenu(GetNativeCell(1)); + return 0; +} + +public int Native_GetMenuShowing(Handle plugin, int numParams) +{ + return view_as<int>(gB_MenuShowing[GetNativeCell(1)]); +} + +public int Native_SetMenuShowing(Handle plugin, int numParams) +{ + gB_MenuShowing[GetNativeCell(1)] = view_as<bool>(GetNativeCell(2)); + return 0; +} + +public int Native_GetSpectatorText(Handle plugin, int numParams) +{ + HUDInfo info; + GetNativeArray(2, info, sizeof(HUDInfo)); + KZPlayer player = KZPlayer(GetNativeCell(1)); + FormatNativeString(3, 0, 0, GetNativeCell(4), _, "", FormatSpectatorTextForMenu(player, info)); + return 0; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-hud/options.sp b/sourcemod/scripting/gokz-hud/options.sp new file mode 100644 index 0000000..84bbf2b --- /dev/null +++ b/sourcemod/scripting/gokz-hud/options.sp @@ -0,0 +1,190 @@ +/* + Options for controlling appearance and behaviour of HUD and UI. +*/ + + + +// =====[ EVENTS ]===== + +void OnOptionsMenuReady_Options() +{ + RegisterOptions(); +} + +void OnOptionChanged_Options(int client, HUDOption option, any newValue) +{ + PrintOptionChangeMessage(client, option, newValue); +} + + + +// =====[ PRIVATE ]===== + +static void RegisterOptions() +{ + for (HUDOption option; option < HUDOPTION_COUNT; option++) + { + GOKZ_RegisterOption(gC_HUDOptionNames[option], gC_HUDOptionDescriptions[option], + OptionType_Int, gI_HUDOptionDefaults[option], 0, gI_HUDOptionCounts[option] - 1); + } +} + +static void PrintOptionChangeMessage(int client, HUDOption option, any newValue) +{ + // NOTE: Not all options have a message for when they are changed. + switch (option) + { + case HUDOption_TPMenu: + { + switch (newValue) + { + case TPMenu_Disabled: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Teleport Menu - Disable"); + } + case TPMenu_Simple: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Teleport Menu - Enable (Simple)"); + } + case TPMenu_Advanced: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Teleport Menu - Enable (Advanced)"); + } + } + } + case HUDOption_InfoPanel: + { + switch (newValue) + { + case InfoPanel_Disabled: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Info Panel - Disable"); + } + case InfoPanel_Enabled: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Info Panel - Enable"); + } + } + } + case HUDOption_TimerStyle: + { + switch (newValue) + { + case TimerStyle_Standard: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Timer Style - Standard"); + } + case TimerStyle_Precise: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Timer Style - Precise"); + } + } + } + case HUDOption_TimerType: + { + switch (newValue) + { + case TimerType_Disabled: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Timer Type - Disabled"); + } + case TimerType_Enabled: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Timer Type - Enabled"); + } + } + } + case HUDOption_ShowWeapon: + { + switch (newValue) + { + case ShowWeapon_Disabled: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Show Weapon - Disable"); + } + case ShowWeapon_Enabled: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Show Weapon - Enable"); + } + } + } + case HUDOption_ShowControls: + { + switch (newValue) + { + case ReplayControls_Disabled: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Show Controls - Disable"); + } + case ReplayControls_Enabled: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Show Controls - Enable"); + } + } + } + case HUDOption_DeadstrafeColor: + { + switch (newValue) + { + case DeadstrafeColor_Disabled: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Dead Strafe - Disable"); + } + case DeadstrafeColor_Enabled: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Dead Strafe - Enable"); + } + } + } + case HUDOption_ShowSpectators: + { + switch (newValue) + { + case ShowSpecs_Disabled: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Show Spectators - Disable"); + } + case ShowSpecs_Number: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Show Spectators - Number"); + } + case ShowSpecs_Full: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Show Spectators - Full"); + } + } + } + case HUDOption_SpecListPosition: + { + switch (newValue) + { + case SpecListPosition_InfoPanel: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Spectator List Position - Info Panel"); + } + case SpecListPosition_TPMenu: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Spectator List Position - TP Menu"); + } + } + } + case HUDOption_DynamicMenu: + { + switch (newValue) + { + case DynamicMenu_Legacy: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Dynamic Menu - Legacy"); + } + case DynamicMenu_Disabled: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Dynamic Menu - Disable"); + } + case DynamicMenu_Enabled: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Dynamic Menu - Enable"); + } + } + } + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-hud/options_menu.sp b/sourcemod/scripting/gokz-hud/options_menu.sp new file mode 100644 index 0000000..705df27 --- /dev/null +++ b/sourcemod/scripting/gokz-hud/options_menu.sp @@ -0,0 +1,181 @@ +static TopMenu optionsTopMenu; +static TopMenuObject catHUD; +static TopMenuObject itemsHUD[HUDOPTION_COUNT]; + + + +// =====[ EVENTS ]===== + +void OnOptionsMenuCreated_OptionsMenu(TopMenu topMenu) +{ + if (optionsTopMenu == topMenu && catHUD != INVALID_TOPMENUOBJECT) + { + return; + } + + catHUD = topMenu.AddCategory(HUD_OPTION_CATEGORY, TopMenuHandler_Categories); +} + +void OnOptionsMenuReady_OptionsMenu(TopMenu topMenu) +{ + // Make sure category exists + if (catHUD == INVALID_TOPMENUOBJECT) + { + GOKZ_OnOptionsMenuCreated(topMenu); + } + + if (optionsTopMenu == topMenu) + { + return; + } + + optionsTopMenu = topMenu; + + // Add HUD option items + for (int option = 0; option < view_as<int>(HUDOPTION_COUNT); option++) + { + itemsHUD[option] = optionsTopMenu.AddItem(gC_HUDOptionNames[option], TopMenuHandler_HUD, catHUD); + } +} + +public void TopMenuHandler_Categories(TopMenu topmenu, TopMenuAction action, TopMenuObject topobj_id, int param, char[] buffer, int maxlength) +{ + if (action == TopMenuAction_DisplayOption || action == TopMenuAction_DisplayTitle) + { + if (topobj_id == catHUD) + { + Format(buffer, maxlength, "%T", "Options Menu - HUD", param); + } + } +} + +public void TopMenuHandler_HUD(TopMenu topmenu, TopMenuAction action, TopMenuObject topobj_id, int param, char[] buffer, int maxlength) +{ + HUDOption option = HUDOPTION_INVALID; + for (int i = 0; i < view_as<int>(HUDOPTION_COUNT); i++) + { + if (topobj_id == itemsHUD[i]) + { + option = view_as<HUDOption>(i); + break; + } + } + + if (option == HUDOPTION_INVALID) + { + return; + } + + if (action == TopMenuAction_DisplayOption) + { + switch (option) + { + case HUDOption_TPMenu: + { + FormatEx(buffer, maxlength, "%T - %T", + gC_HUDOptionPhrases[option], param, + gC_TPMenuPhrases[GOKZ_HUD_GetOption(param, option)], param); + } + case HUDOption_ShowKeys: + { + FormatEx(buffer, maxlength, "%T - %T", + gC_HUDOptionPhrases[option], param, + gC_ShowKeysPhrases[GOKZ_HUD_GetOption(param, option)], param); + } + case HUDOption_TimerText: + { + FormatEx(buffer, maxlength, "%T - %T", + gC_HUDOptionPhrases[option], param, + gC_TimerTextPhrases[GOKZ_HUD_GetOption(param, option)], param); + } + case HUDOption_TimerStyle: + { + int optionValue = GOKZ_HUD_GetOption(param, option); + if (optionValue == TimerStyle_Precise) + { + FormatEx(buffer, maxlength, "%T - 01:23.45", + gC_HUDOptionPhrases[option], param); + } + else + { + FormatEx(buffer, maxlength, "%T - 1:23", + gC_HUDOptionPhrases[option], param); + } + } + case HUDOption_TimerType: + { + FormatEx(buffer, maxlength, "%T - %T", + gC_HUDOptionPhrases[option], param, + gC_TimerTypePhrases[GOKZ_HUD_GetOption(param, option)], param); + } + case HUDOption_SpeedText: + { + FormatEx(buffer, maxlength, "%T - %T", + gC_HUDOptionPhrases[option], param, + gC_SpeedTextPhrases[GOKZ_HUD_GetOption(param, option)], param); + } + case HUDOption_ShowControls: + { + FormatEx(buffer, maxlength, "%T - %T", + gC_HUDOptionPhrases[option], param, + gC_ShowControlsPhrases[GOKZ_HUD_GetOption(param, option)], param); + } + case HUDOption_DeadstrafeColor: + { + FormatEx(buffer, maxlength, "%T - %T", + gC_HUDOptionPhrases[option], param, + gC_DeadstrafeColorPhrases[GOKZ_HUD_GetOption(param, option)], param); + } + case HUDOption_UpdateRate: + { + FormatEx(buffer, maxlength, "%T - %T", + gC_HUDOptionPhrases[option], param, + gC_HUDUpdateRatePhrases[GOKZ_HUD_GetOption(param, option)], param); + } + case HUDOption_ShowSpectators: + { + FormatEx(buffer, maxlength, "%T - %T", + gC_HUDOptionPhrases[option], param, + gC_ShowSpecsPhrases[GOKZ_HUD_GetOption(param, option)], param); + } + case HUDOption_SpecListPosition: + { + FormatEx(buffer, maxlength, "%T - %T", + gC_HUDOptionPhrases[option], param, + gC_SpecListPositionPhrases[GOKZ_HUD_GetOption(param, option)], param); + } + case HUDOption_DynamicMenu: + { + FormatEx(buffer, maxlength, "%T - %T", + gC_HUDOptionPhrases[option], param, + gC_DynamicMenuPhrases[GOKZ_HUD_GetOption(param, option)], param); + } + default:FormatToggleableOptionDisplay(param, option, buffer, maxlength); + } + } + else if (action == TopMenuAction_SelectOption) + { + GOKZ_HUD_CycleOption(param, option); + optionsTopMenu.Display(param, TopMenuPosition_LastCategory); + } +} + + + +// =====[ PRIVATE ]===== + +static void FormatToggleableOptionDisplay(int client, HUDOption option, char[] buffer, int maxlength) +{ + if (GOKZ_HUD_GetOption(client, option) == 0) + { + FormatEx(buffer, maxlength, "%T - %T", + gC_HUDOptionPhrases[option], client, + "Options Menu - Disabled", client); + } + else + { + FormatEx(buffer, maxlength, "%T - %T", + gC_HUDOptionPhrases[option], client, + "Options Menu - Enabled", client); + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-hud/racing_text.sp b/sourcemod/scripting/gokz-hud/racing_text.sp new file mode 100644 index 0000000..ac6ea3d --- /dev/null +++ b/sourcemod/scripting/gokz-hud/racing_text.sp @@ -0,0 +1,167 @@ +/* + Uses HUD text to show the race countdown and a start message. + + This is manually refreshed when a race starts to show the start message as + soon as possible, improving responsiveness. +*/ + + + +static Handle racingHudSynchronizer; +static float countdownStartTime[MAXPLAYERS + 1]; + + + +// =====[ EVENTS ]===== + +void OnPluginStart_RacingText() +{ + racingHudSynchronizer = CreateHudSynchronizer(); +} + +void OnPlayerRunCmdPost_RacingText(int client, int cmdnum) +{ + int updateSpeed = gB_FastUpdateRate[client] ? 3 : 6; + if (gB_GOKZRacing && cmdnum % updateSpeed == 2) + { + UpdateRacingText(client); + } +} + +void OnRaceInfoChanged_RacingText(int raceID, RaceInfo prop, int newValue) +{ + if (prop != RaceInfo_Status) + { + return; + } + + if (newValue == RaceStatus_Countdown) + { + for (int client = 1; client <= MaxClients; client++) + { + if (GOKZ_RC_GetRaceID(client) == raceID) + { + countdownStartTime[client] = GetGameTime(); + } + } + } + else if (newValue == RaceStatus_Aborting) + { + for (int client = 1; client <= MaxClients; client++) + { + if (GOKZ_RC_GetRaceID(client) == raceID) + { + ClearRacingText(client); + } + } + } + else if (newValue == RaceStatus_Started) + { + for (int client = 1; client <= MaxClients; client++) + { + if (GOKZ_RC_GetRaceID(client) == raceID) + { + UpdateRacingText(client); + } + } + } +} + + + +// =====[ PRIVATE ]===== + +static void UpdateRacingText(int client) +{ + KZPlayer player = KZPlayer(client); + + if (player.Fake) + { + return; + } + + if (player.Alive) + { + ShowRacingText(player, player); + } + else + { + KZPlayer targetPlayer = KZPlayer(player.ObserverTarget); + if (targetPlayer.ID != -1 && !targetPlayer.Fake) + { + ShowRacingText(player, targetPlayer); + } + } +} + +static void ClearRacingText(int client) +{ + ClearSyncHud(client, racingHudSynchronizer); +} + +static void ShowRacingText(KZPlayer player, KZPlayer targetPlayer) +{ + if (GOKZ_RC_GetStatus(targetPlayer.ID) != RacerStatus_Racing) + { + return; + } + + int raceStatus = GOKZ_RC_GetRaceInfo(GOKZ_RC_GetRaceID(targetPlayer.ID), RaceInfo_Status); + if (raceStatus == RaceStatus_Countdown) + { + ShowCountdownText(player, targetPlayer); + } + else if (raceStatus == RaceStatus_Started) + { + ShowStartedText(player, targetPlayer); + } +} + +static void ShowCountdownText(KZPlayer player, KZPlayer targetPlayer) +{ + float timeToStart = (countdownStartTime[targetPlayer.ID] + RC_COUNTDOWN_TIME) - GetGameTime(); + int colour[4]; + GetCountdownColour(timeToStart, colour); + + SetHudTextParams(-1.0, 0.3, GetTextHoldTime(gB_FastUpdateRate[player.ID] ? 3 : 6), colour[0], colour[1], colour[2], colour[3], 0, 1.0, 0.0, 0.0); + ShowSyncHudText(player.ID, racingHudSynchronizer, "%t\n\n%d", "Get Ready", IntMax(RoundToCeil(timeToStart), 1)); +} + +static void GetCountdownColour(float timeToStart, int buffer[4]) +{ + // From red to green + if (timeToStart >= RC_COUNTDOWN_TIME) + { + buffer[0] = 255; + buffer[1] = 0; + } + else if (timeToStart > RC_COUNTDOWN_TIME / 2.0) + { + buffer[0] = 255; + buffer[1] = RoundFloat(-510.0 / RC_COUNTDOWN_TIME * timeToStart + 510.0); + } + else if (timeToStart > 0.0) + { + buffer[0] = RoundFloat(510.0 / RC_COUNTDOWN_TIME * timeToStart); + buffer[1] = 255; + } + else + { + buffer[0] = 0; + buffer[1] = 255; + } + + buffer[2] = 0; + buffer[3] = 255; +} + +static void ShowStartedText(KZPlayer player, KZPlayer targetPlayer) +{ + if (targetPlayer.TimerRunning) + { + return; + } + + SetHudTextParams(-1.0, 0.3, GetTextHoldTime(gB_FastUpdateRate[player.ID] ? 3 : 6), 0, 255, 0, 255, 0, 1.0, 0.0, 0.0); + ShowSyncHudText(player.ID, racingHudSynchronizer, "%t", "Go!"); +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-hud/spectate_text.sp b/sourcemod/scripting/gokz-hud/spectate_text.sp new file mode 100644 index 0000000..9700c38 --- /dev/null +++ b/sourcemod/scripting/gokz-hud/spectate_text.sp @@ -0,0 +1,119 @@ +/* + Responsible for spectator list on the HUD. +*/ + +#define SPECATATOR_LIST_MAX_COUNT 5 + +// =====[ PUBLIC ]===== + +char[] FormatSpectatorTextForMenu(KZPlayer player, HUDInfo info) +{ + int specCount; + char spectatorTextString[224]; + if (player.GetHUDOption(HUDOption_ShowSpectators) >= ShowSpecs_Number) + { + for (int i = 1; i <= MaxClients; i++) + { + if (gI_ObserverTarget[i] == info.ID) + { + specCount++; + if (player.GetHUDOption(HUDOption_ShowSpectators) == ShowSpecs_Full) + { + char buffer[64]; + if (specCount < SPECATATOR_LIST_MAX_COUNT) + { + GetClientName(i, buffer, sizeof(buffer)); + Format(spectatorTextString, sizeof(spectatorTextString), "%s\n%s", spectatorTextString, buffer); + } + else if (specCount == SPECATATOR_LIST_MAX_COUNT) + { + StrCat(spectatorTextString, sizeof(spectatorTextString), "\n..."); + } + } + } + } + if (specCount > 0) + { + if (player.GetHUDOption(HUDOption_ShowSpectators) == ShowSpecs_Full) + { + Format(spectatorTextString, sizeof(spectatorTextString), "%t\n ", "Spectator List - Menu (Full)", specCount, spectatorTextString); + } + else + { + Format(spectatorTextString, sizeof(spectatorTextString), "%t\n ", "Spectator List - Menu (Number)", specCount); + } + } + else + { + FormatEx(spectatorTextString, sizeof(spectatorTextString), ""); + } + } + return spectatorTextString; +} + +char[] FormatSpectatorTextForInfoPanel(KZPlayer player, KZPlayer targetPlayer) +{ + int specCount; + char spectatorTextString[160]; + if (player.GetHUDOption(HUDOption_ShowSpectators) >= ShowSpecs_Number) + { + for (int i = 1; i <= MaxClients; i++) + { + if (gI_ObserverTarget[i] == targetPlayer.ID) + { + specCount++; + if (player.GetHUDOption(HUDOption_ShowSpectators) == ShowSpecs_Full) + { + char buffer[64]; + if (specCount < SPECATATOR_LIST_MAX_COUNT) + { + GetClientName(i, buffer, sizeof(buffer)); + if (specCount == 1) + { + Format(spectatorTextString, sizeof(spectatorTextString), "%s", buffer); + } + else + { + Format(spectatorTextString, sizeof(spectatorTextString), "%s, %s", spectatorTextString, buffer); + } + } + else if (specCount == SPECATATOR_LIST_MAX_COUNT) + { + Format(spectatorTextString, sizeof(spectatorTextString), " ..."); + } + } + } + } + if (specCount > 0) + { + if (player.GetHUDOption(HUDOption_ShowSpectators) == ShowSpecs_Full) + { + Format(spectatorTextString, sizeof(spectatorTextString), "%t\n", "Spectator List - Info Panel (Full)", specCount, spectatorTextString); + } + else + { + Format(spectatorTextString, sizeof(spectatorTextString), "%t\n", "Spectator List - Info Panel (Number)", specCount); + } + } + else + { + FormatEx(spectatorTextString, sizeof(spectatorTextString), ""); + } + } + return spectatorTextString; +} + +void UpdateSpecList() +{ + for (int client = 1; client <= MaxClients; client++) + { + if (IsValidClient(client) && !IsFakeClient(client)) + { + gI_ObserverTarget[client] = GetObserverTarget(client); + } + else + { + gI_ObserverTarget[client] = -1; + } + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-hud/speed_text.sp b/sourcemod/scripting/gokz-hud/speed_text.sp new file mode 100644 index 0000000..3f83949 --- /dev/null +++ b/sourcemod/scripting/gokz-hud/speed_text.sp @@ -0,0 +1,141 @@ +/* + Uses HUD text to show current speed somewhere on the screen. + + This is manually refreshed whenever player has taken off so that they see + their pre-speed as soon as possible, improving responsiveness. +*/ + + + +static Handle speedHudSynchronizer; + +static bool speedTextDuckPressedLast[MAXPLAYERS + 1]; +static bool speedTextOnGroundLast[MAXPLAYERS + 1]; +static bool speedTextShowDuckString[MAXPLAYERS + 1]; + + + +// =====[ EVENTS ]===== + +void OnPluginStart_SpeedText() +{ + speedHudSynchronizer = CreateHudSynchronizer(); +} + +void OnPlayerRunCmdPost_SpeedText(int client, int cmdnum, HUDInfo info) +{ + int updateSpeed = gB_FastUpdateRate[client] ? 3 : 6; + if (cmdnum % updateSpeed == 0 || info.IsTakeoff) + { + UpdateSpeedText(client, info); + } + speedTextOnGroundLast[info.ID] = info.OnGround; + speedTextDuckPressedLast[info.ID] = info.Ducking; +} + +void OnOptionChanged_SpeedText(int client, HUDOption option) +{ + if (option == HUDOption_SpeedText) + { + ClearSpeedText(client); + } +} + + + +// =====[ PRIVATE ]===== + +static void UpdateSpeedText(int client, HUDInfo info) +{ + KZPlayer player = KZPlayer(client); + + if (player.Fake + || player.SpeedText != SpeedText_Bottom) + { + return; + } + + ShowSpeedText(player, info); +} + +static void ClearSpeedText(int client) +{ + ClearSyncHud(client, speedHudSynchronizer); +} + +static void ShowSpeedText(KZPlayer player, HUDInfo info) +{ + if (info.Paused) + { + return; + } + + int colour[4] = { 255, 255, 255, 0 }; // RGBA + float velZ = Movement_GetVerticalVelocity(info.ID); + if (!info.OnGround && !info.OnLadder && !info.Noclipping) + { + if (GOKZ_HUD_GetOption(player.ID, HUDOption_DeadstrafeColor) == DeadstrafeColor_Enabled && velZ > 0.0 && velZ < 140.0) + { + colour = { 255, 32, 32, 0 }; + } + else if (info.HitPerf) + { + if (info.HitJB) + { + colour = { 255, 255, 32, 0 }; + } + else + { + colour = { 64, 255, 64, 0 }; + } + } + } + + switch (player.SpeedText) + { + case SpeedText_Bottom: + { + // Set params based on the available screen space at max scaling HUD + if (!IsDrawingInfoPanel(player.ID)) + { + SetHudTextParams(-1.0, 0.75, GetTextHoldTime(gB_FastUpdateRate[player.ID] ? 3 : 6), colour[0], colour[1], colour[2], colour[3], 0, 1.0, 0.0, 0.0); + } + else + { + SetHudTextParams(-1.0, 0.65, GetTextHoldTime(gB_FastUpdateRate[player.ID] ? 3 : 6), colour[0], colour[1], colour[2], colour[3], 0, 1.0, 0.0, 0.0); + } + } + } + + if (info.OnGround || info.OnLadder || info.Noclipping) + { + ShowSyncHudText(player.ID, speedHudSynchronizer, + "%.0f", + RoundFloat(info.Speed * 10) / 10.0); + speedTextShowDuckString[info.ID] = false; + } + else + { + if (speedTextShowDuckString[info.ID] + || (speedTextOnGroundLast[info.ID] + && !info.HitBhop + && info.IsTakeoff + && info.Jumped + && info.Ducking + && (speedTextDuckPressedLast[info.ID] || GOKZ_GetCoreOption(info.ID, Option_Mode) == Mode_Vanilla))) + { + ShowSyncHudText(player.ID, speedHudSynchronizer, + "%.0f\n (%.0f)C", + RoundToPowerOfTen(info.Speed, -2), + RoundToPowerOfTen(info.TakeoffSpeed, -2)); + speedTextShowDuckString[info.ID] = true; + } + else { + ShowSyncHudText(player.ID, speedHudSynchronizer, + "%.0f\n(%.0f)", + RoundToPowerOfTen(info.Speed, -2), + RoundToPowerOfTen(info.TakeoffSpeed, -2)); + speedTextShowDuckString[info.ID] = false; + } + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-hud/timer_text.sp b/sourcemod/scripting/gokz-hud/timer_text.sp new file mode 100644 index 0000000..a5fd17b --- /dev/null +++ b/sourcemod/scripting/gokz-hud/timer_text.sp @@ -0,0 +1,135 @@ +/* + Uses HUD text to show current run time somewhere on the screen. + + This is manually refreshed whenever the players' timer is started, ended or + stopped to improve responsiveness. +*/ + + + +static Handle timerHudSynchronizer; + + + +// =====[ PUBLIC ]===== + +char[] FormatTimerTextForMenu(KZPlayer player, HUDInfo info) +{ + char timerTextString[32]; + if (info.TimerRunning) + { + if (player.GetHUDOption(HUDOption_TimerType) == TimerType_Enabled) + { + FormatEx(timerTextString, sizeof(timerTextString), + "%s %s", + gC_TimeTypeNames[info.TimeType], + GOKZ_HUD_FormatTime(player.ID, info.Time)); + } + else + { + FormatEx(timerTextString, sizeof(timerTextString), + "%s", + GOKZ_HUD_FormatTime(player.ID, info.Time)); + } + if (info.Paused) + { + Format(timerTextString, sizeof(timerTextString), "%s (%T)", timerTextString, "Info Panel Text - PAUSED", player.ID); + } + } + return timerTextString; +} + + + +// =====[ EVENTS ]===== + +void OnPluginStart_TimerText() +{ + timerHudSynchronizer = CreateHudSynchronizer(); +} + +void OnPlayerRunCmdPost_TimerText(int client, int cmdnum, HUDInfo info) +{ + int updateSpeed = gB_FastUpdateRate[client] ? 3 : 6; + if (cmdnum % updateSpeed == 1) + { + UpdateTimerText(client, info); + } +} + +void OnOptionChanged_TimerText(int client, HUDOption option) +{ + if (option == HUDOption_TimerText) + { + ClearTimerText(client); + } +} + +void OnTimerEnd_TimerText(int client) +{ + ClearTimerText(client); +} + +void OnTimerStopped_TimerText(int client) +{ + ClearTimerText(client); +} + + +// =====[ PRIVATE ]===== + +static void UpdateTimerText(int client, HUDInfo info) +{ + KZPlayer player = KZPlayer(client); + + if (player.Fake) + { + return; + } + + ShowTimerText(player, info); +} + +static void ClearTimerText(int client) +{ + ClearSyncHud(client, timerHudSynchronizer); +} + +static void ShowTimerText(KZPlayer player, HUDInfo info) +{ + if (!info.TimerRunning) + { + if (player.ID != info.ID) + { + CancelGOKZHUDMenu(player.ID); + } + return; + } + if (player.TimerText == TimerText_Top || player.TimerText == TimerText_Bottom) + { + int colour[4]; // RGBA + if (player.GetHUDOption(HUDOption_TimerType) == TimerType_Enabled) + { + switch (info.TimeType) + { + case TimeType_Nub:colour = { 234, 209, 138, 0 }; + case TimeType_Pro:colour = { 181, 212, 238, 0 }; + } + } + else colour = { 255, 255, 255, 0}; + + switch (player.TimerText) + { + case TimerText_Top: + { + SetHudTextParams(-1.0, 0.07, GetTextHoldTime(gB_FastUpdateRate[player.ID] ? 3 : 6), colour[0], colour[1], colour[2], colour[3], 0, 1.0, 0.0, 0.0); + } + case TimerText_Bottom: + { + SetHudTextParams(-1.0, 0.9, GetTextHoldTime(gB_FastUpdateRate[player.ID] ? 3 : 6), colour[0], colour[1], colour[2], colour[3], 0, 1.0, 0.0, 0.0); + } + } + + ShowSyncHudText(player.ID, timerHudSynchronizer, GOKZ_HUD_FormatTime(player.ID, info.Time)); + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-hud/tp_menu.sp b/sourcemod/scripting/gokz-hud/tp_menu.sp new file mode 100644 index 0000000..bb78f1e --- /dev/null +++ b/sourcemod/scripting/gokz-hud/tp_menu.sp @@ -0,0 +1,415 @@ +/* + Lets players easily use teleport functionality. + + This menu is displayed whenever the player is alive and there is + currently no other menu displaying. +*/ + + + +#define ITEM_INFO_CHECKPOINT "cp" +#define ITEM_INFO_TELEPORT "tp" +#define ITEM_INFO_PREV "prev" +#define ITEM_INFO_NEXT "next" +#define ITEM_INFO_UNDO "undo" +#define ITEM_INFO_PAUSE "pause" +#define ITEM_INFO_START "start" + +static bool oldCanMakeCP[MAXPLAYERS + 1]; +static bool oldCanTP[MAXPLAYERS + 1]; +static bool oldCanPrevCP[MAXPLAYERS + 1]; +static bool oldCanNextCP[MAXPLAYERS + 1]; +static bool oldCanUndoTP[MAXPLAYERS + 1]; +static bool oldCanPause[MAXPLAYERS + 1]; +static bool oldCanResume[MAXPLAYERS + 1]; +static bool forceRefresh[MAXPLAYERS + 1]; + +// =====[ EVENTS ]===== + +void OnPlayerRunCmdPost_TPMenu(int client, int cmdnum, HUDInfo info) +{ + int updateSpeed = gB_FastUpdateRate[client] ? 3 : 6; + if (cmdnum % updateSpeed == 2) + { + UpdateTPMenu(client, info); + } +} + +public int PanelHandler_Menu(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Cancel) + { + gB_MenuShowing[param1] = false; + } + return 0; +} + +public int MenuHandler_TPMenu(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + char info[16]; + menu.GetItem(param2, info, sizeof(info)); + + if (StrEqual(info, ITEM_INFO_CHECKPOINT, false)) + { + GOKZ_MakeCheckpoint(param1); + } + else if (StrEqual(info, ITEM_INFO_TELEPORT, false)) + { + GOKZ_TeleportToCheckpoint(param1); + } + else if (StrEqual(info, ITEM_INFO_PREV, false)) + { + GOKZ_PrevCheckpoint(param1); + } + else if (StrEqual(info, ITEM_INFO_NEXT, false)) + { + GOKZ_NextCheckpoint(param1); + } + else if (StrEqual(info, ITEM_INFO_UNDO, false)) + { + GOKZ_UndoTeleport(param1); + } + else if (StrEqual(info, ITEM_INFO_PAUSE, false)) + { + GOKZ_TogglePause(param1); + } + else if (StrEqual(info, ITEM_INFO_START, false)) + { + GOKZ_TeleportToStart(param1); + } + + // Menu closes when player selects something, so... + gB_MenuShowing[param1] = false; + } + else if (action == MenuAction_Cancel) + { + gB_MenuShowing[param1] = false; + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + +// =====[ PUBLIC ]===== +void SetForceUpdateTPMenu(int client) +{ + forceRefresh[client] = true; +} + +// =====[ PRIVATE ]===== + +static void UpdateTPMenu(int client, HUDInfo info) +{ + KZPlayer player = KZPlayer(client); + + if (player.Fake) + { + return; + } + + bool force = forceRefresh[client] + || player.CanMakeCheckpoint != oldCanMakeCP[client] + || player.CanTeleportToCheckpoint != oldCanTP[client] + || player.CanPrevCheckpoint != oldCanPrevCP[client] + || player.CanNextCheckpoint != oldCanNextCP[client] + || player.CanUndoTeleport != oldCanUndoTP[client] + || player.CanPause != oldCanPause[client] + || player.CanResume != oldCanResume[client]; + + + if (player.Alive) + { + if (player.TPMenu != TPMenu_Disabled) + { + if (GetClientMenu(client) == MenuSource_None + || gB_MenuShowing[player.ID] && GetClientAvgLoss(player.ID, NetFlow_Both) > EPSILON + || gB_MenuShowing[player.ID] && player.TimerRunning && !player.Paused && player.TimerText == TimerText_TPMenu + || gB_MenuShowing[player.ID] && force) + { + ShowTPMenu(player, info); + } + } + else + { + // There is no need to update this very often as there's no menu selection to be done here. + if (GetClientMenu(client) == MenuSource_None + || gB_MenuShowing[player.ID] && player.TimerRunning && !player.Paused && player.TimerText == TimerText_TPMenu) + { + ShowPanel(player, info); + } + } + } + else if (player.ObserverTarget != -1) // If the player is spectating someone else + { + // Check if the replay plugin wants to display the replay control menu. + if (!(IsFakeClient(player.ObserverTarget) && gB_GOKZReplays && GOKZ_RP_UpdateReplayControlMenu(client))) + { + ShowPanel(player, info); + } + } + + oldCanMakeCP[client] = player.CanMakeCheckpoint; + oldCanTP[client] = player.CanTeleportToCheckpoint; + oldCanPrevCP[client] = player.CanPrevCheckpoint; + oldCanNextCP[client] = player.CanNextCheckpoint; + oldCanUndoTP[client] = player.CanUndoTeleport; + oldCanPause[client] = player.CanPause; + oldCanResume[client] = player.CanResume; + forceRefresh[client] = false; +} + +static void ShowPanel(KZPlayer player, HUDInfo info) +{ + char panelTitle[256]; + // Spectator List + if (player.ShowSpectators >= ShowSpecs_Number && player.SpecListPosition == SpecListPosition_TPMenu) + { + Format(panelTitle, sizeof(panelTitle), "%s", FormatSpectatorTextForMenu(player, info)); + } + // Timer panel + if (player.TimerText == TimerText_TPMenu && info.TimerRunning) + { + if (panelTitle[0] != '\0') + { + Format(panelTitle, sizeof(panelTitle), "%s \n%s", panelTitle, FormatTimerTextForMenu(player, info)); + } + else + { + Format(panelTitle, sizeof(panelTitle), "%s", FormatTimerTextForMenu(player, info)); + } + if (info.TimeType == TimeType_Nub && info.CurrentTeleport != 0) + { + Format(panelTitle, sizeof(panelTitle), "%s\n%t", panelTitle, "TP Menu - Spectator Teleports", info.CurrentTeleport); + } + } + + if (panelTitle[0] != '\0' && GetClientMenu(player.ID) == MenuSource_None || gB_MenuShowing[player.ID]) + { + Panel panel = new Panel(null); + panel.SetTitle(panelTitle); + panel.Send(player.ID, PanelHandler_Menu, MENU_TIME_FOREVER); + + delete panel; + gB_MenuShowing[player.ID] = true; + } +} + +static void ShowTPMenu(KZPlayer player, HUDInfo info) +{ + Menu menu = new Menu(MenuHandler_TPMenu); + menu.OptionFlags = MENUFLAG_NO_SOUND; + menu.ExitButton = false; + menu.Pagination = MENU_NO_PAGINATION; + TPMenuSetTitle(player, menu, info); + TPMenuAddItems(player, menu); + menu.Display(player.ID, MENU_TIME_FOREVER); + gB_MenuShowing[player.ID] = true; +} + +static void TPMenuSetTitle(KZPlayer player, Menu menu, HUDInfo info) +{ + char title[256]; + if (player.ShowSpectators >= ShowSpecs_Number && player.SpecListPosition == SpecListPosition_TPMenu) + { + Format(title, sizeof(title), "%s", FormatSpectatorTextForMenu(player, info)); + } + if (player.TimerRunning && player.TimerText == TimerText_TPMenu) + { + if (title[0] != '\0') + { + Format(title, sizeof(title), "%s \n%s", title, FormatTimerTextForMenu(player, info)); + } + else + { + Format(title, sizeof(title), "%s", FormatTimerTextForMenu(player, info)); + } + } + if (title[0] != '\0') + { + menu.SetTitle(title); + } +} + +static void TPMenuAddItems(KZPlayer player, Menu menu) +{ + switch (player.TPMenu) + { + case TPMenu_Simple: + { + TPMenuAddItemCheckpoint(player, menu); + TPMenuAddItemTeleport(player, menu); + TPMenuAddItemPause(player, menu); + TPMenuAddItemStart(player, menu); + } + case TPMenu_Advanced: + { + TPMenuAddItemCheckpoint(player, menu); + TPMenuAddItemTeleport(player, menu); + TPMenuAddItemPrevCheckpoint(player, menu); + TPMenuAddItemNextCheckpoint(player, menu); + TPMenuAddItemUndo(player, menu); + TPMenuAddItemPause(player, menu); + TPMenuAddItemStart(player, menu); + } + } +} + +static void TPMenuAddItemCheckpoint(KZPlayer player, Menu menu) +{ + char display[24]; + FormatEx(display, sizeof(display), "%T", "TP Menu - Checkpoint", player.ID); + if (player.TimerRunning) + { + Format(display, sizeof(display), "%s #%d", display, player.CheckpointCount); + } + + // Legacy behavior: Always able to make checkpoint attempts. + if (gI_DynamicMenu[player.ID] == DynamicMenu_Enabled && !player.CanMakeCheckpoint) + { + menu.AddItem(ITEM_INFO_CHECKPOINT, display, ITEMDRAW_DISABLED); + } + else + { + menu.AddItem(ITEM_INFO_CHECKPOINT, display, ITEMDRAW_DEFAULT); + } + +} + +static void TPMenuAddItemTeleport(KZPlayer player, Menu menu) +{ + char display[24]; + FormatEx(display, sizeof(display), "%T", "TP Menu - Teleport", player.ID); + if (player.TimerRunning) + { + Format(display, sizeof(display), "%s #%d", display, player.TeleportCount); + } + + // Legacy behavior: Only able to make TP attempts when there is a checkpoint. + if (gI_DynamicMenu[player.ID] == DynamicMenu_Disabled || player.CanTeleportToCheckpoint) + { + menu.AddItem(ITEM_INFO_TELEPORT, display, ITEMDRAW_DEFAULT); + } + else + { + menu.AddItem(ITEM_INFO_TELEPORT, display, ITEMDRAW_DISABLED); + } +} + +static void TPMenuAddItemPrevCheckpoint(KZPlayer player, Menu menu) +{ + char display[24]; + FormatEx(display, sizeof(display), "%T", "TP Menu - Prev CP", player.ID); + + // Legacy behavior: Only able to do prev CP when there is a previous checkpoint to go back to. + if (gI_DynamicMenu[player.ID] == DynamicMenu_Disabled || player.CanPrevCheckpoint) + { + menu.AddItem(ITEM_INFO_PREV, display, ITEMDRAW_DEFAULT); + } + else + { + menu.AddItem(ITEM_INFO_PREV, display, ITEMDRAW_DISABLED); + } +} + +static void TPMenuAddItemNextCheckpoint(KZPlayer player, Menu menu) +{ + char display[24]; + FormatEx(display, sizeof(display), "%T", "TP Menu - Next CP", player.ID); + + // Legacy behavior: Only able to do prev CP when there is a next checkpoint to go forward to. + if (gI_DynamicMenu[player.ID] == DynamicMenu_Disabled || player.CanNextCheckpoint) + { + menu.AddItem(ITEM_INFO_NEXT, display, ITEMDRAW_DEFAULT); + } + else + { + menu.AddItem(ITEM_INFO_NEXT, display, ITEMDRAW_DISABLED); + } +} + +static void TPMenuAddItemUndo(KZPlayer player, Menu menu) +{ + char display[24]; + FormatEx(display, sizeof(display), "%T", "TP Menu - Undo TP", player.ID); + + // Legacy behavior: Only able to attempt to undo TP when it is allowed. + if (gI_DynamicMenu[player.ID] == DynamicMenu_Disabled || player.CanUndoTeleport) + { + menu.AddItem(ITEM_INFO_UNDO, display, ITEMDRAW_DEFAULT); + } + else + { + menu.AddItem(ITEM_INFO_UNDO, display, ITEMDRAW_DISABLED); + } + +} + +static void TPMenuAddItemPause(KZPlayer player, Menu menu) +{ + char display[24]; + + // Legacy behavior: Always able to attempt to pause. + if (gI_DynamicMenu[player.ID] == DynamicMenu_Enabled) + { + if (player.Paused) + { + FormatEx(display, sizeof(display), "%T", "TP Menu - Resume", player.ID); + if (player.CanResume) + { + menu.AddItem(ITEM_INFO_PAUSE, display, ITEMDRAW_DEFAULT); + } + else + { + menu.AddItem(ITEM_INFO_PAUSE, display, ITEMDRAW_DISABLED); + } + } + else + { + FormatEx(display, sizeof(display), "%T", "TP Menu - Pause", player.ID); + if (player.CanPause) + { + menu.AddItem(ITEM_INFO_PAUSE, display, ITEMDRAW_DEFAULT); + } + else + { + menu.AddItem(ITEM_INFO_PAUSE, display, ITEMDRAW_DISABLED); + } + } + } + else + { + if (player.Paused) + { + FormatEx(display, sizeof(display), "%T", "TP Menu - Resume", player.ID); + } + else + { + FormatEx(display, sizeof(display), "%T", "TP Menu - Pause", player.ID); + } + menu.AddItem(ITEM_INFO_PAUSE, display, ITEMDRAW_DEFAULT); + } +} + +static void TPMenuAddItemStart(KZPlayer player, Menu menu) +{ + char display[24]; + if (player.StartPositionType == StartPositionType_Spawn) + { + FormatEx(display, sizeof(display), "%T", "TP Menu - Respawn", player.ID); + menu.AddItem(ITEM_INFO_START, display, ITEMDRAW_DEFAULT); + } + else if (player.TimerRunning) + { + FormatEx(display, sizeof(display), "%T", "TP Menu - Restart", player.ID); + menu.AddItem(ITEM_INFO_START, display, ITEMDRAW_DEFAULT); + } + else + { + FormatEx(display, sizeof(display), "%T", "TP Menu - Start", player.ID); + menu.AddItem(ITEM_INFO_START, display, ITEMDRAW_DEFAULT); + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-jumpbeam.sp b/sourcemod/scripting/gokz-jumpbeam.sp new file mode 100644 index 0000000..9f5b48d --- /dev/null +++ b/sourcemod/scripting/gokz-jumpbeam.sp @@ -0,0 +1,325 @@ +#include <sourcemod> + +#include <sdktools> + +#include <gokz/core> +#include <gokz/jumpbeam> + +#undef REQUIRE_EXTENSIONS +#undef REQUIRE_PLUGIN +#include <updater> + +#include <gokz/kzplayer> + +#pragma newdecls required +#pragma semicolon 1 + + + +public Plugin myinfo = +{ + name = "GOKZ Jump Beam", + author = "DanZay", + description = "Provides option to leave behind a trail when in midair", + version = GOKZ_VERSION, + url = GOKZ_SOURCE_URL +}; + +#define UPDATER_URL GOKZ_UPDATER_BASE_URL..."gokz-jumpbeam.txt" + +float gF_OldOrigin[MAXPLAYERS + 1][3]; +bool gB_OldDucking[MAXPLAYERS + 1]; +int gI_BeamModel; +TopMenu gTM_Options; +TopMenuObject gTMO_CatGeneral; +TopMenuObject gTMO_ItemsJB[JBOPTION_COUNT]; + + + +// =====[ PLUGIN EVENTS ]===== + +public APLRes AskPluginLoad2(Handle myself, bool late, char[] error, int err_max) +{ + RegPluginLibrary("gokz-jumpbeam"); + return APLRes_Success; +} + +public void OnPluginStart() +{ + LoadTranslations("gokz-common.phrases"); + LoadTranslations("gokz-jumpbeam.phrases"); +} + +public void OnAllPluginsLoaded() +{ + if (LibraryExists("updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + + TopMenu topMenu; + if (LibraryExists("gokz-core") && ((topMenu = GOKZ_GetOptionsTopMenu()) != null)) + { + GOKZ_OnOptionsMenuReady(topMenu); + } +} + +public void OnLibraryAdded(const char[] name) +{ + if (StrEqual(name, "updater")) + { + Updater_AddPlugin(UPDATER_URL); + } +} + + + +// =====[ CLIENT EVENTS ]===== + +public void OnPlayerRunCmdPost(int client, int buttons, int impulse, const float vel[3], const float angles[3], int weapon, int subtype, int cmdnum, int tickcount, int seed, const int mouse[2]) +{ + if (!IsValidClient(client)) + { + return; + } + + OnPlayerRunCmdPost_JumpBeam(client); + UpdateOldVariables(client); +} + + + +// =====[ OTHER EVENTS ]===== + +public void OnMapStart() +{ + gI_BeamModel = PrecacheModel("materials/sprites/laserbeam.vmt", true); +} + +public void GOKZ_OnOptionsMenuReady(TopMenu topMenu) +{ + OnOptionsMenuReady_Options(); + OnOptionsMenuReady_OptionsMenu(topMenu); +} + + + +// =====[ GENERAL ]===== + +void UpdateOldVariables(int client) +{ + if (IsPlayerAlive(client)) + { + Movement_GetOrigin(client, gF_OldOrigin[client]); + gB_OldDucking[client] = Movement_GetDucking(client); + } +} + + + +// =====[ JUMP BEAM ]===== + +void OnPlayerRunCmdPost_JumpBeam(int targetClient) +{ + // In this case, spectators are handled from the target + // client's OnPlayerRunCmd call, otherwise the jump + // beam will be all broken up. + + KZPlayer targetPlayer = KZPlayer(targetClient); + + if (targetPlayer.Fake || !targetPlayer.Alive || targetPlayer.OnGround || !targetPlayer.ValidJump) + { + return; + } + + // Send to self + SendJumpBeam(targetPlayer, targetPlayer); + + // Send to spectators + for (int client = 1; client <= MaxClients; client++) + { + KZPlayer player = KZPlayer(client); + if (player.InGame && !player.Alive && player.ObserverTarget == targetClient) + { + SendJumpBeam(player, targetPlayer); + } + } +} + +void SendJumpBeam(KZPlayer player, KZPlayer targetPlayer) +{ + if (player.JBType == JBType_Disabled) + { + return; + } + + switch (player.JBType) + { + case JBType_Feet:SendFeetJumpBeam(player, targetPlayer); + case JBType_Head:SendHeadJumpBeam(player, targetPlayer); + case JBType_FeetAndHead: + { + SendFeetJumpBeam(player, targetPlayer); + SendHeadJumpBeam(player, targetPlayer); + } + case JBType_Ground:SendGroundJumpBeam(player, targetPlayer); + } +} + +void SendFeetJumpBeam(KZPlayer player, KZPlayer targetPlayer) +{ + float origin[3], beamStart[3], beamEnd[3]; + int beamColour[4]; + targetPlayer.GetOrigin(origin); + + beamStart = gF_OldOrigin[targetPlayer.ID]; + beamEnd = origin; + GetJumpBeamColour(targetPlayer, beamColour); + + TE_SetupBeamPoints(beamStart, beamEnd, gI_BeamModel, 0, 0, 0, JB_BEAM_LIFETIME, 0.25, 0.25, 10, 0.0, beamColour, 0); + TE_SendToClient(player.ID); +} + +void SendHeadJumpBeam(KZPlayer player, KZPlayer targetPlayer) +{ + float origin[3], beamStart[3], beamEnd[3]; + int beamColour[4]; + targetPlayer.GetOrigin(origin); + + beamStart = gF_OldOrigin[targetPlayer.ID]; + beamEnd = origin; + if (gB_OldDucking[targetPlayer.ID]) + { + beamStart[2] = beamStart[2] + 54.0; + } + else + { + beamStart[2] = beamStart[2] + 72.0; + } + if (targetPlayer.Ducking) + { + beamEnd[2] = beamEnd[2] + 54.0; + } + else + { + beamEnd[2] = beamEnd[2] + 72.0; + } + GetJumpBeamColour(targetPlayer, beamColour); + + TE_SetupBeamPoints(beamStart, beamEnd, gI_BeamModel, 0, 0, 0, JB_BEAM_LIFETIME, 0.25, 0.25, 10, 0.0, beamColour, 0); + TE_SendToClient(player.ID); +} + +void SendGroundJumpBeam(KZPlayer player, KZPlayer targetPlayer) +{ + float origin[3], takeoffOrigin[3], beamStart[3], beamEnd[3]; + int beamColour[4]; + targetPlayer.GetOrigin(origin); + targetPlayer.GetTakeoffOrigin(takeoffOrigin); + + beamStart = gF_OldOrigin[targetPlayer.ID]; + beamEnd = origin; + beamStart[2] = takeoffOrigin[2] + 0.1; + beamEnd[2] = takeoffOrigin[2] + 0.1; + GetJumpBeamColour(targetPlayer, beamColour); + + TE_SetupBeamPoints(beamStart, beamEnd, gI_BeamModel, 0, 0, 0, JB_BEAM_LIFETIME, 0.25, 0.25, 10, 0.0, beamColour, 0); + TE_SendToClient(player.ID); +} + +void GetJumpBeamColour(KZPlayer targetPlayer, int colour[4]) +{ + float velocity[3]; + targetPlayer.GetVelocity(velocity); + if (targetPlayer.Ducking) + { + colour = { 255, 0, 0, 110 }; // Red + } + else if( velocity[2] < 140 && velocity[2] > 0 ) { + colour = { 255, 220, 0, 110 }; + } + else + { + colour = { 0, 255, 0, 110 }; // Green + } +} + + + +// =====[ OPTIONS ]===== + +void OnOptionsMenuReady_Options() +{ + RegisterOptions(); +} + +void RegisterOptions() +{ + for (JBOption option; option < JBOPTION_COUNT; option++) + { + GOKZ_RegisterOption(gC_JBOptionNames[option], gC_JBOptionDescriptions[option], + OptionType_Int, gI_JBOptionDefaultValues[option], 0, gI_JBOptionCounts[option] - 1); + } +} + + + +// =====[ OPTIONS MENU ]===== + +void OnOptionsMenuReady_OptionsMenu(TopMenu topMenu) +{ + if (gTM_Options == topMenu) + { + return; + } + + gTM_Options = topMenu; + gTMO_CatGeneral = gTM_Options.FindCategory(GENERAL_OPTION_CATEGORY); + + for (int option = 0; option < view_as<int>(JBOPTION_COUNT); option++) + { + gTMO_ItemsJB[option] = gTM_Options.AddItem(gC_JBOptionNames[option], TopMenuHandler_General, gTMO_CatGeneral); + } +} + +public void TopMenuHandler_General(TopMenu topmenu, TopMenuAction action, TopMenuObject topobj_id, int param, char[] buffer, int maxlength) +{ + JBOption option = JBOPTION_INVALID; + for (int i = 0; i < view_as<int>(JBOPTION_COUNT); i++) + { + if (topobj_id == gTMO_ItemsJB[i]) + { + option = view_as<JBOption>(i); + break; + } + } + + if (option == JBOPTION_INVALID) + { + return; + } + + if (action == TopMenuAction_DisplayOption) + { + switch (option) + { + case JBOption_Type: + { + FormatEx(buffer, maxlength, "%T - %T", + gC_JBOptionPhrases[option], param, + gC_JBTypePhrases[GOKZ_JB_GetOption(param, option)], param); + } + } + } + else if (action == TopMenuAction_SelectOption) + { + switch (option) + { + default: + { + GOKZ_JB_CycleOption(param, option); + gTM_Options.Display(param, TopMenuPosition_LastCategory); + } + } + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-jumpstats.sp b/sourcemod/scripting/gokz-jumpstats.sp new file mode 100644 index 0000000..74d9220 --- /dev/null +++ b/sourcemod/scripting/gokz-jumpstats.sp @@ -0,0 +1,216 @@ +#include <sourcemod> + +#include <dhooks> +#include <sdkhooks> +#include <sdktools> + +#include <gokz/core> +#include <gokz/jumpstats> + +#undef REQUIRE_EXTENSIONS +#undef REQUIRE_PLUGIN +#include <gokz/localdb> +#include <updater> + +#include <gokz/kzplayer> + +#pragma newdecls required +#pragma semicolon 1 + + + +public Plugin myinfo = +{ + name = "GOKZ Jumpstats", + author = "DanZay", + description = "Tracks and outputs movement statistics", + version = GOKZ_VERSION, + url = GOKZ_SOURCE_URL +}; + +#define UPDATER_URL GOKZ_UPDATER_BASE_URL..."gokz-jumpstats.txt" + +// This must be global because it's both used by jump tracking and validating. +bool gB_SpeedJustModifiedExternally[MAXPLAYERS + 1]; + +#include "gokz-jumpstats/api.sp" +#include "gokz-jumpstats/commands.sp" +#include "gokz-jumpstats/distance_tiers.sp" +#include "gokz-jumpstats/jump_reporting.sp" +#include "gokz-jumpstats/jump_tracking.sp" +#include "gokz-jumpstats/jump_validating.sp" +#include "gokz-jumpstats/options.sp" +#include "gokz-jumpstats/options_menu.sp" + + +// =====[ PLUGIN EVENTS ]===== + +public APLRes AskPluginLoad2(Handle myself, bool late, char[] error, int err_max) +{ + CreateNatives(); + RegPluginLibrary("gokz-jumpstats"); + return APLRes_Success; +} + +public void OnPluginStart() +{ + LoadTranslations("gokz-common.phrases"); + LoadTranslations("gokz-jumpstats.phrases"); + + LoadBroadcastTiers(); + CreateGlobalForwards(); + RegisterCommands(); + + OnPluginStart_JumpTracking(); + OnPluginStart_JumpValidating(); +} + +public void OnAllPluginsLoaded() +{ + if (LibraryExists("updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + + TopMenu topMenu; + if (LibraryExists("gokz-core") && ((topMenu = GOKZ_GetOptionsTopMenu()) != null)) + { + GOKZ_OnOptionsMenuReady(topMenu); + } + + for (int client = 1; client <= MaxClients; client++) + { + if (IsClientInGame(client)) + { + OnClientPutInServer(client); + } + } +} + +public void OnLibraryAdded(const char[] name) +{ + if (StrEqual(name, "updater")) + { + Updater_AddPlugin(UPDATER_URL); + } +} + + + +// =====[ CLIENT EVENTS ]===== + +public void OnClientPutInServer(int client) +{ + HookClientEvents(client); + OnClientPutInServer_Options(client); + OnClientPutInServer_JumpTracking(client); +} + +public Action OnPlayerRunCmd(int client, int &buttons, int &impulse, float vel[3], float angles[3], int &weapon, int &subtype, int &cmdnum, int &tickcount, int &seed, int mouse[2]) +{ + OnPlayerRunCmd_JumpTracking(client, buttons, tickcount); + return Plugin_Continue; +} + +public void OnPlayerRunCmdPost(int client, int buttons, int impulse, const float vel[3], const float angles[3], int weapon, int subtype, int cmdnum, int tickcount, int seed, const int mouse[2]) +{ + OnPlayerRunCmdPost_JumpTracking(client); +} + +public void Movement_OnStartTouchGround(int client) +{ + OnStartTouchGround_JumpTracking(client); +} + +public void GOKZ_OnJumpInvalidated(int client) +{ + OnJumpInvalidated_JumpTracking(client); +} + +public void GOKZ_OnJumpValidated(int client, bool jumped, bool ladderJump, bool jumpbug) +{ + OnJumpValidated_JumpTracking(client, jumped, ladderJump, jumpbug); +} + +public void GOKZ_OnOptionChanged(int client, const char[] option, any newValue) +{ + OnOptionChanged_JumpTracking(client, option); + OnOptionChanged_Options(client, option, newValue); +} + +public void GOKZ_JS_OnLanding(Jump jump) +{ + OnLanding_JumpReporting(jump); +} + +public void GOKZ_JS_OnFailstat(Jump jump) +{ + OnFailstat_FailstatReporting(jump); +} + +public void GOKZ_JS_OnJumpstatAlways(Jump jump) +{ + OnJumpstatAlways_JumpstatAlwaysReporting(jump); +} + +public void GOKZ_JS_OnFailstatAlways(Jump jump) +{ + OnFailstatAlways_FailstatAlwaysReporting(jump); +} + +public void SDKHook_StartTouch_Callback(int client, int touched) // SDKHook_StartTouchPost +{ + OnStartTouch_JumpTracking(client, touched); +} + +public void SDKHook_Touch_CallBack(int client, int touched) +{ + OnTouch_JumpTracking(client); +} + +public void SDKHook_EndTouch_Callback(int client, int touched) // SDKHook_EndTouchPost +{ + OnEndTouch_JumpTracking(client, touched); +} + +public void GOKZ_OnTeleport(int client) +{ + OnTeleport_FailstatAlways(client); +} + + + +// =====[ OTHER EVENTS ]===== + +public void OnMapStart() +{ + OnMapStart_JumpReporting(); + OnMapStart_DistanceTiers(); +} + +public void GOKZ_OnOptionsMenuCreated(TopMenu topMenu) +{ + OnOptionsMenuCreated_OptionsMenu(topMenu); +} + +public void GOKZ_OnOptionsMenuReady(TopMenu topMenu) +{ + OnOptionsMenuReady_Options(); + OnOptionsMenuReady_OptionsMenu(topMenu); +} + +public void GOKZ_OnSlap(int client) +{ + InvalidateJumpstat(client); +} + + + +// =====[ PRIVATE ]===== + +static void HookClientEvents(int client) +{ + SDKHook(client, SDKHook_StartTouchPost, SDKHook_StartTouch_Callback); + SDKHook(client, SDKHook_TouchPost, SDKHook_Touch_CallBack); + SDKHook(client, SDKHook_EndTouchPost, SDKHook_EndTouch_Callback); +} diff --git a/sourcemod/scripting/gokz-jumpstats/api.sp b/sourcemod/scripting/gokz-jumpstats/api.sp new file mode 100644 index 0000000..2625fda --- /dev/null +++ b/sourcemod/scripting/gokz-jumpstats/api.sp @@ -0,0 +1,78 @@ +static GlobalForward H_OnTakeoff; +static GlobalForward H_OnLanding; +static GlobalForward H_OnFailstat; +static GlobalForward H_OnJumpstatAlways; +static GlobalForward H_OnFailstatAlways; +static GlobalForward H_OnJumpInvalidated; + + + +// =====[ FORWARDS ]===== + +void CreateGlobalForwards() +{ + H_OnTakeoff = new GlobalForward("GOKZ_JS_OnTakeoff", ET_Ignore, Param_Cell, Param_Cell); + H_OnLanding = new GlobalForward("GOKZ_JS_OnLanding", ET_Ignore, Param_Array); + H_OnFailstat = new GlobalForward("GOKZ_JS_OnFailstat", ET_Ignore, Param_Array); + H_OnJumpstatAlways = new GlobalForward("GOKZ_JS_OnJumpstatAlways", ET_Ignore, Param_Array); + H_OnFailstatAlways = new GlobalForward("GOKZ_JS_OnFailstatAlways", ET_Ignore, Param_Array); + H_OnJumpInvalidated = new GlobalForward("GOKZ_JS_OnJumpInvalidated", ET_Ignore, Param_Cell); +} + +void Call_OnTakeoff(int client, int jumpType) +{ + Call_StartForward(H_OnTakeoff); + Call_PushCell(client); + Call_PushCell(jumpType); + Call_Finish(); +} + +void Call_OnLanding(Jump jump) +{ + Call_StartForward(H_OnLanding); + Call_PushArray(jump, sizeof(jump)); + Call_Finish(); +} + +void Call_OnJumpInvalidated(int client) +{ + Call_StartForward(H_OnJumpInvalidated); + Call_PushCell(client); + Call_Finish(); +} + +void Call_OnFailstat(Jump jump) +{ + Call_StartForward(H_OnFailstat); + Call_PushArray(jump, sizeof(jump)); + Call_Finish(); +} + +void Call_OnJumpstatAlways(Jump jump) +{ + Call_StartForward(H_OnJumpstatAlways); + Call_PushArray(jump, sizeof(jump)); + Call_Finish(); +} + +void Call_OnFailstatAlways(Jump jump) +{ + Call_StartForward(H_OnFailstatAlways); + Call_PushArray(jump, sizeof(jump)); + Call_Finish(); +} + + + +// =====[ NATIVES ]===== + +void CreateNatives() +{ + CreateNative("GOKZ_JS_InvalidateJump", Native_InvalidateJump); +} + +public int Native_InvalidateJump(Handle plugin, int numParams) +{ + InvalidateJumpstat(GetNativeCell(1)); + return 0; +} diff --git a/sourcemod/scripting/gokz-jumpstats/commands.sp b/sourcemod/scripting/gokz-jumpstats/commands.sp new file mode 100644 index 0000000..991f9e6 --- /dev/null +++ b/sourcemod/scripting/gokz-jumpstats/commands.sp @@ -0,0 +1,28 @@ + +void RegisterCommands() +{ + RegConsoleCmd("sm_jso", CommandJumpstatsOptions, "[KZ] Open the jumpstats options menu."); + RegConsoleCmd("sm_jsalways", CommandAlwaysJumpstats, "[KZ] Toggle the always-on jumpstats."); +} + +public Action CommandJumpstatsOptions(int client, int args) +{ + DisplayJumpstatsOptionsMenu(client); + return Plugin_Handled; +} + +public Action CommandAlwaysJumpstats(int client, int args) +{ + if (GOKZ_JS_GetOption(client, JSOption_JumpstatsAlways) == JSToggleOption_Enabled) + { + GOKZ_JS_SetOption(client, JSOption_JumpstatsAlways, JSToggleOption_Disabled); + GOKZ_PrintToChat(client, true, "%t", "Jumpstats Option - Jumpstats Always - Disable"); + } + else + { + GOKZ_JS_SetOption(client, JSOption_JumpstatsAlways, JSToggleOption_Enabled); + GOKZ_PrintToChat(client, true, "%t", "Jumpstats Option - Jumpstats Always - Enable"); + } + + return Plugin_Handled; +} diff --git a/sourcemod/scripting/gokz-jumpstats/distance_tiers.sp b/sourcemod/scripting/gokz-jumpstats/distance_tiers.sp new file mode 100644 index 0000000..3abe8e9 --- /dev/null +++ b/sourcemod/scripting/gokz-jumpstats/distance_tiers.sp @@ -0,0 +1,118 @@ +/* + Categorises jumps into tiers based on their distance. + Tier thresholds are loaded from a config. +*/ + + + +static float distanceTiers[JUMPTYPE_COUNT - 3][MODE_COUNT][DISTANCETIER_COUNT]; + + + +// =====[ PUBLIC ]===== + +int GetDistanceTier(int jumpType, int mode, float distance, float offset = 0.0) +{ + // No tiers given for 'Invalid' jumps. + if (jumpType == JumpType_Invalid || jumpType == JumpType_FullInvalid + || jumpType == JumpType_Fall || jumpType == JumpType_Other + || jumpType != JumpType_LadderJump && offset < -JS_OFFSET_EPSILON + || distance > JS_MAX_JUMP_DISTANCE) + { + // TODO Give a tier to "Other" jumps + // TODO Give a tier to offset jumps + return DistanceTier_None; + } + + // Get highest tier distance that the jump beats + int tier = DistanceTier_None; + while (tier + 1 < DISTANCETIER_COUNT && distance >= GetDistanceTierDistance(jumpType, mode, tier + 1)) + { + tier++; + } + + return tier; +} + +float GetDistanceTierDistance(int jumpType, int mode, int tier) +{ + return distanceTiers[jumpType][mode][tier]; +} + +bool LoadBroadcastTiers() +{ + char chatTier[16], soundTier[16]; + + KeyValues kv = new KeyValues("broadcast"); + if (!kv.ImportFromFile(JS_CFG_BROADCAST)) + { + return false; + } + + kv.GetString("chat", chatTier, sizeof(chatTier), "ownage"); + kv.GetString("sound", soundTier, sizeof(chatTier), ""); + + for (int tier = 0; tier < sizeof(gC_DistanceTierKeys); tier++) + { + if (StrEqual(chatTier, gC_DistanceTierKeys[tier])) + { + gI_JSOptionDefaults[JSOption_MinChatBroadcastTier] = tier; + } + if (StrEqual(soundTier, gC_DistanceTierKeys[tier])) + { + gI_JSOptionDefaults[JSOption_MinSoundBroadcastTier] = tier; + } + } + + delete kv; + return true; +} + + + +// =====[ EVENTS ]===== + +void OnMapStart_DistanceTiers() +{ + if (!LoadDistanceTiers()) + { + SetFailState("Failed to load file: \"%s\".", JS_CFG_TIERS); + } +} + + + +// =====[ PRIVATE ]===== + +static bool LoadDistanceTiers() +{ + KeyValues kv = new KeyValues("tiers"); + if (!kv.ImportFromFile(JS_CFG_TIERS)) + { + return false; + } + + // It's a bit of a hack to exclude non-tiered jumptypes + for (int jumpType = 0; jumpType < sizeof(gC_JumpTypeKeys) - 3; jumpType++) + { + if (!kv.JumpToKey(gC_JumpTypeKeys[jumpType])) + { + return false; + } + for (int mode = 0; mode < MODE_COUNT; mode++) + { + if (!kv.JumpToKey(gC_ModeKeys[mode])) + { + return false; + } + for (int tier = DistanceTier_Meh; tier < DISTANCETIER_COUNT; tier++) + { + distanceTiers[jumpType][mode][tier] = kv.GetFloat(gC_DistanceTierKeys[tier]); + } + kv.GoBack(); + } + kv.GoBack(); + } + delete kv; + return true; +} diff --git a/sourcemod/scripting/gokz-jumpstats/jump_reporting.sp b/sourcemod/scripting/gokz-jumpstats/jump_reporting.sp new file mode 100644 index 0000000..31a1bb2 --- /dev/null +++ b/sourcemod/scripting/gokz-jumpstats/jump_reporting.sp @@ -0,0 +1,508 @@ +/* + Chat and console reports for jumpstats. +*/ + +static char sounds[DISTANCETIER_COUNT][256]; + + + +// =====[ PUBLIC ]===== + +void PlayJumpstatSound(int client, int tier) +{ + int soundOption = GOKZ_JS_GetOption(client, JSOption_MinSoundTier); + if (tier <= DistanceTier_Meh || soundOption == DistanceTier_None || soundOption > tier) + { + return; + } + + GOKZ_EmitSoundToClient(client, sounds[tier], _, "Jumpstats"); +} + + + +// =====[ EVENTS ]===== + +void OnMapStart_JumpReporting() +{ + if (!LoadSounds()) + { + SetFailState("Failed to load file: \"%s\".", JS_CFG_SOUNDS); + } +} + +void OnLanding_JumpReporting(Jump jump) +{ + int minTier; + int tier = GetDistanceTier(jump.type, GOKZ_GetCoreOption(jump.jumper, Option_Mode), jump.distance, jump.offset); + if (tier == DistanceTier_None) + { + return; + } + + // Report the jumpstat to the client and their spectators + DoJumpstatsReport(jump.jumper, jump, tier); + + for (int client = 1; client <= MaxClients; client++) + { + if (IsValidClient(client) && client != jump.jumper) + { + if (GetObserverTarget(client) == jump.jumper) + { + DoJumpstatsReport(client, jump, tier); + } + else + { + minTier = GOKZ_JS_GetOption(client, JSOption_MinChatBroadcastTier); + if (minTier != 0 && tier >= minTier) + { + GOKZ_PrintToChat(client, true, "%t", "Broadcast Jumpstat Chat Report", + gC_DistanceTierChatColours[tier], + jump.jumper, + jump.distance, + gC_JumpTypes[jump.originalType]); + DoConsoleReport(client, false, jump, tier, "Console Jump Header"); + } + + minTier = GOKZ_JS_GetOption(client, JSOption_MinSoundBroadcastTier); + if (minTier != 0 && tier >= minTier) + { + PlayJumpstatSound(client, tier); + } + } + } + } +} + +void OnFailstat_FailstatReporting(Jump jump) +{ + int tier = GetDistanceTier(jump.type, GOKZ_GetCoreOption(jump.jumper, Option_Mode), jump.distance); + if (tier == DistanceTier_None) + { + return; + } + + // Report the failstat to the client and their spectators + DoFailstatReport(jump.jumper, jump, tier); + + for (int client = 1; client <= MaxClients; client++) + { + if (IsValidClient(client) && GetObserverTarget(client) == jump.jumper) + { + DoFailstatReport(client, jump, tier); + } + } +} + +void OnJumpstatAlways_JumpstatAlwaysReporting(Jump jump) +{ + DoJumpstatAlwaysReport(jump.jumper, jump); + + for (int client = 1; client <= MaxClients; client++) + { + if (IsValidClient(client) && GetObserverTarget(client) == jump.jumper) + { + DoJumpstatAlwaysReport(client, jump); + } + } +} + + +void OnFailstatAlways_FailstatAlwaysReporting(Jump jump) +{ + DoFailstatAlwaysReport(jump.jumper, jump); + + for (int client = 1; client <= MaxClients; client++) + { + if (IsValidClient(client) && GetObserverTarget(client) == jump.jumper) + { + DoFailstatAlwaysReport(client, jump); + } + } +} + + + +// =====[ PRIVATE ]===== + +static void DoJumpstatsReport(int client, Jump jump, int tier) +{ + if (GOKZ_JS_GetOption(client, JSOption_JumpstatsMaster) == JSToggleOption_Disabled) + { + return; + } + + DoChatReport(client, false, jump, tier); + DoConsoleReport(client, false, jump, tier, "Console Jump Header"); + PlayJumpstatSound(client, tier); +} + +static void DoFailstatReport(int client, Jump jump, int tier) +{ + if (GOKZ_JS_GetOption(client, JSOption_JumpstatsMaster) == JSToggleOption_Disabled) + { + return; + } + + DoChatReport(client, true, jump, tier); + DoConsoleReport(client, true, jump, tier, "Console Failstat Header"); +} + +static void DoJumpstatAlwaysReport(int client, Jump jump) +{ + if (GOKZ_JS_GetOption(client, JSOption_JumpstatsMaster) == JSToggleOption_Disabled || + GOKZ_JS_GetOption(client, JSOption_JumpstatsAlways) == JSToggleOption_Disabled) + { + return; + } + + DoChatReport(client, false, jump, 1); + DoConsoleReport(client, false, jump, 1, "Console Jump Header"); +} + +static void DoFailstatAlwaysReport(int client, Jump jump) +{ + if (GOKZ_JS_GetOption(client, JSOption_JumpstatsMaster) == JSToggleOption_Disabled || + GOKZ_JS_GetOption(client, JSOption_JumpstatsAlways) == JSToggleOption_Disabled) + { + return; + } + + DoChatReport(client, true, jump, 1); + DoConsoleReport(client, true, jump, 1, "Console Failstat Header"); +} + + + + +// CONSOLE REPORT + +static void DoConsoleReport(int client, bool isFailstat, Jump jump, int tier, char[] header) +{ + int minConsoleTier = GOKZ_JS_GetOption(client, JSOption_MinConsoleTier); + if ((minConsoleTier == 0 || minConsoleTier > tier) && GOKZ_JS_GetOption(client, JSOption_JumpstatsAlways) == JSToggleOption_Disabled + || isFailstat && GOKZ_JS_GetOption(client, JSOption_FailstatsConsole) == JSToggleOption_Disabled) + { + return; + } + + char releaseWString[32], blockString[32], edgeString[32], deviationString[32], missString[32]; + + if (jump.originalType == JumpType_LongJump || + jump.originalType == JumpType_LadderJump || + jump.originalType == JumpType_WeirdJump || + jump.originalType == JumpType_LowpreWeirdJump) + { + FormatEx(releaseWString, sizeof(releaseWString), " %s", GetIntConsoleString(client, "W Release", jump.releaseW)); + } + else if (jump.crouchRelease < 20 && jump.crouchRelease > -20) + { + FormatEx(releaseWString, sizeof(releaseWString), " %s", GetIntConsoleString(client, "Crouch Release", jump.crouchRelease)); + } + + if (jump.miss > 0.0) + { + FormatEx(missString, sizeof(missString), " %s", GetFloatConsoleString2(client, "Miss", jump.miss)); + } + + if (jump.block > 0) + { + FormatEx(blockString, sizeof(blockString), " %s", GetIntConsoleString(client, "Block", jump.block)); + FormatEx(deviationString, sizeof(deviationString), " %s", GetFloatConsoleString1(client, "Deviation", jump.deviation)); + } + + if (jump.edge > 0.0 || (jump.block > 0 && jump.edge == 0.0)) + { + FormatEx(edgeString, sizeof(edgeString), " %s", GetFloatConsoleString2(client, "Edge", jump.edge)); + } + + PrintToConsole(client, "%t", header, jump.jumper, jump.distance, gC_JumpTypes[jump.originalType]); + + PrintToConsole(client, "%s%s%s%s %s %s %s %s%s %s %s%s %s %s %s %s %s", + gC_ModeNamesShort[GOKZ_GetCoreOption(jump.jumper, Option_Mode)], + blockString, + edgeString, + missString, + GetIntConsoleString(client, jump.strafes == 1 ? "Strafe" : "Strafes", jump.strafes), + GetSyncConsoleString(client, jump.sync), + GetFloatConsoleString2(client, "Pre", jump.preSpeed), + GetFloatConsoleString2(client, "Max", jump.maxSpeed), + releaseWString, + GetIntConsoleString(client, "Overlap", jump.overlap), + GetIntConsoleString(client, "Dead Air", jump.deadair), + deviationString, + GetWidthConsoleString(client, jump.width, jump.strafes), + GetFloatConsoleString1(client, "Height", jump.height), + GetIntConsoleString(client, "Airtime", jump.duration), + GetFloatConsoleString1(client, "Offset", jump.offset), + GetIntConsoleString(client, "Crouch Ticks", jump.crouchTicks)); + + PrintToConsole(client, " #. %12t%12t%12t%12t%12t%9t%t", "Sync (Table)", "Gain (Table)", "Loss (Table)", "Airtime (Table)", "Width (Table)", "Overlap (Table)", "Dead Air (Table)"); + if (jump.strafes_ticks[0] > 0) + { + PrintToConsole(client, " 0. ---- ----- ----- %3.0f%% ----- -- --", GetStrafeAirtime(jump, 0)); + } + for (int strafe = 1; strafe <= jump.strafes && strafe < JS_MAX_TRACKED_STRAFES; strafe++) + { + PrintToConsole(client, + " %2d. %3.0f%% %5.2f %5.2f %3.0f%% %5.1f° %2d %2d", + strafe, + GetStrafeSync(jump, strafe), + jump.strafes_gain[strafe], + jump.strafes_loss[strafe], + GetStrafeAirtime(jump, strafe), + FloatAbs(jump.strafes_width[strafe]), + jump.strafes_overlap[strafe], + jump.strafes_deadair[strafe]); + } + PrintToConsole(client, ""); // New line +} + +static char[] GetSyncConsoleString(int client, float sync) +{ + char resultString[32]; + FormatEx(resultString, sizeof(resultString), "| %.0f%% %T", sync, "Sync", client); + return resultString; +} + +static char[] GetWidthConsoleString(int client, float width, int strafes) +{ + char resultString[32]; + FormatEx(resultString, sizeof(resultString), "| %.1f° %T", GetAverageStrafeWidth(strafes, width), "Width", client); + return resultString; +} + +// I couldn't really merge those together +static char[] GetFloatConsoleString1(int client, const char[] stat, float value) +{ + char resultString[32]; + FormatEx(resultString, sizeof(resultString), "| %.1f %T", value, stat, client); + return resultString; +} + +static char[] GetFloatConsoleString2(int client, const char[] stat, float value) +{ + char resultString[32]; + FormatEx(resultString, sizeof(resultString), "| %.2f %T", value, stat, client); + return resultString; +} + +static char[] GetIntConsoleString(int client, const char[] stat, int value) +{ + char resultString[32]; + FormatEx(resultString, sizeof(resultString), "| %d %T", value, stat, client); + return resultString; +} + + + +// CHAT REPORT + +static void DoChatReport(int client, bool isFailstat, Jump jump, int tier) +{ + int minChatTier = GOKZ_JS_GetOption(client, JSOption_MinChatTier); + if ((minChatTier == 0 || minChatTier > tier) // 0 means disabled + && GOKZ_JS_GetOption(client, JSOption_JumpstatsAlways) == JSToggleOption_Disabled) + { + return; + } + + char typePostfix[3], color[16], blockStats[32], extBlockStats[32]; + char releaseStats[32], edgeOffset[64], offsetEdge[32], missString[32]; + + if (isFailstat) + { + if (GOKZ_JS_GetOption(client, JSOption_FailstatsChat) == JSToggleOption_Disabled + && GOKZ_JS_GetOption(client, JSOption_JumpstatsAlways) == JSToggleOption_Disabled) + { + return; + } + strcopy(typePostfix, sizeof(typePostfix), "-F"); + strcopy(color, sizeof(color), "{grey}"); + } + else + { + strcopy(color, sizeof(color), gC_DistanceTierChatColours[tier]); + } + + if (jump.block > 0) + { + FormatEx(blockStats, sizeof(blockStats), " | %s", GetFloatChatString(client, "Edge", jump.edge)); + FormatEx(extBlockStats, sizeof(extBlockStats), " | %s", GetFloatChatString(client, "Deviation", jump.deviation)); + } + + if (jump.miss > 0.0) + { + FormatEx(missString, sizeof(missString), " | %s", GetFloatChatString(client, "Miss", jump.miss)); + } + + if (jump.edge > 0.0 || (jump.block > 0 && jump.edge == 0.0)) + { + if (jump.originalType == JumpType_LadderJump) + { + FormatEx(offsetEdge, sizeof(offsetEdge), " | %s", GetFloatChatString(client, "Edge", jump.edge)); + } + else + { + FormatEx(edgeOffset, sizeof(edgeOffset), " | %s", GetFloatChatString(client, "Edge", jump.edge)); + } + } + + if (jump.originalType == JumpType_LongJump || + jump.originalType == JumpType_LadderJump || + jump.originalType == JumpType_WeirdJump) + { + if (jump.releaseW >= 20 || jump.releaseW <= -20) + { + FormatEx(releaseStats, sizeof(releaseStats), " | {red}✗ {grey}W", GetReleaseChatString(client, "W Release", jump.releaseW)); + } + else + { + FormatEx(releaseStats, sizeof(releaseStats), " | %s", GetReleaseChatString(client, "W Release", jump.releaseW)); + } + } + else if (jump.crouchRelease < 20 && jump.crouchRelease > -20) + { + FormatEx(releaseStats, sizeof(releaseStats), " | %s", GetReleaseChatString(client, "Crouch Release", jump.crouchRelease)); + } + + if (jump.originalType == JumpType_LadderJump) + { + FormatEx(edgeOffset, sizeof(edgeOffset), " | %s", GetFloatChatString(client, "Offset Short", jump.offset)); + } + else + { + FormatEx(offsetEdge, sizeof(offsetEdge), " | %s", GetFloatChatString(client, "Offset", jump.offset)); + } + + GOKZ_PrintToChat(client, true, + "%s%s%s{grey}: %s%.1f{grey} | %s | %s%s%s", + color, + gC_JumpTypesShort[jump.originalType], + typePostfix, + color, + jump.distance, + GetStrafesSyncChatString(client, jump.strafes, jump.sync), + GetSpeedChatString(client, jump.preSpeed, jump.maxSpeed), + edgeOffset, + releaseStats); + + if (GOKZ_JS_GetOption(client, JSOption_ExtendedChatReport) == JSToggleOption_Enabled) + { + GOKZ_PrintToChat(client, false, + "%s | %s%s%s | %s | %s%s", + GetIntChatString(client, "Overlap", jump.overlap), + GetIntChatString(client, "Dead Air", jump.deadair), + offsetEdge, + extBlockStats, + GetWidthChatString(client, jump.width, jump.strafes), + GetFloatChatString(client, "Height", jump.height), + missString); + } +} + +static char[] GetStrafesSyncChatString(int client, int strafes, float sync) +{ + char resultString[64]; + FormatEx(resultString, sizeof(resultString), + "{lime}%d{grey} %T ({lime}%.0f%%%%{grey})", + strafes, "Strafes", client, sync); + return resultString; +} + +static char[] GetSpeedChatString(int client, float preSpeed, float maxSpeed) +{ + char resultString[64]; + FormatEx(resultString, sizeof(resultString), + "{lime}%.0f{grey} / {lime}%.0f{grey} %T", + preSpeed, maxSpeed, "Speed", client); + return resultString; +} + +static char[] GetReleaseChatString(int client, char[] releaseType, int release) +{ + char resultString[32]; + if (release == 0) + { + FormatEx(resultString, sizeof(resultString), + "{green}✓{grey} %T", + releaseType, client); + } + else if (release > 0) + { + FormatEx(resultString, sizeof(resultString), + "{red}+%d{grey} %T", + release, + releaseType, client); + } + else + { + FormatEx(resultString, sizeof(resultString), + "{blue}%d{grey} %T", + release, + releaseType, client); + } + return resultString; +} + +static char[] GetWidthChatString(int client, float width, int strafes) +{ + char resultString[32]; + FormatEx(resultString, sizeof(resultString), + "{lime}%.1f°{grey} %T", + GetAverageStrafeWidth(strafes, width), "Width", client); + return resultString; +} + +static float GetAverageStrafeWidth(int strafes, float totalWidth) +{ + if (strafes == 0) + { + return 0.0; + } + + return totalWidth / strafes; +} + +static char[] GetFloatChatString(int client, const char[] stat, float value) +{ + char resultString[32]; + FormatEx(resultString, sizeof(resultString), + "{lime}%.1f{grey} %T", + value, stat, client); + return resultString; +} + +static char[] GetIntChatString(int client, const char[] stat, int value) +{ + char resultString[32]; + FormatEx(resultString, sizeof(resultString), + "{lime}%d{grey} %T", + value, stat, client); + return resultString; +} + + + +// SOUNDS + +static bool LoadSounds() +{ + KeyValues kv = new KeyValues("sounds"); + if (!kv.ImportFromFile(JS_CFG_SOUNDS)) + { + return false; + } + + char downloadPath[256]; + for (int tier = DistanceTier_Impressive; tier < DISTANCETIER_COUNT; tier++) + { + kv.GetString(gC_DistanceTierKeys[tier], sounds[tier], sizeof(sounds[])); + FormatEx(downloadPath, sizeof(downloadPath), "sound/%s", sounds[tier]); + AddFileToDownloadsTable(downloadPath); + PrecacheSound(sounds[tier], true); + } + + delete kv; + return true; +} diff --git a/sourcemod/scripting/gokz-jumpstats/jump_tracking.sp b/sourcemod/scripting/gokz-jumpstats/jump_tracking.sp new file mode 100644 index 0000000..acd9442 --- /dev/null +++ b/sourcemod/scripting/gokz-jumpstats/jump_tracking.sp @@ -0,0 +1,1624 @@ +/* + Tracking of jump type, speed, strafes and more. +*/ + + + +// =====[ STRUCTS ]============================================================ + +enum struct Pose +{ + float position[3]; + float orientation[3]; + float velocity[3]; + float speed; + int duration; + int overlap; + int deadair; + int syncTicks; +} + + + +// =====[ GLOBAL VARIABLES ]=================================================== + +static ArrayList entityTouchList[MAXPLAYERS + 1]; +static int entityTouchDuration[MAXPLAYERS + 1]; +static int lastNoclipTime[MAXPLAYERS + 1]; +static int lastDuckbugTime[MAXPLAYERS + 1]; +static int lastGroundSpeedCappedTime[MAXPLAYERS + 1]; +static int lastMovementProcessedTime[MAXPLAYERS + 1]; +static float lastJumpButtonTime[MAXPLAYERS + 1]; +static bool validCmd[MAXPLAYERS + 1]; // Whether no illegal action is detected +static const float playerMins[3] = { -16.0, -16.0, 0.0 }; +static const float playerMaxs[3] = { 16.0, 16.0, 0.0 }; +static const float playerMinsEx[3] = { -20.0, -20.0, 0.0 }; +static const float playerMaxsEx[3] = { 20.0, 20.0, 0.0 }; +static bool doFailstatAlways[MAXPLAYERS + 1]; +static bool isInAir[MAXPLAYERS + 1]; +static const Jump emptyJump; +static Handle acceptInputHook; + + +// =====[ DEFINITIONS ]======================================================== + +// We cannot return enum structs and it's annoying +// The modulo operator is broken, so we can't access this using negative numbers +// (https://github.com/alliedmodders/sourcepawn/issues/456). We use the method +// described here instead: https://stackoverflow.com/a/42131603/7421666 +#define pose(%1) (poseHistory[this.jumper][((this.poseIndex + (%1)) % JS_FAILSTATS_MAX_TRACKED_TICKS + JS_FAILSTATS_MAX_TRACKED_TICKS) % JS_FAILSTATS_MAX_TRACKED_TICKS]) + + + +// =====[ TRACKING ]=========================================================== + +// We cannot put that into the tracker struct +Pose poseHistory[MAXPLAYERS + 1][JS_FAILSTATS_MAX_TRACKED_TICKS]; + +enum struct JumpTracker +{ + Jump jump; + int jumper; + int jumpoffTick; + int poseIndex; + int strafeDirection; + int lastJumpTick; + int lastTeleportTick; + int lastType; + int lastWPressedTick; + int nextCrouchRelease; + int syncTicks; + int lastCrouchPressedTick; + int tickCount; + bool failstatBlockDetected; + bool failstatFailed; + bool failstatValid; + float failstatBlockHeight; + float takeoffOrigin[3]; + float takeoffVelocity[3]; + float position[3]; + + void Init(int jumper) + { + this.jumper = jumper; + this.jump.jumper = jumper; + this.nextCrouchRelease = 100; + this.tickCount = 0; + } + + + + // =====[ ENTRYPOINTS ]======================================================= + + void Reset(bool jumped, bool ladderJump, bool jumpbug) + { + // We need to do that before we reset the jump cause we need the + // offset and type of the previous jump + this.lastType = this.DetermineType(jumped, ladderJump, jumpbug); + + // We need this for weirdjump w-release + int releaseWTemp = this.jump.releaseW; + + // Reset all stats + this.jump = emptyJump; + this.jump.type = this.lastType; + this.jump.jumper = this.jumper; + this.syncTicks = 0; + this.strafeDirection = StrafeDirection_None; + this.jump.releaseW = 100; + + // We have to show this on the jumpbug stat, not the lj stat + this.jump.crouchRelease = this.nextCrouchRelease; + this.nextCrouchRelease = 100; + + // Handle weirdjump w-release + if (this.jump.type == JumpType_WeirdJump) + { + this.jump.releaseW = releaseWTemp; + } + + // Reset pose history + this.poseIndex = 0; + // Update the first tick if it is a jumpbug. + this.UpdateOnGround(); + } + + void Begin() + { + // Initialize stats + this.CalcTakeoff(); + this.AdjustLowpreJumptypes(); + + this.failstatBlockDetected = this.jump.type != JumpType_LadderJump; + this.failstatFailed = false; + this.failstatValid = false; + this.failstatBlockHeight = this.takeoffOrigin[2]; + + // Store the original type for the always stats + this.jump.originalType = this.jump.type; + + // Notify everyone about the takeoff + Call_OnTakeoff(this.jumper, this.jump.type); + } + + void Update() + { + this.UpdatePoseHistory(); + + float speed = pose(0).speed; + + // Fix certain props that don't give you base velocity + /* + We check for speed reduction for abuse; while prop abuses increase speed, + wall collision will very likely (if not always) result in a speed reduction. + */ + float actualSpeed = GetVectorHorizontalDistance(this.position, pose(-1).position) / GetTickInterval(); + if (FloatAbs(speed - actualSpeed) > JS_SPEED_MODIFICATION_TOLERANCE && this.jump.duration != 0) + { + if (actualSpeed <= pose(-1).speed) + { + pose(0).speed = actualSpeed; + } + // This check is needed if you land via ducking instead of moving (duckbug) + else if (FloatAbs(actualSpeed) > EPSILON) + { + this.Invalidate(); + } + } + // You shouldn't gain any vertical velocity during a jump. + // This would only happen if you get boosted back up somehow, or you edgebugged. + if (!Movement_GetOnGround(this.jumper) && pose(0).velocity[2] > pose(-1).velocity[2]) + { + this.Invalidate(); + } + + this.jump.height = FloatMax(this.jump.height, this.position[2] - this.takeoffOrigin[2]); + this.jump.maxSpeed = FloatMax(this.jump.maxSpeed, speed); + this.jump.crouchTicks += Movement_GetDucking(this.jumper) ? 1 : 0; + this.syncTicks += speed > pose(-1).speed ? 1 : 0; + this.jump.duration++; + + this.UpdateStrafes(); + this.UpdateFailstat(); + this.UpdatePoseStats(); + + this.lastType = this.jump.type; + } + + void End() + { + // The jump is so invalid we don't even have to bother. + // Also check if the player just teleported. + if (this.jump.type == JumpType_FullInvalid || + this.tickCount - this.lastTeleportTick < JS_MIN_TELEPORT_DELAY) + { + return; + } + + // Measure last tick of jumpstat + this.Update(); + + // Fix the edgebug for the current position + Movement_GetNobugLandingOrigin(this.jumper, this.position); + + // There are a couple bugs and exploits we have to check for + this.EndBugfixExploits(); + + // Calculate the last stats + this.jump.distance = this.CalcDistance(); + this.jump.sync = float(this.syncTicks) / float(this.jump.duration) * 100.0; + this.jump.offset = this.position[2] - this.takeoffOrigin[2]; + + this.EndBlockDistance(); + + // Make sure the ladder has no offset for ladder jumps + if (this.jump.type == JumpType_LadderJump) + { + this.TraceLadderOffset(this.position[2]); + } + + // Calculate always-on stats + if (GOKZ_JS_GetOption(this.jumper, JSOption_JumpstatsAlways) == JSToggleOption_Enabled) + { + this.EndAlwaysJumpstats(); + } + + // Call the appropriate functions for either regular or always stats + this.Callback(); + } + + void Invalidate() + { + if (this.jump.type != JumpType_Invalid && + this.jump.type != JumpType_FullInvalid) + { + this.jump.type = JumpType_Invalid; + Call_OnJumpInvalidated(this.jumper); + } + } + + + + // =====[ BEGIN HELPERS ]===================================================== + + void CalcTakeoff() + { + // MovementAPI now correctly calculates the takeoff origin + // and velocity for jumpbugs. What is wrong though, is how + // mode plugins set bhop prespeed. + // Jumpbug takeoff origin is correct. + Movement_GetTakeoffOrigin(this.jumper, this.takeoffOrigin); + Movement_GetTakeoffVelocity(this.jumper, this.takeoffVelocity); + if (this.jump.type == JumpType_Jumpbug || this.jump.type == JumpType_MultiBhop + || this.jump.type == JumpType_Bhop || this.jump.type == JumpType_LowpreBhop + || this.jump.type == JumpType_LowpreWeirdJump || this.jump.type == JumpType_WeirdJump) + { + // Move the origin to the ground. + // The difference can only be 2 units maximum. + float bhopOrigin[3]; + CopyVector(this.takeoffOrigin, bhopOrigin); + bhopOrigin[2] -= 2.0; + TraceHullPosition(this.takeoffOrigin, bhopOrigin, playerMins, playerMaxs, this.takeoffOrigin); + } + + this.jump.preSpeed = Movement_GetTakeoffSpeed(this.jumper); + poseHistory[this.jumper][0].speed = this.jump.preSpeed; + } + + void AdjustLowpreJumptypes() + { + // Exclude SKZ and VNL stats. + if (GOKZ_GetCoreOption(this.jumper, Option_Mode) == Mode_KZTimer) + { + if (this.jump.type == JumpType_Bhop && + this.jump.preSpeed < 360.0) + { + this.jump.type = JumpType_LowpreBhop; + } + else if (this.jump.type == JumpType_WeirdJump && + this.jump.preSpeed < 300.0) + { + this.jump.type = JumpType_LowpreWeirdJump; + } + } + } + + int DetermineType(bool jumped, bool ladderJump, bool jumpbug) + { + if (gB_SpeedJustModifiedExternally[this.jumper] || this.tickCount - this.lastTeleportTick < JS_MIN_TELEPORT_DELAY) + { + return JumpType_Invalid; + } + else if (ladderJump) + { + // Check for ladder gliding. + float curtime = GetGameTime(); + float ignoreLadderJumpTime = GetEntPropFloat(this.jumper, Prop_Data, "m_ignoreLadderJumpTime"); + // Check if the ladder glide period is still active and if the player held jump in that period. + if (ignoreLadderJumpTime > curtime && + ignoreLadderJumpTime - IGNORE_JUMP_TIME < lastJumpButtonTime[this.jumper] && lastJumpButtonTime[this.jumper] < ignoreLadderJumpTime) + { + return JumpType_Invalid; + } + if (jumped) + { + return JumpType_Ladderhop; + } + else + { + return JumpType_LadderJump; + } + } + else if (!jumped) + { + return JumpType_Fall; + } + else if (jumpbug) + { + // Check for no offset + // The origin and offset is now correct, no workaround needed + if (FloatAbs(this.jump.offset) < JS_OFFSET_EPSILON && this.lastType == JumpType_LongJump) + { + return JumpType_Jumpbug; + } + else + { + return JumpType_Invalid; + } + } + else if (this.HitBhop() && !this.HitDuckbugRecently()) + { + // Check for no offset + if (FloatAbs(this.jump.offset) < JS_OFFSET_EPSILON) + { + switch (this.lastType) + { + case JumpType_LongJump:return JumpType_Bhop; + case JumpType_Bhop:return JumpType_MultiBhop; + case JumpType_LowpreBhop:return JumpType_MultiBhop; + case JumpType_MultiBhop:return JumpType_MultiBhop; + default:return JumpType_Other; + } + } + // Check for weird jump + else if (this.lastType == JumpType_Fall && + this.ValidWeirdJumpDropDistance()) + { + return JumpType_WeirdJump; + } + else + { + return JumpType_Other; + } + } + if (this.HitDuckbugRecently() || !this.GroundSpeedCappedRecently()) + { + return JumpType_Invalid; + } + return JumpType_LongJump; + } + + bool HitBhop() + { + return Movement_GetTakeoffCmdNum(this.jumper) - Movement_GetLandingCmdNum(this.jumper) <= JS_MAX_BHOP_GROUND_TICKS; + } + + bool ValidWeirdJumpDropDistance() + { + if (this.jump.offset < -1 * JS_MAX_WEIRDJUMP_FALL_OFFSET) + { + // Don't bother telling them if they fell a very far distance + if (!GetJumpstatsDisabled(this.jumper) && this.jump.offset >= -2 * JS_MAX_WEIRDJUMP_FALL_OFFSET) + { + GOKZ_PrintToChat(this.jumper, true, "%t", "Dropped Too Far (Weird Jump)", -1 * this.jump.offset, JS_MAX_WEIRDJUMP_FALL_OFFSET); + } + return false; + } + return true; + } + + bool HitDuckbugRecently() + { + return this.tickCount - lastDuckbugTime[this.jumper] <= JS_MAX_DUCKBUG_RESET_TICKS; + } + + bool GroundSpeedCappedRecently() + { + // A valid longjump needs to have their ground speed capped the tick right before. + return lastGroundSpeedCappedTime[this.jumper] == lastMovementProcessedTime[this.jumper]; + } + + // =====[ UPDATE HELPERS ]==================================================== + + // We split that up in two functions to get a reference to the pose so we + // don't have to recalculate the pose index all the time. + void UpdatePoseHistory() + { + this.poseIndex++; + this.UpdatePose(pose(0)); + } + + void UpdatePose(Pose p) + { + Movement_GetProcessingOrigin(this.jumper, p.position); + Movement_GetProcessingVelocity(this.jumper, p.velocity); + Movement_GetEyeAngles(this.jumper, p.orientation); + p.speed = GetVectorHorizontalLength(p.velocity); + + // We use the current position in a lot of places, so we store it + // separately to avoid calling 'pose' all the time. + CopyVector(p.position, this.position); + } + + // We split that up in two functions to get a reference to the pose so we + // don't have to recalculate the pose index all the time. We seperate that + // from UpdatePose() cause those stats are not calculated yet when we call that. + void UpdatePoseStats() + { + this.UpdatePoseStats_P(pose(0)); + } + + void UpdatePoseStats_P(Pose p) + { + p.duration = this.jump.duration; + p.syncTicks = this.syncTicks; + p.overlap = this.jump.overlap; + p.deadair = this.jump.deadair; + } + + void UpdateOnGround() + { + // We want accurate values to measure the first tick + this.UpdatePose(poseHistory[this.jumper][0]); + } + + void UpdateRelease() + { + // Using UpdateOnGround doesn't work because + // takeoff tick is calculated after leaving the ground. + this.jumpoffTick = Movement_GetTakeoffTick(this.jumper); + + // We also check IN_BACK cause that happens for backwards ladderjumps + if (Movement_GetButtons(this.jumper) & IN_FORWARD || + Movement_GetButtons(this.jumper) & IN_BACK) + { + this.lastWPressedTick = this.tickCount; + } + else if (this.jump.releaseW > 99) + { + this.jump.releaseW = this.lastWPressedTick - this.jumpoffTick + 1; + } + + if (Movement_GetButtons(this.jumper) & IN_DUCK) + { + this.lastCrouchPressedTick = this.tickCount; + this.nextCrouchRelease = 100; + } + else if (this.nextCrouchRelease > 99) + { + this.nextCrouchRelease = this.lastCrouchPressedTick - this.jumpoffTick - 95; + } + } + + void UpdateStrafes() + { + // Strafe direction + if (Movement_GetTurningLeft(this.jumper) && + this.strafeDirection != StrafeDirection_Left) + { + this.strafeDirection = StrafeDirection_Left; + this.jump.strafes++; + } + else if (Movement_GetTurningRight(this.jumper) && + this.strafeDirection != StrafeDirection_Right) + { + this.strafeDirection = StrafeDirection_Right; + this.jump.strafes++; + } + + // Overlap / Deadair + int buttons = Movement_GetButtons(this.jumper); + int overlap = buttons & IN_MOVERIGHT && buttons & IN_MOVELEFT ? 1 : 0; + int deadair = !(buttons & IN_MOVERIGHT) && !(buttons & IN_MOVELEFT) ? 1 : 0; + + // Sync / Gain / Loss + float deltaSpeed = pose(0).speed - pose(-1).speed; + bool gained = deltaSpeed > EPSILON; + bool lost = deltaSpeed < -EPSILON; + + // Width + float width = FloatAbs(CalcDeltaAngle(pose(0).orientation[1], pose(-1).orientation[1])); + + // Overall stats + this.jump.overlap += overlap; + this.jump.deadair += deadair; + this.jump.width += width; + + // Individual stats + if (this.jump.strafes >= JS_MAX_TRACKED_STRAFES) + { + return; + } + + int i = this.jump.strafes; + this.jump.strafes_ticks[i]++; + + this.jump.strafes_overlap[i] += overlap; + this.jump.strafes_deadair[i] += deadair; + this.jump.strafes_loss[i] += lost ? -1 * deltaSpeed : 0.0; + this.jump.strafes_width[i] += width; + + if (gained) + { + this.jump.strafes_gainTicks[i]++; + this.jump.strafes_gain[i] += deltaSpeed; + } + } + + void UpdateFailstat() + { + int coordDist, distSign; + float failstatPosition[3], block[3], traceStart[3]; + + // There's no point in going further if we're already done + if (this.failstatValid || this.failstatFailed) + { + return; + } + + // Get the coordinate system orientation. + GetCoordOrientation(this.position, this.takeoffOrigin, coordDist, distSign); + + // For ladderjumps we have to find the landing block early so we know at which point the jump failed. + // For this, we search for the block 10 units above the takeoff origin, assuming the player already + // traveled a significant enough distance in the direction of the block at this time. + if (!this.failstatBlockDetected && + this.position[2] - this.takeoffOrigin[2] < 10.0 && + this.jump.height > 10.0) + { + this.failstatBlockDetected = true; + + // Setup a trace to search for the block + CopyVector(this.takeoffOrigin, traceStart); + traceStart[2] -= 5.0; + CopyVector(traceStart, block); + traceStart[coordDist] += JS_MIN_LAJ_BLOCK_DISTANCE * distSign; + block[coordDist] += JS_MAX_LAJ_FAILSTAT_DISTANCE * distSign; + + // Search for the block + if (!TraceHullPosition(traceStart, block, playerMins, playerMaxs, block)) + { + // Mark the calculation as failed + this.failstatFailed = true; + return; + } + + // Find the block height + block[2] += 5.0; + this.failstatBlockHeight = this.FindBlockHeight(block, float(distSign) * 17.0, coordDist, 10.0) - 0.031250; + } + + // Only do the calculation once we're below the block level + if (this.position[2] >= this.failstatBlockHeight) + { + // We need that cause we can duck after getting lower than the failstat + // height and still make the block. + this.failstatValid = false; + return; + } + + // Calculate the true origin where the player would have hit the ground. + this.GetFailOrigin(this.failstatBlockHeight, failstatPosition, -1); + + // Calculate the jump distance. + this.jump.distance = FloatAbs(GetVectorHorizontalDistance(failstatPosition, this.takeoffOrigin)); + + // Construct the maximum landing origin, assuming the player reached + // at least the middle of the gap. + CopyVector(this.takeoffOrigin, block); + block[coordDist] = 2 * failstatPosition[coordDist] - this.takeoffOrigin[coordDist]; + block[view_as<int>(!coordDist)] = failstatPosition[view_as<int>(!coordDist)]; + block[2] = this.failstatBlockHeight; + + // Calculate block stats + if ((this.lastType == JumpType_LongJump || + this.lastType == JumpType_Bhop || + this.lastType == JumpType_MultiBhop || + this.lastType == JumpType_Ladderhop || + this.lastType == JumpType_WeirdJump || + this.lastType == JumpType_Jumpbug || + this.lastType == JumpType_LowpreBhop || + this.lastType == JumpType_LowpreWeirdJump) + && this.jump.distance >= JS_MIN_BLOCK_DISTANCE) + { + // Add the player model to the distance. + this.jump.distance += 32.0; + + this.CalcBlockStats(block, true); + } + else if (this.lastType == JumpType_LadderJump && + this.jump.distance >= JS_MIN_LAJ_BLOCK_DISTANCE) + { + this.CalcLadderBlockStats(block, true); + } + else + { + this.failstatFailed = true; + return; + } + + if (this.jump.block > 0) + { + // Calculate the last stats + this.jump.sync = float(this.syncTicks) / float(this.jump.duration) * 100.0; + this.jump.offset = failstatPosition[2] - this.takeoffOrigin[2]; + + // Call the callback for the reporting. + Call_OnFailstat(this.jump); + + // Mark the calculation as successful + this.failstatValid = true; + } + else + { + this.failstatFailed = true; + } + } + + + + // =====[ END HELPERS ]===================================================== + + float CalcDistance() + { + float distance = GetVectorHorizontalDistance(this.takeoffOrigin, this.position); + + // Check whether the distance is NaN + if (distance != distance) + { + this.Invalidate(); + + // We need that for the always stats + float pos[3]; + + // For the always stats it's ok to ignore the bug + Movement_GetOrigin(this.jumper, pos); + + distance = GetVectorHorizontalDistance(this.takeoffOrigin, pos); + } + + if (this.jump.originalType != JumpType_LadderJump) + { + distance += 32.0; + } + return distance; + } + + void EndBlockDistance() + { + if ((this.jump.type == JumpType_LongJump || + this.jump.type == JumpType_Bhop || + this.jump.type == JumpType_MultiBhop || + this.jump.type == JumpType_Ladderhop || + this.jump.type == JumpType_WeirdJump || + this.jump.type == JumpType_Jumpbug || + this.jump.type == JumpType_LowpreBhop || + this.jump.type == JumpType_LowpreWeirdJump) + && this.jump.distance >= JS_MIN_BLOCK_DISTANCE) + { + this.CalcBlockStats(this.position); + } + else if (this.jump.type == JumpType_LadderJump && + this.jump.distance >= JS_MIN_LAJ_BLOCK_DISTANCE) + { + this.CalcLadderBlockStats(this.position); + } + } + + void EndAlwaysJumpstats() + { + // Only calculate that form of edge if the regular block calculations failed + if (this.jump.block == 0 && this.jump.type != JumpType_LadderJump) + { + this.CalcAlwaysEdge(); + } + + // It's possible that the offset calculation failed with the nobug origin + // functions, so we have to fix it when that happens. The offset shouldn't + // be affected by the bug anyway. + if (this.jump.offset != this.jump.offset) + { + Movement_GetOrigin(this.jumper, this.position); + this.jump.offset = this.position[2] - this.takeoffOrigin[2]; + } + } + + void EndBugfixExploits() + { + // Try to prevent a form of booster abuse + if (!this.IsValidAirtime()) + { + this.Invalidate(); + } + } + + bool IsValidAirtime() + { + // Ladderjumps can have pretty much any airtime. + if (this.jump.type == JumpType_LadderJump) + { + return true; + } + + // Ladderhops can have a maximum airtime of 102. + if (this.jump.type == JumpType_Ladderhop + && this.jump.duration <= 102) + { + return true; + } + + // Crouchjumped or perfed longjumps/bhops can have a maximum of 101 airtime + // when the lj bug occurs. Since we've fixed that the airtime is valid. + if (this.jump.duration <= 101) + { + return true; + } + + return false; + } + + void Callback() + { + if (GOKZ_JS_GetOption(this.jumper, JSOption_JumpstatsAlways) == JSToggleOption_Enabled) + { + Call_OnJumpstatAlways(this.jump); + } + else + { + Call_OnLanding(this.jump); + } + } + + + + // =====[ ALWAYS FAILSTATS ]================================================== + + void AlwaysFailstat() + { + bool foundBlock; + int coordDist, distSign; + float traceStart[3], traceEnd[3], tracePos[3], landingPos[3], orientation[3], failOrigin[3]; + + // Check whether the jump was already handled + if (this.jump.type == JumpType_FullInvalid || this.failstatValid) + { + return; + } + + // Initialize the trace boxes + float traceMins[3] = { 0.0, 0.0, 0.0 }; + float traceLongMaxs[3] = { 0.0, 0.0, 200.0 }; + float traceShortMaxs[3] = { 0.0, 0.0, 54.0 }; + + // Clear the stats + this.jump.miss = 0.0; + this.jump.distance = 0.0; + + // Calculate the edge + this.CalcAlwaysEdge(); + + // We will search for the block based on the direction the player was looking + CopyVector(pose(0).orientation, orientation); + + // Get the landing orientation + coordDist = FloatAbs(orientation[0]) < FloatAbs(orientation[1]); + distSign = orientation[coordDist] > 0 ? 1 : -1; + + // Initialize the traces + CopyVector(this.position, traceStart); + CopyVector(this.position, traceEnd); + + // Assume the miss is less than 100 units + traceEnd[coordDist] += 100.0 * distSign; + + // Search for the end block with the long trace + foundBlock = TraceHullPosition(traceStart, traceEnd, traceMins, traceLongMaxs, tracePos); + + // If not even the long trace finds the block, we're out of luck + if (foundBlock) + { + // Search for the block height + tracePos[2] = this.position[2]; + foundBlock = this.TryFindBlockHeight(tracePos, landingPos, coordDist, distSign); + + // Maybe there was a headbanger, try with the short trace instead + if (!foundBlock) + { + if (TraceHullPosition(traceStart, traceEnd, traceMins, traceShortMaxs, tracePos)) + { + // Search for the height again + tracePos[2] = this.position[2]; + foundBlock = this.TryFindBlockHeight(tracePos, landingPos, coordDist, distSign); + } + } + + if (foundBlock) + { + // Search for the last tick the player was above the landing block elevation. + for (int i = 0; i < JS_FAILSTATS_MAX_TRACKED_TICKS; i++) + { + Pose p; + + // This copies it, but it shouldn't be that much of a problem + p = pose(-i); + + if(p.position[2] >= landingPos[2]) + { + // Calculate the correct fail position + this.GetFailOrigin(landingPos[2], failOrigin, -i); + + // Calculate all missing stats + this.jump.miss = FloatAbs(failOrigin[coordDist] - landingPos[coordDist]) - 16.0; + this.jump.distance = GetVectorHorizontalDistance(failOrigin, this.takeoffOrigin); + this.jump.offset = failOrigin[2] - this.takeoffOrigin[2]; + this.jump.duration = p.duration; + this.jump.overlap = p.overlap; + this.jump.deadair = p.deadair; + this.jump.sync = float(p.syncTicks) / float(this.jump.duration) * 100.0; + break; + } + } + } + } + + // Notify everyone about the jump + Call_OnFailstatAlways(this.jump); + + // Fully invalidate the jump cause we failstatted it already + this.jump.type = JumpType_FullInvalid; + } + + void CalcAlwaysEdge() + { + int coordDist, distSign; + float traceStart[3], traceEnd[3], velocity[3]; + float ladderNormal[3], ladderMins[3], ladderMaxs[3]; + + // Ladder jumps have a different definition of edge + if (this.jump.originalType == JumpType_LadderJump) + { + // Get a vector that points outwards from the lader towards the player + GetEntPropVector(this.jumper, Prop_Send, "m_vecLadderNormal", ladderNormal); + + // Initialize box to search for the ladder + if (ladderNormal[0] > ladderNormal[1]) + { + ladderMins = view_as<float>({ 0.0, -20.0, 0.0 }); + ladderMaxs = view_as<float>({ 0.0, 20.0, 0.0 }); + coordDist = 0; + } + else + { + ladderMins = view_as<float>({ -20.0, 0.0, 0.0 }); + ladderMaxs = view_as<float>({ 20.0, 0.0, 0.0 }); + coordDist = 1; + } + + // The max the ladder will be away is the player model (16) + danvari tech (10) + a safety unit + CopyVector(this.takeoffOrigin, traceEnd); + traceEnd[coordDist] += 27.0; + + // Search for the ladder + if (TraceHullPosition(this.takeoffOrigin, traceEnd, ladderMins, ladderMaxs, traceEnd)) + { + this.jump.edge = FloatAbs(traceEnd[coordDist] - this.takeoffOrigin[coordDist]) - 16.0; + } + } + else + { + // We calculate the orientation of the takeoff block based on what + // direction the player was moving + CopyVector(this.takeoffVelocity, velocity); + this.jump.edge = -1.0; + + // Calculate the takeoff orientation + coordDist = FloatAbs(velocity[0]) < FloatAbs(velocity[1]); + distSign = velocity[coordDist] > 0 ? 1 : -1; + + // Make sure we hit the jumpoff block + CopyVector(this.takeoffOrigin, traceEnd); + traceEnd[coordDist] -= 16.0 * distSign; + traceEnd[2] -= 1.0; + + // Assume a max edge of 20 + CopyVector(traceEnd, traceStart); + traceStart[coordDist] += 20.0 * distSign; + + // Trace the takeoff block + if (TraceRayPosition(traceStart, traceEnd, traceEnd)) + { + // Check whether the trace was stuck in the block from the beginning + if (FloatAbs(traceEnd[coordDist] - traceStart[coordDist]) > EPSILON) + { + // Block trace ends 0.03125 in front of the actual block. Adjust the edge correctly. + this.jump.edge = FloatAbs(traceEnd[coordDist] - this.takeoffOrigin[coordDist] + (16.0 - 0.03125) * distSign); + } + } + } + } + + bool TryFindBlockHeight(const float position[3], float result[3], int coordDist, int distSign) + { + float traceStart[3], traceEnd[3]; + + // Setup the trace points + CopyVector(position, traceStart); + traceStart[coordDist] += distSign; + CopyVector(traceStart, traceEnd); + + // We search in 54 unit steps + traceStart[2] += 54.0; + + // We search with multiple trace starts in case the landing block has a roof + for (int i = 0; i < 3; i += 1) + { + if (TraceRayPosition(traceStart, traceEnd, result)) + { + // Make sure the trace didn't get stuck right away + if (FloatAbs(result[2] - traceStart[2]) > EPSILON) + { + result[coordDist] -= distSign; + return true; + } + } + + // Try the next are to find the block. We use two different values to have + // some overlap in case the block perfectly aligns with the trace. + traceStart[2] += 54.0; + traceEnd[2] += 53.0; + } + + return false; + } + + + + // =====[ BLOCK STATS HELPERS ]=============================================== + + void CalcBlockStats(float landingOrigin[3], bool checkOffset = false) + { + int coordDist, coordDev, distSign; + float middle[3], startBlock[3], endBlock[3], sweepBoxMin[3], sweepBoxMax[3]; + + // Get the orientation of the block. + GetCoordOrientation(landingOrigin, this.takeoffOrigin, coordDist, distSign); + coordDev = !coordDist; + + // We can't make measurements from within an entity, so we assume the + // player had a remotely reasonable edge and that the middle of the jump + // is not over a block and then start measuring things out from there. + middle[coordDist] = (this.takeoffOrigin[coordDist] + landingOrigin[coordDist]) / 2; + middle[coordDev] = (this.takeoffOrigin[coordDev] + landingOrigin[coordDev]) / 2; + middle[2] = this.takeoffOrigin[2] - 1.0; + + // Get the deviation. + this.jump.deviation = FloatAbs(landingOrigin[coordDev] - this.takeoffOrigin[coordDev]); + + // Setup a sweeping line that starts in the middle and tries to search for the smallest + // block within the deviation of the player. + sweepBoxMin[coordDist] = 0.0; + sweepBoxMin[coordDev] = -this.jump.deviation - 16.0; + sweepBoxMin[2] = 0.0; + sweepBoxMax[coordDist] = 0.0; + sweepBoxMax[coordDev] = this.jump.deviation + 16.0; + sweepBoxMax[2] = 0.0; + + // Modify the takeoff and landing origins to line up with the middle and respect + // the bounding box of the player. + startBlock[coordDist] = this.takeoffOrigin[coordDist] - distSign * 16.0; + // Sometimes you can land 0.03125 units in front of a block, so the trace needs to be extended. + endBlock[coordDist] = landingOrigin[coordDist] + distSign * (16.0 + 0.03125); + startBlock[coordDev] = middle[coordDev]; + endBlock[coordDev] = middle[coordDev]; + startBlock[2] = middle[2]; + endBlock[2] = middle[2]; + + // Search for the blocks + if (!TraceHullPosition(middle, startBlock, sweepBoxMin, sweepBoxMax, startBlock) + || !TraceHullPosition(middle, endBlock, sweepBoxMin, sweepBoxMax, endBlock)) + { + return; + } + + // Make sure the edges of the blocks are parallel. + if (!this.BlockAreEdgesParallel(startBlock, endBlock, this.jump.deviation + 32.0, coordDist, coordDev)) + { + this.jump.block = 0; + this.jump.edge = -1.0; + return; + } + + // Needed for failstats, but you need the endBlock position for that, so we do it here. + if (checkOffset) + { + endBlock[2] += 1.0; + if (FloatAbs(this.FindBlockHeight(endBlock, float(distSign) * 17.0, coordDist, 1.0) - landingOrigin[2]) > JS_OFFSET_EPSILON) + { + return; + } + } + + // Calculate distance and edge. + this.jump.block = RoundFloat(FloatAbs(endBlock[coordDist] - startBlock[coordDist])); + // Block trace ends 0.03125 in front of the actual block. Adjust the edge correctly. + this.jump.edge = FloatAbs(startBlock[coordDist] - this.takeoffOrigin[coordDist] + (16.0 - 0.03125) * distSign); + + // Make it easier to check for blocks that too short + if (this.jump.block < JS_MIN_BLOCK_DISTANCE) + { + this.jump.block = 0; + this.jump.edge = -1.0; + } + } + + void CalcLadderBlockStats(float landingOrigin[3], bool checkOffset = false) + { + int coordDist, coordDev, distSign; + float sweepBoxMin[3], sweepBoxMax[3], blockPosition[3], ladderPosition[3], normalVector[3], endBlock[3], middle[3]; + + // Get the orientation of the block. + GetCoordOrientation(landingOrigin, this.takeoffOrigin, coordDist, distSign); + coordDev = !coordDist; + + // Get the deviation. + this.jump.deviation = FloatAbs(landingOrigin[coordDev] - this.takeoffOrigin[coordDev]); + + // Make sure the ladder is aligned. + GetEntPropVector(this.jumper, Prop_Send, "m_vecLadderNormal", normalVector); + if (FloatAbs(FloatAbs(normalVector[coordDist]) - 1.0) > EPSILON) + { + return; + } + + // Make sure we'll find the block and ladder. + CopyVector(this.takeoffOrigin, ladderPosition); + CopyVector(landingOrigin, endBlock); + endBlock[2] -= 1.0; + ladderPosition[2] = endBlock[2]; + + // Setup a line to search for the ladder. + sweepBoxMin[coordDist] = 0.0; + sweepBoxMin[coordDev] = -20.0; + sweepBoxMin[2] = 0.0; + sweepBoxMax[coordDist] = 0.0; + sweepBoxMax[coordDev] = 20.0; + sweepBoxMax[2] = 0.0; + middle[coordDist] = ladderPosition[coordDist] + distSign * JS_MIN_LAJ_BLOCK_DISTANCE; + middle[coordDev] = endBlock[coordDev]; + middle[2] = ladderPosition[2]; + + // Search for the ladder. + if (!TraceHullPosition(ladderPosition, middle, sweepBoxMin, sweepBoxMax, ladderPosition)) + { + return; + } + + // Find the block and make sure it's aligned + endBlock[coordDist] += distSign * 16.0; + if (!TraceRayPositionNormal(middle, endBlock, blockPosition, normalVector) + || FloatAbs(FloatAbs(normalVector[coordDist]) - 1.0) > EPSILON) + { + return; + } + + // Needed for failstats, but you need the blockPosition for that, so we do it here. + if (checkOffset) + { + blockPosition[2] += 1.0; + if (!this.TraceLadderOffset(this.FindBlockHeight(blockPosition, float(distSign), coordDist, 1.0) - 0.031250)) + { + return; + } + } + + // Calculate distance and edge. + this.jump.block = RoundFloat(FloatAbs(blockPosition[coordDist] - ladderPosition[coordDist])); + this.jump.edge = FloatAbs(this.takeoffOrigin[coordDist] - ladderPosition[coordDist]) - 16.0; + + // Make it easier to check for blocks that too short + if (this.jump.block < JS_MIN_LAJ_BLOCK_DISTANCE) + { + this.jump.block = 0; + this.jump.edge = -1.0; + } + } + + bool TraceLadderOffset(float landingHeight) + { + float traceOrigin[3], traceEnd[3], ladderTop[3], ladderNormal[3]; + + // Get normal vector of the ladder. + GetEntPropVector(this.jumper, Prop_Send, "m_vecLadderNormal", ladderNormal); + + // 10 units is the furthest away from the ladder surface you can get while still being on the ladder. + traceOrigin[0] = this.takeoffOrigin[0] - 10.0 * ladderNormal[0]; + traceOrigin[1] = this.takeoffOrigin[1] - 10.0 * ladderNormal[1]; + traceOrigin[2] = this.takeoffOrigin[2] + 5; + + CopyVector(traceOrigin, traceEnd); + traceEnd[2] = this.takeoffOrigin[2] - 10; + + // Search for the ladder + if (!TraceHullPosition(traceOrigin, traceEnd, playerMinsEx, playerMaxsEx, ladderTop) + || FloatAbs(ladderTop[2] - landingHeight) > JS_OFFSET_EPSILON) + { + this.Invalidate(); + return false; + } + return true; + } + + bool BlockTraceAligned(const float origin[3], const float end[3], int coordDist) + { + float normalVector[3]; + if (!TraceRayNormal(origin, end, normalVector)) + { + return false; + } + return FloatAbs(FloatAbs(normalVector[coordDist]) - 1.0) <= EPSILON; + } + + bool BlockAreEdgesParallel(const float startBlock[3], const float endBlock[3], float deviation, int coordDist, int coordDev) + { + float start[3], end[3], offset; + + // We use very short rays to find the blocks where they're supposed to be and use + // their normals to determine whether they're parallel or not. + offset = startBlock[coordDist] > endBlock[coordDist] ? 0.1 : -0.1; + + // We search for the blocks on both sides of the player, on one of the sides + // there has to be a valid block. + start[coordDist] = startBlock[coordDist] - offset; + start[coordDev] = startBlock[coordDev] - deviation; + start[2] = startBlock[2]; + + end[coordDist] = startBlock[coordDist] + offset; + end[coordDev] = startBlock[coordDev] - deviation; + end[2] = startBlock[2]; + + if (this.BlockTraceAligned(start, end, coordDist)) + { + start[coordDist] = endBlock[coordDist] + offset; + end[coordDist] = endBlock[coordDist] - offset; + if (this.BlockTraceAligned(start, end, coordDist)) + { + return true; + } + start[coordDist] = startBlock[coordDist] - offset; + end[coordDist] = startBlock[coordDist] + offset; + } + + start[coordDev] = startBlock[coordDev] + deviation; + end[coordDev] = startBlock[coordDev] + deviation; + + if (this.BlockTraceAligned(start, end, coordDist)) + { + start[coordDist] = endBlock[coordDist] + offset; + end[coordDist] = endBlock[coordDist] - offset; + if (this.BlockTraceAligned(start, end, coordDist)) + { + return true; + } + } + + return false; + } + + float FindBlockHeight(const float origin[3], float offset, int coord, float searchArea) + { + float block[3], traceStart[3], traceEnd[3], normalVector[3]; + + // Setup the trace. + CopyVector(origin, traceStart); + traceStart[coord] += offset; + CopyVector(traceStart, traceEnd); + traceStart[2] += searchArea; + traceEnd[2] -= searchArea; + + // Find the block height. + if (!TraceRayPositionNormal(traceStart, traceEnd, block, normalVector) + || FloatAbs(normalVector[2] - 1.0) > EPSILON) + { + return -99999999999999999999.0; // Let's hope that's wrong enough + } + + return block[2]; + } + + void GetFailOrigin(float planeHeight, float result[3], int poseIndex) + { + float newVel[3], oldVel[3]; + + // Calculate the actual velocity. + CopyVector(pose(poseIndex).velocity, oldVel); + ScaleVector(oldVel, GetTickInterval()); + + // Calculate at which percentage of the velocity vector we hit the plane. + float scale = (planeHeight - pose(poseIndex).position[2]) / oldVel[2]; + + // Calculate the position we hit the plane. + CopyVector(oldVel, newVel); + ScaleVector(newVel, scale); + AddVectors(pose(poseIndex).position, newVel, result); + } +} + +static JumpTracker jumpTrackers[MAXPLAYERS + 1]; + + + +// =====[ HELPER FUNCTIONS ]=================================================== + +void GetCoordOrientation(const float vec1[3], const float vec2[3], int &coordDist, int &distSign) +{ + coordDist = FloatAbs(vec1[0] - vec2[0]) < FloatAbs(vec1[1] - vec2[1]); + distSign = vec1[coordDist] > vec2[coordDist] ? 1 : -1; +} + +bool TraceRayPosition(const float traceStart[3], const float traceEnd[3], float position[3]) +{ + Handle trace = TR_TraceRayFilterEx(traceStart, traceEnd, MASK_PLAYERSOLID, RayType_EndPoint, TraceEntityFilterPlayers); + if (TR_DidHit(trace)) + { + TR_GetEndPosition(position, trace); + delete trace; + return true; + } + delete trace; + return false; +} + +static bool TraceRayNormal(const float traceStart[3], const float traceEnd[3], float rayNormal[3]) +{ + Handle trace = TR_TraceRayFilterEx(traceStart, traceEnd, MASK_PLAYERSOLID, RayType_EndPoint, TraceEntityFilterPlayers); + if (TR_DidHit(trace)) + { + TR_GetPlaneNormal(trace, rayNormal); + delete trace; + return true; + } + delete trace; + return false; +} + +static bool TraceRayPositionNormal(const float traceStart[3], const float traceEnd[3], float position[3], float rayNormal[3]) +{ + Handle trace = TR_TraceRayFilterEx(traceStart, traceEnd, MASK_PLAYERSOLID, RayType_EndPoint, TraceEntityFilterPlayers); + if (TR_DidHit(trace)) + { + TR_GetEndPosition(position, trace); + TR_GetPlaneNormal(trace, rayNormal); + delete trace; + return true; + } + delete trace; + return false; +} + +static bool TraceHullPosition(const float traceStart[3], const float traceEnd[3], const float mins[3], const float maxs[3], float position[3]) +{ + Handle trace = TR_TraceHullFilterEx(traceStart, traceEnd, mins, maxs, MASK_PLAYERSOLID, TraceEntityFilterPlayers); + if (TR_DidHit(trace)) + { + TR_GetEndPosition(position, trace); + delete trace; + return true; + } + delete trace; + return false; +} + + + +// =====[ EVENTS ]============================================================= + +void OnPluginStart_JumpTracking() +{ + GameData gd = LoadGameConfigFile("sdktools.games/engine.csgo"); + int offset = gd.GetOffset("AcceptInput"); + if (offset == -1) + { + SetFailState("Failed to get AcceptInput offset"); + } + + acceptInputHook = DHookCreate(offset, HookType_Entity, ReturnType_Bool, ThisPointer_CBaseEntity, DHooks_AcceptInput); + DHookAddParam(acceptInputHook, HookParamType_CharPtr); + DHookAddParam(acceptInputHook, HookParamType_CBaseEntity); + DHookAddParam(acceptInputHook, HookParamType_CBaseEntity); + //varaint_t is a union of 12 (float[3]) plus two int type params 12 + 8 = 20 + DHookAddParam(acceptInputHook, HookParamType_Object, 20, DHookPass_ByVal|DHookPass_ODTOR|DHookPass_OCTOR|DHookPass_OASSIGNOP); + DHookAddParam(acceptInputHook, HookParamType_Int); + delete gd; +} + +void OnOptionChanged_JumpTracking(int client, const char[] option) +{ + if (StrEqual(option, gC_CoreOptionNames[Option_Mode])) + { + jumpTrackers[client].jump.type = JumpType_FullInvalid; + } +} + +void OnClientPutInServer_JumpTracking(int client) +{ + if (entityTouchList[client] != INVALID_HANDLE) + { + delete entityTouchList[client]; + } + entityTouchList[client] = new ArrayList(); + lastNoclipTime[client] = 0; + lastDuckbugTime[client] = 0; + lastJumpButtonTime[client] = 0.0; + jumpTrackers[client].Init(client); + DHookEntity(acceptInputHook, true, client); +} + + +// This was originally meant for invalidating jumpstats but was removed. +void OnJumpInvalidated_JumpTracking(int client) +{ + jumpTrackers[client].Invalidate(); +} + +void OnJumpValidated_JumpTracking(int client, bool jumped, bool ladderJump, bool jumpbug) +{ + if (!validCmd[client]) + { + return; + } + + // Update: Takeoff speed should be always correct with the new MovementAPI. + if (jumped) + { + jumpTrackers[client].lastJumpTick = jumpTrackers[client].tickCount; + } + jumpTrackers[client].Reset(jumped, ladderJump, jumpbug); + jumpTrackers[client].Begin(); +} + +void OnStartTouchGround_JumpTracking(int client) +{ + if (!doFailstatAlways[client]) + { + jumpTrackers[client].End(); + } +} + +void OnStartTouch_JumpTracking(int client, int touched) +{ + if (entityTouchList[client] != INVALID_HANDLE) + { + entityTouchList[client].Push(touched); + // Do not immediately invalidate jumps upon collision. + // Give the player a few ticks of leniency for late ducking. + } +} + +void OnTouch_JumpTracking(int client) +{ + if (entityTouchList[client] != INVALID_HANDLE && entityTouchList[client].Length > 0) + { + entityTouchDuration[client]++; + } + if (!Movement_GetOnGround(client) && entityTouchDuration[client] > JS_TOUCH_GRACE_TICKS) + { + jumpTrackers[client].Invalidate(); + } +} + +void OnEndTouch_JumpTracking(int client, int touched) +{ + if (entityTouchList[client] != INVALID_HANDLE) + { + int index = entityTouchList[client].FindValue(touched); + if (index != -1) + { + entityTouchList[client].Erase(index); + } + if (entityTouchList[client].Length == 0) + { + entityTouchDuration[client] = 0; + } + } +} + +void OnPlayerRunCmd_JumpTracking(int client, int buttons, int tickcount) +{ + if (!IsValidClient(client) || !IsPlayerAlive(client)) + { + return; + } + + jumpTrackers[client].tickCount = tickcount; + + if (GetClientButtons(client) & IN_JUMP) + { + lastJumpButtonTime[client] = GetGameTime(); + } + + if (CheckNoclip(client)) + { + lastNoclipTime[client] = tickcount; + } + + // Don't bother checking if player is already in air and jumpstat is already invalid + if (Movement_GetOnGround(client) || + jumpTrackers[client].jump.type != JumpType_FullInvalid) + { + UpdateValidCmd(client, buttons); + } +} + +public Action Movement_OnWalkMovePost(int client) +{ + lastGroundSpeedCappedTime[client] = jumpTrackers[client].tickCount; + return Plugin_Continue; +} + +public Action Movement_OnPlayerMovePost(int client) +{ + lastMovementProcessedTime[client] = jumpTrackers[client].tickCount; + return Plugin_Continue; +} + +public void OnPlayerRunCmdPost_JumpTracking(int client) +{ + if (!IsValidClient(client) || !IsPlayerAlive(client)) + { + return; + } + + // Check for always failstats + if (doFailstatAlways[client]) + { + doFailstatAlways[client] = false; + // Prevent TP shenanigans that would trigger failstats + //jumpTypeLast[client] = JumpType_Invalid; + + if (GOKZ_JS_GetOption(client, JSOption_JumpstatsAlways) == JSToggleOption_Enabled && + isInAir[client]) + { + jumpTrackers[client].AlwaysFailstat(); + } + } + + if (!Movement_GetOnGround(client)) + { + isInAir[client] = true; + jumpTrackers[client].Update(); + } + + if (Movement_GetOnGround(client) || + Movement_GetMovetype(client) == MOVETYPE_LADDER) + { + isInAir[client] = false; + jumpTrackers[client].UpdateOnGround(); + } + + // We always have to track this, no matter if in the air or not + jumpTrackers[client].UpdateRelease(); + + if (Movement_GetDuckbugged(client)) + { + lastDuckbugTime[client] = jumpTrackers[client].tickCount; + } +} + +static MRESReturn DHooks_AcceptInput(int client, DHookReturn hReturn, DHookParam hParams) +{ + if (!IsValidClient(client) || !IsPlayerAlive(client)) + { + return MRES_Ignored; + } + + // Get args + static char param[64]; + static char command[64]; + DHookGetParamString(hParams, 1, command, sizeof(command)); + if (StrEqual(command, "AddOutput")) + { + DHookGetParamObjectPtrString(hParams, 4, 0, ObjectValueType_String, param, sizeof(param)); + char kv[16]; + SplitString(param, " ", kv, sizeof(kv)); + // KVs are case insensitive. + if (StrEqual(kv[0], "origin", false)) + { + // The player technically did not get "teleported" but the origin gets changed regardless, + // which effectively is a teleport. + OnTeleport_FailstatAlways(client); + } + } + return MRES_Ignored; +} + +// =====[ CHECKS ]===== + +static void UpdateValidCmd(int client, int buttons) +{ + if (!CheckGravity(client) + || !CheckBaseVelocity(client) + || !CheckInWater(client) + || !CheckTurnButtons(buttons)) + { + InvalidateJumpstat(client); + validCmd[client] = false; + } + else + { + validCmd[client] = true; + } + + if (jumpTrackers[client].tickCount - lastNoclipTime[client] < GOKZ_JUMPSTATS_NOCLIP_RESET_TICKS) + { + jumpTrackers[client].jump.type = JumpType_FullInvalid; + } + + if (!CheckLadder(client)) + { + InvalidateJumpstat(client); + } +} + +static bool CheckGravity(int client) +{ + float gravity = Movement_GetGravity(client); + // Allow 1.0 and 0.0 gravity as both values appear during normal gameplay + if (FloatAbs(gravity - 1.0) > EPSILON && FloatAbs(gravity) > EPSILON) + { + return false; + } + return true; +} + +static bool CheckBaseVelocity(int client) +{ + float baseVelocity[3]; + Movement_GetBaseVelocity(client, baseVelocity); + if (FloatAbs(baseVelocity[0]) > EPSILON || + FloatAbs(baseVelocity[1]) > EPSILON || + FloatAbs(baseVelocity[2]) > EPSILON) + { + return false; + } + return true; +} + +static bool CheckInWater(int client) +{ + int waterLevel = GetEntProp(client, Prop_Data, "m_nWaterLevel"); + return waterLevel == 0; +} + +static bool CheckTurnButtons(int buttons) +{ + // Don't allow +left or +right turns binds + return !(buttons & (IN_LEFT | IN_RIGHT)); +} + +static bool CheckNoclip(int client) +{ + return Movement_GetMovetype(client) == MOVETYPE_NOCLIP; +} + +static bool CheckLadder(int client) +{ + return Movement_GetMovetype(client) != MOVETYPE_LADDER; +} + + + +// =====[ EXTERNAL HELPER FUNCTIONS ]========================================== + +void InvalidateJumpstat(int client) +{ + jumpTrackers[client].Invalidate(); +} + +float GetStrafeSync(Jump jump, int strafe) +{ + if (strafe < JS_MAX_TRACKED_STRAFES) + { + return float(jump.strafes_gainTicks[strafe]) + / float(jump.strafes_ticks[strafe]) + * 100.0; + } + else + { + return 0.0; + } +} + +float GetStrafeAirtime(Jump jump, int strafe) +{ + if (strafe < JS_MAX_TRACKED_STRAFES) + { + return float(jump.strafes_ticks[strafe]) + / float(jump.duration) + * 100.0; + } + else + { + return 0.0; + } +} + +void OnTeleport_FailstatAlways(int client) +{ + // We want to synchronize all of that + doFailstatAlways[client] = true; + + // gokz-core does that too, but for some reason we have to do it again + InvalidateJumpstat(client); + + jumpTrackers[client].lastTeleportTick = jumpTrackers[client].tickCount; +} diff --git a/sourcemod/scripting/gokz-jumpstats/jump_validating.sp b/sourcemod/scripting/gokz-jumpstats/jump_validating.sp new file mode 100644 index 0000000..c6835c7 --- /dev/null +++ b/sourcemod/scripting/gokz-jumpstats/jump_validating.sp @@ -0,0 +1,82 @@ +/* + Invalidating invalid jumps, such as ones with a modified velocity. +*/ + +static Handle processMovementHookPost; + +void OnPluginStart_JumpValidating() +{ + Handle gamedataConf = LoadGameConfigFile("gokz-core.games"); + if (gamedataConf == null) + { + SetFailState("Failed to load gokz-core gamedata"); + } + + // CreateInterface + // Thanks SlidyBat and ici + StartPrepSDKCall(SDKCall_Static); + if (!PrepSDKCall_SetFromConf(gamedataConf, SDKConf_Signature, "CreateInterface")) + { + SetFailState("Failed to get CreateInterface"); + } + PrepSDKCall_AddParameter(SDKType_String, SDKPass_Pointer); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Pointer, VDECODE_FLAG_ALLOWNULL); + PrepSDKCall_SetReturnInfo(SDKType_PlainOldData, SDKPass_Plain); + Handle CreateInterface = EndPrepSDKCall(); + + if (CreateInterface == null) + { + SetFailState("Unable to prepare SDKCall for CreateInterface"); + } + + char interfaceName[64]; + + // ProcessMovement + if (!GameConfGetKeyValue(gamedataConf, "IGameMovement", interfaceName, sizeof(interfaceName))) + { + SetFailState("Failed to get IGameMovement interface name"); + } + Address IGameMovement = SDKCall(CreateInterface, interfaceName, 0); + if (!IGameMovement) + { + SetFailState("Failed to get IGameMovement pointer"); + } + + int offset = GameConfGetOffset(gamedataConf, "ProcessMovement"); + if (offset == -1) + { + SetFailState("Failed to get ProcessMovement offset"); + } + + processMovementHookPost = DHookCreate(offset, HookType_Raw, ReturnType_Void, ThisPointer_Ignore, DHook_ProcessMovementPost); + DHookAddParam(processMovementHookPost, HookParamType_CBaseEntity); + DHookAddParam(processMovementHookPost, HookParamType_ObjectPtr); + DHookRaw(processMovementHookPost, false, IGameMovement); +} + +static MRESReturn DHook_ProcessMovementPost(Handle hParams) +{ + int client = DHookGetParam(hParams, 1); + if (!IsValidClient(client) || IsFakeClient(client)) + { + return MRES_Ignored; + } + float pVelocity[3], velocity[3]; + Movement_GetProcessingVelocity(client, pVelocity); + Movement_GetVelocity(client, velocity); + + gB_SpeedJustModifiedExternally[client] = false; + for (int i = 0; i < 3; i++) + { + if (FloatAbs(pVelocity[i] - velocity[i]) > EPSILON) + { + // The current velocity doesn't match the velocity of the end of movement processing, + // so it must have been modified by something like a trigger. + InvalidateJumpstat(client); + gB_SpeedJustModifiedExternally[client] = true; + break; + } + } + + return MRES_Ignored; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-jumpstats/options.sp b/sourcemod/scripting/gokz-jumpstats/options.sp new file mode 100644 index 0000000..7e0e9e9 --- /dev/null +++ b/sourcemod/scripting/gokz-jumpstats/options.sp @@ -0,0 +1,86 @@ +/* + Options for jumpstats, including an option to disable it completely. +*/ + + + +// =====[ PUBLIC ]===== + +bool GetJumpstatsDisabled(int client) +{ + return GOKZ_JS_GetOption(client, JSOption_JumpstatsMaster) == JSToggleOption_Disabled + || (GOKZ_JS_GetOption(client, JSOption_MinChatTier) == DistanceTier_None + && GOKZ_JS_GetOption(client, JSOption_MinConsoleTier) == DistanceTier_None + && GOKZ_JS_GetOption(client, JSOption_MinSoundTier) == DistanceTier_None + && GOKZ_JS_GetOption(client, JSOption_FailstatsConsole) == JSToggleOption_Disabled + && GOKZ_JS_GetOption(client, JSOption_FailstatsChat) == JSToggleOption_Disabled + && GOKZ_JS_GetOption(client, JSOption_JumpstatsAlways) == JSToggleOption_Disabled); +} + + + +// =====[ EVENTS ]===== + +void OnOptionsMenuReady_Options() +{ + RegisterOptions(); +} + +void OnClientPutInServer_Options(int client) +{ + if (GOKZ_JS_GetOption(client, JSOption_MinSoundTier) == DistanceTier_Meh) + { + GOKZ_JS_SetOption(client, JSOption_MinSoundTier, DistanceTier_Impressive); + } +} + +void OnOptionChanged_Options(int client, const char[] option, any newValue) +{ + JSOption jsOption; + if (GOKZ_JS_IsJSOption(option, jsOption)) + { + if (jsOption == JSOption_MinSoundTier && newValue == DistanceTier_Meh) + { + GOKZ_JS_SetOption(client, JSOption_MinSoundTier, DistanceTier_Impressive); + } + else + { + PrintOptionChangeMessage(client, jsOption, newValue); + } + } +} + + + +// =====[ PRIVATE ]===== + +static void RegisterOptions() +{ + for (JSOption option; option < JSOPTION_COUNT; option++) + { + GOKZ_RegisterOption(gC_JSOptionNames[option], gC_JSOptionDescriptions[option], + OptionType_Int, gI_JSOptionDefaults[option], 0, gI_JSOptionCounts[option] - 1); + } +} + +static void PrintOptionChangeMessage(int client, JSOption option, any newValue) +{ + // NOTE: Not all options have a message for when they are changed. + switch (option) + { + case JSOption_JumpstatsMaster: + { + switch (newValue) + { + case JSToggleOption_Enabled: + { + GOKZ_PrintToChat(client, true, "%t", "Jumpstats Option - Master Switch - Enable"); + } + case JSToggleOption_Disabled: + { + GOKZ_PrintToChat(client, true, "%t", "Jumpstats Option - Master Switch - Disable"); + } + } + } + } +} diff --git a/sourcemod/scripting/gokz-jumpstats/options_menu.sp b/sourcemod/scripting/gokz-jumpstats/options_menu.sp new file mode 100644 index 0000000..903a8bb --- /dev/null +++ b/sourcemod/scripting/gokz-jumpstats/options_menu.sp @@ -0,0 +1,145 @@ +static TopMenu optionsTopMenu; +static TopMenuObject catJumpstats; +static TopMenuObject itemsJumpstats[JSOPTION_COUNT]; + + + +// =====[ PUBLIC ]===== + +void DisplayJumpstatsOptionsMenu(int client) +{ + optionsTopMenu.DisplayCategory(catJumpstats, client); +} + + + +// =====[ EVENTS ]===== + +void OnOptionsMenuCreated_OptionsMenu(TopMenu topMenu) +{ + if (optionsTopMenu == topMenu && catJumpstats != INVALID_TOPMENUOBJECT) + { + return; + } + + catJumpstats = topMenu.AddCategory(JS_OPTION_CATEGORY, TopMenuHandler_Categories); +} + +void OnOptionsMenuReady_OptionsMenu(TopMenu topMenu) +{ + // Make sure category exists + if (catJumpstats == INVALID_TOPMENUOBJECT) + { + GOKZ_OnOptionsMenuCreated(topMenu); + } + + if (optionsTopMenu == topMenu) + { + return; + } + + optionsTopMenu = topMenu; + + // Add HUD option items + for (int option = 0; option < view_as<int>(JSOPTION_COUNT); option++) + { + itemsJumpstats[option] = optionsTopMenu.AddItem(gC_JSOptionNames[option], TopMenuHandler_HUD, catJumpstats); + } +} + +public void TopMenuHandler_Categories(TopMenu topmenu, TopMenuAction action, TopMenuObject topobj_id, int param, char[] buffer, int maxlength) +{ + if (action == TopMenuAction_DisplayOption || action == TopMenuAction_DisplayTitle) + { + if (topobj_id == catJumpstats) + { + Format(buffer, maxlength, "%T", "Options Menu - Jumpstats", param); + } + } +} + +public void TopMenuHandler_HUD(TopMenu topmenu, TopMenuAction action, TopMenuObject topobj_id, int param, char[] buffer, int maxlength) +{ + JSOption option = JSOPTION_INVALID; + for (int i = 0; i < view_as<int>(JSOPTION_COUNT); i++) + { + if (topobj_id == itemsJumpstats[i]) + { + option = view_as<JSOption>(i); + break; + } + } + + if (option == JSOPTION_INVALID) + { + return; + } + + if (action == TopMenuAction_DisplayOption) + { + if (option == JSOption_JumpstatsMaster || + option == JSOption_ExtendedChatReport || + option == JSOption_FailstatsConsole || + option == JSOption_FailstatsChat || + option == JSOption_JumpstatsAlways) + { + FormatToggleableOptionDisplay(param, option, buffer, maxlength); + } + else + { + FormatDistanceTierOptionDisplay(param, option, buffer, maxlength); + } + } + else if (action == TopMenuAction_SelectOption) + { + GOKZ_JS_CycleOption(param, option); + optionsTopMenu.Display(param, TopMenuPosition_LastCategory); + } +} + + + +// =====[ PRIVATE ]===== + +static void FormatToggleableOptionDisplay(int client, JSOption option, char[] buffer, int maxlength) +{ + if (GOKZ_JS_GetOption(client, option) == JSToggleOption_Disabled) + { + FormatEx(buffer, maxlength, "%T - %T", + gI_JSOptionPhrases[option], client, + "Options Menu - Disabled", client); + } + else + { + FormatEx(buffer, maxlength, "%T - %T", + gI_JSOptionPhrases[option], client, + "Options Menu - Enabled", client); + } +} + +static void FormatDistanceTierOptionDisplay(int client, JSOption option, char[] buffer, int maxlength) +{ + int optionValue = GOKZ_JS_GetOption(client, option); + if (optionValue == DistanceTier_None) // Disabled + { + FormatEx(buffer, maxlength, "%T - %T", + gI_JSOptionPhrases[option], client, + "Options Menu - Disabled", client); + } + else + { + // Add a plus sign to anything below the highest tier + if (optionValue < DISTANCETIER_COUNT - 1) + { + FormatEx(buffer, maxlength, "%T - %s+", + gI_JSOptionPhrases[option], client, + gC_DistanceTiers[optionValue]); + } + else + { + FormatEx(buffer, maxlength, "%T - %s", + gI_JSOptionPhrases[option], client, + gC_DistanceTiers[optionValue]); + } + } +} diff --git a/sourcemod/scripting/gokz-localdb.sp b/sourcemod/scripting/gokz-localdb.sp new file mode 100644 index 0000000..d9b07c2 --- /dev/null +++ b/sourcemod/scripting/gokz-localdb.sp @@ -0,0 +1,188 @@ +#include <sourcemod> + +#include <geoip> + +#include <gokz/core> +#include <gokz/localdb> + +#undef REQUIRE_EXTENSIONS +#undef REQUIRE_PLUGIN +#include <gokz/jumpstats> +#include <updater> + +#pragma newdecls required +#pragma semicolon 1 + + + +public Plugin myinfo = +{ + name = "GOKZ Local DB", + author = "DanZay", + description = "Provides database for players, maps, courses and times", + version = GOKZ_VERSION, + url = GOKZ_SOURCE_URL +}; + +#define UPDATER_URL GOKZ_UPDATER_BASE_URL..."gokz-localdb.txt" + +Database gH_DB = null; +DatabaseType g_DBType = DatabaseType_None; +bool gB_ClientSetUp[MAXPLAYERS + 1]; +bool gB_ClientPostAdminChecked[MAXPLAYERS + 1]; +bool gB_Cheater[MAXPLAYERS + 1]; +int gI_PBJSCache[MAXPLAYERS + 1][MODE_COUNT][JUMPTYPE_COUNT][JUMPSTATDB_CACHE_COUNT]; +bool gB_MapSetUp; +int gI_DBCurrentMapID; + +#include "gokz-localdb/api.sp" +#include "gokz-localdb/commands.sp" +#include "gokz-localdb/options.sp" + +#include "gokz-localdb/db/sql.sp" +#include "gokz-localdb/db/helpers.sp" +#include "gokz-localdb/db/cache_js.sp" +#include "gokz-localdb/db/create_tables.sp" +#include "gokz-localdb/db/save_js.sp" +#include "gokz-localdb/db/save_time.sp" +#include "gokz-localdb/db/set_cheater.sp" +#include "gokz-localdb/db/setup_client.sp" +#include "gokz-localdb/db/setup_database.sp" +#include "gokz-localdb/db/setup_map.sp" +#include "gokz-localdb/db/setup_map_courses.sp" +#include "gokz-localdb/db/timer_setup.sp" + + + +// =====[ PLUGIN EVENTS ]===== + +public APLRes AskPluginLoad2(Handle myself, bool late, char[] error, int err_max) +{ + CreateNatives(); + RegPluginLibrary("gokz-localdb"); + return APLRes_Success; +} + +public void OnPluginStart() +{ + LoadTranslations("gokz-localdb.phrases"); + + CreateGlobalForwards(); + RegisterCommands(); + DB_SetupDatabase(); +} + +public void OnAllPluginsLoaded() +{ + if (LibraryExists("updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + + char auth[32]; + for (int client = 1; client <= MaxClients; client++) + { + if (IsClientAuthorized(client) && GetClientAuthId(client, AuthId_Engine, auth, sizeof(auth))) + { + OnClientAuthorized(client, auth); + } + } +} + +public void OnLibraryAdded(const char[] name) +{ + if (StrEqual(name, "updater")) + { + Updater_AddPlugin(UPDATER_URL); + } +} + + + +// =====[ OTHER EVENTS ]===== + +public void OnConfigsExecuted() +{ + DB_SetupMap(); +} + +public void GOKZ_DB_OnMapSetup(int mapID) +{ + DB_SetupMapCourses(); + + for (int client = 1; client < MAXPLAYERS + 1; client++) + { + if (IsValidClient(client) && !IsFakeClient(client) && + gB_ClientPostAdminChecked[client] && + GOKZ_GetOption(client, gC_DBOptionNames[DBOption_AutoLoadTimerSetup]) == DBOption_Enabled) + { + DB_LoadTimerSetup(client); + } + } +} + +public void OnMapEnd() +{ + gB_MapSetUp = false; +} + +public void OnClientAuthorized(int client, const char[] auth) +{ + DB_SetupClient(client); +} + +public void OnClientPostAdminCheck(int client) +{ + // We need this after OnClientPutInServer cause that's where the VBs get reset + gB_ClientPostAdminChecked[client] = true; + + if (gB_MapSetUp && GOKZ_GetOption(client, gC_DBOptionNames[DBOption_AutoLoadTimerSetup]) == DBOption_Enabled) + { + DB_LoadTimerSetup(client); + } +} + +public void GOKZ_DB_OnClientSetup(int client, int steamID, bool cheater) +{ + DB_CacheJSPBs(client, steamID); +} + +public void GOKZ_OnOptionsLoaded(int client) +{ + if (gB_MapSetUp && gB_ClientPostAdminChecked[client] && GOKZ_GetOption(client, gC_DBOptionNames[DBOption_AutoLoadTimerSetup]) == DBOption_Enabled) + { + DB_LoadTimerSetup(client); + } +} + +public void OnClientDisconnect(int client) +{ + gB_ClientSetUp[client] = false; + gB_ClientPostAdminChecked[client] = false; +} + +public void GOKZ_OnCourseRegistered(int course) +{ + if (gB_MapSetUp) + { + DB_SetupMapCourse(course); + } +} + +public void GOKZ_OnOptionsMenuReady(TopMenu topMenu) +{ + OnOptionsMenuReady_Options(); + OnOptionsMenuReady_OptionsMenu(topMenu); +} + +public void GOKZ_OnTimerEnd_Post(int client, int course, float time, int teleportsUsed) +{ + int mode = GOKZ_GetCoreOption(client, Option_Mode); + int style = GOKZ_GetCoreOption(client, Option_Style); + DB_SaveTime(client, course, mode, style, time, teleportsUsed); +} + +public void GOKZ_JS_OnLanding(Jump jump) +{ + OnLanding_SaveJumpstat(jump); +} diff --git a/sourcemod/scripting/gokz-localdb/api.sp b/sourcemod/scripting/gokz-localdb/api.sp new file mode 100644 index 0000000..a4bc29c --- /dev/null +++ b/sourcemod/scripting/gokz-localdb/api.sp @@ -0,0 +1,126 @@ +static GlobalForward H_OnDatabaseConnect; +static GlobalForward H_OnClientSetup; +static GlobalForward H_OnMapSetup; +static GlobalForward H_OnTimeInserted; +static GlobalForward H_OnJumpstatPB; + + + +// =====[ FORWARDS ]===== + +void CreateGlobalForwards() +{ + H_OnDatabaseConnect = new GlobalForward("GOKZ_DB_OnDatabaseConnect", ET_Ignore, Param_Cell); + H_OnClientSetup = new GlobalForward("GOKZ_DB_OnClientSetup", ET_Ignore, Param_Cell, Param_Cell, Param_Cell); + H_OnMapSetup = new GlobalForward("GOKZ_DB_OnMapSetup", ET_Ignore, Param_Cell); + H_OnTimeInserted = new GlobalForward("GOKZ_DB_OnTimeInserted", ET_Ignore, Param_Cell, Param_Cell, Param_Cell, Param_Cell, Param_Cell, Param_Cell, Param_Cell, Param_Cell); + H_OnJumpstatPB = new GlobalForward("GOKZ_DB_OnJumpstatPB", ET_Ignore, Param_Cell, Param_Cell, Param_Cell, Param_Cell, Param_Cell, Param_Cell, Param_Cell, Param_Cell, Param_Cell, Param_Cell); +} + +void Call_OnDatabaseConnect() +{ + Call_StartForward(H_OnDatabaseConnect); + Call_PushCell(g_DBType); + Call_Finish(); +} + +void Call_OnClientSetup(int client, int steamID, bool cheater) +{ + Call_StartForward(H_OnClientSetup); + Call_PushCell(client); + Call_PushCell(steamID); + Call_PushCell(cheater); + Call_Finish(); +} + +void Call_OnMapSetup() +{ + Call_StartForward(H_OnMapSetup); + Call_PushCell(gI_DBCurrentMapID); + Call_Finish(); +} + +void Call_OnTimeInserted(int client, int steamID, int mapID, int course, int mode, int style, int runTimeMS, int teleportsUsed) +{ + Call_StartForward(H_OnTimeInserted); + Call_PushCell(client); + Call_PushCell(steamID); + Call_PushCell(mapID); + Call_PushCell(course); + Call_PushCell(mode); + Call_PushCell(style); + Call_PushCell(runTimeMS); + Call_PushCell(teleportsUsed); + Call_Finish(); +} + +void Call_OnJumpstatPB(int client, int jumptype, int mode, float distance, int block, int strafes, float sync, float pre, float max, int airtime) +{ + Call_StartForward(H_OnJumpstatPB); + Call_PushCell(client); + Call_PushCell(jumptype); + Call_PushCell(mode); + Call_PushCell(distance); + Call_PushCell(block); + Call_PushCell(strafes); + Call_PushCell(sync); + Call_PushCell(pre); + Call_PushCell(max); + Call_PushCell(airtime); + Call_Finish(); +} + + + +// =====[ NATIVES ]===== + +void CreateNatives() +{ + CreateNative("GOKZ_DB_GetDatabase", Native_GetDatabase); + CreateNative("GOKZ_DB_GetDatabaseType", Native_GetDatabaseType); + CreateNative("GOKZ_DB_IsClientSetUp", Native_IsClientSetUp); + CreateNative("GOKZ_DB_IsMapSetUp", Native_IsMapSetUp); + CreateNative("GOKZ_DB_GetCurrentMapID", Native_GetCurrentMapID); + CreateNative("GOKZ_DB_IsCheater", Native_IsCheater); + CreateNative("GOKZ_DB_SetCheater", Native_SetCheater); +} + +public int Native_GetDatabase(Handle plugin, int numParams) +{ + if (gH_DB == null) + { + return view_as<int>(gH_DB); + } + return view_as<int>(CloneHandle(gH_DB)); +} + +public int Native_GetDatabaseType(Handle plugin, int numParams) +{ + return view_as<int>(g_DBType); +} + +public int Native_IsClientSetUp(Handle plugin, int numParams) +{ + return view_as<int>(gB_ClientSetUp[GetNativeCell(1)]); +} + +public int Native_IsMapSetUp(Handle plugin, int numParams) +{ + return view_as<int>(gB_MapSetUp); +} + +public int Native_GetCurrentMapID(Handle plugin, int numParams) +{ + return gI_DBCurrentMapID; +} + +public int Native_IsCheater(Handle plugin, int numParams) +{ + return view_as<int>(gB_Cheater[GetNativeCell(1)]); +} + +public int Native_SetCheater(Handle plugin, int numParams) +{ + DB_SetCheater(GetNativeCell(1), GetNativeCell(2)); + return 0; +} diff --git a/sourcemod/scripting/gokz-localdb/commands.sp b/sourcemod/scripting/gokz-localdb/commands.sp new file mode 100644 index 0000000..2410fc5 --- /dev/null +++ b/sourcemod/scripting/gokz-localdb/commands.sp @@ -0,0 +1,199 @@ +void RegisterCommands() +{ + RegConsoleCmd("sm_savetimersetup", Command_SaveTimerSetup, "[KZ] Save the current timer setup (virtual buttons and start position)."); + RegConsoleCmd("sm_sts", Command_SaveTimerSetup, "[KZ] Save the current timer setup (virtual buttons and start position)."); + RegConsoleCmd("sm_loadtimersetup", Command_LoadTimerSetup, "[KZ] Load the saved timer setup (virtual buttons and start position)."); + RegConsoleCmd("sm_lts", Command_LoadTimerSetup, "[KZ] Load the saved timer setup (virtual buttons and start position)."); + + RegAdminCmd("sm_setcheater", CommandSetCheater, ADMFLAG_ROOT, "[KZ] Set a SteamID as a cheater. Usage: !setcheater <STEAM_1:X:X>"); + RegAdminCmd("sm_setnotcheater", CommandSetNotCheater, ADMFLAG_ROOT, "[KZ] Set a SteamID as not a cheater. Usage: !setnotcheater <STEAM_1:X:X>"); + RegAdminCmd("sm_deletebestjump", CommandDeleteBestJump, ADMFLAG_ROOT, "[KZ] Remove the top jumpstat of a SteamID. Usage: !deletebestjump <STEAM_1:X:X> <mode> <jump type> <block?>"); + RegAdminCmd("sm_deletealljumps", CommandDeleteAllJumps, ADMFLAG_ROOT, "[KZ] Remove all jumpstats of a SteamID. Usage: !deletealljumps <STEAM_1:X:X>"); + RegAdminCmd("sm_deletejump", CommandDeleteJump, ADMFLAG_ROOT, "[KZ] Remove a jumpstat by it's id. Usage: !deletejump <id>"); + RegAdminCmd("sm_deletetime", CommandDeleteTime, ADMFLAG_ROOT, "[KZ] Remove a time by it's id. Usage: !deletetime <id>"); +} + +public Action Command_SaveTimerSetup(int client, int args) +{ + DB_SaveTimerSetup(client); + return Plugin_Handled; +} + +public Action Command_LoadTimerSetup(int client, int args) +{ + DB_LoadTimerSetup(client, true); + return Plugin_Handled; +} + +public Action CommandSetCheater(int client, int args) +{ + if (args == 0) + { + GOKZ_PrintToChat(client, true, "%t", "No SteamID specified"); + return Plugin_Handled; + } + + char steamID2[64]; + GetCmdArgString(steamID2, sizeof(steamID2)); + int steamAccountID = Steam2ToSteamAccountID(steamID2); + if (steamAccountID == -1) + { + GOKZ_PrintToChat(client, true, "%t", "Invalid SteamID"); + } + else + { + DB_SetCheaterSteamID(client, steamAccountID, true); + } + + return Plugin_Handled; +} + +public Action CommandSetNotCheater(int client, int args) +{ + if (args == 0) + { + GOKZ_PrintToChat(client, true, "%t", "No SteamID specified"); + } + + char steamID2[64]; + GetCmdArgString(steamID2, sizeof(steamID2)); + int steamAccountID = Steam2ToSteamAccountID(steamID2); + if (steamAccountID == -1) + { + GOKZ_PrintToChat(client, true, "%t", "Invalid SteamID"); + } + else + { + DB_SetCheaterSteamID(client, steamAccountID, false); + } + + return Plugin_Handled; +} + +public Action CommandDeleteBestJump(int client, int args) +{ + if (args < 3) + { + GOKZ_PrintToChat(client, true, "%t", "Delete Best Jump Usage"); + return Plugin_Handled; + } + + int steamAccountID, isBlock, mode, jumpType; + char query[1024], split[4][32]; + + // Get arguments + split[3][0] = '\0'; + GetCmdArgString(query, sizeof(query)); + ExplodeString(query, " ", split, 4, 32, false); + + // SteamID32 + steamAccountID = Steam2ToSteamAccountID(split[0]); + if (steamAccountID == -1) + { + GOKZ_PrintToChat(client, true, "%t", "Invalid SteamID"); + return Plugin_Handled; + } + + // Mode + for (mode = 0; mode < MODE_COUNT; mode++) + { + if (StrEqual(split[1], gC_ModeNames[mode]) || StrEqual(split[1], gC_ModeNamesShort[mode], false)) + { + break; + } + } + if (mode == MODE_COUNT) + { + GOKZ_PrintToChat(client, true, "%t", "Invalid Mode"); + return Plugin_Handled; + } + + // Jumptype + for (jumpType = 0; jumpType < JUMPTYPE_COUNT; jumpType++) + { + if (StrEqual(split[2], gC_JumpTypes[jumpType]) || StrEqual(split[2], gC_JumpTypesShort[jumpType], false)) + { + break; + } + } + if (jumpType == JUMPTYPE_COUNT) + { + GOKZ_PrintToChat(client, true, "%t", "Invalid Jumptype"); + return Plugin_Handled; + } + + // Is it a block jump? + isBlock = StrEqual(split[3], "yes", false) || StrEqual(split[3], "true", false) || StrEqual(split[3], "1"); + + DB_DeleteBestJump(client, steamAccountID, jumpType, mode, isBlock); + + return Plugin_Handled; +} + +public Action CommandDeleteAllJumps(int client, int args) +{ + if (args < 1) + { + GOKZ_PrintToChat(client, true, "%t", "Delete All Jumps Usage"); + return Plugin_Handled; + } + + int steamAccountID; + char steamid[32]; + + GetCmdArgString(steamid, sizeof(steamid)); + steamAccountID = Steam2ToSteamAccountID(steamid); + if (steamAccountID == -1) + { + GOKZ_PrintToChat(client, true, "%t", "Invalid SteamID"); + return Plugin_Handled; + } + + DB_DeleteAllJumps(client, steamAccountID); + + return Plugin_Handled; +} + +public Action CommandDeleteJump(int client, int args) +{ + if (args < 1) + { + GOKZ_PrintToChat(client, true, "%t", "Delete Jump Usage"); + return Plugin_Handled; + } + + char buffer[24]; + int jumpID; + GetCmdArgString(buffer, sizeof(buffer)); + if (StringToIntEx(buffer, jumpID) == 0) + { + GOKZ_PrintToChat(client, true, "%t", "Invalid Jump ID"); + return Plugin_Handled; + } + + DB_DeleteJump(client, jumpID); + + return Plugin_Handled; +} + +public Action CommandDeleteTime(int client, int args) +{ + if (args < 1) + { + GOKZ_PrintToChat(client, true, "%t", "Delete Time Usage"); + return Plugin_Handled; + } + + char buffer[24]; + int timeID; + GetCmdArgString(buffer, sizeof(buffer)); + if (StringToIntEx(buffer, timeID) == 0) + { + GOKZ_PrintToChat(client, true, "%t", "Invalid Time ID"); + return Plugin_Handled; + } + + DB_DeleteTime(client, timeID); + + return Plugin_Handled; +} diff --git a/sourcemod/scripting/gokz-localdb/db/cache_js.sp b/sourcemod/scripting/gokz-localdb/db/cache_js.sp new file mode 100644 index 0000000..b0df708 --- /dev/null +++ b/sourcemod/scripting/gokz-localdb/db/cache_js.sp @@ -0,0 +1,67 @@ +/* + Caches the player's personal best jumpstats. +*/ + + + +void DB_CacheJSPBs(int client, int steamID) +{ + ClearCache(client); + + char query[1024]; + + Transaction txn = SQL_CreateTransaction(); + + FormatEx(query, sizeof(query), sql_jumpstats_getpbs, steamID); + txn.AddQuery(query); + + FormatEx(query, sizeof(query), sql_jumpstats_getblockpbs, steamID, steamID); + txn.AddQuery(query); + + SQL_ExecuteTransaction(gH_DB, txn, DB_TxnSuccess_CacheJSPBs, DB_TxnFailure_Generic, GetClientUserId(client), DBPrio_High); +} + +public void DB_TxnSuccess_CacheJSPBs(Handle db, int userID, int numQueries, Handle[] results, any[] queryData) +{ + int client = GetClientOfUserId(userID); + if (client < 1 || client > MaxClients || !IsClientAuthorized(client) || IsFakeClient(client)) + { + return; + } + + int distance, mode, jumpType, block; + + while (SQL_FetchRow(results[0])) + { + distance = SQL_FetchInt(results[0], 0); + mode = SQL_FetchInt(results[0], 1); + jumpType = SQL_FetchInt(results[0], 2); + + gI_PBJSCache[client][mode][jumpType][JumpstatDB_Cache_Distance] = block; + } + + while (SQL_FetchRow(results[1])) + { + distance = SQL_FetchInt(results[1], 0); + mode = SQL_FetchInt(results[1], 1); + jumpType = SQL_FetchInt(results[1], 2); + block = SQL_FetchInt(results[1], 3); + + gI_PBJSCache[client][mode][jumpType][JumpstatDB_Cache_BlockDistance] = distance; + gI_PBJSCache[client][mode][jumpType][JumpstatDB_Cache_Block] = block; + } +} + +void ClearCache(int client) +{ + for (int mode = 0; mode < MODE_COUNT; mode += 1) + { + for (int type = 0; type < JUMPTYPE_COUNT; type += 1) + { + for (int cache = 0; cache < JUMPSTATDB_CACHE_COUNT; cache += 1) + { + gI_PBJSCache[client][mode][type][cache] = 0; + } + } + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-localdb/db/create_tables.sp b/sourcemod/scripting/gokz-localdb/db/create_tables.sp new file mode 100644 index 0000000..2138830 --- /dev/null +++ b/sourcemod/scripting/gokz-localdb/db/create_tables.sp @@ -0,0 +1,36 @@ +/* + Table creation and alteration. +*/ + + + +void DB_CreateTables() +{ + Transaction txn = SQL_CreateTransaction(); + + switch (g_DBType) + { + case DatabaseType_SQLite: + { + txn.AddQuery(sqlite_players_create); + txn.AddQuery(sqlite_maps_create); + txn.AddQuery(sqlite_mapcourses_create); + txn.AddQuery(sqlite_times_create); + txn.AddQuery(sqlite_jumpstats_create); + txn.AddQuery(sqlite_vbpos_create); + txn.AddQuery(sqlite_startpos_create); + } + case DatabaseType_MySQL: + { + txn.AddQuery(mysql_players_create); + txn.AddQuery(mysql_maps_create); + txn.AddQuery(mysql_mapcourses_create); + txn.AddQuery(mysql_times_create); + txn.AddQuery(mysql_jumpstats_create); + txn.AddQuery(mysql_vbpos_create); + txn.AddQuery(mysql_startpos_create); + } + } + + SQL_ExecuteTransaction(gH_DB, txn, _, DB_TxnFailure_Generic, _, DBPrio_High); +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-localdb/db/helpers.sp b/sourcemod/scripting/gokz-localdb/db/helpers.sp new file mode 100644 index 0000000..1eff866 --- /dev/null +++ b/sourcemod/scripting/gokz-localdb/db/helpers.sp @@ -0,0 +1,18 @@ +/* + Database helper functions and callbacks. +*/ + + + +/* Error report callback for failed transactions */ +public void DB_TxnFailure_Generic(Handle db, any data, int numQueries, const char[] error, int failIndex, any[] queryData) +{ + LogError("Database transaction error: %s", error); +} + +/* Error report callback for failed transactions which deletes the DataPack */ +public void DB_TxnFailure_Generic_DataPack(Handle db, DataPack data, int numQueries, const char[] error, int failIndex, any[] queryData) +{ + delete data; + LogError("Database transaction error: %s", error); +} diff --git a/sourcemod/scripting/gokz-localdb/db/save_js.sp b/sourcemod/scripting/gokz-localdb/db/save_js.sp new file mode 100644 index 0000000..1d50754 --- /dev/null +++ b/sourcemod/scripting/gokz-localdb/db/save_js.sp @@ -0,0 +1,291 @@ +/* + Inserts or updates the player's jumpstat into the database. +*/ + + + +public void OnLanding_SaveJumpstat(Jump jump) +{ + int mode = GOKZ_GetCoreOption(jump.jumper, Option_Mode); + + // No tiers given for 'Invalid' jumps. + if (jump.type == JumpType_Invalid || jump.type == JumpType_FullInvalid + || jump.type == JumpType_Fall || jump.type == JumpType_Other + || jump.type != JumpType_LadderJump && jump.offset < -JS_OFFSET_EPSILON + || jump.distance > JS_MAX_JUMP_DISTANCE + || jump.type == JumpType_LadderJump && jump.distance < JS_MIN_LAJ_BLOCK_DISTANCE + || jump.type != JumpType_LadderJump && jump.distance < JS_MIN_BLOCK_DISTANCE) + { + return; + } + + char query[1024]; + DataPack data; + int steamid = GetSteamAccountID(jump.jumper); + int int_dist = RoundToNearest(jump.distance * GOKZ_DB_JS_DISTANCE_PRECISION); + + // Non-block + if (gI_PBJSCache[jump.jumper][mode][jump.type][JumpstatDB_Cache_Distance] == 0 + || int_dist > gI_PBJSCache[jump.jumper][mode][jump.type][JumpstatDB_Cache_Distance]) + { + data = JSRecord_FillDataPack(jump, steamid, mode, false); + Transaction txn_noblock = SQL_CreateTransaction(); + FormatEx(query, sizeof(query), sql_jumpstats_getrecord, steamid, jump.type, mode, 0); + txn_noblock.AddQuery(query); + SQL_ExecuteTransaction(gH_DB, txn_noblock, DB_TxnSuccess_LookupJSRecordForSave, DB_TxnFailure_Generic_DataPack, data, DBPrio_Low); + } + + // Block + if (jump.block > 0 + && (gI_PBJSCache[jump.jumper][mode][jump.type][JumpstatDB_Cache_Block] == 0 + || (jump.block > gI_PBJSCache[jump.jumper][mode][jump.type][JumpstatDB_Cache_Block] + || jump.block == gI_PBJSCache[jump.jumper][mode][jump.type][JumpstatDB_Cache_Block] + && int_dist > gI_PBJSCache[jump.jumper][mode][jump.type][JumpstatDB_Cache_BlockDistance]))) + { + data = JSRecord_FillDataPack(jump, steamid, mode, true); + Transaction txn_block = SQL_CreateTransaction(); + FormatEx(query, sizeof(query), sql_jumpstats_getrecord, steamid, jump.type, mode, 1); + txn_block.AddQuery(query); + SQL_ExecuteTransaction(gH_DB, txn_block, DB_TxnSuccess_LookupJSRecordForSave, DB_TxnFailure_Generic_DataPack, data, DBPrio_Low); + } +} + +static DataPack JSRecord_FillDataPack(Jump jump, int steamid, int mode, bool blockJump) +{ + DataPack data = new DataPack(); + data.WriteCell(jump.jumper); + data.WriteCell(steamid); + data.WriteCell(jump.type); + data.WriteCell(mode); + data.WriteCell(RoundToNearest(jump.distance * GOKZ_DB_JS_DISTANCE_PRECISION)); + data.WriteCell(blockJump ? jump.block : 0); + data.WriteCell(jump.strafes); + data.WriteCell(RoundToNearest(jump.sync * GOKZ_DB_JS_SYNC_PRECISION)); + data.WriteCell(RoundToNearest(jump.preSpeed * GOKZ_DB_JS_PRE_PRECISION)); + data.WriteCell(RoundToNearest(jump.maxSpeed * GOKZ_DB_JS_MAX_PRECISION)); + data.WriteCell(RoundToNearest(jump.duration * GetTickInterval() * GOKZ_DB_JS_AIRTIME_PRECISION)); + return data; +} + +public void DB_TxnSuccess_LookupJSRecordForSave(Handle db, DataPack data, int numQueries, Handle[] results, any[] queryData) +{ + data.Reset(); + int client = data.ReadCell(); + int steamid = data.ReadCell(); + int jumpType = data.ReadCell(); + int mode = data.ReadCell(); + int distance = data.ReadCell(); + int block = data.ReadCell(); + int strafes = data.ReadCell(); + int sync = data.ReadCell(); + int pre = data.ReadCell(); + int max = data.ReadCell(); + int airtime = data.ReadCell(); + + if (!IsValidClient(client)) + { + delete data; + return; + } + + char query[1024]; + int rows = SQL_GetRowCount(results[0]); + if (rows == 0) + { + FormatEx(query, sizeof(query), sql_jumpstats_insert, steamid, jumpType, mode, distance, block > 0, block, strafes, sync, pre, max, airtime); + } + else + { + SQL_FetchRow(results[0]); + int rec_distance = SQL_FetchInt(results[0], JumpstatDB_Lookup_Distance); + int rec_block = SQL_FetchInt(results[0], JumpstatDB_Lookup_Block); + + if (rec_block == 0) + { + gI_PBJSCache[client][mode][jumpType][JumpstatDB_Cache_Distance] = rec_distance; + } + else + { + gI_PBJSCache[client][mode][jumpType][JumpstatDB_Cache_Block] = rec_block; + gI_PBJSCache[client][mode][jumpType][JumpstatDB_Cache_BlockDistance] = rec_distance; + } + + if (block < rec_block || block == rec_block && distance < rec_distance) + { + delete data; + return; + } + + if (rows < GOKZ_DB_JS_MAX_JUMPS_PER_PLAYER) + { + FormatEx(query, sizeof(query), sql_jumpstats_insert, steamid, jumpType, mode, distance, block > 0, block, strafes, sync, pre, max, airtime); + } + else + { + for (int i = 1; i < GOKZ_DB_JS_MAX_JUMPS_PER_PLAYER; i++) + { + SQL_FetchRow(results[0]); + } + int min_rec_id = SQL_FetchInt(results[0], JumpstatDB_Lookup_JumpID); + FormatEx(query, sizeof(query), sql_jumpstats_update, steamid, jumpType, mode, distance, block > 0, block, strafes, sync, pre, max, airtime, min_rec_id); + } + + } + + Transaction txn = SQL_CreateTransaction(); + txn.AddQuery(query); + SQL_ExecuteTransaction(gH_DB, txn, DB_TxnSuccess_SaveJSRecord, DB_TxnFailure_Generic_DataPack, data, DBPrio_Low); +} + +public void DB_TxnSuccess_SaveJSRecord(Handle db, DataPack data, int numQueries, Handle[] results, any[] queryData) +{ + data.Reset(); + int client = data.ReadCell(); + data.ReadCell(); + int jumpType = data.ReadCell(); + int mode = data.ReadCell(); + int distance = data.ReadCell(); + int block = data.ReadCell(); + int strafes = data.ReadCell(); + int sync = data.ReadCell(); + int pre = data.ReadCell(); + int max = data.ReadCell(); + int airtime = data.ReadCell(); + delete data; + + if (!IsValidClient(client) || GOKZ_JS_GetOption(client, JSOption_JumpstatsMaster) == JSToggleOption_Disabled) + { + return; + } + + float distanceFloat = float(distance) / GOKZ_DB_JS_DISTANCE_PRECISION; + float syncFloat = float(sync) / GOKZ_DB_JS_SYNC_PRECISION; + float preFloat = float(pre) / GOKZ_DB_JS_PRE_PRECISION; + float maxFloat = float(max) / GOKZ_DB_JS_MAX_PRECISION; + + if (block == 0) + { + gI_PBJSCache[client][mode][jumpType][JumpstatDB_Cache_Distance] = distance; + GOKZ_PrintToChat(client, true, "%t", "Jump Record", + client, + gC_JumpTypes[jumpType], + distanceFloat, + gC_ModeNamesShort[mode]); + } + else + { + gI_PBJSCache[client][mode][jumpType][JumpstatDB_Cache_Block] = block; + gI_PBJSCache[client][mode][jumpType][JumpstatDB_Cache_BlockDistance] = distance; + GOKZ_PrintToChat(client, true, "%t", "Block Jump Record", + client, + block, + gC_JumpTypes[jumpType], + distanceFloat, + gC_ModeNamesShort[mode], + block); + } + + Call_OnJumpstatPB(client, jumpType, mode, distanceFloat, block, strafes, syncFloat, preFloat, maxFloat, airtime); +} + +public void DB_DeleteBestJump(int client, int steamAccountID, int jumpType, int mode, int isBlock) +{ + DataPack data = new DataPack(); + data.WriteCell(client == 0 ? -1 : GetClientUserId(client)); // -1 if called from server console + data.WriteCell(steamAccountID); + data.WriteCell(jumpType); + data.WriteCell(mode); + data.WriteCell(isBlock); + + char query[1024]; + + FormatEx(query, sizeof(query), sql_jumpstats_deleterecord, steamAccountID, jumpType, mode, isBlock); + + Transaction txn = SQL_CreateTransaction(); + txn.AddQuery(query); + + SQL_ExecuteTransaction(gH_DB, txn, DB_TxnSuccess_BestJumpDeleted, DB_TxnFailure_Generic_DataPack, data, DBPrio_Low); +} + +public void DB_TxnSuccess_BestJumpDeleted(Handle db, DataPack data, int numQueries, Handle[] results, any[] queryData) +{ + char blockString[16] = ""; + + data.Reset(); + int client = GetClientOfUserId(data.ReadCell()); + int steamAccountID = data.ReadCell(); + int jumpType = data.ReadCell(); + int mode = data.ReadCell(); + bool isBlock = data.ReadCell() == 1; + delete data; + + if (isBlock) + { + FormatEx(blockString, sizeof(blockString), "%T ", "Block", client); + } + + ClearCache(client); + + GOKZ_PrintToChatAndLog(client, true, "%t", "Best Jump Deleted", + gC_ModeNames[mode], + blockString, + gC_JumpTypes[jumpType], + steamAccountID & 1, + steamAccountID >> 1); +} + +public void DB_DeleteAllJumps(int client, int steamAccountID) +{ + DataPack data = new DataPack(); + data.WriteCell(client == 0 ? -1 : GetClientUserId(client)); // -1 if called from server console + data.WriteCell(steamAccountID); + + char query[1024]; + + FormatEx(query, sizeof(query), sql_jumpstats_deleteallrecords, steamAccountID); + + Transaction txn = SQL_CreateTransaction(); + txn.AddQuery(query); + + SQL_ExecuteTransaction(gH_DB, txn, DB_TxnSuccess_AllJumpsDeleted, DB_TxnFailure_Generic_DataPack, data, DBPrio_Low); +} + +public void DB_TxnSuccess_AllJumpsDeleted(Handle db, DataPack data, int numQueries, Handle[] results, any[] queryData) +{ + data.Reset(); + int client = GetClientOfUserId(data.ReadCell()); + int steamAccountID = data.ReadCell(); + delete data; + + ClearCache(client); + + GOKZ_PrintToChatAndLog(client, true, "%t", "All Jumps Deleted", + steamAccountID & 1, + steamAccountID >> 1); +} + +public void DB_DeleteJump(int client, int jumpID) +{ + DataPack data = new DataPack(); + data.WriteCell(client == 0 ? -1 : GetClientUserId(client)); // -1 if called from server console + data.WriteCell(jumpID); + + char query[1024]; + FormatEx(query, sizeof(query), sql_jumpstats_deletejump, jumpID); + + Transaction txn = SQL_CreateTransaction(); + txn.AddQuery(query); + + SQL_ExecuteTransaction(gH_DB, txn, DB_TxnSuccess_JumpDeleted, DB_TxnFailure_Generic_DataPack, data, DBPrio_Low); +} + +public void DB_TxnSuccess_JumpDeleted(Handle db, DataPack data, int numQueries, Handle[] results, any[] queryData) +{ + data.Reset(); + int client = GetClientOfUserId(data.ReadCell()); + int jumpID = data.ReadCell(); + delete data; + + GOKZ_PrintToChatAndLog(client, true, "%t", "Jump Deleted", + jumpID); +} diff --git a/sourcemod/scripting/gokz-localdb/db/save_time.sp b/sourcemod/scripting/gokz-localdb/db/save_time.sp new file mode 100644 index 0000000..84589a5 --- /dev/null +++ b/sourcemod/scripting/gokz-localdb/db/save_time.sp @@ -0,0 +1,83 @@ +/* + Inserts the player's time into the database. +*/ + + + +void DB_SaveTime(int client, int course, int mode, int style, float runTime, int teleportsUsed) +{ + if (IsFakeClient(client)) + { + return; + } + + char query[1024]; + int steamID = GetSteamAccountID(client); + int mapID = GOKZ_DB_GetCurrentMapID(); + int runTimeMS = GOKZ_DB_TimeFloatToInt(runTime); + + DataPack data = new DataPack(); + data.WriteCell(GetClientUserId(client)); + data.WriteCell(steamID); + data.WriteCell(mapID); + data.WriteCell(course); + data.WriteCell(mode); + data.WriteCell(style); + data.WriteCell(runTimeMS); + data.WriteCell(teleportsUsed); + + Transaction txn = SQL_CreateTransaction(); + + // Save runTime to DB + FormatEx(query, sizeof(query), sql_times_insert, steamID, mode, style, runTimeMS, teleportsUsed, mapID, course); + txn.AddQuery(query); + + SQL_ExecuteTransaction(gH_DB, txn, DB_TxnSuccess_SaveTime, DB_TxnFailure_Generic_DataPack, data, DBPrio_Normal); +} + +public void DB_TxnSuccess_SaveTime(Handle db, DataPack data, int numQueries, Handle[] results, any[] queryData) +{ + data.Reset(); + int client = GetClientOfUserId(data.ReadCell()); + int steamID = data.ReadCell(); + int mapID = data.ReadCell(); + int course = data.ReadCell(); + int mode = data.ReadCell(); + int style = data.ReadCell(); + int runTimeMS = data.ReadCell(); + int teleportsUsed = data.ReadCell(); + delete data; + + if (!IsValidClient(client)) + { + return; + } + + Call_OnTimeInserted(client, steamID, mapID, course, mode, style, runTimeMS, teleportsUsed); +} + +public void DB_DeleteTime(int client, int timeID) +{ + DataPack data = new DataPack(); + data.WriteCell(client == 0 ? -1 : GetClientUserId(client)); // -1 if called from server console + data.WriteCell(timeID); + + char query[1024]; + FormatEx(query, sizeof(query), sql_times_delete, timeID); + + Transaction txn = SQL_CreateTransaction(); + txn.AddQuery(query); + + SQL_ExecuteTransaction(gH_DB, txn, DB_TxnSuccess_TimeDeleted, DB_TxnFailure_Generic_DataPack, data, DBPrio_Low); +} + +public void DB_TxnSuccess_TimeDeleted(Handle db, DataPack data, int numQueries, Handle[] results, any[] queryData) +{ + data.Reset(); + int client = GetClientOfUserId(data.ReadCell()); + int timeID = data.ReadCell(); + delete data; + + GOKZ_PrintToChatAndLog(client, true, "%t", "Time Deleted", + timeID); +} diff --git a/sourcemod/scripting/gokz-localdb/db/set_cheater.sp b/sourcemod/scripting/gokz-localdb/db/set_cheater.sp new file mode 100644 index 0000000..c63f161 --- /dev/null +++ b/sourcemod/scripting/gokz-localdb/db/set_cheater.sp @@ -0,0 +1,64 @@ +/* + Sets whether player is a cheater in the database. +*/ + + + +void DB_SetCheater(int cheaterClient, bool cheater) +{ + if (gB_Cheater[cheaterClient] == cheater) + { + return; + } + + gB_Cheater[cheaterClient] = cheater; + + DataPack data = new DataPack(); + data.WriteCell(-1); + data.WriteCell(GetSteamAccountID(cheaterClient)); + data.WriteCell(cheater); + + char query[128]; + + Transaction txn = SQL_CreateTransaction(); + + FormatEx(query, sizeof(query), sql_players_set_cheater, cheater ? 1 : 0, GetSteamAccountID(cheaterClient)); + txn.AddQuery(query); + + SQL_ExecuteTransaction(gH_DB, txn, DB_TxnSuccess_SetCheater, DB_TxnFailure_Generic_DataPack, data, DBPrio_High); +} + +void DB_SetCheaterSteamID(int client, int cheaterSteamID, bool cheater) +{ + DataPack data = new DataPack(); + data.WriteCell(client == 0 ? -1 : GetClientUserId(client)); // -1 if called from server console + data.WriteCell(cheaterSteamID); + data.WriteCell(cheater); + + char query[128]; + + Transaction txn = SQL_CreateTransaction(); + + FormatEx(query, sizeof(query), sql_players_set_cheater, cheater ? 1 : 0, cheaterSteamID); + txn.AddQuery(query); + + SQL_ExecuteTransaction(gH_DB, txn, DB_TxnSuccess_SetCheater, DB_TxnFailure_Generic_DataPack, data, DBPrio_High); +} + +public void DB_TxnSuccess_SetCheater(Handle db, DataPack data, int numQueries, Handle[] results, any[] queryData) +{ + data.Reset(); + int client = GetClientOfUserId(data.ReadCell()); + int steamID = data.ReadCell(); + bool cheater = view_as<bool>(data.ReadCell()); + delete data; + + if (cheater) + { + GOKZ_PrintToChatAndLog(client, true, "%t", "Set Cheater", steamID & 1, steamID >> 1); + } + else + { + GOKZ_PrintToChatAndLog(client, true, "%t", "Set Not Cheater", steamID & 1, steamID >> 1); + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-localdb/db/setup_client.sp b/sourcemod/scripting/gokz-localdb/db/setup_client.sp new file mode 100644 index 0000000..848be87 --- /dev/null +++ b/sourcemod/scripting/gokz-localdb/db/setup_client.sp @@ -0,0 +1,99 @@ +/* + Inserts the player into the database, or else updates their information. +*/ + + + +void DB_SetupClient(int client) +{ + if (IsFakeClient(client)) + { + return; + } + + // Setup Client Step 1 - Upsert them into Players Table + char query[1024], name[MAX_NAME_LENGTH], nameEscaped[MAX_NAME_LENGTH * 2 + 1], clientIP[16], country[45]; + + int steamID = GetSteamAccountID(client); + if (!GetClientName(client, name, MAX_NAME_LENGTH)) + { + LogMessage("Couldn't get name of %L.", client); + name = "Unknown"; + } + SQL_EscapeString(gH_DB, name, nameEscaped, MAX_NAME_LENGTH * 2 + 1); + if (!GetClientIP(client, clientIP, sizeof(clientIP))) + { + LogMessage("Couldn't get IP of %L.", client); + clientIP = "Unknown"; + } + if (!GeoipCountry(clientIP, country, sizeof(country))) + { + LogMessage("Couldn't get country of %L (%s).", client, clientIP); + country = "Unknown"; + } + + DataPack data = new DataPack(); + data.WriteCell(GetClientUserId(client)); + data.WriteCell(steamID); + + Transaction txn = SQL_CreateTransaction(); + + // Insert/Update player into Players table + switch (g_DBType) + { + case DatabaseType_SQLite: + { + // UPDATE OR IGNORE + FormatEx(query, sizeof(query), sqlite_players_update, nameEscaped, country, clientIP, steamID); + txn.AddQuery(query); + // INSERT OR IGNORE + FormatEx(query, sizeof(query), sqlite_players_insert, nameEscaped, country, clientIP, steamID); + txn.AddQuery(query); + } + case DatabaseType_MySQL: + { + // INSERT ... ON DUPLICATE KEY ... + FormatEx(query, sizeof(query), mysql_players_upsert, nameEscaped, country, clientIP, steamID); + txn.AddQuery(query); + } + } + + FormatEx(query, sizeof(query), sql_players_get_cheater, steamID); + txn.AddQuery(query); + + SQL_ExecuteTransaction(gH_DB, txn, DB_TxnSuccess_SetupClient, DB_TxnFailure_Generic_DataPack, data, DBPrio_High); +} + +public void DB_TxnSuccess_SetupClient(Handle db, DataPack data, int numQueries, Handle[] results, any[] queryData) +{ + data.Reset(); + int client = GetClientOfUserId(data.ReadCell()); + int steamID = data.ReadCell(); + delete data; + + if (client == 0 || !IsClientAuthorized(client)) + { + return; + } + + switch (g_DBType) + { + case DatabaseType_SQLite: + { + if (SQL_FetchRow(results[2])) + { + gB_Cheater[client] = SQL_FetchInt(results[2], 0) == 1; + } + } + case DatabaseType_MySQL: + { + if (SQL_FetchRow(results[1])) + { + gB_Cheater[client] = SQL_FetchInt(results[1], 0) == 1; + } + } + } + + gB_ClientSetUp[client] = true; + Call_OnClientSetup(client, steamID, gB_Cheater[client]); +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-localdb/db/setup_database.sp b/sourcemod/scripting/gokz-localdb/db/setup_database.sp new file mode 100644 index 0000000..4965541 --- /dev/null +++ b/sourcemod/scripting/gokz-localdb/db/setup_database.sp @@ -0,0 +1,34 @@ +/* + Set up the connection to the local database. +*/ + + + +void DB_SetupDatabase() +{ + char error[255]; + gH_DB = SQL_Connect("gokz", true, error, sizeof(error)); + if (gH_DB == null) + { + SetFailState("Database connection failed. Error: \"%s\".", error); + } + + char databaseType[8]; + SQL_ReadDriver(gH_DB, databaseType, sizeof(databaseType)); + if (strcmp(databaseType, "sqlite", false) == 0) + { + g_DBType = DatabaseType_SQLite; + } + else if (strcmp(databaseType, "mysql", false) == 0) + { + g_DBType = DatabaseType_MySQL; + } + else + { + SetFailState("Incompatible database driver. Use SQLite or MySQL."); + } + + DB_CreateTables(); + + Call_OnDatabaseConnect(); +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-localdb/db/setup_map.sp b/sourcemod/scripting/gokz-localdb/db/setup_map.sp new file mode 100644 index 0000000..a02e2d2 --- /dev/null +++ b/sourcemod/scripting/gokz-localdb/db/setup_map.sp @@ -0,0 +1,71 @@ +/* + Inserts the map information into the database. + Retrieves the MapID of the map and stores it in a global variable. +*/ + + + +void DB_SetupMap() +{ + gB_MapSetUp = false; + + char query[1024]; + + char map[PLATFORM_MAX_PATH]; + GetCurrentMapDisplayName(map, sizeof(map)); + + char escapedMap[PLATFORM_MAX_PATH * 2 + 1]; + SQL_EscapeString(gH_DB, map, escapedMap, sizeof(escapedMap)); + + Transaction txn = SQL_CreateTransaction(); + + // Insert/Update map into database + switch (g_DBType) + { + case DatabaseType_SQLite: + { + // UPDATE OR IGNORE + FormatEx(query, sizeof(query), sqlite_maps_update, escapedMap); + txn.AddQuery(query); + // INSERT OR IGNORE + FormatEx(query, sizeof(query), sqlite_maps_insert, escapedMap); + txn.AddQuery(query); + } + case DatabaseType_MySQL: + { + // INSERT ... ON DUPLICATE KEY ... + FormatEx(query, sizeof(query), mysql_maps_upsert, escapedMap); + txn.AddQuery(query); + } + } + // Retrieve mapID of map name + FormatEx(query, sizeof(query), sql_maps_findid, escapedMap, escapedMap); + txn.AddQuery(query); + + SQL_ExecuteTransaction(gH_DB, txn, DB_TxnSuccess_SetupMap, DB_TxnFailure_Generic, 0, DBPrio_High); +} + +public void DB_TxnSuccess_SetupMap(Handle db, any data, int numQueries, Handle[] results, any[] queryData) +{ + switch (g_DBType) + { + case DatabaseType_SQLite: + { + if (SQL_FetchRow(results[2])) + { + gI_DBCurrentMapID = SQL_FetchInt(results[2], 0); + gB_MapSetUp = true; + Call_OnMapSetup(); + } + } + case DatabaseType_MySQL: + { + if (SQL_FetchRow(results[1])) + { + gI_DBCurrentMapID = SQL_FetchInt(results[1], 0); + gB_MapSetUp = true; + Call_OnMapSetup(); + } + } + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-localdb/db/setup_map_courses.sp b/sourcemod/scripting/gokz-localdb/db/setup_map_courses.sp new file mode 100644 index 0000000..69bb89e --- /dev/null +++ b/sourcemod/scripting/gokz-localdb/db/setup_map_courses.sp @@ -0,0 +1,45 @@ +/* + Inserts the map's courses into the database. +*/ + + + +void DB_SetupMapCourses() +{ + char query[512]; + + Transaction txn = SQL_CreateTransaction(); + + for (int course = 0; course < GOKZ_MAX_COURSES; course++) + { + if (!GOKZ_GetCourseRegistered(course)) + { + continue; + } + + switch (g_DBType) + { + case DatabaseType_SQLite:FormatEx(query, sizeof(query), sqlite_mapcourses_insert, gI_DBCurrentMapID, course); + case DatabaseType_MySQL:FormatEx(query, sizeof(query), mysql_mapcourses_insert, gI_DBCurrentMapID, course); + } + txn.AddQuery(query); + } + + SQL_ExecuteTransaction(gH_DB, txn, INVALID_FUNCTION, DB_TxnFailure_Generic, _, DBPrio_High); +} + +void DB_SetupMapCourse(int course) +{ + char query[512]; + + Transaction txn = SQL_CreateTransaction(); + + switch (g_DBType) + { + case DatabaseType_SQLite:FormatEx(query, sizeof(query), sqlite_mapcourses_insert, gI_DBCurrentMapID, course); + case DatabaseType_MySQL:FormatEx(query, sizeof(query), mysql_mapcourses_insert, gI_DBCurrentMapID, course); + } + txn.AddQuery(query); + + SQL_ExecuteTransaction(gH_DB, txn, INVALID_FUNCTION, DB_TxnFailure_Generic, _, DBPrio_High); +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-localdb/db/sql.sp b/sourcemod/scripting/gokz-localdb/db/sql.sp new file mode 100644 index 0000000..46ea5e3 --- /dev/null +++ b/sourcemod/scripting/gokz-localdb/db/sql.sp @@ -0,0 +1,406 @@ +/* + SQL query templates. +*/ + + + +// =====[ PLAYERS ]===== + +char sqlite_players_create[] = "\ +CREATE TABLE IF NOT EXISTS Players ( \ + SteamID32 INTEGER NOT NULL, \ + Alias TEXT, \ + Country TEXT, \ + IP TEXT, \ + Cheater INTEGER NOT NULL DEFAULT '0', \ + LastPlayed TIMESTAMP NULL DEFAULT NULL, \ + Created TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, \ + CONSTRAINT PK_Player PRIMARY KEY (SteamID32))"; + +char mysql_players_create[] = "\ +CREATE TABLE IF NOT EXISTS Players ( \ + SteamID32 INTEGER UNSIGNED NOT NULL, \ + Alias VARCHAR(32), \ + Country VARCHAR(45), \ + IP VARCHAR(15), \ + Cheater TINYINT UNSIGNED NOT NULL DEFAULT '0', \ + LastPlayed TIMESTAMP NULL DEFAULT NULL, \ + Created TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, \ + CONSTRAINT PK_Player PRIMARY KEY (SteamID32))"; + +char sqlite_players_insert[] = "\ +INSERT OR IGNORE INTO Players (Alias, Country, IP, SteamID32, LastPlayed) \ + VALUES ('%s', '%s', '%s', %d, CURRENT_TIMESTAMP)"; + +char sqlite_players_update[] = "\ +UPDATE OR IGNORE Players \ + SET Alias='%s', Country='%s', IP='%s', LastPlayed=CURRENT_TIMESTAMP \ + WHERE SteamID32=%d"; + +char mysql_players_upsert[] = "\ +INSERT INTO Players (Alias, Country, IP, SteamID32, LastPlayed) \ + VALUES ('%s', '%s', '%s', %d, CURRENT_TIMESTAMP) \ + ON DUPLICATE KEY UPDATE \ + SteamID32=VALUES(SteamID32), Alias=VALUES(Alias), Country=VALUES(Country), \ + IP=VALUES(IP), LastPlayed=VALUES(LastPlayed)"; + +char sql_players_get_cheater[] = "\ +SELECT Cheater \ + FROM Players \ + WHERE SteamID32=%d"; + +char sql_players_set_cheater[] = "\ +UPDATE Players \ + SET Cheater=%d \ + WHERE SteamID32=%d"; + + + +// =====[ MAPS ]===== + +char sqlite_maps_create[] = "\ +CREATE TABLE IF NOT EXISTS Maps ( \ + MapID INTEGER NOT NULL, \ + Name VARCHAR(32) NOT NULL UNIQUE, \ + LastPlayed TIMESTAMP NULL DEFAULT NULL, \ + Created TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, \ + CONSTRAINT PK_Maps PRIMARY KEY (MapID))"; + +char mysql_maps_create[] = "\ +CREATE TABLE IF NOT EXISTS Maps ( \ + MapID INTEGER UNSIGNED NOT NULL AUTO_INCREMENT, \ + Name VARCHAR(32) NOT NULL UNIQUE, \ + LastPlayed TIMESTAMP NULL DEFAULT NULL, \ + Created TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, \ + CONSTRAINT PK_Maps PRIMARY KEY (MapID))"; + +char sqlite_maps_insert[] = "\ +INSERT OR IGNORE INTO Maps (Name, LastPlayed) \ + VALUES ('%s', CURRENT_TIMESTAMP)"; + +char sqlite_maps_update[] = "\ +UPDATE OR IGNORE Maps \ + SET LastPlayed=CURRENT_TIMESTAMP \ + WHERE Name='%s'"; + +char mysql_maps_upsert[] = "\ +INSERT INTO Maps (Name, LastPlayed) \ + VALUES ('%s', CURRENT_TIMESTAMP) \ + ON DUPLICATE KEY UPDATE \ + LastPlayed=CURRENT_TIMESTAMP"; + +char sql_maps_findid[] = "\ +SELECT MapID, Name \ + FROM Maps \ + WHERE Name LIKE '%%%s%%' \ + ORDER BY (Name='%s') DESC, LENGTH(Name) \ + LIMIT 1"; + + + +// =====[ MAPCOURSES ]===== + +char sqlite_mapcourses_create[] = "\ +CREATE TABLE IF NOT EXISTS MapCourses ( \ + MapCourseID INTEGER NOT NULL, \ + MapID INTEGER NOT NULL, \ + Course INTEGER NOT NULL, \ + Created INTEGER NOT NULL DEFAULT CURRENT_TIMESTAMP, \ + CONSTRAINT PK_MapCourses PRIMARY KEY (MapCourseID), \ + CONSTRAINT UQ_MapCourses_MapIDCourse UNIQUE (MapID, Course), \ + CONSTRAINT FK_MapCourses_MapID FOREIGN KEY (MapID) REFERENCES Maps(MapID) \ + ON UPDATE CASCADE ON DELETE CASCADE)"; + +char mysql_mapcourses_create[] = "\ +CREATE TABLE IF NOT EXISTS MapCourses ( \ + MapCourseID INTEGER UNSIGNED NOT NULL AUTO_INCREMENT, \ + MapID INTEGER UNSIGNED NOT NULL, \ + Course INTEGER UNSIGNED NOT NULL, \ + Created TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, \ + CONSTRAINT PK_MapCourses PRIMARY KEY (MapCourseID), \ + CONSTRAINT UQ_MapCourses_MapIDCourse UNIQUE (MapID, Course), \ + CONSTRAINT FK_MapCourses_MapID FOREIGN KEY (MapID) REFERENCES Maps(MapID) \ + ON UPDATE CASCADE ON DELETE CASCADE)"; + +char sqlite_mapcourses_insert[] = "\ +INSERT OR IGNORE INTO MapCourses (MapID, Course) \ + VALUES (%d, %d)"; + +char mysql_mapcourses_insert[] = "\ +INSERT IGNORE INTO MapCourses (MapID, Course) \ + VALUES (%d, %d)"; + + + +// =====[ TIMES ]===== + +char sqlite_times_create[] = "\ +CREATE TABLE IF NOT EXISTS Times ( \ + TimeID INTEGER NOT NULL, \ + SteamID32 INTEGER NOT NULL, \ + MapCourseID INTEGER NOT NULL, \ + Mode INTEGER NOT NULL, \ + Style INTEGER NOT NULL, \ + RunTime INTEGER NOT NULL, \ + Teleports INTEGER NOT NULL, \ + Created INTEGER NOT NULL DEFAULT CURRENT_TIMESTAMP, \ + CONSTRAINT PK_Times PRIMARY KEY (TimeID), \ + CONSTRAINT FK_Times_SteamID32 FOREIGN KEY (SteamID32) REFERENCES Players(SteamID32) \ + ON UPDATE CASCADE ON DELETE CASCADE, CONSTRAINT FK_Times_MapCourseID \ + FOREIGN KEY (MapCourseID) REFERENCES MapCourses(MapCourseID) \ + ON UPDATE CASCADE ON DELETE CASCADE)"; + +char mysql_times_create[] = "\ +CREATE TABLE IF NOT EXISTS Times ( \ + TimeID INTEGER UNSIGNED NOT NULL AUTO_INCREMENT, \ + SteamID32 INTEGER UNSIGNED NOT NULL, \ + MapCourseID INTEGER UNSIGNED NOT NULL, \ + Mode TINYINT UNSIGNED NOT NULL, \ + Style TINYINT UNSIGNED NOT NULL, \ + RunTime INTEGER UNSIGNED NOT NULL, \ + Teleports SMALLINT UNSIGNED NOT NULL, \ + Created TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, \ + CONSTRAINT PK_Times PRIMARY KEY (TimeID), \ + CONSTRAINT FK_Times_SteamID32 FOREIGN KEY (SteamID32) REFERENCES Players(SteamID32) \ + ON UPDATE CASCADE ON DELETE CASCADE, \ + CONSTRAINT FK_Times_MapCourseID FOREIGN KEY (MapCourseID) REFERENCES MapCourses(MapCourseID) \ + ON UPDATE CASCADE ON DELETE CASCADE)"; + +char sql_times_insert[] = "\ +INSERT INTO Times (SteamID32, MapCourseID, Mode, Style, RunTime, Teleports) \ + SELECT %d, MapCourseID, %d, %d, %d, %d \ + FROM MapCourses \ + WHERE MapID=%d AND Course=%d"; + +char sql_times_delete[] = "\ +DELETE FROM Times \ + WHERE TimeID=%d"; + + + +// =====[ JUMPSTATS ]===== + +char sqlite_jumpstats_create[] = "\ +CREATE TABLE IF NOT EXISTS Jumpstats ( \ + JumpID INTEGER NOT NULL, \ + SteamID32 INTEGER NOT NULL, \ + JumpType INTEGER NOT NULL, \ + Mode INTEGER NOT NULL, \ + Distance INTEGER NOT NULL, \ + IsBlockJump INTEGER NOT NULL, \ + Block INTEGER NOT NULL, \ + Strafes INTEGER NOT NULL, \ + Sync INTEGER NOT NULL, \ + Pre INTEGER NOT NULL, \ + Max INTEGER NOT NULL, \ + Airtime INTEGER NOT NULL, \ + Created INTEGER NOT NULL DEFAULT CURRENT_TIMESTAMP, \ + CONSTRAINT PK_Jumpstats PRIMARY KEY (JumpID), \ + CONSTRAINT FK_Jumpstats_SteamID32 FOREIGN KEY (SteamID32) REFERENCES Players(SteamID32) \ + ON UPDATE CASCADE ON DELETE CASCADE)"; + +char mysql_jumpstats_create[] = "\ +CREATE TABLE IF NOT EXISTS Jumpstats ( \ + JumpID INTEGER UNSIGNED NOT NULL AUTO_INCREMENT, \ + SteamID32 INTEGER UNSIGNED NOT NULL, \ + JumpType TINYINT UNSIGNED NOT NULL, \ + Mode TINYINT UNSIGNED NOT NULL, \ + Distance INTEGER UNSIGNED NOT NULL, \ + IsBlockJump TINYINT UNSIGNED NOT NULL, \ + Block SMALLINT UNSIGNED NOT NULL, \ + Strafes INTEGER UNSIGNED NOT NULL, \ + Sync INTEGER UNSIGNED NOT NULL, \ + Pre INTEGER UNSIGNED NOT NULL, \ + Max INTEGER UNSIGNED NOT NULL, \ + Airtime INTEGER UNSIGNED NOT NULL, \ + Created TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, \ + CONSTRAINT PK_Jumpstats PRIMARY KEY (JumpID), \ + CONSTRAINT FK_Jumpstats_SteamID32 FOREIGN KEY (SteamID32) REFERENCES Players(SteamID32) \ + ON UPDATE CASCADE ON DELETE CASCADE)"; + +char sql_jumpstats_insert[] = "\ +INSERT INTO Jumpstats (SteamID32, JumpType, Mode, Distance, IsBlockJump, Block, Strafes, Sync, Pre, Max, Airtime) \ + VALUES (%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d)"; + +char sql_jumpstats_update[] = "\ +UPDATE Jumpstats \ + SET \ + SteamID32=%d, \ + JumpType=%d, \ + Mode=%d, \ + Distance=%d, \ + IsBlockJump=%d, \ + Block=%d, \ + Strafes=%d, \ + Sync=%d, \ + Pre=%d, \ + Max=%d, \ + Airtime=%d \ + WHERE \ + JumpID=%d"; + +char sql_jumpstats_getrecord[] = "\ +SELECT JumpID, Distance, Block \ + FROM \ + Jumpstats \ + WHERE \ + SteamID32=%d AND \ + JumpType=%d AND \ + Mode=%d AND \ + IsBlockJump=%d \ + ORDER BY Block DESC, Distance DESC"; + +char sql_jumpstats_deleterecord[] = "\ +DELETE \ + FROM \ + Jumpstats \ + WHERE \ + JumpID = \ + ( SELECT * FROM ( \ + SELECT JumpID \ + FROM \ + Jumpstats \ + WHERE \ + SteamID32=%d AND \ + JumpType=%d AND \ + Mode=%d AND \ + IsBlockJump=%d \ + ORDER BY Block DESC, Distance DESC \ + LIMIT 1 \ + ) AS tmp \ + )"; + +char sql_jumpstats_deleteallrecords[] = "\ +DELETE \ + FROM \ + Jumpstats \ + WHERE \ + SteamID32 = %d;"; + +char sql_jumpstats_deletejump[] = "\ +DELETE \ + FROM \ + Jumpstats \ + WHERE \ + JumpID = %d;"; + +char sql_jumpstats_getpbs[] = "\ +SELECT MAX(Distance), Mode, JumpType \ + FROM \ + Jumpstats \ + WHERE \ + SteamID32=%d \ + GROUP BY \ + Mode, JumpType"; + +char sql_jumpstats_getblockpbs[] = "\ +SELECT MAX(js.Distance), js.Mode, js.JumpType, js.Block \ + FROM \ + Jumpstats js \ + INNER JOIN \ + ( \ + SELECT Mode, JumpType, MAX(BLOCK) Block \ + FROM \ + Jumpstats \ + WHERE \ + IsBlockJump=1 AND \ + SteamID32=%d \ + GROUP BY \ + Mode, JumpType \ + ) pb \ + ON \ + js.Mode=pb.Mode AND \ + js.JumpType=pb.JumpType AND \ + js.Block=pb.Block \ + WHERE \ + js.SteamID32=%d \ + GROUP BY \ + js.Mode, js.JumpType, js.Block"; + + + +// =====[ VB POSITIONS ]===== + +char sqlite_vbpos_create[] = "\ +CREATE TABLE IF NOT EXISTS VBPosition ( \ + SteamID32 INTEGER NOT NULL, \ + MapID INTEGER NOT NULL, \ + X REAL NOT NULL, \ + Y REAL NOT NULL, \ + Z REAL NOT NULL, \ + Course INTEGER NOT NULL, \ + IsStart INTEGER NOT NULL, \ + CONSTRAINT PK_VBPosition PRIMARY KEY (SteamID32, MapID, IsStart), \ + CONSTRAINT FK_VBPosition_SteamID32 FOREIGN KEY (SteamID32) REFERENCES Players(SteamID32), \ + CONSTRAINT FK_VBPosition_MapID FOREIGN KEY (MapID) REFERENCES Maps(MapID) \ + ON UPDATE CASCADE ON DELETE CASCADE)"; + +char mysql_vbpos_create[] = "\ +CREATE TABLE IF NOT EXISTS VBPosition ( \ + SteamID32 INTEGER UNSIGNED NOT NULL, \ + MapID INTEGER UNSIGNED NOT NULL, \ + X REAL NOT NULL, \ + Y REAL NOT NULL, \ + Z REAL NOT NULL, \ + Course INTEGER NOT NULL, \ + IsStart INTEGER NOT NULL, \ + CONSTRAINT PK_VBPosition PRIMARY KEY (SteamID32, MapID, IsStart), \ + CONSTRAINT FK_VBPosition_SteamID32 FOREIGN KEY (SteamID32) REFERENCES Players(SteamID32), \ + CONSTRAINT FK_VBPosition_MapID FOREIGN KEY (MapID) REFERENCES Maps(MapID) \ + ON UPDATE CASCADE ON DELETE CASCADE)"; + +char sql_vbpos_upsert[] = "\ +REPLACE INTO VBPosition (SteamID32, MapID, X, Y, Z, Course, IsStart) \ + VALUES (%d, %d, %f, %f, %f, %d, %d)"; + +char sql_vbpos_get[] = "\ +SELECT SteamID32, MapID, Course, IsStart, X, Y, Z \ + FROM \ + VBPosition \ + WHERE \ + SteamID32 = %d AND \ + MapID = %d"; + + + +// =====[ START POSITIONS ]===== + +char sqlite_startpos_create[] = "\ +CREATE TABLE IF NOT EXISTS StartPosition ( \ + SteamID32 INTEGER NOT NULL, \ + MapID INTEGER NOT NULL, \ + X REAL NOT NULL, \ + Y REAL NOT NULL, \ + Z REAL NOT NULL, \ + Angle0 REAL NOT NULL, \ + Angle1 REAL NOT NULL, \ + CONSTRAINT PK_StartPosition PRIMARY KEY (SteamID32, MapID), \ + CONSTRAINT FK_StartPosition_SteamID32 FOREIGN KEY (SteamID32) REFERENCES Players(SteamID32) \ + CONSTRAINT FK_StartPosition_MapID FOREIGN KEY (MapID) REFERENCES Maps(MapID) \ + ON UPDATE CASCADE ON DELETE CASCADE)"; + +char mysql_startpos_create[] = "\ +CREATE TABLE IF NOT EXISTS StartPosition ( \ + SteamID32 INTEGER UNSIGNED NOT NULL, \ + MapID INTEGER UNSIGNED NOT NULL, \ + X REAL NOT NULL, \ + Y REAL NOT NULL, \ + Z REAL NOT NULL, \ + Angle0 REAL NOT NULL, \ + Angle1 REAL NOT NULL, \ + CONSTRAINT PK_StartPosition PRIMARY KEY (SteamID32, MapID), \ + CONSTRAINT FK_StartPosition_SteamID32 FOREIGN KEY (SteamID32) REFERENCES Players(SteamID32), \ + CONSTRAINT FK_StartPosition_MapID FOREIGN KEY (MapID) REFERENCES Maps(MapID) \ + ON UPDATE CASCADE ON DELETE CASCADE)"; + +char sql_startpos_upsert[] = "\ +REPLACE INTO StartPosition (SteamID32, MapID, X, Y, Z, Angle0, Angle1) \ + VALUES (%d, %d, %f, %f, %f, %f, %f)"; + +char sql_startpos_get[] = "\ +SELECT SteamID32, MapID, X, Y, Z, Angle0, Angle1 \ + FROM \ + StartPosition \ + WHERE \ + SteamID32 = %d AND \ + MapID = %d"; diff --git a/sourcemod/scripting/gokz-localdb/db/timer_setup.sp b/sourcemod/scripting/gokz-localdb/db/timer_setup.sp new file mode 100644 index 0000000..b123eeb --- /dev/null +++ b/sourcemod/scripting/gokz-localdb/db/timer_setup.sp @@ -0,0 +1,167 @@ + +// ===== [ SAVE TIMER SETUP ] ===== + +void DB_SaveTimerSetup(int client) +{ + bool txnHasQuery = false; + int course; + float position[3], angles[3]; + + if (!IsValidClient(client)) + { + return; + } + + int steamid = GetSteamAccountID(client); + DataPack data = new DataPack(); + + data.WriteCell(client); + data.WriteCell(steamid); + + char query[1024]; + Transaction txn = SQL_CreateTransaction(); + + if (GOKZ_GetStartPosition(client, position, angles) == StartPositionType_Custom) + { + FormatEx(query, sizeof(query), sql_startpos_upsert, steamid, gI_DBCurrentMapID, position[0], position[1], position[2], angles[0], angles[1]); + txn.AddQuery(query); + txnHasQuery = true; + } + + course = GOKZ_GetVirtualButtonPosition(client, position, true); + if (course != -1) + { + FormatEx(query, sizeof(query), sql_vbpos_upsert, steamid, gI_DBCurrentMapID, position[0], position[1], position[2], course, 1); + txn.AddQuery(query); + txnHasQuery = true; + } + + course = GOKZ_GetVirtualButtonPosition(client, position, false); + if (course != -1) + { + FormatEx(query, sizeof(query), sql_vbpos_upsert, steamid, gI_DBCurrentMapID, position[0], position[1], position[2], course, 0); + txn.AddQuery(query); + txnHasQuery = true; + } + + if (txnHasQuery) + { + SQL_ExecuteTransaction(gH_DB, txn, DB_TxnSuccess_SaveTimerSetup, DB_TxnFailure_Generic_DataPack, data, DBPrio_Low); + } + else + { + delete data; + delete txn; + } +} + +public void DB_TxnSuccess_SaveTimerSetup(Handle db, DataPack data, int numQueries, Handle[] results, any[] queryData) +{ + data.Reset(); + int client = data.ReadCell(); + int steamid = data.ReadCell(); + delete data; + + if (!IsValidClient(client) || steamid != GetSteamAccountID(client)) + { + return; + } + + GOKZ_PrintToChat(client, true, "%t", "Timer Setup Saved"); +} + + + +// ===== [ LOAD TIMER SETUP ] ===== + +void DB_LoadTimerSetup(int client, bool doChatMessage = false) +{ + if (!IsValidClient(client)) + { + return; + } + + int steamid = GetSteamAccountID(client); + + DataPack data = new DataPack(); + data.WriteCell(client); + data.WriteCell(steamid); + data.WriteCell(doChatMessage); + + char query[1024]; + Transaction txn = SQL_CreateTransaction(); + + // Virtual Buttons + FormatEx(query, sizeof(query), sql_vbpos_get, steamid, gI_DBCurrentMapID); + txn.AddQuery(query); + + // Start Position + FormatEx(query, sizeof(query), sql_startpos_get, steamid, gI_DBCurrentMapID); + txn.AddQuery(query); + + SQL_ExecuteTransaction(gH_DB, txn, DB_TxnSuccess_LoadTimerSetup, DB_TxnFailure_Generic_DataPack, data, DBPrio_Normal); +} + +public void DB_TxnSuccess_LoadTimerSetup(Handle db, DataPack data, int numQueries, DBResultSet[] results, any[] queryData) +{ + data.Reset(); + int client = data.ReadCell(); + int steamid = data.ReadCell(); + bool doChatMessage = data.ReadCell(); + delete data; + + if (!IsValidClient(client) || steamid != GetSteamAccountID(client)) + { + return; + } + + int course; + bool isStart, vbSetup = false; + float position[3], angles[3]; + + if (results[0].RowCount > 0 && results[0].FetchRow()) + { + position[0] = results[0].FetchFloat(TimerSetupDB_GetVBPos_PositionX); + position[1] = results[0].FetchFloat(TimerSetupDB_GetVBPos_PositionY); + position[2] = results[0].FetchFloat(TimerSetupDB_GetVBPos_PositionZ); + course = results[0].FetchInt(TimerSetupDB_GetVBPos_Course); + isStart = results[0].FetchInt(TimerSetupDB_GetVBPos_IsStart) == 1; + + GOKZ_SetVirtualButtonPosition(client, position, course, isStart); + vbSetup = true; + } + + if (results[0].RowCount > 1 && results[0].FetchRow()) + { + position[0] = results[0].FetchFloat(TimerSetupDB_GetVBPos_PositionX); + position[1] = results[0].FetchFloat(TimerSetupDB_GetVBPos_PositionY); + position[2] = results[0].FetchFloat(TimerSetupDB_GetVBPos_PositionZ); + course = results[0].FetchInt(TimerSetupDB_GetVBPos_Course); + isStart = results[0].FetchInt(TimerSetupDB_GetVBPos_IsStart) == 1; + + GOKZ_SetVirtualButtonPosition(client, position, course, isStart); + vbSetup = true; + } + + if (results[1].RowCount > 0 && results[1].FetchRow()) + { + position[0] = results[1].FetchFloat(TimerSetupDB_GetStartPos_PositionX); + position[1] = results[1].FetchFloat(TimerSetupDB_GetStartPos_PositionY); + position[2] = results[1].FetchFloat(TimerSetupDB_GetStartPos_PositionZ); + angles[0] = results[1].FetchFloat(TimerSetupDB_GetStartPos_Angle0); + angles[1] = results[1].FetchFloat(TimerSetupDB_GetStartPos_Angle1); + angles[2] = 0.0; + + GOKZ_SetStartPosition(client, StartPositionType_Custom, position, angles); + } + + if (vbSetup) + { + GOKZ_LockVirtualButtons(client); + } + + if (doChatMessage) + { + GOKZ_PrintToChat(client, true, "%t", "Timer Setup Loaded"); + } +} diff --git a/sourcemod/scripting/gokz-localdb/options.sp b/sourcemod/scripting/gokz-localdb/options.sp new file mode 100644 index 0000000..2a8240a --- /dev/null +++ b/sourcemod/scripting/gokz-localdb/options.sp @@ -0,0 +1,90 @@ + +// =====[ OPTIONS ]===== + +void OnOptionsMenuReady_Options() +{ + RegisterOptions(); +} + +void RegisterOptions() +{ + for (DBOption option; option < DBOPTION_COUNT; option++) + { + GOKZ_RegisterOption(gC_DBOptionNames[option], gC_DBOptionDescriptions[option], + OptionType_Int, gI_DBOptionDefaultValues[option], 0, gI_DBOptionCounts[option] - 1); + } +} + + + +// =====[ OPTIONS MENU ]===== + +TopMenu gTM_Options; +TopMenuObject gTMO_CatGeneral; +TopMenuObject gTMO_ItemsDB[DBOPTION_COUNT]; + +void OnOptionsMenuReady_OptionsMenu(TopMenu topMenu) +{ + if (gTM_Options == topMenu) + { + return; + } + + gTM_Options = topMenu; + gTMO_CatGeneral = gTM_Options.FindCategory(GENERAL_OPTION_CATEGORY); + + for (int option = 0; option < view_as<int>(DBOPTION_COUNT); option++) + { + gTMO_ItemsDB[option] = gTM_Options.AddItem(gC_DBOptionNames[option], TopMenuHandler_DB, gTMO_CatGeneral); + } +} + +public void TopMenuHandler_DB(TopMenu topmenu, TopMenuAction action, TopMenuObject topobj_id, int param, char[] buffer, int maxlength) +{ + DBOption option = DBOPTION_COUNT; + for (int i = 0; i < view_as<int>(DBOPTION_COUNT); i++) + { + if (topobj_id == gTMO_ItemsDB[i]) + { + option = view_as<DBOption>(i); + break; + } + } + + if (option == DBOPTION_COUNT) + { + return; + } + + if (action == TopMenuAction_DisplayOption) + { + switch (option) + { + case DBOption_AutoLoadTimerSetup: + { + FormatToggleableOptionDisplay(param, DBOption_AutoLoadTimerSetup, buffer, maxlength); + } + } + } + else if (action == TopMenuAction_SelectOption) + { + GOKZ_CycleOption(param, gC_DBOptionNames[option]); + gTM_Options.Display(param, TopMenuPosition_LastCategory); + } +} + +void FormatToggleableOptionDisplay(int client, DBOption option, char[] buffer, int maxlength) +{ + if (GOKZ_GetOption(client, gC_DBOptionNames[option]) == DBOption_Disabled) + { + FormatEx(buffer, maxlength, "%T - %T", + gC_DBOptionPhrases[option], client, + "Options Menu - Disabled", client); + } + else + { + FormatEx(buffer, maxlength, "%T - %T", + gC_DBOptionPhrases[option], client, + "Options Menu - Enabled", client); + } +} diff --git a/sourcemod/scripting/gokz-localranks.sp b/sourcemod/scripting/gokz-localranks.sp new file mode 100644 index 0000000..e2fd06d --- /dev/null +++ b/sourcemod/scripting/gokz-localranks.sp @@ -0,0 +1,263 @@ +#include <sourcemod> + +#include <cstrike> +#include <sdktools> + +#include <gokz/core> +#include <gokz/localdb> +#include <gokz/localranks> + +#include <sourcemod-colors> + +#undef REQUIRE_EXTENSIONS +#undef REQUIRE_PLUGIN +#include <gokz/global> +#include <gokz/jumpstats> +#include <gokz/replays> +#include <updater> + +#pragma newdecls required +#pragma semicolon 1 + + + +public Plugin myinfo = +{ + name = "GOKZ Local Ranks", + author = "DanZay", + description = "Extends and provides in-game functionality for local database", + version = GOKZ_VERSION, + url = GOKZ_SOURCE_URL +}; + +#define UPDATER_URL GOKZ_UPDATER_BASE_URL..."gokz-localranks.txt" + +bool gB_GOKZGlobal; +Database gH_DB = null; +DatabaseType g_DBType = DatabaseType_None; +bool gB_RecordExistsCache[GOKZ_MAX_COURSES][MODE_COUNT][TIMETYPE_COUNT]; +float gF_RecordTimesCache[GOKZ_MAX_COURSES][MODE_COUNT][TIMETYPE_COUNT]; +bool gB_RecordMissed[MAXPLAYERS + 1][TIMETYPE_COUNT]; +bool gB_PBExistsCache[MAXPLAYERS + 1][GOKZ_MAX_COURSES][MODE_COUNT][TIMETYPE_COUNT]; +float gF_PBTimesCache[MAXPLAYERS + 1][GOKZ_MAX_COURSES][MODE_COUNT][TIMETYPE_COUNT]; +bool gB_PBMissed[MAXPLAYERS + 1][TIMETYPE_COUNT]; +char gC_BeatRecordSound[256]; + + +#include "gokz-localranks/api.sp" +#include "gokz-localranks/commands.sp" +#include "gokz-localranks/misc.sp" + +#include "gokz-localranks/db/sql.sp" +#include "gokz-localranks/db/helpers.sp" +#include "gokz-localranks/db/cache_pbs.sp" +#include "gokz-localranks/db/cache_records.sp" +#include "gokz-localranks/db/create_tables.sp" +#include "gokz-localranks/db/get_completion.sp" +#include "gokz-localranks/db/js_top.sp" +#include "gokz-localranks/db/map_top.sp" +#include "gokz-localranks/db/player_top.sp" +#include "gokz-localranks/db/print_average.sp" +#include "gokz-localranks/db/print_js.sp" +#include "gokz-localranks/db/print_pbs.sp" +#include "gokz-localranks/db/print_records.sp" +#include "gokz-localranks/db/process_new_time.sp" +#include "gokz-localranks/db/recent_records.sp" +#include "gokz-localranks/db/update_ranked_map_pool.sp" +#include "gokz-localranks/db/display_js.sp" + + + +// =====[ PLUGIN EVENTS ]===== + +public APLRes AskPluginLoad2(Handle myself, bool late, char[] error, int err_max) +{ + CreateNatives(); + RegPluginLibrary("gokz-localranks"); + return APLRes_Success; +} + +public void OnPluginStart() +{ + LoadTranslations("gokz-common.phrases"); + LoadTranslations("gokz-localranks.phrases"); + + CreateGlobalForwards(); + RegisterCommands(); +} + +public void OnAllPluginsLoaded() +{ + if (LibraryExists("updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + gB_GOKZGlobal = LibraryExists("gokz-global"); + + gH_DB = GOKZ_DB_GetDatabase(); + if (gH_DB != null) + { + g_DBType = GOKZ_DB_GetDatabaseType(); + DB_CreateTables(); + CompletionMVPStarsUpdateAll(); + } + + if (GOKZ_DB_IsMapSetUp()) + { + GOKZ_DB_OnMapSetup(GOKZ_DB_GetCurrentMapID()); + } + + for (int i = 1; i <= MaxClients; i++) + { + if (GOKZ_DB_IsClientSetUp(i)) + { + GOKZ_DB_OnClientSetup(i, GetSteamAccountID(i), GOKZ_DB_IsCheater(i)); + } + } +} + +public void OnLibraryAdded(const char[] name) +{ + if (StrEqual(name, "updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + gB_GOKZGlobal = gB_GOKZGlobal || StrEqual(name, "gokz-global"); +} + +public void OnLibraryRemoved(const char[] name) +{ + gB_GOKZGlobal = gB_GOKZGlobal && !StrEqual(name, "gokz-global"); +} + + + +// =====[ CLIENT EVENTS ]===== + +public Action OnPlayerRunCmd(int client, int &buttons, int &impulse, float vel[3], float angles[3], int &weapon, int &subtype, int &cmdnum, int &tickcount, int &seed, int mouse[2]) +{ + UpdateRecordMissed(client); + UpdatePBMissed(client); + return Plugin_Continue; +} + +public void GOKZ_OnTimerStart_Post(int client, int course) +{ + ResetRecordMissed(client); + ResetPBMissed(client); +} + +public void GOKZ_DB_OnClientSetup(int client, int steamID, bool cheater) +{ + if (GOKZ_DB_IsMapSetUp()) + { + DB_CachePBs(client, steamID); + CompletionMVPStarsUpdate(client); + } +} + +public void GOKZ_DB_OnTimeInserted(int client, int steamID, int mapID, int course, int mode, int style, int runTimeMS, int teleportsUsed) +{ + if (GOKZ_DB_IsCheater(client)) + { + DB_CachePBs(client, GetSteamAccountID(client)); + } + else + { + DB_ProcessNewTime(client, steamID, mapID, course, mode, style, runTimeMS, teleportsUsed); + } +} + +public void GOKZ_LR_OnTimeProcessed( + int client, + int steamID, + int mapID, + int course, + int mode, + int style, + float runTime, + int teleportsUsed, + bool firstTime, + float pbDiff, + int rank, + int maxRank, + bool firstTimePro, + float pbDiffPro, + int rankPro, + int maxRankPro) +{ + if (mapID != GOKZ_DB_GetCurrentMapID()) + { + return; + } + + AnnounceNewTime(client, course, mode, runTime, teleportsUsed, firstTime, pbDiff, rank, maxRank, firstTimePro, pbDiffPro, rankPro, maxRankPro); + + if (mode == GOKZ_GetDefaultMode() && firstTimePro) + { + CompletionMVPStarsUpdate(client); + } + + // If new PB, update PB cache + if (firstTime || firstTimePro || pbDiff < 0.0 || pbDiffPro < 0.0) + { + DB_CachePBs(client, GetSteamAccountID(client)); + } +} + +public void GOKZ_LR_OnNewRecord(int client, int steamID, int mapID, int course, int mode, int style, int recordType) +{ + if (mapID != GOKZ_DB_GetCurrentMapID()) + { + return; + } + + AnnounceNewRecord(client, course, mode, recordType); + DB_CacheRecords(mapID); +} + +public void GOKZ_LR_OnPBMissed(int client, float pbTime, int course, int mode, int style, int recordType) +{ + DoPBMissedReport(client, pbTime, recordType); +} + + + +// =====[ OTHER EVENTS ]===== + +public void OnMapStart() +{ + PrecacheAnnouncementSounds(); +} + +public void GOKZ_DB_OnDatabaseConnect(DatabaseType DBType) +{ + gH_DB = GOKZ_DB_GetDatabase(); + g_DBType = DBType; + DB_CreateTables(); + CompletionMVPStarsUpdateAll(); +} + +public void GOKZ_DB_OnMapSetup(int mapID) +{ + DB_CacheRecords(mapID); + + for (int client = 1; client <= MaxClients; client++) + { + if (GOKZ_DB_IsClientSetUp(client)) + { + DB_CachePBs(client, GetSteamAccountID(client)); + } + } +} + +public Action GOKZ_OnTimerEndMessage(int client, int course, float time, int teleportsUsed) +{ + if (GOKZ_DB_IsCheater(client)) + { + return Plugin_Continue; + } + + // Block timer end messages from GOKZ Core - this plugin handles them + return Plugin_Stop; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-localranks/api.sp b/sourcemod/scripting/gokz-localranks/api.sp new file mode 100644 index 0000000..34b3ece --- /dev/null +++ b/sourcemod/scripting/gokz-localranks/api.sp @@ -0,0 +1,120 @@ +static GlobalForward H_OnTimeProcessed; +static GlobalForward H_OnNewRecord; +static GlobalForward H_OnRecordMissed; +static GlobalForward H_OnPBMissed; + + + +// =====[ FORWARDS ]===== + +void CreateGlobalForwards() +{ + H_OnTimeProcessed = new GlobalForward("GOKZ_LR_OnTimeProcessed", ET_Ignore, Param_Cell, Param_Cell, Param_Cell, Param_Cell, Param_Cell, Param_Cell, Param_Float, Param_Cell, Param_Cell, Param_Float, Param_Cell, Param_Cell, Param_Cell, Param_Float, Param_Cell, Param_Cell); + H_OnNewRecord = new GlobalForward("GOKZ_LR_OnNewRecord", ET_Ignore, Param_Cell, Param_Cell, Param_Cell, Param_Cell, Param_Cell, Param_Cell, Param_Cell, Param_Float, Param_Cell, Param_Float, Param_Cell); + H_OnRecordMissed = new GlobalForward("GOKZ_LR_OnRecordMissed", ET_Ignore, Param_Cell, Param_Float, Param_Cell, Param_Cell, Param_Cell, Param_Cell); + H_OnPBMissed = new GlobalForward("GOKZ_LR_OnPBMissed", ET_Ignore, Param_Cell, Param_Float, Param_Cell, Param_Cell, Param_Cell, Param_Cell); +} + +void Call_OnTimeProcessed( + int client, + int steamID, + int mapID, + int course, + int mode, + int style, + float runTime, + int teleports, + bool firstTime, + float pbDiff, + int rank, + int maxRank, + bool firstTimePro, + float pbDiffPro, + int rankPro, + int maxRankPro) +{ + Call_StartForward(H_OnTimeProcessed); + Call_PushCell(client); + Call_PushCell(steamID); + Call_PushCell(mapID); + Call_PushCell(course); + Call_PushCell(mode); + Call_PushCell(style); + Call_PushFloat(runTime); + Call_PushCell(teleports); + Call_PushCell(firstTime); + Call_PushFloat(pbDiff); + Call_PushCell(rank); + Call_PushCell(maxRank); + Call_PushCell(firstTimePro); + Call_PushFloat(pbDiffPro); + Call_PushCell(rankPro); + Call_PushCell(maxRankPro); + Call_Finish(); +} + +void Call_OnNewRecord(int client, int steamID, int mapID, int course, int mode, int style, int recordType, float pbDiff, int teleportsUsed) +{ + Call_StartForward(H_OnNewRecord); + Call_PushCell(client); + Call_PushCell(steamID); + Call_PushCell(mapID); + Call_PushCell(course); + Call_PushCell(mode); + Call_PushCell(style); + Call_PushCell(recordType); + Call_PushFloat(pbDiff); + Call_PushCell(teleportsUsed); + Call_Finish(); +} + +void Call_OnRecordMissed(int client, float recordTime, int course, int mode, int style, int recordType) +{ + Call_StartForward(H_OnRecordMissed); + Call_PushCell(client); + Call_PushFloat(recordTime); + Call_PushCell(course); + Call_PushCell(mode); + Call_PushCell(style); + Call_PushCell(recordType); + Call_Finish(); +} + +void Call_OnPBMissed(int client, float pbTime, int course, int mode, int style, int recordType) +{ + Call_StartForward(H_OnPBMissed); + Call_PushCell(client); + Call_PushFloat(pbTime); + Call_PushCell(course); + Call_PushCell(mode); + Call_PushCell(style); + Call_PushCell(recordType); + Call_Finish(); +} + + + +// =====[ NATIVES ]===== + +void CreateNatives() +{ + CreateNative("GOKZ_LR_GetRecordMissed", Native_GetRecordMissed); + CreateNative("GOKZ_LR_GetPBMissed", Native_GetPBMissed); + CreateNative("GOKZ_LR_ReopenMapTopMenu", Native_ReopenMapTopMenu); +} + +public int Native_GetRecordMissed(Handle plugin, int numParams) +{ + return view_as<int>(gB_RecordMissed[GetNativeCell(1)][GetNativeCell(2)]); +} + +public int Native_GetPBMissed(Handle plugin, int numParams) +{ + return view_as<int>(gB_PBMissed[GetNativeCell(1)][GetNativeCell(2)]); +} + +public int Native_ReopenMapTopMenu(Handle plugin, int numParams) +{ + ReopenMapTopMenu(GetNativeCell(1)); + return 0; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-localranks/commands.sp b/sourcemod/scripting/gokz-localranks/commands.sp new file mode 100644 index 0000000..44063af --- /dev/null +++ b/sourcemod/scripting/gokz-localranks/commands.sp @@ -0,0 +1,506 @@ +static float lastCommandTime[MAXPLAYERS + 1]; + + + +void RegisterCommands() +{ + RegConsoleCmd("sm_top", CommandTop, "[KZ] Open a menu showing the top record holders."); + RegConsoleCmd("sm_maptop", CommandMapTop, "[KZ] Open a menu showing the top main course times of a map. Usage: !maptop <map>"); + RegConsoleCmd("sm_bmaptop", CommandBMapTop, "[KZ] Open a menu showing the top bonus times of a map. Usage: !bmaptop <#bonus> <map>"); + RegConsoleCmd("sm_bonustop", CommandBMapTop, "[KZ] Open a menu showing the top bonus times of a map. Usage: !bonustop <#bonus> <map>"); + RegConsoleCmd("sm_btop", CommandBMapTop, "[KZ] Open a menu showing the top bonus times of a map. Usage: !btop <#bonus> <map>"); + RegConsoleCmd("sm_pb", CommandPB, "[KZ] Show PB main course times and ranks in chat. Usage: !pb <map> <player>"); + RegConsoleCmd("sm_bpb", CommandBPB, "[KZ] Show PB bonus times and ranks in chat. Usage: !bpb <#bonus> <map> <player>"); + RegConsoleCmd("sm_wr", CommandWR, "[KZ] Show main course record times in chat. Usage: !wr <map>"); + RegConsoleCmd("sm_bwr", CommandBWR, "[KZ] Show bonus record times in chat. Usage: !bwr <#bonus> <map>"); + RegConsoleCmd("sm_avg", CommandAVG, "[KZ] Show the average main course run time in chat. Usage !avg <map>"); + RegConsoleCmd("sm_bavg", CommandBAVG, "[KZ] Show the average bonus run time in chat. Usage !bavg <#bonus> <map>"); + RegConsoleCmd("sm_pc", CommandPC, "[KZ] Show course completion in chat. Usage: !pc <player>"); + RegConsoleCmd("sm_rr", CommandRecentRecords, "[KZ] Open a menu showing recently broken records."); + RegConsoleCmd("sm_latest", CommandRecentRecords, "[KZ] Open a menu showing recently broken records."); + + RegConsoleCmd("sm_ljpb", CommandLJPB, "[KZ] Show PB Long Jump in chat. Usage: !ljpb <jumper>"); + RegConsoleCmd("sm_bhpb", CommandBHPB, "[KZ] Show PB Bunnyhop in chat. Usage: !bhpb <jumper>"); + RegConsoleCmd("sm_lbhpb", CommandLBHPB, "[KZ] Show PB Lowpre Bunnyhop in chat. Usage: !lbhpb <jumper>"); + RegConsoleCmd("sm_mbhpb", CommandMBHPB, "[KZ] Show PB Multi Bunnyhop in chat. Usage: !mbhpb <jumper>"); + RegConsoleCmd("sm_wjpb", CommandWJPB, "[KZ] Show PB Weird Jump in chat. Usage: !wjpb <jumper>"); + RegConsoleCmd("sm_lwjpb", CommandLWJPB, "[KZ] Show PB Lowpre Weird Jump in chat. Usage: !lwjpb <jumper>"); + RegConsoleCmd("sm_lajpb", CommandLAJPB, "[KZ] Show PB Ladder Jump in chat. Usage: !lajpb <jumper>"); + RegConsoleCmd("sm_lahpb", CommandLAHPB, "[KZ] Show PB Ladderhop in chat. Usage: !lahpb <jumper>"); + RegConsoleCmd("sm_jbpb", CommandJBPB, "[KZ] Show PB Jumpbug in chat. Usage: !jbpb <jumper>"); + RegConsoleCmd("sm_js", CommandJS, "[KZ] Open a menu showing jumpstat PBs. Usage: !js <jumper>"); + RegConsoleCmd("sm_jumpstats", CommandJS, "[KZ] Open a menu showing jumpstat PBs. Usage: !jumpstats <jumper>"); + RegConsoleCmd("sm_jstop", CommandJSTop, "[KZ] Open a menu showing the top jumpstats."); + RegConsoleCmd("sm_jumptop", CommandJSTop, "[KZ] Open a menu showing the top jumpstats."); + + RegAdminCmd("sm_updatemappool", CommandUpdateMapPool, ADMFLAG_ROOT, "[KZ] Update the ranked map pool with the list of maps in cfg/sourcemod/gokz/gokz-localranks-mappool.cfg."); +} + +public Action CommandTop(int client, int args) +{ + if (IsSpammingCommands(client)) + { + return Plugin_Handled; + } + + DisplayPlayerTopModeMenu(client); + return Plugin_Handled; +} + +public Action CommandMapTop(int client, int args) +{ + if (IsSpammingCommands(client)) + { + return Plugin_Handled; + } + + if (args == 0) + { // Open map top for current map + DB_OpenMapTopModeMenu(client, GOKZ_DB_GetCurrentMapID(), 0); + } + else if (args >= 1) + { // Open map top for specified map + char specifiedMap[33]; + GetCmdArg(1, specifiedMap, sizeof(specifiedMap)); + DB_OpenMapTopModeMenu_FindMap(client, specifiedMap, 0); + } + return Plugin_Handled; +} + +public Action CommandBMapTop(int client, int args) +{ + if (IsSpammingCommands(client)) + { + return Plugin_Handled; + } + + if (args == 0) + { // Open Bonus 1 top for current map + DB_OpenMapTopModeMenu(client, GOKZ_DB_GetCurrentMapID(), 1); + } + else if (args == 1) + { // Open specified Bonus # top for current map + char argBonus[4]; + GetCmdArg(1, argBonus, sizeof(argBonus)); + int bonus = StringToInt(argBonus); + if (GOKZ_IsValidCourse(bonus, true)) + { + DB_OpenMapTopModeMenu(client, GOKZ_DB_GetCurrentMapID(), bonus); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Invalid Bonus Number", argBonus); + } + } + else if (args >= 2) + { // Open specified bonus top for specified map + char argBonus[4], argMap[33]; + GetCmdArg(1, argBonus, sizeof(argBonus)); + GetCmdArg(2, argMap, sizeof(argMap)); + int bonus = StringToInt(argBonus); + if (GOKZ_IsValidCourse(bonus, true)) + { + DB_OpenMapTopModeMenu_FindMap(client, argMap, bonus); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Invalid Bonus Number", argBonus); + } + } + return Plugin_Handled; +} + +public Action CommandPB(int client, int args) +{ + if (IsSpammingCommands(client)) + { + return Plugin_Handled; + } + + if (args == 0) + { // Print their PBs for current map and their current mode + DB_PrintPBs(client, GetSteamAccountID(client), GOKZ_DB_GetCurrentMapID(), 0, GOKZ_GetCoreOption(client, Option_Mode)); + if (gB_GOKZGlobal) + { + char steamid[32]; + GetClientAuthId(client, AuthId_Steam2, steamid, sizeof(steamid)); + GOKZ_GL_PrintRecords(client, "", 0, GOKZ_GetCoreOption(client, Option_Mode), steamid); + } + } + else if (args == 1) + { // Print their PBs for specified map and their current mode + char argMap[33]; + GetCmdArg(1, argMap, sizeof(argMap)); + DB_PrintPBs_FindMap(client, GetSteamAccountID(client), argMap, 0, GOKZ_GetCoreOption(client, Option_Mode)); + } + else if (args >= 2) + { // Print specified player's PBs for specified map and their current mode + char argMap[33], argPlayer[MAX_NAME_LENGTH]; + GetCmdArg(1, argMap, sizeof(argMap)); + GetCmdArg(2, argPlayer, sizeof(argPlayer)); + DB_PrintPBs_FindPlayerAndMap(client, argPlayer, argMap, 0, GOKZ_GetCoreOption(client, Option_Mode)); + } + return Plugin_Handled; +} + +public Action CommandBPB(int client, int args) +{ + if (IsSpammingCommands(client)) + { + return Plugin_Handled; + } + + if (args == 0) + { // Print their Bonus 1 PBs for current map and their current mode + DB_PrintPBs(client, GetSteamAccountID(client), GOKZ_DB_GetCurrentMapID(), 1, GOKZ_GetCoreOption(client, Option_Mode)); + if (gB_GOKZGlobal) + { + char steamid[32]; + GetClientAuthId(client, AuthId_Steam2, steamid, sizeof(steamid)); + GOKZ_GL_PrintRecords(client, "", 1, GOKZ_GetCoreOption(client, Option_Mode), steamid); + } + } + else if (args == 1) + { // Print their specified Bonus # PBs for current map and their current mode + char argBonus[4]; + GetCmdArg(1, argBonus, sizeof(argBonus)); + int bonus = StringToInt(argBonus); + if (GOKZ_IsValidCourse(bonus, true)) + { + DB_PrintPBs(client, GetSteamAccountID(client), GOKZ_DB_GetCurrentMapID(), bonus, GOKZ_GetCoreOption(client, Option_Mode)); + if (gB_GOKZGlobal) + { + char steamid[32]; + GetClientAuthId(client, AuthId_Steam2, steamid, sizeof(steamid)); + GOKZ_GL_PrintRecords(client, "", bonus, GOKZ_GetCoreOption(client, Option_Mode), steamid); + } + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Invalid Bonus Number", argBonus); + } + } + else if (args == 2) + { // Print their specified Bonus # PBs for specified map and their current mode + char argBonus[4], argMap[33]; + GetCmdArg(1, argBonus, sizeof(argBonus)); + GetCmdArg(2, argMap, sizeof(argMap)); + int bonus = StringToInt(argBonus); + if (GOKZ_IsValidCourse(bonus, true)) + { + DB_PrintPBs_FindMap(client, GetSteamAccountID(client), argMap, bonus, GOKZ_GetCoreOption(client, Option_Mode)); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Invalid Bonus Number", argBonus); + } + } + else if (args >= 3) + { // Print specified player's specified Bonus # PBs for specified map and their current mode + char argBonus[4], argMap[33], argPlayer[MAX_NAME_LENGTH]; + GetCmdArg(1, argBonus, sizeof(argBonus)); + GetCmdArg(2, argMap, sizeof(argMap)); + GetCmdArg(3, argPlayer, sizeof(argPlayer)); + int bonus = StringToInt(argBonus); + if (GOKZ_IsValidCourse(bonus, true)) + { + DB_PrintPBs_FindPlayerAndMap(client, argPlayer, argMap, bonus, GOKZ_GetCoreOption(client, Option_Mode)); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Invalid Bonus Number", argBonus); + } + } + return Plugin_Handled; +} + +public Action CommandWR(int client, int args) +{ + if (IsSpammingCommands(client)) + { + return Plugin_Handled; + } + + if (args == 0) + { // Print record times for current map and their current mode + DB_PrintRecords(client, GOKZ_DB_GetCurrentMapID(), 0, GOKZ_GetCoreOption(client, Option_Mode)); + if (gB_GOKZGlobal) + { + GOKZ_GL_PrintRecords(client, "", 0, GOKZ_GetCoreOption(client, Option_Mode)); + } + } + else if (args >= 1) + { // Print record times for specified map and their current mode + char argMap[33]; + GetCmdArg(1, argMap, sizeof(argMap)); + DB_PrintRecords_FindMap(client, argMap, 0, GOKZ_GetCoreOption(client, Option_Mode)); + } + return Plugin_Handled; +} + +public Action CommandBWR(int client, int args) +{ + if (IsSpammingCommands(client)) + { + return Plugin_Handled; + } + + if (args == 0) + { // Print Bonus 1 record times for current map and their current mode + DB_PrintRecords(client, GOKZ_DB_GetCurrentMapID(), 1, GOKZ_GetCoreOption(client, Option_Mode)); + if (gB_GOKZGlobal) + { + GOKZ_GL_PrintRecords(client, "", 1, GOKZ_GetCoreOption(client, Option_Mode)); + } + } + else if (args == 1) + { // Print specified Bonus # record times for current map and their current mode + char argBonus[4]; + GetCmdArg(1, argBonus, sizeof(argBonus)); + int bonus = StringToInt(argBonus); + if (GOKZ_IsValidCourse(bonus, true)) + { + DB_PrintRecords(client, GOKZ_DB_GetCurrentMapID(), bonus, GOKZ_GetCoreOption(client, Option_Mode)); + if (gB_GOKZGlobal) + { + GOKZ_GL_PrintRecords(client, "", bonus, GOKZ_GetCoreOption(client, Option_Mode)); + } + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Invalid Bonus Number", argBonus); + } + } + else if (args >= 2) + { // Print specified Bonus # record times for specified map and their current mode + char argBonus[4], argMap[33]; + GetCmdArg(1, argBonus, sizeof(argBonus)); + GetCmdArg(2, argMap, sizeof(argMap)); + int bonus = StringToInt(argBonus); + if (GOKZ_IsValidCourse(bonus, true)) + { + DB_PrintRecords_FindMap(client, argMap, bonus, GOKZ_GetCoreOption(client, Option_Mode)); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Invalid Bonus Number", argBonus); + } + } + return Plugin_Handled; +} + +public Action CommandAVG(int client, int args) +{ + if (IsSpammingCommands(client)) + { + return Plugin_Handled; + } + + if (args == 0) + { // Print average times for current map and their current mode + DB_PrintAverage(client, GOKZ_DB_GetCurrentMapID(), 0, GOKZ_GetCoreOption(client, Option_Mode)); + } + else if (args >= 1) + { // Print average times for specified map and their current mode + char argMap[33]; + GetCmdArg(1, argMap, sizeof(argMap)); + DB_PrintAverage_FindMap(client, argMap, 0, GOKZ_GetCoreOption(client, Option_Mode)); + } + return Plugin_Handled; +} + +public Action CommandBAVG(int client, int args) +{ + if (IsSpammingCommands(client)) + { + return Plugin_Handled; + } + + if (args == 0) + { // Print Bonus 1 average times for current map and their current mode + DB_PrintAverage(client, GOKZ_DB_GetCurrentMapID(), 1, GOKZ_GetCoreOption(client, Option_Mode)); + } + else if (args == 1) + { // Print specified Bonus # average times for current map and their current mode + char argBonus[4]; + GetCmdArg(1, argBonus, sizeof(argBonus)); + int bonus = StringToInt(argBonus); + if (GOKZ_IsValidCourse(bonus, true)) + { + DB_PrintAverage(client, GOKZ_DB_GetCurrentMapID(), bonus, GOKZ_GetCoreOption(client, Option_Mode)); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Invalid Bonus Number", argBonus); + } + } + else if (args >= 2) + { // Print specified Bonus # average times for specified map and their current mode + char argBonus[4], argMap[33]; + GetCmdArg(1, argBonus, sizeof(argBonus)); + GetCmdArg(2, argMap, sizeof(argMap)); + int bonus = StringToInt(argBonus); + if (GOKZ_IsValidCourse(bonus, true)) + { + DB_PrintAverage_FindMap(client, argMap, bonus, GOKZ_GetCoreOption(client, Option_Mode)); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Invalid Bonus Number", argBonus); + } + } + return Plugin_Handled; +} + +public Action CommandPC(int client, int args) +{ + if (IsSpammingCommands(client)) + { + return Plugin_Handled; + } + + if (args < 1) + { + DB_GetCompletion(client, GetSteamAccountID(client), GOKZ_GetCoreOption(client, Option_Mode), true); + } + else if (args >= 1) + { // Print record times for specified map and their current mode + char argPlayer[MAX_NAME_LENGTH]; + GetCmdArg(1, argPlayer, sizeof(argPlayer)); + DB_GetCompletion_FindPlayer(client, argPlayer, GOKZ_GetCoreOption(client, Option_Mode)); + } + return Plugin_Handled; +} + +public Action CommandRecentRecords(int client, int args) +{ + if (IsSpammingCommands(client)) + { + return Plugin_Handled; + } + + DisplayRecentRecordsModeMenu(client); + return Plugin_Handled; +} + +public Action CommandUpdateMapPool(int client, int args) +{ + DB_UpdateRankedMapPool(client); + return Plugin_Handled; +} + +public Action CommandLJPB(int client, int args) +{ + DisplayJumpstatRecordCommand(client, args, JumpType_LongJump); + return Plugin_Handled; +} + +public Action CommandBHPB(int client, int args) +{ + DisplayJumpstatRecordCommand(client, args, JumpType_Bhop); + return Plugin_Handled; +} + +public Action CommandLBHPB(int client, int args) +{ + DisplayJumpstatRecordCommand(client, args, JumpType_LowpreBhop); + return Plugin_Handled; +} + +public Action CommandMBHPB(int client, int args) +{ + DisplayJumpstatRecordCommand(client, args, JumpType_MultiBhop); + return Plugin_Handled; +} + +public Action CommandWJPB(int client, int args) +{ + DisplayJumpstatRecordCommand(client, args, JumpType_WeirdJump); + return Plugin_Handled; +} + +public Action CommandLWJPB(int client, int args) +{ + DisplayJumpstatRecordCommand(client, args, JumpType_LowpreWeirdJump); + return Plugin_Handled; +} + +public Action CommandLAJPB(int client, int args) +{ + DisplayJumpstatRecordCommand(client, args, JumpType_LadderJump); + return Plugin_Handled; +} + +public Action CommandLAHPB(int client, int args) +{ + DisplayJumpstatRecordCommand(client, args, JumpType_Ladderhop); + return Plugin_Handled; +} + +public Action CommandJBPB(int client, int args) +{ + DisplayJumpstatRecordCommand(client, args, JumpType_Jumpbug); + return Plugin_Handled; +} + +public Action CommandJS(int client, int args) +{ + if (IsSpammingCommands(client)) + { + return Plugin_Handled; + } + + if (args < 1) + { + DB_OpenJumpStatsModeMenu(client, GetSteamAccountID(client)); + } + else if (args >= 1) + { + char argPlayer[MAX_NAME_LENGTH]; + GetCmdArg(1, argPlayer, sizeof(argPlayer)); + DB_OpenJumpStatsModeMenu_FindPlayer(client, argPlayer); + } + return Plugin_Handled; +} + +public Action CommandJSTop(int client, int args) +{ + DisplayJumpTopModeMenu(client); + return Plugin_Handled; +} + +void DisplayJumpstatRecordCommand(int client, int args, int jumpType) +{ + if (args >= 1) + { + char argJumper[33]; + GetCmdArg(1, argJumper, sizeof(argJumper)); + DisplayJumpstatRecord(client, jumpType, argJumper); + } + else + { + DisplayJumpstatRecord(client, jumpType); + } +} + + + +// =====[ PRIVATE ]===== + +bool IsSpammingCommands(int client, bool printMessage = true) +{ + float currentTime = GetEngineTime(); + float timeSinceLastCommand = currentTime - lastCommandTime[client]; + if (timeSinceLastCommand < LR_COMMAND_COOLDOWN) + { + if (printMessage) + { + GOKZ_PrintToChat(client, true, "%t", "Please Wait Before Using Command", LR_COMMAND_COOLDOWN - timeSinceLastCommand + 0.1); + } + return true; + } + + // Not spamming commands - all good! + lastCommandTime[client] = currentTime; + return false; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-localranks/db/cache_pbs.sp b/sourcemod/scripting/gokz-localranks/db/cache_pbs.sp new file mode 100644 index 0000000..12c3ed2 --- /dev/null +++ b/sourcemod/scripting/gokz-localranks/db/cache_pbs.sp @@ -0,0 +1,62 @@ +/* + Caches the player's personal best times on the map. +*/ + + + +void DB_CachePBs(int client, int steamID) +{ + char query[1024]; + + Transaction txn = SQL_CreateTransaction(); + + // Reset PB exists array + for (int course = 0; course < GOKZ_MAX_COURSES; course++) + { + for (int mode = 0; mode < MODE_COUNT; mode++) + { + for (int timeType = 0; timeType < TIMETYPE_COUNT; timeType++) + { + gB_PBExistsCache[client][course][mode][timeType] = false; + } + } + } + + int mapID = GOKZ_DB_GetCurrentMapID(); + + // Get Map PBs + FormatEx(query, sizeof(query), sql_getpbs, steamID, mapID); + txn.AddQuery(query); + // Get PRO PBs + FormatEx(query, sizeof(query), sql_getpbspro, steamID, mapID); + txn.AddQuery(query); + + SQL_ExecuteTransaction(gH_DB, txn, DB_TxnSuccess_CachePBs, DB_TxnFailure_Generic, GetClientUserId(client), DBPrio_High); +} + +public void DB_TxnSuccess_CachePBs(Handle db, int userID, int numQueries, Handle[] results, any[] queryData) +{ + int client = GetClientOfUserId(userID); + if (client < 1 || client > MaxClients || !IsClientAuthorized(client) || IsFakeClient(client)) + { + return; + } + + int course, mode; + + while (SQL_FetchRow(results[0])) + { + course = SQL_FetchInt(results[0], 1); + mode = SQL_FetchInt(results[0], 2); + gB_PBExistsCache[client][course][mode][TimeType_Nub] = true; + gF_PBTimesCache[client][course][mode][TimeType_Nub] = GOKZ_DB_TimeIntToFloat(SQL_FetchInt(results[0], 0)); + } + + while (SQL_FetchRow(results[1])) + { + course = SQL_FetchInt(results[1], 1); + mode = SQL_FetchInt(results[1], 2); + gB_PBExistsCache[client][course][mode][TimeType_Pro] = true; + gF_PBTimesCache[client][course][mode][TimeType_Pro] = GOKZ_DB_TimeIntToFloat(SQL_FetchInt(results[1], 0)); + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-localranks/db/cache_records.sp b/sourcemod/scripting/gokz-localranks/db/cache_records.sp new file mode 100644 index 0000000..611b13c --- /dev/null +++ b/sourcemod/scripting/gokz-localranks/db/cache_records.sp @@ -0,0 +1,54 @@ +/* + Caches the record times on the map. +*/ + + + +void DB_CacheRecords(int mapID) +{ + char query[1024]; + + Transaction txn = SQL_CreateTransaction(); + + // Reset record exists array + for (int course = 0; course < GOKZ_MAX_COURSES; course++) + { + for (int mode = 0; mode < MODE_COUNT; mode++) + { + for (int timeType = 0; timeType < TIMETYPE_COUNT; timeType++) + { + gB_RecordExistsCache[course][mode][timeType] = false; + } + } + } + + // Get Map WRs + FormatEx(query, sizeof(query), sql_getwrs, mapID); + txn.AddQuery(query); + // Get PRO WRs + FormatEx(query, sizeof(query), sql_getwrspro, mapID); + txn.AddQuery(query); + + SQL_ExecuteTransaction(gH_DB, txn, DB_TxnSuccess_CacheRecords, DB_TxnFailure_Generic, _, DBPrio_High); +} + +public void DB_TxnSuccess_CacheRecords(Handle db, any data, int numQueries, Handle[] results, any[] queryData) +{ + int course, mode; + + while (SQL_FetchRow(results[0])) + { + course = SQL_FetchInt(results[0], 1); + mode = SQL_FetchInt(results[0], 2); + gB_RecordExistsCache[course][mode][TimeType_Nub] = true; + gF_RecordTimesCache[course][mode][TimeType_Nub] = GOKZ_DB_TimeIntToFloat(SQL_FetchInt(results[0], 0)); + } + + while (SQL_FetchRow(results[1])) + { + course = SQL_FetchInt(results[1], 1); + mode = SQL_FetchInt(results[1], 2); + gB_RecordExistsCache[course][mode][TimeType_Pro] = true; + gF_RecordTimesCache[course][mode][TimeType_Pro] = GOKZ_DB_TimeIntToFloat(SQL_FetchInt(results[1], 0)); + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-localranks/db/create_tables.sp b/sourcemod/scripting/gokz-localranks/db/create_tables.sp new file mode 100644 index 0000000..a15f67c --- /dev/null +++ b/sourcemod/scripting/gokz-localranks/db/create_tables.sp @@ -0,0 +1,27 @@ +/* + Table creation and alteration. +*/ + + + +void DB_CreateTables() +{ + Transaction txn = SQL_CreateTransaction(); + + // Create/alter database tables + switch (g_DBType) + { + case DatabaseType_SQLite: + { + txn.AddQuery(sqlite_maps_alter1); + } + case DatabaseType_MySQL: + { + txn.AddQuery(mysql_maps_alter1); + } + } + + // No error logs for this transaction as it will always throw an error + // if the column already exists, which is more annoying than helpful. + SQL_ExecuteTransaction(gH_DB, txn, _, _, _, DBPrio_High); +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-localranks/db/display_js.sp b/sourcemod/scripting/gokz-localranks/db/display_js.sp new file mode 100644 index 0000000..779148f --- /dev/null +++ b/sourcemod/scripting/gokz-localranks/db/display_js.sp @@ -0,0 +1,325 @@ +/* + Displays player's best jumpstats in a menu. +*/ + +static int jumpStatsTargetSteamID[MAXPLAYERS + 1]; +static char jumpStatsTargetAlias[MAXPLAYERS + 1][MAX_NAME_LENGTH]; +static int jumpStatsMode[MAXPLAYERS + 1]; + + + +// =====[ JUMPSTATS MODE ]===== + +void DB_OpenJumpStatsModeMenu(int client, int targetSteamID) +{ + char query[1024]; + + DataPack data = new DataPack(); + data.WriteCell(GetClientUserId(client)); + data.WriteCell(targetSteamID); + + Transaction txn = SQL_CreateTransaction(); + + // Retrieve name of target + FormatEx(query, sizeof(query), sql_players_getalias, targetSteamID); + txn.AddQuery(query); + + SQL_ExecuteTransaction(gH_DB, txn, DB_TxnSuccess_OpenJumpStatsModeMenu, DB_TxnFailure_Generic_DataPack, data, DBPrio_Low); +} + +public void DB_TxnSuccess_OpenJumpStatsModeMenu(Handle db, DataPack data, int numQueries, Handle[] results, any[] queryData) +{ + data.Reset(); + int client = GetClientOfUserId(data.ReadCell()); + int targetSteamID = data.ReadCell(); + delete data; + + if (!IsValidClient(client)) + { + return; + } + + // Get name of target + if (!SQL_FetchRow(results[0])) + { + return; + } + SQL_FetchString(results[0], 0, jumpStatsTargetAlias[client], sizeof(jumpStatsTargetAlias[])); + + jumpStatsTargetSteamID[client] = targetSteamID; + DisplayJumpStatsModeMenu(client); +} + +void DB_OpenJumpStatsModeMenu_FindPlayer(int client, const char[] target) +{ + DataPack data = new DataPack(); + data.WriteCell(GetClientUserId(client)); + data.WriteString(target); + + DB_FindPlayer(target, DB_TxnSuccess_OpenJumpStatsModeMenu_FindPlayer, data, DBPrio_Low); +} + +public void DB_TxnSuccess_OpenJumpStatsModeMenu_FindPlayer(Handle db, DataPack data, int numQueries, Handle[] results, any[] queryData) +{ + data.Reset(); + int client = GetClientOfUserId(data.ReadCell()); + char playerSearch[33]; + data.ReadString(playerSearch, sizeof(playerSearch)); + delete data; + + if (!IsValidClient(client)) + { + return; + } + + else if (SQL_GetRowCount(results[0]) == 0) + { + GOKZ_PrintToChat(client, true, "%t", "Player Not Found", playerSearch); + return; + } + else if (SQL_FetchRow(results[0])) + { + DB_OpenJumpStatsModeMenu(client, SQL_FetchInt(results[0], 0)); + } +} + + + +// =====[ MENUS ]===== + +static void DisplayJumpStatsModeMenu(int client) +{ + Menu menu = new Menu(MenuHandler_JumpStatsMode); + menu.SetTitle("%T", "Jump Stats Mode Menu - Title", client, jumpStatsTargetAlias[client]); + GOKZ_MenuAddModeItems(client, menu, false); + menu.Display(client, MENU_TIME_FOREVER); +} + +static void DisplayJumpStatsBlockTypeMenu(int client, int mode) +{ + jumpStatsMode[client] = mode; + + Menu menu = new Menu(MenuHandler_JumpStatsBlockType); + menu.SetTitle("%T", "Jump Stats Block Type Menu - Title", client, jumpStatsTargetAlias[client], gC_ModeNames[jumpStatsMode[client]]); + JumpStatsBlockTypeMenuAddItems(client, menu); + menu.Display(client, MENU_TIME_FOREVER); +} + +static void JumpStatsBlockTypeMenuAddItems(int client, Menu menu) +{ + char str[64]; + FormatEx(str, sizeof(str), "%T", "Jump Records", client); + menu.AddItem("jump", str); + FormatEx(str, sizeof(str), "%T %T", "Block", client, "Jump Records", client); + menu.AddItem("blockjump", str); +} + + + +// =====[ JUMPSTATS ]===== + +void DB_OpenJumpStats(int client, int targetSteamID, int mode, int blockType) +{ + char query[1024]; + Transaction txn = SQL_CreateTransaction(); + + // Get alias + FormatEx(query, sizeof(query), sql_players_getalias, targetSteamID); + txn.AddQuery(query); + + // Get jumpstat pbs + if (blockType == 0) + { + FormatEx(query, sizeof(query), sql_jumpstats_getpbs, targetSteamID, mode); + } + else + { + FormatEx(query, sizeof(query), sql_jumpstats_getblockpbs, targetSteamID, mode); + } + txn.AddQuery(query); + + DataPack datapack = new DataPack(); + datapack.WriteCell(GetClientUserId(client)); + datapack.WriteCell(targetSteamID); + datapack.WriteCell(mode); + datapack.WriteCell(blockType); + + SQL_ExecuteTransaction(gH_DB, txn, DB_TxnSuccess_OpenJumpStats, DB_TxnFailure_Generic_DataPack, datapack, DBPrio_Low); +} + +public void DB_TxnSuccess_OpenJumpStats(Handle db, DataPack datapack, int numQueries, Handle[] results, any[] queryData) +{ + datapack.Reset(); + int client = GetClientOfUserId(datapack.ReadCell()); + int targetSteamID = datapack.ReadCell(); + int mode = datapack.ReadCell(); + int blockType = datapack.ReadCell(); + delete datapack; + + if (!IsValidClient(client)) + { + return; + } + + // Get target name + if (!SQL_FetchRow(results[0])) + { + return; + } + char alias[MAX_NAME_LENGTH]; + SQL_FetchString(results[0], 0, alias, sizeof(alias)); + + if (SQL_GetRowCount(results[1]) == 0) + { + if (blockType == 0) + { + GOKZ_PrintToChat(client, true, "%T", "Jump Stats Menu - No Jump Stats", client, alias); + } + else + { + GOKZ_PrintToChat(client, true, "%T", "Jump Stats Menu - No Block Jump Stats", client, alias); + } + + DisplayJumpStatsBlockTypeMenu(client, mode); + return; + } + + Menu menu = new Menu(MenuHandler_JumpStatsSubmenu); + if (blockType == 0) + { + menu.SetTitle("%T", "Jump Stats Submenu - Title (Jump)", client, alias, gC_ModeNames[mode]); + } + else + { + menu.SetTitle("%T", "Jump Stats Submenu - Title (Block Jump)", client, alias, gC_ModeNames[mode]); + } + + char buffer[128], admin[64]; + bool clientIsAdmin = CheckCommandAccess(client, "sm_deletejump", ADMFLAG_ROOT, false); + + if (blockType == 0) + { + FormatEx(buffer, sizeof(buffer), "%T", "Jump Stats - Jump Console Header", + client, gC_ModeNames[mode], alias, targetSteamID & 1, targetSteamID >> 1); + PrintToConsole(client, "%s", buffer); + int titleLength = strlen(buffer); + strcopy(buffer, sizeof(buffer), "----------------------------------------------------------------"); + buffer[titleLength] = '\0'; + PrintToConsole(client, "%s", buffer); + + while (SQL_FetchRow(results[1])) + { + int jumpid = SQL_FetchInt(results[1], JumpstatDB_PBMenu_JumpID); + int jumpType = SQL_FetchInt(results[1], JumpstatDB_PBMenu_JumpType); + float distance = SQL_FetchFloat(results[1], JumpstatDB_PBMenu_Distance) / GOKZ_DB_JS_DISTANCE_PRECISION; + int strafes = SQL_FetchInt(results[1], JumpstatDB_PBMenu_Strafes); + float sync = SQL_FetchFloat(results[1], JumpstatDB_PBMenu_Sync) / GOKZ_DB_JS_SYNC_PRECISION; + float pre = SQL_FetchFloat(results[1], JumpstatDB_PBMenu_Pre) / GOKZ_DB_JS_PRE_PRECISION; + float max = SQL_FetchFloat(results[1], JumpstatDB_PBMenu_Max) / GOKZ_DB_JS_MAX_PRECISION; + float airtime = SQL_FetchFloat(results[1], JumpstatDB_PBMenu_Air) / GOKZ_DB_JS_AIRTIME_PRECISION; + + FormatEx(buffer, sizeof(buffer), "%0.4f %s", distance, gC_JumpTypes[jumpType]); + menu.AddItem("", buffer, ITEMDRAW_DISABLED); + + FormatEx(buffer, sizeof(buffer), "%8s", gC_JumpTypesShort[jumpType]); + buffer[3] = '\0'; + + if (clientIsAdmin) + { + FormatEx(admin, sizeof(admin), "<id: %d>", jumpid); + } + + PrintToConsole(client, "%s %0.4f [%d %t | %.2f%% %t | %.2f %t | %.2f %t | %.4f %t] %s", + buffer, distance, strafes, "Strafes", sync, "Sync", pre, "Pre", max, "Max", airtime, "Air", admin); + } + } + else + { + FormatEx(buffer, sizeof(buffer), "%T", "Jump Stats - Block Jump Console Header", + client, gC_ModeNames[mode], alias, targetSteamID & 1, targetSteamID >> 1); + PrintToConsole(client, "%s", buffer); + int titleLength = strlen(buffer); + strcopy(buffer, sizeof(buffer), "----------------------------------------------------------------"); + buffer[titleLength] = '\0'; + PrintToConsole(client, "%s", buffer); + + while (SQL_FetchRow(results[1])) + { + int jumpid = SQL_FetchInt(results[1], JumpstatDB_BlockPBMenu_JumpID); + int jumpType = SQL_FetchInt(results[1], JumpstatDB_BlockPBMenu_JumpType); + int block = SQL_FetchInt(results[1], JumpstatDB_BlockPBMenu_Block); + float distance = SQL_FetchFloat(results[1], JumpstatDB_BlockPBMenu_Distance) / GOKZ_DB_JS_DISTANCE_PRECISION; + int strafes = SQL_FetchInt(results[1], JumpstatDB_BlockPBMenu_Strafes); + float sync = SQL_FetchFloat(results[1], JumpstatDB_BlockPBMenu_Sync) / GOKZ_DB_JS_SYNC_PRECISION; + float pre = SQL_FetchFloat(results[1], JumpstatDB_BlockPBMenu_Pre) / GOKZ_DB_JS_PRE_PRECISION; + float max = SQL_FetchFloat(results[1], JumpstatDB_BlockPBMenu_Max) / GOKZ_DB_JS_MAX_PRECISION; + float airtime = SQL_FetchFloat(results[1], JumpstatDB_BlockPBMenu_Air) / GOKZ_DB_JS_AIRTIME_PRECISION; + + FormatEx(buffer, sizeof(buffer), "%d %T (%0.4f) %s", block, "Block", client, distance, gC_JumpTypes[jumpType]); + menu.AddItem("", buffer, ITEMDRAW_DISABLED); + + FormatEx(buffer, sizeof(buffer), "%8s", gC_JumpTypesShort[jumpType]); + buffer[3] = '\0'; + + if (clientIsAdmin) + { + FormatEx(admin, sizeof(admin), "<id: %d>", jumpid); + } + + PrintToConsole(client, "%s %d %t (%0.4f) [%d %t | %.2f%% %t | %.2f %t | %.2f %t | %.4f %t] %s", + buffer, block, "Block", distance, strafes, "Strafes", sync, "Sync", pre, "Pre", max, "Max", airtime, "Air", admin); + } + } + + PrintToConsole(client, ""); + menu.Display(client, MENU_TIME_FOREVER); +} + + + +// =====[ MENU HANDLERS ]===== + +public int MenuHandler_JumpStatsMode(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + // param1 = client, param2 = mode + DisplayJumpStatsBlockTypeMenu(param1, param2); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + +public int MenuHandler_JumpStatsBlockType(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + // param1 = client, param2 = blockType + DB_OpenJumpStats(param1, jumpStatsTargetSteamID[param1], jumpStatsMode[param1], param2); + } + else if (action == MenuAction_Cancel && param2 == MenuCancel_Exit) + { + DisplayJumpStatsModeMenu(param1); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + +public int MenuHandler_JumpStatsSubmenu(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Cancel && param2 == MenuCancel_Exit) + { + DisplayJumpStatsBlockTypeMenu(param1, jumpStatsMode[param1]); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-localranks/db/get_completion.sp b/sourcemod/scripting/gokz-localranks/db/get_completion.sp new file mode 100644 index 0000000..fbc76e7 --- /dev/null +++ b/sourcemod/scripting/gokz-localranks/db/get_completion.sp @@ -0,0 +1,155 @@ +/* + Gets the number and percentage of maps completed. +*/ + + + +void DB_GetCompletion(int client, int targetSteamID, int mode, bool print) +{ + char query[1024]; + + DataPack data = new DataPack(); + data.WriteCell(GetClientUserId(client)); + data.WriteCell(targetSteamID); + data.WriteCell(mode); + data.WriteCell(print); + + Transaction txn = SQL_CreateTransaction(); + + // Retrieve Alias of SteamID + FormatEx(query, sizeof(query), sql_players_getalias, targetSteamID); + txn.AddQuery(query); + // Get total number of ranked main courses + txn.AddQuery(sql_getcount_maincourses); + // Get number of main course completions + FormatEx(query, sizeof(query), sql_getcount_maincoursescompleted, targetSteamID, mode); + txn.AddQuery(query); + // Get number of main course completions (PRO) + FormatEx(query, sizeof(query), sql_getcount_maincoursescompletedpro, targetSteamID, mode); + txn.AddQuery(query); + + // Get total number of ranked bonuses + txn.AddQuery(sql_getcount_bonuses); + // Get number of bonus completions + FormatEx(query, sizeof(query), sql_getcount_bonusescompleted, targetSteamID, mode); + txn.AddQuery(query); + // Get number of bonus completions (PRO) + FormatEx(query, sizeof(query), sql_getcount_bonusescompletedpro, targetSteamID, mode); + txn.AddQuery(query); + + SQL_ExecuteTransaction(gH_DB, txn, DB_TxnSuccess_GetCompletion, DB_TxnFailure_Generic_DataPack, data, DBPrio_Low); +} + +public void DB_TxnSuccess_GetCompletion(Handle db, DataPack data, int numQueries, Handle[] results, any[] queryData) +{ + data.Reset(); + int client = GetClientOfUserId(data.ReadCell()); + int targetSteamID = data.ReadCell(); + int mode = data.ReadCell(); + bool print = data.ReadCell(); + delete data; + + if (!IsValidClient(client)) + { + return; + } + + char playerName[MAX_NAME_LENGTH]; + int totalMainCourses, completions, completionsPro; + int totalBonuses, bonusCompletions, bonusCompletionsPro; + + // Get Player Name from results + if (SQL_FetchRow(results[0])) + { + SQL_FetchString(results[0], 0, playerName, sizeof(playerName)); + } + + // Get total number of main courses + if (SQL_FetchRow(results[1])) + { + totalMainCourses = SQL_FetchInt(results[1], 0); + } + // Get completed main courses + if (SQL_FetchRow(results[2])) + { + completions = SQL_FetchInt(results[2], 0); + } + // Get completed main courses (PRO) + if (SQL_FetchRow(results[3])) + { + completionsPro = SQL_FetchInt(results[3], 0); + } + + // Get total number of bonuses + if (SQL_FetchRow(results[4])) + { + totalBonuses = SQL_FetchInt(results[4], 0); + } + // Get completed bonuses + if (SQL_FetchRow(results[5])) { + bonusCompletions = SQL_FetchInt(results[5], 0); + } + // Get completed bonuses (PRO) + if (SQL_FetchRow(results[6])) + { + bonusCompletionsPro = SQL_FetchInt(results[6], 0); + } + + // Print completion message to chat if specified + if (print) + { + if (totalMainCourses + totalBonuses == 0) + { + GOKZ_PrintToChat(client, true, "%t", "No Ranked Maps"); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Map Completion", + playerName, + completions, totalMainCourses, completionsPro, totalMainCourses, + bonusCompletions, totalBonuses, bonusCompletionsPro, totalBonuses, + gC_ModeNamesShort[mode]); + } + } + + // Set scoreboard MVP stars to percentage PRO completion of server's default mode + if (totalMainCourses + totalBonuses != 0 && targetSteamID == GetSteamAccountID(client) && mode == GOKZ_GetDefaultMode()) + { + CS_SetMVPCount(client, RoundToFloor(float(completionsPro + bonusCompletionsPro) / float(totalMainCourses + totalBonuses) * 100.0)); + } +} + +void DB_GetCompletion_FindPlayer(int client, const char[] target, int mode) +{ + DataPack data = new DataPack(); + data.WriteCell(GetClientUserId(client)); + data.WriteString(target); + data.WriteCell(mode); + + DB_FindPlayer(target, DB_TxnSuccess_GetCompletion_FindPlayer, data, DBPrio_Low); +} + +public void DB_TxnSuccess_GetCompletion_FindPlayer(Handle db, DataPack data, int numQueries, Handle[] results, any[] queryData) +{ + data.Reset(); + int client = GetClientOfUserId(data.ReadCell()); + char playerSearch[33]; + data.ReadString(playerSearch, sizeof(playerSearch)); + int mode = data.ReadCell(); + delete data; + + if (!IsValidClient(client)) + { + return; + } + + else if (SQL_GetRowCount(results[0]) == 0) + { + GOKZ_PrintToChat(client, true, "%t", "Player Not Found", playerSearch); + return; + } + else if (SQL_FetchRow(results[0])) + { + DB_GetCompletion(client, SQL_FetchInt(results[0], 0), mode, true); + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-localranks/db/helpers.sp b/sourcemod/scripting/gokz-localranks/db/helpers.sp new file mode 100644 index 0000000..670a420 --- /dev/null +++ b/sourcemod/scripting/gokz-localranks/db/helpers.sp @@ -0,0 +1,91 @@ +/* + Database helper functions and callbacks. +*/ + + + +/* Error report callback for failed transactions */ +public void DB_TxnFailure_Generic(Handle db, any data, int numQueries, const char[] error, int failIndex, any[] queryData) +{ + LogError("Database transaction error: %s", error); +} + +/* Error report callback for failed transactions which deletes the DataPack */ +public void DB_TxnFailure_Generic_DataPack(Handle db, DataPack data, int numQueries, const char[] error, int failIndex, any[] queryData) +{ + delete data; + LogError("Database transaction error: %s", error); +} + +/* Used to search the database for a player name and return their PlayerID and alias + + For SQLTxnSuccess onSuccess: + results[0] - 0:PlayerID, 1:Alias +*/ +void DB_FindPlayer(const char[] playerSearch, SQLTxnSuccess onSuccess, any data = 0, DBPriority priority = DBPrio_Normal) +{ + char query[1024], playerEscaped[MAX_NAME_LENGTH * 2 + 1]; + SQL_EscapeString(gH_DB, playerSearch, playerEscaped, sizeof(playerEscaped)); + + String_ToLower(playerEscaped, playerEscaped, sizeof(playerEscaped)); + + Transaction txn = SQL_CreateTransaction(); + + // Look for player name and retrieve their PlayerID + FormatEx(query, sizeof(query), sql_players_searchbyalias, playerEscaped, playerEscaped); + txn.AddQuery(query); + + SQL_ExecuteTransaction(gH_DB, txn, onSuccess, DB_TxnFailure_Generic, data, priority); +} + +/* Used to search the database for a map name and return its MapID and name + + For SQLTxnSuccess onSuccess: + results[0] - 0:MapID, 1:Name +*/ +void DB_FindMap(const char[] mapSearch, SQLTxnSuccess onSuccess, any data = 0, DBPriority priority = DBPrio_Normal) +{ + char query[1024], mapEscaped[129]; + SQL_EscapeString(gH_DB, mapSearch, mapEscaped, sizeof(mapEscaped)); + + Transaction txn = SQL_CreateTransaction(); + + // Look for map name and retrieve it's MapID + FormatEx(query, sizeof(query), sql_maps_searchbyname, mapEscaped, mapEscaped); + txn.AddQuery(query); + + SQL_ExecuteTransaction(gH_DB, txn, onSuccess, DB_TxnFailure_Generic, data, priority); +} + +/* Used to search the database for a player name and return their PlayerID and alias, + and search the database for a map name and return its MapID and name + + For SQLTxnSuccess onSuccess: + results[0] - 0:PlayerID, 1:Alias + results[1] - 0:MapID, 1:Name +*/ +void DB_FindPlayerAndMap(const char[] playerSearch, const char[] mapSearch, SQLTxnSuccess onSuccess, any data = 0, DBPriority priority = DBPrio_Normal) +{ + char query[1024], mapEscaped[129], playerEscaped[MAX_NAME_LENGTH * 2 + 1]; + SQL_EscapeString(gH_DB, playerSearch, playerEscaped, sizeof(playerEscaped)); + SQL_EscapeString(gH_DB, mapSearch, mapEscaped, sizeof(mapEscaped)); + + String_ToLower(playerEscaped, playerEscaped, sizeof(playerEscaped)); + + Transaction txn = SQL_CreateTransaction(); + + // Look for player name and retrieve their PlayerID + FormatEx(query, sizeof(query), sql_players_searchbyalias, playerEscaped, playerEscaped); + txn.AddQuery(query); + // Look for map name and retrieve it's MapID + FormatEx(query, sizeof(query), sql_maps_searchbyname, mapEscaped, mapEscaped); + txn.AddQuery(query); + + SQL_ExecuteTransaction(gH_DB, txn, onSuccess, DB_TxnFailure_Generic, data, priority); +} + +// Used to convert the Account ID to the SteamID we can use for a Global API query +int GetSteam2FromAccountId(char[] result, int maxlen, int account_id) +{ + return Format(result, maxlen, "STEAM_1:%d:%d", view_as<bool>(account_id % 2), account_id / 2); +} diff --git a/sourcemod/scripting/gokz-localranks/db/js_top.sp b/sourcemod/scripting/gokz-localranks/db/js_top.sp new file mode 100644 index 0000000..a336a90 --- /dev/null +++ b/sourcemod/scripting/gokz-localranks/db/js_top.sp @@ -0,0 +1,286 @@ + +static int jumpTopMode[MAXPLAYERS + 1]; +static int jumpTopType[MAXPLAYERS + 1]; +static int blockNums[MAXPLAYERS + 1][JS_TOP_RECORD_COUNT]; +static int jumpInfo[MAXPLAYERS + 1][JS_TOP_RECORD_COUNT][3]; + + + +void DB_OpenJumpTop(int client, int mode, int jumpType, int blockType) +{ + char query[1024]; + + Transaction txn = SQL_CreateTransaction(); + + FormatEx(query, sizeof(query), sql_jumpstats_gettop, jumpType, mode, blockType, jumpType, mode, blockType, JS_TOP_RECORD_COUNT); + txn.AddQuery(query); + + DataPack data = new DataPack(); + data.WriteCell(GetClientUserId(client)); + data.WriteCell(mode); + data.WriteCell(jumpType); + data.WriteCell(blockType); + + SQL_ExecuteTransaction(gH_DB, txn, DB_TxnSuccess_GetJumpTop, DB_TxnFailure_Generic_DataPack, data, DBPrio_Low); +} + +void DB_TxnSuccess_GetJumpTop(Handle db, DataPack data, int numQueries, Handle[] results, any[] queryData) +{ + data.Reset(); + int client = GetClientOfUserId(data.ReadCell()); + int mode = data.ReadCell(); + int type = data.ReadCell(); + int blockType = data.ReadCell(); + delete data; + + if (!IsValidClient(client)) + { + return; + } + + jumpTopMode[client] = mode; + jumpTopType[client] = type; + + int rows = SQL_GetRowCount(results[0]); + if (rows == 0) + { + GOKZ_PrintToChat(client, true, "%t", "No Jumpstats Found"); + DisplayJumpTopBlockTypeMenu(client, mode, type); + return; + } + + char display[128], alias[33], title[65], admin[65]; + int jumpid, steamid, block, strafes; + float distance, sync, pre, max, airtime; + + bool clientIsAdmin = CheckCommandAccess(client, "sm_deletejump", ADMFLAG_ROOT, false); + + Menu menu = new Menu(MenuHandler_JumpTopList); + menu.Pagination = 5; + + if (blockType == 0) + { + menu.SetTitle("%T", "Jump Top Submenu - Title (Jump)", client, gC_ModeNames[mode], gC_JumpTypes[type]); + + FormatEx(title, sizeof(title), "%s %s %T", gC_ModeNames[mode], gC_JumpTypes[type], "Top", client); + strcopy(display, sizeof(display), "----------------------------------------------------------------"); + display[strlen(title)] = '\0'; + + PrintToConsole(client, title); + PrintToConsole(client, display); + + for (int i = 0; i < rows; i++) + { + SQL_FetchRow(results[0]); + jumpid = SQL_FetchInt(results[0], JumpstatDB_Top20_JumpID); + steamid = SQL_FetchInt(results[0], JumpstatDB_Top20_SteamID); + SQL_FetchString(results[0], JumpstatDB_Top20_Alias, alias, sizeof(alias)); + distance = float(SQL_FetchInt(results[0], JumpstatDB_Top20_Distance)) / GOKZ_DB_JS_DISTANCE_PRECISION; + strafes = SQL_FetchInt(results[0], JumpstatDB_Top20_Strafes); + sync = float(SQL_FetchInt(results[0], JumpstatDB_Top20_Sync)) / GOKZ_DB_JS_SYNC_PRECISION; + pre = float(SQL_FetchInt(results[0], JumpstatDB_Top20_Pre)) / GOKZ_DB_JS_PRE_PRECISION; + max = float(SQL_FetchInt(results[0], JumpstatDB_Top20_Max)) / GOKZ_DB_JS_MAX_PRECISION; + airtime = float(SQL_FetchInt(results[0], JumpstatDB_Top20_Air)) / GOKZ_DB_JS_AIRTIME_PRECISION; + + FormatEx(display, sizeof(display), "#%-2d %.4f %s", i + 1, distance, alias); + + menu.AddItem(IntToStringEx(i), display); + + if (clientIsAdmin) + { + FormatEx(admin, sizeof(admin), "<id: %d>", jumpid); + } + + PrintToConsole(client, "#%-2d %.4f %s <STEAM_1:%d:%d> [%d %t | %.2f%% %t | %.2f %t | %.2f %t | %.4f %t] %s", + i + 1, distance, alias, steamid & 1, steamid >> 1, + strafes, "Strafes", sync, "Sync", pre, "Pre", max, "Max", airtime, "Air", + admin); + + jumpInfo[client][i][0] = steamid; + jumpInfo[client][i][1] = type; + jumpInfo[client][i][2] = mode; + blockNums[client][i] = 0; + } + } + else + { + menu.SetTitle("%T", "Jump Top Submenu - Title (Block Jump)", client, gC_ModeNames[mode], gC_JumpTypes[type]); + + FormatEx(title, sizeof(title), "%s %T %s %T", gC_ModeNames[mode], "Block", client, gC_JumpTypes[type], "Top", client); + strcopy(display, sizeof(display), "----------------------------------------------------------------"); + display[strlen(title)] = '\0'; + + PrintToConsole(client, title); + PrintToConsole(client, display); + + for (int i = 0; i < rows; i++) + { + SQL_FetchRow(results[0]); + jumpid = SQL_FetchInt(results[0], JumpstatDB_Top20_JumpID); + steamid = SQL_FetchInt(results[0], JumpstatDB_Top20_SteamID); + SQL_FetchString(results[0], JumpstatDB_Top20_Alias, alias, sizeof(alias)); + block = SQL_FetchInt(results[0], JumpstatDB_Top20_Block); + distance = float(SQL_FetchInt(results[0], JumpstatDB_Top20_Distance)) / GOKZ_DB_JS_DISTANCE_PRECISION; + strafes = SQL_FetchInt(results[0], JumpstatDB_Top20_Strafes); + sync = float(SQL_FetchInt(results[0], JumpstatDB_Top20_Sync)) / GOKZ_DB_JS_SYNC_PRECISION; + pre = float(SQL_FetchInt(results[0], JumpstatDB_Top20_Pre)) / GOKZ_DB_JS_PRE_PRECISION; + max = float(SQL_FetchInt(results[0], JumpstatDB_Top20_Max)) / GOKZ_DB_JS_MAX_PRECISION; + airtime = float(SQL_FetchInt(results[0], JumpstatDB_Top20_Air)) / GOKZ_DB_JS_AIRTIME_PRECISION; + + FormatEx(display, sizeof(display), "#%-2d %d %T (%.4f) %s", i + 1, block, "Block", client, distance, alias); + menu.AddItem(IntToStringEx(i), display); + + if (clientIsAdmin) + { + FormatEx(admin, sizeof(admin), "<id: %d>", jumpid); + } + + PrintToConsole(client, "#%-2d %d %t (%.4f) %s <STEAM_1:%d:%d> [%d %t | %.2f%% %t | %.2f %t | %.2f %t | %.4f %t] %s", + i + 1, block, "Block", distance, alias, steamid & 1, steamid >> 1, + strafes, "Strafes", sync, "Sync", pre, "Pre", max, "Max", airtime, "Air", + admin); + + jumpInfo[client][i][0] = steamid; + jumpInfo[client][i][1] = type; + jumpInfo[client][i][2] = mode; + blockNums[client][i] = block; + } + } + menu.Display(client, MENU_TIME_FOREVER); + PrintToConsole(client, ""); +} + +// =====[ MENUS ]===== + +void DisplayJumpTopModeMenu(int client) +{ + Menu menu = new Menu(MenuHandler_JumpTopMode); + menu.SetTitle("%T", "Jump Top Mode Menu - Title", client); + GOKZ_MenuAddModeItems(client, menu, false); + menu.Display(client, MENU_TIME_FOREVER); +} + +void DisplayJumpTopTypeMenu(int client, int mode) +{ + jumpTopMode[client] = mode; + + Menu menu = new Menu(MenuHandler_JumpTopType); + menu.SetTitle("%T", "Jump Top Type Menu - Title", client, gC_ModeNames[jumpTopMode[client]]); + JumpTopTypeMenuAddItems(menu); + menu.Display(client, MENU_TIME_FOREVER); +} + +static void JumpTopTypeMenuAddItems(Menu menu) +{ + char display[32]; + for (int i = 0; i < JUMPTYPE_COUNT - 3; i++) + { + FormatEx(display, sizeof(display), "%s", gC_JumpTypes[i]); + menu.AddItem(IntToStringEx(i), display); + } +} + +void DisplayJumpTopBlockTypeMenu(int client, int mode, int type) +{ + jumpTopMode[client] = mode; + jumpTopType[client] = type; + + Menu menu = new Menu(MenuHandler_JumpTopBlockType); + menu.SetTitle("%T", "Jump Top Block Type Menu - Title", client, gC_ModeNames[jumpTopMode[client]], gC_JumpTypes[jumpTopType[client]]); + JumpTopBlockTypeMenuAddItems(client, menu); + menu.Display(client, MENU_TIME_FOREVER); +} + +static void JumpTopBlockTypeMenuAddItems(int client, Menu menu) +{ + char str[64]; + FormatEx(str, sizeof(str), "%T", "Jump Records", client); + menu.AddItem("jump", str); + FormatEx(str, sizeof(str), "%T %T", "Block", client, "Jump Records", client); + menu.AddItem("blockjump", str); +} + + + +// =====[ MENU HANDLERS ]===== + +public int MenuHandler_JumpTopMode(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + // param1 = client, param2 = mode + DisplayJumpTopTypeMenu(param1, param2); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + +public int MenuHandler_JumpTopType(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + // param1 = client, param2 = type + DisplayJumpTopBlockTypeMenu(param1, jumpTopMode[param1], param2); + } + else if (action == MenuAction_Cancel && param2 == MenuCancel_Exit) + { + DisplayJumpTopModeMenu(param1); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + +public int MenuHandler_JumpTopBlockType(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + // param1 = client, param2 = block type + DB_OpenJumpTop(param1, jumpTopMode[param1], jumpTopType[param1], param2); + } + else if (action == MenuAction_Cancel && param2 == MenuCancel_Exit) + { + DisplayJumpTopTypeMenu(param1, jumpTopMode[param1]); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + +public int MenuHandler_JumpTopList(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + char path[PLATFORM_MAX_PATH]; + if (blockNums[param1][param2] == 0) + { + BuildPath(Path_SM, path, sizeof(path), + "%s/%d/%d_%s_%s.%s", + RP_DIRECTORY_JUMPS, jumpInfo[param1][param2][0], jumpTopType[param1], gC_ModeNamesShort[jumpInfo[param1][param2][2]], gC_StyleNamesShort[0], RP_FILE_EXTENSION); + } + else + { + BuildPath(Path_SM, path, sizeof(path), + "%s/%d/%s/%d_%d_%s_%s.%s", + RP_DIRECTORY_JUMPS, jumpInfo[param1][param2][0], RP_DIRECTORY_BLOCKJUMPS, jumpTopType[param1], blockNums[param1][param2], gC_ModeNamesShort[jumpInfo[param1][param2][2]], gC_StyleNamesShort[0], RP_FILE_EXTENSION); + } + GOKZ_RP_LoadJumpReplay(param1, path); + } + + if (action == MenuAction_Cancel && param2 == MenuCancel_Exit) + { + DisplayJumpTopBlockTypeMenu(param1, jumpTopMode[param1], jumpTopType[param1]); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} diff --git a/sourcemod/scripting/gokz-localranks/db/map_top.sp b/sourcemod/scripting/gokz-localranks/db/map_top.sp new file mode 100644 index 0000000..5b296e9 --- /dev/null +++ b/sourcemod/scripting/gokz-localranks/db/map_top.sp @@ -0,0 +1,388 @@ +/* + Opens a menu with the top times for a map course and mode. +*/ + + + +#define ITEM_INFO_GLOBAL_TOP_NUB "gn" +#define ITEM_INFO_GLOBAL_TOP_PRO "gp" + +static char mapTopMap[MAXPLAYERS + 1][64]; +static int mapTopMapID[MAXPLAYERS + 1]; +static int mapTopCourse[MAXPLAYERS + 1]; +static int mapTopMode[MAXPLAYERS + 1]; + + + +// =====[ MAP TOP MODE ]===== + +void DB_OpenMapTopModeMenu(int client, int mapID, int course) +{ + char query[1024]; + + DataPack data = new DataPack(); + data.WriteCell(GetClientUserId(client)); + data.WriteCell(mapID); + data.WriteCell(course); + + Transaction txn = SQL_CreateTransaction(); + + // Retrieve Map Name of MapID + FormatEx(query, sizeof(query), sql_maps_getname, mapID); + txn.AddQuery(query); + // Check for existence of map course with that MapID and Course + FormatEx(query, sizeof(query), sql_mapcourses_findid, mapID, course); + txn.AddQuery(query); + + SQL_ExecuteTransaction(gH_DB, txn, DB_TxnSuccess_OpenMapTopModeMenu, DB_TxnFailure_Generic_DataPack, data, DBPrio_Low); +} + +public void DB_TxnSuccess_OpenMapTopModeMenu(Handle db, DataPack data, int numQueries, Handle[] results, any[] queryData) +{ + data.Reset(); + int client = GetClientOfUserId(data.ReadCell()); + int mapID = data.ReadCell(); + int course = data.ReadCell(); + delete data; + + if (!IsValidClient(client)) + { + return; + } + + // Get name of map + if (SQL_FetchRow(results[0])) + { + SQL_FetchString(results[0], 0, mapTopMap[client], sizeof(mapTopMap[])); + } + // Check if the map course exists in the database + if (SQL_GetRowCount(results[1]) == 0) + { + if (course == 0) + { + GOKZ_PrintToChat(client, true, "%t", "Main Course Not Found", mapTopMap[client]); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Bonus Not Found", mapTopMap[client], course); + } + return; + } + + mapTopMapID[client] = mapID; + mapTopCourse[client] = course; + DisplayMapTopModeMenu(client); +} + +void DB_OpenMapTopModeMenu_FindMap(int client, const char[] mapSearch, int course) +{ + DataPack data = new DataPack(); + data.WriteCell(GetClientUserId(client)); + data.WriteString(mapSearch); + data.WriteCell(course); + + DB_FindMap(mapSearch, DB_TxnSuccess_OpenMapTopModeMenu_FindMap, data, DBPrio_Low); +} + +public void DB_TxnSuccess_OpenMapTopModeMenu_FindMap(Handle db, DataPack data, int numQueries, Handle[] results, any[] queryData) +{ + data.Reset(); + int client = GetClientOfUserId(data.ReadCell()); + char mapSearch[33]; + data.ReadString(mapSearch, sizeof(mapSearch)); + int course = data.ReadCell(); + delete data; + + if (!IsValidClient(client)) + { + return; + } + + if (SQL_GetRowCount(results[0]) == 0) + { + GOKZ_PrintToChat(client, true, "%t", "Map Not Found", mapSearch); + return; + } + else if (SQL_FetchRow(results[0])) + { // Result is the MapID + DB_OpenMapTopModeMenu(client, SQL_FetchInt(results[0], 0), course); + } +} + + + +// =====[ MAP TOP ]===== + +void DB_OpenMapTop(int client, int mapID, int course, int mode, int timeType) +{ + char query[1024]; + + DataPack data = new DataPack(); + data.WriteCell(GetClientUserId(client)); + data.WriteCell(course); + data.WriteCell(mode); + data.WriteCell(timeType); + + Transaction txn = SQL_CreateTransaction(); + + // Get map name + FormatEx(query, sizeof(query), sql_maps_getname, mapID); + txn.AddQuery(query); + // Check for existence of map course with that MapID and Course + FormatEx(query, sizeof(query), sql_mapcourses_findid, mapID, course); + txn.AddQuery(query); + + // Get top times for each time type + switch (timeType) + { + case TimeType_Nub:FormatEx(query, sizeof(query), sql_getmaptop, mapID, course, mode, LR_MAP_TOP_CUTOFF); + case TimeType_Pro:FormatEx(query, sizeof(query), sql_getmaptoppro, mapID, course, mode, LR_MAP_TOP_CUTOFF); + } + txn.AddQuery(query); + + SQL_ExecuteTransaction(gH_DB, txn, DB_TxnSuccess_OpenMapTop, DB_TxnFailure_Generic_DataPack, data, DBPrio_Low); +} + +public void DB_TxnSuccess_OpenMapTop(Handle db, DataPack data, int numQueries, Handle[] results, any[] queryData) +{ + data.Reset(); + int client = GetClientOfUserId(data.ReadCell()); + int course = data.ReadCell(); + int mode = data.ReadCell(); + int timeType = data.ReadCell(); + delete data; + + if (!IsValidClient(client)) + { + return; + } + + // Get map name from results + char mapName[64]; + if (SQL_FetchRow(results[0])) + { + SQL_FetchString(results[0], 0, mapName, sizeof(mapName)); + } + // Check if the map course exists in the database + if (SQL_GetRowCount(results[1]) == 0) + { + if (course == 0) + { + GOKZ_PrintToChat(client, true, "%t", "Main Course Not Found", mapName); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Bonus Not Found", mapName, course); + } + return; + } + + // Check if there are any times + if (SQL_GetRowCount(results[2]) == 0) + { + switch (timeType) + { + case TimeType_Nub:GOKZ_PrintToChat(client, true, "%t", "No Times Found"); + case TimeType_Pro:GOKZ_PrintToChat(client, true, "%t", "No Times Found (PRO)"); + } + DisplayMapTopMenu(client, mode); + return; + } + + Menu menu = new Menu(MenuHandler_MapTopSubmenu); + menu.Pagination = 5; + + // Set submenu title + if (course == 0) + { + menu.SetTitle("%T", "Map Top Submenu - Title", client, + LR_MAP_TOP_CUTOFF, gC_TimeTypeNames[timeType], mapName, gC_ModeNames[mode]); + } + else + { + menu.SetTitle("%T", "Map Top Submenu - Title (Bonus)", client, + LR_MAP_TOP_CUTOFF, gC_TimeTypeNames[timeType], mapName, course, gC_ModeNames[mode]); + } + + // Add submenu items + char display[128], title[65], admin[65]; + char playerName[MAX_NAME_LENGTH]; + float runTime; + int timeid, steamid, teleports, rank = 0; + + bool clientIsAdmin = CheckCommandAccess(client, "sm_deletetime", ADMFLAG_ROOT, false); + + FormatEx(title, sizeof(title), "%s %s %s %T", gC_ModeNames[mode], mapName, gC_TimeTypeNames[timeType], "Top", client); + strcopy(display, sizeof(display), "----------------------------------------------------------------"); + display[strlen(title)] = '\0'; + PrintToConsole(client, title); + PrintToConsole(client, display); + + while (SQL_FetchRow(results[2])) + { + rank++; + timeid = SQL_FetchInt(results[2], 0); + steamid = SQL_FetchInt(results[2], 1); + SQL_FetchString(results[2], 2, playerName, sizeof(playerName)); + runTime = GOKZ_DB_TimeIntToFloat(SQL_FetchInt(results[2], 3)); + + if (clientIsAdmin) + { + FormatEx(admin, sizeof(admin), "<id: %d>", timeid); + } + + switch (timeType) + { + case TimeType_Nub: + { + teleports = SQL_FetchInt(results[2], 4); + FormatEx(display, sizeof(display), "#%-2d %11s %3d TP %s", + rank, GOKZ_FormatTime(runTime), teleports, playerName); + + PrintToConsole(client, "#%-2d %11s %3d TP %s <STEAM_1:%d:%d> %s", + rank, GOKZ_FormatTime(runTime), teleports, playerName, steamid & 1, steamid >> 1, admin); + } + case TimeType_Pro: + { + FormatEx(display, sizeof(display), "#%-2d %11s %s", + rank, GOKZ_FormatTime(runTime), playerName); + + PrintToConsole(client, "#%-2d %11s %s <STEAM_1:%d:%d> %s", + rank, GOKZ_FormatTime(runTime), playerName, steamid & 1, steamid >> 1, admin); + } + } + menu.AddItem("", display, ITEMDRAW_DISABLED); + } + + menu.Display(client, MENU_TIME_FOREVER); +} + + + +// =====[ MENUS ]===== + +void DisplayMapTopModeMenu(int client) +{ + Menu menu = new Menu(MenuHandler_MapTopMode); + MapTopModeMenuSetTitle(client, menu); + GOKZ_MenuAddModeItems(client, menu, false); + menu.Display(client, MENU_TIME_FOREVER); +} + +static void MapTopModeMenuSetTitle(int client, Menu menu) +{ + if (mapTopCourse[client] == 0) + { + menu.SetTitle("%T", "Map Top Mode Menu - Title", client, mapTopMap[client]); + } + else + { + menu.SetTitle("%T", "Map Top Mode Menu - Title (Bonus)", client, mapTopMap[client], mapTopCourse[client]); + } +} + +void DisplayMapTopMenu(int client, int mode) +{ + mapTopMode[client] = mode; + + Menu menu = new Menu(MenuHandler_MapTop); + if (mapTopCourse[client] == 0) + { + menu.SetTitle("%T", "Map Top Menu - Title", client, + mapTopMap[client], gC_ModeNames[mapTopMode[client]]); + } + else + { + menu.SetTitle("%T", "Map Top Menu - Title (Bonus)", client, + mapTopMap[client], mapTopCourse[client], gC_ModeNames[mapTopMode[client]]); + } + MapTopMenuAddItems(client, menu); + menu.Display(client, MENU_TIME_FOREVER); +} + +static void MapTopMenuAddItems(int client, Menu menu) +{ + char display[32]; + for (int i = 0; i < TIMETYPE_COUNT; i++) + { + FormatEx(display, sizeof(display), "%T", "Map Top Menu - Top", client, LR_MAP_TOP_CUTOFF, gC_TimeTypeNames[i]); + menu.AddItem(IntToStringEx(i), display); + } + if (gB_GOKZGlobal) + { + FormatEx(display, sizeof(display), "%T", "Map Top Menu - Global Top", client, gC_TimeTypeNames[TimeType_Nub]); + menu.AddItem(ITEM_INFO_GLOBAL_TOP_NUB, display); + + FormatEx(display, sizeof(display), "%T", "Map Top Menu - Global Top", client, gC_TimeTypeNames[TimeType_Pro]); + menu.AddItem(ITEM_INFO_GLOBAL_TOP_PRO, display); + } +} + +void ReopenMapTopMenu(int client) +{ + DisplayMapTopMenu(client, mapTopMode[client]); +} + + + +// =====[ MENU HANDLERS ]===== + +public int MenuHandler_MapTopMode(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + // param1 = client, param2 = mode + DisplayMapTopMenu(param1, param2); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + +public int MenuHandler_MapTop(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + char info[8]; + menu.GetItem(param2, info, sizeof(info)); + + if (gB_GOKZGlobal && StrEqual(info, ITEM_INFO_GLOBAL_TOP_NUB)) + { + GOKZ_GL_DisplayMapTopMenu(param1, mapTopMap[param1], mapTopCourse[param1], mapTopMode[param1], TimeType_Nub); + } + else if (gB_GOKZGlobal && StrEqual(info, ITEM_INFO_GLOBAL_TOP_PRO)) + { + GOKZ_GL_DisplayMapTopMenu(param1, mapTopMap[param1], mapTopCourse[param1], mapTopMode[param1], TimeType_Pro); + } + else + { + int timeType = StringToInt(info); + DB_OpenMapTop(param1, mapTopMapID[param1], mapTopCourse[param1], mapTopMode[param1], timeType); + } + } + else if (action == MenuAction_Cancel && param2 == MenuCancel_Exit) + { + DisplayMapTopModeMenu(param1); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + +public int MenuHandler_MapTopSubmenu(Menu menu, MenuAction action, int param1, int param2) +{ + // TODO Menu item info is player's SteamID32, but is currently not used + if (action == MenuAction_Cancel && param2 == MenuCancel_Exit) + { + ReopenMapTopMenu(param1); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-localranks/db/player_top.sp b/sourcemod/scripting/gokz-localranks/db/player_top.sp new file mode 100644 index 0000000..0348eec --- /dev/null +++ b/sourcemod/scripting/gokz-localranks/db/player_top.sp @@ -0,0 +1,165 @@ +/* + Opens a menu with top record holders of a time type and mode. +*/ + + + +static int playerTopMode[MAXPLAYERS + 1]; + + + +void DB_OpenPlayerTop(int client, int timeType, int mode) +{ + char query[1024]; + + DataPack data = new DataPack(); + data.WriteCell(GetClientUserId(client)); + data.WriteCell(timeType); + data.WriteCell(mode); + + Transaction txn = SQL_CreateTransaction(); + + // Get top players + switch (timeType) + { + case TimeType_Nub: + { + FormatEx(query, sizeof(query), sql_gettopplayers, mode, LR_PLAYER_TOP_CUTOFF); + txn.AddQuery(query); + } + case TimeType_Pro: + { + FormatEx(query, sizeof(query), sql_gettopplayerspro, mode, LR_PLAYER_TOP_CUTOFF); + txn.AddQuery(query); + } + } + + SQL_ExecuteTransaction(gH_DB, txn, DB_TxnSuccess_OpenPlayerTop, DB_TxnFailure_Generic_DataPack, data, DBPrio_Low); +} + +public void DB_TxnSuccess_OpenPlayerTop(Handle db, DataPack data, int numQueries, Handle[] results, any[] queryData) +{ + data.Reset(); + int client = GetClientOfUserId(data.ReadCell()); + int timeType = data.ReadCell(); + int mode = data.ReadCell(); + delete data; + + if (!IsValidClient(client)) + { + return; + } + + if (SQL_GetRowCount(results[0]) == 0) + { + switch (timeType) + { + case TimeType_Nub:GOKZ_PrintToChat(client, true, "%t", "Player Top - No Times"); + case TimeType_Pro:GOKZ_PrintToChat(client, true, "%t", "Player Top - No Times (PRO)"); + } + DisplayPlayerTopMenu(client, playerTopMode[client]); + return; + } + + Menu menu = new Menu(MenuHandler_PlayerTopSubmenu); + menu.Pagination = 5; + + // Set submenu title + menu.SetTitle("%T", "Player Top Submenu - Title", client, + LR_PLAYER_TOP_CUTOFF, gC_TimeTypeNames[timeType], gC_ModeNames[mode]); + + // Add submenu items + char display[256]; + int rank = 0; + while (SQL_FetchRow(results[0])) + { + rank++; + char playerString[33]; + SQL_FetchString(results[0], 1, playerString, sizeof(playerString)); + FormatEx(display, sizeof(display), "#%-2d %s (%d)", rank, playerString, SQL_FetchInt(results[0], 2)); + menu.AddItem(IntToStringEx(SQL_FetchInt(results[0], 0)), display, ITEMDRAW_DISABLED); + } + + menu.Display(client, MENU_TIME_FOREVER); +} + + + +// =====[ MENUS ]===== + +void DisplayPlayerTopModeMenu(int client) +{ + Menu menu = new Menu(MenuHandler_PlayerTopMode); + menu.SetTitle("%T", "Player Top Mode Menu - Title", client); + GOKZ_MenuAddModeItems(client, menu, false); + menu.Display(client, MENU_TIME_FOREVER); +} + +void DisplayPlayerTopMenu(int client, int mode) +{ + playerTopMode[client] = mode; + + Menu menu = new Menu(MenuHandler_PlayerTop); + menu.SetTitle("%T", "Player Top Menu - Title", client, gC_ModeNames[mode]); + PlayerTopMenuAddItems(client, menu); + menu.Display(client, MENU_TIME_FOREVER); +} + +static void PlayerTopMenuAddItems(int client, Menu menu) +{ + char display[32]; + for (int timeType = 0; timeType < TIMETYPE_COUNT; timeType++) + { + FormatEx(display, sizeof(display), "%T", "Player Top Menu - Top", client, + LR_PLAYER_TOP_CUTOFF, gC_TimeTypeNames[timeType]); + menu.AddItem("", display, ITEMDRAW_DEFAULT); + } +} + + + +// =====[ MENU HANLDERS ]===== + +public int MenuHandler_PlayerTopMode(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + DisplayPlayerTopMenu(param1, param2); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + +public int MenuHandler_PlayerTop(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + DB_OpenPlayerTop(param1, param2, playerTopMode[param1]); + } + else if (action == MenuAction_Cancel && param2 == MenuCancel_Exit) + { + DisplayPlayerTopModeMenu(param1); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + +public int MenuHandler_PlayerTopSubmenu(Menu menu, MenuAction action, int param1, int param2) +{ + // Menu item info is player's SteamID32, but is currently not used + if (action == MenuAction_Cancel && param2 == MenuCancel_Exit) + { + DisplayPlayerTopMenu(param1, playerTopMode[param1]); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-localranks/db/print_average.sp b/sourcemod/scripting/gokz-localranks/db/print_average.sp new file mode 100644 index 0000000..7f7c4e4 --- /dev/null +++ b/sourcemod/scripting/gokz-localranks/db/print_average.sp @@ -0,0 +1,152 @@ +/* + Gets the average personal best time of a course. +*/ + + + +void DB_PrintAverage(int client, int mapID, int course, int mode) +{ + char query[1024]; + + DataPack data = new DataPack(); + data.WriteCell(GetClientUserId(client)); + data.WriteCell(course); + data.WriteCell(mode); + + Transaction txn = SQL_CreateTransaction(); + + // Retrieve Map Name of MapID + FormatEx(query, sizeof(query), sql_maps_getname, mapID); + txn.AddQuery(query); + // Check for existence of map course with that MapID and Course + FormatEx(query, sizeof(query), sql_mapcourses_findid, mapID, course); + txn.AddQuery(query); + // Get Average PB Time + FormatEx(query, sizeof(query), sql_getaverage, mapID, course, mode); + txn.AddQuery(query); + // Get Average PRO PB Time + FormatEx(query, sizeof(query), sql_getaverage_pro, mapID, course, mode); + txn.AddQuery(query); + + SQL_ExecuteTransaction(gH_DB, txn, DB_TxnSuccess_PrintAverage, DB_TxnFailure_Generic_DataPack, data, DBPrio_Low); +} + +public void DB_TxnSuccess_PrintAverage(Handle db, DataPack data, int numQueries, Handle[] results, any[] queryData) +{ + data.Reset(); + int client = GetClientOfUserId(data.ReadCell()); + int course = data.ReadCell(); + int mode = data.ReadCell(); + delete data; + + if (!IsValidClient(client)) + { + return; + } + + char mapName[33]; + int mapCompletions, mapCompletionsPro; + float averageTime, averageTimePro; + + // Get Map Name from results + if (SQL_FetchRow(results[0])) + { + SQL_FetchString(results[0], 0, mapName, sizeof(mapName)); + } + if (SQL_GetRowCount(results[1]) == 0) + { + if (course == 0) + { + GOKZ_PrintToChat(client, true, "%t", "Main Course Not Found", mapName); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Bonus Not Found", mapName, course); + } + return; + } + + // Get number of completions and average time + if (SQL_FetchRow(results[2])) + { + mapCompletions = SQL_FetchInt(results[2], 1); + if (mapCompletions > 0) + { + averageTime = GOKZ_DB_TimeIntToFloat(SQL_FetchInt(results[2], 0)); + } + } + + // Get number of completions and average time (PRO) + if (SQL_FetchRow(results[3])) + { + mapCompletionsPro = SQL_FetchInt(results[3], 1); + if (mapCompletions > 0) + { + averageTimePro = GOKZ_DB_TimeIntToFloat(SQL_FetchInt(results[3], 0)); + } + } + + // Print average time header to chat + if (course == 0) + { + GOKZ_PrintToChat(client, true, "%t", "Average Time Header", mapName, gC_ModeNamesShort[mode]); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Average Time Header (Bonus)", mapName, course, gC_ModeNamesShort[mode]); + } + + if (mapCompletions == 0) + { + CPrintToChat(client, "%t", "No Times Found"); + } + else if (mapCompletionsPro == 0) + { + CPrintToChat(client, "%t, %t", + "Average Time - NUB", GOKZ_FormatTime(averageTime), mapCompletions, + "Average Time - No PRO Time"); + } + else + { + CPrintToChat(client, "%t, %t", + "Average Time - NUB", GOKZ_FormatTime(averageTime), mapCompletions, + "Average Time - PRO", GOKZ_FormatTime(averageTimePro), mapCompletionsPro); + } +} + +void DB_PrintAverage_FindMap(int client, const char[] mapSearch, int course, int mode) +{ + DataPack data = new DataPack(); + data.WriteCell(GetClientUserId(client)); + data.WriteString(mapSearch); + data.WriteCell(course); + data.WriteCell(mode); + + DB_FindMap(mapSearch, DB_TxnSuccess_PrintAverage_FindMap, data, DBPrio_Low); +} + +public void DB_TxnSuccess_PrintAverage_FindMap(Handle db, DataPack data, int numQueries, Handle[] results, any[] queryData) +{ + data.Reset(); + int client = GetClientOfUserId(data.ReadCell()); + char mapSearch[33]; + data.ReadString(mapSearch, sizeof(mapSearch)); + int course = data.ReadCell(); + int mode = data.ReadCell(); + delete data; + + if (!IsValidClient(client)) + { + return; + } + + if (SQL_GetRowCount(results[0]) == 0) + { + GOKZ_PrintToChat(client, true, "%t", "Map Not Found", mapSearch); + return; + } + else if (SQL_FetchRow(results[0])) + { // Result is the MapID + DB_PrintAverage(client, SQL_FetchInt(results[0], 0), course, mode); + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-localranks/db/print_js.sp b/sourcemod/scripting/gokz-localranks/db/print_js.sp new file mode 100644 index 0000000..e694a95 --- /dev/null +++ b/sourcemod/scripting/gokz-localranks/db/print_js.sp @@ -0,0 +1,108 @@ +/* + Prints the player's personal best jumps. +*/ + + + +void DisplayJumpstatRecord(int client, int jumpType, char[] jumper = "") +{ + int mode = GOKZ_GetCoreOption(client, Option_Mode); + + int steamid; + char alias[33]; + if (StrEqual(jumper, "")) + { + steamid = GetSteamAccountID(client); + FormatEx(alias, sizeof(alias), "%N", client); + + DB_JS_OpenPlayerRecord(client, steamid, alias, jumpType, mode, 0); + DB_JS_OpenPlayerRecord(client, steamid, alias, jumpType, mode, 1); + } + else + { + DataPack data = new DataPack(); + data.WriteCell(client); + data.WriteCell(jumpType); + data.WriteCell(mode); + data.WriteString(jumper); + + DB_FindPlayer(jumper, DB_JS_TxnSuccess_LookupPlayer, data); + } +} + +public void DB_JS_TxnSuccess_LookupPlayer(Handle db, DataPack data, int numQueries, Handle[] results, any[] queryData) +{ + char jumper[MAX_NAME_LENGTH]; + + data.Reset(); + int client = data.ReadCell(); + int jumpType = data.ReadCell(); + int mode = data.ReadCell(); + data.ReadString(jumper, sizeof(jumper)); + delete data; + + if (SQL_GetRowCount(results[0]) == 0) + { + GOKZ_PrintToChat(client, true, "%t", "Player Not Found", jumper); + return; + } + + char alias[33]; + SQL_FetchRow(results[0]); + int steamid = SQL_FetchInt(results[0], JumpstatDB_FindPlayer_SteamID32); + SQL_FetchString(results[0], JumpstatDB_FindPlayer_Alias, alias, sizeof(alias)); + + DB_JS_OpenPlayerRecord(client, steamid, alias, jumpType, mode, 0); + DB_JS_OpenPlayerRecord(client, steamid, alias, jumpType, mode, 1); +} + +void DB_JS_OpenPlayerRecord(int client, int steamid, char[] alias, int jumpType, int mode, int block) +{ + char query[1024]; + + DataPack data = new DataPack(); + data.WriteCell(client); + data.WriteString(alias); + data.WriteCell(jumpType); + data.WriteCell(mode); + + Transaction txn = SQL_CreateTransaction(); + FormatEx(query, sizeof(query), sql_jumpstats_getrecord, steamid, jumpType, mode, block); + txn.AddQuery(query); + SQL_ExecuteTransaction(gH_DB, txn, DB_JS_TxnSuccess_OpenPlayerRecord, DB_TxnFailure_Generic_DataPack, data, DBPrio_Low); +} + +public void DB_JS_TxnSuccess_OpenPlayerRecord(Handle db, DataPack data, int numQueries, Handle[] results, any[] queryData) +{ + char alias[33]; + data.Reset(); + int client = data.ReadCell(); + data.ReadString(alias, sizeof(alias)); + int jumpType = data.ReadCell(); + int mode = data.ReadCell(); + delete data; + + if (!IsValidClient(client)) + { + return; + } + + if (SQL_GetRowCount(results[0]) == 0) + { + GOKZ_PrintToChat(client, true, "%t", "No Jumpstats Found"); + return; + } + + SQL_FetchRow(results[0]); + float distance = float(SQL_FetchInt(results[0], JumpstatDB_Lookup_Distance)) / 10000; + int block = SQL_FetchInt(results[0], JumpstatDB_Lookup_Block); + + if (block == 0) + { + GOKZ_PrintToChat(client, true, "%t", "Jump Record", gC_ModeNamesShort[mode], gC_JumpTypes[jumpType], alias, distance); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Block Jump Record", gC_ModeNamesShort[mode], gC_JumpTypes[jumpType], alias, block, distance); + } +} diff --git a/sourcemod/scripting/gokz-localranks/db/print_pbs.sp b/sourcemod/scripting/gokz-localranks/db/print_pbs.sp new file mode 100644 index 0000000..0d541d4 --- /dev/null +++ b/sourcemod/scripting/gokz-localranks/db/print_pbs.sp @@ -0,0 +1,266 @@ +/* + Prints the player's personal times on a map course and given mode. +*/ + + + +void DB_PrintPBs(int client, int targetSteamID, int mapID, int course, int mode) +{ + char query[1024]; + + DataPack data = new DataPack(); + data.WriteCell(GetClientUserId(client)); + data.WriteCell(course); + data.WriteCell(mode); + + Transaction txn = SQL_CreateTransaction(); + + // Retrieve Alias of SteamID + FormatEx(query, sizeof(query), sql_players_getalias, targetSteamID); + txn.AddQuery(query); + // Retrieve Map Name of MapID + FormatEx(query, sizeof(query), sql_maps_getname, mapID); + txn.AddQuery(query); + // Check for existence of map course with that MapID and Course + FormatEx(query, sizeof(query), sql_mapcourses_findid, mapID, course); + txn.AddQuery(query); + + // Get PB + FormatEx(query, sizeof(query), sql_getpb, targetSteamID, mapID, course, mode, 1); + txn.AddQuery(query); + // Get Rank + FormatEx(query, sizeof(query), sql_getmaprank, mapID, course, mode, targetSteamID, mapID, course, mode); + txn.AddQuery(query); + // Get Number of Players with Times + FormatEx(query, sizeof(query), sql_getlowestmaprank, mapID, course, mode); + txn.AddQuery(query); + + // Get PRO PB + FormatEx(query, sizeof(query), sql_getpbpro, targetSteamID, mapID, course, mode, 1); + txn.AddQuery(query); + // Get PRO Rank + FormatEx(query, sizeof(query), sql_getmaprankpro, mapID, course, mode, targetSteamID, mapID, course, mode); + txn.AddQuery(query); + // Get Number of Players with PRO Times + FormatEx(query, sizeof(query), sql_getlowestmaprankpro, mapID, course, mode); + txn.AddQuery(query); + + SQL_ExecuteTransaction(gH_DB, txn, DB_TxnSuccess_PrintPBs, DB_TxnFailure_Generic_DataPack, data, DBPrio_Low); +} + +public void DB_TxnSuccess_PrintPBs(Handle db, DataPack data, int numQueries, Handle[] results, any[] queryData) +{ + data.Reset(); + int client = GetClientOfUserId(data.ReadCell()); + int course = data.ReadCell(); + int mode = data.ReadCell(); + delete data; + + if (!IsValidClient(client)) + { + return; + } + + char playerName[MAX_NAME_LENGTH], mapName[33]; + + bool hasPB = false; + bool hasPBPro = false; + + float runTime; + int teleportsUsed; + int rank; + int maxRank; + + float runTimePro; + int rankPro; + int maxRankPro; + + // Get Player Name from results + if (SQL_FetchRow(results[0])) + { + SQL_FetchString(results[0], 0, playerName, sizeof(playerName)); + } + // Get Map Name from results + if (SQL_FetchRow(results[1])) + { + SQL_FetchString(results[1], 0, mapName, sizeof(mapName)); + } + if (SQL_GetRowCount(results[2]) == 0) + { + if (course == 0) + { + GOKZ_PrintToChat(client, true, "%t", "Main Course Not Found", mapName); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Bonus Not Found", mapName, course); + } + return; + } + + // Get PB info from results + if (SQL_GetRowCount(results[3]) > 0) + { + hasPB = true; + if (SQL_FetchRow(results[3])) + { + runTime = GOKZ_DB_TimeIntToFloat(SQL_FetchInt(results[3], 0)); + teleportsUsed = SQL_FetchInt(results[3], 1); + } + if (SQL_FetchRow(results[4])) + { + rank = SQL_FetchInt(results[4], 0); + } + if (SQL_FetchRow(results[5])) + { + maxRank = SQL_FetchInt(results[5], 0); + } + } + // Get PB info (Pro) from results + if (SQL_GetRowCount(results[6]) > 0) + { + hasPBPro = true; + if (SQL_FetchRow(results[6])) + { + runTimePro = GOKZ_DB_TimeIntToFloat(SQL_FetchInt(results[6], 0)); + } + if (SQL_FetchRow(results[7])) + { + rankPro = SQL_FetchInt(results[7], 0); + } + if (SQL_FetchRow(results[8])) + { + maxRankPro = SQL_FetchInt(results[8], 0); + } + } + + // Print PB header to chat + if (course == 0) + { + GOKZ_PrintToChat(client, true, "%t", "PB Header", playerName, mapName, gC_ModeNamesShort[mode]); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "PB Header (Bonus)", playerName, mapName, course, gC_ModeNamesShort[mode]); + } + + // Print PB times to chat + if (!hasPB) + { + CPrintToChat(client, "%t", "PB Time - No Times"); + } + else if (!hasPBPro) + { + CPrintToChat(client, "%t", "PB Time - NUB", GOKZ_FormatTime(runTime), teleportsUsed, rank, maxRank); + CPrintToChat(client, "%t", "PB Time - No PRO Time"); + } + else if (teleportsUsed == 0) + { // Their MAP PB has 0 teleports, and is therefore also their PRO PB + CPrintToChat(client, "%t", "PB Time - NUB and PRO", GOKZ_FormatTime(runTime), rank, maxRank, rankPro, maxRankPro); + } + else + { + CPrintToChat(client, "%t", "PB Time - NUB", GOKZ_FormatTime(runTime), teleportsUsed, rank, maxRank); + CPrintToChat(client, "%t", "PB Time - PRO", GOKZ_FormatTime(runTimePro), rankPro, maxRankPro); + } +} + +void DB_PrintPBs_FindMap(int client, int targetSteamID, const char[] mapSearch, int course, int mode) +{ + DataPack data = new DataPack(); + data.WriteCell(GetClientUserId(client)); + data.WriteCell(targetSteamID); + data.WriteString(mapSearch); + data.WriteCell(course); + data.WriteCell(mode); + + DB_FindMap(mapSearch, DB_TxnSuccess_PrintPBs_FindMap, data, DBPrio_Low); +} + +public void DB_TxnSuccess_PrintPBs_FindMap(Handle db, DataPack data, int numQueries, Handle[] results, any[] queryData) +{ + data.Reset(); + int client = GetClientOfUserId(data.ReadCell()); + int targetSteamID = data.ReadCell(); + char mapSearch[33]; + data.ReadString(mapSearch, sizeof(mapSearch)); + int course = data.ReadCell(); + int mode = data.ReadCell(); + delete data; + + if (!IsValidClient(client)) + { + return; + } + + // Check if the map course exists in the database + if (SQL_GetRowCount(results[0]) == 0) + { + GOKZ_PrintToChat(client, true, "%t", "Map Not Found", mapSearch); + return; + } + else if (SQL_FetchRow(results[0])) + { // Result is the MapID + DB_PrintPBs(client, targetSteamID, SQL_FetchInt(results[0], 0), course, mode); + if (gB_GOKZGlobal) + { + char map[33], steamid[32]; + SQL_FetchString(results[0], 1, map, sizeof(map)); + GetSteam2FromAccountId(steamid, sizeof(steamid), targetSteamID); + GOKZ_GL_PrintRecords(client, map, course, GOKZ_GetCoreOption(client, Option_Mode), steamid); + } + } +} + +void DB_PrintPBs_FindPlayerAndMap(int client, const char[] playerSearch, const char[] mapSearch, int course, int mode) +{ + DataPack data = new DataPack(); + data.WriteCell(GetClientUserId(client)); + data.WriteString(playerSearch); + data.WriteString(mapSearch); + data.WriteCell(course); + data.WriteCell(mode); + + DB_FindPlayerAndMap(playerSearch, mapSearch, DB_TxnSuccess_PrintPBs_FindPlayerAndMap, data, DBPrio_Low); +} + +public void DB_TxnSuccess_PrintPBs_FindPlayerAndMap(Handle db, DataPack data, int numQueries, Handle[] results, any[] queryData) +{ + data.Reset(); + int client = GetClientOfUserId(data.ReadCell()); + char playerSearch[MAX_NAME_LENGTH]; + data.ReadString(playerSearch, sizeof(playerSearch)); + char mapSearch[33]; + data.ReadString(mapSearch, sizeof(mapSearch)); + int course = data.ReadCell(); + int mode = data.ReadCell(); + delete data; + + if (!IsValidClient(client)) + { + return; + } + + if (SQL_GetRowCount(results[0]) == 0) + { + GOKZ_PrintToChat(client, true, "%t", "Player Not Found", playerSearch); + return; + } + else if (SQL_GetRowCount(results[1]) == 0) + { + GOKZ_PrintToChat(client, true, "%t", "Map Not Found", mapSearch); + return; + } + else if (SQL_FetchRow(results[0]) && SQL_FetchRow(results[1])) + { + int accountid = SQL_FetchInt(results[0], 0); + DB_PrintPBs(client, accountid, SQL_FetchInt(results[1], 0), course, mode); + if (gB_GOKZGlobal) + { + char map[33], steamid[32]; + SQL_FetchString(results[1], 1, map, sizeof(map)); + GetSteam2FromAccountId(steamid, sizeof(steamid), accountid); + GOKZ_GL_PrintRecords(client, map, course, GOKZ_GetCoreOption(client, Option_Mode), steamid); + } + } +} diff --git a/sourcemod/scripting/gokz-localranks/db/print_records.sp b/sourcemod/scripting/gokz-localranks/db/print_records.sp new file mode 100644 index 0000000..b5de03b --- /dev/null +++ b/sourcemod/scripting/gokz-localranks/db/print_records.sp @@ -0,0 +1,173 @@ +/* + Prints the record times on a map course and given mode. +*/ + + + +void DB_PrintRecords(int client, int mapID, int course, int mode) +{ + char query[1024]; + + DataPack data = new DataPack(); + data.WriteCell(GetClientUserId(client)); + data.WriteCell(course); + data.WriteCell(mode); + + Transaction txn = SQL_CreateTransaction(); + + // Retrieve Map Name of MapID + FormatEx(query, sizeof(query), sql_maps_getname, mapID); + txn.AddQuery(query); + // Check for existence of map course with that MapID and Course + FormatEx(query, sizeof(query), sql_mapcourses_findid, mapID, course); + txn.AddQuery(query); + + // Get Map WR + FormatEx(query, sizeof(query), sql_getmaptop, mapID, course, mode, 1); + txn.AddQuery(query); + // Get PRO WR + FormatEx(query, sizeof(query), sql_getmaptoppro, mapID, course, mode, 1); + txn.AddQuery(query); + + SQL_ExecuteTransaction(gH_DB, txn, DB_TxnSuccess_PrintRecords, DB_TxnFailure_Generic_DataPack, data, DBPrio_Low); +} + +public void DB_TxnSuccess_PrintRecords(Handle db, DataPack data, int numQueries, Handle[] results, any[] queryData) +{ + data.Reset(); + int client = GetClientOfUserId(data.ReadCell()); + int course = data.ReadCell(); + int mode = data.ReadCell(); + delete data; + + if (!IsValidClient(client)) + { + return; + } + + char mapName[33]; + + bool mapHasRecord = false; + bool mapHasRecordPro = false; + + char recordHolder[33]; + float runTime; + int teleportsUsed; + + char recordHolderPro[33]; + float runTimePro; + + // Get Map Name from results + if (SQL_FetchRow(results[0])) + { + SQL_FetchString(results[0], 0, mapName, sizeof(mapName)); + } + // Check if the map course exists in the database + if (SQL_GetRowCount(results[1]) == 0) + { + if (course == 0) + { + GOKZ_PrintToChat(client, true, "%t", "Main Course Not Found", mapName); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Bonus Not Found", mapName, course); + } + return; + } + + // Get WR info from results + if (SQL_GetRowCount(results[2]) > 0) + { + mapHasRecord = true; + if (SQL_FetchRow(results[2])) + { + SQL_FetchString(results[2], 2, recordHolder, sizeof(recordHolder)); + runTime = GOKZ_DB_TimeIntToFloat(SQL_FetchInt(results[2], 3)); + teleportsUsed = SQL_FetchInt(results[2], 4); + } + } + // Get Pro WR info from results + if (SQL_GetRowCount(results[3]) > 0) + { + mapHasRecordPro = true; + if (SQL_FetchRow(results[3])) + { + SQL_FetchString(results[3], 2, recordHolderPro, sizeof(recordHolderPro)); + runTimePro = GOKZ_DB_TimeIntToFloat(SQL_FetchInt(results[3], 3)); + } + } + + // Print WR header to chat + if (course == 0) + { + GOKZ_PrintToChat(client, true, "%t", "WR Header", mapName, gC_ModeNamesShort[mode]); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "WR Header (Bonus)", mapName, course, gC_ModeNamesShort[mode]); + } + + // Print WR times to chat + if (!mapHasRecord) + { + CPrintToChat(client, "%t", "No Times Found"); + } + else if (!mapHasRecordPro) + { + CPrintToChat(client, "%t", "WR Time - NUB", GOKZ_FormatTime(runTime), teleportsUsed, recordHolder); + CPrintToChat(client, "%t", "WR Time - No PRO Time"); + } + else if (teleportsUsed == 0) + { + CPrintToChat(client, "%t", "WR Time - NUB and PRO", GOKZ_FormatTime(runTimePro), recordHolderPro); + } + else + { + CPrintToChat(client, "%t", "WR Time - NUB", GOKZ_FormatTime(runTime), teleportsUsed, recordHolder); + CPrintToChat(client, "%t", "WR Time - PRO", GOKZ_FormatTime(runTimePro), recordHolderPro); + } +} + +void DB_PrintRecords_FindMap(int client, const char[] mapSearch, int course, int mode) +{ + DataPack data = new DataPack(); + data.WriteCell(GetClientUserId(client)); + data.WriteString(mapSearch); + data.WriteCell(course); + data.WriteCell(mode); + + DB_FindMap(mapSearch, DB_TxnSuccess_PrintRecords_FindMap, data, DBPrio_Low); +} + +public void DB_TxnSuccess_PrintRecords_FindMap(Handle db, DataPack data, int numQueries, Handle[] results, any[] queryData) +{ + data.Reset(); + int client = GetClientOfUserId(data.ReadCell()); + char mapSearch[33]; + data.ReadString(mapSearch, sizeof(mapSearch)); + int course = data.ReadCell(); + int mode = data.ReadCell(); + delete data; + + if (!IsValidClient(client)) + { + return; + } + + if (SQL_GetRowCount(results[0]) == 0) + { + GOKZ_PrintToChat(client, true, "%t", "Map Not Found", mapSearch); + return; + } + else if (SQL_FetchRow(results[0])) + { // Result is the MapID + DB_PrintRecords(client, SQL_FetchInt(results[0], 0), course, mode); + if (gB_GOKZGlobal) + { + char map[33]; + SQL_FetchString(results[0], 1, map, sizeof(map)); + GOKZ_GL_PrintRecords(client, map, course, GOKZ_GetCoreOption(client, Option_Mode)); + } + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-localranks/db/process_new_time.sp b/sourcemod/scripting/gokz-localranks/db/process_new_time.sp new file mode 100644 index 0000000..f9aaf73 --- /dev/null +++ b/sourcemod/scripting/gokz-localranks/db/process_new_time.sp @@ -0,0 +1,157 @@ +/* + Processes a newly submitted time, determining if the player beat their + personal best and if they beat the map course and mode's record time. +*/ + + + +void DB_ProcessNewTime(int client, int steamID, int mapID, int course, int mode, int style, int runTimeMS, int teleportsUsed) +{ + char query[1024]; + + DataPack data = new DataPack(); + data.WriteCell(GetClientUserId(client)); + data.WriteCell(steamID); + data.WriteCell(mapID); + data.WriteCell(course); + data.WriteCell(mode); + data.WriteCell(style); + data.WriteCell(runTimeMS); + data.WriteCell(teleportsUsed); + + Transaction txn = SQL_CreateTransaction(); + + // Get Top 2 PBs + FormatEx(query, sizeof(query), sql_getpb, steamID, mapID, course, mode, 2); + txn.AddQuery(query); + // Get Rank + FormatEx(query, sizeof(query), sql_getmaprank, mapID, course, mode, steamID, mapID, course, mode); + txn.AddQuery(query); + // Get Number of Players with Times + FormatEx(query, sizeof(query), sql_getlowestmaprank, mapID, course, mode); + txn.AddQuery(query); + + if (teleportsUsed == 0) + { + // Get Top 2 PRO PBs + FormatEx(query, sizeof(query), sql_getpbpro, steamID, mapID, course, mode, 2); + txn.AddQuery(query); + // Get PRO Rank + FormatEx(query, sizeof(query), sql_getmaprankpro, mapID, course, mode, steamID, mapID, course, mode); + txn.AddQuery(query); + // Get Number of Players with PRO Times + FormatEx(query, sizeof(query), sql_getlowestmaprankpro, mapID, course, mode); + txn.AddQuery(query); + } + + SQL_ExecuteTransaction(gH_DB, txn, DB_TxnSuccess_ProcessTimerEnd, DB_TxnFailure_Generic_DataPack, data, DBPrio_Normal); +} + +public void DB_TxnSuccess_ProcessTimerEnd(Handle db, DataPack data, int numQueries, Handle[] results, any[] queryData) +{ + data.Reset(); + int client = GetClientOfUserId(data.ReadCell()); + int steamID = data.ReadCell(); + int mapID = data.ReadCell(); + int course = data.ReadCell(); + int mode = data.ReadCell(); + int style = data.ReadCell(); + int runTimeMS = data.ReadCell(); + int teleportsUsed = data.ReadCell(); + delete data; + + if (!IsValidClient(client)) + { + return; + } + + bool firstTime = SQL_GetRowCount(results[0]) == 1; + int pbDiff = 0; + int rank = -1; + int maxRank = -1; + if (!firstTime) + { + SQL_FetchRow(results[0]); + int pb = SQL_FetchInt(results[0], 0); + if (runTimeMS == pb) // New time is new PB + { + SQL_FetchRow(results[0]); + int oldPB = SQL_FetchInt(results[0], 0); + pbDiff = runTimeMS - oldPB; + } + else // Didn't beat PB + { + pbDiff = runTimeMS - pb; + } + } + // Get NUB Rank + SQL_FetchRow(results[1]); + rank = SQL_FetchInt(results[1], 0); + SQL_FetchRow(results[2]); + maxRank = SQL_FetchInt(results[2], 0); + + // Repeat for PRO Runs + bool firstTimePro = false; + int pbDiffPro = 0; + int rankPro = -1; + int maxRankPro = -1; + if (teleportsUsed == 0) + { + firstTimePro = SQL_GetRowCount(results[3]) == 1; + if (!firstTimePro) + { + SQL_FetchRow(results[3]); + int pb = SQL_FetchInt(results[3], 0); + if (runTimeMS == pb) // New time is new PB + { + SQL_FetchRow(results[3]); + int oldPB = SQL_FetchInt(results[3], 0); + pbDiffPro = runTimeMS - oldPB; + } + else // Didn't beat PB + { + pbDiffPro = runTimeMS - pb; + } + } + // Get PRO Rank + SQL_FetchRow(results[4]); + rankPro = SQL_FetchInt(results[4], 0); + SQL_FetchRow(results[5]); + maxRankPro = SQL_FetchInt(results[5], 0); + } + + // Call OnTimeProcessed forward + Call_OnTimeProcessed( + client, + steamID, + mapID, + course, + mode, + style, + GOKZ_DB_TimeIntToFloat(runTimeMS), + teleportsUsed, + firstTime, + GOKZ_DB_TimeIntToFloat(pbDiff), + rank, + maxRank, + firstTimePro, + GOKZ_DB_TimeIntToFloat(pbDiffPro), + rankPro, + maxRankPro); + + // Call OnNewRecord forward + bool newWR = (firstTime || pbDiff < 0) && rank == 1; + bool newWRPro = (firstTimePro || pbDiffPro < 0) && rankPro == 1; + if (newWR && newWRPro) + { + Call_OnNewRecord(client, steamID, mapID, course, mode, style, RecordType_NubAndPro, GOKZ_DB_TimeIntToFloat(pbDiffPro), teleportsUsed); + } + else if (newWR) + { + Call_OnNewRecord(client, steamID, mapID, course, mode, style, RecordType_Nub, GOKZ_DB_TimeIntToFloat(pbDiff), teleportsUsed); + } + else if (newWRPro) + { + Call_OnNewRecord(client, steamID, mapID, course, mode, style, RecordType_Pro, GOKZ_DB_TimeIntToFloat(pbDiffPro), teleportsUsed); + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-localranks/db/recent_records.sp b/sourcemod/scripting/gokz-localranks/db/recent_records.sp new file mode 100644 index 0000000..939b132 --- /dev/null +++ b/sourcemod/scripting/gokz-localranks/db/recent_records.sp @@ -0,0 +1,171 @@ +/* + Opens the menu with a list of recently broken records for the given mode + and time type. +*/ + + + +static int recentRecordsMode[MAXPLAYERS + 1]; + + + +void DB_OpenRecentRecords(int client, int mode, int timeType) +{ + char query[1024]; + + DataPack data = new DataPack(); + data.WriteCell(GetClientUserId(client)); + data.WriteCell(mode); + data.WriteCell(timeType); + + Transaction txn = SQL_CreateTransaction(); + + switch (timeType) + { + case TimeType_Nub:FormatEx(query, sizeof(query), sql_getrecentrecords, mode, LR_PLAYER_TOP_CUTOFF); + case TimeType_Pro:FormatEx(query, sizeof(query), sql_getrecentrecords_pro, mode, LR_PLAYER_TOP_CUTOFF); + } + txn.AddQuery(query); + + SQL_ExecuteTransaction(gH_DB, txn, DB_TxnSuccess_OpenRecentRecords, DB_TxnFailure_Generic_DataPack, data, DBPrio_Low); +} + +public void DB_TxnSuccess_OpenRecentRecords(Handle db, DataPack data, int numQueries, Handle[] results, any[] queryData) +{ + data.Reset(); + int client = GetClientOfUserId(data.ReadCell()); + int mode = data.ReadCell(); + int timeType = data.ReadCell(); + delete data; + + if (!IsValidClient(client)) + { + return; + } + + // Check if there are any times + if (SQL_GetRowCount(results[0]) == 0) + { + switch (timeType) + { + case TimeType_Nub:GOKZ_PrintToChat(client, true, "%t", "No Times Found"); + case TimeType_Pro:GOKZ_PrintToChat(client, true, "%t", "No Times Found (PRO)"); + } + return; + } + + Menu menu = new Menu(MenuHandler_RecentRecordsSubmenu); + menu.Pagination = 5; + + // Set submenu title + menu.SetTitle("%T", "Recent Records Submenu - Title", client, + gC_TimeTypeNames[timeType], gC_ModeNames[mode]); + + // Add submenu items + char display[256], mapName[64], playerName[33]; + int course; + float runTime; + + while (SQL_FetchRow(results[0])) + { + SQL_FetchString(results[0], 0, mapName, sizeof(mapName)); + course = SQL_FetchInt(results[0], 1); + SQL_FetchString(results[0], 3, playerName, sizeof(playerName)); + runTime = GOKZ_DB_TimeIntToFloat(SQL_FetchInt(results[0], 4)); + + if (course == 0) + { + FormatEx(display, sizeof(display), "%s - %s (%s)", + mapName, playerName, GOKZ_FormatTime(runTime)); + } + else + { + FormatEx(display, sizeof(display), "%s B%d - %s (%s)", + mapName, course, playerName, GOKZ_FormatTime(runTime)); + } + + menu.AddItem(IntToStringEx(SQL_FetchInt(results[0], 2)), display, ITEMDRAW_DISABLED); + } + + menu.Display(client, MENU_TIME_FOREVER); +} + + + +// =====[ MENUS ]===== + +void DisplayRecentRecordsModeMenu(int client) +{ + Menu menu = new Menu(MenuHandler_RecentRecordsMode); + menu.SetTitle("%T", "Recent Records Mode Menu - Title", client); + GOKZ_MenuAddModeItems(client, menu, false); + menu.Display(client, MENU_TIME_FOREVER); +} + +void DisplayRecentRecordsTimeTypeMenu(int client, int mode) +{ + recentRecordsMode[client] = mode; + + Menu menu = new Menu(MenuHandler_RecentRecordsTimeType); + menu.SetTitle("%T", "Recent Records Menu - Title", client, gC_ModeNames[recentRecordsMode[client]]); + RecentRecordsTimeTypeAddItems(client, menu); + menu.Display(client, MENU_TIME_FOREVER); +} + +static void RecentRecordsTimeTypeAddItems(int client, Menu menu) +{ + char display[32]; + for (int timeType = 0; timeType < TIMETYPE_COUNT; timeType++) + { + FormatEx(display, sizeof(display), "%T", "Recent Records Menu - Record Type", client, gC_TimeTypeNames[timeType]); + menu.AddItem("", display, ITEMDRAW_DEFAULT); + } +} + + + +// =====[ MENU HANDLERS ]===== + +public int MenuHandler_RecentRecordsMode(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + DisplayRecentRecordsTimeTypeMenu(param1, param2); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + +public int MenuHandler_RecentRecordsTimeType(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + DB_OpenRecentRecords(param1, recentRecordsMode[param1], param2); + } + else if (action == MenuAction_Cancel && param2 == MenuCancel_Exit) + { + DisplayRecentRecordsModeMenu(param1); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + +public int MenuHandler_RecentRecordsSubmenu(Menu menu, MenuAction action, int param1, int param2) +{ + // TODO Menu item info is course's MapCourseID, but is currently not used + if (action == MenuAction_Cancel && param2 == MenuCancel_Exit) + { + DisplayRecentRecordsTimeTypeMenu(param1, recentRecordsMode[param1]); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} diff --git a/sourcemod/scripting/gokz-localranks/db/sql.sp b/sourcemod/scripting/gokz-localranks/db/sql.sp new file mode 100644 index 0000000..f768e9a --- /dev/null +++ b/sourcemod/scripting/gokz-localranks/db/sql.sp @@ -0,0 +1,411 @@ +/* + SQL query templates. +*/ + + + +// =====[ MAPS ]===== + +char sqlite_maps_alter1[] = "\ +ALTER TABLE Maps \ + ADD InRankedPool INTEGER NOT NULL DEFAULT '0'"; + +char mysql_maps_alter1[] = "\ +ALTER TABLE Maps \ + ADD InRankedPool TINYINT NOT NULL DEFAULT '0'"; + +char sqlite_maps_insertranked[] = "\ +INSERT OR IGNORE INTO Maps \ + (InRankedPool, Name) \ + VALUES (%d, '%s')"; + +char sqlite_maps_updateranked[] = "\ +UPDATE OR IGNORE Maps \ + SET InRankedPool=%d \ + WHERE Name = '%s'"; + +char mysql_maps_upsertranked[] = "\ +INSERT INTO Maps (InRankedPool, Name) \ + VALUES (%d, '%s') \ + ON DUPLICATE KEY UPDATE \ + InRankedPool=VALUES(InRankedPool)"; + +char sql_maps_reset_mappool[] = "\ +UPDATE Maps \ + SET InRankedPool=0"; + +char sql_maps_getname[] = "\ +SELECT Name \ + FROM Maps \ + WHERE MapID=%d"; + +char sql_maps_searchbyname[] = "\ +SELECT MapID, Name \ + FROM Maps \ + WHERE Name LIKE '%%%s%%' \ + ORDER BY (Name='%s') DESC, LENGTH(Name) \ + LIMIT 1"; + + + +// =====[ PLAYERS ]===== + +char sql_players_getalias[] = "\ +SELECT Alias \ + FROM Players \ + WHERE SteamID32=%d"; + +char sql_players_searchbyalias[] = "\ +SELECT SteamID32, Alias \ + FROM Players \ + WHERE Players.Cheater=0 AND LOWER(Alias) LIKE '%%%s%%' \ + ORDER BY (LOWER(Alias)='%s') DESC, LastPlayed DESC \ + LIMIT 1"; + + + +// =====[ MAPCOURSES ]===== + +char sql_mapcourses_findid[] = "\ +SELECT MapCourseID \ + FROM MapCourses \ + WHERE MapID=%d AND Course=%d"; + + + +// =====[ GENERAL ]===== + +char sql_getpb[] = "\ +SELECT Times.RunTime, Times.Teleports \ + FROM Times \ + INNER JOIN MapCourses ON MapCourses.MapCourseID=Times.MapCourseID \ + WHERE Times.SteamID32=%d AND MapCourses.MapID=%d \ + AND MapCourses.Course=%d AND Times.Mode=%d \ + ORDER BY Times.RunTime \ + LIMIT %d"; + +char sql_getpbpro[] = "\ +SELECT Times.RunTime \ + FROM Times \ + INNER JOIN MapCourses ON MapCourses.MapCourseID=Times.MapCourseID \ + WHERE Times.SteamID32=%d AND MapCourses.MapID=%d \ + AND MapCourses.Course=%d AND Times.Mode=%d AND Times.Teleports=0 \ + ORDER BY Times.RunTime \ + LIMIT %d"; + +char sql_getmaptop[] = "\ +SELECT t.TimeID, t.SteamID32, p.Alias, t.RunTime AS PBTime, t.Teleports \ + FROM Times t \ + INNER JOIN MapCourses mc ON mc.MapCourseID=t.MapCourseID \ + INNER JOIN Players p ON p.SteamID32=t.SteamID32 \ + LEFT OUTER JOIN Times t2 ON t2.SteamID32=t.SteamID32 \ + AND t2.MapCourseID=t.MapCourseID AND t2.Mode=t.Mode AND t2.RunTime<t.RunTime \ + WHERE t2.TimeID IS NULL AND p.Cheater=0 AND mc.MapID=%d AND mc.Course=%d AND t.Mode=%d \ + ORDER BY PBTime \ + LIMIT %d"; + +char sql_getmaptoppro[] = "\ +SELECT t.TimeID, t.SteamID32, p.Alias, t.RunTime AS PBTime, t.Teleports \ + FROM Times t \ + INNER JOIN MapCourses mc ON mc.MapCourseID=t.MapCourseID \ + INNER JOIN Players p ON p.SteamID32=t.SteamID32 \ + LEFT OUTER JOIN Times t2 ON t2.SteamID32=t.SteamID32 AND t2.MapCourseID=t.MapCourseID \ + AND t2.Mode=t.Mode AND t2.RunTime<t.RunTime AND t.Teleports=0 AND t2.Teleports=0 \ + WHERE t2.TimeID IS NULL AND p.Cheater=0 AND mc.MapID=%d \ + AND mc.Course=%d AND t.Mode=%d AND t.Teleports=0 \ + ORDER BY PBTime \ + LIMIT %d"; + +char sql_getwrs[] = "\ +SELECT MIN(Times.RunTime), MapCourses.Course, Times.Mode \ + FROM Times \ + INNER JOIN MapCourses ON MapCourses.MapCourseID=Times.MapCourseID \ + INNER JOIN Players ON Players.SteamID32=Times.SteamID32 \ + WHERE Players.Cheater=0 AND MapCourses.MapID=%d \ + GROUP BY MapCourses.Course, Times.Mode"; + +char sql_getwrspro[] = "\ +SELECT MIN(Times.RunTime), MapCourses.Course, Times.Mode \ + FROM Times \ + INNER JOIN MapCourses ON MapCourses.MapCourseID=Times.MapCourseID \ + INNER JOIN Players ON Players.SteamID32=Times.SteamID32 \ + WHERE Players.Cheater=0 AND MapCourses.MapID=%d AND Times.Teleports=0 \ + GROUP BY MapCourses.Course, Times.Mode"; + +char sql_getpbs[] = "\ +SELECT MIN(Times.RunTime), MapCourses.Course, Times.Mode \ + FROM Times \ + INNER JOIN MapCourses ON MapCourses.MapCourseID=Times.MapCourseID \ + WHERE Times.SteamID32=%d AND MapCourses.MapID=%d \ + GROUP BY MapCourses.Course, Times.Mode"; + +char sql_getpbspro[] = "\ +SELECT MIN(Times.RunTime), MapCourses.Course, Times.Mode \ + FROM Times \ + INNER JOIN MapCourses ON MapCourses.MapCourseID=Times.MapCourseID \ + WHERE Times.SteamID32=%d AND MapCourses.MapID=%d AND Times.Teleports=0 \ + GROUP BY MapCourses.Course, Times.Mode"; + +char sql_getmaprank[] = "\ +SELECT COUNT(DISTINCT Times.SteamID32) \ + FROM Times \ + INNER JOIN MapCourses ON MapCourses.MapCourseID=Times.MapCourseID \ + INNER JOIN Players ON Players.SteamID32=Times.SteamID32 \ + WHERE Players.Cheater=0 AND MapCourses.MapID=%d AND MapCourses.Course=%d \ + AND Times.Mode=%d AND Times.RunTime < \ + (SELECT MIN(Times.RunTime) \ + FROM Times \ + INNER JOIN MapCourses ON MapCourses.MapCourseID=Times.MapCourseID \ + INNER JOIN Players ON Players.SteamID32=Times.SteamID32 \ + WHERE Players.Cheater=0 AND Times.SteamID32=%d AND MapCourses.MapID=%d \ + AND MapCourses.Course=%d AND Times.Mode=%d) \ + + 1"; + +char sql_getmaprankpro[] = "\ +SELECT COUNT(DISTINCT Times.SteamID32) \ + FROM Times \ + INNER JOIN MapCourses ON MapCourses.MapCourseID=Times.MapCourseID \ + INNER JOIN Players ON Players.SteamID32=Times.SteamID32 \ + WHERE Players.Cheater=0 AND MapCourses.MapID=%d AND MapCourses.Course=%d \ + AND Times.Mode=%d AND Times.Teleports=0 \ + AND Times.RunTime < \ + (SELECT MIN(Times.RunTime) \ + FROM Times \ + INNER JOIN MapCourses ON MapCourses.MapCourseID=Times.MapCourseID \ + INNER JOIN Players ON Players.SteamID32=Times.SteamID32 \ + WHERE Players.Cheater=0 AND Times.SteamID32=%d AND MapCourses.MapID=%d \ + AND MapCourses.Course=%d AND Times.Mode=%d AND Times.Teleports=0) \ + + 1"; + +char sql_getlowestmaprank[] = "\ +SELECT COUNT(DISTINCT Times.SteamID32) \ + FROM Times \ + INNER JOIN MapCourses ON MapCourses.MapCourseID=Times.MapCourseID \ + INNER JOIN Players ON Players.SteamID32=Times.SteamID32 \ + WHERE Players.Cheater=0 AND MapCourses.MapID=%d \ + AND MapCourses.Course=%d AND Times.Mode=%d"; + +char sql_getlowestmaprankpro[] = "\ +SELECT COUNT(DISTINCT Times.SteamID32) \ + FROM Times \ + INNER JOIN MapCourses ON MapCourses.MapCourseID=Times.MapCourseID \ + INNER JOIN Players ON Players.SteamID32=Times.SteamID32 \ + WHERE Players.Cheater=0 AND MapCourses.MapID=%d \ + AND MapCourses.Course=%d AND Times.Mode=%d AND Times.Teleports=0"; + +char sql_getcount_maincourses[] = "\ +SELECT COUNT(*) \ + FROM MapCourses \ + INNER JOIN Maps ON Maps.MapID=MapCourses.MapID \ + WHERE Maps.InRankedPool=1 AND MapCourses.Course=0"; + +char sql_getcount_maincoursescompleted[] = "\ +SELECT COUNT(DISTINCT Times.MapCourseID) \ + FROM Times \ + INNER JOIN MapCourses ON MapCourses.MapCourseID=Times.MapCourseID \ + INNER JOIN Maps ON Maps.MapID=MapCourses.MapID \ + WHERE Maps.InRankedPool=1 AND MapCourses.Course=0 \ + AND Times.SteamID32=%d AND Times.Mode=%d"; + +char sql_getcount_maincoursescompletedpro[] = "\ +SELECT COUNT(DISTINCT Times.MapCourseID) \ + FROM Times \ + INNER JOIN MapCourses ON MapCourses.MapCourseID=Times.MapCourseID \ + INNER JOIN Maps ON Maps.MapID=MapCourses.MapID \ + WHERE Maps.InRankedPool=1 AND MapCourses.Course=0 \ + AND Times.SteamID32=%d AND Times.Mode=%d AND Times.Teleports=0"; + +char sql_getcount_bonuses[] = "\ +SELECT COUNT(*) \ + FROM MapCourses \ + INNER JOIN Maps ON Maps.MapID=MapCourses.MapID \ + WHERE Maps.InRankedPool=1 AND MapCourses.Course>0"; + +char sql_getcount_bonusescompleted[] = "\ +SELECT COUNT(DISTINCT Times.MapCourseID) \ + FROM Times \ + INNER JOIN MapCourses ON MapCourses.MapCourseID=Times.MapCourseID \ + INNER JOIN Maps ON Maps.MapID=MapCourses.MapID \ + WHERE Maps.InRankedPool=1 AND MapCourses.Course>0 \ + AND Times.SteamID32=%d AND Times.Mode=%d"; + +char sql_getcount_bonusescompletedpro[] = "\ +SELECT COUNT(DISTINCT Times.MapCourseID) \ + FROM Times \ + INNER JOIN MapCourses ON MapCourses.MapCourseID=Times.MapCourseID \ + INNER JOIN Maps ON Maps.MapID=MapCourses.MapID \ + WHERE Maps.InRankedPool=1 AND MapCourses.Course>0 \ + AND Times.SteamID32=%d AND Times.Mode=%d AND Times.Teleports=0"; + +char sql_gettopplayers[] = "\ +SELECT Players.SteamID32, Players.Alias, COUNT(*) AS RecordCount \ + FROM Times \ + INNER JOIN \ + (SELECT Times.MapCourseID, Times.Mode, MIN(Times.RunTime) AS RecordTime \ + FROM Times \ + INNER JOIN MapCourses ON MapCourses.MapCourseID=Times.MapCourseID \ + INNER JOIN Maps ON Maps.MapID=MapCourses.MapID \ + INNER JOIN Players ON Players.SteamID32=Times.SteamID32 \ + WHERE Players.Cheater=0 AND Maps.InRankedPool=1 AND MapCourses.Course=0 \ + AND Times.Mode=%d \ + GROUP BY Times.MapCourseID) Records \ + ON Times.MapCourseID=Records.MapCourseID AND Times.Mode=Records.Mode AND Times.RunTime=Records.RecordTime \ + INNER JOIN Players ON Players.SteamID32=Times.SteamID32 \ + GROUP BY Players.SteamID32, Players.Alias \ + ORDER BY RecordCount DESC \ + LIMIT %d"; // Doesn't include bonuses + +char sql_gettopplayerspro[] = "\ +SELECT Players.SteamID32, Players.Alias, COUNT(*) AS RecordCount \ + FROM Times \ + INNER JOIN \ + (SELECT Times.MapCourseID, Times.Mode, MIN(Times.RunTime) AS RecordTime \ + FROM Times \ + INNER JOIN MapCourses ON MapCourses.MapCourseID=Times.MapCourseID \ + INNER JOIN Maps ON Maps.MapID=MapCourses.MapID \ + INNER JOIN Players ON Players.SteamID32=Times.SteamID32 \ + WHERE Players.Cheater=0 AND Maps.InRankedPool=1 AND MapCourses.Course=0 \ + AND Times.Mode=%d AND Times.Teleports=0 \ + GROUP BY Times.MapCourseID) Records \ + ON Times.MapCourseID=Records.MapCourseID AND Times.Mode=Records.Mode AND Times.RunTime=Records.RecordTime AND Times.Teleports=0 \ + INNER JOIN Players ON Players.SteamID32=Times.SteamID32 \ + GROUP BY Players.SteamID32, Players.Alias \ + ORDER BY RecordCount DESC \ + LIMIT %d"; // Doesn't include bonuses + +char sql_getaverage[] = "\ +SELECT AVG(PBTime), COUNT(*) \ + FROM \ + (SELECT MIN(Times.RunTime) AS PBTime \ + FROM Times \ + INNER JOIN MapCourses ON Times.MapCourseID=MapCourses.MapCourseID \ + INNER JOIN Players ON Times.SteamID32=Players.SteamID32 \ + WHERE Players.Cheater=0 AND MapCourses.MapID=%d \ + AND MapCourses.Course=%d AND Times.Mode=%d \ + GROUP BY Times.SteamID32) AS PBTimes"; + +char sql_getaverage_pro[] = "\ +SELECT AVG(PBTime), COUNT(*) \ + FROM \ + (SELECT MIN(Times.RunTime) AS PBTime \ + FROM Times \ + INNER JOIN MapCourses ON Times.MapCourseID=MapCourses.MapCourseID \ + INNER JOIN Players ON Times.SteamID32=Players.SteamID32 \ + WHERE Players.Cheater=0 AND MapCourses.MapID=%d \ + AND MapCourses.Course=%d AND Times.Mode=%d AND Times.Teleports=0 \ + GROUP BY Times.SteamID32) AS PBTimes"; + +char sql_getrecentrecords[] = "\ +SELECT Maps.Name, MapCourses.Course, MapCourses.MapCourseID, Players.Alias, a.RunTime \ + FROM Times AS a \ + INNER JOIN MapCourses ON a.MapCourseID=MapCourses.MapCourseID \ + INNER JOIN Maps ON MapCourses.MapID=Maps.MapID \ + INNER JOIN Players ON a.SteamID32=Players.SteamID32 \ + WHERE Players.Cheater=0 AND Maps.InRankedPool AND a.Mode=%d \ + AND NOT EXISTS \ + (SELECT * \ + FROM Times AS b \ + WHERE a.MapCourseID=b.MapCourseID AND a.Mode=b.Mode \ + AND a.Created>b.Created AND a.RunTime>b.RunTime) \ + ORDER BY a.TimeID DESC \ + LIMIT %d"; + +char sql_getrecentrecords_pro[] = "\ +SELECT Maps.Name, MapCourses.Course, MapCourses.MapCourseID, Players.Alias, a.RunTime \ + FROM Times AS a \ + INNER JOIN MapCourses ON a.MapCourseID=MapCourses.MapCourseID \ + INNER JOIN Maps ON MapCourses.MapID=Maps.MapID \ + INNER JOIN Players ON a.SteamID32=Players.SteamID32 \ + WHERE Players.Cheater=0 AND Maps.InRankedPool AND a.Mode=%d AND a.Teleports=0 \ + AND NOT EXISTS \ + (SELECT * \ + FROM Times AS b \ + WHERE b.Teleports=0 AND a.MapCourseID=b.MapCourseID AND a.Mode=b.Mode \ + AND a.Created>b.Created AND a.RunTime>b.RunTime) \ + ORDER BY a.TimeID DESC \ + LIMIT %d"; + + + +// =====[ JUMPSTATS ]===== + +char sql_jumpstats_gettop[] = "\ +SELECT j.JumpID, p.SteamID32, p.Alias, j.Block, j.Distance, j.Strafes, j.Sync, j.Pre, j.Max, j.Airtime \ + FROM \ + Jumpstats j \ + INNER JOIN \ + Players p ON \ + p.SteamID32=j.SteamID32 AND \ + p.Cheater = 0 \ + INNER JOIN \ + ( \ + SELECT j.SteamID32, j.JumpType, j.Mode, j.IsBlockJump, MAX(j.Distance) BestDistance \ + FROM \ + Jumpstats j \ + INNER JOIN \ + ( \ + SELECT SteamID32, MAX(Block) AS MaxBlockDist \ + FROM \ + Jumpstats \ + WHERE \ + JumpType = %d AND \ + Mode = %d AND \ + IsBlockJump = %d \ + GROUP BY SteamID32 \ + ) MaxBlock ON \ + j.SteamID32 = MaxBlock.SteamID32 AND \ + j.Block = MaxBlock.MaxBlockDist \ + WHERE \ + j.JumpType = %d AND \ + j.Mode = %d AND \ + j.IsBlockJump = %d \ + GROUP BY j.SteamID32, j.JumpType, j.Mode, j.IsBlockJump \ + ) MaxDist ON \ + j.SteamID32 = MaxDist.SteamID32 AND \ + j.JumpType = MaxDist.JumpType AND \ + j.Mode = MaxDist.Mode AND \ + j.IsBlockJump = MaxDist.IsBlockJump AND \ + j.Distance = MaxDist.BestDistance \ + ORDER BY j.Block DESC, j.Distance DESC \ + LIMIT %d"; + +char sql_jumpstats_getrecord[] = "\ +SELECT JumpID, Distance, Block \ + FROM \ + Jumpstats rec \ + WHERE \ + SteamID32 = %d AND \ + JumpType = %d AND \ + Mode = %d AND \ + IsBlockJump = %d \ + ORDER BY Block DESC, Distance DESC"; + +char sql_jumpstats_getpbs[] = "\ +SELECT b.JumpID, b.JumpType, b.Distance, b.Strafes, b.Sync, b.Pre, b.Max, b.Airtime \ + FROM Jumpstats b \ + INNER JOIN ( \ + SELECT a.SteamID32, a.Mode, a.JumpType, MAX(a.Distance) Distance \ + FROM Jumpstats a \ + WHERE a.SteamID32=%d AND a.Mode=%d AND NOT a.IsBlockJump \ + GROUP BY a.JumpType, a.Mode, a.SteamID32 \ + ) a ON a.JumpType=b.JumpType AND a.Distance=b.Distance \ + WHERE a.SteamID32=b.SteamID32 AND a.Mode=b.Mode AND NOT b.IsBlockJump \ + ORDER BY b.JumpType"; + +char sql_jumpstats_getblockpbs[] = "\ +SELECT c.JumpID, c.JumpType, c.Block, c.Distance, c.Strafes, c.Sync, c.Pre, c.Max, c.Airtime \ + FROM Jumpstats c \ + INNER JOIN ( \ + SELECT a.SteamID32, a.Mode, a.JumpType, a.Block, MAX(b.Distance) Distance \ + FROM Jumpstats b \ + INNER JOIN ( \ + SELECT a.SteamID32, a.Mode, a.JumpType, MAX(a.Block) Block \ + FROM Jumpstats a \ + WHERE a.SteamID32=%d AND a.Mode=%d AND a.IsBlockJump \ + GROUP BY a.JumpType, a.Mode, a.SteamID32 \ + ) a ON a.JumpType=b.JumpType AND a.Block=b.Block \ + WHERE a.SteamID32=b.SteamID32 AND a.Mode=b.Mode AND b.IsBlockJump \ + GROUP BY a.JumpType, a.Mode, a.SteamID32, a.Block \ + ) b ON b.JumpType=c.JumpType AND b.Block=c.Block AND b.Distance=c.Distance \ + WHERE b.SteamID32=c.SteamID32 AND b.Mode=c.Mode AND c.IsBlockJump \ + ORDER BY c.JumpType"; diff --git a/sourcemod/scripting/gokz-localranks/db/update_ranked_map_pool.sp b/sourcemod/scripting/gokz-localranks/db/update_ranked_map_pool.sp new file mode 100644 index 0000000..ee9bd6d --- /dev/null +++ b/sourcemod/scripting/gokz-localranks/db/update_ranked_map_pool.sp @@ -0,0 +1,104 @@ +/* + Inserts a list of maps read from a file into the Maps table, + and updates them to be part of the ranked map pool. +*/ + + + +void DB_UpdateRankedMapPool(int client) +{ + File file = OpenFile(LR_CFG_MAP_POOL, "r"); + if (file == null) + { + LogError("Failed to load file: '%s'.", LR_CFG_MAP_POOL); + if (IsValidClient(client)) + { + GOKZ_PrintToChat(client, true, "%t", "Ranked Map Pool - Error"); + } + return; + } + + char map[256]; + int mapsCount = 0; + + Transaction txn = new Transaction(); + + // Reset all maps to be unranked + txn.AddQuery(sql_maps_reset_mappool); + + // Insert/Update maps in gokz-localranks-mappool.cfg to be ranked + while (file.ReadLine(map, sizeof(map))) + { + TrimString(map); + String_ToLower(map, map, sizeof(map)); + + // Ignore blank lines and comments + if (map[0] == '\0' || map[0] == ';' || (map[0] == '/' && map[1] == '/')) + { + continue; + } + + mapsCount++; + + switch (g_DBType) + { + case DatabaseType_SQLite: + { + char updateQuery[512]; + gH_DB.Format(updateQuery, sizeof(updateQuery), sqlite_maps_updateranked, 1, map); + + char insertQuery[512]; + gH_DB.Format(insertQuery, sizeof(insertQuery), sqlite_maps_insertranked, 1, map); + + txn.AddQuery(updateQuery); + txn.AddQuery(insertQuery); + } + case DatabaseType_MySQL: + { + char query[512]; + gH_DB.Format(query, sizeof(query), mysql_maps_upsertranked, 1, map); + + txn.AddQuery(query); + } + } + } + + delete file; + + if (mapsCount == 0) + { + LogError("No maps found in file: '%s'.", LR_CFG_MAP_POOL); + + if (IsValidClient(client)) + { + GOKZ_PrintToChat(client, true, "%t", "Ranked Map Pool - No Maps In File"); + GOKZ_PlayErrorSound(client); + } + + delete txn; + return; + } + + // Pass client user ID (or -1) as data + int data = -1; + if (IsValidClient(client)) + { + data = GetClientUserId(client); + } + + gH_DB.Execute(txn, DB_TxnSuccess_UpdateRankedMapPool, DB_TxnFailure_Generic, data); +} + +public void DB_TxnSuccess_UpdateRankedMapPool(Handle db, int userid, int numQueries, Handle[] results, any[] queryData) +{ + int client = GetClientOfUserId(userid); + if (IsValidClient(client)) + { + LogMessage("The ranked map pool was updated by %L.", client); + GOKZ_PrintToChat(client, true, "%t", "Ranked Map Pool - Success"); + } + else + { + LogMessage("The ranked map pool was updated."); + } +} diff --git a/sourcemod/scripting/gokz-localranks/misc.sp b/sourcemod/scripting/gokz-localranks/misc.sp new file mode 100644 index 0000000..0c6d96c --- /dev/null +++ b/sourcemod/scripting/gokz-localranks/misc.sp @@ -0,0 +1,319 @@ +/* + Miscellaneous functions. +*/ + + + +// =====[ COMPLETION MVP STARS ]===== + +void CompletionMVPStarsUpdate(int client) +{ + DB_GetCompletion(client, GetSteamAccountID(client), GOKZ_GetDefaultMode(), false); +} + +void CompletionMVPStarsUpdateAll() +{ + for (int client = 1; client <= MaxClients; client++) + { + if (IsClientInGame(client) && !IsFakeClient(client)) + { + CompletionMVPStarsUpdate(client); + } + } +} + + + +// =====[ ANNOUNCEMENTS ]===== + +void PrecacheAnnouncementSounds() +{ + if (!LoadSounds()) + { + SetFailState("Failed to load file: \"%s\".", LR_CFG_SOUNDS); + } +} + +static bool LoadSounds() +{ + KeyValues kv = new KeyValues("sounds"); + if (!kv.ImportFromFile(LR_CFG_SOUNDS)) + { + return false; + } + + char downloadPath[256]; + + kv.GetString("beatrecord", gC_BeatRecordSound, sizeof(gC_BeatRecordSound)); + FormatEx(downloadPath, sizeof(downloadPath), "sound/%s", gC_BeatRecordSound); + AddFileToDownloadsTable(downloadPath); + PrecacheSound(gC_BeatRecordSound, true); + + delete kv; + return true; +} + +static void PlayBeatRecordSound() +{ + GOKZ_EmitSoundToAll(gC_BeatRecordSound, _, "Server Record"); +} + +void AnnounceNewTime( + int client, + int course, + int mode, + float runTime, + int teleportsUsed, + bool firstTime, + float pbDiff, + int rank, + int maxRank, + bool firstTimePro, + float pbDiffPro, + int rankPro, + int maxRankPro) +{ + // Main Course + if (course == 0) + { + // Main Course PRO Times + if (teleportsUsed == 0) + { + if (firstTimePro) + { + GOKZ_PrintToChatAll(true, "%t", "New Time - First Time (PRO)", + client, GOKZ_FormatTime(runTime), rankPro, maxRankPro, gC_ModeNamesShort[mode]); + } + else if (pbDiffPro < 0) + { + GOKZ_PrintToChatAll(true, "%t", "New Time - Beat PB (PRO)", + client, GOKZ_FormatTime(runTime), GOKZ_FormatTime(FloatAbs(pbDiffPro)), rankPro, maxRankPro, gC_ModeNamesShort[mode]); + } + else + { + GOKZ_PrintToChatAll(true, "%t", "New Time - Miss PB (PRO)", + client, GOKZ_FormatTime(runTime), GOKZ_FormatTime(pbDiffPro), rankPro, maxRankPro, gC_ModeNamesShort[mode]); + } + } + // Main Course NUB Times + else + { + if (firstTime) + { + GOKZ_PrintToChatAll(true, "%t", "New Time - First Time", + client, GOKZ_FormatTime(runTime), rank, maxRank, gC_ModeNamesShort[mode]); + } + else if (pbDiff < 0) + { + GOKZ_PrintToChatAll(true, "%t", "New Time - Beat PB", + client, GOKZ_FormatTime(runTime), GOKZ_FormatTime(FloatAbs(pbDiff)), rank, maxRank, gC_ModeNamesShort[mode]); + } + else + { + GOKZ_PrintToChatAll(true, "%t", "New Time - Miss PB", + client, GOKZ_FormatTime(runTime), GOKZ_FormatTime(pbDiff), rank, maxRank, gC_ModeNamesShort[mode]); + } + } + } + // Bonus Course + else + { + // Bonus Course PRO Times + if (teleportsUsed == 0) + { + if (firstTimePro) + { + GOKZ_PrintToChatAll(true, "%t", "New Bonus Time - First Time (PRO)", + client, course, GOKZ_FormatTime(runTime), rankPro, maxRankPro, gC_ModeNamesShort[mode]); + } + else if (pbDiffPro < 0) + { + GOKZ_PrintToChatAll(true, "%t", "New Bonus Time - Beat PB (PRO)", + client, course, GOKZ_FormatTime(runTime), GOKZ_FormatTime(FloatAbs(pbDiffPro)), rankPro, maxRankPro, gC_ModeNamesShort[mode]); + } + else + { + GOKZ_PrintToChatAll(true, "%t", "New Bonus Time - Miss PB (PRO)", + client, course, GOKZ_FormatTime(runTime), GOKZ_FormatTime(pbDiffPro), rankPro, maxRankPro, gC_ModeNamesShort[mode]); + } + } + // Bonus Course NUB Times + else + { + if (firstTime) + { + GOKZ_PrintToChatAll(true, "%t", "New Bonus Time - First Time", + client, course, GOKZ_FormatTime(runTime), rank, maxRank, gC_ModeNamesShort[mode]); + } + else if (pbDiff < 0) + { + GOKZ_PrintToChatAll(true, "%t", "New Bonus Time - Beat PB", + client, course, GOKZ_FormatTime(runTime), GOKZ_FormatTime(FloatAbs(pbDiff)), rank, maxRank, gC_ModeNamesShort[mode]); + } + else + { + GOKZ_PrintToChatAll(true, "%t", "New Bonus Time - Miss PB", + client, course, GOKZ_FormatTime(runTime), GOKZ_FormatTime(pbDiff), rank, maxRank, gC_ModeNamesShort[mode]); + } + } + } +} + +void AnnounceNewRecord(int client, int course, int mode, int recordType) +{ + if (course == 0) + { + switch (recordType) + { + case RecordType_Nub: + { + GOKZ_PrintToChatAll(true, "%t", "New Record (NUB)", client, gC_ModeNamesShort[mode]); + } + case RecordType_Pro: + { + GOKZ_PrintToChatAll(true, "%t", "New Record (PRO)", client, gC_ModeNamesShort[mode]); + } + case RecordType_NubAndPro: + { + GOKZ_PrintToChatAll(true, "%t", "New Record (NUB and PRO)", client, gC_ModeNamesShort[mode]); + } + } + } + else + { + switch (recordType) + { + case RecordType_Nub: + { + GOKZ_PrintToChatAll(true, "%t", "New Bonus Record (NUB)", client, course, gC_ModeNamesShort[mode]); + } + case RecordType_Pro: + { + GOKZ_PrintToChatAll(true, "%t", "New Bonus Record (PRO)", client, course, gC_ModeNamesShort[mode]); + } + case RecordType_NubAndPro: + { + GOKZ_PrintToChatAll(true, "%t", "New Bonus Record (NUB and PRO)", client, course, course, gC_ModeNamesShort[mode]); + } + } + } + + PlayBeatRecordSound(); // Play sound! +} + + + +// =====[ MISSED RECORD TRACKING ]===== + +void ResetRecordMissed(int client) +{ + for (int timeType = 0; timeType < TIMETYPE_COUNT; timeType++) + { + gB_RecordMissed[client][timeType] = false; + } +} + +void UpdateRecordMissed(int client) +{ + if (!GOKZ_GetTimerRunning(client) || gB_RecordMissed[client][TimeType_Nub] && gB_RecordMissed[client][TimeType_Pro]) + { + return; + } + + int course = GOKZ_GetCourse(client); + int mode = GOKZ_GetCoreOption(client, Option_Mode); + float currentTime = GOKZ_GetTime(client); + + bool nubRecordExists = gB_RecordExistsCache[course][mode][TimeType_Nub]; + float nubRecordTime = gF_RecordTimesCache[course][mode][TimeType_Nub]; + bool nubRecordMissed = gB_RecordMissed[client][TimeType_Nub]; + bool proRecordExists = gB_RecordExistsCache[course][mode][TimeType_Pro]; + float proRecordTime = gF_RecordTimesCache[course][mode][TimeType_Pro]; + bool proRecordMissed = gB_RecordMissed[client][TimeType_Pro]; + + if (nubRecordExists && !nubRecordMissed && currentTime >= nubRecordTime) + { + gB_RecordMissed[client][TimeType_Nub] = true; + + // Check if nub record is also the pro record, and call the forward appropriately + if (proRecordExists && FloatAbs(nubRecordTime - proRecordTime) < EPSILON) + { + gB_RecordMissed[client][TimeType_Pro] = true; + Call_OnRecordMissed(client, nubRecordTime, course, mode, Style_Normal, RecordType_NubAndPro); + } + else + { + Call_OnRecordMissed(client, nubRecordTime, course, mode, Style_Normal, RecordType_Nub); + } + } + else if (proRecordExists && !proRecordMissed && currentTime >= proRecordTime) + { + gB_RecordMissed[client][TimeType_Pro] = true; + Call_OnRecordMissed(client, proRecordTime, course, mode, Style_Normal, RecordType_Pro); + } +} + + + +// =====[ MISSED PB TRACKING ]===== + +#define MISSED_PB_SOUND "buttons/button18.wav" + +void ResetPBMissed(int client) +{ + for (int timeType = 0; timeType < TIMETYPE_COUNT; timeType++) + { + gB_PBMissed[client][timeType] = false; + } +} + +void UpdatePBMissed(int client) +{ + if (!GOKZ_GetTimerRunning(client) || gB_PBMissed[client][TimeType_Nub] && gB_PBMissed[client][TimeType_Pro]) + { + return; + } + + int course = GOKZ_GetCourse(client); + int mode = GOKZ_GetCoreOption(client, Option_Mode); + float currentTime = GOKZ_GetTime(client); + + bool nubPBExists = gB_PBExistsCache[client][course][mode][TimeType_Nub]; + float nubPBTime = gF_PBTimesCache[client][course][mode][TimeType_Nub]; + bool nubPBMissed = gB_PBMissed[client][TimeType_Nub]; + bool proPBExists = gB_PBExistsCache[client][course][mode][TimeType_Pro]; + float proPBTime = gF_PBTimesCache[client][course][mode][TimeType_Pro]; + bool proPBMissed = gB_PBMissed[client][TimeType_Pro]; + + if (nubPBExists && !nubPBMissed && currentTime >= nubPBTime) + { + gB_PBMissed[client][TimeType_Nub] = true; + + // Check if nub PB is also the pro PB, and call the forward appropriately + if (proPBExists && FloatAbs(nubPBTime - proPBTime) < EPSILON) + { + gB_PBMissed[client][TimeType_Pro] = true; + Call_OnPBMissed(client, nubPBTime, course, mode, Style_Normal, RecordType_NubAndPro); + } + else + { + Call_OnPBMissed(client, nubPBTime, course, mode, Style_Normal, RecordType_Nub); + } + } + else if (proPBExists && !proPBMissed && currentTime >= proPBTime) + { + gB_PBMissed[client][TimeType_Pro] = true; + Call_OnPBMissed(client, proPBTime, course, mode, Style_Normal, RecordType_Pro); + } +} + +void DoPBMissedReport(int client, float pbTime, int recordType) +{ + switch (recordType) + { + case RecordType_Nub:GOKZ_PrintToChat(client, true, "%t", "Missed PB (NUB)", GOKZ_FormatTime(pbTime)); + case RecordType_Pro:GOKZ_PrintToChat(client, true, "%t", "Missed PB (PRO)", GOKZ_FormatTime(pbTime)); + case RecordType_NubAndPro:GOKZ_PrintToChat(client, true, "%t", "Missed PB (NUB and PRO)", GOKZ_FormatTime(pbTime)); + } + GOKZ_EmitSoundToClient(client, MISSED_PB_SOUND, _, "Missed PB"); +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-measure.sp b/sourcemod/scripting/gokz-measure.sp new file mode 100644 index 0000000..2360625 --- /dev/null +++ b/sourcemod/scripting/gokz-measure.sp @@ -0,0 +1,82 @@ +#include <sourcemod> + +#include <sdktools> + +#include <gokz/core> + +#undef REQUIRE_EXTENSIONS +#undef REQUIRE_PLUGIN +#include <updater> + +#pragma newdecls required +#pragma semicolon 1 + +/* + Lets players measure the distance between two points. + Credits to DaFox (https://forums.alliedmods.net/showthread.php?t=88830?t=88830) +*/ + + +public Plugin myinfo = +{ + name = "GOKZ Measure", + author = "DanZay", + description = "Provides tools for measuring things", + version = GOKZ_VERSION, + url = GOKZ_SOURCE_URL +}; + +#define UPDATER_URL GOKZ_UPDATER_BASE_URL..."gokz-measure.txt" +#define MEASURE_MIN_DIST 0.01 +int gI_BeamModel; +bool gB_Measuring[MAXPLAYERS + 1]; +bool gB_MeasurePosSet[MAXPLAYERS + 1][2]; +float gF_MeasurePos[MAXPLAYERS + 1][2][3]; +float gF_MeasureNormal[MAXPLAYERS + 1][2][3]; +Handle gH_P2PRed[MAXPLAYERS + 1]; +Handle gH_P2PGreen[MAXPLAYERS + 1]; + +#include "gokz-measure/measurer.sp" +#include "gokz-measure/commands.sp" +#include "gokz-measure/measure_menu.sp" + + +// =====[ PLUGIN EVENTS ]===== + +public APLRes AskPluginLoad2(Handle myself, bool late, char[] error, int err_max) +{ + RegPluginLibrary("gokz-measure"); + return APLRes_Success; +} + +public void OnPluginStart() +{ + LoadTranslations("gokz-measure.phrases"); + + RegisterCommands(); +} + +public void OnAllPluginsLoaded() +{ + if (LibraryExists("updater")) + { + Updater_AddPlugin(UPDATER_URL); + } +} + +public void OnLibraryAdded(const char[] name) +{ + if (StrEqual(name, "updater")) + { + Updater_AddPlugin(UPDATER_URL); + } +} + + + +// =====[ OTHER EVENTS ]===== + +public void OnMapStart() +{ + gI_BeamModel = PrecacheModel("materials/sprites/laserbeam.vmt", true); +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-measure/commands.sp b/sourcemod/scripting/gokz-measure/commands.sp new file mode 100644 index 0000000..5fe3028 --- /dev/null +++ b/sourcemod/scripting/gokz-measure/commands.sp @@ -0,0 +1,49 @@ +void RegisterCommands() +{ + RegConsoleCmd("+measure", CommandMeasureStart, "[KZ] Set the measure origin."); + RegConsoleCmd("-measure", CommandMeasureEnd, "[KZ] Set the measure origin."); + RegConsoleCmd("sm_measure", CommandMeasureMenu, "[KZ] Open the measurement menu."); + RegConsoleCmd("sm_measuremenu", CommandMeasureMenu, "[KZ] Open the measurement menu."); + RegConsoleCmd("sm_measureblock", CommandMeasureBlock, "[KZ] Measure the block distance."); +} + +public Action CommandMeasureMenu(int client, int args) +{ + DisplayMeasureMenu(client); + return Plugin_Handled; +} + +public Action CommandMeasureStart(int client, int args) +{ + if (!IsValidClient(client)) + { + return Plugin_Handled; + } + gB_Measuring[client] = true; + MeasureGetPos(client, 0); + return Plugin_Handled; +} + +public Action CommandMeasureEnd(int client, int args) +{ + if (!IsValidClient(client)) + { + return Plugin_Handled; + } + gB_Measuring[client] = false; + MeasureGetPos(client, 1); + MeasureDistance(client, MEASURE_MIN_DIST); + CreateTimer(4.9, Timer_DeletePoints, GetClientUserId(client)); + return Plugin_Handled; +} + +public Action CommandMeasureBlock(int client, int args) +{ + if (!IsValidClient(client)) + { + return Plugin_Handled; + } + MeasureBlock(client); + CreateTimer(4.9, Timer_DeletePoints, GetClientUserId(client)); + return Plugin_Handled; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-measure/measure_menu.sp b/sourcemod/scripting/gokz-measure/measure_menu.sp new file mode 100644 index 0000000..cf9deb3 --- /dev/null +++ b/sourcemod/scripting/gokz-measure/measure_menu.sp @@ -0,0 +1,82 @@ +#define ITEM_INFO_POINT_A "a" +#define ITEM_INFO_POINT_B "b" +#define ITEM_INFO_GET_DISTANCE "get" +#define ITEM_INFO_GET_BLOCK_DISTANCE "block" + +// =====[ PUBLIC ]===== + +void DisplayMeasureMenu(int client, bool reset = true) +{ + if (reset) + { + MeasureResetPos(client); + } + + Menu menu = new Menu(MenuHandler_Measure); + menu.SetTitle("%T", "Measure Menu - Title", client); + MeasureMenuAddItems(client, menu); + menu.Display(client, MENU_TIME_FOREVER); +} + + + +// =====[ EVENTS ]===== + +public int MenuHandler_Measure(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + char info[16]; + menu.GetItem(param2, info, sizeof(info)); + + if (StrEqual(info, ITEM_INFO_POINT_A, false)) + { + MeasureGetPos(param1, 0); + } + else if (StrEqual(info, ITEM_INFO_POINT_B, false)) + { + MeasureGetPos(param1, 1); + } + else if (StrEqual(info, ITEM_INFO_GET_DISTANCE, false)) + { + MeasureDistance(param1); + } + else if (StrEqual(info, ITEM_INFO_GET_BLOCK_DISTANCE, false)) + { + if (!MeasureBlock(param1)) + { + DisplayMeasureMenu(param1, false); + } + } + + DisplayMeasureMenu(param1, false); + } + else if (action == MenuAction_Cancel) + { + MeasureResetPos(param1); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + + + +// =====[ PRIVATE ]===== + +static void MeasureMenuAddItems(int client, Menu menu) +{ + char display[32]; + + FormatEx(display, sizeof(display), "%T", "Measure Menu - Point A", client); + menu.AddItem(ITEM_INFO_POINT_A, display); + FormatEx(display, sizeof(display), "%T", "Measure Menu - Point B", client); + menu.AddItem(ITEM_INFO_POINT_B, display); + FormatEx(display, sizeof(display), "%T\n ", "Measure Menu - Get Distance", client); + menu.AddItem(ITEM_INFO_GET_DISTANCE, display); + FormatEx(display, sizeof(display), "%T", "Measure Menu - Get Block Distance", client); + menu.AddItem(ITEM_INFO_GET_BLOCK_DISTANCE, display); +} + diff --git a/sourcemod/scripting/gokz-measure/measurer.sp b/sourcemod/scripting/gokz-measure/measurer.sp new file mode 100644 index 0000000..f88e79c --- /dev/null +++ b/sourcemod/scripting/gokz-measure/measurer.sp @@ -0,0 +1,231 @@ +// =====[ PUBLIC ]===== + +void MeasureGetPos(int client, int arg) +{ + float origin[3]; + float angles[3]; + + GetClientEyePosition(client, origin); + GetClientEyeAngles(client, angles); + + MeasureGetPosEx(client, arg, origin, angles); +} + +void MeasureResetPos(int client) +{ + delete gH_P2PRed[client]; + delete gH_P2PGreen[client]; + + gB_MeasurePosSet[client][0] = false; + gB_MeasurePosSet[client][1] = false; + + gF_MeasurePos[client][0][0] = 0.0; // This is stupid. + gF_MeasurePos[client][0][1] = 0.0; + gF_MeasurePos[client][0][2] = 0.0; + gF_MeasurePos[client][1][0] = 0.0; + gF_MeasurePos[client][1][1] = 0.0; + gF_MeasurePos[client][1][2] = 0.0; +} + +bool MeasureBlock(int client) +{ + float angles[3]; + MeasureGetPos(client, 0); + GetVectorAngles(gF_MeasureNormal[client][0], angles); + MeasureGetPosEx(client, 1, gF_MeasurePos[client][0], angles); + AddVectors(gF_MeasureNormal[client][0], gF_MeasureNormal[client][1], angles); + if (GetVectorLength(angles, true) > EPSILON || + FloatAbs(gF_MeasureNormal[client][0][2]) > EPSILON || + FloatAbs(gF_MeasureNormal[client][1][2]) > EPSILON) + { + GOKZ_PrintToChat(client, true, "%t", "Measure Failure (Blocks not aligned)"); + GOKZ_PlayErrorSound(client); + return false; + } + GOKZ_PrintToChat(client, true, "%t", "Block Measure Result", RoundFloat(GetVectorHorizontalDistance(gF_MeasurePos[client][0], gF_MeasurePos[client][1]))); + MeasureBeam(client, gF_MeasurePos[client][0], gF_MeasurePos[client][1], 5.0, 0.2, 200, 200, 200); + return true; +} + +bool MeasureDistance(int client, float minDistToMeasureBlock = -1.0) +{ + // Find Distance + if (gB_MeasurePosSet[client][0] && gB_MeasurePosSet[client][1]) + { + float horizontalDist = GetVectorHorizontalDistance(gF_MeasurePos[client][0], gF_MeasurePos[client][1]); + float effectiveDist = CalcEffectiveDistance(gF_MeasurePos[client][0], gF_MeasurePos[client][1]); + float verticalDist = gF_MeasurePos[client][1][2] - gF_MeasurePos[client][0][2]; + if (minDistToMeasureBlock >= 0.0 && (horizontalDist <= minDistToMeasureBlock && verticalDist <= minDistToMeasureBlock)) + { + return MeasureBlock(client); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Measure Result", horizontalDist, effectiveDist, verticalDist); + MeasureBeam(client, gF_MeasurePos[client][0], gF_MeasurePos[client][1], 5.0, 0.2, 200, 200, 200); + } + return true; + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Measure Failure (Points Not Set)"); + GOKZ_PlayErrorSound(client); + return false; + } +} + +// =====[ TIMERS ]===== + +public Action Timer_P2PRed(Handle timer, int userid) +{ + int client = GetClientOfUserId(userid); + if (IsValidClient(client)) + { + P2PXBeam(client, 0); + } + return Plugin_Continue; +} + +public Action Timer_P2PGreen(Handle timer, int userid) +{ + int client = GetClientOfUserId(userid); + if (IsValidClient(client)) + { + P2PXBeam(client, 1); + } + return Plugin_Continue; +} + +public Action Timer_DeletePoints(Handle timer, int userid) +{ + int client = GetClientOfUserId(userid); + if (!gB_Measuring[client]) + { + MeasureResetPos(client); + } + return Plugin_Continue; +} + + +// =====[ PRIVATES ]===== +static void P2PXBeam(int client, int arg) +{ + float Origin0[3]; + float Origin1[3]; + float Origin2[3]; + float Origin3[3]; + + Origin0[0] = (gF_MeasurePos[client][arg][0] + 8.0); + Origin0[1] = (gF_MeasurePos[client][arg][1] + 8.0); + Origin0[2] = gF_MeasurePos[client][arg][2]; + + Origin1[0] = (gF_MeasurePos[client][arg][0] - 8.0); + Origin1[1] = (gF_MeasurePos[client][arg][1] - 8.0); + Origin1[2] = gF_MeasurePos[client][arg][2]; + + Origin2[0] = (gF_MeasurePos[client][arg][0] + 8.0); + Origin2[1] = (gF_MeasurePos[client][arg][1] - 8.0); + Origin2[2] = gF_MeasurePos[client][arg][2]; + + Origin3[0] = (gF_MeasurePos[client][arg][0] - 8.0); + Origin3[1] = (gF_MeasurePos[client][arg][1] + 8.0); + Origin3[2] = gF_MeasurePos[client][arg][2]; + + if (arg == 0) + { + MeasureBeam(client, Origin0, Origin1, 0.97, 0.2, 0, 255, 0); + MeasureBeam(client, Origin2, Origin3, 0.97, 0.2, 0, 255, 0); + } + else + { + MeasureBeam(client, Origin0, Origin1, 0.97, 0.2, 255, 0, 0); + MeasureBeam(client, Origin2, Origin3, 0.97, 0.2, 255, 0, 0); + } +} + +static void MeasureGetPosEx(int client, int arg, float origin[3], float angles[3]) +{ + Handle trace = TR_TraceRayFilterEx(origin, angles, MASK_PLAYERSOLID, RayType_Infinite, TraceEntityFilterPlayers, client); + + if (!TR_DidHit(trace)) + { + delete trace; + GOKZ_PrintToChat(client, true, "%t", "Measure Failure (Not Aiming at Solid)"); + GOKZ_PlayErrorSound(client); + return; + } + + TR_GetEndPosition(gF_MeasurePos[client][arg], trace); + TR_GetPlaneNormal(trace, gF_MeasureNormal[client][arg]); + delete trace; + + if (arg == 0) + { + delete gH_P2PRed[client]; + gB_MeasurePosSet[client][0] = true; + gH_P2PRed[client] = CreateTimer(1.0, Timer_P2PRed, GetClientUserId(client), TIMER_REPEAT); + P2PXBeam(client, 0); + } + else + { + delete gH_P2PGreen[client]; + gH_P2PGreen[client] = null; + gB_MeasurePosSet[client][1] = true; + P2PXBeam(client, 1); + gH_P2PGreen[client] = CreateTimer(1.0, Timer_P2PGreen, GetClientUserId(client), TIMER_REPEAT); + } +} + +static void MeasureBeam(int client, float vecStart[3], float vecEnd[3], float life, float width, int r, int g, int b) +{ + TE_Start("BeamPoints"); + TE_WriteNum("m_nModelIndex", gI_BeamModel); + TE_WriteNum("m_nHaloIndex", 0); + TE_WriteNum("m_nStartFrame", 0); + TE_WriteNum("m_nFrameRate", 0); + TE_WriteFloat("m_fLife", life); + TE_WriteFloat("m_fWidth", width); + TE_WriteFloat("m_fEndWidth", width); + TE_WriteNum("m_nFadeLength", 0); + TE_WriteFloat("m_fAmplitude", 0.0); + TE_WriteNum("m_nSpeed", 0); + TE_WriteNum("r", r); + TE_WriteNum("g", g); + TE_WriteNum("b", b); + TE_WriteNum("a", 255); + TE_WriteNum("m_nFlags", 0); + TE_WriteVector("m_vecStartPoint", vecStart); + TE_WriteVector("m_vecEndPoint", vecEnd); + TE_SendToClient(client); +} + +// Calculates the minimum equivalent jumpstat distance to go between the two points +static float CalcEffectiveDistance(const float pointA[3], const float pointB[3]) +{ + float Ax = FloatMin(pointA[0], pointB[0]); + float Bx = FloatMax(pointA[0], pointB[0]); + float Ay = FloatMin(pointA[1], pointB[1]); + float By = FloatMax(pointA[1], pointB[1]); + + if (Bx - Ax < 32.0) + { + Ax = Bx; + } + else + { + Ax = Ax + 16.0; + Bx = Bx - 16.0; + } + + if (By - Ay < 32.0) + { + Ay = By; + } + else + { + Ay = Ay + 16.0; + By = By - 16.0; + } + + return SquareRoot(Pow(Ax - Bx, 2.0) + Pow(Ay - By, 2.0)) + 32.0; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-mode-kztimer.sp b/sourcemod/scripting/gokz-mode-kztimer.sp new file mode 100644 index 0000000..272652b --- /dev/null +++ b/sourcemod/scripting/gokz-mode-kztimer.sp @@ -0,0 +1,709 @@ +#include <sourcemod> + +#include <sdkhooks> +#include <sdktools> +#include <dhooks> + +#include <movementapi> + +#undef REQUIRE_EXTENSIONS +#undef REQUIRE_PLUGIN +#include <gokz/core> +#include <updater> + +#include <gokz/kzplayer> + +#pragma newdecls required +#pragma semicolon 1 + + + +public Plugin myinfo = +{ + name = "GOKZ Mode - KZTimer", + author = "DanZay", + description = "KZTimer mode for GOKZ", + version = GOKZ_VERSION, + url = GOKZ_SOURCE_URL +}; + +#define UPDATER_URL GOKZ_UPDATER_BASE_URL..."gokz-mode-kztimer.txt" + +#define MODE_VERSION 217 +#define DUCK_SPEED_NORMAL 8.0 +#define PRE_VELMOD_MAX 1.104 // Calculated 276/250 +#define PERF_SPEED_CAP 380.0 + +float gF_ModeCVarValues[MODECVAR_COUNT] = +{ + 6.5, // sv_accelerate + 0.0, // sv_accelerate_use_weapon_speed + 100.0, // sv_airaccelerate + 30.0, // sv_air_max_wishspeed + 1.0, // sv_enablebunnyhopping + 5.0, // sv_friction + 800.0, // sv_gravity + 301.993377, // sv_jump_impulse + 1.0, // sv_ladder_scale_speed + 0.0, // sv_ledge_mantle_helper + 320.0, // sv_maxspeed + 2000.0, // sv_maxvelocity + 0.0, // sv_staminajumpcost + 0.0, // sv_staminalandcost + 0.0, // sv_staminamax + 0.0, // sv_staminarecoveryrate + 0.7, // sv_standable_normal + 0.0, // sv_timebetweenducks + 0.7, // sv_walkable_normal + 10.0, // sv_wateraccelerate + 0.8, // sv_water_movespeed_multiplier + 0.0, // sv_water_swim_mode + 0.0, // sv_weapon_encumbrance_per_item + 0.0 // sv_weapon_encumbrance_scale +}; + +bool gB_GOKZCore; +ConVar gCV_ModeCVar[MODECVAR_COUNT]; +float gF_PreVelMod[MAXPLAYERS + 1]; +float gF_PreVelModLastChange[MAXPLAYERS + 1]; +float gF_RealPreVelMod[MAXPLAYERS + 1]; +int gI_PreTickCounter[MAXPLAYERS + 1]; +Handle gH_GetPlayerMaxSpeed; +DynamicDetour gH_CanUnduck; +int gI_TickCount[MAXPLAYERS + 1]; +DynamicDetour gH_AirAccelerate; +int gI_OldButtons[MAXPLAYERS + 1]; +int gI_OldFlags[MAXPLAYERS + 1]; +bool gB_OldOnGround[MAXPLAYERS + 1]; +float gF_OldVelocity[MAXPLAYERS + 1][3]; +bool gB_Jumpbugged[MAXPLAYERS + 1]; +int gI_OffsetCGameMovement_player; + + + +// =====[ PLUGIN EVENTS ]===== + +public void OnPluginStart() +{ + if (FloatAbs(1.0 / GetTickInterval() - 128.0) > EPSILON) + { + SetFailState("gokz-mode-kztimer only supports 128 tickrate servers."); + } + HookEvents(); + CreateConVars(); +} + +public void OnAllPluginsLoaded() +{ + if (LibraryExists("updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + if (LibraryExists("gokz-core")) + { + gB_GOKZCore = true; + GOKZ_SetModeLoaded(Mode_KZTimer, true, MODE_VERSION); + } + + for (int client = 1; client <= MaxClients; client++) + { + if (IsClientInGame(client)) + { + OnClientPutInServer(client); + } + } +} + +public void OnPluginEnd() +{ + if (gB_GOKZCore) + { + GOKZ_SetModeLoaded(Mode_KZTimer, false); + } +} + +public void OnLibraryAdded(const char[] name) +{ + if (StrEqual(name, "updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + else if (StrEqual(name, "gokz-core")) + { + gB_GOKZCore = true; + GOKZ_SetModeLoaded(Mode_KZTimer, true, MODE_VERSION); + } +} + +public void OnLibraryRemoved(const char[] name) +{ + gB_GOKZCore = gB_GOKZCore && !StrEqual(name, "gokz-core"); +} + + + +// =====[ CLIENT EVENTS ]===== + +public void OnClientPutInServer(int client) +{ + if (IsValidClient(client)) + { + HookClientEvents(client); + } + if (IsUsingMode(client)) + { + ReplicateConVars(client); + } +} + +public Action OnPlayerRunCmd(int client, int &buttons, int &impulse, float vel[3], float angles[3], int &weapon, int &subtype, int &cmdnum, int &tickcount, int &seed, int mouse[2]) +{ + if (!IsPlayerAlive(client) || !IsUsingMode(client)) + { + return Plugin_Continue; + } + + KZPlayer player = KZPlayer(client); + RemoveCrouchJumpBind(player, buttons); + gF_RealPreVelMod[player.ID] = CalcPrestrafeVelMod(player); + ReduceDuckSlowdown(player); + FixWaterBoost(player, buttons); + FixDisplacementStuck(player); + + gB_Jumpbugged[player.ID] = false; + gI_OldButtons[player.ID] = buttons; + gI_OldFlags[player.ID] = GetEntityFlags(client); + gB_OldOnGround[player.ID] = Movement_GetOnGround(client); + gI_TickCount[player.ID] = tickcount; + Movement_GetVelocity(client, gF_OldVelocity[client]); + return Plugin_Continue; +} + +public MRESReturn DHooks_OnGetPlayerMaxSpeed(int client, Handle hReturn) +{ + if (!IsPlayerAlive(client) || !IsUsingMode(client)) + { + return MRES_Ignored; + } + + DHookSetReturn(hReturn, SPEED_NORMAL * gF_RealPreVelMod[client]); + return MRES_Supercede; +} + +public MRESReturn DHooks_OnAirAccelerate_Pre(Address pThis, DHookParam hParams) +{ + int client = GOKZGetClientFromGameMovementAddress(pThis, gI_OffsetCGameMovement_player); + if (!IsPlayerAlive(client) || !IsUsingMode(client)) + { + return MRES_Ignored; + } + + // NOTE: Prestrafing changes GetPlayerMaxSpeed, which changes + // air acceleration, so remove gF_PreVelMod[client] from wishspeed/maxspeed. + // This also applies to when the player is ducked: their wishspeed is + // 85 and with prestrafing can be ~93. + float wishspeed = DHookGetParam(hParams, 2); + if (gF_PreVelMod[client] > 1.0) + { + DHookSetParam(hParams, 2, wishspeed / gF_PreVelMod[client]); + return MRES_ChangedHandled; + } + + return MRES_Ignored; +} + +public MRESReturn DHooks_OnCanUnduck_Pre(Address pThis, DHookReturn hReturn) +{ + int client = GOKZGetClientFromGameMovementAddress(pThis, gI_OffsetCGameMovement_player); + if (!IsPlayerAlive(client) || !IsUsingMode(client)) + { + return MRES_Ignored; + } + // Just landed fully ducked, you can't unduck. + if (Movement_GetLandingTick(client) == (gI_TickCount[client] - 1) && GetEntPropFloat(client, Prop_Send, "m_flDuckAmount") >= 1.0 && GetEntProp(client, Prop_Send, "m_bDucked")) + { + hReturn.Value = false; + return MRES_Supercede; + } + return MRES_Ignored; +} + +public void SDKHook_OnClientPreThink_Post(int client) +{ + if (!IsPlayerAlive(client) || !IsUsingMode(client)) + { + return; + } + + // Don't tweak convars if GOKZ isn't running + if (gB_GOKZCore) + { + TweakConVars(); + } +} + +public Action Movement_OnCategorizePositionPost(int client, float origin[3], float velocity[3]) +{ + if (!IsPlayerAlive(client) || !IsUsingMode(client)) + { + return Plugin_Continue; + } + return SlopeFix(client, origin, velocity); +} + +public Action Movement_OnJumpPre(int client, float origin[3], float velocity[3]) +{ + if (!IsPlayerAlive(client) || !IsUsingMode(client)) + { + return Plugin_Continue; + } + + KZPlayer player = KZPlayer(client); + return TweakJump(player, velocity); +} + +public Action Movement_OnJumpPost(int client) +{ + if (!IsUsingMode(client)) + { + return Plugin_Continue; + } + + KZPlayer player = KZPlayer(client); + if (gB_GOKZCore) + { + player.GOKZHitPerf = player.HitPerf; + player.GOKZTakeoffSpeed = player.TakeoffSpeed; + } + return Plugin_Continue; +} + +public void Movement_OnStopTouchGround(int client) +{ + if (!IsUsingMode(client)) + { + return; + } + + KZPlayer player = KZPlayer(client); + if (gB_GOKZCore) + { + player.GOKZHitPerf = player.HitPerf; + player.GOKZTakeoffSpeed = player.TakeoffSpeed; + } +} + +public void Movement_OnChangeMovetype(int client, MoveType oldMovetype, MoveType newMovetype) +{ + if (!IsPlayerAlive(client) || !IsUsingMode(client)) + { + return; + } + + KZPlayer player = KZPlayer(client); + if (gB_GOKZCore && newMovetype == MOVETYPE_WALK) + { + player.GOKZHitPerf = false; + player.GOKZTakeoffSpeed = player.TakeoffSpeed; + } +} + +public void GOKZ_OnOptionChanged(int client, const char[] option, any newValue) +{ + if (StrEqual(option, gC_CoreOptionNames[Option_Mode]) && newValue == Mode_KZTimer) + { + ReplicateConVars(client); + } +} + +public void GOKZ_OnCountedTeleport_Post(int client) +{ + KZPlayer player = KZPlayer(client); + ResetPrestrafeVelMod(player); +} + + + +// =====[ GENERAL ]===== + +bool IsUsingMode(int client) +{ + // If GOKZ core isn't loaded, then apply mode at all times + return !gB_GOKZCore || GOKZ_GetCoreOption(client, Option_Mode) == Mode_KZTimer; +} + +void HookEvents() +{ + GameData gameData = LoadGameConfigFile("movementapi.games"); + if (gameData == INVALID_HANDLE) + { + SetFailState("Failed to find movementapi.games config"); + } + + int offset = gameData.GetOffset("GetPlayerMaxSpeed"); + if (offset == -1) + { + SetFailState("Failed to get GetPlayerMaxSpeed offset"); + } + gH_GetPlayerMaxSpeed = DHookCreate(offset, HookType_Entity, ReturnType_Float, ThisPointer_CBaseEntity, DHooks_OnGetPlayerMaxSpeed); + + gH_AirAccelerate = DynamicDetour.FromConf(gameData, "CGameMovement::AirAccelerate"); + if (gH_AirAccelerate == INVALID_HANDLE) + { + SetFailState("Failed to find CGameMovement::AirAccelerate function signature"); + } + + if (!gH_AirAccelerate.Enable(Hook_Pre, DHooks_OnAirAccelerate_Pre)) + { + SetFailState("Failed to enable detour on CGameMovement::AirAccelerate"); + } + + char buffer[16]; + if (!gameData.GetKeyValue("CGameMovement::player", buffer, sizeof(buffer))) + { + SetFailState("Failed to get CGameMovement::player offset."); + } + gI_OffsetCGameMovement_player = StringToInt(buffer); + + gameData = LoadGameConfigFile("gokz-core.games"); + gH_CanUnduck = DynamicDetour.FromConf(gameData, "CCSGameMovement::CanUnduck"); + if (gH_CanUnduck == INVALID_HANDLE) + { + SetFailState("Failed to find CCSGameMovement::CanUnduck function signature"); + } + + if (!gH_CanUnduck.Enable(Hook_Pre, DHooks_OnCanUnduck_Pre)) + { + SetFailState("Failed to enable detour on CCSGameMovement::CanUnduck"); + } + delete gameData; +} + +// =====[ CONVARS ]===== + +void CreateConVars() +{ + for (int cvar = 0; cvar < MODECVAR_COUNT; cvar++) + { + gCV_ModeCVar[cvar] = FindConVar(gC_ModeCVars[cvar]); + } +} + +void TweakConVars() +{ + for (int i = 0; i < MODECVAR_COUNT; i++) + { + gCV_ModeCVar[i].FloatValue = gF_ModeCVarValues[i]; + } +} + +void ReplicateConVars(int client) +{ + // Replicate convars only when player changes mode in GOKZ + // so that lagg isn't caused by other players using other + // modes, and also as an optimisation. + + if (IsFakeClient(client)) + { + return; + } + + for (int i = 0; i < MODECVAR_COUNT; i++) + { + gCV_ModeCVar[i].ReplicateToClient(client, FloatToStringEx(gF_ModeCVarValues[i])); + } +} + + + +// =====[ VELOCITY MODIFIER ]===== + +void HookClientEvents(int client) +{ + DHookEntity(gH_GetPlayerMaxSpeed, true, client); + SDKHook(client, SDKHook_PreThinkPost, SDKHook_OnClientPreThink_Post); +} + +// Adapted from KZTimerGlobal +float CalcPrestrafeVelMod(KZPlayer player) +{ + if (!player.OnGround) + { + return gF_PreVelMod[player.ID]; + } + + if (!player.Turning) + { + if (GetEngineTime() - gF_PreVelModLastChange[player.ID] > 0.2) + { + gF_PreVelMod[player.ID] = 1.0; + gF_PreVelModLastChange[player.ID] = GetEngineTime(); + } + else if (gF_PreVelMod[player.ID] > PRE_VELMOD_MAX + 0.007) + { + return PRE_VELMOD_MAX - 0.001; // Returning without setting the variable is intentional + } + } + else if ((player.Buttons & IN_MOVELEFT || player.Buttons & IN_MOVERIGHT) && player.Speed > 248.9) + { + float increment = 0.0009; + if (gF_PreVelMod[player.ID] > 1.04) + { + increment = 0.001; + } + + bool forwards = GetClientMovingDirection(player.ID, false) > 0.0; + + if ((player.Buttons & IN_MOVERIGHT && player.TurningRight || player.TurningLeft && !forwards) + || (player.Buttons & IN_MOVELEFT && player.TurningLeft || player.TurningRight && !forwards)) + { + gI_PreTickCounter[player.ID]++; + + if (gI_PreTickCounter[player.ID] < 75) + { + gF_PreVelMod[player.ID] += increment; + if (gF_PreVelMod[player.ID] > PRE_VELMOD_MAX) + { + if (gF_PreVelMod[player.ID] > PRE_VELMOD_MAX + 0.007) + { + gF_PreVelMod[player.ID] = PRE_VELMOD_MAX - 0.001; + } + else + { + gF_PreVelMod[player.ID] -= 0.007; + } + } + gF_PreVelMod[player.ID] += increment; + } + else + { + gF_PreVelMod[player.ID] -= 0.0045; + gI_PreTickCounter[player.ID] -= 2; + + if (gF_PreVelMod[player.ID] < 1.0) + { + gF_PreVelMod[player.ID] = 1.0; + gI_PreTickCounter[player.ID] = 0; + } + } + } + else + { + gF_PreVelMod[player.ID] -= 0.04; + + if (gF_PreVelMod[player.ID] < 1.0) + { + gF_PreVelMod[player.ID] = 1.0; + } + } + + gF_PreVelModLastChange[player.ID] = GetEngineTime(); + } + else + { + gI_PreTickCounter[player.ID] = 0; + return 1.0; // Returning without setting the variable is intentional + } + + return gF_PreVelMod[player.ID]; +} + +// Adapted from KZTimerGlobal +float GetClientMovingDirection(int client, bool ladder) +{ + float fVelocity[3]; + GetEntPropVector(client, Prop_Data, "m_vecAbsVelocity", fVelocity); + + float fEyeAngles[3]; + GetClientEyeAngles(client, fEyeAngles); + + if (fEyeAngles[0] > 70.0)fEyeAngles[0] = 70.0; + if (fEyeAngles[0] < -70.0)fEyeAngles[0] = -70.0; + + float fViewDirection[3]; + + if (ladder) + { + GetEntPropVector(client, Prop_Send, "m_vecLadderNormal", fViewDirection); + } + else + { + GetAngleVectors(fEyeAngles, fViewDirection, NULL_VECTOR, NULL_VECTOR); + } + + NormalizeVector(fVelocity, fVelocity); + NormalizeVector(fViewDirection, fViewDirection); + + float direction = GetVectorDotProduct(fVelocity, fViewDirection); + if (ladder) + { + direction = direction * -1; + } + return direction; +} + +void ResetPrestrafeVelMod(KZPlayer player) +{ + gF_PreVelMod[player.ID] = 1.0; + gI_PreTickCounter[player.ID] = 0; +} + + + +// =====[ SLOPEFIX ]===== + +// ORIGINAL AUTHORS : Mev & Blacky +// URL : https://forums.alliedmods.net/showthread.php?p=2322788 +// NOTE : Modified by DanZay for this plugin + +Action SlopeFix(int client, float origin[3], float velocity[3]) +{ + KZPlayer player = KZPlayer(client); + // Check if player landed on the ground + if (Movement_GetOnGround(client) && !gB_OldOnGround[client]) + { + float vMins[] = {-16.0, -16.0, 0.0}; + // Always use ducked hull as the real hull size isn't updated yet. + // Might cause slight issues in extremely rare scenarios. + float vMaxs[] = {16.0, 16.0, 54.0}; + + float vEndPos[3]; + vEndPos[0] = origin[0]; + vEndPos[1] = origin[1]; + vEndPos[2] = origin[2] - gF_ModeCVarValues[ModeCVar_MaxVelocity]; + + // Set up and do tracehull to find out if the player landed on a slope + TR_TraceHullFilter(origin, vEndPos, vMins, vMaxs, MASK_PLAYERSOLID_BRUSHONLY, TraceRayDontHitSelf, client); + + if (TR_DidHit()) + { + // Gets the normal vector of the surface under the player + float vPlane[3], vLast[3]; + player.GetLandingVelocity(vLast); + TR_GetPlaneNormal(null, vPlane); + + // Make sure it's not flat ground and not a surf ramp (1.0 = flat ground, < 0.7 = surf ramp) + if (0.7 <= vPlane[2] < 1.0) + { + /* + Copy the ClipVelocity function from sdk2013 + (https://mxr.alliedmods.net/hl2sdk-sdk2013/source/game/shared/gamemovement.cpp#3145) + With some minor changes to make it actually work + */ + + float fBackOff = GetVectorDotProduct(vLast, vPlane); + + float change, vVel[3]; + for (int i; i < 2; i++) + { + change = vPlane[i] * fBackOff; + vVel[i] = vLast[i] - change; + } + + float fAdjust = GetVectorDotProduct(vVel, vPlane); + if (fAdjust < 0.0) + { + for (int i; i < 2; i++) + { + vVel[i] -= (vPlane[i] * fAdjust); + } + } + + vVel[2] = 0.0; + vLast[2] = 0.0; + + // Make sure the player is going down a ramp by checking if they actually will gain speed from the boost + if (GetVectorLength(vVel) > GetVectorLength(vLast)) + { + CopyVector(vVel, velocity); + player.SetLandingVelocity(velocity); + return Plugin_Changed; + } + } + } + } + return Plugin_Continue; +} + +public bool TraceRayDontHitSelf(int entity, int mask, any data) +{ + return entity != data && !(0 < entity <= MaxClients); +} + + + +// =====[ JUMPING ]===== + +Action TweakJump(KZPlayer player, float velocity[3]) +{ + if (player.HitPerf) + { + if (GetVectorHorizontalLength(velocity) > PERF_SPEED_CAP) + { + SetVectorHorizontalLength(velocity, PERF_SPEED_CAP); + return Plugin_Changed; + } + } + return Plugin_Continue; +} +// =====[ OTHER ]===== + +void FixWaterBoost(KZPlayer player, int buttons) +{ + if (GetEntProp(player.ID, Prop_Send, "m_nWaterLevel") >= 2) // WL_Waist = 2 + { + // If duck is being pressed and we're not already ducking or on ground + if (GetEntityFlags(player.ID) & (FL_DUCKING | FL_ONGROUND) == 0 + && buttons & IN_DUCK && ~gI_OldButtons[player.ID] & IN_DUCK) + { + float newOrigin[3]; + Movement_GetOrigin(player.ID, newOrigin); + newOrigin[2] += 9.0; + + TR_TraceHullFilter(newOrigin, newOrigin, view_as<float>({-16.0, -16.0, 0.0}), view_as<float>({16.0, 16.0, 54.0}), MASK_PLAYERSOLID, TraceEntityFilterPlayers); + if (!TR_DidHit()) + { + TeleportEntity(player.ID, newOrigin, NULL_VECTOR, NULL_VECTOR); + } + } + } +} + +void FixDisplacementStuck(KZPlayer player) +{ + int flags = GetEntityFlags(player.ID); + bool unducked = ~flags & FL_DUCKING && gI_OldFlags[player.ID] & FL_DUCKING; + + float standingMins[] = {-16.0, -16.0, 0.0}; + float standingMaxs[] = {16.0, 16.0, 72.0}; + + if (unducked) + { + // check if we're stuck after unducking and if we're stuck then force duck + float origin[3]; + Movement_GetOrigin(player.ID, origin); + TR_TraceHullFilter(origin, origin, standingMins, standingMaxs, MASK_PLAYERSOLID, TraceEntityFilterPlayers); + + if (TR_DidHit()) + { + player.SetVelocity(gF_OldVelocity[player.ID]); + SetEntProp(player.ID, Prop_Send, "m_bDucking", true); + } + } +} + +void RemoveCrouchJumpBind(KZPlayer player, int &buttons) +{ + if (player.OnGround && buttons & IN_JUMP && !(gI_OldButtons[player.ID] & IN_JUMP) && !(gI_OldButtons[player.ID] & IN_DUCK)) + { + buttons &= ~IN_DUCK; + } +} + +void ReduceDuckSlowdown(KZPlayer player) +{ + if (GetEntProp(player.ID, Prop_Data, "m_afButtonReleased") & IN_DUCK) + { + Movement_SetDuckSpeed(player.ID, DUCK_SPEED_NORMAL); + } +} diff --git a/sourcemod/scripting/gokz-mode-simplekz.sp b/sourcemod/scripting/gokz-mode-simplekz.sp new file mode 100644 index 0000000..99d76ac --- /dev/null +++ b/sourcemod/scripting/gokz-mode-simplekz.sp @@ -0,0 +1,846 @@ +#include <sourcemod> + +#include <sdkhooks> +#include <sdktools> +#include <dhooks> + +#include <movementapi> + +#undef REQUIRE_EXTENSIONS +#undef REQUIRE_PLUGIN +#include <gokz/core> +#include <updater> + +#include <gokz/kzplayer> + +#pragma newdecls required +#pragma semicolon 1 + + + +public Plugin myinfo = +{ + name = "GOKZ Mode - SimpleKZ", + author = "DanZay", + description = "SimpleKZ mode for GOKZ", + version = GOKZ_VERSION, + url = GOKZ_SOURCE_URL +}; + +#define UPDATER_URL GOKZ_UPDATER_BASE_URL..."gokz-mode-simplekz.txt" + +#define MODE_VERSION 21 +#define PS_MAX_REWARD_TURN_RATE 0.703125 // Degrees per tick (90 degrees per second) +#define PS_MAX_TURN_RATE_DECREMENT 0.015625 // Degrees per tick (2 degrees per second) +#define PS_SPEED_MAX 26.54321 // Units +#define PS_SPEED_INCREMENT 0.35 // Units per tick +#define PS_SPEED_DECREMENT_MIDAIR 0.2824 // Units per tick (lose PS_SPEED_MAX in 0 offset jump i.e. 94 ticks) +#define PS_GRACE_TICKS 3 // No. of ticks allowed to fail prestrafe checks when prestrafing - helps players with low fps +#define DUCK_SPEED_NORMAL 8.0 +#define DUCK_SPEED_MINIMUM 6.0234375 // Equal to if you just ducked/unducked for the first time in a while + +float gF_ModeCVarValues[MODECVAR_COUNT] = +{ + 6.5, // sv_accelerate + 0.0, // sv_accelerate_use_weapon_speed + 100.0, // sv_airaccelerate + 30.0, // sv_air_max_wishspeed + 1.0, // sv_enablebunnyhopping + 5.2, // sv_friction + 800.0, // sv_gravity + 301.993377, // sv_jump_impulse + 1.0, // sv_ladder_scale_speed + 0.0, // sv_ledge_mantle_helper + 320.0, // sv_maxspeed + 3500.0, // sv_maxvelocity + 0.0, // sv_staminajumpcost + 0.0, // sv_staminalandcost + 0.0, // sv_staminamax + 0.0, // sv_staminarecoveryrate + 0.7, // sv_standable_normal + 0.0, // sv_timebetweenducks + 0.7, // sv_walkable_normal + 10.0, // sv_wateraccelerate + 0.8, // sv_water_movespeed_multiplier + 0.0, // sv_water_swim_mode + 0.0, // sv_weapon_encumbrance_per_item + 0.0 // sv_weapon_encumbrance_scale +}; + +bool gB_GOKZCore; +ConVar gCV_ModeCVar[MODECVAR_COUNT]; +bool gB_HitTweakedPerf[MAXPLAYERS + 1]; +int gI_Cmdnum[MAXPLAYERS + 1]; +float gF_PSBonusSpeed[MAXPLAYERS + 1]; +float gF_PSVelMod[MAXPLAYERS + 1]; +float gF_PSVelModLanding[MAXPLAYERS + 1]; +bool gB_PSTurningLeft[MAXPLAYERS + 1]; +float gF_PSTurnRate[MAXPLAYERS + 1]; +int gI_PSTicksSinceIncrement[MAXPLAYERS + 1]; +Handle gH_GetPlayerMaxSpeed; +DynamicDetour gH_CanUnduck; +int gI_TickCount[MAXPLAYERS + 1]; +DynamicDetour gH_AirAccelerate; +int gI_OldButtons[MAXPLAYERS + 1]; +int gI_OldFlags[MAXPLAYERS + 1]; +bool gB_OldOnGround[MAXPLAYERS + 1]; +float gF_OldOrigin[MAXPLAYERS + 1][3]; +float gF_OldAngles[MAXPLAYERS + 1][3]; +float gF_OldVelocity[MAXPLAYERS + 1][3]; +int gI_LastJumpButtonCmdnum[MAXPLAYERS + 1]; +int gI_OffsetCGameMovement_player; + + + +// =====[ PLUGIN EVENTS ]===== + +public void OnPluginStart() +{ + if (FloatAbs(1.0 / GetTickInterval() - 128.0) > EPSILON) + { + SetFailState("gokz-mode-simplekz only supports 128 tickrate servers."); + } + HookEvents(); + CreateConVars(); +} + +public void OnAllPluginsLoaded() +{ + if (LibraryExists("updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + if (LibraryExists("gokz-core")) + { + gB_GOKZCore = true; + GOKZ_SetModeLoaded(Mode_SimpleKZ, true, MODE_VERSION); + } + + for (int client = 1; client <= MaxClients; client++) + { + if (IsClientInGame(client)) + { + OnClientPutInServer(client); + } + } +} + +public void OnPluginEnd() +{ + if (gB_GOKZCore) + { + GOKZ_SetModeLoaded(Mode_SimpleKZ, false); + } +} + +public void OnLibraryAdded(const char[] name) +{ + if (StrEqual(name, "updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + else if (StrEqual(name, "gokz-core")) + { + gB_GOKZCore = true; + GOKZ_SetModeLoaded(Mode_SimpleKZ, true, MODE_VERSION); + } +} + +public void OnLibraryRemoved(const char[] name) +{ + gB_GOKZCore = gB_GOKZCore && !StrEqual(name, "gokz-core"); +} + + + +// =====[ CLIENT EVENTS ]===== + +public void OnClientPutInServer(int client) +{ + ResetClient(client); + if (IsValidClient(client)) + { + HookClientEvents(client); + } + if (IsUsingMode(client)) + { + ReplicateConVars(client); + } +} + +public Action OnPlayerRunCmd(int client, int &buttons, int &impulse, float vel[3], float angles[3], int &weapon, int &subtype, int &cmdnum, int &tickcount, int &seed, int mouse[2]) +{ + if (!IsPlayerAlive(client) || !IsUsingMode(client)) + { + return Plugin_Continue; + } + + KZPlayer player = KZPlayer(client); + RemoveCrouchJumpBind(player, buttons); + ReduceDuckSlowdown(player); + CalcPrestrafeVelMod(player, angles); + FixWaterBoost(player, buttons); + FixDisplacementStuck(player); + + gB_HitTweakedPerf[player.ID] = false; + gI_Cmdnum[player.ID] = cmdnum; + gI_OldButtons[player.ID] = buttons; + gI_OldFlags[player.ID] = GetEntityFlags(player.ID); + gB_OldOnGround[player.ID] = player.OnGround; + gI_TickCount[player.ID] = tickcount; + player.GetOrigin(gF_OldOrigin[player.ID]); + player.GetEyeAngles(gF_OldAngles[player.ID]); + player.GetVelocity(gF_OldVelocity[player.ID]); + + return Plugin_Continue; +} + +public MRESReturn DHooks_OnGetPlayerMaxSpeed(int client, Handle hReturn) +{ + if (!IsUsingMode(client)) + { + return MRES_Ignored; + } + DHookSetReturn(hReturn, SPEED_NORMAL * gF_PSVelMod[client]); + return MRES_Supercede; +} + +public MRESReturn DHooks_OnAirAccelerate_Pre(Address pThis, DHookParam hParams) +{ + int client = GOKZGetClientFromGameMovementAddress(pThis, gI_OffsetCGameMovement_player); + if (!IsPlayerAlive(client) || !IsUsingMode(client)) + { + return MRES_Ignored; + } + + // NOTE: Prestrafing changes GetPlayerMaxSpeed, which changes + // air acceleration, so remove gF_PreVelMod[client] from wishspeed/maxspeed. + // This also applies to when the player is ducked: their wishspeed is + // 85 and with prestrafing can be ~93. + float wishspeed = DHookGetParam(hParams, 2); + if (gF_PSVelMod[client] > 1.0) + { + DHookSetParam(hParams, 2, wishspeed / gF_PSVelMod[client]); + return MRES_ChangedHandled; + } + + return MRES_Ignored; +} + +public MRESReturn DHooks_OnCanUnduck_Pre(Address pThis, DHookReturn hReturn) +{ + int client = GOKZGetClientFromGameMovementAddress(pThis, gI_OffsetCGameMovement_player); + if (!IsPlayerAlive(client) || !IsUsingMode(client)) + { + return MRES_Ignored; + } + // Just landed fully ducked, you can't unduck. + if (Movement_GetLandingTick(client) == (gI_TickCount[client] - 1) && GetEntPropFloat(client, Prop_Send, "m_flDuckAmount") >= 1.0 && GetEntProp(client, Prop_Send, "m_bDucked")) + { + hReturn.Value = false; + return MRES_Supercede; + } + return MRES_Ignored; +} + +public void OnPlayerRunCmdPost(int client, int buttons, int impulse, const float vel[3], const float angles[3], int weapon, int subtype, int cmdnum, int tickcount, int seed, const int mouse[2]) +{ + if (!IsValidClient(client) || !IsPlayerAlive(client) || !IsUsingMode(client)) + { + return; + } + + if (buttons & IN_JUMP) + { + gI_LastJumpButtonCmdnum[client] = cmdnum; + } +} + +public void SDKHook_OnClientPreThink_Post(int client) +{ + if (!IsPlayerAlive(client) || !IsUsingMode(client)) + { + return; + } + + // Don't tweak convars if GOKZ isn't running + if (gB_GOKZCore) + { + TweakConVars(); + } +} + +public void Movement_OnStartTouchGround(int client) +{ + if (!IsUsingMode(client)) + { + return; + } + + KZPlayer player = KZPlayer(client); + gF_PSVelModLanding[player.ID] = gF_PSVelMod[player.ID]; +} + +public Action Movement_OnJumpPre(int client, float origin[3], float velocity[3]) +{ + if (!IsPlayerAlive(client) || !IsUsingMode(client)) + { + return Plugin_Continue; + } + + KZPlayer player = KZPlayer(client); + return TweakJump(player, origin, velocity); +} + +public Action Movement_OnCategorizePositionPost(int client, float origin[3], float velocity[3]) +{ + if (!IsPlayerAlive(client) || !IsUsingMode(client)) + { + return Plugin_Continue; + } + return SlopeFix(client, origin, velocity); +} + +public void Movement_OnChangeMovetype(int client, MoveType oldMovetype, MoveType newMovetype) +{ + if (!IsUsingMode(client)) + { + return; + } + + KZPlayer player = KZPlayer(client); + if (gB_GOKZCore && newMovetype == MOVETYPE_WALK) + { + player.GOKZHitPerf = false; + player.GOKZTakeoffSpeed = player.TakeoffSpeed; + } +} + +public void GOKZ_OnOptionChanged(int client, const char[] option, any newValue) +{ + if (StrEqual(option, gC_CoreOptionNames[Option_Mode]) && newValue == Mode_SimpleKZ) + { + ReplicateConVars(client); + } +} + +public void GOKZ_OnCountedTeleport_Post(int client) +{ + ResetClient(client); +} + + + +// =====[ GENERAL ]===== + +bool IsUsingMode(int client) +{ + // If GOKZ core isn't loaded, then apply mode at all times + return !gB_GOKZCore || GOKZ_GetCoreOption(client, Option_Mode) == Mode_SimpleKZ; +} + +void ResetClient(int client) +{ + KZPlayer player = KZPlayer(client); + ResetVelMod(player); +} + +void HookEvents() +{ + GameData gameData = LoadGameConfigFile("movementapi.games"); + if (gameData == INVALID_HANDLE) + { + SetFailState("Failed to find movementapi.games config"); + } + + int offset = gameData.GetOffset("GetPlayerMaxSpeed"); + if (offset == -1) + { + SetFailState("Failed to get GetPlayerMaxSpeed offset"); + } + gH_GetPlayerMaxSpeed = DHookCreate(offset, HookType_Entity, ReturnType_Float, ThisPointer_CBaseEntity, DHooks_OnGetPlayerMaxSpeed); + + gH_AirAccelerate = DynamicDetour.FromConf(gameData, "CGameMovement::AirAccelerate"); + if (gH_AirAccelerate == INVALID_HANDLE) + { + SetFailState("Failed to find CGameMovement::AirAccelerate function signature"); + } + + if (!gH_AirAccelerate.Enable(Hook_Pre, DHooks_OnAirAccelerate_Pre)) + { + SetFailState("Failed to enable detour on CGameMovement::AirAccelerate"); + } + + char buffer[16]; + if (!gameData.GetKeyValue("CGameMovement::player", buffer, sizeof(buffer))) + { + SetFailState("Failed to get CGameMovement::player offset."); + } + gI_OffsetCGameMovement_player = StringToInt(buffer); + + gameData = LoadGameConfigFile("gokz-core.games"); + gH_CanUnduck = DynamicDetour.FromConf(gameData, "CCSGameMovement::CanUnduck"); + if (gH_CanUnduck == INVALID_HANDLE) + { + SetFailState("Failed to find CCSGameMovement::CanUnduck function signature"); + } + + if (!gH_CanUnduck.Enable(Hook_Pre, DHooks_OnCanUnduck_Pre)) + { + SetFailState("Failed to enable detour on CCSGameMovement::CanUnduck"); + } + delete gameData; +} + +// =====[ CONVARS ]===== + +void CreateConVars() +{ + for (int i = 0; i < MODECVAR_COUNT; i++) + { + gCV_ModeCVar[i] = FindConVar(gC_ModeCVars[i]); + } +} + +void TweakConVars() +{ + for (int i = 0; i < MODECVAR_COUNT; i++) + { + gCV_ModeCVar[i].FloatValue = gF_ModeCVarValues[i]; + } +} + +void ReplicateConVars(int client) +{ + /* + Replicate convars only when player changes mode in GOKZ + so that lagg isn't caused by other players using other + modes, and also as an optimisation. + */ + + if (IsFakeClient(client)) + { + return; + } + + for (int i = 0; i < MODECVAR_COUNT; i++) + { + gCV_ModeCVar[i].ReplicateToClient(client, FloatToStringEx(gF_ModeCVarValues[i])); + } +} + + + +// =====[ VELOCITY MODIFIER ]===== + +void HookClientEvents(int client) +{ + DHookEntity(gH_GetPlayerMaxSpeed, true, client); + SDKHook(client, SDKHook_PreThinkPost, SDKHook_OnClientPreThink_Post); +} + +void ResetVelMod(KZPlayer player) +{ + gF_PSBonusSpeed[player.ID] = 0.0; + gF_PSVelMod[player.ID] = 1.0; + gF_PSTurnRate[player.ID] = 0.0; +} + +void CalcPrestrafeVelMod(KZPlayer player, const float angles[3]) +{ + gI_PSTicksSinceIncrement[player.ID]++; + + // Short circuit if speed is 0 (also avoids divide by 0 errors) + if (player.Speed < EPSILON) + { + ResetVelMod(player); + return; + } + + // Current speed without bonus + float baseSpeed = FloatMin(SPEED_NORMAL, player.Speed / gF_PSVelMod[player.ID]); + + float newBonusSpeed = gF_PSBonusSpeed[player.ID]; + + // If player is in mid air, decrement their velocity modifier + if (!player.OnGround) + { + newBonusSpeed -= PS_SPEED_DECREMENT_MIDAIR; + } + // If player is turning at the required speed, and has the correct button inputs, reward it + else if (player.Turning && ValidPrestrafeButtons(player)) + { + // If player changes their prestrafe direction, reset it + if (player.TurningLeft && !gB_PSTurningLeft[player.ID] + || player.TurningRight && gB_PSTurningLeft[player.ID]) + { + ResetVelMod(player); + newBonusSpeed = 0.0; + } + + // Keep track of the direction of the turn + gB_PSTurningLeft[player.ID] = player.TurningLeft; + + // Step one of calculating new turn rate + float newTurningRate = FloatAbs(CalcDeltaAngle(gF_OldAngles[player.ID][1], angles[1])); + + // If no turning for just a few ticks, then forgive and calculate reward based on that no. of ticks + if (gI_PSTicksSinceIncrement[player.ID] <= PS_GRACE_TICKS) + { + // This turn occurred over multiple ticks, so scale appropriately + // Also cap turn rate at maximum reward turn rate + newTurningRate = FloatMin(PS_MAX_REWARD_TURN_RATE, + newTurningRate / gI_PSTicksSinceIncrement[player.ID]); + + // Limit how fast turn rate can decrease (also scaled appropriately) + gF_PSTurnRate[player.ID] = FloatMax(newTurningRate, + gF_PSTurnRate[player.ID] - PS_MAX_TURN_RATE_DECREMENT * gI_PSTicksSinceIncrement[player.ID]); + + newBonusSpeed += CalcPreRewardSpeed(gF_PSTurnRate[player.ID], baseSpeed) * gI_PSTicksSinceIncrement[player.ID]; + } + else + { + // Cap turn rate at maximum reward turn rate + newTurningRate = FloatMin(PS_MAX_REWARD_TURN_RATE, newTurningRate); + + // Limit how fast turn rate can decrease + gF_PSTurnRate[player.ID] = FloatMax(newTurningRate, + gF_PSTurnRate[player.ID] - PS_MAX_TURN_RATE_DECREMENT); + + // This is normal turning behaviour + newBonusSpeed += CalcPreRewardSpeed(gF_PSTurnRate[player.ID], baseSpeed); + } + + gI_PSTicksSinceIncrement[player.ID] = 0; + } + else if (gI_PSTicksSinceIncrement[player.ID] > PS_GRACE_TICKS) + { + // They definitely aren't turning, but limit how fast turn rate can decrease + gF_PSTurnRate[player.ID] = FloatMax(0.0, + gF_PSTurnRate[player.ID] - PS_MAX_TURN_RATE_DECREMENT); + } + + if (newBonusSpeed < 0.0) + { + // Keep velocity modifier positive + newBonusSpeed = 0.0; + } + else + { + // Scale the bonus speed based on current base speed and turn rate + float baseSpeedScaleFactor = baseSpeed / SPEED_NORMAL; // Max 1.0 + float turnRateScaleFactor = FloatMin(1.0, gF_PSTurnRate[player.ID] / PS_MAX_REWARD_TURN_RATE); + float scaledMaxBonusSpeed = PS_SPEED_MAX * baseSpeedScaleFactor * turnRateScaleFactor; + newBonusSpeed = FloatMin(newBonusSpeed, scaledMaxBonusSpeed); + } + + gF_PSBonusSpeed[player.ID] = newBonusSpeed; + gF_PSVelMod[player.ID] = 1.0 + (newBonusSpeed / baseSpeed); +} + +bool ValidPrestrafeButtons(KZPlayer player) +{ + bool forwardOrBack = player.Buttons & (IN_FORWARD | IN_BACK) && !(player.Buttons & IN_FORWARD && player.Buttons & IN_BACK); + bool leftOrRight = player.Buttons & (IN_MOVELEFT | IN_MOVERIGHT) && !(player.Buttons & IN_MOVELEFT && player.Buttons & IN_MOVERIGHT); + return forwardOrBack || leftOrRight; +} + +float CalcPreRewardSpeed(float yawDiff, float baseSpeed) +{ + // Formula + float reward; + if (yawDiff >= PS_MAX_REWARD_TURN_RATE) + { + reward = PS_SPEED_INCREMENT; + } + else + { + reward = PS_SPEED_INCREMENT * (yawDiff / PS_MAX_REWARD_TURN_RATE); + } + + return reward * baseSpeed / SPEED_NORMAL; +} + + + + +// =====[ JUMPING ]===== + +Action TweakJump(KZPlayer player, float origin[3], float velocity[3]) +{ + // TakeoffCmdnum and TakeoffSpeed is not defined here because the player technically hasn't taken off yet. + int cmdsSinceLanding = gI_Cmdnum[player.ID] - player.LandingCmdNum; + gB_HitTweakedPerf[player.ID] = cmdsSinceLanding <= 1 + || cmdsSinceLanding <= 3 && gI_Cmdnum[player.ID] - gI_LastJumpButtonCmdnum[player.ID] <= 3; + + if (gB_HitTweakedPerf[player.ID]) + { + if (cmdsSinceLanding <= 1) + { + NerfRealPerf(player, origin); + } + + ApplyTweakedTakeoffSpeed(player, velocity); + + if (cmdsSinceLanding > 1 || player.TakeoffSpeed > SPEED_NORMAL) + { + // Restore prestrafe lost due to briefly being on the ground + gF_PSVelMod[player.ID] = gF_PSVelModLanding[player.ID]; + } + return Plugin_Changed; + } + return Plugin_Continue; +} + +public Action Movement_OnJumpPost(int client) +{ + if (!IsUsingMode(client)) + { + return Plugin_Continue; + } + KZPlayer player = KZPlayer(client); + player.GOKZHitPerf = gB_HitTweakedPerf[player.ID]; + player.GOKZTakeoffSpeed = player.TakeoffSpeed; + return Plugin_Continue; +} + +public void Movement_OnStopTouchGround(int client) +{ + if (!IsUsingMode(client)) + { + return; + } + KZPlayer player = KZPlayer(client); + player.GOKZHitPerf = gB_HitTweakedPerf[player.ID]; + player.GOKZTakeoffSpeed = player.TakeoffSpeed; +} + +void NerfRealPerf(KZPlayer player, float origin[3]) +{ + // Not worth worrying about if player is already falling + // player.VerticalVelocity is not updated yet! Use processing velocity. + float velocity[3]; + Movement_GetProcessingVelocity(player.ID, velocity); + if (velocity[2] < EPSILON) + { + return; + } + + // Work out where the ground was when they bunnyhopped + float startPosition[3], endPosition[3], mins[3], maxs[3], groundOrigin[3]; + + startPosition = origin; + + endPosition = startPosition; + endPosition[2] = endPosition[2] - 2.0; // Should be less than 2.0 units away + + GetEntPropVector(player.ID, Prop_Send, "m_vecMins", mins); + GetEntPropVector(player.ID, Prop_Send, "m_vecMaxs", maxs); + + Handle trace = TR_TraceHullFilterEx( + startPosition, + endPosition, + mins, + maxs, + MASK_PLAYERSOLID, + TraceEntityFilterPlayers, + player.ID); + + // This is expected to always hit, previously this can fail upon jumpbugs. + if (TR_DidHit(trace)) + { + TR_GetEndPosition(groundOrigin, trace); + origin[2] = groundOrigin[2]; + } + + delete trace; +} + +void ApplyTweakedTakeoffSpeed(KZPlayer player, float velocity[3]) +{ + // Note that resulting velocity has same direction as landing velocity, not current velocity + // because current velocity direction can change drastically in just one tick (eg. walls) + // and it doesnt make sense for the new velocity to push you in that direction. + + float newVelocity[3], baseVelocity[3]; + player.GetLandingVelocity(newVelocity); + player.GetBaseVelocity(baseVelocity); + SetVectorHorizontalLength(newVelocity, CalcTweakedTakeoffSpeed(player)); + AddVectors(newVelocity, baseVelocity, newVelocity); // For backwards compatibility + velocity[0] = newVelocity[0]; + velocity[1] = newVelocity[1]; +} + +// Takeoff speed assuming player has met the conditions to need tweaking +float CalcTweakedTakeoffSpeed(KZPlayer player) +{ + // Formula + if (player.LandingSpeed > SPEED_NORMAL) + { + return FloatMin(player.LandingSpeed, (0.2 * player.LandingSpeed + 200) * gF_PSVelModLanding[player.ID]); + } + return player.LandingSpeed; +} + + + +// =====[ SLOPEFIX ]===== + +// ORIGINAL AUTHORS : Mev & Blacky +// URL : https://forums.alliedmods.net/showthread.php?p=2322788 +// NOTE : Modified by DanZay for this plugin + +Action SlopeFix(int client, float origin[3], float velocity[3]) +{ + KZPlayer player = KZPlayer(client); + // Check if player landed on the ground + if (Movement_GetOnGround(client) && !gB_OldOnGround[client]) + { + float vMins[] = {-16.0, -16.0, 0.0}; + // Always use ducked hull as the real hull size isn't updated yet. + // Might cause slight issues in extremely rare scenarios. + float vMaxs[] = {16.0, 16.0, 54.0}; + + float vEndPos[3]; + vEndPos[0] = origin[0]; + vEndPos[1] = origin[1]; + vEndPos[2] = origin[2] - gF_ModeCVarValues[ModeCVar_MaxVelocity]; + + // Set up and do tracehull to find out if the player landed on a slope + TR_TraceHullFilter(origin, vEndPos, vMins, vMaxs, MASK_PLAYERSOLID_BRUSHONLY, TraceRayDontHitSelf, client); + + if (TR_DidHit()) + { + // Gets the normal vector of the surface under the player + float vPlane[3], vLast[3]; + player.GetLandingVelocity(vLast); + TR_GetPlaneNormal(null, vPlane); + + // Make sure it's not flat ground and not a surf ramp (1.0 = flat ground, < 0.7 = surf ramp) + if (0.7 <= vPlane[2] < 1.0) + { + /* + Copy the ClipVelocity function from sdk2013 + (https://mxr.alliedmods.net/hl2sdk-sdk2013/source/game/shared/gamemovement.cpp#3145) + With some minor changes to make it actually work + */ + + float fBackOff = GetVectorDotProduct(vLast, vPlane); + + float change, vVel[3]; + for (int i; i < 2; i++) + { + change = vPlane[i] * fBackOff; + vVel[i] = vLast[i] - change; + } + + float fAdjust = GetVectorDotProduct(vVel, vPlane); + if (fAdjust < 0.0) + { + for (int i; i < 2; i++) + { + vVel[i] -= (vPlane[i] * fAdjust); + } + } + + vVel[2] = 0.0; + vLast[2] = 0.0; + + // Make sure the player is going down a ramp by checking if they actually will gain speed from the boost + if (GetVectorLength(vVel) > GetVectorLength(vLast)) + { + CopyVector(vVel, velocity); + player.SetLandingVelocity(velocity); + return Plugin_Changed; + } + } + } + } + return Plugin_Continue; +} + +public bool TraceRayDontHitSelf(int entity, int mask, any data) +{ + return entity != data && !(0 < entity <= MaxClients); +} + + + +// =====[ OTHER ]===== + +void FixWaterBoost(KZPlayer player, int buttons) +{ + if (GetEntProp(player.ID, Prop_Send, "m_nWaterLevel") >= 2) // WL_Waist = 2 + { + // If duck is being pressed and we're not already ducking or on ground + if (GetEntityFlags(player.ID) & (FL_DUCKING | FL_ONGROUND) == 0 + && buttons & IN_DUCK && ~gI_OldButtons[player.ID] & IN_DUCK) + { + float newOrigin[3]; + Movement_GetOrigin(player.ID, newOrigin); + newOrigin[2] += 9.0; + + TR_TraceHullFilter(newOrigin, newOrigin, view_as<float>( { -16.0, -16.0, 0.0 } ), view_as<float>( { 16.0, 16.0, 54.0 } ), MASK_PLAYERSOLID, TraceEntityFilterPlayers); + if (!TR_DidHit()) + { + TeleportEntity(player.ID, newOrigin, NULL_VECTOR, NULL_VECTOR); + } + } + } +} + +void FixDisplacementStuck(KZPlayer player) +{ + int flags = GetEntityFlags(player.ID); + bool unducked = ~flags & FL_DUCKING && gI_OldFlags[player.ID] & FL_DUCKING; + + float standingMins[] = {-16.0, -16.0, 0.0}; + float standingMaxs[] = {16.0, 16.0, 72.0}; + + if (unducked) + { + // check if we're stuck after unducking and if we're stuck then force duck + float origin[3]; + Movement_GetOrigin(player.ID, origin); + TR_TraceHullFilter(origin, origin, standingMins, standingMaxs, MASK_PLAYERSOLID, TraceEntityFilterPlayers); + + if (TR_DidHit()) + { + player.SetVelocity(gF_OldVelocity[player.ID]); + SetEntProp(player.ID, Prop_Send, "m_bDucking", true); + } + } +} + +void RemoveCrouchJumpBind(KZPlayer player, int &buttons) +{ + if (player.OnGround && buttons & IN_JUMP && !(gI_OldButtons[player.ID] & IN_JUMP) && !(gI_OldButtons[player.ID] & IN_DUCK)) + { + buttons &= ~IN_DUCK; + } +} + +void ReduceDuckSlowdown(KZPlayer player) +{ + /* + Duck speed is reduced by the game upon ducking or unducking. + The goal here is to accept that duck speed is reduced, but + stop it from being reduced further when spamming duck. + + This is done by enforcing a minimum duck speed equivalent to + the value as if the player only ducked once. When not in not + in the middle of ducking, duck speed is reset to its normal + value in effort to reduce the number of times the minimum + duck speed is enforced. This should reduce noticeable lagg. + */ + + if (!GetEntProp(player.ID, Prop_Send, "m_bDucking") + && player.DuckSpeed < DUCK_SPEED_NORMAL - EPSILON) + { + player.DuckSpeed = DUCK_SPEED_NORMAL; + } + else if (player.DuckSpeed < DUCK_SPEED_MINIMUM - EPSILON) + { + player.DuckSpeed = DUCK_SPEED_MINIMUM; + } +} diff --git a/sourcemod/scripting/gokz-mode-vanilla.sp b/sourcemod/scripting/gokz-mode-vanilla.sp new file mode 100644 index 0000000..aecc201 --- /dev/null +++ b/sourcemod/scripting/gokz-mode-vanilla.sp @@ -0,0 +1,291 @@ +#include <sourcemod> + +#include <sdkhooks> +#include <sdktools> +#include <dhooks> + +#include <movementapi> + +#undef REQUIRE_EXTENSIONS +#undef REQUIRE_PLUGIN +#include <gokz/core> +#include <updater> + +#include <gokz/kzplayer> + +#pragma newdecls required +#pragma semicolon 1 + + + +public Plugin myinfo = +{ + name = "GOKZ Mode - Vanilla", + author = "DanZay", + description = "Vanilla mode for GOKZ", + version = GOKZ_VERSION, + url = GOKZ_SOURCE_URL +}; + +#define UPDATER_URL GOKZ_UPDATER_BASE_URL..."gokz-mode-vanilla.txt" + +#define MODE_VERSION 17 + +float gF_ModeCVarValues[MODECVAR_COUNT] = +{ + 5.5, // sv_accelerate + 1.0, // sv_accelerate_use_weapon_speed + 12.0, // sv_airaccelerate + 30.0, // sv_air_max_wishspeed + 0.0, // sv_enablebunnyhopping + 5.2, // sv_friction + 800.0, // sv_gravity + 301.993377, // sv_jump_impulse + 0.78, // sv_ladder_scale_speed + 1.0, // sv_ledge_mantle_helper + 320.0, // sv_maxspeed + 3500.0, // sv_maxvelocity + 0.080, // sv_staminajumpcost + 0.050, // sv_staminalandcost + 80.0, // sv_staminamax + 60.0, // sv_staminarecoveryrate + 0.7, // sv_standable_normal + 0.4, // sv_timebetweenducks + 0.7, // sv_walkable_normal + 10.0, // sv_wateraccelerate + 0.8, // sv_water_movespeed_multiplier + 0.0, // sv_water_swim_mode + 0.85, // sv_weapon_encumbrance_per_item + 0.0 // sv_weapon_encumbrance_scale +}; + +bool gB_GOKZCore; +ConVar gCV_ModeCVar[MODECVAR_COUNT]; +bool gB_ProcessingMaxSpeed[MAXPLAYERS + 1]; +Handle gH_GetPlayerMaxSpeed; +Handle gH_GetPlayerMaxSpeed_SDKCall; + +// =====[ PLUGIN EVENTS ]===== + +public void OnPluginStart() +{ + CreateConVars(); + HookEvents(); +} + +public void OnAllPluginsLoaded() +{ + if (LibraryExists("updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + if (LibraryExists("gokz-core")) + { + gB_GOKZCore = true; + GOKZ_SetModeLoaded(Mode_Vanilla, true, MODE_VERSION); + } + + for (int client = 1; client <= MaxClients; client++) + { + if (IsClientInGame(client)) + { + OnClientPutInServer(client); + } + } +} + +public void OnPluginEnd() +{ + if (gB_GOKZCore) + { + GOKZ_SetModeLoaded(Mode_Vanilla, false); + } +} + +public void OnLibraryAdded(const char[] name) +{ + if (StrEqual(name, "updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + else if (StrEqual(name, "gokz-core")) + { + gB_GOKZCore = true; + GOKZ_SetModeLoaded(Mode_Vanilla, true, MODE_VERSION); + } +} + +public void OnLibraryRemoved(const char[] name) +{ + gB_GOKZCore = gB_GOKZCore && !StrEqual(name, "gokz-core"); +} + + + +// =====[ CLIENT EVENTS ]===== + +public void OnClientPutInServer(int client) +{ + if (IsValidClient(client)) + { + HookClientEvents(client); + } + if (IsUsingMode(client)) + { + ReplicateConVars(client); + } +} + +void HookClientEvents(int client) +{ + DHookEntity(gH_GetPlayerMaxSpeed, true, client); + SDKHook(client, SDKHook_PreThinkPost, SDKHook_OnClientPreThink_Post); +} + +public MRESReturn DHooks_OnGetPlayerMaxSpeed(int client, Handle hReturn) +{ + if (!IsUsingMode(client) || gB_ProcessingMaxSpeed[client]) + { + return MRES_Ignored; + } + gB_ProcessingMaxSpeed[client] = true; + float maxSpeed = SDKCall(gH_GetPlayerMaxSpeed_SDKCall, client); + // Prevent players from running faster than 250u/s + if (maxSpeed > SPEED_NORMAL) + { + DHookSetReturn(hReturn, SPEED_NORMAL); + gB_ProcessingMaxSpeed[client] = false; + return MRES_Supercede; + } + gB_ProcessingMaxSpeed[client] = false; + return MRES_Ignored; +} + +public void SDKHook_OnClientPreThink_Post(int client) +{ + if (!IsUsingMode(client)) + { + return; + } + + // Don't tweak convars if GOKZ isn't running + if (gB_GOKZCore) + { + TweakConVars(); + } +} + +public Action Movement_OnJumpPost(int client) +{ + if (!IsUsingMode(client)) + { + return Plugin_Continue; + } + + KZPlayer player = KZPlayer(client); + if (gB_GOKZCore) + { + player.GOKZHitPerf = player.HitPerf; + player.GOKZTakeoffSpeed = player.TakeoffSpeed; + } + return Plugin_Continue; +} +public void Movement_OnStopTouchGround(int client, bool jumped) +{ + if (!IsUsingMode(client)) + { + return; + } + + KZPlayer player = KZPlayer(client); + if (gB_GOKZCore) + { + player.GOKZHitPerf = player.HitPerf; + player.GOKZTakeoffSpeed = player.TakeoffSpeed; + } +} + +public void Movement_OnChangeMovetype(int client, MoveType oldMovetype, MoveType newMovetype) +{ + if (!IsUsingMode(client)) + { + return; + } + + KZPlayer player = KZPlayer(client); + if (gB_GOKZCore && newMovetype == MOVETYPE_WALK) + { + player.GOKZHitPerf = false; + player.GOKZTakeoffSpeed = player.TakeoffSpeed; + } +} + +public void GOKZ_OnOptionChanged(int client, const char[] option, any newValue) +{ + if (StrEqual(option, gC_CoreOptionNames[Option_Mode]) && newValue == Mode_Vanilla) + { + ReplicateConVars(client); + } +} + + + +// =====[ GENERAL ]===== + +bool IsUsingMode(int client) +{ + // If GOKZ core isn't loaded, then apply mode at all times + return !gB_GOKZCore || GOKZ_GetCoreOption(client, Option_Mode) == Mode_Vanilla; +} + +void HookEvents() +{ + GameData gameData = LoadGameConfigFile("movementapi.games"); + int offset = gameData.GetOffset("GetPlayerMaxSpeed"); + if (offset == -1) + { + SetFailState("Failed to get GetPlayerMaxSpeed offset"); + } + gH_GetPlayerMaxSpeed = DHookCreate(offset, HookType_Entity, ReturnType_Float, ThisPointer_CBaseEntity, DHooks_OnGetPlayerMaxSpeed); + + StartPrepSDKCall(SDKCall_Player); + PrepSDKCall_SetFromConf(gameData, SDKConf_Virtual, "GetPlayerMaxSpeed"); + PrepSDKCall_SetReturnInfo(SDKType_Float, SDKPass_ByValue); + gH_GetPlayerMaxSpeed_SDKCall = EndPrepSDKCall(); +} + + +// =====[ CONVARS ]===== + +void CreateConVars() +{ + for (int cvar = 0; cvar < MODECVAR_COUNT; cvar++) + { + gCV_ModeCVar[cvar] = FindConVar(gC_ModeCVars[cvar]); + } +} + +void TweakConVars() +{ + for (int i = 0; i < MODECVAR_COUNT; i++) + { + gCV_ModeCVar[i].FloatValue = gF_ModeCVarValues[i]; + } +} + +void ReplicateConVars(int client) +{ + // Replicate convars only when player changes mode in GOKZ + // so that lagg isn't caused by other players using other + // modes, and also as an optimisation. + + if (IsFakeClient(client)) + { + return; + } + + for (int i = 0; i < MODECVAR_COUNT; i++) + { + gCV_ModeCVar[i].ReplicateToClient(client, FloatToStringEx(gF_ModeCVarValues[i])); + } +} diff --git a/sourcemod/scripting/gokz-momsurffix.sp b/sourcemod/scripting/gokz-momsurffix.sp new file mode 100644 index 0000000..2738e90 --- /dev/null +++ b/sourcemod/scripting/gokz-momsurffix.sp @@ -0,0 +1,724 @@ +#include "sourcemod" +#include "sdktools" +#include "sdkhooks" +#include "dhooks" + +#include <gokz/core> +#include <gokz/momsurffix> + +#define SNAME "[gokz-momsurffix] " +#define GAME_DATA_FILE "gokz-momsurffix.games" +//#define DEBUG_PROFILE +//#define DEBUG_MEMTEST + +public Plugin myinfo = { + name = "GOKZ Momsurffix", + author = "GAMMA CASE", + description = "Ported surf fix from momentum mod. Modified for GOKZ by GameChaos. Original source code: https://github.com/GAMMACASE/MomSurfFix", + version = GOKZ_VERSION, + url = GOKZ_SOURCE_URL +}; + +#define FLT_EPSILON 1.192092896e-07 +#define MAX_CLIP_PLANES 5 + +#define ASM_PATCH_LEN 17 +#define ASM_START_OFFSET 100 + +#define WALKABLE_PLANE_NORMAL 0.7 + +enum OSType +{ + OSUnknown = -1, + OSWindows = 1, + OSLinux = 2 +}; + +OSType gOSType; +EngineVersion gEngineVersion; + +#define ASSERTUTILS_FAILSTATE_FUNC SetFailStateCustom +#define MEMUTILS_PLUGINENDCALL +#include "glib/memutils" +#undef MEMUTILS_PLUGINENDCALL + +#include "momsurffix/utils.sp" +#include "momsurffix/baseplayer.sp" +#include "momsurffix/gametrace.sp" +#include "momsurffix/gamemovement.sp" + +ConVar gBounce; + +float vec3_origin[3] = {0.0, 0.0, 0.0}; +bool gBasePlayerLoadedTooEarly; + +#if defined DEBUG_PROFILE +#include "profiler" +Profiler gProf; +ArrayList gProfData; +float gProfTime; + +void PROF_START() +{ + if(gProf) + gProf.Start(); +} + +void PROF_STOP(int idx) +{ + if(gProf) + { + gProf.Stop(); + Prof_Check(idx); + } +} + +#else +#define PROF_START%1; +#define PROF_STOP%1; +#endif + +public APLRes AskPluginLoad2(Handle myself, bool late, char[] error, int err_max) +{ + RegPluginLibrary("gokz-momsurffix"); + return APLRes_Success; +} + +public void OnPluginStart() +{ +#if defined DEBUG_MEMTEST + RegAdminCmd("sm_mom_dumpmempool", SM_Dumpmempool, ADMFLAG_ROOT, "Dumps active momory pool. Mainly for debugging."); +#endif +#if defined DEBUG_PROFILE + RegAdminCmd("sm_mom_prof", SM_Prof, ADMFLAG_ROOT, "Profiles performance of some expensive parts. Mainly for debugging."); +#endif + + gBounce = FindConVar("sv_bounce"); + ASSERT_MSG(gBounce, "\"sv_bounce\" convar wasn't found!"); + + GameData gd = new GameData(GAME_DATA_FILE); + ASSERT_FINAL(gd); + + ValidateGameAndOS(gd); + + InitUtils(gd); + InitGameTrace(gd); + gBasePlayerLoadedTooEarly = InitBasePlayer(gd); + InitGameMovement(gd); + + SetupDhooks(gd); + + delete gd; +} + +public void OnMapStart() +{ + if(gBasePlayerLoadedTooEarly) + { + GameData gd = new GameData(GAME_DATA_FILE); + LateInitBasePlayer(gd); + gBasePlayerLoadedTooEarly = false; + delete gd; + } +} + +public void OnPluginEnd() +{ + CleanUpUtils(); +} + +#if defined DEBUG_MEMTEST +public Action SM_Dumpmempool(int client, int args) +{ + DumpMemoryUsage(); + + return Plugin_Handled; +} +#endif + +#if defined DEBUG_PROFILE +public Action SM_Prof(int client, int args) +{ + if(args < 1) + { + ReplyToCommand(client, SNAME..."Usage: sm_prof <seconds>"); + return Plugin_Handled; + } + + char buff[32]; + GetCmdArg(1, buff, sizeof(buff)); + gProfTime = StringToFloat(buff); + + if(gProfTime <= 0.1) + { + ReplyToCommand(client, SNAME..."Time should be higher then 0.1 seconds."); + return Plugin_Handled; + } + + gProfData = new ArrayList(3); + gProf = new Profiler(); + CreateTimer(gProfTime, Prof_Check_Timer, client); + + ReplyToCommand(client, SNAME..."Profiler started, awaiting %.2f seconds.", gProfTime); + + return Plugin_Handled; +} + +stock void Prof_Check(int idx) +{ + int idx2; + if(gProfData.Length - 1 < idx) + { + idx2 = gProfData.Push(gProf.Time); + gProfData.Set(idx2, 1, 1); + gProfData.Set(idx2, idx, 2); + } + else + { + idx2 = gProfData.FindValue(idx, 2); + + gProfData.Set(idx2, view_as<float>(gProfData.Get(idx2)) + gProf.Time); + gProfData.Set(idx2, gProfData.Get(idx2, 1) + 1, 1); + } +} + +public Action Prof_Check_Timer(Handle timer, int client) +{ + ReplyToCommand(client, SNAME..."Profiler finished:"); + if(gProfData.Length == 0) + ReplyToCommand(client, SNAME..."There was no profiling data..."); + + for(int i = 0; i < gProfData.Length; i++) + ReplyToCommand(client, SNAME..."[%i] Avg time: %f | Calls: %i", i, view_as<float>(gProfData.Get(i)) / float(gProfData.Get(i, 1)), gProfData.Get(i, 1)); + + delete gProf; + delete gProfData; + + return Plugin_Handled; +} +#endif + +void ValidateGameAndOS(GameData gd) +{ + gOSType = view_as<OSType>(gd.GetOffset("OSType")); + ASSERT_FINAL_MSG(gOSType != OSUnknown, "Failed to get OS type or you are trying to load it on unsupported OS!"); + + gEngineVersion = GetEngineVersion(); + ASSERT_FINAL_MSG(gEngineVersion == Engine_CSS || gEngineVersion == Engine_CSGO, "Only CSGO and CSS are supported by this plugin!"); +} + +void SetupDhooks(GameData gd) +{ + Handle dhook = DHookCreateDetour(Address_Null, CallConv_THISCALL, ReturnType_Int, ThisPointer_Address); + + DHookSetFromConf(dhook, gd, SDKConf_Signature, "CGameMovement::TryPlayerMove"); + DHookAddParam(dhook, HookParamType_Int); + DHookAddParam(dhook, HookParamType_Int); + + ASSERT(DHookEnableDetour(dhook, false, TryPlayerMove_Dhook)); +} + +public MRESReturn TryPlayerMove_Dhook(Address pThis, Handle hReturn, Handle hParams) +{ + Address pFirstDest = DHookGetParam(hParams, 1); + Address pFirstTrace = DHookGetParam(hParams, 2); + + DHookSetReturn(hReturn, TryPlayerMove(view_as<CGameMovement>(pThis), view_as<Vector>(pFirstDest), view_as<CGameTrace>(pFirstTrace))); + + return MRES_Supercede; +} + +int TryPlayerMove(CGameMovement pThis, Vector pFirstDest, CGameTrace pFirstTrace) +{ + float original_velocity[3], primal_velocity[3], fixed_origin[3], valid_plane[3], new_velocity[3], end[3], dir[3]; + float allFraction, d, time_left = GetGameFrameTime(), planes[MAX_CLIP_PLANES][3]; + int bumpcount, blocked, numplanes, numbumps = 8, i, j, h; + bool stuck_on_ramp, has_valid_plane; + CGameTrace pm = CGameTrace(); + + Vector vecVelocity = pThis.mv.m_vecVelocity; + vecVelocity.ToArray(original_velocity); + vecVelocity.ToArray(primal_velocity); + Vector vecAbsOrigin = pThis.mv.m_vecAbsOrigin; + vecAbsOrigin.ToArray(fixed_origin); + + Vector plane_normal; + static Vector alloced_vector, alloced_vector2; + + if(alloced_vector.Address == Address_Null) + alloced_vector = Vector(); + + if(alloced_vector2.Address == Address_Null) + alloced_vector2 = Vector(); + + const float rampInitialRetraceLength = 0.03125; + for(bumpcount = 0; bumpcount < numbumps; bumpcount++) + { + if(vecVelocity.LengthSqr() == 0.0) + break; + + if(stuck_on_ramp) + { + if(!has_valid_plane) + { + plane_normal = pm.plane.normal; + if(!CloseEnough(VectorToArray(plane_normal), view_as<float>({0.0, 0.0, 0.0})) && + !IsEqual(valid_plane, VectorToArray(plane_normal))) + { + plane_normal.ToArray(valid_plane); + has_valid_plane = true; + } + else + { + for(i = numplanes; i-- > 0;) + { + if(!CloseEnough(planes[i], view_as<float>({0.0, 0.0, 0.0})) && + FloatAbs(planes[i][0]) <= 1.0 && FloatAbs(planes[i][1]) <= 1.0 && FloatAbs(planes[i][2]) <= 1.0 && + !IsEqual(valid_plane, planes[i])) + { + VectorCopy(planes[i], valid_plane); + has_valid_plane = true; + break; + } + } + } + } + + if(has_valid_plane) + { + alloced_vector.FromArray(valid_plane); + if(valid_plane[2] >= WALKABLE_PLANE_NORMAL && valid_plane[2] <= 1.0) + { + ClipVelocity(pThis, vecVelocity, alloced_vector, vecVelocity, 1.0); + vecVelocity.ToArray(original_velocity); + } + else + { + ClipVelocity(pThis, vecVelocity, alloced_vector, vecVelocity, 1.0 + gBounce.FloatValue * (1.0 - pThis.player.m_surfaceFriction)); + vecVelocity.ToArray(original_velocity); + } + alloced_vector.ToArray(valid_plane); + } + //TODO: should be replaced with normal solution!! Currently hack to fix issue #1. + else if((vecVelocity.z < -6.25 || vecVelocity.z > 0.0)) + { + //Quite heavy part of the code, should not be triggered much or else it'll impact performance by a lot!!! + float offsets[3]; + offsets[0] = (float(bumpcount) * 2.0) * -rampInitialRetraceLength; + offsets[2] = (float(bumpcount) * 2.0) * rampInitialRetraceLength; + int valid_planes = 0; + + VectorCopy(view_as<float>({0.0, 0.0, 0.0}), valid_plane); + + float offset[3], offset_mins[3], offset_maxs[3], buff[3]; + static Ray_t ray; + + // Keep this variable allocated only once + // since ray.Init should take care of removing any left garbage values + if(ray.Address == Address_Null) + ray = Ray_t(); + + for(i = 0; i < 3; i++) + { + for(j = 0; j < 3; j++) + { + for(h = 0; h < 3; h++) + { + PROF_START(); + offset[0] = offsets[i]; + offset[1] = offsets[j]; + offset[2] = offsets[h]; + + offset_mins = offset; + ScaleVector(offset_mins, 0.5); + offset_maxs = offset; + ScaleVector(offset_maxs, 0.5); + + if(offset[0] > 0.0) + offset_mins[0] /= 2.0; + if(offset[1] > 0.0) + offset_mins[1] /= 2.0; + if(offset[2] > 0.0) + offset_mins[2] /= 2.0; + + if(offset[0] < 0.0) + offset_maxs[0] /= 2.0; + if(offset[1] < 0.0) + offset_maxs[1] /= 2.0; + if(offset[2] < 0.0) + offset_maxs[2] /= 2.0; + PROF_STOP(0); + + PROF_START(); + AddVectors(fixed_origin, offset, buff); + SubtractVectors(end, offset, offset); + if(gEngineVersion == Engine_CSGO) + { + SubtractVectors(VectorToArray(GetPlayerMins(pThis)), offset_mins, offset_mins); + AddVectors(VectorToArray(GetPlayerMaxs(pThis)), offset_maxs, offset_maxs); + } + else + { + SubtractVectors(VectorToArray(GetPlayerMinsCSS(pThis, alloced_vector)), offset_mins, offset_mins); + AddVectors(VectorToArray(GetPlayerMaxsCSS(pThis, alloced_vector2)), offset_maxs, offset_maxs); + } + PROF_STOP(1); + + PROF_START(); + ray.Init(buff, offset, offset_mins, offset_maxs); + PROF_STOP(2); + + PROF_START(); + UTIL_TraceRay(ray, MASK_PLAYERSOLID, pThis, COLLISION_GROUP_PLAYER_MOVEMENT, pm); + PROF_STOP(3); + + PROF_START(); + plane_normal = pm.plane.normal; + + if(FloatAbs(plane_normal.x) <= 1.0 && FloatAbs(plane_normal.y) <= 1.0 && + FloatAbs(plane_normal.z) <= 1.0 && pm.fraction > 0.0 && pm.fraction < 1.0 && !pm.startsolid) + { + valid_planes++; + AddVectors(valid_plane, VectorToArray(plane_normal), valid_plane); + } + PROF_STOP(4); + } + } + } + + if(valid_planes != 0 && !CloseEnough(valid_plane, view_as<float>({0.0, 0.0, 0.0}))) + { + has_valid_plane = true; + NormalizeVector(valid_plane, valid_plane); + continue; + } + } + + if(has_valid_plane) + { + VectorMA(fixed_origin, rampInitialRetraceLength, valid_plane, fixed_origin); + } + else + { + stuck_on_ramp = false; + continue; + } + } + + VectorMA(fixed_origin, time_left, VectorToArray(vecVelocity), end); + + if(pFirstDest.Address != Address_Null && IsEqual(end, VectorToArray(pFirstDest))) + { + pm.Free(); + pm = pFirstTrace; + } + else + { + alloced_vector2.FromArray(end); + + if(stuck_on_ramp && has_valid_plane) + { + alloced_vector.FromArray(fixed_origin); + TracePlayerBBox(pThis, alloced_vector, alloced_vector2, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, pm); + pm.plane.normal.FromArray(valid_plane); + } + else + { + TracePlayerBBox(pThis, vecAbsOrigin, alloced_vector2, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, pm); + } + } + + if(bumpcount > 0 && pThis.player.m_hGroundEntity == view_as<Address>(-1) && !IsValidMovementTrace(pThis, pm)) + { + has_valid_plane = false; + stuck_on_ramp = true; + continue; + } + + if(pm.fraction > 0.0) + { + if((bumpcount == 0 || pThis.player.m_hGroundEntity != view_as<Address>(-1)) && numbumps > 0 && pm.fraction == 1.0) + { + CGameTrace stuck = CGameTrace(); + TracePlayerBBox(pThis, pm.endpos, pm.endpos, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, stuck); + + if((stuck.startsolid || stuck.fraction != 1.0) && bumpcount == 0) + { + has_valid_plane = false; + stuck_on_ramp = true; + + stuck.Free(); + continue; + } + else if(stuck.startsolid || stuck.fraction != 1.0) + { + vecVelocity.FromArray(vec3_origin); + + stuck.Free(); + break; + } + + stuck.Free(); + } + + has_valid_plane = false; + stuck_on_ramp = false; + + vecVelocity.ToArray(original_velocity); + vecAbsOrigin.FromArray(VectorToArray(pm.endpos)); + vecAbsOrigin.ToArray(fixed_origin); + allFraction += pm.fraction; + numplanes = 0; + } + + if(CloseEnoughFloat(pm.fraction, 1.0)) + break; + + MoveHelper().AddToTouched(pm, vecVelocity); + + if(pm.plane.normal.z >= WALKABLE_PLANE_NORMAL) + blocked |= 1; + + if(CloseEnoughFloat(pm.plane.normal.z, 0.0)) + blocked |= 2; + + time_left -= time_left * pm.fraction; + + if(numplanes >= MAX_CLIP_PLANES) + { + vecVelocity.FromArray(vec3_origin); + break; + } + + pm.plane.normal.ToArray(planes[numplanes]); + numplanes++; + + if(numplanes == 1 && pThis.player.m_MoveType == MOVETYPE_WALK && pThis.player.m_hGroundEntity != view_as<Address>(-1)) + { + Vector vec1 = Vector(); + PROF_START(); + if(planes[0][2] >= WALKABLE_PLANE_NORMAL) + { + vec1.FromArray(original_velocity); + alloced_vector2.FromArray(planes[0]); + alloced_vector.FromArray(new_velocity); + ClipVelocity(pThis, vec1, alloced_vector2, alloced_vector, 1.0); + alloced_vector.ToArray(original_velocity); + alloced_vector.ToArray(new_velocity); + } + else + { + vec1.FromArray(original_velocity); + alloced_vector2.FromArray(planes[0]); + alloced_vector.FromArray(new_velocity); + ClipVelocity(pThis, vec1, alloced_vector2, alloced_vector, 1.0 + gBounce.FloatValue * (1.0 - pThis.player.m_surfaceFriction)); + alloced_vector.ToArray(new_velocity); + } + PROF_STOP(5); + + vecVelocity.FromArray(new_velocity); + VectorCopy(new_velocity, original_velocity); + + vec1.Free(); + } + else + { + for(i = 0; i < numplanes; i++) + { + alloced_vector2.FromArray(original_velocity); + alloced_vector.FromArray(planes[i]); + ClipVelocity(pThis, alloced_vector2, alloced_vector, vecVelocity, 1.0); + alloced_vector.ToArray(planes[i]); + + for(j = 0; j < numplanes; j++) + if(j != i) + if(vecVelocity.Dot(planes[j]) < 0.0) + break; + + if(j == numplanes) + break; + } + + if(i != numplanes) + { + + } + else + { + if(numplanes != 2) + { + vecVelocity.FromArray(vec3_origin); + break; + } + + // Fun fact time: these next five lines of code fix (vertical) rampbug + if(CloseEnough(planes[0], planes[1])) + { + // Why did the above return true? Well, when surfing, you can "clip" into the + // ramp, due to the ramp not pushing you away enough, and when that happens, + // a surfer cries. So the game thinks the surfer is clipping along two of the exact + // same planes. So what we do here is take the surfer's original velocity, + // and add the along the normal of the surf ramp they're currently riding down, + // essentially pushing them away from the ramp. + + // NOTE: the following comment is here for context: + // NOTE: Technically the 20.0 here can be 2.0, but that causes "jitters" sometimes, so I found + // 20 to be pretty safe and smooth. If it causes any unforeseen consequences, tweak it! + VectorMA(original_velocity, 2.0, planes[0], new_velocity); + vecVelocity.x = new_velocity[0]; + vecVelocity.y = new_velocity[1]; + // Note: We don't want the player to gain any Z boost/reduce from this, gravity should be the + // only force working in the Z direction! + + // Lastly, let's get out of here before the following lines of code make the surfer lose speed. + + break; + } + + GetVectorCrossProduct(planes[0], planes[1], dir); + NormalizeVector(dir, dir); + + d = vecVelocity.Dot(dir); + + ScaleVector(dir, d); + vecVelocity.FromArray(dir); + } + + d = vecVelocity.Dot(primal_velocity); + if(d <= 0.0) + { + vecVelocity.FromArray(vec3_origin); + break; + } + } + } + + if(CloseEnoughFloat(allFraction, 0.0)) + vecVelocity.FromArray(vec3_origin); + + pm.Free(); + return blocked; +} + +stock void VectorMA(float start[3], float scale, float dir[3], float dest[3]) +{ + dest[0] = start[0] + dir[0] * scale; + dest[1] = start[1] + dir[1] * scale; + dest[2] = start[2] + dir[2] * scale; +} + +stock void VectorCopy(float from[3], float to[3]) +{ + to[0] = from[0]; + to[1] = from[1]; + to[2] = from[2]; +} + +stock float[] VectorToArray(Vector vec) +{ + float ret[3]; + vec.ToArray(ret); + return ret; +} + +stock bool IsEqual(float a[3], float b[3]) +{ + return a[0] == b[0] && a[1] == b[1] && a[2] == b[2]; +} + +stock bool CloseEnough(float a[3], float b[3], float eps = FLT_EPSILON) +{ + return FloatAbs(a[0] - b[0]) <= eps && + FloatAbs(a[1] - b[1]) <= eps && + FloatAbs(a[2] - b[2]) <= eps; +} + +stock bool CloseEnoughFloat(float a, float b, float eps = FLT_EPSILON) +{ + return FloatAbs(a - b) <= eps; +} + +public void SetFailStateCustom(const char[] fmt, any ...) +{ + char buff[512]; + VFormat(buff, sizeof(buff), fmt, 2); + + CleanUpUtils(); + + char ostype[32]; + switch(gOSType) + { + case OSLinux: ostype = "LIN"; + case OSWindows: ostype = "WIN"; + default: ostype = "UNK"; + } + + SetFailState("[%s | %i] %s", ostype, gEngineVersion, buff); +} + +// 0-2 are axial planes +#define PLANE_X 0 +#define PLANE_Y 1 +#define PLANE_Z 2 + +// 3-5 are non-axial planes snapped to the nearest +#define PLANE_ANYX 3 +#define PLANE_ANYY 4 +#define PLANE_ANYZ 5 + +stock bool IsValidMovementTrace(CGameMovement pThis, CGameTrace tr) +{ + if(tr.allsolid || tr.startsolid) + return false; + + // This fixes pixelsurfs in a kind of scuffed way + Vector plane_normal = tr.plane.normal; + if(CloseEnoughFloat(tr.fraction, 0.0) + && tr.plane.type >= PLANE_Z // axially aligned vertical planes (not floors) can be pixelsurfs! + && plane_normal.z < WALKABLE_PLANE_NORMAL) // if plane isn't walkable + { + return false; + } + + if(FloatAbs(plane_normal.x) > 1.0 || FloatAbs(plane_normal.y) > 1.0 || FloatAbs(plane_normal.z) > 1.0) + return false; + + CGameTrace stuck = CGameTrace(); + + TracePlayerBBox(pThis, tr.endpos, tr.endpos, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, stuck); + if(stuck.startsolid || !CloseEnoughFloat(stuck.fraction, 1.0)) + { + stuck.Free(); + return false; + } + + stuck.Free(); + return true; +} + +stock void UTIL_TraceRay(Ray_t ray, int mask, CGameMovement gm, int collisionGroup, CGameTrace trace) +{ + if(gEngineVersion == Engine_CSGO) + { + CTraceFilterSimple filter = LockTraceFilter(gm, collisionGroup); + + gm.m_nTraceCount++; + ITraceListData tracelist = gm.m_pTraceListData; + + if(tracelist.Address != Address_Null && tracelist.CanTraceRay(ray)) + TraceRayAgainstLeafAndEntityList(ray, tracelist, mask, filter, trace); + else + TraceRay(ray, mask, filter, trace); + + UnlockTraceFilter(gm, filter); + } + else if(gEngineVersion == Engine_CSS) + { + CTraceFilterSimple filter = CTraceFilterSimple(); + filter.Init(LookupEntity(gm.mv.m_nPlayerHandle), collisionGroup); + + TraceRay(ray, mask, filter, trace); + + filter.Free(); + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-paint.sp b/sourcemod/scripting/gokz-paint.sp new file mode 100644 index 0000000..3de93a7 --- /dev/null +++ b/sourcemod/scripting/gokz-paint.sp @@ -0,0 +1,410 @@ +#include <sourcemod> + +#include <gokz/core> +#include <gokz/paint> + +#undef REQUIRE_EXTENSIONS +#undef REQUIRE_PLUGIN +#include <updater> + +#pragma newdecls required +#pragma semicolon 1 + + + +// Credit to SlidyBat for a large part of the painting code (https://forums.alliedmods.net/showthread.php?p=2541664) +// Credit to Cabbage McGravel of the MomentumMod team for making the textures + +public Plugin myinfo = +{ + name = "GOKZ Paint", + author = "zealain", + description = "Provides client sided paint for visibility", + version = GOKZ_VERSION, + url = GOKZ_SOURCE_URL +}; + +#define UPDATER_URL GOKZ_UPDATER_BASE_URL..."gokz-paint.txt" + +char gC_PaintColors[][32] = +{ + "paint_red", + "paint_white", + "paint_black", + "paint_blue", + "paint_brown", + "paint_green", + "paint_yellow", + "paint_purple" +}; + +char gC_PaintSizePostfix[][8] = +{ + "_small", + "_med", + "_large" +}; + +int gI_Decals[sizeof(gC_PaintColors)][sizeof(gC_PaintSizePostfix)]; +float gF_LastPaintPos[MAXPLAYERS + 1][3]; +bool gB_IsPainting[MAXPLAYERS + 1]; + +TopMenu gTM_Options; +TopMenuObject gTMO_CatPaint; +TopMenuObject gTMO_ItemsPaint[PAINTOPTION_COUNT]; + + +// =====[ PLUGIN EVENTS ]===== + +public APLRes AskPluginLoad2(Handle myself, bool late, char[] error, int err_max) +{ + RegPluginLibrary("gokz-paint"); + return APLRes_Success; +} + +public void OnPluginStart() +{ + LoadTranslations("gokz-paint.phrases"); + + RegisterCommands(); +} + +public void OnAllPluginsLoaded() +{ + if (LibraryExists("updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + + TopMenu topMenu; + if (LibraryExists("gokz-core") && ((topMenu = GOKZ_GetOptionsTopMenu()) != null)) + { + GOKZ_OnOptionsMenuReady(topMenu); + } +} + +public void OnLibraryAdded(const char[] name) +{ + if (StrEqual(name, "updater")) + { + Updater_AddPlugin(UPDATER_URL); + } +} + + + +// =====[ EVENTS ]===== + +public void GOKZ_OnOptionsMenuCreated(TopMenu topMenu) +{ + OnOptionsMenuCreated_OptionsMenu(topMenu); +} + +public void GOKZ_OnOptionsMenuReady(TopMenu topMenu) +{ + OnOptionsMenuReady_Options(); + OnOptionsMenuReady_OptionsMenu(topMenu); +} + +public void OnMapStart() +{ + char buffer[PLATFORM_MAX_PATH]; + + AddFileToDownloadsTable("materials/gokz/paint/paint_decal.vtf"); + for (int color = 0; color < sizeof(gC_PaintColors); color++) + { + for (int size = 0; size < sizeof(gC_PaintSizePostfix); size++) + { + Format(buffer, sizeof(buffer), "gokz/paint/%s%s.vmt", gC_PaintColors[color], gC_PaintSizePostfix[size]); + gI_Decals[color][size] = PrecachePaint(buffer); + } + } + + CreateTimer(0.1, Timer_Paint, _, TIMER_REPEAT|TIMER_FLAG_NO_MAPCHANGE); +} + + + +// =====[ PAINT ]===== + +void Paint(int client) +{ + if (!IsValidClient(client) || + IsFakeClient(client)) + { + return; + } + + float position[3]; + bool hit = GetPlayerEyeViewPoint(client, position); + + if (!hit || GetVectorDistance(position, gF_LastPaintPos[client], true) < MIN_PAINT_SPACING) + { + return; + } + + int paint = GOKZ_GetOption(client, gC_PaintOptionNames[PaintOption_Color]); + int size = GOKZ_GetOption(client, gC_PaintOptionNames[PaintOption_Size]); + + TE_SetupWorldDecal(position, gI_Decals[paint][size]); + TE_SendToClient(client); + + gF_LastPaintPos[client] = position; +} + +public Action Timer_Paint(Handle timer) +{ + for (int client = 1; client <= MAXPLAYERS; client++) + { + if (gB_IsPainting[client]) + { + Paint(client); + } + } + return Plugin_Continue; +} + +void TE_SetupWorldDecal(const float origin[3], int index) +{ + TE_Start("World Decal"); + TE_WriteVector("m_vecOrigin", origin); + TE_WriteNum("m_nIndex", index); +} + +int PrecachePaint(char[] filename) +{ + char path[PLATFORM_MAX_PATH]; + Format(path, sizeof(path), "materials/%s", filename); + AddFileToDownloadsTable(path); + + return PrecacheDecal(filename, true); +} + +bool GetPlayerEyeViewPoint(int client, float position[3]) +{ + float angles[3]; + GetClientEyeAngles(client, angles); + + float origin[3]; + GetClientEyePosition(client, origin); + + Handle trace = TR_TraceRayFilterEx(origin, angles, MASK_PLAYERSOLID, RayType_Infinite, TraceEntityFilterPlayers); + if (TR_DidHit(trace)) + { + TR_GetEndPosition(position, trace); + delete trace; + return true; + } + delete trace; + return false; +} + + + +// =====[ OPTIONS ]===== + +void OnOptionsMenuReady_Options() +{ + RegisterOptions(); +} + +void RegisterOptions() +{ + for (PaintOption option; option < PAINTOPTION_COUNT; option++) + { + GOKZ_RegisterOption(gC_PaintOptionNames[option], gC_PaintOptionDescriptions[option], + OptionType_Int, gI_PaintOptionDefaults[option], 0, gI_PaintOptionCounts[option] - 1); + } +} + + + +// =====[ OPTIONS MENU ]===== + +void OnOptionsMenuCreated_OptionsMenu(TopMenu topMenu) +{ + if (gTM_Options == topMenu && gTMO_CatPaint != INVALID_TOPMENUOBJECT) + { + return; + } + + gTMO_CatPaint = topMenu.AddCategory(PAINT_OPTION_CATEGORY, TopMenuHandler_Categories); +} + +void OnOptionsMenuReady_OptionsMenu(TopMenu topMenu) +{ + // Make sure category exists + if (gTMO_CatPaint == INVALID_TOPMENUOBJECT) + { + GOKZ_OnOptionsMenuCreated(topMenu); + } + + if (gTM_Options == topMenu) + { + return; + } + + gTM_Options = topMenu; + + // Add gokz-paint option items + for (int option = 0; option < view_as<int>(PAINTOPTION_COUNT); option++) + { + gTMO_ItemsPaint[option] = gTM_Options.AddItem(gC_PaintOptionNames[option], TopMenuHandler_Paint, gTMO_CatPaint); + } +} + +void DisplayPaintOptionsMenu(int client) +{ + gTM_Options.DisplayCategory(gTMO_CatPaint, client); +} + +public void TopMenuHandler_Categories(TopMenu topmenu, TopMenuAction action, TopMenuObject topobj_id, int param, char[] buffer, int maxlength) +{ + if (action == TopMenuAction_DisplayOption || action == TopMenuAction_DisplayTitle) + { + if (topobj_id == gTMO_CatPaint) + { + Format(buffer, maxlength, "%T", "Options Menu - Paint", param); + } + } +} + +public void TopMenuHandler_Paint(TopMenu topmenu, TopMenuAction action, TopMenuObject topobj_id, int param, char[] buffer, int maxlength) +{ + PaintOption option = PAINTOPTION_INVALID; + for (int i = 0; i < view_as<int>(PAINTOPTION_COUNT); i++) + { + if (topobj_id == gTMO_ItemsPaint[i]) + { + option = view_as<PaintOption>(i); + break; + } + } + + if (option == PAINTOPTION_INVALID) + { + return; + } + + if (action == TopMenuAction_DisplayOption) + { + switch (option) + { + case PaintOption_Color: + { + FormatEx(buffer, maxlength, "%T - %T", + gC_PaintOptionPhrases[option], param, + gC_PaintColorPhrases[GOKZ_GetOption(param, gC_PaintOptionNames[option])], param); + } + case PaintOption_Size: + { + FormatEx(buffer, maxlength, "%T - %T", + gC_PaintOptionPhrases[option], param, + gC_PaintSizePhrases[GOKZ_GetOption(param, gC_PaintOptionNames[option])], param); + } + } + } + else if (action == TopMenuAction_SelectOption) + { + if (option == PaintOption_Color) + { + DisplayColorMenu(param); + } + else + { + GOKZ_CycleOption(param, gC_PaintOptionNames[option]); + gTM_Options.Display(param, TopMenuPosition_LastCategory); + } + } +} + +void DisplayColorMenu(int client) +{ + char buffer[32]; + + Menu menu = new Menu(MenuHandler_PaintColor); + menu.ExitButton = true; + menu.ExitBackButton = true; + menu.SetTitle("%T", "Paint Color Menu - Title", client); + + for (int i = 0; i < PAINTCOLOR_COUNT; i++) + { + FormatEx(buffer, sizeof(buffer), "%T", gC_PaintColorPhrases[i], client); + menu.AddItem(gC_PaintColors[i], buffer); + } + + menu.Display(client, MENU_TIME_FOREVER); +} + +int MenuHandler_PaintColor(Menu menu, MenuAction action, int param1, int param2) +{ + switch (action) + { + case MenuAction_Select: + { + char item[32]; + menu.GetItem(param2, item, sizeof(item)); + + for (int i = 0; i < PAINTCOLOR_COUNT; i++) + { + if (StrEqual(gC_PaintColors[i], item)) + { + GOKZ_SetOption(param1, gC_PaintOptionNames[PaintOption_Color], i); + DisplayPaintOptionsMenu(param1); + return 0; + } + } + } + + case MenuAction_Cancel: + { + if (param2 == MenuCancel_ExitBack) + { + DisplayPaintOptionsMenu(param1); + } + } + + case MenuAction_End: + { + delete menu; + } + } + + return 0; +} + + + +// =====[ COMMANDS ]===== + +void RegisterCommands() +{ + RegConsoleCmd("+paint", CommandPaintStart, "[KZ] Start painting."); + RegConsoleCmd("-paint", CommandPaintEnd, "[KZ] Stop painting."); + RegConsoleCmd("sm_paint", CommandPaint, "[KZ] Place a paint."); + RegConsoleCmd("sm_paintoptions", CommandPaintOptions, "[KZ] Open the paint options."); +} + +public Action CommandPaintStart(int client, int args) +{ + gB_IsPainting[client] = true; + return Plugin_Handled; +} + +public Action CommandPaintEnd(int client, int args) +{ + gB_IsPainting[client] = false; + return Plugin_Handled; +} + +public Action CommandPaint(int client, int args) +{ + Paint(client); + return Plugin_Handled; +} + +public Action CommandPaintOptions(int client, int args) +{ + DisplayPaintOptionsMenu(client); + return Plugin_Handled; +} diff --git a/sourcemod/scripting/gokz-pistol.sp b/sourcemod/scripting/gokz-pistol.sp new file mode 100644 index 0000000..53f79d9 --- /dev/null +++ b/sourcemod/scripting/gokz-pistol.sp @@ -0,0 +1,303 @@ +#include <sourcemod> + +#include <cstrike> +#include <sdktools> + +#include <gokz/core> +#include <gokz/pistol> + +#undef REQUIRE_EXTENSIONS +#undef REQUIRE_PLUGIN +#include <updater> + +#pragma newdecls required +#pragma semicolon 1 + + + +public Plugin myinfo = +{ + name = "GOKZ Pistol", + author = "DanZay", + description = "Allows players to pick a pistol to KZ with", + version = GOKZ_VERSION, + url = GOKZ_SOURCE_URL +}; + +#define UPDATER_URL GOKZ_UPDATER_BASE_URL..."gokz-pistols.txt" + +TopMenu gTM_Options; +TopMenuObject gTMO_CatGeneral; +TopMenuObject gTMO_ItemPistol; +bool gB_CameFromOptionsMenu[MAXPLAYERS + 1]; + + + +// =====[ PLUGIN EVENTS ]===== + +public APLRes AskPluginLoad2(Handle myself, bool late, char[] error, int err_max) +{ + RegPluginLibrary("gokz-pistol"); + return APLRes_Success; +} + +public void OnPluginStart() +{ + LoadTranslations("gokz-common.phrases"); + LoadTranslations("gokz-pistol.phrases"); + + HookEvents(); + RegisterCommands(); +} + +public void OnAllPluginsLoaded() +{ + if (LibraryExists("updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + + TopMenu topMenu; + if (LibraryExists("gokz-core") && ((topMenu = GOKZ_GetOptionsTopMenu()) != null)) + { + GOKZ_OnOptionsMenuReady(topMenu); + } +} + +public void OnLibraryAdded(const char[] name) +{ + if (StrEqual(name, "updater")) + { + Updater_AddPlugin(UPDATER_URL); + } +} + + + +// =====[ CLIENT EVENTS ]===== + +public void OnPlayerSpawn(Event event, const char[] name, bool dontBroadcast) // player_spawn post hook +{ + int client = GetClientOfUserId(event.GetInt("userid")); + if (IsValidClient(client)) + { + UpdatePistol(client); + } +} + +public void GOKZ_OnOptionChanged(int client, const char[] option, any newValue) +{ + if (StrEqual(option, PISTOL_OPTION_NAME)) + { + UpdatePistol(client); + } +} + + + +// =====[ OTHER EVENTS ]===== + +public void GOKZ_OnOptionsMenuReady(TopMenu topMenu) +{ + OnOptionsMenuReady_Options(); + OnOptionsMenuReady_OptionsMenu(topMenu); +} + + + +// =====[ GENERAL ]===== + +void HookEvents() +{ + HookEvent("player_spawn", OnPlayerSpawn, EventHookMode_Post); +} + + + +// =====[ PISTOL ]===== + +void UpdatePistol(int client) +{ + GivePistol(client, GOKZ_GetOption(client, PISTOL_OPTION_NAME)); +} + +void GivePistol(int client, int pistol) +{ + if (!IsClientInGame(client) || !IsPlayerAlive(client) + || GetClientTeam(client) == CS_TEAM_NONE) + { + return; + } + + int playerTeam = GetClientTeam(client); + bool switchedTeams = false; + + // Switch teams to the side that buys that gun so that gun skins load + if (gI_PistolTeams[pistol] == CS_TEAM_CT && playerTeam != CS_TEAM_CT) + { + CS_SwitchTeam(client, CS_TEAM_CT); + switchedTeams = true; + } + else if (gI_PistolTeams[pistol] == CS_TEAM_T && playerTeam != CS_TEAM_T) + { + CS_SwitchTeam(client, CS_TEAM_T); + switchedTeams = true; + } + + // Give the player this pistol (or remove it) + int currentPistol = GetPlayerWeaponSlot(client, CS_SLOT_SECONDARY); + if (currentPistol != -1) + { + RemovePlayerItem(client, currentPistol); + } + + if (pistol == Pistol_Disabled) + { + // Force switch to knife to avoid weird behaviour + // Doesn't use EquipPlayerWeapon because server hangs when player spawns + FakeClientCommand(client, "use weapon_knife"); + } + else + { + GivePlayerItem(client, gC_PistolClassNames[pistol]); + } + + // Go back to original team + if (switchedTeams) + { + CS_SwitchTeam(client, playerTeam); + } +} + + + +// =====[ PISTOL MENU ]===== + +void DisplayPistolMenu(int client, int atItem = 0, bool fromOptionsMenu = false) +{ + Menu menu = new Menu(MenuHandler_Pistol); + menu.SetTitle("%T", "Pistol Menu - Title", client); + PistolMenuAddItems(client, menu); + menu.DisplayAt(client, atItem, MENU_TIME_FOREVER); + + gB_CameFromOptionsMenu[client] = fromOptionsMenu; +} + +public int MenuHandler_Pistol(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + GOKZ_SetOption(param1, PISTOL_OPTION_NAME, param2); + DisplayPistolMenu(param1, param2 / 6 * 6, gB_CameFromOptionsMenu[param1]); // Re-display menu at same spot + } + else if (action == MenuAction_Cancel && gB_CameFromOptionsMenu[param1]) + { + gTM_Options.Display(param1, TopMenuPosition_LastCategory); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + +void PistolMenuAddItems(int client, Menu menu) +{ + int selectedPistol = GOKZ_GetOption(client, PISTOL_OPTION_NAME); + char display[32]; + + for (int pistol = 0; pistol < PISTOL_COUNT; pistol++) + { + if (pistol == Pistol_Disabled) + { + FormatEx(display, sizeof(display), "%T", "Options Menu - Disabled", client); + } + else + { + FormatEx(display, sizeof(display), "%s", gC_PistolNames[pistol]); + } + + // Add asterisk to selected pistol + if (pistol == selectedPistol) + { + Format(display, sizeof(display), "%s*", display); + } + + menu.AddItem("", display, ITEMDRAW_DEFAULT); + } +} + + + +// =====[ OPTIONS ]===== + +void OnOptionsMenuReady_Options() +{ + RegisterOption(); +} + +void RegisterOption() +{ + GOKZ_RegisterOption(PISTOL_OPTION_NAME, PISTOL_OPTION_DESCRIPTION, + OptionType_Int, Pistol_USPS, 0, PISTOL_COUNT - 1); +} + + + +// =====[ OPTIONS MENU ]===== + +void OnOptionsMenuReady_OptionsMenu(TopMenu topMenu) +{ + if (gTM_Options == topMenu) + { + return; + } + + gTM_Options = topMenu; + gTMO_CatGeneral = gTM_Options.FindCategory(GENERAL_OPTION_CATEGORY); + gTMO_ItemPistol = gTM_Options.AddItem(PISTOL_OPTION_NAME, TopMenuHandler_Pistol, gTMO_CatGeneral); +} + +public void TopMenuHandler_Pistol(TopMenu topmenu, TopMenuAction action, TopMenuObject topobj_id, int param, char[] buffer, int maxlength) +{ + if (topobj_id != gTMO_ItemPistol) + { + return; + } + + if (action == TopMenuAction_DisplayOption) + { + int pistol = GOKZ_GetOption(param, PISTOL_OPTION_NAME); + if (pistol == Pistol_Disabled) + { + FormatEx(buffer, maxlength, "%T - %T", + "Options Menu - Pistol", param, + "Options Menu - Disabled", param); + } + else + { + FormatEx(buffer, maxlength, "%T - %s", + "Options Menu - Pistol", param, + gC_PistolNames[pistol]); + } + } + else if (action == TopMenuAction_SelectOption) + { + DisplayPistolMenu(param, _, true); + } +} + + + +// =====[ COMMANDS ]===== + +void RegisterCommands() +{ + RegConsoleCmd("sm_pistol", CommandPistolMenu, "[KZ] Open the pistol selection menu."); +} + +public Action CommandPistolMenu(int client, int args) +{ + DisplayPistolMenu(client); + return Plugin_Handled; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-playermodels.sp b/sourcemod/scripting/gokz-playermodels.sp new file mode 100644 index 0000000..237b7df --- /dev/null +++ b/sourcemod/scripting/gokz-playermodels.sp @@ -0,0 +1,198 @@ +#include <sourcemod> + +#include <cstrike> +#include <sdktools> + +#include <gokz/core> + +#include <autoexecconfig> + +#undef REQUIRE_EXTENSIONS +#undef REQUIRE_PLUGIN +#include <updater> + +#pragma newdecls required +#pragma semicolon 1 + + + +public Plugin myinfo = +{ + name = "GOKZ Player Models", + author = "DanZay", + description = "Sets player's model upon spawning", + version = GOKZ_VERSION, + url = GOKZ_SOURCE_URL +}; + +#define UPDATER_URL GOKZ_UPDATER_BASE_URL..."gokz-playermodels.txt" +#define PLAYER_MODEL_T "models/player/tm_leet_varianta.mdl" +#define PLAYER_MODEL_CT "models/player/ctm_idf_variantc.mdl" +#define PLAYER_MODEL_T_BOT "models/player/custom_player/legacy/tm_leet_varianta.mdl" +#define PLAYER_MODEL_CT_BOT "models/player/custom_player/legacy/ctm_idf_variantc.mdl" +ConVar gCV_gokz_player_models_alpha; +ConVar gCV_sv_disable_immunity_alpha; + + + +// =====[ PLUGIN EVENTS ]===== + +public APLRes AskPluginLoad2(Handle myself, bool late, char[] error, int err_max) +{ + RegPluginLibrary("gokz-playermodels"); + return APLRes_Success; +} + +public void OnPluginStart() +{ + CreateConVars(); + HookEvents(); +} + +public void OnAllPluginsLoaded() +{ + if (LibraryExists("updater")) + { + Updater_AddPlugin(UPDATER_URL); + } +} + +public void OnLibraryAdded(const char[] name) +{ + if (StrEqual(name, "updater")) + { + Updater_AddPlugin(UPDATER_URL); + } +} + + + +// =====[ CLIENT EVENTS ]===== + +public void OnPlayerSpawn(Event event, const char[] name, bool dontBroadcast) // player_spawn post hook +{ + int client = GetClientOfUserId(event.GetInt("userid")); + if (IsValidClient(client)) + { + // Can't use a timer here because it's not precise enough. We want exactly 2 ticks of delay! + // 2 ticks is the minimum amount of time after which gloves will work. + // The reason we need precision is because SetEntityModel momentarily resets the + // player hull to standing (or something along those lines), so when a player + // spawns/gets reset to a crouch tunnel where there's a trigger less than 18 units from the top + // of the ducked player hull, then they touch that trigger! SetEntityModel interferes with the + // fix for that (JoinTeam in gokz-core/misc calls TeleportPlayer in gokz.inc, which fixes that bug). + RequestFrame(RequestFrame_UpdatePlayerModel, GetClientUserId(client)); + } +} + + + +// =====[ OTHER EVENTS ]===== + +public void OnMapStart() +{ + PrecachePlayerModels(); +} + + + +// =====[ GENERAL ]===== + +void HookEvents() +{ + HookEvent("player_spawn", OnPlayerSpawn, EventHookMode_Post); +} + + + +// =====[ CONVARS ]===== + +void CreateConVars() +{ + AutoExecConfig_SetFile("gokz-playermodels", "sourcemod/gokz"); + AutoExecConfig_SetCreateFile(true); + + gCV_gokz_player_models_alpha = AutoExecConfig_CreateConVar("gokz_player_models_alpha", "65", "Amount of alpha (transparency) to set player models to.", _, true, 0.0, true, 255.0); + gCV_gokz_player_models_alpha.AddChangeHook(OnConVarChanged); + + AutoExecConfig_ExecuteFile(); + AutoExecConfig_CleanFile(); + + gCV_sv_disable_immunity_alpha = FindConVar("sv_disable_immunity_alpha"); +} + +public void OnConVarChanged(ConVar convar, const char[] oldValue, const char[] newValue) +{ + if (convar == gCV_gokz_player_models_alpha) + { + for (int client = 1; client <= MaxClients; client++) + { + if (IsClientInGame(client) && IsPlayerAlive(client)) + { + UpdatePlayerModelAlpha(client); + } + } + } +} + + + +// =====[ PLAYER MODELS ]===== + +public void RequestFrame_UpdatePlayerModel(int userid) +{ + RequestFrame(RequestFrame_UpdatePlayerModel2, userid); +} + +public void RequestFrame_UpdatePlayerModel2(int userid) +{ + int client = GetClientOfUserId(userid); + if (!IsValidClient(client) || !IsPlayerAlive(client)) + { + return; + } + // Bots are unaffected by the bobbing animation caused by the new models. + switch (GetClientTeam(client)) + { + case CS_TEAM_T: + { + if (IsFakeClient(client)) + { + SetEntityModel(client, PLAYER_MODEL_T_BOT); + } + else + { + SetEntityModel(client, PLAYER_MODEL_T); + } + } + case CS_TEAM_CT: + { + if (IsFakeClient(client)) + { + SetEntityModel(client, PLAYER_MODEL_CT_BOT); + } + else + { + SetEntityModel(client, PLAYER_MODEL_CT); + } + } + } + + UpdatePlayerModelAlpha(client); +} + +void UpdatePlayerModelAlpha(int client) +{ + SetEntityRenderMode(client, RENDER_TRANSCOLOR); + SetEntityRenderColor(client, _, _, _, gCV_gokz_player_models_alpha.IntValue); +} + +void PrecachePlayerModels() +{ + gCV_sv_disable_immunity_alpha.IntValue = 1; // Ensures player transparency works + + PrecacheModel(PLAYER_MODEL_T, true); + PrecacheModel(PLAYER_MODEL_CT, true); + PrecacheModel(PLAYER_MODEL_T_BOT, true); + PrecacheModel(PLAYER_MODEL_CT_BOT, true); +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-profile.sp b/sourcemod/scripting/gokz-profile.sp new file mode 100644 index 0000000..9d92e61 --- /dev/null +++ b/sourcemod/scripting/gokz-profile.sp @@ -0,0 +1,396 @@ +#include <sourcemod> + +#include <cstrike> + +#include <gokz/core> +#include <gokz/profile> +#include <gokz/global> + +#undef REQUIRE_EXTENSIONS +#undef REQUIRE_PLUGIN +#include <updater> +#include <gokz/chat> + +#pragma newdecls required +#pragma semicolon 1 + + + +public Plugin myinfo = +{ + name = "GOKZ Profile", + author = "zealain", + description = "Player profiles and ranks based on local and global data.", + version = GOKZ_VERSION, + url = GOKZ_SOURCE_URL +}; + +#define UPDATER_URL GOKZ_UPDATER_BASE_URL..."gokz-profile.txt" + +int gI_Rank[MAXPLAYERS + 1][MODE_COUNT]; +bool gB_Localranks; +bool gB_Chat; + +#include "gokz-profile/options.sp" +#include "gokz-profile/profile.sp" + + + +// =====[ PLUGIN EVENTS ]===== + +public APLRes AskPluginLoad2(Handle myself, bool late, char[] error, int err_max) +{ + CreateNatives(); + RegPluginLibrary("gokz-profile"); + return APLRes_Success; +} + +public void OnPluginStart() +{ + LoadTranslations("common.phrases"); + LoadTranslations("gokz-profile.phrases"); + CreateGlobalForwards(); + RegisterCommands(); +} + +public void OnAllPluginsLoaded() +{ + if (LibraryExists("updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + gB_Localranks = LibraryExists("gokz-localranks"); + gB_Chat = LibraryExists("gokz-chat"); + + for (int client = 1; client <= MaxClients; client++) + { + if (IsValidClient(client) && !IsFakeClient(client)) + { + UpdateRank(client, GOKZ_GetCoreOption(client, Option_Mode)); + } + } + + TopMenu topMenu; + if (LibraryExists("gokz-core") && ((topMenu = GOKZ_GetOptionsTopMenu()) != null)) + { + GOKZ_OnOptionsMenuReady(topMenu); + } +} + +public void OnLibraryAdded(const char[] name) +{ + if (StrEqual(name, "updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + gB_Localranks = gB_Localranks || StrEqual(name, "gokz-localranks"); + gB_Chat = gB_Chat || StrEqual(name, "gokz-chat"); +} + +public void OnLibraryRemoved(const char[] name) +{ + gB_Localranks = gB_Localranks && !StrEqual(name, "gokz-localranks"); + gB_Chat = gB_Chat && !StrEqual(name, "gokz-chat"); +} + + + +// =====[ EVENTS ]===== + +public Action OnClientCommandKeyValues(int client, KeyValues kv) +{ + // Block clan tag changes - Credit: GoD-Tony (https://forums.alliedmods.net/showpost.php?p=2337679&postcount=6) + char cmd[16]; + if (kv.GetSectionName(cmd, sizeof(cmd)) && StrEqual(cmd, "ClanTagChanged", false)) + { + return Plugin_Handled; + } + return Plugin_Continue; +} + +public void OnRebuildAdminCache(AdminCachePart part) +{ + for (int client = 1; client <= MaxClients; client++) + { + if (IsValidClient(client) && !IsFakeClient(client)) + { + int mode = GOKZ_GetCoreOption(client, Option_Mode); + UpdateRank(client, mode); + } + } +} + +public void GOKZ_OnOptionsMenuCreated(TopMenu topMenu) +{ + OnOptionsMenuCreated_OptionsMenu(topMenu); +} + +public void GOKZ_OnOptionsMenuReady(TopMenu topMenu) +{ + OnOptionsMenuReady_Options(); + OnOptionsMenuReady_OptionsMenu(topMenu); +} + +public void GOKZ_OnOptionsLoaded(int client) +{ + if (IsValidClient(client) && !IsFakeClient(client)) + { + int mode = GOKZ_GetCoreOption(client, Option_Mode); + UpdateTags(client, gI_Rank[client][mode], mode); + } +} + +public void OnClientConnected(int client) +{ + for (int mode = 0; mode < MODE_COUNT; mode++) + { + gI_Rank[client][mode] = 0; + } + Profile_OnClientConnected(client); +} + +public void OnClientDisconnect(int client) +{ + Profile_OnClientDisconnect(client); +} + +public void GOKZ_OnOptionChanged(int client, const char[] option, any newValue) +{ + Option coreOption; + if (GOKZ_IsCoreOption(option, coreOption) && coreOption == Option_Mode) + { + UpdateRank(client, newValue); + } + else if (StrEqual(option, gC_ProfileOptionNames[ProfileOption_ShowRankChat], true) + || StrEqual(option, gC_ProfileOptionNames[ProfileOption_ShowRankClanTag], true) + || StrEqual(option, gC_ProfileOptionNames[ProfileOption_TagType], true)) + { + UpdateRank(client, GOKZ_GetCoreOption(client, Option_Mode)); + } +} + +public void GOKZ_GL_OnPointsUpdated(int client, int mode) +{ + UpdateRank(client, mode); + Profile_OnPointsUpdated(client, mode); +} + +public void UpdateRank(int client, int mode) +{ + if (!IsValidClient(client) || IsFakeClient(client)) + { + return; + } + + int tagType = GetAvailableTagTypeOrDefault(client); + + if (tagType != ProfileTagType_Rank) + { + char clanTag[64], chatTag[32], color[64]; + + if (tagType == ProfileTagType_Admin) + { + FormatEx(clanTag, sizeof(clanTag), "[%s %T]", gC_ModeNamesShort[mode], "Tag - Admin", client); + FormatEx(chatTag, sizeof(chatTag), "%T", "Tag - Admin", client); + color = TAG_COLOR_ADMIN; + } + if (tagType == ProfileTagType_VIP) + { + FormatEx(clanTag, sizeof(clanTag), "[%s %T]", gC_ModeNamesShort[mode], "Tag - VIP", client); + FormatEx(chatTag, sizeof(chatTag), "%T", "Tag - VIP", client); + color = TAG_COLOR_VIP; + } + + if (GOKZ_GetOption(client, gC_ProfileOptionNames[ProfileOption_ShowRankClanTag]) != ProfileOptionBool_Enabled) + { + FormatEx(clanTag, sizeof(clanTag), "[%s]", gC_ModeNamesShort[mode]); + } + CS_SetClientClanTag(client, clanTag); + + if (gB_Chat) + { + if (GOKZ_GetOption(client, gC_ProfileOptionNames[ProfileOption_ShowRankChat]) == ProfileOptionBool_Enabled) + { + GOKZ_CH_SetChatTag(client, chatTag, color); + } + else + { + GOKZ_CH_SetChatTag(client, "", "{default}"); + } + } + return; + } + + int points = GOKZ_GL_GetRankPoints(client, mode); + int rank; + for (rank = 1; rank < RANK_COUNT; rank++) + { + if (points < gI_rankThreshold[mode][rank]) + { + break; + } + } + rank--; + + if (GOKZ_GetCoreOption(client, Option_Mode) == mode) + { + if (points == -1) + { + UpdateTags(client, -1, mode); + } + else + { + UpdateTags(client, rank, mode); + } + } + + if (gI_Rank[client][mode] != rank) + { + gI_Rank[client][mode] = rank; + Call_OnRankUpdated(client, mode, rank); + } +} + +void UpdateTags(int client, int rank, int mode) +{ + char str[64]; + if (rank != -1 && + GOKZ_GetOption(client, gC_ProfileOptionNames[ProfileOption_ShowRankClanTag]) == ProfileOptionBool_Enabled) + { + FormatEx(str, sizeof(str), "[%s %s]", gC_ModeNamesShort[mode], gC_rankName[rank]); + CS_SetClientClanTag(client, str); + } + else + { + FormatEx(str, sizeof(str), "[%s]", gC_ModeNamesShort[mode]); + CS_SetClientClanTag(client, str); + } + + if (gB_Chat) + { + if (rank != -1 && + GOKZ_GetOption(client, gC_ProfileOptionNames[ProfileOption_ShowRankChat]) == ProfileOptionBool_Enabled) + { + GOKZ_CH_SetChatTag(client, gC_rankName[rank], gC_rankColor[rank]); + } + else + { + GOKZ_CH_SetChatTag(client, "", "{default}"); + } + } +} + +bool CanUseTagType(int client, int tagType) +{ + switch (tagType) + { + case ProfileTagType_Rank: return true; + case ProfileTagType_VIP: return CheckCommandAccess(client, "gokz_flag_vip", ADMFLAG_CUSTOM1); + case ProfileTagType_Admin: return CheckCommandAccess(client, "gokz_flag_admin", ADMFLAG_GENERIC); + default: return false; + } +} + +int GetAvailableTagTypeOrDefault(int client) +{ + int tagType = GOKZ_GetOption(client, gC_ProfileOptionNames[ProfileOption_TagType]); + if (!CanUseTagType(client, tagType)) + { + return ProfileTagType_Rank; + } + + return tagType; +} + +// =====[ COMMANDS ]===== + +void RegisterCommands() +{ + RegConsoleCmd("sm_profile", CommandProfile, "[KZ] Show the profile of a player. Usage: !profile <player>"); + RegConsoleCmd("sm_p", CommandProfile, "[KZ] Show the profile of a player. Usage: !p <player>"); + RegConsoleCmd("sm_profileoptions", CommandProfileOptions, "[KZ] Show the profile options."); + RegConsoleCmd("sm_pfo", CommandProfileOptions, "[KZ] Show the profile options."); + RegConsoleCmd("sm_ranks", CommandRanks, "[KZ] Show all the available ranks."); +} + +public Action CommandProfile(int client, int args) +{ + if (args == 0) + { + ShowProfile(client, client); + } + else + { + char playerName[64]; + GetCmdArgString(playerName, sizeof(playerName)); + int player = FindTarget(client, playerName, true, false); + if (player != -1) + { + ShowProfile(client, player); + } + } + return Plugin_Handled; +} + +public Action CommandProfileOptions(int client, int args) +{ + DisplayProfileOptionsMenu(client); + return Plugin_Handled; +} + +public Action CommandRanks(int client, int args) +{ + char rankBuffer[256]; + char buffer[256]; + int mode = GOKZ_GetCoreOption(client, Option_Mode); + + Format(buffer, sizeof(buffer), "%s: ", gC_ModeNamesShort[mode]); + + for (int i = 0; i < RANK_COUNT; i++) { + Format(rankBuffer, sizeof(rankBuffer), "%s%s (%d) ", gC_rankColor[i], gC_rankName[i], gI_rankThreshold[mode][i]); + StrCat(buffer, sizeof(buffer), rankBuffer); + + if (i > 0 && i % 3 == 0) { + GOKZ_PrintToChat(client, true, buffer); + Format(buffer, sizeof(buffer), "%s: ", gC_ModeNamesShort[mode]); + } + } + + GOKZ_PrintToChat(client, true, buffer); + + return Plugin_Handled; +} + + +// =====[ FORWARDS ]===== + +static GlobalForward H_OnRankUpdated; + + +void CreateGlobalForwards() +{ + H_OnRankUpdated = new GlobalForward("GOKZ_PF_OnRankUpdated", ET_Ignore, Param_Cell, Param_Cell, Param_Cell); +} + +void Call_OnRankUpdated(int client, int mode, int rank) +{ + Call_StartForward(H_OnRankUpdated); + Call_PushCell(client); + Call_PushCell(mode); + Call_PushCell(rank); + Call_Finish(); +} + + + +// =====[ NATIVES ]===== + +void CreateNatives() +{ + CreateNative("GOKZ_PF_GetRank", Native_GetRank); +} + +public int Native_GetRank(Handle plugin, int numParams) +{ + return gI_Rank[GetNativeCell(1)][GetNativeCell(2)]; +} diff --git a/sourcemod/scripting/gokz-profile/options.sp b/sourcemod/scripting/gokz-profile/options.sp new file mode 100644 index 0000000..de8da51 --- /dev/null +++ b/sourcemod/scripting/gokz-profile/options.sp @@ -0,0 +1,128 @@ + +// =====[ OPTIONS ]===== + +void OnOptionsMenuReady_Options() +{ + RegisterOptions(); +} + +void RegisterOptions() +{ + for (ProfileOption option; option < PROFILEOPTION_COUNT; option++) + { + GOKZ_RegisterOption(gC_ProfileOptionNames[option], gC_ProfileOptionDescriptions[option], + OptionType_Int, gI_ProfileOptionDefaults[option], 0, gI_ProfileOptionCounts[option] - 1); + } +} + + + +// =====[ OPTIONS MENU ]===== + +TopMenu gTM_Options; +TopMenuObject gTMO_CatProfile; +TopMenuObject gTMO_ItemsProfile[PROFILEOPTION_COUNT]; + +void OnOptionsMenuCreated_OptionsMenu(TopMenu topMenu) +{ + if (gTM_Options == topMenu && gTMO_CatProfile != INVALID_TOPMENUOBJECT) + { + return; + } + + gTMO_CatProfile = topMenu.AddCategory(PROFILE_OPTION_CATEGORY, TopMenuHandler_Categories); +} + +void OnOptionsMenuReady_OptionsMenu(TopMenu topMenu) +{ + // Make sure category exists + if (gTMO_CatProfile == INVALID_TOPMENUOBJECT) + { + GOKZ_OnOptionsMenuCreated(topMenu); + } + + if (gTM_Options == topMenu) + { + return; + } + + gTM_Options = topMenu; + + // Add gokz-profile option items + for (int option = 0; option < view_as<int>(PROFILEOPTION_COUNT); option++) + { + gTMO_ItemsProfile[option] = gTM_Options.AddItem(gC_ProfileOptionNames[option], TopMenuHandler_Profile, gTMO_CatProfile); + } +} + +void DisplayProfileOptionsMenu(int client) +{ + if (gTMO_CatProfile != INVALID_TOPMENUOBJECT) + { + gTM_Options.DisplayCategory(gTMO_CatProfile, client); + } +} + +public void TopMenuHandler_Categories(TopMenu topmenu, TopMenuAction action, TopMenuObject topobj_id, int param, char[] buffer, int maxlength) +{ + if (action == TopMenuAction_DisplayOption || action == TopMenuAction_DisplayTitle) + { + if (topobj_id == gTMO_CatProfile) + { + Format(buffer, maxlength, "%T", "Options Menu - Profile", param); + } + } +} + +public void TopMenuHandler_Profile(TopMenu topmenu, TopMenuAction action, TopMenuObject topobj_id, int param, char[] buffer, int maxlength) +{ + ProfileOption option = PROFILEOPTION_INVALID; + for (int i = 0; i < view_as<int>(PROFILEOPTION_COUNT); i++) + { + if (topobj_id == gTMO_ItemsProfile[i]) + { + option = view_as<ProfileOption>(i); + break; + } + } + + if (option == PROFILEOPTION_INVALID) + { + return; + } + + if (action == TopMenuAction_DisplayOption) + { + if (option == ProfileOption_TagType) + { + FormatEx(buffer, maxlength, "%T - %T", + gC_ProfileOptionPhrases[option], param, + gC_ProfileTagTypePhrases[GOKZ_GetOption(param, gC_ProfileOptionNames[option])], param); + } + else + { + FormatEx(buffer, maxlength, "%T - %T", + gC_ProfileOptionPhrases[option], param, + gC_ProfileBoolPhrases[GOKZ_GetOption(param, gC_ProfileOptionNames[option])], param); + } + } + else if (action == TopMenuAction_SelectOption) + { + GOKZ_CycleOption(param, gC_ProfileOptionNames[option]); + + if (option == ProfileOption_TagType) + { + for (int i = 0; i < PROFILETAGTYPE_COUNT; i++) + { + int tagType = GOKZ_GetOption(param, gC_ProfileOptionNames[option]); + if (!CanUseTagType(param, tagType)) + { + GOKZ_CycleOption(param, gC_ProfileOptionNames[option]); + } + } + } + + gTM_Options.Display(param, TopMenuPosition_LastCategory); + } +} + diff --git a/sourcemod/scripting/gokz-profile/profile.sp b/sourcemod/scripting/gokz-profile/profile.sp new file mode 100644 index 0000000..fabdb0e --- /dev/null +++ b/sourcemod/scripting/gokz-profile/profile.sp @@ -0,0 +1,222 @@ + +#define ITEM_INFO_NAME "name" +#define ITEM_INFO_MODE "mode" +#define ITEM_INFO_RANK "rank" +#define ITEM_INFO_POINTS "points" + +int profileTargetPlayer[MAXPLAYERS]; +int profileMode[MAXPLAYERS]; +bool profileWaitingForUpdate[MAXPLAYERS]; + + + +// =====[ PUBLIC ]===== + +void ShowProfile(int client, int player = 0) +{ + if (player != 0) + { + profileTargetPlayer[client] = player; + profileMode[client] = GOKZ_GetCoreOption(player, Option_Mode); + } + + if (GOKZ_GL_GetRankPoints(profileTargetPlayer[client], profileMode[client]) < 0) + { + if (!profileWaitingForUpdate[client]) + { + GOKZ_GL_UpdatePoints(profileTargetPlayer[client], profileMode[client]); + profileWaitingForUpdate[client] = true; + } + return; + } + + profileWaitingForUpdate[client] = false; + Menu menu = new Menu(MenuHandler_Profile); + menu.SetTitle("%T - %N", "Profile Menu - Title", client, profileTargetPlayer[client]); + ProfileMenuAddItems(client, menu); + menu.Display(client, MENU_TIME_FOREVER); +} + + + +// =====[ EVENTS ]===== + +void Profile_OnClientConnected(int client) +{ + profileTargetPlayer[client] = 0; + profileWaitingForUpdate[client] = false; +} + +void Profile_OnClientDisconnect(int client) +{ + profileTargetPlayer[client] = 0; + profileWaitingForUpdate[client] = false; +} + +void Profile_OnPointsUpdated(int player, int mode) +{ + for (int client = 1; client <= MaxClients; client++) + { + if (profileWaitingForUpdate[client] + && profileTargetPlayer[client] == player + && profileMode[client] == mode) + { + ShowProfile(client); + } + } +} + +public int MenuHandler_Profile(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + char info[16]; + menu.GetItem(param2, info, sizeof(info)); + + if (StrEqual(info, ITEM_INFO_MODE, false)) + { + if (++profileMode[param1] == MODE_COUNT) + { + profileMode[param1] = 0; + } + } + else if (StrEqual(info, ITEM_INFO_RANK, false)) + { + ShowRankInfo(param1); + return 0; + } + else if (StrEqual(info, ITEM_INFO_POINTS, false)) + { + ShowPointsInfo(param1); + return 0; + } + + ShowProfile(param1); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + + + +// =====[ PRIVATE ]===== + +static void ProfileMenuAddItems(int client, Menu menu) +{ + char display[32]; + int player = profileTargetPlayer[client]; + int mode = profileMode[client]; + + FormatEx(display, sizeof(display), "%T: %s", + "Profile Menu - Mode", client, gC_ModeNames[mode]); + menu.AddItem(ITEM_INFO_MODE, display); + + FormatEx(display, sizeof(display), "%T: %s", + "Profile Menu - Rank", client, gC_rankName[gI_Rank[player][mode]]); + menu.AddItem(ITEM_INFO_RANK, display); + + FormatEx(display, sizeof(display), "%T: %d", + "Profile Menu - Points", client, GOKZ_GL_GetRankPoints(player, mode)); + menu.AddItem(ITEM_INFO_POINTS, display); +} + +static void ShowRankInfo(int client) +{ + Menu menu = new Menu(MenuHandler_RankInfo); + menu.SetTitle("%T - %N", "Rank Info Menu - Title", client, profileTargetPlayer[client]); + RankInfoMenuAddItems(client, menu); + menu.Display(client, MENU_TIME_FOREVER); +} + +static void RankInfoMenuAddItems(int client, Menu menu) +{ + char display[32]; + int player = profileTargetPlayer[client]; + int mode = profileMode[client]; + + FormatEx(display, sizeof(display), "%T: %s", + "Rank Info Menu - Current Rank", client, gC_rankName[gI_Rank[player][mode]]); + menu.AddItem("", display); + + int next_rank = gI_Rank[player][mode] + 1; + if (next_rank == RANK_COUNT) + { + FormatEx(display, sizeof(display), "%T: -", + "Rank Info Menu - Next Rank", client); + menu.AddItem("", display); + + FormatEx(display, sizeof(display), "%T: 0", + "Rank Info Menu - Points needed", client); + menu.AddItem("", display); + } + else + { + FormatEx(display, sizeof(display), "%T: %s", + "Rank Info Menu - Next Rank", client, gC_rankName[next_rank]); + menu.AddItem("", display); + + FormatEx(display, sizeof(display), "%T: %d", + "Rank Info Menu - Points needed", client, gI_rankThreshold[mode][next_rank] - GOKZ_GL_GetRankPoints(player, mode)); + menu.AddItem("", display); + } +} + +static int MenuHandler_RankInfo(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Cancel) + { + ShowProfile(param1); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + +static void ShowPointsInfo(int client) +{ + Menu menu = new Menu(MenuHandler_PointsInfo); + menu.SetTitle("%T - %N", "Points Info Menu - Title", client, profileTargetPlayer[client]); + PointsInfoMenuAddItems(client, menu); + menu.Display(client, MENU_TIME_FOREVER); +} + +static void PointsInfoMenuAddItems(int client, Menu menu) +{ + char display[32]; + int player = profileTargetPlayer[client]; + int mode = profileMode[client]; + + FormatEx(display, sizeof(display), "%T: %d", + "Points Info Menu - Overall Points", client, GOKZ_GL_GetPoints(player, mode, TimeType_Nub)); + menu.AddItem("", display); + + FormatEx(display, sizeof(display), "%T: %d", + "Points Info Menu - Pro Points", client, GOKZ_GL_GetPoints(player, mode, TimeType_Pro)); + menu.AddItem("", display); + + FormatEx(display, sizeof(display), "%T: %d", + "Points Info Menu - Overall Completion", client, GOKZ_GL_GetFinishes(player, mode, TimeType_Nub)); + menu.AddItem("", display); + + FormatEx(display, sizeof(display), "%T: %d", + "Points Info Menu - Pro Completion", client, GOKZ_GL_GetFinishes(player, mode, TimeType_Pro)); + menu.AddItem("", display); +} + +static int MenuHandler_PointsInfo(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Cancel) + { + ShowProfile(param1); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} diff --git a/sourcemod/scripting/gokz-quiet.sp b/sourcemod/scripting/gokz-quiet.sp new file mode 100644 index 0000000..06cc246 --- /dev/null +++ b/sourcemod/scripting/gokz-quiet.sp @@ -0,0 +1,151 @@ +#include <sourcemod> + +#include <cstrike> +#include <sdkhooks> +#include <dhooks> + +#include <gokz/core> +#include <gokz/quiet> + +#undef REQUIRE_EXTENSIONS +#undef REQUIRE_PLUGIN +#include <updater> + +#pragma newdecls required +#pragma semicolon 1 + + + +public Plugin myinfo = +{ + name = "GOKZ Quiet", + author = "DanZay", + description = "Provides options for a quieter KZ experience", + version = GOKZ_VERSION, + url = GOKZ_SOURCE_URL +}; + +#define UPDATER_URL GOKZ_UPDATER_BASE_URL..."gokz-quiet.txt" + + +#include "gokz-quiet/ambient.sp" +#include "gokz-quiet/soundscape.sp" +#include "gokz-quiet/hideplayers.sp" +#include "gokz-quiet/falldamage.sp" +#include "gokz-quiet/gokz-sounds.sp" +#include "gokz-quiet/options.sp" + +// =====[ PLUGIN EVENTS ]===== + +public APLRes AskPluginLoad2(Handle myself, bool late, char[] error, int err_max) +{ + RegPluginLibrary("gokz-quiet"); + return APLRes_Success; +} + +public void OnPluginStart() +{ + OnPluginStart_HidePlayers(); + OnPluginStart_FallDamage(); + OnPluginStart_Ambient(); + + LoadTranslations("gokz-common.phrases"); + LoadTranslations("gokz-quiet.phrases"); + + RegisterCommands(); +} + +public void OnAllPluginsLoaded() +{ + if (LibraryExists("updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + + TopMenu topMenu; + if (LibraryExists("gokz-core") && ((topMenu = GOKZ_GetOptionsTopMenu()) != null)) + { + GOKZ_OnOptionsMenuReady(topMenu); + } + + for (int client = 1; client <= MaxClients; client++) + { + if (IsClientInGame(client)) + { + GOKZ_OnJoinTeam(client, GetClientTeam(client)); + } + } +} + +public void OnLibraryAdded(const char[] name) +{ + if (StrEqual(name, "updater")) + { + Updater_AddPlugin(UPDATER_URL); + } +} + + + +// =====[ CLIENT EVENTS ]===== + +public void GOKZ_OnJoinTeam(int client, int team) +{ + OnJoinTeam_HidePlayers(client, team); +} + +public void OnPlayerRunCmdPost(int client, int buttons, int impulse, const float vel[3], const float angles[3], int weapon, int subtype, int cmdnum, int tickcount, int seed, const int mouse[2]) +{ + if (!IsValidClient(client)) + { + return; + } + + OnPlayerRunCmdPost_Soundscape(client); +} + + +// =====[ OTHER EVENTS ]===== + +public void GOKZ_OnOptionsMenuReady(TopMenu topMenu) +{ + OnOptionsMenuReady_Options(); + OnOptionsMenuReady_OptionsMenu(topMenu); +} + +public void GOKZ_OnOptionChanged(int client, const char[] option, any newValue) +{ + any qtOption; + if (GOKZ_QT_IsQTOption(option, qtOption)) + { + OnOptionChanged_Options(client, qtOption, newValue); + } +} + +public void GOKZ_OnOptionsMenuCreated(TopMenu topMenu) +{ + OnOptionsMenuCreated_OptionsMenu(topMenu); +} + +// =====[ STOP SOUNDS ]===== + +void StopSounds(int client) +{ + ClientCommand(client, "snd_playsounds Music.StopAllExceptMusic"); + GOKZ_PrintToChat(client, true, "%t", "Stopped Sounds"); +} + + +// =====[ COMMANDS ]===== + +void RegisterCommands() +{ + RegConsoleCmd("sm_hide", CommandToggleShowPlayers, "[KZ] Toggle the visibility of other players."); + RegConsoleCmd("sm_stopsound", CommandStopSound, "[KZ] Stop all sounds e.g. map soundscapes (music)."); +} + +public Action CommandStopSound(int client, int args) +{ + StopSounds(client); + return Plugin_Handled; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-quiet/ambient.sp b/sourcemod/scripting/gokz-quiet/ambient.sp new file mode 100644 index 0000000..a67e20e --- /dev/null +++ b/sourcemod/scripting/gokz-quiet/ambient.sp @@ -0,0 +1,100 @@ +/* + Hide sound effect from ambient_generics. + Credit to Haze - https://github.com/Haze1337/Sound-Manager +*/ + +Handle getPlayerSlot; + +void OnPluginStart_Ambient() +{ + HookSendSound(); +} +static void HookSendSound() +{ + GameData gd = LoadGameConfigFile("gokz-quiet.games"); + + DynamicDetour sendSoundDetour = DHookCreateDetour(Address_Null, CallConv_THISCALL, ReturnType_Void, ThisPointer_Address); + DHookSetFromConf(sendSoundDetour, gd, SDKConf_Signature, "CGameClient::SendSound"); + DHookAddParam(sendSoundDetour, HookParamType_ObjectPtr); + DHookAddParam(sendSoundDetour, HookParamType_Bool); + if (!DHookEnableDetour(sendSoundDetour, false, DHooks_OnSendSound)) + { + SetFailState("Couldn't enable CGameClient::SendSound detour."); + } + + StartPrepSDKCall(SDKCall_Raw); + PrepSDKCall_SetFromConf(gd, SDKConf_Virtual, "CBaseClient::GetPlayerSlot"); + PrepSDKCall_SetReturnInfo(SDKType_PlainOldData, SDKPass_Plain); + getPlayerSlot = EndPrepSDKCall(); + if (getPlayerSlot == null) + { + SetFailState("Could not initialize call to CBaseClient::GetPlayerSlot."); + } +} + + +/*struct SoundInfo_t +{ + Vector vOrigin; Offset: 0 | Size: 12 + Vector vDirection Offset: 12 | Size: 12 + Vector vListenerOrigin; Offset: 24 | Size: 12 + const char *pszName; Offset: 36 | Size: 4 + float fVolume; Offset: 40 | Size: 4 + float fDelay; Offset: 44 | Size: 4 + float fTickTime; Offset: 48 | Size: 4 + int nSequenceNumber; Offset: 52 | Size: 4 + int nEntityIndex; Offset: 56 | Size: 4 + int nChannel; Offset: 60 | Size: 4 + int nPitch; Offset: 64 | Size: 4 + int nFlags; Offset: 68 | Size: 4 + unsigned int nSoundNum; Offset: 72 | Size: 4 + int nSpeakerEntity; Offset: 76 | Size: 4 + int nRandomSeed; Offset: 80 | Size: 4 + soundlevel_t Soundlevel; Offset: 84 | Size: 4 + bool bIsSentence; Offset: 88 | Size: 1 + bool bIsAmbient; Offset: 89 | Size: 1 + bool bLooping; Offset: 90 | Size: 1 +};*/ + +//void CGameClient::SendSound( SoundInfo_t &sound, bool isReliable ) +public MRESReturn DHooks_OnSendSound(Address pThis, Handle hParams) +{ + // Check volume + float volume = DHookGetParamObjectPtrVar(hParams, 1, 40, ObjectValueType_Float); + if(volume == 0.0) + { + return MRES_Ignored; + } + + Address pIClient = pThis + view_as<Address>(0x4); + int client = view_as<int>(SDKCall(getPlayerSlot, pIClient)) + 1; + + if(!IsValidClient(client)) + { + return MRES_Ignored; + } + + bool isAmbient = DHookGetParamObjectPtrVar(hParams, 1, 89, ObjectValueType_Bool); + if (!isAmbient) + { + return MRES_Ignored; + } + + float newVolume; + if (GOKZ_QT_GetOption(client, QTOption_AmbientSounds) == -1 || GOKZ_QT_GetOption(client, QTOption_AmbientSounds) == 10) + { + newVolume = volume; + } + else + { + float volumeFactor = float(GOKZ_QT_GetOption(client, QTOption_AmbientSounds)) * 0.1; + newVolume = volume * volumeFactor; + } + + if (newVolume <= 0.0) + { + return MRES_Supercede; + } + DHookSetParamObjectPtrVar(hParams, 1, 40, ObjectValueType_Float, newVolume); + return MRES_ChangedHandled; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-quiet/falldamage.sp b/sourcemod/scripting/gokz-quiet/falldamage.sp new file mode 100644 index 0000000..6bd0533 --- /dev/null +++ b/sourcemod/scripting/gokz-quiet/falldamage.sp @@ -0,0 +1,40 @@ +/* + Toggle player's fall damage sounds. +*/ + +void OnPluginStart_FallDamage() +{ + AddNormalSoundHook(Hook_NormalSound); +} + +static Action Hook_NormalSound(int clients[MAXPLAYERS], int& numClients, char sample[PLATFORM_MAX_PATH], int& entity, int& channel, float& volume, int& level, int& pitch, int& flags, char soundEntry[PLATFORM_MAX_PATH], int& seed) +{ + if (!StrEqual(soundEntry, "Player.FallDamage")) + { + return Plugin_Continue; + } + + for (int i = 0; i < numClients; i++) + { + int client = clients[i]; + if (!IsValidClient(client)) + { + continue; + } + int clientArray[1]; + clientArray[0] = client; + float newVolume; + if (GOKZ_QT_GetOption(client, QTOption_FallDamageSound) == -1 || GOKZ_QT_GetOption(client, QTOption_FallDamageSound) == 10) + { + newVolume = volume; + } + else + { + float volumeFactor = float(GOKZ_QT_GetOption(client, QTOption_FallDamageSound)) * 0.1; + newVolume = volume * volumeFactor; + } + + EmitSoundEntry(clientArray, 1, soundEntry, sample, entity, channel, level, seed, flags, newVolume, pitch); + } + return Plugin_Handled; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-quiet/gokz-sounds.sp b/sourcemod/scripting/gokz-quiet/gokz-sounds.sp new file mode 100644 index 0000000..02cf681 --- /dev/null +++ b/sourcemod/scripting/gokz-quiet/gokz-sounds.sp @@ -0,0 +1,71 @@ +/* + Volume options for various GOKZ sounds. +*/ + +public Action GOKZ_OnEmitSoundToClient(int client, const char[] sample, float &volume, const char[] description) +{ + int volumeFactor = 10; + if (StrEqual(description, "Checkpoint") || StrEqual(description, "Set Start Position")) + { + volumeFactor = GOKZ_QT_GetOption(client, QTOption_CheckpointVolume); + if (volumeFactor == -1) + { + return Plugin_Continue; + } + } + else if (StrEqual(description, "Checkpoint")) + { + volumeFactor = GOKZ_QT_GetOption(client, QTOption_TeleportVolume); + if (volumeFactor == -1) + { + return Plugin_Continue; + } + } + else if (StrEqual(description, "Timer Start") || StrEqual(description, "Timer End") || StrEqual(description, "Timer False End") || StrEqual(description, "Missed PB")) + { + volumeFactor = GOKZ_QT_GetOption(client, QTOption_TimerVolume); + if (volumeFactor == -1) + { + return Plugin_Continue; + } + } + else if (StrEqual(description, "Error")) + { + volumeFactor = GOKZ_QT_GetOption(client, QTOption_ErrorVolume); + if (volumeFactor == -1) + { + return Plugin_Continue; + } + } + else if (StrEqual(description, "Server Record")) + { + volumeFactor = GOKZ_QT_GetOption(client, QTOption_ServerRecordVolume); + if (volumeFactor == -1) + { + return Plugin_Continue; + } + } + else if (StrEqual(description, "World Record")) + { + volumeFactor = GOKZ_QT_GetOption(client, QTOption_WorldRecordVolume); + if (volumeFactor == -1) + { + return Plugin_Continue; + } + } + else if (StrEqual(description, "Jumpstats")) + { + volumeFactor = GOKZ_QT_GetOption(client, QTOption_JumpstatsVolume); + if (volumeFactor == -1) + { + return Plugin_Continue; + } + } + + if (volumeFactor == 10) + { + return Plugin_Continue; + } + volume *= float(volumeFactor) * 0.1; + return Plugin_Changed; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-quiet/hideplayers.sp b/sourcemod/scripting/gokz-quiet/hideplayers.sp new file mode 100644 index 0000000..65736f0 --- /dev/null +++ b/sourcemod/scripting/gokz-quiet/hideplayers.sp @@ -0,0 +1,309 @@ +/* + Hide sounds and effects from other players. +*/ + +void OnPluginStart_HidePlayers() +{ + AddNormalSoundHook(Hook_NormalSound); + AddTempEntHook("Shotgun Shot", Hook_ShotgunShot); + AddTempEntHook("EffectDispatch", Hook_EffectDispatch); + HookUserMessage(GetUserMessageId("WeaponSound"), Hook_WeaponSound, true); + + // Lateload support + for (int client = 1; client <= MaxClients; client++) + { + if (IsValidClient(client)) + { + OnJoinTeam_HidePlayers(client, GetClientTeam(client)); + } + } +} + +void OnJoinTeam_HidePlayers(int client, int team) +{ + // Make sure client is only ever hooked once + SDKUnhook(client, SDKHook_SetTransmit, OnSetTransmitClient); + + if (team == CS_TEAM_T || team == CS_TEAM_CT) + { + SDKHook(client, SDKHook_SetTransmit, OnSetTransmitClient); + } +} + +Action CommandToggleShowPlayers(int client, int args) +{ + if (GOKZ_GetOption(client, gC_QTOptionNames[QTOption_ShowPlayers]) == ShowPlayers_Disabled) + { + GOKZ_SetOption(client, gC_QTOptionNames[QTOption_ShowPlayers], ShowPlayers_Enabled); + } + else + { + GOKZ_SetOption(client, gC_QTOptionNames[QTOption_ShowPlayers], ShowPlayers_Disabled); + } + return Plugin_Handled; +} + +// =====[ PRIVATE ]===== + +// Hide most of the other players' actions. This function is expensive. +static Action OnSetTransmitClient(int entity, int client) +{ + if (GOKZ_GetOption(client, gC_QTOptionNames[QTOption_ShowPlayers]) == ShowPlayers_Disabled + && entity != client + && entity != GetObserverTarget(client)) + { + return Plugin_Handled; + } + return Plugin_Continue; +} + +// Hide reload sounds. Required if other players were visible at one point during the gameplay. +static Action Hook_WeaponSound(UserMsg msg_id, Protobuf msg, const int[] players, int playersNum, bool reliable, bool init) +{ + int newClients[MAXPLAYERS], newTotal = 0; + int entidx = msg.ReadInt("entidx"); + for (int i = 0; i < playersNum; i++) + { + int client = players[i]; + if (GOKZ_GetOption(client, gC_QTOptionNames[QTOption_ShowPlayers]) == ShowPlayers_Enabled + || entidx == client + || entidx == GetObserverTarget(client)) + { + newClients[newTotal] = client; + newTotal++; + } + } + + // Nothing's changed, let the engine handle it. + if (newTotal == playersNum) + { + return Plugin_Continue; + } + // No one to send to so it doesn't matter if we block or not. We block just to end the function early. + if (newTotal == 0) + { + return Plugin_Handled; + } + // Only way to modify the recipient list is to RequestFrame and create our own user message. + char path[PLATFORM_MAX_PATH]; + msg.ReadString("sound", path, sizeof(path)); + int flags = USERMSG_BLOCKHOOKS; + if (reliable) + { + flags |= USERMSG_RELIABLE; + } + if (init) + { + flags |= USERMSG_INITMSG; + } + + DataPack dp = new DataPack(); + dp.WriteCell(msg_id); + dp.WriteCell(newTotal); + dp.WriteCellArray(newClients, newTotal); + dp.WriteCell(flags); + dp.WriteCell(entidx); + dp.WriteFloat(msg.ReadFloat("origin_x")); + dp.WriteFloat(msg.ReadFloat("origin_y")); + dp.WriteFloat(msg.ReadFloat("origin_z")); + dp.WriteString(path); + dp.WriteFloat(msg.ReadFloat("timestamp")); + + RequestFrame(RequestFrame_WeaponSound, dp); + return Plugin_Handled; +} + +static void RequestFrame_WeaponSound(DataPack dp) +{ + dp.Reset(); + + UserMsg msg_id = dp.ReadCell(); + int newTotal = dp.ReadCell(); + int newClients[MAXPLAYERS]; + dp.ReadCellArray(newClients, newTotal); + int flags = dp.ReadCell(); + + Protobuf newMsg = view_as<Protobuf>(StartMessageEx(msg_id, newClients, newTotal, flags)); + + newMsg.SetInt("entidx", dp.ReadCell()); + newMsg.SetFloat("origin_x", dp.ReadFloat()); + newMsg.SetFloat("origin_y", dp.ReadFloat()); + newMsg.SetFloat("origin_z", dp.ReadFloat()); + char path[PLATFORM_MAX_PATH]; + dp.ReadString(path, sizeof(path)); + newMsg.SetString("sound", path); + newMsg.SetFloat("timestamp", dp.ReadFloat()); + + EndMessage(); + + delete dp; +} + +// Hide various sounds that don't get blocked by SetTransmit hook. +static Action Hook_NormalSound(int clients[MAXPLAYERS], int& numClients, char sample[PLATFORM_MAX_PATH], int& entity, int& channel, float& volume, int& level, int& pitch, int& flags, char soundEntry[PLATFORM_MAX_PATH], int& seed) +{ + if (StrContains(sample, "Player.EquipArmor") != -1 || StrContains(sample, "BaseCombatCharacter.AmmoPickup") != -1) + { + // When the sound is emitted, the owner of these entities are not set yet. + // Hence we cannot do the entity parent stuff below. + // In that case, we just straight up block armor and ammo pickup sounds. + return Plugin_Stop; + } + int ent = entity; + while (ent > MAXPLAYERS) + { + // Block some gun and knife sounds by trying to find its parent entity. + ent = GetEntPropEnt(ent, Prop_Send, "moveparent"); + if (ent < MAXPLAYERS) + { + break; + } + else if (ent == -1) + { + return Plugin_Continue; + } + } + int numNewClients = 0; + for (int i = 0; i < numClients; i++) + { + int client = clients[i]; + if (GOKZ_GetOption(client, gC_QTOptionNames[QTOption_ShowPlayers]) == ShowPlayers_Enabled + || ent == client + || ent == GetObserverTarget(client)) + { + clients[numNewClients] = client; + numNewClients++; + } + } + + if (numNewClients != numClients) + { + numClients = numNewClients; + return Plugin_Changed; + } + + return Plugin_Continue; +} + +// Hide firing sounds. +static Action Hook_ShotgunShot(const char[] te_name, const int[] players, int numClients, float delay) +{ + int newClients[MAXPLAYERS], newTotal = 0; + for (int i = 0; i < numClients; i++) + { + int client = players[i]; + if (GOKZ_GetOption(client, gC_QTOptionNames[QTOption_ShowPlayers]) == ShowPlayers_Enabled + || TE_ReadNum("m_iPlayer") + 1 == GetObserverTarget(client)) + { + newClients[newTotal] = client; + newTotal++; + } + } + + // Noone wants the sound + if (newTotal == 0) + { + return Plugin_Stop; + } + + // Nothing's changed, let the engine handle it. + if (newTotal == numClients) + { + return Plugin_Continue; + } + + float origin[3]; + TE_ReadVector("m_vecOrigin", origin); + + float angles[2]; + angles[0] = TE_ReadFloat("m_vecAngles[0]"); + angles[1] = TE_ReadFloat("m_vecAngles[1]"); + + int weapon = TE_ReadNum("m_weapon"); + int mode = TE_ReadNum("m_iMode"); + int seed = TE_ReadNum("m_iSeed"); + int player = TE_ReadNum("m_iPlayer"); + float inaccuracy = TE_ReadFloat("m_fInaccuracy"); + float recoilIndex = TE_ReadFloat("m_flRecoilIndex"); + float spread = TE_ReadFloat("m_fSpread"); + int itemIdx = TE_ReadNum("m_nItemDefIndex"); + int soundType = TE_ReadNum("m_iSoundType"); + + TE_Start("Shotgun Shot"); + TE_WriteVector("m_vecOrigin", origin); + TE_WriteFloat("m_vecAngles[0]", angles[0]); + TE_WriteFloat("m_vecAngles[1]", angles[1]); + TE_WriteNum("m_weapon", weapon); + TE_WriteNum("m_iMode", mode); + TE_WriteNum("m_iSeed", seed); + TE_WriteNum("m_iPlayer", player); + TE_WriteFloat("m_fInaccuracy", inaccuracy); + TE_WriteFloat("m_flRecoilIndex", recoilIndex); + TE_WriteFloat("m_fSpread", spread); + TE_WriteNum("m_nItemDefIndex", itemIdx); + TE_WriteNum("m_iSoundType", soundType); + + // Send the TE and stop the engine from processing its own. + TE_Send(newClients, newTotal, delay); + return Plugin_Stop; +} + +// Hide knife and blood effect caused by other players. +static Action Hook_EffectDispatch(const char[] te_name, const int[] players, int numClients, float delay) +{ + // Block bullet impact effects. + int effIndex = TE_ReadNum("m_iEffectName"); + if (effIndex != EFFECT_IMPACT && effIndex != EFFECT_KNIFESLASH) + { + return Plugin_Continue; + } + int newClients[MAXPLAYERS], newTotal = 0; + for (int i = 0; i < numClients; i++) + { + int client = players[i]; + if (GOKZ_GetOption(client, gC_QTOptionNames[QTOption_ShowPlayers]) == ShowPlayers_Enabled) + { + newClients[newTotal] = client; + newTotal++; + } + } + // Noone wants the sound + if (newTotal == 0) + { + return Plugin_Stop; + } + + // Nothing's changed, let the engine handle it. + if (newTotal == numClients) + { + return Plugin_Continue; + } + float origin[3], start[3]; + origin[0] = TE_ReadFloat("m_vOrigin.x"); + origin[1] = TE_ReadFloat("m_vOrigin.y"); + origin[2] = TE_ReadFloat("m_vOrigin.z"); + start[0] = TE_ReadFloat("m_vStart.x"); + start[1] = TE_ReadFloat("m_vStart.y"); + start[2] = TE_ReadFloat("m_vStart.z"); + int flags = TE_ReadNum("m_fFlags"); + float scale = TE_ReadFloat("m_flScale"); + int surfaceProp = TE_ReadNum("m_nSurfaceProp"); + int damageType = TE_ReadNum("m_nDamageType"); + int entindex = TE_ReadNum("entindex"); + int positionsAreRelativeToEntity = TE_ReadNum("m_bPositionsAreRelativeToEntity"); + + TE_Start("EffectDispatch"); + TE_WriteNum("m_iEffectName", effIndex); + TE_WriteFloatArray("m_vOrigin.x", origin, 3); + TE_WriteFloatArray("m_vStart.x", start, 3); + TE_WriteFloat("m_flScale", scale); + TE_WriteNum("m_nSurfaceProp", surfaceProp); + TE_WriteNum("m_nDamageType", damageType); + TE_WriteNum("entindex", entindex); + TE_WriteNum("m_bPositionsAreRelativeToEntity", positionsAreRelativeToEntity); + TE_WriteNum("m_fFlags", flags); + + // Send the TE and stop the engine from processing its own. + TE_Send(newClients, newTotal, delay); + return Plugin_Stop; +} diff --git a/sourcemod/scripting/gokz-quiet/options.sp b/sourcemod/scripting/gokz-quiet/options.sp new file mode 100644 index 0000000..a9da3d7 --- /dev/null +++ b/sourcemod/scripting/gokz-quiet/options.sp @@ -0,0 +1,206 @@ +// =====[ OPTIONS ]===== + +void OnOptionsMenuReady_Options() +{ + RegisterOptions(); +} + +void RegisterOptions() +{ + for (QTOption option; option < QTOPTION_COUNT; option++) + { + GOKZ_RegisterOption(gC_QTOptionNames[option], gC_QTOptionDescriptions[option], + OptionType_Int, gI_QTOptionDefaultValues[option], 0, gI_QTOptionCounts[option] - 1); + } +} + +void OnOptionChanged_Options(int client, QTOption option, any newValue) +{ + if (option == QTOption_Soundscapes && newValue == Soundscapes_Enabled) + { + EnableSoundscape(client); + } + PrintOptionChangeMessage(client, option, newValue); +} + +void PrintOptionChangeMessage(int client, QTOption option, any newValue) +{ + switch (option) + { + case QTOption_ShowPlayers: + { + switch (newValue) + { + case ShowPlayers_Disabled: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Show Players - Disable"); + } + case ShowPlayers_Enabled: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Show Players - Enable"); + } + } + } + case QTOption_Soundscapes: + { + switch (newValue) + { + case Soundscapes_Disabled: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Soundscapes - Disable"); + } + case Soundscapes_Enabled: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Soundscapes - Enable"); + } + } + } + } +} + +// =====[ OPTIONS MENU ]===== + +TopMenu gTM_Options; +TopMenuObject gTMO_CatQuiet; +TopMenuObject gTMO_ItemsQuiet[QTOPTION_COUNT]; + +void OnOptionsMenuCreated_OptionsMenu(TopMenu topMenu) +{ + if (gTM_Options == topMenu && gTMO_CatQuiet != INVALID_TOPMENUOBJECT) + { + return; + } + + gTMO_CatQuiet = topMenu.AddCategory(QUIET_OPTION_CATEGORY, TopMenuHandler_Categories); +} + +void OnOptionsMenuReady_OptionsMenu(TopMenu topMenu) +{ + // Make sure category exists + if (gTMO_CatQuiet == INVALID_TOPMENUOBJECT) + { + GOKZ_OnOptionsMenuCreated(topMenu); + } + + if (gTM_Options == topMenu) + { + return; + } + + gTM_Options = topMenu; + + // Add gokz-profile option items + for (int option = 0; option < view_as<int>(QTOPTION_COUNT); option++) + { + gTMO_ItemsQuiet[option] = gTM_Options.AddItem(gC_QTOptionNames[option], TopMenuHandler_QT, gTMO_CatQuiet); + } +} + +public void TopMenuHandler_Categories(TopMenu topmenu, TopMenuAction action, TopMenuObject topobj_id, int param, char[] buffer, int maxlength) +{ + if (action == TopMenuAction_DisplayOption || action == TopMenuAction_DisplayTitle) + { + if (topobj_id == gTMO_CatQuiet) + { + Format(buffer, maxlength, "%T", "Options Menu - Quiet", param); + } + } +} + +public void TopMenuHandler_QT(TopMenu topmenu, TopMenuAction action, TopMenuObject topobj_id, int param, char[] buffer, int maxlength) +{ + QTOption option = QTOPTION_INVALID; + for (int i = 0; i < view_as<int>(QTOPTION_COUNT); i++) + { + if (topobj_id == gTMO_ItemsQuiet[i]) + { + option = view_as<QTOption>(i); + break; + } + } + + if (option == QTOPTION_INVALID) + { + return; + } + + if (action == TopMenuAction_DisplayOption) + { + switch (option) + { + case QTOption_ShowPlayers: + { + FormatToggleableOptionDisplay(param, option, buffer, maxlength); + } + case QTOption_Soundscapes: + { + FormatToggleableOptionDisplay(param, option, buffer, maxlength); + } + case QTOption_FallDamageSound: + { + FormatVolumeOptionDisplay(param, option, buffer, maxlength); + } + case QTOption_AmbientSounds: + { + FormatVolumeOptionDisplay(param, option, buffer, maxlength); + } + case QTOption_CheckpointVolume: + { + FormatVolumeOptionDisplay(param, option, buffer, maxlength); + } + case QTOption_TeleportVolume: + { + FormatVolumeOptionDisplay(param, option, buffer, maxlength); + } + case QTOption_TimerVolume: + { + FormatVolumeOptionDisplay(param, option, buffer, maxlength); + } + case QTOption_ErrorVolume: + { + FormatVolumeOptionDisplay(param, option, buffer, maxlength); + } + case QTOption_ServerRecordVolume: + { + FormatVolumeOptionDisplay(param, option, buffer, maxlength); + } + case QTOption_WorldRecordVolume: + { + FormatVolumeOptionDisplay(param, option, buffer, maxlength); + } + case QTOption_JumpstatsVolume: + { + FormatVolumeOptionDisplay(param, option, buffer, maxlength); + } + } + } + else if (action == TopMenuAction_SelectOption) + { + GOKZ_CycleOption(param, gC_QTOptionNames[option]); + gTM_Options.Display(param, TopMenuPosition_LastCategory); + } +} + +void FormatToggleableOptionDisplay(int client, QTOption option, char[] buffer, int maxlength) +{ + if (GOKZ_GetOption(client, gC_QTOptionNames[option]) == 0) + { + FormatEx(buffer, maxlength, "%T - %T", + gC_QTOptionPhrases[option], client, + "Options Menu - Disabled", client); + } + else + { + FormatEx(buffer, maxlength, "%T - %T", + gC_QTOptionPhrases[option], client, + "Options Menu - Enabled", client); + } +} + +void FormatVolumeOptionDisplay(int client, QTOption option, char[] buffer, int maxlength) +{ + // Assume 10% volume steps. + FormatEx(buffer, maxlength, "%T - %i%", + gC_QTOptionPhrases[option], client, + GOKZ_QT_GetOption(client, option) * 10); +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-quiet/soundscape.sp b/sourcemod/scripting/gokz-quiet/soundscape.sp new file mode 100644 index 0000000..f320ad3 --- /dev/null +++ b/sourcemod/scripting/gokz-quiet/soundscape.sp @@ -0,0 +1,30 @@ +/* + Toggle soundscapes. +*/ + +static int currentSoundscapeIndex[MAXPLAYERS + 1] = {BLANK_SOUNDSCAPEINDEX, ...}; + +void EnableSoundscape(int client) +{ + if (currentSoundscapeIndex[client] != BLANK_SOUNDSCAPEINDEX) + { + SetEntProp(client, Prop_Data, "soundscapeIndex", currentSoundscapeIndex[client]); + } +} + +void OnPlayerRunCmdPost_Soundscape(int client) +{ + int soundscapeIndex = GetEntProp(client, Prop_Data, "soundscapeIndex"); + if (GOKZ_GetOption(client, gC_QTOptionNames[QTOption_Soundscapes]) == Soundscapes_Disabled) + { + if (soundscapeIndex != BLANK_SOUNDSCAPEINDEX) + { + currentSoundscapeIndex[client] = soundscapeIndex; + } + SetEntProp(client, Prop_Data, "soundscapeIndex", BLANK_SOUNDSCAPEINDEX); + } + else + { + currentSoundscapeIndex[client] = soundscapeIndex; + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-racing.sp b/sourcemod/scripting/gokz-racing.sp new file mode 100644 index 0000000..416d28a --- /dev/null +++ b/sourcemod/scripting/gokz-racing.sp @@ -0,0 +1,174 @@ +#include <sourcemod> + +#include <gokz/core> +#include <gokz/racing> + +#undef REQUIRE_EXTENSIONS +#undef REQUIRE_PLUGIN +#include <updater> + +#pragma newdecls required +#pragma semicolon 1 + + + +public Plugin myinfo = +{ + name = "GOKZ Racing", + author = "DanZay", + description = "Lets players race against each other", + version = GOKZ_VERSION, + url = GOKZ_SOURCE_URL +}; + +#define UPDATER_URL GOKZ_UPDATER_BASE_URL..."gokz-racing.txt" + +#include "gokz-racing/announce.sp" +#include "gokz-racing/api.sp" +#include "gokz-racing/commands.sp" +#include "gokz-racing/duel_menu.sp" +#include "gokz-racing/race.sp" +#include "gokz-racing/race_menu.sp" +#include "gokz-racing/racer.sp" + + + +// =====[ PLUGIN EVENTS ]===== + +public APLRes AskPluginLoad2(Handle myself, bool late, char[] error, int err_max) +{ + CreateNatives(); + RegPluginLibrary("gokz-racing"); + return APLRes_Success; +} + +public void OnPluginStart() +{ + LoadTranslations("gokz-common.phrases"); + LoadTranslations("gokz-racing.phrases"); + + CreateGlobalForwards(); + RegisterCommands(); + + OnPluginStart_Race(); +} + +public void OnAllPluginsLoaded() +{ + if (LibraryExists("updater")) + { + Updater_AddPlugin(UPDATER_URL); + } +} + +public void OnLibraryAdded(const char[] name) +{ + if (StrEqual(name, "updater")) + { + Updater_AddPlugin(UPDATER_URL); + } +} + + + +// =====[ CLIENT EVENTS ]===== + +public void OnClientPutInServer(int client) +{ + OnClientPutInServer_Racer(client); +} + +public void OnClientDisconnect(int client) +{ + OnClientDisconnect_Racer(client); +} + +public Action GOKZ_OnTimerStart(int client, int course) +{ + Action action = OnTimerStart_Racer(client, course); + if (action != Plugin_Continue) + { + return action; + } + + return Plugin_Continue; +} + +public void GOKZ_OnTimerStart_Post(int client, int course) +{ + OnTimerStart_Post_Racer(client); +} + +public void GOKZ_OnTimerEnd_Post(int client, int course, float time, int teleportsUsed) +{ + FinishRacer(client, course); +} + +public Action GOKZ_OnMakeCheckpoint(int client) +{ + Action action = OnMakeCheckpoint_Racer(client); + if (action != Plugin_Continue) + { + return action; + } + + return Plugin_Continue; +} + +public void GOKZ_OnMakeCheckpoint_Post(int client) +{ + OnMakeCheckpoint_Post_Racer(client); +} + +public Action GOKZ_OnUndoTeleport(int client) +{ + Action action = OnUndoTeleport_Racer(client); + if (action != Plugin_Continue) + { + return action; + } + + return Plugin_Continue; +} + +public void GOKZ_RC_OnFinish(int client, int raceID, int place) +{ + OnFinish_Announce(client, raceID, place); + OnFinish_Race(raceID); +} + +public void GOKZ_RC_OnSurrender(int client, int raceID) +{ + OnSurrender_Announce(client, raceID); +} + +public void GOKZ_RC_OnRequestReceived(int client, int raceID) +{ + OnRequestReceived_Announce(client, raceID); +} + +public void GOKZ_RC_OnRequestAccepted(int client, int raceID) +{ + OnRequestAccepted_Announce(client, raceID); + OnRequestAccepted_Race(raceID); +} + +public void GOKZ_RC_OnRequestDeclined(int client, int raceID, bool timeout) +{ + OnRequestDeclined_Announce(client, raceID, timeout); + OnRequestDeclined_Race(raceID); +} + + + +// =====[ OTHER EVENTS ]===== + +public void GOKZ_RC_OnRaceStarted(int raceID) +{ + OnRaceStarted_Announce(raceID); +} + +public void GOKZ_RC_OnRaceAborted(int raceID) +{ + OnRaceAborted_Announce(raceID); +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-racing/announce.sp b/sourcemod/scripting/gokz-racing/announce.sp new file mode 100644 index 0000000..7b6a920 --- /dev/null +++ b/sourcemod/scripting/gokz-racing/announce.sp @@ -0,0 +1,229 @@ +/* + Chat messages of race and racer events. +*/ + + + +// =====[ PUBLIC ]===== + +/** + * Prints a message to chat for all clients in a race, formatting colours + * and optionally adding the chat prefix. If using the chat prefix, specify + * a colour at the beginning of the message e.g. "{default}Hello!". + * + * @param raceID ID of the race. + * @param specs Whether to also include racer spectators. + * @param addPrefix Whether to add the chat prefix. + * @param format Formatting rules. + * @param any Variable number of format parameters. + */ +void PrintToChatAllInRace(int raceID, bool specs, bool addPrefix, const char[] format, any...) +{ + char buffer[1024]; + for (int client = 1; client <= MaxClients; client++) + { + if (IsClientInGame(client) && GetRaceID(client) == raceID) + { + SetGlobalTransTarget(client); + VFormat(buffer, sizeof(buffer), format, 5); + GOKZ_PrintToChat(client, addPrefix, buffer); + + if (specs) + { + for (int target = 1; target <= MaxClients; target++) + { + if (IsClientInGame(target) && GetObserverTarget(target) == client && GetRaceID(target) != raceID) + { + SetGlobalTransTarget(target); + VFormat(buffer, sizeof(buffer), format, 5); + GOKZ_PrintToChat(target, addPrefix, buffer); + } + } + } + } + } +} + + + +// =====[ EVENTS ]===== + +void OnFinish_Announce(int client, int raceID, int place) +{ + switch (GetRaceInfo(raceID, RaceInfo_Type)) + { + case RaceType_Normal: + { + if (place == 1) + { + PrintToChatAllInRace(raceID, true, true, "%t", "Race Won", client); + } + else + { + ArrayList unfinishedRacers = GetUnfinishedRacers(raceID); + if (unfinishedRacers.Length >= 1) + { + PrintToChatAllInRace(raceID, true, true, "%t", "Race Placed", client, place); + } + else + { + PrintToChatAllInRace(raceID, true, true, "%t", "Race Lost", client, place); + } + delete unfinishedRacers; + } + } + case RaceType_Duel: + { + ArrayList unfinishedRacers = GetUnfinishedRacers(raceID); + if (unfinishedRacers.Length == 1) + { + int opponent = unfinishedRacers.Get(0); + GOKZ_PrintToChatAll(true, "%t", "Duel Won", client, opponent); + } + delete unfinishedRacers; + } + } +} + +void OnSurrender_Announce(int client, int raceID) +{ + switch (GetRaceInfo(raceID, RaceInfo_Type)) + { + case RaceType_Normal: + { + PrintToChatAllInRace(raceID, true, true, "%t", "Race Surrendered", client); + } + case RaceType_Duel: + { + ArrayList unfinishedRacers = GetUnfinishedRacers(raceID); + if (unfinishedRacers.Length == 1) + { + int opponent = unfinishedRacers.Get(0); + GOKZ_PrintToChatAll(true, "%t", "Duel Surrendered", client, opponent); + } + delete unfinishedRacers; + } + } +} + +void OnRequestReceived_Announce(int client, int raceID) +{ + int host = GetRaceHost(raceID); + + switch (GetRaceInfo(raceID, RaceInfo_Type)) + { + case RaceType_Normal: + { + GOKZ_PrintToChat(client, true, "%t", "Race Request Received", host); + } + case RaceType_Duel: + { + GOKZ_PrintToChat(client, true, "%t", "Duel Request Received", host); + } + } + + int cpRule = GetRaceInfo(raceID, RaceInfo_CheckpointRule); + int cdRule = GetRaceInfo(raceID, RaceInfo_CooldownRule); + int mode = GetRaceInfo(raceID, RaceInfo_Mode); + int course = GetRaceInfo(raceID, RaceInfo_Course); + + char courseStr[32]; + if (course == 0) + { + FormatEx(courseStr, sizeof(courseStr), "%T", "Race Rules - Main Course", client); + } + else + { + FormatEx(courseStr, sizeof(courseStr), "%T %d", "Race Rules - Bonus Course", client, course); + } + + if (cpRule == -1 && cdRule == 0) + { + GOKZ_PrintToChat(client, false, "%t", "Race Rules - Unlimited", gC_ModeNames[mode], courseStr); + } + if (cpRule == -1 && cdRule > 0) + { + GOKZ_PrintToChat(client, false, "%t", "Race Rules - Limited Cooldown", gC_ModeNames[mode], courseStr, cdRule); + } + if (cpRule == 0) + { + GOKZ_PrintToChat(client, false, "%t", "Race Rules - No Checkpoints", gC_ModeNames[mode], courseStr); + } + if (cpRule > 0 && cdRule == 0) + { + GOKZ_PrintToChat(client, false, "%t", "Race Rules - Limited Checkpoints", gC_ModeNames[mode], courseStr, cpRule); + } + if (cpRule > 0 && cdRule > 0) + { + GOKZ_PrintToChat(client, false, "%t", "Race Rules - Limited", gC_ModeNames[mode], courseStr, cpRule, cdRule); + } + + GOKZ_PrintToChat(client, false, "%t", "You Have Seconds To Accept", RoundFloat(RC_REQUEST_TIMEOUT_TIME)); +} + +void OnRequestAccepted_Announce(int client, int raceID) +{ + int host = GetRaceHost(raceID); + + switch (GetRaceInfo(raceID, RaceInfo_Type)) + { + case RaceType_Normal: + { + PrintToChatAllInRace(raceID, true, true, "%t", "Race Request Accepted", client, host); + } + case RaceType_Duel: + { + GOKZ_PrintToChatAll(true, "%t", "Duel Request Accepted", client, host); + } + } +} + +void OnRequestDeclined_Announce(int client, int raceID, bool timeout) +{ + int host = GetRaceHost(raceID); + + if (timeout) + { + switch (GetRaceInfo(raceID, RaceInfo_Type)) + { + case RaceType_Normal: + { + GOKZ_PrintToChat(client, true, "%t", "Race Request Not Accepted In Time (Target)"); + GOKZ_PrintToChat(host, true, "%t", "Race Request Not Accepted In Time (Host)", client); + } + case RaceType_Duel: + { + GOKZ_PrintToChat(client, true, "%t", "Duel Request Not Accepted In Time (Target)"); + GOKZ_PrintToChat(host, true, "%t", "Duel Request Not Accepted In Time (Host)", client); + } + } + } + else + { + GOKZ_PrintToChat(client, true, "%t", "You Have Declined"); + GOKZ_PrintToChat(host, true, "%t", "Player Has Declined", client); + } +} + +void OnRaceStarted_Announce(int raceID) +{ + if (GetRaceInfo(raceID, RaceInfo_Type) == RaceType_Normal) + { + PrintToChatAllInRace(raceID, true, true, "%t", "Race Host Started Countdown", GetRaceHost(raceID)); + } +} + +void OnRaceAborted_Announce(int raceID) +{ + for (int client = 1; client <= MaxClients; client++) + { + if (IsClientInGame(client) && GetRaceID(client) == raceID) + { + GOKZ_PrintToChat(client, true, "%t", "Race Has Been Aborted"); + if (GetStatus(client) == RacerStatus_Racing) + { + GOKZ_PlayErrorSound(client); + } + } + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-racing/api.sp b/sourcemod/scripting/gokz-racing/api.sp new file mode 100644 index 0000000..13d82a3 --- /dev/null +++ b/sourcemod/scripting/gokz-racing/api.sp @@ -0,0 +1,107 @@ +static GlobalForward H_OnFinish; +static GlobalForward H_OnSurrender; +static GlobalForward H_OnRequestReceived; +static GlobalForward H_OnRequestAccepted; +static GlobalForward H_OnRequestDeclined; +static GlobalForward H_OnRaceRegistered; +static GlobalForward H_OnRaceInfoChanged; + + + +// =====[ FORWARDS ]===== + +void CreateGlobalForwards() +{ + H_OnFinish = new GlobalForward("GOKZ_RC_OnFinish", ET_Ignore, Param_Cell, Param_Cell, Param_Cell); + H_OnSurrender = new GlobalForward("GOKZ_RC_OnSurrender", ET_Ignore, Param_Cell, Param_Cell); + H_OnRequestReceived = new GlobalForward("GOKZ_RC_OnRequestReceived", ET_Ignore, Param_Cell, Param_Cell); + H_OnRequestAccepted = new GlobalForward("GOKZ_RC_OnRequestAccepted", ET_Ignore, Param_Cell, Param_Cell); + H_OnRequestDeclined = new GlobalForward("GOKZ_RC_OnRequestDeclined", ET_Ignore, Param_Cell, Param_Cell, Param_Cell); + H_OnRaceRegistered = new GlobalForward("GOKZ_RC_OnRaceRegistered", ET_Ignore, Param_Cell); + H_OnRaceInfoChanged = new GlobalForward("GOKZ_RC_OnRaceInfoChanged", ET_Ignore, Param_Cell, Param_Cell, Param_Cell, Param_Cell); +} + +void Call_OnFinish(int client, int raceID, int place) +{ + Call_StartForward(H_OnFinish); + Call_PushCell(client); + Call_PushCell(raceID); + Call_PushCell(place); + Call_Finish(); +} + +void Call_OnSurrender(int client, int raceID) +{ + Call_StartForward(H_OnSurrender); + Call_PushCell(client); + Call_PushCell(raceID); + Call_Finish(); +} + +void Call_OnRequestReceived(int client, int raceID) +{ + Call_StartForward(H_OnRequestReceived); + Call_PushCell(client); + Call_PushCell(raceID); + Call_Finish(); +} + +void Call_OnRequestAccepted(int client, int raceID) +{ + Call_StartForward(H_OnRequestAccepted); + Call_PushCell(client); + Call_PushCell(raceID); + Call_Finish(); +} + +void Call_OnRequestDeclined(int client, int raceID, bool timeout) +{ + Call_StartForward(H_OnRequestDeclined); + Call_PushCell(client); + Call_PushCell(raceID); + Call_PushCell(timeout); + Call_Finish(); +} + +void Call_OnRaceRegistered(int raceID) +{ + Call_StartForward(H_OnRaceRegistered); + Call_PushCell(raceID); + Call_Finish(); +} + +void Call_OnRaceInfoChanged(int raceID, RaceInfo infoIndex, int oldValue, int newValue) +{ + Call_StartForward(H_OnRaceInfoChanged); + Call_PushCell(raceID); + Call_PushCell(infoIndex); + Call_PushCell(oldValue); + Call_PushCell(newValue); + Call_Finish(); +} + + + +// =====[ NATIVES ]===== + +void CreateNatives() +{ + CreateNative("GOKZ_RC_GetRaceInfo", Native_GetRaceInfo); + CreateNative("GOKZ_RC_GetStatus", Native_GetStatus); + CreateNative("GOKZ_RC_GetRaceID", Native_GetRaceID); +} + +public int Native_GetRaceInfo(Handle plugin, int numParams) +{ + return GetRaceInfo(GetNativeCell(1), GetNativeCell(2)); +} + +public int Native_GetStatus(Handle plugin, int numParams) +{ + return GetStatus(GetNativeCell(1)); +} + +public int Native_GetRaceID(Handle plugin, int numParams) +{ + return GetRaceID(GetNativeCell(1)); +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-racing/commands.sp b/sourcemod/scripting/gokz-racing/commands.sp new file mode 100644 index 0000000..9fbd7ab --- /dev/null +++ b/sourcemod/scripting/gokz-racing/commands.sp @@ -0,0 +1,47 @@ +void RegisterCommands() +{ + RegConsoleCmd("sm_accept", CommandAccept, "[KZ] Accept an incoming race request."); + RegConsoleCmd("sm_decline", CommandDecline, "[KZ] Decline an incoming race request."); + RegConsoleCmd("sm_surrender", CommandSurrender, "[KZ] Surrender your race."); + RegConsoleCmd("sm_duel", CommandDuel, "[KZ] Open the duel menu."); + RegConsoleCmd("sm_challenge", CommandDuel, "[KZ] Open the duel menu."); + RegConsoleCmd("sm_abort", CommandAbort, "[KZ] Abort the race you are hosting."); + + RegAdminCmd("sm_race", CommandRace, ADMFLAG_RESERVATION, "[KZ] Open the race hosting menu."); +} + +public Action CommandAccept(int client, int args) +{ + AcceptRequest(client); + return Plugin_Handled; +} + +public Action CommandDecline(int client, int args) +{ + DeclineRequest(client); + return Plugin_Handled; +} + +public Action CommandSurrender(int client, int args) +{ + SurrenderRacer(client); + return Plugin_Handled; +} + +public Action CommandDuel(int client, int args) +{ + DisplayDuelMenu(client); + return Plugin_Handled; +} + +public Action CommandAbort(int client, int args) +{ + AbortHostedRace(client); + return Plugin_Handled; +} + +public Action CommandRace(int client, int args) +{ + DisplayRaceMenu(client); + return Plugin_Handled; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-racing/duel_menu.sp b/sourcemod/scripting/gokz-racing/duel_menu.sp new file mode 100644 index 0000000..44c519f --- /dev/null +++ b/sourcemod/scripting/gokz-racing/duel_menu.sp @@ -0,0 +1,534 @@ +/* + A menu for initiating 1v1 races. +*/ + + + +#define ITEM_INFO_CHALLENGE "ch" +#define ITEM_INFO_ABORT "ab" +#define ITEM_INFO_MODE "md" +#define ITEM_INFO_COURSE "co" +#define ITEM_INFO_TELEPORT "tp" + +static int duelMenuMode[MAXPLAYERS + 1]; +static int duelMenuCourse[MAXPLAYERS + 1]; +static int duelMenuCheckpointLimit[MAXPLAYERS + 1]; +static int duelMenuCheckpointCooldown[MAXPLAYERS + 1]; + + + +// =====[ PICK MODE ]===== + +void DisplayDuelMenu(int client, bool reset = true) +{ + if (InRace(client) && (!IsRaceHost(client) || GetRaceInfo(GetRaceID(client), RaceInfo_Type) != RaceType_Duel)) + { + GOKZ_PrintToChat(client, true, "%t", "You Are Already Part Of A Race"); + GOKZ_PlayErrorSound(client); + return; + } + + if (reset) + { + duelMenuMode[client] = GOKZ_GetCoreOption(client, Option_Mode); + } + + Menu menu = new Menu(MenuHandler_Duel); + menu.SetTitle("%T", "Duel Menu - Title", client); + DuelMenuAddItems(client, menu); + menu.Display(client, MENU_TIME_FOREVER); +} + +public int MenuHandler_Duel(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + char info[16]; + menu.GetItem(param2, info, sizeof(info)); + + if (StrEqual(info, ITEM_INFO_CHALLENGE, false)) + { + if (!DisplayDuelOpponentMenu(param1)) + { + DisplayDuelMenu(param1, false); + } + } + else if (StrEqual(info, ITEM_INFO_ABORT, false)) + { + AbortHostedRace(param1); + DisplayDuelMenu(param1, false); + } + else if (StrEqual(info, ITEM_INFO_MODE, false)) + { + DisplayDuelModeMenu(param1); + } + else if (StrEqual(info, ITEM_INFO_COURSE, false)) + { + int course = duelMenuCourse[param1]; + do + { + course++; + if (!GOKZ_IsValidCourse(course)) + { + course = 0; + } + } while (!GOKZ_GetCourseRegistered(course) && course != duelMenuCourse[param1]); + duelMenuCourse[param1] = course; + DisplayDuelMenu(param1, false); + } + else if (StrEqual(info, ITEM_INFO_TELEPORT, false)) + { + DisplayDuelCheckpointMenu(param1); + } + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + +void DuelMenuAddItems(int client, Menu menu) +{ + char display[64]; + + menu.RemoveAllItems(); + + FormatEx(display, sizeof(display), "%T", "Duel Menu - Choose Opponent", client); + menu.AddItem(ITEM_INFO_CHALLENGE, display, InRace(client) ? ITEMDRAW_DISABLED : ITEMDRAW_DEFAULT); + + FormatEx(display, sizeof(display), "%T\n \n%T", "Race Menu - Abort Race", client, "Race Menu - Rules", client); + menu.AddItem(ITEM_INFO_ABORT, display, InRace(client) ? ITEMDRAW_DEFAULT : ITEMDRAW_DISABLED); + + FormatEx(display, sizeof(display), "%s", gC_ModeNames[duelMenuMode[client]]); + menu.AddItem(ITEM_INFO_MODE, display, InRace(client) ? ITEMDRAW_DISABLED : ITEMDRAW_DEFAULT); + + if (duelMenuCourse[client] == 0) + { + FormatEx(display, sizeof(display), "%T", "Race Rules - Main Course", client); + } + else + { + FormatEx(display, sizeof(display), "%T %d", "Race Rules - Bonus Course", client, duelMenuCourse[client]); + } + menu.AddItem(ITEM_INFO_COURSE, display, InRace(client) ? ITEMDRAW_DISABLED : ITEMDRAW_DEFAULT); + + FormatEx(display, sizeof(display), "%s", GetDuelRuleSummary(client, duelMenuCheckpointLimit[client], duelMenuCheckpointCooldown[client])); + menu.AddItem(ITEM_INFO_TELEPORT, display, InRace(client) ? ITEMDRAW_DISABLED : ITEMDRAW_DEFAULT); +} + + + +// =====[ MODE MENU ]===== + +static void DisplayDuelModeMenu(int client) +{ + Menu menu = new Menu(MenuHandler_DuelMode); + menu.ExitButton = false; + menu.ExitBackButton = true; + menu.SetTitle("%T", "Mode Rule Menu - Title", client); + GOKZ_MenuAddModeItems(client, menu, true); + menu.Display(client, MENU_TIME_FOREVER); +} + +public int MenuHandler_DuelMode(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + duelMenuMode[param1] = param2; + DisplayDuelMenu(param1, false); + } + else if (action == MenuAction_Cancel) + { + DisplayDuelMenu(param1, false); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + + + +// =====[ CHECKPOINT MENU ]===== + +static void DisplayDuelCheckpointMenu(int client) +{ + Menu menu = new Menu(MenuHandler_DuelCheckpoint); + menu.ExitButton = false; + menu.ExitBackButton = true; + menu.SetTitle("%T", "Checkpoint Rule Menu - Title", client); + DuelCheckpointMenuAddItems(client, menu); + menu.Display(client, MENU_TIME_FOREVER); +} + +public int MenuHandler_DuelCheckpoint(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + switch (param2) + { + case CheckpointRule_None: + { + duelMenuCheckpointCooldown[param1] = 0; + duelMenuCheckpointLimit[param1] = 0; + DisplayDuelMenu(param1, false); + } + case CheckpointRule_Limit: + { + DisplayCheckpointLimitMenu(param1); + } + case CheckpointRule_Cooldown: + { + DisplayCheckpointCooldownMenu(param1); + } + case CheckpointRule_Unlimited: + { + duelMenuCheckpointCooldown[param1] = 0; + duelMenuCheckpointLimit[param1] = -1; + DisplayDuelMenu(param1, false); + } + } + } + else if (action == MenuAction_Cancel) + { + DisplayDuelMenu(param1, false); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + +void DuelCheckpointMenuAddItems(int client, Menu menu) +{ + char display[32]; + + menu.RemoveAllItems(); + + FormatEx(display, sizeof(display), "%T", "Checkpoint Rule - None", client); + menu.AddItem("", display); + + if (duelMenuCheckpointLimit[client] == -1) + { + FormatEx(display, sizeof(display), "%T", "Checkpoint Rule - No Checkpoint Limit", client); + } + else + { + FormatEx(display, sizeof(display), "%T", "Checkpoint Rule - Checkpoint Limit", client, duelMenuCheckpointLimit[client]); + } + menu.AddItem("", display); + + if (duelMenuCheckpointCooldown[client] == 0) + { + FormatEx(display, sizeof(display), "%T", "Checkpoint Rule - No Checkpoint Cooldown", client); + } + else + { + FormatEx(display, sizeof(display), "%T", "Checkpoint Rule - Checkpoint Cooldown", client, duelMenuCheckpointCooldown[client]); + } + menu.AddItem("", display); + + FormatEx(display, sizeof(display), "%T", "Checkpoint Rule - Unlimited", client); + menu.AddItem("", display); +} + + + +// =====[ CP LIMIT MENU ]===== + +static void DisplayCheckpointLimitMenu(int client) +{ + char display[32]; + + Menu menu = new Menu(MenuHandler_DuelCheckpointLimit); + menu.ExitButton = false; + menu.ExitBackButton = true; + + if (duelMenuCheckpointLimit[client] == -1) + { + menu.SetTitle("%T", "Checkpoint Limit Menu - Title Unlimited", client); + } + else + { + menu.SetTitle("%T", "Checkpoint Limit Menu - Title Limited", client, duelMenuCheckpointLimit[client]); + } + + FormatEx(display, sizeof(display), "%T", "Checkpoint Limit Menu - Add One", client); + menu.AddItem("+1", display); + + FormatEx(display, sizeof(display), "%T", "Checkpoint Limit Menu - Add Five", client); + menu.AddItem("+5", display); + + FormatEx(display, sizeof(display), "%T", "Checkpoint Limit Menu - Remove One", client); + menu.AddItem("-1", display); + + FormatEx(display, sizeof(display), "%T", "Checkpoint Limit Menu - Remove Five", client); + menu.AddItem("-5", display); + + FormatEx(display, sizeof(display), "%T", "Checkpoint Limit Menu - Unlimited", client); + menu.AddItem("Unlimited", display); + + menu.Display(client, MENU_TIME_FOREVER); +} + +public int MenuHandler_DuelCheckpointLimit(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + char item[32]; + menu.GetItem(param2, item, sizeof(item)); + if (StrEqual(item, "+1")) + { + if (duelMenuCheckpointLimit[param1] == -1) + { + duelMenuCheckpointLimit[param1]++; + } + duelMenuCheckpointLimit[param1]++; + } + if (StrEqual(item, "+5")) + { + if (duelMenuCheckpointLimit[param1] == -1) + { + duelMenuCheckpointLimit[param1]++; + } + duelMenuCheckpointLimit[param1] += 5; + } + if (StrEqual(item, "-1")) + { + duelMenuCheckpointLimit[param1]--; + } + if (StrEqual(item, "-5")) + { + duelMenuCheckpointLimit[param1] -= 5; + } + if (StrEqual(item, "Unlimited")) + { + duelMenuCheckpointLimit[param1] = -1; + DisplayDuelCheckpointMenu(param1); + return 0; + } + + duelMenuCheckpointLimit[param1] = duelMenuCheckpointLimit[param1] < 0 ? 0 : duelMenuCheckpointLimit[param1]; + DisplayCheckpointLimitMenu(param1); + } + else if (action == MenuAction_Cancel) + { + DisplayDuelCheckpointMenu(param1); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + + + +// =====[ CP COOLDOWN MENU ]===== + +static void DisplayCheckpointCooldownMenu(int client) +{ + char display[32]; + + Menu menu = new Menu(MenuHandler_DuelCPCooldown); + menu.ExitButton = false; + menu.ExitBackButton = true; + + if (duelMenuCheckpointCooldown[client] == -1) + { + menu.SetTitle("%T", "Checkpoint Cooldown Menu - Title None", client); + } + else + { + menu.SetTitle("%T", "Checkpoint Cooldown Menu - Title Limited", client, duelMenuCheckpointCooldown[client]); + } + + FormatEx(display, sizeof(display), "%T", "Checkpoint Cooldown Menu - Add One Second", client); + menu.AddItem("+1", display); + + FormatEx(display, sizeof(display), "%T", "Checkpoint Cooldown Menu - Add Five Seconds", client); + menu.AddItem("+5", display); + + FormatEx(display, sizeof(display), "%T", "Checkpoint Cooldown Menu - Remove One Second", client); + menu.AddItem("-1", display); + + FormatEx(display, sizeof(display), "%T", "Checkpoint Cooldown Menu - Remove Five Seconds", client); + menu.AddItem("-5", display); + + FormatEx(display, sizeof(display), "%T", "Checkpoint Cooldown Menu - None", client); + menu.AddItem("None", display); + + menu.Display(client, MENU_TIME_FOREVER); +} + +public int MenuHandler_DuelCPCooldown(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + char item[32]; + menu.GetItem(param2, item, sizeof(item)); + if (StrEqual(item, "+1")) + { + if (duelMenuCheckpointCooldown[param1] == -1) + { + duelMenuCheckpointCooldown[param1]++; + } + duelMenuCheckpointCooldown[param1]++; + } + if (StrEqual(item, "+5")) + { + if (duelMenuCheckpointCooldown[param1] == -1) + { + duelMenuCheckpointCooldown[param1]++; + } + duelMenuCheckpointCooldown[param1] += 5; + } + if (StrEqual(item, "-1")) + { + duelMenuCheckpointCooldown[param1]--; + } + if (StrEqual(item, "-5")) + { + duelMenuCheckpointCooldown[param1] -= 5; + } + if (StrEqual(item, "None")) + { + duelMenuCheckpointCooldown[param1] = 0; + DisplayDuelCheckpointMenu(param1); + return 0; + } + + duelMenuCheckpointCooldown[param1] = duelMenuCheckpointCooldown[param1] < 0 ? 0 : duelMenuCheckpointCooldown[param1]; + DisplayCheckpointCooldownMenu(param1); + } + else if (action == MenuAction_Cancel) + { + DisplayDuelCheckpointMenu(param1); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + + + +// =====[ OPPONENT MENU ]===== + +static bool DisplayDuelOpponentMenu(int client) +{ + Menu menu = new Menu(MenuHandler_DuelOpponent); + menu.ExitButton = false; + menu.ExitBackButton = true; + menu.SetTitle("%T", "Duel Opponent Selection Menu - Title", client); + if (DuelOpponentMenuAddItems(client, menu) == 0) + { + GOKZ_PrintToChat(client, true, "%t", "No Opponents Available"); + GOKZ_PlayErrorSound(client); + delete menu; + return false; + } + menu.Display(client, MENU_TIME_FOREVER); + + return true; +} + +static int DuelOpponentMenuAddItems(int client, Menu menu) +{ + int count = 0; + for (int i = 1; i <= MaxClients; i++) + { + char display[MAX_NAME_LENGTH]; + if (i != client && IsClientInGame(i) && !IsFakeClient(i) && !InRace(i)) + { + FormatEx(display, sizeof(display), "%N", i); + menu.AddItem(IntToStringEx(GetClientUserId(i)), display); + count++; + } + } + return count; +} + +public int MenuHandler_DuelOpponent(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + char info[16]; + menu.GetItem(param2, info, sizeof(info)); + int target = GetClientOfUserId(StringToInt(info)); + if (IsValidClient(target)) + { + if (SendDuelRequest(param1, target)) + { + GOKZ_PrintToChat(param1, true, "%t", "Duel Request Sent", target); + } + else + { + DisplayDuelOpponentMenu(param1); + } + } + else + { + GOKZ_PrintToChat(param1, true, "%t", "Player No Longer Valid"); + GOKZ_PlayErrorSound(param1); + DisplayDuelOpponentMenu(param1); + } + } + else if (action == MenuAction_Cancel) + { + DisplayDuelMenu(param1, false); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + +static bool SendDuelRequest(int host, int target) +{ + if (InRace(target)) + { + GOKZ_PrintToChat(host, true, "%t", "Player Already In A Race", target); + GOKZ_PlayErrorSound(host); + return false; + } + + HostRace(host, RaceType_Duel, duelMenuCourse[host], duelMenuMode[host], duelMenuCheckpointLimit[host], duelMenuCheckpointCooldown[host]); + return SendRequest(host, target); +} + + + +// =====[ PRIVATE ]===== + +char[] GetDuelRuleSummary(int client, int checkpointLimit, int checkpointCooldown) +{ + char rulesString[64]; + if (checkpointLimit == -1 && checkpointCooldown == 0) + { + FormatEx(rulesString, sizeof(rulesString), "%T", "Rule Summary - Unlimited", client); + } + else if (checkpointLimit > 0 && checkpointCooldown == 0) + { + FormatEx(rulesString, sizeof(rulesString), "%T", "Rule Summary - Limited Checkpoints", client, checkpointLimit); + } + else if (checkpointLimit == -1 && checkpointCooldown > 0) + { + FormatEx(rulesString, sizeof(rulesString), "%T", "Rule Summary - Limited Cooldown", client, checkpointCooldown); + } + else if (checkpointLimit > 0 && checkpointCooldown > 0) + { + FormatEx(rulesString, sizeof(rulesString), "%T", "Rule Summary - Limited Everything", client, checkpointLimit, checkpointCooldown); + } + else if (checkpointLimit == 0) + { + FormatEx(rulesString, sizeof(rulesString), "%T", "Rule Summary - No Checkpoints", client); + } + + return rulesString; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-racing/race.sp b/sourcemod/scripting/gokz-racing/race.sp new file mode 100644 index 0000000..5ddc2a8 --- /dev/null +++ b/sourcemod/scripting/gokz-racing/race.sp @@ -0,0 +1,221 @@ +/* + Race info storing and accessing using a StringMap. + Each race is given a unique race ID when created. + See the RaceInfo enum for what information is accessible. + See the RaceStatus enum for possible race states. +*/ + + + +static StringMap raceInfo; +static int lastRaceID; + + + +// =====[ GENERAL ]===== + +int GetRaceInfo(int raceID, RaceInfo prop) +{ + ArrayList info; + if (raceInfo.GetValue(IntToStringEx(raceID), info)) + { + return info.Get(view_as<int>(prop)); + } + else + { + return -1; + } +} + +static bool SetRaceInfo(int raceID, RaceInfo prop, int value) +{ + ArrayList info; + if (raceInfo.GetValue(IntToStringEx(raceID), info)) + { + int oldValue = info.Get(view_as<int>(prop)); + if (oldValue != value) + { + info.Set(view_as<int>(prop), value); + Call_OnRaceInfoChanged(raceID, prop, oldValue, value); + } + return true; + } + else + { + return false; + } +} + +int IncrementFinishedRacerCount(int raceID) +{ + int finishedRacers = GetRaceInfo(raceID, RaceInfo_FinishedRacerCount) + 1; + SetRaceInfo(raceID, RaceInfo_FinishedRacerCount, finishedRacers); + return finishedRacers; +} + +int GetRaceHost(int raceID) +{ + return GetClientOfUserId(GetRaceInfo(raceID, RaceInfo_HostUserID)); +} + +ArrayList GetUnfinishedRacers(int raceID) +{ + ArrayList racers = new ArrayList(); + for (int i = 1; i <= MaxClients; i++) + { + if (GetRaceID(i) == raceID && !IsFinished(i)) + { + racers.Push(i); + } + } + return racers; +} + +int GetUnfinishedRacersCount(int raceID) +{ + ArrayList racers = GetUnfinishedRacers(raceID); + int count = racers.Length; + delete racers; + return count; +} + +ArrayList GetAcceptedRacers(int raceID) +{ + ArrayList racers = new ArrayList(); + for (int i = 1; i <= MaxClients; i++) + { + if (GetRaceID(i) == raceID && IsAccepted(i)) + { + racers.Push(i); + } + } + return racers; +} + +int GetAcceptedRacersCount(int raceID) +{ + ArrayList racers = GetAcceptedRacers(raceID); + int count = racers.Length; + delete racers; + return count; +} + + + +// =====[ REGISTRATION ]===== + +int RegisterRace(int host, int type, int course, int mode, int checkpointRule, int cooldownRule) +{ + int raceID = ++lastRaceID; + + ArrayList info = new ArrayList(1, view_as<int>(RACEINFO_COUNT)); + info.Set(view_as<int>(RaceInfo_ID), raceID); + info.Set(view_as<int>(RaceInfo_Status), RaceStatus_Pending); + info.Set(view_as<int>(RaceInfo_HostUserID), GetClientUserId(host)); + info.Set(view_as<int>(RaceInfo_FinishedRacerCount), 0); + info.Set(view_as<int>(RaceInfo_Type), type); + info.Set(view_as<int>(RaceInfo_Course), course); + info.Set(view_as<int>(RaceInfo_Mode), mode); + info.Set(view_as<int>(RaceInfo_CheckpointRule), checkpointRule); + info.Set(view_as<int>(RaceInfo_CooldownRule), cooldownRule); + + raceInfo.SetValue(IntToStringEx(raceID), info); + + Call_OnRaceRegistered(raceID); + + return raceID; +} + +static void UnregisterRace(int raceID) +{ + ArrayList info; + if (raceInfo.GetValue(IntToStringEx(raceID), info)) + { + delete info; + raceInfo.Remove(IntToStringEx(raceID)); + } +} + + + +// =====[ START ]===== + +bool StartRace(int raceID) +{ + SetRaceInfo(raceID, RaceInfo_Status, RaceStatus_Countdown); + + for (int client = 1; client <= MaxClients; client++) + { + if (GetRaceID(client) == raceID) + { + StartRacer(client); + GOKZ_PrintToChat(client, true, "%t", "Race Countdown Started"); + } + } + + CreateTimer(RC_COUNTDOWN_TIME, Timer_EndCountdown, raceID); + + return true; +} + +public Action Timer_EndCountdown(Handle timer, int raceID) +{ + SetRaceInfo(raceID, RaceInfo_Status, RaceStatus_Started); + return Plugin_Continue; +} + + + +// =====[ ABORT ]===== + +bool AbortRace(int raceID) +{ + SetRaceInfo(raceID, RaceInfo_Status, RaceStatus_Aborting); + + for (int client = 1; client <= MaxClients; client++) + { + if (GetRaceID(client) == raceID) + { + AbortRacer(client); + GOKZ_PrintToChat(client, true, "%t", "Race Has Been Aborted"); + GOKZ_PlayErrorSound(client); + } + } + + UnregisterRace(raceID); + + return true; +} + + + +// =====[ EVENTS ]===== + +void OnPluginStart_Race() +{ + raceInfo = new StringMap(); +} + +void OnFinish_Race(int raceID) +{ + if (GetUnfinishedRacersCount(raceID) == 0) + { + UnregisterRace(raceID); + } +} + +void OnRequestAccepted_Race(int raceID) +{ + if (GetRaceInfo(raceID, RaceInfo_Type) == RaceType_Duel) + { + StartRace(raceID); + } +} + +void OnRequestDeclined_Race(int raceID) +{ + if (GetRaceInfo(raceID, RaceInfo_Type) == RaceType_Duel) + { + AbortRace(raceID); + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-racing/race_menu.sp b/sourcemod/scripting/gokz-racing/race_menu.sp new file mode 100644 index 0000000..0518a2a --- /dev/null +++ b/sourcemod/scripting/gokz-racing/race_menu.sp @@ -0,0 +1,464 @@ +/* + A menu for hosting big races. +*/ + + + +#define ITEM_INFO_START "st" +#define ITEM_INFO_ABORT "ab" +#define ITEM_INFO_INVITE "iv" +#define ITEM_INFO_MODE "md" +#define ITEM_INFO_COURSE "co" +#define ITEM_INFO_TELEPORT "tp" + +static int raceMenuMode[MAXPLAYERS + 1]; +static int raceMenuCourse[MAXPLAYERS + 1]; +static int raceMenuCheckpointLimit[MAXPLAYERS + 1]; +static int raceMenuCheckpointCooldown[MAXPLAYERS + 1]; + + + +// =====[ PICK MODE ]===== + +void DisplayRaceMenu(int client, bool reset = true) +{ + if (InRace(client) && (!IsRaceHost(client) || GetRaceInfo(GetRaceID(client), RaceInfo_Type) != RaceType_Normal)) + { + GOKZ_PrintToChat(client, true, "%t", "You Are Already Part Of A Race"); + GOKZ_PlayErrorSound(client); + return; + } + + if (reset) + { + raceMenuMode[client] = GOKZ_GetCoreOption(client, Option_Mode); + raceMenuCourse[client] = 0; + } + + Menu menu = new Menu(MenuHandler_Race); + menu.SetTitle("%T", "Race Menu - Title", client); + RaceMenuAddItems(client, menu); + menu.Display(client, MENU_TIME_FOREVER); +} + +public int MenuHandler_Race(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + char info[16]; + menu.GetItem(param2, info, sizeof(info)); + + if (StrEqual(info, ITEM_INFO_START, false)) + { + if (!StartHostedRace(param1)) + { + DisplayRaceMenu(param1, false); + } + } + else if (StrEqual(info, ITEM_INFO_ABORT, false)) + { + AbortHostedRace(param1); + DisplayRaceMenu(param1, false); + } + else if (StrEqual(info, ITEM_INFO_INVITE, false)) + { + if (!InRace(param1)) + { + HostRace(param1, RaceType_Normal, raceMenuCourse[param1], raceMenuMode[param1], raceMenuCheckpointLimit[param1], raceMenuCheckpointCooldown[param1]); + } + + SendRequestAll(param1); + GOKZ_PrintToChat(param1, true, "%t", "You Invited Everyone"); + DisplayRaceMenu(param1, false); + } + else if (StrEqual(info, ITEM_INFO_MODE, false)) + { + DisplayRaceModeMenu(param1); + } + else if (StrEqual(info, ITEM_INFO_COURSE, false)) + { + int course = raceMenuCourse[param1]; + do + { + course++; + if (!GOKZ_IsValidCourse(course)) + { + course = 0; + } + } while (!GOKZ_GetCourseRegistered(course) && course != raceMenuCourse[param1]); + raceMenuCourse[param1] = course; + DisplayRaceMenu(param1, false); + } + else if (StrEqual(info, ITEM_INFO_TELEPORT, false)) + { + DisplayRaceCheckpointMenu(param1); + } + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + +void RaceMenuAddItems(int client, Menu menu) +{ + char display[32]; + + menu.RemoveAllItems(); + + bool pending = GetRaceInfo(GetRaceID(client), RaceInfo_Status) == RaceStatus_Pending; + FormatEx(display, sizeof(display), "%T", "Race Menu - Start Race", client); + menu.AddItem(ITEM_INFO_START, display, (InRace(client) && pending) ? ITEMDRAW_DEFAULT : ITEMDRAW_DISABLED); + + FormatEx(display, sizeof(display), "%T", "Race Menu - Invite Everyone", client); + menu.AddItem(ITEM_INFO_INVITE, display, (!InRace(client) || pending) ? ITEMDRAW_DEFAULT : ITEMDRAW_DISABLED); + + FormatEx(display, sizeof(display), "%T\n \n%T", "Race Menu - Abort Race", client, "Race Menu - Rules", client); + menu.AddItem(ITEM_INFO_ABORT, display, InRace(client) ? ITEMDRAW_DEFAULT : ITEMDRAW_DISABLED); + + FormatEx(display, sizeof(display), "%s", gC_ModeNames[raceMenuMode[client]]); + menu.AddItem(ITEM_INFO_MODE, display, InRace(client) ? ITEMDRAW_DISABLED : ITEMDRAW_DEFAULT); + + if (raceMenuCourse[client] == 0) + { + FormatEx(display, sizeof(display), "%T", "Race Rules - Main Course", client); + } + else + { + FormatEx(display, sizeof(display), "%T %d", "Race Rules - Bonus Course", client, raceMenuCourse[client]); + } + menu.AddItem(ITEM_INFO_COURSE, display, InRace(client) ? ITEMDRAW_DISABLED : ITEMDRAW_DEFAULT); + + FormatEx(display, sizeof(display), "%s", GetRaceRuleSummary(client, raceMenuCheckpointLimit[client], raceMenuCheckpointCooldown[client])); + menu.AddItem(ITEM_INFO_TELEPORT, display, InRace(client) ? ITEMDRAW_DISABLED : ITEMDRAW_DEFAULT); +} + + + +// =====[ MODE MENU ]===== + +static void DisplayRaceModeMenu(int client) +{ + Menu menu = new Menu(MenuHandler_RaceMode); + menu.ExitButton = false; + menu.ExitBackButton = true; + menu.SetTitle("%T", "Mode Rule Menu - Title", client); + GOKZ_MenuAddModeItems(client, menu, true); + menu.Display(client, MENU_TIME_FOREVER); +} + +public int MenuHandler_RaceMode(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + raceMenuMode[param1] = param2; + DisplayRaceMenu(param1, false); + } + else if (action == MenuAction_Cancel) + { + DisplayRaceMenu(param1, false); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + + + +// =====[ CHECKPOINT MENU ]===== + +static void DisplayRaceCheckpointMenu(int client) +{ + Menu menu = new Menu(MenuHandler_RaceCheckpoint); + menu.ExitButton = false; + menu.ExitBackButton = true; + menu.SetTitle("%T", "Checkpoint Rule Menu - Title", client); + RaceCheckpointMenuAddItems(client, menu); + menu.Display(client, MENU_TIME_FOREVER); +} + +public int MenuHandler_RaceCheckpoint(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + switch (param2) + { + case CheckpointRule_None: + { + raceMenuCheckpointLimit[param1] = 0; + raceMenuCheckpointCooldown[param1] = 0; + DisplayRaceMenu(param1, false); + } + case CheckpointRule_Limit: + { + DisplayCheckpointLimitMenu(param1); + } + case CheckpointRule_Cooldown: + { + DisplayCheckpointCooldownMenu(param1); + } + case CheckpointRule_Unlimited: + { + raceMenuCheckpointLimit[param1] = -1; + raceMenuCheckpointCooldown[param1] = 0; + DisplayRaceMenu(param1, false); + } + } + } + else if (action == MenuAction_Cancel) + { + DisplayRaceMenu(param1, false); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + +void RaceCheckpointMenuAddItems(int client, Menu menu) +{ + char display[32]; + + menu.RemoveAllItems(); + + FormatEx(display, sizeof(display), "%T", "Checkpoint Rule - None", client); + menu.AddItem("", display); + + if (raceMenuCheckpointLimit[client] == -1) + { + FormatEx(display, sizeof(display), "%T", "Checkpoint Rule - No Checkpoint Limit", client); + } + else + { + FormatEx(display, sizeof(display), "%T", "Checkpoint Rule - Checkpoint Limit", client, raceMenuCheckpointLimit[client]); + } + menu.AddItem("", display); + + if (raceMenuCheckpointCooldown[client] == 0) + { + FormatEx(display, sizeof(display), "%T", "Checkpoint Rule - No Checkpoint Cooldown", client); + } + else + { + FormatEx(display, sizeof(display), "%T", "Checkpoint Rule - Checkpoint Cooldown", client, raceMenuCheckpointCooldown[client]); + } + menu.AddItem("", display); + + FormatEx(display, sizeof(display), "%T", "Checkpoint Rule - Unlimited", client); + menu.AddItem("", display); +} + + + +// =====[ CP LIMIT MENU ]===== + +static void DisplayCheckpointLimitMenu(int client) +{ + char display[32]; + + Menu menu = new Menu(MenuHandler_RaceCheckpointLimit); + menu.ExitButton = false; + menu.ExitBackButton = true; + + if (raceMenuCheckpointLimit[client] == -1) + { + menu.SetTitle("%T", "Checkpoint Limit Menu - Title Unlimited", client); + } + else + { + menu.SetTitle("%T", "Checkpoint Limit Menu - Title Limited", client, raceMenuCheckpointLimit[client]); + } + + FormatEx(display, sizeof(display), "%T", "Checkpoint Limit Menu - Add One", client); + menu.AddItem("+1", display); + + FormatEx(display, sizeof(display), "%T", "Checkpoint Limit Menu - Add Five", client); + menu.AddItem("+5", display); + + FormatEx(display, sizeof(display), "%T", "Checkpoint Limit Menu - Remove One", client); + menu.AddItem("-1", display); + + FormatEx(display, sizeof(display), "%T", "Checkpoint Limit Menu - Remove Five", client); + menu.AddItem("-5", display); + + FormatEx(display, sizeof(display), "%T", "Checkpoint Limit Menu - Unlimited", client); + menu.AddItem("Unlimited", display); + + menu.Display(client, MENU_TIME_FOREVER); +} + +public int MenuHandler_RaceCheckpointLimit(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + char item[32]; + menu.GetItem(param2, item, sizeof(item)); + if (StrEqual(item, "+1")) + { + if (raceMenuCheckpointLimit[param1] == -1) + { + raceMenuCheckpointLimit[param1]++; + } + raceMenuCheckpointLimit[param1]++; + } + if (StrEqual(item, "+5")) + { + if (raceMenuCheckpointLimit[param1] == -1) + { + raceMenuCheckpointLimit[param1]++; + } + raceMenuCheckpointLimit[param1] += 5; + } + if (StrEqual(item, "-1")) + { + raceMenuCheckpointLimit[param1]--; + } + if (StrEqual(item, "-5")) + { + raceMenuCheckpointLimit[param1] -= 5; + } + if (StrEqual(item, "Unlimited")) + { + raceMenuCheckpointLimit[param1] = -1; + DisplayRaceCheckpointMenu(param1); + return 0; + } + + raceMenuCheckpointLimit[param1] = raceMenuCheckpointLimit[param1] < 0 ? 0 : raceMenuCheckpointLimit[param1]; + DisplayCheckpointLimitMenu(param1); + } + else if (action == MenuAction_Cancel) + { + DisplayRaceCheckpointMenu(param1); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + + + +// =====[ CP COOLDOWN MENU ]===== + +static void DisplayCheckpointCooldownMenu(int client) +{ + char display[32]; + + Menu menu = new Menu(MenuHandler_RaceCPCooldown); + menu.ExitButton = false; + menu.ExitBackButton = true; + + if (raceMenuCheckpointCooldown[client] == -1) + { + menu.SetTitle("%T", "Checkpoint Cooldown Menu - Title None", client); + } + else + { + menu.SetTitle("%T", "Checkpoint Cooldown Menu - Title Limited", client, raceMenuCheckpointCooldown[client]); + } + + FormatEx(display, sizeof(display), "%T", "Checkpoint Cooldown Menu - Add One Second", client); + menu.AddItem("+1", display); + + FormatEx(display, sizeof(display), "%T", "Checkpoint Cooldown Menu - Add Five Seconds", client); + menu.AddItem("+5", display); + + FormatEx(display, sizeof(display), "%T", "Checkpoint Cooldown Menu - Remove One Second", client); + menu.AddItem("-1", display); + + FormatEx(display, sizeof(display), "%T", "Checkpoint Cooldown Menu - Remove Five Seconds", client); + menu.AddItem("-5", display); + + FormatEx(display, sizeof(display), "%T", "Checkpoint Cooldown Menu - None", client); + menu.AddItem("None", display); + + menu.Display(client, MENU_TIME_FOREVER); +} + +public int MenuHandler_RaceCPCooldown(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + char item[32]; + menu.GetItem(param2, item, sizeof(item)); + if (StrEqual(item, "+1")) + { + if (raceMenuCheckpointCooldown[param1] == -1) + { + raceMenuCheckpointCooldown[param1]++; + } + raceMenuCheckpointCooldown[param1]++; + } + if (StrEqual(item, "+5")) + { + if (raceMenuCheckpointCooldown[param1] == -1) + { + raceMenuCheckpointCooldown[param1]++; + } + raceMenuCheckpointCooldown[param1] += 5; + } + if (StrEqual(item, "-1")) + { + raceMenuCheckpointCooldown[param1]--; + } + if (StrEqual(item, "-5")) + { + raceMenuCheckpointCooldown[param1] -= 5; + } + if (StrEqual(item, "None")) + { + raceMenuCheckpointCooldown[param1] = 0; + DisplayRaceCheckpointMenu(param1); + return 0; + } + + raceMenuCheckpointCooldown[param1] = raceMenuCheckpointCooldown[param1] < 0 ? 0 : raceMenuCheckpointCooldown[param1]; + DisplayCheckpointCooldownMenu(param1); + } + else if (action == MenuAction_Cancel) + { + DisplayRaceCheckpointMenu(param1); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + + + +// =====[ PRIVATE ]===== + +char[] GetRaceRuleSummary(int client, int checkpointLimit, int checkpointCooldown) +{ + char rulesString[64]; + if (checkpointLimit == -1 && checkpointCooldown == 0) + { + FormatEx(rulesString, sizeof(rulesString), "%T", "Rule Summary - Unlimited", client); + } + else if (checkpointLimit > 0 && checkpointCooldown == 0) + { + FormatEx(rulesString, sizeof(rulesString), "%T", "Rule Summary - Limited Checkpoints", client, checkpointLimit); + } + else if (checkpointLimit == -1 && checkpointCooldown > 0) + { + FormatEx(rulesString, sizeof(rulesString), "%T", "Rule Summary - Limited Cooldown", client, checkpointCooldown); + } + else if (checkpointLimit > 0 && checkpointCooldown > 0) + { + FormatEx(rulesString, sizeof(rulesString), "%T", "Rule Summary - Limited Everything", client, checkpointLimit, checkpointCooldown); + } + else if (checkpointLimit == 0) + { + FormatEx(rulesString, sizeof(rulesString), "%T", "Rule Summary - No Checkpoints", client); + } + + return rulesString; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-racing/racer.sp b/sourcemod/scripting/gokz-racing/racer.sp new file mode 100644 index 0000000..eb4ff3f --- /dev/null +++ b/sourcemod/scripting/gokz-racing/racer.sp @@ -0,0 +1,439 @@ +/* + Functions that affect the state of clients participating in a race. + See the RacerStatus enum for possible states. +*/ + + + +static int racerStatus[MAXPLAYERS + 1]; +static int racerRaceID[MAXPLAYERS + 1]; +static float lastTimerStartTime[MAXPLAYERS + 1]; +static float lastCheckpointTime[MAXPLAYERS + 1]; + + + +// =====[ EVENTS ]===== + +Action OnTimerStart_Racer(int client, int course) +{ + if (InCountdown(client) + || InStartedRace(client) && (!InRaceMode(client) || !IsRaceCourse(client, course))) + { + return Plugin_Stop; + } + + return Plugin_Continue; +} + +Action OnTimerStart_Post_Racer(int client) +{ + lastTimerStartTime[client] = GetGameTime(); + return Plugin_Continue; +} + +Action OnMakeCheckpoint_Racer(int client) +{ + if (GOKZ_GetTimerRunning(client) && InStartedRace(client)) + { + int checkpointRule = GetRaceInfo(GetRaceID(client), RaceInfo_CheckpointRule); + if (checkpointRule == 0) + { + GOKZ_PrintToChat(client, true, "%t", "Checkpoints Not Allowed During Race"); + GOKZ_PlayErrorSound(client); + return Plugin_Handled; + } + else if (checkpointRule != -1 && GOKZ_GetCheckpointCount(client) >= checkpointRule) + { + GOKZ_PrintToChat(client, true, "%t", "No Checkpoints Left"); + GOKZ_PlayErrorSound(client); + return Plugin_Handled; + } + + float cooldownRule = float(GetRaceInfo(GetRaceID(client), RaceInfo_CooldownRule)); + float timeSinceLastCheckpoint = FloatMin( + GetGameTime() - lastTimerStartTime[client], + GetGameTime() - lastCheckpointTime[client]); + if (timeSinceLastCheckpoint < cooldownRule) + { + GOKZ_PrintToChat(client, true, "%t", "Checkpoint On Cooldown", (cooldownRule - timeSinceLastCheckpoint)); + GOKZ_PlayErrorSound(client); + return Plugin_Handled; + } + } + + return Plugin_Continue; +} + +void OnMakeCheckpoint_Post_Racer(int client) +{ + lastCheckpointTime[client] = GetGameTime(); +} + +Action OnUndoTeleport_Racer(int client) +{ + if (GOKZ_GetTimerRunning(client) + && InStartedRace(client) + && GetRaceInfo(GetRaceID(client), RaceInfo_CheckpointRule) != -1) + { + GOKZ_PrintToChat(client, true, "%t", "Undo TP Not Allowed During Race"); + GOKZ_PlayErrorSound(client); + return Plugin_Handled; + } + + return Plugin_Continue; +} + + + +// =====[ GENERAL ]===== + +int GetStatus(int client) +{ + return racerStatus[client]; +} + +int GetRaceID(int client) +{ + return racerRaceID[client]; +} + +bool InRace(int client) +{ + return GetStatus(client) != RacerStatus_Available; +} + +bool InStartedRace(int client) +{ + return GetStatus(client) == RacerStatus_Racing; +} + +bool InCountdown(int client) +{ + return GetRaceInfo(GetRaceID(client), RaceInfo_Status) == RaceStatus_Countdown; +} + +bool InRaceMode(int client) +{ + return GOKZ_GetCoreOption(client, Option_Mode) == GetRaceInfo(GetRaceID(client), RaceInfo_Mode); +} + +bool IsRaceCourse(int client, int course) +{ + return course == GetRaceInfo(GetRaceID(client), RaceInfo_Course); +} + +bool IsFinished(int client) +{ + int status = GetStatus(client); + return status == RacerStatus_Finished || status == RacerStatus_Surrendered; +} + +bool IsAccepted(int client) +{ + return GetStatus(client) == RacerStatus_Accepted; +} + +bool IsRaceHost(int client) +{ + return GetRaceHost(GetRaceID(client)) == client; +} + +static void ResetRacer(int client) +{ + racerStatus[client] = RacerStatus_Available; + racerRaceID[client] = -1; + lastTimerStartTime[client] = 0.0; + lastCheckpointTime[client] = 0.0; +} + +static void ResetRacersInRace(int raceID) +{ + for (int client = 1; client <= MaxClients; client++) + { + if (racerRaceID[client] == raceID) + { + ResetRacer(client); + } + } +} + + + +// =====[ RACING ]===== + +void StartRacer(int client) +{ + if (racerStatus[client] == RacerStatus_Pending) + { + DeclineRequest(client, true); + return; + } + + if (racerStatus[client] != RacerStatus_Accepted) + { + return; + } + + racerStatus[client] = RacerStatus_Racing; + + // Prepare the racer + GOKZ_StopTimer(client); + GOKZ_SetCoreOption(client, Option_Mode, GetRaceInfo(racerRaceID[client], RaceInfo_Mode)); + + int course = GetRaceInfo(racerRaceID[client], RaceInfo_Course); + if (GOKZ_SetStartPositionToMapStart(client, course)) + { + GOKZ_TeleportToStart(client); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "No Start Found", course); + } +} + +bool FinishRacer(int client, int course) +{ + if (racerStatus[client] != RacerStatus_Racing || + course != GetRaceInfo(racerRaceID[client], RaceInfo_Course)) + { + return false; + } + + racerStatus[client] = RacerStatus_Finished; + + int raceID = racerRaceID[client]; + int place = IncrementFinishedRacerCount(raceID); + + Call_OnFinish(client, raceID, place); + + CheckRaceFinished(raceID); + + return true; +} + +bool SurrenderRacer(int client) +{ + if (racerStatus[client] == RacerStatus_Available + || racerStatus[client] == RacerStatus_Surrendered) + { + return false; + } + + racerStatus[client] = RacerStatus_Surrendered; + + int raceID = racerRaceID[client]; + + Call_OnSurrender(client, raceID); + + CheckRaceFinished(raceID); + + return true; +} + +// Auto-finish last remaining racer, and reset everyone if no one is left +static void CheckRaceFinished(int raceID) +{ + ArrayList remainingRacers = GetUnfinishedRacers(raceID); + if (remainingRacers.Length == 1) + { + int lastRacer = remainingRacers.Get(0); + FinishRacer(lastRacer, GetRaceInfo(racerRaceID[lastRacer], RaceInfo_Course)); + } + else if (remainingRacers.Length == 0) + { + ResetRacersInRace(raceID); + } + delete remainingRacers; +} + +bool AbortRacer(int client) +{ + if (racerStatus[client] == RacerStatus_Available) + { + return false; + } + + ResetRacer(client); + + return true; +} + + + +// =====[ HOSTING ]===== + +int HostRace(int client, int type, int course, int mode, int checkpointRule, int cooldownRule) +{ + if (InRace(client)) + { + return -1; + } + + int raceID = RegisterRace(client, type, course, mode, checkpointRule, cooldownRule); + racerRaceID[client] = raceID; + racerStatus[client] = RacerStatus_Accepted; + + return raceID; +} + +bool StartHostedRace(int client) +{ + if (!InRace(client) || !IsRaceHost(client)) + { + GOKZ_PrintToChat(client, true, "%t", "You Are Not Hosting A Race"); + GOKZ_PlayErrorSound(client); + return false; + } + + int raceID = racerRaceID[client]; + + if (GetRaceInfo(raceID, RaceInfo_Status) != RaceStatus_Pending) + { + GOKZ_PrintToChat(client, true, "%t", "Race Already Started"); + GOKZ_PlayErrorSound(client); + return false; + } + + if (GetAcceptedRacersCount(raceID) <= 1) + { + GOKZ_PrintToChat(client, true, "%t", "No One Accepted"); + GOKZ_PlayErrorSound(client); + return false; + } + + return StartRace(raceID); +} + +bool AbortHostedRace(int client) +{ + if (!InRace(client) || !IsRaceHost(client)) + { + GOKZ_PrintToChat(client, true, "%t", "You Are Not Hosting A Race"); + GOKZ_PlayErrorSound(client); + return false; + } + + int raceID = racerRaceID[client]; + + return AbortRace(raceID); +} + + + +// =====[ REQUESTS ]===== + +bool SendRequest(int host, int target) +{ + if (IsFakeClient(target) || target == host || InRace(target) + || !IsRaceHost(host) || GetRaceInfo(racerRaceID[host], RaceInfo_Status) != RaceStatus_Pending) + { + return false; + } + + int raceID = racerRaceID[host]; + + racerRaceID[target] = raceID; + racerStatus[target] = RacerStatus_Pending; + + // Host callback + DataPack data = new DataPack(); + data.WriteCell(GetClientUserId(host)); + data.WriteCell(GetClientUserId(target)); + data.WriteCell(raceID); + CreateTimer(RC_REQUEST_TIMEOUT_TIME, Timer_RequestTimeout, data); + + Call_OnRequestReceived(target, raceID); + + return true; +} + +public Action Timer_RequestTimeout(Handle timer, DataPack data) +{ + data.Reset(); + int host = GetClientOfUserId(data.ReadCell()); + int target = GetClientOfUserId(data.ReadCell()); + int raceID = data.ReadCell(); + delete data; + + if (!IsValidClient(host) || racerRaceID[host] != raceID + || !IsValidClient(target) || racerRaceID[target] != raceID) + { + return Plugin_Continue; + } + + // If haven't accepted by now, auto decline the race + if (racerStatus[target] == RacerStatus_Pending) + { + DeclineRequest(target, true); + } + return Plugin_Continue; +} + +int SendRequestAll(int host) +{ + int sentCount = 0; + for (int target = 1; target <= MaxClients; target++) + { + if (IsClientInGame(target) && SendRequest(host, target)) + { + sentCount++; + } + } + return sentCount; +} + +bool AcceptRequest(int client) +{ + if (GetStatus(client) != RacerStatus_Pending) + { + return false; + } + + racerStatus[client] = RacerStatus_Accepted; + + Call_OnRequestAccepted(client, racerRaceID[client]); + + return true; +} + +bool DeclineRequest(int client, bool timeout = false) +{ + if (GetStatus(client) != RacerStatus_Pending) + { + return false; + } + + int raceID = racerRaceID[client]; + ResetRacer(client); + + Call_OnRequestDeclined(client, raceID, timeout); + + return true; +} + + + +// =====[ EVENTS ]===== + +void OnClientPutInServer_Racer(int client) +{ + ResetRacer(client); +} + +void OnClientDisconnect_Racer(int client) +{ + // Abort if player was the host of the race, else surrender + if (InRace(client)) + { + if (IsRaceHost(client) && GetRaceInfo(racerRaceID[client], RaceInfo_Status) == RaceStatus_Pending) + { + AbortRace(racerRaceID[client]); + } + else + { + SurrenderRacer(client); + } + } + + ResetRacer(client); +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-replays.sp b/sourcemod/scripting/gokz-replays.sp new file mode 100644 index 0000000..bc826c4 --- /dev/null +++ b/sourcemod/scripting/gokz-replays.sp @@ -0,0 +1,397 @@ +#include <sourcemod> + +#include <cstrike> +#include <sdkhooks> +#include <sdktools> +#include <dhooks> + +#include <movementapi> + +#include <gokz/core> +#include <gokz/localranks> +#include <gokz/replays> + +#undef REQUIRE_EXTENSIONS +#undef REQUIRE_PLUGIN +#include <gokz/hud> +#include <gokz/jumpstats> +#include <gokz/localdb> +#include <updater> + +#pragma newdecls required +#pragma semicolon 1 + +//#define DEBUG + + + +public Plugin myinfo = +{ + name = "GOKZ Replays", + author = "DanZay", + description = "Records runs to disk and allows playback using bots", + version = GOKZ_VERSION, + url = GOKZ_SOURCE_URL +}; + +#define UPDATER_URL GOKZ_UPDATER_BASE_URL..."gokz-replays.txt" + +bool gB_GOKZHUD; +bool gB_GOKZLocalDB; +char gC_CurrentMap[64]; +int gI_CurrentMapFileSize; +bool gB_HideNameChange; +bool gB_NubRecordMissed[MAXPLAYERS + 1]; +ArrayList g_ReplayInfoCache; +Address gA_BotDuckAddr; +int gI_BotDuckPatchRestore[40]; // Size of patched section in gamedata +int gI_BotDuckPatchLength; + +DynamicDetour gH_DHooks_TeamFull; + +#include "gokz-replays/commands.sp" +#include "gokz-replays/nav.sp" +#include "gokz-replays/playback.sp" +#include "gokz-replays/recording.sp" +#include "gokz-replays/replay_cache.sp" +#include "gokz-replays/replay_menu.sp" +#include "gokz-replays/api.sp" +#include "gokz-replays/controls.sp" + + + +// =====[ PLUGIN EVENTS ]===== + +public APLRes AskPluginLoad2(Handle myself, bool late, char[] error, int err_max) +{ + CreateNatives(); + RegPluginLibrary("gokz-replays"); + return APLRes_Success; +} + +public void OnPluginStart() +{ + LoadTranslations("gokz-common.phrases"); + LoadTranslations("gokz-replays.phrases"); + + CreateGlobalForwards(); + HookEvents(); + RegisterCommands(); +} + +public void OnAllPluginsLoaded() +{ + if (LibraryExists("updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + gB_GOKZLocalDB = LibraryExists("gokz-localdb"); + gB_GOKZHUD = LibraryExists("gokz-hud"); + + for (int client = 1; client <= MaxClients; client++) + { + if (IsClientInGame(client)) + { + OnClientPutInServer(client); + } + } +} + +public void OnLibraryAdded(const char[] name) +{ + if (StrEqual(name, "updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + gB_GOKZLocalDB = gB_GOKZLocalDB || StrEqual(name, "gokz-localdb"); + gB_GOKZHUD = gB_GOKZHUD || StrEqual(name, "gokz-hud"); +} + +public void OnLibraryRemoved(const char[] name) +{ + gB_GOKZLocalDB = gB_GOKZLocalDB && !StrEqual(name, "gokz-localdb"); + gB_GOKZHUD = gB_GOKZHUD && !StrEqual(name, "gokz-hud"); +} + +public void OnPluginEnd() +{ + // Restore bot auto duck behavior. + if (gA_BotDuckAddr == Address_Null) + { + return; + } + for (int i = 0; i < gI_BotDuckPatchLength; i++) + { + StoreToAddress(gA_BotDuckAddr + view_as<Address>(i), gI_BotDuckPatchRestore[i], NumberType_Int8); + } +} + +// =====[ OTHER EVENTS ]===== + +public void OnMapStart() +{ + UpdateCurrentMap(); // Do first + OnMapStart_Nav(); + OnMapStart_Recording(); + OnMapStart_ReplayCache(); +} + +public void OnConfigsExecuted() +{ + FindConVar("mp_autoteambalance").BoolValue = false; + FindConVar("mp_limitteams").IntValue = 0; + // Stop the bots! + FindConVar("bot_stop").BoolValue = true; + FindConVar("bot_chatter").SetString("off"); + FindConVar("bot_zombie").BoolValue = true; + FindConVar("bot_join_after_player").BoolValue = false; + FindConVar("bot_quota_mode").SetString("normal"); + FindConVar("bot_quota").Flags &= ~FCVAR_NOTIFY; + FindConVar("bot_quota").Flags &= ~FCVAR_REPLICATED; +} + +public void OnEntityCreated(int entity, const char[] classname) +{ + // Block trigger and door interaction for bots + // Credit to shavit's simple bhop timer - https://github.com/shavitush/bhoptimer + + // trigger_once | trigger_multiple.. etc + // func_door | func_door_rotating + if (StrContains(classname, "trigger_") != -1 || StrContains(classname, "_door") != -1) + { + SDKHook(entity, SDKHook_StartTouch, HookTriggers); + SDKHook(entity, SDKHook_EndTouch, HookTriggers); + SDKHook(entity, SDKHook_Touch, HookTriggers); + } +} + +public Action HookTriggers(int entity, int other) +{ + if (other >= 1 && other <= MaxClients && IsFakeClient(other)) + { + return Plugin_Handled; + } + + return Plugin_Continue; +} + +public Action Hook_SayText2(UserMsg msg_id, any msg, const int[] players, int playersNum, bool reliable, bool init) +{ + // Name change supression + // Credit to shavit's simple bhop timer - https://github.com/shavitush/bhoptimer + if (!gB_HideNameChange) + { + return Plugin_Continue; + } + + char msgName[24]; + Protobuf pbmsg = msg; + pbmsg.ReadString("msg_name", msgName, sizeof(msgName)); + if (StrEqual(msgName, "#Cstrike_Name_Change")) + { + gB_HideNameChange = false; + return Plugin_Handled; + } + + return Plugin_Continue; +} + +public MRESReturn DHooks_OnTeamFull_Pre(Address pThis, DHookReturn hReturn, DHookParam hParams) +{ + DHookSetReturn(hReturn, false); + return MRES_Supercede; +} + +// =====[ CLIENT EVENTS ]===== + +public void OnClientPutInServer(int client) +{ + OnClientPutInServer_Playback(client); + OnClientPutInServer_Recording(client); +} + +public void OnClientAuthorized(int client, const char[] auth) +{ + OnClientAuthorized_Recording(client); +} + +public void OnClientDisconnect(int client) +{ + OnClientDisconnect_Playback(client); + OnClientDisconnect_Recording(client); +} + +public Action OnPlayerRunCmd(int client, int &buttons, int &impulse, float vel[3], float angles[3], int &weapon, int &subtype, int &cmdnum, int &tickcount, int &seed, int mouse[2]) +{ + if (!IsFakeClient(client)) + { + return Plugin_Continue; + } + OnPlayerRunCmd_Playback(client, buttons, vel, angles); + return Plugin_Changed; +} + +public void OnPlayerRunCmdPost(int client, int buttons, int impulse, const float vel[3], const float angles[3], int weapon, int subtype, int cmdnum, int tickcount, int seed, const int mouse[2]) +{ + OnPlayerRunCmdPost_Playback(client); + OnPlayerRunCmdPost_Recording(client, buttons, tickcount, vel, mouse); + OnPlayerRunCmdPost_ReplayControls(client, cmdnum); +} + +public Action GOKZ_OnTimerStart(int client, int course) +{ + Action action = GOKZ_OnTimerStart_Recording(client); + if (action != Plugin_Continue) + { + return action; + } + + return Plugin_Continue; +} + +public void GOKZ_OnTimerStart_Post(int client, int course) +{ + gB_NubRecordMissed[client] = false; + GOKZ_OnTimerStart_Post_Recording(client); +} + +public void GOKZ_OnTimerEnd_Post(int client, int course, float time, int teleportsUsed) +{ + GOKZ_OnTimerEnd_Recording(client, course, time, teleportsUsed); +} + +public void GOKZ_OnPause_Post(int client) +{ + GOKZ_OnPause_Recording(client); +} + +public void GOKZ_OnResume_Post(int client) +{ + GOKZ_OnResume_Recording(client); +} + +public void GOKZ_OnTimerStopped(int client) +{ + GOKZ_OnTimerStopped_Recording(client); +} + +public void GOKZ_OnCountedTeleport_Post(int client) +{ + GOKZ_OnCountedTeleport_Recording(client); +} + +public void GOKZ_LR_OnRecordMissed(int client, float recordTime, int course, int mode, int style, int recordType) +{ + if (recordType == RecordType_Nub) + { + gB_NubRecordMissed[client] = true; + } + GOKZ_LR_OnRecordMissed_Recording(client, recordType); +} + +public void GOKZ_AC_OnPlayerSuspected(int client, ACReason reason) +{ + GOKZ_AC_OnPlayerSuspected_Recording(client, reason); +} + +public void GOKZ_DB_OnJumpstatPB(int client, int jumptype, int mode, float distance, int block, int strafes, float sync, float pre, float max, int airtime) +{ + GOKZ_DB_OnJumpstatPB_Recording(client, jumptype, distance, block, strafes, sync, pre, max, airtime); +} + +public void GOKZ_OnOptionsLoaded(int client) +{ + if (IsFakeClient(client)) + { + GOKZ_OnOptionsLoaded_Playback(client); + } +} + +// =====[ PRIVATE ]===== + +static void HookEvents() +{ + HookUserMessage(GetUserMessageId("SayText2"), Hook_SayText2, true); + GameData gameData = LoadGameConfigFile("gokz-replays.games"); + + gH_DHooks_TeamFull = DynamicDetour.FromConf(gameData, "CCSGameRules::TeamFull"); + if (gH_DHooks_TeamFull == INVALID_HANDLE) + { + SetFailState("Failed to find CCSGameRules::TeamFull function signature"); + } + + if (!gH_DHooks_TeamFull.Enable(Hook_Pre, DHooks_OnTeamFull_Pre)) + { + SetFailState("Failed to enable detour on CCSGameRules::TeamFull"); + } + + // Remove bot auto duck behavior. + gA_BotDuckAddr = gameData.GetAddress("BotDuck"); + gI_BotDuckPatchLength = gameData.GetOffset("BotDuckPatchLength"); + for (int i = 0; i < gI_BotDuckPatchLength; i++) + { + gI_BotDuckPatchRestore[i] = LoadFromAddress(gA_BotDuckAddr + view_as<Address>(i), NumberType_Int8); + StoreToAddress(gA_BotDuckAddr + view_as<Address>(i), 0x90, NumberType_Int8); + } + delete gameData; +} + +static void UpdateCurrentMap() +{ + GetCurrentMapDisplayName(gC_CurrentMap, sizeof(gC_CurrentMap)); + gI_CurrentMapFileSize = GetCurrentMapFileSize(); +} + + +// =====[ PUBLIC ]===== + +// NOTE: These serialisation functions were made because the internal data layout of enum structs can change. +void TickDataToArray(ReplayTickData tickData, any result[RP_V2_TICK_DATA_BLOCKSIZE]) +{ + // NOTE: HAS to match ReplayTickData exactly! + result[0] = tickData.deltaFlags; + result[1] = tickData.deltaFlags2; + result[2] = tickData.vel[0]; + result[3] = tickData.vel[1]; + result[4] = tickData.vel[2]; + result[5] = tickData.mouse[0]; + result[6] = tickData.mouse[1]; + result[7] = tickData.origin[0]; + result[8] = tickData.origin[1]; + result[9] = tickData.origin[2]; + result[10] = tickData.angles[0]; + result[11] = tickData.angles[1]; + result[12] = tickData.angles[2]; + result[13] = tickData.velocity[0]; + result[14] = tickData.velocity[1]; + result[15] = tickData.velocity[2]; + result[16] = tickData.flags; + result[17] = tickData.packetsPerSecond; + result[18] = tickData.laggedMovementValue; + result[19] = tickData.buttonsForced; +} + +void TickDataFromArray(any array[RP_V2_TICK_DATA_BLOCKSIZE], ReplayTickData result) +{ + // NOTE: HAS to match ReplayTickData exactly! + result.deltaFlags = array[0]; + result.deltaFlags2 = array[1]; + result.vel[0] = array[2]; + result.vel[1] = array[3]; + result.vel[2] = array[4]; + result.mouse[0] = array[5]; + result.mouse[1] = array[6]; + result.origin[0] = array[7]; + result.origin[1] = array[8]; + result.origin[2] = array[9]; + result.angles[0] = array[10]; + result.angles[1] = array[11]; + result.angles[2] = array[12]; + result.velocity[0] = array[13]; + result.velocity[1] = array[14]; + result.velocity[2] = array[15]; + result.flags = array[16]; + result.packetsPerSecond = array[17]; + result.laggedMovementValue = array[18]; + result.buttonsForced = array[19]; +} diff --git a/sourcemod/scripting/gokz-replays/api.sp b/sourcemod/scripting/gokz-replays/api.sp new file mode 100644 index 0000000..3c115e1 --- /dev/null +++ b/sourcemod/scripting/gokz-replays/api.sp @@ -0,0 +1,78 @@ +static GlobalForward H_OnReplaySaved; +static GlobalForward H_OnReplayDiscarded; +static GlobalForward H_OnTimerEnd_Post; + +// =====[ NATIVES ]===== + +void CreateNatives() +{ + CreateNative("GOKZ_RP_GetPlaybackInfo", Native_RP_GetPlaybackInfo); + CreateNative("GOKZ_RP_LoadJumpReplay", Native_RP_LoadJumpReplay); + CreateNative("GOKZ_RP_UpdateReplayControlMenu", Native_RP_UpdateReplayControlMenu); +} + +public int Native_RP_GetPlaybackInfo(Handle plugin, int numParams) +{ + HUDInfo info; + GetPlaybackState(GetNativeCell(1), info); + SetNativeArray(2, info, sizeof(HUDInfo)); + return 1; +} + +public int Native_RP_LoadJumpReplay(Handle plugin, int numParams) +{ + int len; + GetNativeStringLength(2, len); + char[] path = new char[len + 1]; + GetNativeString(2, path, len + 1); + int botClient = LoadReplayBot(GetNativeCell(1), path); + return botClient; +} + +public int Native_RP_UpdateReplayControlMenu(Handle plugin, int numParams) +{ + return view_as<int>(UpdateReplayControlMenu(GetNativeCell(1))); +} + +// =====[ FORWARDS ]===== + +void CreateGlobalForwards() +{ + H_OnReplaySaved = new GlobalForward("GOKZ_RP_OnReplaySaved", ET_Event, Param_Cell, Param_Cell, Param_String, Param_Cell, Param_Cell, Param_Float, Param_String, Param_Cell); + H_OnReplayDiscarded = new GlobalForward("GOKZ_RP_OnReplayDiscarded", ET_Ignore, Param_Cell); + H_OnTimerEnd_Post = new GlobalForward("GOKZ_RP_OnTimerEnd_Post", ET_Ignore, Param_Cell, Param_String, Param_Cell, Param_Float, Param_Cell); +} + +Action Call_OnReplaySaved(int client, int replayType, const char[] map, int course, int timeType, float time, const char[] filePath, bool tempReplay) +{ + Action result; + Call_StartForward(H_OnReplaySaved); + Call_PushCell(client); + Call_PushCell(replayType); + Call_PushString(map); + Call_PushCell(course); + Call_PushCell(timeType); + Call_PushFloat(time); + Call_PushString(filePath); + Call_PushCell(tempReplay); + Call_Finish(result); + return result; +} + +void Call_OnReplayDiscarded(int client) +{ + Call_StartForward(H_OnReplayDiscarded); + Call_PushCell(client); + Call_Finish(); +} + +void Call_OnTimerEnd_Post(int client, const char[] filePath, int course, float time, int teleportsUsed) +{ + Call_StartForward(H_OnTimerEnd_Post); + Call_PushCell(client); + Call_PushString(filePath); + Call_PushCell(course); + Call_PushFloat(time); + Call_PushCell(teleportsUsed); + Call_Finish(); +} diff --git a/sourcemod/scripting/gokz-replays/commands.sp b/sourcemod/scripting/gokz-replays/commands.sp new file mode 100644 index 0000000..43251f6 --- /dev/null +++ b/sourcemod/scripting/gokz-replays/commands.sp @@ -0,0 +1,55 @@ +void RegisterCommands() +{ + RegConsoleCmd("sm_replay", CommandReplay, "[KZ] Open the replay loading menu."); + RegConsoleCmd("sm_replaycontrols", CommandReplayControls, "[KZ] Toggle the replay control menu."); + RegConsoleCmd("sm_rpcontrols", CommandReplayControls, "[KZ] Toggle the replay control menu."); + RegConsoleCmd("sm_replaygoto", CommandReplayGoto, "[KZ] Skip to a specific time in the replay (hh:mm:ss)."); + RegConsoleCmd("sm_rpgoto", CommandReplayGoto, "[KZ] Skip to a specific time in the replay (hh:mm:ss)."); +} + +public Action CommandReplay(int client, int args) +{ + DisplayReplayModeMenu(client); + return Plugin_Handled; +} + +public Action CommandReplayControls(int client, int args) +{ + ToggleReplayControls(client); + return Plugin_Handled; +} + +public Action CommandReplayGoto(int client, int args) +{ + int seconds; + char timeString[32], split[3][32]; + + GetCmdArgString(timeString, sizeof(timeString)); + int res = ExplodeString(timeString, ":", split, 3, 32, false); + switch (res) + { + case 1: + { + seconds = StringToInt(split[0]); + } + + case 2: + { + seconds = StringToInt(split[0]) * 60 + StringToInt(split[1]); + } + + case 3: + { + seconds = StringToInt(split[0]) * 3600 + StringToInt(split[1]) * 60 + StringToInt(split[2]); + } + + default: + { + GOKZ_PrintToChat(client, true, "%t", "Replay Controls - Invalid Time"); + return Plugin_Handled; + } + } + + TrySkipToTime(client, seconds); + return Plugin_Handled; +} diff --git a/sourcemod/scripting/gokz-replays/controls.sp b/sourcemod/scripting/gokz-replays/controls.sp new file mode 100644 index 0000000..cda7f07 --- /dev/null +++ b/sourcemod/scripting/gokz-replays/controls.sp @@ -0,0 +1,224 @@ +/* + Lets player control the replay bot. +*/ + +#define ITEM_INFO_PAUSE "pause" +#define ITEM_INFO_SKIP "skip" +#define ITEM_INFO_REWIND "rewind" +#define ITEM_INFO_FREECAM "freecam" + +static int controllingPlayer[RP_MAX_BOTS]; +static int botTeleports[RP_MAX_BOTS]; +static bool showReplayControls[MAXPLAYERS + 1]; + + + +// =====[ PUBLIC ]===== + +void OnPlayerRunCmdPost_ReplayControls(int client, int cmdnum) +{ + // Let the HUD plugin takes care of this if possible. + if (cmdnum % 6 == 3 && !gB_GOKZHUD) + { + UpdateReplayControlMenu(client); + } +} + +bool UpdateReplayControlMenu(int client) +{ + if (!IsValidClient(client) || IsFakeClient(client)) + { + return false; + } + + int botClient = GetObserverTarget(client); + int bot = GetBotFromClient(botClient); + if (bot == -1) + { + return false; + } + + if (!IsReplayBotControlled(bot, botClient) && !InBreather(bot)) + { + CancelReplayControlsForBot(bot); + controllingPlayer[bot] = client; + } + else if (controllingPlayer[bot] != client) + { + return false; + } + + if (showReplayControls[client] && + GOKZ_HUD_GetOption(client, HUDOption_ShowControls) == ReplayControls_Enabled) + { + // We have to update this often if bot uses teleports. + if (GetClientMenu(client) == MenuSource_None || + GOKZ_HUD_GetMenuShowing(client) && GetClientAvgLoss(client, NetFlow_Both) > EPSILON || + GOKZ_HUD_GetMenuShowing(client) && GOKZ_HUD_GetOption(client, HUDOption_TimerText) == TimerText_TPMenu || + GOKZ_HUD_GetMenuShowing(client) && PlaybackGetTeleports(bot) > 0) + { + botTeleports[bot] = PlaybackGetTeleports(bot); + ShowReplayControlMenu(client, bot); + } + return true; + } + return false; +} + +void ShowReplayControlMenu(int client, int bot) +{ + char text[256]; + + Menu menu = new Menu(MenuHandler_ReplayControls); + menu.OptionFlags = MENUFLAG_NO_SOUND; + menu.Pagination = MENU_NO_PAGINATION; + menu.ExitButton = true; + if (gB_GOKZHUD) + { + if (GOKZ_HUD_GetOption(client, HUDOption_ShowSpectators) != ShowSpecs_Disabled && + GOKZ_HUD_GetOption(client, HUDOption_SpecListPosition) == SpecListPosition_TPMenu) + { + HUDInfo info; + GetPlaybackState(client, info); + GOKZ_HUD_GetMenuSpectatorText(client, info, text, sizeof(text)); + } + if (GOKZ_HUD_GetOption(client, HUDOption_TimerText) == TimerText_TPMenu) + { + Format(text, sizeof(text), "%s\n%T - %s", text, "Replay Controls - Title", client, + GOKZ_FormatTime(GetPlaybackTime(bot), GOKZ_HUD_GetOption(client, HUDOption_TimerStyle) == TimerStyle_Precise)); + } + else + { + Format(text, sizeof(text), "%s%T", text, "Replay Controls - Title", client); + } + } + else + { + Format(text, sizeof(text), "%s%T", text, "Replay Controls - Title", client); + } + + + if (botTeleports[bot] > 0) + { + Format(text, sizeof(text), "%s\n%T", text, "Replay Controls - Teleports", client, botTeleports[bot]); + } + + menu.SetTitle(text); + + if (PlaybackPaused(bot)) + { + FormatEx(text, sizeof(text), "%T", "Replay Controls - Resume", client); + menu.AddItem(ITEM_INFO_PAUSE, text); + } + else + { + FormatEx(text, sizeof(text), "%T", "Replay Controls - Pause", client); + menu.AddItem(ITEM_INFO_PAUSE, text); + } + + FormatEx(text, sizeof(text), "%T", "Replay Controls - Skip", client); + menu.AddItem(ITEM_INFO_SKIP, text); + + FormatEx(text, sizeof(text), "%T\n ", "Replay Controls - Rewind", client); + menu.AddItem(ITEM_INFO_REWIND, text); + + FormatEx(text, sizeof(text), "%T", "Replay Controls - Freecam", client); + menu.AddItem(ITEM_INFO_FREECAM, text); + + menu.Display(client, MENU_TIME_FOREVER); + + if (gB_GOKZHUD) + { + GOKZ_HUD_SetMenuShowing(client, true); + } +} + +void ToggleReplayControls(int client) +{ + if (showReplayControls[client]) + { + CancelReplayControls(client); + } + else + { + showReplayControls[client] = true; + } +} + +void EnableReplayControls(int client) +{ + showReplayControls[client] = true; +} + +bool IsReplayBotControlled(int bot, int botClient) +{ + return IsValidClient(controllingPlayer[bot]) && + (GetObserverTarget(controllingPlayer[bot]) == botClient || + GetEntProp(controllingPlayer[bot], Prop_Send, "m_iObserverMode") == 6); +} + +int MenuHandler_ReplayControls(Menu menu, MenuAction action, int param1, int param2) +{ + switch (action) + { + case MenuAction_Select: + { + if (!IsValidClient(param1)) + { + return; + } + + int bot = GetBotFromClient(GetObserverTarget(param1)); + if (bot == -1 || controllingPlayer[bot] != param1) + { + return; + } + + char info[16]; + menu.GetItem(param2, info, sizeof(info)); + if (StrEqual(info, ITEM_INFO_PAUSE, false)) + { + PlaybackTogglePause(bot); + } + else if (StrEqual(info, ITEM_INFO_SKIP, false)) + { + PlaybackSkipForward(bot); + } + else if (StrEqual(info, ITEM_INFO_REWIND, false)) + { + PlaybackSkipBack(bot); + } + else if (StrEqual(info, ITEM_INFO_FREECAM, false)) + { + SetEntProp(param1, Prop_Send, "m_iObserverMode", 6); + } + GOKZ_HUD_SetMenuShowing(param1, false); + } + case MenuAction_Cancel: + { + GOKZ_HUD_SetMenuShowing(param1, false); + if (param2 == MenuCancel_Exit) + { + CancelReplayControls(param1); + } + } + case MenuAction_End: + { + delete menu; + } + } +} + +void CancelReplayControls(int client) +{ + if (IsValidClient(client) && showReplayControls[client]) + { + CancelClientMenu(client); + showReplayControls[client] = false; + } +} + +void CancelReplayControlsForBot(int bot) +{ + CancelReplayControls(controllingPlayer[bot]); +} diff --git a/sourcemod/scripting/gokz-replays/nav.sp b/sourcemod/scripting/gokz-replays/nav.sp new file mode 100644 index 0000000..4e73c2f --- /dev/null +++ b/sourcemod/scripting/gokz-replays/nav.sp @@ -0,0 +1,97 @@ +/* + Ensures that there is .nav file for the map so the server + does not to auto-generating one. +*/ + + + +// =====[ EVENTS ]===== + +void OnMapStart_Nav() +{ + if (!CheckForNavFile()) + { + GenerateNavFile(); + } +} + + + +// =====[ PRIVATE ]===== + +static bool CheckForNavFile() +{ + // Make sure there's a nav file + // Credit to shavit's simple bhop timer - https://github.com/shavitush/bhoptimer + + char mapPath[PLATFORM_MAX_PATH]; + GetCurrentMap(mapPath, sizeof(mapPath)); + + char navFilePath[PLATFORM_MAX_PATH]; + FormatEx(navFilePath, PLATFORM_MAX_PATH, "maps/%s.nav", mapPath); + + return FileExists(navFilePath); +} + +static void GenerateNavFile() +{ + // Generate (copy a) .nav file for the map + // Credit to shavit's simple bhop timer - https://github.com/shavitush/bhoptimer + + char mapPath[PLATFORM_MAX_PATH]; + GetCurrentMap(mapPath, sizeof(mapPath)); + + char[] navFilePath = new char[PLATFORM_MAX_PATH]; + FormatEx(navFilePath, PLATFORM_MAX_PATH, "maps/%s.nav", mapPath); + + if (!FileExists(RP_NAV_FILE)) + { + SetFailState("Failed to load file: \"%s\". Check that it exists.", RP_NAV_FILE); + } + File_Copy(RP_NAV_FILE, navFilePath); + ForceChangeLevel(gC_CurrentMap, "[gokz-replays] Generate .nav file."); +} + +/* + * Copies file source to destination + * Based on code of javalia: + * http://forums.alliedmods.net/showthread.php?t=159895 + * + * Credit to shavit's simple bhop timer - https://github.com/shavitush/bhoptimer + * + * @param source Input file + * @param destination Output file + */ +static bool File_Copy(const char[] source, const char[] destination) +{ + File file_source = OpenFile(source, "rb"); + + if (file_source == null) + { + return false; + } + + File file_destination = OpenFile(destination, "wb"); + + if (file_destination == null) + { + delete file_source; + + return false; + } + + int[] buffer = new int[32]; + int cache = 0; + + while (!IsEndOfFile(file_source)) + { + cache = ReadFile(file_source, buffer, 32, 1); + + file_destination.Write(buffer, cache, 1); + } + + delete file_source; + delete file_destination; + + return true; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-replays/playback.sp b/sourcemod/scripting/gokz-replays/playback.sp new file mode 100644 index 0000000..b3f6865 --- /dev/null +++ b/sourcemod/scripting/gokz-replays/playback.sp @@ -0,0 +1,1501 @@ +/* + Bot replay playback logic and processes. + + The recorded files are read and their information and tick data + stored into variables. A bot is then used to playback the recorded + data by setting it's origin, velocity, etc. in OnPlayerRunCmd. +*/ + + + +static int preAndPostRunTickCount; + +static int playbackTick[RP_MAX_BOTS]; +static ArrayList playbackTickData[RP_MAX_BOTS]; +static bool inBreather[RP_MAX_BOTS]; +static float breatherStartTime[RP_MAX_BOTS]; + +// Original bot caller, needed for OnClientPutInServer callback +static int botCaller[RP_MAX_BOTS]; +// Original bot name after creation by bot_add, needed for bot removal +static char botName[RP_MAX_BOTS][MAX_NAME_LENGTH]; +static bool botInGame[RP_MAX_BOTS]; +static int botClient[RP_MAX_BOTS]; +static bool botDataLoaded[RP_MAX_BOTS]; +static int botReplayType[RP_MAX_BOTS]; +static int botReplayVersion[RP_MAX_BOTS]; +static int botSteamAccountID[RP_MAX_BOTS]; +static int botCourse[RP_MAX_BOTS]; +static int botMode[RP_MAX_BOTS]; +static int botStyle[RP_MAX_BOTS]; +static float botTime[RP_MAX_BOTS]; +static int botTimeTicks[RP_MAX_BOTS]; +static char botAlias[RP_MAX_BOTS][MAX_NAME_LENGTH]; +static bool botPaused[RP_MAX_BOTS]; +static bool botPlaybackPaused[RP_MAX_BOTS]; +static int botKnife[RP_MAX_BOTS]; +static int botWeapon[RP_MAX_BOTS]; +static int botJumpType[RP_MAX_BOTS]; +static float botJumpDistance[RP_MAX_BOTS]; +static int botJumpBlockDistance[RP_MAX_BOTS]; + +static int timeOnGround[RP_MAX_BOTS]; +static int timeInAir[RP_MAX_BOTS]; +static int botTeleportsUsed[RP_MAX_BOTS]; +static int botCurrentTeleport[RP_MAX_BOTS]; +static int botButtons[RP_MAX_BOTS]; +static MoveType botMoveType[RP_MAX_BOTS]; +static float botTakeoffSpeed[RP_MAX_BOTS]; +static float botSpeed[RP_MAX_BOTS]; +static float botLastOrigin[RP_MAX_BOTS][3]; +static bool hitBhop[RP_MAX_BOTS]; +static bool hitPerf[RP_MAX_BOTS]; +static bool botJumped[RP_MAX_BOTS]; +static bool botIsTakeoff[RP_MAX_BOTS]; +static bool botJustTeleported[RP_MAX_BOTS]; +static float botLandingSpeed[RP_MAX_BOTS]; + + + +// =====[ PUBLIC ]===== + +// Returns the client index of the replay bot, or -1 otherwise +int LoadReplayBot(int client, char[] path) +{ + // Safeguard Check + if (GOKZ_GetCoreOption(client, Option_Safeguard) > Safeguard_Disabled && GOKZ_GetTimerRunning(client) && GOKZ_GetValidTimer(client)) + { + if (!GOKZ_GetPaused(client) && !GOKZ_GetCanPause(client)) + { + GOKZ_PrintToChat(client, true, "%t", "Safeguard - Blocked"); + GOKZ_PlayErrorSound(client); + return -1; + } + } + int bot; + if (GetBotsInUse() < RP_MAX_BOTS) + { + bot = GetUnusedBot(); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "No Bots Available"); + GOKZ_PlayErrorSound(client); + return -1; + } + + if (bot == -1) + { + LogError("Unused bot could not be found even though only %d out of %d are known to be in use.", + GetBotsInUse(), RP_MAX_BOTS); + GOKZ_PlayErrorSound(client); + return -1; + } + + if (!LoadPlayback(client, bot, path)) + { + GOKZ_PlayErrorSound(client); + return -1; + } + + ServerCommand("bot_add"); + botCaller[bot] = client; + return botClient[bot]; +} + +// Passes the current state of the replay into the HUDInfo struct +void GetPlaybackState(int client, HUDInfo info) +{ + int bot, i; + for(i = 0; i < RP_MAX_BOTS; i++) + { + bot = botClient[i] == client ? i : bot; + } + if (i == RP_MAX_BOTS + 1) return; + + if (playbackTickData[bot] == INVALID_HANDLE) + { + return; + } + + info.TimerRunning = botReplayType[bot] == ReplayType_Jump ? false : true; + if (botReplayVersion[bot] == 1) + { + info.Time = playbackTick[bot] * GetTickInterval(); + } + else if (botReplayVersion[bot] == 2) + { + if (playbackTick[bot] < preAndPostRunTickCount) + { + info.Time = 0.0; + } + else if (playbackTick[bot] >= playbackTickData[bot].Length - preAndPostRunTickCount) + { + info.Time = botTime[bot]; + } + else if (playbackTick[bot] >= preAndPostRunTickCount) + { + info.Time = (playbackTick[bot] - preAndPostRunTickCount) * GetTickInterval(); + } + } + info.TimerRunning = true; + info.TimeType = botTeleportsUsed[bot] > 0 ? TimeType_Nub : TimeType_Pro; + info.Speed = botSpeed[bot]; + info.Paused = false; + info.OnLadder = (botMoveType[bot] == MOVETYPE_LADDER); + info.Noclipping = false; + info.OnGround = Movement_GetOnGround(client); + info.Ducking = botButtons[bot] & IN_DUCK > 0; + info.ID = botClient[bot]; + info.Jumped = botJumped[bot]; + info.HitBhop = hitBhop[bot]; + info.HitPerf = hitPerf[bot]; + info.Buttons = botButtons[bot]; + info.TakeoffSpeed = botTakeoffSpeed[bot]; + info.IsTakeoff = botIsTakeoff[bot] && !Movement_GetOnGround(client); + info.CurrentTeleport = botCurrentTeleport[bot]; +} + +int GetBotFromClient(int client) +{ + for (int bot = 0; bot < RP_MAX_BOTS; bot++) + { + if (botClient[bot] == client) + { + return bot; + } + } + return -1; +} + +bool InBreather(int bot) +{ + return inBreather[bot]; +} + +bool PlaybackPaused(int bot) +{ + return botPlaybackPaused[bot]; +} + +void PlaybackTogglePause(int bot) +{ + if(botPlaybackPaused[bot]) + { + botPlaybackPaused[bot] = false; + } + else + { + botPlaybackPaused[bot] = true; + } +} + +void PlaybackSkipForward(int bot) +{ + if (playbackTick[bot] + RoundToZero(RP_SKIP_TIME / GetTickInterval()) < playbackTickData[bot].Length) + { + PlaybackSkipToTick(bot, playbackTick[bot] + RoundToZero(RP_SKIP_TIME / GetTickInterval())); + } +} + +void PlaybackSkipBack(int bot) +{ + if (playbackTick[bot] < RoundToZero(RP_SKIP_TIME / GetTickInterval())) + { + PlaybackSkipToTick(bot, 0); + } + else + { + PlaybackSkipToTick(bot, playbackTick[bot] - RoundToZero(RP_SKIP_TIME / GetTickInterval())); + } +} + +int PlaybackGetTeleports(int bot) +{ + return botCurrentTeleport[bot]; +} + +void TrySkipToTime(int client, int seconds) +{ + if (!IsValidClient(client)) + { + return; + } + + int tick = seconds * 128 + preAndPostRunTickCount; + int bot = GetBotFromClient(GetObserverTarget(client)); + + if (tick >= 0 && tick < playbackTickData[bot].Length) + { + PlaybackSkipToTick(bot, tick); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Replay Controls - Invalid Time"); + } +} + +float GetPlaybackTime(int bot) +{ + if (playbackTick[bot] < preAndPostRunTickCount) + { + return 0.0; + } + if (playbackTick[bot] >= playbackTickData[bot].Length - preAndPostRunTickCount) + { + return botTime[bot]; + } + if (playbackTick[bot] >= preAndPostRunTickCount) + { + return (playbackTick[bot] - preAndPostRunTickCount) * GetTickInterval(); + } + + return 0.0; +} + + + +// =====[ EVENTS ]===== + +void OnClientPutInServer_Playback(int client) +{ + if (!IsFakeClient(client) || IsClientSourceTV(client)) + { + return; + } + + // Check if an unassigned bot has joined, and assign it + for (int bot; bot < RP_MAX_BOTS; bot++) + { + // Also check if the bot was created by us. + if (!botInGame[bot] && botCaller[bot] != 0) + { + botInGame[bot] = true; + botClient[bot] = client; + GetClientName(client, botName[bot], sizeof(botName[])); + // The bot won't receive its weapons properly if we don't wait a frame + RequestFrame(SetBotStuff, bot); + if (IsValidClient(botCaller[bot])) + { + MakePlayerSpectate(botCaller[bot], botClient[bot]); + botCaller[bot] = 0; + } + break; + } + } +} + +void OnClientDisconnect_Playback(int client) +{ + for (int bot; bot < RP_MAX_BOTS; bot++) + { + if (botClient[bot] != client) + { + continue; + } + + botInGame[bot] = false; + if (playbackTickData[bot] != null) + { + playbackTickData[bot].Clear(); // Clear it all out + botDataLoaded[bot] = false; + } + } +} + +void OnPlayerRunCmd_Playback(int client, int &buttons, float vel[3], float angles[3]) +{ + if (!IsFakeClient(client)) + { + return; + } + + for (int bot; bot < RP_MAX_BOTS; bot++) + { + // Check if not the bot we're looking for + if (!botInGame[bot] || botClient[bot] != client || !botDataLoaded[bot]) + { + continue; + } + + switch (botReplayVersion[bot]) + { + case 1: PlaybackVersion1(client, bot, buttons); + case 2: PlaybackVersion2(client, bot, buttons, vel, angles); + } + break; + } +} + +void OnPlayerRunCmdPost_Playback(int client) +{ + for (int bot; bot < RP_MAX_BOTS; bot++) + { + // Check if not the bot we're looking for + if (!botInGame[bot] || botClient[bot] != client || !botDataLoaded[bot]) + { + continue; + } + if (botReplayVersion[bot] == 2) + { + PlaybackVersion2Post(client, bot); + } + break; + } +} + +void GOKZ_OnOptionsLoaded_Playback(int client) +{ + for (int bot = 0; bot < RP_MAX_BOTS; bot++) + { + if (botClient[bot] == client) + { + // Reset its movement options as it might be wrongfully changed + GOKZ_SetCoreOption(client, Option_Mode, botMode[bot]); + GOKZ_SetCoreOption(client, Option_Style, botStyle[bot]); + } + } +} +// =====[ PRIVATE ]===== + +// Returns false if there was a problem loading the playback e.g. doesn't exist +static bool LoadPlayback(int client, int bot, char[] path) +{ + if (!FileExists(path)) + { + GOKZ_PrintToChat(client, true, "%t", "No Replay Found"); + return false; + } + + File file = OpenFile(path, "rb"); + + // Check magic number in header + int magicNumber; + file.ReadInt32(magicNumber); + if (magicNumber != RP_MAGIC_NUMBER) + { + LogError("Failed to load invalid replay file: \"%s\".", path); + delete file; + return false; + } + + // Check replay format version + int formatVersion; + file.ReadInt8(formatVersion); + switch(formatVersion) + { + case 1: + { + botReplayVersion[bot] = 1; + if (!LoadFormatVersion1Replay(file, bot)) + { + return false; + } + } + case 2: + { + botReplayVersion[bot] = 2; + if (!LoadFormatVersion2Replay(file, client, bot)) + { + return false; + } + } + + default: + { + LogError("Failed to load replay file with unsupported format version: \"%s\".", path); + delete file; + return false; + } + } + + return true; +} + +static bool LoadFormatVersion1Replay(File file, int bot) +{ + // Old replays only support runs, not jumps + botReplayType[bot] = ReplayType_Run; + + int length; + + // GOKZ version + file.ReadInt8(length); + char[] gokzVersion = new char[length + 1]; + file.ReadString(gokzVersion, length, length); + gokzVersion[length] = '\0'; + + // Map name + file.ReadInt8(length); + char[] mapName = new char[length + 1]; + file.ReadString(mapName, length, length); + mapName[length] = '\0'; + + // Some integers... + file.ReadInt32(botCourse[bot]); + file.ReadInt32(botMode[bot]); + file.ReadInt32(botStyle[bot]); + + // Old replays don't store the weapon information + botKnife[bot] = CS_WeaponIDToItemDefIndex(CSWeapon_KNIFE); + botWeapon[bot] = (botMode[bot] == Mode_Vanilla) ? -1 : CS_WeaponIDToItemDefIndex(CSWeapon_USP_SILENCER); + + // Time + int timeAsInt; + file.ReadInt32(timeAsInt); + botTime[bot] = view_as<float>(timeAsInt); + + // Some integers... + file.ReadInt32(botTeleportsUsed[bot]); + file.ReadInt32(botSteamAccountID[bot]); + + // SteamID2 + file.ReadInt8(length); + char[] steamID2 = new char[length + 1]; + file.ReadString(steamID2, length, length); + steamID2[length] = '\0'; + + // IP + file.ReadInt8(length); + char[] IP = new char[length + 1]; + file.ReadString(IP, length, length); + IP[length] = '\0'; + + // Alias + file.ReadInt8(length); + file.ReadString(botAlias[bot], sizeof(botAlias[]), length); + botAlias[bot][length] = '\0'; + + // Read tick data + file.ReadInt32(length); + + // Setup playback tick data array list + if (playbackTickData[bot] == null) + { + playbackTickData[bot] = new ArrayList(IntMax(RP_V1_TICK_DATA_BLOCKSIZE, sizeof(ReplayTickData)), length); + } + else + { // Make sure it's all clear and the correct size + playbackTickData[bot].Clear(); + playbackTickData[bot].Resize(length); + } + + // The replay has no replay data, this shouldn't happen normally, + // but this would cause issues in other code, so we don't even try to load this. + if (length == 0) + { + delete file; + return false; + } + + any tickData[RP_V1_TICK_DATA_BLOCKSIZE]; + for (int i = 0; i < length; i++) + { + file.Read(tickData, RP_V1_TICK_DATA_BLOCKSIZE, 4); + playbackTickData[bot].Set(i, view_as<float>(tickData[0]), 0); // origin[0] + playbackTickData[bot].Set(i, view_as<float>(tickData[1]), 1); // origin[1] + playbackTickData[bot].Set(i, view_as<float>(tickData[2]), 2); // origin[2] + playbackTickData[bot].Set(i, view_as<float>(tickData[3]), 3); // angles[0] + playbackTickData[bot].Set(i, view_as<float>(tickData[4]), 4); // angles[1] + playbackTickData[bot].Set(i, view_as<int>(tickData[5]), 5); // buttons + playbackTickData[bot].Set(i, view_as<int>(tickData[6]), 6); // flags + } + + playbackTick[bot] = 0; + botDataLoaded[bot] = true; + + delete file; + return true; +} + +static bool LoadFormatVersion2Replay(File file, int client, int bot) +{ + int length; + + // Replay type + int replayType; + file.ReadInt8(replayType); + + // GOKZ version + file.ReadInt8(length); + char[] gokzVersion = new char[length + 1]; + file.ReadString(gokzVersion, length, length); + gokzVersion[length] = '\0'; + + // Map name + file.ReadInt8(length); + char[] mapName = new char[length + 1]; + file.ReadString(mapName, length, length); + mapName[length] = '\0'; + if (!StrEqual(mapName, gC_CurrentMap)) + { + GOKZ_PrintToChat(client, true, "%t", "Replay Menu - Wrong Map", mapName); + delete file; + return false; + } + + // Map filesize + int mapFileSize; + file.ReadInt32(mapFileSize); + + // Server IP + int serverIP; + file.ReadInt32(serverIP); + + // Timestamp + int timestamp; + file.ReadInt32(timestamp); + + // Player Alias + file.ReadInt8(length); + file.ReadString(botAlias[bot], sizeof(botAlias[]), length); + botAlias[bot][length] = '\0'; + + // Player Steam ID + int steamID; + file.ReadInt32(steamID); + + // Mode + file.ReadInt8(botMode[bot]); + + // Style + file.ReadInt8(botStyle[bot]); + + // Player Sensitivity + int intPlayerSensitivity; + file.ReadInt32(intPlayerSensitivity); + float playerSensitivity = view_as<float>(intPlayerSensitivity); + + // Player MYAW + int intPlayerMYaw; + file.ReadInt32(intPlayerMYaw); + float playerMYaw = view_as<float>(intPlayerMYaw); + + // Tickrate + int tickrateAsInt; + file.ReadInt32(tickrateAsInt); + float tickrate = view_as<float>(tickrateAsInt); + if (tickrate != RoundToZero(1 / GetTickInterval())) + { + GOKZ_PrintToChat(client, true, "%t", "Replay Menu - Wrong Tickrate", tickrate, (RoundToZero(1 / GetTickInterval()))); + delete file; + return false; + } + + // Tick Count + int tickCount; + file.ReadInt32(tickCount); + + // The replay has no replay data, this shouldn't happen normally, + // but this would cause issues in other code, so we don't even try to load this. + if (tickCount == 0) + { + delete file; + return false; + } + + // Equipped Weapon + file.ReadInt32(botWeapon[bot]); + + // Equipped Knife + file.ReadInt32(botKnife[bot]); + + // Big spit to console + PrintToConsole(client, "Replay Type: %d\nGOKZ Version: %s\nMap Name: %s\nMap Filesize: %d\nServer IP: %d\nTimestamp: %d\nPlayer Alias: %s\nPlayer Steam ID: %d\nMode: %d\nStyle: %d\nPlayer Sensitivity: %f\nPlayer m_yaw: %f\nTickrate: %f\nTick Count: %d\nWeapon: %d\nKnife: %d", replayType, gokzVersion, mapName, mapFileSize, serverIP, timestamp, botAlias[bot], steamID, botMode[bot], botStyle[bot], playerSensitivity, playerMYaw, tickrate, tickCount, botWeapon[bot], botKnife[bot]); + + switch(replayType) + { + case ReplayType_Run: + { + // Time + int timeAsInt; + file.ReadInt32(timeAsInt); + botTime[bot] = view_as<float>(timeAsInt); + botTimeTicks[bot] = RoundToNearest(botTime[bot] * tickrate); + + // Course + file.ReadInt8(botCourse[bot]); + + // Teleports Used + file.ReadInt32(botTeleportsUsed[bot]); + + // Type + botReplayType[bot] = ReplayType_Run; + + // Finish spit to console + PrintToConsole(client, "Time: %f\nCourse: %d\nTeleports Used: %d", botTime[bot], botCourse[bot], botTeleportsUsed[bot]); + } + case ReplayType_Cheater: + { + // Reason + int reason; + file.ReadInt8(reason); + + // Type + botReplayType[bot] = ReplayType_Cheater; + + // Finish spit to console + PrintToConsole(client, "AC Reason: %s", gC_ACReasons[reason]); + } + case ReplayType_Jump: + { + // Jump Type + file.ReadInt8(botJumpType[bot]); + + // Distance + file.ReadInt32(view_as<int>(botJumpDistance[bot])); + + // Block Distance + file.ReadInt32(botJumpBlockDistance[bot]); + + // Strafe Count + int strafeCount; + file.ReadInt8(strafeCount); + + // Sync + float sync; + file.ReadInt32(view_as<int>(sync)); + + // Pre + float pre; + file.ReadInt32(view_as<int>(pre)); + + // Max + float max; + file.ReadInt32(view_as<int>(max)); + + // Airtime + int airtime; + file.ReadInt32(airtime); + + // Type + botReplayType[bot] = ReplayType_Jump; + + // Finish spit to console + PrintToConsole(client, "Jump Type: %s\nJump Distance: %f\nBlock Distance: %d\nStrafe Count: %d\nSync: %f\n Pre: %f\nMax: %f\nAirtime: %d", + gC_JumpTypes[botJumpType[bot]], botJumpDistance[bot], botJumpBlockDistance[bot], strafeCount, sync, pre, max, airtime); + } + } + + // Tick Data + // Setup playback tick data array list + if (playbackTickData[bot] == null) + { + playbackTickData[bot] = new ArrayList(IntMax(RP_V1_TICK_DATA_BLOCKSIZE, sizeof(ReplayTickData))); + } + else + { + playbackTickData[bot].Clear(); + } + + // Read tick data + preAndPostRunTickCount = RoundToZero(RP_PLAYBACK_BREATHER_TIME / GetTickInterval()); + any tickDataArray[RP_V2_TICK_DATA_BLOCKSIZE]; + for (int i = 0; i < tickCount; i++) + { + file.ReadInt32(tickDataArray[RPDELTA_DELTAFLAGS]); + + for (int index = 1; index < sizeof(tickDataArray); index++) + { + int currentFlag = (1 << index); + if (tickDataArray[RPDELTA_DELTAFLAGS] & currentFlag) + { + file.ReadInt32(tickDataArray[index]); + } + } + + ReplayTickData tickData; + TickDataFromArray(tickDataArray, tickData); + // HACK: Jump replays don't record proper length sometimes. I don't know why. + // This leads to oversized replays full of 0s at the end. + // So, we do this horrible check to dodge that issue. + if (tickData.origin[0] == 0 && tickData.origin[1] == 0 && tickData.origin[2] == 0 && tickData.angles[0] == 0 && tickData.angles[1] == 0) + { + break; + } + playbackTickData[bot].PushArray(tickData); + } + + playbackTick[bot] = 0; + botDataLoaded[bot] = true; + + delete file; + + return true; +} + +static void PlaybackVersion1(int client, int bot, int &buttons) +{ + int size = playbackTickData[bot].Length; + float repOrigin[3], repAngles[3]; + int repButtons, repFlags; + + // If first or last frame of the playback + if (playbackTick[bot] == 0 || playbackTick[bot] == (size - 1)) + { + // Move the bot and pause them at that tick + repOrigin[0] = playbackTickData[bot].Get(playbackTick[bot], 0); + repOrigin[1] = playbackTickData[bot].Get(playbackTick[bot], 1); + repOrigin[2] = playbackTickData[bot].Get(playbackTick[bot], 2); + repAngles[0] = playbackTickData[bot].Get(playbackTick[bot], 3); + repAngles[1] = playbackTickData[bot].Get(playbackTick[bot], 4); + TeleportEntity(client, repOrigin, repAngles, view_as<float>( { 0.0, 0.0, 0.0 } )); + + if (!inBreather[bot]) + { + // Start the breather period + inBreather[bot] = true; + breatherStartTime[bot] = GetEngineTime(); + if (playbackTick[bot] == (size - 1)) + { + GOKZ_EmitSoundToClientSpectators(client, gC_ModeEndSounds[GOKZ_GetCoreOption(client, Option_Mode)], _, "Timer End"); + } + } + else if (GetEngineTime() > breatherStartTime[bot] + RP_PLAYBACK_BREATHER_TIME) + { + // End the breather period + inBreather[bot] = false; + botPlaybackPaused[bot] = false; + if (playbackTick[bot] == 0) + { + GOKZ_EmitSoundToClientSpectators(client, gC_ModeStartSounds[GOKZ_GetCoreOption(client, Option_Mode)], _, "Timer Start"); + } + // Start the bot if first tick. Clear bot if last tick. + playbackTick[bot]++; + if (playbackTick[bot] == size) + { + playbackTickData[bot].Clear(); // Clear it all out + botDataLoaded[bot] = false; + CancelReplayControlsForBot(bot); + ServerCommand("bot_kick %s", botName[bot]); + } + } + } + else + { + // Check whether somebody is actually spectating the bot + int spec; + for (spec = 1; spec < MAXPLAYERS + 1; spec++) + { + if (IsValidClient(spec) && GetObserverTarget(spec) == botClient[bot]) + { + break; + } + } + if (spec == MAXPLAYERS + 1 && !IsReplayBotControlled(bot, botClient[bot])) + { + playbackTickData[bot].Clear(); + botDataLoaded[bot] = false; + CancelReplayControlsForBot(bot); + ServerCommand("bot_kick %s", botName[bot]); + return; + } + + // Load in the next tick + repOrigin[0] = playbackTickData[bot].Get(playbackTick[bot], 0); + repOrigin[1] = playbackTickData[bot].Get(playbackTick[bot], 1); + repOrigin[2] = playbackTickData[bot].Get(playbackTick[bot], 2); + repAngles[0] = playbackTickData[bot].Get(playbackTick[bot], 3); + repAngles[1] = playbackTickData[bot].Get(playbackTick[bot], 4); + repButtons = playbackTickData[bot].Get(playbackTick[bot], 5); + repFlags = playbackTickData[bot].Get(playbackTick[bot], 6); + + // Check if the replay is paused + if (botPlaybackPaused[bot]) + { + TeleportEntity(client, repOrigin, repAngles, view_as<float>( { 0.0, 0.0, 0.0 } )); + return; + } + + // Set velocity to travel from current origin to recorded origin + float currentOrigin[3], velocity[3]; + Movement_GetOrigin(client, currentOrigin); + MakeVectorFromPoints(currentOrigin, repOrigin, velocity); + ScaleVector(velocity, 128.0); // Hard-coded 128 tickrate + TeleportEntity(client, NULL_VECTOR, repAngles, velocity); + + // We need the velocity directly from the replay to calculate the speeds + // for the HUD. + MakeVectorFromPoints(botLastOrigin[bot], repOrigin, velocity); + ScaleVector(velocity, 128.0); // Hard-coded 128 tickrate + CopyVector(repOrigin, botLastOrigin[bot]); + + botSpeed[bot] = GetVectorHorizontalLength(velocity); + buttons = repButtons; + botButtons[bot] = repButtons; + + // Should the bot be ducking?! + if (repButtons & IN_DUCK || repFlags & FL_DUCKING) + { + buttons |= IN_DUCK; + } + + // If the replay file says the bot's on the ground, then fine! Unless you're going too fast... + // Note that we don't mind if replay file says bot isn't on ground but the bot is. + if (repFlags & FL_ONGROUND && Movement_GetSpeed(client) < SPEED_NORMAL * 2) + { + if (timeInAir[bot] > 0) + { + botLandingSpeed[bot] = botSpeed[bot]; + timeInAir[bot] = 0; + botIsTakeoff[bot] = false; + botJumped[bot] = false; + hitBhop[bot] = false; + hitPerf[bot] = false; + if (!Movement_GetOnGround(client)) + { + timeOnGround[bot] = 0; + } + } + + SetEntityFlags(client, GetEntityFlags(client) | FL_ONGROUND); + Movement_SetMovetype(client, MOVETYPE_WALK); + + timeOnGround[bot]++; + botTakeoffSpeed[bot] = botSpeed[bot]; + } + else + { + if (timeInAir[bot] == 0) + { + botIsTakeoff[bot] = true; + botJumped[bot] = botButtons[bot] & IN_JUMP > 0; + hitBhop[bot] = (timeOnGround[bot] <= RP_MAX_BHOP_GROUND_TICKS) && botJumped[bot]; + + if (botMode[bot] == Mode_SimpleKZ) + { + hitPerf[bot] = timeOnGround[bot] < 3 && botJumped[bot]; + } + else + { + hitPerf[bot] = timeOnGround[bot] < 2 && botJumped[bot]; + } + + if (hitPerf[bot]) + { + if (botMode[bot] == Mode_SimpleKZ) + { + botTakeoffSpeed[bot] = FloatMin(botLandingSpeed[bot], (0.2 * botLandingSpeed[bot] + 200)); + } + else if (botMode[bot] == Mode_KZTimer) + { + botTakeoffSpeed[bot] = FloatMin(botLandingSpeed[bot], 380.0); + } + else + { + botTakeoffSpeed[bot] = FloatMin(botLandingSpeed[bot], 286.0); + } + } + } + else + { + botJumped[bot] = false; + botIsTakeoff[bot] = false; + } + + timeInAir[bot]++; + Movement_SetMovetype(client, MOVETYPE_NOCLIP); + } + + playbackTick[bot]++; + } +} +void PlaybackVersion2(int client, int bot, int &buttons, float vel[3], float angles[3]) +{ + int size = playbackTickData[bot].Length; + ReplayTickData prevTickData; + ReplayTickData currentTickData; + + // If first or last frame of the playback + if (playbackTick[bot] == 0 || playbackTick[bot] == (size - 1)) + { + // Move the bot and pause them at that tick + playbackTickData[bot].GetArray(playbackTick[bot], currentTickData); + playbackTickData[bot].GetArray(IntMax(playbackTick[bot] - 1, 0), prevTickData); + TeleportEntity(client, currentTickData.origin, currentTickData.angles, view_as<float>( { 0.0, 0.0, 0.0 } )); + + if (!inBreather[bot]) + { + // Start the breather period + inBreather[bot] = true; + breatherStartTime[bot] = GetEngineTime(); + } + else if (GetEngineTime() > breatherStartTime[bot] + RP_PLAYBACK_BREATHER_TIME) + { + // End the breather period + inBreather[bot] = false; + botPlaybackPaused[bot] = false; + + // Start the bot if first tick. Clear bot if last tick. + playbackTick[bot]++; + if (playbackTick[bot] == size) + { + playbackTickData[bot].Clear(); // Clear it all out + botDataLoaded[bot] = false; + CancelReplayControlsForBot(bot); + ServerCommand("bot_kick %s", botName[bot]); + } + } + } + else + { + // Check whether somebody is actually spectating the bot + int spec; + for (spec = 1; spec < MAXPLAYERS + 1; spec++) + { + if (IsValidClient(spec) && GetObserverTarget(spec) == botClient[bot]) + { + break; + } + } + if (spec == MAXPLAYERS + 1 && !IsReplayBotControlled(bot, botClient[bot])) + { + playbackTickData[bot].Clear(); + botDataLoaded[bot] = false; + CancelReplayControlsForBot(bot); + ServerCommand("bot_kick %s", botName[bot]); + return; + } + + // Load in the next tick + playbackTickData[bot].GetArray(playbackTick[bot], currentTickData); + playbackTickData[bot].GetArray(IntMax(playbackTick[bot] - 1, 0), prevTickData); + + // Check if the replay is paused + if (botPlaybackPaused[bot]) + { + TeleportEntity(client, currentTickData.origin, currentTickData.angles, view_as<float>( { 0.0, 0.0, 0.0 } )); + return; + } + + // Play timer start/end sound, if necessary. Reset teleports + if (playbackTick[bot] == preAndPostRunTickCount && botReplayType[bot] == ReplayType_Run) + { + GOKZ_EmitSoundToClientSpectators(client, gC_ModeStartSounds[GOKZ_GetCoreOption(client, Option_Mode)], _, "Timer Start"); + botCurrentTeleport[bot] = 0; + } + if (playbackTick[bot] == botTimeTicks[bot] + preAndPostRunTickCount && botReplayType[bot] == ReplayType_Run) + { + GOKZ_EmitSoundToClientSpectators(client, gC_ModeEndSounds[GOKZ_GetCoreOption(client, Option_Mode)], _, "Timer End"); + } + // We use the previous position/velocity data to recreate sounds accurately. + // This might not be necessary as we already did do this in OnPlayerRunCmdPost of last tick, + // but we do it again just in case the values don't match up somehow (eg. collision with moving objects?) + TeleportEntity(client, NULL_VECTOR, prevTickData.angles, prevTickData.velocity); + // TeleportEntity does not set the absolute origin and velocity so we need to do it + // to prevent inaccurate eye position interpolation. + SetEntPropVector(client, Prop_Data, "m_vecVelocity", prevTickData.velocity); + SetEntPropVector(client, Prop_Data, "m_vecAbsVelocity", prevTickData.velocity); + + SetEntPropVector(client, Prop_Data, "m_vecAbsOrigin", prevTickData.origin); + SetEntPropVector(client, Prop_Data, "m_vecOrigin", prevTickData.origin); + + + // Set buttons and potential inputs. + int newButtons; + if (currentTickData.flags & RP_IN_ATTACK) + { + newButtons |= IN_ATTACK; + } + if (currentTickData.flags & RP_IN_ATTACK2) + { + newButtons |= IN_ATTACK2; + } + if (currentTickData.flags & RP_IN_JUMP) + { + newButtons |= IN_JUMP; + } + if (currentTickData.flags & RP_IN_DUCK || currentTickData.flags & RP_FL_DUCKING) + { + newButtons |= IN_DUCK; + } + // Few assumptions here because the replay doesn't track them: Player doesn't use +klook or +strafe. + // If the assumptions are wrong we will just end up with wrong sound prediction, no big deal. + if (currentTickData.flags & RP_IN_FORWARD) + { + newButtons |= IN_FORWARD; + vel[0] += RP_PLAYER_ACCELSPEED; + } + if (currentTickData.flags & RP_IN_BACK) + { + newButtons |= IN_BACK; + vel[0] -= RP_PLAYER_ACCELSPEED; + } + if (currentTickData.flags & RP_IN_MOVELEFT) + { + newButtons |= IN_MOVELEFT; + vel[1] -= RP_PLAYER_ACCELSPEED; + } + if (currentTickData.flags & RP_IN_MOVERIGHT) + { + newButtons |= IN_MOVERIGHT; + vel[1] += RP_PLAYER_ACCELSPEED; + } + if (currentTickData.flags & RP_IN_LEFT) + { + newButtons |= IN_LEFT; + } + if (currentTickData.flags & RP_IN_RIGHT) + { + newButtons |= IN_RIGHT; + } + if (currentTickData.flags & RP_IN_RELOAD) + { + newButtons |= IN_RELOAD; + } + if (currentTickData.flags & RP_IN_SPEED) + { + newButtons |= IN_SPEED; + } + buttons = newButtons; + botButtons[bot] = buttons; + // The angles might be wrong if the player teleports, but this should only affect sound prediction. + angles = currentTickData.angles; + + // Set the bot's MoveType + MoveType replayMoveType = view_as<MoveType>(prevTickData.flags & RP_MOVETYPE_MASK); + botMoveType[bot] = replayMoveType; + if (replayMoveType == MOVETYPE_WALK) + { + Movement_SetMovetype(client, MOVETYPE_WALK); + } + else if (replayMoveType == MOVETYPE_LADDER) + { + botPaused[bot] = false; + Movement_SetMovetype(client, MOVETYPE_LADDER); + } + else + { + Movement_SetMovetype(client, MOVETYPE_NOCLIP); + } + // Set some variables + if (currentTickData.flags & RP_TELEPORT_TICK) + { + botJustTeleported[bot] = true; + botCurrentTeleport[bot]++; + } + + if (currentTickData.flags & RP_TAKEOFF_TICK) + { + hitPerf[bot] = currentTickData.flags & RP_HIT_PERF > 0; + botIsTakeoff[bot] = true; + botTakeoffSpeed[bot] = GetVectorHorizontalLength(currentTickData.velocity); + } + + if ((currentTickData.flags & RP_SECONDARY_EQUIPPED) && !IsCurrentWeaponSecondary(client)) + { + int item = GetPlayerWeaponSlot(client, CS_SLOT_SECONDARY); + if (item != -1) + { + char name[64]; + GetEntityClassname(item, name, sizeof(name)); + FakeClientCommand(client, "use %s", name); + } + } + else if (!(currentTickData.flags & RP_SECONDARY_EQUIPPED) && IsCurrentWeaponSecondary(client)) + { + int item = GetPlayerWeaponSlot(client, CS_SLOT_KNIFE); + if (item != -1) + { + char name[64]; + GetEntityClassname(item, name, sizeof(name)); + FakeClientCommand(client, "use %s", name); + } + } + + #if defined DEBUG + if(!botPlaybackPaused[bot]) + { + PrintToServer("Tick: %d", playbackTick[bot]); + PrintToServer("X %f \nY %f \nZ %f\nPitch %f\nYaw %f", currentTickData.origin[0], currentTickData.origin[1], currentTickData.origin[2], currentTickData.angles[0], currentTickData.angles[1]); + if(currentTickData.flags & RP_MOVETYPE_MASK == view_as<int>(MOVETYPE_WALK)) PrintToServer("MOVETYPE_WALK"); + if(currentTickData.flags & RP_MOVETYPE_MASK == view_as<int>(MOVETYPE_LADDER)) PrintToServer("MOVETYPE_LADDER"); + if(currentTickData.flags & RP_MOVETYPE_MASK == view_as<int>(MOVETYPE_NOCLIP)) PrintToServer("MOVETYPE_NOCLIP"); + if(currentTickData.flags & RP_MOVETYPE_MASK == view_as<int>(MOVETYPE_NOCLIP)) PrintToServer("MOVETYPE_NONE"); + + if(currentTickData.flags & RP_IN_ATTACK) PrintToServer("IN_ATTACK"); + if(currentTickData.flags & RP_IN_ATTACK2) PrintToServer("IN_ATTACK2"); + if(currentTickData.flags & RP_IN_JUMP) PrintToServer("IN_JUMP"); + if(currentTickData.flags & RP_IN_DUCK) PrintToServer("IN_DUCK"); + if(currentTickData.flags & RP_IN_FORWARD) PrintToServer("IN_FORWARD"); + if(currentTickData.flags & RP_IN_BACK) PrintToServer("IN_BACK"); + if(currentTickData.flags & RP_IN_LEFT) PrintToServer("IN_LEFT"); + if(currentTickData.flags & RP_IN_RIGHT) PrintToServer("IN_RIGHT"); + if(currentTickData.flags & RP_IN_MOVELEFT) PrintToServer("IN_MOVELEFT"); + if(currentTickData.flags & RP_IN_MOVERIGHT) PrintToServer("IN_MOVERIGHT"); + if(currentTickData.flags & RP_IN_RELOAD) PrintToServer("IN_RELOAD"); + if(currentTickData.flags & RP_IN_SPEED) PrintToServer("IN_SPEED"); + if(currentTickData.flags & RP_IN_USE) PrintToServer("IN_USE"); + if(currentTickData.flags & RP_IN_BULLRUSH) PrintToServer("IN_BULLRUSH"); + + if(currentTickData.flags & RP_FL_ONGROUND) PrintToServer("FL_ONGROUND"); + if(currentTickData.flags & RP_FL_DUCKING ) PrintToServer("FL_DUCKING"); + if(currentTickData.flags & RP_FL_SWIM) PrintToServer("FL_SWIM"); + if(currentTickData.flags & RP_UNDER_WATER) PrintToServer("WATERLEVEL!=0"); + if(currentTickData.flags & RP_TELEPORT_TICK) PrintToServer("TELEPORT"); + if(currentTickData.flags & RP_TAKEOFF_TICK) PrintToServer("TAKEOFF"); + if(currentTickData.flags & RP_HIT_PERF) PrintToServer("PERF"); + if(currentTickData.flags & RP_SECONDARY_EQUIPPED) PrintToServer("SECONDARY_WEAPON_EQUIPPED"); + PrintToServer("=============================================================="); + } + #endif + } +} + +void PlaybackVersion2Post(int client, int bot) +{ + if (botPlaybackPaused[bot]) + { + return; + } + int size = playbackTickData[bot].Length; + if (playbackTick[bot] != 0 && playbackTick[bot] != (size - 1)) + { + ReplayTickData currentTickData; + ReplayTickData prevTickData; + playbackTickData[bot].GetArray(playbackTick[bot], currentTickData); + playbackTickData[bot].GetArray(IntMax(playbackTick[bot] - 1, 0), prevTickData); + + // TeleportEntity does not set the absolute origin and velocity so we need to do it + // to prevent inaccurate eye position interpolation. + SetEntPropVector(client, Prop_Data, "m_vecVelocity", currentTickData.velocity); + SetEntPropVector(client, Prop_Data, "m_vecAbsVelocity", currentTickData.velocity); + + SetEntPropVector(client, Prop_Data, "m_vecAbsOrigin", currentTickData.origin); + SetEntPropVector(client, Prop_Data, "m_vecOrigin", currentTickData.origin); + + SetEntPropFloat(client, Prop_Send, "m_angEyeAngles[0]", currentTickData.angles[0]); + SetEntPropFloat(client, Prop_Send, "m_angEyeAngles[1]", currentTickData.angles[1]); + + MoveType replayMoveType = view_as<MoveType>(currentTickData.flags & RP_MOVETYPE_MASK); + botMoveType[bot] = replayMoveType; + int entityFlags = GetEntityFlags(client); + if (replayMoveType == MOVETYPE_WALK) + { + if (currentTickData.flags & RP_FL_ONGROUND) + { + SetEntityFlags(client, entityFlags | FL_ONGROUND); + botPaused[bot] = false; + // The bot is on the ground, so there must be a ground entity attributed to the bot. + int groundEnt = GetEntPropEnt(client, Prop_Send, "m_hGroundEntity"); + if (groundEnt == -1 && botJustTeleported[bot]) + { + SetEntPropFloat(client, Prop_Send, "m_flFallVelocity", 0.0); + float endPosition[3], mins[3], maxs[3]; + GetEntPropVector(client, Prop_Send, "m_vecMaxs", maxs); + GetEntPropVector(client, Prop_Send, "m_vecMins", mins); + endPosition = currentTickData.origin; + endPosition[2] -= 2.0; + TR_TraceHullFilter(currentTickData.origin, endPosition, mins, maxs, MASK_PLAYERSOLID, TraceEntityFilterPlayers); + + // This should always hit. + if (TR_DidHit()) + { + groundEnt = TR_GetEntityIndex(); + SetEntPropEnt(client, Prop_Data, "m_hGroundEntity", groundEnt); + } + } + } + else + { + botJustTeleported[bot] = false; + } + } + + if (currentTickData.flags & RP_UNDER_WATER) + { + SetEntityFlags(client, entityFlags | FL_INWATER); + } + + botSpeed[bot] = GetVectorHorizontalLength(currentTickData.velocity); + playbackTick[bot]++; + } +} + +// Set the bot client's GOKZ options, clan tag and name based on the loaded replay data +static void SetBotStuff(int bot) +{ + if (!botInGame[bot] || !botDataLoaded[bot]) + { + return; + } + + int client = botClient[bot]; + + // Set its movement options just in case it could negatively affect the playback + GOKZ_SetCoreOption(client, Option_Mode, botMode[bot]); + GOKZ_SetCoreOption(client, Option_Style, botStyle[bot]); + + // Clan tag and name + SetBotClanTag(bot); + SetBotName(bot); + + // Bot takes one tick after being put in server to be able to respawn. + RequestFrame(RequestFrame_SetBotStuff, GetClientUserId(client)); +} + +public void RequestFrame_SetBotStuff(int userid) +{ + int client = GetClientOfUserId(userid); + if (!client) + { + return; + } + int bot; + for (bot = 0; bot <= RP_MAX_BOTS; bot++) + { + if (botClient[bot] == client) + { + break; + } + else if (bot == RP_MAX_BOTS) + { + return; + } + } + // Set the bot's team based on if it's NUB or PRO + if (botReplayType[bot] == ReplayType_Run + && GOKZ_GetTimeTypeEx(botTeleportsUsed[bot]) == TimeType_Pro) + { + GOKZ_JoinTeam(client, CS_TEAM_CT, .forceBroadcast = true); + } + else + { + GOKZ_JoinTeam(client, CS_TEAM_CT, .forceBroadcast = true); + } + // Set bot weapons + // Always start by removing the pistol and knife + int currentPistol = GetPlayerWeaponSlot(client, CS_SLOT_SECONDARY); + if (currentPistol != -1) + { + RemovePlayerItem(client, currentPistol); + } + + int currentKnife = GetPlayerWeaponSlot(client, CS_SLOT_KNIFE); + if (currentKnife != -1) + { + RemovePlayerItem(client, currentKnife); + } + + char weaponName[128]; + // Give the bot the knife stored in the replay + /* + if (botKnife[bot] != 0) + { + CS_WeaponIDToAlias(CS_ItemDefIndexToID(botKnife[bot]), weaponName, sizeof(weaponName)); + Format(weaponName, sizeof(weaponName), "weapon_%s", weaponName); + GivePlayerItem(client, weaponName); + } + else + { + GivePlayerItem(client, "weapon_knife"); + } + */ + // We are currently not doing that, as it would require us to disable the + // FollowCSGOServerGuidelines failsafe if the bot has a non-standard knife. + GivePlayerItem(client, "weapon_knife"); + + // Give the bot the pistol stored in the replay + if (botWeapon[bot] != -1) + { + CS_WeaponIDToAlias(CS_ItemDefIndexToID(botWeapon[bot]), weaponName, sizeof(weaponName)); + Format(weaponName, sizeof(weaponName), "weapon_%s", weaponName); + GivePlayerItem(client, weaponName); + } + + botCurrentTeleport[bot] = 0; +} + +static void SetBotClanTag(int bot) +{ + char tag[MAX_NAME_LENGTH]; + + if (botReplayType[bot] == ReplayType_Run) + { + if (botCourse[bot] == 0) + { + // KZT PRO + FormatEx(tag, sizeof(tag), "%s %s", + gC_ModeNamesShort[botMode[bot]], gC_TimeTypeNames[GOKZ_GetTimeTypeEx(botTeleportsUsed[bot])]); + } + else + { + // KZT B2 PRO + FormatEx(tag, sizeof(tag), "%s B%d %s", + gC_ModeNamesShort[botMode[bot]], botCourse[bot], gC_TimeTypeNames[GOKZ_GetTimeTypeEx(botTeleportsUsed[bot])]); + } + } + else if (botReplayType[bot] == ReplayType_Jump) + { + // KZT LJ + FormatEx(tag, sizeof(tag), "%s %s", + gC_ModeNamesShort[botMode[bot]], gC_JumpTypesShort[botJumpType[bot]]); + } + else + { + // KZT + FormatEx(tag, sizeof(tag), "%s", + gC_ModeNamesShort[botMode[bot]]); + } + + CS_SetClientClanTag(botClient[bot], tag); +} + +static void SetBotName(int bot) +{ + char name[MAX_NAME_LENGTH]; + + if (botReplayType[bot] == ReplayType_Run) + { + // DanZay (01:23.45) + FormatEx(name, sizeof(name), "%s (%s)", + botAlias[bot], GOKZ_FormatTime(botTime[bot])); + } + else if (botReplayType[bot] == ReplayType_Jump) + { + if (botJumpBlockDistance[bot] == 0) + { + // DanZay (291.44) + FormatEx(name, sizeof(name), "%s (%.2f)", + botAlias[bot], botJumpDistance[bot]); + } + else + { + // DanZay (291.44 on 289 block) + FormatEx(name, sizeof(name), "%s (%.2f on %d block)", + botAlias[bot], botJumpDistance[bot], botJumpBlockDistance[bot]); + } + } + else + { + // DanZay + FormatEx(name, sizeof(name), "%s", + botAlias[bot]); + } + + gB_HideNameChange = true; + SetClientName(botClient[bot], name); +} + +// Returns the number of bots that are currently replaying +static int GetBotsInUse() +{ + int botsInUse = 0; + for (int bot; bot < RP_MAX_BOTS; bot++) + { + if (botInGame[bot] && botDataLoaded[bot]) + { + botsInUse++; + } + } + return botsInUse; +} + +// Returns a bot that isn't currently replaying, or -1 if no unused bots found +static int GetUnusedBot() +{ + for (int bot = 0; bot < RP_MAX_BOTS; bot++) + { + if (!botInGame[bot]) + { + return bot; + } + } + return -1; +} + +static void PlaybackSkipToTick(int bot, int tick) +{ + if (botReplayVersion[bot] == 1) + { + // Load in the next tick + float repOrigin[3], repAngles[3]; + repOrigin[0] = playbackTickData[bot].Get(tick, 0); + repOrigin[1] = playbackTickData[bot].Get(tick, 1); + repOrigin[2] = playbackTickData[bot].Get(tick, 2); + repAngles[0] = playbackTickData[bot].Get(tick, 3); + repAngles[1] = playbackTickData[bot].Get(tick, 4); + + TeleportEntity(botClient[bot], repOrigin, repAngles, view_as<float>( { 0.0, 0.0, 0.0 } )); + } + else if (botReplayVersion[bot] == 2) + { + // Load in the next tick + ReplayTickData currentTickData; + playbackTickData[bot].GetArray(tick, currentTickData); + + TeleportEntity(botClient[bot], currentTickData.origin, currentTickData.angles, view_as<float>( { 0.0, 0.0, 0.0 } )); + + int direction = tick < playbackTick[bot] ? -1 : 1; + for (int i = playbackTick[bot]; i != tick; i += direction) + { + playbackTickData[bot].GetArray(i, currentTickData); + if (currentTickData.flags & RP_TELEPORT_TICK) + { + botCurrentTeleport[bot] += direction; + } + } + + #if defined DEBUG + PrintToServer("X %f \nY %f \nZ %f\nPitch %f\nYaw %f", currentTickData.origin[0], currentTickData.origin[1], currentTickData.origin[2], currentTickData.angles[0], currentTickData.angles[1]); + if(currentTickData.flags & RP_MOVETYPE_MASK == view_as<int>(MOVETYPE_WALK)) PrintToServer("MOVETYPE_WALK"); + if(currentTickData.flags & RP_MOVETYPE_MASK == view_as<int>(MOVETYPE_LADDER)) PrintToServer("MOVETYPE_LADDER"); + if(currentTickData.flags & RP_MOVETYPE_MASK == view_as<int>(MOVETYPE_NOCLIP)) PrintToServer("MOVETYPE_NOCLIP"); + if(currentTickData.flags & RP_MOVETYPE_MASK == view_as<int>(MOVETYPE_NONE)) PrintToServer("MOVETYPE_NONE"); + + if(currentTickData.flags & RP_IN_ATTACK) PrintToServer("IN_ATTACK"); + if(currentTickData.flags & RP_IN_ATTACK2) PrintToServer("IN_ATTACK2"); + if(currentTickData.flags & RP_IN_JUMP) PrintToServer("IN_JUMP"); + if(currentTickData.flags & RP_IN_DUCK) PrintToServer("IN_DUCK"); + if(currentTickData.flags & RP_IN_FORWARD) PrintToServer("IN_FORWARD"); + if(currentTickData.flags & RP_IN_BACK) PrintToServer("IN_BACK"); + if(currentTickData.flags & RP_IN_LEFT) PrintToServer("IN_LEFT"); + if(currentTickData.flags & RP_IN_RIGHT) PrintToServer("IN_RIGHT"); + if(currentTickData.flags & RP_IN_MOVELEFT) PrintToServer("IN_MOVELEFT"); + if(currentTickData.flags & RP_IN_MOVERIGHT) PrintToServer("IN_MOVERIGHT"); + if(currentTickData.flags & RP_IN_RELOAD) PrintToServer("IN_RELOAD"); + if(currentTickData.flags & RP_IN_SPEED) PrintToServer("IN_SPEED"); + if(currentTickData.flags & RP_FL_ONGROUND) PrintToServer("FL_ONGROUND"); + if(currentTickData.flags & RP_FL_DUCKING ) PrintToServer("FL_DUCKING"); + if(currentTickData.flags & RP_FL_SWIM) PrintToServer("FL_SWIM"); + if(currentTickData.flags & RP_UNDER_WATER) PrintToServer("WATERLEVEL!=0"); + if(currentTickData.flags & RP_TELEPORT_TICK) PrintToServer("TELEPORT"); + if(currentTickData.flags & RP_TAKEOFF_TICK) PrintToServer("TAKEOFF"); + if(currentTickData.flags & RP_HIT_PERF) PrintToServer("PERF"); + if(currentTickData.flags & RP_SECONDARY_EQUIPPED) PrintToServer("SECONDARY_WEAPON_EQUIPPED"); + PrintToServer("=============================================================="); + #endif + } + + Movement_SetMovetype(botClient[bot], MOVETYPE_NOCLIP); + playbackTick[bot] = tick; +} + +static bool IsCurrentWeaponSecondary(int client) +{ + int activeWeaponEnt = GetEntPropEnt(client, Prop_Send, "m_hActiveWeapon"); + int secondaryEnt = GetPlayerWeaponSlot(client, CS_SLOT_SECONDARY); + return activeWeaponEnt == secondaryEnt; +} + +static void MakePlayerSpectate(int client, int bot) +{ + GOKZ_JoinTeam(client, CS_TEAM_SPECTATOR); + SetEntProp(client, Prop_Send, "m_iObserverMode", 4); + SetEntPropEnt(client, Prop_Send, "m_hObserverTarget", bot); + + int clientUserID = GetClientUserId(client); + DataPack data = new DataPack(); + data.WriteCell(clientUserID); + data.WriteCell(GetClientUserId(bot)); + CreateTimer(0.1, Timer_UpdateBotName, GetClientUserId(bot)); + EnableReplayControls(client); +} + +public Action Timer_UpdateBotName(Handle timer, int botUID) +{ + Event e = CreateEvent("spec_target_updated"); + e.SetInt("userid", botUID); + e.Fire(); + return Plugin_Continue; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-replays/recording.sp b/sourcemod/scripting/gokz-replays/recording.sp new file mode 100644 index 0000000..babbd5e --- /dev/null +++ b/sourcemod/scripting/gokz-replays/recording.sp @@ -0,0 +1,990 @@ +/* + Bot replay recording logic and processes. + + Records data every time OnPlayerRunCmdPost is called. + If the player doesn't have their timer running, it keeps track + of the last 2 minutes of their actions. If a player is banned + while their timer isn't running, those 2 minutes are saved. + If the player has their timer running, the recording is done from + the beginning of the run. If the player can no longer beat their PB, + then the recording goes back to only keeping track of the last + two minutes. Upon beating their PB, a temporary binary file will be + written with a 'header' containing information about the run, + followed by the recorded tick data from OnPlayerRunCmdPost. + The binary file will be permanently locally saved on the server + if the run beats the server record. +*/ + +static float tickrate; +static int preAndPostRunTickCount; +static int maxCheaterReplayTicks; +static int recordingIndex[MAXPLAYERS + 1]; +static float playerSensitivity[MAXPLAYERS + 1]; +static float playerMYaw[MAXPLAYERS + 1]; +static bool isTeleportTick[MAXPLAYERS + 1]; +static ReplaySaveState replaySaveState[MAXPLAYERS + 1]; +static bool recordingPaused[MAXPLAYERS + 1]; +static bool postRunRecording[MAXPLAYERS + 1]; +static ArrayList recordedRecentData[MAXPLAYERS + 1]; +static ArrayList recordedRunData[MAXPLAYERS + 1]; +static ArrayList recordedPostRunData[MAXPLAYERS + 1]; +static Handle runningRunBreatherTimer[MAXPLAYERS + 1]; +static ArrayList runningJumpstatTimers[MAXPLAYERS + 1]; + +// =====[ EVENTS ]===== + +void OnMapStart_Recording() +{ + CreateReplaysDirectory(gC_CurrentMap); + tickrate = 1/GetTickInterval(); + preAndPostRunTickCount = RoundToZero(RP_PLAYBACK_BREATHER_TIME * tickrate); + maxCheaterReplayTicks = RoundToCeil(RP_MAX_CHEATER_REPLAY_LENGTH * tickrate); +} + +void OnClientPutInServer_Recording(int client) +{ + ClearClientRecordingState(client); +} + +void OnClientAuthorized_Recording(int client) +{ + // Apparently the client isn't valid yet here, so we can't check for that! + if(!IsFakeClient(client)) + { + // Create directory path for player if not exists + char replayPath[PLATFORM_MAX_PATH]; + BuildPath(Path_SM, replayPath, sizeof(replayPath), "%s/%d", RP_DIRECTORY_JUMPS, GetSteamAccountID(client)); + if (!DirExists(replayPath)) + { + CreateDirectory(replayPath, 511); + } + BuildPath(Path_SM, replayPath, sizeof(replayPath), "%s/%d/%s", RP_DIRECTORY_JUMPS, GetSteamAccountID(client), RP_DIRECTORY_BLOCKJUMPS); + if (!DirExists(replayPath)) + { + CreateDirectory(replayPath, 511); + } + } +} + +void OnClientDisconnect_Recording(int client) +{ + // Stop exceptions if OnClientPutInServer was never ran for this client id. + // As long as the arrays aren't null we'll be fine. + if (runningJumpstatTimers[client] == null) + { + return; + } + + // Trigger all timers early + if(!IsFakeClient(client)) + { + if (runningRunBreatherTimer[client] != INVALID_HANDLE) + { + TriggerTimer(runningRunBreatherTimer[client], false); + } + + // We have to clone the array because the timer callback removes the timer + // from the array we're running over, and doing weird tricks is scary. + ArrayList timers = runningJumpstatTimers[client].Clone(); + for (int i = 0; i < timers.Length; i++) + { + Handle timer = timers.Get(i); + TriggerTimer(timer, false); + } + delete timers; + } + + ClearClientRecordingState(client); +} + +void OnPlayerRunCmdPost_Recording(int client, int buttons, int tickCount, const float vel[3], const int mouse[2]) +{ + if (!IsValidClient(client) || IsFakeClient(client) || !IsPlayerAlive(client) || recordingPaused[client]) + { + return; + } + + ReplayTickData tickData; + + Movement_GetOrigin(client, tickData.origin); + + tickData.mouse = mouse; + tickData.vel = vel; + Movement_GetVelocity(client, tickData.velocity); + Movement_GetEyeAngles(client, tickData.angles); + tickData.flags = EncodePlayerFlags(client, buttons, tickCount); + tickData.packetsPerSecond = GetClientAvgPackets(client, NetFlow_Incoming); + tickData.laggedMovementValue = GetEntPropFloat(client, Prop_Send, "m_flLaggedMovementValue"); + tickData.buttonsForced = GetEntProp(client, Prop_Data, "m_afButtonForced"); + + // HACK: Reset teleport tick marker. Too bad! + if (isTeleportTick[client]) + { + isTeleportTick[client] = false; + } + + if (replaySaveState[client] != ReplaySave_Disabled) + { + int runTick = GetArraySize(recordedRunData[client]); + if (runTick < RP_MAX_DURATION) + { + // Resize might fail if the timer exceed the max duration, + // as it is not guaranteed to allocate more than 1GB of contiguous memory, + // causing mass lag spikes that kick everyone out of the server. + // We can still attempt to save the rest of the recording though. + recordedRunData[client].Resize(runTick + 1); + recordedRunData[client].SetArray(runTick, tickData); + } + } + if (postRunRecording[client]) + { + int tick = GetArraySize(recordedPostRunData[client]); + if (tick < RP_MAX_DURATION) + { + recordedPostRunData[client].Resize(tick + 1); + recordedPostRunData[client].SetArray(tick, tickData); + } + } + + int tick = recordingIndex[client]; + if (recordedRecentData[client].Length < maxCheaterReplayTicks) + { + recordedRecentData[client].Resize(recordedRecentData[client].Length + 1); + recordingIndex[client] = recordingIndex[client] + 1 == maxCheaterReplayTicks ? 0 : recordingIndex[client] + 1; + } + else + { + recordingIndex[client] = RecordingIndexAdd(client, 1); + } + + recordedRecentData[client].SetArray(tick, tickData); +} + +Action GOKZ_OnTimerStart_Recording(int client) +{ + // Hack to fix an exception when starting the timer on the very + // first tick after loading the plugin. + if (recordedRecentData[client].Length == 0) + { + return Plugin_Handled; + } + + return Plugin_Continue; +} + +void GOKZ_OnTimerStart_Post_Recording(int client) +{ + replaySaveState[client] = ReplaySave_Local; + StartRunRecording(client); +} + +void GOKZ_OnTimerEnd_Recording(int client, int course, float time, int teleportsUsed) +{ + if (replaySaveState[client] == ReplaySave_Disabled) + { + return; + } + + DataPack data = new DataPack(); + data.WriteCell(GetClientUserId(client)); + data.WriteCell(course); + data.WriteFloat(time); + data.WriteCell(teleportsUsed); + data.WriteCell(replaySaveState[client]); + // The previous run breather still did not finish, end it now or + // we will start overwriting the data. + if (runningRunBreatherTimer[client] != INVALID_HANDLE) + { + TriggerTimer(runningRunBreatherTimer[client], false); + } + + replaySaveState[client] = ReplaySave_Disabled; + postRunRecording[client] = true; + + // Swap recordedRunData and recordedPostRunData. + // This lets new runs start immediately, before the post-run breather is + // finished recording. + ArrayList tmp = recordedPostRunData[client]; + recordedPostRunData[client] = recordedRunData[client]; + recordedRunData[client] = tmp; + recordedRunData[client].Clear(); + + runningRunBreatherTimer[client] = CreateTimer(RP_PLAYBACK_BREATHER_TIME, Timer_EndRecording, data); + if (runningRunBreatherTimer[client] == INVALID_HANDLE) + { + LogError("Could not create a timer so can't end the run replay recording"); + } +} + +public Action Timer_EndRecording(Handle timer, DataPack data) +{ + data.Reset(); + int client = GetClientOfUserId(data.ReadCell()); + int course = data.ReadCell(); + float time = data.ReadFloat(); + int teleportsUsed = data.ReadCell(); + ReplaySaveState saveState = data.ReadCell(); + delete data; + + // The client left after the run was done but before the post-run + // breather had the chance to finish. This should not happen, as we + // trigger all running timers on disconnect. + if (!IsValidClient(client)) + { + return Plugin_Stop; + } + + runningRunBreatherTimer[client] = INVALID_HANDLE; + postRunRecording[client] = false; + + if (gB_GOKZLocalDB && GOKZ_DB_IsCheater(client)) + { + // Replay might be submitted globally, but will not be saved locally. + saveState = ReplaySave_Temp; + } + + char path[PLATFORM_MAX_PATH]; + if (SaveRecordingOfRun(path, client, course, time, teleportsUsed, saveState == ReplaySave_Temp)) + { + Call_OnTimerEnd_Post(client, path, course, time, teleportsUsed); + } + else + { + Call_OnTimerEnd_Post(client, "", course, time, teleportsUsed); + } + + return Plugin_Stop; +} + +void GOKZ_OnPause_Recording(int client) +{ + PauseRecording(client); +} + +void GOKZ_OnResume_Recording(int client) +{ + ResumeRecording(client); +} + +void GOKZ_OnTimerStopped_Recording(int client) +{ + replaySaveState[client] = ReplaySave_Disabled; +} + +void GOKZ_OnCountedTeleport_Recording(int client) +{ + if (gB_NubRecordMissed[client]) + { + replaySaveState[client] = ReplaySave_Disabled; + } + + isTeleportTick[client] = true; +} + +void GOKZ_LR_OnRecordMissed_Recording(int client, int recordType) +{ + if (replaySaveState[client] == ReplaySave_Disabled) + { + return; + } + // If missed PRO record or both records, then can no longer beat a server record + if (recordType == RecordType_NubAndPro || recordType == RecordType_Pro) + { + replaySaveState[client] = ReplaySave_Temp; + } + + // If on a NUB run and missed NUB record, then can no longer beat a server record + // Otherwise wait to see if they teleport before stopping the recording + if (recordType == RecordType_Nub) + { + if (GOKZ_GetTeleportCount(client) > 0) + { + replaySaveState[client] = ReplaySave_Temp; + } + } +} + +public void GOKZ_LR_OnPBMissed(int client, float pbTime, int course, int mode, int style, int recordType) +{ + if (replaySaveState[client] == ReplaySave_Disabled) + { + return; + } + // If missed PRO record or both records, then can no longer beat PB + if (recordType == RecordType_NubAndPro || recordType == RecordType_Pro) + { + replaySaveState[client] = ReplaySave_Disabled; + } + + // If on a NUB run and missed NUB record, then can no longer beat PB + // Otherwise wait to see if they teleport before stopping the recording + if (recordType == RecordType_Nub) + { + if (GOKZ_GetTeleportCount(client) > 0) + { + replaySaveState[client] = ReplaySave_Disabled; + } + } +} + +void GOKZ_AC_OnPlayerSuspected_Recording(int client, ACReason reason) +{ + SaveRecordingOfCheater(client, reason); +} + +void GOKZ_DB_OnJumpstatPB_Recording(int client, int jumptype, float distance, int block, int strafes, float sync, float pre, float max, int airtime) +{ + DataPack data = new DataPack(); + data.WriteCell(GetClientUserId(client)); + data.WriteCell(jumptype); + data.WriteFloat(distance); + data.WriteCell(block); + data.WriteCell(strafes); + data.WriteFloat(sync); + data.WriteFloat(pre); + data.WriteFloat(max); + data.WriteCell(airtime); + + Handle timer = CreateTimer(RP_PLAYBACK_BREATHER_TIME, SaveJump, data); + if (timer != INVALID_HANDLE) + { + runningJumpstatTimers[client].Push(timer); + } + else + { + LogError("Could not create a timer so can't save jumpstat pb replay"); + } +} + +public Action SaveJump(Handle timer, DataPack data) +{ + data.Reset(); + int client = GetClientOfUserId(data.ReadCell()); + int jumptype = data.ReadCell(); + float distance = data.ReadFloat(); + int block = data.ReadCell(); + int strafes = data.ReadCell(); + float sync = data.ReadFloat(); + float pre = data.ReadFloat(); + float max = data.ReadFloat(); + int airtime = data.ReadCell(); + delete data; + + // The client left after the jump was done but before the post-jump + // breather had the chance to finish. This should not happen, as we + // trigger all running timers on disconnect. + if (!IsValidClient(client)) + { + return Plugin_Stop; + } + + RemoveFromRunningTimers(client, timer); + + SaveRecordingOfJump(client, jumptype, distance, block, strafes, sync, pre, max, airtime); + return Plugin_Stop; +} + + + +// =====[ PRIVATE ]===== + +static void ClearClientRecordingState(int client) +{ + recordingIndex[client] = 0; + playerSensitivity[client] = -1.0; + playerMYaw[client] = -1.0; + isTeleportTick[client] = false; + replaySaveState[client] = ReplaySave_Disabled; + recordingPaused[client] = false; + postRunRecording[client] = false; + runningRunBreatherTimer[client] = INVALID_HANDLE; + + if (recordedRecentData[client] == null) + recordedRecentData[client] = new ArrayList(sizeof(ReplayTickData)); + + if (recordedRunData[client] == null) + recordedRunData[client] = new ArrayList(sizeof(ReplayTickData)); + + if (recordedPostRunData[client] == null) + recordedPostRunData[client] = new ArrayList(sizeof(ReplayTickData)); + + if (runningJumpstatTimers[client] == null) + runningJumpstatTimers[client] = new ArrayList(); + + recordedRecentData[client].Clear(); + recordedRunData[client].Clear(); + recordedPostRunData[client].Clear(); + runningJumpstatTimers[client].Clear(); +} + +static void StartRunRecording(int client) +{ + if (IsFakeClient(client)) + { + return; + } + + QueryClientConVar(client, "sensitivity", SensitivityCheck, client); + QueryClientConVar(client, "m_yaw", MYAWCheck, client); + + DiscardRecording(client); + ResumeRecording(client); + + // Copy pre data + int index; + recordedRunData[client].Resize(preAndPostRunTickCount); + if (recordedRecentData[client].Length < preAndPostRunTickCount) + { + index = recordingIndex[client] - preAndPostRunTickCount; + } + else + { + index = RecordingIndexAdd(client, -preAndPostRunTickCount); + } + for (int i = 0; i < preAndPostRunTickCount; i++) + { + ReplayTickData tickData; + if (index < 0) + { + recordedRecentData[client].GetArray(0, tickData); + recordedRunData[client].SetArray(i, tickData); + index += 1; + } + else + { + recordedRecentData[client].GetArray(index, tickData); + recordedRunData[client].SetArray(i, tickData); + index = RecordingIndexAdd(client, -preAndPostRunTickCount + i + 1); + } + } +} + +static void DiscardRecording(int client) +{ + recordedRunData[client].Clear(); + Call_OnReplayDiscarded(client); +} + +static void PauseRecording(int client) +{ + recordingPaused[client] = true; +} + +static void ResumeRecording(int client) +{ + recordingPaused[client] = false; +} + +static bool SaveRecordingOfRun(char replayPath[PLATFORM_MAX_PATH], int client, int course, float time, int teleportsUsed, bool temp) +{ + // Prepare data + int timeType = GOKZ_GetTimeTypeEx(teleportsUsed); + + // Create and fill General Header + GeneralReplayHeader generalHeader; + FillGeneralHeader(generalHeader, client, ReplayType_Run, recordedPostRunData[client].Length); + + // Create and fill Run Header + RunReplayHeader runHeader; + runHeader.time = time; + runHeader.course = course; + runHeader.teleportsUsed = teleportsUsed; + + // Build path and create/overwrite associated file + FormatRunReplayPath(replayPath, sizeof(replayPath), course, generalHeader.mode, generalHeader.style, timeType, temp); + if (FileExists(replayPath)) + { + DeleteFile(replayPath); + } + else if (!temp) + { + AddToReplayInfoCache(course, generalHeader.mode, generalHeader.style, timeType); + SortReplayInfoCache(); + } + + File file = OpenFile(replayPath, "wb"); + if (file == null) + { + LogError("Failed to create/open replay file to write to: \"%s\".", replayPath); + return false; + } + + WriteGeneralHeader(file, generalHeader); + + // Write run header + file.WriteInt32(view_as<int>(runHeader.time)); + file.WriteInt8(runHeader.course); + file.WriteInt32(runHeader.teleportsUsed); + + WriteTickData(file, client, ReplayType_Run); + + delete file; + // If there is no plugin that wants to take over the replay file, we will delete it ourselves. + if (Call_OnReplaySaved(client, ReplayType_Run, gC_CurrentMap, course, timeType, time, replayPath, temp) == Plugin_Continue && temp) + { + DeleteFile(replayPath); + } + + return true; +} + +static bool SaveRecordingOfCheater(int client, ACReason reason) +{ + // Create and fill general header + GeneralReplayHeader generalHeader; + FillGeneralHeader(generalHeader, client, ReplayType_Cheater, recordedRecentData[client].Length); + + // Create and fill cheater header + CheaterReplayHeader cheaterHeader; + cheaterHeader.ACReason = reason; + + //Build path and create/overwrite associated file + char replayPath[PLATFORM_MAX_PATH]; + FormatCheaterReplayPath(replayPath, sizeof(replayPath), client, generalHeader.mode, generalHeader.style); + + File file = OpenFile(replayPath, "wb"); + if (file == null) + { + LogError("Failed to create/open replay file to write to: \"%s\".", replayPath); + return false; + } + + WriteGeneralHeader(file, generalHeader); + file.WriteInt8(view_as<int>(cheaterHeader.ACReason)); + WriteTickData(file, client, ReplayType_Cheater); + + delete file; + + return true; +} + +static bool SaveRecordingOfJump(int client, int jumptype, float distance, int block, int strafes, float sync, float pre, float max, int airtime) +{ + // Just cause I know how buggy jumpstats can be + int airtimeTicks = RoundToNearest((float(airtime) / GOKZ_DB_JS_AIRTIME_PRECISION) * tickrate); + if (airtimeTicks + 2 * preAndPostRunTickCount >= maxCheaterReplayTicks) + { + LogError("WARNING: Invalid airtime (this is probably a bugged jump, please report it!)."); + return false; + } + + // Create and fill general header + GeneralReplayHeader generalHeader; + FillGeneralHeader(generalHeader, client, ReplayType_Jump, 2 * preAndPostRunTickCount + airtimeTicks); + + // Create and fill jump header + JumpReplayHeader jumpHeader; + FillJumpHeader(jumpHeader, jumptype, distance, block, strafes, sync, pre, max, airtime); + + // Make sure the client is authenticated + if (GetSteamAccountID(client) == 0) + { + LogError("Failed to save jump, client is not authenticated."); + return false; + } + + // Build path and create/overwrite associated file + char replayPath[PLATFORM_MAX_PATH]; + if (block > 0) + { + FormatBlockJumpReplayPath(replayPath, sizeof(replayPath), client, block, jumpHeader.jumpType, generalHeader.mode, generalHeader.style); + } + else + { + FormatJumpReplayPath(replayPath, sizeof(replayPath), client, jumpHeader.jumpType, generalHeader.mode, generalHeader.style); + } + + File file = OpenFile(replayPath, "wb"); + if (file == null) + { + LogError("Failed to create/open replay file to write to: \"%s\".", replayPath); + delete file; + return false; + } + + WriteGeneralHeader(file, generalHeader); + WriteJumpHeader(file, jumpHeader); + WriteTickData(file, client, ReplayType_Jump, airtimeTicks); + + delete file; + + return true; +} + +static void FillGeneralHeader(GeneralReplayHeader generalHeader, int client, int replayType, int tickCount) +{ + // Prepare data + int mode = GOKZ_GetCoreOption(client, Option_Mode); + int style = GOKZ_GetCoreOption(client, Option_Style); + + // Fill general header + generalHeader.magicNumber = RP_MAGIC_NUMBER; + generalHeader.formatVersion = RP_FORMAT_VERSION; + generalHeader.replayType = replayType; + generalHeader.gokzVersion = GOKZ_VERSION; + generalHeader.mapName = gC_CurrentMap; + generalHeader.mapFileSize = gI_CurrentMapFileSize; + generalHeader.serverIP = FindConVar("hostip").IntValue; + generalHeader.timestamp = GetTime(); + GetClientName(client, generalHeader.playerAlias, sizeof(GeneralReplayHeader::playerAlias)); + generalHeader.playerSteamID = GetSteamAccountID(client); + generalHeader.mode = mode; + generalHeader.style = style; + generalHeader.playerSensitivity = playerSensitivity[client]; + generalHeader.playerMYaw = playerMYaw[client]; + generalHeader.tickrate = tickrate; + generalHeader.tickCount = tickCount; + generalHeader.equippedWeapon = GetPlayerWeaponSlotDefIndex(client, CS_SLOT_SECONDARY); + generalHeader.equippedKnife = GetPlayerWeaponSlotDefIndex(client, CS_SLOT_KNIFE); +} + +static void FillJumpHeader(JumpReplayHeader jumpHeader, int jumptype, float distance, int block, int strafes, float sync, float pre, float max, int airtime) +{ + jumpHeader.jumpType = jumptype; + jumpHeader.distance = distance; + jumpHeader.blockDistance = block; + jumpHeader.strafeCount = strafes; + jumpHeader.sync = sync; + jumpHeader.pre = pre; + jumpHeader.max = max; + jumpHeader.airtime = airtime; +} + +static void WriteGeneralHeader(File file, GeneralReplayHeader generalHeader) +{ + file.WriteInt32(generalHeader.magicNumber); + file.WriteInt8(generalHeader.formatVersion); + file.WriteInt8(generalHeader.replayType); + file.WriteInt8(strlen(generalHeader.gokzVersion)); + file.WriteString(generalHeader.gokzVersion, false); + file.WriteInt8(strlen(generalHeader.mapName)); + file.WriteString(generalHeader.mapName, false); + file.WriteInt32(generalHeader.mapFileSize); + file.WriteInt32(generalHeader.serverIP); + file.WriteInt32(generalHeader.timestamp); + file.WriteInt8(strlen(generalHeader.playerAlias)); + file.WriteString(generalHeader.playerAlias, false); + file.WriteInt32(generalHeader.playerSteamID); + file.WriteInt8(generalHeader.mode); + file.WriteInt8(generalHeader.style); + file.WriteInt32(view_as<int>(generalHeader.playerSensitivity)); + file.WriteInt32(view_as<int>(generalHeader.playerMYaw)); + file.WriteInt32(view_as<int>(generalHeader.tickrate)); + file.WriteInt32(generalHeader.tickCount); + file.WriteInt32(generalHeader.equippedWeapon); + file.WriteInt32(generalHeader.equippedKnife); +} + +static void WriteJumpHeader(File file, JumpReplayHeader jumpHeader) +{ + file.WriteInt8(jumpHeader.jumpType); + file.WriteInt32(view_as<int>(jumpHeader.distance)); + file.WriteInt32(jumpHeader.blockDistance); + file.WriteInt8(jumpHeader.strafeCount); + file.WriteInt32(view_as<int>(jumpHeader.sync)); + file.WriteInt32(view_as<int>(jumpHeader.pre)); + file.WriteInt32(view_as<int>(jumpHeader.max)); + file.WriteInt32((jumpHeader.airtime)); +} + +static void WriteTickData(File file, int client, int replayType, int airtime = 0) +{ + ReplayTickData tickData; + ReplayTickData prevTickData; + bool isFirstTick = true; + switch(replayType) + { + case ReplayType_Run: + { + for (int i = 0; i < recordedPostRunData[client].Length; i++) + { + recordedPostRunData[client].GetArray(i, tickData); + recordedPostRunData[client].GetArray(IntMax(0, i-1), prevTickData); + WriteTickDataToFile(file, isFirstTick, tickData, prevTickData); + isFirstTick = false; + } + } + case ReplayType_Cheater: + { + for (int i = 0; i < recordedRecentData[client].Length; i++) + { + int rollingI = RecordingIndexAdd(client, i); + recordedRecentData[client].GetArray(rollingI, tickData); + recordedRecentData[client].GetArray(IntMax(0, i-1), prevTickData); + WriteTickDataToFile(file, isFirstTick, tickData, prevTickData); + isFirstTick = false; + } + + } + case ReplayType_Jump: + { + int replayLength = 2 * preAndPostRunTickCount + airtime; + for (int i = 0; i < replayLength; i++) + { + int rollingI = RecordingIndexAdd(client, i - replayLength); + recordedRecentData[client].GetArray(rollingI, tickData); + recordedRecentData[client].GetArray(IntMax(0, i-1), prevTickData); + WriteTickDataToFile(file, isFirstTick, tickData, prevTickData); + isFirstTick = false; + } + } + } +} + +static void WriteTickDataToFile(File file, bool isFirstTick, ReplayTickData tickDataStruct, ReplayTickData prevTickDataStruct) +{ + any tickData[RP_V2_TICK_DATA_BLOCKSIZE]; + any prevTickData[RP_V2_TICK_DATA_BLOCKSIZE]; + TickDataToArray(tickDataStruct, tickData); + TickDataToArray(prevTickDataStruct, prevTickData); + + int deltaFlags = (1 << RPDELTA_DELTAFLAGS); + if (isFirstTick) + { + // NOTE: Set every bit to 1 until RP_V2_TICK_DATA_BLOCKSIZE. + deltaFlags = (1 << (RP_V2_TICK_DATA_BLOCKSIZE)) - 1; + } + else + { + // NOTE: Test tickData against prevTickData for differences. + for (int i = 1; i < sizeof(tickData); i++) + { + // If the bits in tickData[i] are different to prevTickData[i], then + // set the corresponding bitflag. + if (tickData[i] ^ prevTickData[i]) + { + deltaFlags |= (1 << i); + } + } + } + + file.WriteInt32(deltaFlags); + // NOTE: write only data that has changed since the previous tick. + for (int i = 1; i < sizeof(tickData); i++) + { + int currentFlag = (1 << i); + if (deltaFlags & currentFlag) + { + file.WriteInt32(tickData[i]); + } + } +} + +static void FormatRunReplayPath(char[] buffer, int maxlength, int course, int mode, int style, int timeType, bool tempPath) +{ + // Use GetEngineTime to prevent accidental replay overrides. + // Technically it would still be possible to override this file by accident, + // if somehow the server restarts to this exact map and course, + // and this function is run at the exact same time, but that is extremely unlikely. + // Also by then this file should have already been deleted. + char tempTimeString[32]; + Format(tempTimeString, sizeof(tempTimeString), "%f_", GetEngineTime()); + BuildPath(Path_SM, buffer, maxlength, + "%s/%s/%s%d_%s_%s_%s.%s", + tempPath ? RP_DIRECTORY_RUNS_TEMP : RP_DIRECTORY_RUNS, + gC_CurrentMap, + tempPath ? tempTimeString : "", + course, + gC_ModeNamesShort[mode], + gC_StyleNamesShort[style], + gC_TimeTypeNames[timeType], + RP_FILE_EXTENSION); +} + +static void FormatCheaterReplayPath(char[] buffer, int maxlength, int client, int mode, int style) +{ + BuildPath(Path_SM, buffer, maxlength, + "%s/%d_%s_%d_%s_%s.%s", + RP_DIRECTORY_CHEATERS, + GetSteamAccountID(client), + gC_CurrentMap, + GetTime(), + gC_ModeNamesShort[mode], + gC_StyleNamesShort[style], + RP_FILE_EXTENSION); +} + +static void FormatJumpReplayPath(char[] buffer, int maxlength, int client, int jumpType, int mode, int style) +{ + BuildPath(Path_SM, buffer, maxlength, + "%s/%d/%d_%s_%s.%s", + RP_DIRECTORY_JUMPS, + GetSteamAccountID(client), + jumpType, + gC_ModeNamesShort[mode], + gC_StyleNamesShort[style], + RP_FILE_EXTENSION); +} + +static void FormatBlockJumpReplayPath(char[] buffer, int maxlength, int client, int block, int jumpType, int mode, int style) +{ + BuildPath(Path_SM, buffer, maxlength, + "%s/%d/%s/%d_%d_%s_%s.%s", + RP_DIRECTORY_JUMPS, + GetSteamAccountID(client), + RP_DIRECTORY_BLOCKJUMPS, + jumpType, + block, + gC_ModeNamesShort[mode], + gC_StyleNamesShort[style], + RP_FILE_EXTENSION); +} + +static int EncodePlayerFlags(int client, int buttons, int tickCount) +{ + int flags = 0; + MoveType movetype = Movement_GetMovetype(client); + int clientFlags = GetEntityFlags(client); + + flags = view_as<int>(movetype) & RP_MOVETYPE_MASK; + + SetKthBit(flags, 4, IsBitSet(buttons, IN_ATTACK)); + SetKthBit(flags, 5, IsBitSet(buttons, IN_ATTACK2)); + SetKthBit(flags, 6, IsBitSet(buttons, IN_JUMP)); + SetKthBit(flags, 7, IsBitSet(buttons, IN_DUCK)); + SetKthBit(flags, 8, IsBitSet(buttons, IN_FORWARD)); + SetKthBit(flags, 9, IsBitSet(buttons, IN_BACK)); + SetKthBit(flags, 10, IsBitSet(buttons, IN_LEFT)); + SetKthBit(flags, 11, IsBitSet(buttons, IN_RIGHT)); + SetKthBit(flags, 12, IsBitSet(buttons, IN_MOVELEFT)); + SetKthBit(flags, 13, IsBitSet(buttons, IN_MOVERIGHT)); + SetKthBit(flags, 14, IsBitSet(buttons, IN_RELOAD)); + SetKthBit(flags, 15, IsBitSet(buttons, IN_SPEED)); + SetKthBit(flags, 16, IsBitSet(buttons, IN_USE)); + SetKthBit(flags, 17, IsBitSet(buttons, IN_BULLRUSH)); + SetKthBit(flags, 18, IsBitSet(clientFlags, FL_ONGROUND)); + SetKthBit(flags, 19, IsBitSet(clientFlags, FL_DUCKING)); + SetKthBit(flags, 20, IsBitSet(clientFlags, FL_SWIM)); + + SetKthBit(flags, 21, GetEntProp(client, Prop_Data, "m_nWaterLevel") != 0); + + SetKthBit(flags, 22, isTeleportTick[client]); + SetKthBit(flags, 23, Movement_GetTakeoffTick(client) == tickCount); + SetKthBit(flags, 24, GOKZ_GetHitPerf(client)); + SetKthBit(flags, 25, IsCurrentWeaponSecondary(client)); + + return flags; +} + +// Function to set the bitNum bit in integer to value +static void SetKthBit(int &number, int offset, bool value) +{ + int intValue = value ? 1 : 0; + number |= intValue << offset; +} + +static bool IsBitSet(int number, int checkBit) +{ + return (number & checkBit) ? true : false; +} + +static int GetPlayerWeaponSlotDefIndex(int client, int slot) +{ + int ent = GetPlayerWeaponSlot(client, slot); + + // Nothing equipped in the slot + if (ent == -1) + { + return -1; + } + + return GetEntProp(ent, Prop_Send, "m_iItemDefinitionIndex"); +} + +static bool IsCurrentWeaponSecondary(int client) +{ + int activeWeaponEnt = GetEntPropEnt(client, Prop_Send, "m_hActiveWeapon"); + int secondaryEnt = GetPlayerWeaponSlot(client, CS_SLOT_SECONDARY); + return activeWeaponEnt == secondaryEnt; +} + +static void CreateReplaysDirectory(const char[] map) +{ + char path[PLATFORM_MAX_PATH]; + + // Create parent replay directory + BuildPath(Path_SM, path, sizeof(path), RP_DIRECTORY); + if (!DirExists(path)) + { + CreateDirectory(path, 511); + } + + // Create maps parent replay directory + BuildPath(Path_SM, path, sizeof(path), "%s", RP_DIRECTORY_RUNS); + if (!DirExists(path)) + { + CreateDirectory(path, 511); + } + + + // Create maps replay directory + BuildPath(Path_SM, path, sizeof(path), "%s/%s", RP_DIRECTORY_RUNS, map); + if (!DirExists(path)) + { + CreateDirectory(path, 511); + } + + // Create maps parent replay directory + BuildPath(Path_SM, path, sizeof(path), "%s", RP_DIRECTORY_RUNS_TEMP); + if (!DirExists(path)) + { + CreateDirectory(path, 511); + } + + + // Create maps replay directory + BuildPath(Path_SM, path, sizeof(path), "%s/%s", RP_DIRECTORY_RUNS_TEMP, map); + if (!DirExists(path)) + { + CreateDirectory(path, 511); + } + + // Create cheaters replay directory + BuildPath(Path_SM, path, sizeof(path), "%s", RP_DIRECTORY_CHEATERS); + if (!DirExists(path)) + { + CreateDirectory(path, 511); + } + + // Create jumps parent replay directory + BuildPath(Path_SM, path, sizeof(path), "%s", RP_DIRECTORY_JUMPS); + if (!DirExists(path)) + { + CreateDirectory(path, 511); + } +} + +public void MYAWCheck(QueryCookie cookie, int client, ConVarQueryResult result, const char[] cvarName, const char[] cvarValue, any value) +{ + if (IsValidClient(client) && !IsFakeClient(client)) + { + playerMYaw[client] = StringToFloat(cvarValue); + } +} + +public void SensitivityCheck(QueryCookie cookie, int client, ConVarQueryResult result, const char[] cvarName, const char[] cvarValue, any value) +{ + if (IsValidClient(client) && !IsFakeClient(client)) + { + playerSensitivity[client] = StringToFloat(cvarValue); + } +} + +static int RecordingIndexAdd(int client, int offset) +{ + int index = recordingIndex[client] + offset; + if (index < 0) + { + index += recordedRecentData[client].Length; + } + return index % recordedRecentData[client].Length; +} + +static void RemoveFromRunningTimers(int client, Handle timerToRemove) +{ + int index = runningJumpstatTimers[client].FindValue(timerToRemove); + if (index != -1) + { + runningJumpstatTimers[client].Erase(index); + } +} diff --git a/sourcemod/scripting/gokz-replays/replay_cache.sp b/sourcemod/scripting/gokz-replays/replay_cache.sp new file mode 100644 index 0000000..83f36d0 --- /dev/null +++ b/sourcemod/scripting/gokz-replays/replay_cache.sp @@ -0,0 +1,176 @@ +/* + Cached info about the map's available replay bots stored in an ArrayList. +*/ + + + +// =====[ PUBLIC ]===== + +// Adds a replay to the cache +void AddToReplayInfoCache(int course, int mode, int style, int timeType) +{ + int index = g_ReplayInfoCache.Length; + g_ReplayInfoCache.Resize(index + 1); + g_ReplayInfoCache.Set(index, course, 0); + g_ReplayInfoCache.Set(index, mode, 1); + g_ReplayInfoCache.Set(index, style, 2); + g_ReplayInfoCache.Set(index, timeType, 3); +} + +// Use this to sort the cache after finished adding to it +void SortReplayInfoCache() +{ + g_ReplayInfoCache.SortCustom(SortFunc_ReplayInfoCache); +} + +public int SortFunc_ReplayInfoCache(int index1, int index2, Handle array, Handle hndl) +{ + // Do not expect any indexes to be 'equal' + int replayInfo1[RP_CACHE_BLOCKSIZE], replayInfo2[RP_CACHE_BLOCKSIZE]; + g_ReplayInfoCache.GetArray(index1, replayInfo1); + g_ReplayInfoCache.GetArray(index2, replayInfo2); + + // Compare courses - lower course number goes first + if (replayInfo1[0] < replayInfo2[0]) + { + return -1; + } + else if (replayInfo1[0] > replayInfo2[0]) + { + return 1; + } + // Same course, so compare mode + else if (replayInfo1[1] < replayInfo2[1]) + { + return -1; + } + else if (replayInfo1[1] > replayInfo2[1]) + { + return 1; + } + // Same course and mode, so compare style + else if (replayInfo1[2] < replayInfo2[2]) + { + return -1; + } + else if (replayInfo1[2] > replayInfo2[2]) + { + return 1; + } + // Same course, mode and style so compare time type, assuming can't be identical + else if (replayInfo1[3] == TimeType_Pro) + { + return 1; + } + return -1; +} + + + +// =====[ EVENTS ]===== + +void OnMapStart_ReplayCache() +{ + if (g_ReplayInfoCache == null) + { + g_ReplayInfoCache = new ArrayList(RP_CACHE_BLOCKSIZE, 0); + } + else + { + g_ReplayInfoCache.Clear(); + } + + char path[PLATFORM_MAX_PATH]; + BuildPath(Path_SM, path, sizeof(path), "%s/%s", RP_DIRECTORY_RUNS, gC_CurrentMap); + DirectoryListing dir = OpenDirectory(path); + + // We want to find files that look like "0_KZT_NRM_PRO.rec" + char file[PLATFORM_MAX_PATH], pieces[4][16]; + int length, dotpos, course, mode, style, timeType; + + while (dir.GetNext(file, sizeof(file))) + { + // Some credit to Influx Timer - https://github.com/TotallyMehis/Influx-Timer + + // Check file extension + length = strlen(file); + dotpos = 0; + for (int i = 0; i < length; i++) + { + if (file[i] == '.') + { + dotpos = i; + } + } + if (!StrEqual(file[dotpos + 1], RP_FILE_EXTENSION, false)) + { + continue; + } + + // Remove file extension + Format(file, dotpos + 1, file); + + // Break down file name into pieces + if (ExplodeString(file, "_", pieces, sizeof(pieces), sizeof(pieces[])) != sizeof(pieces)) + { + continue; + } + + // Extract info from the pieces + course = StringToInt(pieces[0]); + mode = GetModeIDFromString(pieces[1]); + style = GetStyleIDFromString(pieces[2]); + timeType = GetTimeTypeIDFromString(pieces[3]); + if (!GOKZ_IsValidCourse(course) || mode == -1 || style == -1 || timeType == -1) + { + continue; + } + + // Add it to the cache + AddToReplayInfoCache(course, mode, style, timeType); + } + + SortReplayInfoCache(); + + delete dir; +} + + + +// =====[ PRIVATE ]===== + +static int GetModeIDFromString(const char[] mode) +{ + for (int modeID = 0; modeID < MODE_COUNT; modeID++) + { + if (StrEqual(mode, gC_ModeNamesShort[modeID], false)) + { + return modeID; + } + } + return -1; +} + +static int GetStyleIDFromString(const char[] style) +{ + for (int styleID = 0; styleID < STYLE_COUNT; styleID++) + { + if (StrEqual(style, gC_StyleNamesShort[styleID], false)) + { + return styleID; + } + } + return -1; +} + +static int GetTimeTypeIDFromString(const char[] timeType) +{ + for (int timeTypeID = 0; timeTypeID < TIMETYPE_COUNT; timeTypeID++) + { + if (StrEqual(timeType, gC_TimeTypeNames[timeTypeID], false)) + { + return timeTypeID; + } + } + return -1; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-replays/replay_menu.sp b/sourcemod/scripting/gokz-replays/replay_menu.sp new file mode 100644 index 0000000..94acd66 --- /dev/null +++ b/sourcemod/scripting/gokz-replays/replay_menu.sp @@ -0,0 +1,139 @@ +/* + Lets player select a replay bot to play back. +*/ + + + +static int selectedReplayMode[MAXPLAYERS + 1]; + + + +// =====[ PUBLIC ]===== + +void DisplayReplayModeMenu(int client) +{ + if (g_ReplayInfoCache.Length == 0) + { + GOKZ_PrintToChat(client, true, "%t", "No Replays Found (Map)"); + GOKZ_PlayErrorSound(client); + return; + } + + Menu menu = new Menu(MenuHandler_ReplayMode); + menu.SetTitle("%T", "Replay Menu (Mode) - Title", client, gC_CurrentMap); + GOKZ_MenuAddModeItems(client, menu, false); + menu.Display(client, MENU_TIME_FOREVER); +} + + + +// =====[ EVENTS ]===== + +public int MenuHandler_ReplayMode(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + selectedReplayMode[param1] = param2; + DisplayReplayMenu(param1); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + +public int MenuHandler_Replay(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + char info[4]; + menu.GetItem(param2, info, sizeof(info)); + int replayIndex = StringToInt(info); + int replayInfo[RP_CACHE_BLOCKSIZE]; + g_ReplayInfoCache.GetArray(replayIndex, replayInfo); + + char path[PLATFORM_MAX_PATH]; + BuildPath(Path_SM, path, sizeof(path), + "%s/%s/%d_%s_%s_%s.%s", + RP_DIRECTORY_RUNS, gC_CurrentMap, replayInfo[0], gC_ModeNamesShort[replayInfo[1]], gC_StyleNamesShort[replayInfo[2]], gC_TimeTypeNames[replayInfo[3]], RP_FILE_EXTENSION); + if (!FileExists(path)) + { + BuildPath(Path_SM, path, sizeof(path), + "%s/%d_%s_%s_%s.%s", + RP_DIRECTORY, gC_CurrentMap, replayInfo[0], gC_ModeNamesShort[replayInfo[1]], gC_StyleNamesShort[replayInfo[2]], gC_TimeTypeNames[replayInfo[3]], RP_FILE_EXTENSION); + if (!FileExists(path)) + { + LogError("Failed to load file: \"%s\".", path); + GOKZ_PrintToChat(param1, true, "%t", "Replay Menu - No File"); + return 0; + } + } + + LoadReplayBot(param1, path); + } + else if (action == MenuAction_Cancel) + { + DisplayReplayModeMenu(param1); + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + + + +// =====[ PRIVATE ]===== + +static void DisplayReplayMenu(int client) +{ + Menu menu = new Menu(MenuHandler_Replay); + menu.SetTitle("%T", "Replay Menu - Title", client, gC_CurrentMap, gC_ModeNames[selectedReplayMode[client]]); + if (ReplayMenuAddItems(client, menu) > 0) + { + menu.Display(client, MENU_TIME_FOREVER); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "No Replays Found (Mode)", gC_ModeNames[selectedReplayMode[client]]); + GOKZ_PlayErrorSound(client); + DisplayReplayModeMenu(client); + } +} + +// Returns the number of replay menu items added +static int ReplayMenuAddItems(int client, Menu menu) +{ + int replaysAdded = 0; + int replayCount = g_ReplayInfoCache.Length; + int replayInfo[RP_CACHE_BLOCKSIZE]; + char temp[32], indexString[4]; + + menu.RemoveAllItems(); + + for (int i = 0; i < replayCount; i++) + { + IntToString(i, indexString, sizeof(indexString)); + g_ReplayInfoCache.GetArray(i, replayInfo); + if (replayInfo[1] != selectedReplayMode[client]) // Wrong mode! + { + continue; + } + + if (replayInfo[0] == 0) + { + FormatEx(temp, sizeof(temp), "Main %s", gC_TimeTypeNames[replayInfo[3]]); + } + else + { + FormatEx(temp, sizeof(temp), "Bonus %d %s", replayInfo[0], gC_TimeTypeNames[replayInfo[3]]); + } + menu.AddItem(indexString, temp, ITEMDRAW_DEFAULT); + + replaysAdded++; + } + + return replaysAdded; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-saveloc.sp b/sourcemod/scripting/gokz-saveloc.sp new file mode 100644 index 0000000..98d64c0 --- /dev/null +++ b/sourcemod/scripting/gokz-saveloc.sp @@ -0,0 +1,822 @@ +#include <sourcemod> + +#include <cstrike> +#include <sdktools> + +#include <gokz/core> +#include <gokz/kzplayer> + +#undef REQUIRE_EXTENSIONS +#undef REQUIRE_PLUGIN +#include <updater> +#include <gokz/hud> +#pragma newdecls required +#pragma semicolon 1 + +public Plugin myinfo = +{ + name = "GOKZ SaveLoc", + author = "JWL", + description = "Allows players to save/load locations that preserve position, angles, and velocity", + version = GOKZ_VERSION, + url = GOKZ_SOURCE_URL +}; + +#define UPDATER_URL GOKZ_UPDATER_BASE_URL..."gokz-saveloc.txt" +#define LOADLOC_INVALIDATE_DURATION 0.12 +#define MAX_LOCATION_NAME_LENGTH 32 + +enum struct Location { + // Location name must be first for FindString to work. + char locationName[MAX_LOCATION_NAME_LENGTH]; + char locationCreator[MAX_NAME_LENGTH]; + + // GOKZ related states + int mode; + int course; + float currentTime; + ArrayList checkpointData; + int checkpointCount; + int teleportCount; + ArrayList undoTeleportData; + + // Movement related states + int groundEnt; + int flags; + float position[3]; + float angles[3]; + float velocity[3]; + float duckAmount; + bool ducking; + bool ducked; + float lastDuckTime; + float duckSpeed; + float stamina; + MoveType movetype; + float ladderNormal[3]; + int collisionGroup; + float waterJumpTime; + bool hasWalkMovedSinceLastJump; + float ignoreLadderJumpTimeOffset; + float lastPositionAtFullCrouchSpeed[2]; + + void Create(int client, int target) + { + GetClientName(client, this.locationCreator, sizeof(Location::locationCreator)); + this.groundEnt = GetEntPropEnt(target, Prop_Data, "m_hGroundEntity"); + this.flags = GetEntityFlags(target); + this.mode = GOKZ_GetCoreOption(target, Option_Mode); + this.course = GOKZ_GetCourse(target); + GetClientAbsOrigin(target, this.position); + GetClientEyeAngles(target, this.angles); + GetEntPropVector(target, Prop_Data, "m_vecVelocity", this.velocity); + this.duckAmount = GetEntPropFloat(target, Prop_Send, "m_flDuckAmount"); + this.ducking = !!GetEntProp(target, Prop_Send, "m_bDucking"); + this.ducked = !!GetEntProp(target, Prop_Send, "m_bDucked"); + this.lastDuckTime = GetEntPropFloat(target, Prop_Send, "m_flLastDuckTime"); + this.duckSpeed = Movement_GetDuckSpeed(target); + this.stamina = GetEntPropFloat(target, Prop_Send, "m_flStamina"); + this.movetype = Movement_GetMovetype(target); + GetEntPropVector(target, Prop_Send, "m_vecLadderNormal", this.ladderNormal); + this.collisionGroup = GetEntProp(target, Prop_Send, "m_CollisionGroup"); + this.waterJumpTime = GetEntPropFloat(target, Prop_Data, "m_flWaterJumpTime"); + this.hasWalkMovedSinceLastJump = !!GetEntProp(target, Prop_Data, "m_bHasWalkMovedSinceLastJump"); + this.ignoreLadderJumpTimeOffset = GetEntPropFloat(target, Prop_Data, "m_ignoreLadderJumpTime") - GetGameTime(); + GetLastPositionAtFullCrouchSpeed(target, this.lastPositionAtFullCrouchSpeed); + + if (GOKZ_GetTimerRunning(target)) + { + this.currentTime = GOKZ_GetTime(target); + } + else + { + this.currentTime = -1.0; + } + this.checkpointData = GOKZ_GetCheckpointData(target); + this.checkpointCount = GOKZ_GetCheckpointCount(target); + this.teleportCount = GOKZ_GetTeleportCount(target); + this.undoTeleportData = GOKZ_GetUndoTeleportData(target); + } + + bool Load(int client) + { + // Safeguard Check + if (GOKZ_GetCoreOption(client, Option_Safeguard) > Safeguard_Disabled && GOKZ_GetTimerRunning(client) && GOKZ_GetValidTimer(client)) + { + GOKZ_PrintToChat(client, true, "%t", "Safeguard - Blocked"); + GOKZ_PlayErrorSound(client); + return false; + } + if (!GOKZ_SetMode(client, this.mode)) + { + GOKZ_PrintToChat(client, true, "%t", "LoadLoc - Mode Not Available"); + } + GOKZ_SetCourse(client, this.course); + if (this.currentTime >= 0.0) + { + GOKZ_SetTime(client, this.currentTime); + } + GOKZ_SetCheckpointData(client, this.checkpointData, GOKZ_CHECKPOINT_VERSION); + GOKZ_SetCheckpointCount(client, this.checkpointCount); + GOKZ_SetTeleportCount(client, this.teleportCount); + GOKZ_SetUndoTeleportData(client, this.undoTeleportData, GOKZ_CHECKPOINT_VERSION); + + SetEntPropEnt(client, Prop_Data, "m_hGroundEntity", this.groundEnt); + SetEntityFlags(client, this.flags); + TeleportEntity(client, this.position, this.angles, this.velocity); + SetEntPropFloat(client, Prop_Send, "m_flDuckAmount", this.duckAmount); + SetEntProp(client, Prop_Send, "m_bDucking", this.ducking); + SetEntProp(client, Prop_Send, "m_bDucked", this.ducked); + SetEntPropFloat(client, Prop_Send, "m_flLastDuckTime", this.lastDuckTime); + Movement_SetDuckSpeed(client, this.duckSpeed); + SetEntPropFloat(client, Prop_Send, "m_flStamina", this.stamina); + Movement_SetMovetype(client, this.movetype); + SetEntPropVector(client, Prop_Send, "m_vecLadderNormal", this.ladderNormal); + SetEntProp(client, Prop_Send, "m_CollisionGroup", this.collisionGroup); + SetEntPropFloat(client, Prop_Data, "m_flWaterJumpTime", this.waterJumpTime); + SetEntProp(client, Prop_Data, "m_bHasWalkMovedSinceLastJump", this.hasWalkMovedSinceLastJump); + SetEntPropFloat(client, Prop_Data, "m_ignoreLadderJumpTime", this.ignoreLadderJumpTimeOffset + GetGameTime()); + SetLastPositionAtFullCrouchSpeed(client, this.lastPositionAtFullCrouchSpeed); + + GOKZ_InvalidateRun(client); + return true; + } +} + +ArrayList gA_Locations; +bool gB_LocMenuOpen[MAXPLAYERS + 1]; +bool gB_UsedLoc[MAXPLAYERS + 1]; +int gI_MostRecentLocation[MAXPLAYERS + 1]; +float gF_LastLoadlocTime[MAXPLAYERS + 1]; + +bool gB_GOKZHUD; + +// =====[ PLUGIN EVENTS ]===== + +public APLRes AskPluginLoad2(Handle myself, bool late, char[] error, int err_max) +{ + RegPluginLibrary("gokz-saveloc"); + return APLRes_Success; +} + +public void OnPluginStart() +{ + LoadTranslations("gokz-common.phrases"); + LoadTranslations("gokz-saveloc.phrases"); + + HookEvents(); + RegisterCommands(); + CreateArrays(); +} + +public void OnAllPluginsLoaded() +{ + if (LibraryExists("updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + gB_GOKZHUD = LibraryExists("gokz-hud"); +} + +public void OnLibraryAdded(const char[] name) +{ + if (StrEqual(name, "updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + gB_GOKZHUD = gB_GOKZHUD || StrEqual(name, "gokz-hud"); +} + +public void OnLibraryRemoved(const char[] name) +{ + gB_GOKZHUD = gB_GOKZHUD && !StrEqual(name, "gokz-hud"); +} + +public void OnMapStart() +{ + ClearLocations(); +} + + + +// =====[ CLIENT EVENTS ]===== + +public void OnClientPutInServer(int client) +{ + gF_LastLoadlocTime[client] = 0.0; +} + +public void OnPlayerDeath(Event event, const char[] name, bool dontBroadcast) +{ + int client = GetClientOfUserId(event.GetInt("userid")); + + CloseLocMenu(client); +} + +public void OnPlayerJoinTeam(Event event, const char[] name, bool dontBroadcast) +{ + int client = GetClientOfUserId(event.GetInt("userid")); + int team = event.GetInt("team"); + + if (team == CS_TEAM_SPECTATOR) + { + CloseLocMenu(client); + } +} + +public Action GOKZ_OnTimerStart(int client, int course) +{ + CloseLocMenu(client); + gB_UsedLoc[client] = false; + if (GetGameTime() < gF_LastLoadlocTime[client] + LOADLOC_INVALIDATE_DURATION) + { + return Plugin_Stop; + } + return Plugin_Continue; +} + +public Action GOKZ_OnTimerEnd(int client, int course, float time) +{ + if (gB_UsedLoc[client]) + { + PrintEndTimeString_SaveLoc(client, course, time); + } + return Plugin_Continue; +} + +// =====[ GENERAL ]===== + +void HookEvents() +{ + HookEvent("player_death", OnPlayerDeath); + HookEvent("player_team", OnPlayerJoinTeam); +} + + + +// =====[ COMMANDS ]===== + +void RegisterCommands() +{ + RegConsoleCmd("sm_saveloc", Command_SaveLoc, "[KZ] Save location. Usage: !saveloc <name>"); + RegConsoleCmd("sm_loadloc", Command_LoadLoc, "[KZ] Load location. Usage: !loadloc <#id OR name>"); + RegConsoleCmd("sm_prevloc", Command_PrevLoc, "[KZ] Go back to the previous location."); + RegConsoleCmd("sm_nextloc", Command_NextLoc, "[KZ] Go forward to the next location."); + RegConsoleCmd("sm_locmenu", Command_LocMenu, "[KZ] Open location menu."); + RegConsoleCmd("sm_nameloc", Command_NameLoc, "[KZ] Name location. Usage: !nameloc <#id> <name>"); +} + +public Action Command_SaveLoc(int client, int args) +{ + if (!IsValidClient(client)) + { + return Plugin_Handled; + } + int target = -1; + if (!IsPlayerAlive(client)) + { + KZPlayer player = KZPlayer(client); + target = player.ObserverTarget; + if (target == -1) + { + GOKZ_PrintToChat(client, true, "%t", "Must Be Alive"); + GOKZ_PlayErrorSound(client); + return Plugin_Handled; + } + } + + if (args == 0) + { + // save location with empty <name> + SaveLocation(client, "", target); + } + else if (args == 1) + { + // get location <name> + char arg[MAX_LOCATION_NAME_LENGTH]; + GetCmdArg(1, arg, sizeof(arg)); + + if (IsValidLocationName(arg)) + { + // save location with <name> + SaveLocation(client, arg, target); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "NameLoc - Naming Format"); + } + } + else + { + GOKZ_PrintToChat(client, true, "%t", "SaveLoc - Usage"); + } + + return Plugin_Handled; +} + +public Action Command_LoadLoc(int client, int args) +{ + if (!IsValidClient(client)) + { + return Plugin_Handled; + } + else if (!IsPlayerAlive(client)) + { + GOKZ_PrintToChat(client, true, "%t", "Must Be Alive"); + return Plugin_Handled; + } + else if (gA_Locations.Length == 0) + { + GOKZ_PrintToChat(client, true, "%t", "No Locations Found"); + return Plugin_Handled; + } + + if (args == 0) + { + // load most recent location + int id = gI_MostRecentLocation[client]; + LoadLocation(client, id); + } + else if (args == 1) + { + // get location <#id OR name> + char arg[MAX_LOCATION_NAME_LENGTH]; + GetCmdArg(1, arg, sizeof(arg)); + int id; + + if (arg[0] == '#') + { + // load location <#id> + id = StringToInt(arg[1]); + } + else + { + // load location <name> + id = gA_Locations.FindString(arg); + } + + if (IsValidLocationId(id)) + { + if (LoadLocation(client, id)) + { + gF_LastLoadlocTime[client] = GetGameTime(); + } + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Location Not Found"); + } + } + else + { + GOKZ_PrintToChat(client, true, "%t", "LoadLoc - Usage"); + } + + return Plugin_Handled; +} + +public Action Command_PrevLoc(int client, int args) +{ + if (!IsValidClient(client)) + { + return Plugin_Handled; + } + else if (gA_Locations.Length == 0) + { + GOKZ_PrintToChat(client, true, "%t", "No Locations Found"); + return Plugin_Handled; + } + else if (gI_MostRecentLocation[client] <= 0) + { + GOKZ_PrintToChat(client, true, "%t", "PrevLoc - Can't Prev Location (No Location Found)"); + return Plugin_Handled; + } + LoadLocation(client, gI_MostRecentLocation[client] - 1); + return Plugin_Handled; +} + +public Action Command_NextLoc(int client, int args) +{ + if (!IsValidClient(client)) + { + return Plugin_Handled; + } + else if (gA_Locations.Length == 0) + { + GOKZ_PrintToChat(client, true, "%t", "No Locations Found"); + return Plugin_Handled; + } + else if (gI_MostRecentLocation[client] >= gA_Locations.Length - 1) + { + GOKZ_PrintToChat(client, true, "%t", "NextLoc - Can't Next Location (No Location Found)"); + return Plugin_Handled; + } + LoadLocation(client, gI_MostRecentLocation[client] + 1); + return Plugin_Handled; +} + +public Action Command_NameLoc(int client, int args) +{ + if (!IsValidClient(client)) + { + return Plugin_Handled; + } + else if (gA_Locations.Length == 0) + { + GOKZ_PrintToChat(client, true, "%t", "No Locations Found"); + return Plugin_Handled; + } + + if (args == 0) + { + GOKZ_PrintToChat(client, true, "%t", "NameLoc - Usage"); + } + else if (args == 1) + { + // name most recent location + char arg[MAX_LOCATION_NAME_LENGTH]; + GetCmdArg(1, arg, sizeof(arg)); + int id = gI_MostRecentLocation[client]; + + if (IsValidLocationName(arg) && IsClientLocationCreator(client, id)) + { + NameLocation(client, id, arg); + } + else if (!IsClientLocationCreator(client, id)) + { + GOKZ_PrintToChat(client, true, "%t", "NameLoc - Not Creator"); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "NameLoc - Naming Format"); + } + } + else if (args == 2) + { + // name specified location + char arg1[MAX_LOCATION_NAME_LENGTH]; + char arg2[MAX_LOCATION_NAME_LENGTH]; + GetCmdArg(1, arg1, sizeof(arg1)); + GetCmdArg(2, arg2, sizeof(arg2)); + int id = StringToInt(arg1[1]); + + if (IsValidLocationId(id)) + { + + if (IsValidLocationName(arg2) && IsClientLocationCreator(client, id)) + { + NameLocation(client, id, arg2); + } + else if (!IsClientLocationCreator(client, id)) + { + GOKZ_PrintToChat(client, true, "%t", "NameLoc - Not Creator"); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "NameLoc - Naming Format"); + } + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Location Not Found"); + } + } + else + { + GOKZ_PrintToChat(client, true, "%t", "NameLoc - Usage"); + } + + return Plugin_Handled; +} + +public Action Command_LocMenu(int client, int args) +{ + if (!IsValidClient(client)) + { + return Plugin_Handled; + } + else if (!IsPlayerAlive(client)) + { + GOKZ_PrintToChat(client, true, "%t", "Must Be Alive"); + return Plugin_Handled; + } + else if (gA_Locations.Length == 0) + { + GOKZ_PrintToChat(client, true, "%t", "No Locations Found"); + return Plugin_Handled; + } + + ShowLocMenu(client); + + return Plugin_Handled; +} + +// ====[ SAVELOC MENU ]==== + +void ShowLocMenu(int client) +{ + Menu locMenu = new Menu(LocMenuHandler, MENU_ACTIONS_ALL); + locMenu.SetTitle("%t", "LocMenu - Title"); + + // fill the menu with all locations + for (int i = 0; i < gA_Locations.Length; i++) + { + char item[MAX_LOCATION_NAME_LENGTH]; + Format(item, sizeof(item), "%i", i); + locMenu.AddItem(item, item); + } + + // calculate which page of the menu contains client's most recent location + int firstItem; + if (gI_MostRecentLocation[client] > 5) + { + firstItem = gI_MostRecentLocation[client] - (gI_MostRecentLocation[client] % 6); + } + + locMenu.DisplayAt(client, firstItem, MENU_TIME_FOREVER); +} + + + +// ====[ SAVELOC MENU HANDLER ]==== + +public int LocMenuHandler(Menu menu, MenuAction action, int client, int choice) +{ + switch (action) + { + case MenuAction_Display: + { + gB_LocMenuOpen[client] = true; + } + + case MenuAction_DisplayItem: + { + Location loc; + char item[MAX_LOCATION_NAME_LENGTH]; + menu.GetItem(choice, item, sizeof(item)); + + int id = StringToInt(item); + gA_Locations.GetArray(id, loc); + char name[MAX_LOCATION_NAME_LENGTH]; + strcopy(name, sizeof(name), loc.locationName); + + if (id == gI_MostRecentLocation[client]) + { + Format(item, sizeof(item), "> #%i %s", id, name); + } + else + { + Format(item, sizeof(item), "#%i %s", id, name); + } + + return RedrawMenuItem(item); + } + + case MenuAction_Select: + { + char item[MAX_LOCATION_NAME_LENGTH]; + menu.GetItem(choice, item, sizeof(item)); + ReplaceString(item, sizeof(item), "#", ""); + int id = StringToInt(item); + + LoadLocation(client, id); + } + + case MenuAction_Cancel: + { + gB_LocMenuOpen[client] = false; + } + + case MenuAction_End: + { + delete menu; + } + } + + return 0; +} + + + +// ====[ SAVE LOCATION ]==== + +void SaveLocation(int client, char[] name, int target) +{ + Location loc; + if (target == -1) + { + target = client; + } + loc.Create(client, target); + strcopy(loc.locationName, sizeof(Location::locationName), name); + GetClientName(client, loc.locationCreator, sizeof(loc.locationCreator)); + gA_Locations.PushArray(loc); + gI_MostRecentLocation[client] = gA_Locations.Length - 1; + + GOKZ_PrintToChat(client, true, "%t", "SaveLoc - ID Name", gA_Locations.Length - 1, name); + + for (int i = 1; i <= MaxClients; i++) + { + RefreshLocMenu(i); + } +} + + + +// ====[ LOAD LOCATION ]==== + +bool LoadLocation(int client, int id) +{ + if (!IsPlayerAlive(client)) + { + GOKZ_PrintToChat(client, true, "%t", "Must Be Alive"); + return false; + } + char clientName[MAX_NAME_LENGTH]; + + GetClientName(client, clientName, sizeof(clientName)); + Location loc; + gA_Locations.GetArray(id, loc); + if (loc.Load(client)) + { + gB_UsedLoc[client] = true; + if (gB_GOKZHUD) + { + GOKZ_HUD_ForceUpdateTPMenu(client); + } + } + else + { + return false; + } + // print message if loading new location + if (gI_MostRecentLocation[client] != id) + { + gI_MostRecentLocation[client] = id; + + if (StrEqual(clientName, loc.locationCreator)) + { + GOKZ_PrintToChat(client, true, "%t", "LoadLoc - ID Name", id, loc.locationName); + } + else + { + if (StrEqual(loc.locationName, "")) + { + GOKZ_PrintToChat(client, true, "%t", "LoadLoc - ID Creator", id, loc.locationCreator); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "LoadLoc - ID Name Creator", id, loc.locationName, loc.locationCreator); + } + } + } + + RefreshLocMenu(client); + + return true; +} + + + +// ====[ NAME LOCATION ]==== + +void NameLocation(int client, int id, char[] name) +{ + Location loc; + gA_Locations.GetArray(id, loc); + strcopy(loc.locationName, sizeof(Location::locationName), name); + + GOKZ_PrintToChat(client, true, "%t", "NameLoc - ID Name", id, name); + + for (int i = 1; i <= MaxClients; i++) + { + RefreshLocMenu(i); + } +} + + + +// =====[ HELPER FUNCTIONS ]===== + +void CreateArrays() +{ + gA_Locations = new ArrayList(sizeof(Location)); +} + +void ClearLocations() +{ + Location loc; + for (int i = 0; i < gA_Locations.Length; i++) + { + // Prevent memory leak + gA_Locations.GetArray(i, loc); + delete loc.checkpointData; + } + gA_Locations.Clear(); + for (int i = 1; i <= MaxClients; i++) + { + gI_MostRecentLocation[i] = -1; + gB_LocMenuOpen[i] = false; + } +} + +void RefreshLocMenu(int client) +{ + if (gB_LocMenuOpen[client]) + { + ShowLocMenu(client); + } +} + +void CloseLocMenu(int client) +{ + if (gB_LocMenuOpen[client]) + { + CancelClientMenu(client, true); + gB_LocMenuOpen[client] = false; + } +} + +bool IsValidLocationId(int id) +{ + return !(id < 0) && !(id > gA_Locations.Length - 1); +} + +bool IsValidLocationName(char[] name) +{ + // check if location name starts with letter and is unique + return IsCharAlpha(name[0]) && gA_Locations.FindString(name) == -1; +} + +bool IsClientLocationCreator(int client, int id) +{ + char clientName[MAX_NAME_LENGTH]; + Location loc; + gA_Locations.GetArray(id, loc); + GetClientName(client, clientName, sizeof(clientName)); + + return StrEqual(clientName, loc.locationCreator); +} + +void GetLastPositionAtFullCrouchSpeed(int client, float origin[2]) +{ + // m_vecLastPositionAtFullCrouchSpeed is right after m_flDuckSpeed. + int baseOffset = FindSendPropInfo("CBasePlayer", "m_flDuckSpeed"); + origin[0] = GetEntDataFloat(client, baseOffset + 4); + origin[1] = GetEntDataFloat(client, baseOffset + 8); +} + +void SetLastPositionAtFullCrouchSpeed(int client, float origin[2]) +{ + int baseOffset = FindSendPropInfo("CBasePlayer", "m_flDuckSpeed"); + SetEntDataFloat(client, baseOffset + 4, origin[0]); + SetEntDataFloat(client, baseOffset + 8, origin[1]); +} + +// ====[ PRIVATE ]==== + +static void PrintEndTimeString_SaveLoc(int client, int course, float time) +{ + if (course == 0) + { + switch (GOKZ_GetTimeType(client)) + { + case TimeType_Nub: + { + GOKZ_PrintToChat(client, true, "%t", "Beat Map (NUB)", + client, + GOKZ_FormatTime(time), + gC_ModeNamesShort[GOKZ_GetCoreOption(client, Option_Mode)]); + } + case TimeType_Pro: + { + GOKZ_PrintToChat(client, true, "%t", "Beat Map (PRO)", + client, + GOKZ_FormatTime(time), + gC_ModeNamesShort[GOKZ_GetCoreOption(client, Option_Mode)]); + } + } + } + else + { + switch (GOKZ_GetTimeType(client)) + { + case TimeType_Nub: + { + GOKZ_PrintToChat(client, true, "%t", "Beat Bonus (NUB)", + client, + GOKZ_GetCourse(client), + GOKZ_FormatTime(time), + gC_ModeNamesShort[GOKZ_GetCoreOption(client, Option_Mode)]); + } + case TimeType_Pro: + { + GOKZ_PrintToChat(client, true, "%t", "Beat Bonus (PRO)", + client, + GOKZ_GetCourse(client), + GOKZ_FormatTime(time), + gC_ModeNamesShort[GOKZ_GetCoreOption(client, Option_Mode)]); + } + } + } +} diff --git a/sourcemod/scripting/gokz-slayonend.sp b/sourcemod/scripting/gokz-slayonend.sp new file mode 100644 index 0000000..c83c4e6 --- /dev/null +++ b/sourcemod/scripting/gokz-slayonend.sp @@ -0,0 +1,190 @@ +#include <sourcemod> + +#include <gokz/core> +#include <gokz/slayonend> + +#undef REQUIRE_EXTENSIONS +#undef REQUIRE_PLUGIN +#include <updater> + +#pragma newdecls required +#pragma semicolon 1 + + + +public Plugin myinfo = +{ + name = "GOKZ Slay On End", + author = "DanZay", + description = "Adds option to slay the player upon ending their timer", + version = GOKZ_VERSION, + url = GOKZ_SOURCE_URL +}; + +#define UPDATER_URL GOKZ_UPDATER_BASE_URL..."gokz-slayonend.txt" + +TopMenu gTM_Options; +TopMenuObject gTMO_CatGeneral; +TopMenuObject gTMO_ItemSlayOnEnd; + + + +// =====[ PLUGIN EVENTS ]===== + +public APLRes AskPluginLoad2(Handle myself, bool late, char[] error, int err_max) +{ + RegPluginLibrary("gokz-slayonend"); + return APLRes_Success; +} + +public void OnPluginStart() +{ + LoadTranslations("gokz-common.phrases"); + LoadTranslations("gokz-slayonend.phrases"); +} + +public void OnAllPluginsLoaded() +{ + if (LibraryExists("updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + + TopMenu topMenu; + if (LibraryExists("gokz-core") && ((topMenu = GOKZ_GetOptionsTopMenu()) != null)) + { + GOKZ_OnOptionsMenuReady(topMenu); + } +} + +public void OnLibraryAdded(const char[] name) +{ + if (StrEqual(name, "updater")) + { + Updater_AddPlugin(UPDATER_URL); + } +} + + + +// =====[ CLIENT EVENTS ]===== + +public void GOKZ_OnTimerEnd_Post(int client, int course, float time, int teleportsUsed) +{ + OnTimerEnd_SlayOnEnd(client); +} + +public void GOKZ_OnOptionChanged(int client, const char[] option, any newValue) +{ + OnOptionChanged_Options(client, option, newValue); +} + + + +// =====[ OTHER EVENTS ]===== + +public void GOKZ_OnOptionsMenuReady(TopMenu topMenu) +{ + OnOptionsMenuReady_Options(); + OnOptionsMenuReady_OptionsMenu(topMenu); +} + + + +// =====[ SLAY ON END ]===== + +void OnTimerEnd_SlayOnEnd(int client) +{ + if (GOKZ_GetOption(client, SLAYONEND_OPTION_NAME) == SlayOnEnd_Enabled) + { + CreateTimer(3.0, Timer_SlayPlayer, GetClientUserId(client)); + } +} + +public Action Timer_SlayPlayer(Handle timer, int userid) +{ + int client = GetClientOfUserId(userid); + if (IsValidClient(client)) + { + ForcePlayerSuicide(client); + } + return Plugin_Continue; +} + + + +// =====[ OPTIONS ]===== + +void OnOptionsMenuReady_Options() +{ + RegisterOption(); +} + +void RegisterOption() +{ + GOKZ_RegisterOption(SLAYONEND_OPTION_NAME, SLAYONEND_OPTION_DESCRIPTION, + OptionType_Int, SlayOnEnd_Disabled, 0, SLAYONEND_COUNT - 1); +} + +void OnOptionChanged_Options(int client, const char[] option, any newValue) +{ + if (StrEqual(option, SLAYONEND_OPTION_NAME)) + { + switch (newValue) + { + case SlayOnEnd_Disabled: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Slay On End - Disable"); + } + case SlayOnEnd_Enabled: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Slay On End - Enable"); + } + } + } +} + + + +// =====[ OPTIONS MENU ]===== + +void OnOptionsMenuReady_OptionsMenu(TopMenu topMenu) +{ + if (gTM_Options == topMenu) + { + return; + } + + gTM_Options = topMenu; + gTMO_CatGeneral = gTM_Options.FindCategory(GENERAL_OPTION_CATEGORY); + gTMO_ItemSlayOnEnd = gTM_Options.AddItem(SLAYONEND_OPTION_NAME, TopMenuHandler_SlayOnEnd, gTMO_CatGeneral); +} + +public void TopMenuHandler_SlayOnEnd(TopMenu topmenu, TopMenuAction action, TopMenuObject topobj_id, int param, char[] buffer, int maxlength) +{ + if (topobj_id != gTMO_ItemSlayOnEnd) + { + return; + } + + if (action == TopMenuAction_DisplayOption) + { + if (GOKZ_GetOption(param, SLAYONEND_OPTION_NAME) == SlayOnEnd_Disabled) + { + FormatEx(buffer, maxlength, "%T - %T", + "Options Menu - Slay On End", param, + "Options Menu - Disabled", param); + } + else + { + FormatEx(buffer, maxlength, "%T - %T", + "Options Menu - Slay On End", param, + "Options Menu - Enabled", param); + } + } + else if (action == TopMenuAction_SelectOption) + { + GOKZ_CycleOption(param, SLAYONEND_OPTION_NAME); + gTM_Options.Display(param, TopMenuPosition_LastCategory); + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-spec.sp b/sourcemod/scripting/gokz-spec.sp new file mode 100644 index 0000000..29f842f --- /dev/null +++ b/sourcemod/scripting/gokz-spec.sp @@ -0,0 +1,323 @@ +#include <sourcemod> + +#include <cstrike> + +#include <gokz/core> + +#undef REQUIRE_EXTENSIONS +#undef REQUIRE_PLUGIN +#include <updater> + +#pragma newdecls required +#pragma semicolon 1 + + + +public Plugin myinfo = +{ + name = "GOKZ Spectate Menu", + author = "DanZay", + description = "Provides easy ways to spectate players", + version = GOKZ_VERSION, + url = GOKZ_SOURCE_URL +}; + +#define UPDATER_URL GOKZ_UPDATER_BASE_URL..."gokz-spec.txt" + + + +// =====[ PLUGIN EVENTS ]===== + +public APLRes AskPluginLoad2(Handle myself, bool late, char[] error, int err_max) +{ + RegPluginLibrary("gokz-spec"); + return APLRes_Success; +} + +public void OnPluginStart() +{ + LoadTranslations("common.phrases"); + LoadTranslations("gokz-common.phrases"); + LoadTranslations("gokz-spec.phrases"); + + RegisterCommands(); +} + +public void OnAllPluginsLoaded() +{ + if (LibraryExists("updater")) + { + Updater_AddPlugin(UPDATER_URL); + } +} + +public void OnLibraryAdded(const char[] name) +{ + if (StrEqual(name, "updater")) + { + Updater_AddPlugin(UPDATER_URL); + } +} + + + +// =====[ SPEC MENU ]===== + +int DisplaySpecMenu(int client, bool useFilter = false, char[] filter = "") +{ + Menu menu = new Menu(MenuHandler_Spec); + menu.SetTitle("%T", "Spec Menu - Title", client); + int menuItems = SpecMenuAddItems(client, menu, useFilter, filter); + if (menuItems == 0 || menuItems == 1) + { + delete menu; + } + else + { + menu.Display(client, MENU_TIME_FOREVER); + } + return menuItems; +} + +bool Spectate(int client) +{ + if (!CanSpectate(client)) + { + return false; + } + + GOKZ_JoinTeam(client, CS_TEAM_SPECTATOR); + + // Put player in free look mode and apply according movetype + SetEntProp(client, Prop_Send, "m_iObserverMode", 6); + SetEntityMoveType(client, MOVETYPE_OBSERVER); + return true; +} + +// Returns whether change to spectating the target was successful +bool SpectatePlayer(int client, int target, bool printMessage = true) +{ + if (!CanSpectate(client)) + { + return false; + } + + if (target == client) + { + Spectate(client); + return true; + } + else if (!IsPlayerAlive(target)) + { + if (printMessage) + { + GOKZ_PrintToChat(client, true, "%t", "Spectate Failure (Dead)"); + GOKZ_PlayErrorSound(client); + } + return false; + } + + GOKZ_JoinTeam(client, CS_TEAM_SPECTATOR); + SetEntProp(client, Prop_Send, "m_iObserverMode", 4); + SetEntPropEnt(client, Prop_Send, "m_hObserverTarget", target); + + return true; +} + +bool CanSpectate(int client) +{ + return !IsPlayerAlive(client) || GOKZ_GetPaused(client) || GOKZ_GetCanPause(client); +} + +public int MenuHandler_Spec(Menu menu, MenuAction action, int param1, int param2) +{ + if (action == MenuAction_Select) + { + char info[16]; + menu.GetItem(param2, info, sizeof(info)); + int target = GetClientOfUserId(StringToInt(info)); + + if (!IsValidClient(target)) + { + GOKZ_PrintToChat(param1, true, "%t", "Player No Longer Valid"); + GOKZ_PlayErrorSound(param1); + DisplaySpecMenu(param1); + } + else if (!SpectatePlayer(param1, target)) + { + DisplaySpecMenu(param1); + } + } + else if (action == MenuAction_End) + { + delete menu; + } + return 0; +} + +// Returns number of items added to the menu +int SpecMenuAddItems(int client, Menu menu, bool useFilter, char[] filter) +{ + char display[MAX_NAME_LENGTH + 4]; + int targetCount = 0; + int latestResult; + + for (int i = 1; i <= MaxClients; i++) + { + if (!IsClientInGame(i) || !IsPlayerAlive(i) || i == client) + { + continue; + } + if (useFilter) + { + FormatEx(display, sizeof(display), "%N", i); + if (StrContains(display, filter, false) != -1) + { + if (IsFakeClient(i)) + { + FormatEx(display, sizeof(display), "BOT %N", i); + } + } + else // If it doesn't fit the filter, move on + { + continue; + } + } + else + { + if (IsFakeClient(i)) + { + FormatEx(display, sizeof(display), "BOT %N", i); + } + else + { + FormatEx(display, sizeof(display), "%N", i); + } + } + latestResult = i; + menu.AddItem(IntToStringEx(GetClientUserId(i)), display, ITEMDRAW_DEFAULT); + targetCount++; + } + // The only spectate-able player is the latest result, this happens when the player issuing the command also fits in the filter + if (targetCount == 1) + { + SpectatePlayer(client, latestResult); + } + + return targetCount; +} + + + +// =====[ COMMANDS ]===== + +void RegisterCommands() +{ + RegConsoleCmd("sm_spec", CommandSpec, "[KZ] Spectate another player. Usage: !spec <player>"); + RegConsoleCmd("sm_specs", CommandSpecs, "[KZ] List currently spectating players in chat."); + RegConsoleCmd("sm_speclist", CommandSpecs, "[KZ] List currently spectating players in chat."); +} + +public Action CommandSpec(int client, int args) +{ + // If no arguments, display the spec menu + if (args < 1) + { + if (DisplaySpecMenu(client) == 0) + { + // No targets, so just join spec + Spectate(client); + } + } + // Otherwise try to spectate the player + else + { + char specifiedPlayer[MAX_NAME_LENGTH]; + GetCmdArg(1, specifiedPlayer, sizeof(specifiedPlayer)); + + char targetName[MAX_TARGET_LENGTH]; + int targetList[1], targetCount; + bool tnIsML; + int flags = COMMAND_FILTER_NO_MULTI | COMMAND_FILTER_NO_IMMUNITY | COMMAND_FILTER_ALIVE; + + if ((targetCount = ProcessTargetString( + specifiedPlayer, + client, + targetList, + 1, + flags, + targetName, + sizeof(targetName), + tnIsML)) == 1) + { + SpectatePlayer(client, targetList[0]); + } + else if (targetCount == COMMAND_TARGET_AMBIGUOUS) + { + DisplaySpecMenu(client, true, specifiedPlayer); + } + else + { + ReplyToTargetError(client, targetCount); + } + + } + return Plugin_Handled; +} + +public Action CommandSpecs(int client, int args) +{ + int specs = 0; + char specNames[1024]; + + int target = IsPlayerAlive(client) ? client : GetObserverTarget(client); + int targetSpecs = 0; + char targetSpecNames[1024]; + + for (int i = 1; i <= MaxClients; i++) + { + if (IsClientInGame(i) && !IsFakeClient(i) && IsSpectating(i)) + { + specs++; + if (specs == 1) + { + FormatEx(specNames, sizeof(specNames), "{lime}%N", i); + } + else + { + Format(specNames, sizeof(specNames), "%s{grey}, {lime}%N", specNames, i); + } + + if (target != -1 && GetObserverTarget(i) == target) + { + targetSpecs++; + if (targetSpecs == 1) + { + FormatEx(targetSpecNames, sizeof(targetSpecNames), "{lime}%N", i); + } + else + { + Format(targetSpecNames, sizeof(targetSpecNames), "%s{grey}, {lime}%N", targetSpecNames, i); + } + } + } + } + + if (specs == 0) + { + GOKZ_PrintToChat(client, true, "%t", "Spectator List (None)"); + } + else + { + GOKZ_PrintToChat(client, true, "%t", "Spectator List", specs, specNames); + if (targetSpecs == 0) + { + GOKZ_PrintToChat(client, false, "%t", "Target Spectator List (None)", target); + } + else + { + GOKZ_PrintToChat(client, false, "%t", "Target Spectator List", target, targetSpecs, targetSpecNames); + } + } + return Plugin_Handled; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-tips.sp b/sourcemod/scripting/gokz-tips.sp new file mode 100644 index 0000000..8a84b9e --- /dev/null +++ b/sourcemod/scripting/gokz-tips.sp @@ -0,0 +1,357 @@ +#include <sourcemod> + +#include <gokz/core> +#include <gokz/tips> + +#include <autoexecconfig> + +#undef REQUIRE_EXTENSIONS +#undef REQUIRE_PLUGIN +#include <updater> + +#include <gokz/kzplayer> + +#pragma newdecls required +#pragma semicolon 1 + + + +public Plugin myinfo = +{ + name = "GOKZ Tips", + author = "DanZay", + description = "Prints tips to chat periodically based on loaded plugins", + version = GOKZ_VERSION, + url = GOKZ_SOURCE_URL +}; + +#define UPDATER_URL GOKZ_UPDATER_BASE_URL..."gokz-tips.txt" + +bool gC_PluginsWithTipsLoaded[TIPS_PLUGINS_COUNT]; +ArrayList g_TipPhrases; +int gI_CurrentTip; +Handle gH_TipTimer; +TopMenu gTM_Options; +TopMenuObject gTMO_CatGeneral; +TopMenuObject gTMO_ItemTips; +ConVar gCV_gokz_tips_interval; + + + +// =====[ PLUGIN EVENTS ]===== + +public APLRes AskPluginLoad2(Handle myself, bool late, char[] error, int err_max) +{ + RegPluginLibrary("gokz-tips"); + return APLRes_Success; +} + +public void OnPluginStart() +{ + LoadTranslations("gokz-common.phrases"); + LoadTranslations("gokz-tips.phrases"); + LoadTranslations("gokz-tips-tips.phrases"); + LoadTranslations("gokz-tips-core.phrases"); + + // Load translations of tips for other GOKZ plugins + char translation[PLATFORM_MAX_PATH]; + for (int i = 0; i < TIPS_PLUGINS_COUNT; i++) + { + FormatEx(translation, sizeof(translation), "gokz-tips-%s.phrases", gC_PluginsWithTips[i]); + LoadTranslations(translation); + } + + CreateConVars(); + RegisterCommands(); + CreateTipsTimer(); +} + +public void OnAllPluginsLoaded() +{ + if (LibraryExists("updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + + char gokzPlugin[PLATFORM_MAX_PATH]; + for (int i = 0; i < TIPS_PLUGINS_COUNT; i++) + { + FormatEx(gokzPlugin, sizeof(gokzPlugin), "gokz-%s", gC_PluginsWithTips[i]); + gC_PluginsWithTipsLoaded[i] = LibraryExists(gokzPlugin); + } + + TopMenu topMenu; + if (LibraryExists("gokz-core") && ((topMenu = GOKZ_GetOptionsTopMenu()) != null)) + { + GOKZ_OnOptionsMenuReady(topMenu); + } +} + +public void OnLibraryAdded(const char[] name) +{ + if (StrEqual(name, "updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + + char gokzPlugin[PLATFORM_MAX_PATH]; + for (int i = 0; i < TIPS_PLUGINS_COUNT; i++) + { + FormatEx(gokzPlugin, sizeof(gokzPlugin), "gokz-%s", gC_PluginsWithTips[i]); + gC_PluginsWithTipsLoaded[i] = gC_PluginsWithTipsLoaded[i] || StrEqual(name, gokzPlugin); + } +} + +public void OnLibraryRemoved(const char[] name) +{ + char gokzPlugin[PLATFORM_MAX_PATH]; + for (int i = 0; i < TIPS_PLUGINS_COUNT; i++) + { + FormatEx(gokzPlugin, sizeof(gokzPlugin), "gokz-%s", gC_PluginsWithTips[i]); + gC_PluginsWithTipsLoaded[i] = gC_PluginsWithTipsLoaded[i] && !StrEqual(name, gokzPlugin); + } +} + + + +// =====[ CLIENT EVENTS ]===== + +public void GOKZ_OnOptionChanged(int client, const char[] option, any newValue) +{ + OnOptionChanged_Options(client, option, newValue); +} + + + +// =====[ OTHER EVENTS ]===== + +public void OnMapStart() +{ + LoadTipPhrases(); +} + +public void GOKZ_OnOptionsMenuReady(TopMenu topMenu) +{ + OnOptionsMenuReady_Options(); + OnOptionsMenuReady_OptionsMenu(topMenu); +} + + + +// =====[ CONVARS ]===== + +void CreateConVars() +{ + AutoExecConfig_SetFile("gokz-tips", "sourcemod/gokz"); + AutoExecConfig_SetCreateFile(true); + + gCV_gokz_tips_interval = AutoExecConfig_CreateConVar("gokz_tips_interval", "75", "How often GOKZ tips are printed to chat in seconds.", _, true, 1.0, false); + gCV_gokz_tips_interval.AddChangeHook(OnConVarChanged); + + AutoExecConfig_ExecuteFile(); + AutoExecConfig_CleanFile(); +} + +public void OnConVarChanged(ConVar convar, const char[] oldValue, const char[] newValue) +{ + if (convar == gCV_gokz_tips_interval) + { + CreateTipsTimer(); + } +} + + + +// =====[ TIPS ]===== + +void LoadTipPhrases() +{ + if (g_TipPhrases == null) + { + g_TipPhrases = new ArrayList(64, 0); + } + else + { + g_TipPhrases.Clear(); + } + + char tipsPath[PLATFORM_MAX_PATH]; + + BuildPath(Path_SM, tipsPath, sizeof(tipsPath), "translations/%s", TIPS_TIPS); + LoadTipPhrasesFromFile(tipsPath); + + BuildPath(Path_SM, tipsPath, sizeof(tipsPath), "translations/%s", TIPS_CORE); + LoadTipPhrasesFromFile(tipsPath); + + // Load tips for other loaded GOKZ plugins + for (int i = 0; i < TIPS_PLUGINS_COUNT; i++) + { + if (gC_PluginsWithTipsLoaded[i]) + { + BuildPath(Path_SM, tipsPath, sizeof(tipsPath), "translations/gokz-tips-%s.phrases.txt", gC_PluginsWithTips[i]); + LoadTipPhrasesFromFile(tipsPath); + } + } + + ShuffleTipPhrases(); +} + +void LoadTipPhrasesFromFile(const char[] filePath) +{ + KeyValues kv = new KeyValues("Phrases"); + if (!kv.ImportFromFile(filePath)) + { + SetFailState("Failed to load file: \"%s\".", filePath); + } + + char phraseName[64]; + kv.GotoFirstSubKey(true); + do + { + kv.GetSectionName(phraseName, sizeof(phraseName)); + g_TipPhrases.PushString(phraseName); + } while (kv.GotoNextKey(true)); + + delete kv; +} + +void ShuffleTipPhrases() +{ + for (int i = g_TipPhrases.Length - 1; i >= 1; i--) + { + int j = GetRandomInt(0, i); + char tempStringI[64]; + g_TipPhrases.GetString(i, tempStringI, sizeof(tempStringI)); + char tempStringJ[64]; + g_TipPhrases.GetString(j, tempStringJ, sizeof(tempStringJ)); + g_TipPhrases.SetString(i, tempStringJ); + g_TipPhrases.SetString(j, tempStringI); + } +} + +void CreateTipsTimer() +{ + if (gH_TipTimer != null) + { + delete gH_TipTimer; + } + gH_TipTimer = CreateTimer(gCV_gokz_tips_interval.FloatValue, Timer_PrintTip, _, TIMER_REPEAT); +} + +public Action Timer_PrintTip(Handle timer) +{ + char tip[256]; + g_TipPhrases.GetString(gI_CurrentTip, tip, sizeof(tip)); + + for (int client = 1; client <= MaxClients; client++) + { + KZPlayer player = KZPlayer(client); + if (player.InGame && player.Tips != Tips_Disabled) + { + GOKZ_PrintToChat(client, true, "%t", tip); + } + } + + gI_CurrentTip = NextIndex(gI_CurrentTip, g_TipPhrases.Length); + return Plugin_Continue; +} + + + +// =====[ OPTIONS ]===== + +void OnOptionsMenuReady_Options() +{ + RegisterOption(); +} + +void RegisterOption() +{ + GOKZ_RegisterOption(TIPS_OPTION_NAME, TIPS_OPTION_DESCRIPTION, + OptionType_Int, Tips_Enabled, 0, TIPS_COUNT - 1); +} + +void OnOptionChanged_Options(int client, const char[] option, any newValue) +{ + if (StrEqual(option, TIPS_OPTION_NAME)) + { + switch (newValue) + { + case Tips_Disabled: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Tips - Disable"); + } + case Tips_Enabled: + { + GOKZ_PrintToChat(client, true, "%t", "Option - Tips - Enable"); + } + } + } +} + + + +// =====[ OPTIONS MENU ]===== + +void OnOptionsMenuReady_OptionsMenu(TopMenu topMenu) +{ + if (gTM_Options == topMenu) + { + return; + } + + gTM_Options = topMenu; + gTMO_CatGeneral = gTM_Options.FindCategory(GENERAL_OPTION_CATEGORY); + gTMO_ItemTips = gTM_Options.AddItem(TIPS_OPTION_NAME, TopMenuHandler_Tips, gTMO_CatGeneral); +} + +public void TopMenuHandler_Tips(TopMenu topmenu, TopMenuAction action, TopMenuObject topobj_id, int param, char[] buffer, int maxlength) +{ + if (topobj_id != gTMO_ItemTips) + { + return; + } + + if (action == TopMenuAction_DisplayOption) + { + if (GOKZ_GetOption(param, TIPS_OPTION_NAME) == Tips_Disabled) + { + FormatEx(buffer, maxlength, "%T - %T", + "Options Menu - Tips", param, + "Options Menu - Disabled", param); + } + else + { + FormatEx(buffer, maxlength, "%T - %T", + "Options Menu - Tips", param, + "Options Menu - Enabled", param); + } + } + else if (action == TopMenuAction_SelectOption) + { + GOKZ_CycleOption(param, TIPS_OPTION_NAME); + gTM_Options.Display(param, TopMenuPosition_LastCategory); + } +} + + + +// =====[ COMMANDS ]===== + +void RegisterCommands() +{ + RegConsoleCmd("sm_tips", CommandToggleTips, "[KZ] Toggle seeing help and tips."); +} + +public Action CommandToggleTips(int client, int args) +{ + if (GOKZ_GetOption(client, TIPS_OPTION_NAME) == Tips_Disabled) + { + GOKZ_SetOption(client, TIPS_OPTION_NAME, Tips_Enabled); + } + else + { + GOKZ_SetOption(client, TIPS_OPTION_NAME, Tips_Disabled); + } + return Plugin_Handled; +}
\ No newline at end of file diff --git a/sourcemod/scripting/gokz-tpanglefix.sp b/sourcemod/scripting/gokz-tpanglefix.sp new file mode 100644 index 0000000..6297795 --- /dev/null +++ b/sourcemod/scripting/gokz-tpanglefix.sp @@ -0,0 +1,277 @@ +#include <sourcemod> + +#include <dhooks> + +#include <gokz/core> +#include <gokz/tpanglefix> + +#include <autoexecconfig> + +#undef REQUIRE_EXTENSIONS +#undef REQUIRE_PLUGIN +#include <updater> + +#pragma newdecls required +#pragma semicolon 1 + + + +public Plugin myinfo = +{ + name = "GOKZ Teleport Angle Fix", + author = "zer0.k", + description = "Fix teleporting not modifying player's view angles due to packet loss", + version = GOKZ_VERSION, + url = "https://github.com/KZGlobalTeam/gokz" +}; + +#define UPDATER_URL GOKZ_UPDATER_BASE_URL..."gokz-tpanglefix.txt" + +TopMenu gTM_Options; +TopMenuObject gTMO_CatGeneral; +TopMenuObject gTMO_ItemTPAngleFix; +Address gA_ViewAnglePatchAddress; +bool gB_EnableFix[MAXPLAYERS + 1]; +DynamicDetour gH_WriteViewAngleUpdate; +int gI_ClientOffset; + +// =====[ PLUGIN EVENTS ]===== + +public APLRes AskPluginLoad2(Handle myself, bool late, char[] error, int err_max) +{ + RegPluginLibrary("gokz-tpanglefix"); + return APLRes_Success; +} + +public void OnPluginStart() +{ + LoadTranslations("gokz-common.phrases"); + LoadTranslations("gokz-tpanglefix.phrases"); + + SetupPatch(); + HookEvents(); + RegisterCommands(); +} + +void SetupPatch() +{ + GameData gamedataConf = LoadGameConfigFile("gokz-tpanglefix.games"); + if (gamedataConf == null) + { + SetFailState("Failed to load gokz-tpanglefix gamedata"); + } + // Get the patching address + Address addr = GameConfGetAddress(gamedataConf, "WriteViewAngleUpdate"); + if(addr == Address_Null) + { + SetFailState("Can't find WriteViewAngleUpdate address."); + } + + // Get the offset from the start of the signature to the start of our patch area. + int offset = GameConfGetOffset(gamedataConf, "WriteViewAngleUpdateReliableOffset"); + if(offset == -1) + { + SetFailState("Can't find WriteViewAngleUpdateReliableOffset in gamedata."); + } + gA_ViewAnglePatchAddress = view_as<Address>(addr + view_as<Address>(offset)); +} + +void HookEvents() +{ + GameData gamedataConf = LoadGameConfigFile("gokz-tpanglefix.games"); + if (gamedataConf == null) + { + SetFailState("Failed to load gokz-tpanglefix gamedata"); + } + gH_WriteViewAngleUpdate = DynamicDetour.FromConf(gamedataConf, "CGameClient::WriteViewAngleUpdate"); + + if (gH_WriteViewAngleUpdate == INVALID_HANDLE) + { + SetFailState("Failed to find CGameClient::WriteViewAngleUpdate function signature"); + } + + if (!gH_WriteViewAngleUpdate.Enable(Hook_Pre, DHooks_OnWriteViewAngleUpdate_Pre)) + { + SetFailState("Failed to enable detour on CGameClient::WriteViewAngleUpdate"); + } + // Prevent the server from crashing. + FindConVar("sv_parallel_sendsnapshot").SetBool(false); + FindConVar("sv_parallel_sendsnapshot").AddChangeHook(OnParallelSendSnapshotCvarChanged); + + gI_ClientOffset = gamedataConf.GetOffset("ClientIndexOffset"); + if (gI_ClientOffset == -1) + { + SetFailState("Failed to get ClientIndexOffset offset."); + } +} + +void OnParallelSendSnapshotCvarChanged(ConVar convar, const char[] oldValue, const char[] newValue) +{ + if (convar.BoolValue) + { + convar.BoolValue = false; + } +} + +public MRESReturn DHooks_OnWriteViewAngleUpdate_Pre(Address pThis) +{ + int client = LoadFromAddress(pThis + view_as<Address>(gI_ClientOffset), NumberType_Int32); + if (gB_EnableFix[client]) + { + PatchAngleFix(); + } + else + { + RestoreAngleFix(); + } + return MRES_Ignored; +} + +void PatchAngleFix() +{ + if (LoadFromAddress(gA_ViewAnglePatchAddress, NumberType_Int8) == 0) + { + StoreToAddress(gA_ViewAnglePatchAddress, 1, NumberType_Int8); + } +} + +void RestoreAngleFix() +{ + if (LoadFromAddress(gA_ViewAnglePatchAddress, NumberType_Int8) == 1) + { + StoreToAddress(gA_ViewAnglePatchAddress, 0, NumberType_Int8); + } +} + +bool ToggleAngleFix(int client) +{ + gB_EnableFix[client] = !gB_EnableFix[client]; + return gB_EnableFix[client]; +} + +public void OnAllPluginsLoaded() +{ + if (LibraryExists("updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + + TopMenu topMenu; + if (LibraryExists("gokz-core") && ((topMenu = GOKZ_GetOptionsTopMenu()) != null)) + { + GOKZ_OnOptionsMenuReady(topMenu); + } +} + +public void OnLibraryAdded(const char[] name) +{ + if (StrEqual(name, "updater")) + { + Updater_AddPlugin(UPDATER_URL); + } + +} + +// =====[ CLIENT EVENTS ]===== + +public void GOKZ_OnOptionChanged(int client, const char[] option, any newValue) +{ + OnOptionChanged_Options(client, option, newValue); +} + +// =====[ OTHER EVENTS ]===== + +public void GOKZ_OnOptionsMenuReady(TopMenu topMenu) +{ + OnOptionsMenuReady_Options(); + OnOptionsMenuReady_OptionsMenu(topMenu); +} + + +// =====[ OPTIONS ]===== + +void OnOptionsMenuReady_Options() +{ + RegisterOption(); +} + +void RegisterOption() +{ + GOKZ_RegisterOption(TPANGLEFIX_OPTION_NAME, TPANGLEFIX_OPTION_DESCRIPTION, + OptionType_Int, TPAngleFix_Disabled, 0, TPANGLEFIX_COUNT - 1); +} + +void OnOptionChanged_Options(int client, const char[] option, any newValue) +{ + if (StrEqual(option, TPANGLEFIX_OPTION_NAME)) + { + gB_EnableFix[client] = newValue; + switch (newValue) + { + case TPAngleFix_Disabled: + { + GOKZ_PrintToChat(client, true, "%t", "Option - TP Angle Fix - Disable"); + } + case TPAngleFix_Enabled: + { + GOKZ_PrintToChat(client, true, "%t", "Option - TP Angle Fix - Enable"); + } + } + } +} + +// =====[ OPTIONS MENU ]===== + +void OnOptionsMenuReady_OptionsMenu(TopMenu topMenu) +{ + if (gTM_Options == topMenu) + { + return; + } + + gTM_Options = topMenu; + gTMO_CatGeneral = gTM_Options.FindCategory(GENERAL_OPTION_CATEGORY); + gTMO_ItemTPAngleFix = gTM_Options.AddItem(TPANGLEFIX_OPTION_NAME, TopMenuHandler_TPAngleFix, gTMO_CatGeneral); +} + +public void TopMenuHandler_TPAngleFix(TopMenu topmenu, TopMenuAction action, TopMenuObject topobj_id, int param, char[] buffer, int maxlength) +{ + if (topobj_id != gTMO_ItemTPAngleFix) + { + return; + } + + if (action == TopMenuAction_DisplayOption) + { + if (GOKZ_GetOption(param, TPANGLEFIX_OPTION_NAME) == TPAngleFix_Disabled) + { + FormatEx(buffer, maxlength, "%T - %T", + "Options Menu - TP Angle Fix", param, + "Options Menu - Disabled", param); + } + else + { + FormatEx(buffer, maxlength, "%T - %T", + "Options Menu - TP Angle Fix", param, + "Options Menu - Enabled", param); + } + } + else if (action == TopMenuAction_SelectOption) + { + GOKZ_CycleOption(param, TPANGLEFIX_OPTION_NAME); + gTM_Options.Display(param, TopMenuPosition_LastCategory); + } +} + +// =====[ COMMANDS ]===== + +void RegisterCommands() +{ + RegConsoleCmd("sm_tpafix", CommandTPAFix, "[KZ] Toggle teleport angle fix."); +} + +public Action CommandTPAFix(int client, int args) +{ + GOKZ_SetOption(client, TPANGLEFIX_OPTION_NAME, ToggleAngleFix(client)); + return Plugin_Handled; +}
\ No newline at end of file diff --git a/sourcemod/scripting/include/GlobalAPI.inc b/sourcemod/scripting/include/GlobalAPI.inc new file mode 100644 index 0000000..8813645 --- /dev/null +++ b/sourcemod/scripting/include/GlobalAPI.inc @@ -0,0 +1,822 @@ +// ================== DOUBLE INCLUDE ========================= // + +#if defined _GlobalAPI_included_ +#endinput +#endif +#define _GlobalAPI_included_ + +// ======================= DEFINITIONS ======================= // + +#define DEFAULT_DATA 0 +#define DEFAULT_INT -1 +#define DEFAULT_STRING "" +#define DEFAULT_FLOAT -1.0 +#define DEFAULT_BOOL view_as<bool>(-1) + +#define GlobalAPI_Plugin_Version "2.0.0" +#define GlobalAPI_Plugin_Desc "Plugin helper for GlobalAPI Production & Staging" +#define GlobalAPI_Plugin_Url "https://bitbucket.org/kztimerglobalteam/GlobalAPI-SMPlugin" +#define GlobalAPI_Plugin_NameVersion "GlobalAPI Plugin " ... GlobalAPI_Plugin_Version + +#define GlobalAPI_Backend_Version "v2.0" +#define GlobalAPI_Backend_Staging_Version "v2.0" +#define GlobalAPI_BaseUrl "https://kztimerglobal.com/api/" ... GlobalAPI_Backend_Version +#define GlobalAPI_Staging_BaseUrl "https://globalapi.ruto.sh/api/" ... GlobalAPI_Backend_Staging_Version + +#define GlobalAPI_Max_BaseUrl_Length 128 +#define GlobalAPI_Max_QueryParam_Num 20 +#define GlobalAPI_Max_QueryParam_Length 64 +#define GlobalAPI_Max_QueryParams_Length (GlobalAPI_Max_QueryParam_Num * GlobalAPI_Max_QueryParam_Length) +#define GlobalAPI_Max_QueryUrl_Length (GlobalAPI_Max_QueryParams_Length + GlobalAPI_Max_BaseUrl_Length) +#define GlobalAPI_Max_QueryParam_Array_Length 64 + +#define GlobalAPI_Max_APIKey_Length 128 +#define GlobalAPI_Max_PluginName_Length 64 +#define GlobalAPI_Max_PluginVersion_Length 32 +#define GlobalAPI_Data_File_Extension "GAPI" + +// ======================= INCLUDES ========================== // + +#include <GlobalAPI/requestdata> +#include <GlobalAPI/responses> +#include <GlobalAPI/stocks> + +// ======================= ENUMS ============================= // + +/** + * Defines what request method is used on requests + */ +enum +{ + GlobalAPIRequestType_GET = 0, /**< Request uses GET HTTP method */ + GlobalAPIRequestType_POST /**< Request uses POST HTTP method */ +}; + +/** + * Defines what accept type is used on requests + */ +enum +{ + GlobalAPIRequestAcceptType_JSON = 0, /**< Request uses application/json HTTP accept type */ + GlobalAPIRequestAcceptType_OctetStream /**< Request uses application/octet-stream HTTP accept type */ +}; + +/** + * Defines what content type is used on requests + */ +enum +{ + GlobalAPIRequestContentType_JSON = 0, /**< Request uses application/json HTTP content type */ + GlobalAPIRequestContentType_OctetStream /**< Request uses application/octet-stream HTTP content type */ +}; + +// ======================= TYPEDEFS ========================== // + +/* + Function types when API call finishes +*/ +typeset OnAPICallFinished +{ + /** + * Called when an API call has finished + * + * @param hResponse JSON_Object handle to the response + * @param hData GlobalAPIRequestData handle for the request + * @noreturn + */ + function void(JSON_Object hResponse, GlobalAPIRequestData hData); + + /** + * Called when an API call has finished + * + * @param hResponse JSON_Object handle to the response + * @param hData GlobalAPIRequestData handle for the request + * @param data Optional data that was passed + * @noreturn + */ + function void(JSON_Object hResponse, GlobalAPIRequestData hData, any data); +}; + +// ======================= FORWARDS ========================== // + +/** + * Called when GlobalAPI plugin is initialized, + * this means API Key is loaded and all the cvars are loaded + * + * @noreturn + */ +forward void GlobalAPI_OnInitialized(); + +/** + * Called when GlobalAPI plugin has failed a request + * + * @param request Handle to the request failed + * @param hData Handle to request's GlobalAPIRequestData + * @noreturn + */ +forward void GlobalAPI_OnRequestFailed(Handle request, GlobalAPIRequestData hData); + +/** + * Called when GlobalAPI plugin has started a request + * + * @param request Handle to the request started + * @param hData Handle to request's GlobalAPIRequestData + * @noreturn + */ +forward void GlobalAPI_OnRequestStarted(Handle request, GlobalAPIRequestData hData); + +/** + * Called when GlobalAPI plugin has finished a request + * + * @param request Handle to the request finished + * @param hData Handle to request's GlobalAPIRequestData + * @noreturn + */ +forward void GlobalAPI_OnRequestFinished(Handle request, GlobalAPIRequestData hData); + +// ======================= NATIVES =========================== // + +/** + * Gets a boolean of whether GlobalAPI plugin is initialized. + * + * @note See GlobalAPI_OnInitialized for the event version. + * @return Whether GlobalAPI plugin is initialized. + */ +native bool GlobalAPI_IsInit(); + +/** + * Gets the API Key used by GlobalAPI plugin + * + * @param buffer Buffer to store result in + * @param maxlength Max length of the buffer + * @noreturn + */ +native void GlobalAPI_GetAPIKey(char[] buffer, int maxlength); + +/** + * Gets whether GlobalAPI is using an API Key + * + * @note This does not mean the API Key is valid! + * @return Whether API Key is used by GlobalAPI plugin + */ +native bool GlobalAPI_HasAPIKey(); + +/** + * Gets whether GlobalAPI is using the staging endpoint + * + * @note It is not safe to call this before GlobalAPI_OnInitialized! + * @return Whether staging endpoint is used by GlobalAPI plugin + */ +native bool GlobalAPI_IsStaging(); + +/** + * Gets whether GlobalAPI is in debug mode + * + * @note It is not safe to call this before GlobalAPI_OnInitialized! + * @return Whether GlobalAPI plugin is in debug mode + */ +native bool GlobalAPI_IsDebugging(); + +/** + * Sends a request in GlobalAPI plugin format + * + * @param hData Handle to GlobalAPIRequestData + * @return Whether the request was sent successfully + */ +native bool GlobalAPI_SendRequest(GlobalAPIRequestData hData); + +/** + * Sends a debug message to GlobalAPI plugin logs if debugging is enabled + * + * @param message Formatting rules + * @param ... Variable number of format parameters + * @note This is not safe to use before convars have loaded + * @return Whether the message was logged + */ +native bool GlobalAPI_DebugMessage(const char[] message, any ...); + +/** + * Starts a GET HTTP Request to /api/{version}/auth/status + * + * @param callback Callback when request has finished + * @param data Optional data to pass + * @return Whether request was successfully sent + */ +native bool GlobalAPI_GetAuthStatus(OnAPICallFinished callback = INVALID_FUNCTION, any data = DEFAULT_DATA); + +/** + * Starts a GET HTTP Request to /api/{version}/bans + * + * @param callback Callback when request has finished + * @param data Optional data to pass + * @param banTypes Ban types to query + * @param banTypesList -Unsupported at the moment- + * @param isExpired Whether to query for isExpired or not + * @param ipAddress IP address to query + * @param steamId64 SteamID64 to query + * @param steamId SteamID2 to query + * @param notesContain Notes to query + * @param statsContain Stats to query + * @param serverId Server ID to query + * @param createdSince Created since date to query + * @param updatedSince Updated since date to query + * @param offset Offset of the dataset to query + * @param limit Amount of items returned for the query + * @return Whether request was successfully sent + */ +native bool GlobalAPI_GetBans(OnAPICallFinished callback = INVALID_FUNCTION, any data = DEFAULT_DATA, const char[] banTypes = DEFAULT_STRING, + const char[] banTypesList = DEFAULT_STRING, bool isExpired = DEFAULT_BOOL, const char[] ipAddress = DEFAULT_STRING, + const char[] steamId64 = DEFAULT_STRING, const char[] steamId = DEFAULT_STRING, const char[] notesContain = DEFAULT_STRING, + const char[] statsContain = DEFAULT_STRING, int serverId = DEFAULT_INT, const char[] createdSince = DEFAULT_STRING, + const char[] updatedSince = DEFAULT_STRING, int offset = DEFAULT_INT, int limit = DEFAULT_INT); + +/** + * Starts a POST HTTP Request to /api/{version}/bans + * + * @param callback Callback when request has finished + * @param data Optional data to pass + * @param steamId SteamID2 of the user + * @param banType Type of the ban + * @param stats Stats of the ban + * @param notes Notes of the ban + * @param ipAddress IP address of the user + * @return Whether request was successfully sent + */ +native bool GlobalAPI_CreateBan(OnAPICallFinished callback = INVALID_FUNCTION, any data = DEFAULT_DATA, + const char[] steamId, const char[] banType, const char[] stats, + const char[] notes, const char[] ipAddress); + +/** + * Starts a GET HTTP Request to /api/{version}/jumpstats + * + * @param callback Callback when request has finished + * @param data Optional data to pass + * @param id Id to query + * @param serverId Server id to query + * @param steamId64 SteamID64 to query + * @param steamId SteamID2 to query + * @param jumpType Jump type to query + * @param steamId64List -Unsupported at the moment- + * @param jumpTypeList -Unsupported at the moment- + * @param greaterThanDistance Greater than distance to query + * @param lessThanDistance Less than distance to query + * @param isMsl Whether to query for isMsl or not + * @param isCrouchBind Whether to query for isCrouchBind or not + * @param isForwardBind Whether to query for isForwardBind or not + * @param isCrouchBoost Whether to query for isCrouchBoost or not + * @param updatedById Updated by id to query + * @param createdSince Created since date to query + * @param updatedSince Updated since date to query + * @param offset Offset of the dataset to query + * @param limit Amount of items returned for the query + * @return Whether request was successfully sent + */ +native bool GlobalAPI_GetJumpstats(OnAPICallFinished callback = INVALID_FUNCTION, any data = DEFAULT_DATA, int id = DEFAULT_INT, + int serverId = DEFAULT_INT, const char[] steamId64 = DEFAULT_STRING, const char[] steamId = DEFAULT_STRING, + const char[] jumpType = DEFAULT_STRING, const char[] steamId64List = DEFAULT_STRING, + const char[] jumpTypeList = DEFAULT_STRING, float greaterThanDistance = DEFAULT_FLOAT, + float lessThanDistance = DEFAULT_FLOAT, bool isMsl = DEFAULT_BOOL, bool isCrouchBind = DEFAULT_BOOL, + bool isForwardBind = DEFAULT_BOOL, bool isCrouchBoost = DEFAULT_BOOL, int updatedById = DEFAULT_INT, + const char[] createdSince = DEFAULT_STRING, const char[] updatedSince = DEFAULT_STRING, + int offset = DEFAULT_INT, int limit = DEFAULT_INT); + +/** + * Starts a POST HTTP Request to /api/{version}/jumpstats + * + * @param callback Callback when request has finished + * @param data Optional data to pass + * @param steamId SteamID2 of the user + * @param jumpType Type of the jump + * @param distance Distance of the jump + * @param jumpJsonInfo Data of the jump + * @param tickRate Tickrate of the server + * @param mslCount Msl count of the jump + * @param isCrouchBind Whether crouch bind was used + * @param isForwardBind Whether forward bind was used + * @param isCrouchBoost Whether crouch boost was used + * @param strafeCount Strafe count of the jump + * @return Whether request was successfully sent + */ +native bool GlobalAPI_CreateJumpstat(OnAPICallFinished callback = INVALID_FUNCTION, any data = DEFAULT_DATA, const char[] steamId, + int jumpType, float distance, const char[] jumpJsonInfo, int tickRate, int mslCount, + bool isCrouchBind, bool isForwardBind, bool isCrouchBoost, int strafeCount); + +/** + * Starts a GET HTTP Request to /api/{version}/jumpstats/{jump_type}/top + * + * @param callback Callback when request has finished + * @param data Optional data to pass + * @param jumpType Jump type to query + * @param id Id to query + * @param serverId Server Id to query + * @param steamId64 SteamID64 to query + * @param steamId SteamID2 to query + * @param steamId64List -Unsupported at the moment- + * @param jumpTypeList -Unsupported at the moment- + * @param greaterThanDistance Greater than distance to query + * @param lessThanDistance Less than distance to query + * @param isMsl Whether to query for isMsl or not + * @param isCrouchBind Whether to query for isCrouchBind or not + * @param isForwardBind Whether to query for isForwardBind or not + * @param isCrouchBoost Whether to query for isCrouchBoost or not + * @param updatedById Updated by id to query + * @param createdSince Created since date to query + * @param updatedSince Updated since date to query + * @param offset Offset of the dataset to query + * @param limit Amount of items returned for the query + * @return Whether request was successfully sent + */ +native bool GlobalAPI_GetJumpstatTop(OnAPICallFinished callback = INVALID_FUNCTION, any data = DEFAULT_DATA, const char[] jumpType, + int id = DEFAULT_INT, int serverId = DEFAULT_INT, const char[] steamId64 = DEFAULT_STRING, + const char[] steamId = DEFAULT_STRING, const char[] steamId64List = DEFAULT_STRING, + const char[] jumpTypeList = DEFAULT_STRING, float greaterThanDistance = DEFAULT_FLOAT, + float lessThanDistance = DEFAULT_FLOAT, bool isMsl = DEFAULT_BOOL, bool isCrouchBind = DEFAULT_BOOL, + bool isForwardBind = DEFAULT_BOOL, bool isCrouchBoost = DEFAULT_BOOL, int updatedById = DEFAULT_INT, + const char[] createdSince = DEFAULT_STRING, const char[] updatedSince = DEFAULT_STRING, + int offset = DEFAULT_INT, int limit = DEFAULT_INT); + +/** + * Starts a GET HTTP Request to /api/{version}/jumpstats/{jump_type}/top30 + * + * @param callback Callback when request has finished + * @param data Optional data to pass + * @param jumpType Jump type to query + * @return Whether request was successfully sent + */ +native bool GlobalAPI_GetJumpstatTop30(OnAPICallFinished callback = INVALID_FUNCTION, any data = DEFAULT_DATA, const char[] jumpType); + +/** + * Starts a GET HTTP Request to /api/{version}/maps + * + * @param callback Callback when request has finished + * @param data Optional data to pass + * @param name Map name to query + * @param largerThanFilesize Larger than filesize to query + * @param smallerThanFilesize Smaller than filesize to query + * @param isValidated Whether to query for isValidated or not + * @param difficulty Map difficulty to query + * @param createdSince Created since date to query + * @param updatedSince Updated since date to query + * @param offset Offset of the dataset to query + * @param limit Amount of items returned for the query + * @return Whether request was successfully sent + */ +native bool GlobalAPI_GetMaps(OnAPICallFinished callback = INVALID_FUNCTION, any data = DEFAULT_DATA, const char[] name = DEFAULT_STRING, + int largerThanFilesize = DEFAULT_INT, int smallerThanFilesize = DEFAULT_INT, bool isValidated = DEFAULT_BOOL, + int difficulty = DEFAULT_INT, const char[] createdSince = DEFAULT_STRING, const char[] updatedSince = DEFAULT_STRING, + int offset = DEFAULT_INT, int limit = DEFAULT_INT); + +/** + * Starts a GET HTTP Request to /api/{version}/maps/{id} + * + * @param callback Callback when request has finished + * @param data Optional data to pass + * @param id Map id to query + * @return Whether request was successfully sent + */ +native bool GlobalAPI_GetMapById(OnAPICallFinished callback = INVALID_FUNCTION, any data = DEFAULT_DATA, int id); + +/** + * Starts a GET HTTP Request to /api/{version}/maps/name/{map_name} + * + * @param callback Callback when request has finished + * @param data Optional data to pass + * @param name Map name to query + * @return Whether request was successfully sent + */ +native bool GlobalAPI_GetMapByName(OnAPICallFinished callback = INVALID_FUNCTION, any data = DEFAULT_DATA, const char[] name); + +/** + * Starts a GET HTTP Request to /api/{version}/modes + * + * @param callback Callback when request has finished + * @param data Optional data to pass + * @return Whether request was successfully sent + */ +native bool GlobalAPI_GetModes(OnAPICallFinished callback = INVALID_FUNCTION, any data = DEFAULT_DATA); + +/** + * Starts a GET HTTP Request to /api/{version}/modes/id/{id} + * + * @param callback Callback when request has finished + * @param data Optional data to pass + * @param id Mode id to query + * @return Whether request was successfully sent + */ +native bool GlobalAPI_GetModeById(OnAPICallFinished callback = INVALID_FUNCTION, any data = DEFAULT_DATA, int id); + +/** + * Starts a GET HTTP Request to /api/{version}/modes/name/{mode_name} + * + * @param callback Callback when request has finished + * @param data Optional data to pass + * @param name Mode name to query + * @return Whether request was successfully sent + */ +native bool GlobalAPI_GetModeByName(OnAPICallFinished callback = INVALID_FUNCTION, any data = DEFAULT_DATA, const char[] name); + +/** + * Starts a GET HTTP Request to /api/{version}/players + * + * @param callback Callback when request has finished + * @param data Optional data to pass + * @param steamId SteamID2 to query + * @param isBanned Whether to query for isBanned or not + * @param totalRecords Total records to query + * @param ipAddress IP address to query + * @param steamId64List -Unsupported at the moment- + * @return Whether request was successfully sent + */ +native bool GlobalAPI_GetPlayers(OnAPICallFinished callback = INVALID_FUNCTION, any data = DEFAULT_DATA, const char[] steamId = DEFAULT_STRING, + bool isBanned = DEFAULT_BOOL, int totalRecords = DEFAULT_INT, const char[] ipAddress = DEFAULT_STRING, + const char[] steamId64List = DEFAULT_STRING); + +/** + * Starts a GET HTTP Request to /api/{version}/players/steamid/{steamid} + * + * @param callback Callback when request has finished + * @param data Optional data to pass + * @param steamId SteamID2 to query + * @return Whether request was successfully sent + */ +native bool GlobalAPI_GetPlayerBySteamId(OnAPICallFinished callback = INVALID_FUNCTION, any data = DEFAULT_DATA, const char[] steamId); + +/** + * Starts a GET HTTP Request to /api/{version}/players/steamid/{steamid}/ip/{ip} + * + * @param callback Callback when request has finished + * @param data Optional data to pass + * @param steamId SteamID2 to query + * @param ipAddress IP address to query + * @return Whether request was successfully sent + */ +native bool GlobalAPI_GetPlayerBySteamIdAndIp(OnAPICallFinished callback = INVALID_FUNCTION, any data = DEFAULT_DATA, + const char[] steamId, const char[] ipAddress); + +/** + * Starts a POST HTTP Request to /api/{version}/records + * + * @param callback Callback when request has finished + * @param data Optional data to pass + * @param steamId SteamID2 of the user + * @param mapId Map id of the record + * @param mode Mode of the record + * @param stage Stage of the record + * @param tickRate Tickrate of the server + * @param teleports Teleport count of the record + * @param time Elapsed time of the record + * @return Whether request was successfully sent + */ +native bool GlobalAPI_CreateRecord(OnAPICallFinished callback = INVALID_FUNCTION, any data = DEFAULT_DATA, const char[] steamId, + int mapId, const char[] mode, int stage, int tickRate, int teleports, float time); + +/** + * Starts a GET HTTP Request to /api/{version}/records/place/{id} + * + * @note This is deprecated! + * @param callback Callback when request has finished + * @param data Optional data to pass + * @param id Id to query + * @return Whether request was successfully sent + */ +native bool GlobalAPI_GetRecordPlaceById(OnAPICallFinished callback = INVALID_FUNCTION, any data = DEFAULT_DATA, int id); + +/** + * Starts a GET HTTP Request to /api/{version}/records/top + * + * @param callback Callback when request has finished + * @param data Optional data to pass + * @param steamId SteamID2 to query + * @param steamId64 SteamID64 to query + * @param mapId Map id to query + * @param mapName Map name to query + * @param tickRate Tickrate to query + * @param stage Stage to query + * @param modes Mode(s) to query + * @param hasTeleports Whether to query for hasTeleports or not + * @param playerName Player name to query + * @param offset Offset of the dataset to query + * @param limit Amount of items returned for the query + * @return Whether request was successfully sent + */ +native bool GlobalAPI_GetRecordsTop(OnAPICallFinished callback = INVALID_FUNCTION, any data = DEFAULT_DATA, + const char[] steamId = DEFAULT_STRING, const char[] steamId64 = DEFAULT_STRING, int mapId = DEFAULT_INT, + const char[] mapName = DEFAULT_STRING, int tickRate = DEFAULT_INT, int stage = DEFAULT_INT, + const char[] modes = DEFAULT_STRING, bool hasTeleports = DEFAULT_BOOL, + const char[] playerName = DEFAULT_STRING, int offset = DEFAULT_INT, int limit = DEFAULT_INT); + +/** + * Starts a GET HTTP Request to /api/{version}/records/top/recent + * + * @param callback Callback when request has finished + * @param data Optional data to pass + * @param steamId SteamID2 to query + * @param steamId64 SteamID64 to query + * @param mapId Map id to query + * @param mapName Map name to query + * @param tickRate Tickrate to query + * @param stage Stage to query + * @param modes Mode(s) to query + * @param topAtLeast Place top at least to query + * @param topOverallAtLeast Place top overall at least to query + * @param hasTeleports Whether to query for hasTeleports or not + * @param createdSince Created since date to query + * @param playerName Player name to query + * @param offset Offset of the dataset to query + * @param limit Amount of items returned for the query + * @return Whether request was successfully sent + */ +native bool GlobalAPI_GetRecordsTopRecent(OnAPICallFinished callback = INVALID_FUNCTION, any data = DEFAULT_DATA, + const char[] steamId = DEFAULT_STRING, const char[] steamId64 = DEFAULT_STRING, + int mapId = DEFAULT_INT, const char[] mapName = DEFAULT_STRING, + int tickRate = DEFAULT_INT, int stage = DEFAULT_INT, + const char[] modes = DEFAULT_STRING, int topAtLeast = DEFAULT_INT, + int topOverallAtLeast = DEFAULT_INT, bool hasTeleports = DEFAULT_BOOL, + const char[] createdSince = DEFAULT_STRING, const char[] playerName = DEFAULT_STRING, + int offset = DEFAULT_INT, int limit = DEFAULT_INT); + +/** + * Starts a GET HTTP Request to /api/{version}/records/top/world_records + * + * @param callback Callback when request has finished + * @param data Optional data to pass + * @param ids Array of ids to query + * @param idsLength Length of the ids array + * @param mapIds Array of map ids to query + * @param mapIdsLength Length of the map ids array + * @param stages Array of stages to query + * @param stagesLength Length of the stages array + * @param modeIds Array of mode ids to query + * @param modeIdsLength Length of the mode ids array + * @param tickRates Array of tickrates to query + * @param tickRatesLength Length of the tickrates array + * @param hasTeleports Whether to query for hasTeleports or not + * @param mapTag Map tags to query + * @param offset Offset of the dataset to query + * @param limit Amount of items returned for the query + * @return Whether request was successfully sent + */ +native bool GlobalAPI_GetRecordsTopWorldRecords(OnAPICallFinished callback = INVALID_FUNCTION, any data = DEFAULT_DATA, + int[] ids = {}, int idsLength = DEFAULT_INT, + int[] mapIds = {}, int mapIdsLength = DEFAULT_INT, + int[] stages = {}, int stagesLength = DEFAULT_INT, + int[] modeIds = {}, int modeIdsLength = DEFAULT_INT, + int[] tickRates = {}, int tickRatesLength = DEFAULT_INT, + bool hasTeleports = DEFAULT_BOOL, char[] mapTag = DEFAULT_STRING, + int offset = DEFAULT_INT, int limit = DEFAULT_INT); + +/** + * Starts a GET HTTP Request to /api/{version}/servers + * + * @param callback Callback when request has finished + * @param data Optional data to pass + * @param id Id to query + * @param port Port to query + * @param ip IP address to query + * @param name Server name to query + * @param ownerSteamId64 Owner's steamid64 to query + * @param approvalStatus Approval status to query + * @param offset Offset of the dataset to query + * @param limit Amount of items returned for the query + * @return Whether request was successfully sent + */ +native bool GlobalAPI_GetServers(OnAPICallFinished callback = INVALID_FUNCTION, any data = DEFAULT_DATA, + int id = DEFAULT_INT, int port = DEFAULT_INT, const char[] ip = DEFAULT_STRING, + const char[] name = DEFAULT_STRING, const char[] ownerSteamId64 = DEFAULT_STRING, + int approvalStatus = DEFAULT_INT, int offset = DEFAULT_INT, int limit = DEFAULT_INT); + +/** + * Starts a GET HTTP Request to /api/{version}/servers/{id} + * + * @param callback Callback when request has finished + * @param data Optional data to pass + * @param id Id to query + * @return Whether request was successfully sent + */ +native bool GlobalAPI_GetServerById(OnAPICallFinished callback = INVALID_FUNCTION, any data = DEFAULT_DATA, int id); + +/** + * Starts a GET HTTP Request to /api/{version}/servers/name/{server_name} + * + * @param callback Callback when request has finished + * @param data Optional data to pass + * @param serverName Server name to query + * @return Whether request was successfully sent + */ +native bool GlobalAPI_GetServersByName(OnAPICallFinished callback = INVALID_FUNCTION, any data = DEFAULT_DATA, const char[] serverName); + +/** + * Starts a GET HTTP Request to /api/{version}/player_ranks + * + * @param callback Callback when request has finished + * @param data Optional data to pass + * @param pointsGreaterThan Points greater than to query + * @param averageGreaterThan Average greater than to query + * @param ratingGreaterThan Rating greater than to query + * @param finishesGreaterThan Finishes greater than to query + * @param steamId64List Comma-separated stirng of steamid64s to query + * @param recordFilterIds Array of record filter ids to query + * @param recordFilterIdsLength Length of the record filter ids array + * @param mapIds Array of map ids to query + * @param mapIdsLength Length of the map ids array + * @param stages Array of stages to query + * @param stagesLength Length of the stages array + * @param modeIds Array of mode ids to query + * @param modeIdsLength Length of the mode ids array + * @param tickRates Array of tickrates to query + * @param tickRatesLength Length of the tickrates array + * @param hasTeleports Whether to query for hasTeleports or not + * @param offset Offset of the dataset to query + * @param limit Amount of items returned for the query + * @return Whether request was successfully sent + */ +native bool GlobalAPI_GetPlayerRanks(OnAPICallFinished callback = INVALID_FUNCTION, any data = DEFAULT_DATA, + int pointsGreaterThan = DEFAULT_INT, float averageGreaterThan = DEFAULT_FLOAT, + float ratingGreaterThan = DEFAULT_FLOAT, int finishesGreaterThan = DEFAULT_INT, + const char[] steamId64List = DEFAULT_STRING, + int[] recordFilterIds = {}, int recordFilterIdsLength = DEFAULT_INT, + int[] mapIds = {}, int mapIdsLength = DEFAULT_INT, + int[] stages = {}, int stagesLength = DEFAULT_INT, + int[] modeIds = {}, int modeIdsLength = DEFAULT_INT, + int[] tickRates = {}, int tickRatesLength = DEFAULT_INT, + bool hasTeleports = DEFAULT_BOOL, int offset = DEFAULT_INT, int limit = DEFAULT_INT); + +/** + * Starts a GET HTTP Request to /api/{version}/record_filters + * + * @param callback Callback when request has finished + * @param data Optional data to pass + * @param ids Array of ids to query + * @param idsLength Length of the ids array + * @param mapIds Array of map ids to query + * @param mapIdsLength Length of the map ids array + * @param stages Array of stages to query + * @param stagesLength Length of the stages array + * @param modeIds Array of mode ids to query + * @param modeIdsLength Length of the mode ids array + * @param tickRates Array of tickrates to query + * @param tickRatesLength Length of the tickrates array + * @param hasTeleports Whether to query for hasTeleports or not + * @param offset Offset of the dataset to query + * @param limit Amount of items returned for the query + * @return Whether request was successfully sent + */ +native bool GlobalAPI_GetRecordFilters(OnAPICallFinished callback = INVALID_FUNCTION, any data = DEFAULT_DATA, + int[] ids = {}, int idsLength = DEFAULT_INT, + int[] mapIds = {}, int mapIdsLength = DEFAULT_INT, + int[] stages = {}, int stagesLength = DEFAULT_INT, + int[] modeIds = {}, int modeIdsLength = DEFAULT_INT, + int[] tickRates = {}, int tickRatesLength = DEFAULT_INT, + bool hasTeleports = DEFAULT_BOOL, bool isOverall = DEFAULT_BOOL, + int offset = DEFAULT_INT, int limit = DEFAULT_INT); + +/** + * Starts a GET HTTP Request to /api/{version}/record_filters/distributions + * + * @param callback Callback when request has finished + * @param data Optional data to pass + * @param ids Array of ids to query + * @param idsLength Length of the ids array + * @param mapIds Array of map ids to query + * @param mapIdsLength Length of the map ids array + * @param stages Array of stages to query + * @param stagesLength Length of the stages array + * @param modeIds Array of mode ids to query + * @param modeIdsLength Length of the mode ids array + * @param tickRates Array of tickrates to query + * @param tickRatesLength Length of the tickrates array + * @param hasTeleports Whether to query for hasTeleports or not + * @param offset Offset of the dataset to query + * @param limit Amount of items returned for the query + * @return Whether request was successfully sent + */ +native bool GlobalAPI_GetRecordFilterDistributions(OnAPICallFinished callback = INVALID_FUNCTION, any data = DEFAULT_DATA, + int[] ids = {}, int idsLength = DEFAULT_INT, + int[] mapIds = {}, int mapIdsLength = DEFAULT_INT, + int[] stages = {}, int stagesLength = DEFAULT_INT, + int[] modeIds = {}, int modeIdsLength = DEFAULT_INT, + int[] tickRates = {}, int tickRatesLength = DEFAULT_INT, + bool hasTeleports = DEFAULT_BOOL, bool isOverall = DEFAULT_BOOL, + int offset = DEFAULT_INT, int limit = DEFAULT_INT); + +/** + * Starts a GET HTTP Request to /api/{version}/records/replay/list + * + * @param callback Callback when request has finished + * @param data Optional data to pass + * @param offset Offset of the dataset to query + * @param limit Amount of items returned for the query + * @return Whether request was successfully sent + */ +native bool GlobalAPI_GetReplayList(OnAPICallFinished callback = INVALID_FUNCTION, any data = DEFAULT_DATA, + int offset = DEFAULT_INT, int limit = DEFAULT_INT); + +/** + * Starts a GET HTTP Request to /api/{version}/records/{recordId}/replay + * + * @param callback Callback when request has finished + * @param data Optional data to pass + * @param recordId Record id to query + * @return Whether request was successfully sent + */ +native bool GlobalAPI_GetReplayByRecordId(OnAPICallFinished callback = INVALID_FUNCTION, any data = DEFAULT_DATA, int recordId); +/** + * Starts a GET HTTP Request to /api/{version}/records/replay/{replayId} + * + * @param callback Callback when request has finished + * @param data Optional data to pass + * @param replayId Replay id to query + * @return Whether request was successfully sent + */ +native bool GlobalAPI_GetReplayByReplayId(OnAPICallFinished callback = INVALID_FUNCTION, any data = DEFAULT_DATA, int replayId); + +/** + * Starts a POST HTTP Request to /api/{version}/records/{recordId}/replay + * + * @param callback Callback when request has finished + * @param data Optional data to pass + * @param recordId Id of the record + * @param replayFile Path to the replay file + * @return Whether request was successfully sent + */ +native bool GlobalAPI_CreateReplayForRecordId(OnAPICallFinished callback = INVALID_FUNCTION, any data = DEFAULT_DATA, + int recordId, const char[] replayFile); + +// ======================= PLUGIN INFO ======================= // + +public SharedPlugin __pl_GlobalAPI = +{ + name = "GlobalAPI", + file = "GlobalAPI.smx", + #if defined REQUIRE_PLUGIN + required = 1, + #else + required = 0, + #endif +}; + +#if !defined REQUIRE_PLUGIN +public void __pl_GlobalAPI_SetNTVOptional() +{ + // Plugin + MarkNativeAsOptional("GlobalAPI_IsInit"); + MarkNativeAsOptional("GlobalAPI_GetAPIKey"); + MarkNativeAsOptional("GlobalAPI_HasAPIKey"); + MarkNativeAsOptional("GlobalAPI_IsStaging"); + MarkNativeAsOptional("GlobalAPI_IsDebugging"); + MarkNativeAsOptional("GlobalAPI_SendRequest"); + MarkNativeAsOptional("GlobalAPI_DebugMessage"); + + // Auth + MarkNativeAsOptional("GlobalAPI_GetAuthStatus"); + + // Bans + MarkNativeAsOptional("GlobalAPI_GetBans"); + MarkNativeAsOptional("GlobalAPI_CreateBan"); + + // Jumpstats + MarkNativeAsOptional("GlobalAPI_GetJumpstats"); + MarkNativeAsOptional("GlobalAPI_GetJumpstatTop"); + MarkNativeAsOptional("GlobalAPI_GetJumpstatTop30"); + + // Maps + MarkNativeAsOptional("GlobalAPI_GetMaps"); + MarkNativeAsOptional("GlobalAPI_GetMapById"); + MarkNativeAsOptional("GlobalAPI_GetMapByName"); + + // Modes + MarkNativeAsOptional("GlobalAPI_GetModes"); + MarkNativeAsOptional("GlobalAPI_GetModeById"); + MarkNativeAsOptional("GlobalAPI_GetModeByName"); + + // Players + MarkNativeAsOptional("GlobalAPI_GetPlayers"); + MarkNativeAsOptional("GlobalAPI_GetPlayerBySteamId"); + MarkNativeAsOptional("GlobalAPI_GetPlayerBySteamIdAndIp"); + + // Records + MarkNativeAsOptional("GlobalAPI_CreateRecord"); + MarkNativeAsOptional("GlobalAPI_GetRecordPlaceById"); + MarkNativeAsOptional("GlobalAPI_GetRecordsTop"); + MarkNativeAsOptional("GlobalAPI_GetRecordsTopRecent"); + MarkNativeAsOptional("GlobalAPI_GetRecordsTopWorldRecords"); + + // Servers + MarkNativeAsOptional("GlobalAPI_GetServers"); + MarkNativeAsOptional("GlobalAPI_GetServerById"); + MarkNativeAsOptional("GlobalAPI_GetServersByName"); + + // Ranks + MarkNativeAsOptional("GlobalAPI_GetPlayerRanks"); + + // Record Filters + MarkNativeAsOptional("GlobalAPI_GetRecordFilters"); + MarkNativeAsOptional("GlobalAPI_GetRecordFilterDistributions"); + + // Replays + MarkNativeAsOptional("GlobalAPI_GetReplayList"); + MarkNativeAsOptional("GlobalAPI_GetReplayByRecordId"); + MarkNativeAsOptional("GlobalAPI_GetReplayByReplayId"); + MarkNativeAsOptional("GlobalAPI_CreateReplayForRecordId"); +} +#endif diff --git a/sourcemod/scripting/include/GlobalAPI/iterable.inc b/sourcemod/scripting/include/GlobalAPI/iterable.inc new file mode 100644 index 0000000..585873b --- /dev/null +++ b/sourcemod/scripting/include/GlobalAPI/iterable.inc @@ -0,0 +1,55 @@ +// ================== DOUBLE INCLUDE ========================= // + +#if defined _GlobalAPI_Iterable_included_ +#endinput +#endif +#define _GlobalAPI_Iterable_included_ + +// =========================================================== // + +#include <json> + +// =========================================================== // + +/* + Helper methodmap for JSON_Object arrays +*/ +methodmap APIIterable < JSON_Object +{ + /** + * Creates a new APIIterable + * + * @param hItems JSON_Object array handle + * @return A new APIIterable handle + */ + public APIIterable(JSON_Object hItems) + { + if (hItems.HasKey("result")) + { + return view_as<APIIterable>(hItems.GetObject("result")); + } + return view_as<APIIterable>(hItems); + } + + /* + Gets count of the items in the array + */ + property int Count + { + public get() { return this.Length; } + } + + /** + * Gets an object from the array by index + * + * @note This is an alias to GetObjectIndexed + * @param index Index of the object we want to retrieve + * @return JSON_Object handle to the object retrieved + */ + public JSON_Object GetById(int index) + { + return this.GetObjectIndexed(index); + } +} + +// =========================================================== //
\ No newline at end of file diff --git a/sourcemod/scripting/include/GlobalAPI/request.inc b/sourcemod/scripting/include/GlobalAPI/request.inc new file mode 100644 index 0000000..e683125 --- /dev/null +++ b/sourcemod/scripting/include/GlobalAPI/request.inc @@ -0,0 +1,185 @@ +// ================== DOUBLE INCLUDE ========================= // + +#if defined _GlobalAPI_Request_included_ +#endinput +#endif +#define _GlobalAPI_Request_included_ + +// =========================================================== // + +static char gC_acceptTypePhrases[][] = +{ + "application/json", + "application/octet-stream" +}; + +static char gC_contentTypePhrases[][] = +{ + "application/json", + "application/octet-stream" +}; + +// =========================================================== // + +methodmap GlobalAPIRequest < Handle +{ + /** + * Creates a new GlobalAPIRequest + * + * @param url URL of the request + * @param method SteamWorks k_ETTPMethod of the request + * @return A new GlobalAPIRequest handle + */ + public GlobalAPIRequest(char[] url, EHTTPMethod method) + { + Handle request = SteamWorks_CreateHTTPRequest(method, url); + return view_as<GlobalAPIRequest>(request); + } + + /** + * Sets request timeout + * + * @param seconds Timeout in seconds + * @return Whether the operation was successful + */ + public bool SetTimeout(int seconds) + { + return SteamWorks_SetHTTPRequestAbsoluteTimeoutMS(this, seconds * 1000); + } + + /** + * Sets request body + * + * @param hData GlobalAPIRequestData containing contentType + * @param body Request body to set + * @param maxlength Maxlength of the body + * @return Whether the operation was successful + */ + public bool SetBody(GlobalAPIRequestData hData, char[] body, int maxlength) + { + return SteamWorks_SetHTTPRequestRawPostBody(this, gC_contentTypePhrases[hData.ContentType], body, maxlength); + } + + /** + * Sets request body from a file + * + * @param hData GlobalAPIRequestData containing contentType + * @return Whether the operation was successful + */ + public bool SetBodyFromFile(GlobalAPIRequestData hData, char[] file) + { + return SteamWorks_SetHTTPRequestRawPostBodyFromFile(this, gC_contentTypePhrases[hData.ContentType], file); + } + + /** + * Sets a request context value + * + * @param data Any data to pass + * @return Whether the operation was successful + */ + public bool SetData(any data1, any data2 = 0) + { + return SteamWorks_SetHTTPRequestContextValue(this, data1, data2); + } + + /** + * Sets predefined HTTP callbacks + * + * @note Predefined values respectively: + * @note Global_HTTP_Completed, Global_HTTP_Headers and Global_HTTP_DataReceived + * @noreturn + */ + public void SetCallbacks() + { + SteamWorks_SetHTTPCallbacks(this, Global_HTTP_Completed, Global_HTTP_Headers, Global_HTTP_DataReceived); + } + + /** + * Sets "Accept" header + * + * @param hData GlobalAPIRequestData containing acceptType + * @return Whether the operation was successful + */ + public bool SetAcceptHeaders(GlobalAPIRequestData hData) + { + return SteamWorks_SetHTTPRequestHeaderValue(this, "Accept", gC_acceptTypePhrases[hData.AcceptType]); + } + + /** + * Sets "powered by" header + * + * @return Whether the operation was successful + */ + public bool SetPoweredByHeader() + { + return SteamWorks_SetHTTPRequestHeaderValue(this, "X-Powered-By", GlobalAPI_Plugin_NameVersion); + } + + /** + * Sets authentication header + * + * @return Whether the operation was successful + */ + public bool SetAuthenticationHeader(char[] apiKey) + { + return SteamWorks_SetHTTPRequestHeaderValue(this, "X-ApiKey", apiKey); + } + + /** + * Sets envinroment headers (MetaMod & SourceMod) + * + * @param mmVersion MetaMod version string + * @param smVersion SourceMod version string + * @return Whether the operation was successful + */ + public bool SetEnvironmentHeaders(char[] mmVersion, char[] smVersion) + { + return SteamWorks_SetHTTPRequestHeaderValue(this, "X-MetaMod-Version", mmVersion) + && SteamWorks_SetHTTPRequestHeaderValue(this, "X-SourceMod-Version", smVersion); + } + + /** + * Sets content type header + * + * @param hData GlobalAPIRequestData containing contentType + * @return Whether the operation was successful + */ + public bool SetContentTypeHeader(GlobalAPIRequestData hData) + { + return SteamWorks_SetHTTPRequestHeaderValue(this, "Content-Type", gC_contentTypePhrases[hData.ContentType]); + } + + /** + * Sets request origin header + * + * @param hData GlobalAPIRequestData containing pluginName + * @return Whether the operation was successful + */ + public bool SetRequestOriginHeader(GlobalAPIRequestData hData) + { + char pluginName[GlobalAPI_Max_PluginName_Length]; + hData.GetString("pluginName", pluginName, sizeof(pluginName)); + + char pluginVersion[GlobalAPI_Max_PluginVersion_Length + 2]; + hData.GetString("pluginVersion", pluginVersion, sizeof(pluginVersion)); + + char fullPluginDisplay[sizeof(pluginName) + sizeof(pluginVersion) + 6]; + Format(fullPluginDisplay, sizeof(fullPluginDisplay), "%s (V.%s)", pluginName, pluginVersion); + + return SteamWorks_SetHTTPRequestHeaderValue(this, "X-Request-Origin", fullPluginDisplay); + } + + /** + * Sends our request with all available data + * + * @param hData GlobalAPIRequestData handle with all required keys + * @return Whether the operation was successful + */ + public bool Send(GlobalAPIRequestData hData) + { + Call_Private_OnHTTPStart(this, hData); + return SteamWorks_SendHTTPRequest(this); + } +} + +// =========================================================== //
\ No newline at end of file diff --git a/sourcemod/scripting/include/GlobalAPI/requestdata.inc b/sourcemod/scripting/include/GlobalAPI/requestdata.inc new file mode 100644 index 0000000..f055ee8 --- /dev/null +++ b/sourcemod/scripting/include/GlobalAPI/requestdata.inc @@ -0,0 +1,534 @@ +// ================== DOUBLE INCLUDE ========================= // + +#if defined _GlobalAPI_RequestData_included_ +#endinput +#endif +#define _GlobalAPI_RequestData_included_ + +// =========================================================== // + +#include <json> + +// =========================================================== // + +/* + Helper methodmap for wrapping data related to requests +*/ +methodmap GlobalAPIRequestData < JSON_Object +{ + /** + * Creates a new GlobalAPIRequestData + * + * @note You can pass a plugin handle or name and/or version + * @note Plugin handle is always preferred + * @param plugin Handle to calling plugin + * @param pluginName Name of the calling plugin + * @param pluginVersion Version of the calling plugin + * @return A new GlobalAPIRequestData handle + */ + public GlobalAPIRequestData(Handle plugin = null, char[] pluginName = "Unknown", char[] pluginVersion = "Unknown") + { + JSON_Object requestData = new JSON_Object(); + + if (plugin == null) + { + requestData.SetString("pluginName", pluginName); + requestData.SetString("pluginVersion", pluginVersion); + } + else + { + requestData.SetString("pluginName", GetPluginDisplayName(plugin)); + requestData.SetString("pluginVersion", GetPluginVersion(plugin)); + } + + requestData.SetKeyHidden("pluginName", true); + requestData.SetKeyHidden("pluginVersion", true); + + requestData.SetInt("acceptType", 0); + requestData.SetKeyHidden("acceptType", true); + + requestData.SetInt("contentType", 0); + requestData.SetKeyHidden("contentType", true); + + return view_as<GlobalAPIRequestData>(requestData); + } + + /** + * Sets a key as default + * + * @note This sets them as "Handle" type + * @note - See GlobalAPI.inc for default values + * @param key Key to set as default + * @noreturn + */ + public void SetDefault(char[] key) + { + this.SetHandle(key); + this.SetKeyHidden(key, true); + } + + /** + * Sets url to the request data + * + * @param url Url to set + * @noreturn + */ + public void AddUrl(char[] url) + { + this.SetString("url", url); + this.SetKeyHidden("url", true); + } + + /** + * Sets endpoint to the request data + * + * @param endpoint Endpoint to set + * @noreturn + */ + public void AddEndpoint(char[] endpoint) + { + this.SetString("endpoint", endpoint); + this.SetKeyHidden("endpoint", true); + } + + /** + * Sets body file path to the request data + * + * @note Path to file with data to be posted + * @param path Body file (path) to set + * @noreturn + */ + public void AddBodyFile(char[] path) + { + this.SetString("bodyFile", path); + this.SetKeyHidden("bodyFile", true); + } + + /** + * Sets data file path to the request data + * + * @note Path for downloaded files + * @param path Data path to set + * @noreturn + */ + public void AddDataPath(char[] path) + { + this.SetString("dataFilePath", path); + this.SetKeyHidden("dataFilePath", true); + } + + /* + Get or set the request's "acceptType" + */ + property int AcceptType + { + public get() + { + return this.GetInt("acceptType"); + } + public set(int type) + { + this.SetInt("acceptType", type); + } + } + + /* + Get or set the request's "contentType" + */ + property int ContentType + { + public get() + { + return this.GetInt("contentType"); + } + public set(int type) + { + this.SetInt("contentType", type); + } + } + + /* + Get or set the request's "keyRequired" + */ + property bool KeyRequired + { + public get() + { + return this.GetBool("keyRequired"); + } + public set(bool required) + { + this.SetBool("keyRequired", required); + this.SetKeyHidden("keyRequired", true); + } + } + + /* + Get or set the request's "isRetried" + */ + property bool IsRetried + { + public get() + { + return this.GetBool("isRetried"); + } + public set(bool retried) + { + this.SetBool("isRetried", retried); + this.SetKeyHidden("isRetried", true); + } + } + + /* + Get or set the request's "bodyLength" + */ + property int BodyLength + { + public get() + { + return this.GetInt("bodyLength"); + } + public set(int length) + { + this.SetInt("bodyLength", length); + this.SetKeyHidden("bodyLength", true); + } + } + + /* + Get or set the request's "status" + */ + property int Status + { + public get() + { + return this.GetInt("status"); + } + public set(int status) + { + this.SetInt("status", status); + this.SetKeyHidden("status", true); + } + } + + /* + Get or set the request's "responseTime" + */ + property int ResponseTime + { + public get() + { + return this.GetInt("responseTime"); + } + public set(int responseTime) + { + this.SetInt("responseTime", responseTime); + this.SetKeyHidden("responseTime", true); + } + } + + /* + Get or set the request's "requestType" + */ + property int RequestType + { + public get() + { + return this.GetInt("requestType"); + } + public set(int type) + { + this.SetInt("requestType", type); + this.SetKeyHidden("requestType", true); + } + } + + /* + Get or set the request's "failure" + */ + property bool Failure + { + public get() + { + return this.GetBool("failure"); + } + public set(bool failure) + { + this.SetBool("failure", failure); + this.SetKeyHidden("failure", true); + } + } + + /* + Get or set the request's "callback" + */ + property Handle Callback + { + public get() + { + return view_as<Handle>(this.GetInt("callback")); + } + public set(Handle hFwd) + { + this.SetHandle("callback", hFwd); + this.SetKeyType("callback", Type_Int); + this.SetKeyHidden("callback", true); + } + } + + /* + Get or set the request's "data" + */ + property any Data + { + public get() + { + return this.GetInt("data"); + } + public set(any data) + { + this.SetInt("data", data); + this.SetKeyHidden("data", true); + } + } + + /** + * Adds a number to the request data + * + * @note Default values are added as "defaults" + * @note See GlobalAPI.inc for the default values + * @param key Key name to set + * @param value Value of the key + * @noreturn + */ + public void AddNum(char[] key, int value) + { + if (value == -1) + { + this.SetDefault(key); + } + else + { + this.SetInt(key, value); + } + } + + /** + * Adds a float to the request data + * + * @note Default values are added as "defaults" + * @note See GlobalAPI.inc for the default values + * @param key Key name to set + * @param value Value of the key + * @noreturn + */ + public void AddFloat(char[] key, float value) + { + if (value == -1.000000) + { + this.SetDefault(key); + } + else + { + this.SetFloat(key, value); + } + } + + /** + * Adds a string to the request data + * + * @note Default values are added as "defaults" + * @note See GlobalAPI.inc for the default values + * @param key Key name to set + * @param value Value of the key + * @noreturn + */ + public void AddString(char[] key, char[] value) + { + if (StrEqual(value, "")) + { + this.SetDefault(key); + } + else + { + this.SetString(key, value); + } + } + + /** + * Adds a boolean to the request data + * + * @note Default values are added as "defaults" + * @note See GlobalAPI.inc for the default values + * @param key Key name to set + * @param value Value of the key + * @noreturn + */ + public void AddBool(char[] key, bool value) + { + if (value != true && value != false) + { + this.SetDefault(key); + } + else + { + this.SetBool(key, value); + } + } + + /** + * Adds integer array to the request data + * + * @note Max length <= 0 are added as defaults + * @param key Key name to set + * @param value Values (array) of the key + * @param maxlength Max length of the values array + * @noreturn + */ + public void AddIntArray(char[] key, int[] value, int maxlength) + { + if (maxlength <= 0) + { + this.SetDefault(key); + } + else + { + JSON_Object hArray = new JSON_Object(true); + + for (int i = 0; i < maxlength; i++) + { + hArray.PushInt(value[i]); + } + + this.SetObject(key, hArray); + } + } + + /** + * Adds string array to the request data + * + * @note Item count <= 0 are added as defaults + * @param key Key name to set + * @param itemCount Amount of strings in the array + * @noreturn + */ + public void AddStringArray(char[] key, char[][] value, int itemCount) + { + if (itemCount <= 0) + { + this.SetDefault(key); + } + else + { + JSON_Object hArray = new JSON_Object(true); + + for (int i = 0; i < itemCount; i++) + { + hArray.PushString(value[i]); + } + + this.SetObject(key, hArray); + } + } + + /** + * Converts all of the request data into a query string representation + * + * @note This ignores "hidden" keys + * @param queryString Buffer to store the result in + * @param maxlength Max length of the buffer + * @noreturn + */ + public void ToString(char[] queryString, int maxlength) + { + StringMapSnapshot paramsMap = this.Snapshot(); + + char key[64]; + char value[1024]; + + int paramCount = 0; + + for (int i = 0; i < paramsMap.Length; i++) + { + paramsMap.GetKey(i, key, sizeof(key)); + if (this.GetKeyHidden(key) || json_is_meta_key(key)) + { + continue; + } + + switch(this.GetKeyType(key)) + { + case Type_String: + { + this.GetString(key, value, sizeof(value)); + AppendToQueryString(paramCount, queryString, maxlength, key, value); + } + case Type_Float: + { + float temp = this.GetFloat(key); + FloatToString(temp, value, sizeof(value)); + AppendToQueryString(paramCount, queryString, maxlength, key, value); + } + case Type_Int: + { + int temp = this.GetInt(key); + IntToString(temp, value, sizeof(value)); + AppendToQueryString(paramCount, queryString, maxlength, key, value); + } + case Type_Bool: + { + bool temp = this.GetBool(key); + BoolToString(temp, value, sizeof(value)); + AppendToQueryString(paramCount, queryString, maxlength, key, value); + } + case Type_Object: + { + JSON_Object hObject = this.GetObject(key); + + if (!hObject.IsArray) continue; + + for (int x = 0; x < hObject.Length; x++) + { + switch (hObject.GetKeyTypeIndexed(x)) + { + case Type_Int: + { + int temp = hObject.GetIntIndexed(x); + IntToString(temp, value, sizeof(value)); + AppendToQueryString(paramCount, queryString, maxlength, key, value); + } + case Type_String: + { + hObject.GetStringIndexed(x, value, sizeof(value)); + AppendToQueryString(paramCount, queryString, maxlength, key, value); + } + } + } + } + } + } + + delete paramsMap; + } +} + +// =====[ PRIVATE ]===== + +static void BoolToString(bool value, char[] buffer, int maxlength) +{ + FormatEx(buffer, maxlength, "%s", value ? "true" : "false"); +} + +static void AppendToQueryString(int &index, char[] buffer, int maxlength, char[] key, char[] value) +{ + if (index == 0) + { + index++; + Format(buffer, maxlength, "?%s=%s", key, value); + } + else + { + index++; + Format(buffer, maxlength, "%s&%s=%s", buffer, key, value); + } +} diff --git a/sourcemod/scripting/include/GlobalAPI/responses.inc b/sourcemod/scripting/include/GlobalAPI/responses.inc new file mode 100644 index 0000000..62ebfd2 --- /dev/null +++ b/sourcemod/scripting/include/GlobalAPI/responses.inc @@ -0,0 +1,575 @@ +// ================== DOUBLE INCLUDE ========================= // + +#if defined _GlobalAPI_Responses_included_ +#endinput +#endif +#define _GlobalAPI_Responses_included_ + +// =========================================================== // + +#include <json> +#include <GlobalAPI/iterable> + +// =========================================================== // + +methodmap APIAuth < JSON_Object +{ + public APIAuth(JSON_Object hAuth) + { + return view_as<APIAuth>(hAuth); + } + + public bool GetType(char[] buffer, int maxlength) + { + return this.GetString("Type", buffer, maxlength); + } + + property bool IsValid + { + public get() { return this.GetBool("IsValid"); } + } + + property int Identity + { + public get() { return this.GetInt("Identity"); } + } +} + +// =========================================================== // + +methodmap APIBan < JSON_Object +{ + public APIBan(JSON_Object hBan) + { + return view_as<APIBan>(hBan); + } + + property int Id + { + public get() { return this.GetInt("id"); } + } + + property int UpdatedById + { + public get() { return this.GetInt("updated_by_id"); } + } + + public void GetStats(char[] buffer, int maxlength) + { + this.GetString("stats", buffer, maxlength); + } + + public void GetBanType(char[] buffer, int maxlength) + { + this.GetString("ban_type", buffer, maxlength); + } + + public void GetExpiresOn(char[] buffer, int maxlength) + { + this.GetString("expires_on", buffer, maxlength); + } + + public void GetSteamId64(char[] buffer, int maxlength) + { + this.GetString("steamid64", buffer, maxlength); + } + + public void GetPlayerName(char[] buffer, int maxlength) + { + this.GetString("player_name", buffer, maxlength); + } + + public void GetNotes(char[] buffer, int maxlength) + { + this.GetString("notes", buffer, maxlength); + } + + public void GetSteamId(char[] buffer, int maxlength) + { + this.GetString("steam_id", buffer, maxlength); + } + + public void GetUpdatedOn(char[] buffer, int maxlength) + { + this.GetString("updated_on", buffer, maxlength); + } + + property int ServerId + { + public get() { return this.GetInt("server_id"); } + } + + public void GetCreatedOn(char[] buffer, int maxlength) + { + this.GetString("created_on", buffer, maxlength); + } +} + +// =========================================================== // + +methodmap APIJumpstat < JSON_Object +{ + public APIJumpstat(JSON_Object hJump) + { + return view_as<APIJumpstat>(hJump); + } + + property int Id + { + public get() { return this.GetInt("id"); } + } + + property int ServerId + { + public get() { return this.GetInt("server_id"); } + } + + public void GetSteamId64(char[] buffer, int maxlength) + { + this.GetString("steamid64", buffer, maxlength); + } + + public void GetName(char[] buffer, int maxlength) + { + this.GetString("player_name", buffer, maxlength); + } + + public void GetSteamId(char[] buffer, int maxlength) + { + this.GetString("steam_id", buffer, maxlength); + } + + property int JumpType + { + public get() { return this.GetInt("jump_type"); } + } + + property float Distance + { + public get() { return this.GetFloat("distance"); } + } + + property int TickRate + { + public get() { return this.GetInt("tickrate"); } + } + + property int MslCount + { + public get() { return this.GetInt("msl_count"); } + } + + property int StrafeCount + { + public get() { return this.GetInt("strafe_count"); } + } + + property bool IsCrouchBind + { + public get() { return this.GetBool("is_crouch_bind"); } + } + + property bool IsForwardBind + { + public get() { return this.GetBool("is_forward_bind"); } + } + + property bool IsCrouchBoost + { + public get() { return this.GetBool("is_crouch_boost"); } + } + + property int UpdatedById + { + public get() { return this.GetInt("updated_by_id"); } + } + + public void GetCreatedOn(char[] buffer, int maxlength) + { + this.GetString("created_on", buffer, maxlength); + } + + public void GetUpdatedOn(char[] buffer, int maxlength) + { + this.GetString("updated_on", buffer, maxlength); + } +} + +// =========================================================== // + +methodmap APIMap < JSON_Object +{ + public APIMap(JSON_Object hMap) + { + return view_as<APIMap>(hMap); + } + + property int Id + { + public get() { return this.GetInt("id"); } + } + + public void GetName(char[] buffer, int maxlength) + { + this.GetString("name", buffer, maxlength); + } + + property int Filesize + { + public get() { return this.GetInt("filesize"); } + } + + property bool IsValidated + { + public get() { return this.GetBool("validated"); } + } + + property int Difficulty + { + public get() { return this.GetInt("difficulty"); } + } + + public void GetCreatedOn(char[] buffer, int maxlength) + { + this.GetString("created_on", buffer, maxlength); + } + + public void GetUpdatedOn(char[] buffer, int maxlength) + { + this.GetString("updated_on", buffer, maxlength); + } + + public void GetApprovedBySteamId64(char[] buffer, int maxlength) + { + this.GetString("approved_by_steamid64", buffer, maxlength); + } +} + +// =========================================================== // + +methodmap APIMode < JSON_Object +{ + public APIMode(JSON_Object hMode) + { + return view_as<APIMode>(hMode); + } + + property int Id + { + public get() { return this.GetInt("id"); } + } + + public void GetName(char[] buffer, int maxlength) + { + this.GetString("name", buffer, maxlength); + } + + public void GetDescription(char[] buffer, int maxlength) + { + this.GetString("description", buffer, maxlength); + } + + property int LatestVersion + { + public get() { return this.GetInt("latest_version"); } + } + + public void GetLatestVersionDesc(char[] buffer, int maxlength) + { + this.GetString("latest_version_description", buffer, maxlength); + } + + public void GetWebsite(char[] buffer, int maxlength) + { + this.GetString("website", buffer, maxlength); + } + + public void GetRepository(char[] buffer, int maxlength) + { + this.GetString("repo", buffer, maxlength); + } + + public void GetContactSteamId64(char[] buffer, int maxlength) + { + this.GetString("contact_steamid64", buffer, maxlength); + } + + // TODO: Add supported_tickrates + + public void GetCreatedOn(char[] buffer, int maxlength) + { + this.GetString("created_on", buffer, maxlength); + } + + public void GetUpdatedOn(char[] buffer, int maxlength) + { + this.GetString("updated_on", buffer, maxlength); + } + + public void GetUpdatedById(char[] buffer, int maxlength) + { + this.GetString("updated_by_id", buffer, maxlength); + } +} + +// =========================================================== // + +methodmap APIPlayerRank < JSON_Object +{ + public APIPlayerRank(JSON_Object hPlayerRank) + { + return view_as<APIPlayerRank>(hPlayerRank); + } + + property int Points + { + public get() { return this.GetInt("points"); } + } + + property int PointsOverall + { + public get() { return this.GetInt("points_overall"); } + } + + property float Average + { + public get() { return this.GetFloat("average"); } + } + + property float Rating + { + public get() { return this.GetFloat("rating"); } + } + + property int Finishes + { + public get() { return this.GetInt("finishes"); } + } + + public void GetSteamId64(char[] buffer, int maxlength) + { + this.GetString("steamid64", buffer, maxlength); + } + + public void GetSteamId(char[] buffer, int maxlength) + { + this.GetString("steamid", buffer, maxlength); + } + + public void GetPlayerName(char[] buffer, int maxlength) + { + this.GetString("player_name", buffer, maxlength); + } +} + +// =========================================================== // + +methodmap APIPlayer < JSON_Object +{ + public APIPlayer(JSON_Object hPlayer) + { + return view_as<APIPlayer>(hPlayer); + } + + public void GetSteamId64(char[] buffer, int maxlength) + { + this.GetString("steamid64", buffer, maxlength); + } + + public void GetSteamId(char[] buffer, int maxlength) + { + this.GetString("steam_id", buffer, maxlength); + } + + property bool IsBanned + { + public get() { return this.GetBool("is_banned"); } + } + + property int TotalRecords + { + public get() { return this.GetInt("total_records"); } + } + + public void GetName(char[] buffer, int maxlength) + { + this.GetString("name", buffer, maxlength); + } +} + +// =========================================================== // + +methodmap APIRecord < JSON_Object +{ + public APIRecord(JSON_Object hRecord) + { + return view_as<APIRecord>(hRecord); + } + + property int Id + { + public get() { return this.GetInt("id"); } + } + + public void GetSteamId64(char[] buffer, int maxlength) + { + this.GetString("steamid64", buffer, maxlength); + } + + public void GetPlayerName(char[] buffer, int maxlength) + { + this.GetString("player_name", buffer, maxlength); + } + + public void GetSteamId(char[] buffer, int maxlength) + { + this.GetString("steam_id", buffer, maxlength); + } + + property int ServerId + { + public get() { return this.GetInt("server_id"); } + } + + property int MapId + { + public get() { return this.GetInt("map_id"); } + } + + property int Stage + { + public get() { return this.GetInt("stage"); } + } + + public void GetMode(char[] buffer, int maxlength) + { + this.GetString("mode", buffer, maxlength); + } + + property int TickRate + { + public get() { return this.GetInt("tickrate"); } + } + + property float Time + { + public get() { return this.GetFloat("time"); } + } + + property int Teleports + { + public get() { return this.GetInt("teleports"); } + } + + public void GetCreatedOn(char[] buffer, int maxlength) + { + this.GetString("created_on", buffer, maxlength); + } + + public void GetUpdatedOn(char[] buffer, int maxlength) + { + this.GetString("updated_on", buffer, maxlength); + } + + property int UpdatedBy + { + public get() { return this.GetInt("updated_by"); } + } + + public void GetServerName(char[] buffer, int maxlength) + { + this.GetString("server_name", buffer, maxlength); + } + + public void GetMapName(char[] buffer, int maxlength) + { + this.GetString("map_name", buffer, maxlength); + } +} + +// =========================================================== // + +methodmap APIServer < JSON_Object +{ + public APIServer(JSON_Object hServer) + { + return view_as<APIServer>(hServer); + } + + property int Port + { + public get() { return this.GetInt("port"); } + } + + public void GetIPAddress(char[] buffer, int maxlength) + { + this.GetString("ip", buffer, maxlength); + } + + public void GetName(char[] buffer, int maxlength) + { + this.GetString("name", buffer, maxlength); + } + + public void GetOwnerSteamId64(char[] buffer, int maxlength) + { + this.GetString("owner_steamid64", buffer, maxlength); + } +} + +// =========================================================== // + +methodmap APIRecordFilter < JSON_Object +{ + public APIRecordFilter(JSON_Object hRecordFilter) + { + return view_as<APIRecordFilter>(hRecordFilter); + } + + property int Id + { + public get() { return this.GetInt("id"); } + } + + property int MapId + { + public get() { return this.GetInt("map_id"); } + } + + property int Stage + { + public get() { return this.GetInt("stage"); } + } + + property int ModeId + { + public get() { return this.GetInt("mode_id"); } + } + + property int TickRate + { + public get() { return this.GetInt("tickrate"); } + } + + property bool HasTeleports + { + public get() { return this.GetBool("has_teleports"); } + } + + public void GetCreatedOn(char[] buffer, int maxlength) + { + this.GetString("created_on", buffer, maxlength); + } + + public void GetUpdatedOn(char[] buffer, int maxlength) + { + this.GetString("updated_on", buffer, maxlength); + } + + public void GetUpdatedById(char[] buffer, int maxlength) + { + this.GetString("updated_by_id", buffer, maxlength); + } +} + +// =========================================================== // diff --git a/sourcemod/scripting/include/GlobalAPI/stocks.inc b/sourcemod/scripting/include/GlobalAPI/stocks.inc new file mode 100644 index 0000000..52596c4 --- /dev/null +++ b/sourcemod/scripting/include/GlobalAPI/stocks.inc @@ -0,0 +1,67 @@ +// ================== DOUBLE INCLUDE ========================= // + +#if defined _GlobalAPI_Stocks_included_ +#endinput +#endif +#define _GlobalAPI_Stocks_included_ + +// =========================================================== // + +/** + * Gets plugin's display name from its handle + * + * @param plugin Plugin handle to retrieve name from + * @return String representation of the plugin name + */ +stock char[] GetPluginDisplayName(Handle plugin) +{ + char pluginName[GlobalAPI_Max_PluginName_Length] = "Unknown"; + GetPluginInfo(plugin, PlInfo_Name, pluginName, sizeof(pluginName)); + + return pluginName; +} + +/** + * Gets plugin's version from its handle + * + * @param plugin Plugin handle to retrieve version from + * @return String representation of the plugin version + */ +stock char[] GetPluginVersion(Handle plugin) +{ + char pluginVersion[GlobalAPI_Max_PluginVersion_Length] = "Unknown"; + GetPluginInfo(plugin, PlInfo_Version, pluginVersion, sizeof(pluginVersion)); + + return pluginVersion; +} + +/** + * Gets current map's "display name" + * + * @param buffer Buffer to store the result in + * @param maxlength Max length of the buffer + * @noreturn + */ +stock void GetMapDisplay(char[] buffer, int maxlength) +{ + char map[PLATFORM_MAX_PATH]; + GetCurrentMap(map, sizeof(map)); + GetMapDisplayName(map, map, sizeof(map)); + + FormatEx(buffer, maxlength, map); +} + +/** + * Gets current map's full (game dir) path + * + * @param buffer Buffer to store result in + * @param maxlength Max length of the buffer + * @noreturn + */ +stock void GetMapFullPath(char[] buffer, int maxlength) +{ + char mapPath[PLATFORM_MAX_PATH]; + GetCurrentMap(mapPath, sizeof(mapPath)); + + Format(buffer, maxlength, "maps/%s.bsp", mapPath); +} diff --git a/sourcemod/scripting/include/SteamWorks.inc b/sourcemod/scripting/include/SteamWorks.inc new file mode 100644 index 0000000..0e4aec3 --- /dev/null +++ b/sourcemod/scripting/include/SteamWorks.inc @@ -0,0 +1,413 @@ +#if defined _SteamWorks_Included + #endinput +#endif +#define _SteamWorks_Included + +/* results from UserHasLicenseForApp */ +enum EUserHasLicenseForAppResult +{ + k_EUserHasLicenseResultHasLicense = 0, // User has a license for specified app + k_EUserHasLicenseResultDoesNotHaveLicense = 1, // User does not have a license for the specified app + k_EUserHasLicenseResultNoAuth = 2, // User has not been authenticated +}; + +/* General result codes */ +enum EResult +{ + k_EResultOK = 1, // success + k_EResultFail = 2, // generic failure + k_EResultNoConnection = 3, // no/failed network connection +// k_EResultNoConnectionRetry = 4, // OBSOLETE - removed + k_EResultInvalidPassword = 5, // password/ticket is invalid + k_EResultLoggedInElsewhere = 6, // same user logged in elsewhere + k_EResultInvalidProtocolVer = 7, // protocol version is incorrect + k_EResultInvalidParam = 8, // a parameter is incorrect + k_EResultFileNotFound = 9, // file was not found + k_EResultBusy = 10, // called method busy - action not taken + k_EResultInvalidState = 11, // called object was in an invalid state + k_EResultInvalidName = 12, // name is invalid + k_EResultInvalidEmail = 13, // email is invalid + k_EResultDuplicateName = 14, // name is not unique + k_EResultAccessDenied = 15, // access is denied + k_EResultTimeout = 16, // operation timed out + k_EResultBanned = 17, // VAC2 banned + k_EResultAccountNotFound = 18, // account not found + k_EResultInvalidSteamID = 19, // steamID is invalid + k_EResultServiceUnavailable = 20, // The requested service is currently unavailable + k_EResultNotLoggedOn = 21, // The user is not logged on + k_EResultPending = 22, // Request is pending (may be in process, or waiting on third party) + k_EResultEncryptionFailure = 23, // Encryption or Decryption failed + k_EResultInsufficientPrivilege = 24, // Insufficient privilege + k_EResultLimitExceeded = 25, // Too much of a good thing + k_EResultRevoked = 26, // Access has been revoked (used for revoked guest passes) + k_EResultExpired = 27, // License/Guest pass the user is trying to access is expired + k_EResultAlreadyRedeemed = 28, // Guest pass has already been redeemed by account, cannot be acked again + k_EResultDuplicateRequest = 29, // The request is a duplicate and the action has already occurred in the past, ignored this time + k_EResultAlreadyOwned = 30, // All the games in this guest pass redemption request are already owned by the user + k_EResultIPNotFound = 31, // IP address not found + k_EResultPersistFailed = 32, // failed to write change to the data store + k_EResultLockingFailed = 33, // failed to acquire access lock for this operation + k_EResultLogonSessionReplaced = 34, + k_EResultConnectFailed = 35, + k_EResultHandshakeFailed = 36, + k_EResultIOFailure = 37, + k_EResultRemoteDisconnect = 38, + k_EResultShoppingCartNotFound = 39, // failed to find the shopping cart requested + k_EResultBlocked = 40, // a user didn't allow it + k_EResultIgnored = 41, // target is ignoring sender + k_EResultNoMatch = 42, // nothing matching the request found + k_EResultAccountDisabled = 43, + k_EResultServiceReadOnly = 44, // this service is not accepting content changes right now + k_EResultAccountNotFeatured = 45, // account doesn't have value, so this feature isn't available + k_EResultAdministratorOK = 46, // allowed to take this action, but only because requester is admin + k_EResultContentVersion = 47, // A Version mismatch in content transmitted within the Steam protocol. + k_EResultTryAnotherCM = 48, // The current CM can't service the user making a request, user should try another. + k_EResultPasswordRequiredToKickSession = 49,// You are already logged in elsewhere, this cached credential login has failed. + k_EResultAlreadyLoggedInElsewhere = 50, // You are already logged in elsewhere, you must wait + k_EResultSuspended = 51, // Long running operation (content download) suspended/paused + k_EResultCancelled = 52, // Operation canceled (typically by user: content download) + k_EResultDataCorruption = 53, // Operation canceled because data is ill formed or unrecoverable + k_EResultDiskFull = 54, // Operation canceled - not enough disk space. + k_EResultRemoteCallFailed = 55, // an remote call or IPC call failed + k_EResultPasswordUnset = 56, // Password could not be verified as it's unset server side + k_EResultExternalAccountUnlinked = 57, // External account (PSN, Facebook...) is not linked to a Steam account + k_EResultPSNTicketInvalid = 58, // PSN ticket was invalid + k_EResultExternalAccountAlreadyLinked = 59, // External account (PSN, Facebook...) is already linked to some other account, must explicitly request to replace/delete the link first + k_EResultRemoteFileConflict = 60, // The sync cannot resume due to a conflict between the local and remote files + k_EResultIllegalPassword = 61, // The requested new password is not legal + k_EResultSameAsPreviousValue = 62, // new value is the same as the old one ( secret question and answer ) + k_EResultAccountLogonDenied = 63, // account login denied due to 2nd factor authentication failure + k_EResultCannotUseOldPassword = 64, // The requested new password is not legal + k_EResultInvalidLoginAuthCode = 65, // account login denied due to auth code invalid + k_EResultAccountLogonDeniedNoMail = 66, // account login denied due to 2nd factor auth failure - and no mail has been sent + k_EResultHardwareNotCapableOfIPT = 67, // + k_EResultIPTInitError = 68, // + k_EResultParentalControlRestricted = 69, // operation failed due to parental control restrictions for current user + k_EResultFacebookQueryError = 70, // Facebook query returned an error + k_EResultExpiredLoginAuthCode = 71, // account login denied due to auth code expired + k_EResultIPLoginRestrictionFailed = 72, + k_EResultAccountLockedDown = 73, + k_EResultAccountLogonDeniedVerifiedEmailRequired = 74, + k_EResultNoMatchingURL = 75, + k_EResultBadResponse = 76, // parse failure, missing field, etc. + k_EResultRequirePasswordReEntry = 77, // The user cannot complete the action until they re-enter their password + k_EResultValueOutOfRange = 78, // the value entered is outside the acceptable range + k_EResultUnexpectedError = 79, // something happened that we didn't expect to ever happen + k_EResultDisabled = 80, // The requested service has been configured to be unavailable + k_EResultInvalidCEGSubmission = 81, // The set of files submitted to the CEG server are not valid ! + k_EResultRestrictedDevice = 82, // The device being used is not allowed to perform this action + k_EResultRegionLocked = 83, // The action could not be complete because it is region restricted + k_EResultRateLimitExceeded = 84, // Temporary rate limit exceeded, try again later, different from k_EResultLimitExceeded which may be permanent + k_EResultAccountLoginDeniedNeedTwoFactor = 85, // Need two-factor code to login + k_EResultItemDeleted = 86, // The thing we're trying to access has been deleted + k_EResultAccountLoginDeniedThrottle = 87, // login attempt failed, try to throttle response to possible attacker + k_EResultTwoFactorCodeMismatch = 88, // two factor code mismatch + k_EResultTwoFactorActivationCodeMismatch = 89, // activation code for two-factor didn't match + k_EResultAccountAssociatedToMultiplePartners = 90, // account has been associated with multiple partners + k_EResultNotModified = 91, // data not modified + k_EResultNoMobileDevice = 92, // the account does not have a mobile device associated with it + k_EResultTimeNotSynced = 93, // the time presented is out of range or tolerance + k_EResultSmsCodeFailed = 94, // SMS code failure (no match, none pending, etc.) + k_EResultAccountLimitExceeded = 95, // Too many accounts access this resource + k_EResultAccountActivityLimitExceeded = 96, // Too many changes to this account + k_EResultPhoneActivityLimitExceeded = 97, // Too many changes to this phone + k_EResultRefundToWallet = 98, // Cannot refund to payment method, must use wallet + k_EResultEmailSendFailure = 99, // Cannot send an email + k_EResultNotSettled = 100, // Can't perform operation till payment has settled + k_EResultNeedCaptcha = 101, // Needs to provide a valid captcha + k_EResultGSLTDenied = 102, // a game server login token owned by this token's owner has been banned + k_EResultGSOwnerDenied = 103, // game server owner is denied for other reason (account lock, community ban, vac ban, missing phone) + k_EResultInvalidItemType = 104 // the type of thing we were requested to act on is invalid +}; + +/* This enum is used in client API methods, do not re-number existing values. */ +enum EHTTPMethod +{ + k_EHTTPMethodInvalid = 0, + k_EHTTPMethodGET, + k_EHTTPMethodHEAD, + k_EHTTPMethodPOST, + k_EHTTPMethodPUT, + k_EHTTPMethodDELETE, + k_EHTTPMethodOPTIONS, + k_EHTTPMethodPATCH, + + // The remaining HTTP methods are not yet supported, per rfc2616 section 5.1.1 only GET and HEAD are required for + // a compliant general purpose server. We'll likely add more as we find uses for them. + + // k_EHTTPMethodTRACE, + // k_EHTTPMethodCONNECT +}; + + +/* HTTP Status codes that the server can send in response to a request, see rfc2616 section 10.3 for descriptions + of each of these. */ +enum EHTTPStatusCode +{ + // Invalid status code (this isn't defined in HTTP, used to indicate unset in our code) + k_EHTTPStatusCodeInvalid = 0, + + // Informational codes + k_EHTTPStatusCode100Continue = 100, + k_EHTTPStatusCode101SwitchingProtocols = 101, + + // Success codes + k_EHTTPStatusCode200OK = 200, + k_EHTTPStatusCode201Created = 201, + k_EHTTPStatusCode202Accepted = 202, + k_EHTTPStatusCode203NonAuthoritative = 203, + k_EHTTPStatusCode204NoContent = 204, + k_EHTTPStatusCode205ResetContent = 205, + k_EHTTPStatusCode206PartialContent = 206, + + // Redirection codes + k_EHTTPStatusCode300MultipleChoices = 300, + k_EHTTPStatusCode301MovedPermanently = 301, + k_EHTTPStatusCode302Found = 302, + k_EHTTPStatusCode303SeeOther = 303, + k_EHTTPStatusCode304NotModified = 304, + k_EHTTPStatusCode305UseProxy = 305, + //k_EHTTPStatusCode306Unused = 306, (used in old HTTP spec, now unused in 1.1) + k_EHTTPStatusCode307TemporaryRedirect = 307, + + // Error codes + k_EHTTPStatusCode400BadRequest = 400, + k_EHTTPStatusCode401Unauthorized = 401, // You probably want 403 or something else. 401 implies you're sending a WWW-Authenticate header and the client can sent an Authorization header in response. + k_EHTTPStatusCode402PaymentRequired = 402, // This is reserved for future HTTP specs, not really supported by clients + k_EHTTPStatusCode403Forbidden = 403, + k_EHTTPStatusCode404NotFound = 404, + k_EHTTPStatusCode405MethodNotAllowed = 405, + k_EHTTPStatusCode406NotAcceptable = 406, + k_EHTTPStatusCode407ProxyAuthRequired = 407, + k_EHTTPStatusCode408RequestTimeout = 408, + k_EHTTPStatusCode409Conflict = 409, + k_EHTTPStatusCode410Gone = 410, + k_EHTTPStatusCode411LengthRequired = 411, + k_EHTTPStatusCode412PreconditionFailed = 412, + k_EHTTPStatusCode413RequestEntityTooLarge = 413, + k_EHTTPStatusCode414RequestURITooLong = 414, + k_EHTTPStatusCode415UnsupportedMediaType = 415, + k_EHTTPStatusCode416RequestedRangeNotSatisfiable = 416, + k_EHTTPStatusCode417ExpectationFailed = 417, + k_EHTTPStatusCode4xxUnknown = 418, // 418 is reserved, so we'll use it to mean unknown + k_EHTTPStatusCode429TooManyRequests = 429, + + // Server error codes + k_EHTTPStatusCode500InternalServerError = 500, + k_EHTTPStatusCode501NotImplemented = 501, + k_EHTTPStatusCode502BadGateway = 502, + k_EHTTPStatusCode503ServiceUnavailable = 503, + k_EHTTPStatusCode504GatewayTimeout = 504, + k_EHTTPStatusCode505HTTPVersionNotSupported = 505, + k_EHTTPStatusCode5xxUnknown = 599, +}; + +/* list of possible return values from the ISteamGameCoordinator API */ +enum EGCResults +{ + k_EGCResultOK = 0, + k_EGCResultNoMessage = 1, // There is no message in the queue + k_EGCResultBufferTooSmall = 2, // The buffer is too small for the requested message + k_EGCResultNotLoggedOn = 3, // The client is not logged onto Steam + k_EGCResultInvalidMessage = 4, // Something was wrong with the message being sent with SendMessage +}; + +native bool:SteamWorks_IsVACEnabled(); +native bool:SteamWorks_GetPublicIP(ipaddr[4]); +native SteamWorks_GetPublicIPCell(); +native bool:SteamWorks_IsLoaded(); +native bool:SteamWorks_SetGameData(const String:sData[]); +native bool:SteamWorks_SetGameDescription(const String:sDesc[]); +native bool:SteamWorks_SetMapName(const String:sMapName[]); +native bool:SteamWorks_IsConnected(); +native bool:SteamWorks_SetRule(const String:sKey[], const String:sValue[]); +native bool:SteamWorks_ClearRules(); +native bool:SteamWorks_ForceHeartbeat(); +native bool:SteamWorks_GetUserGroupStatus(client, groupid); +native bool:SteamWorks_GetUserGroupStatusAuthID(authid, groupid); + +native EUserHasLicenseForAppResult:SteamWorks_HasLicenseForApp(client, app); +native EUserHasLicenseForAppResult:SteamWorks_HasLicenseForAppId(authid, app); +native SteamWorks_GetClientSteamID(client, String:sSteamID[], length); + +native bool:SteamWorks_RequestStatsAuthID(authid, appid); +native bool:SteamWorks_RequestStats(client, appid); +native bool:SteamWorks_GetStatCell(client, const String:sKey[], &value); +native bool:SteamWorks_GetStatAuthIDCell(authid, const String:sKey[], &value); +native bool:SteamWorks_GetStatFloat(client, const String:sKey[], &Float:value); +native bool:SteamWorks_GetStatAuthIDFloat(authid, const String:sKey[], &Float:value); + +native Handle:SteamWorks_CreateHTTPRequest(EHTTPMethod:method, const String:sURL[]); +native bool:SteamWorks_SetHTTPRequestContextValue(Handle:hHandle, any:data1, any:data2=0); +native bool:SteamWorks_SetHTTPRequestNetworkActivityTimeout(Handle:hHandle, timeout); +native bool:SteamWorks_SetHTTPRequestHeaderValue(Handle:hHandle, const String:sName[], const String:sValue[]); +native bool:SteamWorks_SetHTTPRequestGetOrPostParameter(Handle:hHandle, const String:sName[], const String:sValue[]); +native bool:SteamWorks_SetHTTPRequestUserAgentInfo(Handle:hHandle, const String:sUserAgentInfo[]); +native bool:SteamWorks_SetHTTPRequestRequiresVerifiedCertificate(Handle:hHandle, bool:bRequireVerifiedCertificate); +native bool:SteamWorks_SetHTTPRequestAbsoluteTimeoutMS(Handle:hHandle, unMilliseconds); + +#if SOURCEMOD_V_MAJOR >= 1 && SOURCEMOD_V_MINOR >= 9 +typeset SteamWorksHTTPRequestCompleted +{ + function void (Handle hRequest, bool bFailure, bool bRequestSuccessful, EHTTPStatusCode eStatusCode); + function void (Handle hRequest, bool bFailure, bool bRequestSuccessful, EHTTPStatusCode eStatusCode, any data1); + function void (Handle hRequest, bool bFailure, bool bRequestSuccessful, EHTTPStatusCode eStatusCode, any data1, any data2); +}; + +typeset SteamWorksHTTPHeadersReceived +{ + function void (Handle hRequest, bool bFailure); + function void (Handle hRequest, bool bFailure, any data1); + function void (Handle hRequest, bool bFailure, any data1, any data2); +}; + +typeset SteamWorksHTTPDataReceived +{ + function void (Handle hRequest, bool bFailure, int offset, int bytesreceived); + function void (Handle hRequest, bool bFailure, int offset, int bytesreceived, any data1); + function void (Handle hRequest, bool bFailure, int offset, int bytesreceived, any data1, any data2); +}; + +typeset SteamWorksHTTPBodyCallback +{ + function void (const char[] sData); + function void (const char[] sData, any value); + function void (const int[] data, any value, int datalen); +}; + +#else + +funcenum SteamWorksHTTPRequestCompleted +{ + public(Handle:hRequest, bool:bFailure, bool:bRequestSuccessful, EHTTPStatusCode:eStatusCode), + public(Handle:hRequest, bool:bFailure, bool:bRequestSuccessful, EHTTPStatusCode:eStatusCode, any:data1), + public(Handle:hRequest, bool:bFailure, bool:bRequestSuccessful, EHTTPStatusCode:eStatusCode, any:data1, any:data2) +}; + +funcenum SteamWorksHTTPHeadersReceived +{ + public(Handle:hRequest, bool:bFailure), + public(Handle:hRequest, bool:bFailure, any:data1), + public(Handle:hRequest, bool:bFailure, any:data1, any:data2) +}; + +funcenum SteamWorksHTTPDataReceived +{ + public(Handle:hRequest, bool:bFailure, offset, bytesreceived), + public(Handle:hRequest, bool:bFailure, offset, bytesreceived, any:data1), + public(Handle:hRequest, bool:bFailure, offset, bytesreceived, any:data1, any:data2) +}; + +funcenum SteamWorksHTTPBodyCallback +{ + public(const String:sData[]), + public(const String:sData[], any:value), + public(const data[], any:value, datalen) +}; + +#endif + +native bool:SteamWorks_SetHTTPCallbacks(Handle:hHandle, SteamWorksHTTPRequestCompleted:fCompleted = INVALID_FUNCTION, SteamWorksHTTPHeadersReceived:fHeaders = INVALID_FUNCTION, SteamWorksHTTPDataReceived:fData = INVALID_FUNCTION, Handle:hCalling = INVALID_HANDLE); +native bool:SteamWorks_SendHTTPRequest(Handle:hRequest); +native bool:SteamWorks_SendHTTPRequestAndStreamResponse(Handle:hRequest); +native bool:SteamWorks_DeferHTTPRequest(Handle:hRequest); +native bool:SteamWorks_PrioritizeHTTPRequest(Handle:hRequest); +native bool:SteamWorks_GetHTTPResponseHeaderSize(Handle:hRequest, const String:sHeader[], &size); +native bool:SteamWorks_GetHTTPResponseHeaderValue(Handle:hRequest, const String:sHeader[], String:sValue[], size); +native bool:SteamWorks_GetHTTPResponseBodySize(Handle:hRequest, &size); +native bool:SteamWorks_GetHTTPResponseBodyData(Handle:hRequest, String:sBody[], length); +native bool:SteamWorks_GetHTTPStreamingResponseBodyData(Handle:hRequest, cOffset, String:sBody[], length); +native bool:SteamWorks_GetHTTPDownloadProgressPct(Handle:hRequest, &Float:percent); +native bool:SteamWorks_GetHTTPRequestWasTimedOut(Handle:hRequest, &bool:bWasTimedOut); +native bool:SteamWorks_SetHTTPRequestRawPostBody(Handle:hRequest, const String:sContentType[], const String:sBody[], bodylen); +native bool:SteamWorks_SetHTTPRequestRawPostBodyFromFile(Handle:hRequest, const String:sContentType[], const String:sFileName[]); + +native bool:SteamWorks_GetHTTPResponseBodyCallback(Handle:hRequest, SteamWorksHTTPBodyCallback:fCallback, any:data = 0, Handle:hPlugin = INVALID_HANDLE); /* Look up, moved definition for 1.7+ compat. */ +native bool:SteamWorks_WriteHTTPResponseBodyToFile(Handle:hRequest, const String:sFileName[]); + +forward SW_OnValidateClient(ownerauthid, authid); +forward SteamWorks_OnValidateClient(ownerauthid, authid); +forward SteamWorks_SteamServersConnected(); +forward SteamWorks_SteamServersConnectFailure(EResult:result); +forward SteamWorks_SteamServersDisconnected(EResult:result); + +forward Action:SteamWorks_RestartRequested(); +forward SteamWorks_TokenRequested(String:sToken[], maxlen); + +forward SteamWorks_OnClientGroupStatus(authid, groupid, bool:isMember, bool:isOfficer); + +forward EGCResults:SteamWorks_GCSendMessage(unMsgType, const String:pubData[], cubData); +forward SteamWorks_GCMsgAvailable(cubData); +forward EGCResults:SteamWorks_GCRetrieveMessage(punMsgType, const String:pubDest[], cubDest, pcubMsgSize); + +native EGCResults:SteamWorks_SendMessageToGC(unMsgType, const String:pubData[], cubData); + +public Extension:__ext_SteamWorks = +{ + name = "SteamWorks", + file = "SteamWorks.ext", +#if defined AUTOLOAD_EXTENSIONS + autoload = 1, +#else + autoload = 0, +#endif +#if defined REQUIRE_EXTENSIONS + required = 1, +#else + required = 0, +#endif +}; + +#if !defined REQUIRE_EXTENSIONS +public __ext_SteamWorks_SetNTVOptional() +{ + MarkNativeAsOptional("SteamWorks_IsVACEnabled"); + MarkNativeAsOptional("SteamWorks_GetPublicIP"); + MarkNativeAsOptional("SteamWorks_GetPublicIPCell"); + MarkNativeAsOptional("SteamWorks_IsLoaded"); + MarkNativeAsOptional("SteamWorks_SetGameData"); + MarkNativeAsOptional("SteamWorks_SetGameDescription"); + MarkNativeAsOptional("SteamWorks_IsConnected"); + MarkNativeAsOptional("SteamWorks_SetRule"); + MarkNativeAsOptional("SteamWorks_ClearRules"); + MarkNativeAsOptional("SteamWorks_ForceHeartbeat"); + MarkNativeAsOptional("SteamWorks_GetUserGroupStatus"); + MarkNativeAsOptional("SteamWorks_GetUserGroupStatusAuthID"); + + MarkNativeAsOptional("SteamWorks_HasLicenseForApp"); + MarkNativeAsOptional("SteamWorks_HasLicenseForAppId"); + MarkNativeAsOptional("SteamWorks_GetClientSteamID"); + + MarkNativeAsOptional("SteamWorks_RequestStatsAuthID"); + MarkNativeAsOptional("SteamWorks_RequestStats"); + MarkNativeAsOptional("SteamWorks_GetStatCell"); + MarkNativeAsOptional("SteamWorks_GetStatAuthIDCell"); + MarkNativeAsOptional("SteamWorks_GetStatFloat"); + MarkNativeAsOptional("SteamWorks_GetStatAuthIDFloat"); + + MarkNativeAsOptional("SteamWorks_SendMessageToGC"); + + MarkNativeAsOptional("SteamWorks_CreateHTTPRequest"); + MarkNativeAsOptional("SteamWorks_SetHTTPRequestContextValue"); + MarkNativeAsOptional("SteamWorks_SetHTTPRequestNetworkActivityTimeout"); + MarkNativeAsOptional("SteamWorks_SetHTTPRequestHeaderValue"); + MarkNativeAsOptional("SteamWorks_SetHTTPRequestGetOrPostParameter"); + + MarkNativeAsOptional("SteamWorks_SetHTTPCallbacks"); + MarkNativeAsOptional("SteamWorks_SendHTTPRequest"); + MarkNativeAsOptional("SteamWorks_SendHTTPRequestAndStreamResponse"); + MarkNativeAsOptional("SteamWorks_DeferHTTPRequest"); + MarkNativeAsOptional("SteamWorks_PrioritizeHTTPRequest"); + MarkNativeAsOptional("SteamWorks_GetHTTPResponseHeaderSize"); + MarkNativeAsOptional("SteamWorks_GetHTTPResponseHeaderValue"); + MarkNativeAsOptional("SteamWorks_GetHTTPResponseBodySize"); + MarkNativeAsOptional("SteamWorks_GetHTTPResponseBodyData"); + MarkNativeAsOptional("SteamWorks_GetHTTPStreamingResponseBodyData"); + MarkNativeAsOptional("SteamWorks_GetHTTPDownloadProgressPct"); + MarkNativeAsOptional("SteamWorks_SetHTTPRequestRawPostBody"); + MarkNativeAsOptional("SteamWorks_SetHTTPRequestRawPostBodyFromFile"); + + MarkNativeAsOptional("SteamWorks_GetHTTPResponseBodyCallback"); + MarkNativeAsOptional("SteamWorks_WriteHTTPResponseBodyToFile"); +} +#endif
\ No newline at end of file diff --git a/sourcemod/scripting/include/autoexecconfig.inc b/sourcemod/scripting/include/autoexecconfig.inc new file mode 100644 index 0000000..e057b1b --- /dev/null +++ b/sourcemod/scripting/include/autoexecconfig.inc @@ -0,0 +1,765 @@ +/** + * AutoExecConfig + * + * Copyright (C) 2013-2017 Impact + * + * 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 3 of the License, or + * 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, see <http://www.gnu.org/licenses/> + */ + +#if defined _autoexecconfig_included + #endinput +#endif +#define _autoexecconfig_included + + +#include <sourcemod> + +#define AUTOEXECCONFIG_VERSION "0.1.5" +#define AUTOEXECCONFIG_URL "https://forums.alliedmods.net/showthread.php?t=204254" + +// Append +#define AUTOEXEC_APPEND_BAD_FILENAME 0 +#define AUTOEXEC_APPEND_FILE_NOT_FOUND 1 +#define AUTOEXEC_APPEND_BAD_HANDLE 2 +#define AUTOEXEC_APPEND_SUCCESS 3 + + + +// Find +#define AUTOEXEC_FIND_BAD_FILENAME 10 +#define AUTOEXEC_FIND_FILE_NOT_FOUND 11 +#define AUTOEXEC_FIND_BAD_HANDLE 12 +#define AUTOEXEC_FIND_NOT_FOUND 13 +#define AUTOEXEC_FIND_SUCCESS 14 + + + +// Clean +#define AUTOEXEC_CLEAN_FILE_NOT_FOUND 20 +#define AUTOEXEC_CLEAN_BAD_HANDLE 21 +#define AUTOEXEC_CLEAN_SUCCESS 22 + + + +// General +#define AUTOEXEC_NO_CONFIG 30 + + + +// Formatter +#define AUTOEXEC_FORMAT_BAD_FILENAME 40 +#define AUTOEXEC_FORMAT_SUCCESS 41 + + + +// Global variables +static char g_sConfigFile[PLATFORM_MAX_PATH]; +static char g_sRawFileName[PLATFORM_MAX_PATH]; +static char g_sFolderPath[PLATFORM_MAX_PATH]; + +static bool g_bCreateFile = false; +static Handle g_hPluginHandle = null; + +static bool g_bCreateDirectory = false; +static int g_bCreateDirectoryMode = FPERM_U_READ|FPERM_U_WRITE|FPERM_U_EXEC|FPERM_G_READ|FPERM_G_EXEC|FPERM_O_READ|FPERM_O_EXEC; + + +// Workaround for now +static int g_iLastFindResult; +static int g_iLastAppendResult; + + + + +/** + * Returns the last result from the parser. + * + * @return Returns one of the AUTOEXEC_FIND values or -1 if not set. +*/ +stock int AutoExecConfig_GetFindResult() +{ + return g_iLastFindResult; +} + + + + + +/** + * Returns the last result from the appender. + * + * @return Returns one of the AUTOEXEC_APPEND values or -1 if not set. +*/ +stock int AutoExecConfig_GetAppendResult() +{ + return g_iLastAppendResult; +} + + +/** + * Set if the config file should be created by the autoexecconfig include itself if it doesn't exist. + * + * @param create True if config file should be created, false otherwise. + * @noreturn + */ +stock void AutoExecConfig_SetCreateFile(bool create) +{ + g_bCreateFile = create; +} + + +/** + * Set if the config file's folder should be created by the autoexecconfig include itself if it doesn't exist. + * Note: Must be used before AutoExecConfig_SetFile as the potential creation of it happens there + * + * @param create True if config file should be created, false otherwise. + * @param mode Folder permission mode, default is u=rwx,g=rx,o=rx. + * @noreturn + */ +stock void AutoExecConfig_SetCreateDirectory(bool create, int mode=FPERM_U_READ|FPERM_U_WRITE|FPERM_U_EXEC|FPERM_G_READ|FPERM_G_EXEC|FPERM_O_READ|FPERM_O_EXEC) +{ + g_bCreateDirectory = create; + g_bCreateDirectoryMode = mode; +} + + +/** + * Returns if the config file should be created if it doesn't exist. + * + * @return Returns true, if the config file should be created or false if it should not. + */ +stock bool AutoExecConfig_GetCreateFile() +{ + return g_bCreateFile; +} + + +/** + * Set the plugin for which the config file should be created. + * Set to null to use the calling plugin. + * Used to print the correct filename in the top comment when creating the file. + * + * @param plugin The plugin to create convars for or null to use the calling plugin. + * @noreturn + */ +stock void AutoExecConfig_SetPlugin(Handle plugin) +{ + g_hPluginHandle = plugin; +} + + +/** + * Returns the plugin's handle for which the config file is created. + * + * @return The plugin handle + */ +stock Handle AutoExecConfig_GetPlugin() +{ + return g_hPluginHandle; +} + + +/** + * Set the global autoconfigfile used by functions of this file. + * Note: does not support subfolders like folder1/folder2 + * + * @param file Name of the config file, path and .cfg extension is being added if not given. + * @param folder Folder under cfg/ to use. By default this is "sourcemod." + * @return True if formatter returned success, false otherwise. +*/ +stock bool AutoExecConfig_SetFile(char[] file, char[] folder="sourcemod") +{ + Format(g_sConfigFile, sizeof(g_sConfigFile), "%s", file); + + // Global buffers for cfg execution + strcopy(g_sRawFileName, sizeof(g_sRawFileName), file); + strcopy(g_sFolderPath, sizeof(g_sFolderPath), folder); + + + // Format the filename + return AutoExecConfig_FormatFileName(g_sConfigFile, sizeof(g_sConfigFile), folder) == AUTOEXEC_FORMAT_SUCCESS; +} + + + + + + +/** + * Get the formatted autoconfigfile used by functions of this file. + * + * @param buffer String to format. + * @param size Maximum size of buffer + * @return True if filename was set, false otherwise. +*/ +stock bool AutoExecConfig_GetFile(char[] buffer,int size) +{ + if (strlen(g_sConfigFile) > 0) + { + strcopy(buffer, size, g_sConfigFile); + + return true; + } + + // Security for decl users + buffer[0] = '\0'; + + return false; +} + + + + + + +/** + * Creates a convar and appends it to the autoconfigfile if not found. + * FCVAR_DONTRECORD will be skipped. + * + * @param name Name of new convar. + * @param defaultValue String containing the default value of new convar. + * @param description Optional description of the convar. + * @param flags Optional bitstring of flags determining how the convar should be handled. See FCVAR_* constants for more details. + * @param hasMin Optional boolean that determines if the convar has a minimum value. + * @param min Minimum floating point value that the convar can have if hasMin is true. + * @param hasMax Optional boolean that determines if the convar has a maximum value. + * @param max Maximum floating point value that the convar can have if hasMax is true. + * @return A handle to the newly created convar. If the convar already exists, a handle to it will still be returned. + * @error Convar name is blank or is the same as an existing console command. +*/ +stock ConVar AutoExecConfig_CreateConVar(const char[] name, const char[] defaultValue, const char[] description="", int flags=0, bool hasMin=false, float min=0.0, bool hasMax=false, float max=0.0) +{ + // If configfile was set and convar has no dontrecord flag + if (!(flags & FCVAR_DONTRECORD) && strlen(g_sConfigFile) > 0) + { + // Reset the results + g_iLastFindResult = -1; + g_iLastAppendResult = -1; + + + // Add it if not found + char buffer[64]; + + g_iLastFindResult = AutoExecConfig_FindValue(name, buffer, sizeof(buffer), true); + + // We only add this convar if it doesn't exist, or the file doesn't exist and it should be auto-generated + if (g_iLastFindResult == AUTOEXEC_FIND_NOT_FOUND || (g_iLastFindResult == AUTOEXEC_FIND_FILE_NOT_FOUND && g_bCreateFile)) + { + g_iLastAppendResult = AutoExecConfig_AppendValue(name, defaultValue, description, flags, hasMin, min, hasMax, max); + } + } + + + // Create the convar + return CreateConVar(name, defaultValue, description, flags, hasMin, min, hasMax, max); +} + + + + +/** + * Executes the autoconfigfile and adds it to the OnConfigsExecuted forward. + * If we didn't create it ourselves we let SourceMod create it. + * + * @noreturn +*/ +stock void AutoExecConfig_ExecuteFile() +{ + // Only let sourcemod create the file, if we didn't do that already. + AutoExecConfig(!g_bCreateFile, g_sRawFileName, g_sFolderPath); +} + + + + + +/** + * Formats a autoconfigfile, prefixes path and adds .cfg extension if missing. + * + * @param buffer String to format. + * @param size Maximum size of buffer. + * @return Returns one of the AUTOEXEC_FORMAT values.. +*/ +stock static int AutoExecConfig_FormatFileName(char[] buffer, int size, char[] folder="sourcemod") +{ + // No config set + if (strlen(g_sConfigFile) < 1) + { + return AUTOEXEC_NO_CONFIG; + } + + + // Can't be an cfgfile + if (StrContains(g_sConfigFile, ".cfg") != -1 && strlen(g_sConfigFile) < 4) + { + return AUTOEXEC_FORMAT_BAD_FILENAME; + } + + + // Pathprefix + char pathprefixbuffer[PLATFORM_MAX_PATH]; + if (strlen(folder) > 0) + { + Format(pathprefixbuffer, sizeof(pathprefixbuffer), "cfg/%s/", folder); + + if (g_bCreateDirectory && !DirExists(pathprefixbuffer)) + { + CreateDirectory(pathprefixbuffer, g_bCreateDirectoryMode); + } + } + else + { + Format(pathprefixbuffer, sizeof(pathprefixbuffer), "cfg/"); + } + + + char filebuffer[PLATFORM_MAX_PATH]; + filebuffer[0] = '\0'; + + // Add path if file doesn't begin with it + if (StrContains(buffer, pathprefixbuffer) != 0) + { + StrCat(filebuffer, sizeof(filebuffer), pathprefixbuffer); + } + + StrCat(filebuffer, sizeof(filebuffer), g_sConfigFile); + + + // Add .cfg extension if file doesn't end with it + if (StrContains(filebuffer[strlen(filebuffer) - 4], ".cfg") != 0) + { + StrCat(filebuffer, sizeof(filebuffer), ".cfg"); + } + + strcopy(buffer, size, filebuffer); + + return AUTOEXEC_FORMAT_SUCCESS; +} + + + + + + +/** + * Appends a convar to the global autoconfigfile + * + * @param name Name of new convar. + * @param defaultValue String containing the default value of new convar. + * @param description Optional description of the convar. + * @param flags Optional bitstring of flags determining how the convar should be handled. See FCVAR_* constants for more details. + * @param hasMin Optional boolean that determines if the convar has a minimum value. + * @param min Minimum floating point value that the convar can have if hasMin is true. + * @param hasMax Optional boolean that determines if the convar has a maximum value. + * @param max Maximum floating point value that the convar can have if hasMax is true. + * @return Returns one of the AUTOEXEC_APPEND values +*/ +stock int AutoExecConfig_AppendValue(const char[] name, const char[] defaultValue, const char[] description, int flags, bool hasMin, float min, bool hasMax, float max) +{ + // No config set + if (strlen(g_sConfigFile) < 1) + { + return AUTOEXEC_NO_CONFIG; + } + + + char filebuffer[PLATFORM_MAX_PATH]; + strcopy(filebuffer, sizeof(filebuffer), g_sConfigFile); + + + //PrintToServer("pathbuffer: %s", filebuffer); + + bool bFileExists = FileExists(filebuffer); + + if (g_bCreateFile || bFileExists) + { + // If the file already exists we open it in append mode, otherwise we use a write mode which creates the file + File fFile = OpenFile(filebuffer, (bFileExists ? "a" : "w")); + char writebuffer[2048]; + + + if (fFile == null) + { + return AUTOEXEC_APPEND_BAD_HANDLE; + } + + // We just created the file, so add some header about version and stuff + if (g_bCreateFile && !bFileExists) + { + fFile.WriteLine( "// This file was auto-generated by AutoExecConfig v%s (%s)", AUTOEXECCONFIG_VERSION, AUTOEXECCONFIG_URL); + + GetPluginFilename(g_hPluginHandle, writebuffer, sizeof(writebuffer)); + Format(writebuffer, sizeof(writebuffer), "// ConVars for plugin \"%s\"", writebuffer); + fFile.WriteLine(writebuffer); + } + + // Spacer + fFile.WriteLine("\n"); + + + // This is used for multiline comments + int newlines = GetCharCountInStr('\n', description); + if (newlines == 0) + { + // We have no newlines, we can write the description to the file as is + Format(writebuffer, sizeof(writebuffer), "// %s", description); + fFile.WriteLine(writebuffer); + } + else + { + char[][] newlineBuf = new char[newlines +1][2048]; + ExplodeString(description, "\n", newlineBuf, newlines +1, 2048, false); + + // Each newline gets a commented newline + for (int i; i <= newlines; i++) + { + if (strlen(newlineBuf[i]) > 0) + { + fFile.WriteLine("// %s", newlineBuf[i]); + } + } + } + + + // Descspacer + fFile.WriteLine("// -"); + + + // Default + Format(writebuffer, sizeof(writebuffer), "// Default: \"%s\"", defaultValue); + fFile.WriteLine(writebuffer); + + + // Minimum + if (hasMin) + { + Format(writebuffer, sizeof(writebuffer), "// Minimum: \"%f\"", min); + fFile.WriteLine(writebuffer); + } + + + // Maximum + if (hasMax) + { + Format(writebuffer, sizeof(writebuffer), "// Maximum: \"%f\"", max); + fFile.WriteLine(writebuffer); + } + + + // Write end and defaultvalue + Format(writebuffer, sizeof(writebuffer), "%s \"%s\"", name, defaultValue); + fFile.WriteLine(writebuffer); + + + fFile.Close(); + + return AUTOEXEC_APPEND_SUCCESS; + } + + return AUTOEXEC_APPEND_FILE_NOT_FOUND; +} + + + + + + +/** + * Returns a convar's value from the global autoconfigfile + * + * @param cvar Cvar to search for. + * @param value Buffer to store result into. + * @param size Maximum size of buffer. + * @param caseSensitive Whether or not the search should be case sensitive. + * @return Returns one of the AUTOEXEC_FIND values +*/ +stock int AutoExecConfig_FindValue(const char[] cvar, char[] value, int size, bool caseSensitive=false) +{ + // Security for decl users + value[0] = '\0'; + + + // No config set + if (strlen(g_sConfigFile) < 1) + { + return AUTOEXEC_NO_CONFIG; + } + + + char filebuffer[PLATFORM_MAX_PATH]; + strcopy(filebuffer, sizeof(filebuffer), g_sConfigFile); + + + + //PrintToServer("pathbuffer: %s", filebuffer); + + bool bFileExists = FileExists(filebuffer); + + // We want to create the config file and it doesn't exist yet. + if (g_bCreateFile && !bFileExists) + { + return AUTOEXEC_FIND_FILE_NOT_FOUND; + } + + + if (bFileExists) + { + File fFile = OpenFile(filebuffer, "r"); + int valuestart; + int valueend; + int cvarend; + + // Just an reminder to self, leave the values that high + char sConvar[64]; + char sValue[64]; + char readbuffer[2048]; + char copybuffer[2048]; + + if (fFile == null) + { + return AUTOEXEC_FIND_BAD_HANDLE; + } + + + while (!fFile.EndOfFile() && fFile.ReadLine(readbuffer, sizeof(readbuffer))) + { + // Is a comment or not valid + if (IsCharSpace(readbuffer[0]) || readbuffer[0] == '/' || (!IsCharNumeric(readbuffer[0]) && !IsCharAlpha(readbuffer[0])) ) + { + continue; + } + + + // Has not enough spaces, must have at least 1 + if (GetCharCountInStr(' ', readbuffer) < 1) + { + continue; + } + + + // Ignore cvars which aren't quoted + if (GetCharCountInStr('"', readbuffer) != 2) + { + continue; + } + + + + // Get the start of the value + if ( (valuestart = StrContains(readbuffer, "\"")) == -1 ) + { + continue; + } + + + // Get the end of the value + if ( (valueend = StrContains(readbuffer[valuestart+1], "\"")) == -1 ) + { + continue; + } + + + // Get the start of the cvar, + if ( (cvarend = StrContains(readbuffer, " ")) == -1 || cvarend >= valuestart) + { + continue; + } + + + // Skip if cvarendindex is before valuestartindex + if (cvarend >= valuestart) + { + continue; + } + + + // Convar + // Tempcopy for security + strcopy(copybuffer, sizeof(copybuffer), readbuffer); + copybuffer[cvarend] = '\0'; + + strcopy(sConvar, sizeof(sConvar), copybuffer); + + + // Value + // Tempcopy for security + strcopy(copybuffer, sizeof(copybuffer), readbuffer[valuestart+1]); + copybuffer[valueend] = '\0'; + + strcopy(sValue, sizeof(sValue), copybuffer); + + + //PrintToServer("Cvar %s has a value of %s", sConvar, sValue); + + if (StrEqual(sConvar, cvar, caseSensitive)) + { + Format(value, size, "%s", sConvar); + + fFile.Close(); + return AUTOEXEC_FIND_SUCCESS; + } + } + + fFile.Close(); + return AUTOEXEC_FIND_NOT_FOUND; + } + + + return AUTOEXEC_FIND_FILE_NOT_FOUND; +} + + + + + + +/** + * Cleans the global autoconfigfile from too much spaces + * + * @return One of the AUTOEXEC_CLEAN values. +*/ +stock int AutoExecConfig_CleanFile() +{ + // No config set + if (strlen(g_sConfigFile) < 1) + { + return AUTOEXEC_NO_CONFIG; + } + + + char sfile[PLATFORM_MAX_PATH]; + strcopy(sfile, sizeof(sfile), g_sConfigFile); + + + // Security + if (!FileExists(sfile)) + { + return AUTOEXEC_CLEAN_FILE_NOT_FOUND; + } + + + + char sfile2[PLATFORM_MAX_PATH]; + Format(sfile2, sizeof(sfile2), "%s_tempcopy", sfile); + + + char readbuffer[2048]; + int count; + bool firstreached; + + + // Open files + File fFile1 = OpenFile(sfile, "r"); + File fFile2 = OpenFile(sfile2, "w"); + + + + // Check filehandles + if (fFile1 == null || fFile2 == null) + { + if (fFile1 != null) + { + //PrintToServer("Handle1 invalid"); + fFile1.Close(); + } + + if (fFile2 != null) + { + //PrintToServer("Handle2 invalid"); + fFile2.Close(); + } + + return AUTOEXEC_CLEAN_BAD_HANDLE; + } + + + + while (!fFile1.EndOfFile() && fFile1.ReadLine(readbuffer, sizeof(readbuffer))) + { + // Is space + if (IsCharSpace(readbuffer[0])) + { + count++; + } + // No space, count from start + else + { + count = 0; + } + + + // Don't write more than 1 space if seperation after informations have been reached + if (count < 2 || !firstreached) + { + ReplaceString(readbuffer, sizeof(readbuffer), "\n", ""); + fFile2.WriteLine(readbuffer); + } + + + // First bigger seperation after informations has been reached + if (count == 2) + { + firstreached = true; + } + } + + + fFile1.Close(); + fFile2.Close(); + + + // This might be a risk, for now it works + DeleteFile(sfile); + RenameFile(sfile, sfile2); + + return AUTOEXEC_CLEAN_SUCCESS; +} + + + + + + +/** + * Returns how many times the given char occures in the given string. + * + * @param str String to search for in. + * @return Occurences of the given char found in string. +*/ +stock static int GetCharCountInStr(int character, const char[] str) +{ + int len = strlen(str); + int count; + + for (int i; i < len; i++) + { + if (str[i] == character) + { + count++; + } + } + + return count; +} + + + + + + +#pragma deprecated +stock bool AutoExecConfig_CacheConvars() +{ + return false; +} diff --git a/sourcemod/scripting/include/colors.inc b/sourcemod/scripting/include/colors.inc new file mode 100644 index 0000000..3ce8b6a --- /dev/null +++ b/sourcemod/scripting/include/colors.inc @@ -0,0 +1,945 @@ +/************************************************************************** + * * + * Colored Chat Functions * + * Author: exvel, Editor: Popoklopsi, Powerlord, Bara * + * Version: 1.2.3 * + * by modified by 1NutWunDeR * + **************************************************************************/ + +/*Info: purple works only with CPrintToChat and CPrintToChatAll and without {blue} in the same string + (volvo gave them the same color code and saytext2 overrides purple with your current teamcolor.)*/ + +#if defined _colors_included + #endinput +#endif +#define _colors_included + +#define MAX_MESSAGE_LENGTH 320 +#define MAX_COLORS 17 + +#define SERVER_INDEX 0 +#define NO_INDEX -1 +#define NO_PLAYER -2 + +enum Colors +{ + Color_Default = 0, + Color_Darkred, + Color_Green, + Color_Lightgreen, + Color_Red, + Color_Blue, + Color_Olive, + Color_Lime, + Color_Orange, + Color_Purple, + Color_Grey, + Color_Yellow, + Color_Lightblue, + Color_Steelblue, + Color_Darkblue, + Color_Pink, + Color_Lightred, +} + +/* Colors' properties */ +// {"{default}", "{darkred}", "{green}", "{lightgreen}", "{orange}", "{blue}", "{olive}", "{lime}", "{red}", "{purple}", "{grey}", "{yellow}", "{lightblue}", "{steelblue}", "{darkblue}", "{pink}", "{lightred}"}; +new String:CTag[][] = {"{d}", "{dr}", "{gr}", "{lg}", "{o}", "{b}", "{ol}", "{l}", "{r}", "{p}", "{g}", "{y}", "{lb}", "{sb}", "{db}", "{pi}", "{lr}"}; +new String:CTagCode[][] = {"\x01", "\x02", "\x04", "\x03", "\x03", "\x03", "\x05", "\x06", "\x07", "\x03", "\x08", "\x09","\x0A","\x0B","\x0C","\x0E","\x0F"}; +new bool:CTagReqSayText2[] = {false, false, false, true, true, true, false, false, false, false, false, false, false, false, false, false, false}; +new bool:CEventIsHooked = false; +new bool:CSkipList[MAXPLAYERS+1] = {false,...}; + +/* Game default profile */ +new bool:CProfile_Colors[] = {true, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false}; +new CProfile_TeamIndex[] = {NO_INDEX, NO_INDEX, NO_INDEX, NO_INDEX, NO_INDEX, NO_INDEX, NO_INDEX, NO_INDEX, NO_INDEX, NO_INDEX, NO_INDEX, NO_INDEX, NO_INDEX, NO_INDEX, NO_INDEX}; +new bool:CProfile_SayText2 = false; + + +static Handle:sm_show_activity = INVALID_HANDLE; + +/** + * Prints a message to a specific client in the chat area. + * Supports color tags. + * + * @param client Client index. + * @param szMessage Message (formatting rules). + * @return No return + * + * On error/Errors: If the client is not connected an error will be thrown. + */ +stock CPrintToChat(client, const String:szMessage[], any:...) +{ + if (client <= 0 || client > MaxClients) + ThrowError("Invalid client index %d", client); + + if (!IsClientInGame(client)) + ThrowError("Client %d is not in game", client); + + decl String:szBuffer[MAX_MESSAGE_LENGTH]; + decl String:szCMessage[MAX_MESSAGE_LENGTH]; + + SetGlobalTransTarget(client); + + Format(szBuffer, sizeof(szBuffer), "\x01%s", szMessage); + VFormat(szCMessage, sizeof(szCMessage), szBuffer, 3); + + new index = CFormat(szCMessage, sizeof(szCMessage)); + + if (index == NO_INDEX) + PrintToChat(client, "%s", szCMessage); + else + CSayText2(client, index, szCMessage); +} + +/** + * Reples to a message in a command. A client index of 0 will use PrintToServer(). + * If the command was from the console, PrintToConsole() is used. If the command was from chat, CPrintToChat() is used. + * Supports color tags. + * + * @param client Client index, or 0 for server. + * @param szMessage Formatting rules. + * @param ... Variable number of format parameters. + * @return No return + * + * On error/Errors: If the client is not connected or invalid. + */ +stock CReplyToCommand(client, const String:szMessage[], any:...) +{ + decl String:szCMessage[MAX_MESSAGE_LENGTH]; + SetGlobalTransTarget(client); + VFormat(szCMessage, sizeof(szCMessage), szMessage, 3); + + if (client == 0) + { + CRemoveTags(szCMessage, sizeof(szCMessage)); + PrintToServer("%s", szCMessage); + } + else if (GetCmdReplySource() == SM_REPLY_TO_CONSOLE) + { + CRemoveTags(szCMessage, sizeof(szCMessage)); + PrintToConsole(client, "%s", szCMessage); + } + else + { + CPrintToChat(client, "%s", szCMessage); + } +} + +/** + * Reples to a message in a command. A client index of 0 will use PrintToServer(). + * If the command was from the console, PrintToConsole() is used. If the command was from chat, CPrintToChat() is used. + * Supports color tags. + * + * @param client Client index, or 0 for server. + * @param author Author index whose color will be used for teamcolor tag. + * @param szMessage Formatting rules. + * @param ... Variable number of format parameters. + * @return No return + * + * On error/Errors: If the client is not connected or invalid. + */ +stock CReplyToCommandEx(client, author, const String:szMessage[], any:...) +{ + decl String:szCMessage[MAX_MESSAGE_LENGTH]; + SetGlobalTransTarget(client); + VFormat(szCMessage, sizeof(szCMessage), szMessage, 4); + + if (client == 0) + { + CRemoveTags(szCMessage, sizeof(szCMessage)); + PrintToServer("%s", szCMessage); + } + else if (GetCmdReplySource() == SM_REPLY_TO_CONSOLE) + { + CRemoveTags(szCMessage, sizeof(szCMessage)); + PrintToConsole(client, "%s", szCMessage); + } + else + { + CPrintToChatEx(client, author, "%s", szCMessage); + } +} + +/** + * Prints a message to all clients in the chat area. + * Supports color tags. + * + * @param client Client index. + * @param szMessage Message (formatting rules) + * @return No return + */ +stock CPrintToChatAll(const String:szMessage[], any:...) +{ + decl String:szBuffer[MAX_MESSAGE_LENGTH]; + + for (new i = 1; i <= MaxClients; i++) + { + if (IsClientInGame(i) && !IsFakeClient(i) && !CSkipList[i]) + { + SetGlobalTransTarget(i); + VFormat(szBuffer, sizeof(szBuffer), szMessage, 2); + + CPrintToChat(i, "%s", szBuffer); + } + + CSkipList[i] = false; + } +} + +/** + * Prints a message to a specific client in the chat area. + * Supports color tags and teamcolor tag. + * + * @param client Client index. + * @param author Author index whose color will be used for teamcolor tag. + * @param szMessage Message (formatting rules). + * @return No return + * + * On error/Errors: If the client or author are not connected an error will be thrown. + */ +stock CPrintToChatEx(client, author, const String:szMessage[], any:...) +{ + if (client <= 0 || client > MaxClients) + ThrowError("Invalid client index %d", client); + + if (!IsClientInGame(client)) + ThrowError("Client %d is not in game", client); + + if (author < 0 || author > MaxClients) + ThrowError("Invalid client index %d", author); + + decl String:szBuffer[MAX_MESSAGE_LENGTH]; + decl String:szCMessage[MAX_MESSAGE_LENGTH]; + + SetGlobalTransTarget(client); + + Format(szBuffer, sizeof(szBuffer), "\x01%s", szMessage); + VFormat(szCMessage, sizeof(szCMessage), szBuffer, 4); + + new index = CFormat(szCMessage, sizeof(szCMessage), author); + + if (index == NO_INDEX) + PrintToChat(client, "%s", szCMessage); + else + CSayText2(client, author, szCMessage); +} + +/** + * Prints a message to all clients in the chat area. + * Supports color tags and teamcolor tag. + * + * @param author Author index whos color will be used for teamcolor tag. + * @param szMessage Message (formatting rules). + * @return No return + * + * On error/Errors: If the author is not connected an error will be thrown. + */ +stock CPrintToChatAllEx(author, const String:szMessage[], any:...) +{ + if (author < 0 || author > MaxClients) + ThrowError("Invalid client index %d", author); + + if (!IsClientInGame(author)) + ThrowError("Client %d is not in game", author); + + decl String:szBuffer[MAX_MESSAGE_LENGTH]; + + for (new i = 1; i <= MaxClients; i++) + { + if (IsClientInGame(i) && !IsFakeClient(i) && !CSkipList[i]) + { + SetGlobalTransTarget(i); + VFormat(szBuffer, sizeof(szBuffer), szMessage, 3); + + CPrintToChatEx(i, author, "%s", szBuffer); + } + + CSkipList[i] = false; + } +} + +/** + * Removes color tags from the string. + * + * @param szMessage String. + * @return No return + */ +stock CRemoveTags(String:szMessage[], maxlength) +{ + for (new i = 0; i < MAX_COLORS; i++) + ReplaceString(szMessage, maxlength, CTag[i], "", false); + + ReplaceString(szMessage, maxlength, "{teamcolor}", "", false); +} + +/** + * Checks whether a color is allowed or not + * + * @param tag Color Tag. + * @return True when color is supported, otherwise false + */ +stock CColorAllowed(Colors:color) +{ + if (!CEventIsHooked) + { + CSetupProfile(); + + CEventIsHooked = true; + } + + return CProfile_Colors[color]; +} + +/** + * Replace the color with another color + * Handle with care! + * + * @param color color to replace. + * @param newColor color to replace with. + * @noreturn + */ +stock CReplaceColor(Colors:color, Colors:newColor) +{ + if (!CEventIsHooked) + { + CSetupProfile(); + + CEventIsHooked = true; + } + + CProfile_Colors[color] = CProfile_Colors[newColor]; + CProfile_TeamIndex[color] = CProfile_TeamIndex[newColor]; + + CTagReqSayText2[color] = CTagReqSayText2[newColor]; + Format(CTagCode[color], sizeof(CTagCode[]), CTagCode[newColor]) +} + +/** + * This function should only be used right in front of + * CPrintToChatAll or CPrintToChatAllEx and it tells + * to those funcions to skip specified client when printing + * message to all clients. After message is printed client will + * no more be skipped. + * + * @param client Client index + * @return No return + */ +stock CSkipNextClient(client) +{ + if (client <= 0 || client > MaxClients) + ThrowError("Invalid client index %d", client); + + CSkipList[client] = true; +} + +/** + * Replaces color tags in a string with color codes + * + * @param szMessage String. + * @param maxlength Maximum length of the string buffer. + * @return Client index that can be used for SayText2 author index + * + * On error/Errors: If there is more then one team color is used an error will be thrown. + */ +stock CFormat(String:szMessage[], maxlength, author=NO_INDEX) +{ + decl String:szGameName[30]; + + GetGameFolderName(szGameName, sizeof(szGameName)); + + /* Hook event for auto profile setup on map start */ + if (!CEventIsHooked) + { + CSetupProfile(); + HookEvent("server_spawn", CEvent_MapStart, EventHookMode_PostNoCopy); + + CEventIsHooked = true; + } + + new iRandomPlayer = NO_INDEX; + + // On CS:GO set invisible precolor + if (StrEqual(szGameName, "csgo", false)) + Format(szMessage, maxlength, " \x01\x0B\x01%s", szMessage); + + /* If author was specified replace {teamcolor} tag */ + if (author != NO_INDEX) + { + if (CProfile_SayText2) + { + ReplaceString(szMessage, maxlength, "{teamcolor}", "\x03", false); + + iRandomPlayer = author; + } + /* If saytext2 is not supported by game replace {teamcolor} with green tag */ + else + ReplaceString(szMessage, maxlength, "{teamcolor}", CTagCode[Color_Green], false); + } + else + ReplaceString(szMessage, maxlength, "{teamcolor}", "", false); + + /* For other color tags we need a loop */ + for (new i = 0; i < MAX_COLORS; i++) + { + /* If tag not found - skip */ + if (StrContains(szMessage, CTag[i], false) == -1) + continue; + + /* If tag is not supported by game replace it with green tag */ + else if (!CProfile_Colors[i]) + ReplaceString(szMessage, maxlength, CTag[i], CTagCode[Color_Green], false); + + /* If tag doesn't need saytext2 simply replace */ + else if (!CTagReqSayText2[i]) + ReplaceString(szMessage, maxlength, CTag[i], CTagCode[i], false); + + /* Tag needs saytext2 */ + else + { + /* If saytext2 is not supported by game replace tag with green tag */ + if (!CProfile_SayText2) + ReplaceString(szMessage, maxlength, CTag[i], CTagCode[Color_Green], false); + + /* Game supports saytext2 */ + else + { + /* If random player for tag wasn't specified replace tag and find player */ + if (iRandomPlayer == NO_INDEX) + { + /* Searching for valid client for tag */ + iRandomPlayer = CFindRandomPlayerByTeam(CProfile_TeamIndex[i]); + + /* If player not found replace tag with green color tag */ + if (iRandomPlayer == NO_PLAYER) + ReplaceString(szMessage, maxlength, CTag[i], CTagCode[Color_Green], false); + + /* If player was found simply replace */ + else + ReplaceString(szMessage, maxlength, CTag[i], CTagCode[i], false); + + } + /* If found another team color tag throw error */ + else + { + //ReplaceString(szMessage, maxlength, CTag[i], ""); + ThrowError("Using two team colors in one message is not allowed"); + } + } + + } + } + + return iRandomPlayer; +} + +/** + * Founds a random player with specified team + * + * @param color_team Client team. + * @return Client index or NO_PLAYER if no player found + */ +stock CFindRandomPlayerByTeam(color_team) +{ + if (color_team == SERVER_INDEX) + return 0; + else + { + for (new i = 1; i <= MaxClients; i++) + { + if (IsClientInGame(i) && GetClientTeam(i) == color_team) + return i; + } + } + + return NO_PLAYER; +} + +/** + * Sends a SayText2 usermessage to a client + * + * @param szMessage Client index + * @param maxlength Author index + * @param szMessage Message + * @return No return. + */ +stock CSayText2(client, author, const String:szMessage[]) +{ + new Handle:hBuffer = StartMessageOne("SayText2", client, USERMSG_RELIABLE|USERMSG_BLOCKHOOKS); + + if(GetFeatureStatus(FeatureType_Native, "GetUserMessageType") == FeatureStatus_Available && GetUserMessageType() == UM_Protobuf) + { + PbSetInt(hBuffer, "ent_idx", author); + PbSetBool(hBuffer, "chat", true); + PbSetString(hBuffer, "msg_name", szMessage); + PbAddString(hBuffer, "params", ""); + PbAddString(hBuffer, "params", ""); + PbAddString(hBuffer, "params", ""); + PbAddString(hBuffer, "params", ""); + } + else + { + BfWriteByte(hBuffer, author); + BfWriteByte(hBuffer, true); + BfWriteString(hBuffer, szMessage); + } + + EndMessage(); +} + +/** + * Creates game color profile + * This function must be edited if you want to add more games support + * + * @return No return. + */ +stock CSetupProfile() +{ + decl String:szGameName[30]; + GetGameFolderName(szGameName, sizeof(szGameName)); + + if (StrEqual(szGameName, "cstrike", false)) + { + CProfile_Colors[Color_Lightgreen] = true; + CProfile_Colors[Color_Orange] = true; + CProfile_Colors[Color_Blue] = true; + CProfile_Colors[Color_Olive] = true; + CProfile_TeamIndex[Color_Lightgreen] = SERVER_INDEX; + CProfile_TeamIndex[Color_Orange] = 2; + CProfile_TeamIndex[Color_Blue] = 3; + CProfile_SayText2 = true; + } + else if (StrEqual(szGameName, "csgo", false)) + { + CProfile_Colors[Color_Red] = true; + CProfile_Colors[Color_Blue] = true; + CProfile_Colors[Color_Olive] = true; + CProfile_Colors[Color_Darkred] = true; + CProfile_Colors[Color_Lime] = true; + CProfile_Colors[Color_Purple] = true; + CProfile_Colors[Color_Grey] = true; + CProfile_Colors[Color_Yellow] = true; + CProfile_Colors[Color_Lightblue] = true; + CProfile_Colors[Color_Steelblue] = true; + CProfile_Colors[Color_Darkblue] = true; + CProfile_Colors[Color_Pink] = true; + CProfile_Colors[Color_Lightred] = true; + CProfile_TeamIndex[Color_Orange] = 2; + CProfile_TeamIndex[Color_Blue] = 3; + CProfile_SayText2 = true; + } + else if (StrEqual(szGameName, "tf", false)) + { + CProfile_Colors[Color_Lightgreen] = true; + CProfile_Colors[Color_Orange] = true; + CProfile_Colors[Color_Blue] = true; + CProfile_Colors[Color_Olive] = true; + CProfile_TeamIndex[Color_Lightgreen] = SERVER_INDEX; + CProfile_TeamIndex[Color_Orange] = 2; + CProfile_TeamIndex[Color_Blue] = 3; + CProfile_SayText2 = true; + } + else if (StrEqual(szGameName, "left4dead", false) || StrEqual(szGameName, "left4dead2", false)) + { + CProfile_Colors[Color_Lightgreen] = true; + CProfile_Colors[Color_Orange] = true; + CProfile_Colors[Color_Blue] = true; + CProfile_Colors[Color_Olive] = true; + CProfile_TeamIndex[Color_Lightgreen] = SERVER_INDEX; + CProfile_TeamIndex[Color_Orange] = 3; + CProfile_TeamIndex[Color_Blue] = 2; + CProfile_SayText2 = true; + } + else if (StrEqual(szGameName, "hl2mp", false)) + { + /* hl2mp profile is based on mp_teamplay convar */ + if (GetConVarBool(FindConVar("mp_teamplay"))) + { + CProfile_Colors[Color_Orange] = true; + CProfile_Colors[Color_Blue] = true; + CProfile_Colors[Color_Olive] = true; + CProfile_TeamIndex[Color_Orange] = 3; + CProfile_TeamIndex[Color_Blue] = 2; + CProfile_SayText2 = true; + } + else + { + CProfile_SayText2 = false; + CProfile_Colors[Color_Olive] = true; + } + } + else if (StrEqual(szGameName, "dod", false)) + { + CProfile_Colors[Color_Olive] = true; + CProfile_SayText2 = false; + } + /* Profile for other games */ + else + { + if (GetUserMessageId("SayText2") == INVALID_MESSAGE_ID) + { + CProfile_SayText2 = false; + } + else + { + CProfile_Colors[Color_Orange] = true; + CProfile_Colors[Color_Blue] = true; + CProfile_TeamIndex[Color_Orange] = 2; + CProfile_TeamIndex[Color_Blue] = 3; + CProfile_SayText2 = true; + } + } +} + +public Action:CEvent_MapStart(Handle:event, const String:name[], bool:dontBroadcast) +{ + CSetupProfile(); + + for (new i = 1; i <= MaxClients; i++) + CSkipList[i] = false; +} + +/** + * Displays usage of an admin command to users depending on the + * setting of the sm_show_activity cvar. + * + * This version does not display a message to the originating client + * if used from chat triggers or menus. If manual replies are used + * for these cases, then this function will suffice. Otherwise, + * CShowActivity2() is slightly more useful. + * Supports color tags. + * + * @param client Client index doing the action, or 0 for server. + * @param format Formatting rules. + * @param ... Variable number of format parameters. + * @noreturn + * @error + */ +stock CShowActivity(client, const String:format[], any:...) +{ + if (sm_show_activity == INVALID_HANDLE) + sm_show_activity = FindConVar("sm_show_activity"); + + new String:tag[] = "[SM] "; + + decl String:szBuffer[MAX_MESSAGE_LENGTH]; + //decl String:szCMessage[MAX_MESSAGE_LENGTH]; + new value = GetConVarInt(sm_show_activity); + new ReplySource:replyto = GetCmdReplySource(); + + new String:name[MAX_NAME_LENGTH] = "Console"; + new String:sign[MAX_NAME_LENGTH] = "ADMIN"; + new bool:display_in_chat = false; + if (client != 0) + { + if (client < 0 || client > MaxClients || !IsClientConnected(client)) + ThrowError("Client index %d is invalid", client); + + GetClientName(client, name, sizeof(name)); + new AdminId:id = GetUserAdmin(client); + if (id == INVALID_ADMIN_ID + || !GetAdminFlag(id, Admin_Generic, Access_Effective)) + { + sign = "PLAYER"; + } + + /* Display the message to the client? */ + if (replyto == SM_REPLY_TO_CONSOLE) + { + SetGlobalTransTarget(client); + VFormat(szBuffer, sizeof(szBuffer), format, 3); + + CRemoveTags(szBuffer, sizeof(szBuffer)); + PrintToConsole(client, "%s%s\n", tag, szBuffer); + display_in_chat = true; + } + } + else + { + SetGlobalTransTarget(LANG_SERVER); + VFormat(szBuffer, sizeof(szBuffer), format, 3); + + CRemoveTags(szBuffer, sizeof(szBuffer)); + PrintToServer("%s%s\n", tag, szBuffer); + } + + if (!value) + { + return 1; + } + + for (new i = 1; i <= MaxClients; i++) + { + if (!IsClientInGame(i) + || IsFakeClient(i) + || (display_in_chat && i == client)) + { + continue; + } + new AdminId:id = GetUserAdmin(i); + SetGlobalTransTarget(i); + if (id == INVALID_ADMIN_ID + || !GetAdminFlag(id, Admin_Generic, Access_Effective)) + { + /* Treat this as a normal user. */ + if ((value & 1) | (value & 2)) + { + new String:newsign[MAX_NAME_LENGTH]; + newsign = sign; + if ((value & 2) || (i == client)) + { + newsign = name; + } + VFormat(szBuffer, sizeof(szBuffer), format, 3); + + CPrintToChatEx(i, client, "%s%s: %s", tag, newsign, szBuffer); + } + } + else + { + /* Treat this as an admin user */ + new bool:is_root = GetAdminFlag(id, Admin_Root, Access_Effective); + if ((value & 4) + || (value & 8) + || ((value & 16) && is_root)) + { + new String:newsign[MAX_NAME_LENGTH] + newsign = sign; + if ((value & 8) || ((value & 16) && is_root) || (i == client)) + { + newsign = name; + } + VFormat(szBuffer, sizeof(szBuffer), format, 3); + + CPrintToChatEx(i, client, "%s%s: %s", tag, newsign, szBuffer); + } + } + } + + return 1; +} + +/** + * Same as CShowActivity(), except the tag parameter is used instead of "[SM] " (note that you must supply any spacing). + * Supports color tags. + * + * @param client Client index doing the action, or 0 for server. + * @param tags Tag to display with. + * @param format Formatting rules. + * @param ... Variable number of format parameters. + * @noreturn + * @error + */ +stock CShowActivityEx(client, const String:tag[], const String:format[], any:...) +{ + if (sm_show_activity == INVALID_HANDLE) + sm_show_activity = FindConVar("sm_show_activity"); + + decl String:szBuffer[MAX_MESSAGE_LENGTH]; + //decl String:szCMessage[MAX_MESSAGE_LENGTH]; + new value = GetConVarInt(sm_show_activity); + new ReplySource:replyto = GetCmdReplySource(); + + new String:name[MAX_NAME_LENGTH] = "Console"; + new String:sign[MAX_NAME_LENGTH] = "ADMIN"; + new bool:display_in_chat = false; + if (client != 0) + { + if (client < 0 || client > MaxClients || !IsClientConnected(client)) + ThrowError("Client index %d is invalid", client); + + GetClientName(client, name, sizeof(name)); + new AdminId:id = GetUserAdmin(client); + if (id == INVALID_ADMIN_ID + || !GetAdminFlag(id, Admin_Generic, Access_Effective)) + { + sign = "PLAYER"; + } + + /* Display the message to the client? */ + if (replyto == SM_REPLY_TO_CONSOLE) + { + SetGlobalTransTarget(client); + VFormat(szBuffer, sizeof(szBuffer), format, 4); + + CRemoveTags(szBuffer, sizeof(szBuffer)); + PrintToConsole(client, "%s%s\n", tag, szBuffer); + display_in_chat = true; + } + } + else + { + SetGlobalTransTarget(LANG_SERVER); + VFormat(szBuffer, sizeof(szBuffer), format, 4); + + CRemoveTags(szBuffer, sizeof(szBuffer)); + PrintToServer("%s%s\n", tag, szBuffer); + } + + if (!value) + { + return 1; + } + + for (new i = 1; i <= MaxClients; i++) + { + if (!IsClientInGame(i) + || IsFakeClient(i) + || (display_in_chat && i == client)) + { + continue; + } + new AdminId:id = GetUserAdmin(i); + SetGlobalTransTarget(i); + if (id == INVALID_ADMIN_ID + || !GetAdminFlag(id, Admin_Generic, Access_Effective)) + { + /* Treat this as a normal user. */ + if ((value & 1) | (value & 2)) + { + new String:newsign[MAX_NAME_LENGTH]; + newsign = sign; + if ((value & 2) || (i == client)) + { + newsign = name; + } + VFormat(szBuffer, sizeof(szBuffer), format, 4); + + CPrintToChatEx(i, client, "%s%s: %s", tag, newsign, szBuffer); + } + } + else + { + /* Treat this as an admin user */ + new bool:is_root = GetAdminFlag(id, Admin_Root, Access_Effective); + if ((value & 4) + || (value & 8) + || ((value & 16) && is_root)) + { + new String:newsign[MAX_NAME_LENGTH]; + newsign = sign; + if ((value & 8) || ((value & 16) && is_root) || (i == client)) + { + newsign = name; + } + VFormat(szBuffer, sizeof(szBuffer), format, 4); + + CPrintToChatEx(i, client, "%s%s: %s", tag, newsign, szBuffer); + } + } + } + + return 1; +} + +/** + * Displays usage of an admin command to users depending on the setting of the sm_show_activity cvar. + * All users receive a message in their chat text, except for the originating client, + * who receives the message based on the current ReplySource. + * Supports color tags. + * + * @param client Client index doing the action, or 0 for server. + * @param tags Tag to prepend to the message. + * @param format Formatting rules. + * @param ... Variable number of format parameters. + * @noreturn + * @error + */ +stock CShowActivity2(client, const String:tag[], const String:format[], any:...) +{ + if (sm_show_activity == INVALID_HANDLE) + sm_show_activity = FindConVar("sm_show_activity"); + + decl String:szBuffer[MAX_MESSAGE_LENGTH]; + //decl String:szCMessage[MAX_MESSAGE_LENGTH]; + new value = GetConVarInt(sm_show_activity); + GetCmdReplySource(); + + new String:name[MAX_NAME_LENGTH] = "Console"; + new String:sign[MAX_NAME_LENGTH] = "ADMIN"; + if (client != 0) + { + if (client < 0 || client > MaxClients || !IsClientConnected(client)) + ThrowError("Client index %d is invalid", client); + + GetClientName(client, name, sizeof(name)); + new AdminId:id = GetUserAdmin(client); + if (id == INVALID_ADMIN_ID + || !GetAdminFlag(id, Admin_Generic, Access_Effective)) + { + sign = "PLAYER"; + } + + SetGlobalTransTarget(client); + VFormat(szBuffer, sizeof(szBuffer), format, 4); + + /* We don't display directly to the console because the chat text + * simply gets added to the console, so we don't want it to print + * twice. + */ + CPrintToChatEx(client, client, "%s%s", tag, szBuffer); + } + else + { + SetGlobalTransTarget(LANG_SERVER); + VFormat(szBuffer, sizeof(szBuffer), format, 4); + + CRemoveTags(szBuffer, sizeof(szBuffer)); + PrintToServer("%s%s\n", tag, szBuffer); + } + + if (!value) + { + return 1; + } + + for (new i = 1; i <= MaxClients; i++) + { + if (!IsClientInGame(i) + || IsFakeClient(i) + || i == client) + { + continue; + } + new AdminId:id = GetUserAdmin(i); + SetGlobalTransTarget(i); + if (id == INVALID_ADMIN_ID + || !GetAdminFlag(id, Admin_Generic, Access_Effective)) + { + /* Treat this as a normal user. */ + if ((value & 1) | (value & 2)) + { + new String:newsign[MAX_NAME_LENGTH]; + newsign = sign; + if ((value & 2)) + { + newsign = name; + } + VFormat(szBuffer, sizeof(szBuffer), format, 4); + + CPrintToChatEx(i, client, "%s%s: %s", tag, newsign, szBuffer); + } + } + else + { + /* Treat this as an admin user */ + new bool:is_root = GetAdminFlag(id, Admin_Root, Access_Effective); + if ((value & 4) + || (value & 8) + || ((value & 16) && is_root)) + { + new String:newsign[MAX_NAME_LENGTH]; + newsign = sign; + if ((value & 8) || ((value & 16) && is_root)) + { + newsign = name; + } + VFormat(szBuffer, sizeof(szBuffer), format, 4); + + CPrintToChatEx(i, client, "%s%s: %s", tag, newsign, szBuffer); + } + } + } + + return 1; +}
\ No newline at end of file diff --git a/sourcemod/scripting/include/distbugfix.inc b/sourcemod/scripting/include/distbugfix.inc new file mode 100644 index 0000000..6a7ed18 --- /dev/null +++ b/sourcemod/scripting/include/distbugfix.inc @@ -0,0 +1,261 @@ + +#if defined _distbug_included + #endinput +#endif +#define _distbug_included + +#define DISTBUG_CONFIG_NAME "distbugfix" + +#define CHAT_PREFIX "{d}[{l}GC{d}]" +#define CONSOLE_PREFIX "[GC]" +#define CHAT_SPACER " {d}|{g} " +#define DISTBUG_VERSION "2.0.0" + +#define MAX_STRAFES 32 +#define MAX_EDGE 32.0 +#define MAX_JUMP_FRAMES 150 // for frame based arrays +#define MAX_BHOP_FRAMES 8 + +#define MAX_COOKIE_SIZE 32 + +enum +{ + SETTINGS_DISTBUG_ENABLED = (1 << 0), + SETTINGS_SHOW_VEER_BEAM = (1 << 1), + SETTINGS_SHOW_JUMP_BEAM = (1 << 2), + SETTINGS_SHOW_HUD_GRAPH = (1 << 3), + SETTINGS_DISABLE_STRAFE_STATS = (1 << 4), + SETTINGS_DISABLE_STRAFE_GRAPH = (1 << 5), + SETTINGS_ADV_CHAT_STATS = (1 << 6), +} + +enum JumpType +{ + // unprintable jumptypes. only for tracking + JUMPTYPE_NONE, + + JUMPTYPE_LJ, // longjump + JUMPTYPE_WJ, // weirdjump + JUMPTYPE_LAJ, // ladderjump + JUMPTYPE_BH, // bunnyhop + JUMPTYPE_CBH, // crouched bunnyhop +}; + +enum JumpDir +{ + JUMPDIR_FORWARDS, + JUMPDIR_BACKWARDS, + JUMPDIR_LEFT, + JUMPDIR_RIGHT, +}; + +enum StrafeType +{ + STRAFETYPE_OVERLAP, // IN_MOVELEFT and IN_MOVERIGHT are overlapping and sidespeed is 0 + STRAFETYPE_NONE, // IN_MOVELEFT and IN_MOVERIGHT are both not pressed and sidespeed is 0 + + STRAFETYPE_LEFT, // only IN_MOVELEFT is down and sidespeed isn't 0. + STRAFETYPE_OVERLAP_LEFT, // IN_MOVELEFT and IN_MOVERIGHT are overlapping, but sidespeed is smaller than 0 (not 0) + STRAFETYPE_NONE_LEFT, // IN_MOVELEFT and IN_MOVERIGHT are both not pressed and sidespeed is smaller than 0 (not 0) + + STRAFETYPE_RIGHT, // only IN_MOVERIGHT is down and sidespeed isn't 0. + STRAFETYPE_OVERLAP_RIGHT, // IN_MOVELEFT and IN_MOVERIGHT are overlapping, but sidespeed is bigger than 0 (not 0) + STRAFETYPE_NONE_RIGHT, // IN_MOVELEFT and IN_MOVERIGHT are both not pressed and sidespeed is bigger than 0 (not 0) +}; + +enum JumpBeamColour +{ + JUMPBEAM_NEUTRAL, // speed stays the same + JUMPBEAM_LOSS, // speed loss + JUMPBEAM_GAIN, // speed gain + JUMPBEAM_DUCK, // duck key down +}; + +enum struct PlayerData +{ + int tickCount; + int buttons; + int lastButtons; + int flags; + int lastFlags; + int framesOnGround; + int framesInAir; + MoveType movetype; + MoveType lastMovetype; + float stamina; + float lastStamina; + float forwardmove; + float lastForwardmove; + float sidemove; + float lastSidemove; + float gravity; + float angles[3]; + float lastAngles[3]; + float position[3]; + float lastPosition[3]; + float velocity[3]; + float lastVelocity[3]; + float lastGroundPos[3]; // last position where the player left the ground. + float ladderNormal[3]; + bool lastGroundPosWalkedOff; + bool landedDucked; + + int prespeedFog; + float prespeedStamina; + + float jumpGroundZ; + float jumpPos[3]; + float jumpAngles[3]; + float landGroundZ; + float landPos[3]; + + int fwdReleaseFrame; + int jumpFrame; + bool trackingJump; + bool failedJump; + bool jumpGotFailstats; + + // jump data + JumpType jumpType; + JumpType lastJumpType; + JumpDir jumpDir; + float jumpDistance; + float jumpPrespeed; + float jumpMaxspeed; + float jumpVeer; + float jumpAirpath; + float jumpSync; + float jumpEdge; + float jumpLandEdge; + float jumpBlockDist; + float jumpHeight; + float jumpJumpoffAngle; + int jumpAirtime; + int jumpFwdRelease; + int jumpOverlap; + int jumpDeadair; + + // strafes! + int strafeCount; + float strafeSync[MAX_STRAFES]; + float strafeGain[MAX_STRAFES]; + float strafeLoss[MAX_STRAFES]; + float strafeMax[MAX_STRAFES]; + int strafeAirtime[MAX_STRAFES]; + int strafeOverlap[MAX_STRAFES]; + int strafeDeadair[MAX_STRAFES]; + float strafeAvgGain[MAX_STRAFES]; + + float strafeAvgEfficiency[MAX_STRAFES]; + int strafeAvgEfficiencyCount[MAX_STRAFES]; // how many samples are in strafeAvgEfficiency + float strafeMaxEfficiency[MAX_STRAFES]; + + StrafeType strafeGraph[MAX_JUMP_FRAMES]; + float mouseGraph[MAX_JUMP_FRAMES]; + float jumpBeamX[MAX_JUMP_FRAMES]; + float jumpBeamY[MAX_JUMP_FRAMES]; + JumpBeamColour jumpBeamColour[MAX_JUMP_FRAMES]; +} + +/** + * Check if player is overlapping their MOVERIGHT and MOVELEFT buttons. + * + * @param x Buttons; + * @return True if overlapping, false otherwise. + */ +stock bool IsOverlapping(int buttons, JumpDir jumpDir) +{ + if (jumpDir == JUMPDIR_FORWARDS || jumpDir == JUMPDIR_BACKWARDS) + { + return (buttons & IN_MOVERIGHT) && (buttons & IN_MOVELEFT); + } + // else if (jumpDir == JUMPDIR_LEFT || jumpDir == JUMPDIR_RIGHT) + return (buttons & IN_FORWARD) && (buttons & IN_BACK); +} + +/** + * Checks if the player is not holding down their MOVERIGHT and MOVELEFT buttons. + * + * @param x Buttons. + * @return True if they're not holding either, false otherwise. + */ +stock bool IsDeadAirtime(int buttons, JumpDir jumpDir) +{ + if (jumpDir == JUMPDIR_FORWARDS || jumpDir == JUMPDIR_BACKWARDS) + { + return (!(buttons & IN_MOVERIGHT) && !(buttons & IN_MOVELEFT)); + } + // else if (jumpDir == JUMPDIR_LEFT || jumpDir == JUMPDIR_RIGHT) + return (!(buttons & IN_FORWARD) && !(buttons & IN_BACK)); +} + +stock void ToggleCVar(ConVar cvar) +{ + cvar.BoolValue = !cvar.BoolValue; +} + +stock void GetRealLandingOrigin(float landGroundZ, const float origin[3], const float velocity[3], float result[3]) +{ + if ((origin[2] - landGroundZ) == 0.0) + { + result = origin; + return; + } + + // this is like this because it works + float frametime = GetTickInterval(); + float verticalDistance = origin[2] - (origin[2] + velocity[2] * frametime); + float fraction = (origin[2] - landGroundZ) / verticalDistance; + + float addDistance[3]; + addDistance = velocity; + ScaleVector(addDistance, frametime * fraction); + + AddVectors(origin, addDistance, result); +} + +stock int FloatSign(float value) +{ + if (value > 0.0) + { + return 1; + } + else if (value < 0.0) + { + return -1; + } + return 0; +} + +stock int FloatSign2(float value) +{ + if (value >= 0.0) + { + return 1; + } + // else if (value < 0.0) + return -1; +} + +stock void ShowPanel(int client, int duration, const char[] message) +{ + Event show_survival_respawn_status = CreateEvent("show_survival_respawn_status"); + if (show_survival_respawn_status == INVALID_HANDLE) + { + return; + } + + show_survival_respawn_status.SetString("loc_token", message); + show_survival_respawn_status.SetInt("duration", duration); + show_survival_respawn_status.SetInt("userid", -1); + + if (client == -1) + { + show_survival_respawn_status.Fire(); + } + else + { + show_survival_respawn_status.FireToClient(client); + show_survival_respawn_status.Cancel(); + } +} diff --git a/sourcemod/scripting/include/gamechaos.inc b/sourcemod/scripting/include/gamechaos.inc new file mode 100644 index 0000000..eeaf040 --- /dev/null +++ b/sourcemod/scripting/include/gamechaos.inc @@ -0,0 +1,20 @@ + +// GameChaos's includes for various specific stuff + +#if defined _gamechaos_stocks_included + #endinput +#endif +#define _gamechaos_stocks_included + +#define GC_INCLUDES_VERSION 0x01_00_00 +#define GC_INCLUDES_VERSION_STRING "1.0.0" + +#include <gamechaos/arrays> +#include <gamechaos/client> +#include <gamechaos/debug> +#include <gamechaos/maths> +#include <gamechaos/misc> +#include <gamechaos/strings> +#include <gamechaos/tempents> +#include <gamechaos/tracing> +#include <gamechaos/vectors>
\ No newline at end of file diff --git a/sourcemod/scripting/include/gamechaos/arrays.inc b/sourcemod/scripting/include/gamechaos/arrays.inc new file mode 100644 index 0000000..eba62bb --- /dev/null +++ b/sourcemod/scripting/include/gamechaos/arrays.inc @@ -0,0 +1,52 @@ + +#if defined _gamechaos_stocks_arrays_included + #endinput +#endif +#define _gamechaos_stocks_arrays_included + +#define GC_ARRAYS_VERSION 0x01_00_00 +#define GC_ARRAYS_VERSION_STRING "1.0.0" + +/** + * Copies an array into an arraylist. + * + * @param array Arraylist Handle. + * @param index Index in the arraylist. + * @param values Array to copy. + * @param size Size of the array to copy. + * @param offset Arraylist offset to set. + * @return Number of cells copied. + * @error Invalid Handle or invalid index. + */ +stock int GCSetArrayArrayIndexOffset(ArrayList array, int index, const any[] values, int size, int offset) +{ + int cells; + for (int i; i < size; i++) + { + array.Set(index, values[i], offset + i); + cells++; + } + return cells; +} + +/** + * Copies an arraylist's specified cells to an array. + * + * @param array Arraylist Handle. + * @param index Index in the arraylist. + * @param result Array to copy to. + * @param size Size of the array to copy to. + * @param offset Arraylist offset. + * @return Number of cells copied. + * @error Invalid Handle or invalid index. + */ +stock int GCCopyArrayArrayIndex(const ArrayList array, int index, any[] result, int size, int offset) +{ + int cells; + for (int i = offset; i < (size + offset); i++) + { + result[i] = array.Get(index, i); + cells++; + } + return cells; +}
\ No newline at end of file diff --git a/sourcemod/scripting/include/gamechaos/client.inc b/sourcemod/scripting/include/gamechaos/client.inc new file mode 100644 index 0000000..cb2114a --- /dev/null +++ b/sourcemod/scripting/include/gamechaos/client.inc @@ -0,0 +1,300 @@ + +#if defined _gamechaos_stocks_client_included + #endinput +#endif +#define _gamechaos_stocks_client_included + +#define GC_CLIENT_VERSION 0x01_00_00 +#define GC_CLIENT_VERSION_STRING "1.0.0" + +/** + * Credit: Don't remember. + * Removes a player's weapon from the specified slot. + * + * @param client Client index. + * @param slot Weapon slot. + * @return True if removed, false otherwise. + */ +stock bool GCRemoveWeaponBySlot(int client, int slot) +{ + int entity = GetPlayerWeaponSlot(client, slot); + if (IsValidEdict(entity)) + { + RemovePlayerItem(client, entity); + AcceptEntityInput(entity, "kill"); + return true; + } + return false; +} + +/** + * Checks if a client is valid and not the server and optionally, whether he's alive. + * + * @param client Client index. + * @param alive Whether to check alive. + * @return True if valid, false otherwise. + */ +stock bool GCIsValidClient(int client, bool alive = false) +{ + return (client >= 1 && client <= MaxClients && IsClientConnected(client) && IsClientInGame(client) && !IsClientSourceTV(client) && (!alive || IsPlayerAlive(client))); +} + + + +/** + * Gets the value of m_flForwardMove. + * + * @param client Client index. + * @return Value of m_flForwardMove. + */ +stock float GCGetClientForwardMove(int client) +{ + return GetEntPropFloat(client, Prop_Data, "m_flForwardMove"); +} + +/** + * Gets the value of m_flSideMove. + * + * @param client Client index. + * @return Value of m_flSideMove. + */ +stock float GCGetClientSideMove(int client) +{ + return GetEntPropFloat(client, Prop_Data, "m_flSideMove"); +} + +/** + * Gets the client's abs origin. + * + * @param client Client index. + * @return result Player's origin. + */ +stock float[] GCGetClientAbsOriginRet(int client) +{ + float result[3] + GetClientAbsOrigin(client, result); + return result; +} + +/** + * Copies the client's velocity to a vector. + * + * @param client Client index. + * @param result Resultant vector. + */ +stock void GCGetClientVelocity(int client, float result[3]) +{ + GetEntPropVector(client, Prop_Data, "m_vecVelocity", result); +} + +/** + * Gets the client's velocity (m_vecVelocity). + * + * @param client Client index. + * @return result m_vecVelocity. + */ +stock float[] GCGetClientVelocityRet(int client) +{ + float result[3] + GetEntPropVector(client, Prop_Data, "m_vecVelocity", result); + return result +} + +/** + * Copies the client's basevelocity to a vector. + * + * @param client Client index. + * @param result Resultant vector. + */ +stock void GCGetClientBaseVelocity(int client, float result[3]) +{ + GetEntPropVector(client, Prop_Data, "m_vecBaseVelocity", result); +} + +/** + * Gets the client's basevelocity (m_vecBaseVelocity). + * + * @param client Client index. + * @return result m_vecBaseVelocity. + */ +stock float[] GCGetClientBaseVelocityRet(int client) +{ + float result[3]; + GetEntPropVector(client, Prop_Data, "m_vecBaseVelocity", result); + return result; +} + + +/** + * Gets the client's "m_flDuckSpeed" value. + * + * @param client Client index. + * @return "m_flDuckSpeed". + */ +stock float GCGetClientDuckSpeed(int client) +{ + return GetEntPropFloat(client, Prop_Send, "m_flDuckSpeed"); +} + +/** + * Gets the client's "m_flDuckAmount" value. + * + * @param client Client index. + * @return "m_flDuckAmount". + */ +stock float GCGetClientDuckAmount(int client) +{ + return GetEntPropFloat(client, Prop_Send, "m_flDuckAmount"); +} + +/** + * Gets the client's "m_bDucking" value. + * + * @param client Client index. + * @return "m_bDucking". + */ +stock int GCGetClientDucking(int client) +{ + return GetEntProp(client, Prop_Data, "m_bDucking"); +} + +/** + * Gets the client's "m_flMaxspeed" value. + * + * @param client Client index. + * @return "m_flMaxspeed". + */ +stock float GCGetClientMaxspeed(int client) +{ + return GetEntPropFloat(client, Prop_Send, "m_flMaxspeed"); +} + +/** + * Gets the client's "m_afButtonPressed" value. + * + * @param client Client index. + * @return "m_afButtonPressed". + */ +stock int GCGetClientButtonPressed(int client) +{ + return GetEntProp(client, Prop_Data, "m_afButtonPressed"); +} + +/** + * Gets the client's "m_afButtonReleased" value. + * + * @param client Client index. + * @return "m_afButtonReleased". + */ +stock int GCGetClientButtonReleased(int client) +{ + return GetEntProp(client, Prop_Data, "m_afButtonReleased"); +} + +/** + * Gets the client's "m_afButtonLast" value. + * + * @param client Client index. + * @return "m_afButtonLast". + */ +stock int GCGetClientButtonLast(int client) +{ + return GetEntProp(client, Prop_Data, "m_afButtonLast"); +} + +/** + * Gets the client's "m_afButtonForced" value. + * + * @param client Client index. + * @return "m_afButtonForced". + */ +stock int GCGetClientForcedButtons(int client) +{ + return GetEntProp(client, Prop_Data, "m_afButtonForced"); +} + +/** + * Gets the client's "m_flStamina" value. + * + * @param client Client index. + * @return "m_flStamina". + */ +stock float GCGetClientStamina(int client) +{ + return GetEntPropFloat(client, Prop_Send, "m_flStamina"); +} + + + +/** + * Sets the client's origin. + * + * @param client Client index. + * @param origin New origin. + */ +stock void GCSetClientAbsOrigin(int client, const float origin[3]) +{ + SetEntPropVector(client, Prop_Data, "m_vecAbsOrigin", origin); +} + +/** + * Sets the client's velocity. + * + * @param client Client index. + * @param velocity New velocity. + */ +stock void GCSetClientVelocity(int client, const float velocity[3]) +{ + SetEntPropVector(client, Prop_Data, "m_vecVelocity", velocity); +} + +/** + * Sets the client's "m_vecAbsVelocity". + * + * @param client Client index. + * @param velocity New "m_vecAbsVelocity". + */ +stock void GCSetClientAbsVelocity(int client, const float velocity[3]) +{ + SetEntPropVector(client, Prop_Data, "m_vecAbsVelocity", velocity); +} + +/** + * Sets the client's eye angles. + * Ang has to be a 2 member array or more + * + * @param client Client index. + * @param ang New eyeangles. + */ +stock void GCSetClientEyeAngles(int client, const float[] ang) +{ + SetEntPropFloat(client, Prop_Send, "m_angEyeAngles[0]", ang[0]); + SetEntPropFloat(client, Prop_Send, "m_angEyeAngles[1]", ang[1]); +} + + +/** + * Sets the client's "m_flDuckSpeed". + * + * @param client Client index. + * @param value New "m_flDuckSpeed". + */ +stock void GCSetClientDuckSpeed(int client, float value) +{ + SetEntPropFloat(client, Prop_Send, "m_flDuckSpeed", value); +} + +stock void GCSetClientDuckAmount(int client, float value) +{ + SetEntPropFloat(client, Prop_Send, "m_flDuckAmount", value); +} + +stock void GCSetClientForcedButtons(int client, int buttons) +{ + SetEntProp(client, Prop_Data, "m_afButtonForced", buttons); +} + +stock void GCSetClientStamina(int client, float stamina) +{ + SetEntPropFloat(client, Prop_Send, "m_flStamina", stamina) +}
\ No newline at end of file diff --git a/sourcemod/scripting/include/gamechaos/debug.inc b/sourcemod/scripting/include/gamechaos/debug.inc new file mode 100644 index 0000000..4e5b7e7 --- /dev/null +++ b/sourcemod/scripting/include/gamechaos/debug.inc @@ -0,0 +1,19 @@ + +// gamechaos's debug stocks +// useful stocks for debugging + +#if defined _gamechaos_debug_included + #endinput +#endif +#define _gamechaos_debug_included + +#define GC_DEBUG_VERSION 0x1_00_00 +#define GC_DEBUG_VERSION_STRING "1.0.0" + +#if defined GC_DEBUG + #define GC_ASSERT(%1) if (!(%1))SetFailState("Assertion failed: \""...#%1..."\"") + #define GC_DEBUGPRINT(%1) PrintToChatAll(%1) +#else + #define GC_ASSERT(%1)%2; + #define GC_DEBUGPRINT(%1)%2; +#endif diff --git a/sourcemod/scripting/include/gamechaos/isvalidclient.inc b/sourcemod/scripting/include/gamechaos/isvalidclient.inc new file mode 100644 index 0000000..bf80246 --- /dev/null +++ b/sourcemod/scripting/include/gamechaos/isvalidclient.inc @@ -0,0 +1,16 @@ + +#if defined _gamechaos_isvalidclient_client_included + #endinput +#endif +#define _gamechaos_isvalidclient_client_included + +/** + * Checks if a client is valid. + * + * @param client Client index. + * @return True if valid, false otherwise. + */ +stock bool IsValidClient(int client) +{ + return (client >= 0 && client <= MaxClients && IsValidEntity(client) && IsClientConnected(client) && IsClientInGame(client)); +}
\ No newline at end of file diff --git a/sourcemod/scripting/include/gamechaos/kreedzclimbing.inc b/sourcemod/scripting/include/gamechaos/kreedzclimbing.inc new file mode 100644 index 0000000..0cbb828 --- /dev/null +++ b/sourcemod/scripting/include/gamechaos/kreedzclimbing.inc @@ -0,0 +1,226 @@ +// +// Useful things for making plugins for Kreedz Climbing +// + +#if defined _gamechaos_kreedzclimbing_included + #endinput +#endif +#define _gamechaos_kreedzclimbing_included + +#define GC_KREEDZCLIMBING_VERSION 0x01_00_00 +#define GC_KREEDZCLIMBING_VERSION_STRING "1.0.0" + + +#define MAX_COURSE_SIZE 128 // Reasonable maximum characters a course name can have +#define COURSE_CVAR_COUNT 20 // the amount of Course<int> cvars + +// Kreedz Climbing Client Commands: +// These may be executed by a player via the console, with / in chat, or via binds. + +// specmode - Cycles spectator mode (F3 by default). +// kz_pause - Pauses the timer. +// flare - Fires a flare. +// gototimer | start - Returns to the last pressed start timer. +// spectate | spec - Enters spectator mode. +// forcespectator - Becomes a spectator no matter what (force respawns a dead player as well). +// stoptimer - Instantly stops the player's timer. +// climb | ct - Respawns at the map spawnpoint. +// InvalidateTimer - Invalidates the player's timer. An invalid timer can't earn rewards for completing the course. InvalidateTimer 1 displays the message, without the 1 it does not. + +// Kreedz Climbing Constants + +// Timer state (player->m_Local->Timer_Active) +#define TIMER_STATE_INVISIBLE 0 +#define TIMER_STATE_ACTIVE 1 +#define TIMER_STATE_INACTIVE 2 +#define TIMER_STATE_PAUSED 3 + +// Timer flags (player_manager->m_iTimerFlags[32]) +// These are replicated flags for player's timer (most timer data is local to it's own player). +// Note that these flags are mirrors of data local to the player - they are set to the player's +// state every frame and cannot be changed. + +#define TIMER_FLAG_INVALID (1 << 0) +#define TIMER_FLAG_ACTIVE (1 << 1) // We need to broadcast this because Timer_State is local only. +#define TIMER_FLAG_PAUSED (1 << 2) // A paused timer cannot be active and vice versa. + +// Environmental Attributes (player->m_iEnvironmentalAttributes) +#define PLAYER_ENV_ATTRIBUTES_BHOP (1 << 0) +#define PLAYER_ENV_ATTRIBUTES_SURF (1 << 1) +#define PLAYER_ENV_ATTRIBUTES_AUTOBHOP (1 << 2) +#define PLAYER_ENV_ATTRIBUTES_CSGOMOVEMENT (1 << 3) +#define PLAYER_ENV_ATTRIBUTES_CSGODUCKHULL (1 << 4) + +// Movement restriction flags (player->m_iMovementRestrictions) (new version of Environmental Restrictions below) +#define PLAYER_MOVEMENT_RESTRICTION_NOJUMP (1 << 0) +#define PLAYER_MOVEMENT_RESTRICTION_NOBHOP (1 << 1) +#define PLAYER_MOVEMENT_RESTRICTION_NODOUBLEDUCK (1 << 2) + +// OBSOLETE: ONLY IN OLD MAPS: Environmental Restrictions (player->m_iEnvironmentalRestrictions), note not flags, complete integer. +#define PLAYER_ENV_RESTRICTION_NOJUMP 1 +#define PLAYER_ENV_RESTRICTION_NOBHOP 2 +#define PLAYER_ENV_RESTRICTION_BOTH 3 + +// Cooperative status (player->m_Local.m_multiplayercoursedata.Player1Status, Player2Status etc) +#define COOPERATIVE_STATUS_NONE 0 +#define COOPERATIVE_STATUS_WAITING 1 +#define COOPERATIVE_STATUS_READY 2 +#define COOPERATIVE_STATUS_TIMER_ACTIVE 3 +#define COOPERATIVE_STATUS_TIMER_COMPLETE 4 +#define COOPERATIVE_STATUS_PLAYER_DISCONNECTED 5 // Player disconnected from server, waiting for them to reconnect. +#define COOPERATIVE_STATUS_TIMER_PAUSED 6 + +// Kreedz Climbing Button Constants +#define IN_CHECKPOINT (1 << 25) +#define IN_TELEPORT (1 << 26) +#define IN_SPECTATE (1 << 27) +//#define IN_AVAILABLE (1 << 28) // Unused +#define IN_HOOK (1 << 29) + +// converts the course id from the obsolete "player_starttimer" event into the course name +stock void GCCourseidToString(int courseid, char[] course, int size) +{ + char szCourseid[16]; + if (courseid < 1 || courseid > COURSE_CVAR_COUNT) + { + return; + } + FormatEx(szCourseid, sizeof(szCourseid), "Course%i", courseid); + FindConVar(szCourseid).GetString(course, size); +} + +stock void GCGetCurrentMapCourses(ArrayList &array) +{ + if (array == null) + { + // 1 for endurance bool + array = new ArrayList(ByteCountToCells(MAX_COURSE_SIZE) + 1); + } + else + { + array.Clear(); + } + + char course[MAX_COURSE_SIZE]; + + int ent; + while((ent = FindEntityByClassname(ent, "func_stoptimer")) != -1) + { + int courseid = GetEntProp(ent, Prop_Data, "CourseID"); + GCCourseidToString(courseid, course, sizeof(course)); + array.PushString(course); + + bool endurance = GCIsCourseEndurance(course, ent); + array.Set(array.Length - 1, endurance, ByteCountToCells(MAX_COURSE_SIZE)); + } + + int courseStringtableCount; + int courseNamesIdx = FindStringTable("CourseNames"); + courseStringtableCount = GetStringTableNumStrings(courseNamesIdx); + + for (int i; i < courseStringtableCount; i++) + { + ReadStringTable(courseNamesIdx, i, course, sizeof(course)); + array.PushString(course); + + bool endurance = GCIsCourseEndurance(course, ent); + array.Set(array.Length - 1, endurance, ByteCountToCells(MAX_COURSE_SIZE)); + } +} + +stock int GCGetTimerState(int client) +{ + return GetEntProp(client, Prop_Send, "Timer_Active"); +} + +stock void GCSetTimerState(int client, int timerstate) +{ + SetEntProp(client, Prop_Send, "Timer_Active", timerstate); +} + +stock int GCGetPlayerEnvAttributes(int client) +{ + return GetEntProp(client, Prop_Send, "m_iEnvironmentalAttributes"); +} + +stock void GCSetPlayerEnvAttributes(int client, int attributes) +{ + SetEntProp(client, Prop_Send, "m_iEnvironmentalAttributes", attributes); +} + +stock int GCGetPlayerMovementRestrictions(int client) +{ + return GetEntProp(client, Prop_Send, "m_iMovementRestrictions"); +} + +stock void GCSetPlayerMovementRestrictions(int client, int restrictions) +{ + SetEntProp(client, Prop_Send, "m_iMovementRestrictions", restrictions); +} + +stock void GCSetActiveCourse(int client, int course) +{ + int ent = FindEntityByClassname(0, "player_manager"); + int courseOffset = FindSendPropInfo("CPlayerResource", "m_iActiveCourse"); + SetEntData(ent, courseOffset + (client * 4), course); +} + +stock int GCGetTimerFlags(int client) +{ + int ent = FindEntityByClassname(0, "player_manager"); + int courseOffset = FindSendPropInfo("CPlayerResource", "m_iTimerFlags"); + return GetEntData(ent, courseOffset + (client * 4)); +} + +stock bool GCInvalidateTimer(int client) +{ + if (~GCGetTimerFlags(client) & TIMER_FLAG_INVALID) + { + FakeClientCommand(client, "InvalidateTimer 1"); + return true; + } + + return false; +} + +stock bool GCIsCourseEndurance(char[] course, int ent = -1) +{ + if (ent != -1) + { + if (IsValidEntity(ent)) + { + return !!(GetEntProp(ent, Prop_Data, "m_bEnduranceCourse")); + } + } + + while ((ent = FindEntityByClassname(ent, "point_climbtimer")) != -1) + { + if (IsValidEntity(ent)) + { + char buffer[MAX_COURSE_SIZE]; + GetEntPropString(ent, Prop_Data, "m_strCourseName", buffer, sizeof(buffer)); + + if (StrEqual(buffer, course)) + { + return !!(GetEntProp(ent, Prop_Data, "m_bEnduranceCourse")); + } + } + } + + while ((ent = FindEntityByClassname(ent, "func_stoptimer")) != -1) + { + if (IsValidEntity(ent)) + { + char buffer[MAX_COURSE_SIZE]; + int courseid = GetEntProp(ent, Prop_Data, "CourseID"); + GCCourseidToString(courseid, buffer, sizeof(buffer)); + + if (StrEqual(buffer, course)) + { + return !!(GetEntProp(ent, Prop_Data, "m_bEnduranceCourse")); + } + } + } + + return false; +}
\ No newline at end of file diff --git a/sourcemod/scripting/include/gamechaos/maths.inc b/sourcemod/scripting/include/gamechaos/maths.inc new file mode 100644 index 0000000..f3c94af --- /dev/null +++ b/sourcemod/scripting/include/gamechaos/maths.inc @@ -0,0 +1,362 @@ + +#if defined _gamechaos_stocks_maths_included + #endinput +#endif +#define _gamechaos_stocks_maths_included + +#define GC_MATHS_VERSION 0x02_00_00 +#define GC_MATHS_VERSION_STRING "2.0.0" + +#include <gamechaos/vectors> + +#define GC_PI 3.14159265359 + +#define GC_DEGREES(%1) ((%1) * 180.0 / GC_PI) // convert radians to degrees +#define GC_RADIANS(%1) ((%1) * GC_PI / 180.0) // convert degrees to radians + +#define GC_FLOAT_NAN view_as<float>(0xffffffff) +#define GC_FLOAT_INFINITY view_as<float>(0x7f800000) +#define GC_FLOAT_NEGATIVE_INFINITY view_as<float>(0xff800000) + +#define GC_FLOAT_LARGEST_POSITIVE view_as<float>(0x7f7fffff) +#define GC_FLOAT_SMALLEST_NEGATIVE view_as<float>(0xff7fffff) + +#define GC_FLOAT_SMALLEST_POSITIVE view_as<float>(0x00000001) +#define GC_FLOAT_LARGEST_NEGATIVE view_as<float>(0x80000001) + +#define GC_INT_MAX 0x7fffffff +#define GC_INT_MIN 0xffffffff + + +/** + * Credit: https://stackoverflow.com/questions/5666222/3d-line-plane-intersection + * Determines the point of intersection between a plane defined by a point and a normal vector and a line defined by a point and a direction vector. + * + * @param planePoint A point on the plane. + * @param planeNormal Normal vector of the plane. + * @param linePoint A point on the line. + * @param lineDirection Direction vector of the line. + * @param result Resultant vector. + */ +stock void GCLineIntersection(const float planePoint[3], const float planeNormal[3], const float linePoint[3], const float lineDirection[3], float result[3]) +{ + if (GetVectorDotProduct(planeNormal, lineDirection) == 0) + { + return; + } + + float t = (GetVectorDotProduct(planeNormal, planePoint) + - GetVectorDotProduct(planeNormal, linePoint)) + / GetVectorDotProduct(planeNormal, lineDirection); + + float lineDir[3]; + lineDir = lineDirection; + NormalizeVector(lineDir, lineDir); + + ScaleVector(lineDir, t); + + AddVectors(linePoint, lineDir, result); +} + +/** + * Calculates a point according to angles supplied that is a certain distance away. + * + * @param client Client index. + * @param result Resultant vector. + * @param distance Maximum distance to trace. + * @return True on success, false otherwise. + */ +stock void GCCalcPointAngleDistance(const float start[3], const float angle[3], float distance, float result[3]) +{ + float zsine = Sine(DegToRad(-angle[0])); + float zcos = Cosine(DegToRad(-angle[0])); + + result[0] = Cosine(DegToRad(angle[1])) * zcos; + result[1] = Sine(DegToRad(angle[1])) * zcos; + result[2] = zsine; + + ScaleVector(result, distance); + AddVectors(start, result, result); +} + +/** + * Compares how close 2 floats are. + * + * @param z1 Float 1 + * @param z2 Float 2 + * @param tolerance How close the floats have to be to return true. + * @return True on success, false otherwise. + */ +stock bool GCIsRoughlyEqual(float z1, float z2, float tolerance) +{ + return FloatAbs(z1 - z2) < tolerance; +} + +/** + * Checks if a float is within a range + * + * @param number Float to check. + * @param min Minimum range. + * @param max Maximum range. + * @return True on success, false otherwise. + */ +stock bool GCIsFloatInRange(float number, float min, float max) +{ + return number >= min && number <= max; +} + +/** + * Keeps the yaw angle within the range of -180 to 180. + * + * @param angle Angle. + * @return Normalised angle. + */ +stock float GCNormaliseYaw(float angle) +{ + if (angle <= -180.0) + { + angle += 360.0; + } + + if (angle > 180.0) + { + angle -= 360.0; + } + + return angle; +} + +/** + * Keeps the yaw angle within the range of -180 to 180. + * + * @param angle Angle. + * @return Normalised angle. + */ +stock float GCNormaliseYawRad(float angle) +{ + if (angle <= -FLOAT_PI) + { + angle += FLOAT_PI * 2; + } + + if (angle > FLOAT_PI) + { + angle -= FLOAT_PI * 2; + } + + return angle; +} + +/** + * Linearly interpolates between 2 values. + * + * @param f1 Float 1. + * @param f2 Float 2. + * @param fraction Amount to interpolate. + * @return Interpolated value. + */ +stock float GCInterpLinear(float f1, float f2, float fraction) +{ + float diff = f2 - f1; + + return diff * fraction + f1; +} + +/** + * Calculates the linear fraction from a value that was interpolated and 2 values it was interpolated from. + * + * @param f1 Float 1. + * @param f2 Float 2. + * @param fraction Interpolated value. + * @return Fraction. + */ +stock float GCCalcLerpFraction(float f1, float f2, float lerped) +{ + float diff = f2 - f1; + + float fraction = lerped - f1 / diff; + return fraction; +} + +/** + * Calculate absolute value of an integer. + * + * @param x Integer. + * @return Absolute value of integer. + */ +stock int GCIntAbs(int x) +{ + return x >= 0 ? x : -x; +} + +/** + * Get the maximum of 2 integers. + * + * @param n1 Integer. + * @param n2 Integer. + * @return The biggest of n1 and n2. + */ +stock int GCIntMax(int n1, int n2) +{ + return n1 > n2 ? n1 : n2; +} + +/** + * Get the minimum of 2 integers. + * + * @param n1 Integer. + * @param n2 Integer. + * @return The smallest of n1 and n2. + */ +stock int GCIntMin(int n1, int n2) +{ + return n1 < n2 ? n1 : n2; +} + +/** + * Checks if an integer is within a range + * + * @param number Integer to check. + * @param min Minimum range. + * @param max Maximum range. + * @return True on success, false otherwise. + */ +stock bool GCIsIntInRange(int number, int min, int max) +{ + return number >= min && number <= max; +} + +/** + * Calculates a float percentage from a common fraction. + * + * @param numerator Numerator. + * @param denominator Denominator. + * @return Float percentage. -1.0 on failure. + */ +stock float GCCalcIntPercentage(int numerator, int denominator) +{ + return float(numerator) / float(denominator) * 100.0; +} + +/** + * Integer power. + * Returns the base raised to the power of the exponent. + * Returns 0 if exponent is negative. + * + * @param base Base to be raised. + * @param exponent Value to raise the base. + * @return Value to the power of exponent. + */ +stock int GCIntPow(int base, int exponent) +{ + if (exponent < 0) + { + return 0; + } + + int result = 1; + for (;;) + { + if (exponent & 1) + { + result *= base + } + + exponent >>= 1; + + if (!exponent) + { + break; + } + + base *= base; + } + return result; +} + +/** + * Swaps the values of 2 variables. + * + * @param cell1 Cell 1. + * @param cell2 Cell 2. + */ +stock void GCSwapCells(any &cell1, any &cell2) +{ + any temp = cell1; + cell1 = cell2; + cell2 = temp; +} + +/** + * Clamps an int between min and max. + * + * @param value Float to clamp. + * @param min Minimum range. + * @param max Maximum range. + * @return Clamped value. + */ +stock int GCIntClamp(int value, int min, int max) +{ + if (value < min) + { + return min; + } + if (value > max) + { + return max; + } + return value; +} + +/** + * Returns the biggest of 2 values. + * + * @param num1 Number 1. + * @param num2 Number 2. + * @return Biggest number. + */ +stock float GCFloatMax(float num1, float num2) +{ + if (num1 > num2) + { + return num1; + } + return num2; +} + +/** + * Returns the smallest of 2 values. + * + * @param num1 Number 1. + * @param num2 Number 2. + * @return Smallest number. + */ +stock float GCFloatMin(float num1, float num2) +{ + if (num1 < num2) + { + return num1; + } + return num2; +} + +/** + * Clamps a float between min and max. + * + * @param value Float to clamp. + * @param min Minimum range. + * @param max Maximum range. + * @return Clamped value. + */ +stock float GCFloatClamp(float value, float min, float max) +{ + if (value < min) + { + return min; + } + if (value > max) + { + return max; + } + return value; +} diff --git a/sourcemod/scripting/include/gamechaos/misc.inc b/sourcemod/scripting/include/gamechaos/misc.inc new file mode 100644 index 0000000..f964862 --- /dev/null +++ b/sourcemod/scripting/include/gamechaos/misc.inc @@ -0,0 +1,245 @@ + +#if defined _gamechaos_stocks_misc_included + #endinput +#endif +#define _gamechaos_stocks_misc_included + +#define GC_MISC_VERSION 0x01_00_00 +#define GC_MISC_VERSION_STRING "1.0.0" + +/** + * Check if player is overlapping their MOVERIGHT and MOVELEFT buttons. + * + * @param x Buttons; + * @return True if overlapping, false otherwise. + */ +stock bool GCIsOverlapping(int buttons) +{ + return buttons & IN_MOVERIGHT && buttons & IN_MOVELEFT +} + +/** + * Checks if player gained speed. + * + * @param speed Current player speed. + * @param lastspeed Player speed from previous tick. + * @return True if player gained speed, false otherwise. + */ +stock bool GCIsStrafeSynced(float speed, float lastspeed) +{ + return speed > lastspeed; +} + +/** + * Checks if the player is not holding down their MOVERIGHT and MOVELEFT buttons. + * + * @param x Buttons. + * @return True if they're not holding either, false otherwise. + */ +stock bool GCIsDeadAirtime(int buttons) +{ + return !(buttons & IN_MOVERIGHT) && !(buttons & IN_MOVELEFT); +} + +/** +* Source: https://forums.alliedmods.net/showthread.php?p=2535972 +* Runs a single line of vscript code. +* NOTE: Dont use the "script" console command, it startes a new instance and leaks memory. Use this instead! +* +* @param code The code to run. +* @noreturn +*/ +stock void GCRunScriptCode(const char[] code, any ...) +{ + static int scriptLogic = INVALID_ENT_REFERENCE; + + if (scriptLogic == INVALID_ENT_REFERENCE || !IsValidEntity(scriptLogic)) + { + scriptLogic = EntIndexToEntRef(CreateEntityByName("logic_script")); + if (scriptLogic == INVALID_ENT_REFERENCE || !IsValidEntity(scriptLogic)) + { + SetFailState("Could not create a 'logic_script' entity."); + } + + DispatchSpawn(scriptLogic); + } + + char buffer[512]; + VFormat(buffer, sizeof(buffer), code, 2); + + SetVariantString(buffer); + AcceptEntityInput(scriptLogic, "RunScriptCode"); +} + +stock void GCTE_SendBeamBox(int client, + const float origin[3], + const float mins[3], + const float maxs[3], + int ModelIndex, + int HaloIndex = 0, + float Life = 3.0, + float Width = 2.0, + const int Colour[4] = { 255, 255, 255, 255 }, + float EndWidth = 2.0, + int StartFrame = 0, + int FrameRate = 0, + int FadeLength = 0, + float Amplitude = 0.0, + int Speed = 0) +{ + // credit to some bhop timer by shavit? thanks + int pairs[8][3] = { { 0, 0, 0 }, { 1, 0, 0 }, { 1, 1, 0 }, { 0, 1, 0 }, { 0, 0, 1 }, { 1, 0, 1 }, { 1, 1, 1 }, { 0, 1, 1 } }; + int edges[12][2] = { { 0, 1 }, { 0, 3 }, { 0, 4 }, { 2, 1 }, { 2, 3 }, { 2, 6 }, { 5, 4 }, { 5, 6 }, { 5, 1 }, { 7, 4 }, { 7, 6 }, { 7, 3 } }; + + float corners[8][3]; + float corner[2][3]; + + AddVectors(origin, mins, corner[0]); + AddVectors(origin, maxs, corner[1]); + + for (int i = 0; i < 8; i++) + { + corners[i][0] = corner[pairs[i][0]][0]; + corners[i][1] = corner[pairs[i][1]][1]; + corners[i][2] = corner[pairs[i][2]][2]; + } + + for (int i = 0; i < 12; i++) + { + TE_SetupBeamPoints(corners[edges[i][0]], + corners[edges[i][1]], + ModelIndex, + HaloIndex, + StartFrame, + FrameRate, + Life, + Width, + EndWidth, + FadeLength, + Amplitude, + Colour, + Speed); + TE_SendToClient(client); + } +} + +stock void GCTE_SendBeamCross(int client, + const float origin[3], + int ModelIndex, + int HaloIndex = 0, + float Life = 3.0, + float Width = 2.0, + const int Colour[4] = { 255, 255, 255, 255 }, + float EndWidth = 2.0, + int StartFrame = 0, + int FrameRate = 0, + int FadeLength = 0, + float Amplitude = 0.0, + int Speed = 0) +{ + float points[4][3]; + + for (int i; i < 4; i++) + { + points[i][2] = origin[2]; + } + + // -x; -y + points[0][0] = origin[0] - 8.0; + points[0][1] = origin[1] - 8.0; + + // +x; -y + points[1][0] = origin[0] + 8.0; + points[1][1] = origin[1] - 8.0; + + // +x; +y + points[2][0] = origin[0] + 8.0; + points[2][1] = origin[1] + 8.0; + + // -x; +y + points[3][0] = origin[0] - 8.0; + points[3][1] = origin[1] + 8.0; + + //draw cross + for (int corner; corner < 4; corner++) + { + TE_SetupBeamPoints(origin, points[corner], ModelIndex, HaloIndex, StartFrame, FrameRate, Life, Width, EndWidth, FadeLength, Amplitude, Colour, Speed); + TE_SendToClient(client); + } +} + +stock void GCTE_SendBeamRectangle(int client, + const float origin[3], + const float mins[3], + const float maxs[3], + int modelIndex, + int haloIndex = 0, + float life = 3.0, + float width = 2.0, + const int colour[4] = { 255, 255, 255, 255 }, + float endWidth = 2.0, + int startFrame = 0, + int frameRate = 0, + int fadeLength = 0, + float amplitude = 0.0, + int speed = 0) +{ + float vertices[4][3]; + GCRectangleVerticesFromPoint(vertices, origin, mins, maxs); + + // send the square + for (int i; i < 4; i++) + { + int j = (i == 3) ? (0) : (i + 1); + TE_SetupBeamPoints(vertices[i], + vertices[j], + modelIndex, + haloIndex, + startFrame, + frameRate, + life, + width, + endWidth, + fadeLength, + amplitude, + colour, + speed); + TE_SendToClient(client); + } +} + +/** + * Calculates vertices for a rectangle from a point, mins and maxs. + * + * @param result Vertex array result. + * @param origin Origin to offset mins and maxs by. + * @param mins Minimum size of the rectangle. + * @param maxs Maximum size of the rectangle. + * @return True if overlapping, false otherwise. + */ +stock void GCRectangleVerticesFromPoint(float result[4][3], const float origin[3], const float mins[3], const float maxs[3]) +{ + // Vertices are set clockwise starting from top left (-x; -y) + + // -x; -y + result[0][0] = origin[0] + mins[0]; + result[0][1] = origin[1] + mins[1]; + + // +x; -y + result[1][0] = origin[0] + maxs[0]; + result[1][1] = origin[1] + mins[1]; + + // +x; +y + result[2][0] = origin[0] + maxs[0]; + result[2][1] = origin[1] + maxs[1]; + + // -x; +y + result[3][0] = origin[0] + mins[0]; + result[3][1] = origin[1] + maxs[1]; + + // z is the same for every vertex + for (int vertex; vertex < 4; vertex++) + { + result[vertex][2] = origin[2]; + } +}
\ No newline at end of file diff --git a/sourcemod/scripting/include/gamechaos/strings.inc b/sourcemod/scripting/include/gamechaos/strings.inc new file mode 100644 index 0000000..8ffcb60 --- /dev/null +++ b/sourcemod/scripting/include/gamechaos/strings.inc @@ -0,0 +1,367 @@ + +#if defined _gamechaos_stocks_strings_included + #endinput +#endif +#define _gamechaos_stocks_strings_included + +// these are used for functions that return strings. +// you can change these if they're too small/big. +#define GC_FIXED_BUFFER_SIZE_SMALL 64 +#define GC_FIXED_BUFFER_SIZE_LARGE 4096 + +/** + * Puts the values from a string of integers into an array + * + * @param string + * @param separator + * @param array + * @param arraysize + */ +stock void GCSeparateIntsFromString(const char[] string, const char[] separator, int[] array, int arraysize) +{ + char[][] explodedbuffer = new char[arraysize][32]; + + ExplodeString(string, separator, explodedbuffer, arraysize, 32); + + for (int i; i < arraysize; i++) + { + array[i] = StringToInt(explodedbuffer[i]); + } +} + +/** + * Prints a message to all admins in the chat area. + * + * @param format Formatting rules. + * @param ... Variable number of format parameters. + */ +stock void GCPrintToChatAdmins(const char[] format, any ...) +{ + char buffer[256]; + + for (int i = 1; i <= MaxClients; i++) + { + if (GCIsValidClient(i)) + { + AdminId id = GetUserAdmin(i); + if (!GetAdminFlag(id, Admin_Generic)) + { + continue; + } + SetGlobalTransTarget(i); + VFormat(buffer, sizeof(buffer), format, 2); + PrintToChat(i, "%s", buffer); + } + } +} + +/** + * Removes trailings zeroes from a string. Also removes the decimal point if it can. + * + * @param buffer Buffer to trim. + * @return Whether anything was removed. + */ +stock bool GCRemoveTrailing0s(char[] buffer) +{ + bool removed; + int maxlen = strlen(buffer); + + if (maxlen == 0) + { + return removed; + } + + for (int i = maxlen - 1; i > 0 && (buffer[i] == '0' || buffer[i] == '.' || buffer[i] == 0); i--) + { + if (buffer[i] == 0) + { + continue; + } + if (buffer[i] == '.') + { + buffer[i] = 0; + removed = true; + break; + } + buffer[i] = 0; + removed = true; + } + return removed; +} + +/** + * Formats time by HHMMSS. Uses ticks for the time. + * + * @param timeInTicks Time in ticks. + * @param tickRate Tickrate. + * @param formattedTime String to use for formatting. + * @param size String size. + */ +stock void GCFormatTickTimeHHMMSS(int timeInTicks, float tickRate, char[] formattedTime, int size) +{ + if (timeInTicks <= 0) + { + FormatEx(formattedTime, size, "-00:00:00"); + return; + } + + int time = RoundFloat(float(timeInTicks) / tickRate * 100.0); // centiseconds + int iHours = time / 360000; + int iMinutes = time / 6000 - iHours * 6000; + int iSeconds = (time - iHours * 360000 - iMinutes * 6000) / 100; + int iCentiSeconds = time % 100; + + if (iHours != 0) + { + FormatEx(formattedTime, size, "%02i:", iHours); + } + if (iMinutes != 0) + { + Format(formattedTime, size, "%s%02i:", formattedTime, iMinutes); + } + + Format(formattedTime, size, "%s%02i.%02i", formattedTime, iSeconds, iCentiSeconds); +} + +/** + * Formats time by HHMMSS. Uses seconds. + * + * @param seconds Time in seconds. + * @param formattedTime String to use for formatting. + * @param size String size. + * @param decimals Amount of decimals to use for the fractional part. + */ +stock void GCFormatTimeHHMMSS(float seconds, char[] formattedTime, int size, int decimals) +{ + int iFlooredTime = RoundToFloor(seconds); + int iHours = iFlooredTime / 3600; + int iMinutes = iFlooredTime / 60 - iHours * 60; + int iSeconds = iFlooredTime - iHours * 3600 - iMinutes * 60; + int iFraction = RoundToFloor(FloatFraction(seconds) * Pow(10.0, float(decimals))); + + if (iHours != 0) + { + FormatEx(formattedTime, size, "%02i:", iHours); + } + if (iMinutes != 0) + { + Format(formattedTime, size, "%s%02i:", formattedTime, iMinutes); + } + char szFraction[32]; + FormatEx(szFraction, sizeof(szFraction), "%i", iFraction); + + int iTest = strlen(szFraction); + for (int i; i < decimals - iTest; i++) + { + Format(szFraction, sizeof(szFraction), "%s%s", "0", szFraction); + } + + Format(formattedTime, size, "%s%02i.%s", formattedTime, iSeconds, szFraction); +} + +/** + * Encodes and appends a number onto the end of a UTF-8 string. + * + * @param string String to append to. + * @param strsize String size. + * @param number Unicode codepoint to encode. + */ +stock void GCEncodeUtf8(char[] string, char strsize, int number) +{ + // UTF-8 octet sequence (only change digits marked with x) + /* + Char. number range | UTF-8 octet sequence + (hexadecimal) | (binary) + --------------------+--------------------------------------------- + 0000 0000-0000 007F | 0xxxxxxx + 0000 0080-0000 07FF | 110xxxxx 10xxxxxx + 0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx + 0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx + // byte 4 | byte 3 | byte 2 | byte 1*/ + + //char encodedChar = 0b_11110000_10000000_10000000_10000000; + + int zeropos = strlen(string); + + if (zeropos >= strsize - 1) // need one byte for null terminator + { + return; + } + + if (number < 0) + { + //PrintToServer("ERROR: Encode() - Can't encode negative numbers"); + return; + } + + if (number >= 0x110_000) + { + //PrintToServer("ERROR: Encode() - Number is too big to encode"); + return; + } + + // 1 byte + if (number < 0x80) + { + string[zeropos] = number; + string[zeropos + 1] = '\0'; + } + // 2 bytes + else if (number < 0x800) + { + // can't encode if we don't have enough room + if (zeropos + 2 >= strsize) + { + return; + } + + string[zeropos] = 0b_1100_0000 | (number >> 6); // don't need to mask out bits over 0x7FF + string[zeropos + 1] = 0b_1000_0000 | (number & 0b_0011_1111); + + string[zeropos + 2] = '\0'; + } + // 3 bytes + else if (number < 0x10_000) + { + // can't encode if we don't have enough room + if (zeropos + 3 >= strsize) + { + return; + } + + string[zeropos] = 0b_1110_0000 | (number >> 12); // don't need to mask out bits over 0xFFFF + string[zeropos + 1] = 0b_1000_0000 | ((number >> 6) & 0b_0011_1111); + string[zeropos + 2] = 0b_1000_0000 | (number & 0b_0011_1111); + + string[zeropos + 3] = '\0'; + } + // 4 bytes + else if (number < 0x110_000) + { + // can't encode if we don't have enough room + if (zeropos + 4 >= strsize) + { + return; + } + + string[zeropos] = 0b_1111_0000 | (number >> 18); // don't need to mask out bits over 0x10FFFF + string[zeropos + 1] = 0b_1000_0000 | ((number >> 12) & 0b_0011_1111); + string[zeropos + 2] = 0b_1000_0000 | ((number >> 6) & 0b_0011_1111); + string[zeropos + 3] = 0b_1000_0000 | (number & 0b_0011_1111); + + string[zeropos + 4] = '\0'; + } +} + +// decode a UTF-8 string into an array of unicode codepoints +/** + * Decodes a UTF-8 string into an array of unicode codepoints. + * + * @param string String to decode. + * @param strsize String size. + * @param codepoints Array to use to store the codepoints. + * @param cplength Array length. + */ +stock void GCDecodeUtf8(char[] string, int strsize, int[] codepoints, int cplength) +{ + int charindex; + int cpindex; + + while (charindex < strsize && cpindex < cplength) + { + if (string[charindex] == '\0') + { + break; + } + + int bytes = GetCharBytes(string[charindex]); + + switch (bytes) + { + case 1: + { + codepoints[cpindex] = string[charindex]; + } + case 2: + { + codepoints[cpindex] = (string[charindex++] & 0b_0001_1111) << 6; // byte 2 + codepoints[cpindex] |= string[charindex] & 0b_0011_1111; // byte 1 + } + case 3: + { + codepoints[cpindex] = (string[charindex++] & 0b_0000_1111) << 12; // byte 3 + codepoints[cpindex] |= (string[charindex++] & 0b_0011_1111) << 6; // byte 2 + codepoints[cpindex] |= string[charindex] & 0b_0011_1111; // byte 1 + } + case 4: + { + codepoints[cpindex] = (string[charindex++] & 0b_0000_0111) << 18; // byte 4 + codepoints[cpindex] |= (string[charindex++] & 0b_0011_1111) << 12; // byte 3 + codepoints[cpindex] |= (string[charindex++] & 0b_0011_1111) << 6; // byte 2 + codepoints[cpindex] |= string[charindex] & 0b_0011_1111; // byte 1 + } + } + + charindex++; + cpindex++; + } +} + +/** + * Converts an integer to a string. + * Same as IntToString, but it returns the string. + * + * @param num Integer to convert. + * @return String of the number. + */ +stock char[] GCIntToStringRet(int num) +{ + char string[GC_FIXED_BUFFER_SIZE_SMALL]; + IntToString(num, string, sizeof string); + return string; +} + + /** + * Converts a floating point number to a string. + * Same as FloatToString, but it returns the string. + * + * @param num Floating point number to convert. + * @return String of the number. + */ +stock char[] GCFloatToStringRet(float num) +{ + char string[GC_FIXED_BUFFER_SIZE_SMALL]; + FloatToString(num, string, sizeof string); + return string; +} + +/** + * Formats a string according to the SourceMod format rules (see documentation). + * Same as Format, except it returns the formatted string. + * + * @param format Formatting rules. + * @param ... Variable number of format parameters. + * @return Formatted string. + */ +stock char[] GCFormatReturn(const char[] format, any ...) +{ + char string[GC_FIXED_BUFFER_SIZE_LARGE]; + VFormat(string, sizeof string, format, 2); + return string; +} + +/** + * Removes whitespace characters from the beginning and end of a string. + * Same as TrimString, except it returns the formatted string and + * it doesn't modify the passed string. + * + * @param str The string to trim. + * @return Number of bytes written (UTF-8 safe). + */ +stock char[] GCTrimStringReturn(char[] str) +{ + char string[GC_FIXED_BUFFER_SIZE_LARGE]; + strcopy(string, sizeof string, str); + TrimString(string); + return string; +}
\ No newline at end of file diff --git a/sourcemod/scripting/include/gamechaos/tempents.inc b/sourcemod/scripting/include/gamechaos/tempents.inc new file mode 100644 index 0000000..7ec9b5a --- /dev/null +++ b/sourcemod/scripting/include/gamechaos/tempents.inc @@ -0,0 +1,62 @@ + +#if defined _gamechaos_stocks_tempents_included + #endinput +#endif +#define _gamechaos_stocks_tempents_included + +// improved api of some tempents + +#define GC_TEMPENTS_VERSION 0x01_00_00 +#define GC_TEMPENTS_VERSION_STRING "1.0.0" + +#include <sdktools_tempents> + +/** + * Sets up a point to point beam effect. + * + * @param start Start position of the beam. + * @param end End position of the beam. + * @param modelIndex Precached model index. + * @param life Time duration of the beam. + * @param width Initial beam width. + * @param endWidth Final beam width. + * @param colour Color array (r, g, b, a). + * @param haloIndex Precached model index. + * @param amplitude Beam amplitude. + * @param speed Speed of the beam. + * @param fadeLength Beam fade time duration. + * @param frameRate Beam frame rate. + * @param startFrame Initial frame to render. + */ +stock void GCTE_SetupBeamPoints(const float start[3], + const float end[3], + int modelIndex, + float life = 2.0, + float width = 2.0, + float endWidth = 2.0, + const int colour[4] = {255, 255, 255, 255}, + int haloIndex = 0, + float amplitude = 0.0, + int speed = 0, + int fadeLength = 0, + int frameRate = 0, + int startFrame = 0) +{ + TE_Start("BeamPoints"); + TE_WriteVector("m_vecStartPoint", start); + TE_WriteVector("m_vecEndPoint", end); + TE_WriteNum("m_nModelIndex", modelIndex); + TE_WriteNum("m_nHaloIndex", haloIndex); + TE_WriteNum("m_nStartFrame", startFrame); + TE_WriteNum("m_nFrameRate", frameRate); + TE_WriteFloat("m_fLife", life); + TE_WriteFloat("m_fWidth", width); + TE_WriteFloat("m_fEndWidth", endWidth); + TE_WriteFloat("m_fAmplitude", amplitude); + TE_WriteNum("r", colour[0]); + TE_WriteNum("g", colour[1]); + TE_WriteNum("b", colour[2]); + TE_WriteNum("a", colour[3]); + TE_WriteNum("m_nSpeed", speed); + TE_WriteNum("m_nFadeLength", fadeLength); +}
\ No newline at end of file diff --git a/sourcemod/scripting/include/gamechaos/tracing.inc b/sourcemod/scripting/include/gamechaos/tracing.inc new file mode 100644 index 0000000..65d54a8 --- /dev/null +++ b/sourcemod/scripting/include/gamechaos/tracing.inc @@ -0,0 +1,242 @@ + +#if defined _gamechaos_stocks_tracing_included + #endinput +#endif +#define _gamechaos_stocks_tracing_included + +#include <sdktools_trace> + +#define GC_TRACING_VERSION 0x01_00_00 +#define GC_TRACING_VERSION_STRING "1.0.0" + +/** + * Trace ray filter that filters players from being traced. + * + * @param entity Entity. + * @param data Data. + * @return True on success, false otherwise. + */ +stock bool GCTraceEntityFilterPlayer(int entity, any data) +{ + return entity > MAXPLAYERS; +} + +/** + * Traces the player hull beneath the player in the direction of + * the player's velocity. This should be used on the tick when the player lands + * + * @param client Player's index. + * @param pos Player's position vector. + * @param velocity Player's velocity vector. This shuold have the current tick's x and y velocities, but the previous tick's z velocity, since when you're on ground, your z velocity is 0. + * @param result Trace endpoint on success, player's position on failure. + * @param bugged Whether to add gravity to the player's velocity or not. + * @return True on success, false otherwise. + */ +stock bool GCTraceLandPos(int client, const float pos[3], const float velocity[3], float result[3], float fGravity, bool bugged = false) +{ + float newVel[3]; + newVel = velocity; + + if (bugged) + { + // add 0.5 gravity + newVel[2] -= fGravity * GetTickInterval() * 0.5; + } + else + { + // add 1.5 gravity + newVel[2] -= fGravity * GetTickInterval() * 1.5; + } + + ScaleVector(newVel, GetTickInterval() * 2.0); + float pos2[3]; + AddVectors(pos, newVel, pos2); + + float mins[3]; + float maxs[3]; + GetClientMins(client, mins); + GetClientMaxs(client, maxs); + + Handle trace = TR_TraceHullFilterEx(pos, pos2, mins, maxs, MASK_PLAYERSOLID, GCTraceEntityFilterPlayer); + + if (!TR_DidHit(trace)) + { + result = pos; + CloseHandle(trace); + return false; + } + + TR_GetEndPosition(result, trace); + CloseHandle(trace); + + return true; +} + +/** + * Traces the player hull 2 units straight down beneath the player. + * + * @param client Player's index. + * @param pos Player's position vector. + * @param result Trace endpoint on success, player's position on failure. + * @return True on success, false otherwise. + */ +stock bool GCTraceGround(int client, const float pos[3], float result[3]) +{ + float mins[3]; + float maxs[3]; + + GetClientMins(client, mins); + GetClientMaxs(client, maxs); + + float startpos[3]; + float endpos[3]; + + startpos = pos; + endpos = pos; + + endpos[2] -= 2.0; + + TR_TraceHullFilter(startpos, endpos, mins, maxs, MASK_PLAYERSOLID, GCTraceEntityFilterPlayer); + + if (TR_DidHit()) + { + TR_GetEndPosition(result); + return true; + } + else + { + result = endpos; + return false; + } +} + +/** + * Traces a hull between 2 positions. + * + * @param pos1 Position 1. + * @param pos2 Position 2 + * @param result Trace endpoint on success, player's position on failure. + * @return True on success, false otherwise. + */ +stock bool GCTraceBlock(const float pos1[3], const float pos2[3], float result[3]) +{ + float mins[3] = {-16.0, -16.0, -1.0}; + float maxs[3] = { 16.0, 16.0, 0.0}; + + TR_TraceHullFilter(pos1, pos2, mins, maxs, MASK_PLAYERSOLID, GCTraceEntityFilterPlayer); + + if (TR_DidHit()) + { + TR_GetEndPosition(result); + return true; + } + else + { + return false; + } +} + +/** + * Traces from player eye position in the direction of where the player is looking. + * + * @param client Client index. + * @param result Resultant vector. + * @return True on success, false otherwise. + */ +stock bool GCGetEyeRayPosition(int client, float result[3], TraceEntityFilter filter, any data = 0, int flags = MASK_PLAYERSOLID) +{ + float start[3]; + float angle[3]; + + GetClientEyePosition(client, start); + GetClientEyeAngles(client, angle); + + TR_TraceRayFilter(start, angle, flags, RayType_Infinite, filter, data); + + if (TR_DidHit(INVALID_HANDLE)) + { + TR_GetEndPosition(result, INVALID_HANDLE); + return true; + } + return false; +} + +/** + * Traces from player eye position in the direction of where the player is looking, up to a certain distance. + * + * @param client Client index. + * @param result Resultant vector. + * @param distance Maximum distance to trace. + * @return True on success, false otherwise. + */ +stock bool GCTraceEyeRayPositionDistance(int client, float result[3], float distance) +{ + float start[3]; + float angle[3]; + + GetClientEyePosition(client, start); + GetClientEyeAngles(client, angle); + + float endpoint[3]; + float zsine = Sine(DegToRad(-angle[0])); + float zcos = Cosine(DegToRad(-angle[0])); + + endpoint[0] = Cosine(DegToRad(angle[1])) * zcos; + endpoint[1] = Sine(DegToRad(angle[1])) * zcos; + endpoint[2] = zsine; + + ScaleVector(endpoint, distance); + AddVectors(start, endpoint, endpoint); + + TR_TraceRayFilter(start, endpoint, MASK_PLAYERSOLID, RayType_EndPoint, GCTraceEntityFilterPlayer, client); + + if (TR_DidHit()) + { + TR_GetEndPosition(result); + return true; + } + + result = endpoint; + return false; +} + +/** + * Traces a hull in a certain direction and distance. + * + * @param origin Position to trace from. + * @param direction Trace direction. + * @param mins Minimum size of the hull. + * @param maxs Maximum size of the hull. + * @param result Resultant vector. + * @return True on success, false otherwise. + */ +stock bool GCTraceHullDirection(const float origin[3], + const float direction[3], + const float mins[3], + const float maxs[3], + float result[3], + float distance, + TraceEntityFilter filter, + any data = 0, + int flags = MASK_PLAYERSOLID) +{ + float pos2[3]; + float zsine = Sine(DegToRad(-direction[0])); + float zcos = Cosine(DegToRad(-direction[0])); + + pos2[0] = Cosine(DegToRad(direction[1])) * zcos; + pos2[1] = Sine(DegToRad(direction[1])) * zcos; + pos2[2] = zsine; + + ScaleVector(pos2, distance); + AddVectors(origin, pos2, pos2); + + TR_TraceHullFilter(origin, pos2, mins, maxs, flags, filter, data); + if (TR_DidHit()) + { + TR_GetEndPosition(result); + return true; + } + result = pos2; + return false; +}
\ No newline at end of file diff --git a/sourcemod/scripting/include/gamechaos/vectors.inc b/sourcemod/scripting/include/gamechaos/vectors.inc new file mode 100644 index 0000000..79d5e8f --- /dev/null +++ b/sourcemod/scripting/include/gamechaos/vectors.inc @@ -0,0 +1,66 @@ + +#if defined _gamechaos_stocks_vectors_included + #endinput +#endif +#define _gamechaos_stocks_vectors_included + +#define GC_VECTORS_VERSION 0x01_00_01 +#define GC_VECTORS_VERSION_STRING "1.0.1" + +/** + * Calculates the horizontal (x, y) length of a vector. + * + * @param vec Vector. + * @return Vector length (magnitude). + */ +stock float GCGetVectorLength2D(const float vec[3]) +{ + float tempVec[3]; + tempVec = vec; + tempVec[2] = 0.0; + + return GetVectorLength(tempVec); +} + +/** + * Calculates the horizontal (x, y) distance between 2 vectors. + * + * @param x Vector 1. + * @param y Vector 2. + * @param tolerance How close the floats have to be to return true. + * @return True on success, false otherwise. + */ +stock float GCGetVectorDistance2D(const float x[3], const float y[3]) +{ + float x2[3]; + float y2[3]; + + x2 = x; + y2 = y; + + x2[2] = 0.0; + y2[2] = 0.0; + + return GetVectorDistance(x2, y2); +} + +/** + * Checks if 2 vectors are exactly equal. + * + * @param a Vector 1. + * @param b Vector 2. + * @return True on success, false otherwise. + */ +stock bool GCVectorsEqual(const float a[3], const float b[3]) +{ + bool result = true; + for (int i = 0; i < 3; i++) + { + if (a[i] != b[i]) + { + result = false; + break; + } + } + return result; +}
\ No newline at end of file diff --git a/sourcemod/scripting/include/glib/addressutils.inc b/sourcemod/scripting/include/glib/addressutils.inc new file mode 100644 index 0000000..bbe8f14 --- /dev/null +++ b/sourcemod/scripting/include/glib/addressutils.inc @@ -0,0 +1,54 @@ +#if defined _addressutils_included +#endinput +#endif +#define _addressutils_included + +methodmap AddressBase +{ + property Address Address + { + public get() { return view_as<Address>(this); } + } +} + +//-==Operator overloadings +stock Address operator+(Address l, int r) +{ + return l + view_as<Address>(r); +} + +stock Address operator+(int l, Address r) +{ + return view_as<Address>(l) + r; +} + +stock Address operator-(Address l, int r) +{ + return l - view_as<Address>(r); +} + +stock Address operator-(int l, Address r) +{ + return view_as<Address>(l) - r; +} + +stock Address operator*(Address l, int r) +{ + return l * view_as<Address>(r); +} + +stock Address operator*(int l, Address r) +{ + return view_as<Address>(l) * r; +} + +stock Address operator/(Address l, int r) +{ + return l / view_as<Address>(r); +} + +stock Address operator/(int l, Address r) +{ + return view_as<Address>(l) / r; +} +//Operator overloadings==-
\ No newline at end of file diff --git a/sourcemod/scripting/include/glib/assertutils.inc b/sourcemod/scripting/include/glib/assertutils.inc new file mode 100644 index 0000000..83cd90d --- /dev/null +++ b/sourcemod/scripting/include/glib/assertutils.inc @@ -0,0 +1,61 @@ +#if defined _assertutils_included +#endinput +#endif +#define _assertutils_included + +/* Compile time settings for this include. Should be defined before including this file. +* #define ASSERTUTILS_DISABLE //Disables all assertions +* #define ASSERTUTILS_FAILSTATE_FUNC //Define the name of the function that should be called when assertion is hit +*/ + +#if !defined SNAME +#define __SNAME "" +#else +#define __SNAME SNAME +#endif + +#define ASSERT_FMT_STRING_LEN 512 + +#if defined ASSERTUTILS_DISABLE + +#define ASSERT(%1)%2; +#define ASSERT_MSG(%1,%2)%3; +#define ASSERT_FMT(%1,%2)%3; +#define ASSERT_FINAL(%1)%2; +#define ASSERT_FINAL_MSG(%1,%2)%3; + +#elseif defined ASSERTUTILS_FAILSTATE_FUNC + +#define ASSERT(%1) if(!(%1)) ASSERTUTILS_FAILSTATE_FUNC(__SNAME..."Assertion failed: \""...#%1..."\"") +#define ASSERT_MSG(%1,%2) if(!(%1)) ASSERTUTILS_FAILSTATE_FUNC(__SNAME...%2) +#define ASSERT_FMT(%1,%2) if(!(%1)) ASSERTUTILS_FAILSTATE_FUNC(__SNAME...%2) +#define ASSERT_FINAL(%1) if(!(%1)) SetFailState(__SNAME..."Assertion failed: \""...#%1..."\"") +#define ASSERT_FINAL_MSG(%1,%2) if(!(%1)) SetFailState(__SNAME...%2) + +#else + +#define ASSERT(%1) if(!(%1)) SetFailState(__SNAME..."Assertion failed: \""...#%1..."\"") +#define ASSERT_MSG(%1,%2) if(!(%1)) SetFailState(__SNAME...%2) +#define ASSERT_FMT(%1,%2) if(!(%1)) SetFailState(__SNAME...%2) +#define ASSERT_FINAL(%1) ASSERT(%1) +#define ASSERT_FINAL_MSG(%1,%2) ASSERT_MSG(%1,%2) + +#endif + +// Might be redundant as default ASSERT_MSG accept format arguments just fine. +#if 0 +stock void ASSERT_FMT(bool result, char[] fmt, any ...) +{ +#if !defined ASSERTUTILS_DISABLE + if(!result) + { + char buff[ASSERT_FMT_STRING_LEN]; + VFormat(buff, sizeof(buff), fmt, 3); + + SetFailState(__SNAME..."%s", buff); + } +#endif +} +#endif + +#undef ASSERT_FMT_STRING_LEN
\ No newline at end of file diff --git a/sourcemod/scripting/include/glib/memutils.inc b/sourcemod/scripting/include/glib/memutils.inc new file mode 100644 index 0000000..5813d92 --- /dev/null +++ b/sourcemod/scripting/include/glib/memutils.inc @@ -0,0 +1,232 @@ +#if defined _memutils_included +#endinput +#endif +#define _memutils_included + +#include "glib/assertutils" +#include "glib/addressutils" + +/* Compile time settings for this include. Should be defined before including this file. +* #define MEMUTILS_PLUGINENDCALL //This should be defined if main plugin has OnPluginEnd() forward used. +*/ + +#define MEM_LEN_SAFE_THRESHOLD 2000 + +//-==PatchHandling methodmap +static StringMap gPatchStack; + +methodmap PatchHandler < AddressBase +{ + public PatchHandler(Address addr) + { + ASSERT(addr != Address_Null); + + if(!gPatchStack) + gPatchStack = new StringMap(); + + return view_as<PatchHandler>(addr); + } + + property any Any + { + public get() { return view_as<any>(this); } + } + + public void Save(int len) + { + ASSERT(gPatchStack); + ASSERT(len > 0 && len < MEM_LEN_SAFE_THRESHOLD); + + len++; + + int[] arr = new int[len]; + arr[0] = len; + + for(int i = 0; i < len - 1; i++) + arr[i + 1] = LoadFromAddress(this.Address + i, NumberType_Int8); + + char buff[32]; + IntToString(this.Any, buff, sizeof(buff)); + gPatchStack.SetArray(buff, arr, len); + } + + public void PatchNSave(int len, char byte = 0x90) + { + ASSERT(gPatchStack); + ASSERT(len > 0 && len < MEM_LEN_SAFE_THRESHOLD); + + len++; + + int[] arr = new int[len]; + arr[0] = len; + + for(int i = 0; i < len - 1; i++) + { + arr[i + 1] = LoadFromAddress(this.Address + i, NumberType_Int8); + StoreToAddress(this.Address + i, byte, NumberType_Int8); + } + + char buff[32]; + IntToString(this.Any, buff, sizeof(buff)); + gPatchStack.SetArray(buff, arr, len); + } + + public void PatchNSaveSeq(const char[] data, int len) + { + ASSERT(gPatchStack); + ASSERT(len > 0 && len < MEM_LEN_SAFE_THRESHOLD); + + len++; + + int[] arr = new int[len]; + arr[0] = len; + + for(int i = 0; i < len - 1; i++) + { + arr[i + 1] = LoadFromAddress(this.Address + i, NumberType_Int8); + StoreToAddress(this.Address + i, data[i], NumberType_Int8); + } + + char buff[32]; + IntToString(this.Any, buff, sizeof(buff)); + gPatchStack.SetArray(buff, arr, len); + } + + public void Restore() + { + if(!gPatchStack) + return; + + char buff[32]; + IntToString(this.Any, buff, sizeof(buff)); + + int arrSize[1]; + if(!gPatchStack.GetArray(buff, arrSize, sizeof(arrSize))) + return; + + int[] arr = new int[arrSize[0]]; + gPatchStack.GetArray(buff, arr, arrSize[0]); + gPatchStack.Remove(buff); + + for(int i = 0; i < arrSize[0] - 1; i++) + StoreToAddress(this.Address + i, arr[i + 1], NumberType_Int8); + + if(gPatchStack.Size == 0) + delete gPatchStack; + } +} + +public void OnPluginEnd() +{ + if(gPatchStack) + { + StringMapSnapshot sms = gPatchStack.Snapshot(); + char buff[32]; + Address addr; + + for(int i = 0; i < sms.Length; i++) + { + sms.GetKey(i, buff, sizeof(buff)); + addr = view_as<Address>(StringToInt(buff)); + view_as<PatchHandler>(addr).Restore(); + } + } + +#if defined MEMUTILS_PLUGINENDCALL + OnPluginEnd_MemUtilsRedefined(); +#endif +} +#undef OnPluginEnd +#if defined MEMUTILS_PLUGINENDCALL +#define OnPluginEnd OnPluginEnd_MemUtilsRedefined +#else +#define OnPluginEnd OnPluginEnd_Redifined(){}\ +void MEMUTILS_INCLUDE_WARNING_OnPluginEnd_REDIFINITION +#endif +//PatchHandling methodmap==- + +//-==Other util functions +stock int LoadStringFromAddress(Address addr, char[] buff, int length) +{ + int i; + for(i = 0; i < length && (buff[i] = LoadFromAddress(addr + i, NumberType_Int8)) != '\0'; i++) { } + buff[i == length ? i - 1 : i] = '\0'; + return i; +} + +stock void DumpOnAddress(Address addr, int len, int columns = 10) +{ + char buff[128], buff2[128]; + + ASSERT(addr != Address_Null); + ASSERT(len > 0 && len < MEM_LEN_SAFE_THRESHOLD); + + Format(buff, sizeof(buff), "[0x%08X]", addr); + char chr; + for(int i = 0; i < len; i++) + { + chr = LoadFromAddress(addr + i, NumberType_Int8); + Format(buff, sizeof(buff), "%s %02X", buff, chr); + Format(buff2, sizeof(buff2), "%s%c", buff2, (chr > ' ' && chr != 0x7F && chr != 0xFF ? chr : '.')); + if(i % columns == columns - 1) + { + PrintToServer(__SNAME..."%s %s", buff, buff2); + Format(buff, sizeof(buff), "[0x%08X]", addr + i); + buff2[0] = '\0'; + } + } + + if((len - 1) % columns != columns - 1) + PrintToServer(__SNAME..."%s %s", buff, buff2); +} + +//NO OVERLAPPING!! +stock void MoveBytes(Address from, Address to, int len, char replace_with = 0x90) +{ + ASSERT(from != Address_Null); + ASSERT(to != Address_Null); + ASSERT(len > 0 && len < MEM_LEN_SAFE_THRESHOLD); + ASSERT(to < from || to > from + len); + + if(from == to) + return; + + for(int i = 0; i < len; i++) + { + StoreToAddress(to + i, LoadFromAddress(from + i, NumberType_Int8), NumberType_Int8); + StoreToAddress(from + i, replace_with, NumberType_Int8); + } +} + +stock void CutNCopyBytes(Address from, Address to, int len, char replace_with = 0x90) +{ + ASSERT(from != Address_Null); + ASSERT(to != Address_Null); + ASSERT(len > 0 && len < MEM_LEN_SAFE_THRESHOLD); + + if(from == to) + return; + + int[] arr = new int[len]; + + for(int i = 0; i < len; i++) + { + arr[i] = LoadFromAddress(from + i, NumberType_Int8); + StoreToAddress(from + i, replace_with, NumberType_Int8); + } + + for(int i = 0; i < len; i++) + StoreToAddress(to + i, arr[i], NumberType_Int8); +} + +stock void PatchArea(Address addr, int len, char byte = 0x90) +{ + ASSERT(addr != Address_Null); + ASSERT(len > 0 && len < MEM_LEN_SAFE_THRESHOLD); + + for(int i = 0; i < len; i++) + StoreToAddress(addr + i, byte, NumberType_Int8); +} +//Other util functions==- + +#undef MEM_LEN_SAFE_THRESHOLD
\ No newline at end of file diff --git a/sourcemod/scripting/include/gokz.inc b/sourcemod/scripting/include/gokz.inc new file mode 100644 index 0000000..edbd896 --- /dev/null +++ b/sourcemod/scripting/include/gokz.inc @@ -0,0 +1,1097 @@ +/* + GOKZ General Include + + Website: https://bitbucket.org/kztimerglobalteam/gokz +*/ + +#if defined _gokz_included_ +#endinput +#endif +#define _gokz_included_ +#include <cstrike> +#include <movement> + +#include <gokz/version> + + + +// =====[ ENUMS ]===== + +enum ObsMode +{ + ObsMode_None = 0, // Not in spectator mode + ObsMode_DeathCam, // Special mode for death cam animation + ObsMode_FreezeCam, // Zooms to a target, and freeze-frames on them + ObsMode_Fixed, // View from a fixed camera position + ObsMode_InEye, // Follow a player in first person view + ObsMode_Chase, // Follow a player in third person view + ObsMode_Roaming // Free roaming +}; + + + +// =====[ CONSTANTS ]===== + +#define GOKZ_SOURCE_URL "https://github.com/KZGlobalTeam/gokz" +#define GOKZ_UPDATER_BASE_URL "http://updater.gokz.org/v2/" +#define GOKZ_COLLISION_GROUP_STANDARD 2 +#define GOKZ_COLLISION_GROUP_NOTRIGGER 1 +#define GOKZ_TP_FREEZE_TICKS 5 +#define EPSILON 0.000001 +#define PI 3.14159265359 +#define SPEED_NORMAL 250.0 +#define SPEED_NO_WEAPON 260.0 +#define FLOAT_MAX view_as<float>(0x7F7FFFFF) +#define SF_BUTTON_USE_ACTIVATES 1024 +#define IGNORE_JUMP_TIME 0.2 +stock float PLAYER_MINS[3] = {-16.0, -16.0, 0.0}; +stock float PLAYER_MAXS[3] = {16.0, 16.0, 72.0}; +stock float PLAYER_MAXS_DUCKED[3] = {16.0, 16.0, 54.0}; + + + +// =====[ STOCKS ]===== + +/** + * Represents a time float as a string e.g. 01:23.45. + * + * @param time Time in seconds. + * @param precise Whether to include fractional seconds. + * @return String representation of time. + */ +stock char[] GOKZ_FormatTime(float time, bool precise = true) +{ + char formattedTime[12]; + + int roundedTime = RoundFloat(time * 100); // Time rounded to number of centiseconds + + int centiseconds = roundedTime % 100; + roundedTime = (roundedTime - centiseconds) / 100; + int seconds = roundedTime % 60; + roundedTime = (roundedTime - seconds) / 60; + int minutes = roundedTime % 60; + roundedTime = (roundedTime - minutes) / 60; + int hours = roundedTime; + + if (hours == 0) + { + if (precise) + { + FormatEx(formattedTime, sizeof(formattedTime), "%02d:%02d.%02d", minutes, seconds, centiseconds); + } + else + { + FormatEx(formattedTime, sizeof(formattedTime), "%d:%02d", minutes, seconds); + } + } + else + { + if (precise) + { + FormatEx(formattedTime, sizeof(formattedTime), "%d:%02d:%02d.%02d", hours, minutes, seconds, centiseconds); + } + else + { + FormatEx(formattedTime, sizeof(formattedTime), "%d:%02d:%02d", hours, minutes, seconds); + } + } + return formattedTime; +} + +/** + * Checks if the value is a valid client entity index, if they are in-game and not GOTV. + * + * @param client Client index. + * @return Whether client is valid. + */ +stock bool IsValidClient(int client) +{ + return client >= 1 && client <= MaxClients && IsClientInGame(client) && !IsClientSourceTV(client); +} + +/** + * Returns the greater of two float values. + * + * @param value1 First value. + * @param value2 Second value. + * @return Greatest value. + */ +stock float FloatMax(float value1, float value2) +{ + if (value1 >= value2) + { + return value1; + } + return value2; +} + +/** + * Returns the lesser of two float values. + * + * @param value1 First value. + * @param value2 Second value. + * @return Lesser value. + */ +stock float FloatMin(float value1, float value2) +{ + if (value1 <= value2) + { + return value1; + } + return value2; +} + +/** + * Clamp a float value between an upper and lower bound. + * + * @param value Preferred value. + * @param min Minimum value. + * @param max Maximum value. + * @return The closest value to the preferred value. + */ +stock float FloatClamp(float value, float min, float max) +{ + if (value >= max) + { + return max; + } + if (value <= min) + { + return min; + } + return value; +} + + +/** + * Returns the greater of two int values. + * + * @param value1 First value. + * @param value2 Second value. + * @return Greatest value. + */ +stock int IntMax(int value1, int value2) +{ + if (value1 >= value2) + { + return value1; + } + return value2; +} + +/** + * Returns the lesser of two int values. + * + * @param value1 First value. + * @param value2 Second value. + * @return Lesser value. + */ +stock int IntMin(int value1, int value2) +{ + if (value1 <= value2) + { + return value1; + } + return value2; +} + +/** + * Rounds a float to the nearest specified power of 10. + * + * @param value Value to round. + * @param power Power of 10 to round to. + * @return Rounded value. + */ +stock float RoundToPowerOfTen(float value, int power) +{ + float pow = Pow(10.0, float(power)); + return RoundFloat(value / pow) * pow; +} + +/** + * Sets all characters in a string to lower case. + * + * @param input Input string. + * @param output Output buffer. + * @param size Maximum size of output. + */ +stock void String_ToLower(const char[] input, char[] output, int size) +{ + size--; + int i = 0; + while (input[i] != '\0' && i < size) + { + output[i] = CharToLower(input[i]); + i++; + } + output[i] = '\0'; +} + +/** + * Gets the client's observer mode. + * + * @param client Client index. + * @return Current observer mode. + */ +stock ObsMode GetObserverMode(int client) +{ + return view_as<ObsMode>(GetEntProp(client, Prop_Send, "m_iObserverMode")); +} + +/** + * Gets the player a client is spectating. + * + * @param client Client index. + * @return Client index of target, or -1 if not spectating anyone. + */ +stock int GetObserverTarget(int client) +{ + if (!IsValidClient(client)) + { + return -1; + } + ObsMode mode = GetObserverMode(client); + if (mode == ObsMode_InEye || mode == ObsMode_Chase) + { + return GetEntPropEnt(client, Prop_Send, "m_hObserverTarget"); + } + return -1; +} + +/** + * Emits a sound to other players that are spectating the client. + * + * @param client Client being spectated. + * @param sound Sound to play. + */ +stock void EmitSoundToClientSpectators(int client, const char[] sound) +{ + for (int i = 1; i <= MaxClients; i++) + { + if (IsValidClient(i) && GetObserverTarget(i) == client) + { + EmitSoundToClient(i, sound); + } + } +} + +/** + * Calculates the lowest angle from angle A to angle B. + * Input and result angles are between -180 and 180. + * + * @param angleA Angle A. + * @param angleB Angle B. + * @return Delta angle. + */ +stock float CalcDeltaAngle(float angleA, float angleB) +{ + float difference = angleB - angleA; + + if (difference > 180.0) + { + difference = difference - 360.0; + } + else if (difference <= -180.0) + { + difference = difference + 360.0; + } + + return difference; +} + +/** + * Strips all color control characters in a string. + * The Output buffer can be the same as the input buffer. + * Original code by Psychonic, thanks. + * Source: smlib + * + * @param input Input String. + * @param output Output String. + * @param size Max Size of the Output string + */ +stock void Color_StripFromChatText(const char[] input, char[] output, int size) +{ + int x = 0; + for (int i = 0; input[i] != '\0'; i++) { + + if (x + 1 == size) + { + break; + } + + int character = input[i]; + + if (character > 0x08) + { + output[x++] = character; + } + } + + output[x] = '\0'; +} + +/** + * Returns an integer as a string. + * + * @param num Integer to stringify. + * @return Integer as a string. + */ +stock char[] IntToStringEx(int num) +{ + char string[12]; + IntToString(num, string, sizeof(string)); + return string; +} + +/** + * Returns a float as a string. + * + * @param num Float to stringify. + * @return Float as a string. + */ +stock char[] FloatToStringEx(float num) +{ + char string[32]; + FloatToString(num, string, sizeof(string)); + return string; +} + +/** + * Increment an index, looping back to 0 if the max value is reached. + * + * @param index Current index. + * @param buffer Max value of index. + * @return Current index incremented, or 0 if max value is reached. + */ +stock int NextIndex(int index, int max) +{ + index++; + if (index == max) + { + return 0; + } + return index; +} + +/** + * Reorders an array with current index at the front, and previous + * values after, including looping back to the end after reaching + * the start of the array. + * + * @param input Array to reorder. + * @param inputSize Size of input array. + * @param buffer Output buffer. + * @param bufferSize Size of buffer. + * @param index Index of current/most recent value of input array. + */ +stock void SortByRecent(const int[] input, int inputSize, int[] buffer, int bufferSize, int index) +{ + int reorderedIndex = 0; + for (int i = index; reorderedIndex < bufferSize && i >= 0; i--) + { + buffer[reorderedIndex] = input[i]; + reorderedIndex++; + } + for (int i = inputSize - 1; reorderedIndex < bufferSize && i > index; i--) + { + buffer[reorderedIndex] = input[i]; + reorderedIndex++; + } +} + +/** + * Returns the Steam account ID for a given SteamID2. + * Checks for invalid input are not very extensive. + * + * @param steamID2 SteamID2 to convert. + * @return Steam account ID, or -1 if invalid. + */ +stock int Steam2ToSteamAccountID(const char[] steamID2) +{ + char pieces[3][16]; + if (ExplodeString(steamID2, ":", pieces, sizeof(pieces), sizeof(pieces[])) != 3) + { + return -1; + } + + int IDNumberPart1 = StringToInt(pieces[1]); + int IDNumberPart2 = StringToInt(pieces[2]); + if (pieces[1][0] != '0' && IDNumberPart1 == 0 || IDNumberPart1 != 0 && IDNumberPart1 != 1 || IDNumberPart2 <= 0) + { + return -1; + } + + return IDNumberPart1 + (IDNumberPart2 << 1); +} + +/** + * Teleports a player and removes their velocity and base velocity + * immediately and also every tick for the next 5 ticks. Automatically + * makes the player crouch if there is a ceiling above them. + * + * @param client Client index. + * @param origin Origin to teleport to. + * @param angles Eye angles to set. + */ +stock void TeleportPlayer(int client, const float origin[3], const float angles[3], bool setAngles = true, bool holdStill = true) +{ + // Clear the player's parent before teleporting to fix being + // teleported into seemingly random places if the player has a parent. + AcceptEntityInput(client, "ClearParent"); + + Movement_SetOrigin(client, origin); + Movement_SetVelocity(client, view_as<float>( { 0.0, 0.0, 0.0 } )); + Movement_SetBaseVelocity(client, view_as<float>( { 0.0, 0.0, 0.0 } )); + if (setAngles) + { + // NOTE: changing angles with TeleportEntity can fail due to packet loss!!! + // (Movement_SetEyeAngles is a thin wrapper of TeleportEntity) + Movement_SetEyeAngles(client, angles); + } + // Duck the player if there is something blocking them from above + Handle trace = TR_TraceHullFilterEx(origin, + origin, + view_as<float>( { -16.0, -16.0, 0.0 } ), // Standing players are 32 x 32 x 72 + view_as<float>( { 16.0, 16.0, 72.0 } ), + MASK_PLAYERSOLID, + TraceEntityFilterPlayers, + client); + bool ducked = TR_DidHit(trace); + + if (holdStill) + { + // Prevent noclip exploit + SetEntProp(client, Prop_Send, "m_CollisionGroup", GOKZ_COLLISION_GROUP_STANDARD); + + // Intelligently hold player still to prevent booster and trigger exploits + StartHoldStill(client, ducked); + } + else if (ducked) + { + ForcePlayerDuck(client); + } + + delete trace; +} + +static void StartHoldStill(int client, bool ducked) +{ + DataPack data = new DataPack(); + data.WriteCell(GetClientUserId(client)); + data.WriteCell(0); // tick counter + data.WriteCell(GOKZ_TP_FREEZE_TICKS); // number of ticks to hold still + data.WriteCell(ducked); + ContinueHoldStill(data); +} + +public void ContinueHoldStill(DataPack data) +{ + data.Reset(); + int client = GetClientOfUserId(data.ReadCell()); + int ticks = data.ReadCell(); + int tickCount = data.ReadCell(); + bool ducked = data.ReadCell(); + delete data; + + if (!IsValidClient(client)) + { + return; + } + + if (ticks < tickCount) + { + Movement_SetVelocity(client, view_as<float>( { 0.0, 0.0, 0.0 } )); + Movement_SetBaseVelocity(client, view_as<float>( { 0.0, 0.0, 0.0 } )); + Movement_SetGravity(client, 1.0); + + // Don't drop the player off of ladders. + // The game will automatically change the movetype back to MOVETYPE_WALK if it can't find a ladder. + // Don't change the movetype if it's currently MOVETYPE_NONE, as that means the player is paused. + if (Movement_GetMovetype(client) != MOVETYPE_NONE) + { + Movement_SetMovetype(client, MOVETYPE_LADDER); + } + + // Prevent noclip exploit + SetEntProp(client, Prop_Send, "m_CollisionGroup", GOKZ_COLLISION_GROUP_STANDARD); + + // Force duck on player and make sure that the player can't trigger triggers above them. + // they can still trigger triggers even when we force ducking. + if (ducked) + { + ForcePlayerDuck(client); + + if (ticks < tickCount - 1) + { + // Don't trigger triggers + SetEntProp(client, Prop_Send, "m_CollisionGroup", GOKZ_COLLISION_GROUP_NOTRIGGER); + } + else + { + // Let the player trigger triggers on the last tick + SetEntProp(client, Prop_Send, "m_CollisionGroup", GOKZ_COLLISION_GROUP_STANDARD); + } + } + + ++ticks; + data = new DataPack(); + data.WriteCell(GetClientUserId(client)); + data.WriteCell(ticks); + data.WriteCell(tickCount); + data.WriteCell(ducked); + RequestFrame(ContinueHoldStill, data); + } +} + +/** + * Forces the player to instantly duck. + * + * @param client Client index. + */ +stock void ForcePlayerDuck(int client) +{ + // these are both necessary, because on their own the player will sometimes still be in a state that isn't fully ducked. + SetEntPropFloat(client, Prop_Send, "m_flDuckAmount", 1.0, 0); + SetEntProp(client, Prop_Send, "m_bDucking", false); + SetEntProp(client, Prop_Send, "m_bDucked", true); +} + +/** + * Returns whether the player is stuck e.g. in a wall after noclipping. + * + * @param client Client index. + * @return Whether player is stuck. + */ +stock bool IsPlayerStuck(int client) +{ + float vecMin[3], vecMax[3], vecOrigin[3]; + + GetClientMins(client, vecMin); + GetClientMaxs(client, vecMax); + GetClientAbsOrigin(client, vecOrigin); + + TR_TraceHullFilter(vecOrigin, vecOrigin, vecMin, vecMax, MASK_PLAYERSOLID, TraceEntityFilterPlayers); + return TR_DidHit(); // head in wall ? +} + +/** + * Retrieves the absolute origin of an entity. + * + * @param entity Index of the entity. + * @param result Entity's origin if successful. + * @return Returns true if successful. + */ +stock bool GetEntityAbsOrigin(int entity, float result[3]) +{ + if (!IsValidEntity(entity)) + { + return false; + } + + if (!HasEntProp(entity, Prop_Data, "m_vecAbsOrigin")) + { + return false; + } + + GetEntPropVector(entity, Prop_Data, "m_vecAbsOrigin", result); + return true; +} + +/** + * Retrieves the name of an entity. + * + * @param entity Index of the entity. + * @param buffer Buffer to store the name. + * @param maxlength Maximum length of the buffer. + * @return Number of non-null bytes written. + */ +stock int GetEntityName(int entity, char[] buffer, int maxlength) +{ + return GetEntPropString(entity, Prop_Data, "m_iName", buffer, maxlength); +} + +/** + * Finds an entity by name or by name and classname. + * Taken from smlib https://github.com/bcserv/smlib + * This can take anywhere from ~0.2% to ~11% of frametime (i5-7600k) in the worst case scenario where + * every entity which has a name (4096 of them) is iterated over. Your mileage may vary. + * + * @param name Name of the entity to find. + * @param className Optional classname to match along with name. + * @param ignorePlayers Ignore player entities. + * @return Entity index if successful, INVALID_ENT_REFERENCE if not. + */ +stock int GOKZFindEntityByName(const char[] name, const char[] className = "", bool ignorePlayers = false) +{ + int result = INVALID_ENT_REFERENCE; + if (className[0] == '\0') + { + // HACK: Double the limit to get non-networked entities too. + // https://developer.valvesoftware.com/wiki/Entity_limit + int realMaxEntities = GetMaxEntities() * 2; + int startEntity = 1; + if (ignorePlayers) + { + startEntity = MaxClients + 1; + } + for (int entity = startEntity; entity < realMaxEntities; entity++) + { + if (!IsValidEntity(entity)) + { + continue; + } + + char entName[65]; + GetEntityName(entity, entName, sizeof(entName)); + if (StrEqual(entName, name)) + { + result = entity; + break; + } + } + } + else + { + int entity = INVALID_ENT_REFERENCE; + while ((entity = FindEntityByClassname(entity, className)) != INVALID_ENT_REFERENCE) + { + char entName[65]; + GetEntityName(entity, entName, sizeof(entName)); + if (StrEqual(entName, name)) + { + result = entity; + break; + } + } + } + return result; +} + +/** + * Gets the current map's display name in lower case. + * + * @param buffer Buffer to store the map name. + * @param maxlength Maximum length of buffer. + */ +stock void GetCurrentMapDisplayName(char[] buffer, int maxlength) +{ + char map[PLATFORM_MAX_PATH]; + GetCurrentMap(map, sizeof(map)); + GetMapDisplayName(map, map, sizeof(map)); + String_ToLower(map, buffer, maxlength); +} + +/** + * Gets the current map's file size. + */ +stock int GetCurrentMapFileSize() +{ + char mapBuffer[PLATFORM_MAX_PATH]; + GetCurrentMap(mapBuffer, sizeof(mapBuffer)); + Format(mapBuffer, sizeof(mapBuffer), "maps/%s.bsp", mapBuffer); + return FileSize(mapBuffer); +} + +/** + * Copies the elements of a source vector to a destination vector. + * + * @param src Source vector. + * @param dest Destination vector. + */ +stock void CopyVector(const any src[3], any dest[3]) +{ + dest[0] = src[0]; + dest[1] = src[1]; + dest[2] = src[2]; +} + +/** + * Returns whether the player is spectating. + * + * @param client Client index. + */ +stock bool IsSpectating(int client) +{ + int team = GetClientTeam(client); + return team == CS_TEAM_SPECTATOR || team == CS_TEAM_NONE; +} + +/** + * Rotate a vector on an axis. + * + * @param vec Vector to rotate. + * @param axis Axis to rotate around. + * @param theta Angle in radians. + * @param result Rotated vector. + */ +stock void RotateVectorAxis(float vec[3], float axis[3], float theta, float result[3]) +{ + float cosTheta = Cosine(theta); + float sinTheta = Sine(theta); + + float axisVecCross[3]; + GetVectorCrossProduct(axis, vec, axisVecCross); + + for (int i = 0; i < 3; i++) + { + result[i] = (vec[i] * cosTheta) + (axisVecCross[i] * sinTheta) + (axis[i] * GetVectorDotProduct(axis, vec)) * (1.0 - cosTheta); + } +} + +/** + * Rotate a vector by pitch and yaw. + * + * @param vec Vector to rotate. + * @param pitch Pitch angle (in degrees). + * @param yaw Yaw angle (in degrees). + * @param result Rotated vector. + */ +stock void RotateVectorPitchYaw(float vec[3], float pitch, float yaw, float result[3]) +{ + if (pitch != 0.0) + { + RotateVectorAxis(vec, view_as<float>({0.0, 1.0, 0.0}), DegToRad(pitch), result); + } + if (yaw != 0.0) + { + RotateVectorAxis(result, view_as<float>({0.0, 0.0, 1.0}), DegToRad(yaw), result); + } +} + +/** + * Attempts to return a valid spawn location. + * + * @param origin Spawn origin if found. + * @param angles Spawn angles if found. + * @return Whether a valid spawn point is found. + */ +stock bool GetValidSpawn(float origin[3], float angles[3]) +{ + // Return true if the spawn found is truly valid (not in the ground or out of bounds) + bool foundValidSpawn; + bool searchCT; + float spawnOrigin[3]; + float spawnAngles[3]; + int spawnEntity = -1; + while (!foundValidSpawn) + { + if (searchCT) + { + spawnEntity = FindEntityByClassname(spawnEntity, "info_player_counterterrorist"); + } + else + { + spawnEntity = FindEntityByClassname(spawnEntity, "info_player_terrorist"); + } + + if (spawnEntity != -1) + { + GetEntPropVector(spawnEntity, Prop_Data, "m_vecOrigin", spawnOrigin); + GetEntPropVector(spawnEntity, Prop_Data, "m_angRotation", spawnAngles); + if (IsSpawnValid(spawnOrigin)) + { + origin = spawnOrigin; + angles = spawnAngles; + foundValidSpawn = true; + } + } + else if (!searchCT) + { + searchCT = true; + } + else + { + break; + } + } + return foundValidSpawn; +} + +/** + * Check whether a position is a valid spawn location. + * A spawn location is considered valid if it is in bounds and not stuck inside the ground. + * + * @param origin Origin vector. + * @return Whether the origin is a valid spawn location. + */ +stock bool IsSpawnValid(float origin[3]) +{ + Handle trace = TR_TraceHullFilterEx(origin, origin, PLAYER_MINS, PLAYER_MAXS, MASK_PLAYERSOLID, TraceEntityFilterPlayers); + if (!TR_StartSolid(trace) && !TR_AllSolid(trace) && TR_GetFraction(trace) == 1.0) + { + delete trace; + return true; + } + delete trace; + return false; +} + +/** + * Get an entity's origin, angles, its bounding box's center and the distance from the center to its bounding box's edges. + * + * @param entity Index of the entity. + * @param origin Entity's origin. + * @param center Center of the entity's bounding box. + * @param angles Entity's angles. + * @param distFromCenter The distance between the center of the entity's bounding box and its edges. + */ +stock void GetEntityPositions(int entity, float origin[3], float center[3], float angles[3], float distFromCenter[3]) +{ + int ent = entity; + float maxs[3], mins[3]; + GetEntPropVector(ent, Prop_Send, "m_vecOrigin", origin); + // Take parent entities into account. + while (GetEntPropEnt(ent, Prop_Send, "moveparent") != -1) + { + ent = GetEntPropEnt(ent, Prop_Send, "moveparent"); + float tempOrigin[3]; + GetEntPropVector(ent, Prop_Send, "m_vecOrigin", tempOrigin); + for (int i = 0; i < 3; i++) + { + origin[i] += tempOrigin[i]; + } + } + + GetEntPropVector(ent, Prop_Data, "m_angRotation", angles); + + GetEntPropVector(ent, Prop_Send, "m_vecMaxs", maxs); + GetEntPropVector(ent, Prop_Send, "m_vecMins", mins); + for (int i = 0; i < 3; i++) + { + center[i] = origin[i] + (maxs[i] + mins[i]) / 2; + distFromCenter[i] = (maxs[i] - mins[i]) / 2; + } +} + +/** + * Find a valid position around a timer. + * + * @param entity Index of the timer entity. + * @param originDest Result origin if a valid position is found. + * @param anglesDest Result angles if a valid position is found. + * @return Whether a valid position is found. + */ +stock bool FindValidPositionAroundTimerEntity(int entity, float originDest[3], float anglesDest[3], bool isButton) +{ + float origin[3], center[3], angles[3], distFromCenter[3]; + GetEntityPositions(entity, origin, center, angles, distFromCenter); + float extraOffset[3]; + if (isButton) // Test several positions within button press range. + { + extraOffset[0] = 32.0; + extraOffset[1] = 32.0; + extraOffset[2] = 32.0; + } + else // Test positions at the inner surface of the zone. + { + extraOffset[0] = -(PLAYER_MAXS[0] - PLAYER_MINS[0]) - 1.03125; + extraOffset[1] = -(PLAYER_MAXS[1] - PLAYER_MINS[1]) - 1.03125; + extraOffset[2] = -(PLAYER_MAXS[2] - PLAYER_MINS[2]) - 1.03125; + } + if (FindValidPositionAroundCenter(center, distFromCenter, extraOffset, originDest, anglesDest)) + { + return true; + } + // Test the positions right next to the timer button/zones if the tests above fail. + // This can fail when the timer has a cover brush over it. + extraOffset[0] = 0.03125; + extraOffset[1] = 0.03125; + extraOffset[2] = 0.03125; + return FindValidPositionAroundCenter(center, distFromCenter, extraOffset, originDest, anglesDest); +} + +static bool FindValidPositionAroundCenter(float center[3], float distFromCenter[3], float extraOffset[3], float originDest[3], float anglesDest[3]) +{ + float testOrigin[3]; + int x, y; + + for (int i = 0; i < 3; i++) + { + // The search starts from the center then outwards to opposite directions. + x = i == 2 ? -1 : i; + for (int j = 0; j < 3; j++) + { + y = j == 2 ? -1 : j; + for (int z = -1; z <= 1; z++) + { + testOrigin = center; + testOrigin[0] = testOrigin[0] + (distFromCenter[0] + extraOffset[0]) * x + (PLAYER_MAXS[0] - PLAYER_MINS[0]) * x * 0.5; + testOrigin[1] = testOrigin[1] + (distFromCenter[1] + extraOffset[1]) * y + (PLAYER_MAXS[1] - PLAYER_MINS[1]) * y * 0.5; + testOrigin[2] = testOrigin[2] + (distFromCenter[2] + extraOffset[2]) * z + (PLAYER_MAXS[2] - PLAYER_MINS[2]) * z; + + // Check if there's a line of sight towards the zone as well. + if (IsSpawnValid(testOrigin) && CanSeeBox(testOrigin, center, distFromCenter)) + { + originDest = testOrigin; + // Always look towards the center. + float offsetVector[3]; + offsetVector[0] = -(distFromCenter[0] + extraOffset[0]) * x; + offsetVector[1] = -(distFromCenter[1] + extraOffset[1]) * y; + offsetVector[2] = -(distFromCenter[2] + extraOffset[2]) * z; + GetVectorAngles(offsetVector, anglesDest); + anglesDest[2] = 0.0; // Roll should always be 0.0 + return true; + } + } + } + } + return false; +} + +static bool CanSeeBox(float origin[3], float center[3], float distFromCenter[3]) +{ + float traceOrigin[3], traceDest[3], mins[3], maxs[3]; + + CopyVector(origin, traceOrigin); + + + SubtractVectors(center, distFromCenter, mins); + AddVectors(center, distFromCenter, maxs); + + for (int i = 0; i < 3; i++) + { + mins[i] += 0.03125; + maxs[i] -= 0.03125; + traceDest[i] = FloatClamp(traceOrigin[i], mins[i], maxs[i]); + } + int mask = (MASK_NPCSOLID_BRUSHONLY | MASK_OPAQUE_AND_NPCS) & ~CONTENTS_OPAQUE; + Handle trace = TR_TraceRayFilterEx(traceOrigin, traceDest, mask, RayType_EndPoint, TraceEntityFilterPlayers); + if (TR_DidHit(trace)) + { + float end[3]; + TR_GetEndPosition(end, trace); + for (int i = 0; i < 3; i++) + { + if (end[i] != traceDest[i]) + { + delete trace; + return false; + } + } + } + delete trace; + return true; +} + +/** + * Gets entity index from the address to an entity. + * + * @param pEntity Entity address. + * @return Entity index. + * @error Couldn't find offset for m_angRotation, m_vecViewOffset, couldn't confirm offset of m_RefEHandle. + */ +stock int GOKZGetEntityFromAddress(Address pEntity) +{ + static int offs_RefEHandle; + if (offs_RefEHandle) + { + return EntRefToEntIndex(LoadFromAddress(pEntity + view_as<Address>(offs_RefEHandle), NumberType_Int32) | (1 << 31)); + } + + // if we don't have it already, attempt to lookup offset based on SDK information + // CWorld is derived from CBaseEntity so it should have both offsets + int offs_angRotation = FindDataMapInfo(0, "m_angRotation"), offs_vecViewOffset = FindDataMapInfo(0, "m_vecViewOffset"); + if (offs_angRotation == -1) + { + SetFailState("Could not find offset for ((CBaseEntity) CWorld)::m_angRotation"); + } + else if (offs_vecViewOffset == -1) + { + SetFailState("Could not find offset for ((CBaseEntity) CWorld)::m_vecViewOffset"); + } + else if ((offs_angRotation + 0x0C) != (offs_vecViewOffset - 0x04)) + { + char game[32]; + GetGameFolderName(game, sizeof(game)); + SetFailState("Could not confirm offset of CBaseEntity::m_RefEHandle (incorrect assumption for game '%s'?)", game); + } + + // offset seems right, cache it for the next call + offs_RefEHandle = offs_angRotation + 0x0C; + return GOKZGetEntityFromAddress(pEntity); +} + +/** + * Gets client index from CGameMovement class. + * + * @param addr Address of CGameMovement class. + * @param offsetCGameMovement_player Offset of CGameMovement::player. + * @return Client index. + * @error Couldn't find offset for m_angRotation, m_vecViewOffset, couldn't confirm offset of m_RefEHandle. + */ +stock int GOKZGetClientFromGameMovementAddress(Address addr, int offsetCGameMovement_player) +{ + Address playerAddr = view_as<Address>(LoadFromAddress(view_as<Address>(view_as<int>(addr) + offsetCGameMovement_player), NumberType_Int32)); + return GOKZGetEntityFromAddress(playerAddr); +} + +/** + * Gets the nearest point in the oriented bounding box of an entity to a point. + * + * @param entity Entity index. + * @param origin Point's origin. + * @param result Result point. + */ +stock void CalcNearestPoint(int entity, float origin[3], float result[3]) +{ + float entOrigin[3], entMins[3], entMaxs[3], trueMins[3], trueMaxs[3]; + GetEntPropVector(entity, Prop_Send, "m_vecOrigin", entOrigin); + GetEntPropVector(entity, Prop_Send, "m_vecMaxs", entMaxs); + GetEntPropVector(entity, Prop_Send, "m_vecMins", entMins); + + AddVectors(entOrigin, entMins, trueMins); + AddVectors(entOrigin, entMaxs, trueMaxs); + + for (int i = 0; i < 3; i++) + { + result[i] = FloatClamp(origin[i], trueMins[i], trueMaxs[i]); + } +} + +/** + * Get the shortest distance from P to the (infinite) line through vLineA and vLineB. + * + * @param P Point's origin. + * @param vLineA Origin of the first point of the line. + * @param vLineB Origin of the first point of the line. + * @return The shortest distance from the point to the line. + */ +stock float CalcDistanceToLine(float P[3], float vLineA[3], float vLineB[3]) +{ + float vClosest[3]; + float vDir[3]; + float t; + float delta[3]; + SubtractVectors(vLineB, vLineA, vDir); + float div = GetVectorDotProduct(vDir, vDir); + if (div < EPSILON) + { + t = 0.0; + } + else + { + t = (GetVectorDotProduct(vDir, P) - GetVectorDotProduct(vDir, vLineA)) / div; + } + for (int i = 0; i < 3; i++) + { + vClosest[i] = vLineA[i] + vDir[i]*t; + } + SubtractVectors(P, vClosest, delta); + return GetVectorLength(delta); +} + +/** + * Gets the ideal amount of time the text should be held for HUD messages. + * + * The message buffer is only 16 slots long, and it is shared between 6 channels maximum. + * Assuming a message is sent every game frame, each channel used should be only taking around 2.5 slots on average. + * This also assumes all channels are used equally (so no other plugin taking all the channel buffer for itself). + * We want to use as much of the message buffer as possible to take into account latency variances. + * + * @param interval HUD message update interval, in tick intervals. + * @return How long the text should be held for. + */ +stock float GetTextHoldTime(int interval) +{ + return 3 * interval * GetTickInterval(); +} diff --git a/sourcemod/scripting/include/gokz/anticheat.inc b/sourcemod/scripting/include/gokz/anticheat.inc new file mode 100644 index 0000000..7fa5409 --- /dev/null +++ b/sourcemod/scripting/include/gokz/anticheat.inc @@ -0,0 +1,168 @@ +/* + gokz-anticheat Plugin Include + + Website: https://bitbucket.org/kztimerglobalteam/gokz +*/ + +#if defined _gokz_anticheat_included_ +#endinput +#endif +#define _gokz_anticheat_included_ + + + +// =====[ ENUMS ]===== + +enum ACReason: +{ + ACReason_BhopMacro = 0, + ACReason_BhopHack, + ACREASON_COUNT +}; + + + +// =====[ CONSTANTS ]===== + +#define AC_MAX_BUTTON_SAMPLES 40 +#define AC_MAX_BHOP_GROUND_TICKS 8 +#define AC_MAX_BHOP_SAMPLES 30 +#define AC_BINDEXCEPTION_SAMPLES 5 +#define AC_LOG_PATH "logs/gokz-anticheat.log" + +stock char gC_ACReasons[ACREASON_COUNT][] = +{ + "BHop Macro", + "BHop Hack" +}; + + + +// =====[ FORWARDS ]===== + +/** + * Called when gokz-anticheat suspects a player of cheating. + * + * @param client Client index. + * @param reason Reason for suspicion. + * @param notes Additional reasoning, description etc. + * @param stats Data supporting the suspicion e.g. scroll pattern. + */ +forward void GOKZ_AC_OnPlayerSuspected(int client, ACReason reason, const char[] notes, const char[] stats); + + + +// =====[ NATIVES ]===== + +/** + * Gets the number of recent bhop samples available for a player. + * + * @param client Client index. + * @return Number of bhop samples available. + */ +native int GOKZ_AC_GetSampleSize(int client); + +/** + * Gets whether a player hit a perfect bhop for a number of + * recent bhops. Buffer must be large enough to fit the sample + * size. + * + * @param client Client index. + * @param buffer Buffer for perfect bhop booleans, with the first element being the most recent bhop. + * @param sampleSize Maximum recent bhop samples. + * @return Number of bhop samples. + */ +native int GOKZ_AC_GetHitPerf(int client, bool[] buffer, int sampleSize); + +/** + * Gets a player's number of perfect bhops out of a sample + * size of bhops. + * + * @param client Client index. + * @param sampleSize Maximum recent bhop samples to include in calculation. + * @return Player's number of perfect bhops. + */ +native int GOKZ_AC_GetPerfCount(int client, int sampleSize); + +/** + * Gets a player's ratio of perfect bhops to normal bhops. + * + * @param client Client index. + * @param sampleSize Maximum recent bhop samples to include in calculation. + * @return Player's ratio of perfect bhops to normal bhops. + */ +native float GOKZ_AC_GetPerfRatio(int client, int sampleSize); + +/** + * Gets a player's jump input counts for a number of recent + * bhops. Buffer must be large enough to fit the sample size. + * + * @param client Client index. + * @param buffer Buffer for jump input counts, with the first element being the most recent bhop. + * @param sampleSize Maximum recent bhop samples. + * @return Number of bhop samples. + */ +native int GOKZ_AC_GetJumpInputs(int client, int[] buffer, int sampleSize); + +/** + * Gets a player's average number of jump inputs for a number + * of recent bhops. + * + * @param client Client index. + * @param sampleSize Maximum recent bhop samples to include in calculation. + * @return Player's average number of jump inputs. + */ +native float GOKZ_AC_GetAverageJumpInputs(int client, int sampleSize); + +/** + * Gets a player's jump input counts prior to a number of recent + * bhops. Buffer must be large enough to fit the sample size. + * Includes the jump input that resulted in the jump. + * + * @param client Client index. + * @param buffer Buffer for jump input counts, with the first element being the most recent bhop. + * @param sampleSize Maximum recent bhop samples. + * @return Number of bhop samples. + */ +native int GOKZ_AC_GetPreJumpInputs(int client, int[] buffer, int sampleSize); + +/** + * Gets a player's jump input counts after a number of recent + * bhops. Buffer must be large enough to fit the sample size. + * Excludes the jump input that resulted in the jump. + * + * @param client Client index. + * @param buffer Buffer for jump input counts, with the first element being the most recent bhop. + * @param sampleSize Maximum recent bhop samples. + * @return Number of bhop samples. + */ +native int GOKZ_AC_GetPostJumpInputs(int client, int[] buffer, int sampleSize); + + + +// =====[ DEPENDENCY ]===== + +public SharedPlugin __pl_gokz_anticheat = +{ + name = "gokz-anticheat", + file = "gokz-anticheat.smx", + #if defined REQUIRE_PLUGIN + required = 1, + #else + required = 0, + #endif +}; + +#if !defined REQUIRE_PLUGIN +public void __pl_gokz_anticheat_SetNTVOptional() +{ + MarkNativeAsOptional("GOKZ_AC_GetSampleSize"); + MarkNativeAsOptional("GOKZ_AC_GetHitPerf"); + MarkNativeAsOptional("GOKZ_AC_GetPerfCount"); + MarkNativeAsOptional("GOKZ_AC_GetPerfRatio"); + MarkNativeAsOptional("GOKZ_AC_GetJumpInputs"); + MarkNativeAsOptional("GOKZ_AC_GetAverageJumpInputs"); + MarkNativeAsOptional("GOKZ_AC_GetPreJumpInputs"); + MarkNativeAsOptional("GOKZ_AC_GetPostJumpInputs"); +} +#endif
\ No newline at end of file diff --git a/sourcemod/scripting/include/gokz/chat.inc b/sourcemod/scripting/include/gokz/chat.inc new file mode 100644 index 0000000..0264a57 --- /dev/null +++ b/sourcemod/scripting/include/gokz/chat.inc @@ -0,0 +1,45 @@ +/* + gokz-chat Plugin Include + + Website: https://bitbucket.org/kztimerglobalteam/gokz +*/ + +#if defined _gokz_chat_included_ +#endinput +#endif +#define _gokz_chat_included_ + + + +// =====[ NATIVES ]===== + +/** + * Gets whether a mode is loaded. + * + * @param client Client. + * @param tag Tag to prepend to the player name in chat. + * @param color Color to use for the tag. + */ +native void GOKZ_CH_SetChatTag(int client, const char[] tag, const char[] color); + + + +// =====[ DEPENDENCY ]===== + +public SharedPlugin __pl_gokz_chat = +{ + name = "gokz-chat", + file = "gokz-chat.smx", + #if defined REQUIRE_PLUGIN + required = 1, + #else + required = 0, + #endif +}; + +#if !defined REQUIRE_PLUGIN +public void __pl_gokz_chat_SetNTVOptional() +{ + MarkNativeAsOptional("GOKZ_CH_SetChatTag"); +} +#endif
\ No newline at end of file diff --git a/sourcemod/scripting/include/gokz/core.inc b/sourcemod/scripting/include/gokz/core.inc new file mode 100644 index 0000000..fb450d1 --- /dev/null +++ b/sourcemod/scripting/include/gokz/core.inc @@ -0,0 +1,1920 @@ +/* + gokz-core Plugin Include + + Website: https://bitbucket.org/kztimerglobalteam/gokz +*/ + +#if defined _gokz_core_included_ +#endinput +#endif +#define _gokz_core_included_ + +#include <cstrike> +#include <regex> +#include <topmenus> + +#include <gokz> + + + +// =====[ ENUMS ]===== + +enum +{ + TimeType_Nub = 0, + TimeType_Pro, + TIMETYPE_COUNT +}; + +enum +{ + MapPrefix_Other = 0, + MapPrefix_KZPro, + MAPPREFIX_COUNT +}; + +enum StartPositionType: +{ + StartPositionType_Spawn, + StartPositionType_Custom, + StartPositionType_MapButton, + StartPositionType_MapStart, + STARTPOSITIONTYPE_COUNT +}; + +enum CourseTimerType: +{ + CourseTimerType_None, + CourseTimerType_Default, + CourseTimerType_Button, + CourseTimerType_ZoneLegacy, + CourseTimerType_ZoneNew, + CourseTimerType_COUNT +}; + +enum OptionProp: +{ + OptionProp_Cookie = 0, + OptionProp_Type, + OptionProp_DefaultValue, + OptionProp_MinValue, + OptionProp_MaxValue, + OPTIONPROP_COUNT +}; + +enum OptionType: +{ + OptionType_Int = 0, + OptionType_Float +}; + +enum Option: +{ + OPTION_INVALID = -1, + Option_Mode, + Option_Style, + Option_CheckpointMessages, + Option_CheckpointSounds, + Option_TeleportSounds, + Option_ErrorSounds, + Option_VirtualButtonIndicators, + Option_TimerButtonZoneType, + Option_ButtonThroughPlayers, + Option_Safeguard, + OPTION_COUNT +}; + +enum +{ + Mode_Vanilla = 0, + Mode_SimpleKZ, + Mode_KZTimer, + MODE_COUNT +}; + +enum +{ + Style_Normal = 0, + STYLE_COUNT +}; + +enum +{ + CheckpointMessages_Disabled = 0, + CheckpointMessages_Enabled, + CHECKPOINTMESSAGES_COUNT +}; + +enum +{ + CheckpointSounds_Disabled = 0, + CheckpointSounds_Enabled, + CHECKPOINTSOUNDS_COUNT +}; + +enum +{ + TeleportSounds_Disabled = 0, + TeleportSounds_Enabled, + TELEPORTSOUNDS_COUNT +}; + +enum +{ + ErrorSounds_Disabled = 0, + ErrorSounds_Enabled, + ERRORSOUNDS_COUNT +}; + +enum +{ + VirtualButtonIndicators_Disabled = 0, + VirtualButtonIndicators_Enabled, + VIRTUALBUTTONINDICATORS_COUNT +}; + +enum +{ + TimerButtonZoneType_BothButtons = 0, + TimerButtonZoneType_EndZone, + TimerButtonZoneType_BothZones, + TIMERBUTTONZONETYPE_COUNT +}; + +enum +{ + ButtonThroughPlayers_Disabled = 0, + ButtonThroughPlayers_Enabled, + BUTTONTHROUGHPLAYERS_COUNT +}; + +enum +{ + Safeguard_Disabled = 0, + Safeguard_EnabledNUB, + Safeguard_EnabledPRO, + SAFEGUARD_COUNT +}; + +enum +{ + ModeCVar_Accelerate = 0, + ModeCVar_AccelerateUseWeaponSpeed, + ModeCVar_AirAccelerate, + ModeCVar_AirMaxWishSpeed, + ModeCVar_EnableBunnyhopping, + ModeCVar_Friction, + ModeCVar_Gravity, + ModeCVar_JumpImpulse, + ModeCVar_LadderScaleSpeed, + ModeCVar_LedgeMantleHelper, + ModeCVar_MaxSpeed, + ModeCVar_MaxVelocity, + ModeCVar_StaminaJumpCost, + ModeCVar_StaminaLandCost, + ModeCVar_StaminaMax, + ModeCVar_StaminaRecoveryRate, + ModeCVar_StandableNormal, + ModeCVar_TimeBetweenDucks, + ModeCVar_WalkableNormal, + ModeCVar_WaterAccelerate, + MoveCVar_WaterMoveSpeedMultiplier, + MoveCVar_WaterSwimMode, + MoveCVar_WeaponEncumbrancePerItem, + ModeCVar_WeaponEncumbranceScale, + MODECVAR_COUNT +}; + +// NOTE: gokz-core/map/entlump.sp +enum EntlumpTokenType +{ + EntlumpTokenType_OpenBrace, // { + EntlumpTokenType_CloseBrace, // } + EntlumpTokenType_Identifier, // everything that's inside quotations + EntlumpTokenType_Unknown, + EntlumpTokenType_EndOfStream +}; + +// NOTE: gokz-core/map/triggers.sp +// NOTE: corresponds to climb_teleport_type in kz_mapping_api.fgd +enum TeleportType +{ + TeleportType_Invalid = -1, + TeleportType_Normal, + TeleportType_MultiBhop, + TeleportType_SingleBhop, + TeleportType_SequentialBhop, + TELEPORTTYPE_COUNT +}; + +enum TriggerType +{ + TriggerType_Invalid = 0, + TriggerType_Teleport, + TriggerType_Antibhop +}; + + + +// =====[ CONSTANTS ]===== + +#define GOKZ_CHECKPOINT_VERSION 2 +#define GOKZ_MAX_CHECKPOINTS 2048 +#define GOKZ_MAX_COURSES 100 + +#define GOKZ_BHOP_NO_CHECKPOINT_TIME 0.15 +#define GOKZ_MULT_NO_CHECKPOINT_TIME 0.11 +#define GOKZ_LADDER_NO_CHECKPOINT_TIME 1.5 +#define GOKZ_PAUSE_COOLDOWN 1.0 +#define GOKZ_TIMER_START_NO_TELEPORT_TICKS 4 +#define GOKZ_TIMER_START_GROUND_TICKS 4 +#define GOKZ_TIMER_START_NOCLIP_TICKS 4 +#define GOKZ_JUMPSTATS_NOCLIP_RESET_TICKS 4 +#define GOKZ_TIMER_SOUND_COOLDOWN 0.15 +#define GOKZ_VIRTUAL_BUTTON_USE_DETECTION_TIME 2.0 +#define GOKZ_TURNBIND_COOLDOWN 0.3 + +#define GOKZ_MAPPING_API_VERSION_NONE 0 // the map doesn't have a mapping api version +#define GOKZ_MAPPING_API_VERSION 1 + +#define GOKZ_ANTI_BHOP_TRIGGER_DEFAULT_DELAY 0.2 +#define GOKZ_TELEPORT_TRIGGER_DEFAULT_TYPE TeleportType_Normal +#define GOKZ_TELEPORT_TRIGGER_DEFAULT_DELAY 0.0 +#define GOKZ_TELEPORT_TRIGGER_DEFAULT_USE_DEST_ANGLES true +#define GOKZ_TELEPORT_TRIGGER_DEFAULT_RESET_SPEED true +#define GOKZ_TELEPORT_TRIGGER_DEFAULT_RELATIVE_DESTINATION false +#define GOKZ_TELEPORT_TRIGGER_DEFAULT_REORIENT_PLAYER false +#define GOKZ_TELEPORT_TRIGGER_BHOP_MIN_DELAY 0.08 + +#define GOKZ_SOUND_CHECKPOINT "buttons/blip1.wav" +#define GOKZ_SOUND_TELEPORT "buttons/blip1.wav" +#define GOKZ_SOUND_TIMER_STOP "buttons/button18.wav" + +#define GOKZ_START_NAME "climb_start" +#define GOKZ_BONUS_START_NAME_REGEX "^climb_bonus(\\d+)_start$" +#define GOKZ_BONUS_END_NAME_REGEX "^climb_bonus(\\d+)_end$" + +#define GOKZ_START_BUTTON_NAME "climb_startbutton" +#define GOKZ_END_BUTTON_NAME "climb_endbutton" +#define GOKZ_BONUS_START_BUTTON_NAME_REGEX "^climb_bonus(\\d+)_startbutton$" +#define GOKZ_BONUS_END_BUTTON_NAME_REGEX "^climb_bonus(\\d+)_endbutton$" +#define GOKZ_ANTI_BHOP_TRIGGER_NAME "climb_anti_bhop" +#define GOKZ_ANTI_CP_TRIGGER_NAME "climb_anti_checkpoint" +#define GOKZ_ANTI_PAUSE_TRIGGER_NAME "climb_anti_pause" +#define GOKZ_ANTI_JUMPSTAT_TRIGGER_NAME "climb_anti_jumpstat" +#define GOKZ_BHOP_RESET_TRIGGER_NAME "climb_bhop_reset" +#define GOKZ_TELEPORT_TRIGGER_NAME "climb_teleport" + +#define GOKZ_START_ZONE_NAME "climb_startzone" +#define GOKZ_END_ZONE_NAME "climb_endzone" +#define GOKZ_BONUS_START_ZONE_NAME_REGEX "^climb_bonus(\\d+)_startzone$" +#define GOKZ_BONUS_END_ZONE_NAME_REGEX "^climb_bonus(\\d+)_endzone$" + +#define GOKZ_CFG_SERVER "sourcemod/gokz/gokz.cfg" +#define GOKZ_CFG_OPTIONS "cfg/sourcemod/gokz/options.cfg" +#define GOKZ_CFG_OPTIONS_SORTING "cfg/sourcemod/gokz/options_menu_sorting.cfg" +#define GOKZ_CFG_OPTIONS_ROOT "Options" +#define GOKZ_CFG_OPTIONS_DESCRIPTION "description" +#define GOKZ_CFG_OPTIONS_DEFAULT "default" + +#define GOKZ_OPTION_MAX_NAME_LENGTH 30 +#define GOKZ_OPTION_MAX_DESC_LENGTH 255 +#define GENERAL_OPTION_CATEGORY "General" + +// TODO: where do i put the defines? +#define GOKZ_BSP_HEADER_IDENTIFIER (('P' << 24) | ('S' << 16) | ('B' << 8) | 'V') +#define GOKZ_ENTLUMP_MAX_KEY 32 +#define GOKZ_ENTLUMP_MAX_VALUE 1024 + +#define GOKZ_MAX_MAPTRIGGERS_ERROR_LENGTH 256 + +#define CHAR_ESCAPE view_as<char>(27) + +#define GOKZ_SAFEGUARD_RESTART_MIN_DELAY 0.6 +#define GOKZ_SAFEGUARD_RESTART_MAX_DELAY 5.0 + +// Prevents the player from retouching a trigger too often. +#define GOKZ_MAX_RETOUCH_TRIGGER_COUNT 4 + +stock char gC_TimeTypeNames[TIMETYPE_COUNT][] = +{ + "NUB", + "PRO" +}; + +stock char gC_ModeNames[MODE_COUNT][] = +{ + "Vanilla", + "SimpleKZ", + "KZTimer" +}; + +stock char gC_ModeNamesShort[MODE_COUNT][] = +{ + "VNL", + "SKZ", + "KZT" +}; + +stock char gC_ModeKeys[MODE_COUNT][] = +{ + "vanilla", + "simplekz", + "kztimer" +}; + +stock float gF_ModeVirtualButtonRanges[MODE_COUNT] = +{ + 0.0, + 32.0, + 70.0 +}; + +stock char gC_ModeStartSounds[MODE_COUNT][] = +{ + "common/wpn_select.wav", + "buttons/button9.wav", + "buttons/button3.wav" +}; + +stock char gC_ModeEndSounds[MODE_COUNT][] = +{ + "common/wpn_select.wav", + "buttons/bell1.wav", + "buttons/button3.wav" +}; + +stock char gC_ModeFalseEndSounds[MODE_COUNT][] = +{ + "common/wpn_select.wav", + "buttons/button11.wav", + "buttons/button2.wav" +}; + +stock char gC_StyleNames[STYLE_COUNT][] = +{ + "Normal" +}; + +stock char gC_StyleNamesShort[STYLE_COUNT][] = +{ + "NRM" +}; + +stock char gC_CoreOptionNames[OPTION_COUNT][] = +{ + "GOKZ - Mode", + "GOKZ - Style", + "GOKZ - Checkpoint Messages", + "GOKZ - Checkpoint Sounds", + "GOKZ - Teleport Sounds", + "GOKZ - Error Sounds", + "GOKZ - VB Indicators", + "GOKZ - Timer Button Zone Type", + "GOKZ - Button Through Players", + "GOKZ - Safeguard" +}; + +stock char gC_CoreOptionDescriptions[OPTION_COUNT][] = +{ + "Movement Mode - 0 = Vanilla, 1 = SimpleKZ, 2 = KZTimer", + "Movement Style - 0 = Normal", + "Checkpoint Messages - 0 = Disabled, 1 = Enabled", + "Checkpoint Sounds - 0 = Disabled, 1 = Enabled", + "Teleport Sounds - 0 = Disabled, 1 = Enabled", + "Error Sounds - 0 = Disabled, 1 = Enabled", + "Virtual Button Indicators - 0 = Disabled, 1 = Enabled", + "Timer Button Zone Type - 0 = Both buttons, 1 = Only end zone, 2 = Both zones", + "Button Through Players - 0 = Disabled, 1 = Enabled", + "Safeguard - 0 = Disabled, 1 = Enabled (NUB), 2 = Enabled (PRO)" +}; + +stock char gC_CoreOptionPhrases[OPTION_COUNT][] = +{ + "Options Menu - Mode", + "Options Menu - Style", + "Options Menu - Checkpoint Messages", + "Options Menu - Checkpoint Sounds", + "Options Menu - Teleport Sounds", + "Options Menu - Error Sounds", + "Options Menu - Virtual Button Indicators", + "Options Menu - Timer Button Zone Type", + "Options Menu - Button Through Players", + "Options Menu - Safeguard" +}; + +stock char gC_TimerButtonZoneTypePhrases[TIMERBUTTONZONETYPE_COUNT][] = +{ + "Timer Button Zone Type - Both Buttons", + "Timer Button Zone Type - Only End Zone", + "Timer Button Zone Type - Both Zones" +}; + +stock char gC_SafeGuardPhrases[SAFEGUARD_COUNT][] = +{ + "Options Menu - Disabled", + "Safeguard - Enabled NUB", + "Safeguard - Enabled PRO" +} + +stock int gI_CoreOptionCounts[OPTION_COUNT] = +{ + MODE_COUNT, + STYLE_COUNT, + CHECKPOINTMESSAGES_COUNT, + CHECKPOINTSOUNDS_COUNT, + TELEPORTSOUNDS_COUNT, + ERRORSOUNDS_COUNT, + VIRTUALBUTTONINDICATORS_COUNT, + TIMERBUTTONZONETYPE_COUNT, + BUTTONTHROUGHPLAYERS_COUNT, + SAFEGUARD_COUNT +}; + +stock int gI_CoreOptionDefaults[OPTION_COUNT] = +{ + Mode_KZTimer, + Style_Normal, + CheckpointMessages_Disabled, + CheckpointSounds_Enabled, + TeleportSounds_Disabled, + ErrorSounds_Enabled, + VirtualButtonIndicators_Disabled, + TimerButtonZoneType_BothButtons, + ButtonThroughPlayers_Enabled, + Safeguard_Disabled +}; + +stock char gC_ModeCVars[MODECVAR_COUNT][] = +{ + "sv_accelerate", + "sv_accelerate_use_weapon_speed", + "sv_airaccelerate", + "sv_air_max_wishspeed", + "sv_enablebunnyhopping", + "sv_friction", + "sv_gravity", + "sv_jump_impulse", + "sv_ladder_scale_speed", + "sv_ledge_mantle_helper", + "sv_maxspeed", + "sv_maxvelocity", + "sv_staminajumpcost", + "sv_staminalandcost", + "sv_staminamax", + "sv_staminarecoveryrate", + "sv_standable_normal", + "sv_timebetweenducks", + "sv_walkable_normal", + "sv_wateraccelerate", + "sv_water_movespeed_multiplier", + "sv_water_swim_mode", + "sv_weapon_encumbrance_per_item", + "sv_weapon_encumbrance_scale" +}; + + +// =====[ STRUCTS ]===== + +enum struct Checkpoint +{ + float origin[3]; + float angles[3]; + float ladderNormal[3]; + bool onLadder; + int groundEnt; + + void Create(int client) + { + Movement_GetOrigin(client, this.origin); + Movement_GetEyeAngles(client, this.angles); + GetEntPropVector(client, Prop_Send, "m_vecLadderNormal", this.ladderNormal); + this.onLadder = Movement_GetMovetype(client) == MOVETYPE_LADDER; + this.groundEnt = GetEntPropEnt(client, Prop_Data, "m_hGroundEntity"); + } +} + +enum struct UndoTeleportData +{ + float tempOrigin[3]; + float tempAngles[3]; + float origin[3]; + float angles[3]; + // Undo TP properties + bool lastTeleportOnGround; + bool lastTeleportInBhopTrigger; + bool lastTeleportInAntiCpTrigger; + + void Init(int client, bool lastTeleportInBhopTrigger, bool lastTeleportOnGround, bool lastTeleportInAntiCpTrigger) + { + Movement_GetOrigin(client, this.tempOrigin); + Movement_GetEyeAngles(client, this.tempAngles); + this.lastTeleportInBhopTrigger = lastTeleportInBhopTrigger; + this.lastTeleportOnGround = lastTeleportOnGround; + this.lastTeleportInAntiCpTrigger = lastTeleportInAntiCpTrigger; + } + + void Update() + { + this.origin = this.tempOrigin; + this.angles = this.tempAngles; + } +} + + +// NOTE: gokz-core/map/entlump.sp +enum struct EntlumpToken +{ + EntlumpTokenType type; + char string[GOKZ_ENTLUMP_MAX_VALUE]; +} + +// NOTE: gokz-core/map/triggers.sp +enum struct AntiBhopTrigger +{ + int entRef; + int hammerID; + float time; +} + +enum struct TeleportTrigger +{ + int hammerID; + TeleportType type; + float delay; + char tpDestination[256]; + bool useDestAngles; + bool resetSpeed; + bool relativeDestination; + bool reorientPlayer; +} + +enum struct TouchedTrigger +{ + TriggerType triggerType; + int entRef; // entref of one of the TeleportTriggers + int startTouchTick; // tick where the player touched the trigger + int groundTouchTick; // tick where the player touched the ground +} + +// Legacy triggers that activate timer buttons. +enum struct TimerButtonTrigger +{ + int hammerID; + int course; + bool isStartTimer; +} + +// =====[ FORWARDS ]===== + +/** + * Called when a player's options values are loaded from clientprefs. + * + * @param client Client index. + */ +forward void GOKZ_OnOptionsLoaded(int client); + +/** + * Called when a player's option's value is changed. + * Only called if client is in game. + * + * @param client Client index. + * @param option Option name. + * @param newValue New value of the option. + */ +forward void GOKZ_OnOptionChanged(int client, const char[] option, any newValue); + +/** + * Called when a player starts their timer. + * + * @param client Client index. + * @param course Course number. + * @return Plugin_Handled or Plugin_Stop to block, Plugin_Continue to proceed. + */ +forward Action GOKZ_OnTimerStart(int client, int course); + +/** + * Called when a player has started their timer. + * + * @param client Client index. + * @param course Course number. + */ +forward void GOKZ_OnTimerStart_Post(int client, int course); + +/** + * Called when a player ends their timer. + * + * @param client Client index. + * @param course Course number. + * @param time Player's end time. + * @param teleportsUsed Number of teleports used by player. + * @return Plugin_Handled or Plugin_Stop to block, Plugin_Continue to proceed. + */ +forward Action GOKZ_OnTimerEnd(int client, int course, float time, int teleportsUsed); + +/** + * Called when a player has ended their timer. + * + * @param client Client index. + * @param course Course number. + * @param time Player's end time. + * @param teleportsUsed Number of teleports used by player. + */ +forward void GOKZ_OnTimerEnd_Post(int client, int course, float time, int teleportsUsed); + +/** + * Called when the end timer message is printed to chat. + * + * @param client Client index. + * @param course Course number. + * @param time Player's end time. + * @param teleportsUsed Number of teleports used by player. + * @return Plugin_Handled or Plugin_Stop to block, Plugin_Continue to proceed. + */ +forward Action GOKZ_OnTimerEndMessage(int client, int course, float time, int teleportsUsed); + +/** + * Called when a player's timer has been forcefully stopped. + * + * @param client Client index. + */ +forward void GOKZ_OnTimerStopped(int client); + +/** + * Called when a player pauses. + * + * @param client Client index. + * @return Plugin_Handled or Plugin_Stop to block, Plugin_Continue to proceed. + */ +forward Action GOKZ_OnPause(int client); + +/** + * Called when a player has paused. + * + * @param client Client index. + */ +forward void GOKZ_OnPause_Post(int client); + +/** + * Called when a player resumes. + * + * @param client Client index. + * @return Plugin_Handled or Plugin_Stop to block, Plugin_Continue to proceed. + */ +forward Action GOKZ_OnResume(int client); + +/** + * Called when a player has resumed. + * + * @param client Client index. + */ +forward void GOKZ_OnResume_Post(int client); + +/** + * Called when a player makes a checkpoint. + * + * @param client Client index. + * @return Plugin_Handled or Plugin_Stop to block, Plugin_Continue to proceed. + */ +forward Action GOKZ_OnMakeCheckpoint(int client); + +/** + * Called when a player has made a checkpoint. + * + * @param client Client index. + */ +forward void GOKZ_OnMakeCheckpoint_Post(int client); + +/** + * Called when a player teleports to their checkpoint. + * + * @param client Client index. + * @return Plugin_Handled or Plugin_Stop to block, Plugin_Continue to proceed. + */ +forward Action GOKZ_OnTeleportToCheckpoint(int client); + +/** + * Called when a player has teleported to their checkpoint. + * + * @param client Client index. + */ +forward void GOKZ_OnTeleportToCheckpoint_Post(int client); + +/** + * Called when a player goes to a previous checkpoint. + * + * @param client Client index. + * @return Plugin_Handled or Plugin_Stop to block, Plugin_Continue to proceed. + */ +forward Action GOKZ_OnPrevCheckpoint(int client); + +/** + * Called when a player has gone to a previous checkpoint. + * + * @param client Client index. + */ +forward void GOKZ_OnPrevCheckpoint_Post(int client); + +/** + * Called when a player goes to a next checkpoint. + * + * @param client Client index. + * @return Plugin_Handled or Plugin_Stop to block, Plugin_Continue to proceed. + */ +forward Action GOKZ_OnNextCheckpoint(int client); + +/** + * Called when a player has gone to a next checkpoint. + * + * @param client Client index. + */ +forward void GOKZ_OnNextCheckpoint_Post(int client); + +/** + * Called when a player teleports to start. + * + * @param client Client index. + * @param course Course index. + * @return Plugin_Handled or Plugin_Stop to block, Plugin_Continue to proceed. + */ +forward Action GOKZ_OnTeleportToStart(int client, int course); + +/** + * Called when a player has teleported to start. + * + * @param client Client index. + * @param course Course index. + */ +forward void GOKZ_OnTeleportToStart_Post(int client, int course); + +/** + * Called when a player teleports to end. + * + * @param client Client index. + * @param course Course index. + * @return Plugin_Handled or Plugin_Stop to block, Plugin_Continue to proceed. + */ +forward Action GOKZ_OnTeleportToEnd(int client, int course); + +/** + * Called when a player has teleported to end. + * + * @param client Client index. + * @param course Course index. + */ +forward void GOKZ_OnTeleportToEnd_Post(int client, int course); + +/** + * Called when a player undoes a teleport. + * + * @param client Client index. + * @return Plugin_Handled or Plugin_Stop to block, Plugin_Continue to proceed. + */ +forward Action GOKZ_OnUndoTeleport(int client); + +/** + * Called when a player has undone a teleport. + * + * @param client Client index. + */ +forward void GOKZ_OnUndoTeleport_Post(int client); + +/** + * Called when a player has performed a counted teleport (teleport count went up) + * i.e. a catch-all for teleport to checkpoint, teleport to start, undo teleport etc. + * + * @param client Client index. + */ +forward void GOKZ_OnCountedTeleport_Post(int client); + +/** + * Called when a player's start position is set. + * + * @param client Client index. + * @param type Start position type. + * @param origin Start position origin. + * @param angles Start position eye angles. + */ +forward void GOKZ_OnStartPositionSet_Post(int client, StartPositionType type, const float origin[3], const float angles[3]); + +/** + * Called when player's begins a jump that is deemed valid. + * A jump is deemed invalid if a player is teleported. + * + * @param client Client index. + * @param jumped Whether player jumped. + * @param ladderJump Whether it was a ladder jump. + * @param jumpbug Whether player performed a jumpbug. + */ +forward void GOKZ_OnJumpValidated(int client, bool jumped, bool ladderJump, bool jumpbug); + +/** + * Called when player's current jump is invalidated. + * A jump is deemed invalid if a player is teleported. + * + * @param client Client index. + */ +forward void GOKZ_OnJumpInvalidated(int client); + +/** + * Called when a player has been switched to a team. + * + * @param client Client index. + */ +forward void GOKZ_OnJoinTeam(int client, int team); + +/** + * Called the first time a player spawns in on a team. + * + * @param client Client index. + */ +forward void GOKZ_OnFirstSpawn(int client); + +/** + * Called when a mode has been loaded. + * + * @param mode Mode loaded. + */ +forward void GOKZ_OnModeLoaded(int mode); + +/** + * Called when a mode has been unloaded. + * + * @param mode Mode unloaded. + */ +forward void GOKZ_OnModeUnloaded(int mode); + +/** + * Called when a plugin other than gokz-core calls a native + * that may affect a player's timer or teleport count in + * their favour e.g. GOKZ_StartTimer, GOKZ_EndTimer, + * GOKZ_SetTime and GOKZ_SetTeleportCount. + * + * @param plugin Handle of the calling plugin. + * @param client Client index. + * @return Plugin_Handled or Plugin_Stop to block, Plugin_Continue to proceed. + */ +forward Action GOKZ_OnTimerNativeCalledExternally(Handle plugin, int client); + +/** + * Called when the options menu has been created and 3rd + * party plugins can grab the handle or add categories. + * + * @param topMenu Options top menu handle. + */ +forward void GOKZ_OnOptionsMenuCreated(TopMenu topMenu); + +/** + * Called when the options menu is ready to have items added. + * + * @param topMenu Options top menu handle. + */ +forward void GOKZ_OnOptionsMenuReady(TopMenu topMenu); + +/** + * Called when a course is registered. A course is registered if both the + * start and end of it (e.g. timer buttons) have been detected. + * + * @param course Course number. + */ +forward void GOKZ_OnCourseRegistered(int course); + +/** + * Called when a player's run becomes invalidated. + * An invalidated run doesn't necessarily stop the timer. + * + * @param client Client index. + */ +forward void GOKZ_OnRunInvalidated(int client); + +/** + * Called when a sound is emitted to the client via GOKZ Core. + * + * @param client Client index. + * @param sample Sound file name relative to the "sound" folder. + * @param volume Sound volume. + * @param description Optional description. + * @return Plugin_Continue to allow the sound to be played, Plugin_Stop to block it, + * Plugin_Changed when any parameter has been modified. + */ +forward Action GOKZ_OnEmitSoundToClient(int client, const char[] sample, float &volume, const char[] description); + + +// =====[ NATIVES ]===== + +/** + * Gets whether a mode is loaded. + * + * @param mode Mode. + * @return Whether mode is loaded. + */ +native bool GOKZ_GetModeLoaded(int mode); + +/** + * Gets the version number of a loaded mode. + * + * @param mode Mode. + * @return Version number of the mode, or -1 if not loaded. + */ +native int GOKZ_GetModeVersion(int mode); + +/** + * Sets whether a mode is loaded. To be used by mode plugins. + * + * @param mode Mode. + * @param loaded Whether mode is loaded. + * @param version Version number of the mode. + */ +native void GOKZ_SetModeLoaded(int mode, bool loaded, int version = -1); + +/** + * Gets the total number of loaded modes. + * + * @return Number of loaded modes. + */ +native int GOKZ_GetLoadedModeCount(); + +/** + * Sets the player's current mode. + * If the player's timer is running, it will be stopped. + * + * @param client Client index. + * @param mode Mode. + * @return Whether the operation was successful. + */ +native bool GOKZ_SetMode(int client, int mode); + +/** + * Gets the Handle to the options top menu. + * + * @return Handle to the options top menu, + * or null if not created yet. + */ +native TopMenu GOKZ_GetOptionsTopMenu(); + +/** + * Gets whether a course is registered. A course is registered if both the + * start and end of it (e.g. timer buttons) have been detected. + * + * @param course Course number. + * @return Whether course has been registered. + */ +native bool GOKZ_GetCourseRegistered(int course); + +/** + * Prints a message to a client's chat, formatting colours and optionally + * adding the chat prefix. If using the chat prefix, specify a colour at + * the beginning of the message e.g. "{default}Hello!". + * + * @param client Client index. + * @param addPrefix Whether to add the chat prefix. + * @param format Formatting rules. + * @param any Variable number of format parameters. + */ +native void GOKZ_PrintToChat(int client, bool addPrefix, const char[] format, any...); + +/** + * Prints a message to a client's chat, formatting colours and optionally + * adding the chat prefix. If using the chat prefix, specify a colour at + * the beginning of the message e.g. "{default}Hello!". Also prints the + * message to the server log. + * + * @param client Client index. + * @param addPrefix Whether to add the chat prefix. + * @param format Formatting rules. + * @param any Variable number of format parameters. + */ +native void GOKZ_PrintToChatAndLog(int client, bool addPrefix, const char[] format, any...); + +/** + * Starts a player's timer for a course on the current map. + * This can be blocked by OnTimerNativeCalledExternally(). + * + * @param client Client index. + * @param course Course number. + * @param allowMidair Whether player is allowed to start timer midair. + * @return Whether player's timer was started. + */ +native bool GOKZ_StartTimer(int client, int course, bool allowOffGround = false); + +/** + * Ends a player's timer for a course on the current map. + * This can be blocked by OnTimerNativeCalledExternally(). + * + * @param client Client index. + * @param course Course number. + * @return Whether player's timer was ended. + */ +native bool GOKZ_EndTimer(int client, int course); + +/** + * Forces a player's timer to stop. Intended for run invalidation. + * + * @param client Client index. + * @param playSound Whether to play the timer stop sound. + * @return Whether player's timer was stopped. + */ +native bool GOKZ_StopTimer(int client, bool playSound = true); + +/** + * Forces all players' timers to stop. Intended for run invalidation. + * + * @param playSound Whether to play the timer stop sound. + */ +native void GOKZ_StopTimerAll(bool playSound = true); + +/** + * Gets whether or not a player's timer is running i.e. isn't 'stopped'. + * + * @param client Client index. + * @return Whether player's timer is running. + */ +native bool GOKZ_GetTimerRunning(int client); + +/** + * Gets whether or not a player's timer is valid i.e the run is a valid run. + * + * @param client Client index. + * @return Whether player's timer is running. + */ +native bool GOKZ_GetValidTimer(int client); + +/** + * Gets the course a player is currently running. + * + * @param client Client index. + * @return Course number. + */ +native int GOKZ_GetCourse(int client); + +/** + * Set the player's current course. + * This can be blocked by OnTimerNativeCalledExternally(). + * + * @param client Client index. + * @param course Course number. + * @return Whether native was allowed to proceed. + */ +native bool GOKZ_SetCourse(int client, int course); + +/** + * Gets whether a player is paused. + * + * @param client Client index. + * @return Whether player is paused. + */ +native bool GOKZ_GetPaused(int client); + +/** + * Gets a player's current run time. + * + * @param client Client index. + * @return Player's current run time. + */ +native float GOKZ_GetTime(int client); + +/** + * Gets a player's current run time. + * This can be blocked by OnTimerNativeCalledExternally(). + * + * @param client Client index. + * @param time Run time to set to. + * @return Whether native was allowed to proceed. + */ +native bool GOKZ_SetTime(int client, float time); + +/** + * Mark a player's run as invalid without stopping the timer. + * + * @param client Client index. + */ +native void GOKZ_InvalidateRun(int client); + +/** + * Gets a player's current checkpoint count. + * + * @param client Client index. + * @return Player's current checkpoint count. + */ +native int GOKZ_GetCheckpointCount(int client); + +/** + * Sets a player's current checkpoint count. + * This can be blocked by OnTimerNativeCalledExternally(). + * + * @param client Client index. + * @param cpCount Checkpoint count to set to. + * @return Whether native was allowed to proceed. + */ +native int GOKZ_SetCheckpointCount(int client, int cpCount); + +/** + * Gets checkpoint data of a player. + * + * @param client Client index. + * @return Client's checkpoint data. + */ +native ArrayList GOKZ_GetCheckpointData(int client); + +/** + * Sets checkpoint data of a player. The checkpoint data is assumed to be ordered. + * This can be blocked by OnTimerNativeCalledExternally(). + * + * @param client Client index. + * @param checkpoints Checkpoint data. + * @param version Checkpoint version. + * @return Whether native was allowed to proceed and operation was successful. + */ +native bool GOKZ_SetCheckpointData(int client, ArrayList checkpoints, int version); + +/** + * Get undo teleport data of a player. + * + * @param client Client index. + * @return ArrayList of length 1 containing player's undo teleport data. + */ +native ArrayList GOKZ_GetUndoTeleportData(int client); + +/** + * Set undo teleport data of a player. + * This can be blocked by OnTimerNativeCalledExternally(). + * + * @param client Client index. + * @param undoTeleportDataArray ArrayList of length 1 containing player's undo teleport data. + * @param version Checkpoint version. + * @return Whether native was allowed to proceed and operation was successful. + */ +native bool GOKZ_SetUndoTeleportData(int client, ArrayList undoTeleportDataArray, int version); + +/** + * Gets a player's current teleport count. + * + * @param client Client index. + * @return Player's current teleport count. + */ +native int GOKZ_GetTeleportCount(int client); + +/** + * Sets a player's current teleport count. + * This can be blocked by OnTimerNativeCalledExternally(). + * + * @param client Client index. + * @param tpCount Teleport count to set to. + * @return Whether native was allowed to proceed. + */ +native bool GOKZ_SetTeleportCount(int client, int tpCount); + +/** + * Teleports a player to start, or respawns them. + * + * @param client Client index. + */ +native void GOKZ_TeleportToStart(int client); + +/** + * Teleports a player to the start zone/button of the specified course. + * + * @param client Client index. + * @param course Course index. + */ +native void GOKZ_TeleportToSearchStart(int client, int course); + +/** + * Gets the virtual button position the player currently has. + * + * @param client Client index. + * @param position Returns the client's virtual button position. + * @param isStart True to get the start button position, false for the end button. + * @return The course the button belongs to. + */ +native int GOKZ_GetVirtualButtonPosition(int client, float position[3], bool isStart); + +/** + * Sets the virtual button position the player currently has. + * + * @param client Client index. + * @param position The client's virtual button position. + * @param course The course the virtual button belongs to. + * @param isStart True to get the start button position, false for the end button. + */ +native void GOKZ_SetVirtualButtonPosition(int client, const float position[3], int course, bool isStart); + +/** + * Resets the player's virtual button. + * + * @param client Client index. + * @param isStart True to get the start button position, false for the end button. + */ +native void GOKZ_ResetVirtualButtonPosition(int client, bool isStart); + +/** + * Locks the virtual button position of a player. + * + * @param client Client index. + */ +native void GOKZ_LockVirtualButtons(int client); + +/** + * Gets the start position the player currently has. + * + * @param client Client index. + * @param position Returns the client's start position. + * @param angles Returns the client's start angles. + * @return Player's current start position type. + */ +native StartPositionType GOKZ_GetStartPosition(int client, float position[3], float angles[3]); + +/** + * Sets the start position the player currently has. + * + * @param client Client index. + * @param type The start position type. + * @param position The client's start position. + * @param angles The client's start angles. + */ +native void GOKZ_SetStartPosition(int client, StartPositionType type, const float position[3], const float angles[3]); + +/** + * Gets the type of start position the player currently has. + * The "Spawn" type means teleport to start will respawn the player. + * + * @param client Client index. + * @return Player's current start position type. + */ +native StartPositionType GOKZ_GetStartPositionType(int client); + +/** + * Set the start position of the player to the start of a course. + * + * @param client Client index. + * @param course Course index. + * + * @return False if the course start was not found. + */ +native bool GOKZ_SetStartPositionToMapStart(int client, int course); + +/** + * Teleports a player to end. + * + * @param client Client index. + * @param course Course index. + */ +native void GOKZ_TeleportToEnd(int client, int course); + +/** + * Set a new checkpoint at a player's current position. + * + * @param client Client index. + */ +native void GOKZ_MakeCheckpoint(int client); + +/** + * Gets whether a player can make a new checkpoint. + * @param client Client index. + * @return Whether player can set a checkpoint. + */ +native bool GOKZ_GetCanMakeCheckpoint(int client); + +/** + * Teleports a player to their last checkpoint. + * + * @param client Client index. + */ +native void GOKZ_TeleportToCheckpoint(int client); + +/** + * Gets whether a player can teleport to their checkpoint + * e.g. will return false if player has no checkpoints. + * + * @param client Client index. + * @return Whether player can teleport to checkpoint. + */ +native bool GOKZ_GetCanTeleportToCheckpoint(int client); + +/** + * Teleport a player back to a previous checkpoint. + * + * @param client Client index. + */ +native void GOKZ_PrevCheckpoint(int client); + +/** + * Gets whether a player can go to their previous checkpoint + * e.g. will return false if player has no checkpoints. + * + * @param client Client index. + * @return Whether player can go to previous checkpoint. + */ +native bool GOKZ_GetCanPrevCheckpoint(int client); + +/** + * Teleport a player to a more recent checkpoint. + * + * @param client Client index. + */ +native void GOKZ_NextCheckpoint(int client); + +/** + * Gets whether a player can go to their next checkpoint + * e.g. will return false if player has no checkpoints. + * + * @param client Client index. + * @return Whether player can go to next checkpoint. + */ +native bool GOKZ_GetCanNextCheckpoint(int client); + +/** + * Teleport a player to where they last teleported from. + * + * @param client Client index. + */ +native void GOKZ_UndoTeleport(int client); + +/** + * Gets whether a player can undo their teleport + * e.g. will return false if teleport was from midair. + * + * @param client Client index. + * @return Whether player can undo teleport. + */ +native bool GOKZ_GetCanUndoTeleport(int client); + +/** + * Pause a player's timer and freeze them. + * + * @param client Client index. + */ +native void GOKZ_Pause(int client); + +/** + * Gets whether a player can pause. Pausing is not allowed + * under some circumstance when the timer is running. + * + * @param client Client index. + */ +native bool GOKZ_GetCanPause(int client); + +/** + * Resumes a player's timer and unfreezes them. + * + * @param client Client index. + */ +native void GOKZ_Resume(int client); + +/** + * Gets whether a player can resume. Resuming is not allowed + * under some circumstance when the timer is running. + * + * @param client Client index. + */ +native bool GOKZ_GetCanResume(int client); + +/** + * Toggles the paused state of a player. + * + * @param client Client index. + */ +native void GOKZ_TogglePause(int client); + +/** + * Gets whether a player can teleport to start. + * + * @param client Client index. + * @return Whether player can teleport to start. + */ +native bool GOKZ_GetCanTeleportToStartOrEnd(int client); + +/** + * Plays the error sound to a player if they have the option enabled. + * + * @param client Client index. + */ +native void GOKZ_PlayErrorSound(int client); + +/** + * Set the origin of a player without invalidating any jumpstats. + * + * Only use this in plugins that create a new mode! + * + * @param client Client index. + * @param origin The new origin. + */ +native void GOKZ_SetValidJumpOrigin(int client, const float origin[3]); + +/** + * Registers an option with gokz-core, which uses clientprefs to + * keep track of the option's value and to save it to a database. + * This also effectively provides natives and forwards for other + * plugins to access any options that have been registered. + * + * @param name Option name. + * @param description Option description. + * @param type Type to treat the option value as. + * @param defaultValue Default value of option. + * @param minValue Minimum value of option. + * @param maxValue Maximum value of option. + * @return Whether registration was successful. + */ +native bool GOKZ_RegisterOption(const char[] name, const char[] description, OptionType type, any defaultValue, any minValue, any maxValue); + +/** + * Gets a property of a registered option. If used outside of + * gokz-core to get the cookie, a clone of its Handle is returned. + * + * @param option Option name. + * @param prop Option property to get. + * @return Value of property, or -1 (int) if option isn't registered. + */ +native any GOKZ_GetOptionProp(const char[] option, OptionProp prop); + +/** + * Sets a property of a registered option. For safety and simplicity, + * the cookie property is read-only and will fail to be set. + * + * @param option Option name. + * @param prop Option property to set. + * @param value Value to set the property to. + * @return Whether option property was successfully set. + */ +native bool GOKZ_SetOptionProp(const char[] option, OptionProp prop, any value); + +/** + * Gets the current value of a player's option. + * + * @param client Client index. + * @param option Option name. + * @return Current value of option, or -1 (int) if option isn't registered. + */ +native any GOKZ_GetOption(int client, const char[] option); + +/** + * Sets a player's option's value. Fails if option doesn't exist, + * or if desired value is outside the registered value range. + * + * @param client Client index. + * @param option Option name. + * @param value New option value. + * @return Whether option was successfully set. + */ +native bool GOKZ_SetOption(int client, const char[] option, any value); + +/** + * Gets whether player's last takeoff was a perfect bunnyhop as adjusted by GOKZ. + * + * @param client Client index. + * @return Whether player's last takeoff was a GOKZ perfect b-hop. + */ +native bool GOKZ_GetHitPerf(int client); + +/** + * Sets whether player's last takeoff was a perfect bunnyhop as adjusted by GOKZ. + * Intended to be called by GOKZ mode plugins only. + * + * @param client Client index. + * @param hitPerf Whether player's last takeoff was a GOKZ perfect b-hop. + */ +native void GOKZ_SetHitPerf(int client, bool hitPerf); + +/** + * Gets a player's horizontal speed at the time of their last takeoff as recorded by GOKZ. + * + * @param client Client index. + * @return Player's last takeoff speed as recorded by GOKZ. + */ +native float GOKZ_GetTakeoffSpeed(int client); + +/** + * Sets a player's recorded horizontal speed at the time of their last takeoff. + * Intended to be called by GOKZ mode plugins only. + * + * @param client Client index. + * @param takeoffSpeed Player's last takeoff speed as recorded by GOKZ. + */ +native void GOKZ_SetTakeoffSpeed(int client, float takeoffSpeed); + +/** + * Gets whether a player's current or last jump/airtime is valid. + * A jump is deemed invalid if the player is teleported. + * + * @param client Client index. + * @return Validity of player's current or last jump. + */ +native bool GOKZ_GetValidJump(int client); + +/** + * Has a player switch to a team via GOKZ Core. + * + * @param client Client index. + * @param team Which team to switch to. + * @param restorePos Whether to restore saved position if leaving spectators. + * @param forceBroadcast Force JoinTeam forward calling even if client's team did not change. + */ +native void GOKZ_JoinTeam(int client, int team, bool restorePos = true, bool forceBroadcast = false); + +/** + * Emit a sound to a player via GOKZ Core. + * Sounds emitted by this native will call GOKZ_OnEmitSoundToClient forward. + * + * @param client Client index. + * @param sample Sound file name relative to the "sound" folder. + * @param volume Sound volume. + * @param description Optional description. + */ +native void GOKZ_EmitSoundToClient(int client, const char[] sample, float volume = SNDVOL_NORMAL, const char[] description = ""); + + +// =====[ STOCKS ]===== + +/** + * Makes a player join a team if they aren't on one and respawns them. + * + * @param client Client index. + * @param team Which team to switch to if not on one. + * @param restorePos Whether to restore saved position if leaving spectators. + */ +stock void GOKZ_RespawnPlayer(int client, int team = CS_TEAM_T, bool restorePos = true) +{ + if (IsSpectating(client)) + { + GOKZ_JoinTeam(client, team, restorePos); + } + else + { + CS_RespawnPlayer(client); + } +} + +/** + * Prints a message to all client's chat, formatting colours and optionally + * adding the chat prefix. If using the chat prefix, specify a colour at + * the beginning of the message e.g. "{default}Hello!". + * + * @param addPrefix Whether to add the chat prefix. + * @param format Formatting rules. + * @param any Variable number of format parameters. + */ +stock void GOKZ_PrintToChatAll(bool addPrefix, const char[] format, any...) +{ + char buffer[1024]; + for (int client = 1; client <= MaxClients; client++) + { + if (IsClientInGame(client)) + { + SetGlobalTransTarget(client); + VFormat(buffer, sizeof(buffer), format, 3); + GOKZ_PrintToChat(client, addPrefix, buffer); + } + } +} + +/** + * Prints a chat message to those spectating the client, formatting colours + * and optionally adding the chat prefix. If using the chat prefix, specify + * a colour at the beginning of the message e.g. "{default}Hello!". + * + * @param client Client index. + * @param addPrefix Whether to add the chat prefix. + * @param format Formatting rules. + * @param any Variable number of format parameters. + */ +stock void GOKZ_PrintToChatSpectators(int client, bool addPrefix, const char[] format, any...) +{ + char buffer[1024]; + for (int target = 1; target <= MaxClients; target++) + { + if (IsClientInGame(target) && GetObserverTarget(target) == client) + { + SetGlobalTransTarget(target); + VFormat(buffer, sizeof(buffer), format, 4); + GOKZ_PrintToChat(target, addPrefix, buffer); + } + } +} + +/** + * Gets the player's current time type. + * + * @param client Client index. + * @return Player's current time type. + */ +stock int GOKZ_GetTimeType(int client) +{ + return GOKZ_GetTimeTypeEx(GOKZ_GetTeleportCount(client)); +} + +/** + * Gets the time type given a teleport count. + * + * @param teleports Teleport count. + * @return Time type. + */ +stock int GOKZ_GetTimeTypeEx(int teleportCount) +{ + if (teleportCount == 0) + { + return TimeType_Pro; + } + return TimeType_Nub; +} + +/** + * Clears and populates a menu with an item for each mode + * in order of the mode enumeration. Highlights the client's + * selected mode with an asterisk. + * + * @param client Client index to check selected mode. + * @param menu Menu to populate items with. + * @param disableUnloadedModes Draw items for unloaded modes as disabled. + */ +stock void GOKZ_MenuAddModeItems(int client, Menu menu, bool disableUnloadedModes) +{ + int selectedMode = GOKZ_GetCoreOption(client, Option_Mode); + char display[32]; + + menu.RemoveAllItems(); + + for (int mode = 0; mode < MODE_COUNT; mode++) + { + FormatEx(display, sizeof(display), "%s", gC_ModeNames[mode]); + // Add asterisk to selected mode + if (mode == selectedMode) + { + Format(display, sizeof(display), "%s*", display); + } + + if (GOKZ_GetModeLoaded(mode)) + { + menu.AddItem("", display, ITEMDRAW_DEFAULT); + } + else + { + menu.AddItem("", display, ITEMDRAW_DISABLED); + } + } +} + +/** + * Increment an (integer-type) option's value. + * Loops back to min. value if max. value is exceeded. + * + * @param client Client index. + * @param option Option name. + * @return Whether option was successfully set. + */ +stock bool GOKZ_CycleOption(int client, const char[] option) +{ + int maxValue = GOKZ_GetOptionProp(option, OptionProp_MaxValue); + if (maxValue == -1) + { + return false; + } + + int newValue = GOKZ_GetOption(client, option) + 1; + if (newValue > GOKZ_GetOptionProp(option, OptionProp_MaxValue)) + { + newValue = GOKZ_GetOptionProp(option, OptionProp_MinValue); + } + return GOKZ_SetOption(client, option, newValue); +} + +/** + * Returns whether an option is a gokz-core option. + * + * @param option Option name. + * @param optionEnum Variable to store enumerated gokz-core option (if it is one). + * @return Whether option is a gokz-core option. + */ +stock bool GOKZ_IsCoreOption(const char[] option, Option &optionEnum = OPTION_INVALID) +{ + for (Option i; i < OPTION_COUNT; i++) + { + if (StrEqual(option, gC_CoreOptionNames[i])) + { + optionEnum = i; + return true; + } + } + return false; +} + +/** + * Gets a property of a gokz-core option. + * + * @param coreOption gokz-core option. + * @param prop Option property to get. + * @return Value of property, or -1 if option isn't registered. + */ +stock any GOKZ_GetCoreOptionProp(Option option, OptionProp prop) +{ + return GOKZ_GetOptionProp(gC_CoreOptionNames[option], prop); +} + +/** + * Gets the current value of a player's gokz-core option. + * + * @param client Client index. + * @param option gokz-core option. + * @return Current value of option. + */ +stock any GOKZ_GetCoreOption(int client, Option option) +{ + return GOKZ_GetOption(client, gC_CoreOptionNames[option]); +} + +/** + * Sets the player's gokz-core option's value. + * + * @param client Client index. + * @param option gokz-core option. + * @param value New option value. + * @return Whether option was successfully set. + */ +stock bool GOKZ_SetCoreOption(int client, Option option, any value) +{ + return GOKZ_SetOption(client, gC_CoreOptionNames[option], value); +} + +/** + * Increment an integer-type gokz-core option's value. + * Loops back to '0' if max value is exceeded. + * + * @param client Client index. + * @param option gokz-core option. + * @return Whether option was successfully set. + */ +stock bool GOKZ_CycleCoreOption(int client, Option option) +{ + return GOKZ_CycleOption(client, gC_CoreOptionNames[option]); +} + +/** + * Gets the current default mode. + * + * @return Default mode. + */ +stock int GOKZ_GetDefaultMode() +{ + return GOKZ_GetCoreOptionProp(Option_Mode, OptionProp_DefaultValue); +} + +/** + * Returns whether a course number is a valid (within valid range). + * + * @param course Course number. + * @param bonus Whether to only consider bonus course numbers as valid. + * @return Whether course number is valid. + */ +stock bool GOKZ_IsValidCourse(int course, bool bonus = false) +{ + return (!bonus && course == 0) || (0 < course && course < GOKZ_MAX_COURSES); +} + +/** + * Returns an integer from an entity's name as matched using a regular expression. + * + * @param entity Entity index. + * @param re Regular expression to match the integer with. + * @param substringID ID of the substring that will contain the integer. + * @returns Integer found in the entity's name, or -1 if not found. + */ +stock int GOKZ_MatchIntFromEntityName(int entity, Regex re, int substringID) +{ + int num = -1; + char buffer[32]; + GetEntityName(entity, buffer, sizeof(buffer)); + + if (re.Match(buffer) > 0) + { + re.GetSubString(1, buffer, sizeof(buffer)); + num = StringToInt(buffer); + } + + return num; +} + +/** + * Emits a sound to other players that are spectating the client. + * Sounds emitted by this function will call GOKZ_OnEmitSoundToClient forward. + * + * @param sample Sound file name relative to the "sound" folder. + * @param volume Sound volume. + * @param description Optional description. + */ +stock void GOKZ_EmitSoundToAll(const char[] sample, float volume = SNDVOL_NORMAL, const char[] description = "") +{ + for (int client = 1; client <= MaxClients; client++) + { + if (IsClientInGame(client)) + { + GOKZ_EmitSoundToClient(client, sample, volume, description); + } + } +} + +/** + * Emits a sound to other players that are spectating the client. + * Sounds emitted by this function will call GOKZ_OnEmitSoundToClient forward. + * + * @param client Client being spectated. + * @param sample Sound file name relative to the "sound" folder. + * @param volume Sound volume. + * @param description Optional description. + */ +stock void GOKZ_EmitSoundToClientSpectators(int client, const char[] sample, float volume = SNDVOL_NORMAL, const char[] description = "") +{ + for (int i = 1; i <= MaxClients; i++) + { + if (IsValidClient(i) && GetObserverTarget(i) == client) + { + GOKZ_EmitSoundToClient(i, sample, volume); + } + } +} + +// =====[ DEPENDENCY ]===== + +public SharedPlugin __pl_gokz_core = +{ + name = "gokz-core", + file = "gokz-core.smx", + #if defined REQUIRE_PLUGIN + required = 1, + #else + required = 0, + #endif +}; + +#if !defined REQUIRE_PLUGIN +public void __pl_gokz_core_SetNTVOptional() +{ + MarkNativeAsOptional("GOKZ_GetModeLoaded"); + MarkNativeAsOptional("GOKZ_GetModeVersion"); + MarkNativeAsOptional("GOKZ_SetModeLoaded"); + MarkNativeAsOptional("GOKZ_GetLoadedModeCount"); + MarkNativeAsOptional("GOKZ_SetMode"); + MarkNativeAsOptional("GOKZ_GetOptionsTopMenu"); + MarkNativeAsOptional("GOKZ_GetCourseRegistered"); + MarkNativeAsOptional("GOKZ_PrintToChat"); + MarkNativeAsOptional("GOKZ_PrintToChatAndLog"); + MarkNativeAsOptional("GOKZ_StartTimer"); + MarkNativeAsOptional("GOKZ_EndTimer"); + MarkNativeAsOptional("GOKZ_StopTimer"); + MarkNativeAsOptional("GOKZ_StopTimerAll"); + MarkNativeAsOptional("GOKZ_TeleportToStart"); + MarkNativeAsOptional("GOKZ_TeleportToSearchStart"); + MarkNativeAsOptional("GOKZ_GetVirtualButtonPosition"); + MarkNativeAsOptional("GOKZ_SetVirtualButtonPosition"); + MarkNativeAsOptional("GOKZ_ResetVirtualButtonPosition"); + MarkNativeAsOptional("GOKZ_LockVirtualButtons"); + MarkNativeAsOptional("GOKZ_GetStartPosition"); + MarkNativeAsOptional("GOKZ_SetStartPosition"); + MarkNativeAsOptional("GOKZ_GetStartPositionType"); + MarkNativeAsOptional("GOKZ_SetStartPositionToMapStart"); + MarkNativeAsOptional("GOKZ_TeleportToEnd"); + MarkNativeAsOptional("GOKZ_MakeCheckpoint"); + MarkNativeAsOptional("GOKZ_GetCanMakeCheckpoint"); + MarkNativeAsOptional("GOKZ_TeleportToCheckpoint"); + MarkNativeAsOptional("GOKZ_GetCanTeleportToCheckpoint"); + MarkNativeAsOptional("GOKZ_PrevCheckpoint"); + MarkNativeAsOptional("GOKZ_GetCanPrevCheckpoint"); + MarkNativeAsOptional("GOKZ_NextCheckpoint"); + MarkNativeAsOptional("GOKZ_GetCanNextCheckpoint"); + MarkNativeAsOptional("GOKZ_UndoTeleport"); + MarkNativeAsOptional("GOKZ_GetCanUndoTeleport"); + MarkNativeAsOptional("GOKZ_Pause"); + MarkNativeAsOptional("GOKZ_GetCanPause"); + MarkNativeAsOptional("GOKZ_Resume"); + MarkNativeAsOptional("GOKZ_GetCanResume"); + MarkNativeAsOptional("GOKZ_TogglePause"); + MarkNativeAsOptional("GOKZ_GetCanTeleportToStartOrEnd"); + MarkNativeAsOptional("GOKZ_PlayErrorSound"); + MarkNativeAsOptional("GOKZ_SetValidJumpOrigin"); + MarkNativeAsOptional("GOKZ_GetTimerRunning"); + MarkNativeAsOptional("GOKZ_GetCourse"); + MarkNativeAsOptional("GOKZ_SetCourse"); + MarkNativeAsOptional("GOKZ_GetPaused"); + MarkNativeAsOptional("GOKZ_GetTime"); + MarkNativeAsOptional("GOKZ_SetTime"); + MarkNativeAsOptional("GOKZ_InvalidateRun"); + MarkNativeAsOptional("GOKZ_GetCheckpointCount"); + MarkNativeAsOptional("GOKZ_SetCheckpointCount"); + MarkNativeAsOptional("GOKZ_GetCheckpointData"); + MarkNativeAsOptional("GOKZ_SetCheckpointData"); + MarkNativeAsOptional("GOKZ_GetUndoTeleportData"); + MarkNativeAsOptional("GOKZ_SetUndoTeleportData"); + MarkNativeAsOptional("GOKZ_GetTeleportCount"); + MarkNativeAsOptional("GOKZ_SetTeleportCount"); + MarkNativeAsOptional("GOKZ_RegisterOption"); + MarkNativeAsOptional("GOKZ_GetOptionProp"); + MarkNativeAsOptional("GOKZ_SetOptionProp"); + MarkNativeAsOptional("GOKZ_GetOption"); + MarkNativeAsOptional("GOKZ_SetOption"); + MarkNativeAsOptional("GOKZ_GetHitPerf"); + MarkNativeAsOptional("GOKZ_SetHitPerf"); + MarkNativeAsOptional("GOKZ_GetTakeoffSpeed"); + MarkNativeAsOptional("GOKZ_SetTakeoffSpeed"); + MarkNativeAsOptional("GOKZ_GetValidJump"); + MarkNativeAsOptional("GOKZ_JoinTeam"); + MarkNativeAsOptional("GOKZ_EmitSoundToClient"); +} +#endif
\ No newline at end of file diff --git a/sourcemod/scripting/include/gokz/global.inc b/sourcemod/scripting/include/gokz/global.inc new file mode 100644 index 0000000..0f23a0c --- /dev/null +++ b/sourcemod/scripting/include/gokz/global.inc @@ -0,0 +1,317 @@ +/* + gokz-global Plugin Include + + Website: https://bitbucket.org/kztimerglobalteam/gokz +*/ + +#if defined _gokz_global_included_ +#endinput +#endif +#define _gokz_global_included_ + +#include <GlobalAPI> + + + +// =====[ ENUMS ]===== + +enum +{ + EnforcedCVar_Cheats = 0, + EnforcedCVar_ClampUnsafeVelocities, + EnforcedCVar_DropKnifeEnable, + EnforcedCVar_AutoBunnyhopping, + EnforcedCVar_MinUpdateRate, + EnforcedCVar_MaxUpdateRate, + EnforcedCVar_MinCmdRate, + EnforcedCVar_MaxCmdRate, + EnforcedCVar_ClientCmdrateDifference, + EnforcedCVar_Turbophysics, + ENFORCEDCVAR_COUNT +}; + +enum +{ + BannedPluginCommand_Funcommands = 0, + BannedPluginCommand_Playercommands, + BANNEDPLUGINCOMMAND_COUNT +}; + +enum +{ + BannedPlugin_Funcommands = 0, + BannedPlugin_Playercommands, + BANNEDPLUGIN_COUNT +}; + +enum GlobalMode +{ + GlobalMode_Invalid = -1, + GlobalMode_KZTimer = 200, + GlobalMode_KZSimple, + GlobalMode_Vanilla +} + + + +// =====[ CONSTANTS ]===== + +#define GL_SOUND_NEW_RECORD "gokz/holyshit.mp3" +#define GL_FPS_MAX_CHECK_INTERVAL 1.0 +#define GL_FPS_MAX_KICK_TIMEOUT 10.0 +#define GL_FPS_MAX_MIN_VALUE 120 +#define GL_MYAW_MAX_VALUE 0.3 + +stock char gC_EnforcedCVars[ENFORCEDCVAR_COUNT][] = +{ + "sv_cheats", + "sv_clamp_unsafe_velocities", + "mp_drop_knife_enable", + "sv_autobunnyhopping", + "sv_minupdaterate", + "sv_maxupdaterate", + "sv_mincmdrate", + "sv_maxcmdrate", + "sv_client_cmdrate_difference", + "sv_turbophysics" +}; + +stock char gC_BannedPluginCommands[BANNEDPLUGINCOMMAND_COUNT][] = +{ + "sm_beacon", + "sm_slap" +}; + +stock char gC_BannedPlugins[BANNEDPLUGIN_COUNT][] = +{ + "Fun Commands", + "Player Commands" +}; + +stock float gF_EnforcedCVarValues[ENFORCEDCVAR_COUNT] = +{ + 0.0, + 0.0, + 0.0, + 0.0, + 128.0, + 128.0, + 128.0, + 128.0, + 0.0, + 0.0 +}; + + + +// =====[ FORWARDS ]===== + +/** + * Called when a player sets a new global top time. + * + * @param client Client index. + * @param course Course number e.g. 0=main, 1='bonus1' etc. + * @param mode Player's movement mode. + * @param timeType Time type i.e. NUB or PRO. + * @param rank Ranking within the same time type. + * @param rankOverall Overall (NUB and PRO) ranking (0 if not ranked high enough). + * @param runTime Player's end time. + */ +forward void GOKZ_GL_OnNewTopTime(int client, int course, int mode, int timeType, int rank, int rankOverall, float runTime); + + + +// =====[ NATIVES ]===== + +/** + * Prints to chat the global records for a map, course and mode. + * + * @param client Client index. + * @param map Map name or "" for current map. + * @param course Course number e.g. 0=main, 1='bonus1' etc. + * @param mode GOKZ mode. + */ +native void GOKZ_GL_PrintRecords(int client, const char[] map = "", int course, int mode, const char[] steamid = DEFAULT_STRING); + +/** + * Opens up the global map top menu for a map, course and mode. + * + * @param client Client index. + * @param map Map name or "" for current map. + * @param course Course number e.g. 0=main, 1='bonus1' etc. + * @param mode GOKZ mode. + * @param timeType Type of time i.e. NUB or PRO. + */ +native void GOKZ_GL_DisplayMapTopMenu(int client, const char[] map = "", int course, int mode, int timeType); + +/** + * Get the total global points of a player. + * + * @param client Client index. + * @param mode GOKZ mode. + * @param timeType Type of time i.e. NUB or PRO. + */ +native void GOKZ_GL_GetPoints(int client, int mode, int timeType); + +/** + * Get the global points on the main coruse of the current map. + * + * @param client Client index. + * @param mode GOKZ mode. + * @param timeType Type of time i.e. NUB or PRO. + */ +native void GOKZ_GL_GetMapPoints(int client, int mode, int timeType); + +/** + * Get the total global ranking points of a player. + * + * @param client Client index. + * @param mode GOKZ mode. + * @return The points. + */ +native int GOKZ_GL_GetRankPoints(int client, int mode); + +/** + * Get the amount of maps a player finished. + * + * @param client Client index. + * @param mode GOKZ mode. + * @param timeType Type of time i.e. NUB or PRO. + */ +native void GOKZ_GL_GetFinishes(int client, int mode, int timeType); + +/** + * Fetch the points a player got from the Global API. + * + * @param client Client index. -1 to update all indices. + * @param mode GOKZ mode. -1 to update all modes. + */ +native void GOKZ_GL_UpdatePoints(int client = -1, int mode = -1); + +/** + * Gets whether the Global API key is valid or not for global status. + * + * @return True if the API key is valid, false otherwise or if there is no connection to the Global API. + */ +native bool GOKZ_GL_GetAPIKeyValid(); + +/** + * Gets whether the running plugins are valid or not for global status. + * + * @return True if the plugins are valid, false otherwise. + */ +native bool GOKZ_GL_GetPluginsValid(); + +/** + * Gets whether the setting enforcer is valid or not for global status. + * + * @return True if the setting enforcer is valid, false otherwise. + */ +native bool GOKZ_GL_GetSettingsEnforcerValid(); + +/** + * Gets whether the current map is valid or not for global status. + * + * @return True if the map is valid, false otherwise or if there is no connection to the Global API. + */ +native bool GOKZ_GL_GetMapValid(); + +/** + * Gets whether the current player is valid or not for global status. + * + * @param client Client index. + * @return True if the player is valid, false otherwise or if there is no connection to the Global API. + */ +native bool GOKZ_GL_GetPlayerValid(int client); + + + +// =====[ STOCKS ]===== + +/** + * Gets the global mode enumeration equivalent for the GOKZ mode. + * + * @param mode GOKZ mode. + * @return Global mode enumeration equivalent. + */ +stock GlobalMode GOKZ_GL_GetGlobalMode(int mode) +{ + switch (mode) + { + case Mode_Vanilla:return GlobalMode_Vanilla; + case Mode_SimpleKZ:return GlobalMode_KZSimple; + case Mode_KZTimer:return GlobalMode_KZTimer; + } + return GlobalMode_Invalid; +} + +/** + * Gets the global mode enumeration equivalent for the GOKZ mode. + * + * @param mode GOKZ mode. + * @return Global mode enumeration equivalent. + */ +stock int GOKZ_GL_FromGlobalMode(GlobalMode mode) +{ + switch (mode) + { + case GlobalMode_Vanilla:return Mode_Vanilla; + case GlobalMode_KZSimple:return Mode_SimpleKZ; + case GlobalMode_KZTimer:return Mode_KZTimer; + } + return -1; +} + +/** + * Gets the string representation of a mode. + * + * @param mode GOKZ mode. + * @param mode_str String version of the mode. + * @param size Max length of mode_str. + * @return True if the conversion was successful. + */ +stock bool GOKZ_GL_GetModeString(int mode, char[] mode_str, int size) +{ + switch (mode) + { + case Mode_Vanilla:strcopy(mode_str, size, "kz_vanilla"); + case Mode_SimpleKZ:strcopy(mode_str, size, "kz_simple"); + case Mode_KZTimer:strcopy(mode_str, size, "kz_timer"); + default:return false; + } + return true; +} + + + +// =====[ DEPENDENCY ]===== + +public SharedPlugin __pl_gokz_global = +{ + name = "gokz-global", + file = "gokz-global.smx", + #if defined REQUIRE_PLUGIN + required = 1, + #else + required = 0, + #endif +}; + +#if !defined REQUIRE_PLUGIN +public void __pl_gokz_global_SetNTVOptional() +{ + MarkNativeAsOptional("GOKZ_GL_PrintRecords"); + MarkNativeAsOptional("GOKZ_GL_DisplayMapTopMenu"); + MarkNativeAsOptional("GOKZ_GL_UpdatePoints"); + MarkNativeAsOptional("GOKZ_GL_GetAPIKeyValid"); + MarkNativeAsOptional("GOKZ_GL_GetPluginsValid"); + MarkNativeAsOptional("GOKZ_GL_GetSettingsEnforcerValid"); + MarkNativeAsOptional("GOKZ_GL_GetMapValid"); + MarkNativeAsOptional("GOKZ_GL_GetPlayerValid"); + MarkNativeAsOptional("GOKZ_GL_GetPoints"); + MarkNativeAsOptional("GOKZ_GL_GetMapPoints"); + MarkNativeAsOptional("GOKZ_GL_GetRankPoints"); + MarkNativeAsOptional("GOKZ_GL_GetFinishes"); + MarkNativeAsOptional("GOKZ_GL_UpdatePoints"); +} +#endif
\ No newline at end of file diff --git a/sourcemod/scripting/include/gokz/hud.inc b/sourcemod/scripting/include/gokz/hud.inc new file mode 100644 index 0000000..5d658ff --- /dev/null +++ b/sourcemod/scripting/include/gokz/hud.inc @@ -0,0 +1,468 @@ +/* + gokz-hud Plugin Include + + Website: https://bitbucket.org/kztimerglobalteam/gokz +*/ + +#if defined _gokz_hud_included_ +#endinput +#endif +#define _gokz_hud_included_ + + + +// =====[ ENUMS ]===== + +enum HUDOption: +{ + HUDOPTION_INVALID = -1, + HUDOption_TPMenu, + HUDOption_InfoPanel, + HUDOption_ShowKeys, + HUDOption_TimerText, + HUDOption_TimerStyle, + HUDOption_TimerType, + HUDOption_SpeedText, + HUDOption_ShowWeapon, + HUDOption_ShowControls, + HUDOption_DeadstrafeColor, + HUDOption_ShowSpectators, + HUDOption_SpecListPosition, + HUDOption_UpdateRate, + HUDOption_DynamicMenu, + HUDOPTION_COUNT +}; + +enum +{ + TPMenu_Disabled = 0, + TPMenu_Simple, + TPMenu_Advanced, + TPMENU_COUNT +}; + +enum +{ + InfoPanel_Disabled = 0, + InfoPanel_Enabled, + INFOPANEL_COUNT +}; + +enum +{ + ShowKeys_Spectating = 0, + ShowKeys_Always, + ShowKeys_Disabled, + SHOWKEYS_COUNT +}; + +enum +{ + TimerText_Disabled = 0, + TimerText_InfoPanel, + TimerText_TPMenu, + TimerText_Bottom, + TimerText_Top, + TIMERTEXT_COUNT +}; + +enum +{ + TimerStyle_Standard = 0, + TimerStyle_Precise, + TIMERSTYLE_COUNT +}; + +enum +{ + TimerType_Disabled = 0, + TimerType_Enabled, + TIMERTYPE_COUNT +}; + +enum +{ + SpeedText_Disabled = 0, + SpeedText_InfoPanel, + SpeedText_Bottom, + SPEEDTEXT_COUNT +}; + +enum +{ + ShowWeapon_Disabled = 0, + ShowWeapon_Enabled, + SHOWWEAPON_COUNT +}; + +enum +{ + ReplayControls_Disabled = 0, + ReplayControls_Enabled, + REPLAYCONTROLS_COUNT +}; + +enum +{ + DeadstrafeColor_Disabled = 0, + DeadstrafeColor_Enabled, + DEADSTRAFECOLOR_COUNT +}; + +enum +{ + ShowSpecs_Disabled = 0, + ShowSpecs_Number, + ShowSpecs_Full, + SHOWSPECS_COUNT +}; + +enum +{ + SpecListPosition_TPMenu = 0, + SpecListPosition_InfoPanel, + SPECLISTPOSITION_COUNT +} + +enum +{ + UpdateRate_Slow = 0, + UpdateRate_Fast, + UPDATERATE_COUNT, +}; + +enum +{ + DynamicMenu_Legacy = 0, + DynamicMenu_Disabled, + DynamicMenu_Enabled, + DYNAMICMENU_COUNT +}; + +// =====[ STRUCTS ]====== + +enum struct HUDInfo +{ + bool TimerRunning; + int TimeType; + float Time; + bool Paused; + bool OnGround; + bool OnLadder; + bool Noclipping; + bool Ducking; + bool HitBhop; + bool IsTakeoff; + float Speed; + int ID; + bool Jumped; + bool HitPerf; + bool HitJB; + float TakeoffSpeed; + int Buttons; + int CurrentTeleport; +} + + + +// =====[ CONSTANTS ]===== + +#define HUD_OPTION_CATEGORY "HUD" +#define HUD_MAX_BHOP_GROUND_TICKS 5 +#define HUD_MAX_HINT_SIZE 227 + +stock char gC_HUDOptionNames[HUDOPTION_COUNT][] = +{ + "GOKZ HUD - Teleport Menu", + "GOKZ HUD - Centre Panel", + "GOKZ HUD - Show Keys", + "GOKZ HUD - Timer Text", + "GOKZ HUD - Timer Style", + "GOKZ HUD - Show Time Type", + "GOKZ HUD - Speed Text", + "GOKZ HUD - Show Weapon", + "GOKZ HUD - Show Controls", + "GOKZ HUD - Dead Strafe", + "GOKZ HUD - Show Spectators", + "GOKZ HUD - Spec List Pos", + "GOKZ HUD - Update Rate", + "GOKZ HUD - Dynamic Menu" +}; + +stock char gC_HUDOptionDescriptions[HUDOPTION_COUNT][] = +{ + "Teleport Menu - 0 = Disabled, 1 = Simple, 2 = Advanced", + "Centre Information Panel - 0 = Disabled, 1 = Enabled", + "Key Press Display - 0 = Spectating, 1 = Always, 2 = Disabled", + "Timer Display - 0 = Disabled, 1 = Centre Panel, 2 = Teleport Menu, 3 = Bottom, 4 = Top", + "Timer Style - 0 = Standard, 1 = Precise", + "Timer Type - 0 = Disabled, 1 = Enabled", + "Speed Display - 0 = Disabled, 1 = Centre Panel, 2 = Bottom", + "Weapon Viewmodel - 0 = Disabled, 1 = Enabled", + "Replay Controls Display - 0 = Disbled, 1 = Enabled", + "Dead Strafe Indicator - 0 = Disabled, 1 = Enabled", + "Show Spectators - 0 = Disabled, 1 = Number Only, 2 = Number and Names", + "Spectator List Position - 0 = Teleport Menu, 2 = Center Panel", + "HUD Update Rate - 0 = Slow, 1 = Fast", + "Dynamic Menu - 0 = Legacy, 1 = Disabled, 2 = Enabled" +}; + +stock char gC_HUDOptionPhrases[HUDOPTION_COUNT][] = +{ + "Options Menu - Teleport Menu", + "Options Menu - Info Panel", + "Options Menu - Show Keys", + "Options Menu - Timer Text", + "Options Menu - Timer Style", + "Options Menu - Timer Type", + "Options Menu - Speed Text", + "Options Menu - Show Weapon", + "Options Menu - Show Controls", + "Options Menu - Dead Strafe Indicator", + "Options Menu - Show Spectators", + "Options Menu - Spectator List Position", + "Options Menu - Update Rate", + "Options Menu - Dynamic Menu" +}; + +stock int gI_HUDOptionCounts[HUDOPTION_COUNT] = +{ + TPMENU_COUNT, + INFOPANEL_COUNT, + SHOWKEYS_COUNT, + TIMERTEXT_COUNT, + TIMERSTYLE_COUNT, + TIMERTYPE_COUNT, + SPEEDTEXT_COUNT, + SHOWWEAPON_COUNT, + REPLAYCONTROLS_COUNT, + DEADSTRAFECOLOR_COUNT, + SHOWSPECS_COUNT, + SPECLISTPOSITION_COUNT, + UPDATERATE_COUNT, + DYNAMICMENU_COUNT +}; + +stock int gI_HUDOptionDefaults[HUDOPTION_COUNT] = +{ + TPMenu_Advanced, + InfoPanel_Enabled, + ShowKeys_Spectating, + TimerText_InfoPanel, + TimerStyle_Standard, + TimerType_Enabled, + SpeedText_InfoPanel, + ShowWeapon_Enabled, + ReplayControls_Enabled, + DeadstrafeColor_Disabled, + ShowSpecs_Disabled, + SpecListPosition_TPMenu, + UpdateRate_Slow, + DynamicMenu_Legacy +}; + +stock char gC_TPMenuPhrases[TPMENU_COUNT][] = +{ + "Options Menu - Disabled", + "Options Menu - Simple", + "Options Menu - Advanced" +}; + +stock char gC_ShowKeysPhrases[SHOWKEYS_COUNT][] = +{ + "Options Menu - Spectating", + "Options Menu - Always", + "Options Menu - Disabled" +}; + +stock char gC_TimerTextPhrases[TIMERTEXT_COUNT][] = +{ + "Options Menu - Disabled", + "Options Menu - Info Panel", + "Options Menu - Teleport Menu", + "Options Menu - Bottom", + "Options Menu - Top" +}; + +stock char gC_TimerTypePhrases[TIMERTYPE_COUNT][] = +{ + "Options Menu - Disabled", + "Options Menu - Enabled" +}; + +stock char gC_SpeedTextPhrases[SPEEDTEXT_COUNT][] = +{ + "Options Menu - Disabled", + "Options Menu - Info Panel", + "Options Menu - Bottom" +}; + +stock char gC_ShowControlsPhrases[REPLAYCONTROLS_COUNT][] = +{ + "Options Menu - Disabled", + "Options Menu - Enabled" +}; + +stock char gC_DeadstrafeColorPhrases[DEADSTRAFECOLOR_COUNT][] = +{ + "Options Menu - Disabled", + "Options Menu - Enabled" +}; + +stock char gC_ShowSpecsPhrases[SHOWSPECS_COUNT][] = +{ + "Options Menu - Disabled", + "Options Menu - Number", + "Options Menu - Number and Names" +}; + +stock char gC_SpecListPositionPhrases[SPECLISTPOSITION_COUNT][] = +{ + "Options Menu - Teleport Menu", + "Options Menu - Info Panel" +}; + +stock char gC_HUDUpdateRatePhrases[UPDATERATE_COUNT][]= +{ + "Options Menu - Slow", + "Options Menu - Fast" +}; + +stock char gC_DynamicMenuPhrases[DYNAMICMENU_COUNT][]= +{ + "Options Menu - Legacy", + "Options Menu - Disabled", + "Options Menu - Enabled" +}; + +// =====[ NATIVES ]===== + +/** + * Returns whether the GOKZ HUD menu is showing for a client. + * + * @param client Client index. + * @return Whether the GOKZ HUD menu is showing. + */ +native bool GOKZ_HUD_GetMenuShowing(int client); + +/** + * Sets whether the GOKZ HUD menu would be showing for a client. + * + * @param client Client index. + * @param value Whether the GOKZ HUD menu would be showing for a client. + */ +native void GOKZ_HUD_SetMenuShowing(int client, bool value); + +/** + * Gets the spectator text for the menu. Used by GOKZ-replays. + * + * @param client Client index. + * @param value Whether the GOKZ HUD menu would be showing for a client. + */ +native void GOKZ_HUD_GetMenuSpectatorText(int client, any[] info, char[] buffer, int size); + +/** + * Forces the client's TP menu to update. + * + * @param client Client index. + */ +native void GOKZ_HUD_ForceUpdateTPMenu(int client); + +// =====[ STOCKS ]===== + +/** + * Returns whether an option is a gokz-hud option. + * + * @param option Option name. + * @param optionEnum Variable to store enumerated gokz-hud option (if it is one). + * @return Whether option is a gokz-hud option. + */ +stock bool GOKZ_HUD_IsHUDOption(const char[] option, HUDOption &optionEnum = HUDOPTION_INVALID) +{ + for (HUDOption i; i < HUDOPTION_COUNT; i++) + { + if (StrEqual(option, gC_HUDOptionNames[i])) + { + optionEnum = i; + return true; + } + } + return false; +} + +/** + * Gets the current value of a player's gokz-hud option. + * + * @param client Client index. + * @param option gokz-hud option. + * @return Current value of option. + */ +stock any GOKZ_HUD_GetOption(int client, HUDOption option) +{ + return GOKZ_GetOption(client, gC_HUDOptionNames[option]); +} + +/** + * Sets a player's gokz-hud option's value. + * + * @param client Client index. + * @param option gokz-hud option. + * @param value New option value. + * @return Whether option was successfully set. + */ +stock bool GOKZ_HUD_SetOption(int client, HUDOption option, any value) +{ + return GOKZ_SetOption(client, gC_HUDOptionNames[option], value); +} + +/** + * Increment an integer-type gokz-hud option's value. + * Loops back to '0' if max value is exceeded. + * + * @param client Client index. + * @param option gokz-hud option. + * @return Whether option was successfully set. + */ +stock bool GOKZ_HUD_CycleOption(int client, HUDOption option) +{ + return GOKZ_CycleOption(client, gC_HUDOptionNames[option]); +} + +/** + * Represents a time float as a string e.g. 01:23.45 + * and according to the client's HUD options. + * + * @param client Client index. + * @param time Time in seconds. + * @return String representation of time. + */ +stock char[] GOKZ_HUD_FormatTime(int client, float time) +{ + bool precise = GOKZ_HUD_GetOption(client, HUDOption_TimerStyle) == TimerStyle_Precise; + return GOKZ_FormatTime(time, precise); +} + + + +// =====[ DEPENDENCY ]===== + +public SharedPlugin __pl_gokz_hud = +{ + name = "gokz-hud", + file = "gokz-hud.smx", + #if defined REQUIRE_PLUGIN + required = 1, + #else + required = 0, + #endif +}; + +#if !defined REQUIRE_PLUGIN +public void __pl_gokz_hud_SetNTVOptional() +{ + MarkNativeAsOptional("GOKZ_HUD_GetMenuShowing"); + MarkNativeAsOptional("GOKZ_HUD_SetMenuShowing"); + MarkNativeAsOptional("GOKZ_HUD_GetMenuSpectatorText"); + MarkNativeAsOptional("GOKZ_HUD_ForceUpdateTPMenu"); +} +#endif diff --git a/sourcemod/scripting/include/gokz/jumpbeam.inc b/sourcemod/scripting/include/gokz/jumpbeam.inc new file mode 100644 index 0000000..1b92479 --- /dev/null +++ b/sourcemod/scripting/include/gokz/jumpbeam.inc @@ -0,0 +1,148 @@ +/* + gokz-jumpbeam Plugin Include + + Website: https://bitbucket.org/kztimerglobalteam/gokz +*/ + +#if defined _gokz_jumpbeam_included_ +#endinput +#endif +#define _gokz_jumpbeam_included_ + + + +// =====[ ENUMS ]===== + +enum JBOption: +{ + JBOPTION_INVALID = -1, + JBOption_Type, + JBOPTION_COUNT +}; + +enum +{ + JBType_Disabled = 0, + JBType_Feet, + JBType_Head, + JBType_FeetAndHead, + JBType_Ground, + JBTYPE_COUNT +}; + + + +// =====[ CONSTANTS ]===== + +#define JB_BEAM_LIFETIME 4.0 + +stock char gC_JBOptionNames[JBOPTION_COUNT][] = +{ + "GOKZ JB - Jump Beam Type" +}; + +stock char gC_JBOptionDescriptions[JBOPTION_COUNT][] = +{ + "Jump Beam Type - 0 = Disabled, 1 = Feet, 2 = Head, 3 = Feet & Head, 4 = Ground" +}; + +stock int gI_JBOptionDefaultValues[JBOPTION_COUNT] = +{ + JBType_Disabled +}; + +stock int gI_JBOptionCounts[JBOPTION_COUNT] = +{ + JBTYPE_COUNT +}; + +stock char gC_JBOptionPhrases[JBOPTION_COUNT][] = +{ + "Options Menu - Jump Beam" +}; + +stock char gC_JBTypePhrases[JBTYPE_COUNT][] = +{ + "Options Menu - Disabled", + "Options Menu - Feet", + "Options Menu - Head", + "Options Menu - Feet and Head", + "Options Menu - Ground" +}; + + + +// =====[ STOCKS ]===== + +/** + * Returns whether an option is a gokz-jumpbeam option. + * + * @param option Option name. + * @param optionEnum Variable to store enumerated gokz-jumpbeam option (if it is one). + * @return Whether option is a gokz-jumpbeam option. + */ +stock bool GOKZ_JB_IsJBOption(const char[] option, JBOption &optionEnum = JBOPTION_INVALID) +{ + for (JBOption i; i < JBOPTION_COUNT; i++) + { + if (StrEqual(option, gC_JBOptionNames[i])) + { + optionEnum = i; + return true; + } + } + return false; +} + +/** + * Gets the current value of a player's gokz-jumpbeam option. + * + * @param client Client index. + * @param option gokz-jumpbeam option. + * @return Current value of option. + */ +stock any GOKZ_JB_GetOption(int client, JBOption option) +{ + return GOKZ_GetOption(client, gC_JBOptionNames[option]); +} + +/** + * Sets a player's gokz-jumpbeam option's value. + * + * @param client Client index. + * @param option gokz-jumpbeam option. + * @param value New option value. + * @return Whether option was successfully set. + */ +stock bool GOKZ_JB_SetOption(int client, JBOption option, any value) +{ + return GOKZ_SetOption(client, gC_JBOptionNames[option], value); +} + +/** + * Increment an integer-type gokz-jumpbeam option's value. + * Loops back to '0' if max value is exceeded. + * + * @param client Client index. + * @param option gokz-jumpbeam option. + * @return Whether option was successfully set. + */ +stock bool GOKZ_JB_CycleOption(int client, JBOption option) +{ + return GOKZ_CycleOption(client, gC_JBOptionNames[option]); +} + + + +// =====[ DEPENDENCY ]===== + +public SharedPlugin __pl_gokz_jumpbeam = +{ + name = "gokz-jumpbeam", + file = "gokz-jumpbeam.smx", + #if defined REQUIRE_PLUGIN + required = 1, + #else + required = 0, + #endif +};
\ No newline at end of file diff --git a/sourcemod/scripting/include/gokz/jumpstats.inc b/sourcemod/scripting/include/gokz/jumpstats.inc new file mode 100644 index 0000000..452ae28 --- /dev/null +++ b/sourcemod/scripting/include/gokz/jumpstats.inc @@ -0,0 +1,442 @@ +/* + gokz-jumpstats Plugin Include + + Website: https://bitbucket.org/kztimerglobalteam/gokz +*/ + +#if defined _gokz_jumpstats_included_ +#endinput +#endif +#define _gokz_jumpstats_included_ + + + +// =====[ ENUMS ]===== + +enum +{ + JumpType_FullInvalid = -1, + JumpType_LongJump, + JumpType_Bhop, + JumpType_MultiBhop, + JumpType_WeirdJump, + JumpType_LadderJump, + JumpType_Ladderhop, + JumpType_Jumpbug, + JumpType_LowpreBhop, + JumpType_LowpreWeirdJump, + JumpType_Fall, + JumpType_Other, + JumpType_Invalid, + JUMPTYPE_COUNT +}; + +enum +{ + StrafeDirection_None, + StrafeDirection_Left, + StrafeDirection_Right +}; + +enum +{ + DistanceTier_None = 0, + DistanceTier_Meh, + DistanceTier_Impressive, + DistanceTier_Perfect, + DistanceTier_Godlike, + DistanceTier_Ownage, + DistanceTier_Wrecker, + DISTANCETIER_COUNT +}; + +enum JSOption: +{ + JSOPTION_INVALID = -1, + JSOption_JumpstatsMaster, + JSOption_MinChatTier, + JSOption_MinConsoleTier, + JSOption_MinSoundTier, + JSOption_FailstatsConsole, + JSOption_FailstatsChat, + JSOption_JumpstatsAlways, + JSOption_ExtendedChatReport, + JSOption_MinChatBroadcastTier, + JSOption_MinSoundBroadcastTier, + JSOPTION_COUNT +}; + +enum +{ + JSToggleOption_Disabled = 0, + JSToggleOption_Enabled, + JSTOGGLEOPTION_COUNT +}; + + + +// =====[ CONSTANTS ]===== + +#define JS_CFG_TIERS "cfg/sourcemod/gokz/gokz-jumpstats-tiers.cfg" +#define JS_CFG_SOUNDS "cfg/sourcemod/gokz/gokz-jumpstats-sounds.cfg" +#define JS_CFG_BROADCAST "cfg/sourcemod/gokz/gokz-jumpstats-broadcast.cfg" +#define JS_OPTION_CATEGORY "Jumpstats" +#define JS_MAX_LADDERJUMP_OFFSET 2.0 +#define JS_MAX_BHOP_GROUND_TICKS 5 +#define JS_MAX_DUCKBUG_RESET_TICKS 6 +#define JS_MAX_WEIRDJUMP_FALL_OFFSET 64.0 +#define JS_TOUCH_GRACE_TICKS 3 +#define JS_MAX_TRACKED_STRAFES 48 +#define JS_MIN_BLOCK_DISTANCE 186 +#define JS_MIN_LAJ_BLOCK_DISTANCE 50 +#define JS_MAX_LAJ_FAILSTAT_DISTANCE 250 +#define JS_TOP_RECORD_COUNT 20 +#define JS_MAX_JUMP_DISTANCE 500 +#define JS_FAILSTATS_MAX_TRACKED_TICKS 128 +#define JS_MIN_TELEPORT_DELAY 5 +#define JS_SPEED_MODIFICATION_TOLERANCE 0.1 +#define JS_OFFSET_EPSILON 0.03125 + +stock char gC_JumpTypes[JUMPTYPE_COUNT][] = +{ + "Long Jump", + "Bunnyhop", + "Multi Bunnyhop", + "Weird Jump", + "Ladder Jump", + "Ladderhop", + "Jumpbug", + "Lowpre Bunnyhop", + "Lowpre Weird Jump", + "Fall", + "Unknown Jump", + "Invalid Jump" +}; + +stock char gC_JumpTypesShort[JUMPTYPE_COUNT][] = +{ + "LJ", + "BH", + "MBH", + "WJ", + "LAJ", + "LAH", + "JB", + "LBH", + "LWJ", + "FL", + "UNK", + "INV" +}; + +stock char gC_JumpTypeKeys[JUMPTYPE_COUNT][] = +{ + "longjump", + "bhop", + "multibhop", + "weirdjump", + "ladderjump", + "ladderhop", + "jumpbug", + "lowprebhop", + "lowpreweirdjump", + "fall", + "unknown", + "invalid" +}; + +stock char gC_DistanceTiers[DISTANCETIER_COUNT][] = +{ + "None", + "Meh", + "Impressive", + "Perfect", + "Godlike", + "Ownage", + "Wrecker" +}; + +stock char gC_DistanceTierKeys[DISTANCETIER_COUNT][] = +{ + "none", + "meh", + "impressive", + "perfect", + "godlike", + "ownage", + "wrecker" +}; + +stock char gC_DistanceTierChatColours[DISTANCETIER_COUNT][] = +{ + "{grey}", + "{grey}", + "{blue}", + "{green}", + "{darkred}", + "{gold}", + "{orchid}" +}; + +stock char gC_JSOptionNames[JSOPTION_COUNT][] = +{ + "GOKZ JS - Master Switch", + "GOKZ JS - Chat Report", + "GOKZ JS - Console Report", + "GOKZ JS - Sounds", + "GOKZ JS - Failstats Console", + "GOKZ JS - Failstats Chat", + "GOKZ JS - Jumpstats Always", + "GOKZ JS - Ext Chat Report", + "GOKZ JS - Min Chat Broadcast", + "GOKZ JS - Min Sound Broadcast" +}; + +stock char gC_JSOptionDescriptions[JSOPTION_COUNT][] = +{ + "Master Switch for All Jumpstats Functionality - 0 = Disabled, 1 = Enabled", + "Minimum Tier for Jumpstats Chat Report - 0 = Disabled, 1 = Meh+, 2 = Impressive+, 3 = Perfect+, 4 = Godlike+, 5 = Ownage+, 6 = Wrecker", + "Minimum Tier for Jumpstats Console report - 0 = Disabled, 1 = Meh+, 2 = Impressive+, 3 = Perfect+, 4 = Godlike+, 5 = Ownage+, 6 = Wrecker", + "Minimum Tier for Jumpstats Sounds - 0 = Disabled, 2 = Impressive+, 3 = Perfect+, 4 = Godlike+, 5 = Ownage+, 6 = Wrecker", + "Print Failstats To Console - 0 = Disabled, 1 = Enabled", + "Print Failstats To Chat - 0 = Disabled, 1 = Enabled", + "Always show jumpstats, even for invalid jumps - 0 = Disabled, 1 = Enabled", + "Extended Chat Report - 0 = Disabled, 1 = Enabled", + "Minimum Jump Tier for Jumpstat Chat Broadcast - 0 = Disabled, 1 = Meh+, 2 = Impressive+, 3 = Perfect+, 4 = Godlike+, 5 = Ownage+, 6 = Wrecker", + "Minimum Jump Tier for Jumpstat Sound Broadcast - 0 = Disabled, 1 = Meh+, 2 = Impressive+, 3 = Perfect+, 4 = Godlike+, 5 = Ownage+, 6 = Wrecker" +}; + +stock char gI_JSOptionPhrases[JSOPTION_COUNT][] = +{ + "Options Menu - Jumpstats Master Switch", + "Options Menu - Jumpstats Chat Report", + "Options Menu - Jumpstats Console Report", + "Options Menu - Jumpstats Sounds", + "Options Menu - Failstats Console Report", + "Options Menu - Failstats Chat Report", + "Options Menu - Jumpstats Always", + "Options Menu - Extended Jump Chat Report", + "Options Menu - Minimal Jump Chat Broadcast Tier", + "Options Menu - Minimal Jump Sound Broadcast Tier" +}; + +stock int gI_JSOptionDefaults[JSOPTION_COUNT] = +{ + JSToggleOption_Enabled, + DistanceTier_Meh, + DistanceTier_Meh, + DistanceTier_Impressive, + JSToggleOption_Enabled, + JSToggleOption_Disabled, + JSToggleOption_Disabled, + JSToggleOption_Disabled, + DistanceTier_Ownage, + DistanceTier_None +}; + +stock int gI_JSOptionCounts[JSOPTION_COUNT] = +{ + JSTOGGLEOPTION_COUNT, + DISTANCETIER_COUNT, + DISTANCETIER_COUNT, + DISTANCETIER_COUNT, + JSTOGGLEOPTION_COUNT, + JSTOGGLEOPTION_COUNT, + JSTOGGLEOPTION_COUNT, + JSTOGGLEOPTION_COUNT, + DISTANCETIER_COUNT, + DISTANCETIER_COUNT +}; + + + +// =====[ STRUCTS ]===== + +enum struct Jump +{ + int jumper; + int block; + int crouchRelease; + int crouchTicks; + int deadair; + int duration; + int originalType; + int overlap; + int releaseW; + int strafes; + int type; + float deviation; + float distance; + float edge; + float height; + float maxSpeed; + float offset; + float preSpeed; + float sync; + float width; + + // For the 'always' stats + float miss; + + // We can't make a separate enum struct for that cause it won't let us + // index an array of enum structs. + int strafes_gainTicks[JS_MAX_TRACKED_STRAFES]; + int strafes_deadair[JS_MAX_TRACKED_STRAFES]; + int strafes_overlap[JS_MAX_TRACKED_STRAFES]; + int strafes_ticks[JS_MAX_TRACKED_STRAFES]; + float strafes_gain[JS_MAX_TRACKED_STRAFES]; + float strafes_loss[JS_MAX_TRACKED_STRAFES]; + float strafes_sync[JS_MAX_TRACKED_STRAFES]; + float strafes_width[JS_MAX_TRACKED_STRAFES]; +} + + + +// =====[ FORWARDS ]===== + +/** + * Called when a player begins their jump. + * + * @param client Client index. + * @param jumpType Type of jump. + */ +forward void GOKZ_JS_OnTakeoff(int client, int jumpType); + +/** + * Called when a player lands their jump. + * + * @param jump The jumpstats. + */ +forward void GOKZ_JS_OnLanding(Jump jump); + +/** + * Called when player's current jump has been declared an invalid jumpstat. + * + * @param client Client index. + */ +forward void GOKZ_JS_OnJumpInvalidated(int client); + +/** + * Called when a player fails a blockjump. + * + * @param jump The jumpstats. + */ +forward void GOKZ_JS_OnFailstat(Jump jump); + +/** + * Called when a player lands a jump and has always-on jumpstats enabled. + * + * @param jump The jumpstats. + */ +forward void GOKZ_JS_OnJumpstatAlways(Jump jump); + +/** + * Called when a player fails a jump and has always-on failstats enabled. + * + * @param jump The failstats. + */ +forward void GOKZ_JS_OnFailstatAlways(Jump jump); + + + +// =====[ NATIVES ]===== + +/** + * Gets the default jumpstats option value as set by a config file. + * + * @param option GOKZ Jumpstats option. + * @return Default option value. + */ +native int GOKZ_JS_GetDefaultOption(JSOption option); + +/** + * Declare a player's current jump an invalid jumpstat. + * + * @param client Client index. + */ +native void GOKZ_JS_InvalidateJump(int client); + + + +// =====[ STOCKS ]===== + +/** + * Returns whether an option is a gokz-jumpstats option. + * + * @param option Option name. + * @param optionEnum Variable to store enumerated gokz-jumpstats option (if it is one). + * @return Whether option is a gokz-jumpstats option. + */ +stock bool GOKZ_JS_IsJSOption(const char[] option, JSOption &optionEnum = JSOPTION_INVALID) +{ + for (JSOption i; i < JSOPTION_COUNT; i++) + { + if (StrEqual(option, gC_JSOptionNames[i])) + { + optionEnum = i; + return true; + } + } + return false; +} + +/** + * Gets the current value of a player's gokz-jumpstats option. + * + * @param client Client index. + * @param option gokz-jumpstats option. + * @return Current value of option. + */ +stock any GOKZ_JS_GetOption(int client, JSOption option) +{ + return GOKZ_GetOption(client, gC_JSOptionNames[option]); +} + +/** + * Sets a player's gokz-jumpstats option's value. + * + * @param client Client index. + * @param option gokz-jumpstats option. + * @param value New option value. + * @return Whether option was successfully set. + */ +stock bool GOKZ_JS_SetOption(int client, JSOption option, any value) +{ + return GOKZ_SetOption(client, gC_JSOptionNames[option], value); +} + +/** + * Increment an integer-type gokz-jumpstats option's value. + * Loops back to '0' if max value is exceeded. + * + * @param client Client index. + * @param option gokz-jumpstats option. + * @return Whether option was successfully set. + */ +stock bool GOKZ_JS_CycleOption(int client, JSOption option) +{ + return GOKZ_CycleOption(client, gC_JSOptionNames[option]); +} + + + +// =====[ DEPENDENCY ]===== + +public SharedPlugin __pl_gokz_jumpstats = +{ + name = "gokz-jumpstats", + file = "gokz-jumpstats.smx", + #if defined REQUIRE_PLUGIN + required = 1, + #else + required = 0, + #endif +}; + +#if !defined REQUIRE_PLUGIN +public void __pl_gokz_jumpstats_SetNTVOptional() +{ + MarkNativeAsOptional("GOKZ_JS_GetDefaultOption"); + MarkNativeAsOptional("GOKZ_JS_InvalidateJump"); +} +#endif diff --git a/sourcemod/scripting/include/gokz/kzplayer.inc b/sourcemod/scripting/include/gokz/kzplayer.inc new file mode 100644 index 0000000..8176d39 --- /dev/null +++ b/sourcemod/scripting/include/gokz/kzplayer.inc @@ -0,0 +1,584 @@ +/* + GOKZ KZPlayer Methodmap Include + + Website: https://bitbucket.org/kztimerglobalteam/gokz +*/ + +#if defined _gokz_kzplayer_included_ +#endinput +#endif +#define _gokz_kzplayer_included_ + +#include <movementapi> + +#include <gokz> + + + +methodmap KZPlayer < MovementAPIPlayer { + + public KZPlayer(int client) { + return view_as<KZPlayer>(MovementAPIPlayer(client)); + } + + + + // =====[ GENERAL ]===== + + property bool Valid { + public get() { + return IsValidClient(this.ID); + } + } + + property bool InGame { + public get() { + return IsClientInGame(this.ID); + } + } + + property bool Authorized { + public get() { + return IsClientAuthorized(this.ID); + } + } + + property bool Fake { + public get() { + return IsFakeClient(this.ID); + } + } + + property bool Alive { + public get() { + return IsPlayerAlive(this.ID); + } + } + + property ObsMode ObserverMode { + public get() { + return GetObserverMode(this.ID); + } + } + + property int ObserverTarget { + public get() { + return GetObserverTarget(this.ID); + } + } + + + + // =====[ CORE ]===== + #if defined _gokz_core_included_ + + public void StartTimer(int course) { + GOKZ_StartTimer(this.ID, course); + } + + public void EndTimer(int course) { + GOKZ_EndTimer(this.ID, course); + } + + public bool StopTimer() { + return GOKZ_StopTimer(this.ID); + } + + public void TeleportToStart() { + GOKZ_TeleportToStart(this.ID); + } + + public void TeleportToSearchStart(int course) { + GOKZ_TeleportToSearchStart(this.ID, course); + } + + public void TeleportToEnd(int course) { + GOKZ_TeleportToEnd(this.ID, course); + } + + property StartPositionType StartPositionType { + public get() { + return GOKZ_GetStartPositionType(this.ID); + } + } + + public void MakeCheckpoint() { + GOKZ_MakeCheckpoint(this.ID); + } + + property bool CanMakeCheckpoint { + public get() { + return GOKZ_GetCanMakeCheckpoint(this.ID); + } + } + + public void TeleportToCheckpoint() { + GOKZ_TeleportToCheckpoint(this.ID); + } + + property bool CanTeleportToCheckpoint { + public get() { + return GOKZ_GetCanTeleportToCheckpoint(this.ID); + } + } + + public void PrevCheckpoint() { + GOKZ_PrevCheckpoint(this.ID); + } + + property bool CanPrevCheckpoint { + public get() { + return GOKZ_GetCanPrevCheckpoint(this.ID); + } + } + + public void NextCheckpoint() { + GOKZ_NextCheckpoint(this.ID); + } + + property bool CanNextCheckpoint { + public get() { + return GOKZ_GetCanNextCheckpoint(this.ID); + } + } + + public void UndoTeleport() { + GOKZ_UndoTeleport(this.ID); + } + + property bool CanUndoTeleport { + public get() { + return GOKZ_GetCanUndoTeleport(this.ID); + } + } + + public void Pause() { + GOKZ_Pause(this.ID); + } + + property bool CanPause { + public get() { + return GOKZ_GetCanPause(this.ID); + } + } + + public void Resume() { + GOKZ_Resume(this.ID); + } + + property bool CanResume { + public get() { + return GOKZ_GetCanResume(this.ID); + } + } + + public void TogglePause() { + GOKZ_TogglePause(this.ID); + } + + public void PlayErrorSound() { + GOKZ_PlayErrorSound(this.ID); + } + + property bool TimerRunning { + public get() { + return GOKZ_GetTimerRunning(this.ID); + } + } + + property int Course { + public get() { + return GOKZ_GetCourse(this.ID); + } + } + + property bool Paused { + public get() { + return GOKZ_GetPaused(this.ID); + } + public set(bool pause) { + if (pause) { + this.Pause(); + } + else { + this.Resume(); + } + } + } + + property bool CanTeleportToStart { + public get() { + return GOKZ_GetCanTeleportToStartOrEnd(this.ID); + } + } + + property float Time { + public get() { + return GOKZ_GetTime(this.ID); + } + public set(float value) { + GOKZ_SetTime(this.ID, value); + } + } + + property int CheckpointCount { + public get() { + return GOKZ_GetCheckpointCount(this.ID); + } + public set(int cpCount) { + GOKZ_SetCheckpointCount(this.ID, cpCount); + } + } + + property ArrayList CheckpointData { + public get() { + return GOKZ_GetCheckpointData(this.ID); + } + public set(ArrayList checkpoints) { + GOKZ_SetCheckpointData(this.ID, checkpoints, GOKZ_CHECKPOINT_VERSION); + } + } + + property int TeleportCount { + public get() { + return GOKZ_GetTeleportCount(this.ID); + } + public set(int value) { + GOKZ_SetTeleportCount(this.ID, value); + } + } + + property int TimeType { + public get() { + return GOKZ_GetTimeType(this.ID); + } + } + + property bool GOKZHitPerf { + public get() { + return GOKZ_GetHitPerf(this.ID); + } + public set(bool value) { + GOKZ_SetHitPerf(this.ID, value); + } + } + + property float GOKZTakeoffSpeed { + public get() { + return GOKZ_GetTakeoffSpeed(this.ID); + } + public set(float value) { + GOKZ_SetTakeoffSpeed(this.ID, value); + } + } + + property bool ValidJump { + public get() { + return GOKZ_GetValidJump(this.ID); + } + } + + public any GetOption(const char[] option) { + return GOKZ_GetOption(this.ID, option); + } + + public bool SetOption(const char[] option, any value) { + return GOKZ_SetOption(this.ID, option, value); + } + + public bool CycleOption(const char[] option) { + return GOKZ_CycleOption(this.ID, option); + } + + public any GetCoreOption(Option option) { + return GOKZ_GetCoreOption(this.ID, option); + } + + public bool SetCoreOption(Option option, int value) { + return GOKZ_SetCoreOption(this.ID, option, value); + } + + public bool CycleCoreOption(Option option) { + return GOKZ_CycleCoreOption(this.ID, option); + } + + property int Mode { + public get() { + return this.GetCoreOption(Option_Mode); + } + public set(int value) { + this.SetCoreOption(Option_Mode, value); + } + } + + property int Style { + public get() { + return this.GetCoreOption(Option_Style); + } + public set(int value) { + this.SetCoreOption(Option_Style, value); + } + } + + property int CheckpointMessages { + public get() { + return this.GetCoreOption(Option_CheckpointMessages); + } + public set(int value) { + this.SetCoreOption(Option_CheckpointMessages, value); + } + } + + property int CheckpointSounds { + public get() { + return this.GetCoreOption(Option_CheckpointSounds); + } + public set(int value) { + this.SetCoreOption(Option_CheckpointSounds, value); + } + } + + property int TeleportSounds { + public get() { + return this.GetCoreOption(Option_TeleportSounds); + } + public set(int value) { + this.SetCoreOption(Option_TeleportSounds, value); + } + } + + property int ErrorSounds { + public get() { + return this.GetCoreOption(Option_ErrorSounds); + } + public set(int value) { + this.SetCoreOption(Option_ErrorSounds, value); + } + } + + #endif + // =====[ END CORE ]===== + + + + // =====[ HUD ]===== + #if defined _gokz_hud_included_ + + public any GetHUDOption(HUDOption option) { + return GOKZ_HUD_GetOption(this.ID, option); + } + + public bool SetHUDOption(HUDOption option, any value) { + return GOKZ_HUD_SetOption(this.ID, option, value); + } + + public bool CycleHUDOption(HUDOption option) { + return GOKZ_HUD_CycleOption(this.ID, option); + } + + property int TPMenu { + public get() { + return this.GetHUDOption(HUDOption_TPMenu); + } + public set(int value) { + this.SetHUDOption(HUDOption_TPMenu, value); + } + } + + property int InfoPanel { + public get() { + return this.GetHUDOption(HUDOption_InfoPanel); + } + public set(int value) { + this.SetHUDOption(HUDOption_InfoPanel, value); + } + } + + property int ShowKeys { + public get() { + return this.GetHUDOption(HUDOption_ShowKeys); + } + public set(int value) { + this.SetHUDOption(HUDOption_ShowKeys, value); + } + } + + property int TimerText { + public get() { + return this.GetHUDOption(HUDOption_TimerText); + } + public set(int value) { + this.SetHUDOption(HUDOption_TimerText, value); + } + } + + property int TimerStyle { + public get() { + return this.GetHUDOption(HUDOption_TimerStyle); + } + public set(int value) { + this.SetHUDOption(HUDOption_TimerStyle, value); + } + } + + property int SpeedText { + public get() { + return this.GetHUDOption(HUDOption_SpeedText); + } + public set(int value) { + this.SetHUDOption(HUDOption_SpeedText, value); + } + } + + property int ShowWeapon { + public get() { + return this.GetHUDOption(HUDOption_ShowWeapon); + } + public set(int value) { + this.SetHUDOption(HUDOption_ShowWeapon, value); + } + } + + property int ReplayControls { + public get() { + return this.GetHUDOption(HUDOption_ShowControls); + } + public set(int value) { + this.SetHUDOption(HUDOption_ShowControls, value); + } + } + + property int ShowSpectators { + public get() { + return this.GetHUDOption(HUDOption_ShowSpectators); + } + public set(int value) { + this.SetHUDOption(HUDOption_ShowSpectators, value); + } + } + + property int SpecListPosition { + public get() { + return this.GetHUDOption(HUDOption_SpecListPosition); + } + public set(int value){ + this.SetHUDOption(HUDOption_SpecListPosition, value); + } + } + + property bool MenuShowing { + public get() { + return GOKZ_HUD_GetMenuShowing(this.ID); + } + public set(bool value) { + GOKZ_HUD_SetMenuShowing(this.ID, value); + } + } + property int DynamicMenu { + public get() { + return this.GetHUDOption(HUDOption_DynamicMenu); + } + public set(int value) { + this.SetHUDOption(HUDOption_DynamicMenu, value); + } + } + #endif + // =====[ END HUD ]===== + + + + // =====[ PISTOL ]===== + #if defined _gokz_pistol_included_ + + property int Pistol { + public get() { + return this.GetOption(PISTOL_OPTION_NAME); + } + public set(int value) { + this.SetOption(PISTOL_OPTION_NAME, value); + } + } + + #endif + // =====[ END PISTOL ]===== + + + + // =====[ JUMP BEAM ]===== + #if defined _gokz_jumpbeam_included_ + + public any GetJBOption(JBOption option) { + return GOKZ_JB_GetOption(this.ID, option); + } + + public bool SetJBOption(JBOption option, any value) { + return GOKZ_JB_SetOption(this.ID, option, value); + } + + public bool CycleJBOption(JBOption option) { + return GOKZ_JB_CycleOption(this.ID, option); + } + + property int JBType { + public get() { + return this.GetJBOption(JBOption_Type); + } + public set(int value) { + this.SetJBOption(JBOption_Type, value); + } + } + + #endif + // =====[ END JUMP BEAM ]===== + + + + // =====[ TIPS ]===== + #if defined _gokz_tips_included_ + + property int Tips { + public get() { + return this.GetOption(TIPS_OPTION_NAME); + } + public set(int value) { + this.SetOption(TIPS_OPTION_NAME, value); + } + } + + #endif + // =====[ END TIPS ]===== + + + + // =====[ QUIET ]===== + #if defined _gokz_quiet_included_ + + property int ShowPlayers { + public get() { + return this.GetOption(gC_QTOptionNames[QTOption_ShowPlayers]); + } + public set(int value) { + this.SetOption(gC_QTOptionNames[QTOption_ShowPlayers], value); + } + } + + #endif + // =====[ END QUIET ]===== + + + + // =====[ SLAY ON END ]===== + #if defined _gokz_slayonend_included_ + + property int SlayOnEnd { + public get() { + return this.GetOption(SLAYONEND_OPTION_NAME); + } + public set(int value) { + this.SetOption(SLAYONEND_OPTION_NAME, value); + } + } + + #endif + // =====[ END SLAY ON END ]===== +}
\ No newline at end of file diff --git a/sourcemod/scripting/include/gokz/localdb.inc b/sourcemod/scripting/include/gokz/localdb.inc new file mode 100644 index 0000000..472a120 --- /dev/null +++ b/sourcemod/scripting/include/gokz/localdb.inc @@ -0,0 +1,353 @@ +/* + gokz-localdb Plugin Include + + Website: https://bitbucket.org/kztimerglobalteam/gokz +*/ + +#if defined _gokz_localdb_included_ +#endinput +#endif +#define _gokz_localdb_included_ + + + +// =====[ ENUMS ]===== + +enum DatabaseType +{ + DatabaseType_None = -1, + DatabaseType_MySQL, + DatabaseType_SQLite +}; + +enum +{ + JumpstatDB_Lookup_JumpID = 0, + JumpstatDB_Lookup_Distance, + JumpstatDB_Lookup_Block +}; + +enum +{ + JumpstatDB_FindPlayer_SteamID32 = 0, + JumpstatDB_FindPlayer_Alias +}; + +enum +{ + JumpstatDB_Top20_JumpID = 0, + JumpstatDB_Top20_SteamID, + JumpstatDB_Top20_Alias, + JumpstatDB_Top20_Block, + JumpstatDB_Top20_Distance, + JumpstatDB_Top20_Strafes, + JumpstatDB_Top20_Sync, + JumpstatDB_Top20_Pre, + JumpstatDB_Top20_Max, + JumpstatDB_Top20_Air +}; + +enum +{ + JumpstatDB_PBMenu_JumpID = 0, + JumpstatDB_PBMenu_JumpType, + JumpstatDB_PBMenu_Distance, + JumpstatDB_PBMenu_Strafes, + JumpstatDB_PBMenu_Sync, + JumpstatDB_PBMenu_Pre, + JumpstatDB_PBMenu_Max, + JumpstatDB_PBMenu_Air +}; + +enum +{ + JumpstatDB_BlockPBMenu_JumpID = 0, + JumpstatDB_BlockPBMenu_JumpType, + JumpstatDB_BlockPBMenu_Block, + JumpstatDB_BlockPBMenu_Distance, + JumpstatDB_BlockPBMenu_Strafes, + JumpstatDB_BlockPBMenu_Sync, + JumpstatDB_BlockPBMenu_Pre, + JumpstatDB_BlockPBMenu_Max, + JumpstatDB_BlockPBMenu_Air +}; + +enum +{ + JumpstatDB_Cache_Distance = 0, + JumpstatDB_Cache_Block, + JumpstatDB_Cache_BlockDistance, + JUMPSTATDB_CACHE_COUNT +}; + +enum +{ + TimerSetupDB_GetVBPos_SteamID = 0, + TimerSetupDB_GetVBPos_MapID, + TimerSetupDB_GetVBPos_Course, + TimerSetupDB_GetVBPos_IsStart, + TimerSetupDB_GetVBPos_PositionX, + TimerSetupDB_GetVBPos_PositionY, + TimerSetupDB_GetVBPos_PositionZ +}; + +enum +{ + TimerSetupDB_GetStartPos_SteamID = 0, + TimerSetupDB_GetStartPos_MapID, + TimerSetupDB_GetStartPos_PositionX, + TimerSetupDB_GetStartPos_PositionY, + TimerSetupDB_GetStartPos_PositionZ, + TimerSetupDB_GetStartPos_Angle0, + TimerSetupDB_GetStartPos_Angle1 +}; + +enum DBOption: +{ + DBOption_AutoLoadTimerSetup = 0, + DBOPTION_COUNT +}; + +enum +{ + DBOption_Disabled = 0, + DBOption_Enabled, + DBOPTIONBOOL_COUNT +}; + + + +// =====[ CONSTANTS ]===== + +#define GOKZ_DB_JS_DISTANCE_PRECISION 10000 +#define GOKZ_DB_JS_SYNC_PRECISION 100 +#define GOKZ_DB_JS_PRE_PRECISION 100 +#define GOKZ_DB_JS_MAX_PRECISION 100 +#define GOKZ_DB_JS_AIRTIME_PRECISION 10000 +#define GOKZ_DB_JS_MAX_JUMPS_PER_PLAYER 100 + +stock char gC_DBOptionNames[DBOPTION_COUNT][] = +{ + "GOKZ DB - Auto Load Setup" +}; + +stock char gC_DBOptionDescriptions[DBOPTION_COUNT][] = +{ + "Automatically load timer setup on map start - 0 = Disabled, 1 = Enabled" +} + +stock int gI_DBOptionDefaultValues[DBOPTION_COUNT] = +{ + DBOption_Disabled +}; + +stock int gI_DBOptionCounts[DBOPTION_COUNT] = +{ + DBOPTIONBOOL_COUNT +}; + +stock char gC_DBOptionPhrases[DBOPTION_COUNT][] = +{ + "Options Menu - Auto Load Timer Setup" +}; + + + +// =====[ TYPES ]===== + +typeset GetVBPositionCallback +{ + function Action(int client, const float position[3], int course, bool isStart); +}; + +typeset GetStartPositionCallback +{ + function Action(int client, const float position[3], const float angles[3]); +}; + + + +// =====[ FORWARDS ]===== + +/** + * Called when gokz-localdb has connected to the database. + * Use GOKZ_DB_GetDatabase to get a clone of the database handle. + * + * @param DBType Database type. + */ +forward void GOKZ_DB_OnDatabaseConnect(DatabaseType DBType); + +/** + * Called when a player is ready for database interaction. + * At this point, the player is present and updated in the "Players" table. + * + * @param client Client index. + * @param steamID SteamID32 of the player (from GetSteamAccountID()). + * @param cheater Whether player is marked as a cheater in the database. + */ +forward void GOKZ_DB_OnClientSetup(int client, int steamID, bool cheater); + +/** + * Called when the current map is ready for database interaction. + * At this point, the map is present and updated in the "Maps" table. + * + * @param mapID MapID from the "Maps" table. + */ +forward void GOKZ_DB_OnMapSetup(int mapID); + +/** + * Called when a time has been inserted into the database. + * + * @param client Client index. + * @param steamID SteamID32 of the player (from GetSteamAccountID()). + * @param mapID MapID from the "Maps" table. + * @param course Course number e.g. 0=main, 1='bonus1' etc. + * @param mode Player's movement mode. + * @param style Player's movement style. + * @param runTimeMS Player's end time in milliseconds. + * @param teleportsUsed Number of teleports used by player. + */ +forward void GOKZ_DB_OnTimeInserted( + int client, + int steamID, + int mapID, + int course, + int mode, + int style, + int runTimeMS, + int teleportsUsed); + +/** + * Called when jumpstat PB has been achieved. + * + * @param client Client index. + * @param jumptype Type of the jump. + * @param mode Mode the jump was performed in. + * @param distance Distance jumped. + * @param block The size of the block jumped across. + * @param strafes The amount of strafes used. + * @param sync Keyboard/mouse synchronisation of the jump. + * @param pre Speed at takeoff. + * @param max Maximum speed during the jump. + * @param airtime Amount of time spend airborne. + */ +forward void GOKZ_DB_OnJumpstatPB( + int client, + int jumptype, + int mode, + float distance, + int block, + int strafes, + float sync, + float pre, + float max, + int airtime); + + +// =====[ NATIVES ]===== + +/** + * Gets a clone of the GOKZ local database handle. + * + * @param database Database handle, or null if connection hasn't been made. + */ +native Database GOKZ_DB_GetDatabase(); + +/** + * Gets the GOKZ local database type. + * + * @return Database type. + */ +native DatabaseType GOKZ_DB_GetDatabaseType(); + +/** + * Gets whether client has been set up for GOKZ Local DB. + * + * @param client Client index. + * @return Whether GOKZ Local DB has set up the client. + */ +native bool GOKZ_DB_IsClientSetUp(int client); + +/** + * Gets whether GOKZ Local DB is set up for the current map. + * + * @return Whether GOKZ Local DB has set up the current map. + */ +native bool GOKZ_DB_IsMapSetUp(); + +/** + * Gets the current map's MapID as in the "Maps" table. + * + * @return MapID from the "Maps" table. + */ +native int GOKZ_DB_GetCurrentMapID(); + +/** + * Gets whether player is marked as a cheater in the database. + * + * @param client Client index. + * @return Whether player is marked as a cheater in the database. + */ +native bool GOKZ_DB_IsCheater(int client); + +/** + * Sets wheter player is marked as a cheater in the database. + * + * @param client Client index. + * @param cheater Whether to mark the player as a cheater. + */ +native void GOKZ_DB_SetCheater(int client, bool cheater); + + + +// =====[ STOCKS ]===== + +/** + * Converts a time float (seconds) to an integer (milliseconds). + * + * @param time Time in seconds. + * @return Time in milliseconds. + */ +stock int GOKZ_DB_TimeFloatToInt(float time) +{ + return RoundFloat(time * 1000.0); +} + +/** + * Converts a time integer (milliseconds) to a float (seconds). + * + * @param time Time in milliseconds. + * @return Time in seconds. + */ +stock float GOKZ_DB_TimeIntToFloat(int time) +{ + return time / 1000.0; +} + + + +// =====[ DEPENDENCY ]===== + +public SharedPlugin __pl_gokz_localdb = +{ + name = "gokz-localdb", + file = "gokz-localdb.smx", + #if defined REQUIRE_PLUGIN + required = 1, + #else + required = 0, + #endif +}; + +#if !defined REQUIRE_PLUGIN +public void __pl_gokz_localdb_SetNTVOptional() +{ + MarkNativeAsOptional("GOKZ_DB_GetDatabase"); + MarkNativeAsOptional("GOKZ_DB_GetDatabaseType"); + MarkNativeAsOptional("GOKZ_DB_IsClientSetUp"); + MarkNativeAsOptional("GOKZ_DB_IsMapSetUp"); + MarkNativeAsOptional("GOKZ_DB_GetCurrentMapID"); + MarkNativeAsOptional("GOKZ_DB_IsCheater"); + MarkNativeAsOptional("GOKZ_DB_SetCheater"); +} +#endif diff --git a/sourcemod/scripting/include/gokz/localranks.inc b/sourcemod/scripting/include/gokz/localranks.inc new file mode 100644 index 0000000..914c6cb --- /dev/null +++ b/sourcemod/scripting/include/gokz/localranks.inc @@ -0,0 +1,176 @@ +/* + gokz-localranks Plugin Include + + Website: https://bitbucket.org/kztimerglobalteam/gokz +*/ + +#if defined _gokz_localranks_included_ +#endinput +#endif +#define _gokz_localranks_included_ + + + +// =====[ ENUMS ]===== + +enum +{ + RecordType_Nub = 0, + RecordType_Pro, + RecordType_NubAndPro, + RECORDTYPE_COUNT +}; + + + +// =====[ CONSTANTS ]===== + +#define LR_CFG_MAP_POOL "cfg/sourcemod/gokz/gokz-localranks-mappool.cfg" +#define LR_CFG_SOUNDS "cfg/sourcemod/gokz/gokz-localranks-sounds.cfg" +#define LR_COMMAND_COOLDOWN 2.5 +#define LR_MAP_TOP_CUTOFF 20 +#define LR_PLAYER_TOP_CUTOFF 20 + + + +// =====[ FORWARDS ]===== + +/** + * Called when a player's time has been processed by GOKZ Local Ranks. + * + * @param client Client index. + * @param steamID SteamID32 of the player (from GetSteamAccountID()). + * @param mapID MapID from the "Maps" database table. + * @param course Course number e.g. 0=main, 1='bonus1' etc. + * @param mode Player's movement mode. + * @param style Player's movement style. + * @param runTime Player's end time. + * @param teleportsUsed Number of teleportsUsed used by player. + * @param firstTime Whether this is player's first time on this course. + * @param pbDiff Difference between new time and PB in seconds (-'ve means beat PB). + * @param rank New rank of the player's PB time. + * @param maxRank New total number of players with times. + * @param firstTimePro Whether this is player's first PRO time on this course. + * @param pbDiffPro Difference between new time and PRO PB in seconds (-'ve means beat PB). + * @param rankPro New rank of the player's PB PRO time. + * @param maxRankPro New total number of players with PRO times. + */ +forward void GOKZ_LR_OnTimeProcessed( + int client, + int steamID, + int mapID, + int course, + int mode, + int style, + float runTime, + int teleportsUsed, + bool firstTime, + float pbDiff, + int rank, + int maxRank, + bool firstTimePro, + float pbDiffPro, + int rankPro, + int maxRankPro); + +/** + * Called when a player sets a new local record. + * + * @param client Client index. + * @param steamID SteamID32 of the player (from GetSteamAccountID()). + * @param mapID MapID from the "Maps" table. + * @param course Course number e.g. 0=main, 1='bonus1' etc. + * @param mode Player's movement mode. + * @param style Player's movement style. + * @param recordType Type of record. + */ +forward void GOKZ_LR_OnNewRecord( + int client, + int steamID, + int mapID, + int course, + int mode, + int style, + int recordType, + float pbDiff, + int teleportsUsed); + +/** + * Called when a player misses the server record time. + * Is called regardless of player's current run type. + * + * @param client Client index. + * @param recordTime Record time missed. + * @param course Course number e.g. 0=main, 1='bonus1' etc. + * @param mode Player's movement mode. + * @param style Player's movement style. + * @param recordType Type of record. + */ +forward void GOKZ_LR_OnRecordMissed(int client, float recordTime, int course, int mode, int style, int recordType); + +/** + * Called when a player misses their personal best time. + * Is called regardless of player's current run type. + * + * @param client Client index. + * @param pbTime Personal best time missed. + * @param course Course number e.g. 0=main, 1='bonus1' etc. + * @param mode Player's movement mode. + * @param style Player's movement style. + * @param recordType Type of record. + */ +forward void GOKZ_LR_OnPBMissed(int client, float pbTime, int course, int mode, int style, int recordType); + + + +// =====[ NATIVES ]===== + +/** + * Gets whether player has missed the server record time. + * + * @param client Client index. + * @param timeType Which record time i.e. NUB or PRO. + * @return Whether player has missed the server record time. + */ +native bool GOKZ_LR_GetRecordMissed(int client, int timeType); + +/** + * Gets whether player has missed their personal best time. + * + * @param client Client index. + * @param timeType Which PB time i.e. NUB or PRO. + * @return Whether player has missed their PB time. + */ +native bool GOKZ_LR_GetPBMissed(int client, int timeType); + +/** + * Reopens the map top menu with the already selected parameters. + * Don't use if the client hasn't opened the map top menu before. + * + * @param client Client index. + */ +native void GOKZ_LR_ReopenMapTopMenu(int client); + + + +// =====[ DEPENDENCY ]===== + +public SharedPlugin __pl_gokz_localranks = +{ + name = "gokz-localranks", + file = "gokz-localranks.smx", + #if defined REQUIRE_PLUGIN + required = 1, + #else + required = 0, + #endif +}; + +#if !defined REQUIRE_PLUGIN +public void __pl_gokz_localranks_SetNTVOptional() +{ + MarkNativeAsOptional("GOKZ_LR_GetRecordMissed"); + MarkNativeAsOptional("GOKZ_LR_GetPBMissed"); + MarkNativeAsOptional("GOKZ_LR_ReopenMapTopMenu"); +} +#endif
\ No newline at end of file diff --git a/sourcemod/scripting/include/gokz/momsurffix.inc b/sourcemod/scripting/include/gokz/momsurffix.inc new file mode 100644 index 0000000..65f603e --- /dev/null +++ b/sourcemod/scripting/include/gokz/momsurffix.inc @@ -0,0 +1,23 @@ +/* + gokz-momsurffix Plugin Include + + Website: https://bitbucket.org/kztimerglobalteam/gokz +*/ + +#if defined _gokz_momsurffix_included_ +#endinput +#endif +#define _gokz_momsurffix_included_ + +// =====[ DEPENDENCY ]===== + +public SharedPlugin __pl_gokz_momsurffix = +{ + name = "gokz-momsurffix", + file = "gokz-momsurffix.smx", + #if defined REQUIRE_PLUGIN + required = 1, + #else + required = 0, + #endif +};
\ No newline at end of file diff --git a/sourcemod/scripting/include/gokz/paint.inc b/sourcemod/scripting/include/gokz/paint.inc new file mode 100644 index 0000000..19f4fb5 --- /dev/null +++ b/sourcemod/scripting/include/gokz/paint.inc @@ -0,0 +1,114 @@ +/* + gokz-paint Plugin Include + + Website: https://bitbucket.org/kztimerglobalteam/gokz +*/ + +#if defined _gokz_paint_included_ +#endinput +#endif +#define _gokz_paint_included_ + + + +// =====[ ENUMS ]===== + +enum PaintOption: +{ + PAINTOPTION_INVALID = -1, + PaintOption_Color, + PaintOption_Size, + PAINTOPTION_COUNT +}; + +enum +{ + PaintColor_Red = 0, + PaintColor_White, + PaintColor_Black, + PaintColor_Blue, + PaintColor_Brown, + PaintColor_Green, + PaintColor_Yellow, + PaintColor_Purple, + PAINTCOLOR_COUNT +}; + +enum +{ + PaintSize_Small = 0, + PaintSize_Medium, + PaintSize_Big, + PAINTSIZE_COUNT +}; + + + +// =====[ CONSTANTS ]===== + +#define PAINT_OPTION_CATEGORY "Paint" +#define MIN_PAINT_SPACING 1.0 + +stock char gC_PaintOptionNames[PAINTOPTION_COUNT][] = +{ + "GOKZ Paint - Color", + "GOKZ Paint - Size" +}; + +stock char gC_PaintOptionDescriptions[PAINTOPTION_COUNT][] = +{ + "Paint Color", + "Paint Size - 0 = Small, 1 = Medium, 2 = Big" +}; + +stock char gC_PaintOptionPhrases[PAINTOPTION_COUNT][] = +{ + "Options Menu - Paint Color", + "Options Menu - Paint Size" +}; + +stock int gI_PaintOptionCounts[PAINTOPTION_COUNT] = +{ + PAINTCOLOR_COUNT, + PAINTSIZE_COUNT +}; + +stock int gI_PaintOptionDefaults[PAINTOPTION_COUNT] = +{ + PaintColor_Red, + PaintSize_Medium +}; + +stock char gC_PaintColorPhrases[PAINTCOLOR_COUNT][] = +{ + "Options Menu - Red", + "Options Menu - White", + "Options Menu - Black", + "Options Menu - Blue", + "Options Menu - Brown", + "Options Menu - Green", + "Options Menu - Yellow", + "Options Menu - Purple" +}; + +stock char gC_PaintSizePhrases[PAINTSIZE_COUNT][] = +{ + "Options Menu - Small", + "Options Menu - Medium", + "Options Menu - Big" +}; + + + +// =====[ DEPENDENCY ]===== + +public SharedPlugin __pl_gokz_paint = +{ + name = "gokz-paint", + file = "gokz-paint.smx", + #if defined REQUIRE_PLUGIN + required = 1, + #else + required = 0, + #endif +}; diff --git a/sourcemod/scripting/include/gokz/pistol.inc b/sourcemod/scripting/include/gokz/pistol.inc new file mode 100644 index 0000000..1edd5f9 --- /dev/null +++ b/sourcemod/scripting/include/gokz/pistol.inc @@ -0,0 +1,93 @@ +/* + gokz-pistol Plugin Include + + Website: https://bitbucket.org/kztimerglobalteam/gokz +*/ + +#if defined _gokz_pistol_included_ +#endinput +#endif +#define _gokz_pistol_included_ + + + +// =====[ ENUMS ]===== + +enum +{ + Pistol_Disabled = 0, + Pistol_USPS, + Pistol_Glock18, + Pistol_DualBerettas, + Pistol_P250, + Pistol_FiveSeveN, + Pistol_Tec9, + Pistol_CZ75Auto, + Pistol_DesertEagle, + Pistol_R8Revolver, + PISTOL_COUNT +}; + + + +// =====[ CONSTANTS ]===== + +#define PISTOL_OPTION_NAME "GOKZ - Pistol" +#define PISTOL_OPTION_DESCRIPTION "Pistol - 0 = Disabled, 1 = USP-S / P2000, 2 = Glock-18, 3 = Dual Berettas, 4 = P250, 5 = Five-SeveN, 6 = Tec-9, 7 = CZ75-Auto, 8 = Desert Eagle, 9 = R8 Revolver" + +stock char gC_PistolNames[PISTOL_COUNT][] = +{ + "", // Disabled + "USP-S / P2000", + "Glock-18", + "Dual Berettas", + "P250", + "Five-SeveN", + "Tec-9", + "CZ75-Auto", + "Desert Eagle", + "R8 Revolver" +}; + +stock char gC_PistolClassNames[PISTOL_COUNT][] = +{ + "", // Disabled + "weapon_hkp2000", + "weapon_glock", + "weapon_elite", + "weapon_p250", + "weapon_fiveseven", + "weapon_tec9", + "weapon_cz75a", + "weapon_deagle", + "weapon_revolver" +}; + +stock int gI_PistolTeams[PISTOL_COUNT] = +{ + CS_TEAM_NONE, // Disabled + CS_TEAM_CT, + CS_TEAM_T, + CS_TEAM_NONE, + CS_TEAM_NONE, + CS_TEAM_CT, + CS_TEAM_T, + CS_TEAM_NONE, + CS_TEAM_NONE, + CS_TEAM_NONE +}; + + + +// =====[ DEPENDENCY ]===== + +public SharedPlugin __pl_gokz_pistol = +{ + name = "gokz-pistol", + file = "gokz-pistol.smx", + #if defined REQUIRE_PLUGIN + required = 1, + #else + required = 0, + #endif +};
\ No newline at end of file diff --git a/sourcemod/scripting/include/gokz/profile.inc b/sourcemod/scripting/include/gokz/profile.inc new file mode 100644 index 0000000..70d314a --- /dev/null +++ b/sourcemod/scripting/include/gokz/profile.inc @@ -0,0 +1,291 @@ +/* + gokz-profile Plugin Include + + Website: https://bitbucket.org/kztimerglobalteam/gokz +*/ + +#if defined _gokz_profile_included_ +#endinput +#endif +#define _gokz_profile_included_ + + +// =====[ RANKS ]===== + +#define RANK_COUNT 23 + +stock int gI_rankThreshold[MODE_COUNT][RANK_COUNT] = { + { + 0, + 1, + 500, + 1000, + + 2000, + 5000, + 10000, + + 20000, + 30000, + 40000, + + 60000, + 70000, + 80000, + + 100000, + 120000, + 140000, + + 160000, + 180000, + 200000, + + 250000, + 300000, + 400000, + 600000 + }, + { + 0, + 1, + 500, + 1000, + + 2000, + 5000, + 10000, + + 20000, + 30000, + 40000, + + 60000, + 70000, + 80000, + + 100000, + 120000, + 150000, + + 200000, + 230000, + 250000, + + 300000, + 400000, + 500000, + 800000 + }, + { + 0, + 1, + 500, + 1000, + + 2000, + 5000, + 10000, + + 20000, + 30000, + 40000, + + 60000, + 70000, + 80000, + + 100000, + 120000, + 150000, + + 200000, + 230000, + 250000, + + 400000, + 600000, + 800000, + 1000000 + }, +}; + +stock char gC_rankName[RANK_COUNT][] = { + "New", + "Beginner-", + "Beginner", + "Beginner+", + "Amateur-", + "Amateur", + "Amateur+", + "Casual-", + "Casual", + "Casual+", + "Regular-", + "Regular", + "Regular+", + "Skilled-", + "Skilled", + "Skilled+", + "Expert-", + "Expert", + "Expert+", + "Semipro", + "Pro", + "Master", + "Legend" +}; + +stock char gC_rankColor[RANK_COUNT][] = { + "{grey}", + "{default}", + "{default}", + "{default}", + "{blue}", + "{blue}", + "{blue}", + "{lightgreen}", + "{lightgreen}", + "{lightgreen}", + "{green}", + "{green}", + "{green}", + "{purple}", + "{purple}", + "{purple}", + "{orchid}", + "{orchid}", + "{orchid}", + "{lightred}", + "{lightred}", + "{red}", + "{gold}" +}; + + +// =====[ ENUMS ]===== + +enum ProfileOption: +{ + PROFILEOPTION_INVALID = -1, + ProfileOption_ShowRankChat, + ProfileOption_ShowRankClanTag, + ProfileOption_TagType, + PROFILEOPTION_COUNT +}; + +enum +{ + ProfileOptionBool_Disabled = 0, + ProfileOptionBool_Enabled, + PROFILEOPTIONBOOL_COUNT +}; + +enum +{ + ProfileTagType_Rank = 0, + ProfileTagType_Admin, + ProfileTagType_VIP, + PROFILETAGTYPE_COUNT +}; + + + +// =====[ CONSTANTS ]===== + +stock char gC_ProfileOptionNames[PROFILEOPTION_COUNT][] = +{ + "GOKZ Profile - Show Rank Chat", + "GOKZ Profile - Show Rank Clan", + "GOKZ Profile - Tag Type" +}; + +stock char gC_ProfileOptionDescriptions[PROFILEOPTION_COUNT][] = +{ + "Show Rank Tag in Chat - 0 = Disabled, 1 = Enabled", + "Show Rank in Clan - 0 = Disabled, 1 = Enabled", + "Type of Tag to Show - 0 = Rank, 1 = Admin, 2 = VIP" +}; + +stock char gC_ProfileOptionPhrases[PROFILEOPTION_COUNT][] = +{ + "Options Menu - Show Rank Chat", + "Options Menu - Show Rank Clan", + "Options Menu - Tag Type", +}; + +stock char gC_ProfileBoolPhrases[PROFILEOPTIONBOOL_COUNT][] = +{ + "Options Menu - Disabled", + "Options Menu - Enabled" +}; + +stock char gC_ProfileTagTypePhrases[PROFILETAGTYPE_COUNT][] = +{ + "Options Menu - Tag Rank", + "Options Menu - Tag Admin", + "Options Menu - Tag VIP" +}; + +stock int gI_ProfileOptionCounts[PROFILEOPTION_COUNT] = +{ + PROFILEOPTIONBOOL_COUNT, + PROFILEOPTIONBOOL_COUNT, + PROFILETAGTYPE_COUNT +}; + +stock int gI_ProfileOptionDefaults[PROFILEOPTION_COUNT] = +{ + ProfileOptionBool_Enabled, + ProfileOptionBool_Enabled, + ProfileTagType_Rank +}; + +#define PROFILE_OPTION_CATEGORY "Profile" +#define TAG_COLOR_ADMIN "{red}" +#define TAG_COLOR_VIP "{purple}" + + +// =====[ FORWARDS ]===== + + +/** + * Called when the rank of a player is updated. + * + * @param client Client index. + * @param mode Game mode. + * @param rank The new rank. + */ +forward void GOKZ_PF_OnRankUpdated(int client, int mode, int rank); + +// =====[ NATIVES ]===== + +/** + * Gets whether a mode is loaded. + * + * @param client Client. + * @param tag Mode. + * @returns Integer representing the player rank. + */ +native int GOKZ_PF_GetRank(int client, int mode); + + +// =====[ DEPENDENCY ]===== + +public SharedPlugin __pl_gokz_profile = +{ + name = "gokz-profile", + file = "gokz-profile.smx", + #if defined REQUIRE_PLUGIN + required = 1, + #else + required = 0, + #endif +}; + +#if !defined REQUIRE_PLUGIN +public void __pl_gokz_profile_SetNTVOptional() +{ + MarkNativeAsOptional("GOKZ_PF_GetRank"); +} +#endif
\ No newline at end of file diff --git a/sourcemod/scripting/include/gokz/quiet.inc b/sourcemod/scripting/include/gokz/quiet.inc new file mode 100644 index 0000000..a328b7e --- /dev/null +++ b/sourcemod/scripting/include/gokz/quiet.inc @@ -0,0 +1,205 @@ +/* + gokz-quiet Plugin Include + + Website: https://bitbucket.org/kztimerglobalteam/gokz +*/ + +#if defined _gokz_quiet_included_ +#endinput +#endif +#define _gokz_quiet_included_ + + + +// =====[ ENUMS ]===== + +enum QTOption: +{ + QTOPTION_INVALID = -1, + QTOption_ShowPlayers, + QTOption_Soundscapes, + QTOption_FallDamageSound, + QTOption_AmbientSounds, + QTOption_CheckpointVolume, + QTOption_TeleportVolume, + QTOption_TimerVolume, + QTOption_ErrorVolume, + QTOption_ServerRecordVolume, + QTOption_WorldRecordVolume, + QTOption_JumpstatsVolume, + QTOPTION_COUNT +}; + +enum +{ + ShowPlayers_Disabled = 0, + ShowPlayers_Enabled, + SHOWPLAYERS_COUNT +}; + +enum +{ + Soundscapes_Disabled = 0, + Soundscapes_Enabled, + SOUNDSCAPES_COUNT +}; + +// =====[ CONSTANTS ]===== + +#define QUIET_OPTION_CATEGORY "Quiet" +#define DEFAULT_VOLUME 10 +#define VOLUME_COUNT 21 // Maximum of 200% + +#define EFFECT_IMPACT 8 +#define EFFECT_KNIFESLASH 2 +#define BLANK_SOUNDSCAPEINDEX 482 // Search for "coopcementplant.missionselect_blank" id with sv_soundscape_printdebuginfo. + +stock char gC_QTOptionNames[QTOPTION_COUNT][] = +{ + "GOKZ QT - Show Players", + "GOKZ QT - Soundscapes", + "GOKZ QT - Fall Damage Sound", + "GOKZ QT - Ambient Sounds", + "GOKZ QT - Checkpoint Volume", + "GOKZ QT - Teleport Volume", + "GOKZ QT - Timer Volume", + "GOKZ QT - Error Volume", + "GOKZ QT - Server Record Volume", + "GOKZ QT - World Record Volume", + "GOKZ QT - Jumpstats Volume" +}; + +stock char gC_QTOptionDescriptions[QTOPTION_COUNT][] = +{ + "Visibility of Other Players - 0 = Disabled, 1 = Enabled", + "Play Soundscapes - 0 = Disabled, 1 = Enabled", + "Play Fall Damage Sound - 0 to 20 = 0% to 200%", + "Play Ambient Sounds - 0 to 20 = 0% to 200%", + "Checkpoint Volume - 0 to 20 = 0% to 200%", + "Teleport Volume - 0 to 20 = 0% to 200%", + "Timer Volume - 0 to 20 = 0% to 200%", + "Error Volume - 0 to 20 = 0% to 200%", + "Server Record Volume - 0 to 20 = 0% to 200%", + "World Record Volume - 0 to 20 = 0% to 200%", + "Jumpstats Volume - 0 to 20 = 0% to 200%" +}; + +stock int gI_QTOptionDefaultValues[QTOPTION_COUNT] = +{ + ShowPlayers_Enabled, + Soundscapes_Enabled, + DEFAULT_VOLUME, // Fall damage volume + DEFAULT_VOLUME, // Ambient volume + DEFAULT_VOLUME, // Checkpoint volume + DEFAULT_VOLUME, // Teleport volume + DEFAULT_VOLUME, // Timer volume + DEFAULT_VOLUME, // Error volume + DEFAULT_VOLUME, // Server Record Volume + DEFAULT_VOLUME, // World Record Volume + DEFAULT_VOLUME // Jumpstats Volume +}; + +stock int gI_QTOptionCounts[QTOPTION_COUNT] = +{ + SHOWPLAYERS_COUNT, + SOUNDSCAPES_COUNT, + VOLUME_COUNT, // Fall damage volume + VOLUME_COUNT, // Ambient volume + VOLUME_COUNT, // Checkpoint volume + VOLUME_COUNT, // Teleport volume + VOLUME_COUNT, // Timer volume + VOLUME_COUNT, // Error volume + VOLUME_COUNT, // Server Record volume + VOLUME_COUNT, // World Record volume + VOLUME_COUNT // Jumpstats volume +}; + +stock char gC_QTOptionPhrases[QTOPTION_COUNT][] = +{ + "Options Menu - Show Players", + "Options Menu - Soundscapes", + "Options Menu - Fall Damage Sounds", + "Options Menu - Ambient Sounds", + "Options Menu - Checkpoint Volume", + "Options Menu - Teleport Volume", + "Options Menu - Timer Volume", + "Options Menu - Error Volume", + "Options Menu - Server Record Volume", + "Options Menu - World Record Volume", + "Options Menu - Jumpstats Volume" +}; + +// =====[ STOCKS ]===== + +/** + * Returns whether an option is a gokz-quiet option. + * + * @param option Option name. + * @param optionEnum Variable to store enumerated gokz-quiet option (if it is one). + * @return Whether option is a gokz-quiet option. + */ +stock bool GOKZ_QT_IsQTOption(const char[] option, QTOption &optionEnum = QTOPTION_INVALID) +{ + for (QTOption i; i < QTOPTION_COUNT; i++) + { + if (StrEqual(option, gC_QTOptionNames[i])) + { + optionEnum = i; + return true; + } + } + return false; +} + +/** + * Gets the current value of a player's gokz-quiet option. + * + * @param client Client index. + * @param option gokz-quiet option. + * @return Current value of option. + */ +stock any GOKZ_QT_GetOption(int client, QTOption option) +{ + return GOKZ_GetOption(client, gC_QTOptionNames[option]); +} + +/** + * Sets a player's gokz-quiet option's value. + * + * @param client Client index. + * @param option gokz-quiet option. + * @param value New option value. + * @return Whether option was successfully set. + */ +stock bool GOKZ_QT_SetOption(int client, QTOption option, any value) +{ + return GOKZ_SetOption(client, gC_QTOptionNames[option], value); +} + +/** + * Increment an integer-type gokz-quiet option's value. + * Loops back to '0' if max value is exceeded. + * + * @param client Client index. + * @param option gokz-quiet option. + * @return Whether option was successfully set. + */ +stock bool GOKZ_QT_CycleOption(int client, QTOption option) +{ + return GOKZ_CycleOption(client, gC_QTOptionNames[option]); +} + + + +// =====[ DEPENDENCY ]===== + +public SharedPlugin __pl_gokz_quiet = +{ + name = "gokz-quiet", + file = "gokz-quiet.smx", + #if defined REQUIRE_PLUGIN + required = 1, + #else + required = 0, + #endif +};
\ No newline at end of file diff --git a/sourcemod/scripting/include/gokz/racing.inc b/sourcemod/scripting/include/gokz/racing.inc new file mode 100644 index 0000000..d6819ea --- /dev/null +++ b/sourcemod/scripting/include/gokz/racing.inc @@ -0,0 +1,189 @@ +/* + gokz-racing Plugin Include + + Website: https://bitbucket.org/kztimerglobalteam/gokz +*/ + +#if defined _gokz_racing_included_ +#endinput +#endif +#define _gokz_racing_included_ + + + +// =====[ ENUMS ]===== + +enum RaceInfo: +{ + RaceInfo_ID, + RaceInfo_Status, + RaceInfo_HostUserID, + RaceInfo_FinishedRacerCount, + RaceInfo_Type, + RaceInfo_Course, + RaceInfo_Mode, + RaceInfo_CheckpointRule, + RaceInfo_CooldownRule, + RACEINFO_COUNT +}; + +enum +{ + RaceType_Normal, + RaceType_Duel, + RACETYPE_COUNT +}; + +enum +{ + RaceStatus_Pending, + RaceStatus_Countdown, + RaceStatus_Started, + RaceStatus_Aborting, + RACESTATUS_COUNT +}; + +enum +{ + RacerStatus_Available, + RacerStatus_Pending, + RacerStatus_Accepted, + RacerStatus_Racing, + RacerStatus_Finished, + RacerStatus_Surrendered, + RACERSTATUS_COUNT +}; + +enum +{ + CheckpointRule_None, + CheckpointRule_Limit, + CheckpointRule_Cooldown, + CheckpointRule_Unlimited, + CHECKPOINTRULE_COUNT +}; + + + +// =====[ CONSTANTS ]===== + +#define RC_COUNTDOWN_TIME 10.0 +#define RC_REQUEST_TIMEOUT_TIME 15.0 + + + +// =====[ FORWARDS ]===== + +/** + * Called when a player has finished their race. + * + * @param client Client index. + * @param raceID ID of the race. + * @param place Final placement in the race. + */ +forward void GOKZ_RC_OnFinish(int client, int raceID, int place); + +/** + * Called when a player has surrendered their race. + * + * @param client Client index. + * @param raceID ID of the race. + */ +forward void GOKZ_RC_OnSurrender(int client, int raceID); + +/** + * Called when a player receives a race request. + * + * @param client Client index. + * @param raceID ID of the race. + */ +forward void GOKZ_RC_OnRequestReceived(int client, int raceID) + +/** + * Called when a player accepts a race request. + * + * @param client Client index. + * @param raceID ID of the race. + */ +forward void GOKZ_RC_OnRequestAccepted(int client, int raceID) + +/** + * Called when a player declines a race request. + * + * @param client Client index. + * @param raceID ID of the race. + * @param timeout Whether the client was too late to respond. + */ +forward void GOKZ_RC_OnRequestDeclined(int client, int raceID, bool timeout) + +/** + * Called when a race has been registered. + * The initial status of a race is RaceStatus_Pending. + * + * @param raceID ID of the race. + */ +forward void GOKZ_RC_OnRaceRegistered(int raceID); + +/** + * Called when a race's info property has changed. + * + * @param raceID ID of the race. + * @param prop Info property that was changed. + * @param oldValue Previous value. + * @param newValue New value. + */ +forward void GOKZ_RC_OnRaceInfoChanged(int raceID, RaceInfo prop, int oldValue, int newValue); + + + +// =====[ NATIVES ]===== + +/** + * Gets the value of a race info property. + * + * @param raceID Race index. + * @param prop Info property to get. + * @return Value of the info property. + */ +native int GOKZ_RC_GetRaceInfo(int raceID, RaceInfo prop); + +/** + * Gets a player's racer status. + * Refer to the RacerStatus enumeration. + * + * @param client Client index. + * @return Racer status of the client. + */ +native int GOKZ_RC_GetStatus(int client); + +/** + * Gets the ID of the race a player is in. + * + * @param client Client index. + * @return ID of the race the player is in, or -1 if not in a race. + */ +native int GOKZ_RC_GetRaceID(int client); + + + +// =====[ DEPENDENCY ]===== + +public SharedPlugin __pl_gokz_racing = +{ + name = "gokz-racing", + file = "gokz-racing.smx", + #if defined REQUIRE_PLUGIN + required = 1, + #else + required = 0, + #endif +}; + +#if !defined REQUIRE_PLUGIN +public void __pl_gokz_racing_SetNTVOptional() +{ + MarkNativeAsOptional("GOKZ_RC_GetRaceInfo"); + MarkNativeAsOptional("GOKZ_RC_GetStatus"); + MarkNativeAsOptional("GOKZ_RC_GetRaceID"); +} +#endif
\ No newline at end of file diff --git a/sourcemod/scripting/include/gokz/replays.inc b/sourcemod/scripting/include/gokz/replays.inc new file mode 100644 index 0000000..6aabdbd --- /dev/null +++ b/sourcemod/scripting/include/gokz/replays.inc @@ -0,0 +1,275 @@ +/* + gokz-replays Plugin Include + + Website: https://bitbucket.org/kztimerglobalteam/gokz +*/ + +#if defined _gokz_replays_included_ +#endinput +#endif +#define _gokz_replays_included_ + +// Bit of a hack, but need it for other plugins that depend on replays to compile +#if defined REQUIRE_PLUGIN +#undef REQUIRE_PLUGIN +#include <gokz/anticheat> +#define REQUIRE_PLUGIN +#else +#include <gokz/anticheat> +#endif + + + +// =====[ ENUMS ]===== +enum +{ + ReplayType_Run = 0, + ReplayType_Cheater, + ReplayType_Jump, + REPLAYTYPE_COUNT +}; + +enum ReplaySaveState +{ + ReplaySave_Local = 0, + ReplaySave_Temp, + ReplaySave_Disabled +}; + +// NOTE: Replays use delta compression for storage. +// This enum is the indices of the ReplayTickData enum struct. +// NOTE: This has to match the ReplayTickData enum struct!!! +enum +{ + RPDELTA_DELTAFLAGS = 0, + RPDELTA_DELTAFLAGS2, + RPDELTA_VEL_X, + RPDELTA_VEL_Y, + RPDELTA_VEL_Z, + RPDELTA_MOUSE_X, + RPDELTA_MOUSE_Y, + RPDELTA_ORIGIN_X, + RPDELTA_ORIGIN_Y, + RPDELTA_ORIGIN_Z, + RPDELTA_ANGLES_X, + RPDELTA_ANGLES_Y, + RPDELTA_ANGLES_Z, + RPDELTA_VELOCITY_X, + RPDELTA_VELOCITY_Y, + RPDELTA_VELOCITY_Z, + RPDELTA_FLAGS, + RPDELTA_PACKETSPERSECOND, + RPDELTA_LAGGEDMOVEMENTVALUE, + RPDELTA_BUTTONSFORCED, + + RP_V2_TICK_DATA_BLOCKSIZE +}; + + + +// =====[ STRUCTS ] ===== + +enum struct GeneralReplayHeader +{ + int magicNumber; + int formatVersion; + int replayType; + char gokzVersion[32]; + char mapName[64]; + int mapFileSize; + int serverIP; + int timestamp; + char playerAlias[MAX_NAME_LENGTH]; + int playerSteamID; + int mode; + int style; + float playerSensitivity; + float playerMYaw; + float tickrate; + int tickCount; + int equippedWeapon; + int equippedKnife; +} + +enum struct JumpReplayHeader +{ + int jumpType; + float distance; + int blockDistance; + int strafeCount; + float sync; + float pre; + float max; + int airtime; +} + +enum struct CheaterReplayHeader +{ + ACReason ACReason; +} + +enum struct RunReplayHeader +{ + float time; + int course; + int teleportsUsed; +} + +// NOTE: Make sure to change the RPDELTA_* enum, TickDataToArray() and TickDataFromArray() when adding/removing stuff from this!!! +enum struct ReplayTickData +{ + int deltaFlags; + int deltaFlags2; + float vel[3]; + int mouse[2]; + float origin[3]; + float angles[3]; + float velocity[3]; + int flags; + float packetsPerSecond; + float laggedMovementValue; + int buttonsForced; +} + + + +// =====[ CONSTANTS ]===== + +#define RP_DIRECTORY "data/gokz-replays" // In Path_SM +#define RP_DIRECTORY_RUNS "data/gokz-replays/_runs" // In Path_SM +#define RP_DIRECTORY_RUNS_TEMP "data/gokz-replays/_tempRuns" // In Path_SM +#define RP_DIRECTORY_CHEATERS "data/gokz-replays/_cheaters" // In Path_SM +#define RP_DIRECTORY_JUMPS "data/gokz-replays/_jumps" // In Path_SM +#define RP_DIRECTORY_BLOCKJUMPS "blocks" +#define RP_FILE_EXTENSION "replay" +#define RP_MAGIC_NUMBER 0x676F6B7A +#define RP_FORMAT_VERSION 0x02 +#define RP_NAV_FILE "maps/gokz-replays.nav" +#define RP_V1_TICK_DATA_BLOCKSIZE 7 +#define RP_CACHE_BLOCKSIZE 4 +#define RP_MAX_BOTS 4 +#define RP_PLAYBACK_BREATHER_TIME 2.0 +#define RP_MIN_CHEATER_REPLAY_LENGTH 30 // 30 seconds +#define RP_MAX_CHEATER_REPLAY_LENGTH 120 // 2 minutes +#define RP_MAX_BHOP_GROUND_TICKS 5 +#define RP_SKIP_TIME 10 // 10 seconds +#define RP_MAX_DURATION 6451200 // 14 hours on 128 tick +#define RP_JUMP_STEP_SOUND_THRESHOLD 140.0 +#define RP_PLAYER_ACCELSPEED 450.0 + +#define RP_MOVETYPE_MASK (0xF) +#define RP_IN_ATTACK (1 << 4) +#define RP_IN_ATTACK2 (1 << 5) +#define RP_IN_JUMP (1 << 6) +#define RP_IN_DUCK (1 << 7) +#define RP_IN_FORWARD (1 << 8) +#define RP_IN_BACK (1 << 9) +#define RP_IN_LEFT (1 << 10) +#define RP_IN_RIGHT (1 << 11) +#define RP_IN_MOVELEFT (1 << 12) +#define RP_IN_MOVERIGHT (1 << 13) +#define RP_IN_RELOAD (1 << 14) +#define RP_IN_SPEED (1 << 15) +#define RP_IN_USE (1 << 16) +#define RP_IN_BULLRUSH (1 << 17) +#define RP_FL_ONGROUND (1 << 18) +#define RP_FL_DUCKING (1 << 19) +#define RP_FL_SWIM (1 << 20) +#define RP_UNDER_WATER (1 << 21) +#define RP_TELEPORT_TICK (1 << 22) +#define RP_TAKEOFF_TICK (1 << 23) +#define RP_HIT_PERF (1 << 24) +#define RP_SECONDARY_EQUIPPED (1 << 25) + + + +// =====[ FORWARDS ]===== + +/** + * Called when a replay of a player is written to disk. + * This includes replays of cheaters which are saved if + * the player is marked as a cheater by gokz-localdb. + * + * @param client The client ID of the player who completed the run. + * @param replayType The type of the replay (Run/Jump/Cheater). + * @param map The name of the map the run was completed on. + * @param course The specific course on the map the run was completed on. + * @param timeType The type of time (Pro/Nub). + * @param time The time the run was completed in. + * @param filePath Replay file path. + * @param tempReplay Whether the replay file should only be temporaily stored. + * @return Plugin_Handled to take over the temporary replay deletion, Plugin_Continue to allow temporary replay deletion by the replay plugin. + */ +forward Action GOKZ_RP_OnReplaySaved(int client, int replayType, const char[] map, int course, int timeType, float time, const char[] filePath, bool tempReplay); + +/** + * Called when a currently being recorded replay is discarded from + * memory and recording has been stopped (without writing it to disk). + * + * @param client Client index. + */ +forward void GOKZ_RP_OnReplayDiscarded(int client); + +/** + * Called when a player has ended their timer, and gokz-replays has + * processed the time and has possibly written a replay to disk. + * + * @param client Client index. + * @param filePath Replay file path, or "" if no replay saved. + * @param course Course number. + * @param time Player's end time. + * @param teleportsUsed Number of teleports used by player. + */ +forward void GOKZ_RP_OnTimerEnd_Post(int client, const char[] filePath, int course, float time, int teleportsUsed); + + + +// =====[ NATIVES ]==== + +/** + * Called by the HUD to get the state of the current replay. + * + * @param client Client index. + * @param info Struct to pass the values into. + * @return If successful + */ +native int GOKZ_RP_GetPlaybackInfo(int client, any[] info); + +/** + * Called by the LocalDB to initiate a replay of a jump + * + * @param client Client index. + * @param path Path to the replay file. + * @return The client ID of the bot performing the replay. + */ +native int GOKZ_RP_LoadJumpReplay(int client, char[] path); + +/** + * Called by the HUD to show the replay control menu. + * + * @param client Client index. + */ +native bool GOKZ_RP_UpdateReplayControlMenu(int client); + + +// =====[ DEPENDENCY ]===== + +public SharedPlugin __pl_gokz_replays = +{ + name = "gokz-replays", + file = "gokz-replays.smx", + #if defined REQUIRE_PLUGIN + required = 1, + #else + required = 0, + #endif +}; + +#if !defined REQUIRE_PLUGIN +public void __pl_gokz_replays_SetNTVOptional() +{ + MarkNativeAsOptional("GOKZ_RP_GetPlaybackInfo"); + MarkNativeAsOptional("GOKZ_RP_LoadJumpReplay"); + MarkNativeAsOptional("GOKZ_RP_UpdateReplayControlMenu"); +} +#endif diff --git a/sourcemod/scripting/include/gokz/slayonend.inc b/sourcemod/scripting/include/gokz/slayonend.inc new file mode 100644 index 0000000..2ed01e5 --- /dev/null +++ b/sourcemod/scripting/include/gokz/slayonend.inc @@ -0,0 +1,43 @@ +/* + gokz-slayonend Plugin Include + + Website: https://bitbucket.org/kztimerglobalteam/gokz +*/ + +#if defined _gokz_slayonend_included_ +#endinput +#endif +#define _gokz_slayonend_included_ + + + +// =====[ ENUMS ]===== + +enum +{ + SlayOnEnd_Disabled = 0, + SlayOnEnd_Enabled, + SLAYONEND_COUNT +}; + + + +// =====[ CONSTANTS ]===== + +#define SLAYONEND_OPTION_NAME "GOKZ - Slay On End" +#define SLAYONEND_OPTION_DESCRIPTION "Automatic Slaying Upon Ending Timer - 0 = Disabled, 1 = Enabled" + + + +// =====[ DEPENDENCY ]===== + +public SharedPlugin __pl_gokz_slayonend = +{ + name = "gokz-slayonend", + file = "gokz-slayonend.smx", + #if defined REQUIRE_PLUGIN + required = 1, + #else + required = 0, + #endif +};
\ No newline at end of file diff --git a/sourcemod/scripting/include/gokz/tips.inc b/sourcemod/scripting/include/gokz/tips.inc new file mode 100644 index 0000000..b5e2d3e --- /dev/null +++ b/sourcemod/scripting/include/gokz/tips.inc @@ -0,0 +1,59 @@ +/* + gokz-tips Plugin Include + + Website: https://bitbucket.org/kztimerglobalteam/gokz +*/ + +#if defined _gokz_tips_included_ +#endinput +#endif +#define _gokz_tips_included_ + + + +// =====[ ENUMS ]===== + +enum +{ + Tips_Disabled = 0, + Tips_Enabled, + TIPS_COUNT +}; + + + +// =====[ CONSTANTS ]===== + +#define TIPS_PLUGINS_COUNT 9 +#define TIPS_CORE "gokz-tips-core.phrases.txt" +#define TIPS_TIPS "gokz-tips-tips.phrases.txt" +#define TIPS_OPTION_NAME "GOKZ - Tips" +#define TIPS_OPTION_DESCRIPTION "Random Tips Periodically in Chat - 0 = Disabled, 1 = Enabled" + +stock char gC_PluginsWithTips[TIPS_PLUGINS_COUNT][] = +{ + "goto", + "hud", + "jumpstats", + "localranks", + "measure", + "pistol", + "quiet", + "replays", + "spec" +} + + + +// =====[ DEPENDENCY ]===== + +public SharedPlugin __pl_gokz_tips = +{ + name = "gokz-tips", + file = "gokz-tips.smx", + #if defined REQUIRE_PLUGIN + required = 1, + #else + required = 0, + #endif +};
\ No newline at end of file diff --git a/sourcemod/scripting/include/gokz/tpanglefix.inc b/sourcemod/scripting/include/gokz/tpanglefix.inc new file mode 100644 index 0000000..fc8faa2 --- /dev/null +++ b/sourcemod/scripting/include/gokz/tpanglefix.inc @@ -0,0 +1,40 @@ +/* + gokz-tpanglefix Plugin Include + + Website: https://github.com/KZGlobalTeam/gokz +*/ + +#if defined _gokz_tpanglefix_included_ +#endinput +#endif +#define _gokz_tpanglefix_included_ + + +// =====[ ENUMS ]===== + +enum +{ + TPAngleFix_Disabled = 0, + TPAngleFix_Enabled, + TPANGLEFIX_COUNT +}; + + +// =====[ CONSTANTS ]===== + +#define TPANGLEFIX_OPTION_NAME "GOKZ - TPAngleFix" +#define TPANGLEFIX_OPTION_DESCRIPTION "TPAngleFix - 0 = Disabled, 1 = Enabled" + + +// =====[ DEPENDENCY ]===== + +public SharedPlugin __pl_gokz_tpanglefix = +{ + name = "gokz-tpanglefix", + file = "gokz-tpanglefix.smx", + #if defined REQUIRE_PLUGIN + required = 1, + #else + required = 0, + #endif +};
\ No newline at end of file diff --git a/sourcemod/scripting/include/gokz/version.inc b/sourcemod/scripting/include/gokz/version.inc new file mode 100644 index 0000000..34cdb19 --- /dev/null +++ b/sourcemod/scripting/include/gokz/version.inc @@ -0,0 +1,12 @@ +/* + GOKZ Version Include + + Website: https://bitbucket.org/kztimerglobalteam/gokz + + You should not need to edit this file. + This file is overwritten in the build pipeline for versioning. +*/ + + + +#define GOKZ_VERSION ""
\ No newline at end of file diff --git a/sourcemod/scripting/include/json.inc b/sourcemod/scripting/include/json.inc new file mode 100644 index 0000000..ebc46e4 --- /dev/null +++ b/sourcemod/scripting/include/json.inc @@ -0,0 +1,473 @@ +/** + * vim: set ts=4 : + * ============================================================================= + * sm-json + * Provides a pure SourcePawn implementation of JSON encoding and decoding. + * https://github.com/clugg/sm-json + * + * sm-json (C)2019 James Dickens. (clug) + * SourceMod (C)2004-2008 AlliedModders LLC. All rights reserved. + * ============================================================================= + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 3.0, as published by the + * Free Software Foundation. + * + * 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, see <http://www.gnu.org/licenses/>. + * + * As a special exception, AlliedModders LLC gives you permission to link the + * code of this program (as well as its derivative works) to "Half-Life 2," the + * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software + * by the Valve Corporation. You must obey the GNU General Public License in + * all respects for all other code used. Additionally, AlliedModders LLC grants + * this exception to all derivative works. AlliedModders LLC defines further + * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007), + * or <http://www.sourcemod.net/license.php>. + */ + +#if defined _json_included + #endinput +#endif +#define _json_included + +#include <string> +#include <json/definitions> +#include <json/helpers/decode> +#include <json/helpers/encode> +#include <json/helpers/string> +#include <json/object> + +/** + * Encodes a JSON instance into its string representation. + * + * @param obj Object to encode. + * @param output String buffer to store output. + * @param max_size Maximum size of string buffer. + * @param pretty_print Should the output be pretty printed (newlines and spaces)? [default: false] + * @param depth The current depth of the encoder. [default: 0] + */ +stock void json_encode( + JSON_Object obj, + char[] output, + int max_size, + bool pretty_print = false, + int depth = 0 +) +{ + bool is_array = obj.IsArray; + bool is_empty = true; + int builder_size; + + // used in key iterator + int str_length = 1; + int int_value; + int cell_length = 0; + + StringMapSnapshot snap = null; + int json_size = 0; + if (is_array) { + json_size = obj.CurrentIndex; + + strcopy(output, max_size, "["); + } else { + snap = obj.Snapshot(); + json_size = snap.Length; + + strcopy(output, max_size, "{"); + } + + int key_length = 0; + for (int i = 0; i < json_size; ++i) { + key_length = (is_array) ? JSON_INDEX_BUFFER_SIZE : snap.KeyBufferSize(i); + char[] key = new char[key_length]; + + if (is_array) { + obj.GetIndexString(key, key_length, i); + } else { + snap.GetKey(i, key, key_length); + } + + // skip meta-keys + if (json_is_meta_key(key)) { + continue; + } + + // skip keys that are marked as hidden + if (obj.GetKeyHidden(key)) { + continue; + } + + JSON_CELL_TYPE type = obj.GetKeyType(key); + // skip keys of unknown type + if (type == Type_Invalid) { + continue; + } + + // if we are dealing with a string, prepare the str_value variable for fetching + if (type == Type_String) { + str_length = obj.GetKeyLength(key); + } + char[] str_value = new char[str_length + 1]; + + // determine the length of the char[] needed to represent our cell data + cell_length = 0; + switch (type) { + case Type_String: { + // get the string value early, as its cell_length is determined by its contents + obj.GetString(key, str_value, str_length + 1); + cell_length = json_cell_string_size(str_length); + } + case Type_Int: { + // get the int value early, as its cell_length is determined by its contents + int_value = obj.GetInt(key); + cell_length = json_cell_int_size(int_value); + } + case Type_Float: { + cell_length = json_cell_float_size(); + } + case Type_Bool: { + cell_length = json_cell_bool_size(); + } + case Type_Null: { + cell_length = json_cell_null_size(); + } + case Type_Object: { + cell_length = max_size; + } + } + + // fit the contents into the cell + char[] cell = new char[cell_length]; + switch (type) { + case Type_String: { + json_cell_string(str_value, cell, cell_length); + } + case Type_Int: { + json_cell_int(int_value, cell, cell_length); + } + case Type_Float: { + float value = obj.GetFloat(key); + json_cell_float(value, cell, cell_length); + } + case Type_Bool: { + bool value = obj.GetBool(key); + json_cell_bool(value, cell, cell_length); + } + case Type_Null: { + json_cell_null(cell, cell_length); + } + case Type_Object: { + JSON_Object child = obj.GetObject(key); + json_encode(child, cell, cell_length, pretty_print, depth + 1); + } + } + + // make the builder fit our key:value + // use previously determined cell length and + 1 for , + builder_size = cell_length + 1; + if (! is_array) { + // get the length of the key and + 1 for : + builder_size += json_cell_string_size(strlen(key)) + 1; + + if (pretty_print) { + builder_size += strlen(JSON_PP_AFTER_COLON); + } + } + + char[] builder = new char[builder_size]; + strcopy(builder, builder_size, ""); + + // add the key if we're working with an object + if (! is_array) { + json_cell_string(key, builder, builder_size); + StrCat(builder, builder_size, ":"); + + if (pretty_print) { + StrCat(builder, builder_size, JSON_PP_AFTER_COLON); + } + } + + // add the value and a trailing comma + StrCat(builder, builder_size, cell); + StrCat(builder, builder_size, ","); + + // prepare pretty printing then send builder to output afterwards + if (pretty_print) { + StrCat(output, max_size, JSON_PP_NEWLINE); + + for (int j = 0; j < depth + 1; ++j) { + StrCat(output, max_size, JSON_PP_INDENT); + } + } + + StrCat(output, max_size, builder); + + is_empty = false; + } + + if (snap != null) { + delete snap; + } + + if (! is_empty) { + // remove the final comma + output[strlen(output) - 1] = '\0'; + + if (pretty_print) { + StrCat(output, max_size, JSON_PP_NEWLINE); + + for (int j = 0; j < depth; ++j) { + StrCat(output, max_size, JSON_PP_INDENT); + } + } + } + + // append closing bracket + StrCat(output, max_size, (is_array) ? "]" : "}"); +} + +/** + * Decodes a JSON string into a JSON instance. + * + * @param buffer Buffer to decode. + * @param result Object to store output in. Setting this allows loading over + * an existing JSON instance, 'refreshing' it as opposed to + * creating a new one. [default: null] + * @param pos Current position of the decoder as a bytes offset into the buffer. + * @param depth Current depth of the decoder as child elements in the object. + * @returns JSON instance or null if decoding failed (buffer didn't contain valid JSON). + */ +stock JSON_Object json_decode( + const char[] buffer, + JSON_Object result = null, + int &pos = 0, + int depth = 0 +) +{ + int length = strlen(buffer); + bool is_array = false; + + // skip preceding whitespace + if (! json_skip_whitespace(buffer, length, pos)) { + LogError("json_decode: buffer ended early at position %d", pos); + + return null; + } + + if (json_is_object(buffer[pos])) { + is_array = false; + } else if (json_is_array(buffer[pos])) { + is_array = true; + } else { + LogError("json_decode: character not identified as object or array at position %d", pos); + + return null; + } + + if (result == null) { + result = new JSON_Object(is_array); + } + + bool empty_checked = false; + char[] key = new char[length]; + char[] cell = new char[length]; + + // while we haven't reached the end of our structure + while (! is_array && ! json_is_object_end(buffer[pos]) + || is_array && ! json_is_array_end(buffer[pos])) { + // pos is either an opening structure or comma, so increment past it + ++pos; + + // skip any whitespace preceding the element + if (! json_skip_whitespace(buffer, length, pos)) { + LogError("json_decode: buffer ended early at position %d", pos); + + return null; + } + + // if we are at the end of an object or array + // and haven't checked for empty yet, we can stop here (empty structure) + if ((! is_array && json_is_object_end(buffer[pos]) + || is_array && json_is_array_end(buffer[pos])) + && ! empty_checked) { + break; + } + + empty_checked = true; + + // if dealing with an object, look for the key + if (! is_array) { + if (! json_is_string(buffer[pos])) { + LogError("json_decode: expected key string at position %d", pos); + + return null; + } + + // extract the key from the buffer + json_extract_string(buffer, length, pos, key, length, is_array); + + // skip any whitespace following the key + if (! json_skip_whitespace(buffer, length, pos)) { + LogError("json_decode: buffer ended early at position %d", pos); + + return null; + } + + // ensure that we find a colon + if (buffer[pos++] != ':') { + LogError("json_decode: expected colon after key at position %d", pos); + + return null; + } + + // skip any whitespace following the colon + if (! json_skip_whitespace(buffer, length, pos)) { + LogError("json_decode: buffer ended early at position %d", pos); + + return null; + } + } + + if (json_is_object(buffer[pos]) || json_is_array(buffer[pos])) { + // if we are dealing with an object or array + // fetch the existing object if one exists at the key + JSON_Object current = (! is_array) ? result.GetObject(key) : null; + + // decode recursively + JSON_Object value = json_decode(buffer, current, pos, depth + 1); + + // decoding failed, error will be logged in json_decode + if (value == null) { + return null; + } + + if (is_array) { + result.PushObject(value); + } else { + result.SetObject(key, value); + } + } else if (json_is_string(buffer[pos])) { + // if we are dealing with a string, attempt to extract it + if (! json_extract_string(buffer, length, pos, cell, length, is_array)) { + LogError("json_decode: couldn't extract string at position %d", pos); + + return null; + } + + if (is_array) { + result.PushString(cell); + } else { + result.SetString(key, cell); + } + } else { + if (! json_extract_until_end(buffer, length, pos, cell, length, is_array)) { + LogError("json_decode: couldn't extract until end at position %d", pos); + + return null; + } + + if (strlen(cell) == 0) { + LogError("json_decode: empty cell encountered at position %d", pos); + + return null; + } + + if (json_is_int(cell)) { + int value = json_extract_int(cell); + if (is_array) { + result.PushInt(value); + } else { + result.SetInt(key, value); + } + } else if (json_is_float(cell)) { + float value = json_extract_float(cell); + if (is_array) { + result.PushFloat(value); + } else { + result.SetFloat(key, value); + } + } else if (json_is_bool(cell)) { + bool value = json_extract_bool(cell); + if (is_array) { + result.PushBool(value); + } else { + result.SetBool(key, value); + } + } else if (json_is_null(cell)) { + if (is_array) { + result.PushHandle(null); + } else { + result.SetHandle(key, null); + } + } else { + LogError("json_decode: unknown type encountered at position %d: %s", pos, cell); + + return null; + } + } + + if (! json_skip_whitespace(buffer, length, pos)) { + LogError("json_decode: buffer ended early at position %d", pos); + + return null; + } + } + + // skip remaining whitespace and ensure we're at the end of the buffer + ++pos; + if (json_skip_whitespace(buffer, length, pos) && depth == 0) { + LogError("json_decode: unexpected data after end of structure at position %d", pos); + + return null; + } + + return result; +} + +/** + * Recursively cleans up a JSON instance and any JSON instances stored within. + * + * @param obj JSON instance to clean up. + */ +stock void json_cleanup(JSON_Object obj) +{ + bool is_array = obj.IsArray; + + int key_length = 0; + StringMapSnapshot snap = obj.Snapshot(); + for (int i = 0; i < snap.Length; ++i) { + key_length = snap.KeyBufferSize(i); + char[] key = new char[key_length]; + + // ignore meta keys + snap.GetKey(i, key, key_length); + if (json_is_meta_key(key)) { + continue; + } + + // only clean up objects + JSON_CELL_TYPE type = obj.GetKeyType(key); + if (type != Type_Object) { + continue; + } + + JSON_Object nested_obj = obj.GetObject(key); + if (nested_obj != null) { + nested_obj.Cleanup(); + delete nested_obj; + } + } + + obj.Clear(); + delete snap; + + if (is_array) { + obj.SetValue(JSON_ARRAY_INDEX_KEY, 0); + } +} diff --git a/sourcemod/scripting/include/json/decode_helpers.inc b/sourcemod/scripting/include/json/decode_helpers.inc new file mode 100644 index 0000000..0032cc3 --- /dev/null +++ b/sourcemod/scripting/include/json/decode_helpers.inc @@ -0,0 +1,312 @@ +/** + * vim: set ts=4 : + * ============================================================================= + * sm-json + * Provides a pure SourcePawn implementation of JSON encoding and decoding. + * https://github.com/clugg/sm-json + * + * sm-json (C)2018 James D. (clug) + * SourceMod (C)2004-2008 AlliedModders LLC. All rights reserved. + * ============================================================================= + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 3.0, as published by the + * Free Software Foundation. + * + * 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, see <http://www.gnu.org/licenses/>. + * + * As a special exception, AlliedModders LLC gives you permission to link the + * code of this program (as well as its derivative works) to "Half-Life 2," the + * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software + * by the Valve Corporation. You must obey the GNU General Public License in + * all respects for all other code used. Additionally, AlliedModders LLC grants + * this exception to all derivative works. AlliedModders LLC defines further + * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007), + * or <http://www.sourcemod.net/license.php>. + */ + +#if defined _json_decode_helpers_included + #endinput +#endif +#define _json_decode_helpers_included + +#include <string> + +/** + * @section Analysing format of incoming JSON cells. + */ + +/** + * Checks whether the character at the given + * position in the buffer is whitespace. + * + * @param buffer String buffer of data. + * @param pos Position to check in buffer. + * @return True if buffer[pos] is whitespace, false otherwise. + */ +stock bool json_is_whitespace(const char[] buffer, int &pos) { + return buffer[pos] == ' ' || buffer[pos] == '\t' || + buffer[pos] == '\r' || buffer[pos] == '\n'; +} + +/** + * Checks whether the character at the beginning + * of the buffer is the start of a string. + * + * @param buffer String buffer of data. + * @return True if buffer[0] is the start of a string, false otherwise. + */ +stock bool json_is_string(const char[] buffer) { + return buffer[0] == '"'; +} + +/** + * Checks whether the buffer provided contains an int. + * + * @param buffer String buffer of data. + * @return True if buffer contains an int, false otherwise. + */ +stock bool json_is_int(const char[] buffer) { + int length = strlen(buffer); + if (buffer[0] != '+' && buffer[0] != '-' && !IsCharNumeric(buffer[0])) { + return false; + } + + for (int i = 0; i < length; ++i) { + if (!IsCharNumeric(buffer[i])) return false; + } + + return true; +} + +/** + * Checks whether the buffer provided contains a float. + * + * @param buffer String buffer of data. + * @return True if buffer contains a float, false otherwise. + */ +stock bool json_is_float(const char[] buffer) { + bool has_decimal = false; + int length = strlen(buffer); + if (buffer[0] != '+' && buffer[0] != '-' && buffer[0] != '.' && !IsCharNumeric(buffer[0])) { + return false; + } + + for (int i = 0; i < length; ++i) { + if (buffer[i] == '.') { + if (has_decimal) { + return false; + } + + has_decimal = true; + } else if (!IsCharNumeric(buffer[i])) { + return false; + } + } + + return true; +} + +/** + * Checks whether the buffer provided contains a bool. + * + * @param buffer String buffer of data. + * @return True if buffer contains a bool, false otherwise. + */ +stock bool json_is_bool(const char[] buffer) { + return StrEqual(buffer, "true") || + StrEqual(buffer, "false"); +} + +/** + * Checks whether the buffer provided contains null. + * + * @param buffer String buffer of data. + * @return True if buffer contains null, false otherwise. + */ +stock bool json_is_null(const char[] buffer) { + return StrEqual(buffer, "null"); +} + +/** + * Checks whether the character at the beginning + * of the buffer is the start of an object. + * + * @param buffer String buffer of data. + * @return True if buffer[0] is the start of an object, false otherwise. + */ +stock bool json_is_object(const char[] buffer) { + return buffer[0] == '{'; +} + +/** + * Checks whether the character at the beginning + * of the buffer is the end of an object. + * + * @param buffer String buffer of data. + * @return True if buffer[0] is the end of an object, false otherwise. + */ +stock bool json_is_object_end(const char[] buffer) { + return buffer[0] == '}'; +} + +/** + * Checks whether the character at the beginning + * of the buffer is the start of an array. + * + * @param buffer String buffer of data. + * @return True if buffer[0] is the start of an array, false otherwise. + */ +stock bool json_is_array(const char[] buffer) { + return buffer[0] == '['; +} + +/** + * Checks whether the character at the beginning + * of the buffer is the start of an array. + * + * @param buffer String buffer of data. + * @return True if buffer[0] is the start of an array, false otherwise. + */ +stock bool json_is_array_end(const char[] buffer) { + return buffer[0] == ']'; +} + +/** + * Checks whether the character at the given position in the buffer + * is considered a valid 'end point' for some data, such as a + * colon (indicating a key), a comma (indicating a new element), + * or the end of an object or array. + * + * @param buffer String buffer of data. + * @param pos Position to check in buffer. + * @return True if buffer[pos] is a valid data end point, false otherwise. + */ +stock bool json_is_at_end(const char[] buffer, int &pos, bool is_array) { + return buffer[pos] == ',' || + (!is_array && buffer[pos] == ':') || + json_is_object_end(buffer[pos]) || + json_is_array_end(buffer[pos]); +} + +/** + * Moves the position until it reaches a non-whitespace + * character or the end of the buffer's maximum size. + * + * @param buffer String buffer of data. + * @param maxlen Maximum size of string buffer. + * @param pos Position to increment. + * @return True if pos is not at the end of the buffer, false otherwise. + */ +stock bool json_skip_whitespace(const char[] buffer, int maxlen, int &pos) { + while (json_is_whitespace(buffer, pos) && pos < maxlen) { + ++pos; + } + + return pos < maxlen; +} + +/** + * Extracts a JSON cell from the buffer until + * a valid end point is reached. + * + * @param buffer String buffer of data. + * @param maxlen Maximum size of string buffer. + * @param pos Position to increment. + * @param output String buffer to store output. + * @param output_maxlen Maximum size of output string buffer. + * @param is_array Whether the decoder is currently processing an array. + * @return True if pos is not at the end of the buffer, false otherwise. + */ +stock bool json_extract_until_end(const char[] buffer, int maxlen, int &pos, char[] output, int output_maxlen, bool is_array) { + // extracts a string from current pos until a valid 'end point' + strcopy(output, output_maxlen, ""); + + int start = pos; + while (!json_is_whitespace(buffer, pos) && !json_is_at_end(buffer, pos, is_array) && pos < maxlen) { + ++pos; + } + int end = pos - 1; + + // skip trailing whitespace + json_skip_whitespace(buffer, maxlen, pos); + + if (!json_is_at_end(buffer, pos, is_array)) return false; + strcopy(output, end - start + 2, buffer[start]); + + return pos < maxlen; +} + + +/** + * Extracts a JSON string from the buffer until + * a valid end point is reached. + * + * @param buffer String buffer of data. + * @param maxlen Maximum size of string buffer. + * @param pos Position to increment. + * @param output String buffer to store output. + * @param output_maxlen Maximum size of output string buffer. + * @param is_array Whether the decoder is currently processing an array. + * @return True if pos is not at the end of the buffer, false otherwise. + */ +stock bool json_extract_string(const char[] buffer, int maxlen, int &pos, char[] output, int output_maxlen, bool is_array) { + // extracts a string which needs to be quote-escaped + strcopy(output, output_maxlen, ""); + + ++pos; + int start = pos; + while (!(buffer[pos] == '"' && buffer[pos - 1] != '\\') && pos < maxlen) { + ++pos; + } + int end = pos - 1; + + // jump 1 ahead since we ended on " instead of an ending char + ++pos; + + // skip trailing whitespace + json_skip_whitespace(buffer, maxlen, pos); + + if (!json_is_at_end(buffer, pos, is_array)) return false; + // copy only from start with length end - start + 2 (+2 for NULL terminator and something else) + strcopy(output, end - start + 2, buffer[start]); + json_unescape_string(output, maxlen); + + return pos < maxlen; +} + +/** + * Extracts an int from the buffer. + * + * @param buffer String buffer of data. + * @return Int value of the buffer. + */ +stock int json_extract_int(const char[] buffer) { + return StringToInt(buffer); +} + +/** + * Extracts a float from the buffer. + * + * @param buffer String buffer of data. + * @return Float value of the buffer. + */ +stock float json_extract_float(const char[] buffer) { + return StringToFloat(buffer); +} + +/** + * Extracts a bool from the buffer. + * + * @param buffer String buffer of data. + * @return Bool value of the buffer. + */ +stock bool json_extract_bool(const char[] buffer) { + return StrEqual(buffer, "true"); +} diff --git a/sourcemod/scripting/include/json/definitions.inc b/sourcemod/scripting/include/json/definitions.inc new file mode 100644 index 0000000..63063d3 --- /dev/null +++ b/sourcemod/scripting/include/json/definitions.inc @@ -0,0 +1,103 @@ +/** + * vim: set ts=4 : + * ============================================================================= + * sm-json + * Provides a pure SourcePawn implementation of JSON encoding and decoding. + * https://github.com/clugg/sm-json + * + * sm-json (C)2019 James Dickens. (clug) + * SourceMod (C)2004-2008 AlliedModders LLC. All rights reserved. + * ============================================================================= + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 3.0, as published by the + * Free Software Foundation. + * + * 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, see <http://www.gnu.org/licenses/>. + * + * As a special exception, AlliedModders LLC gives you permission to link the + * code of this program (as well as its derivative works) to "Half-Life 2," the + * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software + * by the Valve Corporation. You must obey the GNU General Public License in + * all respects for all other code used. Additionally, AlliedModders LLC grants + * this exception to all derivative works. AlliedModders LLC defines further + * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007), + * or <http://www.sourcemod.net/license.php>. + */ + +#if defined _json_definitions_included + #endinput +#endif +#define _json_definitions_included + +#include <string> +#include <json/helpers/string> + +/** + * @section Pretty Print Constants + * + * Used to determine how pretty printed JSON should be formatted when encoded. + * You can modify these if you prefer your JSON formatted differently. + */ + +#define JSON_PP_AFTER_COLON " " +#define JSON_PP_INDENT " " +#define JSON_PP_NEWLINE "\n" + +/** + * @section Buffer Size Constants + * + * You may need to change these if you are working with very large arrays or floating point numbers. + */ + +#define JSON_FLOAT_BUFFER_SIZE 32 +#define JSON_INDEX_BUFFER_SIZE 16 + +/** + * @section Meta-key Constants + * + * Used to store metadata for each key in an object. + * You shouldn't need to change these unless working with keys that may clash with them. + */ + +#define JSON_ARRAY_INDEX_KEY "__array_index" +#define JSON_META_TYPE_KEY ":type" +#define JSON_META_LENGTH_KEY ":length" +#define JSON_META_HIDDEN_KEY ":hidden" + +/** + * @section General + */ + +/** + * Types of cells within a JSON object + */ +enum JSON_CELL_TYPE { + Type_Invalid = -1, + Type_String = 0, + Type_Int, + Type_Float, + Type_Bool, + Type_Null, + Type_Object +}; + +/** + * Checks whether the key provided is a meta-key that should only be used internally. + * + * @param key Key to check. + * @returns True when it is a meta-key, false otherwise. + */ +stock bool json_is_meta_key(char[] key) +{ + return json_string_endswith(key, JSON_META_TYPE_KEY) + || json_string_endswith(key, JSON_META_LENGTH_KEY) + || json_string_endswith(key, JSON_META_HIDDEN_KEY) + || StrEqual(key, JSON_ARRAY_INDEX_KEY); +} diff --git a/sourcemod/scripting/include/json/encode_helpers.inc b/sourcemod/scripting/include/json/encode_helpers.inc new file mode 100644 index 0000000..37cb83d --- /dev/null +++ b/sourcemod/scripting/include/json/encode_helpers.inc @@ -0,0 +1,164 @@ +/** + * vim: set ts=4 : + * ============================================================================= + * sm-json + * Provides a pure SourcePawn implementation of JSON encoding and decoding. + * https://github.com/clugg/sm-json + * + * sm-json (C)2018 James D. (clug) + * SourceMod (C)2004-2008 AlliedModders LLC. All rights reserved. + * ============================================================================= + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 3.0, as published by the + * Free Software Foundation. + * + * 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, see <http://www.gnu.org/licenses/>. + * + * As a special exception, AlliedModders LLC gives you permission to link the + * code of this program (as well as its derivative works) to "Half-Life 2," the + * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software + * by the Valve Corporation. You must obey the GNU General Public License in + * all respects for all other code used. Additionally, AlliedModders LLC grants + * this exception to all derivative works. AlliedModders LLC defines further + * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007), + * or <http://www.sourcemod.net/license.php>. + */ + +#if defined _json_encode_helpers_included + #endinput +#endif +#define _json_encode_helpers_included + +#include <string> + +/** + * @section Calculating buffer sizes for JSON cells. + */ + +/** + * Calculates the maximum buffer length required to + * store the JSON cell representation of a string. + * + * @param maxlen The string's current length or buffer size. + * @return Maximum buffer length. + */ +stock int json_cell_string_size(int maxlen) { + return (maxlen * 2) + 3; // * 2 for potential escaping, + 2 for surrounding quotes + NULL +} + +/** + * Calculates the maximum buffer length required to + * store the JSON cell representation of an int. + * + * @param input The int. + * @return Maximum buffer length. + */ +stock int json_cell_int_size(int input) { + if (input == 0) { + return 2; // "0" + NULL + } + + return ((input < 0) ? 1 : 0) + RoundToFloor(Logarithm(FloatAbs(float(input)), 10.0)) + 2; // neg sign + number of digits + NULL +} + +/** + * Calculates the maximum buffer length required to + * store the JSON cell representation of a float. + * + * @return Maximum buffer length. + */ +stock int json_cell_float_size() { + return JSON_FLOAT_BUFFER_SIZE; // fixed-length +} + +/** + * Calculates the maximum buffer length required to + * store the JSON cell representation of a bool. + * + * @return Maximum buffer length. + */ +stock int json_cell_bool_size() { + return 6; // "true|false" + NULL +} + +/** + * Calculates the maximum buffer length required to + * store the JSON cell representation of null. + * + * @return Maximum buffer length. + */ +stock int json_cell_null_size() { + return 5; // "null" + NULL +} + +/** + * @section Generating JSON cells. + */ + +/** + * Generates the JSON cell representation of a string. + * + * @param input Value to generate output for. + * @param output String buffer to store output. + * @param maxlen Maximum size of string buffer. + */ +stock void json_cell_string(const char[] input, char[] output, int maxlen) { + strcopy(output, maxlen, "_"); // add dummy char at start so first quotation isn't escaped + StrCat(output, maxlen, input); // add input string to output + // escape everything according to JSON spec + json_escape_string(output, maxlen); + + // surround string with quotations + output[0] = '"'; + StrCat(output, maxlen, "\""); +} + +/** + * Generates the JSON cell representation of an int. + * + * @param input Value to generate output for. + * @param output String buffer to store output. + * @param maxlen Maximum size of string buffer. + */ +stock void json_cell_int(int input, char[] output, int maxlen) { + IntToString(input, output, maxlen); +} + +/** + * Generates the JSON cell representation of a float. + * + * @param input Value to generate output for. + * @param output String buffer to store output. + * @param maxlen Maximum size of string buffer. + */ +stock void json_cell_float(float input, char[] output, int maxlen) { + FloatToString(input, output, maxlen); +} + +/** + * Generates the JSON cell representation of a bool. + * + * @param input Value to generate output for. + * @param output String buffer to store output. + * @param maxlen Maximum size of string buffer. + */ +stock void json_cell_bool(bool input, char[] output, int maxlen) { + strcopy(output, maxlen, (input) ? "true" : "false"); +} + +/** + * Generates the JSON cell representation of null. + * + * @param output String buffer to store output. + * @param maxlen Maximum size of string buffer. + */ +stock void json_cell_null(char[] output, int maxlen) { + strcopy(output, maxlen, "null"); +} diff --git a/sourcemod/scripting/include/json/helpers/decode.inc b/sourcemod/scripting/include/json/helpers/decode.inc new file mode 100644 index 0000000..f420222 --- /dev/null +++ b/sourcemod/scripting/include/json/helpers/decode.inc @@ -0,0 +1,502 @@ +/** + * vim: set ts=4 : + * ============================================================================= + * sm-json + * Provides a pure SourcePawn implementation of JSON encoding and decoding. + * https://github.com/clugg/sm-json + * + * sm-json (C)2019 James Dickens. (clug) + * SourceMod (C)2004-2008 AlliedModders LLC. All rights reserved. + * ============================================================================= + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 3.0, as published by the + * Free Software Foundation. + * + * 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, see <http://www.gnu.org/licenses/>. + * + * As a special exception, AlliedModders LLC gives you permission to link the + * code of this program (as well as its derivative works) to "Half-Life 2," the + * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software + * by the Valve Corporation. You must obey the GNU General Public License in + * all respects for all other code used. Additionally, AlliedModders LLC grants + * this exception to all derivative works. AlliedModders LLC defines further + * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007), + * or <http://www.sourcemod.net/license.php>. + */ + +#if defined _json_helpers_decode_included + #endinput +#endif +#define _json_helpers_decode_included + +#include <string> + +/** + * @section Determine Buffer Contents + */ + +/** + * Checks whether the character at the beginning + * of the buffer is whitespace. + * + * @param buffer String buffer of data. + * @returns True if the first character in the buffer + * is whitespace, false otherwise. + */ +stock bool json_is_whitespace(const char[] buffer) +{ + return buffer[0] == ' ' + || buffer[0] == '\t' + || buffer[0] == '\r' + || buffer[0] == '\n'; +} + +/** + * Checks whether the character at the beginning + * of the buffer is the start of a string. + * + * @param buffer String buffer of data. + * @returns True if the first character in the buffer + * is the start of a string, false otherwise. + */ +stock bool json_is_string(const char[] buffer) +{ + return buffer[0] == '"'; +} + +/** + * Checks whether the buffer provided contains an int. + * + * @param buffer String buffer of data. + * @returns True if buffer contains an int, false otherwise. + */ +stock bool json_is_int(const char[] buffer) +{ + bool starts_with_zero = false; + bool has_digit_gt_zero = false; + + int length = strlen(buffer); + for (int i = 0; i < length; ++i) { + // allow minus as first character only + if (i == 0 && buffer[i] == '-') { + continue; + } + + if (IsCharNumeric(buffer[i])) { + if (buffer[i] == '0') { + if (starts_with_zero) { + // detect repeating leading zeros + return false; + } else if (! has_digit_gt_zero) { + starts_with_zero = true; + } + } else { + has_digit_gt_zero = true; + } + } else { + return false; + } + } + + // buffer must start with zero and have no other numerics before decimal + // OR not start with zero and have other numerics + return (starts_with_zero && ! has_digit_gt_zero) + || (! starts_with_zero && has_digit_gt_zero); +} + +/** + * Checks whether the buffer provided contains a float. + * + * @param buffer String buffer of data. + * @returns True if buffer contains a float, false otherwise. + */ +stock bool json_is_float(const char[] buffer) +{ + bool starts_with_zero = false; + bool has_digit_gt_zero = false; + bool after_decimal = false; + bool has_digit_after_decimal = false; + bool after_exponent = false; + bool has_digit_after_exponent = false; + + int length = strlen(buffer); + for (int i = 0; i < length; ++i) { + // allow minus as first character only + if (i == 0 && buffer[i] == '-') { + continue; + } + + // if we haven't encountered a decimal or exponent yet + if (! after_decimal && ! after_exponent) { + if (buffer[i] == '.') { + // if we encounter a decimal before any digits + if (! starts_with_zero && ! has_digit_gt_zero) { + return false; + } + + after_decimal = true; + } else if (buffer[i] == 'e' || buffer[i] == 'E') { + // if we encounter an exponent before any non-zero digits + if (starts_with_zero && ! has_digit_gt_zero) { + return false; + } + + after_exponent = true; + } else if (IsCharNumeric(buffer[i])) { + if (buffer[i] == '0') { + if (starts_with_zero) { + // detect repeating leading zeros + return false; + } else if (! has_digit_gt_zero) { + starts_with_zero = true; + } + } else { + has_digit_gt_zero = true; + } + } else { + return false; + } + } else if (after_decimal && ! after_exponent) { + // after decimal has been encountered, allow any numerics + if (IsCharNumeric(buffer[i])) { + has_digit_after_decimal = true; + } else if (buffer[i] == 'e' || buffer[i] == 'E') { + if (! has_digit_after_decimal) { + // detect exponents directly after decimal + return false; + } + + after_exponent = true; + } else { + return false; + } + } else if (after_exponent) { + if ( + (buffer[i] == '+' || buffer[i] == '-') + && (buffer[i - 1] == 'e' || buffer[i - 1] == 'E') + ) { + // allow + or - directly after exponent + continue; + } else if (IsCharNumeric(buffer[i])) { + has_digit_after_exponent = true; + } else { + return false; + } + } + } + + if (starts_with_zero && has_digit_gt_zero) { + /* if buffer starts with zero, there should + be no other digits before the decimal */ + return false; + } + + // if we have a decimal, there should be digit(s) after it + if (after_decimal) { + if (! has_digit_after_decimal) { + return false; + } + } + + // if we have an exponent, there should be digit(s) after it + if (after_exponent) { + if (! has_digit_after_exponent) { + return false; + } + } + + /* we should have reached an exponent, decimal, or both. + otherwise, this number can be handled by the int parser */ + return after_decimal || after_exponent; +} + +/** + * Checks whether the buffer provided contains a bool. + * + * @param buffer String buffer of data. + * @returns True if buffer contains a bool, false otherwise. + */ +stock bool json_is_bool(const char[] buffer) +{ + return StrEqual(buffer, "true") || StrEqual(buffer, "false"); +} + +/** + * Checks whether the buffer provided contains null. + * + * @param buffer String buffer of data. + * @returns True if buffer contains null, false otherwise. + */ +stock bool json_is_null(const char[] buffer) +{ + return StrEqual(buffer, "null"); +} + +/** + * Checks whether the character at the beginning + * of the buffer is the start of an object. + * + * @param buffer String buffer of data. + * @returns True if the first character in the buffer is + * the start of an object, false otherwise. + */ +stock bool json_is_object(const char[] buffer) +{ + return buffer[0] == '{'; +} + +/** + * Checks whether the character at the beginning + * of the buffer is the end of an object. + * + * @param buffer String buffer of data. + * @returns True if the first character in the buffer is + * the end of an object, false otherwise. + */ +stock bool json_is_object_end(const char[] buffer) +{ + return buffer[0] == '}'; +} + +/** + * Checks whether the character at the beginning + * of the buffer is the start of an array. + * + * @param buffer String buffer of data. + * @returns True if the first character in the buffer is + * the start of an array, false otherwise. + */ +stock bool json_is_array(const char[] buffer) +{ + return buffer[0] == '['; +} + +/** + * Checks whether the character at the beginning + * of the buffer is the end of an array. + * + * @param buffer String buffer of data. + * @returns True if the first character in the buffer is + * the end of an array, false otherwise. + */ +stock bool json_is_array_end(const char[] buffer) +{ + return buffer[0] == ']'; +} + +/** + * Checks whether the character at the beginning of the buffer + * is considered a valid 'end point' for some data, such as a + * colon (indicating a key), a comma (indicating a new element), + * or the end of an object or array. + * + * @param buffer String buffer of data. + * @returns True if the first character in the buffer + * is a valid data end point, false otherwise. + */ +stock bool json_is_at_end(const char[] buffer, bool is_array) +{ + return buffer[0] == ',' + || (! is_array && buffer[0] == ':') + || json_is_object_end(buffer[0]) + || json_is_array_end(buffer[0]); +} + +/** + * @section Extract Contents from Buffer + */ + +/** + * Moves the position until it reaches a non-whitespace + * character or the end of the buffer's maximum size. + * + * @param buffer String buffer of data. + * @param max_size Maximum size of string buffer. + * @param pos Position to increment. + * @returns True if pos has not reached the end + * of the buffer, false otherwise. + */ +stock bool json_skip_whitespace(const char[] buffer, int max_size, int &pos) +{ + while (json_is_whitespace(buffer[pos]) && pos < max_size) { + ++pos; + } + + return pos < max_size; +} + +/** + * Extracts a JSON cell from the buffer until + * a valid end point is reached. + * + * @param buffer String buffer of data. + * @param max_size Maximum size of string buffer. + * @param pos Position to increment. + * @param output String buffer to store output. + * @param output_max_size Maximum size of output string buffer. + * @param is_array Whether the decoder is processing an array. + * @returns True if pos has not reached the end + * of the buffer, false otherwise. + */ +stock bool json_extract_until_end( + const char[] buffer, + int max_size, + int &pos, + char[] output, + int output_max_size, + bool is_array +) { + strcopy(output, output_max_size, ""); + + // set start to position of first character in cell + int start = pos; + + // while we haven't hit whitespace, an end point or the end of the buffer + while ( + ! json_is_whitespace(buffer[pos]) + && ! json_is_at_end(buffer[pos], is_array) + && pos < max_size + ) { + ++pos; + } + + // set end to the current position + int end = pos; + + // skip any following whitespace + json_skip_whitespace(buffer, max_size, pos); + + // if we aren't at a valid endpoint, extraction has failed + if (! json_is_at_end(buffer[pos], is_array)) { + return false; + } + + // copy only from start with length end - start + NULL terminator + strcopy(output, end - start + 1, buffer[start]); + + return pos < max_size; +} + +/** + * Extracts a JSON string from the buffer until + * a valid end point is reached. + * + * @param buffer String buffer of data. + * @param max_size Maximum size of string buffer. + * @param pos Position to increment. + * @param output String buffer to store output. + * @param output_max_size Maximum size of output string buffer. + * @param is_array Whether the decoder is processing an array. + * @returns True if pos has not reached the end + * of the buffer, false otherwise. + */ +stock bool json_extract_string( + const char[] buffer, + int max_size, + int &pos, + char[] output, + int output_max_size, + bool is_array +) { + strcopy(output, output_max_size, ""); + + // increment past opening quote + ++pos; + + // set start to position of first character in string + int start = pos; + + // while we haven't hit the end of the buffer + while (pos < max_size) { + // check for unescaped control characters + if ( + buffer[pos] == '\b' + || buffer[pos] == '\f' + || buffer[pos] == '\n' + || buffer[pos] == '\r' + || buffer[pos] == '\t' + ) { + return false; + } + + if (buffer[pos] == '"') { + // count preceding backslashes to check if quote is escaped + int search_pos = pos; + int preceding_backslashes = 0; + while (search_pos > 0 && buffer[--search_pos] == '\\') { + ++preceding_backslashes; + } + + // if we have an even number of backslashes, the quote is not escaped + if (preceding_backslashes % 2 == 0) { + break; + } + } + + // pass over the character as it is part of the string + ++pos; + } + + // set end to the current position + int end = pos; + + // increment past closing quote + ++pos; + + // skip trailing whitespace + if (! json_skip_whitespace(buffer, max_size, pos)) { + return false; + } + + // if we haven't reached an ending character at the end of the cell, + // there is likely junk data not encapsulated by a string + if (! json_is_at_end(buffer[pos], is_array)) { + return false; + } + + // copy only from start with length end - start + NULL terminator + strcopy(output, end - start + 1, buffer[start]); + json_unescape_string(output, max_size); + + return pos < max_size; +} + +/** + * Extracts an int from the buffer. + * + * @param buffer String buffer of data. + * @returns Int value of the buffer. + */ +stock int json_extract_int(const char[] buffer) +{ + return StringToInt(buffer); +} + +/** + * Extracts a float from the buffer. + * + * @param buffer String buffer of data. + * @returns Float value of the buffer. + */ +stock float json_extract_float(const char[] buffer) +{ + return StringToFloat(buffer); +} + +/** + * Extracts a bool from the buffer. + * + * @param buffer String buffer of data. + * @returns Bool value of the buffer. + */ +stock bool json_extract_bool(const char[] buffer) +{ + return StrEqual(buffer, "true"); +} diff --git a/sourcemod/scripting/include/json/helpers/encode.inc b/sourcemod/scripting/include/json/helpers/encode.inc new file mode 100644 index 0000000..ceae54d --- /dev/null +++ b/sourcemod/scripting/include/json/helpers/encode.inc @@ -0,0 +1,200 @@ +/** + * vim: set ts=4 : + * ============================================================================= + * sm-json + * Provides a pure SourcePawn implementation of JSON encoding and decoding. + * https://github.com/clugg/sm-json + * + * sm-json (C)2019 James Dickens. (clug) + * SourceMod (C)2004-2008 AlliedModders LLC. All rights reserved. + * ============================================================================= + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 3.0, as published by the + * Free Software Foundation. + * + * 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, see <http://www.gnu.org/licenses/>. + * + * As a special exception, AlliedModders LLC gives you permission to link the + * code of this program (as well as its derivative works) to "Half-Life 2," the + * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software + * by the Valve Corporation. You must obey the GNU General Public License in + * all respects for all other code used. Additionally, AlliedModders LLC grants + * this exception to all derivative works. AlliedModders LLC defines further + * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007), + * or <http://www.sourcemod.net/license.php>. + */ + +#if defined _json_helpers_encode_included + #endinput +#endif +#define _json_helpers_encode_included + +#include <string> + +/** + * @section Calculate Buffer Size for Value + */ + +/** + * Calculates the maximum buffer length required to + * store the JSON cell representation of a string. + * + * @param length The length of the string. + * @returns Maximum buffer length. + */ +stock int json_cell_string_size(int length) +{ + // double for potential escaping, + 2 for outside quotes + NULL terminator + return (length * 2) + 3; +} + +/** + * Calculates the maximum buffer length required to + * store the JSON cell representation of an int. + * + * @param input Value to calculate maximum buffer length for. + * @returns Maximum buffer length. + */ +stock int json_cell_int_size(int input) +{ + if (input == 0) { + // "0" + NULL terminator + return 2; + } + + int result = 0; + if (input < 0) { + // negative sign + result += 1; + } + + // calculate number of digits in number + result += RoundToFloor(Logarithm(FloatAbs(float(input)), 10.0)) + 1; + + // NULL terminator + result += 1; + + return result; +} + +/** + * Calculates the maximum buffer length required to + * store the JSON cell representation of a float. + * + * @returns Maximum buffer length. + */ +stock int json_cell_float_size() +{ + return JSON_FLOAT_BUFFER_SIZE; +} + +/** + * Calculates the maximum buffer length required to + * store the JSON cell representation of a bool. + * + * @returns Maximum buffer length. + */ +stock int json_cell_bool_size() +{ + // "true"|"false" + NULL terminator + return 6; +} + +/** + * Calculates the maximum buffer length required to + * store the JSON cell representation of null. + * + * @returns Maximum buffer length. + */ +stock int json_cell_null_size() +{ + // "null" + NULL terminator + return 5; +} + +/** + * @section Convert Values to JSON Cells + */ + +/** + * Generates the JSON cell representation of a string. + * + * @param input Value to generate output for. + * @param output String buffer to store output. + * @param max_size Maximum size of string buffer. + */ +stock void json_cell_string(const char[] input, char[] output, int max_size) +{ + // add dummy char that won't be escaped to replace with a quote later + strcopy(output, max_size, "?"); + + // add input string to output + StrCat(output, max_size, input); + + // escape the output string + json_escape_string(output, max_size); + + // surround string with quotations + output[0] = '"'; + StrCat(output, max_size, "\""); +} + +/** + * Generates the JSON cell representation of an int. + * + * @param input Value to generate output for. + * @param output String buffer to store output. + * @param max_size Maximum size of string buffer. + */ +stock void json_cell_int(int input, char[] output, int max_size) +{ + IntToString(input, output, max_size); +} + +/** + * Generates the JSON cell representation of a float. + * + * @param input Value to generate output for. + * @param output String buffer to store output. + * @param max_size Maximum size of string buffer. + */ +stock void json_cell_float(float input, char[] output, int max_size) +{ + FloatToString(input, output, max_size); + + // trim trailing 0s from float output up until decimal point + int last_char = strlen(output) - 1; + while (output[last_char] == '0' && output[last_char - 1] != '.') { + output[last_char--] = '\0'; + } +} + +/** + * Generates the JSON cell representation of a bool. + * + * @param input Value to generate output for. + * @param output String buffer to store output. + * @param max_size Maximum size of string buffer. + */ +stock void json_cell_bool(bool input, char[] output, int max_size) +{ + strcopy(output, max_size, (input) ? "true" : "false"); +} + +/** + * Generates the JSON cell representation of null. + * + * @param output String buffer to store output. + * @param max_size Maximum size of string buffer. + */ +stock void json_cell_null(char[] output, int max_size) +{ + strcopy(output, max_size, "null"); +} diff --git a/sourcemod/scripting/include/json/helpers/string.inc b/sourcemod/scripting/include/json/helpers/string.inc new file mode 100644 index 0000000..14fe38a --- /dev/null +++ b/sourcemod/scripting/include/json/helpers/string.inc @@ -0,0 +1,133 @@ +/** + * vim: set ts=4 : + * ============================================================================= + * sm-json + * Provides a pure SourcePawn implementation of JSON encoding and decoding. + * https://github.com/clugg/sm-json + * + * sm-json (C)2019 James Dickens. (clug) + * SourceMod (C)2004-2008 AlliedModders LLC. All rights reserved. + * ============================================================================= + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 3.0, as published by the + * Free Software Foundation. + * + * 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, see <http://www.gnu.org/licenses/>. + * + * As a special exception, AlliedModders LLC gives you permission to link the + * code of this program (as well as its derivative works) to "Half-Life 2," the + * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software + * by the Valve Corporation. You must obey the GNU General Public License in + * all respects for all other code used. Additionally, AlliedModders LLC grants + * this exception to all derivative works. AlliedModders LLC defines further + * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007), + * or <http://www.sourcemod.net/license.php>. + */ + +#if defined _json_helpers_string_included + #endinput +#endif +#define _json_helpers_string_included + +/** + * Mapping characters to their escaped form. + */ +char JSON_STRING_NORMAL[][] = { + "\\", "\"", "/", "\b", "\f", "\n", "\r", "\t" +}; +char JSON_STRING_ESCAPED[][] = { + "\\\\", "\\\"", "\\/", "\\b", "\\f", "\\n", "\\r", "\\t" +}; + +/** + * Escapes a string in-place in a buffer. + * + * @param buffer String buffer. + * @param max_size Maximum size of string buffer. + */ +stock void json_escape_string(char[] buffer, int max_size) +{ + for (int i = 0; i < sizeof(JSON_STRING_NORMAL); ++i) { + ReplaceString( + buffer, + max_size, + JSON_STRING_NORMAL[i], + JSON_STRING_ESCAPED[i] + ); + } +} + +/** + * Unescapes a string in-place in a buffer. + * + * @param buffer String buffer. + * @param max_size Maximum size of string buffer. + */ +stock void json_unescape_string(char[] buffer, int max_size) +{ + for (int i = 0; i < sizeof(JSON_STRING_NORMAL); ++i) { + ReplaceString( + buffer, + max_size, + JSON_STRING_ESCAPED[i], + JSON_STRING_NORMAL[i] + ); + } +} + +/** + * Checks if a string starts with another string. + * + * @param haystack String to check that starts with needle. + * @param max_size Maximum size of string buffer. + * @param needle String to check that haystack starts with. + * @returns True if haystack begins with needle, false otherwise. + */ +stock bool json_string_startswith(const char[] haystack, const char[] needle) +{ + int haystack_length = strlen(haystack); + int needle_length = strlen(needle); + if (needle_length > haystack_length) { + return false; + } + + for (int i = 0; i < needle_length; ++i) { + if (haystack[i] != needle[i]) { + return false; + } + } + + return true; +} + +/** + * Checks if a string ends with another string. + * + * @param haystack String to check that ends with needle. + * @param max_size Maximum size of string buffer. + * @param needle String to check that haystack ends with. + * @returns True if haystack ends with needle, false otherwise. + */ +stock bool json_string_endswith(const char[] haystack, const char[] needle) +{ + int haystack_length = strlen(haystack); + int needle_length = strlen(needle); + if (needle_length > haystack_length) { + return false; + } + + for (int i = 0; i < needle_length; ++i) { + if (haystack[haystack_length - needle_length + i] != needle[i]) { + return false; + } + } + + return true; +} diff --git a/sourcemod/scripting/include/json/object.inc b/sourcemod/scripting/include/json/object.inc new file mode 100644 index 0000000..8d17568 --- /dev/null +++ b/sourcemod/scripting/include/json/object.inc @@ -0,0 +1,1014 @@ +/** + * vim: set ts=4 : + * ============================================================================= + * sm-json + * Provides a pure SourcePawn implementation of JSON encoding and decoding. + * https://github.com/clugg/sm-json + * + * sm-json (C)2019 James Dickens. (clug) + * SourceMod (C)2004-2008 AlliedModders LLC. All rights reserved. + * ============================================================================= + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 3.0, as published by the + * Free Software Foundation. + * + * 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, see <http://www.gnu.org/licenses/>. + * + * As a special exception, AlliedModders LLC gives you permission to link the + * code of this program (as well as its derivative works) to "Half-Life 2," the + * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software + * by the Valve Corporation. You must obey the GNU General Public License in + * all respects for all other code used. Additionally, AlliedModders LLC grants + * this exception to all derivative works. AlliedModders LLC defines further + * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007), + * or <http://www.sourcemod.net/license.php>. + */ + +#if defined _json_object_included + #endinput +#endif +#define _json_object_included + +#include <string> +#include <json/definitions> +#include <json/helpers/encode> +#include <json> + +methodmap JSON_Object < StringMap +{ + /** + * Creates a new JSON_Object. + * + * @param is_array Should the object created be an array? [default: false] + * @returns A new JSON_Object. + */ + public JSON_Object(bool is_array = false) + { + StringMap self = CreateTrie(); + if (is_array) { + self.SetValue(JSON_ARRAY_INDEX_KEY, 0); + } + + return view_as<JSON_Object>(self); + } + + /** + * Checks whether the object has a key. + * + * @param key Key to check existence of. + * @returns True if the key exists, false otherwise. + */ + public bool HasKey(const char[] key) + { + int dummy_int; + char dummy_str[1]; + + return this.GetValue(key, dummy_int) + || this.GetString(key, dummy_str, sizeof(dummy_str)); + } + + /** + * @section Array helpers. + */ + + /** + * Whether the current object is an array. + */ + property bool IsArray { + public get() + { + return this.HasKey(JSON_ARRAY_INDEX_KEY); + } + } + + /** + * The current index of the object if it is an array, or -1 otherwise. + */ + property int CurrentIndex { + public get() + { + if (! this.IsArray) { + return -1; + } + + int result; + return (this.GetValue(JSON_ARRAY_INDEX_KEY, result)) ? result : -1; + } + + public set(int value) + { + this.SetValue(JSON_ARRAY_INDEX_KEY, value); + } + } + + /** + * The number of items in the object if it is an array, + * or the number of keys (including meta-keys) otherwise. + */ + property int Length { + public get() + { + StringMapSnapshot snap = this.Snapshot(); + int length = (this.IsArray) ? this.CurrentIndex : snap.Length; + delete snap; + + return length; + } + } + + /** + * Increments the current index of the object. + * + * @returns True on success, false if the current object is not an array. + */ + public bool IncrementIndex() + { + if (! this.HasKey(JSON_ARRAY_INDEX_KEY)) { + return false; + } + + this.CurrentIndex += 1; + + return true; + } + + /** + * Checks whether the object has an index. + * + * @param index Index to check existence of. + * @returns True if the index exists, false otherwise. + */ + public bool HasIndex(int index) + { + return index >= 0 && index < this.Length; + } + + /** + * Gets the string representation of an array index. + * + * @param output String buffer to store output. + * @param max_size Maximum size of string buffer. + * @param key Key to get string for. [default: current index] + * @returns True on success, false otherwise. + */ + public int GetIndexString(char[] output, int max_size, int key = -1) + { + key = (key == -1) ? this.CurrentIndex : key; + if (key == -1) { + return false; + } + + return IntToString(key, output, max_size); + } + + /** + * @section Internal Getters + */ + + /** + * Gets the cell type stored at a key. + * + * @param key Key to get value type for. + * @returns Value type for key provided, + * or Type_Invalid if it does not exist. + */ + public JSON_CELL_TYPE GetKeyType(const char[] key) + { + int max_size = strlen(key) + strlen(JSON_META_TYPE_KEY) + 1; + char[] type_key = new char[max_size]; + Format(type_key, max_size, "%s%s", key, JSON_META_TYPE_KEY); + + JSON_CELL_TYPE type; + return (this.GetValue(type_key, type)) ? type : Type_Invalid; + } + + /** + * Gets the cell type stored at an index. + * + * @param index Index to get value type for. + * @returns Value type for index provided, or Type_Invalid if it does not exist. + */ + public JSON_CELL_TYPE GetKeyTypeIndexed(int index) + { + char key[JSON_INDEX_BUFFER_SIZE]; + if (! this.GetIndexString(key, sizeof(key), index)) { + return Type_Invalid; + } + + return this.GetKeyType(key); + } + + /** + * Gets the length of the string stored at a key. + * + * @param key Key to get string length for. + * @returns Length of string at key provided, + * or -1 if it is not a string/does not exist. + */ + public int GetKeyLength(const char[] key) + { + int max_size = strlen(key) + strlen(JSON_META_LENGTH_KEY) + 1; + char[] length_key = new char[max_size]; + Format(length_key, max_size, "%s%s", key, JSON_META_LENGTH_KEY); + + int length; + return (this.GetValue(length_key, length)) ? length : -1; + } + + /** + * Gets the length of the string stored at an index. + * + * @param index Index to get string length for. + * @returns Length of string at index provided, or -1 if it is not a string/does not exist. + */ + public int GetKeyLengthIndexed(int index) + { + char key[JSON_INDEX_BUFFER_SIZE]; + if (! this.GetIndexString(key, sizeof(key), index)) { + return -1; + } + + return this.GetKeyLength(key); + } + + /** + * Gets whether the key should be hidden from encoding. + * + * @param key Key to get hidden state for. + * @returns Whether or not the key should be hidden. + */ + public bool GetKeyHidden(const char[] key) + { + int max_size = strlen(key) + strlen(JSON_META_HIDDEN_KEY) + 1; + char[] length_key = new char[max_size]; + Format(length_key, max_size, "%s%s", key, JSON_META_HIDDEN_KEY); + + bool hidden; + return (this.GetValue(length_key, hidden)) ? hidden : false; + } + + /** + * Gets whether the index should be hidden from encoding. + * + * @param index Index to get hidden state for. + * @returns Whether or not the index should be hidden. + */ + public bool GetKeyHiddenIndexed(int index) + { + char key[JSON_INDEX_BUFFER_SIZE]; + if (! this.GetIndexString(key, sizeof(key), index)) { + return false; + } + + return this.GetKeyHidden(key); + } + + /** + * @section Internal Setters + */ + + /** + * Sets the cell type stored at a key. + * + * @param key Key to set value type for. + * @param type Type to set key to. + * @returns True on success, false otherwise. + */ + public bool SetKeyType(const char[] key, JSON_CELL_TYPE type) + { + int max_size = strlen(key) + strlen(JSON_META_TYPE_KEY) + 1; + char[] type_key = new char[max_size]; + Format(type_key, max_size, "%s%s", key, JSON_META_TYPE_KEY); + + return this.SetValue(type_key, type); + } + + /** + * Sets the cell type stored at an index. + * + * @param index Index to set value type for. + * @param type Type to set index to. + * @returns True on success, false otherwise. + */ + public bool SetKeyTypeIndexed(int index, JSON_CELL_TYPE value) + { + char key[JSON_INDEX_BUFFER_SIZE]; + if (! this.GetIndexString(key, sizeof(key), index)) { + return false; + } + + return this.SetKeyType(key, value); + } + + /** + * Sets the length of the string stored at a key. + * + * @param key Key to set string length for. + * @param length Length to set string to. + * @returns True on success, false otherwise. + */ + public bool SetKeyLength(const char[] key, int length) + { + int max_size = strlen(key) + strlen(JSON_META_LENGTH_KEY) + 1; + char[] length_key = new char[max_size]; + Format(length_key, max_size, "%s%s", key, JSON_META_LENGTH_KEY); + + return this.SetValue(length_key, length); + } + + /** + * Sets the length of the string stored at an index. + * + * @param index Index to set string length for. + * @param length Length to set string to. + * @returns True on success, false otherwise. + */ + public bool SetKeyLengthIndexed(int index, int length) + { + char key[JSON_INDEX_BUFFER_SIZE]; + if (! this.GetIndexString(key, sizeof(key), index)) { + return false; + } + + return this.SetKeyLength(key, length); + } + + /** + * Sets whether the key should be hidden from encoding. + * + * @param key Key to set hidden state for. + * @param hidden Wheter or not the key should be hidden. + * @returns True on success, false otherwise. + */ + public bool SetKeyHidden(const char[] key, bool hidden) + { + int max_size = strlen(key) + strlen(JSON_META_HIDDEN_KEY) + 1; + char[] hidden_key = new char[max_size]; + Format(hidden_key, max_size, "%s%s", key, JSON_META_HIDDEN_KEY); + + return this.SetValue(hidden_key, hidden); + } + + /** + * Sets whether the index should be hidden from encoding. + * + * @param index Index to set hidden state for. + * @param hidden Wheter or not the index should be hidden. + * @returns True on success, false otherwise. + */ + public bool SetKeyHiddenIndexed(int index, bool hidden) + { + char key[JSON_INDEX_BUFFER_SIZE]; + if (! this.GetIndexString(key, sizeof(key), index)) { + return false; + } + + return this.SetKeyHidden(key, hidden); + } + + /** + * @section Getters + */ + + // GetValue is implemented natively by StringMap + + /** + * Retrieves the value stored at an index. + * + * @param index Index to retrieve value for. + * @param value Variable to store value. + * @returns Value stored at index. + */ + public bool GetValueIndexed(int index, any &value) + { + char key[JSON_INDEX_BUFFER_SIZE]; + if (! this.GetIndexString(key, sizeof(key), index)) { + return false; + } + + return this.GetValue(key, value); + } + + // GetString is implemented natively by StringMap + + /** + * Retrieves the string stored at an index. + * + * @param index Index to retrieve string value for. + * @param value String buffer to store output. + * @param max_size Maximum size of string buffer. + * @returns True on success. False if the key is not set, or the key is set as a value or array (not a string). + */ + public bool GetStringIndexed(int index, char[] value, int max_size) + { + char key[JSON_INDEX_BUFFER_SIZE]; + if (! this.GetIndexString(key, sizeof(key), index)) { + return false; + } + + return this.GetString(key, value, max_size); + } + + /** + * Retrieves the int stored at a key. + * + * @param key Key to retrieve int value for. + * @returns Value stored at key. + */ + public int GetInt(const char[] key) + { + int value; + return (this.GetValue(key, value)) ? value : -1; + } + + /** + * Retrieves the int stored at an index. + * + * @param index Index to retrieve int value for. + * @returns Value stored at index. + */ + public int GetIntIndexed(int index) + { + char key[JSON_INDEX_BUFFER_SIZE]; + if (! this.GetIndexString(key, sizeof(key), index)) { + return -1; + } + + return this.GetInt(key); + } + + /** + * Retrieves the float stored at a key. + * + * @param key Key to retrieve float value for. + * @returns Value stored at key. + */ + public float GetFloat(const char[] key) + { + float value; + return (this.GetValue(key, value)) ? value : -1.0; + } + + /** + * Retrieves the float stored at an index. + * + * @param index Index to retrieve float value for. + * @returns Value stored at index. + */ + public float GetFloatIndexed(int index) + { + char key[JSON_INDEX_BUFFER_SIZE]; + if (! this.GetIndexString(key, sizeof(key), index)) { + return -1.0; + } + + return this.GetFloat(key); + } + + /** + * Retrieves the bool stored at a key. + * + * @param key Key to retrieve bool value for. + * @returns Value stored at key. + */ + public bool GetBool(const char[] key) + { + bool value; + return (this.GetValue(key, value)) ? value : false; + } + + /** + * Retrieves the bool stored at an index. + * + * @param index Index to retrieve bool value for. + * @returns Value stored at index. + */ + public bool GetBoolIndexed(int index) + { + char key[JSON_INDEX_BUFFER_SIZE]; + if (! this.GetIndexString(key, sizeof(key), index)) { + return false; + } + + return this.GetBool(key); + } + + /** + * Retrieves the handle stored at a key. + * + * @param key Key to retrieve handle value for. + * @returns Value stored at key. + */ + public Handle GetHandle(const char[] key) + { + Handle value; + return (this.GetValue(key, value)) ? value : null; + } + + /** + * Retrieves the handle stored at an index. + * + * @param index Index to retrieve handle value for. + * @returns Value stored at index. + */ + public Handle GetHandleIndexed(int index) + { + char key[JSON_INDEX_BUFFER_SIZE]; + if (! this.GetIndexString(key, sizeof(key), index)) { + return null; + } + + return this.GetHandle(key); + } + + /** + * Retrieves the JSON object stored at a key. + * + * @param key Key to retrieve object value for. + * @returns Value stored at key. + */ + public JSON_Object GetObject(const char[] key) + { + return view_as<JSON_Object>(this.GetHandle(key)); + } + + /** + * Retrieves the object stored at an index. + * + * @param index Index to retrieve object value for. + * @returns Value stored at index. + */ + public JSON_Object GetObjectIndexed(int index) + { + char key[JSON_INDEX_BUFFER_SIZE]; + if (! this.GetIndexString(key, sizeof(key), index)) { + return null; + } + + return this.GetObject(key); + } + + /** + * @section Setters + */ + + /** + * Sets the string stored at a key. + * + * @param key Key to set to string value. + * @param value Value to set. + * @returns True on success, false otherwise. + */ + public bool SetString(const char[] key, const char[] value, bool replace = true) + { + return this.SetString(key, value, replace) + && this.SetKeyType(key, Type_String) + && this.SetKeyLength(key, strlen(value)); + } + + /** + * Sets the string stored at an index. + * + * @param index Index to set to string value. + * @param value Value to set. + * @returns True on success, false otherwise. + */ + public bool SetStringIndexed(int index, const char[] value, bool replace = true) + { + char key[JSON_INDEX_BUFFER_SIZE]; + if (! this.GetIndexString(key, sizeof(key), index)) { + return false; + } + + return this.SetString(key, value, replace); + } + + /** + * Sets the int stored at a key. + * + * @param key Key to set to int value. + * @param value Value to set. + * @returns True on success, false otherwise. + */ + public bool SetInt(const char[] key, int value, bool replace = true) + { + return this.SetValue(key, value, replace) + && this.SetKeyType(key, Type_Int); + } + + /** + * Sets the int stored at an index. + * + * @param index Index to set to int value. + * @param value Value to set. + * @returns True on success, false otherwise. + */ + public bool SetIntIndexed(int index, int value, bool replace = true) + { + char key[JSON_INDEX_BUFFER_SIZE]; + if (! this.GetIndexString(key, sizeof(key), index)) { + return false; + } + + return this.SetInt(key, value, replace); + } + + /** + * Sets the float stored at a key. + * + * @param key Key to set to float value. + * @param value Value to set. + * @returns True on success, false otherwise. + */ + public bool SetFloat(const char[] key, float value, bool replace = true) + { + return this.SetValue(key, value, replace) + && this.SetKeyType(key, Type_Float); + } + + /** + * Sets the float stored at an index. + * + * @param index Index to set to float value. + * @param value Value to set. + * @returns True on success, false otherwise. + */ + public bool SetFloatIndexed(int index, float value, bool replace = true) + { + char key[JSON_INDEX_BUFFER_SIZE]; + if (! this.GetIndexString(key, sizeof(key), index)) { + return false; + } + + return this.SetFloat(key, value, replace); + } + + /** + * Sets the bool stored at a key. + * + * @param key Key to set to bool value. + * @param value Value to set. + * @returns True on success, false otherwise. + */ + public bool SetBool(const char[] key, bool value, bool replace = true) + { + return this.SetValue(key, value, replace) + && this.SetKeyType(key, Type_Bool); + } + + /** + * Sets the bool stored at an index. + * + * @param index Index to set to bool value. + * @param value Value to set. + * @returns True on success, false otherwise. + */ + public bool SetBoolIndexed(int index, bool value, bool replace = true) + { + char key[JSON_INDEX_BUFFER_SIZE]; + if (! this.GetIndexString(key, sizeof(key), index)) { + return false; + } + + return this.SetBool(key, value, replace); + } + + /** + * Sets the handle stored at a key. + * + * @param key Key to set to handle value. + * @param value Value to set. + * @returns True on success, false otherwise. + */ + public bool SetHandle(const char[] key, Handle value = null, bool replace = true) + { + return this.SetValue(key, value, replace) + && this.SetKeyType(key, Type_Null); + } + + /** + * Sets the handle stored at an index. + * + * @param index Index to set to handle value. + * @param value Value to set. + * @returns True on success, false otherwise. + */ + public bool SetHandleIndexed(int index, Handle value = null, bool replace = true) + { + char key[JSON_INDEX_BUFFER_SIZE]; + if (! this.GetIndexString(key, sizeof(key), index)) { + return false; + } + + return this.SetHandle(key, value, replace); + } + + /** + * Sets the object stored at a key. + * + * @param key Key to set to object value. + * @param value Value to set. + * @returns True on success, false otherwise. + */ + public bool SetObject(const char[] key, JSON_Object value, bool replace = true) + { + return this.SetValue(key, value, replace) + && this.SetKeyType(key, Type_Object); + } + + /** + * Sets the object stored at an index. + * + * @param index Index to set to object value. + * @param value Value to set. + * @returns True on success, false otherwise. + */ + public bool SetObjectIndexed(int index, JSON_Object value, bool replace = true) + { + char key[JSON_INDEX_BUFFER_SIZE]; + if (! this.GetIndexString(key, sizeof(key), index)) { + return false; + } + + return this.SetObject(key, value, replace); + } + + /** + * @section Array setters. + */ + + /** + * Pushes a string to the end of the array. + * + * @param value Value to push. + * @returns True on success, false otherwise. + */ + public bool PushString(const char[] value) + { + return this.SetStringIndexed(this.CurrentIndex, value) + && this.IncrementIndex(); + } + + /** + * Pushes an int to the end of the array. + * + * @param value Value to push. + * @returns True on success, false otherwise. + */ + public bool PushInt(int value) + { + return this.SetIntIndexed(this.CurrentIndex, value) + && this.IncrementIndex(); + } + + /** + * Pushes a float to the end of the array. + * + * @param value Value to push. + * @returns True on success, false otherwise. + */ + public bool PushFloat(float value) + { + return this.SetFloatIndexed(this.CurrentIndex, value) + && this.IncrementIndex(); + } + + /** + * Pushes a bool to the end of the array. + * + * @param value Value to push. + * @returns True on success, false otherwise. + */ + public bool PushBool(bool value) + { + return this.SetBoolIndexed(this.CurrentIndex, value) + && this.IncrementIndex(); + } + + /** + * Pushes a handle to the end of the array. + * + * @param value Value to push. + * @returns True on success, false otherwise. + */ + public bool PushHandle(Handle value = null) + { + return this.SetHandleIndexed(this.CurrentIndex, value) + && this.IncrementIndex(); + } + + /** + * Pushes an object to the end of the array. + * + * @param value Value to push. + * @returns True on success, false otherwise. + */ + public bool PushObject(JSON_Object value) + { + return this.SetObjectIndexed(this.CurrentIndex, value) + && this.IncrementIndex(); + } + + /** + * @section Generic. + */ + + /** + * Finds the index of a value in the array. + * + * @param value Value to search for. + * @returns The index of the value if it is found, -1 otherwise. + */ + public int IndexOf(any value) + { + any current; + for (int i = 0; i < this.CurrentIndex; ++i) { + if (this.GetValueIndexed(i, current) && value == current) { + return i; + } + } + + return -1; + } + + /** + * Finds the index of a string in the array. + * + * @param value String to search for. + * @returns The index of the string if it is found, -1 otherwise. + */ + public int IndexOfString(const char[] value) + { + for (int i = 0; i < this.CurrentIndex; ++i) { + if (this.GetKeyTypeIndexed(i) != Type_String) { + continue; + } + + int current_size = this.GetKeyLengthIndexed(i) + 1; + char[] current = new char[current_size]; + this.GetStringIndexed(i, current, current_size); + if (StrEqual(value, current)) { + return i; + } + } + + return -1; + } + + /** + * Determines whether the array contains a value. + * + * @param value Value to search for. + * @returns True if the value is found, false otherwise. + */ + public bool Contains(any value) + { + return this.IndexOf(value) != -1; + } + + /** + * Determines whether the array contains a string. + * + * @param value String to search for. + * @returns True if the string is found, false otherwise. + */ + public bool ContainsString(const char[] value) + { + return this.IndexOfString(value) != -1; + } + + /** + * Removes an item from the object by key. + * + * @param key Key of object to remove. + * @returns True on success, false if the value was never set. + */ + public bool Remove(const char[] key) { + static char meta_keys[][] = { + JSON_META_TYPE_KEY, JSON_META_LENGTH_KEY, JSON_META_HIDDEN_KEY + }; + + // create a new char[] which will fit the longest meta-key + int meta_key_size = strlen(key) + 8; + char[] meta_key = new char[meta_key_size]; + + // view ourselves as a StringMap so we can call underlying Remove() method + StringMap self = view_as<StringMap>(this); + + bool success = true; + for (int i = 0; i < sizeof(meta_keys); ++i) { + Format(meta_key, meta_key_size, "%s%s", key, meta_keys[i]); + + if (this.HasKey(meta_key)) { + success = success && self.Remove(meta_key); + } + } + + return success && self.Remove(key); + } + + /** + * Removes a key and its related meta-keys from the object. + * + * @param key Key to remove. + * @returns True on success, false if the value was never set. + */ + public bool RemoveIndexed(int index) + { + if (! this.HasIndex(index)) { + return false; + } + + char key[JSON_INDEX_BUFFER_SIZE]; + if (! this.GetIndexString(key, sizeof(key), index)) { + return false; + } + + if (! this.Remove(key)) { + return false; + } + + for (int i = index + 1; i < this.CurrentIndex; ++i) { + if (! this.GetIndexString(key, sizeof(key), i)) { + return false; + } + + int target = i - 1; + + JSON_CELL_TYPE type = this.GetKeyTypeIndexed(i); + + switch (type) { + case Type_String: { + int str_length = this.GetKeyLengthIndexed(i); + char[] str_value = new char[str_length]; + + this.GetStringIndexed(i, str_value, str_length + 1); + this.SetStringIndexed(target, str_value); + } + case Type_Int: { + this.SetIntIndexed(target, this.GetIntIndexed(i)); + } + case Type_Float: { + this.SetFloatIndexed(target, this.GetFloatIndexed(i)); + } + case Type_Bool: { + this.SetBoolIndexed(target, this.GetBoolIndexed(i)); + } + case Type_Null: { + this.SetHandleIndexed(target, this.GetHandleIndexed(i)); + } + case Type_Object: { + this.SetObjectIndexed(target, this.GetObjectIndexed(i)); + } + } + + if (this.GetKeyHiddenIndexed(i)) { + this.SetKeyHiddenIndexed(target, true); + } + + this.Remove(key); + } + + this.CurrentIndex -= 1; + + return true; + } + + /** + * Encodes the instance into its string representation. + * + * @param output String buffer to store output. + * @param max_size Maximum size of string buffer. + * @param pretty_print Should the output be pretty printed (newlines and spaces)? [default: false] + * @param depth The current depth of the encoder. [default: 0] + */ + public void Encode(char[] output, int max_size, bool pretty_print = false, int depth = 0) + { + json_encode(this, output, max_size, pretty_print, depth); + } + + /** + * Decodes a JSON string into this object. + * + * @param buffer Buffer to decode. + */ + public void Decode(const char[] buffer) + { + json_decode(buffer, this); + } + + /** + * Recursively cleans up the object and any objects referenced within. + */ + public void Cleanup() + { + json_cleanup(this); + } +}; diff --git a/sourcemod/scripting/include/json/string_helpers.inc b/sourcemod/scripting/include/json/string_helpers.inc new file mode 100644 index 0000000..6063d47 --- /dev/null +++ b/sourcemod/scripting/include/json/string_helpers.inc @@ -0,0 +1,77 @@ +/** + * vim: set ts=4 : + * ============================================================================= + * sm-json + * Provides a pure SourcePawn implementation of JSON encoding and decoding. + * https://github.com/clugg/sm-json + * + * sm-json (C)2018 James D. (clug) + * SourceMod (C)2004-2008 AlliedModders LLC. All rights reserved. + * ============================================================================= + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 3.0, as published by the + * Free Software Foundation. + * + * 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, see <http://www.gnu.org/licenses/>. + * + * As a special exception, AlliedModders LLC gives you permission to link the + * code of this program (as well as its derivative works) to "Half-Life 2," the + * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software + * by the Valve Corporation. You must obey the GNU General Public License in + * all respects for all other code used. Additionally, AlliedModders LLC grants + * this exception to all derivative works. AlliedModders LLC defines further + * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007), + * or <http://www.sourcemod.net/license.php>. + */ + +#if defined _json_string_helpers_included + #endinput +#endif +#define _json_string_helpers_included + +/** + * Checks if a string starts with another string. + * + * @param haystack String to check that starts with needle. + * @param maxlen Maximum size of string buffer. + * @param needle String to check that haystack starts with. + * @return True if haystack begins with needle, false otherwise. + */ +stock bool json_string_startswith(const char[] haystack, const char[] needle) { + int haystack_length = strlen(haystack); + int needle_length = strlen(needle); + if (needle_length > haystack_length) return false; + + for (int i = 0; i < needle_length; ++i) { + if (haystack[i] != needle[i]) return false; + } + + return true; +} + +/** + * Checks if a string ends with another string. + * + * @param haystack String to check that ends with needle. + * @param maxlen Maximum size of string buffer. + * @param needle String to check that haystack ends with. + * @return True if haystack ends with needle, false otherwise. + */ +stock bool json_string_endswith(const char[] haystack, const char[] needle) { + int haystack_length = strlen(haystack); + int needle_length = strlen(needle); + if (needle_length > haystack_length) return false; + + for (int i = 0; i < needle_length; ++i) { + if (haystack[haystack_length - needle_length + i] != needle[i]) return false; + } + + return true; +}
\ No newline at end of file diff --git a/sourcemod/scripting/include/movement.inc b/sourcemod/scripting/include/movement.inc new file mode 100644 index 0000000..7cc5b29 --- /dev/null +++ b/sourcemod/scripting/include/movement.inc @@ -0,0 +1,530 @@ +/* + MovementAPI Function Stock Library + + Website: https://github.com/danzayau/MovementAPI +*/ + +#if defined _movement_included_ + #endinput +#endif +#define _movement_included_ + +#include <sdktools> + + + +// =====[ STOCKS ]===== + +/** + * Calculates the horizontal distance between two vectors. + * + * @param vec1 First vector. + * @param vec2 Second vector. + * @return Vector horizontal distance. + */ +stock float GetVectorHorizontalDistance(const float vec1[3], const float vec2[3]) +{ + return SquareRoot(Pow(vec2[0] - vec1[0], 2.0) + Pow(vec2[1] - vec1[1], 2.0)); +} + +/** + * Calculates a vector's horizontal length. + * + * @param vec Vector. + * @return Vector horizontal length (magnitude). + */ +stock float GetVectorHorizontalLength(const float vec[3]) +{ + return SquareRoot(Pow(vec[0], 2.0) + Pow(vec[1], 2.0)); +} + +/** + * Scales a vector to a certain horizontal length. + * + * @param vec Vector. + * @param length New horizontal length. + */ +stock void SetVectorHorizontalLength(float vec[3], float length) +{ + float newVec[3]; + newVec = vec; + newVec[2] = 0.0; + NormalizeVector(newVec, newVec); + ScaleVector(newVec, length); + newVec[2] = vec[2]; + vec = newVec; +} + +/** + * Gets a player's currently pressed buttons. + * + * @param client Client index. + * @return Bitsum of buttons. + */ +stock int Movement_GetButtons(int client) +{ + return GetClientButtons(client); +} + +/** + * Gets a player's origin. + * + * @param client Client index. + * @param result Resultant vector. + */ +stock void Movement_GetOrigin(int client, float result[3]) +{ + GetClientAbsOrigin(client, result); +} + +/** + * Gets a player's origin. + * If the player is on the ground, a trace hull is used to find the + * exact height of the ground the player is standing on. This is thus + * more accurate than Movement_GetOrigin when player is on ground. + * + * @param client Client index. + * @param result Resultant vector. + */ +stock void Movement_GetOriginEx(int client, float result[3]) +{ + if (!Movement_GetOnGround(client)) + { + GetClientAbsOrigin(client, result); + return; + } + + // Get the coordinate of the solid beneath the player's origin + // More accurate than GetClientAbsOrigin when on ground + float startPosition[3], endPosition[3]; + GetClientAbsOrigin(client, startPosition); + endPosition = startPosition; + endPosition[2] = startPosition[2] - 2.0; // Should be less than 2.0 units away + Handle trace = TR_TraceHullFilterEx( + startPosition, + endPosition, + view_as<float>( { -16.0, -16.0, 0.0 } ), // Players are 32 x 32 x 72 + view_as<float>( { 16.0, 16.0, 72.0 } ), + MASK_PLAYERSOLID, + TraceEntityFilterPlayers, + client); + if (TR_DidHit(trace)) + { + TR_GetEndPosition(result, trace); + // Do not get rid of the offset. The offset is correct, as the player must be + // at least 0.03125 units away from the ground. + } + else + { + result = startPosition; // Fallback to GetClientAbsOrigin + } + delete trace; +} + +public bool TraceEntityFilterPlayers(int entity, int contentsMask) +{ + return entity > MaxClients; +} + +/** + * Sets a player's origin by teleporting them. + * + * @param client Client index. + * @param origin New origin. + */ +stock void Movement_SetOrigin(int client, const float origin[3]) +{ + TeleportEntity(client, origin, NULL_VECTOR, NULL_VECTOR); +} + +/** + * Gets a player's velocity. + * + * @param client Client index. + * @param result Resultant vector. + */ +stock void Movement_GetVelocity(int client, float result[3]) +{ + GetEntPropVector(client, Prop_Data, "m_vecVelocity", result); +} + +/** + * Sets a player's velocity by teleporting them. + * + * @param client Client index. + * @param velocity New velocity. + */ +stock void Movement_SetVelocity(int client, const float velocity[3]) +{ + TeleportEntity(client, NULL_VECTOR, NULL_VECTOR, velocity); +} + +/** + * Gets a player's horizontal speed. + * + * @param client Client index. + * @return Player's horizontal speed. + */ +stock float Movement_GetSpeed(int client) +{ + float velocity[3]; + Movement_GetVelocity(client, velocity); + return GetVectorHorizontalLength(velocity); +} + +/** + * Sets a player's horizontal speed. + * + * @param client Client index. + * @param value New horizontal speed. + * @param applyBaseVel Whether to apply base velocity as well. + */ +stock void Movement_SetSpeed(int client, float value, bool applyBaseVel = false) +{ + float velocity[3]; + Movement_GetVelocity(client, velocity); + SetVectorHorizontalLength(velocity, value) + if (applyBaseVel) + { + float baseVelocity[3]; + Movement_GetBaseVelocity(client, baseVelocity); + AddVectors(velocity, baseVelocity, velocity); + } + Movement_SetVelocity(client, velocity); +} + +/** + * Gets a player's vertical velocity. + * + * @param client Client index. + * @return Player's vertical velocity. + */ +stock float Movement_GetVerticalVelocity(int client) +{ + float velocity[3]; + Movement_GetVelocity(client, velocity); + return velocity[2]; +} + +/** + * Sets a player's vertical velocity. + * + * @param client Client index. + * @param value New vertical velocity. + */ +stock void Movement_SetVerticalVelocity(int client, float value) +{ + float velocity[3]; + Movement_GetVelocity(client, velocity); + velocity[2] = value; + Movement_SetVelocity(client, velocity); +} + +/** + * Gets a player's base velocity. + * + * @param client Client index. + * @param result Resultant vector. + */ +stock void Movement_GetBaseVelocity(int client, float result[3]) +{ + GetEntPropVector(client, Prop_Data, "m_vecBaseVelocity", result); +} + +/** + * Sets a player's base velocity. + * + * @param client Client index. + * @param baseVelocity New base velocity. + */ +stock void Movement_SetBaseVelocity(int client, const float baseVelocity[3]) +{ + SetEntPropVector(client, Prop_Data, "m_vecBaseVelocity", baseVelocity); +} + +/** + * Gets a player's eye angles. + * + * @param client Client index. + * @param result Resultant vector. + */ +stock void Movement_GetEyeAngles(int client, float result[3]) +{ + GetClientEyeAngles(client, result); +} + +/** + * Sets a player's eye angles by teleporting them. + * + * @param client Client index. + * @param eyeAngles New eye angles. + */ +stock void Movement_SetEyeAngles(int client, const float eyeAngles[3]) +{ + TeleportEntity(client, NULL_VECTOR, eyeAngles, NULL_VECTOR); +} + +/** + * Gets whether a player is on the ground. + * + * @param client Client index. + * @return Whether player is on the ground. + */ +stock bool Movement_GetOnGround(int client) +{ + return view_as<bool>(GetEntityFlags(client) & FL_ONGROUND); +} + +/** + * Gets whether a player is ducking or ducked. + * + * @param client Client index. + * @return Whether player is ducking or ducked. + */ +stock bool Movement_GetDucking(int client) +{ + return GetEntProp(client, Prop_Send, "m_bDucked") || GetEntProp(client, Prop_Send, "m_bDucking"); +} + +/** + * Gets a player's "m_flDuckSpeed" value. + * + * @param client Client index. + * @return Value of "m_flDuckSpeed". + */ +stock float Movement_GetDuckSpeed(int client) +{ + return GetEntPropFloat(client, Prop_Send, "m_flDuckSpeed"); +} + +/** + * Sets a player's "m_flDuckSpeed" value. + * + * @param client Client index. + * @param value New "m_flDuckSpeed" value. + */ +stock void Movement_SetDuckSpeed(int client, float value) +{ + SetEntPropFloat(client, Prop_Send, "m_flDuckSpeed", value); +} + +/** + * Gets a player's "m_flVelocityModifier" value. + * + * @param client Client index. + * @return Value of "m_flVelocityModifier". + */ +stock float Movement_GetVelocityModifier(int client) +{ + return GetEntPropFloat(client, Prop_Send, "m_flVelocityModifier"); +} + +/** + * Sets a player's "m_flVelocityModifier" value. + * + * @param client Client index. + * @param value New "m_flVelocityModifier" value. + */ +stock void Movement_SetVelocityModifier(int client, float value) +{ + SetEntPropFloat(client, Prop_Send, "m_flVelocityModifier", value); +} + +/** + * Gets a player's gravity scale factor. + * + * @param client Client index. + * @return Gravity scale factor. + */ +stock float Movement_GetGravity(int client) +{ + return GetEntityGravity(client); +} + +/** + * Sets a player's gravity scale factor. + * + * @param client Client index. + * @param value Desired gravity scale factor. + */ +stock void Movement_SetGravity(int client, float value) +{ + SetEntityGravity(client, value); +} + +/** + * Gets a player's movetype. + * + * @param client Client index. + * @return Player's movetype. + */ +stock MoveType Movement_GetMovetype(int client) +{ + return GetEntityMoveType(client); +} + +/** + * Sets a player's movetype. + * + * @param client Client index. + * @param movetype New movetype. + */ +stock void Movement_SetMovetype(int client, MoveType movetype) +{ + SetEntityMoveType(client, movetype); +} + +/** + * Gets whether a player is on a ladder. + * + * @param client Client index. + * @return Whether player is on a ladder. + */ +stock bool Movement_GetOnLadder(int client) +{ + return GetEntityMoveType(client) == MOVETYPE_LADDER; +} + +/** + * Gets whether a player is noclipping. + * + * @param client Client index. + * @return Whether player is noclipping. + */ +stock bool Movement_GetNoclipping(int client) +{ + return GetEntityMoveType(client) == MOVETYPE_NOCLIP; +} + + + +// =====[ METHODMAP ]===== + +methodmap MovementPlayer { + + public MovementPlayer(int client) { + return view_as<MovementPlayer>(client); + } + + property int ID { + public get() { + return view_as<int>(this); + } + } + + property int Buttons { + public get() { + return Movement_GetButtons(this.ID); + } + } + + public void GetOrigin(float result[3]) { + Movement_GetOrigin(this.ID, result); + } + + public void SetOrigin(const float origin[3]) { + Movement_SetOrigin(this.ID, origin); + } + + public void GetVelocity(float result[3]) { + Movement_GetVelocity(this.ID, result); + } + + public void SetVelocity(const float velocity[3]) { + Movement_SetVelocity(this.ID, velocity); + } + + property float Speed { + public get() { + return Movement_GetSpeed(this.ID); + } + public set(float value) { + Movement_SetSpeed(this.ID, value); + } + } + + property float VerticalVelocity { + public get() { + return Movement_GetVerticalVelocity(this.ID); + } + public set(float value) { + Movement_SetVerticalVelocity(this.ID, value); + } + } + + public void GetBaseVelocity(float result[3]) { + Movement_GetBaseVelocity(this.ID, result); + } + + public void SetBaseVelocity(const float baseVelocity[3]) { + Movement_SetBaseVelocity(this.ID, baseVelocity); + } + + public void GetEyeAngles(float result[3]) { + Movement_GetEyeAngles(this.ID, result); + } + + public void SetEyeAngles(const float eyeAngles[3]) { + Movement_SetEyeAngles(this.ID, eyeAngles); + } + + property bool OnGround { + public get() { + return Movement_GetOnGround(this.ID); + } + } + + property bool Ducking { + public get() { + return Movement_GetDucking(this.ID); + } + } + + property float DuckSpeed { + public get() { + return Movement_GetDuckSpeed(this.ID); + } + public set(float value) { + Movement_SetDuckSpeed(this.ID, value); + } + } + + property float VelocityModifier { + public get() { + return Movement_GetVelocityModifier(this.ID); + } + public set(float value) { + Movement_SetVelocityModifier(this.ID, value); + } + } + + property float Gravity { + public get() { + return Movement_GetGravity(this.ID); + } + public set(float value) { + Movement_SetGravity(this.ID, value); + } + } + + property MoveType Movetype { + public get() { + return Movement_GetMovetype(this.ID); + } + public set(MoveType movetype) { + Movement_SetMovetype(this.ID, movetype); + } + } + + property bool OnLadder { + public get() { + return Movement_GetOnLadder(this.ID); + } + } + + property bool Noclipping { + public get() { + return Movement_GetNoclipping(this.ID); + } + } +} diff --git a/sourcemod/scripting/include/movementapi.inc b/sourcemod/scripting/include/movementapi.inc new file mode 100644 index 0000000..290c3f2 --- /dev/null +++ b/sourcemod/scripting/include/movementapi.inc @@ -0,0 +1,663 @@ +/* + MovementAPI Plugin Include + + Website: https://github.com/danzayau/MovementAPI +*/ + +#if defined _movementapi_included_ + #endinput +#endif +#define _movementapi_included_ + +#include <movement> + + + +/* + Terminology + + Takeoff + Becoming airborne, including jumping, falling, getting off a ladder and leaving noclip. + + Landing + Leaving the air, including landing on the ground, grabbing a ladder and entering noclip. + + Perfect Bunnyhop (Perf) + When the player has jumped in the tick after landing and keeps their speed. + + Duckbug/Crouchbug + When the player sucessfully lands due to uncrouching from mid air and not by falling + down. This causes no stamina loss or fall damage upon landing. + + Jumpbug + This is achieved by duckbugging and jumping at the same time. The player is never seen + as 'on ground' when bunnyhopping from a tick by tick perspective. A jumpbug inherits + the same behavior as a duckbug/crouchbug, along with its effects such as maintaining + speed due to no stamina loss. + + Distbug + Landing behavior varies depending on whether the player lands close to the edge of a + block or not: + + 1. If the player lands close to the edge of a block, this causes the jump duration to + be one tick longer and the player can "slide" on the ground during the landing tick, + using the position post-tick as landing position becomes inaccurate. + + 2. On the other hand, if the player does not land close to the edge, the player will + be considered on the ground one tick earlier, using this position as landing position + is not accurate as the player has yet to be fully on the ground. + + In scenario 1, GetNobugLandingOrigin calculates the correct landing position of the + player before the sliding effect takes effect. + + In scenario 2, GetNobugLandingOrigin attempts to extrapolate the player's fully on + ground position to make landing positions consistent across scenarios. +*/ + + + +// =====[ FORWARDS ]===== + +/** + * Called when a player's movetype changes. + * + * @param client Client index. + * @param oldMovetype Player's old movetype. + * @param newMovetype Player's new movetype. + */ +forward void Movement_OnChangeMovetype(int client, MoveType oldMovetype, MoveType newMovetype); + +/** + * Called when a player touches the ground. + * + * @param client Client index. + */ +forward void Movement_OnStartTouchGround(int client); + +/** + * Called when a player leaves the ground. + * + * @param client Client index. + * @param jumped Whether player jumped to leave ground. + * @param ladderJump Whether player jumped from a ladder. + * @param jumpbug Whether player performed a jumpbug. + */ +forward void Movement_OnStopTouchGround(int client, bool jumped, bool ladderJump, bool jumpbug); + +/** + * Called when a player starts ducking. + * + * @param client Client index. + */ +forward void Movement_OnStartDucking(int client); + +/** + * Called when a player stops ducking. + * + * @param client Client index. + */ +forward void Movement_OnStopDucking(int client); + +/** + * Called when a player jumps (player_jump event), including 'jumpbugs'. + * Setting velocity when this is called may not be effective. + * + * @param client Client index. + * @param jumpbug Whether player 'jumpbugged'. + */ +forward void Movement_OnPlayerJump(int client, bool jumpbug); + +/** + * Called before PlayerMove movement function is called. + * Modifying origin or velocity parameters will change player's origin and velocity accordingly. + * + * @param client Client index. + * @param origin Player origin. + * @param velocity Player velocity. + * @return Plugin_Changed if origin or velocity is changed, Plugin_Continue otherwise. + */ +forward Action Movement_OnPlayerMovePre(int client, float origin[3], float velocity[3]); + +/** + * Called after PlayerMove movement function is called. + * Modifying origin or velocity parameters will change player's origin and velocity accordingly. + * + * @param client Client index. + * @param origin Player origin. + * @param velocity Player velocity. + * @return Plugin_Changed if origin or velocity is changed, Plugin_Continue otherwise. + */ +forward Action Movement_OnPlayerMovePost(int client, float origin[3], float velocity[3]); + +/** + * Called before Duck movement function is called. + * Modifying origin or velocity parameters will change player's origin and velocity accordingly. + * + * @param client Client index. + * @param origin Player origin. + * @param velocity Player velocity. + * @return Plugin_Changed if origin or velocity is changed, Plugin_Continue otherwise. + */ +forward Action Movement_OnDuckPre(int client, float origin[3], float velocity[3]); + +/** + * Called after Duck movement function is called. + * Modifying origin or velocity parameters will change player's origin and velocity accordingly. + * + * @param client Client index. + * @param origin Player origin. + * @param velocity Player velocity. + * @return Plugin_Changed if origin or velocity is changed, Plugin_Continue otherwise. + */ +forward Action Movement_OnDuckPost(int client, float origin[3], float velocity[3]); + +/** + * Called before LadderMove movement function is called. + * Modifying origin or velocity parameters will change player's origin and velocity accordingly. + * + * @param client Client index. + * @param origin Player origin. + * @param velocity Player velocity. + * @return Plugin_Changed if origin or velocity is changed, Plugin_Continue otherwise. + */ +forward Action Movement_OnLadderMovePre(int client, float origin[3], float velocity[3]); + +/** + * Called after LadderMove movement function is called. + * Modifying origin or velocity parameters will change player's origin and velocity accordingly. + * + * @param client Client index. + * @param origin Player origin. + * @param velocity Player velocity. + * @return Plugin_Changed if origin or velocity is changed, Plugin_Continue otherwise. + */ +forward Action Movement_OnLadderMovePost(int client, float origin[3], float velocity[3]); + +/** + * Called before FullLadderMove movement function is called. + * Modifying origin or velocity parameters will change player's origin and velocity accordingly. + * + * @param client Client index. + * @param origin Player origin. + * @param velocity Player velocity. + * @return Plugin_Changed if origin or velocity is changed, Plugin_Continue otherwise. + */ +forward Action Movement_OnFullLadderMovePre(int client, float origin[3], float velocity[3]); + +/** + * Called after FullLadderMove movement function is called. + * Modifying origin or velocity parameters will change player's origin and velocity accordingly. + * + * @param client Client index. + * @param origin Player origin. + * @param velocity Player velocity. + * @return Plugin_Changed if origin or velocity is changed, Plugin_Continue otherwise. + */ +forward Action Movement_OnFullLadderMovePost(int client, float origin[3], float velocity[3]); + +/** + * Called after the player jumps, but before jumping stamina is applied and takeoff variables are not set yet. + * Modifying origin or velocity parameters will change player's origin and velocity accordingly. + * + * @param client Client index. + * @param origin Player origin. + * @param velocity Player velocity. + * @return Plugin_Changed if origin or velocity is changed, Plugin_Continue otherwise. + */ +forward Action Movement_OnJumpPre(int client, float origin[3], float velocity[3]); + +/** + * Called after the player jumps and after jumping stamina is applied and takeoff variables are already set here. + * Modifying origin or velocity parameters will change player's origin and velocity accordingly. + * + * @param client Client index. + * @param origin Player origin. + * @param velocity Player velocity. + * @return Plugin_Changed if origin or velocity is changed, Plugin_Continue otherwise. + */ +forward Action Movement_OnJumpPost(int client, float origin[3], float velocity[3]); + +/** + * Called before AirAccelerate movement function is called. + * Modifying origin or velocity parameters will change player's origin and velocity accordingly. + * + * @param client Client index. + * @param origin Player origin. + * @param velocity Player velocity. + * @return Plugin_Changed if origin or velocity is changed, Plugin_Continue otherwise. + */ +forward Action Movement_OnAirAcceleratePre(int client, float origin[3], float velocity[3]); + +/** + * Called after AirAccelerate movement function is called. + * Modifying origin or velocity parameters will change player's origin and velocity accordingly. + * + * @param client Client index. + * @param origin Player origin. + * @param velocity Player velocity. + * @return Plugin_Changed if origin or velocity is changed, Plugin_Continue otherwise. + */ +forward Action Movement_OnAirAcceleratePost(int client, float origin[3], float velocity[3]); + +/** + * Called before WalkMove movement function is called. + * Modifying origin or velocity parameters will change player's origin and velocity accordingly. + * + * @param client Client index. + * @param origin Player origin. + * @param velocity Player velocity. + * @return Plugin_Changed if origin or velocity is changed, Plugin_Continue otherwise. + */ +forward Action Movement_OnWalkMovePre(int client, float origin[3], float velocity[3]); + +/** + * Called after WalkMove movement function is called. + * Modifying origin or velocity parameters will change player's origin and velocity accordingly. + * + * @param client Client index. + * @param origin Player origin. + * @param velocity Player velocity. + * @return Plugin_Changed if origin or velocity is changed, Plugin_Continue otherwise. + */ +forward Action Movement_OnWalkMovePost(int client, float origin[3], float velocity[3]); + +/** + * Called before CategorizePosition movement function is called. + * Modifying origin or velocity parameters will change player's origin and velocity accordingly. + * + * @param client Client index. + * @param origin Player origin. + * @param velocity Player velocity. + * @return Plugin_Changed if origin or velocity is changed, Plugin_Continue otherwise. + */ +forward Action Movement_OnCategorizePositionPre(int client, float origin[3], float velocity[3]); + +/** + * Called after CategorizePosition movement function is called. + * Modifying origin or velocity parameters will change player's origin and velocity accordingly. + * + * @param client Client index. + * @param origin Player origin. + * @param velocity Player velocity. + * @return Plugin_Changed if origin or velocity is changed, Plugin_Continue otherwise. + */ +forward Action Movement_OnCategorizePositionPost(int client, float origin[3], float velocity[3]); + +// =====[ NATIVES ]===== + +/** + * Gets whether a player's last takeoff was a jump. + * + * @param client Client index. + * @return Whether player's last takeoff was a jump. + */ +native bool Movement_GetJumped(int client); + +/** + * Gets whether a player's last takeoff was a perfect bunnyhop. + * + * @param client Client index. + * @return Whether player's last takeoff was a perfect bunnyhop. + */ +native bool Movement_GetHitPerf(int client); + +/** + * Gets a player's origin at the time of their last takeoff. + * + * @param client Client index. + * @param result Resultant vector. + */ +native void Movement_GetTakeoffOrigin(int client, float result[3]); + +/** + * Gets a player's velocity at the time of their last takeoff. + * + * If sv_enablebunnyhopping is 0, CS:GO may adjust the player's + * velocity after the takeoff velocity has already been measured. + * + * @param client Client index. + * @param result Resultant vector. + */ +native void Movement_GetTakeoffVelocity(int client, float result[3]); + +/** + * Gets a player's horizontal speed at the time of their last takeoff. + * + * If sv_enablebunnyhopping is 0, CS:GO may adjust the player's + * velocity after the takeoff velocity has already been measured. + * + * @param client Client index. + * @return Player's last takeoff speed. + */ +native float Movement_GetTakeoffSpeed(int client); + +/** + * Gets a player's 'tickcount' at the time of their last takeoff. + * + * @param client Client index. + * @return Player's last takeoff 'tickcount'. + */ +native int Movement_GetTakeoffTick(int client); + +/** + * Gets a player's 'cmdnum' at the time of their last takeoff. + * + * @param client Client index. + * @return Player's last takeoff 'cmdnum'. + */ +native int Movement_GetTakeoffCmdNum(int client); + +/** + * Gets a player's origin at the time of their last landing with the distbug fixed. + * + * @param client Client index. + * @param result Resultant vector. + */ +native void Movement_GetNobugLandingOrigin(int client, float result[3]); + +/** + * Gets a player's origin at the time of their last landing. + * + * @param client Client index. + * @param result Resultant vector. + */ +native void Movement_GetLandingOrigin(int client, float result[3]); + +/** + * Gets a player's velocity at the time of their last landing. + * + * @param client Client index. + * @param result Resultant vector. + */ +native void Movement_GetLandingVelocity(int client, float result[3]); + +/** + * Gets a player's horizontal speed at the time of their last landing. + * + * @param client Client index. + * @return Last landing speed of the player (horizontal). + */ +native float Movement_GetLandingSpeed(int client); + +/** + * Gets a player's 'tickcount' at the time of their last landing. + * + * @param client Client index. + * @return Player's last landing 'tickcount'. + */ +native int Movement_GetLandingTick(int client); + +/** + * Gets a player's 'cmdnum' at the time of their last landing. + * + * @param client Client index. + * @return Player's last landing 'cmdnum'. + */ +native int Movement_GetLandingCmdNum(int client); + +/** + * Gets whether a player is turning their aim horizontally. + * + * @param client Client index. + * @return Whether player is turning their aim horizontally. + */ +native bool Movement_GetTurning(int client); + +/** + * Gets whether a player is turning their aim left. + * + * @param client Client index. + * @return Whether player is turning their aim left. + */ +native bool Movement_GetTurningLeft(int client); + +/** + * Gets whether a player is turning their aim right. + * + * @param client Client index. + * @return Whether player is turning their aim right. + */ +native bool Movement_GetTurningRight(int client); + +/** + * Gets result of CCSPlayer::GetPlayerMaxSpeed(client), which + * is the player's max speed as limited by their weapon. + * + * @param client Client index. + * @return Player's max speed as limited by their weapon. + */ +native float Movement_GetMaxSpeed(int client); + +/** + * Gets whether a player duckbugged on this tick. + * + * @param client Client index. + * @return Whether a player duckbugged on this tick. + */ +native bool Movement_GetDuckbugged(int client); + +/** + * Gets whether a player jumpbugged on this tick. + * + * @param client Client index. + * @return Whether a player jumpbugged on this tick. + */ +native bool Movement_GetJumpbugged(int client); + +/** + * Get the player's origin during movement processing. + * + * @param client Client index. + * @param result Resultant vector. + */ +native void Movement_GetProcessingOrigin(int client, float result[3]); + +/** + * Get the player's velocity during movement processing. + * + * @param client Param description + * @param result Resultant vector. + */ +native void Movement_GetProcessingVelocity(int client, float result[3]); + +/** + * Set the player's takeoff origin. + * + * @param client Client index. + * @param origin Desired origin. + */ +native void Movement_SetTakeoffOrigin(int client, float origin[3]); + +/** + * Set the player's takeoff velocity. + * + * @param client Client index. + * @param origin Desired velocity. + */ +native void Movement_SetTakeoffVelocity(int client, float velocity[3]); + +/** + * Set the player's landing origin. + * + * @param client Client index. + * @param origin Desired origin. + */ +native void Movement_SetLandingOrigin(int client, float origin[3]); + +/** + * Set the player's landing velocity. + * + * @param client Client index. + * @param origin Desired velocity. + */ +native void Movement_SetLandingVelocity(int client, float velocity[3]); + +// =====[ METHODMAP ]===== + +methodmap MovementAPIPlayer < MovementPlayer { + + public MovementAPIPlayer(int client) { + return view_as<MovementAPIPlayer>(MovementPlayer(client)); + } + + property bool Jumped { + public get() { + return Movement_GetJumped(this.ID); + } + } + + property bool HitPerf { + public get() { + return Movement_GetHitPerf(this.ID); + } + } + + public void GetTakeoffOrigin(float buffer[3]) { + Movement_GetTakeoffOrigin(this.ID, buffer); + } + + public void GetTakeoffVelocity(float buffer[3]) { + Movement_GetTakeoffVelocity(this.ID, buffer); + } + + public void SetTakeoffOrigin(float buffer[3]) + { + Movement_SetTakeoffOrigin(this.ID, buffer); + } + + public void SetTakeoffVelocity(float buffer[3]) + { + Movement_SetTakeoffVelocity(this.ID, buffer); + } + + property float TakeoffSpeed { + public get() { + return Movement_GetTakeoffSpeed(this.ID); + } + } + + property int TakeoffTick { + public get() { + return Movement_GetTakeoffTick(this.ID); + } + } + + property int TakeoffCmdNum { + public get() { + return Movement_GetTakeoffCmdNum(this.ID); + } + } + + public void GetLandingOrigin(float buffer[3]) { + Movement_GetLandingOrigin(this.ID, buffer); + } + + public void GetLandingVelocity(float buffer[3]) { + Movement_GetLandingVelocity(this.ID, buffer); + } + + public void SetLandingOrigin(float buffer[3]) + { + Movement_SetLandingOrigin(this.ID, buffer); + } + + public void SetLandingVelocity(float buffer[3]) + { + Movement_SetLandingVelocity(this.ID, buffer); + } + + property float LandingSpeed { + public get() { + return Movement_GetLandingSpeed(this.ID); + } + } + + property int LandingTick { + public get() { + return Movement_GetLandingTick(this.ID); + } + } + + property int LandingCmdNum { + public get() { + return Movement_GetLandingCmdNum(this.ID); + } + } + + property bool Turning { + public get() { + return Movement_GetTurning(this.ID); + } + } + + property bool TurningLeft { + public get() { + return Movement_GetTurningLeft(this.ID); + } + } + + property bool TurningRight { + public get() { + return Movement_GetTurningRight(this.ID); + } + } + + property float MaxSpeed { + public get() { + return Movement_GetMaxSpeed(this.ID); + } + } + + public void GetProcessingVelocity(float buffer[3]) + { + Movement_GetProcessingVelocity(this.ID, buffer); + } + + public void GetProcessingOrigin(float buffer[3]) + { + Movement_GetProcessingOrigin(this.ID, buffer); + } +} + + + +// =====[ DEPENDENCY ]===== + +public SharedPlugin __pl_movementapi = +{ + name = "movementapi", + file = "movementapi.smx", + #if defined REQUIRE_PLUGIN + required = 1, + #else + required = 0, + #endif +}; + +#if !defined REQUIRE_PLUGIN +public void __pl_movementapi_SetNTVOptional() +{ + MarkNativeAsOptional("Movement_GetJumped"); + MarkNativeAsOptional("Movement_GetHitPerf"); + MarkNativeAsOptional("Movement_GetTakeoffOrigin"); + MarkNativeAsOptional("Movement_GetTakeoffVelocity"); + MarkNativeAsOptional("Movement_GetTakeoffSpeed"); + MarkNativeAsOptional("Movement_GetTakeoffTick"); + MarkNativeAsOptional("Movement_GetTakeoffCmdNum"); + MarkNativeAsOptional("Movement_GetLandingOrigin"); + MarkNativeAsOptional("Movement_GetLandingVelocity"); + MarkNativeAsOptional("Movement_GetLandingSpeed"); + MarkNativeAsOptional("Movement_GetLandingTick"); + MarkNativeAsOptional("Movement_GetLandingCmdNum"); + MarkNativeAsOptional("Movement_GetTurning"); + MarkNativeAsOptional("Movement_GetTurningLeft"); + MarkNativeAsOptional("Movement_GetTurningRight"); + MarkNativeAsOptional("Movement_GetMaxSpeed"); + MarkNativeAsOptional("Movement_GetProcessingOrigin"); + MarkNativeAsOptional("Movement_GetProcessingVelocity"); + MarkNativeAsOptional("Movement_SetTakeoffOrigin"); + MarkNativeAsOptional("Movement_SetTakeoffVelocity"); + MarkNativeAsOptional("Movement_SetLandingOrigin"); + MarkNativeAsOptional("Movement_SetLandingVelocity"); +} +#endif
\ No newline at end of file diff --git a/sourcemod/scripting/include/smjansson.inc b/sourcemod/scripting/include/smjansson.inc new file mode 100644 index 0000000..029a492 --- /dev/null +++ b/sourcemod/scripting/include/smjansson.inc @@ -0,0 +1,1328 @@ +#if defined _jansson_included_ + #endinput +#endif +#define _jansson_included_ + + +/** + * --- Type + * + * The JSON specification (RFC 4627) defines the following data types: + * object, array, string, number, boolean, and null. + * JSON types are used dynamically; arrays and objects can hold any + * other data type, including themselves. For this reason, Jansson�s + * type system is also dynamic in nature. There�s one Handle type to + * represent all JSON values, and the referenced structure knows the + * type of the JSON value it holds. + * + */ +enum json_type { + JSON_OBJECT, + JSON_ARRAY, + JSON_STRING, + JSON_INTEGER, + JSON_REAL, + JSON_TRUE, + JSON_FALSE, + JSON_NULL +} + +/** + * Return the type of the JSON value. + * + * @param hObj Handle to the JSON value + * + * @return json_type of the value. + */ +native json_type:json_typeof(Handle:hObj); + +/** + * The type of a JSON value is queried and tested using these macros + * + * @param %1 Handle to the JSON value + * + * @return True if the value has the correct type. + */ +#define json_is_object(%1) ( json_typeof(%1) == JSON_OBJECT ) +#define json_is_array(%1) ( json_typeof(%1) == JSON_ARRAY ) +#define json_is_string(%1) ( json_typeof(%1) == JSON_STRING ) +#define json_is_integer(%1) ( json_typeof(%1) == JSON_INTEGER ) +#define json_is_real(%1) ( json_typeof(%1) == JSON_REAL ) +#define json_is_true(%1) ( json_typeof(%1) == JSON_TRUE ) +#define json_is_false(%1) ( json_typeof(%1) == JSON_FALSE ) +#define json_is_null(%1) ( json_typeof(%1) == JSON_NULL ) +#define json_is_number(%1) ( json_typeof(%1) == JSON_INTEGER || json_typeof(%1) == JSON_REAL ) +#define json_is_boolean(%1) ( json_typeof(%1) == JSON_TRUE || json_typeof(%1) == JSON_FALSE ) + +/** + * Saves json_type as a String in output + * + * @param input json_type value to convert to string + * @param output Buffer to store the json_type value + * @param maxlength Maximum length of string buffer. + * + * @return False if the type does not exist. + */ +stock bool:Stringify_json_type(json_type:input, String:output[], maxlength) { + switch(input) { + case JSON_OBJECT: strcopy(output, maxlength, "Object"); + case JSON_ARRAY: strcopy(output, maxlength, "Array"); + case JSON_STRING: strcopy(output, maxlength, "String"); + case JSON_INTEGER: strcopy(output, maxlength, "Integer"); + case JSON_REAL: strcopy(output, maxlength, "Real"); + case JSON_TRUE: strcopy(output, maxlength, "True"); + case JSON_FALSE: strcopy(output, maxlength, "False"); + case JSON_NULL: strcopy(output, maxlength, "Null"); + default: return false; + } + + return true; +} + + + +/** + * --- Equality + * + * - Two integer or real values are equal if their contained numeric + * values are equal. An integer value is never equal to a real value, + * though. + * - Two strings are equal if their contained UTF-8 strings are equal, + * byte by byte. Unicode comparison algorithms are not implemented. + * - Two arrays are equal if they have the same number of elements and + * each element in the first array is equal to the corresponding + * element in the second array. + * - Two objects are equal if they have exactly the same keys and the + * value for each key in the first object is equal to the value of + * the corresponding key in the second object. + * - Two true, false or null values have no "contents", so they are + * equal if their types are equal. + * + */ + +/** + * Test whether two JSON values are equal. + * + * @param hObj Handle to the first JSON object + * @param hOther Handle to the second JSON object + * + * @return Returns false if they are inequal or one + * or both of the pointers are NULL. + */ +native bool:json_equal(Handle:hObj, Handle:hOther); + + + + +/** + * --- Copying + * + * Jansson supports two kinds of copying: shallow and deep. There is + * a difference between these methods only for arrays and objects. + * + * Shallow copying only copies the first level value (array or object) + * and uses the same child values in the copied value. + * + * Deep copying makes a fresh copy of the child values, too. Moreover, + * all the child values are deep copied in a recursive fashion. + * + */ + +/** + * Get a shallow copy of the passed object + * + * @param hObj Handle to JSON object to be copied + * + * @return Returns a shallow copy of the object, + * or INVALID_HANDLE on error. + */ +native Handle:json_copy(Handle:hObj); + +/** + * Get a deep copy of the passed object + * + * @param hObj Handle to JSON object to be copied + * + * @return Returns a deep copy of the object, + * or INVALID_HANDLE on error. + */ +native Handle:json_deep_copy(Handle:hObj); + + + + +/** + * --- Objects + * + * A JSON object is a dictionary of key-value pairs, where the + * key is a Unicode string and the value is any JSON value. + * + */ + +/** + * Returns a handle to a new JSON object, or INVALID_HANDLE on error. + * Initially, the object is empty. + * + * @return Handle to a new JSON object. + */ +native Handle:json_object(); + +/** + * Returns the number of elements in hObj + * + * @param hObj Handle to JSON object + * + * @return Number of elements in hObj, + * or 0 if hObj is not a JSON object. + */ +native json_object_size(Handle:hObj); + +/** + * Get a value corresponding to sKey from hObj + * + * @param hObj Handle to JSON object to get a value from + * @param sKey Key to retrieve + * + * @return Handle to a the JSON object or + * INVALID_HANDLE on error. + */ +native Handle:json_object_get(Handle:hObj, const String:sKey[]); + +/** + * Set the value of sKey to hValue in hObj. + * If there already is a value for key, it is replaced by the new value. + * + * @param hObj Handle to JSON object to set a value on + * @param sKey Key to store in the object + * Must be a valid null terminated UTF-8 encoded + * Unicode string. + * @param hValue Value to store in the object + * + * @return True on success. + */ +native bool:json_object_set(Handle:hObj, const String:sKey[], Handle:hValue); + +/** + * Set the value of sKey to hValue in hObj. + * If there already is a value for key, it is replaced by the new value. + * This function automatically closes the Handle to the value object. + * + * @param hObj Handle to JSON object to set a value on + * @param sKey Key to store in the object + * Must be a valid null terminated UTF-8 encoded + * Unicode string. + * @param hValue Value to store in the object + * + * @return True on success. + */ +native bool:json_object_set_new(Handle:hObj, const String:sKey[], Handle:hValue); + +/** + * Delete sKey from hObj if it exists. + * + * @param hObj Handle to JSON object to delete a key from + * @param sKey Key to delete + * + * @return True on success. + */ +native bool:json_object_del(Handle:hObj, const String:sKey[]); + +/** + * Remove all elements from hObj. + * + * @param hObj Handle to JSON object to remove all + * elements from. + * + * @return True on success. + */ +native bool:json_object_clear(Handle:hObj); + +/** + * Update hObj with the key-value pairs from hOther, overwriting + * existing keys. + * + * @param hObj Handle to JSON object to update + * @param hOther Handle to JSON object to get update + * keys/values from. + * + * @return True on success. + */ +native bool:json_object_update(Handle:hObj, Handle:hOther); + +/** + * Like json_object_update(), but only the values of existing keys + * are updated. No new keys are created. + * + * @param hObj Handle to JSON object to update + * @param hOther Handle to JSON object to get update + * keys/values from. + * + * @return True on success. + */ +native bool:json_object_update_existing(Handle:hObj, Handle:hOther); + +/** + * Like json_object_update(), but only new keys are created. + * The value of any existing key is not changed. + * + * @param hObj Handle to JSON object to update + * @param hOther Handle to JSON object to get update + * keys/values from. + * + * @return True on success. + */ +native bool:json_object_update_missing(Handle:hObj, Handle:hOther); + + + + +/** + * Object iteration + * + * Example code: + * - We assume hObj is a Handle to a valid JSON object. + * + * + * new Handle:hIterator = json_object_iter(hObj); + * while(hIterator != INVALID_HANDLE) + * { + * new String:sKey[128]; + * json_object_iter_key(hIterator, sKey, sizeof(sKey)); + * + * new Handle:hValue = json_object_iter_value(hIterator); + * + * // Do something with sKey and hValue + * + * CloseHandle(hValue); + * + * hIterator = json_object_iter_next(hObj, hIterator); + * } + * + */ + +/** + * Returns a handle to an iterator which can be used to iterate over + * all key-value pairs in hObj. + * If you are not iterating to the end of hObj make sure to close the + * handle to the iterator manually. + * + * @param hObj Handle to JSON object to get an iterator + * for. + * + * @return Handle to JSON object iterator, + * or INVALID_HANDLE on error. + */ +native Handle:json_object_iter(Handle:hObj); + +/** + * Like json_object_iter(), but returns an iterator to the key-value + * pair in object whose key is equal to key. + * Iterating forward to the end of object only yields all key-value + * pairs of the object if key happens to be the first key in the + * underlying hash table. + * + * @param hObj Handle to JSON object to get an iterator + * for. + * @param sKey Start key for the iterator + * + * @return Handle to JSON object iterator, + * or INVALID_HANDLE on error. + */ +native Handle:json_object_iter_at(Handle:hObj, const String:key[]); + +/** + * Returns an iterator pointing to the next key-value pair in object. + * This automatically closes the Handle to the iterator hIter. + * + * @param hObj Handle to JSON object. + * @param hIter Handle to JSON object iterator. + * + * @return Handle to JSON object iterator, + * or INVALID_HANDLE on error, or if the + * whole object has been iterated through. + */ +native Handle:json_object_iter_next(Handle:hObj, Handle:hIter); + +/** + * Extracts the associated key of hIter as a null terminated UTF-8 + * encoded string in the passed buffer. + * + * @param hIter Handle to the JSON String object + * @param sKeyBuffer Buffer to store the value of the String. + * @param maxlength Maximum length of string buffer. + * @error Invalid JSON Object Iterator. + * @return Length of the returned string or -1 on error. + */ +native json_object_iter_key(Handle:hIter, String:sKeyBuffer[], maxlength); + +/** + * Returns a handle to the value hIter is pointing at. + * + * @param hIter Handle to JSON object iterator. + * + * @return Handle to value or INVALID_HANDLE on error. + */ +native Handle:json_object_iter_value(Handle:hIter); + +/** + * Set the value of the key-value pair in hObj, that is pointed to + * by hIter, to hValue. + * + * @param hObj Handle to JSON object. + * @param hIter Handle to JSON object iterator. + * @param hValue Handle to JSON value. + * + * @return True on success. + */ +native bool:json_object_iter_set(Handle:hObj, Handle:hIter, Handle:hValue); + +/** + * Set the value of the key-value pair in hObj, that is pointed to + * by hIter, to hValue. + * This function automatically closes the Handle to the value object. + * + * @param hObj Handle to JSON object. + * @param hIter Handle to JSON object iterator. + * @param hValue Handle to JSON value. + * + * @return True on success. + */ +native bool:json_object_iter_set_new(Handle:hObj, Handle:hIter, Handle:hValue); + + + + +/** + * Arrays + * + * A JSON array is an ordered collection of other JSON values. + * + */ + +/** + * Returns a handle to a new JSON array, or INVALID_HANDLE on error. + * + * @return Handle to the new JSON array + */ +native Handle:json_array(); + +/** + * Returns the number of elements in hArray + * + * @param hObj Handle to JSON array + * + * @return Number of elements in hArray, + * or 0 if hObj is not a JSON array. + */ +native json_array_size(Handle:hArray); + +/** + * Returns the element in hArray at position iIndex. + * + * @param hArray Handle to JSON array to get a value from + * @param iIndex Position to retrieve + * + * @return Handle to a the JSON object or + * INVALID_HANDLE on error. + */ +native Handle:json_array_get(Handle:hArray, iIndex); + +/** + * Replaces the element in array at position iIndex with hValue. + * The valid range for iIndex is from 0 to the return value of + * json_array_size() minus 1. + * + * @param hArray Handle to JSON array + * @param iIndex Position to replace + * @param hValue Value to store in the array + * + * @return True on success. + */ +native bool:json_array_set(Handle:hArray, iIndex, Handle:hValue); + +/** + * Replaces the element in array at position iIndex with hValue. + * The valid range for iIndex is from 0 to the return value of + * json_array_size() minus 1. + * This function automatically closes the Handle to the value object. + * + * @param hArray Handle to JSON array + * @param iIndex Position to replace + * @param hValue Value to store in the array + * + * @return True on success. + */ +native bool:json_array_set_new(Handle:hArray, iIndex, Handle:hValue); + +/** + * Appends value to the end of array, growing the size of array by 1. + * + * @param hArray Handle to JSON array + * @param hValue Value to append to the array + * + * @return True on success. + */ +native bool:json_array_append(Handle:hArray, Handle:hValue); + +/** + * Appends value to the end of array, growing the size of array by 1. + * This function automatically closes the Handle to the value object. + * + * @param hArray Handle to JSON array + * @param hValue Value to append to the array + * + * @return True on success. + */ +native bool:json_array_append_new(Handle:hArray, Handle:hValue); + +/** + * Inserts value to hArray at position iIndex, shifting the elements at + * iIndex and after it one position towards the end of the array. + * + * @param hArray Handle to JSON array + * @param iIndex Position to insert at + * @param hValue Value to store in the array + * + * @return True on success. + */ +native bool:json_array_insert(Handle:hArray, iIndex, Handle:hValue); + +/** + * Inserts value to hArray at position iIndex, shifting the elements at + * iIndex and after it one position towards the end of the array. + * This function automatically closes the Handle to the value object. + * + * @param hArray Handle to JSON array + * @param iIndex Position to insert at + * @param hValue Value to store in the array + * + * @return True on success. + */ +native bool:json_array_insert_new(Handle:hArray, iIndex, Handle:hValue); + +/** + * Removes the element in hArray at position iIndex, shifting the + * elements after iIndex one position towards the start of the array. + * + * @param hArray Handle to JSON array + * @param iIndex Position to insert at + * + * @return True on success. + */ +native bool:json_array_remove(Handle:hArray, iIndex); + +/** + * Removes all elements from hArray. + * + * @param hArray Handle to JSON array + * + * @return True on success. + */ +native bool:json_array_clear(Handle:hArray); + +/** + * Appends all elements in hOther to the end of hArray. + * + * @param hArray Handle to JSON array to be extended + * @param hOther Handle to JSON array, source to copy from + * + * @return True on success. + */ +native bool:json_array_extend(Handle:hArray, Handle:hOther); + + + + +/** + * Booleans & NULL + * + */ + +/** + * Returns a handle to a new JSON Boolean with value true, + * or INVALID_HANDLE on error. + * + * @return Handle to the new Boolean object + */ +native Handle:json_true(); + +/** + * Returns a handle to a new JSON Boolean with value false, + * or INVALID_HANDLE on error. + * + * @return Handle to the new Boolean object + */ +native Handle:json_false(); + +/** + * Returns a handle to a new JSON Boolean with the value passed + * in bState or INVALID_HANDLE on error. + * + * @param bState Value for the new Boolean object + * @return Handle to the new Boolean object + */ +native Handle:json_boolean(bool:bState); + +/** + * Returns a handle to a new JSON NULL or INVALID_HANDLE on error. + * + * @return Handle to the new NULL object + */ +native Handle:json_null(); + + + + +/** + * Strings + * + * Jansson uses UTF-8 as the character encoding. All JSON strings must + * be valid UTF-8 (or ASCII, as it�s a subset of UTF-8). Normal null + * terminated C strings are used, so JSON strings may not contain + * embedded null characters. + * + */ + +/** + * Returns a handle to a new JSON string, or INVALID_HANDLE on error. + * + * @param sValue Value for the new String object + * Must be a valid UTF-8 encoded Unicode string. + * @return Handle to the new String object + */ +native Handle:json_string(const String:sValue[]); + +/** + * Saves the associated value of hString as a null terminated UTF-8 + * encoded string in the passed buffer. + * + * @param hString Handle to the JSON String object + * @param sValueBuffer Buffer to store the value of the String. + * @param maxlength Maximum length of string buffer. + * @error Invalid JSON String Object. + * @return Length of the returned string or -1 on error. + */ +native json_string_value(Handle:hString, String:sValueBuffer[], maxlength); + +/** + * Sets the associated value of JSON String object to value. + * + * @param hString Handle to the JSON String object + * @param sValue Value to set the object to. + * Must be a valid UTF-8 encoded Unicode string. + * @error Invalid JSON String Object. + * @return True on success. + */ +native bool:json_string_set(Handle:hString, String:sValue[]); + + + + +/** + * Numbers + * + * The JSON specification only contains one numeric type, 'number'. + * The C (and Pawn) programming language has distinct types for integer + * and floating-point numbers, so for practical reasons Jansson also has + * distinct types for the two. They are called 'integer' and 'real', + * respectively. (Whereas 'real' is a 'Float' for Pawn). + * Therefore a number is represented by either a value of the type + * JSON_INTEGER or of the type JSON_REAL. + * + */ + +/** + * Returns a handle to a new JSON integer, or INVALID_HANDLE on error. + * + * @param iValue Value for the new Integer object + * @return Handle to the new Integer object + */ +native Handle:json_integer(iValue); + +/** + * Returns the associated value of a JSON Integer Object. + * + * @param hInteger Handle to the JSON Integer object + * @error Invalid JSON Integer Object. + * @return Value of the hInteger, + * or 0 if hInteger is not a JSON integer. + */ +native json_integer_value(Handle:hInteger); + +/** + * Sets the associated value of JSON Integer to value. + * + * @param hInteger Handle to the JSON Integer object + * @param iValue Value to set the object to. + * @error Invalid JSON Integer Object. + * @return True on success. + */ +native bool:json_integer_set(Handle:hInteger, iValue); + +/** + * Returns a handle to a new JSON real, or INVALID_HANDLE on error. + * + * @param fValue Value for the new Real object + * @return Handle to the new String object + */ +native Handle:json_real(Float:fValue); + +/** + * Returns the associated value of a JSON Real. + * + * @param hReal Handle to the JSON Real object + * @error Invalid JSON Real Object. + * @return Float value of hReal, + * or 0.0 if hReal is not a JSON Real. + */ +native Float:json_real_value(Handle:hReal); + +/** + * Sets the associated value of JSON Real to fValue. + * + * @param hReal Handle to the JSON Integer object + * @param fValue Value to set the object to. + * @error Invalid JSON Real handle. + * @return True on success. + */ +native bool:json_real_set(Handle:hReal, Float:value); + +/** + * Returns the associated value of a JSON integer or a + * JSON Real, cast to Float regardless of the actual type. + * + * @param hNumber Handle to the JSON Number + * @error Not a JSON Real or JSON Integer + * @return Float value of hNumber, + * or 0.0 on error. + */ +native Float:json_number_value(Handle:hNumber); + + + + +/** + * Decoding + * + * This sections describes the functions that can be used to decode JSON text + * to the Jansson representation of JSON data. The JSON specification requires + * that a JSON text is either a serialized array or object, and this + * requirement is also enforced with the following functions. In other words, + * the top level value in the JSON text being decoded must be either array or + * object. + * + */ + +/** + * Decodes the JSON string sJSON and returns the array or object it contains. + * Errors while decoding can be found in the sourcemod error log. + * + * @param sJSON String containing valid JSON + + * @return Handle to JSON object or array. + * or INVALID_HANDLE on error. + */ +native Handle:json_load(const String:sJSON[]); + +/** + * Decodes the JSON string sJSON and returns the array or object it contains. + * This function provides additional error feedback and does not log errors + * to the sourcemod error log. + * + * @param sJSON String containing valid JSON + * @param sErrorText This buffer will be filled with the error + * message. + * @param maxlen Size of the buffer + * @param iLine This int will contain the line of the error + * @param iColumn This int will contain the column of the error + * + * @return Handle to JSON object or array. + * or INVALID_HANDLE on error. + */ +native Handle:json_load_ex(const String:sJSON[], String:sErrorText[], maxlen, &iLine, &iColumn); + +/** + * Decodes the JSON text in file sFilePath and returns the array or object + * it contains. + * Errors while decoding can be found in the sourcemod error log. + * + * @param sFilePath Path to a file containing pure JSON + * + * @return Handle to JSON object or array. + * or INVALID_HANDLE on error. + */ +native Handle:json_load_file(const String:sFilePath[PLATFORM_MAX_PATH]); + +/** + * Decodes the JSON text in file sFilePath and returns the array or object + * it contains. + * This function provides additional error feedback and does not log errors + * to the sourcemod error log. + * + * @param sFilePath Path to a file containing pure JSON + * @param sErrorText This buffer will be filled with the error + * message. + * @param maxlen Size of the buffer + * @param iLine This int will contain the line of the error + * @param iColumn This int will contain the column of the error + * + * @return Handle to JSON object or array. + * or INVALID_HANDLE on error. + */ +native Handle:json_load_file_ex(const String:sFilePath[PLATFORM_MAX_PATH], String:sErrorText[], maxlen, &iLine, &iColumn); + + + +/** + * Encoding + * + * This sections describes the functions that can be used to encode values + * to JSON. By default, only objects and arrays can be encoded directly, + * since they are the only valid root values of a JSON text. + * + */ + +/** + * Saves the JSON representation of hObject in sJSON. + * + * @param hObject String containing valid JSON + * @param sJSON Buffer to store the created JSON string. + * @param maxlength Maximum length of string buffer. + * @param iIndentWidth Indenting with iIndentWidth spaces. + * The valid range for this is between 0 and 31 (inclusive), + * other values result in an undefined output. If this is set + * to 0, no newlines are inserted between array and object items. + * @param bEnsureAscii If this is set, the output is guaranteed + * to consist only of ASCII characters. This is achieved + * by escaping all Unicode characters outside the ASCII range. + * @param bSortKeys If this flag is used, all the objects in output are sorted + * by key. This is useful e.g. if two JSON texts are diffed + * or visually compared. + * @param bPreserveOrder If this flag is used, object keys in the output are sorted + * into the same order in which they were first inserted to + * the object. For example, decoding a JSON text and then + * encoding with this flag preserves the order of object keys. + * @return Length of the returned string or -1 on error. + */ +native json_dump(Handle:hObject, String:sJSON[], maxlength, iIndentWidth = 4, bool:bEnsureAscii = false, bool:bSortKeys = false, bool:bPreserveOrder = false); + +/** + * Write the JSON representation of hObject to the file sFilePath. + * If sFilePath already exists, it is overwritten. + * + * @param hObject String containing valid JSON + * @param sFilePath Buffer to store the created JSON string. + * @param iIndentWidth Indenting with iIndentWidth spaces. + * The valid range for this is between 0 and 31 (inclusive), + * other values result in an undefined output. If this is set + * to 0, no newlines are inserted between array and object items. + * @param bEnsureAscii If this is set, the output is guaranteed + * to consist only of ASCII characters. This is achieved + * by escaping all Unicode characters outside the ASCII range. + * @param bSortKeys If this flag is used, all the objects in output are sorted + * by key. This is useful e.g. if two JSON texts are diffed + * or visually compared. + * @param bPreserveOrder If this flag is used, object keys in the output are sorted + * into the same order in which they were first inserted to + * the object. For example, decoding a JSON text and then + * encoding with this flag preserves the order of object keys. + * @return Length of the returned string or -1 on error. + */ +native bool:json_dump_file(Handle:hObject, const String:sFilePath[], iIndentWidth = 4, bool:bEnsureAscii = false, bool:bSortKeys = false, bool:bPreserveOrder = false); + + + +/** + * Convenience stocks + * + * These are some custom functions to ease the development using this + * extension. + * + */ + +/** + * Returns a handle to a new JSON string, or INVALID_HANDLE on error. + * Formats the string according to the SourceMod format rules. + * The result must be a valid UTF-8 encoded Unicode string. + * + * @param sFormat Formatting rules. + * @param ... Variable number of format parameters. + * @return Handle to the new String object + */ +stock Handle:json_string_format(const String:sFormat[], any:...) { + new String:sTmp[4096]; + VFormat(sTmp, sizeof(sTmp), sFormat, 2); + + return json_string(sTmp); +} + +/** + * Returns a handle to a new JSON string, or INVALID_HANDLE on error. + * This stock allows to specify the size of the temporary buffer used + * to create the string. Use this if the default of 4096 is not enough + * for your string. + * Formats the string according to the SourceMod format rules. + * The result must be a valid UTF-8 encoded Unicode string. + * + * @param tmpBufferLength Size of the temporary buffer + * @param sFormat Formatting rules. + * @param ... Variable number of format parameters. + * @return Handle to the new String object + */ +stock Handle:json_string_format_ex(tmpBufferLength, const String:sFormat[], any:...) { + new String:sTmp[tmpBufferLength]; + VFormat(sTmp, sizeof(sTmp), sFormat, 3); + + return json_string(sTmp); +} + + +/** + * Returns the boolean value of the element in hArray at position iIndex. + * + * @param hArray Handle to JSON array to get a value from + * @param iIndex Position to retrieve + * + * @return True if it's a boolean and TRUE, + * false otherwise. + */ +stock bool:json_array_get_bool(Handle:hArray, iIndex) { + new Handle:hElement = json_array_get(hArray, iIndex); + + new bool:bResult = (json_is_true(hElement) ? true : false); + + CloseHandle(hElement); + return bResult; +} + +/** + * Returns the float value of the element in hArray at position iIndex. + * + * @param hArray Handle to JSON array to get a value from + * @param iIndex Position to retrieve + * + * @return Float value, + * or 0.0 if element is not a JSON Real. + */ +stock Float:json_array_get_float(Handle:hArray, iIndex) { + new Handle:hElement = json_array_get(hArray, iIndex); + + new Float:fResult = (json_is_number(hElement) ? json_number_value(hElement) : 0.0); + + CloseHandle(hElement); + return fResult; +} + +/** + * Returns the integer value of the element in hArray at position iIndex. + * + * @param hArray Handle to JSON array to get a value from + * @param iIndex Position to retrieve + * + * @return Integer value, + * or 0 if element is not a JSON Integer. + */ +stock json_array_get_int(Handle:hArray, iIndex) { + new Handle:hElement = json_array_get(hArray, iIndex); + + new iResult = (json_is_integer(hElement) ? json_integer_value(hElement) : 0); + + CloseHandle(hElement); + return iResult; +} + +/** + * Saves the associated value of the element in hArray at position iIndex + * as a null terminated UTF-8 encoded string in the passed buffer. + * + * @param hArray Handle to JSON array to get a value from + * @param iIndex Position to retrieve + * @param sBuffer Buffer to store the value of the String. + * @param maxlength Maximum length of string buffer. + * + * @error Element is not a JSON String. + * @return Length of the returned string or -1 on error. + */ +stock json_array_get_string(Handle:hArray, iIndex, String:sBuffer[], maxlength) { + new Handle:hElement = json_array_get(hArray, iIndex); + + new iResult = -1; + if(json_is_string(hElement)) { + iResult = json_string_value(hElement, sBuffer, maxlength); + } + CloseHandle(hElement); + + return iResult; +} + +/** + * Returns the boolean value of the element in hObj at entry sKey. + * + * @param hObj Handle to JSON object to get a value from + * @param sKey Entry to retrieve + * + * @return True if it's a boolean and TRUE, + * false otherwise. + */ +stock bool:json_object_get_bool(Handle:hObj, const String:sKey[]) { + new Handle:hElement = json_object_get(hObj, sKey); + + new bool:bResult = (json_is_true(hElement) ? true : false); + + CloseHandle(hElement); + return bResult; +} + +/** + * Returns the float value of the element in hObj at entry sKey. + * + * @param hObj Handle to JSON object to get a value from + * @param sKey Position to retrieve + * + * @return Float value, + * or 0.0 if element is not a JSON Real. + */ +stock Float:json_object_get_float(Handle:hObj, const String:sKey[]) { + new Handle:hElement = json_object_get(hObj, sKey); + + new Float:fResult = (json_is_number(hElement) ? json_number_value(hElement) : 0.0); + + CloseHandle(hElement); + return fResult; +} + +/** + * Returns the integer value of the element in hObj at entry sKey. + * + * @param hObj Handle to JSON object to get a value from + * @param sKey Position to retrieve + * + * @return Integer value, + * or 0 if element is not a JSON Integer. + */ +stock json_object_get_int(Handle:hObj, const String:sKey[]) { + new Handle:hElement = json_object_get(hObj, sKey); + + new iResult = (json_is_integer(hElement) ? json_integer_value(hElement) : 0); + + CloseHandle(hElement); + return iResult; +} + +/** + * Saves the associated value of the element in hObj at entry sKey + * as a null terminated UTF-8 encoded string in the passed buffer. + * + * @param hObj Handle to JSON object to get a value from + * @param sKey Entry to retrieve + * @param sBuffer Buffer to store the value of the String. + * @param maxlength Maximum length of string buffer. + * + * @error Element is not a JSON String. + * @return Length of the returned string or -1 on error. + */ +stock json_object_get_string(Handle:hObj, const String:sKey[], String:sBuffer[], maxlength) { + new Handle:hElement = json_object_get(hObj, sKey); + + new iResult = -1; + if(json_is_string(hElement)) { + iResult = json_string_value(hElement, sBuffer, maxlength); + } + CloseHandle(hElement); + + return iResult; +} + + + +/** + * Pack String Rules + * + * Here�s the full list of format characters: + * n Output a JSON null value. No argument is consumed. + * s Output a JSON string, consuming one argument. + * b Output a JSON bool value, consuming one argument. + * i Output a JSON integer value, consuming one argument. + * f Output a JSON real value, consuming one argument. + * r Output a JSON real value, consuming one argument. + * [] Build an array with contents from the inner format string, + * recursive value building is supported. + * No argument is consumed. + * {} Build an array with contents from the inner format string. + * The first, third, etc. format character represent a key, + * and must be s (as object keys are always strings). The + * second, fourth, etc. format character represent a value. + * Recursive value building is supported. + * No argument is consumed. + * + */ + +/** + * This method can be used to create json objects/arrays directly + * without having to create the structure. + * See 'Pack String Rules' for more details. + * + * @param sPackString Pack string similiar to Format()s fmt. + * See 'Pack String Rules'. + * @param hParams ADT Array containing all keys and values + * in the order they appear in the pack string. + * + * @error Invalid pack string or pack string and + * ADT Array don't match up regarding type + * or size. + * @return Handle to JSON element. + */ +stock Handle:json_pack(const String:sPackString[], Handle:hParams) { + new iPos = 0; + return json_pack_element_(sPackString, iPos, hParams); +} + + + + + +/** +* Internal stocks used by json_pack(). Don't use these directly! +* +*/ +stock Handle:json_pack_array_(const String:sFormat[], &iPos, Handle:hParams) { + new Handle:hObj = json_array(); + new iStrLen = strlen(sFormat); + for(; iPos < iStrLen;) { + new this_char = sFormat[iPos]; + + if(this_char == 32 || this_char == 58 || this_char == 44) { + // Skip whitespace, ',' and ':' + iPos++; + continue; + } + + if(this_char == 93) { + // array end + iPos++; + break; + } + + // Get the next entry as value + // This automatically increments the position! + new Handle:hValue = json_pack_element_(sFormat, iPos, hParams); + + // Append the value to the array. + json_array_append_new(hObj, hValue); + } + + return hObj; +} + +stock Handle:json_pack_object_(const String:sFormat[], &iPos, Handle:hParams) { + new Handle:hObj = json_object(); + new iStrLen = strlen(sFormat); + for(; iPos < iStrLen;) { + new this_char = sFormat[iPos]; + + if(this_char == 32 || this_char == 58 || this_char == 44) { + // Skip whitespace, ',' and ':' + iPos++; + continue; + } + + if(this_char == 125) { + // } --> object end + iPos++; + break; + } + + if(this_char != 115) { + LogError("Object keys must be strings at %d.", iPos); + return INVALID_HANDLE; + } + + // Get the key string for this object from + // the hParams array. + decl String:sKey[255]; + GetArrayString(hParams, 0, sKey, sizeof(sKey)); + RemoveFromArray(hParams, 0); + + // Advance one character in the pack string, + // because we've just read the Key string for + // this object. + iPos++; + + // Get the next entry as value + // This automatically increments the position! + new Handle:hValue = json_pack_element_(sFormat, iPos, hParams); + + // Insert into object + json_object_set_new(hObj, sKey, hValue); + } + + return hObj; +} + +stock Handle:json_pack_element_(const String:sFormat[], &iPos, Handle:hParams) { + new this_char = sFormat[iPos]; + while(this_char == 32 || this_char == 58 || this_char == 44) { + iPos++; + this_char = sFormat[iPos]; + } + + // Advance one character in the pack string + iPos++; + + switch(this_char) { + case 91: { + // { --> Array + return json_pack_array_(sFormat, iPos, hParams); + } + + case 123: { + // { --> Object + return json_pack_object_(sFormat, iPos, hParams); + + } + + case 98: { + // b --> Boolean + new iValue = GetArrayCell(hParams, 0); + RemoveFromArray(hParams, 0); + + return json_boolean(bool:iValue); + } + + case 102, 114: { + // r,f --> Real (Float) + new Float:iValue = GetArrayCell(hParams, 0); + RemoveFromArray(hParams, 0); + + return json_real(iValue); + } + + case 110: { + // n --> NULL + return json_null(); + } + + case 115: { + // s --> String + decl String:sKey[255]; + GetArrayString(hParams, 0, sKey, sizeof(sKey)); + RemoveFromArray(hParams, 0); + + return json_string(sKey); + } + + case 105: { + // i --> Integer + new iValue = GetArrayCell(hParams, 0); + RemoveFromArray(hParams, 0); + + return json_integer(iValue); + } + } + + SetFailState("Invalid pack String '%s'. Type '%s' not supported at %i", sFormat, this_char, iPos); + return json_null(); +} + + + + + +/** + * Not yet implemented + * + * native json_object_foreach(Handle:hObj, ForEachCallback:cb); + * native Handle:json_unpack(const String:sFormat[], ...); + * + */ + + + + + + +/** + * Do not edit below this line! + */ +public Extension:__ext_smjansson = +{ + name = "SMJansson", + file = "smjansson.ext", +#if defined AUTOLOAD_EXTENSIONS + autoload = 1, +#else + autoload = 0, +#endif +#if defined REQUIRE_EXTENSIONS + required = 1, +#else + required = 0, +#endif +}; + +#if !defined REQUIRE_EXTENSIONS +public __ext_smjansson_SetNTVOptional() +{ + MarkNativeAsOptional("json_typeof"); + MarkNativeAsOptional("json_equal"); + + MarkNativeAsOptional("json_copy"); + MarkNativeAsOptional("json_deep_copy"); + + MarkNativeAsOptional("json_object"); + MarkNativeAsOptional("json_object_size"); + MarkNativeAsOptional("json_object_get"); + MarkNativeAsOptional("json_object_set"); + MarkNativeAsOptional("json_object_set_new"); + MarkNativeAsOptional("json_object_del"); + MarkNativeAsOptional("json_object_clear"); + MarkNativeAsOptional("json_object_update"); + MarkNativeAsOptional("json_object_update_existing"); + MarkNativeAsOptional("json_object_update_missing"); + + MarkNativeAsOptional("json_object_iter"); + MarkNativeAsOptional("json_object_iter_at"); + MarkNativeAsOptional("json_object_iter_next"); + MarkNativeAsOptional("json_object_iter_key"); + MarkNativeAsOptional("json_object_iter_value"); + MarkNativeAsOptional("json_object_iter_set"); + MarkNativeAsOptional("json_object_iter_set_new"); + + MarkNativeAsOptional("json_array"); + MarkNativeAsOptional("json_array_size"); + MarkNativeAsOptional("json_array_get"); + MarkNativeAsOptional("json_array_set"); + MarkNativeAsOptional("json_array_set_new"); + MarkNativeAsOptional("json_array_append"); + MarkNativeAsOptional("json_array_append_new"); + MarkNativeAsOptional("json_array_insert"); + MarkNativeAsOptional("json_array_insert_new"); + MarkNativeAsOptional("json_array_remove"); + MarkNativeAsOptional("json_array_clear"); + MarkNativeAsOptional("json_array_extend"); + + MarkNativeAsOptional("json_string"); + MarkNativeAsOptional("json_string_value"); + MarkNativeAsOptional("json_string_set"); + + MarkNativeAsOptional("json_integer"); + MarkNativeAsOptional("json_integer_value"); + MarkNativeAsOptional("json_integer_set"); + + MarkNativeAsOptional("json_real"); + MarkNativeAsOptional("json_real_value"); + MarkNativeAsOptional("json_real_set"); + MarkNativeAsOptional("json_number_value"); + + MarkNativeAsOptional("json_boolean"); + MarkNativeAsOptional("json_true"); + MarkNativeAsOptional("json_false"); + MarkNativeAsOptional("json_null"); + + MarkNativeAsOptional("json_load"); + MarkNativeAsOptional("json_load_file"); + + MarkNativeAsOptional("json_dump"); + MarkNativeAsOptional("json_dump_file"); +} +#endif diff --git a/sourcemod/scripting/include/sourcebanspp.inc b/sourcemod/scripting/include/sourcebanspp.inc new file mode 100644 index 0000000..c984bff --- /dev/null +++ b/sourcemod/scripting/include/sourcebanspp.inc @@ -0,0 +1,106 @@ +// ************************************************************************* +// This file is part of SourceBans++. +// +// Copyright (C) 2014-2019 SourceBans++ Dev Team <https://github.com/sbpp> +// +// SourceBans++ 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, per version 3 of the License. +// +// SourceBans++ 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 SourceBans++. If not, see <http://www.gnu.org/licenses/>. +// +// This file based off work(s) covered by the following copyright(s): +// +// SourceBans 1.4.11 +// Copyright (C) 2007-2015 SourceBans Team - Part of GameConnect +// Licensed under GNU GPL version 3, or later. +// Page: <http://www.sourcebans.net/> - <https://github.com/GameConnect/sourcebansv1> +// +// ************************************************************************* + +#if defined _sourcebanspp_included +#endinput +#endif +#define _sourcebanspp_included + +public SharedPlugin __pl_sourcebanspp = +{ + name = "sourcebans++", + file = "sbpp_main.smx", + #if defined REQUIRE_PLUGIN + required = 1 + #else + required = 0 + #endif +}; + +#if !defined REQUIRE_PLUGIN +public void __pl_sourcebanspp_SetNTVOptional() +{ + MarkNativeAsOptional("SBBanPlayer"); + MarkNativeAsOptional("SBPP_BanPlayer"); + MarkNativeAsOptional("SBPP_ReportPlayer"); +} +#endif + + +/********************************************************* + * Ban Player from server + * + * @param iAdmin The client index of the admin who is banning the client + * @param iTarget The client index of the player to ban + * @param iTime The time to ban the player for (in minutes, 0 = permanent) + * @param sReason The reason to ban the player from the server + * @noreturn + *********************************************************/ +#pragma deprecated Use SBPP_BanPlayer() instead. +native void SBBanPlayer(int iAdmin, int iTarget, int iTime, const char[] sReason); + +/********************************************************* + * Ban Player from server + * + * @param iAdmin The client index of the admin who is banning the client + * @param iTarget The client index of the player to ban + * @param iTime The time to ban the player for (in minutes, 0 = permanent) + * @param sReason The reason to ban the player from the server + * @noreturn + *********************************************************/ +native void SBPP_BanPlayer(int iAdmin, int iTarget, int iTime, const char[] sReason); + +/********************************************************* + * Reports a player + * + * @param iReporter The client index of the reporter + * @param iTarget The client index of the player to report + * @param sReason The reason to report the player + * @noreturn + *********************************************************/ +native void SBPP_ReportPlayer(int iReporter, int iTarget, const char[] sReason); + +/********************************************************* + * Called when the admin banning the player. + * + * @param iAdmin The client index of the admin who is banning the client + * @param iTarget The client index of the player to ban + * @param iTime The time to ban the player for (in minutes, 0 = permanent) + * @param sReason The reason to ban the player from the server + *********************************************************/ +forward void SBPP_OnBanPlayer(int iAdmin, int iTarget, int iTime, const char[] sReason); + +/********************************************************* + * Called when a new report is inserted + * + * @param iReporter The client index of the reporter + * @param iTarget The client index of the player to report + * @param sReason The reason to report the player + * @noreturn + *********************************************************/ +forward void SBPP_OnReportPlayer(int iReporter, int iTarget, const char[] sReason); + +//Yarr! diff --git a/sourcemod/scripting/include/sourcemod-colors.inc b/sourcemod/scripting/include/sourcemod-colors.inc new file mode 100644 index 0000000..66bc97b --- /dev/null +++ b/sourcemod/scripting/include/sourcemod-colors.inc @@ -0,0 +1,921 @@ +#if defined _sourcemod_colors_included + #endinput +#endif +#define _sourcemod_colors_included "1.0" + +/* +* _____ _ _____ _ +* / ____| | | / ____| | | +* | (___ ___ _ _ _ __ ___ ___ _ __ ___ ___ __| | | | ___ | | ___ _ __ ___ +* \___ \ / _ \| | | | '__/ __/ _ \ '_ ` _ \ / _ \ / _` | | | / _ \| |/ _ \| '__/ __| +* ____) | (_) | |_| | | | (_| __/ | | | | | (_) | (_| | | |___| (_) | | (_) | | \__ \ +* |_____/ \___/ \__,_|_| \___\___|_| |_| |_|\___/ \__,_| \_____\___/|_|\___/|_| |___/ +* +* +* - Author: Keith Warren (Drixevel) +* - Original By: Raska aka KissLick (ColorVariables) +* +* This is meant to be a drop-in replacement for every Source Engine game to add colors to chat and more cheat features. +*/ + +// ---------------------------------------------------------------------------------------- +#define MAX_BUFFER_SIZE 1024 + +static bool g_bInit; +static StringMap g_hColors; +static char g_sChatPrefix[64]; + +static bool g_bIgnorePrefix; +static int g_iAuthor; +static bool g_bSkipPlayers[MAXPLAYERS + 1]; +// ---------------------------------------------------------------------------------------- + +/* +* Sets the prefix for all chat prints to use. +* +* prefix - String to use. +* any - Extra Parameters +* +* Return - N/A +*/ +stock void CSetPrefix(const char[] prefix, any ...) +{ + VFormat(g_sChatPrefix, sizeof(g_sChatPrefix), prefix, 2); +} + +/* +* Setup the next print to skip using the prefix. +* +* +* Return - N/A +*/ +stock void CSkipNextPrefix() +{ + g_bIgnorePrefix = true; +} + +/* +* Sets the author for the next print. (Mostly applies colors) +* +* client - Author index. +* +* Return - N/A +*/ +stock void CSetNextAuthor(int client) +{ + if (client < 1 || client > MaxClients || !IsClientInGame(client)) + ThrowError("Invalid client index %i", client); + + g_iAuthor = client; +} + +/* +* Setup the next chat print to not be sent to this client. +* +* client - Client index. +* +* Return - N/A +*/ +stock void CSkipNextClient(int client) +{ + if (client < 1 || client > MaxClients) + ThrowError("Invalid client index %i", client); + + g_bSkipPlayers[client] = true; +} + +/* +* Sends a chat print to the client. +* +* client - Client index. +* message - Message string. +* any - Extra Parameters +* +* Return - N/A +*/ +stock void CPrintToChat(int client, const char[] message, any ...) +{ + if ((client < 1 || client > MaxClients || !IsClientInGame(client) || IsFakeClient(client)) && !IsClientSourceTV(client)) + return; + + SetGlobalTransTarget(client); + + char buffer[MAX_BUFFER_SIZE]; + VFormat(buffer, sizeof(buffer), message, 3); + + AddPrefixAndDefaultColor(buffer, sizeof(buffer)); + g_bIgnorePrefix = false; + + CProcessVariables(buffer, sizeof(buffer)); + CAddWhiteSpace(buffer, sizeof(buffer)); + + SendPlayerMessage(client, buffer, g_iAuthor); + g_iAuthor = 0; +} + +/* +* Sends a chat print to the client with a specified author. +* +* client - Client index. +* author - Author index. +* message - Message string. +* any - Extra Parameters +* +* Return - N/A +*/ +stock void CPrintToChatEx(int client, int author, const char[] message, any ...) +{ + CSetNextAuthor(author); + char buffer[MAX_BUFFER_SIZE]; + VFormat(buffer, sizeof(buffer), message, 4); + CPrintToChat(client, buffer); +} + +/* +* Sends a chat print to all clients. +* +* message - Message string. +* any - Extra Parameters +* +* Return - N/A +*/ +stock void CPrintToChatAll(const char[] message, any ...) +{ + char buffer[MAX_BUFFER_SIZE]; + + for (int client = 1; client <= MaxClients; client++) + { + if (!IsClientInGame(client) || g_bSkipPlayers[client]) + { + g_bSkipPlayers[client] = false; + continue; + } + + SetGlobalTransTarget(client); + + VFormat(buffer, sizeof(buffer), message, 2); + + AddPrefixAndDefaultColor(buffer, sizeof(buffer)); + g_bIgnorePrefix = false; + + CProcessVariables(buffer, sizeof(buffer)); + CAddWhiteSpace(buffer, sizeof(buffer)); + + SendPlayerMessage(client, buffer, g_iAuthor); + } + + g_iAuthor = 0; +} + +/* +* Sends a chat print to all clients with a specified author. +* +* author - Author index. +* message - Message string. +* any - Extra Parameters +* +* Return - N/A +*/ +stock void CPrintToChatAllEx(int author, const char[] message, any ...) +{ + CSetNextAuthor(author); + char buffer[MAX_BUFFER_SIZE]; + VFormat(buffer, sizeof(buffer), message, 3); + CPrintToChatAll(buffer); +} + +/* +* Sends a chat print to a specified team. +* +* team - Team index. +* message - Message string. +* any - Extra Parameters +* +* Return - N/A +*/ +stock void CPrintToChatTeam(int team, const char[] message, any ...) +{ + char buffer[MAX_BUFFER_SIZE]; + + for (int client = 1; client <= MaxClients; client++) + { + if (!IsClientInGame(client) || GetClientTeam(client) != team || g_bSkipPlayers[client]) + { + g_bSkipPlayers[client] = false; + continue; + } + + SetGlobalTransTarget(client); + VFormat(buffer, sizeof(buffer), message, 3); + + AddPrefixAndDefaultColor(buffer, sizeof(buffer)); + g_bIgnorePrefix = false; + + CProcessVariables(buffer, sizeof(buffer)); + CAddWhiteSpace(buffer, sizeof(buffer)); + + SendPlayerMessage(client, buffer, g_iAuthor); + } + + g_iAuthor = 0; +} + +/* +* Sends a chat print to a specified team with a specified author. +* +* team - Team index. +* message - Message string. +* any - Extra Parameters +* +* Return - N/A +*/ +stock void CPrintToChatTeamEx(int team, int author, const char[] message, any ...) +{ + CSetNextAuthor(author); + char buffer[MAX_BUFFER_SIZE]; + VFormat(buffer, sizeof(buffer), message, 4); + CPrintToChatTeam(team, buffer); +} + +/* +* Sends a chat print to available admins. +* Example for bitflags: (ADMFLAG_RESERVATION | ADMFLAG_GENERIC) +* +* bitflags - Bit Flags. +* message - Message string. +* any - Extra Parameters +* +* Return - N/A +*/ +stock void CPrintToChatAdmins(int bitflags, const char[] message, any ...) +{ + char buffer[MAX_BUFFER_SIZE]; + AdminId iAdminID; + + for (int client = 1; client <= MaxClients; client++) + { + if (!IsClientInGame(client) || g_bSkipPlayers[client]) + { + g_bSkipPlayers[client] = false; + continue; + } + + iAdminID = GetUserAdmin(client); + + if (iAdminID == INVALID_ADMIN_ID || !(GetAdminFlags(iAdminID, Access_Effective) & bitflags)) + continue; + + SetGlobalTransTarget(client); + VFormat(buffer, sizeof(buffer), message, 3); + + AddPrefixAndDefaultColor(buffer, sizeof(buffer)); + g_bIgnorePrefix = false; + + CProcessVariables(buffer, sizeof(buffer)); + CAddWhiteSpace(buffer, sizeof(buffer)); + + SendPlayerMessage(client, buffer, g_iAuthor); + } + + g_iAuthor = 0; +} + +/* +* Sends a chat print to available admins with a specified author. +* Example for bitflags: (ADMFLAG_RESERVATION | ADMFLAG_GENERIC) +* +* bitflags - Bit Flags. +* message - Message string. +* any - Extra Parameters +* +* Return - N/A +*/ +stock void CPrintToChatAdminsEx(int bitflags, int author, const char[] message, any ...) +{ + CSetNextAuthor(author); + char buffer[MAX_BUFFER_SIZE]; + VFormat(buffer, sizeof(buffer), message, 4); + CPrintToChatTeam(bitflags, buffer); +} + +/* +* Sends a reply message to the client. (This is useful because it works for console as well) +* +* client - Client index. +* message - Message string. +* any - Extra Parameters +* +* Return - N/A +*/ +stock void CReplyToCommand(int client, const char[] message, any ...) +{ + if (client < 0 || client > MaxClients) + ThrowError("Invalid client index %d", client); + + if (client != 0 && !IsClientInGame(client)) + ThrowError("Client %d is not in game", client); + + char buffer[MAX_BUFFER_SIZE]; + SetGlobalTransTarget(client); + VFormat(buffer, sizeof(buffer), message, 3); + + AddPrefixAndDefaultColor(buffer, sizeof(buffer), "engine 1"); + g_bIgnorePrefix = false; + + if (GetCmdReplySource() == SM_REPLY_TO_CONSOLE) + { + CRemoveColors(buffer, sizeof(buffer)); + PrintToConsole(client, "%s", buffer); + } + else + CPrintToChat(client, "%s", buffer); +} + +/* +* Displays usage of an admin command to users depending on the setting of the sm_show_activity cvar. +* This version does not display a message to the originating client if used from chat triggers or menus. +* If manual replies are used for these cases, then this function will suffice. +* Otherwise, ShowActivity2() is slightly more useful. +* +* client - Client index. +* message - Message string. +* any - Extra Parameters +* +* Return - N/A +*/ +stock void CShowActivity(int client, const char[] message, any ...) +{ + if (client < 0 || client > MaxClients) + ThrowError("Invalid client index %d", client); + + if (client != 0 && !IsClientInGame(client)) + ThrowError("Client %d is not in game", client); + + char buffer[MAX_BUFFER_SIZE]; + SetGlobalTransTarget(client); + VFormat(buffer, sizeof(buffer), message, 3); + Format(buffer, sizeof(buffer), "{engine 1}%s", buffer); + CProcessVariables(buffer, sizeof(buffer)); + CAddWhiteSpace(buffer, sizeof(buffer)); + + ShowActivity(client, "%s", buffer); +} + +/* +* Displays usage of an admin command to users depending on the setting of the sm_show_activity cvar. +* All users receive a message in their chat text, except for the originating client, who receives the message based on the current ReplySource. +* +* client - Client index. +* tag - Tag to show. +* message - Message string. +* any - Extra Parameters +* +* Return - N/A +*/ +stock void CShowActivityEx(int client, const char[] tag, const char[] message, any ...) +{ + if (client < 0 || client > MaxClients) + ThrowError("Invalid client index %d", client); + + if (client != 0 && !IsClientInGame(client)) + ThrowError("Client %d is not in game", client); + + char buffer[MAX_BUFFER_SIZE]; char sBufferTag[MAX_BUFFER_SIZE]; + SetGlobalTransTarget(client); + VFormat(buffer, sizeof(buffer), message, 4); + Format(buffer, sizeof(buffer), "{engine 1}%s", buffer); + CProcessVariables(buffer, sizeof(buffer)); + Format(sBufferTag, sizeof(sBufferTag), "{prefix}%s", tag); + CProcessVariables(sBufferTag, sizeof(sBufferTag)); + CAddWhiteSpace(buffer, sizeof(buffer)); + CAddWhiteSpace(sBufferTag, sizeof(sBufferTag)); + + ShowActivityEx(client, sBufferTag, " %s", buffer); +} + +/* +* Same as ShowActivity(), except the tag parameter is used instead of "[SM] " (note that you must supply any spacing). +* +* client - Client index. +* tag - Tag to show. +* message - Message string. +* any - Extra Parameters +* +* Return - N/A +*/ +stock void CShowActivity2(int client, const char[] tag, const char[] message, any ...) +{ + if (client < 0 || client > MaxClients) + ThrowError("Invalid client index %d", client); + + if (client != 0 && !IsClientInGame(client)) + ThrowError("Client %d is not in game", client); + + char buffer[MAX_BUFFER_SIZE]; char sBufferTag[MAX_BUFFER_SIZE]; + SetGlobalTransTarget(client); + VFormat(buffer, sizeof(buffer), message, 4); + Format(buffer, sizeof(buffer), "{engine 2}%s", buffer); + CProcessVariables(buffer, sizeof(buffer)); + Format(sBufferTag, sizeof(sBufferTag), "{prefix}%s", tag); + CProcessVariables(sBufferTag, sizeof(sBufferTag)); + CAddWhiteSpace(buffer, sizeof(buffer)); + CAddWhiteSpace(sBufferTag, sizeof(sBufferTag)); + + ShowActivityEx(client, sBufferTag, " %s", buffer); +} + +/* +* Strips all colors from the specified string. +* +* msg - String buffer. +* size - Size of the string. +* +* Return - N/A +*/ +stock void CRemoveColors(char[] msg, int size) +{ + CProcessVariables(msg, size, true); +} + +/* +* Processes colors in a string by replacing found tags with color/hex codes. +* +* msg - String buffer. +* size - Size of the string. +* removecolors - Whether to remove colors or keep them. (same as CRemoveColors) +* +* Return - N/A +*/ +stock void CProcessVariables(char[] msg, int size, bool removecolors = false) +{ + Init(); + + char[] sOut = new char[size]; char[] sCode = new char[size]; char[] color = new char[size]; + int iOutPos = 0; int iCodePos = -1; + int iMsgLen = strlen(msg); + + for (int i = 0; i < iMsgLen; i++) + { + if (msg[i] == '{') + iCodePos = 0; + + if (iCodePos > -1) + { + sCode[iCodePos] = msg[i]; + sCode[iCodePos + 1] = '\0'; + + if (msg[i] == '}' || i == iMsgLen - 1) + { + strcopy(sCode, strlen(sCode) - 1, sCode[1]); + StringToLower(sCode); + + if (CGetColor(sCode, color, size)) + { + if (!removecolors) + { + StrCat(sOut, size, color); + iOutPos += strlen(color); + } + } + else + { + Format(sOut, size, "%s{%s}", sOut, sCode); + iOutPos += strlen(sCode) + 2; + } + + iCodePos = -1; + strcopy(sCode, size, ""); + strcopy(color, size, ""); + } + else + iCodePos++; + + continue; + } + + sOut[iOutPos] = msg[i]; + iOutPos++; + sOut[iOutPos] = '\0'; + } + + strcopy(msg, size, sOut); +} + +/* +* Retrieves the color/hex code for a specified color name. +* +* name - Color to search for. +* color - String buffer. +* size - Size of the string. +* +* Return - True if found, false otherwise. +*/ +stock bool CGetColor(const char[] name, char[] color, int size) +{ + if (name[0] == '\0') + return false; + + if (name[0] == '@') + { + int iSpace; + char sData[64]; char m_sName[64]; + strcopy(m_sName, sizeof(m_sName), name[1]); + + if ((iSpace = FindCharInString(m_sName, ' ')) != -1 && (iSpace + 1 < strlen(m_sName))) + { + strcopy(m_sName, iSpace + 1, m_sName); + strcopy(sData, sizeof(sData), m_sName[iSpace + 1]); + } + + if (color[0] != '\0') + return true; + } + else if (name[0] == '#') + { + if (strlen(name) == 7) + { + Format(color, size, "\x07%s", name[1]); + return true; + } + + if (strlen(name) == 9) + { + Format(color, size, "\x08%s", name[1]); + return true; + } + } + else if (StrContains(name, "player ", false) == 0 && strlen(name) > 7) + { + int client = StringToInt(name[7]); + + if (client < 1 || client > MaxClients || !IsClientInGame(client)) + { + strcopy(color, size, "\x01"); + LogError("Invalid client index %d", client); + return false; + } + + strcopy(color, size, "\x01"); + + switch (GetClientTeam(client)) + { + case 1: g_hColors.GetString("engine 8", color, size); + case 2: g_hColors.GetString("engine 9", color, size); + case 3: g_hColors.GetString("engine 11", color, size); + } + + return true; + } + else + return g_hColors.GetString(name, color, size); + + return false; +} + +/* +* Checks if the specified color exists. +* +* name - Color to search for. +* +* Return - True if found, false otherwise. +*/ +stock bool CExistColor(const char[] name) +{ + if (name[0] == '\0' || name[0] == '@' || name[0] == '#') + return false; + + char color[64]; + return g_hColors.GetString(name, color, sizeof(color)); +} + +/* +* Sends a raw SayText2 usermsg to the specified client with settings. +* +* client - Client index. +* message - Message string. +* author - Author index. +* chat - "0 - raw text, 1 - sets CHAT_FILTER_PUBLICCHAT " +* +* Return - N/A +*/ +stock void CSayText2(int client, const char[] message, int author, bool chat = true) +{ + if (client < 1 || client > MaxClients) + return; + + Handle hMsg = StartMessageOne("SayText2", client, USERMSG_RELIABLE|USERMSG_BLOCKHOOKS); + if (GetFeatureStatus(FeatureType_Native, "GetUserMessageType") == FeatureStatus_Available && GetUserMessageType() == UM_Protobuf) + { + PbSetInt(hMsg, "ent_idx", author); + PbSetBool(hMsg, "chat", chat); + PbSetString(hMsg, "msg_name", message); + PbAddString(hMsg, "params", ""); + PbAddString(hMsg, "params", ""); + PbAddString(hMsg, "params", ""); + PbAddString(hMsg, "params", ""); + } + else + { + BfWriteByte(hMsg, author); + BfWriteByte(hMsg, true); + BfWriteString(hMsg, message); + } + + EndMessage(); +} + +/* +* Adds a space to the start a string buffer. +* +* buffer - String buffer. +* size - Size of the string. +* +* Return - N/A +*/ +stock void CAddWhiteSpace(char[] buffer, int size) +{ + if (!IsSource2009()) + Format(buffer, size, " %s", buffer); +} + +// ---------------------------------------------------------------------------------------- +// Private stuff +// ---------------------------------------------------------------------------------------- + +stock bool Init() +{ + if (g_bInit) + { + LoadColors(); + return true; + } + + for (int i = 1; i <= MaxClients; i++) + g_bSkipPlayers[i] = false; + + LoadColors(); + g_bInit = true; + + return true; +} + +stock void LoadColors() +{ + if (g_hColors == null) + g_hColors = new StringMap(); + else + g_hColors.Clear(); + + g_hColors.SetString("default", "\x01"); + g_hColors.SetString("teamcolor", "\x03"); + + if (IsSource2009()) + { + g_hColors.SetString("aliceblue", "\x07F0F8FF"); + g_hColors.SetString("allies", "\x074D7942"); + g_hColors.SetString("ancient", "\x07EB4B4B"); + g_hColors.SetString("antiquewhite", "\x07FAEBD7"); + g_hColors.SetString("aqua", "\x0700FFFF"); + g_hColors.SetString("aquamarine", "\x077FFFD4"); + g_hColors.SetString("arcana", "\x07ADE55C"); + g_hColors.SetString("axis", "\x07FF4040"); + g_hColors.SetString("azure", "\x07007FFF"); + g_hColors.SetString("beige", "\x07F5F5DC"); + g_hColors.SetString("bisque", "\x07FFE4C4"); + g_hColors.SetString("black", "\x07000000"); + g_hColors.SetString("blanchedalmond", "\x07FFEBCD"); + g_hColors.SetString("blue", "\x0799CCFF"); + g_hColors.SetString("blueviolet", "\x078A2BE2"); + g_hColors.SetString("brown", "\x07A52A2A"); + g_hColors.SetString("burlywood", "\x07DEB887"); + g_hColors.SetString("cadetblue", "\x075F9EA0"); + g_hColors.SetString("chartreuse", "\x077FFF00"); + g_hColors.SetString("chocolate", "\x07D2691E"); + g_hColors.SetString("collectors", "\x07AA0000"); + g_hColors.SetString("common", "\x07B0C3D9"); + g_hColors.SetString("community", "\x0770B04A"); + g_hColors.SetString("coral", "\x07FF7F50"); + g_hColors.SetString("cornflowerblue", "\x076495ED"); + g_hColors.SetString("cornsilk", "\x07FFF8DC"); + g_hColors.SetString("corrupted", "\x07A32C2E"); + g_hColors.SetString("crimson", "\x07DC143C"); + g_hColors.SetString("cyan", "\x0700FFFF"); + g_hColors.SetString("darkblue", "\x0700008B"); + g_hColors.SetString("darkcyan", "\x07008B8B"); + g_hColors.SetString("darkgoldenrod", "\x07B8860B"); + g_hColors.SetString("darkgray", "\x07A9A9A9"); + g_hColors.SetString("darkgrey", "\x07A9A9A9"); + g_hColors.SetString("darkgreen", "\x07006400"); + g_hColors.SetString("darkkhaki", "\x07BDB76B"); + g_hColors.SetString("darkmagenta", "\x078B008B"); + g_hColors.SetString("darkolivegreen", "\x07556B2F"); + g_hColors.SetString("darkorange", "\x07FF8C00"); + g_hColors.SetString("darkorchid", "\x079932CC"); + g_hColors.SetString("darkred", "\x078B0000"); + g_hColors.SetString("darksalmon", "\x07E9967A"); + g_hColors.SetString("darkseagreen", "\x078FBC8F"); + g_hColors.SetString("darkslateblue", "\x07483D8B"); + g_hColors.SetString("darkslategray", "\x072F4F4F"); + g_hColors.SetString("darkslategrey", "\x072F4F4F"); + g_hColors.SetString("darkturquoise", "\x0700CED1"); + g_hColors.SetString("darkviolet", "\x079400D3"); + g_hColors.SetString("deeppink", "\x07FF1493"); + g_hColors.SetString("deepskyblue", "\x0700BFFF"); + g_hColors.SetString("dimgray", "\x07696969"); + g_hColors.SetString("dimgrey", "\x07696969"); + g_hColors.SetString("dodgerblue", "\x071E90FF"); + g_hColors.SetString("exalted", "\x07CCCCCD"); + g_hColors.SetString("firebrick", "\x07B22222"); + g_hColors.SetString("floralwhite", "\x07FFFAF0"); + g_hColors.SetString("forestgreen", "\x07228B22"); + g_hColors.SetString("frozen", "\x074983B3"); + g_hColors.SetString("fuchsia", "\x07FF00FF"); + g_hColors.SetString("fullblue", "\x070000FF"); + g_hColors.SetString("fullred", "\x07FF0000"); + g_hColors.SetString("gainsboro", "\x07DCDCDC"); + g_hColors.SetString("genuine", "\x074D7455"); + g_hColors.SetString("ghostwhite", "\x07F8F8FF"); + g_hColors.SetString("gold", "\x07FFD700"); + g_hColors.SetString("goldenrod", "\x07DAA520"); + g_hColors.SetString("gray", "\x07CCCCCC"); + g_hColors.SetString("grey", "\x07CCCCCC"); + g_hColors.SetString("green", "\x073EFF3E"); + g_hColors.SetString("greenyellow", "\x07ADFF2F"); + g_hColors.SetString("haunted", "\x0738F3AB"); + g_hColors.SetString("honeydew", "\x07F0FFF0"); + g_hColors.SetString("hotpink", "\x07FF69B4"); + g_hColors.SetString("immortal", "\x07E4AE33"); + g_hColors.SetString("indianred", "\x07CD5C5C"); + g_hColors.SetString("indigo", "\x074B0082"); + g_hColors.SetString("ivory", "\x07FFFFF0"); + g_hColors.SetString("khaki", "\x07F0E68C"); + g_hColors.SetString("lavender", "\x07E6E6FA"); + g_hColors.SetString("lavenderblush", "\x07FFF0F5"); + g_hColors.SetString("lawngreen", "\x077CFC00"); + g_hColors.SetString("legendary", "\x07D32CE6"); + g_hColors.SetString("lemonchiffon", "\x07FFFACD"); + g_hColors.SetString("lightblue", "\x07ADD8E6"); + g_hColors.SetString("lightcoral", "\x07F08080"); + g_hColors.SetString("lightcyan", "\x07E0FFFF"); + g_hColors.SetString("lightgoldenrodyellow", "\x07FAFAD2"); + g_hColors.SetString("lightgray", "\x07D3D3D3"); + g_hColors.SetString("lightgrey", "\x07D3D3D3"); + g_hColors.SetString("lightgreen", "\x0799FF99"); + g_hColors.SetString("lightpink", "\x07FFB6C1"); + g_hColors.SetString("lightsalmon", "\x07FFA07A"); + g_hColors.SetString("lightseagreen", "\x0720B2AA"); + g_hColors.SetString("lightskyblue", "\x0787CEFA"); + g_hColors.SetString("lightslategray", "\x07778899"); + g_hColors.SetString("lightslategrey", "\x07778899"); + g_hColors.SetString("lightsteelblue", "\x07B0C4DE"); + g_hColors.SetString("lightyellow", "\x07FFFFE0"); + g_hColors.SetString("lime", "\x0700FF00"); + g_hColors.SetString("limegreen", "\x0732CD32"); + g_hColors.SetString("linen", "\x07FAF0E6"); + g_hColors.SetString("magenta", "\x07FF00FF"); + g_hColors.SetString("maroon", "\x07800000"); + g_hColors.SetString("mediumaquamarine", "\x0766CDAA"); + g_hColors.SetString("mediumblue", "\x070000CD"); + g_hColors.SetString("mediumorchid", "\x07BA55D3"); + g_hColors.SetString("mediumpurple", "\x079370D8"); + g_hColors.SetString("mediumseagreen", "\x073CB371"); + g_hColors.SetString("mediumslateblue", "\x077B68EE"); + g_hColors.SetString("mediumspringgreen", "\x0700FA9A"); + g_hColors.SetString("mediumturquoise", "\x0748D1CC"); + g_hColors.SetString("mediumvioletred", "\x07C71585"); + g_hColors.SetString("midnightblue", "\x07191970"); + g_hColors.SetString("mintcream", "\x07F5FFFA"); + g_hColors.SetString("mistyrose", "\x07FFE4E1"); + g_hColors.SetString("moccasin", "\x07FFE4B5"); + g_hColors.SetString("mythical", "\x078847FF"); + g_hColors.SetString("navajowhite", "\x07FFDEAD"); + g_hColors.SetString("navy", "\x07000080"); + g_hColors.SetString("normal", "\x07B2B2B2"); + g_hColors.SetString("oldlace", "\x07FDF5E6"); + g_hColors.SetString("olive", "\x079EC34F"); + g_hColors.SetString("olivedrab", "\x076B8E23"); + g_hColors.SetString("orange", "\x07FFA500"); + g_hColors.SetString("orangered", "\x07FF4500"); + g_hColors.SetString("orchid", "\x07DA70D6"); + g_hColors.SetString("palegoldenrod", "\x07EEE8AA"); + g_hColors.SetString("palegreen", "\x0798FB98"); + g_hColors.SetString("paleturquoise", "\x07AFEEEE"); + g_hColors.SetString("palevioletred", "\x07D87093"); + g_hColors.SetString("papayawhip", "\x07FFEFD5"); + g_hColors.SetString("peachpuff", "\x07FFDAB9"); + g_hColors.SetString("peru", "\x07CD853F"); + g_hColors.SetString("pink", "\x07FFC0CB"); + g_hColors.SetString("plum", "\x07DDA0DD"); + g_hColors.SetString("powderblue", "\x07B0E0E6"); + g_hColors.SetString("purple", "\x07800080"); + g_hColors.SetString("rare", "\x074B69FF"); + g_hColors.SetString("red", "\x07FF4040"); + g_hColors.SetString("rosybrown", "\x07BC8F8F"); + g_hColors.SetString("royalblue", "\x074169E1"); + g_hColors.SetString("saddlebrown", "\x078B4513"); + g_hColors.SetString("salmon", "\x07FA8072"); + g_hColors.SetString("sandybrown", "\x07F4A460"); + g_hColors.SetString("seagreen", "\x072E8B57"); + g_hColors.SetString("seashell", "\x07FFF5EE"); + g_hColors.SetString("selfmade", "\x0770B04A"); + g_hColors.SetString("sienna", "\x07A0522D"); + g_hColors.SetString("silver", "\x07C0C0C0"); + g_hColors.SetString("skyblue", "\x0787CEEB"); + g_hColors.SetString("slateblue", "\x076A5ACD"); + g_hColors.SetString("slategray", "\x07708090"); + g_hColors.SetString("slategrey", "\x07708090"); + g_hColors.SetString("snow", "\x07FFFAFA"); + g_hColors.SetString("springgreen", "\x0700FF7F"); + g_hColors.SetString("steelblue", "\x074682B4"); + g_hColors.SetString("strange", "\x07CF6A32"); + g_hColors.SetString("tan", "\x07D2B48C"); + g_hColors.SetString("teal", "\x07008080"); + g_hColors.SetString("thistle", "\x07D8BFD8"); + g_hColors.SetString("tomato", "\x07FF6347"); + g_hColors.SetString("turquoise", "\x0740E0D0"); + g_hColors.SetString("uncommon", "\x07B0C3D9"); + g_hColors.SetString("unique", "\x07FFD700"); + g_hColors.SetString("unusual", "\x078650AC"); + g_hColors.SetString("valve", "\x07A50F79"); + g_hColors.SetString("vintage", "\x07476291"); + g_hColors.SetString("violet", "\x07EE82EE"); + g_hColors.SetString("wheat", "\x07F5DEB3"); + g_hColors.SetString("white", "\x07FFFFFF"); + g_hColors.SetString("whitesmoke", "\x07F5F5F5"); + g_hColors.SetString("yellow", "\x07FFFF00"); + g_hColors.SetString("yellowgreen", "\x079ACD32"); + } + else + { + g_hColors.SetString("red", "\x07"); + g_hColors.SetString("lightred", "\x0F"); + g_hColors.SetString("darkred", "\x02"); + g_hColors.SetString("bluegrey", "\x0A"); + g_hColors.SetString("blue", "\x0B"); + g_hColors.SetString("darkblue", "\x0C"); + g_hColors.SetString("purple", "\x03"); + g_hColors.SetString("orchid", "\x0E"); + g_hColors.SetString("yellow", "\x09"); + g_hColors.SetString("gold", "\x10"); + g_hColors.SetString("lightgreen", "\x05"); + g_hColors.SetString("green", "\x04"); + g_hColors.SetString("lime", "\x06"); + g_hColors.SetString("grey", "\x08"); + g_hColors.SetString("grey2", "\x0D"); + } + + g_hColors.SetString("engine 1", "\x01"); + g_hColors.SetString("engine 2", "\x02"); + g_hColors.SetString("engine 3", "\x03"); + g_hColors.SetString("engine 4", "\x04"); + g_hColors.SetString("engine 5", "\x05"); + g_hColors.SetString("engine 6", "\x06"); + g_hColors.SetString("engine 7", "\x07"); + g_hColors.SetString("engine 8", "\x08"); + g_hColors.SetString("engine 9", "\x09"); + g_hColors.SetString("engine 10", "\x0A"); + g_hColors.SetString("engine 11", "\x0B"); + g_hColors.SetString("engine 12", "\x0C"); + g_hColors.SetString("engine 13", "\x0D"); + g_hColors.SetString("engine 14", "\x0E"); + g_hColors.SetString("engine 15", "\x0F"); + g_hColors.SetString("engine 16", "\x10"); +} + +stock bool HasBrackets(const char[] sSource) +{ + return (sSource[0] == '{' && sSource[strlen(sSource) - 1] == '}'); +} + +stock void StringToLower(char[] sSource) +{ + for (int i = 0; i < strlen(sSource); i++) + { + if (sSource[i] == '\0') + break; + + sSource[i] = CharToLower(sSource[i]); + } +} + +stock bool IsSource2009() +{ + EngineVersion iEngineVersion = GetEngineVersion(); + return (iEngineVersion == Engine_CSS || iEngineVersion == Engine_TF2 || iEngineVersion == Engine_HL2DM || iEngineVersion == Engine_DODS); +} + +stock void AddPrefixAndDefaultColor(char[] message, int size, char[] sDefaultColor = "engine 1", char[] sPrefixColor = "engine 2") +{ + if (g_sChatPrefix[0] != '\0' && !g_bIgnorePrefix) + Format(message, size, "{%s}[%s]{%s} %s", sPrefixColor, g_sChatPrefix, sDefaultColor, message); + else + Format(message, size, "{%s}%s", sDefaultColor, message); +} + +stock void SendPlayerMessage(int client, char[] message, int author = 0) +{ + if (author > 0 && author <= MaxClients && IsClientInGame(author)) + CSayText2(client, message, author); + else + PrintToChat(client, message); +}
\ No newline at end of file diff --git a/sourcemod/scripting/include/updater.inc b/sourcemod/scripting/include/updater.inc new file mode 100644 index 0000000..f37bdf2 --- /dev/null +++ b/sourcemod/scripting/include/updater.inc @@ -0,0 +1,97 @@ +#if defined _updater_included + #endinput +#endif +#define _updater_included + +/** + * Adds your plugin to the updater. The URL will be updated if + * your plugin was previously added. + * + * @param url URL to your plugin's update file. + * @noreturn + */ +native Updater_AddPlugin(const String:url[]); + +/** + * Removes your plugin from the updater. This does not need to + * be called during OnPluginEnd. + * + * @noreturn + */ +native Updater_RemovePlugin(); + +/** + * Forces your plugin to be checked for updates. The behaviour + * of the update is dependant on the server's configuration. + * + * @return True if an update was triggered. False otherwise. + * @error Plugin not found in updater. + */ +native bool:Updater_ForceUpdate(); + +/** + * Called when your plugin is about to be checked for updates. + * + * @return Plugin_Handled to prevent checking, Plugin_Continue to allow it. + */ +forward Action:Updater_OnPluginChecking(); + +/** + * Called when your plugin is about to begin downloading an available update. + * + * @return Plugin_Handled to prevent downloading, Plugin_Continue to allow it. + */ +forward Action:Updater_OnPluginDownloading(); + +/** + * Called when your plugin's update files have been fully downloaded + * and are about to write to their proper location. This should be used + * to free read-only resources that require write access for your update. + * + * @note OnPluginUpdated will be called later during the same frame. + * + * @noreturn + */ +forward Updater_OnPluginUpdating(); + +/** + * Called when your plugin's update has been completed. It is safe + * to reload your plugin at this time. + * + * @noreturn + */ +forward Updater_OnPluginUpdated(); + +/** + * @brief Reloads a plugin. + * + * @param plugin Plugin Handle (INVALID_HANDLE uses the calling plugin). + * @noreturn + */ +stock ReloadPlugin(Handle:plugin=INVALID_HANDLE) +{ + decl String:filename[64]; + GetPluginFilename(plugin, filename, sizeof(filename)); + ServerCommand("sm plugins reload %s", filename); +} + + +public SharedPlugin:__pl_updater = +{ + name = "updater", + file = "updater.smx", +#if defined REQUIRE_PLUGIN + required = 1, +#else + required = 0, +#endif +}; + +#if !defined REQUIRE_PLUGIN +public __pl_updater_SetNTVOptional() +{ + MarkNativeAsOptional("Updater_AddPlugin"); + MarkNativeAsOptional("Updater_RemovePlugin"); + MarkNativeAsOptional("Updater_ForceUpdate"); +} +#endif diff --git a/sourcemod/scripting/momsurffix/baseplayer.sp b/sourcemod/scripting/momsurffix/baseplayer.sp new file mode 100644 index 0000000..c638773 --- /dev/null +++ b/sourcemod/scripting/momsurffix/baseplayer.sp @@ -0,0 +1,189 @@ +#define MAX_EDICT_BITS 11 +#define NUM_ENT_ENTRY_BITS (MAX_EDICT_BITS + 1) +#define NUM_ENT_ENTRIES (1 << NUM_ENT_ENTRY_BITS) +#define ENT_ENTRY_MASK (NUM_ENT_ENTRIES - 1) +#define INVALID_EHANDLE_INDEX 0xFFFFFFFF + +enum struct CBasePlayerOffsets +{ + //... + int m_surfaceFriction; + //... + int m_hGroundEntity; + //... + int m_MoveType; + //... +} + +enum struct CBaseHandleOffsets +{ + int m_Index; +} + +enum struct CEntInfoOffsets +{ + int m_pEntity; + int m_SerialNumber; + //... + int size; +} + +enum struct CBaseEntityListOffsets +{ + int m_EntPtrArray; +} + +enum struct BasePlayerOffsets +{ + CBasePlayerOffsets cbpoffsets; + CBaseHandleOffsets cbhoffsets; + CEntInfoOffsets ceioffsets; + CBaseEntityListOffsets cbeloffsets; +} +static BasePlayerOffsets offsets; + +methodmap CBasePlayer < AddressBase +{ + property float m_surfaceFriction + { + public get() { return view_as<float>(LoadFromAddress(this.Address + offsets.cbpoffsets.m_surfaceFriction, NumberType_Int32)); } + } + + //... + + property Address m_hGroundEntity + { + public get() { return view_as<Address>(LoadFromAddress(this.Address + offsets.cbpoffsets.m_hGroundEntity, NumberType_Int32)); } + } + + //... + + property MoveType m_MoveType + { + public get() { return view_as<MoveType>(LoadFromAddress(this.Address + offsets.cbpoffsets.m_MoveType, NumberType_Int8)); } + } +} + +methodmap CBaseEntityList < AddressBase +{ + property PseudoStackArray m_EntPtrArray + { + public get() { return view_as<PseudoStackArray>(LoadFromAddress(this.Address + offsets.cbeloffsets.m_EntPtrArray, NumberType_Int32)); } + } +} + +static CBaseEntityList g_pEntityList; + +methodmap CBaseHandle < AddressBase +{ + property int m_Index + { + public get() { return LoadFromAddress(this.Address + offsets.cbhoffsets.m_Index, NumberType_Int32); } + } + + public CBaseHandle Get() + { + return LookupEntity(this); + } + + public int GetEntryIndex() + { + return + } +} + +methodmap CEntInfo < AddressBase +{ + public static int Size() + { + return offsets.ceioffsets.size; + } + + property CBaseHandle m_pEntity + { + public get() { return view_as<CBaseHandle>(LoadFromAddress(this.Address + offsets.ceioffsets.m_pEntity, NumberType_Int32)); } + } + + property int m_SerialNumber + { + public get() { return LoadFromAddress(this.Address + offsets.ceioffsets.m_SerialNumber, NumberType_Int32); } + } +} + +stock bool InitBasePlayer(GameData gd) +{ + char buff[128]; + bool early = false; + + if(gEngineVersion == Engine_CSS) + { + //g_pEntityList + g_pEntityList = view_as<CBaseEntityList>(gd.GetAddress("g_pEntityList")); + ASSERT_MSG(g_pEntityList.Address != Address_Null, "Can't get \"g_pEntityList\" address from gamedata. Gamedata needs an update."); + + //CBaseEntityList + ASSERT_FMT(gd.GetKeyValue("CBaseEntityList::m_EntPtrArray", buff, sizeof(buff)), "Can't get \"CBaseEntityList::m_EntPtrArray\" offset from gamedata."); + offsets.cbeloffsets.m_EntPtrArray = StringToInt(buff); + + //CEntInfo + ASSERT_FMT(gd.GetKeyValue("CEntInfo::m_pEntity", buff, sizeof(buff)), "Can't get \"CEntInfo::m_pEntity\" offset from gamedata."); + offsets.ceioffsets.m_pEntity = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("CEntInfo::m_SerialNumber", buff, sizeof(buff)), "Can't get \"CEntInfo::m_SerialNumber\" offset from gamedata."); + offsets.ceioffsets.m_SerialNumber = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("CEntInfo::size", buff, sizeof(buff)), "Can't get \"CEntInfo::size\" offset from gamedata."); + offsets.ceioffsets.size = StringToInt(buff); + + //CBaseHandle + ASSERT_FMT(gd.GetKeyValue("CBaseHandle::m_Index", buff, sizeof(buff)), "Can't get \"CBaseHandle::m_Index\" offset from gamedata."); + offsets.cbhoffsets.m_Index = StringToInt(buff); + + //CBasePlayer + ASSERT_FMT(gd.GetKeyValue("CBasePlayer::m_surfaceFriction", buff, sizeof(buff)), "Can't get \"CBasePlayer::m_surfaceFriction\" offset from gamedata."); + int offs = StringToInt(buff); + int prop_offs = FindSendPropInfo("CBasePlayer", "m_szLastPlaceName"); + ASSERT_FMT(prop_offs > 0, "Can't get \"CBasePlayer::m_szLastPlaceName\" offset from FindSendPropInfo()."); + offsets.cbpoffsets.m_surfaceFriction = prop_offs + offs; + } + else if(gEngineVersion == Engine_CSGO) + { + //CBasePlayer + ASSERT_FMT(gd.GetKeyValue("CBasePlayer::m_surfaceFriction", buff, sizeof(buff)), "Can't get \"CBasePlayer::m_surfaceFriction\" offset from gamedata."); + int offs = StringToInt(buff); + int prop_offs = FindSendPropInfo("CBasePlayer", "m_ubEFNoInterpParity"); + ASSERT_FMT(prop_offs > 0, "Can't get \"CBasePlayer::m_ubEFNoInterpParity\" offset from FindSendPropInfo()."); + offsets.cbpoffsets.m_surfaceFriction = prop_offs - offs; + } + + offsets.cbpoffsets.m_hGroundEntity = FindSendPropInfo("CBasePlayer", "m_hGroundEntity"); + ASSERT_FMT(offsets.cbpoffsets.m_hGroundEntity > 0, "Can't get \"CBasePlayer::m_hGroundEntity\" offset from FindSendPropInfo()."); + + if(IsValidEntity(0)) + { + offsets.cbpoffsets.m_MoveType = FindDataMapInfo(0, "m_MoveType"); + ASSERT_FMT(offsets.cbpoffsets.m_MoveType != -1, "Can't get \"CBasePlayer::m_MoveType\" offset from FindDataMapInfo()."); + } + else + early = true; + + return early; +} + +stock void LateInitBasePlayer(GameData gd) +{ + ASSERT(IsValidEntity(0)); + offsets.cbpoffsets.m_MoveType = FindDataMapInfo(0, "m_MoveType"); + ASSERT_FMT(offsets.cbpoffsets.m_MoveType != -1, "Can't get \"CBasePlayer::m_MoveType\" offset from FindDataMapInfo()."); +} + +stock CBaseHandle LookupEntity(CBaseHandle handle) +{ + if(handle.m_Index == INVALID_EHANDLE_INDEX) + return view_as<CBaseHandle>(0); + + CEntInfo pInfo = view_as<CEntInfo>(g_pEntityList.m_EntPtrArray.Get32(handle.m_Index & ENT_ENTRY_MASK, CEntInfo.Size())); + + if(pInfo.m_SerialNumber == (handle.m_Index >> NUM_ENT_ENTRY_BITS)) + return pInfo.m_pEntity; + else + return view_as<CBaseHandle>(0); +}
\ No newline at end of file diff --git a/sourcemod/scripting/momsurffix/gamemovement.sp b/sourcemod/scripting/momsurffix/gamemovement.sp new file mode 100644 index 0000000..a51beeb --- /dev/null +++ b/sourcemod/scripting/momsurffix/gamemovement.sp @@ -0,0 +1,411 @@ +enum struct CGameMovementOffsets +{ + int player; + int mv; + //... + int m_pTraceListData; + int m_nTraceCount; +} + +enum struct CMoveDataOffsets +{ + int m_nPlayerHandle; + //... + int m_vecVelocity; + //... + int m_vecAbsOrigin; +} + +enum struct GameMoventOffsets +{ + CGameMovementOffsets cgmoffsets; + CMoveDataOffsets cmdoffsets; +} +static GameMoventOffsets offsets; + +methodmap CMoveData < AddressBase +{ + property CBaseHandle m_nPlayerHandle + { + public get() { return view_as<CBaseHandle>(this.Address + offsets.cmdoffsets.m_nPlayerHandle); } + } + + //... + + property Vector m_vecVelocity + { + public get() { return view_as<Vector>(this.Address + offsets.cmdoffsets.m_vecVelocity); } + } + + //... + + property Vector m_vecAbsOrigin + { + public get() { return view_as<Vector>(this.Address + offsets.cmdoffsets.m_vecAbsOrigin); } + } +} + +methodmap CGameMovement < AddressBase +{ + property CBasePlayer player + { + public get() { return view_as<CBasePlayer>(LoadFromAddress(this.Address + offsets.cgmoffsets.player, NumberType_Int32)); } + } + + property CMoveData mv + { + public get() { return view_as<CMoveData>(LoadFromAddress(this.Address + offsets.cgmoffsets.mv, NumberType_Int32)); } + } + + //... + + property ITraceListData m_pTraceListData + { + public get() { return view_as<ITraceListData>(LoadFromAddress(this.Address + offsets.cgmoffsets.m_pTraceListData, NumberType_Int32)); } + } + + property int m_nTraceCount + { + public get() { return LoadFromAddress(this.Address + offsets.cgmoffsets.m_nTraceCount, NumberType_Int32); } + public set(int _tracecount) { StoreToAddress(this.Address + offsets.cgmoffsets.m_nTraceCount, _tracecount, NumberType_Int32, false); } + } +} + +static Handle gAddToTouched; + +methodmap IMoveHelper < AddressBase +{ + public bool AddToTouched(CGameTrace trace, Vector vec) + { + return SDKCall(gAddToTouched, this.Address, trace, vec); + } +} + +enum //Collision_Group_t +{ + COLLISION_GROUP_NONE = 0, + COLLISION_GROUP_DEBRIS, // Collides with nothing but world and static stuff + COLLISION_GROUP_DEBRIS_TRIGGER, // Same as debris, but hits triggers + COLLISION_GROUP_INTERACTIVE_DEBRIS, // Collides with everything except other interactive debris or debris + COLLISION_GROUP_INTERACTIVE, // Collides with everything except interactive debris or debris + COLLISION_GROUP_PLAYER, + COLLISION_GROUP_BREAKABLE_GLASS, + COLLISION_GROUP_VEHICLE, + COLLISION_GROUP_PLAYER_MOVEMENT, // For HL2, same as Collision_Group_Player, for + // TF2, this filters out other players and CBaseObjects + COLLISION_GROUP_NPC, // Generic NPC group + COLLISION_GROUP_IN_VEHICLE, // for any entity inside a vehicle + COLLISION_GROUP_WEAPON, // for any weapons that need collision detection + COLLISION_GROUP_VEHICLE_CLIP, // vehicle clip brush to restrict vehicle movement + COLLISION_GROUP_PROJECTILE, // Projectiles! + COLLISION_GROUP_DOOR_BLOCKER, // Blocks entities not permitted to get near moving doors + COLLISION_GROUP_PASSABLE_DOOR, // Doors that the player shouldn't collide with + COLLISION_GROUP_DISSOLVING, // Things that are dissolving are in this group + COLLISION_GROUP_PUSHAWAY, // Nonsolid on client and server, pushaway in player code + + COLLISION_GROUP_NPC_ACTOR, // Used so NPCs in scripts ignore the player. + COLLISION_GROUP_NPC_SCRIPTED, // USed for NPCs in scripts that should not collide with each other + + LAST_SHARED_COLLISION_GROUP +}; + +static Handle gClipVelocity, gLockTraceFilter, gUnlockTraceFilter, gGetPlayerMins, gGetPlayerMaxs, gTracePlayerBBox; +static IMoveHelper sm_pSingleton; + +stock void InitGameMovement(GameData gd) +{ + char buff[128]; + + //CGameMovement + ASSERT_FMT(gd.GetKeyValue("CGameMovement::player", buff, sizeof(buff)), "Can't get \"CGameMovement::player\" offset from gamedata."); + offsets.cgmoffsets.player = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("CGameMovement::mv", buff, sizeof(buff)), "Can't get \"CGameMovement::mv\" offset from gamedata."); + offsets.cgmoffsets.mv = StringToInt(buff); + + if(gEngineVersion == Engine_CSGO) + { + ASSERT_FMT(gd.GetKeyValue("CGameMovement::m_pTraceListData", buff, sizeof(buff)), "Can't get \"CGameMovement::m_pTraceListData\" offset from gamedata."); + offsets.cgmoffsets.m_pTraceListData = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("CGameMovement::m_nTraceCount", buff, sizeof(buff)), "Can't get \"CGameMovement::m_nTraceCount\" offset from gamedata."); + offsets.cgmoffsets.m_nTraceCount = StringToInt(buff); + } + + //CMoveData + if(gEngineVersion == Engine_CSS) + { + ASSERT_FMT(gd.GetKeyValue("CMoveData::m_nPlayerHandle", buff, sizeof(buff)), "Can't get \"CMoveData::m_nPlayerHandle\" offset from gamedata."); + offsets.cmdoffsets.m_nPlayerHandle = StringToInt(buff); + } + + ASSERT_FMT(gd.GetKeyValue("CMoveData::m_vecVelocity", buff, sizeof(buff)), "Can't get \"CMoveData::m_vecVelocity\" offset from gamedata."); + offsets.cmdoffsets.m_vecVelocity = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("CMoveData::m_vecAbsOrigin", buff, sizeof(buff)), "Can't get \"CMoveData::m_vecAbsOrigin\" offset from gamedata."); + offsets.cmdoffsets.m_vecAbsOrigin = StringToInt(buff); + + if(gEngineVersion == Engine_CSGO) + { + //sm_pSingleton + sm_pSingleton = view_as<IMoveHelper>(gd.GetAddress("sm_pSingleton")); + ASSERT_MSG(sm_pSingleton.Address != Address_Null, "Can't get \"sm_pSingleton\" address from gamedata. Gamedata needs an update."); + } + else + { + //sm_pSingleton for late loading + sm_pSingleton = view_as<IMoveHelper>(gd.GetAddress("sm_pSingleton")); + + //CMoveHelperServer::CMoveHelperServer + Handle dhook = DHookCreateDetour(Address_Null, CallConv_CDECL, ReturnType_Int, ThisPointer_Ignore); + ASSERT_MSG(DHookSetFromConf(dhook, gd, SDKConf_Signature, "CMoveHelperServer::CMoveHelperServer"), "Failed to get \"CMoveHelperServer::CMoveHelperServer\" signature. Gamedata needs an update."); + DHookAddParam(dhook, HookParamType_Int); + DHookEnableDetour(dhook, true, CMoveHelperServer_Dhook); + } + + //AddToTouched + StartPrepSDKCall(SDKCall_Raw); + + PrepSDKCall_SetVirtual(gd.GetOffset("AddToTouched")); + + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + + PrepSDKCall_SetReturnInfo(SDKType_Bool, SDKPass_Plain); + + gAddToTouched = EndPrepSDKCall(); + ASSERT(gAddToTouched); + + if(gEngineVersion == Engine_CSGO) + { + //ClipVelocity + StartPrepSDKCall(SDKCall_Raw); + + PrepSDKCall_SetVirtual(gd.GetOffset("ClipVelocity")); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + PrepSDKCall_AddParameter(SDKType_Float, SDKPass_Plain); + + PrepSDKCall_SetReturnInfo(SDKType_PlainOldData, SDKPass_Plain); + + gClipVelocity = EndPrepSDKCall(); + ASSERT(gClipVelocity); + + //LockTraceFilter + StartPrepSDKCall(SDKCall_Raw); + + PrepSDKCall_SetVirtual(gd.GetOffset("LockTraceFilter")); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + + PrepSDKCall_SetReturnInfo(SDKType_PlainOldData, SDKPass_Plain); + + gLockTraceFilter = EndPrepSDKCall(); + ASSERT(gLockTraceFilter); + + //UnlockTraceFilter + StartPrepSDKCall(SDKCall_Raw); + + PrepSDKCall_SetVirtual(gd.GetOffset("UnlockTraceFilter")); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Pointer); + + gUnlockTraceFilter = EndPrepSDKCall(); + ASSERT(gUnlockTraceFilter); + } + else if(gEngineVersion == Engine_CSS && gOSType == OSLinux) + { + //ClipVelocity + StartPrepSDKCall(SDKCall_Static); + + ASSERT_MSG(PrepSDKCall_SetFromConf(gd, SDKConf_Signature, "CGameMovement::ClipVelocity"), "Failed to get \"CGameMovement::ClipVelocity\" signature. Gamedata needs an update."); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + PrepSDKCall_AddParameter(SDKType_Float, SDKPass_Plain); + + PrepSDKCall_SetReturnInfo(SDKType_PlainOldData, SDKPass_Plain); + + gClipVelocity = EndPrepSDKCall(); + ASSERT(gClipVelocity); + } + + if(gEngineVersion == Engine_CSGO || gOSType == OSWindows) + { + //GetPlayerMins + StartPrepSDKCall(SDKCall_Raw); + + PrepSDKCall_SetVirtual(gd.GetOffset("GetPlayerMins")); + + if(gEngineVersion == Engine_CSS) + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + PrepSDKCall_SetReturnInfo(SDKType_PlainOldData, SDKPass_Plain); + + gGetPlayerMins = EndPrepSDKCall(); + ASSERT(gGetPlayerMins); + + //GetPlayerMaxs + StartPrepSDKCall(SDKCall_Raw); + + PrepSDKCall_SetVirtual(gd.GetOffset("GetPlayerMaxs")); + + if(gEngineVersion == Engine_CSS) + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + PrepSDKCall_SetReturnInfo(SDKType_PlainOldData, SDKPass_Plain); + + gGetPlayerMaxs = EndPrepSDKCall(); + ASSERT(gGetPlayerMaxs); + } + else + { + //GetPlayerMins + StartPrepSDKCall(SDKCall_Static); + + ASSERT_MSG(PrepSDKCall_SetFromConf(gd, SDKConf_Signature, "CGameMovement::GetPlayerMins"), "Failed to get \"CGameMovement::GetPlayerMins\" signature. Gamedata needs an update."); + + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + + gGetPlayerMins = EndPrepSDKCall(); + ASSERT(gGetPlayerMins); + + //GetPlayerMaxs + StartPrepSDKCall(SDKCall_Static); + + ASSERT_MSG(PrepSDKCall_SetFromConf(gd, SDKConf_Signature, "CGameMovement::GetPlayerMaxs"), "Failed to get \"CGameMovement::GetPlayerMaxs\" signature. Gamedata needs an update."); + + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + + gGetPlayerMaxs = EndPrepSDKCall(); + ASSERT(gGetPlayerMaxs); + } + + //TracePlayerBBox + StartPrepSDKCall(SDKCall_Raw); + + PrepSDKCall_SetVirtual(gd.GetOffset("TracePlayerBBox")); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + + gTracePlayerBBox = EndPrepSDKCall(); + ASSERT(gTracePlayerBBox); +} + +public MRESReturn CMoveHelperServer_Dhook(Handle hReturn, Handle hParams) +{ + if(sm_pSingleton.Address == Address_Null) + { + if(gOSType == OSLinux) + { + GameData gd = new GameData(GAME_DATA_FILE); + + sm_pSingleton = view_as<IMoveHelper>(gd.GetAddress("sm_pSingleton")); + ASSERT_MSG(sm_pSingleton.Address != Address_Null, "Can't get \"sm_pSingleton\" address from gamedata. Gamedata needs an update."); + + delete gd; + } + else + { + sm_pSingleton = view_as<IMoveHelper>(DHookGetReturn(hReturn)); + ASSERT_MSG(sm_pSingleton.Address != Address_Null, "Can't get \"sm_pSingleton\" address from \"CMoveHelperServer::CMoveHelperServer\" dhook."); + } + } + + return MRES_Ignored; +} + +stock void TracePlayerBBox(CGameMovement pThis, Vector start, Vector end, int mask, int collisionGroup, CGameTrace trace) +{ + SDKCall(gTracePlayerBBox, pThis, start, end, mask, collisionGroup, trace); +} + +stock CTraceFilterSimple LockTraceFilter(CGameMovement pThis, int collisionGroup) +{ + ASSERT(pThis.Address != Address_Null); + return SDKCall(gLockTraceFilter, pThis.Address, collisionGroup); +} + +stock void UnlockTraceFilter(CGameMovement pThis, CTraceFilterSimple filter) +{ + ASSERT(pThis.Address != Address_Null); + SDKCall(gUnlockTraceFilter, pThis.Address, filter.Address); +} + +stock int ClipVelocity(CGameMovement pThis, Vector invec, Vector normal, Vector out, float overbounce) +{ + if(gEngineVersion == Engine_CSGO) + { + ASSERT(pThis.Address != Address_Null); + return SDKCall(gClipVelocity, pThis.Address, invec.Address, normal.Address, out.Address, overbounce); + } + else if (gEngineVersion == Engine_CSS && gOSType == OSLinux) + { + return SDKCall(gClipVelocity, pThis.Address, invec.Address, normal.Address, out.Address, overbounce); + } + else + { + float backoff, angle, adjust; + int blocked; + + angle = normal.z; + + if(angle > 0.0) + blocked |= 0x01; + if(CloseEnoughFloat(angle, 0.0)) + blocked |= 0x02; + + backoff = invec.Dot(VectorToArray(normal)) * overbounce; + + out.x = invec.x - (normal.x * backoff); + out.y = invec.y - (normal.y * backoff); + out.z = invec.z - (normal.z * backoff); + + adjust = out.Dot(VectorToArray(normal)); + if(adjust < 0.0) + { + out.x -= (normal.x * adjust); + out.y -= (normal.y * adjust); + out.z -= (normal.z * adjust); + } + + return blocked; + } +} + +stock Vector GetPlayerMinsCSS(CGameMovement pThis, Vector vec) +{ + if(gOSType == OSLinux) + { + SDKCall(gGetPlayerMins, vec.Address, pThis.Address); + return vec; + } + else + return SDKCall(gGetPlayerMins, pThis.Address, vec.Address); +} + +stock Vector GetPlayerMaxsCSS(CGameMovement pThis, Vector vec) +{ + if(gOSType == OSLinux) + { + SDKCall(gGetPlayerMaxs, vec.Address, pThis.Address); + return vec; + } + else + return SDKCall(gGetPlayerMaxs, pThis.Address, vec.Address); +} + +stock Vector GetPlayerMins(CGameMovement pThis) +{ + return SDKCall(gGetPlayerMins, pThis.Address); +} + +stock Vector GetPlayerMaxs(CGameMovement pThis) +{ + return SDKCall(gGetPlayerMaxs, pThis.Address); +} + +stock IMoveHelper MoveHelper() +{ + return sm_pSingleton; +}
\ No newline at end of file diff --git a/sourcemod/scripting/momsurffix/gametrace.sp b/sourcemod/scripting/momsurffix/gametrace.sp new file mode 100644 index 0000000..e8db1ad --- /dev/null +++ b/sourcemod/scripting/momsurffix/gametrace.sp @@ -0,0 +1,480 @@ +enum struct cplane_tOffsets +{ + int normal; + int dist; + int type; + int signbits; +} + +enum struct csurface_tOffsets +{ + int name; + int surfaceProps; + int flags; +} + +enum struct CGameTraceOffsets +{ + //CBaseTrace + int startpos; + int endpos; + int plane; + int fraction; + int contents; + int dispFlags; + int allsolid; + int startsolid; + //CGameTrace + int fractionleftsolid; + int surface; + int hitgroup; + int physicsbone; + int m_pEnt; + int hitbox; + int size; +} + +enum struct Ray_tOffsets +{ + int m_Start; + int m_Delta; + int m_StartOffset; + int m_Extents; + int m_pWorldAxisTransform; + int m_IsRay; + int m_IsSwept; + int size; +} + +enum struct CTraceFilterSimpleOffsets +{ + int vptr; + int m_pPassEnt; + int m_collisionGroup; + int m_pExtraShouldHitCheckFunction; + int size; + Address vtable; +} + +enum struct GameTraceOffsets +{ + cplane_tOffsets cptoffsets; + csurface_tOffsets cstoffsets; + CGameTraceOffsets cgtoffsets; + Ray_tOffsets rtoffsets; + CTraceFilterSimpleOffsets ctfsoffsets; +} +static GameTraceOffsets offsets; + +methodmap Cplane_t < AddressBase +{ + property Vector normal + { + public get() { return view_as<Vector>(this.Address + offsets.cptoffsets.normal); } + } + + property float dist + { + public get() { return view_as<float>(LoadFromAddress(this.Address + offsets.cptoffsets.dist, NumberType_Int32)); } + } + + property char type + { + public get() { return view_as<char>(LoadFromAddress(this.Address + offsets.cptoffsets.type, NumberType_Int8)); } + } + + property char signbits + { + public get() { return view_as<char>(LoadFromAddress(this.Address + offsets.cptoffsets.signbits, NumberType_Int8)); } + } +} + +methodmap Csurface_t < AddressBase +{ + property Address name + { + public get() { return view_as<Address>(LoadFromAddress(this.Address + offsets.cstoffsets.name, NumberType_Int32)); } + } + + property int surfaceProps + { + public get() { return LoadFromAddress(this.Address + offsets.cstoffsets.surfaceProps, NumberType_Int16); } + } + + property int flags + { + public get() { return LoadFromAddress(this.Address + offsets.cstoffsets.flags, NumberType_Int16); } + } +} + +methodmap CGameTrace < AllocatableBase +{ + public static int Size() + { + return offsets.cgtoffsets.size; + } + + property Vector startpos + { + public get() { return view_as<Vector>(this.Address + offsets.cgtoffsets.startpos); } + } + + property Vector endpos + { + public get() { return view_as<Vector>(this.Address + offsets.cgtoffsets.endpos); } + } + + property Cplane_t plane + { + public get() { return view_as<Cplane_t>(this.Address + offsets.cgtoffsets.plane); } + } + + property float fraction + { + public get() { return view_as<float>(LoadFromAddress(this.Address + offsets.cgtoffsets.fraction, NumberType_Int32)); } + } + + property int contents + { + public get() { return LoadFromAddress(this.Address + offsets.cgtoffsets.contents, NumberType_Int32); } + } + + property int dispFlags + { + public get() { return LoadFromAddress(this.Address + offsets.cgtoffsets.dispFlags, NumberType_Int16); } + } + + property bool allsolid + { + public get() { return view_as<bool>(LoadFromAddress(this.Address + offsets.cgtoffsets.allsolid, NumberType_Int8)); } + } + + property bool startsolid + { + public get() { return view_as<bool>(LoadFromAddress(this.Address + offsets.cgtoffsets.startsolid, NumberType_Int8)); } + } + + property float fractionleftsolid + { + public get() { return view_as<float>(LoadFromAddress(this.Address + offsets.cgtoffsets.fractionleftsolid, NumberType_Int32)); } + } + + property Csurface_t surface + { + public get() { return view_as<Csurface_t>(this.Address + offsets.cgtoffsets.surface); } + } + + property int hitgroup + { + public get() { return LoadFromAddress(this.Address + offsets.cgtoffsets.hitgroup, NumberType_Int32); } + } + + property int physicsbone + { + public get() { return LoadFromAddress(this.Address + offsets.cgtoffsets.physicsbone, NumberType_Int16); } + } + + property Address m_pEnt + { + public get() { return view_as<Address>(LoadFromAddress(this.Address + offsets.cgtoffsets.m_pEnt, NumberType_Int32)); } + } + + property int hitbox + { + public get() { return LoadFromAddress(this.Address + offsets.cgtoffsets.hitbox, NumberType_Int32); } + } + + public CGameTrace() + { + return MALLOC(CGameTrace); + } +} + +methodmap Ray_t < AllocatableBase +{ + public static int Size() + { + return offsets.rtoffsets.size; + } + + property Vector m_Start + { + public get() { return view_as<Vector>(this.Address + offsets.rtoffsets.m_Start); } + } + + property Vector m_Delta + { + public get() { return view_as<Vector>(this.Address + offsets.rtoffsets.m_Delta); } + } + + property Vector m_StartOffset + { + public get() { return view_as<Vector>(this.Address + offsets.rtoffsets.m_StartOffset); } + } + + property Vector m_Extents + { + public get() { return view_as<Vector>(this.Address + offsets.rtoffsets.m_Extents); } + } + + property Address m_pWorldAxisTransform + { + public get() { return view_as<Address>(LoadFromAddress(this.Address + offsets.rtoffsets.m_pWorldAxisTransform, NumberType_Int32)); } + public set(Address _worldaxistransform) { StoreToAddress(this.Address + offsets.rtoffsets.m_pWorldAxisTransform, view_as<int>(_worldaxistransform), NumberType_Int32, false); } + } + + property bool m_IsRay + { + public get() { return view_as<bool>(LoadFromAddress(this.Address + offsets.rtoffsets.m_IsRay, NumberType_Int8)); } + public set(bool _isray) { StoreToAddress(this.Address + offsets.rtoffsets.m_IsRay, _isray, NumberType_Int8, false); } + } + + property bool m_IsSwept + { + public get() { return view_as<bool>(LoadFromAddress(this.Address + offsets.rtoffsets.m_IsSwept, NumberType_Int8)); } + public set(bool _isswept) { StoreToAddress(this.Address + offsets.rtoffsets.m_IsSwept, _isswept, NumberType_Int8, false); } + } + + public Ray_t() + { + return MALLOC(Ray_t); + } + + //That function is quite heavy, linux builds have it inlined, so can't use it! + //Replacing this function with lighter alternative may increase speed by ~4 times! + //From my testings the main performance killer here is StoreToAddress().... + public void Init(float start[3], float end[3], float mins[3], float maxs[3]) + { + float buff[3], buff2[3]; + + SubtractVectors(end, start, buff); + this.m_Delta.FromArray(buff); + + if(gEngineVersion == Engine_CSGO) + this.m_pWorldAxisTransform = Address_Null; + this.m_IsSwept = (this.m_Delta.LengthSqr() != 0.0); + + SubtractVectors(maxs, mins, buff); + ScaleVector(buff, 0.5); + this.m_Extents.FromArray(buff); + + this.m_IsRay = (this.m_Extents.LengthSqr() < 1.0e-6); + + AddVectors(mins, maxs, buff); + ScaleVector(buff, 0.5); + AddVectors(start, buff, buff2); + this.m_Start.FromArray(buff2); + NegateVector(buff); + this.m_StartOffset.FromArray(buff); + } +} + +methodmap CTraceFilterSimple < AllocatableBase +{ + public static int Size() + { + return offsets.ctfsoffsets.size; + } + + property Address vptr + { + public get() { return view_as<Address>(LoadFromAddress(this.Address + offsets.ctfsoffsets.vptr, NumberType_Int32)); } + public set(Address _vtbladdr) { StoreToAddress(this.Address + offsets.ctfsoffsets.vptr, view_as<int>(_vtbladdr), NumberType_Int32, false); } + } + + property CBaseHandle m_pPassEnt + { + public get() { return view_as<CBaseHandle>(LoadFromAddress(this.Address + offsets.ctfsoffsets.m_pPassEnt, NumberType_Int32)); } + public set(CBaseHandle _passent) { StoreToAddress(this.Address + offsets.ctfsoffsets.m_pPassEnt, view_as<int>(_passent), NumberType_Int32, false); } + } + + property int m_collisionGroup + { + public get() { return LoadFromAddress(this.Address + offsets.ctfsoffsets.m_collisionGroup, NumberType_Int32); } + public set(int _collisiongroup) { StoreToAddress(this.Address + offsets.ctfsoffsets.m_collisionGroup, _collisiongroup, NumberType_Int32, false); } + } + + property Address m_pExtraShouldHitCheckFunction + { + public get() { return view_as<Address>(LoadFromAddress(this.Address + offsets.ctfsoffsets.m_pExtraShouldHitCheckFunction, NumberType_Int32)); } + public set(Address _checkfnc) { StoreToAddress(this.Address + offsets.ctfsoffsets.m_pExtraShouldHitCheckFunction, view_as<int>(_checkfnc), NumberType_Int32, false); } + } + + public CTraceFilterSimple() + { + CTraceFilterSimple addr = MALLOC(CTraceFilterSimple); + addr.vptr = offsets.ctfsoffsets.vtable; + return addr; + } + + public void Init(CBaseHandle passentity, int collisionGroup, Address pExtraShouldHitCheckFn = Address_Null) + { + this.m_pPassEnt = passentity; + this.m_collisionGroup = collisionGroup; + this.m_pExtraShouldHitCheckFunction = pExtraShouldHitCheckFn; + } +} + +static Handle gCanTraceRay; + +methodmap ITraceListData < AddressBase +{ + public bool CanTraceRay(Ray_t ray) + { + return SDKCall(gCanTraceRay, this.Address, ray.Address); + } +} + +static Handle gTraceRay, gTraceRayAgainstLeafAndEntityList; +static Address gEngineTrace; + +stock void InitGameTrace(GameData gd) +{ + char buff[128]; + + //cplane_t + ASSERT_FMT(gd.GetKeyValue("cplane_t::normal", buff, sizeof(buff)), "Can't get \"cplane_t::normal\" offset from gamedata."); + offsets.cptoffsets.normal = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("cplane_t::dist", buff, sizeof(buff)), "Can't get \"cplane_t::dist\" offset from gamedata."); + offsets.cptoffsets.dist = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("cplane_t::type", buff, sizeof(buff)), "Can't get \"cplane_t::type\" offset from gamedata."); + offsets.cptoffsets.type = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("cplane_t::signbits", buff, sizeof(buff)), "Can't get \"cplane_t::signbits\" offset from gamedata."); + offsets.cptoffsets.signbits = StringToInt(buff); + + //csurface_t + ASSERT_FMT(gd.GetKeyValue("csurface_t::name", buff, sizeof(buff)), "Can't get \"csurface_t::name\" offset from gamedata."); + offsets.cstoffsets.name = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("csurface_t::surfaceProps", buff, sizeof(buff)), "Can't get \"csurface_t::surfaceProps\" offset from gamedata."); + offsets.cstoffsets.surfaceProps = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("csurface_t::flags", buff, sizeof(buff)), "Can't get \"csurface_t::flags\" offset from gamedata."); + offsets.cstoffsets.flags = StringToInt(buff); + + //CGameTrace + ASSERT_FMT(gd.GetKeyValue("CGameTrace::startpos", buff, sizeof(buff)), "Can't get \"CGameTrace::startpos\" offset from gamedata."); + offsets.cgtoffsets.startpos = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("CGameTrace::endpos", buff, sizeof(buff)), "Can't get \"CGameTrace::endpos\" offset from gamedata."); + offsets.cgtoffsets.endpos = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("CGameTrace::plane", buff, sizeof(buff)), "Can't get \"CGameTrace::plane\" offset from gamedata."); + offsets.cgtoffsets.plane = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("CGameTrace::fraction", buff, sizeof(buff)), "Can't get \"CGameTrace::fraction\" offset from gamedata."); + offsets.cgtoffsets.fraction = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("CGameTrace::contents", buff, sizeof(buff)), "Can't get \"CGameTrace::contents\" offset from gamedata."); + offsets.cgtoffsets.contents = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("CGameTrace::dispFlags", buff, sizeof(buff)), "Can't get \"CGameTrace::dispFlags\" offset from gamedata."); + offsets.cgtoffsets.dispFlags = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("CGameTrace::allsolid", buff, sizeof(buff)), "Can't get \"CGameTrace::allsolid\" offset from gamedata."); + offsets.cgtoffsets.allsolid = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("CGameTrace::startsolid", buff, sizeof(buff)), "Can't get \"CGameTrace::startsolid\" offset from gamedata."); + offsets.cgtoffsets.startsolid = StringToInt(buff); + + ASSERT_FMT(gd.GetKeyValue("CGameTrace::fractionleftsolid", buff, sizeof(buff)), "Can't get \"CGameTrace::fractionleftsolid\" offset from gamedata."); + offsets.cgtoffsets.fractionleftsolid = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("CGameTrace::surface", buff, sizeof(buff)), "Can't get \"CGameTrace::surface\" offset from gamedata."); + offsets.cgtoffsets.surface = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("CGameTrace::hitgroup", buff, sizeof(buff)), "Can't get \"CGameTrace::hitgroup\" offset from gamedata."); + offsets.cgtoffsets.hitgroup = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("CGameTrace::physicsbone", buff, sizeof(buff)), "Can't get \"CGameTrace::physicsbone\" offset from gamedata."); + offsets.cgtoffsets.physicsbone = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("CGameTrace::m_pEnt", buff, sizeof(buff)), "Can't get \"CGameTrace::m_pEnt\" offset from gamedata."); + offsets.cgtoffsets.m_pEnt = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("CGameTrace::hitbox", buff, sizeof(buff)), "Can't get \"CGameTrace::hitbox\" offset from gamedata."); + offsets.cgtoffsets.hitbox = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("CGameTrace::size", buff, sizeof(buff)), "Can't get \"CGameTrace::size\" offset from gamedata."); + offsets.cgtoffsets.size = StringToInt(buff); + + //Ray_t + ASSERT_FMT(gd.GetKeyValue("Ray_t::m_Start", buff, sizeof(buff)), "Can't get \"Ray_t::m_Start\" offset from gamedata."); + offsets.rtoffsets.m_Start = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("Ray_t::m_Delta", buff, sizeof(buff)), "Can't get \"Ray_t::m_Delta\" offset from gamedata."); + offsets.rtoffsets.m_Delta = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("Ray_t::m_StartOffset", buff, sizeof(buff)), "Can't get \"Ray_t::m_StartOffset\" offset from gamedata."); + offsets.rtoffsets.m_StartOffset = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("Ray_t::m_Extents", buff, sizeof(buff)), "Can't get \"Ray_t::m_Extents\" offset from gamedata."); + offsets.rtoffsets.m_Extents = StringToInt(buff); + + if(gEngineVersion == Engine_CSGO) + { + ASSERT_FMT(gd.GetKeyValue("Ray_t::m_pWorldAxisTransform", buff, sizeof(buff)), "Can't get \"Ray_t::m_pWorldAxisTransform\" offset from gamedata."); + offsets.rtoffsets.m_pWorldAxisTransform = StringToInt(buff); + } + + ASSERT_FMT(gd.GetKeyValue("Ray_t::m_IsRay", buff, sizeof(buff)), "Can't get \"Ray_t::m_IsRay\" offset from gamedata."); + offsets.rtoffsets.m_IsRay = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("Ray_t::m_IsSwept", buff, sizeof(buff)), "Can't get \"Ray_t::m_IsSwept\" offset from gamedata."); + offsets.rtoffsets.m_IsSwept = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("Ray_t::size", buff, sizeof(buff)), "Can't get \"Ray_t::size\" offset from gamedata."); + offsets.rtoffsets.size = StringToInt(buff); + + //CTraceFilterSimple + ASSERT_FMT(gd.GetKeyValue("CTraceFilterSimple::vptr", buff, sizeof(buff)), "Can't get \"CTraceFilterSimple::vptr\" offset from gamedata."); + offsets.ctfsoffsets.vptr = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("CTraceFilterSimple::m_pPassEnt", buff, sizeof(buff)), "Can't get \"CTraceFilterSimple::m_pPassEnt\" offset from gamedata."); + offsets.ctfsoffsets.m_pPassEnt = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("CTraceFilterSimple::m_collisionGroup", buff, sizeof(buff)), "Can't get \"CTraceFilterSimple::m_collisionGroup\" offset from gamedata."); + offsets.ctfsoffsets.m_collisionGroup = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("CTraceFilterSimple::m_pExtraShouldHitCheckFunction", buff, sizeof(buff)), "Can't get \"CTraceFilterSimple::m_pExtraShouldHitCheckFunction\" offset from gamedata."); + offsets.ctfsoffsets.m_pExtraShouldHitCheckFunction = StringToInt(buff); + ASSERT_FMT(gd.GetKeyValue("CTraceFilterSimple::size", buff, sizeof(buff)), "Can't get \"CTraceFilterSimple::size\" offset from gamedata."); + offsets.ctfsoffsets.size = StringToInt(buff); + + if(gEngineVersion == Engine_CSS) + { + offsets.ctfsoffsets.vtable = gd.GetAddress("CTraceFilterSimple::vtable"); + ASSERT_MSG(offsets.ctfsoffsets.vtable != Address_Null, "Can't get \"CTraceFilterSimple::vtable\" address from gamedata. Gamedata needs an update."); + } + + //enginetrace + gd.GetKeyValue("CEngineTrace", buff, sizeof(buff)); + gEngineTrace = CreateInterface(buff); + ASSERT_MSG(gEngineTrace != Address_Null, "Can't create \"enginetrace\" from CreateInterface()."); + + //RayTrace + StartPrepSDKCall(SDKCall_Raw); + + PrepSDKCall_SetVirtual(gd.GetOffset("TraceRay")); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + + gTraceRay = EndPrepSDKCall(); + ASSERT(gTraceRay); + + if(gEngineVersion == Engine_CSGO) + { + //TraceRayAgainstLeafAndEntityList + StartPrepSDKCall(SDKCall_Raw); + + PrepSDKCall_SetVirtual(gd.GetOffset("TraceRayAgainstLeafAndEntityList")); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + + gTraceRayAgainstLeafAndEntityList = EndPrepSDKCall(); + ASSERT(gTraceRayAgainstLeafAndEntityList); + + //CanTraceRay + StartPrepSDKCall(SDKCall_Raw); + + PrepSDKCall_SetVirtual(gd.GetOffset("CanTraceRay")); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + + PrepSDKCall_SetReturnInfo(SDKType_Bool, SDKPass_Plain); + + gCanTraceRay = EndPrepSDKCall(); + ASSERT(gCanTraceRay); + } +} + +stock void TraceRayAgainstLeafAndEntityList(Ray_t ray, ITraceListData traceData, int mask, CTraceFilterSimple filter, CGameTrace trace) +{ + SDKCall(gTraceRayAgainstLeafAndEntityList, gEngineTrace, ray.Address, traceData.Address, mask, filter.Address, trace.Address); +} + +stock void TraceRay(Ray_t ray, int mask, CTraceFilterSimple filter, CGameTrace trace) +{ + SDKCall(gTraceRay, gEngineTrace, ray.Address, mask, filter.Address, trace.Address); +} diff --git a/sourcemod/scripting/momsurffix/utils.sp b/sourcemod/scripting/momsurffix/utils.sp new file mode 100644 index 0000000..e68e342 --- /dev/null +++ b/sourcemod/scripting/momsurffix/utils.sp @@ -0,0 +1,279 @@ +#define MALLOC(%1) view_as<%1>(AllocatableBase._malloc(%1.Size(), #%1)) +#define MEMORYPOOL_NAME_MAX 128 + +enum struct MemoryPoolEntry +{ + Address addr; + char name[MEMORYPOOL_NAME_MAX]; +} + +methodmap AllocatableBase < AddressBase +{ + public static Address _malloc(int size, const char[] name) + { + Address addr = Malloc(size, name); + + return addr; + } + + public void Free() + { + Free(this.Address); + } +} + +methodmap PseudoStackArray < AddressBase +{ + public Address Get8(int idx, int size = 4) + { + ASSERT(idx >= 0); + ASSERT(size > 0); + + return view_as<Address>(LoadFromAddress(this.Address + (idx * size), NumberType_Int8)); + } + + public Address Get16(int idx, int size = 4) + { + ASSERT(idx >= 0); + ASSERT(size > 0); + + return view_as<Address>(LoadFromAddress(this.Address + (idx * size), NumberType_Int16)); + } + + public Address Get32(int idx, int size = 4) + { + ASSERT(idx >= 0); + ASSERT(size > 0); + + return this.Address + (idx * size); + } +} + +methodmap Vector < AllocatableBase +{ + public static int Size() + { + return 12; + } + + public Vector() + { + return MALLOC(Vector); + } + + property float x + { + public set(float _x) { StoreToAddress(this.Address, view_as<int>(_x), NumberType_Int32, false); } + public get() { return view_as<float>(LoadFromAddress(this.Address, NumberType_Int32)); } + } + + property float y + { + public set(float _y) { StoreToAddress(this.Address + 4, view_as<int>(_y), NumberType_Int32, false); } + public get() { return view_as<float>(LoadFromAddress(this.Address + 4, NumberType_Int32)); } + } + + property float z + { + public set(float _z) { StoreToAddress(this.Address + 8, view_as<int>(_z), NumberType_Int32, false); } + public get() { return view_as<float>(LoadFromAddress(this.Address + 8, NumberType_Int32)); } + } + + public void ToArray(float buff[3]) + { + buff[0] = this.x; + buff[1] = this.y; + buff[2] = this.z; + } + + public void FromArray(float buff[3]) + { + this.x = buff[0]; + this.y = buff[1]; + this.z = buff[2]; + } + + public void CopyTo(Vector dst) + { + dst.x = this.x; + dst.y = this.y; + dst.z = this.z; + } + + public float LengthSqr() + { + return this.x*this.x + this.y*this.y + this.z*this.z; + } + + public float Length() + { + return SquareRoot(this.LengthSqr()); + } + + public float Dot(float vec[3]) + { + return this.x*vec[0] + this.y*vec[1] + this.z*vec[2]; + } +} + +static Address g_pMemAlloc; +static Handle gMalloc, gFree, gCreateInterface; +static ArrayList gMemoryPool; + +stock void InitUtils(GameData gd) +{ + gMemoryPool = new ArrayList(sizeof(MemoryPoolEntry)); + + //CreateInterface + StartPrepSDKCall(SDKCall_Static); + + ASSERT_MSG(PrepSDKCall_SetFromConf(gd, SDKConf_Signature, "CreateInterface"), "Failed to get \"CreateInterface\" signature. Gamedata needs an update."); + + PrepSDKCall_AddParameter(SDKType_String, SDKPass_Pointer); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + + PrepSDKCall_SetReturnInfo(SDKType_PlainOldData, SDKPass_Plain); + + gCreateInterface = EndPrepSDKCall(); + ASSERT(gCreateInterface); + + if(gEngineVersion == Engine_CSGO || gOSType == OSWindows) + { + //g_pMemAlloc + g_pMemAlloc = gd.GetAddress("g_pMemAlloc"); + ASSERT_MSG(g_pMemAlloc != Address_Null, "Can't get \"g_pMemAlloc\" address from gamedata. Gamedata needs an update."); + + //Malloc + StartPrepSDKCall(SDKCall_Raw); + + PrepSDKCall_SetVirtual(gd.GetOffset("Malloc")); + + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + PrepSDKCall_SetReturnInfo(SDKType_PlainOldData, SDKPass_Plain); + + gMalloc = EndPrepSDKCall(); + ASSERT(gMalloc); + + //Free + StartPrepSDKCall(SDKCall_Raw); + + PrepSDKCall_SetVirtual(gd.GetOffset("Free")); + + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + + gFree = EndPrepSDKCall(); + ASSERT(gFree); + } + else + { + //Malloc + StartPrepSDKCall(SDKCall_Static); + ASSERT_MSG(PrepSDKCall_SetFromConf(gd, SDKConf_Signature, "malloc"), "Failed to get \"malloc\" signature. Gamedata needs an update."); + + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + + PrepSDKCall_SetReturnInfo(SDKType_PlainOldData, SDKPass_Plain); + + gMalloc = EndPrepSDKCall(); + ASSERT(gMalloc); + + //Free + StartPrepSDKCall(SDKCall_Static); + ASSERT_MSG(PrepSDKCall_SetFromConf(gd, SDKConf_Signature, "free"), "Failed to get \"free\" signature. Gamedata needs an update."); + + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain); + + gFree = EndPrepSDKCall(); + ASSERT(gFree); + } +} + +stock Address CreateInterface(const char[] name) +{ + return SDKCall(gCreateInterface, name, 0); +} + +stock Address Malloc(int size, const char[] name) +{ + ASSERT(gMemoryPool); + ASSERT(size > 0); + + MemoryPoolEntry entry; + strcopy(entry.name, sizeof(MemoryPoolEntry::name), name); + + if(gEngineVersion == Engine_CSS && gOSType == OSLinux) + entry.addr = SDKCall(gMalloc, 0, size); + else + entry.addr = SDKCall(gMalloc, g_pMemAlloc, size); + + ASSERT_FMT(entry.addr != Address_Null, "Failed to allocate memory (size: %i)!", size); + gMemoryPool.PushArray(entry); + + return entry.addr; +} + +stock void Free(Address addr) +{ + ASSERT(addr != Address_Null); + ASSERT(gMemoryPool); + int idx = gMemoryPool.FindValue(addr, MemoryPoolEntry::addr); + + //Memory wasn't allocated by this plugin, return. + if(idx == -1) + return; + + gMemoryPool.Erase(idx); + + if(gEngineVersion == Engine_CSS && gOSType == OSLinux) + SDKCall(gFree, 0, addr); + else + SDKCall(gFree, g_pMemAlloc, addr); +} + +stock void AddToMemoryPool(Address addr, const char[] name) +{ + ASSERT(addr != Address_Null); + ASSERT(gMemoryPool); + + MemoryPoolEntry entry; + strcopy(entry.name, sizeof(MemoryPoolEntry::name), name); + entry.addr = addr; + + gMemoryPool.PushArray(entry); +} + +stock void CleanUpUtils() +{ + if(!gMemoryPool) + return; + + MemoryPoolEntry entry; + + for(int i = 0; i < gMemoryPool.Length; i++) + { + gMemoryPool.GetArray(i, entry, sizeof(MemoryPoolEntry)); + view_as<AllocatableBase>(entry.addr).Free(); + } + + delete gMemoryPool; +} + +stock void DumpMemoryUsage() +{ + if(!gMemoryPool || (gMemoryPool && gMemoryPool.Length == 0)) + { + PrintToServer(SNAME..."Theres's currently no active pool or it's empty!"); + return; + } + + MemoryPoolEntry entry; + + PrintToServer(SNAME..."Active memory pool (%i):", gMemoryPool.Length); + for(int i = 0; i < gMemoryPool.Length; i++) + { + gMemoryPool.GetArray(i, entry, sizeof(MemoryPoolEntry)); + PrintToServer(SNAME..."[%i]: 0x%08X \"%s\"", i, entry.addr, entry.name); + } +}
\ No newline at end of file |