using System; using System.Collections.Generic; using System.IO; using System.Linq; using Lidgren.Network; using Newtonsoft.Json; using Newtonsoft.Json.Linq; using StardewModdingAPI.Events; using StardewModdingAPI.Framework.Events; using StardewModdingAPI.Framework.Networking; using StardewModdingAPI.Framework.Reflection; using StardewModdingAPI.Toolkit.Serialisation; using StardewValley; using StardewValley.Network; namespace StardewModdingAPI.Framework { /// SMAPI's implementation of the game's core multiplayer logic. /// /// SMAPI syncs mod context to all players through the host as such: /// 1. Farmhand sends ModContext + PlayerIntro. /// 2. If host receives ModContext: it stores the context, replies with known contexts, and forwards it to other farmhands. /// 3. If host receives PlayerIntro before ModContext: it stores a 'vanilla player' context, and forwards it to other farmhands. /// 4. If farmhand receives ModContext: it stores it. /// 5. If farmhand receives ServerIntro without a preceding ModContext: it stores a 'vanilla host' context. /// 6. If farmhand receives PlayerIntro without a preceding ModContext AND it's not the host peer: it stores a 'vanilla player' context. /// /// Once a farmhand/server stored a context, messages can be sent to that player through the SMAPI APIs. /// internal class SMultiplayer : Multiplayer { /********* ** Properties *********/ /// Encapsulates monitoring and logging. private readonly IMonitor Monitor; /// Tracks the installed mods. private readonly ModRegistry ModRegistry; /// Encapsulates SMAPI's JSON file parsing. private readonly JsonHelper JsonHelper; /// Simplifies access to private code. private readonly Reflector Reflection; /// Manages SMAPI events. private readonly EventManager EventManager; /// The players who are currently disconnecting. private readonly IList DisconnectingFarmers; /// A callback to invoke when a mod message is received. private readonly Action OnModMessageReceived; /********* ** Accessors *********/ /// The metadata for each connected peer. public IDictionary Peers { get; } = new Dictionary(); /// The metadata for the host player, if the current player is a farmhand. public MultiplayerPeer HostPeer; /********* ** Public methods *********/ /// Construct an instance. /// Encapsulates monitoring and logging. /// Manages SMAPI events. /// Encapsulates SMAPI's JSON file parsing. /// Tracks the installed mods. /// Simplifies access to private code. /// A callback to invoke when a mod message is received. public SMultiplayer(IMonitor monitor, EventManager eventManager, JsonHelper jsonHelper, ModRegistry modRegistry, Reflector reflection, Action onModMessageReceived) { this.Monitor = monitor; this.EventManager = eventManager; this.JsonHelper = jsonHelper; this.ModRegistry = modRegistry; this.Reflection = reflection; this.OnModMessageReceived = onModMessageReceived; this.DisconnectingFarmers = reflection.GetField>(this, "disconnectingFarmers").GetValue(); } /// Handle sync messages from other players and perform other initial sync logic. public override void UpdateEarly() { this.EventManager.Legacy_BeforeMainSync.Raise(); base.UpdateEarly(); this.EventManager.Legacy_AfterMainSync.Raise(); } /// Broadcast sync messages to other players and perform other final sync logic. public override void UpdateLate(bool forceSync = false) { this.EventManager.Legacy_BeforeMainBroadcast.Raise(); base.UpdateLate(forceSync); this.EventManager.Legacy_AfterMainBroadcast.Raise(); } /// Initialise a client before the game connects to a remote server. /// The client to initialise. public override Client InitClient(Client client) { if (client is LidgrenClient) { string address = this.Reflection.GetField(client, "address").GetValue(); return new SLidgrenClient(address, this.OnClientProcessingMessage, this.OnClientSendingMessage); } return client; } /// Initialise a server before the game connects to an incoming player. /// The server to initialise. public override Server InitServer(Server server) { if (server is LidgrenServer) { IGameServer gameServer = this.Reflection.GetField(server, "gameServer").GetValue(); return new SLidgrenServer(gameServer, this.Reflection, this.readFarmer, this.OnServerProcessingMessage, this.OnServerSendingMessage); } return server; } /// A callback raised when sending a network message as the host player. /// The server sending the message. /// The connection to which a message is being sent. /// The message being sent. /// Send the underlying message. protected void OnServerSendingMessage(SLidgrenServer server, NetConnection connection, OutgoingMessage message, Action resume) { if (this.Monitor.IsVerbose) this.Monitor.Log($"SERVER SEND {(MessageType)message.MessageType} {message.FarmerID}", LogLevel.Trace); resume(); } /// A callback raised when sending a message as a farmhand. /// The client sending the message. /// The message being sent. /// Send the underlying message. protected void OnClientSendingMessage(SLidgrenClient client, OutgoingMessage message, Action resume) { if (this.Monitor.IsVerbose) this.Monitor.Log($"CLIENT SEND {(MessageType)message.MessageType} {message.FarmerID}", LogLevel.Trace); switch (message.MessageType) { // sync mod context (step 1) case (byte)MessageType.PlayerIntroduction: client.sendMessage((byte)MessageType.ModContext, this.GetContextSyncMessageFields()); resume(); break; // run default logic default: resume(); break; } } /// Process an incoming network message as the host player. /// The server instance that received the connection. /// The raw network message that was received. /// The message to process. /// Process the message using the game's default logic. public void OnServerProcessingMessage(SLidgrenServer server, NetIncomingMessage rawMessage, IncomingMessage message, Action resume) { if (this.Monitor.IsVerbose) this.Monitor.Log($"SERVER RECV {(MessageType)message.MessageType} {message.FarmerID}", LogLevel.Trace); switch (message.MessageType) { // sync mod context (step 2) case (byte)MessageType.ModContext: { // parse message RemoteContextModel model = this.ReadContext(message.Reader); this.Monitor.Log($"Received context for farmhand {message.FarmerID} running {(model != null ? $"SMAPI {model.ApiVersion} with {model.Mods.Length} mods" : "vanilla")}.", LogLevel.Trace); // store peer MultiplayerPeer newPeer = MultiplayerPeer.ForConnectionToFarmhand(message.FarmerID, model, server, rawMessage.SenderConnection); if (this.Peers.ContainsKey(message.FarmerID)) { this.Monitor.Log($"Rejected mod context from farmhand {message.FarmerID}: already received context for that player.", LogLevel.Error); return; } this.AddPeer(newPeer, canBeHost: false, raiseEvent: false); // reply with own context this.Monitor.VerboseLog(" Replying with host context..."); newPeer.SendMessage(new OutgoingMessage((byte)MessageType.ModContext, Game1.player.UniqueMultiplayerID, this.GetContextSyncMessageFields())); // reply with other players' context foreach (MultiplayerPeer otherPeer in this.Peers.Values.Where(p => p.PlayerID != newPeer.PlayerID)) { this.Monitor.VerboseLog($" Replying with context for player {otherPeer.PlayerID}..."); newPeer.SendMessage(new OutgoingMessage((byte)MessageType.ModContext, otherPeer.PlayerID, this.GetContextSyncMessageFields(otherPeer))); } // forward to other peers if (this.Peers.Count > 1) { object[] fields = this.GetContextSyncMessageFields(newPeer); foreach (MultiplayerPeer otherPeer in this.Peers.Values.Where(p => p.PlayerID != newPeer.PlayerID)) { this.Monitor.VerboseLog($" Forwarding context to player {otherPeer.PlayerID}..."); otherPeer.SendMessage(new OutgoingMessage((byte)MessageType.ModContext, newPeer.PlayerID, fields)); } } // raise event this.EventManager.PeerContextReceived.Raise(new PeerContextReceivedEventArgs(newPeer)); } break; // handle player intro case (byte)MessageType.PlayerIntroduction: // store peer if new if (!this.Peers.ContainsKey(message.FarmerID)) { this.Monitor.Log($"Received connection for vanilla player {message.FarmerID}.", LogLevel.Trace); MultiplayerPeer peer = MultiplayerPeer.ForConnectionToFarmhand(message.FarmerID, null, server, rawMessage.SenderConnection); this.AddPeer(peer, canBeHost: false); } resume(); break; // handle mod message case (byte)MessageType.ModMessage: this.ReceiveModMessage(message); break; default: resume(); break; } } /// Process an incoming network message as a farmhand. /// The client instance that received the connection. /// The message to process. /// Process the message using the game's default logic. /// Returns whether the message was handled. public void OnClientProcessingMessage(SLidgrenClient client, IncomingMessage message, Action resume) { if (this.Monitor.IsVerbose) this.Monitor.Log($"CLIENT RECV {(MessageType)message.MessageType} {message.FarmerID}", LogLevel.Trace); switch (message.MessageType) { // mod context sync (step 4) case (byte)MessageType.ModContext: { // parse message RemoteContextModel model = this.ReadContext(message.Reader); this.Monitor.Log($"Received context for {(model?.IsHost == true ? "host" : "farmhand")} {message.FarmerID} running {(model != null ? $"SMAPI {model.ApiVersion} with {model.Mods.Length} mods" : "vanilla")}.", LogLevel.Trace); // store peer MultiplayerPeer peer = MultiplayerPeer.ForConnectionToHost(message.FarmerID, model, client, model?.IsHost ?? this.HostPeer == null); if (peer.IsHost && this.HostPeer != null) { this.Monitor.Log($"Rejected mod context from host player {peer.PlayerID}: already received host data from {(peer.PlayerID == this.HostPeer.PlayerID ? "that player" : $"player {peer.PlayerID}")}.", LogLevel.Error); return; } this.AddPeer(peer, canBeHost: true); } break; // handle server intro case (byte)MessageType.ServerIntroduction: { // store peer if (!this.Peers.ContainsKey(message.FarmerID) && this.HostPeer == null) { this.Monitor.Log($"Received connection for vanilla host {message.FarmerID}.", LogLevel.Trace); this.AddPeer(MultiplayerPeer.ForConnectionToHost(message.FarmerID, null, client, isHost: true), canBeHost: false); } resume(); break; } // handle player intro case (byte)MessageType.PlayerIntroduction: { // store peer if (!this.Peers.TryGetValue(message.FarmerID, out MultiplayerPeer peer)) { peer = MultiplayerPeer.ForConnectionToHost(message.FarmerID, null, client, isHost: this.HostPeer == null); this.Monitor.Log($"Received connection for vanilla {(peer.IsHost ? "host" : "farmhand")} {message.FarmerID}.", LogLevel.Trace); this.AddPeer(peer, canBeHost: true); } resume(); break; } // handle mod message case (byte)MessageType.ModMessage: this.ReceiveModMessage(message); break; default: resume(); break; } } /// Remove players who are disconnecting. protected override void removeDisconnectedFarmers() { foreach (long playerID in this.DisconnectingFarmers) { if (this.Peers.TryGetValue(playerID, out MultiplayerPeer peer)) { this.Monitor.Log($"Player quit: {playerID}", LogLevel.Trace); this.Peers.Remove(playerID); this.EventManager.PeerDisconnected.Raise(new PeerDisconnectedEventArgs(peer)); } } base.removeDisconnectedFarmers(); } /// Broadcast a mod message to matching players. /// The data to send over the network. /// A message type which receiving mods can use to decide whether it's the one they want to handle, like SetPlayerLocation. This doesn't need to be globally unique, since mods should check the originating mod ID. /// The unique ID of the mod sending the message. /// The mod IDs which should receive the message on the destination computers, or null for all mods. Specifying mod IDs is recommended to improve performance, unless it's a general-purpose broadcast. /// The values for the players who should receive the message, or null for all players. If you don't need to broadcast to all players, specifying player IDs is recommended to reduce latency. public void BroadcastModMessage(TMessage message, string messageType, string fromModID, string[] toModIDs, long[] toPlayerIDs) { // validate if (message == null) throw new ArgumentNullException(nameof(message)); if (string.IsNullOrWhiteSpace(messageType)) throw new ArgumentNullException(nameof(messageType)); if (string.IsNullOrWhiteSpace(fromModID)) throw new ArgumentNullException(nameof(fromModID)); if (!this.Peers.Any()) { this.Monitor.VerboseLog($"Ignored '{messageType}' broadcast from mod {fromModID}: not connected to any players."); return; } // filter player IDs HashSet playerIDs = null; if (toPlayerIDs != null && toPlayerIDs.Any()) { playerIDs = new HashSet(toPlayerIDs); playerIDs.RemoveWhere(id => !this.Peers.ContainsKey(id)); if (!playerIDs.Any()) { this.Monitor.VerboseLog($"Ignored '{messageType}' broadcast from mod {fromModID}: none of the specified player IDs are connected."); return; } } // get data to send ModMessageModel model = new ModMessageModel( fromPlayerID: Game1.player.UniqueMultiplayerID, fromModID: fromModID, toModIDs: toModIDs, toPlayerIDs: playerIDs?.ToArray(), type: messageType, data: JToken.FromObject(message) ); string data = JsonConvert.SerializeObject(model, Formatting.None); // log message if (this.Monitor.IsVerbose) this.Monitor.Log($"Broadcasting '{messageType}' message: {data}.", LogLevel.Trace); // send message if (Context.IsMainPlayer) { foreach (MultiplayerPeer peer in this.Peers.Values) { if (playerIDs == null || playerIDs.Contains(peer.PlayerID)) { model.ToPlayerIDs = new[] { peer.PlayerID }; peer.SendMessage(new OutgoingMessage((byte)MessageType.ModMessage, peer.PlayerID, data)); } } } else if (this.HostPeer != null && this.HostPeer.HasSmapi) this.HostPeer.SendMessage(new OutgoingMessage((byte)MessageType.ModMessage, this.HostPeer.PlayerID, data)); else this.Monitor.VerboseLog(" Can't send message because no valid connections were found."); } /********* ** Private methods *********/ /// Save a received peer. /// The peer to add. /// Whether to track the peer as the host if applicable. /// Whether to raise the event. private void AddPeer(MultiplayerPeer peer, bool canBeHost, bool raiseEvent = true) { // store this.Peers[peer.PlayerID] = peer; if (canBeHost && peer.IsHost) this.HostPeer = peer; // raise event if (raiseEvent) this.EventManager.PeerContextReceived.Raise(new PeerContextReceivedEventArgs(peer)); } /// Read the metadata context for a player. /// The stream reader. private RemoteContextModel ReadContext(BinaryReader reader) { string data = reader.ReadString(); RemoteContextModel model = this.JsonHelper.Deserialise(data); return model.ApiVersion != null ? model : null; // no data available for unmodded players } /// Receive a mod message sent from another player's mods. /// The raw message to parse. private void ReceiveModMessage(IncomingMessage message) { // parse message string json = message.Reader.ReadString(); ModMessageModel model = this.JsonHelper.Deserialise(json); HashSet playerIDs = new HashSet(model.ToPlayerIDs ?? this.GetKnownPlayerIDs()); if (this.Monitor.IsVerbose) this.Monitor.Log($"Received message: {json}."); // notify local mods if (playerIDs.Contains(Game1.player.UniqueMultiplayerID)) this.OnModMessageReceived(model); // forward to other players if (Context.IsMainPlayer && playerIDs.Any(p => p != Game1.player.UniqueMultiplayerID)) { ModMessageModel newModel = new ModMessageModel(model); foreach (long playerID in playerIDs) { if (playerID != Game1.player.UniqueMultiplayerID && playerID != model.FromPlayerID && this.Peers.TryGetValue(playerID, out MultiplayerPeer peer)) { newModel.ToPlayerIDs = new[] { peer.PlayerID }; this.Monitor.VerboseLog($" Forwarding message to player {peer.PlayerID}."); peer.SendMessage(new OutgoingMessage((byte)MessageType.ModMessage, peer.PlayerID, this.JsonHelper.Serialise(newModel, Formatting.None))); } } } } /// Get all connected player IDs, including the current player. private IEnumerable GetKnownPlayerIDs() { yield return Game1.player.UniqueMultiplayerID; foreach (long peerID in this.Peers.Keys) yield return peerID; } /// Get the fields to include in a context sync message sent to other players. private object[] GetContextSyncMessageFields() { RemoteContextModel model = new RemoteContextModel { IsHost = Context.IsWorldReady && Context.IsMainPlayer, Platform = Constants.TargetPlatform, ApiVersion = Constants.ApiVersion, GameVersion = Constants.GameVersion, Mods = this.ModRegistry .GetAll() .Select(mod => new RemoteContextModModel { ID = mod.Manifest.UniqueID, Name = mod.Manifest.Name, Version = mod.Manifest.Version }) .ToArray() }; return new object[] { this.JsonHelper.Serialise(model, Formatting.None) }; } /// Get the fields to include in a context sync message sent to other players. /// The peer whose data to represent. private object[] GetContextSyncMessageFields(IMultiplayerPeer peer) { if (!peer.HasSmapi) return new object[] { "{}" }; RemoteContextModel model = new RemoteContextModel { IsHost = peer.IsHost, Platform = peer.Platform.Value, ApiVersion = peer.ApiVersion, GameVersion = peer.GameVersion, Mods = peer.Mods .Select(mod => new RemoteContextModModel { ID = mod.ID, Name = mod.Name, Version = mod.Version }) .ToArray() }; return new object[] { this.JsonHelper.Serialise(model, Formatting.None) }; } } }