🎵 Currently listening to… 🎧

👾 czip://retro.run/playstation_2 🏃‍♀️

😊 Hello again! 👋

Much has happened since I last wrote a retro_run, but I think I’d primarily like to focus on my PS2 ventures.

But first: I landed a new Trinitron PVM! This time a 19", which is a very noticeable upgrade from my 14". The model number has an ST suffix which I haven’t been able to find anywhere, but the few mentions I’ve seen of it online seem to indicate that it’s effectively identical to an MD model.

My old 14" didn’t support sync-on-green, and all I had otherwise was composite, so I never spent any time playing PS2 on my 14". The picture would be strongly tinted green, and I could tell that it was a sharp and good-looking picture otherwise, but I never got to experience it in all its beauty until coming across this new 19" PVM.

⚔️ Final Fantasy X ⚽

All of that said, I’ve had Final Fantasy X and a handful of other games tucked away in my closet for some time now. I never owned FFX myself as a kid, only occasionally finding the opportunity to play it on what was likely a 14" CRT, over composite, at the bottom of the stairs in an older friend’s unfurnished basement. (I remember that same friend would rage whenever he was killed in SOCOM II, though I’m sure I looked about the same at that time; I look forward to playing S2 again in the future nonetheless, but that’s a post for another day).

I’m only a few hours in but FFX is a stunningly gorgeous and engaging game. I hadn’t realized how highly regarded the game was until I went searching for other PS2 games to to try out and saw FFX at the top of players’ lists time and time again.

The game is somewhat known for its dialog being a little “strange” at times, with the main character’s laughing scenes cropping up throughout, but I don’t find that bothersome in the least. It’s a very cinematic game and it’s impressing how good the voice acting is given where voice acting in video games was at that time; a little cringe feels inevitable.

I’m invested in the storyline and I’m interested to see where it goes from here. I have a rough idea of how it all plays out but I’m still enjoying every minute of working through it first-hand, though I certainly do have a tendency of not finishing longer games; I suppose we’ll see!

👊 Bully 🎒

Bully was always one of those Rockstar games that I wish I had the opportunity to play as a teenager, but it always worked out that I was either spending my $7/hr paychecks on something else, and I never asked for it as a gift for the holidays; it was also released relatively late in the console’s life, and I recall moving quickly onto the PS3 when it became more affordable. I can say about the same regarding Max Payne, but I’ve since found the time to play a little bit of Max Payne 1 & 2 throughout the years, whereas I’ve never put any time into Bully – and not for a total lack of trying; I think the Bully being sold on Steam is sitting in my library and still broken to this day!

Anyhow, I managed to get Bully up and running on my PS2 after wrestling a bit with all of the different jailbreaking steps, which I’ll discuss shortly.

The game itself feels like a T-rated Grand Theft Auto, with teenage characters, and missions revolving around escorting a nerd to his locker to pick up some books, shooting jocks and bullies with a slingshot along the way, rather than escorting drug dealers and getting in shootouts or deadly car chases.

And… I’m really enjoying it!

I can’t say for sure if I’ll end up playing through the full game, as I’m only at 4% completion, but it’s an enjoyable game so far and I’m interested to see how it continues to unfold. It was worth all of my PS2 jailbreaking induced headaches :)

🔓 PS2 Jailbreaking 🕹️

💾 FreeMCBoot & FreeHDBoot 🆓

I’m not sure if it should be referred to as “jailbreaking” or “hacking” or “rooting” or however else, but the process of getting game backups running natively on a PS2 should be borderline trivial for most people in most situations.

First, I purchased a FreeMCBoot memory card from Kaico and essentially thought that was it – and it sort-of was! But then I wanted to put games onto an internal HDD and, this is where it gets a little difficult.

See, if you have a FreeMCBoot card, it’s actually not that difficult to get some games onto a FAT32-formatted USB drive, plug it in, and boot them from OPL (Open PS2 Loader). However, 1. many games cross the 4GB file-size limit, and you have to use a PC application to split these games up into multiple files 2. you’re stuck with USB 1.1 speeds, which is too slow for the vast majority of games.

I figured, this is easy enough, I’ll buy a network adapter that supports IDE drives, buy and install a SATA adapter, buy a 2TB HDD, and I’m golden; I can put my game backups on the HDD and boot from my “hacked” memory card!

