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);
}
