1. Revisa las Opciones de Búsqueda en "Opciones de carpeta y búsqueda", no vaya a ser que moviste algo ahí

puedes arrastrar y soltar para seleccionar pequeños rangos o usar Shift + click para seleccionar un rango mucho más grande.

Cartas = ["MarioDK", "DK"];
// Lo anterior se usa para hacer sus efectos, esto es cómo se muestran sus nombres:
ShowerDeCartas = ["Mario de Donkey Kong", "Donkey Kong"];
HumanoHP = 10;
IAHP = 10;
// Frame 1: Se dan cartas, el mensaje no tiene saltos de línea.
// F2: Un objeto repite TurnoDeHumano hasta que se presione A.
NroDeCartaDeHumano = random(Cartas.length);
Mensaje = "Tu carta ahora es "+ShowerDeCartas[NroDeCartaDeHumano];
NroDeCartaDeIA = random(Cartas.length);
function TurnoDeHumano () {
	// Si se presiona A:
	if (Key.isDown(65)) {
		// Usa la carta (dando su estadística AT a la función):
		eval(Cartas[NroDeCartaDeHumano])(eval(Cartas[NroDeCartaDeHumano]+"AT"));
	}
}
function HumanoObtieneCarta () {
	NroDeCartaDeHumano = random(Cartas.length);
	Mensaje = Mensaje+"\n\nTu carta ahora es "+ShowerDeCartas[NroDeCartaDeHumano];
}
function FinDelTurnoDeHumano () {
	HumanoObtieneCarta();
	// Turno de la IA:
}
function Victoria () {
	Mensaje = Mensaje+"\n\n¡Ganaste!";
	gotoAndStop (4);
}
// Estadísticas:
MarioDKAT = 1;
DKAT = 2;
// Efectos:
function MarioDK (ataque) {
	Mensaje = "¡Tu rival ha sido enjaulado!";
	IAHP = IAHP-ataque;
	if (IAHP > 0) {
		FinDelTurnoDeHumano();
	} else {
		Victoria();
	}
}
function DK (ataque) {
	Mensaje = "¡Rival dañado!";
	IAHP = IAHP-ataque;
	if (IAHP > 0) {
		FinDelTurnoDeHumano();
	} else {
		Victoria();
	}
}

	IAHP = IAHP-ataque;
	if (IAHP > 0) {
		FinDelTurnoDeHumano();
	} else {
		Victoria();
	}
 

# Análisis y Mejoras para el Juego de Cartas

## Mejoras de Código y Estructura

1. **Eliminar duplicación de código**: El patrón de reducir HP y verificar victoria se repite. Podrías crear una función común:
```actionscript
function aplicarAtaque(target, ataque, mensajeEfecto) {
    target.HP -= ataque;
    Mensaje = mensajeEfecto;
    if (target.HP > 0) {
        FinDelTurnoDeHumano();
    } else {
        Victoria();
    }
}
```

2. **Sistema de objetivos más flexible**: En lugar de hardcodear el objetivo, puedes pasar el objetivo como parámetro:

```actionscript
function MarioDK(ataque, objetivo) {
    aplicarAtaque(objetivo, ataque, "¡Tu rival ha sido enjaulado!");
}

// Llamada:
eval(Cartas[NroDeCartaDeHumano])(eval(Cartas[NroDeCartaDeHumano]+"AT"), IA);
```

3. **Estructura de datos más organizada**: En lugar de tener arrays separados para nombres y estadísticas, podrías usar objetos:

```actionscript
Cartas = [
    {nombre: "Mario de Donkey Kong", ataque: 1, efecto: MarioDK},
    {nombre: "Donkey Kong", ataque: 2, efecto: DK}
];
```

4. **Sistema de turnos más robusto**: Implementar un sistema de gestión de turnos que alterna entre jugadores.

## Implementación Mejorada

Aquí tienes una versión mejorada que aborda estos puntos:

