Wiki yi de

Raknetify2 · ייִדיש (אשכנזיש יידן)

שפראך

• הויפּטזײַט
• אינסטאַלירן
• Velocity און BungeeCord
• אײַנשטעלן דעם פֿײַערוואַל און דעם רוטער
• קאָמפּאַטיביליטעט
• דער סדרדיקער מאָדוס
• אויטאָמאַטיש אַריבערפֿירן שפּילער
• ווײַטערשיקן UDP און דער PROXY־פּראָטאָקאָל
• Simple Voice Chat
• הילף בײַ פּראָבלעמען
• צופּאַסן אַ מאָד צו Raknetify2
• UDP־פּראָקסיס

מערשפּילער

נעץ־פֿאַרבינדונגען דורך RakNet פֿאַר Minecraft־קליענטן און סערווערס.

אראפלאדן · GitHub

Minecraft	Raknetify2	קליענט / סערווער
Fabric	mods/raknetify2-fabric-*.jar	קליענט / סערווער
Forge	mods/raknetify2-forge-*.jar	קליענט / סערווער
NeoForge	mods/raknetify2-neoforge-*.jar	קליענט / סערווער
Spigot / Paper	plugins/raknetify2-spigot-*.jar	סערווער
Velocity	plugins/raknetify2-velocity-*.jar	Velocity
BungeeCord	plugins/raknetify2-bungee-*.jar	BungeeCord

סערווער צוגעבן

1. מערשפּילער

2. סערווער צוגעבן

3. סערוועראדרעסע

   	סערוועראדרעסע
   RakNet · UDP	raknet;play.example.com:25565
   TCP	play.example.com:25565

4. געטאן

5. סערווער בייַטרעטן

F3 · Raknetify2

	F3
RakNet · UDP	אַקטיוו · MTU 1400
TCP	נישט אַקטיוו

Velocity / BungeeCord

1. קליענט · Raknetify2 → UDP → Velocity / BungeeCord · Raknetify2
2. Velocity / BungeeCord → TCP → סערווער

	פּאָרט נומער · UDP	Java
Fabric / Forge / NeoForge	1–65534	-Draknetify.fabric.portOverride=25570
Spigot / Paper ≥ 0.1.0-beta.1.431	1–65535	-Draknetify.spigot.portOverride=25570
Velocity	1–65534	-Draknetify.velocity.portOverride=25570
BungeeCord	1–65534	-Draknetify.bungee.portOverride=25570

צייַטיבערשרייַטונג

סערוועראדרעסע	UDP
raknet;play.example.com:25580	play.example.com:25580 → NAT → 192.0.2.10:25570
סערווער · 192.0.2.10	25570/udp

config/raknetify2-compatibility.json

סערווער / Velocity / BungeeCord

	JSON
① ② ③	{"mode":"ordered"}
① ∥ ② ∥ ③	{"mode":"multichannel"}

Simple Voice Chat

סערווער	Raknetify2 · UDP 25565	Simple Voice Chat
Fabric / Forge / NeoForge	config/raknetify2-voicechat.json · {"enabled":true}	config/voicechat/voicechat-server.properties · port=-1
Spigot / Paper	config/raknetify2-voicechat.json · {"enabled":true}	plugins/voicechat/voicechat-server.properties · port=-1

Simple Voice Chat · Velocity / BungeeCord

PROXY protocol v2 · UDP

סערוועראדרעסע	trustedProxies	RakNet
192.0.2.10 · PROXY v2 / UDP	["192.0.2.10"]	✓
192.0.2.11 · PROXY v2 / UDP	["192.0.2.10"]	✗
קליענט → RakNet / UDP	["192.0.2.10"]	✗

config/raknetify2-proxy-protocol.json

{"trustedProxies":["192.0.2.10"]}

Minecraft ≥ 1.20.5 · /transfer

1. סערווער A · Fabric / Forge / NeoForge · config/raknetify2-transfers.json

   {"destinations":[{"host":"play.example.com","tcpPort":25565,"udpPort":25570}]}

2. סערווער B · play.example.com · server.properties → accepts-transfers=true

3. סערווער A · /transfer play.example.com 25565 Alex → קליענט (Alex) → RakNet · play.example.com:25570

PacketOrdering

	Minecraft
ui	אפּציעס
entity	סקעלעט
world_interaction	ינוואַנטאָרי
effects	פּארטיקלן
chunk	בלאקן

PacketOrdering.java

ינקאַמפּאַטאַבאַל ווערסיע!

• Fabric · Minecraft / Java · English
• Forge / NeoForge / Spigot / Paper · GitHub Releases

באריכט באַגז

הויפּטזײַט

Raknetify2

בײַ אַ Minecraft־שפּיל מיט עטלעכע שפּילער שיקט Raknetify2 די דאַטן דורך RakNet איבער UDP. די פּאַקעטן ווערן צעטיילט אויף קאַנאַלן, יעדער מיט זײַן אייגענער ריי. אויב אַ פּאַקעט גייט פֿאַרלוירן אויף איין קאַנאַל, קענען די פּאַקעטן אויף די אַנדערע קאַנאַלן ווײַטערגיין. אַזוי קען דאָס שפּיל גיכער רעאַגירן בשעת מע שיקט איבער פֿאַרלוירענע דאַטן אָדער שיקט שטיקער פֿון דער וועלט.

Raknetify2 איז אַ באַזונדערער צווײַג פֿון Raknetify, וואָס ishland האָט אָריגינעל געשאַפֿן. דער צווײַג ווערט ווײַטער אַנטוויקלט באַזונדער. ער שטיצט נײַערע Minecraft־ווערסיעס און האַלט אין אָרדענונג דעם נעץ־קאָד, די פֿאַרבינדונגען מיט פֿאַרשידענע פּלאַטפֿאָרמעס און די פּרוּוון אויף קאָמפּאַטיביליטעט.

פֿון וואַנען אָנהייבן

1. קוקט וועלכע Minecraft־ווערסיעס און מאָדס אַרבעטן צוזאַמען.
2. קלײַבט אַ טעקע, לאָדט זי אַראָפּ און אינסטאַלירט זי.
3. פֿאַרבינדט זיך מיט אַן אַדרעס ווי raknet;play.example.com.

אָנווײַזונגען פֿאַר סערווער־פֿאַרוואַלטער

• Velocity און BungeeCord
• אײַנשטעלן דעם פֿײַערוואַל און דעם רוטער
• אויטאָמאַטיש אַריבערפֿירן שפּילער
• ווײַטערשיקן UDP און דער PROXY־פּראָטאָקאָל
• באַניצן איין UDP־פּאָרט צוזאַמען מיט Simple Voice Chat
• אויסגעפֿינען די סיבה פֿון אַ פּראָבלעם און מעלדן פֿעלערן

מחברים פֿון מאָדס קענען דורך דעם צווישנבינד פֿאַר דער ריי פֿון פּאַקעטן אָנגעבן וועלכע אייגענע דאַטן דאַרפֿן אָנקומען אין דער זעלבער ריי ווי געוויסע Minecraft־פּאַקעטן.

פֿאַרבינדונגען צום פּראָיעקט

• אַראָפּלאָדן
• קוואַל־קאָד
• פֿעלער־באַריכטן
• אַנדערע מאָדס · English

Raknetify2 ווערט פֿאַרשפּרייט אונטער דער MIT־ליצענץ און היט אָפּ די אָריגינעלע אָנזאָגן וועגן מחבר־רעכט. זײַן נעץ־קאָד בויט זיך אויף Raknetify און netty-raknet.

אינסטאַלירן

לאָדט אַראָפּ אַן אויסגאַבע פֿון GitHub Releases. איידער איר אינסטאַלירט זי, קוקט וועלכע Minecraft־ווערסיע און וועלכן מאָד־לאָדער זי פֿאָדערט.

וווּ מע אינסטאַלירט	טעקע	פֿאַרצייכעניש
Fabric־קליענט אָדער סערווער	raknetify2-fabric-*.jar	mods
Forge־קליענט אָדער סערווער	raknetify2-forge-*.jar	mods
NeoForge־קליענט אָדער סערווער	raknetify2-neoforge-*.jar	mods
Spigot־ אָדער Paper־סערווער	raknetify2-spigot-*.jar	plugins
Velocity־פּראָקסי	raknetify2-velocity-*.jar	plugins
BungeeCord־פּראָקסי	raknetify2-bungee-*.jar	plugins

מאַכט צו דעם קליענט אָדער שטעלט אָפּ דעם סערווער איידער איר בײַט אויס זײַן JAR. נעמט אַוועק די אָריגינעלע Raknetify־JAR און אַלע עלטערע Raknetify2־JAR־טעקעס פֿון דער זעלבער אינסטאַלאַציע איידער איר לייגט צו די נײַע טעקע.

די קליענט־פֿאַרצייכענישן געפֿינען זיך בײַ יענעם Minecraft־עקזעמפּלאַר אָדער מאָדפּאַק וואָס איר הייבט אָן. די סערווער־ און פּראָקסי־פֿאַרצייכענישן געפֿינען זיך וווּ דער באַטרעפֿנדיקער סערווער אָדער פּראָקסי איז אינסטאַלירט. אויב דער לאָדער האָט נאָך נישט געשאַפֿן דאָס נייטיקע פֿאַרצייכעניש, שאַפֿט עס.

אַ דירעקטע פֿאַרבינדונג מיטן סערווער

