コード例 #1
0
        public override bool CanStack(MyObjectBuilder_PhysicalObject a)
        {
            MyObjectBuilder_BlockItem other = a as MyObjectBuilder_BlockItem;
            if (other == null) return false;

            return other.BlockDefId.TypeId == BlockDefId.TypeId && other.BlockDefId.SubtypeId == this.BlockDefId.SubtypeId && a.Flags == this.Flags;
        }
コード例 #2
0
 public MyInventoryItem(MyObjectBuilder_InventoryItem item)
 {
     Debug.Assert(item.Amount > 0, "Creating inventory item with zero amount!");
     ItemId = 0;
     Amount = item.Amount;
     Content = item.PhysicalContent;
 }
コード例 #3
0
 public MyInventoryItem(MyFixedPoint amount, MyObjectBuilder_PhysicalObject content)
 {
     Debug.Assert(amount > 0, "Creating inventory item with zero amount!");
     ItemId = 0;
     Amount = amount;
     Content = content;
 }
コード例 #4
0
        protected override void Init(MyObjectBuilder_DefinitionBase builder)
        {
            base.Init(builder);

            var generatorBuilder = builder as MyObjectBuilder_ReactorDefinition;
            MyDebug.AssertDebug(generatorBuilder != null, "Initializing thrust definition using wrong object builder.");
            InventorySize = generatorBuilder.InventorySize;
            InventoryMaxVolume = InventorySize.X * InventorySize.Y * InventorySize.Z;

            FuelId = generatorBuilder.FuelId;
            FuelDefinition = MyDefinitionManager.Static.GetPhysicalItemDefinition(FuelId);
            MyDebug.AssertDebug(FuelDefinition != null);

            FuelItem = MyObjectBuilderSerializer.CreateNewObject(generatorBuilder.FuelId) as MyObjectBuilder_PhysicalObject;
            MyDebug.AssertDebug(FuelItem != null);

            //StringBuilder constraintTooltip = new StringBuilder();
            //constraintTooltip.Append(FuelDefinition.DisplayNameText);
            //InventoryConstraint = new MyInventoryConstraint(constraintTooltip).Add(FuelId);
            String constraintTooltip = FuelDefinition.DisplayNameText;
            InventoryConstraint = new MyInventoryConstraint(constraintTooltip).Add(FuelId);
        }
コード例 #5
0
        public void AddItems(MyFixedPoint amount, MyObjectBuilder_PhysicalObject objectBuilder, int index = -1)
        {
            if (amount == 0) return;
            if (!CanItemsBeAdded(amount, objectBuilder.GetObjectId())) return;

            if (Sync.IsServer)
            {
                if (MyPerGameSettings.ConstrainInventory())
                    AffectAddBySurvival(ref amount, objectBuilder);
                if (amount == 0)
                    return;
                AddItemsInternal(amount, objectBuilder, index);
                SyncObject.SendAddItemsAnnounce(this, amount, objectBuilder, index);
            }
            else
                SyncObject.SendAddItemsRequest(this, index, amount, objectBuilder);
        }
コード例 #6
0
        private int? FindFirstStackablePosition(MyObjectBuilder_PhysicalObject toStack)
        {
            for (int i = 0; i < m_items.Count; ++i)
            {
                if (m_items[i].Content.CanStack(toStack)) return i;
            }

            return null;
        }
コード例 #7
0
 public bool ContainItems(MyFixedPoint amount, MyObjectBuilder_PhysicalObject ob)
 {
     return ContainItems(amount, ob.GetObjectId());
 }
コード例 #8
0
 public virtual bool CanStack(MyObjectBuilder_PhysicalObject a)
 {
     return(CanStack(a.TypeId, a.SubtypeId, a.Flags));
 }
コード例 #9
0
 public bool AddItems(MyInventory inventory, MyObjectBuilder_PhysicalObject obj, bool overrideCheck)
 {
     return AddItems(inventory, obj, overrideCheck, 1);
 }
