MAQUINA TRAGA MONEDAS (SIMULACION) EN JAVA

1-)  MAQUINA TRAGA MONEDAS

PASO A PASO 

1. Define el enumerado Fruta con los valores fresa, sandía, plátano, melocotón y pera.

public enum Fruta {
    FRESA,SANDIA,PLATANO,MELOCOTON,PERA
}

2. Define la clase Premio que representa los posibles premios que puede conceder

una máquina traga monedas.

• Las propiedades de un premio son: el array de frutas que conforman la combinación ganadora y la cantidad de dinero que se concede si sale esta combinación. Estas propiedades pueden ser consultadas pero no se pueden modificar.
• Para construir un premio se deben pasar como parámetro los valores de todas las propiedades.
• No existe ninguna funcionalidad salvo la consulta de sus propiedades.
• Nótese que puesto que un array es un objeto modificable se debe evitar el problema del aliasing. Para copiar un array se puede utilizar el método de clase copyOf de la clase java.util.Arrays al que debemos pasar como parámetro el array que queremos copiar y el tamaño. La ejecución del método devuelve un nuevo array que es una copia del que se ha pasado como parámetro.

import java.util.Arrays;
public class Premio {
    Fruta[ ] combinacionFrutas;
    int cantidadDinero;

    public Premio(Fruta[] combinacionFrutas, int cantidadDinero) {
        this.combinacionFrutas = Arrays.copyOf(combinacionFrutas, combinacionFrutas.length);
        this.cantidadDinero = cantidadDinero;
    }

    public Fruta[] getCombinacionFrutas() {
        return Arrays.copyOf(combinacionFrutas, combinacionFrutas.length);
    }

    public int getCantidadDinero() {
        return cantidadDinero;
    }
}

3. Define la clase Maquina que representa el concepto de una máquina traga monedas. Las propiedades que caracterizan a una máquina traga monedas y que se pueden consultar son:

• número de casillas que forma la combinación de frutas que se generará en cada jugada. El valor de esta propiedad no se puede cambiar.
• precio de la jugada, que puede modificarse en cualquier momento.
• crédito disponible en la máquina para poder jugar.
• colección (array) de los premios que concede. La colección de premios no podrá modificarse una vez establecida en la construcción.

Una máquina se construye estableciendo el número de casillas de la máquina, el precio de la jugada y una lista variable de premios que puede conceder.

LA FUNCIONALIDAD DE ESTA CLASE ES:

• incrementarCredito: incrementa el credito disponible en la cantidad indicada por el parámetro.
• cobrar: devuelve el crédito disponible y por tanto deja a cero el crédito disponible en la máquina.
• jugar: devuelve la combinación generada en la jugada o un valor null si no se ha podido jugar. Para poder jugar se tiene que cumplir que el crédito disponible sea igual o superior al precio de la jugada. Si se puede jugar el algoritmo del método es el siguiente:
•  Decrementar el crédito disponible la cantidad correspondiente al precio de la jugada.
•  Generar aleatoriamente una combinación de frutas del tamaño de la combinación establecido en la máquina.
• Comprobar si la combinación generada se encuentra entre los premios registrados en la máquina. Para ello puedes utilizar el método de clase equals de la clase Arrays que recibe como parámetros los dos arrays que se quieren comparar y devuelve true si los arrays son del mismo tamaño y los objetos que contiene son iguales en las mismas posiciones.
• En el caso de que la combinación generada coincida con uno de los premios registrados, se incrementa el crédito disponible en la cantidad fijada para el premio.

NOTA: Para generar la combinación aleatoria te puede ser útil la siguiente información

La clase java.util.Random es un generador de números aleatorios. Dispone del método de instancia nextInt que recibe como parámetro la cota superior para la generación del número aleatorio, es decir, generará un entero entre 0 y la cota superior, no incluida.

El código es el siguiente:

import java.util.Arrays;
import java.util.Random;


public class Maquina {
    int numeroCasillas;
    double precioJugada;
    double credito;
    Premio[] premios;

    public Maquina(int numeroCasillas, double precioJugada, Premio[] premios) {
        this.numeroCasillas = numeroCasillas;
        this.precioJugada = precioJugada;
        this.credito = 0.0;
        this.premios = premios;
    }

    public int getNumCasillas() {
        return numeroCasillas;
    }

    public double getPrecioJugada() {
        return precioJugada;
    }

    public double getCredito() {
        return credito;
    }

    public Premio[] getPremios() {
        return premios;
    }

    public void setPrecioJugada(int precioJugada) {
        this.precioJugada = precioJugada;
    }
 
    public void incrementarCredito(double cantidad) {
        credito += cantidad;
    }
 
