Andrew Scott reads Sol Lewitt’s April 14th, 1965 letter to Eva Hesse.
- Previous games of this type have failed.
- Vague or unknown voter preference algorithms make scoring and victory determination difficult if not impossible and/or reliant on chance.
- Large icon vocabulary increases player confusion.
- How do you show relationship between words, i.e. grammar
- 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.
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.
- You’re given a list of valid choices for the sentence’s Verb.
- 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).
- 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.
[INSERT VIDEO HERE]
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.
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.
Over the years I’ve played many computer games about US presidential elections, games like Doonesbury Election Game: Campaign ’96, The 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
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.
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).
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?
- 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
|@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.