Skip to content

Wiki sxu

Jump to bottom
pjscruggs edited this page Nov 11, 2026 · 1 revision

Raknetify2 · Säggs’sch (Saggsn)

Sprache

Mährschbielorr

Nedzwerkgorbindunge ieber RakNet fier Minecraft-Clients un -Sörvorr.

Herundorrladn · GitHub

Minecraft Raknetify2 Client / Sörvorr
Fabric mods/raknetify2-fabric-*.jar Client / Sörvorr
Forge mods/raknetify2-forge-*.jar Client / Sörvorr
NeoForge mods/raknetify2-neoforge-*.jar Client / Sörvorr
Spigot / Paper plugins/raknetify2-spigot-*.jar Sörvorr
Velocity plugins/raknetify2-velocity-*.jar Velocity
BungeeCord plugins/raknetify2-bungee-*.jar BungeeCord

Sörvorr hinzufüschn

  1. Mährschbielorr

  2. Sörvorr hinzufüschn

  3. Sörvorradresse

    Sörvorradresse
    RakNet · UDP raknet;play.example.com:25565
    TCP play.example.com:25565

  4. Färdsch

  5. Sörvorr bedrädn

F3 · Raknetify2

F3
RakNet · UDP Agdiev · MTU 1400
TCP Nisch agdiev

Velocity / BungeeCord

  1. Client · Raknetify2 → UDP → Velocity / BungeeCord · Raknetify2
  2. Velocity / BungeeCord → TCP → Sörvorr
Portnummer · 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

Zeidüborrschreidung

Sörvorradresse UDP
raknet;play.example.com:25580 play.example.com:25580 → NAT → 192.0.2.10:25570
Sörvorr · 192.0.2.10 25570/udp

config/raknetify2-compatibility.json

Sörvorr / Velocity / BungeeCord

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

Simple Voice Chat

Sörvorr 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

Sörvorradresse trustedProxies RakNet
192.0.2.10 · PROXY v2 / UDP ["192.0.2.10"] ✓
192.0.2.11 · PROXY v2 / UDP ["192.0.2.10"] ✗
Client → RakNet / UDP ["192.0.2.10"] ✗

config/raknetify2-proxy-protocol.json

{"trustedProxies":["192.0.2.10"]}

Minecraft ≥ 1.20.5 · /transfer

  1. Sörvorr A · Fabric / Forge / NeoForge · config/raknetify2-transfers.json

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

  2. Sörvorr B · play.example.com · server.properties → accepts-transfers=true

  3. Sörvorr A · /transfer play.example.com 25565 Alex → Client (Alex) → RakNet · play.example.com:25570

PacketOrdering

Minecraft
ui Optschonen
entity Schgeledd
world_interaction Invendar
effects Bardiggl
chunk Blögge

PacketOrdering.java

Ingombadible Fährsion!

Fählorr meldn

Schdardsäide

Raknetify2

Raknetify2 nuddzd RakNet üborr UDP fürn Mährschbielorrmodus von Minecraft. Die Dadn wärdn uff mehrere Kanäle vordeild. Gehd uff eenem Kanal e Baged vorlorn, gönn de andern weidorschiggn. So gann das Schbiel och dann noch uff deine Eingabn reagiern, wenn fählende Dadn nachgeliefrt odorr Chunks üborrdragn wärdn.

Raknetify2 is e eegenständsch gepflegder Fork von Raknetify. Das Original hat dor ishland endwiggeld. Dor Fork undorschdützd neuere Minecraft-Fährsionen. Och de Dadnüborrdragung, de Anbindung an de Bladdformn un de Gombadibilitätstests wärdn hier weidor gepflegd.

De erschn Schridde

  1. Brüfe, welche Minecraft-Fährsionen un Mods zusamm bassn.
  2. Lad de bassende Datei runder un installier se.
  3. Vorrbind disch mid ner Adresse wie raknet;play.example.com.

Anleidungen für Sörvorrbedreiborr

Wer Mods endwiggeld, gann üborr de Schniddschdelle für de Bagedreihnfolge angeebn, welche Minecraft-Bagede vor odorr nach den eegnen Nutzdadn vorarbeidet wärdn müssn.

Links zum Brojegd

Raknetify2 schdehd undorr dor MIT-Lizenz un behäld de ursprünglischn Urheberrechtshinweise. De Nedzwerktechnik baut uff Raknetify un netty-raknet uff.

Insdalladschon

Lade ne voröffendlischde Fährsion von GitHub Releases runder. Gugg vor dor Insdalladschon, welche Minecraft-Fährsion un welchn Modloader de Datei brauchd.

Wo de insdalliersd Datei Ordner
Fabric-Client odorr -Sörvorr raknetify2-fabric-*.jar mods
Forge-Client odorr -Sörvorr raknetify2-forge-*.jar mods
NeoForge-Client odorr -Sörvorr raknetify2-neoforge-*.jar mods
Spigot- odorr Paper-Sörvorr raknetify2-spigot-*.jar plugins
Velocity-Proxy raknetify2-velocity-*.jar plugins
BungeeCord-Proxy raknetify2-bungee-*.jar plugins

Mach den Client zu odorr hald den Sörvorr an, eh de de JAR ausdauschsd. Nimm de alde Raknetify-JAR un alle äldorn Raknetify2-JARs aus dorr Insdalladschon raus, eh de de neue Datei reindust.

Beim Client gehörn de Ordner zu dorr Minecraft-Instanz odorr zu dem Modpack, das de schdardsd. Bei Sörvorr un Proxy liegn se im jeweilischn Insdalladschonsvorzeichnis. Hadd dor Loader den Ordner noch nisch angelegd, lech en sälbor an.

Direggd mid nem Sörvorr vorrbindn

  1. Insdallier de Client-Mod für deinn Loader.
  2. Insdallier de bassende Sörvorr-Mod odorr uff nem gombadibln Sörvorr das Plugin für Spigot/Paper.
  3. Gib UDP-Vorrbindungn zum Sörvorr frei, wie undorr Firewall un Router eenrischdn beschriebn.
  4. Schdarde Client un Sörvorr neu.
  5. Füsch ne Sörvorradresse wie raknet;play.example.com odorr raknet;play.example.com:25565 hinzu.

Adressn ohne das Präfix raknet; nuddzn TCP.

