Some people have requested information about how to create player aids
like the ones in this .zip archive. Therefore, I decided to write up an
outline of the steps I take during the design process, and include it
with the player aids I distribute. Hopefully this will answer at least
some of your questions, if you decide you'd like to design player aids
of your own!

-- NLP/22JA04

Player-Aid Design HOWTO, Version 1.0


Introduction:

This HOWTO is intended to provide suggestions for creating translated
player aids (cards, tiles, etc.) that are almost identical to the
original foreign-language components. It is NOT a guide for assembly of
the finished designs; for that, refer to the accompanying README.TXT
file.

I welcome any suggested improvements for this HOWTO. Please send your
ideas to me at npetry@accesscomm.ca, and I will do what I can to
incorporate your changes in future versions of this file.


Design Overview:

To create cards/tiles, I use two main types of software in combination:

1. A raster-image/graphic editing program (like photoshop) 
2. A vector-drawing program.

Specifically, I use a program called "The GIMP" (GNU Image Manipulation
Program, similar to Photoshop) to create replacement card images, and
then embed the finished cards in a page layout created using a program
called "XFig". Both of these programs are Free Software
(http://www.gnu.org/philosophy/free-sw.html) that's readily available at
no cost for my operating system (I use the Red Hat 9 version of
GNU/Linux). You can get information about both these programs, and/or
download them from:

XFig 3.2 - http://www.xfig.org
The GIMP 1.2.5 - http://www.gimp.org

If you use some version of MS Windows, rather than a Unix-like system,
using these particular programs on your system may be problematic. I
think it's fairly easy to get The GIMP running under Windows, but you
may prefer to use Photoshop or something similar if you already have a
copy. Your scanner may have included some MS-Windows software that can
be used. 

For XFig, I'm not aware of a reasonable substitute program, although I'm
sure there are some. If you go to the XFig website, there's a link that
will take you to a description of how to get XFig to work under
MS-Windows (http://www.cs.usask.ca/grads/wew036/latex/xfig.html), but it
looks fairly tricky :-(

XFig was designed for X-Windows, so it's not really well adapted for use
under MS-Windows (it's easy with GNU/Linux, or other Unixes).

Anyway, the reason I use both types of programs, rather than just using
The GIMP, is because photoshop-like programs are not good at precision
compositing of graphics, being primarily intended for editing photos and
similar. Using XFig, it is easy to lay out sheets of cards or tiles with
an accuracy of 1/1200th of an inch! (postscript/pdf resolution) Trying
to do the same with the GIMP would involve editing huge page-sized
graphics files, and eyeballing the alignment of each card, which is slow
and error-prone. 

Depending on the original design, I use more or less of one program or
the other to create the finished work. For example, the "Wallenstein"
event cards consist of 25 unique layouts, each involving some fancy
fonts and graphics. For these, I created separate image files (.png/jpg
format) for each card that get embedded in a simple xfig layout that
adds little more than card borders and cut lines. On the other hand, my
"Auf Achse" cards are created almost entirely in xfig, since the
graphics on the original cards are simple geometric shapes, and the text
uses an ordinary sans serif font. All this is easy to replicate within
xfig, and the result is a small, resolution-independent file. Sometimes
I use a mix of techniques, where the common backgrounds are images
created in the GIMP, and the unique foreground text/graphic on each card
is added using xfig (see Ausbrecher AG/Vier zu Mir! for examples). My
advice: always use the drawing program where possible, and the graphics
program only where necessary.


Detailed Steps:

Here's an outline of the series of steps I normally take to make
replacement cards:

1. Scan a subset of the original cards that contains at least one copy
of the illustrations that are required (usually 1 or 2 sheets). I do
these scans at 720 x 720 dpi, as that is a convenient hi-resolution mode
for my inkjet printer. My scanning software (XSane) allows
colour-balancing to be done during the scan, so I set that to be optimal
for high-density inkjet printing.

2. If you look closely at the scanned images, you'll see that rather
than having uniform colours, they are pixellated, due to the dither
patterns that are used in the printing process. The first step is to get
rid of this dithering by applying a 'blur' filter to the images. In the
GIMP, I use a 'Selective Gaussian Blur' filter, which gives best results
if the filter parameters are set carefully (do test filtering of a small
sample of the image to find the right settings). You might do colour
correction, etc. at this stage as well.

3. Generally, cards will have have the same outer dimensions (h x w), so
you should create a set of card image files that use exactly the same
dimensions (in pixels) so that they can be composited without scaling in
the finished result. Normally I measure the original card in mm, deduct
a suitable amount (often a bit less than about 1/8" or so) from each
side to allow for a round-cornered border that will be superimposed
later using xfig. Calculate what these dimensions should be in 720ths of
an inch, and make all card images that size, in pixels. It's often
helpful to create a single 'template' file that contains any features
common to all the cards (such as a background layer), and then
repeatedly save this file under new names as you add the card-specific
features.

Of course, the same graphic can appear repeatedly on the final sheet, so
for example you'll only need to create a single image file for all the
cardbacks, for example.

4. Begin by copying images of particular cards from your master file,
and work on these one at a time using the GIMP. The image should be
broken out into separate layers, using a variety of selection/copying
tools provided in the GIMP. For example, to create the "Wallenstein"
images, I created the following layers:

a) Original (the original composite image, to allow text to be aligned
like the original) 
b) Background (blank white) 
c) Foreground (the grey overlay with the ragged border) 
d) Line Pattern (the irregular horizontal lines on the background) 
e) Overlay (the unique card graphics, such as the grain loss count and
card #) 
f) Text Body (card description - an editable text layer) 
g) Text Title (same as e)

