Those of us who play Invisible Sun remotely would often like to be able to share the various magic cards with our players. The PDFs of the game include the cards for printing out but are formatted 8 cards to a sheet there is no easy way to create individual images of the cards.

Although you could export the pages as images and crop them by hand, or take partial screenshots, the effort involved in making >1000 cards (especially once you add in the Book M cards) is substantial.

This is a tutorial to show you a few ways of making these cards for yourself and your players. The particular technique you use will depend on what technology you have available to you and that you are comfortable with but perhaps this tutorial will help you become more comfortable with these ideas. Everything I did here was the first time I had done any of it and I learned a lot in the process. Also, there are many other approaches you could take, and I am not claiming that these are the best by any means.

There is a lot here but there are 3 main methods presented in increasing order of complexity.

  1. Making card images using Adobe Acrobat
  2. Making unlabelled card images with command line scripting
  3. Making properly labelled cards with command line scripting

Important note on fan use and legality

A few very important notes first. It is not legal to distribute cards made with these techniques to anybody outside your play group. The MCG fan use policy does not allow you to distribute software that would do this automatically. I personally agree with the principles of the fan use policy and am enthusiastic about MCG’s support of community development of their games. With that said, don’t ask me to provide any of the outcomes of this material beyond what is here. This is a guide to doing it yourself. I hope that the techniques discussed here are useful for you in lots of ways beyond just playing Invisible Sun.

The structure of the PDF

The first thing to take note of is the structure of the card PDFs. The cards are laid out on US Letter size paper (11 in x 8.5 in) with 4 columns and 2 rows.

The pages have trim marks for when you print them yourself and have to cut them apart. They’re the little black lines along each side of the grid of cards shown in this image. (All the content of the images will be blurred and are demonstrative only to ensure this complies with the fan use policy.)

If you were to trim the cards, you would cut on lines corresponding to those trim lines so there is actually what is called a “gutter” between the cards. That is what you will get if you have the real Black Cube cards as well. This is because when you print the sheets of cards on a commercial printer and then cut them apart with the “die”, the sharp metal cutting template that will be typically custom made for these kinds of print jobs, the sheet of card and the die might not be perfectly aligned. The pages of cards are designed with a “bleed” or a region of colour that extends beyond the edges of where you would like to trim so if the die and paper don’t quite align, as they often don’t, you don’t end up with ugly white lines along some of the edges.

But for our purposes, we are cutting the images digitally so have as much precision as we want. That means we can just cut right to the edges of a region and we won’t have extraneous white borders. You can see the difference in this next image.

I opened the PDF in Adobe Illustrator, where you can get in and manipulate most of the parts of the cards. The blue rectangle you can see is where I selected a single card. The card is designed to that size but you can see the trim marks would make it a bit smaller.

So we’ll be cutting these apart corresponding to the full card size rather then the trim lines.

While I have it open in Illustrator, I can also see exactly the positioning of that blue box and so know the measurements for cropping. For example, the left and right hand edges have a 0.25 in border and the top and bottom have a 0.625 in border.

You can then go through and get all the other card border positions as needed, or just calculate them from knowing those left/right/top/bottom page borders.

The other aspect of the card PDFs to note is their overall structure. Page 1 is a cover sheet with instructions on how to print your own cards, Page 2 is blank, and then the rest of the pages have the card backs on the odd numbered pages and the card fronts on the even numbers. You can see it from the thumbnails:

Now, how do we get those card images made? There are a couple of options I have used and I know there are many more, probably including much more efficient ones.

Method 1: Manually cropping entire PDF documents (not the fastest but doesn’t require too much technical knowledge)

The general approach here is to crop the entire PDF to the size of one of the eight card positions and then export the pages as individual images. You then repeat that for each of the card positions. It’s not the fastest operation in the world, but it works.

The instructions I give here will use Adobe Acrobat but there are similar functions in many other PDF editing applications.

Before you start though, to try to save yourself some time, there are a few things to do. One is to always work on copies of the PDFs as you will be pretty rough on them and won’t get them back into original form!

Then, for this technique, we want to throw out pages 1-3 and all odd numbered pages after that, leaving just the card fronts. Just delete them from the document.

You might also want to consider compiling all the card PDFs into one big PDF as the time intensive part is still to come and if you can just do it eight times rather than 64 times, if you include all card PDFs form both the Black Cube and Book M, you’ll be much better off. You’ll need to do a little sorting of images after your done to split them into sets but that is relatively easy.

