Someone just asked me regarding a certain port from ps2 to pc. Has anyone ever done a port from ps2 to pc? How difficult was it?

It's easier than making the same game from scratch, but harder than just recompiling the source code.

Without any other information about what you want to port, it's impossible to narrow it down further.

My experience is similar. We targeted console platforms, but several of our porting contracts had a (barely) functional PC version we used for development purposes. It lacked a bunch of stuff. You could only play in a window and you HAD to use a gamepad (mouse and keyboard didn't work at all). The main menu didn't quite work correctly - typically you would launch the game with the level identifier you wanted and it would just load directly there with basic character equipment. Cheat menus were added to do the rest.

Most of us had devkits though, since the large companies we contracted for had a huge stockpile of them and would ship them to us for the duration of the project.


Here's a handful of things I can think of off the top of my head, but there are likely more:

- Add mouse and keyboard support: GOOD camera controls, tooltip-icons for keys and mouse buttons, keyboard binding option screen (Us PC gamers hate it when you can't rebind keys).

- Add options menus with graphics options. Old PS2 games almost never had resolution or graphics detail settings, and us PC gamers ALWAYS notice and rightly complain about hastily ported games that overlook these.

- Redo textures at a higher res. PS2 texture quality is crap due to space limitations (the limit on PCs is much, much higher), and you should have artists spend some time increasing their quality.

- Redo meshes with more detail (try to keep the same rigs and animations though - some games had their animations tuned precisely to behave in specific ways, and changing these risks breaking the game's behavior in hard-to-detect ways).

- Add task-switching (ALT+TAB) support and a menu option to exit to the OS. PS2 games had neither. Alt+Tab support can be more painful than you'd think. Don't underestimate it.

- Make sure the game works with a variety of different gamepads, assuming you keep gamepad support from the original. PC gamepads come in a wide variety and they don't always work with identical code in the same way. Don't just assume everyone has a 360 controller.

- Depending on the graphics and sound libraries the original game used, you might expect to spend quite a lot of time fixing/replacing them for PC.

- File system stuff will be slightly different (easier). Many of the older consoles had memory cards which were a pain to deal with due to all of the possible hot-swapping cases you had to test for. You can probably comment out most of that stuff and just keep the no-free-space handling code. You'll likely want to add file system permissions checks.

- Add an Installer. PS2 games just insert the disk and run. On PCs you have to install them somehow (via Steam or via a disc or whatever).

- Test on Intel, AMD, and NVidia GPUs - as many different models as you can afford. Many a port has been ripped to shreds by gamers due to developers only testing on NVidia cards.

- If the game had an online matchmaking service (pretty rare back in PS2 days), it's likely no longer running. You'll need to host your own (or, if you're contracting for a publisher, have the publisher's online services team host it), and update URLs/IP addresses that the game uses to connect, OR take the drastic measure of ripping out multiplayer.

Also, if you don't have source code, then give up right now. I was once part of a PS2->PS3 porting project where the original developer lost the source code, and we had to abandon the project; trying to resurrect a game via decompiling MIPS disassembly is the worst thing ever when you have a tight budget and schedule.

If you're in this situation, use an emulator and call it quits.

And finally, don't assume the source code works.

I have had to port many games from one platform to another and often you get supplied what the developer "thinks" is the final source code.

Often it isn't and you have bugs to fix to get it to compile. (then bugs to fix that they shipped with...... sigh)

My process was very simple. I installed all the files and then created a brand new project for the new target platform.

Add the source code files a bit at a time. The shear volume of errors otherwise makes it impossible to deal with.

When you have a call into the underlying OS, add it to a header file and include the header in the source.

Just keep going until the whole project compiles, but doesn't link as all the OS specific functions are missing. You do now have a list of all the functions you need to create though.

Then write code for the missing functions and bingo you have something that links and runs, and probably crashes, but you have a starting point.

Making it a good game after that is a different kettle of kippers.