```actionscript
// Configuración inicial
Cartas = [
    {nombre: "Mario de Donkey Kong", ataque: 1, efecto: function(objetivo) {
        aplicarAtaque(objetivo, this.ataque, "¡Tu rival ha sido enjaulado!");
    }},
    {nombre: "Donkey Kong", ataque: 2, efecto: function(objetivo) {
        aplicarAtaque(objetivo, this.ataque, "¡Rival dañado!");
    }}
];

Jugador = {HP: 10, nombre: "Humano"};
IA = {HP: 10, nombre: "IA"};
turnoActual = Jugador;
Mensaje = "";

// Frame 1: Repartir cartas iniciales
repartirCartas();

// Frame 2: Lógica del juego
function repartirCartas() {
    NroDeCartaDeHumano = random(Cartas.length);
    NroDeCartaDeIA = random(Cartas.length);
    Mensaje = "Tu carta ahora es " + Cartas[NroDeCartaDeHumano].nombre;
}

function TurnoDeHumano() {
    if (Key.isDown(65)) { // Si se presiona A
        var carta = Cartas[NroDeCartaDeHumano];
        carta.efecto(IA); // Siempre ataca a la IA en este caso
    }
}

function aplicarAtaque(objetivo, ataque, mensajeEfecto) {
    objetivo.HP -= ataque;
    Mensaje = mensajeEfecto;
   
    if (objetivo.HP <= 0) {
        Victoria();
    } else if (turnoActual == Jugador) {
        FinDelTurnoDeHumano();
    } else {
        // Turno de la IA
        turnoIA();
    }
}

function FinDelTurnoDeHumano() {
    turnoActual = IA;
    repartirCartas();
    // La IA juega inmediatamente después
    turnoIA();
}

function turnoIA() {
    var carta = Cartas[NroDeCartaDeIA];
    carta.efecto(Jugador); // La IA siempre ataca al jugador
   
    // Volver al turno del jugador
    turnoActual = Jugador;
    repartirCartas();
}

function Victoria() {
    var ganador = (IA.HP <= 0) ? Jugador : IA;
    Mensaje = "¡" + ganador.nombre + " ha ganado!";
    gotoAndStop(4);
}
```

## Ventajas de esta implementación:

1. **Flexibilidad en objetivos**: Las funciones de efecto ahora reciben explícitamente su objetivo.
2. **Estructura más clara**: Los datos de las cartas están encapsulados en objetos.
3. **Sistema de turnos**: Más fácil de extender para más jugadores o mecánicas complejas.
4. **Menos duplicación**: La lógica común está centralizada en `aplicarAtaque`.

## Para futuras expansiones:

1. **Efectos complejos**: Puedes añadir propiedades adicionales a las cartas (como "dañoAutomatico", "curar", etc.)
2. **Selección de objetivo**: Modificar la UI para permitir elegir objetivo cuando sea relevante.
3. **Múltiples jugadores**: El sistema de turnos ya está preparado para escalar.

Esta estructura hace que sea más fácil añadir nuevos tipos de cartas con efectos variados sin tener que modificar mucho la lógica principal del juego.

¡Muy buena observación!  
Lo que mencionas es **totalmente cierto**: en varios juegos clásicos de arcade (y sus versiones de consola como NES), había límites estrictos en la cantidad de disparos que podías tener activos al mismo tiempo. Esto se debía principalmente a **limitaciones de hardware** de la época (CPU, memoria, etc.), pero también era un recurso de **diseño de dificultad intencional**.

---

## Sobre tu pregunta: **¿Se puede romper ese límite?**

**¡Sí, es posible!** Hay varias maneras:

### 1. **Utilizar cheats (códigos de trucos) en emuladores**
Muchos emuladores modernos (como **FCEUX**, **Nestopia**, **Mesen**, etc.) permiten insertar códigos tipo **Game Genie**, **Pro Action Replay**, o incluso usar parches de memoria para modificar dinámicamente el comportamiento del juego.

- **Ejemplo**: podrías buscar un código Game Genie que elimine o modifique la restricción de disparos.
- **En FCEUX**, además puedes usar el **Memory Viewer** para buscar la variable que cuenta tus disparos y cambiarla para que no limite.

---

