Context and Significance

After reading “The Art of Interactive Design” by Chris Crawford in the previous group project, I realized that interactive products are similar to a good conversation. It would be better if the project combined both the interactions between the users and the projects and the interactions between the users via the products. My team partner Robert Cen, as a card player, prompted that we could do a card dealer since the servo and motor in the previous recitations could be useful in making the outputs. Initially, it started with a running race but after the User Testing, we changed it to Drum Master. The details of User Testing will be covered in Fabrication and Production. The significance of our project is that the card is for the loser of the race in the interactive game and we created a system of workout instructions for the poker cards to enhance interactivity. After all, you lost, indicating you need more exercise. If one of the players loses the race then they will have to do the workout as the instructions given by the card dealt with by the card dealer. For instance, the loser would have to do 5 push-ups if the card is Heart 5. We believe the target audience is the people who would like to make the workout fun and the game and the card instructions are capable of meeting the expectations.

Conception and Design

Originally, the project would be a racing game plus a card dealer for exercise penalty. The two players run to the project and the one who gets to the project first wins. The loser will be assigned a card as the penalty to do the workout. We thought that the first interaction could be the distance sensor sensing the distance between the project and the players. The distance sensor measures how close the player is to the project, making it the most direct measurement for the race. Then the card dealer would give out the card through the servo and the motor. The cardboard in the IMA studio is useful for structuring the card dealer and the sensor. The springs can be stuffed in the cardboard box to deal cards better when the card size decreases as the cards are shot out. As you can see, the main criteria was on the function. In other words, we came up with an idea and then thought about the gadgets that would realize the movements. 

Fabrication and Production

For the project, I mainly worked on the sensors, circuits, and code while my partner Robert focused on the cardboard and the card dealer. We would check on each other’s process give feedback to each other and combine the input and output together.

At first, we tried to use the distance sensor since it was about the running race.

//1

int triggerPin1 = 6;

int echoPin1 = 7;

long distance1;

//2

int triggerPin2 = 3;

int echoPin2 = 4;

long distance2;

int w=0;

int gamestate = 0;

//condition

void setup() {

Serial.begin(9600);




//set 1

pinMode(triggerPin1, OUTPUT);

pinMode(echoPin1, INPUT);

//set 2

pinMode(triggerPin2, OUTPUT);

pinMode(echoPin2, INPUT);

}

void loop() {

// additional 2 microsecond delay to ensure pulse clarity

//loop1

digitalWrite(triggerPin1, LOW);

delayMicroseconds(2);

digitalWrite(triggerPin1, HIGH);

delayMicroseconds(10);

digitalWrite(triggerPin1, LOW);

// pulseIn waits for signal to go from HIGH to LOW,

// timeout according to max range of sensor

//1

long duration1 = pulseIn(echoPin1, HIGH, 17400);

//loop2

digitalWrite(triggerPin2, LOW);

delayMicroseconds(2);

digitalWrite(triggerPin2, HIGH);

delayMicroseconds(10);

digitalWrite(triggerPin2, LOW);

//2

long duration2 = pulseIn(echoPin2, HIGH, 17400);

// sound travels roughly 29cm per microsecond so we divide by 29,

// then by 2 since we recorded sound both going forth and back

distance1 = duration1 / 29 / 2;

distance2 = duration2 / 29 / 2;

//conditions

//if 1 hits and 2 not hit

if(distance1 < 10 && distance1>0){

w = 1;




}elseif(distance2 < 10 && distance2>0){

// if 2 hits and 1 not hit

w = 2;




}

//print test

Serial.print("distance1:");

Serial.print(distance1);

Serial.print(" distance2:");

Serial.print(distance2);

// Serial.print("distance1:");
ab
//if not equal to 0, then someone won state 1

}

The code above helped us try out the distance sensor. The following video is a demonstration of how the distance sensors work.

https://drive.google.com/file/d/1N8KmzAkgbtwQXgIO-sxINK8QBiUO53Ay/view?usp=sharing

During the User Testing Session, we tried to deal the card with the card dealer. However, the card dealer was not working as expected, the cards were stuck in the machine and the distance sensors were not as efficient as we expected. If the distance is too far, the sensor cannot sense the player. Also, in the previous video, when I removed my hands, the distance suddenly changed from 13 to 65, detecting some mysterious object.