1. אינסטאַלירט דעם קליענט־מאָד וואָס פּאַסט צו אײַער לאָדער.
2. אינסטאַלירט דעם צוגעפּאַסטן סערווער־מאָד, אָדער דעם Spigot/Paper־צוגאָב אויף אַ סערווער וואָס שטיצט אים.
3. פֿאָלגט די אָנווײַזונגען פֿאַרן פֿײַערוואַל און רוטער כּדי אַרײַנצולאָזן UDP־פֿאַרבינדונגען צום סערווער.
4. לאָזט ווידער גיין דעם קליענט און דעם סערווער.
5. לייגט צו אַ סערווער־אַדרעס ווי raknet;play.example.com אָדער raknet;play.example.com:25565.

אַדרעסן אָן raknet; אין אָנהייב באַניצן TCP.

אינסטאַלירן בלויז דעם קליענט־מאָד גיט דעם ווײַטן סערווער נישט קיין RakNet־שטיצע. דער סערווער־פֿאַרוואַלטער דאַרף שטעלן אַ פּאָרט וואָס נעמט אָן RakNet. אַ שפּילער וואָס טרעט אַרײַן אויף עמעצנס אַנדערש סערווער דאַרף בדרך־כּלל נישט אײַנשטעלן קיין ווײַטערשיקן אײַנגייענדיקע פּאָרטן אויף זײַן אייגענעם רוטער.

Velocity און BungeeCord

אינסטאַלירט דעם צוגעפּאַסטן פּראָקסי־צוגאָב און דעם קליענט־מאָד. זעט Velocity און BungeeCord פֿאַר די הער־פּאָרטן, ווײַטערשיקן צום הינטער־סערווער, באַגרענעצן דעם צוטריט און די אַדרעס וואָס די שפּילער דאַרפֿן באַניצן.

אַ באַזונדערער הער־פּאָרט פֿאַר UDP

אויף אַ דירעקטן Minecraft־סערווער שטעלט אײַן דעם פּאַסיקן Java־פּאַראַמעטער אונטן. פֿאַר אַ פּראָקסי, זעט די הער־אײַנשטעלונגען פֿון Velocity און BungeeCord.

פּלאַטפֿאָרמע	Java־פּאַראַמעטער	דערלויבטע פּאָרטן
Fabric־, Forge־ אָדער NeoForge־סערווער	-Draknetify.fabric.portOverride=25570	פֿון 1 ביז 65534
Spigot־ אָדער Paper־סערווער	-Draknetify.spigot.portOverride=25570	פֿון 1 ביז 65535

Forge און NeoForge באַניצן דעם זעלבן קאָד כּדי צו הערן אויף אַ פּאָרט. דערפֿאַר אַנטהאַלט אויך זייער פּאַראַמעטער־נאָמען fabric. שרײַבט אַנשטאָט 25570 דעם געוואָלטן UDP־פּאָרט.

Spigot / Paper ≥ 0.1.0-beta.1.431

לייגט צו דעם פּאַראַמעטער פֿאַר -jar אינעם Java־באַפֿעל, אָדער אינעם פֿעלד פֿאַר JVM־פּאַראַמעטערס בײַ אײַער האָסטינג־דינסט. לאָזט ווידער גיין דעם סערווער און דערלויבט UDP אויפֿן אויסגעקליבענעם הער־פּאָרט. אויב דער דרויסנדיקער פּאָרט איז אויך 25570, פֿאַרבינדט זיך מיט raknet;play.example.com:25570. אויב אַ רוטער בײַט דעם פּאָרט־נומער, שרײַבט דעם דרויסנדיקן פּאָרט אין דער קליענט־אַדרעס. דער TCP־פּאָרט בלײַבט דער זעלבער.

אויף Spigot/Paper הערט UDP אויף דער זעלבער לאָקאַלער אַדרעס ווי דער Minecraft־פּאָרט פֿאַר TCP. אויב דער פּאַראַמעטער איז אומגילטיק אָדער דער UDP־פּאָרט פֿאַרנומען, קען RakNet זיך נישט אָנהייבן. זוכט די טאַקע געעפֿנטע UDP־אַדרעס און פּאָרט אינעם אָנהייב־זשורנאַל. כּדי צוריקצוגיין צום TCP־פּאָרט־נומער, נעמט אַוועק דעם פּאַראַמעטער און לאָזט ווידער גיין.

אַ רוטער אָדער UDP־פּראָקסי קען אויך עפֿענען אַן אַנדערן דרויסנדיקן UDP־פּאָרט און ווײַטערשיקן די פּאַקעטן צום שוין אָפֿענעם הער־פּאָרט אָן ענדערן די Java־פּאַראַמעטערס פֿון סערווער.

ווערסיעס אין אַנטוויקלונג

עפֿנט אויף GitHub Actions אַ דערפֿאָלגרײַכן main־גאַנג און לאָדט אַראָפּ זײַן Artifacts־אַרכיוו. GitHub פֿאָדערט אַ קאָנטע כּדי אַראָפּצולאָדן די געשאַפֿענע טעקעס. ניצט די אינסטאַליר־טאַבעלע אויבן כּדי אויסצוקלײַבן אַ JAR פֿונעם אַרכיוו.

Velocity און BungeeCord

Velocity און BungeeCord שטייען צווישן די שפּילער און די Minecraft־סערווערס הינטערן פּראָקסי. אינסטאַלירט Raknetify2 אויפֿן פּראָקסי און אויף יעדן קליענט וואָס וועט זיך פֿאַרבינדן דורך RakNet.

Raknetify2־קליענט --UDP--> Velocity אָדער BungeeCord --TCP--> הינטער־סערווער

דער הינטער־סערווער דאַרף נישט Raknetify2 פֿאַר אַזאַ פֿאַרבינדונג. ער דאַרף ווײַטער די מאָדס, צוגאָבן און שטיצע פֿאַר ווײַטערשיקן וואָס אײַער נעץ פֿאָדערט. Raknetify2 זעצט נישט איבער צווישן Minecraft־ווערסיעס און ענדערט נישט דאָס באַשטעטיקן קאָנטעס אויפֿן פּראָקסי.

אינסטאַלירן דעם פּראָקסי־צוגאָב

1. פּרוּווט אַז געוויינטלעכע TCP־פֿאַרבינדונגען דורכן פּראָקסי אַרבעטן, אַרײַנגערעכנט קאָנטע־באַשטעטיקונג און אַריבערגיין צווישן הינטער־סערווערס.
2. שטעלט אָפּ דעם פּראָקסי און לאָדט אַראָפּ דעם פּאַסיקן צוגאָב פֿון GitHub Releases.
3. לייגט raknetify2-velocity-*-all.jar אָדער raknetify2-bungee-*-all.jar אינעם plugins־פֿאַרצייכעניש פֿונעם פּראָקסי. נעמט אַוועק אַלע עלטערע Raknetify־ אָדער Raknetify2־צוגאָבן פֿון דאָרטן.
4. אינסטאַלירט דעם פּאַסיקן Raknetify2־קליענט־מאָד לויט די אינסטאַליר־אָנווײַזונגען.
5. קאָנטראָלירט די הער־אײַנשטעלונגען אונטן, לאָזט ווידער גיין דעם פּראָקסי און זוכט אין זײַן זשורנאַל צי RakNet האָט געהאַט אַ פֿעלער בײַם עפֿענען אַ פּאָרט.
6. דערלויבט דרויסנדיקן UDP־פֿאַרקער צום פּראָקסי און באַגרענעצט דעם צוטריט צו די שפּיל־פּאָרטן פֿון די הינטער־סערווערס לויט די פֿײַערוואַל־ און רוטער־אָנווײַזונגען.

ניצט קאָמפּאַטיבלע אויסגאַבעס פֿון Raknetify2 אויפֿן קליענט און אויפֿן פּראָקסי. קוקט וועלכע ווערסיעס אַרבעטן צוזאַמען איידער איר מישט אויסגאַבעס.

Velocity

bind אין velocity.toml באַשטימט די Minecraft־אַדרעס און דעם TCP־פּאָרט אויף וועלכן Velocity הערט. געוויינטלעך ניצט Raknetify2 דעם זעלבן פּאָרט־נומער פֿאַר UDP. די איינסן אין [servers] ווײַזן אָן די הינטער־סערווערס. לאָזט זיי ווײַזן אויף זייערע TCP־אַדרעסן. זעט די אײַנשטעלונגען פֿון Velocity.

פֿאַר אַ באַזונדערן UDP־פּאָרט, לייגט צו דעם ווײַטערדיקן JVM־פּאַראַמעטער פֿאַר -jar אינעם אָנהייב־באַפֿעל פֿון Velocity:

-Draknetify.velocity.portOverride=25570

פֿאַרבײַט 25570 מיט אײַער אויסגעקליבענעם פּאָרט. דאָס ענדערט דעם RakNet UDP־פּאָרט און לאָזט דעם Velocity TCP־פּאָרט און די הינטער־אַדרעסן ווי פֿריִער. לאָזט ווידער גיין Velocity נאָך דער ענדערונג.

