private static void OnStatActionRequest(ref StatActionRequestMsg msg, MyNetworkClient sender)
{
Debug.Assert(Sync.IsServer);
MyEntity entity = null;
if (!MyEntities.TryGetEntityById(msg.EntityId, out entity))
{
return;
}
MyEntityStatComponent statComponent = null;
if (!entity.Components.TryGet <MyEntityStatComponent>(out statComponent))
{
return;
}
StatActionMsg actionMsg = new StatActionMsg()
{
EntityId = msg.EntityId,
StatActions = new Dictionary <string, MyStatLogic.MyStatAction>(),
};
foreach (var script in statComponent.m_scripts)
{
foreach (var actionPair in script.StatActions)
{
if (!actionMsg.StatActions.ContainsKey(actionPair.Key))
{
actionMsg.StatActions.Add(actionPair.Key, actionPair.Value);
}
}
}
MySession.Static.SyncLayer.SendMessage(ref actionMsg, sender.SteamUserId, MyTransportMessageEnum.Success);
}
private static void OnUpdateOxygenLevel(ref UpdateOxygenLevelMsg msg, MyNetworkClient sender)
{
if (!MyEntities.EntityExists(msg.OwnerEntityId))
{
return;
}
IMyInventoryOwner owner = MyEntities.GetEntityById(msg.OwnerEntityId) as IMyInventoryOwner;
MyInventory inv = owner.GetInventory(msg.InventoryIndex);
var item = inv.GetItemByID(msg.ItemId);
if (!item.HasValue)
{
return;
}
var oxygenContainer = item.Value.Content as MyObjectBuilder_OxygenContainerObject;
if (oxygenContainer != null)
{
oxygenContainer.OxygenLevel = msg.OxygenLevel;
inv.UpdateOxygenAmount();
}
}
static void CreateFactionSuccess(ref AddFactionMsg msg, MyNetworkClient sender)
{
MySession.Static.Factions.AddPlayerToFaction(msg.FounderId, msg.FactionId);
MySession.Static.Factions.Add(new MyFaction(
id: msg.FactionId,
tag: msg.FactionTag,
name: msg.FactionName,
desc: msg.FactionDescription,
privateInfo: msg.FactionPrivateInfo,
creatorId: msg.FounderId));
foreach (var entry in MySession.Static.Factions)
{
var faction = entry.Value;
faction.CancelJoinRequest(msg.FounderId);
}
var handler = MySession.Static.Factions.FactionCreated;
if (handler != null)
{
handler(msg.FactionId);
}
}
static void DeleteSuccess(ref DeleteMsg msg, MyNetworkClient sender)
{
Dictionary <int, MyGps> gpsList;
var result = MySession.Static.Gpss.m_playerGpss.TryGetValue(msg.IdentityId, out gpsList);
if (result)
{
MyGps gps;
result = gpsList.TryGetValue(msg.Hash, out gps);
if (result)
{
if (gps.ShowOnHud)
{
MyHud.GpsMarkers.UnregisterMarker(gps);
}
gpsList.Remove(msg.Hash);
var handler = MySession.Static.Gpss.ListChanged;
if (handler != null)
{
handler(msg.IdentityId);
}
}
}
}
static void OnSyncCooldownRequest(ref SyncCooldownRequestMessage msg, MyNetworkClient sender)
{
MySpaceRespawnComponent.Static.SyncCooldownToPlayer(sender.SteamUserId);
}
private static void OnCheckAccessChanged(MySyncButtonPanel syncObject, ref CheckAccessMsg msg, MyNetworkClient sender)
{
syncObject.m_panel.m_anyoneCanUse = msg.CheckAccess;
}
static void OnUpdateSlider(MySyncMotorSuspension sync, ref UpdateSliderMsg msg, MyNetworkClient sender)
{
switch (msg.Slider)
{
case SliderEnum.Height:
sync.Entity.Height = msg.Value;
break;
case SliderEnum.MaxSteerAngle:
sync.Entity.MaxSteerAngle = msg.Value;
break;
case SliderEnum.SteerSpeed:
sync.Entity.SteerSpeed = msg.Value;
break;
case SliderEnum.SteerReturnSpeed:
sync.Entity.SteerReturnSpeed = msg.Value;
break;
case SliderEnum.InvertSteer:
sync.Entity.InvertSteer = msg.Value > 0;
break;
case SliderEnum.SuspensionTravel:
sync.Entity.SuspensionTravel = msg.Value;
break;
}
}
static void OnChangePower(MySyncMotorSuspension sync, ref PowerMsg msg, MyNetworkClient sender)
{
sync.Entity.Power = msg.Power;
}
static void OnChangePropulsion(MySyncMotorSuspension sync, ref PropulsionMsg msg, MyNetworkClient sender)
{
sync.Entity.Propulsion = msg.Propulsion;
}
static void OnChangeDamping(MySyncMotorSuspension sync, ref DampingMsg msg, MyNetworkClient sender)
{
sync.Entity.Damping = msg.Damping;
}
private static void OnFlagsChanged(MySyncCharacter sync, ref ChangeFlagsMsg msg, MyNetworkClient sender)
{
if (MyFakes.CHARACTER_SERVER_SYNC)
{
var handler = sync.FlagsChanged;
if (handler != null)
{
handler(msg.EnableJetpack, msg.EnableDampeners, msg.EnableLights, msg.EnableIronsight, msg.EnableBroadcast);
}
if (Sync.IsServer)
{
Sync.Layer.SendMessageToAll(ref msg);
}
}
else
if (sync.ResponsibleForUpdate(sender))
{
var handler = sync.FlagsChanged;
if (handler != null)
{
handler(msg.EnableJetpack, msg.EnableDampeners, msg.EnableLights, msg.EnableIronsight, msg.EnableBroadcast);
}
}
}
private static void OnSwitchCharacterModel(MySyncCharacter sync, ref SwitchCharacterModelMsg msg, MyNetworkClient sender)
{
if (sync.ResponsibleForUpdate(sender))
{
var handler = sync.CharacterModelSwitched;
if (handler != null)
{
handler(msg.Model, msg.ColorMaskHSV);
}
}
}
private static void OnAnimationCommand(MySyncCharacter sync, ref AnimationCommandMsg msg, MyNetworkClient sender)
{
sync.Entity.AddCommand(new MyAnimationCommand()
{
AnimationSubtypeName = msg.AnimationSubtypeName,
Mode = msg.Mode,
Area = msg.Area,
BlendTime = msg.BlendTime,
TimeScale = msg.TimeScale,
Loop = msg.Loop
});
}
private static void OnMovementStateChanged(MySyncCharacter sync, ref ChangeMovementStateMsg msg, MyNetworkClient sender)
{
if (sync.ResponsibleForUpdate(sender))
{
var handler = sync.MovementStateChanged;
if (handler != null)
{
handler(msg.MovementState);
}
}
}
private static void OnRagdollTransformsUpdate(MySyncCharacter syncObject, ref RagdollTransformsMsg message, MyNetworkClient sender)
{
if (syncObject.Entity.Physics == null)
{
return;
}
if (syncObject.Entity.Physics.Ragdoll == null)
{
return;
}
if (syncObject.Entity.RagdollMapper == null)
{
return;
}
if (!syncObject.Entity.Physics.Ragdoll.IsAddedToWorld)
{
return;
}
if (!syncObject.Entity.RagdollMapper.IsActive)
{
return;
}
Debug.Assert(message.worldOrientation != null && message.worldOrientation != Quaternion.Zero, "Received invalid ragdoll orientation from server!");
Debug.Assert(message.worldPosition != null && message.worldPosition != Vector3.Zero, "Received invalid ragdoll orientation from server!");
Debug.Assert(message.transformsOrientations != null && message.transformsPositions != null, "Received empty ragdoll transformations from server!");
Debug.Assert(message.transformsPositions.Count() == message.TransformsCount && message.transformsOrientations.Count() == message.TransformsCount, "Received ragdoll data count doesn't match!");
Matrix worldMatrix = Matrix.CreateFromQuaternion(message.worldOrientation);
worldMatrix.Translation = message.worldPosition;
Matrix[] transforms = new Matrix[message.TransformsCount];
for (int i = 0; i < message.TransformsCount; ++i)
{
transforms[i] = Matrix.CreateFromQuaternion(message.transformsOrientations[i]);
transforms[i].Translation = message.transformsPositions[i];
}
syncObject.Entity.RagdollMapper.UpdateRigidBodiesTransformsSynced(message.TransformsCount, worldMatrix, transforms);
}
public bool TryGetClient(ulong steamId, out MyNetworkClient client)
{
client = null;
return(m_clients.TryGetValue(steamId, out client));
}
static void OnChangeControllable(MySyncMotorSuspension sync, ref SteeringMsg msg, MyNetworkClient sender)
{
sync.Entity.Steering = msg.Steering;
}
private static void OnCharacterInput(MySyncCharacter sync, ref CharacterInputMsg msg, MyNetworkClient sender)
{
sender.ClientFrameId = msg.ClientFrameId;
sync.CachedMovementState = msg;
var matrix = MatrixD.CreateFromQuaternion(msg.Orientation);
matrix.Translation = msg.Position;
sync.Entity.WorldMatrix = matrix;
if (Sync.IsServer)
{
Sync.Layer.SendMessageToAllButOne(ref msg, sender.SteamUserId);
}
}
static void OnChangeStrength(MySyncMotorSuspension sync, ref StrengthMsg msg, MyNetworkClient sender)
{
sync.Entity.Strength = msg.Strength;
}
private static void OnHeadOrSpineChanged(MySyncCharacter sync, ref ChangeHeadOrSpineMsg msg, MyNetworkClient sender)
{
if (sync.ResponsibleForUpdate(sender))
{
var handler = sync.HeadOrSpineChanged;
if (handler != null)
{
handler(msg.HeadLocalXAngle, msg.HeadLocalYAngle,
msg.AdditionalSpineRotation, msg.AdditionalHeadRotation, msg.AdditionalHandRotation, msg.AdditionalUpperHandRotation);
}
}
}
static void OnChangeFriction(MySyncMotorSuspension sync, ref FrictionMsg msg, MyNetworkClient sender)
{
sync.Entity.Friction = msg.Friction;
}
static void OnAttachToCockpit(MySyncCharacter sync, ref AttachToCockpitMsg msg, MyNetworkClient sender)
{
MyCharacter character = sync.Entity;
MyCockpit cockpit = MyEntities.GetEntityById(msg.CockpitEntityId) as MyCockpit;
Debug.Assert(cockpit != null);
if (cockpit == null)
{
return;
}
cockpit.AttachPilot(character, false);
}
static void OnUpdateSteer(MySyncMotorSuspension sync, ref SteerMsg msg, MyNetworkClient sender)
{
sync.Entity.SteerAngle = msg.Steer;
}
private static void OnPlayerMessageRequest(MySyncCharacter sync, ref SendPlayerMessageMsg msg, MyNetworkClient sender)
{
//Ignore messages that have improper lengths
if (msg.Text.Length == 0 || msg.Text.Length > MyChatConstants.MAX_CHAT_STRING_LENGTH)
{
return;
}
var receiverId = MySession.Static.Players.TryGetPlayerIdentity(new MyPlayer.PlayerId(msg.ReceiverSteamId));
var senderId = MySession.Static.Players.TryGetPlayerIdentity(new MyPlayer.PlayerId(msg.SenderSteamId));
//TODO(AF) Check if message was already received
if (receiverId != null && receiverId.Character != null && senderId != null && senderId.Character != null && MyAntennaSystem.CheckConnection(senderId, receiverId))
{
Sync.Layer.SendMessage(ref msg, msg.ReceiverSteamId, MyTransportMessageEnum.Success);
Sync.Layer.SendMessage(ref msg, sender.SteamUserId, MyTransportMessageEnum.Success);
//Save chat history on server for non-server players
if (receiverId.Character != MySession.LocalCharacter)
{
MyChatSystem.AddPlayerChatItem(receiverId.IdentityId, senderId.IdentityId, new MyPlayerChatItem(msg.Text, senderId.IdentityId, msg.Timestamp, true));
}
if (senderId.Character != MySession.LocalCharacter)
{
MyChatSystem.AddPlayerChatItem(senderId.IdentityId, receiverId.IdentityId, new MyPlayerChatItem(msg.Text, senderId.IdentityId, msg.Timestamp, true));
}
}
}
private static void OnToolbarItemChanged(MySyncButtonPanel sync, ref ChangeToolbarItemMsg msg, MyNetworkClient sender)
{
sync.m_syncing = true;
MyToolbarItem item = null;
if (msg.Item.EntityID != 0)
{
if (string.IsNullOrEmpty(msg.Item.GroupName))
{
MyTerminalBlock block;
if (MyEntities.TryGetEntityById <MyTerminalBlock>(msg.Item.EntityID, out block))
{
var builder = MyToolbarItemFactory.TerminalBlockObjectBuilderFromBlock(block);
builder.Action = msg.Item.Action;
item = MyToolbarItemFactory.CreateToolbarItem(builder);
}
}
else
{
MyButtonPanel parent;
if (MyEntities.TryGetEntityById <MyButtonPanel>(msg.Item.EntityID, out parent))
{
var grid = parent.CubeGrid;
var groupName = msg.Item.GroupName;
var group = grid.GridSystems.TerminalSystem.BlockGroups.Find((x) => x.Name.ToString() == groupName);
if (group != null)
{
var builder = MyToolbarItemFactory.TerminalGroupObjectBuilderFromGroup(group);
builder.Action = msg.Item.Action;
builder.BlockEntityId = msg.Item.EntityID;
item = MyToolbarItemFactory.CreateToolbarItem(builder);
}
}
}
}
sync.m_panel.Toolbar.SetItemAtIndex(msg.Index, item);
sync.m_syncing = false;
}
private static void OnPlayerMessageSuccess(MySyncCharacter sync, ref SendPlayerMessageMsg msg, MyNetworkClient sender)
{
var receiverId = MySession.Static.Players.TryGetPlayerIdentity(new MyPlayer.PlayerId(msg.ReceiverSteamId));
var senderId = MySession.Static.Players.TryGetPlayerIdentity(new MyPlayer.PlayerId(msg.SenderSteamId));
if (receiverId != null && receiverId.Character != null && senderId != null && senderId.Character != null)
{
if (receiverId.Character == MySession.LocalCharacter && receiverId.Character != senderId.Character)
{
MyChatSystem.AddPlayerChatItem(receiverId.IdentityId, senderId.IdentityId, new MyPlayerChatItem(msg.Text, senderId.IdentityId, msg.Timestamp, true));
MySession.Static.ChatSystem.OnNewPlayerMessage(senderId.IdentityId, senderId.IdentityId);
MySession.Static.Gpss.ScanText(msg.Text, MyTexts.GetString(MySpaceTexts.TerminalTab_GPS_NewFromPrivateComms));
}
else
{
MyChatSystem.SetPlayerChatItemSent(senderId.IdentityId, receiverId.IdentityId, msg.Text, new TimeSpan(msg.Timestamp), true);
MySession.Static.ChatSystem.OnNewPlayerMessage(receiverId.IdentityId, senderId.IdentityId);
}
}
}
private static void OnButtonCustomNameChanged(MySyncButtonPanel syncObject, ref SetCustomButtonName msg, MyNetworkClient sender)
{
syncObject.m_panel.SetButtonName(msg.CustomName, msg.Index);
}
private static void OnFactionMessageRequest(MySyncCharacter sync, ref SendNewFactionMessageMsg msg, MyNetworkClient sender)
{
//Ignore messages that have improper lengths
if (msg.ChatItem.Text.Length == 0 || msg.ChatItem.Text.Length > MyChatConstants.MAX_CHAT_STRING_LENGTH)
{
return;
}
long currentSenderId = MyEntityIdentifier.ConstructId(MyEntityIdentifier.ID_OBJECT_TYPE.IDENTITY, msg.ChatItem.IdentityIdUniqueNumber);
var senderId = MySession.Static.Players.TryGetIdentity(currentSenderId);
var chatItem = new MyFactionChatItem();
chatItem.Init(msg.ChatItem);
//Find all members that can receive this messages
m_tempValidIds.Clear();
for (int i = 0; i < msg.ChatItem.PlayersToSendToUniqueNumber.Count; i++)
{
if (!msg.ChatItem.IsAlreadySentTo[i])
{
long receiverIdentityId = MyEntityIdentifier.ConstructId(MyEntityIdentifier.ID_OBJECT_TYPE.IDENTITY, msg.ChatItem.PlayersToSendToUniqueNumber[i]);
var receiverId = MySession.Static.Players.TryGetIdentity(receiverIdentityId);
if (receiverId != null && receiverId.Character != null && MyAntennaSystem.CheckConnection(senderId, receiverId))
{
m_tempValidIds.Add(receiverIdentityId);
}
}
}
//Set their sent flag to true, so that everyone knows they already got it (no need for confirm message)
foreach (var id in m_tempValidIds)
{
chatItem.PlayersToSendTo[id] = true;
}
//Save the flags back in the message
msg.ChatItem = chatItem.GetObjectBuilder();
//Send success message back to all recepient members
foreach (var id in m_tempValidIds)
{
MyPlayer.PlayerId receiverPlayerId;
MySession.Static.Players.TryGetPlayerId(id, out receiverPlayerId);
ulong steamId = receiverPlayerId.SteamId;
Sync.Layer.SendMessage(ref msg, steamId, MyTransportMessageEnum.Success);
}
//Save chat history on server for non-server players
if (senderId.Character != MySession.LocalCharacter)
{
MyChatSystem.AddFactionChatItem(senderId.IdentityId, msg.FactionId1, msg.FactionId2, chatItem);
}
}
static void OnSyncCooldownResponse(ref SyncCooldownResponseMessage msg, MyNetworkClient sender)
{
msg = MySpaceRespawnComponent.Static.SyncCooldownResponse(msg);
}
private static void OnFactionMessageSuccess(MySyncCharacter sync, ref SendNewFactionMessageMsg msg, MyNetworkClient sender)
{
long senderIdentityId = MyEntityIdentifier.ConstructId(MyEntityIdentifier.ID_OBJECT_TYPE.IDENTITY, msg.ChatItem.IdentityIdUniqueNumber);
var factionChatItem = new MyFactionChatItem();
factionChatItem.Init(msg.ChatItem);
if (!(Sync.IsServer && senderIdentityId != MySession.LocalPlayerId))
{
MyChatSystem.AddFactionChatItem(MySession.LocalPlayerId, msg.FactionId1, msg.FactionId2, factionChatItem);
}
if (senderIdentityId != MySession.LocalPlayerId)
{
MySession.Static.Gpss.ScanText(factionChatItem.Text, MyTexts.GetString(MySpaceTexts.TerminalTab_GPS_NewFromFactionComms));
}
MySession.Static.ChatSystem.OnNewFactionMessage(msg.FactionId1, msg.FactionId2, senderIdentityId, true);
}