### 2. **Modificar directamente el ROM**
Esto es más avanzado, pero totalmente posible.

- Puedes usar un **desensamblador** de NES (como **IDA Pro**, **Ghidra**, o incluso herramientas especializadas de NES) para encontrar el código que maneja la cantidad de disparos activos.
- Luego, podrías:
  - Eliminar la comparación que limita el número de disparos.
  - O aumentar el número máximo permitido.

Esto básicamente requiere hacer un **parche IPS** o editar el ROM manualmente con un **hex editor**.

---

### 3. **Buscar hacks ya hechos**
Algunos fans ya han creado **hacks de ROMs** donde arreglan limitaciones molestas como esta. Puede que exista un hack de Donkey Kong 3 o Galaxian que elimine la restricción de disparos.

Sitios como:
- [ROMhacking.net](https://www.romhacking.net/)
- [NESWorld](http://www.nesworld.com/)

tienen miles de hacks de mejora y podría haber uno que te sirva.

---

## ¿Cómo funcionaría técnicamente el límite de disparos?

Usualmente, el juego tiene una **variable de conteo** de disparos activos. El flujo suele ser algo así:

```assembly
si (disparos_activos < 2) {
    crear_disparo();
}
```

Así que para romper eso, podrías:

- Forzar `disparos_activos` a 0 siempre.
- O eliminar el chequeo de cantidad (`< 2`).
- O aumentar el número máximo a, digamos, 10.

---

## ¿Quieres que te ayude a intentar encontrar o crear un código para romper esa limitación en **Donkey Kong 3** específicamente?

Podríamos:
- Buscar un **cheat** ya hecho.
- O diseñar juntos uno usando memoria RAM en un emulador como **FCEUX**.

🚀 **Si quieres, dime qué emulador usas y atacamos el problema juntos**. 🚀

---

¿Te gustaría que incluso te prepare un pequeño **tutorial paso a paso** para intentar modificarlo tú mismo? 🔥  
(¡No es tan difícil como parece!)

### Solución para convertir minutos a segundos en el comando `shutdown`
Puedes modificar tu script para que acepte minutos (incluso con decimales, como `4.3`) y los convierta automáticamente a segundos. 

Aquí tienes una versión mejorada de tu script: 

```cmd
@echo off
set /p minutos="Tiempo hasta apagar el dispositivo (en minutos)? : "

:: Reemplazar coma por punto por si el usuario introduce 4,3 en lugar de 4.3
set minutos=%minutos:,=.%

:: Calcular segundos (minutos * 60) usando PowerShell para soportar decimales
for /f %%a in ('powershell -command "[math]::Floor(%minutos% * 60)"') do set segundos=%%a

echo Apagando el equipo en %segundos% segundos (%minutos% minutos)...
shutdown /s /t %segundos%
```

### Explicación:
1. **`set /p minutos=...`** → Pide al usuario que introduzca el tiempo en minutos. 
2. **`%minutos:,=.%`** → Convierte comas en puntos para evitar errores con decimales (ej: `4,3` → `4.3`). 
3. **`powershell -command "[math]::Floor(%minutos% * 60)"`** → Usa PowerShell para hacer la multiplicación (`minutos × 60`) y redondear hacia abajo. 
4. **`shutdown /s /t %segundos%`** → Ejecuta el comando de apagado con el tiempo en segundos. 

### Ejemplo de uso:
- Si el usuario introduce **`4.3`**, el script calculará: 
  `4.3 × 60 = 258 segundos` → `shutdown /s /t 258`. 

### Alternativa sin PowerShell (solo minutos enteros)
Si prefieres evitar PowerShell y solo necesitas minutos enteros (sin decimales), puedes hacerlo así: 
```cmd
@echo off
set /p minutos="Tiempo hasta apagar el dispositivo (en minutos, enteros)? : "
set /a segundos=%minutos% * 60
shutdown /s /t %segundos%
```

### Conclusión
La versión mejorada permite introducir minutos en lugar de segundos, haciéndolo más práctico. 

Si tienes más dudas sobre scripts en `CMD`, ¡avísame!