README_es_ES.md

   1 # sm64pc
   2 Adaptación a OpenGL de [n64decomp/sm64](https://github.com/n64decomp/sm64).
   3
   4 No dudes en contribuir o reportar bugs, pero recuerda: **no se debe subir nada con copyright**.
   5 Ejecuta `./extract_assets.py --clean && make clean` o `make distclean` para borrar todo el contenido proveniente de la ROM. Este port es posible gracias a [n64-fast32-engine](https://github.com/Emill/n64-fast3d-engine/) creado por [Emill](https://github.com/Emill).
   6
   7 ## Funcionalidades
   8
   9  * Renderizado nativo. Podrás jugar a Super Mario 64 sin necesidad de un emulador.
  10  * Resolución y relación de aspecto variables. Puedes jugar a Super Mario 64 a básicamente cualquier resolución o tamaño de ventana.
  11  * Soporte nativo para mandos XInput. En Linux, se ha confirmado que el DualShock 4 funciona sin más.
  12  * Cámara analógica y cámara controlada con el ratón. (Se activa con `make BETTERCAMERA=1`.)
  13  * Opción para desactivar el límite de distancia de renderizado. (Se activa con `make NODRAWINGDISTANCE=1`.)
  14  * Configurar los controles desde el juego.
  15  * Posibilidad de saltarte la intro con la opción de línea de comandos `--skip-intro`
  16  * Menú de trucos (_cheats_) en _options_. (Se activa con la opción de línea de comandos `--cheats`) Ten en cuenta que si un cheat te pide pulsar el botón "L", se refiere al botón de N64, el cual tendrá que estar asignado a un botón de tu mando. Ve a los ajustes de control y asegúrate de que tienes "L" mapeado a un botón de tu mando.
  17
  18 ## Compilar en Windows
  19 **No intentes compilar ejecutables para Windows bajo Linux usando `WINDOWS_BUILD=1`. No va a funcionar. Sigue la guía.**
  20 #### 1. Instalación y configuración de MSYS2.
  21
  22 1. Descarga [msys2-x86_64-latest.exe](http://repo.msys2.org/distrib/msys2-x86_64-latest.exe) y ejecútalo. Si tu sistema operativo es de 32 bits (¿por qué?) descarga [msys2-i686-latest.exe](http://repo.msys2.org/distrib/msys2-i686-latest.exe) en su lugar. Asegúrate de que lo instalas en `C:\dev\msys64` (o `C:\dev\msys32` para 32 bits...). Ejecuta MSYS2.
  23
  24 2. En la ventana de comandos de MSYS2, ejecuta el siguiente comando:
  25     ```
  26    pacman -Syuu
  27     ```
  28 3. Abre "MSYS2 MinGW 64-Bit". Ejecuta este comando __repetidamente__ hasta que MSYS diga que ya no hay más actualizaciones. Es posible que tengas que volver a cerrar y abrir MSYS2.
  29
  30    ```
  31    pacman -Syuu
  32    ```
  33
  34 5. Ejecuta este comando y cuando te pida confirmación pulsa intro:
  35
  36    ```
  37    pacman -S --needed base-devel mingw-w64-i686-toolchain mingw-w64-x86_64-toolchain \
  38                        git subversion mercurial \
  39                        mingw-w64-i686-cmake mingw-w64-x86_64-cmake
  40    ```
  41 6. Listo.
  42 #### Instala las dependencias
  43 ```
  44 pacman -S mingw-w64-i686-glew mingw-w64-x86_64-glew mingw-w64-i686-SDL2 mingw-w64-x86_64-SDL2 python3
  45 ```
  46 ### Crea el directorio en el que preparar todo
  47 Desde el explorador de Windows, navega a `C:\msys64\home\(nombre de usuario)\` y crea una carpeta con el nombre que te apetezca. Aquí es donde vamos a preparar todo.
  48 ### Clona el repositorio
  49 En MSYS2, introduce el siguiente comando:
  50 ```
  51 git clone https://github.com/sm64pc/sm64pc/
  52 ```
  53 (Si no funciona, prueba a escribirlo manualmente, en lugar de copiar y pegar)
  54 #### Copia la ROM base al directorio correspondiente
  55 El paso anterior tiene que haber creado una carpeta llamada sm64pc. Dentro de esa carpeta, y para cada version de la ROM (jp/us/eu) de la cual quieras compilar un ejecutable, coloca la ROM con el nombre `baserom.<version>.z64` para extraer sus assets. Por ejemplo, `baserom.us.z64` para la versión americana, o `baserom.eu.z64` para la versión europea.
  56
  57 #### En MSYS2, vamos a navegar a la carpeta `./tools/audiofile-0.3.6/` y ejecutar el `autoreconf-i`. Introduce los siguientes comandos, en orden, uno a uno:
  58 ```
  59 cd sm64pc/tools/audiofile-0.3.6/
  60 autoreconf -i
  61 ```
  62 No te vayas de este directorio hasta el paso 9.
  63
  64 #### Ejecuta el script `configure`
  65 ```
  66 PATH=/mingw64/bin:/mingw32/bin:$PATH LIBS=-lstdc++ ./configure --disable-docs
  67 ```
  68 #### Ejecuta el script `make`
  69 ```
  70 PATH=/mingw64/bin:/mingw32/bin:$PATH make
  71 ```
  72 #### Crea un directorio `lib` en `tools/`
  73 ```
  74 mkdir ../lib
  75 ```
  76
  77 #### Acabas de compilar `libaudiofile`. Ahora cópialo a `tools/lib/`
  78 ```
  79 cp libaudiofile/.libs/libaudiofile.a ../lib/
  80 cp libaudiofile/.libs/libaudiofile.la ../lib/
  81 ```
  82 #### Ahora toca hacer algo desde Windows.
  83 En el explorador de Windows, ve a sm64pc\tools y edita el archivo Makefile desde un editor de texto (es recomendable usar un editor decente como Notepad++ o Sublime Text, en lugar del bloc de notas, para asegurarte de que no rompes el formato del texto) Busca la línea que contiene esto:
  84
  85 ```tabledesign_CFLAGS := -Wno-uninitialized -laudiofile```
  86
  87 Y añade ` -lstdc++` al final, de manera que quede así (¡no olvides el espacio!)
  88
  89 ```tabledesign_CFLAGS := -Wno-uninitialized -laudiofile -lstdc++```
  90
  91 Guarda el archivo.
  92 #### Vuelve a la carpeta tools y ejecuta `make` con los siguientes comandos.
  93 ```
  94 cd ..
  95 PATH=/mingw64/bin:/mingw32/bin:$PATH make
  96 ```
  97 #### Vuelve al directorio sm64pc
  98 ```
  99 cd ..
 100 ```
 101 #### Finalmente, ejecuta ```make``` de nuevo.
 102
 103 (Ten en cuenta que mingw32 y mingw64 han sido intercambiados. Esto es para que puedas compilar la versión de 32 bits si quieres.)
 104
 105 Aquí pones las opciones que quieras según la versión que quieras compilar. Por ejemplo, si quieres activar la cámara analógica, añade al final BETTERCAMERA=1. Si quieres la opción de distancia de renderizado ilimitada, añade NODRAWINGDISTANCE=1.
 106
 107 Por ejemplo:
 108 ```
 109 PATH=/mingw32/bin:/mingw64/bin:$PATH make BETTERCAMERA=1 NODRAWINGDISTANCE=1
 110 ```
 111 Listo. El .exe estará en sm64pc\build\. Disfruta.
 112 ## Compilar en Linux
 113
 114 ### Nota para usuarios de Windows
 115 No intentes compilar un ejecutable para Windows desde Linux o WSL. No funciona. Sigue la guía para Windows.
 116
 117 #### Copia la(s) ROM(s) base para la extracción de assets.
 118
 119 Por cada versión de la cual quieras compilar un ejecutable, copia la ROM en `./baserom.<versión>.z64` para extraer los assets.
 120
 121 #### Instala las dependencias.
 122
 123 Para compilar necesitas las sigueintes dependencias.
 124   * python3 >= 3.6
 125   * libsdl2-dev
 126   * [audiofile](https://audiofile.68k.org/)
 127   * libglew-dev
 128   * git
 129
 130 Puedes instalarlas con este comando:
 131
 132 ##### Debian / Ubuntu - (compilando para 32 bits)
 133 ```
 134 sudo apt install build-essential git python3 libaudiofile-dev libglew-dev:i386 libsdl2-dev:i386
 135 ```
 136 ##### Debian / Ubuntu - (compilando para 64 bits)
 137 ```
 138 sudo apt install build-essential git python3 libaudiofile-dev libglew-dev libsdl2-dev
 139 ```
 140 ##### Arch Linux
 141 Hay un paquete AUR (cortesía de @narukeh) disponible bajo el nombre [sm64pc-git](https://aur.archlinux.org/packages/sm64pc-git/). Instálalo con tu gestor de AURs preferido.
 142
 143 Si quieres compilarlo por tu cuenta:
 144 ```
 145 sudo pacman -S base-devel python audiofile sdl2 glew
 146 ```
 147
 148 ##### Void Linux - (compilando para 64 bits)
 149 ```
 150 sudo xbps-install -S base-devel python3 audiofile-devel SDL2-devel glew-devel
 151 ```
 152
 153 ##### Void Linux - (compilando para 32 bits)
 154 ```
 155 sudo xbps-install -S base-devel python3 audiofile-devel-32bit SDL2-devel-32bit glew-devel-32bit
 156 ```
 157
 158 ##### Alpine Linux - (compilando para 32 bits y 64 bits)
 159 ```
 160 sudo apk add build-base python3 audiofile-dev sdl2-dev glew-dev
 161 ```
 162
 163 #### Compila el ejecutable.
 164
 165 Ejecuta `make` para compilar (por defecto `VERSION=us`)
 166
 167 ```
 168 make VERSION=jp -j6                           # Compila la versión (J) usando 6 hilos
 169 make VERSION=us MARCH=i686 TARGET_BITS=32     # Compila un ejecutable de la versión (U) de 32 bits
 170 make TARGET_RPI=1                             # Compila un ejecutable para Raspberry Pi
 171 ```
 172 ## Compilar para la web
 173 Puedes compilar el juego para navegadores que admitan WebGL usando [Emscripten](https://github.com/emscripten-core). Para hacerlo, instala [emsdk](https://github.com/emscripten-core/emsdk) y ejecuta `make TARGET_WEB=1`.
 174
 175 ## Script para compilar para Raspberry Pi
 176
 177 [Hyenadae](https://github.com/Hyenadae/) ha creado un script que ayuda a compilar el juego para Raspberry Pi. Estos son los pasos que hace el script:
 178
 179   * Instala las dependencias;
 180   * Cambia VC4_DRM en la RPi de 0 a 3;
 181   * Cambia ajustes en la memoria de las RPis 0 y 1 para que se pueda completar la compilación;
 182   * Permite la instalación de un SDL2 con KMS, lo que elimina la necesidad de usar X11 y garantiza el máximo rendimiento de cualquier RPi que ejecute VC4;
 183   * Clona sm64pc si no encuentra los archivos necesarios;
 184   * Comprueba si existen los assets y la ROM base necesaria (baserom.*.z64);
 185   * Compila sm64pc.
 186
 187 El script está incluído en la rama master, pero también puede descargarse [aquí](https://raw.githubusercontent.com/sm64pc/sm64pc/master/pisetup.sh).
 188 # Problemas conocidos
 189 ### Problemas ya conocidos:
 190   * La versión EU tiene bugs en los textos y no tiene audio.
 191   * El movimiento analógico horizontal de la cámara vuelve al estilo antiguo en el nivel Bowser in the Dark World (#72)
 192   * La cámara con el ratón falla cuando disparas a Mario hacia un árbol o un tubo. (#71)
 193   * "make: Nothing to be done for 'default'" al compilar para web. (#67)
 194
 195 ### Estos problemas están marcados como solucionados. Por favor, contacta si sigues teniendo estos problemas.
 196   * El juego se llena de flags aleatorias en las builds de 64 bits para Windows
 197   * Hazy Maze Cave se cuelga en pantalla completa (#57)
 198   * La pantalla de título no tiene el cursor para manipular a Mario en pantalla completa. (#28)
 199
 200 ## Parches
 201 En la carpeta `./enhancements` hay varios archivos `patch`, que pueden aplicarse de la siguiente manera:
 202
 203 ```
 204  git apply fps.patch --ignore-whitespace --reject
 205 ```
 206 Si ocurre un rechazo, puedes buscarlo con el comando `find | grep .rej`.
 207 Intenta resolver los rechazos a través de [wiggle](https://github.com/neilbrown/wiggle).
 208 ```
 209 wiggle rejection.rej --replace
 210 ```