The Alfred Project

Purpose

This fork serves as a repository to store changes to the Slippi dolphin client to provide a sufficient pipeline to extracting frame by frame images created by Slippi. This will be fed into a deep learning model; front-end for the images and back-end for the Slippi data processed, afterwhich, the model will generate a JSON string that will be sent to Dolphin to be read.

To have everything transition smoothly, I had originally compiled the project to continually save screen shots in order to collect this data; at the time not knowing Slippi's underlying codebase was being controlled by the ASM codes provided. This README will serve as documentation on how to use Alfred and revisioning changes on what to expect in the coming months, enjoy.

Progress Table

Task	Status	Dated Last Updated
Build image extractor	Complete	03/01/2020
Extract stage, character specifics for training data	Complete	04/21/2020
Add argument for image extraction	Discarded	04/21/2020
Write network I/O For Dolphin	Complete	03/01/2020
Add function to send data image array with OutputComm	Complete	05/15/2020
Add function to send controller state with OutputComm	Complete	03/01/2020
Stress test UDP vs TCP implementation	Complete	04/21/2020
Update CMake files	Discarded	04/18/2020
Docker Dolphin Container w/ X11	Discarded	06/10/2020
Write Python code to parse chunked Pre/Post frame updates	Complete	05/30/2020
Write Python code to parse and convert image data to PNG	Complete	05/30/2020

Setup

Building

Follow the instructions listed below on building for your respective Operating System. Current development resides on an Ubuntu 18.04 test stack while Dolphin is X11 forwarded to my Windows PC.

Run the build.sh script that will construct a netplay dolphin folder, this is important as the settings configured in the script allow Dolphin to write Slippi file data; thus allowing image and Slippi data to be written through the sockets. After everything is built, the Dolphin emulator will setup socket communications for the following.

Input Communication (Located in User/Config/Dolphin.ini -> StartingPlayerPort) Port Range(s): 55082-55085 w.r.t Player(s)

Output Communication (User/Config/Dolphin.ini -> ControllerPort, SlippiPort, and VideoPort)

• Controller Port: 55079
• Slippi Port: 55080
• Video Port: 55081

I/O is configured for localhost (127.0.0.1), modifiable in User/Config/Dolphin.ini -> SendingIpAddress

• Later this will be changed to a configuration file located in either Sys or Usr *

Running Python

Coming soon...

Dolphin - A GameCube and Wii Emulator

Homepage | Project Site | Forums | Wiki | Issue Tracker | Coding Style | Transifex Page

Dolphin is an emulator for running GameCube and Wii games on Windows, Linux, macOS, and recent Android devices. It's licensed under the terms of the GNU General Public License, version 2 or later (GPLv2+).

Please read the FAQ before using Dolphin.

System Requirements

Desktop

• OS
  • Windows (7 SP1 or higher is officially supported, but Vista SP2 might also work).
  • Linux.
  • macOS (10.10 Yosemite or higher).
  • Unix-like systems other than Linux are not officially supported but might work.
• Processor
  • A CPU with SSE2 support.
  • A modern CPU (3 GHz and Dual Core, not older than 2008) is highly recommended.
• Graphics
  • A reasonably modern graphics card (Direct3D 10.0 / OpenGL 3.0).
  • A graphics card that supports Direct3D 11 / OpenGL 4.4 is recommended.

Android

• OS
  • Android (5.0 Lollipop or higher).
• Processor
  • An ARM processor with support for 64-bit applications. (An Intel x86 processor could also work in theory, but no known x86 devices support 64-bit applications.)
• Graphics
  • A graphics processor that supports OpenGL ES 3.0 or higher. Performance varies heavily with driver quality.
  • A graphics processor that supports standard desktop OpenGL features is recommended for best performance.

Dolphin can only be installed on devices that satisfy the above requirements. Attempting to install on an unsupported device will fail and display an error message.

Building for Windows

Use the solution file Source/dolphin-emu.sln to build Dolphin on Windows. Visual Studio 2017 is now used. Other compilers might be able to build Dolphin on Windows but have not been tested and are not recommended to be used. Git and Windows 10 SDK 10.0.10586.0 must be installed.

You will most likely have issues installing this, look at this comment for how to fix it. Not sure everything in it is a hard requirement.

If you have trouble with some .lib files missing, right click the Externals directory and click rebuild.

An installer can be created by using the Installer.nsi script in the Installer directory. This will require the Nullsoft Scriptable Install System (NSIS) to be installed. Creating an installer is not necessary to run Dolphin since the Binary directory contains a working Dolphin distribution.

Building for Linux and macOS

Dolphin requires CMake for systems other than Windows. Many libraries are bundled with Dolphin and used if they're not installed on your system. CMake will inform you if a bundled library is used or if you need to install any missing packages yourself.

macOS Build Steps:

1. mkdir build
2. cd build
3. cmake ..
4. make

An application bundle will be created in ./Binaries.

If you are building on Mojave or later, you will need to install the 10.11 SDK to build because Quicktime has been removed in the latest SDKs. Find the sdk version here https://github.com/phracker/MacOSX-SDKs and copy it to /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs. You should not need to modify the plist file as the project readme seems to indicate.