This may have worked, but after seeing a game load from USB 1.1 for the first and only time on my console before shutting it off, that was the last time my FreeMCBoot card functioned; I’m told that this is not uncommon for unofficial PS2 memory cards. I had just set up the internal HDD and thought I was ready to rock before several hours of troubleshooting began that ultimately led me to give up on that memory card entirely.

What I found was an HDD image that already contained FHDB (FreeHDBoot, which seems to be identical to FMCB aka FreeMCBoot, except that it runs off of your HDD instead of memory card). The HDD image is meant to be used as a way to bootstrap your jailbreak: 1. write the hacked HDD image to your drive 2. boot to your drive 3. reformat your drive properly using the utility currently-installed on the drive 4. install FHDB properly. It’s quite a process, but surely it’ll be worth it?

🛑 Giving Up 😞

From here, I think that what led me down the path that I ultimately took was the lack of PS2 tools for Linux. Everyone and their mum seems to use Windows for this stuff, and indeed it’s possible to make do with what’s what’s available on Linux, but my feeling is that you’re expected to know what the end result is supposed to look like, and to be familiar with the Windows equivalent applications. In other words, there’s far less hand-holding; for someone in my situation (very new to PS2 jailbreaking), this just wasn’t working out.

I think I manually copied a game or two over the USB port onto the HDD and didn’t see it work. Then I spent a while trying to figure out how to network my PS2 to copy games via FTP or some other method, but my FTP client would always sit and churn waiting for acknowledgement from the PS2 that would never come… until I shut down the FTP server and the client would come back and say that it’s ready to start transferring files before quickly terminating the connection.

But I did find a solution, eventually.

💡 Solution: SMB 📂

It was right in front of me all along! OPL (Open PS2 Loader) doesn’t just support booting games over USB or the internal HDD, but it also supports booting games over the network via SMB – and that SMB server can be hosted either on my PC or on my NAS, and it just so happens that I typically store all of my games on my NAS anyways.

iso2opl was also really handy through all this; simply use iso2opl SCAN to fix the naming for an entire directory of ISOs.

OPL takes care of nearly everything for you from here. You can take a look at your game options and enable features like using a virtual memory card (stored by your SMB server!) as well. There’s also no need to break the ISOs up into smaller files. The only real expectation is that your ISOs are organized into DVD and CD directories, as is the typical expectation for OPL.

🎮 PS1: POPS & POPStarter 📀

✨ POPS & POPStarter introduction 📘

When I realized that running PS1 games in a similar fashion was a possibility, I put a lot of effort into pursuing it. I learned a lot along the way and I wanted to just get some information written down here for either myself or others to reference later. It will probably help if I explain what the goal is here and provide some context.

Playing PS1 backups on your PS2, making use of the native PS1 chip, is not trivial. Because of this, it is not typically done, and this section will not be discussing running PS1 backups natively.
POPS is the official Sony PS1 emulator made for running on PS2 hardware.
Most gamers resort to using POPS (via POPStarter) to emulate PS1 game backups on their PS2 rather than running PS1 game backups “natively.”
POPS requires that games are in VCD format, rather than the typical BIN/CUE or ISO or IMG formats.
Many applications exist to aid in building VCDs; On Linux, I use cue2pops and a script I’ll share at the end of this section.
POPStarter is essentially a wrapper for POPS; POPS is running the game, whereas POPStarter is telling POPS what game to run.
You are responsible for sourcing POPS yourself, as it is a proprietary Sony product and therefore cannot be shared around freely due to copyright.
POPStarter supports running from USB, HDD, as well as SMB. To keep things relatively uniform, I opted to stick to SMB.
There’s a very nifty POPStarter w/ SMB quick start guide that covers configuring POPStarter to boot games over SMB.
POPS does not support every game perfectly. Here is a relatively short SMB compatibility list, and here is a longer USB/HDD compatibility list.
POPS compatibility can be improved via the hugopocked fixes. Download the “outdated patches” RAR, extract, and read the readme; the fixes can be applied by simply copying these files alongside each game’s virtual memory cards.

⚙️ POPStarter w/ SMB configuration 📁

And some further information regarding POPStarter w/ SMB:

