I have look at VASSAL and i feel that the need to learn a programming skill to code a new board game may not appeal to many. So I thought about it and i come up with an idea.
i didn't have time to really analysis how it can be done but here is a quick draft of what i think is possible to do.
To describe my idea, i shall first focus on card games as an example.
In all the card games, we can first break them down into smaller components that are part of the games.
1) Zones : Zones defines the places that the card can be in (Hand, Remove from the game, etc)
2) Counters : Life , any form of counter. Counter can be put on cards in any zones (more on that later), or on any players.
3) Cards : Cards are just encoding for "sequence of actions".
4) Actions : Define a sequence of "system action".
Zones : Zones can be of many types. The first few that i can think of are
1) Private (Only you can see and do action on the cards)
2) Team (Only your team can see and do action on the cards)
3) Personal_Team(Your team can see but only you can do action on it).
4) Personal(Everyone can see but only you can do action on it).
5) Global(Everyone can see , and everyone can do action on it).
We probably need to define how each zones are duplicated for each players or if the zone is unique.
We also need to define if the zone is a Piled zone(meaning all the cards are hidden) or a open zone where all the cards are revealed to all.
Counters : Counters are just numbers , but we need to be able to define whether it is a global counter, or personal counter or specific counters for a card etc.
Cards & Actions :
Most of the cards games are just manipulating Cards(moving from zones to zones), increasing/decreasing counters and providing actions for cards in different zones.
So the simplest System action that i can think off would be
Move ___ To ___
Increase ___ By ___
etc.
So Actions can be defined by user. For example, we want to allow players to "play"(Action_Play) their cards from their hand(Zone_Hand).
Then we can define an Action call Play, that only can be "triggered" by the player who own the Zone (Hand), and the card have to be in the Zone.
The action (Action_Play) does nothing but defining the Action that can be done on a card from which zone.
What the action does for each card is defined in the card.
It is probably unclear regarding what i say so lets use Magic the gathering as an example, since it is probably one of the most hard to define card games.
In MTG , the zones are defined as
Hand(Private),
Graveyard(Personal),
Play(Personal),
Remove From the game(Personal),
Library(Private),
etc..
Then we define the counters
Mana_Blue,Mana_Red etc etc.
Life_counter,
etc.
Actions :
Play[Only from Hand]
Discard[Only from Hand]
So for example, lets take summoning a creature in mtg as an example.
A creature card would have a cost , defined in term of counter, so if the creature have a cost of 2 blue mana, the requirement would be Mana_Blue >= 2.
The action for [Play] for this card can be defined in the following manner.
Mana_Blue - 2
Move This to Zone_Play.
A card that let the player choose one cards from opponent hand can be defined as
Owner Choose 1 Player(as plist)
Foreach p in plist
Owner Choose 1 Card(as cards) from p.hand
Move cards To p.Graveyard
I probably over simplified things for this case but you get my point(hopefully).
The next think would be to define the game flow.
Game flow would be broken up into stages , each stages contains turns and each turns contains phrase.
For MTG the stages would be
StartGame
InGame
StartGame would define the steps for mulligans and drawing of starting hand, In game will be the game itself. The phrases for MTG is defined clearly, such as Draw phrase, combat etc etc.
In each Phrase/Turn/Stage, we can also define a action that we want to do. Etc.
So you may think , All this are still programming, so we are still back to square one. Not really.
These are just low-level designs that we can implements in the engine, and the developers can be provided with a good tool that allow them to choose the sequence of action they want to do.
The engine can then provide small systems actions, that can be combined into actions that mimic the effects of cards.Note that what i posted here is just the rule set portion and i probably oversimplify a lot of things here. I believe the UI and networking portion would not be as hard as compared to defining a good engine backend for developer to design and prototype their game.
After we do this for card games, we might be able to define a bigger set of ruleset for board games as well but doing that will take a slightly longer time.
The hard part ? analyzing enough card games to find all the small actions that we needs to define. I don't have time at the moment as i am still schooling to start on such a big project. I might work on it during my breaks but in the mean time i hope we can brainstorm
and perhap one day someone might pick it up and start on the project.
(sorry for the long post)