Fortunately, we received a lot of feedback from the users. Learning Assistant Amelia suggested that we change the sensor to a pressure sensor to set the time instead of measuring the distance. Professor Andy Garcia advised that the game should have a shortcut to restart and visual cues for the players to know the game is on. Other advice included that the card dealer spin card might not be as “intense” as the running race. Based on this feedback, the first adaptation is to switch the game to drum master. For the sensor, we tested both the vibration sensor and the pressure sensor. The vibration sensor detected the wave of the vibration:

https://drive.google.com/file/d/1ftOagVBww0U1Irg2I0dEF9ujkHdfjjfh/view?usp=drive_link

However, as shown in the video, it still activates vibrantly after I stopped interfering.

The pressure sensor detected the pressure on it:

https://drive.google.com/file/d/1NA8sgF-9jvrfJ7QWZwv-qqHg_C6so4Bl/view?usp=drive_link

It is more stable than the vibration sensor after the interaction. The second adaptation was to add a button to restart and the LED to visually cue the players who won. The winner side’s LED would be on.

https://drive.google.com/file/d/1p1xB9Z2ZvsD6ZM1OrtRD4usZwSPosZ3c/view?usp=drive_link

The problem that I encountered was how to stop the game when the time was up.

if(millis() - startTime >= 10000){
Serial.print("GAME OVER!");
// stop the game by setting an unreachable pressure 
HIT1 = 1500; 
HIT2 = 1500;

Originally, I wanted to use millis() – startTime == 10000, but it didn’t work as expected. Professor Garcia explained that the time was too instant to detect so it would be better to use >= instead. At the same time, Robert finished the servo and the card dealer. The servo is to point at the loser to cue them to get the card.

https://drive.google.com/file/d/1EByl1kbUEftUgMMsmoGYk8A_ulKXEGI_/view?usp=drive_link

https://drive.google.com/file/d/1vm4fDy9z9uS3PpRWr8NwClLSk-Cz21Ay/view?usp=drive_link

https://drive.google.com/file/d/1cu7FRDn5tT8iKJlijgMi9cB3aa4UrNL1/view?usp=drive_link

The final demonstration is shown in the following video and the code is attached.

https://drive.google.com/file/d/1_X0WzuAjVlsJ0AfuKvE4I6G3ZMHIEwu7/view?usp=drive_link

#include <Servo.h>

Servo myservo;

int servov;

int p1;

int p2;

int val;

int prevVal;

int count1 = 0;

int count2 = 0;

int HIT1 = 210;

int HIT2 = 50;

int winner;

long startTime;

long shuffleTime;

int ledPin1_GREEN = 9;

int ledPin2_RED = 10;

int shuffle = 5;

bool shuffled = false;

void setup() {

myservo.attach(11);

Serial.begin(9600);

pinMode(2, INPUT);

pinMode(ledPin1_GREEN, OUTPUT);

pinMode(ledPin2_RED, OUTPUT);

pinMode(shuffle, OUTPUT);

}

void loop() {

//timer

val = digitalRead(2);

if(prevVal == LOW && val == HIGH){

Serial.println("Pressed");

startTime = millis();

count1 = 0;

count2 = 0;

HIT1 = 210;

HIT2 = 50;

shuffled = false;

// digitalWrite(ledPin1_GREEN, LOW);

// digitalWrite(ledPin2_RED, LOW);

digitalWrite(ledPin1_GREEN, HIGH);

digitalWrite(ledPin2_RED, HIGH); // turn the LED on (HIGH is the voltage level)

delay(1000); // wait for a second

digitalWrite(ledPin1_GREEN, LOW);

digitalWrite(ledPin2_RED, LOW); // turn the LED off by making the voltage LOW

delay(1000);

digitalWrite(shuffle, LOW);

myservo.write(90);

}

prevVal = val;

// read the input on analog pin 0 GREEN

p1 = analogRead(A1);

// print out the value of the sensor

Serial.print("player1:");

Serial.print(p1);

if(p1>HIT1){

count1 += 1;

}

Serial.print(" 1Hits:");

Serial.print(count1);

// delay for stability

delay(10);

// read the input on analog pin 0 GREEN

p2 = analogRead(A0);

// print out the value of the sensor

Serial.print(" player2:");

Serial.println(p2);

if(p2>HIT2){

count2 += 1;

}

Serial.print(" 2Hits:");

Serial.print(count2);

// delay for stability

delay(60);

//GAME OVER AFTER 10 SECONDS

if(millis() - startTime >= 10000){

Serial.print("GAME OVER!");

// stop the game by setting an unreachable pressure

HIT1 = 1500;

HIT2 = 1500;

if(count1>count2){

Serial.print("1 win!!!!!!");

digitalWrite(ledPin1_GREEN, HIGH);

digitalWrite(shuffle, HIGH);

myservo.write(0);

}elseif(count2>count1){

Serial.print("2 win!!!");

digitalWrite(ledPin2_RED, HIGH);

myservo.write(180);

}else{

Serial.print("DRAW!!!");

digitalWrite(ledPin1_GREEN, HIGH);

digitalWrite(ledPin2_RED, HIGH);

myservo.write(90);

}

if((count1>count2 || count2>count1) && shuffled == false){

digitalWrite(shuffle, HIGH);

shuffleTime = millis();

shuffled = true;

}

if(millis() - shuffleTime >= 3000 && shuffled){

digitalWrite(shuffle, LOW);

myservo.write(90);

}

}

}

The adaptations, the drum game, and the visual cues worked mostly as expected. The game is easier to monitor with straightforward winners and losers. The visual cues could show who won and who needed to do the exercise.

Conclusion

The project is called Deal A Workout. The 2 players try to hit the drum as fast as they can after they press the button and the lights go off. After 10 seconds, the game stops. The winner side’s LED will be on and the arrow will point at the loser. The card dealer will work for 3 seconds. The loser needs to get the card and do the exercise as the card indicates. Spades mean jumping jacks; hearts mean push-ups; clubs mean squats; diamonds mean burpees. For instance, if it is Heart 5, the loser needs to do 5 push-ups. If you press the button, the game starts again. The project aligns with my definition of interaction because the project responds to the users’s behaviors and the users can have an activity afterward. Ultimately, the audience interacted with the project mostly. I would improve the project in aesthetics, visual and sound cues, and the card dealer if we had more time. First, the wires could be hidden in some boxes rather than exposed to air. That would make the project more organized. In addition, the physical cues could be more obvious. The audience might not realize that the game has stopped as the LED is not that obvious. Especially, it might be difficult for the loser to know that since only the winner side’s LED will be on. We could add a buzzer to notify the players that the game is over. I have learned from the setbacks that the most direct instinct might not be the most practical approach to realizing the expectations. Sometimes, it might take some detours to make it. For this project, we changed 3 types of sensors from the most intuitive distance sensor to the pressure sensor. It took some time to realize that. Furthermore, the timer setting is another example. The game should stop after 10 seconds. The most instant one would be to stop it when it reaches 10 seconds. But in practice, it should be when the time is over 10 seconds. The takeaway from my accomplishments is that the logic of the conditions is not that scary as long as you have a flowchart.

Disassembly

Trash and the stuff we returned.

Appendix

Testing the outcomes for the win-lose two pressure sensors.

https://drive.google.com/file/d/1Iv_S2eF4CBAoF8aUO3G9Jx12ZiZ3Rxod/view?usp=drive_link

link: https://jasonlee557.github.io/CCLab/project-b-draft/

Title: English in Shanghainese

Description:

This is a draft of my project B. It will be an interactive storytelling that helps people to learn Shanghainese.

Reflection:

• How can orderly file name convention (html files, css files, images, etc.) prevent errors when building a website?
  • By classifying different files into different folders and distinct names, I don’t think people will mix different files up. Different types of files have different purposes, so a taxonomy can help people to distinguish things.
• When would you want to use classes, when IDs?
  • Classes are for HTML files and identifying different paragraphs, and different divs while IDs are not used regularly in HTML.
• Which limitations did you run into in the styling of your page?
  • I can only style of the text styles, the margins and padding in one page and I am not sure about how to create more than one page and making them have the button to jump back and forth.
• How does editing and styling a text in (WYSIWYG) text editor, such as Microsoft Word, compare to writing HTML? What are advantages of each over the other?
  • Microsoft Word gives users the freedom of choice and it is easier to vary the style, while HTML is more difficult to use with Google fonts.
• Explain how different web technologies come together in your webpage. How is writing HTML or CSS different from writing p5.js (JavaScript)?
  • HTML sets the tone and the structure of the website while CSS is used for the styling of the web page, whereas p5.js can add more interactivity and get the immediate outcome to the web page.
     

Project Description:

The project will be a mix of interactive storytelling and a tool. It is a website about learning English loanwords in Shanghainese. The minimum goal is to let the users learn six words after using the website.

The project will start with an introduction of the content, loanwords in Shanghainese, and the purpose. It will then follow with an interactive story about a kid feeling as if he were the child of a boss after going to a bakery by taxi to buy biscuits and nougats. The story will contain six loanwords in Shanghainese. Hopefully, the audience will learn from them. The interaction will be the taxi driving, the snacks eaten, and the camera capture of the audience’s figure as if he were the character in the story. 

If the users are eager learners, there will be an appendix of many loanwords in Shanghainese for them to learn more. Sound of the pronunciations and interaction to play the sound will be included.

Presentation:

https://docs.google.com/presentation/d/1VzXFv9OeKYW9xzgiCz-6d4zmrpARO3kffWSJ6U8E7-4/edit?usp=sharing

Project Title: Tadpoles to Frogs

link: https://editor.p5js.org/jl14064/sketches/kjU3aX4h3

Description: 

In this project, I tried to explore the principles and dynamic applications of Object-Oriented Programming (OOP) by creating the tadpoles’ growth into frogs.

Initially, they are just tiny tadpoles while their sizes will grow bigger as they swim in the pool. They will try to avoid colliding with each other by shaking their bodies. And if the size exceeds 70, the tadpole will become a frog. Eventually, the grown frogs will inhabit the surface of the pool in a “V” sequence. 

You should hear the frogs’ sound in the program though the following video doesn’t include the sound.

Coding:

During the coding process, I encountered several problems. 

At first, I put Class Tadpoles in the draw() function, which made several variables not defined before being called.

In addition, to count how many tadpoles successfully grow up, I introduced variable fn as a counter. I put it in Class Tad at first and made it this.fn. However, fn would be a local variable instead of a global variable, which would not be called when I tried to push Frog into the frog array. Therefore, I created a global variable called fn in the first few lines.

By introducing Class Frog after Class Tad, I also finished the challenging option of making two classes. 

let fn = 0;

function draw() {
background(152, 218, 248);
......
//remove tads
for (let i = tads.length - 1; i >= 0; i--) {
if (tads[i].isGone == true) {
if (tads[i].frog == true) {
fn += 1;
}
tads.splice(i, 1); // (index, quantity)
console.log(tads.length);
console.log(fn);
}
}

//frogs
for (let i = 0; i < fn; i++) {
if (i < fn / 2) {
frogs[i] = new Frog(
i * (width / frogs.length) + 20,
i * (height / (frogs.length / 2)) + 20
);
} else if (i == fn / 2) {
frogs[i] = new Frog(width / 2 + 20, height - 20);
} else {
frogs[i] = new Frog(
i * (width / frogs.length) + 20,
height - (i - fn / 2) * (height / (frogs.length / 2)) + 20
);
}
}
for (let i = 0; i < fn; i++) {
let frog = frogs[i];
frog.display();
}
}

To meet the challenging options, I created interactions among the tadpoles by making them shake if they were too close to each other.

detectCollition(other) {
let d = dist(other.x, other.y, this.x, this.y);
if (d < (this.w + other.w) * 0.8) {
this.y += random(-5, 5);
}
}

Reflection:

• What is Object-Oriented Programming (OOP), a Class and an Instance of the Class?
  • Programming with objects is called Object-Oriented Programming (OOP). A class is a grouping of related data and subroutines. A Class is like a blueprint for an Object, describing what an Object like this should have. An Instance is a specific version of an object, with its own particular details.
    

• Discuss the effectiveness of OOP. When is OOP useful? In what way can it be utilized?
  • OOP is useful when the code is designed to create an object, and it can be easily utilized for different purposes and it can be reused easily.
• Describe the objects you have created. What properties and methods were implemented? What kind of behaviors did you create by manipulating them?
  • I created a tadpole-like and a frog-like class. I used methods: update(), display(), detectCollition(), checkOutOfCanvas(), growth(). The tadpoles will grow bigger as they move around and their tails will make waves. If they are big enough, they will become frogs.

Project A: Acid Leaves

https://jasonlee557.github.io/CCLab/my-first-project/

2023 

Creative Coding by Jiasheng Li (Jason)

The leaves migrate with the blowing wind to survive. The audience can press the mouse to blow a wind and release the mouse to stop the wind.

The Elevator Pitch

Not only do the animals migrate, but also the plants do! The project establishes an environment where the leaves falling are from a polluted area with acid rains and they will migrate to a sunny and safe environment with the wind blowing by the audience pressing the mouse.

Abstract

Acid Leaves is about leaves migrating from a toxic environment to a safe environment. The leaves are red by default due to the pollution from the acid rain while they will be green and healthy again after migrating to the safe zone. The project aims to create a creature and embed a narrative and interaction with the audience in it. The audience can interact with the project by pressing the mouse to blow the wind and releasing the mouse to stop the wind. It resembles the process of exhalation, pressing the mouse compared to blowing. 

Reflection

1) Process: Design and Composition

