Addon Packages — History and Current State

Historically, RCC was sold with two separately-purchased addon packages that added major systems on top of the core asset:

1. BCG Shared Assets — an Enter/Exit system that let players walk around on foot and enter/exit vehicles.
2. Photon Integration Package — multiplayer support using Photon PUN 2.

Both addons have been discontinued in V5. This document explains why, what to do if you have an old project that uses them, and where to look for equivalent functionality today.

Why Both Addons Were Removed

When V5 of RCC went into LTS / maintenance mode, BoneCracker Games audited every system to decide what fit the new scope. The two addons were removed for these reasons:

• They weren't part of RCC's identity. RCC is a vehicle physics package. Multiplayer and on-foot character control are major systems with their own complexity and maintenance burden. Tying them to RCC's release cycle was holding both back.
• Better alternatives exist. Unity now ships its own first-party networking (Netcode for GameObjects), and the Unity Asset Store has dozens of dedicated character controllers. Maintaining custom versions inside RCC was duplicating work.
• LTS philosophy. RCC is now a "stable, no new features" asset. Photon and Enter/Exit changes would have forced ongoing development, which isn't compatible with the LTS commitment.

For projects that need these features going forward, the recommendation is to layer your own network sync or character system on top of RCC. 17 — Overriding Inputs is the foundation: any external controller — multiplayer, AI, or character-driven — talks to the vehicle through that same interface.

BCG Shared Assets — The Enter/Exit System

What It Was

The Enter/Exit system gave you:

• A third-person character controller (player walks around).
• A vehicle "enter" trigger zone — walk up to a vehicle, press a key, the camera transitions to vehicle mode and you take control.
• An "exit" mechanic — press the same key to step out, the camera returns to character mode.
• A bridge between RCC's vehicle events and the character (so the character ragdolled during major vehicle crashes, for example).

It was sold as a separate Asset Store package because the character system was substantial enough to warrant its own price.

Why It Was Useful

GTA-style gameplay, where the player can be on foot or in a vehicle, requires this kind of transition. Without it, you had to build the character controller and the enter/exit logic yourself — non-trivial work, especially the camera handoff.

What Replaces It

For new projects, build your own:

1. Use any third-party character controller (Unity's free Starter Assets pack, or commercial ones like UMotion, Opsive's UCC).
2. When the player presses "enter": - Hide the character mesh. - Disable the character controller. - Call RCC.RegisterPlayerVehicle(vehicle). - The RCC camera takes over and follows the vehicle.
3. When the player presses "exit": - Call RCC.DeRegisterPlayerVehicle(). - Re-enable the character. - Position the character next to the vehicle's exit anchor. - Disable the RCC camera and re-enable a character follow camera.

This is a few hundred lines of glue code, mostly state-machine logic for the transitions. Use the RCC_Events.OnRCCPlayerSpawned / OnRCCPlayerDestroyed events to coordinate.

Migrating an Old Project

If you have an existing project that uses the old BCG Shared Assets package:

1. Don't update RCC yet. Updating overwrites the integration points the addon hooks into.
2. Decide your migration strategy. Options: - Stay on RCC V4.x indefinitely (the addon works there). - Update to RCC V5 and rewrite your enter/exit logic from scratch. - Stay on V4.x for one final release and migrate to V5 for the next.
3. Back up your project (Git commit) before any RCC update.

If you ask BoneCracker Games support, they can sometimes share archived V4-era versions of the addon for projects that need backward compatibility.

Photon Integration Package

What It Was

The Photon Integration Package wrapped RCC vehicles with Photon PUN 2 networking. Each player's vehicle was a PhotonView, and the package handled:

• Input replication (player inputs sent over the network).
• Transform sync (position / rotation interpolation).
• Rigidbody state sync (velocity, angular velocity).
• Event sync (gear shifts, indicator toggles, etc.).
• A demo scene with a lobby and a city scene.

It was sold separately because Photon networking is a major dependency and not everyone needed it.

