Author: Mandy

For my final project, it is an extension of my midterm project onto a physical scale. The project is a game where two players have to work cooperatively to “dance” to input the right sequence to defeat the orbs that appear on the screen moving closer to them. In my final project I initially wanted to make a dance pad which user can control using their feet, but after evaluating the amount of material and time left to complete the project, I decided to scale down my project scope. Additionally, I decided to make a game box which players can press as in an arcade rather than using the button on my laptop.

Schematic

Serial Communication

For my project, the serial communication was mostly reliant on the signal from Arduino rather than p5. Since I didn’t attach any output device (LED, buzzer) on the Arduino, I didn’t need p5 to send anything back to Arduino. On the other hand, Arduino would continuously check if any of the buttons that I had made were pressed and if they were pressed, send a send to p5 so the characters moved, or the game state changed. In the future, I would like to add a buzzer to indicate a life loss or when the player advances to the next round to provide game feedback to the player.

p5 Code (Serial Communication)

function readSerial(data) {
  // Send control values (left, right) to Arduino
  if (data && data.length > 6){
    let fromArduino = split(trim(data), ",");
    redUP_arrowPressed = int(fromArduino[0]);
    redDOWN_arrowPressed = int(fromArduino[1]);
    redRIGHT_arrowPressed = int(fromArduino[2]);
    redLEFT_arrowPressed = int(fromArduino[3]); 
    
    blueUP_arrowPressed = int(fromArduino[4]);
    blueDOWN_arrowPressed = int(fromArduino[5]);
    blueRIGHT_arrowPressed = int(fromArduino[6]);
    blueLEFT_arrowPressed = int(fromArduino[7]); 
    
    proceedButton = int(fromArduino[8]);
    yesButton = int(fromArduino[9]);
    noButton = int(fromArduino[10]);
  }
}

Arduino Serial Communication

void loop() {
  // Read the state of the UP_BUTTON (HIGH = not pressed, LOW = pressed)
  int redUPButtonState = digitalRead(redUP_BUTTON); 
  int redDOWNButtonState = digitalRead(redDOWN_BUTTON); 
  int redRIGHTButtonState = digitalRead(redRIGHT_BUTTON); 
  int redLEFTButtonState = digitalRead(redLEFT_BUTTON); 

  int blueUPButtonState = digitalRead(blueUP_BUTTON); 
  int blueDOWNButtonState = digitalRead(blueDOWN_BUTTON); 
  int blueRIGHTButtonState = digitalRead(blueRIGHT_BUTTON); 
  int blueLEFTButtonState = digitalRead(blueLEFT_BUTTON); 

  int proceedButtonState = digitalRead(proceedButton); 
  int yesButtonState = digitalRead(yesButton);
  int noButtonState = digitalRead(noButton); 

  // Print the value (HIGH or LOW) to the Serial Monitor
  Serial.print(redUPButtonState);
  Serial.print(",");
  Serial.print(redDOWNButtonState);
  Serial.print(",");
  Serial.print(redRIGHTButtonState);
  Serial.print(",");
  Serial.print(redLEFTButtonState);

  Serial.print(",");
  Serial.print(blueUPButtonState);
  Serial.print(",");
  Serial.print(blueDOWNButtonState);
  Serial.print(",");
  Serial.print(blueRIGHTButtonState);
  Serial.print(",");
  Serial.print(blueLEFTButtonState);

  Serial.print(",");
  Serial.print(proceedButtonState);
  Serial.print(",");
  Serial.print(yesButtonState);
  Serial.print(",");
  Serial.println(noButtonState);

}

Integration of Serial Communication into P5

Since my p5 were originally mapped to button on the keyboard, all I had to do was replace the variables mapped to the keyboard to the Arduino through the serial communication. Although that sounds easy enough to change, when I was implementing the buttons to change the game states, I ran into a lot of problems with the communication because I had initialized my buttons with INPUT_PULLUP rather than simply INPUT. By initializing the button to INPUT_PULLUP, the button was more sensitive and would remain on an ON-state longer compared to initializing it to INPUT. As I wanted a quicker and smoother response with the buttons, I had to make the program wouldn’t move on to the next sequence when the ON-signal was still being processed between p5 and the Arduino. As such I did a hybrid catch statements to make sure the signal was in the OFF-state before it read another ON-state signal.

Controlling the ON and OFF state