コード例 #10
0
 public void RemoveItemsOfType(MyFixedPoint amount, MyObjectBuilder_PhysicalObject objectBuilder, bool spawn = false)
 {
     TransferOrRemove(this, amount, objectBuilder.GetObjectId(), objectBuilder.Flags, null, spawn);
 }
コード例 #11
0
 void Sandbox.ModAPI.IMyInventory.RemoveItemsOfType(VRage.MyFixedPoint amount, MyObjectBuilder_PhysicalObject objectBuilder, bool spawn)
 {
     RemoveItemsOfType(amount, objectBuilder, spawn);
 }
コード例 #12
0
 void Sandbox.ModAPI.IMyInventory.AddItems(VRage.MyFixedPoint amount, MyObjectBuilder_PhysicalObject objectBuilder, int index)
 {
     AddItems(amount, objectBuilder, index);
 }
コード例 #13
0
 bool Sandbox.ModAPI.Interfaces.IMyInventory.ContainItems(VRage.MyFixedPoint amount, MyObjectBuilder_PhysicalObject ob)
 {
     return ContainItems(amount, ob);
 }
コード例 #14
0
 public override bool CanStack(MyObjectBuilder_PhysicalObject a)
 {
     return false;
 }
コード例 #15
0
 public override bool CanStack(MyObjectBuilder_PhysicalObject a)
 {
     return(false);
 }
コード例 #16
0
 public bool AddItems(MyInventory inventory, MyObjectBuilder_PhysicalObject obj, bool overrideCheck, MyFixedPoint amount)
 {
     if (overrideCheck || !inventory.ContainItems(amount, obj))
     {
         if (inventory.CanItemsBeAdded(amount, obj.GetId()))
         {
             inventory.AddItems(amount, obj);
             return true;
         }
         else
         {
             return false;
         }
     }
     else
     {
         return false;
     }
 }
コード例 #17
0
 private void AffectAddBySurvival(ref MyFixedPoint amount, MyObjectBuilder_PhysicalObject objectBuilder)
 {
     Debug.Assert(Sync.IsServer);
     MyFixedPoint space = ComputeAmountThatFits(objectBuilder.GetObjectId());
     if (space < amount)
     {
         if (Owner.InventoryOwnerType == MyInventoryOwnerTypeEnum.Character)
         {
             MyCharacter c = (Owner as MyCharacter);
             Matrix m = c.GetHeadMatrix(true);
             MyEntity entity = MyFloatingObjects.Spawn(new MyInventoryItem(amount - space, objectBuilder), m.Translation, m.Forward, m.Up, c.Physics);
             entity.Physics.ApplyImpulse(m.Forward.Cross(m.Up), c.PositionComp.GetPosition());
         }
         amount = space;
     }
 }
コード例 #18
0
        public bool AddItems(int count, MyObjectBuilder_PhysicalObject physicalObject)
        {
            int index = 0;
            foreach (var item in m_items)
            {
                if (item.Content.CanStack(physicalObject))
                    break;
                index++;
            }
            if (index == m_items.Count())
            {
                Debug.Assert(count < int.MaxValue, "Trying to add more items into construction stockpile than int.MaxValue");
                if (count >= int.MaxValue) return false;

                MyStockpileItem item = new MyStockpileItem();
                item.Amount = (int)count;
                item.Content = physicalObject;
                m_items.Add(item);
                AddSyncItem(item);
                return true;
            }
            else
            {
                Debug.Assert((long)m_items[index].Amount + count < int.MaxValue, "Trying to add more items into construction stockpile than int.MaxValue");
                if ((long)m_items[index].Amount + count >= int.MaxValue) return false;

                MyStockpileItem item = new MyStockpileItem();
                item.Amount = (int)(m_items[index].Amount + count);
                item.Content = m_items[index].Content;
                m_items[index] = item;

                MyStockpileItem syncItem = new MyStockpileItem();
                syncItem.Content = m_items[index].Content;
                syncItem.Amount = (int)count;
                AddSyncItem(syncItem);
                return true;
            }

            return false;
        }
