Desafíos de POO Game — Asociación y Combate por Turnos

class Punto {
    private int fila;
    private int columna;
    private int valor;
    private boolean comido;

    public Punto(int fila, int columna, int valor) {
        this.fila = fila;
        this.columna = columna;
        this.valor = valor;
        this.comido = false;
    }

    public void comer() {
        this.comido = true;
    }

    public boolean estaComido() {
        return this.comido;
    }

    public boolean coincide(int fila, int columna) {
        return this.fila == fila && this.columna == columna;
    }

    public String getPosicion() {
        return "(" + fila + "," + columna + ")";
    }

    public int getValor() {
        return valor;
    }
}

class Pacman {
    private String nombre;
    private int fila;
    private int columna;
    private String direccion;
    private int puntosComidos;
    private int marcador;

    public Pacman(String nombre, int fila, int columna, String direccion) {
        this.nombre = nombre;
        this.fila = fila;
        this.columna = columna;
        this.direccion = direccion;
        this.puntosComidos = 0;
        this.marcador = 0;
    }

    public void mover(int nuevaFila, int nuevaColumna, String nuevaDireccion) {
        this.fila = nuevaFila;
        this.columna = nuevaColumna;
        this.direccion = nuevaDireccion;
        System.out.println("🕹️ " + nombre + " se mueve " + nuevaDireccion + " hasta la celda " + nuevaFila + "," + nuevaColumna);
    }

    public boolean estaEnPunto(Punto punto) {
        return !punto.estaComido() && punto.coincide(this.fila, this.columna);
    }

    public void comer(Punto punto) {
        if (estaEnPunto(punto)) {
            punto.comer();
            this.puntosComidos++;
            this.marcador += punto.getValor();
            System.out.println("😋 " + nombre + " come el punto de " + punto.getPosicion() + " (+" + punto.getValor() + ")");
        } else {
            System.out.println(nombre + " está en " + this.fila + "," + this.columna + " y ese punto ya no está disponible.");
        }
    }

    public void mostrarEstado() {
        System.out.println(nombre + " -> " + direccion + " | puntos comidos: " + puntosComidos + " | marcador: " + marcador);
    }

    public String getNombre() {
        return nombre;
    }
}

public class Main {
    public static void main(String[] args) {
        Punto puntoRojo = new Punto(3, 4, 10);
        Punto puntoAzul = new Punto(3, 5, 20);

        Pacman pacman = new Pacman("Pac-Man", 3, 3, "DERECHA");
        pacman.mostrarEstado();

        pacman.mover(3, 4, "DERECHA");
        pacman.comer(puntoRojo);
        pacman.comer(puntoRojo);

        pacman.mover(3, 5, "DERECHA");
        pacman.comer(puntoAzul);
        pacman.mostrarEstado();
    }
}

class Pieza {
    private String forma;
    private int fila;
    private int columna;
    private boolean quieta;

    public Pieza(String forma, int fila, int columna) {
        this.forma = forma;
        this.fila = fila;
        this.columna = columna;
        this.quieta = false;
    }

    public boolean moverAbajo(int filasTablero) {
        if (this.fila + 1 >= filasTablero) {
            this.quieta = true;
            return false;
        }
        this.fila++;
        return true;
    }

    public void moverIzquierda() {
        if (this.columna > 0) {
            this.columna--;
        }
    }

    public void moverDerecha() {
        this.columna++;
    }

    public boolean estaQuieta() {
        return this.quieta;
    }

    public String getPosicion() {
        return forma + " en (" + fila + "," + columna + ")";
    }

    public int getColumna() {
        return columna;
    }

    public int getFila() {
        return fila;
    }
}

class Tablero {
    private int filas;
    private int columnas;
    private Pieza piezaActiva;
    private int lineasCompletadas;

    // Composicion: el tablero crea su propia pieza, no la recibe.
    public Tablero(int filas, int columnas) {
        this.filas = filas;
        this.columnas = columnas;
        this.lineasCompletadas = 0;
        this.piezaActiva = new Pieza("T", 0, 3);
    }

    public boolean cabe(Pieza pieza) {
        return pieza.getColumna() >= 0 && pieza.getColumna() < this.columnas && pieza.getFila() < this.filas;
    }

    public void soltarPieza() {
        if (piezaActiva.estaQuieta()) {
            lineasCompletadas++;
            System.out.println("🧱 Línea completada por la pieza " + piezaActiva.getPosicion());
            piezaActiva = new Pieza("L", 0, 2);
        }
    }

    public void mostrar() {
        System.out.println("Tablero " + filas + "x" + columnas + " | líneas: " + lineasCompletadas + " | activa: " + piezaActiva.getPosicion());
    }
}

public class Main {
    public static void main(String[] args) {
        Tablero tablero = new Tablero(20, 10);
        tablero.mostrar();

        for (int i = 0; i < 19; i++) {
            tablero.soltarPieza();
        }
        tablero.soltarPieza();
        tablero.mostrar();
    }
}

class Coche {
    private String color;
    private int carril;
    private int columna;
    private int velocidad;
    private boolean activo;

    public Coche(String color, int carril, int velocidad) {
        this.color = color;
        this.carril = carril;
        this.columna = 0;
        this.velocidad = velocidad;
        this.activo = true;
    }

    public void avanzar() {
        if (!activo) {
            return;
        }
        this.columna += this.velocidad;
        if (this.columna > 20) {
            this.columna = 0;
        }
    }

    public boolean estaEn(int columnaRana) {
        return this.activo && this.columna == columnaRana;
    }

    public void frenar() {
        this.activo = false;
    }

    public int getColumna() {
        return columna;
    }

    public String getColor() {
        return color + " (carril " + carril + ", col " + columna + ")";
    }
}

class Rana {
    private String nombre;
    private int carril;
    private int columna;
    private int vidas;
    private int puntos;
    private int carrilMaximo;

    public Rana(String nombre, int columna, int vidas, int carrilMaximo) {
        this.nombre = nombre;
        this.carril = 0;
        this.columna = columna;
        this.vidas = vidas;
        this.puntos = 0;
        this.carrilMaximo = carrilMaximo;
    }

    public void avanzar() {
        if (this.carril < this.carrilMaximo) {
            this.carril++;
            this.puntos += 10;
        }
    }

    public boolean saltar(Coche coche) {
        if (coche.estaEn(this.columna)) {
            this.vidas--;
            System.out.println("💥 " + nombre + " fue atropellado por el " + coche.getColor() + ". Vidas: " + this.vidas);
            return false;
        }
        this.puntos += 5;
        System.out.println("🐸 " + nombre + " saltó el carril con éxito (+5)");
        return true;
    }

    public boolean estaViva() {
        return this.vidas > 0;
    }

    public void mostrarEstado() {
        System.out.println(nombre + " | carril: " + this.carril + "/" + this.carrilMaximo + " | puntos: " + puntos + " | vidas: " + vidas);
    }
}

public class Main {
    public static void main(String[] args) {
        Coche cocheRojo = new Coche("ROJO", 1, 3);
        Coche cocheAzul = new Coche("AZUL", 2, 5);

        Rana rana = new Rana("Rana Pepe", 10, 3, 5);
        rana.mostrarEstado();

        rana.avanzar();
        cocheRojo.avanzar();
        cocheRojo.avanzar();
        cocheRojo.avanzar();
        rana.saltar(cocheRojo);

        cocheAzul.frenar();
        rana.saltar(cocheAzul);
        rana.mostrarEstado();
    }
}

class Pelota {
    private double posicionX;
    private double posicionY;
    private double velocidadX;
    private double velocidadY;
    private int rebotes;

    public Pelota(double posicionX, double posicionY, double velocidadX, double velocidadY) {
        this.posicionX = posicionX;
        this.posicionY = posicionY;
        this.velocidadX = velocidadX;
        this.velocidadY = velocidadY;
        this.rebotes = 0;
    }

    public void mover(int anchoCampo, int altoCampo) {
        this.posicionX += this.velocidadX;
        this.posicionY += this.velocidadY;

        if (this.posicionY <= 0 || this.posicionY >= altoCampo) {
            this.velocidadY = -this.velocidadY;
            this.rebotes++;
            System.out.println("🟡 Rebote en el borde superior/inferior (rebote " + this.rebotes + ")");
        }
        if (this.posicionX <= 0 || this.posicionX >= anchoCampo) {
            this.velocidadX = -this.velocidadX;
        }
    }

    public void rebotarEnJugador(Jugador jugador, int anchoCampo) {
        this.posicionX = anchoCampo - 1;
        this.velocidadX = -Math.abs(this.velocidadX);
        this.posicionY = jugador.getPosicionY();
        this.rebotes++;
        System.out.println("🏓 " + jugador.getNombre() + " devuelve la pelota (rebote " + this.rebotes + ")");
    }

    public boolean superaJugador(Jugador jugador, int anchoCampo) {
        return this.posicionX <= 1 && jugador.getPosicionY() + 12 < this.posicionY - 12;
    }

    public double getPosicionY() {
        return posicionY;
    }

    public double getPosicionX() {
        return posicionX;
    }
}

class Jugador {
    private String nombre;
    private int posicionY;
    private int puntos;
    private int velocidad;
    private int alturaCampo;

    public Jugador(String nombre, int posicionY, int velocidad, int alturaCampo) {
        this.nombre = nombre;
        this.posicionY = posicionY;
        this.puntos = 0;
        this.velocidad = velocidad;
        this.alturaCampo = alturaCampo;
    }

    public void mover(int delta) {
        int nuevaPosicion = this.posicionY + delta * this.velocidad;
        if (nuevaPosicion < 0) {
            nuevaPosicion = 0;
        }
        if (nuevaPosicion > this.alturaCampo - 40) {
            nuevaPosicion = this.alturaCampo - 40;
        }
        this.posicionY = nuevaPosicion;
    }

    public boolean cubre(Pelota pelota, int anchoCampo) {
        return Math.abs(pelota.getPosicionY() - this.posicionY) < 20 && pelota.getPosicionX() <= 2;
    }

    public void marcarPunto() {
        this.puntos++;
        System.out.println("🏆 Punto para " + this.nombre + ". Marcador: " + this.puntos);
    }

    public int getPosicionY() {
        return posicionY;
    }

    public String getNombre() {
        return nombre;
    }
}

public class Main {
    public static void main(String[] args) {
        int anchoCampo = 60;
        int altoCampo = 30;

        Jugador jugador = new Jugador("Jugador 1", 15, 2, altoCampo);
        Pelota pelota = new Pelota(5, 15, 3, 1);

        for (int i = 0; i < 3; i++) {
            pelota.mover(anchoCampo, altoCampo);
            if (jugador.cubre(pelota, anchoCampo)) {
                pelota.rebotarEnJugador(jugador, anchoCampo);
            }
        }
        jugador.mover(1);
        jugador.marcarPunto();
    }
}

class Alien {
    private String tipo;
    private int posicionX;
    private int posicionY;
    private int vida;
    private int velocidad;

    public Alien(String tipo, int posicionX, int posicionY, int vida, int velocidad) {
        this.tipo = tipo;
        this.posicionX = posicionX;
        this.posicionY = posicionY;
        this.vida = vida;
        this.velocidad = velocidad;
    }

    public boolean recibirDisparo(int danio) {
        this.vida -= danio;
        if (this.vida <= 0) {
            System.out.println("💥 Alien " + tipo + " destruido en x=" + posicionX);
            return true;
        }
        System.out.println("🛡️ Alien " + tipo + " resistió el disparo (vida: " + this.vida + ")");
        return false;
    }

    public boolean estaVivo() {
        return this.vida > 0;
    }

    public void mover(int delta) {
        this.posicionX += delta * this.velocidad;
    }

    public String getTipo() {
        return tipo;
    }

    public int getPosicionX() {
        return posicionX;
    }
}

class Nave {
    private String nombre;
    private int posicionX;
    private int posicionY;
    private int puntos;
    private int anchoCampo;
    private int danioDisparo;

    public Nave(String nombre, int posicionX, int posicionY, int anchoCampo) {
        this.nombre = nombre;
        this.posicionX = posicionX;
        this.posicionY = posicionY;
        this.puntos = 0;
        this.anchoCampo = anchoCampo;
        this.danioDisparo = 2;
    }

    public void mover(int delta) {
        int nuevaPosicion = this.posicionX + delta;
        if (nuevaPosicion >= 0 && nuevaPosicion <= this.anchoCampo) {
            this.posicionX = nuevaPosicion;
        }
    }

    public void disparar(Alien alien) {
        System.out.println("🚀 " + nombre + " dispara en x=" + this.posicionX + " hacia el alien " + alien.getTipo());
        if (alien.recibirDisparo(this.danioDisparo)) {
            this.puntos += puntosPorTipo(alien.getTipo());
            System.out.println("   +" + puntosPorTipo(alien.getTipo()) + " puntos");
        }
    }

    private int puntosPorTipo(String tipo) {
        if (tipo.equals("Calamar")) {
            return 30;
        }
        if (tipo.equals("Cangrejo")) {
            return 20;
        }
        return 10;
    }

    public void mostrarEstado() {
        System.out.println(nombre + " | x=" + posicionX + " | puntos: " + this.puntos);
    }
}

public class Main {
    public static void main(String[] args) {
        Nave nave = new Nave("Nave Interceptora", 10, 20, 30);
        Alien calamar = new Alien("Calamar", 10, 5, 2, 1);
        Alien pulpo = new Alien("Cangrejo", 14, 5, 5, 1);

        nave.mostrarEstado();
        nave.disparar(calamar);
        nave.mover(2);
        nave.disparar(calamar);
        nave.disparar(pulpo);
        pulpo.mover(1);
        nave.mostrarEstado();
    }
}