if (!serialCheck) {
    isCheckSerial();
  }

  else {
      
    if (proceedButton == 1) {
      buttonReleased = true; 
    }
    
    if (!musicPlaying){
      playMusic();
      musicPlaying = true;
    }

    if (gameState == 'start' && buttonReleased){
      startScreen();
    }

    else if(gameState == 'friendship warning' && buttonReleased){
      showFriendShipWarning(); 
    }
.
.
.

Integration

function proceedButtonPressed(){
  console.log('gamestate', gameState, proceedButton)

  if (gameState == 'start' && proceedButton == 0){
    gameState = 'friendship warning';
    buttonReleased = false;
    
  }

  else if(gameState == 'friendship warning' && proceedButton == 0){
    gameState = 'tutorial';
    buttonReleased = false;

  }

As for the player controls, it was much easier to replace the mapping from the keyboard to the buttons and the ON-signal wasn’t as noticeable.

player1Moves() {
    fill(this.playerColor);
    if (redUP_arrowPressed == 0) {

// redUP_arrowPressed being an int variable that holds either 1 (OFF) or 0 (ON)

Reflection

Overall, I am really happy with the out of my project and amount of time I put into making sure the visuals and themes were consistent. I am really glad people enjoyed the little game I made, and I hope in the future I’ll get to work on it more and make it less buggy. For future implements, I want to make the orbs on the screen be actual creatures or monsters which the players will have to defeat. Additionally, I hope to highlight the combination which the players will have to press, so I don’t have to directly remind or tell the player to read from left to right. I also wish to build a smooth storyline/ streamline from the starting page to the game. Some people were telling me there were too many instructions to read.

On the physical side, I want to make my game pad less wobbly. Due to the wires under the game pad, when players were hitting the key, the input may not always be registered and made the experience a bit less enjoyable. I would also like to add more game feedback in terms of sound and LED lights that can help signal which orb was just defeat or when they move onto the next round. Since these were small aspects to the game, I didn’t focus on these tasks within the time constraint, but for future implementations, these are topics I can think about adding.

Project

Full Arduino Code

const int redUP_BUTTON = 12;
const int redDOWN_BUTTON = 11;
const int redRIGHT_BUTTON = 10;
const int redLEFT_BUTTON = 9;

const int blueUP_BUTTON = 7;
const int blueDOWN_BUTTON = 6;
const int blueRIGHT_BUTTON = 5;
const int blueLEFT_BUTTON = 4;

const int proceedButton = 13; 
const int yesButton = 3; 
const int noButton = 2; 

void setup() {
  // Start serial communication at 9600 baud
  Serial.begin(9600);

  // Set button pins as input with internal pull-up resistors
  pinMode(redUP_BUTTON, INPUT_PULLUP); 
  pinMode(redDOWN_BUTTON, INPUT_PULLUP);
  pinMode(redRIGHT_BUTTON, INPUT_PULLUP);
  pinMode(redLEFT_BUTTON, INPUT_PULLUP); 

  pinMode(blueUP_BUTTON, INPUT_PULLUP); 
  pinMode(blueDOWN_BUTTON, INPUT_PULLUP);
  pinMode(blueRIGHT_BUTTON, INPUT_PULLUP);
  pinMode(blueLEFT_BUTTON, INPUT_PULLUP); 

  pinMode(proceedButton, INPUT_PULLUP);
  pinMode(yesButton, INPUT_PULLUP);
  pinMode(noButton, INPUT_PULLUP);
}
void loop() {
  // Read the state of the UP_BUTTON (HIGH = not pressed, LOW = pressed)
  int redUPButtonState = digitalRead(redUP_BUTTON); 
  int redDOWNButtonState = digitalRead(redDOWN_BUTTON); 
  int redRIGHTButtonState = digitalRead(redRIGHT_BUTTON); 
  int redLEFTButtonState = digitalRead(redLEFT_BUTTON); 

  int blueUPButtonState = digitalRead(blueUP_BUTTON); 
  int blueDOWNButtonState = digitalRead(blueDOWN_BUTTON); 
  int blueRIGHTButtonState = digitalRead(blueRIGHT_BUTTON); 
  int blueLEFTButtonState = digitalRead(blueLEFT_BUTTON); 

  int proceedButtonState = digitalRead(proceedButton); 
  int yesButtonState = digitalRead(yesButton);
  int noButtonState = digitalRead(noButton); 

  // Print the value (HIGH or LOW) to the Serial Monitor
  Serial.print(redUPButtonState);
  Serial.print(",");
  Serial.print(redDOWNButtonState);
  Serial.print(",");
  Serial.print(redRIGHTButtonState);
  Serial.print(",");
  Serial.print(redLEFTButtonState);

  Serial.print(",");
  Serial.print(blueUPButtonState);
  Serial.print(",");
  Serial.print(blueDOWNButtonState);
  Serial.print(",");
  Serial.print(blueRIGHTButtonState);
  Serial.print(",");
  Serial.print(blueLEFTButtonState);

  Serial.print(",");
  Serial.print(proceedButtonState);
  Serial.print(",");
  Serial.print(yesButtonState);
  Serial.print(",");
  Serial.println(noButtonState);

}

Link to P5: https://editor.p5js.org/yamdn/sketches/1TavUEyVF

Google Drive Video Link 

Through my user testing experience, I realized that I still have a lot of work to do before the IM Show. The person I had for my user testing experience had already played through the game on the web, but when it came to the physical components, there were a couple of mishaps.

One of the key issues was the user interface to interact with the shifting of game states from the start menu to the tutorial, to the instructions, to the game, etc. In setting up the serial port, I had the setup key connected to the SPACE bar. When the user tried to proceed to the next game state, sometimes they would instinctively reach for the SPACE bar, press it, and the program would then be stuck and unplayable. As such that is a critical point which I need to address as to how player will interact with the game.

As for the game experience, I had them play with a prototype so there were no obviously signs of what each of the button does besides the small scribbles of “up”, “down”, “left,” and “right.” I hope in the near future to get it cleaned up and have it be more presentable because the controls got a bit confusing as the game when on and more creatures appeared on the screen. However, I am very surprised that the prototype worked as well as it did, especially since it was made out of cardboard, straws, tape, and a dream. Some feedback I received was that the button was less sensitive towards the edges, so that can be something of interest to change in the coming future.

On the software side, and while the game was a success, I would like to make the progression easier and less demanding on the players. Watching others play the game and having experienced the game itself, I felt the game become overwhelming really quick. I want people to sit and enjoy the game with someone else, so I hope to make things easier and slow down the pacing of the game as well.

For my final project, I decided to bring my midterm project to life and create controllers for the game characters that I designed. If it’s possible, I would like to make two game pads which two players will have to press physically with their feet, which then controls the two characters on the screen. The game pads would be inspired by the video game Dance Dance Revolution (DDR). In addition to the game pads, I was also thinking about adding sound effects using the beeper when the health decreases in the game, the LCD display to depict some artwork or health bar, or the LEDs to give some feedback to the players. I would like to make use of the woodshop, but if time doesn’t permit this idea, I wouldn’t mind scaling down to use the 3D printers or laser cutters.

Some Code Snippet for the Week

const int UP_BUTTON = 11;
const int DOWN_BUTTON = 10;
const int RIGHT_BUTTON = 6;
const int LEFT_BUTTON = 5;

void setup() {
  // Start serial communication at 9600 baud
  Serial.begin(9600);

  // Set button pins as input with internal pull-up resistors
  pinMode(UP_BUTTON, INPUT_PULLUP); 
  pinMode(DOWN_BUTTON, INPUT_PULLUP);
  pinMode(RIGHT_BUTTON, INPUT_PULLUP);
  pinMode(LEFT_BUTTON, INPUT_PULLUP); 
}

void loop() {
  // Read the state of the UP_BUTTON (HIGH = not pressed, LOW = pressed)
  int upButtonState = digitalRead(UP_BUTTON); 
  int downButtonState = digitalRead(DOWN_BUTTON); 
  int rightButtonState = digitalRead(RIGHT_BUTTON); 
  int leftButtonState = digitalRead(LEFT_BUTTON); 

  // Print the value (HIGH or LOW) to the Serial Monitor
  Serial.print(upButtonState);
  Serial.print(",");
  Serial.print(downButtonState);
  Serial.print(",");
  Serial.print(rightButtonState);
  Serial.print(",");
  Serial.println(leftButtonState);

}

 

1. Make an ellipse in p5 move on the horizontal axis using only one sensor. Video Link

int leftLedPin = 4;
int rightLedPin = 6;
const int trigPin = 10;
const int echoPin = 9;

void setup() {
  // Start serial communication at 9600 baud
  Serial.begin(9600);

  // Set up the LED and ultrasonic sensor pins
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(leftLedPin, OUTPUT);
  pinMode(rightLedPin, OUTPUT);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);

  // Blink LEDs to check wiring
  digitalWrite(leftLedPin, HIGH);
  digitalWrite(rightLedPin, HIGH);
  delay(200);
  digitalWrite(leftLedPin, LOW);
  digitalWrite(rightLedPin, LOW);
}

void loop() {
  // Check if there is data available from p5.js
  if (Serial.available()) {
    int left = Serial.parseInt();   // Get the left LED value
    int right = Serial.parseInt();  // Get the right LED value

    // Update LEDs based on values from p5.js
    digitalWrite(leftLedPin, left);
    digitalWrite(rightLedPin, right);

    // Clear any remaining characters in the serial buffer (such as '\n')
    Serial.read();
  }

  // Trigger the ultrasonic sensor
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // determine the time for the echo
  long timeTraveled = pulseIn(echoPin, HIGH);

  // the distance in centimeters
  int distance = timeTraveled * 3.4/2;
  
  int sensor = analogRead(A1);

  // Send the distance value to p5.js
  Serial.print(sensor);
  Serial.print(",");
  Serial.println(distance); 

  delay(100);  
}

 2. Control the LED brightness from p5 Video Link

const int blue_LED = 4;
const int red_LED = 6;

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);

  // Initalization of LED pins 
  pinMode(blue_LED, OUTPUT);
  pinMode(red_LED, OUTPUT); 

  // Blink LEDs to check wiring
  digitalWrite(blue_LED, HIGH);
  digitalWrite(red_LED, HIGH);
  delay(200);
  digitalWrite(blue_LED, LOW);
  digitalWrite(red_LED, LOW);

}

void loop() {
  // put your main code here, to run repeatedly:
  Serial.println(0);
  if (Serial.available()) {
    int left = Serial.parseInt();   // Get the left LED value
    int right = Serial.parseInt();  // Get the right LED value

    // Update LEDs based on values from p5.js
    digitalWrite(blue_LED, left);
    digitalWrite(red_LED, right);

    // removes remaining characters in the serial buffer
  }
  Serial.read();
  delay(100);
}

3. Gravity and Wind Video Link

const int LED_pin = 6;

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  pinMode (LED_pin, OUTPUT);

  // digitalWrite(LED_pin, HIGH);
  // delay(200);
  // digitalWrite(LED_pin, LOW);

}

