Emulation/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch.git synced 2024-06-02 19:57:24 -04:00
Code Issues Packages Projects Releases Wiki Activity

(Netplay) Removal of older unused code (#14312)

Browse source
This commit is contained in:
Cthulhu-throwaway 2022-08-11 18:17:33 -03:00 committed by GitHub
parent d62b866237
commit 908667d97a
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
48 changed files with 57 additions and 569 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
config.def.h
View file

@ -1228,9 +1228,6 @@ static const bool netplay_allow_slaves = true;
/* Require connections only in slave mode */
static const bool netplay_require_slaves = false;
/* Netplay without savestates/rewind */
static const bool netplay_stateless_mode = false;
/* When being client over netplay, use keybinds for
* user 1 rather than user 2. */
static const bool netplay_client_swap_input = true;

2
configuration.c
View file

@ -1618,8 +1618,6 @@ static struct config_bool_setting *populate_settings_bool(
SETTING_BOOL("netplay_allow_pausing", &settings->bools.netplay_allow_pausing, true, netplay_allow_pausing, false);
SETTING_BOOL("netplay_allow_slaves", &settings->bools.netplay_allow_slaves, true, netplay_allow_slaves, false);
SETTING_BOOL("netplay_require_slaves", &settings->bools.netplay_require_slaves, true, netplay_require_slaves, false);
SETTING_BOOL("netplay_stateless_mode", &settings->bools.netplay_stateless_mode, true, netplay_stateless_mode, false);
SETTING_OVERRIDE(RARCH_OVERRIDE_SETTING_NETPLAY_STATELESS_MODE);
SETTING_BOOL("netplay_use_mitm_server", &settings->bools.netplay_use_mitm_server, true, netplay_use_mitm_server, false);
SETTING_BOOL("netplay_request_device_p1", &settings->bools.netplay_request_devices[0], true, false, false);
SETTING_BOOL("netplay_request_device_p2", &settings->bools.netplay_request_devices[1], true, false, false);

1
configuration.h
View file

@ -769,7 +769,6 @@ typedef struct settings
bool netplay_allow_pausing;
bool netplay_allow_slaves;
bool netplay_require_slaves;
bool netplay_stateless_mode;
bool netplay_nat_traversal;
bool netplay_use_mitm_server;
bool netplay_request_devices[MAX_USERS];

9
intl/msg_hash_ar.c
View file

@ -1592,15 +1592,6 @@ int msg_hash_get_help_ar_enum(enum msg_hash_enums msg, char *s, size_t len)
"Not recommended except for very fast networks \n"
"with very weak machines. \n");
break;
case MENU_ENUM_LABEL_NETPLAY_STATELESS_MODE:
snprintf(s, len,
"Whether to run netplay in a mode not requiring\n"
"save states. \n"
" \n"
"If set to true, a very fast network is required,\n"
"but no rewinding is performed, so there will be\n"
"no netplay jitter.\n");
break;
case MENU_ENUM_LABEL_NETPLAY_CHECK_FRAMES:
snprintf(s, len,
"The frequency in frames with which netplay \n"

4
intl/msg_hash_ar.h
View file

@ -3794,10 +3794,6 @@ MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_REQUIRE_SLAVES,
"عدم السماح للعملاء في وضع غير الرق"
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_STATELESS_MODE,
"وضع عديم الجنسية للشبكة"
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_CHECK_FRAMES,
"إطارات التحقق من الشبكة"

8
intl/msg_hash_chs.h
View file

@ -5390,14 +5390,6 @@ MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_REQUIRE_SLAVES,
"不允许非从属模式连接。一般不推荐，除非您的网络极快但硬件性能极差。"
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_STATELESS_MODE,
"联机无状态模式"
)
MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_STATELESS_MODE,
"在没有即时存档的模式下开始联机游戏。需要非常快的网络，但是不进行回溯处理，因此不会有联机卡顿。"
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_CHECK_FRAMES,
"在线游戏检查帧数"

4
intl/msg_hash_cht.h
View file

@ -2906,10 +2906,6 @@ MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_SPECTATE_PASSWORD,
"伺服器圍觀的密碼"
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_STATELESS_MODE,
"連線遊戲無狀態模式"
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_CHECK_FRAMES,
"連線遊戲檢查幀數"

9
intl/msg_hash_cs.c
View file

@ -1793,15 +1793,6 @@ int msg_hash_get_help_cs_enum(enum msg_hash_enums msg, char *s, size_t len)
"Not recommended except for very fast networks \n"
"with very weak machines.");
break;
case MENU_ENUM_LABEL_NETPLAY_STATELESS_MODE:
snprintf(s, len,
"Whether to run netplay in a mode not requiring"
"save states. \n"
" \n"
"If set to true, a very fast network is required, \n"
"but no rewinding is performed, so there will be \n"
"no netplay jitter. \n");
break;
case MENU_ENUM_LABEL_NETPLAY_CHECK_FRAMES:
snprintf(s, len,
"The frequency in frames with which netplay \n"

8
intl/msg_hash_cs.h
View file

@ -5578,14 +5578,6 @@ MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_REQUIRE_SLAVES,
"Zakázat připojení, která nejsou v podřízeném režimu. Nedoporučuje se s výjimkou velmi rychlých sítí s velmi slabými stroji."
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_STATELESS_MODE,
"Bezstavový Režim Netplay"
)
MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_STATELESS_MODE,
"Spusťte hru po síti v režimu, který nevyžaduje uložení pozic. Je vyžadována velmi rychlá síť, ale neprovádí se žádné převíjení, takže nedochází k žádnému trhání při přehrávání v síti."
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_CHECK_FRAMES,
"Kontrolní Snímky Netplay"

9
intl/msg_hash_de.c
View file

@ -1597,15 +1597,6 @@ int msg_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
"Nicht empfohlen, außer für sehr schnelle \n"
"Netzwerke mit sehr schwachen Geräten. \n");
break;
case MENU_ENUM_LABEL_NETPLAY_STATELESS_MODE: /* Maybe FIXME*/
snprintf(s, len,
"Legt fest, ob Netplay in einem Modus laufen soll, der keine\n"
"Savestates benötigt. \n"
" \n"
"Wenn diese Option eingeschaltet wird, wird ein sehr \n"
"schnelles Netzwerk benötigt. Da kein Rücklauf benötigt wird, \n"
"tritt keine Netplay-Verzögerung auf.\n");
break;
case MENU_ENUM_LABEL_NETPLAY_CHECK_FRAMES:
{
/* Work around C89 limitations */

8
intl/msg_hash_de.h
View file

@ -5566,14 +5566,6 @@ MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_REQUIRE_SLAVES,
"Keine nicht-Slave-Modus-Verbindungen zulassen. Nicht empfohlen, außer für sehr schnelle Netzwerke mit sehr schwachen Maschinen."
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_STATELESS_MODE,
"Netzwerkspiel ohne Savestates"
)
MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_STATELESS_MODE,
"Netzwerkspiel startet in einem Modus, der keine Savestates erfordert. Ein sehr schnelles Netzwerk wird benötigt, aber es wird kein Zurückspulen durchgeführt, sodass keine Netzwerk-Ruckler auftreten."
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_CHECK_FRAMES,
"Netzwerkspiel-Synchronisationsperiode"

