Exemplo n.º 1
0
        public static Instruction[,] GetRules(int ruleSeed)
        {
            var random  = new MonoRandom(ruleSeed);
            var weights = new WeightMap <Instruction, string>(i => i.Key);
            var rules   = new Instruction[NumStages, 4];

            for (int i = 0; i < NumStages; ++i)
            {
                for (int j = 0; j < 4; ++j)
                {
                    var digit = random.Next(1, 5);
                    var stage = random.Next(1, i + 1);

                    var instructions = new List <Instruction>()
                    {
                        Instruction.Position1, Instruction.Position2, Instruction.Position3, Instruction.Position4, Instruction.PressDigit(digit)
                    };
                    if (i > 0)
                    {
                        var instruction = i % 2 == 0 ? Instruction.PressLabelFromStage(stage) :
                                          Instruction.PressPositionFromStage(stage);
                        if (i > 2)
                        {
                            weights.SetWeight(instruction, 1);
                        }
                        instructions.Add(instruction);
                    }

                    var instruction2 = weights.Roll(instructions, random);
                    rules[i, j] = instruction2;
                }
            }
            return(rules);
        }
Exemplo n.º 2
0
        public static RuleSet GetRules(int ruleSeed)
        {
            if (ruleSeed == 1)
            {
                return(new RuleSet(
                           new[] {
                    new InitialRule(new List <Condition <ButtonData> >()
                    {
                        ButtonColour(Colour.Blue), ButtonLabel(Label.Abort)
                    }, InitialSolution.Hold),
                    new InitialRule(new List <Condition <ButtonData> >()
                    {
                        Condition <ButtonData> .MoreThanNBatteries(1), ButtonLabel(Label.Detonate)
                    }, InitialSolution.Tap),
                    new InitialRule(new List <Condition <ButtonData> >()
                    {
                        ButtonColour(Colour.White), Condition <ButtonData> .IndicatorLit("CAR")
                    }, InitialSolution.Hold),
                    new InitialRule(new List <Condition <ButtonData> >()
                    {
                        Condition <ButtonData> .MoreThanNBatteries(2), Condition <ButtonData> .IndicatorLit("FRK")
                    }, InitialSolution.Tap),
                    new InitialRule(new List <Condition <ButtonData> >()
                    {
                        ButtonColour(Colour.Yellow)
                    }, InitialSolution.Hold),
                    new InitialRule(new List <Condition <ButtonData> >()
                    {
                        ButtonColour(Colour.Red), ButtonLabel(Label.Hold)
                    }, InitialSolution.Tap),
                    new InitialRule(InitialSolution.Hold)
                },
                           new[] {
                    new HeldRule(Colour.Blue, new HeldSolution(HeldSolutionType.ReleaseOnTimerDigit, 4)),
                    new HeldRule(Colour.White, new HeldSolution(HeldSolutionType.ReleaseOnTimerDigit, 1)),
                    new HeldRule(Colour.Yellow, new HeldSolution(HeldSolutionType.ReleaseOnTimerDigit, 5)),
                    new HeldRule(null, new HeldSolution(HeldSolutionType.ReleaseOnTimerDigit, 1)),
                }
                           ));
            }

            var random                    = new MonoRandom(ruleSeed);
            var conditionWeights          = new WeightMap <Condition <ButtonData>, string>(c => c.Key);
            var initialInstructionWeights = new WeightMap <InitialSolution, InitialSolution>(s => s);

            initialInstructionWeights.SetWeight(InitialSolution.Tap, 0.1f);
            initialInstructionWeights.SetWeight(InitialSolution.TapWhenSecondsMatch, 0.05f);
            var heldInstructionWeights = new WeightMap <HeldSolution, string>(s => s.Key);

            // Build condition lists.
            var PrimaryConditions = new List <Condition <ButtonData> >()
            {
                ButtonColour(Colour.Red), ButtonColour(Colour.Blue), ButtonColour(Colour.Yellow), ButtonColour(Colour.White), Condition <ButtonData> .MoreThanNBatteries(1), Condition <ButtonData> .MoreThanNBatteries(2)
            };
            var IndicatorColorConditions = new List <Colour?>()
            {
                Colour.Red, Colour.Blue, Colour.Yellow, Colour.White
            };
            var SecondaryConditions = new List <Condition <ButtonData> >()
            {
                ButtonLabel(Label.Press), ButtonLabel(Label.Hold), ButtonLabel(Label.Abort), ButtonLabel(Label.Detonate)
            };

            for (int i = 0; i < 3; ++i)
            {
                SecondaryConditions.Add(Condition <ButtonData> .IndicatorLit(random.Pick(Utils.IndicatorLabels)));
            }

            var ports = new List <PortType>()
            {
                PortType.DviD, PortType.PS2, PortType.RJ45, PortType.StereoRCA, PortType.Parallel, PortType.Serial
            };

            for (int i = 0; i < 3; ++i)
            {
                var port = Utils.RemoveRandom(ports, random);
                SecondaryConditions.Add(Condition <ButtonData> .Port(port));
            }
            foreach (var port in ports)
            {
                PrimaryConditions.Add(Condition <ButtonData> .Port(port));
            }
            PrimaryConditions.Add(Condition <ButtonData> .EmptyPortPlate());
            SecondaryConditions.Add(Condition <ButtonData> .SerialNumberStartsWithLetter());
            SecondaryConditions.Add(Condition <ButtonData> .SerialNumberIsOdd());

            // Generate initial rules.
            var initialRules = new List <InitialRule>();

            while (initialRules.Count < MaxInitialRules && PrimaryConditions.Count > 0)
            {
                var query = Utils.RemoveRandom(PrimaryConditions, random);
                if (random.Next(2) == 0)
                {
                    initialRules.Add(CreateInitialRule(new List <Condition <ButtonData> >()
                    {
                        query
                    }, initialInstructionWeights, random));
                }
                else
                {
                    initialRules.Add(CreateInitialRule(new List <Condition <ButtonData> >()
                    {
                        query, Utils.RemoveRandom(SecondaryConditions, random)
                    }, initialInstructionWeights, random));
                }
            }
            initialRules.Add(new InitialRule(InitialSolution.Hold));

            // Generate held rules.
            var heldRules = new List <HeldRule>();

            while (heldRules.Count < MaxHeldRules && IndicatorColorConditions.Count > 0)
            {
                var condition = Utils.RemoveRandom(IndicatorColorConditions, random);
                heldRules.Add(CreateHeldRule(condition, heldInstructionWeights, random));
            }
            heldRules.Add(CreateHeldRule(null, heldInstructionWeights, random));

            // Remove redundant rules.
            RemoveRedundantRules(initialRules, initialInstructionWeights, random, PrimaryConditions, SecondaryConditions);

            return(new RuleSet(initialRules.ToArray(), heldRules.ToArray()));
        }