public bool TryGetCameraSettings(PlayerId pid, long entityId, out MyEntityCameraSettings cameraSettings)
{
MyPlayer client = null;
if (MySandboxGame.IsDedicated)
{
client = MySession.Static.Players.GetPlayerById(pid);
}
else
{
client = MySession.Static.LocalHumanPlayer;
}
if (m_characterCameraSettings != null && client != null && client.Character != null && client.Character.EntityId == entityId)
{
cameraSettings = m_characterCameraSettings;
return(true);
}
if (ContainsPlayer(pid) && m_entityCameraSettings[pid].ContainsKey(entityId))
{
return(m_entityCameraSettings[pid].TryGetValue(entityId, out cameraSettings));
}
cameraSettings = null;
return(false);
}
static void OnChangeSlotItemRequest(ref PlayerToolbarChangeSlotMsg msg, MyNetworkClient sender)
{
var playerId = new PlayerId(sender.SteamUserId, msg.PlayerSerialId);
if (!MySession.Static.Toolbars.ContainsToolbar(playerId))
{
return;
}
MyDefinitionBase def;
MyDefinitionManager.Static.TryGetDefinition(msg.DefId, out def);
if (def == null)
{
return;
}
var ob = MyToolbarItemFactory.ObjectBuilderFromDefinition(def);
var tItem = MyToolbarItemFactory.CreateToolbarItem(ob);
var toolbar = MySession.Static.Toolbars.TryGetPlayerToolbar(playerId);
if (toolbar == null)
{
return;
}
toolbar.SetItemAtIndex(msg.Index, tItem);
}
public static void RequestChangeSlotItem(PlayerId pid, int index, MyDefinitionId defId)
{
DefinitionIdBlit defIdBlit = new DefinitionIdBlit();
defIdBlit = defId;
MyMultiplayer.RaiseStaticEvent(s => MyToolBarCollection.OnChangeSlotItemRequest, pid.SerialId, index, defIdBlit);
}
static void OnChangeSlotItemRequest(int playerSerialId, int index, DefinitionIdBlit defId)
{
ulong senderId = GetSenderIdSafe();
var playerId = new PlayerId(senderId, playerSerialId);
if (!MySession.Static.Toolbars.ContainsToolbar(playerId))
{
return;
}
MyDefinitionBase def;
MyDefinitionManager.Static.TryGetDefinition(defId, out def);
if (def == null)
{
return;
}
var ob = MyToolbarItemFactory.ObjectBuilderFromDefinition(def);
var tItem = MyToolbarItemFactory.CreateToolbarItem(ob);
var toolbar = MySession.Static.Toolbars.TryGetPlayerToolbar(playerId);
if (toolbar == null)
{
return;
}
toolbar.SetItemAtIndex(index, tItem);
}
public static void RequestCreateToolbar(PlayerId pid)
{
var msg = new PlayerToolbarCreatedMsg();
msg.ClientSteamId = pid.SteamId;
msg.PlayerSerialId = pid.SerialId;
Sync.Layer.SendMessageToServer(ref msg);
}
public static void RequestClearSlot(PlayerId pid, int index)
{
var msg = new PlayerToolbarClearSlotMsg();
msg.ClientSteamId = pid.SteamId;
msg.PlayerSerialId = pid.SerialId;
msg.Index = index;
Sync.Layer.SendMessageToServer(ref msg);
}
public static void RequestChangeSlotItem(PlayerId pid, int index, MyDefinitionId defId)
{
var msg = new PlayerToolbarChangeSlotMsg();
msg.ClientSteamId = pid.SteamId;
msg.PlayerSerialId = pid.SerialId;
msg.Index = index;
msg.DefId = defId;
Sync.Layer.SendMessageToServer(ref msg);
}
static void OnClearSlotRequest(ref PlayerToolbarClearSlotMsg msg, MyNetworkClient sender)
{
var playerId = new PlayerId(sender.SteamUserId, msg.PlayerSerialId);
if (!MySession.Static.Toolbars.ContainsToolbar(playerId))
return;
var toolbar = MySession.Static.Toolbars.TryGetPlayerToolbar(playerId);
toolbar.SetItemAtIndex(msg.Index, null);
}
public static void RequestClearSlot(PlayerId pid, int index)
{
var msg = new PlayerToolbarClearSlotMsg();
msg.ClientSteamId = pid.SteamId;
msg.PlayerSerialId = pid.SerialId;
msg.Index = index;
Sync.Layer.SendMessageToServer(ref msg);
}
static void OnSaveEntityCameraSettings(PlayerId playerId, long entityId, bool isFirstPerson, double distance, float headAngleX, float headAngleY)
{
PlayerId pid = new PlayerId(playerId.SteamId, playerId.SerialId);
Vector2 headAngle = new Vector2(headAngleX, headAngleY);
MyPlayer player = MySession.Static.Players.GetPlayerById(pid);
if (player != null && player.Character != null && player.Character.EntityId == entityId)
MySession.Static.Cameras.AddCharacterCameraData(pid, isFirstPerson, distance, headAngle);
else
MySession.Static.Cameras.AddCameraData(pid, entityId, isFirstPerson, distance, headAngle);
}
public void SaveCameraCollection(MyObjectBuilder_Checkpoint checkpoint)
{
MyDebug.AssertDebug(checkpoint.AllPlayersData != null, "Players data not initialized!");
if (checkpoint.AllPlayersData == null)
{
return;
}
foreach (var playerData in checkpoint.AllPlayersData.Dictionary)
{
PlayerId pid = new PlayerId(playerData.Key.ClientId, playerData.Key.SerialId);
playerData.Value.EntityCameraData = new List <CameraControllerSettings>();
if (!m_entityCameraSettings.ContainsKey(pid))
{
continue;
}
m_entitiesToRemove.Clear();
foreach (var cameraSetting in m_entityCameraSettings[pid])
{
if (MyEntities.EntityExists(cameraSetting.Key))
{
CameraControllerSettings settings = new CameraControllerSettings()
{
Distance = cameraSetting.Value.Distance,
IsFirstPerson = cameraSetting.Value.IsFirstPerson,
HeadAngle = cameraSetting.Value.HeadAngle,
EntityId = cameraSetting.Key,
};
playerData.Value.EntityCameraData.Add(settings);
}
else
{
m_entitiesToRemove.Add(cameraSetting.Key);
}
}
foreach (long entityId in m_entitiesToRemove)
{
m_entityCameraSettings[pid].Remove(entityId);
}
if (m_characterCameraSettings != null)
{
playerData.Value.CharacterCameraData = new CameraControllerSettings()
{
Distance = m_characterCameraSettings.Distance,
IsFirstPerson = m_characterCameraSettings.IsFirstPerson,
HeadAngle = m_characterCameraSettings.HeadAngle,
};
}
}
}
static void OnClearSlotRequest(int playerSerialId, int index)
{
ulong senderId = GetSenderIdSafe();
var playerId = new PlayerId(senderId, playerSerialId);
if (!MySession.Static.Toolbars.ContainsToolbar(playerId))
return;
var toolbar = MySession.Static.Toolbars.TryGetPlayerToolbar(playerId);
toolbar.SetItemAtIndex(index, null);
}
private void CreateDefaultToolbar(PlayerId playerId)
{
if (ContainsToolbar(playerId))
{
return;
}
var toolbar = new MyToolbar(MyToolbarType.Character);
toolbar.Init(MySession.Static.Scenario.DefaultToolbar, null, true);
AddPlayerToolbar(playerId, toolbar);
}
public static void RequestChangeSlotItem(PlayerId pid, int index, MyObjectBuilder_ToolbarItem itemBuilder)
{
var msg = new PlayerToolbarChangeSlotBuilderMsg();
msg.ClientSteamId = pid.SteamId;
msg.PlayerSerialId = pid.SerialId;
msg.Index = index;
msg.itemBuilder = itemBuilder;
Sync.Layer.SendMessageToServer(ref msg);
}
public bool RemovePlayerToolbar(PlayerId pid)
{
if (pid == null)
{
return(false);
}
var ret = m_playerToolbars.Remove(pid);
return(ret);
}
public static void RequestChangeSlotItem(PlayerId pid, int index, MyDefinitionId defId)
{
var msg = new PlayerToolbarChangeSlotMsg();
msg.ClientSteamId = pid.SteamId;
msg.PlayerSerialId = pid.SerialId;
msg.Index = index;
msg.DefId = defId;
Sync.Layer.SendMessageToServer(ref msg);
}
private Dictionary <MyStringId, object> GetOrAllocatePlayerDataDictionary(PlayerId playerId)
{
Dictionary <MyStringId, object> playerData = null;
if (!m_playerDataByPlayerId.TryGetValue(playerId, out playerData))
{
playerData = new Dictionary <MyStringId, object>(MyStringId.Comparer);
m_playerDataByPlayerId[playerId] = playerData;
}
return(playerData);
}
private void AddCharacterCameraData(PlayerId pid, bool isFirstPerson, double distance, Vector2 headAngle)
{
if (m_characterCameraSettings == null)
{
m_characterCameraSettings = new MyEntityCameraSettings();
}
m_characterCameraSettings.IsFirstPerson = isFirstPerson;
if (!isFirstPerson)
{
m_characterCameraSettings.Distance = distance;
m_characterCameraSettings.HeadAngle = headAngle;
}
}
static void OnClearSlotRequest(ref PlayerToolbarClearSlotMsg msg, MyNetworkClient sender)
{
var playerId = new PlayerId(sender.SteamUserId, msg.PlayerSerialId);
if (!MySession.Static.Toolbars.ContainsToolbar(playerId))
{
return;
}
var toolbar = MySession.Static.Toolbars.TryGetPlayerToolbar(playerId);
toolbar.SetItemAtIndex(msg.Index, null);
}
public void LoadToolbars(MyObjectBuilder_Checkpoint checkpoint)
{
if (checkpoint.AllPlayersData != null)
{
foreach (var item in checkpoint.AllPlayersData.Dictionary)
{
var playerId = new PlayerId(item.Key.ClientId, item.Key.SerialId);
var toolbar = new MyToolbar(MyToolbarType.Character);
toolbar.Init(item.Value.Toolbar, null, true);
AddPlayerToolbar(playerId, toolbar);
}
}
}
public MyToolbar TryGetPlayerToolbar(PlayerId pid)
{
if (pid == null)
{
return(null);
}
MyToolbar result;
m_playerToolbars.TryGetValue(pid, out result);
return(result);
}
static void OnClearSlotRequest(int playerSerialId, int index)
{
ulong senderId = GetSenderIdSafe();
var playerId = new PlayerId(senderId, playerSerialId);
if (!MySession.Static.Toolbars.ContainsToolbar(playerId))
{
return;
}
var toolbar = MySession.Static.Toolbars.TryGetPlayerToolbar(playerId);
toolbar.SetItemAtIndex(index, null);
}
static void OnChangeSlotBuilderItemRequest(int playerSerialId, int index,
[Serialize(MyObjectFlags.Dynamic, DynamicSerializerType = typeof(MyObjectBuilderDynamicSerializer))] MyObjectBuilder_ToolbarItem itemBuilder)
{
ulong senderId = GetSenderIdSafe();
var playerId = new PlayerId(senderId, playerSerialId);
if (!MySession.Static.Toolbars.ContainsToolbar(playerId))
return;
var tItem = MyToolbarItemFactory.CreateToolbarItem(itemBuilder);
var toolbar = MySession.Static.Toolbars.TryGetPlayerToolbar(playerId);
if (toolbar == null)
return;
toolbar.SetItemAtIndex(index, tItem);
}
static void OnSaveEntityCameraSettings(ref PlayerSaveEntityCameraSettingsMsg msg, MyNetworkClient sender)
{
PlayerId pid = new PlayerId(sender.SteamUserId, msg.PlayerSerialId);
Vector2 headAngle = new Vector2(msg.HeadX, msg.HeadY);
MyPlayer player = MySession.Static.Players.TryGetPlayerById(pid);
if (player != null && player.Character != null && player.Character.EntityId == msg.EntityId)
{
MySession.Static.Cameras.AddCharacterCameraData(pid, msg.IsFirstPerson, msg.Distance, headAngle);
}
else
{
MySession.Static.Cameras.AddCameraData(pid, msg.EntityId, msg.IsFirstPerson, msg.Distance, headAngle);
}
}
public void RequestSaveEntityCameraSettings(PlayerId pid, long entityId, bool isFirstPerson, double distance, float headAngleX, float headAngleY)
{
if (MyEntities.CloseAllowed)
return;
var msg = new PlayerSaveEntityCameraSettingsMsg();
msg.PlayerSerialId = pid.SerialId;
msg.EntityId = entityId;
msg.Distance = distance;
msg.IsFirstPerson = isFirstPerson;
msg.HeadX = headAngleX;
msg.HeadY = headAngleY;
Sync.Layer.SendMessageToServer(ref msg);
}
static void OnSaveEntityCameraSettings(PlayerId playerId, long entityId, bool isFirstPerson, double distance, float headAngleX, float headAngleY)
{
PlayerId pid = new PlayerId(playerId.SteamId, playerId.SerialId);
Vector2 headAngle = new Vector2(headAngleX, headAngleY);
MyPlayer player = MySession.Static.Players.GetPlayerById(pid);
if (player != null && player.Character != null && player.Character.EntityId == entityId)
{
MySession.Static.Cameras.AddCharacterCameraData(pid, isFirstPerson, distance, headAngle);
}
else
{
MySession.Static.Cameras.AddCameraData(pid, entityId, isFirstPerson, distance, headAngle);
}
}
private void AddCameraData(PlayerId pid, long entityId, MyEntityCameraSettings data)
{
if (!ContainsPlayer(pid))
{
m_entityCameraSettings[pid] = new Dictionary <long, MyEntityCameraSettings>();
}
if (m_entityCameraSettings[pid].ContainsKey(entityId))
{
m_entityCameraSettings[pid][entityId] = data;
}
else
{
m_entityCameraSettings[pid].Add(entityId, data);
}
}
public MyVirtualClient(Endpoint endPoint, MyClientStateBase clientState, Sandbox.Game.World.MyPlayer.PlayerId playerId)
{
this.m_clientState = clientState;
this.m_clientState.EndpointId = endPoint;
this.m_clientState.PlayerSerialId = playerId.SerialId;
this.PlayerId = playerId;
TransportLayer.Register(MyMessageId.SERVER_DATA, endPoint.Index, new Action <MyPacket>(this.OnServerData));
TransportLayer.Register(MyMessageId.REPLICATION_CREATE, endPoint.Index, new Action <MyPacket>(this.OnReplicationCreate));
TransportLayer.Register(MyMessageId.REPLICATION_DESTROY, endPoint.Index, new Action <MyPacket>(this.OnReplicationDestroy));
TransportLayer.Register(MyMessageId.SERVER_STATE_SYNC, endPoint.Index, new Action <MyPacket>(this.OnServerStateSync));
TransportLayer.Register(MyMessageId.RPC, endPoint.Index, new Action <MyPacket>(this.OnEvent));
TransportLayer.Register(MyMessageId.REPLICATION_STREAM_BEGIN, endPoint.Index, new Action <MyPacket>(this.OnReplicationStreamBegin));
TransportLayer.Register(MyMessageId.JOIN_RESULT, endPoint.Index, new Action <MyPacket>(this.OnJoinResult));
TransportLayer.Register(MyMessageId.WORLD_DATA, endPoint.Index, new Action <MyPacket>(this.OnWorldData));
TransportLayer.Register(MyMessageId.CLIENT_CONNNECTED, endPoint.Index, new Action <MyPacket>(this.OnClientConnected));
TransportLayer.Register(MyMessageId.REPLICATION_ISLAND_DONE, endPoint.Index, new Action <MyPacket>(this.OnReplicationIslandDone));
}
public void SaveEntityCameraSettings(PlayerId pid, long entityId, bool isFirstPerson, double distance, float headAngleX, float headAngleY, bool sync = true)
{
if (!Sync.IsServer && sync)
{
RequestSaveEntityCameraSettings(pid, entityId, isFirstPerson, distance, headAngleX, headAngleY);
}
Vector2 headAngle = new Vector2(headAngleX, headAngleY);
if (MySession.Static.ControlledEntity is MyCharacter || (MySession.Static.LocalCharacter != null && MySession.Static.LocalCharacter.EntityId == entityId))
{
AddCharacterCameraData(pid, isFirstPerson, distance, headAngle);
}
else
{
AddCameraData(pid, entityId, isFirstPerson, distance, headAngle);
}
}
public T GetPlayerData <T>(PlayerId playerId, MyStringId dataId, T defaultValue)
{
Dictionary <MyStringId, object> playerData = null;
if (!m_playerDataByPlayerId.TryGetValue(playerId, out playerData))
{
return(defaultValue);
}
object data = null;
if (!playerData.TryGetValue(dataId, out data))
{
return(defaultValue);
}
return((T)data);
}
static void OnChangeSlotBuilderItemRequest(ref PlayerToolbarChangeSlotBuilderMsg msg, MyNetworkClient sender)
{
var playerId = new PlayerId(sender.SteamUserId, msg.PlayerSerialId);
if (!MySession.Static.Toolbars.ContainsToolbar(playerId))
{
return;
}
var tItem = MyToolbarItemFactory.CreateToolbarItem(msg.itemBuilder);
var toolbar = MySession.Static.Toolbars.TryGetPlayerToolbar(playerId);
if (toolbar == null)
{
return;
}
toolbar.SetItemAtIndex(msg.Index, tItem);
}
public void RequestSaveEntityCameraSettings(PlayerId pid, long entityId, bool isFirstPerson, double distance, float headAngleX, float headAngleY)
{
if (MyEntities.CloseAllowed)
{
return;
}
var msg = new PlayerSaveEntityCameraSettingsMsg();
msg.PlayerSerialId = pid.SerialId;
msg.EntityId = entityId;
msg.Distance = distance;
msg.IsFirstPerson = isFirstPerson;
msg.HeadX = headAngleX;
msg.HeadY = headAngleY;
Sync.Layer.SendMessageToServer(ref msg);
}
static void OnChangeSlotItemRequest(int playerSerialId, int index, DefinitionIdBlit defId)
{
ulong senderId = GetSenderIdSafe();
var playerId = new PlayerId(senderId, playerSerialId);
if (!MySession.Static.Toolbars.ContainsToolbar(playerId))
return;
MyDefinitionBase def;
MyDefinitionManager.Static.TryGetDefinition(defId, out def);
if (def == null)
return;
var ob = MyToolbarItemFactory.ObjectBuilderFromDefinition(def);
var tItem = MyToolbarItemFactory.CreateToolbarItem(ob);
var toolbar = MySession.Static.Toolbars.TryGetPlayerToolbar(playerId);
if (toolbar == null)
return;
toolbar.SetItemAtIndex(index, tItem);
}
public bool AddPlayerToolbar(PlayerId pid, MyToolbar toolbar)
{
if (pid == null || toolbar == null)
{
return(false);
}
MyToolbar result;
var success = m_playerToolbars.TryGetValue(pid, out result);
if (!success)
{
m_playerToolbars.Add(pid, toolbar);
return(true);
}
else
{
return(false);
}
}
static void OnChangeSlotBuilderItemRequest(int playerSerialId, int index,
[Serialize(MyObjectFlags.Dynamic, DynamicSerializerType = typeof(MyObjectBuilderDynamicSerializer))] MyObjectBuilder_ToolbarItem itemBuilder)
{
ulong senderId = GetSenderIdSafe();
var playerId = new PlayerId(senderId, playerSerialId);
if (!MySession.Static.Toolbars.ContainsToolbar(playerId))
{
return;
}
var tItem = MyToolbarItemFactory.CreateToolbarItem(itemBuilder);
var toolbar = MySession.Static.Toolbars.TryGetPlayerToolbar(playerId);
if (toolbar == null)
{
return;
}
toolbar.SetItemAtIndex(index, tItem);
}
private void AddCameraData(PlayerId pid, long entityId, bool isFirstPerson, double distance, Vector2 headAngle)
{
MyEntityCameraSettings cameraSettings = null;
if (TryGetCameraSettings(pid, entityId, out cameraSettings))
{
cameraSettings.IsFirstPerson = isFirstPerson;
if (!isFirstPerson)
{
cameraSettings.Distance = distance;
cameraSettings.HeadAngle = headAngle;
}
}
else
{
cameraSettings = new MyEntityCameraSettings()
{
Distance = distance,
IsFirstPerson = isFirstPerson,
HeadAngle = headAngle,
};
AddCameraData(pid, entityId, cameraSettings);
}
}
public void LoadCameraCollection(MyObjectBuilder_Checkpoint checkpoint)
{
m_entityCameraSettings = new Dictionary <PlayerId, Dictionary <long, MyEntityCameraSettings> >();
var allPlayers = checkpoint.AllPlayersData;
if (allPlayers != null)
{
foreach (var playerData in allPlayers.Dictionary)
{
PlayerId pid = new PlayerId(playerData.Key.ClientId, playerData.Key.SerialId);
m_entityCameraSettings[pid] = new Dictionary <long, MyEntityCameraSettings>();
foreach (var cameraSettings in playerData.Value.EntityCameraData)
{
MyEntityCameraSettings data = new MyEntityCameraSettings()
{
Distance = cameraSettings.Distance,
HeadAngle = (Vector2?)cameraSettings.HeadAngle,
IsFirstPerson = cameraSettings.IsFirstPerson
};
m_entityCameraSettings[pid][cameraSettings.EntityId] = data;
}
if (playerData.Value.CharacterCameraData != null)
{
m_characterCameraSettings = new MyEntityCameraSettings()
{
Distance = playerData.Value.CharacterCameraData.Distance,
HeadAngle = playerData.Value.CharacterCameraData.HeadAngle,
IsFirstPerson = playerData.Value.CharacterCameraData.IsFirstPerson
};
}
}
}
}
private void AddCameraData(PlayerId pid, long entityId, bool isFirstPerson, double distance, Vector2 headAngle)
{
MyEntityCameraSettings cameraSettings = null;
if (TryGetCameraSettings(pid, entityId, out cameraSettings))
{
cameraSettings.IsFirstPerson = isFirstPerson;
if (!isFirstPerson)
{
cameraSettings.Distance = distance;
cameraSettings.HeadAngle = headAngle;
}
}
else
{
cameraSettings = new MyEntityCameraSettings()
{
Distance = distance,
IsFirstPerson = isFirstPerson,
HeadAngle = headAngle,
};
AddCameraData(pid, entityId, cameraSettings);
}
}
static void OnNewPlayerFailure(ref NewPlayerFailureMsg msg, MyNetworkClient sender)
{
if (msg.ClientSteamId != MySteam.UserId)
{
Debug.Assert(false, "Your SteamId differs from message steam id");
return;
}
var playerId = new PlayerId(msg.ClientSteamId, msg.PlayerSerialId);
if (Sync.Players.NewPlayerRequestFailed != null)
{
Sync.Players.NewPlayerRequestFailed(playerId.SerialId);
}
}
static void OnCharacterChanged(MySyncEntity entity, ref CharacterChangedMsg msg, MyNetworkClient sender)
{
MyCharacter characterEntity = entity.Entity as MyCharacter;
MyEntity controlledEntity;
if (!MyEntities.TryGetEntity(msg.ControlledEntityId, out controlledEntity))
{
MySandboxGame.Log.WriteLine("Controlled entity not found");
Debug.Fail("Controlled entity not found");
}
PlayerId id = new PlayerId(msg.ClientSteamId, msg.PlayerSerialId);
MyPlayer player = Sync.Players.TryGetPlayerById(id);
ChangePlayerCharacterInternal(player, characterEntity, controlledEntity);
}
static void OnPlayerIdentityChanged(ref PlayerIdentityChangedMsg msg, MyNetworkClient sender)
{
Debug.Assert(!Sync.IsServer);
var playerId = new PlayerId(msg.ClientSteamId, msg.PlayerSerialId);
var player = Sync.Players.TryGetPlayerById(playerId);
Debug.Assert(player != null, "Changing identity of an unknown or unconnected player!");
if (player == null) return;
MyIdentity identity = null;
Sync.Players.m_allIdentities.TryGetValue(msg.IdentityId, out identity);
Debug.Assert(identity != null, "Changing player's identity to an unknown identity!");
if (identity == null) return;
player.ChangeIdentity(identity);
}
public bool ContainsPlayer(PlayerId pid)
{
return(m_entityCameraSettings.ContainsKey(pid));
}
static void OnControlChangedSuccess(MySyncEntity entity, ref ControlChangedMsg msg, MyNetworkClient sender)
{
PlayerId id = new PlayerId(msg.ClientSteamId, msg.PlayerSerialId);
MyTrace.Send(TraceWindow.Multiplayer, "OnControlChanged to entity: " + msg.EntityId, id.ToString());
Sync.Players.SetControlledEntityInternal(id, entity.Entity);
}
public MyPlayer CreateNewPlayer(MyIdentity identity, PlayerId id, string playerName)
{
Debug.Assert(Sync.IsServer);
MyNetworkClient steamClient;
Sync.Clients.TryGetClient(id.SteamId, out steamClient);
Debug.Assert(steamClient != null, "Could not find a client for the new player!");
if (steamClient == null) return null;
var player = CreateNewPlayerInternal(identity, steamClient, playerName, ref id);
if (player != null)
{
var msg = new PlayerCreatedMsg();
msg.ClientSteamId = id.SteamId;
msg.PlayerSerialId = id.SerialId;
msg.IdentityId = identity.IdentityId;
msg.DisplayName = playerName;
Sync.Layer.SendMessageToAll(ref msg, MyTransportMessageEnum.Success);
}
return player;
}
public void SaveEntityCameraSettings(PlayerId pid, long entityId, bool isFirstPerson, double distance, float headAngleX, float headAngleY, bool sync = true)
{
if (!Sync.IsServer && sync)
{
RequestSaveEntityCameraSettings(pid, entityId, isFirstPerson, distance, headAngleX, headAngleY);
}
Vector2 headAngle = new Vector2(headAngleX, headAngleY);
if (MySession.ControlledEntity is MyCharacter || (MySession.LocalCharacter != null && MySession.LocalCharacter.EntityId == entityId))
AddCharacterCameraData(pid, isFirstPerson, distance, headAngle);
else
AddCameraData(pid, entityId, isFirstPerson, distance, headAngle);
}
public void LoadCameraCollection(MyObjectBuilder_Checkpoint checkpoint)
{
m_entityCameraSettings = new Dictionary<PlayerId, Dictionary<long, MyEntityCameraSettings>>();
var allPlayers = checkpoint.AllPlayersData;
if (allPlayers != null)
{
foreach (var playerData in allPlayers.Dictionary)
{
PlayerId pid = new PlayerId(playerData.Key.ClientId, playerData.Key.SerialId);
m_entityCameraSettings[pid] = new Dictionary<long, MyEntityCameraSettings>();
foreach (var cameraSettings in playerData.Value.EntityCameraData)
{
MyEntityCameraSettings data = new MyEntityCameraSettings()
{
Distance = cameraSettings.Distance,
HeadAngle = (Vector2?)cameraSettings.HeadAngle,
IsFirstPerson = cameraSettings.IsFirstPerson
};
m_entityCameraSettings[pid][cameraSettings.EntityId] = data;
}
if (playerData.Value.CharacterCameraData != null)
{
m_characterCameraSettings = new MyEntityCameraSettings()
{
Distance = playerData.Value.CharacterCameraData.Distance,
HeadAngle = playerData.Value.CharacterCameraData.HeadAngle,
IsFirstPerson = playerData.Value.CharacterCameraData.IsFirstPerson
};
}
}
}
}
private void AddCameraData(PlayerId pid, long entityId, MyEntityCameraSettings data)
{
if (!ContainsPlayer(pid))
{
m_entityCameraSettings[pid] = new Dictionary<long, MyEntityCameraSettings>();
}
if (m_entityCameraSettings[pid].ContainsKey(entityId))
m_entityCameraSettings[pid][entityId] = data;
else
m_entityCameraSettings[pid].Add(entityId, data);
}
public bool ContainsPlayer(PlayerId pid)
{
return m_entityCameraSettings.ContainsKey(pid);
}
//public MyPlayer InitNewPlayer(MyIdentity identity, PlayerId id, string playerName)
//{
// MyNetworkClient steamClient;
// Sync.Clients.TryGetClient(id.SteamId, out steamClient);
// Debug.Assert(steamClient != null, "Could not find a client for the new player!");
// if (steamClient == null) return null;
// return CreateNewPlayerInternal(identity, steamClient, playerName, ref id);
//}
public MyPlayer InitNewPlayer(MyIdentity identity, PlayerId id, MyObjectBuilder_Player playerOb)
{
MyNetworkClient steamClient;
Sync.Clients.TryGetClient(id.SteamId, out steamClient);
Debug.Assert(steamClient != null, "Could not find a client for the new player!");
if (steamClient == null) return null;
MyPlayer playerInstance = CreateNewPlayerInternal(identity, steamClient, playerOb.DisplayName, ref id);
return playerInstance;
}
public void LoadControlledEntities(SerializableDictionaryCompat<long, MyObjectBuilder_Checkpoint.PlayerId, ulong> controlledEntities, long controlledObject, MyPlayer.PlayerId? savingPlayerId = null)
{
if (controlledEntities == null) return;
foreach (var controlledEntityIt in controlledEntities.Dictionary)
{
MyEntity controlledEntity;
MyEntities.TryGetEntityById(controlledEntityIt.Key, out controlledEntity);
var playerId = new PlayerId(controlledEntityIt.Value.ClientId, controlledEntityIt.Value.SerialId);
if (savingPlayerId != null && playerId == savingPlayerId) playerId = new PlayerId(MySteam.UserId);
MyPlayer player = Sync.Players.TryGetPlayerById(playerId);
if (player != null && controlledEntity != null)
{
if (!MySandboxGame.IsDedicated && controlledEntity is IMyControllableEntity)
{
player.Controller.TakeControl(controlledEntity as IMyControllableEntity);
if (controlledEntity is MyCharacter)
player.Identity.ChangeCharacter(controlledEntity as MyCharacter);
if (controlledEntity is MyShipController)
player.Identity.ChangeCharacter((controlledEntity as MyShipController).Pilot);
if (controlledEntity is MyLargeTurretBase)
player.Identity.ChangeCharacter((controlledEntity as MyLargeTurretBase).Pilot);
}
else
{
m_controlledEntities.Add(controlledEntityIt.Key, playerId, true);
}
}
}
}
private void AddCharacterCameraData(PlayerId pid, bool isFirstPerson, double distance, Vector2 headAngle)
{
if (m_characterCameraSettings == null)
m_characterCameraSettings = new MyEntityCameraSettings();
m_characterCameraSettings.IsFirstPerson = isFirstPerson;
if (!isFirstPerson)
{
m_characterCameraSettings.Distance = distance;
m_characterCameraSettings.HeadAngle = headAngle;
}
}
public void LoadConnectedPlayers(MyObjectBuilder_Checkpoint checkpoint, MyPlayer.PlayerId? savingPlayerId = null)
{
#warning TODO: Probably not needed? If not, remove the method
//long identityId = FindLocalIdentityId(checkpoint);
// Backward compatibility
if (checkpoint.AllPlayers != null && checkpoint.AllPlayers.Count != 0)
{
foreach (var playerItem in checkpoint.AllPlayers)
{
long identityId = playerItem.PlayerId;
var playerOb = new MyObjectBuilder_Player();
playerOb.Connected = true;
playerOb.DisplayName = playerItem.Name;
playerOb.IdentityId = identityId;
var playerId = new PlayerId(playerItem.SteamId, 0);
if (savingPlayerId != null && playerId == savingPlayerId)
{
playerId = new PlayerId(MySteam.UserId);
ChangeDisplayNameOfPlayerAndIdentity(playerOb, MySteam.UserName);
}
LoadPlayerInternal(ref playerId, playerOb, obsolete: true);
}
}
// Backward compatibility
else if (checkpoint.ConnectedPlayers != null && checkpoint.ConnectedPlayers.Dictionary.Count != 0)
{
Debug.Assert(checkpoint.DisconnectedPlayers != null, "Inconsistency in save! ConnectedPlayers were present, but DisconnectedPlayers not!");
foreach (var playerItem in checkpoint.ConnectedPlayers.Dictionary)
{
var playerId = new PlayerId(playerItem.Key.ClientId, playerItem.Key.SerialId);
if (savingPlayerId != null && playerId == savingPlayerId)
{
playerId = new PlayerId(MySteam.UserId);
ChangeDisplayNameOfPlayerAndIdentity(playerItem.Value, MySteam.UserName);
}
playerItem.Value.Connected = true;
LoadPlayerInternal(ref playerId, playerItem.Value, obsolete: false);
}
foreach (var playerItem in checkpoint.DisconnectedPlayers.Dictionary)
{
var playerId = new PlayerId(playerItem.Key.ClientId, playerItem.Key.SerialId);
var playerOb = new MyObjectBuilder_Player();
playerOb.Connected = false;
playerOb.IdentityId = playerItem.Value;
playerOb.DisplayName = null;
if (savingPlayerId != null && playerId == savingPlayerId)
{
playerId = new PlayerId(MySteam.UserId);
ChangeDisplayNameOfPlayerAndIdentity(playerOb, MySteam.UserName);
}
LoadPlayerInternal(ref playerId, playerOb, obsolete: false);
}
//LoadDisconnectedPlayers(checkpoint.DisconnectedPlayers.Dictionary);
}
else if (checkpoint.AllPlayersData != null)
{
foreach (var playerItem in checkpoint.AllPlayersData.Dictionary)
{
var playerId = new MyPlayer.PlayerId(playerItem.Key.ClientId, playerItem.Key.SerialId);
if (savingPlayerId != null && playerId == savingPlayerId)
{
playerId = new PlayerId(MySteam.UserId);
ChangeDisplayNameOfPlayerAndIdentity(playerItem.Value, MySteam.UserName);
}
LoadPlayerInternal(ref playerId, playerItem.Value, obsolete: false);
}
}
/*long identityId = FindLocalIdentityId(checkpoint);
//Player was saved in death state or there is no player
if (identityId == 0)
{
checkpoint.ControlledObject = 0; //This will lead to RequestRespawn
checkpoint.CameraController = MyCameraControllerEnum.Entity;
IsCameraAwaitingEntity = true;
}
else
{
// TODO: Refactor this later
MyEntity controlledObject = null;
if (checkpoint.ControlledObject != -1)
{
MyEntities.TryGetEntityById(checkpoint.ControlledObject, out controlledObject);
System.Diagnostics.Debug.Assert(controlledObject != null);
if (controlledObject is IMyControllableEntity)
{
var cockpit = controlledObject as MyCockpit;
if (cockpit != null)
{
var pilot = cockpit.Pilot;
if (pilot == null)
{
Debug.Fail("Creating new pilot for cockpit, because saved cockpit was controlled and had no pilot sitting in it.");
MySandboxGame.Log.WriteLine("Creating new pilot for cockpit, because saved cockpit was controlled and had no pilot sitting in it.");
var characterOb = MyCharacter.Random();
characterOb.Battery = new MyObjectBuilder_Battery() { CurrentCapacity = MyEnergyConstants.BATTERY_MAX_CAPACITY };
pilot = (MyCharacter)MyEntityFactory.CreateEntity(characterOb);
pilot.Init(characterOb);
MyWorldGenerator.InitInventoryWithDefaults(pilot.GetInventory());
cockpit.RequestUse(UseActionEnum.Manipulate, pilot);
}
MySession.Player.Init(pilot, null, identityId);
}
else if (controlledObject.Parent is MyCockpit)
{
MySession.Player.Init((MyCharacter)controlledObject, null, identityId);
controlledObject = controlledObject.Parent;
}
else
{
if (!MySandboxGame.IsDedicated)
{
if (controlledObject is MyCharacter)
{
MySession.Player.Init((MyCharacter)controlledObject, null, identityId);
}
}
}
if (!MySandboxGame.IsDedicated)
MySession.Player.Controller.TakeControl((IMyControllableEntity)controlledObject);
}
}
if (checkpoint.Players != null)
{
foreach (var playerIt in checkpoint.Players.Dictionary)
{
if (playerIt.Key == Player.SteamUserId)
{
Player.PlayerId = identityId;
if (string.IsNullOrEmpty(Player.Model))
{
if (!string.IsNullOrEmpty(playerIt.Value.PlayerModel))
Player.Model = playerIt.Value.PlayerModel;
else
Player.Model = MyCharacter.DefaultModel;
}
}
MyPlayer player;
if (Sync.Controllers.TryGetPlayer(playerIt.Key, out player))
{
MyCharacter playerEntity;
if (MyEntities.TryGetEntityById<MyCharacter>(playerIt.Value.PlayerEntity, out playerEntity))
{
player.Init(playerEntity, playerIt.Value.PlayerModel, playerIt.Key == Player.SteamUserId ? identityId : playerIt.Value.PlayerId);
}
}
}
}
}*/
}
public bool TryGetCameraSettings(PlayerId pid, long entityId, out MyEntityCameraSettings cameraSettings)
{
MyPlayer client = null;
if (MySandboxGame.IsDedicated)
client = MySession.Static.Players.TryGetPlayerById(pid);
else
client = MySession.LocalHumanPlayer;
if (m_characterCameraSettings != null && client != null && client.Character != null && client.Character.EntityId == entityId)
{
cameraSettings = m_characterCameraSettings;
return true;
}
if (ContainsPlayer(pid) && m_entityCameraSettings[pid].ContainsKey(entityId))
{
return m_entityCameraSettings[pid].TryGetValue(entityId, out cameraSettings);
}
cameraSettings = null;
return false;
}
public void LoadDisconnectedPlayers(Dictionary<MyObjectBuilder_Checkpoint.PlayerId, long> dictionary)
{
foreach (var item in dictionary)
{
var playerId = new PlayerId(item.Key.ClientId, item.Key.SerialId);
m_playerIdentityIds.Add(playerId, item.Value);
}
}
public void SaveCameraCollection(MyObjectBuilder_Checkpoint checkpoint)
{
MyDebug.AssertDebug(checkpoint.AllPlayersData != null, "Players data not initialized!");
if (checkpoint.AllPlayersData == null)
return;
foreach (var playerData in checkpoint.AllPlayersData.Dictionary)
{
PlayerId pid = new PlayerId(playerData.Key.ClientId, playerData.Key.SerialId);
playerData.Value.EntityCameraData = new List<CameraControllerSettings>();
if (!m_entityCameraSettings.ContainsKey(pid))
continue;
m_entitiesToRemove.Clear();
foreach (var cameraSetting in m_entityCameraSettings[pid])
{
if (MyEntities.EntityExists(cameraSetting.Key))
{
CameraControllerSettings settings = new CameraControllerSettings()
{
Distance = cameraSetting.Value.Distance,
IsFirstPerson = cameraSetting.Value.IsFirstPerson,
HeadAngle = cameraSetting.Value.HeadAngle,
EntityId = cameraSetting.Key,
};
playerData.Value.EntityCameraData.Add(settings);
}
else
{
m_entitiesToRemove.Add(cameraSetting.Key);
}
}
foreach (long entityId in m_entitiesToRemove)
m_entityCameraSettings[pid].Remove(entityId);
if (m_characterCameraSettings != null)
{
playerData.Value.CharacterCameraData = new CameraControllerSettings()
{
Distance = m_characterCameraSettings.Distance,
IsFirstPerson = m_characterCameraSettings.IsFirstPerson,
HeadAngle = m_characterCameraSettings.HeadAngle,
};
}
}
}
private void RemovePlayerFromDictionary(PlayerId playerId)
{
m_players.Remove(playerId);
OnPlayersChanged(false, playerId.SteamId);
}
public void SaveEntityCameraSettingsLocally(PlayerId pid, long entityId, bool isFirstPerson, double distance, float headAngleX, float headAngleY)
{
SaveEntityCameraSettings(pid, entityId, isFirstPerson, distance, headAngleX, headAngleY, false);
}
private void AddPlayer(PlayerId playerId, MyPlayer newPlayer)
{
m_players.Add(playerId, newPlayer);
OnPlayersChanged(true, playerId.SteamId);
}
static void OnSaveEntityCameraSettings(ref PlayerSaveEntityCameraSettingsMsg msg, MyNetworkClient sender)
{
PlayerId pid = new PlayerId(sender.SteamUserId, msg.PlayerSerialId);
Vector2 headAngle = new Vector2(msg.HeadX, msg.HeadY);
MyPlayer player = MySession.Static.Players.TryGetPlayerById(pid);
if (player != null && player.Character != null && player.Character.EntityId == msg.EntityId)
MySession.Static.Cameras.AddCharacterCameraData(pid, msg.IsFirstPerson, msg.Distance, headAngle);
else
MySession.Static.Cameras.AddCameraData(pid, msg.EntityId, msg.IsFirstPerson, msg.Distance, headAngle);
}
static void OnControlChangedRequest(MySyncEntity entity, ref ControlChangedMsg msg, MyNetworkClient sender)
{
PlayerId id = new PlayerId(msg.ClientSteamId, msg.PlayerSerialId);
MyTrace.Send(TraceWindow.Multiplayer, "OnControlChanged to entity: " + msg.EntityId, id.ToString());
Sync.Players.SetControlledEntityInternal(id, entity.Entity);
Debug.Assert(sender.SteamUserId == msg.ClientSteamId);
msg.ClientSteamId = sender.SteamUserId;
Sync.Layer.SendMessageToAll(ref msg, MyTransportMessageEnum.Success);
}
