Welcome to Day 6!

Almost done. The one thing missing is how to handle items. In theory we could do this the same way it is handled in the board game - use the character ID boards and prepare all the cards, including Wounded cards as tokens, so you can pull them onto the boards.

There are two distinct disadvantages to this, though: It takes up a lot of valuable screen estate, and secondly it does not help you to use any automation functions FG might provide.

Fantasy Grounds is a Roleplaying Virtual Table Top after all - dealing with characters and their abilities and equipment is what it was made for.

The Core RPG is a general RPG that allows you to pretty much play any RPG. It just doesn't offer any additional tools that you'd find in the D&D, Pathfinder, Savage Worlds or many other rulesets that have been programmed already. That means, if we want functionality, we'll have to do it ourselves.

At first though, we'll use the Core RPG features. Building a custom character sheet is quite easy, as Doug Davison demonstrates in this video.

Armed with this knowledge I very quickly whipped up character sheets for each character. There are only two skills: Melee and Ranged. Both always use d6. I modified the number of dice rolled according to the weapon rolled - and adjusted the title accordingly ("Melee" for example became "Melee (Chainsaw 5+)" when Amy found that one.




Now a double click on the dice in the character sheet rolls the dice with the notice what skill was used. It's easy to see that this roll scored 1 hit.

The items were entered via the items tab and then added to a table, similar to the Zombies table. If you click on the link you can see the description for the item in question.

The character sheet is not optimized in any way - but it looks like we can definitely play now!

Welcome to Day 5!

So many components are ready, but the most important ones are the CARDS.

Zombicide basically uses two different card types: Zombie Cards and Equipment cards, of which Wounded Cards are a subtype (they are used on the equipment slots, although they of course are not items per se).

Let's talk about Zombie Cards first: When you draw one, you put Zombies on the board according to the highest experience level of any survivor (yes, that implies he/she has to be alive to be "eligible").



Ideally we'd have a function that allows us to set what cards are to be used in the scenario (you can make it easier or harder by excluding certain cards from the deck you are playing with) then shuffle it, draw from it, and show the resulting card as an image, but we are not there yet.

Instead we are going to use the table function in FG. In its basic version that comes with the Core Ruleset it is meant to be used for Random Encounter or Loot tables. Very, very old school D&D.

If we used that vanilla version, though, we'd have the same chance of drawing each card every time (1 in 42 for the full set).

Fortunately Trenloe has done a magnificent little extension to the tables, called Basic Card Deck Tables.

This extension allows to set a table to "cards" and then manually exclude the table items you have already "drawn".

Another nifty feature of Fantasy Grounds: If you have a link (to an image or a library entry), you can simply drag the link into the result in the table and it will be reproduced in the result. Simply click the link and (in our case) the Zombie Card will be shown in all its glory. Or infamy.



Once you have drawn a card, you have likely to scroll down a bit to find it and disable it, but that is a minor inconvenience, as is the fact that on resetting the list will not be reset to its original order.

Scanning all those cards was a bit tricky, due to Moiré effects and those rounded cardboard corners, but all in all this took just under an hour.

It looks like we are almost there - just one more thing until we can do our first test run...

Welcome to Day 4!

Today it's time to populate the board with... TOKENS!

Zombicide's appeal in part stems from all those nifty miniatures appearing on the board (My huge box of Zombicide stuff arrived this week, so I can tell from first-hand experience now ;-)). For the virtual table top that doesn't work so well.

Fortunately Zombicide provides all the graphics you need. Once again the regular card board tokens you need to set up the missions are already available in the mission generator we already cannibalized for the tiles (see what I did there?).

Which leaves us the survivors and the zombies.



With just a little bit of Photoshop work, this is quite easy - the key is clipping masks. I have set up a circular black layer with a few effects (Inner Shadow, Inner Glow) and just dump the character image (from the survivor id card) into that mask.

On a higher level I have the frame - basically a colored ring, where I choose the color according to the main color for that character.

In the end I export a transparent .png like this:



I do like exporting these at 150x150 px, but if your group has problems with bandwidth, you can make these smaller, of course.

Images for the zombies likewise are available on the website (just photographing the unpainted grey ones from the box makes it a lot harder to distinguish them).

This time I do not use a circular border, but a somewhat irregular one (this was done very quickly, it could be neater). The key here is to use different colors for the different zombies, so they can be easily identified on the board. Walkers come in abundance, so I used both the male and the female version.



Of course you can make these as varied as you'd like - adding them from screen shots for the Walking Dead TV series or any other source into your template.

Where to put them?

Once again FG helps you with that. In FG just click the Tokens button to the lower right. This opens the Tokens window. Near the bottom you'll find buttons for "GM" and "Shared" (and "Modules", but that is for using Tokens as a module, something we might do much, much later to clean things up).

Clicking on the "Shared" one brings up a standard Windows Explorer where you can put your tokens. Or you add a sub folder here called e.g. "Zombicide" and place all the tokens in there. Place them all in Shared makes sure all players can access the tokens, so you as the "GM" don't have to do everything. It's a board game after all, and there is no reason to keep these things hidden from the players.

For this screen shot I only added the Survivors and the Zombies to the Zombicide sub folder:

Welcome to Day 4!

We now know how to put the rules into Fantasy Grounds, but that's not really what we want, is it? What we want is to play! And we want to see some visuals.

There is a reason you call it a board game: You play it on a board. Let's get to it. Once the game is here I plan to scan the tiles in all their glory, but for now we'll take the ones coming with the Map Editor. The tiles in there are only 250x250 pixel, plus they are kind of greyed out (easily remedied with an Auto-Level command in Photoshop - I am sure Gimp has similar features), but they'll do until we can scan the real thing in Hi-Res glory. At least these will be very upload-friendly.

Once I have set up the dimensions in Photoshop and set up some guides to click the images into, each map only takes 1-2 minutes or so to produce. Getting out he board game tiles and arranging them takes easily the same time (or longer).

This for example is the (very small) tutorial map done this way:



Where to put it?

The correct folder sometimes is a bit awkward to find, but there is a simple solution:

Click on the Images & Maps Button in the right column. Then click the Folder button on top of the window that just opened and the folder opens right there. All images put into that folder immediately appear in Fantasy Grounds.



Nifty, isn't it?

That takes care of the Board in Board Game for now.

In addition to the tiled boards, you can find the character boards (called 'Survivor Identity Cards') on the Zombicide website. For now these can go into the same folder, and everybody has an instant character sheet).