class Tubo {
    private int columna;
    private int huecoCentro;
    private int huecoTamano;
    private int altoPantalla;

    public Tubo(int columna, int huecoCentro, int huecoTamano, int altoPantalla) {
        this.columna = columna;
        this.huecoCentro = huecoCentro;
        this.huecoTamano = huecoTamano;
        this.altoPantalla = altoPantalla;
    }

    public int alturaBordeSuperior() {
        return this.huecoCentro - (this.huecoTamano / 2);
    }

    public int alturaBordeInferior() {
        return this.huecoCentro + (this.huecoTamano / 2);
    }

    public boolean pasoSeguro(int alturaPajaro) {
        if (this.columna > 0) {
            return true;
        }
        return alturaPajaro > this.alturaBordeSuperior() && alturaPajaro < this.alturaBordeInferior();
    }

    public int getColumna() {
        return columna;
    }
}

class Pajaro {
    private String nombre;
    private int altura;
    private int velocidad;
    private int gravedad;
    private int altoPantalla;
    private int columnasAvanzadas;
    private boolean vivo;

    public Pajaro(String nombre, int alturaInicial, int altoPantalla) {
        this.nombre = nombre;
        this.altura = alturaInicial;
        this.altoPantalla = altoPantalla;
        this.velocidad = 0;
        this.gravedad = 1;
        this.columnasAvanzadas = 0;
        this.vivo = true;
    }

    public void volar() {
        this.velocidad = -2;
        this.altura += this.velocidad;
    }

    public void caer() {
        this.velocidad += this.gravedad;
        this.altura += this.velocidad;
        this.columnasAvanzadas++;
        if (this.altura >= this.altoPantalla) {
            this.altura = this.altoPantalla;
            this.vivo = false;
            System.out.println("💥 " + nombre + " cayó al suelo.");
        }
    }

    public boolean choca(Tubo tubo) {
        if (tubo.getColumna() != 0) {
            return false;
        }
        boolean seguro = tubo.pasoSeguro(this.altura);
        if (!seguro) {
            this.vivo = false;
            System.out.println("💥 " + nombre + " chocó con el tubo en la columna " + tubo.getColumna());
        }
        return seguro;
    }

    public boolean estaVivo() {
        return vivo;
    }

    public void mostrarEstado() {
        System.out.println(nombre + " | altura: " + altura + " | velocidad: " + velocidad + " | vivo: " + vivo);
    }
}

public class Main {
    public static void main(String[] args) {
        int altoPantalla = 40;
        Pajaro pajaro = new Pajaro("Flappy", 20, altoPantalla);
        Tubo tuboRojo = new Tubo(0, 20, 16, altoPantalla);

        pajaro.mostrarEstado();
        pajaro.volar();
        pajaro.caer();
        pajaro.mostrarEstado();
        pajaro.caer();
        pajaro.caer();
        pajaro.volar();
        pajaro.caer();
        pajaro.mostrarEstado();
        pajaro.choca(tuboRojo);
        System.out.println("¿Sobrevivió? " + pajaro.estaVivo());
    }
}

class Piloto {
    private String nombre;
    private String equipo;
    private int pericia;
    private int carrerasGanadas;

    public Piloto(String nombre, String equipo, int pericia) {
        this.nombre = nombre;
        this.equipo = equipo;
        this.pericia = pericia;
        this.carrerasGanadas = 0;
    }

    public String getNombre() {
        return nombre;
    }

    public String getEquipo() {
        return equipo;
    }

    public boolean esExperto() {
        return this.pericia >= 8;
    }

    public void ganarCarrera() {
        this.carrerasGanadas++;
    }
}

class Kart {
    private String modelo;
    private String color;
    private int velocidad;
    private int velocidadMaxima;
    private int resistencia;
    private Piloto piloto;

    public Kart(String modelo, String color, int velocidadMaxima, int resistencia, Piloto piloto) {
        this.modelo = modelo;
        this.color = color;
        this.velocidadMaxima = velocidadMaxima;
        this.resistencia = resistencia;
        this.piloto = piloto;
        this.velocidad = 0;
    }

    public void acelerar() {
        int tope = this.piloto.esExperto() ? this.velocidadMaxima : this.velocidadMaxima - 10;
        this.velocidad += 5;
        if (this.velocidad > tope) {
            this.velocidad = tope;
        }
        System.out.println("🏎️ " + this.piloto.getNombre() + " acelera el " + modelo + " (" + this.velocidad + "/" + tope + ")");
    }

    public void frenar() {
        this.velocidad = 0;
        System.out.println("🛑 Kart detenido en boxes.");
    }

    public void asignarPiloto(Piloto nuevoPiloto) {
        this.piloto = nuevoPiloto;
        System.out.println("🔁 El " + modelo + " ahora lo conduce " + nuevoPiloto.getNombre() + " (" + nuevoPiloto.getEquipo() + ")");
    }

    public void desgaste(int puntos) {
        this.resistencia -= puntos;
        System.out.println("🔧 " + modelo + " (" + color + ") sufre " + puntos + " de desgaste. Resistencia: " + this.resistencia);
    }
}

public class Main {
    public static void main(String[] args) {
        Piloto mario = new Piloto("Mario", "Equipo Champiñón", 9);
        Kart kartRojo = new Kart("Kart Fénix", "ROJO", 100, 80, mario);

        kartRojo.acelerar();
        kartRojo.acelerar();
        kartRojo.desgaste(25);
        kartRojo.frenar();

        Piloto rosalina = new Piloto("Rosalina", "Equipo Estrella", 5);
        kartRojo.asignarPiloto(rosalina);
        kartRojo.acelerar();
        kartRojo.acelerar();
    }
}

class Anillo {
    private int valor;
    private boolean recogido;
    private int posicionX;

    public Anillo(int valor, int posicionX) {
        this.valor = valor;
        this.posicionX = posicionX;
        this.recogido = false;
    }

    public void recoger() {
        this.recogido = true;
    }

    public boolean estaRecogido() {
        return this.recogido;
    }

    public int getValor() {
        return valor;
    }

    public int getPosicionX() {
        return posicionX;
    }
}

class Sonic {
    private String nombre;
    private int anillos;
    private int velocidad;
    private int energia;
    private int distancia;

    public Sonic(String nombre, int velocidad, int energia) {
        this.nombre = nombre;
        this.anillos = 0;
        this.velocidad = velocidad;
        this.energia = energia;
        this.distancia = 0;
    }

    public void correr(int distancia) {
        this.distancia += distancia;
        this.energia -= distancia / 10;
        System.out.println("💨 " + nombre + " corre " + distancia + " m a " + this.velocidad + " km/h. Energía: " + this.energia);
    }

    public void recoger(Anillo anillo) {
        if (anillo.estaRecogido()) {
            System.out.println("El anillo de x=" + anillo.getPosicionX() + " ya estaba recogido.");
            return;
        }
        anillo.recoger();
        this.anillos += anillo.getValor();
        System.out.println("💍 " + nombre + " recoge un anillo (+" + anillo.getValor() + "). Total: " + this.anillos);
    }

    public boolean puedeSaltar() {
        return this.energia > 20;
    }

    public void mostrarEstado() {
        System.out.println(nombre + " | distancia: " + distancia + " m | anillos: " + anillos + " | energía: " + energia);
    }
}

public class Main {
    public static void main(String[] args) {
        Anillo chico = new Anillo(1, 120);
        Anillo grande = new Anillo(10, 350);

        Sonic sonic = new Sonic("Sonic", 40, 100);
        sonic.correr(60);
        sonic.recoger(chico);
        sonic.recoger(chico);
        sonic.correr(120);
        sonic.recoger(grande);
        sonic.mostrarEstado();
        System.out.println("Puede saltar: " + sonic.puedeSaltar());
    }
}

class Barril {
    private int columna;
    private int velocidad;
    private int posicion;
    private int posicionMaxima;
    private boolean activo;

    public Barril(int columna, int velocidad, int posicionMaxima) {
        this.columna = columna;
        this.velocidad = velocidad;
        this.posicionMaxima = posicionMaxima;
        this.posicion = 0;
        this.activo = true;
    }

    public void caer() {
        if (!activo) {
            return;
        }
        this.posicion += this.velocidad;
        if (this.posicion >= this.posicionMaxima) {
            this.posicion = 0;
            this.activo = false;
        }
    }

    public boolean estaEn(int posicionMario) {
        return this.activo && this.columna == posicionMario && this.posicion > this.posicionMaxima / 2;
    }

    public boolean estaActivo() {
        return activo;
    }
}

class Mario {
    private String nombre;
    private int posicionX;
    private int piso;
    private int vidas;
    private int puntuacion;
    private int pisoMaximo;

    public Mario(String nombre, int posicionX, int vidas, int pisoMaximo) {
        this.nombre = nombre;
        this.posicionX = posicionX;
        this.piso = 0;
        this.vidas = vidas;
        this.puntuacion = 0;
        this.pisoMaximo = pisoMaximo;
    }

    public void subir(int pisos) {
        int nuevoPiso = this.piso + pisos;
        if (nuevoPiso > this.pisoMaximo) {
            nuevoPiso = this.pisoMaximo;
        }
        this.piso = nuevoPiso;
        this.puntuacion += pisos * 100;
    }

    public boolean esquivar(Barril barril) {
        if (barril.estaEn(this.posicionX)) {
            this.vidas--;
            System.out.println("💥 ¡Barril en la columna " + this.posicionX + "! Vidas: " + this.vidas);
            return false;
        }
        System.out.println("🍌 " + this.nombre + " esquivó el barril de la columna " + this.posicionX);
        return true;
    }

    public boolean estaVivo() {
        return this.vidas > 0;
    }

    public void mostrarEstado() {
        System.out.println(nombre + " | piso: " + piso + "/" + pisoMaximo + " | vidas: " + vidas + " | puntos: " + puntuacion);
    }
}

public class Main {
    public static void main(String[] args) {
        Mario mario = new Mario("Mario", 4, 3, 8);
        Barril barrilRapido = new Barril(4, 3, 12);
        Barril barrilLento = new Barril(7, 1, 12);

        mario.mostrarEstado();
        barrilRapido.caer();
        barrilRapido.caer();
        barrilRapido.caer();
        barrilRapido.caer();
        mario.esquivar(barrilRapido);

        mario.subir(3);
        barrilLento.caer();
        mario.esquivar(barrilLento);
        mario.mostrarEstado();
    }
}

class Tabla {
    private String modelo;
    private String color;
    private int desgaste;
    private String nivel;

    public Tabla(String modelo, String color, String nivel) {
        this.modelo = modelo;
        this.color = color;
        this.nivel = nivel;
        this.desgaste = 0;
    }

    public void desgastarse(int factor) {
        this.desgaste += factor;
        if (this.desgaste > 100) {
            this.desgaste = 100;
            System.out.println("💔 La tabla " + modelo + " se rompió en dos.");
        }
    }

    public boolean estaRota() {
        return this.desgaste >= 100;
    }

    public String getModelo() {
        return modelo;
    }

    public int getDesgaste() {
        return desgaste;
    }
}

class Skater {
    private String nombre;
    private Tabla tabla;
    private int puntaje;
    private String trucoActual;
    private int distancia;

    public Skater(String nombre, Tabla tabla) {
        this.nombre = nombre;
        this.tabla = tabla;
        this.puntaje = 0;
        this.trucoActual = "ninguno";
        this.distancia = 0;
    }

    public void hacerTruco(String nombreTruco, int dificultad) {
        if (tabla.estaRota()) {
            System.out.println(nombre + " no puede hacer " + nombreTruco + ": la tabla está rota.");
            return;
        }
        this.trucoActual = nombreTruco;
        this.puntaje += dificultad * 100;
        tabla.desgastarse(dificultad * 8);
        System.out.println("🛹 " + nombre + " hizo " + nombreTruco + " (+" + (dificultad * 100) + ") con la tabla " + tabla.getModelo());
    }

    public void deslizarse(int distancia) {
        this.distancia += distancia;
        tabla.desgastarse(2);
    }

    public Tabla getTabla() {
        return tabla;
    }

    public void mostrarEstado() {
        System.out.println(nombre + " | truco: " + trucoActual + " | puntaje: " + puntaje + " | tabla " + tabla.getModelo() + " (" + tabla.getDesgaste() + "% desgaste)");
    }
}

public class Main {
    public static void main(String[] args) {
        Tabla tablaPatineta = new Tabla("Patineta Neón", "VERDE", "pro");
        Skater skater = new Skater("Tony", tablaPatineta);

        skater.deslizarse(50);
        skater.hacerTruco("Ollie", 2);
        skater.hacerTruco("Kickflip", 4);
        skater.hacerTruco("Grind en el riel", 6);
        skater.mostrarEstado();
        skater.hacerTruco("900", 9);
        skater.mostrarEstado();
    }
}

class Poder {
    private String nombre;
    private String tipo;
    private int dano;
    private int usos;

    public Poder(String nombre, String tipo, int dano) {
        this.nombre = nombre;
        this.tipo = tipo;
        this.dano = dano;
        this.usos = 0;
    }

    public int usar() {
        this.usos++;
        if (this.tipo.equals("FUEGO")) {
            return this.dano * 2;
        }
        return this.dano;
    }

    public boolean estaAgotado() {
        return this.usos >= 3;
    }

    public String getNombre() {
        return nombre;
    }
}

class Enemigo {
    private String nombre;
    private int vida;
    private String poderQueOtorga;
    private String tipo;

    public Enemigo(String nombre, String tipo, int vida, String poderQueOtorga) {
        this.nombre = nombre;
        this.tipo = tipo;
        this.vida = vida;
        this.poderQueOtorga = poderQueOtorga;
    }

