OpenRA3 v0.0.1: C++26 modules, BIG4/RefPack reader, minimal skirmish
This commit is contained in:
EnderTheCoder
@@ -0,0 +1,30 @@
|
|||||||
|
---
|
||||||
|
Language: Cpp
|
||||||
|
BasedOnStyle: LLVM
|
||||||
|
Standard: c++20
|
||||||
|
UseTab: Never
|
||||||
|
IndentWidth: 4
|
||||||
|
TabWidth: 4
|
||||||
|
NamespaceIndentation: All
|
||||||
|
AccessModifierOffset: -4
|
||||||
|
IndentCaseLabels: true
|
||||||
|
ColumnLimit: 150
|
||||||
|
KeepEmptyLinesAtTheStartOfBlocks: true
|
||||||
|
MaxEmptyLinesToKeep: 1
|
||||||
|
PointerAlignment: Right
|
||||||
|
ReferenceAlignment: Right
|
||||||
|
DerivePointerAlignment: false
|
||||||
|
AllowShortIfStatementsOnASingleLine: WithoutElse
|
||||||
|
AllowShortBlocksOnASingleLine: Never
|
||||||
|
AllowShortFunctionsOnASingleLine: Inline
|
||||||
|
Cpp11BracedListStyle: true
|
||||||
|
ConstructorInitializerAllOnOneLineOrOnePerLine: true
|
||||||
|
BreakConstructorInitializers: BeforeColon
|
||||||
|
ConstructorInitializerIndentWidth: 4
|
||||||
|
BinPackParameters: false
|
||||||
|
BinPackArguments: true
|
||||||
|
AlignAfterOpenBracket: Align
|
||||||
|
SpaceBeforeRangeBasedForLoopColon: false
|
||||||
|
AlwaysBreakTemplateDeclarations: Yes
|
||||||
|
SortIncludes: Never
|
||||||
|
FixNamespaceComments: false
|
||||||
@@ -0,0 +1,12 @@
|
|||||||
|
.git
|
||||||
|
build
|
||||||
|
build-*
|
||||||
|
cmake-build-*
|
||||||
|
out
|
||||||
|
artifacts_bin
|
||||||
|
reference
|
||||||
|
*.gcm
|
||||||
|
gcm.cache
|
||||||
|
dev-image.tar
|
||||||
|
.idea
|
||||||
|
.vscode
|
||||||
+32
@@ -0,0 +1,32 @@
|
|||||||
|
# build trees
|
||||||
|
build/
|
||||||
|
build-*/
|
||||||
|
cmake-build-*/
|
||||||
|
out/
|
||||||
|
artifacts_bin/
|
||||||
|
*.gcm
|
||||||
|
gcm.cache/
|
||||||
|
|
||||||
|
# CI image artifacts
|
||||||
|
dev-image.tar
|
||||||
|
|
||||||
|
# reference sources (fetched, not vendored)
|
||||||
|
reference/
|
||||||
|
|
||||||
|
# retail game data must never be committed (read from the user's install)
|
||||||
|
gamedata/
|
||||||
|
local/
|
||||||
|
*.big
|
||||||
|
*.manifest
|
||||||
|
*.relo
|
||||||
|
*.imp
|
||||||
|
|
||||||
|
# tooling
|
||||||
|
.idea/
|
||||||
|
.vscode/
|
||||||
|
.cache/
|
||||||
|
compile_commands.json
|
||||||
|
|
||||||
|
# local data dumps / RE artifacts
|
||||||
|
re-data/
|
||||||
|
*.log
|
||||||
@@ -0,0 +1,64 @@
|
|||||||
|
stages:
|
||||||
|
- image
|
||||||
|
- build
|
||||||
|
|
||||||
|
variables:
|
||||||
|
DOCKER_HOST: tcp://docker:2375
|
||||||
|
DOCKER_DRIVER: overlay2
|
||||||
|
DOCKER_TLS_CERTDIR: ""
|
||||||
|
# Where to push the dev image. Leave empty to not push at all.
|
||||||
|
# Examples: "192.168.1.11:9090/<group>/openra3" or "docker.io/<user>/openra3"
|
||||||
|
IMAGE_NAME: ""
|
||||||
|
APT_MIRROR: "http://mirrors.tuna.tsinghua.edu.cn/ubuntu"
|
||||||
|
|
||||||
|
image_build:
|
||||||
|
stage: image
|
||||||
|
image: docker:latest
|
||||||
|
services:
|
||||||
|
- name: docker:dind
|
||||||
|
# Pull docker.io images through the intranet Harbor pull-through cache;
|
||||||
|
# plain HTTP registry, hence --insecure-registry.
|
||||||
|
command:
|
||||||
|
- --registry-mirror=http://192.168.1.11:9090/dockerhub
|
||||||
|
- --insecure-registry=192.168.1.11:9090
|
||||||
|
script:
|
||||||
|
- docker build --target dev -t openra3-dev:local --build-arg APT_MIRROR=$APT_MIRROR .
|
||||||
|
- docker save openra3-dev:local -o dev-image.tar
|
||||||
|
- |
|
||||||
|
if [ -n "$IMAGE_NAME" ]; then
|
||||||
|
# add `docker login` here if IMAGE_NAME points to a private registry
|
||||||
|
docker tag openra3-dev:local $IMAGE_NAME:$CI_COMMIT_SHORT_SHA
|
||||||
|
docker push $IMAGE_NAME:$CI_COMMIT_SHORT_SHA
|
||||||
|
fi
|
||||||
|
artifacts:
|
||||||
|
name: "dev-image-$CI_COMMIT_SHORT_SHA"
|
||||||
|
paths:
|
||||||
|
- dev-image.tar
|
||||||
|
expire_in: 1 day
|
||||||
|
tags:
|
||||||
|
- docker
|
||||||
|
|
||||||
|
build_test_package:
|
||||||
|
stage: build
|
||||||
|
image: docker:latest
|
||||||
|
services:
|
||||||
|
- name: docker:dind
|
||||||
|
command:
|
||||||
|
- --registry-mirror=http://192.168.1.11:9090/dockerhub
|
||||||
|
- --insecure-registry=192.168.1.11:9090
|
||||||
|
needs:
|
||||||
|
- image_build
|
||||||
|
before_script:
|
||||||
|
- docker load -i dev-image.tar
|
||||||
|
script:
|
||||||
|
- docker run --rm -v "$(pwd):/work" -w /work openra3-dev:local cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release
|
||||||
|
- docker run --rm -v "$(pwd):/work" -w /work openra3-dev:local cmake --build build -j
|
||||||
|
- docker run --rm -v "$(pwd):/work" -w /work openra3-dev:local ctest --test-dir build --output-on-failure
|
||||||
|
- docker run --rm -v "$(pwd):/work" -w /work openra3-dev:local bash -c "mkdir -p artifacts_bin && cp build/bin/openra3 artifacts_bin/"
|
||||||
|
artifacts:
|
||||||
|
name: "$CI_PROJECT_NAME-executables-$CI_COMMIT_SHORT_SHA"
|
||||||
|
paths:
|
||||||
|
- artifacts_bin/
|
||||||
|
expire_in: 7 days
|
||||||
|
tags:
|
||||||
|
- docker
|
||||||
+105
@@ -0,0 +1,105 @@
|
|||||||
|
cmake_minimum_required(VERSION 3.28)
|
||||||
|
|
||||||
|
project(OpenRA3 VERSION 0.0.1 LANGUAGES CXX)
|
||||||
|
|
||||||
|
set(CMAKE_CXX_STANDARD 26)
|
||||||
|
set(CMAKE_CXX_STANDARD_REQUIRED ON)
|
||||||
|
set(CMAKE_CXX_EXTENSIONS OFF)
|
||||||
|
|
||||||
|
if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
|
||||||
|
set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
|
||||||
|
endif()
|
||||||
|
|
||||||
|
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
|
||||||
|
|
||||||
|
option(OPENRA3_WERROR "Treat warnings as errors" OFF)
|
||||||
|
|
||||||
|
function(openra3_target_defaults target)
|
||||||
|
target_compile_options(${target} PRIVATE -Wall -Wextra -Wpedantic)
|
||||||
|
if(OPENRA3_WERROR)
|
||||||
|
target_compile_options(${target} PRIVATE -Werror)
|
||||||
|
endif()
|
||||||
|
endfunction()
|
||||||
|
|
||||||
|
# --- engine core: fundamental types, math, strings, random, message stream ---
|
||||||
|
add_library(ra3_core STATIC)
|
||||||
|
target_sources(ra3_core
|
||||||
|
PUBLIC FILE_SET CXX_MODULES FILES
|
||||||
|
src/core/ra3.core.cppm
|
||||||
|
)
|
||||||
|
openra3_target_defaults(ra3_core)
|
||||||
|
|
||||||
|
# --- game logic: objects, players, teams, spatial partition, game loop ---
|
||||||
|
add_library(ra3_logic STATIC)
|
||||||
|
target_sources(ra3_logic
|
||||||
|
PUBLIC FILE_SET CXX_MODULES FILES
|
||||||
|
src/logic/ra3.logic.cppm
|
||||||
|
)
|
||||||
|
target_link_libraries(ra3_logic PUBLIC ra3_core)
|
||||||
|
openra3_target_defaults(ra3_logic)
|
||||||
|
|
||||||
|
# --- client: headless display/input abstraction and the client facade ---
|
||||||
|
add_library(ra3_client STATIC)
|
||||||
|
target_sources(ra3_client
|
||||||
|
PUBLIC FILE_SET CXX_MODULES FILES
|
||||||
|
src/client/ra3.client.cppm
|
||||||
|
)
|
||||||
|
target_link_libraries(ra3_client PUBLIC ra3_core ra3_logic)
|
||||||
|
openra3_target_defaults(ra3_client)
|
||||||
|
|
||||||
|
# --- RA3 game definitions: factions, player templates, science, special powers ---
|
||||||
|
add_library(ra3_game STATIC)
|
||||||
|
target_sources(ra3_game
|
||||||
|
PUBLIC FILE_SET CXX_MODULES FILES
|
||||||
|
src/game/ra3.game.cppm
|
||||||
|
)
|
||||||
|
target_link_libraries(ra3_game PUBLIC ra3_core ra3_logic)
|
||||||
|
openra3_target_defaults(ra3_game)
|
||||||
|
|
||||||
|
# --- filesystem: BIG4 archives, RefPack codec, local install locator ---
|
||||||
|
add_library(ra3_fs STATIC)
|
||||||
|
target_sources(ra3_fs
|
||||||
|
PUBLIC FILE_SET CXX_MODULES FILES
|
||||||
|
src/fs/ra3.fs.cppm
|
||||||
|
)
|
||||||
|
target_link_libraries(ra3_fs PUBLIC ra3_core)
|
||||||
|
openra3_target_defaults(ra3_fs)
|
||||||
|
|
||||||
|
# --- map discovery/loading (real .big data, user's local install) ---
|
||||||
|
add_library(ra3_map STATIC)
|
||||||
|
target_sources(ra3_map
|
||||||
|
PUBLIC FILE_SET CXX_MODULES FILES
|
||||||
|
src/map/ra3.map.cppm
|
||||||
|
)
|
||||||
|
target_link_libraries(ra3_map PUBLIC ra3_core ra3_fs)
|
||||||
|
openra3_target_defaults(ra3_map)
|
||||||
|
|
||||||
|
# --- minimal headless skirmish simulation ---
|
||||||
|
add_library(ra3_skirmish STATIC)
|
||||||
|
target_sources(ra3_skirmish
|
||||||
|
PUBLIC FILE_SET CXX_MODULES FILES
|
||||||
|
src/skirmish/ra3.skirmish.cppm
|
||||||
|
)
|
||||||
|
target_link_libraries(ra3_skirmish PUBLIC ra3_core ra3_logic ra3_game ra3_map)
|
||||||
|
openra3_target_defaults(ra3_skirmish)
|
||||||
|
|
||||||
|
# --- umbrella module re-exporting the whole SDK ---
|
||||||
|
add_library(ra3 STATIC)
|
||||||
|
target_sources(ra3
|
||||||
|
PUBLIC FILE_SET CXX_MODULES FILES
|
||||||
|
src/ra3.cppm
|
||||||
|
)
|
||||||
|
target_link_libraries(ra3 PUBLIC ra3_core ra3_logic ra3_client ra3_game ra3_fs ra3_map ra3_skirmish)
|
||||||
|
openra3_target_defaults(ra3)
|
||||||
|
|
||||||
|
# --- the headless game executable ---
|
||||||
|
add_executable(openra3 apps/openra3/main.cpp)
|
||||||
|
target_link_libraries(openra3 PRIVATE ra3)
|
||||||
|
openra3_target_defaults(openra3)
|
||||||
|
|
||||||
|
# --- unit tests ---
|
||||||
|
enable_testing()
|
||||||
|
add_executable(ra3_tests tests/ra3_tests.cpp)
|
||||||
|
target_link_libraries(ra3_tests PRIVATE ra3)
|
||||||
|
openra3_target_defaults(ra3_tests)
|
||||||
|
add_test(NAME ra3_tests COMMAND ra3_tests)
|
||||||
+58
@@ -0,0 +1,58 @@
|
|||||||
|
# syntax=docker/dockerfile:1
|
||||||
|
|
||||||
|
# dev target: full toolchain + debug tools for development and debugging.
|
||||||
|
# Base image and compiler are the latest stable (ubuntu:26.04 ships gcc/g++ 16).
|
||||||
|
FROM ubuntu:26.04 AS dev
|
||||||
|
|
||||||
|
ENV DEBIAN_FRONTEND=noninteractive
|
||||||
|
|
||||||
|
# Optional apt mirror override, e.g. --build-arg APT_MIRROR=http://mirrors.tuna.tsinghua.edu.cn/ubuntu
|
||||||
|
ARG APT_MIRROR=""
|
||||||
|
RUN if [ -n "$APT_MIRROR" ]; then \
|
||||||
|
sed -i -e "s|http://archive.ubuntu.com/ubuntu|${APT_MIRROR}|g" \
|
||||||
|
-e "s|http://security.ubuntu.com/ubuntu|${APT_MIRROR}|g" \
|
||||||
|
-e "s|http://ports.ubuntu.com/ubuntu-ports|${APT_MIRROR}|g" \
|
||||||
|
/etc/apt/sources.list /etc/apt/sources.list.d/*.sources 2>/dev/null || true; \
|
||||||
|
fi
|
||||||
|
|
||||||
|
RUN --mount=type=cache,target=/var/lib/apt,sharing=locked \
|
||||||
|
--mount=type=cache,target=/var/cache/apt,sharing=locked \
|
||||||
|
apt-get update && apt-get install -y --no-install-recommends \
|
||||||
|
build-essential \
|
||||||
|
ca-certificates \
|
||||||
|
cmake \
|
||||||
|
g++-16 \
|
||||||
|
gdb \
|
||||||
|
git \
|
||||||
|
ninja-build \
|
||||||
|
pkg-config \
|
||||||
|
&& rm -rf /var/lib/apt/lists/*
|
||||||
|
|
||||||
|
# Pin the toolchain to GCC 16 (the distro default is still GCC 15).
|
||||||
|
ENV CC=gcc-16
|
||||||
|
ENV CXX=g++-16
|
||||||
|
RUN update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-16 100 \
|
||||||
|
&& update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-16 100 \
|
||||||
|
&& update-alternatives --install /usr/bin/c++ c++ /usr/bin/g++-16 100
|
||||||
|
|
||||||
|
WORKDIR /work
|
||||||
|
COPY . .
|
||||||
|
|
||||||
|
# C++26 modules need CMake >= 3.28, the Ninja generator and a module-aware gcc.
|
||||||
|
RUN cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release \
|
||||||
|
&& cmake --build build -j \
|
||||||
|
&& ctest --test-dir build --output-on-failure
|
||||||
|
|
||||||
|
# deploy target: runtime dependencies + final binary, minimal and fast.
|
||||||
|
FROM ubuntu:26.04 AS deploy
|
||||||
|
|
||||||
|
ENV DEBIAN_FRONTEND=noninteractive
|
||||||
|
|
||||||
|
RUN apt-get update && apt-get install -y --no-install-recommends \
|
||||||
|
libstdc++6 \
|
||||||
|
&& rm -rf /var/lib/apt/lists/*
|
||||||
|
|
||||||
|
WORKDIR /app
|
||||||
|
COPY --from=dev /work/build/bin/openra3 /app/openra3
|
||||||
|
|
||||||
|
ENTRYPOINT ["/app/openra3"]
|
||||||
@@ -0,0 +1,20 @@
|
|||||||
|
OpenRA3
|
||||||
|
Copyright (C) 2026 OpenRA3 contributors
|
||||||
|
|
||||||
|
This program is free software: you can redistribute it and/or modify it under
|
||||||
|
the terms of the GNU General Public License as published by the Free Software
|
||||||
|
Foundation, either version 3 of the License, or (at your option) any later
|
||||||
|
version.
|
||||||
|
|
||||||
|
This program is distributed in the hope that it will be useful, but WITHOUT ANY
|
||||||
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
|
||||||
|
PARTICULAR PURPOSE. See the GNU General Public License for more details.
|
||||||
|
|
||||||
|
You should have received a copy of the GNU General Public License along with
|
||||||
|
this program. If not, see <https://www.gnu.org/licenses/>.
|
||||||
|
|
||||||
|
The architecture of this project is derived from
|
||||||
|
electronicarts/CnC_Generals_Zero_Hour, which is licensed under the GNU General
|
||||||
|
Public License v3 with additional terms. Command & Conquer and Red Alert are
|
||||||
|
trademarks of Electronic Arts. This project is unaffiliated with and
|
||||||
|
unsupported by EA.
|
||||||
@@ -0,0 +1,115 @@
|
|||||||
|
# OpenRA3
|
||||||
|
|
||||||
|
A from-scratch, portable re-implementation of **Command & Conquer: Red Alert 3**
|
||||||
|
in **C++26** using **C++ modules**, built with **GCC 16**.
|
||||||
|
|
||||||
|
Red Alert 3 runs SAGE 2.0. EA never released that engine's C++ source, but it
|
||||||
|
did open-source the closely related SAGE 1.0 engine as
|
||||||
|
[`electronicarts/CnC_Generals_Zero_Hour`](https://github.com/electronicarts/CnC_Generals_Zero_Hour)
|
||||||
|
(GPLv3). OpenRA3 uses that tree as the architectural reference and reconstructs
|
||||||
|
the RA3-specific behaviour by decompiling the retail `ra3_1.12.game` binary with
|
||||||
|
Ghidra.
|
||||||
|
|
||||||
|
> OpenRA3 ships **no game assets or binaries**. You must own Red Alert 3. The
|
||||||
|
> engine reads your own local installation at runtime; nothing from it is ever
|
||||||
|
> copied into this repository. Command & Conquer and Red Alert are trademarks of
|
||||||
|
> Electronic Arts; this project is unaffiliated with and unsupported by EA.
|
||||||
|
|
||||||
|
## Status
|
||||||
|
|
||||||
|
OpenRA3 is at **v0.0.1**. The engine compiles and runs headless, and a **minimal
|
||||||
|
skirmish** is playable: it reads a real multiplayer map out of your install,
|
||||||
|
recovers the player start waypoints, and simulates two sides earning credits,
|
||||||
|
training units and fighting until one base falls. There is no renderer yet, so
|
||||||
|
the match is observed as a deterministic headless result.
|
||||||
|
|
||||||
|
```text
|
||||||
|
$ openra3 skirmish --game-dir "/game" --map map_mp_2_feasel4
|
||||||
|
OpenRA3 skirmish map=map_mp_2_feasel4 source=archive:map_mp_2_feasel4 seed=1
|
||||||
|
start positions:
|
||||||
|
P0 (1338, 1940)
|
||||||
|
P1 (1291, 1404)
|
||||||
|
result: decided winner=0 frames=3397 (113.2 s)
|
||||||
|
P0 Commander Allied money= 129 units=19 kills=21 losses=3
|
||||||
|
P1 AI Soviet money= 840 units= 0 kills=3 losses=21
|
||||||
|
```
|
||||||
|
|
||||||
|
## Offline only
|
||||||
|
|
||||||
|
OpenRA3 implements **offline skirmish and, eventually, LAN/single-player**.
|
||||||
|
There is deliberately **no online mode**: no EA account, no online service, no
|
||||||
|
matchmaking, no GameSpy/Steam integration, and no networking in the simulation.
|
||||||
|
The match loop is deterministic and self-contained so it can be replayed and
|
||||||
|
tested without any external service.
|
||||||
|
|
||||||
|
## Assets
|
||||||
|
|
||||||
|
The engine reads the retail game from your local install:
|
||||||
|
|
||||||
|
- default path `C:\Red Alert 3`, or `--game-dir DIR`, or `$RA3_GAME_DIR`;
|
||||||
|
- `Data\MapsMultiplayer.big` is read for the map catalog;
|
||||||
|
- maps are unpacked from `BIG4` + RefPack and their start waypoints recovered.
|
||||||
|
|
||||||
|
**No game data is committed or distributed.** `reference/` (the GPLv3 Generals
|
||||||
|
source) and any extracted assets are git-ignored; `tools/fetch_reference.sh`
|
||||||
|
fetches the former on demand. Without an install, the engine falls back to a
|
||||||
|
built-in test map so the project still builds and runs in CI.
|
||||||
|
|
||||||
|
## Layout
|
||||||
|
|
||||||
|
| Path | Purpose |
|
||||||
|
| --- | --- |
|
||||||
|
| `src/core/ra3.core.cppm` | fundamental types, math, strings, random, message stream |
|
||||||
|
| `src/logic/ra3.logic.cppm` | objects, players, teams, spatial partition, game loop |
|
||||||
|
| `src/client/ra3.client.cppm` | display abstraction + client facade / frame loop |
|
||||||
|
| `src/game/ra3.game.cppm` | RA3 sides, player templates, skirmish defaults |
|
||||||
|
| `src/fs/ra3.fs.cppm` | `BIG4` archives, RefPack codec, local install locator |
|
||||||
|
| `src/map/ra3.map.cppm` | map catalog, `EAR`/RefPack unwrap, start waypoints |
|
||||||
|
| `src/skirmish/ra3.skirmish.cppm` | units, economy, AI, combat, win condition |
|
||||||
|
| `src/ra3.cppm` | umbrella module re-exporting the SDK |
|
||||||
|
| `apps/openra3/main.cpp` | `maps` / `skirmish` CLI |
|
||||||
|
| `tests/ra3_tests.cpp` | smoke tests (run via `ctest`) |
|
||||||
|
| `tools/` | reference fetch + Ghidra-driven reconstruction helpers |
|
||||||
|
| `docs/` | architecture, reverse-engineering notes, roadmap |
|
||||||
|
| `Dockerfile` | `dev` (toolchain) and `deploy` (runtime) targets |
|
||||||
|
| `.gitlab-ci.yml` | build → test → package pipeline |
|
||||||
|
|
||||||
|
## Build
|
||||||
|
|
||||||
|
The host needs no toolchain: build inside the container.
|
||||||
|
|
||||||
|
```bash
|
||||||
|
docker build --target dev -t openra3-dev:local .
|
||||||
|
|
||||||
|
docker run --rm -v "$PWD:/work" -w /work openra3-dev:local cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release
|
||||||
|
docker run --rm -v "$PWD:/work" -w /work openra3-dev:local cmake --build build -j
|
||||||
|
docker run --rm -v "$PWD:/work" -w /work openra3-dev:local ctest --test-dir build --output-on-failure
|
||||||
|
```
|
||||||
|
|
||||||
|
Behind a slow or blocked mirror, pass `--build-arg APT_MIRROR=<url>`.
|
||||||
|
|
||||||
|
## Running a skirmish
|
||||||
|
|
||||||
|
```bash
|
||||||
|
# list the maps in your install
|
||||||
|
docker run --rm -v "/path/to/Red Alert 3:/game:ro" openra3-dev:local \
|
||||||
|
./build/bin/openra3 maps --game-dir /game
|
||||||
|
|
||||||
|
# play a headless skirmish on a real map
|
||||||
|
docker run --rm -v "/path/to/Red Alert 3:/game:ro" openra3-dev:local \
|
||||||
|
./build/bin/openra3 skirmish --game-dir /game --map map_mp_2_feasel4 --seed 7
|
||||||
|
```
|
||||||
|
|
||||||
|
`--frames N` caps the simulation length (default 15 minutes of game time at
|
||||||
|
30 Hz). The result is deterministic for a given map and seed.
|
||||||
|
|
||||||
|
## Reverse engineering
|
||||||
|
|
||||||
|
The reconstruction is driven by Ghidra against the retail binary. See
|
||||||
|
[`docs/REVERSE_ENGINEERING.md`](docs/REVERSE_ENGINEERING.md) for the workflow and
|
||||||
|
the recovered symbol map, and [`tools/`](tools/) for the helpers.
|
||||||
|
|
||||||
|
## License
|
||||||
|
|
||||||
|
Project code: GPLv3, matching the `CnC_Generals_Zero_Hour` reference (see
|
||||||
|
[`LICENSE`](LICENSE)).
|
||||||
@@ -0,0 +1,125 @@
|
|||||||
|
#include <cstdio>
|
||||||
|
#include <exception>
|
||||||
|
#include <filesystem>
|
||||||
|
#include <optional>
|
||||||
|
#include <string>
|
||||||
|
#include <string_view>
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
|
import ra3;
|
||||||
|
|
||||||
|
namespace {
|
||||||
|
auto print_usage() -> void {
|
||||||
|
std::puts("OpenRA3 - headless Red Alert 3 reconstruction");
|
||||||
|
std::puts("usage:");
|
||||||
|
std::puts(" openra3 maps [--game-dir DIR]");
|
||||||
|
std::puts(" openra3 skirmish [--game-dir DIR] [--map ID] [--frames N] [--seed N]");
|
||||||
|
std::puts("env: RA3_GAME_DIR (default C:\\Red Alert 3); game data is never copied into the repo");
|
||||||
|
}
|
||||||
|
|
||||||
|
auto option_value(const std::vector<std::string> &args, std::string_view name) -> std::optional<std::string> {
|
||||||
|
for (std::size_t i = 0; i + 1U < args.size(); ++i) {
|
||||||
|
if (args[i] == name) return args[i + 1U];
|
||||||
|
}
|
||||||
|
return std::nullopt;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Build `<dir>/Data/<name>` portably (avoids path/char[] ambiguity). */
|
||||||
|
auto data_path(const std::filesystem::path &dir, std::string_view name) -> std::filesystem::path {
|
||||||
|
return dir / std::string{"Data"} / std::string{name};
|
||||||
|
}
|
||||||
|
|
||||||
|
auto command_maps(const std::optional<std::filesystem::path> &game_dir) -> int {
|
||||||
|
const auto dir = ra3::fs::find_game_dir(game_dir);
|
||||||
|
if (!dir) {
|
||||||
|
std::puts("no Red Alert 3 install found; pass --game-dir or set RA3_GAME_DIR");
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
const auto archive_path = data_path(*dir, "MapsMultiplayer.big");
|
||||||
|
const auto archive = ra3::fs::big_archive::open(archive_path);
|
||||||
|
const auto catalog = ra3::map::map_catalog::from_archive(archive);
|
||||||
|
const auto name = archive_path.filename().string();
|
||||||
|
std::printf("maps in %s: %zu\n", name.c_str(), catalog.size());
|
||||||
|
for (const auto &entry: catalog.maps()) {
|
||||||
|
std::printf(" %-28s %6u KB packed / %6u KB unpacked\n", entry.id.c_str(), entry.stored_size / 1024U, entry.unpacked_size / 1024U);
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
auto command_skirmish(const std::vector<std::string> &args, const std::optional<std::filesystem::path> &game_dir) -> int {
|
||||||
|
ra3::skirmish::match_config config;
|
||||||
|
std::vector<ra3::map::start_position> starts;
|
||||||
|
std::string source = "builtin";
|
||||||
|
|
||||||
|
const auto requested_map = option_value(args, "--map");
|
||||||
|
if (const auto dir = ra3::fs::find_game_dir(game_dir)) {
|
||||||
|
try {
|
||||||
|
const auto archive = ra3::fs::big_archive::open(data_path(*dir, "MapsMultiplayer.big"));
|
||||||
|
const auto catalog = ra3::map::map_catalog::from_archive(archive);
|
||||||
|
const ra3::map::map_info *info = nullptr;
|
||||||
|
if (requested_map) {
|
||||||
|
info = catalog.find(*requested_map);
|
||||||
|
if (info == nullptr) std::printf("map '%s' not found; falling back\n", requested_map->c_str());
|
||||||
|
} else if (catalog.size() > 0U) {
|
||||||
|
info = &catalog.maps().front();
|
||||||
|
}
|
||||||
|
if (info != nullptr) {
|
||||||
|
const auto loaded = ra3::map::load_map(archive, *info);
|
||||||
|
starts = loaded.starts;
|
||||||
|
config.map_id = info->id;
|
||||||
|
source = "archive:" + info->id;
|
||||||
|
}
|
||||||
|
} catch (const std::exception &error) {
|
||||||
|
std::printf("map load failed: %s\n", error.what());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (starts.size() < 2U) {
|
||||||
|
starts = ra3::skirmish::builtin_start_positions();
|
||||||
|
source = "builtin";
|
||||||
|
}
|
||||||
|
if (const auto seed = option_value(args, "--seed")) config.seed = static_cast<ra3::core::uint32>(std::stoul(*seed));
|
||||||
|
if (const auto frames = option_value(args, "--frames")) config.max_frames = static_cast<ra3::core::uint32>(std::stoul(*frames));
|
||||||
|
|
||||||
|
auto match = ra3::skirmish::skirmish_match::create(config, starts);
|
||||||
|
const auto summary = match.run();
|
||||||
|
|
||||||
|
std::printf("OpenRA3 skirmish map=%s source=%s seed=%u\n", config.map_id.c_str(), source.c_str(), config.seed);
|
||||||
|
std::puts("start positions:");
|
||||||
|
for (std::size_t i = 0; i < starts.size(); ++i) {
|
||||||
|
std::printf(" P%zu (%.0f, %.0f)\n", i, static_cast<double>(starts[i].x), static_cast<double>(starts[i].y));
|
||||||
|
}
|
||||||
|
std::printf("result: %s winner=%d frames=%u (%.1f s)\n", summary.decided ? "decided" : "timeout", summary.winner, summary.frames,
|
||||||
|
static_cast<double>(summary.frames) / 30.0);
|
||||||
|
for (const auto &player: match.players()) {
|
||||||
|
const auto side = std::string{ra3::game::to_string(player.side)};
|
||||||
|
std::printf(" P%u %-10s %-7s money=%6d units=%2zu kills=%d losses=%d\n", player.index, player.name.c_str(), side.c_str(), player.money,
|
||||||
|
match.unit_count(player.index), player.kills, player.losses);
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
auto main(int argc, char **argv) -> int {
|
||||||
|
const std::vector<std::string> args{argv + 1, argv + argc};
|
||||||
|
if (args.empty()) {
|
||||||
|
print_usage();
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
const auto command = args[0];
|
||||||
|
const std::vector<std::string> rest{args.begin() + 1, args.end()};
|
||||||
|
|
||||||
|
std::optional<std::filesystem::path> game_dir;
|
||||||
|
if (const auto dir = option_value(rest, "--game-dir")) game_dir = *dir;
|
||||||
|
|
||||||
|
if (command == "maps") return command_maps(game_dir);
|
||||||
|
if (command == "skirmish") return command_skirmish(rest, game_dir);
|
||||||
|
if (command == "help" || command == "--help" || command == "-h") {
|
||||||
|
print_usage();
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
print_usage();
|
||||||
|
return 2;
|
||||||
|
}
|
||||||
@@ -0,0 +1,78 @@
|
|||||||
|
# Architecture
|
||||||
|
|
||||||
|
OpenRA3 is organised as a stack of C++ modules. Each layer may import the ones
|
||||||
|
below it, never the ones above.
|
||||||
|
|
||||||
|
```
|
||||||
|
┌───────────────────────────────┐
|
||||||
|
applications │ openra3 (apps/openra3) │
|
||||||
|
└───────────────┬───────────────┘
|
||||||
|
│ import ra3
|
||||||
|
┌───────────────▼───────────────┐
|
||||||
|
umbrella │ ra3 (re-exports everything) │
|
||||||
|
└───────────────┬───────────────┘
|
||||||
|
┌───────────────┬────────┴────────┬───────────────┐
|
||||||
|
▼ ▼ ▼ ▼
|
||||||
|
ra3.skirmish ra3.client ra3.game ra3.map
|
||||||
|
match rules display/loop RA3 sides map catalog
|
||||||
|
│ │ │ │
|
||||||
|
└───────┬───────┴────────┬────────┘ │
|
||||||
|
▼ ▼ ▼
|
||||||
|
ra3.logic ra3.core ra3.fs
|
||||||
|
simulation types/math/random BIG4 + RefPack
|
||||||
|
```
|
||||||
|
|
||||||
|
## Module responsibilities
|
||||||
|
|
||||||
|
### `ra3.core`
|
||||||
|
The vocabulary every other module shares, mirroring SAGE's `GameEngine/Common`:
|
||||||
|
`real`/`int32`/`uint32`, `coord3d`/`coord2d`/`rgb_color`, `ascii_string` +
|
||||||
|
`make_name_key`, the deterministic `random` stream, and the `message_stream`
|
||||||
|
command bus (node layout derived from retail `MessageStream::appendMessage`,
|
||||||
|
`0x0060c4a0`).
|
||||||
|
|
||||||
|
### `ra3.logic`
|
||||||
|
The deterministic simulation, mirroring SAGE's `GameLogic`: `thing` → `object`
|
||||||
|
with pluggable `update_module`s, `player`/`player_list`, the `partition_manager`
|
||||||
|
spatial grid, and the 30 Hz `game_logic` driver (`prepare_new_game` /
|
||||||
|
`start_new_game` / `update`).
|
||||||
|
|
||||||
|
### `ra3.client`
|
||||||
|
The presentation boundary: an abstract `display` with a `headless_display`
|
||||||
|
implementation, and `game_client`, the seam a future W3D/D3D9 renderer plugs
|
||||||
|
into.
|
||||||
|
|
||||||
|
### `ra3.game`
|
||||||
|
Red Alert 3 data that SAGE keeps in `PlayerTemplate`: the three sides
|
||||||
|
(`faction` flags `Empire=2`, `Allied=4`, `Soviet=8`, `Random=7`, recovered from
|
||||||
|
the retail skirmish setup) and skirmish defaults.
|
||||||
|
|
||||||
|
### `ra3.fs`
|
||||||
|
Reading the user's installation. Implements the `BIG4` archive container and
|
||||||
|
EA's RefPack codec, plus `find_game_dir` (`--game-dir` / `$RA3_GAME_DIR` /
|
||||||
|
`C:\Red Alert 3`). Only the archive index is held in memory; payloads are read
|
||||||
|
on demand.
|
||||||
|
|
||||||
|
### `ra3.map`
|
||||||
|
Map discovery and loading: scans `MapsMultiplayer.big` for main map entries,
|
||||||
|
unwraps the two compression layers (`BIG4` RefPack → `EAR\0` wrapper → RefPack →
|
||||||
|
`CkMp`), and recovers `Player_N_Start` waypoint coordinates. Degenerate
|
||||||
|
extractions are rejected so the caller can fall back.
|
||||||
|
|
||||||
|
### `ra3.skirmish`
|
||||||
|
The minimal match: two players, unit classes (harvester/infantry/tank/base),
|
||||||
|
passive + harvester income, a simple build AI, movement and combat on a fixed
|
||||||
|
30 Hz step, and a base-destruction win condition. Fully deterministic.
|
||||||
|
|
||||||
|
## Design rules
|
||||||
|
|
||||||
|
1. **No raw owning pointers.** Ownership is `std::unique_ptr`; the partition
|
||||||
|
manager holds non-owning `thing *` views only.
|
||||||
|
2. **Portable simulation.** No platform APIs in `ra3.core` / `ra3.logic`. All
|
||||||
|
platform concerns live behind `display`.
|
||||||
|
3. **Determinism.** Anything that can diverge between runs (random, iteration
|
||||||
|
order) is explicit and seedable.
|
||||||
|
4. **RE-traceable.** Where a structure or constant comes from the retail
|
||||||
|
binary, the address is cited in the comment.
|
||||||
|
5. **No bundled assets, no online.** Game data is read from the user's install
|
||||||
|
and never committed; there is no networking or online service.
|
||||||
@@ -0,0 +1,135 @@
|
|||||||
|
# Reverse engineering workflow
|
||||||
|
|
||||||
|
OpenRA3 is reconstructed from two sources:
|
||||||
|
|
||||||
|
1. **Architecture** — the GPLv3 SAGE 1.0 tree,
|
||||||
|
[`electronicarts/CnC_Generals_Zero_Hour`](https://github.com/electronicarts/CnC_Generals_Zero_Hour).
|
||||||
|
RA3 runs SAGE 2.0, so class names, message flow and subsystem boundaries
|
||||||
|
carry over even though the code does not.
|
||||||
|
2. **Facts** — the retail `ra3_1.12.game` binary (image base `0x400000`),
|
||||||
|
analysed in Ghidra and, when needed, observed live.
|
||||||
|
|
||||||
|
Nothing in OpenRA3 should assert a structure or constant that is not either
|
||||||
|
copied from the reference or cited to a retail address.
|
||||||
|
|
||||||
|
## Fetching the reference
|
||||||
|
|
||||||
|
```bash
|
||||||
|
tools/fetch_reference.sh # sparse-clone Code/GameEngine into reference/
|
||||||
|
```
|
||||||
|
|
||||||
|
The checkout is git-ignored (large, and GPLv3 terms differ from this repo's).
|
||||||
|
|
||||||
|
## Ghidra
|
||||||
|
|
||||||
|
The retail module is loaded into Ghidra as `ra3_1.12.game`
|
||||||
|
(`x86:LE:32:default`, 34k+ functions). The analysis is driven through the
|
||||||
|
Ghidra MCP bridge, so every recovered fact can be re-derived:
|
||||||
|
|
||||||
|
| Question | Tool call |
|
||||||
|
| --- | --- |
|
||||||
|
| What does an address do? | `decompile_function(address=0x…)` |
|
||||||
|
| What is this function? | `get_function_by_address(address=0x…)` |
|
||||||
|
| Who touches a global? | `get_xrefs_to(address=0x…)` |
|
||||||
|
| What are the vtable slots? | `list_class_members` / `analyze_data_region` |
|
||||||
|
| Where is a string referenced? | `search_strings` + `get_xrefs_to` |
|
||||||
|
|
||||||
|
### Recovery loop
|
||||||
|
|
||||||
|
1. Pick a subsystem from the reference tree (e.g. `MessageStream`).
|
||||||
|
2. Find its RTTI/vtable in the binary via `search_strings` and xrefs.
|
||||||
|
3. Decompile the constructor to recover object size and field init order.
|
||||||
|
4. Decompile the hot methods to recover field meaning.
|
||||||
|
5. Write the OpenRA3 module with a comment citing the address.
|
||||||
|
6. Add a smoke test that pins the behaviour.
|
||||||
|
|
||||||
|
## Recovered symbol map (retail `ra3_1.12.game`)
|
||||||
|
|
||||||
|
### Engine singletons
|
||||||
|
|
||||||
|
Each holds an object pointer (0 when the subsystem is down).
|
||||||
|
|
||||||
|
| Global | Address | Object vtable |
|
||||||
|
| --- | --- | --- |
|
||||||
|
| `TheGameLogic` | `0x00cd8ce4` | `0x00beb630` |
|
||||||
|
| `ThePlayerList` | `0x00ce8c9c` | `0x00c5b9e0` |
|
||||||
|
| `ThePartitionManager` | `0x00ce2f9c` | `0x00c6af98` |
|
||||||
|
| `TheShroudManager` | `0x00ce2fa0` | `0x00c6aefc` |
|
||||||
|
| `ThePlacementGrid` | `0x00cd8d0c` | `0x00bea560` |
|
||||||
|
| `TheRecorder` | `0x00ce2fd0` | `0x00c10544` |
|
||||||
|
| `TheGlobalObjectRegistry` | `0x00cd8d08` | `0x00bea644` |
|
||||||
|
| `ThePlayerTemplateStore` | `0x00ce8ca0` | `0x00c5bc70` |
|
||||||
|
| `TheGameState` | `0x00cdbbc4` | `0x00bef0c0` |
|
||||||
|
| `GlobalData` | `0x00ce2fa8` | `0x00c0d8e4` |
|
||||||
|
| `TheMessageStream` | `0x00ce2fb8` | `0x00c0ecd4` |
|
||||||
|
|
||||||
|
### Reconstructed layouts
|
||||||
|
|
||||||
|
- **`GameLogic`** — tick counter at `+0x50` (incremented once per 30 Hz
|
||||||
|
simulation step); `starting` guard flag at `+0xa7`, raised while a new match
|
||||||
|
initialises.
|
||||||
|
- **`MessageStream`** — intrusive doubly linked list; head at `+0x24`, tail at
|
||||||
|
`+0x28`. `appendMessage` (`0x0060c4a0`) allocates a `0x74`-byte node:
|
||||||
|
`+0x00` next, `+0x04` prev, `+0x08` owner stream, `+0x0c` message type,
|
||||||
|
`+0x10` player index, `+0x18` capacity, `+0x1c` data pointer (`node + 0x20`).
|
||||||
|
- **`Player`** — money via `std::vector<Money*>` at `+0xe4`; power at `+0x74`;
|
||||||
|
team at `+0xac`; relation maps at `+0xfc` / `+0x100`.
|
||||||
|
- **Skirmish setup** (`SkirmishGameInfo`, pointer at `[0x00ce3a78]`) — starting
|
||||||
|
cash `+0x64`, player slots `+0xfc` (stride `0x5c`, 6 slots), faction at
|
||||||
|
`slot + 0x18` (`Empire=2`, `Allied=4`, `Soviet=8`, `Random=7`).
|
||||||
|
|
||||||
|
### Match start
|
||||||
|
|
||||||
|
The BEGIN button calls `SkirmishGameOptionsMenu::start` (`0x00b28d60`), which
|
||||||
|
copies the map, calls `GameInfo::startGame(0)`, seeds the logic random and
|
||||||
|
appends `MSG_NEW_GAME` (`0x2`). `startNewGame` itself is `0x00623e40`. OpenRA3
|
||||||
|
mirrors this two-phase `prepare_new_game` / `start_new_game` split.
|
||||||
|
|
||||||
|
## Container and map formats
|
||||||
|
|
||||||
|
Recovered by inspection of `Data\*.big` (see `ra3.fs` / `ra3.map`).
|
||||||
|
|
||||||
|
### `BIG4` archive
|
||||||
|
|
||||||
|
All integers little-endian except where noted:
|
||||||
|
|
||||||
|
```
|
||||||
|
offset 0 magic "BIG4"
|
||||||
|
offset 4 fileSize u32 LE total archive size
|
||||||
|
offset 8 fileCount u32 BE number of entries
|
||||||
|
offset 12 indexSize u32
|
||||||
|
offset 16 entries fileCount * { offset u32 BE, size u32 BE, name cstring }
|
||||||
|
```
|
||||||
|
|
||||||
|
Entry offsets are absolute; payloads are RefPack-compressed.
|
||||||
|
|
||||||
|
### RefPack
|
||||||
|
|
||||||
|
EA's `10 FB` stream. `ra3.fs::refpack_decompress` implements the 2/3/4-byte
|
||||||
|
commands and the long-literal/stop opcodes; `refpack_output_size` reads the
|
||||||
|
declared output length without decompressing.
|
||||||
|
|
||||||
|
### Map file (`.map`)
|
||||||
|
|
||||||
|
Two layers of compression:
|
||||||
|
|
||||||
|
```
|
||||||
|
BIG4 payload = RefPack -> "EAR\0" + u32 unpacked_size + RefPack -> "CkMp" ...
|
||||||
|
```
|
||||||
|
|
||||||
|
The `CkMp` payload is the compiled SAGE map: a type/field name table followed by
|
||||||
|
chunk data. Player start positions appear as waypoints named
|
||||||
|
`Player_1_Start`, `Player_2_Start`, ... Each waypoint record carries a `Coord3D`
|
||||||
|
(three little-endian `float`s) shortly after the name; `ra3.map` scans forward
|
||||||
|
from the name for the first plausible `(x, y, 0)` triple. Maps that store starts
|
||||||
|
in `MPPositionList` instead yield no waypoints and fall back.
|
||||||
|
|
||||||
|
Verified example (`map_mp_2_feasel4`): `Player_1_Start` = `(1338.9, 1940.5, 0)`,
|
||||||
|
`Player_2_Start` = `(1290.8, 1404.9, 0)`.
|
||||||
|
|
||||||
|
### Still to recover
|
||||||
|
|
||||||
|
- `MPPositionList` layout (per-player starts for maps without waypoints).
|
||||||
|
- Map dimensions / `HeightMapData` / `BlendTileData`.
|
||||||
|
- Compiled asset blobs (`map.bin`, `global.bin`, `static.*.bin`) and the
|
||||||
|
`.manifest` schema used to deserialise them.
|
||||||
@@ -0,0 +1,41 @@
|
|||||||
|
# Roadmap
|
||||||
|
|
||||||
|
OpenRA3 is a very large undertaking. This roadmap is deliberately honest about
|
||||||
|
scope: reconstructing a 2008 RTS engine from a decompiler plus a related open
|
||||||
|
engine is a multi-year, multi-person effort. The milestones below are ordered so
|
||||||
|
that each one produces something that builds and runs.
|
||||||
|
|
||||||
|
## Done
|
||||||
|
|
||||||
|
- [x] **v0.0.1 — skeleton + minimal skirmish.** C++26 modules, GCC 16,
|
||||||
|
CMake/Ninja, Docker `dev`/`deploy`, GitLab CI. Reads `BIG4`/RefPack data
|
||||||
|
from a local install, recovers map start waypoints, and runs a
|
||||||
|
deterministic headless two-player skirmish to a decision.
|
||||||
|
|
||||||
|
## Next
|
||||||
|
|
||||||
|
- [ ] **v0.1.0 — complete map parsing.** Parse `MPPositionList` for maps that do
|
||||||
|
not use `Player_N_Start` waypoints; recover map dimensions, terrain
|
||||||
|
heightmap and placement grid; place real starting structures/units.
|
||||||
|
- [ ] **v0.2.0 — data & file formats.** Parse compiled gameplay assets
|
||||||
|
(`GameObject`, `WeaponTemplate`, `ArmorTemplate`, `LocomotorTemplate`) so
|
||||||
|
units use the real balance numbers instead of OpenRA3's stand-ins.
|
||||||
|
- [ ] **v0.3.0 — deterministic simulation.** Real update modules, locomotor
|
||||||
|
movement, weapons/damage/armour resolution, build queues and the tech
|
||||||
|
tree, pathfinding and shroud.
|
||||||
|
- [ ] **v0.4.0 — AI.** Skirmish AI: build states, team composition, attack
|
||||||
|
waves (the reference tree's `AI*` modules).
|
||||||
|
- [ ] **v0.5.0 — renderer.** A W3D/D3D9 (or portable Vulkan/OpenGL) client
|
||||||
|
backend implementing `ra3::client::display`, plus input.
|
||||||
|
- [ ] **v0.6.0 — content.** Load real maps, units, powers and strings; play a
|
||||||
|
skirmish end-to-end with a UI.
|
||||||
|
|
||||||
|
## Cross-cutting tracks
|
||||||
|
|
||||||
|
- **RE depth** — keep recovering retail layouts (see
|
||||||
|
[`REVERSE_ENGINEERING.md`](REVERSE_ENGINEERING.md)); every structure gets an
|
||||||
|
address citation and a test.
|
||||||
|
- **Determinism & replay** — the logic random stream and frame ordering must be
|
||||||
|
reproducible; replay format and a golden-replay test suite.
|
||||||
|
- **Offline only** — no online mode. Multiplayer, if pursued, is LAN lockstep on
|
||||||
|
the message stream, never an online service.
|
||||||
@@ -0,0 +1,74 @@
|
|||||||
|
module;
|
||||||
|
|
||||||
|
#include <cstdint>
|
||||||
|
#include <memory>
|
||||||
|
#include <string_view>
|
||||||
|
|
||||||
|
export module ra3.client;
|
||||||
|
|
||||||
|
import ra3.core;
|
||||||
|
import ra3.logic;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The presentation layer: an abstract output surface plus the client facade
|
||||||
|
* that owns the simulation and drives the frame loop.
|
||||||
|
*
|
||||||
|
* A future W3D/D3D9 backend implements the same `display` interface; the
|
||||||
|
* default headless backend keeps OpenRA3 runnable on a CPU-only box.
|
||||||
|
*/
|
||||||
|
export namespace ra3::client {
|
||||||
|
using ra3::core::uint32;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Abstract output surface presented once per logic frame.
|
||||||
|
*/
|
||||||
|
class display {
|
||||||
|
public:
|
||||||
|
virtual ~display() = default;
|
||||||
|
|
||||||
|
virtual auto begin_frame() -> void = 0;
|
||||||
|
virtual auto end_frame() -> void = 0;
|
||||||
|
[[nodiscard]] virtual auto name() const -> std::string_view = 0;
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A display that renders nothing and consumes no resources.
|
||||||
|
*/
|
||||||
|
class headless_display final : public display {
|
||||||
|
public:
|
||||||
|
auto begin_frame() -> void override {}
|
||||||
|
auto end_frame() -> void override {}
|
||||||
|
[[nodiscard]] auto name() const -> std::string_view override { return "headless"; }
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Owns the simulation and its display, and drives the frame loop.
|
||||||
|
*/
|
||||||
|
class game_client {
|
||||||
|
public:
|
||||||
|
game_client() = default;
|
||||||
|
|
||||||
|
[[nodiscard]] auto logic() -> logic::game_logic & { return logic_; }
|
||||||
|
[[nodiscard]] auto display() -> client::display & { return *display_; }
|
||||||
|
|
||||||
|
auto set_display(std::unique_ptr<client::display> value) -> void { display_ = std::move(value); }
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Run `frames` logic steps, bracketing each with a present.
|
||||||
|
*
|
||||||
|
* @param target Simulation to advance.
|
||||||
|
* @param frames Number of 30 Hz logic frames to run.
|
||||||
|
*/
|
||||||
|
auto run(logic::game_logic &target, uint32 frames) -> void {
|
||||||
|
for (uint32 i = 0; i < frames; ++i) {
|
||||||
|
display_->begin_frame();
|
||||||
|
target.update();
|
||||||
|
display_->end_frame();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
logic::game_logic logic_;
|
||||||
|
std::unique_ptr<client::display> display_ = std::make_unique<headless_display>();
|
||||||
|
};
|
||||||
|
}
|
||||||
@@ -0,0 +1,247 @@
|
|||||||
|
module;
|
||||||
|
|
||||||
|
#include <cmath>
|
||||||
|
#include <compare>
|
||||||
|
#include <cstddef>
|
||||||
|
#include <cstdint>
|
||||||
|
#include <limits>
|
||||||
|
#include <optional>
|
||||||
|
#include <ostream>
|
||||||
|
#include <span>
|
||||||
|
#include <string>
|
||||||
|
#include <string_view>
|
||||||
|
#include <utility>
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
|
export module ra3.core;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Fundamental engine types shared by every OpenRA3 module.
|
||||||
|
*
|
||||||
|
* The vocabulary mirrors SAGE 2.0 (the engine Red Alert 3 runs on) as it
|
||||||
|
* appears in the CnC Generals source, with layouts cross-checked against the
|
||||||
|
* retail `ra3_1.12.game` binary through Ghidra.
|
||||||
|
*/
|
||||||
|
export namespace ra3::core {
|
||||||
|
inline constexpr int version_major = 0;
|
||||||
|
inline constexpr int version_minor = 0;
|
||||||
|
inline constexpr int version_patch = 1;
|
||||||
|
|
||||||
|
using real = float;
|
||||||
|
using int32 = std::int32_t;
|
||||||
|
using uint32 = std::uint32_t;
|
||||||
|
using uint16 = std::uint16_t;
|
||||||
|
using uint8 = std::uint8_t;
|
||||||
|
using usize = std::size_t;
|
||||||
|
|
||||||
|
/** SAGE advances the simulation on a fixed 30 Hz logic tick. */
|
||||||
|
inline constexpr int logic_frames_per_second = 30;
|
||||||
|
inline constexpr real logic_frame_seconds = 1.0F / static_cast<real>(logic_frames_per_second);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A world-space position or direction, matching SAGE's `Coord3D`.
|
||||||
|
*/
|
||||||
|
struct coord3d {
|
||||||
|
real x = 0.0F;
|
||||||
|
real y = 0.0F;
|
||||||
|
real z = 0.0F;
|
||||||
|
|
||||||
|
auto operator+(const coord3d &rhs) const -> coord3d { return {x + rhs.x, y + rhs.y, z + rhs.z}; }
|
||||||
|
auto operator-(const coord3d &rhs) const -> coord3d { return {x - rhs.x, y - rhs.y, z - rhs.z}; }
|
||||||
|
auto operator*(real scalar) const -> coord3d { return {x * scalar, y * scalar, z * scalar}; }
|
||||||
|
auto operator==(const coord3d &) const -> bool = default;
|
||||||
|
|
||||||
|
/** Squared length, cheaper than `length()` when only comparing. */
|
||||||
|
[[nodiscard]] auto length_squared() const -> real { return x * x + y * y + z * z; }
|
||||||
|
|
||||||
|
[[nodiscard]] auto length() const -> real;
|
||||||
|
|
||||||
|
[[nodiscard]] auto distance_to(const coord3d &other) const -> real { return (*this - other).length(); }
|
||||||
|
|
||||||
|
/** Unit vector, or the zero vector when this one is degenerate. */
|
||||||
|
[[nodiscard]] auto normalized() const -> coord3d;
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Integer grid coordinates, matching SAGE's `ICoord2D`.
|
||||||
|
*/
|
||||||
|
struct coord2d {
|
||||||
|
int32 x = 0;
|
||||||
|
int32 y = 0;
|
||||||
|
|
||||||
|
auto operator==(const coord2d &) const -> bool = default;
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* An 8-bit-per-channel RGB colour.
|
||||||
|
*/
|
||||||
|
struct rgb_color {
|
||||||
|
uint8 r = 0;
|
||||||
|
uint8 g = 0;
|
||||||
|
uint8 b = 0;
|
||||||
|
|
||||||
|
auto operator==(const rgb_color &) const -> bool = default;
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Derive the 32-bit identifier SAGE associates with an ASCII name.
|
||||||
|
*
|
||||||
|
* The retail `NameKeyGenerator` hash is still being recovered; this
|
||||||
|
* deterministic, case-insensitive FNV-1a stand-in keeps the interface
|
||||||
|
* stable until exact parity is proven against the binary.
|
||||||
|
*/
|
||||||
|
constexpr auto make_name_key(std::string_view name) -> uint32 {
|
||||||
|
uint32 key = 2166136261U;
|
||||||
|
for (const auto ch: name) {
|
||||||
|
auto c = static_cast<unsigned char>(ch);
|
||||||
|
if (c >= 'a' && c <= 'z') c = static_cast<unsigned char>(c - 'a' + 'A');
|
||||||
|
key ^= c;
|
||||||
|
key *= 16777619U;
|
||||||
|
}
|
||||||
|
return key;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* An owned ASCII identifier carrying a cached `NameKey`.
|
||||||
|
*/
|
||||||
|
class ascii_string {
|
||||||
|
public:
|
||||||
|
ascii_string() = default;
|
||||||
|
ascii_string(std::string_view text) : text_(text) {}
|
||||||
|
explicit ascii_string(std::string text) : text_(std::move(text)) {}
|
||||||
|
|
||||||
|
[[nodiscard]] auto view() const -> std::string_view { return text_; }
|
||||||
|
[[nodiscard]] auto empty() const -> bool { return text_.empty(); }
|
||||||
|
[[nodiscard]] auto c_str() const -> const char * { return text_.c_str(); }
|
||||||
|
[[nodiscard]] auto key() const -> uint32 { return make_name_key(text_); }
|
||||||
|
|
||||||
|
auto operator==(const ascii_string &) const -> bool = default;
|
||||||
|
auto operator<=>(const ascii_string &) const = default;
|
||||||
|
|
||||||
|
friend auto operator<<(std::ostream &out, const ascii_string &value) -> std::ostream &;
|
||||||
|
|
||||||
|
private:
|
||||||
|
std::string text_;
|
||||||
|
};
|
||||||
|
|
||||||
|
inline auto operator<<(std::ostream &out, const ascii_string &value) -> std::ostream & {
|
||||||
|
return out << value.text_;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A deterministic pseudo-random source.
|
||||||
|
*
|
||||||
|
* SAGE separates the logic and client random streams so replays stay in
|
||||||
|
* sync; this is the logic-stream stand-in. The retail generator constants
|
||||||
|
* are pending recovery, so this uses a standard 32-bit LCG.
|
||||||
|
*/
|
||||||
|
class random {
|
||||||
|
public:
|
||||||
|
explicit random(uint32 seed = 1U) : state_(seed == 0U ? 1U : seed) {}
|
||||||
|
|
||||||
|
auto seed(uint32 value) -> void { state_ = (value == 0U ? 1U : value); }
|
||||||
|
[[nodiscard]] auto state() const -> uint32 { return state_; }
|
||||||
|
|
||||||
|
auto next_uint() -> uint32 {
|
||||||
|
state_ = state_ * 1664525U + 1013904223U;
|
||||||
|
return state_;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Uniform integer in the inclusive range `[lo, hi]`. */
|
||||||
|
auto next_int(int32 lo, int32 hi) -> int32 {
|
||||||
|
if (hi <= lo) return lo;
|
||||||
|
const auto span = static_cast<uint32>(hi - lo + 1);
|
||||||
|
return lo + static_cast<int32>(this->next_uint() % span);
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Uniform real in `[0, 1)`. */
|
||||||
|
auto next_real() -> real { return static_cast<real>(this->next_uint() >> 8) / static_cast<real>(1U << 24); }
|
||||||
|
|
||||||
|
private:
|
||||||
|
uint32 state_;
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Message types carried by the engine's `MessageStream`.
|
||||||
|
*
|
||||||
|
* `new_game` is confirmed against the retail binary: the skirmish BEGIN
|
||||||
|
* handler appends type `0x2` to start a match.
|
||||||
|
*/
|
||||||
|
enum class message_id : uint32 {
|
||||||
|
invalid = 0x0,
|
||||||
|
new_game = 0x2,
|
||||||
|
clear_game_data = 0x3,
|
||||||
|
begin_block = 0x5,
|
||||||
|
end_block = 0x6,
|
||||||
|
};
|
||||||
|
|
||||||
|
[[nodiscard]] constexpr auto to_string(message_id id) -> std::string_view {
|
||||||
|
switch (id) {
|
||||||
|
case message_id::invalid:
|
||||||
|
return "Invalid";
|
||||||
|
case message_id::new_game:
|
||||||
|
return "NewGame";
|
||||||
|
case message_id::clear_game_data:
|
||||||
|
return "ClearGameData";
|
||||||
|
case message_id::begin_block:
|
||||||
|
return "BeginBlock";
|
||||||
|
case message_id::end_block:
|
||||||
|
return "EndBlock";
|
||||||
|
}
|
||||||
|
return "Unknown";
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A single entry in the message stream.
|
||||||
|
*
|
||||||
|
* The retail `MessageStream::appendMessage` allocates a 0x74-byte node
|
||||||
|
* (recovered at `0x0060c4a0`); this is its owning equivalent.
|
||||||
|
*/
|
||||||
|
struct game_message {
|
||||||
|
message_id id = message_id::invalid;
|
||||||
|
uint32 player_index = 0;
|
||||||
|
std::vector<uint8> payload;
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A FIFO of `game_message`s drained once per logic frame.
|
||||||
|
*
|
||||||
|
* In the retail engine the stream is an intrusive doubly linked list
|
||||||
|
* (head at `+0x24`, tail at `+0x28` of the stream object); this is the
|
||||||
|
* behaviourally equivalent owning version.
|
||||||
|
*/
|
||||||
|
class message_stream {
|
||||||
|
public:
|
||||||
|
auto append(message_id id, uint32 player_index = 0U) -> game_message & {
|
||||||
|
auto &slot = messages_.emplace_back();
|
||||||
|
slot.id = id;
|
||||||
|
slot.player_index = player_index;
|
||||||
|
return slot;
|
||||||
|
}
|
||||||
|
|
||||||
|
[[nodiscard]] auto empty() const -> bool { return messages_.empty(); }
|
||||||
|
[[nodiscard]] auto size() const -> usize { return messages_.size(); }
|
||||||
|
[[nodiscard]] auto pending() const -> std::span<const game_message> { return messages_; }
|
||||||
|
|
||||||
|
auto clear() -> void { messages_.clear(); }
|
||||||
|
|
||||||
|
/** Remove and return the oldest message, if any. */
|
||||||
|
auto pop() -> std::optional<game_message> {
|
||||||
|
if (messages_.empty()) return std::nullopt;
|
||||||
|
auto front = std::move(messages_.front());
|
||||||
|
messages_.erase(messages_.begin());
|
||||||
|
return front;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
std::vector<game_message> messages_;
|
||||||
|
};
|
||||||
|
|
||||||
|
inline auto coord3d::length() const -> real { return std::sqrt(this->length_squared()); }
|
||||||
|
|
||||||
|
inline auto coord3d::normalized() const -> coord3d {
|
||||||
|
const auto len = this->length();
|
||||||
|
if (len <= std::numeric_limits<real>::epsilon()) return {0.0F, 0.0F, 0.0F};
|
||||||
|
return *this * (1.0F / len);
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,339 @@
|
|||||||
|
module;
|
||||||
|
|
||||||
|
#include <algorithm>
|
||||||
|
#include <array>
|
||||||
|
#include <cstddef>
|
||||||
|
#include <cstdint>
|
||||||
|
#include <cstdlib>
|
||||||
|
#include <cstring>
|
||||||
|
#include <filesystem>
|
||||||
|
#include <fstream>
|
||||||
|
#include <optional>
|
||||||
|
#include <span>
|
||||||
|
#include <stdexcept>
|
||||||
|
#include <string>
|
||||||
|
#include <string_view>
|
||||||
|
#include <unordered_map>
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
|
export module ra3.fs;
|
||||||
|
|
||||||
|
export import ra3.core;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Reading of the retail game's on-disk assets.
|
||||||
|
*
|
||||||
|
* Red Alert 3 ships its data in `BIG4` archives under `<install>\Data`, with
|
||||||
|
* individual payloads compressed by EA's RefPack codec. This module implements
|
||||||
|
* the container and codec so OpenRA3 can read a user's own installation.
|
||||||
|
*
|
||||||
|
* No game data is ever written into the repository; callers point the loader at
|
||||||
|
* their local install (`--game-dir` / `RA3_GAME_DIR`, default `C:\Red Alert 3`).
|
||||||
|
*/
|
||||||
|
export namespace ra3::fs {
|
||||||
|
using ra3::core::uint32;
|
||||||
|
using ra3::core::uint8;
|
||||||
|
using ra3::core::usize;
|
||||||
|
|
||||||
|
/** Thrown when a `BIG4` archive is malformed or an entry is missing. */
|
||||||
|
class archive_error : public std::runtime_error {
|
||||||
|
public:
|
||||||
|
using std::runtime_error::runtime_error;
|
||||||
|
};
|
||||||
|
|
||||||
|
/** Thrown when a RefPack stream is malformed. */
|
||||||
|
class refpack_error : public std::runtime_error {
|
||||||
|
public:
|
||||||
|
using std::runtime_error::runtime_error;
|
||||||
|
};
|
||||||
|
|
||||||
|
inline constexpr std::array<uint8, 4> big_magic{'B', 'I', 'G', '4'};
|
||||||
|
inline constexpr uint8 refpack_mask = 0x3EU;
|
||||||
|
inline constexpr uint8 refpack_magic2 = 0xFBU;
|
||||||
|
|
||||||
|
/** One file inside a `BIG4` archive. */
|
||||||
|
struct big_entry {
|
||||||
|
std::string name;
|
||||||
|
uint32 offset = 0;
|
||||||
|
uint32 size = 0;
|
||||||
|
};
|
||||||
|
|
||||||
|
/** True when `data` starts with a RefPack header (`0b??010000`, `0xFB`). */
|
||||||
|
[[nodiscard]] inline auto is_refpack(std::span<const uint8> data) -> bool {
|
||||||
|
return data.size() >= 2 && (data[0] & refpack_mask) == 0x10U && data[1] == refpack_magic2;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Decompress an EA RefPack stream.
|
||||||
|
*
|
||||||
|
* @param data Compressed stream, starting at the header byte.
|
||||||
|
* @return The decompressed bytes.
|
||||||
|
* @throws refpack_error if the stream is malformed or the length disagrees.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] inline auto refpack_decompress(std::span<const uint8> data) -> std::vector<uint8> {
|
||||||
|
if (!is_refpack(data)) throw refpack_error("not a RefPack stream");
|
||||||
|
|
||||||
|
usize pos = 0;
|
||||||
|
const auto header = data[pos++];
|
||||||
|
const bool large_files = (header & 0x80U) != 0;
|
||||||
|
const bool compressed_size_present = (header & 0x01U) != 0;
|
||||||
|
pos++; // 0xFB
|
||||||
|
|
||||||
|
const usize size_bytes = large_files ? 4U : 3U;
|
||||||
|
auto read_size = [&]() -> uint32 {
|
||||||
|
uint32 value = 0;
|
||||||
|
for (usize i = 0; i < size_bytes; ++i) {
|
||||||
|
if (pos >= data.size()) throw refpack_error("truncated RefPack size field");
|
||||||
|
value = (value << 8) | data[pos++];
|
||||||
|
}
|
||||||
|
return value;
|
||||||
|
};
|
||||||
|
|
||||||
|
if (compressed_size_present) (void)read_size();
|
||||||
|
const auto out_len = read_size();
|
||||||
|
|
||||||
|
std::vector<uint8> out;
|
||||||
|
out.reserve(out_len);
|
||||||
|
|
||||||
|
auto copy_literals = [&](usize count) {
|
||||||
|
if (pos + count > data.size()) throw refpack_error("truncated RefPack literals");
|
||||||
|
out.insert(out.end(), data.begin() + static_cast<std::ptrdiff_t>(pos), data.begin() + static_cast<std::ptrdiff_t>(pos + count));
|
||||||
|
pos += count;
|
||||||
|
};
|
||||||
|
|
||||||
|
auto copy_reference = [&](usize length, usize distance) {
|
||||||
|
if (distance == 0 || distance > out.size()) throw refpack_error("RefPack back-reference out of range");
|
||||||
|
usize start = out.size() - distance;
|
||||||
|
for (usize i = 0; i < length; ++i) out.push_back(out[start + i]);
|
||||||
|
};
|
||||||
|
|
||||||
|
while (pos < data.size()) {
|
||||||
|
const auto cmd = data[pos++];
|
||||||
|
if ((cmd & 0x80U) == 0) { // 2-byte command
|
||||||
|
if (pos >= data.size()) throw refpack_error("truncated 2-byte command");
|
||||||
|
const auto b2 = data[pos++];
|
||||||
|
copy_literals(cmd & 0x03U);
|
||||||
|
copy_reference(((cmd & 0x1CU) >> 2) + 3, ((cmd & 0x60U) << 3) + b2 + 1);
|
||||||
|
} else if ((cmd & 0x40U) == 0) { // 3-byte command
|
||||||
|
if (pos + 1 >= data.size()) throw refpack_error("truncated 3-byte command");
|
||||||
|
const auto b2 = data[pos];
|
||||||
|
const auto b3 = data[pos + 1];
|
||||||
|
pos += 2;
|
||||||
|
copy_literals((b2 & 0xC0U) >> 6);
|
||||||
|
copy_reference((cmd & 0x3FU) + 4, ((b2 & 0x3FU) << 8) + b3 + 1);
|
||||||
|
} else if ((cmd & 0x20U) == 0) { // 4-byte command
|
||||||
|
if (pos + 2 >= data.size()) throw refpack_error("truncated 4-byte command");
|
||||||
|
const auto b2 = data[pos];
|
||||||
|
const auto b3 = data[pos + 1];
|
||||||
|
const auto b4 = data[pos + 2];
|
||||||
|
pos += 3;
|
||||||
|
copy_literals(cmd & 0x03U);
|
||||||
|
copy_reference(((cmd & 0x0CU) << 6) + b4 + 5, ((cmd & 0x10U) << 12) + (b2 << 8) + b3 + 1);
|
||||||
|
} else if (cmd < 0xFCU) { // long literal run
|
||||||
|
copy_literals(((cmd & 0x1FU) + 1) << 2);
|
||||||
|
} else { // stop
|
||||||
|
copy_literals(cmd & 0x03U);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (out.size() != out_len) throw refpack_error("RefPack length mismatch");
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Decompress `data` when it is RefPack, otherwise copy it unchanged. */
|
||||||
|
[[nodiscard]] inline auto maybe_decompress(std::span<const uint8> data) -> std::vector<uint8> {
|
||||||
|
if (is_refpack(data)) return refpack_decompress(data);
|
||||||
|
return {data.begin(), data.end()};
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Read the declared output size from a RefPack header without decompressing.
|
||||||
|
*
|
||||||
|
* @throws refpack_error if the stream is malformed.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] inline auto refpack_output_size(std::span<const uint8> data) -> uint32 {
|
||||||
|
if (!is_refpack(data)) throw refpack_error("not a RefPack stream");
|
||||||
|
usize pos = 0;
|
||||||
|
const auto header = data[pos++];
|
||||||
|
const bool large_files = (header & 0x80U) != 0;
|
||||||
|
const bool compressed_size_present = (header & 0x01U) != 0;
|
||||||
|
pos++; // 0xFB
|
||||||
|
const usize size_bytes = large_files ? 4U : 3U;
|
||||||
|
auto read_size = [&]() -> uint32 {
|
||||||
|
uint32 value = 0;
|
||||||
|
for (usize i = 0; i < size_bytes; ++i) {
|
||||||
|
if (pos >= data.size()) throw refpack_error("truncated RefPack size field");
|
||||||
|
value = (value << 8) | data[pos++];
|
||||||
|
}
|
||||||
|
return value;
|
||||||
|
};
|
||||||
|
if (compressed_size_present) (void)read_size();
|
||||||
|
return read_size();
|
||||||
|
}
|
||||||
|
|
||||||
|
[[nodiscard]] constexpr auto read_be32(const uint8 *p) -> uint32 {
|
||||||
|
return (static_cast<uint32>(p[0]) << 24U) | (static_cast<uint32>(p[1]) << 16U) | (static_cast<uint32>(p[2]) << 8U) | static_cast<uint32>(p[3]);
|
||||||
|
}
|
||||||
|
|
||||||
|
[[nodiscard]] constexpr auto read_le32(const uint8 *p) -> uint32 {
|
||||||
|
return static_cast<uint32>(p[0]) | (static_cast<uint32>(p[1]) << 8U) | (static_cast<uint32>(p[2]) << 16U) | (static_cast<uint32>(p[3]) << 24U);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A parsed `BIG4` archive. Only the index is held in memory; payloads are
|
||||||
|
* read from disk on demand so multi-hundred-megabyte archives stay cheap.
|
||||||
|
*/
|
||||||
|
class big_archive {
|
||||||
|
public:
|
||||||
|
/**
|
||||||
|
* Parse the index of a `BIG4` archive.
|
||||||
|
*
|
||||||
|
* @param path Archive path.
|
||||||
|
* @throws archive_error if the file is missing, not `BIG4`, or truncated.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] static auto open(const std::filesystem::path &path) -> big_archive {
|
||||||
|
big_archive archive;
|
||||||
|
archive.path_ = path;
|
||||||
|
std::error_code ec;
|
||||||
|
archive.file_size_ = static_cast<usize>(std::filesystem::file_size(path, ec));
|
||||||
|
if (ec) throw archive_error("cannot stat archive: " + path.string());
|
||||||
|
|
||||||
|
std::ifstream in(path, std::ios::binary);
|
||||||
|
if (!in) throw archive_error("cannot open archive: " + path.string());
|
||||||
|
|
||||||
|
std::array<uint8, 16> header{};
|
||||||
|
in.read(reinterpret_cast<char *>(header.data()), static_cast<std::streamsize>(header.size()));
|
||||||
|
if (!in || std::memcmp(header.data(), big_magic.data(), big_magic.size()) != 0) throw archive_error("not a BIG4 archive: " + path.string());
|
||||||
|
|
||||||
|
const auto count = read_be32(header.data() + 8);
|
||||||
|
|
||||||
|
// Read the variable-length index, growing the window until parsed.
|
||||||
|
usize window = std::min(archive.file_size_, std::max<usize>(1U << 20U, static_cast<usize>(count) * 256U));
|
||||||
|
std::vector<uint8> index;
|
||||||
|
for (;;) {
|
||||||
|
index.resize(window);
|
||||||
|
in.clear();
|
||||||
|
in.seekg(0);
|
||||||
|
in.read(reinterpret_cast<char *>(index.data()), static_cast<std::streamsize>(window));
|
||||||
|
const auto got = static_cast<usize>(in.gcount());
|
||||||
|
index.resize(got);
|
||||||
|
|
||||||
|
archive.entries_.clear();
|
||||||
|
archive.entries_.reserve(count);
|
||||||
|
usize pos = 16;
|
||||||
|
bool complete = true;
|
||||||
|
for (uint32 i = 0; i < count; ++i) {
|
||||||
|
if (pos + 8 > index.size()) {
|
||||||
|
complete = false;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
big_entry entry;
|
||||||
|
entry.offset = read_be32(index.data() + pos);
|
||||||
|
entry.size = read_be32(index.data() + pos + 4);
|
||||||
|
pos += 8;
|
||||||
|
const auto *begin = reinterpret_cast<const char *>(index.data() + pos);
|
||||||
|
const auto *end = reinterpret_cast<const char *>(std::memchr(begin, '\0', index.size() - pos));
|
||||||
|
if (end == nullptr) {
|
||||||
|
complete = false;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
entry.name.assign(begin, end);
|
||||||
|
pos += static_cast<usize>(end - begin) + 1U;
|
||||||
|
archive.entries_.push_back(std::move(entry));
|
||||||
|
}
|
||||||
|
if (complete) break;
|
||||||
|
if (window >= archive.file_size_) throw archive_error("truncated BIG4 index: " + path.string());
|
||||||
|
window = std::min(archive.file_size_, window * 2U);
|
||||||
|
}
|
||||||
|
|
||||||
|
archive.index_.reserve(archive.entries_.size());
|
||||||
|
for (usize i = 0; i < archive.entries_.size(); ++i) archive.index_.emplace(archive.entries_[i].name, i);
|
||||||
|
return archive;
|
||||||
|
}
|
||||||
|
|
||||||
|
[[nodiscard]] auto path() const -> const std::filesystem::path & { return path_; }
|
||||||
|
[[nodiscard]] auto entries() const -> const std::vector<big_entry> & { return entries_; }
|
||||||
|
[[nodiscard]] auto size() const -> usize { return entries_.size(); }
|
||||||
|
[[nodiscard]] auto contains(std::string_view name) const -> bool { return index_.contains(std::string{name}); }
|
||||||
|
|
||||||
|
/** Entry names whose path contains `needle`, in index order. */
|
||||||
|
[[nodiscard]] auto find(std::string_view needle) const -> std::vector<const big_entry *> {
|
||||||
|
std::vector<const big_entry *> matches;
|
||||||
|
for (const auto &entry: entries_) {
|
||||||
|
if (entry.name.find(needle) != std::string::npos) matches.push_back(&entry);
|
||||||
|
}
|
||||||
|
return matches;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Read an entry's payload.
|
||||||
|
*
|
||||||
|
* @param name Entry name (backslash-separated, case-sensitive).
|
||||||
|
* @param decompress RefPack-decompress the payload when true.
|
||||||
|
* @throws archive_error if the entry is missing or unreadable.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] auto read(std::string_view name, bool decompress = true) const -> std::vector<uint8> {
|
||||||
|
const auto it = index_.find(std::string{name});
|
||||||
|
if (it == index_.end()) throw archive_error("no such entry: " + std::string{name});
|
||||||
|
const auto &entry = entries_[it->second];
|
||||||
|
|
||||||
|
std::ifstream in(path_, std::ios::binary);
|
||||||
|
if (!in) throw archive_error("cannot open archive: " + path_.string());
|
||||||
|
in.seekg(static_cast<std::streamoff>(entry.offset));
|
||||||
|
std::vector<uint8> raw(entry.size);
|
||||||
|
in.read(reinterpret_cast<char *>(raw.data()), static_cast<std::streamsize>(raw.size()));
|
||||||
|
if (!in) throw archive_error("short read for entry: " + entry.name);
|
||||||
|
return decompress ? maybe_decompress(raw) : raw;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Read the first `count` stored bytes of an entry (no decompression). */
|
||||||
|
[[nodiscard]] auto read_prefix(std::string_view name, usize count) const -> std::vector<uint8> {
|
||||||
|
const auto it = index_.find(std::string{name});
|
||||||
|
if (it == index_.end()) throw archive_error("no such entry: " + std::string{name});
|
||||||
|
const auto &entry = entries_[it->second];
|
||||||
|
|
||||||
|
std::ifstream in(path_, std::ios::binary);
|
||||||
|
if (!in) throw archive_error("cannot open archive: " + path_.string());
|
||||||
|
in.seekg(static_cast<std::streamoff>(entry.offset));
|
||||||
|
const auto want = std::min(count, static_cast<usize>(entry.size));
|
||||||
|
std::vector<uint8> raw(want);
|
||||||
|
in.read(reinterpret_cast<char *>(raw.data()), static_cast<std::streamsize>(raw.size()));
|
||||||
|
raw.resize(static_cast<usize>(in.gcount()));
|
||||||
|
return raw;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
big_archive() = default;
|
||||||
|
|
||||||
|
std::filesystem::path path_;
|
||||||
|
usize file_size_ = 0;
|
||||||
|
std::vector<big_entry> entries_;
|
||||||
|
std::unordered_map<std::string, usize> index_;
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Locate a Red Alert 3 installation.
|
||||||
|
*
|
||||||
|
* Resolution order: the explicit argument, then `$RA3_GAME_DIR`, then the
|
||||||
|
* default `C:\Red Alert 3`. A directory qualifies only if it has a `Data`
|
||||||
|
* subdirectory.
|
||||||
|
*
|
||||||
|
* @return The install root, or `std::nullopt` when none is found.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] inline auto find_game_dir(const std::optional<std::filesystem::path> &explicit_dir = std::nullopt) -> std::optional<std::filesystem::path> {
|
||||||
|
auto qualifies = [](const std::filesystem::path &candidate) {
|
||||||
|
std::error_code ec;
|
||||||
|
return !candidate.empty() && std::filesystem::is_directory(candidate / "Data", ec);
|
||||||
|
};
|
||||||
|
|
||||||
|
if (explicit_dir && qualifies(*explicit_dir)) return explicit_dir;
|
||||||
|
if (const auto *env = std::getenv("RA3_GAME_DIR"); env != nullptr && *env != '\0') {
|
||||||
|
const std::filesystem::path candidate{env};
|
||||||
|
if (qualifies(candidate)) return candidate;
|
||||||
|
}
|
||||||
|
const std::filesystem::path default_dir{"C:/Red Alert 3"};
|
||||||
|
if (qualifies(default_dir)) return default_dir;
|
||||||
|
return std::nullopt;
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,72 @@
|
|||||||
|
module;
|
||||||
|
|
||||||
|
#include <cstdint>
|
||||||
|
#include <string>
|
||||||
|
#include <string_view>
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
|
export module ra3.game;
|
||||||
|
|
||||||
|
import ra3.core;
|
||||||
|
import ra3.logic;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Red Alert 3 game definitions: the three base-game sides and the data that
|
||||||
|
* seeds a skirmish.
|
||||||
|
*
|
||||||
|
* The `faction` values are recovered from the retail skirmish setup object,
|
||||||
|
* where a slot stores its side at `slot + 0x18`.
|
||||||
|
*/
|
||||||
|
export namespace ra3::game {
|
||||||
|
using ra3::core::int32;
|
||||||
|
using ra3::core::uint32;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Faction bit flags as stored by the retail skirmish setup.
|
||||||
|
*/
|
||||||
|
enum class faction : uint32 {
|
||||||
|
none = 0U,
|
||||||
|
empire = 2U,
|
||||||
|
allied = 4U,
|
||||||
|
random = 7U,
|
||||||
|
soviet = 8U,
|
||||||
|
};
|
||||||
|
|
||||||
|
[[nodiscard]] constexpr auto to_string(faction value) -> std::string_view {
|
||||||
|
switch (value) {
|
||||||
|
case faction::empire:
|
||||||
|
return "Empire";
|
||||||
|
case faction::allied:
|
||||||
|
return "Allied";
|
||||||
|
case faction::soviet:
|
||||||
|
return "Soviet";
|
||||||
|
case faction::random:
|
||||||
|
return "Random";
|
||||||
|
case faction::none:
|
||||||
|
return "None";
|
||||||
|
}
|
||||||
|
return "Unknown";
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Static description of a playable side, the OpenRA3 analogue of a
|
||||||
|
* `PlayerTemplate` entry.
|
||||||
|
*/
|
||||||
|
struct player_template {
|
||||||
|
std::string name;
|
||||||
|
faction side = faction::none;
|
||||||
|
int32 starting_money = 10000;
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The three base-game sides. Skirmish defaults to 10,000 credits, matching
|
||||||
|
* the retail setup object at `setup + 0x64`.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] inline auto base_templates() -> std::vector<player_template> {
|
||||||
|
return {
|
||||||
|
{"Allied", faction::allied, 10000},
|
||||||
|
{"Soviet", faction::soviet, 10000},
|
||||||
|
{"Empire", faction::empire, 10000},
|
||||||
|
};
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,304 @@
|
|||||||
|
module;
|
||||||
|
|
||||||
|
#include <cstddef>
|
||||||
|
#include <cstdint>
|
||||||
|
#include <memory>
|
||||||
|
#include <span>
|
||||||
|
#include <string>
|
||||||
|
#include <string_view>
|
||||||
|
#include <unordered_map>
|
||||||
|
#include <utility>
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
|
export module ra3.logic;
|
||||||
|
|
||||||
|
import ra3.core;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The deterministic simulation layer: objects, players, teams, spatial
|
||||||
|
* partitioning and the 30 Hz game loop.
|
||||||
|
*
|
||||||
|
* This is the OpenRA3 counterpart of SAGE's `GameLogic` subsystem. Addresses
|
||||||
|
* cited in comments come from the retail `ra3_1.12.game` binary (image base
|
||||||
|
* `0x400000`); they are the anchors used to keep this reconstruction honest.
|
||||||
|
*/
|
||||||
|
export namespace ra3::logic {
|
||||||
|
using ra3::core::coord3d;
|
||||||
|
using ra3::core::int32;
|
||||||
|
using ra3::core::message_id;
|
||||||
|
using ra3::core::message_stream;
|
||||||
|
using ra3::core::random;
|
||||||
|
using ra3::core::real;
|
||||||
|
using ra3::core::uint32;
|
||||||
|
using ra3::core::uint8;
|
||||||
|
using ra3::core::usize;
|
||||||
|
|
||||||
|
using object_id = uint32;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Broad classification of a game object.
|
||||||
|
*/
|
||||||
|
enum class object_kind : uint8 {
|
||||||
|
invalid = 0,
|
||||||
|
infantry,
|
||||||
|
vehicle,
|
||||||
|
aircraft,
|
||||||
|
structure,
|
||||||
|
projectile,
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A thing the partition manager can index (SAGE `Thing`).
|
||||||
|
*/
|
||||||
|
class thing {
|
||||||
|
public:
|
||||||
|
explicit thing(object_id id) : id_(id) {}
|
||||||
|
virtual ~thing() = default;
|
||||||
|
|
||||||
|
[[nodiscard]] auto id() const -> object_id { return id_; }
|
||||||
|
[[nodiscard]] auto position() const -> const coord3d & { return position_; }
|
||||||
|
auto set_position(const coord3d &value) -> void { position_ = value; }
|
||||||
|
|
||||||
|
/** Bounding radius used by the spatial partition. */
|
||||||
|
[[nodiscard]] virtual auto radius() const -> real { return 0.0F; }
|
||||||
|
|
||||||
|
protected:
|
||||||
|
object_id id_;
|
||||||
|
coord3d position_;
|
||||||
|
};
|
||||||
|
|
||||||
|
class object;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A pluggable behaviour ticked every logic frame (SAGE `UpdateModule`).
|
||||||
|
*/
|
||||||
|
class update_module {
|
||||||
|
public:
|
||||||
|
virtual ~update_module() = default;
|
||||||
|
|
||||||
|
virtual auto update(object &owner) -> void = 0;
|
||||||
|
[[nodiscard]] virtual auto name() const -> std::string_view = 0;
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A simulation entity (SAGE `Object`): identity, ownership, health and a
|
||||||
|
* list of behaviour modules.
|
||||||
|
*/
|
||||||
|
class object : public thing {
|
||||||
|
public:
|
||||||
|
object(object_id id, object_kind kind, uint32 owner_player) : thing(id), kind_(kind), owner_(owner_player) {}
|
||||||
|
|
||||||
|
[[nodiscard]] auto kind() const -> object_kind { return kind_; }
|
||||||
|
[[nodiscard]] auto owner() const -> uint32 { return owner_; }
|
||||||
|
|
||||||
|
[[nodiscard]] auto health() const -> real { return health_; }
|
||||||
|
auto set_health(real value) -> void { health_ = value; }
|
||||||
|
auto damage(real amount) -> void { health_ = health_ > amount ? health_ - amount : 0.0F; }
|
||||||
|
[[nodiscard]] auto destroyed() const -> bool { return health_ <= 0.0F; }
|
||||||
|
|
||||||
|
[[nodiscard]] auto radius() const -> real override { return radius_; }
|
||||||
|
auto set_radius(real value) -> void { radius_ = value; }
|
||||||
|
|
||||||
|
auto add_module(std::unique_ptr<update_module> module) -> void { modules_.push_back(std::move(module)); }
|
||||||
|
[[nodiscard]] auto module_count() const -> usize { return modules_.size(); }
|
||||||
|
|
||||||
|
/** Tick every attached behaviour module. */
|
||||||
|
auto update() -> void {
|
||||||
|
for (const auto &module: modules_) module->update(*this);
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
object_kind kind_ = object_kind::invalid;
|
||||||
|
uint32 owner_ = 0U;
|
||||||
|
real health_ = 1.0F;
|
||||||
|
real radius_ = 0.0F;
|
||||||
|
std::vector<std::unique_ptr<update_module>> modules_;
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A participant in a match.
|
||||||
|
*
|
||||||
|
* The retail `Player` keeps money behind a `std::vector<Money*>` at
|
||||||
|
* `+0xe4` and power at `+0x74`; the fields here collapse those into plain
|
||||||
|
* values until the pointer indirection matters.
|
||||||
|
*/
|
||||||
|
class player {
|
||||||
|
public:
|
||||||
|
player(uint32 index, std::string name) : index_(index), name_(std::move(name)) {}
|
||||||
|
|
||||||
|
[[nodiscard]] auto index() const -> uint32 { return index_; }
|
||||||
|
[[nodiscard]] auto name() const -> const std::string & { return name_; }
|
||||||
|
|
||||||
|
[[nodiscard]] auto money() const -> int32 { return money_; }
|
||||||
|
auto set_money(int32 value) -> void { money_ = value < 0 ? 0 : value; }
|
||||||
|
auto add_money(int32 delta) -> void { this->set_money(money_ + delta); }
|
||||||
|
|
||||||
|
[[nodiscard]] auto power_produced() const -> int32 { return power_produced_; }
|
||||||
|
[[nodiscard]] auto power_consumed() const -> int32 { return power_consumed_; }
|
||||||
|
auto set_power(int32 produced, int32 consumed) -> void {
|
||||||
|
power_produced_ = produced;
|
||||||
|
power_consumed_ = consumed;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Faction bit flag (see `ra3::game::faction`). */
|
||||||
|
[[nodiscard]] auto faction() const -> uint32 { return faction_; }
|
||||||
|
auto set_faction(uint32 value) -> void { faction_ = value; }
|
||||||
|
|
||||||
|
[[nodiscard]] auto human() const -> bool { return human_; }
|
||||||
|
auto set_human(bool value) -> void { human_ = value; }
|
||||||
|
|
||||||
|
private:
|
||||||
|
uint32 index_;
|
||||||
|
std::string name_;
|
||||||
|
int32 money_ = 0;
|
||||||
|
int32 power_produced_ = 0;
|
||||||
|
int32 power_consumed_ = 0;
|
||||||
|
uint32 faction_ = 0U;
|
||||||
|
bool human_ = false;
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The ordered set of players in a match (SAGE `PlayerList`).
|
||||||
|
*
|
||||||
|
* The retail list materialises an inline array of 20 `Player*` starting at
|
||||||
|
* `+0x30`; this owns them instead.
|
||||||
|
*/
|
||||||
|
class player_list {
|
||||||
|
public:
|
||||||
|
auto add(std::unique_ptr<player> value) -> player & {
|
||||||
|
auto &ref = *value;
|
||||||
|
players_.push_back(std::move(value));
|
||||||
|
return ref;
|
||||||
|
}
|
||||||
|
|
||||||
|
[[nodiscard]] auto size() const -> usize { return players_.size(); }
|
||||||
|
[[nodiscard]] auto at(usize index) -> player & { return *players_.at(index); }
|
||||||
|
[[nodiscard]] auto at(usize index) const -> const player & { return *players_.at(index); }
|
||||||
|
|
||||||
|
/** First human-controlled player, or `nullptr` in an all-AI match. */
|
||||||
|
[[nodiscard]] auto human() -> player * {
|
||||||
|
for (const auto &entry: players_) {
|
||||||
|
if (entry->human()) return entry.get();
|
||||||
|
}
|
||||||
|
return nullptr;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
std::vector<std::unique_ptr<player>> players_;
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A spatial index over `Thing`s, bucketed on a fixed-size grid.
|
||||||
|
*
|
||||||
|
* A stand-in for SAGE's `PartitionManager`, which indexes the world into
|
||||||
|
* cells and answers proximity queries.
|
||||||
|
*/
|
||||||
|
class partition_manager {
|
||||||
|
public:
|
||||||
|
explicit partition_manager(real cell_size = 40.0F) : cell_size_(cell_size) {}
|
||||||
|
|
||||||
|
auto insert(thing &value) -> void { cells_[this->cell_of(value.position())].push_back(&value); }
|
||||||
|
auto clear() -> void { cells_.clear(); }
|
||||||
|
[[nodiscard]] auto cell_count() const -> usize { return cells_.size(); }
|
||||||
|
|
||||||
|
/** Non-owning view of everything bucketed with `position`. */
|
||||||
|
[[nodiscard]] auto things_at(const coord3d &position) -> std::span<thing *> {
|
||||||
|
const auto it = cells_.find(this->cell_of(position));
|
||||||
|
if (it == cells_.end()) return {};
|
||||||
|
return it->second;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
struct cell_key {
|
||||||
|
int32 x = 0;
|
||||||
|
int32 y = 0;
|
||||||
|
auto operator==(const cell_key &) const -> bool = default;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct cell_hash {
|
||||||
|
auto operator()(const cell_key &key) const -> usize {
|
||||||
|
return (static_cast<usize>(static_cast<uint32>(key.x)) << 32U) ^ static_cast<uint32>(key.y);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
[[nodiscard]] auto cell_of(const coord3d &position) const -> cell_key {
|
||||||
|
return {static_cast<int32>(position.x / cell_size_), static_cast<int32>(position.y / cell_size_)};
|
||||||
|
}
|
||||||
|
|
||||||
|
real cell_size_;
|
||||||
|
std::unordered_map<cell_key, std::vector<thing *>, cell_hash> cells_;
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The simulation root and frame driver (SAGE `GameLogic`, singleton at
|
||||||
|
* `[0x00cd8ce4]` in the retail binary).
|
||||||
|
*
|
||||||
|
* `frame()` corresponds to the tick counter at `TheGameLogic + 0x50`, and
|
||||||
|
* `starting()` to the guard flag at `+0xa7` that the retail start routine
|
||||||
|
* raises while subsystems initialise.
|
||||||
|
*/
|
||||||
|
class game_logic {
|
||||||
|
public:
|
||||||
|
game_logic() = default;
|
||||||
|
|
||||||
|
[[nodiscard]] auto frame() const -> uint32 { return frame_; }
|
||||||
|
[[nodiscard]] auto starting() const -> bool { return starting_; }
|
||||||
|
|
||||||
|
[[nodiscard]] auto players() -> player_list & { return players_; }
|
||||||
|
[[nodiscard]] auto partition() -> partition_manager & { return partition_; }
|
||||||
|
[[nodiscard]] auto messages() -> message_stream & { return messages_; }
|
||||||
|
[[nodiscard]] auto random() -> ra3::core::random & { return random_; }
|
||||||
|
|
||||||
|
/**
|
||||||
|
* First half of starting a match: reset subsystems and seed the random
|
||||||
|
* stream. Mirrors the retail reset that runs before the message pump
|
||||||
|
* drains (the retail `startNewGame` raises `TheGameLogic + 0xa7`).
|
||||||
|
*
|
||||||
|
* @param seed Deterministic seed for the logic random stream.
|
||||||
|
*/
|
||||||
|
auto prepare_new_game(uint32 seed) -> void {
|
||||||
|
frame_ = 0U;
|
||||||
|
starting_ = true;
|
||||||
|
partition_.clear();
|
||||||
|
objects_.clear();
|
||||||
|
messages_.clear();
|
||||||
|
random_.seed(seed);
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Second half: emit `new_game` so the pump starts the match. */
|
||||||
|
auto start_new_game() -> void {
|
||||||
|
messages_.append(message_id::new_game, 0U);
|
||||||
|
starting_ = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
auto add_object(std::unique_ptr<object> value) -> object & {
|
||||||
|
auto &ref = *value;
|
||||||
|
partition_.insert(ref);
|
||||||
|
objects_.push_back(std::move(value));
|
||||||
|
return ref;
|
||||||
|
}
|
||||||
|
|
||||||
|
[[nodiscard]] auto object_count() const -> usize { return objects_.size(); }
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Advance the simulation by exactly one 30 Hz logic frame: drain the
|
||||||
|
* message stream, tick every object, then bump the frame counter.
|
||||||
|
*/
|
||||||
|
auto update() -> void {
|
||||||
|
while (const auto message = messages_.pop()) {
|
||||||
|
(void)message;
|
||||||
|
}
|
||||||
|
for (const auto &entry: objects_) entry->update();
|
||||||
|
++frame_;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
uint32 frame_ = 0U;
|
||||||
|
bool starting_ = false;
|
||||||
|
player_list players_;
|
||||||
|
partition_manager partition_;
|
||||||
|
message_stream messages_;
|
||||||
|
ra3::core::random random_{1U};
|
||||||
|
std::vector<std::unique_ptr<object>> objects_;
|
||||||
|
};
|
||||||
|
}
|
||||||
@@ -0,0 +1,222 @@
|
|||||||
|
module;
|
||||||
|
|
||||||
|
#include <algorithm>
|
||||||
|
#include <cmath>
|
||||||
|
#include <cstdint>
|
||||||
|
#include <cstring>
|
||||||
|
#include <optional>
|
||||||
|
#include <span>
|
||||||
|
#include <string>
|
||||||
|
#include <string_view>
|
||||||
|
#include <utility>
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
|
export module ra3.map;
|
||||||
|
|
||||||
|
export import ra3.core;
|
||||||
|
export import ra3.fs;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Red Alert 3 map discovery and loading.
|
||||||
|
*
|
||||||
|
* Multiplayer maps live in `Data\MapsMultiplayer.big` as one directory per map:
|
||||||
|
* `<id>\<id>.map` plus compiled companions. The `.map` file is an `EAR\0`
|
||||||
|
* wrapper around a RefPack stream whose payload is the `CkMp` chunk tree.
|
||||||
|
*
|
||||||
|
* This module reads the archive for real, unwraps the map, and extracts the
|
||||||
|
* `Player_N_Start` waypoint coordinates that seed a skirmish. Anything beyond
|
||||||
|
* start positions (terrain, objects) is the next milestone.
|
||||||
|
*/
|
||||||
|
export namespace ra3::map {
|
||||||
|
using ra3::core::coord3d;
|
||||||
|
using ra3::core::real;
|
||||||
|
using ra3::core::uint32;
|
||||||
|
using ra3::core::uint8;
|
||||||
|
using ra3::core::usize;
|
||||||
|
|
||||||
|
/** A player start location extracted from a map's waypoints. */
|
||||||
|
struct start_position {
|
||||||
|
real x = 0.0F;
|
||||||
|
real y = 0.0F;
|
||||||
|
real z = 0.0F;
|
||||||
|
|
||||||
|
[[nodiscard]] auto as_coord() const -> coord3d { return {x, y, z}; }
|
||||||
|
};
|
||||||
|
|
||||||
|
/** Identity and sizes of one map inside an archive. */
|
||||||
|
struct map_info {
|
||||||
|
std::string id;
|
||||||
|
std::string entry;
|
||||||
|
uint32 stored_size = 0;
|
||||||
|
uint32 unpacked_size = 0;
|
||||||
|
};
|
||||||
|
|
||||||
|
/** The result of loading a map: its metadata and recovered start positions. */
|
||||||
|
struct loaded_map {
|
||||||
|
map_info info;
|
||||||
|
std::vector<start_position> starts;
|
||||||
|
usize ckmp_size = 0;
|
||||||
|
};
|
||||||
|
|
||||||
|
namespace detail {
|
||||||
|
[[nodiscard]] inline auto split_path(std::string_view path) -> std::vector<std::string> {
|
||||||
|
std::vector<std::string> parts;
|
||||||
|
usize start = 0;
|
||||||
|
while (start <= path.size()) {
|
||||||
|
const auto at = path.find_first_of("\\/", start);
|
||||||
|
const auto end = at == std::string_view::npos ? path.size() : at;
|
||||||
|
parts.emplace_back(path.substr(start, end - start));
|
||||||
|
if (at == std::string_view::npos) break;
|
||||||
|
start = at + 1;
|
||||||
|
}
|
||||||
|
return parts;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** True for a main map entry (`.../<stem>/<stem>.map`). */
|
||||||
|
[[nodiscard]] inline auto is_main_map(const fs::big_entry &entry) -> bool {
|
||||||
|
const auto parts = split_path(entry.name);
|
||||||
|
if (parts.size() < 2) return false;
|
||||||
|
const auto &file = parts[parts.size() - 1];
|
||||||
|
const auto &parent = parts[parts.size() - 2];
|
||||||
|
if (file.size() < 5 || file.compare(file.size() - 4, 4, ".map") != 0) return false;
|
||||||
|
const auto stem = file.substr(0, file.size() - 4);
|
||||||
|
return stem == parent && !stem.ends_with("_edit");
|
||||||
|
}
|
||||||
|
|
||||||
|
[[nodiscard]] inline auto stem_of(std::string_view path) -> std::string {
|
||||||
|
const auto parts = split_path(path);
|
||||||
|
if (parts.empty()) return {};
|
||||||
|
auto file = parts.back();
|
||||||
|
if (file.size() > 4 && file.compare(file.size() - 4, 4, ".map") == 0) file.resize(file.size() - 4);
|
||||||
|
return file;
|
||||||
|
}
|
||||||
|
|
||||||
|
[[nodiscard]] inline auto find_bytes(std::span<const uint8> haystack, std::string_view needle) -> usize {
|
||||||
|
if (needle.empty()) return 0;
|
||||||
|
const auto *needle_begin = reinterpret_cast<const uint8 *>(needle.data());
|
||||||
|
const auto it = std::search(haystack.begin(), haystack.end(), needle_begin, needle_begin + needle.size());
|
||||||
|
return it == haystack.end() ? static_cast<usize>(-1) : static_cast<usize>(it - haystack.begin());
|
||||||
|
}
|
||||||
|
|
||||||
|
[[nodiscard]] inline auto read_le_f32(const uint8 *p) -> real {
|
||||||
|
const auto bits = fs::read_le32(p);
|
||||||
|
real value = 0.0F;
|
||||||
|
std::memcpy(&value, &bits, sizeof(value));
|
||||||
|
return value;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** First plausible `(x, y, 0)` float triple at or after `from`. */
|
||||||
|
[[nodiscard]] inline auto scan_triple(std::span<const uint8> data, usize from, usize window) -> std::optional<start_position> {
|
||||||
|
const auto end = std::min(data.size(), from + window);
|
||||||
|
for (usize p = from; p + 12U <= end; ++p) {
|
||||||
|
const auto x = read_le_f32(data.data() + p);
|
||||||
|
const auto y = read_le_f32(data.data() + p + 4U);
|
||||||
|
const auto z = read_le_f32(data.data() + p + 8U);
|
||||||
|
if (z == 0.0F && std::isfinite(x) && std::isfinite(y) && x > 0.0F && x < 20000.0F && y > 0.0F && y < 20000.0F) {
|
||||||
|
return start_position{x, y, z};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return std::nullopt;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Extract `Player_1_Start` .. `Player_N_Start` waypoint coordinates. */
|
||||||
|
[[nodiscard]] inline auto extract_start_positions(std::span<const uint8> ckmp, int max_players = 8) -> std::vector<start_position> {
|
||||||
|
std::vector<start_position> result;
|
||||||
|
for (int n = 1; n <= max_players; ++n) {
|
||||||
|
const auto needle = std::string{"Player_"} + std::to_string(n) + "_Start";
|
||||||
|
usize cursor = 0;
|
||||||
|
while (cursor < ckmp.size()) {
|
||||||
|
const auto at = find_bytes(ckmp.subspan(cursor), needle);
|
||||||
|
if (at == static_cast<usize>(-1)) break;
|
||||||
|
const auto abs = cursor + at;
|
||||||
|
if (const auto triple = scan_triple(ckmp, abs + needle.size(), 128); triple) {
|
||||||
|
result.push_back(*triple);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
cursor = abs + 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Number of distinct integer positions (used to reject degenerate sets). */
|
||||||
|
[[nodiscard]] inline auto distinct_positions(const std::vector<start_position> &starts) -> usize {
|
||||||
|
std::vector<std::pair<int, int>> seen;
|
||||||
|
for (const auto &start: starts) {
|
||||||
|
const auto key = std::pair{static_cast<int>(start.x), static_cast<int>(start.y)};
|
||||||
|
if (std::find(seen.begin(), seen.end(), key) == seen.end()) seen.push_back(key);
|
||||||
|
}
|
||||||
|
return seen.size();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Every main map discoverable in one archive.
|
||||||
|
*/
|
||||||
|
class map_catalog {
|
||||||
|
public:
|
||||||
|
/**
|
||||||
|
* Scan an archive for main map entries.
|
||||||
|
*
|
||||||
|
* @param archive An opened `MapsMultiplayer.big` (or similar).
|
||||||
|
*/
|
||||||
|
[[nodiscard]] static auto from_archive(const fs::big_archive &archive) -> map_catalog {
|
||||||
|
map_catalog catalog;
|
||||||
|
for (const auto &entry: archive.entries()) {
|
||||||
|
if (!detail::is_main_map(entry)) continue;
|
||||||
|
map_info info;
|
||||||
|
info.entry = entry.name;
|
||||||
|
info.id = detail::stem_of(entry.name);
|
||||||
|
info.stored_size = entry.size;
|
||||||
|
info.unpacked_size = entry.size;
|
||||||
|
// The BIG4 payload is RefPack; its output is the `EAR\0` wrapper.
|
||||||
|
if (const auto prefix = archive.read_prefix(entry.name, 16); fs::is_refpack(prefix)) {
|
||||||
|
info.unpacked_size = fs::refpack_output_size(prefix);
|
||||||
|
}
|
||||||
|
catalog.maps_.push_back(std::move(info));
|
||||||
|
}
|
||||||
|
return catalog;
|
||||||
|
}
|
||||||
|
|
||||||
|
[[nodiscard]] auto maps() const -> const std::vector<map_info> & { return maps_; }
|
||||||
|
[[nodiscard]] auto size() const -> usize { return maps_.size(); }
|
||||||
|
|
||||||
|
[[nodiscard]] auto find(std::string_view id) const -> const map_info * {
|
||||||
|
for (const auto &info: maps_) {
|
||||||
|
if (info.id == id) return &info;
|
||||||
|
}
|
||||||
|
return nullptr;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
std::vector<map_info> maps_;
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Load a map: unwrap the `EAR\0` + RefPack container and recover the
|
||||||
|
* player start waypoints.
|
||||||
|
*
|
||||||
|
* @param archive Archive that holds the map.
|
||||||
|
* @param info Map selected from a `map_catalog`.
|
||||||
|
* @throws fs::archive_error / fs::refpack_error on malformed input.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] inline auto load_map(const fs::big_archive &archive, const map_info &info) -> loaded_map {
|
||||||
|
loaded_map result;
|
||||||
|
result.info = info;
|
||||||
|
|
||||||
|
// Layer 1: BIG4 payload is RefPack, yielding the `EAR\0` wrapper.
|
||||||
|
const auto wrapper = archive.read(info.entry, true);
|
||||||
|
std::span<const uint8> payload{wrapper};
|
||||||
|
if (wrapper.size() >= 8U && std::memcmp(wrapper.data(), "EAR\0", 4) == 0) payload = payload.subspan(8);
|
||||||
|
|
||||||
|
// Layer 2: the wrapper body is RefPack again, yielding the `CkMp` tree.
|
||||||
|
auto ckmp = fs::maybe_decompress(payload);
|
||||||
|
result.ckmp_size = ckmp.size();
|
||||||
|
result.starts = detail::extract_start_positions(ckmp);
|
||||||
|
// Maps that keep starts in `MPPositionList` instead of `Player_N_Start`
|
||||||
|
// waypoints yield fewer than two distinct points; signal "unknown" so
|
||||||
|
// the caller can fall back rather than spawn everyone at the origin.
|
||||||
|
if (detail::distinct_positions(result.starts) < 2U) result.starts.clear();
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,15 @@
|
|||||||
|
/**
|
||||||
|
* Umbrella module re-exporting the whole OpenRA3 SDK.
|
||||||
|
*
|
||||||
|
* Consumers that want everything can `import ra3;`; narrower targets should
|
||||||
|
* import only the module they need.
|
||||||
|
*/
|
||||||
|
export module ra3;
|
||||||
|
|
||||||
|
export import ra3.core;
|
||||||
|
export import ra3.logic;
|
||||||
|
export import ra3.client;
|
||||||
|
export import ra3.game;
|
||||||
|
export import ra3.fs;
|
||||||
|
export import ra3.map;
|
||||||
|
export import ra3.skirmish;
|
||||||
@@ -0,0 +1,371 @@
|
|||||||
|
module;
|
||||||
|
|
||||||
|
#include <algorithm>
|
||||||
|
#include <cmath>
|
||||||
|
#include <cstdint>
|
||||||
|
#include <span>
|
||||||
|
#include <string>
|
||||||
|
#include <string_view>
|
||||||
|
#include <utility>
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
|
export module ra3.skirmish;
|
||||||
|
|
||||||
|
export import ra3.core;
|
||||||
|
export import ra3.map;
|
||||||
|
export import ra3.game;
|
||||||
|
import ra3.logic;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A minimal, headless skirmish simulation.
|
||||||
|
*
|
||||||
|
* Two sides start on a real map's waypoint positions, earn credits, train
|
||||||
|
* units and fight until one side's base is destroyed. The simulation is fully
|
||||||
|
* deterministic: fixed 30 Hz steps, no wall-clock, and a seeded logic random
|
||||||
|
* stream. There is no networking, no online service and no EA account - this is
|
||||||
|
* offline skirmish only.
|
||||||
|
*/
|
||||||
|
export namespace ra3::skirmish {
|
||||||
|
using ra3::core::coord3d;
|
||||||
|
using ra3::core::int32;
|
||||||
|
using ra3::core::real;
|
||||||
|
using ra3::core::uint32;
|
||||||
|
using ra3::core::uint8;
|
||||||
|
using ra3::core::usize;
|
||||||
|
|
||||||
|
/** Broad unit role. */
|
||||||
|
enum class unit_class : uint8 { harvester, infantry, tank, base };
|
||||||
|
|
||||||
|
[[nodiscard]] constexpr auto to_string(unit_class value) -> std::string_view {
|
||||||
|
switch (value) {
|
||||||
|
case unit_class::harvester:
|
||||||
|
return "Harvester";
|
||||||
|
case unit_class::infantry:
|
||||||
|
return "Infantry";
|
||||||
|
case unit_class::tank:
|
||||||
|
return "Tank";
|
||||||
|
case unit_class::base:
|
||||||
|
return "Base";
|
||||||
|
}
|
||||||
|
return "Unknown";
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Static combat/economy stats for a unit class.
|
||||||
|
*
|
||||||
|
* These are OpenRA3's own balance values (the retail numbers live in
|
||||||
|
* compiled assets that are not parsed yet), chosen so a skirmish resolves.
|
||||||
|
*/
|
||||||
|
struct unit_type {
|
||||||
|
unit_class cls = unit_class::infantry;
|
||||||
|
std::string_view name;
|
||||||
|
real max_health = 1.0F;
|
||||||
|
real speed = 0.0F;
|
||||||
|
real weapon_damage = 0.0F;
|
||||||
|
real weapon_range = 0.0F;
|
||||||
|
real weapon_cooldown = 1.0F;
|
||||||
|
int32 cost = 0;
|
||||||
|
real build_time = 1.0F;
|
||||||
|
bool mobile = false;
|
||||||
|
bool produces = false;
|
||||||
|
};
|
||||||
|
|
||||||
|
inline constexpr unit_type harvester_type{unit_class::harvester, "Harvester", 300.0F, 10.0F, 0.0F, 0.0F, 0.0F, 1400, 8.0F, true, false};
|
||||||
|
inline constexpr unit_type infantry_type{unit_class::infantry, "Infantry", 120.0F, 12.0F, 8.0F, 55.0F, 1.0F, 150, 3.0F, true, false};
|
||||||
|
inline constexpr unit_type tank_type{unit_class::tank, "Tank", 480.0F, 9.0F, 30.0F, 70.0F, 1.6F, 900, 8.0F, true, false};
|
||||||
|
inline constexpr unit_type base_type{unit_class::base, "Base", 2500.0F, 0.0F, 20.0F, 90.0F, 2.0F, 0, 0.0F, false, true};
|
||||||
|
|
||||||
|
[[nodiscard]] constexpr auto unit_stats(unit_class value) -> const unit_type & {
|
||||||
|
switch (value) {
|
||||||
|
case unit_class::harvester:
|
||||||
|
return harvester_type;
|
||||||
|
case unit_class::infantry:
|
||||||
|
return infantry_type;
|
||||||
|
case unit_class::tank:
|
||||||
|
return tank_type;
|
||||||
|
case unit_class::base:
|
||||||
|
return base_type;
|
||||||
|
}
|
||||||
|
return infantry_type;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** A live unit instance. */
|
||||||
|
struct unit {
|
||||||
|
uint32 id = 0;
|
||||||
|
uint32 owner = 0;
|
||||||
|
unit_class cls = unit_class::infantry;
|
||||||
|
coord3d position{};
|
||||||
|
real health = 0.0F;
|
||||||
|
real max_health = 0.0F;
|
||||||
|
real cooldown = 0.0F;
|
||||||
|
bool alive = true;
|
||||||
|
};
|
||||||
|
|
||||||
|
/** Per-player state for the match. */
|
||||||
|
struct player_state {
|
||||||
|
uint32 index = 0;
|
||||||
|
std::string name;
|
||||||
|
game::faction side = game::faction::none;
|
||||||
|
bool human = false;
|
||||||
|
int32 money = 0;
|
||||||
|
real money_accumulator = 0.0F;
|
||||||
|
coord3d start{};
|
||||||
|
uint32 base_unit = 0;
|
||||||
|
real build_timer = 0.0F;
|
||||||
|
int32 kills = 0;
|
||||||
|
int32 losses = 0;
|
||||||
|
};
|
||||||
|
|
||||||
|
/** Skirmish parameters. */
|
||||||
|
struct match_config {
|
||||||
|
std::string map_id = "builtin";
|
||||||
|
int32 starting_money = 10000;
|
||||||
|
uint32 seed = 1;
|
||||||
|
uint32 max_frames = 30U * 60U * 15U;
|
||||||
|
real income_per_second = 25.0F;
|
||||||
|
real harvester_income_per_second = 15.0F;
|
||||||
|
};
|
||||||
|
|
||||||
|
/** Outcome of a completed (or capped) match. */
|
||||||
|
struct match_result {
|
||||||
|
bool decided = false;
|
||||||
|
int32 winner = -1;
|
||||||
|
uint32 frames = 0;
|
||||||
|
int32 units_left[2] = {0, 0};
|
||||||
|
int32 kills[2] = {0, 0};
|
||||||
|
int32 losses[2] = {0, 0};
|
||||||
|
};
|
||||||
|
|
||||||
|
/** Fallback start positions when a map yields none (CI, no game data). */
|
||||||
|
[[nodiscard]] inline auto builtin_start_positions() -> std::vector<ra3::map::start_position> {
|
||||||
|
return {{300.0F, 300.0F, 0.0F}, {1500.0F, 1500.0F, 0.0F}};
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A running skirmish. Construct with `create`, then `run` or `step`.
|
||||||
|
*/
|
||||||
|
class skirmish_match {
|
||||||
|
public:
|
||||||
|
/**
|
||||||
|
* Set up a two-player match.
|
||||||
|
*
|
||||||
|
* @param config Match parameters.
|
||||||
|
* @param starts Player start positions (at least two recommended).
|
||||||
|
*/
|
||||||
|
[[nodiscard]] static auto create(const match_config &config, std::span<const ra3::map::start_position> starts) -> skirmish_match {
|
||||||
|
skirmish_match match;
|
||||||
|
match.config_ = config;
|
||||||
|
match.random_.seed(config.seed);
|
||||||
|
|
||||||
|
const coord3d first = starts.size() >= 1U ? starts[0].as_coord() : coord3d{300.0F, 300.0F, 0.0F};
|
||||||
|
const coord3d second = starts.size() >= 2U ? starts[1].as_coord() : coord3d{1500.0F, 1500.0F, 0.0F};
|
||||||
|
|
||||||
|
match.spawn_player(0U, "Commander", game::faction::allied, true, first);
|
||||||
|
match.spawn_player(1U, "AI", game::faction::soviet, false, second);
|
||||||
|
return match;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Run until a base falls or the frame cap is reached. */
|
||||||
|
auto run() -> match_result {
|
||||||
|
while (!this->decided() && frame_ < config_.max_frames) this->step();
|
||||||
|
return this->result();
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Advance exactly one 30 Hz frame. */
|
||||||
|
auto step() -> void {
|
||||||
|
constexpr real dt = 1.0F / 30.0F;
|
||||||
|
this->apply_income(dt);
|
||||||
|
this->run_ai(dt);
|
||||||
|
this->update_units(dt);
|
||||||
|
this->check_victory();
|
||||||
|
++frame_;
|
||||||
|
}
|
||||||
|
|
||||||
|
[[nodiscard]] auto frame() const -> uint32 { return frame_; }
|
||||||
|
[[nodiscard]] auto decided() const -> bool { return decided_; }
|
||||||
|
[[nodiscard]] auto winner() const -> int32 { return winner_; }
|
||||||
|
[[nodiscard]] auto players() const -> const std::vector<player_state> & { return players_; }
|
||||||
|
[[nodiscard]] auto units() const -> const std::vector<unit> & { return units_; }
|
||||||
|
|
||||||
|
[[nodiscard]] auto unit_count(uint32 owner) const -> usize {
|
||||||
|
usize count = 0;
|
||||||
|
for (const auto &entry: units_) {
|
||||||
|
if (entry.alive && entry.owner == owner) ++count;
|
||||||
|
}
|
||||||
|
return count;
|
||||||
|
}
|
||||||
|
|
||||||
|
[[nodiscard]] auto result() const -> match_result {
|
||||||
|
match_result summary;
|
||||||
|
summary.decided = decided_;
|
||||||
|
summary.winner = winner_;
|
||||||
|
summary.frames = frame_;
|
||||||
|
for (const auto &player: players_) {
|
||||||
|
if (player.index < 2U) {
|
||||||
|
summary.kills[player.index] = player.kills;
|
||||||
|
summary.losses[player.index] = player.losses;
|
||||||
|
summary.units_left[player.index] = static_cast<int32>(this->unit_count(player.index));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return summary;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
static constexpr real build_interval_seconds = 4.0F;
|
||||||
|
|
||||||
|
auto spawn_player(uint32 index, std::string name, game::faction side, bool human, const coord3d &start) -> void {
|
||||||
|
player_state player;
|
||||||
|
player.index = index;
|
||||||
|
player.name = std::move(name);
|
||||||
|
player.side = side;
|
||||||
|
player.human = human;
|
||||||
|
player.money = config_.starting_money;
|
||||||
|
player.start = start;
|
||||||
|
player.base_unit = this->spawn_unit(index, unit_class::base, start);
|
||||||
|
this->spawn_unit(index, unit_class::harvester, {start.x + 60.0F, start.y + 20.0F, 0.0F});
|
||||||
|
this->spawn_unit(index, unit_class::tank, {start.x + 40.0F, start.y + 50.0F, 0.0F});
|
||||||
|
this->spawn_unit(index, unit_class::tank, {start.x + 70.0F, start.y - 30.0F, 0.0F});
|
||||||
|
this->spawn_unit(index, unit_class::infantry, {start.x + 30.0F, start.y - 60.0F, 0.0F});
|
||||||
|
this->spawn_unit(index, unit_class::infantry, {start.x + 90.0F, start.y - 60.0F, 0.0F});
|
||||||
|
players_.push_back(std::move(player));
|
||||||
|
}
|
||||||
|
|
||||||
|
auto spawn_unit(uint32 owner, unit_class cls, const coord3d &position) -> uint32 {
|
||||||
|
const auto &stats = unit_stats(cls);
|
||||||
|
unit created;
|
||||||
|
created.id = next_unit_id_++;
|
||||||
|
created.owner = owner;
|
||||||
|
created.cls = cls;
|
||||||
|
created.position = position;
|
||||||
|
created.health = stats.max_health;
|
||||||
|
created.max_health = stats.max_health;
|
||||||
|
units_.push_back(created);
|
||||||
|
return created.id;
|
||||||
|
}
|
||||||
|
|
||||||
|
auto apply_income(real dt) -> void {
|
||||||
|
for (auto &player: players_) {
|
||||||
|
real rate = config_.income_per_second;
|
||||||
|
for (const auto &entry: units_) {
|
||||||
|
if (entry.alive && entry.owner == player.index && entry.cls == unit_class::harvester) rate += config_.harvester_income_per_second;
|
||||||
|
}
|
||||||
|
player.money_accumulator += rate * dt;
|
||||||
|
const auto whole = static_cast<int32>(player.money_accumulator);
|
||||||
|
if (whole > 0) {
|
||||||
|
player.money += whole;
|
||||||
|
player.money_accumulator -= static_cast<real>(whole);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
auto run_ai(real dt) -> void {
|
||||||
|
for (auto &player: players_) {
|
||||||
|
player.build_timer += dt;
|
||||||
|
if (player.build_timer < build_interval_seconds) continue;
|
||||||
|
player.build_timer = 0.0F;
|
||||||
|
|
||||||
|
const auto *base = this->find_unit(player.base_unit);
|
||||||
|
if (base == nullptr || !base->alive) continue;
|
||||||
|
if (player.money < tank_type.cost) continue;
|
||||||
|
|
||||||
|
player.money -= tank_type.cost;
|
||||||
|
this->spawn_unit(player.index, unit_class::tank, {base->position.x + 50.0F, base->position.y - 50.0F, 0.0F});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
auto update_units(real dt) -> void {
|
||||||
|
for (auto &entry: units_) {
|
||||||
|
if (!entry.alive) continue;
|
||||||
|
if (entry.cooldown > 0.0F) entry.cooldown -= dt;
|
||||||
|
if (entry.cls == unit_class::harvester) continue; // economy only, no combat
|
||||||
|
|
||||||
|
const auto &stats = unit_stats(entry.cls);
|
||||||
|
auto *target = this->nearest_enemy(entry);
|
||||||
|
if (target == nullptr) continue;
|
||||||
|
|
||||||
|
const auto dx = target->position.x - entry.position.x;
|
||||||
|
const auto dy = target->position.y - entry.position.y;
|
||||||
|
const auto dz = target->position.z - entry.position.z;
|
||||||
|
const auto distance = std::sqrt(dx * dx + dy * dy + dz * dz);
|
||||||
|
|
||||||
|
if (distance > stats.weapon_range && stats.mobile && stats.speed > 0.0F) {
|
||||||
|
if (distance > 1.0e-3F) {
|
||||||
|
const auto travel = stats.speed * dt;
|
||||||
|
entry.position.x += dx / distance * travel;
|
||||||
|
entry.position.y += dy / distance * travel;
|
||||||
|
}
|
||||||
|
} else if (stats.weapon_damage > 0.0F && distance <= stats.weapon_range && entry.cooldown <= 0.0F) {
|
||||||
|
entry.cooldown = stats.weapon_cooldown;
|
||||||
|
target->health -= stats.weapon_damage;
|
||||||
|
if (target->health <= 0.0F) {
|
||||||
|
target->health = 0.0F;
|
||||||
|
target->alive = false;
|
||||||
|
this->player_ref(entry.owner).kills += 1;
|
||||||
|
this->player_ref(target->owner).losses += 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
auto check_victory() -> void {
|
||||||
|
const bool first_alive = this->base_alive(0U);
|
||||||
|
const bool second_alive = this->base_alive(1U);
|
||||||
|
if (first_alive && second_alive) return;
|
||||||
|
decided_ = true;
|
||||||
|
if (first_alive) {
|
||||||
|
winner_ = 0;
|
||||||
|
} else if (second_alive) {
|
||||||
|
winner_ = 1;
|
||||||
|
} else {
|
||||||
|
winner_ = -1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
[[nodiscard]] auto base_alive(uint32 owner) const -> bool {
|
||||||
|
const auto &player = players_.at(owner);
|
||||||
|
const auto *base = this->find_unit(player.base_unit);
|
||||||
|
return base != nullptr && base->alive;
|
||||||
|
}
|
||||||
|
|
||||||
|
[[nodiscard]] auto nearest_enemy(const unit &self) -> unit * {
|
||||||
|
unit *best = nullptr;
|
||||||
|
real best_distance = 1.0e30F;
|
||||||
|
for (auto &candidate: units_) {
|
||||||
|
if (!candidate.alive || candidate.owner == self.owner) continue;
|
||||||
|
const auto dx = candidate.position.x - self.position.x;
|
||||||
|
const auto dy = candidate.position.y - self.position.y;
|
||||||
|
const auto squared = dx * dx + dy * dy;
|
||||||
|
if (squared < best_distance) {
|
||||||
|
best_distance = squared;
|
||||||
|
best = &candidate;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return best;
|
||||||
|
}
|
||||||
|
|
||||||
|
[[nodiscard]] auto find_unit(uint32 id) -> unit * {
|
||||||
|
for (auto &entry: units_) {
|
||||||
|
if (entry.id == id) return &entry;
|
||||||
|
}
|
||||||
|
return nullptr;
|
||||||
|
}
|
||||||
|
|
||||||
|
[[nodiscard]] auto find_unit(uint32 id) const -> const unit * {
|
||||||
|
for (const auto &entry: units_) {
|
||||||
|
if (entry.id == id) return &entry;
|
||||||
|
}
|
||||||
|
return nullptr;
|
||||||
|
}
|
||||||
|
|
||||||
|
[[nodiscard]] auto player_ref(uint32 index) -> player_state & { return players_.at(index); }
|
||||||
|
|
||||||
|
match_config config_;
|
||||||
|
ra3::core::random random_{1U};
|
||||||
|
std::vector<player_state> players_;
|
||||||
|
std::vector<unit> units_;
|
||||||
|
uint32 next_unit_id_ = 1U;
|
||||||
|
uint32 frame_ = 0U;
|
||||||
|
bool decided_ = false;
|
||||||
|
int32 winner_ = -1;
|
||||||
|
};
|
||||||
|
}
|
||||||
@@ -0,0 +1,126 @@
|
|||||||
|
#include <cstdint>
|
||||||
|
#include <cstdio>
|
||||||
|
#include <filesystem>
|
||||||
|
#include <fstream>
|
||||||
|
#include <memory>
|
||||||
|
#include <string>
|
||||||
|
#include <string_view>
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
|
import ra3;
|
||||||
|
|
||||||
|
namespace {
|
||||||
|
int failures = 0;
|
||||||
|
|
||||||
|
auto check(bool condition, std::string_view what) -> void {
|
||||||
|
if (!condition) {
|
||||||
|
std::printf("FAIL: %.*s\n", static_cast<int>(what.size()), what.data());
|
||||||
|
++failures;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
auto append_be32(std::vector<std::uint8_t> &out, std::uint32_t value) -> void {
|
||||||
|
out.push_back(static_cast<std::uint8_t>(value >> 24U));
|
||||||
|
out.push_back(static_cast<std::uint8_t>(value >> 16U));
|
||||||
|
out.push_back(static_cast<std::uint8_t>(value >> 8U));
|
||||||
|
out.push_back(static_cast<std::uint8_t>(value));
|
||||||
|
}
|
||||||
|
|
||||||
|
auto append_le32(std::vector<std::uint8_t> &out, std::uint32_t value) -> void {
|
||||||
|
out.push_back(static_cast<std::uint8_t>(value));
|
||||||
|
out.push_back(static_cast<std::uint8_t>(value >> 8U));
|
||||||
|
out.push_back(static_cast<std::uint8_t>(value >> 16U));
|
||||||
|
out.push_back(static_cast<std::uint8_t>(value >> 24U));
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Build a one-entry BIG4 archive and return its path. */
|
||||||
|
auto make_test_archive(const std::filesystem::path &path) -> void {
|
||||||
|
const std::string name = "data\\hello.txt";
|
||||||
|
const std::string payload = "hello big4";
|
||||||
|
|
||||||
|
std::vector<std::uint8_t> index;
|
||||||
|
append_be32(index, 0); // offset, patched below
|
||||||
|
append_be32(index, static_cast<std::uint32_t>(payload.size()));
|
||||||
|
index.insert(index.end(), name.begin(), name.end());
|
||||||
|
index.push_back(0);
|
||||||
|
|
||||||
|
const std::uint32_t payload_offset = 16U + static_cast<std::uint32_t>(index.size());
|
||||||
|
std::vector<std::uint8_t> index_patched;
|
||||||
|
append_be32(index_patched, payload_offset);
|
||||||
|
index_patched.insert(index_patched.end(), index.begin() + 4, index.end());
|
||||||
|
|
||||||
|
std::vector<std::uint8_t> file;
|
||||||
|
file.insert(file.end(), {'B', 'I', 'G', '4'});
|
||||||
|
append_le32(file, static_cast<std::uint32_t>(16U + index_patched.size() + payload.size()));
|
||||||
|
append_be32(file, 1U);
|
||||||
|
append_le32(file, 0U);
|
||||||
|
file.insert(file.end(), index_patched.begin(), index_patched.end());
|
||||||
|
file.insert(file.end(), payload.begin(), payload.end());
|
||||||
|
|
||||||
|
std::ofstream out(path, std::ios::binary);
|
||||||
|
out.write(reinterpret_cast<const char *>(file.data()), static_cast<std::streamsize>(file.size()));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
auto main() -> int {
|
||||||
|
using namespace ra3;
|
||||||
|
|
||||||
|
check(core::make_name_key("Tank") == core::make_name_key("tank"), "name keys are case-insensitive");
|
||||||
|
|
||||||
|
core::message_stream stream;
|
||||||
|
stream.append(core::message_id::begin_block);
|
||||||
|
stream.append(core::message_id::new_game);
|
||||||
|
check(stream.size() == 2U, "message stream counts entries");
|
||||||
|
check(stream.pop()->id == core::message_id::begin_block, "message stream is FIFO");
|
||||||
|
|
||||||
|
logic::game_logic simulation;
|
||||||
|
simulation.prepare_new_game(7U);
|
||||||
|
check(simulation.starting(), "prepare raises the starting flag");
|
||||||
|
simulation.start_new_game();
|
||||||
|
check(!simulation.messages().empty(), "start appends new_game");
|
||||||
|
simulation.update();
|
||||||
|
check(simulation.frame() == 1U, "update advances the frame counter");
|
||||||
|
check(simulation.messages().empty(), "update drains the message stream");
|
||||||
|
|
||||||
|
auto &side = simulation.players().add(std::make_unique<logic::player>(0U, "Test"));
|
||||||
|
side.set_money(250);
|
||||||
|
side.add_money(-100);
|
||||||
|
check(side.money() == 150, "money clamps and accumulates");
|
||||||
|
|
||||||
|
check(game::to_string(game::faction::soviet) == "Soviet", "faction names round-trip");
|
||||||
|
|
||||||
|
// RefPack: a literal-only stream decodes to its payload.
|
||||||
|
const std::vector<core::uint8> refpack{0x10, 0xFB, 0x00, 0x00, 0x03, 0xFF, 'A', 'B', 'C'};
|
||||||
|
check(fs::is_refpack(refpack), "literal RefPack stream is recognised");
|
||||||
|
const auto decoded = fs::refpack_decompress(refpack);
|
||||||
|
check(decoded.size() == 3U && decoded[0] == 'A' && decoded[2] == 'C', "RefPack literals decode");
|
||||||
|
check(fs::maybe_decompress(std::vector<core::uint8>{'x', 'y'}).size() == 2U, "non-RefPack passes through");
|
||||||
|
|
||||||
|
// BIG4: build and read a synthetic archive.
|
||||||
|
const auto archive_path = std::filesystem::temp_directory_path() / "openra3_test.big";
|
||||||
|
make_test_archive(archive_path);
|
||||||
|
const auto archive = fs::big_archive::open(archive_path);
|
||||||
|
check(archive.size() == 1U, "BIG4 index has one entry");
|
||||||
|
check(archive.contains("data\\hello.txt"), "BIG4 entry is indexed");
|
||||||
|
const auto payload = archive.read("data\\hello.txt");
|
||||||
|
check(std::string(payload.begin(), payload.end()) == "hello big4", "BIG4 payload reads back");
|
||||||
|
std::error_code ignored;
|
||||||
|
std::filesystem::remove(archive_path, ignored);
|
||||||
|
|
||||||
|
// Skirmish: deterministic, resolves within the frame cap.
|
||||||
|
skirmish::match_config config;
|
||||||
|
config.seed = 42U;
|
||||||
|
const auto starts = skirmish::builtin_start_positions();
|
||||||
|
auto first = skirmish::skirmish_match::create(config, starts);
|
||||||
|
const auto first_result = first.run();
|
||||||
|
auto second = skirmish::skirmish_match::create(config, starts);
|
||||||
|
const auto second_result = second.run();
|
||||||
|
check(first_result.decided, "skirmish reaches a decision");
|
||||||
|
check(first_result.winner == 0 || first_result.winner == 1, "skirmish has a winner");
|
||||||
|
check(first_result.frames == second_result.frames && first_result.winner == second_result.winner, "skirmish is deterministic");
|
||||||
|
|
||||||
|
if (failures == 0) {
|
||||||
|
std::puts("ra3_tests: OK");
|
||||||
|
}
|
||||||
|
return failures == 0 ? 0 : 1;
|
||||||
|
}
|
||||||
@@ -0,0 +1,18 @@
|
|||||||
|
#!/usr/bin/env bash
|
||||||
|
# Sparse-clone the GPLv3 SAGE 1.0 engine sources used as OpenRA3's reference.
|
||||||
|
#
|
||||||
|
# Usage: tools/fetch_reference.sh [destination]
|
||||||
|
set -euo pipefail
|
||||||
|
|
||||||
|
REPO="https://github.com/electronicarts/CnC_Generals_Zero_Hour.git"
|
||||||
|
DEST="${1:-reference/CnC_Generals_Zero_Hour}"
|
||||||
|
|
||||||
|
if [ -d "$DEST/.git" ]; then
|
||||||
|
echo "reference already present at $DEST"
|
||||||
|
exit 0
|
||||||
|
fi
|
||||||
|
|
||||||
|
mkdir -p "$(dirname "$DEST")"
|
||||||
|
git clone --depth 1 --filter=blob:none --sparse "$REPO" "$DEST"
|
||||||
|
git -C "$DEST" sparse-checkout set Generals GeneralsMD
|
||||||
|
echo "reference ready at $DEST"
|
||||||
@@ -0,0 +1,26 @@
|
|||||||
|
# Ghidra helpers
|
||||||
|
|
||||||
|
OpenRA3's retail facts are recovered through the Ghidra MCP bridge. The retail
|
||||||
|
module is loaded as `ra3_1.12.game` (image base `0x400000`, x86 32-bit).
|
||||||
|
|
||||||
|
## Quick queries
|
||||||
|
|
||||||
|
```text
|
||||||
|
decompile_function(address=0x00623e40) # GameLogic::startNewGame
|
||||||
|
decompile_function(address=0x0060c4a0) # MessageStream::appendMessage
|
||||||
|
get_function_by_address(address=0x00cd8ce4) # TheGameLogic global
|
||||||
|
get_xrefs_to(address=0x00ce3a78) # who touches the skirmish setup
|
||||||
|
search_strings(search_term="SkirmishGameInfo")
|
||||||
|
```
|
||||||
|
|
||||||
|
## Recording a finding
|
||||||
|
|
||||||
|
When a layout or constant is recovered:
|
||||||
|
|
||||||
|
1. Add it to [`../../docs/REVERSE_ENGINEERING.md`](../../docs/REVERSE_ENGINEERING.md)
|
||||||
|
with its retail address.
|
||||||
|
2. Cite the address in the OpenRA3 source comment that depends on it.
|
||||||
|
3. Add a test that pins the behaviour.
|
||||||
|
|
||||||
|
The goal is that every assertion in the code can be re-derived from the binary
|
||||||
|
by someone who has never seen this repo.
|
||||||
Reference in New Issue
Block a user