It costs you something to be here, that makes you some kind of immigrant.

– Past Lives (2023)

The concept is inspired by the line in my recent favorite movie Past Lives (2023) directed by Celine Song. Though I am not an immigrant, I thought about migration and this quotation. On the other hand, the project requires me to create a kind of creature. So, why not make plants migrate? 

In terms of visualization, I was so ambitious that I wanted to include elements from every week. I tried to create two environments, one toxic and one healthy, where the leaves falling change between polluted and healthy states due to being blown into different environments.

In my project, the core elements are trees, rain, leaves, and sun. For the trees, I drew inspiration from Nina Wang’s mini-project 1. I used her tree structure as a reference and made it iterate. During Interaction Day, I noticed Ada Chen made a meteor shower in her Space Duck draft, which influenced me to add the acid rain in the toxic environment to make the pollution explicit. 

The interaction is mainly the wind blowing by the audience pressing the mouse. At first, the movement was too fast and not “natural”. In the later version, the movement is smoother and slower. I also cut out my plans of making syndromes such as measles, which is not practical. 

In conclusion, the overall process is a journey to make my articulation much more visualized and explicit to the audience. By establishing the background and making the effects smoother, the project became easier for the audience to understand. 

2) Process: Technical

Because this was a mid-term project, I wanted to deploy skills learned every week as much as possible. In the trees, I used function() to initialize the template and integrated the trees into the forest by constantly calling the function. The trees used the mini project1 knowledge of drawing with codes. The sun’s rays are made by angular movements, which contain a loop. For the leaves, I tried out arc.

