Features and Considerations for Digital Board Game Conversion

Some Definitions

  • Conversion: The labor/effort involved in porting a game from a tabletop or “boxed” version to a digital platform.
  • Digital Platform: An environment where software can run. Possibilities include: mobile devices (iOS/Android), desktop (Windows, Apple, Linux), game consoles (Playstation, Xbox, Nintendo) 
  • UI: This stands for User Interface. Sometimes used interchangeably with “graphic design”, the user interface refers to the visual elements that make up your application. Typically an artist or graphic designer (or both) creates mock-ups of your UI in an early stage of the project and then the developers implement it, or “make it real” throughout the project.
  • UX: This stands for User Experience and is not to be confused with UI. The UX is all about the actions the user takes to accomplish various tasks or access the features of your application. UX for games (especially on mobile platforms) can be a bit more complex than non-game applications, and should be well thought-out either before, or early on in development. 
  • Costs: For the purposes of this document, this can mean time or it can mean money. Because you can convert from one to the other.

Basic features every mobile board game must have

  • Basic game playability – This essentially means the “engine” of the game. It’s nothing you can see, but represents the cost of implementing rules enforcement and game state.
  • Game UI – A basic game screen. Costs include UX considerations and graphic design as well as the implementation of that design. This can be entirely 2D (cheaper), or entirely 3D (which will look more like the physical version, but generally costs at least 2x), or a combination of both.
  • Menu screens – At least a “main menu” (before start screen), and in-game (pause) menu will be required. These are usually 2D.
  • Rules reference – At minimum this is just the rulebook of the game implemented as a screen in the application. (See Tutorials in optional features.)

Additional features


  • Pass-and-play mode – This is a feature where two or more players can play the game using a single copy of the application. Essentially the only cost of this is the amount of effort it takes to implement the UX and UI necessary to support the feature. (Typically fairly minimal, although it does necessitate a game setup screen.)
  • AI – This enables playing without an opponent. Costs can vary wildly for this feature, and there are many cost considerations and options just related to this feature. It is typically a fairly large portion of the cost of conversion, however statistics that I’ve seen show that most players are looking for solo play in their digital board game conversions. (If you do not have “play against an AI” in your list of features, many users, including some reviewers, will not even look at your application.)
  • AI Difficulty Tiers – Typically once an AI has been developed, it is not too difficult to make it play “better” or “worse” by tweaking some parameters.
  • AI “Personality” Tiers – This means implementing multiple “play styles” for the AI opponent. This is typically more work than tweaking AI difficulty. It is more noticeable/effective in some games than others.
  • Online Multiplayer – There are so many options and considerations here that I gave it its own section below.


  • Game Setup Screen – Depending on the game, this can be a required feature. This allows for the customization of the game before play begins.
  • Tutorials – There are a number of varying approaches you can take here. Simplest (and lowest cost) is a non-interactive or “step-through tutorial”, which essentially just allows the user to page through what amounts to screenshots of the application while highlighting the rules of the game as well as highlighting the actions the user must take in the application to play it. This is generally considered a poor tutorial experience for all but the simplest games. A more effective tutorial strategy is an interactive or “in-game” tutorial, guiding the player through an example game (or part of one), allowing them to perform some of the actions of the game while the rules are pointed out to them in a scripted sequence. Finally, a third approach is to allow the user to start playing the game right away, while seamlessly presenting them with “contextual prompts” that either tell them how or why to perform the actions available at any given moment. A blend or combination of all three approaches is also possible.
  • Music – Usually considered the minimum effort, a single musical loop is quite easy to implement, and will improve the user experience for some players significantly. An actual soundtrack is not usually cost prohibitive, however, and the true cost is that of the additional development time incurred in deciding when to start and stop playback.
  • Sound effects – Note that some lists would probably put music & sound effects in the required list. They are typically a very high cost to benefit ratio, and there are a not-insignificant number of users who will complain if your conversion doesn’t have at least some basic audio effects.
  • Settings – At minimum, you probably want to implement a mute switch for the aforementioned game audio.
  • Additional “static” screens – Typically these include things like: logo splash, a sales pitch for the physical game, or about the publisher. Costs here are generally fairly minimal.
  • Visual Polish – “Juice” is a game industry term that generally refers to how good the game “feels” to play. This is its own discipline, and a major part of almost all commercial game development. One way to think of it is to break down each of the actions you can take in a game and ensure that they have appropriate feedback for the user. (Usually some combination of both visual and audio effects.) Often it makes sense for these effects to have animations associated with them. Generally, the more pleasing the effect, the more the user will want to continue to play the game. Most video games incorporate quite a lot of these animations and graphical effects. This is not always the case for board game conversions, because the players can be counted on to be attracted to the physical game they already know (or know about). Put another way, these players are not playing because they saw a fancy trailer or because they saw a screenshot and decided the art looks amazing. That said, amazing art and fancy animations WILL absolutely help you sell more copies of the application, which in turn will help you sell more copies of the board game. Visual polish is unfortunately, very time consuming, and while some simple animations can be built easily “as you go”, generally the more animation and “juice” a game has, the more likely the developers spent a some amount of time after the development of the basic game on additional visual polish. This additional effort is referred to as “juicing” the game.


  • Statistics – A collection of metadata about the user’s game playing over time. Typical statistics might include: number of games played, win percentage, average score, etc. Each game usually also has some distinct things specific to it that can be collected into statistics. An example in Chess might be the number of pieces captured by your Queen. Usually for each statistic you can give at least two numbers, a total over all games, and an average per game. Statistics generally have three costs, the cost of collecting the statistics (generally there will be a list built up during gameplay, as well as a few that can only happen when the game is completed), the cost of saving the statistics (whether to disk or in the cloud), as well as the cost of displaying the statistics to the user elsewhere in the application.
  • Achievements – Often the statistics mentioned previously will be used to drive these, but your game might also suggest specific goals that can be made into achievements as well. You want each achievement to be a singular accomplishment that the user can take pride in completing. Most platforms have their own systems for achievements, and many of them require an image (or icon) to be associated with each achievement. If you are building a cross-platform application, you’ll typically want to build some kind of custom visual display (UI) for these yourself, as well as push them to the platform’s achievement APIs.
  • Leaderboards – These are rankings or ladders where players can compare their own statistics with other players’ statistics. The best platform implementations of this allow the user to see a filtered list of these comparisons against just their list of friends on the platform. All the major platforms have their own leaderboards. As with Achievements, if you are building cross-platform, one decision you’ll have to make is whether to allow users to compare themselves to users on other platforms. If so, this is a feature you’ll need to leverage your multiplayer server to create.
  • ELO or Skill Ranking – This is a number meant to represent the player’s skill in a particular game. It is generally calculated after every game, and in some games (Chess, especially) used to match players with other players of similar skill.

