Krome Studios Merkury Engine

Edit on Github | Updated: 6th October 2025

The Merkury engine is a proprietary game engine developed by Krome Studios since at least 2001, known to run on PS2, PSP, Wii and with version 3 of the engine it added support for Xbox 360 and PS3. It is likely also running on the Nintendo Switch thanks to the recent port of Star Wars: The Force Unleashed to the console.

Nowadays new games are developed in Unity at Krome Studios (e.g Ty the Tasmanian Tiger 4) rather than the Merkury engine, but remaster of older games are still being relased based on the Merkury engine so Krome Studios are still activly developing with it.

It is best known for the custom versions of Star Wars: The Force Unleashed on less powerful consoles, because the LucasArts version for Xbox 360 and PS3 was too demanding to port directly to PS2, PSP or Wii. Because a significant installer base remained for those consoles, LucasArts opted to outsource a custom version to Krome, using their existing engine architecture under the name Merkury

Origin of the Merkury Engine

The Merkury engine is first listed on the official Krome Studios website sometime before March 2001 (when it was archived by the wayback machine) where it claimed the engine had been in development for 3 years ¹, so this would put the creation of the Merkury engine around with 1998 or 1999, depending on when the text was written on the website.

There are at least three known major versions of the Merkury engine:

• Version 1 (1998/1999) - Originally called BEAST (and the 3d library Blast Graphics) created around 1998 or 1999
• Version 2 (2004) - Created for Ty the Tasmanian Tiger 2
• Version 3 (2010) - Created for The Legend of the Guardians: The Owls of Ga’hoole around 2010

Merkury Engine 1.0 features

On the official website archived on March 3rd 2001, it called Merkury a “world-class 3D game engine” ¹ and it listed the featues of the engine as:

• Soft-Skinned Skeletal Animation System
• Simultaneous Independent Animations
• Mesh Morphing and Animation Morphing
• Full Support For implementation Of 3D Studio MAX Meshes And Animation
• Support For Hardware Transformation And Lighting
• Real-time Shadows
• Full Particle Library Using Realistic Motion Simulation.
• Advance Material Management System
• Real-time Collision System
• Indoor And Outdoor Environments
• Multi-Platform
• Multi-Genre
• Multiple Field Of View

The first game that is oficially credited as using the engine is the Windows version of Championship Surfer from 2000 with Tony Ball being listed as the Merkury engine programmer in the credits section of the manual.

Programming the Merkury engine

The Merkury engine was built in C++ with a few modules written in Assembler, with simultanious development of the engine on multiple platforms at once (Windows, PS2, GameCube and Xbox) ².

On the port of the Merkury engine to GameCube for Ty the Tasmanian Tiger, Chris Lacy had the following to say in an interview with Nintendo World Report (NWR):

In about July of last year (2001) we received our first GameCube DevKit, which was very exciting for me, especially because I had been following the development of “Dolphin” since the PlanetN2000 days when Rick first broke the story about the codename for the project. To see it in person was so cool.

Within a couple of weeks, Tony Ball, our GameCube engine lead, had the character animating and drawing and doing most of what was doing in the PS2 version. A couple of months went by and by that point the GameCube version of the Merkury engine was pretty much inline with the PS2 version, so from then on development was simultaneous between the PS2 and GameCube, and later Xbox versions of the game.

Early Merkury Engine Games

The original Krome Studios website archived back in March 2001 has the following games as using the Merkury engine ¹:

• Mike Stewart’s Pro Bodyboarding - Released in February 1999 for Windows
• Chronicles of Jaru Tenk - Released in 1999 sold as shareware via ScreenOpera
• Spirit Board - Released in 1999 sold as shareware via ScreenOpera
• Championship Surfer - Released in 2000 for Windows
• Kat Burglar - Never released
• Gruesome Castle - Never released but in development in 1998 (Gruesome Castle - Unseen64)

However the only actual reference in the game files for the name Merkury was in the 2000 windows release of Championship Surfer. The rest of the games refer to a game engine called BEAST and a 3D engine called Blast Graphics which we believe was simply just renamed to Merkury sometime during the development of Championship Surfer.

Krome Studios games and their engines

Because not all uses of Merkury are documented, below is a table of major titles developed by Krome Studios across platforms. This is a reference for potential engine use, not confirmation of Merkury integration.

History of Krome Studios

The company was originally founded as Interactive Binary Illusions in 1993 ³, then renamed Gee Wizz! entertainment in 1996 on the release of their game Zombie Wars ⁴, it was formed by partners John Passfield and Steve Stamatiadis ⁵. It later became Krome Studios on the 1st November 1999 merging with Robert Walsh’s Pacific Interactive Entertainment ⁶.

Despite all the evolution, the studio continued to be based in Brisbane, Australia.

Interactive Binary Illusions (1993-1996)

Interactive Binary Illusions (IBI) released their first game all the way back in 1993 called Alien Carnage (also known as Halloween Harry), followed by the graphic adventure Flight of the Amazon Queen in 1995 ³.

They were working on a third title called Stereo Jack for planned release in 1996, however due to lack of funding it has to be cancelled and the pair instead formed a new company called Gee Wizz! entertainment.

Halloween Harry (1993) - Alien Carnage

Halloween Harry was a join effort between SubZero Software (later became Mind Mechanics ⁷) and Interactive Binary Illusions, the game itself later got renamed to Alien Carnage to avoid the consumer thinking it was a game that could only be enjoyed on October 31st.

John Passfield’s site has Alien Carnage (Halloween Harry) on the Free Stuff! - Passfield Games page but there is no download link, presumably the copyright of the game is owned by Apogee.

Flight of the Amazon Queen (1995) - JASPER engine

Flight of the Amazon Queen was released for DOS and Amiga in 1995 and then later Windows (2004), iPhone (2009), Mac (2013) and even Linux in 2021! ⁸.

Since the company was so small the copyright for these games is owned by the two co-founders of IBI and John Passfield has generously uploaded the original version of Flight of the Amazon Queen to his personal website which you can download completely free from his Free Stuff! - Passfield Games page!

We also highly recommend you buy the recent iOS re-release of the game on the App Store as its incredibly cheap and a great game to play on the go, along with supporting that amazing industry veteren Mr Passfield, a link to it is also available on his Free Stuff! - Passfield Games page.

JASPAR (Queen) game engine

The game was built with a custom game engine called JASPAR (John And Steve’s Programmable Adventure Resource) and John even wrote some game editor tools ⁹:

• JOKER - JASPAR Object Kernel Editor Resource - Game Editor for building rooms (laying out of objects and actors and walk paths, etc) - may have worked with .JAS files
• CUTS - Game cutscene editor (it was also called ASE in Flight Of The Amazon Queen - Hall Of Light not sure if this is a typo or an alternative name) worked with .CUT files
• DOG - Dialogue Object Generation System - Conversation tree editor works with .DOG files

The game was first written in AMOS BASIC, then converted to C code for the final Amiga build, then the PC version was a port of this C code by Tony Ball. According to John the C code contained a lot of emulated AMOS function calls and game was still edited on the AMIGA using JOKER as they were still all written in AMOS BASIC ⁹. It was compiled using the WATCOM C toolchain accorsing to strings in the Queen.exe file.

In March 1997 they mentioned working on the new version of the engine JASPAR2 for their new game The Elf Lord’s Bane Quest Saga which sadly never got released ¹⁰.

The engine was the second non-LucasArts engine added to ScummVM on September 28th 2003 in version 0.6.0 where they called it the Queen engine due to the only game that used it was the Flight of the Amazon Queen and they possibly didn’t know about it being called JASPER at the time. The engine supports all known DOS and Amiga versions of the game, including multiple languages and demos ¹¹.

For more information, you absolutely must read John’s blog post on the making of the game Game Musings: Making of Flight of the Amazon Queen - A 20th Anniversary Retrospective

What I also thought was super cool was at the end of John’s 2015 blog post he teased an Apple Watch version of the game with this screenshot:

However it was never released due to John realizing that there’s no market on the watch for this kind of game., which is sad because I would love to have seen how well this works on a watch, maybe adverture games are the perfect candidate for watch games? Although to be honest although I own an apple watch I have never downloaded a game for it… maybe I need to be the change I want to see in the market.

As facinating as the JASPAR engine is, this page is about Merkury and none of the Interactive Binary Illusions games have any hint of the Merkury (or Blast graphics) engines so lets keep going.

Gee Wizz! entertainment (1996-1999)

In 1996 Gee Wizz! entertainment was born and during their run until they become Krome Studios in 1999 they released the following games:

• Zombie Wars - 1996 on Windows, a sequal to Alien Carnage/Halloween Harry written in Delphi
• Mike Stewart’s Pro Bodyboarding - February 1999 on Windows
• The Chronicles of Jaruu Tenk - October 1999 on Windows (sold via ScreenOpera)
• Halloween Spirit Board - October 1999 on Windows (sold via ScreenOpera)

The original Gee Wizz! entertainment site from back in March 1997 has the following to say about each of the original team members ⁵:

# Steve Stamatiadis
Steve started out working in the comics field before he got into computer game design and graphics. After studying animation he worked on comics like The Statlight agency, Markam and even a did a short stint on From Hell as a background artist. In 1991 he worked on the movie Fortress after which he and John began work on Flight of the Amazon queen (which was done on a lowly Amiga). Today at Age 27 he is responsible for the look of Gee whiz! games and gets to work with more powerful machines and software to create really cool stuff.

# John Passfield
John had his first computer game published in 1985 at the ripe old age of 17. He later studied computer science and worked as a programmer for a telecommunications company before co-founding Gee Whiz! Entertainment. John prefers to think of himself as a member of the "Star Wars Generation" rather then "Generation X". John likes to write comic books - his credits include a two year stint writing Dingo Boy and Vixen Rangers for one of Australia's largest selling magazines, Stereo Jack for Issue One Comics and Jace Riegel for Dark Horse Comics.

# Robert Crane
Robert is a 24 year old programmer who spent his whole life dedicated to the cause of proving that Pascal is every bit as good as "C" as a programming language. In the process he has developed an install program for DOS that games publisher Apogee picked up and uses for its shareware titles. He is also an acknowledged database programmer but likes to keep that secret. His strongest point is doing graphics tools like game systems and sprite editors. Being around so much graphics, he also likes to dabble in 3d modeling.

# Tony Ball
Tony has worked on many games, some of which actually made it onto the shelves, including Halloween Harry, Alien Carnage and Flight of the Amazon Queen. He specializes in 'C' and Intel Assembly, particularly graphics code, and is currently working on some really cool stuff with Gee Whiz! Entertainment.

Zombie Wars (1996)

Zombie Wars was a sequal to Halloween Harry released in 1996 and written in Delphi, it has the codename Harry95 left in the executable.

Pratik Anand has reverse engineered the assets for Zombie wars and has an excellent write up here: Detective work on Reverse Engineering obscure 16-bit Windows game (Zombie Wars) · Pratik Anand

Sadly they found that reverse engineering an old Delphi executable is not easy with most modern tools. It is likely build using a very early version of Delphi such as 1.0 (1995) and their are tools that can help recovering the source files for Delphi 2.0/3.0 from compiled executables such as EXE2DPR - Delphi project sources Rescuer, but I don’t know of any software that works on 1.0 executables unfortunetly.

It was built using the Microsoft WinG library, which was the original name for DirectX. It also uses a library from SubZero Software with a build date of 4th December 1995. Since its assets are all stored in .SUB0 archives this hints at a library for packing game assets, SubZero Software are also listed as a join developer on the original Halloween Harry game.

For the limited analysis of the binary I can do there doesn’t seem to be any connection between the game and what would become the Merkury engine or the 3d library Blast Graphics) and it was written in a completely different programming language so it is unlikely there is a strong connection.

Delphi Programming

Robert Crane was a big fan of the Delphi programming langauge (Object Oriented version of Pascal) and exclaimed the following on the company website back in 1997 ¹⁰:

Let me say that if it wasn’t for Delphi, this project would have been a nightmare of great proportions. If there are any sceptics of what Delphi is capable of, wait ‘til they see Zombie Wars.

Since all the coding of Zombie Wars (excluding graphics routines) is up to me, I have been REALLY busy just keeping up with the graphics that Steve does. I guess it is a little easier this time around because most of the code was a direct port from the old Halloween Harry. I am glad we chose to do the sequel though because I’ve added some really cool stuff to the engine.

BEAST & Blast Graphics - The Original Merkury engine

Many of the games listed on the official website in 2001 as being Merkury engine games refer to the engine under a different name BEAST and Blast graphics. Later on Krome would come to retroactivley refer to these games as based on the Merkury engine.

In the Help file for Mike Stewart’s Pro Bodyboarding it lists two libraries used for making the game, BEAST and Blast Graphics:

• Beast Game Engine Copyright © 1999 Mind Mechanics
• Blast Graphics 3D Engine Copyright © 1999 Tony Ball

BEAST Game Engine

The BEAST game engine was built by Mind Mechanics (SubZero Software) and was used for Mike Stewart’s Pro Bodyboarding and the surfing games that used the same engine.

In Championship Surfer we can clearly see the engine was called BEAST: // For use with the BEAST Game Engine and contained a file called beast.cfg which is a plain text file with the text BEAST Config File at the top.

It was always compiled into the main game executable so unlike the Blast Graphics 3d library we don’t have a lot of information on what functions it contained.

What we do know is a few of the source file paths which were left in the Dreamcast version of championship surfer:

• C:\Src\beast98\beast98.cpp - Dreamcast version of championship surfer
• C:\Src\beast98\animscript.cpp - Dreamcast version of championship surfer
• d:\beast\FUNCDECS.CPP - Inside Mike Stewart’s Pro Bodyboarding Dso.bnk

And from a crash log output found on the Russian Disc called Classic Fond 58 we have:

BEAST::Timer1Timer
 BEAST::RunHub
  BEAST::DoLogics
   GAME::Main
    GAME::B4MainMenu
     GAME::PlayASong
      BEAST::vLoadSFX
       BEAST::myhandler

Release/beast98.exe
NB11P
.\Release\beast98.res
.\Release\StdAfx.obj
.\Release\INSIDEPOly.obj
.\Release\Filebank.obj
.\Release\dxinput.obj
.\Release\diskio.obj
.\Release\beast98.obj
.\Release\animscript.obj

Microsoft CVTRES 5.00.1720.1
C:\beast\INSIDEPOly.CPP
C:\bg\Filebank.cpp
C:\beast\dxinput.cpp
C:\beast\diskio.cpp
C:\beast\beast98.cpp
C:\beast\animscript.cpp

Blast Graphics 3D library (bg.dll)

The Blast Graphics 3d library, which is 3D library used in early Merkury engine games is either located in the bg.dll file or compiled statically in the executable.

The following games have references to Blast graphics in their executables or contain the windows dynamic library bg.dll:

• Gruesome Castle Demo - bg.dll dated 12th January 1998 (96 KB, 361 functions)
• Mike Stewart’s Pro Bodyboarding (Australian version) - bg.dll dated 30th May 1999 (258KB, 489 functions)
• Halloween Spirit Board - bg.dll dated 12th September 1999 (369KB, 1018 functions)
• The Chronicles of Jaruu Tenk - bg.dll dated 8th Oct 1999 (360KB, 1020 functions)
• Mike Stewart’s Pro Bodyboarding - bg.dll dated 26th October 1999 (352KB, 1019 functions)
• Championship Surfer - bg.dll dated 28th September 2000 (217KB, 613 functions)
• Disney’s Extremely Goofy Skateboarding - Blast Graphics is compiled statically in the executable, dated 23rd August 2001

Known Blast Graphics Source files

Thanks to compilers adding some additional metadata we know at least some of the file names that made up the source code for the Blast Graphics Library:

• C:\bg\Bgunit.cpp - From MSPB (Aus) Along with .\Release\Bgunit.obj and C:\bg\bgunit.h

Known Blast Graphics functions

Looking at the exports table of one the the dlls we know it has the following functionality:

Although Blast Graphics was a 3D library it also contained alot of game engine functionality such as sound, keyboard input, AVI video playback, animation and more.

Mike Stewart’s Pro Bodyboarding (February 1999)

Mike Stewart’s Pro Bodyboarding (MSPB) was released to good reviews and would become Gee Whiz! Entertainment’s greatest accompllishment as a studio until they went on to become Krome Studios in November of the same year.

The official Krome Studio’s website from 2001 claimed that it was using the Merkury engine, but analysing the game files has no mention of the Merkury engine and instead seems to be using a custom engine called BEAST and Blast Graphics for the 3D.

It has a file called beast.cfg which has the following string at the top: BEAST Config File (c) Copyright 1999 Mind Mechanics. Note that the next game that used the same engine, Championship Surfer had the name of the engine as Beast98 during development, the 1998 version of the BEAST game engine.

As for Mind Mechanics, they were previously known as SubZero software and had worked on multiple games with Gee Whizz! in the past. Including the Halloween Harry series and their website talked about plans for a 3rd in the series that was 3D, until their site went down at the end of 1999 (when Krome Studios was formed). They are also known for their game Rapid Glider The Race to Galamax ⁷.

We at least know that the wave generation engine was used in three games, as on the website announcing their new PS2 game Sunny Garcia Surfing it proudly announces it :

Ground breaking, 3rd generation, proprietary wave generation engine, first seen in Mike Stewart’s Pro Bodyboarding, then in Championship Surfer, creates stunningly realistic wave sets in full 3D.

The Chronicles of Jaruu Tenk (October 1999)

On 10th of September 1998, Gee Whiz! Entertainment released a press release announcing that they were working on a new 3D title called The Chronicles of Jaruu Tenk with a planned release date of 4th Quarter 1998, however like most ambitious game project it was actually released later on 4th October 1999 ¹².

It was later released for free by John Passfield on his site Free Stuff! - Passfield Games and is still available to this day for everyone to enjoy!

Screen Opera

It was so unique that they coined their own genre: “Screen Opera” and it was followed by another game in the same genre very shortly after called Halloween Spirit Board. They also planned a third “Screen Opera” game called Star Date but it was never released.

It was inspired by David Crane’s Little Computer People and then sold on their own Screen Opera website ¹³.

Game engine - Merkury or Blast Graphics?

The was written in either C or C++ and it is built using DirectX 7 and likely Visual C++ as it uses the Microsoft Visual C++ Runtime Library.

The interesting thing about the game is it was listed as a Merkury engine game on the official Krome Studios website back in 2001 ¹. So if this was built in 1999 then it makes it one of the earliest games based on the Merkury engine!

Although the name “Merkury” wouldn’t appear until the founding of Krome Studios so it used the name Blast Graphics for the 3D engine with the functionality contained in bg.dll. See the Blast graphics section for more information.

Some notes about Jaruu:

• It uses .MAD files for Material Data same as other early Merkury engine games

Halloween Spirit Board (October 1999)

Released on the 25th October 1999 for a price of $9.95 USD Halloween Spirit Board, it was the second game that Gee Wizz! created in a genre that they called “Screen Opera” ¹⁴, the first being Jaruu Tenk. Similar to Jaruu Tenk, you can download the game for free on John Passfield’s site: Free Stuff! - Passfield Games.

Although it is odd that both Jaruu Tenk and Halloween Spirit Board were released in exactly the same month but that is what their official press releases say ¹⁴.

Championship Surfer (November 2000) - First game to officially call the engine Merkury

