示例#1
0
        public void OnSendOption(KettleSendOption sendOption)
        {
            Console.WriteLine("simulator OnSendOption called");

            PowerAllOptions allOptions = _game.AllOptionsMap[sendOption.Id];

            SendPowerHistory(_game.PowerHistory.Last);
            SendChoicesOrOptions();
        }
示例#2
0
        public void OnSendOption(KettleSendOption sendOption)
        {
            Console.WriteLine("simulator OnSendOption called");

            var sendOptionId         = sendOption.Id;
            var sendOptionMainOption = sendOption.MainOption;
            var sendOptionPosition   = sendOption.Position - 1;
            var sendOptionSubOption  = sendOption.SubOption;
            var sendOptionTarget     = sendOption.Target;

            Console.WriteLine($"Id={sendOption.Id} MainOption={sendOption.MainOption} Position={sendOption.Position} SubOption={sendOption.SubOption} Target={sendOption.Target}");
            PlayerTask task = SabberStoneKettleSimulator.Util.KettleOptionToPlayerTask(Game, sendOptionId, sendOptionMainOption, sendOptionTarget, sendOptionPosition, sendOptionSubOption);

            Game.Process(task);
            ShowLog(Game, LogLevel.VERBOSE);

            SendPowerHistory(Game.PowerHistory.Last);
            SendChoicesOrOptions();
        }
示例#3
0
        public void OnOptionsBlock(KettleOptionsBlock optionsBlock)
        {
            Console.WriteLine("AI OnOptionsBlock called.");

            int kettleOptionIndex = Rand.Next(0, optionsBlock.Options.Count);
            var kettleOption      = optionsBlock.Options[kettleOptionIndex];

            var kettleSendOption = new KettleSendOption()
            {
                Id = optionsBlock.Id,
            };

            if (kettleOption.MainOption != null)
            {
                kettleSendOption.MainOption = kettleOptionIndex;
            }

            if (kettleOption.SubOptions != null && kettleOption.SubOptions.Any())
            {
                var kettleSubOptionIndex = Rand.Next(0, kettleOption.SubOptions.Count);
                var subOption            = kettleOption.SubOptions[kettleSubOptionIndex];
                kettleSendOption.SubOption = kettleSubOptionIndex;

                if (subOption.Targets != null && subOption.Targets.Any())
                {
                    kettleSendOption.Target = subOption.Targets[Rand.Next(0, subOption.Targets.Count)];
                }
            }
            else
            {
                if (kettleOption.MainOption != null && kettleOption.MainOption.Targets != null && kettleOption.MainOption.Targets.Any())
                {
                    kettleSendOption.Target = kettleOption.MainOption.Targets[Rand.Next(0, kettleOption.MainOption.Targets.Count)];
                }
            }

            kettleSendOption.Position = 0;

            Adapter.SendMessage(kettleSendOption);
        }
        public void OnOptionsBlock(KettleOptionsBlock optionsBlock)
        {
            // convert that option
            Console.WriteLine("AI OnOptionsBlock called.");
            if (optionsBlock.PlayerId != PlayerId)
            {
                return;
            }

            List <PlayerTask> options = Session.Game.CurrentPlayer.Options();

            // Do AI shit
            PlayerTask option = DoAI(options);

            // Convert it to poweroptions
            PowerAllOptions poweroptions = PowerOptionsBuilder.AllOptions(Session.Game, new List <PlayerTask> {
                option
            });

            // And create a kettle block for it
            KettleOption chosenoption = new KettleOptionsBlock(poweroptions, Session.Game.CurrentPlayer.PlayerId).Options[0];

            int mainOptionIndex = 0;
            int subOptionIndex  = 0;
            int target          = 0;
            int position        = 0;

            // Then we try and find the kettle option that matches
            foreach (KettleOption koption in optionsBlock.Options)
            {
                if (koption.Type != chosenoption.Type)
                {
                    continue;
                }

                if (!OptionsMatch(chosenoption.MainOption, koption.MainOption))
                {
                    continue;
                }

                if ((chosenoption.SubOptions == null || chosenoption.SubOptions.Count == 0) != (koption.SubOptions == null || koption.SubOptions.Count == 0))
                {
                    continue;
                }

                if (chosenoption.SubOptions != null)
                {
                    foreach (KettleSubOption suboption in chosenoption.SubOptions)
                    {
                        if (OptionsMatch(chosenoption.SubOptions[0], suboption))
                        {
                            subOptionIndex = koption.SubOptions.IndexOf(suboption);
                            break;
                        }
                    }
                }

                mainOptionIndex = optionsBlock.Options.IndexOf(koption);

                if (chosenoption.MainOption != null && chosenoption.MainOption.Targets != null)
                {
                    target = chosenoption.MainOption.Targets[0];
                }
                break;
            }

            if (option is PlayCardTask)
            {
                position = ((PlayerTask)option).ZonePosition;
            }

            KettleSendOption sendoption = new KettleSendOption();

            sendoption.Id         = optionsBlock.Id;
            sendoption.MainOption = mainOptionIndex;
            sendoption.SubOption  = subOptionIndex;
            sendoption.Target     = target;
            sendoption.Position   = position;

            Adapter.SendMessage(sendoption);
        }