示例#1
0
 public void Initializing(Vector2 posicao_inicial, tipo_PowerUp tipo, bool passar_turno, Tank tank)
 {
     this.posicao_inicial = posicao_inicial;
     this.posicao_actual_y = (int)posicao_inicial.Y;
     this.posicao_final_y = (int)posicao_inicial.Y - 40;
     this.transparencia = 1f;
     this.tipo = tipo;
     this.ha_dano = false;
     this.passar_turno = passar_turno;
     this.tankAtacante = tank;
 }
示例#2
0
 public void Initializing(Vector2 posicao_inicial, int fire_power_atacante, int dano, bool morreu, Tank tankAtacado, Tank tankAtacante, bool passarTurno)
 {
     this.posicao_inicial = posicao_inicial;
     this.posicao_actual_y = (int)posicao_inicial.Y;
     this.fire_power_atacante = fire_power_atacante;
     this.dano = dano;
     this.posicao_final_y = (int)posicao_inicial.Y - 40;
     this.transparencia = 1f;
     this.morreu = morreu;
     this.ha_dano = true;
     this.passar_turno = passarTurno;
     this.tankAtacado = tankAtacado;
     this.tankAtacante = tankAtacante;
 }
示例#3
0
 public void alterarPosicaoDestino(Vector2 posicao_destino, List<Terreno> lista_pode_mover, Tank tanque_seleccionado)
 {
     this.posicao_destino = posicao_destino;
     this.lista_pode_mover = lista_pode_mover;
     this.tanque_seleccionado = tanque_seleccionado;
 }
