Resurrected Entertainment

Custom Pac-Man Themed Arcade

January 17, 2016

I began work on this unit several months ago. I am a father of three beautiful, very active young girls, and a husband to a gorgeous wife who likes to do renovations, so my free time is not what it use to be. Like so many projects nearing completion, I am overwhelmed by the sheer number of things which could be improved or done differently. Indeed, if I were going to do it all over again, I would do things differently and I imagine I would save a great deal of time, money, and headache. But that’s why people who love to build things dive right in, yes we make mistakes, yes the quality may not be top notch (but this is something that improves the more you build) and yes it may be expensive but the alternative is to sit on the sidelines and not do anything, or do it so slowly that it never gets finished.

This project had many pieces to it and it’s still not 100% finished. The first step was to source and figure out what the first set of materials was going to be. The project as of a few weeks ago looked something like this:

Arcade Mania!

Arcade Mania!

It consists of a themed wall panel, mounted flat screen high-definition television, an extended shelf, an X-Arcade Tank Stick, 257 individually addressable RGB LEDs on the inside edge of the panel, cup holders and a few decorations. The software driving the arcade is custom and consists of the primary server that controls the execution of the games, a mobile client application for selecting the games to play, and another server driving the decorative elements.

The first steps in designing the physical exterior for the arcade involved selecting appropriate materials. This process can vary a lot between projects, but I usually start by determining the theme and any special features or effects I want to add. For example, I knew that I wanted to place LEDs on the inside edge of the frame, so I needed to choose a material that was thick enough and could be easily cut into pieces that were less than an inch wide. I also needed that material to be easily mountable to the outside edge of the frame. I wanted the light from the LEDs to diffuse through the pieces on the board, thus creating an illuminated display. I bought a few 24×12 pieces of clear acrylic. Before doing that, I had researched some acrylic material that was built for optimal diffusion, but it turned out to be too expensive, so I chose to stick with clear acrylic.

The panel was assembled in a more complicated way than I would have liked. I was trying to reuse some plywood so instead of buying a piece of wood that was exactly the size I needed, I chose to assemble the pieces of plywood and glue them against a backing panel made of MDF. That worked, but it consumed considerably more time and there was fussiness around getting the edges lined up (due to the slight inaccuracies from various cutting tools). Anyway, after the pieces were glued, screwed, sanded, and trimmed, I painted the panel with a mat black undercoat. First using latex paint, then switching to oil based. I switched because the latex just wasn’t giving me the kind of mat finish I wanted. Whether or not the paint was acrylic or oil-based likely didn’t matter, it was probably the formulation for that brand that had the most impact on the finish. I happened to have oil based black on hand, so I used that rather than spending more money on a different brand of latex paint.

1/1

The board pieces needed to be designed before the acrylic material could be cut. I used Adobe Illustrator to design the pieces to be cut from 12×24 inch panels. The laser cutter available to me through the public library requires that the thickness of the lines in the design be less than 0.001 inches. When cutting acrylic be aware that the smell is quite unpleasant and should be ventilated. It takes about a day for most of it to dissipate from the cut pieces; I left it out in the garage overnight.

1/2

In order to transfer the Pac-Man like game board pattern to the painted base, I chose to tape the entire surface using painter’s tape. Following that, the acrylic pieces need to be laid out and traced, including all of the pellets from the pattern. Once traced, I cut them out with an X-Acto knife, and then created a special, circular drill bit to cut out the pellets. I chose to use those threaded wire funnels that come with light fixtures, but I needed to grind the bit for the edges to become sharp. Once the tape for the board pieces was cut out and removed, this exposed the flat black surface for paint.

1/2

The painting process was tedious and not very interesting, so I am not going to belabor it anymore. This whole approach worked, but it was very time consuming and error prone as the paint needed to be touched up in many areas due to bleeding. I would recommend taking a different approach, if you were to do something similar.

1/2

The gluing process was almost as tedious as the painting process since the glue could not be applied on top of the painted area as it would have been visible if it sat between the painted surface and the clear acrylic. It also wouldn’t have dried because the type of glue I used, Weldbond, requires exposure to air for curing. Instead, I applied the glue to the edges of the game board pieces (except for the pellets) using a needle. Ouch. The recommended approach above would have also made gluing the pieces to the board a lot easier as I could have used any kind of glue, rather than searching high and low for a specific kind of glue that was both strong and dried clear.

In retrospect, the result would have been faster and  higher quality if I had thought to paint the underside of the board pieces in the desired color first before gluing them to the board. This would have made the painting and the glue selection process a lot easier and is the approach I would take if I were to build another one.