void loop() {
  // put your main code here, to run repeatedly:
  if (Serial.available()) {
    int LED_value = Serial.parseInt();   // Get the LED value

    // Update LEDs based on values from p5.js
    digitalWrite(LED_pin, LED_value);

    // Clear any remaining characters in the serial buffer (such as '\n')
    Serial.read();
  }
  
  int sensor = analogRead(A0);
  Serial.println(sensor); 
}

 

For my final project, my goal is to build upon my midterm project of bring my game to life. As a reminder, my midterm project was a co-op game which two individuals needed to work together with the WASD and arrow keys to input the right order or combination to proceed to the next level. While the p5 side is mostly complete, I would still need to update the code to communicate with the Arduino and determine sensors for which the Arduino can then communicate with p5.

My end goal is to hopefully build a live, immersive experience which two plays can maybe interact in some fashion to control the characters on screen, defeat the creatures, and proceed to the next level. At the very core, I could have the WASD and arrow keys map certain sensors. On the other hand, I am thinking about using the laser cutter or 3D print to make something visually appealing and fun.

For the reading this week, we had to read on the topic of the design of assistive technology and individuals’ opinions on its design and capabilities. Since I don’t typically think task that might be more difficult for someone with a disability, I feel reading on this topic was especially interesting and reminder that simple task may not always be simple. For example, tremors that typically affect the elder cause the involuntarily shaking of the joints. When effected individuals need to eat, write, shower, etc, it oftentimes become difficult because they cannot control the movement of their hands. One assistive technology that aims to tackle the issue is a reactive spoon that remains stable despite extensive shaking or movement.

