Chris’ Feedback on Campaign Puppets

I emailed Chris Crawford to get his feedback on my Campaign Puppets game idea. He replied that the design had several problems:

  1. Previous games of this type have failed.
  2. Vague or unknown voter preference algorithms make scoring and victory determination difficult if not impossible and/or reliant on chance.
  3. Large icon vocabulary increases player confusion.
  4. How do you show relationship between words, i.e. grammar
  5. Large vocabulary leads to problems with language comprehension algorithms

Chris raises some very good points which I’ll try to start addressing below.

Prior Failures (#1)

Previous games in this genre have appealed to a niche audience, those interested in political elections, and focused on resource management–opening campaign offices, running ads, raising funds, giving speeches–and moving the candidate between the states to raise your poll results.

Campaign Puppets focuses on “People not Things,” specifically on the primary candidates and the one area where their direct actions can affect their campaigns–the candidate debates. The game will still appeal to a niche audience (though the debate audience might be larger than the campaign manager audience) and the focus is on conversation which, in today’s political climate, includes trash talk.

There are many more things that have to be done before it can be determined if this design can be judged a success of a failure (some of which are listed below). Right now Campaign Puppets looks like an interesting experiment. Several things need to be hashed out before it can become a reality.

Voter Preference Algorithms (#2)

I haven’t even thought about this until Chris mentioned it. My previous attempts to create polling algorithms for Camelot were incomplete but reviewing them gave me an appreciation of how difficult this work might be.

For Campaign Puppets I want a real-time display of candidate rankings during the debate. At the end of the debatewinner, which means the electorate believes that they should be the party’s candidate in the general election.

IMG_0006 43%
IMG_0007 22%
IMG_0008 17%
IMG_0009 13%
IMG_0010 5%

In order to do this I’ll need to know how candidate reactions are affecting the electorate which means I’ll need an electorate population with positions on certain issues.

I’ve got some ideas building on my previous work (see the link at the beginning of this section). I’ll write up another blog post specifically addressing this issue.

Large Icon Vocabulary (#3)

The icons displayed in the inverse parser are not the final icons but merely placeholders. They’re there to give the player an idea of how and where they’ll create a candidate’s responses. At this point I don’t know what the final “words” will be or how many there will be.

Whatever the final word count turns out to be, I believe that an inverse parser will reduce confusion since it puts the player in the driver’s seat, allowing them visually construct sentences from only the appropriate words for that particular part of the sentence.

Here’s an example of an inverse parser in action creating a sentence from the Storytron version of Siboot.


  1. You’re given a list of valid choices for the sentence’s Verb.
  2. You’re given a list of valid choices for the sentence’s Direct Object (in this case it’s characters who aren’t at the current location).
  3. Piece by piece you construct a complete sentence from only valid options. Here we’re about the select the final word of the sentence before having the character “say” it.

The video below shows the Storytron Siboot inverse parser in action. You’ll see how easy it is to undo previous selections as your mind changes and that at no point should the user be unclear as to what options they can select.

This video of Chris’ work on the latest incarnation of Siboot shows how the same type of inverse parser would work with icons.

Grammar (#4)

Grammar is the syntax and structure of a language. In Storytron the language was sentence-based, with each sentence being composed of a Subject, a Verb, and one or more storyteller-configurable WordSockets. Here’s an example, the “offer to reveal” verb illustrated in the inverse parser above.


The focus in Storytron was conversations between characters. Campaign Puppets is more about swaying an audience, about rhetoric and debate. But it still boils down to what does the candidate say in reply.

I’ll have to give this some additional thought and see what the verbs might be which will help me determine whether candidate replies can fit into the Storytron sentence model (which is quite flexible) or whether I have to invent something new.

Language Comprehension Algorithms (#5)

Teen Talk had a very simple language–”X says that s/he likes Y by amount Z”–and the code behind that language reflected it’s simplicity. The code to parse a Candidate Puppet statement might be several magnitudes larger but I won’t know how much until I’ve done some additional work.

Posted in Side Projects | Tagged | Leave a comment

iPhone Screen Mockups

Some quick iPhone mockups. Some redesign is definitely in the works since the smaller screen sizes will affect visibility and gameplay. This is just a first pass.



Posted in Side Projects | Tagged | Leave a comment

Campaign Puppets

Over the years I’ve played many computer games about US presidential elections, games like Doonesbury Election Game: Campaign ’96The Political Machine, and President Forever. They were entertaining but ultimately degenerated into a state-by-state resource grind. In 2012 I started development on an iOS game focused on the Republican primary elections but I wasn’t able to come up with a design that satisfied me.

On November 26th I watched my first Republican debate of the 2016 primary season and I was appalled at what I saw. I’ve heard about the tenor and tone of the prior debates but I didn’t believe it had reached this level until I saw it with my own eyes. The candidate interactions were anything but presidential, the moderator couldn’t stop the candidates from abusing the format (I don’t know why they don’t turn off their mikes when they go over their time limits), and the whole event made me sad about the direction our political process is heading (I fear the movie Idiocracy is strangely prophetic).

But the whole event did give me an idea for a US presidential election primary computer game for smartphones and tablets that might tap into today’s political zeitgeist, be somewhat entertaining, and let me expand on some ideas I first implemented in Teen Talk. The goal of the game is to win your party’s nomination in a series of debates. The topic is US politics. The gameplay should reflect the conditions of a real debate where one misstatement can bring you down in the polls.

The entire game is played on one screen (see my Entire Game on One Screen post for why I’m going with this design).


On the right side are the candidates (A); on the left are the topics they’ll be questioned about (B). The topic list is scrollable since their will be more topics than can be displayed in the available area (same for the candidate list if necessary).

At the top are the panel of reporters who’ll be asking the candidates questions (C). The reporter’s questions and candidate answers appear in the conversation area (D) and scroll off the top of the screen as time goes by (you can scroll up to see previous dialog).

Candidate replies and interjections are created using the iconic inverse parser (E) at the bottom of the screen along with the candidate and topic icons.


Reporter’s questions are asked in iconic statements. The mockup question below uses, from left to right, top to bottom, the following icons – Trump Iran Favor/Agree Strong Attack/Offense Smart Nuclear QuestionMark (these are not final, just a quick mockup).

In the player’s mind my hope is that it translates into something like the English equivalent of “Mr Trump on Iran you favor a strong offense but is that smart given Iran’s nuclear program?”


The player replies using the inverse parser at the bottom of the screen as well as the candidate and topic icons. They could have the candidate say




or even


These are not the exact icons and statements that you’ll be able to create using the game’s rhetoric engine, just something I threw together using icons from The Noun Project. Also, the statements you can create might be a combination of icons, words, and interactive modifiers to indicate intensity and tone.

Some other gameplay elements that could be programmed in add a tag team wrestling flavor to the debate:

  • Your replies could be time dependent, you only have so much time to respond and any hesitation gives another candidate the opportunity to interrupt or sandbag you
  • Other candidates could interrupt you if your attacking them in their response (a candidate’s inclination to attack would be based on their individual personality traits).
  • Candidate ranking top-to-bottom could change to reflect public perception of who’s “winning” the current debate.
  • Changes in individual candidate traits could be displayed next to a candidate’s icon to give you realtime feedback on how your attacks against them are doing.
  • Candidate traits could be tied to realtime facial animation on candidate icons (examples here and here).

I’m going to give this some additional thought over the next couple of days, particularly while watching the next Republican debate on March 3rd.

Posted in Side Projects | Tagged | 1 Comment

Where’s George Modified Design


Here’s the original design for Where’s George


I’ve decided to modify the design to allow the app to handle more than one pet. The background color indicate a pet’s location (in the mockups below, green indicates outside while blue indicates inside).

Swiping a pet line item to the left displays the valid action you can take on that particular pet–if they’re outside the house coming in you can only select Out; if they’re outside coming back inside you can only select In.


To add a new pet you select the plus sign in the upper right. On the Pet Details screen you add a picture by tapping the square and type your pet’s name in the field below.


To delete a pet from the list you swipe to the right and tap the trash can (this left/right swipe control isn’t out-of-the-box Xamarin Forms so I’ll have to look into creating something).

Posted in Side Projects, Software Development | Tagged , , | Leave a comment

OnBelay Game Pieces

Some 3D printed pieces for a rock climbing game prototype I’m working on.




Posted in Other, Side Projects | Tagged | 1 Comment

Viand Sync Diary #4 – More Notes

Some quick notes  that I jotted down about syncing a single database between two app instances.

Each app’s database will have a unique ID

  • Generated at app startup if it doesn’t already exist
  • Where stored?

App Functions

  • Create Account – email, password
  • Sign In to Existing Account – email, password
    • Azure Accounts table – email, password (hashed), database ID

@1, pwd 1, ID A
@2, pwd 2, ID B

  • Share List
App Azure
@1 creates account @1 ID A
@2 creates account @1 ID A
@2 ID B
@1 shares ID A with @2 (needs @2) @1 ID A
@2 ID A
Database associated with @2 changed if @2 found

Need to flesh all this out more.

Posted in Side Projects | Tagged , , | 1 Comment

Viand Sync Diary #3 – Notes

Some “visual” notes on Viand syncing.

Viand - 3

Viand - 4

Viand - 5 Viand - 6

Viand - 7 Viand - 8 Viand - 9 Viand - 10

Viand - 11 Viand - 12 Viand - 13 Viand - 14

Posted in Side Projects, Software Development | Tagged , | Leave a comment

Viand Sync Diary #2 – Refreshing

Syncing data between the device and the cloud will happen at two times:

  • Automatically when the application starts
  • Automatically when the application comes to the foreground
  • Manually when the user makes the refresh gesture on either list

While I continue refactoring the application to add the automatic sync calls I’ve added a manual refresh gesture to the iPhone app. With Xamarin Forms it’s quite simple (like everything once you figure how to do it). Here’s the code that I added to the Buy list constructor.

buyView.IsPullToRefreshEnabled = true;
buyView.Refreshing += delegate(object sender, EventArgs e) {
	Device.StartTimer(TimeSpan.FromSeconds(5), SyncItems;

The Add list code is similar except I used a lambda expression instead of the C# 2.0 delegate syntax to call SyncItems.

addView.IsPullToRefreshEnabled = true;
addView.Refreshing += (object sender, EventArgs e) => Device.StartTimer(TimeSpan.FromSeconds(5), SyncItems;

For both lists the SyncItems calls the SyncItems method in ItemDatabase (which will perform the actual database syncing), sets IsRefreshing to false to end the refresh state, and then returns false to prevent the timer from recurring.

internal bool SyncItems()
	addView.IsRefreshing = false;

	return false;

Here’s how manual refreshing looks on the iPhone.


Since I’m using Xamarin Forms I get an Android-specific manual refresh indicator without any additional coding.


Posted in Side Projects | Tagged , , | Leave a comment

Viand Sync Diary #1 – Overview

My wife’s been using Viand for several month’s now with no major issues (there is one minor issue related to text size that I’ll have to fix before I push to the App Store).

The final piece is syncing so both of us can share the same lists on our respective iPhones. I’ve broken the implementation down into several steps.

  1. Sync a single Buy/Add list running on a single instance of the app with the backend database (My wife’s iPhone)
  2. Sync a single Buy/Add list running on two instances of the app with the backend database (My wife and my iPhones)
  3. Sync multiple Buy/Add lists running on multiple instances of the app for multiple accounts with the backend database (My wife and my iPhone; my mother-in-law’s iPhone)

I’ve decide to use Microsoft’s Azure for the backend because I’m familiar with the Microsoft stack, mobile services are free up to a point, and you’ve got to start somewhere.

It was relatively easy to create a mobile service (I chose to use the JavaScript backend because I want to use a tool that ubiquitous should I move into web development).


There’s an excellent post on the Azure site on how to get started with Mobile Services so I won’t duplicate the information here. Two caveats:

  • I’ll have to figure out how to sync my local data to the cloud first (The sample ToDo app starts off with an empty local database).
  • I’ll have to figure out how to add the asynchronous sync to my existing Xamarin.Forms code (the ToDo sample used UITableViewController instead of Xamarin.Forms).
Posted in Side Projects | Tagged , , | Leave a comment

What Makes Personal Computers Special?

While in the midst of cleaning out years of clippings and newspaper articles I came across a dot-matrix printout of the editorial below. I recall seeing it in one of the Whole Earth Software Catalog and Review magazines from the 80s but it turns out that was probably a reprint, it originally appeared in the August 1984 issue of Byte Magazine.

People sometimes ask me why there’s so much fuss about personal computers. Now that there are millions of them in the hands of ordinary people, personal computers are, in a sense, commonplace. Even enthusiasts may forget that personal computers are very special indeed. We would enjoy them even if they lacked practical applications and never overcame the digital indifference so often characterized as unfriendliness. To put personal computers in perspective, we should compare them with such earlier cultural watersheds as the printing press, the Industrial Revolution, and the automobile.

Because it made the production of books far more efficient, the printing press made it possible for more people to learn more than ever before. But while the printing press gave creative work a wider audience and eliminated the drudgery of scribes, Gutenberg’s technology did not directly enhance the creativity of the people who wrote books.

The Industrial Revolution made the production of goods far more efficient than ever before. The efficiencies of mass production made possible the accumulation of great wealth. Unfortunately, mass production also brought about cultural impoverishment of many workers. The assembly line deprived workers of the creativity that belonged to craftsmen— the stamp of individuality that went with good handwork. The Encyclopaedia Britannka puts it this way: “. . .the discipline of the factory (a discipline often imposed by strangers), the remorseless monotony of many of the tasks, and the physical hazard and discomfort of some of the new processes took a heavy toll.” Few would deny that the Industrial Revolution was, on balance, a good thing. But it did exact a great human price.

The automobile changed society for all time by broadening the experience of millions of people. The ability to travel quickly and widely enabled people to see more of the world and to judge it for themselves. The automobile’s influence resembled that of the printing press; while widespread book publishing extended knowledge, the mass production of automobiles extended experience. With broadened experience came wider choice in place and type of work. But the automobile did not directly enhance creativity; furthermore, the automobile was produced by the dehumanizing assembly-line methods introduced by the Industrial Revolution.

The personal computer disseminates knowledge, as the printing press did; increases productivity, as the Industrial Revolution did; and broadens experience, as the automobile did. In many applications, personal computers also reduce drudgery such as needless retyping and recalculation.

What sets personal computers apart, however, is their ability to enhance the creativity of the individual. They have justly been called “mind appliances” and “thought amplifiers.” They can help us manipulate information and ideas with remarkable freedom. Rather than forcing us all to work alike under the supervision of strangers, personal computers will let us develop our own unique ways of working. Rather than requiring personal sacrifices to achieve greater social goals, personal computers will contribute to the achievement of social goals by enriching the lives of individual persons. Programs like Bill Budge’s Pinball Construction Set, Bill Atkinson’s MacPaint, and Warren Robinett’s Rocky’s Boots offer glimpses of things to come.

Will personal computers make us all geniuses or saints? No. But they will help us make the most of ourselves. That is ample reason for regarding personal computers as far more than just another major consumer item.

—Phil Lemmons, Editor in Chief


Posted in Other | Tagged | Leave a comment