Esempio n. 1
0
        public static List <RecRateResult> recRate(State2048 root, int depth)
        {
            List <StateTrans> moves = root.getAllMoveStates();

            //If we can't move, the game is over; worst penalty
            if (moves.Count == 0)
            {
                return new List <RecRateResult> {
                           new RecRateResult(double.MaxValue, MoveDir.Self)
                }
            }
            ;

            //If the depth is zero, return the result from this state
            if (depth == 0)
            {
                return new List <RecRateResult> {
                           new RecRateResult(root.rate(), MoveDir.Self)
                }
            }
            ;

            List <RecRateResult> result = new List <RecRateResult>();

            foreach (StateTrans st in moves)
            {
                double bestOfWorst = double.MaxValue;

                List <State2048> allRandom = st.state.getAllRandom();
                foreach (State2048 rand in allRandom)
                {
                    List <RecRateResult> randRes = recRate(rand, depth - 1);

                    //Take the maximum penalty
                    double worstRate = randRes[0].rating;
                    for (int i = 1; i < randRes.Count; i++)
                    {
                        if (randRes[i].rating > worstRate)
                        {
                            worstRate = randRes[i].rating;
                        }
                    }

                    if (worstRate < bestOfWorst)
                    {
                        bestOfWorst = worstRate;
                    }
                }

                result.Add(new RecRateResult(bestOfWorst, st.dir));
            }

            return(result);
        }
Esempio n. 2
0
        //Copy constructor
        public State2048(State2048 s)
        {
            this.rows = s.rows;
            this.cols = s.cols;
            this.grid = new int[rows, cols];

            for (int r = 0; r < this.rows; r++)
            {
                for (int c = 0; c < this.cols; c++)
                {
                    this.grid[r, c] = s.grid[r, c];
                }
            }
        }
Esempio n. 3
0
        public static double alphabetarate(State2048 root, int depth, double alpha, double beta, bool player)
        {
            if (depth == 0)
            {
                return(root.rate());
            }

            if (player)
            {
                List <StateTrans> moves = root.getAllMoveStates();

                //If we can't move, the game is over; worst penalty
                if (moves.Count == 0)
                {
                    return(double.MaxValue);
                }

                foreach (StateTrans st in moves)
                {
                    alpha = Math.Min(alpha, alphabetarate(st.state, depth - 1, alpha, beta, !player));
                    if (beta >= alpha)
                    {
                        break;
                    }
                }
                return(alpha);
            }
            else
            {
                List <State2048> moves = root.getAllRandom();

                foreach (State2048 st in moves)
                {
                    beta = Math.Max(beta, alphabetarate(st, depth - 1, alpha, beta, !player));
                    if (beta <= alpha)
                    {
                        break;
                    }
                }
                return(beta);
            }
        }
Esempio n. 4
0
        public List <State2048> getAllRandom()
        {
            List <State2048>         res  = new List <State2048>();
            List <Tuple <int, int> > free = this.getFree();

            foreach (Tuple <int, int> x in free)
            {
                State2048 next;

                next = new State2048(this);
                next.grid[x.Item1, x.Item2] = 1;
                res.Add(next);

                next = new State2048(this);
                next.grid[x.Item1, x.Item2] = 2;
                res.Add(next);
            }

            return(res);
        }
Esempio n. 5
0
        public bool equalTo(State2048 alt)
        {
            if (this.rows != alt.rows)
            {
                return(false);
            }
            if (this.cols != alt.cols)
            {
                return(false);
            }

            for (int r = 0; r < rows; r++)
            {
                for (int c = 0; c < cols; c++)
                {
                    if (this.grid[r, c] != alt.grid[r, c])
                    {
                        return(false);
                    }
                }
            }

            return(true);
        }
Esempio n. 6
0
        public List <StateTrans> getAllMoveStates()
        {
            List <StateTrans> allMoves = new List <StateTrans>();

            State2048 next;

            next = new State2048(this);
            next.pushLeft();
            if (!this.equalTo(next))
            {
                allMoves.Add(new StateTrans(next, MoveDir.Left));
            }

            next = new State2048(this);
            next.pushRight();
            if (!this.equalTo(next))
            {
                allMoves.Add(new StateTrans(next, MoveDir.Right));
            }

            next = new State2048(this);
            next.pushUp();
            if (!this.equalTo(next))
            {
                allMoves.Add(new StateTrans(next, MoveDir.Up));
            }

            next = new State2048(this);
            next.pushDown();
            if (!this.equalTo(next))
            {
                allMoves.Add(new StateTrans(next, MoveDir.Down));
            }

            return(allMoves);
        }
Esempio n. 7
0
 public StateTrans(State2048 state, MoveDir dir)
 {
     this.dir   = dir;
     this.state = state;
 }