Processing code examples of basic game component logic
Switch branches/tags
Nothing to show
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Failed to load latest commit information.
block_sequence
choose_statements
circle_square_triangle
cups
dig_path
dodge_enemies
floater
item_collecting
item_collecting2
item_collecting3
matching
number_sort
racing
response_time
sequence_recall
shape_tracing
shooter
simple_maze
sorting
speed_click
spot_the_difference
word_guess
LICENSE.md
README.md

README.md

Game Building Blocks for Processing

My interaction design students learn basic programming skills in Processing through the design and development of a digital game. Most, if not all, students begin the project with absolutely no programming experience, so many of them are understandably apprehensive about the notion of creating a game from nothing in the span of only a few weeks.

Processing, "a programming language, development environment, and online community" that "promote[s] software literacy within the visual arts and visual literacy within technology," frames learning to code as involving "looking at lots of other code: running, altering, breaking, and enhancing it until you can reshape it into something new" [1]. As both a learning method and as general practice, the re-use of code written by others is actively encouraged within creative code communities [2].

In the first stage of the project, students design an interactive flow structure for their desired game. Opportunities for leveraging existing sources of relevant code, which include the Game Building Blocks for Processing, as well as other pieces of code that developers have freely shared elsewhere, are identified at this point. It is then up to the students to analyze these pieces of code, understand how they operate, and synthesize / extend them to form their envisioned game [3].

The Blocks are not intended to be fully realized and refined games, nor are they examples of highly optimized code. Rather, they focus on demonstrating basic game component logic through neatly formatted code that has been commented in detail. The use of objects is deliberately avoided in order to more clearly reveal the logic behind certain functional aspects.

Blocks

  • block_sequence: match a displayed sequence using the keyboard
  • choose_statements: select as many correct statements in a row as you can
  • circle_square_triangle: an implementation of Rock-paper-scissors, played against the computer
  • cups: an implementation of the classic cup game: pick the correct circle after it has been moved around
  • dig_path: use the keyboard to dig downwards and leave a path behind
  • dodge_enemies: avoid moving shapes using the keyboard
  • floater: move between two goals by using the space bar
  • item_collecting: collect moving shapes using the mouse
  • item_collecting2: a variation on item_collecting; move shapes into a container
  • item_collecting3: a variation on item_collecting; collect shapes before they fade away
  • matching: identify and remove matched pairs of items
  • number_sort: arrange numbered blocks numerically using as few moves as possible
  • racing: a variation on response_time; move across the window before your challenger does by pressing keys repeatedly
  • response_time: press a specified key before a challenger can press theirs
  • sequence_recall: recall a specified sequence by pressing a series of buttons
  • shape_tracing: accurately trace a displayed shape before time is up
  • shooter: shoot moving enemies before they hit you; hold down the mouse to increase shot speed
  • simple_maze: navigate a cursor through a maze
  • sorting: place items of different types into their respective bins
  • speed_click: destroy shapes by clicking on them in quick succession
  • spot_the_difference: spot the different object in each level
  • word_guess: sequentially guess the letters of a randomly chosen word

This project is in continued development, with more Blocks expected to be added over time.

Compatibility

All of the Blocks have been tested with Processing 3.3.6 (Java mode).

License

The Blocks are licensed under The MIT License.

About the author

Brad Tober is a designer, educator, and researcher whose work explores the potential of emerging code-based and interactive visual communication technologies, with the objective of identifying and investigating their relationships to design practice and pedagogy. His practice-led research entity, the Experimental Interface Lab, is characterized by a speculative approach to design (a manifestation of pure research) that recognizes that forms of and methodologies for contemporary practice that spans design and technology are best developed through fundamentally flexible and exploratory processes. Brad holds an MDes from York University (Toronto, Canada), a BFA in graphic design from the Savannah College of Art and Design, and a BA in mathematics from the University at Buffalo.

Brad is available for freelance design work, invited speaking engagements, and workshops—both near and far. He is also interested in forming productive collaborations involving both design research and practice. E-mail him at brad@bradtober.com, or visit his website at http://www.bradtober.com.

References

  1. Processing.org. Processing. 2013. Web. 25 Oct. 2013. http://www.processing.org/.
  2. Tober, Brad. "Keeping the Balance: Copyright, Plagiarism, and Creative Code in the Classroom." Interartive 50 (2013). Web. 25 Oct. 2013. http://artcopyright.interartive.org/copyright-plagiarism-creative-code/.
  3. Tober, Brad. "Creative Code in the Design Classroom: Preparing Students for Contemporary Professional Practice." An Illinois Sampler: Teaching and Research on the Prairie. Eds. Antoinette Burton and Mary-Ann Winkelmes. Champaign, IL: U of I Press, 2014. Print.