Esempio n. 1
0
 public Match(IOpponent opponent1, IOpponent opponent2, int bestOfTotal)
 {
     _opponent1    = opponent1;
     _opponent2    = opponent2;
     _bestOfTTotal = bestOfTotal;
     IntiSets();
 }
 public GameInstance()
 {
     Console.WriteLine("What kind of opponent would you like? 'Ai' or 'Human'");
     _opponentType = SelectOpponentType();
     _opponent     = CreateOpponent(_opponentType);
     InitaliseGameLoop(_mainPlayer, _opponent);
 }
        /// <summary>
        /// Implements <see cref="IComparer{IOpponent}"/>
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        public int Compare(IOpponent <int> x, IOpponent <int> y)
        {
            if (x == null)
            {
                throw new ArgumentNullException(nameof(x));
            }
            if (y == null)
            {
                throw new ArgumentNullException(nameof(y));
            }

            if (x.Home < y.Home)
            {
                return(-1);
            }
            if (x.Home > y.Home)
            {
                return(1);
            }

            // Home points are equal

            if (x.Guest < y.Guest)
            {
                return(1);
            }
            if (x.Guest > y.Guest)
            {
                return(-1);
            }

            // Home and guest points are equal
            return(0);
        }
Esempio n. 4
0
 public Predictor(IOpponent opponent, ReadOnlyCollection <Deck> metaDecks)
 {
     Log.Debug("Copying possible decks from the meta");
     _classDecks    = new List <Deck>(metaDecks);
     _possibleDecks = new List <Deck>(metaDecks);
     _opponent      = opponent;
     CheckOpponentClass();
     CheckOpponentMana();
 }
Esempio n. 5
0
    // Start is called before the first frame update
    void Start()
    {
        if (IsNetworkedGame)
        {
            InstantiateNetworkController();
        }

        OpponentController = OpponentControllerObject.GetComponent <IOpponent>();
        GameCoreController.Instance.Opponent = OpponentController;
        StartCoroutine(GameCoreController.Instance.PlayGame());
    }
        /*
         * Our main game loops, all instances of the game are held here.
         */
        public void StartAiOpponentGameLoop(MainPlayer mainPlayer, IOpponent opponent)
        {
            Console.ForegroundColor = ConsoleColor.DarkRed;
            // throw new NotImplementedException("To be done at later date");
            mc.Draw(_gameMap, mainPlayer, opponent as Player);

            while (true)
            {
                Play(_gameMap, mainPlayer, opponent as IPlayer);
                Play(_gameMap, opponent as IPlayer, mainPlayer);
            }
        }
 private void InitaliseGameLoop(MainPlayer mainPlayer, IOpponent opponent)
 {
     if (opponent is Ai)
     {
         StartAiOpponentGameLoop(mainPlayer, opponent);
     }
     else
     {
         Console.BackgroundColor = ConsoleColor.White;
         StartPlayerOpponentGameLoop(mainPlayer, opponent);
     }
 }
        public void StartPlayerOpponentGameLoop(MainPlayer mainPlayer, IOpponent opponent)
        {
            Console.Clear();
            Console.ForegroundColor = ConsoleColor.Blue;
            IPlayer ipOpponent = (IPlayer)opponent;

            mc.Draw(_gameMap, mainPlayer, ipOpponent);

            while (true)
            {
                Play(_gameMap, mainPlayer, ipOpponent);
                Play(_gameMap, ipOpponent, mainPlayer);
            }
        }
Esempio n. 9
0
 public bool Beats(IOpponent opponent)
 {
     return opponent.BeatenByPaper();
 }
Esempio n. 10
0
 public bool Beats(IOpponent opponent)
 {
     return(opponent.BeatenByScissors());
 }
Esempio n. 11
0
 public bool Beats(IOpponent opponent)
 {
     return(opponent.BeatenByPaper());
 }
Esempio n. 12
0
 public bool Beats(IOpponent opponent)
 {
     return(opponent.BeatenByRock());
 }
Esempio n. 13
0
        /// <summary>
        /// Start playground in a regular fashion when a match is known
        /// </summary>
        private async void StartRegular(MatchEntity match)
        {
            // which player are we?
            playerColor = match.WhitePlayer == Auth.Player
                ? PieceColor.White : PieceColor.Black;

            // who is the opponent
            UnisavePlayer opponentPlayer = playerColor.IsWhite()
                ? match.BlackPlayer : match.WhitePlayer;

            // connect to the opponent
            if (opponentPlayer == null)
            {
                // AI
                Debug.Log("Starting computer opponent...");
                opponent = new ComputerOpponent(
                    playerColor.Opposite(),
                    board,
                    match.Duration
                    );
            }
            else
            {
                // Real person
                Debug.Log("Connecting to photon opponent...");
                opponent = PhotonOpponent.CreateInstance(match.EntityId);
            }

            // create and setup the board
            board.CreateBoard(
                playerColor.IsWhite(),
                match.WhitePlayerSet,
                match.BlackPlayerSet
                );

            // create the clock
            clock = new Clock(match.Duration);

            // register opponent events
            opponent.OnMoveFinish += OpponentsMoveWasFinished;
            opponent.OnGiveUp     += OnOpponentGaveUp;
            opponent.OnOutOfTime  += OnOpponentTimeOver;

            // wait for the opponent
            Debug.Log("Waiting for the opponent...");
            await opponent.WaitForReady();

            // === start the game ===

            // if we are white, we are the one to start
            Debug.Log("Game has started.");
            if (playerColor.IsWhite())
            {
                PerformOurMove();
            }
            else
            {
                // it's the opponents turn so just wait
                clock.StartOpponent();
            }
        }
 /// <summary>
 /// Implements <see cref="IComparable{IResult}"/>
 /// </summary>
 /// <param name="other"></param>
 /// <returns></returns>
 public int CompareTo(IOpponent <int> other)
 {
     return(Compare(this, other));
 }
