public override bool Update(MyPlayer player, MyEntity me)
{
if (me!=null)
if (Vector3D.DistanceSquared(me.PositionComp.GetPosition(), TargetPos) > m_maxDistance2)
m_IsTrue = true;
return IsTrue;
}
public bool Update(MyPlayer player, MyEntity entity) //returns if lost
{
//MySessionComponentMission.Static.TryCreateFromDefault(Id);
//if (IsLocal(player.Id))
// UpdateLocal(player.Id);
if (!Sync.IsServer)
return false;
MyMissionTriggers mtrig;
if (!MissionTriggers.TryGetValue(player.Id, out mtrig))
{
//Debug.Assert(false,"Bad ID for update in missionTriggers");
mtrig = TryCreateFromDefault(player.Id, false);
}
mtrig.UpdateWin(player, entity);
if (!mtrig.Won)
mtrig.UpdateLose(player, entity);
else
{
m_someoneWon = true;
MyAnalyticsHelper.ReportTutorialEnd();
MyTutorialHelper.MissionSuccess();
}
return mtrig.Lost;
}
public static void Init()
{
if ( !PluginSettings.Instance.PlayerBlockEnforcementEnabled )
return;
if (_init)
return;
_init = true;
MyEntities.OnEntityAdd += MyEntities_OnEntityAdd;
HashSet<MyEntity> allEntities = new HashSet<MyEntity>();
Wrapper.GameAction( () => allEntities = MyEntities.GetEntities() );
MyEntity[] entitiesCopy = new MyEntity[allEntities.Count];
allEntities.CopyTo( entitiesCopy );
Parallel.ForEach( entitiesCopy, ( entity ) =>
{
var grid = entity as MyCubeGrid;
if ( grid == null )
return;
InitGrid( grid );
} );
Essentials.Log.Info( "Initialized player block enforcement." );
ProcessEnforcement();
}
private void on_entity_deleted(MyEntity entity)
{
//log_event("on_entity_deleted", entity);
var cube_grid = entity as MyCubeGrid;
if (cube_grid != null)
grid_manager.remove_grid(cube_grid);
}
public override bool Update(MyPlayer player, MyEntity me)
{
if (MySession.Static.IsScenario)
if (m_limit <= DateTime.UtcNow - MyScenarioSystem.Static.ServerStartGameTime)
m_IsTrue = true;
return IsTrue;
}
public MyCharacterPhysicsStateGroup(MyEntity entity, IMyReplicable ownerReplicable)
: base(entity, ownerReplicable)
{
// This is 9 bits per component which is more than enough (512 discrete values per-axis)
m_lowPrecisionOrientation = true;
FindSupportDelegate = () => MySupportHelper.FindSupportForCharacter(Entity);
}
override protected bool IsMoving(MyEntity entity)
{
// Never know if somebody is moving entity when physics is null
return Entity.Physics == null
|| Vector3.IsZero(entity.Physics.LinearVelocity, PRECISION) == false
|| Entity.RotationSpeed > 0.0f;
}
public MyRadioBroadcaster(MyEntity parent, float broadcastRadius = 100)
{
SyncObject = new MySyncRadioBroadcaster(this);
Parent = parent;
m_broadcastRadius = broadcastRadius;
parent.OnClose += parent_OnClose;
}
public MyBasicObstacle(MyEntity entity)
{
m_entity = entity;
m_entity.OnClosing += OnEntityClosing;
Update();
m_valid = true;
}
public virtual void Init(Vector3 offset, MyEntity parentObject, MyModelsEnum model)
{
base.Init(null, model, null, parentObject, null, null);
LocalMatrix = Matrix.CreateTranslation(offset);
RotationSpeed = 0;
Save = false;
}
public override ChangeInfo Update(MyEntity owner, long playerID = 0)
{
if (MyCubeBuilder.Static==null)
return ChangeInfo.None;
var blockDefinition = MyCubeBuilder.Static.IsActivated ? MyCubeBuilder.Static.ToolbarBlockDefinition : null;
if ((MyCubeBuilder.Static.BlockCreationIsActivated || MyCubeBuilder.Static.MultiBlockCreationIsActivated) && blockDefinition != null && (!MyFakes.ENABLE_BATTLE_SYSTEM || !MySession.Static.Battle))
{
var blockDef = (this.Definition as Sandbox.Definitions.MyCubeBlockDefinition);
if (blockDefinition.BlockPairName == blockDef.BlockPairName)
{
WantsToBeSelected = true;
}
else if (blockDef.BlockStages != null && blockDef.BlockStages.Contains(blockDefinition.Id))
{
WantsToBeSelected = true;
}
else
{
WantsToBeSelected = false;
}
}
else
{
WantsToBeSelected = false;
}
return ChangeInfo.None;
}
protected virtual bool IsMoving(MyEntity entity)
{
// Never know if somebody is moving entity when physics is null
return entity.Physics == null
|| Vector3.IsZero(entity.Physics.LinearVelocity, PRECISION) == false
|| Vector3.IsZero(entity.Physics.AngularVelocity, PRECISION) == false;
}
public static void Add(MyEntity entity)
{
Debug.Assert(entity.Parent == null || (entity.Flags & EntityFlags.IsGamePrunningStructureObject) != 0, "Only topmost entities");
if (entity.TopMostPruningProxyId != MyVRageConstants.PRUNING_PROXY_ID_UNITIALIZED) return; // already inserted
BoundingBoxD bbox = GetEntityAABB(entity);
if (bbox.Size == Vector3D.Zero) return; // don't add entities with zero bounding boxes
if (IsEntityStatic(entity))
{
entity.TopMostPruningProxyId = m_staticObjectsTree.AddProxy(ref bbox, entity, 0);
entity.StaticForPruningStructure = true;
}
else
{
entity.TopMostPruningProxyId = m_dynamicObjectsTree.AddProxy(ref bbox, entity, 0);
entity.StaticForPruningStructure = false;
}
var voxelMap = entity as MyVoxelBase;
if (voxelMap != null)
{
voxelMap.VoxelMapPruningProxyId = m_voxelMapsTree.AddProxy(ref bbox, entity, 0);
}
}
public static MyEntity FindSupportForCharacterAABB(MyEntity entity)
{
BoundingBoxD characterBox = entity.PositionComp.WorldAABB;
characterBox.Inflate(1.0);
m_entities.Clear();
MyEntities.GetTopMostEntitiesInBox(ref characterBox, m_entities);
float maxRadius = 0;
MyCubeGrid biggestGrid = null;
MyEntity voxel = null;
foreach(var parent in m_entities)
{
MyCubeGrid grid = parent as MyCubeGrid;
if(parent is MyVoxelBase)
{
voxel = (parent as MyVoxelBase).RootVoxel;
}
if(grid != null)
{
var rad = grid.PositionComp.LocalVolume.Radius;
if (rad > maxRadius || (rad == maxRadius && (biggestGrid == null || grid.EntityId > biggestGrid.EntityId)))
{
maxRadius = rad;
biggestGrid = grid;
}
}
}
if (biggestGrid == null)
{
return voxel;
}
return biggestGrid;
}
// Not used apparently
public static void AddShotgun(MyProjectileAmmoDefinition ammoDefinition, MyEntity ignorePhysObject, Vector3 origin, Vector3 initialVelocity, Vector3 directionNormalized, bool groupStart, float thicknessMultiplier, MyEntity weapon, float frontBillboardSize, MyEntity ownerEntity = null, float projectileCountMultiplier = 1)
{
MyProjectile newProjectile = m_projectiles.Allocate();
if (newProjectile != null)
{
//newProjectile.Start(
// ammoDefinition,
// ignorePhysObject,
// origin,
// initialVelocity,
// directionNormalized,
// groupStart,
// thicknessMultiplier,
// 1,
// weapon,
// projectileCountMultiplier
// );
// newProjectile.BlendByCameraDirection = true;
// newProjectile.FrontBillboardMaterial = "ShotgunParticle";
// newProjectile.LengthMultiplier = 2;
// newProjectile.FrontBillboardSize = frontBillboardSize;
// newProjectile.OwnerEntity = ownerEntity != null ? ownerEntity : ignorePhysObject;
}
}
public void FirstIntoRowShouldReturnFirstRowIfMoreThanOneEntityUsed()
{
var first = new MyEntity() { Table = "x" };
var second = new MyEntity() { Table = "y" };
var query = new SqlQuery().From(first).From(second.Table, Alias.T1).Into(second);
Assert.Equal(first, ((ISqlQueryExtensible)query).FirstIntoRow);
}
private void SectorOnContactPoint(int itemId, MyEntity other, ref MyPhysics.MyContactPointEvent e)
{
// if item is already disabled: puff
// We get multiple contact points so this is for that
if (m_sector.DataView.Items[itemId].ModelIndex < 0) return;
var vel = Math.Abs(e.ContactPointEvent.SeparatingVelocity);
if (other == null || other.Physics == null || other is MyFloatingObject) return;
if (other is IMyHandheldGunObject<MyDeviceBase>) return;
// Prevent debris from breaking trees.
// Debris flies in unpredictable ways and this could cause out of sync tree destruction which would is bad.
if (other.Physics.RigidBody != null && other.Physics.RigidBody.Layer == MyPhysics.CollisionLayers.DebrisCollisionLayer) return;
// On objects held in manipulation tool, Havok returns high velocities, after this contact is fired by contraint solver.
// Therefore we disable damage from objects connected by constraint to character
if (MyManipulationTool.IsEntityManipulated(other))
return;
float otherMass = MyDestructionHelper.MassFromHavok(other.Physics.Mass);
double impactEnergy = vel * vel * otherMass;
// TODO: per item max impact energy
if (impactEnergy > ItemResilience(itemId))
{
BreakAt(itemId, e.Position, e.ContactPointEvent.ContactPoint.Normal, impactEnergy);
}
// Meteor destroy always
if (other is MyMeteor)
m_sector.EnableItem(itemId, false);
}
public override void Init(StringBuilder displayName, Models.MyModelsEnum? modelLod0Enum, Models.MyModelsEnum? modelLod1Enum, MyEntity parentObject, float? scale, CommonLIB.AppCode.ObjectBuilders.MyMwcObjectBuilder_Base objectBuilder, Models.MyModelsEnum? modelCollision = null, Models.MyModelsEnum? modelLod2 = null)
{
base.Init(displayName, modelLod0Enum, modelLod1Enum, parentObject, scale, objectBuilder, modelCollision, modelLod2);
switch (modelLod0Enum)
{
case Models.MyModelsEnum.Cockpit_SS_04:
Crosshair = HUD.MyHudTexturesEnum.crosshair_nazzi;
break;
case Models.MyModelsEnum.Cockpit_Razorclaw:
Crosshair = HUD.MyHudTexturesEnum.crosshair_templary;
break;
case Models.MyModelsEnum.Cockpit_CN_03:
Crosshair = HUD.MyHudTexturesEnum.crosshair_russian;
break;
case Models.MyModelsEnum.OmniCorp_EAC01_Cockpit:
case Models.MyModelsEnum.OmniCorp01_Cockpit:
case Models.MyModelsEnum.OmniCorp04_Cockpit:
case Models.MyModelsEnum.OmniCorp03_Cockpit:
Crosshair = HUD.MyHudTexturesEnum.crosshair_omnicorp;
break;
case Models.MyModelsEnum.EAC02_Cockpit:
case Models.MyModelsEnum.EAC03_Cockpit:
case Models.MyModelsEnum.EAC04_Cockpit:
case Models.MyModelsEnum.EAC05_Cockpit:
default:
Crosshair = HUD.MyHudTexturesEnum.Crosshair01;
break;
}
m_modelLod0.PreloadTextures(LoadingMode.Immediate, MaterialIndex);
}
// This method realy initiates/starts the missile
// IMPORTANT: Direction vector must be normalized!
public void Start(
Vector3 position,
Vector3 initialVelocity,
Vector3 direction,
float impulseMultiplier,
MyEntity owner)
{
if (Physics.Static)
{
Physics.Static = false;
}
base.Start(position, initialVelocity, direction, impulseMultiplier, owner, MyTextsWrapper.Get(MyTextsWrapperEnum.RemoteCameraHud));
Physics.AngularDamping = 1;
Health = MaxHealth;
m_directionAfterContact = null;
var ownerShip = owner as MySmallShip;
if (ownerShip != null)
{
ownerShip.Config.BackCamera.SetOn();
ownerShip.AddRemoteCamera(this);
ownerShip.SelectLastRemoteCamera();
}
}
public void SetAbsoluteTarget(Vector3 absoluteTarget)
{
m_mode = AimingMode.TARGET;
m_aimTarget = null;
m_relativeTarget = absoluteTarget;
Update();
}
public void SetTarget(MyEntity entity, Vector3? relativeTarget = null)
{
m_mode = AimingMode.TARGET;
m_aimTarget = entity;
m_relativeTarget = relativeTarget;
Update();
}
private void EntityRemoved(MyEntity entity)
{
var planet = entity as MyPlanet;
if (planet != null)
{
m_planets.Remove(entity.EntityId);
}
}
private void EntityAdded(MyEntity entity)
{
var planet = entity as MyPlanet;
if (planet != null)
{
m_planets.Add(entity.EntityId, planet);
}
}
public void Init(MyEntity parent)
{
base.Init(null, MyModelsEnum.HarvestingHead, null, parent, null, null);
// For performance optimizations, we don't check if this small objects are in a frustum and draw them directly
m_frustumCheckBeforeDrawEnabled = false;
Save = false;
}
override protected bool IsMoving(MyEntity entity)
{
// Never know if somebody is moving entity when physics is null
return Entity.Physics == null
|| Vector3.IsZero(entity.Physics.LinearVelocity, PRECISION) == false
|| Vector2.IsZero(Entity.RotationIndicator, PRECISION) == false
|| Math.Abs(Entity.RollIndicator - 0.0f) > 0.001f;
}
public void GetEntityName_returns_name_of_entity()
{
var entity = new MyEntity();
var name = entity.GetEntityName();
Assert.AreEqual("MyEntity", name);
}
public MyRadioBroadcaster(MyEntity parent, float broadcastRadius = 100, bool enabled = true)
{
SyncObject = new MySyncRadioBroadcaster(this);
Parent = parent;
m_broadcastRadius = broadcastRadius;
parent.OnClose += parent_OnClose;
Enabled = enabled;
}
public override void Init(StringBuilder displayName, Models.MyModelsEnum? modelLod0Enum, Models.MyModelsEnum? modelLod1Enum, MyEntity parentObject, float? scale, CommonLIB.AppCode.ObjectBuilders.MyMwcObjectBuilder_Base objectBuilder, Models.MyModelsEnum? modelCollision = null, Models.MyModelsEnum? modelLod2Enum = null)
{
// Some fake builder
var builder = new MyMwcObjectBuilder_SmallShip_Weapon(MyMwcObjectBuilder_SmallShip_Weapon_TypesEnum.Drilling_Device_Crusher);
base.Init(displayName, modelLod0Enum, modelLod1Enum, parentObject, scale, builder, modelCollision, modelLod2Enum);
SetModel(MyModelsEnum.MysteriousBox_matt_5m);
}
void m_entity_OnClose(MyEntity obj)
{
if (m_shotSmoke != null)
{
MyParticlesManager.RemoveParticleEffect(m_shotSmoke);
m_shotSmoke = null;
}
}
public MyEntityPhysicsStateGroupWithSupport(MyEntity entity, IMyReplicable ownerReplicable)
: base(entity, ownerReplicable)
{
m_onSupportMove = OnSupportMove;
m_onSupportVelocityChanged = OnSupportVelocityChanged;
if (Sync.IsServer)
OnMoved += PhysicsStateGroup_OnMoved;
}
private void m_endEntity_OnClosing(MyEntity obj)
{
m_endEntity = null;
IsValid = false;
}
protected override bool IsUsed(MyEntity thrustEntity)
{
return(Enabled);
}
void collidedEntity_OnClose(MyEntity obj)
{
m_collidedEntity = null;
obj.OnClose -= m_collidedEntity_OnClose;
}
protected override void AddToGroup(MyEntity thrustEntity, MyEntityThrustComponent.MyConveyorConnectedGroup group)
{
}
protected override void CustomClientRead(uint timeStamp, ref MyTimeStampValues serverPositionAndOrientation, VRage.Library.Collections.BitStream stream)
{
bool hasSupport = stream.ReadBool();
if (hasSupport)
{
long entityId = stream.ReadInt64();
Vector3D serverDelta = stream.ReadVector3D();
Vector3D serverSupportPos = stream.ReadVector3D();
if (!MyEntities.EntityExists(entityId))
{
return;
}
MyEntity support = MyEntities.GetEntityById(entityId);
MyTimeStampValues?clientTransform = m_timestamp.GetTransform(timeStamp);
Vector3D clientDelta = Vector3.Zero;
Vector3D clientVelocity = Vector3D.Zero;
Quaternion rotationComp = Quaternion.Identity;
if (clientTransform != null)
{
if (m_supportTimeStamp == null)
{
return;
}
MyTimeStampValues?supportTransform = m_supportTimeStamp.GetTransform(timeStamp);
Vector3D supportPosition = support.PositionComp.WorldMatrix.Translation;
if (supportTransform.HasValue)
{
supportPosition = supportTransform.Value.Transform.Position;
if (supportTransform.Value.EntityId != entityId)
{
supportPosition = serverSupportPos;
return;
}
}
clientDelta = supportPosition - clientTransform.Value.Transform.Position;
clientVelocity = clientTransform.Value.LinearVelocity;
rotationComp = Quaternion.Inverse(clientTransform.Value.Transform.Rotation);
}
else
{
m_character.PositionComp.SetWorldMatrix(serverPositionAndOrientation.Transform.TransformMatrix, null, true);
return;
}
MyTimeStampValues delta = new MyTimeStampValues();
Quaternion.Multiply(ref serverPositionAndOrientation.Transform.Rotation, ref rotationComp, out delta.Transform.Rotation);
delta.Transform.Position = clientDelta - serverDelta;
delta.LinearVelocity = serverPositionAndOrientation.LinearVelocity - clientVelocity;
double deltaL = delta.Transform.Position.Length();
//if difference is more than
if (deltaL < (MyGridPhysics.ShipMaxLinearVelocity() * Sync.RelativeSimulationRatio))
{
delta.Transform.Position = delta.Transform.Position * 0.2;
delta.Transform.Rotation = Quaternion.Slerp(delta.Transform.Rotation, Quaternion.Identity, 0.2f);
}
Quaternion normalized = delta.Transform.Rotation;
normalized.Normalize();
delta.Transform.Rotation = normalized;
normalized = serverPositionAndOrientation.Transform.Rotation;
normalized.Normalize();
serverPositionAndOrientation.Transform.Rotation = normalized;
Quaternion clientNormalized = clientTransform.Value.Transform.Rotation;
clientNormalized.Normalize();
double eps = 0.001;
bool hasJetpack = m_character.JetpackComp != null;
if (hasJetpack && m_character.JetpackComp.TurnedOn && m_character.IsDead == false)
{
if (Math.Abs(Quaternion.Dot(serverPositionAndOrientation.Transform.Rotation, clientNormalized)) < 1 - eps)
{
Quaternion currentOrientation = Quaternion.CreateFromForwardUp(m_character.WorldMatrix.Forward, m_character.WorldMatrix.Up);
Quaternion.Multiply(ref delta.Transform.Rotation, ref currentOrientation, out currentOrientation);
MatrixD matrix = MatrixD.CreateFromQuaternion(currentOrientation);
MatrixD currentMatrix = m_character.PositionComp.WorldMatrix;
currentMatrix.Translation = Vector3D.Zero;
if (currentMatrix.EqualsFast(ref matrix) == false)
{
if (m_character.Physics.CharacterProxy != null)
{
m_character.Physics.CharacterProxy.Forward = matrix.Forward;
m_character.Physics.CharacterProxy.Up = matrix.Up;
}
}
}
}
if (deltaL > (MyGridPhysics.ShipMaxLinearVelocity() * Sync.RelativeSimulationRatio))
{
m_character.PositionComp.SetPosition(serverPositionAndOrientation.Transform.Position);
m_character.Physics.LinearVelocity = serverPositionAndOrientation.LinearVelocity;
m_timestamp.OverwriteServerPosition(timeStamp, ref serverPositionAndOrientation);
return;
}
else if (deltaL > 5.0f * MyTimestampHelper.POSITION_TOLERANCE)
{
m_character.CacheMoveDelta(ref delta.Transform.Position);
}
m_character.Physics.LinearVelocity += delta.LinearVelocity;
m_timestamp.UpdateDeltaPosition(timeStamp, ref delta);
}
else
{
base.CustomClientRead(timeStamp, ref serverPositionAndOrientation, stream);
}
}
public MySyncEntity(MyEntity entity)
{
Entity = entity;
ResetUpdateTimer();
UpdatesOnlyOnServer = false;
}
// 构造方法
public MyQueryable(string connectionString)
{
_masterEntity = MyEntityContainer.Get(typeof(T));
_connectionString = connectionString;
}
public float GetPostModifier(float damage, MyStringHash damageSource, MyHitInfo?hitInfo, MyEntity attacker = null)
{
return(0);
}
public float GetMultiplier(float damage, MyStringHash damageSource, MyHitInfo?hitInfo, MyEntity attacker = null)
{
if (Definition == null)
{
return(1);
}
float reduction;
return(Definition.DamageReduction.TryGetValue(damageSource, out reduction) ? 1 - reduction : 1);
}
public MyEntity3DSoundEmitter(MyEntity entity, MyEntity owner = null)
{
m_entity = entity;
m_owner = owner;
}
internal void MyStaticInfo()
{
ClosestStaticSqr = double.MaxValue;
StaticGridInRange = false;
MyEntity closestEnt = null;
var closestCenter = Vector3D.Zero;
double closestDistSqr = double.MaxValue;
CanShoot = true;
for (int i = 0; i < StaticsInRange.Count; i++)
{
var ent = StaticsInRange[i];
if (ent == null)
{
continue;
}
if (ent.MarkedForClose)
{
continue;
}
var safeZone = ent as MySafeZone;
var staticCenter = ent.PositionComp.WorldAABB.Center;
if (ent is MyCubeGrid)
{
StaticGridInRange = true;
}
double distSqr;
Vector3D.DistanceSquared(ref staticCenter, ref ScanVolume.Center, out distSqr);
if (distSqr < closestDistSqr)
{
closestDistSqr = distSqr;
closestEnt = ent;
closestCenter = staticCenter;
}
if (CanShoot && safeZone != null && safeZone.Enabled)
{
if (safeZone.PositionComp.WorldVolume.Contains(MyGrid.PositionComp.WorldVolume) != ContainmentType.Disjoint && ((Session.SafeZoneAction)safeZone.AllowedActions & Session.SafeZoneAction.Shooting) == 0)
{
CanShoot = !TouchingSafeZone(safeZone);
}
}
}
if (closestEnt != null)
{
var dist = Vector3D.Distance(ScanVolume.Center, closestCenter);
dist -= closestEnt.PositionComp.LocalVolume.Radius;
dist -= ScanVolume.Radius;
if (dist < 0)
{
dist = 0;
}
var distSqr = dist * dist;
if (ClosestPlanetSqr < distSqr)
{
distSqr = ClosestPlanetSqr;
}
ClosestStaticSqr = distSqr;
}
else if (ClosestPlanetSqr < ClosestStaticSqr)
{
ClosestStaticSqr = ClosestPlanetSqr;
}
}
public void RequestJump(string destinationName, Vector3D destination, long userId)
{
if (!Vector3.IsZero(MyGravityProviderSystem.CalculateNaturalGravityInPoint(m_grid.WorldMatrix.Translation)))
{
var notification = new MyHudNotification(MySpaceTexts.NotificationCannotJumpFromGravity, 1500);
MyHud.Notifications.Add(notification);
return;
}
if (!Vector3.IsZero(MyGravityProviderSystem.CalculateNaturalGravityInPoint(destination)))
{
var notification = new MyHudNotification(MySpaceTexts.NotificationCannotJumpIntoGravity, 1500);
MyHud.Notifications.Add(notification);
return;
}
if (!IsJumpValid(userId))
{
return;
}
if (MySession.Static.Settings.WorldSizeKm > 0 && destination.Length() > MySession.Static.Settings.WorldSizeKm * 500)
{
var notification = new MyHudNotification(MySpaceTexts.NotificationCannotJumpOutsideWorld, 1500);
MyHud.Notifications.Add(notification);
return;
}
m_selectedDestination = destination;
double maxJumpDistance = GetMaxJumpDistance(userId);
m_jumpDirection = destination - m_grid.WorldMatrix.Translation;
double jumpDistance = m_jumpDirection.Length();
double actualDistance = jumpDistance;
if (jumpDistance > maxJumpDistance)
{
double ratio = maxJumpDistance / jumpDistance;
actualDistance = maxJumpDistance;
m_jumpDirection *= ratio;
}
//By Gregory: Check for obstacle not that fast but happens rarely(on Jump drive enable)
//TODO: make compatible with GetMaxJumpDistance and refactor to much code checks for actual jump
var direction = Vector3D.Normalize(destination - m_grid.WorldMatrix.Translation);
var startPos = m_grid.WorldMatrix.Translation + m_grid.PositionComp.LocalAABB.Extents.Max() * direction;
var line = new LineD(startPos, destination);
var intersection = MyEntities.GetIntersectionWithLine(ref line, m_grid, null, ignoreObjectsWithoutPhysics: false);
Vector3D newDestination = Vector3D.Zero;
Vector3D newDirection = Vector3D.Zero;
if (intersection.HasValue)
{
MyEntity MyEntity = intersection.Value.Entity as MyEntity;
var targetPos = MyEntity.WorldMatrix.Translation;
var obstaclePoint = MyUtils.GetClosestPointOnLine(ref startPos, ref destination, ref targetPos);
MyPlanet MyEntityPlanet = intersection.Value.Entity as MyPlanet;
if (MyEntityPlanet != null)
{
var notification = new MyHudNotification(MySpaceTexts.NotificationCannotJumpIntoGravity, 1500);
MyHud.Notifications.Add(notification);
return;
}
//var Radius = MyEntityPlanet != null ? MyEntityPlanet.MaximumRadius : MyEntity.PositionComp.LocalAABB.Extents.Length();
var Radius = MyEntity.PositionComp.LocalAABB.Extents.Length();
destination = obstaclePoint - direction * (Radius + m_grid.PositionComp.LocalAABB.HalfExtents.Length());
m_selectedDestination = destination;
m_jumpDirection = m_selectedDestination - startPos;
actualDistance = m_jumpDirection.Length();
}
if (actualDistance < MIN_JUMP_DISTANCE)
{
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateMessageBox(
buttonType: MyMessageBoxButtonsType.OK,
messageText: GetWarningText(actualDistance, intersection.HasValue),
messageCaption: MyTexts.Get(MyCommonTexts.MessageBoxCaptionWarning)
));
}
else
{
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateMessageBox(
buttonType : MyMessageBoxButtonsType.YES_NO,
messageText : GetConfimationText(destinationName, jumpDistance, actualDistance, userId, intersection.HasValue),
messageCaption : MyTexts.Get(MyCommonTexts.MessageBoxCaptionPleaseConfirm),
size : new Vector2(0.839375f, 0.3675f), callback : delegate(MyGuiScreenMessageBox.ResultEnum result)
{
if (result == MyGuiScreenMessageBox.ResultEnum.YES && IsJumpValid(userId))
{
RequestJump(m_selectedDestination, userId);
}
else
{
AbortJump();
}
}
));
}
}
private void TakeMaterialsFromBuilder(MyEntity builder)
{
if (builder == null)
{
return;
}
var inventory = GetBuilderInventory(builder);
if (inventory == null)
{
return;
}
MyInventory shipInventory = null;
MyCockpit cockpit = null;
long identityId = long.MaxValue;
if (builder is MyCharacter)
{//construction cockpit?
cockpit = (builder as MyCharacter).IsUsing as MyCockpit;
if (cockpit != null)
{
shipInventory = cockpit.GetInventory();
identityId = cockpit.ControllerInfo.ControllingIdentityId;
}
else
if ((builder as MyCharacter).ControllerInfo != null)
{
identityId = (builder as MyCharacter).ControllerInfo.ControllingIdentityId;
}
else
{
Debug.Fail("failed to get identityId");
}
}
VRage.MyFixedPoint hasAmount, hasAmountCockpit;
foreach (var entry in m_materialList.RequiredMaterials)
{
VRage.MyFixedPoint toRemove = entry.Value;
hasAmount = GetItemAmountCombined(inventory, entry.Key);
if (hasAmount > entry.Value)
{
RemoveItemsCombined(inventory, (int)toRemove, entry.Key);
continue;
}
if (hasAmount > 0)
{
RemoveItemsCombined(inventory, (int)hasAmount, entry.Key);
toRemove -= hasAmount;
}
if (shipInventory != null)
{
hasAmountCockpit = GetItemAmountCombined(shipInventory, entry.Key);
if (hasAmountCockpit >= toRemove)
{
RemoveItemsCombined(shipInventory, (int)toRemove, entry.Key);
continue;
}
if (hasAmountCockpit > 0)
{
RemoveItemsCombined(shipInventory, (int)hasAmountCockpit, entry.Key);
toRemove -= hasAmountCockpit;
}
var transferred = MyGridConveyorSystem.ItemPullRequest(cockpit, shipInventory, identityId, entry.Key, toRemove, true);
Debug.Assert(transferred == toRemove, "Cannot pull enough materials to build, " + transferred + "!=" + toRemove);
}
else
{
Debug.Assert(toRemove == 0, "Needs more materials and ship inventory is null");
}
}
}
private void DroneMainEntityOnClosing(MyEntity entity)
{
UnregisterDrone(entity);
}
/// <summary>
/// Adjusts input for the autopilot's velocity and entity's velocity.
/// </summary>
/// <param name="input">Original TestInput with Direction as the desired direction of travel and Length as the distance to the destination.</param>
/// <param name="adjusted">Offset will be zero, Direction and Length will be modified from input for the velocity of autopilot and entity.</param>
/// <param name="entity">The potential obstruction, if null, assumes a static entity</param>
public void AdjustForCurrentVelocity(ref TestInput input, out TestInput adjusted, MyEntity entity, bool destination)
{
Vector3 autopilotVelocity = AutopilotGrid.Physics.LinearVelocity;
Vector3 relativeVelocity;
if (entity == null)
{
relativeVelocity = autopilotVelocity;
}
else
{
MyPhysicsComponentBase physics = entity.GetTopMostParent().Physics;
if (physics == null || physics.IsStatic)
{
relativeVelocity = autopilotVelocity;
}
else
{
Vector3 entityVelocity = physics.LinearVelocity;
Vector3.Subtract(ref autopilotVelocity, ref entityVelocity, out relativeVelocity);
}
}
Vector3.Add(ref relativeVelocity, ref input.Direction, out adjusted.Direction);
adjusted.Offset = Vector3D.Zero;
if (adjusted.Direction == Vector3.Zero)
{
adjusted.Length = 0f;
}
else
{
adjusted.Length = 20f + adjusted.Direction.Normalize() * Pathfinder.SpeedFactor;
if (destination && input.Length < adjusted.Length)
{
adjusted.Length = input.Length;
}
}
}
protected override bool IsThrustEntityType(MyEntity thrustEntity)
{
return(thrustEntity is MyCharacter);
}
private void character_OnClosing(MyEntity obj)
{
Character.OnClosing -= character_OnClosing;
Character = null;
}
protected override float MinPowerConsumption(MyEntity thrustEntity)
{
return(Jetpack.MinPowerConsumption);
}
/// <summary>
/// Tests if a section of space can be travelled without hitting the specified entity.
/// </summary>
/// <param name="entity">The potential obstruction</param>
/// <param name="ignoreBlock">Null or the block autopilot is trying to connect with.</param>
/// <param name="input"><see cref="TestInput"/></param>
/// <param name="result"><see cref="GridTestResult"/></param>
/// <returns>True if the specified entity obstructs the path.</returns>
public bool ObstructedBy(MyEntity entity, MyCubeBlock ignoreBlock, ref TestInput input, out GridTestResult result)
{
//Logger.DebugLog("checking: " + entity.getBestName() + ", offset: " + offset + ", rejection vector: " + rejectionVector + ", rejection distance: " + rejectionDistance);
#if DEBUG
if (!input.Direction.IsValid() || Math.Abs(1f - input.Direction.LengthSquared()) > 0.01f)
{
throw new Exception("rejection vector is invalid. entity: " + entity.nameWithId() + ", input: " + input);
}
#endif
result = GridTestResult.Default;
result.Distance = input.Length;
MyCubeGrid grid = entity as MyCubeGrid;
if (grid != null)
{
// check for dangerous tools on grid
CubeGridCache cache = CubeGridCache.GetFor(grid);
if (cache == null)
{
return(false);
}
Profiler.StartProfileBlock("Checking Tools");
foreach (MyShipDrill drill in cache.BlocksOfType(typeof(MyObjectBuilder_Drill)))
{
if (drill.IsShooting)
{
if (SphereTest(drill, ref input, ref result))
{
Profiler.EndProfileBlock();
return(true);
}
}
}
foreach (MyShipGrinder grinder in cache.BlocksOfType(typeof(MyObjectBuilder_ShipGrinder)))
{
if (grinder.IsShooting)
{
if (SphereTest(grinder, ref input, ref result))
{
Profiler.EndProfileBlock();
return(true);
}
}
}
Profiler.EndProfileBlock();
if (ExtensionsRelations.canConsiderFriendly(Controller.CubeBlock, grid) && EndangerGrid(grid, ref input, ref result))
{
Logger.DebugLog("Movement would endanger: " + grid.getBestName());
return(true);
}
Profiler.StartProfileBlock("RejectionIntersects");
if (RejectionIntersects(grid, ignoreBlock, ref input, ref result))
{
Profiler.EndProfileBlock();
return(true);
}
Profiler.EndProfileBlock();
}
else
{
return(SphereTest(entity, ref input, ref result));
}
return(false);
}
/// <summary>
/// Updates resource.
/// </summary>
public override void UpdateBeforeSimulation()
{
try
{
VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("MyMissile.UpdateBeforeSimulation");
if (m_isExploded)
{
Vector3D explosionPoint;
if (m_collisionPoint.HasValue)
{
explosionPoint = PlaceDecal();
}
else
{
// Can have no collision point when exploding from cascade explosions
explosionPoint = PositionComp.GetPosition();
}
if (Sandbox.Game.Multiplayer.Sync.IsServer)
{
// Create explosion
float radius = m_missileAmmoDefinition.MissileExplosionRadius;
BoundingSphereD explosionSphere = new BoundingSphereD(explosionPoint, radius);
MyEntity ownerEntity = null;
var ownerId = Sync.Players.TryGetIdentity(m_owner);
if (ownerId != null)
{
ownerEntity = ownerId.Character;
}
//MyEntities.TryGetEntityById(m_owner, out ownerEntity);
// Call main explosion starter
MyExplosionInfo info = new MyExplosionInfo()
{
PlayerDamage = 0,
//Damage = m_ammoProperties.Damage,
Damage = MyFakes.ENABLE_VOLUMETRIC_EXPLOSION ? m_missileAmmoDefinition.MissileExplosionDamage : 200,
ExplosionType = m_explosionType,
ExplosionSphere = explosionSphere,
LifespanMiliseconds = MyExplosionsConstants.EXPLOSION_LIFESPAN,
CascadeLevel = CascadedExplosionLevel,
HitEntity = m_collidedEntity,
ParticleScale = 1.0f,
OwnerEntity = ownerEntity,
Direction = WorldMatrix.Forward,
VoxelExplosionCenter = explosionSphere.Center + radius * WorldMatrix.Forward * 0.25f,
ExplosionFlags = MyExplosionFlags.AFFECT_VOXELS | MyExplosionFlags.APPLY_FORCE_AND_DAMAGE | MyExplosionFlags.CREATE_DEBRIS | MyExplosionFlags.CREATE_DECALS | MyExplosionFlags.CREATE_SHRAPNELS | MyExplosionFlags.APPLY_DEFORMATION,
VoxelCutoutScale = 0.3f,
PlaySound = true,
ApplyForceAndDamage = true
};
if (!MarkedToDestroy)
{
info.ExplosionFlags |= MyExplosionFlags.CREATE_PARTICLE_EFFECT;
}
MyExplosions.AddExplosion(ref info);
if (m_collidedEntity != null && !(m_collidedEntity is MyAmmoBase))
{
if (!m_collidedEntity.Physics.IsStatic)
{
m_collidedEntity.Physics.AddForce(MyPhysicsForceType.APPLY_WORLD_IMPULSE_AND_WORLD_ANGULAR_IMPULSE,
100 * Physics.LinearVelocity, m_collisionPoint, null);
}
}
}
Close();
return;
}
base.UpdateBeforeSimulation();
if (m_missileAmmoDefinition.MissileSkipAcceleration)
{
Physics.LinearVelocity = WorldMatrix.Forward * m_missileAmmoDefinition.DesiredSpeed * 0.7f;
}
else
{
Physics.LinearVelocity += PositionComp.WorldMatrix.Forward * m_missileAmmoDefinition.MissileAcceleration * VRage.Game.MyEngineConstants.UPDATE_STEP_SIZE_IN_SECONDS;
}
if (m_smokeEffect == null)
{
// if (MyCamera.GetDistanceWithFOV(GetPosition()) < 150)
{
if (MyParticlesManager.TryCreateParticleEffect((int)MyParticleEffectsIDEnum.Smoke_Missile, out m_smokeEffect))
{
m_smokeEffect.UserScale = 0.3f;
var matrix = PositionComp.WorldMatrix;
matrix.Translation -= matrix.Forward * m_smokeEffectOffsetMultiplier;
m_smokeEffect.WorldMatrix = matrix;
//m_smokeEffect.WorldMatrix = PositionComp.WorldMatrix;
m_smokeEffect.CalculateDeltaMatrix = true;
}
}
}
Physics.AngularVelocity = Vector3.Zero;
if ((Vector3.Distance(PositionComp.GetPosition(), m_origin) >= m_maxTrajectory))
{
Explode();
return;
}
}
finally
{
VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();
}
}
protected override MyDefinitionId FuelType(MyEntity thrustEntity)
{
return(Jetpack.FuelDefinition != null ? Jetpack.FuelDefinition.Id : MyResourceDistributorComponent.ElectricityId);
}
internal bool SelectTarget(bool manualSelect = true)
{
var s = _session;
var ai = s.TrackingAi;
if (s.Tick - MasterUpdateTick > 300 || MasterUpdateTick < 300 && _masterTargets.Count == 0)
{
BuildMasterCollections(ai);
}
if (!_cachedPointerPos)
{
InitPointerOffset(0.05);
}
if (!_cachedTargetPos)
{
InitTargetOffset();
}
var cockPit = s.ActiveCockPit;
Vector3D end;
if (!s.UiInput.FirstPersonView)
{
var offetPosition = Vector3D.Transform(PointerOffset, s.CameraMatrix);
AimPosition = offetPosition;
AimDirection = Vector3D.Normalize(AimPosition - s.CameraPos);
end = offetPosition + (AimDirection * ai.MaxTargetingRange);
}
else
{
if (!_session.UiInput.AltPressed)
{
AimDirection = cockPit.PositionComp.WorldMatrixRef.Forward;
AimPosition = cockPit.PositionComp.WorldAABB.Center;
end = AimPosition + (AimDirection * s.TrackingAi.MaxTargetingRange);
}
else
{
var offetPosition = Vector3D.Transform(PointerOffset, s.CameraMatrix);
AimPosition = offetPosition;
AimDirection = Vector3D.Normalize(AimPosition - s.CameraPos);
end = offetPosition + (AimDirection * ai.MaxTargetingRange);
}
}
var foundTarget = false;
var rayOnlyHitSelf = false;
var rayHitSelf = false;
MyEntity closestEnt = null;
_session.Physics.CastRay(AimPosition, end, _hitInfo);
for (int i = 0; i < _hitInfo.Count; i++)
{
var hit = _hitInfo[i];
closestEnt = hit.HitEntity.GetTopMostParent() as MyEntity;
var hitGrid = closestEnt as MyCubeGrid;
if (hitGrid != null && hitGrid.IsSameConstructAs(ai.MyGrid))
{
rayHitSelf = true;
rayOnlyHitSelf = true;
continue;
}
if (rayOnlyHitSelf)
{
rayOnlyHitSelf = false;
}
if (manualSelect)
{
if (hitGrid == null || !_masterTargets.ContainsKey(hitGrid))
{
continue;
}
s.SetTarget(hitGrid, ai, _masterTargets);
return(true);
}
foundTarget = true;
ai.Session.PlayerDummyTargets[ai.Session.PlayerId].Update(hit.Position, ai, closestEnt);
break;
}
if (rayHitSelf)
{
ReticleOnSelfTick = s.Tick;
ReticleAgeOnSelf++;
if (rayOnlyHitSelf)
{
ai.Session.PlayerDummyTargets[ai.Session.PlayerId].Update(end, ai);
}
}
else
{
ReticleAgeOnSelf = 0;
}
Vector3D hitPos;
bool foundOther = false;
if (!foundTarget && RayCheckTargets(AimPosition, AimDirection, out closestEnt, out hitPos, out foundOther, !manualSelect))
{
foundTarget = true;
if (manualSelect)
{
s.SetTarget(closestEnt, ai, _masterTargets);
return(true);
}
ai.Session.PlayerDummyTargets[ai.Session.PlayerId].Update(hitPos, ai, closestEnt);
}
if (!manualSelect)
{
var activeColor = closestEnt != null && !_masterTargets.ContainsKey(closestEnt) || foundOther ? Color.DeepSkyBlue : Color.Red;
_reticleColor = closestEnt != null && !(closestEnt is MyVoxelBase) ? activeColor : Color.White;
if (!foundTarget)
{
ai.Session.PlayerDummyTargets[ai.Session.PlayerId].Update(end, ai);
}
}
return(foundTarget || foundOther);
}
protected override float CalculateConsumptionMultiplier(MyEntity thrustEntity, float naturalGravityStrength)
{
return(1f + Jetpack.ConsumptionFactorPerG * (naturalGravityStrength / MyGravityProviderSystem.G));
}
/// <summary>
/// Override to discard query results of your choice.
/// </summary>
/// <param name="entity"></param>
/// <returns>True for valid entities.</returns>
protected virtual bool QueryEvaluator(MyEntity entity)
{
return(true);
}
protected override float ForceMagnitude(MyEntity thrustEntity, float planetaryInfluence, bool inAtmosphere)
{
return(Jetpack.ForceMagnitude * CalculateForceMultiplier(thrustEntity, planetaryInfluence, inAtmosphere));
}
public static void TakeMaterialsFromBuilder(List <MyObjectBuilder_CubeGrid> blocksToBuild, MyEntity builder)
{
Debug.Assert(blocksToBuild.Count == 1);
if (blocksToBuild.Count == 0)
{
return;
}
// Search for multiblock definition.
var firstBlock = blocksToBuild[0].CubeBlocks.FirstOrDefault();
Debug.Assert(firstBlock != null);
if (firstBlock == null)
{
return;
}
MyDefinitionId multiBlockDefId;
var compound = firstBlock as MyObjectBuilder_CompoundCubeBlock;
if (compound != null)
{
Debug.Assert(compound.Blocks != null && compound.Blocks.Length > 0 && compound.Blocks[0].MultiBlockDefinition != null);
if (compound.Blocks == null || compound.Blocks.Length == 0 || compound.Blocks[0].MultiBlockDefinition == null)
{
return;
}
multiBlockDefId = compound.Blocks[0].MultiBlockDefinition.Value;
}
else
{
Debug.Assert(firstBlock.MultiBlockDefinition != null);
if (firstBlock.MultiBlockDefinition == null)
{
return;
}
multiBlockDefId = firstBlock.MultiBlockDefinition.Value;
}
MyMultiBlockDefinition multiBlockDefinition = MyDefinitionManager.Static.TryGetMultiBlockDefinition(multiBlockDefId);
Debug.Assert(multiBlockDefinition != null);
if (multiBlockDefinition == null)
{
return;
}
MyCubeBuilder.BuildComponent.GetMultiBlockPlacementMaterials(multiBlockDefinition);
MyCubeBuilder.BuildComponent.AfterSuccessfulBuild(builder, instantBuild: false);
}
public override void Init(MyEntity holder, MyHandItem item, MyHandItemBehaviorDefinition definition)
{
base.Init(holder, item, definition);
_definition = (EquiMaterialHereBehaviorDefinition)definition;
}
public MySyncEntity(MyEntity entity)
{
Entity = entity;
}
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);
}
public static void LoadInventoryConfig(MyEntity toolEntity, MyAssetModifierComponent skinComponent)
{
if (toolEntity == null)
{
throw new ArgumentNullException("toolEntity");
}
if (skinComponent == null)
{
throw new ArgumentNullException("skinComponent");
}
if (MyGameService.IsActive)
{
MyObjectBuilder_SkinInventory inventory;
string path = Path.Combine(MyFileSystem.SavesPath, activeInventoryFile);
switch (inventory.Tools)
{
case ((!MyFileSystem.FileExists(path) || !MyObjectBuilderSerializer.DeserializeXML <MyObjectBuilder_SkinInventory>(path, out inventory)) || ((null) || (null))):
break;
default:
{
IMyHandheldGunObject <MyDeviceBase> obj2 = toolEntity as IMyHandheldGunObject <MyDeviceBase>;
MyPhysicalItemDefinition physicalItemDefinition = obj2.PhysicalItemDefinition;
MyGameInventoryItemSlot none = MyGameInventoryItemSlot.None;
if (obj2 is MyHandDrill)
{
none = MyGameInventoryItemSlot.Drill;
}
else if (obj2 is MyAutomaticRifleGun)
{
none = MyGameInventoryItemSlot.Rifle;
}
else if (obj2 is MyWelder)
{
none = MyGameInventoryItemSlot.Welder;
}
else if (obj2 is MyAngleGrinder)
{
none = MyGameInventoryItemSlot.Grinder;
}
if (none != MyGameInventoryItemSlot.None)
{
List <MyGameInventoryItem> items = new List <MyGameInventoryItem>();
using (List <ulong> .Enumerator enumerator = inventory.Tools.GetEnumerator())
{
while (enumerator.MoveNext())
{
MyGameInventoryItem item = MyGameService.InventoryItems.FirstOrDefault <MyGameInventoryItem>(delegate(MyGameInventoryItem i) {
ulong itemId;
return(i.ID == itemId);
});
if ((item != null) && ((physicalItemDefinition != null) && ((physicalItemDefinition == null) || (item.ItemDefinition.ItemSlot == none))))
{
item.IsInUse = true;
items.Add(item);
}
}
}
MyGameService.GetItemsCheckData(items, checkDataResult => skinComponent.TryAddAssetModifier(checkDataResult));
}
break;
}
}
}
}