Author Archives: Martin

For The Win app — relaunching soon & app store rejection

Posted on by

003.ftw_splash@2xSo I mentioned in a previous post that the For The Win app I worked on for Tasty Minstrel Games was removed from the app store, (embarrassingly right before I spoke about it at GDC). When I emailed Michael at TMG, he revealed that it was just not making enough money to justify paying the $99 to apple to keep it there, and he was happy to let me put it back in the app store under my own account.

So I spent some time last Friday and updated it for iOS 7, fixing a few minor cosmetic bugs here and there, finally submitting it around the end of the day.

Long story short, Apple rejected the app, for the following reason: “11.1: Apps that unlock or enable additional features or functionality with mechanisms other than the App Store will be rejected” They clarified with the following statement: “We found your app inappropriately unlocks or enables additional functionality with mechanisms other than the App Store, which is not in compliance with the App Store Review Guidelines. Specifically, your app allows users to unlock avatars by subscribing to a newsletter, following on Twitter, or liking on Facebook.”

Okaaaay… So a couple of reactions: 1. Obviously, this functionality was approved in the original app. But maybe they just didn’t catch it then. And 2. Doesn’t like every 3rd game in the app store do this? I mean, seriously, I see games giving extra currency for FB likes or even just twitter comments ALL THE TIME. Doesn’t candy crush unlock each level pack with Facebook interactions? (Although now that I think about it, those interactions take their friends back into the app, which is maybe how they get around this issue.)

Alright, so my arguments probably amount to “But everybody else does it!” I’ll be making some changes to just give everyone the avatars all the time (and probably re-word the achievements) and upload a new binary… probably sometime later today.

Oh, and by the way, since the app was in the store for about a year, and presumably some people paid for it in that time, I’m just going to put it up again for free. So the folks who downloaded it before can get it again without having to pay. I am considering adding the following functionality in an update: making it Universal, and asynchronous multiplayer. If and when I do that, I’ll probably shout about it some, and then make it paid again.

GDC 2014

Posted on by

Since I posted last year’s GDC badge, I figured I’d do it again. Be sure to scroll down for some of my thoughts about the conference this year, as well as being a speaker for the first time.

20140328-115954.jpg

Being a speaker at GDC was definitely a double-edged sword. All bets are off if I get any consulting work out of it, but if you break down how long I spent preparing for my talk, I definitely invested more of my time than the cost of GDC admission. On the other hand, there were certainly less tangible benefits as well. I got to go to the speaker party, for instance, which was really only “valuable” in terms of meeting other speakers and making some industry contacts. I spent quite a while there talking to Chris DeLeon, for example, who runs Hobby Game Dev. (I finally decided to check out his site, and got completely sucked in, btw. Be careful, there’s so much content over there you can easily lose an afternoon!)

A bit about the process of being accepted as a speaker: When my talk was provisionally accepted, the organizers made some suggestions for directions they’d like to see the talk evolve, and made it clear that my acceptance was contingent on those changes. I (of course) had the opportunity to bow out at that point, but chose to work with them and make it the talk they wanted rather than the talk that I’d submitted. I would definitely like to be a speaker again if I have opportunity to present something I’m very passionate about, but that revision process is not something I think I’d like to participate in again, not because it was unpleasant in any way, simply because it really sapped my enthusiasm for speaking. In this case specifically, my talk was initially not so much about usability, and while I think usability is definitely an important aspect of game development, it’s not a topic that I’m super passionate about. If I speak again, I want it to be something I can get fired up about. (Certainly mobile board games are a topic that fits that qualification, but specifically because that aspect of the talk was deemphasized, my enthusiasm also suffered.)

GDC, for me, has always been about soaking in as much of the panels and content as possible. Performance anxiety really put a damper on that goal (certainly on the day of my talk, but it had ripple effects the day before and after) so that definitely felt like another downside. On the other hand the added prestige associated with the speaker ribbon was a definite plus, especially in terms of talking to and meeting people I would not have otherwise.

The other big difference this year was that I attended GDC from the perspective of an igdatc organizer. I went to various meetings and talked to quite a few other chapter organizers from around the world. My take-away from this is that we are doing just the right amount of stuff, I think. There are definitely chapters WAY ahead of us in terms of volunteer effort and event planning, but there are also chapters that put in way more effort and have less events and fewer attendees. Our new Multiplayer Extravaganza series is humming along, and many of us are super excited to create our own local multiplayer games to showcase there.