The main problems that I encountered were the rain and the wind. 

 //toxic rain
push();
for (let i = 0; i < 500; i++) {
let rainX = random(width / 2);
let rainY = random(height);
stroke("red");
line(rainX, rainY, rainX, rainY + 20);
}
pop();

I tried out the rain in only one column with random. But later on, I turned to Ada Chen, my classmate, she told me to use a loop. Thanks for the help. 

As for the wind, Professor Godoy suggested I use Noise instead of simply changing the x. Thanks Teaching Assistant Cissy for her detailed explanation. She also pointed out the nuances between mouseIsPressed once and mouseIsPressed constantly, which impacted my project narrative. 

//falling leave
x = x + 5 * sin(ld) - 5 + noise(xoff) * 10; //noise
y = y + random(5);
ld = ld + 0.1;
arc(x, y, 100, 100, ld, ld + PI / 3);

//wind
if (mouseIsPressed) {
speedX = random(-15, 20);
x = x + speedX;
y = y + random(5);
}

3) Reflection and Future Development

In retrospect, I am really satisfied with the structure, the variety of coding and the narrative while I think certain effects after the interaction and variety of situations could be more developed. My presentation had a nice reaction from the audience which showed my narrative went well. 

During the feedback session, IMA fellows and my classmates suggested I improve the details and the interaction. Joey Yang was confused by the shape of the leaves as if they were pizza, which she recommended be changed by using curves. Professor Godoy advice me to think more about the time it took for the leaves to recover instead of making them cured instantly after crossing the border. Professor Eric Jiang commented that the wind was “not natural enough” for the reappearance of the leaves from the same position. He also suggested the background transition could be less apparent. Fatima Kazim proposed that the wind could impact the rain as well. 