Championship Surfer is a 2000 game available for Windows, Dreamcast (2001) and PS1 (2001), the Windows and Dreamcast versions are the first game credited as using the Merkury engine, with no mention of the engine for the PS1 release.

However it is presumed some of the code was re-used between the Windows and PS1 games so it is likely that even the PS1 version is using some Merkury engine code.

PS1 version of Championship Surfer

The PS1 version of Championship Surfer (SLUS_012.16) has no mention of the Merkury engine and it was developed by a compeltely different set of programmers at Krome:

• Tyrone McAuley - Lead programmer
• Daniel Sewell
• Craig Herring
• David Gilligan

Assets in the PS1 version

The PS1 version does not use the RKV archive format and instead has files seperately on the disc in various PS1 optimized file formats (e.g TIM).

This is common with PS1 games as they all use a standard ISO 9660 filesystem, allowing individual files (textures, models, audio, maps, scripts, etc.) to be stored as separate, accessible files.

This makes it easy for the game executable to read specific assets directly from the disc and was practical considering memory limits and the way the PS1’s BIOS exposed disc access.

Windows, Dreamcast versions of Championship Surfer

The Windows and Dreamcast versions of Championship Surfer (2001) is the first game credited as using the Merkury engine, with Tony Ball being listed as the Merkury engine programmer in the credits.

It is also the first game that uses the RKV archive format (still never found out what it stands for) in both the Dreamcast and Windows versions, see the section below for the format of these archives as they differ from later Merkury engine games that use the same file extension (.rkv).

Beast98 and HotWaves

Thanks to strings left in the Dreamcast version of the game we know that the main game specific code was in a folder called gamecode under the 1998 Version of their BEAST game engine called beast98. Interestingly call the game HotWaves internally which is a nice nod to Mattel who own the Hot wheels franchise and were also the publisher for this game!

The executable has a few paths left intact which give a hint as to the folder structure:

The PC version also used the Beast98 code even although the strings above were stripped from the binary, we know this as there was a crash.log file left in the Surf_PC.rkv archive:

("C:\src\beast98\PCRelease\Hotwaves.exe" -windowed -lang=2 -nomusic)
 > Exception !!
C:\src\beast98\gamecode\game.cpp @ 3055

Frontend Menu Library

A few paths in the dreamcast version hint at there being a menu library for the main screens (frontend) with the following source files:

• C:\src\FrontEnd\Source\KMenuResources.cpp
• C:\src\FrontEnd\Source\KMenuWinner.cpp
• C:\src\FrontEnd\Source\ktile.cpp - contained KTile class
• C:\src\FrontEnd\Source\ktilescreen.cpp - contained KTextureTile, KTextTile and KTextBoxTile
• C:\src\FrontEnd\Source\KMenuCredits.cpp - Credits screen
• C:\src\FrontEnd\Source\KMenuSelectBeach.cpp - Beach Selection screen
• C:\src\FrontEnd\Source\TestGameScoresScreen.cpp
• C:\src\FrontEnd\Source\LanguageScreen.cpp - Language selection screen
• C:\src\FrontEnd\Source\Shine.cpp
• C:\src\FrontEnd\Source\FrontEndTileScreen.cpp - contained KMenuItemTile, KShadowTextBoxTile, KOutlineTextTile

Standard Platform Library

A few paths in the dreamcast version hint at there being a standard platform library with the following source files:

• C:\src\StdPlatform\DataInputStream.cpp
• C:\src\StdPlatform\FileInputStream.cpp
• C:\src\StdPlatform\IncludeFilterStream.cpp
• C:\src\StdPlatform\StdString.cpp
• C:\src\StdPlatform\StringXlat.cpp
• C:\src\StdPlatform\DirectXConsoleInput.cpp
• C:\src\StdPlatform\StdProfiler.cpp
• C:\src\StdPlatform\FileSystemTOC.cpp
• C:\src\StdPlatform\FileArchive.cpp

Krome’s Dreamcast Blast Graphics (BG) library

Also a few file paths are related to Blast Graphics which uses DirectX 7 on Dreamcast:

• C:\src\Bg\bg.cpp
• C:\src\Bg\bgsound.cpp
• C:\src\Bg\system.cpp
• C:\src\Bg\animate.cpp
• C:\src\Bg\colormap.cpp
• C:\src\Bg\camera.cpp
• C:\src\Bg\vmu.cpp
• C:\src\Bg\PlayVideo.cpp
• C:\src\Bg\waves.cpp - functions like BG_Wave_Create, very specific to surfing games!
• C:\src\Bg\Rain.cpp
• C:\src\Bg\SimpleObject.cpp - looks like the base object for a bit of Object Oriented Programming in the game engine!
• C:\src\Bg\collisions.cpp - presumably collision detection functions
• C:\src\Bg\bmp.cpp - contains LoadBMP function
• C:\src\Bg\loadvq.cpp - Loads VQ texture files with LoadVQ()

Based on other debug strings from error messages we know that the BG library contained the following functions:

• BG_GetHardware()
• BG_AllocObject()
• BG_FreeObject()
• BG_LoadObject()
• BG_Init()
• BG_PushBkg()
• BG_Exit()
• BG_CreateFont()
• BG_LoadMatProperties()
• BS_AllocSound()
• BG_LoadAnimation() - takes in object, skeleton and vat filenames
• BG_LoadColorMap() - takes in a filename to load
• BG_LoadCameraTrack() - takes in a filename to load
• BG_Wave_Create()
• BG_Wave_LoadAnimation() - loads ASE files
• BG_WaveSetControlPoints()

Sound engine - CRI Middleware’s Sound Factory

The dreamcast version uses CRI Middleware’s Sound Factory version 1.51 (built in December 1999) for its audio processing, thanks to this information being left in the built executable.

Specifically we know it uses the following builds (all from December 8th 1999):

• CRI_RNV - Ver.0.70(DRAGON) Build: Dec 8 1999 12:10:29
• CRI_VFD - Ver.0.99 Build: Dec 8 1999 12:10:55
• SJ - Ver.5.50 Build: Dec 8 1999 12:11:38
• mwRna - Ver.1.20 Build: Dec 8 1999 10:41:29
• mwSnd(DS) - Ver.1.20 Build: Dec 8 1999 10:41:37
• SFD - Version 1.21 1999-07-22 (SofdecStream)
• MPV Version 1.21 1999-07-22
• MPS Version 1.21 1999-07-22
• ADXENC Ver.1.00 Build:Dec 8 1999 10:48:12
• ADXENC.DLL Ver.1.00 Dec 8 1999

Other notes:

• Uses .vqf textures in dreamcast version

