Pricing Changes

It has been our pleasure to be your game manufacturer over the past nearly 5 years. We want to support you in everything we do. We’re constantly refining our processes, upgrading our raw materials, and equipment, and as a result our costs increase. After careful analysis we found we’ve been losing money on several items. In order to stay in business for another five years, we unfortunately find ourselves in the difficult position of raising prices on some of our printed components. 

Here is the complete list of changes:

  • Documents go from $0.45 to $0.65 per sheet.
  • Small, Medium, Large, Tall, and Tarot Booklets go from $0.82 to $0.98 per sheet.
  • Jumbo Booklets go from $0.99 to $1.10 per sheet.
  • Dice Stickers go from $2.75 to $4.09 per sheet.
  • Token Stickers go from $2.75 to $3.68 per sheet.
  • Small Square Mats go from $1.56 to $1.73 per sheet.
  • Skinny Mats go from $1.56 to $1.63 per sheet.
  • 18 Card Wraps go from $1.99 to $2.21 per sheet.
  • Medium Game Boxes go from $4.99 to $5.25 per sheet.

We realize many of you are working on entries for The Flux Capacity Publishing Challenge and these prices could hurt your entries, so we’ve increased the max cost to $44.99 to help make up the difference.

We are in the process of contacting those of you with outstanding Crowd Funding Manufacturing Agreements to negotiate a solution for those of you who have already launched your Crowd Funding Campaigns. 

Today we’d like to introduce you to a new type of product, the Small Score Pad. Score pads are used in games like Roll Through The Ages, Yahtzee, and Clue to keep track of complex scoring or problem solving. Our small score pad is printed in black and white, is full bleed, and comes in a variety of page counts 40, 60, 80, or 100, with the 40 page variety costing $2.99 and 7 cents per page after that. It’s designed to fit in the small pro box. Download the template and get started. Enjoy!

Today we’d like to introduce you to a new type of product, the Small Score Pad. Score pads are used in games like Roll Through The Ages, Yahtzee, and Clue to keep track of complex scoring or problem solving. Our small score pad is printed in black and white, is full bleed, and comes in a variety of page counts 40, 60, 80, or 100, with the 40 page variety costing $2.99 and 7 cents per page after that. It’s designed to fit in the small pro box. Download the template and get started. Enjoy!

If you’ve ever found yourself needing a compressed version of your PDF booklet/document to upload to The Game Crafter, then you may want to check out SmallPDF.com. I’ve used this service to convert PDFs from 25MB down to 1.7MB. 

Introducing Small Player Screens

Being able to keep some player information private is critical to some types of games. Now you can make it easy to keep info private using our small player screens.

The player screens are made of card stock, printed full color and full bleed on both sides, with a score down the middle to enable a hinge for folding. They’ve also got a 1/4” lean toward the player for additional privacy. And a graceful arc at the top for a nice little flourish. They measure 10 inches wide and 3.5 inches tall, and fold in half so they’ll fit nicely into a small pro box. They come 4 to a sheet for $2.79 per sheet. 

Download the template and get started today. Enjoy!

Better Bulk Pricing

Last week we announced bulk order fulfillment, and now we’re making it even better with better bulk pricing.

Due to our always ongoing efforts to improve our processes and technology, we’re able to offer better bulk pricing than we could six months ago when we last announced an improvement in our bulk pricing. We’ve improved our bulk pricing in the following ways:

  • Our new best price for games is 45% off. The old best price was 40%. That means a game with a cost of $20 will get an extra $1 off the best bulk price!
  • We are now offering our best pricing at only 400 copies. Previously you’d have to order at least 500 copies to get the best price. That also means that from 25 copies and beyond, the entire scale is getting better pricing. 
  • Several component types are now getting much better bulk pricing. They are:  Tarot Decks, Large/Small Square Mats, Quarter/Half/Skinny Mats, and all sizes of Booklets. So if your game includes those types of components, you may be getting a much better bulk discount than you were before.

With these changes in place, every single game in our system now has even better bulk pricing available.

Enjoy!

Tips for pitching to a game publisher.

Token / Dice Sticker Changes

Today we’re pleased to announce some exciting, and most likely controversial, changes to our token stickers and dice stickers. 

We’re now cutting them with a new process, which is far more accurate. The new print registration process we’re using has near pixel-perfect accuracy, so drift on these stickers, while still possible, is very unlikely. Any drift that remains should be less than 1mm. 