The POPStarter configuration lives in a directory on your memory card, even if you use FHDB and store everything else on your HDD.
The POPStarter configuration can live on either mc0 or mc1; it will use whichever configuration it finds first.
The games themselves live on your SMB server inside of a POPS directory.
The memory cards will be created after the first time you start a game, also inside of the POPS directory; each game gets its own cards.
Each game requires an associated POPStarter ELF which is used to launch that one specific game.
The POPStarter ELFs can be stored on a USB stick, or on your memory card, or on your HDD; wherever you’d like! Whatever is easiest for you.
The POPStarter ELF must be named SB.Game Name.ELF, which would be associated with your smb0:/share name/POPS/Game Name.VCD VCD.
This is all very case-sensitive!

🤖 Helper scripts 📝

Here’s a simple script to aid in building VCDs when a .cue file is not present. I’d like to get multi-part .bins working and update this script accordingly, but for now it only works with a single .bin.

#!/bin/bash

# Check if a .bin file is provided as an argument
if [ -z "$1" ]; then
    echo "Usage: $0 <input_file.bin>"
    exit 1
fi

# Get the input .bin file and its directory
input_bin="$1"
bin_dir=$(dirname "$input_bin")
bin_filename=$(basename "$input_bin")
cue_filename="${bin_filename%.bin}.cue"
cue_path="$bin_dir/$cue_filename"

# Check if the input file is a .bin file
if [[ "$input_bin" != *.bin ]]; then
    echo "Error: The input file must be a .bin file."
    exit 1
fi

# Check if the .bin file exists
if [ ! -f "$input_bin" ]; then
    echo "Error: The file '$input_bin' does not exist."
    exit 1
fi

# Check for an associated .cue file
if [ ! -f "$cue_path" ]; then
    echo "No associated .cue file found. Creating a new .cue file..."

    # Create the .cue file with the required format
    echo "FILE \"$bin_filename\" BINARY" > "$cue_path"
    echo "  TRACK 01 MODE2/2352" >> "$cue_path"
    echo "    INDEX 01 00:00:00" >> "$cue_path"

    echo "Created '$cue_filename'."
fi

# Call cue2pops with the .cue file
echo "Calling cue2pops with '$cue_filename'..."
cue2pops "$cue_path"

And a simple script to create an associated ELF for each VCD:

#!/bin/bash

vcd_dir="/mnt/PS2/POPS" # This is your SMB share
elf_dir="/mnt/sdc1/POP" # This is where you store your ELFs (eg: USB stick)
base_elf="$elf_dir/BASE.ELF" # This is a POPStarter ELF

# Check if the base ELF file exists
if [ ! -f "$base_elf" ]; then
    echo "Error: BASE.ELF not found in $elf_dir."
    exit 1
fi

# List all .VCD files in the specified directory
for vcd_file in "$vcd_dir"/*.VCD; do
    # Extract the base name without extension
    vcd_name=$(basename "$vcd_file" .VCD)
    
    # Construct the associated ELF filename
    elf_name="SB.$vcd_name.ELF"
    elf_path="$elf_dir/$elf_name"
    
    # Check if the ELF file already exists
    if [ -f "$elf_path" ]; then
        echo "ELF file already exists: $elf_path"
    else
        # Copy BASE.ELF to create the new ELF file
        cp "$base_elf" "$elf_path"
        echo "Created ELF file: $elf_path"
    fi
done

🔚 Conclusion & Onward 🚀

I see so much potential. For example, OPL appears to be written in pure C, and there was once a version of it that contained experimental POPStarter support that has since been removed. It doesn’t seem that difficult to write something that, for example:

Lists the PS1 VCDs present in the POPS SMB directory.
User selects a VCD.
OPL checks to see if there is an associated POPStarter ELF. If so, launch it, if not…
OPL creates an associated POPStarter ELF from a BASE.ELF and launches it.

Or perhaps, similar to its support for tweaking PS2 games, it could support a GUI that gives access to all of the different hugopocked fixes.

Recently I’ve also been purchasing and practicing some basic electronics stuff, as I’d like to be able to do something like recap an old console or purchase a broken PS2 and fix it. This has been taking more of my time and attention lately so it’s very difficult to say that it’s worth the time to pursue this sort of contribution to a PS2 project, considering my complete unfamiliarity with the codebase and with coding on PS2 in general… and the fact that POPS is still emulation at the end of the day; it’s really cool that it can run on the PS2, but there are better ways to play PS1 games.

Anyhow, I just wanted to share what I’ve been up to in the land of retro games. I sincerely appreciate you taking the time to read this, and I look forward to writing about this topic again in the future!

c.zip

Previous:
seinfeld, github, dotfiles, wow!

Next:
Zelda 64 Code Spelunking with Ben Villalobos