Finally, the other thing that felt different about this year’s GDC was that there was a lot more opportunity to PLAY there. In addition to the IGF booth (that has existed on the show floor for years AFAIK), as well as the “doing it on the table” (boardgames exhibit that I believe was new as of last year), and GDC Play (which is a paid exhibitor space where you can show off your game), there was also: the Mild Rumpus, Indie Megabooth, alt.ctrl.gdc, and a Killer Queen arcade cabinet randomly positioned near the expo hall entrance. All these were welcome additions, and made for relaxing interludes that definitely helped with that speaker anxiety I previously mentioned.

I feel like this entire week has been “coming down” from GDC. (Which probably explains my high-frequency blog postings.) I definitely feel more energized about game development after this year’s GDC than I felt after last year’s. I don’t think industry events like GDC are required to be a game developer, but if you are developing a game, attending GDC will feel like a giant room full of 24,000 people with whom you already have something in common.

Primitives and Hex Primitives

Posted on by

As a sort of follow-up to yesterday’s post on small-grid games, I realized that I haven’t made this pair of games public anywhere yet. (That I remember.) That post led to some Facebook discussion, where we got to talking about hex grids, and I mentioned that I haven’t seen any small hex grid games… but then I realized that I had worked on a design for one on-and-off last year!

Primitives is a relatively simple game where you place a card or one of your makers, or otherwise manipulate the gameboard. (I believe the last rules I playtested said you could do one of those per turn.) Manipulating the board means you could change a single card without a marker already on it, either by moving, rotating, or flipping it. By claiming a card, you “lock” it into place, and subsequently receive points for its symbols (and any matching symbols on adjacent cards) at the end of the game. The point values are dictated by the symbols on the center of the cards, either plus (+1 point) or minus (-1 point). Each card is double-sided, so flipping a card means it will change that symbol from + to -, or vice versa. The game ends when everyone has placed all their markers and all the cards are out on the board. More playtesting is probably needed, but I may need a rule that says something like: “If only one player has markers remaining, they MUST place it on their turn, and if everyone has placed their markers, the only available action is to place a card onto the gameboard.”

The first version was played with standard playing cards in a hex-like configuration. But I realized I could get more symbol matching in there (and more rotation) if I switched to hexes for the cards themselves. I also went from six symbols to three, for essentially the same reason. Here are some photos of various paper prototypes.