The windows version was also released in a collection called Crazy Fun Games by a french company called fun radio and Ubisoft, but it is currently unknown if it contains any differences or debug symbols present ¹⁵.

Early RKV Archive format

The RKV archive format differs from the one used in the more modern games such as Star Wars, but this same format was also used in early PS2 games running on the Merkury engine such as Jimmy Neutron: Jet Fusion!

It seems to be the first game that introduced the naming convention for the RKV archives which all have a 2-3 character suffix based on the platform the assets are for:

• Surf_PC.rkv - Championship Surfer for PC assets
• SURF_DCP.RKV - Championship Surfer for Dreamcast assets
• DATA_P2.RKV - Jimmy Neutron for PS2 assets
• data_pp.rkv - Star Wars: The Force Unleashed for PSP assets

RKV Version 0 QuickBMS extract script

Since there is already both an RKV.bms and RKV2.bms script to extract RKV files with the QuickBMS tool, I have decided to call the BMS script to extract the early version of the RKV format RKV0.bms, here is a version that works with Surf_PC.rkv and some early PS2 games:

# QuickBMS: Old version of Merkury engine games such as Championship Surfing and PS2 games like Jimmy Neutron
get FILESIZE asize
if FILESIZE < 8
    print "File too small"
    cleanexit
endif

goto -8
get NUM_FILES long
get NUM_DIRS long

# directories block (NUM_DIRS * 256) ends at EOF-8
math DIRS_SIZE = NUM_DIRS
math DIRS_SIZE *= 256
math DIRS_START = FILESIZE
math DIRS_START -= 8
math DIRS_START -= DIRS_SIZE

print "Number of directories: %NUM_DIRS%"
print "Number of file entries: %NUM_FILES%"
print "Reading %DIRS_SIZE% bytes of directory entries starting at 0x%DIRS_START|X%"

# read and store dir names by index
goto DIRS_START
for i = 0 < NUM_DIRS
    getdstring DIR_NAME 256
    print "DIR[%i%]: %DIR_NAME%"
    putarray 0 i DIR_NAME
next i

# files block (NUM_FILES * 64) is before directories
math FILES_SIZE = NUM_FILES
math FILES_SIZE *= 64
math FILES_START = DIRS_START
math FILES_START -= FILES_SIZE

print "Reading %FILES_SIZE% bytes of file entries starting at 0x%FILES_START|X%"

goto FILES_START
for i = 0 < NUM_FILES
    getdstring FILE_NAME 32
    get FOLDER_ID  long
    get FILE_SIZE  long
    get FILE_ZERO  long
    get FILE_OFFSET long
    get FILE_META3 long
    getdstring FILE_RESERVED 12

    # resolve folder name if valid
    set MATCH_DIR string ""
    if FOLDER_ID >= 0
        if FOLDER_ID < NUM_DIRS
            getarray MATCH_DIR 0 FOLDER_ID
        endif
    endif

    # build output path
    strlen DIRLEN MATCH_DIR
    set FULL_NAME string FILE_NAME
    if DIRLEN > 0
        set FULL_NAME string MATCH_DIR
        string FULL_NAME + /
        string FULL_NAME + FILE_NAME
    endif

    print "FILE[%i%] name: %FULL_NAME|S% is located at %FILE_OFFSET|X% with size: %FILE_SIZE|X%"

    if FILE_ZERO != 0
        print "FILE[%i%] Normally this is zero: %FILE_ZERO|X%"
    endif

    strlen RLEN FILE_RESERVED
    if RLEN != 0
        # Not Sure what this data is (CRC? Timestamps?)
        # print "FILE[%i%] reserved: %FILE_RESERVED|X%"
    endif

    # extract
    if FILE_OFFSET != -1
      log FULL_NAME FILE_OFFSET FILE_SIZE
    endif
next i

Kat Burglar (Cancelled late 2000)

It would have been used in the cancelled Kat Burglar game that Krome Studios was working on in late 2000, which even advertised on their official website about the use of their proprietary Merkury engine ¹⁶:

Kat Burglar is a 3rd person action-adventure game set in the swinging 60's. Katherine Kelly is a millionaire playgirl by day and a Robin Hood style thief by night. Katherine ("Kat" to her friends) specializes in stealing hard to get items from museums and fortified storehouses.

But she doesn't steal for the money…

Of course we're not going to give it all away just yet. We are keeping a few things under our hat - Kat Burglar is full of secrets and surprises. What we can tell you is that Kat is being developed for next generation console platforms and uses our proprietary 3D graphics engine Merkury.

Kat Burglar focuses heavily on characters and storyline. This game isn't a shooter. While there will be occasions where Kat won't be able to avoid a fight, more emphasis is placed on stealth. As Kat Burglar, the player will be part of the story that unfolds on the island of Mont-St-Michel. Kat will also come across many characters in the game, some friends, some enemies and some she's just not sure about.

GamesOnNet a site that now seems to be defunct had the following to say about Kat Burglar ¹⁷:

One of the games that came closest to making it was Kat Burglar, an action-stealth game that began life in late 1998 during Steve’s time at Gee Whiz! Entertainment with John Passfield. A light-hearted game with a James Bond-style 60’s flair, Steve recalls that they encountered some difficulty selling their prototype to publishers in 2000. “It was about the same time that No One Lives Forever was being shown around. And the problem we were running into when we were showing publishers, was ‘Monolith is showing this game where they have this 60’s female spy, and you’re showing us this game with a 60’s female thief, you can’t have two games set in the 60’s with a female character in them! That’s the same thing!’. And we were like ‘Wait, what?’”

Recounting with a touch of bitterness that it was apparently okay to have a dozen identical “muscular space marine” games on the market at the same time, Steve and the team were forced to shelve the game. “They just weren’t getting it, even if they did like the characters”, says Steve, remembering failed deals with partners like Mattel. “I’ll always remember the guys came back from one meeting with a publisher, and the publishers said ‘We’re pretty sure there’s already a 60’s female thief game with a character that has red hair’, and I’m standing there going 'Are they... talking about our game?'”.

Set on the island of Mont-St. Michael, Kat Burglar featured a number of adventure-game driven mechanics similar to those found in Flight of the Amazon Queen, as well as AI sidekicks who you could give orders to through hand gestures. The intent was to have a Zelda-style unlockable open world, with the island opening up to you as you progressed. Despite the game being developed to a playable state through one prototyped level, they were unable to secure a publisher. Opportunity did come knocking later in the year, as Sony expressed a desire to publish a cartoony platformer on their PS2 - a desire that Krome were only too happy to help fulfill. That game that would later go on to become TY The Tasmanian Tiger, and one of the company’s most iconic franchises.