I appreciate all these suggestions and I do think they are all valid. In the future, I think I should continue to draw inspiration from nature. As for the coding, the interaction and the effects after the interaction could be more complexed. I was only limited to the mindset that one interaction could only have one outcome. I should make the outcome more vibrant and colorful. 

In Long Live The Web, the author mentioned the beneficial and “ill effects”. From my own experience on the web, one of the beneficial effects is that a lot of data are shared so I can find the information that I need in most cases; the most reflected “ill effects” is that people would argue online fiercely online about some tricky social issues and it would eventually be taken over by trolls, which would make the divergence larger. 

Universality means that the web allows the users to have access to it no matter what kind of hardware, software, network connection, disability, or language they use. Isolation means that this kind of distribution is limited to certain hardware, software, network connection, ability or language. Universality is mostly related to the egalitarian ideal while isolation is about specific priorities and superiority. 

Open Standards refers to free, without certain restrictions and no need to pay, access for the experts to explore and design. Closed Worlds refers to a virtual community that is limited within that area with a certain entrance cost. Open Standards empower various experts to get into the construction of the web while Closed Worlds prevent the constructions from being altered by any John Doe. 

The Web is an application that runs on the Internet. The Internet is an electronic network that links a lot of information and distributes them into diverse media. The Web is a layer of the Internet. In other words, the Web is just a small combination of certain information while the Internet is a vast field of connections. From my experience, I use the webs individually when necessary while I also use them interactively with the Internet.