    public boolean recibirDanio(int danio) {
        this.vida -= danio;
        if (this.vida <= 0) {
            System.out.println("💫 Enemigo " + nombre + " derrotado.");
            return true;
        }
        return false;
    }

    public String otorgarPoder() {
        return this.poderQueOtorga;
    }

    public String getNombre() {
        return nombre;
    }

    public int getVida() {
        return vida;
    }
}

class Kirby {
    private String nombre;
    private int vida;
    private Poder poderCopiado;
    private int poderesUsados;

    public Kirby(String nombre, int vida) {
        this.nombre = nombre;
        this.vida = vida;
        this.poderCopiado = null;
        this.poderesUsados = 0;
    }

    public boolean tienePoder() {
        return this.poderCopiado != null && !this.poderCopiado.estaAgotado();
    }

    public void copiarPoder(Enemigo enemigo) {
        String nombrePoder = enemigo.otorgarPoder();
        this.poderCopiado = new Poder(nombrePoder, nombrePoder, 4);
        System.out.println("🍑 " + nombre + " copió el poder " + nombrePoder + " de " + enemigo.getNombre());
    }

    public void usarPoder(Enemigo objetivo) {
        if (!tienePoder()) {
            System.out.println(nombre + " todavía no tiene ningún poder copiado.");
            return;
        }
        int danio = this.poderCopiado.usar();
        this.poderesUsados++;
        System.out.println("💥 " + nombre + " usa " + this.poderCopiado.getNombre() + " y hace " + danio + " de daño");
        objetivo.recibirDanio(danio);
    }

    public void mostrarEstado() {
        String poder = this.poderCopiado == null ? "ninguno" : this.poderCopiado.getNombre();
        System.out.println(nombre + " | vida: " + vida + " | poder: " + poder + " | usos: " + poderesUsados);
    }
}

public class Main {
    public static void main(String[] args) {
        Kirby kirby = new Kirby("Kirby", 100);
        Enemigo waddle = new Enemigo("Waddle Dee", "MARTILLO", 6, "MARTILLO");

        kirby.mostrarEstado();
        kirby.copiarPoder(waddle);
        kirby.usarPoder(waddle);
        kirby.usarPoder(waddle);
        kirby.mostrarEstado();
    }
}

class Misil {
    private int dano;
    private int radioExplosion;
    private boolean usado;

    public Misil(int dano, int radioExplosion) {
        this.dano = dano;
        this.radioExplosion = radioExplosion;
        this.usado = false;
    }

    public int explota() {
        this.usado = true;
        return this.dano + (this.radioExplosion * 2);
    }

    public int getDano() {
        return dano;
    }

    public boolean estaUsado() {
        return usado;
    }
}

class Metroide {
    private String tipo;
    private int vida;
    private String tamano;
    private boolean partido;

    public Metroide(String tipo, int vida, String tamano) {
        this.tipo = tipo;
        this.vida = vida;
        this.tamano = tamano;
        this.partido = false;
    }

    public boolean recibirDanio(int danio) {
        this.vida -= danio;
        if (this.vida <= 0) {
            System.out.println("☠️ Metroide " + tipo + " destruido (" + tamano + ")");
            return true;
        }
        if (this.tamano.equals("GRANDE") && danio > 10) {
            this.partido = true;
            System.out.println("🧬 El Metroide " + tipo + " se ha partido en dos!");
        }
        return false;
    }

    public boolean sePartio() {
        return this.partido;
    }

    public int getVida() {
        return vida;
    }
}

class Samus {
    private String nombre;
    private int vida;
    private int municion;
    private Misil misilActual;
    private int metroidesDerrotados;

    public Samus(String nombre, int vida, int municion, Misil misil) {
        this.nombre = nombre;
        this.vida = vida;
        this.municion = municion;
        this.misilActual = misil;
        this.metroidesDerrotados = 0;
    }

    public boolean tieneMunicion() {
        return this.municion > 0 && this.misilActual != null;
    }

    public void recogerMisil(Misil misil) {
        this.misilActual = misil;
        this.municion += 5;
        System.out.println("🧨 " + nombre + " recogió un misil nuevo (daño " + misil.getDano() + ")");
    }

    public void disparar(Metroide metroide) {
        if (!tieneMunicion()) {
            System.out.println("🔫 " + nombre + " no tiene munición disponible.");
            return;
        }
        int danio = this.misilActual.explota();
        this.municion--;
        System.out.println("💥 " + nombre + " dispara un misil de daño " + danio);
        if (metroide.recibirDanio(danio)) {
            this.metroidesDerrotados++;
        }
        this.misilActual = new Misil(4, 1);
    }

    public void mostrarEstado() {
        System.out.println(nombre + " | vida: " + vida + " | munición: " + municion + " | metroides derrotados: " + metroidesDerrotados);
    }
}

public class Main {
    public static void main(String[] args) {
        Misil misilInicial = new Misil(8, 3);
        Samus samus = new Samus("Samus", 99, 2, misilInicial);
        Metroide metroideGrande = new Metroide("Zeta", 30, "GRANDE");
        Metroide metroidePequeno = new Metroide("Rinka", 12, "PEQUEÑO");

        samus.mostrarEstado();
        samus.disparar(metroideGrande);
        samus.disparar(metroideGrande);
        samus.disparar(metroidePequeno);
        samus.recogerMisil(new Misil(15, 4));
        samus.disparar(metroidePequeno);
        samus.mostrarEstado();
    }
}

class Planta {
    private String tipo;
    private int vida;
    private int coste;
    private int dano;
    private int recarga;

    public Planta(String tipo, int vida, int coste, int dano) {
        this.tipo = tipo;
        this.vida = vida;
        this.coste = coste;
        this.dano = dano;
        this.recarga = 2;
    }

    public int disparar() {
        if (this.recarga <= 0) {
            return 0;
        }
        this.recarga--;
        return this.dano;
    }

    public boolean recibirDanio(int danio) {
        this.vida -= danio;
        return this.vida <= 0;
    }

    public boolean estaViva() {
        return this.vida > 0;
    }

    public String getTipo() {
        return tipo;
    }

    public int getCoste() {
        return coste;
    }
}

class Zombi {
    private String nombre;
    private int vida;
    private int velocidad;
    private int posX;
    private String tipo;

    public Zombi(String nombre, String tipo, int vida, int velocidad) {
        this.nombre = nombre;
        this.tipo = tipo;
        this.vida = vida;
        this.velocidad = velocidad;
        this.posX = 0;
    }

    public void avanzar() {
        this.posX += this.velocidad;
    }

    public boolean recibirDanio(int danio) {
        int danoEfectivo = this.tipo.equals("CHADOR") ? danio / 2 : danio;
        this.vida -= danoEfectivo;
        if (this.vida <= 0) {
            System.out.println("🧟 " + nombre + " fue derrotado");
            return true;
        }
        return false;
    }

    public boolean llegoAlFinal() {
        return this.posX >= 50;
    }

    public String getNombre() {
        return nombre;
    }
}

class Jardinero {
    private String nombre;
    private int monedas;
    private Planta plantaActiva;
    private int zombisDerrotados;

    public Jardinero(String nombre, int monedas) {
        this.nombre = nombre;
        this.monedas = monedas;
        this.plantaActiva = null;
        this.zombisDerrotados = 0;
    }

    public boolean plantar(Planta planta) {
        if (this.monedas < planta.getCoste()) {
            System.out.println("🪙 No hay monedas suficientes para plantar " + planta.getTipo());
            return false;
        }
        this.monedas -= planta.getCoste();
        this.plantaActiva = planta;
        System.out.println("🌱 " + nombre + " plantó " + planta.getTipo() + " (-" + planta.getCoste() + " monedas)");
        return true;
    }

    public void disparar(Zombi zombi) {
        if (this.plantaActiva == null || !this.plantaActiva.estaViva()) {
            System.out.println("No hay ninguna planta activa que dispare.");
            return;
        }
        int danio = this.plantaActiva.disparar();
        if (danio == 0) {
            System.out.println("La planta está recargando...");
            return;
        }
        System.out.println("🌻 " + this.plantaActiva.getTipo() + " dispara a " + zombi.getNombre());
        if (zombi.recibirDanio(danio)) {
            this.zombisDerrotados++;
        }
    }

    public void mostrarEstado() {
        String planta = this.plantaActiva == null ? "ninguna" : this.plantaActiva.getTipo();
        System.out.println(nombre + " | monedas: " + monedas + " | planta: " + planta + " | zombis derrotados: " + zombisDerrotados);
    }
}

public class Main {
    public static void main(String[] args) {
        Jardinero jardinero = new Jardinero("Crisp", 75);
        Zombi zombiNormal = new Zombi("Zombi básico", "NORMAL", 20, 5);
        Zombi zombiChador = new Zombi("Zombi con cono", "CHADOR", 40, 3);

        jardinero.plantar(new Planta("Girasol", 30, 50, 6));
        jardinero.disparar(zombiNormal);
        jardinero.disparar(zombiNormal);
        zombiNormal.avanzar();
        zombiChador.avanzar();
        jardinero.disparar(zombiChador);
        jardinero.mostrarEstado();
    }
}

class Muro {
    private String tipo;
    private int vida;
    private int nivel;

    public Muro(String tipo, int vida, int nivel) {
        this.tipo = tipo;
        this.vida = vida;
        this.nivel = nivel;
    }

    public boolean recibirDanio(int danio) {
        this.vida -= danio;
        if (this.vida <= 0) {
            this.vida = 0;
            System.out.println("🧱 El muro de " + tipo + " ha caído.");
            return false;
        }
        return true;
    }

    public boolean estaEnPie() {
        return this.vida > 0;
    }

    public String getTipo() {
        return tipo;
    }

    public int getVida() {
        return vida;
    }
}

class Cuartel {
    private int nivel;
    private int capacidadTropas;
    private int tropasFormadas;

    public Cuartel(int nivel) {
        this.nivel = nivel;
        this.capacidadTropas = nivel * 5;
        this.tropasFormadas = 0;
    }

    public void mejorar() {
        this.nivel++;
        this.capacidadTropas = this.nivel * 5;
        System.out.println("🏰 Cuartel mejorado a nivel " + this.nivel + " (capacidad " + this.capacidadTropas + ")");
    }

    public boolean puedeInvocar() {
        return this.tropasFormadas < this.capacidadTropas;
    }

    public void invocarTropa(String nombre) {
        if (puedeInvocar()) {
            this.tropasFormadas++;
            System.out.println("⚔️ Se invocó " + nombre + " en el cuartel");
        } else {
            System.out.println("El cuartel está al máximo de tropas (" + this.tropasFormadas + "/" + this.capacidadTropas + ")");
        }
    }

    public int getCapacidadTropas() {
        return capacidadTropas;
    }
}

class Aldeano {
    private String nombre;
    private int nivel;
    private int oro;
    private Cuartel cuartel;
    private Muro muroPrincipal;
    private int poblacion;

    public Aldeano(String nombre, int nivel, int oro, Cuartel cuartel) {
        this.nombre = nombre;
        this.nivel = nivel;
        this.oro = oro;
        this.cuartel = cuartel;
        this.muroPrincipal = null;
        this.poblacion = 0;
    }

    public void mejorarCuartel() {
        this.oro -= 500;
        this.cuartel.mejorar();
        System.out.println("💰 " + nombre + " gastó 500 de oro (quedan " + this.oro + ")");
    }

    public void invocarTropas(String nombreTropa) {
        this.cuartel.invocarTropa(nombreTropa);
        this.oro -= 50;
        this.poblacion += 2;
    }

    public void colocarMuro(Muro muro) {
        this.muroPrincipal = muro;
        System.out.println("🧱 " + nombre + " colocó un muro de " + muro.getTipo() + " con " + muro.getVida() + " de vida");
    }

    public void mostrarEstado() {
        String muro = this.muroPrincipal == null ? "sin muros" : this.muroPrincipal.getTipo() + " (" + this.muroPrincipal.getVida() + " HP)";
        System.out.println(nombre + " | nivel: " + nivel + " | oro: " + oro + " | población: " + poblacion + " | muro: " + muro);
    }
}

public class Main {
    public static void main(String[] args) {
        Cuartel cuartelInicial = new Cuartel(3);
        Aldeano aldeano = new Aldeano("Chief", 4, 1000, cuartelInicial);

        aldeano.mostrarEstado();
        aldeano.colocarMuro(new Muro("Piedra", 300, 2));
        aldeano.invocarTropas("Duendes");
        aldeano.mejorarCuartel();
        aldeano.invocarTropas("Gólems");
        aldeano.mostrarEstado();
    }
}

class Ficha {
    private String color;
    private int fila;
    private int columna;
    private String tipo;

    public Ficha(String color, String tipo, int fila, int columna) {
        this.color = color;
        this.tipo = tipo;
        this.fila = fila;
        this.columna = columna;
    }

    public void mover(int fila, int columna) {
        this.fila = fila;
        this.columna = columna;
    }

    public boolean mismoColor(Ficha otra) {
        return this.color.equals(otra.getColor());
    }

    public String getColor() {
        return color;
    }

    public String getPosicion() {
        return tipo + " " + color + " en (" + fila + "," + columna + ")";
    }
}

class Azucarita {
    private String tipo;
    private int puntos;
    private String colorOrigen;

    public Azucarita(String tipo) {
        this.tipo = tipo;
        this.puntos = 0;
        this.colorOrigen = "";
    }

    public void generar(String color, int cantidad) {
        this.colorOrigen = color;
        this.puntos = cantidad * cantidad * 10;
        System.out.println("🍬 Azucarita " + tipo + " de color " + color + " (+" + this.puntos + " puntos)");
    }

