Introduction


Light-Bot 2.0 is a 2D Flash game developed by Danny Yaroslavski for Armor Games that is designed as a game to teach the backbone of functional and procedural programming to players.

Below is a detailed analysis of this game roughly following Brian Winn's1 Design/Play/Experience framework, including:

Learning


Light-Bot 2.0 is a Flash puzzle game that teaches the programming mindset. The basic intended learning outcomes include:

Storytelling


The setting in Light-Bot 2.0 is a rather drab world of stackable blocks which make up different shapes depending on the level. The player plays as the Light-Bot, who has been upgraded from its first edition to a more complex second edition.

Light-Bot 2.0 needs to get from the start of the level to the end by lighting up switches along the way. To do this, Light-Bot's controller (the player) gives Light-Bot directions on how proceed through the level.

Light-Bot 2.0 facilitates the learning of simple programming by linking simple commands and the actions of the robot (Light-Bot). The simple actions directly relate to the frame of mind a programmer needs.

Gameplay


Light-Bot 2.0 gives simple commands the player uses to move the Light-Bot from start to finish via a drag and drop interface.

There are nine commands:

  1. Move Forward
  2. Rotate Clockwise
  3. Rotate Counter-Clockwise
  4. Jump Up/Down
  5. Enable/Disable Switch
  6. Start Function One
  7. Start Function Two
  8. Stop Current Function
  9. Conditional Based on Color

In the tutorial level, the player experiences slight fading, as the game highlights how to use the interface and what each command does with the use of arrows, as seen below:

The player places these commands into an order for the Light-Bot to execute with the goal of successfully turning on every switch. The challenges come from the variety of the puzzles and the mixing of different commands to achieve the same result. Because there can be multiple combinations to successfully complete the puzzle, the player can feel unique with his or her attempts.

The players experience shaping as the puzzles slowly build off of one another until the Expert levels show up, which is where all of the player's learning comes together for a few final puzzles.

Most players of Light-Bot 2.0 will feel frustration with some of the puzzles. However, when they figure out those puzzles they will feel accomplished. This makes the player feel as if they have overcome a particularly difficult task.

Other games utilize the same simple command structure with a drag and drop interface such as Algo-Bot2, Robot Trouble3, and others.

User Experience


The user interface for Light-Bot 2.0 consists of the main puzzle on the left and the different methods and commands on the right. This evokes a split-screen feel of many debuggers.

On the right side, the nine commands that the player can use are lined up horizontally along the top. Underneath those commands are the three different methods: Main Method, Function 1, and Function 2. Each method has a number of slots which correspond to the total possible commands it can contain: 16, 8, and 8 respectively.

Alongside the bottom of the right side are debugger options. The System Clock slows down or speeds up the rate which the Light-Bot executes the commands, and the Break/Run button which stops or starts execution. Lastly, there are two sections alongside the bottom which inform the player of the number of commands they have used (a maximum of 32) and the number of calls the current execution has run (which can vary).

The icons are all rounded-rectangles and clearly fit within the slots in the methods. The Run/Break button clearly evoke the same buttons in actual debuggers. The puzzles are all stacked half-cubes that the player can rotate around, but it is often simpler to look at the puzzle from just one angle.

The interface does end up evoking a slim version of a simple debugger, which helps inform the programming mindset. It's very clean and uniform while not interfering with the puzzle at hand.

Technology


Light-Bot 2.0 is played in a modern browser that has Adobe Flash Player installed.

There isn't any reason for this game to be developed using any other platform. Using Flash, at the time, ensured that this game could reach as many people as possible. The game runs cleanly and the developer even created a level editor so that players could make levels for the community. If this game was to be redesigned today, it would probably be better to create it for HTML5 so that it could also be accessible to the mobile crowd who often don't have access to plugins such as Flash (which has been discontinued in mobile form by Adobe).

Additionally, this game is hosted on Armor Games, which is blocked in most grade schools. Distributing this on the developer's personal site, or another site, would probably be a better way to get it into the hands of young programmers.

Assessment


No formal assessment of the game exists. However, there is a leaderboard based on the number of commands and calls the player uses per level. The lower the score the better the ranking, as less commands and calls equates to sharper code.
To test how well the game taught functional and procedural programming the player's initial score could be compared to a later score of similar puzzles. Players who show better scores (lower in number) would have cleaner code. Additionally, the time it takes the player to get through the puzzles could also be used to test whether or not the player has learned from the game.

Conclusion


Light-Bot 2.0 proves to be challenging, engaging, and educational at the same time. It clearly teaches basic functional and procedural programming exercises by slowly working the player through the concepts of recursion and loops to conditional statements. Each level is shaped by the previous levels with new information being taught every few levels. This allows the player a level or two of more complex usage before being asked to learn a new skill.

The game also somewhat rewards the players who write cleaner and more compact functions by giving them a lower score. If a Light-Bot 3.0 were to come out, a better reward should be implemented to further encourage the refactoring of rotten methods.

For players who are already programmers, this game serves as a challenge to utilize their problem-solving while still remaining difficult.

As a game which was not made as a serious game, Light-Bot 2.0 does a marvelous job at teaching players how to think like a programmer without much effort. Players are misled by thinking of Light-Bot 2.0 as a game and learn while solving the puzzles, which is what makes the game as fun as it is.

References

  1. Winn, Brian. The Design, Play and Experience Framework. In R. Ferdig (Ed.), Handbook of Research on Effective Electronic Gaming in Education. Hershey, PA: IGI Global, 2009, pp. 388-401.
  2. "Algo-Bot" Fishing Cactus | Digital Platforms Game Development Studios. Web. 31 Jan. 2013.
  3. Lazarov, Aleksandar, João Serra, and Rafał Gicgier. "Robot Trouble." Robot Trouble. 21 June 2011. Web. 31 Jan. 2013.