Send to Kindle

Background

I grew up in the 70′s and 80′s. The golden age of arcade games. My best friend and I would hit up the various arcades in the surrounding town, and at 25 cents a game, I’d easily spend $10 for a couple hours of entertainment. My favorite game of all time, hands-down, is Tempest. In the arcades of the South Shore of Boston, I was the second best player. I could walk in to any arcade and get my initials on the high score board. Most often, after a few games I could get to the number one spot. Unless my nemesis had been there before me. Who this other person was, I have no idea. He (possibly she, but given the demographics of the time, most likely he) wasn’t amazingly better than me, but better enough to nudge me out of the top spot. I could usually get a number two spot though.

I was the guy people would stand behind and stare at in amazement. Granted, the only time I got such attention at that age was while playing video games, and only that particular one. I was pretty good at plenty of others, but Tempest was my forte.

Later years: Enter MAME

Well, time marched on, I grew up, arcades were replaced by home computers and XBoxes, etc. But I always remembered those old time games. Of course, I’ve installed MAME a dozen times and sought out various ROMs and had a good old time with them, but the holy grail of reliving Tempest was always out of reach. The problem was that Tempest requires a spinner. You spin the spinner to move around the screen and shoot the stuff that’s coming out of the tubes at you. There are plenty of workable Tempest ROMs for MAME, and Flash versions, and various copies. But moving around with the keyboard or mouse was an utterly lame experience compared to the real thing. A few years ago I went as far as getting a Griffin Powermate, thinking that’d work. No such luck. First of all, I was unable to even get it to talk to MAME successfully, and what I heard from those who had, was that it didn’t work all that well anyway.

Let’s just DO this

I most recently installed MAME while working on my Infiltration game, in order to get some Gravitar inspiration (another favorite). Of course, I gave Tempest another shot and had another bout of frustration. But this time I took it one step further and started to look into real game controls. Starting with these sites:

http://buildahomearcade.com/

http://wiki.arcadecontrols.com/wiki/Main_Page

I came up with a list of vendors that sold game controls and various plans on how to put them together. I got a shopping list together from Ultimarc and bought some wood and started cutting and drilling. My plan was to first create an arcade control panel that I could just plug into any computer running MAME. Some people go all out with two- or even four-player control panels. I decided to start with a single player. I ordered a bunch of buttons, a joystick, a control interface, and the ultimate – a real arcade spinner.

The work

While I waited for the controls to arrive, I started preparing the wood. I bought a 2′x4′ sheet of half-inch wood at the local Home Depot. I cut a 1′ strip off the end to give me the 1′x2′ top of the control panel.

Ye olde workshop. (Yes, I keep a bottle of wine in my workshop. Don’t you?)

Control top.

Then I cut a piece of cardboard to the same size and experimented with some layouts, coming up with one I liked.

The plan was to have the joystick and spinner in the center, and three buttons on each side. Some games are all button based, like Gravitar or Asteroids – a pair of buttons turn you left and right and other buttons shoot, thrust, shield, etc. These are usually laid out with buttons on opposite sides of the panel. Other games are joystick / button based, and of course Tempest is spinner / button based. Generally, the joystick or spinner is to the right and controlled with the right hand and the shooting / jumping / action buttons are hit with the left hand. Thus, the main buttons are the ones on the left here. Then, on the top are the coin button and start game button (one player start).

That was about as far as I got before the controls arrived.

The controls are here!!!

The controls arrived on Wednesday of last week. Pretty quick considering I ordered on Satureday and they originated in London. I actually did not realize that when I placed the order with Ultimarc. But I’m VERY happy with what they provided, as well as the prompt service and quick shipping. Here’s everything:

Doesn’t seem like a whole lot for $200 something. But I have zero regrets.

What you see here are:

A. 7 gold leaf buttons. Actually I ordered 6, they threw in an extra green one.

B. A J-Stik joystick with red ball top.

C. A SpinTrak spinner. With a silver/red spin top and extra heavy flyweight. The weight gives it momentum. This thing will spin for a minute or more.

D. A MiniPac interface. With full wiring harness.

