public override void Init(MyComponentDefinitionBase definition)
{
base.Init(definition);
m_definition = definition as MyUseObjectsComponentDefinition;
Debug.Assert(m_definition != null);
}
private static double GetInventoryVolumeInternal(MyDefinitionId id)
{
MyContainerDefinition container;
if (MyComponentContainerExtension.TryGetContainerDefinition(id.TypeId, id.SubtypeId, out container) && container.DefaultComponents != null)
{
foreach (var component in container.DefaultComponents)
{
MyComponentDefinitionBase componentDefinition = null;
if (!MyComponentContainerExtension.TryGetComponentDefinition(component.BuilderType,
component.SubtypeId ?? id.SubtypeId, out componentDefinition))
{
continue;
}
var invDef = componentDefinition as MyInventoryComponentDefinition;
if (invDef != null)
{
return(invDef.Volume * 1000);
}
}
}
var def = MyDefinitionManager.Static.GetCubeBlockDefinition(id);
if (def is MyCargoContainerDefinition)
{
return((def as MyCargoContainerDefinition).InventorySize.Volume * 1000);
}
return(0.0);
}
public override void Init(MyComponentDefinitionBase definition)
{
base.Init(definition);
Definition = definition as MyModelComponentDefinition;
Debug.Assert(Definition != null, "Passed null definition or wrong type!");
}
public override void Init(MyComponentDefinitionBase definition)
{
base.Init(definition);
var craftDefinition = definition as MyCraftingComponentBasicDefinition;
System.Diagnostics.Debug.Assert(craftDefinition != null, "Trying to initialize crafting component from wrong definition type?");
if (craftDefinition != null)
{
ActionSound = new MySoundPair(craftDefinition.ActionSound);
m_craftingSpeedMultiplier = craftDefinition.CraftingSpeedMultiplier;
foreach (var blueprintClass in craftDefinition.AvailableBlueprintClasses)
{
var classDefinition = MyDefinitionManager.Static.GetBlueprintClass(blueprintClass);
System.Diagnostics.Debug.Assert(classDefinition != null, blueprintClass + " blueprint class definition was not found.");
if (classDefinition != null)
{
m_blueprintClasses.Add(classDefinition);
}
}
}
}
public override void Init(MyComponentDefinitionBase definition)
{
base.Init(definition);
var inventorySpawnDef = definition as MyEntityInventorySpawnComponent_Definition;
m_containerDefinition = inventorySpawnDef.ContainerDefinition;
}
public override void Init(MyComponentDefinitionBase definition)
{
base.Init(definition);
logger = new Logger("Player", "Player");
Entity.NeedsUpdate |= VRage.ModAPI.MyEntityUpdateEnum.EACH_100TH_FRAME;
}
public override void Init(MyComponentDefinitionBase definition)
{
base.Init(definition);
MyEntityStatComponentDefinition entityStatDefinition = definition as MyEntityStatComponentDefinition;
Debug.Assert(entityStatDefinition != null);
if (entityStatDefinition == null || !entityStatDefinition.Enabled || MySession.Static == null ||
(!entityStatDefinition.AvailableInSurvival && MySession.Static.SurvivalMode))
{
if (Sync.IsServer) // Only init scripts on server
{
m_statActionsRequested = true;
}
return;
}
foreach (var statId in entityStatDefinition.Stats)
{
MyEntityStatDefinition statDefinition = null;
if (!MyDefinitionManager.Static.TryGetDefinition(statId, out statDefinition))
{
continue;
}
if (!statDefinition.Enabled ||
(!statDefinition.EnabledInCreative && MySession.Static.CreativeMode) ||
(!statDefinition.AvailableInSurvival && MySession.Static.SurvivalMode))
{
continue;
}
var nameHash = MyStringHash.GetOrCompute(statDefinition.Name);
MyEntityStat existingStat = null;
if (m_stats.TryGetValue(nameHash, out existingStat) && existingStat.StatDefinition.Id.SubtypeId == statDefinition.Id.SubtypeId)
{
continue;
}
var builder = new MyObjectBuilder_EntityStat();
builder.SubtypeName = statId.SubtypeName;
builder.MaxValue = 1.0f;
builder.Value = statDefinition.DefaultValue / statDefinition.MaxValue;
AddStat(nameHash, builder);
}
if (Sync.IsServer) // Only init scripts on server
{
Debug.Assert(m_scripts.Count == 0);
foreach (var scriptName in entityStatDefinition.Scripts)
{
InitScript(scriptName);
}
m_statActionsRequested = true;
}
}
public override void Init(MyComponentDefinitionBase definition)
{
base.Init(definition);
MyCraftingComponentInteractiveDefinition definition2 = definition as MyCraftingComponentInteractiveDefinition;
if (definition2 != null)
{
this.ActionSound = new MySoundPair(definition2.ActionSound, true);
base.m_craftingSpeedMultiplier = definition2.CraftingSpeedMultiplier;
foreach (string str in definition2.AvailableBlueprintClasses)
{
MyBlueprintClassDefinition blueprintClass = MyDefinitionManager.Static.GetBlueprintClass(str);
base.m_blueprintClasses.Add(blueprintClass);
}
}
}
public override void Init(MyComponentDefinitionBase definition)
{
base.Init(definition);
MyTimerComponentDefinition definition2 = definition as MyTimerComponentDefinition;
if (definition2 != null)
{
this.TimerEnabled = definition2.TimeToRemoveMin > 0f;
this.m_setTimeMin = definition2.TimeToRemoveMin;
this.TimeToEvent = this.m_setTimeMin;
this.RemoveEntityOnTimer = definition2.TimeToRemoveMin > 0f;
if (this.RemoveEntityOnTimer && Sync.IsServer)
{
this.EventToTrigger = GetRemoveEntityOnTimerEvent();
}
}
}
public override void Init(MyComponentDefinitionBase definition)
{
base.Init(definition);
MyEntityStatComponentDefinition definition2 = definition as MyEntityStatComponentDefinition;
if (((definition2 == null) || (!definition2.Enabled || (MySession.Static == null))) || (!definition2.AvailableInSurvival && MySession.Static.SurvivalMode))
{
if (Sync.IsServer)
{
this.m_statActionsRequested = true;
}
}
else
{
foreach (MyDefinitionId id in definition2.Stats)
{
MyEntityStatDefinition definition3 = null;
if (MyDefinitionManager.Static.TryGetDefinition <MyEntityStatDefinition>(id, out definition3) && (definition3.Enabled && ((definition3.EnabledInCreative || !MySession.Static.CreativeMode) && (definition3.AvailableInSurvival || !MySession.Static.SurvivalMode))))
{
MyStringHash orCompute = MyStringHash.GetOrCompute(definition3.Name);
MyEntityStat stat = null;
if (!this.m_stats.TryGetValue(orCompute, out stat) || (stat.StatDefinition.Id.SubtypeId != definition3.Id.SubtypeId))
{
MyObjectBuilder_EntityStat objectBuilder = new MyObjectBuilder_EntityStat {
SubtypeName = id.SubtypeName,
MaxValue = 1f,
Value = definition3.DefaultValue / definition3.MaxValue
};
this.AddStat(orCompute, objectBuilder, false);
}
}
}
if (Sync.IsServer)
{
foreach (string str in definition2.Scripts)
{
this.InitScript(str);
}
this.m_statActionsRequested = true;
}
}
}
public override void Init(MyComponentDefinitionBase definition)
{
base.Init(definition);
var timerComponentDefinition = definition as MyTimerComponentDefinition;
Debug.Assert(timerComponentDefinition != null);
if (timerComponentDefinition != null)
{
TimerEnabled = timerComponentDefinition.TimeToRemoveMin > 0;
m_setTimeMin = timerComponentDefinition.TimeToRemoveMin;
TimeToEvent = m_setTimeMin;
RemoveEntityOnTimer = timerComponentDefinition.TimeToRemoveMin > 0;
if (RemoveEntityOnTimer)
{
EventToTrigger = GetRemoveEntityOnTimerEvent();
}
}
}
public override void Init(MyComponentDefinitionBase definition)
{
base.Init(definition);
Definition = definition as MyPhysicsComponentDefinitionBase;
Debug.Assert(Definition != null);
if (Definition != null)
{
Flags = Definition.RigidBodyFlags;
if (Definition.LinearDamping != null)
{
LinearDamping = Definition.LinearDamping.Value;
}
if (Definition.AngularDamping != null)
{
AngularDamping = Definition.AngularDamping.Value;
}
}
}
public override void Init(MyComponentDefinitionBase definition)
{
base.Init(definition);
MyCraftingComponentBlockDefinition definition2 = definition as MyCraftingComponentBlockDefinition;
if (definition2 != null)
{
base.m_craftingSpeedMultiplier = definition2.CraftingSpeedMultiplier;
foreach (string str in definition2.AvailableBlueprintClasses)
{
MyBlueprintClassDefinition blueprintClass = MyDefinitionManager.Static.GetBlueprintClass(str);
if (blueprintClass != null)
{
base.m_blueprintClasses.Add(blueprintClass);
}
}
foreach (MyDefinitionId id in definition2.AcceptedOperatingItems)
{
this.m_acceptedOperatingItems.Add(id);
}
}
}
public override void Init(MyComponentDefinitionBase definition)
{
base.Init(definition);
Definition = definition as MyPhysicsComponentDefinitionBase;
Debug.Assert(Definition != null);
if (Definition != null)
{
Flags = Definition.RigidBodyFlags;
if (Definition.LinearDamping != null)
LinearDamping = Definition.LinearDamping.Value;
if (Definition.AngularDamping != null)
AngularDamping = Definition.AngularDamping.Value;
}
}
public override void Init(MyComponentDefinitionBase definition)
{
base.Init(definition);
this.m_definition = definition as MyUseObjectsComponentDefinition;
}
private static MyEntity SpawnBagAround(MyEntity itemOwner, MyContainerDefinition bagDefinition, int sideCheckCount = 3, int frontCheckCount = 2, int upCheckCount = 5, float stepSize = 1f)
{
MatrixD xd;
Vector3D?nullable = null;
MyModel modelOnlyData = null;
foreach (MyContainerDefinition.DefaultComponent component in bagDefinition.DefaultComponents)
{
if (typeof(MyObjectBuilder_ModelComponent).IsAssignableFrom((System.Type)component.BuilderType))
{
MyComponentDefinitionBase componentDefinition = null;
MyStringHash subtypeId = bagDefinition.Id.SubtypeId;
if (component.SubtypeId != null)
{
subtypeId = component.SubtypeId.Value;
}
if (MyComponentContainerExtension.TryGetComponentDefinition(component.BuilderType, subtypeId, out componentDefinition))
{
MyModelComponentDefinition definition = componentDefinition as MyModelComponentDefinition;
if (definition != null)
{
modelOnlyData = MyModels.GetModelOnlyData(definition.Model);
}
}
break;
}
}
if (modelOnlyData == null)
{
return(null);
}
float radius = modelOnlyData.BoundingBox.HalfExtents.Max();
HkShape shape = (HkShape) new HkSphereShape(radius);
try
{
Vector3 vector3;
Vector3 vector5;
Vector3 vector6;
int num4;
Vector3D vectord3;
int num5;
Vector3D translation = itemOwner.PositionComp.WorldMatrix.Translation;
float num2 = radius * stepSize;
Vector3 up = -MyGravityProviderSystem.CalculateNaturalGravityInPoint(itemOwner.PositionComp.WorldMatrix.Translation);
if (up == Vector3.Zero)
{
up = Vector3.Up;
}
else
{
up.Normalize();
}
up.CalculatePerpendicularVector(out vector3);
Vector3 vector4 = Vector3.Cross(vector3, up);
vector4.Normalize();
Quaternion identity = Quaternion.Identity;
Vector3[] vectorArray = new Vector3[] { vector3, vector4, -vector3, -vector4 };
Vector3[] vectorArray2 = new Vector3[] { vector4, -vector3, -vector4, vector3 };
int index = 0;
goto TR_0026;
TR_000D:
if (nullable == null)
{
MyOrientedBoundingBoxD xd3 = new MyOrientedBoundingBoxD(itemOwner.PositionComp.LocalAABB, itemOwner.PositionComp.WorldMatrix);
Vector3D[] corners = new Vector3D[8];
xd3.GetCorners(corners, 0);
float minValue = float.MinValue;
Vector3D[] vectordArray2 = corners;
int num8 = 0;
while (true)
{
if (num8 >= vectordArray2.Length)
{
nullable = new Vector3D?(itemOwner.PositionComp.WorldMatrix.Translation);
if (minValue > 0f)
{
nullable = new Vector3D?(xd3.Center + (minValue * up));
}
break;
}
float num9 = Vector3.Dot((Vector3)(vectordArray2[num8] - xd3.Center), up);
minValue = Math.Max(minValue, num9);
num8++;
}
}
goto TR_0003;
TR_000E:
index++;
goto TR_0026;
TR_000F:
num4++;
goto TR_0022;
TR_0010:
num5++;
TR_001E:
while (true)
{
if (num5 >= sideCheckCount)
{
goto TR_000F;
}
else if (nullable == null)
{
for (int i = 0; (i < upCheckCount) && (nullable == null); i++)
{
Vector3D pos = (vectord3 + ((num5 * num2) * vector6)) + ((i * num2) * up);
if (MyEntities.IsInsideWorld(pos) && !MyEntities.IsShapePenetrating(shape, ref pos, ref identity, 15))
{
BoundingSphereD sphere = new BoundingSphereD(pos, (double)radius);
if (MySession.Static.VoxelMaps.GetOverlappingWithSphere(ref sphere) == null)
{
nullable = new Vector3D?(pos);
break;
}
}
}
}
else
{
goto TR_000F;
}
break;
}
goto TR_0010;
TR_0022:
while (true)
{
if (num4 >= frontCheckCount)
{
goto TR_000E;
}
else if (nullable == null)
{
vectord3 = (((translation + (0.25f * vector5)) + (radius * vector5)) + ((num4 * num2) * vector5)) - (((0.5f * (sideCheckCount - 1)) * num2) * vector6);
num5 = 0;
}
else
{
goto TR_000E;
}
break;
}
goto TR_001E;
TR_0026:
while (true)
{
if (index >= vectorArray.Length)
{
goto TR_000D;
}
else if (nullable == null)
{
vector5 = vectorArray[index];
vector6 = vectorArray2[index];
num4 = 0;
}
else
{
goto TR_000D;
}
break;
}
goto TR_0022;
}
finally
{
shape.RemoveReference();
}
TR_0003:
xd = itemOwner.PositionComp.WorldMatrix;
xd.Translation = nullable.Value;
MyEntity entity = MyEntities.CreateFromComponentContainerDefinitionAndAdd(bagDefinition.Id, false, true);
if (entity == null)
{
return(null);
}
entity.PositionComp.SetWorldMatrix(xd, null, false, true, true, false, false, false);
entity.Physics.LinearVelocity = Vector3.Zero;
entity.Physics.AngularVelocity = Vector3.Zero;
return(entity);
}
/// <summary>
/// Tries to retrieve entity definition of the entity owning this container, check if the definition has some DefaultComponents,
/// tries to retrieve these components definitions, create these components instances and add them
///
/// TODO: This should be ideally a behavior of the MyEntityComponentContainer when it is initialized (deserialized).. or by the factory, for now, this is an extension method
/// </summary>
public static void InitComponents(this MyComponentContainer container, MyObjectBuilderType type, MyStringHash subtypeName, MyObjectBuilder_ComponentContainer builder)
{
if (MyDefinitionManager.Static != null)
{
MyContainerDefinition definition = null;
bool IsFirstInit = builder == null;
if (TryGetContainerDefinition(type, subtypeName, out definition))
{
container.Init(definition);
if (definition.DefaultComponents != null)
{
foreach (var component in definition.DefaultComponents)
{
MyComponentDefinitionBase componentDefinition = null;
MyObjectBuilder_ComponentBase componentBuilder = FindComponentBuilder(component, builder);
bool IsComponentSerialized = componentBuilder != null;
Type componentType = null;
MyComponentBase componentInstance = null;
var componentSubtype = subtypeName;
if (component.SubtypeId.HasValue)
{
componentSubtype = component.SubtypeId.Value;
}
// Create component instance
if (TryGetComponentDefinition(component.BuilderType, componentSubtype, out componentDefinition))
{
componentInstance = MyComponentFactory.CreateInstanceByTypeId(componentDefinition.Id.TypeId);
componentInstance.Init(componentDefinition);
}
else if (component.IsValid())
{
if (!component.BuilderType.IsNull)
{
componentInstance = MyComponentFactory.CreateInstanceByTypeId(component.BuilderType);
}
else
{
componentInstance = MyComponentFactory.CreateInstanceByType(component.InstanceType);
}
}
// Check component type from attributes.
if (componentInstance != null)
{
var componentTypeFromAttr = MyComponentTypeFactory.GetComponentType(componentInstance.GetType());
if (componentTypeFromAttr != null)
{
componentType = componentTypeFromAttr;
}
else
{
if (componentDefinition != null)
{
System.Diagnostics.Debug.Fail("Unknown component type - component type attribute not specified for component class: " + componentInstance.GetType());
}
}
}
//TODO: this should be avoided! Component type MUST be set via MyComponentType attribute.
if (componentType == null && componentInstance != null)
{
componentType = componentInstance.GetType();
}
// If everything passed, go on..
if (componentInstance != null && componentType != null)
{
bool componentShouldBeAdded = IsFirstInit || IsComponentSerialized || component.ForceCreate;
if (componentShouldBeAdded)
{
if (componentBuilder != null)
{
componentInstance.Deserialize(componentBuilder);
}
// Add only fully initialized component..
container.Add(componentType, componentInstance);
}
}
else
{
System.Diagnostics.Debug.Fail("Component instance wasn't created or it's base type couldn't been determined!");
}
}
}
else
{
System.Diagnostics.Debug.Fail("Got definition for container, but DefaultComponents is null!");
}
}
// This may rewrite already once deserialized data, but will also add missing components in definition
container.Deserialize(builder);
}
else
{
System.Diagnostics.Debug.Fail("Trying to init enabled components on entity, but definition manager is null");
}
}
public static bool TryGetComponentDefinition(MyObjectBuilderType type, MyStringHash subtypeName, out MyComponentDefinitionBase componentDefinition)
{
componentDefinition = null;
if (MyDefinitionManager.Static != null)
{
MyDefinitionId subtypeDefinition = new MyDefinitionId(type, subtypeName);
if (MyDefinitionManager.Static.TryGetEntityComponentDefinition(subtypeDefinition, out componentDefinition))
{
return(true);
}
// Fallback to EntityBase type
if (subtypeName != MyStringHash.NullOrEmpty)
{
MyDefinitionId subtypeDefinition_Fallback = new MyDefinitionId(typeof(MyObjectBuilder_EntityBase), subtypeName);
if (MyDefinitionManager.Static.TryGetEntityComponentDefinition(subtypeDefinition_Fallback, out componentDefinition))
{
return(true);
}
}
MyDefinitionId defaultDefinition = new MyDefinitionId(type);
if (MyDefinitionManager.Static.TryGetEntityComponentDefinition(defaultDefinition, out componentDefinition))
{
return(true);
}
}
return(false);
}
public static bool TryGetComponentDefinition(MyObjectBuilderType type, MyStringHash subtypeName, out MyComponentDefinitionBase componentDefinition)
{
componentDefinition = null;
if (MyDefinitionManager.Static == null)
{
return(false);
}
MyDefinitionId componentId = new MyDefinitionId(type, subtypeName);
if (MyDefinitionManager.Static.TryGetEntityComponentDefinition(componentId, out componentDefinition))
{
return(true);
}
if (subtypeName != MyStringHash.NullOrEmpty)
{
MyDefinitionId id3 = new MyDefinitionId(typeof(MyObjectBuilder_EntityBase), subtypeName);
if (MyDefinitionManager.Static.TryGetEntityComponentDefinition(id3, out componentDefinition))
{
return(true);
}
}
MyDefinitionId id2 = new MyDefinitionId(type);
return(MyDefinitionManager.Static.TryGetEntityComponentDefinition(id2, out componentDefinition));
}
public static void InitComponents(this MyComponentContainer container, MyObjectBuilderType type, MyStringHash subtypeName, MyObjectBuilder_ComponentContainer builder)
{
if (MyDefinitionManager.Static != null)
{
MyContainerDefinition definition = null;
bool flag = ReferenceEquals(builder, null);
if (TryGetContainerDefinition(type, subtypeName, out definition))
{
container.Init(definition);
if (definition.DefaultComponents != null)
{
foreach (MyContainerDefinition.DefaultComponent component in definition.DefaultComponents)
{
MyComponentDefinitionBase componentDefinition = null;
MyObjectBuilder_ComponentBase base3 = FindComponentBuilder(component, builder);
bool flag2 = base3 != null;
Type type2 = null;
MyComponentBase base4 = null;
MyStringHash hash = subtypeName;
if (component.SubtypeId != null)
{
hash = component.SubtypeId.Value;
}
if (TryGetComponentDefinition(component.BuilderType, hash, out componentDefinition))
{
base4 = MyComponentFactory.CreateInstanceByTypeId(componentDefinition.Id.TypeId);
base4.Init(componentDefinition);
}
else if (component.IsValid())
{
base4 = component.BuilderType.IsNull ? MyComponentFactory.CreateInstanceByType(component.InstanceType) : MyComponentFactory.CreateInstanceByTypeId(component.BuilderType);
}
if (base4 != null)
{
Type componentType = MyComponentTypeFactory.GetComponentType(base4.GetType());
if (componentType != null)
{
type2 = componentType;
}
else
{
MyComponentDefinitionBase base1 = componentDefinition;
}
}
if ((type2 == null) && (base4 != null))
{
type2 = base4.GetType();
}
if (((base4 != null) && (type2 != null)) && ((flag | flag2) || component.ForceCreate))
{
if (base3 != null)
{
base4.Deserialize(base3);
}
container.Add(type2, base4);
}
}
}
}
container.Deserialize(builder);
}
}
public virtual void Init(MyComponentDefinitionBase definition)
{
}
public override void Init(MyComponentDefinitionBase definition)
{
MyLog.Default.WriteLine($"SkunkWorks: {definition?.Id}");
base.Init(definition);
}
public sealed override void Init(MyComponentDefinitionBase definition)
{
base.Init(definition);
}
/// <summary>
/// Spawns bag around position given by "baseTransform", checks all 4 directions around - forwards (forward, right, backward, left) and on each such direction moves test sphere
/// in 3 directions forward (frontChecks), sides (perpendicular to forward direction - rights) and up. If spawn position is not found then position above "worldAabbTopPosition"
/// is selected.
/// </summary>
private static MyEntity SpawnBagAround(MyEntity itemOwner, MyContainerDefinition bagDefinition,
int sideCheckCount = 3, int frontCheckCount = 2, int upCheckCount = 5, float stepSize = 1f)
{
Debug.Assert(Sandbox.Game.Multiplayer.Sync.IsServer);
Vector3D?finalPos = null;
// Model sphere
MyModel bagModel = null;
foreach (var componentDef in bagDefinition.DefaultComponents)
{
if (typeof(MyObjectBuilder_ModelComponent).IsAssignableFrom(componentDef.BuilderType))
{
MyComponentDefinitionBase componentDefinition = null;
var componentSubtype = bagDefinition.Id.SubtypeId;
if (componentDef.SubtypeId.HasValue)
{
componentSubtype = componentDef.SubtypeId.Value;
}
if (MyComponentContainerExtension.TryGetComponentDefinition(componentDef.BuilderType, componentSubtype, out componentDefinition))
{
var modelComponentDef = componentDefinition as MyModelComponentDefinition;
Debug.Assert(modelComponentDef != null);
if (modelComponentDef != null)
{
bagModel = MyModels.GetModelOnlyData(modelComponentDef.Model);
}
}
break;
}
}
Debug.Assert(bagModel != null);
if (bagModel == null)
{
return(null);
}
float bagBoxRadius = bagModel.BoundingBox.HalfExtents.Max();
HkShape sphere = new HkSphereShape(bagBoxRadius);
try
{
Vector3D basePos = itemOwner.PositionComp.WorldMatrix.Translation;
float step = bagBoxRadius * stepSize;
// Calculate right, up and forward vectors from gravity
Vector3 upDir = -MyGravityProviderSystem.CalculateNaturalGravityInPoint(itemOwner.PositionComp.WorldMatrix.Translation);
if (upDir == Vector3.Zero)
{
upDir = Vector3.Up;
}
else
{
upDir.Normalize();
}
Vector3 forwardDir;
upDir.CalculatePerpendicularVector(out forwardDir);
Vector3 rightDir = Vector3.Cross(forwardDir, upDir);
rightDir.Normalize();
Vector3D currentPos;
Quaternion rot = Quaternion.Identity;
Vector3[] forwards = new Vector3[]
{
forwardDir,
rightDir,
-forwardDir,
-rightDir
};
Vector3[] rights = new Vector3[]
{
rightDir,
-forwardDir,
-rightDir,
forwardDir
};
// All sides
for (int i = 0; i < forwards.Length && finalPos == null; ++i)
{
var forward = forwards[i];
var right = rights[i];
// Move forward
for (int frontMove = 0; frontMove < frontCheckCount && finalPos == null; ++frontMove)
{
Vector3D sidePosBase = basePos + 0.25f * forward + bagBoxRadius * forward + frontMove * step * forward - 0.5f * (sideCheckCount - 1) * step * right;
// Move perp to forward
for (int sideMove = 0; sideMove < sideCheckCount && finalPos == null; ++sideMove)
{
// Move up
for (int upMove = 0; upMove < upCheckCount && finalPos == null; ++upMove)
{
currentPos = sidePosBase + sideMove * step * right + upMove * step * upDir;
if (MyEntities.IsInsideWorld(currentPos) && !MyEntities.IsShapePenetrating(sphere, ref currentPos, ref rot))
{
BoundingSphereD boundingSphere = new BoundingSphereD(currentPos, bagBoxRadius);
MyVoxelBase overlappedVoxelmap = MySession.Static.VoxelMaps.GetOverlappingWithSphere(ref boundingSphere);
if (overlappedVoxelmap == null)
{
finalPos = currentPos;
break;
}
}
}
}
}
}
// If not found position then select position above aabb's top.
if (finalPos == null)
{
MyOrientedBoundingBoxD obb = new MyOrientedBoundingBoxD((BoundingBoxD)itemOwner.PositionComp.LocalAABB, itemOwner.PositionComp.WorldMatrix);
Vector3D[] corners = new Vector3D[8];
obb.GetCorners(corners, 0);
float dotUp = float.MinValue;
foreach (var corner in corners)
{
var localDot = Vector3.Dot(corner - obb.Center, upDir);
dotUp = Math.Max(dotUp, localDot);
}
finalPos = itemOwner.PositionComp.WorldMatrix.Translation;
Debug.Assert(dotUp > 0);
if (dotUp > 0)
{
finalPos = obb.Center + dotUp * upDir;
}
}
}
finally
{
sphere.RemoveReference();
}
Debug.Assert(finalPos != null);
MatrixD transform = itemOwner.PositionComp.WorldMatrix;
transform.Translation = finalPos.Value;
MyEntity bagEntity = MyEntities.CreateFromComponentContainerDefinitionAndAdd(bagDefinition.Id);
if (bagEntity == null)
{
return(null);
}
bagEntity.PositionComp.SetWorldMatrix(transform);
bagEntity.Physics.LinearVelocity = Vector3.Zero;
bagEntity.Physics.AngularVelocity = Vector3.Zero;
return(bagEntity);
}