    public int getPuntos() {
        return puntos;
    }
}

class Partida {
    private String jugador;
    private int movimientos;
    private int puntos;
    private Ficha fichaSeleccionada;
    private Azucarita azucaritaCreada;

    public Partida(String jugador, int movimientos) {
        this.jugador = jugador;
        this.movimientos = movimientos;
        this.puntos = 0;
        this.fichaSeleccionada = null;
        this.azucaritaCreada = new Azucarita("Normal");
    }

    public void seleccionar(Ficha ficha) {
        this.fichaSeleccionada = ficha;
        System.out.println("👆 " + jugador + " seleccionó " + ficha.getPosicion());
    }

    public boolean mover(Ficha ficha, int fila, int columna) {
        if (this.fichaSeleccionada == null) {
            System.out.println("Primero selecciona una ficha.");
            return false;
        }
        ficha.mover(fila, columna);
        this.movimientos--;
        System.out.println("🍭 " + ficha.getPosicion() + " | jugadas restantes: " + this.movimientos);
        return true;
    }

    public void formarCombo(int cantidad) {
        if (cantidad >= 3 && this.fichaSeleccionada != null) {
            this.azucaritaCreada.generar(this.fichaSeleccionada.getColor(), cantidad);
            this.puntos += this.azucaritaCreada.getPuntos();
        } else {
            System.out.println("No hay combo: se necesitan 3 fichas del mismo color.");
        }
    }

    public int jugadasRestantes() {
        return this.movimientos;
    }

    public void mostrarEstado() {
        System.out.println(jugador + " | jugadas: " + movimientos + " | puntos: " + puntos);
    }
}

public class Main {
    public static void main(String[] args) {
        Partida partida = new Partida("Ana", 5);
        Ficha roja = new Ficha("ROJO", "Gomita", 2, 1);
        Ficha roja2 = new Ficha("ROJO", "Gomita", 2, 2);
        Ficha azul = new Ficha("AZUL", "Caramelo", 1, 3);

        partida.seleccionar(roja);
        partida.mover(roja, 2, 2);
        partida.formarCombo(roja.mismoColor(roja2) ? 3 : 1);
        partida.seleccionar(azul);
        partida.mover(azul, 3, 3);
        partida.formarCombo(1);
        partida.mostrarEstado();
    }
}

class Bala {
    private int dano;
    private int velocidad;
    private int alcance;

    public Bala(int dano, int velocidad) {
        this.dano = dano;
        this.velocidad = velocidad;
        this.alcance = 0;
    }

    public boolean recorrer(int distancia) {
        this.alcance += distancia;
        return this.alcance > 120;
    }

    public int impacto() {
        return this.dano;
    }
}

class Arma {
    private String nombre;
    private int dano;
    private int cargador;
    private int precision;

    public Arma(String nombre, int dano, int cargador, int precision) {
        this.nombre = nombre;
        this.dano = dano;
        this.cargador = cargador;
        this.precision = precision;
    }

    public boolean estaVacia() {
        return this.cargador <= 0;
    }

    public Bala disparar() {
        this.cargador--;
        return new Bala(this.dano, this.precision);
    }

    public void recargar() {
        this.cargador = 30;
        System.out.println("🔄 " + nombre + " recargada");
    }

    public String getNombre() {
        return nombre;
    }
}

class Bomba {
    private int tiempo;
    private boolean plantada;
    private String posicion;

    public Bomba(int tiempo) {
        this.tiempo = tiempo;
        this.plantada = false;
        this.posicion = "A";
    }

    public void plantar(String posicion) {
        this.plantada = true;
        this.posicion = posicion;
        System.out.println("💣 Bomba plantada en " + posicion + " con " + this.tiempo + " s");
    }

    public void pasarTiempo() {
        if (plantada && this.tiempo > 0) {
            this.tiempo--;
        }
    }

    public boolean explota() {
        return plantada && this.tiempo == 0;
    }
}

class Agente {
    private String nombre;
    private String rol;
    private int vida;
    private Arma arma;
    private int baja;
    private Bomba bomba;

    public Agente(String nombre, String rol, int vida, Arma arma) {
        this.nombre = nombre;
        this.rol = rol;
        this.vida = vida;
        this.arma = arma;
        this.baja = 0;
        this.bomba = new Bomba(5);
    }

    public void disparar(Agente objetivo) {
        if (arma.estaVacia()) {
            System.out.println(nombre + " no tiene balas en el cargador.");
            arma.recargar();
            return;
        }
        Bala bala = arma.disparar();
        bala.recorrer(60);
        int dano = bala.impacto();
        objetivo.vida -= dano;
        System.out.println("🎯 " + nombre + " dispara al " + objetivo.nombre + " y le quita " + dano + " de vida (" + objetivo.vida + " restante)");
        if (objetivo.vida <= 0) {
            this.baja++;
        }
    }

    public void plantarBomba(String posicion) {
        bomba.plantar(posicion);
    }

    public boolean estaVivo() {
        return this.vida > 0;
    }

    public void mostrarEstado() {
        System.out.println(nombre + " [" + rol + "] | vida: " + vida + " | arma: " + arma.getNombre() + " | bajas: " + baja);
    }
}

public class Main {
    public static void main(String[] args) {
        Arma ak47 = new Arma("AK-47", 25, 2, 4);
        Arma awp = new Arma("AWP", 90, 1, 2);

        Agente terrorist = new Agente("Agente Alfa", "Terrorista", 100, ak47);
        Agente ct = new Agente("Agente Bravo", "Antiterrorista", 100, awp);

        terrorist.mostrarEstado();
        terrorist.disparar(ct);
        ct.disparar(terrorist);
        ct.mostrarEstado();
        terrorist.plantarBomba("B");
        terrorist.disparar(ct);
        terrorist.mostrarEstado();
    }
}

class Cultivo {
    private String tipo;
    private int diasCrecimiento;
    private int diasRegados;
    private int precioBase;
    private boolean listo;

    public Cultivo(String tipo, int diasCrecimiento, int precioBase) {
        this.tipo = tipo;
        this.diasCrecimiento = diasCrecimiento;
        this.diasRegados = 0;
        this.precioBase = precioBase;
        this.listo = false;
    }

    public void regar() {
        if (this.listo) {
            System.out.println("El cultivo de " + tipo + " ya está listo para cosechar.");
            return;
        }
        this.diasRegados++;
        if (this.diasRegados >= this.diasCrecimiento) {
            this.listo = true;
            System.out.println("🌾 " + tipo + " ¡listo para cosechar!");
        }
    }

    public boolean estaListo() {
        return listo;
    }

    public String cosechar() {
        if (!listo) {
            return "";
        }
        this.listo = false;
        this.diasRegados = 0;
        return this.tipo;
    }

    public int getPrecioBase() {
        return precioBase;
    }
}

class Gallina {
    private String nombre;
    private int huevosPorDia;
    private boolean alimentada;

    public Gallina(String nombre, int huevosPorDia) {
        this.nombre = nombre;
        this.huevosPorDia = huevosPorDia;
        this.alimentada = false;
    }

    public void alimentar() {
        this.alimentada = true;
        System.out.println("🌽 Se alimentó a " + this.nombre);
    }

    public int recolectarHuevos() {
        if (!alimentada) {
            System.out.println(this.nombre + " no está alimentada: no da huevos.");
            return 0;
        }
        this.alimentada = false;
        return this.huevosPorDia;
    }

    public String getNombre() {
        return nombre;
    }
}

class Mercado {
    private String nombre;
    private double multiplicador;
    private int ventas;

    public Mercado(String nombre, double multiplicador) {
        this.nombre = nombre;
        this.multiplicador = multiplicador;
        this.ventas = 0;
    }

    public int vender(String producto, int precioBase) {
        this.ventas++;
        int total = (int) (precioBase * this.multiplicador);
        System.out.println("💰 " + nombre + " pagó " + total + " por " + producto);
        return total;
    }

    public String getNombre() {
        return nombre;
    }

    public int getVentas() {
        return ventas;
    }
}

class Granjero {
    private String nombre;
    private int energia;
    private int oro;
    private int huevos;
    private int nivelAgricola;
    private Mercado mercado;

    public Granjero(String nombre, int oro, Mercado mercado) {
        this.nombre = nombre;
        this.oro = oro;
        this.mercado = mercado;
        this.energia = 100;
        this.huevos = 0;
        this.nivelAgricola = 1;
    }

    public void regar(Cultivo cultivo) {
        if (energia < 5) {
            System.out.println("😴 " + nombre + " está muy cansado para regar.");
            return;
        }
        energia -= 5;
        cultivo.regar();
    }

    public void cosechar(Cultivo cultivo) {
        String producto = cultivo.cosechar();
        if (producto.isEmpty()) {
            System.out.println("El cultivo de " + "todavía no está listo.");
            return;
        }
        this.oro += this.mercado.vender(producto, cultivo.getPrecioBase() * this.nivelAgricola);
    }

    public void cuidarGallina(Gallina gallina) {
        gallina.alimentar();
        int huevos = gallina.recolectarHuevos();
        this.huevos += huevos;
        System.out.println("🥚 " + gallina.getNombre() + " dejó " + huevos + " huevos");
    }

    public void mostrarEstado() {
        System.out.println(nombre + " | energía: " + energia + " | oro: " + oro + " | huevos: " + huevos + " | mercado: " + mercado.getNombre());
    }
}

public class Main {
    public static void main(String[] args) {
        Mercado pierre = new Mercado("Tienda de Pierre", 1.25);
        Granjero granjero = new Granjero("Avery", 500, pierre);

        Cultivo papa = new Cultivo("Papa", 3, 40);
        Cultivo girasol = new Cultivo("Girasol", 2, 25);
        Gallina gallina = new Gallina("Gallina Clara", 1);

        granjero.mostrarEstado();
        granjero.regar(papa);
        granjero.regar(papa);
        granjero.cosechar(papa);
        granjero.cuidarGallina(gallina);
        granjero.cosechar(girasol);
        granjero.mostrarEstado();
    }
}

class Mueble {
    private String nombre;
    private String tipo;
    private int confort;
    private int precio;
    private int durabilidad;

    public Mueble(String nombre, String tipo, int confort, int precio) {
        this.nombre = nombre;
        this.tipo = tipo;
        this.confort = confort;
        this.precio = precio;
        this.durabilidad = 100;
    }

    public int usar() {
        if (this.durabilidad <= 0) {
            return 0;
        }
        this.durabilidad -= 10;
        return this.confort;
    }

    public boolean estaRoto() {
        return this.durabilidad <= 0;
    }

    public String getTipo() {
        return tipo;
    }

    public String getNombre() {
        return nombre;
    }
}

class Casa {
    private String direccion;
    private int dimensiones;
    private int contadorMuebles;

    public Casa(String direccion, int dimensiones) {
        this.direccion = direccion;
        this.dimensiones = dimensiones;
        this.contadorMuebles = 0;
    }

    public void agregarMueble(Mueble mueble) {
        this.contadorMuebles++;
        System.out.println("🏠 " + direccion + " ahora tiene " + this.contadorMuebles + " muebles");
    }

    public int getMuebles() {
        return contadorMuebles;
    }
}

class Mascota {
    private String nombre;
    private int hambre;
    private int felicidad;
    private String especie;

    public Mascota(String nombre, String especie) {
        this.nombre = nombre;
        this.especie = especie;
        this.hambre = 50;
        this.felicidad = 50;
    }

    public void comer(String alimento) {
        this.hambre = Math.max(0, this.hambre - 25);
        System.out.println("🥣 " + nombre + " comió " + alimento + " (hambre: " + this.hambre + ")");
    }

    public void jugar() {
        this.felicidad += 10;
        System.out.println("🎾 " + nombre + " jugó con su dueño (felicidad: " + this.felicidad + ")");
    }
}

class Sim {
    private String nombre;
    private int energia;
    private int higiene;
    private int dinero;
    private Casa casa;
    private Mascota mascota;

    public Sim(String nombre, int dinero, Casa casa, Mascota mascota) {
        this.nombre = nombre;
        this.dinero = dinero;
        this.casa = casa;
        this.mascota = mascota;
        this.energia = 60;
        this.higiene = 60;
    }

    public void comprarMueble(Mueble mueble) {
        this.dinero -= 100;
        this.casa.agregarMueble(mueble);
        System.out.println("🛒 " + nombre + " compró " + mueble.getNombre() + " por 100 §");
    }

    public void usarMueble(Mueble mueble) {
        int beneficio = mueble.usar();
        if (mueble.getTipo().equals("ENERGIA")) {
            this.energia = Math.min(100, this.energia + beneficio);
        } else {
            this.higiene = Math.min(100, this.higiene + beneficio);
        }
        System.out.println("🛋️ " + nombre + " usó " + mueble.getNombre() + " (+" + beneficio + ")");
    }

    public void cuidarMascota() {
        this.mascota.comer("croqueta");
        this.mascota.jugar();
    }

    public void mostrarEstado() {
        System.out.println(nombre + " | energía: " + energia + " | higiene: " + higiene + " | dinero: " + dinero + " | muebles: " + casa.getMuebles());
    }
}

public class Main {
    public static void main(String[] args) {
        Casa casa = new Casa("Vía Simulación 12", 60);
        Mascota perrito = new Mascota("Simba", "perro");
        Sim sim = new Sim("Bella", 1000, casa, perrito);

        sim.mostrarEstado();
        sim.usarMueble(new Mueble("Cama acogedora", "ENERGIA", 25, 300));
        sim.comprarMueble(new Mueble("Ducha nueva", "HIGIENE", 20, 200));
        sim.usarMueble(new Mueble("Ducha nueva", "HIGIENE", 20, 200));
        sim.cuidarMascota();
        sim.mostrarEstado();
    }
}

