コード例 #1
0
        private static ISchemeService CreateSchemeService()
        {
            var schemeServiceMock = new Mock <ISchemeService>();

            var propScheme = new PropScheme
            {
                Sid = "test-prop"
            };

            schemeServiceMock.Setup(x => x.GetScheme <PropScheme>(It.IsAny <string>()))
            .Returns(propScheme);

            var trophyTableScheme = new DropTableScheme(0, new DropTableRecordSubScheme[0])
            {
                Sid = "default"
            };

            schemeServiceMock.Setup(x => x.GetScheme <DropTableScheme>(It.IsAny <string>()))
            .Returns(trophyTableScheme);

            var monsterScheme = new MonsterScheme {
                PrimaryAct = new TacticalActStatsSubScheme {
                    Efficient = new Range <float>(10, 20)
                }
            };

            schemeServiceMock.Setup(x => x.GetScheme <MonsterScheme>(It.IsAny <string>()))
            .Returns(monsterScheme);

            var schemeService = schemeServiceMock.Object;

            return(schemeService);
        }
コード例 #2
0
ファイル: FeatureContextBase.cs プロジェクト: tgspn/Zilon
        private IActor CreateMonsterActor([NotNull] IBotPlayer player,
                                          [NotNull] MonsterScheme monsterScheme,
                                          [NotNull] IMapNode startNode)
        {
            var schemeService = Container.GetInstance <ISchemeService>();

            var monsterPerson = new MonsterPerson(monsterScheme);

            var actor = new Actor(monsterPerson, player, startNode);

            return(actor);
        }
コード例 #3
0
ファイル: MonsterPersonTests.cs プロジェクト: tgspn/Zilon
        private static MonsterPerson CreateMonster()
        {
            var monsterScheme = new MonsterScheme
            {
                PrimaryAct = new TacticalActStatsSubScheme
                {
                    Efficient = new Range <float>(1, 1)
                }
            };
            var monster = new MonsterPerson(monsterScheme);

            return(monster);
        }
コード例 #4
0
        public MonsterPerson(MonsterScheme scheme)
        {
            Scheme = scheme;

            Hp = scheme.Hp;
            TacticalActCarrier = new TacticalActCarrier
            {
                Acts = new ITacticalAct[] {
                    new MonsterTacticalAct(scheme.PrimaryAct, 1)
                }
            };

            Effects = new EffectCollection();
        }
コード例 #5
0
ファイル: Sector.cs プロジェクト: tgspn/Zilon
        private DropTableScheme[] GetMonsterDropTables(MonsterScheme monsterScheme)
        {
            if (monsterScheme.DropTableSids == null)
            {
                return(new DropTableScheme[0]);
            }

            var dropTableCount = monsterScheme.DropTableSids.Length;
            var schemes        = new DropTableScheme[dropTableCount];

            for (var i = 0; i < dropTableCount; i++)
            {
                var sid = monsterScheme.DropTableSids[i];
                schemes[i] = _schemeService.GetScheme <DropTableScheme>(sid);
            }

            return(schemes);
        }
コード例 #6
0
ファイル: MonsterPersonTests.cs プロジェクト: tgspn/Zilon
        public void Constructor_HpInScheme_ActorHpEqualsSchemeHp()
        {
            // ARRANGE
            const int expectedHp    = 100;
            var       monsterScheme = new MonsterScheme
            {
                Hp         = expectedHp,
                PrimaryAct = new TacticalActStatsSubScheme
                {
                    Efficient = new Range <float>(1, 2)
                }
            };

            // ACT
            var monster = new MonsterPerson(monsterScheme);



            // ARRANGE
            monster.Hp.Should().Be(expectedHp);
        }
コード例 #7
0
ファイル: MonsterPersonTests.cs プロジェクト: tgspn/Zilon
        public void Constructor_DefaultParams_NoException()
        {
            // ARRANGE
            var monsterScheme = new MonsterScheme
            {
                PrimaryAct = new TacticalActStatsSubScheme
                {
                    Efficient = new Range <float>(1, 2)
                }
            };

            // ACT
            Action act = () =>
            {
                var monster = new MonsterPerson(monsterScheme);
            };



            // ARRANGE
            act.Should().NotThrow();
        }