JAN KEN PON
“Let Me Help You Decide What To Do!”
Jan-Ken-Pon(じゃん拳ぽん) is a Japanese words meaning Rock-Paper-Scissors. Rock-paper-scissors itself is a popular game enjoyed by people worldwide.
CONTEXT AND SIGNIFICANCE: We are building a machine that can play rock paper scissors with you when your friends are not around. This project builds upon existing products. We have seen on the internet a rock paper scissor machine but it is played by 2 people and its not combining arduino or computer system on it. We are not only improving the existing product to have a computation but also andit helps people figure out their decisions. While most times playing with a computer with a game like this feels like it’s “intentionally” making the game fair. As with the computer’s sub-ms response time, it can easily cheat after you make your input. So we want to make a machine that can “play fairly”. Moreover we think more than playing but also the usage of the machine. This machine not only invite your curiosity about the result you get, win or lose or draw but also we make a little twist that makes it more engaging. Here is the instructions of our machine:
- Think of something you want to do but you are not sure of
- Write it on the boards provided above
- Put the board on the space provided above
- Press ‘START’
- Wait until the green light beside ‘YOUR TURN’ lights up then pick and press your choice of JAN-KEN-PON (Rock/Paper/ Scissors)
- Wait until you see whether you win/lose/draw (you will see the proof of the machine’s choice so you know that the machine did not cheat)
- If you win, you do what you wrote above
- If you lose, you dont have to do it but WHY NOT?
Our target audience can actually be anybody, people are usually confuse and need reassurance on what they are going to do. We can use this machine for daily activity which is for fun only or until helping us to choose hard decision. Our special value is it is realistic and actually a solution for common problem people face everyday. We have been testing the machine to some of our colleagues and friends and they are all so happy with the result. Some of them use the machine to decide on what to do, what to eat, or even whether they should do their study away next semester or not. They consider the result of the machine as a sign because the machine result can’t be cheat by the machine, the machine decide their move first then we choose ours.
Overall, my previous Group Project has had me realize that you are not only making a machine that is fun and you think is engaging but you have to start from common problem that is relatable to people and also getting feedback from real user from user testing made a impactful change to the final product. They gave their thoughtful idea that makes the product visually good to attract people and useful to help create solution for their problems.
CONCEPTION AND DESIGN
(1) Draft for User Testing
(2) Draft for Final Product
“We wanted to ensure that the user knows the machine does not cheat, so we use servo motors to demonstrate the machine’s pick. Servo motors are very suitable for this project since they can replicate human-like movements during a game of rock-paper-scissors. We used four servo motors, three for the rock-paper-scissors gestures and one for the lid to display the machine’s pick.
To allow users to make their selection, we implemented buttons. We believe that buttons are more appealing than other sensors because users can physically press them. Professor Eric suggested using arcade buttons for added excitement, but due to the small size of our cardboard product, we decided against using them. We didn’t see the necessity of incorporating arcade buttons into the machine.”
FABRICATION AND PRODUCTION:
*Prototype #1 – user testing (Tuesday, October 13)
*Prototype #2 – Arcade Inspired(Saturday, October 15)
*Final product – Presentation Day(Tuesday, October 17)
Now let’s see the fabrication and production process of our Jan Ken Pon machine, highlighting both our successes and failures along the way. User testing played a significant role in the success of our project, as our goal is always to create a machine that is relatable and interactive. The feedbacks we received from users were the most valuable for us and it helped us add more value to the machine, bringing it closer to its intended purpose.
Here is an overview of our production process from start to finish:
- Idea Generation: My partner and I came up with two ideas, and my partner suggested the Jan Ken Pon concept while I contributed the idea of making the machine more relatable to the decision-making process.
- Initial Draft: We started by drawing a draft of the machine, which ended up being quite different from the final product.
- First Prototype: We built the first prototype with two-sided appearance, one side showing the user’s pick and the other side showing the machine’s pick. We determined the win, lose, and draw outcomes based on sound cues.
- User Testing and Feedback: After completing the first prototype, we conducted user testing on Friday, October 13. Users provided us with feedback, including the following suggestions:
- Add lights to indicate when it’s the user’s turn to pick and to clearly show win, lose, and draw outcomes since sounds alone were not clear enough.
- Make the hand more obvious so that users can easily see the hand gesture without having to go to the other side of the machine.
- Incorporate an arcade button to enhance the fun factor.
- Create a box for the prompt and provide clear instructions so that people understand what to do when interacting with the machine alone.
- Give a name to the project.
- Decorate the machine to resemble an arcade, as the prototype looked like a stack of cardboard.
- Development and Refinement: Over the weekend (October 14-15), we worked on developing the product based on the feedback received during user testing. We rebuilt the machine, giving it an arcade look and making it one-sided to show only the machine’s pick. We determined the win, lose, and draw outcomes using lights and sound.
- Finalization: We spent the entire weekend building the second prototype and acquiring the necessary parts. We chose a color scheme of white, grey, and red to give the machine an arcade-like appearance. On Tuesday, October 17, we completed our final product, including clear instructions.
During the production process, we faced challenges related to time management. With limited time, we had only three days to build our second prototype and finalize the product. However, we successfully overcame this challenge by dedicating our time and effort to the project, working in the studio throughout the entire weekend.
USER TESTING
The user testing sessions played a crucial role in the project’s development. People showed great interest in our product and had a positive overall experience. They found it useful, fancy, and cool. Their feedback provided us with valuable insights and ideas for further improvements. The users were eagerly waiting to see the final product.
The user testing process heavily influenced our subsequent production decisions. We carefully listened to all the feedback and made the necessary improvements to meet the users’ expectations. As a result, we transformed the machine into an arcade-like design, made the hand gesture more noticeable, added boards for users to write their prompts, and created a clear restart button with instructions. We also added the name “Jan Ken Pon” to the machine and incorporated hand gestures for rock, paper, and scissors as decorations on both sides. The machine was designed to be self-explanatory, allowing users to understand how to interact with it by simply reading the instructions and information displayed on the machine itself.
Throughout the decision-making process, we considered various aspects, including code, electronics, and other major components of the project. For example, we encountered a challenge with the background music, as my partner initially used the delay() function, which caused issues with button change detection. To overcome this, he developed a class to play the sound by calculating time lapses instead.
In short, our fabrication and production process involved idea generation, prototyping, user testing, feedback incorporation, and finalization. We overcame challenges through effective time management and collaborated well as a team. User feedback greatly influenced our production decisions, resulting in a more engaging and user-friendly Jan Ken Pon machine.
PERSONAL CONTRIBUTION:
In terms of individual contributions and team collaboration, I took charge of the decoration and overall appearance of the product. I also ensured that the purpose of the machine was always kept in mind and that everything we did aimed to satisfy the users by making the machine relatable, engaging, and exciting. My partner focused on the coding part, working hard to create different tones to determine the win, lose, and draw outcomes.
CONCLUSIONS: The goal of our project, the Jan Ken Pon machine, was to create an interactive and engaging device that could play rock-paper-scissors with users and help them make decisions. We wanted to ensure that the machine provided a fair and transparent game experience, and we incorporated user feedback to enhance its functionality and appearance.
The project results align well with our definition of interaction. Users were able to physically engage with the machine by pressing buttons to make their selection, and they could see the machine’s pick through the movement of servo motors. The addition of lights and sound cues further enhanced the interactive experience, providing clear indications of win, lose, and draw outcomes. The machine successfully created a sense of anticipation and excitement, inviting users to participate and make decisions.
However, one aspect where the project results did not clear to the user was the hand for the machine’s pick. Due to time limit, we decided not to use 3d printed hand gestures. Although 3d hands could have added an extra level on our project, we couldn’t manage to make it happened.
Our audience interacted positively with the project, finding it useful, fancy, and cool in the user testing. Users appreciated the machine’s ability to assist them in decision-making and enjoyed the engaging gameplay. They provided valuable feedback during user testing, which influenced our design choices and improvements. The audience response was enthusiastic, and they cannot wait to try the final product.
If we had more time, there are a few areas we would improve in our project. Firstly, we would explore the possibility of incorporating arcade buttons, as suggested by Professor Eric so people can slap the button. This could enhance the overall fun factor and provide a more immersive experience. Additionally, we would also consider adding 3d hands to make it look more real rock paper scissors hand gestures.
Throughout the project, we realized that if we the purpose of the machine is to help people we have to hear people. I did not know that user testing are that important until we had it. I learned the importance of listen and consider people thoughts and make an improvement based on the feedbacks. I learned to give the best to the project as people are seeing great potential and excited to see the final product. I learned to use effective time management and dedicated effort to overcome challenges within a limited timeframe.
In terms of accomplishments, I am proud of the final product we have created. The Jan Ken Pon machine effectively combines interactivity, decision-making assistance, and an engaging gameplay experience. The positive feedback from users and their excitement towards the project validate our efforts. On the presentation days, some classmates whispered to me about how they like the JAN KEN PON and consider it as the best project. Professor Garcia also gave his sincere compliment to the project. We are happy that our time and effort we put are all worth it at the end.
Overall, Jan Ken Pon machine successfully achieved its goals of providing an interactive and engaging experience for users. It served as a tool for decision-making and elicited positive responses from the audience. I would never forget this experience and the lesson learned throughout the process.
VIDEOS OF TESTING THE JAN-KEN-PON MACHINE
JAN KEN PON VIDEO REAL LIFE EXPERIENCE
GALLERY
ANNEX
Full Code:
```cpp
#include
#include "pitches.h"
#define BUZZER_PIN 2
#define PLAYER_TURN_INDICATOR_PIN 7
#define WINNING_INDICATOR_PIN 13
#define DRAW_INDICATOR_PIN 12
#define LOSING_INDICATOR_PIN 8
#define LID_SERVO_PIN 3
Servo lidServo;
#define LID_SERVO_OPEN_ANGLE 140
#define LID_SERVO_CLOSE_ANGLE 20
int idleMelody[] = {
NOTE_B4, NOTE_B5, NOTE_FS5, NOTE_DS5,
NOTE_B5, NOTE_FS5, NOTE_DS5, NOTE_C5,
NOTE_C6, NOTE_G6, NOTE_E6, NOTE_C6, NOTE_G6, NOTE_E6,
NOTE_B4, NOTE_B5, NOTE_FS5, NOTE_DS5, NOTE_B5,
NOTE_FS5, NOTE_DS5, NOTE_DS5, NOTE_E5, NOTE_F5,
NOTE_F5, NOTE_FS5, NOTE_G5, NOTE_G5, NOTE_GS5, NOTE_A5, NOTE_B5};
int idleMelodyDuration[] = {
16, 16, 16, 16,
32, 16, 8, 16,
16, 16, 16, 32, 16, 8,
16, 16, 16, 16, 32,
16, 8, 32, 32, 32,
32, 32, 32, 32, 32, 16, 8};
enum GAME_STATE
{
IDLE,
PRE_MOVING,
MAKING_MOVE,
MOVE_ENDING,
RESULT_GOOD,
RESULT_DRAW,
RESULT_BAD
} gameState;
void printState(GAME_STATE gameState)
{
if (gameState == IDLE)
{
Serial.println("IDLE");
}
if (gameState == PRE_MOVING)
{
Serial.println("PRE_MOVING");
}
if (gameState == MAKING_MOVE)
{
Serial.println("MAKING_MOVE");
}
if (gameState == MOVE_ENDING)
{
Serial.println("MOVE_ENDING");
}
if (gameState == RESULT_GOOD)
{
Serial.println("RESULT_GOOD");
}
if (gameState == RESULT_DRAW)
{
Serial.println("RESULT_DRAW");
}
if (gameState == RESULT_BAD)
{
Serial.println("RESULT_BAD");
}
}
enum MOVE
{
ROCK,
PAPER,
SCISSORS
} playerMove,
machineMove;
class Button
{
private:
int buttonState;
int lastState;
bool isPressed;
int buttonPin;
public:
Button(int pin)
{
buttonPin = pin;
buttonState = LOW;
lastState = LOW;
isPressed = false;
}
void init()
{
pinMode(buttonPin, INPUT);
}
void update()
{
buttonState = digitalRead(buttonPin);
isPressed = buttonState == HIGH && lastState == LOW;
lastState = buttonState;
}
bool getIsPressed()
{
return isPressed;
}
};
class Hand
{
private:
int servoPin;
const int MOVE_ANGLE = 35;
Servo servo;
public:
Hand(int pin)
{
servoPin = pin;
}
void init()
{
servo.attach(servoPin);
reset();
}
void move()
{
servo.write(MOVE_ANGLE);
}
void reset()
{
servo.write(0);
}
};
class Music
{
private:
int melody[31];
int melodyDuration[31];
int noteIndex = 0;
unsigned long previousMillis = 0;
bool isPlaying = true;
public:
Music(int melody[], int melodyDuration[])
{
for (int i = 0; i < 31; i++) { this->melody[i] = melody[i];
this->melodyDuration[i] = melodyDuration[i];
}
}
void loop()
{
unsigned long currentMillis = millis();
int duration = 1000 / melodyDuration[noteIndex];
if (isPlaying)
{
tone(BUZZER_PIN, melody[noteIndex], duration);
noteIndex = (noteIndex + 1) % 31;
isPlaying = false;
}
if (currentMillis - previousMillis >= duration * 1.30)
{
isPlaying = true;
previousMillis = currentMillis;
}
}
};
Hand rockHand(9);
Hand paperHand(10);
Hand scissorsHand(11);
Music idleMusic(idleMelody, idleMelodyDuration);
// Buttons
Button startButton(A0);
Button moveRockButton(A3);
Button movePaperButton(A2);
Button moveScissorsButton(A1);
void setup()
{
// put your setup code here, to run once:
Serial.begin(9600);
randomSeed(analogRead(A5));
lidServo.write(LID_SERVO_CLOSE_ANGLE);
startButton.init();
moveRockButton.init();
movePaperButton.init();
moveScissorsButton.init();
rockHand.init();
paperHand.init();
scissorsHand.init();
lidServo.attach(LID_SERVO_PIN);
pinMode(PLAYER_TURN_INDICATOR_PIN, OUTPUT);
pinMode(WINNING_INDICATOR_PIN, OUTPUT);
pinMode(DRAW_INDICATOR_PIN, OUTPUT);
pinMode(LOSING_INDICATOR_PIN, OUTPUT);
pinMode(BUZZER_PIN, OUTPUT);
}
void loop()
{
// put your main code here, to run repeatedly:
defaultLooper();
if (gameState == IDLE)
{
idleLooper();
}
if (gameState == PRE_MOVING)
{
preMovingLooper();
}
if (gameState == MAKING_MOVE)
{
makingMoveLooper();
}
if (gameState == MOVE_ENDING)
{
moveEndingLooper();
}
if (gameState == RESULT_GOOD)
{
resultGoodLooper();
}
if (gameState == RESULT_DRAW)
{
resultDrawLooper();
}
if (gameState == RESULT_BAD)
{
resultBadLooper();
}
printState(gameState);
delay(100);
}
void defaultLooper()
{
startButton.update();
moveRockButton.update();
movePaperButton.update();
moveScissorsButton.update();
}
void idleLooper()
{
if (startButton.getIsPressed())
{
gameState = PRE_MOVING;
}
idleMusic.loop();
}
void machineDecide()
{
int randNum = random(0, 3);
if (randNum == 0)
{
machineMove = ROCK;
Serial.println("Machine played: Rock");
}
else if (randNum == 1)
{
machineMove = PAPER;
Serial.println("Machine played: Paper");
}
else
{
machineMove = SCISSORS;
Serial.println("Machine played: Scissors");
}
gameState = MAKING_MOVE;
}
void preMovingLooper()
{
tone(BUZZER_PIN, 500);
delay(500);
noTone(BUZZER_PIN);
delay(500);
tone(BUZZER_PIN, 500);
delay(500);
noTone(BUZZER_PIN);
delay(500);
tone(BUZZER_PIN, 700);
machineDecide();
}
void makingMoveLooper()
{
digitalWrite(PLAYER_TURN_INDICATOR_PIN, HIGH);
if (machineMove == ROCK)
{
rockHand.move();
}
else if (machineMove == PAPER)
{
paperHand.move();
}
else
{
scissorsHand.move();
}
if (moveRockButton.getIsPressed())
{
playerMove = ROCK;
Serial.println("Player played: Rock");
gameState = MOVE_ENDING;
}
else if (movePaperButton.getIsPressed())
{
playerMove = PAPER;
Serial.println("Player played: Paper");
gameState = MOVE_ENDING;
}
else if (moveScissorsButton.getIsPressed())
{
playerMove = SCISSORS;
Serial.println("Player played: Scissors");
gameState = MOVE_ENDING;
}
}
void moveEndingLooper()
{
noTone(BUZZER_PIN);
digitalWrite(PLAYER_TURN_INDICATOR_PIN, LOW);
if (playerMove == ROCK)
{
if (machineMove == ROCK)
{
gameState = RESULT_DRAW;
}
else if (machineMove == PAPER)
{
gameState = RESULT_BAD;
}
else
{
gameState = RESULT_GOOD;
}
}
else if (playerMove == PAPER)
{
if (machineMove == ROCK)
{
gameState = RESULT_GOOD;
}
else if (machineMove == PAPER)
{
gameState = RESULT_DRAW;
}
else
{
gameState = RESULT_BAD;
}
}
else
{
if (machineMove == ROCK)
{
gameState = RESULT_BAD;
}
else if (machineMove == PAPER)
{
gameState = RESULT_GOOD;
}
else
{
gameState = RESULT_DRAW;
}
}
}
void resetHands()
{
rockHand.reset();
paperHand.reset();
scissorsHand.reset();
gameState = IDLE;
}
void resultGoodLooper()
{
lidServo.write(LID_SERVO_OPEN_ANGLE);
digitalWrite(WINNING_INDICATOR_PIN, HIGH);
tone(BUZZER_PIN, 300);
delay(500);
tone(BUZZER_PIN, 400);
delay(500);
tone(BUZZER_PIN, 450);
delay(500);
tone(BUZZER_PIN, 400);
delay(500);
noTone(BUZZER_PIN);
delay(200);
tone(BUZZER_PIN, 470);
delay(200);
noTone(BUZZER_PIN);
delay(200);
tone(BUZZER_PIN, 470);
delay(500);
noTone(BUZZER_PIN);
delay(1000);
digitalWrite(WINNING_INDICATOR_PIN, LOW);
resetHands();
lidServo.write(LID_SERVO_CLOSE_ANGLE);
}
void resultDrawLooper()
{
lidServo.write(LID_SERVO_OPEN_ANGLE);
digitalWrite(DRAW_INDICATOR_PIN, HIGH);
tone(BUZZER_PIN, 300);
delay(500);
tone(BUZZER_PIN, 250);
delay(500);
tone(BUZZER_PIN, 300);
delay(500);
tone(BUZZER_PIN, 250);
delay(500);
noTone(BUZZER_PIN);
delay(200);
tone(BUZZER_PIN, 470);
delay(200);
noTone(BUZZER_PIN);
delay(200);
tone(BUZZER_PIN, 470);
delay(500);
noTone(BUZZER_PIN);
delay(1000);
digitalWrite(DRAW_INDICATOR_PIN, LOW);
resetHands();
lidServo.write(LID_SERVO_CLOSE_ANGLE);
}
void resultBadLooper()
{
lidServo.write(LID_SERVO_OPEN_ANGLE);
digitalWrite(LOSING_INDICATOR_PIN, HIGH);
tone(BUZZER_PIN, 300);
delay(500);
tone(BUZZER_PIN, 250);
delay(500);
tone(BUZZER_PIN, 220);
delay(500);
tone(BUZZER_PIN, 170);
delay(500);
noTone(BUZZER_PIN);
delay(200);
tone(BUZZER_PIN, 470);
delay(200);
noTone(BUZZER_PIN);
delay(200);
tone(BUZZER_PIN, 470);
delay(500);
noTone(BUZZER_PIN);
delay(1000);
digitalWrite(LOSING_INDICATOR_PIN, LOW);
resetHands();
lidServo.write(LID_SERVO_CLOSE_ANGLE);
}
```
Many thanks to all the professor especially Professor Eric that teach us throughout the first half semester of the class so that we understand how to build the project. Thank you to all the fellows and LAs that were very helpful to help us make this project happened. Rachel who helped us with building the project and Shengli on giving us feedback for our instruction and during the user testing. Thank you to all the people in the user testing that helped us by providing the most valuable feedback so JAN KEN PON came out as what it is today. Finally, to my partner Leo that worked hard to make this project happened together!