class Diana {
    private int distancia;
    private String tipo;
    private int dificultad;

    public Diana(int distancia, String tipo, int dificultad) {
        this.distancia = distancia;
        this.tipo = tipo;
        this.dificultad = dificultad;
    }

    public double getFactorDistancia() {
        if (this.distancia <= 20) {
            return 1.0;
        }
        if (this.distancia <= 50) {
            return 0.8;
        }
        return 0.6;
    }

    public String getTipo() {
        return tipo;
    }
}

class Flecha {
    private int dano;
    private int punteria;
    private boolean clavada;

    public Flecha(int dano, int punteria) {
        this.dano = dano;
        this.punteria = punteria;
        this.clavada = false;
    }

    public int clavar(Diana diana) {
        this.clavada = true;
        return (int) (this.dano * this.punteria * diana.getFactorDistancia());
    }

    public boolean estaClavada() {
        return clavada;
    }
}

class Arco {
    private String nombre;
    private int tension;
    private int peso;
    private int desgaste;

    public Arco(String nombre, int tension, int peso) {
        this.nombre = nombre;
        this.tension = tension;
        this.peso = peso;
        this.desgaste = 0;
    }

    public boolean puedeDisparar() {
        return this.desgaste < 50;
    }

    public int aplicarTension(Flecha flecha) {
        this.desgaste += this.peso / 10;
        return this.tension;
    }

    public String getNombre() {
        return nombre;
    }
}

class Arquero {
    private String nombre;
    private int vida;
    private int arquitectura;
    private Arco arco;
    private Diana ultimaDiana;
    private int flechasClavadas;

    public Arquero(String nombre, int vida, int arquitectura, Arco arco) {
        this.nombre = nombre;
        this.vida = vida;
        this.arquitectura = arquitectura;
        this.arco = arco;
        this.ultimaDiana = null;
        this.flechasClavadas = 0;
    }

    public void apuntar(Diana diana) {
        this.ultimaDiana = diana;
        System.out.println("🎯 " + nombre + " apunta a la diana " + diana.getTipo());
    }

    public void disparar(Flecha flecha) {
        if (this.ultimaDiana == null) {
            System.out.println("Primero hay que apuntar a una diana.");
            return;
        }
        if (!this.arco.puedeDisparar()) {
            System.out.println("El arco " + this.arco.getNombre() + " está demasiado gastado.");
            return;
        }
        int bonus = this.arco.aplicarTension(flecha);
        int danoTotal = flecha.clavar(this.ultimaDiana) + bonus;
        System.out.println("🏹 " + nombre + " clavó la flecha con " + danoTotal + " de daño (arco " + this.arco.getNombre() + ")");
        this.flechasClavadas++;
    }

    public int getPunteria() {
        return 10 + this.arquitectura;
    }

    public void mostrarEstado() {
        System.out.println(nombre + " | vida: " + vida + " | puntería: " + getPunteria() + " | flechas clavadas: " + flechasClavadas);
    }
}

public class Main {
    public static void main(String[] args) {
        Arco arcoLargo = new Arco("Arco Largo de Bosque", 12, 30);
        Arquero arquero = new Arquero("Eorlund", 120, 40, arcoLargo);
        Diana cercana = new Diana(15, "cercana", 10);
        Diana lejana = new Diana(80, "lejana", 40);

        arquero.mostrarEstado();
        arquero.apuntar(cercana);
        arquero.disparar(new Flecha(20, arquero.getPunteria() / 10));
        arquero.apuntar(lejana);
        arquero.disparar(new Flecha(20, 1));
        arquero.mostrarEstado();
    }
}

class Mineral {
    private String tipo;
    private int valor;
    private String rareza;
    private int energia;

    public Mineral(String tipo, int valor, String rareza, int energia) {
        this.tipo = tipo;
        this.valor = valor;
        this.rareza = rareza;
        this.energia = energia;
    }

    public int extraer(int dificultad) {
        int resultado = this.valor;
        if (this.rareza.equals("RARO")) {
            resultado = resultado * 2;
        }
        if (this.rareza.equals("LEGENDARIO")) {
            resultado = resultado * 3;
        }
        return Math.max(1, resultado - dificultad);
    }

    public String getTipo() {
        return tipo;
    }

    public int getEnergia() {
        return energia;
    }
}

class Planeta {
    private String nombre;
    private int distancia;
    private int dificultad;
    private String atmosfera;

    public Planeta(String nombre, int distancia, int dificultad, String atmosfera) {
        this.nombre = nombre;
        this.distancia = distancia;
        this.dificultad = dificultad;
        this.atmosfera = atmosfera;
    }

    public Mineral explorar() {
        System.out.println("🪐 Explorando " + this.nombre + "...");
        if (this.dificultad > 5) {
            return new Mineral("Uranio", 30, "RARO", 20);
        }
        return new Mineral("Hierro", 10, "COMUN", 8);
    }

    public boolean esPeligroso() {
        return this.atmosfera.equals("HOSTIL");
    }

    public String getNombre() {
        return nombre;
    }

    public int getDistancia() {
        return distancia;
    }

    public int getDificultad() {
        return dificultad;
    }
}

class Nave {
    private String modelo;
    private int combustible;
    private int velocidad;
    private int capacidadTanque;

    public Nave(String modelo, int capacidadTanque, int velocidad) {
        this.modelo = modelo;
        this.capacidadTanque = capacidadTanque;
        this.combustible = capacidadTanque;
        this.velocidad = velocidad;
    }

    public void viajar(Planeta planeta) {
        int costo = planeta.getDistancia() / 10;
        if (costo > this.combustible) {
            System.out.println("⛽ No hay combustible suficiente para llegar a " + planeta.getNombre());
            return;
        }
        this.combustible -= costo;
        System.out.println("🚀 " + this.modelo + " viaja a " + planeta.getNombre() + " (combustible: " + this.combustible + ")");
    }

    public void recargar(Mineral menaje) {
        int limite = this.capacidadTanque - this.combustible;
        int carga = Math.min(limite, menaje.getEnergia());
        this.combustible += carga;
        System.out.println("⛽ Se recargó con " + menaje.getTipo() + ": +" + carga + " de combustible");
    }

    public int getCombustible() {
        return combustible;
    }
}

class Astronauta {
    private String nombre;
    private int vida;
    private Nave nave;
    private int oro;
    private int mineralesRecolectados;
    private Planeta destino;

    public Astronauta(String nombre, int vida, Nave nave) {
        this.nombre = nombre;
        this.vida = vida;
        this.nave = nave;
        this.oro = 0;
        this.mineralesRecolectados = 0;
        this.destino = null;
    }

    public boolean viajar(Planeta planeta) {
        int costo = planeta.getDistancia() / 10;
        if (costo > this.nave.getCombustible()) {
            return false;
        }
        this.nave.viajar(planeta);
        this.destino = planeta;
        return true;
    }

    public void explorar(Planeta planeta) {
        Mineral mineral = planeta.explorar();
        int valor = mineral.extraer(planeta.getDificultad());
        this.oro += valor;
        this.mineralesRecolectados++;
        if (planeta.esPeligroso()) {
            this.vida -= 10;
        }
        System.out.println("⛏️ " + this.nombre + " extrajo " + mineral.getTipo() + " por " + valor + " de oro");
    }

    public void recargarNave() {
        Mineral auxiliar = new Mineral("Batería de protones", 5, "COMUN", 25);
        this.nave.recargar(auxiliar);
    }

    public void mostrarEstado() {
        String lugar = this.destino == null ? "en órbita" : this.destino.getNombre();
        System.out.println(nombre + " | " + lugar + " | vida: " + vida + " | oro: " + oro + " | minerales: " + mineralesRecolectados + " | combustible: " + this.nave.getCombustible());
    }
}

public class Main {
    public static void main(String[] args) {
        Nave nave = new Nave("Explorador MK-II", 100, 60);
        Astronauta astronauta = new Astronauta("Riley", 90, nave);
        Planeta viridia = new Planeta("Viridia", 30, 3, "AMIGABLE");
        Planeta arkon = new Planeta("Arkon", 90, 7, "HOSTIL");

        astronauta.mostrarEstado();
        astronauta.viajar(viridia);
        astronauta.explorar(viridia);
        astronauta.recargarNave();
        astronauta.viajar(arkon);
        astronauta.explorar(arkon);
        astronauta.mostrarEstado();
    }
}

import java.util.ArrayList;
import java.util.List;

class Espada {
    private String nombre;
    private int danioBase;
    private double probCritico;

    public Espada(String nombre, int danioBase, double probCritico) {
        this.nombre = nombre;
        this.danioBase = danioBase;
        this.probCritico = probCritico;
    }

    public int calcularDanio() {
        boolean esCritico = Math.random() < probCritico;
        int danioFinal = esCritico ? danioBase * 2 : danioBase;
        if (esCritico) System.out.println("  💥 ¡Golpe Crítico con " + nombre + "!");
        return danioFinal;
    }

    public String getNombre() { return nombre; }
}

class Escudo {
    private String nombre;
    private int defensa;
    private int durabilidad;

    public Escudo(String nombre, int defensa, int durabilidad) {
        this.nombre = nombre;
        this.defensa = defensa;
        this.durabilidad = durabilidad;
    }

    public int mitigarDanio(int danio) {
        if (durabilidad <= 0) return danio;
        int danioMitigado = Math.max(0, danio - defensa);
        durabilidad--;
        System.out.println("  🛡️ " + nombre + " absorbió " + (danio - danioMitigado) + " pts de daño. (Durabilidad restante: " + durabilidad + ")");
        return danioMitigado;
    }
}

class Pocion {
    private String nombre;
    private int puntosCuracion;
    private boolean usada;

    public Pocion(String nombre, int puntosCuracion) {
        this.nombre = nombre;
        this.puntosCuracion = puntosCuracion;
        this.usada = false;
    }

    public int aplicar(Luchador objetivo) {
        if (usada) return 0;
        this.usada = true;
        return puntosCuracion;
    }

    public boolean isUsada() { return usada; }
    public String getNombre() { return nombre; }
}

class Luchador {
    private String nombre;
    private int vida;
    private int energia;
    private Espada arma;
    private Escudo escudo;
    private List<Pocion> pociones;

    public Luchador(String nombre, int vida, int energia, Espada arma, Escudo escudo) {
        this.nombre = nombre;
        this.vida = vida;
        this.energia = energia;
        this.arma = arma;
        this.escudo = escudo;
        this.pociones = new ArrayList<>();
    }

    public void agregarPocion(Pocion p) {
        this.pociones.add(p);
    }

    public void atacar(Luchador rival) {
        System.out.println("⚔️ " + nombre + " ataca a " + rival.getNombre() + " con " + arma.getNombre() + "!");
        int danio = arma.calcularDanio();
        rival.recibirDanio(danio);
    }

    public void recibirDanio(int danioEntrante) {
        int danioFinal = escudo != null ? escudo.mitigarDanio(danioEntrante) : danioEntrante;
        this.vida = Math.max(0, this.vida - danioFinal);
        System.out.println("  💔 " + nombre + " recibe " + danioFinal + " de daño. Vida restante: " + this.vida + " HP.");
    }

    public void usarPocion(int indice) {
        if (indice >= 0 && indice < pociones.size()) {
            Pocion p = pociones.get(indice);
            if (!p.isUsada()) {
                int curacion = p.aplicar(this);
                this.vida += curacion;
                System.out.println("🧪 " + nombre + " usó " + p.getNombre() + " y recuperó " + curacion + " HP. Vida actual: " + this.vida);
            }
        }
    }

    public boolean estaVivo() { return this.vida > 0; }
    public String getNombre() { return nombre; }
    public int getVida() { return vida; }
}

public class Main {
    public static void main(String[] args) {
        Espada espadaExcalibur = new Espada("Excalibur", 25, 0.35);
        Escudo escudoTorre = new Escudo("Escudo de Roble", 10, 3);
        Luchador lancelot = new Luchador("Sir Lancelot", 100, 50, espadaExcalibur, escudoTorre);
        lancelot.agregarPocion(new Pocion("Elixir Mayor", 30));

        Espada hachaGuerra = new Espada("Filo Oscuro", 22, 0.20);
        Escudo broquelHierro = new Escudo("Broquel de Hierro", 8, 4);
        Luchador mordred = new Luchador("Mordred", 95, 40, hachaGuerra, broquelHierro);

        System.out.println("=== 🔔 INICIO DEL DUELO POR TURNOS ===");
        // Turno 1
        lancelot.atacar(mordred);
        // Turno 2
        mordred.atacar(lancelot);
        // Turno 3 - Curación
        lancelot.usarPocion(0);
    }
}

import java.util.ArrayList;
import java.util.List;

class Movimiento {
    private String nombre;
    private String tipoElemento;
    private int potencia;
    private int ppActuales;

    public Movimiento(String nombre, String tipoElemento, int potencia, int ppMax) {
        this.nombre = nombre;
        this.tipoElemento = tipoElemento;
        this.potencia = potencia;
        this.ppActuales = ppMax;
    }

    public boolean consumirPP() {
        if (ppActuales > 0) {
            ppActuales--;
            return true;
        }
        return false;
    }

    public String getNombre() { return nombre; }
    public int getPotencia() { return potencia; }
    public int getPpActuales() { return ppActuales; }
}

class ItemCura {
    private String nombre;
    private int puntosRestaurados;
    private int cantidad;

