GLSMAC

Unofficial open-source OpenGL/SDL2 reimplementation of Sid Meier's Alpha Centauri ( + Alien Crossfire ).

Note: you will still need to own the original game and expansion - GLSMAC will load its resources like images or sounds.

Check Screenshots and Videos for current state and history of project.

GLSMAC discord : https://discord.gg/fWG3xK7cUx

Why?

SMAC was a great game, possibly the best in 4x genre, but it's outdated so much it barely runs on modern systems. Especially multiplayer (which is based on ancient directplay).

What will be same between GLSMAC and original game?

Models, images, movies, texts, lore, factions, game rules (such as tech trees, types of armor/weapons etc), UI

What will be completely different?

Graphics engine, network code are fully rewritten to allow it run as smoothly as possible.

What may differ slightly?

Random maps generation, AI, dynamic music, some UI parts. While I'll try to get them as close as possible to original logic, they will still be recreated from scratch.

Compatibility?

Network won't be compatible to original client (so you can't play together with somebody running it).

Maybe I'll make saves and maps compatible, but it's very low priority.

Mod compatibility - it should work with asset mods that replace .PCX, .WAV or other asset files in SMAC directory (later it will also accept upscaled versions). It won't work with mods that modify or link to terranx.exe. Mods that change .txt files - probably not, maybe some settings and rules will be read from original SMAC's .txt but not all of them.

Other improvements?

Once I replicate original game, I'll focus on other things, such as: larger maps, larger maximum number of players, custom mod support, online services such as game browser or hosting long-turns games (where people can login and make 1 turn per day or so), alternative art packs (used instead of original, this may mean better graphics)

Current Version:

v0.3+

Roadmap

Versions 0.x+: replicating original SMAC gameplay as closely as possible (but without bugs and some technical limitations)

• v0.1: fundamental engine functions, such as: rendering, UI, netcode, sound system

• v0.2: basic map functions, such as: tiles, mapgen, creating/saving/loading games, map rendering

• v0.3: basic multiplayer: ability to host and join games, lobby, save/load games with same players. multiplayer support will be maintained during further steps from now on

• v0.4: game processing, such as: game turns, units (only scout patrols, formers and colony pods), buildings (only recycling tanks), technologies (only centauri ecology), building of bases (only land bases), terraforming (only farms, mines and solar arrays), unit combat, victory by conquest

• v0.5: all remaining SMAC units, buildings, terraformings, technologies, etc

• v0.6: all remaining victory types

• v0.7: AI (computer opponents, cities automation, units automation, etc) and diplomacy

• v0.8: alien lifeforms, ecology

• v0.9: all remaining in-game UI, including game settings

• v0.10: non-crucial things like movies, interludes, dynamic music

• v0.11: final polishing and bugfixing

Versions 1.x+: fixing bugs, adding optional small features that weren't present in original SMAC but won't change it's gameplay drastically. See 'GLSMAC v1.x+ features' section at the end

Versions 2.x+: adding all kinds of features, as long as they are worth the time. See 'GLSMAC v2.x+ features' section at the end

Versions 3.x+: not sure yet, probably something cool.

Hardware requirements

Minimum recommended (for at least 60 FPS):

• GPU: Intel HD 4400, AMD Radeon R7, Geforce GT710 or similar
• RAM: 2-4GB
• HDD: 50MB

Requirements may go up slightly as more features are added to game. But I'll try to keep FPS above 60 on low-end cards as above. Amount of RAM will limit maximum size of map you can play on (until some kind of disk caching is implemented, but that will cost performance). Disk space is needed for GLSMAC binary, config files, saves, maybe map files and replays.

Build instructions

Supported platforms:

• GNU/Linux with GCC compiler
• FreeBSD with Clang compiler
• Windows ( Visual Studio + Clang )
• Windows ( MinGW )

Other platforms/toolchains weren't tested but you can try and please report results if you do (or pull request if you manage to get it running on more OSes).

Linux / FreeBSD

You will need CMake and working compiler (gcc or clang).

You will also need following libraries (unless you build with -DVENDORED_DEPENDENCIES=YES):

