Inventory

GC2 Inventory Network Integration

Server-authoritative inventory networking for Game Creator 2 Inventory module. Designed for competitive multiplayer with cheat prevention.

Features

Server Authority

• Content Operations: Add, Remove, Move, Use, Drop items validated server-side

• Equipment System: Equip/Unequip with server validation

• Socket Operations: Attach/Detach items from sockets

• Wealth Management: Currency Add/Subtract/Set with server authority

• Merchant Transactions: Buy/Sell validated server-side

• Crafting Operations: Craft/Dismantle with ingredient verification

• Transfer System: Bag-to-bag transfers with validation

Anti-Cheat Protection

• Item duplication prevention

• Gold/currency exploit prevention

• Illegal crafting blocked

• Equipment slot validation

• Socket compatibility checks

• Rate limiting per client

Architecture

NetworkInventoryManager (Singleton)
    ├── Transport Delegates (wire to your networking)
    ├── Controller Registry
    └── Request Routing

NetworkInventoryController (Per-Bag)
    ├── Request Methods (Client)
    ├── Process Methods (Server)
    ├── Broadcast Receivers (Client)
    └── RuntimeItem Tracking

Component Placement

• Add exactly one NetworkInventoryManager to a persistent scene object (network bootstrap/root).

  • 
• Add one NetworkInventoryController on each networked player/NPC GameObject that owns a GC2 Bag.

  • 
• The controller should live on the same GameObject as Bag and NetworkCharacter.

• Register controllers with the manager using NetworkCharacter.NetworkId when the entity is spawned/ready.

Quick Start

1. Setup Manager

Add NetworkInventoryManager to a persistent scene object:

// On server
NetworkInventoryManager.Instance.IsServer = true;

// Wire transport delegates (example with any networking solution)
NetworkInventoryManager.Instance.OnSendContentAddRequest = SendToServerMethod;
NetworkInventoryManager.Instance.OnBroadcastItemAdded = BroadcastToClientsMethod;
// ... wire all needed delegates

2. Setup Per-Bag Controller

Add NetworkInventoryController alongside each Bag component:

// During spawn/initialize (after NetworkCharacter has a valid NetworkId)
var networkCharacter = GetComponent<NetworkCharacter>();
var controller = GetComponent<NetworkInventoryController>();

controller.Initialize(isServer, isLocalClient);
if (NetworkInventoryManager.Instance != null)
{
    NetworkInventoryManager.Instance.RegisterController(networkCharacter.NetworkId, controller);
}

// During despawn/cleanup
if (NetworkInventoryManager.Instance != null)
{
    NetworkInventoryManager.Instance.UnregisterController(networkCharacter.NetworkId);
}

3. Client Operations

Instead of calling Bag methods directly, use controller requests:

// OLD (don't use in multiplayer):
// bag.Content.Add(item, true);

// NEW (server-authoritative):
controller.RequestAddItem(itemIdHash, 1);

// With callback
controller.RequestAddItem(itemIdHash, 1, OnAddResult);

void OnAddResult(NetworkContentAddResponse response)
{
    if (response.Authorized)
        Debug.Log($"Added item: {response.RuntimeIdString}");
    else
        Debug.Log($"Rejected: {response.RejectionReason}");
}

Operations Reference

Content Operations

Operation	Client Request	Server Validates
Add	RequestAddItem(hash, count)	Space, stacking rules
Remove	RequestRemoveItem(runtimeId, count)	Item exists, count valid
Move	RequestMoveItem(from, to)	Valid indices, space
Use	RequestUseItem(runtimeId)	Item exists, usable
Drop	RequestDropItem(runtimeId, count, pos)	Item exists, count valid

Equipment Operations

Operation	Client Request	Server Validates
Equip	RequestEquip(runtimeId)	Item exists, compatible
Unequip	RequestUnequip(runtimeId)	Item equipped
UnequipFromIndex	RequestUnequipFromIndex(index)	Index valid, item equipped

Socket Operations

Operation	Client Request	Server Validates
Attach	RequestAttachToSocket(parentId, childId, slot)	Items exist, compatible
Detach	RequestDetachFromSocket(parentId, childId, slot)	Items attached

Wealth Operations

Operation	Client Request	Server Validates
Add Currency	RequestWealthModify(Add, currency, amount)	Server-only typically
Subtract	RequestWealthModify(Subtract, currency, amount)	Sufficient funds
Set	RequestWealthModify(Set, currency, amount)	Server-only typically

Network Types

Core Structures

// Network representation of RuntimeItem
NetworkRuntimeItem
{
    ItemHash,           // Item definition hash
    RuntimeIdHash,      // Unique instance hash
    RuntimeIdString,    // String for reconstruction
    Properties[],       // Serialized properties
    Sockets[]          // Nested items in sockets
}

// Inventory cell
NetworkCell
{
    CellIndex,
    Stack[]            // Items in this cell
}

// Full inventory state
NetworkInventorySnapshot
{
    BagNetworkId,
    Cells[],
    EquippedItems[],
    Wealth[]
}

Request/Response Pattern

All operations follow request-response pattern:

// Client sends request
NetworkContentAddRequest
{
    RequestId,          // Unique request ID
    TargetBagNetworkId, // Which bag
    ItemIdHash,         // What item
    Amount,             // How many
    Source             // Modification source
}

// Server responds
NetworkContentAddResponse
{
    RequestId,          // Matching request
    Authorized,         // Was it allowed
    RejectionReason,    // Why rejected
    ResultingItem       // The created item (if authorized)
}

Custom Validation

Extend validation with custom logic:

// Example: Prevent adding items during combat
NetworkInventoryManager.Instance.CustomAddValidator = (request, clientId) =>
{
    if (IsInCombat(clientId))
        return (false, InventoryRejectionReason.ConditionFailed);
    return (true, InventoryRejectionReason.None);
};

// Example: Custom merchant restrictions
NetworkInventoryManager.Instance.CustomMerchantValidator = (request, clientId) =>
{
    if (!IsNearMerchant(clientId, request.MerchantNetworkId))
        return (false, InventoryRejectionReason.OutOfRange);
    return (true, InventoryRejectionReason.None);
};

Transport Integration Examples

Netcode for GameObjects (optional example)

This sample follows NGO 2.10 unified RPC API ([Rpc], RpcParams, RpcTarget).

// using Unity.Netcode;
public class InventoryNetworkBridge : NetworkBehaviour
{
    void Start()
    {
        var manager = NetworkInventoryManager.Instance;
        
        // Client → Server
        manager.OnSendContentAddRequest = (req) => AddItemRequestRpc(req);
        manager.OnSendEquipmentRequest = (req) => EquipmentRequestRpc(req);
        
        // Server → Client
        manager.OnBroadcastItemAdded = (bc) => BroadcastItemAddedRpc(bc);
        manager.OnSendSnapshotToClient = SendSnapshotToClient;
    }
    
    [Rpc(SendTo.Server, InvokePermission = RpcInvokePermission.Everyone)]
    void AddItemRequestRpc(NetworkContentAddRequest request, RpcParams rpcParams = default)
    {
        NetworkInventoryManager.Instance.ReceiveContentAddRequest(request, rpcParams.Receive.SenderClientId);
    }
    
    [Rpc(SendTo.Server, InvokePermission = RpcInvokePermission.Everyone)]
    void EquipmentRequestRpc(NetworkEquipmentRequest request, RpcParams rpcParams = default)
    {
        _ = NetworkInventoryManager.Instance.ReceiveEquipmentRequest(request, rpcParams.Receive.SenderClientId);
    }

    [Rpc(SendTo.ClientsAndHost)]
    void BroadcastItemAddedRpc(NetworkItemAddedBroadcast broadcast)
    {
        if (!IsServer) // Avoid double-processing on host
            NetworkInventoryManager.Instance.ReceiveItemAddedBroadcast(broadcast);
    }

    [Rpc(SendTo.SpecifiedInParams)]
    void SendSnapshotRpc(NetworkInventorySnapshot snapshot, RpcParams rpcParams = default)
    {
        if (!IsServer)
            NetworkInventoryManager.Instance.ReceiveFullSnapshot(snapshot);
    }

    void SendSnapshotToClient(ulong clientId, NetworkInventorySnapshot snapshot)
    {
        SendSnapshotRpc(snapshot, RpcTarget.Single(clientId, RpcTargetUse.Temp));
    }
}

FishNet

public class InventoryNetworkBridge : NetworkBehaviour
{
    public override void OnStartNetwork()
    {
        var manager = NetworkInventoryManager.Instance;
        
        manager.OnSendContentAddRequest = (req) => AddItemServer(req);
        manager.OnBroadcastItemAdded = (bc) => ItemAddedObservers(bc);
    }
    
    [ServerRpc]
    void AddItemServer(NetworkContentAddRequest request)
    {
        var clientId = Owner.ClientId;
        NetworkInventoryManager.Instance.ReceiveContentAddRequest(request, (ulong)clientId);
    }
    
    [ObserversRpc]
    void ItemAddedObservers(NetworkItemAddedBroadcast broadcast)
    {
        if (!IsServerInitialized)
            NetworkInventoryManager.Instance.ReceiveItemAddedBroadcast(broadcast);
    }
}

Best Practices

DO:

• ✅ Always use request methods for player inventory changes

• ✅ Handle rejection callbacks gracefully

• ✅ Implement custom validators for game-specific rules

• ✅ Use snapshots for late-joining players

• ✅ Log rejections for debugging potential exploits

DON'T:

• ❌ Call Bag methods directly on client for authoritative data

• ❌ Trust client-reported item counts

• ❌ Skip server validation for "trusted" operations

• ❌ Broadcast sensitive inventory data to non-owners

Events

The controller fires events for UI updates:

controller.OnItemAdded += (item) => RefreshInventoryUI();
controller.OnItemRemoved += (runtimeId) => RefreshInventoryUI();
controller.OnWealthChanged += (currency, newAmount) => UpdateGoldDisplay(newAmount);
controller.OnEquipmentChanged += () => RefreshEquipmentUI();

Rejection Reasons

Reason	Description
None	No rejection
BagNotFound	Target bag doesn't exist
ItemNotFound	Referenced item not found
BagFull	No space in inventory
InsufficientFunds	Not enough currency
InsufficientAmount	Not enough items
ConditionFailed	Custom condition failed
InvalidOperation	Operation not supported
NotOwner	Client doesn't own this bag
OutOfRange	Target too far away
Cooldown	Operation on cooldown
EquipmentSlotFull	Equipment slot occupied
IncompatibleSocket	Socket doesn't accept item

Files

File	Purpose
NetworkInventoryTypes.cs	All network data structures
NetworkInventoryController.cs	Per-bag inventory network management
NetworkInventoryManager.cs	Global singleton, transport routing

Dependencies

• Game Creator 2 Core

• Game Creator 2 Inventory Module

• Unity 2021.3+

Define Symbol

This module requires GC2_INVENTORY define symbol, which is automatically set via Version Defines when com.gamecreator.inventory package is present.