This lets you hook up a joystick, all your buttons, a spinner, as well as a trackball. You then hook it up to your computer via a mini USB cable and you’re good to go. It basically converts all the buttons and joystick movements into key presses, and spinner and trackball input into mouse signals. It’s set up out of the box to work with standard MAME inputs, but it’s also programmable so you could make any control send whatever signal you want. Here’s how you wire it up:

Took me two or three tries to figure it all out, but once you get the logic, it’s fairly simple. I could rewire the whole thing in five minutes at this point. The wiring harness is well worth it too – you just look up the color and hook it to whatever control it’s supposed to go to.

Alpha Test

My control panel wasn’t ready yet – no holes drilled or anything, but you know I had to see this thing in action. So I put my laptop down on the living room floor and started hooking up wires. Again, there were a few false starts, but I eventually got it at least partway functional.

Dang, that’s a mess o’ wires!

I grabbed one of the cardboard boxes that the stuff came in and cut a couple of 1 1/8″ holes in it. Stuck the #1 button in one and the spinner in the other. And fired up… Tempest! I wish I could describe how awesome that was and how excited I was, but you’d probably get really uncomfortable and click off to some other site. Anyway, playing Tempest with a real spinner, even if only mounted in a cardboard box was nerd nirvana. Several hundred times better than trying to make it work with a keyboard or mouse.

Here’s my daughter Kris getting her first taste of Tempest. She likes.

High tech.

Now you’ve seen my slippers. Feel like you know me better?

As for the joystick, I got that wired backwards AND upside down the first time. After switching all the wires I realized I just could have flipped the thing 180 degrees. I didn’t mount that in anything, just held it steady while Kris got her first experience with Space Invaders.

That’s the look of pure retro joy. Take THAT, Wii!

Making sawdust

Thursday night’s project was to mount this thing in the real control panel. Based on my cardboard plan, I marked out where I wanted all the holes to be.

Then drilled some starter holes.

Then used a 1 1/8″ spade bit to cut out the final holes.

Conveniently, the buttons and the spinner both fit in the same size hole, and that works well for the joystick as well.

Started mounting the components.

And wiring things up in back.

Here’s the frame for the sides.

Right now, the top sites loosely on top of the frame, but I glued some blocks to it so it doesn’t slide around.

Then put the bottom onto the frame and drilled a hole for the USB cable.

A bit of cable management.

And we are good to go!

Yeah, there’s one button missing, but few games actually use all 6 anyway. Originally I ordered 6 buttons thinking of just the 6 player buttons. I can still control MAME, enter coins and start using the keyboard. But when the extra button came, I decided to skip button six for now and implement the coin and player one start buttons on the top. I’m ordering some more buttons anyway – I’ll probably add a pause, reset and select at least.

The cabinet itself is completely unfinished at this point. But we’re having a blast with it. It’s amazing seeing my wife get into it as much as she is. She grew up in the same time and who knew she knows various Space Invaders strategies. She even mentioned some by name. Daaaaamn! The woman is geekier than she lets on. And it’s really awesome to see Kris discovering and enjoying the games that I grew up with. Anyway, I’ll eventually get around to sanding it down a bit and will probably just stain and shellac it. I’m already looking into project number two, which will be a standalone mini table top arcade cabinet, something like one of these. And if that goes well, I might even attempt a full size two-player model.

Send to Kindle

Send to Kindle

You know what I hate? Subscribing to a blog and that blog doesn’t get updated for months and the blogger shows up and says, “Sorry I haven’t been blogging, been really busy, blah, blah, blah. But I’m really going to start blogging now!” and then they don’t blog for another few months and come back and say, “Whew! Still so busy! But I’m really going to get back into this blogging thing now! I promise!” and there’s no actual content in those posts, just promises of impending awesome content. That’s what I hate. That, and silverfish. Those things freak me out.

So, I’m not going to apologize, I’m not going to tell you how busy I was, and I’m making no promises. But, I will tell you what’s been up, what’s up, and what might be up in the future.