示例#4
0
        private void atacarTanque(Tank tanque)
        {
            bool morreu = false;

            //calcular dano que vamos retirar ao tanque atacado
            float distancia = Vector2.Distance(new Vector2(tanque_seleccionado.posicao.X+(tanque_seleccionado.textura.Width/4),
                    tanque_seleccionado.posicao.Y + (tanque_seleccionado.textura.Height / 4)),
                new Vector2(tanque.posicao.X + (tanque.textura.Width / 4),
                    tanque.posicao.Y + (tanque.textura.Height / 4)));

            int firepower = tanque_seleccionado.power;

            //normalizar a distancia para dar valores entre 0 e 100
            distancia = 100 * (distancia - 66) / (1418 - 66);

            //lidar com o powe-up SNIPER
            if (tanque_seleccionado.sniper)
            {
                distancia = 0;
                tanque_seleccionado.sniper = false;
            }

            //power aleatorio
            int power = gerador_numeros.Next(firepower - 50);

            //MEGA-POWER
            if (tanque_seleccionado.mega_power)
            {
                power = 80 + power;
            }
            else
            {
                power = 50 + power;
            }

            //subtrair ao firepower a distancia
            int dano = power - (int)distancia*2;

            //retirar a vida ao tanque atacado
            if (dano > 0) { tanque.vida -= dano; } else { dano=0; };
            if (tanque.vida <= 0)
            {
                tanque.activo = false;
                if (tanque.equipa == Team.Alliance)
                {
                    tanque.textura = tanque.alliance_destruido;
                }
                else
                {
                    tanque.textura = tanque.coalition_destuido;
                }
                morreu = true;
            }

            //calcular os desvios da explosao de acordo com a sorte que teve no tiro

            int max_desvio;
            if (firepower - dano <= 0)
            {
                max_desvio = 1;
            }
            else
            {
                max_desvio = firepower - dano;
            }
            int desvio_x = gerador_numeros.Next(max_desvio);
            //normalizar desvio
            desvio_x = 50*(desvio_x - 1) / (100 - 1);
            int sinal_x = gerador_numeros.Next(2);
            if (sinal_x == 0)
            {
                sinal_x = -1;
            }
            else { sinal_x = 1; }

            int dano_maximo;
            if (firepower - dano <= 0)
            {
                dano_maximo = 199;
            }
            else
            {
                dano_maximo = firepower - dano;
            }

            int desvio_y = gerador_numeros.Next(dano_maximo);
            //normalizar desvio
            desvio_y = 50 * (desvio_y - 1) / (100 - 1);
            int sinal_y = gerador_numeros.Next(2);
            if (sinal_y == 0)
            {
                sinal_y = -1;
            }
            else { sinal_y = 1; }

            //calcular o tamanho e tempo da explosao de acordo com o dano retirado
            float tempo_explosao;
            float escala_explosao;
            if (!morreu)
            {
                tempo_explosao = 100 * (dano - 25) / (100f - 25f);
                escala_explosao = 3 * (dano - 0.3f) / (100 - 0.3f);
            }
            else
            {
                tempo_explosao = 80;
                escala_explosao = 3f;
            }

            float posicao_x = (tanque.posicao.X + (tanque.textura.Width / 4))+(sinal_x * desvio_x);
            float posicao_y = (tanque.posicao.Y + (tanque.textura.Height / 4))+(sinal_y * desvio_y);
            Vector2 posicao = new Vector2(posicao_x, posicao_y);
            explode = new Animacao();
            explode.Initialize(explosao, posicao , 134, 134, 12, tempo_explosao, Color.White, escala_explosao, false,0f);
            lista_animacoes.Add(explode);

            //fogacho no tanque que dispara
            //NÃO CONSIGO POR O FOGACHO NA PONTINHA DO TANQUE POR CAUSA DAS ROTAÇÕES! ver isto melhor

            /*
            float posicao_x_fogacho = (tanque_seleccionado.posicao.X + (tanque_seleccionado.textura.Width / 4));
            float posicao_y_fogacho = (tanque_seleccionado.posicao.Y);
            Vector2 posicao_fogacho = new Vector2(posicao_x_fogacho, posicao_y_fogacho);
            fogacho = new Animacao();
            fogacho.Initialize(explosao, posicao_fogacho, 134, 134, 12, 25, Color.White, 0.2f, false,0f);
            lista_animacoes.Add(fogacho);
            */

            //encontrar o terreno que cai na posicao da explosao e alterar-lhe o contador de explosoes
            for (int i = 0; i < altura_grelha; i++)
            {
                for (int j = 0; j < n_tanques + 1; j++)
                {
                    Terreno terreno = grelha[i, j];
                    Rectangle rect_terreno = new Rectangle((int)terreno.posicao.X, (int)terreno.posicao.Y, terreno.largura / 2, terreno.altura / 2);
                    Rectangle rect_explosao = new Rectangle((int)posicao_x,(int)posicao_y,1,1);
                    if (rect_explosao.Intersects(rect_terreno))
                    {
                        if (!morreu)
                        {
                            terreno.explosoes++;
                        }
                        else
                        {
                            terreno.explosoes = 6;
                            terreno.textura = textura_cratera_1;
                        }
                        break;
                    }
                }
            }

            damageBox.activo = true;
            //mostrar a damageBox
            float damageBox_x, damageBox_y;
            damageBox_x = tanque.posicao.X-21;
            damageBox_y = (tanque.posicao.Y + (tanque.textura.Height/2))-DamageBox.altura;
            Vector2 posicao_damageBox = new Vector2(damageBox_x, damageBox_y);
            damageBox.Initializing(posicao_damageBox, tanque_seleccionado.power, dano, morreu, tanque, tanque_seleccionado, true);

            //verificar o double shot
            if (tanque_seleccionado.double_shot)
            {
                tanque_seleccionado.double_shot = false;
            }
            else
            {
                //não pode disparar durante 5 turnos!
                tanque_seleccionado.turnos_espera_disparar = nTurnosCoolDown;
            }

            tanque_seleccionado.pode_mover = false;
            tanque_seleccionado.cor = Color.Red;

            //se tem mega-power, repor o power
            if (tanque_seleccionado.mega_power)
            {
                tanque_seleccionado.power = tanque_seleccionado.power_anterior;
                tanque_seleccionado.mega_power = false;
            }

            tanque_seleccionado.seleccionado = false;
            terreno_pode_mover.Clear();
            terreno_seleccionado = null;

            //Enviar ataque para o servidor
            SendMessageToServer(new GameAttackMessage(MessageType.Attack, tanque_seleccionado.ID, tanque.ID, posicao, dano, tanque_seleccionado.angulo_actual));

            tanque_seleccionado = null;
        }
