Author: Jackson Pruitt

Having developed an adaptation of our midterm assignment, we had the benefit of hindsight when it came to designing our final project. In fact, our main source of motivation to continue developing the Pirate Chase game was to further realize our original concept with a better design. One of the first aspects we knew needed to be changed was that the game needed to be bigger and more dynamic. An initial challenge was finding an adequately sized base for which could fill enough water for the game to function properly while also not becoming too much of an impediment. The decision to use a small inflatable pool only came to mind once we decided that in fact having a circular base would allow for the game to be more dynamic as players would be inclined to move around the entire structure in order to blow the boats towards the sensor. Secondly, we knew that the boats needed to be secure enough so as not to break, fall apart, or immediately sink after several uses. For this, we made sure to leave ample time to 3-D print four boats of the same size, attaching plastic sails afterward. The boats were then painted a different color to distinguish each individual player’s boat. Thirdly, my partner and I decided to add an additional component to the design that would serve to make the game-play more challenging. Keeping in line with the theme of the game, we felt it would be most suitable to design a machine that creates waves for the boats as this would make blowing the boats across the body of water less consistently achievable. Lastly, with the infrared sensor, we felt the component didn’t require much alteration as we felt a light sensor would be less responsive and infrared allowed us to ensure that one user would account for the ending of the game. 

Project design during user testing:

Users interacting with the project during user testing:

Testing out 3-D printed wave-making component:

Painted 3-D printed boats:

I’d say that the most challenging part of the production process came from the Processing portion of our final project. I felt that, although we had a clear idea of how the design should be laid out and a basic understanding of serial communication, there was a steep learning curve required to finalize the coding to ensure the project would work every time. With enough time dedicated, however, we were able to fulfill this component to our satisfaction. Interestingly, during our user testing, we received very little critic in terms of functionality or concept. Most users enjoyed the concept and thought it was well-realized without much explanation. Additionally, there were few reservations with how users interacted with the game. That being said, we found that a lot of users wished the project had more of a pleasing aesthetic to make the game more inviting. Also, many users recommended we simply set up our project differently so that it would be easier for future users to go around the table and to interact with the computer screen without taking attention away from the physical structure. For the final presentation, we made sure to add several design components to make the game look more appealing. Additionally, we arranged the computer monitor to face users while they were playing in front of it. The results proved to be rather effective, especially during our showcase, as users were more intrigued with a better aesthetic design to our project. The shift in the layout also helped users to follow the narrative in which the game is played. 

First sketch of project layout and design:

The purpose of this project was to develop a game in which users would challenge one another in order to reach a commonly desired end-goal, which in turn would demonstrate this sort of “tragedy of the commons” scenario seeing how individuals act independently against the common good of others. Through layers of challenges, both physically and to some extent emotionally, users would take part in a conversation with the game is the input/output system was apparent. The idea of having a boat being moved to reach a sensor, highlighting the end of the game, served as the main portrayal of this conversation. Although my definition of interaction being a form of conversation has not necessarily changed, the completion of this project taught me the scope in which interaction finds itself. Even though my intention was to create a series of functions resulting in a form of communication of a human-machine level, the interaction continued throughout the process. Users began communicating with each other, with us, to themselves, all based on one form of interaction. I’ve now understood that interaction is just a one-time event but rather links itself perpetually to a chain of communications that may take place in all different forms. 

I think if given more time and more resources, I would like to make this project bigger. The effectiveness of adding challenging components to the design worked so well at creating tension and furthering this form of interaction that I would really enjoy seeing this project at its largest state. For example, having more than just two users competing for the end-goal and as well as having stationary obstacles that would require users to maneuver through this course. In summary, I think this project has shown me the value of proper communication in the modern environment. With so many people putting others down to achieve seemingly one target or goal, the realization that life’s journey along the way is just as important becomes lost. 

Moving image with a varied tint.

Processing:

import processing.serial.*;
import processing.video.*;
Movie myMovie;

Serial myPort;
int valueFromArduino;

void setup() {
  size(500, 500);
  background(0);

  myMovie = new Movie(this, “dancing.mp4”);
  myMovie.play();

  printArray(Serial.list());
  // this prints out the list of all available serial ports on your computer.

  myPort = new Serial(this, Serial.list()[ 12 ], 9600);
  // WARNING!
  // You will definitely get an error here.
  // Change the PORT_INDEX to 0 and try running it again.
  // And then, check the list of the ports,
  // find the port “/dev/cu.usbmodem—-” or “/dev/tty.usbmodem—-”
  // and replace PORT_INDEX above with the index number of the port.
}

void draw() {
  // to read the value from the Arduino
  while ( myPort.available() > 0) {
    valueFromArduino = myPort.read();
    // fill (250);
    //ellipse(200,200,valueFromArduino,valueFromArduino);
  }

  if (myMovie.available()) {
    myMovie.read();
  }
  tint(valueFromArduino, 0, 0);
  image(myMovie, 0, 0);

  println(valueFromArduino);//This prints out the values from Arduino
}

Arduino:

// IMA NYU Shanghai
// Interaction Lab
// This code sends one value from Arduino to Processing

void setup() {
Serial.begin(9600);
}

void loop() {
int sensorValue = analogRead(A0) / 4;
Serial.write(sensorValue);

// too fast communication might cause some latency in Processing
// this delay resolves the issue.
delay(10);
}

Reflection:

