Author: Jack Simon

Auditory ‘Temple Run’ – Jackson Simon – Rodolfo Cossovich

Conception and Design:

I started off just really wanting to create a game, and through conversations with Rudi “Temple Run” came up. I was not about to create a replica of an already made game, but I had this idea that “Temple Run” could be turned into a pure audio game. Audio of a direction played would let the user know where to go, instead of having visual aid. At first, this audio game  was intended to try and potentially help visually impaired people in some way (perhaps helping them know which way they could move in a day to day life, while walking down the street, with the directions being said out loud). However, this was quite presumptuous seeing as I do not know people who have lost, or never had, their eyesight. Therefore, I could not accurately figure out what best way to aid them. The game then turned into an inclusive game, allowing both people who can see, and those who cannot, to be on the same playing field and enjoy themselves. 

Fabrication and Production:

In the beginning (for user testing), I neglected to emphasize the experience of being blind for those who indeed were not. In fact, I started with a joystick as the means of going up, down, left or right. After the feedback I received, it was clear that I needed to switch the way of interacting with the game, and after conversations with Rudi: I decided to use an accelerometer attached to a headset with ‘blinding’ glasses. This allowed for an amplification of the dulling of senses. I realize now that a gyroscope might have been easier, and more successful, in reading the directions (now attached to the way the user moved their head) and in user usability. I believe changing the way the user moves directions, while having their eyesight dulled (for users who are not visually impaired), made it so that a sort of equal ground for playing games was added. Plus, it made it more fun and interactive in a different way then just a simple joystick.

Conclusion:

This game was meant to be able to be played by visually impaired and non-visually impaired people alike. My definition of interaction doesn’t necessarily involve a back and forth: it could be, for example, just reading a book, the words interacting with your brain, however, your brain doesn’t necessarily interact with the book. In the case of my game, there is a back and forth: the sound with the user, the user with the accelerometer (and by extension the game itself). Therefore, my game adheres to my definition but also expands it since there is more than just a singular interaction (which I believe is all that is needed for something to be called an interactive exchange). The audience therefore receives a stimulation, and causes a stimulation themselves. 

If I had more time there is some definite improvement that I could’ve done. For example, improve the ‘blinding’ of non-visually impaired people (even after tweaking the glasses multiple times you could still sort of see through the corner of your eye) and also make sure that the directional readings were as perfect as could be (they worked well, you could definitely get ten points by going in the right direction 10 times, but it still was a little off at times). It has taught me that the experience had by the user for a game is paramount. I got complaints about the uncomfortableness of the headset (which definitely could’ve been made to be nicer), which leads to people not necessarily wanting to where it: which means they wouldn’t play the game! If I were to make another game, similar or not to this project, I would put more focus on the experience (even though I had people that did enjoy it and have fun at the IMA Show) and not just the idea behind the game (even if it is still important).

So what? Why should people care about this project? It definitely did accomplish my goal to a certain extent: a level playing field, no matter if you can see or not. I feel that equalizing the way games are played, while enhancing user experience, is a goal all games should strive for.

For this recitation, the workshop recitation, I decided to attend the one on Serial Communication by Mister Young. I feel it was quite important for my project, since I would need to both be communicating from Arduino to Processing and Processing to Arduino at the same time.

I learned how to make a sensor value from the Arduino influence Processing (for example, in my Final Project, an accelerometer influenced whether the game would continue in Processing).

In this simple example shown in the video below, I connect an Infrared Sensor to Arduino and map the values from 0-1023 to 0-50 and have them being read in Processing.

It ended up being useful (at the start of my project, before I decided to have the start of the game be a different way than with an infrared sensor) since when a person would walk in front of the sensor it would turn on the game in Processing, and start the audio from Processing.

This documentation asked us to create an image made up of different shapes, then to display that image 100 times. After that, to display the 100 times on an infinite loop (using draw() ). The main challenge of this recitation was to use certain functions (i.e. a for loop), and arrays. A for loop allows the user to repeat a certain task as many times as they want until the amount is met (without having to copy paste it the amount of times you want it executed). An array allows you store different values in a same variable, making the randomness (or specific randomness, depending on how you store the values in the Array) much easier.

I started by making a simple square, adding an ellipse and triangle as eyes, and a rectangle as a mouth. Then I executed the code so that it would display it 100 times, and keep display it 100 times on top of the last ones displayed, infinitely (while still staying within the sketch).

My code:

My code in action:

Question 1:

The difference between having the for loop in setup versus draw is relatively simple. When it is in setup() it creates the image 100 times and just displays it as such, when it is in draw() it creates the image 100 times over and over, displaying on top of the previous 100 images (unless background() is put into draw, in which case it will keep printing the 100 images but the previous 100 images will disappear).

Question 2:

The benefit of using arrays resides in the use of the same variable, but with different values. In simpler terms, it means that you can have a variable x (for example for a position), and if this variable is set to an array then you can have multiple x positions depending on your needs. You can specifically make x[1], x[2], x[3]  etc. whatever values you need and call on them when necessary; or make x[i], a large amount of x positions, and have them linked to one random value, which would make each x random.

You could potentially use arrays in serial communication, between Arduino and Processing, to allocate each sensor to a specific sensor[i]: rendering the calling on these sensors (in Processing specifically) easier. That is to say, instead of having to recreate values for each sensor, they get allocated to the specific sensor[i] to allow for the values to be transferable between both programs.

For this recitation, I took the image I had made for Recitation 5 and made some changes. The circle now expands and contracts (staying within the bounds delimited by the squares in the image), and also sporadically changes color. Furthermore, I simply added that when mousePressed() , all the squares change color. I realize this is not much change, however, I wished to further the art aspect of Vera Molnar’s piece of art Untitled (1952).

It was educational to use the boolean function, to make sure the circle never went over the squares. And even though it was easy, to use mousePressed() to change the color was fun. However, I do wish I had been able to figure out how to rotate the shapes (I am still confused on how to translate a specific objects height and width!).

My code:

My code in action:

This documentation asked us to find a piece of image art, and copy it, or transform it. I decided to use Vera Molnar’s Untitled from 1952:

I enjoy the simplicity of it. It makes me think that everyone is the same, yet originality is still in all of us. It is quite thought provoking for such a simple image.

I decided to transform it a tiny bit. I made the non-rotated squares have a random fill of color (but they are all the same). And I decided the make the rotated square a white circle. I tried at first to rotate the rectangle, however ran into multiple issues (every time I rotated it it would disappear from the screen), and even when I tried translate() on the squares height and width, it would not work. However, I do think making the rotated square a different shape can have the same effect as Vera Molnar’s piece of art; but also could very well invoke the thought of being totally different from everything else, without any similarities (even though they are the same thing: they are both shapes).

My rendering: