“When one looks at the floor plan, it is supposed to describe human relationships, in which the addition of windows, doors, walls, and stairs are utilized to first divide the space, then selectively reunite the inhabited space.” Architecture is designed to provide a format for social life, and the dynamic interactions that happen in constantly pacing time. — Robin Evans in Figures, doors & passages.

The Hypothesis — Background

The project aims to rethink the design of future neighborhoods in order to improve the quality of life, while tackling the challenges of rising inequality, densification, increasing costs and globalization in cities today.

Due to rapid urbanization, there has been a resurgence of co-living all over the world. The high prices of real estate and an increasingly solitary lifestyle are leading people to seek new ways of living.

Cities that we inhabit now are the result of the huge transformation in our lives with the arrival of industrialization, the separation of the place of living and the place of work, and the idea that you leave the home to work However, our houses and neighborhoods should be changing in relation to the fact that 80 per cent of young professionals are working from their beds (wall street journal article).

Now workers coordinating across different time zones are returning to a flexible sleep schedule, in order to make conference calls with offices on the other side of the world. Shifting attitudes to sleep are already creating new typologies of urban architecture such as new hotels that have sleeping pods, are very reminiscent of the Archigram designs of the 1960s,”

Community living also brings into question the relationship of men, women and children in today’s world as theorized by Dolores Hayden in The Grand Domestic Revolution through domestic reorganization and creating community services.

The combination of smart-phone technology, the flexible and un-tethered nature of work, the sharing economy, and the rise of co-living has given the “horizontal architecture” of the bed a new significance, claims Architectural Historian Beatriz Colomina.

What are we doing — a new way of organizing apartments.

The co-living models being tried out today concern themselves only with space optimization. The potential, instead, it seems would lie in being able to optimize space through time. It thus presents itself as a spatial as well as a temporal problem. An agent based scheduling and space organization simulation has been attempted to unlock the potential of such an approach.

Ownership

Historically, certain sects of people have been treated in inhuman ways. When it comes to ownership of land and space, they fall into a great disadvantage as ownership of land and space is very much a factor of time. It is an asset that builds through generations and can be used to build other assets. The implications thus multiply significantly. With this ever widening chasm between the rich and the poor, cities are becoming increasingly polarized. With a belief that space shouldn’t be a commodity to be owned by people, the project explores the possibility of housing with zero ownership and tests it against varying levels of privacy.

Privacy

The simulation looks at the use of space in flux based on contemporary variable lifestyle and its inefficiency in occupation of space over different time cycles. Leading to a layered privacy concept where the owner would be able to regulate the sharing ratio of the apartment. Four scenarios are considered:

1. 100% Ownership and 100% Privacy — each person has their own apartment
2. 100% Ownership and 0% Privacy — current co-living model
3. 0% Ownership and 100% Privacy — each room is always occupied by 1 person
4. 0% Ownership and 0% Privacy — each room is always occupied as per the room limit.

Living: 4 persons

Kitchen and Dining: 2 persons

Study: 2 persons

Bedroom: 2 persons

Bathroom: 1 person

Schedule

A hypothetical schedule is created for a nurse who has night shifts, an accountant with a 9–5 job, an architecture student who spends sleepless nights at school, a retiree who spends most of his/her time at home and a techie who works from home. These schedules are then multiplied to get 20 schedules for twenty people.

Adjacency

We outlined different rules for generating floor plans based on the privacy and sharedness level and using the transitions from space to space in the schedule. The corridor is always generated first followed by the living room and the bedroom, the bathroom and the kitchen and then the study. In the model where there is no ownership and no sharedness, the corridor is the seed which connects to the living area or bedroom area. This scenario led to the some of the entries being from the bathroom where people freshen up before entering their living room or bedroom. The kitchen is connected to the living room and bedroom, and the study is connected to the bedroom and living room. The bathroom turns out to be the key in all spaces and they all benefit from being connected to the bathroom. Another model was created where all spaces get accessed from the corridor and thus the corridor becomes the space of encounter.

Since the normal rules for housing such as light/ventilation or efficiency of vertical circulation of services were not the concern here, they were not considered in generating the floor plan.

Simulation Vignettes

How It Works

The schedules of the different people that are going to live in the apartment are input into an excel sheet. A csv file is created from it which is then turned into arrays in c#. An app can be used by people to input their schedules into the system and generate floor plans in real time.

For the sake of simplicity, hours of the day are taken in two hour intervals. Each array contains the spaces that are being used at that hour. The simulation starts from 8 AM and generates all the spaces required at that time. It then goes onto 10 AM and generates only those spaces which are not in the previous array.

People Per Square Foot

CAPITALIST VS COMMUNIST LIVING

The project, through a changed ownership model, proposes a more affordable way of living. One would thus only be paying for the space that they occupy for that specific period of time. People would move from space to space while their phone detects the change in space at the threshold (door) and charges them for it and registers it in the system. The varying affordability allows us to create a society where all are allowed equal access to space vs today’s capitalist rental market.

Even though the proposed designs focus on creating reasonable cost and density, they create opportunities for intellectual conglomeration by means of this density through spaces that can force or stimulate interactions. Through such a controlled system, the owners can control the interactions people have in space.

What Do We Learn

By controlling the privacy and ownership, we create varying floor plans, each which can accommodate a different density of residents. The same number of residents occupy a considerably more area when there is ownership and no sharedness, compared to where there is no ownership and no sharedness. This area occupied reduces even further when there is no ownership and no sharedness. It was thus found that the quality of life can be made better by scheduling the occupancy of the different spaces instead of cramming multiple residents into one space or making the space itself smaller.

Further Thoughts

The traditional notion of a “living room” or a “bedroom” cannot be used to design housing in the future. The way people use these spaces is going to be drastically different in a zero ownership model and it thus lends itself to a lot more experimentation and thought.

Implications of such a project would be an equilibrium of work timings where the population in a city works for different third of the day.

The system can begin as a equal living neighborhood instead of mirroring the current power segregation in society.

This model of living could lead to a reduction in the contemporary social isolation epidemic.

Finally this shared concept can be extended for the reuse of other objects like cellphones,clothes, furniture, etc.

Script Vignettes

Scenario 3 Function

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class RoomSpawning : MonoBehaviour

