¡Claro que puedes hacerlo! Puedes crear un archivo batch (`.bat`) para automatizar este proceso y que ejecute directamente el comando sin necesidad de escribir manualmente en la barra de direcciones o abrir el símbolo del sistema por separado. Aquí tienes una guía paso a paso:

### 1. **Crea el archivo batch**

1. Abre un editor de texto como *Bloc de notas* o cualquier otro editor de texto simple.
2. Escribe el siguiente código (personalizando las rutas según tu configuración):

```batch
@echo off
:: Cambia a la carpeta donde está el ejecutable de John the Ripper
cd /d "C:\ruta\a\la\carpeta\run"

:: Ejecuta el comando con el archivo de wordlist y el archivo de hashes
john --wordlist=Mywords.txt rar.hashes

:: Pausa para que puedas ver el resultado
pause
```

3. Guarda el archivo con la extensión `.bat`. Por ejemplo, podrías llamarlo `ejecutar_john.bat`.

   - Asegúrate de que al guardar uses **Guardar como...** y selecciones "Todos los archivos" como tipo, para evitar que Windows lo guarde como `ejecutar_john.bat.txt`.

---

### 2. **Cómo usar el archivo batch**

1. Coloca el archivo batch (`.bat`) en cualquier lugar que te sea conveniente.
2. Haz doble clic en el archivo batch. Esto hará lo siguiente:
   - Cambiará al directorio `run` donde está el ejecutable de John the Ripper.
   - Ejecutará el comando `john --wordlist=Mywords.txt rar.hashes`.
   - Mantendrá abierta la ventana de la consola al final (gracias al comando `pause`) para que puedas leer los resultados.

---

### 3. **Personaliza el archivo batch**

Si más adelante necesitas cambiar los parámetros (como el archivo de wordlist o el archivo de hashes), simplemente edita el archivo batch con un editor de texto y ajusta las líneas correspondientes.

---

### 4. **Automatización adicional (opcional)**

Si siempre tendrás los archivos `rar.hashes` y `Mywords.txt` en la misma carpeta, podrías simplificar aún más las cosas:

- Coloca el archivo batch en el directorio donde están los archivos, y modifica el batch para que no tengas que cambiar de directorio:

```batch
@echo off
:: Ejecuta John the Ripper directamente en el directorio actual
"C:\ruta\a\la\carpeta\run\john.exe" --wordlist=Mywords.txt rar.hashes

:: Pausa para ver los resultados
pause
```

De este modo, el archivo batch puede ejecutarse desde cualquier lugar, pero necesitarás asegurarte de que `Mywords.txt` y `rar.hashes` estén en la misma carpeta que el batch.

---

### 5. **Cosas a tener en cuenta**

- Si utilizas rutas con espacios, asegúrate de que estén entre comillas, como en `"C:\Program Files\John the Ripper\run"`.
- Si necesitas cambiar el archivo `rar.hashes` manualmente, asegúrate de que esté en el directorio donde espera el batch.
- Si tienes varias tareas similares pero con diferentes archivos, podrías crear diferentes archivos batch para cada tarea con los nombres de archivo correspondientes.

¡Y listo! Con esto, puedes automatizar el proceso y ahorrarte tiempo.

¿Cuales son las variables de los juegos y cual es el más sencillo?


Quiero hacer un juego de cada tipo, comenzando por los más sencillos. El programa tendría una pantalla inicial donde se podría modificar variables y basado en eso aparecería un juego u otro.


El juego más sencillo que se me ocurre es uno que se gane por hacer algo, no importa qué, mover el mouse por ejemplo. Pero eso debería representar algo, por ejemplo que un personaje en la pantalla se movió.
También puede ser ganar por hacer nada durante cierto tiempo. Ganar por actuar o no, me parece que no, no tendría gracia.


En cuanto a variables pienso en:

1- Dimensiones del universo: ¿?
Me dijeron que una aventura de texto, como fueron algunos 1eros juegos, podría tener 0d. No sé.
Un juego de 1d también es posible pero se vería como uno 2d, al menos según pensé. Puede que los personajes sólo se muevan hacia una dirección, pero van a tener cierto alto y ancho, son 2d. Incluso si sólo fuesen 1 pixel cada uno, el pixel tiene cierto alto y cierto ancho.
En el caso de juegos de cartas o algún otro, se podría decir que cada mano es una dimensión, así como la pila de descarte y alguna otra cosa, pero parece un poco forzado, no parece una dimensión normal. Si se tienen opciones, no es que la lista de opciones sea una dimensión. Las cartas en la mano son opciones... En fin, es un caso especial.
Yo creo que lo más simple para empezar es 2d. Las pantallas son 2d. Una aventura de texto, a estas alturas no tiene mucho sentido hacer. Incluso las novelas visuales tienen lugares y si hay más de 1 personaje, no aparecen ambos en el medio.

2- Posibles estados del personaje : ¿?
No su posición en las dimensiones. No es necesario que haya movimiento. El juego puede ser, por ejemplo, que el personaje deba ponerse del mismo color que otro.

3- Máximas caras visibles del personaje: 0~6
Considerado como un cubo, cuántas se pueden llegar a ven. Pueden ser 0, como en juegos de cartas, donde el personaje no se ve.
El máximo normal es 3. Puede ser cuando se muestra medio en diagonal, medio arriba de su cabeza, su perfil y espalda/frente. En vez de arriba de su cabeza podría ser desde abajo, pero es bastante atípico.
Es más de 3 cuando hay más de 2 cámaras mostrando diferentes partes del personaje. Tiene sentido por ejemplo si es una nave que puede ser atacada desde diversos lados.

4- Perfil del personaje es visible: N/S
Se refiere a si su perfil se ve en alguna ocasión o no. No daré relevancia a si se ve uno y no el otro. Por ejemplo del clásico Mario sólo se ve 1 perfil, pero considero que se ve de perfil y ya está.

5- El personaje es visible desde arriba: N/S
Si en algún punto se ve completamente desde arriba o no. Los clásicos de Zelda no se ven completamebte desde arriba, esto se da en juegos de naves scrolldown, por ejemplo.

6- Espalda del personaje es visible: N/S
Lo mismo respecto a su espalda. En este caso supongo que Zelda vale.

7- Frente del personaje es visible: N/S
Simple.

- El personaje es visible desde abajo: N/S
Extraño, pero posible si por ejemplo es una nave y cosas se acercan desde la pantalla. Se vería más o menos como vemos desde abajo a un avión, y desde ahí se le acercarían cosas. Como es tan raro, no lo tendré en cuenta.

8- Perfil, arriba y espalda del pers. es visible: N/S
Si en algún momento se verá todo eso a medias, a la vez.

9- Perfil, arriba y frente del pers. es visible: N/S
Parecido.

- Perfil, abajo y espalda del pers. es visible: N/S
El caso atípico que comenté, por ahora no lo tendré en cuenta.

- Perfil, abajo y frente del pers. es visible: N/S
Parecido.

10- Posibles objetos del personaje: 0~
Típico.

11- El personaje puede moverse hacia adelante: N/S
Típico.

12- El personaje puede moverse hacia atrás:
Aquí las opciones son:
A- No.
B- Sí pero queda mirando hacia allí.
C- Sí.
D- Sí, con opción de quedar mirando hacia allí.

13- El personaje puede moverse hacia los costados:
A- No.
B- Sí pero queda mirando hacia allí.
C- Sí.
D- Sí, con opción de quedar mirando hacia allí.
De nuevo, no consideraré que sólo se pueda mover hacia 1 costado. Es hacia ambos o nada.

14- El personaje puede moverse hacia arriba:
Aquí las opciones me parece complicado decidir cuales serían, se me ocurre:
A- No.
B- Saltando, volando, nadando o trepando, pero queda mirando hacia allí y cae.
C- Saltando, volando, nadando o trepando, pero cae.
D- Volando, nadando o trepando, pero queda mirando hacia allí.
E- Saltando, volando, nadando o trepando, con opción de quedar mirando hacia allí, pero cae.
F- Volando, nadando o trepando, con opción de quedar mirando hacia allí.
En Demon Crest se ve eso de que el personaje se mantiene flotando, no cae, y puede subir con cierto poder. Aunque también puede caer si quiere. En fin, sería para un juego donde no tenga sentido caer, y no subir sea mantenerse.