Online Multiplayer

Here are some important questions to consider: 

  • What kind of multiplayer gameplay? – The most common options are “real-time” and “asynchronous”. Asynchronous play (meaning both players do not have to be online at the same time to play against one another) doesn’t work for all kinds of board games, so the game itself may influence this decision. In general, it’s usually possible to develop an asynchronous implementation in such a way that real-time play is also possible, but not vice versa.
  • Where will you store the online games? – For all multiplayer, there is a server component needed. Here again there are a lot of options. Generally speaking, the easiest option is to use a 3rd party multiplayer service. (Some examples are PlayFab and Photon, both providing relatively “turnkey” solutions for Unity developers.) Many of these exist, and each have their own costs (as well as features and trade-offs) associated with them. Each of the platform holders also have their own multiplayer servers, but then you are limited to multiplayer opponents (and features) specific to that platform. Yet another option is to create your own “custom server application”, which allows for a lot more flexibility and some efficiency gains, but has a higher up-front cost.
  • Will you require an account? – You can do online multiplayer without accounts, but generally the user won’t be able to switch devices or recover the account if they delete the app and reinstall it. There are other limitations as well. Some server options (platform-specific ones especially) have accounts “built in”.
  • What kind of matchmaking? – Some examples of matchmaking: “pit me against a random opponent”, “invite my friends to a game”, “play a game with someone at my skill level”. Each of these has their own difficulties and feature requirements. Some options will not be available on all server types.
  • What social features? – Like matchmaking, which social features you chose to implement will have a lot to do with the capabilities that are available on whatever choice you made for your server component. Here are some examples: “allow the user to create a friend’s list”, “allow the user to react to another player’s move in some way without text (an emoji, for example)”, or “allow the users to chat with one another (text or audio) during a game”.