コード例 #19
0
        public void AddItemsInternal(MyFixedPoint amount, MyObjectBuilder_PhysicalObject objectBuilder, int index = -1, uint? itemId = null)
        {
            Debug.Assert(amount > 0, "Adding 0 amount of item.");

            var newItem = new MyInventoryItem() { Amount = amount, Content = objectBuilder };

            if (index >= 0 && index < m_items.Count)
            {
                if (m_items[index].Content.CanStack(objectBuilder))
                {
                    newItem.Amount += m_items[index].Amount;
                    newItem.ItemId = m_items[index].ItemId;
                    m_items[index] = newItem;
                }
                else
                {
                    newItem.ItemId = NextItemID;
                    m_items.Insert(index, newItem);
                }
            }
            else
            {
                bool add = true;
                bool canStackWithItself = newItem.Content.CanStack(newItem.Content);
                if (index < 0 && canStackWithItself)
                {
                    int? itemPos = FindFirstStackablePosition(objectBuilder);
                    if (itemPos.HasValue)
                    {
                        newItem.ItemId = m_items[itemPos.Value].ItemId;
                        newItem.Amount += m_items[itemPos.Value].Amount;
                        m_items[itemPos.Value] = newItem;
                        add = false;
                    }
                }
                if (add)
                {
                    if (canStackWithItself)
                    {
                        newItem.ItemId = itemId.HasValue ? itemId.Value : NextItemID;
                        m_items.Add(newItem);
                    }
                    else
                    {
                        var targetAmount = newItem.Amount;
                        newItem.Amount = 1;
                        for (MyFixedPoint addedAmount = 0; addedAmount < targetAmount; addedAmount += 1)
                        {
                            newItem.ItemId = itemId.HasValue ? itemId.Value : NextItemID;
                            itemId = null; // so we use NextItemID next time
                            m_items.Add(newItem);
                            newItem.Content = newItem.Content.Clone() as MyObjectBuilder_PhysicalObject;
                            Debug.Assert(newItem.Content != null);
                        }
                    }
                }
            }

            RefreshVolumeAndMass();

            VerifyIntegrity();

            if (ContentsChanged != null)
                ContentsChanged(this);
        }
コード例 #20
0
        public void SendAddItemsRequest(MyInventory inv, int index, MyFixedPoint amount, MyObjectBuilder_PhysicalObject objectBuilder)
        {
            Debug.Assert(inv.Owner != null, "Inventory must have owner to be able to add items synchronously!");
            var msg = new AddItemsMsg();
            msg.OwnerEntityId = inv.Owner.EntityId;
            msg.InventoryIndex = inv.InventoryIdx;
            msg.itemIdx = index;
            msg.Item = objectBuilder;
            msg.Amount = amount;

            Sync.Layer.SendMessageToServer(ref msg, MyTransportMessageEnum.Request);
        }
コード例 #21
0
        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 MyPhysicalInventoryItem(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();
        }
コード例 #22
0
 public bool ContainItems(MyFixedPoint amount, MyObjectBuilder_PhysicalObject ob)
 {
     throw new NotImplementedException();
 }
コード例 #23
0
 public bool RemoveItems(int count, MyObjectBuilder_PhysicalObject physicalObject)
 {
     return RemoveItems(count, physicalObject.GetId(), physicalObject.Flags);
 }
コード例 #24
0
ファイル: MyInventory.cs プロジェクト: fluxit/SpaceEngineers
 public bool ContainItems(MyFixedPoint amount, MyObjectBuilder_PhysicalObject ob)
 {
     if (ob == null) return false;
     return ContainItems(amount, ob.GetObjectId());
 }
コード例 #25
0
 public virtual bool CanStack(MyObjectBuilder_PhysicalObject a)
 {
     return CanStack(a.TypeId, a.SubtypeId, a.Flags);
 }
コード例 #26
0
ファイル: MyInventory.cs プロジェクト: fluxit/SpaceEngineers
        private int? FindFirstStackablePosition(MyObjectBuilder_PhysicalObject toStack, MyFixedPoint wantedAmount)
        {
            for (int i = 0; i < m_items.Count; ++i)
            {
                if (m_items[i].Content.CanStack(toStack) && m_items[i].Amount <= wantedAmount) return i;
            }

            return null;
        }