示例#5
0
        private static void acinzentarAdversarios(Tank tanque)
        {
            if (tanque.equipa != equipaTurno)
            {
                tanque.cor = Color.Yellow;
            }
            else
            {
                if (tanque.pode_mover)
                {
                    tanque.cor = Color.White;
                }
                else
                {
                    tanque.cor = Color.Red;
                }

            }
        }
示例#6
0
 private Terreno verificarRatoTerrenoMover(Vector2 posicao_rato, Tank tanque)
 {
     Terreno terreno_sob = null;
     if (tanque != null)
     {
         foreach (Terreno terreno in terreno_pode_mover)
         {
             Rectangle rato = new Rectangle((int)posicao_rato.X, (int)posicao_rato.Y, 1, 1);
             Rectangle rect_terreno = new Rectangle((int)terreno.posicao.X, (int)terreno.posicao.Y, terreno.largura / 2, terreno.altura / 2);
             if (rato.Intersects(rect_terreno))
             {
                 terreno_sob = terreno;
             }
         }
     }
     return terreno_sob;
 }
示例#7
0
        private void seleccionarTanque(Tank tanque)
        {
            terreno_seleccionado = new Terreno();
            //temos um tanque no sitio que foi clicado, alterar o fundo desta posição
            if (tanque.seleccionado)
            {
                gerarTerrenoPossivel(tanque, "desactivar");
                terreno_seleccionado = null;
                tanque.seleccionado = false;
                tanque_seleccionado = null;
            }
            else
            {
                if (tanque.pode_mover)
                {
                    terreno_seleccionado.posicao = grelha[(int)tanque.posicao_grelha.X, (int)tanque.posicao_grelha.Y].posicao;
                    terreno_seleccionado.posicao_grelha = grelha[(int)tanque.posicao_grelha.X, (int)tanque.posicao_grelha.Y].posicao_grelha;
                    terreno_seleccionado.textura = textura_terreno;
                    if (tanque_seleccionado == null)
                    {
                        tanque.seleccionado = true;
                        tanque_seleccionado = tanque;
                        gerarTerrenoPossivel(tanque, "activar");
                    }
                    else
                    {
                        tanque.seleccionado = true;
                        gerarTerrenoPossivel(tanque_seleccionado, "desactivar");
                        terreno_seleccionado = null;
                        gerarTerrenoPossivel(tanque, "activar");
                        tanque_seleccionado.seleccionado = false;
                        terreno_seleccionado = new Terreno();
                        terreno_seleccionado.posicao = grelha[(int)tanque.posicao_grelha.X, (int)tanque.posicao_grelha.Y].posicao;
                        terreno_seleccionado.posicao_grelha = grelha[(int)tanque.posicao_grelha.X, (int)tanque.posicao_grelha.Y].posicao_grelha;
                        terreno_seleccionado.textura = textura_terreno;
                        tanque_seleccionado = tanque;
                    }
                }

            }
        }
示例#8
0
 private void ReporJogo()
 {
     jogadas = 0;
     foreach (Tank tanque in lista_tanques)
     {
         tanque.posicao = tanque.posicaoOriginal;
         tanque.posicao_destino = tanque.posicaoOriginal;
         tanque.angulo_actual = MathHelper.Pi;
         tanque.angulo_destino = MathHelper.Pi;
         tanque.angulo_original = MathHelper.Pi;
         tanque.power = tanque.powerOriginal;
         tanque.vida = Game1.vidaInicialTanques;
         tanque.seleccionado = false;
         tanque.cor = Color.White;
         tanque.pode_mover = true;
         tanque_seleccionado = null;
         tanque.double_turn = false;
         tanque.double_shot = false;
         tanque.mega_power = false;
         tanque.sniper = false;
         tanque.turnos_espera_disparar = 0;
         tanque.activo = true;
         tanque.em_movimento = false;
         tanque.posicao_grelha = tanque.posicao_grelhaOriginal;
     }
 }
示例#9
0
        public static bool apanharPowerUp(Tank tanque, ContentManager Content)
        {
            bool apanhou = false;
            bool passar_turno = true;
            for (int i = lista_powerups.Count - 1; i >= 0; i--)
            {
                if (lista_powerups[i].posicao_grelha == tanque.posicao_grelha)
                {
                    //tanque apanhou um powerup!
                    apanhou = true;
                    switch (lista_powerups[i].tipo)
                    {
                        case tipo_PowerUp.double_turn:
                            tanque.double_turn = true;
                            passar_turno = false;
                            break;
                        case tipo_PowerUp.mega_power:
                            tanque.mega_power = true;
                            tanque.power = 200;
                            break;
                        case tipo_PowerUp.double_shot:
                            tanque.double_shot = true;
                            break;
                        case tipo_PowerUp.sniper:
                            tanque.sniper = true;
                            break;
                        case tipo_PowerUp.vida:
                            tanque.vida = 200;
                            break;
                        default:
                            break;
                    }
                    tipo_PowerUp tipo = lista_powerups[i].tipo;
                    lista_powerups.RemoveAt(i);
                    if (equipaJogador == equipaTurno)
                    {
                        PowerUp powerUp = gerarPowerupIndividual(Content);
                        lista_powerups.Add(powerUp);
                        //Estamos a jogar e apanhámos um powerUp, geramos um novo e enviamos a informação do novo para o servidor
                        SendMessageToServer(new PowerUpMessage(MessageType.PowerUp, powerUp));
                    }

                    damageBox.activo = true;
                    damageBox.Initializing(tanque.posicao, tipo, passar_turno, tanque);

                }
            }
            return apanhou;
        }
示例#10
0
 public static void actualizarJogadas(Tank tank)
 {
     if (tank != null && tank.equipa == equipaJogador && !gameOver)
     {
         //Só atualizamos as jogadas se formos nós que estivermos a jogar, e não os tanques do adversário a moverem-se
         jogadas++;
         if (numeroTanquesActivosEquipa(lista_tanques, equipaJogador) >= 3)
         {
             if (jogadas == 3)
             {
                 //Informar o servidor que o nosso turno acabou
                 SendMessageToServer(new EndTurnMessage(MessageType.EndTurn));
             }
         }
         else
         {
             //O jogador activo tem menos que 3 tanques
             if (jogadas == numeroTanquesActivosEquipa(lista_tanques, equipaJogador))
             {
                 //Informar o servidor que o nosso turno acabou
                 SendMessageToServer(new EndTurnMessage(MessageType.EndTurn));
             }
         }
     }
 }
示例#11
0
        private void MoverTanqueNetwork(GameMoveMessage moveMessage, Tank tanqueMovido)
        {
            gerarTerrenoPossivel(tanqueMovido, "activar");
            Terreno terreno = verificarRatoTerrenoMover(new Vector2(moveMessage.x, moveMessage.y), tanqueMovido);
            //foi clicada uma posição de andamento válida
            apontador = seta_rato_esperar;
            if (tanqueMovido.equipa == Team.Coalition) tanqueMovido.angulo_destino = tanqueMovido.anguloDoisVectores(
                new Vector2(terreno.posicao.X + terreno.largura / 4, terreno.posicao.Y + terreno.altura / 4), 0f);
            if (tanqueMovido.equipa == Team.Alliance) tanqueMovido.angulo_destino = tanqueMovido.anguloDoisVectores(
                new Vector2(terreno.posicao.X + terreno.largura / 4, terreno.posicao.Y + terreno.altura / 4), MathHelper.Pi);

            Vector2 posicaoDestino = new Vector2(terreno.posicao.X + terreno.largura / 8, terreno.posicao.Y);

            //mandar o tanque andar
            tanqueMovido.alterarPosicaoDestino(posicaoDestino, terreno_pode_mover, tanqueMovido);
            tanqueMovido.posicao_grelha = terreno.posicao_grelha;
            terreno_seleccionado = null;
        }
