openTCS: Change Log

Avoid `NullPointerException`s when rerouting vehicles that process transport orders containing drive order steps that don’t have a path.

Avoid ObjectUnknownException by cleaning orders related to order sequences only once.

Correctly claim resources for transport orders with multiple drive orders. This fixes an issue where allocating the first set of resources for the second drive order in a transport order would fail.

Allow persistence of plant models (to a file and to the kernel) with paths that contain both vehicle envelopes and peripheral operations.

Update Gradle wrapper to 8.7.

Use more sensible defaults for newly created vehicles' recharge energy level threshold values.

Add proper support for recalculating the length of "2-Bezier", "3-Bezier" and "Poly-Path" paths to the Model Editor.

Add support for defining vehicle envelopes at points and paths to the Model Editor.

Make vehicle resource management configurable. For more details, see the documentation of the KernelApplicationConfiguration.vehicleResourceManagementType configuration entry.

When computing a route / costs of a route not related to a transport order, it is now possible to define a set of resources (i.e., points, paths or locations) that should be avoided by vehicles.

Update web API specification and implementation to version 1.6.0:

When referencing paths via the tcs:resourcesToAvoid property in transport orders, don’t implicitly avoid their start and end points, as points can have multiple incoming and outgoing paths.

Don’t create the same peripheral job a second time if the vehicle that triggered the job was rerouted before the job was completed.

Adjust the names of some methods in VehicleProcessModel and VehicleProcessModelTO by removing the redundant "Vehicle" prefix.

Improve performance of updates to the router’s routing topology by allowing it to be updated selectively. (The routing topology can now be updated only for paths that have actually changed.)

When computing a route for a transport order, it is now possible to define a set of resources (i.e., points, paths or locations) that should be avoided by vehicles processing the respective transport order. For this, a property with the key tcs:resourcesToAvoid can be set on a transport order to a comma-separated list of resource names.

The creation of ambiguous peripheral jobs (by kernel clients or via the web API) that have the completionRequired flag set to true is now prevented. (In those cases it is unclear what should happen to the job’s relatedTransportOrder (if any) in case the job fails.)

Add a watchdog task to the kernel which periodically monitors the state of blocks in the plant model and publishes a user notification in case a block is occupied by more than one vehicle. (Such a situation is usually caused by manually moving vehicles around and leads to deadlock situations.)

Update web API specification and implementation to version 1.5.0:

Correctly read configuration entries in the <KEY_1>=<VALUE_1>,…​,<KEY_N>=<VALUE_N> format when using gestalt as the configuration provider.

Provide related TransportOrder and DriveOrder objects as part of every MovementCommand. This way, vehicle drivers can easily look up a movement command’s context without having to explicitly fetch the data via a kernel service call.

Update Mockito to 5.11.0.

Update ApprovalTests to 23.0.0.

Update Jackson to 2.17.0.

Update Gradle license report plugin to 2.6.

Improve handling of failed peripheral jobs (where the completion required flag is set to true) associated with a transport order and withdraw the respective transport order in such cases.

Properly implement simulation of a recharging operation in the virtual vehicle driver.

Add an alternative implementation for reading application configuration from properties files using the gestalt library. This implementation is intended to replace the one using the cfg4j library and is now used by default by the openTCS Kernel, Kernel Control Center, Model Editor and Operations Desk applications. (Note that, until openTCS 6, the cgf4j implementation can still be used by setting a system property. For more details, refer to the developer’s guide.)

Improve resource management on vehicle movement: When a vehicle moves to a new position without having been ordered to move anywhere, allocating and freeing resources is now properly handled.

Update web API specification and implementation to version 1.4.0:

Immediately assigning a transport order to a vehicle in the Operations Desk application now works correctly.

The loopback adapter now properly resumes operation when switching from single step mode to automatic mode.

Properly set layout coordinates when creating a location on the x or y axis.

Deprecate MovementCommand.isWithoutOperation() and introduce MovementCommand.hasEmptyOperation() as a replacement.

