public static bool ColorGridOrBlockRequestValidationPatch(MyCubeGrid __instance, ref bool __result, long player)
{
if (player == 0L || !Sandbox.Game.Multiplayer.Sync.IsServer || __instance.BigOwners.Count == 0)
{
__result = true;
}
else
{
foreach (long bigOwner in __instance.BigOwners)
{
MyRelationsBetweenPlayerAndBlock relationPlayerBlock = MyIDModule.GetRelationPlayerBlock(bigOwner, player, MyOwnershipShareModeEnum.Faction, MyRelationsBetweenPlayerAndBlock.Enemies, MyRelationsBetweenFactions.Enemies, MyRelationsBetweenPlayerAndBlock.FactionShare);
if (relationPlayerBlock == MyRelationsBetweenPlayerAndBlock.Owner ||
relationPlayerBlock == MyRelationsBetweenPlayerAndBlock.FactionShare ||
relationPlayerBlock == MyRelationsBetweenPlayerAndBlock.NoOwnership)
{
__result = true;
break;
}
}
}
// Stop the original method from running
return(false);
}
private void CheckAdminRights()
{
const string spider = "Space_spider";
const string wolf = "SpaceWolf";
foreach (var item in Players)
{
var pLevel = item.Value.PromoteLevel;
var playerId = item.Key;
var player = item.Value;
var wasAdmin = Admins.ContainsKey(playerId);
if (pLevel == MyPromoteLevel.Admin || pLevel == MyPromoteLevel.Owner || pLevel == MyPromoteLevel.SpaceMaster)
{
var character = player.Character;
var isAdmin = false;
if (character != null)
{
if (character.Definition.Id.SubtypeName.Equals(wolf) || character.Definition.Id.SubtypeName.StartsWith(spider))
{
continue;
}
if (MySafeZone.CheckAdminIgnoreSafezones(player.SteamUserId))
{
isAdmin = true;
}
else
{
foreach (var gridAi in GridTargetingAIs.Values)
{
if (gridAi.Targets.ContainsKey((MyEntity)character) && gridAi.Weapons.Count > 0 && ((IMyTerminalBlock)gridAi.Weapons[0].MyCube).HasPlayerAccess(playerId))
{
if (MyIDModule.GetRelationPlayerBlock(playerId, gridAi.AiOwner) == MyRelationsBetweenPlayerAndBlock.Enemies)
{
isAdmin = true;
break;
}
}
}
}
if (isAdmin)
{
Admins[playerId] = character;
AdminMap[character] = player;
continue;
}
}
}
if (wasAdmin)
{
IMyCharacter removeCharacter;
IMyPlayer removePlayer;
Admins.TryRemove(playerId, out removeCharacter);
AdminMap.TryRemove(removeCharacter, out removePlayer);
}
}
}
private static void PrepBlocks(Random rand, MyIDModule owner, MyObjectBuilder_CubeGrid grid, GridComponents comps)
{
for (int i = grid.CubeBlocks.Count - 1; i >= 0; i--)
{
MyObjectBuilder_CubeBlock cubeBuilder = grid.CubeBlocks[i];
if (cubeBuilder.EntityId == 0)
{
if (!Utilities.RandomEntityId(rand, out cubeBuilder.EntityId))
{
grid.CubeBlocks.RemoveAtFast(i);
continue;
}
}
cubeBuilder.SetupForProjector();
MyCubeBlockDefinition def = MyDefinitionManager.Static.GetCubeBlockDefinition(cubeBuilder);
if (def == null)
{
grid.CubeBlocks.RemoveAtFast(i);
continue;
}
if (comps != null)
{
comps.Include(def);
}
cubeBuilder.Owner = owner.Owner;
cubeBuilder.BuiltBy = owner.Owner;
cubeBuilder.ShareMode = owner.ShareMode;
// Since the cross grid entity ids are invalid, remove references to them.
if (cubeBuilder is MyObjectBuilder_AttachableTopBlockBase)
{
((MyObjectBuilder_AttachableTopBlockBase)cubeBuilder).ParentEntityId = 0;
}
if (cubeBuilder is MyObjectBuilder_MechanicalConnectionBlock)
{
((MyObjectBuilder_MechanicalConnectionBlock)cubeBuilder).TopBlockId = null;
}
if (cubeBuilder is MyObjectBuilder_MotorBase)
{
((MyObjectBuilder_MotorBase)cubeBuilder).RotorEntityId = null;
}
if (cubeBuilder is MyObjectBuilder_FunctionalBlock)
{
((MyObjectBuilder_FunctionalBlock)cubeBuilder).Enabled = true;
}
if (cubeBuilder is MyObjectBuilder_BatteryBlock)
{
MyBatteryBlockDefinition batDef = (MyBatteryBlockDefinition)def;
((MyObjectBuilder_BatteryBlock)cubeBuilder).CurrentStoredPower = batDef.InitialStoredPowerRatio * batDef.MaxStoredPower;
}
}
}
private static bool PrepBlocks(ulong activator, MyIDModule owner, MyObjectBuilder_CubeGrid grid, GridComponents comps)
{
foreach (MyObjectBuilder_CubeBlock cubeBuilder in grid.CubeBlocks)
{
if (cubeBuilder.EntityId == 0)
{
if (!Constants.RandomEntityId(out cubeBuilder.EntityId))
{
return(false);
}
}
cubeBuilder.SetupForProjector();
MyCubeBlockDefinition def = MyDefinitionManager.Static.GetCubeBlockDefinition(cubeBuilder);
if (def == null)
{
Constants.Notify(Constants.msgUnknownBlock, activator);
return(false);
}
if (comps != null)
{
comps.Include(def);
}
cubeBuilder.Owner = owner.Owner;
cubeBuilder.BuiltBy = owner.Owner;
cubeBuilder.ShareMode = owner.ShareMode;
// Since the cross grid entity ids are invalid, remove references to them.
if (cubeBuilder is MyObjectBuilder_AttachableTopBlockBase)
{
((MyObjectBuilder_AttachableTopBlockBase)cubeBuilder).ParentEntityId = 0;
}
if (cubeBuilder is MyObjectBuilder_MechanicalConnectionBlock)
{
((MyObjectBuilder_MechanicalConnectionBlock)cubeBuilder).TopBlockId = null;
}
if (cubeBuilder is MyObjectBuilder_FunctionalBlock)
{
((MyObjectBuilder_FunctionalBlock)cubeBuilder).Enabled = true;
}
if (cubeBuilder is MyObjectBuilder_BatteryBlock)
{
MyBatteryBlockDefinition batDef = (MyBatteryBlockDefinition)def;
((MyObjectBuilder_BatteryBlock)cubeBuilder).CurrentStoredPower = batDef.InitialStoredPowerRatio * batDef.MaxStoredPower;
}
}
return(true);
}
public static bool GridEnemy(long gridOwner, MyCubeGrid grid, List <long> owners = null)
{
if (owners == null)
{
owners = grid.BigOwners;
}
if (owners.Count == 0)
{
return(true);
}
var relationship = MyIDModule.GetRelationPlayerBlock(gridOwner, owners[0], MyOwnershipShareModeEnum.Faction);
var enemy = relationship != MyRelationsBetweenPlayerAndBlock.Owner && relationship != MyRelationsBetweenPlayerAndBlock.FactionShare;
return(enemy);
}
private void OnMessageRecieved(MyRadioAntenna requester, string arg, MyTransmitTarget target)
{
if (!ReferenceEquals(requester.CubeGrid, base.CubeGrid))
{
MyProgrammableBlock block2;
switch (MyIDModule.GetRelation(base.OwnerId, requester.OwnerId, MyOwnershipShareModeEnum.Faction, MyRelationsBetweenPlayerAndBlock.Enemies, MyRelationsBetweenFactions.Enemies, MyRelationsBetweenPlayerAndBlock.FactionShare))
{
case MyRelationsBetweenPlayerAndBlock.NoOwnership:
case MyRelationsBetweenPlayerAndBlock.Neutral:
if (target.HasFlag(MyTransmitTarget.Neutral))
{
break;
}
return;
case MyRelationsBetweenPlayerAndBlock.Owner:
if (target.HasFlag(MyTransmitTarget.Owned))
{
break;
}
return;
case MyRelationsBetweenPlayerAndBlock.FactionShare:
if (!this.m_ignoreAlliedBroadcast.Value && target.HasFlag(MyTransmitTarget.Ally))
{
break;
}
return;
case MyRelationsBetweenPlayerAndBlock.Enemies:
if (!this.m_ignoreOtherBroadcast.Value && target.HasFlag(MyTransmitTarget.Enemy))
{
break;
}
return;
default:
return;
}
Sandbox.Game.Entities.MyEntities.TryGetEntityById <MyProgrammableBlock>(this.m_attachedPB.Value, out block2, false);
if (((this.RadioReceiver != null) && ((block2 != null) && MyCubeGridGroups.Static.Logical.GetGroup(block2.CubeGrid).Nodes.Any <MyGroups <MyCubeGrid, MyGridLogicalGroupData> .Node>(n => (n.NodeData == base.CubeGrid)))) && MyAntennaSystem.Static.GetAllRelayedBroadcasters(this.RadioReceiver, base.OwnerId, false, null).Contains(requester.RadioBroadcaster))
{
block2.Run(arg, UpdateType.Antenna);
}
}
}
private void UpdatePlayerPainters()
{
ActiveMarks.Clear();
foreach (var pair in PlayerDummyTargets)
{
IMyPlayer player;
if (Players.TryGetValue(pair.Key, out player))
{
var painted = pair.Value.PaintedTarget;
MyEntity target;
if (!painted.Dirty && painted.EntityId != 0 && Tick - painted.LastInfoTick < 300 && !MyUtils.IsZero(painted.LocalPosition) && MyEntities.TryGetEntityById(painted.EntityId, out target))
{
var grid = target as MyCubeGrid;
if (player.IdentityId == PlayerId && grid != null)
{
var v3 = grid.LocalToGridInteger(painted.LocalPosition);
MyCube cube;
if (!grid.TryGetCube(v3, out cube))
{
var startPos = grid.GridIntegerToWorld(v3);
var endPos = startPos + (TargetUi.AimDirection * grid.PositionComp.LocalVolume.Radius);
if (grid.RayCastBlocks(startPos, endPos) == null)
{
if (++painted.MissCount > 2)
{
painted.ClearMark(Tick);
}
}
}
}
var rep = MyIDModule.GetRelationPlayerPlayer(PlayerId, player.IdentityId);
var self = rep == MyRelationsBetweenPlayers.Self;
var friend = rep == MyRelationsBetweenPlayers.Allies;
var neut = rep == MyRelationsBetweenPlayers.Neutral;
var color = neut ? new Vector4(1, 1, 1, 1) : self ? new Vector4(0.025f, 1f, 0.25f, 2) : friend ? new Vector4(0.025f, 0.025f, 1, 2) : new Vector4(1, 0.025f, 0.025f, 2);
ActiveMarks.Add(new MyTuple <IMyPlayer, Vector4, GridAi.FakeTarget>(player, color, painted));
}
}
}
}
private void UpdatePlayerPainters()
{
ActiveMarks.Clear();
foreach (var pair in PlayerDummyTargets)
{
IMyPlayer player;
if (Players.TryGetValue(pair.Key, out player))
{
var painted = pair.Value.PaintedTarget;
MyEntity target;
if (!painted.Dirty && painted.EntityId != 0 && Tick - painted.LastInfoTick < 300 && !MyUtils.IsZero(painted.LocalPosition) && MyEntities.TryGetEntityById(painted.EntityId, out target))
{
var rep = MyIDModule.GetRelationPlayerPlayer(PlayerId, player.IdentityId);
var self = rep == MyRelationsBetweenPlayers.Self;
var friend = rep == MyRelationsBetweenPlayers.Allies;
var neut = rep == MyRelationsBetweenPlayers.Neutral;
var color = neut ? new Vector4(1, 1, 1, 1) : self ? new Vector4(0.025f, 1f, 0.25f, 2) : friend ? new Vector4(0.025f, 0.025f, 1, 2) : new Vector4(1, 0.025f, 0.025f, 2);
ActiveMarks.Add(new MyTuple <IMyPlayer, Vector4, GridAi.FakeTarget>(player, color, painted));
}
}
}
}
/// <summary>
/// Check the ownership of the grid
/// </summary>
/// <param name="cubeGrid"></param>
/// <param name="userId"></param>
/// <returns></returns>
public static VRage.Game.MyRelationsBetweenPlayerAndBlock GetUserRelationToOwner(this IMyCubeGrid cubeGrid, long userId)
{
var enemies = false;
var neutral = false;
try
{
foreach (var key in cubeGrid.BigOwners)
{
var relation = MyIDModule.GetRelation(key, userId, VRage.Game.MyOwnershipShareModeEnum.Faction);
if (relation == VRage.Game.MyRelationsBetweenPlayerAndBlock.Owner || relation == VRage.Game.MyRelationsBetweenPlayerAndBlock.FactionShare)
{
return(relation);
}
else if (relation == VRage.Game.MyRelationsBetweenPlayerAndBlock.Enemies)
{
enemies = true;
}
else if (relation == VRage.Game.MyRelationsBetweenPlayerAndBlock.Neutral)
{
neutral = true;
}
}
}
catch {
//The list BigOwners could change while iterating -> a silent catch
}
if (enemies)
{
return(VRage.Game.MyRelationsBetweenPlayerAndBlock.Enemies);
}
if (neutral)
{
return(VRage.Game.MyRelationsBetweenPlayerAndBlock.Neutral);
}
return(VRage.Game.MyRelationsBetweenPlayerAndBlock.NoOwnership);
}
internal bool GetTargetState(Session s)
{
var ai = s.TrackingAi;
var validFocus = false;
var size0 = s.Settings.Enforcement.ShipSizes[0];
var size1 = s.Settings.Enforcement.ShipSizes[1];
var size2 = s.Settings.Enforcement.ShipSizes[2];
var size3 = s.Settings.Enforcement.ShipSizes[3];
var size4 = s.Settings.Enforcement.ShipSizes[4];
var size5 = s.Settings.Enforcement.ShipSizes[5];
var size6 = s.Settings.Enforcement.ShipSizes[6];
if (s.Tick - MasterUpdateTick > 300 || MasterUpdateTick < 300 && _masterTargets.Count == 0)
{
BuildMasterCollections(ai);
}
for (int i = 0; i < ai.Construct.Data.Repo.FocusData.Target.Length; i++)
{
var targetId = ai.Construct.Data.Repo.FocusData.Target[i];
float offenseRating;
MyEntity target;
if (targetId <= 0 || !MyEntities.TryGetEntityById(targetId, out target) || !_masterTargets.TryGetValue(target, out offenseRating))
{
continue;
}
validFocus = true;
if (!s.Tick20)
{
continue;
}
var grid = target as MyCubeGrid;
var partCount = 1;
var largeGrid = false;
var smallGrid = false;
if (grid != null)
{
largeGrid = grid.GridSizeEnum == MyCubeSize.Large;
smallGrid = !largeGrid;
GridAi targetAi;
GridMap gridMap;
if (s.GridToMasterAi.TryGetValue(grid, out targetAi))
{
partCount = targetAi.Construct.BlockCount;
}
else if (s.GridToInfoMap.TryGetValue(grid, out gridMap))
{
partCount = gridMap.MostBlocks;
}
}
var targetVel = target.Physics?.LinearVelocity ?? Vector3.Zero;
if (MyUtils.IsZero(targetVel, 1E-01F))
{
targetVel = Vector3.Zero;
}
var targetDir = Vector3D.Normalize(targetVel);
var targetRevDir = -targetDir;
var targetPos = target.PositionComp.WorldAABB.Center;
var myPos = ai.MyGrid.PositionComp.WorldAABB.Center;
var myHeading = Vector3D.Normalize(myPos - targetPos);
if ((size6.LargeGrid && largeGrid || !size6.LargeGrid && smallGrid) && partCount > size6.BlockCount)
{
ai.TargetState[i].Size = 6;
}
else if ((size5.LargeGrid && largeGrid || !size5.LargeGrid && smallGrid) && partCount > size5.BlockCount)
{
ai.TargetState[i].Size = 5;
}
else if ((size4.LargeGrid && largeGrid || !size4.LargeGrid && smallGrid) && partCount > size4.BlockCount)
{
ai.TargetState[i].Size = 4;
}
else if ((size3.LargeGrid && largeGrid || !size3.LargeGrid && smallGrid) && partCount > size3.BlockCount)
{
ai.TargetState[i].Size = 3;
}
else if ((size2.LargeGrid && largeGrid || !size2.LargeGrid && smallGrid) && partCount > size2.BlockCount)
{
ai.TargetState[i].Size = 2;
}
else if ((size1.LargeGrid && largeGrid || !size1.LargeGrid && smallGrid) && partCount > size1.BlockCount)
{
ai.TargetState[i].Size = 1;
}
else
{
ai.TargetState[i].Size = 0;
}
ai.TargetState[i].SizeExtended = partCount / (largeGrid ? 100f : 500f);
var intercept = MathFuncs.IsDotProductWithinTolerance(ref targetDir, ref myHeading, s.ApproachDegrees);
var retreat = MathFuncs.IsDotProductWithinTolerance(ref targetRevDir, ref myHeading, s.ApproachDegrees);
if (intercept)
{
ai.TargetState[i].Engagement = 0;
}
else if (retreat)
{
ai.TargetState[i].Engagement = 1;
}
else
{
ai.TargetState[i].Engagement = 2;
}
var distanceFromCenters = Vector3D.Distance(ai.MyGrid.PositionComp.WorldAABB.Center, target.PositionComp.WorldAABB.Center);
distanceFromCenters -= ai.MyGrid.PositionComp.LocalVolume.Radius;
distanceFromCenters -= target.PositionComp.LocalVolume.Radius;
distanceFromCenters = distanceFromCenters <= 0 ? 0 : distanceFromCenters;
ai.TargetState[i].RealDistance = distanceFromCenters;
var distPercent = (distanceFromCenters / ai.MaxTargetingRange) * 100;
if (distPercent > 95)
{
ai.TargetState[i].Distance = 9;
}
else if (distPercent > 90)
{
ai.TargetState[i].Distance = 8;
}
else if (distPercent > 80)
{
ai.TargetState[i].Distance = 7;
}
else if (distPercent > 70)
{
ai.TargetState[i].Distance = 6;
}
else if (distPercent > 60)
{
ai.TargetState[i].Distance = 5;
}
else if (distPercent > 50)
{
ai.TargetState[i].Distance = 4;
}
else if (distPercent > 40)
{
ai.TargetState[i].Distance = 3;
}
else if (distPercent > 30)
{
ai.TargetState[i].Distance = 2;
}
else if (distPercent > 20)
{
ai.TargetState[i].Distance = 1;
}
else if (distPercent > 0)
{
ai.TargetState[i].Distance = 0;
}
else
{
ai.TargetState[i].Distance = -1;
}
var speed = Math.Round(target.Physics?.Speed ?? 0, 1);
if (speed <= 0)
{
ai.TargetState[i].Speed = -1;
}
else
{
var speedPercent = (speed / s.MaxEntitySpeed) * 100;
if (speedPercent > 95)
{
ai.TargetState[i].Speed = 9;
}
else if (speedPercent > 90)
{
ai.TargetState[i].Speed = 8;
}
else if (speedPercent > 80)
{
ai.TargetState[i].Speed = 7;
}
else if (speedPercent > 70)
{
ai.TargetState[i].Speed = 6;
}
else if (speedPercent > 60)
{
ai.TargetState[i].Speed = 5;
}
else if (speedPercent > 50)
{
ai.TargetState[i].Speed = 4;
}
else if (speedPercent > 40)
{
ai.TargetState[i].Speed = 3;
}
else if (speedPercent > 30)
{
ai.TargetState[i].Speed = 2;
}
else if (speedPercent > 20)
{
ai.TargetState[i].Speed = 1;
}
else if (speedPercent > 0.3)
{
ai.TargetState[i].Speed = 0;
}
else
{
ai.TargetState[i].Speed = -1;
}
}
MyTuple <bool, bool, float, float, float, int> shieldInfo = new MyTuple <bool, bool, float, float, float, int>();
if (s.ShieldApiLoaded)
{
shieldInfo = s.SApi.GetShieldInfo(target);
}
if (shieldInfo.Item1)
{
var shieldPercent = shieldInfo.Item5;
if (shieldPercent > 95)
{
ai.TargetState[i].ShieldHealth = 9;
}
else if (shieldPercent > 90)
{
ai.TargetState[i].ShieldHealth = 8;
}
else if (shieldPercent > 80)
{
ai.TargetState[i].ShieldHealth = 7;
}
else if (shieldPercent > 70)
{
ai.TargetState[i].ShieldHealth = 6;
}
else if (shieldPercent > 60)
{
ai.TargetState[i].ShieldHealth = 5;
}
else if (shieldPercent > 50)
{
ai.TargetState[i].ShieldHealth = 4;
}
else if (shieldPercent > 40)
{
ai.TargetState[i].ShieldHealth = 3;
}
else if (shieldPercent > 30)
{
ai.TargetState[i].ShieldHealth = 2;
}
else if (shieldPercent > 20)
{
ai.TargetState[i].ShieldHealth = 1;
}
else if (shieldPercent > 0)
{
ai.TargetState[i].ShieldHealth = 0;
}
else
{
ai.TargetState[i].ShieldHealth = -1;
}
}
else
{
ai.TargetState[i].ShieldHealth = -1;
}
var friend = false;
if (grid != null && grid.BigOwners.Count != 0)
{
var relation = MyIDModule.GetRelationPlayerBlock(ai.AiOwner, grid.BigOwners[0], MyOwnershipShareModeEnum.Faction);
if (relation == MyRelationsBetweenPlayerAndBlock.FactionShare || relation == MyRelationsBetweenPlayerAndBlock.Owner || relation == MyRelationsBetweenPlayerAndBlock.Friends)
{
friend = true;
}
}
if (friend)
{
ai.TargetState[i].ThreatLvl = -1;
}
else
{
int shieldBonus = 0;
if (s.ShieldApiLoaded)
{
var myShieldInfo = s.SApi.GetShieldInfo(ai.MyGrid);
if (shieldInfo.Item1 && myShieldInfo.Item1)
{
shieldBonus = shieldInfo.Item5 > myShieldInfo.Item5 ? 1 : -1;
}
else if (shieldInfo.Item1)
{
shieldBonus = 1;
}
else if (myShieldInfo.Item1)
{
shieldBonus = -1;
}
}
if (offenseRating > 5)
{
ai.TargetState[i].ThreatLvl = shieldBonus < 0 ? 8 : 9;
}
else if (offenseRating > 4)
{
ai.TargetState[i].ThreatLvl = 8 + shieldBonus;
}
else if (offenseRating > 3)
{
ai.TargetState[i].ThreatLvl = 7 + shieldBonus;
}
else if (offenseRating > 2)
{
ai.TargetState[i].ThreatLvl = 6 + shieldBonus;
}
else if (offenseRating > 1)
{
ai.TargetState[i].ThreatLvl = 5 + shieldBonus;
}
else if (offenseRating > 0.5)
{
ai.TargetState[i].ThreatLvl = 4 + shieldBonus;
}
else if (offenseRating > 0.25)
{
ai.TargetState[i].ThreatLvl = 3 + shieldBonus;
}
else if (offenseRating > 0.125)
{
ai.TargetState[i].ThreatLvl = 2 + shieldBonus;
}
else if (offenseRating > 0.0625)
{
ai.TargetState[i].ThreatLvl = 1 + shieldBonus;
}
else if (offenseRating > 0)
{
ai.TargetState[i].ThreatLvl = shieldBonus > 0 ? 1 : 0;
}
else
{
ai.TargetState[i].ThreatLvl = -1;
}
}
}
return(validFocus);
}
/// <summary>
/// Adds a disruption effect to a grid.
/// </summary>
/// <param name="grid">Grid that will be disrupted</param>
/// <param name="duration">Duration of disruption</param>
/// <param name="strength">Strength of disruption (in hackyness)</param>
/// <param name="effectOwner">The owner of the disruption.</param>
public void Start(IMyCubeGrid grid, TimeSpan duration, ref float strength, long effectOwner)
{
if (strength < MinCost)
{
Logger.DebugLog("strength: " + strength + ", below minimum: " + MinCost);
return;
}
CubeGridCache cache = CubeGridCache.GetFor(grid);
float applied = 0;
if (!EffectOwnerCanAccess)
{
effectOwner = long.MinValue;
}
m_effectOwner = effectOwner;
foreach (MyObjectBuilderType type in BlocksAffected)
{
foreach (IMyCubeBlock block in cache.BlocksOfType(type).OrderBy(OrderBy))
{
if (!block.IsWorking || m_allAffected.Contains(block))
{
Logger.DebugLog("cannot disrupt: " + block);
continue;
}
float cost = BlockCost(block);
if (cost > strength)
{
Logger.DebugLog("cannot disrupt block: " + block + ", cost: " + cost + " is greater than strength available: " + strength);
continue;
}
StartEffect(block);
Logger.DebugLog("disrupting: " + block + ", cost: " + cost + ", remaining strength: " + strength);
strength -= cost;
applied += cost;
MyCubeBlock cubeBlock = block as MyCubeBlock;
MyIDModule idMod = new MyIDModule()
{
Owner = cubeBlock.IDModule.Owner, ShareMode = cubeBlock.IDModule.ShareMode
};
m_affected.Add(block, idMod);
m_allAffected.Add(block);
block.SetDamageEffect(true);
cubeBlock.ChangeOwner(effectOwner, MyOwnershipShareModeEnum.Faction);
if (strength < MinCost)
{
goto FinishedBlocks;
}
}
}
FinishedBlocks:
if (m_affected.Count != 0)
{
Logger.DebugLog("Added new effect, strength: " + applied);
m_expire = Globals.ElapsedTime.Add(duration);
UpdateManager.Register(UpdateFrequency, UpdateEffect); // don't unregister on grid close, blocks can still be valid
AllDisruptions.Add(this);
}
}
internal bool GetTargetState()
{
var validFocus = false;
for (int i = 0; i < Focus.Target.Length; i++)
{
var target = Focus.Target[i];
TargetInfo info;
if (target == null || !Targets.TryGetValue(target, out info))
{
continue;
}
validFocus = true;
if (!Session.Tick20 && Focus.PrevTargetId[i] == info.EntInfo.EntityId)
{
continue;
}
Focus.PrevTargetId[i] = info.EntInfo.EntityId;
var targetVel = target.Physics?.LinearVelocity ?? Vector3.Zero;
if (MyUtils.IsZero(targetVel, 1E-02F))
{
targetVel = Vector3.Zero;
}
var targetDir = Vector3D.Normalize(targetVel);
var targetRevDir = -targetDir;
var targetPos = target.PositionComp.WorldAABB.Center;
var myPos = MyGrid.PositionComp.WorldAABB.Center;
var myHeading = Vector3D.Normalize(myPos - targetPos);
if (info.LargeGrid && info.PartCount > 24000)
{
Focus.TargetState[i].Size = 6;
}
else if (info.LargeGrid && info.PartCount > 12000)
{
Focus.TargetState[i].Size = 5;
}
else if (info.LargeGrid && info.PartCount > 6000)
{
Focus.TargetState[i].Size = 4;
}
else if (info.LargeGrid && info.PartCount > 3000)
{
Focus.TargetState[i].Size = 3;
}
else if (info.LargeGrid)
{
Focus.TargetState[i].Size = 2;
}
else if (info.PartCount > 2000)
{
Focus.TargetState[i].Size = 1;
}
else
{
Focus.TargetState[i].Size = 0;
}
var intercept = MathFuncs.IsDotProductWithinTolerance(ref targetDir, ref myHeading, Session.ApproachDegrees);
var retreat = MathFuncs.IsDotProductWithinTolerance(ref targetRevDir, ref myHeading, Session.ApproachDegrees);
if (intercept)
{
Focus.TargetState[i].Engagement = 0;
}
else if (retreat)
{
Focus.TargetState[i].Engagement = 1;
}
else
{
Focus.TargetState[i].Engagement = 2;
}
var distanceFromCenters = Vector3D.Distance(MyGrid.PositionComp.WorldAABB.Center, target.PositionComp.WorldAABB.Center);
distanceFromCenters -= MyGrid.PositionComp.LocalVolume.Radius;
distanceFromCenters -= target.PositionComp.LocalVolume.Radius;
distanceFromCenters = distanceFromCenters <= 0 ? 0 : distanceFromCenters;
var distPercent = (distanceFromCenters / MaxTargetingRange) * 100;
if (distPercent > 95)
{
Focus.TargetState[i].Distance = 9;
}
else if (distPercent > 90)
{
Focus.TargetState[i].Distance = 8;
}
else if (distPercent > 80)
{
Focus.TargetState[i].Distance = 7;
}
else if (distPercent > 70)
{
Focus.TargetState[i].Distance = 6;
}
else if (distPercent > 60)
{
Focus.TargetState[i].Distance = 5;
}
else if (distPercent > 50)
{
Focus.TargetState[i].Distance = 4;
}
else if (distPercent > 40)
{
Focus.TargetState[i].Distance = 3;
}
else if (distPercent > 30)
{
Focus.TargetState[i].Distance = 2;
}
else if (distPercent > 20)
{
Focus.TargetState[i].Distance = 1;
}
else if (distPercent > 0)
{
Focus.TargetState[i].Distance = 0;
}
else
{
Focus.TargetState[i].Distance = -1;
}
var speed = Math.Round(target.Physics?.Speed ?? 0, 1);
if (speed <= 0)
{
Focus.TargetState[i].Speed = -1;
}
else
{
var speedPercent = (speed / Session.MaxEntitySpeed) * 100;
if (speedPercent > 95)
{
Focus.TargetState[i].Speed = 9;
}
else if (speedPercent > 90)
{
Focus.TargetState[i].Speed = 8;
}
else if (speedPercent > 80)
{
Focus.TargetState[i].Speed = 7;
}
else if (speedPercent > 70)
{
Focus.TargetState[i].Speed = 6;
}
else if (speedPercent > 60)
{
Focus.TargetState[i].Speed = 5;
}
else if (speedPercent > 50)
{
Focus.TargetState[i].Speed = 4;
}
else if (speedPercent > 40)
{
Focus.TargetState[i].Speed = 3;
}
else if (speedPercent > 30)
{
Focus.TargetState[i].Speed = 2;
}
else if (speedPercent > 20)
{
Focus.TargetState[i].Speed = 1;
}
else if (speedPercent > 0)
{
Focus.TargetState[i].Speed = 0;
}
else
{
Focus.TargetState[i].Speed = -1;
}
}
MyTuple <bool, bool, float, float, float, int> shieldInfo = new MyTuple <bool, bool, float, float, float, int>();
if (Session.ShieldApiLoaded)
{
shieldInfo = Session.SApi.GetShieldInfo(target);
}
if (shieldInfo.Item1)
{
var shieldPercent = shieldInfo.Item5;
if (shieldPercent > 95)
{
Focus.TargetState[i].ShieldHealth = 9;
}
else if (shieldPercent > 90)
{
Focus.TargetState[i].ShieldHealth = 8;
}
else if (shieldPercent > 80)
{
Focus.TargetState[i].ShieldHealth = 7;
}
else if (shieldPercent > 70)
{
Focus.TargetState[i].ShieldHealth = 6;
}
else if (shieldPercent > 60)
{
Focus.TargetState[i].ShieldHealth = 5;
}
else if (shieldPercent > 50)
{
Focus.TargetState[i].ShieldHealth = 4;
}
else if (shieldPercent > 40)
{
Focus.TargetState[i].ShieldHealth = 3;
}
else if (shieldPercent > 30)
{
Focus.TargetState[i].ShieldHealth = 2;
}
else if (shieldPercent > 20)
{
Focus.TargetState[i].ShieldHealth = 1;
}
else if (shieldPercent > 0)
{
Focus.TargetState[i].ShieldHealth = 0;
}
else
{
Focus.TargetState[i].ShieldHealth = -1;
}
}
else
{
Focus.TargetState[i].ShieldHealth = -1;
}
var grid = target as MyCubeGrid;
var friend = false;
if (grid != null && grid.BigOwners.Count != 0)
{
var relation = MyIDModule.GetRelationPlayerBlock(MyOwner, grid.BigOwners[0], MyOwnershipShareModeEnum.Faction);
if (relation == MyRelationsBetweenPlayerAndBlock.FactionShare || relation == MyRelationsBetweenPlayerAndBlock.Owner || relation == MyRelationsBetweenPlayerAndBlock.Friends)
{
friend = true;
}
}
if (friend)
{
Focus.TargetState[i].ThreatLvl = -1;
}
else
{
int shieldBonus = 0;
if (Session.ShieldApiLoaded)
{
var myShieldInfo = Session.SApi.GetShieldInfo(MyGrid);
if (shieldInfo.Item1 && myShieldInfo.Item1)
{
shieldBonus = shieldInfo.Item5 > myShieldInfo.Item5 ? 1 : -1;
}
else if (shieldInfo.Item1)
{
shieldBonus = 1;
}
else if (myShieldInfo.Item1)
{
shieldBonus = -1;
}
}
var offenseRating = info.OffenseRating;
if (offenseRating > 5)
{
Focus.TargetState[i].ThreatLvl = shieldBonus < 0 ? 8 : 9;
}
else if (offenseRating > 4)
{
Focus.TargetState[i].ThreatLvl = 8 + shieldBonus;
}
else if (offenseRating > 3)
{
Focus.TargetState[i].ThreatLvl = 7 + shieldBonus;
}
else if (offenseRating > 2)
{
Focus.TargetState[i].ThreatLvl = 6 + shieldBonus;
}
else if (offenseRating > 1)
{
Focus.TargetState[i].ThreatLvl = 5 + shieldBonus;
}
else if (offenseRating > 0.5)
{
Focus.TargetState[i].ThreatLvl = 4 + shieldBonus;
}
else if (offenseRating > 0.25)
{
Focus.TargetState[i].ThreatLvl = 3 + shieldBonus;
}
else if (offenseRating > 0.125)
{
Focus.TargetState[i].ThreatLvl = 2 + shieldBonus;
}
else if (offenseRating > 0.0625)
{
Focus.TargetState[i].ThreatLvl = 1 + shieldBonus;
}
else if (offenseRating > 0)
{
Focus.TargetState[i].ThreatLvl = shieldBonus > 0 ? 1 : 0;
}
else
{
Focus.TargetState[i].ThreatLvl = -1;
}
}
}
return(validFocus);
}
/// <summary>
/// Check the ownership of the grid
/// </summary>
/// <param name="cubeGrid"></param>
/// <param name="userId"></param>
/// <returns></returns>
public static VRage.Game.MyRelationsBetweenPlayerAndBlock GetUserRelationToOwner(this IMyCubeGrid cubeGrid, long userId, bool ignoreCubeGridList = false)
{
var enemies = false;
var neutral = false;
try
{
if (cubeGrid.BigOwners != null && cubeGrid.BigOwners.Count != 0)
{
foreach (var key in cubeGrid.BigOwners)
{
var relation = MyIDModule.GetRelationPlayerBlock(key, userId, VRage.Game.MyOwnershipShareModeEnum.Faction);
if (relation == VRage.Game.MyRelationsBetweenPlayerAndBlock.Owner || relation == VRage.Game.MyRelationsBetweenPlayerAndBlock.FactionShare)
{
return(relation);
}
else if (relation == VRage.Game.MyRelationsBetweenPlayerAndBlock.Enemies)
{
enemies = true;
}
else if (relation == VRage.Game.MyRelationsBetweenPlayerAndBlock.Neutral)
{
neutral = true;
}
}
}
else if (!ignoreCubeGridList)
{
//E.G. the case if a landing gear is directly attatched to piston/rotor (with no ownable block in the same subgrid) and the gear gets connected to something
var cubegridsList = MyAPIGateway.GridGroups.GetGroup(cubeGrid, GridLinkTypeEnum.Mechanical);
if (cubegridsList != null)
{
foreach (var cubeGrid1 in cubegridsList)
{
if (cubeGrid1 == cubeGrid)
{
continue;
}
var relation = cubeGrid1.GetUserRelationToOwner(userId, true); //Do not recurse as this list is already complete
if (relation == VRage.Game.MyRelationsBetweenPlayerAndBlock.Owner || relation == VRage.Game.MyRelationsBetweenPlayerAndBlock.FactionShare)
{
return(relation);
}
else if (relation == VRage.Game.MyRelationsBetweenPlayerAndBlock.Enemies)
{
enemies = true;
}
else if (relation == VRage.Game.MyRelationsBetweenPlayerAndBlock.Neutral)
{
neutral = true;
}
}
}
}
}
catch {
//The list BigOwners could change while iterating -> a silent catch
}
if (enemies)
{
return(VRage.Game.MyRelationsBetweenPlayerAndBlock.Enemies);
}
if (neutral)
{
return(VRage.Game.MyRelationsBetweenPlayerAndBlock.Neutral);
}
return(VRage.Game.MyRelationsBetweenPlayerAndBlock.NoOwnership);
}
void Server_GrindingBlock(IMySlimBlock block, ref MyDamageInformation info, IMyAngleGrinder grinder, ulong attackerSteamId)
{
DetachData data = Server_DetachData.GetValueOrDefault(attackerSteamId);
if (data == null || !data.DetachMode)
{
return;
}
float grindAmount = info.Amount; // store grinder speed for later use
info.Amount = 0; // prevent grinding while detach mode is enabled
MyCubeBlockDefinition blockDef = (MyCubeBlockDefinition)block.BlockDefinition;
if (!blockDef.IsStandAlone || !blockDef.HasPhysics)
{
ProgressPacket.Send(attackerSteamId, DetachState.NoStandalone);
return;
}
if (grindAmount == 0)
{
ProgressPacket.Send(attackerSteamId, DetachState.ZeroGrindAmount);
return;
}
long owner = block.OwnerId;
if (owner == 0 && block.CubeGrid.BigOwners != null && block.CubeGrid.BigOwners.Count > 0)
{
owner = block.CubeGrid.BigOwners[0];
}
if (owner == 0)
{
owner = block.BuiltBy;
}
if (owner != 0)
{
MyRelationsBetweenPlayerAndBlock relation = MyIDModule.GetRelationPlayerBlock(owner, grinder.OwnerIdentityId, MyOwnershipShareModeEnum.Faction);
if (relation == MyRelationsBetweenPlayerAndBlock.Enemies)
{
ProgressPacket.Send(attackerSteamId, DetachState.EnemyBlock);
return;
}
}
MyCubeGrid grid = (MyCubeGrid)block.CubeGrid;
if (grid.BlocksCount <= 1)
{
if (grid.DisplayName.StartsWith("(Detached"))
{
ProgressPacket.Send(attackerSteamId, DetachState.DetachComplete);
}
else
{
ProgressPacket.Send(attackerSteamId, DetachState.SingleBlock);
}
return;
}
// checking safezones doesn't seem necessary, as you cannot grind to begin with...
if (data.GrindedBlock != block)
{
data.GrindedBlock = block;
data.GrindedTimes = 0;
data.GrindExpiresAtTick = 0;
}
int tick = MyAPIGateway.Session.GameplayFrameCounter;
if (data.GrindExpiresAtTick == 0 || data.GrindExpiresAtTick > tick)
{
data.GrindedTimes++;
}
else
{
data.GrindedTimes = 0;
}
data.GrindExpiresAtTick = tick + 30;
// make it require as much time as it normally would to grind to critical line
float divideBy = (block.FatBlock != null ? block.FatBlock.DisassembleRatio : blockDef.DisassembleRatio);
float finalDamage = (grindAmount / divideBy) * blockDef.IntegrityPointsPerSec;
int grindTimesToDetach = (int)((block.MaxIntegrity * blockDef.CriticalIntegrityRatio) / finalDamage);
grindTimesToDetach = Math.Max(grindTimesToDetach, (int)(1000 / GrinderCooldownMs)); // at least one second
if (data.GrindedTimes >= grindTimesToDetach)
{
data.GrindedTimes = 0;
ProgressPacket.Send(attackerSteamId, DetachState.DetachComplete);
DetachBlock(block, grinder);
}
else
{
int progress = (data.GrindedTimes * 100) / grindTimesToDetach;
ProgressPacket.Send(attackerSteamId, DetachState.Detaching, progress);
}
}
public static bool TryCreate(ulong activator, IMyProjector p, bool shiftBuildArea, out ProjectedGrid projectedGrid)
{
projectedGrid = null;
// Ensure the projector is valid and has a projection
if (p.CubeGrid?.Physics == null)
{
Utilities.Notify(Constants.msgError + "bad_physics", activator);
return(false);
}
if (p.ProjectedGrid == null)
{
Utilities.Notify(Constants.msgNoGrid, activator);
return(false);
}
MyObjectBuilder_Projector pBuilder = (MyObjectBuilder_Projector)p.GetObjectBuilderCubeBlock(true);
if (pBuilder.ProjectedGrids == null || pBuilder.ProjectedGrids.Count == 0)
{
Utilities.Notify(Constants.msgNoGrid, activator);
return(false);
}
// Prepare list of grids
List <MyObjectBuilder_CubeGrid> grids = pBuilder.ProjectedGrids;
int largestIndex = FindLargest(grids);
MyObjectBuilder_CubeGrid largestGrid = grids[largestIndex];
if (Utilities.SupportsSubgrids(p))
{
if (largestIndex != 0)
{
MyObjectBuilder_CubeGrid temp = grids[0];
grids[0] = largestGrid;
grids[largestIndex] = temp;
}
}
else
{
grids.Clear();
grids.Add(largestGrid);
}
MatrixD largestMatrixInvert = MatrixD.Invert(largestGrid.PositionAndOrientation.Value.GetMatrix());
MatrixD targetMatrix = p.ProjectedGrid.WorldMatrix;
float scale = GetScale(p);
GridOrientation orientation = new GridOrientation(p);
GridComponents comps = null;
if (!MyAPIGateway.Session.CreativeMode)
{
comps = new GridComponents();
}
int totalBlocks = 0;
MyIDModule owner = ((MyCubeBlock)p).IDModule;
if (activator != 0)
{
long temp = MyAPIGateway.Players.TryGetIdentityId(activator);
if (temp != 0)
{
if (owner.ShareMode == MyOwnershipShareModeEnum.All)
{
owner = new MyIDModule(temp, MyOwnershipShareModeEnum.Faction);
}
else
{
owner = new MyIDModule(temp, owner.ShareMode);
}
}
}
Random rand = new Random();
foreach (MyObjectBuilder_CubeGrid grid in grids)
{
totalBlocks += grid.CubeBlocks.Count;
if (totalBlocks > IPSession.Instance.MapSettings.MaxBlocks)
{
Utilities.Notify(Constants.msgGridLarge, activator);
return(false);
}
PrepBlocks(rand, owner, grid, comps);
if (grid.CubeBlocks.Count == 0)
{
Utilities.Notify(Constants.msgGridSmall, activator);
return(false);
}
grid.IsStatic = false;
grid.CreatePhysics = true;
grid.Immune = false;
grid.DestructibleBlocks = true;
MatrixD current = grid.PositionAndOrientation.Value.GetMatrix();
if (scale != 1)
{
current.Translation /= scale;
}
MatrixD newWorldMatrix = (current * largestMatrixInvert) * targetMatrix;
grid.PositionAndOrientation = new MyPositionAndOrientation(ref newWorldMatrix);
orientation.Include(newWorldMatrix);
}
if (totalBlocks < IPSession.Instance.MapSettings.MinBlocks)
{
Utilities.Notify(Constants.msgGridSmall, activator);
return(false);
}
if (comps == null)
{
comps = new GridComponents();
}
else
{
comps.ApplySettings(IPSession.Instance.MapSettings);
int needed;
MyDefinitionId neededId;
if (!comps.HasComponents(Utilities.GetInventories(p), out needed, out neededId))
{
Utilities.Notify(Utilities.GetCompsString(needed, neededId), activator);
return(false);
}
}
GridBounds bounds = new GridBounds(p, grids);
IMyEntity e = bounds.GetOverlappingEntity();
if (e != null && (!shiftBuildArea || !bounds.HasClearArea()))
{
Utilities.Notify(Utilities.GetOverlapString(true, e), activator);
return(false);
}
projectedGrid = new ProjectedGrid(activator, p, grids, bounds, comps, orientation, shiftBuildArea, totalBlocks);
return(true);
}
public Ent EntType(MyEntity ent)
{
if (ent is IMyFloatingObject)
{
if (CustomCollision.AllAabbInShield(ent.PositionComp.WorldAABB, DetectMatrixOutsideInv, _obbCorners))
{
return(Ent.Ignore);
}
return(Ent.Floater);
}
var voxel = ent as MyVoxelBase;
if (voxel != null && (Session.Enforced.DisableVoxelSupport == 1 || ShieldComp.Modulator == null || ShieldComp.Modulator.ModSet.Settings.ModulateVoxels || !GridIsMobile))
{
return(Ent.Ignore);
}
if (EntityBypass.Contains(ent))
{
return(Ent.Ignore);
}
var character = ent as IMyCharacter;
if (character != null)
{
var getComponentOwner = ent as IMyComponentOwner <MyIDModule>;
long playerId;
MyIDModule targetIdModule;
if (getComponentOwner != null && getComponentOwner.GetComponent(out targetIdModule))
{
playerId = targetIdModule.Owner;
}
else
{
var controllingId = character.ControllerInfo?.ControllingIdentityId;
playerId = controllingId ?? 0;
}
if (playerId == 0 || character.IsDead || character.Integrity <= 0)
{
return(Ent.Ignore);
}
var playerrelationship = MyIDModule.GetRelationPlayerBlock(MyCube.IDModule.Owner, playerId, MyOwnershipShareModeEnum.Faction);
var modulateAllies = (ShieldComp.Modulator != null && ShieldComp.Modulator.ModSet.Settings.AllowAllies);
if (playerrelationship == MyRelationsBetweenPlayerAndBlock.Owner || playerrelationship == MyRelationsBetweenPlayerAndBlock.FactionShare || modulateAllies && playerrelationship == MyRelationsBetweenPlayerAndBlock.Friends)
{
var playerInShield = CustomCollision.PointInShield(ent.PositionComp.WorldAABB.Center, DetectMatrixOutsideInv);
return(playerInShield ? Ent.Protected : Ent.Friendly);
}
if (CustomCollision.NewObbPointsInShield(ent, DetectMatrixOutsideInv, _obbPoints) == 9)
{
return(Ent.EnemyInside);
}
return(Ent.EnemyPlayer);
}
var grid = ent as MyCubeGrid;
if (grid != null)
{
var modulateGrids = (ShieldComp.Modulator != null && ShieldComp.Modulator.ModSet.Settings.ModulateGrids) || Session.Enforced.DisableEntityBarrier == 1;
ModulatorGridComponent modComp;
grid.Components.TryGet(out modComp);
if (!string.IsNullOrEmpty(modComp?.ModulationPassword) && modComp.ModulationPassword == Shield.CustomData)
{
var modShield = modComp.Modulator?.ShieldComp?.DefenseShields;
if (modShield != null)
{
foreach (var subGrid in modShield.ShieldComp.SubGrids.Keys)
{
if (ShieldEnt.PositionComp.WorldVolume.Intersects(grid.PositionComp.WorldVolume))
{
if (CustomCollision.CornerOrCenterInShield(grid, DetectMatrixOutsideInv, _resetEntCorners) > 0)
{
return(Ent.Protected);
}
AuthenticatedCache.Add(subGrid);
}
else
{
AuthenticatedCache.Add(subGrid);
}
}
return(Ent.Authenticated);
}
foreach (var subGrid in modComp.SubGrids)
{
if (ShieldEnt.PositionComp.WorldVolume.Intersects(grid.PositionComp.WorldVolume))
{
if (CustomCollision.CornerOrCenterInShield(grid, DetectMatrixOutsideInv, _resetEntCorners) > 0)
{
return(Ent.Protected);
}
AuthenticatedCache.Add((MyCubeGrid)subGrid);
}
else
{
AuthenticatedCache.Add((MyCubeGrid)subGrid);
}
}
}
List <long> bigOwners;
int bigOwnersCnt;
Session.ParentGrid parent;
if (Session.Instance.GetParentGrid.TryGetValue(grid, out parent) && !CustomCollision.AllAabbInShield(parent.Parent.PositionComp.WorldAABB, DetectMatrixOutsideInv, _obbCorners))
{
bigOwners = grid.BigOwners;
bigOwnersCnt = bigOwners.Count;
if (bigOwnersCnt == 0 || GridEnemy(grid, bigOwners))
{
return(Ent.EnemyGrid);
}
}
else
{
bigOwners = grid.BigOwners;
bigOwnersCnt = bigOwners.Count;
}
if (CustomCollision.AllAabbInShield(ent.PositionComp.WorldAABB, DetectMatrixOutsideInv, _obbCorners))
{
return(Ent.Protected);
}
if (!modulateGrids && bigOwnersCnt == 0)
{
return(Ent.NobodyGrid);
}
var enemy = !modulateGrids && GridEnemy(grid, bigOwners);
if (!enemy)
{
if (ShieldComp.SubGrids.ContainsKey(grid))
{
return(Ent.Protected);
}
var pointsInShield = CustomCollision.NewObbPointsInShield(grid, DetectMatrixOutsideInv, _obbPoints);
return(pointsInShield > 0 ? Ent.Protected : Ent.Friendly);
}
ShieldGridComponent shieldComponent;
grid.Components.TryGet(out shieldComponent);
if (shieldComponent?.DefenseShields?.ShieldComp != null && shieldComponent.DefenseShields.NotFailed && shieldComponent.DefenseShields.DsState != null && !shieldComponent.DefenseShields.DsState.State.ReInforce)
{
var dsComp = shieldComponent.DefenseShields;
var shieldEntity = MyCube.Parent;
dsComp.EnemyShields.Add(shieldEntity);
return(Ent.Shielded);
}
return(Ent.EnemyGrid);
}
if (ent is IMyMeteor || (ent.DefinitionId.HasValue && ent.DefinitionId.Value.TypeId == Session.Instance.MissileObj))
{
return(Ent.Other);
}
if (voxel != null && GridIsMobile)
{
return(Ent.VoxelBase);
}
return(0);
}
internal bool CreateEntInfo(MyEntity entity, long gridOwner, out Sandbox.ModAPI.Ingame.MyDetectedEntityInfo entInfo)
{
try
{
MyRelationsBetweenPlayerAndBlock relationship = MyRelationsBetweenPlayerAndBlock.Neutral;
if (entity == null)
{
entInfo = new Sandbox.ModAPI.Ingame.MyDetectedEntityInfo();
return(false);
}
var grid = entity.GetTopMostParent() as MyCubeGrid;
if (grid != null)
{
if (!grid.DestructibleBlocks || grid.Immune || grid.GridGeneralDamageModifier <= 0)
{
entInfo = new Sandbox.ModAPI.Ingame.MyDetectedEntityInfo();
return(false);
}
var bigOwners = grid.BigOwners;
var topOwner = bigOwners.Count > 0 ? bigOwners[0] : long.MaxValue;
relationship = topOwner != long.MaxValue ? MyIDModule.GetRelationPlayerBlock(gridOwner, topOwner, MyOwnershipShareModeEnum.Faction) : MyRelationsBetweenPlayerAndBlock.NoOwnership;
var type = grid.GridSizeEnum != MyCubeSize.Small ? Sandbox.ModAPI.Ingame.MyDetectedEntityType.LargeGrid : Sandbox.ModAPI.Ingame.MyDetectedEntityType.SmallGrid;
entInfo = new Sandbox.ModAPI.Ingame.MyDetectedEntityInfo(grid.EntityId, string.Empty, type, null, MatrixD.Zero, Vector3.Zero, relationship, new BoundingBoxD(), Session.Tick);
return(true);
}
var myCharacter = entity as IMyCharacter;
if (myCharacter != null)
{
var type = !myCharacter.IsPlayer ? Sandbox.ModAPI.Ingame.MyDetectedEntityType.CharacterOther : Sandbox.ModAPI.Ingame.MyDetectedEntityType.CharacterHuman;
var getComponentOwner = entity as IMyComponentOwner <MyIDModule>;
long playerId;
MyIDModule targetIdModule;
if (getComponentOwner != null && getComponentOwner.GetComponent(out targetIdModule))
{
playerId = targetIdModule.Owner;
}
else
{
var controllingId = myCharacter.ControllerInfo?.ControllingIdentityId;
playerId = controllingId ?? 0;
}
relationship = MyIDModule.GetRelationPlayerBlock(gridOwner, playerId, MyOwnershipShareModeEnum.Faction);
entInfo = new Sandbox.ModAPI.Ingame.MyDetectedEntityInfo(entity.EntityId, string.Empty, type, null, MatrixD.Zero, Vector3.Zero, relationship, new BoundingBoxD(), Session.Tick);
return(!myCharacter.IsDead && myCharacter.Integrity > 0);
}
var myPlanet = entity as MyPlanet;
if (myPlanet != null)
{
const Sandbox.ModAPI.Ingame.MyDetectedEntityType type = Sandbox.ModAPI.Ingame.MyDetectedEntityType.Planet;
entInfo = new Sandbox.ModAPI.Ingame.MyDetectedEntityInfo(entity.EntityId, string.Empty, type, null, MatrixD.Zero, Vector3.Zero, relationship, new BoundingBoxD(), Session.Tick);
return(true);
}
if (entity is MyVoxelMap)
{
const Sandbox.ModAPI.Ingame.MyDetectedEntityType type = Sandbox.ModAPI.Ingame.MyDetectedEntityType.Asteroid;
entInfo = new Sandbox.ModAPI.Ingame.MyDetectedEntityInfo(entity.EntityId, string.Empty, type, null, MatrixD.Zero, Vector3.Zero, relationship, new BoundingBoxD(), Session.Tick);
return(true);
}
if (entity is MyMeteor)
{
const Sandbox.ModAPI.Ingame.MyDetectedEntityType type = Sandbox.ModAPI.Ingame.MyDetectedEntityType.Meteor;
entInfo = new Sandbox.ModAPI.Ingame.MyDetectedEntityInfo(entity.EntityId, string.Empty, type, null, MatrixD.Zero, Vector3.Zero, MyRelationsBetweenPlayerAndBlock.Enemies, new BoundingBoxD(), Session.Tick);
return(true);
}
}
catch (Exception ex) { Log.Line($"Exception in CreateEntInfo: {ex}"); }
entInfo = new Sandbox.ModAPI.Ingame.MyDetectedEntityInfo();
return(false);
}
internal bool GetTargetState(Session s)
{
var ai = s.TrackingAi;
var validFocus = false;
var maxNameLength = 18;
if (s.Tick - MasterUpdateTick > 300 || MasterUpdateTick < 300 && _masterTargets.Count == 0)
{
BuildMasterCollections(ai);
}
for (int i = 0; i < ai.Construct.Data.Repo.FocusData.Target.Length; i++)
{
var targetId = ai.Construct.Data.Repo.FocusData.Target[i];
float offenseRating;
MyEntity target;
if (targetId <= 0 || !MyEntities.TryGetEntityById(targetId, out target) || !_masterTargets.TryGetValue(target, out offenseRating))
{
continue;
}
validFocus = true;
if (!s.Tick20)
{
continue;
}
var grid = target as MyCubeGrid;
var partCount = 1;
var largeGrid = false;
GridAi targetAi = null;
if (grid != null)
{
largeGrid = grid.GridSizeEnum == MyCubeSize.Large;
GridMap gridMap;
if (s.GridToMasterAi.TryGetValue(grid, out targetAi))
{
partCount = targetAi.Construct.BlockCount;
}
else if (s.GridToInfoMap.TryGetValue(grid, out gridMap))
{
partCount = gridMap.MostBlocks;
}
}
var state = ai.TargetState[i];
state.Aware = targetAi != null?AggressionState(ai, targetAi) : TargetStatus.Awareness.WONDERING;
var displayName = target.DisplayName;
var name = string.IsNullOrEmpty(displayName) ? string.Empty : displayName.Length <= maxNameLength ? displayName : displayName.Substring(0, maxNameLength);
var targetVel = target.Physics?.LinearVelocity ?? Vector3.Zero;
if (MyUtils.IsZero(targetVel, 1E-01F))
{
targetVel = Vector3.Zero;
}
var targetDir = Vector3D.Normalize(targetVel);
var targetRevDir = -targetDir;
var targetPos = target.PositionComp.WorldAABB.Center;
var myPos = ai.MyGrid.PositionComp.WorldAABB.Center;
var myHeading = Vector3D.Normalize(myPos - targetPos);
var intercept = MathFuncs.IsDotProductWithinTolerance(ref targetDir, ref myHeading, s.ApproachDegrees);
var retreat = MathFuncs.IsDotProductWithinTolerance(ref targetRevDir, ref myHeading, s.ApproachDegrees);
var distanceFromCenters = Vector3D.Distance(ai.MyGrid.PositionComp.WorldAABB.Center, target.PositionComp.WorldAABB.Center);
distanceFromCenters -= ai.MyGrid.PositionComp.LocalVolume.Radius;
distanceFromCenters -= target.PositionComp.LocalVolume.Radius;
distanceFromCenters = distanceFromCenters <= 0 ? 0 : distanceFromCenters;
var speed = (float)Math.Round(target.Physics?.Speed ?? 0, 1);
state.Name = name;
state.RealDistance = distanceFromCenters;
state.SizeExtended = (float)Math.Round(partCount / (largeGrid ? 100f : 500f), 1);
state.Speed = speed;
if (intercept)
{
state.Engagement = 0;
}
else if (retreat)
{
state.Engagement = 1;
}
else
{
state.Engagement = 2;
}
MyTuple <bool, bool, float, float, float, int> shieldInfo = new MyTuple <bool, bool, float, float, float, int>();
if (s.ShieldApiLoaded)
{
shieldInfo = s.SApi.GetShieldInfo(target);
}
if (shieldInfo.Item1)
{
var modInfo = s.SApi.GetModulationInfo(target);
var modValue = MyUtils.IsEqual(modInfo.Item3, modInfo.Item4) ? 0 : modInfo.Item3 > modInfo.Item4 ? modInfo.Item3 : -modInfo.Item4;
var faceInfo = s.SApi.GetFacesFast(target);
state.ShieldFaces = faceInfo.Item1 ? faceInfo.Item2 : Vector3I.Zero;
state.ShieldHeat = shieldInfo.Item6 / 10;
state.ShieldMod = modValue;
state.ShieldHealth = (float)Math.Round(shieldInfo.Item5);
}
else
{
state.ShieldHeat = 0;
state.ShieldMod = 0;
state.ShieldHealth = -1;
state.ShieldFaces = Vector3I.Zero;
}
var friend = false;
if (grid != null && grid.BigOwners.Count != 0)
{
var relation = MyIDModule.GetRelationPlayerBlock(ai.AiOwner, grid.BigOwners[0], MyOwnershipShareModeEnum.Faction);
if (relation == MyRelationsBetweenPlayerAndBlock.FactionShare || relation == MyRelationsBetweenPlayerAndBlock.Owner || relation == MyRelationsBetweenPlayerAndBlock.Friends)
{
friend = true;
}
}
if (friend)
{
state.ThreatLvl = -1;
}
else
{
int shieldBonus = 0;
if (s.ShieldApiLoaded)
{
var myShieldInfo = s.SApi.GetShieldInfo(ai.MyGrid);
if (shieldInfo.Item1 && myShieldInfo.Item1)
{
shieldBonus = shieldInfo.Item5 > myShieldInfo.Item5 ? 1 : -1;
}
else if (shieldInfo.Item1)
{
shieldBonus = 1;
}
else if (myShieldInfo.Item1)
{
shieldBonus = -1;
}
}
if (offenseRating > 5)
{
state.ThreatLvl = shieldBonus < 0 ? 8 : 9;
}
else if (offenseRating > 4)
{
state.ThreatLvl = 8 + shieldBonus;
}
else if (offenseRating > 3)
{
state.ThreatLvl = 7 + shieldBonus;
}
else if (offenseRating > 2)
{
state.ThreatLvl = 6 + shieldBonus;
}
else if (offenseRating > 1)
{
state.ThreatLvl = 5 + shieldBonus;
}
else if (offenseRating > 0.5)
{
state.ThreatLvl = 4 + shieldBonus;
}
else if (offenseRating > 0.25)
{
state.ThreatLvl = 3 + shieldBonus;
}
else if (offenseRating > 0.125)
{
state.ThreatLvl = 2 + shieldBonus;
}
else if (offenseRating > 0.0625)
{
state.ThreatLvl = 1 + shieldBonus;
}
else if (offenseRating > 0)
{
state.ThreatLvl = shieldBonus > 0 ? 1 : 0;
}
else
{
state.ThreatLvl = -1;
}
}
}
return(validFocus);
}
internal bool CreateEntInfo(MyEntity entity, long gridOwner, out Sandbox.ModAPI.Ingame.MyDetectedEntityInfo entInfo)
{
if (entity == null)
{
entInfo = new Sandbox.ModAPI.Ingame.MyDetectedEntityInfo();
return(false);
}
var topMostParent = entity.GetTopMostParent() as MyCubeGrid;
if (topMostParent != null)
{
var type = topMostParent.GridSizeEnum != MyCubeSize.Small ? Sandbox.ModAPI.Ingame.MyDetectedEntityType.LargeGrid : Sandbox.ModAPI.Ingame.MyDetectedEntityType.SmallGrid;
var hasOwner = topMostParent.BigOwners.Count != 0;
MyRelationsBetweenPlayerAndBlock relationship;
if (hasOwner)
{
var topOwner = topMostParent.BigOwners[0];
relationship = MyIDModule.GetRelationPlayerBlock(gridOwner, topOwner, MyOwnershipShareModeEnum.Faction);
if (relationship == MyRelationsBetweenPlayerAndBlock.Neutral)
{
var topFaction = MyAPIGateway.Session.Factions.TryGetPlayerFaction(topOwner);
if (topFaction != null)
{
var aiFaction = MyAPIGateway.Session.Factions.TryGetPlayerFaction(gridOwner);
if (aiFaction != null && MyAPIGateway.Session.Factions.GetReputationBetweenPlayerAndFaction(aiFaction.FactionId, topFaction.FactionId) < -500)
{
relationship = MyRelationsBetweenPlayerAndBlock.Enemies;
}
}
}
}
else
{
relationship = MyRelationsBetweenPlayerAndBlock.Owner;
}
entInfo = new Sandbox.ModAPI.Ingame.MyDetectedEntityInfo(topMostParent.EntityId, string.Empty, type, null, MatrixD.Zero, Vector3.Zero, relationship, new BoundingBoxD(), Session.Tick);
return(true);
}
var myCharacter = entity as IMyCharacter;
if (myCharacter != null)
{
var controllingId = myCharacter.ControllerInfo?.ControllingIdentityId;
var playerId = controllingId ?? 0;
var type = !myCharacter.IsPlayer ? Sandbox.ModAPI.Ingame.MyDetectedEntityType.CharacterOther : Sandbox.ModAPI.Ingame.MyDetectedEntityType.CharacterHuman;
var relationPlayerBlock = MyIDModule.GetRelationPlayerBlock(gridOwner, playerId, MyOwnershipShareModeEnum.Faction);
entInfo = new Sandbox.ModAPI.Ingame.MyDetectedEntityInfo(entity.EntityId, string.Empty, type, null, MatrixD.Zero, Vector3.Zero, relationPlayerBlock, new BoundingBoxD(), Session.Tick);
return(!myCharacter.IsDead);
}
const MyRelationsBetweenPlayerAndBlock relationship1 = MyRelationsBetweenPlayerAndBlock.Neutral;
var myPlanet = entity as MyPlanet;
if (myPlanet != null)
{
const Sandbox.ModAPI.Ingame.MyDetectedEntityType type = Sandbox.ModAPI.Ingame.MyDetectedEntityType.Planet;
entInfo = new Sandbox.ModAPI.Ingame.MyDetectedEntityInfo(entity.EntityId, string.Empty, type, null, MatrixD.Zero, Vector3.Zero, relationship1, new BoundingBoxD(), Session.Tick);
return(true);
}
if (entity is MyVoxelMap)
{
const Sandbox.ModAPI.Ingame.MyDetectedEntityType type = Sandbox.ModAPI.Ingame.MyDetectedEntityType.Asteroid;
entInfo = new Sandbox.ModAPI.Ingame.MyDetectedEntityInfo(entity.EntityId, string.Empty, type, null, MatrixD.Zero, Vector3.Zero, relationship1, new BoundingBoxD(), Session.Tick);
return(true);
}
if (entity is MyMeteor)
{
const Sandbox.ModAPI.Ingame.MyDetectedEntityType type = Sandbox.ModAPI.Ingame.MyDetectedEntityType.Meteor;
entInfo = new Sandbox.ModAPI.Ingame.MyDetectedEntityInfo(entity.EntityId, string.Empty, type, null, MatrixD.Zero, Vector3.Zero, MyRelationsBetweenPlayerAndBlock.Enemies, new BoundingBoxD(), Session.Tick);
return(true);
}
entInfo = new Sandbox.ModAPI.Ingame.MyDetectedEntityInfo();
return(false);
}
void Scan()
{
m_lastScan = MySession.Static.GameplayFrameCounter;
ProfilerShort.Begin("QueryTargets");
BoundingSphereD bs = new BoundingSphereD(Vector3D.Transform(m_queryLocal.Center, m_grid.WorldMatrix), m_queryLocal.Radius);
m_targetRoots.Clear();
m_targetBlocks.Clear();
ProfilerShort.Begin("MyGamePruningStructure.GetAllTop...");
MyGamePruningStructure.GetAllTopMostEntitiesInSphere(ref bs, m_targetRoots);
ProfilerShort.End();
int targetCount = m_targetRoots.Count;
m_ownersA.AddList(m_grid.SmallOwners);
m_ownersA.AddList(m_grid.BigOwners);
for (int i = 0; i < targetCount; i++)
{
var grid = m_targetRoots[i] as MyCubeGrid; //perf: using grid owners to not querry friendly ships for blocks
if (grid != null)
{
if (grid.Physics != null && !grid.Physics.Enabled)
{
continue;
}
ProfilerShort.Begin("Friend checks");
bool enemy = false;
if (grid.BigOwners.Count == 0 && grid.SmallOwners.Count == 0)
{
foreach (var owner in m_ownersA)
{
if (MyIDModule.GetRelation(owner, 0) == VRage.Game.MyRelationsBetweenPlayerAndBlock.Enemies)
{
enemy = true;
break;
}
}
}
else
{
m_ownersB.AddList(grid.BigOwners);
m_ownersB.AddList(grid.SmallOwners);
foreach (var owner in m_ownersA)
{
foreach (var other in m_ownersB)
{
if (MyIDModule.GetRelation(owner, other) == VRage.Game.MyRelationsBetweenPlayerAndBlock.Enemies)
{
enemy = true;
break;
}
}
}
m_ownersB.Clear();
}
ProfilerShort.End();
if (enemy)
{
ProfilerShort.Begin("grid.Hierarchy.QuerySphere");
var list = m_targetBlocks.GetOrAddList(grid);
grid.Hierarchy.QuerySphere(ref bs, list);
ProfilerShort.End();
}
else
{
MyIDModule module;
//performance unfriendly case when grid is not clearly neutral or enemy
foreach (var block in grid.GetFatBlocks())
{
var moduleOwner = ((MyEntity)block) as IMyComponentOwner <MyIDModule>;
if (!(moduleOwner != null && moduleOwner.GetComponent(out module)))
{
continue;
}
var myID = block.OwnerId;
foreach (var owner in m_ownersA)
{
if (MyIDModule.GetRelation(owner, myID) == VRage.Game.MyRelationsBetweenPlayerAndBlock.Enemies)
{
enemy = true;
break;
}
}
if (enemy)
{
break;
}
}
if (enemy)
{
ProfilerShort.Begin("grid.Hierarchy.QuerySphere");
var list = m_targetBlocks.GetOrAddList(grid);
grid.Hierarchy.QuerySphere(ref bs, list);
ProfilerShort.End();
}
}
}
}
m_ownersA.Clear();
ProfilerShort.Begin("Filter small objects");
for (int i = m_targetRoots.Count - 1; i >= 0; i--)
{
var target = m_targetRoots[i];
if (target is Sandbox.Game.Entities.Debris.MyDebrisBase ||
target is MyFloatingObject ||
(target.Physics != null && !target.Physics.Enabled) ||
target.GetTopMostParent().Physics == null || !target.GetTopMostParent().Physics.Enabled)
{
m_targetRoots.RemoveAtFast(i);
}
}
ProfilerShort.End();
ProfilerShort.End();
}
private static MyTuple <bool, float> TAPI_IntersectEntToShieldFast(List <MyEntity> entities, RayD ray, bool onlyIfOnline, bool enenmyOnly = false, long requesterId = 0, float maxLengthSqr = float.MaxValue)
{
if (enenmyOnly)
{
if (requesterId == 0)
{
return(new MyTuple <bool, float>(false, 0));
}
}
float closestOtherDist = float.MaxValue;
float closestFriendDist = float.MaxValue;
bool closestOther = false;
bool closestFriend = false;
for (int i = 0; i < entities.Count; i++)
{
var entity = entities[i];
ShieldGridComponent c;
if (entity != null && Session.Instance.IdToBus.TryGetValue(entity.EntityId, out c) && c?.DefenseShields?.DsState?.State != null && c.DefenseShields.MyCube != null)
{
var s = c.DefenseShields;
if (onlyIfOnline && (!s.DsState.State.Online || s.DsState.State.Lowered) || s.ReInforcedShield)
{
continue;
}
lock (s.MatrixLock) {
var normSphere = new BoundingSphereD(Vector3.Zero, 1f);
var kRay = new RayD(Vector3D.Zero, Vector3D.Forward);
var ellipsoidMatrixInv = s.DetectMatrixOutsideInv;
Vector3D krayPos;
Vector3D.Transform(ref ray.Position, ref ellipsoidMatrixInv, out krayPos);
Vector3D nDir;
Vector3D.TransformNormal(ref ray.Direction, ref ellipsoidMatrixInv, out nDir);
Vector3D krayDir;
Vector3D.Normalize(ref nDir, out krayDir);
kRay.Direction = krayDir;
kRay.Position = krayPos;
var nullDist = normSphere.Intersects(kRay);
if (!nullDist.HasValue)
{
continue;
}
var hitPos = krayPos + (krayDir * -nullDist.Value);
var ellipsoidMatrix = s.DetectMatrixOutside;
Vector3D worldHitPos;
Vector3D.Transform(ref hitPos, ref ellipsoidMatrix, out worldHitPos);
var intersectDist = Vector3.DistanceSquared(worldHitPos, ray.Position);
if (intersectDist <= 0 || intersectDist > maxLengthSqr)
{
continue;
}
var firstOrLast = enenmyOnly && (!closestFriend || intersectDist < closestFriendDist);
var notEnemyCheck = false;
if (firstOrLast)
{
var relationship = MyIDModule.GetRelationPlayerBlock(requesterId, s.MyCube.OwnerId);
var enemy = relationship != MyRelationsBetweenPlayerAndBlock.Owner && relationship != MyRelationsBetweenPlayerAndBlock.FactionShare;
notEnemyCheck = !enemy;
}
if (notEnemyCheck)
{
closestFriendDist = intersectDist;
closestFriend = true;
}
else
{
closestOtherDist = intersectDist;
closestOther = true;
}
}
}
}
if (!enenmyOnly && closestOther || closestOther && !closestFriend)
{
return(new MyTuple <bool, float>(true, closestOtherDist));
}
if (closestFriend && !closestOther || closestFriendDist < closestOtherDist)
{
return(new MyTuple <bool, float>(false, closestFriendDist));
}
if (!closestOther)
{
return(new MyTuple <bool, float>(false, 0));
}
return(new MyTuple <bool, float>(true, closestOtherDist));
}