15- El personaje puede moverse hacia abajo:
Parecido supongo:
A- No.
B- Sí, pero queda mirando hacia allí y sube.
C- Sí, pero sube.
D- Sí, pero queda mirando hacia allí.
E- Sí, con opción de quedar mirando hacia allí, pero sube.
F- Sí, con opción de quedar mirando hacia allí.
Podría subir en el caso de que quiera hundirse y no sea suficientemente denso, o si en la parte de arriba de la pantalla hay un agujero negro u objeto con mucha gravedad, se me ocurre. Como que el motor genera un impulso pero se apaga, hay que reencenderlo, y así.

BaseUrna = "WWB";
AlexPerdidas = 0;
BartPerdidas = 0;
CamiloPerdidas = 0;
function Sortear () {
	// Preparar urna:
	Urna = BaseUrna;
	// Elección de la 1er persona, Alex:
	BolaDeAlexNro = random(3);
	if (BolaDeAlexNro == 2) {
		AlexPerdidas++;
	} else {
		BolaDeAlex = Urna.charat(BolaDeAlexNro);
		Parte1 = substring(Urna, 0, BolaDeAlexNro);
		trace(Parte1);
		Parte2 = substring(Urna, BolaDeAlexNro+1, Urna.length);
		trace(Parte2);
		Urna = Parte1+Parte2;
		// trace(Urna);
		// Elección de la 2nda persona, Bart:
		BolaDeBartNro = random(2);
		if (BolaDeBartNro == 1) {
			BartPerdidas++;
		} else {
			CamiloPerdidas++;
		}
	}
}

myString.concat(valor1,...valorN);
Argumentos

valor1,...valorN
Cero o más valores que se van a concatenar.

Descripción

Método; combina los valores especificados y devuelve una nueva cadena. Si es necesario, cada argumento valor se convierte en una cadena y se anexa, en orden, al final de la cadena.

BaseUrna = "ABC";
BaseUrna.concat("D");
trace(BaseUrna);

myString.slice(inicio, fin);
Argumentos

inicio: Un número que especifica el índice del punto de inicio del sector. Si inicio es un número negativo, el punto inicial se especifica desde el final de la matriz, donde -1 es el último elemento.

fin: Un número que especifica el índice del punto final del sector. Si no se especifica fin, el sector incluye todos los caracteres desde el inicio al final de la cadena. Si fin es un número negativo, el punto final se determina desde el final de la cadena, donde -1 es el último carácter.

Descripción
Método; extrae un sector o una subcadena del objeto String especificado, después la devuelve como una nueva cadena sin modificar el objeto String original. La cadena devuelta incluye el carácter inicio y todos los caracteres hasta (pero sin incluir) el carácter fin.

myString.split(delimitador);
Argumentos

delimitador: El carácter utilizado para delimitar la cadena.

Descripción

Método. divide un objeto String rompiendo la cadena cuando se produce el argumento delimitador especificado y devuelve las subcadenas en una matriz. Si no se especifica delimitador, la matriz devuelta contiene solamente un elemento: la propia cadena. Si el delimitador es una cadena vacía, cada carácter del objeto String se convierte en un elemento de la matriz.

myString.substr(inicio, longitud);
Argumentos

inicio: Un número entero que indica la posición del primer carácter de la subcadena que se está creando. Si inicio es un número negativo, el punto inicial se determina desde el final de la matriz, donde -1 es el último carácter.

longitud: El número de caracteres en la subcadena que se está creando. Si no se especifica longitud, la subcadena incluye todos los caracteres desde el inicio al final de la cadena.

Descripción

Método; devuelve los caracteres de una cadena desde el índice especificado en el argumento inicio, hasta el número de caracteres especificados en el argumento longitud.

BaseUrna = "ABCD";
AlexPerdidas = 0;
BartPerdidas = 0;
CamiloPerdidas = 0;
function Sortear () {
	// Preparar urna:
	Urna = BaseUrna;
	// Elección de la 1er persona, Alex:
	BolaDeAlexNro = random(4);
	if (BolaDeAlexNro == 3) {
		AlexPerdidas++;
	} else {
		BolaDeAlex = Urna.charat(BolaDeAlexNro);
		Parte1 = Urna.substr(0, BolaDeAlexNro);
		// trace(Parte1);
		Parte2 = Urna.substr(BolaDeAlexNro+1, Urna.length);
		// trace(Parte2);
		Urna = Parte1+Parte2;
		trace(Urna);
	}
}