שטעלט אײַן דאָס ווײַטערשיקן די דאַטן וועגן שפּילער אויף Velocity און אויף זײַנע הינטער־סערווערס. וווּ דער הינטער־סערווער שטיצט דעם נײַעם אופֿן (modern forwarding), ניצט אים און היט זײַן שליסל אין סוד. פֿאָלגט די אָנווײַזונגען פֿאַר אײַער הינטער־סערווער אין Velocity וועגן ווײַטערשיקן שפּילער־דאַטן. לאָזט אויך אין כּוח די צוטריט־באַגרענעצונגען פֿונעם פֿײַערוואַל אויפֿן הינטער־סערווער.

BungeeCord

אין BungeeCord config.yml גיט host אונטער יעדער listeners־איינס די Minecraft־הער־אַדרעס און דעם TCP־פּאָרט. Raknetify2 לייגט געוויינטלעך צו UDP אויף דעם זעלבן נומער. די servers־איינסן אַנטהאַלטן די TCP־אַדרעסן פֿון די הינטער־סערווערס. זעט די BungeeCord־אײַנשטעלונגען.

פֿאַר אַ באַזונדערן UDP־פּאָרט, לייגט צו דעם ווײַטערדיקן JVM־פּאַראַמעטער פֿאַר -jar אינעם אָנהייב־באַפֿעל פֿון BungeeCord:

-Draknetify.bungee.portOverride=25570

דער פּאַראַמעטער גילט פֿאַרן גאַנצן פּראָקסי־פּראָצעס. אויב Minecraft הערט אויף עטלעכע אַדרעסן, זעט אינעם אָנהייב־זשורנאַל וווּ RakNet האָט טאַקע געעפֿנט די פֿאַרבינדונגען, איידער איר לייגט צו פֿײַערוואַל־כּללים. לאָזט ווידער גיין BungeeCord נאָכן ענדערן דעם פּאַראַמעטער.

לאָזט די קאָנטע־באַשטעטיקונג אָנגעצונדן אויפֿן פּראָקסי. פֿאַר Spigot הינטער־סערווערס קאָמבינירן די IP־ווײַטערשיק־אָנווײַזונגען פֿון BungeeCord ip_forward: true אויפֿן פּראָקסי מיט settings.bungeecord: true אויפֿן הינטער־סערווער. דאָס ווײַטערשיקן אַליין שטערט קיינעם נישט צו קומען גלײַך צום הינטער־סערווער. באַגרענעצט דעם צוטריט לויט די פֿײַערוואַל־אָנווײַזונגען.

אויסקלײַבן די אַדרעס פֿאַר די שפּילער

ביידע פּראָקסיס נעמען אָן פּאָרטן פֿון 1 ביז 65534. אומגילטיקע נומערן ווערן איגנאָרירט. באַשטעטיקט דעם געעפֿנטן UDP־פּאָרט אינעם אָנהייב־זשורנאַל. נעמט אַוועק דעם פּאַראַמעטער און הייבט ווידער אָן כּדי צוריקצוגיין צום Minecraft־הער־פּאָרט־נומער.

שפּילער ניצן דעם עפֿנטלעכן נאָמען און UDP־פּאָרט פֿונעם פּראָקסי, למשל raknet;play.example.com:25570. אויב אַ רוטער בײַט פּאָרט־נומערן, שרײַבט זײַן דרויסנדיקן UDP־פּאָרט אין דער קליענט־אַדרעס. אַן אַדרעס אָן raknet; אין אָנהייב בלײַבט בײַם TCP־הער־פּאָרט פֿונעם פּראָקסי.

לאָזט Query, Geyser און אַנדערע UDP־דינסטן אויף באַזונדערע UDP־פּאָרטן. אַן אַנדער TCP־פּאָרט וועט נישט לייזן אַ סיכסוך וועגן אַ UDP־סאָקעט.

קול־שמועס און ווײַטערשיקן UDP

אויף Velocity און BungeeCord ניצט Simple Voice Chat זײַן אייגענעם פּראָקסי־צוגאָב און UDP־פּאָרט. פֿאַר אַזאַ אײַנשטעלונג פֿאָלגט די אָנווײַזונגען פֿאַרן קול־פּראָקסי.

אויב פֿאַר אײַער Minecraft־פּראָקסי שטייט נאָך אַ UDP־פּראָקסי און שיקט צו אײַער הער־פּאָרט PROXY protocol v2 קעפּלעך, שטעלט אײַן Raknetify2 לויט ווײַטערשיקן UDP און דער PROXY־פּראָטאָקאָל. בײַ Velocity אָדער BungeeCord אַליין דאַרף מען די אײַנשטעלונג נישט.

פּרוּוון די פֿאַרבינדונג

פּרוּווט מיט אַ Raknetify2־קליענט פֿון אויסער אײַער אָרטיקער נעץ. טרעט אַרײַן דורכן פּראָקסי, גייט איבער צווישן די הינטער־סערווערס וואָס איר ניצט, און קאָנטראָלירט אַז דער שפּילער ווערט ריכטיק דערקענט און זײַנע דערלויבענישן בלײַבן ריכטיק.

• אויב TCP דורכן פּראָקסי אַרבעט אָבער RakNet וואַרט אומזיסט ביז די צײַט גייט אויס, קאָנטראָלירט דעם הער־פּאָרט UDP אויפֿן פּראָקסי, דעם דרויסנדיקן פּאָרט, די IPv4־ און IPv6־וועגן און די פֿײַערוואַל־כּללים.
• אויב ביידע אופֿנים אַרבעטן נישט בײַ דער פֿאַרבינדונג פֿונעם פּראָקסי מיט אַ הינטער־סערווער, קאָנטראָלירט יענעמס TCP־אַדרעס, צוטריט־כּללים און אײַנשטעלונגען פֿאַר ווײַטערשיקן שפּילער־דאַטן.
• אויב דער פּראָקסי מעלדט אַז אַ UDP־פּאָרט איז פֿאַרנומען, קוקט צי Query, Geyser, אַ קול־פּראָקסי אָדער נאָך אַ פּראָצעס באַניצט אים.

לייגט צו באַריכטן די זשורנאַלן פֿון ביידע, דעם פּראָקסי און דעם הינטער־סערווער, פֿון דעם זעלבן פֿאַרבינדונג־פּרוּוו. אין הילף בײַ פּראָבלעמען שטייט וועלכע ווערסיעס צו דערמאָנען.

אײַנשטעלן דעם פֿײַערוואַל און דעם רוטער

די אָנווײַזונגען זענען פֿאַר סערווער־פֿאַרוואַלטער. Raknetify2 דאַרף אַן אָפֿענעם UDP־וועג ביזן סערווער אָדער פּראָקסי וואָס נעמט אָן RakNet. בײַ דער אָריגינעלער אײַנשטעלונג איז דער פּאָרט־נומער דער זעלבער ווי בײַם TCP־הער־פּאָרט פֿון Minecraft.

פֿאַר שפּילער אין דער זעלבער אָרטיקער נעץ ניצט די אָרטיקע סערווער־אַדרעס און דערלויבט UDP אינעם פֿײַערוואַל פֿונעם קאָמפּיוטער. מע דאַרף ווײַטערשיקן דעם פּאָרט אויפֿן רוטער ווען דער אינטערנעץ־פֿאַרקער דאַרף דורכגיין דעם IPv4 NAT פֿונעם רוטער.

אויסקלײַבן וווּהין צו שיקן און דעם פּאָרט

דירעקטער סערווער

שיקט דרויסנדיקן UDP־פֿאַרקער צום קאָמפּיוטער וווּ ס׳לויפֿט דער Minecraft־סערווער מיט Raknetify2. דער ציל־פּאָרט איז דער UDP־פּאָרט אויף וועלכן RakNet הערט דאָרטן. דערלויבט אים אינעם פֿײַערוואַל פֿונעם קאָמפּיוטער. לאָזט דעם ביז־איצטיקן TCP־וועג פֿאַר געוויינטלעכע Minecraft־פֿאַרבינדונגען.

למשל, אויב Raknetify2 הערט אויף UDP 25570, שיקט דעם דרויסנדיקן UDP־פֿאַרקער ווײַטער צו דער אָרטיקער אַדרעס פֿונעם סערווער אויף פּאָרט 25570. דער TCP־פּאָרט קען בלײַבן 25565. וועגן אַן אַנדער UDP־פּאָרט זעט די הער־אײַנשטעלונגען אויף אַ דירעקטן סערווער.

Velocity אָדער BungeeCord

שיקט דעם דרויסנדיקן UDP־פֿאַרקער צום קאָמפּיוטער מיט Velocity אָדער BungeeCord און דעם Raknetify2־פּראָקסי־צוגאָב. שיקט אים צום RakNet UDP־הער־פּאָרט פֿונעם פּראָקסי. לאָזט דעם ביז־איצטיקן דרויסנדיקן TCP־וועג צום פּראָקסי פֿאַר געוויינטלעכע Minecraft־פֿאַרבינדונגען.

דער פּראָקסי פֿאַרבינדט זיך מיט די הינטער־סערווערס דורך TCP. בײַם צולייגן Raknetify2 צום פּראָקסי דאַרף מען נישט עפֿענען די UDP־שפּיל־פּאָרטן פֿון די הינטער־סערווערס פֿאַר די שפּילער.

