Link: SJG Report to Stakeholders

Business information is not easy to come by in the tabletop games industry. Hence, any data that appears is highly to be prized by anyone who wants to make a living–or even a reasonable amount of pocket money–in board games. There’s a lot one needs to know, and much of it can only be learned by experience.

Fortunately for all of us, SJG releases an annual Report to Stakeholders. It represents a wealth of knowledge on topics ranging from marketing to management to production, and even on what a major player in the business sees as key industry trends. While obviously it’s not enough to be the foundation of a business plan, it’s still a great window into one company’s process.

As time has gone on I’ve had to become more interested in the business aspects of game design, for better or for worse. SJG’s reports are a valuable resource for the entire community of design professionals. They’re worthy of study.

Link: NYS Game Dev Challenge

If you’re a game designer in New York state, there’s a competition with substantial prize money slated to take applications beginning in early April. Frustratingly, this is one of those events where “game” implicitly means “video game”–but perhaps that’s based on what the funding was earmarked for. This might be a good opportunity for someone who’s (literally, physically) well-positioned . . . .

Finding Indie Games

Over the weekend a friend asked where I find indie video games. There are basically five sources I use:

Steam: The big dog of digital distribution. Lots of indie games are on Steam; unfortunately, Steam’s catalog is at this point so vast that finding them can be difficult if you don’t already know what you’re looking for.

The Humble Store: Some of the same content as Steam, but often at a different price point depending on who’s running a sale. It’s good to compare the two.

Itch.io: A storefront focused on indie designs. Games with cool ideas but which have not secured market interest–or which have no desire to seek market interest–often end up here.

Twitter: Following creators you’re interested in is a good way to find out when they’re releasing something new. This brings with it all the costs of social media, and it’s not for everyone.

Friends: The last but by no means the least. Many, many games are coming out all the time. Your friends know you, what you like, and what you don’t like but might find interesting nevertheless. Their recommendations are a great way to navigate the flood and pick out the content that’s best for you.

Notably absent from this list is Kickstarter. I’ve backed a lot of kickstarters, but I always find the ones I’m interested in elsewhere; there are a lot of games seeking funding, and it’s not feasible to scroll through all of them.

Unity: Debugging Infinite Loops

Unity’s Debug.Log has a singularly frustrating interaction with infinite loops: it stops working immediately upon entering the loop. My theory is that Debug.Log is designed only to output to the console at the end of a frame, so if the end of the frame is never reached messages never get written. Whatever the cause, this fundamental debugging tool is useless for working out what code is involved in the loop.

Fortunately, there’s an easy solution: write to a text file. Debug.Log messages won’t show during an infinite loop, but Unity will honor instructions to write to a file as it goes through code endlessly. By writing messages to a file instead of to the console, you can get the information you need.

Outputting text to a file is easy. Copy the following into a new script:

using UnityEngine;
using System.Collections;
using System.IO;

public class FileIO {

/// <summary>
/// Write a string to a file
/// </summary>
/// <param name=”fileName”>File to write to.</param>
/// <param name=”content”>String to write.</param>
/// <param name=”append”>If set to <c>true</c>, append. If set to <c>false<c>, overwrite file.</param>

public static void WriteStringToFile(string fileName, string content, bool append)
{

StreamWriter sw = new StreamWriter(fileName, append);

sw.WriteLine(content);

sw.Close();

}

}

You can then use it as follows:

FileIO.WriteStringToFile(“debug.txt”, “Animation begins”, true);

Write as many messages as necessary to determine what’s happening.

A few usage notes:

  • Don’t forget “using System.IO;”
  • Note that this class doesn’t inherit from Monobehaviour, so it can’t be attached as a component. That’s fine; use the syntax above to call the function.
  • By default, the text file appears in the Assets folder.

Here’s hoping this saves someone out there a little time and heartache. 🙂