Adobe Acrobat has a crop function in its edit tools. When you open the edit tools, you can see it in the toolbar like this:

It’s not exactly obvious how to use this tool. Start by clicking on “Crop Pages”. At that point you could draw a rectangle around the part you want to crop to, but that won’t be precise. Better is to just double click anywhere in the document and you’ll get a dialog box opening up. In the next image, I’ve filled it out to show how it will look for the card in the upper left position.

The parts to pay attention to are the Margin Controls and the Page Range. In the Margin Controls, make sure you have the setting applied to “CropBox” and in the Page Range, choose “All” as it will default to just the current page you are looking at.

The values for the margins are measured in from each edge of the paper, not as absolute positions from one corner. So for the upper left card, the margin on the left is 0.25 in and top is 0.625 in, which we had identified earlier, while the bottom margin is 4.25 in measured from the bottom of the page (which would be the same from the top or bottom because it is the centre line of the page) and the right margin of 8.125 in is measured in from the right hand side of the page.

Calculating all of these measurements is a little bit of a pain for all 8 cards and it’s easy to make a mistake, so here they are for reference. All measurements are in inches.

Top Bottom Left Right
0.625 4.25 0.25 8.125
0.625 4.25 2.875 5.5
0.625 4.25 5.5 2.875
0.625 4.25 8.125 0.25
4.25 0.625 0.25 8.125
4.25 0.625 2.875 5.5
4.25 0.625 5.5 2.875
4.25 0.625 8.125 0.25

Once you make the crop, the entire PDF reduces to that card position on each page. You can then export the pages as images in whatever image format you want and at whatever resolution you want.

Something to note is that when you crop pages this way, you’re not actually getting rid of the rest of the pages, just hiding them. So one process you can use is to export the images, then undo the crop operation to get back to the full pages and then crop to the next card position, etc. That will save you having to start all over again. Or if you think you want to keep the PDFs of the individual cards, you can save them all, but the files will still be as big as the full card set as all that information is still there albeit hidden.

If you’ve done that, you’ll have a large set of individual image files saved with names that don’t necessarily mean very much but at least you have them.

Method 2: Making the images with scripting (more technical but much faster and more flexible)

If you feel comfortable using linux or the command line on either a PC or Mac, you can script the card creation using a couple of useful tools.

The general approach here is to export the PDF pages to images and then trim them to size, all using ImageMagick.

I’m going to give the instructions for a Mac, because it’s what I’m using, but the versions for other operating systems are almost identical except for installation of the tools.

To do the installation on a Mac, get ImageMagick and make sure you also have Ghostscript installed. This will do the install for you:

brew install imagemagick
brew install ghostscript

I am certain there are more efficient ways of doing the following but I’ll try to present it in a way that has some reasonably clear logic that isn’t obfuscated by compact but unreadable code.

I’ll show the code working on one page at a time and later wrap it in a loop that does the whole lot in one go.

The first step is to turn a PDF page into an image. I will be using jpg images as the quality is good enough for my purposes and there are so many files that they will take up quite a lot of space at a decent resolution.

The command you’ll want to use for this conversion is something like

magick -density 1200 cards.pdf[3] card_page_03.jpg

In this command, the -density option tells the conversion to happen at 1200 dpi (quite a high resolution!) and the3 in brackets after cards.pdf says to export page 4 of the PDF (ImageMagick, like much code, starts counting from 0 but PDF pages are usually labelled from 1). I have a corresponding 3 in the output filename card_page_3.jpg. I have assumed that the PDF containing all the cards is the original PDF with all pages intact but renamed to cards.pdf. I have chosen PDF page 4 (code index 3) in the example because it is the first page with card fronts.

Trimming the cards will happen in two steps to take advantage of some of the functions of ImageMagick.

First is to trim the borders from around the block of 8 cards on the page. This operation happens according to pixel counts so you might need to do some calculations depending on the resolution you choose for your card images. Some ImageMagick operations can be done in terms of fractions/percentages but this offset is not one of them.

The easiest way to figure out in general terms what the pixel dimensions of the crop should be can be obtained by calculating the fractional sizes of the borders. The 0.25 in on left and right amount to (0.25/11) = 0.022727 of the width of the page. The 0.625 in on top and bottom are (0.625/8.5) = 0.073529.

The card block is then (11-2*0.25)/11 = 0.95454 of the width and (8.5-2*0.625)/8.5 = 0.85294 of the height.