Keep track of a vehicle’s drive order route progress in the corresponding transport order the vehicle is processing. Deprecate Vehicle.getRouteProgressIndex() because tracking this in the transport order is more consistent. (Progress in the drive orders list is also tracked in the transport order.)

Update JUnit to 5.10.2.

Update JUnit platform launcher to 1.10.2.

Update ApprovalTests to 22.3.3.

Update Mockito to 5.10.0.

Update AssertJ to 3.25.3.

Update Jackson to 2.16.1.

Update JAXB Runtime to 2.3.9.

Update Gradle wrapper to 8.6.

Move/Rename a couple of kernel configuration entries:

Eliminate use of Java’s SecurityManager from the code. It hasn’t been necessary for quite a while, and does not exist any more with Java 21.

The default strategies for parking and (re)charging vehicles now create transport orders only for vehicles that are actually allowed to process them (according to the respective vehicle’s allowed order types).

In the Operations Desk application, show the vehicle that is allocating a resource in the tooltips of points, paths and locations.

In the Operations Desk application, only offer locations as transport order destinations that are actually linked to at least one point and that have allowed operations.

In the Operations Desk application, if a vehicle’s transport order is withdrawn regularly (i.e. while allowing the vehicle to finish its movements), only the allocated resources in front of the vehicle are highlighted in grey, while the allocated resources behind the vehicle remain highlighted in the vehicle’s route color.

As with transport orders, the event history of order sequences is now also filled with relevant event data.

The load generator plugin now avoids unsuitable locations when generating orders. For example, locations without a link are considered unsuitable, which usually includes locations representing peripheral devices.

When retrieving a plant model’s visual layout via the web API, its properties are now also provided properly. Previously, a visual layout’s properties would always be empty.

Revamp management of MovementCommand queues in BasicVehicleCommAdapter.

For transport orders created by the default strategies for parking and (re)charging vehicles, corresponding transport order types of "Park" and "Charge" are now set.

Add support for vehicle envelopes. In an openTCS plant model, envelopes can now be defined for points and paths a vehicle occupies or traverses. For vehicles, an envelope key can be defined to indicate which envelopes defined at points and paths should be considered for the respective vehicle. This way, it is now possible to prevent vehicles from allocating physical areas intersecting with areas already allocated by other vehicles. (Note that the Model Editor application does not provide any means to set envelopes, yet. At this point, envelopes can only be input programmatically, i.e. via the Java or web API.)

Update web API specification and implementation to version 1.3.0:

When updating the vehicle’s prospective next position, actually consider its future movement commands.

Actually use a vehicle’s preferred recharge location if it is defined.

When rerouting vehicles, properly consider that movement commands are not created for report points along a vehicle’s route.

Allow communication adapters to request transport order withdrawals and integration level updates via VehicleProcessModel.

Update Gradle wrapper to 8.4.

Update Jackson to 2.15.3.

Update Mockito to 5.6.0.

Update ApprovalTests to 22.2.0.

Update Checkstyle to 10.12.4.

Visualize a vehicle’s currently allocated resources and the claimed resource of its current drive order in the Operations Desk instead of just the route of its current drive order.

User notifications are now shown in a table in the Operations Desk.

Make peripheral adapters selectable in the Kernel Control Center.

Allow setting the intended vehicle on a transport order through the transport order service or the web API as long as the transport order has not been assigned to a vehicle, yet.

Add support for immediate assignment of a transport order to its intended vehicle through the dispatcher service. For more details, see the new "Immediate transport order assignment" section in the user’s guide.

Add support for route computation to the router service.

Update web API specification and implementation to version 1.2.0:

Remove the kernel messages panel from the Operations Desk; it has been superseded by the user notifications tab.

Add a configuration entry for enabling/disabling forced withdrawals from the Operations Desk.

Add a menu item for recalculating the lengths of paths (for now, simply based on the Euclidean distance between the start and end point) to the Model Editor.

