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 abstract float GetPriority(MyClientInfo client);
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);
}