I’ve kept this many digits in the fractions so that when you do the calculations at your chosen resolution, you’ll come out to just the right number of pixels without any rounding issues.

If you chose to make the images at 1200 dpi, these then give you the left and right margin of 300 pixels, top and bottom of 750 pixels, and the card block as 12600 x 8700 pixels.

Now we can trim the image using something like this:

magick card_page_03.jpg -crop 12600x8700+300+750 +repage card_trimmed_03.jpg

The -crop parameters are the dimensions of the area you want to remain (the card block, 12600x8700 here) and the other numbers are the offsets from the left edge of the page and top of the page (+300+750 here). The +repage makes the output image just contain the cropped area. Without it, the output image would be the same size as the original but with everything outside the crop area just made white.

Now that we have the card blocks isolated from the borders, we can chop them up into the 8 individual cards. This command will do the job:

magick card_trimmed_03.jpg -crop 25x50% +repage card_image_03.jpg

The great thing about this command is that you don’t have to worry about pixel dimensions because you can specify the cards as percentages of the image (25x50% here). The other is that this command will break the image into tiles of that size so it will automatically create a set of 8 individual images, each named after the original with an automatic index added to the name. So in this case we end up with:

card_image_03-0.jpg
card_image_03-1.jpg
card_image_03-2.jpg
card_image_03-3.jpg
card_image_03-4.jpg
card_image_03-5.jpg
card_image_03-6.jpg
card_image_03-7.jpg

This is essentially where we want to be. If you ran the code exactly as I just gave it, you’ll have those 8 cards, each 3150×4350 pixels (~1.4MB each on my system).

To make this more useful, we now need to automate this for the entire PDF and get all the cards out in a useful form. The steps are to wrap this in a loop to cycle through all the pages of the PDF that include card fronts (ignoring the rest), renaming them all to be a little nicer to see, and then getting rid of the intermediate files we don’t need any more.

First the loop. Remember at the beginning we identified that the cards we want are every second page from 4 to the end? We’ll use that to define our loop, remembering that we have to count from 0 in the code.

numpages=64; for (i = 3; i <numpages; i+=2); do
    ### The stuff here we need for each PDF page
done

In this case, I’ve set the number of pages at the start to 64 to correspond to the Black Cube Ephemera deck PDF. You will want to change that to the number of pages of the PDF you’re processing, or you could just set it to the highest number you’ll use and ignore the errors that turn up when you run out of PDF pages but the code keeps running.

We set the value i=3 to indicate we want to start at index 3/page 4. We keep going while there are pages left, defined by numpages, and we count up two pages at a time (i+=2) to skip the card backs.

(And yes, I realise there are lots of different ways we could write this, but I think this is probably the easiest for beginners.)

To automate this process, we want to use the counter i to tell the code which PDF page to process. This means a little bit that is going to look confusing if you haven’t seen it before. But each line is a generalisation of the code I showed you earlier to do a single page.

First the PDF to jpg full page conversion:

magick -density 1200 $(printf "cards.pdf[%d]" $i) $(printf "card_page_%03d.jpg" $i)

In this line, we use 1200 dpi as before, but then use the value of i in the loop to tell ImageMagick which page of the PDF to use. That is in the section $(printf "cards.pdf[%d]" $i). The $(printf ...) wrapper tells the code to insert some text according to a pattern. The pattern we use is "cards.pdf[%d]" where the [%d] says to fill in an integer that comes next. That integer is $i, the value of the counter in our loop.

The next part defines the name of the jpg file we wish to output using a similar structure although this time it includes %03d which means to insert the next integer but force it to have 3 digits. (If it’s less than 3, it puts extra zeroes in front.) This makes processing things with code a bit easier in general.

But after that complicated looking line, you get a jpg for the page of the PDF you want each time you go through the loop.

Next we do something similar for trimming the page to the card block.

magick $(printf "card_page_%03d.jpg" $i) -crop 12600x8700+300+750 +repage $(printf "card_trimmed_%03d.jpg" $i);

We pull in the image defined by the loop counter, crop it to the card bloock and output it to a file called card_trimmed_###.jpg where the ### is the loop counter.

Now we break that card block into the 8 individual cards with this:

magick $(printf "card_trimmed_%03d.jpg" $i) -crop 25x50% +repage $(printf "card_image%03d" $i).jpg;

Note that when you do that the output filename for each card is defined by card_image###_&&.jpg where the ### is the page number and the && indicates the individual card number ranging from 0 to 7. That last index is added automatically by ImageMagick and you don’t need to specify it in the code.