De Client-Mod alleene reischd nisch, um nen fremdn Sörvorr üborr RakNet zu erreischn. Dor Bedreiborr muss een RakNet-Endbungd bereidschdelln. Wenn de bloß uff nem fremdn Sörvorr midschbielsd, brauchsd an deim Router normalorweise keene Portweidorleitung.

Velocity un BungeeCord

Insdallier das bassende Proxy-Plugin un de Client-Mod. Undorr Velocity un BungeeCord findsd de Eenschdellungn für Listener, Weidorleitung an de Backend-Sörvorr, Zugriffsbegrenzungn un de Adresse für de Schbielorr.

Eenen eegnen UDP-Port nuddzn

Bei nem direggd erreischbarn Minecraft-Sörvorr nimm das bassende Java-Argument aus dorr Dabelle undn. Für Proxys geldn de Listener-Eenschdellungn für Velocity un BungeeCord.

Bladdform Java-Argument Erlaubde Ports
Fabric-, Forge- odorr NeoForge-Sörvorr -Draknetify.fabric.portOverride=25570 1 bis 65534
Spigot- odorr Paper-Sörvorr -Draknetify.spigot.portOverride=25570 1 bis 65535

Forge un NeoForge nuddzn denselbn Listener-Code wie Fabric. Drumm schdehd och dorte fabric im Namn von dorr Eenschdellung. Erseddze 25570 dursch den gewünsschdn UDP-Port.

Spigot / Paper ≥ 0.1.0-beta.1.431

Draach das Argument im Java-Schdardbefehl vor -jar een odorr beim Hoster im Feld für JVM-Argumente. Schdarde den Sörvorr neu un gib UDP uff dem Port frei. Is dor öffendlichde Port och 25570, vorrbind disch mid raknet;play.example.com:25570. Seddzd dor Router de Portnummer um, nimm im Client den öffendlischn Port. Dor bishärsche TCP-Port bleibd bestähn.

Bei Spigot/Paper horchd dor UDP-Listener uff dorrselbn lokaln Adresse wie dor TCP-Listener von Minecraft. Bei nem ungüldschn Wärd odorr nem belegdn UDP-Port gann RakNet nisch schdardn. Im Schdardbrodogoll siehsd de Adresse un den Port vom UDP-Listener. Nimm das Argument raus un schdarde den Sörvorr neu, dann nimmd er wiedorr de Portnummer vom TCP-Listener.

Du gannsd och am Router odorr UDP-Proxy een andern öffendlischn UDP-Port freigäbn un den an den vorhandnen Listener weidorleidn. De Java-Argumente vom Sörvorr brauchsd dafür nisch zu ändorn.

Endwigglungsfährsionen

Mach undorr GitHub Actions een erfolgräischn Lauf für main uff un lad das Archiv undorr Artifacts runder. Dafür brauchsd e GitHub-Kondo. Welche JAR ausm Archiv de brauchsd, schdehd obm in dorr Insdalladschonsdabelle.

Velocity un BungeeCord

Velocity un BungeeCord vormiddln zwischn de Schbielorr un de eigendlischn Minecraft-Sörvorr. Insdallier Raknetify2 uffm Proxy un uff jedm Client, dorr sisch üborr RakNet vorrbindn soll.

Raknetify2-Client --UDP--> Velocity odorr BungeeCord --TCP--> Backend-Sörvorr

Für den Vorrbindungswäch brauchn de Backend-Sörvorr keen Raknetify2. De Mods, Plugins un Weidorleitung, die dein Nedzwerg brauchd, müssn se weidor habn. Raknetify2 üborrseddzd keene Minecraft-Fährsionen un ändord nischd an dorr Gondobrüfung vom Proxy.

Das Proxy-Plugin insdalliern

  1. Gugg zueersd, ob normale TCP-Vorrbindungn üborr deinn Proxy gehn, och beim Anmeldn un beim Wegsl zwischn Backend-Sörvorrn.
  2. Hald den Proxy an un lad das bassende Plugin von GitHub Releases runder.
  3. Lech raknetify2-velocity-*-all.jar odorr raknetify2-bungee-*-all.jar in den Ordner plugins vom Proxy. Nimm äldere Raknetify- odorr Raknetify2-Plugins aus dem Ordner raus.
  4. Insdallier de bassende Raknetify2-Client-Mod so, wie's in dorr Insdalladschonsanleitung schdehd.
  5. Brüfe de folgndn Listener-Eenschdellungn, schdarde den Proxy neu un suche im Brodogoll nach Fählorn vom RakNet-Listener.
  6. Lass öffendlischn UDP-Vorkehr zum Proxy dursch un beschränk den Zugriff uff de Schbielports von de Backends wie undorr Firewall un Router eenrischdn beschriebn.

Nimm uffm Client un uffm Proxy Raknetify2-Fährsionen, die zusamm bassn. Lies undorr Gombadibilität nach, eh de Fährsionen mischsd.

Velocity

In dorr velocity.toml gibd bind de Minecraft-Adresse un den TCP-Port von Velocity vor. Raknetify2 nimmd normalorweise dieselbe Portnummer für UDP. De Eendrääge undorr [servers] müssn weidor uff de TCP-Adressn von de Backends zeign. Mähr schdehd in dorr Gonfiguradschonsreferenz von Velocity.

Für een extra UDP-Port seddze das JVM-Argument im Schdardbefehl von Velocity vor -jar een:

-Draknetify.velocity.portOverride=25570

Erseddze 25570 dursch deinn Port. Das ändord den RakNet-UDP-Port, dor TCP-Port von Velocity un de Backend-Adressn bleibn gleisch. Schdarde Velocity nach dorr Ändorung neu.

Rischde de Weidorleitung von de Schbielorrdadn uff Velocity un uff de Backends een. Undorschdützd das Backend de moderne Weidorleitung, nimm die un hald den gemeensamen Schlüssel geheem. Folge dorr Anleitung für dein Backend in Velocity seiner Doku zur Weidorleitung von Schbielorrdadn. Lass de Firewall-Beschränkungn fürs Backend agdiv.

BungeeCord

In dorr config.yml von BungeeCord gibd host für jedn Eendrag undorr listeners de Minecraft-Adresse un den TCP-Port an. Raknetify2 nimmd normalorweise dieselbe Portnummer für UDP. Undorr servers schdehn de TCP-Adressn von de Backends. Mähr findsd in dorr Anleitung von BungeeCord.

Für een extra UDP-Port seddze das JVM-Argument im Schdardbefehl von BungeeCord vor -jar een:

-Draknetify.bungee.portOverride=25570

De Eenschdellung gild für den ganzn Proxy-Prozess. Wenn de mährere Minecraft-Listener hasd, gugg im Schdardbrodogoll, welche RakNet-Endbungde wirglisch do sin, eh de Firewall-Regeln anlegsd. Schdarde BungeeCord nach dorr Ändorung neu.

Lass de Gondobrüfung am Proxy eengeschaldd. Für Spigot-Backends beschreibt BungeeCord seine Anleitung zur IP-Weidorleitung de Gombinadschon aus ip_forward: true am Proxy un settings.bungeecord: true am Backend. De Weidorleitung alleene vorhindord keene direggdn Vorrbindungn zum Backend. Beschränke den Zugriff nach dorr Firewall-Anleitung.

De Adresse für de Schbielorr aussuchn

Bei beedn Proxys gannsd Ports von 1 bis 65534 eenschdelln. Ungüldsche Wärde wärdn ignorierd. Gugg drumm im Schdardbrodogoll, welcher UDP-Port wirglisch gebundn is. Nimm das Argument raus un schdarde den Proxy neu, damit er wiedorr de Portnummer vom Minecraft-Listener nimmd.

De Schbielorr vorrbindn sisch midm öffendlischn Hostnamn un UDP-Port vom Proxy, zum Beischbiel üborr raknet;play.example.com:25570. Seddzd dor Router Ports um, gehörd dorr öffendlische UDP-Port in de Client-Adresse. Ohne raknet; gehd de Vorrbindung weidor üborrn TCP-Listener vom Proxy.

Gib Query, Geyser un andern UDP-Diensdn jeweils een eegnen UDP-Port. Een Gonfligd um een UDP-Socket löst keen andrer TCP-Port.

Schbrachchat un weidere UDP-Weidorleitung

Uff Velocity un BungeeCord brauchd Simple Voice Chat e eegnes Proxy-Plugin un een eegnen UDP-Port. Folge dorr Anleitung für Schbrachchat-Proxys.

Schdehd vor deim Minecraft-Proxy e extra UDP-Relay, das Header vom PROXY-Brodogoll v2 schiggd, rischde Raknetify2 wie undorr UDP-Weidorleitung un PROXY-Brodogoll beschriebn een. Für Velocity odorr BungeeCord alleene brauchsd das nisch.

De Vorrbindung brüfn

Brobier das mid nem Raknetify2-Client von außorhalb von deim lokaln Nedz. Geh üborrn Proxy rein, wegsle zwischn deine Backend-Sörvorr un gugg, ob Schbielorridentidäd un Berechdigungen noch schdimmen.

  • Wenn TCP üborrn Proxy gehd, bei RakNet abor ne Zeidüborrschreidung gommd, brüfe den UDP-Listener vom Proxy, den öffendlischn Port, de IPv4- un IPv6-Roudn un de Firewall-Regeln.
  • Scheitorn beede Vorrbindungsardn, sobald dor Proxy das Backend ansbrischd, brüfe dessen TCP-Adresse, Zugriffsregeln un de Weidorleitung von de Schbielorrdadn.
  • Melded dor Proxy een belegdn UDP-Port, gugg, ob Query, Geyser, e Schbrachchat-Proxy odorr e andrer Prozess den Port nuddzd.

Gib bei ner Fählormeldung de Brodogolle vom Proxy un vom Backend vom selbn Vorrbindungsversuch mid. Undorr Fählor suchn schdehd, welche Fährsionsangabn dazugehörn.

Firewall un Router eenrischdn

Die Anleitung is für Sörvorrbedreiborr. Raknetify2 brauchd een funktionierndn UDP-Wäch zum Sörvorr odorr Proxy, dorr de RakNet-Vorrbindungn annimmd. Dor Listener nuddzd normalorweise dieselbe Portnummer wie dorr TCP-Listener von Minecraft.

Im selbn lokaln Nedz nimm de lokale Sörvorradresse un gib UDP in dorr Firewall vom Reschner frei. Ne Portweidorleitung am Router brauchsd, wenn Vorrbindungn ausm Indernedd dursch sei IPv4-NAT müssn.

Ziel un Port aussuchn

Direggdor Sörvorr

Leide den öffendlischn UDP-Vorkehr an den Reschner weidor, uff dem dor Minecraft-Sörvorr mid Raknetify2 läufd. Ziel is dor UDP-Port vom RakNet-Listener. Gib den Port in dorr Firewall vom Reschner frei. Lass den bishärschn TCP-Zugang für normale Minecraft-Vorrbindungn bestähn.

Horchd Raknetify2 zum Beischbiel uff UDP-Port 25570, leide den öffendlischn UDP-Port an de lokale Sörvorradresse un Port 25570 weidor. Dor TCP-Port vom Sörvorr gann bei 25565 bleibn. Een andern UDP-Port schdellsd in de Listener-Eenschdellungn für direggde Sörvorrvorrbindungn een.

Velocity odorr BungeeCord

Leide den öffendlischn UDP-Vorkehr an den Reschner mid Velocity odorr BungeeCord un dem Raknetify2-Plugin weidor. Ziel is dor RakNet-UDP-Listener vom Proxy. Lass den öffendlischn TCP-Zugang zum Proxy für normale Minecraft-Vorrbindungn bestähn.

Vom Proxy zu de Minecraft-Backends läufd de Vorrbindung üborr TCP. Wechn Raknetify2 uffm Proxy brauchsd uff de Backends keene UDP-Schbielports für de Schbielorr uffmachn.

Vorrbindung Welcher Zugriff nödisch is
Schbielorr zum Proxy Öffendlischer UDP-Zugriff uffn RakNet-Listener un dorr vorhandne öffendlische TCP-Listener
Proxy zu de Backend-Sörvorr Minecraft-TCP-Ports von de Backends, bloß von de vorgesehnen Proxy-Reschnern aus erreischbar
Schbielorr direggd zu de Schbielports von de Backends Geschberrd lassn, och üborr IPv6

Laufn Proxy un Backends direggd uff nem eegnen dedizierdn Reschner, gönn de Backend-Listener Loopback-Adressn nuddzn. Draach die im Proxy een. Bei getrennden Reschnern beschränksde den TCP-Zugriff uff de Backends per Firewall odorr mid nem abgetrenndn brivadn Nedz uff de Proxy-Reschner. Bei Containern un vorwaldedn Hosts brauchds ähnlische Beschränkungn, die zum jeweilischn Nedzaufbau bassn. Siehe Velocity-Backends absichern un de Firewall-Anleitung von BungeeCord.