示例#12
0
        private void gerarTerrenoPossivel(Tank tanque, string accao)
        {
            Vector2 posicao_original = tanque.posicao_grelha;
            List<Vector2> terrenos_alterar = new List<Vector2>();
            List<Vector2> posicoes_tanques = new List<Vector2>();

            //preencher a lista com as posiçoes de todos os tanques
            foreach (Tank tanque_individual in lista_tanques)
            {
                posicoes_tanques.Add(new Vector2((int)tanque_individual.posicao_grelha.X, (int)tanque_individual.posicao_grelha.Y));
            }

            //procurar terrenos possiveis e inseri-los na lista

            Vector2 terreno;

            for (int i = 1; i < 3; i++)
            {
                //procurar para baixo
                if ((posicao_original.X + i) < altura_grelha && (posicao_original.X + i) > 0)
                {
                    if (!obstaculo(new Vector2((float)posicao_original.X + i, (float)posicao_original.Y),i,direccao.Baixo))
                    {
                        terreno = new Vector2((float)posicao_original.X + i, (float)posicao_original.Y);
                        terrenos_alterar.Add(terreno);
                    }

                    if (i == 1)
                    {
                        //baixo e direita
                        if ((posicao_original.X + i) <= altura_grelha - 1 && (posicao_original.Y + i) < n_tanques + 1)
                        {
                            if (!obstaculo(new Vector2((float)posicao_original.X + i, (float)posicao_original.Y + i),i,direccao.BaixoDireita))
                            {
                                terreno = new Vector2((float)posicao_original.X + i, (float)posicao_original.Y + i);
                                terrenos_alterar.Add(terreno);
                            }
                        }

                        //baixo e esquerda
                        if ((posicao_original.X + i) <= altura_grelha - 1 && (posicao_original.Y - i) >= 0)
                        {
                            if (!obstaculo(new Vector2((float)posicao_original.X + 1, (float)posicao_original.Y - i),i,direccao.BaixoEsquerda))
                            {
                                terreno = new Vector2((float)posicao_original.X + 1, (float)posicao_original.Y - i);
                                terrenos_alterar.Add(terreno);
                            }
                        }

                    }

                }
                //procurar para a esquerda
                if ((posicao_original.Y - i) >= 0)
                {
                    if (!obstaculo(new Vector2((float)posicao_original.X, (float)posicao_original.Y-i),i,direccao.Esquerda))
                    {
                        terreno = new Vector2((float)posicao_original.X, (float)posicao_original.Y-i);
                        terrenos_alterar.Add(terreno);
                    }
                }
                //procurar para a direita
                if ((posicao_original.Y + i) < n_tanques + 1)
                {
                    if (!obstaculo(new Vector2((float)posicao_original.X, (float)posicao_original.Y + i),i,direccao.Direita))
                    {
                        terreno = new Vector2((float)posicao_original.X, (float)posicao_original.Y + i);
                        terrenos_alterar.Add(terreno);
                    }
                }
                //procurar para cima
                if ((posicao_original.X - i) >= 0 && (posicao_original.X - i) <= altura_grelha - 1)
                {
                    if (!obstaculo(new Vector2((float)posicao_original.X - i, (float)posicao_original.Y),i,direccao.Cima))
                    {
                        terreno = new Vector2((float)posicao_original.X - i, (float)posicao_original.Y);
                        terrenos_alterar.Add(terreno);
                    }

                    if (i == 1)
                    {
                        //cima e direita
                        if ((posicao_original.X - i) >= 0 && (posicao_original.Y + i) < n_tanques + 1)
                        {
                            if (!obstaculo(new Vector2((float)posicao_original.X - i, (float)posicao_original.Y + i),i,direccao.CimaDireita))
                            {
                                terreno = new Vector2((float)posicao_original.X - i, (float)posicao_original.Y + i);
                                terrenos_alterar.Add(terreno);
                            }
                        }

                        //cima e esquerda
                        if ((posicao_original.X - i) >= 0 && (posicao_original.Y - i) >= 0)
                        {
                            if (!obstaculo(new Vector2((float)posicao_original.X - 1, (float)posicao_original.Y - i),i,direccao.CimaEsquerda))
                            {
                                terreno = new Vector2((float)posicao_original.X - 1, (float)posicao_original.Y - i);
                                terrenos_alterar.Add(terreno);
                            }
                        }

                    }

                }

            }

            if (accao=="activar")
            {
                //alterar os terrenos encontrados
                foreach (Vector2 terreno_individual in terrenos_alterar)
                {
                    Terreno terreno_a_mover = new Terreno();
                    terreno_a_mover.posicao = grelha[(int)terreno_individual.X, (int)terreno_individual.Y].posicao;
                    terreno_a_mover.posicao_grelha = grelha[(int)terreno_individual.X, (int)terreno_individual.Y].posicao_grelha;
                    terreno_a_mover.textura = textura_terreno;
                    terreno_pode_mover.Add(terreno_a_mover);
                }

            }
            if (accao == "desactivar")
            {
                //alterar os terrenos encontrados
                terreno_pode_mover.Clear();
            }
            terrenos_alterar.Clear();
        }
