Juego Tiro de Cañón

juegoDisparo.java

/**
* Juego que simula el disparo de un cañón hacia un objetivo.
* El jugador debe ingresar el ángulo para cada tiro del cañón.
*
* Código levemente basado en la obra "Cómo construir juegos de aventura"
* de Manuel Afonseca. ISBN 84-7688-019-7
*
* This program is free software. It comes without any warranty, to
* the extent permitted by applicable law. You can redistribute it
* and/or modify it under the terms of the WTFPL
* Version 2, as published by Sam Hocevar. See
* http://sam.zoy.org/wtfpl/COPYING for more details.
*
* @author Camilo Castro <contacto@camilocastro.info>
* @version 1.0
* @since 11-08-2012
*/

import java.util.Scanner;

public class juegoDisparo{
	public static void main(String args[]){

		// El alcance debe ser un número aleatorio entre 10.000 y 50.000
		double alcance;

		// 3 Objetivos
		int cantidad_objetivos;

		// 5 Oportunidades
		int cantidad_oportunidades;

		// Ángulos
		// Deben estar en grados
		// Mínimo 0.5 grados, Máximo 89.5 grados

		double angulo_elevacion;

		double angulo_minimo;
		
		double angulo_maximo;

		// Sentinela para saber si el objetivo fue destruido
		boolean objetivo_destruido;

		// Para saber cuantos tiros fueron necesarios para destruir al objetivo
		int tiros_necesarios;

		// Distancia mínima requerida para considerar el objetivo como destruido
		// Si el proyectil llega a 100 metros del objetivo, se considera destruido
		int distancia_minima;

		// Distancia alcanzada por el tiro en Metros
		double distancia_alcanzada;
		
		// Distancia al azar del objetivo
		// Debe ser igual o menor al alcance del cañón
		// distancia al azar desde el 100 hasta el alcance del cañón

		double distancia_objetivo;

		// Distancia final
		// Es la distancia alcanzada - distancia del objetivo
		double distancia_final;

		// Objeto necesario para leer del Stdin
		Scanner lector = new Scanner(System.in);

		// Comienzo del Juego
	
		// Valores iniciales de variables globales	

		// En Grados
		angulo_minimo = 0.5;
		angulo_maximo = 89.5;

		// En Metros
		// la distancia mínima para considerar destruido el objetivo
		distancia_minima = 100;

		// Se ejecutaran 3 juegos con distintos proyectiles
		for(cantidad_objetivos = 3; cantidad_objetivos > 0; cantidad_objetivos--){
		
			System.out.println("\nQuedan " + cantidad_objetivos + " objetivos \n");
	
			// Valores iniciales por cada objetivo

			cantidad_oportunidades = 5;
			
			objetivo_destruido = false;

			angulo_elevacion = 0;
			
			distancia_final = 0;

			// Comienza en 1 por si destruye en el primer tiro
			tiros_necesarios = 1;			

			// Genera un valor al azar entre 10.000 y 50.000
			alcance = 10000 + (int) (Math.random() * 40000);

			// Calcula la distancia al azar del objetivo
			distancia_objetivo = (int) (100 + Math.random() * alcance);

			System.out.println("El alcance del cañón es " + alcance + " metros.");
			
			System.out.println("El objetivo esta a " + distancia_objetivo + " metros.");

			// Se repetira hasta que las oportunidades sean 0 o menor
			while(cantidad_oportunidades > 0){
				
				// Verificamos que el ángulo este en el rango requerido
				while(angulo_elevacion < angulo_minimo || angulo_elevacion > angulo_maximo){

					System.out.println("\nIngrese el ángulo para disparar");

					angulo_elevacion = Double.parseDouble(lector.nextLine());
					
					if(angulo_elevacion < angulo_minimo)
						System.out.println("\nEl ángulo debe ser mayor a " + angulo_minimo);
					
					else if(angulo_elevacion > angulo_maximo)
						System.out.println("\nEl ángulo debe ser menor a " + angulo_maximo);
				}
			
				// Calculamos la distancia que el tiro llega con el ángulo ingresado	
				distancia_alcanzada = (int) (alcance *  Math.sin(2 * Math.PI * angulo_elevacion / 180));	
				
				// Verificamos si llego al objetivo
				System.out.println("\nDistancia Alcanzada " + distancia_alcanzada  + " Distancia Objetivo " + distancia_objetivo);
				// Para que siempre tenga un valor positivo
				distancia_final = Math.abs(distancia_alcanzada - distancia_objetivo);

				if(distancia_minima >= distancia_final)
					objetivo_destruido = true;

				else if(distancia_alcanzada > distancia_objetivo)	
					System.out.println("\nEl tiro se pasó en " + distancia_final + " metros.");

				else 
					System.out.println("\nEl tiro quedó corto por " + distancia_final + " metros.");

				// Si acabamos de alcanzar al objetivo
				// Continuamos con el siguiente objetivo
				if(objetivo_destruido){

					System.out.println("\nFelicidades, haz destruido al objetivo en " + tiros_necesarios + " intentos.");
					// Salimos del ciclo para continuar
					cantidad_oportunidades = 0;

				} else {
					// Disminuye una oportunidad
					cantidad_oportunidades--;

					// Aumenta la cantidad de tiros
					tiros_necesarios++;	

					// Reinicia el angulo
					angulo_elevacion = 0;

					if(cantidad_oportunidades > 0)
						System.out.println("\n¡Prueba otra vez!, quedan " + cantidad_oportunidades + " tiros");
					 else 
						System.out.println("\nHaz perdido, el enemigo te ha destruido :C!");
					
				}
				
			} // Fin del While

			// Para que salga más bonito en el Stdin
			System.out.println("\n-------------------------------------\n");

		} // Fin del For
		
		// Se termina el juego
		System.out.println("\nGracias por jugar, vuelve pronto C:");

	} // Fin del Main

} // Fin de la clase