Many of the ideas and concepts of Kat Burglar were eventually carried over into one of Krome’s last published titles, Blade Kitten - including a strong resemblance between Katherine Kelly of Kat Burglar and the pink-haired Kit Ballard of Blade Kitten. “I had all these elements I wanted to use but we apparently couldn’t do a 60’s game,” says Steve, “so I went and turned it into a sci-fi, anime game instead”.

More information on Kat Burglar can be found on Unseen64 Kat Burglar- Unseen64

Disney’s Extremely Goofy Skateboarding (September 2001)

The game Disney’s Extremely Goofy Skateboarding pre-dates the Merkury engine and was built to be windows-only, but it was released in 2001 the same year that they released Sunny Garcia Surfing which did use the Merkury engine. Presumably they were working on a new PS2 engine for the surfing game while working on the Disney game for windows, so it would not be easy to just port the skateboarding game over to the new engine.

Although it doesn’t use Merkury it would be interesting to see if any code from this game made it into early versions of the Merkury engine.

The 3D Engine programmer for the Goofy game, Tony Ball was also one of the founding developers of the Merkury engine, for this game the Blast graphics engine was compiled statically inside the executable.

Differences from the Merkury engine:

• Asset archives - Instead of the RKV format, the game bundles its assets into a file called data0.pkg, this is simply a Zip file, so its very easy to extract the contents by adding the .zip extention to the end.
• Images - It stores images directly as .BMP and textures as .TGA in the archive
• Sounds - It stores sounds directly as .WAV and .MP3 files

Skating.exe executable

If you run the binwalk command on the Skating.exe executable you find that it actually has a few embeded executables too:

----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
DECIMAL                            HEXADECIMAL                        DESCRIPTION
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
0                                  0x0                                Windows PE binary, machine type: Intel x86
510344                             0x7C988                            Copyright text: "Copyright 1998 Gilles Vollant "
510760                             0x7CB28                            CRC32 polynomial table, little endian
518636                             0x7E9EC                            Copyright text: "Copyright (C) 1996, Thomas G. Lane"
862766                             0xD2A2E                            Copyright text: "Copyright (c) 1993 Tal Nevo."
872435                             0xD4FF3                            Windows PE binary, machine type: Intel x86
889647                             0xD932F                            Windows PE binary, machine type: Intel x86
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

The copyright messages hint at a few things:

• Gilles Vollant is most likely related to zlib compression used for the asset archives.
• Thomas G. Lane is a principal author of the IJG’s widely used JPEG image compression software libraries, commonly known as libjpeg.
• Tal Nevo is possibly related to executable compression but this is a guess

The executable also has a few file paths left in which give a hint about the folder structure:

• D:\Src\Skating\Source\Character.cpp
• D:\Src\Skating\Source\Object.cpp
• D:\Src\Skating\Source\Main.cpp - Contained WinMain
• D:\Src\Skating\Source\GameData.cpp - Save Data

The reason we know it uses Blast Graphics is due to the string BLASTGRAPHICS Build Date : %s but not sure what the build date actually was for the BlastGraphics library for this game.

Asset Archive - data0.pkg

Since the data0.pkg format is just simple zip compression, it is very easy to extract and modify the assets, so lets take a look at what it contains, there are 1,207 files so we will group files by their extension in the table below:

The ASE files confirm that the game’s 3d models were creating using 3D Studio Max 3 or 4 back in 2001, but not sure the exact version of 3ds Max (does AsciiExport Version 2.00 narrow it down?).

They show how the 3D artists named their 3ds max scene files:

• beach_boardwalk_sign_nobase.max
• beach_1375_7_00_2001_JC1003_JC_TB.max

It also shows the organised folder structure used during development of the game:

• G:\Goofy Skateboarding\data\Models\Textures\badge.tga
• \\Krome-fs4\data12\Goofy\Goofy Skateboarding\data\Models\Textures\ramp2.tga - Shared Network drive?
• \\Krome-fs4\data12\Goofy\Graphics\Screens\S08_Beach\S08_03_BoardWalk\textures\jetty.bmp - I wonder why screen graphics were kept seperate?

Level files - .lvl

The level files are plain text XML data which links together all the other files, it is extremely modder friendly, here is an example:

<LEVEL NAME="Downtown" MESH="riverbend.ase" ENV="Cloud_Blue_env.ASE" MATERIAL="riverbend.mad" ENVROT="0" MUSIC="SUBURB_2.mp3" AMBIENT="ambience_centralpark_01.wav">
  <CLIP NEAR="100.00" FAR="8000.00" FOG="7000.00" COLOR="0.72,0.86,0.85">
  <OBJECTIVES TYPE="SHRED" DATA1="23,7" DATA2="1,70" DATA3="24,7">
  <OBJECTIVES TYPE="AGILITY" DATA1="3,7000" DATA2="4,7" DATA3="5,7" TIME="120">
  <TRIGGER POS="355.37,-3350.55,6692.30" SIZE="100.00,100.00,100.00" TYPE="spawn" ID="0" DATA="0" ENTER="none" EXIT="none">
  <OBJECT POS="4483.87,-3353.96,9730.11" ROT="0.00,0.00,0.00" SCALE="1.00" MESH="coin.ase" TYPE="collectible" UNIQUE="0" ID="1" DATA="0" FLAGS="4" SPEED="1.00">
  <OBJECT POS="7183.09,-3706.17,11404.25" ROT="0.00,-90.00,0.00" SCALE="0.60" MESH="critter_duckling.bad" TYPE="duckling" UNIQUE="0" ID="0" DATA="0" FLAGS="31" SPEED="1.00">
</LEVEL>

As far as I know this is a custom format made for this game and not an industry standard.

Sunny Garcia Surfing (October 2001)

Sunny Garcia Surfing was released on the PS2 in October 2001 in which Krome clearly listed the Merkury engine in the game credits. It has no mentions of Blast Graphics which makes sense as this is the first PS2 game they have released which would have required a complete re-write of the graphics engine to make the most out of the hardware.

The Merkury Engine programming for the game is credited to the following programmers in the manual for the game ¹⁸:

• Tony Ball - The main 3D developer behind the Blast Graphics 3D engine used in prior titles ¹⁹
• James Podesta - Also credited as Lead programmer on the game has been at Krome Studios since at least Championship Surfer back in 2000 and still there in 2023!
• Dave Pevreal - Also credited as Lead engine programmer on the Merkury engine version of Star Wars: The Force Unleashed ¹⁹

Barbie: Sparkling Ice Show (2002)