In the reading, it had mentioned the drive to make assistive tool standard across all individuals with that disability. When I read it, I felt a strong disagreement with that end goal because a disability does not affect everyone the same. As such making a standard tool make not always end up with the right individual and making their lives exponentially better. Not to say tool will not aid them in their daily lives, however certain disabilities require more attention and customization to fit the individuals’ need.

The reading by Bret Victor describes how interactive design has shifted towards the digital world, rather than focusing on the simplicity of tools and capabilities of physical actions. Through the concept of Pictures Under Glass, he describes how there is a growing disconnect between human interaction between activities on screen and in reality. By focusing on primatial features of human hands, they allow us to perceive the world around us. Following the points he mention of human hands, I fully agree that human learn and understand the world around us through senses. We can’t completely interact with the world fully around us by using one sense  such as vision, touch, smell, taste, and hearing.

While I agree technology has benefited society in many ways. I do not want a completely digital world where everything is behind a glass screen or through Victor concept of picture behind glass. I think it’s critical for humans to understand the world us, otherwise we lose the compassion and sense of worth of whatever it is we are interacting with. Without our sense of touch, our capabilities as human diminishes because we cannot grasp or use the tools around us. Likewise, if we don’t physical see an object, it becomes increasingly difficult to learn about and becomes near impossible to appreciate it.

