Results for “simulator”

Reads and summarises ScenarioRunner output — the criteria pass/fail tables from --output/--file, the machine-readable --json and --junit result files, and the criteria JSON written alongside a --record recording — and runs the metrics module (metrics_manager.py) to compute custom measurements over a recorded run offline, without the simulator. Use when the user asks "did the scenario pass", "why did it fail", "summarise these results", "compare these runs", or wants distance/speed/lane metrics from a recording.

The English summary is being prepared. Showing the original description.

Use XcodeBuildMCP to build, run, launch, and debug the current iOS project on a booted simulator. Trigger when asked to run an iOS app, interact with the simulator UI, inspect on-screen state, capture logs/console output, or diagnose runtime behavior using XcodeBuildMCP tools.

The English summary is being prepared. Showing the original description.

Build and optimize quantum circuits with PennyLane, including models that combine quantum circuits with PyTorch or JAX. Explore molecular energy estimation and optimization problems, validate values and gradients in simulation, and prepare tested circuits for provider plugins.

• Check quantum circuit values and gradients in simulation
• Train hybrid quantum and PyTorch or JAX models
• Estimate molecular energies with VQE

Review a marketing plan by clarifying the customer, their need, and the product’s positioning. Examine acquisition channels, customer acquisition costs, and payback periods, then produce a verdict and three concrete next steps.

• Reviewing a campaign before launch
• Revising positioning or a tagline
• Assessing spending on a new acquisition channel

Create and validate SRDF files that define how MoveIt2 plans robot motion. Check planning groups, named poses, end effectors, and collision exclusions against an existing URDF robot model, then review the model visually.

• Define planning groups for a robot arm
• Check named poses and joint limits
• Review collision exclusion settings

Fill documentation gaps identified by a CARLA documentation audit, following the project's writing style. Work through one category at a time, assess which findings deserve entries, update source files, and report changes and skipped findings.

• Add missing Python API documentation
• Expand sensor reference documentation
• Review outdated API entries for renaming or removal

Check which CARLA features are missing on UE 5.5 compared with UE 5.8. Read source markers to identify the checkout, review unsupported workflows, and see which UE 5.8 procedures also apply.

• Checking whether Autoware can be used on UE 5.5
• Reviewing ROS 2 middleware restrictions
• Investigating a black screen when loading Town12

Create, migrate, refine, or debug CARLA vehicle assets with Blender and Unreal. Use real vehicle references to guide geometry and materials, configure wheels, lights, and physics, and deliver editable sources with evidence from runtime validation.

• Creating a CARLA vehicle from real vehicle references
• Refining tires, materials, or body geometry
• Migrating vehicles and debugging Unreal integration

Import FBX 3D models into CARLA on UE 5.8 and register them as props that can be placed in a simulation. Check measured dimensions, adjust scale, verify placement on a running server, and undo imports when needed.

• Add a custom bench or object to CARLA
• Fix imported props missing from the blueprint library
• Import a folder of props organized by tag

Package a CARLA server built with UE 5.8 for distribution, choosing which maps to include. Inspect the resulting files for mismatched containers, missing road data, and exposure settings that can cause runtime failures.

• Packaging a CARLA server with selected maps
• Investigating a black screen in a packaged server
• Checking road data and package consistency

Prepare and launch Autoware with CARLA on UE 5.8 through its native ROS 2 interface. Check communication topics and sensors, generate required maps, and configure either the classical stack or camera-only VAD model.

• Check whether a CARLA build supports Autoware
• Inspect topics exchanged between CARLA and Autoware
• Generate lanelet2 and point-cloud maps for a town

Import a custom pedestrian into CARLA on UE 5.8, connect it to the shared animation skeleton, and verify that it moves. Export an existing walker as an FBX starting point or investigate a walker that stands still.

• Add a custom pedestrian to CARLA
• Export an existing walker as an FBX for editing
• Investigate a walker that spawns but does not move

Guides custom map imports into CARLA on UE 5.8, from FBX geometry and OpenDRIVE road data to packaging or temporary road generation. Helps choose a supported route and verify map files and loading.

• Testing a road network from an OpenDRIVE file
• Importing a town with buildings into the editor
• Including a custom map in a server package

Build CARLA for Unreal Engine 5.8 using CMake, the tool that configures its build process. The skill guides engine setup, optional ROS 2 support, Python API rebuilding, editor builds, and checks that the expected files were actually produced.

• Building CARLA for Unreal Engine 5.8
• Building and verifying native ROS 2 support
• Rebuilding the Python API after client changes

Add pedestrians to a CARLA map and let them walk autonomously. Adjust crowd size, walking speed, road-crossing frequency, and placement seeds, create stationary crowds, and remove pedestrians together with their movement controllers in the correct order.

• Adding pedestrians who walk around a map
• Reusing pedestrian placement with a fixed seed
• Adjusting walking speeds and road crossings

Package a CARLA Leaderboard agent into a Docker image for submission. It checks required directories and Python package files, supports ROS variants, and verifies that dependencies import and the agent loads inside the image.

• Build a Docker image for Leaderboard submission
• Investigate missing egg files in make_docker.sh
• Package a ROS agent with its bridge

Explore roads, lanes, and junctions in a CARLA simulation map through text reports and visual overlays. Locate places described in everyday language, inspect nearby lane details, and trace a path forward or backward along a lane.

• Understand a map's road and lane layout
• Compare the road network overlay with visible roads
• Locate the four-way junction nearest the map center

Read and change a running CARLA server’s timing, physics substeps, and rendering settings. Switch between client-controlled steps and automatic progression, keep Traffic Manager synchronization aligned, and read back the settings to verify each change.

• Setting a fixed simulation rate for sensor capture
• Keeping Traffic Manager aligned with synchronous mode
• Disabling rendering or adjusting physics substeps

Validate CARLA pedestrian navigation by sampling walkable locations and reporting their coverage. Draw the samples as debug points to inspect the walkable area after a map import or investigate pedestrians that will not move.

• Checking pedestrian navigation after importing a map
• Investigating pedestrians that stand still
• Visualizing the area pedestrians can walk through

Install Scenic, a language for describing scenarios with randomized conditions, into the Python environment used by CARLA. Check command-line tools and version compatibility, optionally download example scenarios and map assets, and save the installation paths.

• Preparing Scenic to work with CARLA
• Diagnosing scenario model import failures
• Checking missing vehicle definition tables

Populate a running CARLA simulation with autonomous traffic, evenly spaced vehicles in one lane, or a single vehicle for control and sensors. Filter vehicle models, keep automated driving active, and remove vehicles when the scene is finished.

• Fill a map with autonomous traffic
• Place vehicles at fixed intervals in one lane
• Create an ego vehicle for control and sensors

Read existing CARLA sensors to view live camera or lidar output, save recordings, or inspect a single reading. Display multiple sensors together and check ROS 2 topic names, delivery settings, and whether publishing is enabled.

• View a vehicle camera feed live
• Save camera images or lidar data for a fixed duration
• Inspect a GNSS sensor reading

Draws points, lines, arrows, boxes, and text over a running CARLA world to visually check positions, paths, and objects. Sets colors and display lifetimes for temporary debugging overlays, without creating persistent actors or output files.

• Marking a world position for inspection
• Visualizing paths and waypoints
• Adding a box and label around a target

Import a four-wheel FBX vehicle into a CARLA source build, configure its physics, wheels, and animation, and register it for the Python API. Verify that the resulting vehicle can spawn, drive, and steer.

• Importing a custom van or truck into CARLA
• Registering a vehicle for spawning through the Python API
• Checking why an imported vehicle will not drive or steer