• FreeType
• SDL2
• SDL2_image
• GL
• GLU
• GLEW
• uuid-ossp
• yaml-cpp

Gentoo: emerge cmake libsdl2 sdl2-image freetype glu glew ossp-uuid yaml-cpp

Ubuntu: apt install cmake build-essential libfreetype-dev libsdl2-dev libsdl2-image-dev libglu-dev libglew-dev libossp-uuid-dev libyaml-cpp-dev

ArchLinux: pacman -Syu cmake base-devel freetype2 sdl2 sdl2_image glew yaml-cpp (you'll need to install ossp-uuid manually because it's not in repos) AUR-package: https://aur.archlinux.org/packages/uuid

FreeBSD: pkg install pkgconf cmake sdl2 sdl2_image glew ossp-uuid yaml-cpp

Fedora: dnf install cmake make automake gcc gcc-c++ freetype-devel SDL2-devel SDL2_image-devel glew-devel uuid-devel yaml-cpp-devel

OpenSUSE: zypper install -t pattern devel_basis && zypper install cmake-full freetype2-devel SDL2-devel SDL2_image-devel glew-devel uuid-devel yaml-cpp-devel

It is highly recommended to build project using CMake and make (ninja works too) instead of adding .cpp and .h files manually to IDE (don't report bugs if you try the latter).

It is recommended to build in separate directory. For example: cmake -S . -B build (remove build directory when you'll want a clean build for some reason).

For release build (default): cmake -S . -B build -DCMAKE_BUILD_TYPE=Release && make -C build

For debug build: cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug && make -C build

For portable build (binary that can be executed on different machines): cmake -S . -B build -DCMAKE_BUILD_TYPE=Portable64 && make -C build ( or Portable32 for 32-bit )

For same build as before (or Release if it's first build): cmake -S . -B build && make -C build

Add -j parameter to make to speed up if you have multiple cores, i.e. make -C build -j9 for 8 cores.

Optionally, add -DVENDORED_DEPENDENCIES=YES to cmake parameters to download and build all required libraries, instead of using system-installed ones. By default this is enabled on Windows and disabled on other OSes. You can't disable it on Windows.

Optionally, use VERBOSE=1 make -C build to see actual compiling/linking commands (useful when build fails)

You can also just download binary releases from github, they are built for ubuntu but will run on most linux distros (only 64-bit for now). Windows and other binaries coming soon :)

Apple/Mac

In order to build it on Mac install XCode from AppStore - it is free, no Apple Development Program is required. Then install the following dependencies:

• Brew as a package manager from https://brew.sh
• brew install cmake PkgConfig sdl2 sdl2_image ossp-uuid glew yaml-cpp freetype
• In case of missing packages just install it using brew.

Package ossp-uuid is visible as uuid. Additionally we must link with OpenGL framework (dependency added to make file) Then we can follow with build commands as for Linux versions: cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug && make -C build

Game is build correctly however there are problems related to OpenGL currently which crashes the game.

Windows

Visual Studio

Building with Visual Studio is recommended for windows. You will need git (for example, Git SCM) and Visual Studio 2022 installed. Use the Visual Studio Installer, select Desktop development with C++. Then click modify->individual components on Visual Studio 2022.

You will need to install the following C++ CMake tools for windows, C++ Clang Compiler for windows, C++ Clang-cl, Windows 11 SDK (10.2.22621.0), Windows Universal CRT SDK, Windows Universal C Runtime.

Once that is done you should clone the git, then open the folder. Press the top button Project->Configure, then the output should open. Wait for it to say "CMake generation finished.". On top you'll see build configuration dropdown, select either x64 Debug or x64 Release. Then press 'build' button (or usually it's F10 or Shift+F10 hotkey), wait until build is finished. Once that is done (without errors) select the build target GLSMAC.exe and press the debug button.

You are going to want to add your path to the start argument when running, to do that open the Solution Explorer and press Show all files. Then go to out\build\x64-debug-win-clang\bin, right click GLSMAC.exe and select Add Debug Configuration->Default.

It should open launch.vs.json file, make it look similar to this (debug and release entries, add more arguments as necessary):

{
    "version": "0.2.1",
    "defaults": {},
    "configurations": [
        {
            "type": "default",
            "project": "out\\build\\x64-debug-win-clang\\bin\\GLSMAC.exe",
            "projectTarget": "",
            "currentDir": ".",
            "name": "GLSMAC.exe",
            "args": [
                "--smacpath C:\\smac"
            ]
        },
        {
            "type": "default",
            "project": "out\\build\\x64-release-win-clang\\bin\\GLSMAC.exe",
            "projectTarget": "",
            "currentDir": ".",
            "name": "GLSMAC.exe",
            "args": [
                "--smacpath C:\\smac",
            ]
        }
    ]
}

Replace the path to SMAC installation with your own path to the game. Then you are done and can run the game in Visual Studio.

currentDir above is required because GLSMAC will load scripts from ./GLSMAC_data in runtime.

Alternatively, set working directory to that of your SMAC installation (you'll need to copy GLSMAC_data directory there), it will work without --smacpath argument then.

MinGW

Building on Windows with MinGW is possible, but tricky. You need to install all those libraries manually, and also FreeGLUT. Double-check that you download libraries compiled for MinGW (and not MSVC). GLEW may need to be compiled from source (because they only ship MSVC version). Make sure to have threads-enabled version of MinGW. Maybe this guide will help you - https://github.com/induktio/mingw-glsmac

MSVC

Wasn't tested. Feel free to test, but I have feeling it will require many changes to code to be compatible.

Launch

Note: GLSMAC needs GLSMAC_data directory to be in working directory from where it's run, it loads scripts from there in runtime (later some of them will be built into binary so this step won't be needed).

Just run ./GLSMAC --smacpath

Or copy GLSMAC file and GLSMAC_data directory into your SMAC directory and run without arguments from there.

Run ./bin/GLSMAC --help to see more options. Debug builds have extra options that aren't available for release builds.

Supported SMAC releases: GOG, Loki, Planetary Pack (if you have something else and it doesn't work - double-check that you have SMACX expansion and then create issue)

Reporting problems

If you encountered problem, first thing to try is to update to newest version, maybe it was already fixed.

Next step is to try Stable branch. Main branch contains latest code that may be unfinished or partially finished, and/or contain bugs aswell. Stable branch is supposed to be consistent and bug-free.

Until GLSMAC is v1.0 please do not comment on tiny glitches, sometimes I postpone them bit. Only important game-breaking bugs.

Check existing issues, maybe this bug is already known. Then it would be nice if you comment on existing one with your system specs and maybe other details.

If this feature was working correctly earlier - maybe you can find latest commit where it still worked, it will make fixing faster.

If it fails to build: create issue with errors from build log.

If it crashes: 1) use debug build 2) run gdb --args ./bin/GLSMAC , type "r", make it crash, then type "bt" and create issue with this backtrace and steps to reproduce.

If it freezes: 1) use debug build 2) run gdb --args ./bin/GLSMAC , get to where it freezes, then press Ctrl+C, type "bt" and create issue with backtrace and steps to reproduce.

If it behaves incorrectly: create issue and specify: 1) steps to reproduce 2) expected behavior 3) actual behavior ; attach screenshots if needed.

Update: on Linux you can use --gdb argument for debug build to start inside gdb automatically

If you're using debug build - it will create files tmp/lastmap.seed, tmp/lastmap.gsm (map file) and tmp/lastmap.dump (full dump of initialized map), attach them too if your issue is related to map. Make sure to gzip lastmap.dump, it's huge otherwise.

Copyright disclaimer

GLSMAC does not include any copyrighted assets from original SMAC, it is designed to use assets of existing SMAC installation on user's computer. It will also work with any third-party assets, as long as they are in same format and in same directory structure as original SMAC.

GLSMAC code is created from scratch and tries to imitate original SMAC logic while not actually containing any of it. It does not disassemble original SMAC binaries and does not link to any of SMAC libraries.

GLSMAC requires user to have original SMAC (+expansion) installed in order to operate in a way similar to original SMAC.

All rights for SMAC/SMACX assets belong to their respective owners, sam