A work-in-progress modernization of LEGO Island (1997)
Find a file
Joshua Peisach 428b5ae8db
Initial implementation of MxBitmap (#34)
Co-authored-by: Anonymous Maarten <madebr@users.noreply.github.com>
2023-06-30 16:24:00 -07:00
.github/workflows ci: upload SVGs to external sites 2023-06-30 16:00:27 -07:00
dx5sdk/cdrom Create setup.iss 2023-06-11 14:16:58 +02:00
ISLE implement all DLL exports (as TODOs) 2023-06-30 11:34:39 -07:00
LEGO1 Initial implementation of MxBitmap (#34) 2023-06-30 16:24:00 -07:00
tools reccmp: use "monospace" in svg font 2023-06-30 16:12:22 -07:00
.gitattributes Convert all sources eol's to nl (#41) 2023-06-23 09:17:41 -07:00
.gitignore Yet another CMake implementation (#61) 2023-06-29 16:39:02 -07:00
CMakeLists.txt implement all DLL exports (as TODOs) 2023-06-30 11:34:39 -07:00
CONTRIBUTING.md Update CONTRIBUTING.md 2023-06-29 00:49:57 -07:00
README.md readme: use SVGs [skip ci] 2023-06-30 16:06:30 -07:00

LEGO Island Decompilation

Development Vlog | Contributing | Matrix | Forums | Patreon

This is a work-in-progress decompilation of LEGO Island version 1.1. It aims to be as accurate as possible, matching the recompiled instructions to the original machine code as much as possible. The goal is to provide a workable codebase that can be modified, improved, and ported to other platforms later on.

Status

Currently ISLE.EXE is completely decompiled and behaves identically to the original. A handful of stubborn instructions are not yet matching, however we anticipate they will as more of the overall codebase is implemented.

LEGO1.DLL is still very much incomplete and cannot be used at this time. Instead, if you want to test this, it is recommended to pair the recompiled ISLE.EXE with the LEGO1.DLL from the original game.

Building

This projects uses the CMake build system, which allows for a high degree of versatility regarding compilers and development environments. For the most accurate results, it is recommended to use Microsoft Visual C++ 4.20 (the same compiler used to build the original game). Since we're trying to match this to the original executable as closely as possible, all contributions will be graded with the output of this compiler.

These instructions will outline how to compile this repository into an accurate instruction-matching binary with Visual C++ 4.2. If you wish, you can try using other compilers, but this is at your own risk and won't be covered in this guide.

Prerequisites

You will need the following software installed:

  • Microsoft Visual C++ 4.2. This can be found on many abandonware sites, but the installer can be a little iffy on modern versions of Windows. For convenience, I made a portable version that can be downloaded and used quickly instead.
  • DirectX 5 SDK. Similarly, this can be found on many abandonware sites.
  • CMake. A copy is often included with the "Desktop development with C++" workload in newer versions of Visual Studio, however it can also be installed as a standalone app.

Compiling From Command Line

  1. Open a Command Prompt (cmd).
  2. From Visual C++ 4.2, run BIN/VCVARS32.BAT x86 to populate the path and other environment variables for compiling with MSVC.
  3. Make a folder for compiled objects to go, such as a build folder inside the source repository (the folder you cloned/downloaded to).
  4. In your Command Prompt, cd to the build folder.
  5. Configure the project with CMake by running:
cmake <path-to-source> -G "NMake Makefiles" -DCMAKE_BUILD_TYPE=RelWithDebInfo
  • Replace <path-to-source> with the source repository. Can be .. if your build folder is inside the source repository.
  • RelWithDebInfo is recommended because it will produce debug symbols useful for further decompilation work. However, you can change this to Release if you don't need them. Debug builds are not recommended because they are unlikely to be compatible with the retail LEGO1.DLL, which is currently the only way to really use this decomp.
  • NMake Makefiles is most recommended because it will be immediately compatible with Visual C++ 4.2. For faster builds, you can use Ninja (if you have it installed), however due to limitations in Visual C++ 4.2, you can only build Release builds this way (debug symbols cannot be generated with Ninja).
  1. Build the project by running nmake or cmake --build <build-folder>
  2. When this is done, there should a recompiled ISLE.EXE and LEGO1.DLL in the build folder.

If you have a CMake-compatible IDE, it should be pretty straightforward to use this repository, as long as you can use VCVARS32.BAT and set the generator to NMake Makefiles.

Usage

Simply place the compiled ISLE.EXE into LEGO Island's install folder (usually C:\Program Files\LEGO Island or C:\Program Files (x86)\LEGO Island). Unless you're a developer, disregard the compiled LEGO1.DLL for now as it is too incomplete to be usable. Alternatively, LEGO Island can run from any directory as long as ISLE.EXE and LEGO1.DLL are in the same directory, and the registry keys point to the correct location for the asset files.

Contributing

If you're interested in helping/contributing to this project, check out the CONTRIBUTING page.

Additional Information

Which version of LEGO Island do I have?

Right click on LEGO1.DLL, select Properties, and switch to the Details tab. Under Version you should either see 1.0.0.0 (1.0) or 1.1.0.0 (1.1). Additionally, you can look at the game disc files; 1.0's files will all say August 8, 1997, and 1.1's files will all say September 8, 1997. Version 1.1 is by far the most common, especially if you're not using the English or Japanese versions, so that's most likely the version you have.

SmartHeap

Both ISLE.EXE and LEGO1.DLL were originally statically linked with SmartHeap, a drop-in replacement for malloc/free that presumably provides better heap memory management on the old low-memory (16MB) systems this game was designed for. Unfortunately, acquiring SmartHeap legally is expensive, and the chances of acquiring the exact same version used by Mindscape in the late 90s is very low. Since it's a drop-in binary-compatible replacement, this decomp can just stick with the standard malloc/free functions while still achieving matching assembly on a per-function level, however the resulting binaries will never be byte accurate as a result of this. If you notice significant size disparities, particularly in ISLE.EXE, the lack of statically linked SmartHeap libraries is why.