This project -- creating a LaserTank clone in JavaScript -- deserves some
discussion before diving into the implementation details (you may skip to the
separator below for implementation details without the history). LaserTank is a
game that has a special place in my heart. Not only is it a witty and enjoyable
game, but it is in fact the reason I began programming as a young boy in the
first place. While it is likely that I would have eventually picked up a
programming book for some other reason, I owe that point in time entirely to
this game.
Allow me to explain. At the age of 10, I would spend much of my time on the
Internet downloading various games and demos that may satisfy my interests (the
old days of CNET's download.com showed me many of those, I believe). One of
those games that immediately captivated me was LaserTank, but not purely for
reasons of gameplay. It had this wonderful feature that added so much potential
(and replayability) to the game -- a map editor.
I found myself enthralled with the map editor to the point where I spent all my
time creating maps rather than playing the game. What fascinated me was the
ability to essentially create portions of the game -- to tell the game what to
do and how to function. I was not able to create my own game using this editor,
but I felt like I was creating portions of it. That said, I soon realized that
it wasn't enough; I needed to do more.
It was the limitations of the map editor and the enjoyment of creating the maps
that caused me to convince my parents to take me to Barnes and Noble to purchase
my first programming book - Learn to Program with Visual Basic 6 by John Smiley
(N.B. Visual Basic is proprietary and I cannot recommend using it. I had no
knowledge of the evils of proprietary software back at that point in time.) My
parents had their doubts, but that only pushed me even harder to learn.
Ironically, the book was about creating a business application. I found this
process very enjoyable and began focusing more on conventional desktop software
rather than gaming. I did create a couple games (bop-a-mole and breakout among
others), but my focus was never game development. Eventually, I moved on from
Visual Basic and got into web development. Following that, I discovered
GNU/Linux and began getting more and more into lower-level systems and languages
(such as C and ASM) and began adopting the hacker ethic. That brings us to where
I am today -- nearly 13 years later. It would only seem fitting to bring my
hobby-turned-career full circle by cloning the very game that started
everything.
When I say "clone", I mean nothing more; there will be no additional features
or modifications to the original gameplay, menus, graphics, etc. It will support
all original file formats (I will develop none of my own). The only differences
between the clone and the original game will arise from the obvious issues
introduced by cloning the game on a web platform. Specifically, the user will
have the option to load files from either their local box or a remote resource,
and I may provide pre-masked tile sets for browsers that do not support the
canvas element (a fallback mode, if you will). No matter what the change,
though, the gameplay will remain identical.
That said, the library resulting from the clone will be built with extensibility
in mind. If a user (or myself) wishes to create a derivative work by hooking or
extending the library (for example, to support larger maps, add additional
blocks/enemies, multiplayer support, etc), that should be fairly trivial to do.
However, those works will be entirely separate from the clone and clearly
distinguished. I think the original LaserTank is perfect the way it is.
Remember, it has a special place in my heart (aww) and I would like to preserve
the game as I remember it back then.
---
Alright; now that we have a great deal of unnecessary history out of the way,
let's get into the implementation details for this commit (if you're reading
this as a blog entry, see the first commit). This commit represents a
proof-of-concept showing that the LTG files (containing the LaserTank graphics)
can be properly loaded and their masks properly applied. This was the first
major concern for the project and, if a workaround were needed, would have
prevented me from creating a full clone (as it would not support loading LTG
files without having them first sent to the server, processed, and returned in a
different format).
The LTG file contains some metadata (including the name, author and description)
as well as two bitmaps (BMPs) -- the game tileset and the associated mask. The
game bitmap's position was static, but its length and the offset of the mask
bitmap were provided by the four bytes immediately preceding the game bitmap
(the TLTGREC struct in LTANK.H of the original sources represented this value as
a DWORD, which represents a 32-bit integer). The only challenge with converting
this value into an integer that we could use is its endianness -- is the most
significant byte at the beginning or end? Windows programs (of which LaserTank
is) generally write in little-endian format, but to be sure we can simply open
up the LTG file in your favorite HEX editor (I simply use `xxd`). In the case of
the original tileset, the four bytes immediately preceding the bitmap header (as
identified by 'BM', or `424d`) were `7a f5 00 00`, which on its own clearly
indicates little-endianness. We can verify by searching for 'BM' once again, and
finding that it begins at location `f5 7a` (if your HEX editor displays in
big-endian format). To convert into a number, we can simply add up each byte
individually, left-shifting by 8N bits, where N is the 0-indexed byte position.
Loading the BMP files was then fairly trivial; the file could be loaded into
memory (read from disk using FileReader) and we could cut the relevant portions
of the binary string out. The bitmaps could then be base64-encoded and the
"src" attribute of an Image object set to 'data:image/bmp;base64,B', where B
is the base64-encoded BMP. This could then be rendered however we please - CSS
sprites or to a canvas.
The problem with CSS sprites is that we need to apply the mask and there is no
reliable way to do this without a canvas; transparency in the browser is
normally handled using GIFs or PNGs. As it turns out, the canvas performs
masking using the alpha channel as well, so I would have to create my own
masking algorithm to manipulate the alpha channel of the tileset. To complicate
matters even more, certain tiles had no mask, and they did not consistently
represent the mask with all black (black is used in LT to indicate opacity),
meaning that the algorithm would have to understand what tiles should be skipped
entirely.
The solution was to simply loop through each tile and set the alpha byte of each
pixel relative to the respective pixel on the map. Because the images were
created out of data in memory, the canvas is not tainted when the image is
rendered before using getImageData(). To help speed up the process, since we
know that the mask can only contain black and white, we need only check one of
the channels; we do not need to calculate brightness. This process successfully
returns each individual tile, properly masked, which can be rendered to the
canvas using putImageData(). Crisis averted. With that major concern out of the
way, the clone should no longer be a problem.
I go into more detail in the comments within LtgLoader and TileMasker.
This is going to be an exciting process, both because of the LT clone itself and
because this is my first experience working with the canvas element. As
aforementioned, I seldom create games and I have had no use for the canvas
thus far.
Hopefully this project will be well-received by both those who have played
LaserTank in the past and the original developer of the game (Jim Kindley, JEK
Software). LaserTank is a fairly old game and is not likely to be well known
anymore, but the game itself is a blast (no pun intended) and bringing it to the
browser, where it can be used on any platform (including mobile devices), should
allow everyone to enjoy it.
The source code is released under the GNU AGPL to ensure that the users'
freedoms are preserved even if this game is rendered or in any way run
server-side.
Mike Gerwitz