public override void Callback(int peerId, AbstractNetworkMessage abstractNetworkMessage)
{
ChatMessage receivedChatMessage = abstractNetworkMessage as ChatMessage;
if (Tree.IsNetworkServer())
{
//ServerSide
//TODO -> Check Message for command/ create command lexer
//Add the sending peer as Sender on the server side, the client does not know about itself
receivedChatMessage.Sender = Server.ConnectedClients[peerId];
foreach (var entry in Server.ConnectedClients)
{
//Send ChatMessage to every peer, even the sender himself
//Messages are only added by server message, not on sending on the client maschine
ObjectBroker.Instance.NetworkService.toClient(entry.Key, receivedChatMessage);
}
}
else
{
//ClientSide
if (ObjectBroker.Instance.SceneService.BaseUI.HasNode("ChatWindow"))
{
Label newMessage = new Label();
newMessage.Autowrap = true;
newMessage.Text = String.Format("[{0}]: {1}", receivedChatMessage.Sender.Name, receivedChatMessage.Message);
ScrollContainer chatMessageContainer = ObjectBroker.Instance.SceneService.BaseUI.GetNode <ScrollContainer>("ChatWindow/ScrollContainer");
chatMessageContainer.GetNode("./VBoxContainer").AddChild(newMessage);
//chatMessageContainer.SetVScroll(chatMessageContainer.GetScroll)
chatMessageContainer.ScrollVertical = (int)chatMessageContainer.GetVScrollbar().MaxValue;
}
}
}
//Called when received by server
public override void Callback(int peerId, AbstractNetworkMessage abstractNetworkMessage)
{
if (Tree.IsNetworkServer())
{
ClientSendAuthentication clientSendAuthentication = abstractNetworkMessage as ClientSendAuthentication;
//GD.Print(c);
Logger LOG = new Logger(this.GetType().Name);
LOG.Info(System.String.Format("Adding client {0} with name {1} to client list. Sending map data to client", peerId, clientSendAuthentication.SteamID64));
ClientRepresentation newClient = new ClientRepresentation(peerId, new Vector3(), new Vector3());
newClient.Name = clientSendAuthentication.SteamID64;
Server.AddClient(newClient);
ObjectBroker.Instance.NetworkService.toClient(peerId, new ServerInitialSync("DevWorld/DevWorld.scn"), TransferModeEnum.Reliable);
}
}
public override void Callback(int peerId, AbstractNetworkMessage abstractNetworkMessage)
{
ClientPeerConnectionUpdate clientPeerConnectionUpdate = abstractNetworkMessage as ClientPeerConnectionUpdate;
if (Tree.IsNetworkServer())
{
if (clientPeerConnectionUpdate.Disconnected)
{
ClientRepresentation disconnectedPeer = Server.ConnectedClients[peerId];
//disconnect actual peer
Server.ENetInstance.DisconnectPeer(peerId, true);
foreach (var peer in Server.ConnectedClients)
{
if (peer.Key != peerId)
{
ObjectBroker.Instance.NetworkService.toClient(peer.Key, new ClientPeerConnectionUpdate(disconnectedPeer, true));
}
}
}
}
else
{
if (!clientPeerConnectionUpdate.Disconnected)
{
if (Tree.Root.GetNode(SceneService.NODE_PATH_SCENE).HasNode(GD.Str(clientPeerConnectionUpdate.ClientRepresentation.Id)))
{
return;
}
PackedScene peerRepresentationResource = ResourceLoader.Load("res://assets/scenes/Character/Character.tscn") as PackedScene;
Godot.KinematicBody peerRepresentation = peerRepresentationResource.Instance() as Godot.KinematicBody;
peerRepresentation.Name = GD.Str(clientPeerConnectionUpdate.ClientRepresentation.Id);
peerRepresentation.SetNetworkMaster(clientPeerConnectionUpdate.ClientRepresentation.Id);
peerRepresentation.Translation = clientPeerConnectionUpdate.ClientRepresentation.Translation;
peerRepresentation.Rotation = clientPeerConnectionUpdate.ClientRepresentation.Rotation;
Node peerName = peerRepresentation.GetNode("Name");
((Label)peerName.GetNode("Viewport/Label")).Text = clientPeerConnectionUpdate.ClientRepresentation.Name;
Tree.Root.GetNode(SceneService.NODE_PATH_SCENE).AddChild(peerRepresentation);
}
else
{
Node peerNode = Tree.Root.GetNode(SceneService.NODE_PATH_SCENE).GetNode(GD.Str(clientPeerConnectionUpdate.ClientRepresentation.Id));
Tree.Root.GetNode(SceneService.NODE_PATH_SCENE).RemoveChild(peerNode);
peerNode.QueueFree();
}
}
}
public void SendToServer(AbstractNetworkMessage networkMessage, bool isResponse)
{
var message = networkMessage.ToNetworkMessage(Me.Id);
if (isResponse)
{
message.ResponseTo = RespondingTo;
}
Me.Send(message);
if (isResponse)
{
RespondingTo = null;
}
}
public override void Callback(int peerId, AbstractNetworkMessage abstractNetworkMessage)
{
if (Tree.IsNetworkServer())
{
if (Server.ConnectedClients[peerId].ClientState == ClientState.READY)
{
return;
}
Server.ConnectedClients[peerId].ClientState = ClientState.READY;
logger.Info("there are " + GD.Str(Server.ConnectedClients.Count) + " connected clients, the will all updated with " + GD.Str(peerId));
foreach (var peer in Server.ConnectedClients)
{
if (peer.Key != peerId)
{
ObjectBroker.Instance.NetworkService.toClient(peer.Key, new ClientPeerConnectionUpdate(Server.ConnectedClients[peerId]), TransferModeEnum.Reliable);
}
}
}
}
public override void Callback(int peerId, AbstractNetworkMessage abstractNetworkMessage)
{
if (!Tree.IsNetworkServer())
{
//Client side code
ServerInitialSync s = abstractNetworkMessage as ServerInitialSync;
Logger log = new Logger(this.GetType().Name);
log.Info("new ServerInitialSync package received from server");
FeudalMP.ObjectBroker.Instance.SceneService.LoadSceneDeferred("res://assets/scenes/" + s.MapFilePath);
FeudalMP.ObjectBroker.Instance.SceneService.AttachUI("ChatWindow/ChatWindow.tscn");
PackedScene charResource = ResourceLoader.Load("res://assets/scenes/Character/Character.tscn") as PackedScene;
Node charNode = charResource.Instance();
charNode.Name = GD.Str(Tree.GetNetworkUniqueId());
charNode.SetNetworkMaster(Tree.GetNetworkUniqueId());
Tree.Root.GetNode(SceneService.NODE_PATH_SCENE).AddChild(charNode);
ObjectBroker.Instance.NetworkService.toServer(new ServerConnetedClientsSync());
}
}
public override void Callback(int peerId, AbstractNetworkMessage abstractNetworkMessage)
{
ClientPositionUpdate clientPositionUpdate = abstractNetworkMessage as ClientPositionUpdate;
if (Tree.IsNetworkServer())
{
//Update ClientRepresentation on server
Server.ConnectedClients[peerId].Rotation = clientPositionUpdate.Rotation;
Server.ConnectedClients[peerId].Translation = clientPositionUpdate.Translation;
//send update to all connected clients
foreach (int peer in Server.ConnectedClients.Keys)
{
//do not send position update to the peer which has originally moved itself
//@TODO maybe change this later on for security/lokal hacking attempts
if (peer != peerId && Server.ConnectedClients[peerId].ClientState == ClientState.READY)
{
ClientPositionUpdate updateClients = new ClientPositionUpdate();
updateClients.ClientRepresentation = new ClientRepresentation(peerId, Server.ConnectedClients[peerId].Translation, Server.ConnectedClients[peerId].Rotation);
ObjectBroker.Instance.NetworkService.toClient(peer, updateClients);
}
}
}
else
{
Spatial targetPeer = Tree.Root.GetNode("/root/FeudalMP/Scene").GetNode(GD.Str(clientPositionUpdate.ClientRepresentation.Id)) as Spatial;
if (targetPeer != null)
{
targetPeer.Translation = clientPositionUpdate.ClientRepresentation.Translation;
targetPeer.Rotation = clientPositionUpdate.ClientRepresentation.Rotation;
}
else
{
LOG.Error("Trying to update non-existent targetPeer within scene");
}
}
}
public override void Callback(int peerId, AbstractNetworkMessage abstractNetworkMessage)
{
ServerConnetedClientsSync serverConnetedClientsSync = abstractNetworkMessage as ServerConnetedClientsSync;
if (Tree.IsNetworkServer())
{
serverConnetedClientsSync.ConnectedClients = new Dictionary <int, Vector3>();
foreach (var entry in Server.ConnectedClients)
{
if (entry.Key != peerId)
{
serverConnetedClientsSync.ConnectedClients.Add(entry.Key, entry.Value.Translation);
}
}
serverConnetedClientsSync.Action = NetworkMessageAction.SERVER_CONNECTED_CLIENTS_SYNC;
ObjectBroker.Instance.NetworkService.toClient(peerId, serverConnetedClientsSync, TransferModeEnum.Reliable);
}
else
{
foreach (var entry in serverConnetedClientsSync.ConnectedClients)
{
if (Tree.Root.GetNode(SceneService.NODE_PATH_SCENE).HasNode(GD.Str(entry.Key)))
{
LOG.Warn(System.String.Format("Node with name {0} is already present in the current client scene", entry.Key));
}
PackedScene peerRepresentationResource = ResourceLoader.Load("res://assets/scenes/Character/Character.tscn") as PackedScene;
Godot.KinematicBody peerRepresentation = peerRepresentationResource.Instance() as Godot.KinematicBody;
peerRepresentation.Name = GD.Str(entry.Key);
peerRepresentation.SetNetworkMaster(entry.Key);
peerRepresentation.Translation = entry.Value;
Tree.Root.GetNode(SceneService.NODE_PATH_SCENE).AddChild(peerRepresentation);
}
ObjectBroker.Instance.NetworkService.toServer(new ServerCompletedSync(), TransferModeEnum.Reliable);
}
}
public Error toClient(int targetPeerId, AbstractNetworkMessage message, TransferModeEnum transferMode = TransferModeEnum.Unreliable)
{
return(toClientRaw(targetPeerId, JsonConvert.SerializeObject(message).ToUTF8(), transferMode));
}
public Error toServer(AbstractNetworkMessage message, TransferModeEnum transferMode = TransferModeEnum.Unreliable)
{
return(toServerRaw(JsonConvert.SerializeObject(message).ToUTF8(), transferMode));
}
public override void Callback(int peerId, AbstractNetworkMessage abstractNetworkMessage)
{
throw new System.NotImplementedException();
}
public void RegisterCallback(NetworkMessageAction action, AbstractNetworkMessage callback)
{
CallbackRegister.Add(action, callback);
}