Linux Global Build Steps:

To install to your system.

1. mkdir build
2. cd build
3. cmake ..
4. make
5. sudo make install

Linux Local Build Steps:

Useful for development as root access is not required.

1. mkdir Build
2. cd Build
3. cmake .. -DLINUX_LOCAL_DEV=true
4. make
5. ln -s ../../Data/Sys Binaries/

Linux Portable Build Steps:

Can be stored on external storage and used on different Linux systems. Or useful for having multiple distinct Dolphin setups for testing/development/TAS.

1. mkdir Build
2. cd Build
3. cmake .. -DLINUX_LOCAL_DEV=true
4. make
5. cp -r ../Data/Sys/ Binaries/
6. touch Binaries/portable.txt

Building for Android

These instructions assume familiarity with Android development. If you do not have an Android dev environment set up, see AndroidSetup.md.

If using Android Studio, import the Gradle project located in ./Source/Android.

Android apps are compiled using a build system called Gradle. Dolphin's native component, however, is compiled using CMake. The Gradle script will attempt to run a CMake build automatically while building the Java code.

Uninstalling

When Dolphin has been installed with the NSIS installer, you can uninstall Dolphin like any other Windows application.

Linux users can run cat install_manifest.txt | xargs -d '\n' rm as root from the build directory to uninstall Dolphin from their system.

macOS users can simply delete Dolphin.app to uninstall it.

Additionally, you'll want to remove the global user directory (see below to see where it's stored) if you don't plan to reinstall Dolphin.

Command Line Usage

Usage: Dolphin [-h] [-d] [-l] [-e <str>] [-b] [-V <str>] [-A <str>]

• -h, --help Show this help message
• -d, --debugger Opens the debugger
• -l, --logger Opens the logger
• -e, --exec= Loads the specified file (DOL,ELF,WAD,GCM,ISO)
• -b, --batch Exit Dolphin with emulator
• -V, --video_backend= Specify a video backend
• -A, --audio_emulation= Low level (LLE) or high level (HLE) audio

Available DSP emulation engines are HLE (High Level Emulation) and LLE (Low Level Emulation). HLE is fast but often less accurate while LLE is slow but close to perfect. Note that LLE has two submodes (Interpreter and Recompiler), which cannot be selected from the command line.

Available video backends are "D3D" (only available on Windows) and "OGL". There's also "Software Renderer", which uses the CPU for rendering and is intended for debugging purposes only.

Sys Files

• totaldb.dsy: Database of symbols (for devs only)
• GC/font_ansi.bin: font dumps
• GC/font_sjis.bin: font dumps
• GC/dsp_coef.bin: DSP dumps
• GC/dsp_rom.bin: DSP dumps
• Wii/clientca.pem: Wii network certificate
• Wii/clientcacakey.pem: Wii network certificate
• Wii/rootca.pem: Wii network certificate

The DSP dumps included with Dolphin have been written from scratch and do not contain any copyrighted material. They should work for most purposes, however some games implement copy protection by checksumming the dumps. You will need to dump the DSP files from a console and replace the default dumps if you want to fix those issues.

Wii network certificates must be extracted from a Wii IOS. A guide for that can be found here.

Folder Structure

These folders are installed read-only and should not be changed:

• GameSettings: per-game default settings database
• GC: DSP and font dumps
• Maps: symbol tables (dev only)
• Shaders: post-processing shaders
• Themes: icon themes for GUI
• Resources: icons that are theme-agnostic
• Wii: default Wii NAND contents

Packaging and udev

The Data folder contains a udev rule file for the official GameCube controller adapter and the Mayflash DolphinBar. Package maintainers can use that file in their packages for Dolphin. Users compiling Dolphin on Linux can also just copy the file to their udev rules folder.

User Folder Structure

A number of user writeable directories are created for caching purposes or for allowing the user to edit their contents. On macOS and Linux these folders are stored in ~/Library/Application Support/Dolphin/ and ~/.dolphin-emu respectively. On Windows the user directory is stored in the My Documents folder by default, but there are various way to override this behavior:

• Creating a file called portable.txt next to the Dolphin executable will store the user directory in a local directory called "User" next to the Dolphin executable.
• If the registry string value LocalUserConfig exists in HKEY_CURRENT_USER/Software/Dolphin Emulator and has the value 1, Dolphin will always start in portable mode.
• If the registry string value UserConfigPath exists in HKEY_CURRENT_USER/Software/Dolphin Emulator, the user folders will be stored in the directory given by that string. The other two methods will be prioritized over this setting.

List of user folders:

• Cache: used to cache the ISO list
• Config: configuration files
• Dump: anything dumped from Dolphin
• GameConfig: additional settings to be applied per-game
• GC: memory cards and system BIOS
• Load: custom textures
• Logs: logs, if enabled
• ScreenShots: screenshots taken via Dolphin
• StateSaves: save states
• Wii: Wii NAND contents

Custom Textures

Custom textures have to be placed in the user directory under Load/Textures/[GameID]/. You can find the Game ID by right-clicking a game in the ISO list and selecting "ISO Properties".