9
intl/msg_hash_el.c
View file

@ -1659,15 +1659,6 @@ int msg_hash_get_help_el_enum(enum msg_hash_enums msg, char *s, size_t len)
"Not recommended except for very fast networks \n"
"with very weak machines. \n");
break;
case MENU_ENUM_LABEL_NETPLAY_STATELESS_MODE:
snprintf(s, len,
"Whether to run netplay in a mode not requiring\n"
"save states. \n"
" \n"
"If set to true, a very fast network is required,\n"
"but no rewinding is performed, so there will be\n"
"no netplay jitter.\n");
break;
case MENU_ENUM_LABEL_NETPLAY_CHECK_FRAMES:
snprintf(s, len,
"The frequency in frames with which netplay \n"

8
intl/msg_hash_en.h
View file

@ -994,14 +994,6 @@ MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_ALLOW_PAUSING,
"Allow players to pause during net-play."
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_STATELESS_MODE,
"Net-play Stateless Mode"
)
MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_STATELESS_MODE,
"Start net-play in a mode not requiring save states. A very fast network is required, but no rewinding is performed, so there will be no net-play jitter."
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_CHECK_FRAMES,
"Net-play Check Frames"

10
intl/msg_hash_es.c
View file

@ -1836,16 +1836,6 @@ int msg_hash_get_help_es_enum(enum msg_hash_enums msg, char *s, size_t len)
"No se recomienda su uso salvo en redes\n"
"muy rápidas con máquinas poco potentes.");
break;
case MENU_ENUM_LABEL_NETPLAY_STATELESS_MODE:
snprintf(s, len,
"Ejecuta el juego en red en un modo\n"
"que no utiliza guardados rápidos.\n"
" \n"
"La activación de esta opción requiere\n"
"de una red muy rápida, pero no se realizarán\n"
"rebobinados, de modo que no habrá tirones\n"
"durante la sesión.");
break;
case MENU_ENUM_LABEL_NETPLAY_CHECK_FRAMES: {
/* Work around C89 limitations */
/* Arreglo para saltarse la limitación de 509 caracteres por cadena. */

8
intl/msg_hash_es.h
View file

@ -5662,14 +5662,6 @@ MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_REQUIRE_SLAVES,
"Rechaza las conexiones que no utilicen el modo esclavo. No se recomienda su uso salvo en redes muy rápidas con máquinas poco potentes."
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_STATELESS_MODE,
"Modo sin estados de juego en red"
)
MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_STATELESS_MODE,
"Ejecuta el juego en red en un modo que no permita guardados rápidos. Necesita una red muy rápida, pero como no se utilizará la función de rebobinado, se eliminarán los tirones que provoca."
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_CHECK_FRAMES,
"Frecuencia de comprobación del juego en red"

9
intl/msg_hash_fi.c
View file

@ -1700,15 +1700,6 @@ int msg_hash_get_help_fi_enum(enum msg_hash_enums msg, char *s, size_t len)
"Not recommended except for very fast networks \n"
"with very weak machines.");
break;
case MENU_ENUM_LABEL_NETPLAY_STATELESS_MODE:
snprintf(s, len,
"Whether to run netplay in a mode not requiring"
"save states. \n"
" \n"
"If set to true, a very fast network is required, \n"
"but no rewinding is performed, so there will be \n"
"no netplay jitter. \n");
break;
case MENU_ENUM_LABEL_NETPLAY_CHECK_FRAMES:
snprintf(s, len,
"The frequency in frames with which netplay \n"

8
intl/msg_hash_fi.h
View file

@ -5438,14 +5438,6 @@ MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_REQUIRE_SLAVES,
"Estä yhteydet jotka eivät ole slave-tilassa. Ei suositella, paitsi erittäin nopeissa verkoissa, joissa erittäin heikot koneet."
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_STATELESS_MODE,
"Pelitilaton verkkopelin tila"
)
MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_STATELESS_MODE,
"Käynnistä verkkopeli tilassa, joka ei vaadi pelitilatallennuksia. Erittäin nopea verkkoyhteys tarvitaan, mutta taaksekelausta ei suoriteta, joten verkkopeli ei takkua."
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_CHECK_FRAMES,
"Verkkopelin tarkistuskuvat"

9
intl/msg_hash_fr.c
View file

@ -1712,15 +1712,6 @@ int msg_hash_get_help_fr_enum(enum msg_hash_enums msg, char *s, size_t len)
"Non recommandé sauf pour les réseaux très rapides \n"
"avec des machines très faibles. \n");
break;
case MENU_ENUM_LABEL_NETPLAY_STATELESS_MODE:
snprintf(s, len,
"Faire tourner le jeu en réseau dans un mode\n"
"ne nécessitant pas de sauvegardes instantanées. \n"
" \n"
"Si cette option est activée, un réseau très rapide est requis,\n"
"mais aucun rembobinage n'est effectué. Il n'y aura donc\n"
"pas de variations de la latence sur le jeu en réseau.\n");
break;
case MENU_ENUM_LABEL_NETPLAY_CHECK_FRAMES:
snprintf(s, len,
"Fréquence en images avec laquelle le jeu\n"

8
intl/msg_hash_fr.h
View file

@ -5634,14 +5634,6 @@ MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_REQUIRE_SLAVES,
"Interdit les connexions qui ne sont pas en mode passif. Non recommandé sauf pour les réseaux très rapides avec des machines très faibles."
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_STATELESS_MODE,
"Mode sans état de jeu en réseau"
)
MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_STATELESS_MODE,
"Lance le jeu en réseau dans un mode ne nécessitant pas de sauvegardes instantanées. Un réseau très rapide est requis, mais aucun rembobinage ne sera effectué, il n'y aura donc pas de variations de la latence lors du jeu en réseau."
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_CHECK_FRAMES,
"Vérifier la latence par image du jeu en réseau "

9
intl/msg_hash_id.c
View file

