Ejemplo n.º 1
0
 private static void incTokenCount(ref int tokencount, State.FIELD field)
 {
     if (field == State.FIELD.EMPTY)
     {
         tokencount = 0;
     }
     else
     {
         if (field == State.FIELD.MIN)
         {
             if (tokencount < 0)
             {
                 tokencount--;
             }
             else
             {
                 tokencount = -1;
             }
         }
         else
         {
             if (tokencount > 0)
             {
                 tokencount++;
             }
             else
             {
                 tokencount = 1;
             }
         }
     }
 }
Ejemplo n.º 2
0
        private static void GameTest()
        {
            State.FIELD[,] board = new State.FIELD[State.HEIGHT, State.WIDTH];
            State s = new State(board);

            StartTwoPlayerGame(s);//ref s);

            Console.ReadLine();
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Starts the game with user interactions.
        /// </summary>
        /// <param name="state">Game state</param>
        private static void StartTwoPlayerGame(State state)
        {//ref State state) {
            bool play        = true;
            int  roundNumber = 1;

            State.FIELD winner = State.FIELD.EMPTY;

            //State state = new State();
            List <State> closedList = new List <State>();
            int          depth      = 3;

            //int player = 1;
            state.AddToBoard(3, State.FIELD.MAX);
            while (play)
            {
                //Console.Clear();


                PrintStateWithHeader(state);

                if (roundNumber % 2 != 0)
                {
                    Console.Write("> Player (O) (B-MIN): ");
                    RoundB(ref state);
                }
                else
                {
                    Console.Write("> PC (X) (A-MAX)...\n");
                    RoundA(ref state, closedList, depth);
                }

                if (IsTerminalWithWinner(state, out winner))
                {
                    //Console.Clear();
                    PrintStateWithHeader(state);
                    Console.WriteLine("Finished!");
                    Console.WriteLine("   Winner: " + (winner == State.FIELD.MAX ? "Player A  = X (MAX)" : "Player B  = O (MIN)"));
                    Console.ReadLine();
                    play = false;
                }

                ++roundNumber;
            }
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Decides is the game finished or not giving the winner.
        /// If the game is not finished then winner == State.FEILD.EMPTY
        /// </summary>
        /// <param name="state"></param>
        /// <param name="winner"></param>
        /// <returns></returns>
        private static bool IsTerminalWithWinner(State state, out State.FIELD winner)
        {
            int tokencount = 0;
            // - tokencount = enemy's token count
            // + tokencount = our token count

            bool brk = false; // break indicator, true when return value is decided

            // horizontal:
            for (int i = 0; i < state.Board.GetLength(0); ++i)
            {
                tokencount = 0;

                for (int j = 0; j < state.Board.GetLength(1); ++j)
                {
                    incTokenCount(ref tokencount, state.Board[i, j]);

                    if (Math.Abs(tokencount) >= 4)
                    {
                        brk = true;
                        break;
                    }
                }

                if (brk)
                {
                    break;
                }
            }

            // verical:
            if (!brk)
            {
                for (int j = 0; j < state.Board.GetLength(1); ++j)
                {
                    tokencount = 0;

                    for (int i = 0; i < state.Board.GetLength(0); ++i)
                    {
                        incTokenCount(ref tokencount, state.Board[i, j]);

                        if (Math.Abs(tokencount) >= 4)
                        {
                            brk = true;
                            break;
                        }
                    }

                    if (brk)
                    {
                        break;
                    }
                }
            }

            // main diagonal:
            if (!brk)
            {
                // lower part    .\
                bool isUsed = false;
                for (int i = 0; i < state.Board.GetLength(0); ++i)
                {
                    int x = i;
                    for (int j = 0; j < state.Board.GetLength(1); ++j)
                    {
                        tokencount = 0;
                        int y = j;
                        while (x < state.Board.GetLength(0) && y < state.Board.GetLength(1))
                        {
                            //Console.Write("[" + x + "," + y + "]"+ tokencount + " ");
                            incTokenCount(ref tokencount, state.Board[x, y]);
                            ++x;
                            ++y;
                            isUsed = false;
                            if (Math.Abs(tokencount) >= 4)
                            {
                                brk = true;
                                break;
                            }
                        }
                        if (brk)
                        {
                            break;
                        }
                        if (!isUsed)
                        {
                            isUsed = true;
                        }
                    }
                    //Console.WriteLine();
                    if (brk)
                    {
                        break;
                    }
                }
            }
            if (!brk)
            {
                // upper part    \'
                bool isUsed = false;
                for (int k = 0; k < state.Board.GetLength(1); ++k)
                {
                    int x = 0;
                    for (int j = k + 1; j < state.Board.GetLength(1); ++j)
                    {
                        tokencount = 0;
                        int y = j;
                        while (x < state.Board.GetLength(0) - k && y < state.Board.GetLength(1))
                        {
                            //Console.Write("[" + x + "," + y + "] ");
                            incTokenCount(ref tokencount, state.Board[x, y]);
                            ++x;
                            ++y;
                            isUsed = false;
                            if (Math.Abs(tokencount) >= 4)
                            {
                                brk = true;
                                break;
                            }
                        }
                        if (!isUsed)
                        {
                            isUsed = true;
                        }
                        if (brk)
                        {
                            break;
                        }
                    }
                    //Console.WriteLine();
                    if (brk)
                    {
                        break;
                    }
                }
            }

            // secondary diagonal
            if (!brk)
            {
                // upper part    '/
                bool isUsed = false;
                for (int i = 0; i < state.Board.GetLength(0); ++i)
                {
                    int x = i;
                    for (int j = 0; j < state.Board.GetLength(1); ++j)
                    {
                        tokencount = 0;
                        int y = j;
                        while (x >= 0 && y < state.Board.GetLength(1))
                        {
                            //Console.Write("[" + x + "," + y + "] ");
                            incTokenCount(ref tokencount, state.Board[x, y]);
                            --x;
                            ++y;
                            isUsed = false;
                            if (Math.Abs(tokencount) >= 4)
                            {
                                brk = true;
                                break;
                            }
                        }
                        if (!isUsed)
                        {
                            isUsed = true;
                        }
                        if (brk)
                        {
                            break;
                        }
                    }
                    //Console.WriteLine();
                    if (brk)
                    {
                        break;
                    }
                }
            }
            if (!brk)
            {
                // lower part    /.
                bool isUsed = false;
                for (int k = 1; k < state.Board.GetLength(1); ++k)
                {
                    int x = state.Board.GetLength(0) - 1;
                    for (int j = k; j < state.Board.GetLength(1); ++j)
                    {
                        tokencount = 0;
                        int y = j;
                        while (x >= k - 1 && y < state.Board.GetLength(1))
                        {
                            //Console.Write("[" + x + "," + y + "] ");
                            --x;
                            ++y;
                            isUsed = false;
                            if (Math.Abs(tokencount) >= 4)
                            {
                                brk = true;
                                break;
                            }
                        }
                        if (!isUsed)
                        {
                            isUsed = true;
                        }
                        if (brk)
                        {
                            break;
                        }
                    }
                    //Console.WriteLine();
                    if (brk)
                    {
                        break;
                    }
                }
            }

            // result:
            if (Math.Abs(tokencount) >= 4)
            {
                if (tokencount > 0)
                {
                    winner = State.FIELD.MAX;
                }
                else
                {
                    winner = State.FIELD.MIN;
                }
                return(true);
            }
            else
            {
                winner = State.FIELD.EMPTY;
                return(false);
            }
        }
Ejemplo n.º 5
0
        // Ha egy sorban tobb mint 30% a van az ellenfelnek az mar veszelyt jelent
        private static int AtLeastNTokenInARow(State state, int n, State.FIELD field, int score_points, int danger_miltiplier)
        {
            int  score    = 0;
            int  tokenPcs = 0;
            bool isUsed;

            // Horizontal
            for (int i = 0; i < state.Board.GetLength(0); ++i)
            {
                tokenPcs = 0;

                for (int j = 0; j < state.Board.GetLength(1); ++j)
                {
                    //if( i==5 && j == 3)
                    //{
                    //    Console.WriteLine("*");
                    //}
                    if (state.Board[i, j] == field)
                    {
                        // danger factor is bigger if 3 tokens are down from 4
                        score += ScoreCalc(tokenPcs, n, score_points, danger_miltiplier);
                        tokenPcs++;
                    }
                    else
                    {
                        tokenPcs = 0;
                    }
                }
            }

            // Vertical
            for (int j = 0; j < state.Board.GetLength(1); ++j)
            {
                tokenPcs = 0;

                for (int i = 0; i < state.Board.GetLength(0); ++i)
                {
                    if (state.Board[i, j] == field)
                    {
                        // danger factor is bigger if 3 tokens are down from 4
                        score += ScoreCalc(tokenPcs, n, score_points, danger_miltiplier);
                        tokenPcs++;
                    }
                    else
                    {
                        tokenPcs = 0;
                    }
                }
            }
            // Main Diagonal

            // lower part    .\
            isUsed = false;
            for (int i = 0; i < state.Board.GetLength(0); ++i)
            {
                int x = i;
                for (int j = 0; j < state.Board.GetLength(1); ++j)
                {
                    tokenPcs = 0;
                    int y = j;
                    while (x < state.Board.GetLength(0) && y < state.Board.GetLength(1))
                    {
                        //Console.Write("[" + x + "," + y + "]"+ tokencount + " ");
                        if (state.Board[x, y] == field)
                        {
                            // danger factor is bigger if 3 tokens are down from 4
                            score += ScoreCalc(tokenPcs, n, score_points, danger_miltiplier);
                            tokenPcs++;
                        }
                        else
                        {
                            tokenPcs = 0;
                        }
                        isUsed = false;
                        ++x;
                        ++y;
                    }
                    if (!isUsed)
                    {
                        isUsed = true;
                    }
                }
                //Console.WriteLine();
            }

            // upper part    \'
            isUsed = false;
            for (int k = 0; k < state.Board.GetLength(1); ++k)
            {
                int x = 0;
                for (int j = k + 1; j < state.Board.GetLength(1); ++j)
                {
                    tokenPcs = 0;
                    int y = j;
                    while (x < state.Board.GetLength(0) - k && y < state.Board.GetLength(1))
                    {
                        //Console.Write("[" + x + "," + y + "] ");
                        if (state.Board[x, y] == field)
                        {
                            // danger factor is bigger if 3 tokens are down from 4
                            score += ScoreCalc(tokenPcs, n, score_points, danger_miltiplier);
                            tokenPcs++;
                        }
                        else
                        {
                            tokenPcs = 0;
                        }
                        isUsed = false;
                        ++x;
                        ++y;
                    }
                    if (!isUsed)
                    {
                        isUsed = true;
                    }
                }
                //Console.WriteLine();
            }

            // Secondary Diagonal

            // upper part    '/
            isUsed = false;
            for (int i = 0; i < state.Board.GetLength(0); ++i)
            {
                int x = i;
                for (int j = 0; j < state.Board.GetLength(1); ++j)
                {
                    tokenPcs = 0;
                    int y = j;
                    while (x >= 0 && y < state.Board.GetLength(1))
                    {
                        //Console.Write("[" + x + "," + y + "] ");
                        if (state.Board[x, y] == field)
                        {
                            // danger factor is bigger if 3 tokens are down from 4
                            score += ScoreCalc(tokenPcs, n, score_points, danger_miltiplier);
                            tokenPcs++;
                        }
                        else
                        {
                            tokenPcs = 0;
                        }
                        isUsed = false;
                        --x;
                        ++y;
                    }
                    if (!isUsed)
                    {
                        isUsed = true;
                    }
                }
                //Console.WriteLine();
            }

            // lower part    /.
            isUsed = false;
            for (int k = 1; k < state.Board.GetLength(1); ++k)
            {
                int x = state.Board.GetLength(0) - 1;
                for (int j = k; j < state.Board.GetLength(1); ++j)
                {
                    tokenPcs = 0;
                    int y = j;
                    while (x >= k - 1 && y < state.Board.GetLength(1))
                    {
                        //Console.Write("[" + x + "," + y + "] ");
                        if (state.Board[x, y] == field)
                        {
                            // danger factor is bigger if 3 tokens are down from 4
                            score += ScoreCalc(tokenPcs, n, score_points, danger_miltiplier);
                            tokenPcs++;
                        }
                        else
                        {
                            tokenPcs = 0;
                        }
                        isUsed = false;
                        --x;
                        ++y;
                    }
                    if (!isUsed)
                    {
                        isUsed = true;
                    }
                }
                //Console.WriteLine();
            }


            return(score);
        }