This thread looks like if I am talking about computer software, but I am really talking about board games. Still, it could be a way to bring computer science to board game design. Maybe I should take a look on how plug-ins for real software are actually designed.
I have a civilization like game in design what will be very expandable and that could become very complex to learn and design. But that complexity level is required to make the experience enjoyable. In fact, it's not complex because it's complicated, but rather because there could be a lot of stuff, and most of the time, I get lost in my design. It's very interesting, but there is so much things that it's hard to have a mental view of the game as whole.
This is were I had the idea of making a pluginable game. At first, I wanted to have some optional variant set that players could use as they want it, but I want to push it even further by making almost all aspect of the game pluginable. The way it will work is simple, player will start with the core rules which is a game playable by itself. Then players can add plugins by replacing core rules with the new plugins.
For example, in the core rules, combat could be resolved by matching cards randomly, but you could add the tactical map plugin which allows to play the combat using the same cards with a small tactical map. A second example, you could have a simple magic system where each player has a few special powers for their whole empire, or you could have the complete deck building game with spell casting.
Players can agree to use certain plugins at the beginning of the game. But players could also add or remove plugins in the middle of the game if they are hot swapable (sorry, computer geek terminology). In other words, some plugins must be used from the start of the game while some others could be added or removed during the game.
Plugin design could bring multiple advantages:
Easier to design: You do not have to see the whole game in your mind to design each plug-in. You just have to remember the core and only work on the plug-in it self. It should make the design of the game less overwhelming. Then plugins could be compared together for compatibility.
Progressive teaching: You could teach the game by adding plugins though the game. It makes it easier to learn the game as you assimilate and use gradually the rules.
Adaptable to Tastes: Players can use the plug-in set they want according to their tastes.
Expandable, even by players: It makes it easier to add or change rules by changing plug-ins since the game is design for it. Players will also be able to design their own plug-ins
Speed up on demand: You could speed up the game during the game. For example, you could need to end the game faster, it could be done by switching plugins. For example: we do not resolve tactical battles, we use the basic system from now on.
Print and Play Friendly: For print and play distributions, players can play without building everything. They just print the plug-in they needs when they want it.
Now I am trying to find, how could we design pluginable games. Here are a few guide lines:
Unused information: You could add unused informations to some concepts of the game so that this information could be used later by another plug-in. For example, I could give a creature size to the monsters of my game without ever using that variable. But another player could design a plug-in that will use that variable.
Common Interface: Making sure that the interface for a concept is the same so that all plug-in could communicate with the same interface. For example, I could say that civilizations is managed with 3 variables. By setting this as the standard input, all plug-ins for civilization management will expect to use 3 variables.
Define common concepts: When some game mechanics influence all game mechanics, it could be useful to have common concepts. For example, a common concept for a civilization could be to have a "building". The concept of building could be implemented differently in each plugin. It could be a tile with a power like in puerto rico, or it could be a progress track. The idea is that if I design an "earthquake" spell that destroys a "building", the element destroyed will be different according to the plugin used. But all plug-ins will have a concept called "Building" making sure the "earthquake" spell will always be valid what ever the plugin.
Sub Values: It could also be possible to define sub balues to basic values that could only be used by certain plug-ins. For example, in the 3 variable example above, each variable could have 2 sub values for example, creating 6 variables: 1A, 1B, 2A, 2B, 3A, 3B. If a simple plug in does not want to define the detailed values, it will set value 1,2,3 which will be the same for the sub values. So 1A and 1B will be the same as Value 1. But if a plugin want to go deeper in details, he could define different sub-values.
Do you like the idea?
Do you think it could be useful?
Could it create interesting games?
Will the plug-in structure be too complex to understand?
Any other comments are welcomed. If you have questions let me know.
It has some similarities. But it's like if all the advanced rules were optional and could be used in various combinations. If the core is very thin, it could mean that the core game itself is just boring, you need a few plugins to start with.
It does look similar to Carcasonne, but it's like if each expansion could have multiple versions. for example, you can play the "Inns and cathedral" with 2 different set of rules and/or tiles.