Skip to content

Game.Net.Road

Assembly: (unspecified — part of the game's codebase)
Namespace: Game.Net

Type: struct

Base: IComponentData, IQueryTypeParameter, ISerializable

Summary:
Road is an ECS component (Unity DOTS) that stores aggregated traffic flow metrics and flags for a road entity. The struct packs flow durations and distances into four-component vectors (Unity.Mathematics.float4) and implements custom serialization/deserialization with backward-compatibility logic for older saved data versions. It is intended to be used as a component in the game's entity world (for example, to query or update traffic flow info per-road).

Fields

  • public float4 m_TrafficFlowDuration0
    Stores first set of traffic flow durations as a float4 (Unity.Mathematics.float4). The component uses two duration vectors (0 and 1) to hold flow duration values for multiple lanes/segments or to support interpolated values across frames.

  • public float4 m_TrafficFlowDuration1
    Second set / duplicate of traffic flow durations (float4). Used together with m_TrafficFlowDuration0 for representing separate samples or an updated copy.

  • public float4 m_TrafficFlowDistance0
    Stores first set of traffic flow distances as a float4. Represents aggregated distances related to traffic flow measurements.

  • public float4 m_TrafficFlowDistance1
    Second set / duplicate of traffic flow distances (float4).

  • public RoadFlags m_Flags
    A RoadFlags enum value containing flag bits for the road. In serialized form this flag is written/read as a single byte.

Properties

  • (This struct defines no C# properties; it exposes public fields directly.)

Constructors

  • public Road() (implicit default struct constructor)
    No explicit constructor is defined in the source. The struct relies on the implicit default constructor (all fields default-initialized). When used as an ECS component, instances are typically created/managed by the entities system.

Methods

  • public void Serialize<TWriter>(TWriter writer) where TWriter : IWriter
    Writes the component state to the provided writer. Serialization order:
  • m_TrafficFlowDuration0 (float4)
  • m_TrafficFlowDuration1 (float4)
  • m_TrafficFlowDistance0 (float4)
  • m_TrafficFlowDistance1 (float4)
  • m_Flags written as a single byte

This method assumes the writer is compatible with Colossal.Serialization.Entities.IWriter.

  • public void Deserialize<TReader>(TReader reader) where TReader : IReader
    Reads component state from the provided reader with explicit backward-compatibility handling depending on saved data version (reader.context.version):

  • If version >= Version.netInfoviewImprovements:

    • Reads four float4 values (duration0, duration1, distance0, distance1) into the corresponding fields.
  • Else (older versions):
    • Reads two float4 values: m_TrafficFlowDuration0 and m_TrafficFlowDistance0.
    • If version < Version.trafficFlowFixes:
    • Applies legacy fix/conversion:
      • Computes temp = m_TrafficFlowDuration0 + 1f
      • Scales m_TrafficFlowDistance0 by 0.01f (presumably to convert units)
      • Recomputes m_TrafficFlowDuration0 componentwise as: math.select(m_TrafficFlowDistance0 / temp, 0f, temp <= 0f) (i.e., if temp <= 0 choose 0, otherwise use distance / temp)
    • After legacy fixes (or for versions between trafficFlowFixes and netInfoviewImprovements):
    • Halves m_TrafficFlowDuration0 and m_TrafficFlowDistance0 (multiply by 0.5f).
    • Copies these halved values into m_TrafficFlowDuration1 and m_TrafficFlowDistance1 (duplicates).
  • Finally, if version >= Version.roadFlags:
    • Reads one byte and casts to RoadFlags to populate m_Flags.

Notes about math.select: math.select(a, b, condition) returns componentwise (condition ? b : a). In this code the call ensures that when temp <= 0 the duration becomes 0, otherwise it becomes distance / temp.

Usage Example

// Example usage in a mod or system — pseudo-code showing intent.
// Actual writer/reader types come from Colossal.Serialization.Entities and the game's save system.

using Unity.Mathematics;
using Game.Net;

// Creating and populating a Road component
var road = new Road();
road.m_TrafficFlowDuration0 = new float4(2.0f, 1.5f, 0.8f, 0.0f);
road.m_TrafficFlowDuration1 = road.m_TrafficFlowDuration0; // duplicate or updated separately
road.m_TrafficFlowDistance0 = new float4(100f, 80f, 40f, 0f);
road.m_TrafficFlowDistance1 = road.m_TrafficFlowDistance0;
road.m_Flags = RoadFlags.None; // or appropriate enum value

// Serializing (pseudo-code; concrete writer comes from game's serialization API)
IWriter writer = /* obtain writer from game's serialization context */;
road.Serialize(writer);

// Deserializing (pseudo-code; concrete reader comes from game's serialization API)
IReader reader = /* obtain reader from game's deserialization context */;
var readRoad = new Road();
readRoad.Deserialize(reader);
// readRoad now contains the deserialized and version-adjusted values

Notes and implementation tips: - The component is designed for use with Unity's DOTS/ECS (IComponentData). Access and modification are normally done via systems (IJobForEach, Entities.ForEach, or EntityManager APIs). - The float4 fields are likely a packed representation for up to 4 lanes/segments; treat component fields as batch data rather than per-lane individual objects. - The Deserialize method contains explicit version checks (Version.netInfoviewImprovements, Version.trafficFlowFixes, Version.roadFlags). When writing migration or compatibility code in mods, be mindful of these version gates to keep save/load compatibility. - RoadFlags is persisted as a single byte — ensure your custom flags (if extending via mod) are compatible with storage expectations.