Dated source reference. Current release status: handoff state. Full original relative paths are in the developer archive.

OpenHoops year cell experiment

Current scope (October13,2026): Windows-first deep editing and a public extension API; Mac/Linux compatibility follows later. Earlier native-port goals and next-step proposals in this evidence history are superseded. Technical observations and verification limits remain as recorded.

Three short routines from the supplied NBA 2K14 executable have been reconstructed as ordinary C++17 and compared with the original x86 instructions. The resulting probe runs natively on macOS ARM64, without Wine, a game process or an emulator dependency. Unicorn runs only on the reference side of the verification script.

This is a deliberately small reconstruction experiment: reading, writing and resetting a 32-bit state cell. It does not implement gameplay or establish that the entire game can be recompiled.

Evidence

Elan's source labels module offset 0xF32918 as the internal game year. In our exact executable, that resolves to preferred virtual address 0x01332918. References lead to INT3-delimited, two-instruction routines:

The game-year label is supported by the community source and reset constant; its effect during gameplay has not been exercised. C++ uses uint32_t to preserve bit patterns without assuming signedness, accepted calendar ranges or a complete year subsystem. The reconstructed API uses explicit state instead of the original absolute global address. Setter/reset return values and the original x86 register ABI are not part of that API.

Evidence records exact bytes, RVAs, offsets, instruction decoding and the input executable hash. Validation records the compiler, native binary identity, source hashes and test scope.

Reproduce

From the project root, with Python 3 and a C++17-capable clang++ available:

python3 -m venv .venv
.venv/bin/python -m pip install -r tools/requirements-analysis.txt
.venv/bin/python tools/verify_year_cell.py

The verifier refuses an executable that differs from the recorded reference hash. It extracts only the three routine byte sequences and maps minimal code, state and stack pages in the x86 test oracle. No game startup code or Windows API is executed. Each call has an instruction bound, a checked return destination and neighboring memory checks.

The 3,315 cases cover all three operations over nine edge values paired with each other and 1,024 seeded random pairs. Native results are compared against the original instructions, rather than a second implementation of the C++ formulas.

To build the native probe alone, without Python or Unicorn:

clang++ -std=c++17 -O2 -Wall -Wextra -Werror experiments/year-cell/year_cell.cpp experiments/year-cell/driver.cpp -o openhoops_year_cell_probe

The executable accepts lines containing operation initial_value argument, using decimal integers. Operations are 0=read, 1=write, 2=reset. Output is resulting_state getter_result; the second value is zero for void operations.

A CMake target is supplied for future platform builds. The direct Clang build was tested on macOS ARM64; CMake, Windows x86/x64, macOS x64 and Linux builds have not yet been tested. The C++ probe does not link the analysis libraries.