    public ItemCura(String nombre, int puntosRestaurados, int cantidad) {
        this.nombre = nombre;
        this.puntosRestaurados = puntosRestaurados;
        this.cantidad = cantidad;
    }

    public int consumir() {
        if (cantidad > 0) {
            cantidad--;
            return puntosRestaurados;
        }
        return 0;
    }

    public String getNombre() { return nombre; }
    public int getCantidad() { return cantidad; }
}

class Pokemon {
    private String especie;
    private String tipo;
    private int hpMax;
    private int hpActual;
    private List<Movimiento> movimientos;

    public Pokemon(String especie, String tipo, int hpMax) {
        this.especie = especie;
        this.tipo = tipo;
        this.hpMax = hpMax;
        this.hpActual = hpMax;
        this.movimientos = new ArrayList<>();
    }

    public void aprenderMovimiento(Movimiento m) {
        if (movimientos.size() < 4) movimientos.add(m);
    }

    public Movimiento ejecutarMovimiento(int slot) {
        if (slot >= 0 && slot < movimientos.size()) {
            Movimiento m = movimientos.get(slot);
            if (m.consumirPP()) return m;
        }
        return null;
    }

    public void recibirDanio(int danio) {
        this.hpActual = Math.max(0, this.hpActual - danio);
        System.out.println("  💥 " + especie + " recibió " + danio + " de daño. (PS: " + hpActual + "/" + hpMax + ")");
    }

    public void curar(int hp) {
        this.hpActual = Math.min(hpMax, this.hpActual + hp);
        System.out.println("  ✨ " + especie + " recuperó salud. (PS: " + hpActual + "/" + hpMax + ")");
    }

    public boolean estaDebilitado() { return hpActual <= 0; }
    public String getEspecie() { return especie; }
    public int getHpActual() { return hpActual; }
}

class Entrenador {
    private String nombre;
    private Pokemon pokemonActivo;
    private List<ItemCura> mochila;

    public Entrenador(String nombre, Pokemon pokemonActivo) {
        this.nombre = nombre;
        this.pokemonActivo = pokemonActivo;
        this.mochila = new ArrayList<>();
    }

    public void agregarItem(ItemCura item) { mochila.add(item); }

    public void ordenarAtaque(Entrenador rival, int slot) {
        System.out.println("📢 " + nombre + ": ¡" + pokemonActivo.getEspecie() + ", adelante!");
        Movimiento mov = pokemonActivo.ejecutarMovimiento(slot);
        if (mov != null) {
            System.out.println("  🔥 Usó " + mov.getNombre() + " (Potencia: " + mov.getPotencia() + ")!");
            rival.getPokemonActivo().recibirDanio(mov.getPotencia());
        } else {
            System.out.println("  ❌ No quedan PP para ese movimiento.");
        }
    }

    public void usarItemMochila(int indiceItem) {
        if (indiceItem >= 0 && indiceItem < mochila.size()) {
            ItemCura item = mochila.get(indiceItem);
            int curacion = item.consumir();
            if (curacion > 0) {
                System.out.println("🎒 " + nombre + " usó " + item.getNombre() + " en " + pokemonActivo.getEspecie() + "!");
                pokemonActivo.curar(curacion);
            }
        }
    }

    public boolean tienePokemonVivo() { return !pokemonActivo.estaDebilitado(); }
    public Pokemon getPokemonActivo() { return pokemonActivo; }
    public String getNombre() { return nombre; }
}

public class Main {
    public static void main(String[] args) {
        Pokemon pikachu = new Pokemon("Pikachu", "Eléctrico", 90);
        pikachu.aprenderMovimiento(new Movimiento("Impactrueno", "Eléctrico", 35, 15));
        pikachu.aprenderMovimiento(new Movimiento("Ataque Rápido", "Normal", 25, 20));

        Pokemon charizard = new Pokemon("Charizard", "Fuego", 120);
        charizard.aprenderMovimiento(new Movimiento("Lanzallamas", "Fuego", 40, 10));

        Entrenador ash = new Entrenador("Ash Ketchum", pikachu);
        ash.agregarItem(new ItemCura("Superpocion", 50, 2));

        Entrenador red = new Entrenador("Red", charizard);

        // Turnos
        ash.ordenarAtaque(red, 0);
        red.ordenarAtaque(ash, 0);
        ash.usarItemMochila(0);
    }
}

import java.util.ArrayList;
import java.util.List;

class CartaMonstruo {
    private String nombre;
    private int estrellas;
    private int ataqueATK;
    private int defensaDEF;
    private boolean modoAtaque;

    public CartaMonstruo(String nombre, int estrellas, int ataqueATK, int defensaDEF) {
        this.nombre = nombre;
        this.estrellas = estrellas;
        this.ataqueATK = ataqueATK;
        this.defensaDEF = defensaDEF;
        this.modoAtaque = true;
    }

    public void potenciarATK(int bonus) {
        this.ataqueATK += bonus;
        System.out.println("  ✨ " + nombre + " aumentó su ATK a " + ataqueATK + "!");
    }

    public String getNombre() { return nombre; }
    public int getAtaqueATK() { return ataqueATK; }
    public int getDefensaDEF() { return defensaDEF; }
}

class CartaMagica {
    private String nombre;
    private int bonusATK;
    private boolean fueUsada;

    public CartaMagica(String nombre, int bonusATK) {
        this.nombre = nombre;
        this.bonusATK = bonusATK;
        this.fueUsada = false;
    }

    public void aplicarEfecto(CartaMonstruo objetivo) {
        if (!fueUsada && objetivo != null) {
            System.out.println("🎴 ¡Activando Carta Mágica: " + nombre + "!");
            objetivo.potenciarATK(bonusATK);
            this.fueUsada = true;
        }
    }
}

class Duelista {
    private String nombre;
    private int puntosVidaLP;
    private CartaMonstruo monstruoCampo;
    private CartaMagica magicaActiva;
    private List<CartaMonstruo> cementerio;

    public Duelista(String nombre, int puntosVidaLP) {
        this.nombre = nombre;
        this.puntosVidaLP = puntosVidaLP;
        this.cementerio = new ArrayList<>();
    }

    public void invocarMonstruo(CartaMonstruo m) {
        this.monstruoCampo = m;
        System.out.println("🎴 " + nombre + " invoca a " + m.getNombre() + " (ATK: " + m.getAtaqueATK() + "/DEF: " + m.getDefensaDEF() + ")!");
    }

    public void activarMagia(CartaMagica magia) {
        this.magicaActiva = magia;
        if (monstruoCampo != null) magia.aplicarEfecto(monstruoCampo);
    }

    public void declararAtaque(Duelista rival) {
        if (this.monstruoCampo == null) return;
        System.out.println("⚔️ " + nombre + " declara ataque con " + monstruoCampo.getNombre() + "!");

        CartaMonstruo rivalMonstruo = rival.getMonstruoCampo();
        if (rivalMonstruo != null) {
            int diff = this.monstruoCampo.getAtaqueATK() - rivalMonstruo.getAtaqueATK();
            if (diff > 0) {
                System.out.println("  💥 " + rivalMonstruo.getNombre() + " es destruido!");
                rival.enviarAlCementerio(rivalMonstruo);
                rival.reducirLP(diff);
            } else if (diff < 0) {
                System.out.println("  💥 El ataque falló y " + monstruoCampo.getNombre() + " fue destruido!");
                this.enviarAlCementerio(this.monstruoCampo);
                this.reducirLP(-diff);
            } else {
                System.out.println("  💥 ¡Ambos monstruos se destruyen mutuamente!");
                this.enviarAlCementerio(this.monstruoCampo);
                rival.enviarAlCementerio(rivalMonstruo);
            }
        }
    }

    public void enviarAlCementerio(CartaMonstruo m) {
        cementerio.add(m);
        if (monstruoCampo == m) monstruoCampo = null;
    }

    public void reducirLP(int danio) {
        this.puntosVidaLP = Math.max(0, this.puntosVidaLP - danio);
        System.out.println("  💔 " + nombre + " pierde " + danio + " LP. (LP restantes: " + puntosVidaLP + ")");
    }

    public boolean estaDerrotado() { return puntosVidaLP <= 0; }
    public CartaMonstruo getMonstruoCampo() { return monstruoCampo; }
    public String getNombre() { return nombre; }
}

public class Main {
    public static void main(String[] args) {
        Duelista yugi = new Duelista("Yugi Muto", 4000);
        Duelista kaiba = new Duelista("Seto Kaiba", 4000);

        yugi.invocarMonstruo(new CartaMonstruo("Mago Oscuro", 7, 2500, 2100));
        kaiba.invocarMonstruo(new CartaMonstruo("Dragón Blanco de Ojos Azules", 8, 3000, 2500));

        // Yugi potencia a su monstruo con magia
        yugi.activarMagia(new CartaMagica("Libro de Magia Secreta", 700));

        // Yugi ataca a Kaiba
        yugi.declararAtaque(kaiba);
    }
}

import java.util.ArrayList;
import java.util.List;

class EspadaDiamante {
    private int nivelFilo;
    private double danioBase;

    public EspadaDiamante(int nivelFilo, double danioBase) {
        this.nivelFilo = nivelFilo;
        this.danioBase = danioBase;
    }

    public double calcularGolpe() {
        boolean critico = Math.random() < 0.30;
        double danio = danioBase + (nivelFilo * 1.25);
        if (critico) {
            danio *= 1.5;
            System.out.println("  💥 ¡Golpe Crítico con salto de espada!");
        }
        return danio;
    }
}

class ArmaduraPechera {
    private int proteccionPuntos;
    private int durabilidad;

    public ArmaduraPechera(int proteccionPuntos, int durabilidad) {
        this.proteccionPuntos = proteccionPuntos;
        this.durabilidad = durabilidad;
    }

    public double mitigarDanio(double danio) {
        if (durabilidad <= 0) return danio;
        double reduccion = proteccionPuntos * 0.4;
        durabilidad -= 2;
        return Math.max(1.0, danio - reduccion);
    }
}

class ManzanaDorada {
    private double corazonesRegeneracion;
    private boolean esEncantada;
    private boolean consumida;

    public ManzanaDorada(double corazones, boolean encantada) {
        this.corazonesRegeneracion = corazones;
        this.esEncantada = encantada;
        this.consumida = false;
    }

    public double consumir() {
        if (!consumida) {
            consumida = true;
            return corazonesRegeneracion;
        }
        return 0;
    }
}

class JugadorSteve {
    private String apodo;
    private double corazonesVida;
    private EspadaDiamante armaPrincipal;
    private ArmaduraPechera pechera;
    private List<ManzanaDorada> inventarioManzanas;

    public JugadorSteve(String apodo, double corazones, EspadaDiamante arma, ArmaduraPechera pechera) {
        this.apodo = apodo;
        this.corazonesVida = corazones;
        this.armaPrincipal = arma;
        this.pechera = pechera;
        this.inventarioManzanas = new ArrayList<>();
    }

    public void agregarManzana(ManzanaDorada m) { inventarioManzanas.add(m); }

    public void golpear(JugadorSteve enemigo) {
        System.out.println("🗡️ " + apodo + " ataca a " + enemigo.getApodo() + "!");
        double danio = armaPrincipal.calcularGolpe();
        enemigo.recibirImpacto(danio);
    }

    public void recibirImpacto(double danioFisico) {
        double danioFinal = pechera != null ? pechera.mitigarDanio(danioFisico) : danioFisico;
        this.corazonesVida = Math.max(0.0, this.corazonesVida - danioFinal);
        System.out.printf("  💔 %s recibió %.1f de daño. Corazones: %.1f/20.0\n", apodo, danioFinal, corazonesVida);
    }

    public void comerManzana(int indice) {
        if (indice >= 0 && indice < inventarioManzanas.size()) {
            double curado = inventarioManzanas.get(indice).consumir();
            if (curado > 0) {
                this.corazonesVida = Math.min(20.0, this.corazonesVida + curado);
                System.out.printf("🍎 %s comió Manzana Dorada y regeneró %.1f corazones! (Total: %.1f)\n", apodo, curado, corazonesVida);
            }
        }
    }

    public boolean estaMuerto() { return corazonesVida <= 0; }
    public String getApodo() { return apodo; }
}

public class Main {
    public static void main(String[] args) {
        EspadaDiamante espada1 = new EspadaDiamante(5, 7.0);
        ArmaduraPechera pechera1 = new ArmaduraPechera(8, 100);
        JugadorSteve steve = new JugadorSteve("Steve_Pro", 20.0, espada1, pechera1);
        steve.agregarManzana(new ManzanaDorada(6.0, true));

        EspadaDiamante espada2 = new EspadaDiamante(4, 7.0);
        ArmaduraPechera pechera2 = new ArmaduraPechera(6, 80);
        JugadorSteve alex = new JugadorSteve("Alex_Gamer", 20.0, espada2, pechera2);

        steve.golpear(alex);
        alex.golpear(steve);
        alex.golpear(steve);
        steve.comerManzana(0);
    }
}

import java.util.ArrayList;
import java.util.List;

class EscopetaPump {
    private String rareza;
    private int danioPorPerdigon;
    private int perdigonesPorTiro;

    public EscopetaPump(String rareza, int danioPorPerdigon, int perdigones) {
        this.rareza = rareza;
        this.danioPorPerdigon = danioPorPerdigon;
        this.perdigonesPorTiro = perdigones;
    }

    public int calcularDisparo() {
        int impactados = (int) (Math.random() * 4) + 6; // 6 a 10 perdigones
        int total = impactados * danioPorPerdigon;
        System.out.println("  💥 Pump " + rareza + " impactó " + impactados + "/" + perdigonesPorTiro + " perdigones (" + total + " dmg)!");
        return total;
    }
}

