示例#1
0
        private static void consumer_Listener(IMessage message)
        {
            string taskId = string.Empty;

            try
            {
                ITextMessage msg = (ITextMessage)message;
                Dictionary <string, object> param      = MqConsumerBase.ReadMapFromJson(msg.Text);
                IPerfApiChariot             chariotBll = ChariotFactory.GetChariot(param["deviceModel"].ToString());

                log.Info(msg.NMSMessageId, taskId);
                if (msg.NMSType == "TestThroughput")
                {
                    taskId = param["taskId"].ToString();
                    string        param1      = param["param1"].ToString();
                    string        param2      = param["param2"].ToString();
                    string        param3      = param["param3"].ToString();
                    string        param4      = param["param4"].ToString();
                    string        param5      = param["param5"].ToString();
                    string        param6      = param["param6"].ToString();
                    string        ping        = "ping 127.0.0.1 -n 2 >nul";
                    List <string> commandList = new List <string>()
                    {
                        param1, ping, param2, ping, param3, ping, param4, ping, param5, ping, param6, ping + "&exit"
                    };
                    CmdHelper.SendCmdCommandList(commandList);
                    WriteLogAndSendResponse(msg.NMSMessageId, "回复消息,我已经完成任务!", StepTestStatus.测试通过, "", param["projectId"].ToString(), param["caseId"].ToString(), param["stepId"].ToString());
                }
                else if (msg.NMSType == "AnalysisResult")
                {
                    taskId = param["taskId"].ToString();
                    List <string> resultList = new List <string>();
                    string        filePath1  = param["FilePath1"].ToString();
                    //string filePath2 = param["FilePath2"].ToString();
                    //string filePath3 = param["FilePath3"].ToString();
                    resultList.Add(chariotBll.GetTestValue(filePath1));
                    //resultList.Add(AnalysisResult.GetTestValue(filePath2));
                    //resultList.Add(AnalysisResult.GetTestValue(filePath3));
                    string result = string.Join(",", resultList.ToArray());
                    WriteLogAndSendResponse(msg.NMSMessageId, "回复消息,我已经完成任务!", StepTestStatus.测试通过, "", param["projectId"].ToString(), param["caseId"].ToString(), param["stepId"].ToString());
                }
            }
            catch (Exception ex)
            {
                log.Info(ex.Message, taskId);
            }
        }
