public static HumanPersonStorageData Create(HumanPerson humanPerson)
        {
            if (humanPerson is null)
            {
                throw new ArgumentNullException(nameof(humanPerson));
            }

            var storageData = new HumanPersonStorageData
            {
                Survival = humanPerson.GetModule <ISurvivalModule>().Stats.Select(x => new HumanSurvivalStatStorageData
                {
                    Type  = x.Type,
                    Value = x.ValueShare
                }).ToArray(),

                Equipments = humanPerson.GetModule <IEquipmentModule>().Select(CreateEquipmentStorageData).ToArray(),

                Inventory = humanPerson.GetModule <IInventoryModule>().CalcActualItems().Select(CreatePropStorageData)
                            .ToArray(),

                Perks = humanPerson.GetModule <IEvolutionModule>().Perks.Select(CreatePerkStorageData).ToArray()
            };

            return(storageData);
        }
Beispiel #2
0
        protected void FillSlot(HumanPerson person, IDropTableScheme?dropScheme, int slotIndex)
        {
            if (dropScheme is null)
            {
                return;
            }

            // Генерируем предметы.
            // Выбираем предмет, как экипировку в слот.
            // Если он может быть экипирован, то устанавливаем в слот.
            // Остальные дропнутые предметы складываем просто в инвентарь.
            // Если текущий предмет невозможно экипировать, то его тоже помещаем в инвентарь.

            var inventory     = person.GetModule <IInventoryModule>();
            var dropedProps   = DropResolver.Resolve(new[] { dropScheme });
            var usedEquipment = dropedProps.OfType <Equipment>().FirstOrDefault();

            if (usedEquipment != null)
            {
                var equipmentModule = person.GetModule <IEquipmentModule>();
                var canBeEquiped    = CanBeEquiped(equipmentModule, slotIndex, usedEquipment);
                if (canBeEquiped)
                {
                    AddEquipment(equipmentModule, slotIndex, usedEquipment);
                    var unusedMainWeaponDrops = dropedProps.Where(x => x != usedEquipment).ToArray();
                    foreach (var prop in unusedMainWeaponDrops)
                    {
                        AddPropToInventory(inventory, prop);
                    }
                }
                else
                {
                    foreach (var prop in dropedProps)
                    {
                        AddPropToInventory(inventory, prop);
                    }
                }
            }
            else
            {
                foreach (var prop in dropedProps)
                {
                    AddPropToInventory(inventory, prop);
                }
            }
        }
        public HumanPerson Restore(ISchemeService schemeService,
                                   ISurvivalRandomSource survivalRandomSource,
                                   IPropFactory propFactory)
        {
            if (schemeService is null)
            {
                throw new ArgumentNullException(nameof(schemeService));
            }

            if (survivalRandomSource is null)
            {
                throw new ArgumentNullException(nameof(survivalRandomSource));
            }

            if (propFactory is null)
            {
                throw new ArgumentNullException(nameof(propFactory));
            }

            var storedPerson = this;

            var personScheme = schemeService.GetScheme <IPersonScheme>("human-person");

            var inventory = new InventoryModule();

            var evolutionData = new EvolutionModule(schemeService);

            RestoreEvolutionData(schemeService, storedPerson, evolutionData);

            var person = new HumanPerson(personScheme);

            //TODO Создать необходимые модули и заполнить их.

            foreach (var survivalStoredItem in storedPerson.Survival)
            {
                var normalizedValueShare = RangeHelper.NormalizeShare(survivalStoredItem.Value);

                var stat = person.GetModule <ISurvivalModule>().Stats.Single(x => x.Type == survivalStoredItem.Type);

                stat.SetShare(normalizedValueShare);
            }

            foreach (var storedProp in storedPerson.Inventory)
            {
                var   propScheme = schemeService.GetScheme <IPropScheme>(storedProp.Sid);
                IProp prop;
                switch (storedProp.Type)
                {
                case PropType.Resource:
                    prop = propFactory.CreateResource(propScheme, storedProp.Count);
                    break;

                case PropType.Equipment:
                    var equipment = propFactory.CreateEquipment(propScheme);
                    equipment.Durable.Value = storedProp.Durable;
                    prop = equipment;

                    break;

                default:
                    throw new Exception();
                }

                inventory.Add(prop);
            }

            for (var i = 0; i < storedPerson.Equipments.Length; i++)
            {
                var storedEquipment = storedPerson.Equipments[i];

                if (storedEquipment == null)
                {
                    continue;
                }

                var equipmentScheme = schemeService.GetScheme <IPropScheme>(storedEquipment.Sid);

                var equipment = propFactory.CreateEquipment(equipmentScheme);
                equipment.Durable.Value = storedEquipment.Durable;

                person.GetModule <IEquipmentModule>()[i] = equipment;
                //TODO Уменьшать прочность согласно сохранённым данным
            }

            return(person);
        }