@ -1793,15 +1793,6 @@ int msg_hash_get_help_id_enum(enum msg_hash_enums msg, char *s, size_t len)
"Not recommended except for very fast networks \n"
"with very weak machines.");
break;
case MENU_ENUM_LABEL_NETPLAY_STATELESS_MODE:
snprintf(s, len,
"Whether to run netplay in a mode not requiring"
"save states. \n"
" \n"
"If set to true, a very fast network is required, \n"
"but no rewinding is performed, so there will be \n"
"no netplay jitter. \n");
break;
case MENU_ENUM_LABEL_NETPLAY_CHECK_FRAMES:
snprintf(s, len,
"The frequency in frames with which netplay \n"

8
intl/msg_hash_it.h
View file

@ -5610,14 +5610,6 @@ MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_REQUIRE_SLAVES,
"Non consentire connessioni non in modalità slave. Non consigliato, tranne per reti molto veloci con macchine molto deboli."
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_STATELESS_MODE,
"Modalità senza stato del Netplay"
)
MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_STATELESS_MODE,
"Avvia netplay in una modalità che non richiede stati di salvataggio. È necessaria una rete molto veloce, ma non viene eseguito alcun riavvolgimento, quindi non ci sarà alcun jitter del netplay."
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_CHECK_FRAMES,
"Controllo Netplay Frames"

9
intl/msg_hash_ja.c
View file

@ -1682,15 +1682,6 @@ int msg_hash_get_help_jp_enum(enum msg_hash_enums msg, char *s, size_t len)
"Not recommended except for very fast networks \n"
"with very weak machines. \n");
break;
case MENU_ENUM_LABEL_NETPLAY_STATELESS_MODE:
snprintf(s, len,
"Whether to run netplay in a mode not requiring\n"
"save states. \n"
" \n"
"If set to true, a very fast network is required,\n"
"but no rewinding is performed, so there will be\n"
"no netplay jitter.\n");
break;
case MENU_ENUM_LABEL_NETPLAY_CHECK_FRAMES:
snprintf(s, len,
"The frequency in frames with which netplay \n"

8
intl/msg_hash_ja.h
View file

@ -5002,14 +5002,6 @@ MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_REQUIRE_SLAVES,
"スレーブモードでの接続を禁止します. 非常に弱いマシンがある非常に高速なネットワーク以外では推奨されません."
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_STATELESS_MODE,
"ネットプレイのステートレスモード"
)
MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_STATELESS_MODE,
"セーブステートを必要としないモードでネットプレイを開始します. 非常に高速なネットワークが必要ですが, 巻き戻しは行われないため, ネットプレイのジッターは発生しません."
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_CHECK_FRAMES,
"ネットプレイのチェックフレーム"

9
intl/msg_hash_ko.c
View file

@ -1694,15 +1694,6 @@ int msg_hash_get_help_ko_enum(enum msg_hash_enums msg, char *s, size_t len)
"Not recommended except for very fast networks \n"
"with very weak machines. \n");
break;
case MENU_ENUM_LABEL_NETPLAY_STATELESS_MODE:
snprintf(s, len,
"Whether to run netplay in a mode not requiring\n"
"save states. \n"
" \n"
"If set to true, a very fast network is required,\n"
"but no rewinding is performed, so there will be\n"
"no netplay jitter.\n");
break;
case MENU_ENUM_LABEL_NETPLAY_CHECK_FRAMES:
snprintf(s, len,
"The frequency in frames with which netplay \n"

8
intl/msg_hash_ko.h
View file

@ -5682,14 +5682,6 @@ MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_REQUIRE_SLAVES,
"슬레이브 모드가 아닌 연결을 허용하지 않습니다. 낮은 성능의 컴퓨터와 매우 빠른 네트워크가 있는 경우를 제외하고는 권장하지 않습니다."
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_STATELESS_MODE,
"넷플레이 상태저장금지 모드"
)
MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_STATELESS_MODE,
"상태저장이 필요 없는 모드로 넷플레이를 실행할지 여부를 선택합니다. 매우 빠른 네트워크가 필요하지만 뒤로 감기가 수행되지 않아 지터링이 발생하지 않습니다."
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_CHECK_FRAMES,
"넷플레이 체크 프레임"

4
intl/msg_hash_lbl.h
View file

@ -2118,10 +2118,6 @@ MSG_HASH(
MENU_ENUM_LABEL_NETPLAY_ALLOW_PAUSING,
"netplay_allow_pausing"
)
MSG_HASH(
MENU_ENUM_LABEL_NETPLAY_STATELESS_MODE,
"netplay_stateless_mode"
)
MSG_HASH(
MENU_ENUM_LABEL_NETPLAY_TCP_UDP_PORT,
"netplay_tcp_udp_port"

8
intl/msg_hash_pl.h
View file

@ -5490,14 +5490,6 @@ MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_REQUIRE_SLAVES,
"Nie zezwalaj na połączenia w trybie slave. Niezalecane, z wyjątkiem bardzo szybkich sieci z bardzo słabymi maszynami."
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_STATELESS_MODE,
"Tryb bezstanowej gry online"
)
MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_STATELESS_MODE,
"Rozpocznij grę sieciową w trybie nie wymagającym zapisów stanu. Wymagana jest bardzo szybka sieć, ale przewijanie nie jest wykonywane, więc nie będzie rwania w grze sieciowej."
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_CHECK_FRAMES,
"Sprawdź klatki gry online"

10
intl/msg_hash_pt_br.c
View file

@ -1766,16 +1766,6 @@ int msg_hash_get_help_pt_br_enum(enum msg_hash_enums msg, char *s, size_t len)
"Não recomendado, exceto para redes muito \n"
"rápidas com máquinas muito lentas. \n");
break;
case MENU_ENUM_LABEL_NETPLAY_STATELESS_MODE:
snprintf(s, len,
"Define se o jogo em rede deve executar em um modo \n"
"que não utilize jogos salvos. \n"
" \n"
"Se definido como verdadeiro, uma rede muito \n"
"rápida é necessária, mas Voltar Atrás não é \n"
"permitido, então não haverá oscilação \n"
"no jogo em rede.");
break;
case MENU_ENUM_LABEL_NETPLAY_CHECK_FRAMES:
snprintf(s, len,
"Frequência em quadros na qual o jogo em rede \n"

8
intl/msg_hash_pt_br.h
View file

@ -5626,14 +5626,6 @@ MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_REQUIRE_SLAVES,
"Não permitir conexões fora do modo escravo. Não recomendado, exceto em redes muito rápidas com máquinas muito lentas."
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_STATELESS_MODE,
"Modo sem jogos salvos no jogo em rede"
)
MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_STATELESS_MODE,
"Inicia o jogo em rede em um modo que não exija salvamento de jogos. É necessária uma rede muito rápida, mas nenhuma rebobinagem é realizada, portanto, não haverá tremulação no jogo em rede."
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_CHECK_FRAMES,
"Verificar quadros do jogo em rede"

4
intl/msg_hash_pt_pt.h
View file

