millimeters-of-aluminum/README.md

# 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](https://www.python.org/downloads/)
    * *Windows Users:* Ensure "Add Python to PATH" is checked during installation. [Check this stackoverflow answer](https://stackoverflow.com/questions/57421669/question-about-pip-using-python-from-windows-store).

* **Install SCons:** Open your terminal/command prompt and run:
    ```bash
    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.

```bash
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:**
```Bash
cd godot_engine
scons platform=windows target=editor precision=double arch=x86_64
```

**Linux:**
```Bash
cd godot_engine
scons platform=linuxbsd target=editor precision=double arch=x86_64 
```

**macOS:**
```Bash
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:**
```PowerShell
# Debug Template (console enabled, debug tools)
scons platform=windows target=template_debug

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

**Linux:**
```bash
# 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!