class MuroConstruccion {
    private String material;
    private int saludMuro;

    public MuroConstruccion(String material, int saludInicial) {
        this.material = material;
        this.saludMuro = saludInicial;
    }

    public int absorberDanio(int danio) {
        if (saludMuro <= 0) return danio;
        if (danio >= saludMuro) {
            int sobrante = danio - saludMuro;
            System.out.println("  🧱 ¡El muro de " + material + " fue destruido!");
            saludMuro = 0;
            return sobrante;
        } else {
            saludMuro -= danio;
            System.out.println("  🧱 El muro de " + material + " bloqueó todo el daño (Salud muro restante: " + saludMuro + ")");
            return 0;
        }
    }

    public boolean isEnPie() { return saludMuro > 0; }
}

class MiniEscudo {
    private int valorEscudo;
    private boolean consumido;

    public MiniEscudo(int valorEscudo) {
        this.valorEscudo = valorEscudo;
        this.consumido = false;
    }

    public int aplicar(int escudoActual) {
        if (!consumido && escudoActual < 50) {
            consumido = true;
            return Math.min(valorEscudo, 50 - escudoActual);
        }
        return 0;
    }
}

class JugadorBR {
    private String gamerTag;
    private int salud;
    private int escudo;
    private EscopetaPump arma;
    private MuroConstruccion muroActivo;
    private List<MiniEscudo> inventarioMinis;

    public JugadorBR(String gamerTag, EscopetaPump arma) {
        this.gamerTag = gamerTag;
        this.salud = 100;
        this.escudo = 50;
        this.arma = arma;
        this.inventarioMinis = new ArrayList<>();
    }

    public void agregarMini(MiniEscudo mini) { inventarioMinis.add(mini); }

    public void construirMuro(String material) {
        this.muroActivo = new MuroConstruccion(material, 150);
        System.out.println("🏗️ " + gamerTag + " levantó una pared de " + material + "!");
    }

    public void dispararEscopeta(JugadorBR rival) {
        System.out.println("🎯 " + gamerTag + " dispara su Pump contra " + rival.getGamerTag() + "!");
        int danio = arma.calcularDisparo();
        rival.recibirImpacto(danio);
    }

    public void recibirImpacto(int danio) {
        int danioRestante = (muroActivo != null && muroActivo.isEnPie()) ? muroActivo.absorberDanio(danio) : danio;
        if (danioRestante > 0) {
            if (escudo > 0) {
                int absorbidoEscudo = Math.min(escudo, danioRestante);
                escudo -= absorbidoEscudo;
                danioRestante -= absorbidoEscudo;
            }
            salud = Math.max(0, salud - danioRestante);
            System.out.println("  💔 " + gamerTag + " -> Salud: " + salud + " | Escudo: " + escudo);
        }
    }

    public void beberMini(int indice) {
        if (indice >= 0 && indice < inventarioMinis.size()) {
            int recargado = inventarioMinis.get(indice).aplicar(escudo);
            if (recargado > 0) {
                escudo += recargado;
                System.out.println("🧪 " + gamerTag + " bebió un Mini (+ " + recargado + " escudo). Escudo total: " + escudo);
            }
        }
    }

    public String getGamerTag() { return gamerTag; }
}

public class Main {
    public static void main(String[] args) {
        EscopetaPump pumpDorada = new EscopetaPump("Legendaria", 11, 10);
        JugadorBR ninja = new JugadorBR("Ninja", pumpDorada);
        ninja.agregarMini(new MiniEscudo(25));

        EscopetaPump pumpAzul = new EscopetaPump("Rara", 9, 10);
        JugadorBR tfue = new JugadorBR("Tfue", pumpAzul);

        ninja.dispararEscopeta(tfue);
        tfue.construirMuro("Madera");
        ninja.dispararEscopeta(tfue);
        tfue.beberMini(0);
    }
}

class UltraEspada {
    private String nombre;
    private int danioFisico;
    private int costoEstamina;

    public UltraEspada(String nombre, int danio, int costoEstamina) {
        this.nombre = nombre;
        this.danioFisico = danio;
        this.costoEstamina = costoEstamina;
    }

    public int calcularGolpe() { return danioFisico; }
    public int getCostoEstamina() { return costoEstamina; }
    public String getNombre() { return nombre; }
}

class FrascoEstus {
    private int nivelRefuerzo;
    private int curacionBase;
    private int usosRestantes;

    public FrascoEstus(int refuerzo, int curacion, int usos) {
        this.nivelRefuerzo = refuerzo;
        this.curacionBase = curacion + (refuerzo * 25);
        this.usosRestantes = usos;
    }

    public int beber() {
        if (usosRestantes > 0) {
            usosRestantes--;
            return curacionBase;
        }
        return 0;
    }

    public int getUsosRestantes() { return usosRestantes; }
}

class TalismanProteccion {
    private double reduccionDanioPorcentaje;

    public TalismanProteccion(double reduccion) {
        this.reduccionDanioPorcentaje = reduccion;
    }

    public int filtrarDanio(int danio) {
        return (int) (danio * (1.0 - reduccionDanioPorcentaje));
    }
}

class CaballeroSinLuz {
    private String nombre;
    private int puntosVidaPS;
    private int estamina;
    private UltraEspada armaPesada;
    private FrascoEstus frasco;
    private TalismanProteccion talisman;

    public CaballeroSinLuz(String nombre, int ps, int estamina, UltraEspada arma, FrascoEstus frasco, TalismanProteccion talisman) {
        this.nombre = nombre;
        this.puntosVidaPS = ps;
        this.estamina = estamina;
        this.armaPesada = arma;
        this.frasco = frasco;
        this.talisman = talisman;
    }

    public void ejecutarTajo(CaballeroSinLuz rival) {
        if (estamina >= armaPesada.getCostoEstamina()) {
            estamina -= armaPesada.getCostoEstamina();
            System.out.println("⚔️ " + nombre + " descarga un tajo colosal con " + armaPesada.getNombre() + "! (Estamina: " + estamina + ")");
            rival.recibirGolpe(armaPesada.calcularGolpe());
        } else {
            System.out.println("⚠️ " + nombre + " no tiene suficiente estamina para blandir su arma!");
        }
    }

    public void beberEstus() {
        int curado = frasco.beber();
        if (curado > 0) {
            puntosVidaPS += curado;
            System.out.println("🔥 " + nombre + " bebió Frasco de Estus (+ " + curado + " PS). Salud actual: " + puntosVidaPS + " (Estus: " + frasco.getUsosRestantes() + ")");
        }
    }

    public void recibirGolpe(int danio) {
        int danioFinal = talisman != null ? talisman.filtrarDanio(danio) : danio;
        puntosVidaPS = Math.max(0, puntosVidaPS - danioFinal);
        System.out.println("  💔 " + nombre + " sufre " + danioFinal + " de daño. PS restantes: " + puntosVidaPS);
    }

    public void regenerarEstamina() {
        estamina += 30;
        System.out.println("💨 " + nombre + " recuperó el aliento (+30 estamina).");
    }

    public String getNombre() { return nombre; }
}

public class Main {
    public static void main(String[] args) {
        UltraEspada espadonGuts = new UltraEspada("Espadón de Ceniza", 48, 35);
        FrascoEstus estus = new FrascoEstus(2, 60, 3);
        TalismanProteccion talismanDragon = new TalismanProteccion(0.15);

        CaballeroSinLuz heroe = new CaballeroSinLuz("Latente de Lothric", 160, 70, espadonGuts, estus, talismanDragon);
        CaballeroSinLuz boss = new CaballeroSinLuz("Caballero Negro", 180, 60, new UltraEspada("Hacha de Caballero", 42, 30), new FrascoEstus(0, 0, 0), null);

        heroe.ejecutarTajo(boss);
        boss.ejecutarTajo(heroe);
        heroe.beberEstus();
    }
}

import java.util.ArrayList;
import java.util.List;

class ObjetoMitico {
    private String nombre;
    private int ataqueAD;
    private int poderHabilidadAP;

    public ObjetoMitico(String nombre, int ad, int ap) {
        this.nombre = nombre;
        this.ataqueAD = ad;
        this.poderHabilidadAP = ap;
    }

    public int getAtaqueAD() { return ataqueAD; }
    public int getPoderHabilidadAP() { return poderHabilidadAP; }
}

class HabilidadQ {
    private String nombreHabilidad;
    private int danioBase;
    private int costoMana;
    private double escaladoAP;

    public HabilidadQ(String nombre, int danioBase, int costoMana, double escaladoAP) {
        this.nombreHabilidad = nombre;
        this.danioBase = danioBase;
        this.costoMana = costoMana;
        this.escaladoAP = escaladoAP;
    }

    public int calcularDanioTotal(int apCampeon) {
        return danioBase + (int) (apCampeon * escaladoAP);
    }

    public int getCostoMana() { return costoMana; }
    public String getNombreHabilidad() { return nombreHabilidad; }
}

class PocionCorrupta {
    private int cargas;
    private int curaSalud;
    private int curaMana;

    public PocionCorrupta(int cargas, int curaSalud, int curaMana) {
        this.cargas = cargas;
        this.curaSalud = curaSalud;
        this.curaMana = curaMana;
    }

    public boolean usarCarga() {
        if (cargas > 0) {
            cargas--;
            return true;
        }
        return false;
    }

    public int getCuraSalud() { return curaSalud; }
    public int getCuraMana() { return curaMana; }
}

class Campeon {
    private String nombreCampeon;
    private int saludHP;
    private int manaMP;
    private ObjetoMitico itemMitico;
    private HabilidadQ habilidadQ;
    private List<PocionCorrupta> pociones;

    public Campeon(String nombre, int hp, int mp, ObjetoMitico item, HabilidadQ q) {
        this.nombreCampeon = nombre;
        this.saludHP = hp;
        this.manaMP = mp;
        this.itemMitico = item;
        this.habilidadQ = q;
        this.pociones = new ArrayList<>();
    }

    public void agregarPocion(PocionCorrupta p) { pociones.add(p); }

    public void lanzarHabilidadQ(Campeon rival) {
        if (manaMP >= habilidadQ.getCostoMana()) {
            manaMP -= habilidadQ.getCostoMana();
            int apTotal = itemMitico != null ? itemMitico.getPoderHabilidadAP() : 0;
            int danio = habilidadQ.calcularDanioTotal(apTotal);
            System.out.println("✨ " + nombreCampeon + " lanza [" + habilidadQ.getNombreHabilidad() + "]!");
            rival.recibirDanio(danio);
        } else {
            System.out.println("⚠️ " + nombreCampeon + " no tiene suficiente maná!");
        }
    }

    public void autoAtaque(Campeon rival) {
        int ad = 40 + (itemMitico != null ? itemMitico.getAtaqueAD() : 0);
        System.out.println("🗡️ " + nombreCampeon + " conecta un básico a " + rival.getNombreCampeon() + "!");
        rival.recibirDanio(ad);
    }

    public void recibirDanio(int danio) {
        this.saludHP = Math.max(0, this.saludHP - danio);
        System.out.println("  💥 " + nombreCampeon + " recibió " + danio + " dmg. (HP: " + saludHP + ")");
    }

    public void consumirPocion(int indice) {
        if (indice >= 0 && indice < pociones.size()) {
            PocionCorrupta pot = pociones.get(indice);
            if (pot.usarCarga()) {
                saludHP += pot.getCuraSalud();
                manaMP += pot.getCuraMana();
                System.out.println("🧪 " + nombreCampeon + " consumió poción corrupta (+HP/+MP).");
            }
        }
    }

    public String getNombreCampeon() { return nombreCampeon; }
}

public class Main {
    public static void main(String[] args) {
        ObjetoMitico ecoLuden = new ObjetoMitico("Eco de Luden", 0, 80);
        HabilidadQ orbeEngano = new HabilidadQ("Orbe del Engaño", 55, 40, 0.70);
        Campeon ahri = new Campeon("Ahri", 280, 200, ecoLuden, orbeEngano);
        ahri.agregarPocion(new PocionCorrupta(3, 40, 30));

        ObjetoMitico tempestadLuden = new ObjetoMitico("Tempestad de Luden", 0, 70);
        HabilidadQ desintegrar = new HabilidadQ("Desintegrar", 50, 35, 0.65);
        Campeon annie = new Campeon("Annie", 270, 190, tempestadLuden, desintegrar);

        ahri.lanzarHabilidadQ(annie);
        annie.lanzarHabilidadQ(ahri);
        ahri.consumirPocion(0);
    }
}

class TecnicaKi {
    private String nombreTecnica;
    private int costoKi;
    private int potenciaBase;

    public TecnicaKi(String nombre, int costoKi, int potencia) {
        this.nombreTecnica = nombre;
        this.costoKi = costoKi;
        this.potenciaBase = potencia;
    }

    public int calcularDanio(double multiplicadorAura) {
        return (int) (potenciaBase * multiplicadorAura);
    }

    public int getCostoKi() { return costoKi; }
    public String getNombreTecnica() { return nombreTecnica; }
}

class SemillaErmitano {
    private boolean disponible = true;

    public boolean consumir() {
        if (disponible) {
            disponible = false;
            return true;
        }
        return false;
    }
}

class AuraTransformacion {
    private String nombreFase;
    private double multiplicador;
    private boolean activa = false;

    public AuraTransformacion(String fase, double mult) {
        this.nombreFase = fase;
        this.multiplicador = mult;
    }

    public void activar() {
        this.activa = true;
        System.out.println("⚡ ¡Despertó la transformación " + nombreFase + "!");
    }

    public double getMultiplicador() { return activa ? multiplicador : 1.0; }
}