I modded a couple of Ikea shelves to provide an extended platform so that my Tank Stick could sit comfortably, provide enough room for drinks and extra gamepads for other systems if necessary. It also provided some distance away from the screen so that players didn’t feel too close to it. I fastened them together using some latching hardware and strong clips so that the shelf could be folded if desired.

The panel was mounted flush with the wall using four metal clasps screwed into each corner. I wanted the arcade to have more of a built-in feel, encompassing the joystick shelf and the panel, so I painted a region around the arcade giving it more of a framed in look.

The television was mounted using a leveled bracket. I wanted it to be as close as possible to the panel and for the bracket to not be easily visible when standing next to the arcade on either side. I found a mounting system suitable for my needs and at a relatively cheap price at Ikea. When designing the panel in Adobe Illustrator, you must leave enough space for the bracket, otherwise you’ll be peeling off some acrylic pieces later and making some last minute cuts and holes.

I included a few characters in the design such as Pac-man and the ghosts: Inky, Blinky, Pinky and Clyde. The were cut from acrylic and then painted on their opposite sides using some colorful latex paints. The Home Depot sells small “tester” paint samples which are far too small for a wall, but perfect for small projects like this one. I painted the undersides of the characters (by this point I had caught on to the better approach) and mounted them on the wall next to the arcade using some crazy glue in gel form.

I also bought some black, textured plastic sheets from a plastics company called Canus Plastics. The sheets were about 1/8″ thick and could be cut with an X-Acto blade. After cutting them into strips, I used them as trim around the perimeter of the panel, which give it a more finished look and help to shield some of the light coming from the LED strips. The RGB LED strips were installed in a gap between the main panel and the edging. I bought a 5-foot length from a seller in China for a reasonable price. You can find them for sale in North America but the price can be much higher. The strip must be powered and driven by a micro-controller, so a little time must be spent on what to do with the wires. I have my arcade mounted on a wall that is finished on one side, so it was easy to hide a lot of the wiring for power, input devices, and video cables through the wall. If you were trying to install this on a wall that was finished on both sides, or which covered a foundation wall, then you may want to consider routing the cables through a hole and down the inside of the wall to another location.

There are many multi-cade system’s in the market these days. I like the look of some of them and many are closed systems where expansion and experimentation are difficult. However, I have never enjoyed navigating through the various menus and settings from the arcade screen itself. I did not want to have a keyboard and mouse installed when I need to select a game, or to try and use a joystick to navigate around. As a side note, you can use the X-Arcade buttons and a trackball as a mouse, if you’re interested. Anyway, basically I wanted the system to be simple and intuitive without all of the difficulties around emulation and desktops. I wanted my father to be able to use this system without needing to know what a ROM image was or what sort of commands were needed to load a game or fire up an emulator. I also wanted other players to be able to look through the games and see what’s available while others were using the arcade. I tried other front ends that try to abstract the underlying emulators like Maximus Arcade, but I found that their application was unstable (at the time) and required tedious tuning of mapping the underlying emulator to it’s execution scheme.

Once I knew I needed to write my own arcade front-end, I knew I wanted it to be a service that could accept commands from different clients running on different operating systems. The primary purpose of the server is to allow the user to play games, so it needed to run games made for hardware other than personal computers, such as the Super Nintendo Entertainment System (SNES), TurboGrafx 16 (TG-16), or an Arcade game. This requirement meant that the host platform (the machine and the OS running the server software) needed to emulate the other hardware, so it needed to be capable of running a game like Star Fox and the server software at the same time. The software emulating these other platforms are called, naturally, emulators and there are sometimes different program options available for the same system. The all have various technical limitations so some thought must be given as to which software you should use for your arcade.

The basic interaction model I wanted was a client application running on one or more mobile devices and a server installed on the machine running the arcade, which is just waiting to launch a game when one has been selected on the client. In addition, the server needed to be relatively easily to extend so that new emulation platforms could be added later. There are basically three primary pieces to the overall server platform:

  1. A database to hold and manage the information about the platforms, games, and the system.
  2. A server to drive the communication with the client, read content from the database, and to launch and control the emulation software.
  3. Scripts to wrap and control the life-cycle of the emulation software. These are executed by the service when a game has been selected on the client.

I chose to use Qt as the primary windowing, communications, and UI SDK in case I wanted to move the server application to Mac OS X or Linux at some point in the future. I also consider the API to be one of the best cross-platform APIs around for desktop applications. As it turned out, I ended up implementing platform specific functionality as some of the third-party software required particular bits of functionality in order for them to work together with the system I was building.

