コード例 #1
0
ファイル: FrmConfig.cs プロジェクト: otaviokz/Eukreukla
        private void btnOK_Click(object sender, EventArgs e)
        {
            JogadorUM = new Jogador();
            JogadorDOIS = new Jogador();

            try
            {
                //Teste se é humano
                if (ckbIsJogadorUmHumano.Checked)
                    JogadorUM.IsHumano = true;
                if (ckbIsJogadorDoisHumano.Checked)
                    JogadorDOIS.IsHumano = true;

                if (ckbCorPecaJogadorUM.Checked)
                {
                    JogadorUM.CorDoJogador = BRANCAS;
                    JogadorDOIS.CorDoJogador = PRETAS;
                }
                else
                {
                    JogadorUM.CorDoJogador = PRETAS;
                    JogadorDOIS.CorDoJogador = BRANCAS;
                }

                if (ckbIniciaJogoEmbaixo.Checked)
                    JogadorUM.IsEmbaixo = true;

                if (ckbIsPrimeiroJogar.Checked)
                    JogadorUM.IsPrimeiroJogador = true;

                if (ckbIsJogadorDoisFuncional.Checked)
                    JogadorDOIS.IsFuncional = true;

                SetaTipoJogadores();

                this.DialogResult = DialogResult.OK;
            }
            catch (Exception ex)
            {
                this.DialogResult = DialogResult.Cancel;
                throw ex;
            }
            finally
            {
                this.Close();
            }
        }
