diff --git a/data/scripts/mp/gametypes/_serversettings.gsc b/data/scripts/mp/gametypes/_serversettings.gsc index 0105b093..bf3985aa 100644 Binary files a/data/scripts/mp/gametypes/_serversettings.gsc and b/data/scripts/mp/gametypes/_serversettings.gsc differ diff --git a/data/scripts/mp/gametypes/_serversettings.gsc_raw b/data/scripts/mp/gametypes/_serversettings.gsc_raw index 580e2966..e420ca3c 100644 --- a/data/scripts/mp/gametypes/_serversettings.gsc_raw +++ b/data/scripts/mp/gametypes/_serversettings.gsc_raw @@ -3,11 +3,9 @@ #using scripts\shared\callbacks_shared; #using scripts\shared\system_shared; -#insert scripts\shared\shared.gsh; - #namespace serversettings; -REGISTER_SYSTEM( "serversettings", &__init__, undefined ) +function autoexec __init__sytem__() { system::register("serversettings",&__init__,undefined,undefined); } function __init__() { @@ -17,36 +15,33 @@ function __init__() function init() { level.hostname = GetDvarString( "sv_hostname"); - if (level.hostname == "") - { + if(level.hostname == "") level.hostname = "CoDHost"; - } - SetDvar("sv_hostname", level.hostname); SetDvar("ui_hostname", level.hostname); + //makeDvarServerInfo("ui_hostname", "CoDHost"); level.motd = GetDvarString( "scr_motd" ); if(level.motd == "") - { level.motd = ""; - } SetDvar("scr_motd", level.motd); SetDvar("ui_motd", level.motd); + //makeDvarServerInfo("ui_motd", ""); level.allowvote = GetDvarString( "g_allowvote" ); if(level.allowvote == "") - { level.allowvote = "1"; - } SetDvar("g_allowvote", level.allowvote); SetDvar("ui_allowvote", level.allowvote); - + //makeDvarServerInfo("ui_allowvote", "1"); + level.allow_teamchange = "1"; SetDvar("ui_allow_teamchange", level.allow_teamchange); level.friendlyfire = GetGametypeSetting( "friendlyfiretype" ); SetDvar("ui_friendlyfire", level.friendlyfire); + //makeDvarServerInfo("ui_friendlyfire", "0"); if(GetDvarString( "scr_mapsize") == "") SetDvar("scr_mapsize", "64"); @@ -62,7 +57,7 @@ function init() constrain_gametype(GetDvarString( "g_gametype")); constrain_map_size(level.mapsize); - + thread setup_callbacks(); for(;;) @@ -88,7 +83,7 @@ function update() SetDvar("ui_motd", level.motd); } - g_allowvote = GetDvarString( "g_allowvote"); + g_allowvote = GetDvarString( "g_allowvote" ); if(level.allowvote != g_allowvote) { level.allowvote = g_allowvote; @@ -211,4 +206,4 @@ function setup_callbacks() function default_onForfeit() { level.gameForfeited = false; -} +} \ No newline at end of file diff --git a/data/ui_scripts/frontend_menus/__init__.lua b/data/ui_scripts/frontend_menus/__init__.lua index 836045e8..7ee38ff2 100644 --- a/data/ui_scripts/frontend_menus/__init__.lua +++ b/data/ui_scripts/frontend_menus/__init__.lua @@ -2,9 +2,28 @@ if Engine.GetCurrentMap() ~= "core_frontend" then return end -local utils = require("utils") +local enableLobbyMapVote = true -- toggle map vote in public lobby +local enableLargeServerBrowserButton = true -- toggle large server browser button -CoD.LobbyButtons.MP_STATS = { +local utils = require("utils") +require("datasources_start_menu_tabs") +require("datasources_change_map_categories") +require("datasources_gamesettingsflyout_buttons") + +CoD.LobbyButtons.MP_PUBLIC_MATCH = { + stringRef = "MENU_PLAY_CAPS", + action = NavigateToLobby_SelectionList, + param = "MPLobbyOnline", + customId = "btnPublicMatch", +} + +CoD.LobbyButtons.MP_FIND_MATCH = { + stringRef = "MPUI_BASICTRAINING_CAPS", + action = OpenFindMatch, + customId = "btnFindMatch", +} + +CoD.LobbyButtons.STATS = { stringRef = "STATS", action = function(self, element, controller, param, menu) SetPerControllerTableProperty(controller, "disableGameSettingsOptions", true) @@ -31,17 +50,48 @@ CoD.LobbyButtons.SETTING_UP_BOTS = { customId = "btnSettingUpBots" } -CoD.LobbyButtons.MP_CUSTOM_SETUP_GAME = { +CoD.LobbyButtons.GameSettingsFlyoutArenas = { stringRef = "MPUI_SETUP_GAME_CAPS", - action = OpenSetupGameMP, - customId = "btnSetupGame", + action = function(self, element, controller, param, menu) + SetPerControllerTableProperty(controller, "disableGameSettingsOptions", true) + OpenPopup(menu, "GameSettingsFlyoutMP", controller) + end, + customId = "btnGameSettingsFlyoutMP" } -local shouldShowMapVote = false +CoD.LobbyButtons.GameSettingsFlyoutMP = { + stringRef = "MPUI_SETUP_GAME_CAPS", + action = function(self, element, controller, param, menu) + SetPerControllerTableProperty(controller, "disableGameSettingsOptions", true) + OpenPopup(menu, "GameSettingsFlyoutMPCustom", controller) + end, + customId = "btnGameSettingsFlyoutMPCustom" +} + +CoD.LobbyButtons.SERVER_BROWSER = { + stringRef = "MENU_SERVER_BROWSER_CAPS", + action = function(self, element, controller, param, menu) + SetPerControllerTableProperty(controller, "disableGameSettingsOptions", true) + OpenPopup(menu, "LobbyServerBrowserOnline", controller) + end, + customId = "btnDedicated" +} + +local shouldShowMapVote = enableLobbyMapVote +local lobbyMapVote = function(lobbyMapVoteIsEnabled) + if lobbyMapVoteIsEnabled == true then + Engine.Exec(nil, "LobbyStopDemo") + end +end + local addCustomButtons = function(controller, menuId, buttonTable, isLeader) + if menuId == LobbyData.UITargets.UI_MPLOBBYMAIN.id then + utils.RemoveSpaces(buttonTable) + utils.AddSpacer(buttonTable, utils.GetButtonIndex(buttonTable, CoD.LobbyButtons.THEATER_MP) - 1) + end + if menuId == LobbyData.UITargets.UI_MPLOBBYONLINE.id or menuId == LobbyData.UITargets.UI_ZMLOBBYONLINE.id then - utils.AddSpacer(buttonTable) - utils.AddSmallButton(controller, buttonTable, CoD.LobbyButtons.MP_STATS) + utils.AddSmallButton(controller, buttonTable, CoD.LobbyButtons.STATS) end if menuId == LobbyData.UITargets.UI_MPLOBBYONLINE.id or menuId == LobbyData.UITargets.UI_ZMLOBBYONLINE.id or menuId == LobbyData.UITargets.UI_MPLOBBYMAIN.id or menuId == LobbyData.UITargets.UI_MPLOBBYLANGAME.id then @@ -49,21 +99,34 @@ local addCustomButtons = function(controller, menuId, buttonTable, isLeader) end if menuId == LobbyData.UITargets.UI_MPLOBBYONLINE.id then - shouldShowMapVote = true - elseif menuId == LobbyData.UITargets.UI_MPLOBBYONLINEPUBLICGAME.id then - if shouldShowMapVote == true then - shouldShowMapVote = false - --Enable map vote at start lobby - Engine.Exec(nil, "LobbyStopDemo") + shouldShowMapVote = enableLobbyMapVote + if enableLargeServerBrowserButton then + utils.AddLargeButton(controller, buttonTable, CoD.LobbyButtons.SERVER_BROWSER, 1) end - utils.AddLargeButton(controller, buttonTable, CoD.LobbyButtons.MP_START_GAME, 1) --Launch match button - utils.AddSpacer(buttonTable, 1) + elseif menuId == LobbyData.UITargets.UI_MPLOBBYONLINEPUBLICGAME.id then + utils.RemoveButton(buttonTable, CoD.LobbyButtons.MP_PUBLIC_LOBBY_LEADERBOARD) - utils.AddSpacer(buttonTable) - utils.AddSmallButton(controller, buttonTable, CoD.LobbyButtons.MP_CUSTOM_SETUP_GAME) --Setup game in public lobby + utils.AddLargeButton(controller, buttonTable, CoD.LobbyButtons.MP_START_GAME, 1) + utils.AddSmallButton(controller, buttonTable, CoD.LobbyButtons.GameSettingsFlyoutMP, 2) + utils.AddSpacer(buttonTable, utils.GetButtonIndex(buttonTable, CoD.LobbyButtons.GameSettingsFlyoutMP)) + + lobbyMapVote(shouldShowMapVote) + shouldShowMapVote = false elseif menuId == LobbyData.UITargets.UI_MPLOBBYONLINEARENAGAME.id then - utils.AddSpacer(buttonTable) - utils.AddSmallButton(controller, buttonTable, CoD.LobbyButtons.SETTING_UP_BOTS) --Bot setting button in public lobby + utils.AddLargeButton(controller, buttonTable, CoD.LobbyButtons.MP_START_GAME, 1) + utils.AddSmallButton(controller, buttonTable, CoD.LobbyButtons.GameSettingsFlyoutArenas, 2) + + utils.AddSpacer(buttonTable, utils.GetButtonIndex(buttonTable, CoD.LobbyButtons.GameSettingsFlyoutArenas)) + end + + if menuId == LobbyData.UITargets.UI_ZMLOBBYONLINE.id then + utils.RemoveButton(buttonTable, CoD.LobbyButtons.THEATER_ZM) + utils.AddLargeButton(controller, buttonTable, CoD.LobbyButtons.THEATER_ZM, #buttonTable + 1) + + utils.RemoveSpaces(buttonTable) + utils.AddSpacer(buttonTable, utils.GetButtonIndex(buttonTable, CoD.LobbyButtons.SERVER_BROWSER)) + utils.AddSpacer(buttonTable, utils.GetButtonIndex(buttonTable, CoD.LobbyButtons.ZM_BUBBLEGUM_BUFFS) - 1) + utils.AddSpacer(buttonTable, utils.GetButtonIndex(buttonTable, CoD.LobbyButtons.STATS)) end end diff --git a/data/ui_scripts/frontend_menus/datasources_change_map_categories.lua b/data/ui_scripts/frontend_menus/datasources_change_map_categories.lua new file mode 100644 index 00000000..468c6bfe --- /dev/null +++ b/data/ui_scripts/frontend_menus/datasources_change_map_categories.lua @@ -0,0 +1,96 @@ +local f0_local0 = function(f1_arg0, f1_arg1) + if not CoD.useMouse then + return + else + LUI.OverrideFunction_CallOriginalFirst(f1_arg0, "setState", function(element, controller) + if IsSelfInState(f1_arg0, "SelectingMap") then + f1_arg0.mapList:setMouseDisabled(false) + f1_arg0.mapCategoriesList:setMouseDisabled(true) + f1_arg0.m_categorySet = false + else + f1_arg0.mapList:setMouseDisabled(true) + f1_arg0.mapCategoriesList:setMouseDisabled(false) + end + end) + f1_arg0.mapList:setMouseDisabled(true) + f1_arg0.mapList:registerEventHandler("leftclick_outside", function(element, event) + if IsSelfInState(f1_arg0, "SelectingMap") and f1_arg0.m_categorySet then + CoD.PCUtil.SimulateButtonPress(f1_arg1, Enum.LUIButton.LUI_KEY_XBB_PSCIRCLE) + end + f1_arg0.m_categorySet = true + return true + end) + end +end + +local PostLoadFunc = function(f4_arg0, f4_arg1) + f0_local0(f4_arg0, f4_arg1) +end + +local f0_local2 = 10000 +local f0_local3 = 10001 +local f0_local4 = function(f5_arg0) + local f5_local0 = CoD.mapsTable[f5_arg0] + if CoD.CONTENT_DLC6_INDEX <= f5_local0.dlc_pack or f5_arg0 == "mp_redwood_ice" or f5_arg0 == "mp_veiled_heyday" then + return f0_local3 + elseif f5_local0.dlc_pack > 0 then + return f0_local2 + else + return f5_local0.dlc_pack + end +end + +DataSources.ChangeMapCategories = DataSourceHelpers.ListSetup("ChangeMapCategories", function(f6_arg0) + local f6_local0 = {} + local f6_local1 = CoD.GetMapValue(Engine.DvarString(nil, "ui_mapname"), "dlc_pack", CoD.CONTENT_ORIGINAL_MAP_INDEX) + local f6_local2 = function(f7_arg0, f7_arg1) + return { + models = { + text = Engine.Localize("MPUI_MAP_CATEGORY_" .. f7_arg0 .. "_CAPS"), + buttonText = Engine.Localize("MPUI_MAP_CATEGORY_" .. f7_arg0 .. "_CAPS"), + image = "playlist_map", + description = Engine.Localize("MPUI_MAP_CATEGORY_" .. f7_arg0 .. "_DESC") + }, + properties = { + category = f7_arg1, + selectIndex = f6_local1 == f7_arg1 + } + } + end + + CoD.mapsTable = Engine.GetGDTMapsTable() + local f6_local3 = function(f8_arg0) + for f8_local3, f8_local4 in pairs(CoD.mapsTable) do + if f8_local4.session_mode == CoD.gameModeEnum and f0_local4(f8_local3) == f8_arg0 and (ShowPurchasableMap(f6_arg0, f8_local3) or Engine.IsMapValid(f8_local3)) then + return true + end + end + return false + end + + if CoD.isCampaign == true then + table.insert(f6_local0, f6_local2("missions", CoD.CONTENT_ORIGINAL_MAP_INDEX)) + table.insert(f6_local0, f6_local2("dev", CoD.CONTENT_DEV_MAP_INDEX)) + else + table.insert(f6_local0, f6_local2("standard", CoD.CONTENT_ORIGINAL_MAP_INDEX)) + if not Dvar.ui_execdemo:get() and f6_local3(f0_local2) then + table.insert(f6_local0, f6_local2("dlc", f0_local2)) + end + if not Dvar.ui_execdemo:get() and f6_local3(f0_local3) then + table.insert(f6_local0, f6_local2("dlc_bonus", f0_local3)) + end + if Mods_Enabled() then --and Engine.Mods_Lists_GetInfoEntries( LuaEnums.USERMAP_BASE_PATH, 0, Engine.Mods_Lists_GetInfoEntriesCount( LuaEnums.USERMAP_BASE_PATH ) ) ~= nil then + local f9_local11 = Engine.Mods_Lists_GetInfoEntries(LuaEnums.USERMAP_BASE_PATH, 0, + Engine.Mods_Lists_GetInfoEntriesCount(LuaEnums.USERMAP_BASE_PATH)) + if f9_local11 then + for f9_local12 = 0, #f9_local11, 1 do + local f9_local17 = f9_local11[f9_local12] + if LUI.startswith(f9_local17.internalName, "mp_") then + table.insert(f6_local0, f6_local2("mods", CoD.CONTENT_MODS_INDEX)) + end + end + end + end + end + return f6_local0 +end, true) diff --git a/data/ui_scripts/frontend_menus/datasources_gamesettingsflyout_buttons.lua b/data/ui_scripts/frontend_menus/datasources_gamesettingsflyout_buttons.lua new file mode 100644 index 00000000..497efefb --- /dev/null +++ b/data/ui_scripts/frontend_menus/datasources_gamesettingsflyout_buttons.lua @@ -0,0 +1,260 @@ +local f0_local0 = function(f1_arg0, f1_arg1) + if not CoD.useMouse then + return + else + f1_arg0.Options:setHandleMouse(true) + f1_arg0.Options:registerEventHandler("leftclick_outside", function(element, event) + CoD.PCUtil.SimulateButtonPress(event.controller, Enum.LUIButton.LUI_KEY_XBB_PSCIRCLE) + return true + end) + end +end + +local PostLoadFunc = function(f3_arg0, f3_arg1) + f0_local0(f3_arg0, f3_arg1) + f3_arg0.disableBlur = true + f3_arg0.disablePopupOpenCloseAnim = true + Engine.SetModelValue(Engine.CreateModel(Engine.GetGlobalModel(), "GameSettingsFlyoutOpen"), true) + LUI.OverrideFunction_CallOriginalSecond(f3_arg0, "close", function(element) + Engine.SetModelValue(Engine.CreateModel(Engine.GetGlobalModel(), "GameSettingsFlyoutOpen"), false) + end) + f3_arg0:registerEventHandler("occlusion_change", function(element, event) + local f5_local0 = element:getParent() + if f5_local0 then + local f5_local1 = f5_local0:getFirstChild() + while f5_local1 ~= nil do + if f5_local1.menuName == "Lobby" then + break + end + f5_local1 = f5_local1:getNextSibling() + end + if f5_local1 then + if event.occluded == true then + f5_local1:setAlpha(0) + end + f5_local1:setAlpha(1) + end + end + element:OcclusionChange(event) + end) + f3_arg0:subscribeToModel(Engine.CreateModel(Engine.GetGlobalModel(), "lobbyRoot.lobbyNav", true), function(model) + local f6_local0 = f3_arg0.occludedBy + while f6_local0 do + if f6_local0.occludedBy ~= nil then + f6_local0 = f6_local0.occludedBy + end + while f6_local0 and f6_local0.menuName ~= "Lobby" do + f6_local0 = GoBack(f6_local0, f3_arg1) + end + Engine.SendClientScriptNotify(f3_arg1, "menu_change" .. Engine.GetLocalClientNum(f3_arg1), "Main", + "closeToMenu") + return + end + GoBack(f3_arg0, f3_arg1) + end, false) +end + +DataSources.GameSettingsFlyoutButtonsCustom = DataSourceHelpers.ListSetup("GameSettingsFlyoutButtonsCustom", +function(f7_arg0) + local f7_local0 = { + { + optionDisplay = "MPUI_CHANGE_MAP_CAPS", + customId = "btnChangeMap", + action = OpenChangeMap + }, + -- { + -- optionDisplay = "MPUI_CHANGE_GAME_MODE_CAPS", + -- customId = "btnChangeGameMode", + -- action = OpenChangeGameMode + -- }, + { + optionDisplay = "MENU_SETUP_BOTS_CAPS", + customId = "btnSetupBots", + action = OpenBotSettings + }, + { + optionDisplay = "MPUI_EDIT_GAME_RULES_CAPS", + customId = "btnEditGameRules", + action = OpenEditGameRules + } + } + -- if CoD.isPC and IsServerBrowserEnabled() then + -- table.insert( f7_local0, { + -- optionDisplay = "PLATFORM_SERVER_SETTINGS_CAPS", + -- customID = "btnServerSettings", + -- action = OpenServerSettings + -- } ) + -- end + local f7_local1 = {} + for f7_local5, f7_local6 in ipairs(f7_local0) do + table.insert(f7_local1, { + models = { + displayText = Engine.Localize(f7_local6.optionDisplay), + customId = f7_local6.customId, + disabled = f7_local6.disabled + }, + properties = { + title = f7_local6.optionDisplay, + desc = f7_local6.desc, + action = f7_local6.action, + actionParam = f7_local6.actionParam + } + }) + end + return f7_local1 +end, nil, nil, nil) + +LUI.createMenu.GameSettingsFlyoutMPCustom = function(controller) + local self = CoD.Menu.NewForUIEditor("GameSettingsFlyoutMPCustom") + if PreLoadFunc then + PreLoadFunc(self, controller) + end + self.soundSet = "default" + self:setOwner(controller) + self:setLeftRight(true, true, 0, 0) + self:setTopBottom(true, true, 0, 0) + self:playSound("menu_open", controller) + self.buttonModel = Engine.CreateModel(Engine.GetModelForController(controller), "GameSettingsFlyoutMP.buttonPrompts") + self.anyChildUsesUpdateState = true + + local Options = LUI.UIList.new(self, controller, -2, 0, nil, false, false, 0, 0, false, false) + Options:makeFocusable() + Options:setLeftRight(true, false, 243.43, 523.43) + Options:setTopBottom(true, false, 177.56, 329.56) + Options:setYRot(25) + Options:setWidgetType(CoD.FE_List1ButtonLarge_PH) + Options:setVerticalCount(3) + Options:setSpacing(-2) + Options:setDataSource("GameSettingsFlyoutButtonsCustom") + Options:registerEventHandler("gain_focus", function(element, event) + local f9_local0 = nil + if element.gainFocus then + f9_local0 = element:gainFocus(event) + elseif element.super.gainFocus then + f9_local0 = element.super:gainFocus(event) + end + CoD.Menu.UpdateButtonShownState(element, self, controller, Enum.LUIButton.LUI_KEY_XBA_PSCROSS) + return f9_local0 + end) + Options:registerEventHandler("lose_focus", function(element, event) + local f10_local0 = nil + if element.loseFocus then + f10_local0 = element:loseFocus(event) + elseif element.super.loseFocus then + f10_local0 = element.super:loseFocus(event) + end + return f10_local0 + end) + self:AddButtonCallbackFunction(Options, controller, Enum.LUIButton.LUI_KEY_XBA_PSCROSS, "ENTER", + function(element, menu, controller, model) + ProcessListAction(self, element, controller) + return true + end, function(element, menu, controller) + CoD.Menu.SetButtonLabel(menu, Enum.LUIButton.LUI_KEY_XBA_PSCROSS, "MENU_SELECT") + return true + end, false) + self:addElement(Options) + self.Options = Options + + self:mergeStateConditions({ + { + stateName = "Local", + condition = function(menu, element, event) + return IsLobbyNetworkModeLAN() + end + } + }) + self:subscribeToModel(Engine.GetModel(Engine.GetGlobalModel(), "lobbyRoot.lobbyNetworkMode"), function(model) + local f14_local0 = self + local f14_local1 = { + controller = controller, + name = "model_validation", + modelValue = Engine.GetModelValue(model), + modelName = "lobbyRoot.lobbyNetworkMode" + } + CoD.Menu.UpdateButtonShownState(f14_local0, self, controller, Enum.LUIButton.LUI_KEY_XBY_PSTRIANGLE) + end) + self:subscribeToModel(Engine.GetModel(Engine.GetGlobalModel(), "lobbyRoot.lobbyNav"), function(model) + local f15_local0 = self + local f15_local1 = { + controller = controller, + name = "model_validation", + modelValue = Engine.GetModelValue(model), + modelName = "lobbyRoot.lobbyNav" + } + CoD.Menu.UpdateButtonShownState(f15_local0, self, controller, Enum.LUIButton.LUI_KEY_XBY_PSTRIANGLE) + end) + self:AddButtonCallbackFunction(self, controller, Enum.LUIButton.LUI_KEY_XBB_PSCIRCLE, nil, + function(element, menu, controller, model) + GoBack(self, controller) + ClearMenuSavedState(menu) + return true + end, function(element, menu, controller) + CoD.Menu.SetButtonLabel(menu, Enum.LUIButton.LUI_KEY_XBB_PSCIRCLE, "") + return false + end, false) + self:AddButtonCallbackFunction(self, controller, Enum.LUIButton.LUI_KEY_START, "M", + function(element, menu, controller, model) + GoBackAndOpenOverlayOnParent(self, "StartMenu_Main", controller) + return true + end, function(element, menu, controller) + CoD.Menu.SetButtonLabel(menu, Enum.LUIButton.LUI_KEY_START, "MENU_MENU") + return true + end, false) + self:AddButtonCallbackFunction(self, controller, Enum.LUIButton.LUI_KEY_XBY_PSTRIANGLE, "S", + function(element, menu, controller, model) + if not IsLAN() and not IsPlayerAGuest(controller) and IsPlayerAllowedToPlayOnline(controller) then + GoBackAndOpenOverlayOnParent(self, "Social_Main", controller) + return true + else + + end + end, function(element, menu, controller) + if not IsLAN() and not IsPlayerAGuest(controller) and IsPlayerAllowedToPlayOnline(controller) then + CoD.Menu.SetButtonLabel(menu, Enum.LUIButton.LUI_KEY_XBY_PSTRIANGLE, "") + return false + else + return false + end + end, false) + self:AddButtonCallbackFunction(self, controller, Enum.LUIButton.LUI_KEY_LB, nil, + function(element, menu, controller, model) + SendButtonPressToOccludedMenu(menu, controller, model, Enum.LUIButton.LUI_KEY_LB) + return true + end, function(element, menu, controller) + CoD.Menu.SetButtonLabel(menu, Enum.LUIButton.LUI_KEY_LB, "") + return false + end, false) + self:AddButtonCallbackFunction(self, controller, Enum.LUIButton.LUI_KEY_RB, nil, + function(element, menu, controller, model) + SendButtonPressToOccludedMenu(menu, controller, model, Enum.LUIButton.LUI_KEY_RB) + return true + end, function(element, menu, controller) + CoD.Menu.SetButtonLabel(menu, Enum.LUIButton.LUI_KEY_RB, "") + return false + end, false) + Options.id = "Options" + self:processEvent({ + name = "menu_loaded", + controller = controller + }) + self:processEvent({ + name = "update_state", + menu = self + }) + if not self:restoreState() then + self.Options:processEvent({ + name = "gain_focus", + controller = controller + }) + end + LUI.OverrideFunction_CallOriginalSecond(self, "close", function(element) + element.Options:close() + Engine.UnsubscribeAndFreeModel(Engine.GetModel(Engine.GetModelForController(controller), + "GameSettingsFlyoutMP.buttonPrompts")) + end) + if PostLoadFunc then + PostLoadFunc(self, controller) + end + return self +end diff --git a/data/ui_scripts/frontend_menus/datasources_start_menu_tabs.lua b/data/ui_scripts/frontend_menus/datasources_start_menu_tabs.lua new file mode 100644 index 00000000..77767260 --- /dev/null +++ b/data/ui_scripts/frontend_menus/datasources_start_menu_tabs.lua @@ -0,0 +1,217 @@ +DataSources.StartMenuTabs = ListHelper_SetupDataSource("StartMenuTabs", function(f44_arg0) + local f44_local0 = {} + table.insert(f44_local0, { + models = { + tabIcon = CoD.buttonStrings.shoulderl + }, + properties = { + m_mouseDisabled = true + } + }) + if Engine.IsDemoPlaying() then + local f44_local1 = "CoD.StartMenu_GameOptions" + if Engine.IsZombiesGame() then + f44_local1 = "CoD.StartMenu_GameOptions_ZM" + end + table.insert(f44_local0, { + models = { + tabName = Engine.Localize("MENU_THEATER_CAPS"), + tabWidget = f44_local1, + tabIcon = "" + }, + properties = { + tabId = "gameOptions" + } + }) + elseif Engine.IsInGame() then + if IsGameTypeDOA() and not InSafehouse() then + table.insert(f44_local0, { + models = { + tabName = "DOA", + tabWidget = "CoD.StartMenu_GameOptions_DOA", + tabIcon = "" + }, + properties = { + tabId = "gameOptions" + } + }) + elseif CoD.isCampaign then + table.insert(f44_local0, { + models = { + tabName = SessionModeToUnlocalizedSessionModeCaps(Engine.CurrentSessionMode()), + tabWidget = "CoD.StartMenu_GameOptions_CP", + tabIcon = "" + }, + properties = { + tabId = "gameOptions" + } + }) + if not Engine.IsCampaignModeZombies() then + if CoD.isSafehouse and CoD.isOnlineGame() and not IsInTrainingSim(f44_arg0) and Dvar.ui_safehousebarracks:get() and not IsPlayerAGuest(f44_arg0) then + table.insert(f44_local0, { + models = { + tabName = "CPUI_BARRACKS_CAPS", + tabWidget = "CoD.CombatRecordCP_Contents", + tabIcon = "" + }, + properties = { + tabId = "combatRecord" + } + }) + end + if HighestMapReachedGreaterThan(f44_arg0, 1) or LUI.DEV ~= nil then + table.insert(f44_local0, { + models = { + tabName = "CPUI_TACTICAL_MODE_CAPS", + tabWidget = "CoD.StartMenu_TacticalMode", + tabIcon = "" + }, + properties = { + tabId = "tacticalMode" + } + }) + end + if not CoD.isSafehouse and not IsPlayerAGuest(f44_arg0) then + table.insert(f44_local0, { + models = { + tabName = "CPUI_ACCOLADES", + tabWidget = "CoD.MissionRecordVault_Challenges", + tabIcon = "" + }, + properties = { + tabId = "accolades" + } + }) + end + end + elseif Engine.IsZombiesGame() then + table.insert(f44_local0, { + models = { + tabName = SessionModeToUnlocalizedSessionModeCaps(Engine.CurrentSessionMode()), + tabWidget = "CoD.StartMenu_GameOptions_ZM", + tabIcon = "" + }, + properties = { + tabId = "gameOptions" + } + }) + else + table.insert(f44_local0, { + models = { + tabName = SessionModeToUnlocalizedSessionModeCaps(Engine.CurrentSessionMode()), + tabWidget = "CoD.StartMenu_GameOptions", + tabIcon = "" + }, + properties = { + tabId = "gameOptions" + } + }) + end + else + if not IsPlayerAGuest(f44_arg0) then + table.insert(f44_local0, { + models = { + tabName = "MENU_TAB_IDENTITY_CAPS", + tabWidget = "CoD.StartMenu_Identity", + tabIcon = "" + }, + properties = { + tabId = "identity", + disabled = Dvar.ui_execdemo_gamescom:get() + } + }) + end + if not IsLobbyNetworkModeLAN() and not Dvar.ui_execdemo:get() and not Engine.IsCampaignModeZombies() and not IsPlayerAGuest(f44_arg0) then + table.insert(f44_local0, { + models = { + tabName = "MENU_TAB_CHALLENGES_CAPS", + tabWidget = "CoD.StartMenu_Challenges", + tabIcon = "" + }, + properties = { + tabId = "challenges" + } + }) + local f44_local1 = CoD.isPC + if f44_local1 then + f44_local1 = false --Mods_IsUsingMods() + end + table.insert(f44_local0, { + models = { + tabName = "MENU_TAB_BARRACKS_CAPS", + tabWidget = "CoD.StartMenu_Barracks", + tabIcon = "", + disabled = f44_local1 + }, + properties = { + tabId = "barracks" + } + }) + if CommunityOptionsEnabled() then + local f44_local2 = CoD.perController[f44_arg0].openMediaTabAfterClosingGroups + CoD.perController[f44_arg0].openMediaTabAfterClosingGroups = false + table.insert(f44_local0, { + models = { + tabName = "MENU_TAB_MEDIA_CAPS", + tabWidget = "CoD.StartMenu_Media", + tabIcon = "" + }, + properties = { + tabId = "media", + selectIndex = f44_local2 + } + }) + end + end + end + if IsGameTypeDOA() and Engine.IsInGame() and not InSafehouse() then + local f44_local1 = table.insert + local f44_local2 = f44_local0 + local f44_local3 = { + models = { + tabName = "MENU_TAB_OPTIONS_CAPS", + tabWidget = "CoD.StartMenu_Options_DOA", + tabIcon = "" + } + } + local f44_local4 = { + tabId = "options" + } + local f44_local5 = Dvar.ui_execdemo:get() + if f44_local5 then + f44_local5 = not Engine.IsInGame() + end + f44_local4.selectIndex = f44_local5 + f44_local3.properties = f44_local4 + f44_local1(f44_local2, f44_local3) + else + local f44_local1 = table.insert + local f44_local2 = f44_local0 + local f44_local3 = { + models = { + tabName = "MENU_TAB_OPTIONS_CAPS", + tabWidget = "CoD.StartMenu_Options", + tabIcon = "" + } + } + local f44_local4 = { + tabId = "options" + } + local f44_local5 = Dvar.ui_execdemo_gamescom:get() + if f44_local5 then + f44_local5 = not Engine.IsInGame() + end + f44_local4.selectIndex = f44_local5 + f44_local3.properties = f44_local4 + f44_local1(f44_local2, f44_local3) + end + table.insert(f44_local0, { + models = { + tabIcon = CoD.buttonStrings.shoulderr + }, + properties = { + m_mouseDisabled = true + } + }) + return f44_local0 +end, true) diff --git a/data/ui_scripts/frontend_menus/utils.lua b/data/ui_scripts/frontend_menus/utils.lua index d8190895..7abe1926 100644 --- a/data/ui_scripts/frontend_menus/utils.lua +++ b/data/ui_scripts/frontend_menus/utils.lua @@ -16,6 +16,28 @@ local SetButtonState = function(button, state) end end +local RemoveButton = function(buttonTable, button) + for id, v in pairs(buttonTable) do + if buttonTable[id].optionDisplay == button.stringRef then + table.remove(buttonTable, id) + end + end +end + +local RemoveSpaces = function(buttonTable) + for id, v in pairs(buttonTable) do + buttonTable[id].isLastButtonInGroup = false + end +end + +local GetButtonIndex = function(buttonTable, button) + for id, v in pairs(buttonTable) do + if buttonTable[id].optionDisplay == button.stringRef then + return id + end + end +end + local AddButton = function(controller, options, button, isLargeButton, index) if button == nil then return @@ -125,5 +147,8 @@ return { AddButton = AddButton, AddLargeButton = AddLargeButton, AddSmallButton = AddSmallButton, - AddSpacer = AddSpacer + AddSpacer = AddSpacer, + RemoveButton = RemoveButton, + RemoveSpaces = RemoveSpaces, + GetButtonIndex = GetButtonIndex } diff --git a/data/ui_scripts/party/__init__.lua b/data/ui_scripts/party/__init__.lua index 741d9378..cd6c5e3e 100644 --- a/data/ui_scripts/party/__init__.lua +++ b/data/ui_scripts/party/__init__.lua @@ -1,84 +1,27 @@ +if not Engine.IsInGame() then + return +end -- Removed check for public matches to allow team change in ranked matches CoD.IsTeamChangeAllowed = function() - if Engine.GetGametypeSetting( "allowInGameTeamChange" ) == 1 then + if Engine.GetGametypeSetting("allowInGameTeamChange") == 1 then return true else return false end end -DataSources.StartMenuGameOptions = ListHelper_SetupDataSource("StartMenuGameOptions", function (controller) - local options = {} - if Engine.IsDemoPlaying() then - if not IsDemoRestrictedBasicMode() then - table.insert(options, {models = {displayText = Engine.ToUpper(Engine.Localize("MENU_UPLOAD_CLIP", Engine.GetDemoSegmentCount())), action = StartMenuUploadClip, disabledFunction = IsUploadClipButtonDisabled}, properties = {hideHelpItemLabel = true}}) - end - if Engine.IsDemoHighlightReelMode() then - table.insert(options, {models = {displayText = Engine.ToUpper(Engine.Localize("MENU_DEMO_CUSTOMIZE_HIGHLIGHT_REEL")), action = StartMenuOpenCustomizeHighlightReel, disabledFunction = IsCustomizeHighlightReelButtonDisabled}}) - end - table.insert(options, {models = {displayText = Engine.ToUpper(Engine.ToUpper(Engine.Localize("MENU_JUMP_TO_START"))), action = StartMenuJumpToStart, disabledFunction = IsJumpToStartButtonDisabled}, properties = {hideHelpItemLabel = true}}) - local endDemoButtonText = nil - if Engine.IsDemoClipPlaying() then - endDemoButtonText = Engine.ToUpper(Engine.Localize("MENU_END_CLIP")) - else - endDemoButtonText = Engine.ToUpper(Engine.Localize("MENU_END_FILM")) - end - table.insert(options, {models = {displayText = Engine.ToUpper(endDemoButtonText), action = StartMenuEndDemo}}) - elseif CoD.isCampaign then - table.insert(options, {models = {displayText = "MENU_RESUMEGAME_CAPS", action = StartMenuGoBack_ListElement}}) - local inTrainingSim = CoD.SafeGetModelValue(Engine.GetModelForController(controller), "safehouse.inTrainingSim") - if not inTrainingSim then - inTrainingSim = 0 - end - if Engine.IsLobbyHost(Enum.LobbyType.LOBBY_TYPE_GAME) then - if not CoD.isSafehouse and controller == Engine.GetPrimaryController() then - table.insert(options, {models = {displayText = "MENU_RESTART_MISSION_CAPS", action = RestartMission}}) - if LUI.DEV ~= nil then - table.insert(options, {models = {displayText = "MENU_RESTART_CHECKPOINT_CAPS", action = RestartFromCheckpoint}}) - end - end - if controller == Engine.GetPrimaryController() then - table.insert(options, {models = {displayText = "MENU_CHANGE_DIFFICULTY_CAPS", action = OpenDifficultySelect}}) - end - if CoD.isSafehouse and inTrainingSim == 1 then - table.insert(options, {models = {displayText = "MENU_END_TRAINING_SIM", action = EndTrainingSim}}) - elseif controller == Engine.GetPrimaryController() then - if Engine.DvarBool(0, "ui_blocksaves") then - table.insert(options, {models = {displayText = "MENU_EXIT_CAPS", action = SaveAndQuitGame}}) - else - table.insert(options, {models = {displayText = "MENU_SAVE_AND_QUIT_CAPS", action = SaveAndQuitGame}}) - end - end - elseif CoD.isSafehouse and inTrainingSim == 1 then - table.insert(options, {models = {displayText = "MENU_END_TRAINING_SIM", action = EndTrainingSim}}) - else - table.insert(options, {models = {displayText = "MENU_LEAVE_PARTY_AND_EXIT_CAPS", action = QuitGame}}) - end - elseif CoD.isMultiplayer then - if Engine.Team(controller, "name") ~= "TEAM_SPECTATOR" and Engine.GetGametypeSetting("disableClassSelection") ~= 1 then - table.insert(options, {models = {displayText = "MPUI_CHOOSE_CLASS_BUTTON_CAPS", action = ChooseClass}}) - end - if not Engine.IsVisibilityBitSet(controller, Enum.UIVisibilityBit.BIT_ROUND_END_KILLCAM) and not Engine.IsVisibilityBitSet(controller, Enum.UIVisibilityBit.BIT_FINAL_KILLCAM) and CoD.IsTeamChangeAllowed() then - table.insert(options, {models = {displayText = "MPUI_CHANGE_TEAM_BUTTON_CAPS", action = ChooseTeam}}) - end - if controller == 0 then - local endGameText = "MENU_QUIT_GAME_CAPS" - if Engine.IsLobbyHost(Enum.LobbyType.LOBBY_TYPE_GAME) and not CoD.isOnlineGame() then - endGameText = "MENU_END_GAME_CAPS" - end - table.insert(options, {models = {displayText = endGameText, action = QuitGame_MP}}) - end - elseif CoD.isZombie then - table.insert(options, {models = {displayText = "MENU_RESUMEGAME_CAPS", action = StartMenuGoBack_ListElement}}) - if Engine.IsLobbyHost(Enum.LobbyType.LOBBY_TYPE_GAME) and (not Engine.SessionModeIsMode(CoD.SESSIONMODE_SYSTEMLINK) or Engine.SessionModeIsMode(CoD.SESSIONMODE_OFFLINE)) then - table.insert(options, {models = {displayText = "MENU_RESTART_LEVEL_CAPS", action = RestartGame}}) - end - if Engine.IsLobbyHost(Enum.LobbyType.LOBBY_TYPE_GAME) == true then - table.insert(options, {models = {displayText = "MENU_END_GAME_CAPS", action = QuitGame_MP}}) - else - table.insert(options, {models = {displayText = "MENU_QUIT_GAME_CAPS", action = QuitGame_MP}}) - end - end - return options -end, true) +local getModeInfo = function() + local id = Engine.GetLobbyUIScreen() + return LobbyData:UITargetFromId(id) +end + +local getMaxClients = function() + local modeInfo = getModeInfo() + return modeInfo.maxClients +end + +-- Set com_maxclients InGame so players can join via direct connect (default from lobbydata) +Engine.SetDvar("com_maxclients", getMaxClients()) + +require("datasources_start_menu_game_options") diff --git a/data/ui_scripts/party/datasources_start_menu_game_options.lua b/data/ui_scripts/party/datasources_start_menu_game_options.lua new file mode 100644 index 00000000..ae6eb3bb --- /dev/null +++ b/data/ui_scripts/party/datasources_start_menu_game_options.lua @@ -0,0 +1,75 @@ +DataSources.StartMenuGameOptions = ListHelper_SetupDataSource("StartMenuGameOptions", function (controller) + local options = {} + if Engine.IsDemoPlaying() then + if not IsDemoRestrictedBasicMode() then + table.insert(options, {models = {displayText = Engine.ToUpper(Engine.Localize("MENU_UPLOAD_CLIP", Engine.GetDemoSegmentCount())), action = StartMenuUploadClip, disabledFunction = IsUploadClipButtonDisabled}, properties = {hideHelpItemLabel = true}}) + end + if Engine.IsDemoHighlightReelMode() then + table.insert(options, {models = {displayText = Engine.ToUpper(Engine.Localize("MENU_DEMO_CUSTOMIZE_HIGHLIGHT_REEL")), action = StartMenuOpenCustomizeHighlightReel, disabledFunction = IsCustomizeHighlightReelButtonDisabled}}) + end + table.insert(options, {models = {displayText = Engine.ToUpper(Engine.ToUpper(Engine.Localize("MENU_JUMP_TO_START"))), action = StartMenuJumpToStart, disabledFunction = IsJumpToStartButtonDisabled}, properties = {hideHelpItemLabel = true}}) + local endDemoButtonText = nil + if Engine.IsDemoClipPlaying() then + endDemoButtonText = Engine.ToUpper(Engine.Localize("MENU_END_CLIP")) + else + endDemoButtonText = Engine.ToUpper(Engine.Localize("MENU_END_FILM")) + end + table.insert(options, {models = {displayText = Engine.ToUpper(endDemoButtonText), action = StartMenuEndDemo}}) + elseif CoD.isCampaign then + table.insert(options, {models = {displayText = "MENU_RESUMEGAME_CAPS", action = StartMenuGoBack_ListElement}}) + local inTrainingSim = CoD.SafeGetModelValue(Engine.GetModelForController(controller), "safehouse.inTrainingSim") + if not inTrainingSim then + inTrainingSim = 0 + end + if Engine.IsLobbyHost(Enum.LobbyType.LOBBY_TYPE_GAME) then + if not CoD.isSafehouse and controller == Engine.GetPrimaryController() then + table.insert(options, {models = {displayText = "MENU_RESTART_MISSION_CAPS", action = RestartMission}}) + if LUI.DEV ~= nil then + table.insert(options, {models = {displayText = "MENU_RESTART_CHECKPOINT_CAPS", action = RestartFromCheckpoint}}) + end + end + if controller == Engine.GetPrimaryController() then + table.insert(options, {models = {displayText = "MENU_CHANGE_DIFFICULTY_CAPS", action = OpenDifficultySelect}}) + end + if CoD.isSafehouse and inTrainingSim == 1 then + table.insert(options, {models = {displayText = "MENU_END_TRAINING_SIM", action = EndTrainingSim}}) + elseif controller == Engine.GetPrimaryController() then + if Engine.DvarBool(0, "ui_blocksaves") then + table.insert(options, {models = {displayText = "MENU_EXIT_CAPS", action = SaveAndQuitGame}}) + else + table.insert(options, {models = {displayText = "MENU_SAVE_AND_QUIT_CAPS", action = SaveAndQuitGame}}) + end + end + elseif CoD.isSafehouse and inTrainingSim == 1 then + table.insert(options, {models = {displayText = "MENU_END_TRAINING_SIM", action = EndTrainingSim}}) + else + table.insert(options, {models = {displayText = "MENU_LEAVE_PARTY_AND_EXIT_CAPS", action = QuitGame}}) + end + elseif CoD.isMultiplayer then + if Engine.Team(controller, "name") ~= "TEAM_SPECTATOR" and Engine.GetGametypeSetting("disableClassSelection") ~= 1 then + table.insert(options, {models = {displayText = "MPUI_CHOOSE_CLASS_BUTTON_CAPS", action = ChooseClass}}) + end + if not Engine.IsVisibilityBitSet(controller, Enum.UIVisibilityBit.BIT_ROUND_END_KILLCAM) and not Engine.IsVisibilityBitSet(controller, Enum.UIVisibilityBit.BIT_FINAL_KILLCAM) and CoD.IsTeamChangeAllowed() then + table.insert(options, {models = {displayText = "MPUI_CHANGE_TEAM_BUTTON_CAPS", action = ChooseTeam}}) + end + if controller == 0 then + local endGameText = "MENU_QUIT_GAME_CAPS" + if Engine.IsLobbyHost(Enum.LobbyType.LOBBY_TYPE_GAME) and not CoD.isOnlineGame() then + endGameText = "MENU_END_GAME_CAPS" + end + table.insert(options, {models = {displayText = endGameText, action = QuitGame_MP}}) + end + elseif CoD.isZombie then + table.insert(options, {models = {displayText = "MENU_RESUMEGAME_CAPS", action = StartMenuGoBack_ListElement}}) + if Engine.IsLobbyHost(Enum.LobbyType.LOBBY_TYPE_GAME) and (not Engine.SessionModeIsMode(CoD.SESSIONMODE_SYSTEMLINK) or Engine.SessionModeIsMode(CoD.SESSIONMODE_OFFLINE)) then + table.insert(options, {models = {displayText = "MENU_RESTART_LEVEL_CAPS", action = RestartGame}}) + end + if Engine.IsLobbyHost(Enum.LobbyType.LOBBY_TYPE_GAME) == true then + table.insert(options, {models = {displayText = "MENU_END_GAME_CAPS", action = QuitGame_MP}}) + else + table.insert(options, {models = {displayText = "MENU_QUIT_GAME_CAPS", action = QuitGame_MP}}) + end + end + table.insert(options, {models = {displayText = "QUIT TO DESKTOP", action = OpenPCQuit}}) + return options +end, true) diff --git a/data/ui_scripts/playlist/__init__.lua b/data/ui_scripts/playlist/__init__.lua new file mode 100644 index 00000000..f8080665 --- /dev/null +++ b/data/ui_scripts/playlist/__init__.lua @@ -0,0 +1,34 @@ +if Engine.GetCurrentMap() ~= "core_frontend" then + return +end + +if CoD.LobbyMember then + local oldLobbyMember = CoD.LobbyMember.new + function CoD.LobbyMember.new(menu, controller) + local self = oldLobbyMember(menu, controller) + + -- Hide the playlist count text + if self.SearchingForPlayer then + self.SearchingForPlayer:setAlpha(0) + end + if self.FEMemberBlurPanelContainer0 then + self.FEMemberBlurPanelContainer0:setAlpha(0) + end + + return self + end +end + +function IsLobbyStatusVisible() + return false +end + +Engine.SetDvar("lobbyMigrate_Enabled", 0) +Engine.SetDvar("lobbyTimerStatusVotingInterval", 11000) +Engine.SetDvar("lobbyTimerStatusBeginInterval", 10) +Engine.SetDvar("lobbyTimerStatusStartInterval", 10) +Engine.SetDvar("lobbyTimerStatusPostGameInterval", 10) +Engine.SetDvar("lobbyTimerStatusVotingInterval_Arena", 11000) + +require("widget_playlist_match_settings_info") +require("widget_playlist_category_match_settings_info") diff --git a/data/ui_scripts/playlist/widget_playlist_category_match_settings_info.lua b/data/ui_scripts/playlist/widget_playlist_category_match_settings_info.lua new file mode 100644 index 00000000..28c34d25 --- /dev/null +++ b/data/ui_scripts/playlist/widget_playlist_category_match_settings_info.lua @@ -0,0 +1,15 @@ +if not CoD.playlistCategoryMatchSettingsInfo then + return +end + +local oldPlaylistCategoryMatchSettingsInfo = CoD.playlistCategoryMatchSettingsInfo.new +function CoD.playlistCategoryMatchSettingsInfo.new(menu, controller) + local self = oldPlaylistCategoryMatchSettingsInfo(menu, controller) + + -- Hide the playlist count text + if self.playlistCount then + self.playlistCount:setAlpha(0) + end + + return self +end diff --git a/data/ui_scripts/playlist/widget_playlist_match_settings_info.lua b/data/ui_scripts/playlist/widget_playlist_match_settings_info.lua new file mode 100644 index 00000000..9b31390e --- /dev/null +++ b/data/ui_scripts/playlist/widget_playlist_match_settings_info.lua @@ -0,0 +1,15 @@ +if not CoD.playlistMatchSettingsInfo then + return +end + +local oldPlaylistMatchSettingsInfo = CoD.playlistMatchSettingsInfo.new +function CoD.playlistMatchSettingsInfo.new(menu, controller) + local self = oldPlaylistMatchSettingsInfo(menu, controller) + + -- Hide the playlist count text + if self.playlistCount then + self.playlistCount:setAlpha(0) + end + + return self +end diff --git a/data/ui_scripts/stats/__init__.lua b/data/ui_scripts/stats/__init__.lua index 5ac66426..70a1eeac 100644 --- a/data/ui_scripts/stats/__init__.lua +++ b/data/ui_scripts/stats/__init__.lua @@ -20,7 +20,7 @@ DataSources.MPStatsSettings = DataSourceHelpers.ListSetup("MPStatsSettings", fun table.insert(optionsTable, CoD.OptionsUtility.CreateDvarSettings(controller, "Unlock All Loot", - "Whether loot should be locked based on the player's stats or always unlocked.", "MPStatsSettings_unlock_loot", + "Unlocks all Black Market loot.", "MPStatsSettings_unlock_loot", "cg_unlockall_loot", { { option = "MENU_DISABLED", @@ -47,6 +47,20 @@ DataSources.MPStatsSettings = DataSourceHelpers.ListSetup("MPStatsSettings", fun value = 1 }, }, nil, updateDvar)) + table.insert(optionsTable, + CoD.OptionsUtility.CreateDvarSettings(controller, "Unlock All Class Slots", + "Unlocks all create-a-class slots and sets.", "MPStatsSettings_unlockall_cac_slots", + "cg_unlockall_cac_slots", { + { + option = "MENU_DISABLED", + value = 0, + default = true + }, + { + option = "MENU_ENABLED", + value = 1 + }, + }, nil, updateDvar)) end table.insert(optionsTable, CoD.OptionsUtility.CreateDvarSettings(controller, "Unlock All Attachments", diff --git a/deps/curl b/deps/curl index 7ed010ce..6b1e4dc6 160000 --- a/deps/curl +++ b/deps/curl @@ -1 +1 @@ -Subproject commit 7ed010ce2192ae3e4d9663eaaa3a460f316b708b +Subproject commit 6b1e4dc6cdd2c1fc1730dc64aa5e2d82615e5993 diff --git a/deps/zlib b/deps/zlib index 5799c14c..b8a8373e 160000 --- a/deps/zlib +++ b/deps/zlib @@ -1 +1 @@ -Subproject commit 5799c14c8526bf1aaa130c021982f831d155b46d +Subproject commit b8a8373ec195c8d286fe7e81e78b4a6d31bd859f diff --git a/src/client/component/auth.cpp b/src/client/component/auth.cpp index 78a6b460..9d8108f8 100644 --- a/src/client/component/auth.cpp +++ b/src/client/component/auth.cpp @@ -2,6 +2,7 @@ #include "loader/component_loader.hpp" #include "auth.hpp" +#include "party.hpp" #include "command.hpp" #include "network.hpp" #include "scheduler.hpp" @@ -24,6 +25,8 @@ namespace auth { namespace { + std::array client_xuids{}; + std::string get_hdd_serial() { DWORD serial{}; @@ -151,6 +154,59 @@ namespace auth return 0; } + void distribute_player_xuid(const game::netadr_t& target, const size_t player_index, const uint64_t xuid) + { + if (player_index >= 18) + { + return; + } + + utils::byte_buffer buffer{}; + buffer.write(static_cast(player_index)); + buffer.write(xuid); + + game::foreach_connected_client([&](const game::client_s& client, const size_t index) + { + if (client.address.type != game::NA_BOT) + { + network::send(client.address, "playerXuid", buffer.get_buffer()); + } + + if (index != player_index && target.type != game::NA_BOT) + { + utils::byte_buffer current_buffer{}; + current_buffer.write(static_cast(index)); + current_buffer.write(client.xuid); + + network::send(target, "playerXuid", current_buffer.get_buffer()); + } + }); + } + + void handle_new_player(const game::netadr_t& target) + { + const command::params_sv params{}; + if (params.size() < 2) + { + return; + } + + const utils::info_string info_string(params[1]); + const auto xuid = strtoull(info_string.get("xuid").data(), nullptr, 16); + + size_t player_index = 18; + game::foreach_connected_client([&](game::client_s& client, const size_t index) + { + if (client.address == target) + { + client.xuid = xuid; + player_index = index; + } + }); + + distribute_player_xuid(target, player_index, xuid); + } + void dispatch_connect_packet(const game::netadr_t& target, const std::string& data) { utils::byte_buffer buffer(data); @@ -172,14 +228,7 @@ namespace auth profile_infos::add_and_distribute_profile_info(target, xuid, info); game::SV_DirectConnect(target); - - game::foreach_connected_client([&](game::client_s& client) - { - if (client.address == target) - { - client.xuid = xuid; - } - }); + handle_new_player(target); } void handle_connect_packet_fragment(const game::netadr_t& target, const network::data_view& data) @@ -200,6 +249,30 @@ namespace auth }, scheduler::server); } } + + void handle_player_xuid_packet(const game::netadr_t& target, const network::data_view& data) + { + if (game::is_server_running() || !party::is_host(target)) + { + return; + } + + utils::byte_buffer buffer(data); + + const auto player_id = buffer.read(); + const auto xuid = buffer.read(); + + if (player_id < client_xuids.size()) + { + client_xuids[player_id] = xuid; + } + } + + void direct_connect_bots_stub(const game::netadr_t address) + { + game::SV_DirectConnect(address); + handle_new_player(address); + } } uint64_t get_guid() @@ -217,6 +290,40 @@ namespace auth return guid; } + uint64_t get_guid(const size_t client_num) + { + if (client_num >= 18) + { + return 0; + } + + if (!game::is_server_running()) + { + return client_xuids[client_num]; + } + + uint64_t xuid = 0; + const auto callback = [&xuid](const game::client_s& client) + { + xuid = client.xuid; + }; + + if (!game::access_connected_client(client_num, callback)) + { + return 0; + } + + return xuid; + } + + void clear_stored_guids() + { + for (auto& xuid : client_xuids) + { + xuid = 0; + } + } + struct component final : generic_component { void post_unpack() override @@ -224,6 +331,10 @@ namespace auth // Skip connect handler utils::hook::set(game::select(0x142253EFA, 0x14053714A), 0xEB); network::on("connect", handle_connect_packet_fragment); + network::on("playerXuid", handle_player_xuid_packet); + + // Intercept SV_DirectConnect in SV_AddTestClient + utils::hook::call(game::select(0x1422490DC, 0x14052E582), direct_connect_bots_stub); // Patch steam id bit check std::vector> patches{}; @@ -271,6 +382,9 @@ namespace auth p(0x141EB74D2_g, 0x141EB7515_g); // ? utils::hook::call(0x14134BF7D_g, send_connect_data_stub); + + // Fix crash + utils::hook::nop(0x142249097_g, 5); } for (const auto& patch : patches) diff --git a/src/client/component/auth.hpp b/src/client/component/auth.hpp index 3ee0c53a..30341c98 100644 --- a/src/client/component/auth.hpp +++ b/src/client/component/auth.hpp @@ -3,4 +3,6 @@ namespace auth { uint64_t get_guid(); + uint64_t get_guid(size_t client_num); + void clear_stored_guids(); } diff --git a/src/client/component/colors.cpp b/src/client/component/colors.cpp index 306c44b6..5c7f7b4e 100644 --- a/src/client/component/colors.cpp +++ b/src/client/component/colors.cpp @@ -3,6 +3,10 @@ #include "game/game.hpp" +#include "auth.hpp" + +#include "steam/steam.hpp" + #include #include @@ -10,8 +14,25 @@ namespace colors { namespace { - utils::hook::detour get_player_name_hook; - utils::hook::detour get_gamer_tag_hook; + utils::hook::detour cl_get_client_name_hook; + + std::optional get_color_for_xuid(const uint64_t xuid) + { + if (xuid == 0xCD02AF6448291209 + || xuid == 0x10F0C433E08E1357 + || xuid == 0x60E0FEFE42341715) + { + return 2; + } + + return {}; + } + + std::optional get_color_for_client(const int client_num) + { + const auto xuid = auth::get_guid(static_cast(client_num)); + return get_color_for_xuid(xuid); + } template void patch_color(const uint8_t r, const uint8_t g, const uint8_t b, const uint8_t a = 255) @@ -36,23 +57,39 @@ namespace colors utils::hook::copy(g_color_table + index * 4, color_float, sizeof(color_float)); } - /*uint64_t get_player_name_stub(const uint64_t client, int client_num, char* buffer, const int size, - const bool has_clan_tag) + bool cl_get_client_name_stub(const int local_client_num, const int index, char* buf, const int size, + const bool add_clan_name) { - const auto res = get_player_name_hook.invoke(client, client_num, buffer, size, has_clan_tag); + const auto res = cl_get_client_name_hook.invoke(local_client_num, index, buf, size, add_clan_name); - if (_ReturnAddress() != reinterpret_cast(0x1406A7B56_g)) + if (_ReturnAddress() == reinterpret_cast(0x1406A7B56_g)) { - const auto val = utils::string::va("^%d%s", rand() % 7, buffer); - strncpy_s(buffer, size, val, size); + return res; } - return res; - }*/ + const auto color = get_color_for_client(index); + if (!color) + { + return res; + } - /*const char* get_gamer_tag_stub(const uint64_t num) + const auto val = utils::string::va("^%d%s", *color, buf); + utils::string::copy(buf, size, val); + + return res; + } + + /*const char* get_gamer_tag_stub(const uint32_t num) { - return utils::string::va("^3%s", get_gamer_tag_hook.invoke(num)); + const auto color = get_color_for_xuid(steam::SteamUser()->GetSteamID().bits); + const auto name = reinterpret_cast(0x141EC6E80)(num) + 8; + + if (!color || num) + { + return name; + } + + return utils::string::va("^1%s", *color, name); }*/ } @@ -68,8 +105,8 @@ namespace colors patch_color<6>(151, 80, 221); // 6 - Pink // Old addresses - //get_player_name_hook.create(0x1413E3140_g, get_player_name_stub); - //get_gamer_tag_hook.create(0x141EC7370_g, get_gamer_tag_stub); + cl_get_client_name_hook.create(game::CL_GetClientName, cl_get_client_name_stub); + //utils::hook::jump(0x141EC72E0_g, get_gamer_tag_stub); } }; } diff --git a/src/client/component/discord.cpp b/src/client/component/discord.cpp index 421fe889..e8cabdf1 100644 --- a/src/client/component/discord.cpp +++ b/src/client/component/discord.cpp @@ -9,9 +9,11 @@ namespace discord { namespace { - void ready(const DiscordUser* /*request*/) + void ready(const DiscordUser* request) { - printf("Discord: Ready\n"); + SetEnvironmentVariableA("discord_user", request->userId); + + printf("Discord: Ready: %s - %s\n", request->userId, request->username); DiscordRichPresence discord_presence{}; ZeroMemory(&discord_presence, sizeof(discord_presence)); diff --git a/src/client/component/getinfo.cpp b/src/client/component/getinfo.cpp index 505c0dd6..7514d8cf 100644 --- a/src/client/component/getinfo.cpp +++ b/src/client/component/getinfo.cpp @@ -110,6 +110,7 @@ namespace getinfo info.set("bots", std::to_string(get_bot_count())); info.set("sv_maxclients", std::to_string(get_max_client_count())); info.set("protocol", std::to_string(PROTOCOL)); + info.set("sub_protocol", std::to_string(SUB_PROTOCOL)); info.set("playmode", std::to_string(game::Com_SessionMode_GetMode())); info.set("gamemode", std::to_string(Com_SessionMode_GetGameMode())); info.set("sv_running", std::to_string(game::is_server_running())); diff --git a/src/client/component/loot.cpp b/src/client/component/loot.cpp index 291bcdd6..39a54490 100644 --- a/src/client/component/loot.cpp +++ b/src/client/component/loot.cpp @@ -17,6 +17,7 @@ namespace loot const game::dvar_t* dvar_cg_unlockall_camos_and_reticles; const game::dvar_t* dvar_cg_unlockall_calling_cards; const game::dvar_t* dvar_cg_unlockall_specialists_outfits; + const game::dvar_t* dvar_cg_unlockall_cac_slots; utils::hook::detour loot_getitemquantity_hook; utils::hook::detour liveinventory_getitemquantity_hook; @@ -30,7 +31,8 @@ namespace loot utils::hook::detour bg_unlockablescharactercustomizationitemlocked_hook; utils::hook::detour bg_emblemisentitlementbackgroundgranted_hook; utils::hook::detour liveentitlements_isentitlementactiveforcontroller_hook; - + utils::hook::detour bg_unlockablesgetcustomclasscount_hook; + int loot_getitemquantity_stub(const game::ControllerIndex_t controller_index, const game::eModes mode, const int item_id) { if (!dvar_cg_unlockall_loot->current.value.enabled) @@ -48,19 +50,25 @@ namespace loot int liveinventory_getitemquantity_stub(const game::ControllerIndex_t controller_index, const int item_id) { - // Item id's for extra CaC slots, CWL camo's and paid specialist outfits + // Item id's for CWL camo's and paid specialist outfits if (dvar_cg_unlockall_loot->current.value.enabled && (item_id == 99003 || item_id >= 99018 && item_id <= 99021 || item_id == 99025 || item_id >= 90047 && item_id <= 90064)) { return 1; } + // Item id for extra CaC slots + if (dvar_cg_unlockall_cac_slots->current.value.enabled && item_id == 99003) + { + return 1; + } + return liveinventory_getitemquantity_hook.invoke(controller_index, item_id); } bool liveinventory_areextraslotspurchased_stub(const game::ControllerIndex_t controller_index) { - if (dvar_cg_unlockall_loot->current.value.enabled) + if (dvar_cg_unlockall_cac_slots->current.value.enabled) { return true; } @@ -160,9 +168,19 @@ namespace loot return liveentitlements_isentitlementactiveforcontroller_hook.invoke(controllerIndex, incentiveId); } + + int bg_unlockablesgetcustomclasscount_stub(game::eModes mode, const game::ControllerIndex_t controllerIndex) + { + if (dvar_cg_unlockall_cac_slots->current.value.enabled) + { + return 10; + } + + return bg_unlockablesgetcustomclasscount_hook.invoke(mode, controllerIndex); + } }; - struct component final : client_component + struct component final: client_component { void post_unpack() override { @@ -172,6 +190,7 @@ namespace loot dvar_cg_unlockall_camos_and_reticles = game::register_dvar_bool("cg_unlockall_camos_and_reticles", false, game::DVAR_ARCHIVE, "Unlocks all camos and reticles"); dvar_cg_unlockall_calling_cards = game::register_dvar_bool("cg_unlockall_calling_cards", false, game::DVAR_ARCHIVE, "Unlocks all calling cards"); dvar_cg_unlockall_specialists_outfits = game::register_dvar_bool("cg_unlockall_specialists_outfits", false, game::DVAR_ARCHIVE, "Unlocks all specialists outfits"); + dvar_cg_unlockall_cac_slots = game::register_dvar_bool("cg_unlockall_cac_slots", false, game::DVAR_ARCHIVE, "Unlocks all Create a Class Slots"); loot_getitemquantity_hook.create(0x141E82C00_g, loot_getitemquantity_stub); liveinventory_getitemquantity_hook.create(0x141E09030_g, liveinventory_getitemquantity_stub); @@ -185,6 +204,7 @@ namespace loot bg_unlockablescharactercustomizationitemlocked_hook.create(0x1426A2030_g, bg_unlockablescharactercustomizationitemlocked_stub); bg_emblemisentitlementbackgroundgranted_hook.create(0x142667520_g, bg_emblemisentitlementbackgroundgranted_stub); liveentitlements_isentitlementactiveforcontroller_hook.create(0x141E124E0_g, liveentitlements_isentitlementactiveforcontroller_stub); + bg_unlockablesgetcustomclasscount_hook.create(0x1426A5900_g, bg_unlockablesgetcustomclasscount_stub); scheduler::once([]() { if (dvar_cg_unlockall_loot->current.value.enabled) diff --git a/src/client/component/network.cpp b/src/client/component/network.cpp index 546d5a1f..4371a17a 100644 --- a/src/client/component/network.cpp +++ b/src/client/component/network.cpp @@ -163,7 +163,6 @@ namespace network : 0; } - uint64_t ret2() { return 2; @@ -173,6 +172,15 @@ namespace network { return 0; } + + void com_error_oob_stub(const char* file, int line, int code, [[maybe_unused]] const char* fmt, const char* error) + { + char buffer[1024]{}; + + strncpy_s(buffer, error, _TRUNCATE); + + game::Com_Error_(file, line, code, "%s", buffer); + } } void on(const std::string& command, const callback& callback) @@ -321,10 +329,21 @@ namespace network // NA_IP -> NA_RAWIP in NetAdr_ToString utils::hook::set(game::select(0x142172ED4, 0x140515864), game::NA_RAWIP); + // Kill 'echo' OOB handler + utils::hook::set(game::select(0x14134D0FB, 0x14018EE82), 0xEB); + if (game::is_server()) { // Remove restrictions for rcon commands - utils::hook::call(0x140538D5C_g, &con_restricted_execute_buf_stub); // SVC_RemoteCommand + utils::hook::call(0x140538D5C_g, con_restricted_execute_buf_stub); // SVC_RemoteCommand + + // Kill 'error' OOB handler on the dedi + utils::hook::nop(0x14018EF8B_g, 5); + } + else + { + // Truncate error string to make sure there are no buffer overruns later + utils::hook::call(0x14134D206_g, com_error_oob_stub); } // TODO: Fix that diff --git a/src/client/component/party.cpp b/src/client/component/party.cpp index 837a97f9..f5d0487a 100644 --- a/src/client/component/party.cpp +++ b/src/client/component/party.cpp @@ -3,6 +3,7 @@ #include "game/game.hpp" #include "party.hpp" +#include "auth.hpp" #include "network.hpp" #include "scheduler.hpp" #include "workshop.hpp" @@ -39,6 +40,8 @@ namespace party void connect_to_lobby(const game::netadr_t& addr, const std::string& mapname, const std::string& gamemode, const std::string& usermap_id, const std::string& mod_id) { + auth::clear_stored_guids(); + workshop::load_mod_if_needed(usermap_id, mod_id); game::XSESSION_INFO info{}; @@ -56,7 +59,8 @@ namespace party } void connect_to_lobby_with_mode(const game::netadr_t& addr, const game::eModes mode, const std::string& mapname, - const std::string& gametype, const std::string& usermap_id, const std::string& mod_id, + const std::string& gametype, const std::string& usermap_id, + const std::string& mod_id, const bool was_retried = false) { if (game::Com_SessionMode_IsMode(mode)) @@ -153,6 +157,14 @@ namespace party return; } + const auto sub_protocol = atoi(info.get("sub_protocol").data()); + if (sub_protocol != SUB_PROTOCOL && sub_protocol != (SUB_PROTOCOL - 1)) + { + const auto str = "Invalid sub-protocol."; + printf("%s\n", str); + return; + } + const auto gamename = info.get("gamename"); if (gamename != "T7"s) { @@ -189,7 +201,7 @@ namespace party const auto usermap_id = workshop::get_usermap_publisher_id(mapname); if (workshop::check_valid_usermap_id(mapname, usermap_id) && - workshop::check_valid_mod_id(mod_id)) + workshop::check_valid_mod_id(mod_id)) { if (is_connecting_to_dedi) { diff --git a/src/client/component/party.hpp b/src/client/component/party.hpp index f682a14e..b10ee95c 100644 --- a/src/client/component/party.hpp +++ b/src/client/component/party.hpp @@ -1,6 +1,8 @@ #pragma once #include +#include "game/game.hpp" + namespace party { using query_callback_func = void(bool success, const game::netadr_t& host, const ::utils::info_string& info, uint32_t ping); diff --git a/src/client/component/patches.cpp b/src/client/component/patches.cpp index 0900b5a8..c442fa83 100644 --- a/src/client/component/patches.cpp +++ b/src/client/component/patches.cpp @@ -1,50 +1,68 @@ -#include -#include "loader/component_loader.hpp" - -#include -#include - -#include "scheduler.hpp" - -#include - -namespace patches -{ - namespace - { - void script_errors_stub(const char* file, int line, unsigned int code, const char* fmt, ...) - { - char buffer[0x1000]; - - { - va_list ap; - va_start(ap, fmt); - vsnprintf_s(buffer, sizeof(buffer), _TRUNCATE, fmt, ap); - va_end(ap); - } - - game::Com_Error(game::ERROR_SCRIPT_DROP, "%s", buffer); - } - } - - struct component final : generic_component - { - void post_unpack() override - { - // don't make script errors fatal error - utils::hook::call(game::select(0x1412CAC4D, 0x140158EB2), script_errors_stub); - - // Change 4 character name limit to 3 characters - utils::hook::set(game::select(0x14224DA53, 0x140531143), 3); - utils::hook::set(game::select(0x14224DBB4, 0x1405312A8), 3); - utils::hook::set(game::select(0x14224DF8C, 0x1405316DC), 3); - - scheduler::once([] - { - game::register_dvar_string("password", "", game::DVAR_USERINFO, "password"); - }, scheduler::pipeline::main); - } - }; -} - -REGISTER_COMPONENT(patches::component) +#include +#include "loader/component_loader.hpp" + +#include +#include + +#include "network.hpp" +#include "scheduler.hpp" + +#include + +namespace patches +{ + namespace + { + utils::hook::detour sv_execute_client_messages_hook; + + void sv_execute_client_messages_stub(game::client_s* client, game::msg_t* msg) + { + if ((client->reliableSequence - client->reliableAcknowledge) < 0) + { + client->reliableAcknowledge = client->reliableSequence; + network::send(client->address, "error", "EXE_LOSTRELIABLECOMMANDS"); + return; + } + + sv_execute_client_messages_hook.invoke(client, msg); + } + + void script_errors_stub(const char* file, int line, unsigned int code, const char* fmt, ...) + { + char buffer[0x1000]; + + { + va_list ap; + va_start(ap, fmt); + vsnprintf_s(buffer, sizeof(buffer), _TRUNCATE, fmt, ap); + va_end(ap); + } + + game::Com_Error(game::ERROR_SCRIPT_DROP, "%s", buffer); + } + } + + struct component final : generic_component + { + void post_unpack() override + { + // don't make script errors fatal error + utils::hook::call(game::select(0x1412CAC4D, 0x140158EB2), script_errors_stub); + + // Change 4 character name limit to 3 characters + utils::hook::set(game::select(0x14224DA53, 0x140531143), 3); + utils::hook::set(game::select(0x14224DBB4, 0x1405312A8), 3); + utils::hook::set(game::select(0x14224DF8C, 0x1405316DC), 3); + + // make sure client's reliableAck are not negative + sv_execute_client_messages_hook.create(game::select(0x14224A460, 0x14052F840), sv_execute_client_messages_stub); + + scheduler::once([] + { + game::register_dvar_string("password", "", game::DVAR_USERINFO, "password"); + }, scheduler::pipeline::main); + } + }; +} + +REGISTER_COMPONENT(patches::component) diff --git a/src/client/component/server_list.cpp b/src/client/component/server_list.cpp index 332279ef..d699fbc0 100644 --- a/src/client/component/server_list.cpp +++ b/src/client/component/server_list.cpp @@ -1,93 +1,93 @@ -#include -#include "loader/component_loader.hpp" -#include "server_list.hpp" - -#include "game/game.hpp" - -#include +#include +#include "loader/component_loader.hpp" +#include "server_list.hpp" + +#include "game/game.hpp" + +#include +#include #include -#include - -#include "network.hpp" -#include "scheduler.hpp" - -namespace server_list -{ - namespace - { - utils::hook::detour lua_serverinfo_to_table_hook; - - struct state - { - game::netadr_t address{}; - bool requesting{false}; - std::chrono::high_resolution_clock::time_point query_start{}; - callback callback{}; - }; - + +#include "network.hpp" +#include "scheduler.hpp" + +namespace server_list +{ + namespace + { + utils::hook::detour lua_serverinfo_to_table_hook; + + struct state + { + game::netadr_t address{}; + bool requesting{false}; + std::chrono::high_resolution_clock::time_point query_start{}; + callback callback{}; + }; + utils::concurrency::container master_state; - utils::concurrency::container favorite_servers{}; - - void handle_server_list_response(const game::netadr_t& target, - const network::data_view& data, state& s) - { - if (!s.requesting || s.address != target) - { - return; - } - - s.requesting = false; - const auto callback = std::move(s.callback); - - std::optional start{}; - - for (size_t i = 0; i + 6 < data.size(); ++i) - { - if (data[i + 6] == '\\') - { - start.emplace(i); - break; - } - } - - if (!start.has_value()) - { - callback(true, {}); - return; - } - - std::unordered_set result{}; - - for (auto i = start.value(); i + 6 < data.size(); i += 7) - { - if (data[i + 6] != '\\') - { - break; - } - - game::netadr_t address{}; - address.type = game::NA_RAWIP; - address.localNetID = game::NS_CLIENT1; - memcpy(&address.ipv4.a, data.data() + i + 0, 4); - memcpy(&address.port, data.data() + i + 4, 2); - address.port = ntohs(address.port); - - result.emplace(address); - } - - callback(true, result); - } - - void lua_serverinfo_to_table_stub(game::hks::lua_State* state, game::ServerInfo serverInfo, int index) - { - lua_serverinfo_to_table_hook.invoke(state, serverInfo, index); - - if (state) - { - auto botCount = atoi(game::Info_ValueForKey(serverInfo.tags, "bots")); - game::Lua_SetTableInt("botCount", botCount, state); - } + utils::concurrency::container favorite_servers{}; + + void handle_server_list_response(const game::netadr_t& target, + const network::data_view& data, state& s) + { + if (!s.requesting || s.address != target) + { + return; + } + + s.requesting = false; + const auto callback = std::move(s.callback); + + std::optional start{}; + + for (size_t i = 0; i + 6 < data.size(); ++i) + { + if (data[i + 6] == '\\') + { + start.emplace(i); + break; + } + } + + if (!start.has_value()) + { + callback(true, {}); + return; + } + + std::unordered_set result{}; + + for (auto i = start.value(); i + 6 < data.size(); i += 7) + { + if (data[i + 6] != '\\') + { + break; + } + + game::netadr_t address{}; + address.type = game::NA_RAWIP; + address.localNetID = game::NS_CLIENT1; + memcpy(&address.ipv4.a, data.data() + i + 0, 4); + memcpy(&address.port, data.data() + i + 4, 2); + address.port = ntohs(address.port); + + result.emplace(address); + } + + callback(true, result); + } + + void lua_serverinfo_to_table_stub(game::hks::lua_State* state, game::ServerInfo serverInfo, int index) + { + lua_serverinfo_to_table_hook.invoke(state, serverInfo, index); + + if (state) + { + auto botCount = atoi(game::Info_ValueForKey(serverInfo.tags, "bots")); + game::Lua_SetTableInt("botCount", botCount, state); + } } std::string get_favorite_servers_file_path() @@ -97,14 +97,14 @@ namespace server_list void write_favorite_servers() { - favorite_servers.access([&](std::unordered_set& servers) + favorite_servers.access([&](std::unordered_set& servers) { - std::string servers_buffer = ""; + std::string servers_buffer = ""; for (auto itr : servers) { servers_buffer.append(utils::string::va("%i.%i.%i.%i:%u\n", itr.ipv4.a, itr.ipv4.b, itr.ipv4.c, itr.ipv4.d, itr.port)); } - utils::io::write_file(get_favorite_servers_file_path(), servers_buffer); + utils::io::write_file(get_favorite_servers_file_path(), servers_buffer); }); } @@ -116,8 +116,8 @@ namespace server_list return; } - favorite_servers.access([&path](std::unordered_set& servers) - { + favorite_servers.access([&path](std::unordered_set& servers) + { servers.clear(); std::string filedata; if (utils::io::read_file(path, &filedata)) @@ -126,51 +126,51 @@ namespace server_list for (auto server_address : srv) { auto server = network::address_from_string(server_address); - servers.insert(server); + servers.insert(server); } - } + } }); - } - } - - bool get_master_server(game::netadr_t& address) - { - address = network::address_from_string("server.boiii.re:20810"); - return address.type != game::NA_BAD; - } - - void request_servers(callback callback) - { - master_state.access([&callback](state& s) - { - game::netadr_t addr{}; - if (!get_master_server(addr)) - { - return; - } - - s.requesting = true; - s.address = addr; - s.callback = std::move(callback); - s.query_start = std::chrono::high_resolution_clock::now(); - - network::send(s.address, "getservers", utils::string::va("T7 %i full empty", PROTOCOL)); - }); + } + } + + bool get_master_server(game::netadr_t& address) + { + address = network::address_from_string("server.boiii.re:20810"); + return address.type != game::NA_BAD; + } + + void request_servers(callback callback) + { + master_state.access([&callback](state& s) + { + game::netadr_t addr{}; + if (!get_master_server(addr)) + { + return; + } + + s.requesting = true; + s.address = addr; + s.callback = std::move(callback); + s.query_start = std::chrono::high_resolution_clock::now(); + + network::send(s.address, "getservers", utils::string::va("T7 %i full empty", PROTOCOL)); + }); } void add_favorite_server(game::netadr_t addr) { - favorite_servers.access([&addr](std::unordered_set& servers) - { - servers.insert(addr); + favorite_servers.access([&addr](std::unordered_set& servers) + { + servers.insert(addr); }); write_favorite_servers(); } void remove_favorite_server(game::netadr_t addr) { - favorite_servers.access([&addr](std::unordered_set& servers) - { + favorite_servers.access([&addr](std::unordered_set& servers) + { for (auto it = servers.begin(); it != servers.end(); ++it) { if (network::are_addresses_equal(*it, addr)) @@ -178,7 +178,7 @@ namespace server_list servers.erase(it); break; } - } + } }); write_favorite_servers(); } @@ -187,57 +187,52 @@ namespace server_list { return favorite_servers; } - - struct component final : client_component - { - void post_unpack() override - { - network::on("getServersResponse", [](const game::netadr_t& target, const network::data_view& data) - { - master_state.access([&](state& s) - { - handle_server_list_response(target, data, s); - }); - }); - - scheduler::loop([] - { - master_state.access([](state& s) - { - if (!s.requesting) - { - return; - } - - const auto now = std::chrono::high_resolution_clock::now(); - if ((now - s.query_start) < 2s) - { - return; - } - - s.requesting = false; - s.callback(false, {}); - s.callback = {}; - }); - }, scheduler::async, 200ms); - - lua_serverinfo_to_table_hook.create(0x141F1FD10_g, lua_serverinfo_to_table_stub); - scheduler::once([] + struct component final : client_component + { + void post_unpack() override + { + network::on("getServersResponse", [](const game::netadr_t& target, const network::data_view& data) { - read_favorite_servers(); - }, scheduler::main); - } - - void pre_destroy() override - { - master_state.access([](state& s) - { - s.requesting = false; - s.callback = {}; - }); - } - }; -} - -REGISTER_COMPONENT(server_list::component) + master_state.access([&](state& s) + { + handle_server_list_response(target, data, s); + }); + }); + + scheduler::loop([] + { + master_state.access([](state& s) + { + if (!s.requesting) + { + return; + } + + const auto now = std::chrono::high_resolution_clock::now(); + if ((now - s.query_start) < 2s) + { + return; + } + + s.requesting = false; + s.callback(false, {}); + s.callback = {}; + }); + }, scheduler::async, 200ms); + + lua_serverinfo_to_table_hook.create(0x141F1FD10_g, lua_serverinfo_to_table_stub); + } + + void pre_destroy() override + { + master_state.access([](state& s) + { + s.requesting = false; + s.callback = {}; + }); + } + }; +} + +REGISTER_COMPONENT(server_list::component) diff --git a/src/client/game/structs.hpp b/src/client/game/structs.hpp index 424c59ac..5c13d86e 100644 --- a/src/client/game/structs.hpp +++ b/src/client/game/structs.hpp @@ -1,6 +1,7 @@ #pragma once -#define PROTOCOL 3 +#define PROTOCOL 4 +#define SUB_PROTOCOL 1 #ifdef __cplusplus namespace game @@ -1583,15 +1584,23 @@ namespace game int client_state; char __pad0[0x28]; netadr_t address; - char __pad1[0x5588]; + char __pad1[20468]; + int reliableSequence; + int reliableAcknowledge; + char __pad2[4]; + int messageAcknowledge; + char gap_5040[1416]; uint64_t xuid; - char __pad2[0xB5D84]; + char __pad3[0xB5D84]; int guid; - char __pad3[0x8]; + char __pad4[0x8]; bool bIsTestClient; - char __pad4[0x29DAC]; + char __pad5[3]; + int serverId; + char __pad6[171432]; }; + #ifdef __cplusplus static_assert(sizeof(client_s) == 0xE5110); diff --git a/src/client/game/symbols.hpp b/src/client/game/symbols.hpp index 36a82681..fbb93ad9 100644 --- a/src/client/game/symbols.hpp +++ b/src/client/game/symbols.hpp @@ -78,6 +78,8 @@ namespace game // G WEAK symbol G_ClearVehicleInputs{0x1423812E0, 0x1405C1200}; + WEAK symbol StuckInClient{0x1415A8360, 0x14023BFE0}; + // Live WEAK symbol Live_GetConnectivityInformation{0x141E0C380}; diff --git a/src/client/game/utils.cpp b/src/client/game/utils.cpp index e374a73a..c61a4350 100644 --- a/src/client/game/utils.cpp +++ b/src/client/game/utils.cpp @@ -176,6 +176,30 @@ namespace game } } + + template + static bool access_client(T* client_states, const size_t index, const std::function& callback) + { + if (!client_states || !callback) + { + return false; + } + + if (index >= get_max_client_count()) + { + return false; + } + + auto& client = client_states[index]; + if (client.client_state <= 0) + { + return false; + } + + callback(client); + return true; + } + void foreach_client(const std::function& callback) { if (is_server()) @@ -214,4 +238,14 @@ namespace game callback(client); }); } + + bool access_connected_client(const size_t index, const std::function& callback) + { + if (is_server()) + { + return access_client(*svs_clients, index, callback); + } + + return access_client(*svs_clients_cl, index, callback); + } } diff --git a/src/client/game/utils.hpp b/src/client/game/utils.hpp index 09abd8e7..5bbc78c0 100644 --- a/src/client/game/utils.hpp +++ b/src/client/game/utils.hpp @@ -24,4 +24,6 @@ namespace game void foreach_connected_client(const std::function& callback); void foreach_connected_client(const std::function& callback); + + bool access_connected_client(size_t index, const std::function& callback); } diff --git a/src/client/std_include.hpp b/src/client/std_include.hpp index 59b83a41..422c5ed9 100644 --- a/src/client/std_include.hpp +++ b/src/client/std_include.hpp @@ -65,6 +65,7 @@ #endif #include +#include #include #include #include diff --git a/src/client/steam/interfaces/matchmaking_servers.cpp b/src/client/steam/interfaces/matchmaking_servers.cpp index e42d4a61..69eb3ef7 100644 --- a/src/client/steam/interfaces/matchmaking_servers.cpp +++ b/src/client/steam/interfaces/matchmaking_servers.cpp @@ -1,233 +1,235 @@ -#include -#include "../steam.hpp" - -#include "game/game.hpp" - -#include "component/party.hpp" -#include "component/network.hpp" -#include "component/server_list.hpp" - -#include -#include - -namespace steam -{ - namespace - { - struct server - { - bool handled{false}; - game::netadr_t address{}; - gameserveritem_t server_item{}; - }; - +#include +#include "../steam.hpp" + +#include "game/game.hpp" + +#include "component/party.hpp" +#include "component/network.hpp" +#include "component/server_list.hpp" + +#include +#include + +namespace steam +{ + namespace + { + struct server + { + bool handled{false}; + game::netadr_t address{}; + gameserveritem_t server_item{}; + }; + auto* const internet_request = reinterpret_cast(1); - auto* const favorites_request = reinterpret_cast(4); - - using servers = std::vector; - + auto* const favorites_request = reinterpret_cast(4); + + using servers = std::vector; + ::utils::concurrency::container internet_servers{}; - ::utils::concurrency::container favorites_servers{}; + ::utils::concurrency::container favorites_servers{}; std::atomic internet_response{}; - std::atomic favorites_response{}; - - gameserveritem_t create_server_item(const game::netadr_t& address, const ::utils::info_string& info, - const uint32_t ping, const bool success) - { - gameserveritem_t server{}; - server.m_NetAdr.m_usConnectionPort = address.port; - server.m_NetAdr.m_usQueryPort = address.port; - server.m_NetAdr.m_unIP = ntohl(address.addr); - server.m_nPing = static_cast(ping); - server.m_bHadSuccessfulResponse = success; - server.m_bDoNotRefresh = false; - ::utils::string::copy(server.m_szGameDir, ""); - ::utils::string::copy(server.m_szMap, info.get("mapname").data()); - ::utils::string::copy(server.m_szGameDescription, info.get("description").data()); - server.m_nAppID = 311210; - server.m_nPlayers = atoi(info.get("clients").data()); - server.m_nMaxPlayers = atoi(info.get("sv_maxclients").data()); - server.m_nBotPlayers = atoi(info.get("bots").data()); - server.m_bPassword = info.get("isPrivate") == "1"; - server.m_bSecure = true; - server.m_ulTimeLastPlayed = 0; - server.m_nServerVersion = 1000; - ::utils::string::copy(server.m_szServerName, info.get("hostname").data()); - - const auto playmode = info.get("playmode"); - const auto mode = game::eModes(std::atoi(playmode.data())); - - const auto* tags = ::utils::string::va( - R"(\gametype\%s\dedicated\%s\ranked\false\hardcore\%s\zombies\%s\playerCount\%d\bots\%d\modName\%s\)", - info.get("gametype").data(), + std::atomic favorites_response{}; + + gameserveritem_t create_server_item(const game::netadr_t& address, const ::utils::info_string& info, + const uint32_t ping, const bool success) + { + const auto sub_protocol = atoi(info.get("sub_protocol").data()); + + gameserveritem_t server{}; + server.m_NetAdr.m_usConnectionPort = address.port; + server.m_NetAdr.m_usQueryPort = address.port; + server.m_NetAdr.m_unIP = ntohl(address.addr); + server.m_nPing = static_cast(ping); + server.m_bHadSuccessfulResponse = success; + server.m_bDoNotRefresh = false; + ::utils::string::copy(server.m_szGameDir, ""); + ::utils::string::copy(server.m_szMap, info.get("mapname").data()); + ::utils::string::copy(server.m_szGameDescription, info.get("description").data()); + server.m_nAppID = (sub_protocol == SUB_PROTOCOL || sub_protocol == (SUB_PROTOCOL - 1)) ? 311210 : 0; + server.m_nPlayers = atoi(info.get("clients").data()); + server.m_nMaxPlayers = atoi(info.get("sv_maxclients").data()); + server.m_nBotPlayers = atoi(info.get("bots").data()); + server.m_bPassword = info.get("isPrivate") == "1"; + server.m_bSecure = true; + server.m_ulTimeLastPlayed = 0; + server.m_nServerVersion = 1000; + ::utils::string::copy(server.m_szServerName, info.get("hostname").data()); + + const auto playmode = info.get("playmode"); + const auto mode = game::eModes(std::atoi(playmode.data())); + + const auto* tags = ::utils::string::va( + R"(\gametype\%s\dedicated\%s\ranked\false\hardcore\%s\zombies\%s\playerCount\%d\bots\%d\modName\%s\)", + info.get("gametype").data(), info.get("dedicated") == "1" ? "true" : "false", - info.get("hc") == "1" ? "true" : "false", + info.get("hc") == "1" ? "true" : "false", mode == game::MODE_ZOMBIES ? "true" : "false", server.m_nPlayers, atoi(info.get("bots").data()), - info.get("modname").data()); - - ::utils::string::copy(server.m_szGameTags, tags); - server.m_steamID.bits = strtoull(info.get("xuid").data(), nullptr, 16); - - return server; - } - - void handle_server_respone(const bool success, const game::netadr_t& host, const ::utils::info_string& info, + info.get("modname").data()); + + ::utils::string::copy(server.m_szGameTags, tags); + server.m_steamID.bits = strtoull(info.get("xuid").data(), nullptr, 16); + + return server; + } + + void handle_server_respone(const bool success, const game::netadr_t& host, const ::utils::info_string& info, const uint32_t ping, ::utils::concurrency::container& server_list, - std::atomic& response, void* request) - { - bool all_handled = false; - std::optional index{}; - server_list.access([&](servers& srvs) - { - size_t i = 0; - for (; i < srvs.size(); ++i) - { - if (srvs[i].address == host) - { - break; - } - } - - if (i >= srvs.size()) - { - return; - } - - index = static_cast(i); - - auto& srv = srvs[i]; - srv.handled = true; - srv.server_item = create_server_item(host, info, ping, success); - - - for (const auto& entry : srvs) - { - if (!entry.handled) - { - return; - } - } - - all_handled = true; - }); - - const auto res = response.load(); - if (!index || !res) - { - return; - } - - if (success) - { - res->ServerResponded(request, *index); - } - else - { - res->ServerFailedToRespond(request, *index); - } - - if (all_handled) - { - res->RefreshComplete(request, eServerResponded); - } + std::atomic& response, void* request) + { + bool all_handled = false; + std::optional index{}; + server_list.access([&](servers& srvs) + { + size_t i = 0; + for (; i < srvs.size(); ++i) + { + if (srvs[i].address == host) + { + break; + } + } + + if (i >= srvs.size()) + { + return; + } + + index = static_cast(i); + + auto& srv = srvs[i]; + srv.handled = true; + srv.server_item = create_server_item(host, info, ping, success); + + + for (const auto& entry : srvs) + { + if (!entry.handled) + { + return; + } + } + + all_handled = true; + }); + + const auto res = response.load(); + if (!index || !res) + { + return; + } + + if (success) + { + res->ServerResponded(request, *index); + } + else + { + res->ServerFailedToRespond(request, *index); + } + + if (all_handled) + { + res->RefreshComplete(request, eServerResponded); + } } - void handle_internet_server_response(const bool success, const game::netadr_t& host, const ::utils::info_string& info, + void handle_internet_server_response(const bool success, const game::netadr_t& host, const ::utils::info_string& info, const uint32_t ping) - { - handle_server_respone(success, host, info, ping, internet_servers, internet_response, internet_request); + { + handle_server_respone(success, host, info, ping, internet_servers, internet_response, internet_request); } - void handle_favorites_server_response(const bool success, const game::netadr_t& host, const ::utils::info_string& info, + void handle_favorites_server_response(const bool success, const game::netadr_t& host, const ::utils::info_string& info, const uint32_t ping) - { - handle_server_respone(success, host, info, ping, favorites_servers, favorites_response, favorites_request); - } - - void ping_server(const game::netadr_t& server, party::query_callback callback) - { - party::query_server(server, callback); - } - } - - void* matchmaking_servers::RequestInternetServerList(unsigned int iApp, void** ppchFilters, unsigned int nFilters, - matchmaking_server_list_response* pRequestServersResponse) - { - internet_response = pRequestServersResponse; - - server_list::request_servers([](const bool success, const std::unordered_set& s) - { - const auto res = internet_response.load(); - if (!res) - { - return; - } - - if (!success) - { - res->RefreshComplete(internet_request, eServerFailedToRespond); - return; - } - - if (s.empty()) - { - res->RefreshComplete(internet_request, eNoServersListedOnMasterServer); - return; - } - - internet_servers.access([&s](servers& srvs) - { - srvs = {}; - srvs.reserve(s.size()); - - for (auto& address : s) - { - server new_server{}; - new_server.address = address; - new_server.server_item = create_server_item(address, {}, 0, false); - - srvs.push_back(new_server); - } - }); - - for (auto& srv : s) - { - ping_server(srv, handle_internet_server_response); - } - }); - - return internet_request; - } - - void* matchmaking_servers::RequestLANServerList(unsigned int iApp, - matchmaking_server_list_response* pRequestServersResponse) - { - return reinterpret_cast(2); - } - - void* matchmaking_servers::RequestFriendsServerList(unsigned int iApp, void** ppchFilters, unsigned int nFilters, - matchmaking_server_list_response* pRequestServersResponse) - { - return reinterpret_cast(3); - } - - void* matchmaking_servers::RequestFavoritesServerList(unsigned int iApp, void** ppchFilters, unsigned int nFilters, - matchmaking_server_list_response* pRequestServersResponse) - { + { + handle_server_respone(success, host, info, ping, favorites_servers, favorites_response, favorites_request); + } + + void ping_server(const game::netadr_t& server, party::query_callback callback) + { + party::query_server(server, callback); + } + } + + void* matchmaking_servers::RequestInternetServerList(unsigned int iApp, void** ppchFilters, unsigned int nFilters, + matchmaking_server_list_response* pRequestServersResponse) + { + internet_response = pRequestServersResponse; + + server_list::request_servers([](const bool success, const std::unordered_set& s) + { + const auto res = internet_response.load(); + if (!res) + { + return; + } + + if (!success) + { + res->RefreshComplete(internet_request, eServerFailedToRespond); + return; + } + + if (s.empty()) + { + res->RefreshComplete(internet_request, eNoServersListedOnMasterServer); + return; + } + + internet_servers.access([&s](servers& srvs) + { + srvs = {}; + srvs.reserve(s.size()); + + for (auto& address : s) + { + server new_server{}; + new_server.address = address; + new_server.server_item = create_server_item(address, {}, 0, false); + + srvs.push_back(new_server); + } + }); + + for (auto& srv : s) + { + ping_server(srv, handle_internet_server_response); + } + }); + + return internet_request; + } + + void* matchmaking_servers::RequestLANServerList(unsigned int iApp, + matchmaking_server_list_response* pRequestServersResponse) + { + return reinterpret_cast(2); + } + + void* matchmaking_servers::RequestFriendsServerList(unsigned int iApp, void** ppchFilters, unsigned int nFilters, + matchmaking_server_list_response* pRequestServersResponse) + { + return reinterpret_cast(3); + } + + void* matchmaking_servers::RequestFavoritesServerList(unsigned int iApp, void** ppchFilters, unsigned int nFilters, + matchmaking_server_list_response* pRequestServersResponse) + { favorites_response = pRequestServersResponse; auto& srvs = server_list::get_favorite_servers(); - srvs.access([&](std::unordered_set s) + srvs.access([&](std::unordered_set s) { const auto res = favorites_response.load(); if (!res) { return; } - + if (s.empty()) { res->RefreshComplete(favorites_request, eNoServersListedOnMasterServer); @@ -252,146 +254,145 @@ namespace steam for (auto& srv : s) { ping_server(srv, handle_favorites_server_response); - } + } }); - return favorites_request; - } - - void* matchmaking_servers::RequestHistoryServerList(unsigned int iApp, void** ppchFilters, unsigned int nFilters, - matchmaking_server_list_response* pRequestServersResponse) - { - return reinterpret_cast(5); - } - - void* matchmaking_servers::RequestSpectatorServerList(unsigned int iApp, void** ppchFilters, unsigned int nFilters, - matchmaking_server_list_response* pRequestServersResponse) - { - return reinterpret_cast(6); - } - - void matchmaking_servers::ReleaseRequest(void* hServerListRequest) - { - if (internet_request == hServerListRequest) - { - internet_response = nullptr; - } - if (favorites_request == hServerListRequest) - { - favorites_response = nullptr; - } - } - - gameserveritem_t* matchmaking_servers::GetServerDetails(void* hRequest, int iServer) - { - if (internet_request != hRequest && favorites_request != hRequest) - { - return nullptr; + return favorites_request; + } + + void* matchmaking_servers::RequestHistoryServerList(unsigned int iApp, void** ppchFilters, unsigned int nFilters, + matchmaking_server_list_response* pRequestServersResponse) + { + return reinterpret_cast(5); + } + + void* matchmaking_servers::RequestSpectatorServerList(unsigned int iApp, void** ppchFilters, unsigned int nFilters, + matchmaking_server_list_response* pRequestServersResponse) + { + return reinterpret_cast(6); + } + + void matchmaking_servers::ReleaseRequest(void* hServerListRequest) + { + if (internet_request == hServerListRequest) + { + internet_response = nullptr; + } + if (favorites_request == hServerListRequest) + { + favorites_response = nullptr; + } + } + + gameserveritem_t* matchmaking_servers::GetServerDetails(void* hRequest, int iServer) + { + if (internet_request != hRequest && favorites_request != hRequest) + { + return nullptr; } - auto servers_list = hRequest == favorites_request ? &favorites_servers : &internet_servers; - - static thread_local gameserveritem_t server_item{}; - return servers_list->access([iServer](const servers& s) -> gameserveritem_t* - { - if (iServer < 0 || static_cast(iServer) >= s.size()) - { - return nullptr; - } - - server_item = s[iServer].server_item; - return &server_item; - }); - } - - void matchmaking_servers::CancelQuery(void* hRequest) - { - } - - void matchmaking_servers::RefreshQuery(void* hRequest) - { - } - - bool matchmaking_servers::IsRefreshing(void* hRequest) - { - return false; - } - - int matchmaking_servers::GetServerCount(void* hRequest) - { - if (internet_request != hRequest && favorites_request != hRequest) - { - return 0; - } + auto& servers_list = hRequest == favorites_request ? favorites_servers : internet_servers; - auto servers_list = hRequest == favorites_request ? &favorites_servers : &internet_servers; - return servers_list->access([](const servers& s) - { - return static_cast(s.size()); - }); - } - - void matchmaking_servers::RefreshServer(void* hRequest, const int iServer) - { - if (internet_request != hRequest && favorites_request != hRequest) - { - return; - } - - std::optional address{}; - auto servers_list = hRequest == favorites_request ? &favorites_servers : &internet_servers; - servers_list->access([&](const servers& s) - { - if (iServer < 0 || static_cast(iServer) >= s.size()) - { - return; - } - - address = s[iServer].address; - }); - - if (address) + static thread_local gameserveritem_t server_item{}; + return servers_list.access([iServer](const servers& s) -> gameserveritem_t* { + if (iServer < 0 || static_cast(iServer) >= s.size()) + { + return nullptr; + } + + server_item = s[iServer].server_item; + return &server_item; + }); + } + + void matchmaking_servers::CancelQuery(void* hRequest) + { + } + + void matchmaking_servers::RefreshQuery(void* hRequest) + { + } + + bool matchmaking_servers::IsRefreshing(void* hRequest) + { + return false; + } + + int matchmaking_servers::GetServerCount(void* hRequest) + { + if (internet_request != hRequest && favorites_request != hRequest) { - auto callback = hRequest == favorites_request ? handle_favorites_server_response : handle_internet_server_response; - ping_server(*address, callback); - } - } - - void* matchmaking_servers::PingServer(const unsigned int unIP, const unsigned short usPort, - matchmaking_ping_response* pRequestServersResponse) - { - auto response = pRequestServersResponse; - const auto addr = network::address_from_ip(htonl(unIP), usPort); - - party::query_server( - addr, [response](const bool success, const game::netadr_t& host, const ::utils::info_string& info, - const uint32_t ping) - { - if (success) - { - auto server_item = create_server_item(host, info, ping, success); - response->ServerResponded(server_item); - } - else - { - response->ServerFailedToRespond(); - } - }); - - return reinterpret_cast(static_cast(7 + rand())); - } - - int matchmaking_servers::PlayerDetails(unsigned int unIP, unsigned short usPort, void* pRequestServersResponse) - { - return 0; - } - - int matchmaking_servers::ServerRules(unsigned int unIP, unsigned short usPort, void* pRequestServersResponse) - { - return 0; - } - - void matchmaking_servers::CancelServerQuery(int hServerQuery) - { - } -} + return 0; + } + + auto& servers_list = hRequest == favorites_request ? favorites_servers : internet_servers; + return servers_list.access([](const servers& s) + { + return static_cast(s.size()); + }); + } + + void matchmaking_servers::RefreshServer(void* hRequest, const int iServer) + { + if (internet_request != hRequest && favorites_request != hRequest) + { + return; + } + + std::optional address{}; + auto& servers_list = hRequest == favorites_request ? favorites_servers : internet_servers; + servers_list.access([&](const servers& s) + { + if (iServer < 0 || static_cast(iServer) >= s.size()) + { + return; + } + + address = s[iServer].address; + }); + + if (address) + { + auto callback = hRequest == favorites_request ? handle_favorites_server_response : handle_internet_server_response; + ping_server(*address, callback); + } + } + + void* matchmaking_servers::PingServer(const unsigned int unIP, const unsigned short usPort, + matchmaking_ping_response* pRequestServersResponse) + { + auto response = pRequestServersResponse; + const auto addr = network::address_from_ip(htonl(unIP), usPort); + + party::query_server( + addr, [response](const bool success, const game::netadr_t& host, const ::utils::info_string& info, + const uint32_t ping) + { + if (success) + { + auto server_item = create_server_item(host, info, ping, success); + response->ServerResponded(server_item); + } + else + { + response->ServerFailedToRespond(); + } + }); + + return reinterpret_cast(static_cast(7 + rand())); + } + + int matchmaking_servers::PlayerDetails(unsigned int unIP, unsigned short usPort, void* pRequestServersResponse) + { + return 0; + } + + int matchmaking_servers::ServerRules(unsigned int unIP, unsigned short usPort, void* pRequestServersResponse) + { + return 0; + } + + void matchmaking_servers::CancelServerQuery(int hServerQuery) + { + } +} diff --git a/src/client/updater/file_updater.cpp b/src/client/updater/file_updater.cpp index bee3cf86..f68b6d2d 100644 --- a/src/client/updater/file_updater.cpp +++ b/src/client/updater/file_updater.cpp @@ -200,7 +200,11 @@ namespace updater throw; } - utils::nt::relaunch_self(); + if (!utils::flags::has_flag("norelaunch")) + { + utils::nt::relaunch_self(); + } + throw update_cancelled(); } diff --git a/src/common/utils/cryptography.cpp b/src/common/utils/cryptography.cpp index 98f61550..824cb9a7 100644 --- a/src/common/utils/cryptography.cpp +++ b/src/common/utils/cryptography.cpp @@ -229,7 +229,20 @@ namespace utils::cryptography if (ecc_export(buffer, &length, type, &this->key_storage_) == CRYPT_OK) { - return std::string(cs(buffer), length); + return {cs(buffer), length}; + } + + return ""; + } + + std::string ecc::key::get_openssl() const + { + uint8_t buffer[4096] = {0}; + unsigned long length = sizeof(buffer); + + if (ecc_export_openssl(buffer, &length, PK_PUBLIC, &this->key_storage_) == CRYPT_OK) + { + return {cs(buffer), length}; } return ""; diff --git a/src/common/utils/cryptography.hpp b/src/common/utils/cryptography.hpp index 9538c5eb..456a950b 100644 --- a/src/common/utils/cryptography.hpp +++ b/src/common/utils/cryptography.hpp @@ -31,6 +31,8 @@ namespace utils::cryptography std::string serialize(int type = PK_PRIVATE) const; + std::string get_openssl() const; + void free(); bool operator==(key& key) const;