I’m an aficionado of block-falling puzzle games such as Tetris and Lumines. So it seemed only natural for me to make a game in that vein. But at the same time I wanted to make a game that is different from the vast number of puzzle games already out there. You may be surprised to hear that there are over 50 variants of Tetris alone! So coming up with something new turned out to be quite challenging.

Polaris was born from the idea of transforming the game board into polar coordinates. The name and celestial theme of the game naturally followed from there. To convince myself that this would work on the tiny iPhone screen I made this concept design in Photoshop:

Polaris Concept

At that point I wasn’t sure what the game rules would be, but I had a pretty good idea of how the game mechanics would work. First, blocks would appear on the sides of the screen and fall towards the center, where they would pile up. Second, rather than moving the block directly like one does in say Tetris, in Polaris you would instead rotate the grid (or polar map) underneath the block, while the block stays anchored to the side. After about two weeks using and learning the iPhone SDK, I had my first working prototype:

Early rough prototype

It’s a far cry from the more polished concept art to be sure, but all the game logic is there: you can rotate the grid with your thumb, and use the other to push blocks in order to pile them up at the center of the polar map. After some aesthetic tweaking this was the result:

Round ed grid and leg end at the bot tom of the screen

This is where the long experimentation phase began. First, an interesting idea presented itself: by switching to polar coordinates blocks no longer need to appear and fall from one direction only. They could appear on either side of the screen; or better yet, two different blocks could be on the screen at all times. This adds a completely new strategy element to Polaris: the player can choose which block to place on the pile, as well as reserve a “rare” block for later use. And if the player is really clever, then perhaps they could use both blocks at the same time!

Blocks on either side of the screen

Eventually I settled on game rules that require the player to form complete rings of “deactivated” tiles. The player can deactivate any tile by matching it up with a neighboring tile of the same color. Once a complete ring of inactive tiles is formed, it “collapses” into the polar star at the center. Whatever remains of the pile then settles under gravity.

The player can follow two distinct strategies in order to achieve high scores. The first is to clear multiple rings at once. This is done in a similar manner to Tetris, where the player intentionally leaves a gap in the rings. Unlike Tetris, the player can fill this gap with up to two matching blocks in one move. In this manner, up to 5 rings can be cleared at once.

The second strategy is to set up chain reactions. The player does this by building up layers of complete, but not fully deactivated rings. On top of the outermost ring a carefully color-coordinated pile of blocks needs to be placed, such that the outer ring’s collapse causes the pile to settle under gravity and successively deactivate and collapse inner rings one at a time.

Finished Game

This dual nature of Polaris arose out of experimentation with different game rules and game mechanics—one that I did not anticipate when I first conceived of the game. Pictured above is the final look of Polaris. To see some of the game mechanics mentioned here, please watch the video in my previous post.

About 95% of the code is written in pure C++ (for portability and familiarity reasons), with some hooks into the Cocoa framework using Objective-C++ for system specific functions (application start-up, text drawing, and sound support). Polaris was a very fun project to work on, not only because writing games is fun, but also because of the technical and artistic challenges.

The first and second generation iPhone is OpenGL ES 1.1 capable. As such effects must be realized without any use of shaders. Instead one must rely on clever use of multiple textures, texture transformations, and various blending modes.

The game’s logo was created in Inkscape—an open-source vector graphics editor. Other in-game graphics were created in Photoshop. For the nebulous background I loosely followed these two tutorials: Space Lightning Effects and Creating Clouds. For artistic inspiration I like to browse Smashing Magazine, which I find to be an excellent aggregator of top-notch graphics design.

Polaris is available in the App Store for the iPhone and iPod touch! Check out the game’s website for more information.

Raytracing Final Project (more images after the break!)

Some features of the raytracer are:

1. CSGs, Arbitrary Polygonal Objects (loaded from wavefront obj files)
2. Normals are phong interpolated for smooth shading
3. Texture mapping with bilinear interpolation. Can be applied to any channel of phong model, as well as luminosity
4. Reflections and refractions
5. Diffuse (blurry) reflections and refractions (diffusivity can be set)
6. Point lights with shadows
7. Area lights: Polygonal geometry can serve as an area light. Texture can be applied to the luminosity channel of the  geometry; this way the mesh can cast light with varying color and intensity over its surface.

The images below show how these features can be applied to a scene in order to enhance its visual appearance:

signature

diffuse

shadows

reflections (recursion depth: 1)

reflections (recursion depth: 2)

texture mapping

refraction (blue sphere)

diffuse reflections & refractions

area lights (and resulting soft shadows)

CSG subtractions

Finally, the images below combine the features of the raytracer. These images were submitted to the Wooden Monkey competition and took first place. In order to tune the lighting and various other parameters, thumbnail-sized images were rendered. Rendering times for full resolution images were about 2 hours each.

Scene 1 Close-up Test Rendering

Scene 1 Final

Scene 2: More Geometry

Scene 3: Colored Area Light

32GB of glorious RAM!

Matlab "idling" at 13GB

I’ve had this setup for about a year now. It’s running Ubuntu 8.04 and Matlab 64-bit on a quad core 2.33MHz Xeon and 4 x 8GB DDR2 667 modules. My algorithms are databound, hence the fairly low CPU clock rate.

Only one question remains: Will it run Crysis?

A study conducted by MIT researchers Pawan Sinha, Benjamin Balas, Yuri Ostrovsky, and Richard Russell looks at the ways people recognize each other in order to help guide computer vision research towards building better face recognizers. Their study “Face Recognition by Humans: Nineteen Results All Computer Vision Researchers Should Know About” identifies several characteristics that humans use to recognize faces.

Humans are able to handle significant degradations in images. Faces include Bill Clinton, Tom Hanks, and Jay Leno.

One of the results is that humans can recognize faces even in very low-resolution images. Eyebrows are one of the most important features for recognition. And our ability to tolerate degradations increases with familiarity. Read the full study here. The researcher’s website is found here.