Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
Juego Tiro de Cañón
/**
* 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
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment