Exemplo n.º 1
0
        public async Task <Tuple <Disarming, Disarming, Disarming> > GetDisarmingProcedure(int beepsLevel)
        {
            await _learnNetworkTask;

            _network.StopLearning();
            var procedure = _network.Run(new double[] { beepsLevel });
            var result    = new Disarming[3];
            var mins      = Enumerable.Repeat(100.0, 3).ToArray();

            foreach (var bomb in _bombTypeses)
            {
                var abs1 = Math.Abs((int)bomb.FirstStageDisarming - procedure[0]);
                var abs2 = Math.Abs((int)bomb.SecondStageDisarming - procedure[1]);
                var abs3 = Math.Abs((int)bomb.ThirdStageDisarming - procedure[2]);
                if (mins[0] > abs1)
                {
                    mins[0]   = abs1;
                    result[0] = bomb.FirstStageDisarming;
                }
                if (mins[1] > abs2)
                {
                    mins[1]   = abs2;
                    result[1] = bomb.SecondStageDisarming;
                }
                if (mins[2] > abs3)
                {
                    mins[2]   = abs3;
                    result[2] = bomb.ThirdStageDisarming;
                }
            }
            return(Tuple.Create(result[0], result[1], result[2]));
        }
Exemplo n.º 2
0
 public ExplosiveBomb()
 {
     BeepsLevel           = 4;
     FirstStageDisarming  = Disarming.CutRedWire;
     SecondStageDisarming = Disarming.CutGreenWire;
     ThirdStageDisarming  = Disarming.CutBlueWire;
 }
Exemplo n.º 3
0
 public DemolitionExplosiveBomb()
 {
     BeepsLevel           = 3;
     FirstStageDisarming  = Disarming.CutGreenWire;
     SecondStageDisarming = Disarming.CutControlWire;
     ThirdStageDisarming  = Disarming.CutYellowWire;
 }
Exemplo n.º 4
0
 public Mine()
 {
     BeepsLevel           = 5;
     FirstStageDisarming  = Disarming.CutRedWire;
     SecondStageDisarming = Disarming.CutGreenWire;
     ThirdStageDisarming  = Disarming.CutBlueWire;
 }
 public DemolitionBomb()
 {
     BeepsLevel           = 2;
     FirstStageDisarming  = Disarming.CutBlueWire;
     SecondStageDisarming = Disarming.CutGreenWire;
     ThirdStageDisarming  = Disarming.CutRedWire;
 }
 public BallBomb()
 {
     BeepsLevel           = 1;
     FirstStageDisarming  = Disarming.CutControlWire;
     SecondStageDisarming = Disarming.CutYellowWire;
     ThirdStageDisarming  = Disarming.CutRedWire;
 }
        private BombDecisionTree DisarmingDecisionTree(LearningModel model, string idBomb, Disarming step1, Disarming step2, Disarming step3)
        {
            switch (int.Parse(idBomb))
            {
            case 1:
                _typeBomb = BombTypes.Ball;
                break;

            case 2:
                _typeBomb = BombTypes.Demolition;
                break;

            case 3:
                _typeBomb = BombTypes.DemolitionExplosive;
                break;

            case 4:
                _typeBomb = BombTypes.Explosive;
                break;

            case 5:
                _typeBomb = BombTypes.Mine;
                break;
            }

            var result = model.Model.Predict(new BombDecisionTree
            {
                bomb = _typeBomb,
                FirstStageDisarming  = step1,
                SecondStageDisarming = step2,
                ThirdStageDisarming  = step3
            });

            return(result);
        }
        public async Task <Tuple <Disarming, Disarming, Disarming> > GetDisarmingProcedure(int beepsLevel)
        {
            await _learnTreeTask;
            var   result = new Disarming[3];

            switch (beepsLevel)
            {
            case 1:
                _typeBomb = BombTypes.Ball;
                break;

            case 2:
                _typeBomb = BombTypes.Demolition;
                break;

            case 3:
                _typeBomb = BombTypes.DemolitionExplosive;
                break;

            case 4:
                _typeBomb = BombTypes.Explosive;
                break;

            case 5:
                _typeBomb = BombTypes.Mine;
                break;
            }

            var _result = _model.Model.Predict(new BombDecisionTree
            {
                bomb = _typeBomb
            });
            var _resultStr = _result.ToString();

            if (String.Compare(_resultStr, "true") == 1)
            {
                switch (beepsLevel)
                {
                case 0:
                    result[0] = Disarming.CutControlWire;
                    result[1] = Disarming.CutYellowWire;
                    result[2] = Disarming.CutRedWire;
                    break;

                case 1:
                    result[0] = Disarming.CutBlueWire;
                    result[1] = Disarming.CutGreenWire;
                    result[2] = Disarming.CutRedWire;
                    break;

                case 2:
                    result[0] = Disarming.CutGreenWire;
                    result[1] = Disarming.CutControlWire;
                    result[2] = Disarming.CutYellowWire;
                    break;

                case 3:
                    result[0] = Disarming.CutRedWire;
                    result[1] = Disarming.CutGreenWire;
                    result[2] = Disarming.CutBlueWire;
                    break;

                case 4:
                    result[0] = Disarming.CutRedWire;
                    result[1] = Disarming.CutGreenWire;
                    result[2] = Disarming.CutBlueWire;
                    break;
                }
            }

            return(Tuple.Create(result[0], result[1], result[2]));
        }
        public async Task <Tuple <Disarming, Disarming, Disarming> > GetDisarmingProcedure(int beepsLevel)
        {
            await   _learnGenTask;
            Genetic findResultForBomb = new Genetic();
            bool    foundResult       = false;
            string  currentBomb       = "";
            var     result            = new Disarming[3];

            switch (beepsLevel)
            {
            case 1: currentBomb = "10000"; break;

            case 2: currentBomb = "01000"; break;

            case 3: currentBomb = "00100"; break;

            case 4: currentBomb = "00010"; break;

            case 5: currentBomb = "00001"; break;

            default: currentBomb = "00000"; break;
            }

            //Console.WriteLine("Wkładam = {0}, {1}", currentBomb, beepsLevel);
            string resultOfFunction = findResultForBomb.searchForResult(currentBomb, beepsLevel);

            if (resultOfFunction == currentBomb)
            {
                foundResult = true;
            }

            if (foundResult == true)
            {
                switch (resultOfFunction)
                {
                case "10000":         //Ball
                    result[0] = Disarming.CutControlWire;
                    result[1] = Disarming.CutYellowWire;
                    result[2] = Disarming.CutRedWire;
                    break;

                case "01000":         //DemolitionBomb
                    result[0] = Disarming.CutBlueWire;
                    result[1] = Disarming.CutGreenWire;
                    result[2] = Disarming.CutRedWire;
                    break;

                case "00100":         //DemolitionExplosiveBomb
                    result[0] = Disarming.CutGreenWire;
                    result[1] = Disarming.CutControlWire;
                    result[2] = Disarming.CutYellowWire;
                    break;

                case "00010":         //ExplosiveBomb
                    result[0] = Disarming.CutRedWire;
                    result[1] = Disarming.CutGreenWire;
                    result[2] = Disarming.CutBlueWire;
                    break;

                case "00001":         //Mine
                    result[0] = Disarming.CutRedWire;
                    result[1] = Disarming.CutGreenWire;
                    result[2] = Disarming.CutBlueWire;
                    break;
                }
            }

            return(Tuple.Create(result[0], result[1], result[2]));
        }