The author envisions the future of the web with four trends: open data, social machines, web science and free bandwidth. A decade after the article was published, we can witness a lot of realizations. Open data is widely used as getting information is much easier, especially with ChatGPT. In addition, it is also becoming a social machine for people to connect with each other and promote social justice with social media, ranking apps, and hashtags such as #metoo. Furthermore, Web science is around the corner when people start to realize the web can do more than just mimic the real world, especially during the hype of the metaverse. 

Unfortunately, the free bandwidth is more difficult than before. As artificial intelligence costs more resources and finance, the divergence between developed and developing countries is becoming wider. Other problems such as violation of privacy also arose during the COVID era when people moved a lot of life online. They are mentioned in the author’s articulation as side effects that should be taken into account.

Working Title:  Migration/Leaves

Presentation: https://docs.google.com/presentation/d/1ifQmf_8ThTFL6tDMhhzrsbM-Brx3VWDKh2C7XCFrgDg/edit?usp=sharing

Preparation:

link1 leave: https://editor.p5js.org/jl14064/sketches/SywY_Hn52

link2 migration: https://editor.p5js.org/jl14064/sketches/EqWyVCbeS

link3 measles: https://editor.p5js.org/jl14064/sketches/WK0XCLZRI

These are the 3 sketches I explored in mini project 3 to prepare for Project A.

1.LEAVE:

The first one is “the leave”, which resembles the leaves falling in nature. The location could be changed by pressing the mouse as if a strong wind blows. I will expand on this later. 

2.MIGRATION:

The second one is called “migration”. Alternately, the lollipop vortex moves between the left and right back and forth.

if (x<=0||x>=width){
cx = width - cx
s = 0

3. MEASLES

The third one is called “measles”. Similar to the “migration”, it moves in a seemingly circular motion but it is actually my first attempt to an angular motion.

angleVel = random(5)
angle = angle + angleVel;

// calculate the position
x = width/2 + cos(angle) * radDist;
y = height/2 + sin(angle) * radDist;

// display the circle
circle(x, y, dia)
radDist = radDist + 1

Future:

The main visual element would be based on sketch one LEAVE. It was originally “a slice of melon” but it would be too weird to make it “fall”. By changing it into a leave, the shape could assist me in experimenting with angle and arc. I would like to change the sin and random into noise in future development to make the movement more authentic. 

x = x + 5*sin(ld);
y = y + random(5);

These motions that I experimented with will be combined into my project A, Migration/ Leaves (working title). The idea is that the leaves must emigrate at different times otherwise they would get sick, having measles. Leaves could also be interpreted as a pun resonating with migration.

Ideally, the leave would fall in a random trace. If it successfully traverses width/2, it would be the same in appearance. Otherwise, there will be red spots indicating it is “sick” and it will decay, disappearing on the screen. In addition, the interaction would allow the viewer to “blow” the wind to change the location rapidly. If there is adequate space, I also would like to include pollination assisted by bees in the design to nurture the narrative of “migration” not just to survive but also to thrive.