DOTS Traffic City

DOTS Traffic City is a powerful tool for creating city traffic - Design it from the ground up or customise any existing asset pack to fit your vision!

It uses the extremely powerful DOTS Entities package to simulate thousands of vehicles and pedestrians with unbelievable performance!

Seamlessly integrates into classic workflows: fully compatible with your standard MonoBehaviour and GameObject-based systems.

• Mobile friendly
  Simulate thousands of interacting vehicles and pedestrians, even on mobile devices.
• Performance
  Experience the performance firsthand in our various platform-specific demo projects or just check out the final screenshots to see the results.
• Rapid integrationIntegrate any city asset pack in a heartbeat with our convenient templates and tools.
• SimulationSimulate thousands of entities without relying on physics or raycasting (physics-based simulation is also available).
• Monobehaviour support
  Not familiar with DOTS? No problem! The project is fully compatible with MonoBehaviour scripts in hybrid mono mode (check out the Hybrid Mono sample scene).
• EditorMany flexible tools to bring life to the city of your dreams.
• Demo
  GTA-like sample scene included!
• Sound
  Integration of the FMOD sound engine into bursted jobs (built-in Unity audio engine supported from v1.1.0).
• Documentation
  All components of DOTS Traffic City are linked to online documentation.
• Source codeAll code included.
• Pre-made templatesUse pre-built road templates to integrate some of your favourite cities (POLYGON City, City Pack, Toon City) with just one click.
• Vehicle controllerDOTS physics vehicle controller included!
• You can also use Edy's, RCC or NWH & other custom vehicle controllers for both player and traffic.
• Modular architecture
  Allows you to integrate the project into your existing game without hassles.
• Networking
  A new demo scene showcases a pure DOTS network solution based on Netcode for Entities. Mono traffic supports a universal abstract networking sample with integration examples for Netcode for GameObjects and FishNet.
• Runtime Road API
  New demo scenes show how to create a city builder based on tiles or custom splines (runtime splines can be used with Road Constructor).
• Train support
  You can either use a built-in solution or flexibly integrate a third-party controller for the train.
• Floating Origin
  Built-in Floating Origin system for DOTS & Mono with seamless hybrid synchronization for jitter-free massive maps. (new)
• A* navigation
  Set to follow a car or pedestrian to a given node using the built-in A* pathing or A* pathfinding project.

3rd-Party Integrations:

• EasyRoads3D.
• Road Constructor for editor & runtime.
• CityGen3D.
• MicroVerse Roads.
• Rukhanka Animation System pure & hybrid mono entities.
• Fantastic City Generator for editor & runtime.
• Agents Navigation.
• Animatron. (new)
• Aron’s A* pathfinding project. (point graph for traffic & pedestrian node navigation)

Key features:

🚗 Traffic

• Physics
  Vehicles can use either:
• Simple physics.
• Custom physics (custom physics controller included).
• Hybrid mono physics.
  Any monobehaviour controller can be integrated into the traffic.
• No physics.
• Trailers
  Support for vehicles with trailers (supported for both DOTS Entities and Hybrid Mono).
• Motorcycles & 3-Wheelers
  Support for two-wheeled bikes and three-wheeled vehicles (supported for Hybrid Mono mode only).
• Parking
  Customizable parking lines and parking areas.
• Speed controlAutomatic vehicle speed control depending on lane speed limit, traffic lights and other traffic.
• Lane changingAutomatic vehicle lane changing based on traffic congestion or road type, including overtaking via the oncoming lane when safe and permitted.
• Traffic groupsRestrict lanes to certain traffic group types.
• Public transport
  Vehicles that can either only move on predefined roads (such as trams or cable cars) or randomly throughout the city and can pick up pedestrians at stations and stops.
• Fast creationQuick and easy tool for adding any vehicle into the city.
• AvoidanceVehicle-to-vehicle collision prevention and bypassing of player or custom obstacles.
• Driving stylesThere are different types of driving styles on the road: considerate, passive, and aggressive. (new)
• PriorityVehicles pass through the intersections according to road priority.
• Emergency vehiclesSupport for AI and player-controlled priority vehicles (police, ambulances, etc.) with dynamic traffic avoidance (yielding, pulling over, lane changing).
• AntistuckAn Antistuck system that automatically despawns the entity if it gets stuck for a while and isn't visible in the player's camera.
• Traffic JamsGridlock prevention: Vehicles hold before intersections if the exit lane is blocked.
• Custom PathAllows vehicles to navigate directly to target nodes via A* pathing.
• Left-hand traffic
  Starting with version 1.1.0, driving on the left is available.
