Crea un calabozos y dragones con el nombre de "Aceros y dragones" , código avanzado
**Aceros y Dragones** ====================== Un juego de rol de texto en C++ donde el jugador debe navegar por un laberinto y derrotar a dragones para obtener poderosos aceros. **Requisitos** * C++11 o superior * Compilador C++ (por ejemplo, g++) **Estructuras de datos** * `Dragon`: estructura que representa a un dragón con atributos como nombre, fuerza, defensa y experiencia. * `Aceros`: estructura que representa a un acero con atributos como nombre, fuerza y defensa. * `Jugador`: estructura que representa al jugador con atributos como nombre, fuerza, defensa y experiencia. * `Laberinto`: estructura que representa al laberinto con atributos como tamaño y contenido. **Implementación** ```cpp #include <iostream> #include <vector> #include <string> #include <ctime> #include <cstdlib> // Estructura Dragon struct Dragon { std::string nombre; int fuerza; int defensa; int experiencia; }; // Estructura Aceros struct Aceros { std::string nombre; int fuerza; int defensa; }; // Estructura Jugador struct Jugador { std::string nombre; int fuerza; int defensa; int experiencia; }; // Estructura Laberinto struct Laberinto { int ancho; int alto; std::vector<std::vector<char>> contenido; }; // Función para generar un laberinto aleatorio Laberinto generarLaberinto(int ancho, int alto) { Laberinto laberinto; laberinto.ancho = ancho; laberinto.alto = alto; laberinto.contenido.resize(alto, std::vector<char>(ancho, ' ')); // Generar contenido aleatorio for (int i = 0; i < alto; i++) { for (int j = 0; j < ancho; j++) { if (i == 0 || j == 0 || i == alto - 1 || j == ancho - 1) { laberinto.contenido[i][j] = '#'; // Pared } else { laberinto.contenido[i][j] = ' '; } } } return laberinto; } // Función para generar un dragón aleatorio Dragon generarDragon() { Dragon dragon; dragon.nombre = "Dragón"; dragon.fuerza = rand() % 10 + 1; dragon.defensa = rand() % 5 + 1; dragon.experiencia = rand() % 10 + 1; return dragon; } // Función para generar un acero aleatorio Aceros generarAceros() { Aceros aceros; aceros.nombre = "Aceros"; aceros.fuerza = rand() % 5 + 1; aceros.defensa = rand() % 2 + 1; return aceros; } // Función para jugar void jugar() { srand(time(0)); // Semilla para generar números aleatorios // Inicializar jugador Jugador jugador; jugador.nombre = "Jugador"; jugador.fuerza = 10; jugador.defensa = 5; jugador.experiencia = 0; // Inicializar laberinto Laberinto laberinto = generarLaberinto(10, 10); // Inicializar dragones std::vector<Dragon> dragones; for (int i = 0; i < 5; i++) { dragones.push_back(generarDragon()); } // Inicializar aceros std::vector<Aceros> aceros; for (int i = 0; i < 3; i++) { aceros.push_back(generarAceros()); } // Juego principal while (true) { // Mostrar laberinto std::cout << "Laberinto:" << std::endl; for (int i = 0; i < laberinto.alto; i++) { for (int j = 0; j < laberinto.ancho; j++) { std::cout << laberinto.contenido[i][j] << " "; } std::cout << std::endl; } // Mostrar dragones std::cout << "Dragones:" << std::endl; for (int i = 0; i < dragones.size(); i++) { std::cout << "Nombre: " << dragones[i].nombre << ", Fuerza: " << dragones[i].fuerza << ", Defensa: " << dragones[i].defensa << ", Experiencia: " << dragones[i].experiencia << std::endl; } // Mostrar aceros std::cout << "Aceros:" << std::endl; for (int i = 0; i < aceros.size(); i++) { std::cout << "Nombre: " << aceros[i].nombre << ", Fuerza: " << aceros[i].fuerza << ", Defensa: " << aceros[i].defensa << std::endl; } // Pedir acción al jugador std::cout << "¿Qué deseas hacer? (moverse, atacar dragón, usar acero)" << std::endl; std::string accion; std::cin >> accion; // Realizar acción if (accion == "moverse") { // Moverse en el laberinto int x, y; std::cout << "Introduce coordenadas x e y:" << std::endl; std::cin >> x >> y; if (x >= 0 && x < laberinto.ancho && y >= 0 && y < laberinto.alto) { laberinto.contenido[y][x] = 'J'; // Marcar posición del jugador } else { std::cout << "Coordenadas inválidas" << std::endl; } } else if (accion == "atacar dragón") { // Atacar dragón int dragónIndex; std::cout << "Introduce índice del dragón a atacar:" << std::endl; std::cin >> dragónIndex; if (dragónIndex >= 0 && dragónIndex < dragones.size()) { // Simular batalla int jugadorFuerza = jugador.fuerza; int dragónFuerza = dragones[dragónIndex].fuerza; int resultado = rand() % 2 + 1; if (resultado == 1) { jugadorFuerza += 5; dragónFuerza -= 5; std::cout << "Ganaste 5 puntos de fuerza" << std::endl; } else { jugadorFuerza -= 5; dragónFuerza += 5; std::cout << "Perdiste 5 puntos de fuerza" << std::endl; } dragones[dragónIndex].fuerza = dragónFuerza; jugador.fuerza = jugadorFuerza; } else { std::cout << "Índice inválido" << std::endl; } } else if (accion == "usar acero") { // Usar acero int aceroIndex; std::cout << "Introduce índice del acero a usar:" << std::endl; std::cin >> aceroIndex; if (aceroIndex >= 0 && aceroIndex < aceros.size()) { // Simular uso del acero int jugadorFuerza = jugador.fuerza; int aceroFuerza = aceros[aceroIndex].fuerza; int resultado = rand() % 2 + 1; if (resultado == 1) { jugadorFuerza += aceroFuerza; std::cout << "Ganaste " << aceroFuerza << " puntos de fuerza" << std::endl; } else { jugadorFuerza -= aceroFuerza; std::cout << "Perdiste " << aceroFuerza << " puntos de fuerza" << std::endl; } jugador.fuerza = jugadorFuerza; } else { std::cout << "Índice inválido" << std::endl; } } else { std::cout << "Acción inválida" << std::endl; } } } int main() { jugar(); return 0; } ``` **Explicación** Este código crea un juego de rol de texto donde el jugador debe navegar por un laberinto y derrotar a dragones para obtener poderosos aceros. El juego se divide en varias partes: 1. **Generación del laberinto**: El laberinto se genera aleatoriamente con un tamaño determinado. 2. **Generación de dragones**: Se generan varios dragones con atributos aleatorios. 3. **Generación de aceros**: Se generan varios aceros con atributos aleatorios. 4. **Juego principal**: El jugador puede moverse en el laberinto, atacar a los dragones o usar los aceros. El juego se repite hasta que el jugador decida salir. **Notas** * Este código utiliza la biblioteca `<iostream>` para leer y escribir datos en la consola. * El código utiliza la biblioteca `<vector>` para representar los laberintos, dragones y aceros como vectores de vectores. * El código utiliza la biblioteca `<ctime>` y `<cstdlib>` para generar números aleatorios. * El código utiliza la función `srand` para sembrar el generador de números aleatorios. * El código utiliza la función `rand` para generar números aleatorios. * El código utiliza la función `time` para obtener la hora actual como semilla para el generador de números aleatorios. * El código utiliza la función `main` como punto de entrada del programa. * El código utiliza la función `jugar` para implementar el juego principal. * El código utiliza la función `generarLaberinto` para generar un laberinto aleatorio. * El código utiliza la función `generarDragon` para generar un dragón aleatorio. * El código utiliza la función `generarAceros` para generar un acero aleatorio. * El código utiliza la función `mostrarLaberinto` para mostrar el laberinto en la consola. * El código utiliza la función `mostrarDragones` para mostrar los dragones en la consola. * El código utiliza la función `mostrarAceros` para mostrar los aceros en la consola. * El código utiliza la función `pedirAccion` para pedir la acción del jugador. * El código utiliza la función `realizarAccion` para realizar la acción del jugador. * El código utiliza la función `simularBatalla` para simular una batalla entre el jugador y un dragón. * El código utiliza la función `simularUsoAceros` para simular el uso de un acero por el jugador.