Show peripheral jobs that a vehicle must wait for before it can continue in the vehicle’s tooltip.

In the User’s Guide, document for every configuration entry when changes to it are applied by the respective application.

Properly check validity of destination operations when creating transport orders.

Improve legibility of some text elements in the Model Editor and Operations Desk applications that would not be legible on some systems (e.g. Ubuntu 20.04).

Ensure the Model Editor application is still operable when resetting the window arrangement while a model element is selected.

When a peripheral job is reported as finished or failed via PeripheralJobCallback, ensure that it is properly marked as such, which was previously not the case in some situations.

Avoid a NullPointerException when resetting a vehicle’s position while it is in integration level TO_BE_NOTICED.

Ensure that order reservations for vehicles are properly cleared in case a vehicle’s integration level is changed to anything other than TO_BE_UTILIZED.

Show a vehicle’s destination in the vehicles panel in the Operations Desk application in cases where the vehicle is processing a transport order with a destination location.

Show the correct title in the order sequence details panel in the Operations Desk application.

Properly handle resources for withdrawn orders, fixing an issue where a vehicle would still wait for a pending resource allocation with the transport order remaining in state WITHDRAWN.

Properly handle situations in which vehicles are rerouted more than once during a single drive order, fixing an issue where routes would otherwise not be considered continuous.

Actually accept priority key DEADLINE_AT_RISK_FIRST in the default dispatcher’s configuration entries.

Removed documentation for server side web API errors (code 500).

Introduce data structure Pose in the Java API, and use it to replace and deprecate the previously separate position and orientation angle members in Point and PointCreationTO.

Integrate Gradle license report plugin.

Update Gradle wrapper to 8.3.

Update Jackson to 2.15.2.

Update JAXB Runtime to 2.3.8.

Update JGraphT to 1.5.2.

Update JUnit to 5.10.0.

Update Mockito to 5.5.0.

Update ApprovalTests to 19.0.0.

Update Checkstyle to 10.12.3.

Update JaCoCo log plugin to 3.1.0.

The peripheral jobs panel in the Operations Desk application will now always be shown. The option to enable or disable it via the configuration file has been removed.

Rename peripheral operation execution trigger BEFORE_MOVEMENT to AFTER_ALLOCATION, as this name reflects better when the operation is actually triggered. The previous name is deprecated but may still be used; it will implicitly be converted to the new name.

Sync points' layout and model coordinates in the demo plant model.

Adjust resource management and let a vehicle claim and allocate the destination location(s) of its transport order in addition to points and paths along its route.

Make use of the vehicle’s length for resources management:

Add support for working with order sequences via the web API.

Add support for updating and retrieving a vehicle’s allowed order types via the web API.

Add support for managing peripherals via the web API:

Provide information about available communication adapters for peripheral devices in the Java API.

Add a detail panel for peripheral jobs to the Operations Desk.

Add property and history information to the order sequence detail panel in the Operations Desk.

When publishing new user notifications and the number of notifications exceeds the kernel’s capacity, keep the youngest ones, not the oldest ones.

Update Gradle wrapper to 7.6.1.

Update License Gradle Plugin to 0.16.1.

Update Gradle Swagger Generator Plugin to 2.19.2.

Update JUnit 5 to 5.9.3.

Update ApprovalTests to 18.6.0.

Deprecate SchedulerService.fetchSchedulerAllocations(), as allocations are now part of the Vehicle class.

Deprecate utility class Enums, as its methods can easily be implemented with Java streams these days.

Display properties of plant model elements, transport orders and peripheral jobs in the Model Editor and Operations Desk applications in lexicographically sorted order.

Remove a duplicate key from the OpenAPI specification.

Properly set the date for 5.8 in the changelog.

Add support for explicitly triggering rerouting of single vehicles, including optional forced rerouting from a vehicle’s current position even if it was not routed to that position by openTCS.

Add support for withdrawing/aborting peripheral jobs:

Add PlantModelService.getPlantModel(), which returns a representation of the complete plant model.

Extend web API:

Add support for adding additional peripheral job views in the Operations Desk application via the View menu.

Fix a bug where regularly withdrawing a transport order with peripheral jobs from a vehicle could prevent the withdrawal from being completed.

Fix a bug where forcibly withdrawing a transport order from a vehicle that is waiting for a peripheral job to finish would prevent any further commands (e.g. for new transport orders) to be sent to the vehicle.

Fix resource management for cases in which a vehicle’s transport order was withdrawn while the vehicle was waiting for a resource allocation.

Fix resource management / order processing for cases in which the plant model contains report points.

Fix a bug where the View  Reset window arrangement option in the Operations Desk application would not restore the peripheral job view.

Fix a bug in the GET /events web API endpoint where the type of individual events would not be included in the response.

Fix a bug where peripheral jobs in a final state (FINISHED or FAILED) would never be removed from the internal pool.

Fix a ClassCastException in the Operations Desk application that could happen when a vehicle figure was updated.

Fix a misnomer in the web API specification: There is no category in a transport order, it’s called a type.

Update JAXB Runtime to 2.3.7.

Update Jackson to 2.14.2.

Update JUnit 5 to 5.9.2.

Update AssertJ to 3.24.2.

Update Mockito to 4.11.0.

Update Gradle wrapper to 6.9.3.

Update Checkstyle to 10.7.0.

In the web API, set the content type for a reply to GET /vehicles/{NAME} to application/json as specified.

When creating peripheral jobs, copy all attributes of the respective peripheral operation, and set the related vehicle and transport order attributes, too.

Avoid redundant property updates from vehicle drivers.

Avoid using webfonts / Google Fonts API in Asciidoctor documentation.

Add support for working with peripheral jobs to the web API.

Split the kernel application’s defaultdispatcher.rerouteTrigger configuration entry into two separate entries: defaultdispatcher.rerouteOnTopologyChanges and defaultdispatcher.rerouteOnDriveOrderFinished.

Add explicit support for pausing vehicles, which would previously be implemented using messages sent to the vehicle drivers without being interpreted by the kernel. Vehicles now have a proper paused state, and VehicleService (and the Operations Desk application with it) provides an explicit way to modify it for each individual vehicle.

Defer resource allocations for paused vehicles. This keeps vehicles that do not explicitly support pausing from receiving more movement commands, effectively stopping them after they have processed the commands received before pausing.

Reflect vehicles' paused states in the web API and provide an endpoint to modify them.

Reflect vehicles' paused states in the operations desk by shading paused vehicles.

Fix a bug where adding peripheral operations to a (newly created) path would also affect other paths in a plant model.

Fix a bug with auto-attaching communication adapters to vehicles that have a preferred communication adapter configured. Only attach a preferred communication adapter to a vehicle, if the corresponding adapter factory can actually provide an adapter instance for it.

Update the demo model provided in the Model Editor application:

Update Spark to 2.9.4.

Update Jackson to 2.13.3.

Update AssertJ to 3.23.1.

Update Mockito to 4.6.1.

Inform EdgeEvaluator implementations about beginning and end of routing graph creation to allow them to optimize computations, e.g. by caching data that does not change while building the graph.

Add documentation for peripheral devices and peripheral operations. Also enable the respective GUI components by default now that there is documentation.

In the Operations Desk application’s dialog for creating peripheral jobs, offer locations attached to a peripheral driver only.

Replace old references to the Plant Overview application in the developer’s and user’s guides with references to the Model Editor and/or Operations Desk applications.

Remove the statistics kernel extension and plugin panel. They have been moved to the example integration project.

Update SLF4J to 1.7.36.

Update Guice to 5.1.0.

Update Jakarta XML Bind API to 2.3.3.

Update JAXB Runtime to 2.3.6.

Update Jackson to 2.13.2 (and its data-binding package to 2.13.2.2).

Update Sulky ULID to 8.3.0.

Update JGraphT to 1.5.1.

Update cfg4j to 4.4.1.