In addition, we’re now cutting down the large sticker sheets into poker card sized slugs. This change allows you to use token and dice sticker sheets with the small and medium pro boxes, and eventually even our tuck boxes will be able to be used with them. 

The sticker counts are also changing. Only a tiny hand-ful of games are actually making using of the 221 stickers provided on the current sheet. The new process is slower and more expensive, so cutting down the count is important to keep costs as low as possible. Therefore from now on the dice sticker sheets will only have 120 stickers per sheet. Also, 120 is divisible by 6 (for six-sided dice), which means you’ll have an even 20 custom dice per sheet. That should be more than enough for most games.

The token stickers are going to increase from 63 up to 72. This will help out those of you who like to sticker both sides of your tokens, because now you’ll have an even number of stickers. Also, 72 is sort of a magic number when it comes to games, because it means you can have an equal number for each player in a 4 player game (18 per player).

With these quality improvements, the price will be going up for both types of sheets to $2.75 per sheet. The price change has been reflected in all games with these sheets in them. 

The process we’re using to cut the stickers now is quite a bit more expensive that the old process. When we originally launched the stickers we were eyeing price over quality and flexibility. We spent the past 3 months polling our top customers to get their opinions on whether they would choose quality and flexibility in these stickers, or if we should keep the same process and cheap price. To our surprise, all people who responded to our survey were in favor of the change to the more expensive, but higher quality stickers. 

We realize that not everyone will agree with this change. We did not choose this path lightly. 

This change has gone into effect as of now. If your order number is 22311 or higher, then you have been automatically upgraded to the new sticker cutting process. 

Enjoy!

Proofing Helpers

Sometimes it’s hard to see when a game component has not been proofed, or if there is some other circumstance causing it to not be proofed. To this end we’ve added proofing helpers, a little orange info icon letting you know something needs to be done.

If you hover over the icon, you’ll get more detail about what’s wrong.

We hope this helps your game publishing process easier and more enjoyable.

Designing a Game Programmatically

I while back I talked about how I created Lacuna Expanse: A New Empire programatically. Today, I’m pleased to share with you how another user did it, using a different programming language. The following article was contributed by Alex Wolff (aka Supremacy in chat) of Wolfpack Studios

Designing a Card Game With C#

By Alex Wolff (Wolfpack Studios)

Ever wanted to create games, but weren’t the graphically talented type? Struggle to make stick figures that look like they were drawn by someone over the age of 5? Same here. I’m fairly certain my 3 year old nephew has more artistic talent than I do.

Fortunately, learning to progam can help solve a lot of these issues. Taking advantage of some of the tools in the C# .Net library, mainly System.Drawing, it’s pretty quick and easy to pop out something like a card game.

We can also do this with all completely free software!

The tools that I use are:

Visual C# 2010 Express

Paint.Net (Though Inkscape and GIMP are also options that you can use as well)

Getting Started:

While designing the actual cards programmatically is the end goal, first you will need to design a template using the graphics program of your choice.

Since I used TheGameCrafter to build, design, and publish my game. I’m going to start by using one of their templates. First, I open up the template in Paint.Net and put it on it’s own layer. This way I can start designing the rest without constantly having to check how it fits on the card template, and also to make sure that my finished template is the correct size for upload.

image

Next, I usually add in separate layers for each specific thing that I want to put on the card. These cards are really simple in layout, all they need is a background and some text to be put on them. Putting each piece on a separate layer might seem like more work up front, but if you ever need to make changes, it’s a hell of a lot easier in the long run.

I went with a very simple “terminal” looking background, consisting of green 0’s and 1’s on a black background. This requires absolutely no artwork and still fits the game’s theme. I created a new layer for the black background, filled it in using the Fill tool, and then created a new layer to put my 0’s and 1’s.

image


The 0’s and 1’s were created using the Font tool. I just used Arial font, 12 point. I listened to some music and tapped out random patterns of 0’s and 1’s for a few minutes, then copied and pasted the rest. Just for visual effect I tried not to repeat the same pattern over and over in an obvious way, so I inserted the copy/paste into the middle of itself a few times, and did some overlaying.

Next, per the card design, I wanted to add a layer to show where the card text was going to be. After playtesting and a few different designs, I settled on wanting the text to show on the top and bottom of the card, with a way to distinguish which way the card was being held. This allows the players to adjust to the way they are looking at the game board and makes it much easier for players to see what the numbers on their cards are as they hold them.