コード例 #27
0
ファイル: MyInventory.cs プロジェクト: fluxit/SpaceEngineers
        public void AddItemsInternal(MyFixedPoint amount, MyObjectBuilder_PhysicalObject objectBuilder, int index = -1, uint? itemId = null, bool stack = true)
        {
            Debug.Assert(amount > 0, "Adding 0 amount of item.");

            var newItem = new MyPhysicalInventoryItem() { Amount = amount, Content = objectBuilder };

            MyFixedPoint maxStack = MyFixedPoint.MaxValue;
            MyComponentDefinition compDef = null;
            if (MyDefinitionManager.Static.TryGetComponentDefinition(objectBuilder.GetId(), out compDef))
                maxStack = compDef.MaxStackAmount;

            if (index >= 0 && index < m_items.Count)
            {
                if (m_items[index].Content.CanStack(objectBuilder))
                {
                    var newStackVal = m_items[index].Amount + newItem.Amount - maxStack;
                    if (newStackVal > 0)
                    {
                        newItem.Amount = maxStack;
                        newItem.ItemId = m_items[index].ItemId;
                        m_items[index] = newItem;

                        newItem.Amount = newStackVal;
                        newItem.ItemId = GetNextItemID();
                        newItem.Content = objectBuilder.Clone() as MyObjectBuilder_PhysicalObject;
                        m_items.Add(newItem);
                    }
                    else
                    {
                        newItem.Amount += m_items[index].Amount;
                        newItem.ItemId = m_items[index].ItemId;
                        m_items[index] = newItem;
                    }
                }
                else
                {
                    newItem.ItemId = GetNextItemID();
                    m_items.Insert(index, newItem);
                }
            }
            else
            {
                bool add = true;
                bool canStackWithItself = newItem.Content.CanStack(newItem.Content);
                if (index < 0 && canStackWithItself && stack)
                {
                    int? itemPos = FindFirstStackablePosition(objectBuilder, maxStack - amount);
                    if (itemPos.HasValue)
                    {
                        newItem.ItemId = m_items[itemPos.Value].ItemId;
                        newItem.Amount += m_items[itemPos.Value].Amount;
                        m_items[itemPos.Value] = newItem;
                        add = false;
                    }
                }
                if (add)
                {
                    MyFixedPoint stackSize = canStackWithItself ? MyFixedPoint.Min(maxStack, amount) : 1;
                    var targetAmount = newItem.Amount;
                    MyFixedPoint addAmount = stackSize;
                    while (targetAmount > 0)
                    {
                        targetAmount -= stackSize;
                        if (targetAmount < 0)
                            addAmount = targetAmount + stackSize;
                        newItem.Amount = addAmount;
                        newItem.ItemId = itemId.HasValue ? itemId.Value : GetNextItemID();
                        itemId = null; // so we use NextItemID next time
                        m_items.Add(newItem);
                        newItem.Content = newItem.Content.Clone() as MyObjectBuilder_PhysicalObject;
                        Debug.Assert(newItem.Content != null);
                    }
                }
            }

            RefreshVolumeAndMass();

            VerifyIntegrity();

            OnContentsChanged();
        }
コード例 #28
0
ファイル: Shop.cs プロジェクト: rexxar-tc/ConquestPlugin
        public static int getitemidfromitemname(string itemname,ulong userID, ShopItem item)
        {
            var temp = new MyObjectBuilder_PhysicalObject();

                if (item != null)
                {
                    
                    if (item.ItemName == itemname)
                    {
                        temp = new MyObjectBuilder_Ingot() { SubtypeName = itemname };
                        ChatUtil.SendPrivateChat(userID, Convert.ToString(temp.GetHashCode()));
                        return  temp.GetHashCode();
                        
                    }
                    else
                    {
                        ChatUtil.SendPrivateChat(userID, "Please enter a valid item name.");
                    }
                }
             
            
            return 0;
        }