private void SendJoinGame(IMinecraftUser user)
{
using var joinPacket = new JoinGamePacket();
joinPacket.WriteInt32(user.Player.EntityId); // EntityID
joinPacket.WriteBoolean(_gameConfiguration.Value.IsHardcore); // Is hardcore
joinPacket.WriteByte((byte)_gameConfiguration.Value.Mode); // GameMode
joinPacket.WriteSByte((sbyte)ServerGameModeType.Survival); // Previous game mode
var worldList = new[] { "minecraft:world" };
joinPacket.WriteVarInt32(worldList.Length); // World count
foreach (string world in worldList)
{
joinPacket.WriteString(world);
}
WriteDimensionsAndBiomes(_registry.Dimensions, _registry.Biomes, joinPacket);
Dimension currentDimension = _registry.Dimensions.First();
WriteDimension(currentDimension, joinPacket);
joinPacket.WriteString(currentDimension.Name); // World name identifier
joinPacket.WriteInt64(_gameConfiguration.Value.Seed); // Seed
joinPacket.WriteVarInt32((int)_serverConfiguration.Value.MaxPlayers); // Max players
joinPacket.WriteVarInt32(Math.Clamp(_gameConfiguration.Value.RenderingDistance, RedstoneContants.MinimumRenderDistance, RedstoneContants.MaximumRenderDistance)); // Render distance (2-32 chunks)
joinPacket.WriteBoolean(_serverConfiguration.Value.ReducedDebugInfo); // Reduced debug info
joinPacket.WriteBoolean(_gameConfiguration.Value.DisplayRespawnScreen); // Respawn screen
joinPacket.WriteBoolean(_serverConfiguration.Value.Debug); // Is debug
joinPacket.WriteBoolean(_serverConfiguration.Value.FlatTerrain); // is flat terrain
user.Send(joinPacket);
}
public void OnJoinGame(JoinGamePacket packet)
{
if (loggedIn && (game == null || !game.active))
{
if (legend.HasGame(loggedInUser))
{
legend.StopGame(loggedInUser);
}
game = new ClientGame(this, loggedInUser, loggedInUsername, legend.config, legend);
legend.AddGame(loggedInUser, game);
}
}
private void SendJoinGame()
{
JoinGamePacket joinGame = new JoinGamePacket
{
EntityId = EntityId,
Gamemode = (byte)Gamemode,
Difficulty = 0,
Dimension = 0,
LevelType = "flat",
ReducedDebugInfo = false
};
Connection.SendPacket(joinGame);
}
private void LaunchGame_Click(object sender, EventArgs e)
{
string host = null;
if (UserList.SelectedItem != null)
{
host = UserList.SelectedItem.ToString();
}
JoinGamePacket joinGame = new JoinGamePacket(host)
{
_packetSrc = _client._nick
};
_client.Send(joinGame);
}
private ProtobufPacket GetFMLFakeLoginPacket()
{
var input = Encoding.UTF8.GetBytes("FML");
var murmur3 = new MurmurHash3_32();
var FML_HASH = BitConverter.ToInt32(murmur3.ComputeHash(input), 0);
// Always reset compat to zero before sending our fake packet
JoinGamePacket fake = new JoinGamePacket();
// Hash FML using a simple function
fake.EntityID = FML_HASH;
// The FML protocol version
fake.Dimension = 2;
fake.GameMode = 0;
fake.LevelType = "DunnoLol";
return(fake);
}
public async Task HandleAsync(TcpClient sender)
{
_stream = sender.GetStream();
_sender = sender;
_stream.ReadVarInt(); // packet length
var packetId = (byte)_stream.ReadByte();
if (packetId != 0x00)
{
if (packetId == 0xFE)
{
_logger.LogError("Received 0xFE Legacy Ping packet, the server must have sent the client incorrect data. Skipping.");
}
else
{
_logger.LogError($"Received unknown packet with ID 0x{packetId:x2}. Skipping.");
}
Dispose();
return;
}
var protocolVersion = _stream.ReadVarInt();
var serverAddress = _stream.ReadString();
var serverPort = _stream.Read <ushort>();
var isRequestingStatus = _stream.ReadVarInt() == 1;
_logger.LogDebug($"[Handshaking] New client connecting with protocol version {protocolVersion}, " +
$"using server address {serverAddress}:{serverPort}, " +
$"and {(isRequestingStatus ? "is requesting status information" : "is requesting to login")}.");
_stream.ReadVarInt();
_stream.ReadByte();
if (isRequestingStatus)
{
_logger.LogDebug("[Status] Received status request.");
var serverListPingResponsePacket = new ServerListPingResponsePacket(LibrisMinecraftServer.ServerVersion,
LibrisMinecraftServer.ProtocolVersion, 0, _server.MaximumPlayers, new List <PlayerListSampleEntry> {
new PlayerListSampleEntry("best_jessica", "abdc8af6-70ab-4930-ab47-c6fc4e618155")
},
_server.Description, _server.Favicon?.GetMinecraftFaviconString());
serverListPingResponsePacket.WriteToStream(_stream);
try
{
var latencyPacketLength = _stream.ReadVarInt();
var latencyPacketId = _stream.ReadByte();
if (latencyPacketId != InboundPackets.ServerListLatencyPingPacketId)
{
_logger.LogInformation($"[Status] Closing socket. Client did not request latency detection.");
Dispose();
return;
}
var payload = _stream.Read <long>();
_writer.WritePacket(new ServerListPingPongPacket(payload));
_logger.LogDebug($"[Status] Closing socket.");
Dispose();
}
catch (EndOfStreamException)
{
_logger.LogDebug($"[Status] Closing socket. Client did not request latency detection - received End of Stream. Perhaps the response data was corrupt?");
Dispose();
}
}
else
{
var username = _stream.ReadString();
_logger.LogDebug("[Login] Login request initiated from user " + username);
// <Do authorization logic here>
// Login succeeded
new LoginSuccessPacket("abdc8af6-70ab-4930-ab47-c6fc4e618155", "best_jessica").WriteToStream(_stream);
// Instruct client to join game
var joinGamePacket = new JoinGamePacket(0, PlayerGamemode.Survival, Dimension.Overworld, WorldType.Default, 10);
_writer.WritePacket(joinGamePacket);
// Receive settings from client
_stream.ReadVarInt();
var clientSettingsId = _stream.ReadByte();
if (clientSettingsId != InboundPackets.ClientSettingsPacketId)
{
_logger.LogError($"[Login] Expected byte {InboundPackets.ClientSettingsPacketId} Client Settings, received 0x{clientSettingsId:x2} instead. Closing socket.");
Dispose();
return;
}
var locale = _stream.ReadString();
var viewDistance = _stream.Read <sbyte>();
var chatMode = _stream.ReadVarInt();
var chatColors = _stream.Read <bool>();
var displayedSkinPartBitMask = _stream.ReadByte();
var mainHand = _stream.ReadVarInt();
_logger.LogDebug("[Login] User " + username + " registered client settings with locale " + locale + ", view distance " + Convert.ToInt32(viewDistance) + ", and main hand " + mainHand);
// AT SOME POINT, CHUNK SOME DATA HERE
// Inform client of global spawn
var spawnPositionPacket = new SpawnPositionPacket(25, 50, 2);
_writer.WritePacket(spawnPositionPacket);
// Send client the data of player
double playerX = 1.0;
double playerY = 1.0;
double playerZ = 1.0;
float yaw = 1.0f;
float pitch = 1.0f;
byte flags = 0x00;
int teleportId = 5;
var ppalPacket = new PlayerPositionAndLookPacket(playerX, playerY, playerZ, yaw, pitch, flags, teleportId);
_writer.WritePacket(ppalPacket);
}
}
void TcpClientMethod(int index)
{
Console.WriteLine("Socket opened. (" + _tcpListener.ToString() + ")");
Packet receivedPacket;
Client client = _clients[index];
try {
while ((receivedPacket = client.TcpRead()) != null)
{
Console.Write("TCP Receieved: ");
// act on packet type
switch (receivedPacket._packetType)
{
case Packet.PacketType.EMPTY:
Console.WriteLine("EMPTY");
/* do nothing */
break;
case Packet.PacketType.CHATMESSAGE:
Console.WriteLine("CHAT");
TcpRespondToAll((ChatMessagePacket)receivedPacket, client);
break;
case Packet.PacketType.PRIVATEMESSAGE:
Console.WriteLine("PRIVATE");
TcpRespondTo((PrivateMessagePacket)receivedPacket, client);
break;
case Packet.PacketType.SERVERMESSAGE:
Console.WriteLine("SERVER");
ServerMessagePacket servPacket = (ServerMessagePacket)receivedPacket;
servPacket._messageRecv = GetReturnMessage(servPacket._messageSent);
client.TcpSend(servPacket);
break;
case Packet.PacketType.CLIENTNAME:
Console.WriteLine("NAME");
ClientNamePacket namePacket = (ClientNamePacket)receivedPacket;
// create message
namePacket._message = client._name + " changed name to " + namePacket._name;
// change name
client._name = namePacket._name;
// update client
client.TcpSend(namePacket);
// notify all clients
TcpRespondToAll(new ChatMessagePacket(namePacket._message), client);
break;
case Packet.PacketType.LOGIN:
Console.WriteLine("LOGIN");
LoginPacket loginPacket = (LoginPacket)receivedPacket;
client._endPoint = loginPacket._endPoint;
loginPacket._serverKey = client.UpdateRSA(loginPacket);
client.TcpSend(loginPacket);
break;
case Packet.PacketType.SECUREMESSAGE:
Console.WriteLine("SECURE");
// receive packet
SecurePacket safePacket = (SecurePacket)receivedPacket;
// transmit packet
TcpSecureRespondToAll(
client.GetSecureMessage(safePacket),
safePacket._packetSrc
);
break;
case Packet.PacketType.ERROR:
//should be for other things, in another place
Console.WriteLine("ERROR");
ErrorMessagePacket errPacket = (ErrorMessagePacket)receivedPacket;
client.TcpSend(errPacket);
break;
case Packet.PacketType.ENDSESSION:
Console.Write("ENDING TCP SESSION: " + client._name);
// signal to client to close connections
// and end while loop
client.Close();
break;
case Packet.PacketType.JOINGAME:
Console.Write("JOIN GAME - ");
JoinGamePacket joinGame = (JoinGamePacket)receivedPacket;
Client host = null;
foreach (Client user in _clients.Values)
{
if (user._name == joinGame._targetHost)
{
host = user;
}
}
//ChatMessagePacket resultPacket = null;
if (GameSession.Instance.JoinSession(ref client, host))
{
Console.WriteLine("JOINED A GAME");
//success - msg client
PrivateMessagePacket resultPacket =
new PrivateMessagePacket(client._name, "Started Game Session")
{
_packetSrc = _serverName
};
TcpRespondTo(resultPacket, client);
//launch client's game
client.TcpSend(joinGame);
}
else
{
Console.WriteLine("FAILED TO JOIN A GAME");
//failed - msg client
};
break;
case Packet.PacketType.USERLIST:
Console.WriteLine("USERLIST");
UserListPacket userList = (UserListPacket)receivedPacket;
if (userList._users == null)
{
List <string> usernames = new List <string>();
// collect user names
foreach (KeyValuePair <int, Client> c in _clients)
{
usernames.Add(c.Value._name);
}
userList._users = usernames.ToArray();
TcpSendToAll(userList);
}
// if list is filled, why is it here?!
break;
case Packet.PacketType.LEAVEGAME:
LeaveGamePacket leaveGame = (LeaveGamePacket)receivedPacket;
// check game sessions
bool wasHost = GameSession.Instance.IsHosting(client);
// update game session
List <string> players = GameSession.Instance.LeaveSession(ref client);
ServerMessagePacket serverMessage = null;
if (!leaveGame._wasForced)
{
serverMessage = new ServerMessagePacket
(client._name + " has left the game.", null);
}
else
{
serverMessage = new ServerMessagePacket
("GAME ERROR: " + client._name + " was forced to leave the game.", null);
}
foreach (Client user in _clients.Values)
{
if (players.Contains(user._name))
{
user.TcpSend(serverMessage);
}
}
if (wasHost)
{
leaveGame._wasForced = true;
foreach (Client user in _clients.Values)
{
user.TcpSend(leaveGame);
}
}
break;
default:
break;
}
}
} catch (Exception e) {
Console.WriteLine("Error: " + e.Message);
if (client != null)
{
Console.WriteLine("Client: " + client._name);
}
}
client.Close();
_clients.TryRemove(index, out client);
}
private static async Task LoginStart(Client client, byte[] data)
{
String username = Utils.ReadString(new MemoryStream(data), 16);
Console.WriteLine("Client attempting to authenticate as " + username);
Guid guid = new Guid();
LoginSuccessPacket loginSuccessPacket = new LoginSuccessPacket(client, guid, username);
await loginSuccessPacket.SendToClient();
client.State = ClientState.Play;
client.Player = new Player(client, username, guid);
JoinGamePacket joinGamePacket = new JoinGamePacket(client, client.Player.EntityId, (byte)client.Player.Gamemode, 0, 0x0000000000000000);
await joinGamePacket.SendToClient();
Console.WriteLine("Client authenticated as " + username);
HeldItemChangePacket heldItemChangePacket = new HeldItemChangePacket(client, 0);
await heldItemChangePacket.SendToClient();
client.Player.Y = 68;
PlayerPositionLookPacket playerPositionLookPacket = new PlayerPositionLookPacket(client, client.Player);
await playerPositionLookPacket.SendToClient();
PlayerInfoPacket playerInfoPacket = new PlayerInfoPacket(client, PlayerInfoAction.AddPlayer);
playerInfoPacket.AddPlayer(client.Player);
await playerInfoPacket.SendToClient();
playerInfoPacket = new PlayerInfoPacket(client, PlayerInfoAction.UpdateLatency);
playerInfoPacket.AddPlayer(client.Player);
await playerInfoPacket.SendToClient();
Region region = new Region(0, 0);
ChunkColumn column = new ChunkColumn(0, 0);
column.FillTest();
ChunkDataPacket chunkDataPacket = new ChunkDataPacket(client, column);
await chunkDataPacket.SendToClient();
column = new ChunkColumn(1, 0);
column.FillTest();
chunkDataPacket = new ChunkDataPacket(client, column);
await chunkDataPacket.SendToClient();
column = new ChunkColumn(1, 1);
column.FillTest();
chunkDataPacket = new ChunkDataPacket(client, column);
await chunkDataPacket.SendToClient();
column = new ChunkColumn(0, 1);
column.FillTest();
chunkDataPacket = new ChunkDataPacket(client, column);
await chunkDataPacket.SendToClient();
column = new ChunkColumn(-1, 1);
column.FillTest();
chunkDataPacket = new ChunkDataPacket(client, column);
await chunkDataPacket.SendToClient();
column = new ChunkColumn(-1, -1);
column.FillTest();
chunkDataPacket = new ChunkDataPacket(client, column);
await chunkDataPacket.SendToClient();
column = new ChunkColumn(1, -1);
column.FillTest();
chunkDataPacket = new ChunkDataPacket(client, column);
await chunkDataPacket.SendToClient();
column = new ChunkColumn(0, -1);
column.FillTest();
chunkDataPacket = new ChunkDataPacket(client, column);
await chunkDataPacket.SendToClient();
column = new ChunkColumn(-1, -0);
column.FillTest();
chunkDataPacket = new ChunkDataPacket(client, column);
await chunkDataPacket.SendToClient();
Console.WriteLine("Sent");
}
/// <summary>
/// Signals the game manager to connect to a server
/// </summary>
public IEnumerator ConnectToServerCoroutine(string hostname, int port)
{
// open loading screen
AsyncOperation loadLoadingScreenTask = SceneManager.LoadSceneAsync("LoadingScreen", LoadSceneMode.Additive);
while (!loadLoadingScreenTask.isDone)
{
yield return(null);
}
Debug.Log("Loading screen opened");
SceneManager.SetActiveScene(SceneManager.GetSceneByName("LoadingScreen"));
SceneManager.MoveGameObjectToScene(gameObject, SceneManager.GetSceneByName("LoadingScreen"));
AsyncOperation unloadMainMenuTask = SceneManager.UnloadSceneAsync("MainMenu");
while (!unloadMainMenuTask.isDone)
{
yield return(null);
}
Debug.Log("Closed main menu");
// find loading screen controller
_loadingScreen = GameObject.FindGameObjectWithTag("Loading Screen Controller").GetComponent <LoadingScreenController>();
_loadingScreen.UpdateSubtitleText($"Attempting to connect to {hostname}:{port}");
// set up network client
_disconnecting = false;
_client = new NetworkClient();
_client.Disconnected += ClientDisconnectedEventHandler;
Task connectTask = new Task(() =>
{
_client.Connect(hostname, port);
});
connectTask.Start();
while (!connectTask.IsCompleted)
{
yield return(null);
}
if (connectTask.IsFaulted || !_client.Connected)
{
throw (Exception)connectTask.Exception ?? new UnityException("Connection failed: Unknown");
}
_loadingScreen.UpdateSubtitleText("Connection established. Logging in...");
// perform handshake/login
LoginSuccessPacket loginSuccess = null;
JoinGamePacket joinGame = null;
// TODO: put the rest of the login packets here
// player abilities, item slot change, etc.
// send off packets
_client.WritePackets(new Packet[] {
new HandshakePacket()
{
Address = hostname,
Port = port,
NextState = NetworkClient.ProtocolState.LOGIN
},
new LoginStartPacket()
{
Username = Username
}
});
_client.State = NetworkClient.ProtocolState.LOGIN;
// get login response
while (true)
{
try
{
var packet = _client.ReadNextPacket();
switch ((ClientboundIDs)packet.ID)
{
case ClientboundIDs.LOGIN_SUCCESS:
loginSuccess = new LoginSuccessPacket(packet);
break;
case ClientboundIDs.JOIN_GAME:
joinGame = new JoinGamePacket(packet);
break;
case ClientboundIDs.LOGIN_DISCONNECT:
Disconnect($"Disconnected from server: {new DisconnectPacket(packet).JSONResponse}");
yield break;
}
}
catch (Exception e)
{
Disconnect($"Failed to login: {e.Message}");
yield break;
}
if (loginSuccess != null && joinGame != null)
{
_client.State = NetworkClient.ProtocolState.PLAY;
break;
}
}
_loadingScreen.UpdateSubtitleText("Downloading world...");
// set settings from server
_playerUuid = loginSuccess.UUID;
_currentWorld = new World(DebugCanvas)
{
Dimension = joinGame.Dimension,
};
// open game scene
AsyncOperation loadGameTask = SceneManager.LoadSceneAsync("Game", LoadSceneMode.Additive);
while (!loadGameTask.isDone)
{
yield return(null);
}
SceneManager.SetActiveScene(SceneManager.GetSceneByName("Game"));
SceneManager.MoveGameObjectToScene(gameObject, SceneManager.GetSceneByName("Game"));
// set up references in game scene
_currentWorld.ChunkRenderer = Instantiate(ChunkRendererPrefab, Vector3.zero, Quaternion.identity).GetComponent <ChunkRenderer>();
_currentWorld.ChunkRenderer.DebugCanvas = DebugCanvas;
// start network worker tasks
_netReadTask = new Task(() =>
{
NetworkReadWorker(_cancellationTokenSource.Token);
}, _cancellationTokenSource.Token);
_netReadTask.Start();
_netWriteTask = new Task(() =>
{
NetworkWriteWorker(_cancellationTokenSource.Token);
}, _cancellationTokenSource.Token);
_netWriteTask.Start();
_initialized = true;
// start tick loop
StartCoroutine(ClientTickLoopCoroutine(_cancellationTokenSource.Token));
}
//JoinGamePacket
private static void HandlePacket(JoinGamePacket packet)
{
Globals.LoginForm.TryRemembering();
Globals.LoginForm.HideSafe();
}
//JoinGamePacket
private static void HandlePacket(JoinGamePacket packet)
{
Main.JoinGame();
Globals.JoiningGame = true;
}
public void getPackets()
{
//GD.Print("Get Packets");
//GD.Print(wrapped_client.GetAvailablePacketCount());
if (connected && client.GetAvailableBytes() > 0)
{
//byte[] packet_data = wrapped_client.GetPacket();
//UInt32 packetLength = BitConverter.ToUInt32(packet_data, 0);
//short packetId = BitConverter.ToInt16(packet_data, 4);
UInt32 packetLength = (UInt32)client.GetU32();
short packetId = (short)client.Get16();
var packetData = client.GetData((int)packetLength - 2);
//var data = new List<byte>(packet_data).GetRange(6, packet_data.Length -6).ToArray();
//GD.Print(BitConverter.ToString( (byte[]) packetData[1]));
var data = (byte[])packetData[1];
var packet = Packets.Packets.decode(packetId, data);
if (GetParent().GetNodeOrNull("GUI") != null)
{
var gui = (Control)GetParent().GetNodeOrNull("GUI");
gui.Call("recordPacket", packetLength + 4);
}
GD.Print(String.Format("Received packet {0}, ID: {1} Length: {2}", packet.name, packetId, packetLength));
if (packet is ReadyPacket)
{
ReadyPacket parsed_packet = (ReadyPacket)packet;
if (parsed_packet.code == 0)
{
string token = (string)GetParent().GetNode("Discord Integration").Call("getToken");
var loginPacket = new LoginPacket(token);
GD.Print("Sending login");
sendPacket(loginPacket);
}
else if (parsed_packet.code == 1)
{
var requestWorldPacket = new RequestWorldPacket();
sendPacket(requestWorldPacket);
if (!joined)
{
var loadingRes = GD.Load <PackedScene>("res://scenes/world.tscn");
var node = loadingRes.Instance();
node.SetName("WorldScene");
var loadingGuiRes = GD.Load <PackedScene>("res://scenes/gui.tscn");
var gui = (Control)loadingGuiRes.Instance();
gui.SetName("GUI");
GetParent().Call("setState", 2);
GetParent().AddChild(node);
//GetParent().AddChild(gui);
GetParent().AddChild(gui);
//node.AddChild(gui);
GetParent().GetNode("GameLoader").Free();
//var playerSpriteScene = (PackedScene) node.Call("getSprite", "rowan");
//var playerSprite = (AnimatedSprite) playerSpriteScene.Instance();
//playerSprite.SetName("PlayerSprite");
//node.GetNode("World/Player").AddChild(playerSprite);
//playerSprite.Position = ((KinematicBody2D) node.GetNode("Player")).Position;
//playerSprite.Visible = true;
//GD.Print(playerSprite);
joined = true;
}
}
}
else if (packet is PongPacket)
{
PongPacket parsed_packet = (PongPacket)packet;
GD.Print("Got pong of " + parsed_packet.message);
}
else if (packet is LoginResultPacket)
{
LoginResultPacket parsed_packet = (LoginResultPacket)packet;
GD.Print("Login Result: " + parsed_packet.responseCode.ToString() + " Name: " + parsed_packet.userId);
var joinGamePacket = new JoinGamePacket();
sendPacket(joinGamePacket);
}
else if (packet is WorldPacket)
{
WorldPacket parsed_packet = (WorldPacket)packet;
//GD.Print(parsed_packet.debug);
GetParent().GetNode("WorldScene").Call("loadWorld", new object[] { parsed_packet.worldData, parsed_packet.bumpData, parsed_packet.height, parsed_packet.width });
}
else if (packet is PlayerPositionPacket)
{
PlayerPositionPacket parsed_packet = (PlayerPositionPacket)packet;
GetParent().GetNode("WorldScene/World/Player").Call("move", new object[] { parsed_packet.x, parsed_packet.y });
}
else if (packet is ChatPacket)
{
ChatPacket parsed_packet = (ChatPacket)packet;
GetNode("../GUI/Chat").Call("AddMessage", parsed_packet.author + ": " + parsed_packet.msg);
}
else if (packet is EntityPacket)
{
EntityPacket parsed_packet = (EntityPacket)packet;
GD.Print("Got entity '", parsed_packet.sprite, "' at ", parsed_packet.x, ",", parsed_packet.y, " ID: ", parsed_packet.uuid);
GetNode("../WorldScene").Call("addEntity", parsed_packet.x, parsed_packet.y, parsed_packet.type, parsed_packet.facing, parsed_packet.interactable, parsed_packet.sprite, parsed_packet.uuid, parsed_packet.type != 2);
}
else if (packet is EntityMovePacket)
{
EntityMovePacket parsed_packet = (EntityMovePacket)packet;
GD.Print("Got entity moving to ", parsed_packet.x, ",", parsed_packet.y, " ID: ", parsed_packet.uuid);
GetNode("../WorldScene").Call("moveEntity", parsed_packet.uuid, parsed_packet.x, parsed_packet.y, parsed_packet.facing);
}
else if (packet is InvalidateCachePacket)
{
InvalidateCachePacket parsed_packet = (InvalidateCachePacket)packet;
GD.Print(parsed_packet.uuid, " Invalidated.");
GetNode("../WorldScene").Call("hideEntity", parsed_packet.uuid);
}
else if (packet is DialoguePacket)
{
DialoguePacket parsed_packet = (DialoguePacket)packet;
GD.Print("Got dialogue \"", parsed_packet.text, "\"");
Window window = (Window)GetNode("../GUI/Window");
window.OpenDialoguePanel();
DialoguePanel dialoguePanel = window.OpenDialoguePanel(); //(DialoguePanel) GetNode("../GUI/Window/DialoguePanel");
dialoguePanel.SetDialogue(parsed_packet.text, parsed_packet.author, parsed_packet.sprite, parsed_packet.substitutions, parsed_packet.optionViews);
}
else if (packet is CloseDialoguePacket)
{
CloseDialoguePacket parsed_packet = (CloseDialoguePacket)packet;
DialoguePanel dialoguePanel = (DialoguePanel)GetNode("../GUI/Window/DialoguePanel");
dialoguePanel.CloseDialogue(parsed_packet.guid);
//dialoguePanel.SetDialogue(parsed_packet.text, parsed_packet.author, parsed_packet.sprite, parsed_packet.substitutions, parsed_packet.optionViews);
}
else if (packet is PlayerDataPacket)
{
PlayerDataPacket parsed_packet = (PlayerDataPacket)packet;
var player = (Player)GetNode("../WorldScene/World/Player");
player.SetUuid(parsed_packet.guid);
if (player.GetNodeOrNull("PlayerSprite") != null)
{
player.GetNodeOrNull("PlayerSprite").Free();
}
var playerSpriteScene = (PackedScene)GetNode("../WorldScene").Call("getSprite", parsed_packet.sprite);
var playerSprite = (AnimatedSprite)playerSpriteScene.Instance();
playerSprite.SetName("PlayerSprite");
player.AddChild(playerSprite);
}
else if (packet is InventoryPacket)
{
InventoryPacket parsed_packet = (InventoryPacket)packet;
var player = (Player)GetNode("../WorldScene/World/Player");
if (player.guid == parsed_packet.inventory.guid)
{
player.inventory = parsed_packet.inventory;
foreach (Item item in player.inventory.items)
{
GD.Print("Item: ", item.GetName(), " \"", item.GetDescription(), "\"");
}
}
}
else if (packet is AddItemPacket)
{
AddItemPacket parsed_packet = (AddItemPacket)packet;
var player = (Player)GetNode("../WorldScene/World/Player");
if (player.guid == parsed_packet.guid)
{
//TODO: Make use of indices.
player.inventory.AddItem(parsed_packet.item, true);
}
}
else if (packet is ModifyItemPacket)
{
ModifyItemPacket parsed_packet = (ModifyItemPacket)packet;
var player = (Player)GetNode("../WorldScene/World/Player");
if (player.guid == parsed_packet.guid)
{
//TODO: Make use of indices.
player.inventory.UpdateItem(parsed_packet.item, parsed_packet.index);
}
}
}
else
{
var testPacket = new Packets.PingPacket("Hello There!");
//sendPacket(testPacket);
}
}
