public ProtoBuf.ItemContainer Save() { ProtoBuf.ItemContainer list = Pool.Get <ProtoBuf.ItemContainer>(); list.contents = Pool.GetList <ProtoBuf.Item>(); list.UID = this.uid; list.slots = this.capacity; list.temperature = this.temperature; list.allowedContents = (int)this.allowedContents; list.allowedItem = (this.onlyAllowedItem != null ? this.onlyAllowedItem.itemid : 0); list.flags = (int)this.flags; list.maxStackSize = this.maxStackSize; if (this.availableSlots != null && this.availableSlots.Count > 0) { list.availableSlots = Pool.GetList <int>(); for (int i = 0; i < this.availableSlots.Count; i++) { list.availableSlots.Add(this.availableSlots[i]); } } for (int j = 0; j < this.itemList.Count; j++) { Item item = this.itemList[j]; if (item.IsValid()) { list.contents.Add(item.Save(true, true)); } } return(list); }
public ProtoBuf.ItemContainer Save() { ProtoBuf.ItemContainer itemContainer = Pool.Get <ProtoBuf.ItemContainer>(); itemContainer.contents = Pool.GetList <ProtoBuf.Item>(); itemContainer.UID = uid; itemContainer.slots = capacity; itemContainer.temperature = temperature; itemContainer.allowedContents = (int)allowedContents; itemContainer.allowedItem = ((onlyAllowedItem != null) ? onlyAllowedItem.itemid : 0); itemContainer.flags = (int)flags; itemContainer.maxStackSize = maxStackSize; if (availableSlots != null && availableSlots.Count > 0) { itemContainer.availableSlots = Pool.GetList <int>(); for (int i = 0; i < availableSlots.Count; i++) { itemContainer.availableSlots.Add((int)availableSlots[i]); } } for (int j = 0; j < itemList.Count; j++) { Item item = itemList[j]; if (item.IsValid()) { itemContainer.contents.Add(item.Save(true)); } } return(itemContainer); }
public override void Save(SaveInfo info) { base.Save(info); info.msg.lootableCorpse = Facepunch.Pool.Get <ProtoBuf.LootableCorpse>(); info.msg.lootableCorpse.playerName = playerName; info.msg.lootableCorpse.playerID = playerSteamID; if (!info.forDisk || containers == null) { return; } info.msg.lootableCorpse.privateData = Facepunch.Pool.Get <ProtoBuf.LootableCorpse.Private>(); info.msg.lootableCorpse.privateData.container = Facepunch.Pool.GetList <ProtoBuf.ItemContainer>(); ItemContainer[] array = containers; foreach (ItemContainer itemContainer in array) { if (itemContainer != null) { ProtoBuf.ItemContainer itemContainer2 = itemContainer.Save(); if (itemContainer2 != null) { info.msg.lootableCorpse.privateData.container.Add(itemContainer2); } } } }
public void Load(ProtoBuf.ItemContainer container) { using (TimeWarning.New("ItemContainer.Load")) { uid = container.UID; capacity = container.slots; List <Item> obj = itemList; itemList = Pool.GetList <Item>(); temperature = container.temperature; flags = (Flag)container.flags; allowedContents = (ContentsType)((container.allowedContents == 0) ? 1 : container.allowedContents); onlyAllowedItem = ((container.allowedItem != 0) ? ItemManager.FindItemDefinition(container.allowedItem) : null); maxStackSize = container.maxStackSize; availableSlots.Clear(); for (int i = 0; i < container.availableSlots.Count; i++) { availableSlots.Add((ItemSlot)container.availableSlots[i]); } using (TimeWarning.New("container.contents")) { foreach (ProtoBuf.Item content in container.contents) { Item created = null; foreach (Item item in obj) { if (item.uid == content.UID) { created = item; break; } } created = ItemManager.Load(content, created, isServer); if (created != null) { created.parent = this; created.position = content.slot; Insert(created); } } } using (TimeWarning.New("Delete old items")) { foreach (Item item2 in obj) { if (!itemList.Contains(item2)) { item2.Remove(); } } } dirty = true; Pool.FreeList(ref obj); } }
public void UpdateVisibleItems(ProtoBuf.ItemContainer msg) { for (int i = 0; i < (int)this.displayModels.Length; i++) { VisualStorageContainer.DisplayModel displayModel = this.displayModels[i]; if (displayModel != null) { UnityEngine.Object.Destroy(displayModel.displayModel); this.displayModels[i] = null; } } if (msg == null) { return; } foreach (ProtoBuf.Item content in msg.contents) { ItemDefinition itemDefinition = ItemManager.FindItemDefinition(content.itemid); GameObject vector3 = null; vector3 = (itemDefinition.worldModelPrefab == null || !itemDefinition.worldModelPrefab.isValid ? UnityEngine.Object.Instantiate <GameObject>(this.defaultDisplayModel) : itemDefinition.worldModelPrefab.Instantiate(null)); if (!vector3) { continue; } vector3.transform.position = this.displayNodes[content.slot].transform.position + new Vector3(0f, 0.25f, 0f); vector3.transform.rotation = this.displayNodes[content.slot].transform.rotation; Rigidbody rigidbody = vector3.AddComponent <Rigidbody>(); rigidbody.mass = 1f; rigidbody.drag = 0.1f; rigidbody.angularDrag = 0.1f; rigidbody.interpolation = RigidbodyInterpolation.Interpolate; rigidbody.constraints = RigidbodyConstraints.FreezePositionX | RigidbodyConstraints.FreezePositionZ; this.displayModels[content.slot].displayModel = vector3; this.displayModels[content.slot].slot = content.slot; this.displayModels[content.slot].def = itemDefinition; vector3.SetActive(true); } this.SetItemsVisible(false); base.CancelInvoke(new Action(this.ItemUpdateComplete)); base.Invoke(new Action(this.ItemUpdateComplete), 1f); }
public static LootableCorpse.Private DeserializeLengthDelimited(Stream stream, LootableCorpse.Private instance, bool isDelta) { if (!isDelta && instance.container == null) { instance.container = Pool.Get <List <ItemContainer> >(); } long position = (long)ProtocolParser.ReadUInt32(stream); position += stream.Position; while (stream.Position < position) { int num = stream.ReadByte(); if (num == -1) { throw new EndOfStreamException(); } if (num != 10) { Key key = ProtocolParser.ReadKey((byte)num, stream); if (key.Field == 0) { throw new ProtocolBufferException("Invalid field id: 0, something went wrong in the stream"); } ProtocolParser.SkipKey(stream, key); } else { instance.container.Add(ItemContainer.DeserializeLengthDelimited(stream)); } } if (stream.Position != position) { throw new ProtocolBufferException("Read past max limit"); } return(instance); }
public static StorageBox DeserializeLengthDelimited(Stream stream, StorageBox instance, bool isDelta) { long position = (long)ProtocolParser.ReadUInt32(stream); position += stream.Position; while (stream.Position < position) { int num = stream.ReadByte(); if (num == -1) { throw new EndOfStreamException(); } if (num != 10) { Key key = ProtocolParser.ReadKey((byte)num, stream); if (key.Field == 0) { throw new ProtocolBufferException("Invalid field id: 0, something went wrong in the stream"); } ProtocolParser.SkipKey(stream, key); } else if (instance.contents != null) { ItemContainer.DeserializeLengthDelimited(stream, instance.contents, isDelta); } else { instance.contents = ItemContainer.DeserializeLengthDelimited(stream); } } if (stream.Position != position) { throw new ProtocolBufferException("Read past max limit"); } return(instance); }
public static void SerializeDelta(Stream stream, ResourceExtractor instance, ResourceExtractor previous) { MemoryStream memoryStream = Pool.Get <MemoryStream>(); if (instance.fuelContents != null) { stream.WriteByte(10); memoryStream.SetLength((long)0); ItemContainer.SerializeDelta(memoryStream, instance.fuelContents, previous.fuelContents); uint length = (uint)memoryStream.Length; ProtocolParser.WriteUInt32(stream, length); stream.Write(memoryStream.GetBuffer(), 0, (int)length); } if (instance.outputContents != null) { stream.WriteByte(18); memoryStream.SetLength((long)0); ItemContainer.SerializeDelta(memoryStream, instance.outputContents, previous.outputContents); uint num = (uint)memoryStream.Length; ProtocolParser.WriteUInt32(stream, num); stream.Write(memoryStream.GetBuffer(), 0, (int)num); } Pool.FreeMemoryStream(ref memoryStream); }
public virtual void WriteToStream(Stream stream) { ItemContainer.Serialize(stream, this); }
public void Load(ProtoBuf.ItemContainer container) { ItemContainer.ContentsType contentsType; ItemDefinition itemDefinition; using (TimeWarning timeWarning = TimeWarning.New("ItemContainer.Load", 0.1f)) { this.uid = container.UID; this.capacity = container.slots; List <Item> items = this.itemList; this.itemList = Pool.GetList <Item>(); this.temperature = container.temperature; this.flags = (ItemContainer.Flag)container.flags; if (container.allowedContents == 0) { contentsType = ItemContainer.ContentsType.Generic; } else { contentsType = (ItemContainer.ContentsType)container.allowedContents; } this.allowedContents = contentsType; if (container.allowedItem != 0) { itemDefinition = ItemManager.FindItemDefinition(container.allowedItem); } else { itemDefinition = null; } this.onlyAllowedItem = itemDefinition; this.maxStackSize = container.maxStackSize; this.availableSlots.Clear(); for (int i = 0; i < container.availableSlots.Count; i++) { this.availableSlots.Add((ItemSlot)container.availableSlots[i]); } using (TimeWarning timeWarning1 = TimeWarning.New("container.contents", 0.1f)) { foreach (ProtoBuf.Item content in container.contents) { Item item = null; foreach (Item item1 in items) { if (item1.uid != content.UID) { continue; } item = item1; goto Label0; } Label0: item = ItemManager.Load(content, item, this.isServer); if (item == null) { continue; } item.parent = this; item.position = content.slot; this.Insert(item); } } using (timeWarning1 = TimeWarning.New("Delete old items", 0.1f)) { foreach (Item item2 in items) { if (this.itemList.Contains(item2)) { continue; } item2.Remove(0f); } } this.dirty = true; Pool.FreeList <Item>(ref items); } }
public static ItemContainer Deserialize(Stream stream, ItemContainer instance, bool isDelta) { if (!isDelta) { if (instance.availableSlots == null) { instance.availableSlots = Pool.Get <List <int> >(); } if (instance.contents == null) { instance.contents = Pool.Get <List <Item> >(); } } while (true) { int num = stream.ReadByte(); if (num == -1) { break; } if (num <= 32) { if (num <= 16) { if (num == 8) { instance.UID = ProtocolParser.ReadUInt32(stream); continue; } else if (num == 16) { instance.slots = (int)ProtocolParser.ReadUInt64(stream); continue; } } else if (num == 29) { instance.temperature = ProtocolParser.ReadSingle(stream); continue; } else if (num == 32) { instance.flags = (int)ProtocolParser.ReadUInt64(stream); continue; } } else if (num <= 48) { if (num == 40) { instance.allowedContents = (int)ProtocolParser.ReadUInt64(stream); continue; } else if (num == 48) { instance.maxStackSize = (int)ProtocolParser.ReadUInt64(stream); continue; } } else if (num == 56) { instance.allowedItem = (int)ProtocolParser.ReadUInt64(stream); continue; } else if (num == 64) { instance.availableSlots.Add((int)ProtocolParser.ReadUInt64(stream)); continue; } Key key = ProtocolParser.ReadKey((byte)num, stream); uint field = key.Field; if (field == 0) { throw new ProtocolBufferException("Invalid field id: 0, something went wrong in the stream"); } if (field != 100) { ProtocolParser.SkipKey(stream, key); } else if (key.WireType == Wire.LengthDelimited) { instance.contents.Add(Item.DeserializeLengthDelimited(stream)); } } return(instance); }
public void ToProto(Stream stream) { ItemContainer.Serialize(stream, this); }
public byte[] ToProtoBytes() { return(ItemContainer.SerializeToBytes(this)); }
public static void SerializeLengthDelimited(Stream stream, ItemContainer instance) { byte[] bytes = ItemContainer.SerializeToBytes(instance); ProtocolParser.WriteUInt32(stream, (uint)bytes.Length); stream.Write(bytes, 0, (int)bytes.Length); }
public static void SerializeDelta(Stream stream, ItemContainer instance, ItemContainer previous) { MemoryStream memoryStream = Pool.Get <MemoryStream>(); if (instance.UID != previous.UID) { stream.WriteByte(8); ProtocolParser.WriteUInt32(stream, instance.UID); } if (instance.slots != previous.slots) { stream.WriteByte(16); ProtocolParser.WriteUInt64(stream, (ulong)instance.slots); } if (instance.temperature != previous.temperature) { stream.WriteByte(29); ProtocolParser.WriteSingle(stream, instance.temperature); } if (instance.flags != previous.flags) { stream.WriteByte(32); ProtocolParser.WriteUInt64(stream, (ulong)instance.flags); } if (instance.allowedContents != previous.allowedContents) { stream.WriteByte(40); ProtocolParser.WriteUInt64(stream, (ulong)instance.allowedContents); } if (instance.maxStackSize != previous.maxStackSize) { stream.WriteByte(48); ProtocolParser.WriteUInt64(stream, (ulong)instance.maxStackSize); } if (instance.allowedItem != previous.allowedItem) { stream.WriteByte(56); ProtocolParser.WriteUInt64(stream, (ulong)instance.allowedItem); } if (instance.availableSlots != null) { for (int i = 0; i < instance.availableSlots.Count; i++) { int item = instance.availableSlots[i]; stream.WriteByte(64); ProtocolParser.WriteUInt64(stream, (ulong)item); } } if (instance.contents != null) { for (int j = 0; j < instance.contents.Count; j++) { Item item1 = instance.contents[j]; stream.WriteByte(162); stream.WriteByte(6); memoryStream.SetLength((long)0); Item.SerializeDelta(memoryStream, item1, item1); uint length = (uint)memoryStream.Length; ProtocolParser.WriteUInt32(stream, length); stream.Write(memoryStream.GetBuffer(), 0, (int)length); } } Pool.FreeMemoryStream(ref memoryStream); }
public void ResetToPool() { ItemContainer.ResetToPool(this); }
public virtual void ReadFromStream(Stream stream, int size, bool isDelta = false) { ItemContainer.DeserializeLength(stream, size, this, isDelta); }
public void FromProto(Stream stream, bool isDelta = false) { ItemContainer.Deserialize(stream, this, isDelta); }