Beispiel #1
0
 private void Start(Lato prossimoTurno)
 {
     while (_gioco.Vincitore != null && !_gioco.Parita)
     {
         if (prossimoTurno == Lato.A)
         {
             if (_playerA is IAIPlayer)
             {
                 _gioco.Muovi(((IAIPlayer)_playerA).Elaborazione(_gioco));
             }
         }
         else
         {
             if (_playerA is IAIPlayer)
             {
                 _gioco.Muovi(((IAIPlayer)_playerB).Elaborazione(_gioco));
             }
         }
     }
 }
Beispiel #2
0
        protected override ValoreMossa GetValoreMossa(IGioco gioco, int depth)
        {
            ValoreMossa resultMove = null;

            if (depth <= _max)
            {
                ITavola tavola   = gioco.Tavola;
                Lato    latoStep = gioco.ProssimoTurno;
                int?    beta     = null;
                for (int i = tavola.Buche.Count - 2; i >= 0; --i)
                {
                    IBuca p = tavola.Buche[i];
                    if (p.Lato == latoStep && i != 6 && i != 13 && p.Semi > 0 && !gioco.Finito)
                    {
                        IGioco giocoClone = gioco.Clone();
                        giocoClone.Muovi(i);
                        int valoreAttuale = ValoreAttuale(giocoClone);

                        if (depth == _max - 1 && beta.HasValue && latoStep == LatoPlayer && valoreAttuale < beta.Value)
                        {
                            continue;
                        }
                        else
                        {
                            bool        cambioTurno = gioco.ProssimoTurno != giocoClone.ProssimoTurno;
                            ValoreMossa valoreProssimaMossa;
                            if (!giocoClone.Finito)
                            {
                                valoreProssimaMossa = ValoreProssimaMossa(depth, giocoClone, cambioTurno);
                            }
                            else
                            {
                                valoreProssimaMossa = null;
                            }
                            ValoreMossa valore = new ValoreMossa(valoreProssimaMossa, i, valoreAttuale);
                            if (null == resultMove) //serve per il taglio
                            {
                                resultMove = valore;
                            }
                            else
                            {
                                resultMove = AggiornoValore(resultMove, valore, latoStep);
                                if (depth == _max - 1 && latoStep == LatoPlayer)
                                {
                                    beta = resultMove.Valore;
                                }
                            }
                        }
                    }
                }
            }
            return(resultMove);
        }
Beispiel #3
0
        private ValoreMossa MinValue(IGioco gioco, int depth, int alfa, int beta)
        {
            ValoreMossa resultMove = null;

            if (depth <= _max && !gioco.Finito)
            {
                ITavola tavola   = gioco.Tavola;
                Lato    latoStep = gioco.ProssimoTurno;

                int[] heuristc = _heuristicFunction.HeuristicFunction(gioco.Clone());
                for (int j = 0; j < heuristc.Length; ++j)
                {
                    int i = heuristc[j];
                    OperationCount++;
                    IGioco giocoClone = gioco.Clone();
                    giocoClone.Muovi(i);
                    bool        cambioTurno         = gioco.ProssimoTurno != giocoClone.ProssimoTurno;
                    ValoreMossa valoreProssimaMossa = null;
                    if (!giocoClone.Finito)
                    {
                        if (!cambioTurno)
                        {
                            valoreProssimaMossa = MinValue(giocoClone, depth, alfa, beta);
                        }
                        else
                        {
                            valoreProssimaMossa = MaxValue(giocoClone, depth + 1, alfa, beta);
                        }
                    }

                    ValoreMossa valore = new ValoreMossa(valoreProssimaMossa, i, ValoreAttuale(giocoClone));
                    if (null == resultMove)//inizializzazione
                    {
                        resultMove = valore;
                    }
                    else
                    {
                        resultMove = AggiornoValore(resultMove, valore, latoStep);
                    }
                    if (resultMove.Valore < alfa)
                    {
                        return(resultMove);
                    }
                    beta = resultMove.Valore < beta ? resultMove.Valore : beta;
                }
            }
            return(resultMove);
        }
