Main Entry Point & Bootstrapping

Relevant source files

The following files were used as context for generating this wiki page:

• src/main.cpp
• CMakeLists.txt
• src/api/ApiServer.cpp
• src/api/Command.cpp
• tests/api_server_tests.cpp
• README.md

Introduction

The bootstrapping process of mcpi-recompiled initializes a source-reconstruction and native port of Minecraft: Pi Edition 0.1.1. The primary purpose of the entry point is to establish the core environment required to reproduce the original game's programming API and behavior on modern Linux and Windows x86-64 systems. During Phase 1 of the project, the bootstrapping logic focuses on establishing a portable C++ build environment and verifying the internal protocol parser's readiness.

The system is designed to support the original Minecraft Pi (MCPI) protocol over TCP port 4711, facilitating communication between the game engine and external scripts. The bootstrapping phase ensures that the mcpi_core library and the main executable are correctly linked and that foundational systems, such as the ApiServer and Command parser, are functional.

Sources: README.md:3-12, src/main.cpp:6-10

Build System & Project Configuration

The project uses CMake as its primary build and configuration tool. The bootstrapping logic is defined in CMakeLists.txt, which enforces C++20 standards and manages cross-platform dependencies like threading and Windows Sockets (ws2_32).

Core Library and Executable

The project structure separates the core logic from the entry point:

• mcpi_core: A library containing the foundational API logic, specifically ApiServer.cpp and Command.cpp.
• mcpi-recompiled: The main executable that serves as the application entry point.

Sources: CMakeLists.txt:1-42

Dependency and Platform Management

Component	Requirement / Value	Description
C++ Standard	C++20	Required for modern features and strict extensions.
Threads	Required	Essential for the ApiServer worker thread.
Windows Linker	ws2_32	Linked specifically for socket support on Windows.
GCC/Clang Flags	-Wall -Wextra -Wpedantic	Enforces strict compiler warnings for code quality.

Sources: CMakeLists.txt:9-35

Application Entry Point

The main function in src/main.cpp serves as the initial execution context. Its current role in the bootstrap stage is to announce the project status and perform a self-check of the protocol parsing engine.

int main() {
    std::cout << "mcpi-recompiled bootstrap\n";
    std::cout << "Phase 1: Minecraft Pi 0.1.1 compatibility\n";
    std::cout << "API target: TCP 4711 / MCPI protocol\n";

    const auto sample = mcpi::api::parse_command("world.setBlock(1,2,3,1)");
    if (!sample) {
        std::cerr << "Internal protocol parser self-check failed.\n";
        return 1;
    }
    // ...
    return 0;
}

Sources: src/main.cpp:6-21

Execution Flow

The following diagram illustrates the high-level initialization sequence when the application starts:

The entry point validates the mcpi::api::parse_command utility using a standard Minecraft Pi command (world.setBlock). This ensures the mcpi_core logic is correctly integrated before the full game loop is implemented.

Sources: src/main.cpp:7-17

API Server Bootstrapping

A critical component initialized during the broader system bootstrap is the ApiServer. It handles TCP connections on the standard MCPI port (4711 by default).

Initialization Sequence

The ApiServer::start method manages the platform-specific socket setup and spawns a background worker thread to handle client requests.

Key Bootstrapping Functions in ApiServer

1. WSAStartup: Initializes Winsock on Windows platforms. Sources: src/api/ApiServer.cpp:147-152
2. socket() / bind() / listen(): Standard BSD socket sequence to prepare the server for incoming traffic. Sources: src/api/ApiServer.cpp:155-180
3. getsockname(): Used when port 0 is requested to identify the dynamically assigned TCP port. Sources: src/api/ApiServer.cpp:189-198
4. std::thread: Spawns the background worker that enters the accept loop. Sources: src/api/ApiServer.cpp:208-210

Protocol Validation and Tests

As part of the bootstrap phase, the project includes a test harness to verify API compatibility. This is managed by the MCPI_BUILD_TESTS option in CMake, which compiles separate test executables.

• mcpi_protocol_tests: Validates the parsing logic for commands like world.setBlock, player.getPos, and chat.post.
• mcpi_api_server_tests: Verifies end-to-end TCP communication by simulating a client connection to the ApiServer on the loopback address.

Sources: CMakeLists.txt:37-56, tests/api_server_tests.cpp:108-124, tests/protocol_tests.cpp:21-43

Summary

The bootstrapping process of mcpi-recompiled establishes a foundation for Minecraft Pi compatibility. It configures a cross-platform build environment, validates the command parsing logic, and provides a multi-threaded TCP server architecture. This modular approach ensures that core communication systems are verified through unit and integration tests before the complex reconstruction of game systems begins.

Sources: README.md:25-33, CMakeLists.txt:1-5