Barbie: Sparkling Ice Show was released in 2002 with support for DirectX8, it was the first game they released for windows that had no mentions of Blast Graphics at all and instead had strings related to Merkury in the game executable such as Merkury Options.

This hints that they never updated the Blast Graphics engine to DirectX 8 and this was the first 3D game for Windows that was released without Blast graphics.

Ty the Tasmanian Tiger (2002)

Ty the Tasmanian Tiger was released in 2002 for PS2, Gamecube and Xbox.

Gamecube release of Ty (2002)

The Gamecube release of Ty the Tasmanian Tiger contains not only debug symbols but also 364 references to the names of the C++ source code files used to build the game, all in the main executable TY_REL.elf. Most of the strings are located in the string table section (.strtab) of the GameCube ELF file and thus the location in that section may not indicate anything about the location of the functions that were contained in that source file.

You can find the Source file names in the table below, any descriptions added are a guess at the purpose of the file by us:

The Adventures of Jimmy Neutron: Jet Fusion (2003)

The 2003 game The Adventures of Jimmy Neutron: Jet Fusion is confirmed to use the Merkury engine (it uses RKV archives).

Prototype version for PS2

A Demo of the game was distributed in the Chirstmas 2003 issue (issue number 41) of the Official Playstation 2 magazine in the UK, the demo disc has the code SCED_51536.

It contained a DATA_P2.RKV (201.3MB) RKV archive containing all the game assets and the main game executable JIMMY.ELF (3.4MB).

As usual you can find out about all the interesting cut content that was available in the prototype version at The Cutting Room Floor: Proto:The Adventures of Jimmy Neutron Boy Genius: Jet Fusion (GameCube, PlayStation 2) - The Cutting Room Floor

Star Wars: The Force Unleashed for PS2, PSP and Wii (2008)

Unlike the Xbox 360 and PS3 versions of Star Wars: The Force Unleashed the PS2, PSP and Wii versions were not built by LucasArts or use the Ronin engine. Instead they were developed by Krome Studios, a completely separate studio known for action-platformers and movie tie-in games.

Krome developed these versions with a separate engine tailored for the older hardware and with unique content and gameplay elements. It is unlikely that ILM/LucasArts would allow their Zeno/Zed software to be used by a third party developer, so we presume these versions were not made using Zed and any assets were either sent over manually to the studio or made custom by Krome.

Because of hardware constraints, these versions use the Open Dynamics Engine (ODE) for physics, rather than Havok, which powers the Xbox 360 / PS3 versions.

Files in the PSP Version (UMD Disc contents)

If you extract the files from the UMD disc you will get the following file structure: ./PSP_GAME

• ICON0.PNG – Main XMB game icon (21 KB)
• PARAM.SFO – Game metadata: title, version, firmware (472 B)
• PIC0.PNG – XMB front image (12 KB)
• PIC1.PNG – XMB background image (151 KB)
• SND0.AT3 – Background audio (XMB menu music) (131 KB)
• SYSDIR
  • BOOT.BIN – Main game executable (uncompressed) (5.4 MB)
  • EBOOT.BIN – Main game executable (encrypted/compressed) (5.4 MB)
  • UPDATE
    • DATA.BIN – Firmware update installer data (19 MB)
    • EBOOT.BIN – Firmware updater executable (5.4 MB)
    • PARAM.SFO – Update metadata (2.0 KB)
• USRDIR
  • PIC1.PNG – Duplicate XMB background image (150 KB)
  • Attract01_60.pmf – In-game cutscene/attract video (4.7 MB)
  • Attract02_60.pmf – In-game cutscene/attract video (2.7 MB)
  • KromeLogo_60.pmf – Krome Studios logo video (1.2 MB)
  • LucasLogo_60.pmf – LucasArts logo video (406 KB)
  • LngEN_pp.rkv – English language archive (55 MB)
  • LngFR_pp.rkv – French language archive (52 MB)
  • data_pp.rkv – Main game data archive (models, textures, scripts) (892 MB)
  • audiocodec.prx – Audio codec module (3.2 KB)
  • libatrac3plus.prx – ATRAC3+ audio codec library (19 KB)
  • libpsmfplayer.prx – Video playback module (32 KB)
  • psmf.prx – Video parser module (6.9 KB)
  • sc_sascore.prx – Audio library module (5.8 KB)

The main executables are EBOOT.BIN and BOOT.BIN, it contains the standard firmware update files directory, XMB metadata for the game, some standard PRX modules (think DLLs but for the PSP) and there are some PlayStation Media Format (.pmf) videos used for cutscenes and studio logos.

So it is all pretty standard PSP files apart from the RKV archives, these are where all the game data is stored, so any game modding or asset extraction takes places using these files.

The BOOT.BIN executable confirms it is using the Krome Studios Merkury engine rather than the LucasArts Ronin engine used for the PS3 and Xbox 360 versions.

Source file references in the PSP version

For fun here is a list of unique strings that reference some of the original source code file names from inside the BOOT.BIN executable, they all seem to be related to the Ai system and all have the path prefix d:/starwars/src/StarWars/Source/ :

• Ai/PathMap.cpp
• Ai/Goals/AI_FollowEntityGoal.cpp
• Ai/Goals/AI_OrganisedRetreatGoal.cpp
• Ai/Goals/ScriptGoal.cpp
• Brains/AIBrain.cpp (AIBrain.h)
• Entity/Humanoid/Humanoid.cpp
• Props/CustomizeCostumeProp.cpp

Game Data Archives - .RKV files

The game uses RKV archive format, specifically version 2 of the format, these can be extraced with Luigi Auriemma’s QuickBMS and the Rkv2 BMS script.

Main Game Data Archive (data_pp.rkv)

The data_pp.rkv file has 23,934 files in the PSP version, which seems to be unoptimized as it also contains assets with the Wii prefix such as Wii_Controller.tex and Wii_Vader_Gloves.min.

Due to the huge amount of files in the archive, we are not going to list them out in this page, but the file extensions used for all of the files are in the table below:

BNI Files?

Not quite sure what *.BNI files are, they always start with the ASCII string “D:\starwars\data\RKVs..\Common”, but I presume they are an archive, possibly compressed (but there is a lot of strings so maybe not).

They also have a wide variety of names:

• global.lv3.bni - contain the string “Sire version 2.70 Data File version 3.0”, but not sure if Sire is an in-house tool or a third party software.
• global.sound.bni - contains strings like “swfx_RA_canon_ball_fire”
• GE.model.bni

The lvl files contain strings such as:

• PQuakePos - Also has QuakeRot Was this a quake format?
• GameDefaultCamera - camera settings such as nearPlane and farPlane
• =BOUNDING_REGION - Bounding Box information

Left-over development content

The .mine, .r11913, .r11979 files suggest use of the RCS (Revision Control System) version control system as it uses these extensions to manage file revisions and resolve conflicts locally.

Also it also highlights that the RKV files have a lot of files that are not required by the game at runtime, these version control files and also the translation Excel spreadsheet Translations.xls. it looks like they just archive a certain folder and distribute it with the game. Unfortunetly for us they didn’t accidently also include any debug symbols or source code in the archives.

Language Specific Sound Bank Archives (LngEN_pp.rkv and LngFR_pp.rkv)

LngEN_pp.rkv and LngFR_pp.rkv contain sound bank files (.sbk) for their respective languages, presumably all the voiced dialog in the game is contained in these and they have the file name format like cscc001_01_00_p01dven.sbk.

Likely naming format breakdown:

• cscg001: Likely an ID for a cutscene, always prefixed with “cs” presumably standing for cutscene.
• 01_00: Major/minor numbers w.g for scene/area, event, sequence, or version
• p01 — Possibly part 1/phase 1 or referencing a specific voice/group.
• dv — Character anchors e.g dv is Darth Vader
• en — Audio Language (Known values: en, fr)

SNK Cutscene Codes

Possible cutscene codes are presented in the table below:

Although these are a guess, proper analysis including playing each of the SBK files while playing the game would be required to give more concrete information.

SBK - Sound Bank File Format

After some initial analysis it seems the .SBK (header: SB01) files contained in the RKV archives is a small custom container that wraps a mono PSX-ADPCM stream. The container adds a fixed header (magic/version/size/name/flags) and stores raw ADPCM frames without a VAGp/RIFF wrapper.

Here are the header Metadata fields, numbers are all 32-bit Little Endian:

• Magic - Always “SB01” (ASCII) at 0x00
• Version - e.g 0x00000001 at 0x04
• File size - e.g 0x000029D0 (= 10704) at 0x08
• Name - e.g “CSZZ001_00_00_P01ZZEN” (ASCII, 32 bytes, NUL-padded) at 0x10
• Header size - e.g 0x50 (= 80 bytes) at 0x30
• Data size - 0x2980 (= 10624 = file_size − header_size) at 0x34
• Flags/SampleRate - e.g 0x80004A38; low bits 0x4A38 = 19000 Hz, high bit likely a format flag at 0x38
• Audio payload offset - e.g 0x50 (immediately after the header)

The rest of the file is consistent with PSX ADPCM (a.k.a. VAG):

• 16-byte frames with pattern 0x0C 0x00 … repeated
• mono frames (1-byte predictor/shift, 1-byte flags, 14 data bytes → 28 PCM samples/frame).

Script to convert .SBK to WAV

Here is a Python3 script to convert the .SBK files to WAV:

# Convert .SBK (Merkury Engine Sound Bank, Star Wars Force Unleashed) to WAV
import os, struct, wave, re

src = "./output/csch001_13_03_p01hten.sbk"
with open(src, "rb") as f:
    blob = f.read()

# Basic SB01 parse
magic = blob[0:4]
version = int.from_bytes(blob[4:8], "little")
total_size = int.from_bytes(blob[8:12], "little")
name = blob[0x10:0x30].split(b"\x00",1)[0].decode("ascii", "replace")
hdr_size = int.from_bytes(blob[0x30:0x34], "little")   # typically 0x50
data_size = int.from_bytes(blob[0x34:0x38], "little")  # total_size - hdr_size
flags_sr  = int.from_bytes(blob[0x38:0x3C], "little")  # 0x80000000 | sample_rate
audio = blob[hdr_size:hdr_size+data_size]

# Extract sample rate from low 16/32 bits; keep high bit as a flag
sample_rate = flags_sr & 0x7FFFFFFF  # remove 0x80000000
if sample_rate == 0 or sample_rate > 192000:
    # fallback if the high bit wasn't just a flag
    sample_rate = flags_sr & 0xFFFF

# Minimal PSX ADPCM (VAG) decoder (mono). Each frame is 16 bytes -> 28 samples.
COEFFS = [
    (0.0, 0.0),
    (60.0/64.0, 0.0),
    (115.0/64.0, -52.0/64.0),
    (98.0/64.0, -55.0/64.0),
    (122.0/64.0, -60.0/64.0),
]

def decode_frame(frame, p1, p2):
    shift = frame[0] & 0x0F
    filt  = frame[0] >> 4
    flags = frame[1]
    a1,a2 = COEFFS[filt] if 0 <= filt < len(COEFFS) else (0.0,0.0)
    out = []
    for i in range(2,16):
   b = frame[i]
   for nib in (b & 0x0F, (b >> 4) & 0x0F):
  s = nib if nib < 8 else nib - 16
  sample = (s << 12) >> shift
  sample = int(sample + p1*a1 + p2*a2)
  sample = max(min(sample, 32767), -32768)
  p2, p1 = p1, sample
  out.append(sample)
    return out, p1, p2, flags

pcm = []
p1=p2=0
i=0
# Skip any leading 0x00 frames (padding)
while i+16 <= len(audio):
    frame = audio[i:i+16]
    if frame == b"\x00"*16:
   i += 16
   continue
    batch, p1, p2, fl = decode_frame(frame, p1, p2)
    pcm.extend(batch)
    i += 16

dst = f"./{name}.wav"
with wave.open(dst, "wb") as w:
    w.setnchannels(1)
    w.setsampwidth(2)
    w.setframerate(sample_rate if 8000 <= sample_rate <= 96000 else 19000)
    w.writeframes(b"".join(struct.pack("<h", s) for s in pcm))

print ("Success:", dst, len(pcm), sample_rate, magic, version, total_size, hdr_size, data_size)

Star Wars Lightsaber Duels for the Wii (2008)

There is a video on youtube of a quick behind the scenes route of the Krome offices back in 2008 where they interview the lead programmer of Star Wars Lightsaber Duels Chris Lacey (The Shak EP454)?

Merkury 3 - Xbox 360, PS3 and Wii (2010)

Lead Environment Artist at Krome Studios Brent Waller posted a video showing off the new Merkury 3 engine in action which was built for the Xbox 360, Playstation 3 and Wii Title: The Legend of the Guardians: The Owls of Ga’hoole.

To quote Brent Waller ²⁰:

The engine has such features as large scale (16 square kilometres) terrain rendering and LODing, grass and forest LODing and placement tools and real-time day and night cycles.

You can watch the video below:

References