public static MyGuiControlGrid.Item CreateInventoryGridItem(MyInventoryItem item)
{
var definition = MyDefinitionManager.Static.GetPhysicalItemDefinition(item.Content);
var itemMass = definition.Mass * (double)item.Amount;
var itemVolume = definition.Volume * 1000 * (double)item.Amount;
var gridItem = new MyGuiControlGrid.Item(
icon: definition.Icon,
userData: item,
toolTip: new StringBuilder().AppendFormat(MyTexts.GetString(MySpaceTexts.ToolTipTerminalInventory_ItemInfo),
definition.DisplayNameText,
(itemMass < 0.01) ? "<0.01" : itemMass.ToString(MyInventoryConstants.GUI_DISPLAY_FORMAT, CultureInfo.InvariantCulture),
(itemVolume < 0.01) ? "<0.01" : itemVolume.ToString(MyInventoryConstants.GUI_DISPLAY_FORMAT, CultureInfo.InvariantCulture),
(item.Content.Flags == MyItemFlags.Damaged ? MyTexts.Get(MySpaceTexts.ItemDamagedDescription) : MyTexts.Get(MySpaceTexts.Blank))).ToString());
if (MyFakes.SHOW_INVENTORY_ITEM_IDS)
{
gridItem.ToolTip.AddToolTip(new StringBuilder().AppendFormat("ItemID: {0}", item.ItemId).ToString());
}
FormatItemAmount(item, m_textCache);
gridItem.AddText(m_textCache, MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_BOTTOM);
m_textCache.Clear();
if (definition.IconSymbol.HasValue)
{
gridItem.AddText(MyTexts.Get(definition.IconSymbol.Value), MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_TOP);
}
return(gridItem);
}
public override bool Add(MyInventoryItem item, NewItemParams parameters = NewItemParams.None)
{
if ((parameters & NewItemParams.AsNewStack) != 0)
{
_items.Add(item);
return(true);
}
var stackSize = item.GetDefinition().MaxStackAmount;
for (var i = 0; i < _items.Count; i++)
{
var other = _items[i];
if (!other.CanStack(item))
{
continue;
}
var add = Math.Min(item.Amount, stackSize - other.Amount);
_items[i] = other.Clone(other.Amount + add);
item = item.Clone(item.Amount - add);
if (item.Amount == 0)
{
break;
}
}
if (item.Amount > 0)
{
_items.Add(item);
}
return(true);
}
private static void PackMothership()
{
MyTrace.Send(TraceWindow.Saving, "Player packing mothership");
MyPrefabHangar hangar = MySession.Static.Player.Ship.GetNearMotherShipContainer();
if (hangar == null)
{ //We are traveling in solar map but madelyn is far away. Assume we are travelling with Madelyn by default
MyEntity madelynHangar;
MyEntities.TryGetEntityByName(MyMission.MyMissionLocation.MADELYN_HANGAR, out madelynHangar);
hangar = madelynHangar as MyPrefabHangar;
}
if (hangar != null)
{
// Move player start location dummy, so that next time player starts on same position
UpdateStartDummy(MyDummyPointFlags.PLAYER_START, MySession.PlayerShip.WorldMatrix);
// Move mothership start location dummy, so that next time mothership starts on same position
UpdateStartDummy(MyDummyPointFlags.MOTHERSHIP_START, hangar.Parent.WorldMatrix);
var container = hangar.Parent;
MyInventoryItem item = MyInventory.CreateInventoryItemFromObjectBuilder(container.GetObjectBuilder(true));
MySession.Static.Inventory.AddInventoryItem(item);
container.MarkForClose();
MyTrace.Send(TraceWindow.Saving, "Player mothership found and packed");
}
}
private bool Transfer(IMyInventory source, IMyInventory destination, string itemType, VRage.MyFixedPoint amount)
{
//Moves given amount of given type from source to destination
int ixSource;
List <MyInventoryItem> sourceItems = GetInventoryItems(source);
ixSource = IndexOfFirstTradeItem(source, itemType, false);
if (ixSource < 0)
{
Display(Info.MsgErrTransferNoItemsInSource, itemType, source.ToString());
return(false);
}
MyInventoryItem item = sourceItems[ixSource];
if (amount > item.Amount)
{
Display(Info.MsgErrTransferInsufficientItemsInSource, source.ToString(), item.Amount + "/" + amount.ToString() + " " + itemType);
return(false);
}
if (!source.TransferItemTo(destination, ixSource, null, true, amount))
{
Display(Info.MsgErrTransferFailed, amount.ToString() + " " + itemType, source.ToString() + " -> " + destination.ToString());
return(false);
}
return(true);
}
/// <summary>Returns the main type of the item, as an <see cref="ItemType"/></summary>
/// <param name="item">This</param>
/// <returns>The item type</returns>
public static ItemType GetItemType(this MyInventoryItem item)
{
ItemType res;
TYPES.TryGetValue(item.Type.TypeId, out res);
return(res);
}
public override bool Remove(MyInventoryItem item, int?amount = null)
{
for (var i = 0; i < _items.Count; i++)
{
if (_items[i].ItemId != item.ItemId)
{
continue;
}
if (amount == null)
{
_items.RemoveAtFast(i);
return(true);
}
if (amount.Value > _items[i].Amount)
{
return(false);
}
_items[i].Amount -= amount.Value;
return(true);
}
return(false);
}
private bool ThrowFloatingObjectsFunc()
{
var view = MySession.Static.CameraController.GetViewMatrix();
var inv = Matrix.Invert(view);
//MyInventoryItem item = new MyInventoryItem(100,
var oreBuilder = Sandbox.Common.ObjectBuilders.Serializer.MyObjectBuilderSerializer.CreateNewObject <MyObjectBuilder_Ore>("Stone");
var scrapBuilder = Sandbox.Common.ObjectBuilders.Serializer.MyObjectBuilderSerializer.CreateNewObject <MyObjectBuilder_Ingot>("Scrap");
for (int i = 1; i <= 25; i++)
{
var item = new MyInventoryItem((MyRandom.Instance.Next() % 200) + 1, oreBuilder);
var obj = MyFloatingObjects.Spawn(item, inv.Translation + inv.Forward * i * 1.0f, inv.Forward, inv.Up);
obj.Physics.LinearVelocity = inv.Forward * 50;
}
Vector3D scrapPos = inv.Translation;
scrapPos.X += 10;
for (int i = 1; i <= 25; i++)
{
var item = new MyInventoryItem((MyRandom.Instance.Next() % 200) + 1, scrapBuilder);
var obj = MyFloatingObjects.Spawn(item, scrapPos + inv.Forward * i * 1.0f, inv.Forward, inv.Up);
obj.Physics.LinearVelocity = inv.Forward * 50;
}
return(true);
}
private MyToolKit(MySmallShip smallShipOwner, MyPlayer playerOwner, MyInventoryItem toolInventoryItem, MyToolKitDelegates[] delegates)
{
m_smallShipOwner = smallShipOwner;
m_playerOwner = playerOwner;
m_toolInventoryItem = toolInventoryItem;
m_delegates = delegates;
}
protected override void OnDragDrop(object sender, EventArgs ea)
{
// Return if drop is done on some control
foreach (var control in m_editorControls)
{
if (control == m_addObjectTreeViewdragDrop)
{
continue;
}
if (control.Visible && control.ContainsMouse())
{
return;
}
}
MyObjectToBuild objectToBuild = m_addObjectTreeViewdragDrop.DraggedItem.Tag as MyObjectToBuild;
if (objectToBuild != null && IsDragAndDropObject(objectToBuild))
{
List <MyInventoryItem> prefabInventoryItems = GetInventoryItems(objectToBuild.ObjectBuilder);
if (prefabInventoryItems.Count > 0)
{
AddPrefab(objectToBuild.ObjectBuilder as MyMwcObjectBuilder_PrefabBase);
MyInventoryItem prefabInventoryItem = prefabInventoryItems[0];
MyEditor.Static.FoundationFactory.PrefabContainer.Inventory.RemoveInventoryItem(prefabInventoryItem, true);
}
}
}
public override bool TransferItemsFrom(MyInventoryBase sourceInventory, MyInventoryItem item, int amount)
{
if (sourceInventory == null || item == null || amount > item.Amount)
{
return(false);
}
if (amount == 0)
{
return(true);
}
var limitedItem = amount < item.Amount ? item.Clone(amount) : item;
if (!CanAddItems(item.DefinitionId, amount) && this != sourceInventory)
{
return(false);
}
if (this == sourceInventory)
{
return(sourceInventory.Remove(item, amount) && Add(limitedItem));
}
if (!Add(limitedItem))
{
return(false);
}
if (sourceInventory.Remove(item, amount))
{
return(true);
}
Remove(item, amount);
return(false);
}
public void CheckProductionNeed(ref List <ControlObject> controlObjectList, ref FinalContainer finalContainer)
{
IMyGridTerminalSystem myGridTerminalSystem = null;
IMyCargoContainer finalContainerUnico = null;
foreach (ControlObject controlObject in controlObjectList)
{
MyItemType item = new MyItemType(controlObject.getComponentIDValue(), "");
for (int i = 0; i < finalContainer.getContainerName().Count(); i++)
{
finalContainerUnico = (IMyCargoContainer)myGridTerminalSystem.GetBlockWithName(finalContainer.getContainerName()[i]);
if (finalContainerUnico != null)
{
MyInventoryItem myInventoryItem = (MyInventoryItem)finalContainerUnico.GetInventory().FindItem(item);
if (myInventoryItem != null)
{
controlObject.setComponentsAmountProduced((int)myInventoryItem.Amount);
controlObject.setComponentsAmountToProduce(controlObject.getComponetAmountKeepStorage() - controlObject.getComponentsAmountProduced());
}
else
{
controlObject.setComponentsAmountProduced(controlObject.getComponetAmountKeepStorage());
controlObject.setComponentsAmountToProduce(controlObject.getComponetAmountKeepStorage());
}
}
}
}
}
void MoveToContainer(
MyInventoryItem item,
IMyInventory currentInv,
int itemIndex,
List <CargoContainer> containers)
{
List <CargoContainer> candidateContainers = new List <CargoContainer>();
FindCargoSpace(item, currentInv, containers, candidateContainers);
foreach (CargoContainer container in candidateContainers)
{
IMyInventory targetInv = container.container.GetInventory();
float remainingItemVolume = ItemVolume(item);
float transferrableVolume = Math.Min(remainingItemVolume,
targetInv.MaxVolume.RawValue - targetInv.CurrentVolume.RawValue);
if (currentInv.TransferItemTo(
targetInv,
item,
ItemAmount(item.Type, transferrableVolume)
))
{
remainingItemVolume -= transferrableVolume;
if (remainingItemVolume == 0f)
{
break;
}
}
}
}
void OreAmountChanged(MyEntity entity, MyInventory inventory, MyInventoryItem item, float number)
{
if (MyScriptWrapper.IsPlayerShip(entity))
{
if (item.ObjectBuilderType == MyMwcObjectBuilderTypeEnum.Ore)
{
if (!MyScriptWrapper.IsMissionFinished(MyMissionID.RIFT_URANITE))
{
if (item.ObjectBuilderId == (int)MyMwcObjectBuilder_Ore_TypesEnum.URANITE)
{
float ammount = MyScriptWrapper.GetInventoryItemAmount(MyScriptWrapper.GetPlayerInventory(), MyMwcObjectBuilderTypeEnum.Ore, (int)MyMwcObjectBuilder_Ore_TypesEnum.URANITE);
if (ammount > 0.5f && m_miningquotes == 1)
{
MyScriptWrapper.PlayDialogue(MyDialogueEnum.RIFT_0700_MINING_COLOR);
m_miningquotes++;
}
else if (ammount > 1.0f && m_miningquotes == 2)
{
MyScriptWrapper.PlayDialogue(MyDialogueEnum.RIFT_0800_MINING_TUNE);
m_miningquotes++;
}
else if (ammount > 1.5f && m_miningquotes == 3)
{
MyScriptWrapper.PlayDialogue(MyDialogueEnum.RIFT_0900_MINING_TUNE_2);
m_miningquotes++;
}
}
}
}
}
}
/// <summary>
/// Goes through and stacks any objects we can
/// </summary>
/// <param name="logistics"></param>
private void Sort()
{
if (itemsToSort.Count == 0)
{
return;
}
logistics.output.Print("Sorting " + itemsToSort.Count + " items in " + name, true);
int moved = 0;
for (int i = 0; i < itemsToSort.Count; i++)
{
int index = itemsToSort[i] - moved;
MyInventoryItem item = items[index];
if (inventory.TransferItemTo(inventory, index, null, true))
{
moved++;
logistics.output.Print("--- '" + item.Type.SubtypeId + "' [" + index + "] has been stacked");
}
else
{
logistics.output.Print("!!! '" + item.Type.SubtypeId + "' [" + index + "] failed to move");
}
}
}
private static void UnpackMothership()
{
MyTrace.Send(TraceWindow.Saving, "Player unpacking mothership");
MyInventoryItem item = MySession.Static.Inventory.GetInventoryItem(MyMwcObjectBuilderTypeEnum.PrefabContainer, null);
if (item != null)
{
//place largeship
//MyMwcObjectBuilder_LargeShip largeShipObjectBuilder = (MyMwcObjectBuilder_LargeShip)inventoryItems[0].GetObjectBuilder(true);
MyMwcObjectBuilder_PrefabContainer containerObjectBuilder =
(MyMwcObjectBuilder_PrefabContainer)item.GetInventoryItemObjectBuilder(true);
// We need to remove id's because mothership container could have same entity id in different sector
containerObjectBuilder.RemapEntityIds(new MyEntityIdRemapContext());
MyPrefabContainer container = new MyPrefabContainer();
container.Init(null, containerObjectBuilder, FindMothershipPosition());
MyEntities.Add(container);
//CreateFromObjectBuilderAndAdd(null, largeShipObjectBuilder, Matrix.CreateTranslation(MySession.PlayerShip.GetPosition() + new Vector3(100,100,0)));
MySession.Static.Inventory.RemoveInventoryItem(item);
container.Link();
MyTrace.Send(TraceWindow.Saving, "Player mothership found and unpacked");
}
}
public bool Eject(IMyInventory inventory, MyInventoryItem item)
{
//Log.Info($"IfFull: {IsFull}");
if (IsFull)
{
return(false);
}
var dst = Ejectors[Index].GetInventory(0);
do
{
while (dst.IsFull)
{
Index++;
Used++;
//Log.Info($"Index:{Index}, Used:{Used}");
if (Index >= Ejectors.Count)
{
//Log.Info("resetting Index");
Index = 0;
}
if (Used >= Ejectors.Count)
{
//Log.Info("setting IsFull");
IsFull = true;
return(false);
}
dst = Ejectors[Index].GetInventory(0);
}
} while(!inventory.TransferItemTo(dst, item));
return(true);
}
public void RefineryCleanup(int inventory_index, List <IMyCargoContainer> cargo_list)
{
foreach (IMyRefinery refinery in refinery_list)
{
IMyInventory refinery_inventory = refinery.GetInventory(inventory_index);
List <MyInventoryItem> items = new List <MyInventoryItem>();
refinery_inventory.GetItems(items);
MyInventoryItem[] refinery_items = items.ToArray();
for (int idx = 0; idx < refinery_items.Length; idx++)
{
MyInventoryItem refinery_item = refinery_items[idx];
foreach (IMyCargoContainer cargo in cargo_list)
{
IMyInventory cargo_inventory = cargo.GetInventory(0);
if (!cargo_inventory.IsFull)
{
refinery_inventory.TransferItemTo(cargo_inventory, idx, null, true, null);
}
if (refinery_item.Amount.ToIntSafe() < 1)
{
break;
}
}
}
}
}
private void OnAfterItemsAdded(MyInventoryItem item, int amount)
{
if (item == null || amount == 0)
{
return;
}
MyDefinitionId outputId;
if (_definition.Swaps.TryGetValue(item.DefinitionId, out outputId))
{
SwapItems(item.DefinitionId, outputId, amount);
return;
}
var itemDef = item.GetDefinition();
if (itemDef.Tags == null || itemDef.Tags.Count == 0)
{
return;
}
foreach (var tag in itemDef.Tags)
{
if (!_definition.Swaps.TryGetValue(new MyDefinitionId(typeof(MyObjectBuilder_ItemTagDefinition), tag), out outputId))
{
continue;
}
SwapItems(item.DefinitionId, outputId, amount);
return;
}
}
public static MyEntity Spawn(ref MyInventoryItem item, Vector3 position, Vector3 speed)
{
var builder = PrepareBuilder(ref item);
var meteorEntity = MyEntities.CreateFromObjectBuilder(builder);
Vector3 forward = -MySector.DirectionToSunNormalized;
Vector3 up = MyUtils.GetRandomVector3Normalized();
while (forward == up)
{
up = MyUtils.GetRandomVector3Normalized();
}
Vector3 right = Vector3.Cross(forward, up);
up = Vector3.Cross(right, forward);
meteorEntity.WorldMatrix = Matrix.CreateWorld(position, forward, up);
MyEntities.Add(meteorEntity);
meteorEntity.Physics.RigidBody.MaxLinearVelocity = 500;
meteorEntity.Physics.LinearVelocity = speed;
meteorEntity.Physics.AngularVelocity = MyUtils.GetRandomVector3Normalized() * MyUtils.GetRandomFloat(1.5f, 3);
MySyncCreate.SendEntityCreated(meteorEntity.GetObjectBuilder());
return(meteorEntity);
}
float getItemAmountAsFloat(MyInventoryItem item)
{
float count = 0;
float.TryParse("" + item.Amount, out count);
return(count);
}
private ResourceStack ConvertToResource(MyInventoryItem item)
{
ResourceType resourceType = new ResourceType(item.Type.TypeId, item.Type.SubtypeId);
//if (resourceType.TypeName != "Ore")
// return null;
return(new ResourceStack(resourceType, item.Amount));
}
private static MyObjectBuilder_Meteor PrepareBuilder(ref MyInventoryItem item)
{
var meteorBuilder = Sandbox.Common.ObjectBuilders.Serializer.MyObjectBuilderSerializer.CreateNewObject <MyObjectBuilder_Meteor>();
meteorBuilder.Item = item.GetObjectBuilder();
meteorBuilder.PersistentFlags |= MyPersistentEntityFlags2.Enabled | MyPersistentEntityFlags2.InScene;
return(meteorBuilder);
}
public static bool IsSupportedToolKitItem(MyInventoryItem toolInventoryItem)
{
return(toolInventoryItem != null &&
toolInventoryItem.Amount > 0f &&
toolInventoryItem.ObjectBuilderType == MyMwcObjectBuilderTypeEnum.SmallShip_Tool &&
toolInventoryItem.ObjectBuilderId != null &&
m_delegatesPerToolKitType.ContainsKey(toolInventoryItem.ObjectBuilderId.Value));
}
private bool IsItem(MyInventoryItem item, ItemType itemType)
{
if (itemType == ItemType.Stone)
{
return(item.Type.SubtypeId == itemType.ToString() && item.Type.GetItemInfo().IsIngot);
}
return(item.Type.SubtypeId == itemType.ToString());
}
private void InventoryContentChanged(MyInventory sender, MyInventoryItem inventoryItem, float amountChanged)
{
float oreAmount = sender.GetInventoryItemsCount(MyMwcObjectBuilderTypeEnum.Ore, null);
if (oreAmount >= 50)
{
m_objectives.Find(submission => submission.ID == MyMissionID.M01_Intro_Mining).Success();
}
}
public override bool AddItems(MyDefinitionId id, int amount, NewItemParams parameters = NewItemParams.None)
{
if (amount == 0)
{
return(false);
}
var item = MyInventoryItem.Create(id, amount);
return(item != null && Add(item, parameters));
}
private static MyObjectBuilder_FloatingObject PrepareBuilder(ref MyInventoryItem item)
{
Debug.Assert(item.Amount > 0, "FloatObject item amount must be > 0");
var floatingBuilder = Sandbox.Common.ObjectBuilders.Serializer.MyObjectBuilderSerializer.CreateNewObject <MyObjectBuilder_FloatingObject>();
floatingBuilder.Item = item.GetObjectBuilder();
floatingBuilder.PersistentFlags |= MyPersistentEntityFlags2.Enabled | MyPersistentEntityFlags2.InScene;
return(floatingBuilder);
}
void TransferItemToAvailableInventory(MyInventoryItem item, MyFixedPoint amount, IMyInventory inventory, List <IMyInventory> targetInventories)
{
IMyInventory targetInventory = targetInventories.Find(i => i.CanItemsBeAdded(amount, item.Type));
if (targetInventory != null)
{
int itemIndex = GetItemIndex(item, inventory);
inventory.TransferItemTo(targetInventory, item, amount);
}
}
void AddToGlobalInventory(
MyInventoryItem item, bool isInCargo)
{
AddGlobalInventorySlot(item.Type.TypeId, item.Type.SubtypeId);
globalInventory[item.Type.TypeId][item.Type.SubtypeId].AddAmount(item.Amount);
if (isInCargo)
{
globalInventory[item.Type.TypeId][item.Type.SubtypeId].AddCargoAmount(item.Amount);
}
}
public double GetSecondsToClear(MyInventoryItem item)
{
var type = new ItemType(item.Type.TypeId, item.Type.SubtypeId);
var perSecond = GetAmountConsumedPerSecond(type);
if (perSecond <= 0)
{
return(0);
}
return(((double)item.Amount) / perSecond);
}
public override void Init(MyObjectBuilder_EntityBase objectBuilder)
{
var builder = objectBuilder as MyObjectBuilder_FloatingObject;
if (builder.Item.Amount <= 0)
{
// I can only prevent creation of entity by throwing exception. This might cause crashes when thrown outside of MyEntities.CreateFromObjectBuilder().
throw new ArgumentOutOfRangeException("MyInventoryItem.Amount", string.Format("Creating floating object with invalid amount: {0}x '{1}'", builder.Item.Amount, builder.Item.Content.GetId()));
}
base.Init(objectBuilder);
this.Item = new MyInventoryItem(builder.Item);
InitInternal();
NeedsUpdate |= MyEntityUpdateEnum.EACH_FRAME;
}
public static MyEntity Spawn(ref MyInventoryItem item, Vector3 position, Vector3 speed)
{
var builder = PrepareBuilder(ref item);
var meteorEntity = MyEntities.CreateFromObjectBuilder(builder);
Vector3 forward = -MySector.DirectionToSunNormalized;
Vector3 up = MyUtils.GetRandomVector3Normalized();
while (forward == up)
up = MyUtils.GetRandomVector3Normalized();
Vector3 right = Vector3.Cross(forward, up);
up = Vector3.Cross(right, forward);
meteorEntity.WorldMatrix = Matrix.CreateWorld(position, forward, up);
MyEntities.Add(meteorEntity);
meteorEntity.Physics.RigidBody.MaxLinearVelocity = 500;
meteorEntity.Physics.LinearVelocity = speed;
meteorEntity.Physics.AngularVelocity = MyUtils.GetRandomVector3Normalized() * MyUtils.GetRandomFloat(1.5f, 3);
MySyncCreate.SendEntityCreated(meteorEntity.GetObjectBuilder());
return meteorEntity;
}
public void Init(MyObjectBuilder_ConveyorPacket builder, MyEntity parent)
{
Item = new MyInventoryItem(builder.Item);
LinePosition = builder.LinePosition;
var physicalItem = MyDefinitionManager.Static.GetPhysicalItemDefinition(Item.Content);
var ore = Item.Content as MyObjectBuilder_Ore;
string model = physicalItem.Model;
float scale = 1.0f;
if (ore != null)
{
foreach (var mat in MyDefinitionManager.Static.GetVoxelMaterialDefinitions())
{
if (mat.MinedOre == ore.SubtypeName)
{
model = MyDebris.GetRandomDebrisVoxel();
scale = (float)Math.Pow((float)Item.Amount * physicalItem.Volume / MyDebris.VoxelDebrisModelVolume, 0.333f);
break;
}
}
}
if (scale < 0.05f)
scale = 0.05f;
else if (scale > 1.0f)
scale = 1.0f;
bool entityIdAllocationSuspended = MyEntityIdentifier.AllocationSuspended;
MyEntityIdentifier.AllocationSuspended = false;
Init(null, model, parent, null, null);
MyEntityIdentifier.AllocationSuspended = entityIdAllocationSuspended;
PositionComp.Scale = scale;
// Packets are serialized by conveyor lines
Save = false;
}
private void SpawnOrePieces(MyFixedPoint amountItems, MyFixedPoint maxAmountPerDrop, Vector3 hitPosition, MyObjectBuilder_PhysicalObject oreObjBuilder, MyVoxelMaterialDefinition voxelMaterial)
{
ProfilerShort.Begin("SpawnOrePieces");
var forward = Vector3.Normalize(m_sensor.FrontPoint - m_sensor.Center);
//var pos = m_sensor.CutOutSphere.Center + forward * m_floatingObjectSpawnOffset;
var pos = hitPosition - forward * m_floatingObjectSpawnRadius;
BoundingSphere bsphere = new BoundingSphere(pos, m_floatingObjectSpawnRadius);
while (amountItems > 0)
{
MyFixedPoint dropAmount = MyFixedPoint.Min(amountItems, maxAmountPerDrop);
amountItems -= dropAmount;
var inventoryItem = new MyInventoryItem(dropAmount, oreObjBuilder);
var item = MyFloatingObjects.Spawn(inventoryItem, bsphere, null, voxelMaterial);
item.Physics.LinearVelocity = MyUtils.GetRandomVector3HemisphereNormalized(forward) * MyUtils.GetRandomFloat(5, 8);
item.Physics.AngularVelocity = MyUtils.GetRandomVector3Normalized() * MyUtils.GetRandomFloat(4, 8);
}
ProfilerShort.End();
}
private void TryThrowOutItem()
{
float volume = CubeGrid.GridSizeEnum == MyCubeSize.Large ? 0.25f : 0.05f;
var items = m_inventory.GetItems();
for (int i = 0; i < m_inventory.GetItems().Count; )
{
float rnd = MyUtils.GetRandomFloat(0, CubeGrid.GridSizeEnum == MyCubeSize.Large ? 0.5f : 0.07f);
var circle = MyUtils.GetRandomVector3CircleNormalized();
Vector3 rndPos = Vector3.Transform(ConnectionPosition, CubeGrid.PositionComp.WorldMatrix) + PositionComp.WorldMatrix.Right * circle.X * rnd + PositionComp.WorldMatrix.Up * circle.Z * rnd;
MyPhysicalItemDefinition def;
if (!MyDefinitionManager.Static.TryGetPhysicalItemDefinition(items[i].Content.GetId(), out def))
continue;
Vector3 forward, up;
float offset = def.Size.Max();
if (offset == def.Size.Z)
{
forward = PositionComp.WorldMatrix.Forward;
up = PositionComp.WorldMatrix.Up;
}
else if (offset == def.Size.Y)
{
forward = PositionComp.WorldMatrix.Right;
up = PositionComp.WorldMatrix.Forward;
}
else
{
forward = PositionComp.WorldMatrix.Up;
up = PositionComp.WorldMatrix.Right;
}
offset *= 0.5f;
rndPos += PositionComp.WorldMatrix.Forward * offset;
MyFixedPoint itemAmount = (MyFixedPoint)(volume / def.Volume);
if (items[i].Content.TypeId != typeof(MyObjectBuilder_Ore) &&
items[i].Content.TypeId != typeof(MyObjectBuilder_Ingot))
{
itemAmount = MyFixedPoint.Ceiling(itemAmount);
}
MyParticleEffect effect;
MyEntity entity;
if (items[i].Amount < itemAmount)
{
volume -= ((float)items[i].Amount * def.Volume);
entity = MyFloatingObjects.Spawn(items[i], rndPos, PositionComp.WorldMatrix.Forward, PositionComp.WorldMatrix.Up, CubeGrid.Physics);
m_inventory.RemoveItems(items[i].ItemId);
i++;
}
else
{
var tmpItem = new MyInventoryItem(items[i].GetObjectBuilder());
tmpItem.Amount = itemAmount;
entity = MyFloatingObjects.Spawn(tmpItem, rndPos, PositionComp.WorldMatrix.Forward, PositionComp.WorldMatrix.Up, CubeGrid.Physics);
m_inventory.RemoveItems(items[i].ItemId, itemAmount);
volume = 0;
}
entity.Physics.LinearVelocity += PositionComp.WorldMatrix.Forward * (1);
if (MyParticlesManager.TryCreateParticleEffect((int)MyParticleEffectsIDEnum.Smoke_Collector, out effect))
{
//effect.WorldMatrix = Matrix.CreateWorld(PositionComp.GetPosition(), PositionComp.WorldMatrix.Forward, PositionComp.WorldMatrix.Up);
effect.WorldMatrix = entity.WorldMatrix;
effect.Velocity = CubeGrid.Physics.LinearVelocity;
foreach (var gen in effect.GetGenerations())
{
gen.MotionInheritance.AddKey(0, 1f);
}
}
break;
}
}
public static MyEntity SpawnRandomLarge(Vector3 position, Vector3 direction)
{
MyInventoryItem i = new MyInventoryItem(400 * (MyFixedPoint)MyUtils.GetRandomFloat(0f, 25f), Sandbox.Common.ObjectBuilders.Serializer.MyObjectBuilderSerializer.CreateNewObject<MyObjectBuilder_Ore>("Stone"));
return Spawn(ref i, position, direction * (MIN_SPEED + MyUtils.GetRandomInt(MIN_SPEED / 2)));
}
private bool ThrowFloatingObjectsFunc()
{
var view = MySession.Static.CameraController.GetViewMatrix();
var inv = Matrix.Invert(view);
//MyInventoryItem item = new MyInventoryItem(100,
var oreBuilder = Sandbox.Common.ObjectBuilders.Serializer.MyObjectBuilderSerializer.CreateNewObject<MyObjectBuilder_Ore>("Stone");
var scrapBuilder = MyFloatingObject.ScrapBuilder;
for (int i = 1; i <= 25; i++)
{
var item = new MyInventoryItem((MyRandom.Instance.Next() % 200) + 1, oreBuilder);
var obj = MyFloatingObjects.Spawn(item, inv.Translation + inv.Forward * i * 1.0f, inv.Forward, inv.Up);
obj.Physics.LinearVelocity = inv.Forward * 50;
}
Vector3D scrapPos = inv.Translation;
scrapPos.X += 10;
for (int i = 1; i <= 25; i++)
{
var item = new MyInventoryItem((MyRandom.Instance.Next() % 200) + 1, scrapBuilder);
var obj = MyFloatingObjects.Spawn(item, scrapPos + inv.Forward * i * 1.0f, inv.Forward, inv.Up);
obj.Physics.LinearVelocity = inv.Forward * 50;
}
return true;
}
public override bool HandleInput()
{
bool handled = false;
if (m_gridDebugInfo)
{
LineD line = new LineD(MySector.MainCamera.Position, MySector.MainCamera.Position + MySector.MainCamera.ForwardVector * 1000);
MyCubeGrid grid;
Vector3I cubePos;
double distance;
if (MyCubeGrid.GetLineIntersection(ref line, out grid, out cubePos, out distance))
{
var gridMatrix = grid.WorldMatrix;
var boxMatrix = Matrix.CreateTranslation(cubePos * grid.GridSize) * gridMatrix;
var block = grid.GetCubeBlock(cubePos);
MyRenderProxy.DebugDrawText2D(new Vector2(), cubePos.ToString(), Color.White, 0.7f);
MyRenderProxy.DebugDrawOBB(Matrix.CreateScale(new Vector3(grid.GridSize) + new Vector3(0.15f)) * boxMatrix, Color.Red.ToVector3(), 0.2f, true, true);
//int[, ,] bones = grid.Skeleton.AddCubeBones(cubePos);
//Vector3 closestBone = Vector3.Zero;
//Vector3I closestPoint = Vector3I.Zero;
//float closestPointDist = float.MaxValue;
//int closestBoneIndex = 0;
//for (int x = -1; x <= 1; x += 1)
//{
// for (int y = -1; y <= 1; y += 1)
// {
// for (int z = -1; z <= 1; z += 1)
// {
// int boneIndex = bones[x + 1, y + 1, z + 1];
// Vector3 bone = grid.Skeleton[boneIndex];
// var pos = boxMatrix.Translation + new Vector3(grid.GridSize / 2) * new Vector3(x, y, z);
// //MyRenderProxy.DebugDrawSphere(pos, 0.2f, Color.Blue.ToVector3(), 1.0f, false);
// MyRenderProxy.DebugDrawText3D(pos, String.Format("{0:G2}, {1:G2}, {2:G2}", bone.X, bone.Y, bone.Z), Color.White, 0.5f, false);
// var dist = MyUtils.GetPointLineDistance(ref line, ref pos);
// if (dist < closestPointDist)
// {
// closestPointDist = dist;
// closestPoint = new Vector3I(x, y, z);
// closestBoneIndex = boneIndex;
// closestBone = bone;
// }
// }
// }
//}
//MyRenderProxy.DebugDrawText3D(boxMatrix.Translation + new Vector3(grid.GridSize / 2) * closestPoint * 1.0f, String.Format("{0:G2}, {1:G2}, {2:G2}", closestBone.X, closestBone.Y, closestBone.Z), Color.Red, 0.5f, false);
//var bonePos = grid.Skeleton[bones[closestPoint.X + 1, closestPoint.Y + 1, closestPoint.Z + 1]];
//MyRenderProxy.DebugDrawSphere(boxMatrix.Translation + new Vector3(grid.GridSize / 2) * closestPoint * 1.0f + bonePos, 0.5f, Color.Red.ToVector3(), 0.4f, true, true);
//if (input.IsNewKeyPressed(Keys.P) && block != null)
//{
// if (input.IsAnyShiftKeyPressed())
// {
// grid.ResetBlockSkeleton(block);
// }
// else
// {
// grid.Skeleton[bones[closestPoint.X + 1, closestPoint.Y + 1, closestPoint.Z + 1]] = Vector3.Zero;
// grid.AddDirtyBone(cubePos, closestPoint + Vector3I.One);
// //grid.SetBlockDirty(block);
// }
// handled = true;
//}
//// Move bones to center by 0.1f
//if (input.IsNewKeyPressed(Keys.OemOpenBrackets))
//{
// int index = bones[closestPoint.X + 1, closestPoint.Y + 1, closestPoint.Z + 1];
// grid.Skeleton[index] -= Vector3.Sign(grid.Skeleton[index]) * 0.1f;
// grid.AddDirtyBone(cubePos, closestPoint + Vector3I.One);
// //grid.SetBlockDirty(block);
// handled = true;
//}
//// Reduce max offset by 0.1f
//if (input.IsNewKeyPressed(Keys.OemCloseBrackets))
//{
// int index = bones[closestPoint.X + 1, closestPoint.Y + 1, closestPoint.Z + 1];
// var old = Vector3.Abs(grid.Skeleton[index]);
// var max = new Vector3(Math.Max(Math.Max(old.X, old.Y), old.Z));
// if (max.X > 0.1f)
// {
// grid.Skeleton[index] = Vector3.Clamp(grid.Skeleton[index], -max + 0.1f, max - 0.1f);
// }
// else
// {
// grid.Skeleton[index] = Vector3.Zero;
// }
// grid.AddDirtyBone(cubePos, closestPoint + Vector3I.One);
// //grid.SetBlockDirty(block);
// handled = true;
//}
}
}
if (MyInput.Static.IsAnyAltKeyPressed())
return handled;
bool shift = MyInput.Static.IsAnyShiftKeyPressed();
bool ctrl = MyInput.Static.IsAnyCtrlKeyPressed();
//if (input.IsNewKeyPressed(Keys.I))
//{
// foreach (var grid in MyEntities.GetEntities().OfType<MyCubeGrid>())
// {
// foreach (var block in grid.GetBlocks().ToArray())
// {
// grid.DetectMerge(block.Min, block.Max);
// }
// }
// handled = true;
//}
// Disabled since it is common to have normal control bound to O key.
// If you ever need this again, bind it to something more complicated, like key combination.
//if (input.IsNewKeyPressed(Keys.O))
//{
// m_gridDebugInfo = !m_gridDebugInfo;
// handled = true;
//}
//for (int i = 0; i <= 9; i++)
//{
// if (MyInput.Static.IsNewKeyPressed((Keys)(((int)Keys.D0) + i)))
// {
// string name = "Slot" + i.ToString();
// if (ctrl)
// {
// MySession.Static.Name = name;
// MySession.Static.WorldID = MySession.GetNewWorldId();
// MySession.Static.Save(name);
// }
// else if (shift)
// {
// var path = MyLocalCache.GetSessionSavesPath(name, false, false);
// if (System.IO.Directory.Exists(path))
// {
// MySession.Static.Unload();
// MySession.Load(path);
// }
// }
// handled = true;
// }
//}
//if (MyInput.Static.IsNewKeyPressed(Keys.End))
//{
// MyMeteorShower.MeteorWave(null);
//}
// Disabled for god sake!
//if (MyInput.Static.IsNewKeyPressed(Keys.PageUp) && MyInput.Static.IsAnyCtrlKeyPressed())
//{
// MyReloadTestComponent.Enabled = true;
//}
//if (MyInput.Static.IsNewKeyPressed(Keys.PageDown) && MyInput.Static.IsAnyCtrlKeyPressed())
//{
// MyReloadTestComponent.Enabled = false;
//}
if (MyInput.Static.IsNewKeyPressed(MyKeys.NumPad6))
{
var view = MySession.Static.CameraController.GetViewMatrix();
var inv = Matrix.Invert(view);
//MyInventoryItem item = new MyInventoryItem(100,
var oreBuilder = Sandbox.Common.ObjectBuilders.Serializer.MyObjectBuilderSerializer.CreateNewObject<MyObjectBuilder_Ore>("Stone");
var item = new MyInventoryItem(1, oreBuilder);
var obj = MyFloatingObjects.Spawn(item, inv.Translation + inv.Forward * 1.0f, inv.Forward, inv.Up);
obj.Physics.LinearVelocity = inv.Forward * 50;
}
if (false && MyInput.Static.IsNewKeyPressed(MyKeys.NumPad9))
{
List<HkShape> trShapes = new List<HkShape>();
List<HkConvexShape> shapes = new List<HkConvexShape>();
List<Matrix> matrices = new List<Matrix>();
var grid = new HkGridShape(2.5f, HkReferencePolicy.None);
const short size = 50;
for (short x = 0; x < size; x++)
{
for (short y = 0; y < size; y++)
{
for (short z = 0; z < size; z++)
{
var box = new HkBoxShape(Vector3.One);
grid.AddShapes(new System.Collections.Generic.List<HkShape>() { box }, new Vector3S(x, y, z), new Vector3S(x, y, z));
trShapes.Add(new HkConvexTranslateShape(box, new Vector3(x, y, z), HkReferencePolicy.None));
shapes.Add(box);
matrices.Add(Matrix.CreateTranslation(new Vector3(x, y, z)));
}
}
}
var emptyGeom = new HkGeometry(new List<Vector3>(), new List<int>());
var list = new HkListShape(trShapes.ToArray(), trShapes.Count, HkReferencePolicy.None);
var compressedBv = new HkBvCompressedMeshShape(emptyGeom, shapes, matrices, HkWeldingType.None);
var mopp = new HkMoppBvTreeShape(list, HkReferencePolicy.None);
HkShapeBuffer buf = new HkShapeBuffer();
//HkShapeContainerIterator i = compressedBv.GetIterator(buf);
//int count = 0; // will be 125000
//while (i.IsValid)
//{
// count++;
// i.Next();
//}
buf.Dispose();
var info = new HkRigidBodyCinfo();
info.Mass = 10;
info.CalculateBoxInertiaTensor(Vector3.One, 10);
info.MotionType = HkMotionType.Dynamic;
info.QualityType = HkCollidableQualityType.Moving;
info.Shape = compressedBv;
var body = new HkRigidBody(info);
//MyPhysics.HavokWorld.AddRigidBody(body);
}
if (MyInput.Static.IsNewKeyPressed(MyKeys.NumPad7))
{
foreach (var g in MyEntities.GetEntities().OfType<MyCubeGrid>())
{
foreach (var s in g.CubeBlocks.Select(s => s.FatBlock).Where(s => s != null).OfType<MyMotorStator>())
{
if (s.Rotor != null)
{
var q = Quaternion.CreateFromAxisAngle(s.Rotor.WorldMatrix.Up, MathHelper.ToRadians(45));
s.Rotor.CubeGrid.WorldMatrix = MatrixD.CreateFromQuaternion(q) * s.Rotor.CubeGrid.WorldMatrix;
}
}
}
}
if (MyInput.Static.IsNewKeyPressed(MyKeys.NumPad8))
{
var view = MySession.Static.CameraController.GetViewMatrix();
var inv = Matrix.Invert(view);
var oreBuilder = Sandbox.Common.ObjectBuilders.Serializer.MyObjectBuilderSerializer.CreateNewObject<MyObjectBuilder_Ore>("Stone");
var obj = new MyObjectBuilder_FloatingObject() { Item = new MyObjectBuilder_InventoryItem() { Content = oreBuilder, Amount = 1000 } };
obj.PositionAndOrientation = new MyPositionAndOrientation(inv.Translation + 2.0f * inv.Forward, inv.Forward, inv.Up);
obj.PersistentFlags = MyPersistentEntityFlags2.InScene;
var e = MyEntities.CreateFromObjectBuilderAndAdd(obj);
e.Physics.LinearVelocity = Vector3.Normalize(inv.Forward) * 50.0f;
}
if (MyInput.Static.IsNewKeyPressed(MyKeys.Divide))
{
}
if (MyInput.Static.IsNewKeyPressed(MyKeys.Multiply))
{
MyDebugDrawSettings.ENABLE_DEBUG_DRAW = !MyDebugDrawSettings.ENABLE_DEBUG_DRAW;
MyStructuralIntegrity.Enabled = true;
MyDebugDrawSettings.DEBUG_DRAW_STRUCTURAL_INTEGRITY = true;
var grids = MyEntities.GetEntities().OfType<MyCubeGrid>();
foreach (var g in grids)
{
if (!g.IsStatic)// || g.GetBlocks().Count < 800) //to compute only castle
continue;
g.CreateStructuralIntegrity();
}
}
if (MyInput.Static.IsNewKeyPressed(MyKeys.NumPad1))
{
var e = MyEntities.GetEntities().OfType<MyCubeGrid>().FirstOrDefault();
if (e != null)
{
e.Physics.RigidBody.MaxLinearVelocity = 1000;
if (e.Physics.RigidBody2 != null)
e.Physics.RigidBody2.MaxLinearVelocity = 1000;
e.Physics.LinearVelocity = new Vector3(1000, 0, 0);
}
}
if (MyInput.Static.IsNewKeyPressed(MyKeys.Decimal))
{
MyPrefabManager.Static.SpawnPrefab("respawnship", MySector.MainCamera.Position, MySector.MainCamera.ForwardVector, MySector.MainCamera.UpVector);
}
if (MyInput.Static.IsNewKeyPressed(MyKeys.Multiply) && MyInput.Static.IsAnyShiftKeyPressed())
{
GC.Collect(2);
}
if (MyInput.Static.IsNewKeyPressed(MyKeys.NumPad5))
{
Thread.Sleep(250);
}
if (MyInput.Static.IsNewKeyPressed(MyKeys.NumPad9))
{
var obj = MySession.ControlledEntity != null ? MySession.ControlledEntity.Entity : null;
if (obj != null)
{
const float dist = 5.0f;
obj.PositionComp.SetPosition(obj.PositionComp.GetPosition() + obj.WorldMatrix.Forward * dist);
}
}
if (MyInput.Static.IsNewKeyPressed(MyKeys.NumPad4))
{
IMyInventoryOwner invObject = MySession.ControlledEntity as IMyInventoryOwner;
if (invObject != null)
{
MyFixedPoint amount = 20000;
var oreBuilder = Sandbox.Common.ObjectBuilders.Serializer.MyObjectBuilderSerializer.CreateNewObject<MyObjectBuilder_Ore>("Stone");
MyInventory inventory = invObject.GetInventory(0);
inventory.AddItems(amount, oreBuilder);
}
handled = true;
}
//if (MyInput.Static.IsNewKeyPressed(Keys.NumPad8))
//{
// var pos = MySector.MainCamera.Position + MySector.MainCamera.ForwardVector * 2;
// var grid = (MyObjectBuilder_CubeGrid)Sandbox.Common.ObjectBuilders.Serializer.MyObjectBuilderSerializer.CreateNewObject(MyObjectBuilderTypeEnum.CubeGrid);
// grid.PositionAndOrientation = new MyPositionAndOrientation(pos, Vector3.Forward, Vector3.Up);
// grid.CubeBlocks = new List<MyObjectBuilder_CubeBlock>();
// grid.GridSizeEnum = MyCubeSize.Large;
// var block = new MyObjectBuilder_CubeBlock();
// block.BlockOrientation = MyBlockOrientation.Identity;
// block.Min = Vector3I.Zero;
// //var blockDefinition = Sandbox.Game.Managers.MyDefinitionManager.Static.GetCubeBlockDefinition(new CommonLib.ObjectBuilders.Definitions.MyDefinitionId(typeof(MyObjectBuilder_CubeBlock), "LargeBlockArmorBlock"));
// block.SubtypeName = "LargeBlockArmorBlock";
// grid.CubeBlocks.Add(block);
// grid.LinearVelocity = MySector.MainCamera.ForwardVector * 20;
// grid.PersistentFlags = MyPersistentEntityFlags2.Enabled | MyPersistentEntityFlags2.InScene;
// var x = MyEntities.CreateFromObjectBuilderAndAdd(grid);
//}
//if (MyInput.Static.IsNewKeyPressed(Keys.NumPad9))
//{
// var pos = MySector.MainCamera.Position + MySector.MainCamera.ForwardVector * 2;
// var grid = (MyObjectBuilder_CubeGrid)Sandbox.Common.ObjectBuilders.Serializer.MyObjectBuilderSerializer.CreateNewObject(MyObjectBuilderTypeEnum.CubeGrid);
// grid.PositionAndOrientation = new MyPositionAndOrientation(pos, Vector3.Forward, Vector3.Up);
// grid.CubeBlocks = new List<MyObjectBuilder_CubeBlock>();
// grid.GridSizeEnum = MyCubeSize.Large;
// var block = new MyObjectBuilder_CubeBlock();
// block.BlockOrientation = MyBlockOrientation.Identity;
// block.Min = Vector3I.Zero;
// //var blockDefinition = Sandbox.Game.Managers.MyDefinitionManager.Static.GetCubeBlockDefinition(new CommonLib.ObjectBuilders.Definitions.MyDefinitionId(typeof(MyObjectBuilder_CubeBlock), "LargeBlockArmorBlock"));
// block.SubtypeName = "LargeBlockGyro";
// grid.CubeBlocks.Add(block);
// grid.LinearVelocity = MySector.MainCamera.ForwardVector * 20;
// grid.PersistentFlags = MyPersistentEntityFlags2.Enabled | MyPersistentEntityFlags2.InScene;
// var x = MyEntities.CreateFromObjectBuilderAndAdd(grid);
//}
if (MyInput.Static.IsAnyCtrlKeyPressed() && MyInput.Static.IsNewKeyPressed(MyKeys.Delete))
{
int count = MyEntities.GetEntities().OfType<MyFloatingObject>().Count();
foreach (var obj in MyEntities.GetEntities().OfType<MyFloatingObject>())
{
if (obj == MySession.ControlledEntity)
{
MySession.SetCameraController(MyCameraControllerEnum.Spectator);
}
obj.Close();
}
handled = true;
}
if (MyInput.Static.IsAnyCtrlKeyPressed() && MyInput.Static.IsNewKeyPressed(MyKeys.Decimal))
{
foreach (var obj in MyEntities.GetEntities())
{
if (obj != MySession.ControlledEntity && (MySession.ControlledEntity == null || obj != MySession.ControlledEntity.Entity.Parent) && obj != MyCubeBuilder.Static.FindClosestGrid())
obj.Close();
}
handled = true;
}
if (MyInput.Static.IsNewKeyPressed(MyKeys.NumPad9) || MyInput.Static.IsNewKeyPressed(MyKeys.NumPad5))
{
//MyCubeGrid.UserCollisions = input.IsNewKeyPressed(Keys.NumPad9);
var body = MySession.ControlledEntity.Entity.GetTopMostParent().Physics;
if (body.RigidBody != null)
{
//body.AddForce(Engine.Physics.MyPhysicsForceType.ADD_BODY_FORCE_AND_BODY_TORQUE, new Vector3(0, 0, 10 * body.Mass), null, null);
body.RigidBody.ApplyLinearImpulse(body.Entity.WorldMatrix.Forward * body.Mass * 2);
}
handled = true;
}
//if (input.IsNewKeyPressed(Keys.J) && input.IsAnyCtrlKeyPressed())
//{
// MyGlobalInputComponent.CopyCurrentGridToClipboard();
// MyEntity addedEntity = MyGlobalInputComponent.PasteEntityFromClipboard();
// if (addedEntity != null)
// {
// Vector3 pos = addedEntity.GetPosition();
// pos.Z += addedEntity.WorldVolume.Radius * 1.5f;
// addedEntity.SetPosition(pos);
// }
// handled = true;
//}
if (MyInput.Static.IsAnyCtrlKeyPressed() && MyInput.Static.IsNewKeyPressed(MyKeys.OemComma))
{
foreach (var e in MyEntities.GetEntities().OfType<MyFloatingObject>().ToArray())
e.Close();
}
return handled;
}
public static MyEntity SpawnRandomStaticSmall(Vector3 position)
{
MyInventoryItem i = new MyInventoryItem(4 * (MyFixedPoint)MyUtils.GetRandomFloat(0f, 100f), Sandbox.Common.ObjectBuilders.Serializer.MyObjectBuilderSerializer.CreateNewObject<MyObjectBuilder_Ore>("Stone"));
return Spawn(ref i, position, Vector3.Zero);
}
private void DisableUnacceptingInventoryControls(MyInventoryItem item, MyGuiControlList list)
{
foreach (var control in list.Controls.GetVisibleControls())
{
if (!control.Enabled)
continue;
var ownerControl = (MyGuiControlInventoryOwner)control;
var owner = ownerControl.InventoryOwner;
for (int i = 0; i < owner.InventoryCount; ++i)
{
var inventory = owner.GetInventory(i);
if (!inventory.CanItemsBeAdded(0, item.Content.GetId()))
{
ownerControl.ContentGrids[i].Enabled = false;
m_controlsDisabledWhileDragged.Add(ownerControl.ContentGrids[i]);
}
}
}
}
private static MyObjectBuilder_Meteor PrepareBuilder(ref MyInventoryItem item)
{
var meteorBuilder = Sandbox.Common.ObjectBuilders.Serializer.MyObjectBuilderSerializer.CreateNewObject<MyObjectBuilder_Meteor>();
meteorBuilder.Item = item.GetObjectBuilder();
meteorBuilder.PersistentFlags |= MyPersistentEntityFlags2.Enabled | MyPersistentEntityFlags2.InScene;
return meteorBuilder;
}
protected virtual void OnInventoryItemAmountChange(MyInventory sender, MyInventoryItem inventoryItem, float amountChanged)
{
MyScriptWrapper.OnEntityInventoryAmountChange(this, sender, inventoryItem, amountChanged);
}
public static void AppendReachableEndpoints(IMyConveyorEndpoint source, long playerId, List<IMyConveyorEndpoint> reachable, MyInventoryItem item, Predicate<IMyConveyorEndpoint> endpointFilter = null)
{
IMyConveyorEndpointBlock block = source.CubeBlock as IMyConveyorEndpointBlock;
Debug.Assert(block != null);
if (block == null)
return;
SetTraversalPlayerId(playerId);
var itemId = item.Content.GetId();
SetTraversalInventoryItemDefinitionId(itemId);
m_pathfinding.FindReachable(block.ConveyorEndpoint, reachable, endpointFilter, IsAccessAllowedPredicate, NeedsLargeTube(itemId) ? IsConveyorLargePredicate : null);
}
private static void FixTransferAmount(MyInventory src, MyInventory dst, MyInventoryItem? srcItem, bool spawn, ref MyFixedPoint remove, ref MyFixedPoint add)
{
Debug.Assert(Sync.IsServer);
if (srcItem.Value.Amount < remove)
{
remove = srcItem.Value.Amount;
add = remove;
}
if (!MySession.Static.CreativeMode && !src.Equals(dst))
{
MyFixedPoint space = dst.ComputeAmountThatFits(srcItem.Value.Content.GetId());
if (space < remove)
{
if (spawn)
{
MyEntity e = (dst.Owner as MyEntity);
Matrix m = e.WorldMatrix;
MyFloatingObjects.Spawn(new MyInventoryItem(remove - space, srcItem.Value.Content), e.PositionComp.GetPosition() + m.Forward + m.Up, m.Forward, m.Up, e.Physics);
}
else
{
remove = space;
}
add = space;
}
}
}
private static void CorrectItemAmount(ref MyInventoryItem dragItem)
{
var obType = dragItem.Content.TypeId;
}
private bool TransferToOppositeFirst(MyInventoryItem item)
{
var srcControl = m_focusedOwnerControl;
var otherInventoriesControl = (srcControl.Owner == m_leftOwnersControl) ? m_rightOwnersControl : m_leftOwnersControl;
var dstControlEnumerator = otherInventoriesControl.Controls.GetEnumerator();
MyGuiControlInventoryOwner dstControl = null;//()(dstControlEnumerator.MoveNext() ? dstControlEnumerator.Current : null);
while (dstControlEnumerator.MoveNext())
if (dstControlEnumerator.Current.Visible)
{
dstControl = dstControlEnumerator.Current as MyGuiControlInventoryOwner;
break;
}
if (dstControl == null || !dstControl.Enabled)
return false;
bool localTransfer = ((srcControl.InventoryOwner == m_userAsOwner || srcControl.InventoryOwner == m_interactedAsOwner) &&
(dstControl.InventoryOwner == m_userAsOwner || dstControl.InventoryOwner == m_interactedAsOwner));
if (!localTransfer)
{
bool fromCharacter = srcControl.InventoryOwner is MyCharacter;
bool toCharacter = dstControl.InventoryOwner is MyCharacter;
IMyConveyorEndpointBlock srcEndpoint = srcControl.InventoryOwner == null ? null : (fromCharacter ? m_interactedAsOwner : srcControl.InventoryOwner) as IMyConveyorEndpointBlock;
IMyConveyorEndpointBlock dstEndpoint = dstControl.InventoryOwner == null ? null : (toCharacter ? m_interactedAsOwner : dstControl.InventoryOwner) as IMyConveyorEndpointBlock;
if (srcEndpoint == null || dstEndpoint == null)
return false;
if (!MyGridConveyorSystem.Pathfinding.Reachable(srcEndpoint.ConveyorEndpoint, dstEndpoint.ConveyorEndpoint))
return false;
}
var dstOwner = dstControl.InventoryOwner;
var srcOwner = m_focusedOwnerControl.InventoryOwner;
var srcInventory = (MyInventory)m_focusedGridControl.UserData;
MyInventory dstInventory = null;
for (int i = 0; i < dstOwner.InventoryCount; ++i)
{
var tmp = dstOwner.GetInventory(i);
if (tmp.CheckConstraint(item.Content.GetId()))
{
dstInventory = tmp;
break;
}
}
if (dstInventory == null)
return false;
dstInventory.TransferItemFrom(srcInventory, m_focusedGridControl.SelectedIndex.Value, amount: item.Amount);
return true;
}
private void ShowAmountTransferDialog(MyInventoryItem inventoryItem, Action<float> onConfirmed)
{
var amount = inventoryItem.Amount;
var obType = inventoryItem.Content.TypeId;
int maxDecimalDigits = 0;
bool asInteger = true;
if (obType == typeof(MyObjectBuilder_Ore) ||
obType == typeof(MyObjectBuilder_Ingot))
{
maxDecimalDigits = MyInventoryConstants.GUI_DISPLAY_MAX_DECIMALS;
asInteger = false;
}
var dialog = new MyGuiScreenDialogAmount(0, (float)amount, minMaxDecimalDigits: maxDecimalDigits, parseAsInteger: asInteger);
dialog.OnConfirmed += onConfirmed;
MyGuiSandbox.AddScreen(dialog);
}
private void DisableUnreachableInventoryControls(MyInventory srcInventory, MyInventoryItem item, MyGuiControlList list)
{
bool fromUser = srcInventory.Owner == m_userAsOwner;
bool fromInteracted = srcInventory.Owner == m_interactedAsOwner;
// srcEndpoint will be the endpoint from which we search the graph
var srcInventoryOwner = srcInventory.Owner;
IMyConveyorEndpointBlock srcEndpoint = null;
// Search the interacted's graph if we want to transfer from the user
if (fromUser)
{
if (m_interactedAsEntity != null)
srcEndpoint = m_interactedAsEntity as IMyConveyorEndpointBlock;
}
else if (srcInventoryOwner != null)
{
srcEndpoint = srcInventoryOwner as IMyConveyorEndpointBlock;
}
IMyConveyorEndpointBlock interactedEndpoint = null;
if (m_interactedAsEntity != null)
{
interactedEndpoint = m_interactedAsEntity as IMyConveyorEndpointBlock;
}
if (srcEndpoint != null)
{
long ownerId = MySession.LocalPlayerId;
m_interactedEndpointBlock = interactedEndpoint;
MyGridConveyorSystem.AppendReachableEndpoints(srcEndpoint.ConveyorEndpoint, ownerId, m_reachableInventoryOwners, item, m_endpointPredicate);
}
foreach (var control in list.Controls.GetVisibleControls())
{
if (!control.Enabled)
continue;
var ownerControl = (MyGuiControlInventoryOwner)control;
var owner = ownerControl.InventoryOwner;
IMyConveyorEndpoint endpoint = null;
var ownerBlock = owner as IMyConveyorEndpointBlock;
if (ownerBlock != null)
endpoint = ownerBlock.ConveyorEndpoint;
// TODO: Make some of these as functions so we don't have to call it even when not used due to lazy evaluation
bool transferIsLocal = owner == srcInventoryOwner;
bool transferIsClose = (fromUser && owner == m_interactedAsOwner) || (fromInteracted && owner == m_userAsOwner);
bool transferIsFar = !transferIsLocal && !transferIsClose;
bool endpointUnreachable = !m_reachableInventoryOwners.Contains(endpoint);
bool interactedReachable = interactedEndpoint != null && m_reachableInventoryOwners.Contains(interactedEndpoint.ConveyorEndpoint);
bool toOwnerThroughInteracted = owner == m_userAsOwner && interactedReachable;
if (transferIsFar && endpointUnreachable && !toOwnerThroughInteracted)
{
for (int i = 0; i < owner.InventoryCount; ++i)
{
if (!ownerControl.ContentGrids[i].Enabled)
continue;
ownerControl.ContentGrids[i].Enabled = false;
m_controlsDisabledWhileDragged.Add(ownerControl.ContentGrids[i]);
}
}
}
m_reachableInventoryOwners.Clear();
}
public override void Init(MyObjectBuilder_EntityBase objectBuilder)
{
Entity.SyncFlag = true;
base.Init(objectBuilder);
Entity.SyncObject.UpdatePosition();
var builder = (MyObjectBuilder_Meteor)objectBuilder;
Item = new MyInventoryItem(builder.Item);
m_particleEffectId = MySession.Static.EnvironmentHostility == MyEnvironmentHostilityEnum.CATACLYSM_UNREAL ? (int)MyParticleEffectsIDEnum.MeteorTrail_FireAndSmoke : (int)MyParticleEffectsIDEnum.MeteorParticle;
InitInternal();
Entity.Physics.LinearVelocity = builder.LinearVelocity;
Entity.Physics.AngularVelocity = builder.AngularVelocity;
m_integrity = builder.Integrity;
}
private void FormatDisplayName(StringBuilder outputBuffer, MyInventoryItem item)
{
var definition = MyDefinitionManager.Static.GetPhysicalItemDefinition(item.Content);
outputBuffer.Clear().Append(definition.DisplayNameText);
if (Item.Amount != 1)
{
outputBuffer.Append(" (");
MyGuiControlInventoryOwner.FormatItemAmount(item, outputBuffer);
outputBuffer.Append(")");
}
}
public void SpawnConstructionStockpile()
{
if (m_stockpile == null) return;
Matrix worldMat = CubeGrid.WorldMatrix;
int dist = (Max).RectangularDistance(Min) + 3;
Vector3 a = Min;
Vector3 b = Max;
a *= CubeGrid.GridSize;
b *= CubeGrid.GridSize;
a = Vector3.Transform(a, worldMat);
b = Vector3.Transform(b, worldMat);
Vector3 avgPos = (a + b) / 2;
Vector3 gravity = MyGravityProviderSystem.CalculateGravityInPoint(avgPos);
if (gravity.Length() != 0.0f)
{
gravity.Normalize();
Vector3I? intersected = CubeGrid.RayCastBlocks(avgPos, avgPos + gravity * dist * CubeGrid.GridSize);
if (!intersected.HasValue)
{
a = avgPos;
}
else
{
a = intersected.Value;
a *= CubeGrid.GridSize;
a = Vector3.Transform(a, worldMat);
a -= gravity * CubeGrid.GridSize * 0.1f;
}
}
var items = m_stockpile.GetItems();
foreach (var item in items)
{
var inventoryItem = new MyInventoryItem(item.Amount, item.Content);
MyFloatingObjects.Spawn(inventoryItem, a, worldMat.Forward, worldMat.Up, CubeGrid.Physics);
}
}
public static bool ItemPushRequest(IMyConveyorEndpointBlock start, MyInventory srcInventory, long playerId, MyInventoryItem toSend, MyFixedPoint? amount = null)
{
var itemBuilder = toSend.Content;
if (amount.HasValue)
Debug.Assert(toSend.Content.TypeId == typeof(MyObjectBuilder_Ore) ||
toSend.Content.TypeId == typeof(MyObjectBuilder_Ingot) ||
MyFixedPoint.Floor(amount.Value) == amount.Value);
MyFixedPoint remainingAmount = toSend.Amount;
if (amount.HasValue)
{
remainingAmount = amount.Value;
}
SetTraversalPlayerId(playerId);
var toSendContentId = toSend.Content.GetId();
SetTraversalInventoryItemDefinitionId(toSendContentId);
if (NeedsLargeTube(toSendContentId))
{
PrepareTraversal(start.ConveyorEndpoint, null, IsAccessAllowedPredicate, IsConveyorLargePredicate);
}
else
{
PrepareTraversal(start.ConveyorEndpoint, null, IsAccessAllowedPredicate);
}
bool success = false;
foreach (var conveyorEndpoint in MyGridConveyorSystem.Pathfinding)
{
IMyInventoryOwner owner = conveyorEndpoint.CubeBlock as IMyInventoryOwner;
if (owner == null) continue;
for (int i = 0; i < owner.InventoryCount; ++i)
{
var inventory = owner.GetInventory(i);
if ((inventory.GetFlags() & MyInventoryFlags.CanReceive) == 0)
continue;
if (inventory == srcInventory)
continue;
var fittingAmount = inventory.ComputeAmountThatFits(toSendContentId);
fittingAmount = MyFixedPoint.Min(fittingAmount, remainingAmount);
if (!inventory.CheckConstraint(toSendContentId))
continue;
if (fittingAmount == 0)
continue;
MyInventory.Transfer(srcInventory, inventory, toSend.ItemId, -1, fittingAmount);
success = true;
}
}
return success;
}