@ -2606,10 +2606,6 @@ MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_SPECTATE_PASSWORD,
"Palavra-passe do servidor para espectador"
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_STATELESS_MODE,
"Modo sem estado"
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_CHECK_FRAMES,
"Verificação dos fotogramas de Netplay"

8
intl/msg_hash_ru.h
View file

@ -5686,14 +5686,6 @@ MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_REQUIRE_SLAVES,
"Запрещать подключения не в slave-режиме. Рекомендуется включать только для очень быстрых сетей со слабыми машинами."
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_STATELESS_MODE,
"Режим Netplay без сохранений"
)
MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_STATELESS_MODE,
"Запускать сетевую игру в режиме, не требующем сохранений. Откат не будет использоваться, обеспечивая ровную игру по сети при условии очень быстрого подключения."
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_CHECK_FRAMES,
"Кадры проверки Netplay"

9
intl/msg_hash_sv.c
View file

@ -1793,15 +1793,6 @@ int msg_hash_get_help_sv_enum(enum msg_hash_enums msg, char *s, size_t len)
"Not recommended except for very fast networks \n"
"with very weak machines.");
break;
case MENU_ENUM_LABEL_NETPLAY_STATELESS_MODE:
snprintf(s, len,
"Whether to run netplay in a mode not requiring"
"save states. \n"
" \n"
"If set to true, a very fast network is required, \n"
"but no rewinding is performed, so there will be \n"
"no netplay jitter. \n");
break;
case MENU_ENUM_LABEL_NETPLAY_CHECK_FRAMES:
snprintf(s, len,
"The frequency in frames with which netplay \n"

9
intl/msg_hash_tr.c
View file

@ -1652,15 +1652,6 @@ int msg_hash_get_help_tr_enum(enum msg_hash_enums msg, char *s, size_t len)
"Not recommended except for very fast networks \n"
"with very weak machines. \n");
break;
case MENU_ENUM_LABEL_NETPLAY_STATELESS_MODE:
snprintf(s, len,
"Whether to run netplay in a mode not requiring\n"
"save states. \n"
" \n"
"If set to true, a very fast network is required,\n"
"but no rewinding is performed, so there will be\n"
"no netplay jitter.\n");
break;
case MENU_ENUM_LABEL_NETPLAY_CHECK_FRAMES:
snprintf(s, len,
"The frequency in frames with which netplay \n"

8
intl/msg_hash_tr.h
View file

@ -5658,14 +5658,6 @@ MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_REQUIRE_SLAVES,
"Bağımlı kipte olmayan bağlantılara izin verme. Çok zayıf makineleri olan çok hızlı ağlar dışında önerilmez."
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_STATELESS_MODE,
"Netplay Bölgesiz Kip"
)
MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_STATELESS_MODE,
"Netplay'i durum kaydı gerektirmeyen bir kipte başlatın. Çok hızlı bir ağ gereklidir, ancak geri sarma yapılamaz, bu nedenle netplay gecikmesi olmaz."
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_CHECK_FRAMES,
"Netplay Karelerini Denetle"

9
intl/msg_hash_uk.c
View file

@ -1793,15 +1793,6 @@ int msg_hash_get_help_uk_enum(enum msg_hash_enums msg, char *s, size_t len)
"Not recommended except for very fast networks \n"
"with very weak machines.");
break;
case MENU_ENUM_LABEL_NETPLAY_STATELESS_MODE:
snprintf(s, len,
"Whether to run netplay in a mode not requiring"
"save states. \n"
" \n"
"If set to true, a very fast network is required, \n"
"but no rewinding is performed, so there will be \n"
"no netplay jitter. \n");
break;
case MENU_ENUM_LABEL_NETPLAY_CHECK_FRAMES:
snprintf(s, len,
"The frequency in frames with which netplay \n"

8
intl/msg_hash_uk.h
View file

@ -3398,14 +3398,6 @@ MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_START_AS_SPECTATOR,
"Запустити мережеву гру в режимі споглядача."
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_STATELESS_MODE,
"Режим без стану у мережевій грі"
)
MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_STATELESS_MODE,
"Запускати мережеву гру в режимі, який не вимагає збереження станів. Потрібна дуже швидка мережа, але перемотування не виконується, тому не буде тремтіння мережевої гри."
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_CHECK_FRAMES,
"Перевірка кадрів мережевою грою"

9
intl/msg_hash_us.c
View file

