TIZIOMANAGER
17 hours ago
29 minutes ago
3

TIZIOMANAGER - Comments

Comments
#888274 Decompiling & Reverse Engineering (AssetRipper, dnSpy, ILSpy, Il2CppDumper)
TIZIOMANAGER
17 hours ago
29 minutes ago
3
13 Jul 2026 15:19:36

Hi everyone, I’ve opened a dedicated thread about my FM23 native x64 reverse-engineering project:

[FM23] Looking for a partner — Bit-for-bit C++ replication of the native match engine
https://sortitoutsi.net/content/77224/fm23-looking-for-a-partner-bit-for-bit-c-replication-of-the-native-match-engine

The reverse-engineering work is already at a fairly advanced stage. I’m specifically looking for help with Ghidra, Cheat Engine, native pointers and runtime validation.

Anyone interested or looking for more information can reply in the dedicated thread or contact me by PM.

@thehologram, your work on the FM23 Cheat Engine table sounds particularly relevant, so I hope you don’t mind the tag.

#888272 [FM23] Looking for a partner — Bit-for-bit C++ replication of the native match engine
TIZIOMANAGER
17 hours ago
29 minutes ago
3
13 Jul 2026 15:12:09

Hi everyone,

I’m Tizio, a software developer from Italy with a professional background in Java, Spring Boot and Angular, and practical experience with C++, Ghidra, Cheat Engine, Blender and Unreal Engine 5.

For the past several months, I’ve been working on a difficult project: replicating the native FM23 match engine bit-for-bit in C++, starting from the x64 disassembly of fm.exe.

This is not .fmf tweaking, database editing or Unity/C# modding. The goal is to reproduce the actual match-engine logic in a standalone 2D simulator which, given the same initial state, produces the same result as FM23.

Current state

This is already an active reverse-engineering project with runtime validation, not just an idea.

Scoring and action evaluation

  • FM23 RNG identified as the LCG:

state = state * 0x41C64E6D + 0x3039

  • Rating calculation, modulator and evaluator reconstructed.
  • Validated against the running game through real runtime captures.
  • Replica and FM23 outputs match across the tested calls.

Ball physics

  • Ground rolling reconstructed and validated:

v' = v * 0.975 - 0.3472

  • Ball-flight segment calculations reconstructed.
  • Gravity identified as approximately -10.666.
  • Shot solver at 144410800 reconstructed, including direction and mode-dependent lift.
  • Validated across tens of thousands of real calls.

Player movement and pathing

  • Acceleration/deceleration functions reconstructed:
    • 1447401f0
    • 144740600
  • Interpolation function reconstructed:
    • 14442b1b0
  • Tick-indexed path sampling reconstructed.
  • End-to-end movement confirmed against the live game.
  • Current pathing test suite: 76/76 tests passing.

Important finding

The FM23 match engine appears to be largely geometric and deterministic.

Tackles, passes, goalkeeper interventions and shots are primarily resolved through:

  • distances;
  • angles;
  • positions;
  • velocities;
  • lookup tables;
  • deterministic branches.

They do not appear to use a simple independent dice roll for every action.

Targeted RNG is instead used in specific areas, especially fouls and scoring, through a shared utility function with roughly 9,000 call sites.

Where I need help

The next block is the emergent interaction layer:

  • tackle and duel resolution;
  • shot-to-outcome chain;
  • passing;
  • goalkeeper positioning and interception;
  • referee and foul generation;
  • final outcome dispatching.

The main functions have already been identified in Ghidra, including the duel resolver, foul generator, goalkeeper logic, pass logic and outcome dispatcher.

The difficult part now is runtime validation:

  1. Break on the real FM23 functions.
  2. Capture the actual arguments, registers, object pointers and structures.
  3. Compare the native FM23 result against the C++ replica.
  4. Resolve any remaining unknown fields and branches.
  5. Repeat until the outputs match.

This requires Ghidra, Cheat Engine, x64 debugging and a lot of patience.

Who I’m looking for

I’m looking for someone with experience or a strong interest in:

  • x64 assembly and Windows calling conventions;
  • Ghidra or IDA;
  • Cheat Engine and live-process debugging;
  • pointer tracing and structure reconstruction;
  • native C or C++;
  • deterministic simulation systems.

Experience with Football Manager modding is useful, but not required. Proper native reverse-engineering experience is more important.

I maintain a detailed technical log containing:

  • function addresses;
  • offsets;
  • decompiled functions;
  • reconstructed structures;
  • runtime captures;
  • comparison tests;
  • conclusions marked as [CONFIRMED], [HYPOTHESIS], [TESTED] or [DISCARDED].

I’m happy to share the relevant project state and technical log with someone genuinely interested in collaborating.

This project does not distribute the FM executable or original copyrighted game code.

If this sounds interesting, reply here. I cannot send private messages yet because this is a new account, but I can be contacted through the thread.

Cheers 🤝