public void PerkLevelUpTest()
        {
            // ARRANGE
            var schemeServiceMock = new Mock <ISchemeService>();

            schemeServiceMock.Setup(x => x.GetSchemes <IPerkScheme>())
            .Returns(new IPerkScheme[]
            {
                new PerkScheme
                {
                    Levels = new[]
                    {
                        new PerkLevelSubScheme
                        {
                            MaxValue = 2,
                            Jobs     = Array.Empty <IJobSubScheme>()
                        }
                    }
                }
            });
            var schemeService = schemeServiceMock.Object;

            var evolutionData = new EvolutionModule(schemeService);

            var perk = evolutionData.Perks[0];

            evolutionData.PerkLevelUp(perk);

            // ACT
            evolutionData.PerkLevelUp(perk);

            // ASSERT
            evolutionData.Perks.Length.Should().Be(1);
            evolutionData.Perks[0].CurrentLevel.Sub.Should().Be(2);
        }
        private static void RestoreEvolutionData(ISchemeService schemeService,
                                                 HumanPersonStorageData storedPerson,
                                                 EvolutionModule evolutionData)
        {
            var perksFromSave = new List <IPerk>();

            foreach (var storedPerk in storedPerson.Perks)
            {
                var perkScheme = schemeService.GetScheme <IPerkScheme>(storedPerk.Sid);

                var perk = new Perk
                {
                    Scheme = perkScheme
                };

                if (storedPerk.Level != null)
                {
                    perk.CurrentLevel = new PerkLevel(storedPerk.Level.Value, storedPerk.SubLevel.Value);
                }

                // TODO Доработать, когда будет доработана прокачка больше, чем на один лвл
                var currentLevelScheme = perkScheme.Levels[0];

                perk.CurrentJobs = currentLevelScheme.Jobs.Select(job => new PerkJob(job)
                {
                    IsComplete = storedPerk.Jobs.Single(storedJob => storedJob.Type == job.Type && storedJob.Scope == job.Scope).IsComplete,
                    Progress   = storedPerk.Jobs.Single(storedJob => storedJob.Type == job.Type && storedJob.Scope == job.Scope).Progress,
                }).ToArray();

                perksFromSave.Add(perk);
            }
            evolutionData.SetPerksForced(perksFromSave);
        }
        public IPerson Create(string personSchemeSid, IFraction fraction)
        {
            var personScheme = _schemeService.GetScheme <IPersonScheme>(personSchemeSid);

            var person = new HumanPerson(personScheme, fraction);

            var attributes = new[]
            {
                new PersonAttribute(PersonAttributeType.PhysicalStrength, 10),
                new PersonAttribute(PersonAttributeType.Dexterity, 10),
                new PersonAttribute(PersonAttributeType.Perception, 10),
                new PersonAttribute(PersonAttributeType.Constitution, 10)
            };
            var attributesModule = new AttributesModule(attributes);

            person.AddModule(attributesModule);

            var inventoryModule = new InventoryModule();

            person.AddModule(inventoryModule);

            var equipmentModule = new EquipmentModule(personScheme.Slots);

            person.AddModule(equipmentModule);

            var сonditionModule = new ConditionsModule();

            person.AddModule(сonditionModule);

            var evolutionModule = new EvolutionModule(_schemeService);

            person.AddModule(evolutionModule);

            var survivalModule = new HumanSurvivalModule(personScheme, _survivalRandomSource, attributesModule,
                                                         сonditionModule, evolutionModule, equipmentModule);

            person.AddModule(survivalModule);

            var defaultActScheme  = _schemeService.GetScheme <ITacticalActScheme>(person.Scheme.DefaultActs.First());
            var defaultActSchemes = new[] { defaultActScheme };
            var combatActModule   = new CombatActModule(
                defaultActSchemes,
                equipmentModule,
                сonditionModule,
                evolutionModule);

            person.AddModule(combatActModule);

            var combatStatsModule = new CombatStatsModule(evolutionModule, equipmentModule);

            person.AddModule(combatStatsModule);

            var diseaseModule = new DiseaseModule(сonditionModule);

            person.AddModule(diseaseModule);

            return(person);
        }