פֿאַרבינדונג	וואָס צו דערלויבן
פֿון די שפּילער צום פּראָקסי	דרויסנדיקן UDP צום RakNet־הער־פּאָרט און דעם שוין אָפֿענעם דרויסנדיקן TCP־פּאָרט
פֿונעם פּראָקסי צו די הינטער־סערווערס	די TCP־פּאָרטן פֿון Minecraft אויף די הינטער־סערווערס. בלויז די אויסגעקליבענע פּראָקסי־מאַשינען זאָלן קענען צוקומען
שפּילער גלײַך צו די שפּיל־פּאָרטן אויפֿן הינטער־סערווער	לאָזט דעם צוטריט פֿאַרשפּאַרט, אויך דורך IPv6

אויב דער פּראָקסי און די הינטער־סערווערס לויפֿן דירעקט אויף איין באַזונדערער מאַשין אונטער אײַער קאָנטראָל, קענען די הינטער־סערווערס הערן אויף loopback־אַדרעסן. שטעלט אײַן דעם פּראָקסי זיי דאָרטן צו דערגרייכן. אויף באַזונדערע מאַשינען דערלויבט TCP־צוטריט צום הינטער־סערווער בלויז פֿון די פּראָקסי־מאַשינען, מיט אַ פֿײַערוואַל אָדער אַ באַזונדערער פּריוואַטער נעץ. בײַ קאָנטיינערס און פֿאַרוואַלטע האָסטינג־דינסטן דאַרף מען ענלעכע באַגרענעצונגען צוגעפּאַסט צו דער נעץ. זעט Velocity וועגן זיכערקייט הינטערן פּראָקסי און BungeeCord וועגן פֿײַערוואַלן.

דאָס ווײַטערשיקן שפּילער־דאַטן און די באַגרענעצונגען פֿונעם פֿײַערוואַל אַרבעטן צוזאַמען. אַ דירעקטער צוטריט צום הינטער־סערווער קען אויסמײַדן די קליענט־באַשטעטיקונג בײַם פּראָקסי. וועגן אינסטאַלירן דעם צוגאָב, אײַנשטעלן דאָס ווײַטערשיקן און ענדערן דעם UDP־פּאָרט זעט Velocity און BungeeCord.

דרויסנדיקע און אָרטיקע פּאָרט־נומערן

ווען אַ רוטער בײַט דעם פּאָרט־נומער, קען דער דרויסנדיקער פּאָרט זײַן אַנדערש פֿונעם הער־פּאָרט:

אײַנשטעלונג	וועלכן פּאָרט צו ניצן
סערווער־אַדרעס אינעם קליענט	דרויסנדיקער UDP־פּאָרט
דרויסנדיקער פּאָרט אינעם ווײַטערשיק־כּלל פֿונעם רוטער	דרויסנדיקער UDP־פּאָרט
אינערלעכער פּאָרט אינעם ווײַטערשיק־כּלל פֿונעם רוטער	UDP־פּאָרט אויף וועלכן RakNet הערט
אָרטיקער פּאָרט אינעם פֿײַערוואַל פֿונעם סערווער־קאָמפּיוטער	UDP־פּאָרט אויף וועלכן RakNet הערט

ווײַטערשיקן פּאָרטן דורך IPv4

אויב דער סערווער געפֿינט זיך הינטער אַן IPv4־רוטער:

1. געפֿינט די אָרטיקע IPv4־אַדרעס פֿון דער מאַשין וואָס נעמט אָן RakNet. רעזערווירט איר אין DHCP די אַדרעס אָדער גיט איר אַ פּאַסיקע פֿעסטע אַדרעס, כּדי דער כּלל זאָל ווײַטער שיקן צו יענער מאַשין.
2. לייגט צו אַ UDP־ווײַטערשיק־כּלל פֿאַרן דרויסנדיקן פּאָרט וואָס די שפּילער וועלן ניצן.
3. גיט אָן ווי ציל די אָרטיקע אַדרעס פֿון דער מאַשין און דעם UDP־הער־פּאָרט פֿון RakNet.
4. דערלויבט אַרײַנקומענדיקן UDP אויפֿן הער־פּאָרט אינעם פֿײַערוואַל פֿונעם קאָמפּיוטער.

למשל, אַ סערווער וואָס הערט אויף UDP־פּאָרט 25565 קען ניצן אַ כּלל מיט דרויסנדיקן פּאָרט 25565, ציל־אַדרעס 192.168.1.100 און ציל־פּאָרט 25565. בײַט די אַדרעס פֿונעם בײַשפּיל מיט דער אמתער אָרטיקער אַדרעס פֿון אײַער סערווער.

לאָזט דעם ביז־איצטיקן TCP־כּלל פֿאַר געוויינטלעכע Minecraft־פֿאַרבינדונגען. אַ כּלל וואָס שיקט ווײַטער בלויז TCP טראָגט נישט קיין UDP.

ווען דאָס ווײַטערשיקן אַרבעט נאָך אַלץ נישט

קאָנטראָלירט צי נאָך אַ רוטער אָדער אײַער אינטערנעץ־פּראָווידער ניצט NAT איידער דער פֿאַרקער קומט אָן צו אײַער רוטער. אויב ביידע רוטערס זענען אונטער אײַער קאָנטראָל, שטעלט אײַן דאָס ווײַטערשיקן אויף ביידע. אויב דער פּראָווידער ניצט CGNAT, פֿרעגט צי איר קענט באַקומען אַן עפֿנטלעכע IPv4־אַדרעס, אָדער ניצט אַ האָסטינג־דינסט אָדער טונעל וואָס דערלויבט אַרײַנקומענדיקן UDP. אײַער רוטער־כּלל קען נישט אײַנשטעלן דעם NAT פֿונעם פּראָווידער. זעט די TP-Link־אָנווײַזונגען וועגן דער נייטיקער עפֿנטלעכער WAN־אַדרעס.

פֿײַערוואַל־כּללים פֿאַר IPv6

דערלויבט דעם אויסגעקליבענעם UDP־פּאָרט סײַ אינעם IPv6־פֿײַערוואַל פֿונעם רוטער, סײַ אינעם פֿײַערוואַל פֿונעם קאָמפּיוטער. דער ציל איז די IPv6־אַדרעס פֿון דער מאַשין וואָס נעמט אָן RakNet.

זעט אַז די IPv6־אַדרעס אונטערן נאָמען ווײַזט אויף יענער מאַשין. אויב די אַדרעס ענדערט זיך, באַנײַט דעם DNS־אײַנטראָג און די פֿײַערוואַל־כּללים וואָס דערמאָנען יענע אַדרעס.

אויב איין נאָמען גיט סײַ אַן IPv4־, סײַ אַן IPv6־אַדרעס, דאַרף אַרבעטן אַן אָנקום־וועג פֿאַר יעדער אַדרעס. אויב איין שפּילער קען זיך פֿאַרבינדן און אַן אַנדערער נישט, קאָנטראָלירט ביידע גרופּעס כּללים.

אויב דאָס IPv4־ווײַטערשיקן בײַט דעם פּאָרט־נומער, זעט אַז דער פּאָרט וואָס די שפּילער שרײַבן דערגרייכט אויך דעם IPv6־הער־פּאָרט. דאָס איבערזעצן אַן IPv4־פּאָרט שטעלט נישט אײַן דעם IPv6־וועג.

האָסטינג־פּראָווידערס און טונעלן

דער פּראָווידער אָדער טונעל דאַרף שטיצן UDP אויף דער עפֿנטלעכער אַדרעס וואָס איר גיט די שפּילער. קאָנטראָלירט וועלכע פּאָרטן מען האָט אײַך געגעבן און די כּללים פֿונעם נעץ־פֿײַערוואַל, צוזאַמען מיטן פֿײַערוואַל פֿונעם סערווער.

אויב נאָך אַ UDP־פּראָקסי שיקט ווײַטער קליענט־אַדרעסן מיט PROXY protocol v2, זעט ווײַטערשיקן UDP און דער PROXY־פּראָטאָקאָל. דערלויבט צוטריט צום אויפֿנעמענדיקן UDP־פּאָרט בלויז פֿונעם פֿאַרטרויטן פּראָקסי.

פּרוּוון די פֿאַרבינדונג

פֿאַרבינדט זיך פֿון אויסער דער אָרטיקער נעץ פֿונעם סערווער מיט אַן אַקטועלע Raknetify2־קליענט־ווערסיע, למשל אויף raknet;play.example.com:25565. ניצט דעם דרויסנדיקן UDP־פּאָרט אין דער אַדרעס.

פּרוּווט דעם וועג מיט אַן אמתער RakNet־פֿאַרבינדונג. ווען אַ UDP־סקאַן באַקומט נישט קיין ענטפֿער, איז זײַן רעזולטאַט נישט באַשטימט. אַ דינסט וואָס אַרבעט קען פּשוט אַוועקוואַרפֿן אַ פּרוּוו וואָס ער דערקענט נישט. וועגן דעם זעט די באַשרײַבונג פֿון UDP־סקאַנירן אין Nmap.

אַ געלונגענע TCP־פֿאַרבינדונג באַשטעטיקט בלויז דעם TCP־וועג. אויב RakNet באַקומט נישט קיין ענטפֿער אין צײַט, קאָנטראָלירט דעם הער־פּאָרט, דעם ווײַטערשיק־ציל, דעם UDP־פּאָרט און די פֿײַערוואַל־כּללים לויט די אָנווײַזונגען בײַ פּראָבלעמען.

קאָמפּאַטיביליטעט

