ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Netplay: Rename variable names in NetSettings to match style guide.

This commit is contained in:
Admiral H. Curtiss 2022-09-19 01:18:26 +02:00
parent 07f86446a6
commit bec4850fc3
No known key found for this signature in database
GPG Key ID: F051B4C4044F33FB
6 changed files with 372 additions and 373 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Source/Core/Core/BootManager.cpp
View File

@ -91,7 +91,7 @@ bool BootCore(std::unique_ptr<BootParameters> boot, const WindowSystemInfo& wsi)
return false;
Config::AddLayer(ConfigLoaders::GenerateNetPlayConfigLoader(*netplay_settings));
StartUp.bCopyWiiSaveNetplay = netplay_settings->m_CopyWiiSave;
StartUp.bCopyWiiSaveNetplay = netplay_settings->copy_wii_save;
}
else
{

138
Source/Core/Core/ConfigLoaders/NetPlayConfigLoader.cpp
View File

@ -30,99 +30,99 @@ public:
void Load(Config::Layer* layer) override
{
layer->Set(Config::MAIN_CPU_THREAD, m_settings.m_CPUthread);
layer->Set(Config::MAIN_CPU_CORE, m_settings.m_CPUcore);
layer->Set(Config::MAIN_ENABLE_CHEATS, m_settings.m_EnableCheats);
layer->Set(Config::MAIN_GC_LANGUAGE, m_settings.m_SelectedLanguage);
layer->Set(Config::MAIN_OVERRIDE_REGION_SETTINGS, m_settings.m_OverrideRegionSettings);
layer->Set(Config::MAIN_DSP_HLE, m_settings.m_DSPHLE);
layer->Set(Config::MAIN_OVERCLOCK_ENABLE, m_settings.m_OCEnable);
layer->Set(Config::MAIN_OVERCLOCK, m_settings.m_OCFactor);
layer->Set(Config::MAIN_CPU_THREAD, m_settings.cpu_thread);
layer->Set(Config::MAIN_CPU_CORE, m_settings.cpu_core);
layer->Set(Config::MAIN_ENABLE_CHEATS, m_settings.enable_cheats);
layer->Set(Config::MAIN_GC_LANGUAGE, m_settings.selected_language);
layer->Set(Config::MAIN_OVERRIDE_REGION_SETTINGS, m_settings.override_region_settings);
layer->Set(Config::MAIN_DSP_HLE, m_settings.dsp_hle);
layer->Set(Config::MAIN_OVERCLOCK_ENABLE, m_settings.oc_enable);
layer->Set(Config::MAIN_OVERCLOCK, m_settings.oc_factor);
for (ExpansionInterface::Slot slot : ExpansionInterface::SLOTS)
layer->Set(Config::GetInfoForEXIDevice(slot), m_settings.m_EXIDevice[slot]);
layer->Set(Config::MAIN_MEMORY_CARD_SIZE, m_settings.m_MemcardSizeOverride);
layer->Set(Config::SESSION_SAVE_DATA_WRITABLE, m_settings.m_WriteToMemcard);
layer->Set(Config::MAIN_RAM_OVERRIDE_ENABLE, m_settings.m_RAMOverrideEnable);
layer->Set(Config::MAIN_MEM1_SIZE, m_settings.m_Mem1Size);
layer->Set(Config::MAIN_MEM2_SIZE, m_settings.m_Mem2Size);
layer->Set(Config::MAIN_FALLBACK_REGION, m_settings.m_FallbackRegion);
layer->Set(Config::MAIN_ALLOW_SD_WRITES, m_settings.m_AllowSDWrites);
layer->Set(Config::MAIN_DSP_JIT, m_settings.m_DSPEnableJIT);
layer->Set(Config::GetInfoForEXIDevice(slot), m_settings.exi_device[slot]);
layer->Set(Config::MAIN_MEMORY_CARD_SIZE, m_settings.memcard_size_override);
layer->Set(Config::SESSION_SAVE_DATA_WRITABLE, m_settings.write_to_memcard);
layer->Set(Config::MAIN_RAM_OVERRIDE_ENABLE, m_settings.ram_override_enable);
layer->Set(Config::MAIN_MEM1_SIZE, m_settings.mem1_size);
layer->Set(Config::MAIN_MEM2_SIZE, m_settings.mem2_size);
layer->Set(Config::MAIN_FALLBACK_REGION, m_settings.fallback_region);
layer->Set(Config::MAIN_ALLOW_SD_WRITES, m_settings.allow_sd_writes);
layer->Set(Config::MAIN_DSP_JIT, m_settings.dsp_enable_jit);
for (size_t i = 0; i < Config::SYSCONF_SETTINGS.size(); ++i)
{
std::visit(
[&](auto* info) {
layer->Set(*info, static_cast<decltype(info->GetDefaultValue())>(
m_settings.m_SYSCONFSettings[i]));
m_settings.sysconf_settings[i]));
},
Config::SYSCONF_SETTINGS[i].config_info);
}
layer->Set(Config::GFX_HACK_EFB_ACCESS_ENABLE, m_settings.m_EFBAccessEnable);
layer->Set(Config::GFX_HACK_BBOX_ENABLE, m_settings.m_BBoxEnable);
layer->Set(Config::GFX_HACK_FORCE_PROGRESSIVE, m_settings.m_ForceProgressive);
layer->Set(Config::GFX_HACK_SKIP_EFB_COPY_TO_RAM, m_settings.m_EFBToTextureEnable);
layer->Set(Config::GFX_HACK_SKIP_XFB_COPY_TO_RAM, m_settings.m_XFBToTextureEnable);
layer->Set(Config::GFX_HACK_DISABLE_COPY_TO_VRAM, m_settings.m_DisableCopyToVRAM);
layer->Set(Config::GFX_HACK_IMMEDIATE_XFB, m_settings.m_ImmediateXFBEnable);
layer->Set(Config::GFX_HACK_EFB_EMULATE_FORMAT_CHANGES, m_settings.m_EFBEmulateFormatChanges);
layer->Set(Config::GFX_HACK_EFB_ACCESS_ENABLE, m_settings.efb_access_enable);
layer->Set(Config::GFX_HACK_BBOX_ENABLE, m_settings.bbox_enable);
layer->Set(Config::GFX_HACK_FORCE_PROGRESSIVE, m_settings.force_progressive);
layer->Set(Config::GFX_HACK_SKIP_EFB_COPY_TO_RAM, m_settings.efb_to_texture_enable);
layer->Set(Config::GFX_HACK_SKIP_XFB_COPY_TO_RAM, m_settings.xfb_to_texture_enable);
layer->Set(Config::GFX_HACK_DISABLE_COPY_TO_VRAM, m_settings.disable_copy_to_vram);
layer->Set(Config::GFX_HACK_IMMEDIATE_XFB, m_settings.immediate_xfb_enable);
layer->Set(Config::GFX_HACK_EFB_EMULATE_FORMAT_CHANGES, m_settings.efb_emulate_format_changes);
layer->Set(Config::GFX_SAFE_TEXTURE_CACHE_COLOR_SAMPLES,
m_settings.m_SafeTextureCacheColorSamples);
layer->Set(Config::GFX_PERF_QUERIES_ENABLE, m_settings.m_PerfQueriesEnable);
layer->Set(Config::MAIN_FLOAT_EXCEPTIONS, m_settings.m_FloatExceptions);
layer->Set(Config::MAIN_DIVIDE_BY_ZERO_EXCEPTIONS, m_settings.m_DivideByZeroExceptions);
layer->Set(Config::MAIN_FPRF, m_settings.m_FPRF);
layer->Set(Config::MAIN_ACCURATE_NANS, m_settings.m_AccurateNaNs);
layer->Set(Config::MAIN_DISABLE_ICACHE, m_settings.m_DisableICache);
layer->Set(Config::MAIN_SYNC_ON_SKIP_IDLE, m_settings.m_SyncOnSkipIdle);
layer->Set(Config::MAIN_SYNC_GPU, m_settings.m_SyncGPU);
layer->Set(Config::MAIN_SYNC_GPU_MAX_DISTANCE, m_settings.m_SyncGpuMaxDistance);
layer->Set(Config::MAIN_SYNC_GPU_MIN_DISTANCE, m_settings.m_SyncGpuMinDistance);
layer->Set(Config::MAIN_SYNC_GPU_OVERCLOCK, m_settings.m_SyncGpuOverclock);
m_settings.safe_texture_cache_color_samples);
layer->Set(Config::GFX_PERF_QUERIES_ENABLE, m_settings.perf_queries_enable);
layer->Set(Config::MAIN_FLOAT_EXCEPTIONS, m_settings.float_exceptions);
layer->Set(Config::MAIN_DIVIDE_BY_ZERO_EXCEPTIONS, m_settings.divide_by_zero_exceptions);
layer->Set(Config::MAIN_FPRF, m_settings.fprf);
layer->Set(Config::MAIN_ACCURATE_NANS, m_settings.accurate_nans);
layer->Set(Config::MAIN_DISABLE_ICACHE, m_settings.disable_icache);
layer->Set(Config::MAIN_SYNC_ON_SKIP_IDLE, m_settings.sync_on_skip_idle);
layer->Set(Config::MAIN_SYNC_GPU, m_settings.sync_gpu);
layer->Set(Config::MAIN_SYNC_GPU_MAX_DISTANCE, m_settings.sync_gpu_max_distance);
layer->Set(Config::MAIN_SYNC_GPU_MIN_DISTANCE, m_settings.sync_gpu_min_distance);
layer->Set(Config::MAIN_SYNC_GPU_OVERCLOCK, m_settings.sync_gpu_overclock);
layer->Set(Config::MAIN_JIT_FOLLOW_BRANCH, m_settings.m_JITFollowBranch);
layer->Set(Config::MAIN_FAST_DISC_SPEED, m_settings.m_FastDiscSpeed);
layer->Set(Config::MAIN_MMU, m_settings.m_MMU);
layer->Set(Config::MAIN_FASTMEM, m_settings.m_Fastmem);
layer->Set(Config::MAIN_SKIP_IPL, m_settings.m_SkipIPL);
layer->Set(Config::SESSION_LOAD_IPL_DUMP, m_settings.m_LoadIPLDump);
layer->Set(Config::MAIN_JIT_FOLLOW_BRANCH, m_settings.jit_follow_branch);
layer->Set(Config::MAIN_FAST_DISC_SPEED, m_settings.fast_disc_speed);
layer->Set(Config::MAIN_MMU, m_settings.mmu);
layer->Set(Config::MAIN_FASTMEM, m_settings.fastmem);
layer->Set(Config::MAIN_SKIP_IPL, m_settings.skip_ipl);
layer->Set(Config::SESSION_LOAD_IPL_DUMP, m_settings.load_ipl_dump);
layer->Set(Config::GFX_HACK_DEFER_EFB_COPIES, m_settings.m_DeferEFBCopies);
layer->Set(Config::GFX_HACK_EFB_ACCESS_TILE_SIZE, m_settings.m_EFBAccessTileSize);
layer->Set(Config::GFX_HACK_EFB_DEFER_INVALIDATION, m_settings.m_EFBAccessDeferInvalidation);
layer->Set(Config::GFX_HACK_DEFER_EFB_COPIES, m_settings.defer_efb_copies);
layer->Set(Config::GFX_HACK_EFB_ACCESS_TILE_SIZE, m_settings.efb_access_tile_size);
layer->Set(Config::GFX_HACK_EFB_DEFER_INVALIDATION, m_settings.efb_access_defer_invalidation);
layer->Set(Config::SESSION_USE_FMA, m_settings.m_UseFMA);
layer->Set(Config::SESSION_USE_FMA, m_settings.use_fma);
layer->Set(Config::MAIN_BLUETOOTH_PASSTHROUGH_ENABLED, false);
if (m_settings.m_StrictSettingsSync)
if (m_settings.strict_settings_sync)
{
layer->Set(Config::GFX_HACK_VERTEX_ROUNDING, m_settings.m_VertexRounding);
layer->Set(Config::GFX_EFB_SCALE, m_settings.m_InternalResolution);
layer->Set(Config::GFX_HACK_COPY_EFB_SCALED, m_settings.m_EFBScaledCopy);
layer->Set(Config::GFX_FAST_DEPTH_CALC, m_settings.m_FastDepthCalc);
layer->Set(Config::GFX_ENABLE_PIXEL_LIGHTING, m_settings.m_EnablePixelLighting);
layer->Set(Config::GFX_WIDESCREEN_HACK, m_settings.m_WidescreenHack);
layer->Set(Config::GFX_ENHANCE_FORCE_FILTERING, m_settings.m_ForceFiltering);
layer->Set(Config::GFX_ENHANCE_MAX_ANISOTROPY, m_settings.m_MaxAnisotropy);
layer->Set(Config::GFX_ENHANCE_FORCE_TRUE_COLOR, m_settings.m_ForceTrueColor);
layer->Set(Config::GFX_ENHANCE_DISABLE_COPY_FILTER, m_settings.m_DisableCopyFilter);
layer->Set(Config::GFX_DISABLE_FOG, m_settings.m_DisableFog);
layer->Set(Config::GFX_HACK_VERTEX_ROUNDING, m_settings.vertex_rounding);
layer->Set(Config::GFX_EFB_SCALE, m_settings.internal_resolution);
layer->Set(Config::GFX_HACK_COPY_EFB_SCALED, m_settings.efb_scaled_copy);
layer->Set(Config::GFX_FAST_DEPTH_CALC, m_settings.fast_depth_calc);
layer->Set(Config::GFX_ENABLE_PIXEL_LIGHTING, m_settings.enable_pixel_lighting);
layer->Set(Config::GFX_WIDESCREEN_HACK, m_settings.widescreen_hack);
layer->Set(Config::GFX_ENHANCE_FORCE_FILTERING, m_settings.force_filtering);
layer->Set(Config::GFX_ENHANCE_MAX_ANISOTROPY, m_settings.max_anisotropy);
layer->Set(Config::GFX_ENHANCE_FORCE_TRUE_COLOR, m_settings.force_true_color);
layer->Set(Config::GFX_ENHANCE_DISABLE_COPY_FILTER, m_settings.disable_copy_filter);
layer->Set(Config::GFX_DISABLE_FOG, m_settings.disable_fog);
layer->Set(Config::GFX_ENHANCE_ARBITRARY_MIPMAP_DETECTION,
m_settings.m_ArbitraryMipmapDetection);
m_settings.arbitrary_mipmap_detection);
layer->Set(Config::GFX_ENHANCE_ARBITRARY_MIPMAP_DETECTION_THRESHOLD,
m_settings.m_ArbitraryMipmapDetectionThreshold);
layer->Set(Config::GFX_ENABLE_GPU_TEXTURE_DECODING, m_settings.m_EnableGPUTextureDecoding);
m_settings.arbitrary_mipmap_detection_threshold);
layer->Set(Config::GFX_ENABLE_GPU_TEXTURE_DECODING, m_settings.enable_gpu_texture_decoding);
// Disable AA as it isn't deterministic across GPUs
layer->Set(Config::GFX_MSAA, 1);
layer->Set(Config::GFX_SSAA, false);
}
if (m_settings.m_SyncSaveData)
if (m_settings.sync_save_data)
{
if (!m_settings.m_IsHosting)
if (!m_settings.is_hosting)
{
const std::string path = File::GetUserPath(D_GCUSER_IDX) + GC_MEMCARD_NETPLAY DIR_SEP;
layer->Set(Config::MAIN_GCI_FOLDER_A_PATH_OVERRIDE, path + "Card A");
@ -130,7 +130,7 @@ public:
const auto make_memcard_path = [this](char letter) {
return fmt::format("{}{}{}.{}.raw", File::GetUserPath(D_GCUSER_IDX), GC_MEMCARD_NETPLAY,
letter, m_settings.m_SaveDataRegion);
letter, m_settings.save_data_region);
};
layer->Set(Config::MAIN_MEMCARD_A_PATH, make_memcard_path('A'));
layer->Set(Config::MAIN_MEMCARD_B_PATH, make_memcard_path('B'));
@ -140,14 +140,14 @@ public:
}
#ifdef HAS_LIBMGBA
for (size_t i = 0; i < m_settings.m_GBARomPaths.size(); ++i)
for (size_t i = 0; i < m_settings.gba_rom_paths.size(); ++i)
{
layer->Set(Config::MAIN_GBA_ROM_PATHS[i], m_settings.m_GBARomPaths[i]);
layer->Set(Config::MAIN_GBA_ROM_PATHS[i], m_settings.gba_rom_paths[i]);
}
#endif
// Check To Override Client's Cheat Codes
if (m_settings.m_SyncCodes && !m_settings.m_IsHosting)
if (m_settings.sync_codes && !m_settings.is_hosting)
{
// Raise flag to use host's codes
layer->Set(Config::SESSION_CODE_SYNC_OVERRIDE, true);

162
Source/Core/Core/NetPlayClient.cpp
View File

@ -635,7 +635,7 @@ void NetPlayClient::OnGBAConfig(sf::Packet& packet)
std::tie(old_config.has_rom, old_config.title, old_config.hash))
{
m_dialog->OnMsgChangeGBARom(static_cast<int>(i), config);
m_net_settings.m_GBARomPaths[i] =
m_net_settings.gba_rom_paths[i] =
config.has_rom ?
m_dialog->FindGBARomPath(config.hash, config.title, static_cast<int>(i)) :
"";
@ -809,91 +809,91 @@ void NetPlayClient::OnStartGame(sf::Packet& packet)
INFO_LOG_FMT(NETPLAY, "Start of game {}", m_selected_game.game_id);
packet >> m_current_game;
packet >> m_net_settings.m_CPUthread;
packet >> m_net_settings.m_CPUcore;
packet >> m_net_settings.m_EnableCheats;
packet >> m_net_settings.m_SelectedLanguage;
packet >> m_net_settings.m_OverrideRegionSettings;
packet >> m_net_settings.m_DSPEnableJIT;
packet >> m_net_settings.m_DSPHLE;
packet >> m_net_settings.m_WriteToMemcard;
packet >> m_net_settings.m_RAMOverrideEnable;
packet >> m_net_settings.m_Mem1Size;
packet >> m_net_settings.m_Mem2Size;
packet >> m_net_settings.m_FallbackRegion;
packet >> m_net_settings.m_AllowSDWrites;
packet >> m_net_settings.m_CopyWiiSave;
packet >> m_net_settings.m_OCEnable;
packet >> m_net_settings.m_OCFactor;
packet >> m_net_settings.cpu_thread;
packet >> m_net_settings.cpu_core;
packet >> m_net_settings.enable_cheats;
packet >> m_net_settings.selected_language;
packet >> m_net_settings.override_region_settings;
packet >> m_net_settings.dsp_enable_jit;
packet >> m_net_settings.dsp_hle;
packet >> m_net_settings.write_to_memcard;
packet >> m_net_settings.ram_override_enable;
packet >> m_net_settings.mem1_size;
packet >> m_net_settings.mem2_size;
packet >> m_net_settings.fallback_region;
packet >> m_net_settings.allow_sd_writes;
packet >> m_net_settings.copy_wii_save;
packet >> m_net_settings.oc_enable;
packet >> m_net_settings.oc_factor;
for (auto slot : ExpansionInterface::SLOTS)
packet >> m_net_settings.m_EXIDevice[slot];
packet >> m_net_settings.exi_device[slot];
packet >> m_net_settings.m_MemcardSizeOverride;
packet >> m_net_settings.memcard_size_override;
for (u32& value : m_net_settings.m_SYSCONFSettings)
for (u32& value : m_net_settings.sysconf_settings)
packet >> value;
packet >> m_net_settings.m_EFBAccessEnable;
packet >> m_net_settings.m_BBoxEnable;
packet >> m_net_settings.m_ForceProgressive;
packet >> m_net_settings.m_EFBToTextureEnable;
packet >> m_net_settings.m_XFBToTextureEnable;
packet >> m_net_settings.m_DisableCopyToVRAM;
packet >> m_net_settings.m_ImmediateXFBEnable;
packet >> m_net_settings.m_EFBEmulateFormatChanges;
packet >> m_net_settings.m_SafeTextureCacheColorSamples;
packet >> m_net_settings.m_PerfQueriesEnable;
packet >> m_net_settings.m_FloatExceptions;
packet >> m_net_settings.m_DivideByZeroExceptions;
packet >> m_net_settings.m_FPRF;
packet >> m_net_settings.m_AccurateNaNs;
packet >> m_net_settings.m_DisableICache;
packet >> m_net_settings.m_SyncOnSkipIdle;
packet >> m_net_settings.m_SyncGPU;
packet >> m_net_settings.m_SyncGpuMaxDistance;
packet >> m_net_settings.m_SyncGpuMinDistance;
packet >> m_net_settings.m_SyncGpuOverclock;
packet >> m_net_settings.m_JITFollowBranch;
packet >> m_net_settings.m_FastDiscSpeed;
packet >> m_net_settings.m_MMU;
packet >> m_net_settings.m_Fastmem;
packet >> m_net_settings.m_SkipIPL;
packet >> m_net_settings.m_LoadIPLDump;
packet >> m_net_settings.m_VertexRounding;
packet >> m_net_settings.m_InternalResolution;
packet >> m_net_settings.m_EFBScaledCopy;
packet >> m_net_settings.m_FastDepthCalc;
packet >> m_net_settings.m_EnablePixelLighting;
packet >> m_net_settings.m_WidescreenHack;
packet >> m_net_settings.m_ForceFiltering;
packet >> m_net_settings.m_MaxAnisotropy;
packet >> m_net_settings.m_ForceTrueColor;
packet >> m_net_settings.m_DisableCopyFilter;
packet >> m_net_settings.m_DisableFog;
packet >> m_net_settings.m_ArbitraryMipmapDetection;
packet >> m_net_settings.m_ArbitraryMipmapDetectionThreshold;
packet >> m_net_settings.m_EnableGPUTextureDecoding;
packet >> m_net_settings.m_DeferEFBCopies;
packet >> m_net_settings.m_EFBAccessTileSize;
packet >> m_net_settings.m_EFBAccessDeferInvalidation;
packet >> m_net_settings.m_StrictSettingsSync;
packet >> m_net_settings.efb_access_enable;
packet >> m_net_settings.bbox_enable;
packet >> m_net_settings.force_progressive;
packet >> m_net_settings.efb_to_texture_enable;
packet >> m_net_settings.xfb_to_texture_enable;
packet >> m_net_settings.disable_copy_to_vram;
packet >> m_net_settings.immediate_xfb_enable;
packet >> m_net_settings.efb_emulate_format_changes;
packet >> m_net_settings.safe_texture_cache_color_samples;
packet >> m_net_settings.perf_queries_enable;
packet >> m_net_settings.float_exceptions;
packet >> m_net_settings.divide_by_zero_exceptions;
packet >> m_net_settings.fprf;
packet >> m_net_settings.accurate_nans;
packet >> m_net_settings.disable_icache;
packet >> m_net_settings.sync_on_skip_idle;
packet >> m_net_settings.sync_gpu;
packet >> m_net_settings.sync_gpu_max_distance;
packet >> m_net_settings.sync_gpu_min_distance;
packet >> m_net_settings.sync_gpu_overclock;
packet >> m_net_settings.jit_follow_branch;
packet >> m_net_settings.fast_disc_speed;
packet >> m_net_settings.mmu;
packet >> m_net_settings.fastmem;
packet >> m_net_settings.skip_ipl;
packet >> m_net_settings.load_ipl_dump;
packet >> m_net_settings.vertex_rounding;
packet >> m_net_settings.internal_resolution;
packet >> m_net_settings.efb_scaled_copy;
packet >> m_net_settings.fast_depth_calc;
packet >> m_net_settings.enable_pixel_lighting;
packet >> m_net_settings.widescreen_hack;
packet >> m_net_settings.force_filtering;
packet >> m_net_settings.max_anisotropy;
packet >> m_net_settings.force_true_color;
packet >> m_net_settings.disable_copy_filter;
packet >> m_net_settings.disable_fog;
packet >> m_net_settings.arbitrary_mipmap_detection;
packet >> m_net_settings.arbitrary_mipmap_detection_threshold;
packet >> m_net_settings.enable_gpu_texture_decoding;
packet >> m_net_settings.defer_efb_copies;
packet >> m_net_settings.efb_access_tile_size;
packet >> m_net_settings.efb_access_defer_invalidation;
packet >> m_net_settings.strict_settings_sync;
m_initial_rtc = Common::PacketReadU64(packet);
packet >> m_net_settings.m_SyncSaveData;
packet >> m_net_settings.m_SaveDataRegion;
packet >> m_net_settings.m_SyncCodes;
packet >> m_net_settings.m_SyncAllWiiSaves;
packet >> m_net_settings.sync_save_data;
packet >> m_net_settings.save_data_region;
packet >> m_net_settings.sync_codes;
packet >> m_net_settings.sync_all_wii_saves;
for (int& extension : m_net_settings.m_WiimoteExtension)
for (int& extension : m_net_settings.wiimote_extension)
packet >> extension;
packet >> m_net_settings.m_GolfMode;
packet >> m_net_settings.m_UseFMA;
packet >> m_net_settings.m_HideRemoteGBAs;
packet >> m_net_settings.golf_mode;
packet >> m_net_settings.use_fma;
packet >> m_net_settings.hide_remote_gbas;
m_net_settings.m_IsHosting = m_local_player->IsHost();
m_net_settings.is_hosting = m_local_player->IsHost();
}
m_dialog->OnMsgStartGame();
@ -2299,7 +2299,7 @@ void NetPlayClient::SendPowerButtonEvent()
void NetPlayClient::RequestGolfControl(const PlayerId pid)
{
if (!m_host_input_authority || !m_net_settings.m_GolfMode)
if (!m_host_input_authority || !m_net_settings.golf_mode)
return;
sf::Packet packet;
@ -2401,7 +2401,7 @@ void NetPlayClient::SendGameStatus()
for (size_t i = 0; i < 4; ++i)
{
if (m_gba_config[i].enabled && m_gba_config[i].has_rom &&
m_net_settings.m_GBARomPaths[i].empty())
m_net_settings.gba_rom_paths[i].empty())
{
result = SyncIdentifierComparison::DifferentGame;
}
@ -2591,7 +2591,7 @@ bool IsSyncingAllWiiSaves()
std::lock_guard lk(crit_netplay_client);
if (netplay_client)
return netplay_client->GetNetSettings().m_SyncAllWiiSaves;
return netplay_client->GetNetSettings().sync_all_wii_saves;
return false;
}
@ -2601,14 +2601,14 @@ void SetupWiimotes()
ASSERT(IsNetPlayRunning());
const NetSettings& netplay_settings = netplay_client->GetNetSettings();
const PadMappingArray& wiimote_map = netplay_client->GetWiimoteMapping();
for (size_t i = 0; i < netplay_settings.m_WiimoteExtension.size(); i++)
for (size_t i = 0; i < netplay_settings.wiimote_extension.size(); i++)
{
if (wiimote_map[i] > 0)
{
static_cast<ControllerEmu::Attachments*>(
static_cast<WiimoteEmu::Wiimote*>(Wiimote::GetConfig()->GetController(int(i)))
->GetWiimoteGroup(WiimoteEmu::WiimoteGroup::Attachments))
->SetSelectedAttachment(netplay_settings.m_WiimoteExtension[i]);
->SetSelectedAttachment(netplay_settings.wiimote_extension[i]);
}
}
}
@ -2617,7 +2617,7 @@ std::string GetGBASavePath(int pad_num)
{
std::lock_guard lk(crit_netplay_client);
if (!netplay_client || netplay_client->GetNetSettings().m_IsHosting)
if (!netplay_client || netplay_client->GetNetSettings().is_hosting)
{
#ifdef HAS_LIBMGBA
std::string rom_path = Config::Get(Config::MAIN_GBA_ROM_PATHS[pad_num]);
@ -2627,7 +2627,7 @@ std::string GetGBASavePath(int pad_num)
#endif
}
if (!netplay_client->GetNetSettings().m_SyncSaveData)
if (!netplay_client->GetNetSettings().sync_save_data)
return {};
return fmt::format("{}{}{}.sav", File::GetUserPath(D_GBAUSER_IDX), GBA_SAVE_NETPLAY, pad_num + 1);
@ -2663,7 +2663,7 @@ PadDetails GetPadDetails(int pad_num)
}
res.is_local = netplay_client->IsLocalPlayer(pad_map[pad_num]);
res.local_pad = res.is_local ? local_pad : netplay_client->NumLocalPads() + non_local_pad;
res.hide_gba = !res.is_local && netplay_client->GetNetSettings().m_HideRemoteGBAs &&
res.hide_gba = !res.is_local && netplay_client->GetNetSettings().hide_remote_gbas &&
netplay_client->LocalPlayerHasControllerMapped();
return res;
}