The service does several things, but the most important responsibilities are list below (in no particular order):

  • Provide the clients with a list of supported emulation platforms and games, including image content.
  • Provide some safe guards around multiple clients accessing and attempting to control the arcade at the same time.
  • Launch and terminate the emulation applications so that the arcade always returns to the same ready state when someone finishes playing a game.
  • Communicate with other services so that decorative elements can be synchronized with the games and platforms being used.

The client is an Android application, since I wanted it to work on the Ouya platform as well. The client presents the users with a simple connection method to the server (multiple servers are supported), platform selection, and game selection. I wanted to keep the client relatively simple so that game selection is fast and easy. As a minor feature, I wanted to the ability to take a screen shot of the currently running game, for high scores and other awesome feats, and then save it to the device so that it can be browsed and shared later.

There is a decorative component to the arcade that gives it a bit of bling and acts as an attract mode. The LED strips mentioned earlier require a micro-controller to control them. I wrote a service that runs on a Raspberry Pi and it receives commands from the game server when various events happen, such as launching a game. The commands are simple and usually contain a payload like an RGB color. This allows the server to send different colors for each platform when a game is selected.

Battletoads: Terra Tubes!

July 15, 2015

Without a doubt, this is one of the most difficult levels I have ever played for any game on the NES — incidentally, I don’t think I have ever finished it. Here is someone who played it through with barely a nick:

Zelda Mural: The Adventure!

May 10, 2015

I have recently finished a small Ode-to-Zelda techno-art project that involved some readily available construction materials like plastic moulding, foam board, and 3/16″ MDF board, as well as some less common parts like custom circuits, Pixel Blocks, and laser cut acrylic pieces. In the end, it took around 4 months to complete the project, but someone else who has access to more free time could complete it much sooner, and by not ordering parts from China on eBay (it usually took 4-5 weeks to arrive). It was very enjoyable and a good learning experience even though the result is not something I would want to sell, due to the lack of polish. Here is a photo of the scene in the game and the finished project:

It’s a representation of the first cave you come across in Nintendo’s pilot Legend of Zelda game. The scene illuminates with the flick of a switch on the left side of the frame. There is a flickering fire effect which is implemented via a couple of small circuits (5V) that are each driven by an Atmel ATTiny13-20PU 8-bit microcontroller and a series of low-power LED strips (12V). Since I wanted to drive the circuit with only one power supply, the project needed a small power regulation circuit to drive both loads.

Programming the flickering fire effect using the Atmel microcontroller can be tricky because it lacks a floating point unit and only has 1 KB of program space. This means that you can’t use decimal calculations lest the compiler pull in routines for floating point emulation, which result in a program too large to fit in the microcontroller. The solution was to employ a fancy sounding algorithm called a Linear Congruential Generator, which essentially provides the required randomness via a calculation that makes clever use of prime numbers. Early computers used this technique to achieve pseudo-random number generation at low computational cost.

The borders of the frame were printed using the graphics tiles copied from the game; the panels were sealed with rubberized paint spray and raised in a 3D effect using foam board, which itself has been painted and sealed for added strength and a semi-gloss, darker look. The letters have been laser cut from white acrylic using the font from the game; just a warning if you laser cut acrylic, it generates a nasty smell that is more than likely toxic, so get those laser cut pieces out in the open as soon as possible. I found the smell to dissipate after a few hours in the garage.

Keyboard or Joystick: You Decide!

April 19, 2015

For those who don’t like playing DOS games using their keyboard, there is a nifty little software package called “JoyEmu“. It allows you to map keyboard keys to joystick input (2 or 4 button joysticks), along with the axial directions. It has a great configuration utility to help you set this up, and allows you to save keyboard mappings and joystick assignments as files. These files can be loaded manually alongside a batch file wrapper, if you desire,  so that playing your favourite games is quick and easy. It also allows for mappings to your mouse and a truck load of documentation; you really couldn’t ask for a better utility of this type!

Alone in the Dark for DOS

I have been playing that game recently and researching different aspects of its history; I ran across a thread on the ScummVM message board that said you can enter the text “benjaminyaelfred” at the copy protection screen and it will let you play the game, if you don’t have the code book that came with the game. The last part of the text “yaelfred” is from one of the original artists of the game, Yaël Barroz, and the original engine programmer, Frédérick Raynal.

8-bit Christmas

December 27, 2014

I have recently finished the book entitled “8-bit Christmas” by Kevin Jakubowski. It was a very enjoyable read with many similarities to my childhood along with many differences; it was fun to read about another person’s perspective on that period. My brothers and I all wanted a Nintendo after we played one at a relative’s house during the Christmas break. The trouble being, of course, that we would have to wait until next Christmas to get one. Luckily, I had a birthday in July!

Supercharge Your Life!

December 21, 2014

The Arcadia (or Starpath) Supercharger is a device which allows you to play beefed up games on your Atari 2600. Games ship on cassettes and are loaded onto the system via an audio cable that connects to a tape player. The other way is to hook up the cable to your computer and pipe a sound file to the device. For 2K and 4K games, you can use a tool called “makewav” which encodes an Atari 2600 binary ROM file into a WAV encoded audio file. I have “ported” the utility so that it can be built on Mac OS X; I use the term loosely since I had to do very little to get it to build. You’ll want to run it like this once it is built:

$ makewav -ts atarigame.bin

Which will produce a WAV file of the same name + a “.wav” extension. You may also want to locate a CD called Stella Gets a New Brain, which is a complete compilation of the games released for the Supercharger. If you decide to rip the audio tracks to an MP3 file, be sure to use a very low compression for maximum fidelity and open the file in a piece of software like Audacity to make sure that the audio is duplicated on both channels; this is because your laptop has stereo output but the Supercharger only accepts mono. You will likely need an interface adapter which converts your stereo signal to a mono signal, but a better way might be to simply find yourself an old stereo audio cable, cut it and the wire going to the Supercharger, and solder one signal line from your stereo cable + ground to the mono cable’s signal line + ground. While attempting to use my Supercharger, I found the noise introduced by the adapter and the oxidized cable from the 30+ year old device was causing a lot of interference, after I cut out the middle man things worked perfectly.

Once that is done, try The Official Frogger by Sega — it’s awesome!

DOS Software Development Environment

December 12, 2014

I love writing software for Microsoft’s DOS. I didn’t cut my teeth programming on this platform, that was done on an Atari 800 XL machine. However, it was on this platform that I was first exposed to languages like C and Assembly Language, and thus sparked my torrid love affair for programming which lasts to this day. The focus of this post is about DOS software development and remote debugging.

If you have done any development for iOS or Android, then you have already been using remote debugging — unless you are some kind of masochist who still clings to device logging even when it is not necessary. The basic concept is that a programmer can walk through the execution of a program on one machine via the debugger client, and trace the execution of that program through a debug server running on another machine.

The really cool part of this technology is that it’s available for all sorts of platforms, including DOS! Using the right tool chain, we can initiate a remote debugging session from one platform (Windows XP in this case), and debug our program on another machine which is running DOS! The client program can even have a relatively competent UI. For this project, the toolset we are going to use is available through the OpenWatcom project, and the tools found inside that wonderful package will allow us to write 16-bit or 32-bit DOS applications and debug them on an actual DOS hardware target! In addition, we can apply similar techniques but this time our server can be hosted within a customized DOSBox emulator, which is also really cool since it allows you to debug your code more easily on the road.

The first scenario is the one I prefer, since it is the faster of the two approaches, but before we get into the details how to set this up, let’s consider some of the broader requirements.

You’ll need two machines for scenario number one. The DOS machine will need to be a network enabled machine, meaning it should have a network interface card and a working packet driver. I would recommend testing your driver out with tools like SSH for DOS, or the PC/TCP networking software originally sold by FTP Software. In order to use the OpenWatcom IDE, you’ll need a Windows machine. I use VirtualBox and a Windows XP Professional installation; my host machine is a Macbook Pro running Max OS X 10.7.5 with 4 GB of RAM.

The second scenario involves using the same virtual machine configuration, but running the DOSBox emulator within that environment. You will need to use this version of the DOSBox emulator, which has built-in network card emulation. They chose to emulate an NE2000 compatible card for maximum compatibility, and also because the original author of the patch was technically familiar with it. After installation, you’ll need to associate a real network card with the emulated one, and then load up the right packet driver (it comes bundled with the archive).

For reference, the network interface card and the associated packet driver I am using on the DOS machines is listed below:

  • D-Link DFE-538TX

These are the steps I have used to initiate a remote debugging session on the DOS machine:

  • Using Microsoft’s LAN Manager, I obtain an IP address. For network resolution speed and simplicity, I have configured my router to assign a static IP address using the MAC address of my network card;
  • Load the D-Link Packet driver;
  • I load a TSR program, which I have built from a Turbo Assembly module, which can kill the active DOS process. I do this because the TCP server provided with OpenWatcom v1.9 does not exit cleanly all of the time;
  • Navigate to my OpenWatcom project directory, then I start the TCP server which uses the packet driver and your active IP address to start the service. The service will wait for a client connection; in my case, the client is initiated from my Windows XP virtual machine using the OpenWatcom Windows IDE.