{

public GameObject LivingRoom;

public GameObject KitchenDiningRoom;

public GameObject StudyRoom;

public GameObject BathRoom;

public GameObject BedRoom;

public GameObject Corridor;

string[] eightAM = { "Living", "Bedroom", "Bathroom", "Bathroom", "Study" , "Living", "Bedroom", "Bathroom", "Bathroom", "Study" , "Living", "Bedroom", "Bathroom", "Bathroom", "Study" ,"Living", "Bedroom", "Bathroom", "Bathroom", "Study" };

string[] tenAM = { "Living", "Bed", "Bed", "Out", "Out" , "Living", "Bed", "Bed", "Out", "Out" ,"Living", "Bed", "Bed", "Out", "Out", "Living", "Bed", "Bed", "Out", "Out" , "Living", "Bed", "Bed", "Out", "Out" };

string[] twelvePM = { "Bath", "Bath", "Bed", "Out", "Out" , "Bath", "Bath", "Bed", "Out", "Out" , "Bath", "Bath", "Bed", "Out", "Out", "Bath", "Bath", "Bed", "Out", "Out"  };

string[] twoPM = { "Study", "Kitchen", "Bed", "Out", "Out" , "Study", "Kitchen", "Bed", "Out", "Out" , "Study", "Kitchen", "Bed", "Out", "Out", "Study", "Kitchen", "Bed", "Out", "Out" };

string[] fourPM = { "Living", "Study", "Bed", "Out", "Out" ,"Living", "Study", "Bed", "Out", "Out", "Living", "Study", "Bed", "Out", "Out", "Living", "Study", "Bed", "Out", "Out"  };

string[] sixPM = { "Bath", "Study", "Bath", "Kitchen", "Out" , "Bath", "Study", "Bath", "Kitchen", "Out" , "Bath", "Study", "Bath", "Kitchen", "Out", "Bath", "Study", "Bath", "Kitchen", "Out" };

string[] eightPM = { "Bed", "Study", "Kitchen", "Living", "Out" ,"Bed", "Study", "Kitchen", "Living", "Out" , "Bed", "Study", "Kitchen", "Living", "Out", "Bed", "Study", "Kitchen", "Living", "Out"  };

string[] tenPM = { "Bed", "Study", "Out", "Bath", "Out" , "Bed", "Study", "Out", "Bath", "Out" , "Bed", "Study", "Out", "Bath", "Out" , "Bed", "Study", "Out", "Bath", "Out"  };

string[] twelveAM = { "Bed", "Bath", "Out", "Bed", "Out" , "Bed", "Bath", "Out", "Bed", "Out" , "Bed", "Bath", "Out", "Bed", "Out" , "Bed", "Bath", "Out", "Bed", "Out" };

string[] twoAM = { "Bed", "Living", "Out", "Bed", "Bath" , "Bed", "Living", "Out", "Bed", "Bath", "Bed", "Living", "Out", "Bed", "Bath", "Bed", "Living", "Out", "Bed", "Bath" };

string[] fourAM = { "Bath", "Bed", "Out", "Bed", "Bed" , "Bath", "Bed", "Out", "Bed", "Bed", "Bath", "Bed", "Out", "Bed", "Bed" , "Bath", "Bed", "Out", "Bed", "Bed"  };

string[] sixAM = { "Kitchen", "Bed", "Out", "Bed", "Bath" ,"Kitchen", "Bed", "Out", "Bed", "Bath" , "Kitchen", "Bed", "Out", "Bed", "Bath" , "Kitchen", "Bed", "Out", "Bed", "Bath"   };

int LivingBuilt = 0;

int LivingNeed = 0;

int KitchenBuilt = 0;

int KitchenNeed = 0;

int BedBuilt = 0;

int BedNeed = 0;

int BathBuilt = 0;

int BathNeed = 0;

int StudyBuilt = 0;

int StudyNeed = 0;

// Start is called before the first frame update

void Start()

{}

// Update is called once per frame

void FixedUpdate()

{

List<string> schedule = new List<string>();

//eightAM Array adding spaces to the List

foreach (string Living in eightAM)

{

schedule.Add("Living");

LivingBuilt++;

break;

}

foreach (string Bedroom in eightAM)

{

schedule.Add("Bedroom");

break;

}

foreach (string Bathroom in eightAM)

{

schedule.Add("Bathroom");

break;

}

foreach (string Study in eightAM)

{

schedule.Add("Study");

break;

}

foreach (string Kitchen in eightAM)

{

schedule.Add("Kitchen");

break;

}

foreach (string Living in tenAM)

{

if schedule.Count "Living" >= LivingBuilt

schedule.Add("Living");

LivingBuilt++

else don't do anything

}

foreach (string Bedroom in tenAM)

{

schedule.Add("Bedroom");

}

foreach (string Bathroom in tenAM)

{

schedule.Add("Bathroom");

}

foreach (string Study in tenAM)

{

schedule.Add("Study");

}

foreach (string Kitchen in tenAM)

{

schedule.Add("Kitchen");

}

foreach (string Living in twelvePM)

{

schedule.Add("Living");

}

foreach (string Bedroom in twelvePM)

{

schedule.Add("Bedroom");

}

foreach (string Bathroom in twelvePM)

{

schedule.Add("Bathroom");

}

foreach (string Study in twelvePM)

{

schedule.Add("Study");

}

foreach (string Kitchen in twelvePM)

{

schedule.Add("Kitchen");

}

foreach (string Living in twoPM)

{

schedule.Add("Living");

}

foreach (string Bedroom in twoPM)

{

schedule.Add("Bedroom");

}

foreach (string Bathroom in twoPM)

{

schedule.Add("Bathroom");

}

foreach (string Study in twoPM)

{

schedule.Add("Study");

}

foreach (string Kitchen in twoPM)

{

schedule.Add("Kitchen");

}

foreach (string Living in fourPM)

{

schedule.Add("Living");

}

foreach (string Bedroom in fourPM)

{

schedule.Add("Bedroom");

}

foreach (string Bathroom in fourPM)

{

schedule.Add("Bathroom");

}

foreach (string Study in fourPM)

{

schedule.Add("Study");

}

foreach (string Kitchen in fourPM)

{

schedule.Add("Kitchen");

}

foreach (string Living in sixPM)

{

schedule.Add("Living");

}

foreach (string Bedroom in sixPM)

{

schedule.Add("Bedroom");

}

foreach (string Bathroom in sixPM)

{

schedule.Add("Bathroom");

}

foreach (string Study in sixPM)

{

schedule.Add("Study");

}

foreach (string Kitchen in sixPM)

{

schedule.Add("Kitchen");

}

foreach (string Living in eightPM)

{

schedule.Add("Living");

}

foreach (string Bedroom in eightPM)

{

schedule.Add("Bedroom");

}

foreach (string Bathroom in eightPM)

{

schedule.Add("Bathroom");

}

foreach (string Study in eightPM)

{

schedule.Add("Study");

}

foreach (string Kitchen in eightPM)

{

schedule.Add("Kitchen");

}

foreach (string Living in tenPM)

{

schedule.Add("Living");

}

foreach (string Bedroom in tenPM)

{

schedule.Add("Bedroom");

}

foreach (string Bathroom in tenPM)

{

schedule.Add("Bathroom");

}

foreach (string Study in tenPM)

{

schedule.Add("Study");

}

foreach (string Kitchen in tenPM)

{

schedule.Add("Kitchen");

}

foreach (string Living in twelveAM)

{

schedule.Add("Living");

}

foreach (string Bedroom in twelveAM)

{

schedule.Add("Bedroom");

}

foreach (string Bathroom in twelveAM)

{

schedule.Add("Bathroom");

}

foreach (string Study in twelveAM)

{

schedule.Add("Study");

}

foreach (string Kitchen in twelveAM)

{

schedule.Add("Kitchen");

}

foreach (string Living in twoAM)

{

schedule.Add("Living");

}

foreach (string Bedroom in twoAM)

{

schedule.Add("Bedroom");

}

foreach (string Bathroom in twoAM)

{

schedule.Add("Bathroom");

}

foreach (string Study in twoAM)

{

schedule.Add("Study");

}

foreach (string Kitchen in twoAM)

{

schedule.Add("Kitchen");

}

foreach (string Living in fourAM)

{

schedule.Add("Living");

}

foreach (string Bedroom in fourAM)

{

schedule.Add("Bedroom");

}

foreach (string Bathroom in fourAM)

{

schedule.Add("Bathroom");

}

foreach (string Study in fourAM)

{

schedule.Add("Study");

}

foreach (string Kitchen in fourAM)

{

schedule.Add("Kitchen");

}

foreach (string Living in sixAM)

{

schedule.Add("Living");

}

foreach (string Bedroom in sixAM)

{

schedule.Add("Bedroom");

}

foreach (string Bathroom in sixAM)

{

schedule.Add("Bathroom");

}

foreach (string Study in sixAM)

{

schedule.Add("Study");

}

foreach (string Kitchen in sixAM)

{

schedule.Add("Kitchen");

}

var CorridorPosition = new Vector3(10, 0, 0);

var LivingPosition = CorridorPosition + new Vector3(10, 0, 0);

var BedPosition = CorridorPosition + new Vector3(10, 0, 10);

Vector3 BathPosition = LivingPosition + BedPosition ;

var StudyPosition

var KitchenPosition

var NewLivingPosition = CorridorPosition + new Vector3(10, 0, 0);

var NewBedPosition = CorridorPosition + new Vector3(10, 0, 0);

var NewStudyPosition

var NewBathPosition

var NewKitchenPosition

Instantiate(Corridor, CorridorPosition, Quaternion.identity);

foreach (string Living in schedule)

{

Instantiate(LivingRoom, LivingPosition, Quaternion.identity);

break;

}

foreach (string Bedroom in schedule)

{

Instantiate(BedRoom, BedPosition, Quaternion.identity);

break;

}

foreach (string Bathroom in schedule)

{

Instantiate(BathRoom, BathPosition, Quaternion.identity);

break;

}

foreach (string Kitchen in schedule)

{

Instantiate(KitchenDiningRoom, new Vector3(0, 0, 0), Quaternion.identity);

break;

}

foreach (string Study in schedule)

{

Instantiate(StudyRoom, new Vector3(0, 0, 0), Quaternion.identity);

break;

}

schedule.Clear();

}

}

