private void ShieldIntersect(MyEntity ent)
{
var grid = ent as MyCubeGrid;
if (grid == null)
{
return;
}
if (GridInside(grid, MyOrientedBoundingBoxD.CreateFromBoundingBox(grid.PositionComp.WorldAABB)))
{
return;
}
ShieldGridComponent shieldComponent;
grid.Components.TryGet(out shieldComponent);
if (shieldComponent?.DefenseShields == null)
{
return;
}
var ds = shieldComponent.DefenseShields;
if (!ds.WasOnline)
{
EntIntersectInfo entInfo;
WebEnts.TryRemove(ent, out entInfo);
}
var dsVerts = ds.ShieldComp.PhysicsOutside;
var dsMatrixInv = ds.DetectMatrixOutsideInv;
var myGrid = Shield.CubeGrid;
var insidePoints = new List <Vector3D>();
if (_isServer)
{
CustomCollision.ShieldX2PointsInside(dsVerts, dsMatrixInv, ShieldComp.PhysicsOutside, DetectMatrixOutsideInv, insidePoints);
}
else
{
CustomCollision.ClientShieldX2PointsInside(dsVerts, dsMatrixInv, ShieldComp.PhysicsOutsideLow, DetectMatrixOutsideInv, insidePoints);
}
var bPhysics = ((IMyCubeGrid)grid).Physics;
var sPhysics = myGrid.Physics;
var bMass = grid.GetCurrentMass();
var sMass = ((MyCubeGrid)myGrid).GetCurrentMass();
if (bMass <= 0)
{
bMass = int.MaxValue;
}
if (sMass <= 0)
{
sMass = int.MaxValue;
}
var bVel = bPhysics.LinearVelocity;
var bVelLen = bVel.Length();
var momentum = (bMass * bVel) + (sMass * sPhysics.LinearVelocity);
var resultVelocity = momentum / (bMass + sMass);
var collisionAvg = Vector3D.Zero;
var numOfPointsInside = insidePoints.Count;
for (int i = 0; i < numOfPointsInside; i++)
{
collisionAvg += insidePoints[i];
}
collisionAvg /= numOfPointsInside;
if (numOfPointsInside > 0 && !bPhysics.IsStatic)
{
var ejectorAccel = numOfPointsInside > 10 ? numOfPointsInside : 10;
var impulseData = new MyImpulseData {
MyGrid = grid, Direction = (resultVelocity - bVel) * bMass, Position = bPhysics.CenterOfMassWorld
};
var forceData = new MyAddForceData {
MyGrid = grid, Force = (bPhysics.CenterOfMassWorld - collisionAvg) * bMass * ejectorAccel, MaxSpeed = MathHelper.Clamp(bVelLen, 1f, 50f)
};
ImpulseData.Enqueue(impulseData);
ForceData.Enqueue(forceData);
}
if (!_isServer || numOfPointsInside <= 0)
{
return;
}
var shieldMaxChargeRate = ds._shieldMaxChargeRate;
var damage = ((shieldMaxChargeRate * ConvToHp) * DsState.State.ModulateKinetic) * 0.01666666666f;
if (_mpActive)
{
if (_isServer)
{
AddShieldHit(ds.Shield.EntityId, damage, Session.Instance.MPEnergy, null, false, collisionAvg);
}
}
else
{
EnergyHit = true;
WorldImpactPosition = collisionAvg;
ds.EnergyHit = true;
ds.WorldImpactPosition = collisionAvg;
Absorb += damage;
ImpactSize = damage;
WebDamage = true;
}
}
private void BlockIntersect(MyCubeGrid breaching, MyOrientedBoundingBoxD bOriBBoxD, EntIntersectInfo entInfo)
{
var collisionAvg = Vector3D.Zero;
var transformInv = DetectMatrixOutsideInv;
var normalMat = MatrixD.Transpose(transformInv);
var damageBlocks = Session.Enforced.DisableBlockDamage == 0;
var blockDmgNum = 5;
if (ShieldMode == ShieldType.Station && DsState.State.Enhancer)
{
blockDmgNum = 50;
}
var intersection = bOriBBoxD.Intersects(ref SOriBBoxD);
try
{
if (intersection)
{
var cacheBlockList = entInfo.CacheBlockList;
var bPhysics = ((IMyCubeGrid)breaching).Physics;
var sPhysics = Shield.CubeGrid.Physics;
var sGrid = (MyCubeGrid)Shield.CubeGrid;
var bMass = breaching.GetCurrentMass();
var sMass = sGrid.GetCurrentMass();
var momentum = (bMass * bPhysics.LinearVelocity) + (sMass * sPhysics.LinearVelocity);
var resultVelocity = momentum / (bMass + sMass);
Vector3D bBlockCenter;
var stale = false;
var rawDamage = 0f;
var blockSize = breaching.GridSize;
var gc = breaching.WorldToGridInteger(DetectionCenter);
var rc = ShieldSize.AbsMax() / blockSize;
rc *= rc;
rc = rc + 1;
rc = Math.Ceiling(rc);
var hits = 0;
var blockPoints = new Vector3D[9];
for (int i = 0; i < cacheBlockList.Count; i++)
{
var block = cacheBlockList[i];
var blockPos = block.Position;
var num1 = gc.X - blockPos.X;
var num2 = gc.Y - blockPos.Y;
var num3 = gc.Z - blockPos.Z;
var result = (num1 * num1) + (num2 * num2) + (num3 * num3);
if (_isServer)
{
if (result > rc)
{
continue;
}
if (damageBlocks && block.IsDestroyed)
{
DestroyedBlocks.Enqueue(block);
continue;
}
if (block.CubeGrid != breaching)
{
stale = true;
continue;
}
}
else
{
if (hits > blockDmgNum)
{
break;
}
if (result > rc || block.IsDestroyed || block.CubeGrid != breaching)
{
continue;
}
}
BoundingBoxD blockBox;
block.GetWorldBoundingBox(out blockBox);
blockBox.GetCorners(blockPoints);
blockPoints[8] = blockBox.Center;
for (int j = 8; j > -1; j--)
{
var point = blockPoints[j];
if (Vector3.Transform(point, DetectMatrixOutsideInv).LengthSquared() > 1)
{
continue;
}
collisionAvg += point;
hits++;
if (!_isServer)
{
break;
}
if (!damageBlocks)
{
if (hits > blockDmgNum)
{
break;
}
}
else if (CollidingBlocks.Count > blockDmgNum)
{
break;
}
rawDamage += MathHelper.Clamp(block.Integrity, 0, 350);
if (damageBlocks)
{
CollidingBlocks.Enqueue(block);
}
break;
}
}
entInfo.MarkForClose = stale;
if (collisionAvg != Vector3D.Zero)
{
collisionAvg /= hits;
if (sPhysics.IsStatic && !bPhysics.IsStatic)
{
var bLSpeed = bPhysics.LinearVelocity;
var bASpeed = bPhysics.AngularVelocity * 100;
var bLSpeedLen = bLSpeed.Length();
var bASpeedLen = bASpeed.Length();
bASpeedLen = MathHelper.Clamp(bASpeedLen, 0, 50);
var bSpeedLen = bLSpeedLen > bASpeedLen ? bLSpeedLen : bASpeedLen;
var surfaceMass = (bMass > sMass) ? sMass : bMass;
var surfaceMulti = (hits > 5) ? 5 : hits;
var localNormal = Vector3D.Transform(collisionAvg, transformInv);
var surfaceNormal = Vector3D.Normalize(Vector3D.TransformNormal(localNormal, normalMat));
var impulseData1 = new MyImpulseData {
MyGrid = breaching, Direction = (resultVelocity - bLSpeed) * bMass, Position = bPhysics.CenterOfMassWorld
};
var impulseData2 = new MyImpulseData {
MyGrid = breaching, Direction = surfaceMulti * (surfaceMass * 0.025) * -Vector3D.Dot(bLSpeed, surfaceNormal) * surfaceNormal, Position = collisionAvg
};
var forceData = new MyAddForceData {
MyGrid = breaching, Force = (bPhysics.CenterOfMassWorld - collisionAvg) * (bMass * bSpeedLen), MaxSpeed = MathHelper.Clamp(bSpeedLen, 1f, bSpeedLen * 0.5f)
};
ImpulseData.Enqueue(impulseData1);
ImpulseData.Enqueue(impulseData2);
ForceData.Enqueue(forceData);
}
else
{
var bLSpeed = bPhysics.LinearVelocity;
var bASpeed = bPhysics.AngularVelocity * 100;
var bLSpeedLen = bLSpeed.Length();
var bASpeedLen = bASpeed.Length();
bASpeedLen = MathHelper.Clamp(bASpeedLen, 0, 50);
var bSpeedLen = bLSpeedLen > bASpeedLen ? bLSpeedLen : bASpeedLen;
float?speed;
if (!bPhysics.IsStatic)
{
var bImpulseData = new MyImpulseData {
MyGrid = breaching, Direction = (resultVelocity - bLSpeed) * bMass, Position = bPhysics.CenterOfMassWorld
};
ImpulseData.Enqueue(bImpulseData);
}
if (!sPhysics.IsStatic)
{
var sImpulseData = new MyImpulseData {
MyGrid = sGrid, Direction = (resultVelocity - sPhysics.LinearVelocity) * sMass, Position = sPhysics.CenterOfMassWorld
};
ImpulseData.Enqueue(sImpulseData);
}
if (!sPhysics.IsStatic)
{
if (bMass / sMass > 20)
{
speed = MathHelper.Clamp(bSpeedLen, 1f, bSpeedLen * 0.5f);
}
else
{
speed = null;
}
var sForceData = new MyAddForceData {
MyGrid = sGrid, Force = (sPhysics.CenterOfMassWorld - collisionAvg) * bMass, MaxSpeed = speed
};
ForceData.Enqueue(sForceData);
}
if (!bPhysics.IsStatic)
{
if (sMass / bMass > 20)
{
speed = MathHelper.Clamp(bSpeedLen, 1f, bSpeedLen * 0.5f);
}
else
{
speed = null;
}
var bForceData = new MyAddForceData {
MyGrid = breaching, Force = (bPhysics.CenterOfMassWorld - collisionAvg) * sMass, MaxSpeed = speed
};
ForceData.Enqueue(bForceData);
}
}
WebDamage = true;
bBlockCenter = collisionAvg;
}
else
{
return;
}
if (!_isServer)
{
return;
}
var damage = rawDamage * DsState.State.ModulateEnergy;
entInfo.Damage = damage;
if (_mpActive)
{
if (_isServer && bBlockCenter != Vector3D.NegativeInfinity)
{
AddShieldHit(breaching.EntityId, damage, Session.Instance.MPKinetic, null, false, collisionAvg);
}
}
else
{
if (bBlockCenter != Vector3D.NegativeInfinity)
{
entInfo.ContactPoint = bBlockCenter;
ImpactSize = entInfo.Damage;
entInfo.Damage = 0;
entInfo.EmpSize = 0;
WorldImpactPosition = bBlockCenter;
}
}
Absorb += damage;
}
}
catch (Exception ex) { Log.Line($"Exception in BlockIntersect: {ex}"); }
}
private void SyncThreadedEnts(bool clear = false, bool client = false)
{
try
{
if (clear)
{
Eject.Clear();
DestroyedBlocks.Clear();
MissileDmg.Clear();
MeteorDmg.Clear();
VoxelDmg.Clear();
CharacterDmg.Clear();
FewDmgBlocks.Clear();
CollidingBlocks.Clear();
ForceData.Clear();
ImpulseData.Clear();
return;
}
try
{
if (!Eject.IsEmpty)
{
MyCubeGrid myGrid;
while (Eject.TryDequeue(out myGrid))
{
if (myGrid == null || myGrid.MarkedForClose)
{
continue;
}
myGrid.Physics.LinearVelocity *= -0.25f;
}
}
}
catch (Exception ex) { Log.Line($"Exception in Eject: {ex}"); }
try
{
if (!ForceData.IsEmpty)
{
MyAddForceData data;
while (ForceData.TryDequeue(out data))
{
var myGrid = data.MyGrid;
if (myGrid == null || myGrid.MarkedForClose)
{
continue;
}
myGrid.Physics.AddForce(MyPhysicsForceType.APPLY_WORLD_FORCE, data.Force, null, Vector3D.Zero, data.MaxSpeed, data.Immediate);
}
}
}
catch (Exception ex) { Log.Line($"Exception in forceData: {ex}"); }
try
{
if (!ImpulseData.IsEmpty)
{
MyImpulseData data;
while (ImpulseData.TryDequeue(out data))
{
var myGrid = data.MyGrid;
if (myGrid == null || myGrid.MarkedForClose)
{
continue;
}
myGrid.Physics.ApplyImpulse(data.Direction, data.Position);
}
}
}
catch (Exception ex) { Log.Line($"Exception in impulseData: {ex}"); }
if (client)
{
return;
}
try
{
if (!DestroyedBlocks.IsEmpty)
{
IMySlimBlock block;
var nullCount = 0;
while (DestroyedBlocks.TryDequeue(out block))
{
var myGrid = block.CubeGrid as MyCubeGrid;
if (myGrid == null)
{
continue;
}
EntIntersectInfo entInfo;
WebEnts.TryGetValue(myGrid, out entInfo);
if (entInfo == null)
{
nullCount++;
myGrid.EnqueueDestroyedBlock(block.Position);
continue;
}
EntIntersectInfo entRemoved;
if (nullCount > 0)
{
WebEnts.TryRemove(myGrid, out entRemoved);
}
entInfo.CacheBlockList.Remove(block);
myGrid.EnqueueDestroyedBlock(block.Position);
}
}
}
catch (Exception ex) { Log.Line($"Exception in destroyedBlocks: {ex}"); }
try
{
if (!MissileDmg.IsEmpty)
{
MyEntity ent;
while (MissileDmg.TryDequeue(out ent))
{
if (ent == null || !ent.InScene || ent.MarkedForClose)
{
continue;
}
var computedDamage = ComputeAmmoDamage(ent);
var damage = computedDamage * DsState.State.ModulateKinetic;
if (computedDamage < 0)
{
damage = computedDamage;
}
var rayDir = Vector3D.Normalize(ent.Physics.LinearVelocity);
var ray = new RayD(ent.PositionComp.WorldVolume.Center, rayDir);
var intersect = CustomCollision.IntersectEllipsoid(DetectMatrixOutsideInv, DetectionMatrix, ray);
var hitDist = intersect ?? 0;
var hitPos = ray.Position + (ray.Direction * -hitDist);
if (_mpActive)
{
AddShieldHit(ent.EntityId, damage, Session.Instance.MPExplosion, null, false, hitPos);
ent.Close();
ent.InScene = false;
}
else
{
EnergyHit = true;
WorldImpactPosition = hitPos;
Absorb += damage;
ImpactSize = damage;
UtilsStatic.CreateFakeSmallExplosion(hitPos);
ent.Close();
ent.InScene = false;
}
}
}
}
catch (Exception ex) { Log.Line($"Exception in missileDmg: {ex}"); }
try
{
if (!MeteorDmg.IsEmpty)
{
IMyMeteor meteor;
while (MeteorDmg.TryDequeue(out meteor))
{
if (meteor == null || meteor.MarkedForClose || meteor.Closed)
{
continue;
}
var damage = 5000 * DsState.State.ModulateEnergy;
if (_mpActive)
{
AddShieldHit(meteor.EntityId, damage, Session.Instance.MPKinetic, null, false, meteor.PositionComp.WorldVolume.Center);
meteor.DoDamage(10000f, Session.Instance.MpIgnoreDamage, true, null, MyCube.EntityId);
}
else
{
WorldImpactPosition = meteor.PositionComp.WorldVolume.Center;
Absorb += damage;
ImpactSize = damage;
meteor.DoDamage(10000f, Session.Instance.MpIgnoreDamage, true, null, MyCube.EntityId);
}
}
}
}
catch (Exception ex) { Log.Line($"Exception in missileDmg: {ex}"); }
try
{
if (!VoxelDmg.IsEmpty)
{
MyVoxelBase voxel;
while (VoxelDmg.TryDequeue(out voxel))
{
if (voxel == null || voxel.RootVoxel.MarkedForClose || voxel.RootVoxel.Closed)
{
continue;
}
voxel.RootVoxel.RequestVoxelOperationElipsoid(Vector3.One * 1.0f, DetectMatrixOutside, 0, MyVoxelBase.OperationType.Cut);
}
}
}
catch (Exception ex) { Log.Line($"Exception in missileDmg: {ex}"); }
try
{
if (!CharacterDmg.IsEmpty)
{
IMyCharacter character;
while (CharacterDmg.TryDequeue(out character))
{
var npcname = character.ToString();
if (npcname.Equals("Space_Wolf"))
{
character.Delete();
continue;
}
var hId = MyCharacterOxygenComponent.HydrogenId;
var playerGasLevel = character.GetSuitGasFillLevel(hId);
character.Components.Get <MyCharacterOxygenComponent>().UpdateStoredGasLevel(ref hId, (playerGasLevel * -0.0001f) + .002f);
MyVisualScriptLogicProvider.CreateExplosion(character.GetPosition(), 0, 0);
character.DoDamage(50f, Session.Instance.MpIgnoreDamage, true, null, MyCube.EntityId);
var vel = character.Physics.LinearVelocity;
if (vel == new Vector3D(0, 0, 0))
{
vel = MyUtils.GetRandomVector3Normalized();
}
var speedDir = Vector3D.Normalize(vel);
var rnd = new Random();
var randomSpeed = rnd.Next(10, 20);
var additionalSpeed = vel + (speedDir * randomSpeed);
character.Physics.LinearVelocity = additionalSpeed;
}
}
}
catch (Exception ex) { Log.Line($"Exception in missileDmg: {ex}"); }
try
{
if (!CollidingBlocks.IsEmpty)
{
IMySlimBlock block;
var damageMulti = 350;
if (ShieldMode == ShieldType.Station && DsState.State.Enhancer)
{
damageMulti = 10000;
}
while (CollidingBlocks.TryDequeue(out block))
{
if (block == null)
{
continue;
}
var myGrid = block.CubeGrid as MyCubeGrid;
if (block.IsDestroyed)
{
myGrid.EnqueueDestroyedBlock(block.Position);
continue;
}
block.DoDamage(damageMulti, Session.Instance.MpIgnoreDamage, true, null, MyCube.EntityId);
if (myGrid.BlocksCount == 0)
{
myGrid.SendGridCloseRequest();
}
}
}
}
catch (Exception ex) { Log.Line($"Exception in dmgBlocks: {ex}"); }
try
{
if (!FewDmgBlocks.IsEmpty)
{
IMySlimBlock block;
while (FewDmgBlocks.TryDequeue(out block))
{
if (block == null)
{
continue;
}
var myGrid = block.CubeGrid as MyCubeGrid;
if (block.IsDestroyed)
{
myGrid.EnqueueDestroyedBlock(block.Position);
myGrid.Close();
continue;
}
block.DoDamage(block.MaxIntegrity * 0.9f, Session.Instance.MpIgnoreDamage, true, null, MyCube.EntityId);
if (myGrid.BlocksCount == 0)
{
myGrid.SendGridCloseRequest();
}
}
}
}
catch (Exception ex) { Log.Line($"Exception in fewBlocks: {ex}"); }
try
{
if (Session.Instance.EmpWork.EventRunning && Vector3D.DistanceSquared(DetectionCenter, Session.Instance.EmpWork.EpiCenter) <= Session.Instance.EmpWork.RangeCapSqr)
{
var empResistenceRatio = 1f;
const long AttackerId = 0L;
var energyResistenceRatio = DsState.State.ModulateKinetic;
var epiCenter = Session.Instance.EmpWork.EpiCenter;
var rangeCap = Session.Instance.EmpWork.RangeCap;
var empDirYield = Session.Instance.EmpWork.DirYield;
if (DsState.State.EmpProtection)
{
if (energyResistenceRatio < 0.4)
{
energyResistenceRatio = 0.4f;
}
empResistenceRatio = 0.1f;
}
//if (Session.Enforced.Debug >= 2) Log.Line($"[EmpBlastShield - Start] ShieldOwner:{MyGrid.DebugName} - Yield:{warHeadYield} - StackCount:{stackCount} - ProtectionRatio:{energyResistenceRatio * empResistenceRatio} - epiCenter:{epiCenter}");
var line = new LineD(epiCenter, SOriBBoxD.Center);
var testDir = Vector3D.Normalize(line.From - line.To);
var ray = new RayD(line.From, -testDir);
var ellipsoid = CustomCollision.IntersectEllipsoid(DetectMatrixOutsideInv, DetectionMatrix, ray);
if (!ellipsoid.HasValue)
{
//if (Session.Enforced.Debug >= 2) Log.Line($"[EmpBlastShield - Ellipsoid null hit] ShieldOwner:{MyGrid.DebugName} - Yield:{warHeadYield} - StackCount:{stackCount} - ProtectionRatio:{energyResistenceRatio * empResistenceRatio} - epiCenter:{epiCenter}");
return;
}
var impactPos = line.From + (testDir * -ellipsoid.Value);
IHitInfo hitInfo;
MyAPIGateway.Physics.CastRay(epiCenter, impactPos, out hitInfo, CollisionLayers.DefaultCollisionLayer);
if (hitInfo != null)
{
//if (Session.Enforced.Debug >= 2) Log.Line($"[EmpBlastShield - occluded] ShieldOwner:{MyGrid.DebugName} - by {((MyEntity)hitInfo.HitEntity).DebugName}");
return;
}
var gridLocalMatrix = MyGrid.PositionComp.LocalMatrix;
var worldDirection = impactPos - gridLocalMatrix.Translation;
var localPosition = Vector3D.TransformNormal(worldDirection, MatrixD.Transpose(gridLocalMatrix));
var hitFaceSurfaceArea = UtilsStatic.GetIntersectingSurfaceArea(ShieldShapeMatrix, localPosition);
var invSqrDist = UtilsStatic.InverseSqrDist(epiCenter, impactPos, rangeCap);
var damageScaler = invSqrDist * hitFaceSurfaceArea;
if (invSqrDist <= 0)
{
//if (Session.Enforced.Debug >= 2) Log.Line($"[EmpBlastShield - Range] ShieldOwner:{MyGrid.DebugName} - insqrDist was 0");
return;
}
var targetDamage = (float)(((empDirYield * damageScaler) * energyResistenceRatio) * empResistenceRatio);
if (targetDamage >= DsState.State.Charge * ConvToHp)
{
_empOverLoad = true;
}
//if (Session.Enforced.Debug >= 2) Log.Line($"-----------------------] epiDist:{Vector3D.Distance(epiCenter, impactPos)} - iSqrDist:{invSqrDist} - RangeCap:{rangeCap} - SurfaceA:{hitFaceSurfaceArea}({_ellipsoidSurfaceArea * 0.5}) - dirYield:{empDirYield} - damageScaler:{damageScaler} - Damage:{targetDamage}(toOver:{(targetDamage / (DsState.State.Charge * ConvToHp))})");
if (_isServer && _mpActive)
{
AddEmpBlastHit(AttackerId, targetDamage, Session.Instance.MPEMP, impactPos);
}
EnergyHit = true;
WorldImpactPosition = epiCenter;
Absorb += targetDamage;
}
}
catch (Exception ex) { Log.Line($"Exception in EmpBlast: {ex}"); }
}
catch (Exception ex) { Log.Line($"Exception in DamageGrids: {ex}"); }
}