public void OnWorldPosChanged(ref MatrixD newTransform)
{
MatrixD worldPos = newTransform;
m_caster.OnWorldPositionChanged(ref worldPos);
var entitiesInRange = this.m_caster.EntitiesInRange;
float closestDistance = float.MaxValue;
MyEntity closestEntity = null;
if (!m_isPointOfRefSet)
m_pointOfReference = worldPos.Translation;
if (entitiesInRange != null && entitiesInRange.Count > 0)
{
// int i = 0;
foreach (var entity in entitiesInRange.Values)
{
float distanceSq = (float)Vector3D.DistanceSquared(entity.DetectionPoint, m_pointOfReference);
if (entity.Entity.Physics != null && entity.Entity.Physics.Enabled)
{
if (distanceSq < closestDistance)
{
closestEntity = entity.Entity;
this.m_distanceToHitSq = distanceSq;
this.m_hitPosition = entity.DetectionPoint;
closestDistance = distanceSq;
}
}
// ++i;
}
}
this.m_hitCubeGrid = closestEntity as MyCubeGrid;
this.m_hitBlock = null;
this.m_hitDestroaybleObj = closestEntity as IMyDestroyableObject;
this.m_hitFloatingObject = closestEntity as MyFloatingObject;
this.m_hitCharacter = closestEntity as MyCharacter;
if (m_hitCubeGrid != null)
{
var invWorld = m_hitCubeGrid.PositionComp.WorldMatrixNormalizedInv;
var gridLocalPos = Vector3D.Transform(this.m_hitPosition, invWorld);
Vector3I blockPos;
m_hitCubeGrid.FixTargetCube(out blockPos, gridLocalPos / m_hitCubeGrid.GridSize);
m_hitBlock = m_hitCubeGrid.GetCubeBlock(blockPos);
}
}
public MyFloatingObjectPhysicsStateGroup(MyFloatingObject entity, IMyReplicable owner)
: base(entity, owner)
{
m_lowPrecisionOrientation = true;
m_prioritySettings.AcceleratingPriority /= 2;
m_prioritySettings.LinearMovingPriority /= 2;
m_prioritySettings.StoppedPriority /= 2;
m_prioritySettings.AcceleratingUpdateCount *= 2;
m_prioritySettings.LinearMovingUpdateCount *= 2;
m_prioritySettings.StoppedUpdateCount *= 2;
}
private static bool ComputeFloatingObjectAmount(MyFloatingObject obj, ref MyFixedPoint amount, MyInventory inv)
{
amount = obj.Item.Amount;
if (!MySession.Static.CreativeMode)
{
amount = MyFixedPoint.Min(amount, inv.ComputeAmountThatFits(obj.Item.Content.GetId()));
}
if (amount <= 0) // does not fit into inventory
{
return(false);
}
return(true);
}
static void RemoveFloating_Impelentation()
{
if (!MyEventContext.Current.IsLocallyInvoked && !MySession.Static.HasPlayerAdminRights(MyEventContext.Current.Sender.Value))
{
MyEventContext.ValidationFailed();
return;
}
foreach (var entity in MyEntities.GetEntities())
{
MyFloatingObject floating = entity as MyFloatingObject;
if (floating != null)
{
floating.SendCloseRequest();
}
}
}
private void OnRemoveFloating(MyGuiControlButton obj)
{
foreach (var entity in MyEntities.GetEntities())
{
MyFloatingObject floating = entity as MyFloatingObject;
if (floating != null)
{
if (Sync.IsServer)
{
floating.Close();
}
else
{
floating.SendCloseRequest();
}
}
}
}
public void TakeFloatingObject(MyFloatingObject obj)
{
MyFixedPoint amount = obj.Item.Amount;
if (MyPerGameSettings.ConstrainInventory())
amount = MyFixedPoint.Min(ComputeAmountThatFits(obj.Item.Content.GetObjectId()), amount);
if (amount > 0)
{
if (Sync.IsServer)
{
if (obj.MarkedForClose)
return;
MyFloatingObjects.RemoveFloatingObject(obj, amount);
AddItemsInternal(amount, obj.Item.Content);
SyncObject.SendAddItemsAnnounce(this, amount, obj.Item.Content);
}
else
SyncObject.TakeFloatingObjectRequest(this, obj);
}
}
//Do our actual removal.
void Entities_OnEntityAdd(IMyEntity entity)
{
MyFloatingObject floaty = entity as MyFloatingObject;
//Make sure its not null
if (floaty?.Item != null)
{
//Also make sure its not null
if (floaty.Item.Content?.SubtypeId != null)
{
MyStringHash subtype = floaty.Item.Content.SubtypeId;
//Do a 2fast4u comparison
if (m_scraphash.Equals(subtype))
{
//Delete the entity
entity.Close();
}
}
}
}
static void OnCreateFloatingObjectsCallback(ref FloatingObjectsCreateMsg msg, MyNetworkClient sender)
{
//MySandboxGame.Log.WriteLine("FloatingObjectsCreateMsg: " + msg.FloatingObjects.Count);
foreach (var floatingObject in msg.FloatingObjects)
{
foreach (var instance in floatingObject.Instances)
{
System.Diagnostics.Debug.Assert(instance.Amount > 0);
if (instance.Amount <= 0)
{
continue;
}
if (MyEntities.EntityExists(instance.Location.EntityId))
{
continue;
}
var objectBuilder = new MyObjectBuilder_FloatingObject();
objectBuilder.Item = new MyObjectBuilder_InventoryItem();
objectBuilder.Item.Amount = instance.Amount;
objectBuilder.Item.Content = MyObjectBuilderSerializer.CreateNewObject(((MyDefinitionId)floatingObject.TypeId).TypeId, ((MyDefinitionId)floatingObject.TypeId).SubtypeName);
objectBuilder.EntityId = instance.Location.EntityId;
objectBuilder.PositionAndOrientation = new MyPositionAndOrientation(instance.Location.Position, instance.Location.Forward, instance.Location.Up);
objectBuilder.PersistentFlags = MyPersistentEntityFlags2.InScene | MyPersistentEntityFlags2.Enabled | MyPersistentEntityFlags2.CastShadows;
MyFloatingObject floatingObjectAdded = (MyFloatingObject)MyEntities.CreateFromObjectBuilderAndAdd(objectBuilder);
if (floatingObjectAdded.Physics != null)
{
floatingObjectAdded.Physics.LinearVelocity = instance.Location.LinearVelocity;
floatingObjectAdded.Physics.AngularVelocity = instance.Location.AngularVelocity;
}
}
}
if (Sync.IsServer)
{
Sync.Layer.SendMessageToAllButOne(ref msg, sender.SteamUserId);
}
}
static void OnUpdateCompressedCallback(ref PositionUpdateCompressedMsg msg, MyNetworkClient sender)
{
MyEntity entity;
if (MyEntities.TryGetEntityById(msg.EntityId, out entity))
{
MyFloatingObject floatingObject = entity as MyFloatingObject;
if (floatingObject != null)
{
MatrixD matrix = msg.GetWorldMatrix();
floatingObject.PositionComp.SetWorldMatrix(matrix, sender);
if (floatingObject.Physics != null)
{
Vector3 linearVelocity, angularVelocity;
msg.GetVelocities(out linearVelocity, out angularVelocity);
floatingObject.Physics.LinearVelocity = linearVelocity;
floatingObject.Physics.AngularVelocity = angularVelocity;
}
}
}
}
static void OnUpdateCallback(ref FloatingObjectPositionUpdateMsg msg, MyNetworkClient sender)
{
Debug.Assert(!Sync.IsServer);
MyEntity entity;
if (MyEntities.TryGetEntityById(msg.EntityId, out entity))
{
MyFloatingObject floatingObject = entity as MyFloatingObject;
if (floatingObject != null)
{
MatrixD matrix = MatrixD.CreateWorld(msg.Position, msg.Forward, msg.Up);
Vector3D translation = floatingObject.PositionComp.GetPosition();
//Quaternion rotation = Quaternion.CreateFromRotationMatrix(floatingObject.WorldMatrix.GetOrientation());
Quaternion rotation = Quaternion.Identity;
m_rigidBodyList.Clear();
Sandbox.Engine.Physics.MyPhysics.GetPenetrationsShape(floatingObject.Physics.RigidBody.GetShape(), ref translation, ref rotation, m_rigidBodyList, Sandbox.Engine.Physics.MyPhysics.NotCollideWithStaticLayer);
//if (m_rigidBodyList.Count == 0 || MyPerGameSettings.EnableFloatingObjectsActiveSync)
//{
// floatingObject.PositionComp.SetWorldMatrix(matrix, sender);
//}
if (floatingObject.Physics != null)
{
if (m_rigidBodyList.Count == 1 && m_rigidBodyList[0].Body == floatingObject.Physics.RigidBody)
{
floatingObject.PositionComp.SetWorldMatrix(matrix, sender);
}
floatingObject.Physics.LinearVelocity = msg.LinearVelocity;
floatingObject.Physics.AngularVelocity = msg.AngularVelocity;
}
}
}
}
private static void GetSurfaceAndMaterial(IMyEntity entity, out MySurfaceImpactEnum surfaceImpact, out MyStringHash materialType)
{
if (entity is MyVoxelMap)
{
materialType = MyMaterialType.ROCK;
surfaceImpact = MySurfaceImpactEnum.DESTRUCTIBLE;
}
else if (entity is MyCharacter)
{
surfaceImpact = MySurfaceImpactEnum.CHARACTER;
materialType = MyMaterialType.CHARACTER;
}
else if (entity is MyFloatingObject)
{
MyFloatingObject obj = entity as MyFloatingObject;
materialType = (obj.VoxelMaterial != null) ? MyMaterialType.ROCK : MyMaterialType.METAL;
surfaceImpact = MySurfaceImpactEnum.METAL;
}
else
{
surfaceImpact = MySurfaceImpactEnum.METAL;
materialType = MyMaterialType.METAL;
}
}
public static void UpdatePosition(MyFloatingObject floatingObject, bool toAll = true, MyNetworkClient receiver = null)
{
var m = floatingObject.WorldMatrix;
FloatingObjectPositionUpdateMsg msg = new FloatingObjectPositionUpdateMsg();
msg.EntityId = floatingObject.EntityId;
msg.Forward = m.Forward;
msg.Up = m.Up;
msg.Position = m.Translation;
if (floatingObject.Physics != null)
{
msg.LinearVelocity = floatingObject.Physics.LinearVelocity;
msg.AngularVelocity = floatingObject.Physics.AngularVelocity;
}
//PositionUpdateCompressedMsg msg = new PositionUpdateCompressedMsg();
//msg.EntityId = floatingObject.EntityId;
//msg.SetWorldMatrix(m);
//if (floatingObject.Physics != null)
//{
// if (floatingObject.Physics.RigidBody.IsActive)
// {
// if (floatingObject.Physics.LinearVelocity.Length() > 0.1f || floatingObject.Physics.AngularVelocity.Length() > 0.1f)
// msg.SetVelocities(floatingObject.Physics.LinearVelocity, floatingObject.Physics.AngularVelocity);
// }
//}
if (toAll | receiver == null)
{
MySession.Static.SyncLayer.SendMessageToAll(ref msg);
}
else
{
MySession.Static.SyncLayer.SendMessage(ref msg, receiver.SteamUserId);
}
}
private bool FindFreeCargo(IMyEntity target, MyCubeBlock startBlock, bool transfer)
{
var list = Conveyor.GetConveyorListFromEntity(m_constructionBlock.ConstructionBlock);
if (list == null)
{
return(false);
}
List <MyInventory> inventoryList = new List <MyInventory>();
foreach (var item in list)
{
IMyEntity entity;
if (MyAPIGateway.Entities.TryGetEntityById(item, out entity))
{
if (!(entity is IMyCubeBlock))
{
continue;
}
if (entity is Ingame.IMyRefinery || entity is Ingame.IMyAssembler)
{
continue;
}
MyCubeBlock block = (MyCubeBlock)entity;
if (!block.HasInventory)
{
continue;
}
inventoryList.Add(block.GetInventory());
}
}
MyFloatingObject floating = (MyFloatingObject)target;
float amount = 0f;
MyInventory targetInventory = null;
foreach (var item in inventoryList.OrderByDescending(x => (float)x.MaxVolume - (float)x.CurrentVolume))
{
amount = GetNaniteInventoryAmountThatFits(target, (MyCubeBlock)item.Owner);
if ((int)amount == 0)
{
continue;
}
targetInventory = item;
break;
}
if ((int)amount == 0)
{
return(false);
}
var def = MyDefinitionManager.Static.GetPhysicalItemDefinition(new VRage.Game.MyDefinitionId(floating.Item.Content.TypeId, floating.Item.Content.SubtypeId));
if ((int)amount > 1 && (amount / def.Volume) > m_carryVolume)
{
amount = m_carryVolume / def.Volume;
}
if ((int)amount < 1)
{
amount = 1f;
}
if (transfer)
{
targetInventory.PickupItem(floating, (int)amount);
}
return(true);
}
public override void UpdateAfterSimulation()
{
base.UpdateAfterSimulation();
//MyRenderProxy.DebugDrawSphere(m_gunBase.PositionMuzzleWorld, 0.2f, new Vector3(1, 0, 0), 1.0f, true);
m_targetGrid = null;
m_targetDestroyable = null;
m_targetFloatingObject = null;
m_targetCharacter = null;
if (Owner == null)
{
return;
}
var entitiesInRange = m_sensor.EntitiesInRange;
int closestEntityIndex = 0;
float closestDistance = float.MaxValue;
if (entitiesInRange != null && entitiesInRange.Count > 0)
{
int i = 0;
foreach (var entity in entitiesInRange.Values)
{
var targetGrid = entity.Entity as MyCubeGrid;
var distanceSq = (float)Vector3D.DistanceSquared(entity.DetectionPoint, m_gunBase.GetMuzzleWorldPosition());
if (entity.Entity.Physics != null && entity.Entity.Physics.Enabled)
{
if (distanceSq < closestDistance)
{
m_targetGrid = targetGrid;
m_targetDistanceSq = (float)distanceSq;
m_targetDestroyable = entity.Entity as IMyDestroyableObject;
m_targetFloatingObject = entity.Entity as MyFloatingObject;
m_targetCharacter = entity.Entity as MyCharacter;
closestDistance = m_targetDistanceSq;
closestEntityIndex = i;
}
}
++i;
}
}
if (m_targetGrid != null)
{
m_targetPosition = entitiesInRange.Values.ElementAt(closestEntityIndex).DetectionPoint;
var invWorld = m_targetGrid.PositionComp.GetWorldMatrixNormalizedInv();
var gridLocalPos = Vector3D.Transform(m_targetPosition, invWorld);
var gridSpacePos = Vector3I.Round(gridLocalPos / m_targetGrid.GridSize);
m_targetGrid.FixTargetCube(out m_targetCube, gridLocalPos / m_targetGrid.GridSize);
var head = PositionComp.WorldMatrix;
var aimToMuzzle = Vector3D.Normalize(m_targetPosition - m_gunBase.GetMuzzleWorldPosition());
if (Vector3.Dot(aimToMuzzle, head.Forward) > 0)
{
m_targetDistanceSq = 0;
}
else
{
m_targetDistanceSq = (float)Vector3D.DistanceSquared(m_targetPosition, m_gunBase.GetMuzzleWorldPosition());
}
}
PowerReceiver.Update();
if (IsShooting && !PowerReceiver.IsPowered)
{
EndShoot(MyShootActionEnum.PrimaryAction);
}
UpdateEffect();
CheckEffectType();
//MyTrace.Watch("MyEngineerToolBase.RequiredPowerInput", RequiredPowerInput);
}
private static void GetSurfaceAndMaterial(IMyEntity entity, ref Vector3D hitPosition, out MySurfaceImpactEnum surfaceImpact, out MyStringHash materialType)
{
var voxelBase = entity as MyVoxelBase;
if (voxelBase != null)
{
materialType = MyMaterialType.ROCK;
surfaceImpact = MySurfaceImpactEnum.DESTRUCTIBLE;
var voxelDefinition = voxelBase.GetMaterialAt(ref hitPosition);
if (voxelDefinition != null)
{
materialType = MyStringHash.GetOrCompute(voxelDefinition.MaterialTypeName);
}
}
else if (entity is MyCharacter)
{
surfaceImpact = MySurfaceImpactEnum.CHARACTER;
materialType = MyMaterialType.CHARACTER;
if ((entity as MyCharacter).Definition.PhysicalMaterial != null)
{
materialType = MyStringHash.GetOrCompute((entity as MyCharacter).Definition.PhysicalMaterial);
}
}
else if (entity is MyFloatingObject)
{
MyFloatingObject obj = entity as MyFloatingObject;
materialType = (obj.VoxelMaterial != null) ? MyMaterialType.ROCK : MyMaterialType.METAL;
surfaceImpact = MySurfaceImpactEnum.METAL;
}
else if (entity is MyTrees)
{
surfaceImpact = MySurfaceImpactEnum.DESTRUCTIBLE;
materialType = MyMaterialType.WOOD;
}
else
{
surfaceImpact = MySurfaceImpactEnum.METAL;
materialType = MyMaterialType.METAL;
if (entity is MyCubeGrid)
{
Vector3I blockPos;
var grid = (entity as MyCubeGrid);
if (grid != null)
{
grid.FixTargetCube(out blockPos, Vector3D.Transform(hitPosition, grid.PositionComp.WorldMatrixNormalizedInv) / grid.GridSize);
var block = grid.GetCubeBlock(blockPos);
if (block != null)
{
if (block.BlockDefinition.PhysicalMaterial != null)
{
materialType = MyStringHash.GetOrCompute(block.BlockDefinition.PhysicalMaterial.Id.SubtypeName);
}
}
}
}
if (materialType.GetHashCode() == 0)
{
materialType = MyMaterialType.METAL;
}
}
}
public bool Drill(bool collectOre = true, bool performCutout = true, bool assignDamagedMaterial = false)
{
ProfilerShort.Begin("MyDrillBase::Drill()");
bool drillingSuccess = false;
MySoundPair sound = null;
if ((m_drillEntity.Parent != null) && (m_drillEntity.Parent.Physics != null) && !m_drillEntity.Parent.Physics.Enabled)
{
return(false);
}
if (performCutout)
{
StopSparkParticles();
StopDustParticles();
var entitiesInRange = m_sensor.EntitiesInRange;
MyStringHash targetMaterial = MyStringHash.NullOrEmpty;
bool targetIsBlock = false;
foreach (var entry in entitiesInRange)
{
drillingSuccess = false;
var entity = entry.Value.Entity;
if (entity.MarkedForClose)
{
continue;
}
if (entity is MyCubeGrid)
{
var grid = entity as MyCubeGrid;
if (grid.Physics != null && grid.Physics.Enabled)
{
drillingSuccess = TryDrillBlocks(grid, entry.Value.DetectionPoint, !Sync.IsServer, out targetMaterial);
targetIsBlock = true;
}
if (drillingSuccess)
{
m_initialHeatup = false;
CreateParticles(entry.Value.DetectionPoint, false, true, false);
}
}
else if (entity is MyVoxelBase)
{
ProfilerShort.Begin("Drill voxel map");
var voxels = entity as MyVoxelBase;
drillingSuccess = TryDrillVoxels(voxels, entry.Value.DetectionPoint, collectOre, !Sync.IsServer, assignDamagedMaterial);
ProfilerShort.BeginNextBlock("Create particles");
if (drillingSuccess)
{
Vector3D drillHitPoint = entry.Value.DetectionPoint;
if (targetMaterial == MyStringHash.NullOrEmpty)
{
var voxelMaterial = voxels.GetMaterialAt(ref drillHitPoint);
if (voxelMaterial != null)
{
targetMaterial = MyStringHash.GetOrCompute(voxelMaterial.MaterialTypeName);
}
}
CreateParticles(entry.Value.DetectionPoint, true, false, true);
}
ProfilerShort.End();
}
else if (entity is MyFloatingObject)
{
var sphere = (BoundingSphereD)m_cutOut.Sphere;
sphere.Radius *= 1.33f;
if (entity.GetIntersectionWithSphere(ref sphere))
{
MyFloatingObject flObj = entity as MyFloatingObject;
if (Sync.IsServer)
{
if (flObj.Item.Content.TypeId == typeof(MyObjectBuilder_Ore))
{
var invOwn = (m_drillEntity != null && m_drillEntity.HasInventory) ? m_drillEntity : null;
if (invOwn == null)
{
invOwn = (m_drillEntity as MyHandDrill).Owner;
}
System.Diagnostics.Debug.Assert((invOwn.GetInventory(0) as MyInventory) != null, "Null or unexpected inventory type!");
(invOwn.GetInventory(0) as MyInventory).TakeFloatingObject(flObj);
}
else
{
(entity as MyFloatingObject).DoDamage(70, MyDamageType.Drill, true, attackerId: m_drillEntity != null ? m_drillEntity.EntityId : 0);
}
}
drillingSuccess = true;
}
}
else if (entity is MyCharacter)
{
var sphere = (BoundingSphereD)m_cutOut.Sphere;
sphere.Radius *= 0.8f;
var character = entity as MyCharacter;
if (targetMaterial == MyStringHash.NullOrEmpty)
{
targetMaterial = MyStringHash.GetOrCompute((entity as MyCharacter).Definition.PhysicalMaterial);
}
if (entity.GetIntersectionWithSphere(ref sphere))
{
//MyRenderProxy.DebugDrawSphere(sphere.Center, sphere.Radius, Color.Green.ToVector3(), 1, true);
//damage tracking
if ((m_drillEntity is MyHandDrill) && (m_drillEntity as MyHandDrill).Owner == MySession.Static.LocalCharacter && character != MySession.Static.LocalCharacter && character.IsDead == false)
{
MySession.Static.TotalDamageDealt += 20;
}
if (Sync.IsServer)
{
character.DoDamage(20, MyDamageType.Drill, true, attackerId: m_drillEntity != null ? m_drillEntity.EntityId : 0);
}
drillingSuccess = true;
}
else
{
BoundingSphereD headSphere = new BoundingSphereD(character.PositionComp.WorldMatrix.Translation + character.WorldMatrix.Up * 1.25f, 0.6f);
//MyRenderProxy.DebugDrawSphere(headSphere.Center, headSphere.Radius, Color.Red.ToVector3(), 1, false);
if (headSphere.Intersects(sphere))
{
//MyRenderProxy.DebugDrawSphere(sphere.Center, sphere.Radius, Color.Green.ToVector3(), 1, true);
//damage tracking
if ((m_drillEntity is MyHandDrill) && (m_drillEntity as MyHandDrill).Owner == MySession.Static.LocalCharacter && character != MySession.Static.LocalCharacter && character.IsDead == false)
{
MySession.Static.TotalDamageDealt += 20;
}
if (Sync.IsServer)
{
character.DoDamage(20, MyDamageType.Drill, true, attackerId: m_drillEntity != null ? m_drillEntity.EntityId : 0);
}
drillingSuccess = true;
}
}
}
if (drillingSuccess)
{
m_lastContactTime = MySandboxGame.TotalGamePlayTimeInMilliseconds;
}
}
if (targetMaterial != null && targetMaterial != MyStringHash.NullOrEmpty)
{
sound = MyMaterialPropertiesHelper.Static.GetCollisionCue(MyMaterialPropertiesHelper.CollisionType.Start, m_drillMaterial, targetMaterial);
if (sound == null || sound == MySoundPair.Empty)//target material was not set in definition - using metal/rock sound
{
if (targetIsBlock)
{
targetMaterial = m_metalMaterial;
}
else
{
targetMaterial = m_rockMaterial;
}
}
sound = MyMaterialPropertiesHelper.Static.GetCollisionCue(MyMaterialPropertiesHelper.CollisionType.Start, m_drillMaterial, targetMaterial);
}
}
if (sound != null && sound != MySoundPair.Empty)
{
StartLoopSound(sound);
}
else
{
StartIdleSound(m_idleSoundLoop);
}
if (!IsDrilling)
{
IsDrilling = true;
m_animationLastUpdateTime = MySandboxGame.TotalGamePlayTimeInMilliseconds;
}
ProfilerShort.End();
return(drillingSuccess);
}
public override void OnAddedToContainer()
{
base.OnAddedToContainer();
m_floatingObject = Container.Entity as MyFloatingObject;
}
private static void GetSurfaceAndMaterial(IMyEntity entity, ref Vector3D hitPosition, out MySurfaceImpactEnum surfaceImpact, out MyStringHash materialType)
{
var voxelBase = entity as MyVoxelBase;
if (voxelBase != null)
{
materialType = MyMaterialType.ROCK;
surfaceImpact = MySurfaceImpactEnum.DESTRUCTIBLE;
var voxelDefinition = voxelBase.GetMaterialAt(ref hitPosition);
if (voxelDefinition != null)
{
materialType = MyStringHash.GetOrCompute(voxelDefinition.MaterialTypeName);
}
}
else if (entity is MyCharacter)
{
surfaceImpact = MySurfaceImpactEnum.CHARACTER;
materialType = MyMaterialType.CHARACTER;
if ((entity as MyCharacter).Definition.PhysicalMaterial != null)
{
materialType = MyStringHash.GetOrCompute((entity as MyCharacter).Definition.PhysicalMaterial);
}
}
else if (entity is MyFloatingObject)
{
MyFloatingObject obj = entity as MyFloatingObject;
materialType = (obj.VoxelMaterial != null) ? MyMaterialType.ROCK : (obj.ItemDefinition != null && obj.ItemDefinition.PhysicalMaterial != MyStringHash.NullOrEmpty ? obj.ItemDefinition.PhysicalMaterial : MyMaterialType.METAL);
surfaceImpact = MySurfaceImpactEnum.METAL;
}
else if (entity is MyTrees)
{
surfaceImpact = MySurfaceImpactEnum.DESTRUCTIBLE;
materialType = MyMaterialType.WOOD;
}
else if (entity is IMyHandheldGunObject <MyGunBase> )
{
surfaceImpact = MySurfaceImpactEnum.METAL;
materialType = MyMaterialType.METAL;
var mat = (entity as IMyHandheldGunObject <MyGunBase>).GunBase;
if (mat != null && mat.WeaponProperties != null && mat.WeaponProperties.WeaponDefinition != null)
{
materialType = mat.WeaponProperties.WeaponDefinition.PhysicalMaterial;
}
}
else
{
surfaceImpact = MySurfaceImpactEnum.METAL;
materialType = MyMaterialType.METAL;
if (entity is MyCubeGrid)
{
var grid = (entity as MyCubeGrid);
if (grid != null)
{
var block = grid.GetTargetedBlock(hitPosition);
if (block != null)
{
if (block.BlockDefinition.PhysicalMaterial != null)
{
materialType = MyStringHash.GetOrCompute(block.BlockDefinition.PhysicalMaterial.Id.SubtypeName);
}
}
}
}
}
if (materialType.GetHashCode() == 0)
{
materialType = MyMaterialType.METAL;
}
}
public FloatingObjectViewModel(MyFloatingObject floating, EntityTreeViewModel tree) : base(floating, tree)
{
}
public bool Drill(bool collectOre = true, bool performCutout = true)
{
ProfilerShort.Begin("MyDrillBase::Drill()");
bool drillingSuccess = false;
MySoundPair sound = null;
if ((m_drillEntity.Parent != null) && (m_drillEntity.Parent.Physics != null) && !m_drillEntity.Parent.Physics.Enabled)
{
return(false);
}
if (performCutout)
{
var entitiesInRange = m_sensor.EntitiesInRange;
foreach (var entry in entitiesInRange)
{
drillingSuccess = false;
var entity = entry.Value.Entity;
if (entity.MarkedForClose)
{
continue;
}
if (entity is MyCubeGrid)
{
var grid = entity as MyCubeGrid;
if (grid.Physics != null && grid.Physics.Enabled)
{
drillingSuccess = TryDrillBlocks(grid, entry.Value.DetectionPoint, !Sync.IsServer);
}
if (drillingSuccess)
{
m_initialHeatup = false;
sound = m_sounds.MetalLoop;
CreateParticles(entry.Value.DetectionPoint, false, true, false);
}
}
else if (entity is MyVoxelBase)
{
ProfilerShort.Begin("Drill voxel map");
var voxels = entity as MyVoxelBase;
drillingSuccess = TryDrillVoxels(voxels, entry.Value.DetectionPoint, collectOre, !Sync.IsServer);
ProfilerShort.BeginNextBlock("Create particles");
if (drillingSuccess)
{
sound = m_sounds.RockLoop;
CreateParticles(entry.Value.DetectionPoint, true, false, true);
}
ProfilerShort.End();
}
else if (entity is MyFloatingObject)
{
var sphere = (BoundingSphereD)m_cutOut.Sphere;
sphere.Radius *= 1.33f;
if (entity.GetIntersectionWithSphere(ref sphere))
{
MyFloatingObject flObj = entity as MyFloatingObject;
if (Sync.IsServer)
{
if (flObj.Item.Content.TypeId == typeof(MyObjectBuilder_Ore))
{
IMyInventoryOwner invOwn = m_drillEntity as IMyInventoryOwner;
if (invOwn == null)
{
invOwn = (m_drillEntity as MyHandDrill).Owner as IMyInventoryOwner;
}
invOwn.GetInventory(0).TakeFloatingObject(flObj);
}
else
{
(entity as MyFloatingObject).DoDamage(70, MyDamageType.Drill, true, attackerId: m_drillEntity != null ? m_drillEntity.EntityId : 0);
}
}
drillingSuccess = true;
}
}
else if (entity is MyCharacter)
{
var sphere = (BoundingSphereD)m_cutOut.Sphere;
sphere.Radius *= (4 / 5f);
var character = entity as MyCharacter;
if (entity.GetIntersectionWithSphere(ref sphere))
{
//MyRenderProxy.DebugDrawSphere(sphere.Center, sphere.Radius, Color.Green.ToVector3(), 1, true);
if (Sync.IsServer)
{
character.DoDamage(20, MyDamageType.Drill, true, attackerId: m_drillEntity != null ? m_drillEntity.EntityId : 0);
}
drillingSuccess = true;
}
else
{
BoundingSphereD headSphere = new BoundingSphereD(character.PositionComp.WorldMatrix.Translation + character.WorldMatrix.Up * 1.25f, 0.6f);
//MyRenderProxy.DebugDrawSphere(headSphere.Center, headSphere.Radius, Color.Red.ToVector3(), 1, false);
if (headSphere.Intersects(sphere))
{
//MyRenderProxy.DebugDrawSphere(sphere.Center, sphere.Radius, Color.Green.ToVector3(), 1, true);
if (Sync.IsServer)
{
character.DoDamage(20, MyDamageType.Drill, true, attackerId: m_drillEntity != null ? m_drillEntity.EntityId : 0);
}
drillingSuccess = true;
}
}
}
if (drillingSuccess)
{
m_lastContactTime = MySandboxGame.TotalGamePlayTimeInMilliseconds;
}
}
}
if (sound != null)
{
StartLoopSound(sound);
}
else
{
StartIdleSound(m_sounds.IdleLoop);
}
IsDrilling = true;
m_animationLastUpdateTime = MySandboxGame.TotalGamePlayTimeInMilliseconds;
ProfilerShort.End();
return(drillingSuccess);
}
public string SendHttpResponseResponse(HttpListenerRequest request)
{
StringBuilder sb = new StringBuilder();
JsonWriter writer = new JsonWriter(sb);
switch (request.Url.AbsolutePath)
{
//case "/gc/collect/0":
// GC.Collect(0);
// break;
//case "/gc/collect/1":
// GC.Collect(1);
// break;
//case "/gc/collect/2":
// GC.Collect(2);
// break;
case "/metrics/v1/server":
int usedPCU = 0;
int maxPlayers = 0;
int maxFactionCount = 0;
int maxFloatingObjects = 0;
int maxGridSize = 0;
int maxBlocksPerPlayer = 0;
string blockLimit = "";
int totalPCU = 0;
int modCount = 0;
if (MySession.Static != null)
{
if (MySession.Static.GlobalBlockLimits != null)
{
usedPCU = MySession.Static.GlobalBlockLimits.PCUBuilt;
}
maxPlayers = MySession.Static.MaxPlayers;
maxFactionCount = MySession.Static.MaxFactionsCount;
maxFloatingObjects = MySession.Static.MaxFloatingObjects;
maxGridSize = MySession.Static.MaxGridSize;
maxBlocksPerPlayer = MySession.Static.MaxBlocksPerPlayer;
totalPCU = MySession.Static.TotalPCU;
modCount = MySession.Static.Mods.Count;
switch (MySession.Static.BlockLimitsEnabled)
{
case MyBlockLimitsEnabledEnum.GLOBALLY:
blockLimit = "globally";
break;
case MyBlockLimitsEnabledEnum.NONE:
blockLimit = "none";
break;
case MyBlockLimitsEnabledEnum.PER_FACTION:
blockLimit = "faction";
break;
case MyBlockLimitsEnabledEnum.PER_PLAYER:
blockLimit = "player";
break;
}
}
writer.WriteObjectStart();
writer.WritePropertyName("Version");
writer.Write(MyFinalBuildConstants.APP_VERSION_STRING_DOTS.ToString());
writer.WritePropertyName("ServerName");
writer.Write(MySandboxGame.ConfigDedicated.ServerName);
writer.WritePropertyName("WorldName");
writer.Write(MySandboxGame.ConfigDedicated.WorldName);
writer.WritePropertyName("IsReady");
writer.Write(MySession.Static != null && MySession.Static.Ready);
writer.WritePropertyName("SimSpeed");
writer.Write(Sync.ServerSimulationRatio);
writer.WritePropertyName("SimulationCpuLoad");
writer.Write((float)(int)Sync.ServerCPULoad);
writer.WritePropertyName("TotalTime");
writer.Write(MySandboxGame.TotalTimeInMilliseconds / 1000);
writer.WritePropertyName("Players");
writer.Write((Sync.Clients != null) ? (Sync.Clients.Count - 1) : 0);
writer.WritePropertyName("UsedPCU");
writer.Write(usedPCU);
writer.WritePropertyName("MaxPlayers");
writer.Write(maxPlayers);
writer.WritePropertyName("MaxFactionsCount");
writer.Write(maxFactionCount);
writer.WritePropertyName("MaxFloatingObjects");
writer.Write(maxFloatingObjects);
writer.WritePropertyName("MaxGridSize");
writer.Write(maxGridSize);
writer.WritePropertyName("MaxBlocksPerPlayer");
writer.Write(maxBlocksPerPlayer);
writer.WritePropertyName("BlockLimitsEnabled");
writer.Write(blockLimit);
writer.WritePropertyName("TotalPCU");
writer.Write(totalPCU);
writer.WritePropertyName("ModCount");
writer.Write(modCount);
writer.WritePropertyName("SaveDuration");
writer.Write(saveDuration);
writer.WriteObjectEnd();
break;
case "/metrics/v1/load":
writer.WriteArrayStart();
LoadEvent loadEv;
while (!loadEvents.Empty)
{
if (loadEvents.TryDequeueBack(out loadEv))
{
writer.WriteObjectStart();
writer.WritePropertyName("ServerCPULoad");
writer.Write(loadEv.ServerCPULoad);
writer.WritePropertyName("ServerCPULoadSmooth");
writer.Write(loadEv.ServerCPULoadSmooth);
writer.WritePropertyName("ServerSimulationRatio");
writer.Write(loadEv.ServerSimulationRatio);
writer.WritePropertyName("ServerThreadLoad");
writer.Write(loadEv.ServerThreadLoad);
writer.WritePropertyName("ServerThreadLoadSmooth");
writer.Write(loadEv.ServerThreadLoadSmooth);
writer.WritePropertyName("MillisecondsInThePast");
writer.Write((DateTime.Now - loadEv.Occurred).TotalMilliseconds);
writer.WriteObjectEnd();
}
}
writer.WriteArrayEnd();
break;
case "/metrics/v1/process":
System.Diagnostics.Process currentProcess = System.Diagnostics.Process.GetCurrentProcess();
writer.WriteObjectStart();
writer.WritePropertyName("PrivateMemorySize64");
writer.Write(currentProcess.PrivateMemorySize64);
writer.WritePropertyName("VirtualMemorySize64");
writer.Write(currentProcess.VirtualMemorySize64);
writer.WritePropertyName("WorkingSet64");
writer.Write(currentProcess.WorkingSet64);
writer.WritePropertyName("NonpagedSystemMemorySize64");
writer.Write(currentProcess.NonpagedSystemMemorySize64);
writer.WritePropertyName("PagedMemorySize64");
writer.Write(currentProcess.PagedMemorySize64);
writer.WritePropertyName("PagedSystemMemorySize64");
writer.Write(currentProcess.PagedSystemMemorySize64);
writer.WritePropertyName("PeakPagedMemorySize64");
writer.Write(currentProcess.PeakPagedMemorySize64);
writer.WritePropertyName("PeakVirtualMemorySize64");
writer.Write(currentProcess.PeakVirtualMemorySize64);
writer.WritePropertyName("PeakWorkingSet64");
writer.Write(currentProcess.PeakWorkingSet64);
writer.WritePropertyName("GCLatencyMode");
writer.Write((int)System.Runtime.GCSettings.LatencyMode);
writer.WritePropertyName("GCIsServerGC");
writer.Write(System.Runtime.GCSettings.IsServerGC);
writer.WritePropertyName("GCTotalMemory");
writer.Write(GC.GetTotalMemory(false));
writer.WritePropertyName("GCMaxGeneration");
writer.Write(GC.MaxGeneration);
writer.WritePropertyName("GCCollectionCount0");
writer.Write(GC.CollectionCount(0));
writer.WritePropertyName("GCCollectionCount1");
writer.Write(GC.CollectionCount(1));
writer.WritePropertyName("GCCollectionCount2");
writer.Write(GC.CollectionCount(2));
writer.WriteObjectEnd();
break;
case "/metrics/v1/events":
writer.WriteArrayStart();
Event ev;
while (!events.Empty)
{
if (events.TryDequeueBack(out ev))
{
writer.WriteObjectStart();
writer.WritePropertyName("Type");
writer.Write(ev.Type);
writer.WritePropertyName("Text");
writer.Write(ev.Text);
writer.WritePropertyName("Tags");
writer.WriteArrayStart();
foreach (var tag in ev.Tags)
{
writer.Write(tag);
}
writer.WriteArrayEnd();
writer.WritePropertyName("SecondsInThePast");
writer.Write((DateTime.Now - ev.Occurred).TotalSeconds);
writer.WriteObjectEnd();
}
}
writer.WriteArrayEnd();
break;
case "/metrics/v1/players":
writer.WriteArrayStart();
PlayerEvent playerEv;
while (!playerEvents.Empty)
{
if (playerEvents.TryDequeueBack(out playerEv))
{
writer.WriteObjectStart();
writer.WritePropertyName("Type");
writer.Write(playerEv.Type);
writer.WritePropertyName("SteamId");
writer.Write(playerEv.SteamId);
writer.WritePropertyName("MillisecondsInThePast");
writer.Write((DateTime.Now - playerEv.Occurred).TotalMilliseconds);
writer.WriteObjectEnd();
}
}
writer.WriteArrayEnd();
break;
case "/metrics/v1/session/grids":
writer.WriteArrayStart();
if (MySession.Static != null && MySession.Static.Ready)
{
ICollection <MyPlayer> onlinePlayers = MySession.Static.Players.GetOnlinePlayers();
MyConcurrentHashSet <MyEntity> entities = MyEntities.GetEntities();
Type type = typeof(MyEntities);
FieldInfo info = type.GetField("m_entitiesForUpdateOnce", BindingFlags.NonPublic | BindingFlags.Static);
object value = info.GetValue(null);
CachingList <MyEntity> m_entitiesForUpdateOnce = value as CachingList <MyEntity>;
List <long> x_entitiesForUpdateOnce = new List <long>();
info = type.GetField("m_entitiesForUpdate", BindingFlags.NonPublic | BindingFlags.Static);
value = info.GetValue(null);
MyDistributedUpdater <ConcurrentCachingList <MyEntity>, MyEntity> m_entitiesForUpdate = value as MyDistributedUpdater <ConcurrentCachingList <MyEntity>, MyEntity>;
List <long> x_entitiesForUpdate = new List <long>();
info = type.GetField("m_entitiesForUpdate10", BindingFlags.NonPublic | BindingFlags.Static);
value = info.GetValue(null);
MyDistributedUpdater <CachingList <MyEntity>, MyEntity> m_entitiesForUpdate10 = value as MyDistributedUpdater <CachingList <MyEntity>, MyEntity>;
List <long> x_entitiesForUpdate10 = new List <long>();
info = type.GetField("m_entitiesForUpdate100", BindingFlags.NonPublic | BindingFlags.Static);
value = info.GetValue(null);
MyDistributedUpdater <CachingList <MyEntity>, MyEntity> m_entitiesForUpdate100 = value as MyDistributedUpdater <CachingList <MyEntity>, MyEntity>;
List <long> x_entitiesForUpdate100 = new List <long>();
info = type.GetField("m_entitiesForSimulate", BindingFlags.NonPublic | BindingFlags.Static);
value = info.GetValue(null);
MyDistributedUpdater <CachingList <MyEntity>, MyEntity> m_entitiesForSimulate = value as MyDistributedUpdater <CachingList <MyEntity>, MyEntity>;
List <long> x_entitiesForSimulate = new List <long>();
Torch.InvokeBlocking(() =>
{
x_entitiesForUpdateOnce = m_entitiesForUpdateOnce.Select((x) => x.EntityId).ToList();
x_entitiesForUpdate = m_entitiesForUpdate.List.Select((x) => x.EntityId).ToList();
x_entitiesForUpdate10 = m_entitiesForUpdate10.List.Select((x) => x.EntityId).ToList();
x_entitiesForUpdate100 = m_entitiesForUpdate100.List.Select((x) => x.EntityId).ToList();
x_entitiesForSimulate = m_entitiesForSimulate.List.Select((x) => x.EntityId).ToList();
});
bool IsConcealed(MyCubeGrid grid)
{
int NeedsUpdateMatches = 0;
int RegistedMatches = 0;
if ((grid.NeedsUpdate & MyEntityUpdateEnum.BEFORE_NEXT_FRAME) > MyEntityUpdateEnum.NONE)
{
NeedsUpdateMatches++;
if (x_entitiesForUpdateOnce.Any((x) => x == grid.EntityId))
{
RegistedMatches++;
}
}
if ((grid.NeedsUpdate & MyEntityUpdateEnum.EACH_FRAME) > MyEntityUpdateEnum.NONE)
{
NeedsUpdateMatches++;
if (x_entitiesForUpdate.Any((x) => x == grid.EntityId))
{
RegistedMatches++;
}
}
if ((grid.NeedsUpdate & MyEntityUpdateEnum.EACH_10TH_FRAME) > MyEntityUpdateEnum.NONE)
{
NeedsUpdateMatches++;
if (x_entitiesForUpdate10.Any((x) => x == grid.EntityId))
{
RegistedMatches++;
}
}
if ((grid.NeedsUpdate & MyEntityUpdateEnum.EACH_100TH_FRAME) > MyEntityUpdateEnum.NONE)
{
NeedsUpdateMatches++;
if (x_entitiesForUpdate100.Any((x) => x == grid.EntityId))
{
RegistedMatches++;
}
}
if ((grid.NeedsUpdate & MyEntityUpdateEnum.SIMULATE) > MyEntityUpdateEnum.NONE)
{
NeedsUpdateMatches++;
if (x_entitiesForSimulate.Any((x) => x == grid.EntityId))
{
RegistedMatches++;
}
}
return(NeedsUpdateMatches > 0 && RegistedMatches == 0);
}
foreach (MyEntity item in entities)
{
MyCubeGrid myCubeGrid = item as MyCubeGrid;
if (myCubeGrid != null && !myCubeGrid.Closed && myCubeGrid.Physics != null)
{
long steamId = 0L;
string displayName = string.Empty;
string factionTag = string.Empty;
string factionName = string.Empty;
long groupEntityId = 0L;
if (myCubeGrid.BigOwners.Count > 0)
{
steamId = myCubeGrid.BigOwners[0];
MyIdentity myIdentity = MySession.Static.Players.TryGetIdentity(steamId);
if (myIdentity != null)
{
displayName = myIdentity.DisplayName;
}
IMyFaction myFaction = MySession.Static.Factions.TryGetPlayerFaction(steamId);
if (myFaction != null)
{
factionTag = myFaction.Tag;
factionName = myFaction.Name;
}
}
foreach (var group in MyCubeGridGroups.Static.Physical.Groups)
{
bool found = false;
foreach (var node in group.Nodes)
{
if (node.NodeData != myCubeGrid)
{
continue;
}
groupEntityId = group.Nodes.OrderByDescending(x => x.NodeData.BlocksCount).First().NodeData.EntityId;
found = true;
break;
}
if (found)
{
break;
}
}
int conveyorInventoryBlockCount = 0;
int conveyorEndpointBlockCount = 0;
int conveyorLineCount = 0;
int conveyorConnectorCount = 0;
if (myCubeGrid?.GridSystems?.ConveyorSystem != null)
{
type = myCubeGrid.GridSystems.ConveyorSystem.GetType();
conveyorInventoryBlockCount = (type.GetField("m_inventoryBlocks", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(myCubeGrid.GridSystems.ConveyorSystem) as HashSet <MyCubeBlock>).Count;
conveyorEndpointBlockCount = (type.GetField("m_conveyorEndpointBlocks", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(myCubeGrid.GridSystems.ConveyorSystem) as HashSet <IMyConveyorEndpointBlock>).Count;
conveyorLineCount = (type.GetField("m_lines", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(myCubeGrid.GridSystems.ConveyorSystem) as HashSet <MyConveyorLine>).Count;
conveyorConnectorCount = (type.GetField("m_connectors", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(myCubeGrid.GridSystems.ConveyorSystem) as HashSet <MyShipConnector>).Count;
}
writer.WriteObjectStart();
writer.WritePropertyName("DisplayName");
writer.Write(myCubeGrid.DisplayName);
writer.WritePropertyName("EntityId");
writer.Write(myCubeGrid.EntityId);
writer.WritePropertyName("PhysicsGroupEntityId");
writer.Write(groupEntityId);
writer.WritePropertyName("GridSize");
writer.Write(myCubeGrid.GridSizeEnum == MyCubeSize.Large ? "Large" : "Small");
writer.WritePropertyName("BlocksCount");
writer.Write(myCubeGrid.BlocksCount);
writer.WritePropertyName("Mass");
writer.Write(myCubeGrid.Physics.Mass);
writer.WritePropertyName("LinearSpeed");
writer.Write(myCubeGrid.Physics.LinearVelocity.Length());
writer.WritePropertyName("DistanceToPlayer");
writer.Write(MySession.GetPlayerDistance(myCubeGrid, onlinePlayers));
writer.WritePropertyName("OwnerSteamId");
writer.Write(steamId);
writer.WritePropertyName("OwnerDisplayName");
writer.Write(displayName);
writer.WritePropertyName("OwnerFactionTag");
writer.Write(factionTag);
writer.WritePropertyName("OwnerFactionName");
writer.Write(factionName);
writer.WritePropertyName("IsPowered");
writer.Write(myCubeGrid.GridSystems.ResourceDistributor.ResourceStateByType(MyResourceDistributorComponent.ElectricityId, withRecompute: false) != MyResourceStateEnum.NoPower);
writer.WritePropertyName("PCU");
writer.Write(myCubeGrid.BlocksPCU);
writer.WritePropertyName("IsConcealed");
writer.Write(IsConcealed(myCubeGrid));
writer.WritePropertyName("DampenersEnabled");
writer.Write(myCubeGrid.DampenersEnabled);
writer.WritePropertyName("IsStatic");
writer.Write(myCubeGrid.Physics.IsStatic);
writer.WritePropertyName("ConveyorSystemInventoryBlockCount");
writer.Write(conveyorInventoryBlockCount);
writer.WritePropertyName("ConveyorSystemEndpointBlockCount");
writer.Write(conveyorEndpointBlockCount);
writer.WritePropertyName("ConveyorSystemLineCount");
writer.Write(conveyorLineCount);
writer.WritePropertyName("ConveyorSystemConnectorCount");
writer.Write(conveyorConnectorCount);
writer.WriteObjectEnd();
}
}
}
writer.WriteArrayEnd();
break;
case "/metrics/v1/session/asteroids":
writer.WriteArrayStart();
if (MySession.Static != null && MySession.Static.Ready)
{
MyConcurrentHashSet <MyEntity> entities = MyEntities.GetEntities();
foreach (MyEntity item in entities)
{
MyVoxelBase myVoxelBase = item as MyVoxelBase;
if (myVoxelBase != null && !(myVoxelBase is MyPlanet) && !myVoxelBase.Closed)
{
writer.WriteObjectStart();
writer.WritePropertyName("DisplayName");
writer.Write(myVoxelBase.StorageName);
writer.WritePropertyName("EntityId");
writer.Write(myVoxelBase.EntityId);
writer.WriteObjectEnd();
}
}
}
writer.WriteArrayEnd();
break;
case "/metrics/v1/session/planets":
writer.WriteArrayStart();
if (MySession.Static != null && MySession.Static.Ready)
{
MyConcurrentHashSet <MyEntity> entities = MyEntities.GetEntities();
foreach (MyEntity item in entities)
{
MyPlanet myPlanet = item as MyPlanet;
if (myPlanet != null && !myPlanet.Closed)
{
string storageName = myPlanet.StorageName;
long entityId = myPlanet.EntityId;
writer.WriteObjectStart();
writer.WritePropertyName("DisplayName");
writer.Write(storageName);
writer.WritePropertyName("EntityId");
writer.Write(entityId);
writer.WriteObjectEnd();
}
}
}
writer.WriteArrayEnd();
break;
case "/metrics/v1/session/floatingObjects":
writer.WriteArrayStart();
if (MySession.Static != null && MySession.Static.Ready)
{
ICollection <MyPlayer> onlinePlayers = MySession.Static.Players.GetOnlinePlayers();
MyConcurrentHashSet <MyEntity> entities = MyEntities.GetEntities();
foreach (MyEntity item in entities)
{
MyFloatingObject myFloatingObject = item as MyFloatingObject;
MyInventoryBagEntity myInventoryBagEntity = item as MyInventoryBagEntity;
if (myFloatingObject != null || myInventoryBagEntity != null)
{
string value = string.Empty;
long value2 = 0L;
string value3 = string.Empty;
float value4 = 0f;
float value5 = 0f;
float value6 = 0f;
string value7 = string.Empty;
if (myFloatingObject != null)
{
if (myFloatingObject.Closed || myFloatingObject.Physics == null)
{
continue;
}
value = myFloatingObject.DisplayName;
value2 = myFloatingObject.EntityId;
value3 = "FloatingObject";
value4 = myFloatingObject.Physics.Mass;
value5 = myFloatingObject.Physics.LinearVelocity.Length();
value6 = MySession.GetPlayerDistance(myFloatingObject, onlinePlayers);
var def = MyDefinitionManager.Static.GetPhysicalItemDefinition(new MyDefinitionId(myFloatingObject.Item.Content.TypeId, myFloatingObject.Item.Content.SubtypeId));
value7 = def.DisplayNameText;
}
else if (myInventoryBagEntity != null)
{
if (myInventoryBagEntity.Closed || myInventoryBagEntity.Physics == null)
{
continue;
}
value = myInventoryBagEntity.DisplayName;
value2 = myInventoryBagEntity.EntityId;
value3 = "Bag";
value4 = myInventoryBagEntity.Physics.Mass;
value5 = myInventoryBagEntity.Physics.LinearVelocity.Length();
value6 = MySession.GetPlayerDistance(myInventoryBagEntity, onlinePlayers);
value7 = "Bag";
}
writer.WriteObjectStart();
writer.WritePropertyName("DisplayName");
writer.Write(value);
writer.WritePropertyName("EntityId");
writer.Write(value2);
writer.WritePropertyName("Kind");
writer.Write(value3);
writer.WritePropertyName("Mass");
writer.Write(value4);
writer.WritePropertyName("LinearSpeed");
writer.Write(value5);
writer.WritePropertyName("DistanceToPlayer");
writer.Write(value6);
writer.WritePropertyName("TypeDisplayName");
writer.Write(value7);
writer.WriteObjectEnd();
}
}
}
writer.WriteArrayEnd();
break;
case "/metrics/v1/session/factions":
writer.WriteArrayStart();
if (MySession.Static != null && MySession.Static.Ready)
{
List <MyFaction> factions = MySession.Static.Factions.Select((x) => x.Value).ToList();
foreach (MyFaction myfaction in factions)
{
writer.WriteObjectStart();
writer.WritePropertyName("AcceptHumans");
writer.Write(myfaction.AcceptHumans);
writer.WritePropertyName("AutoAcceptMember");
writer.Write(myfaction.AutoAcceptMember);
writer.WritePropertyName("AutoAcceptPeace");
writer.Write(myfaction.AutoAcceptPeace);
writer.WritePropertyName("EnableFriendlyFire");
writer.Write(myfaction.EnableFriendlyFire);
writer.WritePropertyName("FactionId");
writer.Write(myfaction.FactionId);
writer.WritePropertyName("FounderId");
writer.Write(myfaction.FounderId);
writer.WritePropertyName("MemberCount");
writer.Write(myfaction.Members.Count);
writer.WritePropertyName("Name");
writer.Write(myfaction.Name);
writer.WritePropertyName("Tag");
writer.Write(myfaction.Tag);
writer.WritePropertyName("NPCOnly");
writer.Write(myfaction.Members.All((x) => MySession.Static.Players.IdentityIsNpc(x.Value.PlayerId)));
writer.WriteObjectEnd();
}
}
writer.WriteArrayEnd();
break;
}
return(sb.ToString());
}
public override void OnAddedToContainer(MyComponentContainer container)
{
base.OnAddedToContainer(container);
m_floatingObject = Entity as MyFloatingObject;
}
private static void GetSurfaceAndMaterial(IMyEntity entity, ref LineD line, ref Vector3D hitPosition, out MySurfaceImpactEnum surfaceImpact, out MyStringHash materialType)
{
var voxelBase = entity as MyVoxelBase;
if (voxelBase != null)
{
materialType = MyMaterialType.ROCK;
surfaceImpact = MySurfaceImpactEnum.DESTRUCTIBLE;
var voxelDefinition = voxelBase.GetMaterialAt(ref hitPosition);
if (voxelDefinition != null)
{
materialType = MyStringHash.GetOrCompute(voxelDefinition.MaterialTypeName);
}
}
else if (entity is MyCharacter)
{
surfaceImpact = MySurfaceImpactEnum.CHARACTER;
materialType = MyMaterialType.CHARACTER;
if ((entity as MyCharacter).Definition.PhysicalMaterial != null)
{
materialType = MyStringHash.GetOrCompute((entity as MyCharacter).Definition.PhysicalMaterial);
}
}
else if (entity is MyFloatingObject)
{
MyFloatingObject obj = entity as MyFloatingObject;
materialType = (obj.VoxelMaterial != null) ? MyMaterialType.ROCK : (obj.ItemDefinition != null && obj.ItemDefinition.PhysicalMaterial != MyStringHash.NullOrEmpty ? obj.ItemDefinition.PhysicalMaterial : MyMaterialType.METAL);
surfaceImpact = MySurfaceImpactEnum.METAL;
}
else if (entity is MyTrees)
{
surfaceImpact = MySurfaceImpactEnum.DESTRUCTIBLE;
materialType = MyMaterialType.WOOD;
}
else if (entity is IMyHandheldGunObject <MyGunBase> )
{
surfaceImpact = MySurfaceImpactEnum.METAL;
materialType = MyMaterialType.METAL;
var mat = (entity as IMyHandheldGunObject <MyGunBase>).GunBase;
if (mat != null && mat.WeaponProperties != null && mat.WeaponProperties.WeaponDefinition != null)
{
materialType = mat.WeaponProperties.WeaponDefinition.PhysicalMaterial;
}
}
else
{
surfaceImpact = MySurfaceImpactEnum.METAL;
materialType = MyMaterialType.METAL;
if (entity is MyCubeGrid)
{
var grid = (entity as MyCubeGrid);
if (grid != null)
{
var block = grid.GetTargetedBlock(hitPosition);
if (block != null)
{
if (block.BlockDefinition.PhysicalMaterial != null && !block.BlockDefinition.PhysicalMaterial.Id.TypeId.IsNull)
{
materialType = MyStringHash.GetOrCompute(block.BlockDefinition.PhysicalMaterial.Id.SubtypeName);
}
else
{
if (block.FatBlock != null)
{
MyIntersectionResultLineTriangleEx?res = null;
block.FatBlock.GetIntersectionWithLine(ref line, out res);
if (res.HasValue)
{
var technique = block.FatBlock.ModelCollision.GetDrawTechnique(res.Value.Triangle.TriangleIndex);
if (technique == VRageRender.Import.MyMeshDrawTechnique.GLASS)
{
materialType = MyStringHash.GetOrCompute("Glass");
}
}
}
}
}
}
}
}
System.Diagnostics.Debug.Assert(materialType.GetHashCode() != 0, "Unknown material");
}
public override void UpdateAfterSimulation()
{
base.UpdateAfterSimulation();
//MyRenderProxy.DebugDrawSphere(m_gunBase.PositionMuzzleWorld, 0.2f, new Vector3(1, 0, 0), 1.0f, true);
m_targetGrid = null;
m_targetDestroyable = null;
m_targetFloatingObject = null;
m_targetCharacter = null;
if (Owner == null)
{
return;
}
var entitiesInRange = m_sensor.EntitiesInRange;
int closestEntityIndex = 0;
float closestDistance = float.MaxValue;
if (entitiesInRange != null && entitiesInRange.Count > 0)
{
int i = 0;
foreach (var entity in entitiesInRange.Values)
{
var targetGrid = entity.Entity as MyCubeGrid;
var distanceSq = (float)Vector3D.DistanceSquared(entity.DetectionPoint, m_gunBase.GetMuzzleWorldPosition());
if (entity.Entity.Physics != null && entity.Entity.Physics.Enabled)
{
if (distanceSq < closestDistance)
{
m_targetGrid = targetGrid;
m_targetDistanceSq = (float)distanceSq;
m_targetDestroyable = entity.Entity as IMyDestroyableObject;
m_targetFloatingObject = entity.Entity as MyFloatingObject;
m_targetCharacter = entity.Entity as MyCharacter;
closestDistance = m_targetDistanceSq;
closestEntityIndex = i;
}
}
++i;
}
}
if (m_targetGrid != null)
{
m_targetPosition = entitiesInRange.Values.ElementAt(closestEntityIndex).DetectionPoint;
var invWorld = m_targetGrid.PositionComp.GetWorldMatrixNormalizedInv();
var gridLocalPos = Vector3D.Transform(m_targetPosition, invWorld);
var gridSpacePos = Vector3I.Round(gridLocalPos / m_targetGrid.GridSize);
m_targetGrid.FixTargetCube(out m_targetCube, gridLocalPos / m_targetGrid.GridSize);
var head = PositionComp.WorldMatrix;
var aimToMuzzle = Vector3D.Normalize(m_targetPosition - m_gunBase.GetMuzzleWorldPosition());
if (Vector3.Dot(aimToMuzzle, head.Forward) > 0)
{
m_targetDistanceSq = 0;
}
else
{
m_targetDistanceSq = (float)Vector3D.DistanceSquared(m_targetPosition, m_gunBase.GetMuzzleWorldPosition());
}
}
SinkComp.Update();
if (IsShooting && !SinkComp.IsPowered)
{
EndShoot(MyShootActionEnum.PrimaryAction);
}
UpdateEffect();
CheckEffectType();
if (Owner != null && Owner.ControllerInfo.IsLocallyHumanControlled())
{
if (MySession.Static.SurvivalMode && (MySession.GetCameraControllerEnum() != MyCameraControllerEnum.Spectator || MyFinalBuildConstants.IS_OFFICIAL))
{
var character = ((MyCharacter)this.CharacterInventory.Owner);
MyCubeBuilder.Static.MaxGridDistanceFrom = character.PositionComp.GetPosition() + character.WorldMatrix.Up * 1.8f;
}
else
{
MyCubeBuilder.Static.MaxGridDistanceFrom = null;
}
}
//MyTrace.Watch("MyEngineerToolBase.RequiredPowerInput", RequiredPowerInput);
}
private static bool TakeFloatingObjectPrepare(long ownerEntityId, long floatingObjectId, byte inventoryIndex, out MyFloatingObject obj, out MyFixedPoint amount)
{
obj = null;
amount = 0;
if (!MyEntities.EntityExists(ownerEntityId) || !MyEntities.EntityExists(floatingObjectId))
{
return(false);
}
obj = MyEntities.GetEntityById(floatingObjectId) as MyFloatingObject;
if (obj.MarkedForClose)
{
return(false);
}
var owner = MyEntities.GetEntityById(ownerEntityId) as IMyInventoryOwner;
var inv = owner.GetInventory(inventoryIndex);
return(ComputeFloatingObjectAmount(obj, ref amount, inv));
}
public FloatingObjectWrapper(MyFloatingObject entity)
{
Entity = entity;
}
