The inspiration for MarioDarts came from a circus act called the Wheel of Death where a woman is strung to a spinning wheel and a man will throw knives at the wheel without hitting the woman. The decision to go forward with creating something based on this idea came from wanting to do something different from our group project. We thought we would make something more fun and interesting; something that would cause the user to physically interact with it using more than just speech. This is different from our last project (iMirror) because unlike iMirror, this is more like a game. The interaction in iMirror was in communication through human speech because the user can talk with the AI behind iMirror. But the interaction in MarioDart doesn’t require speech at all. Although the users can speak with each other, the interaction in terms of speech is not between the user and the project itself. In addition, whereas iMirror is geared more towards women and adults who wish to take care of their skin, MarioDarts targets a younger audience who are more interested in playing games.
At first, we wanted to make the purpose of the game to throw darts, representing knives, at a spinning wheel with a person strapped to it but the player has to avoid “stabbing” the person. And when we went into mapping out how and what we were going to use to make the wheel, we tossed around some ideas like velcro or magnets. After our first idea meeting, we decided to start putting together our prototype in the lab. We asked Fellow Nick some questions regarding some issues we thought we would face. Such issues included the possibility that the wires connecting the motor used to spin the wheel would get tangled up once the wheel started spinning. We also wanted to incorporate some sort of sensor into our project, like making the person scream if she was hit. But then we ran into the problem of deciding what kind of sensors to use. Nick suggested a vibration sensor but we didn’t want it to get activated if it senses a vibration from the board itself. We finally decided on a combination of using a magnetic board and force sensors to make our project happen. Another problem we had was how to program a human scream. We ended up programming the first few notes of the Mario theme song instead. Which led us to change the lady on the wheel to Mario as well.
The first step in putting together our project was everything that we can do for the board/wheel itself. Because we wanted to attach our wheel to a base so the wheel would be spinning while facing the user instead of facing the ceiling, we had to make sure the board, and more specifically the sensors, was working before we attached it to the base. As mentioned before, one of the problems with a spinning wheel is that the wires would get tangled up when it spins. So Fellow Nick suggested that we use two Arduinos, one to power the motor (another problem altogether) and one to power the sensor. In addition, we could put everything that makes the sensors work (the Arduino, wires, separate batteries, and breadboards) onto the back of the board itself. This way the wires won’t be sticking to an external source and be tangled up when it spins. Unfortunately this added on the problem of extra weight, which brings me to the issue we faced with selecting a motor that would spin the wheel. In order, we tried the DC motor (too small to attach to the board), Servo motor (not strong enough), a different Stepper motor the equipment room gave us (something was wrong with it and it wouldn’t program like normal), and finally the Stepper motor. I think if we had started with the Stepper motor we could have avoided wasting a lot of time and now that I think about it, I’m not sure why we didn’t think of it.
During the User Testing Session, we got a lot of feedback about the nature of our project. When we set out to make this wheel, we weren’t planning on turning it into a multiplayer game because the original concept was more of a performance than a game. But after seeing the competitive urge this wheel brings up in other people, we thought we should definitely turn it into a game. We also got the feedback that some people might not feel comfortable with “killing Mario,” but we didn’t want to change the character we placed in the middle of the board, so following Marcela’s advice, we put pictures of coins at the end of the darts and changed the purpose of the game. So instead of avoiding hitting the Mario at the center of the wheel, players would be trying to send the “coins” into Mario’s hands, feet, and head so he can collect the coins like he does in the video games.
The goal of my project is to create a game where more than two players can take turns throwing darts at a spinning wheel to see who can hit Mario the most. This project aligns with my definition of interaction because it involves a reciprocal action-reaction process between the players and the board, where if the player hits the Mario at certain sensor-points, the board will make a sound. I think at this point in my project, the link between the audience and the sensors isn’t that great because the sensors aren’t that sensitive. So this doesn’t align with my definition of interaction in that it isn’t as complete or act as it should, at this point in time. If I had more time, I would find some way to increase the amount of sensors so the board is more sensitive. I would also find some way to make the magnetic parts of the darts stick to the board more than they fly off. Through the process of making this project I learned many valuable lessons about project planning and design. I learned the importance of planning before executing and the effect the lack thereof has on the creation process. I learned how to use sensors and motors collectively to accomplish a final goal. I also learned the importance of teamwork and the value of other people’s opinions and suggestions. I will keep all of these in mind as I go into my final project in a few weeks time.
// Sensor and output
int senRd1 = 0;
int senRd2 = 0;
int senRd3 = 0;
int senRd4 = 0;
int senRd5 = 0;
boolean personHit = false;
int speakerPin = 9;
// define notes for melody
#define REST 1
#define NOTE_B0 31
#define NOTE_C1 33
#define NOTE_CS1 35
#define NOTE_D1 37
#define NOTE_DS1 39
#define NOTE_E1 41
#define NOTE_F1 44
#define NOTE_FS1 46
#define NOTE_G1 49
#define NOTE_GS1 52
#define NOTE_A1 55
#define NOTE_AS1 58
#define NOTE_B1 62
#define NOTE_C2 65
#define NOTE_CS2 69
#define NOTE_D2 73
#define NOTE_DS2 78
#define NOTE_E2 82
#define NOTE_F2 87
#define NOTE_FS2 93
#define NOTE_G2 98
#define NOTE_GS2 104
#define NOTE_A2 110
#define NOTE_AS2 117
#define NOTE_B2 123
#define NOTE_C3 131
#define NOTE_CS3 139
#define NOTE_D3 147
#define NOTE_DS3 156
#define NOTE_E3 165
#define NOTE_F3 175
#define NOTE_FS3 185
#define NOTE_G3 196
#define NOTE_GS3 208
#define NOTE_A3 220
#define NOTE_AS3 233
#define NOTE_B3 247
#define NOTE_C4 262
#define NOTE_CS4 277
#define NOTE_D4 294
#define NOTE_DS4 311
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_FS4 370
#define NOTE_G4 392
#define NOTE_GS4 415
#define NOTE_A4 440
#define NOTE_AS4 466
#define NOTE_B4 494
#define NOTE_C5 523
#define NOTE_CS5 554
#define NOTE_D5 587
#define NOTE_DS5 622
#define NOTE_E5 659
#define NOTE_F5 698
#define NOTE_FS5 740
#define NOTE_G5 784
#define NOTE_GS5 831
#define NOTE_A5 880
#define NOTE_AS5 932
#define NOTE_B5 988
#define NOTE_C6 1047
#define NOTE_CS6 1109
#define NOTE_D6 1175
#define NOTE_DS6 1245
#define NOTE_E6 1319
#define NOTE_F6 1397
#define NOTE_FS6 1480
#define NOTE_G6 1568
#define NOTE_GS6 1661
#define NOTE_A6 1760
#define NOTE_AS6 1865
#define NOTE_B6 1976
#define NOTE_C7 2093
#define NOTE_CS7 2217
#define NOTE_D7 2349
#define NOTE_DS7 2489
#define NOTE_E7 2637
#define NOTE_F7 2794
#define NOTE_FS7 2960
#define NOTE_G7 3136
#define NOTE_GS7 3322
#define NOTE_A7 3520
#define NOTE_AS7 3729
#define NOTE_B7 3951
#define NOTE_C8 4186
#define NOTE_CS8 4435
#define NOTE_D8 4699
#define NOTE_DS8 4978
// Sample code for Mario melody is from:
// https://www.instructables.com/id/Play-Custom-Melodies-on-Arduino/
// by JmsDwh
// notes in the melody:
int Mario_melody[] = {
NOTE_E4, NOTE_E4, REST, NOTE_E4,
REST, NOTE_C4, NOTE_E4, REST,
NOTE_G4, REST, REST, NOTE_G3, REST,
};
int Mario_Notes[] = {
4, 4, 4, 4,
4, 4, 4, 4,
4, 2, 4, 2, 2,
};
const int num_elements_in_arr = sizeof(Mario_Notes)/sizeof(Mario_Notes[0]);
void setup() {
pinMode(speakerPin, OUTPUT);
}
void loop() {
// reading any inputs
senRd1 = analogRead(A0);
senRd2 = analogRead(A1);
senRd3 = analogRead(A2);
senRd4 = analogRead(A3);
senRd5 = analogRead(A4);
senRd6 = analogRead(A5);
// if any sensor is hit
if (senRd1 > 0 || senRd2 > 0 || senRd3 > 0 || senRd4 > 0 || senRd5 > 0) {
personHit = true;
}
// play melody
if (personHit) {
playMelody();
personHit = false;
}
}
// code by JmsDwh
void playMelody() {
// iterate over the notes of the melody:
for (int thisNote = 0; thisNote < num_elements_in_arr; thisNote++) {
// to calculate the note duration, take one second
// divided by the note type.
//e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
int noteDuration = 500/Mario_Notes[thisNote];
tone(speakerPin, Mario_melody[thisNote],noteDuration);
// to distinguish the notes, set a minimum time between them.
// the note’s duration + 30% seems to work well:
int pauseBetweenNotes = noteDuration * 1.30;
delay(pauseBetweenNotes);
// stop the tone playing:
noTone(speakerPin);
}
}
[/code for the sensor]
[code for stepper motor] // Spins the wheel at a slow speed
#include <Stepper.h>
const int stepsPerRevolution = 200; // change this to fit the number of steps per revolution
// for your motor
// initialize the stepper library on pins 8 through 11:
Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11);
void setup() {
myStepper.setSpeed(10);
}
void loop() {
myStepper.step(stepsPerRevolution);
delay(1);
}
[/code for stepper motor]