Why It Was Useful

Multiplayer driving games are a popular genre. Pre-built networking saves weeks of work and avoids common pitfalls like jittery remote vehicles.

What Replaces It

For new projects, the recommended approach is Unity's official Netcode for GameObjects (NGO):

1. Install Netcode for GameObjects via Package Manager.
2. Add a NetworkObject component to your vehicle prefab.
3. Add a NetworkTransform component for sync.
4. Write a small script that: - On the owning client, reads inputs from RCC's input system and pushes them via an RPC. - On the non-owning clients, receives inputs and feeds them via OverrideInputs().

The full implementation depends on your authority model (server-authoritative vs client-authoritative) and your latency requirements. Search "Unity Netcode racing game" for community tutorials.

Alternatives:

• Mirror Networking — open-source, mature.
• Photon Fusion — Photon's modern replacement for PUN, faster and more deterministic.
• Photon PUN 2 — still available, but no longer integrated with RCC. You'd build the integration yourself using the same pattern.

Migrating an Old Project

Same advice as for Enter/Exit:

1. Back up.
2. Decide: stay on V4.x, or migrate to V5 and rewrite networking.
3. If migrating, use the Photon integration as a reference (it's a guide for how to bridge RCC to a network library), but the actual code needs to be rewritten on top of NGO / Fusion / Mirror.

Photon-Related Defines

If you previously had the Photon addon installed, your project may have these scripting define symbols left over:

• RCC_PHOTON
• PHOTON_UNITY_NETWORKING

These were used by RCC's V4-era code to conditionally compile Photon-aware code paths. In V5, all #if RCC_PHOTON blocks have been removed. You can safely remove these defines from your project's Scripting Define Symbols (Project Settings → Player → Other Settings).

If you see compile errors mentioning Photon.PhotonNetwork or PhotonView after updating to V5, it's because your project still has Photon assemblies but RCC no longer references them. Either:

• Install Photon PUN 2 (if you actually want multiplayer).
• Or remove Photon from your project entirely.

BCG_ENTEREXIT Define

Similarly, the BCG_ENTEREXIT define was used by V4-era RCC code to conditionally enable Enter/Exit integration points. In V5:

• All #if BCG_ENTEREXIT blocks are still in RCC_Events.cs (so user code that subscribes to OnPlayerEnteredVehicle / OnPlayerExitedVehicle doesn't break at compile time).
• The events never fire because the addon is gone.

You can safely remove the BCG_ENTEREXIT define from your project once you've ensured no game code depends on it.

What's Left in V5

V5 includes a minimal RCC_CharacterController.cs script in Scripts/Others/. This is a very basic placeholder (a few dozen lines) used by certain demo scenes for cameras that aren't following a vehicle. It is not an Enter/Exit system — don't try to use it as a base for character gameplay.

Building Your Own Multiplayer / Character Integration

If you're starting fresh on either feature, here's the recommended path:

Multiplayer

1. Install Netcode for GameObjects.
2. Make your vehicle prefab a NetworkObject.
3. Use OverrideInputs() on non-owning clients to drive the vehicle from received inputs.
4. Sync transform + rigidbody state with NetworkTransform + custom RPCs.
5. Test on LAN, then iterate on latency masking.

A complete implementation is roughly 200–400 lines of glue code. There are community examples on GitHub — search "Unity NGO car game."

Character

1. Use any third-party character controller.
2. Detect "enter vehicle" via a trigger volume around each vehicle.
3. On enter input, switch state machines (hide character, register RCC player).
4. On exit input, switch back.
5. Add cosmetic transitions (open door, animated entry, camera blend).

Total: 100–300 lines, depending on polish.

Next Steps

• 17 — Overriding Inputs — the foundation for multiplayer / character integration.
• 24 — Events System — events to coordinate between vehicle and external systems.
• 23 — Scripting API — RegisterPlayerVehicle / DeRegisterPlayerVehicle for character transitions.