Update JSR305 to 3.0.2.

Update JUnit to 5.8.2.

Update AssertJ to 3.22.0.

Update Swagger UI to 3.52.5.

Update the Gradle wrapper to 6.9.2.

Update Stats Gradle Plugin to 0.2.2.

Update License Gradle Plugin to 0.14.0.

Enable vehicle drivers to inspect the whole transport order before accepting it, not just the respective sequence of destination operations.

Reflect the currently claimed and allocated resources in a vehicle’s state.

Show the currently claimed and allocated resources for a selected vehicle in the properties panel in the Operations Desk application.

Show all properties of a path’s peripheral operations in a table instead of listing only the location and operation names.

Update web API specification and implementation to version 1.1.0:

Skip the user confirmation for exiting the Kernel Control Center application.

In the File menu, improve the names of the entries for uploading a model to the kernel and downloading it from the kernel.

Update Jackson to 2.13.0.

Update Spark to 2.9.3.

Properly specify and implement claim semantics in the Scheduler interface, allowing custom scheduling strategies to take vehicles' planned future resource allocations into account.

Introduce VehicleCommAdapter.canAcceptNextCommand(), which can be used to (statically or dynamically) influence the amount of movement commands a comm adapter receives from its VehicleController.

Execute virtual vehicle simulation using the kernel executor to avoid potential deadlocks.

Restore single-step mode for virtual vehicles.

Fix immediate withdrawal of transport orders.

When the Kernel application is started, initialize its components (e.g. dispatcher, router, scheduler) using the kernel executor, especially to avoid scheduling issues with plant models that are loaded with application start up.

Fix the order sequence details panel which would not load due to some wrong paths to a resource bundle.

Fix an issue where the Operations Desk was not in sync with the Kernel when using very large models.

Fix an issue where cutting and pasting elements in the Model Editor would create multiple elements with the same name.

Switch to publishing artifacts via the Maven Central artifact repository. (Previously, artifacts used to be published to JCenter, an artifact repository that has been discontinued.)

Update the license information: All components, including the Model Editor and Operations Desk applications, are now licensed under the terms of the MIT license.

When a vehicle is waiting for resources to be allocated (e.g. because resources are occupied/blocked by another vehicle), allow it to be rerouted from its current position. (Previously, rerouting was done from the point for which the vehicle was waiting, which could lead to unnecessary waiting times.)

When a vehicle is rerouted while it is waiting for peripheral interactions to be finished, properly reroute the vehicle from the peripheral’s position.

When loading plant models with the Model Editor and Operations Desk applications, show more fine-grained steps in the corresponding progress bars.

In the Operations Desk, sort transport orders and peripheral jobs in the respective tables in descending order according to their creation time.

Reduce the time it takes the Operations Desk to process vehicle updates.

Update Gradle wrapper to 6.8.3.

Update JUnit 4 to 4.13.2.

Update JUnit 5 to 5.7.2.

Update Hamcrest to 2.2.

For plant model elements' tooltip texts in the Operations Desk, sort properties lexicographically and colorize vehicles' states.

Made names generated for transport orders to be (really) lexicographically sortable.

Add a QueryService to the kernel that can be used to execute generic/custom queries via registered QueryResponder instances.

Add support for creating plant models with multiple layers.

Add experimental support for peripheral devices, with device interactions triggered by vehicles travelling along paths. (Note that this is not really documented, yet, and that experimental means that developers using any parts of it are on their own, for now.)

Add a new version of the XML Schema definition for the openTCS plant model.

Allow the scheduler to be triggered explicitly via Scheduler.reschedule().

Show properties in model elements' tooltips.

Split the Plant Overview application in two separate applications: The Model Editor provides model creation and manipulation functionality, while the Operations Desk is used for interacting with a plant while it is in operation.

Split the Operations Desk’s pause button into a pause and a resume button.

Remove support for groups. (Layers can now be used to group plant model components.)

Allow project-specific edge evaluators and routing group mappings to be used.