    public double cobrar() {
        double credi = credito;
        credito = 0.0;
     
        return credi;
    }
 
    public Fruta[] jugar() {
        if (credito < precioJugada) {
            return null;
        }
     
        credito -= precioJugada;
     
        Fruta[] frutas = Fruta.values();
        Fruta[] combinacion = new Fruta[numeroCasillas];
     
        for (int i = 0; i < numeroCasillas; i++) {
            int index = new Random().nextInt(frutas.length);
            combinacion[i] = frutas[index];
        }
     
        for (Premio premio : premios) {
            if (Arrays.equals(premio.getCombinacionFrutas(), combinacion)) {
                credito += premio.cantidadDinero;
                break;
            }
        }
     
        return combinacion;
    }
 
}

5. Implementaremos la clase Programa que contenga el siguiente método main para comenzar el juego, crearemos dos premios con la combinaciones (FRESA, FRESA, FRESA) y (SANDIA, FRESA, SANDIA), y también crearemos una maquina con un tamaño de combinación de tres frutas con un precio de partida de 0.5 pesos, euros o como lo quieran llamar y los dos premios declarados previamente.

El código es el siguiente:

import java.util.Arrays;
import java.util.Scanner;

public class Programa {

    public static void main(String[] args) {

        // 1. Declara dos variables locales de tipo Premio

        Fruta[] combinacion1 = {Fruta.FRESA, Fruta.FRESA, Fruta.FRESA};

        Premio premio1 = new Premio(combinacion1, 20);

        Fruta[] combinacion2 = {Fruta.SANDIA, Fruta.FRESA,Fruta.SANDIA};

        Premio premio2 = new Premio(combinacion2, 10);

        /* 2. Crea una maquina con un tamaño de combinacion de 3 frutas,

         * un precio por partida de 0,5 euros

         * y los dos premios declarados previamente

         */

        Maquina maquina = new Maquina(3, 0.5, new Premio[]{premio1, premio2});

        /* 3. Solicita al usuario que introduzca por teclado la cantidad

        * de crédito para jugar.

        */

        System.out.println("Introduzca el credito: ");

        Scanner teclado = new Scanner(System.in);

        double credito = teclado.nextDouble();

        teclado.nextLine();

        maquina.incrementarCredito(credito);

        // 4. Jugamos mientras haya credito disponible

        Fruta[ ] combinacion;

        while (maquina.getCredito() > 0){

            //4.1 Realiza la jugada

            combinación = maquina.jugar();

            //4.2 Muestra la combinación obtenida y el crédito
            System.out.println(Arrays.toString(combinación)
                    +" --- "+maquina.getCredito());

            //4.3 Pide al usuario que pulse intro para continuar

            System.out.println("Pulse Intro para volver a jugar");

            teclado.nextLine();

        }
    }
}

YA HEMOS TERMINADO, AHORA SOLO TOCA EJECUTARLO.

Introduzca el credito:
30
[PERA, SANDIA, PERA] --- 29.5
Pulse Intro para volver a jugar

[PLATANO, MELOCOTON, SANDIA] --- 29.0
Pulse Intro para volver a jugar

[SANDIA, PLATANO, SANDIA] --- 28.5
Pulse Intro para volver a jugar

[FRESA, PERA, SANDIA] --- 28.0
Pulse Intro para volver a jugar

[MELOCOTON, MELOCOTON, FRESA] --- 27.5
Pulse Intro para volver a jugar

[MELOCOTON, PERA, PERA] --- 27.0
Pulse Intro para volver a jugar

[PLATANO, SANDIA, SANDIA] --- 26.5
Pulse Intro para volver a jugar

[FRESA, FRESA, PERA] --- 26.0
Pulse Intro para volver a jugar

[FRESA, FRESA, MELOCOTON] --- 25.5
Pulse Intro para volver a jugar

[PERA, MELOCOTON, PERA] --- 25.0
Pulse Intro para volver a jugar

[FRESA, FRESA, PERA] --- 24.5
Pulse Intro para volver a jugar

[PERA, SANDIA, FRESA] --- 24.0
Pulse Intro para volver a jugar

[FRESA, FRESA, FRESA] --- 43.5
Pulse Intro para volver a jugar

[SANDIA, SANDIA, SANDIA] --- 43.0
Pulse Intro para volver a jugar

Aquí en lo que resaltado con azul nos podemos dar cuenta que cuando sale uno de los premios, nuestro crédito aumenta, del contrario disminuye.

Gracias esto es todo. 

Acontinuacion el link para que descarguen el proyecto completo hecho en eclipse.

Descargar el archivo  

• Tweet
• Share
• Share
• Share
• Share