Vehicle Driving Simulator [Claude Code]

ooki — Mon, 19 Oct 2026 08:18:20 GMT

I made a GDL object that drives a truck-mounted crane, a dump truck or a lorry along a route in the Archicad 3D window and marks every place where the vehicle would touch the model. One button in the Tapir palette checks the route and saves an MP4 that I can show at the site meeting.

What the video shows

One route object per vehicle plan. The departure is where the object is placed; the arrival flag and the route vertices are hotspots that I drag in plan or in 3D. Corners are rounded automatically.
"Judge and drive" checks the whole route against the model first, then the vehicle drives it in the 3D window. Red = contact, orange = closer than 25 cm, purple = tighter than the vehicle can turn. The elements that are hit are highlighted.
Swept-path lines (four corners, inner rear wheel, mirror tips) and a swept-path drawing (vehicle outline at intervals, axle dimensions, turning centres) are drawn in plan and on the ground in 3D, growing as the vehicle moves.
The video is recorded automatically. I can orbit the 3D view while the vehicle drives, and the video records exactly what I see.

1. Environment: Archicad 30 + MCP + Tapir

Archicad 30 (JPN 30.0.0.3001) on Windows.
The built-in Archicad MCP server (Desktop AI Tool Connection) and the open-source Tapir add-on with its own MCP server. Tapir extends the Archicad JSON API with more than 250 commands. Both are connected to Claude Code (Anthropic's AI coding agent) on the same PC.
Division of work: I described what I wanted, tried every version in Archicad and gave feedback (several rounds over four days). The AI agent read the model and the command schemas through MCP, wrote the GDL generator, the Python scripts and the tests, and checked its own results in the running Archicad.
No AI is needed to use the tool. The palette buttons run Python scripts that call the Archicad JSON API (localhost) with commands from the public Tapir release.

Development:  Claude Code ⇄ MCP (Archicad official / Tapir) ⇄ Archicad JSON API ⇄ model
Daily use:    Tapir palette button → Python script → JSON API + Tapir commands → model
                                                   → 3D window capture → MP4 on the desktop

2. The GDL object

Vehicles and route

7 vehicle types built from manufacturers' spec sheets and a rental catalogue: truck-mounted cranes 2–3 t, 4 t and 10 t (8×4), lorries 4 t and 10 t, dump trucks 4 t and 10 t. Wheelbase, overhangs, width, height, minimum turning radius and twin front axles are in a table compiled into the object; estimated values are flagged in the caption.
The route line is the centre of the front axle. The minimum route radius is derived from the minimum turning radius (outer front wheel), and the rear follows the front-axle-centre path.
A guard in the parameter script stops a vertex drag at the point where a corner would become tighter than the selected vehicle can turn, so an impossible route cannot be drawn.

Results are stored in the object

After judging, the poses are written into array parameters every 5 cm: [x, y, heading, steering angle, state, parts hit], together with the contact markers and ranges.
Playback changes a single parameter (the position along the route), so every animation frame is one SetGDLParametersOfElements call. The plan drawing can be printed as it is.

2D and 3D scripts

2D: route, swept-path lines coloured by result, swept-path drawing (front edge red, rear edge cyan, sides blue, dimension chain through every axle, turning centres). Texts stay readable for any placement angle, mirroring and plan rotation (SYMB_ROTANGLE, SYMB_MIRRORED, REQUEST("View_Rotangle")), and spacing follows the drawing scale.
3D: a light but recognisable body (cab, crane, deck or dump body, wheels) from the spec dimensions, plus thin strips on the ground for the traces.
The GDL is generated by a Python script and built with LP_XMLConverter. Each build runs about 130 checkall variants and compares what the scripts draw (PRINT dumps) with expected geometry computed in Python.

3. Tapir scripts (palette buttons)

Button	What it does
Judge and drive	Recalculate the path for the current route and vehicle, check collisions, drive and record
Play and record	Drive the last result again and record the 3D view as you move it
Smooth recording	Record frame by frame at a constant speed
Clear results	Remove highlights and baked results, keep the route and the vehicle

How the collision check works

Python computes the path. The check itself uses Archicad's own collision detection (GetCollisions) against walls, columns, beams, slabs and objects.
A hidden copy of the route object is placed for the check, so the visible vehicle never changes shape. The copy is moved every 0.45 m with the body inflated by 25 cm; only the zones that come close are checked again every 0.1 m at true size.
Example: a 75.8 m route with 18 nearby elements takes 170 collision calls, about 25 seconds.

Main commands: GetCollisions, CreateObjects / DeleteElements (the hidden copy), SetGDLParametersOfElements / GetGDLParametersOfElements, HighlightElements, ChangeSelectionOfElements, ChangeWindow / GetCurrentWindowType, AddFilesToEmbeddedLibrary (replaces the object when the GDL changes), GetPenTables (picks plan pens close to the intended colours).

Moving the vehicle is one call:

{"command": "API.ExecuteAddOnCommand",
 "parameters": {
   "addOnCommandId": {"commandNamespace": "TapirCommand",
                      "commandName": "SetGDLParametersOfElements"},
   "addOnCommandParameters": {"elementsWithGDLParameters": [
     {"elementId": {"guid": "<route object>"},
      "gdlParameters": [{"name": "vr_s", "value": 412}]}]}}}

4. Automatic video

The script captures the 3D view window directly (Windows screen copy), adds the title, distance, events and legend with Pillow, and encodes H.264 MP4 with ffmpeg.
Live mode records at 25 fps from a separate thread while the vehicle drives. While I orbit the view, the vehicle waits and the recording continues.
Smooth mode writes the position, captures, and repeats: 0.2 m per frame, so the speed is constant no matter how fast Archicad redraws.
Things I had to handle: the selection highlight shows in 3D (Archicad 30 keeps a separate selection per window, so I deselect after bringing the 3D window to the front); the 3D window shows the floor plan when another tab is in front, so a frame is written only after GetCurrentWindowType confirms the 3D tab. If I switch tabs during recording, the vehicle and the recording pause and continue from the last confirmed frame.

Status and limits

Prototype on a study model. Some vehicle values are estimated (mirrors, crane height). Forward driving only; mobile cranes and trailers are not included yet.
The tool is used inside our company and is not distributed, but I am happy to discuss the approach.

Questions

How do you check vehicle access today: 2D swept-path drawings, separate software, or inside Archicad?
Which vehicles or situations would you check first (concrete pumps, trailers, reversing)?
For Graphisoft: a collision check that accepts a transformation without moving an element would make this kind of check much faster.

Archicad and AI (Claude Code) work very well together. A large part of the work that I used to enter and verify by hand can now be eliminated. I plan to keep posting things that I hope will be useful to you!

topic Vehicle Driving Simulator [Claude Code] in AI solutions