Note: Developed for (480 x 800) screen resolution

Snapshots:

——————————

Final project for Introduction to Computational Media at ITP – NYU

Purpose: BeerBingo attempts to bridge the gap between location-based gaming and physical socializing.

How it works:

• Gamer enters zipcode
• App accesses database to gather relevant information
• Gamer is presented with a bingo board with nine (9) touchable tiles.
  • Each tile represents a bar. When tile is touched:
  • Revalant information for the bar is shown
  • Map of bar’s location is also shown.
  • Gamer can either select ‘yes’ for if they visited the bar or ‘no’ if they have not
    • Clicking ‘yes’ takes gamer back to the bingo board, with associated tile blacked out and unresponsive
    • Clicking ‘no’ takes gamer back to the bingo board, and associated tile has full functionality
• Once gamer gets bingo:
  • Click on bingo button
  • If Bingo has been achieved, go to congratulations screen
  • If Bingo has not been achieved, stay in bingo board screen.

Precautions:

• Issue: Slow data load
  • Solution: Loading screen implemented
• Issue: Non-digits entered
  • Solution: Only accept digit input
• Issue: Non-existant zipcode
  • Solution: Asks for zipcode again
• Issue: Wrong digit selected
  • Solution: Delete key offered on-screen
• Issue: Prematurely selecting continue button
  • Solution: Continue buttons disabled until gamer enters appropriate info

Development Process:

• Get API’s working properly
• Design Bingo Board
• Determine classes & objects needed
• Develop classes
  • Front-End
    • Bingo Board screen
    • Detail screen
    • Bingo screen
    • Input screen
    • About screen
  • Back-End
    • Main API class
    • Map API class
    • Bingo Algorithm
    • Keypad
• Integrate classes
• Button functionality
• Debugging Mode
  • Debug Code
  • Comment Code
  • Clean Code
  • Make code efficient
• Export for Android

Bugs/Issues:

• Designed for 480×800 px screen. Performance on other resolutions will vary.

Future Development:

• Implementing GPS to populate bingo board based on gamer’s location
• Implementing GPS to mark bars visited by gamer

Solution: Code

Note: Please Drink Responsibly

People enjoy playing games. Folks would rather spend countless hours trying to pass level after level than socializing. There is a push in the gaming industry to bring the social aspect into the gaming world. Originally what started as a one person game evolved into a two-person game where the games would see each other physically. Games later evolved to include online multiplayer, which allowed a great deal of people to socialize, but removed the physical aspect. Recently there has been a move to bring back the physical socializing aspect of gaming, with games like RockBand and consoles like Microsoft Kinect and Nintendo Wii. The problem with these solutions is that while the games are socializing, they are not meeting new faces, places, and adventures. These games and consoles allow for physical socializing in a location all to common: our living rooms.

For my final project, I would like to design & develop a dynamic web-based application for the Android that merges location-based gaming with physical computing.

The program itself is a bingo game, where the gamer fills up the bingo board by visiting the bars. Once the gamer gets bingo, he/she gets to press the bingo button and celebrate his/her victory.

The app itself will be coded using Processing and Java. To gather information from the web, Yahoo! APIs will be used.

Resources:

• Android – Processing
• Android  Developers
• Processing & Android

Coding Assignment: Create a sketch that loads data into Processing or saves data out of Processing using loadStrings() and saveStrings()/PrintWriter.

Solution: Processing Code

“Greetings From New York” is a digital tourist postcard. The foreground of the card contains the symbolic “greetings from New York”, as seen on countless postcards. The background is made up of up to date traffic information in Manhattan, specifically the 10003 area. The data is provided by Yahoo!’s Traffic API, then parsed for the specific content.

Coding Assignment: Complete midterm assignment. Document the “larger idea” for the project, as well as your”one-step” implementation exercise.

Project: Motion Breaker. Players must break all the blocks on the screen by using their body as a game controller. Blocks must be broken in a proper sequence in order to win the level.

Larger Idea: Multi-level timed game where players must break blocks in a proper sequence. High scores, which are sent to a server and displayed in the game, are achieved by taking the least amount of time to break blocks.

One-Step Implementation:

• Create block class
  • Animate blocks
    • Startup animation
    • In game animation
    • When blocks are knocked
  • Start cleaning code
• Create driver class
  • Add computer vision
  • Create user interface (UI)
  • Add motion detection
• Add communication between driver & block classes
  • Getter & setter methods
  • Other support methods
• Comment Code
  • Mark areas to redesign and/or fix

Solution: Mac, Windows