And there you have it. Of course, it would be nice for things to be a little neater, so we can then bulk rename all the cards with something like this:

num=0; for i in card_image*.jpg; do mv "$i" "$(printf 'Ephemera%03d' $num).${i#*.}"; ((num++)); done

This just loops through all the images that have filename starting with card_image, and renames them with an index starting at 0 and counting up by 1 each time. In this case, I’ve renamed the cards to all have filenames like Ephemera014.jpg because this is for the Ephemera cards. (I also used the loop counter running up to 64 for the number of pages in the Ephemera cards PDF earlier. Those two things need to change for each card set.)

The last step is to clean up the intermediate files we don’t need any more. I was careful to name all intermediate files starting with card_ so that I can identify them and delete them without removing anything else. The code to do this is simply:

rm card_*.jpg

To stitch the whole lot together, we end up with the following code block which you can just copy and paste into your terminal window (although set the number of PDF pages 64 and the output filename 'Ephemera%03d' to what you need for the particular card set).

numpages=64; for (i = 3; i <numpages; i+=2); do
magick -density 1200 $(printf "cards.pdf[%d]" $i) $(printf "card_page_%03d.jpg" $i);
magick $(printf "card_page_%03d.jpg" $i) -crop 12600x8700+300+750 +repage $(printf "card_trimmed_%03d.jpg" $i);
magick $(printf "card_trimmed_%03d.jpg" $i) -crop 25x50% +repage $(printf "card_image%03d" $i).jpg;
done
num=0; for i in card_image*.jpg; do mv "$i" "$(printf 'Ephemera%03d' $num).${i#*.}"; ((num++)); done
rm card_*.jpg

The directory listing on my computer looks like this now, where you can see a list of cards (with a preview of the card to the right) and you can see the card pixel dimensions listed below the preview:

These aren’t labelled with the cards names but that is a more complicated problem addressed in the next method.

However, the card images you have are roughly in alphabetical order (not exactly because there are a couple of cases where the cards in the PDFs aren’t alphabetical, there are a couple of repeats in odd places, and the code listed pulls apart the images going down the columns on each page rather than across the rows). That means if you have some kind of thumbnail previewer you can pretty quickly scan down the list to find the card you want. And if you wanted to choose one at random, having the numbers there might actually be useful! Just choose a random number and grab that card.

Method 3: Automatically creating labelled images of the cards (the most powerful and automated but requires the most computing knowledge)

This method is the most powerful and conceptually easiest but it requires a fair bit more knowledge of computers. As such, I won’t be explaining it in as much detail.

The technique shown here is something I have done on a recent Mac using zsh on the command line, as is now standard. I’ll try to point out a few places where this might break down if you don’t have the same system but might miss some places.

The general approach is to crop the cards PDF into 8 PDFs, each with just a single card on each page. Then those PDFs can be analysed page by page to extract the text to produce a name for the file and then converting that page to an image file.