קאָנטראָלירט וואָס אַרבעט מיט דער באַשטימטער אויסגאַבע וואָס איר לאָדט אַראָפּ. דער אַנטוויקלונגס־צווײַג קען שוין שטיצן עפּעס וואָס איז נאָך נישט אַרײַן אין אַן אַרויסגעגעבענער ווערסיע.

Minecraft־ און Java־ווערסיעס

Minecraft־ און Java־ווערסיעס · English

די Java־ווערסיע וואָס Raknetify2 פֿאָדערט איז דער מינימום. Minecraft אָדער דער לאָדער קענען פֿאָדערן אַ נײַערע. קלײַבט אַ Java־ווערסיע וואָס פּאַסט פֿאַר אַלע דרײַ.

ווערסיעס אויפֿן קליענט און סערווער

ניצט, אויב מעגלעך, די זעלבע Raknetify2־אויסגאַבע אויפֿן קליענט און אויפֿן סערווער אָדער פּראָקסי וואָס נעמט אים אָן. איידער איר מישט אויסגאַבעס, לייענט די באַמערקונגען צו דער אויסגאַבע. פֿאַר אַ פֿאַרשליסלטער RakNet־פֿאַרבינדונג מוזן ביידע צדדים שטיצן דעם פּראָטאָקאָל וואָס פֿאַרשליסלט און באַשטעטיקט די עכטקייט פֿון די דאַטן. די אָריגינעלע Raknetify און Raknetify2־ווערסיעס פֿון פֿאַר דעם פּראָטאָקאָל קענען נישט אויפֿשטעלן אַזאַ פֿאַרשליסלטע פֿאַרבינדונג מיט אַ באַנײַטן צד.

Raknetify2 פֿירט איבער דעם געוויינטלעכן שפּיל־פּראָטאָקאָל פֿון Minecraft. צו פֿאַרבינדן פֿאַרשידענע Minecraft־ווערסיעס דאַרף מען אַ פּאַסיקן פּראָטאָקאָל־איבערזעצער.

אַנדערע מאָדס

אַנדערע מאָדס · English

בײַ אַ פֿעלער אין אַ גרעסערן מאָדפּאַק, זעט הילף בײַ פּראָבלעמען. רעכנט אויס אין אײַער באַריכט אַלע מאָדס מיט זייערע פּינקטלעכע ווערסיעס.

דער סדרדיקער מאָדוס

דער סדרדיקער מאָדוס

געוויינטלעך קענען די זעלבשטענדיקע קאַנאַלן אין Raknetify2 גיין ווײַטער בשעת איין קאַנאַל וואַרט אויף פֿאַרלוירענע דאַטן. אינעם סדרדיקן מאָדוס פֿליסן אַלע Minecraft־פּאַקעטן אויף איין קאַנאַל. אויב אַ פּאַקעט גייט פֿאַרלוירן, וואַרטן אַלע שפּעטערע פּאַקעטן אין יענער ריכטונג ביז מע שיקט אים ווידער. אַזוי בלײַבט דער סדר וואָס געוויסע פּראָגראַמען קעגן שווינדל דערוואַרטן. בעת דעם וואַרטן האַלט זיך אָפּ אויך דער אַנדערער שפּיל־פֿאַרקער.

אײַנשליסן דעם סדרדיקן מאָדוס

1. אינסטאַלירט אַ Raknetify2־ווערסיע וואָס שטיצט דעם מאָדוס אויף דעם סערווער אָדער פּראָקסי וואָס נעמט אָן RakNet, און אויף יעדן RakNet־קליענט.

2. שאַפֿט config/raknetify2-compatibility.json אונטערן אַרבעטספֿאַרצייכעניש פֿון יענעם סערווער אָדער פּראָקסי. אויב config עקזיסטירט נאָך נישט, שאַפֿט דאָס פֿאַרצייכעניש.

3. לייגט אַרײַן דאָס פֿאָלגנדיקע:

   {"mode": "ordered"}

4. לאָזט ווידער גיין דעם סערווער אָדער פּראָקסי.

די קליענטן פֿאָלגן אויטאָמאַטיש דער אײַנשטעלונג פֿונעם סערווער. שפּילער דאַרפֿן נישט שאַפֿן קיין אײַנשטעל־טעקע און נישט ענדערן זייער RakNet־סערווער־אַדרעס.

אין יעדער ריכטונג קומען אַלע Minecraft־פּאַקעטן אָן פֿאַרזיכערט און אין סדר אויף איין קאַנאַל. דאָס נעמט אויך אַרײַן די צייכנס פֿאַר די גרענעצן פֿון פּאַקעט־בינטלעך און די איבערגאַנגען צווישן וועלטן.

בײַ אַ פּראָקסי

אויב די שפּילער גייען אַרײַן דורך Velocity אָדער BungeeCord, שטעלט אײַן דעם סדרדיקן מאָדוס אויפֿן פּראָקסי, אַפֿילו אויב די קאָנטראָל קעגן שווינדל לויפֿט אויפֿן הינטער־סערווער.

די אײַנשטעלונג בלײַבט אין כּוח בײַם אַריבערגיין צווישן הינטער־סערווערס. אינעם סדרדיקן מאָדוס שיקט דער פּראָקסי די keepalive־פֿראַגעס פֿונעם הינטער־סערווער צום אמתן קליענט אַנשטאָט אַליין צו ענטפֿערן.

קאָנטראָלירן די אײַנשטעלונג

בײַ דער ערשטער RakNet־פֿאַרבינדונג ווײַזט די קאָנסאָל:

Raknetify2 compatibility: ordered (updated clients required, genuine acknowledgements)

בײַ אַ געלונגענער אָפּמאַך וועגן דעם מאָדוס שרײַבט זיך אויך אַרײַן ordered compatibility negotiated, און דערנאָך די אַדרעס פֿונעם צווייטן צד.

לאָזט די קאָנטראָלן קעגן שווינדל אָנגעצונדן און פּרוּווט אײַער אייגענע אײַנשטעלונג.

עלטערע קליענטן

אַ RakNet־קליענט וואָס שטיצט נישט דעם סדרדיקן מאָדוס קען זיך נישט פֿאַרבינדן מיט אַ סערווער וואָס פֿאָדערט אים. באַנײַט Raknetify2 אויף יענע קליענטן, אָדער ניצט די געוויינטלעכע TCP־אַדרעס און פּאָרט פֿונעם סערווער אָדער פּראָקסי אָן דעם אָנהייב raknet;.

צוריק צום מאָדוס מיט עטלעכע קאַנאַלן

ענדערט די טעקע אַזוי:

{"mode": "multichannel"}

דערנאָך לאָזט ווידער גיין דעם סערווער אָדער פּראָקסי. אויב איר מעקט אויס די טעקע און הייבט ווידער אָן, קערט זיך אויך צוריק דער מאָדוס מיט עטלעכע קאַנאַלן.

פּראָבלעמען מיט דער אײַנשטעלונג

אין דער טעקע מוז שטיין פּונקט איין אײַנשטעלונג מיטן נאָמען mode. איר ווערט מוז זײַן "ordered" אָדער "multichannel". די גרויסע און קליינע אותיות שפּילן אַ ראָלע.

אַן אומגילטיקע אָדער אומלייענבאַרע אײַנשטעלונג שטעלט אָפּ דאָס אָננעמען RakNet־פֿאַרבינדונגען. פֿאַרריכט די טעקע און הייבט דעם פּראָצעס ווידער אָן.

אויב די קאָנסאָל ווײַזט ווײַטער multichannel, זעט צי די טעקע געפֿינט זיך אינעם אַרבעטספֿאַרצייכעניש פֿונעם סערווער אָדער פּראָקסי וואָס נעמט אָן די RakNet־פֿאַרבינדונג, און הייבט יענעם פּראָצעס ווידער אָן.

אויטאָמאַטיש אַריבערפֿירן שפּילער

אַ Fabric־, Forge־ אָדער NeoForge־סערווער קען אויסקלײַבן RakNet ווען ער פֿירט אַריבער אַ קליענט מיט אַזאַ שטיצע צו אַן אײַנגעשטעלטן ציל. דאָס ניצט Minecraftס אייגענע פֿעיִקייט אַריבערצופֿירן קליענטן, אײַנגעפֿירט אין Java Edition 1.20.5. קאָנטראָלירט אַז אײַער Raknetify2־אויסגאַבע שטיצט די Minecraft־ווערסיע און דעם לאָדער אויף יעדן צד.

אינסטאַלירט Raknetify2 אויפֿן שיקנדיקן סערווער און אויפֿן קליענט. אויפֿן ציל מוז זײַן אַ פּאַסיקער RakNet־הער־פּאָרט, און מע מוז דאָרטן דערלויבן אַרײַנקומענדיקע Minecraft־אַריבערפֿירונגען.

די אײַנשטעלונג גילט פֿאַר די אַריבערפֿירונגען וואָס די דרײַ אָנגערופֿענע מאָד־לאָדערס שיקן. די Spigot/Paper־, Velocity־ און BungeeCord־צוגאָבן לייענען נישט די אַריבערפֿיר־טעקע.

אײַנשטעלן דעם שיקנדיקן סערווער

שאַפֿט config/raknetify2-transfers.json אינעם פֿאַרצייכעניש פֿונעם שיקנדיקן סערווער:

{
  "destinations": [
    {
      "host": "play.example.com",
      "tcpPort": 25565,
      "udpPort": 25570
    }
  ]
}