NOTE

For simplicity sake’s (and due to being a midterm), code has been compiled as an application.

Creative Process: Originally I wanted to start with a “Simon Says” time game, and spent a good eight (8) hours coding it. At the end the the day, I was not happy with the code. It was too complex, sloppy, and I did not feel it represented my skill set. I metaphorically “threw away” the code, and started from scratch. I wanted to design & develop a game where the player could see a pixelated version of themselves trying to knock down blocks. The idea of having one block that must be knocked down at the end was implemented in order to prevent the player from just waiving their hands around to knock down blocks. Giving precision makes the player be more focused on playing the game.

Issues: As stated above, the code should be cleaned and made more efficient. Not only will this help me if I work on the code later, but it will make it run faster and have less slag.

This is yet another add-on to “Video Manipulation – ICM”.

Coding Assignment: Incorporate the pixels of an image (or video) into a Processing sketch.

Solution: Processing Code

NOTE
Due the usage of a webcam, this code will not run via the applet. Download the code and run it locally.

This solution is motion detection. If the camera perceives motion at the top left or right corners (50 x 50 pixels), it will draw a white square to signal motion in that general area.

Issues: Currently the ‘computer vision’ is very sensitive, so it will pick up the slightest movement. In theory this is great, but in practice it does cause a few issues. The most predominant one is that if there is no change in motion between frames, it will not draw the square. Consider the fact that the webcam is set to capture at 30 frames per second. Future revisions of this code will include making the computer vision less sensitive and keeping the drawn white squares on the screen a little longer.

Coding Assignment: Incorporate the pixels of an image (or video) into a Processing sketch.

Solution: Processing Code

NOTE: Due to the usage of a webcam, this code will not run via the applet. Download the code and run it locally.

This solution in a nutshell is a grain filter. It randomly takes a 20% sample of all the available pixels and modifies its RGB values by a value of -20 to 20. The outcome looks like there is grain embedded in the signal.

During the first run of this solution, the grain was added as a layer on top of the video instead of being embedded with the video. This the overal image look fake due to only having grain of one color. I wanted the grain to look more organic, like a 1990′s television transmission.

Solution A: Processing Code

Solution B: Processing Code

NOTE: Due to the usage of a webcam, this code will not run via the applet. Download the code and run it locally

Both solutions are based on the idea of photomosaic. The overall image, in this case video, is composed of scaled down duplicates of the original image. Each of these scaled down duplicates is tinted to represent the overall pixels (sections of the original image) it is replacing. By focusing on the canvas at large, the overall image can be seen clearly while the smaller images seemed pixelated, and vice versa.

In Solution A, the camera capture dimensions (640 x 480) is the same as the output/screen dimensions. In Solution B, the output/screen dimensions (1280 x 960) is twice the size of the camera capture dimensions, and the code reflects the adjustments needed to display the image properly.

It is important to note that the order of the image called to be ‘drawn’ on the screen is important. In Solution B, for example, if the four ‘image()’ methods are called in a different order, it will not display the output correctly.

Solution: Processing Code

SpellBot V3 code was given a major facelift. Previously there was only the main class with a great number of methods that dealt with the bot, bubbles, bar, listeners, and instructions. This time around, each on of the previously mentioned sections have been separated into their own class, with appropriate methods. This not only allows for better organized code, but for smarter solutions to previous issues. Instead of having multiple methods making sure only one item was carried at a time, now only one method is needed.

From a user’s standpoint, nothing has changed. From a programmers view, the difference is night and day.

7-8: Write a function that takes one argument-F for Fahrenheit-and computes the result of the following equation (converting the temperature to Celsius). C = (F – 32) * (5 / 9)

Solution: Processing Code

8-5: Rewrite the Example 5-9 (Gravity) using objects. Include two instances of a “Ball” (or whatever you call it) object.

Solution: Processing Code

For 7-8, “float c = (5/9);” returns 0.0. I got around this by using modulo and multiplying by .11, “float c = (5 % 9) * (.11) ;”. The other (proper) solution would be to change 5 & 9 to 5.0 and 9.0, to get more accurate results. The example provided above uses modulo.

Spell Bubble V2

My Solution Code

Version 2 of SpellBot contain cleaner code, more usage of conditionals, and a few required updates. The eyes, for example, are animated when SpellBot moves around with a letter bubble. Instructions are also presented at the beginning, where a custom button as created. I realized that the game makes no sense unless there are instructions. Most people would ignore instructions, but by making the suer click on a button, it at least puts emphasis on the screen text.