示例#13
0
        private void gerarTanques2()
        {
            Vector2 posicao_tanque2;
            for (int i = 1; i < n_tanques; i=i+2)
            {
                Tank tank = new Tank();

                #region DEGUB - tanques2 a aparecerem em locais aleatorios

                /*
                int x_aleatorio, y_aleatorio;
                x_aleatorio = gerador_numeros.Next(10);
                y_aleatorio = gerador_numeros.Next(20);
                posicao_tanque2 = new Vector2((grelha[x_aleatorio, y_aleatorio].posicao.X) + (textura_terreno.Width * Terreno.escala / 2) - textura_tanque1.Width * Tank.escala / 2, grelha[x_aleatorio, y_aleatorio].posicao.Y);
                tank.posicao_grelha = new Vector2((float)x_aleatorio, (float)y_aleatorio);
                */

                #endregion

                posicao_tanque2 = new Vector2((grelha[0, i].posicao.X) + (textura_terreno.Width * Terreno.escala / 2) - textura_tanque1.Width * Tank.escala / 2, grelha[altura_grelha - 1, i].posicao.Y);
                tank.posicao_grelha = new Vector2(altura_grelha - 1, i);
                tank.posicao_grelhaOriginal = tank.posicao_grelha;

                tank.Initialiazing(textura_tanque2, posicao_tanque2,SpriteEffects.None, Team.Coalition,gerador_numeros,i);
                lista_tanques.Add(tank);
            }
        }