Concept

For this week’s assignment we spent a lot of time brainstorming ideas and developing different components of the instrument. Originally, we considered a light sensor activated lullaby machine (at night it plays a lullaby and an alarm in the morning) but weren’t sure if that actually constituted an instrument. Therefore, we decided to keep it more straightforward with an electric keyboard design that you can adjust the speed or “consistency” of the notes playing.

Materials

• Arduino Uno
• Jumper wires
• 7 button switches
• Speaker
• SPST Switch
• Potentiometer

Schematic

Design

This project’s two main components are 7 buttons to play the notes and a potentiometer to control the speed of the notes playing. The green button to the left (closest to our potentiometer) represents middle C and then each button plays the consecutive note going up that scale. In our design, we also implemented a an SPST switch to control whether or not you could play anything on it, with the intention of mimicking an electric keyboard’s power button. A unique component to our design is the fact that we used both of our Arduino breadboards in order to better organize and manage the aesthetics of the design. Additionally, by still using one actual Arduino Uno we were able to avoid any complications with synching the information which was convenient in terms of time efficiency.

On the implementation side our biggest challenge was getting the volume to change with the adjustments of the potentiometer. After a bit of troubleshooting and heading back to the drawing board we decided to switch our original play and allow the potentiometer to control the speed of the notes. We intended to recycle as much code as we could from class and ultimately ended up use components from both Arduino’s tone() and button example codes that were reviewed in class. After switching between trying to change the pitch, speed, and volume of the notes with the potentiometer we decided on speed simply because we felt that the other adjustments weren’t noticeable enough for our intended purpose.

Code

#include "pitches.h"
 
// button pins
const int B_key = 4; 
const int A_key = 5;
const int G_key = 6; 
const int F_key = 7;
const int E_key = 8;
const int D_key = 9; 
const int C_key = 10; 
 
const int SWITCH_PIN = 12;  // switch pin
const int BUZZER_PIN = 2; // buzzer pin
const int POT_PIN = A0; // potentiometer pin 
 
// notes
int melody[] = {
  NOTE_B5, NOTE_A5, NOTE_G4, NOTE_F4, NOTE_E4, NOTE_D4, NOTE_C4
};
 
// Array for button pins
int buttonPins[] = { A_key, B_key, C_key, D_key, E_key, F_key, G_key };
 
void setup() { // initalization of the buttons, buzzer, and switch pins 
  for (int i = 0; i < 7; i++) {
    pinMode(buttonPins[i], INPUT_PULLUP); // sets button pins as inputs with internal pull-up resistors
  }
 
  pinMode(BUZZER_PIN, OUTPUT); // sets the buzzer pin as an output
  pinMode(SWITCH_PIN, INPUT_PULLUP);  // sets switch as inputs with internatinoal pull-up resistors
}
 