146
Source/Core/Core/NetPlayProto.h
View File

@ -30,84 +30,84 @@ namespace NetPlay
{
struct NetSettings
{
bool m_CPUthread = false;
PowerPC::CPUCore m_CPUcore{};
bool m_EnableCheats = false;
int m_SelectedLanguage = 0;
bool m_OverrideRegionSettings = false;
bool m_DSPHLE = false;
bool m_DSPEnableJIT = false;
bool m_WriteToMemcard = false;
bool m_RAMOverrideEnable = false;
u32 m_Mem1Size = 0;
u32 m_Mem2Size = 0;
DiscIO::Region m_FallbackRegion{};
bool m_AllowSDWrites = false;
bool m_CopyWiiSave = false;
bool m_OCEnable = false;
float m_OCFactor = 0;
Common::EnumMap<ExpansionInterface::EXIDeviceType, ExpansionInterface::MAX_SLOT> m_EXIDevice{};
int m_MemcardSizeOverride = -1;
bool cpu_thread = false;
PowerPC::CPUCore cpu_core{};
bool enable_cheats = false;
int selected_language = 0;
bool override_region_settings = false;
bool dsp_hle = false;
bool dsp_enable_jit = false;
bool write_to_memcard = false;
bool ram_override_enable = false;
u32 mem1_size = 0;
u32 mem2_size = 0;
DiscIO::Region fallback_region{};
bool allow_sd_writes = false;
bool copy_wii_save = false;
bool oc_enable = false;
float oc_factor = 0;
Common::EnumMap<ExpansionInterface::EXIDeviceType, ExpansionInterface::MAX_SLOT> exi_device{};
int memcard_size_override = -1;
std::array<u32, Config::SYSCONF_SETTINGS.size()> m_SYSCONFSettings{};
std::array<u32, Config::SYSCONF_SETTINGS.size()> sysconf_settings{};
bool m_EFBAccessEnable = false;
bool m_BBoxEnable = false;
bool m_ForceProgressive = false;
bool m_EFBToTextureEnable = false;
bool m_XFBToTextureEnable = false;
bool m_DisableCopyToVRAM = false;
bool m_ImmediateXFBEnable = false;
bool m_EFBEmulateFormatChanges = false;
int m_SafeTextureCacheColorSamples = 0;
bool m_PerfQueriesEnable = false;
bool m_FloatExceptions = false;
bool m_DivideByZeroExceptions = false;
bool m_FPRF = false;
bool m_AccurateNaNs = false;
bool m_DisableICache = false;
bool m_SyncOnSkipIdle = false;
bool m_SyncGPU = false;
int m_SyncGpuMaxDistance = 0;
int m_SyncGpuMinDistance = 0;
float m_SyncGpuOverclock = 0;
bool m_JITFollowBranch = false;
bool m_FastDiscSpeed = false;
bool m_MMU = false;
bool m_Fastmem = false;
bool m_SkipIPL = false;
bool m_LoadIPLDump = false;
bool m_VertexRounding = false;
int m_InternalResolution = 0;
bool m_EFBScaledCopy = false;
bool m_FastDepthCalc = false;
bool m_EnablePixelLighting = false;
bool m_WidescreenHack = false;
bool m_ForceFiltering = false;
int m_MaxAnisotropy = 0;
bool m_ForceTrueColor = false;
bool m_DisableCopyFilter = false;
bool m_DisableFog = false;
bool m_ArbitraryMipmapDetection = false;
float m_ArbitraryMipmapDetectionThreshold = 0;
bool m_EnableGPUTextureDecoding = false;
bool m_DeferEFBCopies = false;
int m_EFBAccessTileSize = 0;
bool m_EFBAccessDeferInvalidation = false;
bool efb_access_enable = false;
bool bbox_enable = false;
bool force_progressive = false;
bool efb_to_texture_enable = false;
bool xfb_to_texture_enable = false;
bool disable_copy_to_vram = false;
bool immediate_xfb_enable = false;
bool efb_emulate_format_changes = false;
int safe_texture_cache_color_samples = 0;
bool perf_queries_enable = false;
bool float_exceptions = false;
bool divide_by_zero_exceptions = false;
bool fprf = false;
bool accurate_nans = false;
bool disable_icache = false;
bool sync_on_skip_idle = false;
bool sync_gpu = false;
int sync_gpu_max_distance = 0;
int sync_gpu_min_distance = 0;
float sync_gpu_overclock = 0;
bool jit_follow_branch = false;
bool fast_disc_speed = false;
bool mmu = false;
bool fastmem = false;
bool skip_ipl = false;
bool load_ipl_dump = false;
bool vertex_rounding = false;
int internal_resolution = 0;
bool efb_scaled_copy = false;
bool fast_depth_calc = false;
bool enable_pixel_lighting = false;
bool widescreen_hack = false;
bool force_filtering = false;
int max_anisotropy = 0;
bool force_true_color = false;
bool disable_copy_filter = false;
bool disable_fog = false;
bool arbitrary_mipmap_detection = false;
float arbitrary_mipmap_detection_threshold = 0;
bool enable_gpu_texture_decoding = false;
bool defer_efb_copies = false;
int efb_access_tile_size = 0;
bool efb_access_defer_invalidation = false;
bool m_StrictSettingsSync = false;
bool m_SyncSaveData = false;
bool m_SyncCodes = false;
std::string m_SaveDataRegion;
bool m_SyncAllWiiSaves = false;
std::array<int, 4> m_WiimoteExtension{};
bool m_GolfMode = false;
bool m_UseFMA = false;
bool m_HideRemoteGBAs = false;
bool strict_settings_sync = false;
bool sync_save_data = false;
bool sync_codes = false;
std::string save_data_region;
bool sync_all_wii_saves = false;
std::array<int, 4> wiimote_extension{};
bool golf_mode = false;
bool use_fma = false;
bool hide_remote_gbas = false;
// These aren't sent over the network directly
bool m_IsHosting = false;
std::array<std::string, 4> m_GBARomPaths{};
bool is_hosting = false;
std::array<std::string, 4> gba_rom_paths{};
};
struct NetTraversalConfig

294
Source/Core/Core/NetPlayServer.cpp
View File

@ -862,7 +862,7 @@ unsigned int NetPlayServer::OnData(sf::Packet& packet, Client& player)
if (!m_players.count(pid) || !PlayerHasControllerMapped(player.pid))
break;
if (m_host_input_authority && m_settings.m_GolfMode && m_pending_golfer == 0 &&
if (m_host_input_authority && m_settings.golf_mode && m_pending_golfer == 0 &&
m_current_golfer != pid && PlayerHasControllerMapped(pid))
{
m_pending_golfer = pid;
@ -1254,22 +1254,22 @@ bool NetPlayServer::SetupNetSettings()
ConfigLoaders::GenerateLocalGameConfigLoader(game->GetGameID(), game->GetRevision()));
// Copy all relevant settings
settings.m_CPUthread = Config::Get(Config::MAIN_CPU_THREAD);
settings.m_CPUcore = Config::Get(Config::MAIN_CPU_CORE);
settings.m_EnableCheats = Config::Get(Config::MAIN_ENABLE_CHEATS);
settings.m_SelectedLanguage = Config::Get(Config::MAIN_GC_LANGUAGE);
settings.m_OverrideRegionSettings = Config::Get(Config::MAIN_OVERRIDE_REGION_SETTINGS);
settings.m_DSPHLE = Config::Get(Config::MAIN_DSP_HLE);
settings.m_DSPEnableJIT = Config::Get(Config::MAIN_DSP_JIT);
settings.m_WriteToMemcard = Config::Get(Config::NETPLAY_WRITE_SAVE_DATA);
settings.m_RAMOverrideEnable = Config::Get(Config::MAIN_RAM_OVERRIDE_ENABLE);
settings.m_Mem1Size = Config::Get(Config::MAIN_MEM1_SIZE);
settings.m_Mem2Size = Config::Get(Config::MAIN_MEM2_SIZE);
settings.m_FallbackRegion = Config::Get(Config::MAIN_FALLBACK_REGION);
settings.m_AllowSDWrites = Config::Get(Config::MAIN_ALLOW_SD_WRITES);
settings.m_CopyWiiSave = Config::Get(Config::NETPLAY_LOAD_WII_SAVE);
settings.m_OCEnable = Config::Get(Config::MAIN_OVERCLOCK_ENABLE);
settings.m_OCFactor = Config::Get(Config::MAIN_OVERCLOCK);
settings.cpu_thread = Config::Get(Config::MAIN_CPU_THREAD);
settings.cpu_core = Config::Get(Config::MAIN_CPU_CORE);
settings.enable_cheats = Config::Get(Config::MAIN_ENABLE_CHEATS);
settings.selected_language = Config::Get(Config::MAIN_GC_LANGUAGE);
settings.override_region_settings = Config::Get(Config::MAIN_OVERRIDE_REGION_SETTINGS);
settings.dsp_hle = Config::Get(Config::MAIN_DSP_HLE);
settings.dsp_enable_jit = Config::Get(Config::MAIN_DSP_JIT);
settings.write_to_memcard = Config::Get(Config::NETPLAY_WRITE_SAVE_DATA);
settings.ram_override_enable = Config::Get(Config::MAIN_RAM_OVERRIDE_ENABLE);
settings.mem1_size = Config::Get(Config::MAIN_MEM1_SIZE);
settings.mem2_size = Config::Get(Config::MAIN_MEM2_SIZE);
settings.fallback_region = Config::Get(Config::MAIN_FALLBACK_REGION);
settings.allow_sd_writes = Config::Get(Config::MAIN_ALLOW_SD_WRITES);
settings.copy_wii_save = Config::Get(Config::NETPLAY_LOAD_WII_SAVE);
settings.oc_enable = Config::Get(Config::MAIN_OVERCLOCK_ENABLE);
settings.oc_factor = Config::Get(Config::MAIN_OVERCLOCK);
for (ExpansionInterface::Slot slot : ExpansionInterface::SLOTS)
{
@ -1283,75 +1283,75 @@ bool NetPlayServer::SetupNetSettings()
{
device = Config::Get(Config::GetInfoForEXIDevice(slot));
}
settings.m_EXIDevice[slot] = device;
settings.exi_device[slot] = device;
}
settings.m_MemcardSizeOverride = Config::Get(Config::MAIN_MEMORY_CARD_SIZE);
settings.memcard_size_override = Config::Get(Config::MAIN_MEMORY_CARD_SIZE);
for (size_t i = 0; i < Config::SYSCONF_SETTINGS.size(); ++i)
{
std::visit(
[&](auto* info) {
static_assert(sizeof(info->GetDefaultValue()) <= sizeof(u32));
settings.m_SYSCONFSettings[i] = static_cast<u32>(Config::Get(*info));
settings.sysconf_settings[i] = static_cast<u32>(Config::Get(*info));
},
Config::SYSCONF_SETTINGS[i].config_info);
}
settings.m_EFBAccessEnable = Config::Get(Config::GFX_HACK_EFB_ACCESS_ENABLE);
settings.m_BBoxEnable = Config::Get(Config::GFX_HACK_BBOX_ENABLE);
settings.m_ForceProgressive = Config::Get(Config::GFX_HACK_FORCE_PROGRESSIVE);
settings.m_EFBToTextureEnable = Config::Get(Config::GFX_HACK_SKIP_EFB_COPY_TO_RAM);
settings.m_XFBToTextureEnable = Config::Get(Config::GFX_HACK_SKIP_XFB_COPY_TO_RAM);
settings.m_DisableCopyToVRAM = Config::Get(Config::GFX_HACK_DISABLE_COPY_TO_VRAM);
settings.m_ImmediateXFBEnable = Config::Get(Config::GFX_HACK_IMMEDIATE_XFB);
settings.m_EFBEmulateFormatChanges = Config::Get(Config::GFX_HACK_EFB_EMULATE_FORMAT_CHANGES);
settings.m_SafeTextureCacheColorSamples =
settings.efb_access_enable = Config::Get(Config::GFX_HACK_EFB_ACCESS_ENABLE);
settings.bbox_enable = Config::Get(Config::GFX_HACK_BBOX_ENABLE);
settings.force_progressive = Config::Get(Config::GFX_HACK_FORCE_PROGRESSIVE);
settings.efb_to_texture_enable = Config::Get(Config::GFX_HACK_SKIP_EFB_COPY_TO_RAM);
settings.xfb_to_texture_enable = Config::Get(Config::GFX_HACK_SKIP_XFB_COPY_TO_RAM);
settings.disable_copy_to_vram = Config::Get(Config::GFX_HACK_DISABLE_COPY_TO_VRAM);
settings.immediate_xfb_enable = Config::Get(Config::GFX_HACK_IMMEDIATE_XFB);
settings.efb_emulate_format_changes = Config::Get(Config::GFX_HACK_EFB_EMULATE_FORMAT_CHANGES);
settings.safe_texture_cache_color_samples =
Config::Get(Config::GFX_SAFE_TEXTURE_CACHE_COLOR_SAMPLES);
settings.m_PerfQueriesEnable = Config::Get(Config::GFX_PERF_QUERIES_ENABLE);
settings.m_FloatExceptions = Config::Get(Config::MAIN_FLOAT_EXCEPTIONS);
settings.m_DivideByZeroExceptions = Config::Get(Config::MAIN_DIVIDE_BY_ZERO_EXCEPTIONS);
settings.m_FPRF = Config::Get(Config::MAIN_FPRF);
settings.m_AccurateNaNs = Config::Get(Config::MAIN_ACCURATE_NANS);
settings.m_DisableICache = Config::Get(Config::MAIN_DISABLE_ICACHE);
settings.m_SyncOnSkipIdle = Config::Get(Config::MAIN_SYNC_ON_SKIP_IDLE);
settings.m_SyncGPU = Config::Get(Config::MAIN_SYNC_GPU);
settings.m_SyncGpuMaxDistance = Config::Get(Config::MAIN_SYNC_GPU_MAX_DISTANCE);
settings.m_SyncGpuMinDistance = Config::Get(Config::MAIN_SYNC_GPU_MIN_DISTANCE);
settings.m_SyncGpuOverclock = Config::Get(Config::MAIN_SYNC_GPU_OVERCLOCK);
settings.m_JITFollowBranch = Config::Get(Config::MAIN_JIT_FOLLOW_BRANCH);
settings.m_FastDiscSpeed = Config::Get(Config::MAIN_FAST_DISC_SPEED);
settings.m_MMU = Config::Get(Config::MAIN_MMU);
settings.m_Fastmem = Config::Get(Config::MAIN_FASTMEM);
settings.m_SkipIPL = Config::Get(Config::MAIN_SKIP_IPL) || !DoAllPlayersHaveIPLDump();
settings.m_LoadIPLDump = Config::Get(Config::SESSION_LOAD_IPL_DUMP) && DoAllPlayersHaveIPLDump();
settings.m_VertexRounding = Config::Get(Config::GFX_HACK_VERTEX_ROUNDING);
settings.m_InternalResolution = Config::Get(Config::GFX_EFB_SCALE);
settings.m_EFBScaledCopy = Config::Get(Config::GFX_HACK_COPY_EFB_SCALED);
settings.m_FastDepthCalc = Config::Get(Config::GFX_FAST_DEPTH_CALC);
settings.m_EnablePixelLighting = Config::Get(Config::GFX_ENABLE_PIXEL_LIGHTING);
settings.m_WidescreenHack = Config::Get(Config::GFX_WIDESCREEN_HACK);
settings.m_ForceFiltering = Config::Get(Config::GFX_ENHANCE_FORCE_FILTERING);
settings.m_MaxAnisotropy = Config::Get(Config::GFX_ENHANCE_MAX_ANISOTROPY);
settings.m_ForceTrueColor = Config::Get(Config::GFX_ENHANCE_FORCE_TRUE_COLOR);
settings.m_DisableCopyFilter = Config::Get(Config::GFX_ENHANCE_DISABLE_COPY_FILTER);
settings.m_DisableFog = Config::Get(Config::GFX_DISABLE_FOG);
settings.m_ArbitraryMipmapDetection = Config::Get(Config::GFX_ENHANCE_ARBITRARY_MIPMAP_DETECTION);
settings.m_ArbitraryMipmapDetectionThreshold =
settings.perf_queries_enable = Config::Get(Config::GFX_PERF_QUERIES_ENABLE);
settings.float_exceptions = Config::Get(Config::MAIN_FLOAT_EXCEPTIONS);
settings.divide_by_zero_exceptions = Config::Get(Config::MAIN_DIVIDE_BY_ZERO_EXCEPTIONS);
settings.fprf = Config::Get(Config::MAIN_FPRF);
settings.accurate_nans = Config::Get(Config::MAIN_ACCURATE_NANS);
settings.disable_icache = Config::Get(Config::MAIN_DISABLE_ICACHE);
settings.sync_on_skip_idle = Config::Get(Config::MAIN_SYNC_ON_SKIP_IDLE);
settings.sync_gpu = Config::Get(Config::MAIN_SYNC_GPU);
settings.sync_gpu_max_distance = Config::Get(Config::MAIN_SYNC_GPU_MAX_DISTANCE);
settings.sync_gpu_min_distance = Config::Get(Config::MAIN_SYNC_GPU_MIN_DISTANCE);
settings.sync_gpu_overclock = Config::Get(Config::MAIN_SYNC_GPU_OVERCLOCK);
settings.jit_follow_branch = Config::Get(Config::MAIN_JIT_FOLLOW_BRANCH);
settings.fast_disc_speed = Config::Get(Config::MAIN_FAST_DISC_SPEED);
settings.mmu = Config::Get(Config::MAIN_MMU);
settings.fastmem = Config::Get(Config::MAIN_FASTMEM);
settings.skip_ipl = Config::Get(Config::MAIN_SKIP_IPL) || !DoAllPlayersHaveIPLDump();
settings.load_ipl_dump = Config::Get(Config::SESSION_LOAD_IPL_DUMP) && DoAllPlayersHaveIPLDump();
settings.vertex_rounding = Config::Get(Config::GFX_HACK_VERTEX_ROUNDING);
settings.internal_resolution = Config::Get(Config::GFX_EFB_SCALE);
settings.efb_scaled_copy = Config::Get(Config::GFX_HACK_COPY_EFB_SCALED);
settings.fast_depth_calc = Config::Get(Config::GFX_FAST_DEPTH_CALC);
settings.enable_pixel_lighting = Config::Get(Config::GFX_ENABLE_PIXEL_LIGHTING);
settings.widescreen_hack = Config::Get(Config::GFX_WIDESCREEN_HACK);
settings.force_filtering = Config::Get(Config::GFX_ENHANCE_FORCE_FILTERING);
settings.max_anisotropy = Config::Get(Config::GFX_ENHANCE_MAX_ANISOTROPY);
settings.force_true_color = Config::Get(Config::GFX_ENHANCE_FORCE_TRUE_COLOR);
settings.disable_copy_filter = Config::Get(Config::GFX_ENHANCE_DISABLE_COPY_FILTER);
settings.disable_fog = Config::Get(Config::GFX_DISABLE_FOG);
settings.arbitrary_mipmap_detection = Config::Get(Config::GFX_ENHANCE_ARBITRARY_MIPMAP_DETECTION);
settings.arbitrary_mipmap_detection_threshold =
Config::Get(Config::GFX_ENHANCE_ARBITRARY_MIPMAP_DETECTION_THRESHOLD);
settings.m_EnableGPUTextureDecoding = Config::Get(Config::GFX_ENABLE_GPU_TEXTURE_DECODING);
settings.m_DeferEFBCopies = Config::Get(Config::GFX_HACK_DEFER_EFB_COPIES);
settings.m_EFBAccessTileSize = Config::Get(Config::GFX_HACK_EFB_ACCESS_TILE_SIZE);
settings.m_EFBAccessDeferInvalidation = Config::Get(Config::GFX_HACK_EFB_DEFER_INVALIDATION);
settings.enable_gpu_texture_decoding = Config::Get(Config::GFX_ENABLE_GPU_TEXTURE_DECODING);
settings.defer_efb_copies = Config::Get(Config::GFX_HACK_DEFER_EFB_COPIES);
settings.efb_access_tile_size = Config::Get(Config::GFX_HACK_EFB_ACCESS_TILE_SIZE);
settings.efb_access_defer_invalidation = Config::Get(Config::GFX_HACK_EFB_DEFER_INVALIDATION);
settings.m_StrictSettingsSync = Config::Get(Config::NETPLAY_STRICT_SETTINGS_SYNC);
settings.m_SyncSaveData = Config::Get(Config::NETPLAY_SYNC_SAVES);
settings.m_SyncCodes = Config::Get(Config::NETPLAY_SYNC_CODES);
settings.m_SyncAllWiiSaves =
settings.strict_settings_sync = Config::Get(Config::NETPLAY_STRICT_SETTINGS_SYNC);
settings.sync_save_data = Config::Get(Config::NETPLAY_SYNC_SAVES);
settings.sync_codes = Config::Get(Config::NETPLAY_SYNC_CODES);
settings.sync_all_wii_saves =
Config::Get(Config::NETPLAY_SYNC_ALL_WII_SAVES) && Config::Get(Config::NETPLAY_SYNC_SAVES);
settings.m_GolfMode = Config::Get(Config::NETPLAY_NETWORK_MODE) == "golf";
settings.m_UseFMA = DoAllPlayersHaveHardwareFMA();
settings.m_HideRemoteGBAs = Config::Get(Config::NETPLAY_HIDE_REMOTE_GBAS);
settings.golf_mode = Config::Get(Config::NETPLAY_NETWORK_MODE) == "golf";
settings.use_fma = DoAllPlayersHaveHardwareFMA();
settings.hide_remote_gbas = Config::Get(Config::NETPLAY_HIDE_REMOTE_GBAS);
// Unload GameINI to restore things to normal
Config::RemoveLayer(Config::LayerType::GlobalGame);
@ -1382,7 +1382,7 @@ bool NetPlayServer::RequestStartGame()
bool start_now = true;
if (m_settings.m_SyncSaveData && m_players.size() > 1)
if (m_settings.sync_save_data && m_players.size() > 1)
{
start_now = false;
m_start_pending = true;
@ -1395,7 +1395,7 @@ bool NetPlayServer::RequestStartGame()
}
// Check To Send Codes to Clients
if (m_settings.m_SyncCodes && m_players.size() > 1)
if (m_settings.sync_codes && m_players.size() > 1)
{
start_now = false;
m_start_pending = true;
@ -1455,82 +1455,82 @@ bool NetPlayServer::StartGame()
sf::Packet spac;
spac << MessageID::StartGame;
spac << m_current_game;
spac << m_settings.m_CPUthread;
spac << m_settings.m_CPUcore;
spac << m_settings.m_EnableCheats;
spac << m_settings.m_SelectedLanguage;
spac << m_settings.m_OverrideRegionSettings;
spac << m_settings.m_DSPEnableJIT;
spac << m_settings.m_DSPHLE;
spac << m_settings.m_WriteToMemcard;
spac << m_settings.m_RAMOverrideEnable;
spac << m_settings.m_Mem1Size;
spac << m_settings.m_Mem2Size;
spac << m_settings.m_FallbackRegion;
spac << m_settings.m_AllowSDWrites;
spac << m_settings.m_CopyWiiSave;
spac << m_settings.m_OCEnable;
spac << m_settings.m_OCFactor;
spac << m_settings.cpu_thread;
spac << m_settings.cpu_core;
spac << m_settings.enable_cheats;
spac << m_settings.selected_language;
spac << m_settings.override_region_settings;
spac << m_settings.dsp_enable_jit;
spac << m_settings.dsp_hle;
spac << m_settings.write_to_memcard;
spac << m_settings.ram_override_enable;
spac << m_settings.mem1_size;
spac << m_settings.mem2_size;
spac << m_settings.fallback_region;
spac << m_settings.allow_sd_writes;
spac << m_settings.copy_wii_save;
spac << m_settings.oc_enable;
spac << m_settings.oc_factor;
for (auto slot : ExpansionInterface::SLOTS)
spac << static_cast<int>(m_settings.m_EXIDevice[slot]);
spac << static_cast<int>(m_settings.exi_device[slot]);
spac << m_settings.m_MemcardSizeOverride;
spac << m_settings.memcard_size_override;
for (u32 value : m_settings.m_SYSCONFSettings)
for (u32 value : m_settings.sysconf_settings)
spac << value;
spac << m_settings.m_EFBAccessEnable;
spac << m_settings.m_BBoxEnable;
spac << m_settings.m_ForceProgressive;
spac << m_settings.m_EFBToTextureEnable;
spac << m_settings.m_XFBToTextureEnable;
spac << m_settings.m_DisableCopyToVRAM;
spac << m_settings.m_ImmediateXFBEnable;
spac << m_settings.m_EFBEmulateFormatChanges;
spac << m_settings.m_SafeTextureCacheColorSamples;
spac << m_settings.m_PerfQueriesEnable;
spac << m_settings.m_FloatExceptions;
spac << m_settings.m_DivideByZeroExceptions;
spac << m_settings.m_FPRF;
spac << m_settings.m_AccurateNaNs;
spac << m_settings.m_DisableICache;
spac << m_settings.m_SyncOnSkipIdle;
spac << m_settings.m_SyncGPU;
spac << m_settings.m_SyncGpuMaxDistance;
spac << m_settings.m_SyncGpuMinDistance;
spac << m_settings.m_SyncGpuOverclock;
spac << m_settings.m_JITFollowBranch;
spac << m_settings.m_FastDiscSpeed;
spac << m_settings.m_MMU;
spac << m_settings.m_Fastmem;
spac << m_settings.m_SkipIPL;
spac << m_settings.m_LoadIPLDump;
spac << m_settings.m_VertexRounding;
spac << m_settings.m_InternalResolution;
spac << m_settings.m_EFBScaledCopy;
spac << m_settings.m_FastDepthCalc;
spac << m_settings.m_EnablePixelLighting;
spac << m_settings.m_WidescreenHack;
spac << m_settings.m_ForceFiltering;
spac << m_settings.m_MaxAnisotropy;
spac << m_settings.m_ForceTrueColor;
spac << m_settings.m_DisableCopyFilter;
spac << m_settings.m_DisableFog;
spac << m_settings.m_ArbitraryMipmapDetection;
spac << m_settings.m_ArbitraryMipmapDetectionThreshold;
spac << m_settings.m_EnableGPUTextureDecoding;
spac << m_settings.m_DeferEFBCopies;
spac << m_settings.m_EFBAccessTileSize;
spac << m_settings.m_EFBAccessDeferInvalidation;
spac << m_settings.m_StrictSettingsSync;
spac << m_settings.efb_access_enable;
spac << m_settings.bbox_enable;
spac << m_settings.force_progressive;
spac << m_settings.efb_to_texture_enable;
spac << m_settings.xfb_to_texture_enable;
spac << m_settings.disable_copy_to_vram;
spac << m_settings.immediate_xfb_enable;
spac << m_settings.efb_emulate_format_changes;
spac << m_settings.safe_texture_cache_color_samples;
spac << m_settings.perf_queries_enable;
spac << m_settings.float_exceptions;
spac << m_settings.divide_by_zero_exceptions;
spac << m_settings.fprf;
spac << m_settings.accurate_nans;
spac << m_settings.disable_icache;
spac << m_settings.sync_on_skip_idle;
spac << m_settings.sync_gpu;
spac << m_settings.sync_gpu_max_distance;
spac << m_settings.sync_gpu_min_distance;
spac << m_settings.sync_gpu_overclock;
spac << m_settings.jit_follow_branch;
spac << m_settings.fast_disc_speed;
spac << m_settings.mmu;
spac << m_settings.fastmem;
spac << m_settings.skip_ipl;
spac << m_settings.load_ipl_dump;
spac << m_settings.vertex_rounding;
spac << m_settings.internal_resolution;
spac << m_settings.efb_scaled_copy;
spac << m_settings.fast_depth_calc;
spac << m_settings.enable_pixel_lighting;
spac << m_settings.widescreen_hack;
spac << m_settings.force_filtering;
spac << m_settings.max_anisotropy;
spac << m_settings.force_true_color;
spac << m_settings.disable_copy_filter;
spac << m_settings.disable_fog;
spac << m_settings.arbitrary_mipmap_detection;
spac << m_settings.arbitrary_mipmap_detection_threshold;
spac << m_settings.enable_gpu_texture_decoding;
spac << m_settings.defer_efb_copies;
spac << m_settings.efb_access_tile_size;
spac << m_settings.efb_access_defer_invalidation;
spac << m_settings.strict_settings_sync;
spac << initial_rtc;
spac << m_settings.m_SyncSaveData;
spac << m_settings.sync_save_data;
spac << region;
spac << m_settings.m_SyncCodes;
spac << m_settings.m_SyncAllWiiSaves;
spac << m_settings.sync_codes;
spac << m_settings.sync_all_wii_saves;
for (size_t i = 0; i < m_settings.m_WiimoteExtension.size(); i++)
for (size_t i = 0; i < m_settings.wiimote_extension.size(); i++)
{
const int extension =
static_cast<ControllerEmu::Attachments*>(
@ -1540,9 +1540,9 @@ bool NetPlayServer::StartGame()
spac << extension;
}
spac << m_settings.m_GolfMode;
spac << m_settings.m_UseFMA;
spac << m_settings.m_HideRemoteGBAs;
spac << m_settings.golf_mode;
spac << m_settings.use_fma;
spac << m_settings.hide_remote_gbas;
SendAsyncToClients(std::move(spac));
@ -1574,7 +1574,7 @@ bool NetPlayServer::SyncSaveData()
for (ExpansionInterface::Slot slot : ExpansionInterface::MEMCARD_SLOTS)
{
if (m_settings.m_EXIDevice[slot] == ExpansionInterface::EXIDeviceType::MemoryCard ||
if (m_settings.exi_device[slot] == ExpansionInterface::EXIDeviceType::MemoryCard ||
Config::Get(Config::GetInfoForEXIDevice(slot)) ==
ExpansionInterface::EXIDeviceType::MemoryCardFolder)
{
@ -1590,7 +1590,7 @@ bool NetPlayServer::SyncSaveData()
}
bool wii_save = false;
if (m_settings.m_CopyWiiSave && (game->GetPlatform() == DiscIO::Platform::WiiDisc ||
if (m_settings.copy_wii_save && (game->GetPlatform() == DiscIO::Platform::WiiDisc ||
game->GetPlatform() == DiscIO::Platform::WiiWAD ||
game->GetPlatform() == DiscIO::Platform::ELFOrDOL))
{
@ -1635,9 +1635,9 @@ bool NetPlayServer::SyncSaveData()
{
const bool is_slot_a = slot == ExpansionInterface::Slot::A;
if (m_settings.m_EXIDevice[slot] == ExpansionInterface::EXIDeviceType::MemoryCard)
if (m_settings.exi_device[slot] == ExpansionInterface::EXIDeviceType::MemoryCard)
{
const int size_override = m_settings.m_MemcardSizeOverride;
const int size_override = m_settings.memcard_size_override;
const u16 card_size_mbits =
size_override >= 0 && size_override <= 4 ?
static_cast<u16>(Memcard::MBIT_SIZE_MEMORY_CARD_59 << size_override) :
@ -1703,7 +1703,7 @@ bool NetPlayServer::SyncSaveData()
const auto configured_fs = IOS::HLE::FS::MakeFileSystem(IOS::HLE::FS::Location::Configured);
std::vector<std::pair<u64, WiiSave::StoragePointer>> saves;
if (m_settings.m_SyncAllWiiSaves)
if (m_settings.sync_all_wii_saves)
{
IOS::HLE::Kernel ios;
for (const u64 title : ios.GetES()->GetInstalledTitles())

3
Source/Core/DolphinQt/NetPlay/NetPlayDialog.cpp
View File

@ -850,8 +850,7 @@ void NetPlayDialog::OnMsgStartGame()
g_netplay_chat_ui =
std::make_unique<NetPlayChatUI>([this](const std::string& message) { SendMessage(message); });
if (m_host_input_authority &&
Settings::Instance().GetNetPlayClient()->GetNetSettings().m_GolfMode)
if (m_host_input_authority && Settings::Instance().GetNetPlayClient()->GetNetSettings().golf_mode)
{
g_netplay_golf_ui = std::make_unique<NetPlayGolfUI>(Settings::Instance().GetNetPlayClient());
}