@ -1789,15 +1789,6 @@ int msg_hash_get_help_us_enum(enum msg_hash_enums msg, char *s, size_t len)
"Not recommended except for very fast networks \n"
"with very weak machines.");
break;
case MENU_ENUM_LABEL_NETPLAY_STATELESS_MODE:
snprintf(s, len,
"Whether to run netplay in a mode not requiring"
"save states. \n"
" \n"
"If set to true, a very fast network is required, \n"
"but no rewinding is performed, so there will be \n"
"no netplay jitter. \n");
break;
case MENU_ENUM_LABEL_NETPLAY_CHECK_FRAMES:
snprintf(s, len,
"The frequency in frames with which netplay \n"

8
intl/msg_hash_us.h
View file

@ -5730,14 +5730,6 @@ MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_REQUIRE_SLAVES,
"Disallow connections not in slave mode. Not recommended except for very fast networks with very weak machines."
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_STATELESS_MODE,
"Netplay Stateless Mode"
)
MSG_HASH(
MENU_ENUM_SUBLABEL_NETPLAY_STATELESS_MODE,
"Start netplay in a mode not requiring save states. A very fast network is required, but no rewinding is performed, so there will be no netplay jitter."
)
MSG_HASH(
MENU_ENUM_LABEL_VALUE_NETPLAY_CHECK_FRAMES,
"Netplay Check Frames"

4
menu/cbs/menu_cbs_sublabel.c
View file

@ -747,7 +747,6 @@ DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_netplay_chat_color_msg, MENU_
DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_netplay_allow_pausing, MENU_ENUM_SUBLABEL_NETPLAY_ALLOW_PAUSING)
DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_netplay_allow_slaves, MENU_ENUM_SUBLABEL_NETPLAY_ALLOW_SLAVES)
DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_netplay_require_slaves, MENU_ENUM_SUBLABEL_NETPLAY_REQUIRE_SLAVES)
DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_netplay_stateless_mode, MENU_ENUM_SUBLABEL_NETPLAY_STATELESS_MODE)
DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_netplay_check_frames, MENU_ENUM_SUBLABEL_NETPLAY_CHECK_FRAMES)
DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_netplay_nat_traversal, MENU_ENUM_SUBLABEL_NETPLAY_NAT_TRAVERSAL)
DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_stdin_cmd_enable, MENU_ENUM_SUBLABEL_STDIN_CMD_ENABLE)
@ -3301,9 +3300,6 @@ int menu_cbs_init_bind_sublabel(menu_file_list_cbs_t *cbs,
case MENU_ENUM_LABEL_NETPLAY_REQUIRE_SLAVES:
BIND_ACTION_SUBLABEL(cbs, action_bind_sublabel_netplay_require_slaves);
break;
case MENU_ENUM_LABEL_NETPLAY_STATELESS_MODE:
BIND_ACTION_SUBLABEL(cbs, action_bind_sublabel_netplay_stateless_mode);
break;
case MENU_ENUM_LABEL_NETPLAY_PASSWORD:
BIND_ACTION_SUBLABEL(cbs, action_bind_sublabel_netplay_password);
break;

1
menu/menu_displaylist.c
View file

@ -7894,7 +7894,6 @@ unsigned menu_displaylist_build_list(
{MENU_ENUM_LABEL_NETPLAY_ALLOW_PAUSING, PARSE_ONLY_BOOL, true},
{MENU_ENUM_LABEL_NETPLAY_ALLOW_SLAVES, PARSE_ONLY_BOOL, true},
{MENU_ENUM_LABEL_NETPLAY_REQUIRE_SLAVES, PARSE_ONLY_BOOL, false},
/*{MENU_ENUM_LABEL_NETPLAY_STATELESS_MODE, PARSE_ONLY_BOOL, true},*/
{MENU_ENUM_LABEL_NETPLAY_CHECK_FRAMES, PARSE_ONLY_INT, true},
{MENU_ENUM_LABEL_NETPLAY_INPUT_LATENCY_FRAMES_MIN, PARSE_ONLY_INT, true},
{MENU_ENUM_LABEL_NETPLAY_INPUT_LATENCY_FRAMES_RANGE, PARSE_ONLY_INT, true},

16
menu/menu_setting.c
View file

@ -20060,22 +20060,6 @@ static bool setting_append_list(
SD_FLAG_NONE);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
CONFIG_BOOL(
list, list_info,
&settings->bools.netplay_stateless_mode,
MENU_ENUM_LABEL_NETPLAY_STATELESS_MODE,
MENU_ENUM_LABEL_VALUE_NETPLAY_STATELESS_MODE,
false,
MENU_ENUM_LABEL_VALUE_OFF,
MENU_ENUM_LABEL_VALUE_ON,
&group_info,
&subgroup_info,
parent_group,
general_write_handler,
general_read_handler,
SD_FLAG_NONE);
SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
CONFIG_INT(
list, list_info,
&settings->ints.netplay_check_frames,

1
msg_hash.h
View file

@ -2017,7 +2017,6 @@ enum msg_hash_enums
MENU_LABEL(NETPLAY_ALLOW_PAUSING),
MENU_LABEL(NETPLAY_ALLOW_SLAVES),
MENU_LABEL(NETPLAY_REQUIRE_SLAVES),
MENU_LABEL(NETPLAY_STATELESS_MODE),
MENU_LABEL(NETPLAY_CHECK_FRAMES),
MENU_LABEL(NETPLAY_INPUT_LATENCY_FRAMES_MIN),
MENU_LABEL(NETPLAY_INPUT_LATENCY_FRAMES_RANGE),

1
network/netplay/netplay.h
View file

@ -277,7 +277,6 @@ typedef struct
bool has_set_netplay_mode;
bool has_set_netplay_ip_address;
bool has_set_netplay_ip_port;
bool has_set_netplay_stateless_mode;
bool has_set_netplay_check_frames;
} net_driver_state_t;

253
network/netplay/netplay_frontend.c
View file

@ -1122,9 +1122,7 @@ static void netplay_handshake_ready(netplay_t *netplay,
slot);
/* Send them the savestate */
if (!(netplay->quirks &
(NETPLAY_QUIRK_NO_SAVESTATES | NETPLAY_QUIRK_NO_TRANSMISSION)))
netplay->force_send_savestate = true;
netplay->force_send_savestate = true;
}
else
{
@ -3576,12 +3574,11 @@ static struct netplay_connection *allocate_connection(netplay_t *netplay)
*/
static bool netplay_sync_pre_frame(netplay_t *netplay, bool *disconnect)
{
if (netplay_delta_frame_ready(netplay, &netplay->buffer[netplay->run_ptr],
netplay->run_frame_count) && netplay->run_frame_count > 0)
if (netplay->run_frame_count > 0 && netplay_delta_frame_ready(netplay,
&netplay->buffer[netplay->run_ptr], netplay->run_frame_count))
{
/* Don't serialize until it's safe */
if (!(netplay->quirks &
(NETPLAY_QUIRK_INITIALIZATION | NETPLAY_QUIRK_NO_SAVESTATES)))
if (!(netplay->quirks & NETPLAY_QUIRK_INITIALIZATION))
{
retro_ctx_serialize_info_t serial_info = {0};
bool okay = false;
@ -3621,31 +3618,10 @@ static bool netplay_sync_pre_frame(netplay_t *netplay, bool *disconnect)
}
else
{
/* If the core can't serialize properly, we must stall for the
* remote input on EVERY frame, because we can't recover */
netplay->quirks |= NETPLAY_QUIRK_NO_SAVESTATES;
netplay->stateless_mode = true;
*disconnect = true;
goto process;
}
}
/* If we can't transmit savestates, we must stall
* until the client is ready. */
if (netplay->quirks &
(NETPLAY_QUIRK_NO_SAVESTATES | NETPLAY_QUIRK_NO_TRANSMISSION))
{
size_t i;
for (i = 0; i < netplay->connections_size; i++)
{
struct netplay_connection *connection = &netplay->connections[i];
if (connection->active &&
connection->mode >= NETPLAY_CONNECTION_CONNECTED)
break;
}
if (i >= netplay->connections_size)
netplay->stall = NETPLAY_STALL_NO_CONNECTION;
}
}
if (netplay->is_server)
@ -5236,8 +5212,6 @@ static bool netplay_get_cmd(netplay_t *netplay,
(unsigned) (connection - netplay->connections));
#endif
netplay->timeout_cnt = 0;
switch (cmd)
{
case NETPLAY_CMD_ACK:
@ -6343,9 +6317,10 @@ static bool netplay_get_cmd(netplay_t *netplay,
}
netplay_recv_flush(&connection->recv_packet_buffer);
netplay->timeout_cnt = 0;
if (had_input)
*had_input = true;
return true;
shrt:
@ -6361,108 +6336,27 @@ shrt:
*
* Poll input from the network
*/
static int netplay_poll_net_input(netplay_t *netplay, bool block)
static void netplay_poll_net_input(netplay_t *netplay)
{
size_t i;
bool had_input;
netplay->timeout_cnt = 0;
struct netplay_connection *connection;
do
{
had_input = false;
/* Read input from each connection */
/* Read input from each connection. */
for (i = 0; i < netplay->connections_size; i++)
{
struct netplay_connection *connection = &netplay->connections[i];
connection = &netplay->connections[i];
if (connection->active)
{
if (!netplay_get_cmd(netplay, connection, &had_input))
netplay_hangup(netplay, connection);
}
if (block)
{
netplay_update_unread_ptr(netplay);
/* If we were blocked for input, pass if we have this frame's input */
if (netplay->unread_frame_count > netplay->run_frame_count)
break;
/* If we're supposed to block but we didn't have enough input, wait for it */
if (!had_input)
{
#ifdef NETWORK_HAVE_POLL
struct pollfd fds[MAX_CLIENTS - 1];
unsigned nfds = 0;
#else
fd_set fds;
int max_fd = -1;
struct timeval tv = {0};
#endif
if (netplay->timeout_cnt >= MAX_RETRIES && !netplay->remote_paused)
return -1;
#ifdef NETWORK_HAVE_POLL
for (i = 0; i < netplay->connections_size; i++)
{
struct netplay_connection *connection = &netplay->connections[i];
if (connection->active)
{
struct pollfd *fd = &fds[nfds++];
NET_POLL_FD(connection->fd, fd);
fd->events = POLLIN;
fd->revents = 0;
}
}
if (!nfds)
break;
#else
FD_ZERO(&fds);
for (i = 0; i < netplay->connections_size; i++)
{
struct netplay_connection *connection = &netplay->connections[i];
if (connection->active)
{
FD_SET(connection->fd, &fds);
if (connection->fd > max_fd)
max_fd = connection->fd;
}
}
if (max_fd < 0)
break;
tv.tv_usec = RETRY_MS * 1000;
#endif
netplay->timeout_cnt++;
RARCH_LOG(
"[Netplay] Network is stalling at frame %lu, count %u of %d ...\n",
(unsigned long)netplay->run_frame_count,
netplay->timeout_cnt,
MAX_RETRIES);
#ifdef NETWORK_HAVE_POLL
if (socket_poll(fds, nfds, RETRY_MS) < 0)
#else
if (socket_select(max_fd + 1, &fds, NULL, NULL, &tv) < 0)
#endif
return -1;
}
}
} while (had_input || block);
return 0;
} while (had_input);
}
/**
@ -6905,19 +6799,13 @@ static bool netplay_init_serialization(netplay_t *netplay)
{
netplay->buffer[i].state = calloc(1, netplay->state_size);
if (!netplay->buffer[i].state)
{
netplay->quirks |= NETPLAY_QUIRK_NO_SAVESTATES;
netplay->stateless_mode = true;
return false;
}
}
netplay->zbuffer_size = netplay->state_size * 2;
netplay->zbuffer = (uint8_t*)calloc(1, netplay->zbuffer_size);
if (!netplay->zbuffer)
{
netplay->quirks |= NETPLAY_QUIRK_NO_TRANSMISSION;
netplay->zbuffer_size = 0;
return false;
@ -6957,7 +6845,7 @@ static bool netplay_try_init_serialization(netplay_t *netplay)
return false;
/* Once initialized, we no longer exhibit this quirk */
netplay->quirks &= ~((uint64_t) NETPLAY_QUIRK_INITIALIZATION);
netplay->quirks &= ~((uint32_t)NETPLAY_QUIRK_INITIALIZATION);
return netplay_init_socket_buffers(netplay);
}
@ -6997,27 +6885,26 @@ bool netplay_wait_and_init_serialization(netplay_t *netplay)
static bool netplay_init_buffers(netplay_t *netplay)
{
struct delta_frame *delta_frames = NULL;
/* Enough to get ahead or behind by MAX_STALL_FRAMES frames, plus one for
* other remote clients, plus one to send the stall message */
/* Enough to get ahead or behind by MAX_STALL_FRAMES frames,
plus one for other remote clients,
plus one to send the stall message. */
netplay->buffer_size = NETPLAY_MAX_STALL_FRAMES + 2;
/* If we're the server, we need enough to get ahead AND behind by
* MAX_STALL_FRAMES frame */
/* If we're the server,
we need enough to get ahead AND behind by MAX_STALL_FRAMES frame. */
if (netplay->is_server)
netplay->buffer_size *= 2;
delta_frames = (struct delta_frame*)calloc(netplay->buffer_size,
sizeof(*delta_frames));
if (!delta_frames)
netplay->buffer = (struct delta_frame*)calloc(netplay->buffer_size,
sizeof(*netplay->buffer));
if (!netplay->buffer)
return false;
netplay->buffer = delta_frames;
if (!(netplay->quirks & (NETPLAY_QUIRK_NO_SAVESTATES|NETPLAY_QUIRK_INITIALIZATION)))
netplay_init_serialization(netplay);
if (!(netplay->quirks & NETPLAY_QUIRK_INITIALIZATION))
{
if (!netplay_init_serialization(netplay))
return false;
}
return netplay_init_socket_buffers(netplay);
}
@ -7096,7 +6983,6 @@ static void netplay_free(netplay_t *netplay)
* @mitm : IP address of the MITM/tunnel server.
* @port : Port of server.
* @mitm_session : Session id for MITM/tunnel.
* @stateless_mode : Shall we use stateless mode?
* @check_frames : Frequency with which to check CRCs.
* @cb : Libretro callbacks.
* @nat_traversal : If true, attempt NAT traversal.
@ -7109,10 +6995,9 @@ static void netplay_free(netplay_t *netplay)
* Returns: new netplay data.
*/
static netplay_t *netplay_new(const char *server, const char *mitm,
uint16_t port, const char *mitm_session,
bool stateless_mode, int check_frames,
const struct retro_callbacks *cb, bool nat_traversal, const char *nick,
uint64_t quirks)
uint16_t port, const char *mitm_session,
int check_frames, const struct retro_callbacks *cb, bool nat_traversal,
const char *nick, uint32_t quirks)
{
settings_t *settings = config_get_ptr();
netplay_t *netplay = (netplay_t*)calloc(1, sizeof(*netplay));
@ -7120,20 +7005,16 @@ static netplay_t *netplay_new(const char *server, const char *mitm,
if (!netplay)
return NULL;
netplay->listen_fd = -1;
netplay->tcp_port = port;
netplay->ext_tcp_port = port;
netplay->cbs = *cb;
netplay->is_server = !server;
netplay->nat_traversal = (!server && !mitm) ? nat_traversal : false;
netplay->stateless_mode = stateless_mode;
netplay->check_frames = check_frames;
netplay->crcs_valid = true;
netplay->quirks = quirks;
netplay->simple_rand_next = 1;
if (netplay->stateless_mode)
netplay->quirks |= NETPLAY_QUIRK_NO_SAVESTATES;
netplay->listen_fd = -1;
netplay->tcp_port = port;
netplay->ext_tcp_port = port;
netplay->cbs = *cb;
netplay->is_server = !server;
netplay->nat_traversal = (!server && !mitm) ? nat_traversal : false;
netplay->check_frames = check_frames;
netplay->crcs_valid = true;
netplay->quirks = quirks;
netplay->simple_rand_next = 1;
netplay_key_init(netplay);
@ -7462,12 +7343,6 @@ void netplay_load_savestate(netplay_t *netplay,
if (netplay->desync)
return;
/* If we can't send it to the peer, loading a state was a bad idea */
if (netplay->quirks & (
NETPLAY_QUIRK_NO_SAVESTATES
| NETPLAY_QUIRK_NO_TRANSMISSION))
return;
/* Send this to every peer */
if (netplay->compress_nil.compression_backend)
netplay_send_savestate(netplay, serial_info, 0, &netplay->compress_nil);
@ -7775,15 +7650,8 @@ static bool netplay_poll(netplay_t *netplay, bool block_libretro_input)
netplay_update_unread_ptr(netplay);
/* Read netplay input,
block if we're configured to stall for input every frame. */
{
bool block = netplay->stateless_mode && netplay->connected_players > 1 &&
netplay->unread_frame_count <= netplay->run_frame_count;
if (netplay_poll_net_input(netplay, block) == -1)
goto catastrophe;
}
/* Read netplay input. */
netplay_poll_net_input(netplay);
/* Resolve and/or simulate the input if we don't have real input. */
netplay_resolve_input(netplay, netplay->run_ptr, false);
@ -7796,23 +7664,7 @@ static bool netplay_poll(netplay_t *netplay, bool block_libretro_input)
/* Figure out how many frames of input latency we should be using to
hide network latency. */
if (netplay->stateless_mode)
{
int input_latency_frames_min = (int)netplay->input_latency_frames_min;
int input_latency_frames_max = (int)netplay->input_latency_frames_max;
/* In stateless mode, we adjust up if we're "close"
and down if we have a lot of slack. */
if (netplay->input_latency_frames < input_latency_frames_min ||
(netplay->unread_frame_count == (netplay->run_frame_count + 1) &&
netplay->input_latency_frames < input_latency_frames_max))
netplay->input_latency_frames++;
else if (netplay->input_latency_frames > input_latency_frames_max ||
(netplay->unread_frame_count > (netplay->run_frame_count + 2) &&
netplay->input_latency_frames > input_latency_frames_min))
netplay->input_latency_frames--;
}
else if (netplay->frame_run_time_avg)
if (netplay->frame_run_time_avg)
{
/* FIXME: Using fixed 60fps for this calculation */
unsigned frames_per_frame = netplay->frame_run_time_avg ?
@ -8651,7 +8503,7 @@ bool init_netplay(const char *server, unsigned port, const char *mitm_session)
netplay_t *netplay;
struct retro_callbacks cbs = {0};
uint64_t serialization_quirks = 0;
uint64_t quirks = 0;
uint32_t quirks = 0;
settings_t *settings = config_get_ptr();
net_driver_state_t *net_st = &networking_driver_st;
struct netplay_room *host_room = &net_st->host_room;
@ -8667,9 +8519,8 @@ bool init_netplay(const char *server, unsigned port, const char *mitm_session)
serialization_quirks = core_serialization_quirks();
if (!core_info_current_supports_netplay() ||
(serialization_quirks & ~((uint64_t)NETPLAY_QUIRK_MAP_UNDERSTOOD)) ||
(serialization_quirks & (NETPLAY_QUIRK_MAP_NO_SAVESTATES |
NETPLAY_QUIRK_MAP_NO_TRANSMISSION)))
serialization_quirks & (RETRO_SERIALIZATION_QUIRK_INCOMPLETE |
RETRO_SERIALIZATION_QUIRK_SINGLE_SESSION))
{
RARCH_ERR("[Netplay] %s\n", msg_hash_to_str(MSG_NETPLAY_UNSUPPORTED));
runloop_msg_queue_push(
@ -8682,12 +8533,12 @@ bool init_netplay(const char *server, unsigned port, const char *mitm_session)
if (!core_set_netplay_callbacks())
goto failure;
/* Map the core's quirks to our quirks */
if (serialization_quirks & NETPLAY_QUIRK_MAP_INITIALIZATION)
/* Map the core's quirks to our quirks. */
if (serialization_quirks & RETRO_SERIALIZATION_QUIRK_MUST_INITIALIZE)
quirks |= NETPLAY_QUIRK_INITIALIZATION;
if (serialization_quirks & NETPLAY_QUIRK_MAP_ENDIAN_DEPENDENT)
if (serialization_quirks & RETRO_SERIALIZATION_QUIRK_ENDIAN_DEPENDENT)
quirks |= NETPLAY_QUIRK_ENDIAN_DEPENDENT;
if (serialization_quirks & NETPLAY_QUIRK_MAP_PLATFORM_DEPENDENT)
if (serialization_quirks & RETRO_SERIALIZATION_QUIRK_PLATFORM_DEPENDENT)
quirks |= NETPLAY_QUIRK_PLATFORM_DEPENDENT;
if (!net_st->netplay_is_client)
@ -8733,8 +8584,6 @@ bool init_netplay(const char *server, unsigned port, const char *mitm_session)
netplay = netplay_new(
server, mitm, port, mitm_session,
/*settings->bools.netplay_stateless_mode,*/
false,
settings->ints.netplay_check_frames,
&cbs,
settings->bools.netplay_nat_traversal,

43
network/netplay/netplay_private.h
View file

@ -63,33 +63,9 @@
/* Quirks mandated by how particular cores save states. This is distilled from
* the larger set of quirks that the quirks environment can communicate. */
#define NETPLAY_QUIRK_NO_SAVESTATES (1<<0)
#define NETPLAY_QUIRK_NO_TRANSMISSION (1<<1)
#define NETPLAY_QUIRK_INITIALIZATION (1<<2)
#define NETPLAY_QUIRK_ENDIAN_DEPENDENT (1<<3)
#define NETPLAY_QUIRK_PLATFORM_DEPENDENT (1<<4)
/* Mapping of serialization quirks to netplay quirks. */
#define NETPLAY_QUIRK_MAP_UNDERSTOOD (\
RETRO_SERIALIZATION_QUIRK_INCOMPLETE |\
RETRO_SERIALIZATION_QUIRK_MUST_INITIALIZE |\
RETRO_SERIALIZATION_QUIRK_CORE_VARIABLE_SIZE |\
RETRO_SERIALIZATION_QUIRK_FRONT_VARIABLE_SIZE |\
RETRO_SERIALIZATION_QUIRK_SINGLE_SESSION |\
RETRO_SERIALIZATION_QUIRK_ENDIAN_DEPENDENT |\
RETRO_SERIALIZATION_QUIRK_PLATFORM_DEPENDENT \
)
#define NETPLAY_QUIRK_MAP_NO_SAVESTATES \
(RETRO_SERIALIZATION_QUIRK_INCOMPLETE)
#define NETPLAY_QUIRK_MAP_NO_TRANSMISSION \
(RETRO_SERIALIZATION_QUIRK_SINGLE_SESSION)
#define NETPLAY_QUIRK_MAP_INITIALIZATION \
(RETRO_SERIALIZATION_QUIRK_MUST_INITIALIZE)
#define NETPLAY_QUIRK_MAP_ENDIAN_DEPENDENT \
(RETRO_SERIALIZATION_QUIRK_ENDIAN_DEPENDENT)
#define NETPLAY_QUIRK_MAP_PLATFORM_DEPENDENT \
(RETRO_SERIALIZATION_QUIRK_PLATFORM_DEPENDENT)
#define NETPLAY_QUIRK_INITIALIZATION (1 << 0)
#define NETPLAY_QUIRK_ENDIAN_DEPENDENT (1 << 1)
#define NETPLAY_QUIRK_PLATFORM_DEPENDENT (1 << 2)
/* Compression protocols supported */
#define NETPLAY_COMPRESSION_ZLIB (1<<0)
@ -484,9 +460,6 @@ struct netplay_chat
struct netplay
{
/* Quirks in the savestate implementation */
uint64_t quirks;
/* We stall if we're far enough ahead that we
* couldn't transparently rewind.
* To know if we could transparently rewind,
@ -561,6 +534,9 @@ struct netplay
/* Pseudo random seed */
unsigned long simple_rand_next;
/* Quirks in the savestate implementation */
uint32_t quirks;
/* Our client number */
uint32_t self_client_num;
@ -604,9 +580,6 @@ struct netplay
int32_t input_latency_frames_min;
int32_t input_latency_frames_max;
/* Counter for timeouts */
unsigned timeout_cnt;
/* TCP connection for listening (server only) */
int listen_fd;
@ -651,10 +624,6 @@ struct netplay
* up/down states will proceed as expected. */
bool have_updown_device;
/* If true, never progress without peer input
* (stateless/rewindless mode) */
bool stateless_mode;
/* Are we the server? */
bool is_server;

18
retroarch.c
View file

@ -262,7 +262,6 @@
enum
{
RA_OPT_MENU = 256, /* must be outside the range of a char */
RA_OPT_STATELESS,
RA_OPT_CHECK_FRAMES,
RA_OPT_PORT,
RA_OPT_SPECTATE,
@ -3473,9 +3472,6 @@ void retroarch_override_setting_set(
case RARCH_OVERRIDE_SETTING_NETPLAY_IP_PORT:
net_st->has_set_netplay_ip_port = true;
break;
case RARCH_OVERRIDE_SETTING_NETPLAY_STATELESS_MODE:
net_st->has_set_netplay_stateless_mode = true;
break;
case RARCH_OVERRIDE_SETTING_NETPLAY_CHECK_FRAMES:
net_st->has_set_netplay_check_frames = true;
break;
@ -3550,9 +3546,6 @@ void retroarch_override_setting_unset(
case RARCH_OVERRIDE_SETTING_NETPLAY_IP_PORT:
net_st->has_set_netplay_ip_port = false;
break;
case RARCH_OVERRIDE_SETTING_NETPLAY_STATELESS_MODE:
net_st->has_set_netplay_stateless_mode = false;
break;
case RARCH_OVERRIDE_SETTING_NETPLAY_CHECK_FRAMES:
net_st->has_set_netplay_check_frames = false;
break;
@ -4538,7 +4531,6 @@ static bool retroarch_parse_input_and_config(
#ifdef HAVE_NETWORKING
{ "host", 0, NULL, 'H' },
{ "connect", 1, NULL, 'C' },
{ "stateless", 0, NULL, RA_OPT_STATELESS },
{ "check-frames", 1, NULL, RA_OPT_CHECK_FRAMES },
{ "port", 1, NULL, RA_OPT_PORT },
#ifdef HAVE_NETWORK_CMD
@ -4933,14 +4925,6 @@ static bool retroarch_parse_input_and_config(
p_rarch->connect_host = strdup(optarg);
break;
case RA_OPT_STATELESS:
configuration_set_bool(settings,
settings->bools.netplay_stateless_mode, true);
retroarch_override_setting_set(
RARCH_OVERRIDE_SETTING_NETPLAY_STATELESS_MODE, NULL);
break;
case RA_OPT_CHECK_FRAMES:
retroarch_override_setting_set(
RARCH_OVERRIDE_SETTING_NETPLAY_CHECK_FRAMES, NULL);
@ -5922,8 +5906,6 @@ bool retroarch_override_setting_is_set(
return net_st->has_set_netplay_ip_address;
case RARCH_OVERRIDE_SETTING_NETPLAY_IP_PORT:
return net_st->has_set_netplay_ip_port;
case RARCH_OVERRIDE_SETTING_NETPLAY_STATELESS_MODE:
return net_st->has_set_netplay_stateless_mode;
case RARCH_OVERRIDE_SETTING_NETPLAY_CHECK_FRAMES:
return net_st->has_set_netplay_check_frames;
#endif

1
retroarch_types.h
View file

@ -152,7 +152,6 @@ enum rarch_override_setting
RARCH_OVERRIDE_SETTING_NETPLAY_MODE,
RARCH_OVERRIDE_SETTING_NETPLAY_IP_ADDRESS,
RARCH_OVERRIDE_SETTING_NETPLAY_IP_PORT,
RARCH_OVERRIDE_SETTING_NETPLAY_STATELESS_MODE,
RARCH_OVERRIDE_SETTING_NETPLAY_CHECK_FRAMES,
#endif
RARCH_OVERRIDE_SETTING_UPS_PREF,

1
ui/drivers/qt/qt_options.cpp
View file

@ -435,7 +435,6 @@ QWidget *NetplayPage::widget()
slaveGroup->add(MENU_ENUM_LABEL_NETPLAY_ALLOW_SLAVES);
slaveGroup->add(MENU_ENUM_LABEL_NETPLAY_REQUIRE_SLAVES);
//syncGroup->add(MENU_ENUM_LABEL_NETPLAY_STATELESS_MODE);
syncGroup->add(MENU_ENUM_LABEL_NETPLAY_CHECK_FRAMES);
syncGroup->add(MENU_ENUM_LABEL_NETPLAY_INPUT_LATENCY_FRAMES_MIN);
syncGroup->add(MENU_ENUM_LABEL_NETPLAY_INPUT_LATENCY_FRAMES_RANGE);