The reason to use layers is that it makes it easy to preserve the common
elements (background patterns, etc) for all the cards, and just edit the
changing layers (text, etc) as you move from card to card.

There are probably dozens of techniques for selecting areas of the
original image that will be useful when creating new layers, and it is
impossible to describe all of them in this HOWTO. Only experience with
using the GIMP or similar programs will teach you how to do this easily.
The best approach is to just experiment! That said, here are
descriptions of a couple of tools that are especially useful when
creating layers:

a) The "Fuzzy Selection" (Magic Wand) tool is often useful when you have
an object in an image that you either want to extract or remove. For
example, in my "Don Pepe" menu cards, I wanted a copy of the small card
graphics on the menu in a new layer. First, I made a copy of the layer
containing these images, and then used the Magic Wand to select the
white background area on the menu. This causes all non-white objects
(text and card illustrations) to become surrounded with selection lines.
Clearing the selection (Ctrl-K) left me with the graphics I wanted on an
invisible (alpha channel) background. Since the wand selects all colours
that are *almost* the colour of the selected pixel, it allowed me to get
rid of the entire original background, even though there was some
variation in the colour. Once the background was eliminated, I just used
the "Rectangular Selection" tool to select the german text and then
clear it from the layer. New layers were then added for (1) english
replacement text, and (2) a white background underlayer, to complete the
design.

b) Sometimes the Magic Wand isn't the most suitable tool. Because it
selects by filling outward from the selection point until it reaches
different colours, it is less useful when you want to remove a colour
where some of that colour is in enclosed areas. For example to remove
black text from a white background, you might use the magic wand to
select the white background, then invert the selection (Ctrl-I), and
clear it. This will not only remove the black text, but also the
background areas enclosed in letters like "D", "B", etc. If the
background had a pattern you were wanting to preserve, this would not be
as good as just getting rid of the black text. To do that, use the
"By-Color Selection" tool to select just the black text, and then clear
it. This will preserve as much of the background pattern as possible,
including areas within each letter. For an example, note that the
"Piratenbucht" cards have parchment scroll backgrounds covered with
german text. Since there were no extra blank cards, it was necessary to
remove the original text from the scroll, and then repair the background
before superimposing a new english text layer. The By-Color selection
tool minimized the amount of background I needed to re-paint (using the
"Clone" tool, btw).

5. You'll want to add layers containing new text in your language to
substitute for the original. Usually, I try to exactly replicate the
original german cards, and this involves tracking down the matching
fonts. There's a really handy free online tool called "What the Font!"
available at http://www.myfonts.com that's incredibly useful for
identifying the fonts used on the original card. Just prepare a sample
text image (.jpg format) using the GIMP, and upload to the site, and the
service will match the fonts to its database; it works very well! For
example, I found that the title font for the Wallenstein cards was
'Medieva E+F' using this technique. Of course, then you'll need to get a
copy of the fonts and install them...

To use "What the Font!", you'll need to prepare a clean, black & white
sample of the font you're trying to match. To do this, just use the
GIMP's rectangular selection tool to choose a text area in your image
that contains a few typographically distinctive letter designs. Copy
this selection to a new image, then use the By-Color selection tool to
select either the font itself or the background (whichever is
monochromatic). Then, you can use the Edit - Fill with FG/BG Color tool
to replace the selection with one colour. Invert the selection, and then
fill with the other colour. You now have a clean 2-color font sample
that will be easy to match using "What the Font!". Save it as a .jpg
image, and then upload it to find the match.

6. Once your cards are finished, create composite .png or .jpg image
files by 'flattening' the image to a single layer and saving in the
portable format (of course, you'll want to keep your editable versions
'unflattened', and have them saved in the GIMP's native (.xcf) format,
in case you decide to rework the cards at a later date.) If file size is
not an issue, use the .png (Portable Network Graphics) format, rather
than .jpg, as PNGs (like GIFs) use a lossless compression technique that
preserves every detail of your .xcf image. Note that if you decide to
prepare PDF files from your finished sheets, the embedded .png images
will be converted to .jpg anyway, so there is no advantage to
prematurely using lossy compression (jpg) if that's how you plan to
distribute your finished designs.

