public static void Atirar(ref aviao pAviao)
        {
            TimeSpan Dif;

            Dif = DateTime.Now - pAviao.DataHoraUltimoTiro;

            if ((pAviao.morto == false))
            {
                if ((pAviao.iQtdeTiros > 0) &&
                   (Dif.Milliseconds >= 300.0f))
                {
                    AtivarDesativarTiro(ref pAviao.AviaoTiros[pAviao.iQtdeTiros - 1], true);

                    pAviao.AviaoTiros[pAviao.iQtdeTiros - 1].posicaoatual = pAviao.posicaoatual;
                    //pAviao.AviaoTiros[pAviao.iQtdeTiros - 1].posicaoatual.Y += (pAviao.modelo.Width / 2) - 5.0f;

                    pAviao.AviaoTiros[pAviao.iQtdeTiros - 1].posicaooriginal = pAviao.posicaooriginal;
                    pAviao.AviaoTiros[pAviao.iQtdeTiros - 1].posicaooriginal.X = pAviao.AviaoTiros[pAviao.iQtdeTiros - 1].posicaooriginal.X / 4 - 2.0f;

                    pAviao.AviaoTiros[pAviao.iQtdeTiros - 1].EspacoTiro = new Rectangle
                            (Convert.ToInt32(pAviao.AviaoTiros[pAviao.iQtdeTiros - 1].posicaoatual.X),
                             Convert.ToInt32(pAviao.AviaoTiros[pAviao.iQtdeTiros - 1].posicaoatual.Y),
                             Convert.ToInt32(pAviao.AviaoTiros[pAviao.iQtdeTiros - 1].modelo.Width),
                             Convert.ToInt32(pAviao.AviaoTiros[pAviao.iQtdeTiros - 1].modelo.Height));

                    pAviao.AviaoTiros[pAviao.iQtdeTiros - 1].Rotacao = pAviao.Rotacao;

                    pAviao.iQtdeTiros -= 1;
                    pAviao.DataHoraUltimoTiro = DateTime.Now;
                }
            }
        }
        public static void CarregarModelo(ref aviao[] pAvioes, ContentManager pContent, Viewport pViewport)
        {
            for (int i = 0; i < pAvioes.Count(); i++)
            {
                //if ((pAvioes[i].ativo == true))
                //{
                    pAvioes[i].modelo = pContent.Load<Texture2D>("aviao_p" + Convert.ToString(i + 1));
                    pAvioes[i].modeloExplosao = pContent.Load<Texture2D>("Explosion");
                    pAvioes[i].arialFont = pContent.Load<SpriteFont>("SpriteFont1");
                    pAvioes[i].arialFont2 = pContent.Load<SpriteFont>("SpriteFont2");

                    pAvioes[i].posicaooriginal.X = pAvioes[i].modelo.Width / 2;
                    pAvioes[i].posicaooriginal.Y = pAvioes[i].modelo.Height / 2;

                    //pAvioes[i].posicaoatual.X = pViewport.Width / 2;
                    //pAvioes[i].posicaoatual.Y = pViewport.Height / 2;

                    pAvioes[i].EspacoAviao = new Rectangle
                        (Convert.ToInt32(pAvioes[i].posicaoatual.X),
                         Convert.ToInt32(pAvioes[i].posicaoatual.Y),
                         Convert.ToInt32(pAvioes[i].modelo.Width),
                         Convert.ToInt32(pAvioes[i].modelo.Height));

                    pAvioes[i].EmMovimento = true;
                    MoverParaFrente(ref pAvioes[i]);
                //}
            }
        }
        public static void CarregarModelo(aviao pAvioes, ref tiro[] pTiros, ContentManager pContent, Viewport pViewport)
        {
            for (int i = 0; i < pTiros.Count(); i++)
            {
                if ((pTiros[i].ativo == true) &&
                    (pTiros[i].carregoumodelo == false))
                {
                    pTiros[i].modelo = pContent.Load<Texture2D>("tiro");

                    pTiros[i].posicaooriginal.X = pTiros[i].modelo.Width / 2;
                    pTiros[i].posicaooriginal.Y = pTiros[i].modelo.Height / 2;
                    pTiros[i].posicaoatual.X = pViewport.Width / 2;
                    pTiros[i].posicaoatual.Y = pViewport.Height / 2;

                    pTiros[i].carregoumodelo = true;
                }
            }
        }
        public static void ZerarTempoTiros(ref aviao[] pAvioes)
        {
            DateTime Data = DateTime.Now;

            for (int i = 0; i < pAvioes.Count(); i++)
            {
                pAvioes[i].DataHoraUltimoTiro = pAvioes[i].DataHoraInicial;
            }
        }
        public static void VerifVencedor(ref aviao[] pAvioes)
        {
            Int32 icv = 0, icm = 0, iv = 0, icativs = 0;
            for (int i = 0; i < pAvioes.Count(); i++)
            {
                if ((pAvioes[i].ativo == true))
                {
                    icativs++;
                    if ((pAvioes[i].morto == true))
                        icm = icm + 1;
                    else
                    {
                        icv = icv + 1;
                        iv = i;
                    }
                }
            }

            if ((icv == 1) && (icativs != 1))
                pAvioes[iv].Vencedor = true;
        }
        public static void PosicionarAvioes(ref aviao[] pAvioes, Viewport pViewport)
        {
            Random rnd = new Random(DateTime.Now.Millisecond);

            for (int i = 0; i < pAvioes.Count(); i++)
            {
                Boolean bProximo = false;

                //if ((pAvioes[i].ativo == true))
                //{
                    //pAvioes[i].posicaoatual.X = 200;
                    //pAvioes[i].posicaoatual.Y = 200;
                    //pAvioes[i].posicaooriginal.X = pAvioes[i].modelo.Width / 2;
                    //pAvioes[i].posicaooriginal.Y = pAvioes[i].modelo.Height / 2;
                    bProximo = true;
                    while (bProximo)
                    {
                        rnd.Next();
                        pAvioes[i].posicaoatual.X = rnd.Next(70, Principal.gciLimiteLargura - 70);
                        rnd.Next();
                        pAvioes[i].posicaoatual.Y = rnd.Next(70, Principal.gciLimiteAltura - 70);
                        rnd.Next();
                        pAvioes[i].Rotacao = rnd.Next(1, 4) * pAvioes[i].Rotacao;

                        if ((i <= 0))
                            bProximo = false;
                        else //Não permite que aviões comecem muito pertos uns dos outros!
                        {
                            if (!(pAvioes[i].EspacoAviao.Intersects(pAvioes[i - 1].EspacoAviao)))
                                bProximo = false;
                        }
                    }
                //}
            }
        }
        public static void Movimentar(ref aviao[] pAvioes, string sDirecao)
        {
            for (int i = 0; i < pAvioes.Count(); i++)
            {
                if ((pAvioes[i].ativo == true) &&
                    (pAvioes[i].EmMovimento == true))
                {
                    try
                    {
                        //Aplicar ângulo sobre a movimentação
                        if ((sDirecao == "F"))
                        {
                            pAvioes[i].posicaoatual.Y = (pAvioes[i].posicaoatual.Y -
                                (pAvioes[i].ValorVelocidadePadrao * (float)Math.Cos(pAvioes[i].Rotacao)));

                            pAvioes[i].EspacoAviao.Y = (pAvioes[i].EspacoAviao.Y -
                                Convert.ToInt32(pAvioes[i].ValorVelocidadePadrao * (float)Math.Cos(pAvioes[i].Rotacao)));

                            pAvioes[i].posicaoatual.X = (pAvioes[i].posicaoatual.X -
                                (pAvioes[i].ValorVelocidadePadrao * (float)-Math.Sin(pAvioes[i].Rotacao)));

                            pAvioes[i].EspacoAviao.X = (pAvioes[i].EspacoAviao.X -
                                Convert.ToInt32(pAvioes[i].ValorVelocidadePadrao * (float)-Math.Sin(pAvioes[i].Rotacao)));
                        }
                        else if ((sDirecao == "T"))
                        {
                            pAvioes[i].posicaoatual.Y = (pAvioes[i].posicaoatual.Y +
                                (pAvioes[i].ValorVelocidadePadrao * (float)Math.Cos(pAvioes[i].Rotacao)));

                            pAvioes[i].EspacoAviao.Y = (pAvioes[i].EspacoAviao.Y +
                                Convert.ToInt32(pAvioes[i].ValorVelocidadePadrao * (float)Math.Cos(pAvioes[i].Rotacao)));

                            pAvioes[i].posicaoatual.X = (pAvioes[i].posicaoatual.X +
                                (pAvioes[i].ValorVelocidadePadrao * (float)-Math.Sin(pAvioes[i].Rotacao)));

                            pAvioes[i].EspacoAviao.X = (pAvioes[i].EspacoAviao.X +
                                Convert.ToInt32(pAvioes[i].ValorVelocidadePadrao * (float)-Math.Sin(pAvioes[i].Rotacao)));
                        }

                        pAvioes[i].fDirecaoRotacao = pAvioes[i].Rotacao;

                        if ((pAvioes[i].posicaoatual.X >= Principal.gciLimiteLargura))
                        {
                            pAvioes[i].posicaoatual.X = 0 - pAvioes[i].modelo.Width;
                            pAvioes[i].EspacoAviao.X = Convert.ToInt32(pAvioes[i].posicaoatual.X);
                        }
                        else if ((pAvioes[i].posicaoatual.X + pAvioes[i].modelo.Width <= 0))
                        {
                            pAvioes[i].posicaoatual.X = Principal.gciLimiteLargura;
                            pAvioes[i].EspacoAviao.X = Convert.ToInt32(pAvioes[i].posicaoatual.X);
                        }

                        if ((pAvioes[i].posicaoatual.Y >= Principal.gciLimiteAltura))
                        {
                            pAvioes[i].posicaoatual.Y = 0 - pAvioes[i].modelo.Height;
                            pAvioes[i].EspacoAviao.Y = Convert.ToInt32(pAvioes[i].posicaoatual.Y);
                        }
                        else if ((pAvioes[i].posicaoatual.Y + pAvioes[i].modelo.Height <= 0))
                        {
                            pAvioes[i].posicaoatual.Y = Principal.gciLimiteAltura;
                            pAvioes[i].EspacoAviao.Y = Convert.ToInt32(pAvioes[i].posicaoatual.Y);
                        }
                    }
                    finally
                    {
                        pAvioes[i].EmMovimento = false;
                    }
                }
            }
        }
        public static Boolean MoverParaTraz(ref aviao pAviao)
        {
            aviao[] tmpAviao = new aviao[1];

            pAviao.EmMovimento = true;
            tmpAviao[0] = pAviao;

            aviao.Movimentar(ref tmpAviao, "T");

            pAviao = tmpAviao[0];

            return false;
        }
        public static void Iniciar(ref aviao[] pAvioes, Boolean pbForceAtivo)
        {
            DateTime Data = DateTime.Now;

            for (int i = 0; i < pAvioes.Count(); i++)
            {
                if ((pAvioes[i] == null))
                   pAvioes[i] = new aviao();
                pAvioes[i].ativo = ((pbForceAtivo));
                pAvioes[i].morto = false;
                pAvioes[i].EmMovimento = false;
                pAvioes[i].DataHoraUltimoTiro = Data;
                pAvioes[i].DataHoraInicial = Data;
                pAvioes[i].DataHoraUltEnvio = Data;
                pAvioes[i].DataHoraUltRecebimeno = Data;
                pAvioes[i].DataHoraUltAtualizacaoTela = Data;
                pAvioes[i].NomeJogador = ("Jogador " + Convert.ToString(i + 1));

                if ((i == 3))
                    pAvioes[i].CorAviao = Color.Pink;
                else if ((i == 2))
                    pAvioes[i].CorAviao = Color.Red;
                else if ((i == 1))
                    pAvioes[i].CorAviao = Color.Green;
                else
                    pAvioes[i].CorAviao = Color.Black;

                tiro.Iniciar(ref pAvioes[i].AviaoTiros);
                for (int j = 0; j < pAvioes[i].AviaoTiros.Count(); j ++) {
                    tiro.Iniciar(ref pAvioes[i].AviaoTiros);
                }
            }
        }
        public static Boolean GirarParaEsquerda(ref aviao pAviao)
        {
            float fTemp = 0;

            if ((pAviao.ativo == true))
            {
                pAviao.Rotacao = pAviao.Rotacao - pAviao.ValorRotacaoPadrao;
                pAviao.EmMovimento = true;
                fTemp = MathHelper.Pi * 2;
                pAviao.Rotacao = pAviao.Rotacao % fTemp;

                return true;
            }
            else
            {
                return false;
            }
        }
        public static void ExplodirAviao(ref aviao pAviao)
        {
            if ((pAviao.ativo == true))
            {
                if ((pAviao.iQtdeVidas > 0))
                    pAviao.iQtdeVidas -= 1;

                pAviao.Explodir = true;
            } //for
        }
 public static void DesenharTiro(aviao pAviao, ref tiro[] pTiro, SpriteBatch pSpriteBatch)
 {
     for (int i = pAviao.iQtdeTiros; i < pTiro.Count(); i++)
     {
         if ((pTiro[i].ativo == true) &&
             (pTiro[i].desenhar == true))
         {
             pSpriteBatch.Draw(
                pTiro[i].modelo,
                pTiro[i].posicaoatual,
                null,
                Color.White,
                pTiro[i].Rotacao,
                pTiro[i].posicaooriginal,
                1.0f,
                SpriteEffects.None,
                0f);
         }
     } //for
 }
        public static void Movimentar(ref aviao[] pAvioes, Int32 pIndice, string sDirecao)
        {
            for (int i = pAvioes[pIndice].iQtdeTiros; i < pAvioes[pIndice].AviaoTiros.Count(); i++)
            {
                if ((pAvioes[pIndice].AviaoTiros[i].ativo == true) &&
                    (pAvioes[pIndice].AviaoTiros[i].movimentar == true))
                {
                    //Aplicar ângulo sobre a movimentação
                    if ((sDirecao == "F"))
                    {
                        pAvioes[pIndice].AviaoTiros[i].posicaoatual.Y = (pAvioes[pIndice].AviaoTiros[i].posicaoatual.Y -
                            (pAvioes[pIndice].AviaoTiros[i].ValorVelocidadeTiro * (float)Math.Cos(pAvioes[pIndice].AviaoTiros[i].Rotacao)));

                        pAvioes[pIndice].AviaoTiros[i].EspacoTiro.Y = (pAvioes[pIndice].AviaoTiros[i].EspacoTiro.Y -
                            Convert.ToInt32(pAvioes[pIndice].AviaoTiros[i].ValorVelocidadeTiro * (float)Math.Cos(pAvioes[pIndice].AviaoTiros[i].Rotacao)));

                        pAvioes[pIndice].AviaoTiros[i].posicaoatual.X = (pAvioes[pIndice].AviaoTiros[i].posicaoatual.X -
                            (pAvioes[pIndice].AviaoTiros[i].ValorVelocidadeTiro * (float)-Math.Sin(pAvioes[pIndice].AviaoTiros[i].Rotacao)));

                        pAvioes[pIndice].AviaoTiros[i].EspacoTiro.X = (pAvioes[pIndice].AviaoTiros[i].EspacoTiro.X -
                            Convert.ToInt32(pAvioes[pIndice].AviaoTiros[i].ValorVelocidadeTiro * (float)-Math.Sin(pAvioes[pIndice].AviaoTiros[i].Rotacao)));
                    }
                    else if ((sDirecao == "T"))
                    {
                        pAvioes[pIndice].AviaoTiros[i].posicaoatual.Y = (pAvioes[pIndice].AviaoTiros[i].posicaoatual.Y +
                            (pAvioes[pIndice].AviaoTiros[i].ValorVelocidadeTiro * (float)Math.Cos(pAvioes[pIndice].AviaoTiros[i].Rotacao)));

                        pAvioes[pIndice].AviaoTiros[i].EspacoTiro.Y = (pAvioes[pIndice].AviaoTiros[i].EspacoTiro.Y +
                            Convert.ToInt32(pAvioes[pIndice].AviaoTiros[i].ValorVelocidadeTiro * (float)Math.Cos(pAvioes[pIndice].AviaoTiros[i].Rotacao)));

                        pAvioes[pIndice].AviaoTiros[i].posicaoatual.X = (pAvioes[pIndice].AviaoTiros[i].posicaoatual.X +
                            (pAvioes[pIndice].AviaoTiros[i].ValorVelocidadeTiro * (float)-Math.Sin(pAvioes[pIndice].AviaoTiros[i].Rotacao)));

                        pAvioes[pIndice].AviaoTiros[i].EspacoTiro.X = (pAvioes[pIndice].AviaoTiros[i].EspacoTiro.X +
                            Convert.ToInt32(pAvioes[pIndice].AviaoTiros[i].ValorVelocidadeTiro * (float)-Math.Sin(pAvioes[pIndice].AviaoTiros[i].Rotacao)));
                    }

                    if ((pAvioes[pIndice].AviaoTiros[i].posicaoatual.X >= Principal.gciLimiteLargura) ||
                        (pAvioes[pIndice].AviaoTiros[i].posicaoatual.X + pAvioes[pIndice].AviaoTiros[i].modelo.Width <= 0) ||
                        (pAvioes[pIndice].AviaoTiros[i].posicaoatual.Y >= Principal.gciLimiteAltura) ||
                        (pAvioes[pIndice].AviaoTiros[i].posicaoatual.Y + pAvioes[pIndice].AviaoTiros[i].modelo.Height <= 0))
                        AtivarDesativarTiro(ref pAvioes[pIndice].AviaoTiros[i], false);
                    else
                    {
                        //Detectando se o tiro atingiu algum avião.
                        for (int iContaAviao = 0; iContaAviao < pAvioes.Count(); iContaAviao++)
                        {
                            if ((iContaAviao != pIndice) &&
                                (pAvioes[iContaAviao].morto == false)
                                )
                            {
                                if ((pAvioes[iContaAviao].EspacoAviao.Intersects(pAvioes[pIndice].AviaoTiros[i].EspacoTiro)))
                                {
                                    AtivarDesativarTiro(ref pAvioes[pIndice].AviaoTiros[i], false);
                                    aviao.ExplodirAviao(ref pAvioes[iContaAviao]);
                                }
                            }
                        }
                    }
                }
            }
        }