Exemple #4
0
        public IPerson Create(string personSchemeSid)
        {
            var personScheme = _schemeService.GetScheme <IPersonScheme>(personSchemeSid);

            var person = new HumanPerson(personScheme);

            var attributeModule = RollAndAddPersonAttributesToPerson(person);

            var movingModule = new MovingModule(attributeModule);

            person.AddModule(movingModule);

            var inventoryModule = new InventoryModule();

            person.AddModule(inventoryModule);

            var equipmentModule = new EquipmentModule(personScheme.Slots);

            person.AddModule(equipmentModule);

            var effectsModule = new EffectsModule();

            person.AddModule(effectsModule);

            var evolutionModule = new EvolutionModule(_schemeService);

            person.AddModule(evolutionModule);
            RollTraitPerks(evolutionModule);

            var survivalModule = new HumanSurvivalModule(personScheme, _survivalRandomSource, attributeModule, effectsModule, evolutionModule, equipmentModule)
            {
                PlayerEventLogService = PlayerEventLogService
            };

            person.AddModule(survivalModule);

            RollStartEquipment(inventoryModule, person);

            var defaultActScheme = _schemeService.GetScheme <ITacticalActScheme>(person.Scheme.DefaultAct);
            var combatActModule  = new CombatActModule(defaultActScheme, equipmentModule, effectsModule, evolutionModule);

            person.AddModule(combatActModule);

            var combatStatsModule = new CombatStatsModule(evolutionModule, equipmentModule);

            person.AddModule(combatStatsModule);

            var diseaseModule = new DiseaseModule();

            person.AddModule(diseaseModule);

            person.PlayerEventLogService = PlayerEventLogService;

            return(person);
        }
Exemple #5
0
        public IPerson Create(string personSchemeSid, IFraction fraction)
        {
            var personScheme = SchemeService.GetScheme <IPersonScheme>(personSchemeSid);

            var person = new HumanPerson(personScheme, fraction);

            var attributeModule = RollAndAddPersonAttributesToPerson(person);

            var movingModule = new MovingModule(attributeModule);

            person.AddModule(movingModule);

            var inventoryModule = new InventoryModule();

            person.AddModule(inventoryModule);

            var notNullSlots    = personScheme.Slots.Select(x => x !).ToArray();
            var equipmentModule = new EquipmentModule(notNullSlots);

            person.AddModule(equipmentModule);

            var effectsModule = new ConditionsModule();

            person.AddModule(effectsModule);

            var evolutionModule = new EvolutionModule(SchemeService);

            person.AddModule(evolutionModule);
            RollTraitPerks(evolutionModule);

            var survivalModule = new HumanSurvivalModule(personScheme, _survivalRandomSource, attributeModule,
                                                         effectsModule, evolutionModule, equipmentModule)
            {
                PlayerEventLogService = PlayerEventLogService
            };

            person.AddModule(survivalModule);

            RollStartEquipment(inventoryModule, person);

            if (person.Scheme.DefaultActs is null)
            {
                throw new InvalidOperationException();
            }

            var defaultActSchemes =
                person.Scheme.DefaultActs.Select(x => SchemeService.GetScheme <ITacticalActScheme>(x));
            var combatActModule = new CombatActModule(
                defaultActSchemes,
                equipmentModule,
                effectsModule,
                evolutionModule);

            person.AddModule(combatActModule);

            var combatStatsModule = new CombatStatsModule(evolutionModule, equipmentModule);

            person.AddModule(combatStatsModule);

            var diseaseModule = new DiseaseModule(effectsModule);

            person.AddModule(diseaseModule);

            var fowModule = new FowData();

            person.AddModule(fowModule);

            person.PlayerEventLogService = PlayerEventLogService;

            return(person);
        }
        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);
        }