Skip to main content

Terminology

This page describes the most commonly used terms when working with Unity and the simulator.

Game Object​

A GameObject is the fundamental object type in Unity that represents every entity in a Scene. GameObjects act as containers for Components, which define the object's appearance, behavior, and physical properties. On their own, GameObjects have no functionality — their behavior is determined entirely by the Components attached to them.

In the simulator, GameObjects represent all agents and environmental elements in a mobility scenario, such as pedestrian NPCs, micromobility vehicles, cars, and static props like benches or traffic signals.

Component​

A Component is a modular unit of behavior or data attached to a GameObject. Each Component defines a specific aspect of how its parent GameObject functions, such as how it moves, how it appears, or how it responds to other objects in the Scene. A single GameObject can hold multiple Components, and the combination of those Components determines the object's overall behavior.

In the simulator, Components control agent movement, sensor logic, interaction detection, and data collection on simulation objects.

Prefab​

A Prefab is a reusable asset that stores a configured GameObject — including its Components and property values — as a template. Prefabs allow the same GameObject configuration to be instantiated multiple times across one or more Scenes without needing to be rebuilt each time. Changes made to a Prefab asset propagate to all instances of that Prefab in the project, unless an instance has been individually overridden.

In the simulator, Prefabs are used for simulation agents such as delivery robots, pedestrians, and vehicles, ensuring each agent type maintains a consistent configuration across scenarios.

See also: Game Object, Scene

Scriptable Object​

A ScriptableObject is a data container that exists in the project as an asset, independent of any Scene or GameObject. ScriptableObjects store shared data that any GameObject can access at runtime, which reduces memory usage by avoiding redundant copies of the same values across multiple instances.

In the simulator, ScriptableObjects are used to define shared configuration data for simulation elements such as survey templates and scenario parameters.

See also: Scriptable Variable

Scriptable Variable​

A Scriptable Variable is a ScriptableObject that stores a single typed value — such as a string, integer, float, or boolean — as a project-level asset. Because the value exists as an asset rather than within a specific GameObject, multiple objects across different Scenes can read from and write to the same variable without direct references to each other. This decouples data sharing from scene hierarchy dependencies.

See also: Scriptable Object

mTurkID​

An mTurkID (stored as the session's ParticipantID) is the participant's crowdsourcing worker ID, such as an Amazon Mechanical Turk or Prolific ID. This value is used to link collected simulation data back to the participant's records in any external survey or study platform. In WebGL deployments it is read from the study URL's search query parameter (for example ?search=ABC123) when the session starts; otherwise the fallback value configured in Edit > Project Settings > mobisim > Server Authorization is used. It persists for the duration of the session and is included in the names of exported data files (mTkID<id>_subID<id>_...).

See also: Subject ID, Data Logging

Subject ID​

A Subject ID is a numeric identifier assigned to a participant by the study server. At session start the simulator posts the mTurkID to the configured server, which responds with the Subject ID. If no server connection is configured, the fallback Subject ID from Edit > Project Settings > mobisim > Server Authorization is used; in the Editor and Windows standalone builds it can also be overridden with the --subjectID N command-line argument. The Subject ID is the key used to merge simulator data with offline survey data.

See also: mTurkID, Data Logging

Scene​

A Scene in Unity is a discrete environment that contains all the GameObjects, assets, lighting, and configuration for a single context within the project. Scenes can represent different spaces, states, or stages of an application and are loaded individually or additively at runtime.

In the simulator, a Scene represents a specific mobility environment — such as an urban street intersection — in which an interaction scenario takes place. Scene structure and transitions are managed through the Scene Network Graph.

See also: Scene Map, Scene Template, Scene Network Graph

Scene Map​

A Scene Map defines the spatial layout and navigable structure of a simulation environment. It specifies the physical arrangement of environmental elements such as roads, crossings, sidewalks, and obstacles that agents and vehicles interact with during a simulation session.

See also: Scene, Scene Template

Scene Template​

A Scene Template is a predefined configuration used as a starting point for building a new Scene. It packages a set of base GameObjects, settings, and layout conventions so that new Scenes begin from a consistent and project-appropriate state rather than from an empty Unity default.

In the simulator, Scene Templates establish the baseline environment setup required for a mobility interaction scenario, including standard lighting, ground geometry, and required manager objects.

See also: Scene, Scene Map

Survey​

A Survey is a structured questionnaire presented to a study participant before, during, or after a simulation session. A survey can include a variety of input types such as radio buttons, sliders, text fields, and rating tables, and may include embedded attention checks to validate participant engagement.

See also: Survey Data, Attention Check, Survey

Survey Data​

Survey Data refers to the participant responses collected through a Survey session. This data is recorded per-participant and per-session, associated with the relevant Subject ID and mTurkID, and written to the data logging system for later analysis.

See also: Survey, Data Logging, Subject ID

Data Logging​

Data Logging is the process by which the simulator records participant and simulation data during a session. Logged data may include participant responses, agent positions, interaction events, and timestamps. All data is associated with the active session's participant identifiers and written to the configured output destination.

See also: Survey Data, Subject ID, mTurkID

Addressable​

An Addressable is an asset managed through Unity's Addressable Asset System. Rather than being directly referenced in a Scene, an Addressable asset is assigned a string address and loaded at runtime on demand. This allows large assets to be loaded and unloaded efficiently without requiring them to be present in memory for the full duration of a session.

In the simulator, Addressables are used to manage Scene and environment assets during build and deployment, enabling the project to load simulation environments dynamically.

See also: Scene, Building the Application

Scene Network Graph​

A Scene Network Graph is a graph-based structure that defines the flow and transition logic between Scenes in the simulator. It specifies which Scenes are available, the order in which they can be visited, and the conditions that determine how the simulator moves from one Scene to the next. This allows non-linear or branching scenario flows to be configured without modifying code.

See also: Scene, Scene Template

Editor​

The Unity Editor is the authoring environment used to build, configure, and test the simulator project. It provides a set of windows and panels — including the Scene view, Game view, Hierarchy, Project browser, and Inspector — through which developers and researchers construct simulation environments, configure GameObjects and Components, and manage project assets.

See also: Inspector

Inspector​

The Inspector is a window in the Unity Editor that displays the properties and Components of the currently selected GameObject or asset. Values shown in the Inspector can be read and modified directly, making it the primary interface for configuring simulation objects, Components, and project settings without writing code.

See also: Component, Editor