Primitives (version #1)
20140325-145301.jpg20140325-142342.jpg



Hex Primitives (version #2)

20140325-142311.jpg20140325-142258.jpg



These games were inspired by my playing Love Letter for the first time, and wanting to design a game that used a similarly ridiculously small number of components. (Love letter is played with a deck of 16 cards. Primitives is played with only 7.) I may try and bring this game to a Game Designer Sessions meetup tonight or in the future.

A Brief Survey of Small-Grid Games

Posted on by

I can’t decide if I should write a GDC wrapup post, but I cobbled this post together from notes I sent to a colleague discussing 4×4 grid games, as well as my thoughts after seeing Asher Vollmer talk about Threes! at GDC.

All games are programmed on a grid of some kind. Fundamentally, even oddly shaped maps are generally reduced to a grid at programming time. But what I want to look at here are “games set on a smaller square grid”, presumably either 4×4 or 5×5 or maybe 6×6. This greatly reduces the search space.

There are games where the grid space contents move, and games where they do not. In the games where they don’t, you are still changing something about the grid, either marking a path or changing the state of the space in some other way. One category of games like this that comes immediately to mind are logic puzzles like nurikabe, numberlink, or nonograms. (I don’t think they all start with ‘n’ tho!) Another category might be games where you place specific pieces onto the game board, as in one of my favorite chess variants, Tic-Tac-Chec. Stacking games like Rumis might also qualify.

It feels like, at least in video games, games where you move the grid might be more common. The hole puzzle is, I think, the oldest. Although the ‘sliding a whole row’ mechanic is also pretty common, there was an early NES game called Yoshi’s Cookie that used that one. I am tempted to break these types of game down by mechanic and make a whole list. (This is the kind of thing I really like to do, and one of my favorite examples of thinking about mechanics is this cool family tree of matching tile games put together by Jesper Juul.)

Recently there has been a really interesting category of these games with a huge spike in popularity started by this game called Threes! launched recently in the app store. You can play it online too at http://threesjs.com/. There are now a ton of clones, and some of them have (slightly) different mechanics, creating a whole new branch of small-grid games. My favorite is this one called 2048, also playable online (though it appears to have not one but three app versions — no doubt because the original is open source). The main new mechanic here is that tile states “combine” to form a new more valuable state. An additional mechanic is that in Threes! as well as the variants I’ve played, the entire game board is moved at once, whether it’s only one space as in Threes!, or to their farthest empty position as in 2048.

I’m not doing a good job of remembering the details of Asher’s talk, but one was that in at least one previous version of Threes!, there were negative numbers. It’s worth noting that I haven’t seen a clone/version that adds those.

This is nowhere near comprehensive. Let me know what I’ve missed in the comments, thanks!

References / further reading:
https://en.wikipedia.org/wiki/Logic_puzzles
https://en.wikipedia.org/wiki/Category:Logic_puzzles
https://en.wikipedia.org/wiki/List_of_puzzle_video_games
http://boardgamegeek.com/geeklist/16754/games-played-on-a-4×4-grid

Usability Lessons from Mobile Board Game Conversions – Notes & References

Posted on by

I gave this talk at GDC (Game Developers Conference) 2014.

Update: Note that the talk was recorded, and you can now watch the video (and slides!) on the GDC Vault.

Here are some notes:

(The numbers below correspond with the side number.)

1. This talk was adapted from a previous talk I gave at Mobile March in 2013, titled Case Studies in Mobile Board Game Conversion (2013). That talk was much more about features of three games in particular, Carcassonne, Ascension, and For the Win.

2. This slide contains a screenshot from Doom (1993), the book cover for Masters of Doom: How Two Guys Created an Empire and Transformed Pop Culture (a book by David Kushner about id Software), and a movie poster for Indiana Jones and the Temple of Doom (from 1984):
Notably, it contains no gloom.
Notably, it contains no gloom.Notably, it contains no gloom.


4. I wanted to include a photo here of a glass bead game, or maybe glass chess set, but didn’t find a good one.

5. In case you haven’t played it, here is QWOP.

8. Arnold Lund’s Usability Maxims were first published in 1997. “Expert ratings of usability maxims. Ergonomics in Design, 5(3), 15-20. A study of the heuristics design experts consider important for good design.” @ArnieLund Oddly enough, this list of “maxims” used to appear on the Wikipedia article for Usability, but was removed before I gave this talk. (Not by me!) Here’s another site that has them: http://www.simonwhatley.co.uk/lunds-expert-ratings-of-usability-maxims

9. Unfortunately, as of this writing, the For The Win application created for Tasty Minstrel Games appears to be no longer available in the app store.

10. I mention here that Usability is a two-way street, even though it is generally thought of as the player communicating with the application, it is far more relevant what the application communicates to the player. This first section is titled “Usability Lessons for the Game Screen: Effectively communicating game information to your player”, and features the following recommendations / lessons, giving each its own slide.

  • Highlight possible actions.
  • Clearly show whose turn it is.
  • Always animate AI turns.
  • Hide “extra” information.
  • Provide linear context.

11. This slide features a screenshot from Ascension: Chronicle of the Godslayer, put out by Playdek.

12. The screenshot here is Carcassonne, by the Coding Monkeys, which I call out as the “gold standard” of iOS board game conversions.

13. Here is a screenshot for Day’s of Wonder’s excellent Ticket To Ride application.

14. More screenshots from Ascension and Carcassonne.

15. Here is another screenshot from Carcassonne, as well as, in the foreground, a screenshot from Suburbia, put out by Jeremiah Maher.

16. This introduces a brief section on gestures and the other half of the picture, allowing the player to communicate back into the game.

17. More Carcassonne and Ascension screenshots. I recommend you support both tap and drag when drag makes sense as a gesture. Tap and drag are the two gestures you probably don’t need to explain in detail.

18. Here is a screenshot from Playdek’s latest masterpiece, Lords of Waterdeep. I talk about other gestures that probably do need to be explained: double-tap, long-press, and swipe. As well as some classes of gesture that I recommend not using at all: Triple (or more) tap, and multi-finger drag/swipe.

19 & 20. I’m not sure I feel like I managed to get my points across about undo and confirmation buttons. Essentially, undo is a good idea, and if you have complex actions, you should always give your user a confirmation step. I guess what I feel less certain about having effectively communicated is WHY those are important. Screenshots from Ascension and Carcassonne.

22. Here is a screenshot from Reiner Knizia’s Samurai (developed by Conlan Rios), as well as another from Carcassonne and For The Win.

23. Screenshots here to illustrate Game Center’s GKTurnBasedMatchmakerViewController, from Reiner Knizia’s Qin, and Cafe International by Application Systems Heidelberg.

UPDATE #1: Here’s a direct link to download the slides: Usability Lessons from Mobile Board Game Conversions (9MB PDF)

UPDATE #2: (2014-03-24) I added additional notes as well as the original session description and takeaway from the GDC Schedule.

UPDATE #3: (2016-05-10) I added a link at the beginning of this post to the video recording of the talk, which is available to watch for free at the GDC Vault.

Session Description
Martin Grider looks at user interface specifics related to touchscreen ports of modern board games. He examines common touch interface paradigms that have emerged in the genre, making in-depth examination of some particularly good mobile board game conversions from the perspective of their UX and UI decisions. Martin also talks about working with Tasty Minstrel Games on the For The Win board game application for iOS in 2012.

Takeaway
The following questions are addressed: What interface elements and control schemes are useful for board game conversion? What UX paradigms apply to board game interactions in mobile, particularly as they apply to the game screen and multiplayer game creation screens? How do these lessons apply to all mobile game development?

Action Go “in action”

Posted on by

Here’s a video demo of my latest project, Action Go, in progress. I’ve got all the code from Go-Tetris (the flash version) ported, and capture / territory counts are updating correctly. Now it just needs a bit of visual polish, a way to switch between game modes, a help / tutorial screen, and maybe some GameCenter leaderboards and achievements. There are a lot of other things on my wishlist, like score multipliers when you make more than one capture/territory at once (super easy), or one I just thought of today — a bonus/multiplier for when you clear all of one color or, better yet, the entire gameboard.

Anyway, here’s the video:

Global Game Jam 2014 Postmortem

Posted on by

Screen Shot 2014-01-26 at 3.44.41 PMThis year’s Global Game Jam is over, and from my perspective it was a raving success. I took part with the other IGDA Twin Cities folks, as part of a relatively large team focused on making a local multiplayer game using Xbox controllers. (Click the image to read more about the project I worked on.)

The weekend began on Friday night with everyone “pitching” at least one idea for a game in front of the group. As there were about 40 people there, this took quite a while. Then people started splintering off into groups. I went into this year’s Global Game Jam with several “agendas”. (Incidentally, I probably wouldn’t recommend this for beginners, but this was my third year taking part, and at least my sixth game jam, so I felt it was okay for me to have some goals.) Here is a list of those goals, in order of importance to me, and whether or not I felt they were achieved:

  • Use Unity – Before this year’s jam, I had really only dabbled in Unity development. I’d watched a few tutorials, installed it a number of times, played around in a couple of sample projects. I went into this year’s jam with the intent of glomming on to someone else’s project who “knows” unity, so I could learn from them and hopefully make some contributions. Status: Wildly successful! I now feel like I know my way around Unity, and can at the very least make sense of projects when opening them. (This was not true before, as I had no idea where to look for things.) I could now easily make a Unity game on my own, and have some plans to do so in the not-so-distant future. All the developers on my team were experienced Unity developers, and I learned quite a bit over each of their shoulders.
  • Make a game using controllers for input – This was a secondary goal, for sure, but it turned out to be not-so-hard to find a group who had this same agenda. I have big plans for this year and multiplayer games, so I needed to have a better sense of what is easy or difficult about using controllers. Status: Definite success! I not only got a sense of how to “manually” implement controller input in Unity (watching on Friday night over Ryan Schaefer‘s shoulder), but then spent an hour or so mucking around with Patrick Hogan’s InControl project, and pretty easily got that working also. (We ended up not using it, because I had some problems initially, but I think they were local to my machine/setup.)
  • Make a “Candy Jam” game – If you haven’t heard of the Candy Jam, essentially, this is a game jam protest of King.com’s attempt to trademark the words “Candy” and “Saga”. There is a lot more information if you follow the Candy Jam link, but if anything, I think the case is not stated strongly enough. The problem is not just with King.com, the problem is with the system of trademarking as it applies to games in general. Similar to the way patents are given for too general concepts in the tech industry, trademarks on single-words are also far too general, and allowing them hurts the industry in my opinion. Anyway, I wanted to join this protest and contribute a game to the jam. Status: My teammates easily agreed, and this was a success also. (Note that we have not yet submitted the game “officially” to the Candy Jam, but that will happen soon!)
  • Design an “action” game rather than turn-based game – Designing a game definitely took a back-seat to my first two objectives for the weekend. I pitched a game idea I had on Friday, but it was pretty simple, and I’m not terribly surprised nobody seemed super excited about it. Then during the after-pitch process, I had a lot of design ideas for another “asymmetrical” multiplayer game. (4-players each with their own objectives for scoring.) I actually still think that idea has a lot of potential, but it was fairly complex. We ended up sorta waffling on what idea we were going to make, deciding we should all just get started, and work on independent “scenes” in unity. None of the games I helped make were my design, so I can’t really say this was successful. Status: Definitely thought about it, but ultimately did not achieve this.

As I mentioned, Friday night was pretty “unfocused”, but I still felt like it was worth it, because I got to learn a lot about controller input in Unity, and thus, also a lot about Unity in general. I was also instrumental in setting up version control for the project on Friday night, but I’m not sure that was a “success” really. I’ll say more about that in a bit. When I left around 4 AM on Saturday morning, there were somewhere between three and five independent “ideas” getting floated around our group, but only one (Bird Drop) had anything appearing on the screen. When I showed up again on Saturday, Bird Drop was playable, and quite fun! I spent a few hours implementing the score display, as well as the system that triggered the game over screen and restarted the game after about 10 seconds or so. Eventually, I also worked on the over-arching menu system, as well as implementing sound effects.

In addition to my personal goals, here are some bullet points about “What went right” from our team’s perspective (although this is all still “in my opinion”, I’m not speaking for the team here or anything):

  • We made a game! – Not only a game, we made (more or less) 3.5 games. There was even art for a 5th one that never got much past an empty scene in Unity. Probably more impressive, we made a menu and stuff. It really helped that Bird Drop was playable (and super fun) on Saturday, and that game got a lot of polish.
  • Bird Drop is awesome! – I think everyone, even those who never worked on it directly, can take some amount of credit for how great it was. Although of course Ryan and Bill (programmer and artist respectfully) are the ones who deserve the most accolades, as the game was truly “theirs” from the start.
  • teamwork! – I truly think we worked well as a team on this, with everyone contributing whatever they could (and often whatever was asked of them) to the overall team effort. This was a lot of people, certainly the largest group I’ve ever “jammed” with, and it was surprisingly painless. Certainly nobody tried to take over the project or had overactive egos or anything like that. A lot of credit should go to Zach, (who also organized the Jam, and runs the local IGDA chapter). He was probably the “glue” that kept the group together.

This would not be a true postmortem without some bullet points about what went wrong over the weekend:

  • Git woes – I was one of maybe two or three of us who had used Git previously, and vocally advocated for using it over SVN for version control. I set up a repository on my bitbucket account, and initially it was marked “private”, which meant that I could only invite some small number of people to it. This limitation showed up in a couple of different ways, and eventually we resolved some of the problems with it by just marking the repo as public (which I should have done from the getgo). In retrospect, one of the other git advocates had only used Github before, and I didn’t want to use that because it’s not free, but of course it is free for public repositories, so we should probably have just used that, which would have allowed him to continue using the github app (and let some of the other devs use it too). Two of our most experienced Unity devs had never used Git before, and we wasted quite a lot of time getting tortoisegit working for them. I would NOT recommend tortoisegit in general, as I still don’t know how to view “git status” using it. Totally non-intuitive to those of us who basically only use the command-line git.
  • Too much polishing on Bird Drop – This is definitely my own opinion, but I felt like we maybe spent too much time adding “juice” to Bird Drop when we could have been helping out finish up the other game modes instead. Bird Drop even ended up a bit more buggy at the end of the jam than it was on Saturday as a result. The final build we uploaded has several bugs that were introduced toward the end of the project.
  • Not enough attention to the other game modes – None of the other game modes were really playable until Sunday, and subsequently were single-developer affairs until that point. As one of two “swing” developers I should personally have made more of an effort to help those other projects get finished faster, so we could have done more iteration on them.
  • No focus on Friday – We basically didn’t even start coding until midnight on Friday.
  • Too much time spent on infrastructure – While we were unfocused on Friday, I think we spent a lot of time talking about what code each of the game modes would share, and where that code would live. One of our developers spent a lot of time on that code, and it ended up only used by one of the games. That particular developer was WIPED by the end of the project, and it’s really only because he is an absolute rockstar that he even finished that game mode.

Overall, it was a great weekend, and I had a blast. Thanks to everyone on my team, and to everyone who participated at our location!

NSNumber+XYCoordinates

Posted on by

So I occasionally have the problem where I want to store a bunch of x,y coordinates. I have solved this a number of ways in the past, but most recently had the idea of writing a category on NSNumber that simply stores two 16 bit integers, bitshifted together. So without further ado, here’s the github project for NSNumber+XYCoordinates.

My first version of this I couldn’t get negative numbers to work, but after some patient binary math explaining today at the coffee shop from my friend Matt, I finally got it to support numbers between -32767 and 32767.

Essentially, my category just adds the following methods:

NSNumber *xyNum = [NSNumber numberWithX:10 andY:10];
int x = [xyNum xValue];
int y = [xyNum yValue];

This seems to work pretty great, and is way less annoying than my previous favorite technique, which was to convert between NSString and CGPoint all the time.

So I got to thinking tonight… this should be fast, right? But I have no idea how fast, really, or how to compare it. So I wrote some test cases. Each of them assigns and then reads back out again some number of sequential integers using various techniques that I’ve used in the past. I compiled the following lists for different numbers of values:

100 Values
CGPointToNSString – size of 100 string objects in multidimensional array is 2263 (0.002 seconds).
NSDictionary – size of 100 objects in NSDictionary is 2413 (0.001 seconds).
NSSet – size of 100 objects in set is 1545 (0.004 seconds).
NSNumber+XYCoordinates – size of 100 objects in multi-dimensional array is 2033 (0.001 seconds).

10,000 Values
CGPointToNSString – size of 10000 string objects in multidimensional array is 241803 (0.162 seconds).
NSDictionary – size of 10000 objects in NSDictionary is 289593 (0.076 seconds).
NSSet – size of 10000 objects in set is 199798 (0.044 seconds).
NSNumber+XYCoordinates – size of 10000 objects in multi-dimensional array is 203503 (0.046 seconds).

1,000,000 Values
CGPointToNSString – size of 1000000 string objects in multidimensional array is 31702088 (10.187 seconds).
NSDictionary – size of 1000000 objects in NSDictionary is 38735561 (121.886 seconds).
NSSet – size of 1000000 objects in set is 25866828 (118.003 seconds).
NSNumber+XYCoordinates – size of 1000000 objects in multi-dimensional array is 25919832 (114.918 seconds).

You see that the technique compares favorably against CGPointToNSString, at 100 and 10,000 values, but somehow, the CGPointToNSString technique just blows it out of the water in terms of speed when we get to a million objects. (Still much smaller though.) I don’t fully understand this, but I guess maybe the C API is faster at high volumes? Let me know if you think you might have some insight!

ActionGo – Quick and Dirty

Posted on by

I’m still trying to finish up Catchup, the board game conversion that I’ve been working on for literally about a year now. (Obviously not full-time.) But I decided the week before last to take a quick break from it and update DrawCade to support the new MFi controllers. That took me all of about three days, (the second update, version 2.1 that fixes some issues from the 2.0 update is now live, yay!) But most importantly, what I got out of those days was a wrapper that supports iCade style controllers (pretending to be bluetooth keyboards), as well as the new GCController style controllers. (The Moga Ace Power and Logitech Power Shell are the only two available at the time of this blog post, but the first Bluetooth one has also been announced, but is not yet available.)

Anyway, I promptly decided I MUST create a game that would use the new controllers. The obvious choice is to port Go Tetris to iOS. This has been on my TODO for a long time, calling it Action Go to match Action Chess, but the big holdup was that I have never been satisfied with touchscreen controls for Tetris. It can be done okay, but not great. I’ll of course have some “okay” controls in there, but now that there are some viable controller options, I’m super excited to get it playable, and decided it was worth putting Catchup off for a few weeks to do so.

I started the project a little over a week ago, and promptly spent a day getting some cool menu animations (using AGGeometryKit) in there. I made the following video:

Then I spent three days preparing some changes to my GDC speaker proposal. (Which still hasn’t been accepted, but also hasn’t — yet — been rejected.)

If we were counting today, this would be the 5th day I’ve worked on it. I’ve got the tetris aspects pretty much done, but the piece capturing and two-eye breaking aspects are not yet complete. That is the bulk of the code that needs to be “ported”, and consists of about 800 lines of ActionScript. I’m maybe an 8th of the way there. Ironically, I’ve got the touch-screen controls finished, but still need to shoehorn my shiny new controller class in there. I decided I wanted it to be playable first. I’m guessing it’ll be another week or so of work.