コード例 #2
0
ファイル: Jogo.cs プロジェクト: otaviokz/Eukreukla
        private void CopiaAtributosJogadores(Jogador _UM, Jogador _DOIS)
        {
            switch (m_enumTipoJogo)
            {
                case TipoDosJogadores.ComputadorXHumano:
                    m_CJogadorUm.CorDoJogador = _UM.CorDoJogador;
                    m_CJogadorUm.IsEmbaixo = _UM.IsEmbaixo;
                    m_CJogadorUm.IsHumano = _UM.IsHumano;
                    m_CJogadorUm.IsPlaying = _UM.IsPlaying;
                    m_CJogadorUm.IsPrimeiroJogador = _UM.IsPrimeiroJogador;
                    m_CJogadorUm.IsVencedor = _UM.IsVencedor;
                    m_CJogadorUm.PecasRestantes = _UM.PecasRestantes;

                    m_HJogadorDois.CorDoJogador = _DOIS.CorDoJogador;
                    m_HJogadorDois.IsEmbaixo = _DOIS.IsEmbaixo;
                    m_HJogadorDois.IsHumano = _DOIS.IsHumano;
                    m_HJogadorDois.IsPlaying = _DOIS.IsPlaying;
                    m_HJogadorDois.IsPrimeiroJogador = _DOIS.IsPrimeiroJogador;
                    m_HJogadorDois.IsVencedor = _DOIS.IsVencedor;
                    m_HJogadorDois.PecasRestantes = _DOIS.PecasRestantes;

                    break;
                case TipoDosJogadores.HumanoXFComputador:
                    m_HJogadorUm.CorDoJogador = _UM.CorDoJogador;
                    m_HJogadorUm.IsEmbaixo = _UM.IsEmbaixo;
                    m_HJogadorUm.IsHumano = _UM.IsHumano;
                    m_HJogadorUm.IsPlaying = _UM.IsPlaying;
                    m_HJogadorUm.IsPrimeiroJogador = _UM.IsPrimeiroJogador;
                    m_HJogadorUm.IsVencedor = _UM.IsVencedor;
                    m_HJogadorUm.PecasRestantes = _UM.PecasRestantes;

                    m_CJogadorDois.CorDoJogador = _DOIS.CorDoJogador;
                    m_CJogadorDois.IsEmbaixo = _DOIS.IsEmbaixo;
                    m_CJogadorDois.IsHumano = _DOIS.IsHumano;
                    m_CJogadorDois.IsPlaying = _DOIS.IsPlaying;
                    m_CJogadorDois.IsPrimeiroJogador = _DOIS.IsPrimeiroJogador;
                    m_CJogadorDois.IsVencedor = _DOIS.IsVencedor;
                    m_CJogadorDois.IsFuncional = _DOIS.IsFuncional;
                    m_CJogadorDois.PecasRestantes = _DOIS.PecasRestantes;
                    break;
                case TipoDosJogadores.HumanoXComputador:
                    m_HJogadorUm.CorDoJogador = _UM.CorDoJogador;
                    m_HJogadorUm.IsEmbaixo = _UM.IsEmbaixo;
                    m_HJogadorUm.IsHumano = _UM.IsHumano;
                    m_HJogadorUm.IsPlaying = _UM.IsPlaying;
                    m_HJogadorUm.IsPrimeiroJogador = _UM.IsPrimeiroJogador;
                    m_HJogadorUm.IsVencedor = _UM.IsVencedor;
                    m_HJogadorUm.PecasRestantes = _UM.PecasRestantes;

                    m_CJogadorDois.CorDoJogador = _DOIS.CorDoJogador;
                    m_CJogadorDois.IsEmbaixo = _DOIS.IsEmbaixo;
                    m_CJogadorDois.IsHumano = _DOIS.IsHumano;
                    m_CJogadorDois.IsPlaying = _DOIS.IsPlaying;
                    m_CJogadorDois.IsPrimeiroJogador = _DOIS.IsPrimeiroJogador;
                    m_CJogadorDois.IsVencedor = _DOIS.IsVencedor;
                    m_CJogadorDois.PecasRestantes = _DOIS.PecasRestantes;

                    break;
                case TipoDosJogadores.HumanoXHumano:
                    m_HJogadorUm.CorDoJogador = _UM.CorDoJogador;
                    m_HJogadorUm.IsEmbaixo = _UM.IsEmbaixo;
                    m_HJogadorUm.IsHumano = _UM.IsHumano;
                    m_HJogadorUm.IsPlaying = _UM.IsPlaying;
                    m_HJogadorUm.IsPrimeiroJogador = _UM.IsPrimeiroJogador;
                    m_HJogadorUm.IsVencedor = _UM.IsVencedor;
                    m_HJogadorUm.PecasRestantes = _UM.PecasRestantes;

                    m_HJogadorDois.CorDoJogador = _DOIS.CorDoJogador;
                    m_HJogadorDois.IsEmbaixo = _DOIS.IsEmbaixo;
                    m_HJogadorDois.IsHumano = _DOIS.IsHumano;
                    m_HJogadorDois.IsPlaying = _DOIS.IsPlaying;
                    m_HJogadorDois.IsPrimeiroJogador = _DOIS.IsPrimeiroJogador;
                    m_HJogadorDois.IsVencedor = _DOIS.IsVencedor;
                    m_HJogadorDois.PecasRestantes = _DOIS.PecasRestantes;
                    break;
                case TipoDosJogadores.ComputadorXComputador:
                    m_CJogadorUm.CorDoJogador = _UM.CorDoJogador;
                    m_CJogadorUm.IsEmbaixo = _UM.IsEmbaixo;
                    m_CJogadorUm.IsHumano = _UM.IsHumano;
                    m_CJogadorUm.IsPlaying = _UM.IsPlaying;
                    m_CJogadorUm.IsPrimeiroJogador = _UM.IsPrimeiroJogador;
                    m_CJogadorUm.IsVencedor = _UM.IsVencedor;
                    m_CJogadorUm.PecasRestantes = _UM.PecasRestantes;

                    m_CJogadorDois.CorDoJogador = _DOIS.CorDoJogador;
                    m_CJogadorDois.IsEmbaixo = _DOIS.IsEmbaixo;
                    m_CJogadorDois.IsHumano = _DOIS.IsHumano;
                    m_CJogadorDois.IsPlaying = _DOIS.IsPlaying;
                    m_CJogadorDois.IsPrimeiroJogador = _DOIS.IsPrimeiroJogador;
                    m_CJogadorDois.IsVencedor = _DOIS.IsVencedor;
                    m_CJogadorDois.PecasRestantes = _DOIS.PecasRestantes;
                    break;
                case TipoDosJogadores.ComputadorXFComputador:
                    m_CJogadorUm.CorDoJogador = _UM.CorDoJogador;
                    m_CJogadorUm.IsEmbaixo = _UM.IsEmbaixo;
                    m_CJogadorUm.IsHumano = _UM.IsHumano;
                    m_CJogadorUm.IsPlaying = _UM.IsPlaying;
                    m_CJogadorUm.IsPrimeiroJogador = _UM.IsPrimeiroJogador;
                    m_CJogadorUm.IsVencedor = _UM.IsVencedor;
                    m_CJogadorUm.PecasRestantes = _UM.PecasRestantes;

                    m_CJogadorDois.CorDoJogador = _DOIS.CorDoJogador;
                    m_CJogadorDois.IsEmbaixo = _DOIS.IsEmbaixo;
                    m_CJogadorDois.IsHumano = _DOIS.IsHumano;
                    m_CJogadorDois.IsPlaying = _DOIS.IsPlaying;
                    m_CJogadorDois.IsPrimeiroJogador = _DOIS.IsPrimeiroJogador;
                    m_CJogadorDois.IsVencedor = _DOIS.IsVencedor;
                    m_CJogadorDois.IsFuncional = _DOIS.IsFuncional;
                    m_CJogadorDois.PecasRestantes = _DOIS.PecasRestantes;
                    break;
                default:
                    break;
            }
        }