פֿאַרבײַט דעם נאָמען און די פּאָרטן פֿונעם בײַשפּיל מיט די אמתע ווערטן פֿונעם ציל. לאָזט ווידער גיין דעם שיקנדיקן סערווער. אַנדערע צילן קומען אַרײַן אין דער זעלבער רשימה.

פֿעלד	באַדײַט
host	נאָמען אָדער IP־אַדרעס פֿונעם ציל, אָן פּראָטאָקאָל־פּרעפֿיקס און אָן פּאָרט
tcpPort	ציל־פּאָרט אין דער אָריגינעלער אַריבערפֿיר־בקשה
udpPort	דרויסנדיקער RakNet־פּאָרט מיט וועלכן דער אַריבערגעפֿירטער קליענט זאָל זיך פֿאַרבינדן

די TCP־ און UDP־פּאָרט־נומערן קענען זײַן גלײַך. אויב דער רוטער בײַט דעם UDP־פּאָרט, ניצט דעם דרויסנדיקן פּאָרט אין דער טעקע. שרײַבט פּאָרטן ווי JSON־צאָלן.

שיקט די אַריבערפֿירונגען צום געוויינטלעכן נאָמען און TCP־פּאָרט פֿונעם ציל. Raknetify2 קאָנטראָלירט צי דער קליענט גיט צו וויסן אַז ער שטיצט אויטאָמאַטישע אַריבערפֿירונגען. פֿאַר אַ פּאַסיקן קליענט און אַ ציל וואָס שטימט מיט דער רשימה קלײַבט ער דעם אײַנגעשטעלטן UDP־פּאָרט. פֿאַר אַנדערע קליענטן אָדער צילן בלײַבט די אָריגינעלע אַדרעס.

פֿאַרן פֿאַרגלײַך ניצט מען דעם נאָמען און TCP־פּאָרט פֿון דער בקשה. גרויסע און קליינע אותיות אינעם נאָמען, אַ לעצטער DNS־פּונקט און פֿאַרשידענע שרײַבונגען פֿון דער זעלבער IPv6־אַדרעס ווערן איינהייטלעך באַהאַנדלט. מע פֿרעגט נישט בײַ DNS בײַם פֿאַרגלײַכן. צוויי פֿאַרשידענע נעמען וואָס פֿירן צו דער זעלבער אַדרעס דאַרפֿן צוויי איינסן. נעמען מיט אַלגעמיינע מוסטער־צייכנס ווערן נישט געשטיצט.

אײַנשטעלן דעם ציל

אויב דער ציל ניצט Minecraftס server.properties, שטעלט אַרײַן accepts-transfers=true און לאָזט אים ווידער גיין. אַ ציל־פּראָקסי קען האָבן זײַן אייגענע אַריבערפֿיר־אָפּציע. בײַ די אָריגינעלע אײַנשטעלונגען זאָגט Minecraft אָפּ אַרײַנקומענדיקע אַריבערפֿירונגען, אַפֿילו ווען מע קען זיך פֿאַרבינדן גלײַך.

דער RakNet־הער־פּאָרט בײַם ציל, דאָס ווײַטערשיקן UDP פֿון דרויסן און דער פֿײַערוואַל פֿונעם קאָמפּיוטער מוזן שוין זײַן אײַנגעשטעלט. די אַריבערפֿיר־טעקע אויפֿן שיקנדיקן סערווער באַשטימט וועלכע אַדרעס מע שיקט צום קליענט.

אויב דער נאָמען פֿונעם ציל גיט סײַ IPv4, סײַ IPv6, פּרוּווט די צוויי וועגן. פּרוּווט פֿריִער אַ דירעקטע RakNet־פֿאַרבינדונג צום ציל איידער איר פֿאָרשט די אויטאָמאַטישע אַריבערפֿירונג.

לאָזט אין כּוח די קאָנטראָלן פֿונעם ציל בײַם אַרײַנשרײַבן אָדער אַרײַנלאָזן אַ שפּילער. די אײַנשטעלונג גיט קיינעם נישט קיין צוטריט און פֿאַרבײַט נישט די קאָנטע־באַשטעטיקונג פֿונעם סערווער.

פֿעלערן אין דער אײַנשטעלונג און אויסלעשן די פֿעיִקייט

אויב עס פֿעלן פֿעלדער, ס׳איז דאָ אַן אומבאַקאַנט פֿעלד, אַן אומגילטיקער פּאָרט אָדער אַ טאָפּלטער ציל, קומט אַ פֿעלער בײַם אָנהייב. געפֿינט אים אינעם סערווער־זשורנאַל, פֿאַרריכט די JSON־טעקע און הייבט ווידער אָן.

כּדי אויסצולעשן דעם אויטאָמאַטישן אויסקלײַב, נעמט אַוועק די אײַנשטעל־טעקע אָדער ניצט {"destinations": []}. דערנאָך לאָזט ווידער גיין דעם שיקנדיקן סערווער. זײַנע אַריבערפֿיר־בקשות וועלן האַלטן די אָריגינעלע אַדרעסן.

ווײַטערשיקן UDP און דער PROXY־פּראָטאָקאָל

אַ UDP־פּראָקסי קען שיקן ווײַטער RakNet־פֿאַרקער און אויפֿהיטן די אמתע קליענט־אַדרעס מיט PROXY protocol v2. צינדט אָן די פֿעיִקייט ווען אַ UDP־פּראָקסי פֿאַר אײַער הער־פּאָרט שיקט אַזעלכע קעפּלעך. פֿאַרן געוויינטלעכן ווײַטערשיקן פּאָרטן אויפֿן רוטער דאַרף מען זי נישט.

אויפֿן סערווער אָדער Minecraft־פּראָקסי וואָס נעמט אָן דעם ווײַטערגעשיקטן UDP־פֿאַרקער, שאַפֿט config/raknetify2-proxy-protocol.json:

{
  "trustedProxies": ["192.0.2.10"]
}

פֿאַרבײַט דעם בײַשפּיל מיט דער אמתער מקור־IP פֿונעם UDP־פּראָקסי אָדער מיט אַ CIDR־ריי אַדרעסן וואָס איר אַליין קאָנטראָלירט. די אַדרעס מוז שטימען מיט וואָס דער אויפֿנעמענדיקער פּאָרט זעט נאָך אַ דורכגאַנג דורך NAT, אויב ס׳איז דאָ איינער אין מיטן. מען נעמט אָן IPv4 און IPv6 גלײַך ווי אַדרעסן. מע זאָגט אָפּ DNS־נעמען. הייבט ווידער אָן דעם אויפֿנעמענדיקן סערווער אָדער פּראָקסי.

שטעלט אײַן דעם ווײַטערשיקנדיקן פּראָקסי צו שיקן PROXY protocol v2 קעפּלעך פֿאַר UDP. Raknetify2 נעמט אָן ווײַטערגעשיקטע קליענט־אַדרעסן נאָר פֿון די מקורים אויף דער רשימה. בשעת די פֿעיִקייט איז אָנגעצונדן, ווערן דירעקטע RakNet־פֿאַרבינדונגען אָן די קעפּלעך אָפּגעזאָגט. די אײַנשטעלונגען פֿונעם TCP־הער־פּאָרט בלײַבן ווי פֿריִער.

צוטרוי און צוטריט

מע געטרויט יעדן פּראָקסי אויף דער רשימה צו געבן די ריכטיקע קליענט־אַדרעס. אינעם פֿײַערוואַל פֿונעם הינטער־סערווער באַגרענעצט דעם צוטריט צום UDP־פּאָרט אַזוי אַז נאָר דער אויסגעקליבענער פּראָקסי קען אים דערגרייכן. לאָזט די רייען פֿון פֿאַרטרויטע אַדרעסן אַזוי קליין ווי אײַער נעץ דערלויבט.

די טעקע טאָר אַנטהאַלטן נאָר trustedProxies, מיט לפּחות איין איינס. אַ ליידיקע רשימה איז אַ פֿעלער. אַן אומגילטיקע טעקע פֿאַרהיט אַז דער RakNet־הער־דינסט זאָל זיך אָנלאָזן.

כּדי זיך אומצוקערן צו דירעקטע UDP־פֿאַרבינדונגען, נעמט אַוועק די טעקע און הייבט דעם הער־דינסט ווידער אָן. פּאַסט אין דער זעלבער צײַט צו דעם ווײַטערשיקנדיקן פּראָקסי און די פֿײַערוואַל־כּללים צום נײַעם וועג.

אויב די פֿאַרבינדונגען אַרבעטן נישט נאָכן אָנצינדן, זעט וועלכע אמתע מקור־אַדרעס פֿונעם פּראָקסי דער הינטער־סערווער זעט, וואָס פֿאַר אַ ריי אַדרעסן איר האָט פֿאַרטרויט, און צי דער פּראָקסי שיקט PROXY protocol v2 קעפּלעך בײַ UDP.

פֿאַרן אינסטאַלירן אַ Minecraft־פּראָקסי און אײַנשטעלן די הינטער־סערווערס זעט Velocity און BungeeCord.

Simple Voice Chat

אויף Fabric, Forge, NeoForge, Spigot און Paper קען Raknetify2 טיילן דעם UDP־הער־פּאָרט פֿונעם סערווער מיט Simple Voice Chat.