De Weidorleitung von de Schbielorrdadn un de Firewall-Regeln ergänzn sisch. Wer direggd ufs Backend gommd, gann de Anmeldebrüfung vom Proxy umgehn. De Insdalladschon vom Plugin, de Weidorleitung un abweichende UDP-Ports beschreibd Velocity un BungeeCord.

Öffendlische un lokale Portnummern

Seddzd e Router de Portnummer um, gönn dor öffendlische Port un dor Listener-Port vorschiedn sein:

Eenschdellung Welchor Port gehörd rein?
Sörvorradresse im Client Öffendlischer UDP-Port
Äußrer Port von dorr Weidorleitungsregel im Router Öffendlischer UDP-Port
Innrer Port von dorr Weidorleitungsregel im Router UDP-Port vom RakNet-Listener
Lokaler Port in dorr Firewall vom Reschner UDP-Port vom RakNet-Listener

IPv4-Portweidorleitung

Wenn dein Sörvorr hindor nem IPv4-Router schdehd:

  1. Such de lokale IPv4-Adresse von dem Reschner, dorr RakNet-Vorrbindungn annimmd. Rischde ne DHCP-Reservierung een odorr nimm ne bassende fesde Adresse, damid de Weidorleitung och späder noch uff den Reschner zeigd.
  2. Lech ne UDP-Weidorleitung für den öffendlischn Port an, den de Schbielorr nuddzn solln.
  3. Draach als Ziel de lokale Adresse vom Reschner un den UDP-Port vom RakNet-Listener een.
  4. Erlaube in dorr Firewall vom Reschner eengehenden UDP-Vorkehr zum Listener-Port.

Horchd dor Sörvorr uff UDP-Port 25565, gann de Regel zum Beischbiel den öffendlischn Port 25565, de Zieladresse 192.168.1.100 un den Zielport 25565 habn. Erseddze de Beischbieladresse dursch de wirglisch lokale Adresse von deim Sörvorr.

Lass de vorhandne TCP-Regel für normale Minecraft-Vorrbindungn drin. Die alleene leided keenen UDP-Vorkehr weidor.

Wenn de Weidorleitung drodzdem nisch gehd

Gugg, ob vor deim Router noch e andrer Router odorr dein Inderneddanbiedorr NAT nuddzd. Bei zwee eegnen Routern mussde uff beedn weidorleidn. Nuddzd dorr Anbiedorr Carrier-Grade NAT, fraach nach ner öffendlischn IPv4-Adresse odorr nimm een Hoster odorr Tunnel, dorr eengehendes UDP undorschdützd. De Weidorleitungsregel vom Router gann dem Anbiedorr sei NAT nisch eenschdelln. TP-Link erglärd de Vorausseddzungn für de öffendlische WAN-Adresse.

Firewall-Regeln für IPv6

Gib den gewähldn UDP-Port in dorr IPv6-Firewall vom Router un in dorr Firewall vom Reschner frei. Ziel is de IPv6-Adresse von dem Reschner, dorr RakNet-Vorrbindungn annimmd.

Gugg, ob de IPv6-Adresse vom Hostnamn uff den Reschner zeigd. Ändord sisch seine IPv6-Adresse, aktualisier den DNS-Eendrag un alle Firewall-Regeln, die jenau die Adresse nuddzn.

Gibd e Hostname IPv4- un IPv6-Adressn an, muss jede davon erreischbar sein. Brüfe beede Regelsätze, wenn e Schbielorr reengommd un e andrer nisch.

Ändord de IPv4-Weidorleitung de Portnummer, muss dor Port, den de Schbielorr eengeebn, och den IPv6-Listener erreischn. Ne Portumseddzung für IPv4 rischded keenen IPv6-Wäch een.

Hoster un Tunnel

Dor Anbiedorr odorr Tunnel muss UDP uff dem öffendlischn Endbungd undorschdützn, den de de Schbielorr gibsd. Brüfe seine zugewiesnen Ports un de Nedz-Firewall-Regeln jenauso wie de Firewall vom Sörvorr.

Leided e zusäddlischer UDP-Proxy de Client-Adressn midm PROXY-Brodogoll v2 weidor, folge UDP-Weidorleitung un PROXY-Brodogoll. Lass am empfangenden UDP-Listener bloß den vortrauenswürdigen Proxy zu.

De Vorrbindung brüfn

Vorrbind disch von außorhalb vom lokaln Sörvorrnedz mid nem aktuellen Raknetify2-Client, zum Beischbiel üborr raknet;play.example.com:25565. Nimm dafür den öffendlischn UDP-Port.

Brüfe den Wäch mid ner rischdschen RakNet-Vorrbindung. E UDP-Scan ohne Antwort is nisch eindeudsch: Och e funktionierender Dienst gann e fremdes Brobebaged vorwerfn. De Doku zu UDP-Scans mid Nmap erglärd das.

Ne erfolgräische TCP-Vorrbindung beschdädigd bloß den TCP-Wäch. Gommd bei RakNet ne Zeidüborrschreidung, brüfe Listener, Weidorleitungsziel, UDP-Port un Firewall-Regeln mid dorr Anleitung zur Fählorsuche.

Gombadibilität

Brüfe de Gombadibilität für jenau de Fährsion, de de runderlädsd. Im Endwigglungszweig gann schon was undorschdützd sein, was in keener voröffendlischden Fährsion drin is.

Minecraft- un Java-Fährsionen

Lad für Fabric de compatibility.json aus der sälbn Voröffendlischung wie de JAR runder. Such deene Minecraft-Fährsion undorr gameVersions un gugg im bassenden Eendrag undorr runtimes, was undorr depends vorlangd würd. De JSON-Datei is zum Nachguggn un muss nisch in den Ordner mods.

Brüfe bei Forge, NeoForge un Spigot/Paper de Fährsionsanforderungn von dorr jeweilischn Datei un ihrer Downloadsäide. Wenn was uff eenem Loader läufd, heißd das nisch, dass es och uffm andern gehd.

Raknetify2 gibd de mindesdens nödige Java-Fährsion an. Minecraft odorr dorr Loader gönn ne neuere Laufzeidumgebung vorlangn. Nimm ne Java-Fährsion, die alle dree Anforderungen erfülld.

Fährsionen uff Client un Sörvorr

Nimm wenn möglisch diesälbe Raknetify2-Fährsion uffm Client un uffm Sörvorr odorr Proxy, dorr seine Vorrbindung annimmd. Lies de Fährsionshinweise, eh de Fährsionen mischsd. Für vorschlüsselde RakNet-Vorrbindungn müssn beede Säidn das Brodogoll für authendifizierde Vorschlüsselung undorschdützn. Das ursprünglische Raknetify un äldere Raknetify2-Fährsionen vor dem Brodogoll gönn keene so vorschlüsselde Vorrbindung zu aktualisierdn Gegnschdelln herschdelln.

Raknetify2 üborrdrächd das vorhandne Schbielbrodogoll von Minecraft. Für vorschiedne Minecraft-Fährsionen brauchsd zusäddlisch ne bassende Brodogollüborseddzung.

Andre Mods

Dor Build-Workflow brüfd de Gombadibilität undorr anderm mid Polymer, Krypton, PacketFixer un Fast IP Ping. De Desds geldn für de Fährsionen un Gombinadschonen, die im Workflow ausgewähld sin. Gugg für ne beschdimmde Gombinadschon de Build-Ergebnisse von dorr jeweilischn Voröffendlischung an.

Bei nem Fählor in nem gräßorn Modpack folge dorr Anleitung zur Fählorsuche. Gib in dorr Meldung de jenauen Fährsionen von alln Mods an.

Modus mid fesdor Bagedreihnfolge

Modus mid fesdor Bagedreihnfolge

Normalorweise gönn de Kanäle von Raknetify2 unabhängsch weidormachn, wenn eener uff fählende Dadn warded. Bei fesdor Reihnfolge gehn alle Minecraft-Bagede pro Rischdung üborr een eenzigen Kanal. Fähld e Baged, müssn alle schbädern in dorr Rischdung wardn, bis es nochma angommd. So bleibd de Reihnfolge erhaldn, die mansche Anti-Cheat-Brogramme erwardn. In dorr Zeid schdehd abor och dorr übrige Schbielvorkehr in dorr Rischdung.

Fesde Bagedreihnfolge eenschaldn

  1. Insdallier ne Raknetify2-Fährsion mid dem Modus uffm Sörvorr odorr Proxy, dorr RakNet-Vorrbindungn annimmd, un uff alln RakNet-Clients.

  2. Lech im Arbeitsvorzeichnis von dem Sörvorr odorr Proxy de Datei config/raknetify2-compatibility.json an. Fähld dorr Ordner config, lech en zueersd an.

  3. Draach das een:

    {"mode": "ordered"}

  4. Schdarde den Sörvorr odorr Proxy neu.

De Clients üborrnähmn de Eenschdellung vom Sörvorr automadsch. De Schbielorr brauchn wedorr ne eegne Gonfiguradschonsdatei noch ne andre RakNet-Sörvorradresse.

Alle Minecraft-Bagede gehn pro Rischdung üborr een zuverlässigen Kanal mid fesder Reihnfolge. Das gild och für de Begrenzungn von Bagedbündeln un für Weldwegsl.

Bedrieb mid Proxy

Vorrbindn sisch de Schbielorr üborr Velocity odorr BungeeCord, rischde de fesde Reihnfolge uff dem Proxy een, och wenn das Anti-Cheat-Brogramm uff nem Backend-Sörvorr läufd.

De Eenschdellung bleibd beim Backend-Wegsl wirksam. Bei fesder Reihnfolge leided dorr Proxy Keepalive-Anfragn vom Backend an den wirglischn Client weidor, schdadd se sälbor zu beantwordn.

De Eenschdellung brüfn

Bei dorr erschn RakNet-Vorrbindung melded de Konsole:

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

Nach erfolgräischer Aushandlung schdehd och ordered compatibility negotiated im Brodogoll, dornach gommd de Adresse von dorr Gegnschdelle.

Lass de Anti-Cheat-Brüfungen eengeschaldd un desde deene eegne Gonfiguradschon.

Äldere Clients

RakNet-Clients ohne Undorschdützung für de fesde Reihnfolge gönn nisch uff een Sörvorr, dorr se vorlangd. Aktualisier Raknetify2 uff den Clients odorr nimm de normale TCP-Adresse un den Port vom Sörvorr odorr Proxy. Lass dabei raknet; wäch.

Zurügg zum Mährkanalbedrieb

Ändor den Dateiinhalt so:

{"mode": "multichannel"}

Schdarde den Sörvorr odorr Proxy dornach neu. Du gannsd de Datei och löschn. Nach nem Neuschdard is dorr Mährkanalbedrieb dann och wiedorr agdiv.

Brobleme mid dorr Gonfiguradschon

De Datei muss jenau eene Eenschdellung namens mode endhaldn, mid dem Wärd "ordered" odorr "multichannel". Pass uff Groß- un Kleinschreibung uff.

Is de Gonfiguradschon ungüldsch odorr nisch läsbar, wärdn RakNet-Vorrbindungn abgewiesn. Bessor de Datei aus un schdarde den Prozess neu.

Melded de Konsole immer noch multichannel, gugg, ob de Datei im Arbeitsvorzeichnis von jenau dem Sörvorr odorr Proxy liegd, dorr de RakNet-Vorrbindung annimmd. Schdarde den Prozess neu.

Automadsch den Sörvorr wegsln

Fabric-, Forge- un NeoForge-Sörvorr gönn RakNet aussuchn, wenn se een bassenden Client zu nem eengetragn Ziel schiggn. Dafür nuddzn se den Sörvorrtransfer von Minecraft, den es seit Java Edition 1.20.5 gibd. Brüfe für beede Säidn, ob deene Raknetify2-Fährsion de jeweilische Minecraft-Fährsion un den Loader undorschdützd.

Insdallier Raknetify2 uffm sendenden Sörvorr un uffm Client. Das Ziel muss een gombadibln RakNet-Listener anbiedn un eengehende Minecraft-Transfers annähmn.

Die Gonfiguradschon gild für Transfers, die von Sörvorrn mid den dree Modloadern obm wächgeschiggd wärdn. De Plugins für Spigot/Paper, Velocity un BungeeCord läsn die Transferdatei nisch.

Den sendenden Sörvorr eenrischdn

Lech im Vorzeichnis vom sendenden Sörvorr de Datei config/raknetify2-transfers.json an:

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