class GuerreroZ {
    private String nombre;
    private int vidaHp;
    private int kiActual;
    private TecnicaKi tecnica;
    private SemillaErmitano semilla;
    private AuraTransformacion aura;

    public GuerreroZ(String nombre, int hp, TecnicaKi tecnica, AuraTransformacion aura) {
        this.nombre = nombre;
        this.vidaHp = hp;
        this.kiActual = 50;
        this.tecnica = tecnica;
        this.semilla = new SemillaErmitano();
        this.aura = aura;
    }

    public void cargarKi() {
        kiActual += 35;
        System.out.println("💥 " + nombre + " concentra su Ki (+35 Ki). Total Ki: " + kiActual);
        if (kiActual >= 80 && aura != null) aura.activar();
    }

    public void lanzarTecnicaEspecial(GuerreroZ rival) {
        if (kiActual >= tecnica.getCostoKi()) {
            kiActual -= tecnica.getCostoKi();
            int danio = tecnica.calcularDanio(aura != null ? aura.getMultiplicador() : 1.0);
            System.out.println("🔥 ¡" + nombre + " grita: " + tecnica.getNombreTecnica() + "!");
            rival.recibirGolpeKi(danio);
        } else {
            System.out.println("⚠️ " + nombre + " no tiene suficiente Ki!");
        }
    }

    public void comerSemilla() {
        if (semilla.consumir()) {
            this.vidaHp = 200;
            this.kiActual = 100;
            System.out.println("🌱 " + nombre + " comió una Semilla del Ermitaño! (Salud y Ki al 100%)");
        }
    }

    public void recibirGolpeKi(int danio) {
        this.vidaHp = Math.max(0, this.vidaHp - danio);
        System.out.println("  💥 " + nombre + " recibió el impacto (-" + danio + " HP). Salud restante: " + vidaHp);
    }

    public String getNombre() { return nombre; }
}

public class Main {
    public static void main(String[] args) {
        GuerreroZ goku = new GuerreroZ("Goku", 180, new TecnicaKi("KAMEHAMEHA", 45, 60), new AuraTransformacion("Super Saiyajin", 1.5));
        GuerreroZ vegeta = new GuerreroZ("Vegeta", 175, new TecnicaKi("FINAL FLASH", 50, 65), new AuraTransformacion("Super Vegeta", 1.4));

        goku.cargarKi();
        goku.lanzarTecnicaEspecial(vegeta);
        vegeta.cargarKi();
        vegeta.lanzarTecnicaEspecial(goku);
        goku.comerSemilla();
    }
}

import java.util.ArrayList;
import java.util.List;

class ArmaGenshin {
    private String nombreArma;
    private int ataqueBasico;
    private double probCritico;

    public ArmaGenshin(String nombre, int atk, double crit) {
        this.nombreArma = nombre;
        this.ataqueBasico = atk;
        this.probCritico = crit;
    }

    public int getDanioTotal() {
        boolean crit = Math.random() < probCritico;
        if (crit) System.out.println("  💥 ¡Golpe Crítico con " + nombreArma + "!");
        return crit ? (int)(ataqueBasico * 1.8) : ataqueBasico;
    }
}

class SetArtefactos {
    private int maestriaElemental;

    public SetArtefactos(int maestria) {
        this.maestriaElemental = maestria;
    }

    public double calcularMultiplicadorReaccion() {
        return 1.5 + (maestriaElemental * 0.002);
    }
}

class ComidaCurativa {
    private String nombrePlato;
    private int puntosCuracion;
    private boolean servida = false;

    public ComidaCurativa(String nombre, int cura) {
        this.nombrePlato = nombre;
        this.puntosCuracion = cura;
    }

    public int consumir() {
        if (!servida) {
            servida = true;
            return puntosCuracion;
        }
        return 0;
    }
    public String getNombrePlato() { return nombrePlato; }
}

class PersonajeTeyvat {
    private String nombre;
    private String elementoVision;
    private int vidaHp;
    private String auraAplicada = "Ninguna";
    private ArmaGenshin arma;
    private SetArtefactos artefactos;
    private List<ComidaCurativa> platos;

    public PersonajeTeyvat(String nombre, String elemento, int hp, ArmaGenshin arma, SetArtefactos artefactos) {
        this.nombre = nombre;
        this.elementoVision = elemento;
        this.vidaHp = hp;
        this.arma = arma;
        this.artefactos = artefactos;
        this.platos = new ArrayList<>();
    }

    public void agregarComida(ComidaCurativa c) { platos.add(c); }

    public void habilidadElemental(PersonajeTeyvat rival) {
        System.out.println("🌟 " + nombre + " [" + elementoVision + "] usa Habilidad Elemental contra " + rival.getNombre() + "!");
        int danio = arma.getDanioTotal();
        rival.recibirImpactoElemental(danio, this.elementoVision);
    }

    public void recibirImpactoElemental(int danioBase, String elementoAtacante) {
        int danioFinal = danioBase;
        if (this.auraAplicada.equals("Hydro") && elementoAtacante.equals("Pyro")) {
            double mult = artefactos != null ? artefactos.calcularMultiplicadorReaccion() : 1.5;
            danioFinal = (int) (danioBase * mult);
            System.out.printf("  🔥💧 ¡REACCIÓN ELEMENTAL: VAPORIZACIÓN! (Daño x%.2f = %d)\n", mult, danioFinal);
            this.auraAplicada = "Ninguna";
        } else {
            this.auraAplicada = elementoAtacante;
            System.out.println("  💧 Aura " + elementoAtacante + " aplicada al objetivo.");
        }
        this.vidaHp = Math.max(0, this.vidaHp - danioFinal);
        System.out.println("  💔 " + nombre + " HP restante: " + vidaHp);
    }

    public void comerPlato(int indice) {
        if (indice >= 0 && indice < platos.size()) {
            ComidaCurativa comida = platos.get(indice);
            int curado = comida.consumir();
            if (curado > 0) {
                this.vidaHp += curado;
                System.out.println("🍲 " + nombre + " comió " + comida.getNombrePlato() + " (+ " + curado + " HP).");
            }
        }
    }

    public String getNombre() { return nombre; }
}

public class Main {
    public static void main(String[] args) {
        PersonajeTeyvat yelan = new PersonajeTeyvat("Yelan", "Hydro", 200, new ArmaGenshin("Aqua Simulacra", 35, 0.4), new SetArtefactos(100));
        PersonajeTeyvat hutao = new PersonajeTeyvat("Hu Tao", "Pyro", 180, new ArmaGenshin("Báculo de Homa", 45, 0.5), new SetArtefactos(220));
        hutao.agregarComida(new ComidaCurativa("Tricolor Dango", 50));

        yelan.habilidadElemental(hutao);
        hutao.habilidadElemental(yelan);
        hutao.comerPlato(0);
    }
}

import java.util.ArrayList;
import java.util.List;

class ArmaForjada {
    private String nombreArma;
    private int danioDPS;

    public ArmaForjada(String nombre, int dps) {
        this.nombreArma = nombre;
        this.danioDPS = dps;
    }

    public int calcularGolpe() { return danioDPS; }
    public String getNombreArma() { return nombreArma; }
}

class TotemSoporte {
    private String tipoTotem;
    private int efectoPuntos;
    private int rondas;

    public TotemSoporte(String tipo, int efecto, int rondas) {
        this.tipoTotem = tipo;
        this.efectoPuntos = efecto;
        this.rondas = rondas;
    }

    public int pulsarRonda() {
        if (rondas > 0) {
            rondas--;
            System.out.println("  ⚡ Tótem de " + tipoTotem + " emitió pulso (+ " + efectoPuntos + " / rondas restantes: " + rondas + ")");
            return efectoPuntos;
        }
        return 0;
    }

    public boolean isActivo() { return rondas > 0; }
}

class FrascoPoder {
    private String nombre;
    private int bonus;
    private boolean usado = false;

    public FrascoPoder(String nombre, int bonus) {
        this.nombre = nombre;
        this.bonus = bonus;
    }

    public int consumir() {
        if (!usado) {
            usado = true;
            return bonus;
        }
        return 0;
    }
}

class HeroeAzeroth {
    private String nombre;
    private String claseRol;
    private int salud;
    private int iraRage;
    private ArmaForjada arma;
    private TotemSoporte totem;
    private List<FrascoPoder> frascos;

    public HeroeAzeroth(String nombre, String clase, int hp, ArmaForjada arma) {
        this.nombre = nombre;
        this.claseRol = clase;
        this.salud = hp;
        this.iraRage = 30;
        this.arma = arma;
        this.frascos = new ArrayList<>();
    }

    public void plantarTotem(TotemSoporte t) {
        this.totem = t;
        System.out.println("🗿 " + nombre + " clavó un tótem en la arena!");
    }

    public void procesarEfectoTotem() {
        if (totem != null && totem.isActivo()) {
            this.salud += totem.pulsarRonda();
        }
    }

    public void golpeMortal(HeroeAzeroth rival) {
        System.out.println("⚔️ " + nombre + " ejecuta Golpe Mortal con " + arma.getNombreArma() + "!");
        int danio = arma.calcularGolpe();
        rival.recibirDanio(danio);
    }

    public void recibirDanio(int danio) {
        this.salud = Math.max(0, this.salud - danio);
        System.out.println("  💥 " + nombre + " sufrió " + danio + " dmg. (Salud: " + salud + ")");
    }

    public void beberFrasco(int i) {
        if (i >= 0 && i < frascos.size()) {
            iraRage += frascos.get(i).consumir();
        }
    }

    public void agregarFrasco(FrascoPoder f) { frascos.add(f); }
    public String getNombre() { return nombre; }
}

public class Main {
    public static void main(String[] args) {
        HeroeAzeroth warrior = new HeroeAzeroth("Garrosh", "Guerrero", 260, new ArmaForjada("Aullavísceras", 45));
        HeroeAzeroth shaman = new HeroeAzeroth("Thrall", "Chamán", 240, new ArmaForjada("Martillo Maldito", 38));

        shaman.plantarTotem(new TotemSoporte("Corriente Sanadora", 25, 3));
        warrior.golpeMortal(shaman);
        shaman.procesarEfectoTotem();
        shaman.golpeMortal(warrior);
    }
}

import java.util.ArrayList;
import java.util.List;

class EspadaRanurada {
    private String nombre;
    private int danioFisico;

    public EspadaRanurada(String nombre, int danio) {
        this.nombre = nombre;
        this.danioFisico = danio;
    }
    public int getDanioFisico() { return danioFisico; }
    public String getNombre() { return nombre; }
}

class MateriaMagica {
    private String elemento;
    private String hechizo;
    private int poder;
    private int costoMP;

    public MateriaMagica(String elemento, String hechizo, int poder, int costoMP) {
        this.elemento = elemento;
        this.hechizo = hechizo;
        this.poder = poder;
        this.costoMP = costoMP;
    }

    public int getPoder() { return poder; }
    public int getCostoMP() { return costoMP; }
    public String getHechizo() { return hechizo; }
}

class PocionEter {
    private int mp;
    private boolean gastado = false;
    public PocionEter(int mp) { this.mp = mp; }
    public int consumir() {
        if (!gastado) { gastado = true; return mp; }
        return 0;
    }
}

class SoldadoFF {
    private String nombre;
    private int hpActual;
    private int mpActual;
    private EspadaRanurada sable;
    private List<MateriaMagica> materias;
    private List<PocionEter> eteres;

    public SoldadoFF(String nombre, int hp, int mp, EspadaRanurada sable) {
        this.nombre = nombre;
        this.hpActual = hp;
        this.mpActual = mp;
        this.sable = sable;
        this.materias = new ArrayList<>();
        this.eteres = new ArrayList<>();
    }

    public void engastarMateria(MateriaMagica m) { materias.add(m); }
    public void agregarEter(PocionEter e) { eteres.add(e); }

    public void ataqueFisico(SoldadoFF rival) {
        System.out.println("🗡️ " + nombre + " corta con " + sable.getNombre() + "!");
        rival.recibirDanio(sable.getDanioFisico());
    }

    public void conjurarMateria(int slot, SoldadoFF rival) {
        if (slot >= 0 && slot < materias.size()) {
            MateriaMagica m = materias.get(slot);
            if (mpActual >= m.getCostoMP()) {
                mpActual -= m.getCostoMP();
                System.out.println("🔮 " + nombre + " conjura [" + m.getHechizo() + "]! (MP restante: " + mpActual + ")");
                rival.recibirDanio(m.getPoder());
            } else {
                System.out.println("❌ No hay suficiente MP!");
            }
        }
    }

    public void usarEter(int i) {
        if (i >= 0 && i < eteres.size()) {
            int rec = eteres.get(i).consumir();
            if (rec > 0) {
                mpActual += rec;
                System.out.println("✨ " + nombre + " bebió Éter (+ " + rec + " MP).");
            }
        }
    }

    public void recibirDanio(int danio) {
        hpActual = Math.max(0, hpActual - danio);
        System.out.println("  💔 " + nombre + " HP: " + hpActual);
    }

    public String getNombre() { return nombre; }
}

public class Main {
    public static void main(String[] args) {
        SoldadoFF cloud = new SoldadoFF("Cloud Strife", 300, 80, new EspadaRanurada("Buster Sword", 35));
        cloud.engastarMateria(new MateriaMagica("Fuego", "Piro+", 55, 30));
        cloud.agregarEter(new PocionEter(40));

        SoldadoFF sephiroth = new SoldadoFF("Sefirot", 350, 100, new EspadaRanurada("Masamune", 42));

        cloud.conjurarMateria(0, sephiroth);
        sephiroth.ataqueFisico(cloud);
        cloud.usarEter(0);
    }
}