Troll Battle 64 Recompiled Project at 99.05%

Technology news

Static recompilation of the N64 video game Troll Battle 64: Person of Lordly Caliber
(USA, Rev A)to a native PC executable, utilizing the N64Recomp toolchain.

This repository consists of no copyrighted video game information. You should provide your own ROM dump (see listed below).

System Requirements

A 64-bit PC and a GPU the renderer supports:

  • GPU — Direct3D 12.0 (Shader Model 6.0) or Vulkan 1.2 on Windows, Vulkan 1.2 on Linux, Metal on macOS. The earliest GPUs those cover are approximately GeForce GT 630, Radeon HD 7750 (2012) and Intel HD 510 (Skylake).
  • CPU — x86-64 with SSE4.1 (Intel Core 2 Penryn, AMD Bulldozer or more recent). The macOS develop requirements Apple Silicon.
  • OS — Windows 10 or 11 (64-bit); macOS 11 or more recent on Apple Silicon; a glibc Linux with a Vulkan 1.2 chauffeur.
  • RAM — 2 GB. The replicated N64 device dedicates 512 MB.
  • Disk — about 150 MB for the app, plus the ROM.
  • Video game information — your own Ogre Battle 64 (USA, Rev A) cartridge dump, 40 MB in
    .z64 .n64 or .v64No video game information is consisted of.
  • A keyboard suffices to play; a gamepad with XInput (Windows) or SDL controller assistance is optional. An audio gadget is optional too: with none, the video game runs quietly. On Windows no Visual C++ redistributable is needed– the plan brings the runtime its shader compiler requirements.
    If the video game crashes as it begins, upgrade the graphics motorist. On an older GPU, OGRE_CONSOLE=1 opens a console with the boot log and OGRE_GRAPHICS_API
    pins the backend (vulkan or d3d12.

    AI Disclaimer

    This operate in this task was mainly carried out by the DeepSeek v4/v4.1 Flash design.[19459089]Status

    The primary code section (807 functions)has actually been totally recompiled to C. The runtime app (making, input, audio)is the next turning point. See PLAN.md for the complete strategy, existing status, and technical findings.

    Directory design

    assets/                your ROM (gitignored; big-endian .z64 expected)
    asm/                   splat-generated disassembly
    debug/                 headless-browser probes for the wasm build (see debug/README.md)
    config.yaml            splat config (segments, vram mapping)
    config.toml            N64Recomp config
    Makefile               assemble + link + recompile
    n64recomp-ob64.patch   our N64Recomp modifications (apply to upstream clone)
    rt64-plume-sdl.patch   our RT64 plume patch — SDL>=2.0.22 guard (apply to the
                           tools/RT64 submodule on systems with older SDL2, e.g. Ubuntu 22.04)
    PLAN.md                the project plan
    

    Getting began

    See Recreate in PLAN.md. Summary:

    # tools(macOS)
    brew set up mips-linux-gnu-binutils cmake python3- m venv tools/venv & tools/venv/bin/ pip set up splat64[mips]
    
    git clone-- recurse-submodules https://github.com/N64Recomp/N64Recomp.git tools/N64Recomp git-C tools/N64Recomp use./>./ n64recomp-ob64. spot cmake-S tools/N64Recomp-B tools/N64Recomp/build- DCMAKE_BUILD_TYPE=Release cmake-- construct tools/N64Recomp/build-- target N64RecompCLI-j4
    
    # ROM: put your.z64 dispose in properties/, then regrow the recompiled code
    # (see docs/guides/app-build. md -> "Regenerating the recompiled code"
    make restore

    The ROM needs to be the USA Rev A dump(40 MB, .n64 16-bit byte-swapped or currently transformed .z64. tools/convert_rom.py transforms .n64.z64
    A fresh clone can not develop the app till make regenerate has actually run when: the recompiled C(RecompiledFuncs/ Bank*Funcs/ RspFuncs/
    app/src/bank_funcs.incis produced from your own ROM and is intentionally not devoted. make regenerate runs splat, the MIPS link, the 34 bank systems, the primary recompilation and

    the RSP microcode in the one order that works.[cmake-Sapp-Bbuild-app-DCMAKE_BUILD_TYPE=Releasecmake–buildbuild-app-j/build-app/ogrebattle64″>
    Build and run the app

    cmake -S app -B build-app -DCMAKE_BUILD_TYPE=Release
    cmake --build build-app -j
    ./build-app/ogrebattle64

    On launch the app reveals a black start screen– OGRE BATTLE 64: RECOMP /
    CLICK TO LOAD YOUR ROM (OR DROP IT IN THIS WINDOW)Click it to select your ROM, drag the ROM onto the window, or simply put the ROM beside the executable. The ROM is verified by hash and kept, so later on introduces go directly into the video game.

    The battery conserve lands in saves/ next to the executable
    A playable develop

    make dist        # -> dist/ogre-battle-64-recomp/   (one self-contained executable)
    make dist-zip    # -> dist/ogre-battle-64-recomp-.zip

    The plan is a file: SDL2 is connected statically (make dist brings and develops a pinned genuine SDL2 when, since Homebrew’s sdl2 is the SDL3-based compat shim and has no fixed library). No video game information is consisted of, so the gamer materials their own ROM on the start screen. See docs/guides/app-build.md
    “Distribution”.
    The renderer (tools/RT64is a git submodule pinned to an upstream dedicate and requires its own one-time spot on systems with SDL <


    Discover more from PMN S.P.O.R.T.S - A PRIME MEDIA NETWORK BRAND

    Subscribe to get the latest posts sent to your email.

    Related Articles

    LEAVE A REPLY

    Please enter your comment!
    Please enter your name here