Project Millimeters of Aluminum

A space simulation game built on a custom fork of the Godot Engine (4.x) with 64-bit double-precision physics enabled.

📋 Prerequisites

Before compiling the engine, ensure you have the following installed on your system.

1. Python & SCons

The Godot build system relies on SCons, which is written in Python.

• Install Python (3.6+): Download Here

  • Windows Users: Ensure "Add Python to PATH" is checked during installation. Check this stackoverflow answer.

• Install SCons: Open your terminal/command prompt and run:

  pip install scons
  

2. C++ Compiler

Godot requires a C++ compiler to build from source.

• Windows:
  • Install Visual Studio Community (2019 or later).
  • During installation, select the "Desktop development with C++" workload.
• Linux:
  • Install GCC or Clang.
  • Debian/Ubuntu: sudo apt-get install build-essential pkg-config libx11-dev libxcursor-dev libxinerama-dev libgl1-mesa-dev libglu-dev libasound2-dev libpulse-dev libudev-dev libxi-dev libxrandr-dev
• macOS:
  • Install Xcode from the App Store.
  • Run xcode-select --install in the terminal.

🛠️ Setup & Compilation

This project uses a custom engine build to support solar-system scale coordinates (Double Precision). You cannot use the standard Steam or website version of Godot to open this project.

1. Clone the Repository

Clone the repository with the --recursive flag to automatically pull the engine source code submodule.

git clone --recursive [https://codeberg.org/YOUR_USERNAME/ProjectMillimetersOfAluminum.git](https://codeberg.org/YOUR_USERNAME/ProjectMillimetersOfAluminum.git)
cd ProjectMillimetersOfAluminum

If you have already cloned without recursive, run:

git submodule update --init --recursive

2. Configure Engine Ignore (Optional but Recommended)

To prevent your Editor from trying to import the thousands of raw assets inside the engine source folder:

1. Navigate to godot_engine/.
2. Create a new empty file named .gdignore.
3. Compile the Engine

Run the build command for your platform from the godot_engine/ directory.

Windows:

cd godot_engine
scons platform=windows target=editor precision=double arch=x86_64

Linux:

cd godot_engine
scons platform=linuxbsd target=editor precision=double arch=x86_64 

macOS:

cd godot_engine
scons platform=macos target=editor precision=double arch=x86_64 

Note: (-j6 flag tells the compiler to use 6 CPU cores. Adjust this number based on your hardware to speed up compilation. Not using the flag will use all available cores)

---

🚀 Running the Project

Once compilation is complete (usually 10-30 minutes), the executable will be located in godot_engine/bin/.

Do not open the project with standard Godot.

Navigate to godot_engine/bin/.

Run the binary ending in .double.x86_64 (e.g., godot.windows.editor.double.x86_64.exe).

Import and open the project.godot file located in the root ProjectMillimetersOfAluminum folder.

Troubleshooting

"No valid compilers found" (Windows): Ensure you installed the C++ Desktop Development workload in the Visual Studio Installer. Just the editor is not enough.

Jittering Objects: If objects jitter at large distances, ensure you are running the double precision binary and not a standard build.

🛠 Compiling Custom Export Templates

This project uses features from the latest development branch of Godot (master branch). As a result, standard export templates downloaded from the Godot website may not be compatible. To export the project, you must compile custom export templates from the same source version used to build your editor.

Prerequisites

Ensure you have a C++ build environment set up (SCons, Python, Visual Studio/GCC/MinGW). See the official Godot documentation on compiling for platform-specific instructions.

1. Build the Editor (Optional)

See above section.

2. Build the Export Templates

You need to build two templates: one for debug (used during development/testing) and one for release (optimized for final distribution).

Windows:

# Debug Template (console enabled, debug tools)
scons platform=windows target=template_debug

# Release Template (optimized, no console)
scons platform=windows target=template_release

Linux:

# Debug Template
scons platform=linuxbsd target=template_debug

# Release Template
scons platform=linuxbsd target=template_release

3. Locate Output Files

After compilation, the binaries will be located in the bin/ directory of your Godot source folder.

• Debug: godot.windows.template_debug.x86_64.exe (or similar)

• Release: godot.windows.template_release.x86_64.exe (or similar)

4. Configure Export Presets

1. Open the project in Godot.

2. Go to Project > Export.

3. Select your export preset (e.g., Windows Desktop).

4. Under the Options tab, find the Custom Template section.

5. Set Debug to the path of your compiled template_debug binary.

6. Set Release to the path of your compiled template_release binary.

You can now export the project using your custom engine build!