コード例 #3
0
ファイル: JComputador.cs プロジェクト: otaviokz/Eukreukla
        private int MinimaxAlfaBeta(BoardNode _Nodo, int _Profundidade,
            Jogador _udtJogadorMax, Jogador _udtJogadorMin, bool _isMax, int _alpha, int _beta)
        {
            if (_Profundidade == m_ProfundidadeTotal)
            {
                return CalculaValorJogada2(_Nodo.Tabuleiro, _Nodo.NumeroPecasJogador, _Nodo.NumeroPecasJogadorAdverario);
            }
            else
            {
                List<BoardNode> lstSucessores = new List<BoardNode>();

                int i = 0;

                if (_isMax)
                {
                    lstSucessores = GeraMovimentos(_Nodo, _udtJogadorMax.CorDoJogador);
                }
                else
                {
                    lstSucessores = GeraMovimentos(_Nodo, _udtJogadorMin.CorDoJogador);
                }
                int nroSucessores = lstSucessores.Count;
                if (lstSucessores.Count == 0)
                {
                    return CalculaValorJogada2(_Nodo.Tabuleiro, _Nodo.NumeroPecasJogador, _Nodo.NumeroPecasJogadorAdverario);
                }
                else
                {
                    if (_isMax)
                    {
                        while (i < nroSucessores && _beta > _alpha)
                        {
                            lstSucessores[i].StepCost = MinimaxAlfaBeta(lstSucessores[i], _Profundidade + 1,
                                _udtJogadorMax, _udtJogadorMin, !_isMax, _alpha, _beta);

                            if (lstSucessores[i].StepCost > _alpha)
                            {
                                _alpha = lstSucessores[i].StepCost;
                            }
                            i++;
                        }
                        return _alpha;
                    }
                    else
                    {
                        while (i < nroSucessores && _beta > _alpha)
                        {
                            lstSucessores[i].StepCost = MinimaxAlfaBeta(lstSucessores[i], _Profundidade + 1,
                                 _udtJogadorMax, _udtJogadorMin, !_isMax, _alpha, _beta);

                            if (lstSucessores[i].StepCost < _beta)
                            {
                                _beta = lstSucessores[i].StepCost;
                            }
                            i++;

                        }
                        return _beta;
                    }
                }
            }
        }
コード例 #4
0
ファイル: JComputador.cs プロジェクト: otaviokz/Eukreukla
        /// <summary>
        /// Algoritmo que realiza a jogada do computador.
        /// </summary>
        /// <param name="_Tabuleiro">aka Posição. Situacao atual do tabuleiro do jogo</param>
        /// <param name="_Profundidade">Profundidade da recursão. Esta ligada com a dificuldade
        /// do jogo (quanto mais profundo, mais dificil)</param>
        /// <param name="_udtJogador">Jogador que deve realizar a jogada.</param>
        /// <returns></returns>
        private int Minimax(BoardNode _Nodo, int _Profundidade,
            Jogador _udtJogadorMax, Jogador _udtJogadorMin, bool _isMax)
        {
            int numeroPecasJogadorAdverario = -1;
            //if (_Profundidade == 0)
            //{
            //    List<BoardNode> lstSucessores = new List<BoardNode>();
            //    lstSucessores = GeraMovimentos(_Nodo, _udtJogadorMax.CorDoJogador);
            //    for (int i = 0; i < lstSucessores.Count; i++)
            //    {
            //        lstSucessores[i] = Minimax(lstSucessores[i], _Profundidade + 1, _udtJogadorMax, _udtJogadorMin, false);
            //    }

            //    lstSucessores.Sort(Comparer<BoardNode>.Default);
            //    return lstSucessores[lstSucessores.Count - 1];
            //}
            if (_Profundidade == m_ProfundidadeTotal)
            {
                for (int i = 0; i < _Nodo.Tabuleiro.Length; i++)
                    if (_Nodo.Pai.Tabuleiro[i] == CorJogadorAdversario(this.CorDoJogador))
                        numeroPecasJogadorAdverario++;

                return CalculaValorJogada2(_Nodo.Tabuleiro, this.PecasRestantes, numeroPecasJogadorAdverario);

            }
            else
            {
                List<BoardNode> lstSucessores = new List<BoardNode>();
                lstSucessores = GeraMovimentos(_Nodo, _udtJogadorMin.CorDoJogador);
                if (lstSucessores.Count == 0)
                {
                    for (int i = 0; i < _Nodo.Tabuleiro.Length; i++)
                        if (_Nodo.Pai.Tabuleiro[i] == CorJogadorAdversario(this.CorDoJogador))
                            numeroPecasJogadorAdverario++;

                    return CalculaValorJogada2(_Nodo.Tabuleiro, this.PecasRestantes, numeroPecasJogadorAdverario);
                }
                else
                {
                    for (int i = 0; i < lstSucessores.Count; i++)
                    {
                        lstSucessores[i].StepCost = Minimax(lstSucessores[i], _Profundidade + 1, _udtJogadorMin, _udtJogadorMax, !_isMax);
                    }
                    lstSucessores.Sort(Comparer<BoardNode>.Default);

                    if (_isMax)
                    {
                        return lstSucessores[lstSucessores.Count - 1].StepCost;
                    }
                    else
                    {
                        return lstSucessores[0].StepCost;
                    }
                }
            }
        }