Esempio n. 15
0
        public void KeyDown(Commands cmd)
        {
            if (Client.IsPlaying)
            {
                if (_isConfusionActive)
                {
                    Commands confusedCmd;
                    if (_confusionMapping.TryGetValue(cmd, out confusedCmd))
                        cmd = confusedCmd;
                }
                if (_timers.ContainsKey(cmd) && _timers[cmd].IsEnabled)
                    return;
                switch (cmd)
                {
                    case TetriNET.Client.Interfaces.Commands.Hold:
                        Client.Hold();
                        break;
                    case TetriNET.Client.Interfaces.Commands.Drop:
                        Client.Drop();
                        break;
                    case TetriNET.Client.Interfaces.Commands.Down:
                        Client.MoveDown();
                        break;
                    case TetriNET.Client.Interfaces.Commands.Left:
                        Client.MoveLeft();
                        break;
                    case TetriNET.Client.Interfaces.Commands.Right:
                        Client.MoveRight();
                        break;
                    case TetriNET.Client.Interfaces.Commands.RotateClockwise:
                        Client.RotateClockwise();
                        break;
                    case TetriNET.Client.Interfaces.Commands.RotateCounterclockwise:
                        Client.RotateCounterClockwise();
                        break;

                    case TetriNET.Client.Interfaces.Commands.DiscardFirstSpecial:
                        Client.DiscardFirstSpecial();
                        break;
                    case TetriNET.Client.Interfaces.Commands.UseSpecialOn1:
                        Client.UseFirstSpecial(0);
                        break;
                    case TetriNET.Client.Interfaces.Commands.UseSpecialOn2:
                        Client.UseFirstSpecial(1);
                        break;
                    case TetriNET.Client.Interfaces.Commands.UseSpecialOn3:
                        Client.UseFirstSpecial(2);
                        break;
                    case TetriNET.Client.Interfaces.Commands.UseSpecialOn4:
                        Client.UseFirstSpecial(3);
                        break;
                    case TetriNET.Client.Interfaces.Commands.UseSpecialOn5:
                        Client.UseFirstSpecial(4);
                        break;
                    case TetriNET.Client.Interfaces.Commands.UseSpecialOn6:
                        Client.UseFirstSpecial(5);
                        break;
                    case TetriNET.Client.Interfaces.Commands.UseSpecialOnSelf:
                        Client.UseFirstSpecial(Client.PlayerId);
                        break;
                    case TetriNET.Client.Interfaces.Commands.UseSpecialOnRandomOpponent:
                        {
                            IOpponent[] opponents = Client.Opponents.ToArray();
                            if (opponents.Any())
                            {
                                int rnd = Randomizer.Instance.Next(opponents.Length);
                                IOpponent opponent = opponents[rnd];
                                if (opponent != null)
                                    Client.UseFirstSpecial(opponent.PlayerId);
                            }
                        }
                        break;
                }
                if (_timers.ContainsKey(cmd))
                    _timers[cmd].Start();
            }
        }
Esempio n. 16
0
 public PredictionController(IOpponent opponent, ReadOnlyCollection <Deck> metaDecks)
 {
     _opponent      = opponent;
     _predictor     = new Predictor(opponent, metaDecks);
     _predictionLog = new CustomLog(LogName);
 }
Esempio n. 17
0
 public bool Beats(IOpponent opponent)
 {
     return opponent.BeatenByScissors();
 }
Esempio n. 18
0
 public bool Beats(IOpponent opponent)
 {
     return opponent.BeatenByRock();
 }
Esempio n. 19
0
        public void KeyDown(Commands cmd)
        {
            if (Client.IsPlaying)
            {
                if (_timers.ContainsKey(cmd) && _timers[cmd].Enabled)
                {
                    return;
                }
                switch (cmd)
                {
                case Commands.Hold:
                    Client.Hold();
                    break;

                case Commands.Drop:
                    Client.Drop();
                    break;

                case Commands.Down:
                    Client.MoveDown();
                    break;

                case Commands.Left:
                    Client.MoveLeft();
                    break;

                case Commands.Right:
                    Client.MoveRight();
                    break;

                case Commands.RotateClockwise:
                    Client.RotateClockwise();
                    break;

                case Commands.RotateCounterclockwise:
                    Client.RotateCounterClockwise();
                    break;

                case Commands.DiscardFirstSpecial:
                    Client.DiscardFirstSpecial();
                    break;

                case Commands.UseSpecialOn1:
                    Client.UseFirstSpecial(0);
                    break;

                case Commands.UseSpecialOn2:
                    Client.UseFirstSpecial(1);
                    break;

                case Commands.UseSpecialOn3:
                    Client.UseFirstSpecial(2);
                    break;

                case Commands.UseSpecialOn4:
                    Client.UseFirstSpecial(3);
                    break;

                case Commands.UseSpecialOn5:
                    Client.UseFirstSpecial(4);
                    break;

                case Commands.UseSpecialOn6:
                    Client.UseFirstSpecial(5);
                    break;

                case Commands.UseSpecialOnSelf:
                    Client.UseFirstSpecial(Client.PlayerId);
                    break;

                case Commands.UseSpecialOnRandomOpponent:
                {
                    IOpponent opponent = Client.Opponents.FirstOrDefault();
                    if (opponent != null)
                    {
                        Client.UseFirstSpecial(opponent.PlayerId);
                    }
                }
                break;
                }
                if (_timers.ContainsKey(cmd))
                {
                    _timers[cmd].Start();
                }
            }
        }