Hello Railroaders!
Can you believe it’s been almost two years since Railroader was released in Early Access? Some of you have been with us since before it was called Railroader! Many of you have joined us along the way, and some of you have only just become familiar with the game. Whether you’re an old head or a greenhorn, we want to sincerely thank you for your support. We’ve been fortunate to hear from many of you over the last couple years how much Railroader has meant to you. Our small dev team feels a lot of responsibility as stewards of the game.
In our last development update we covered some of the features we’ve been working on to support the Maintenance of Way (MoW) update, including enhanced car loads, expanded industry at Hewitt, and the interchange at Almond.
What have we been up to since then, you ask? We’ve been thinking a lot about modding!
Modding has been a remarkable, unofficial part of Railroader since not long after it was released. We’ve been amazed at what modders have created, and continue to create for the game. While official modding support is on our roadmap, it’s something we have thought of as one of the last big features before Railroader leaves Early Access, simply because we don’t want to break mods, and we don’t want modding support to prevent us from making necessary changes to the base game. In working on the car loads feature, however, it became clear that to build it right we would need to build toward official modding support.
Before we get into details, it’s important to acknowledge that modding is very broad topic. Mods run the gamut: they change parts of cars, introduce new cars and engines, add or change track or industries, scenery, augment the UI. Some even aim to create whole new maps.
As much as we want to provide support and tooling for all of these facets of modding, the reality is that that’s not possible at this point with our limited resources. Map modding in particular is one that we’d love to support but due to the richness of the game and complex features like signals/CTC, map progression, etc., let alone the editing UI, it’s not practical to support map modding without some pretty significant limitations, which we don’t see as a great solution.
Our plan for this update in terms of modding support is that it will focus on two areas of modding, but we plan to continue to consider how we can expand our support for modding in the future.
Railroader has unofficially supported adding new equipment to the game through asset packs since day one – it’s part of our internal development workflow – but there have been some critical aspects missing, namely dependency management and support for encoding mods in save games and handling them in multiplayer.
To improve this, we have been working on revamping asset packs with the following: (technical details incoming!)
Asset packs now have strong identifiers in the format: domain/identifier. All built-in asset packs use the domain rr.
Asset packs now have versions.
Asset packs can define versioned dependencies and will be loaded in dependency order.
Definitions (equipment, scenery, etc.) in a pack must have unique identifiers within the domain. If the game defines rr/ls-280-c46 (the C-46 Consolidation), you could define your-name/ls-280-c46. This simplifies creating variants of existing equipment and helps avoid conflicts.
Asset packs with a matching name no longer override other
Including mod information in save games.
This is a big one: Railroader now has its own scripting language! It’s called Relay.
Relay scripts can be used to:
Manipulate definition data during the loading process, similar to Factorio’s modding system. For example, a Data.rl script in an asset pack can change values on any equipment in the game, add or remove components, or create whole new variants of existing equipment. All without having to duplicate the asset files.
Add scripts to control components on equipment in response to property changes. Example: show or hide a ‘stakes’ model on a flat car based on whether it is appropriate for the car’s current load.
Extend the UI: add controls to existing windows, create new windows, or create console slash commands. Main.rl scripts are used for this.
Some of you are probably wondering: why create our own language? In short, creating our own language enables us to better control the performance impact of the in-game scripting system, offer a modern syntax, and maintain a safe, sandboxed scripting environment.
We think these two areas of modding support offer some pretty exciting possibilities.
Here are a few examples of Relay in action. Remember that this is still in development – we welcome your feedback!
You could create a mod to change the prices of cars, or adjust their capacity using a Data.rl file:
func onDefine(data) {
// Change the price on the lightweight steel passenger car:
data.modify("rr/pb-osgbrad-lightweight-steel-1915", (obj) => {
obj["definition"]["basePrice"] = 900
})
// Create a "high capacity" variant:
data.modifyAs("rr/pb-osgbrad-lightweight-steel-1915",
"imtzo/pb-osgbrad-lightweight-steel-1915-highcap",
(obj) => {
var metadata = obj["metadata"]
var definition = obj["definition"]
metadata["description"] = "High Capacity Steel Coach"
var slot0 = definition["loadSlots"][0]
slot0["maximumCapacity"] += 20
definition["basePrice"] += 2000
})
}
You could create a model with customizable parts. Suppose I had created a new engine with a toggle-able superheater detail model.
In a script component on the engine:
var observer = null
func onModelLoad(car) {
var superheater = car.components["Superheater Detail Model"]
// Observe the property and update component enabled states:
observer = car.properties.observe("showSuperheater", true, (value) => {
superheater.enabled = value
})
}
func onModelUnload(car) {
observer?.dispose()
observer = null
}
And in Main.rl in the asset pack:
from railroader import ui
func onModLoad(ctx) {
// Add a toggle to the customize UI:
ui.extend("carInspector.equipment.customize")
.matching({"identifier": "imtzo/my-engine"})
.with((builder) => {
builder.fieldToggle("Superheater",
() => { return car.properties["showSuperheater"] },
(value) => { car.properties["showSuperheater"] = value }
})
}
These are only a couple examples. Relay can also be used to create windows and add slash-commands to the console. A calculator summoned with /calc?
Perhaps you can see why this has taken some time to build. We’re very excited to see what you build with it, and see it as being useful not only for modders, but also some of the more advanced railroads – you know who you are – who can use some basic scripting to help automate parts of your railroad!
We’re still hard at work on this, although we hope to get to a point where we can release an experimental branch soon. While this experimental might be a little rough around the edges, we think it is important to get this work out there and get feedback to shape it before it is released on the main branch.
Of course this release has a load of other enhancements, but those will need to wait for another post. Until then, thank you as always for your patience and support!
Previous update posts for this update cycle: