(adsbygoogle = window.adsbygoogle || []).push({}); https://www.mediafire.com/file/45blp7rv66afn0d/Phoenix_BO1_SPRX_Starter_SDK.zip/file

SPRX base file ( just for testing https://www.mediafire.com/file/ssj1c57bj0qpqnl/PhoenixSdkStarter.sprx/file )

Enjoy
(README)
# BO1 SDK - PS3 Zombies BLES01031 1.13

Portable developer SDK for the exact analyzed BLES01031 1.13 Zombies EBOOT with
PPU TOC `0x00A544B0`. It contains 12746 EBOOT function records, 895 GSC
builtins, 65 engine-binding records, and the recovered 9226-resource extraction
plus generated asset and map metadata.

This export separates callable, signature-gated code from research catalogs.
Finding an address in a CSV file does not make it safe to call.

## Layout

- `include/`: umbrella SDK, semantic addresses, layouts, assets and fastfile resources.
- `src/`: signature-gated native API and bounded typed GSC VM bridge.
- `catalogs/`: full CSV/JSON datasets with address, prototype, status and provenance.
- `docs/`: engine bindings, GSC guide, confidence rules and subsystem indexes.
- `examples/`: native drawing and queued GSC builtin examples.
- `starter/`: Visual Studio PS3 SPRX solution, safe base menu and commented recipes.
- `DISTRIBUTION_README.md`: posting, build, loading and controller guide.
- `tools/`: reproducible generators; run them from the Phoenix source checkout.

## Quick start

### Build the included SPRX without Visual Studio

The SDK includes a standalone PowerShell build route. It invokes the Sony SNC
PPU compiler, PRX linker and `make_fself` directly, so Visual Studio is not
required:

```powershell
# Debug FSELF (default)
.\Build-SPRX.ps1

# Stable SNC release FSELF (-O1, NDEBUG)
.\Build-SPRX.ps1 -Configuration Release

# Clean and rebuild
.\Build-SPRX.ps1 -Configuration Debug -Clean

# Build without opening Windows Explorer afterwards
.\Build-SPRX.ps1 -Configuration Debug -NoExplorer
```

The script compiles the base-menu sources together with the typed BO1 SDK and
GSC VM bridge. Output is written to
`starter/build/debug/PhoenixSdkStarter.sprx` or
`starter/build/release/PhoenixSdkStarter.sprx`. Set `SCE_PS3_ROOT`, or pass
`-SdkRoot C:\usr\local\cell` when the SDK is installed elsewhere.
After a successful interactive build, Windows Explorer opens and selects the
generated SPRX. All paths are resolved relative to the SDK folder; no Windows
username or fixed SDK location is embedded. Use `-NoExplorer` for CI scripts.

1. Add `BO1_SDK/include` to the PPU compiler include path.
2. Compile `src/bo1_zm_sdk.cpp` and, for GSC calls,
`src/bo1_zm_gsc_vm.cpp` into the SPRX.
3. Include `bo1_zm_sdk.h` for typed native calls and
`bo1_zm_gsc_vm.h` for the VM queue.
4. After the supported EBOOT is resident, call `InitializeTypedApi`.
5. Install game/render/server-frame hooks only at their documented contexts.
6. Treat a feature as successful only after an independent Readback.

Minimal native initialization:

```cpp
#include "bo1_zm_sdk.h"
using namespace phoenix::bo1_zm_sdk;
static TypedApi g_api;

bool InitializeSdk() {
return InitializeTypedApi(&g_api, DirectMemoryReader, 0) ==
kTypedBindingCount;
}
```

See `examples/typed_native_example.cpp` and
`examples/gsc_builtin_example.cpp` for compileable integration fragments.
For a complete starting project, open `starter/PhoenixSprxStarter.sln` with the
Sony PS3 Visual Studio platform installed.
Start with `docs/GETTING_STARTED.md`, then use `docs/API_REFERENCE.md` and
`docs/GSC_EXAMPLES.md` as the integration and recipe references.

## Calling native EBOOT functions

`InitializeTypedApi` reads the expected PPC instruction words before creating
persistent PS3 ELFv1 descriptors. Every descriptor pairs an entry address with
TOC `0x00A544B0`. Use only non-null members of `TypedApi`; do not cast catalog
addresses to guessed C++ prototypes. `docs/engine-bindings.md` lists the
prototype, status, signature and context for each recovered binding.

## Calling GSC builtins

GSC builtins are VM wrappers, not ordinary native functions. Initialize with
`InitializeGscVmDispatcher`, queue a typed request using `QueueGscVmCommand` or
`QueueGscVmBuiltin`, then call `TickGscVmDispatcher` from the active GSC VM or
server-frame hook. Retrieve the result by sequence ID using
`TakeGscVmCompletion`. The bridge bounds queue size and per-frame work, restores
VM stack state, and releases temporary strings. Full argument and completion
rules are in `docs/GSC_VM_CALLING.md`.

## Thread and context rules

- Rendering functions run only on the proven render hook.
- Dvar, command, material and font work runs in the game-frame context.
- Entity, origin, ammo, revive and mutation work runs on the server thread.
- GSC dispatch runs only while the active GSC VM context is valid.
- Never call engine or VM functions directly from `module_start` or an
unrelated worker thread.

## Readback and failure handling

Signature acceptance proves binary compatibility, not gameplay effect. After a
mutation, read the affected Dvar, playerState, entity, inventory, perk or VM
result independently. Keep feature state disabled when initialization,
signature validation, context validation, dispatch or Readback fails. Unknown
catalog records remain browse-only until their prototype, context and visible
effect are proven.

## Catalogs and generated headers

- `functions.csv/json`: complete address inventory with callers, callees,
strings, subsystem, confidence and provenance.
- `semantic-functions.csv` and `bo1_zm_semantic_symbols.generated.h`: reviewed
aliases and honest unknown names suitable for search and navigation.
- `builtins.csv/json`: all 895 recovered builtin records; only typed dispatcher
commands are callable through the public bridge.
- `engine-bindings.csv`: typed and research bindings with validation state.
- `bo1_zm_assets.generated.h` and fastfile resource headers: recovered weapon,
model, FX, sound, map and resource metadata, not automatic runtime handles.

## Mapping confidence and naming

Proven symbols use engine or GSC names. Behaviorally reconstructed symbols keep
reviewed provenance. Unresolved functions are named `UNKNOWN_<address>` instead
of leaking `FUN_` placeholders or presenting guesses as facts. Confidence
levels `RUNTIME_READY`, `SIGNATURE_ONLY`, `MAPPED_VM_ONLY`, `reviewed_manual`
and `heuristic_*` are defined in `docs/MAPPING_CONFIDENCE.md`.

## Scope and safety

This SDK is version-locked to BLES01031 1.13. Revalidate signatures, TOC,
entity layouts and thread context for every other EBOOT. `SIGNATURE_ONLY`,
`MAPPED_VM_ONLY` and heuristic records are research metadata until promoted by
runtime evidence. There is deliberately no arbitrary-address call helper.

## Regenerating the SDK

Run the exporter from the Phoenix checkout:

```powershell
powershell -ExecutionPolicy Bypass -File native\tools\export_bo1_sdk.ps1 `
-OutputDirectory C:\Users\vanha\Documents\BO1_SDK -Force
```

The export is cleanly replaced and `MANIFEST.sha256` is regenerated. Verify the
manifest before copying the SDK or comparing builds. Generator scripts in
`tools/` require the original Phoenix reverse-engineering inputs and are kept
for provenance; the exported headers and sources themselves have no Phoenix
include-path dependency.

Validate any exported copy with:

```powershell
powershell -ExecutionPolicy Bypass -File tools\verify_sdk.ps1
```

This is only **v0.1 of the SDK**. More advanced versions will be released later.

I genuinely love **Black Ops 1 Zombies**, and my long-term goal is to push the game beyond its original limitations. I am currently investigating ways to improve the textures, enhance the visuals, and potentially modify or replace parts of the rendering engine.

Since certain PS3 systems can be overclocked, we may be able to take advantage of the additional processing power to improve graphical quality and overall performance.

One of my main objectives is to port or bridge the **Black Ops 1 PS3 server and lobby functionality** into a PS4 or PS5 environment. I believe it is technically possible. I have already managed to join a lobby through this setup, although the game currently crashes as soon as the match begins.

There is still a lot of research, testing, and reverse engineering required, but this is only the beginning....

Make the PS3 Great again!