void MyMultiplayerLobby_ClientLeft(ulong userId, ChatMemberStateChangeEnum stateChange)
{
if (userId == ServerId)
{
Peer2Peer.CloseSession(userId);
}
MySandboxGame.Log.WriteLineAndConsole("Player left: " + GetMemberName(userId) + " (" + userId + ")");
MyTrace.Send(TraceWindow.Multiplayer, "Player left: " + stateChange.ToString());
}
void LogPlayers()
{
MyMwcLog.WriteLine("PLAYER LOG:");
foreach (var player in Peers.Players)
{
string message = String.Format("User: {0,4} - {1,15}, GameId: {2,3}, EP: {3}, {4}", player.UserId, player.GetDisplayName(), player.PlayerId, player.Connection.RemoteEndpoint, player.Faction);
MyTrace.Send(TraceWindow.MultiplayerAlerts, message);
MyMwcLog.WriteLine(message);
}
}
public override MyDownloadWorldResult DownloadWorld()
{
MyTrace.Send(TraceWindow.Multiplayer, "World request sent");
MyDownloadWorldResult ret = new MyDownloadWorldResult(MyMultiplayer.WorldDownloadChannel, Lobby.GetOwner(), this);
MyControlWorldRequestMsg msg = new MyControlWorldRequestMsg();
SendControlMessage(ServerId, ref msg);
return(ret);
}
public virtual void Dispose()
{
MyTrace.Send(TraceWindow.Multiplayer, "Multiplayer closed");
m_voxelMapData = null;
MyNetworkReader.ClearHandler(MyMultiplayer.ControlChannel);
SyncLayer.TransportLayer.Clear();
MyNetworkReader.Clear();
MyMultiplayer.Static = null;
}
void MyDownloadWorldResult_Received(byte[] data, int dataSize, ulong sender, TimeSpan timestamp)
{
ProfilerShort.Begin("DownloadWorldChunk");
Debug.Assert(State == MyDownloadWorldStateEnum.Established || State == MyDownloadWorldStateEnum.InProgress, "This should not be called, find why it's called");
if (m_sender == sender)
{
var status = m_receiveMsg.Compose(data, dataSize);
switch (status)
{
case MyMultipartMessage.Status.InProgress:
break;
case MyMultipartMessage.Status.Finished:
Deregister();
m_receiveMsg.Stream.Position = 0;
if (m_receiveMsg.Stream.Length > 0)
{
MyObjectBuilder_World worldData;
if (Sandbox.Common.ObjectBuilders.Serializer.MyObjectBuilderSerializer.DeserializeGZippedXML(m_receiveMsg.Stream, out worldData))
{
WorldData = worldData;
State = MyDownloadWorldStateEnum.Success;
MySandboxGame.Log.WriteLineAndConsole(String.Format("World download progress status: {0}, {1}", State.ToString(), this.Progress));
}
else
{
MySandboxGame.Log.WriteLine("Deserialization failed during world download.");
State = MyDownloadWorldStateEnum.DeserializationFailed;
}
}
else
{
State = MyDownloadWorldStateEnum.WorldNotAvailable;
}
break;
case MyMultipartMessage.Status.Error:
Deregister();
MySandboxGame.Log.WriteLine("Invalid packet header.");
State = MyDownloadWorldStateEnum.InvalidMessage;
break;
}
m_mp.SendAck(sender);
MyTrace.Send(TraceWindow.Multiplayer, String.Format("World download progress status: {0}, {1}", State.ToString(), this.Progress));
RaiseProgressChanged();
}
ProfilerShort.End();
}
public void WriteTrace()
{
var smallShips = SectorObjects.OfType <MyMwcObjectBuilder_SmallShip>();
MyTrace.Indent(TraceWindow.Saving, "SmallShips");
foreach (var smallShip in smallShips)
{
MyTrace.Send(TraceWindow.Saving, smallShip.DisplayName);
}
MyTrace.UnIndent(TraceWindow.Saving);
}
private void DeactivatePhantom()
{
if (ENABLE_AABB_PHANTOM)
{
MyTrace.Send(TraceWindow.Analytics, "RemovePhantom-before");
HavokWorld.RemovePhantom(m_aabbPhantom);
MyTrace.Send(TraceWindow.Analytics, "RemovePhantom-after");
Debug.Assert(m_nearbyEntities.Count == 0, "Inconsistent entities management");
m_nearbyEntities.Clear();
}
}
public void Receive()
{
NetIncomingMessage msg;
while ((msg = this.ReadMessage()) != null)
{
if (msg.MessageType == NetIncomingMessageType.StatusChanged)
{
var status = (NetConnectionStatus)msg.PeekByte();
if (status == NetConnectionStatus.Connected)
{
RaisePeerConnected(msg.SenderConnection);
if (msg.SenderConnection.RemoteHailMessage != null)
{
var hailMsg = msg.SenderConnection.RemoteHailMessage;
hailMsg.m_senderConnection = msg.SenderConnection;
hailMsg.m_senderEndpoint = msg.SenderEndpoint;
// Recycle hail msg inside
OnMessageReceived(hailMsg);
}
// Process send queue
ProcessQueue();
}
else if (status == NetConnectionStatus.Disconnected)
{
RaisePeerDisconnected(msg.SenderConnection);
}
Recycle(msg);
}
else if (msg.MessageType == NetIncomingMessageType.NatIntroductionSuccess)
{
RaiseNatIntroductionSuccess(msg.SenderEndpoint, msg.ReadString());
Recycle(msg);
}
else if (msg.MessageType == NetIncomingMessageType.Data)
{
// Recycle inside
OnMessageReceived(msg);
}
else if (
//msg.MessageType == NetIncomingMessageType.DebugMessage ||
msg.MessageType == NetIncomingMessageType.WarningMessage ||
msg.MessageType == NetIncomingMessageType.ErrorMessage)
{
var text = msg.ReadString();
MyTrace.Send(TraceWindow.MultiplayerAlerts, text);
Recycle(msg);
}
else
{
Recycle(msg);
}
}
}
public void WriteTrace()
{
if (SectorObjectBuilder != null)
{
SectorObjectBuilder.WriteTrace();
}
else
{
MyTrace.Send(TraceWindow.Saving, "No sector object builder");
}
InventoryObjectBuilder.WriteTrace();
}
public void TravelLeave(MyMwcTravelTypeEnum travelType)
{
MyTrace.Send(TraceWindow.Saving, "Player.TravelLeave()");
var handler = TravelLeaving;
if (handler != null)
{
handler(travelType);
}
PackBeforeLeave(travelType);
}
private void RecreateWeldedShape(HkShape thisShape)
{
if (RigidBody == null || RigidBody.IsDisposed)
{
Debug.Fail("Missing rigid body");
MyTrace.Send(TraceWindow.Analytics, "Recreating welded shape without RB", string.Format("{0},{1}", Entity.MarkedForClose, WeldInfo.Children.Count));
return;
}
ProfilerShort.Begin("RecreateWeldedShape");
//me.Tranform.Translation = Entity.PositionComp.LocalAABB.Center;
if (WeldInfo.Children.Count == 0)
{
RigidBody.SetShape(thisShape);
if (RigidBody2 != null)
RigidBody2.SetShape(thisShape);
}
else
{
ProfilerShort.Begin("Create shapes");
//m_tmpElements.Add(WeldInfo.MassElement);
m_tmpShapeList.Add(thisShape);
foreach (var child in WeldInfo.Children)
{
var transformShape = new HkTransformShape(child.WeldedRigidBody.GetShape(), ref child.WeldInfo.Transform);
HkShape.SetUserData(transformShape, child.WeldedRigidBody);
m_tmpShapeList.Add(transformShape);
//m_tmpElements.Add(child.WeldInfo.MassElement);
}
//var list = new HkListShape(m_tmpShapeList.ToArray(), HkReferencePolicy.None);
var list = new HkSmartListShape(0);
foreach (var shape in m_tmpShapeList)
list.AddShape(shape);
RigidBody.SetShape(list);
if (RigidBody2 != null)
RigidBody2.SetShape(list);
list.Base.RemoveReference();
WeldedMarkBreakable();
for (int i = 1; i < m_tmpShapeList.Count; i++)
m_tmpShapeList[i].RemoveReference();
m_tmpShapeList.Clear();
ProfilerShort.End();
ProfilerShort.Begin("CalcMassProps");
UpdateMassProps();
//m_tmpElements.Clear();
ProfilerShort.End();
}
ProfilerShort.End();
}
void Matchmaking_LobbyChatUpdate(Lobby lobby, ulong changedUser, ulong makingChangeUser, ChatMemberStateChangeEnum stateChange)
{
//System.Diagnostics.Debug.Assert(MySession.Static != null);
if (lobby.LobbyId == Lobby.LobbyId)
{
if (stateChange == ChatMemberStateChangeEnum.Entered)
{
MySandboxGame.Log.WriteLineAndConsole("Player entered: " + MySteam.API.Friends.GetPersonaName(changedUser) + " (" + changedUser + ")");
MyTrace.Send(TraceWindow.Multiplayer, "Player entered");
Peer2Peer.AcceptSession(changedUser);
RaiseClientJoined(changedUser);
if (MySandboxGame.IsGameReady && changedUser != ServerId)
{
var playerJoined = new MyHudNotification(MySpaceTexts.NotificationClientConnected, 5000, level: MyNotificationLevel.Important);
playerJoined.SetTextFormatArguments(MySteam.API.Friends.GetPersonaName(changedUser));
MyHud.Notifications.Add(playerJoined);
}
}
else
{
RaiseClientLeft(changedUser, stateChange);
if (changedUser == ServerId)
{
MyTrace.Send(TraceWindow.Multiplayer, "Host left: " + stateChange.ToString());
RaiseHostLeft();
MyGuiScreenMainMenu.UnloadAndExitToMenu();
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateMessageBox(
messageCaption: MyTexts.Get(MySpaceTexts.MessageBoxCaptionError),
messageText: MyTexts.Get(MySpaceTexts.MultiplayerErrorServerHasLeft)));
// Set new server
//ServerId = Lobby.GetOwner();
//if (ServerId == Sync.MyId)
//{
// Lobby.SetLobbyData(HostNameTag, Sync.MyName);
//}
}
else if (MySandboxGame.IsGameReady)
{
var playerLeft = new MyHudNotification(MySpaceTexts.NotificationClientDisconnected, 5000, level: MyNotificationLevel.Important);
playerLeft.SetTextFormatArguments(MySteam.API.Friends.GetPersonaName(changedUser));
MyHud.Notifications.Add(playerLeft);
}
}
}
}
public MyObjectBuilder_World ProcessWorldDownloadResult(MyDownloadWorldResult result)
{
MyTrace.Send(TraceWindow.Multiplayer, "World data processed");
m_voxelMapData = result.WorldData.VoxelMaps.Dictionary;
MyLog.Default.WriteLine("ProcessWorldDownloadResult voxel maps:");
foreach (var voxelmap in m_voxelMapData)
{
MyLog.Default.WriteLine(voxelmap.Key);
}
return(result.WorldData);
}
void phantom_Leave(HkPhantomCallbackShape sender, HkRigidBody body)
{
var entity = body.GetEntity();
lock (m_locker)
{
if (entity != null)
{
m_containedEntities.Remove(entity);
MyTrace.Send(TraceWindow.EntityId, string.Format("Entity left gravity field, entity: {0}", entity));
}
}
}
private void DeactivatePhantom()
{
if (ENABLE_AABB_PHANTOM)
{
MyTrace.Send(TraceWindow.Analytics, "RemovePhantom-before");
Debug.Assert(m_aabbPhantom != null);
HavokWorld.RemovePhantom(m_aabbPhantom);
MyTrace.Send(TraceWindow.Analytics, "RemovePhantom-after");
// TODO(DI): Check if this assert is really not valid anymore
//Debug.Assert(m_nearbyEntities.Count == 0, "Inconsistent entities management");
m_nearbyEntities.Clear();
}
}
public void WriteTrace()
{
MyTrace.Indent(TraceWindow.Saving, "Inventory SmallShips");
foreach (var item in this.InventoryItems)
{
var smallShip = item.ItemObjectBuilder as MyMwcObjectBuilder_SmallShip;
if (smallShip != null)
{
MyTrace.Send(TraceWindow.Saving, smallShip.DisplayName);
}
}
MyTrace.UnIndent(TraceWindow.Saving);
}
private void ActivatePhantom()
{
if (ENABLE_AABB_PHANTOM)
{
var center = GetRigidBodyMatrix().Translation + m_voxelMap.SizeInMetresHalf;
var size = m_voxelMap.SizeInMetres;
size *= m_phantomExtend;
m_aabbPhantom.Aabb = new BoundingBox(center - 0.5f * size, center + 0.5f * size);
MyTrace.Send(TraceWindow.Analytics, "AddPhantom-before");
HavokWorld.AddPhantom(m_aabbPhantom);
MyTrace.Send(TraceWindow.Analytics, "AddPhantom-after");
}
}
public void SendMessage <TMessage>(ref TMessage msg, List <ulong> recipients, MyTransportMessageEnum messageType, bool includeSelf)
where TMessage : struct
{
if (recipients.Count == 0 && !includeSelf)
{
return;
}
var msgId = GetId <TMessage>(messageType);
ITransportCallback <TMessage> c = (ITransportCallback <TMessage>)m_callbacks[msgId.Item1].Callback;
P2PMessageEnum sendType = msgId.Item2;
m_sendStream.Position = 0;
m_sendStream.WriteByte((byte)MyMessageId.OLD_GAME_EVENT);
m_sendStream.WriteUShort(msgId.Item1);
c.Write(m_sendStream, ref msg);
const int mtu = 1200;
if ((sendType == P2PMessageEnum.Unreliable || sendType == P2PMessageEnum.UnreliableNoDelay) && m_sendStream.Position > mtu)
{
Debug.Fail("Sending unreliable message as reliable, because it's bigger than MTU, message type: " + FindDebugName(msgId.Item1));
sendType = P2PMessageEnum.ReliableWithBuffering;
}
if (sendType == P2PMessageEnum.Reliable) // Always with buffering
{
sendType = P2PMessageEnum.ReliableWithBuffering;
}
Stats.Network.WriteFormat(StatName <TMessage> .Name, (int)m_sendStream.Position, VRage.Stats.MyStatTypeEnum.CounterSum, 1000, 0);
if (!MySandboxGame.IsDedicated)
{
LogStats(SendStats, TypeNameHelper <TMessage> .Name, (int)m_sendStream.Position, recipients.Count, msgId.Item2);
}
if (includeSelf)
{
MyTrace.Send(TraceWindow.Multiplayer, "Loopback: " + typeof(TMessage).Name);
m_loopback(m_sendStream.Data, (int)m_sendStream.Position, Sync.MyId);
}
foreach (var sendTo in recipients)
{
Debug.Assert(Sync.MultiplayerActive);
TraceMessage("Sending: ", msg.ToString(), sendTo, m_sendStream.Position, sendType);
SendMessage(m_sendStream, sendType, sendTo, m_channel);
}
}
public object BeforeSendRequest(ref System.ServiceModel.Channels.Message request, System.ServiceModel.IClientChannel channel)
{
var action = request.Headers.Action;
action = action.Replace("http://tempuri.org/", "");
action = action.Replace("IMySectorService", "");
action = action.Replace("/", "");
string message = "SERVER CALL: " + action;
MyMwcLog.WriteLine(message);
MyTrace.Send(TraceWindow.Server, message);
// Not sure what return
//return new System.Guid();
return(null);
}
void phantom_Leave(HkPhantomCallbackShape sender, HkRigidBody body)
{
ProfilerShort.Begin("GravityLeave");
var entity = MyPhysicsExtensions.GetEntity(body, 0);// jn: TODO we should collect bodies not entities
lock (m_locker)
{
if (entity != null)
{
m_containedEntities.Remove(entity);
MyTrace.Send(TraceWindow.EntityId, string.Format("Entity left gravity field, entity: {0}", entity));
}
}
ProfilerShort.End();
}
public override void Dispose()
{
MyTrace.Send(TraceWindow.Multiplayer, "Multiplayer closed");
MySteam.API.Matchmaking.LobbyChatUpdate -= Matchmaking_LobbyChatUpdate;
//MySteam.API.Matchmaking.LobbyDataUpdate -= Matchmaking_LobbyDataUpdate;
MySteam.API.Matchmaking.LobbyChatMsg -= Matchmaking_LobbyChatMsg;
if (Lobby.IsValid)
{
MyTrace.Send(TraceWindow.Multiplayer, "Leaving lobby");
CloseMemberSessions();
Lobby.Leave();
}
base.Dispose();
}
private void CloseClient()
{
MyTrace.Send(TraceWindow.Multiplayer, "Multiplayer client closed");
MyControlDisconnectedMsg msg = new MyControlDisconnectedMsg();
msg.Client = Sync.MyId;
SendControlMessage(ServerId, ref msg);
OnJoin = null;
//TODO: Any better way? P2P needs to be closed from both sides. If closed right after Send, message
//can stay not sent.
Thread.Sleep(200);
CloseSession();
}
public void TravelEnter()
{
MyMwcLog.WriteLine("MyPlayer::TravelEnter - START");
MyMwcLog.IncreaseIndent();
MyTrace.Send(TraceWindow.Saving, "Player.TravelEnter()");
UnpackAfterEnter();
var handler = TravelEntered;
if (handler != null)
{
handler();
}
MyMwcLog.DecreaseIndent();
MyMwcLog.WriteLine("MyPlayer::TravelEnter - END");
}
void ITransportCallback.Receive(ByteStream source, ulong sender, TimeSpan timestamp)
{
TMsg msg;
try
{
Serializer.Deserialize(source, out msg);
MyTrace.Send(TraceWindow.Multiplayer, "Received control message: " + msg.ToString(), sender + ", " + source.Position + " B");
}
catch (Exception e)
{
// Catch, add more info (what message) and write to log
MySandboxGame.Log.WriteLine(new Exception(String.Format("Error deserializing '{0}', message size '{1}'", typeof(TMsg).Name, source.Length), e));
return;
}
Callback(ref msg, sender);
}
public override void Dispose()
{
MyTrace.Send(TraceWindow.Multiplayer, "Multiplayer closed");
foreach (var member in m_members)
{
MyControlDisconnectedMsg msg = new MyControlDisconnectedMsg();
msg.Client = ServerId;
if (member != ServerId)
{
SendControlMessage(member, ref msg);
}
}
//TODO: Any better way? P2P needs to be closed from both sides. If closed right after Send, message
//can stay not sent.
Thread.Sleep(200);
try
{
CloseMemberSessions();
SteamSDK.SteamServerAPI.Instance.GameServer.EnableHeartbeats(false);
base.Dispose();
MyLog.Default.WriteLineAndConsole("Logging off Steam...");
SteamSDK.SteamServerAPI.Instance.GameServer.LogOff();
MyLog.Default.WriteLineAndConsole("Shutting down server...");
SteamSDK.SteamServerAPI.Instance.GameServer.Shutdown();
MyLog.Default.WriteLineAndConsole("Done");
SteamSDK.Peer2Peer.SessionRequest -= Peer2Peer_SessionRequest;
SteamSDK.Peer2Peer.ConnectionFailed -= Peer2Peer_ConnectionFailed;
ClientLeft -= MyDedicatedServer_ClientLeft;
}
catch (Exception ex)
{
MyLog.Default.WriteLineAndConsole("catch exception : " + ex.ToString());
}
}
void phantom_Enter(HkPhantomCallbackShape sender, HkRigidBody body)
{
var entity = body.GetEntity();
// HACK: disabled gravity for ships (there may be more changes so I won't add Entity.RespectsGravity now)
lock (m_locker)
{
if (entity != null && !(entity is MyCubeGrid))
{
MyTrace.Send(TraceWindow.EntityId, string.Format("Entity entered gravity field, entity: {0}", entity));
m_containedEntities.Add(entity);
if (entity.Physics.HasRigidBody)
{
((MyPhysicsBody)entity.Physics).RigidBody.Activate();
}
}
}
}
private void PackDrones()
{
MyTrace.Send(TraceWindow.Saving, "Player packing drones");
var drones = MySession.PlayerShip.Drones;
if (drones != null && drones.Count > 0)
{
for (int index = drones.Count - 1; index >= 0; index--)
{
var drone = drones[index];
var inventoryItem = MyInventory.CreateInventoryItemFromObjectBuilder(drone.GetObjectBuilder(true));
MySession.Static.Inventory.AddInventoryItem(inventoryItem);
drone.MarkForClose();
}
MyTrace.Send(TraceWindow.Saving, "Drones found and packed");
}
}
private bool RemoveCell(Vector3I cell)
{
if (!MyFakes.REMOVE_VOXEL_NAVMESH_CELLS)
{
return(true);
}
Debug.Assert(m_processedCells.Contains(cell), "Removing a non-existent cell from the navmesh!");
if (!m_processedCells.Contains(cell))
{
return(false);
}
MyTrace.Send(TraceWindow.Ai, "Removing cell " + cell);
ProfilerShort.Begin("Removing navmesh links");
MyVoxelPathfinding.CellId cellId = new MyVoxelPathfinding.CellId()
{
VoxelMap = m_voxelMap, Pos = cell
};
m_navmeshCoordinator.RemoveVoxelNavmeshLinks(cellId);
ProfilerShort.End();
ProfilerShort.Begin("Removing triangles");
MyCellCoord coord = new MyCellCoord(NAVMESH_LOD, cell);
ulong packedCoord = coord.PackId64();
MyIntervalList triangleList = m_higherLevelHelper.TryGetTriangleList(packedCoord);
if (triangleList != null)
{
foreach (var triangleIndex in triangleList)
{
RemoveTerrainTriangle(GetTriangle(triangleIndex));
}
m_higherLevelHelper.ClearCachedCell(packedCoord);
}
ProfilerShort.End();
Debug.Assert(m_processedCells.Contains(ref cell));
m_processedCells.Remove(ref cell);
return(triangleList != null);
}
protected void OnWorldRequest(ref MyControlWorldRequestMsg data, ulong sender)
{
ProfilerShort.Begin("OnWorldRequest");
MyTrace.Send(TraceWindow.Multiplayer, "World request received");
MySandboxGame.Log.WriteLineAndConsole("World request received: " + GetMemberName(sender));
if (IsClientKickedOrBanned(sender) || MySandboxGame.ConfigDedicated.Banned.Contains(sender))
{
MySandboxGame.Log.WriteLineAndConsole("Sending no world, because client has been kicked or banned: " + GetMemberName(sender) + " (Client is probably modified.)");
RaiseClientLeft(sender, ChatMemberStateChangeEnum.Banned);
return;
}
m_worldSendStream = new MemoryStream();
if (IsServer && MySession.Static != null)
{
MySandboxGame.Log.WriteLine("...responding");
MyObjectBuilder_World worldData = MySession.Static.GetWorld(false);
var checkpoint = worldData.Checkpoint;
checkpoint.WorkshopId = null;
checkpoint.CharacterToolbar = null;
checkpoint.Settings.ScenarioEditMode = checkpoint.Settings.ScenarioEditMode && !MySession.Static.LoadedAsMission;
worldData.Clusters = new List <VRageMath.BoundingBoxD>();
Sandbox.Engine.Physics.MyPhysics.SerializeClusters(worldData.Clusters);
ProfilerShort.Begin("SerializeXML");
MyObjectBuilderSerializer.SerializeXML(m_worldSendStream, worldData, MyObjectBuilderSerializer.XmlCompression.Gzip);
ProfilerShort.BeginNextBlock("SendFlush");
SyncLayer.TransportLayer.SendFlush(sender);
ProfilerShort.End();
}
var buffer = m_worldSendStream.ToArray();
MyMultipartSender msgSender = new MyMultipartSender(buffer, buffer.Length, sender, MyMultiplayer.WorldDownloadChannel, 1150);
m_worldSenders[sender] = msgSender;
ProfilerShort.End();
}
protected void OnConnectedClient(ref ConnectedClientDataMsg msg)
{
MySandboxGame.Log.WriteLineAndConsole("Client connected: " + msg.Name + " (" + msg.SteamID.ToString() + ")");
MyTrace.Send(TraceWindow.Multiplayer, "Client connected");
if (MySandboxGame.IsGameReady && msg.SteamID != ServerId && Sync.MyId != msg.SteamID && msg.Join)
{
var clientConnected = new MyHudNotification(MyCommonTexts.NotificationClientConnected, 5000, level: MyNotificationLevel.Important);
clientConnected.SetTextFormatArguments(msg.Name);
MyHud.Notifications.Add(clientConnected);
}
m_memberData[msg.SteamID] = new MyConnectedClientData()
{
Name = msg.Name,
IsAdmin = msg.IsAdmin
};
RaiseClientJoined(msg.SteamID);
}