אינסטאַלירט Simple Voice Chat אויפֿן סערווער און אויף יעדן קליענט פֿון די שפּילער וואָס ווילן רעדן דורכן מיקראָפֿאָן. וועגן די איבעריקע אײַנשטעלונגען זעט די סערווער־אָנווײַזונגען פֿון Simple Voice Chat.

לייגט די Raknetify2־טעקע אינעם config־פֿאַרצייכעניש גלײַך אינעם הויפּטפֿאַרצייכעניש פֿונעם סערווער, אויך אויף Spigot/Paper. די אייגענע טעקע פֿון Simple Voice Chat בלײַבט אויפֿן אָרט וואָס איז אונטן אָנגעגעבן פֿאַר דער פּלאַטפֿאָרמע.

צעטיילן דעם שפּיל־פּאָרט

1. שאַפֿט config/raknetify2-voicechat.json אינעם סערווער־פֿאַרצייכעניש מיט דעם אינהאַלט:

   {"enabled": true}

2. שטעלט אַרײַן port=-1 אין די סערווער־אײַנשטעלונגען פֿון Simple Voice Chat. אויף אַ סערווער מיט מאָדס איז די טעקע config/voicechat/voicechat-server.properties. אויף Spigot/Paper איז זי plugins/voicechat/voicechat-server.properties.

3. לאָזט bind_address ליידיק אויב ס׳איז פֿאַראַן בלויז איין פּאַסיקער RakNet־הער־דינסט. אויב עטלעכע הער־דינסטן אויפֿן סערווער ניצן דעם זעלבן UDP־פּאָרט, גיט אָן די אָרטיקע אַדרעס פֿונעם איינעם וואָס איר ווילט טיילן.

4. לאָזט ווידער גיין דעם סערווער און פֿירט אויס /voicechat test <PLAYERNAME> פֿאַר אַ פֿאַרבונדענעם שפּילער.

אויב RakNet הערט אויף אַן אַנדער פּאָרט ווי Minecraft, שרײַבט בפֿירוש דעם אָרטיקן UDP־פּאָרט אין port פֿאַר קול, אַנשטאָט -1. למשל, אויב RakNet הערט אויפֿן אָרטיקן UDP־פּאָרט 25570, דאַרף מען port=25570.

שטעלט אײַן voice_host ווען די קליענטן דאַרפֿן אַן אַנדער דרויסנדיקע אַדרעס אָדער פּאָרט. בײַ אַ רוטער וואָס שיקט דרויסנדיקן UDP 25580 צו אָרטיקן UDP 25570, ניצט port=25570 און voice_host=play.example.com:25580. די עפֿנטלעכע אַדרעס קומט אין voice_host. מיט bind_address קלײַבט מען דעם אָרטיקן הער־דינסט.

Raknetify2 גיט דעם געמיינזאַמען UDP־סאָקעט דורך דער API פֿון Simple Voice Chat. Simple Voice Chat אַליין באַשטעטיקט די קול־פֿאַרבינדונג און פֿאַרשליסלט די קול־דאַטן. דער קול־שמועס קען אַרבעטן סײַ בײַ אַ TCP־שפּיל־פֿאַרבינדונג, סײַ בײַ RakNet.

אַנדערע UDP־דינסטן און פּראָקסיס

לאָזט Query און Geyser אויף באַזונדערע UDP־פּאָרטן. דער געמיינזאַמער סאָקעט ווערט געשטיצט נאָר מיט Simple Voice Chat.

אויף Velocity אָדער BungeeCord טיילט דער צוגאָב נישט דעם סאָקעט מיטן קול־פּראָקסי. פֿאָלגט די אָנווײַזונגען פֿון Simple Voice Chat פֿאַר אַ פּראָקסי און גיט דעם קול־פּראָקסי זײַן אייגענעם UDP־פּאָרט. בײַם אָפֿיציעלן קול־פּראָקסי־צוגאָב שטעלט אײַן דעם עפֿנטלעכן voice_host אין די קול־אײַנשטעלונגען פֿונעם פּראָקסי. דער צוגאָב איגנאָרירט voice_host אויף די הינטער־סערווערס.

בײַ אַ געוויינטלעכן UDP־טונעל שטעלט אײַן voice_host אויפֿן עפֿנטלעכן נאָמען און UDP־פּאָרט וואָס שיקט ווײַטער צו דעם סערווער.

אויסלעשן דאָס טיילן אָדער לייזן אַ סאָקעט־סיכסוך

אויב אינעם זשורנאַל שטייט No RakNet listener matches the voice bind address and port, באַשטעטיקט אַז RakNet האָט זיך טאַקע אָנגעהויבן און אַז דער קול־פּאָרט מיט דער אָרטיקער אַדרעס שטימען מיט זײַן הער־דינסט.

אויב עס שטייט Multiple RakNet listeners match the voice bind address, קלײַבט איין פּאַסיקע אָרטיקע אַדרעס אין bind_address און הייבט ווידער אָן.

נאָר איין Simple Voice Chat־צוגאָב קען געבן זײַן UDP־סאָקעט. אויב בײַם אָנהייב ווערט געמאָלדן אַז אַן אַנדער צוגאָב גיט שוין אַ סאָקעט, קלײַבט אויס וועלכן צו נוצן.

כּדי אויסצולעשן די Raknetify2־אינטעגראַציע, שטעלט אַרײַן {"enabled": false} אין איר קול־אײַנשטעלונג אָדער נעמט אַוועק די טעקע. גיט Simple Voice Chat אַ באַזונדערן UDP־פּאָרט, פּאַסט צו דעם פֿײַערוואַל אָדער די ווײַטערשיק־כּללים און לאָזט ווידער גיין דעם סערווער.

הילף בײַ פּראָבלעמען

TCP אַרבעט, אָבער די וואַרצײַט פֿון RakNet גייט אויס

קאָנטראָלירט אין דעם סדר:

1. אויפֿן קליענט איז אינסטאַלירט דער ריכטיקער Raknetify2־מאָד פֿאַר זײַן לאָדער און Minecraft־ווערסיע.
2. דער סערווער אָדער פּראָקסי וואָס נעמט אָן די פֿאַרבינדונג האָט Raknetify2 און האָט זיך אָנגעהויבן אָן אַ פֿעלער בײַם עפֿענען דעם הער־פּאָרט.
3. די אַדרעס הייבט זיך אָן מיט raknet; און ניצט דעם דרויסנדיקן UDP־פּאָרט.
4. דער האָסטינג־דינסט, דער רוטער און דער פֿײַערוואַל פֿונעם קאָמפּיוטער דערלויבן אַלע UDP אויף יענעם פּאָרט.
5. ביידע אַדרעסן פֿונעם נאָמען, IPv4 און IPv6, פֿירן צום ריכטיקן קאָמפּיוטער מיט די נייטיקע פֿײַערוואַל־כּללים.

אַ געלונגענע TCP־פֿאַרבינדונג באַשטעטיקט בלויז דעם TCP־וועג. פּרוּווט דאָס ווײַטערשיקן UDP און דעם IPv6־צוטריט לויט די פֿײַערוואַל־ און רוטער־אָנווײַזונגען. אויב PROXY protocol איז אָנגעצונדן, מוזן די קליענטן דערגרייכן דעם הער־פּאָרט דורך אַן אײַנגעשטעלטן פֿאַרטרויטן פּראָקסי.

די אַדרעס איז שוין פֿאַרנומען

קוקט צי נאָך אַ פּראָצעס ניצט דעם UDP־פּאָרט. Query, Geyser און אַנדערע UDP־דינסטן דאַרפֿן אייגענע פּאָרטן. Simple Voice Chat קען ניצן דעם געמיינזאַמען פּאָרט.

איר קענט קלײַבן אַן אַנדער אָרטיקן UDP־פּאָרט מיט די הער־אײַנשטעלונגען אויפֿן דירעקטן סערווער אָדער די אײַנשטעלונגען פֿון Velocity און BungeeCord. באַמערקט וועלכע ווערסיע Spigot/Paper פֿאָדערט פֿאַר דעם. ענדערן נאָר דעם דרויסנדיקן פּאָרט פֿונעם רוטער לאָזט דעם סיכסוך אויפֿן אָרטיקן סאָקעט אומגעלייזט.

מע קען אַרײַנטרעטן, אָבער די אַריבערפֿירונג אַרבעט נישט

פֿאַרבינדט זיך דירעקט מיטן ציל אויף זײַן raknet;־אַדרעס. אויב דאָס געלינגט נישט, פֿאַרריכט צוערשט דעם הער־דינסט אָדער דעם נעץ־וועג דאָרטן.

אויב די דירעקטע פֿאַרבינדונג אַרבעט, זעט צי דער ציל נעמט אָן אַרײַנקומענדיקע אַריבערפֿירונגען. אַ Minecraft־סערווער מיט server.properties דאַרף accepts-transfers=true. בײַם דירעקטן אַרײַנטרעטן ווערט די אײַנשטעלונג נישט געפּרוּווט.

דערנאָך פֿאַרגלײַכט דעם נאָמען און TCP־פּאָרט אין דער אַריבערפֿיר־בקשה מיט config/raknetify2-transfers.json אויפֿן שיקנדיקן סערווער. באַשטעטיקט אַז די טעקע איז אײַנגעלאָדן נאָכן ווידעראָנהייב און אַז דער קליענט שטיצט אויטאָמאַטישע RakNet־אַריבערפֿירונגען. זעט אויטאָמאַטיש אַריבערפֿירן שפּילער.