In the reading Computer Vision for Artists and Designers, there is a quote that reads, “Processing is one such environment, which, through an abundance of graphical capabilities, is extremely well­suited to the electronic arts and visual
design communities. Used worldwide by students, artists, designers, architects, and researchers for learning, prototyping, and production, Processing obtains live video through a QuickTime­based interface, and allows for fast manipulations of pixel buffers with a Java­based scripting language.” Levin, Raes, and Fry are articulating the potential processing has in the visual media arts which is exactly what we took part in during the recitation exercise. Although I was only able to complete the task using one sensor to manipulate one aspect of the video, I feel that this could be further utilized in more advanced software technology such as automizing color grading in film or photography.

Image of the completed etch-a-sketch with drawing

Physical setup

Tinkercad schematic 

import processing.serial.*;

String myString = null;
Serial myPort;


int NUM_OF_VALUES = 2;   /** YOU MUST CHANGE THIS ACCORDING TO YOUR PROJECT **/
int[] sensorValues;      /** this array stores values from Arduino **/
float preX;
float preY;


void setup() {
  size(500, 500);
  background(200);
  setupSerial();
 
}


void draw() {
     //map(sensorValues,0,1023,0,255);
  updateSerial();
  printArray(sensorValues);
 // ellipse(sensorValues[0], sensorValues[1], 25, 25);
  
  //float posX = sensorValues[0];
 // float posY = sensorValues[1];
   
float posX =  map(sensorValues[0],0,1023,0,width);
float posY = map(sensorValues[1],0,1023,0,height);
 fill(0);
  line(preX,preY, posX, posY);

  preX = posX;
  preY = posY;
  // use the values like this!
  // sensorValues[0] 



  // add your code

  //
}



void setupSerial() {
  printArray(Serial.list());
  myPort = new Serial(this, Serial.list()[ 9 ], 9600);
  // WARNING!
  // You will definitely get an error here.
  // Change the PORT_INDEX to 0 and try running it again.
  // And then, check the list of the ports,
  // find the port "/dev/cu.usbmodem----" or "/dev/tty.usbmodem----" 
  // and replace PORT_INDEX above with the index number of the port.

  myPort.clear();
  // Throw out the first reading,
  // in case we started reading in the middle of a string from the sender.
  myString = myPort.readStringUntil( 10 );  // 10 = '\n'  Linefeed in ASCII
  myString = null;

  sensorValues = new int[NUM_OF_VALUES];
}



void updateSerial() {
  while (myPort.available() > 0) {
    myString = myPort.readStringUntil( 10 ); // 10 = '\n'  Linefeed in ASCII
    if (myString != null) {
      String[] serialInArray = split(trim(myString), ",");
      if (serialInArray.length == NUM_OF_VALUES) {
        for (int i=0; i<serialInArray.length; i++) {
          sensorValues[i] = int(serialInArray[i]);
        }
      }
    }
  }
}

void setup() {
  Serial.begin(9600);
}

void loop() {
  int sensor1 = analogRead(A0);
  int sensor2 = analogRead(A1);
 

  // keep this format
  Serial.print(sensor1);
  Serial.print(“,”);  // put comma between sensor values
  Serial.print(sensor2);
  //Serial.print(“,”);
 
  Serial.println(); // add linefeed after sending the last sensor value

  // too fast communication might cause some latency in Processing
  // this delay resolves the issue.
  delay(100);
}

Pirate Chase 2.0 – by Jackson Pruitt

The final project proposal chosen was the adaption of my partner’s and my midterm project: Pirate Chase. The conception of this project was to allow users to interact in a space that assesses their willingness to sacrifice others in order to achieve personal gain when in reality, cooperation is more beneficial. However, the existing model of this project did not fully realize this intention and, therefore, we’ve decided to adapt the project to have a stronger focus on this idea. The new design of the project is one that is larger and has a singular goal, allowing more users to compete and an increase in competitive interaction. The concept mimics closely to the concept conceived by evolutionary biologist Garret Hardin called “tragedy of the commons” which describes a circumstance where an individual acting on their own self-interest will deplete resources against the benefit of the common good. The interactions accumulated by a public audience engaging with Pirate Chase will physically display the repercussions of competition with a singular goal.

In order to realize this goal for our project, my partner and I have devised several new components that will allow for better user engagement and comprehension of the idea. Firstly, we plan on making the design a lot bigger by using a small plastic pool made for small kids. The size will allow the game to consist of up to 4 different users, which would make competition higher and the game more challenging. Secondly, we will design several obstacles placed throughout the body of the game to increase navigation challenges faced by users in comparison to the former one-lane model of our midterm project. This will not only enhance competition but also make the game more dynamic as if offers users to be more strategic in their interaction. Another component is the island sensor, which will be a singular infrared sensor placed in the middle of the body symbolizing the “limited resource” of the common. Lastly, processing features will allow us to display game rules and a clearer proclamation of a winner relative to the red LED used in our previous model. Additionally, this will allow for better game aesthetics.

There has been a lot of research that has inspired the design and conception of this project. One of the articles that really stuck out to me was Bret Victor’s A Brief Rant On The Future of Interactive Design, as he mentions that we should strive to design interactive products using a “dynamic medium that we can see, feel, and manipulate”. I thought that by including the element of using your breath to move the boats takes away this privilege of interaction and would further support his idea as there’s a struggle of not being able to fully feel or manipulate the boats. Another piece that inspired me was one I saw at the Chronus Exhibit that used both natural elements along with technological ones. Although I enjoyed seeing this juxtaposition aesthetically, I thought the main conceptual purpose of having both nature and technology presented in my project would fit the context of the “tragedy of the commons” very suitably. I feel that both of these pieces are insightful to the general public, which is the primary audience of Pirate Chase. I think that for younger users, the purpose would be contextualized as something more entertaining and fun, whereas for older users, the context would be more apparent to this idea of competition for a limited resource.

Works Cited:

Tragedy of the Commons

http://worrydream.com/ABriefRantOnTheFutureOfInteractionDesign/