ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
dolphin/Source/Core/DolphinQt/NetPlay/NetPlayDialog.h

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

163 lines
4.9 KiB
C
Raw Normal View History

Qt: Implement NetPlay
2017-07-21 20:48:21 +00:00
// Copyright 2017 Dolphin Emulator Project
// Licensed under GPLv2+
// Refer to the license.txt file included.
#pragma once
#include <QDialog>
Qt/NetPlayDialog: Move most options into a menu bar This eliminates the clutter of checkboxes at the bottom of the window. A QAction within a QMenu cannot have a tooltip however, so they have been removed and the options will be documented on the wiki.
2019-03-01 04:49:03 +00:00
#include <QMenuBar>
Qt: Implement NetPlay
2017-07-21 20:48:21 +00:00
Qt/NetPlayDialog: Add external IP to interface combo box The interface address isn't particularly useful in most circumstances (playing over internet), and we have a way to get the external IP now, so displaying it in the dialog is useful.
2018-11-15 05:58:07 +00:00
#include "Common/Lazy.h"
Qt: Implement NetPlay
2017-07-21 20:48:21 +00:00
#include "Core/NetPlayClient.h"
GameListModel instance ownership transferred back to the GameList instance. The GameListModel instance will be passed as a constructor parameter where needed.
2019-01-17 22:28:07 +00:00
#include "DolphinQt/GameList/GameListModel.h"
Qt: Implement NetPlay
2017-07-21 20:48:21 +00:00
#include "VideoCommon/OnScreenDisplay.h"
NetPlay: Implement chunked data transfer This sends arbitrary packets in chunks to be reassembled at the other end, allowing large data transfers to be speed-limited and interleaved with other packets being sent. It also enables tracking the progress of large data transfers.
2018-10-18 08:33:05 +00:00
class ChunkedProgressDialog;
Qt: Implement NetPlay
2017-07-21 20:48:21 +00:00
class MD5Dialog;
class PadMappingDialog;
class QCheckBox;
class QComboBox;
class QGridLayout;
class QGroupBox;
class QLabel;
class QLineEdit;
class QPushButton;
class QSpinBox;
Qt/NetPlayDialog: Add splitter
2018-05-10 17:38:58 +00:00
class QSplitter;
Qt/NetPlayDialog: Improve player list
2018-05-12 13:13:30 +00:00
class QTableWidget;
Qt: Implement NetPlay
2017-07-21 20:48:21 +00:00
class QTextEdit;
Core: Namespace NetPlay utilities under the NetPlay namespace Previously there was only one function under the NetPlay namespace, which is kind of silly considering we have all of these other types and functions existing outside of the namespace. This moves the rest of them into the namespace. This gets some general names, like Player, for example, out of the global namespace.
2018-07-06 23:39:42 +00:00
class NetPlayDialog : public QDialog, public NetPlay::NetPlayUI
Qt: Implement NetPlay
2017-07-21 20:48:21 +00:00
{
Q_OBJECT
public:
GameListModel instance ownership transferred back to the GameList instance. The GameListModel instance will be passed as a constructor parameter where needed.
2019-01-17 22:28:07 +00:00
explicit NetPlayDialog(const GameListModel& game_list_model, QWidget* parent = nullptr);
Qt/NetPlayDialog: Add splitter
2018-05-10 17:38:58 +00:00
~NetPlayDialog();
Qt: Implement NetPlay
2017-07-21 20:48:21 +00:00
void show(std::string nickname, bool use_traversal);
void reject() override;
// NetPlayUI methods
void BootGame(const std::string& filename) override;
void StopGame() override;
NetPlay save data synchronization This adds the functionality of sending the host's save data (raw memory cards, as well as GCI files and Wii saves with a matching GameID) to all other clients. The data is compressed using LZO1X to greatly reduce its size while keeping compression/decompression fast. Save synchronization is enabled by default, and toggleable with a checkbox in the NetPlay dialog. On clicking start, if the option is enabled, game boot will be delayed until all players have received the save data sent by the host. If any player fails to receive it properly, boot will be cancelled to prevent desyncs.
2018-07-04 21:01:50 +00:00
bool IsHosting() const override;
Qt: Implement NetPlay
2017-07-21 20:48:21 +00:00
void Update() override;
void AppendChat(const std::string& msg) override;
Make netplay's "same game" check more robust Instead of comparing the game ID, revision, disc number and name, we can compare a hash of important parts of the disc including all the aforementioned data but also additional data such as the FST. The primary reason why I'm making this change is to let us catch more desyncs before they happen, but this should also fix https://bugs.dolphin-emu.org/issues/12115. As a bonus, the UI can now distinguish the case where a client doesn't have the game at all from the case where a client has the wrong version of the game.
2020-06-07 20:58:03 +00:00
void OnMsgChangeGame(const NetPlay::SyncIdentifier& sync_identifier,
const std::string& netplay_name) override;
Qt: Implement NetPlay
2017-07-21 20:48:21 +00:00
void OnMsgStartGame() override;
void OnMsgStopGame() override;
NetPlay: Sync power button event This fixes the deadlock on shutdown when Wii Remotes are in use.
2018-11-11 03:37:49 +00:00
void OnMsgPowerButton() override;
Show a message in netplay chat when a player joins or leaves
2019-07-31 03:14:51 +00:00
void OnPlayerConnect(const std::string& player) override;
void OnPlayerDisconnect(const std::string& player) override;
Qt: Implement NetPlay
2017-07-21 20:48:21 +00:00
void OnPadBufferChanged(u32 buffer) override;
NetPlay host input authority mode Currently, each player buffers their own inputs and sends them to the host. The host then relays those inputs to everyone else. Every player waits on inputs from all players to be buffered before continuing. What this means is all clients run in lockstep, and the total latency of inputs cannot be lower than the sum of the 2 highest client ping times in the game (in 3+ player sessions with people across the world, the latency can be very high). Host input authority mode changes it so players no longer buffer their own inputs, and only send them to the host. The host stores only the most recent input received from a player. The host then sends inputs for all pads at the SI poll interval, similar to the existing code. If a player sends inputs to slowly, their last received input is simply sent again. If they send too quickly, inputs are dropped. This means that the host has full control over what inputs are actually read by the game, hence the name of the mode. Also, because the rate at which inputs are received by SI is decoupled from the rate at which players are sending inputs, clients are no longer dependent on each other. They only care what the host is doing. This means that they can set their buffer individually based on their latency to the host, rather than the highest latency between any 2 players, allowing someone with lower ping to the host to have less latency than someone else. This is a catch to this: as a necessity of how the host's input sending works, the host has 0 latency. There isn't a good way to fix this, as input delay is now solely dependent on the real latency to the host's server. Having differing latency between players would be considered unfair for competitive play, but for casual play we don't really care. For this reason though, combined with the potential for a few inputs to be dropped on a bad connection, the old mode will remain and this new mode is entirely optional.
2018-08-24 08:17:18 +00:00
void OnHostInputAuthorityChanged(bool enabled) override;
Qt: Implement NetPlay
2017-07-21 20:48:21 +00:00
void OnDesync(u32 frame, const std::string& player) override;
void OnConnectionLost() override;
Improve NetPlay connection error handling
2018-07-02 02:52:43 +00:00
void OnConnectionError(const std::string& message) override;
Qt/NetPlay: Use TraversalClient::FailureReason
2017-08-10 13:41:01 +00:00
void OnTraversalError(TraversalClient::FailureReason error) override;
Adds a UI for accepting Discord join requests in Dolphin also did these things fixed crash from joining user that isn't hosting via a direct connection current game stat can now pass to override the current game in config uses ip endpoint from dolphin.org
2018-07-20 22:27:43 +00:00
void OnTraversalStateChanged(TraversalClient::State state) override;
NetPlay: Fix hosting being stuck if player leaves during pending start The logic didn't account for the case where a player leaves, so the host would be left in a dangling state where the UI is disabled but the game won't start, requiring a full restart of Dolphin to fix.
2019-03-28 06:32:06 +00:00
void OnGameStartAborted() override;
NetPlay: Implement golf mode This is an extension of host input authority that allows switching the host (who has zero latency) on the fly, at the further expense of everyone else's latency. This is useful for turn-based games where the latency of players not on their turn doesn't matter. To become the so-called golfer, the player simply presses a hotkey. When the host is the golfer, latency is identical to normal host input authority.
2019-04-02 12:08:27 +00:00
void OnGolferChanged(bool is_golfer, const std::string& golfer_name) override;
NetPlay save data synchronization This adds the functionality of sending the host's save data (raw memory cards, as well as GCI files and Wii saves with a matching GameID) to all other clients. The data is compressed using LZO1X to greatly reduce its size while keeping compression/decompression fast. Save synchronization is enabled by default, and toggleable with a checkbox in the NetPlay dialog. On clicking start, if the option is enabled, game boot will be delayed until all players have received the save data sent by the host. If any player fails to receive it properly, boot will be cancelled to prevent desyncs.
2018-07-04 21:01:50 +00:00
Qt/NetPlay: Show feedback for index adding
2019-04-10 23:21:40 +00:00
void OnIndexAdded(bool success, const std::string error) override;
void OnIndexRefreshFailed(const std::string error) override;
Qt: Implement NetPlay
2017-07-21 20:48:21 +00:00
bool IsRecording() override;
Make netplay's "same game" check more robust Instead of comparing the game ID, revision, disc number and name, we can compare a hash of important parts of the disc including all the aforementioned data but also additional data such as the FST. The primary reason why I'm making this change is to let us catch more desyncs before they happen, but this should also fix https://bugs.dolphin-emu.org/issues/12115. As a bonus, the UI can now distinguish the case where a client doesn't have the game at all from the case where a client has the wrong version of the game.
2020-06-07 20:58:03 +00:00
std::shared_ptr<const UICommon::GameFile>
FindGameFile(const NetPlay::SyncIdentifier& sync_identifier,
NetPlay::SyncIdentifierComparison* found = nullptr) override;
NetPlay: Properly save Hosting GUI settings
2018-10-09 22:52:19 +00:00
Qt/NetPlayDialog: Move settings loading into LoadSettings
2019-05-30 21:44:02 +00:00
void LoadSettings();
NetPlay: Properly save Hosting GUI settings
2018-10-09 22:52:19 +00:00
void SaveSettings();
Make netplay's "same game" check more robust Instead of comparing the game ID, revision, disc number and name, we can compare a hash of important parts of the disc including all the aforementioned data but also additional data such as the FST. The primary reason why I'm making this change is to let us catch more desyncs before they happen, but this should also fix https://bugs.dolphin-emu.org/issues/12115. As a bonus, the UI can now distinguish the case where a client doesn't have the game at all from the case where a client has the wrong version of the game.
2020-06-07 20:58:03 +00:00
void ShowMD5Dialog(const std::string& title) override;
Qt: Implement NetPlay
2017-07-21 20:48:21 +00:00
void SetMD5Progress(int pid, int progress) override;
void SetMD5Result(int pid, const std::string& result) override;
void AbortMD5() override;
NetPlay: Implement chunked data transfer This sends arbitrary packets in chunks to be reassembled at the other end, allowing large data transfers to be speed-limited and interleaved with other packets being sent. It also enables tracking the progress of large data transfers.
2018-10-18 08:33:05 +00:00
void ShowChunkedProgressDialog(const std::string& title, u64 data_size,
const std::vector<int>& players) override;
void HideChunkedProgressDialog() override;
void SetChunkedProgress(int pid, u64 progress) override;
Qt: Implement NetPlay
2017-07-21 20:48:21 +00:00
signals:
void Boot(const QString& filename);
void Stop();
private:
void CreateChatLayout();
void CreatePlayersLayout();
void CreateMainLayout();
void ConnectWidgets();
void OnChat();
void OnStart();
void DisplayMessage(const QString& msg, const std::string& color,
int duration = OSD::Duration::NORMAL);
Qt/NetPlayDialog: Add external IP to interface combo box The interface address isn't particularly useful in most circumstances (playing over internet), and we have a way to get the external IP now, so displaying it in the dialog is useful.
2018-11-15 05:58:07 +00:00
void ResetExternalIP();
Adds a UI for accepting Discord join requests in Dolphin also did these things fixed crash from joining user that isn't hosting via a direct connection current game stat can now pass to override the current game in config uses ip endpoint from dolphin.org
2018-07-20 22:27:43 +00:00
void UpdateDiscordPresence();
Qt: Implement NetPlay
2017-07-21 20:48:21 +00:00
void UpdateGUI();
void GameStatusChanged(bool running);
NetPlay save data synchronization This adds the functionality of sending the host's save data (raw memory cards, as well as GCI files and Wii saves with a matching GameID) to all other clients. The data is compressed using LZO1X to greatly reduce its size while keeping compression/decompression fast. Save synchronization is enabled by default, and toggleable with a checkbox in the NetPlay dialog. On clicking start, if the option is enabled, game boot will be delayed until all players have received the save data sent by the host. If any player fails to receive it properly, boot will be cancelled to prevent desyncs.
2018-07-04 21:01:50 +00:00
void SetOptionsEnabled(bool enabled);
Qt: Implement NetPlay
2017-07-21 20:48:21 +00:00
Add imgui-based Netplay Chat
2019-03-17 00:09:06 +00:00
void SendMessage(const std::string& message);
Qt: Implement NetPlay
2017-07-21 20:48:21 +00:00
// Chat
QGroupBox* m_chat_box;
QTextEdit* m_chat_edit;
QLineEdit* m_chat_type_edit;
QPushButton* m_chat_send_button;
// Players
QGroupBox* m_players_box;
QComboBox* m_room_box;
QLabel* m_hostcode_label;
QPushButton* m_hostcode_action_button;
Qt/NetPlayDialog: Improve player list
2018-05-12 13:13:30 +00:00
QTableWidget* m_players_list;
Qt: Implement NetPlay
2017-07-21 20:48:21 +00:00
QPushButton* m_kick_button;
QPushButton* m_assign_ports_button;
// Other
Qt/NetPlayDialog: Move most options into a menu bar This eliminates the clutter of checkboxes at the bottom of the window. A QAction within a QMenu cannot have a tooltip however, so they have been removed and the options will be documented on the wiki.
2019-03-01 04:49:03 +00:00
QMenuBar* m_menu_bar;
QMenu* m_data_menu;
QMenu* m_network_menu;
Qt/NetPlayDialog: Move MD5 button into menubar
2019-04-23 20:37:22 +00:00
QMenu* m_md5_menu;
Qt/NetPlayDialog: Move most options into a menu bar This eliminates the clutter of checkboxes at the bottom of the window. A QAction within a QMenu cannot have a tooltip however, so they have been removed and the options will be documented on the wiki.
2019-03-01 04:49:03 +00:00
QMenu* m_other_menu;
Qt: Implement NetPlay
2017-07-21 20:48:21 +00:00
QPushButton* m_game_button;
QPushButton* m_start_button;
QLabel* m_buffer_label;
QSpinBox* m_buffer_size_box;
Qt/NetPlayDialog: Move most options into a menu bar This eliminates the clutter of checkboxes at the bottom of the window. A QAction within a QMenu cannot have a tooltip however, so they have been removed and the options will be documented on the wiki.
2019-03-01 04:49:03 +00:00
QAction* m_save_sd_action;
QAction* m_load_wii_action;
QAction* m_sync_save_data_action;
QAction* m_sync_codes_action;
QAction* m_record_input_action;
QAction* m_strict_settings_sync_action;
QAction* m_host_input_authority_action;
QAction* m_sync_all_wii_saves_action;
NetPlay: Implement golf mode This is an extension of host input authority that allows switching the host (who has zero latency) on the fly, at the further expense of everyone else's latency. This is useful for turn-based games where the latency of players not on their turn doesn't matter. To become the so-called golfer, the player simply presses a hotkey. When the host is the golfer, latency is identical to normal host input authority.
2019-04-02 12:08:27 +00:00
QAction* m_golf_mode_action;
Add imgui golf mode overlay
2019-04-02 21:13:42 +00:00
QAction* m_golf_mode_overlay_action;
Qt/NetPlayDialog: Change network mode options to radio buttons This changes the Host Input Authority and Golf Mode checkboxes into a set of radio buttons, consisting of Fair Input Delay, Host Input Authority, and Golf Mode. This represents the 3 network modes we have. Although Golf Mode is just an extension of Host Input Authority, it's more logical to the user to present it as a separate option, rather than enabling the Golf Mode checkbox only when Host Input Authority is enabled. This also eliminates the need to first enable Host Input Authority before Golf Mode can be enabled. This also adds tooltips to provide brief descriptions of the options, as well as reintroducing tooltips that were previously removed.
2019-05-30 21:58:31 +00:00
QAction* m_fixed_delay_action;
Qt: Implement NetPlay
2017-07-21 20:48:21 +00:00
QPushButton* m_quit_button;
Qt/NetPlayDialog: Add splitter
2018-05-10 17:38:58 +00:00
QSplitter* m_splitter;
Qt/NetPlayDialog: Change network mode options to radio buttons This changes the Host Input Authority and Golf Mode checkboxes into a set of radio buttons, consisting of Fair Input Delay, Host Input Authority, and Golf Mode. This represents the 3 network modes we have. Although Golf Mode is just an extension of Host Input Authority, it's more logical to the user to present it as a separate option, rather than enabling the Golf Mode checkbox only when Host Input Authority is enabled. This also eliminates the need to first enable Host Input Authority before Golf Mode can be enabled. This also adds tooltips to provide brief descriptions of the options, as well as reintroducing tooltips that were previously removed.
2019-05-30 21:58:31 +00:00
QActionGroup* m_network_mode_group;
Qt: Implement NetPlay
2017-07-21 20:48:21 +00:00
QGridLayout* m_main_layout;
MD5Dialog* m_md5_dialog;
NetPlay: Implement chunked data transfer This sends arbitrary packets in chunks to be reassembled at the other end, allowing large data transfers to be speed-limited and interleaved with other packets being sent. It also enables tracking the progress of large data transfers.
2018-10-18 08:33:05 +00:00
ChunkedProgressDialog* m_chunked_progress_dialog;
Qt: Implement NetPlay
2017-07-21 20:48:21 +00:00
PadMappingDialog* m_pad_mapping;
Make netplay's "same game" check more robust Instead of comparing the game ID, revision, disc number and name, we can compare a hash of important parts of the disc including all the aforementioned data but also additional data such as the FST. The primary reason why I'm making this change is to let us catch more desyncs before they happen, but this should also fix https://bugs.dolphin-emu.org/issues/12115. As a bonus, the UI can now distinguish the case where a client doesn't have the game at all from the case where a client has the wrong version of the game.
2020-06-07 20:58:03 +00:00
NetPlay::SyncIdentifier m_current_game_identifier;
std::string m_current_game_name;
Qt/NetPlayDialog: Add external IP to interface combo box The interface address isn't particularly useful in most circumstances (playing over internet), and we have a way to get the external IP now, so displaying it in the dialog is useful.
2018-11-15 05:58:07 +00:00
Common::Lazy<std::string> m_external_ip_address;
Qt: Implement NetPlay
2017-07-21 20:48:21 +00:00
std::string m_nickname;
GameListModel instance ownership transferred back to the GameList instance. The GameListModel instance will be passed as a constructor parameter where needed.
2019-01-17 22:28:07 +00:00
const GameListModel& m_game_list_model;
Qt: Implement NetPlay
2017-07-21 20:48:21 +00:00
bool m_use_traversal = false;
bool m_is_copy_button_retry = false;
Qt/NetPlayDialog: Stop games properly
2018-07-03 23:02:13 +00:00
bool m_got_stop_request = true;
Qt/NetPlayDialog: Fix duplicate messages
2018-05-10 17:26:42 +00:00
int m_buffer_size = 0;
Qt/NetPlayDialog: Show alerts when events happen Displays an alert when you receive a message or a player joins / leaves
2018-07-11 10:45:47 +00:00
int m_player_count = 0;
Adds a UI for accepting Discord join requests in Dolphin also did these things fixed crash from joining user that isn't hosting via a direct connection current game stat can now pass to override the current game in config uses ip endpoint from dolphin.org
2018-07-20 22:27:43 +00:00
int m_old_player_count = 0;
NetPlay host input authority mode Currently, each player buffers their own inputs and sends them to the host. The host then relays those inputs to everyone else. Every player waits on inputs from all players to be buffered before continuing. What this means is all clients run in lockstep, and the total latency of inputs cannot be lower than the sum of the 2 highest client ping times in the game (in 3+ player sessions with people across the world, the latency can be very high). Host input authority mode changes it so players no longer buffer their own inputs, and only send them to the host. The host stores only the most recent input received from a player. The host then sends inputs for all pads at the SI poll interval, similar to the existing code. If a player sends inputs to slowly, their last received input is simply sent again. If they send too quickly, inputs are dropped. This means that the host has full control over what inputs are actually read by the game, hence the name of the mode. Also, because the rate at which inputs are received by SI is decoupled from the rate at which players are sending inputs, clients are no longer dependent on each other. They only care what the host is doing. This means that they can set their buffer individually based on their latency to the host, rather than the highest latency between any 2 players, allowing someone with lower ping to the host to have less latency than someone else. This is a catch to this: as a necessity of how the host's input sending works, the host has 0 latency. There isn't a good way to fix this, as input delay is now solely dependent on the real latency to the host's server. Having differing latency between players would be considered unfair for competitive play, but for casual play we don't really care. For this reason though, combined with the potential for a few inputs to be dropped on a bad connection, the old mode will remain and this new mode is entirely optional.
2018-08-24 08:17:18 +00:00
bool m_host_input_authority = false;
Qt: Implement NetPlay
2017-07-21 20:48:21 +00:00
};