פֿעלערן בײַם פֿאַרשליסלען אָדער אינעם פּראָטאָקאָל

קאָנטראָלירט די Raknetify2־ווערסיעס אויף ביידע צדדים. אויב אַן אויסגאַבע ענדערט דעם פֿאַרשליסלונגס־פּראָטאָקאָל, באַנײַט צוזאַמען דעם קליענט און דעם סערווער אָדער פּראָקסי. לאָזט די באַשטעטיקונגס־אײַנשטעלונגען פֿונעם סערווער אין כּוח בײַם אויספֿאָרשן דעם פֿעלער.

פֿעלערן בײַ אַ געוויסן מאָד

פֿאַרשרײַבט וואָס איר טוט ווען ס׳קומט דער פֿעלער, ווי עפֿענען די זאַכן־רשימה, באַקומען אַ רעסורסן־פּאַק, בײַטן וועלטן אָדער אַרײַנשטעלן אַ שפּיל־אָביעקט. אויב מעגלעך, פּרוּווט די זעלבע האַנדלונג אויף אַ באַזונדערער פּרוּוו־אינסטאַלאַציע איבער TCP און איבער RakNet און פֿאַרגלײַכט.

טייל אייגענע מאָד־דאַטן זענען אָפּהענגיק פֿונעם סדר פֿון געוויינטלעכע Minecraft־פּאַקעטן. די מאָד־מחברים קענען מעלדן די באַציִונג דורכן צווישנבינד פֿאַר דער ריי פֿון פּאַקעטן.

מעלדן אַ פֿעלער

עפֿנט אַ באַריכט אין דער פֿעלער־רשימה פֿון Raknetify2 און גיט אָן:

• די ווערסיעס פֿון Minecraft, Java, דעם לאָדער און Raknetify2 אויף ביידע צדדים.
• די ווערסיעס פֿונעם סערווער־ און פּראָקסי־פּראָגראַמוואַרג, אַרײַנגערעכנט יעדער UDP־ווײַטערשיק־פּראָקסי.
• די אַנדערע אינסטאַלירטע מאָדס מיט זייערע ווערסיעס.
• די שריט וואָס רופֿן ווידער אַרויס דעם פֿעלער און וואָס איר האָט דערוואַרט ס׳זאָל געשען.
• צי די זעלבע שריט אַרבעטן דורך TCP.
• די פּאַסיקע אויסצוגן פֿון קליענט־, סערווער־ און פּראָקסי־זשורנאַלן פֿון איין און דעם זעלבן פּרוּוו.

איידער איר לאָדט אַרויף די זשורנאַלן, נעמט אַרויס צוטריט־צייכנס (tokens), פּאַראָלן און אַנדערע פּריוואַטע אינפֿאָרמאַציע. לאָזט די פֿעלער־מעלדונגען און די רשימות פֿון רופֿן אין דער פּראָגראַם (stack traces) וואָס מע דאַרף כּדי צו געפֿינען די סיבה.

צופּאַסן אַ מאָד צו Raknetify2

Raknetify2 לאָזט אַ מאָד אָנגעבן וועלכע Minecraft־פּאַקעטן דאַרפֿן בלײַבן אין סדר מיט זײַנע אייגענע דאַטן. ניצט דאָס ווען די דאַטן קענען באַהאַנדלט ווערן ערשט נאָכדעם ווי פֿריִערדיקע פּאַקעטן האָבן געשטעלט אַ שפּיל־אָביעקט, אַ שטיקל וועלט, אַ זאַכן־רשימה אָדער אַן אַנדער צושטאַנד.

גרופּעס פֿאַרן סדר פֿון פּאַקעטן

גרופּע	שײַכותדיקער פֿאַרקער
ui	מעניוען און האַנדלונגען וואָס הענגען נישט אָפּ פֿון דער וועלט
entity	שאַפֿן, אַראָפּנעמען און רירן שפּיל־אָביעקטן
world_interaction	זאַכן־רשימות און אַנדערע האַנדלונגען וואָס הענגען אָפּ פֿון דער וועלט
effects	קלאַנגען און פּאַרטיקלען
chunk	ענדערונגען אין דער ערד, אין בלאָקן און אין דער באַלײַכטונג

אויף יעדן באַזונדערן קאַנאַל קומען די פּאַקעטן פֿון זײַן גרופּע פֿאַרזיכערט אָן אין דער ריי ווי מע האָט זיי געשיקט. פּאַקעטן אין פֿאַרשידענע גרופּעס קענען אָנקומען אין אַן אַנדער ריי איינס קעגן דאָס אַנדערע. קלײַבט די גרופּע אויף וועלכער די דאַטן פֿונעם מאָד הענגען אָפּ.

אָפּציאָנעלע Fabric־אינטעגראַציע

לייגט צו אַ צושטעלער אונטערן אַרײַנגאַנג raknetify:packet_channels אין fabric.mod.json פֿונעם מאָד. דער צושטעלער אימפּלעמענטירט Consumer<BiConsumer<String, String>> מיט טיפּן פֿון JDK. ער באַקומט אַ רעגיסטרירער וואָס נעמט אָן אַן אידענטיפֿיקאַטאָר פֿון מאָד־דאַטן און אַ גרופּע פֿאַרן סדר.

פֿאַרבינדט די איינס מיט אײַערע פֿאַראַנענע מעטאַדאַטן. פֿאַרבײַט דעם קלאַס־נאָמען מיטן פֿולן נאָמען פֿונעם צושטעלער אַרײַנגערעכנט דעם Java־פּאַקעט:

{
  "entrypoints": {
    "raknetify:packet_channels": [
      "com.example.mod.OrderingProvider"
    ]
  }
}

היט אָפּ דעם רעשט פֿון fabric.mod.json, אַרײַנגערעכנט די שוין פֿאַראַנענע אַרײַנגאַנגען. דאָ שטייט נאָר אַן אויסצוג פֿון דער מעטאַדאַטן־טעקע.

למשל, אַ מאָד וואָס ברייטערט אויס די באַוועגונג פֿון אַ שפּיל־אָביעקט קען רעגיסטרירן example:entity_path אין דער גרופּע entity. די PacketOrdering API־דאָקומענטאַציע ווײַזט דעם קאָד פֿונעם צושטעלער.

אָן Raknetify2 רופֿט Fabric נישט אָן דעם אַרײַנגאַנג. צושטעלער זאָלן בײַם אָנהייב רעגיסטרירן אידענטיפֿיקאַטאָרן און גרופּעס אָן זיך צו פֿאַרלאָזן אַז אַן אַנדער מאָד האָט שוין געענדיקט זײַן צוגרייטונג.

וואָס געשעט בײַ דער רעגיסטראַציע

Forge־ און NeoForge־מאָדס, ווי אויך סערווער־ אָדער פּראָקסי־צוגאָבן, קענען בײַם אָנהייב רופֿן PacketOrdering.register(identifier, group) אויב Raknetify2 איז פֿאַראַן. דער קלאַס איז com.ishland.raknetify.api.PacketOrdering. רעגיסטרירט איידער מע נעמט אָן פֿאַרבינדונגען פֿון שפּילער. זעט אַז דער אָפּציאָנעלער קאָד זאָל נישט אַרײַנלאָדן Raknetify2־קלאַסן ווען Raknetify2 פֿעלט.

די דעקלאַראַציעס גילטן פֿאַר נײַע פֿאַרבינדונגען. שוין פֿאַרבונדענע קליענטן האַלטן די כּללים וואָס זיי האָבן בײַם אָנהייב באַקומען. מע מעג איבערחזרן אַ פּונקט גלײַכע דעקלאַראַציע. זיך סותר זײַענדיקע גרופּעס פֿאַרן זעלבן אידענטיפֿיקאַטאָר ווערן אָפּגעזאָגט.

דער אידענטיפֿיקאַטאָר פֿון מאָד־דאַטן דאַרף האָבן אַן אייגענעם גילטיקן נאָמען־רום. דער נאָמען־רום minecraft איז רעזערווירט. אויף יעדן פֿאַרבינדונג־צד איז דער שיעור 128 דעקלאַראַציעס, אַרײַנגערעכנט די אײַנגעבויטע כּללים און די רעגיסטראַציעס פֿון אַנדערע מאָדס. לויטן נאָמען־רום־סינטאַקס פֿון דער API קען יעדער אידענטיפֿיקאַטאָר אַנטהאַלטן ביז 255 ASCII־צייכנס.

באַנײַטע RakNet־צדדים בײַטן זיך אויס מיט דעקלאַראַציעס בײַם אויפֿשטעלן די פֿאַרבינדונג. אויב אַ סערווער אָדער פּראָקסי האָט נישט קיין אָרטיקן כּלל פֿאַר די דאַטן, קען ער ניצן אַ דעקלאַראַציע פֿונעם צווייטן צד. אָרטיקע כּללים האָבן די בכורה. די דעקלאַראַציעס פֿונעם צווייטן צד גילטן נאָר פֿאַר יענער פֿאַרבינדונג.

UDP־פּראָקסיס

וועגן UDP־ווײַטערשיקער און ווײַטערגעשיקטע קליענט־אַדרעסן זעט ווײַטערשיקן UDP און דער PROXY־פּראָטאָקאָל.

פֿאַרן אײַנשטעלן אַ Minecraft־פּראָקסי זעט Velocity און BungeeCord.

English (US)