Beispiel #4
0
        private ValoreMossa MinValue(IGioco gioco, int depth)
        {
            ValoreMossa resultMove = null;

            if (depth <= _max && !gioco.Finito)
            {
                ITavola tavola   = gioco.Tavola;
                Lato    latoStep = gioco.ProssimoTurno;


                for (int i = tavola.Buche.Count - 2; i >= 0; --i)
                {
                    IBuca p = tavola.Buche[i];
                    if (p.Lato == latoStep && i != 6 && i != 13 && p.Semi > 0 && !gioco.Finito)
                    {
                        OperationCount++;

                        IGioco giocoClone = gioco.Clone();
                        giocoClone.Muovi(i);
                        bool        cambioTurno         = gioco.ProssimoTurno != giocoClone.ProssimoTurno;
                        ValoreMossa valoreProssimaMossa = null;
                        if (!giocoClone.Finito)
                        {
                            if (!cambioTurno)
                            {
                                valoreProssimaMossa = MinValue(giocoClone.Clone(), depth);
                            }
                            else
                            {
                                valoreProssimaMossa = MaxValue(giocoClone.Clone(), depth + 1);
                            }
                        }

                        ValoreMossa valore = new ValoreMossa(valoreProssimaMossa, i, ValoreAttuale(giocoClone));
                        if (null == resultMove)//inizializzazione
                        {
                            resultMove = valore;
                        }
                        else
                        {
                            resultMove = AggiornoValore(resultMove, valore, latoStep);
                        }
                    }
                }
            }
            return(resultMove);
        }
Beispiel #5
0
        public int[] HeuristicFunction(IGioco gioco)
        {
            Dictionary <int, decimal> outDic = new Dictionary <int, decimal>();

            for (int i = gioco.Tavola.Buche.Count - 2; i >= 0; --i)
            {
                IBuca p = gioco.Tavola.Buche[i];
                if (gioco.Tavola.Buche[i].Lato == gioco.ProssimoTurno && i != 6 && i != 13 && gioco.Tavola.Buche[i].Semi > 0 && !gioco.Finito)
                {
                    IGioco giocoClone = gioco.Clone();
                    giocoClone.Muovi(i);
                    bool    cambioTurno = gioco.ProssimoTurno != giocoClone.ProssimoTurno;
                    decimal valore      = (decimal)(cambioTurno ? Valore(giocoClone) : Valore(giocoClone) + 0.5);
                    outDic.Add(i, valore);
                }
            }
            return(outDic.OrderByDescending(x => x.Value).Select(x => x.Key).ToArray());
        }
Beispiel #6
0
        protected override ValoreMossa GetValoreMossa(IGioco gioco, int depth)
        {
            ValoreMossa resultMove = null;

            if (depth <= _max)
            {
                ITavola tavola   = gioco.Tavola;
                Lato    latoStep = gioco.ProssimoTurno;

                for (int i = tavola.Buche.Count - 2; i >= 0; --i)
                {
                    IBuca p = tavola.Buche[i];
                    if (p.Lato == latoStep && i != 6 && i != 13 && p.Semi > 0 && !gioco.Finito)
                    {
                        OperationCount++;
                        IGioco giocoClone = gioco.Clone();
                        giocoClone.Muovi(i);
                        int         valoreAttuale = ValoreAttuale(giocoClone);
                        ValoreMossa valoreProssimaMossa;
                        if (!giocoClone.Finito)
                        {
                            bool cambioTurno = gioco.ProssimoTurno != giocoClone.ProssimoTurno;
                            valoreProssimaMossa = ValoreProssimaMossa(depth, giocoClone.Clone(), cambioTurno);
                        }
                        else
                        {
                            valoreProssimaMossa = null;
                        }
                        ValoreMossa m = new ValoreMossa(valoreProssimaMossa, i, valoreAttuale);

                        if (null == resultMove)//inizializzazione
                        {
                            resultMove = m;
                        }
                        else
                        {
                            resultMove = AggiornoValore(resultMove, m, latoStep);
                        }
                    }
                }
            }
            return(resultMove);
        }