7. Switch to xfig, or equivalent. Start by using the rectangular box
tool to create a narrow black border 1/4" or 1/8" from the edge of the
sheet -- this will be used to match the front and backsides of the cards
after they are printed (see attached README.TXT). Note that work in xfig
is also done in LAYERS (actually levels). Your lowest object should be
this black box outline, and then build up the image from there. Here are
the levels I used for "Wallenstein" (higher number is bottom, lower
numbered levels get superimposed):

250 Border 
200 Cut Lines 
150 Card Graphics (.png/jpg images, prepared using the GIMP) 
100 Card Borders

8. Create a grid of grey, dotted 'cut lines' that will be used when
cutting out the finished cards. To determine where to place these, start
by creating one horizontal and one vertical line, then edit these to use
the correct coordinates for the first lines (see below). Use the
horizontal and vertical copy feature to duplicate these cut lines as
needed, then edit the coordinates of all the lines so they are correctly
placed.

Note that every object's location in xfig is defined in 'fig units'
which are 1/1200". Knowing the size of the outer edge of each card in
mm, convert this size to fig units, and then use some simple arithmetic
to determine the correct corner points for each card on the grid. You
then manually edit your borders, lines, and the placement of graphics to
match these calculated positions.

9. Embed the top-left card image into the xfig figure by using the
'photo' tool. Manually correct the coordinates of the image to provide
the correct placement.

10. Use the round-cornered box tool to superimpose a card border over
the graphic. Again, calculate the correct coordinates & adjust. Unless
the card design has specific requirements, it is usually a good idea to
create 1/8" wide white borders with an outer corner radius of 1/4". That
way, the designed corners will precisely match those that can be created
using the type of corner rounding punches that are commonly available
(Marvy CR-S, etc.). A radius setting of '15', and a thickness setting of
'10' will create a border having these characteristics.

11. Use the "grouping" tool to combine the border, image, and any other
objects that represent a single card into a single xfig object. Use the
horizontal/vertical copy tool to dup this card repeatedly onto the
sheet. You can then place each card in the perfect positions by editing
the corner points to match your grid. I often find it easier to copy one
card to every box on the grid, and then ungroup each of these and change
the photo to the correct one for the card. You can also save time by
creating a correctly placed row or column of cards, grouping that, and
then copying duplicates of that row/column across the sheet.

12. Once the sheet is finished, you can either just print it out, or
export it as a postscript or pdf file. I've found though that it's
better to create a .ps file, and then use a command-line tool called
'ps2pdf' to create pdfs; you may not be able to do this with MS-Windows,
though. When printing/exporting your sheets, it is a good idea to
disable the level that contains the cut-lines (you did put these on a
separate level, right? :-) when printing the card *fronts*, as only the
black border line is used for alignment. If you've done everything
correctly, you'll get a perfect match without having any (potentially
mismatched) cut-lines to appear on the card faces. 

Note that I usually start by creating the 'cardback' sheet (which
usually has a single repeated design for all the cards), then save that
again for the card *fronts*, and edit to use the correct graphics. If
you centre-align everything on the page, the card placements should be
exactly the same for the front and back sheets, which saves a lot of
time.

13. One very useful feature of XFig is that the files it creates are in
an editable text format. Knowing this, you can often save a lot of time
when creating multiple sheets of cards. First, create a single sheet
using the XFig design tools. Then, copy the .fig file from the first
sheet (which has all the correct placement information) to new files,
and edit these manually with a text editor. You can, for example,
quickly replace all the embedded filenames from the first sheet's card
graphics with the correct filenames for images on the second sheet.
Then, if you load this file into XFig, you'll have a completed layout
with the correct graphics in precisely the same placements, all without
ANY additional visual editing!

14. When your designs are finished, you can export them from within XFig
to a wide variety of formats: PostScript (.ps) and Portable Document
Format (.pdf) being most useful. Although you can create .pdfs directly
from within XFig, I have found that better results are obtained by just
saving the image as a .ps file, and then using the command-line 'ps2pdf'
utility (included with GNU GhostScript) to create the finished .pdfs

15. Done! Upload the results (.pdfs) to BoardGameGeek to share with
others.


I know all of the above sounds somewhat involved, but it's really not as
hard as it sounds -- there are lots of steps that can be done only once,
and then reused for all the cards in the set, depending on the amount of
variability there is in the original design. Experiment and have fun!

Good luck! I hope you find this information helpful.

--
Norman Petry, 22JA04 