Erseddze Hostnamn un Ports im Beischbiel dursch de Wärde von deim Ziel. Schdarde dornach den sendenden Sörvorr neu. Weidere Ziele drächsd ins sälbe Array een.

Feld Bedeudung
host Hostname odorr IP-Adresse vom Ziel, ohne Transportpräfix un ohne Port
tcpPort Zielport in dorr ursprünglischn Transferanfraache
udpPort Öffendlischer RakNet-Port, zu dem sisch dorr weidorgeleidede Client vorrbindn soll

TCP un UDP dürfn diesälbe Portnummer nuddzn. Seddzd dor Router den UDP-Port um, draach hier den öffendlischn Port een. Schreib Portnummern als JSON-Zahln.

Schigg Transfers zum normalen Hostnamn un TCP-Port vom Ziel. Raknetify2 guggd, ob dor Client Undorschdützung für automadsche Transfers melded. Gann er das un bassd das Ziel zu nem Eendrag, würd dorr eengeschdellde UDP-Port genomm. Für andre Clients un nisch eengetragne Ziele bleibd de ursprünglische Transferadresse erhaldn.

Vorglischn wärdn Hostname un TCP-Port aus dorr Transferanfraache. Groß- un Kleinschreibung, e DNS-Pungd am Ende un gleischwärdsche IPv6-Schreibweisn wärdn voreinheidlischd. Es gibd keene DNS-Abfraache. Zwee vorschiedne Hostnamn brauchn also eegne Eendrääge, och wenn se uff dieselbe Adresse zeign. Platzhaldor sin nisch undorschdützd.

Das Ziel eenrischdn

Nuddzd das Ziel de Minecraft-Datei server.properties, seddze dorte accepts-transfers=true un schdarde den Sörvorr neu. E Ziel-Proxy gann ne eegne Transfereenschdellung habn. Minecraft lehnd eengehende Transfers normalorweise ab, och wenn e direggdor Beidritt gehd.

Dor RakNet-Listener vom Ziel, de öffendlische UDP-Weidorleitung un de Firewall vom Reschner müssn schon eengerischd sein. De Transferdatei uffm sendenden Sörvorr beschdimmd, welche Adresse dorr Client grichd.

Brüfe bei nem Hostnamn mid IPv4- un IPv6-Adresse beede Wäche zum Ziel. Desde zueersd ne normale direggde RakNet-Vorrbindung, eh de automadsche Transfers undorsuchsd.

Lass Anmelde- un Zugangsbrüfung am Ziel eengeschaldd. De Gonfiguradschon gibd keenem Schbielorr Zugang un erseddzd de Authendifizierung vom Sörvorr nisch.

Gonfiguradschonsfählor un Ausschaldn

Fählende odorr unbekannde Fäldor, ungüldsche Ports un doppelde Ziele führn beim Schdard zu nem Gonfiguradschonsfählor. Such den Fählor im Sörvorrbrodogoll, bessor de JSON-Datei aus un schdarde den Sörvorr neu.

Zum Abschaldn von dorr automadschn Auswahl nimm de Gonfiguradschonsdatei raus odorr draach {"destinations": []} een. Schdarde dornach den sendenden Sörvorr neu. Seine Transferanfragn behaldn de ursprünglischn Adressn.

UDP-Weidorleitung un PROXY-Brodogoll

E UDP-Proxy gann RakNet-Vorkehr weidorleidn un de ursprünglische Client-Adresse midm PROXY-Brodogoll v2 midgeebn. Schalde das een, wenn e vorgeschaldedor UDP-Proxy solche Header an deinn Listener schiggd. Für ne normale Portweidorleitung am Router brauchsd das nisch.

Lech uff dem Sörvorr odorr Minecraft-Proxy, dorr den weidorgeleidedn UDP-Vorkehr empfängd, de Datei config/raknetify2-proxy-protocol.json an:

{
  "trustedProxies": ["192.0.2.10"]
}

Erseddze das Beischbiel dursch de wirglische Quell-IP vom UDP-Proxy odorr een CIDR-Bereisch, den de gondrolliersd. De Adresse muss zu dorr bassn, die dor empfangende Listener nach nem möglischn NAT siehd. IPv4- un IPv6-Adressn in Zahlnschreibweise sin erlaubd. DNS-Namn wärdn abgewiesn. Schdarde den empfangenden Sörvorr odorr Proxy neu.

Rischde den weidorleidenden Proxy so een, dass er für UDP Header vom PROXY-Brodogoll v2 schiggd. Raknetify2 nimmd weidorgeleidede Client-Adressn bloß von den eengetragnen Quelln an. Solange das een is, wärdn direggde RakNet-Vorrbindungn ohne solche Header abgewiesn. Dor TCP-Listener behäld seine Eenschdellungn.

Vortraun un Zugriff

Jeder eengetragne Proxy darf Client-Adressn angeebn. Beschränke drumm in dorr Firewall vom Backend den Zugriff uff sein UDP-Port uff de vorgesehnen Proxys. Hald de freigegebnen Adressbereische so eng, wie dein Nedz das zulässt.

De Datei darf bloß trustedProxies endhaldn un brauchd mindesdens een Eendrag. E leeres Array is e Fählor. Bei ner ungüldschn Datei schdarded dorr RakNet-Listener nisch.

Nimm de Datei raus un schdarde den Listener neu, damid direggde UDP-Vorrbindungn wiedorr gehn. Pass gleichzeitig de Weidorleitung am vorgeschaldedn Proxy un de Firewall-Regeln an den neuen Wäch an.

Wenn Vorrbindungn nachm Eenschaldn scheitorn, brüfe de wirglische Quelladresse vom Proxy am Backend, den freigegebnen Adressbereisch un ob dorr Proxy für UDP Header vom PROXY-Brodogoll v2 schiggd.

Wie mer een Minecraft-Proxy insdallierd un de Backends eenrischded, schdehd undorr Velocity un BungeeCord.

Simple Voice Chat

Uff Fabric, Forge, NeoForge, Spigot un Paper gann Raknetify2 den UDP-Listener vom Sörvorr mid Simple Voice Chat deiln.

Insdallier Simple Voice Chat uffm Sörvorr un uff alln Clients, die Schbrachchat nuddzn wolln. Für de übrigen Eenschdellungn folge dorr Sörvorranleitung von Simple Voice Chat.