myString.substring(desde, hasta);
Argumentos

desde: Un número entero que indica la posición del primer carácter de la subcadena que se está creando. Los valores válidos para desde van de 0 a string.length - 1.

hasta: Un número entero que es 1 + el índice del último carácter de la subcadena que se está creando. Los valores válidos para hasta van de 1a string.length. Si no se especifica el argumento hasta, el final de la subcadena es el final de la cadena. Si desde es igual a hasta, el método devuelve una cadena vacía. Si desde es mayor que hasta, los argumentos se intercambian automáticamente antes de que se ejecute la función.

Descripción

Método; devuelve una cadena que consiste en los caracteres entre los puntos especificados por los argumentos desde y hasta.

substring(cadena, índice, recuento);
Argumentos

cadena La cadena de la que extraer la nueva cadena.

índice El número del primer carácter que se va a extraer.

recuento El número de caracteres que se van a incluir en la cadena extraída, sin incluir el carácter de índice.

Descripción

Función de cadena; extrae parte de una cadena.

charset = "abcdefghijklmnñopqrstuvwxyz"
with open("passwords.txt", "w", encoding="utf-8") as txt :
  for a in charset :
    for b in charset :
      for c in charset :
        for d in charset :
          txt.write(a + b + c + d + "\n")

El problema puede deberse a cómo Python maneja la codificación al escribir en un archivo. Aunque estás especificando `encoding="utf-8"` al abrir el archivo, puede haber conflictos si el sistema en el que estás ejecutando el script no interpreta correctamente los caracteres extendidos, como la `ñ`.

Aquí tienes una solución que debería funcionar correctamente:

### Solución:

1. **Asegúrate de que tu archivo fuente esté guardado en UTF-8**. Si tu editor de texto no guarda el archivo fuente en UTF-8, la `ñ` podría no ser interpretada correctamente. En editores como VS Code, puedes configurar la codificación en UTF-8.

2. **Verifica que la consola/terminal interprete UTF-8**. Si estás ejecutando el código en una terminal que no maneja UTF-8, podría haber problemas al visualizar o procesar caracteres como la `ñ`.

3. **Código corregido:**

```python
# Definir el charset con la letra ñ
charset = "abcdefghijklmnñopqrstuvwxyz"

# Abrir el archivo en modo escritura, asegurando la codificación UTF-8
with open("passwords.txt", "w", encoding="utf-8") as txt:
    # Generar todas las combinaciones de 4 caracteres
    for a in charset:
        for b in charset:
            for c in charset:
                for d in charset:
                    # Escribir cada combinación en una nueva línea
                    txt.write(a + b + c + d + "\n")
```

4. **Verifica el archivo generado**. Tras ejecutar el código, abre el archivo `passwords.txt` con un editor que soporte UTF-8 para confirmar que las combinaciones con la `ñ` se generan correctamente.

### Qué hacer si sigue sin funcionar:

Si el problema persiste, puede ser útil probar estas opciones:

- **Forzar la codificación UTF-8 en tu entorno Python**. Asegúrate de que Python esté utilizando UTF-8 por defecto. Puedes agregar esta línea al inicio de tu script:

  ```python
  import sys
  sys.stdout.reconfigure(encoding='utf-8')
  ```

- **Revisar el entorno de ejecución**. Si estás en Windows, puedes configurar la consola para que use UTF-8 ejecutando este comando en la terminal antes de correr el script:

  ```cmd
  chcp 65001
  ```

### Explicación del problema:

La `ñ` es un carácter que no está en el conjunto básico ASCII. Si hay un desajuste en la codificación entre tu archivo fuente, el entorno Python o el archivo de salida, podría causar que la `ñ` no se procese correctamente. Al usar `encoding="utf-8"` y asegurarte de que todo tu entorno soporte UTF-8, deberías poder manejar la `ñ` sin problemas.