image


The final card template looks like

Now that everything is on the template that I want it to be, the next part is to save it off as a PNG file so that it’s something we can reference in our code that the library understands without too much trouble. In Paint.Net this is as easy and doing a Save As and selecting PNG in the format list.

image



Next is the fun part, the programming part… the part you probably started reading this to get to!

While a console application could easily do the job, I prefer to use standard WinForms applications to do my quick and dirty apps. They give me the control of a button, and when it’s something visual it allows me to do a preview before I create the entire batch.

In Visual Studio Express, I created a new Windows Forms Application project for my Bit Shift cards. I only have 2 controls, a button to fire off the card creation (appropriately labeled CREATE STUFF) and a Picture Box that I can use to preview what my final images look like after I’ve manipulated the template.

image



Warning: I’m well aware that my code probably doesn’t follow standard programming guidelines, best practices, and may possibly not make sense to anyone that isn’t me. Regardless, I’m going to show you what I did to get my cards created.

First, I created a reference to the template:

staticImage baseImage { get { returnImage.FromFile(@"C:\Users\Alex\Desktop\Board and Card Games\Bit Shift\Cards\PNG Files\BitShiftCardTemplate.png"); } }

Then, I needed a method that I would use to create the actual cards in an image based on the template.

staticImage DrawImage(Image baseImage, string textline1)
{
    var newImage = newBitmap(baseImage);
    var graphics = Graphics.FromImage(newImage);
    var line1start = newPointF(100.0f, 162.0f);
    var line2start = newPointF(100.0f, 798.0f);
    var cardFont = newFont("Quartz MS", 114.0f, FontStyle.Regular, GraphicsUnit.Pixel);
    var whiteBrush = Brushes.White;

    graphics.DrawString(textline1, cardFont, whiteBrush, line1start);
    graphics.DrawString(textline1, cardFont, whiteBrush, line2start);

    return newImage;
}

This method will take in a base image (our template), and then write out our card text to it on both the top and the bottom.

Because of certain difficulties with images and how they can be saved/handled, I had to first create a new Bitmap from the base image. Using the Graphics.FromImage method gives me a Graphics object that is what I use to actually manipulate the Bitmap contained on it.

Next I define line1start and line2start as the different PointF objects which are the start points for my lines of text.

Then I need to define the font and size that I want to use. Quartz MS gives me that nice “alarm clock / terminal” feeling, which fits the theme of the game really well, so I went with that.

Note: The sizes of the fonts, and the Point starts did not line up to what I originally tried to do in Paint.Net, so it required a lot of trial and error to get them right. This is one of the reasons that I included a preview on the main screen, so that I could adjust the numbers, run and preview, then adjust them again if something was off.

Since I want my font to be White text on the template, I define my brush using the built-in Brush.White.

The graphics.DrawString method allows me to draw a string directly on the bitmap image contained in the graphics file. Since it updates the Bitmap reference directly, we can then just return the new bitmap that we created. The Graphics library contains a lot of methods that are useful for drawing. You can draw other images, text, ellipses, rectangles. If you’re more artisticly inclined than I am, you could probably get a lot more leverage out of the Graphics library than I can.

Anyway… now that we have a method to put text on our templates, we have to tell the program what text we want and how many cards to create. This is the code for our CREATE STUFF button.

private void btnCreate_Click(object sender, EventArgs e)
{
    //Loop through the numbers and create the images, and then save them
    var savedImagesDirectory = @"C:\Users\Alex\Desktop\Board and Card Games\Bit Shift\Cards\PNG Files\";

    for (short i = 0; i < 256; i++)
    {
        var numAsBinaryString = GetShortBinaryString(i);
        if (numAsBinaryString.Where(c => c == '0').Count() == 4)
        {
            var newImage = DrawImage(baseImage, numAsBinaryString);
            newImage.Save(savedImagesDirectory + "Bit_Shift_" + i.ToString().PadLeft(3, '0') + ".png", System.Drawing.Imaging.ImageFormat.Png);
        }
    }
}

When clicked, the button will loop through all of the numbers between 0 and 255, get their binary string representation, and then create and save the images in the specified directory, with a name based on the number it represents.

Since it turns out that having 256 cards for all combinations was not only too expensive, but did not really make the game too fun, I trimmed down the automated process to only output numbers that contained 4 0’s and 4 1’s in their binary string. I then further cut them down and tried to remove ones that had all 4 0’s or 4 1’s all in a row.