Welcome to Day 2!

We are still working on our rules module. Formatting a library entry with <h> for headers (XML needs you to always close tags!), <p> for paragraphs (text that is not enclosed in either of these tags will not be shown!), and the occasional <b> and <i> tags works fine for most entries.

Lists are done with <list> tags, and then each entry being surrounded with <li> and </li>, ending the whole structure with a closing <list>.

These entries are starting to make the rulebook look useable already:



In chapter 5, though, we not only get more text, but it is divided in to topics we might want to access quicker, with their own heading. This is kind of a workaround that works pretty well: We enter these subdivisions with they own <librarylink> tag, but precede the title with two empty spaces #160; (otherwise the spaces wouldn't be shown - we need to "hardcode" them in).

Code:

<afb_lineofsight>
	<librarylink type="windowreference"><class>referencetext</class><recordname>..</recordname></librarylink>
		<name type="string">**Line of Sight</name>
		<text type="formattedtext">
		<p>Lots of text again</p>
		</text>
</afb_lineofsight>

This gives us immediate access to this subchapter from the main library menu.



How about the proper chapter 5? This will get a little bit of text, and then a link list to the other entries that we also see from the main overview.

Code:

<afa_basics>
	<librarylink type="windowreference"><class>referenceindex</class><recordname>..</recordname></librarylink>
		<name type="string">5. Basics</name>
		<description type="formattedtext">
			<h>Useful Definitions</h>
			<p>Actor: A Survivor or Zombie</p>
			<p>Zone: Inside a building, a Zone is a room. On the Street a Zone is the area between two pedestrian crossings and the walls of buildings along the street. A single Zone may extend over two tiles or even four tiles</p>
		</description>
		<index>
			<sub01>
				<listlink type="windowreference">
					<class>referencetext</class>
					<recordname>library.zombicide.entries.afb_lineofsight@Zombicide</recordname>
				</listlink>
				<name type="string">Line of Sight</name>
			</sub01>
		</index>
</afa_basics>

One thing to look out for is the <class> tag in <sub01>: This one has to be the same as the librarylink class in the target entry, otherwise the link will be displayed just fine, but the opening window will have no text.

With these two techniques we can complete the purely text based rulebook entries, leaving chapter 9 (Skills) and 10 (Missions) with blank entries for now. I have something special in mind for those.

Welcome to Day 1!

Can you already hear the Zombies moan and wail out there? No? Well, that's because we are not quite there yet.

Today we are going to start our rulebook. Why would we do that, when the rulebook is accessible online?

For once converting it into a Fantasy Grounds module allows every player quick access to the rules, plus we can later link the different characters, skills etc. into it. Basically it's going to contain all the content the game needs, the muscles over the bones (even Zombies need that!).

We'll start with the most simple module possible. A module is basically a zip-file with the custom ending '.mod'.

For our purposes it has to contain three items:

• thumbnail.png (I quickly made one out of the game carton pic at 117x117 resolution)
• definition.xml
• client.xml (iirc this could/should be db.xml now with the new version, but client.xml works as well)

This is the definition.xml, it's short and sweet:

