Game.Vehicles.BlockerType

Assembly:
Assembly-CSharp (game code assembly; may vary depending on build)

Namespace: Game.Vehicles

Type:
public enum BlockerType : byte

Base:
System.Enum (underlying type: System.Byte)

Summary:
Represents different kinds of "blockers" used by the vehicle/pathing systems to control movement. Blocker types indicate why a path or lane is being blocked or restricted — for example, because of a crossing, traffic signal, temporary obstruction, spawn point, or oncoming traffic. Modders can use this enum when inspecting or setting blocker flags in vehicle AI, pathfinding, or traffic management code.

---

Fields

• None
  No blocker; the lane/path is not being blocked.

• Continuing
  A blocker indicating a continuing movement (e.g., reserved space for a vehicle continuing through an intersection or lane).

• Crossing
  Blocker used for crossings (pedestrian crossings, cross-traffic) to prevent vehicles from entering conflicting spaces.

• Signal
  Blocker originating from a traffic signal — used when a light/pulse prevents movement.

• Temporary
  Temporary blocker for short-lived obstructions (e.g., short stops, transient reservations).

• Limit
  Blocker representing a capacity or limit restriction (e.g., a maximum number of vehicles allowed in an area).

• Caution
  A cautionary blocker that indicates a reduced-confidence or advisory restriction (not necessarily a full stop).

• Spawn
  Blocker related to spawning logic — used when vehicles are being spawned or a spawn point needs to reserve space.

• Oncoming
  Blocker that marks oncoming traffic as a reason to block a tile/lane (used to avoid head-on conflicts).

Properties

• This enum type does not define any properties. It's a plain value type (enum) used as a flag/indicator in code.

Constructors

• public BlockerType()
  Enums have an implicit parameterless constructor and each named value maps to an underlying byte value. There are no custom constructors defined.

Methods

• This enum does not declare any methods. It inherits the standard System.Enum methods (ToString, HasFlag, etc.) from the .NET base types.

Usage Example

using Game.Vehicles;

public void HandleBlocker(BlockerType blocker)
{
    switch (blocker)
    {
        case BlockerType.None:
            // No restriction; proceed normally.
            break;
        case BlockerType.Signal:
            // Respect traffic signal logic.
            break;
        case BlockerType.Crossing:
            // Wait for crossing to clear.
            break;
        case BlockerType.Temporary:
            // Short pause or reroute.
            break;
        case BlockerType.Spawn:
            // Reserve space for spawning vehicle.
            break;
        case BlockerType.Oncoming:
            // Yield to oncoming traffic.
            break;
        default:
            // Handle other blocker types (Continuing, Limit, Caution).
            break;
    }
}

Notes for modders: - The underlying byte values are assigned in declaration order starting at 0 (None = 0, Continuing = 1, ... Oncoming = 8). Use explicit casts if interacting with raw memory/bitfields. - Check surrounding APIs (vehicle/pathing systems) for how BlockerType is stored/checked — it may appear in structs or arrays used by the simulation.