The Image class contains a Save method that allows you to save it in any of the supported formats.

The following is a function that I found on the Internet that I adapted to meet my needs. It takes a number and converts it to a binary string. The original version was 32 bit, but I only needed 8-bit for my purposes. (While trying to remember where I got it to credit the Author, I found additional articles with much easier ways to do this… but still) Credit to the Author:

static string GetShortBinaryString(short n)
{
    char[] b = newchar[8];
    int pos = 7;
    int i = 0;

    while (i < 8)
    {
        if ((n & (1 << i)) != 0)
        {
            b[pos] = '1';
        }
        else
        {
            b[pos] = '0';
        }
        pos--;
        i++;
    }
    returnnewstring(b);
}

The final piece of the application is to display a preview of the card on the screen before it gets printed. I put this in the form initialization method. I was originally having some troubles so I put in additional debug information into a label on the screen as well.

public frmMain()
{
    InitializeComponent();
    var previewImage = DrawImage(baseImage, "01010101");
    pbxPreview.Image = previewImage;
    pbxPreview.Height = previewImage.Height;
    pbxPreview.Width = previewImage.Width;
    imgInfo.Text = string.Format("Height: {0}, Width: {1}, PhysicalDimHeight: {2}, PhysicalDimWidth: {3}",
    baseImage.Height, baseImage.Width, baseImage.PhysicalDimension.Height, baseImage.PhysicalDimension.Width);
}

When the application loads up, it should load up the template, create an image based on the “01010101” string, and then output it into my Picture Box on the screen to preview. Having the preview was invaluable to getting and tweaking the values for the line1start and line2start values in my DrawImage method.

When the application starts it looks like this: It shows our template with our sample text on it along with some property information. Once it looks good, I know I’m good to click the button.

image



Once the button has been created, the program does its thing and VOILA! Cards.

image



Since I had to recreate the cards a few times based on different template styles, the time it took me to develop the application was nowhere near the time it would have taken me to adjust all of the images every time I wanted to make a template change.

Next step is to upload them to TheGameCrafter and proof them. I’m currently in the process of creating a .Net wrapper around the TheGameCrafter API, but that is a work in progress and has no estimated completion date.

Questions, comments, praise, or other musings can be sent to Wolfpack.Studios.PA@Gmail.com

If you’re interested in Bit Shift, you can find the link to it on TheGameCrafter

By popular demand we’ve uploaded the ICC color profiles we use on our digital presses for your use. Assigning these profiles in your image editor of choice should get you just a small bit closer to having the colors on your screen match the colors that we print.

Please note that due to all kinds of variables outside our control, we still cannot guarantee color matching. We just want to afford you every opportunity to get it as close as possible. 

Game Editor Supports Vimeo

The game editor now supports Vimeo URLs just like it has always supported YouTube URLs. To make use of it, simply add a Vimeo video URL to your Game Description field, like this:

http://vimeo.com/40503001

It will be automatically turned into a video.

Likewise you can now use HTML entities in your descriptions now. So you can display a copyright symbol by using a code such as: &copy; 

Enjoy

We&#8217;re getting very close to releasing the new version of our web site. We recommend uploading a new backdrop and a transparent logo for the new site. As you can see in the photo above, the backdrop is going to be nearly fully exposed in the new site.
If you have not attached a logo to your game by the time we launch the new site your game will be unpublished from the site. Please don&#8217;t let that happen. Just prepare a logo and upload it. Your logo should be a transparent 24-bit png.
We recommend your backdrop be a compressed jpeg to reduce it&#8217;s overall file size.

We’re getting very close to releasing the new version of our web site. We recommend uploading a new backdrop and a transparent logo for the new site. As you can see in the photo above, the backdrop is going to be nearly fully exposed in the new site.

If you have not attached a logo to your game by the time we launch the new site your game will be unpublished from the site. Please don’t let that happen. Just prepare a logo and upload it. Your logo should be a transparent 24-bit png.

We recommend your backdrop be a compressed jpeg to reduce it’s overall file size.

Short Description

We’ve just added a “Short Description” field to all games. This will default to the same thing that is in your “Tag Line” field for now, but you should update it to reflect a one sentence description of your game. The short description will not be used in the current site, but will be used in the new site that we’re working on.