Building Evolve with modding in mind

One thing I have wanted from the very beginning is for Evolve to be easy to extend.

Not just for me.

For anyone who eventually wants to mod it.

That has influenced quite a few of the decisions I've made about how the game itself is structured.

The main one is that almost everything in Evolve is data-driven.

Everything starts as data

Rather than hard-coding every item, block or creature directly into the game, most of that information comes from JSON files.

Items are defined in JSON.

Blocks are defined in JSON.

Recipes are defined in JSON.

Loot tables are defined in JSON.

Even things like dinosaurs and other world entities are built around the same idea.

The game reads the data and uses it to construct whatever that thing is supposed to be.

That makes things considerably easier for me while developing the game, because adding a new item doesn't necessarily mean going back into the code and creating an entirely new implementation.

But it should also make things much easier for modders later.

If someone wants to add a new block, for example, ideally that should mostly mean defining what that block is, what it looks like and how it behaves.

The engine should handle the rest.

That is the direction I'm trying to take with pretty much everything.

Designing around modding now

It would be very easy to build the game first and then worry about modding later.

The problem is that by then a lot of the decisions that make modding easy or difficult have already been made.

So I'm trying to think about it now.

That means keeping systems generic where I can and avoiding assumptions that only make sense for the content I personally intend to create.

Dinosaurs are a good example.

I obviously have a roster of dinosaurs that I want to add to Evolve, but I don't want the creature system to fundamentally know what a Brachiosaurus or a Compy is.

It should understand a creature described by data.

The same should eventually apply to most of the content in the game.

That means, at least in theory, there is nothing particularly special about the content that ships with Evolve compared with something added afterwards by a mod.

There will obviously be limits to that, but that is the goal.

Lua later

JSON works very well for describing things.

It is less useful when you want something to actually do something unusual.

For that, I am planning to add scripting support using MoonSharp, which is a Lua interpreter for .NET.

I haven't actually built the scripting side yet, but I have tried to make decisions around the current systems that won't prevent me adding it later.

The idea is that JSON handles the data, while Lua could eventually handle more complicated custom behaviour.

That should give modders quite a lot of freedom without requiring them to actually modify or compile the game itself.

Exactly how much of Evolve will eventually be exposed through Lua is something I haven't decided yet.

It is very easy to say that everything should be moddable, but every extra thing you expose is also something that needs to be supported and kept working as the game changes.

So I'll probably grow that side of things gradually.

Distribution is a problem for later

The part I haven't really thought too deeply about yet is how mods will actually be distributed.

Steam Workshop would obviously be one possibility.

There are other ways of doing it as well.

There are also questions around how multiplayer servers handle mods, how clients discover what they need to download and how different versions of mods are managed.

Those are all real problems, but they're not problems I need to solve today.

Right now I care much more about making sure that when I eventually get to that point, the game is actually capable of being modded in the first place.

Changing how mods are downloaded later is relatively easy.

Trying to retrofit a modding system into a game where everything has been hard-coded for years is probably not.

So for now, that is the important part.

Modding isn't something I'm planning to bolt onto Evolve at the end.

I'm trying to make sure the foundations for it are there from the beginning.