protected override float GetGroupPriority(int frameCountWithoutSync, MyClientInfo client, PrioritySettings settings) { const float HighQualityDistance = 8; // under 8m, character physics sync gets high priority to have smooth movement var clientPos = ((MyClientState)client.State).Position; var characterPos = Entity.PositionComp.GetPosition(); bool isHighQuality = Vector3D.DistanceSquared(clientPos, characterPos) < HighQualityDistance * HighQualityDistance; isHighQuality = isHighQuality && !Entity.IsDead; var priority = base.GetGroupPriority(frameCountWithoutSync, client, isHighQuality ? m_highQuality : settings); return priority; }
protected override float GetGroupPriority(int frameCountWithoutSync, MyClientInfo client, PrioritySettings settings) { const float HighQualityDistance = 20; // under 8m, character physics sync gets high priority to have smooth movement if (ResponsibleForUpdate(Entity, client.EndpointId)) { return(0.0f); } var clientPos = ((MyClientState)client.State).Position; var characterPos = Entity.PositionComp.GetPosition(); bool isHighQuality = Vector3D.DistanceSquared(clientPos, characterPos) < HighQualityDistance * HighQualityDistance; var priority = base.GetGroupPriority(frameCountWithoutSync, client, isHighQuality ? m_highQuality : settings); return(priority); }
public override float GetPriority(MyClientInfo client, bool cached) { Debug.Assert(!IsChild); MyEntity owner = Inventory.Owner.GetTopMostParent(); if (owner != m_owner) { m_owner = owner; m_parent = MyExternalReplicable.FindByObject(owner); } if (m_parent != null && client.HasReplicable(m_parent)) { return(1.0f); } return(0.0f); }
protected override float GetGroupPriority(int frameCountWithoutSync, MyClientInfo client, PrioritySettings settings) { if (Entity.MarkedForClose) { return(0.0f); } if (Entity != GetMasterGrid(Entity)) { return(0); } //support has allways high priority if (client.State.SupportId.HasValue && client.State.SupportId.Value == Entity.EntityId && IsMoving(Entity)) { return(1000.0f); } return(base.GetGroupPriority(frameCountWithoutSync, client, settings)); }
public float GetBasePriority(Vector3 position, Vector3 size, MyClientInfo client) { float planeArea = Math.Max(size.X * size.Y, Math.Max(size.X * size.Z, size.Y * size.Z)) + 0.01f; float distSq = (float)Vector3D.DistanceSquared(((MyClientState)client.State).Position, position); // Anything bigger than this will behave like it's only this size, it will be hidden anyway by view distance limit //float planeAreaMaxSqrt = MyMultiplayer.ReplicationDistance / baseVisibility; //MathHelper.Clamp(planeArea, 0.1f, planeAreaMaxSqrt * planeAreaMaxSqrt); if (distSq > MyMultiplayer.ReplicationDistance * MyMultiplayer.ReplicationDistance) { return(0); } float relativeDistance = (float)Math.Sqrt(distSq / planeArea); // How far the object would be when recalculated to 1m size float ratio = relativeDistance / m_baseVisibility; // 0 very close; 1 at the edge of visibility; >1 too far return(MathHelper.Clamp(1 - ratio, 0, 1)); }
public void Serialize(BitStream stream, MyClientInfo forClient, MyTimeSpan serverTimestamp, MyTimeSpan lastClientTimestamp, byte packetId, int maxBitPosition, HashSet <string> cachedData) { var endpoint = forClient.EndpointId; if (!stream.Writing) { return; } if (!_serverData.TryGetValue(endpoint, out var data)) { var bits = new SmallBitField(false); stream.WriteUInt64(bits.Bits, 0); return; } var dirtyProperties = data.DirtyProperties; if (!data.HasRights) { dirtyProperties[VOLUME_PROP_INDEX] = false; } stream.WriteUInt64(dirtyProperties.Bits, m_properties.Count); for (var i = 0; i < m_properties.Count; i++) { if (!dirtyProperties[i]) { continue; } var milliseconds = m_propertyTimestamps[i].Milliseconds; stream.WriteDouble(milliseconds); m_properties[i].Serialize(stream, false); } if (stream.BitPosition <= maxBitPosition) { var dataPerClient = _serverData[endpoint]; dataPerClient.SentProperties[packetId].Bits = dataPerClient.DirtyProperties.Bits; dataPerClient.DirtyProperties.Bits = 0UL; } }
public override float GetPriority(MyClientInfo client, bool cached) { if (m_clientList.Contains(client.EndpointId.Value)) { return(1.0f); } if (Inventory.Entity is MyCharacter) { MyPlayer player = MyPlayer.GetPlayerFromCharacter(Inventory.Entity as MyCharacter); if (player != null && player.Id.SteamId == client.EndpointId.Value) { m_clientList.Add(client.EndpointId.Value); return(1.0f); } } return(0.0f); }
public override float GetPriority(MyClientInfo state) { if (Grid == null || Grid.Projector != null || Grid.IsPreview) { return(0.0f); } float priority = base.GetPriority(state); if (priority == 0.0f) { MyPlayerCollection playerCollection = MySession.Static.Players; var connectedPlayers = playerCollection.GetOnlinePlayers(); foreach (var player in connectedPlayers) { if (player.Client.SteamUserId == state.EndpointId.Value && player.Character != null) { var broadcasters = player.Character.RadioReceiver.GetRelayedBroadcastersForPlayer(player.Identity.IdentityId); foreach (var broadcaster in broadcasters) { var cubeblock = broadcaster.Entity as MyCubeBlock; if (cubeblock != null && cubeblock.CubeGrid == Grid) { return(0.1f); // Minimal priority, update, but not that often } } } } } if (MyFakes.ENABLE_SENT_GROUP_AT_ONCE) { MyCubeGrid master = MyGridPhysicsStateGroup.GetMasterGrid(Grid); if (master != Grid) { return(MyExternalReplicable.FindByObject(master).GetPriority(state)); } } return(priority); }
public float GetGroupPriority(int frameCountWithoutSync, MyClientInfo forClient) { // Called only on server if (Entity.Physics == null || Entity.Physics.IsStatic) { return(0); } if (Sync.IsServer && m_clientUpdateFlag[forClient.EndpointId.Value] == false) { return(0); } if (MyEntityPhysicsStateGroup.ResponsibleForUpdate(Entity, forClient.EndpointId)) { return(1); } return(0); }
public override float GetPriority(MyClientInfo client) { var spaceClient = client.State as MySpaceClientState; Debug.Assert(spaceClient != null); long planetId = Instance.Planet.EntityId; HashSet <MyPlanetSectorId> sectors; if (spaceClient.KnownSectors.TryGetValue(planetId, out sectors)) { if (sectors.Contains(Instance.SectorId)) { return(1.0f); } } return(0f); }
public override float GetPriority(MyClientInfo client, bool cached) { ulong clientEndpoint = client.EndpointId.Value; if (cached) { if (m_cachedPriorityForClient != null && m_cachedPriorityForClient.ContainsKey(clientEndpoint)) { return(m_cachedPriorityForClient[clientEndpoint]); } } if (m_cachedPriorityForClient == null) { m_cachedPriorityForClient = new Dictionary <ulong, float>(); } m_cachedPriorityForClient[clientEndpoint] = GetBasePriority(Instance.PositionComp.GetPosition(), Instance.PositionComp.WorldAABB.Size, client); return(m_cachedPriorityForClient[clientEndpoint]); }
public float GetBasePriority(Vector3D position, Vector3D size, MyClientInfo client) { System.Diagnostics.Debug.Assert(!HasToBeChild, "Priority is irrelevant for children. Use parent priority"); double planeArea = Math.Max(size.X * size.Y, Math.Max(size.X * size.Z, size.Y * size.Z)) + 0.01; double distSq = Vector3D.DistanceSquared(((MyClientState)client.State).Position, position); // Anything bigger than this will behave like it's only this size, it will be hidden anyway by view distance limit //float planeAreaMaxSqrt = MyMultiplayer.ReplicationDistance / baseVisibility; //MathHelper.Clamp(planeArea, 0.1f, planeAreaMaxSqrt * planeAreaMaxSqrt); if (distSq > MyMultiplayer.ReplicationDistance * MyMultiplayer.ReplicationDistance) { return(0); } float relativeDistance = (float)Math.Sqrt(distSq / planeArea); // How far the object would be when recalculated to 1m size float ratio = relativeDistance / BaseVisibility; // 0 very close; 1 at the edge of visibility; >1 too far return(MathHelper.Clamp(1 - ratio, 0.1f, 1)); }
public override float GetPriority(MyClientInfo client) { if (m_clientList == null) { m_clientList = new HashSet <ulong>(); } if (m_clientList.Contains(client.EndpointId.Value)) { return(1.0f); } MyEntity owner = Inventory.Owner.GetTopMostParent(); var parent = MyExternalReplicable.FindByObject(owner); if (parent != null && client.HasReplicable(parent)) { m_clientList.Add(client.EndpointId.Value); return(1.0f); } return(0.0f); }
public float GetGroupPriority(int frameCountWithoutSync, MyClientInfo forClient) { StreamClientData clientData = m_clientStreamData[forClient.EndpointId.Value]; if (forClient.IsReplicableReady(Instance as IMyReplicable)) { clientData.CurrentPart = 0; clientData.ForceSend = false; clientData.ObjectData = null; clientData.FailedIncompletePackets.Clear(); clientData.SendPackets.Clear(); return(0.0f); } float priority = forClient.HasReplicable(Instance as IMyReplicable) && clientData.Dirty ? Instance.GetPriority(forClient) * Instance.PriorityScale() : 0.0f; if (priority < 0.01f && (clientData.ForceSend || clientData.FailedIncompletePackets.Count > 0)) { priority = Instance.PriorityScale(); } return(priority); }
public float GetPriorityStateGroup(MyClientInfo client) { MyClientState state = (MyClientState)client.State; if (Inventory.ForcedPriority.HasValue) { return(Inventory.ForcedPriority.Value); } if (state.ContextEntity != null) { if (state.ContextEntity == Inventory.Owner) { return(1.0f); } else { MyCubeGrid parent = state.ContextEntity.GetTopMostParent() as MyCubeGrid; if (parent != null) { foreach (var block in parent.GridSystems.TerminalSystem.Blocks) { if (block == Inventory.Container.Entity) { if (state.Context == Sandbox.Engine.Multiplayer.MyClientState.MyContextKind.Production && (block is MyAssembler) == false) { continue; } return(1.0f); } } } } } return(0); }
/// <summary> /// Gets group priority, when overloaded it can be useful to scale base priority. /// </summary> public virtual float GetGroupPriority(int frameCountWithoutSync, MyClientInfo client) { if (m_properties.Count == 0) { return(0); } // Called only on server float priority = client.GetPriority(Owner); if (priority <= 0) { return(0); } if (m_clientData[client.State].DirtyProperties.Bits > 0 && m_clientData[client.State].PacketId == null) { return(PriorityAdjust(frameCountWithoutSync, client.State, priority)); } else { return(0); } }
public override float GetPriority(MyClientInfo state) { float priority = 0.0f; if (Instance == null || state.State == null) { return(priority); } var player = state.State.GetPlayer(); if (player != null && player.Character == Instance) { priority = 1.0f; } else { priority = base.GetPriority(state); } if (Instance.IsUsing is MyShipController) { if (priority < 0.01f) { //force pilot to client wve when its too far away. var parent = MyExternalReplicable.FindByObject((Instance.IsUsing as MyShipController).CubeGrid); if (state.HasReplicable(parent)) { priority = 1.0f; } } } return(priority); }
public override float GetPriority(MyClientInfo state, bool cached) { if (Grid == null || Grid.Projector != null || Grid.IsPreview) { return(0.0f); } if (MyFakes.MP_ISLANDS) { var parent = Instance.GetTopMostParent(); BoundingBoxD aabb; if (MyIslandSyncComponent.Static.GetIslandAABBForEntity(parent, out aabb)) { var ipriority = GetBasePriority(aabb.Center, aabb.Size, state); MyIslandSyncComponent.Static.SetPriorityForIsland(Instance, state.EndpointId.Value, ipriority); return(ipriority); } } ulong clientEndpoint = state.EndpointId.Value; if (cached) { if (m_cachedPriorityForClient != null && m_cachedPriorityForClient.ContainsKey(clientEndpoint)) { return(m_cachedPriorityForClient[clientEndpoint]); } } if (m_cachedPriorityForClient == null) { m_cachedPriorityForClient = new Dictionary <ulong, float>(); } float priority = base.GetPriority(state, cached); m_cachedPriorityForClient[clientEndpoint] = priority; if (priority < 0.1f) { if (m_clientState == null) { m_clientState = new Dictionary <ulong, int>(); } if (m_clientState.ContainsKey(clientEndpoint)) { m_clientState[state.EndpointId.Value]++; } else { m_clientState[state.EndpointId.Value] = 0; } if (m_clientState[state.EndpointId.Value] % ANTENNA_UPDATE_TIME == 0) { m_clientState[state.EndpointId.Value] = 0; MyPlayerCollection playerCollection = MySession.Static.Players; var connectedPlayers = playerCollection.GetOnlinePlayers(); foreach (var player in connectedPlayers) { if (player.Client.SteamUserId == state.EndpointId.Value && player.Character != null) { var broadcasters = player.Character.RadioReceiver.GetRelayedBroadcastersForPlayer(player.Identity.IdentityId); foreach (var broadcaster in broadcasters) { var cubeblock = broadcaster.Entity as MyCubeBlock; if (cubeblock != null && cubeblock.CubeGrid == Grid) { m_cachedPriorityForClient[clientEndpoint] = 0.1f; return(m_cachedPriorityForClient[clientEndpoint]); // Minimal priority, update, but not that often } } } } } else { return(m_cachedPriorityForClient[clientEndpoint]); } } return(priority); }
/// <summary> /// Gets group priority, when overloaded it can be useful to scale base priority. /// </summary> public virtual float GetGroupPriority(int frameCountWithoutSync, MyClientInfo client) { if (m_properties.Count == 0) { return 0; } if (client.HasReplicable(Owner) == false) { return 0; } // Called only on server float priority = client.GetPriority(Owner); if (priority <= 0) return 0; if (m_clientData[client.State.EndpointId].DirtyProperties.Bits > 0 && m_clientData[client.State.EndpointId].PacketId == null) return PriorityAdjust(frameCountWithoutSync, client.State, priority); else return 0; }
public abstract float GetPriority(MyClientInfo client,bool cached);
public float GetGroupPriority(int frameCountWithoutSync, MyClientInfo forClient) { // Called only on server if (Entity.Physics == null || Entity.Physics.IsStatic) return 0; if (MyEntityPhysicsStateGroup.ResponsibleForUpdate(Entity, forClient.EndpointId)) { return 1000; } return 0; }
public float GetPriorityStateGroup(MyClientInfo client) { MyClientState state = (MyClientState)client.State; if (Inventory.ForcedPriority.HasValue) { return Inventory.ForcedPriority.Value; } if (state.ContextEntity != null) { if (state.ContextEntity == Inventory.Owner) { return 1.0f; } else { MyCubeGrid parent = state.ContextEntity.GetTopMostParent() as MyCubeGrid; if (parent != null) { foreach (var block in parent.GridSystems.TerminalSystem.Blocks) { if (block == Inventory.Container.Entity) { if (state.Context == Sandbox.Engine.Multiplayer.MyClientState.MyContextKind.Production && (block is MyAssembler) == false) { continue; } return 1.0f; } } } } } return 0; }
public float GetGroupPriority(int frameCountWithoutSync, MyClientInfo client) { InventoryClientData clientData = m_clientInventoryUpdate[client.EndpointId.Value]; List<MyPhysicalInventoryItem> items = Inventory.GetItems(); if (clientData.Dirty == false && clientData.FailedIncompletePackets.Count == 0) { return 0.0f; } if (clientData.FailedIncompletePackets.Count > 0) { return 1.0f * frameCountWithoutSync; } MyClientState state = (MyClientState)client.State; if (Inventory.Owner is MyCharacter) { MyCharacter character = Inventory.Owner as MyCharacter; MyPlayer player = MyPlayer.GetPlayerFromCharacter(character); if (player == null && character.IsUsing != null) { MyShipController cockpit = (character.IsUsing as MyShipController); if (cockpit != null && cockpit.ControllerInfo.Controller != null) { player = cockpit.ControllerInfo.Controller.Player; } } if (player != null && player.Id.SteamId == client.EndpointId.Value) { return 1.0f * frameCountWithoutSync; } } if (state.ContextEntity is MyCharacter && state.ContextEntity == Inventory.Owner) { return 1.0f * frameCountWithoutSync; } if (state.Context == MyClientState.MyContextKind.Inventory || state.Context == MyClientState.MyContextKind.Building || (state.Context == MyClientState.MyContextKind.Production && Inventory.Owner is MyAssembler)) { return GetPriorityStateGroup(client) * frameCountWithoutSync; } return 0; }
public override float GetPriority(MyClientInfo client, bool cached) { // TODO: This can be adjusted, but for now, make sure it is always created on clients return(1.0f); }
public abstract float GetPriority(MyClientInfo client);
protected override float GetGroupPriority(int frameCountWithoutSync, MyClientInfo client, PrioritySettings settings) { if (Entity.MarkedForClose) { return 0.0f; } if (Entity != GetMasterGrid(Entity)) return 0; return base.GetGroupPriority(frameCountWithoutSync, client, settings); }
public abstract float GetPriority(MyClientInfo client, bool cached);
public override float GetPriority(MyClientInfo client) { return(500.0f); }
protected override float GetGroupPriority(int frameCountWithoutSync, MyClientInfo client, PrioritySettings settings) { if (Entity.MarkedForClose) { return 0.0f; } if (Entity != GetMasterGrid(Entity)) return 0; //support has allways high priority if (client.State.SupportId.HasValue && client.State.SupportId.Value == Entity.EntityId && IsMoving(Entity)) { return 1000.0f; } return base.GetGroupPriority(frameCountWithoutSync, client, settings); }
public override float GetPriority(MyClientInfo state, bool cached) { float priority = 0.0f; if (Instance == null || state.State == null) { return(priority); } ulong clientEndpoint = state.EndpointId.Value; if (cached) { if (m_cachedPriorityForClient != null && m_cachedPriorityForClient.ContainsKey(clientEndpoint)) { return(m_cachedPriorityForClient[clientEndpoint]); } } if (m_cachedPriorityForClient == null) { m_cachedPriorityForClient = new Dictionary <ulong, float>(); } var player = state.State.GetPlayer(); if (player != null && player.Character == Instance) { priority = 1.0f; } else { //Sync all characters now, as they can serve as antenna relay priority = 0.1f; //priority = base.GetPriority(state, cached); } if (Instance.IsUsing is MyShipController) { //Pilot cannot have higher priority than the grid they control. Otherwise bugs ensue var parent = MyExternalReplicable.FindByObject((Instance.IsUsing as MyShipController).CubeGrid); if (state.HasReplicable(parent)) { priority = parent.GetPriority(state, cached); } else { priority = 0.0f; } } if (MyFakes.MP_ISLANDS) { BoundingBoxD aabb; if (player.Character != null) { if (MyIslandSyncComponent.Static.GetIslandAABBForEntity(player.Character, out aabb)) { var ipriority = GetBasePriority(aabb.Center, aabb.Size, state); MyIslandSyncComponent.Static.SetPriorityForIsland(player.Character, state.EndpointId.Value, ipriority); return(ipriority); } } } m_cachedPriorityForClient[clientEndpoint] = priority; return(priority); }
public override float GetPriority(MyClientInfo client) { return(GetBasePriority(Instance.PositionComp.GetPosition(), Instance.PositionComp.WorldAABB.Size, client)); }
public override float GetPriority(MyClientInfo client, bool cached) { System.Diagnostics.Debug.Fail("Cannot call GetPriority on children"); return(0); }
public override float GetPriority(MyClientInfo client) { Debug.Fail("Getting priority of child replicable: MyTerminalReplicable"); return(0); // This is child replicable }
public override float GetPriority(MyClientInfo state, bool cached) { if (Grid == null || Grid.Projector != null || Grid.IsPreview) { return(0.0f); } ulong clientEndpoint = state.EndpointId.Value; if (cached) { if (m_cachedPriorityForClient != null && m_cachedPriorityForClient.ContainsKey(clientEndpoint)) { return(m_cachedPriorityForClient[clientEndpoint]); } } if (m_cachedPriorityForClient == null) { m_cachedPriorityForClient = new Dictionary <ulong, float>(); } float priority = base.GetPriority(state, cached); m_cachedPriorityForClient[clientEndpoint] = priority; if (priority < 0.1f) { if (m_clientState == null) { m_clientState = new Dictionary <ulong, int>(); } if (m_clientState.ContainsKey(clientEndpoint)) { m_clientState[state.EndpointId.Value]++; } else { m_clientState[state.EndpointId.Value] = 0; } if (m_clientState[state.EndpointId.Value] % ANTENNA_UPDATE_TIME == 0) { m_clientState[state.EndpointId.Value] = 0; MyPlayerCollection playerCollection = MySession.Static.Players; var connectedPlayers = playerCollection.GetOnlinePlayers(); foreach (var player in connectedPlayers) { if (player.Client.SteamUserId == state.EndpointId.Value && player.Character != null) { var broadcasters = player.Character.RadioReceiver.GetRelayedBroadcastersForPlayer(player.Identity.IdentityId); foreach (var broadcaster in broadcasters) { var cubeblock = broadcaster.Entity as MyCubeBlock; if (cubeblock != null && cubeblock.CubeGrid == Grid) { m_cachedPriorityForClient[clientEndpoint] = 0.1f; return(m_cachedPriorityForClient[clientEndpoint]); // Minimal priority, update, but not that often } } } } } else { return(m_cachedPriorityForClient[clientEndpoint]); } } if (MyFakes.ENABLE_SENT_GROUP_AT_ONCE) { MyCubeGrid master = MyGridPhysicsStateGroup.GetMasterGrid(Grid); if (master != Grid) { return(MyExternalReplicable.FindByObject(master).GetPriority(state, cached)); } } return(priority); }
/// <summary> /// Takes into account: /// Static body (zero priority for static), /// ResponsibilityForUpdate by client (zero priority for not responsible), /// otherwise returns OwnerReplicable priority. /// </summary> protected float GetBasicPhysicsPriority(MyClientInfo client) { // Called only on server if (Entity.Physics == null || Entity.Physics.IsStatic || ResponsibleForUpdate(client.EndpointId)) return 0; return client.GetPriority(OwnerReplicable); }
/// <summary> /// Takes into account: /// Static body (zero priority for static), /// ResponsibilityForUpdate by client (zero priority for not responsible), /// otherwise returns OwnerReplicable priority. /// </summary> protected float GetBasicPhysicsPriority(MyClientInfo client) { // Called only on server if (Entity.Physics == null || Entity.Physics.IsStatic) return 0; return client.GetPriority(OwnerReplicable); }
protected virtual float GetGroupPriority(int frameCountWithoutSync, MyClientInfo client, PrioritySettings settings) { float priority = GetBasicPhysicsPriority(client); if (priority <= 0) return 0; float updateFrameCount; priority *= GetMovementScale(settings, out updateFrameCount); return MyReplicationHelpers.RampPriority(priority, frameCountWithoutSync, updateFrameCount); }
float IMyStateGroup.GetGroupPriority(int frameCountWithoutSync, MyClientInfo client) { return(GetGroupPriority(frameCountWithoutSync, client, m_prioritySettings)); }
float IMyStateGroup.GetGroupPriority(int frameCountWithoutSync, MyClientInfo client) { return GetGroupPriority(frameCountWithoutSync, client, m_prioritySettings); }