示例#2
0
        public IGame BuildGame()
        {
            // This composition of the game using poor man's DI does not support automatic registration.
            // To give a fairer view in the benchmark, it invokes the reflection used for automatic registration,
            // though it discards the results.
            var cityTypes = TypeConstraints.Cities;
            var cityFactoryTypes = TypeConstraints.CityFactories;
            var terrainTypes = TypeConstraints.Terrains;
            var terrainFactoryTypes = TypeConstraints.TerrainFactories;
            var unitTypes = TypeConstraints.Units;
            var unitFactoryTypes = TypeConstraints.UnitFactories;
            var productionProjectTypes = TypeConstraints.ProductionProjects;

            // :::: TURN-TAKING ::::
            var players = new[] { new Player("Red"), new Player("Blue") };
            var turnTaking = new RoundRobinTurns(players);

            // :::: UNIT COMBAT ::::
            var unitCombat = new AttackerIsAlwaysVictorious();

            // :::: WORLD MAP COLLECTIONS ::::
            var cities = new HashSet<ICity>(new CityEqualityComparer());
            var terrains = new HashSet<ITerrain>(new TerrainEqualityComparer());
            var units = new HashSet<IUnit>(new UnitEqualityComparer());

            // :::: CITIES ::::
            var cityFactory = new CityFactory(
                () => new FriendlyCityManagementOnly<City>(
                          new ProductionAccumulation<City>(
                              new FixedGeneratedProduction<City>(
                                  new NoCityGrowth<City>(new City())
                                  ), units, turnTaking
                              ), turnTaking
                          ));

            // :::: TERRAINS ::::
            var forestsFactory = new ForestsFactory(() => new Forests());
            var hillsFactory = new HillsFactory(() => new Hills());
            var mountainsFactory = new MountainsFactory(() => new Mountains());
            var oceansFactory = new OceansFactory(() => new Oceans());
            var plainsFactory = new PlainsFactory(() => new Plains());

            // :::: UNITS ::::
            var archerFactory = new ArcherFactory(
                () => new FriendlyUnitManagementOnly<Archer>(
                          new FortificationAction<Archer>(
                              new NoEntranceToImpassableTerrain<Archer>(
                                  new NoFriendlyUnitStacking<Archer>(
                                      new LimitedMoveRange<Archer>(
                                          new OneToOneCombatEngagement<Archer>(
                                              new CityConquest<Archer>(
                                                  new RestorationOfMoves<Archer>(
                                                      new MoveCosts<Archer>(
                                                          new Movability<Archer>(new Archer())
                                                          ), turnTaking
                                                      ), cities
                                                  ), units, unitCombat
                                              )
                                          ), units
                                      ), terrains
                                  )
                              ), turnTaking
                          ));

            var chariotFactory = new ChariotFactory(
                () => new FriendlyUnitManagementOnly<Chariot>(
                          new FortificationAction<Chariot>(
                              new NoEntranceToImpassableTerrain<Chariot>(
                                  new NoFriendlyUnitStacking<Chariot>(
                                      new LimitedMoveRange<Chariot>(
                                          new OneToOneCombatEngagement<Chariot>(
                                              new CityConquest<Chariot>(
                                                  new RestorationOfMoves<Chariot>(
                                                      new MoveCosts<Chariot>(
                                                          new Movability<Chariot>(new Chariot())
                                                          ), turnTaking
                                                      ), cities
                                                  ), units, unitCombat
                                              )
                                          ), units
                                      ), terrains
                                  )
                              ), turnTaking
                          ));

            var legionFactory = new LegionFactory(
                () => new FriendlyUnitManagementOnly<Legion>(
                          new NoEntranceToImpassableTerrain<Legion>(
                              new NoFriendlyUnitStacking<Legion>(
                                  new LimitedMoveRange<Legion>(
                                      new OneToOneCombatEngagement<Legion>(
                                          new CityConquest<Legion>(
                                              new RestorationOfMoves<Legion>(
                                                  new MoveCosts<Legion>(
                                                      new Movability<Legion>(new Legion())
                                                      ), turnTaking
                                                  ), cities
                                              ), units, unitCombat
                                          )
                                      ), units
                                  ), terrains
                              ), turnTaking
                          ));

            var settlerFactory = new SettlerFactory(
                () => new FriendlyUnitManagementOnly<Settler>(
                          new CityBuildingAction<Settler>(
                              new NoEntranceToImpassableTerrain<Settler>(
                                  new NoFriendlyUnitStacking<Settler>(
                                      new LimitedMoveRange<Settler>(
                                          new OneToOneCombatEngagement<Settler>(
                                              new RestorationOfMoves<Settler>(
                                                  new MoveCosts<Settler>(
                                                      new Movability<Settler>(new Settler())
                                                      ), turnTaking
                                                  ), units, unitCombat
                                              )
                                          ), units
                                      ), terrains
                                  ), units, cities, cityFactory
                              ), turnTaking
                          ));

            // :::: WORLD MAP LAYERS ::::
            var cityLayer = new SimpleFixedCityLayer(cities, cityFactory);

            var terrainLayer = new SimpleFixedTerrainLayer(terrains,
                                                           hillsFactory,
                                                           mountainsFactory,
                                                           oceansFactory,
                                                           plainsFactory);

            var unitLayer = new SimpleFixedUnitLayer(units, archerFactory, legionFactory, settlerFactory);

            // :::: WORLD AGE ::::
            var worldAge = new DeceleratingWorldAge(turnTaking);

            // :::: WINNER STRATEGY ::::
            var winnerStrategy = new CityConquerorWins(cities);

            // :::: PRODUCTION PROJECTS ::::
            var productionProjects = new Dictionary<string, IProductionProject>
            {
                ["Archer"] = new ArcherProject(archerFactory),
                ["Chariot"] = new ChariotProject(chariotFactory),
                ["Legion"] = new LegionProject(legionFactory),
                ["Settler"] = new SettlerProject(settlerFactory),
            };

            // :::: GAME ::::
            var game = new ExtenCivGame(cityLayer, terrainLayer, unitLayer,
                                        turnTaking, worldAge, winnerStrategy, productionProjects)
            {
                ContainerName = "Manual/SemiCiv"
            };

            return game;
        }