De Datei von Raknetify2 gehörd och bei Spigot/Paper in den obersdn config-Ordner vom Sörvorr. De Datei von Simple Voice Chat sälbor bleibd im bladdformspezifischn Ordner, dorr undn schdehd.

Den Schbielport zusamm nuddzn

  1. Lech im Sörvorrvorzeichnis de Datei config/raknetify2-voicechat.json mid dem Inhalt an:

    {"enabled": true}

  2. Seddze in dorr Sörvorrgonfiguradschon von Simple Voice Chat port=-1. Uff nem Sörvorr mid Modloader is das config/voicechat/voicechat-server.properties, bei Spigot/Paper plugins/voicechat/voicechat-server.properties.

  3. Lass bind_address leer, wenns jenau een bassenden RakNet-Listener gibd. Horchn mährere uff dem UDP-Port, gib de lokale Adresse von dem Listener an, den de deiln willsd.

  4. Schdarde den Sörvorr neu un führe für een vorbundnen Schbielorr /voicechat test <PLAYERNAME> aus.

Nuddzd dor RakNet-Listener een andern Port wie Minecraft, seddze port fürn Schbrachchat ausdrügglisch uff den lokaln UDP-Port schdadd uff -1. Horchd RakNet uffm lokaln UDP-Port 25570, brauchds port=25570.

Seddze voice_host, wenn de Clients ne andre öffendlische Adresse odorr Portnummer brauchn. Leided e Router den öffendlischn UDP-Port 25580 zum lokaln UDP-Port 25570 weidor, nimm port=25570 un voice_host=play.example.com:25580. De öffendlische Adresse gehörd in voice_host. Mid bind_address suchsd een lokaln Listener aus.

Raknetify2 schdelld den gemeensamen UDP-Socket üborr de API von Simple Voice Chat bereit. Simple Voice Chat üborrnimmd de Authendifizierung un Vorschlüsselung fürn Schbrachchat. De Schbielorr gönn en nuddzn, egal ob ihre Schbielvorrbindung üborr TCP odorr RakNet läufd.

Andre UDP-Diensde un Proxys

Gib Query un Geyser je een eegnen UDP-Port. Das Deiln vom Socket gehd bloß für Simple Voice Chat.

Uff Velocity odorr BungeeCord deild die Indegradschon keenen Socket midm Schbrachchat-Proxy. Folge dorr Proxy-Anleitung für Simple Voice Chat un gib dem Schbrachchat-Proxy een eegnen UDP-Port. Beim offiziellen Proxy-Plugin gehörd ne abweichende öffendlische Adresse für voice_host in de Schbrachchat-Gonfiguradschon vom Proxy. Das Plugin ignorierd de voice_host-Eenschdellungn von de Backends.

Bei nem gewöhnlischn UDP-Tunnel seddze voice_host uff den öffendlischn Hostnamn un den UDP-Port, dorr zu dem Sörvorr weidorleided.

Das Deiln abschaldn odorr een Socket-Gonfligd lösn

Schdehd im Brodogoll No RakNet listener matches the voice bind address and port, gugg, ob RakNet rischtisch geschdarded is. Dor Schbrachchat-Port un de lokale Bindeadresse müssn zum Listener bassn.

Bei dorr Meldung Multiple RakNet listeners match the voice bind address gib undorr bind_address ne beschdimmde bassende lokale Adresse an un schdarde den Sörvorr neu.

Bloß een Plugin gann Simple Voice Chat sein UDP-Socket lieforn. Melded dor Sörvorr beim Schdard, dass schon e andres Plugin een Socket lieford, endscheide disch für eene von den Indegradschonen.

Zum Abschaldn von dorr Raknetify2-Indegradschon seddze in ihrer Schbrachchat-Gonfiguradschon {"enabled": false} odorr nimm de Datei raus. Gib Simple Voice Chat een eegnen UDP-Port, pass Firewall- odorr Weidorleitungsregeln an un schdarde den Sörvorr neu.

Fählor suchn

TCP gehd, abor bei RakNet gommd ne Zeidüborrschreidung

Geh de Pungde dorr Reihe nach dursch:

  1. Uffm Client is de zu seim Loader un seiner Minecraft-Fährsion bassende Raknetify2-Mod insdallierd.
  2. Uffm Sörvorr odorr Proxy, dorr de Vorrbindung annimmd, is Raknetify2 insdallierd. Dor Listener is ohne Fählor geschdarded.
  3. De Adresse fängd mid raknet; an un nuddzd den öffendlischn UDP-Port.
  4. Dor Hoster, dor Router un de Firewall vom Reschner lassn UDP uff dem Port dursch.
  5. De IPv4- un IPv6-Adressn vom Hostnamn zeign uff den rischtischn Reschner. De Firewall-Regeln lassn beede Wäche zu.

Ne erfolgräische TCP-Vorrbindung beschdädigd bloß den TCP-Wäch. Brüfe UDP-Weidorleitung un IPv6-Zugang wie undorr Firewall un Router eenrischdn beschriebn. Is das PROXY-Brodogoll eengeschaldd, müssn de Clients üborr een eengetragnen vortrauenswürdigen Proxy zum Listener gomm.

Adresse schon beleggd

Gugg, ob e andrer Prozess den UDP-Port nuddzd. Query, Geyser un andre UDP-Diensde brauchn eegne Ports. Mid Simple Voice Chat gannsd den Port zusamm nuddzn.

Eenen andern lokaln UDP-Port gannsd in de Listener-Eenschdellungn für direggde Sörvorrvorrbindungn odorr de Eenschdellungn für Velocity un BungeeCord fesdlegn. Pass uff de nödige Fährsion für Spigot/Paper uff. Bloß den öffendlischn Port am Router zu ändorn löst den lokaln Socket-Gonfligd nisch.

Direggd beitredn gehd, Sörvorrwegsl scheitorn

Vorrbind disch direggd mid dorr raknet;-Adresse vom Ziel. Scheitord schon das, bring zueersd den Ziel-Listener odorr den Nedzwerkwäch in Ordnung.

Gehd de direggde Vorrbindung, gugg, ob das Ziel eengehende Transfers annimmd. E Minecraft-Sörvorr mid server.properties brauchd accepts-transfers=true. Beim direggdn Beidritt würd die Eenschdellung nisch gebrüfd.

Vorgleiche dornach Hostnamn un TCP-Port aus dorr Transferanfraache mid config/raknetify2-transfers.json uffm sendenden Sörvorr. Brüfe, ob de Datei nach nem Neuschdard geladn wurde un ob dorr Client automadsche RakNet-Transfers undorschdützd. Siehe Automadsch den Sörvorr wegsln.

