[RUST] Custom save\load system

        private class SavedItems
        {
            [JsonProperty("Пояс")]
            public SavedItem[] Belt;
            [JsonProperty("Основной инвентарь")]
            public SavedItem[] Main;
            [JsonProperty("Одежда")]
            public SavedItem[] Wear;

            [JsonConstructor]
            public SavedItems() { }

            public SavedItems(BasePlayer player)
            {
                Belt = GetItems(player.inventory.containerBelt).ToArray();
                Main = GetItems(player.inventory.containerMain).ToArray();
                Wear = GetItems(player.inventory.containerWear).ToArray();
            }


            public void AddToMain(List<Item> items)
            {
                if (Main == null)
                {
                    Main = ToSaved(items).ToArray();
                    return;
                }
                var n = ToSaved(items).ToArray();
                Array.Resize(ref Main, Main.Length + n.Length);
                n.CopyTo(Main,Main.Length);
            }

            public int Restore(BasePlayer player)
            {
                var items = Restore(player.inventory.containerBelt, Belt);
                items += Restore(player.inventory.containerMain, Main);
                items += Restore(player.inventory.containerWear, Wear);
                return items;
            }

            private int Restore(ItemContainer container, SavedItem[] items)
            {
                if (items == null)
                {
                    return 0;
                }

                int amount = 0;
                foreach (var savedItem in items)
                {
                    var item = savedItem.Load();
                    if (item == null)
                    {
                        continue;
                    }
                    amount++;
                    var moveToContainer = container.Insert(item);
                    if (moveToContainer)
                        continue;
                    item.Drop(container.dropPosition, container.dropVelocity);
                }

                return amount;
            }

            private IEnumerable<SavedItem> GetItems(ItemContainer container)
            {
                return ToSaved(container.itemList);
            }

            private IEnumerable<SavedItem> ToSaved(List<Item> items)
            {
                var amount = items.Count;
                for (int i = 0; i < amount; i++)
                {
                    var item = items.GetRandom();
                    if (item != null)
                    {
                        yield return SavedItem.SaveItem(item);
                        item.RemoveFromContainer();
                        item.Remove();
                    }
                }
                ItemManager.DoRemoves();
            }
        }


...

 #region Custom Save\Load System

        public class SavedItem
        {
            public byte[] Item;
            public SavedEntity HeldEntity;
            public SavedEntity WorldEntity;

            public Item Load()
            {
                HeldEntity?.Load();

                if (WorldEntity != null)
                {
                    var worldEntity = WorldEntity.Load();
                    return worldEntity.GetItem();
                }
                var protoItem = ProtoBuf.Item.Deserialize(Item);
                var load = ItemManager.Load(protoItem, null, true);
                return load;
            }

            public static SavedItem SaveItem(Item item)
            {
                var world = item.GetWorldEntity();
                var held = item.GetHeldEntity();
                var savedItem = new SavedItem
                {
                    Item = world ? null : item.Save(true).ToProtoBytes(),
                    HeldEntity = held ? SavedEntity.SaveEntityWithChilds(held) : null,
                    WorldEntity = world ? SavedEntity.SaveEntityWithChilds(world) : null
                };
                return savedItem;
            }
        }

        public class SavedEntity
        {
            public byte[] Entity;
            public List<byte[]> Childs = new List<byte[]>();

            public BaseEntity Load()
            {
                var main = LoadEntity(Entity);
                Childs.ForEach(x => LoadEntity(x).SetParent(main));
                return main;
            }

            public static SavedEntity SaveEntityWithChilds(BaseEntity entity)
            {
                var savedData = new SavedEntity
                {
                    Entity = SaveEntity(entity)
                };
                entity.children.ForEach(x => savedData.Childs.Add(SaveEntity(x)));
                return savedData;
            }
            public static byte[] SaveEntity(BaseEntity entity)
            {
                var saveInfo = new BaseNetworkable.SaveInfo { forDisk = true };
                using (saveInfo.msg = Pool.Get<Entity>())
                {
                    entity.Save(saveInfo);
                    return saveInfo.msg.ToProtoBytes();
                }
            }

            public static BaseEntity LoadEntity(byte[] protoBytes)
            {
                var entData = ProtoBuf.Entity.Deserialize(protoBytes);
                var entity = GameManager.server.CreateEntity(StringPool.Get(entData.baseNetworkable.prefabID),
                    entData.baseEntity.pos, Quaternion.Euler(entData.baseEntity.rot));
                if (!entity)
                {
                    Interface.Oxide.LogWarning("[{0}] Failed to spawn entity {1}!", nameof(FallingPlatforms),
                        entData.baseNetworkable.prefabID);
                    return null;
                }

                entity.InitLoad(entData.baseNetworkable.uid);

                var info = new BaseNetworkable.LoadInfo { fromDisk = true, msg = entData };
                entity.Spawn();
                entity.Load(info);
                return entity;
            }
        }


        #endregion