What’s been up: not a whole heck of a lot, to be honest. I kind of took a coding sabbatical. Of course, I’ve still got a full time job where I code all day, but historically, that’s only a warm up to the cool personal projects I work on when I get home. But for the last few months, I haven’t really been coding anything at all in my own time. In the few months before that, I’d started all kinds of various projects, apps, games, etc. These dead orphans litter my hard drive. Finally I just stopped forcing it and let myself have a coding vacation. Honestly, for about a month, I’d often not even open my computer at home. I’d check my email and do any other web related tasks on my Nexus 7. If I did open my computer, it was likely to watch a movie or some TV show, or log my runs of course. And you know what? It felt GOOD! Consider that in addition to my full time job, I’ve been coding at the very least, a part-time job’s worth of projects for most of the last 13 years – at times no doubt another whole full time job’s worth of projects. Not that this was something I didn’t like. Obviously, I did it because I love programming and creating cool stuff with code. But damn, you can get burnt out after a decade or so doing that stuff. So yeah, took a couple months and just said screw the code. Had no real plan of when I’d be back or what I’d do, but knew something would come along and yank me back out again.

So what was I doing? Running, reading, (finally) learning to play guitar, maybe spending a bit more time with the family.

So what’s up now? Would I be blogging if I were still playing hooky? Of course not. For the last two weeks or so I’ve been coding up a storm.

What happened was that about a month ago I installed Windows 8 on my PC. I’d previously had a dual boot system on a single hard drive – Linux and Windows 7. That was OK, but it limits your space on both systems. When I decided to try out Win8 I wanted to be able to install whatever I wanted without worrying how much of the disk it ate up, and the same in Linux. So I pulled out the optical drive and bought an adapter tray that allowed me to install a second hard drive in there. Now each drive had its own full 500GB disk. Installed Windows 8 on one, and Ubuntu 12.04 on the other. Great.

My first day on Windows 8 scared me to be quite honest. The whole Win8 interface (formerly known as Metro) looks nice, but is so damned different, I had no idea what to do or where to find anything. After a couple days though, I started learning the gestures and shortcuts and it really all started growing on me. Before long I was using Windows 8 pretty much full time.

The next thing that happened was that my friend, Jesse Freeman, joined Microsoft as a Windows 8 evangelist, and started bugging me to make Windows 8 apps. It did intrigue me, and Jesse is pretty persistent, so eventually I downloaded Visual Studio 2012 Express for Win8. I created one of the sample apps and ran it and messed with the HTML a bit, but didn’t immediately get hooked. But I had an idea.

When I was off doing nothing, I did have one concept for what I wanted to do – revive my Art From Code site and create a framework in JS/Canvas that allowed me to make high resolution generative art pieces that could be printed. Most of the stuff on the site now is not high res enough for quality printing. I had some very cool ideas for how this framework would work, including saving of code, parameters, and results, so that the pieces could be regenerated and rerendered at varying resolutions. One sticky part of it was saving the images as bitmaps. If you are working in a web page, you can get the canvas’s image data and assign it to the src of a new image and display that image. You then have to right click and save the image. Not very elegant, and in my experience the browser constantly chokes on large images. This would be a problem.

So I asked Jesse if it was possible to save a canvas as a bitmap from within an HTML-based Windows 8 app. I’d googled around a bit and it didn’t seem like it. But he came up with a great link that worked like a charm. I made a quick sample and I was hooked! From that day, for the last couple of weeks, I’ve been working on an app that generates artwork and allows the user to save it. Although it was just a proof of concept for the app I plan to make for myself, it was cool enough that I just submitted it to the Windows 8 Store.

That was the first personal project I’ve actually completed start to finish since May of this year. And I’ve already started on my next app – a Windows 8 port of Falling Balls! So I guess it’s safe to say I’m back.

Like I said, no promises, but there are lots of things I’d like to blog about at this time – the app itself, the technology behind Windows 8 apps, and the submission process, to name a few. So who knows, you might see some more posts here before the end of the year.

Send to Kindle

Send to Kindle

I was talking to my coworker, Todd Anderson, today about running build systems in Sublime Text 2. It’s a great editor, very powerful and configurable. But somewhat of a lack of documentation on all those features. One problem we both had was setting up multiple build systems on a project, say one for running unit tests, one for running JSLint, one for deployment, etc. You can specify build systems right in a project file as per this reference: http://www.sublimetext.com/docs/2/projects.html. For a drop dead simple example, you could have one that launches your index.html file in chrome, and another that launches your unit tests in tests.html. This would look something like this:

"build_systems":
[
    {
        "name": "preview",
        "cmd": ["/usr/bin/google-chrome", "$project_path/index.html"]
    },
    {
        "name": "test",
        "cmd": ["/usr/bin/google-chrome", "$project_path/tests.html"]
	}
]

Now, in your “Tools/Build System” menu you should have two entries: preview and build. You can choose one, and the next time you build it will do what you specified in that system. The problem is switching between them. Grab the mouse and go to Menu / Tools / Build System / test (or preview). Then, F7 or Ctrl-B to build. Or maybe you forgot which one you were on, so when you build it builds the wrong thing and you have to cancel and go back and check and redo it. Minor pain, but it gets annoying.

Ideally, you could assign a specific keyboard command to each build system. So I started digging in to see how to do this.

First Part of the Solution: set_build_system

After some digging around, I found that there’s an internal command called “set_build_system”. You pass it a single argument called “file”. The value is one of two things:

1. The path to a sublime-build file, such as “Packages/Java/Ant.sublime-build”

or

2. The name of a custom build path in your project file (like what we just created as “test” and “preview”.

You can use this command in a keyboard shortcut. Go to the Preferences menu, Key Bindings – User. This will open up a Default sublime-keymap file, which should contain an empty JSON array like this: [], unless you have already added some shortcuts. You can create shortcuts that will change your build system like so:

[
    { "keys": ["ctrl+shift+p"], "command": "set_build_system", "args": { "file": "preview"} },
    { "keys": ["ctrl+shift+t"], "command": "set_build_system", "args": { "file": "test"} }
]

With this, Control-Shift-P will set your build system to your custom preview build system, and test likewise. But it’s still a two step process: set the system, then build. And again, there’s no visual indication of which system is currently set, and no visual indication of when it changes, so you’ll still find yourself checking manually in the menu to see which is checked.

Ideal scene again, would be one shortcut that chooses the system and then builds.

Second Part of the Solution: plugins

A keyboard shortcut can only run a single command. But we need to run two commands: choose the build system and then build. To do this, you can create a sublime text 2 plugin. This is far easier than it sounds. In fact, Todd and I were both pretty shocked at how easy it turned out to be and how quickly we got it working.

A plugin is a Python class that creates a custom command. It extends one of three plugin classes: WindowCommand, TextCommand, or ApplicationCommand. This post was very helpful in getting me started:

http://net.tutsplus.com/tutorials/python-tutorials/how-to-create-a-sublime-text-2-plugin/

Here’s the command that Todd and I came up with virtually at the same time:

import sublime, sublime_plugin  
  
class RunBuildCommand(sublime_plugin.WindowCommand):  
    def run(self, build_system):  
        self.window.run_command( "set_build_system", {"file": build_system } )
        self.window.run_command( "build" )

Running through it, this imports a couple of sublime packages, defines a class that extends WindowCommand, and a single method called run.

The run method takes a single parameter (besides “self” that all python methods get) which will be the name of the build system to run.

It then does the two things we need to do by making calls to self.window.run_command, passing in the command to run and any arguments.

First we call “set_build_system” like we did in the first keymap example. This passes through the build_system argument.

Then we call build, with no args.

So we’ve accomplished our two actions in a single stroke: set the build system, then build.

You can save this file as “RunBuild.py” anywhere in your Packages folder in Sublime’s config folder (check documentation to see where that is on your OS). I suggest you give it its own folder so it becomes /Packages/RunBuild/RunBuild.py.

Now we just need to change the keymap to call this custom command instead of set_build_system. The name of the class, RunBuildCommand, will be mapped to a command called “run_build”. CamelCase becomes camel_case in this setup. So we do this:

[
    { "keys": ["ctrl+shift+p"], "command": "run_build", "args": { "build_system": "preview" } },
    { "keys": ["ctrl+shift+t"], "command": "run_build", "args": { "build_system": "test" } } 
]

And we are done! Control-Shift-P launches index.html in the browser, and Control-Shift-T launches test.html. Of course, your build system(s) could be far more complex than the simple one I showed here, there you go.

Send to Kindle