Anything above a straight fixed-price for purchasing the application (the fixed price could be free) is going to take additional development effort. 

  • Ads – I generally recommend against this approach to monetizing digital board games. You’ll need a significant number of daily active users in order to see any appreciable revenue (generally around 100,000), and there are significant drawbacks.
  • In-app purchases – These come in basically two flavors, although both flavors involve building some kind of UI, in addition to the costs associated with integration with the various platform (or separate payment platform) APIs. Some examples: 
    • 1) The most straightforward in-app purchase has a single-use. (Examples of this include game expansions, or sometimes cosmetics, for instance allowing the user to play on a different game board or with different color pieces.)  
    • 2) Another common in-app purchase is for “consumable goods”. Examples of this include coins or some other currency in the application that can then be “spent” on essentially whatever you like. Other examples include allowing the user to purchase hints (or undos) in a puzzle game, or tokens redeemable for additional multiplayer games, or any number of other consumable digital goods.
  • Subscriptions – This is a strategy that is gaining in popularity, but is not very common for individual games. All the major games platforms have a subscription service, and it’s worth noting that these platforms do solicit games to be included in their service. As of this writing, Apple Arcade is boasting about including over 180 games, and Google Play Pass says it includes “hundreds of awesome games and apps, completely free of ads and in-app purchases”.

Conclusion / About this post

I wrote the original version of this document many years ago. (At least 5, but that probably came from notes I’d made even earlier.) I was recently exchanging emails with a potential board game conversion client, and I mentioned that I had a list like this floating around. I made another significant revision before sending off, and decided to present it here. I’m sure it’s missing some things, and of course every game has its own considerations above and beyond the ones that are listed here.

Xcode tips and keyboard shortcuts

I love working in Xcode. It was my first “real” IDE experience, and while I still use vim pretty regularly it’s generally not for editing code (anymore). These days, whenever I’m not working in Xcode (lately it’s almost always Visual Studio on Unity projects), I’m wishing I was.

I read iOS Dev Weekly (https://iosdevweekly.com/) most weeks, and it was via that lovely resource that I discovered this great GitHub page full of Xcode-Tips (https://xcode-tips.github.io/). I already helped include one tip there (about enabling spell-check), and this post is inspired by one of the tips I found there in particular, about using `cmd-shift-j`. 

Xcode is a 3 panel layout. The middle panel where you actually edit code can be split up in a number of ways, (tabs within tabs? c’mon), but I won’t go into that in this post.

The left panel is called the “Navigator”. It has tabs across the top and defaults to the first tab, or “Project Navigator”, showing all the files in your project hierarchy. 

  • Filesystem tip/aside: When I first started using Xcode I was surprised to learn that files presented here are not necessarily 1-to-1 with the files on the filesystem. On one of my current projects, we are using the awesome open source XcodeGen (https://github.com/yonaskolb/XcodeGen) to generate the project from files on the filesystem. It’s actually called from a script that we run from a git checkout-hook, so we almost never have to think about it. This was a new-to-me workflow, but has a lot of benefits, including keeping the project files consistent with the filesystem!

Keyboard shortcuts relevant to the navigator:

  • Hide (or show) the whole Navigator pane with `cmd-0`. (That’s a zero.)
  • Jump to any of the tabs in the navigator with `cmd-<number>` where number is the index of the tab. So `cmd-1` opens the Project Navigator. This works even when the Navigator is hidden!
  • Best of all, the aforementioned `cmd-shift-j` will open the Project Navigator and select the file you are currently editing. You can then use the up or down arrows to browse different files, and `cmd-j` and then `enter` to return to the code editor.

The panel on the right side of Xcode is the Inspector. It too has tabs, and what’s great is that the keyboard shortcuts are very similar to the ones for the Navigator, but with the addition of alt:

  • Show/Hide the Inspector with `cmd-alt-0`.
  • You can also jump to one of the tabs with `cmd-alt-<number>`, again, where number is the index of the tab. What’s interesting here is that there are a different number of tabs here if you are editing an interface builder file. (I don’t think I’ve ever used these shortcuts.)

In general, I am far more likely to want to hide the Inspector pane than the Navigator pane, so it’s kind of a shame the shortcuts to show/hide them aren’t reversed (not to mention the fact that cmd-alt is a difficult combination on my Moonlander keyboard, but of course I could fix that).

I wrote this up in part so I can create another PR and reference myself as the source for a tip about showing and hiding these panes, but this post was also inspired by sharing with another member of my team that I do the majority of my development on a MacBook, without external monitor. <insert scream emoji> One of the aspects that makes that experience tolerable are all these keyboard shortcuts that let you maximize the space you’re using to edit code quickly and easily.

I hope you learned something from this, but if you didn’t, go check out that Xcode-Tips site, because you’re sure to learn something there!