Default Scheduler: Properly handle requests for same-direction blocks for some edge cases.

Default Scheduler: Really free all resources when taking a vehicle out of the driving course.

Plant Overview: Improve performance for vehicle state updates.

As with paths, locations can now be locked via the Plant Overview application to prevent them from being used by vehicles.

Remove the TCP host interface kernel extension.

Remove the kernel application’s GUI.

Provide the route to be travelled to vehicle drivers with every movement order, for cases in which vehicles require some information about it.

Allow supplementary configuration sources to be registered via service loader.

Allow a configuration reload interval to be set via a system property.

Improve performance of loading a plant model file into the kernel.

Rename transport order category to transport order type.

Update Spark to 2.9.1.

In the Plant Overview application’s "Continuous load" plugin panel, it is now possible to properly remove/delete entries in the drive order and property tables.

Changing the loopback driver’s state through its panel in the Kernel Control Center application now works in all cases.

When using the Kernel’s RMI interface with SSL enabled, avoid side effects on other components using SSL.

Fix creating links between points and locations in the Plant Overview application.

Optionally have names for transport orders and order sequences generated by the kernel. Use ULIDs for these generated names by default, to have lexicographically sortable names.

Add a publishEvent() method to the KernelServicePortal interface that RMI-Clients can use to publish events on the Kernel application’s event bus.

Enable the Kernel Control Center application to set positions for all simulating vehicle drivers, not only the loopback driver.

Paths that have the same start and end components are now displayed properly in the Plant Overview.