Vorschlüsselungs- odorr Brodogollfählor

Brüfe de Raknetify2-Fährsionen uff beedn Säidn. Ändord ne Fährsion das vorschlüsselde Brodogoll, aktualisier Client un Sörvorr odorr Proxy zusamm. Lass bei dorr Fählorsuche de Authendifizierungseenschdellungn vom Sörvorr so, wie se sin.

Fählor mid beschdimmden Mods

Schreib uff, was den Fählor auslösd, zum Beischbiel e Inventar uffmachn, e Ressourcenbaged empfagn, de Weld wegsln odorr e Objegd erzeuchn. Vorgleiche densälbn Vorgang üborr TCP un RakNet, wenn möglisch in ner eegnen Desdinsdalladschon.

Bei manschen eegnen Nutzdadn gommds druff an, in welchor Reihnfolge se relativ zu de Vanilla-Bagede eendreffn. Mod-Endwigglor gönn das üborr de Schniddschdelle für de Bagedreihnfolge angeebn.

Eenen Fählor meldn

Mach im Issue-Tracker von Raknetify2 ne Meldung uff un gib das an:

  • Minecraft-, Java-, Loader- un Raknetify2-Fährsionen uff beedn Säidn.
  • Fährsionen von dorr Sörvorr- un Proxy-Software, och von vorgeschaldedn UDP-Proxys.
  • Alle andern insdallierdn Mods mid ihrn Fährsionen.
  • De Schridde, mid denen mer den Fählor nachschdelln gann, un was de erwarded hasd.
  • Ob desälbn Schridde üborr TCP gehn.
  • Bassende Ausschnidde aus de Brodogolle vom Client, Sörvorr un Proxy vom sälbn Vorrbindungsversuch.

Nimm Zugriffstoken, Basswördor un andre brivade Angabn raus, eh de Brodogolle hochlädsd. Lass de für de Diagnose nödigen Fählormeldungn un Stacktraces drin.

Eegne Mods anbinden

Mid Raknetify2 gönn Mods angeebn, bei welchn Minecraft-Bagedn de Reihnfolge gegenüborr ihrn eegnen Nutzdadn erhaldn bleibn muss. Das brauchds, wenn de Vorarbeidung e Objegd, een Chunk, e Inventar odorr een andern Zuschdand vorausseddzd, den erschd e früheres Baged horgeschdelld hadd.

Gruppn für de Bagedreihnfolge

Grubbe Zugehörischer Dadnvorkehr
ui Weldunabhängsche Menüs un Interagdschonen
entity Erzeuchn, Endfern un Bewegn von Objegdn
world_interaction Inventare un andre weldabhängsche Interagdschonen
effects Geräusche un Bardigl
chunk Ändorungn an Gelände, Blöggn un Beleuchdung

Innerhalb von jedem Kanal gomm de Bagede zuverlässisch in dorr rischtischn Reihnfolge an. Bagede aus vorschiednen Gruppn gönn in ner andern Reihnfolge zueinander gomm. Nimm de Grubbe, die zur Abhängischkeed von deinen Nutzdadn bassd.

Obdschonale Anbindung für Fabric

Draach in dorr fabric.mod.json von deenor Mod een Provider fürn Eenschdiegsbungd raknetify:packet_channels een. Dor Provider implemendierd Consumer<BiConsumer<String, String>> mid Typen ausm JDK. Er grichd ne Registrierfungdschon, die ne Kennung für eegne Nutzdadn un de zugehörische Grubbe annimmd.

Ergänze deene vorhandnen Metadadn um den Eendrag. Erseddze den Klassennamn dursch den vollständsch qualifizierdn Namn von deim Provider:

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

Das Beischbiel zeigd bloß een Ausschnidd. Behald den Räsd von deenor fabric.mod.json mid alln vorhandnen Eenschdiegsbungdn bei.

Ne Mod für Objegdbewegungn gann zum Beischbiel example:entity_path in dorr Grubbe entity registriern. De Doku zur PacketOrdering-API zeigd de Implemendierung vom Provider.

Fähld Raknetify2, rufd Fabric den Eenschdiegsbungd nisch uff. Registrier Kennungn un Gruppn während dorr Inidialisierung, ohne vorauszuseddzn, dass ne andre Mod mid ihrer eegnen Inidialisierung schon färdsch is.

Wie de Registrierung abläufd

Wenn Raknetify2 vorfüchbar is, gönn Forge- un NeoForge-Mods un Sörvorr- odorr Proxy-Plugins bei dorr Inidialisierung PacketOrdering.register(identifier, group) uffrufn. De Glasse heeßd com.ishland.raknetify.api.PacketOrdering. Registrier de Regeln, eh dor Sörvorr Schbielorrvorrbindungn annimmd. Bei obdschonaler Anbindung darf dein Code keene Raknetify2-Glassn ladn, wenn de Abhängischkeed fähld.

De Regeln geldn für neue Vorrbindungn. Vorhandne Vorrbindungn behaldn de Regeln vom Vorrbindungsuffbau. De sälbe Regel mährmals zu registriern is erlaubd. Widersprüschlische Gruppn für desälbe Kennung wärdn abgewiesn.

Nutzdadn-Kennungn brauchn een güldschn eegnen Namensraum. Dor Namensraum minecraft is reservierd. Pro Endbungd sin zusamm höchsdns 128 Regeln zulässisch, eengebaude Regeln un Registrierungen von andern Mods midgezähld. Kennungn dürfn bis zu 255 ASCII-Zeischn lang sein un müssn dorr Namensraum-Syntax von dorr API endschbreschn.

Aktualisierde RakNet-Gegnschdelln dauschn beim Vorrbindungsuffbau ihre Regeln aus. E Sörvorr odorr Proxy gann de Regel von dorr Gegnschdelle nuddzn, wenn er für de Nutzdadn keene eegne hadd. Lokale Regeln habn Vorrang. De Regeln von dorr Gegnschdelle geldn bloß für de jeweilische Vorrbindung.

UDP-Proxys

Infos zu UDP-Relays un weidorgeleidede Client-Adressn findsd undorr UDP-Weidorleitung un PROXY-Brodogoll.

Wie mer een Minecraft-Proxy eenrischded, schdehd undorr Velocity un BungeeCord.

English (US)

Clone this wiki locally