These are the steps for the DOSBox emulator running within the Windows XP guest installation:

  • Install the special network enabled build of DOS Box mentioned above;
  • Fire up the NE2000 packet driver  (c:\NE2000 -p 0x60);
  • Start the TCP service (c:\TCPSERV /trap=rsi).

While working on a project, it can be really useful to create the assets on a modern machine and then automatically deploy them to the DOS machine without needing to perform a lot of extra steps. It can also be useful to have the freedom to edit or tweak the data on the DOS machine without needing to manually synchronize them. The solution which came immediately to my mind was a Windows network share. This is possible in DOS via the Microsoft LAN Manager software product and has been discussed before in a previous post.

DOOM’s 21st Birthday

December 11, 2014

It’s hard to believe, but DOOM (or Smashing Pumpkins Into Small Pieces of Putrid Debris as it was known in some circles) was unleashed upon the world as Shareware on this date in 1993. The game was so popular that Microsoft had contemplated purchasing id Software in an effort to promote Windows 95 as a top-notch gaming platform; Bill Gates even featured himself in a video fighting the creatures of DOOM head on. DOOM fever had reached high enough levels inside Microsoft that a special Easter Egg was placed inside of Microsoft Excel 95 with a DOOM-like level called The Hall of Tortured Souls. Over the years, much has been said about this game and the team that created it, so I will not echo that history here, but here are some of the things the DOOM franchise has birthed into this world since its release:

  • It has sold over one million copies, but it has been pirated and downloaded many more times than that
  • DOOM – The movie starring Dwayne John (The Rock)
  • Masters of DOOM Book
  • The source code for the game was released in 1997 spawning numerous source ports to other platforms and revamped engines
  • The game engine has been licensed numerous times, even for such projects as promoting breakfast cereals like Chex
  • For four years after its release, people continued to refer to other 3D games as “DOOM clones”
  • DOOM board games and expansions
  • DOOM comic books and fantasy novels

Building Wolfenstein 3D Source Code

June 16, 2014

Way back on Feb 6, 2012, id Software released the source code to Wolfenstein 3D — 20 years after it had already been written. The source code release does not come with any support or assets from the originally released game. In fact, id Software is still selling this title on various Internet stores like Steam. I played around with a DOS port of the DOOM source code quite some time ago, but I had never bothered to try and build its ancestral project. Until now!

As it turns out, it’s actually quite straight-forward with only a minor hiccup here and there. The first thing you’ll need is a compiler, that almighty piece of software that transforms your poorly written slop into a form that the operating system can feed to the machine. For this project, the authors decided to settle on the Borland C++ v3.0, but it is 100% compatible with v3.1. I don’t know if more recent compilers from Borland are compatible with the project files, or the code present in the project produces viable targets, so good luck if you decide to make your own roads.

As per the details in the README file, there are a couple of object files you will want to make sure don’t get deleted when you perform a clean within the IDE:

  • GAMEPAL.OBJ
  • SIGNON.OBJ

You can open up the pre-built project file in the Borland IDE, and after tweaking the locations for the above two files, you should be able to build without any errors. The resulting executable can then be copied into a working test directory where all of the originally released assets are located, I believe my assets were from the 1.2 release.

There are also a few resource files you must have in order for the compiled executable to find all of the right resources. According to legend, the various asset files were pulled from a sprinkling of source formats and assembled into “WL6” resource files. A utility called I-Grab, which is available via the TED5 editor utility, produced header files (.H) and assembler based (.EQU) files from that resource content which allowed the game to refer to them by constant indices once the monolithic WL6 resource files were built. There are annotations in the definition files, using the “.EQU or .H” extension, with a generated comment at the top which confirms part of that legend.

The tricky part in getting the game to run properly revolves around which resource files are being used by the current code base. The code refers to specific WL6 resource files, but locating those resource files using public releases of the game can be very tricky because those generated files have changed an unknown number of times. Luckily, someone has already gone through the trouble of making sure the graphics match up with the indices in the generated files. The files have conveniently been assembled and made available here:

After unpacking, you’ll need to copy those to the test directory holding the registered content for the game. Note that without the right resource files, the game will not look right and will suffer from a variety of visual ailments, such as B.J. Blazkowicz’s head being used as a cursor in the main menu, or failing to see any content when a level is loaded.