void loop() {
  int switchState = digitalRead(SWITCH_PIN);    // reads the state of the switch
  int potValue = analogRead(POT_PIN);   // reads the potentiometer value (0-1023)
 
  int speedDelay = map(potValue, 0, 1023, 50, 500);  // maps potentiometer value to speed delay range (50-500 ms)
 
  // if the switch is HIGH the button functionality is enabled
  if (switchState == HIGH) {
    // continously checks each button state
    for (int i = 0; i < 7; i++) {
      int buttonState = digitalRead(buttonPins[i]);
        
      // if the button is pressed,  play the corresponding note
      if (buttonState == LOW) {
        tone(BUZZER_PIN, melody[i], 200); // play note for 200ms
        delay(speedDelay); // speed delay based on the position/ value of the potentiometer 
      }
    }
  }
  delay(50);
}

 

Final Project music.mov – Google Drive

Conclusion and Reflection

All in all, we are both rather pleased with the outcome of this weeks assignment. With it being our first assignment working with another person, it was an interesting opportunity to compare techniques in regards to simpler things like breadboard organization or schematic design preferences. We were able to use both of our strengths in different ways and support each other in areas that we were weaker. In terms of future developments we had a few smaller ideas such as adding LEDs to correspond with the keys, or allowing the user to control the pitch of the notes. Looking at the bigger picture, we even discussed what it would look like to allow the user to choose what kind of electric keyboard sounds they wanted to play (going beyond the use of the speakers we have). Although our project is rather simple, we were truly tested when it came to debugging our code but really appreciated the experience of going at it together.

Overview Video Link

The production goal for this week was to understand and play with the analog and digital components in the kit. Then with the input of the components, apply the readings to at least two LED bulbs. Just for fun, I decided to use 4 because I wanted them to glow in a random pattern with varying brightness. With the potentiometer, I decided to showcase how it can be linked to multiple LEDs to control their brightness.

Difficulty and Success of the Process

I felt the most difficult part of the process was the coding and software. Alongside getting use to the IDE, I think connecting the wires to the correct input ports and then referencing the port in the code was a bit confusing to me. Since some of the input ports on the Arduino do not have Pulse Width Modulation (PWM) that converts digital inputs into analog results, I initially was connecting leads to port 13 that didn’t have PWM functionality resulting in my LED blinking when I didn’t want them to and other fault design. With a quick Google search, it seemed like pins 3,5,6,9,10,11 have PWM functionality and changing my routing to those pins resolved most of my issues. As such, my recommendation for others starting out is to use those pins when working with analog measurements while using digital components.

On the other hand, I found great success in connecting multiple LEDs on my breadboard and then connecting the various parts in the IDE. I had a lot of fun organizing and visualizing the routing and see how each of the components would work together. I really loved how the random pattern turned out, but I think in the future I would like to find a way to connect the brightness control with the pattern. With the potentiometer, I ended up connecting each individual light with the meter, but not when the pattern was being displayed. I also wished I had more buttons to play around as well. However, I am still happy with the overall design and look forward to future projects.

Schematic (TinkerCAD)

IRL Photo

 

Physical Computing’s Greatest hits and misses

Here the article describes the various projects seen from interactive media design ranging from instruments design with gloves or pads to reactive art with various sensors or computer vision. Although the author describes these project as common themes amongst physical computing courses, they do not disregard or look down upon the repetitive theme because to them each project brings with a unique idea and innovated process. For me, reading his opinion on this issue brings me comfort because I have been trying to brainstorm ideas for the final project for IM and with each idea, I fear it isn’t original or creative enough. Of course, I would not copy another’s work, however I feel the art I have seen and interacted with has shaped my ideas and influenced my creative thinking process. I believe everyone is shaped by the world around them, so I think it is cool to see how people can reimagine a concept and build upon past works.

Making Interactive Art: Set the Stage, Then Shut Up and Listen

The following articles writes about how interactive artist should design their works a degree of intention that allows the users to explore their art, but also leaving room for the user to decide on the art’s interpretation. The author mentions how interactive artist should avoid bluntly telling the user what to do and how to interpret their art. Although I do see the point the author is trying to make, I think there are exceptions where the artist should have the freedom to express themselves the way they want the user to appreciate and experience their art. For example, in activist artworks, oftentimes they shed light to forgotten/ overlooked history, and I believe in these cases, it is critical for the user to understand the concept behind the art to fully be immersed with the artwork. I don’t think the idea of simply setting up the stage and observing user is enough and there needs to be balance of artist intervenes and user appreciation. As such, I feel it okay if an artist feels the need to describe their works. I rather much learn the passion behind the work, than be completely open to interpretation.