Code:

<?xml version="1.0" encoding="iso-8859-1"?>
<!-- Copyright SmiteWorks USA, LLC., 2011  -->
<root>
  <name>Zombicide</name>
  <author>Copyright 2015, Guillotine Games</author>
  <category>Board Games</category>
  <ruleset>Any</ruleset>
</root>

It names the module, tells us what ruleset it is based on (we may change that later, for now it's just text, hence 'Any') and sets the category "Board Games"

The client.xml is a little bit more involved, this is where all the information is stored and it must be structured in a way that FG can access it.

This is the skeleton we are going to work with:

Code:

<?xml version="1.0" encoding="ISO-8859-1"?>
<!-- Copyright SmiteWorks USA, LLC., 2012  -->
<root version="3.0">
	<library>
		<zombicide static="true">
			<name type="string">Zombicide</name>
			<categoryname type="string">Board Games</categoryname>
			<entries>
			
			</entries>
		</zombicide>		
	</library>
	<reference>
		
	</reference>
</root>

the <zombicide> tag is named by me, everything else is pretty much canon. Make sure that the content of the name string is the same as in definition.xml, otherwise links will not work correctly.

Having files with these entries will put our rulebook "on the board", so to speak, we can now see the module in the module selection screen and open it:

Attachment 9373

Of course if we try to look into it, there is no content (we might even get an error message).

The next step is to get some structure into our library. Fortunately this is quite easy - there are 10 more or less short chapters that make up our top navigation. This is a not a commercial module, so we won't bother with completeness and just take what we need. For sake of reference we'll keep the original chapter numbering, but we'll leave out chapter 01 (Game Contents) - we don't care about that.

Our first chapter entry makes the <entries> tag look like this:

Code:

<entries>
	<aba_survive>
		<librarylink type="windowreference"><class>referencetext</class><recordname>..</recordname></librarylink>
			<name type="string">2. Survive and Win</name>
			<text type="formattedtext">
				<p>Lots of text in paragraph tag</p>
			</text>
	</aba_survive>
</entries>

All entries in the library with the are sorted in alphanumeric order by the name you give the entry in the entries tag and appear with their name once you open the module, but, and this should be written BUT!, you cannot start that tag with a numeral. This used to give me headaches, because you just get an error message, without ever telling you thr cause.

You could name your entry <_001>, but you can't do <001>. I like to use letters (26 instead 10 choices), and count down using the second 'digit'.

It's getting late, we'll continue with this on Day 2.

Hello there!

Fantasy Grounds is a great tool for playing Role-Playing Games with friends over the internet, just like you would at your own table at home.

The Name Who Cannot Be Named, Pathfinder, Savage Worlds and a few others have great rulesets who make things almost easier than playing in your living room. I love it.

Hmm. Table? Living Room? Friends dispersed?

Why not try to convert a board game instead of an RPG? Presumably the rules are easier to convert - and the same reason to play it with Fantasy Grounds applies.

As it is, my kickstartered huge box of Zombicide (Season 1-3 plus lots of add-ons) supposedly is on the boat and will arrive in a few days. With three small kids in the house, I don't supposed my wife would appreciate playing out the Zombie Apocalypse on our dinner table. Who knows, I'll try to convince her. But I am not hopeful.

Attachment 9353

In any case - having a conversion of this cooperative board game sounds like a great idea - I am a sucker for coop games. Maybe I can use it to lift the lid on the one great problems Fantasy Grounds has: It's lack of accessibility to build your own rulesets. Frankly, the documentation sucks big time for those of us who don't program professionally - fortunately the forums are populated by savvy and very helpful people.

In the end this blog hopefully will help others in getting their feet wet and starting to build their own rulesets.

Okay let's move on.

Preparation

The first step, obviously, is to read the rules. Fortunately they are online in PDF form. This is great, because that way we can put them into a rules module very easily - giving all players easy access to it during a session, without me having to type in everything by hand.

Attachment 9354

It starts out with components. We have game tiles for maps, miniatures, dice (haha), lots of tokens, survivor identity cards (basically character sheets), and two sets of cards (zombies and equipment).

Frankly - this looks doable. FG already works with maps. Worst case we can add tokens to a map and move them around, best case we can have "game master tokens" and "player tokens" on different layers to make things easier.

Attachment 9356

Each character has great art, which means we can easily convert characters and zombies into tokens, along with scanning the other tokens. For the cards we'll have to look at something to make it snappy, but in a pinch (and we want a workable prototype asap, don't we?) we can rollable table for these - if we can set them up to remove choices already made (simulating taking a card out of the deck), we at least have the mechanism.

That's it for Day 0 - in the next post we'll tackle something easy, the rulebook.

Note: All rights for Zombicide as well as related images are with Guillotine Games. I will not be able to share the ruleset with you.