Linking CSV file Function

for (int i = 0; i < data.Length - 1; i++)

{

string[] row = data[i].Split(new char[] { ',' });

if (row[1] != "")

{

Schedule s = new Schedule();

int.TryParse(row[0], out s.id);

s.name = row[1];

s.room = row[2];

s.room = row[3];

s.room = row[4];

s.room = row[5];

schedules.Add(s);

}

References

Evans, R. (1997). Translations from drawing to building. Cambridge, MA: MIT Press.

https://steemit.com/architecture/@twotoedsloth/domesticspaceasfiguresdoorsandpassagesbyrobinevans-uw0rl7v1ny

http://work.antonandirene.com/onesharedhouse/2/

https://emthesis.files.wordpress.com/2008/11/evans-figures-doors-and-passages.pdf

The New Domestic was originally published in Data Mining the City on Medium, where people are continuing the conversation by highlighting and responding to this story.

ARGUMENT : To Manipulate and optimize the spatial qualities of residential towers in order to improve the social environment while reducing the cost of living.

SYSTEM A : Optimized Coop living to allow for people to meet neighbors. The neighbors would be optimized by matching needs and tasks. Allowing for a shared convenience and growing familiarity.

SYSTEM B: This system would lead to lower personal costs due to shared living and occupants would pay per sm per hour of spaces used.

SYSTEM C: The system can begin as a equal living neighborhood instead of mirroring the current power segregation in society.

UNITY SNIPPET VIGNETTES: The simulation shows random spawning of multiple rooms around a central room based on the door location of the previous room. The intent is to develop the random spawning into a spawning based on user needs to eventually become a residential floor plan.

ROOM SPAWNING SCRIPT

/* Based on code from Random Dungeon Genrator Tutorial -https://youtu.be/eR74EjkA_4s */

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class RoomSpawner : MonoBehaviour {

 public int openingDirection;
 // 1 --> need bottom door
 // 2 --> need top door
 // 3 --> need left door
 // 4 --> need right door


 private RoomTemplates templates;
 private int rand;
 public bool spawned = false;

 public float waitTime = 4f;

 void Start(){
  Destroy(gameObject, waitTime);
  templates = GameObject.FindGameObjectWithTag("Rooms").GetComponent<RoomTemplates>();
  Invoke("Spawn", 0.1f);
 }


 void Spawn(){
  if(spawned == false){
   if(openingDirection == 1){
    // Need to spawn a room with a BOTTOM door.
    rand = Random.Range(0, templates.bottomRooms.Length);
    Instantiate(templates.bottomRooms[rand], transform.position, templates.bottomRooms[rand].transform.rotation);
   } else if(openingDirection == 2){
    // Need to spawn a room with a TOP door.
    rand = Random.Range(0, templates.topRooms.Length);
    Instantiate(templates.topRooms[rand], transform.position, templates.topRooms[rand].transform.rotation);
   } else if(openingDirection == 3){
    // Need to spawn a room with a LEFT door.
    rand = Random.Range(0, templates.leftRooms.Length);
    Instantiate(templates.leftRooms[rand], transform.position, templates.leftRooms[rand].transform.rotation);
   } else if(openingDirection == 4){
    // Need to spawn a room with a RIGHT door.
    rand = Random.Range(0, templates.rightRooms.Length);
    Instantiate(templates.rightRooms[rand], transform.position, templates.rightRooms[rand].transform.rotation);
   }
   spawned = true;
  }
 }

 void OnTriggerEnter2D(Collider2D other){
  if(other.CompareTag("SpawnPoint")){
   if(other.GetComponent<RoomSpawner>().spawned == false && spawned == false){
    Instantiate(templates.closedRoom, transform.position, Quaternion.identity);
    Destroy(gameObject);
   } 
   spawned = true;
  }
 }
}

Connected Living — Shared Economies was originally published in Data Mining the City on Medium, where people are continuing the conversation by highlighting and responding to this story.

Background

In today’s world, transportation is an integral part of us. However, current transportation systems are accompanied by a variety of issues, including global warming, environmental degradation, health effects, and greenhouse gas emissions. In fact, the transport sector will account for 23% of global greenhouse gas emissions from burning fossil fuels. Road transport accounts for the largest share of total greenhouse gas emissions at 75%, and this trend is expected to increase in the future.

Green transportation is critical because it can reduce the burden on the natural resources of fossil fuels such as oil, natural gas, and petroleum on the planet. Another reason why green transportation is essential is that the use of fossil fuels poses a considerable threat to the environment and humanity itself. When the smoke from a moving vehicle is inhaled by humans, it increases the risk of people suffering from diseases such as asthma. Green transportation can alleviate this problem. Also, green transit can save a lot of money we spend on gasoline.

Simulation Ideas

In the final project, we simulate how policy changes (1. oil tax, 2. Citi bike membership discount, 3. bus monthly card, 4.subway price) will influence the use of transportation modes (car, bike, bus, and subway) of citizens in a specific area. This simulation can be used as a helpful tool to help policymakers better predict the changes in people’s travel patterns after changing one or more transportation policies. Policymakers can use this tool to develop sound policies to enable people in this region to travel more efficiently and encourage people to use more environmentally friendly travel methods.

Parameters (Input):

• Changes in oil tax
• Citi Bike membership discount
• Bus monthly card discount
• Subway discount

Result (Output):

The number of people using bicycles, buses, subways, and cars (different transportation mode)

Diagram

Simulation examples

The following is one of the simulation examples of how we use our tool to predict the results.

• In the first group, firstly, we set the discount of bike membership, bus monthly card and subway ticket at the lowest level (0%), and set the oil tax at 5% to see the simulation result.
• Then we change the oil tax from 5% to 20% to see the change of transportation users.

Method

Literature Review

Investigate the impact of different transportation policies on the use of transportation modes.

Multiple linear regression

For each transportation mode, we conduct multiple linear regression to get their regression formula. To better achieve the reality of simulation, we add random number function in Unity. The formulas are as follows:

Bike = 1.08a+3.21b-1.32c-1.90d+e1+σ

Bus = 1.33a-1.31b+3.51c-1.02d+e2+σ

Subway = 1.09a-1.82b-1.50c+4.02d+e3+σ

Car = -3.34a -1.52b-1.87c-1.49d+e4+σ

a: oil tax [1%, 15%]

b: bicycle membership discount [1%, 20%]

c: monthly bus card discount [1%, 20%]

d: subway discount [1%, 20%]

e1-e4: constant

σ: random number

Illustration of the multiple linear regression process

Visualization in Unity

We visualize our ideas in Unity. There are four “destination”: car, bike, bus, and subway. People are produced based on our regression model. Every time people arrive at the destination, we add one number.

Evaluation of our tools

Advantage:

By using this tool, policymakers can easily accurately predict the changes in people’s travel modes after changing one or more transportation policies.

Disadvantage:

The simulation system is based on the New York City transportation system. New York City has a relatively developed public transportation system. It may not be suitable for other cities.

Reference

Fernández L., J. E., de Cea Ch., J., & de Grange C., L. (2005). Production costs, congestion, scope and scale economies in urban bus transportation corridors. Transportation Research Part A: Policy and Practice, 39(5), 383–403. https://doi.org/10.1016/j.tra.2004.08.003

Frankena, M. W. (1981). The effects of alternative urban transit subsidy formulas. Journal of Public Economics, 15(3), 337–348. https://doi.org/10.1016/0047-2727(81)90015-3

Gaudry, M. J. I. (1980). A study of aggregate bi-modal urban travel supply, demand and network behavior using simultaneous equations with autoregressive residuals. Transportation Research Part B: Methodological, 14(1–2), 29–58. https://doi.org/10.1016/0191-2615(80)90031-4

Glaister, S., & Lewis, D. (1978). An integrated fares policy for transport in London. Journal of Public Economics, 9(3), 341–355. https://doi.org/10.1016/0047-2727(78)90015-4

MTA. (2018). Ridership Trends.

Saggar, R. K. (2009). Economies of scale in bus transport: An indian case study*: bus transport in india. Bulletin of the Oxford University Institute of Economics & Statistics, 30(4), 341–346. https://doi.org/10.1111/j.1468-0084.1968.mp30004005.x

Modes and benefits of green transportation. (2013, April 29). Retrieved December 16, 2019, from Conserve Energy Future website: https://www.conserve-energy-future.com/name=modes-and-benefits-of-green-transportation

Green transportation. (2017, October 25). Retrieved December 16, 2019, from Ierek news website: https://www.ierek.com/news/index.php/2017/10/25/green-transportation/

Final energy consumption in Europe by mode of transport [Indicator Assessment]. (n.d.). Retrieved December 16, 2019, from European Environment Agency website: https://www.eea.europa.eu/data-and-maps/indicators/transport-final-energy-consumption-by-mode/assessment-9

// UI/UX 
// Slider
// SliderValueToText
// 

using UnityEngine;

using System.Collections;

using UnityEngine.UI;

public class SliderValueToText : MonoBehaviour

{

public Slider sliderUI;

private Text textSliderValue;

void Start()

{

textSliderValue = GetComponent<Text>();

ShowSliderValue();

}

public void ShowSliderValue()

{

string sliderMessage = sliderUI.value + “%”;

textSliderValue.text = sliderMessage;

}

}

------------------------------------------------------------------

// MonoBehaviour

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

using UnityEngine.UI;

public class bike_receiver : MonoBehaviour

{

// Start is called before the first frame update

public Text countText;

private Rigidbody rb;

private int count;

void Start()

{

rb = GetComponent<Rigidbody>();

count = 0;

SetCountText();

}

//void FixedUpdate()

//{

//}

void OnTriggerEnter(Collider other)

{

if (other.gameObject.CompareTag("Pick Up"))

{

other.gameObject.SetActive(false);

count = count + 1;

SetCountText();

}

}

void SetCountText()

{

countText.text = "Bike User Number Count:" + count.ToString();

}

}

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class bike : MonoBehaviour

{

public GameObject wall;

// Start is called before the first frame update

void Start()

{

}

// Update is called once per frame

void Update()

{

float speed = 10;

wall.transform.localPosition = Vector3.MoveTowards(gameObject.transform.localPosition, new Vector3(-7, 0, 30), speed * Time.deltaTime);

}

}

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

using UnityEngine.UI;

public class PlayerController : MonoBehaviour

{

// Start is called before the first frame update

public Text countText;

private Rigidbody rb;

private int count;

void Start()

{

rb = GetComponent<Rigidbody>();

count = 0;

SetCountText();

}

//void FixedUpdate()

//{

//}

void OnTriggerEnter(Collider other)

{

if (other.gameObject.CompareTag("Pick Up"))

{

other.gameObject.SetActive(false);

count = count + 1;

SetCountText();

}

}

void SetCountText()

{

countText.text = "Count:" + count.ToString();

}

}

Final Project: Travel Greener was originally published in Data Mining the City on Medium, where people are continuing the conversation by highlighting and responding to this story.

As the decade comes to a close, we are battling two very important problems.

#1. A staggering accumulation of landfill that is unable to be recycled, composted, or destroyed through energy recovery.

#2. The overwhelming percentage of the global population lacking basic human needs: namely, houses to call homes (nearly, half a million people in the US).

Could we harness the better parts of one crisis to alleviate another?

Our proposal: to create a recipe generator that will present a new way of recycling landfill materials.

First, we identified different categories of material, according to the EPA:

“EPA refers to trash, or municipal solid waste (MSW), as various items consumers throw away after they are used. These items include bottles and corrugated boxes, food, grass clippings, sofas, computers, tires and refrigerators. However, MSW does not include everything that is landfilled in MSW, or nonhazardous, landfills, such as construction and demolition (C&D) debris, municipal wastewater sludge, and other non-hazardous industrial wastes.”

Second, we organized each material type to correspond to its ability to be an architecture component.

We added a separate variable that dictated how many of each item was needed to produce (1) roof or wall etc. And a way for the simulation to notify the user on whether they had enough material.

After this research, we inputted these parameters into Unity, through different methods.

Through this simulation, we hope to:

• destigmatize waste
• question the society’s need for vast amounts of domestic space
• give regular civilians agency through the ability to DIY their own homes and write their own recipes

CODES

Code for UI notification of material quantity:

using UnityEngine;

using System.Collections;

using UnityEngine.UI;

public class ViewModel : MonoBehaviour

{

public Text buttonText;

public Text changeText;

public Dropdown selectDropdown;

public void Text_Changed(string newText)

{

float temp = float.Parse(newText);

if (selectDropdown.value == 1)

{

if (temp < 3)

{

changeText.text = "You need to collect more materials!";

}

else

{

changeText.text = "Home Sweet Home!";

}

}

else

{

if (selectDropdown.value == 2)

{

if (temp < 50)

{

changeText.text = "You need to collect more materials!";

}

else

{

changeText.text = "Home Sweet Home!";

}

}

else

{

if (selectDropdown.value == 3)

{

if (temp < 10)

{

changeText.text = "You need to collect more materials!";

}

else

{

changeText.text = "Home Sweet Home!";

}

}

}

}

}

}

for the random generation of buildings:

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

[CreateAssetMenu(menuName = "Building Settings")]

public class BuildingGeneratorSettings : ScriptableObject

{

public Vector2Int dimensionRange;

public int maxTiles;

public bool divideWings = true;

[Range(1, 256)]

public int minWingSizeToDiv;

[Range(1, 128)]

public int wingDivMargin;

[Range(0f, 1f)]

public float wingDivProbabilityBase = 0.3f;

[Range(0f, 1f)]

public float wingDivProbabilityIncrease = 0.1f;

public int maxStories = 2;

public bool limitStoriesByWings = true;

public bool divideRooms = true;

[Range(1, 256)]

public int minRoomSizeToDiv;

[Range(1, 128)]

public int roomDivMargin;

[Range(0f, 1f)]

public float roomDivProbabilityBase = 0.3f;

[Range(0f, 1f)]

public float roomDivProbabilityIncrease = 0.1f;

}

Home Cooked Recipes was originally published in Data Mining the City on Medium, where people are continuing the conversation by highlighting and responding to this story.

The system diagram for the new recommendation system is composed by this:

I want to have a trip.

Considering money, location, space and service,

How can I customize the recommendation?

These four decision elements all have other detailed choice, either to have a parameter affecting the recommendation level or give a threshold value that excludes the choices users don’t want.

In the actual UI system, the user can drag the bars to prioritize their choices. And the detailed divisions have checkbox that tell the user if he/she want this condition. The recommendation level is shown by the brightness and saturation of agents. Also when some choices are highly recommended, there will be a text box shows the detailed information (price, occupancy and review) to the user.

Below are the three gifs recording how the decision tree influences the result of recommendation. First gif is about the single element of influence. Second is telling how the combination of different powers affect the result. The last one shows what happens when changing the priority in decision tree.

Code Snippet:

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

using UnityEngine.UI;

public class AirbnbScript : MonoBehaviour

{

static private List<float> ScoresHolder=new List<float>();

public float Price;

public int HoldGuests;

public float StarNo;

private float ToTarget=10000000;

private float ToStation=10000000;

static private float HighestScore=0;

private bool IsExcluded=false;

private float MyScore=0;

GameObject Info;

Canvas InfoBar;

Text myText;

private int MyCode;

void Start()

{

CalculateDistance();

if(!CheckValidity())

{

Object.Destroy(this);

Debug.Log(“An Invalid Agent Detected!”);

}

ScoresHolder.Add(MyScore);

MyCode=ScoresHolder.Count-1;

Info=new GameObject(“Information”);

InfoBar=Info.AddComponent<Canvas>();

InfoBar.renderMode=RenderMode.WorldSpace;

InfoBar.referencePixelsPerUnit=1;

Info.transform.position=this.transform.position;

Info.transform.rotation=this.transform.rotation;

Info.transform.Rotate(90.0f,0,0);

RectTransform Z=InfoBar.GetComponent<RectTransform>();

Z.sizeDelta=new Vector2(100,50);

Info.transform.position=this.transform.position+new Vector3(0,0.5f,18f);

myText = Info.AddComponent<Text>();

myText.transform.localScale=new Vector3(0.5f,0.5f,0.5f);

myText.fontSize=14;

myText.color=Color.white;

myText.alignment=TextAnchor.MiddleCenter;

myText.font=Resources.GetBuiltinResource(typeof(Font), “Arial.ttf”) as Font;

}

void CalculateDistance()

{

GameObject Target=GameObject.FindGameObjectWithTag(“Target”);

ToTarget=Vector3.Magnitude(this.transform.position-Target.transform.position);

GameObject[] Stations=GameObject.FindGameObjectsWithTag(“ToStation”);

for(int i=0;i<Stations.Length;i++)

{

if(Vector3.Magnitude(this.transform.position-Stations[i].transform.position)<ToStation)

{

ToStation=Vector3.Magnitude(this.transform.position-Stations[i].transform.position);

}

}

}

bool CheckValidity()

{

if(Price<=0||HoldGuests>10||HoldGuests<=0||StarNo>5||StarNo<0||ToTarget<0||ToStation<0)

return false;

return true;

}

private void Update()

{

MyScore=GetLocationScore()+GetMoneyScore()+GetSpaceScore()+GetServiceScore();

if(IsExcluded)

MyScore=0;

ScoresHolder[MyCode]=MyScore;

//Debug.Log(MyScore);

HighestScore=0;

for(int i=0;i<ScoresHolder.Count;i++)

{

if(ScoresHolder[i]>HighestScore)

HighestScore=ScoresHolder[i];

}

ShadeTheAgent();

if(MyScore/HighestScore>0.9f)

{

if(myText.text==””)

{

myText.text = “$”+Price+”\n”+HoldGuests+” Guests”+”\n”+StarNo+” ※”;

}

}

else

{

myText.text=””;

}

}

void ShadeTheAgent()

{

if(HighestScore>0)

{

float x=MyScore/HighestScore;

{

this.gameObject.GetComponent<Renderer>().material.color=new Color(x*x*x*1f,x*x*x/4,x*x*x*0.6f,1);

this.gameObject.GetComponentInChildren<Light>().color=new Color(x*x*x*1f,x*x*x/2,x*x*x*0.8f,1);

this.gameObject.GetComponentInChildren<Light>().intensity=x*x*55;

this.gameObject.GetComponentInChildren<Light>().range=x*x*17;

}

}

else

{

this.gameObject.GetComponent<Renderer>().material.color=new Color(0,0,0,1);

this.gameObject.GetComponentInChildren<Light>().color=new Color(0,0,0,1);

this.gameObject.GetComponentInChildren<Light>().intensity=0;

}

}

float GetLocationScore()

{

float parameter=0.0f;

if(GameObject.Find(“Iv4”).transform.position.y==980)

{

parameter=10.0f;

}

if(GameObject.Find(“Iv4”).transform.position.y==860)

{

parameter=6.0f;

}

if(GameObject.Find(“Iv4”).transform.position.y==740)

{

parameter=3.0f;

}

if(GameObject.Find(“Iv4”).transform.position.y==620)

{

parameter=1.0f;

}

float PartScore=0;

GameObject Downtown, Station;

Toggle DowntownIsOn, StationIsOn;

Downtown=GameObject.Find(“Downtown”);

Station=GameObject.Find(“Subway”);

DowntownIsOn=Downtown.GetComponent<Toggle>();

StationIsOn=Station.GetComponent<Toggle>();

if(DowntownIsOn.isOn)

{

PartScore+=Mathf.Sqrt(1/ToTarget)*10;

}

if(StationIsOn.isOn)

{

PartScore+=Mathf.Sqrt(1/ToStation)*5;

}

return PartScore*parameter;

}

float GetMoneyScore()

{

float parameter=0.0f;

if(GameObject.Find(“Iv3”).transform.position.y==980)

{

parameter=16.0f;

}

if(GameObject.Find(“Iv3”).transform.position.y==860)

{

parameter=9.0f;

}

if(GameObject.Find(“Iv3”).transform.position.y==740)

{

parameter=4.0f;

}

if(GameObject.Find(“Iv3”).transform.position.y==620)

{

parameter=1.0f;

}

float PartScore=0;

GameObject Cheap, Value;

Toggle CheapIsOn, ValueIsOn;

Cheap=GameObject.Find(“Cheap”);

Value=GameObject.Find(“Value”);

CheapIsOn=Cheap.GetComponent<Toggle>();

ValueIsOn=Value.GetComponent<Toggle>();

if(CheapIsOn.isOn)

{

PartScore+=Mathf.Sqrt(10/Price);

}

if(ValueIsOn.isOn)

{

InputField input;

input=GameObject.Find(“MoneyBar”).GetComponent<InputField>();

float Bar = float.Parse(input.text);

if(Price>=Bar)

IsExcluded=true;

else

IsExcluded=false;

}

else

IsExcluded=IsExcluded||false;

return PartScore*parameter;

}

float GetSpaceScore()

{

float parameter=0.0f;

if(GameObject.Find(“Iv2”).transform.position.y==980)

{

parameter=16.0f;

}

if(GameObject.Find(“Iv2”).transform.position.y==860)

{

parameter=9.0f;

}

if(GameObject.Find(“Iv2”).transform.position.y==740)

{

parameter=4.0f;

}

if(GameObject.Find(“Iv2”).transform.position.y==620)

{

parameter=1.0f;

}

float PartScore=0;

GameObject Large, Guests;

Toggle LargeIsOn, GuestsIsOn;

Large=GameObject.Find(“Large”);

Guests=GameObject.Find(“Guests”);

LargeIsOn=Large.GetComponent<Toggle>();

GuestsIsOn=Guests.GetComponent<Toggle>();

if(LargeIsOn.isOn)

{

float guests=HoldGuests;

PartScore+=Mathf.Sqrt(guests/10);

}

if(GuestsIsOn.isOn)

{

InputField input;

input=GameObject.Find(“GuestBar”).GetComponent<InputField>();

int Bar = int.Parse(input.text);

if(HoldGuests<Bar)

IsExcluded=true;

else

IsExcluded=false;

}

else

IsExcluded=IsExcluded||false;

return PartScore*parameter;

}

float GetServiceScore()

{

float parameter=0.0f;

if(GameObject.Find(“Iv1”).transform.position.y==980)

{

parameter=16.0f;

}

if(GameObject.Find(“Iv1”).transform.position.y==860)

{

parameter=9.0f;

}

if(GameObject.Find(“Iv1”).transform.position.y==740)

{

parameter=4.0f;

}

if(GameObject.Find(“Iv1”).transform.position.y==620)

{

parameter=1.0f;

}

float PartScore=0;

GameObject Star, Rating;

Toggle StarIsOn, RatingIsOn;

Star=GameObject.Find(“Star”);

Rating=GameObject.Find(“Rating”);

StarIsOn=Star.GetComponent<Toggle>();

RatingIsOn=Rating.GetComponent<Toggle>();

if(StarIsOn.isOn)

{

PartScore+=StarNo/5;

}

if(RatingIsOn.isOn)

{

InputField input;

input=GameObject.Find(“RatingBar”).GetComponent<InputField>();

float Bar = float.Parse(input.text);

if(StarNo<Bar)

IsExcluded=true;

else

IsExcluded=false;

}

else

IsExcluded=IsExcluded||false;

return PartScore*parameter;

}

}

AirBnb: Customized Decision Tree and Recommendation Algorithm was originally published in Data Mining the City on Medium, where people are continuing the conversation by highlighting and responding to this story.

A Poem

Roaring cars，

running pedestrians，

and decreasing greens;

How could we live in a shared street

with changing participants?

Poetry+

Power:

The street is always under control,

The speed of the cars;

The space for parking;

The red lights control;

The design of the path;

The street is the mixture of different rules exerted on it.

Poetry in Motion

1. Competitive Shared Street System

2. How participants are involved

3. Example of how one participant influence an another

Gif Variation

1. Change the sequence of the time- Red light, speed of pedestrians and cars

2. Change the power- the rules like the path of the cars and the design patterns of the street; set punishment for violations

3. Change the money- Increasing or lowering the parking fees

Coded Poetry Vignette

using System.Collections;
using System.Collections.Generic;
using System.Numerics;
using UnityEngine;
using Vector3 = UnityEngine.Vector3;

public class move : MonoBehaviour
{
public GameObject car1;

public GameObject car2;

public GameObject car3;

public GameObject car4;

public GameObject car5;
public GameObject pedestrian;
public float speed;
private float timer = 0.0f;
public float speed1;

public float speed2;

public float speed3;
    // Start is called before the first frame update
    void Start()
    {
        

    }

    // Update is called once per frame
    void Update()
    {
        pedestrian.transform.position+= Time.deltaTime*2*Vector3.forward;
        car4.transform.position += Time.deltaTime * speed * Vector3.left;
                car5.transform.position += Time.deltaTime * speed * Vector3.right;
                car1.transform.position += Time.deltaTime * speed1 * Vector3.left;
                Vector3 pedestrianPosition = pedestrian.transform.position;
                Vector3 car1Position = car1.transform.position;
                float distance1 = car1Position.x-pedestrianPosition.x;
                if  (distance1<5 && distance1>0)
                {
                    speed1+=-20*Time.deltaTime;
                    if (speed1 <= 0)
                    {
                        speed1 = 0;
                    }
        
                }
                
                car2.transform.position += Time.deltaTime * speed1 * Vector3.right;
                Vector3 car2Position = car2.transform.position;
                float distance2 = pedestrianPosition.x - car2Position.x;
                if  (distance2<5)
                {
                    speed2+=-20*Time.deltaTime;
                    if (speed2 <= 0)
                    {
                        speed2= 0;
                    }
                    
                }
                car3.transform.position += Time.deltaTime * speed3 * Vector3.right;
                                 Vector3 car3Position = car3.transform.position;
                                 float distance3 = car2Position.x - car3Position.x;
                                 if (distance3 < 5)
                                 {
                                     speed3 += -20 * Time.deltaTime;
                                     if (speed3 <= 0)
                                     {
                                         speed3 = 0;
                                     }
                                 }
                                 

    }
}

Shared Street was originally published in Data Mining the City on Medium, where people are continuing the conversation by highlighting and responding to this story.

Poem~

-Before you have a target, you may often just wander.

-You can get to it faster if you become richer.

When we consider moving to a certain target, no matter a location or a moving spot. In some cases, it can be simplified as a chasing ball game. And there are many factors/parameters influence how we get to our destination, for example, we always try to arrive there faster, and the richer we are, the faster we can be.

Agents Build

Some times there is a decision tree frame.

Otherwise, we can have some factors that in a parallel structure to control the agent.

It’s too early to say the more complex, the better the simulation is, but for this time we just based on a simple decision tree to do this.

Simulation

First, there is a basic simulation that is using a “typical” parameter set.

Then the “money” is changed, which means the moving speed of agents will increase when they are richer.

And what if the attractivity of the targets? In real life, this could represent the willingness of moving to the destination.

The spatial limitation is also a factor. What if the targets are more likely to go to the edge area of the platform?

Code Vignette

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace BehaviorDesigner.Runtime.Tasks.Movement
{
[TaskCategory("AgentSystem")]
public Shared String tag;

[Tooltip("The speed of the agent")]
public SharedFloat speed;

[Tooltip("Search area")]
public SharedFloat search;

[Tooltip("Touched distance")]
public SharedFloat touchedDis;

private GameObject[] targetObjects;
private Vector3 prevDir;

public override void OnStart()
{
base.Onstart();

targetObjects = GameObject.FindGameObjectsWithTag(tag.Value);
}

//Follow the target

public override TaskeStatus OnUpdate()
{
if (target.Value == null)
}

var targetPosition = target.Value.transform.position;
if ((targetPosition - lastTargetPosition).magnitude >= moveDistance.Value)
{
SetSestination(targetPosition);
lastTargetPosition = targetPosition;
hasMoved = true;
}
else
{
if  (hasMoved && (targetPosition - transform.position).magnitude < moveDistance.Value)
{
Stop();
hasMoved = false;
lastTargetPosition = targetPosition;
}
}
return TaskStatus.Running;
}

Move to Target was originally published in Data Mining the City on Medium, where people are continuing the conversation by highlighting and responding to this story.

with a quick flash of light

his phone notified him of more

picking it up and without thought

he swiped

right

Push notifications that pop up from your phone can be seen as a form of advertisement. In this instance, the poem is meant to point out how a notification from a dating app can cause people to make real life decisions (sometimes life altering) almost without thinking what one is doing or the repercussions it may have.

INFORMATION DISPERSION was originally published in Data Mining the City on Medium, where people are continuing the conversation by highlighting and responding to this story.

Argument (Poem):

It is party time on Friday night!

WOOHOO!

But what will happen if the MTA 42nd Street Station close this night?

After working hard the whole week, people would like to get a drink and party with friends. Bars around time square might be ideal choices.

However, …

What if the subway station is closed for a night?

How can people meet their friends at parties at 11 pm?

What are the changes in people’s travel patterns?

Let’s simulate them in Unity!!!

WOOHOO!

Pseudo-code and Unity Code:

# Cube
# Cube Spawn
# Object Pooling
  # build an object pool
  # recycle when no more object

------------------------------------------

# cube

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class cube : MonoBehaviour

{

public float upForce = 1f;

public float sideForce = .1f;

// Start is called before the first frame update

void Start()

{

float xForce = Random.Range(-sideForce, sideForce);

float yForce = Random.Range(upForce / 2f, upForce);

float zForce = Random.Range(-sideForce, sideForce);

Vector3 force = new Vector3(xForce, yForce, zForce);

GetComponent<Rigidbody>().velocity = force;

}

// Update is called once per frame

void Update()

{

}

}
---------------------------------------------------------------

#Cube Spawn

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class CubeSpawner : MonoBehaviour

{

public GameObject cubePrefab;

// Start is called before the first frame update

void FixedUpdate()

{

Instantiate(cubePrefab, transform.position, Quaternion.identity);

}

// Update is called once per frame

void Update()

{

}

}

------------------------------------------------------------------

Simulation: An Overnight Closure at MTA 42nd Street Station was originally published in Data Mining the City on Medium, where people are continuing the conversation by highlighting and responding to this story.

Argument: Can social dating app control who you will fall in love with, or will the design of the app change the result who you end up with?

Types of Dating Apps:

1. Geolocation matching dating apps aggregate potential matches based on geographic proximity. (Tinder, Bumble)

2. Matching algorithm-based dating apps are powered by offline matching services or matching algorithms that base their choice on personal survey information. (eHarmony)

3. Niche dating apps target specific groups of people. (The League, The Grade)

The Poem:

Modern Love

Is it closing the gap of distance;

Or is it pulling away different people;

Maybe we are asking too much, aren’t we?

Extraction & Visualization:

(change the sequence of events)

1. Distance-based Geolocation matching

Simulation:

2. Similarity (match or not) Matching algorithm-based

Simulation:

3. The score, the highest score will get the chance to judge other people directly.

Simulation:

Afterthoughts:

Coding of Dating the Distance:

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class cubechase : MonoBehaviour

{

public float speed;

public Material[] material;

Renderer rend;

private Transform target;

private Transform home;

// Start is called before the first frame update

void Start()

{

rend = GetComponent<Renderer>();

rend.enabled = true;

rend.sharedMaterial = material[0];

target = GameObject.FindGameObjectWithTag("cubetwo").GetComponent<Transform>();

home = GameObject.FindGameObjectWithTag("planeone").GetComponent<Transform>();

}

// Update is called once per frame

void Update()

{

if (Vector3.Distance(transform.position, target.position) > 1.5) {

transform.position = Vector3.MoveTowards(transform.position, target.position, speed * Time.deltaTime);

}

if (Vector3.Distance(transform.position, target.position) < 2)

{

rend.sharedMaterial = material[1];

transform.position = Vector3.MoveTowards(transform.position, home.position, speed * Time.deltaTime);

}

Debug.DrawLine(transform.position, target.position, Color.red);

}

}

Coding of Dating the Similarity:

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class cubechase : MonoBehaviour

{

public float speed;

private Transform target;

private Transform home;

// Start is called before the first frame update

void Start()

{

target = GameObject.FindGameObjectWithTag("cubetwo").GetComponent<Transform>();

home = GameObject.FindGameObjectWithTag("planeone").GetComponent<Transform>();

}

// Update is called once per frame

void Update()

{

if (Vector3.Distance(transform.position, target.position) > 1.5) {

transform.position = Vector3.MoveTowards(transform.position, target.position, speed * Time.deltaTime);

}

if (Vector3.Distance(transform.position, target.position) < 2)

{

transform.position = Vector3.MoveTowards(transform.position, home.position, speed * Time.deltaTime);

}

}

}

Coding of Dating the Second Best:

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class cylinderchase : MonoBehaviour

{

public float speed;

public Material[] material;

Renderer rend;

private Transform target;

private Transform home;

private Transform targeta;

private Transform targetb;

private Transform targetc;

private Transform targetd;

// Start is called before the first frame update

void Start()

{

rend = GetComponent<Renderer>();

rend.enabled = true;

rend.sharedMaterial = material[0];

target = GameObject.FindGameObjectWithTag("cylindertwo").GetComponent<Transform>();

home = GameObject.FindGameObjectWithTag("planefour").GetComponent<Transform>();

targeta = GameObject.FindGameObjectWithTag("cube").GetComponent<Transform>();

targetb = GameObject.FindGameObjectWithTag("cubetwo").GetComponent<Transform>();

targetc = GameObject.FindGameObjectWithTag("sphere").GetComponent<Transform>();

targetd = GameObject.FindGameObjectWithTag("spheretwo").GetComponent<Transform>();

}

// Update is called once per frame

void Update()

{

if (Vector3.Distance(targeta.position, targetb.position) > 2)

{

transform.position = Vector3.MoveTowards(transform.position, targeta.position, speed * Time.deltaTime);

Debug.DrawLine(transform.position, targeta.position, Color.blue);

}

if (Vector3.Distance(targeta.position, targetb.position) < 2)

{

if (Vector3.Distance(targetc.position, targetd.position) > 2)

{

transform.position = Vector3.MoveTowards(transform.position, targetc.position, speed * Time.deltaTime);

Debug.DrawLine(transform.position, targetc.position, Color.green);

}

if (Vector3.Distance(targetc.position, targetd.position) < 2)

{

if (Vector3.Distance(transform.position, target.position) > 1.5)

{

transform.position = Vector3.MoveTowards(transform.position, target.position, speed * Time.deltaTime);

}

if (Vector3.Distance(transform.position, target.position) < 2)

{

transform.position = Vector3.MoveTowards(transform.position, home.position, speed * Time.deltaTime);

rend.sharedMaterial = material[1];

}

Debug.DrawLine(transform.position, target.position, Color.red);

}

}

}

}

Time Project was originally published in Data Mining the City on Medium, where people are continuing the conversation by highlighting and responding to this story.