public void CarregarModelo(ClienteJogador pJogador, int piNumJogador, ContentManager pContent)
        {
            int xLarg = 0, yLarg = 0;

            if ((piNumJogador == 1))
               this.modelo = pContent.Load<Texture2D>("peca_preta");
            else
               this.modelo = pContent.Load<Texture2D>("peca_branca");

            pJogador.ArialFont2 = pContent.Load<SpriteFont>("SpriteFont2");

            xLarg = (Principal.LARGURA_TELA / 8);
            yLarg = (Principal.ALTURA_TELA / 8);

            this.EspacoPeca = new Rectangle
                                    (Convert.ToInt32(this.PosicaoAtual.X),
                                     Convert.ToInt32(this.PosicaoAtual.Y),
                                     Convert.ToInt32(xLarg),
                                     Convert.ToInt32(yLarg));
        }
        public void DesenharPecas(ClienteJogador pJogador, SpriteBatch pSpriteBatch)
        {
            string sMsg = "";

            if ((this.Ativa))
            {
                pSpriteBatch.Draw(
                    this.modelo,
                    this.PosicaoAtual,
                    null,
                    Color.White,
                    0, //Rotação
                    this.PosicaoOriginal,
                    1.0f,
                    SpriteEffects.None,
                    0f);
            }

            if ((pJogador.EstadoJogador == ""))
                pJogador.ContaTempoMensagem = 2000;
            else
            {
                pJogador.ContaTempoMensagem = pJogador.ContaTempoMensagem - 1;
                if ((pJogador.ContaTempoMensagem <= 0))
                {
                    if ((pJogador.EstadoJogador == "SELECIONOU_PECA"))
                    {
                        pJogador.ContaTempoMensagem = 2000;
                        pJogador.EstadoJogador = "SELECIONE_QUADRO";
                    }
                    else if ((pJogador.EstadoJogador == "SELECIONOU_QUADRO"))
                    {
                        pJogador.ContaTempoMensagem = 2000;
                        pJogador.EstadoJogador = "MOVENDO_PECA";
                    }
                    else if ((pJogador.EstadoJogador == "AGUARDANDO_OUTRO_JOGADOR"))
                        pJogador.ContaTempoMensagem = 2000;
                    else
                        pJogador.EstadoJogador = "";
                }
            } //else

            if ((pJogador.EstadoJogador == "AGUARDANDO_SELECAO"))
                sMsg = "Selecione a peca para mover.";
            else if ((pJogador.EstadoJogador == "AGUARDANDO_MOVIMENTO"))
                sMsg = "Selecione local para mover a peca.";
            else if ((pJogador.EstadoJogador == "AGUARDANDO_SELECAO"))
                sMsg = "Selecione a peca para mover.";
            else if ((pJogador.EstadoJogador == "MOVIMENTACAO_INVALIDA"))
                sMsg = "Movimentacao nao permitida. Selecione outra peca.";
            else if ((pJogador.EstadoJogador == "AGUARDANDO_OUTRO_JOGADOR"))
                sMsg = "Aguardando outro jogador.";
            else if ((pJogador.EstadoJogador == "GANHOU"))
                sMsg = "Voce ganhou.";
            else if ((pJogador.EstadoJogador == "PERDEU"))
                sMsg = "Voce perdeu.";
            else if ((pJogador.EstadoJogador == "SEM_CONEXAO"))
                sMsg = "Nao conectado ao servidor.";
            else if ((pJogador.EstadoJogador == "SELECIONE_QUADRO"))
                sMsg = "Selecione o local para mover a peca.";
            else if ((pJogador.EstadoJogador == "SELECIONOU_PECA"))
                sMsg = "Selecionou peca: " + Convert.ToString(pJogador.PecaSelecionada + 1);
            else if ((pJogador.EstadoJogador == "SELECIONOU_QUADRO"))
                sMsg = "Selecionou quadro: " + Convert.ToString(pJogador.QuadroSelecionado);
            else if ((pJogador.EstadoJogador == "MOVENDO_PECA"))
                sMsg = "Movendo a peca.";
            else
            {
                if ((pJogador.EstadoJogador != ""))
                {
                    sMsg = pJogador.EstadoJogador;
                    pJogador.EstadoJogador = "";
                }
                else
                {
                    sMsg = "";
                }
            }

               if ((sMsg != "")) {
              pSpriteBatch.DrawString(
                   pJogador.ArialFont2,
                   sMsg,
                   pJogador.PosicaoTextoMsg,
                   Color.BlueViolet);
               } //if ((sMsg != "")) {
        }
        public void jogadorUpdate(ref ClienteJogador pJogador, KeyboardState teclado_estado, MouseState mouseState)
        {
            //PEgar estado e mover a peça.
            //Depois enviar movimentacao ao serivor
            //Se servidor retornar OK, atualizar a tela
            //aguardar pela moviemntaão do outro jogador

            Boolean bClicou = false;
            Rectangle QuadradoMouse;
            Rectangle QuadradoQuadroTabuleiro;

            if (mouseState.LeftButton == Microsoft.Xna.Framework.Input.ButtonState.Pressed)
            {
                bClicou = true;
                QuadradoMouse = new Rectangle
                                    (Convert.ToInt32(mouseState.X - 1),
                                     Convert.ToInt32(mouseState.Y - 1),
                                     Convert.ToInt32(mouseState.X + 1),
                                     Convert.ToInt32(mouseState.Y + 1));
            }

                //Nenhuma peça selecionada.
                if ((pJogador.PecaSelecionada >= 0) &&
                    (pJogador.QuadroSelecionado >= 0))
                {
                    Boolean bMoveu = false;
                    int posX = 0, posY = 0, xMoverPara = 0, yMoverPara = 0;
                    Vector2 posicaoTemp1 = new Vector2(0, 0);
                    Vector2 posicaoTemp2 = new Vector2(0, 0);

                    //MOver peça para o quadro
                    if ((pJogador.NumJogadorCliente <= 1))
                    {
                        posicaoTemp1 = this.ClienteTabuleiroLocal.quadros[pJogador.QuadroSelecionado].posicaoInicio;
                    }
                    else if ((pJogador.NumJogadorCliente >= 2))
                    {
                        posicaoTemp2 = this.ClienteTabuleiroLocal.quadros[pJogador.QuadroSelecionado].posicaoInicio;
                    }

                    //Local
                    posX = Convert.ToInt32(((this.ClienteTabuleiroLocal.quadros[pJogador.QuadroSelecionado].posicaoFim.X - Principal.DIFX) / Convert.ToInt32(Principal.LARGURA_TELA / 8)));
                    posY = Convert.ToInt32(((this.ClienteTabuleiroLocal.quadros[pJogador.QuadroSelecionado].posicaoFim.Y - Principal.DIFY) / Convert.ToInt32(Principal.ALTURA_TELA / 8)));

                    xMoverPara = posX + 1;
                    yMoverPara = posY;

                    bMoveu = pJogador.clientNetwork.MoverPeca(
                               pJogador.NumJogadorCliente - 1,
                               pJogador.PecaSelecionada,
                               xMoverPara,
                               yMoverPara);

                    if ((bMoveu))
                    {

                        if ((pJogador.NumJogadorCliente <= 1))
                        {
                            pJogador.ClientePecasLocal1[pJogador.PecaSelecionada].PosicaoAtual = posicaoTemp1;
                        }
                        else if ((pJogador.NumJogadorCliente >= 2))
                        {
                            pJogador.ClientePecasLocal2[pJogador.PecaSelecionada].PosicaoAtual = posicaoTemp2;
                        }

                        pJogador.TabuleiroLocal.lJogador[pJogador.NumJogadorCliente - 1].Peca[pJogador.PecaSelecionada].PosicaoXDaPeca = xMoverPara;
                        pJogador.TabuleiroLocal.lJogador[pJogador.NumJogadorCliente - 1].Peca[pJogador.PecaSelecionada].PosicaoYDaPeca = yMoverPara;

                        if ((pJogador.NumJogadorCliente <= 1))
                        {
                            for (int i = 0; i < pJogador.ClientePecasLocal1.Count(); i++)
                            {
                                pJogador.ClientePecasLocal1[i].Iniciar(pJogador.TabuleiroLocal, 0, i);
                            }
                        }
                        else if ((pJogador.NumJogadorCliente >= 2))
                        {
                            for (int i = 0; i < pJogador.ClientePecasLocal1.Count(); i++)
                            {
                                pJogador.ClientePecasLocal2[i].Iniciar(pJogador.TabuleiroLocal, 1, i);
                            }
                        }

                        Int32 iUltJogPecaMorta = -1, iUltPecaAMorrer = -1;

                        pJogador.PecaSelecionada = -1;
                        pJogador.QuadroSelecionado = -1;
                        pJogador.EstadoJogador = "AGUARDANDO_OUTRO_JOGADOR";

                        iUltJogPecaMorta = pJogador.clientNetwork.GetUltimoJogadorPecaMorta();
                        if ((iUltJogPecaMorta >= 0))
                        {
                            iUltPecaAMorrer = pJogador.clientNetwork.GetUltimaPecaAMover();

                            if ((iUltPecaAMorrer >= 0))
                            {
                                if ((iUltJogPecaMorta == 0))
                                {
                                    pJogador.ClientePecasLocal1[iUltJogPecaMorta].Ativa = false;
                                }
                                else
                                {
                                    pJogador.ClientePecasLocal2[iUltJogPecaMorta].Ativa = false;
                                }
                            }
                        }
                    }
                    else
                    {

                        pJogador.PecaSelecionada = -1;
                        pJogador.QuadroSelecionado = -1;
                        pJogador.EstadoJogador = "MOVIMENTACAO_INVALIDA";
                    } //else

                } //if
                else if ((bClicou) &&
                         (pJogador.EstadoJogador != "AGUARDANDO_OUTRO_JOGADOR") &&
                        (pJogador.PecaSelecionada <= -1) &&
                         (pJogador.QuadroSelecionado <= -1))
                {
                    int xLarg = 0, yLarg = 0;

                     xLarg = (Principal.LARGURA_TELA / 8);
                     yLarg = (Principal.ALTURA_TELA / 8);

                    if ((pJogador.NumJogadorCliente <= 1))
                    {
                        for (int i = 0; i < pJogador.ClientePecasLocal1.Count(); i++)
                        {

                            if ((pJogador.ClientePecasLocal1[i].PosicaoAtual.X <= mouseState.X) &&
                                (pJogador.ClientePecasLocal1[i].PosicaoAtual.X + xLarg >= mouseState.X) &&
                                (pJogador.ClientePecasLocal1[i].PosicaoAtual.Y <= mouseState.Y) &&
                                (pJogador.ClientePecasLocal1[i].PosicaoAtual.Y + yLarg >= mouseState.Y))
                            {
                                pJogador.PecaSelecionada = i;
                                pJogador.EstadoJogador = "SELECIONOU_PECA";
                            }

                            //if ((ClientePecasLocal1[i].EspacoPeca.Intersects(QuadradoMouse)))
                            //{
                            //}
                        } //for
                    }
                    else if ((pJogador.NumJogadorCliente >= 2))
                    {

                        for (int i = 0; i < pJogador.ClientePecasLocal2.Count(); i++)
                        {

                            if ((pJogador.ClientePecasLocal2[i].PosicaoAtual.X <= mouseState.X) &&
                                (pJogador.ClientePecasLocal2[i].PosicaoAtual.X + xLarg >= mouseState.X) &&
                                (pJogador.ClientePecasLocal2[i].PosicaoAtual.Y <= mouseState.Y) &&
                                (pJogador.ClientePecasLocal2[i].PosicaoAtual.Y + yLarg >= mouseState.Y))
                            {
                                pJogador.PecaSelecionada = i;
                                pJogador.EstadoJogador = "SELECIONOU_PECA";
                            }

                            //if ((ClientePecasLocal2[i].EspacoPeca.Intersects(QuadradoMouse)))
                            //{
                            //}
                        } //for
                    }

                    Thread.Sleep(500);

                } //(pJogador.PecaSelecionada <= -1)
                else if ((bClicou) &&
                         (pJogador.EstadoJogador != "AGUARDANDO_OUTRO_JOGADOR") &&
                         (pJogador.QuadroSelecionado <= -1) &&
                         (pJogador.PecaSelecionada >= 0))
                {
                    int xLarg = 0, yLarg = 0;

                    xLarg = (Principal.LARGURA_TELA / 8);
                    yLarg = (Principal.ALTURA_TELA / 8);

                    for (int i = 0; i < this.ClienteTabuleiroLocal.quadros.Count(); i++)
                    {
                        QuadradoQuadroTabuleiro =
                                 new Rectangle
                                       (Convert.ToInt32(ClienteTabuleiroLocal.quadros[i].posicaoInicio.X),
                                        Convert.ToInt32(ClienteTabuleiroLocal.quadros[i].posicaoInicio.Y),
                                        Convert.ToInt32(ClienteTabuleiroLocal.quadros[i].posicaoFim.X),
                                        Convert.ToInt32(ClienteTabuleiroLocal.quadros[i].posicaoFim.Y));

                        if ((ClienteTabuleiroLocal.quadros[i].posicaoInicio.X <= mouseState.X) &&
                            (ClienteTabuleiroLocal.quadros[i].posicaoInicio.X + xLarg >= mouseState.X) &&
                            (ClienteTabuleiroLocal.quadros[i].posicaoInicio.Y <= mouseState.Y) &&
                            (ClienteTabuleiroLocal.quadros[i].posicaoInicio.Y + yLarg >= mouseState.Y))
                        {
                            pJogador.QuadroSelecionado = i;
                            pJogador.EstadoJogador = "SELECIONOU_QUADRO";
                        }

                        //if ((QuadradoQuadroTabuleiro.Intersects(QuadradoMouse)))
                        //{
                        //}  //if

                    } //for

                    Thread.Sleep(500);
                }
                else if ((pJogador.EstadoJogador == "AGUARDANDO_OUTRO_JOGADOR") ||
                         (pJogador.EstadoJogador == ""))
                {
                    Int32 iUtlJogadorAMover = -1;

                    iUtlJogadorAMover = pJogador.clientNetwork.GetUltimoJogadorAMover();

                    if ((iUtlJogadorAMover > -1) &&
                        (iUtlJogadorAMover != pJogador.NumJogadorCliente)) {

                            pJogador.EstadoJogador = "";

                            iUtlJogadorAMover = iUtlJogadorAMover - 1;

                            Int32 iUltimaPecaAMover = -1;
                            Int32 iPosXUltimaPeca = 0;
                            Int32 iPosYUltimaPeca = 0;

                            iUltimaPecaAMover = pJogador.clientNetwork.GetUltimaPecaAMover();

                            if ((iUltimaPecaAMover >= 0))
                            {

                                iPosXUltimaPeca = pJogador.clientNetwork.GetXUltimaPeca();
                                iPosYUltimaPeca = pJogador.clientNetwork.GetYUltimaPeca();

                                if ((iUtlJogadorAMover == 0))
                                {

                                    pJogador.TabuleiroLocal.lJogador[iUtlJogadorAMover].Peca[iUltimaPecaAMover].PosicaoXDaPeca = iPosXUltimaPeca;
                                    pJogador.TabuleiroLocal.lJogador[iUtlJogadorAMover].Peca[iUltimaPecaAMover].PosicaoYDaPeca = iPosYUltimaPeca;

                                    pJogador.ClientePecasLocal1[iUltimaPecaAMover].Iniciar(pJogador.TabuleiroLocal, iUtlJogadorAMover, iUltimaPecaAMover);

                                }
                                else
                                {
                                    pJogador.TabuleiroLocal.lJogador[iUtlJogadorAMover].Peca[iUltimaPecaAMover].PosicaoXDaPeca = iPosXUltimaPeca;
                                    pJogador.TabuleiroLocal.lJogador[iUtlJogadorAMover].Peca[iUltimaPecaAMover].PosicaoYDaPeca = iPosYUltimaPeca;

                                    pJogador.ClientePecasLocal2[iUltimaPecaAMover].Iniciar(pJogador.TabuleiroLocal, iUtlJogadorAMover, iUltimaPecaAMover);
                                }
                            }
                    }
                }
        }
 public void jogadorLoadContent(ref ClienteJogador pJogador, Viewport pViewport, ContentManager pContent)
 {
     if ((pJogador.ClienteTabuleiroLocal != null))
         pJogador.ClienteTabuleiroLocal.CarregarModelo(pContent);
     for (int i = 0; i < pJogador.ClientePecasLocal1.Count(); i++)
     {
         if ((pJogador.ClientePecasLocal1[i] != null))
         {
             pJogador.ClientePecasLocal1[i].CarregarModelo(pJogador, 1, pContent);
         }
     }
     for (int i = 0; i < pJogador.ClientePecasLocal2.Count(); i++)
     {
         if ((pJogador.ClientePecasLocal2[i] != null))
         {
             pJogador.ClientePecasLocal2[i].CarregarModelo(pJogador, 2, pContent);
         }
     }
 }
        public void jogadorDraw(ref ClienteJogador pJogador, SpriteBatch pSpriteBatch)
        {
            if ((pJogador.ClienteTabuleiroLocal != null))
                pJogador.ClienteTabuleiroLocal.DesenharTabuleiro(pSpriteBatch);

            for (int i = 0; i < pJogador.ClientePecasLocal1.Count(); i++)
            {
                if ((pJogador.ClientePecasLocal1[i] != null))
                    pJogador.ClientePecasLocal1[i].DesenharPecas(pJogador, pSpriteBatch);
            }

            for (int i = 0; i < pJogador.ClientePecasLocal2.Count(); i++)
            {
                if ((pJogador.ClientePecasLocal2[i] != null))
                    pJogador.ClientePecasLocal2[i].DesenharPecas(pJogador, pSpriteBatch);
            }
        }
        public void Iniciar(ref ClienteJogador pJogador, string pipDoServidor, Int32 NumJogadorSel)
        {
            ClassesTabuleiro lTab = new ClassesTabuleiro();

            string sStatus = "";
            Vector2 lTextoMsg = new Vector2(0, 0);

            clientNetwork = new ClienteClientNetWork();
            clientNetwork.Iniciar(pipDoServidor, NumJogadorSel);

            if ((clientNetwork.StatusConexao() == false))
            {
                this.Conectado = false;
                this.EstadoJogador = "SEM_CONEXAO";
                //MessageBox.Show("Não foi possível conectar ao servidor.");
            }
            else
            {
                this.Conectado = true;
                this.EstadoJogador = "";
            }
            sStatus = this.EstadoJogador;

            Random rnd = new Random(DateTime.Now.Millisecond);
            rnd.Next();
            int iNumJogadorRemoto = rnd.Next(1, 999);
            int iNumJogadorTabuleiro = 0;

            if ((this.Conectado))
            {
                iNumJogadorTabuleiro = clientNetwork.GetNumeroJogador(iNumJogadorRemoto);

                if ((iNumJogadorTabuleiro > 0))
                {
                    lTab = clientNetwork.GetTabuleiro();
                }
                this.NumJogadorCliente = iNumJogadorTabuleiro;
            }

            if ((lTab != null))
            {
                TabuleiroLocal = lTab;
            }

            {
                TabuleiroLocal.lJogador[0] = new ClassesJogador();
                TabuleiroLocal.lJogador[0].IniciarJogador("1");

                TabuleiroLocal.lJogador[1] = new ClassesJogador();
                TabuleiroLocal.lJogador[1].IniciarJogador("2");
            }

            if ((ClienteTabuleiroLocal != null))
            {
                ClienteTabuleiroLocal = new ClienteTabuleiroLocal();
                ClienteTabuleiroLocal.Iniciar();
            }

            for (int tj = 0; tj < TabuleiroLocal.lJogador.Count(); tj++)
            {
                if ((tj == 0))
                {
                    for (int i = 0; i < pJogador.ClientePecasLocal1.Count(); i++)
                    {
                        pJogador.ClientePecasLocal1[i] = new ClientePecasLocal();
                        if ((pJogador.ClientePecasLocal1[i] != null))
                            pJogador.ClientePecasLocal1[i].Iniciar(TabuleiroLocal, tj, i);
                    }
                }
                else
                {
                    for (int i = 0; i < pJogador.ClientePecasLocal2.Count(); i++)
                    {
                        pJogador.ClientePecasLocal2[i] = new ClientePecasLocal();
                        if ((pJogador.ClientePecasLocal2[i] != null))
                            pJogador.ClientePecasLocal2[i].Iniciar(TabuleiroLocal, tj, i);
                    }
                }
            }

            lTextoMsg.X = (10);
            lTextoMsg.Y = (Principal.ALTURA_TELA - 80);
            this.PosicaoTextoMsg = lTextoMsg;

            this.Iniciado = true;
            this.EstadoJogador = sStatus;
        }