コード例 #5
0
ファイル: JComputador.cs プロジェクト: otaviokz/Eukreukla
        public int[] RealizaJogada(int[] _TabuleiroAtual, JComputador _udtJogadorPC, Jogador _udtJogadorAdversario, int _ProfundidadeTotal)
        {
            m_ProfundidadeTotal = _ProfundidadeTotal;
            List<BoardNode> lstProximosTabuleiros = GeraMovimentos(new BoardNode(_TabuleiroAtual, this.CorDoJogador), this.CorDoJogador);

            if (lstProximosTabuleiros.Count > 1)
            {
                for (int i = 0; i < lstProximosTabuleiros.Count; i++)
                {
                    lstProximosTabuleiros[i].StepCost = MinimaxAlfaBeta(lstProximosTabuleiros[i], 1,
                        _udtJogadorPC, _udtJogadorAdversario, false, int.MinValue, int.MaxValue);
                }

                lstProximosTabuleiros.Sort(Comparer<BoardNode>.Default);
            }

            if (lstProximosTabuleiros[lstProximosTabuleiros.Count - 1].Tabuleiro[0] == COMEU_PECA)
            {
                m_ComeuPeca = true;
                for (int i = 0; i < 26; i++)
                {
                    if (_TabuleiroAtual[i] == VAZIA &&
                        lstProximosTabuleiros[lstProximosTabuleiros.Count - 1].Tabuleiro[i] == this.CorDoJogador)
                        m_casaDestinoAposComer = i;
                }
            }
            else
                m_ComeuPeca = false;

            this.ProximaJogada = lstProximosTabuleiros[lstProximosTabuleiros.Count - 1].Tabuleiro;

            return lstProximosTabuleiros[lstProximosTabuleiros.Count - 1].Tabuleiro;
        }
コード例 #6
0
ファイル: FrmPrincipal.cs プロジェクト: otaviokz/Eukreukla
        private void menuCarregarJogo_Click(object sender, EventArgs e)
        {
            Stream stream = null;
            Dados carregaJogo = null;
            openFileDialog = new OpenFileDialog();
            openFileDialog.Filter = "Eukreukla files |*.euk";

            try
            {
                if (openFileDialog.ShowDialog() == DialogResult.OK)
                {
                    IFormatter formatter = new BinaryFormatter();
                    stream = new FileStream(openFileDialog.FileName, FileMode.Open, FileAccess.Read, FileShare.None);
                    int version = (int)formatter.Deserialize(stream);
                    carregaJogo = (Dados)formatter.Deserialize(stream);

                    m_enumTipoJogadores = carregaJogo.TipoDosJogadores;
                    novoJogo = carregaJogo.Jogo;
                    m_udtJogadorUm = carregaJogo.JogadorUM;
                    m_udtJogadorDois = carregaJogo.JogadorDOIS;
                    t_diferenca = carregaJogo.TempoDecorrido;

                    IniciarJogo(true);
                }

            }
            catch (Exception ex)
            {
            }
            finally
            {
                if (null != stream)
                    stream.Close();
                openFileDialog.Dispose();
                openFileDialog = null;
                carregaJogo = null;
            }
        }
コード例 #7
0
ファイル: FrmPrincipal.cs プロジェクト: otaviokz/Eukreukla
        /// <summary>
        /// Abre form de configuracao e recebe jogadores e tipo de jogo.
        /// </summary>
        private void Configuracao()
        {
            FrmConfig frmConfig = new FrmConfig();

            if (frmConfig.ShowDialog() == DialogResult.OK)
            {
                m_udtJogadorUm = frmConfig.JogadorUM;
                m_udtJogadorDois = frmConfig.JogadorDOIS;
                m_enumTipoJogadores = frmConfig.TipoDosJogadores;
            }
        }