What you’ll need to have and to have installed:

  • The original card PDFs as part of your purchase of the digital Black Cube
  • Access to the command line on your computer, including zsh. (Some parts of this rely on zsh and won’t work on bash, but you will be able to convert it if you know a bit about those shells.)
  • Imagemagick (brew install imagemagick)
  • Ghostscript (brew install ghostscript)
  • Tesseract (https://formulae.brew.sh/formula/tesseract, should be standard on OSX)
  • pdfjam (https://github.com/FLEWID-AB/homebrew-pdfjam)
  • pdflatex (part of MacTex: https://tug.org/mactex/mactex-download.html)
  • pcregrep (should be standard on OSX)

Some of these might be already installed on your system, such as tesseract on recent Macs.

In all of the following, I’m going to assume you will work on the card sets one at a time and that the cardset you are working on has been renamed cards.pdf. I strongly recommend you work on a copy of the original PDF!

The first step is to crop the PDF just to include a single card on each page. So you’ll make 8 PDFs one for each card position. We’ll use pdfjam for this. The key aspects of this are setting the papersize to the final size of the cards we are making, and the trim values which are defined as distances from the edge of the page in order (left, bottom, right, top). The first of these is used for the first card position.

pdfjam cards.pdf --quiet --papersize '{2.625in,3.625in}' --trim "0.25in 4.25in 8.125in 0.625in" --clip true --outfile cards1.pdf

After this, you repeat the operation 7 more times but using the positions of each of the other cards on the page. So the whole set looks like this:

pdfjam cards.pdf --quiet --papersize '{2.625in,3.625in}' --trim "0.25in 4.25in 8.125in 0.625in" --clip true --outfile cards1.pdf
pdfjam cards.pdf --quiet --papersize '{2.625in,3.625in}' --trim "2.875in 4.25in 5.5in 0.625in" --clip true --outfile cards2.pdf
pdfjam cards.pdf --quiet --papersize '{2.625in,3.625in}' --trim "5.5in 4.25in 2.875in 0.625in" --clip true --outfile cards3.pdf
pdfjam cards.pdf --quiet --papersize '{2.625in,3.625in}' --trim "8.125in 4.25in 0.25in 0.625in" --clip true --outfile cards4.pdf
pdfjam cards.pdf --quiet --papersize '{2.625in,3.625in}' --trim "0.25in 0.625in 8.125in 4.25in" --clip true --outfile cards5.pdf
pdfjam cards.pdf --quiet --papersize '{2.625in,3.625in}' --trim "2.875in 0.625in 5.5in 4.25in" --clip true --outfile cards6.pdf
pdfjam cards.pdf --quiet --papersize '{2.625in,3.625in}' --trim "5.5in 0.625in 2.875in 4.25in" --clip true --outfile cards7.pdf
pdfjam cards.pdf --quiet --papersize '{2.625in,3.625in}' --trim "8.125in 0.625in 0.25in 4.25in" --clip true --outfile cards8.pdf

With this done, you’ll have 8 PDFS named cards1.pdf to cards8.pdf.

To make the script flexible, we’ll automatically determine how many pages are in the PDF so it will work on any of the cardsets without modification. This is an OSX-specific command so you could replace just set the number of pages manually if you are working on a different system.

numpages="$(mdls -name kMDItemNumberOfPages -raw cards.pdf)";

Now we’ll start crunching the PDFs. We’ll have two nested loops: one for the 8 card positions and one for the pages of the PDF. You could do this in any order but I’m doing the card position on the outside.

The first key part is to extract the text from a particular card using this line:

pdftotext -f $pg -l $pg $(printf "cards%d.pdf" $pos) cardtext.txt;

This tells us just to extract the text from page $pg from the file cards<pos>.pdf where <pos> is the particular position on the page, from 1 to 8. We save it in a file cardtext.txt.

Next we pull the title of the card from the file we just saved. This involves a few steps, mostly to make it look pretty. The important thing to note is that the card titles are in all caps and at the beginning of the text file.

First we extract any lines from the text that are in all caps, start with a letter, and contain only letters, hyphens, apostrophes and spaces. This will allow us to get all the titles using the punctuation that appears, and takes into account it could be multiple words spread over multiple lines. We restrict that checking to the first 6 lines of the text file as there are sometimes all caps lines at the bottoms of the files where the cards include references to The Path or The Way. This is the line:

cardtitleraw=$(head -6 cardtext.txt | pcregrep '(?m)^(([A-Z])([A-Z’ -])+$)+');

I won’t explain this as matching regex patterns are a whole world of black magic.

The titles look ugly in all caps if we want to use them as filenames as first we convert them to title case (first letter of each word is capitalised). Ideally we wouldn’t capitalise the minor words (a, the, etc.) but that is actually a complicated task so we’ll just pass on it. We also cause letters after an apostrophe to be capitalised but we can live with that or fix it manually later in a few cases.

The line that does this is specific to zsh so if you are using bash or some other shell, you’ll need to rewrite this is just accept all caps filenames. This is the line I mean:

cardtitleraw=${(C)cardtitleraw};

Next we take care of the fact that some titles are split across multiple lines and make them all one line.

Then we realise that some Object of Power cards have the first line of text as “Kindled”, “Artifact”, or “Relic” and so remove them. We also take out the word “The” if it’s the first word so that it is a little easier to find them in an alphabetical list. I leave initial “A”s though. I never claimed this is all perfectly logical and you can change these things pretty easily.

Now that we have a good title formatted nicely so that we can name the image, we create the image. That uses Imagemagick with this line:

magick -density 1200 $(printf "cards%d.pdf[%d]" $pos $pgindex ) $(printf "card_%03d_%d.jpg" $pg $pos);

The --density 1200 sets the jpg creation to happen at 1200 dpi from the PDF, just as we did in method 2. This gives card images are that each 3150×4350 pixels. We save those images with the name card_<page>_<pos>.jpg just in case something goes wrong with the title extraction. If we are satisfied that there is a title for the card (rather than the blank ones) and it was extracted properly, we rename the file with this:

mv "$(printf "card_%03d_%d.jpg" $pg $pos)" "$(printf "%s.jpg" $cardtitle)";

If you have any files left over at the end without a proper card name, you’ll know why – it will probably just be a blank card. The blank relics, artifacts, and kindled items will be named as such.

The only thing left to do is stitch it all together in a script and add one little display so you know how the process is proceeding. It will take a little while to crunch through all the cards, especially if you are doing this at high resolution. The process will show a . for each page of the PDF and repeat 8 times for each card position.

Here is the total script:

pdfjam cards.pdf --quiet --papersize '{2.625in,3.625in}' --trim "0.25in 4.25in 8.125in 0.625in" --clip true --outfile cards1.pdf
pdfjam cards.pdf --quiet --papersize '{2.625in,3.625in}' --trim "2.875in 4.25in 5.5in 0.625in" --clip true --outfile cards2.pdf
pdfjam cards.pdf --quiet --papersize '{2.625in,3.625in}' --trim "5.5in 4.25in 2.875in 0.625in" --clip true --outfile cards3.pdf
pdfjam cards.pdf --quiet --papersize '{2.625in,3.625in}' --trim "8.125in 4.25in 0.25in 0.625in" --clip true --outfile cards4.pdf
pdfjam cards.pdf --quiet --papersize '{2.625in,3.625in}' --trim "0.25in 0.625in 8.125in 4.25in" --clip true --outfile cards5.pdf
pdfjam cards.pdf --quiet --papersize '{2.625in,3.625in}' --trim "2.875in 0.625in 5.5in 4.25in" --clip true --outfile cards6.pdf
pdfjam cards.pdf --quiet --papersize '{2.625in,3.625in}' --trim "5.5in 0.625in 2.875in 4.25in" --clip true --outfile cards7.pdf
pdfjam cards.pdf --quiet --papersize '{2.625in,3.625in}' --trim "8.125in 0.625in 0.25in 4.25in" --clip true --outfile cards8.pdf
 
numpages="$(mdls -name kMDItemNumberOfPages -raw cards.pdf)";
for ((pos=1; pos<=8; pos++)); do
    for ((pg=4; pg<=numpages; pg+=2)); do
        pgindex=$((pg-1));
        pdftotext -f $pg -l $pg $(printf "cards%d.pdf" $pos) cardtext.txt;
        cardtitleraw=$(head -6 cardtext.txt | pcregrep '(?m)^(([A-Z])([A-Z’ -])+$)+');
        cardtitleraw=${(C)cardtitleraw};
        cardtitle="${cardtitleraw//$'\n'/ }";
        cardtitle="${cardtitle#"Kindled "}";
        cardtitle="${cardtitle#"Relic "}";
        cardtitle="${cardtitle#"Artifact "}";
        cardtitle="${cardtitle#"The "}"
        magick -density 1200 $(printf "cards%d.pdf[%d]" $pos $pgindex ) $(printf "card_%03d_%d.jpg" $pg $pos);
        if [ -n "$cardtitle" ]; then
            mv "$(printf "card_%03d_%d.jpg" $pg $pos)" "$(printf "%s.jpg" $cardtitle)";
        fi
        printf ".";
    done
    printf "*\n";
done

There are a bunch of ways this could be optimised but this structure should be relatively clear for people new to this (just like I am!) You could also modify in a few ways that could be useful. I also don’t do any file cleanup at the end but that would be easy to add or easy to do manually.

If you have followed this process, you could apply these techniques to then parse the full card texts to make a searchable, sortable database of magic. But that’s a bigger problem for another time.

Here is what your folder might look like with the cards processed!

Reminder

It’s important to emphasise that this is as much about showing you how you can automate processes as creating the cards and these techniques can be used in lots of different ways. Before I embarked on this, I had never used ImageMagick, had barely done any scripting on the command line, and didn’t know about how Acrobat could be used to crop images.

This tutorial depends on you having the legally acquired card PDFs, of course, and I won’t be sharing them nor the outputs from these techniques, and I hope that you won’t be either if you go through this process. It’s illegal and also limits our opportunities as gamers to have MCG develop more amazing content for Invisible Sun and all of their other great games.

Written by David Harris

0

Leave a Reply

Your email address will not be published. Required fields are marked *