• CullingVehicles only spawn around the player.
• Combined physicsLimit physics to only the vehicles closest to the player in order to improve performance.
• LODsLOD system for the vehicles depending on the distance to the camera.
• TestsA handy traffic test scene where most traffic situations can be tested with all available parameters.
• Damage
  Health & damage system example included.

🚶Pedestrians

• Rig type:
• Legacy pedestrianHybrid entities using the Unity Mecanim Animator.
• Pure GPU
  Pure entities that are animated by the GPU. May be useful for extreme amounts of entities.
• Hybrid and GPU
  This mode lets you mix Hybrid Animator models for near and GPU animation for far at the same time, with seamless transitions.
• Hybrid On Request And GPU
  By default, the entity is animated by the GPU until a Hybrid skin is requested.
• Hybrid Shape GPU
  Hybrid entity animated on GPU in DOTS & has hybrid monobehaviour collider to interact with pedestrians in a familiar way.
• Rukhanka
  Pure entities animated with Rukhanka Animation System in DOTS.
• Rukhanka Hybrid
  Hybrid entities animated with Rukhanka Animation System with hybrid monobehaviour collider & rigidbody to control or interact with pedestrians in a familiar way.
• Animatron
  Pure entities animated with Animatron in DOTS. (new)
• Animatron Hybrid
  Hybrid entities animated with Animatron with hybrid monobehaviour collider & rigidbody to control or interact with pedestrians in a familiar way. (new)
• Simulation type:
• PhysicsAll pedestrians have a physics collider.
• No physicsPedestrians don't have physics colliders, all interactions and collisions are calculated by custom jobs.
• BehaviourMultiple pedestrian behaviours such as idle, walking, running, talking and sitting.
• Custom / External ControlPedestrians can be temporarily disabled from the simulation system to be fully controlled by custom user scripts.
• Runtime Custom NPCsSeamlessly integrate user-spawned GameObjects/NPCs with full control toggling between custom scripts and DOTS simulation.
• Navigation:
• Local avoidanceSimple lightweight method for avoiding vehicles.
• Simple NavMesh
  Basic Unity NavMesh API pathfinding through poly-nodes.
• Crowd avoidance
  Lightweight predictive steering and OBB vehicle bypassing with smart contour sliding and static obstacle detection for high-density crowd simulation [beta].
• Crowd avoidance NavMesh
  Hybrid avoidance combining OBB logic with NavMesh boundary raycasts, edge sliding, and ground Y-height snapping [beta].
• Agents Navigation
  3rd party navigation package for high quality pedestrian crowd simulation.
• Node FilteringRestrict pedestrian spawning and node navigation to specific group types.
• CullingPedestrians will only spawn around the player.
• Culling stateOnly pedestrians in the player's line of sight are fully active.
• RagdollRagdolling is currently only supported with default colliders (or with Rukhanka in DOTS).
• Custom PathAllows pedestrians to navigate directly to target nodes via A* pathing.
• Event triggeringEvent impact on pedestrians by area.
• TestsPedestrian test scene where entity behavior can be tested.

🏙️ City

• Traffic roadMultiple road templates and custom road customization tools.
• Road APIGenerate road segments from raw data or unity splines.
• Auto-crossroad generationNew option to create crossroads with a single click.
• Parking builderA tool for creating parking lines or parking areas of any complexity.
• StreamingCreate infinite cities by dividing 3D assets and road entities into chunks for streaming at runtime (pure DOTS only).
• CullingAll entities in the city change their behaviour depending on the culling state (including traffic and pedestrians).
• Physics cullingOnly the physics objects close to the player are involved in the physics evaluation.
• Traffic lightQuick and easy creation of traffic lights with an automatic tool to connect all traffic lights in the scene.
• DebugConvenient visualisation of data on scene.

🎮 Demo Scenes (29 total+)

• Demo & HybridGTA-like sample scenes running in pure DOTS or Hybrid Mono mode.
• Traffic Demo
  A large-map sample scene dedicated exclusively to traffic simulation.
• Runtime Generation
  Scenes showing tile/spline city building, custom road creation from raw data, and runtime chunk/road loading.
• Netcode Scenes
  Demo scenes demonstrating network sync support for both pure DOTS and Hybrid Mono simulations.
• Integration Demos
  Examples for 3rd-party train integration and custom setups.
• Stress Test Scenes
  Dedicated benchmark scenes for testing limits with thousands of vehicles, pedestrians, animations, and vehicle physics.

For more information about the scenes, read the Project Scenes.

Tutorial Playlist

Demo

Windows | Android

To get started

Tutorial | Documentation

Contact me

Discord | Email

Read the Limitations in the Technical Details section.

Third-party usage:

Projects:

• Reese's path demo fork under the MIT license
• Extenject (upm version) under the MIT license
• UGizmo under the MIT license
• Custom Physics Authoring

Please read Third-Party Notices.txt for more information