In the Plant Overview’s continuous load panel, transport order definitions can now be saved to and restored from XML files again. (Note that in the course of fixing this issue, the XML files' structure was improved. Since the feature had been broken for a while and is not part of a public API, backwards compatibility was not maintained for this. As a result, transport order definition files from old versions of openTCS cannot be restored.)

Make using the "try it out" buttons in the OpenAPI documentation possible by setting CORS headers in the web API’s responses.

Add history entries for transport orders being deferred or resumed as well as assigned to or reserved for vehicles in the dispatching process. This makes it easier to find out e.g. why a transport order wasn’t assigned to a vehicle, yet. It also implicitly deprecates transport orders' rejection entries, as history entries provide the same functionality, but for more use cases.

Expect applications' locales to be set via BCP 47 language tags, making the configuration more flexible and independent from the source code.

Extend the default router to be able to extract explicitly given routing costs from path properties, too.

In case no load or unload operation is defined for a virtual vehicle, use a default value to avoid exceptions.

Do not (wrongly) set a vehicle’s processing state to IDLE whenever its integration level is set to TO_BE_UTILIZED.

Avoid potential deadlocks related to using the Plant Overview’s resource allocation panel.

Disable the Kernel application’s integrated control center GUI by default. It can still be re-enabled via the Kernel configuration, but it has been deprecated for several openTCS releases now and will be removed with the openTCS 5.

Move all language files for the applications' internationalization to a common hierarchy, remove unused/left-over entries and apply a proper naming pattern to the remaining ones to improve maintainability. (The language files for the Kernel application’s integrated control center GUI are excluded from this, as that GUI will be removed with openTCS 5.)

Remove support for the Plant Overview application’s old model file format (file name extension .opentcs). The old format has been deprecated since openTCS 4.8 in favour of a unified file format (file name extension .xml) shared by Kernel and Plant Overview. Users who still have model files in the old format may want to save them in the current format before updating.

Remove the menu item to trigger the kernel’s dispatching process from the Plant Overview’s main menu. The dispatcher is triggered automatically (and, for special cases in integration projects, periodically), so manual triggering does not need to be involved.

With the defaultdispatcher.reparkVehiclesToHigherPriorityPositions configuration enabled: Prevent a vehicle from being re-parked to positions that have the same priority as the vehicle’s current parking position.

Fix a bug where charging vehicles don’t execute transport orders after they have reached the "sufficiently recharged" state.

The Kernel application does no longer persist Color and ViewBookmark elements of the visual layout. (For some time now, these elements could no longer be created with the PlantOverview application and were ignored when a model was loaded, anyway.)

Fix a bug with the loopback communication adapter that prevents resources from being properly released when the "loopback:initialPosition" property is set on vehicles.

Introduce an event history for transport orders that can be filled with arbitrary event data.

Introduce "*" as a wildcard in a vehicle’s processable categories to allow processing of transport orders in any category.

The Plant Overview’s vehicle panel now also shows the current destination of each vehicle.

With the defaultdispatcher.rerouteTrigger configuration entry set to DRIVE_ORDER_FINISHED, ensure that the rerouting is only applied to the vehicle that has actually finished a drive order.

For vehicles selected in the Plant Overview, re-allow changing their integration levels via the context menu to either "to be utilized" or "to be respected" if any of them is currently processing a transport order, too.

Remove the included integration project generator and document usage of the example integration project, instead.

Update the web API specification to OpenAPI 3.

Update Gradle to 4.10.3.

Update Checkstyle to 8.16.

Update JUnit to 5.3.2.

Update Guice to 4.2.2.

Introduce optional priorities for parking positions. With these, vehicles are parked at the one with the highest priority. Optionally, vehicles already parking may be reparked to unoccupied positions with higher priorities.

Provide additional energy levels for vehicles to influence when recharging may be stopped.

Make the Plant Overview’s naming schemes for plant model elements configurable.

In the Plant Overview, allow multiple vehicles to be selected for changing the integration level or withdrawing transport orders.

Prevent a movement order from being sent to a vehicle a second time after the vehicle got rerouted while waiting for resource allocation.

Introduce a type property for blocks. A block’s type now determines the rules for entering it:

Properly set a point’s layout coordinates when it is placed exactly on an axis in the Plant Overview.

Properly select the correct/clicked-on tree entry in the Plant Overview’s blocks tree view when the same element is a member of more than one block.

Prevent the Kernel application from freezing when loading some larger plant models.

Require the user to confirm immediate withdrawals of transport orders in the plant overview, as they have some implications that may lead to collisions or deadlocks in certain situations.

Improve input validation of unit-based properties for plant model elements.

Remove the Kernel Control Center’s function to reset the position of a vehicle. Users should now set the vehicle’s integration level to TO_BE_IGNORED, instead.

Allow the loopback driver to be disabled completely.

Minor improvements to the configuration interface API.

Mark all AdapterCommand implementations in the base API as deprecated. These commands' functionality is specific to the respective communication adapter and should be implemented and used there.

Introduce an explicit integration level property for vehicles that expresses to what degree a vehicle should be integrated into the system. (Setting the integration level to TO_BE_UTILIZED replaces the manual dispatching that was previously used to integrate a vehicle.)

Allow recomputing of a vehicle’s route after finishing a drive order or on topology changes.

Allow vehicle themes to define not only the graphics used, but also the content and style of vehicle labels in the Plant Overview.

Enable the web API to optionally use HTTPS.

Allow an optional set of properties for meta information to be stored in a model, and use it to store the model file’s last-modified time stamp in it.

Prevent moving of model elements in the Plant Overview when in mode OPERATING.

Prevent creation of groups in the Plant Overview when in mode OPERATING.

Properly handle renaming of paths and path names that do not follow the default naming pattern in the Plant Overview.

Multiple minor fixes for the integration project generator.

When using the Plant Overview or Kernel Control Center with SSL-encrypted RMI, verification of the server certificate is now mandatory.

Adjust the default docking frames layout in the Plant Overview for mode OPERATING a bit to make better use of wide-screen displays.

Include web API documentation generated by Swagger in the distribution.

Include the buildSrc/ directory in the source distribution.

Properly display vehicle routes after adding driving course views in the Plant Overview.

Properly disconnect the plant overview from the kernel when switching to modelling mode.

Fix jumping mouse cursor when dragging/moving model elements in the Plant Overview in some cases.

Allow the kernel to work headless, i.e. without a GUI. Introduce a separate Kernel Control Center application that provides the same functionality and can be attached to the kernel as a client.

Provide a single-threaded executor for sequential processing of tasks in the kernel, which helps avoiding locking and visibility issues. Use this executor for most tasks, especially the ones manipulating kernel state, that were previously executed concurrently.

Introduce a web API (HTTP + JSON), intended to replace the proprietary TCP/IP host interface, which is now deprecated.

Introduce an API for pluggable model import and export implementations in the Plant Overview.

Split the Kernel interface into aspect-specific service interfaces.

Provide a (more) simple event API, including an event bus implementation as a replacement for the previously used MBassador and event hub.

Overhaul the default dispatcher implementation to improve maintainability and extensibility.

Allow suggestions for property values in the Plant Overview to depend on the key.

Improve API and deprecate classes and methods in lots of places.

Improve default formatting of log output for better readability.

Fix erroneous behaviour for renaming of points when points are block members in the plant model.

Fix processing of XML messages received via the TCP-based host interface.

Properly store links between locations and points in the unified XML file format when the link was drawn from the location instead of from the point.

Ensure that marshalling and unmarshalling of XML data always uses UTF-8. This fixes problems with plant models containing special characters (like German umlauts) e.g. in element names.

Properly copy model coordinates to layout coordinates in the plant overview without invalidating the model.

Adjust erroneous behaviour in the load generator plugin panel and properly update its GUI elements depending on its state.

Add a category property to transport orders and order sequences and a set of processable categories to vehicles, allowing a finer-grained selection of processable orders.

Prepare proper encryption for RMI connections.

Use the unified (i.e. the kernel’s) XML file format to load and save plant models in the plant overview by default. (The plant overview’s previous default file format is still supported for both loading and saving. Support for the old format will eventually be removed in a future version, though, so users are advised to switch to the new format.)

Remove some unmaintained features from the loopback adapter and its GUI.

Ensure that scheduler modules are properly terminated.

Allow the colors used for vehicles' routes be defined in the plant model.

Have the default dispatcher periodically check for idle vehicles that could be dispatched. This picks up vehicles that have not been in a dispatchable state when dispatching them was previously tried.

Don’t mark a drive order as finished if the transport order it belongs to was withdrawn.

Properly update the vehicles' states in the kernel control center’s vehicle list.

When creating locations, properly attach links to the respective points, too.

When renaming a point in the plant overview, properly update blocks containing paths starting or ending at this point.

Avoid NPE when the transport order referenced in a Vehicle instance does not exist in the kernel any more.

Allow the kernel’s RMI port to be set via configuration.

Allow preferred parking positions and recharge locations to be set as properties on Vehicle instances.

In XML status channel messages, add a reference to a vehicle’s transport order, and vice versa.

Allow the kernel’s order cleanup task to be adjusted via predicates that approve cleanup of transport orders and order sequences.

Deprecate VehicleCommAdapter.State. It’s not really used anywhere, and the enum elements are fuzzy/incomplete, anyway.

Made documentation of configuration entries (for users) easy via annotations.

Switched configuration files from XML to properties.

Switched to read-only configuration.

Moved vehicle communication adapter base classes to org.opentcs.drivers.vehicle and named them more appropriately.

Removed TCP/IP communication implementation from org.opentcs.util.communication.tcp and a few more utility classes. Maintaining these is out of the openTCS project’s scope.

Communication adapters may now participate with dependency injection.

Default kernel strategies may now easily be overridden.

Method Set<String> getModelNames() was changed to String getModelName(), as from now on there exists only one model at a time.

Method loadModel(String modelName) no longer requires/accepts a parameter.

Method saveModel(String modelName, boolean overwrite) no longer accepts the boolean parameter and overwrites the model automatically.

Method removeModel(String rmName) no longer requires/accepts a parameter.

Methods createLayout(byte[] layoutData) and setLayoutData(TCSObjectReference<Layout> ref, byte[] newData) have been removed along with class Layout.