示例#14
0
        public void Draw(SpriteBatch spritebatch, GraphicsDevice graphics, Tank tanque_seleccionado)
        {
            float x, y;
            x = posicao_rato.X;
            y = posicao_rato.Y;

            if ((x + 170f) > graphics.Viewport.TitleSafeArea.Width)
            {
                x -= 170f;
            }

            if ((y + 99f) > graphics.Viewport.TitleSafeArea.Height)
            {
                y -= 99f;
            }

            if (activo)
            {

                spritebatch.Draw(rectangulo_branco, new Vector2(x,y), null,
                    Color.White*0.5f, 0f, Vector2.Zero, 1f, SpriteEffects.None, 0f);

                string ID;
                if (tanque_activo.ID + 1 < 10)
                {
                    ID = "0" + (tanque_activo.ID + 1);
                }
                else
                {
                    ID = (tanque_activo.ID + 1).ToString();
                }

                spritebatch.DrawString(font, tanque_activo.equipa.ToString()+ID, new Vector2(x+10,y +10), Color.Black);
                spritebatch.DrawString(tahoma_20_bold, "Power : " + tanque_activo.power.ToString(), new Vector2(x + 10, y + 40), Color.Red);
                spritebatch.DrawString(tahoma_20_bold, "Health : " + tanque_activo.vida.ToString(), new Vector2(x + 10, y + 60), Color.LawnGreen);
                if (tanque_activo.sniper == false && tanque_activo.double_shot == false && tanque_activo.mega_power == false)
                {
                    spritebatch.DrawString(tahoma_20_bold, "Powerups : 0", new Vector2(x + 10, y + 80), Color.Blue);
                }
                else
                {
                    spritebatch.DrawString(tahoma_20_bold, "Powerups :", new Vector2(x + 10, y + 80), Color.Blue);
                    int plus=20;
                    if (tanque_activo.sniper == true)
                    {
                        spritebatch.DrawString(tahoma_20_bold, "Sniper", new Vector2(x + 10, y + 80 +plus), Color.Blue);
                        plus += 20;
                    }
                    if (tanque_activo.double_shot == true)
                    {
                        spritebatch.DrawString(tahoma_20_bold, "Double Shot", new Vector2(x + 10, y + 80 + plus), Color.Blue);
                        plus += 20;
                    }
                    if (tanque_activo.mega_power == true)
                    {
                        spritebatch.DrawString(tahoma_20_bold, "Mega Power", new Vector2(x + 10, y + 80 + plus), Color.Blue);
                        plus += 20;
                    }
                }

                /*spritebatch.DrawString(font, "x : " + x.ToString(), new Vector2(x + 10, y + 90), Color.Black);
                spritebatch.DrawString(font, "y : " + y.ToString(), new Vector2(x + 10, y + 120), Color.Black);

                if (tanque_seleccionado != null)
                {
                    spritebatch.DrawString(arial_12, "Angulo : " + tanque_seleccionado.angulo_actual.ToString(), new Vector2(x + 10, y + 150), Color.Black);
                    spritebatch.DrawString(arial_12, "Angulo destino: " + tanque_seleccionado.angulo_destino.ToString(), new Vector2(x + 10, y + 180), Color.Black);
                    spritebatch.DrawString(arial_12, "Angulo variacao: " + ((tanque_seleccionado.angulo_destino - tanque_seleccionado.angulo_actual) / 4).ToString(), new Vector2(x + 10, y + 130), Color.Black);
                }
                */
            }

            #region DEBUG
            /*
            spritebatch.Draw(rectangulo_branco, new Vector2(x, y), null,
                Color.White * 0.75f, 0f, Vector2.Zero, new Vector2(170, 200f), SpriteEffects.None, 0f);
            spritebatch.DrawString(arial_12, "x : " + x.ToString(), new Vector2(x + 10, y + 70), Color.DarkGreen);
            spritebatch.DrawString(arial_12, "y : " + y.ToString(), new Vector2(x + 10, y + 85), Color.DarkGreen);

            if (tanque_seleccionado != null)
            {
                spritebatch.DrawString(arial_12, "Angulo (radiano) : " + tanque_seleccionado.anguloDoisVectores(tanque_seleccionado.posicao,posicao_rato).ToString(), new Vector2(x + 10, y + 40), Color.DarkGreen);
                spritebatch.DrawString(arial_12, "Angulo (graus) : " + MathHelper.ToDegrees(tanque_seleccionado.anguloDoisVectores(tanque_seleccionado.posicao, posicao_rato)).ToString(), new Vector2(x + 10, y + 55), Color.DarkGreen);
            }
            */
            #endregion
        }
示例#15
0
 public void Update(ContentManager content, Tank tanque_seleccionado)
 {
 }
示例#16
0
 public void LoadContent(ContentManager content, GraphicsDevice graphic, Tank tanque_seleccionado)
 {
     font = content.Load<SpriteFont>("fontes/font_tahoma_25_bold");
     arial_12 = content.Load<SpriteFont>("fontes/arial_12");
     tahoma_20 = content.Load<SpriteFont>("fontes/font_tahoma_20");
     tahoma_20_bold = content.Load<SpriteFont>("fontes/font_tahoma_20_bold");
     rectangulo_branco = content.Load<Texture2D>("Texturas/componentes/textura_infobox2");
     /*
      * if (tanque_seleccionado != null)
     {
         if (tanque_seleccionado.sniper == false && tanque_seleccionado.double_shot == false && tanque_seleccionado.mega_power == false)
         {
             rectangulo_branco = content.Load<Texture2D>("Texturas/componentes/textura_infobox2_2");
         }
         else
         {
             rectangulo_branco = content.Load<Texture2D>("Texturas/componentes/textura_infobox2");
         }
     }
     else
     {
         rectangulo_branco = content.Load<Texture2D>("Texturas/componentes/textura_infobox2");
     }
     */
 }