Proxies - Revision history

imported>LassiPulkkinen: Add Category:Minecraft Modern.

2024-02-26T18:44:56Z

← Older revision		Revision as of 18:44, 26 February 2024
Line 15:		Line 15:
	})</syntaxhighlight>		})</syntaxhighlight>
	Although shown in the example, you don’t necessarily have to modify the packets, you can just send the raw packets. One thing you do have to do is handle that the Entity IDs are different, this is where one of the differences between Velocity and BungeeCord comes into play, BungeeCord rewrites all the Entity IDs and Velocity respawns you twice to reset your Entity ID.		Although shown in the example, you don’t necessarily have to modify the packets, you can just send the raw packets. One thing you do have to do is handle that the Entity IDs are different, this is where one of the differences between Velocity and BungeeCord comes into play, BungeeCord rewrites all the Entity IDs and Velocity respawns you twice to reset your Entity ID.

			[[Category:Minecraft Modern]]

imported>NoahvdAa at 10:07, 8 May 2022

2022-05-08T10:07:34Z

← Older revision		Revision as of 10:07, 8 May 2022
Line 5:		Line 5:
	= How do the popular ones work? =		= How do the popular ones work? =

	Currently, the most popular proxy implementations of proxies are [https://github.com/VelocityPowered/Velocity Velocity] and [https://github.com/SpigotMC/BungeeCord ~~Bungee~~]. They work by having the the proxy start the server that is public facing, then having the proxy make the connections to the play server itself and relay the packets, in this way the proxy can change packets before they hit either the actual server or the player’s client. In a simple sense, this is what the code looks like very-oversimplified:		Currently, the most popular proxy implementations of proxies are [https://github.com/VelocityPowered/Velocity Velocity] and [https://github.com/SpigotMC/BungeeCord BungeeCord]. They work by having the the proxy start the server that is public facing, then having the proxy make the connections to the play server itself and relay the packets, in this way the proxy can change packets before they hit either the actual server or the player’s client. In a simple sense, this is what the code looks like very-oversimplified:

	<syntaxhighlight lang="js">server = new Server(/* this will be the player facing server */)		<syntaxhighlight lang="js">server = new Server(/* this will be the player facing server */)
Line 14:		Line 14:
	serverClient.on('packet', packet => server.send(modifyS2C(packet))) // when our internal server wants to send a packet to the client, we relay that packet to the client after modifying it		serverClient.on('packet', packet => server.send(modifyS2C(packet))) // when our internal server wants to send a packet to the client, we relay that packet to the client after modifying it
	})</syntaxhighlight>		})</syntaxhighlight>
	Although shown in the example, you don’t necessarily have to modify the packets, you can just send the raw packets. One thing you do have to do is handle that the Entity Is are different, this is where one of the differences between Velocity and BungeeCord comes into play, ~~Bungeecord~~ rewrites all the Entity IDs and Velocity respawns you twice to reset your Entity ID.		Although shown in the example, you don’t necessarily have to modify the packets, you can just send the raw packets. One thing you do have to do is handle that the Entity IDs are different, this is where one of the differences between Velocity and BungeeCord comes into play, BungeeCord rewrites all the Entity IDs and Velocity respawns you twice to reset your Entity ID.

imported>U9G at 20:54, 20 August 2021

2021-08-20T20:54:09Z

← Older revision		Revision as of 20:54, 20 August 2021
Line 14:		Line 14:
	serverClient.on('packet', packet => server.send(modifyS2C(packet))) // when our internal server wants to send a packet to the client, we relay that packet to the client after modifying it		serverClient.on('packet', packet => server.send(modifyS2C(packet))) // when our internal server wants to send a packet to the client, we relay that packet to the client after modifying it
	})</syntaxhighlight>		})</syntaxhighlight>
	Although shown in the example, you don’t necessarily have to modify the packets, you can just send the raw packets.		Although shown in the example, you don’t necessarily have to modify the packets, you can just send the raw packets. One thing you do have to do is handle that the Entity Is are different, this is where one of the differences between Velocity and BungeeCord comes into play, Bungeecord rewrites all the Entity IDs and Velocity respawns you twice to reset your Entity ID.

imported>U9G at 20:52, 20 August 2021

2021-08-20T20:52:22Z

← Older revision		Revision as of 20:52, 20 August 2021
Line 1:		Line 1:
	~~= Proxies =~~		= How does a proxy work? =

	== How does a proxy work? ==

	Proxies will often stand in the middle of a client and server, and can be used for many reasons, such as bridging two unsupported client versions so they understand each other, or to simply allow one client to connect to many other servers without knowing all of their IPs.		Proxies will often stand in the middle of a client and server, and can be used for many reasons, such as bridging two unsupported client versions so they understand each other, or to simply allow one client to connect to many other servers without knowing all of their IPs.

	== How do the popular ones work? ==		= How do the popular ones work? =

	Currently, the most popular proxy implementations of proxies are [https://github.com/VelocityPowered/Velocity Velocity] and [https://github.com/SpigotMC/BungeeCord Bungee]. They work by having the the proxy start the server that is public facing, then having the proxy make the connections to the play server itself and relay the packets, in this way the proxy can change packets before they hit either the actual server or the player’s client. In a simple sense, this is what the code looks like very-oversimplified:		Currently, the most popular proxy implementations of proxies are [https://github.com/VelocityPowered/Velocity Velocity] and [https://github.com/SpigotMC/BungeeCord Bungee]. They work by having the the proxy start the server that is public facing, then having the proxy make the connections to the play server itself and relay the packets, in this way the proxy can change packets before they hit either the actual server or the player’s client. In a simple sense, this is what the code looks like very-oversimplified:

imported>U9G: Created page with "= Proxies = == How does a proxy work? == Proxies will often stand in the middle of a client and server, and can be used for many reasons, such as bridging two unsupported cl..."

2021-08-20T20:51:08Z

Created page with "= Proxies = == How does a proxy work? == Proxies will often stand in the middle of a client and server, and can be used for many reasons, such as bridging two unsupported cl..."

New page

= Proxies =

== How does a proxy work? ==

Proxies will often stand in the middle of a client and server, and can be used for many reasons, such as bridging two unsupported client versions so they understand each other, or to simply allow one client to connect to many other servers without knowing all of their IPs.

== How do the popular ones work? ==

Currently, the most popular proxy implementations of proxies are [https://github.com/VelocityPowered/Velocity Velocity] and [https://github.com/SpigotMC/BungeeCord Bungee]. They work by having the the proxy start the server that is public facing, then having the proxy make the connections to the play server itself and relay the packets, in this way the proxy can change packets before they hit either the actual server or the player’s client. In a simple sense, this is what the code looks like very-oversimplified:

<syntaxhighlight lang="js">server = new Server(/* this will be the player facing server */)

server.on('connect', client => { // when a client connects to the player facing server
serverClient = new Client(/* this will connect to the actual server */) // we make a new client that connects to our internal server
client.on('packet', packet => serverClient.send(modifyC2S(packet))) // when our player facing server receives a packet, we relay that packet to the server after modifying the packet
serverClient.on('packet', packet => server.send(modifyS2C(packet))) // when our internal server wants to send a packet to the client, we relay that packet to the client after modifying it
})</syntaxhighlight>
Although shown in the example, you don’t necessarily have to modify the packets, you can just send the raw packets.