Computation08

Thesis and Final Prototype

Final Thesis Statement: To Simulate an Ecosystem

An exploration in the potential to create a simulated ecosystem as the basis for a game.

I am interested in creating games that have value beyond entertainment.  The knowledge gained in this exploration is applicable to a game I have been designing.  The purpose of the game is to model the complexities of resource management and building in a dynamic environment where all components are interconnected.   

My final prototype integrates an interactive brush tool.  When the user clicks and drags the mouse the will remove resources.  Immediately, the resources begin to flood into the empty space.  With this tool users can subtly change the layout of the map similar in the way the players of the game would remove resources.  It is an early interactive prototype.  I would like to add a variety of brushes as well as other additional functionality.

Link to: Final Paper and Final Presentation.

Narrowing in

In the last round of prototypes I spent time fleshing out some of my old ideas.  These projects were represented by topics that arose out of the original semantic games posted in earlier entries.  With those ideas addressed I began this week with a fresh ideation session.  Created a new list of interests and topics and fed it into the Semantic game.  See below:

Game
Community
interface
interaction
Players
Actors
Actions
meaning
syntax
language
ecosystem
Cellular Automata
Langton's loop
Game of life
synthetic
simulated
interdependent
software
hardware
organisms
Environment
Sustainability
Charity

The idea of creating the complexity of an ecosystem in a simple computer program is compelling to me.  It came from a game I had design a while back.  I wanted to create a game that went beyond simple entertainment.  I came up with the Masses at the games heart is a simulated ecosystem. 

Imagined cycles for ecosystem.

The game takes the form of a massively multiplayer game.  The central goal of the game is to build a civilization with other players in a collaborative environment.  Each player is reliant on the ecosystem for success while at the same time everything a player does effects the ecosystem on some level.  This is where the games conflict and tension exist.

game concept art.

  The players want to use resources to build and expand their community however if resources are used to aggressively it could take a negative toll on the environment.  The Masses seeks to advocate: sustainable development, collaboration, and creativity. click here to see a full explanation of the game

I found that even though I was making interesting headway with the Semantic game, my true interests were in "the Masses[UP LOAD THE MASSES LINK HERE]" Particularly with the ecosystem the game is built on.  I have always seen this as the crucial component; one that would make or break the game.  At the time of creating the documentation I did not have the skills necessary to explore it (I had never even considered learning how to code).  I wanted the ecosystem to be simple, so the users could grasp what was happening.  I began with three materials, red, green, and blue.  These three materials would exist in an interdependent constantly shifting dance.  After playing with combinations and rule sets I decided to add a fourth and fifth element: the sun and gas (atmosphere).  These would change in direct correlation to one another, if the amount of gas in the atmosphere went up, the amount of sun that hits the ground goes down.  Changes in the gas level is determined by changes in the material cycles, and so we have an interconnected system with dynamic elements.  I planed all this without the ability to test my thoughts.  Though the system looks like it might work on paper there is really no way to know without building it.  I am at the point now where I can write code without the syntax getting in the way of my creativity. Now I am able to tackle this topic.

The Processing book has a chapter title "Simulate: Biology" and I began playing with the examples.   Though I didn't fully understand the code at first, I made small changes and tried to figure out what was going on.  I started with Wolframs Cellular Automata model as it is the simplest. 

Stephen Wolfram's Cellular Automata from "Processing"

It grows in one dimension, each line of pixels drawn to the screen is determined by the pixel states in the previous row.  I did some rule set planning with an image editor to get an idea of how I should set up the rules of my game:

I tried to make my own with the interdependencies of the three materials and struggled with it for a while.  I couldn't get the dynamic results I was seeing from the Wolfram example.  The best I could do was this example:

John Conway's Game of Life from "Processing"

it only repeats the same pattern in a straight line, not very complex, however it is based on the programing techniques of the Wolfram model, each row printed is determined by the row above.

I spent a lot of time scribbling rules down in my note book.  The two dimensional examples were still a bit daunting.  When I first started the pursuit I didn't understand the code well enough to dive in.  Once I had a rule set that I thought might work I decided the best way to get comfortable with the code was to tinker with it.  I started by building a grid of rectangles.  I used Perlin Noise to simulate the sun and gas interaction.  My goal is to layer this rectangle grid over another grid that reacts to rules.  This grid would simulate the atmosphere and the rules grid would react to it.  I set out to add the second grid but still didn't really know what I was doing. 

My first attempt at implementing a grid system.  This acts as a simulation of a simple weather system.

I again turned to the processing book's biology chapter, and this time began working with the code from Conway's Game of Life:

John Conway's game of life.  from "processing."

In this program each pixel is either on (pixel = 1) or off (pixel = 0).  It begins by randomly populating the grid with on pixels and then executes the rule set on those initial random pixels.  The rule applied is determined by the state of the current pixel and the state of it's neighboring pixels.  Conway's game of life has three rules, two turning pixels off and one turning pixels on and a default that leaves the pixels as they are.   I started playing with the conditions that determined the rule applied and was pleasantly surprised.  I was able to get interesting effects by merely changing the conditions.  I was still having trouble understanding exactly what was happening but I was getting some interesting results. 

life v. 2

life v. 3

life v. 4

life v. 5

I was excited to see the results of these experiments,  they were behaving much like I was imagining the materials to behave.  I composited a few screen shots to communicate how I thought a final result may look.

In my next round of prototypes I would like to get a rule set for each material working

Experiements with the game of life

Last week I created a variety of rule sets for the game of life.  I began this weeks work with the aim to combine several rule sets into one program.  I began by attempting to create my own rule set from scratch. I was getting a better handle on how the code worked and was having more success with controlling the programs outcome.  This was due in large part to the use of the 'print' statement.  The rules are dictated by a series of if statements: if there are 3 neighbors than die etc.  I put a print statement in each if statement and had it spit out a number (the first rule spit out one the second spit out two etc.).  By doing this I was able to see which rules where firing and how often.  In the process I found some interesting results. 

Traditionally, Cellular Automata programs work by looking at each pixel individually every frame and comparing them with the surrounding pixels.  I was working with a canvas size of 400 by 400 pixels and the program was set to run  at 8 frames a second.  That's 1,280,000 calculations per second.  This is nearing the limit of Processing's power.  When trying to understand code I like to use print statements to get a handle on what and when things are happening.  With this program many calculations happen every frame Processing was not able to run with both the pixels being drawn and the print statements being displayed.  I could do one or the other but not both.  This made it very difficult to get a handle on what was happening.  However the print results were interesting.

Click to view the printout as HTML.  Your browser can zoom the text in and out. on mac: use "cmd & +/-"  on pc "cntrl & +/-".  Try it out.
  Note: the white space is the number 1.  At the zoom level the images was captured at the 1s don't show up.

This is the program used to make the printout. 

These print outs are interesting to look at, but they also could act as blueprints for the game environment  if it were to ever be developed further. 

I made print outs of some of my other life programs to see the results.  I continued tinkering with my code and gaining a better understanding of how the CAs worked.  It became clear that I would need some kind of system to keep track of which rule set was being applied.  The different rule sets would also need to be recognized by each other in order for the system to act as an integrated ecosystem.  There are many ways to do this, however because of the sheer number of calculations being preformed each frame already I needed a way that was fast.  Integers are the fastest data type so I decided to base the system around them.  The way game of life program that I am working with works, is by looking at each pixel and adding up the value of it's neighbors.  This total represents the number of neighboring pixels that are turned on.  If you have multiple rules working together and iterating with one another this won't work because the system will have no idea which rule is on.  I developed a system that would encapsulate all of the rules into one three digit integer. The "blue" count would be held in the 'ones' place the "red" count would be held in the 'tens' place and the green count would be held in the 'hundreds' place.  I than wrote a function that could parse the three digit number and return which ever place was being checked.  The function follows:

int nb(int N, int num) {
  for(int i =100; i >= 1; i=i/10) {
    int x;
    x = num/i;
    num = num - i*x;
    if(N==100) {
      if( i == 100) { //green
        return x;
      }
    }
    if(N==10) {
      if( i == 10) {//red
        return x;
      }
    }
    if(N==1) {
      if( i == 1) { //blue
        return x;
      }
    }
  }
  return 0;
}

The function returns an integer.  The first parameter is place that you want returned ('1', '10', '100') and the second is the number of neighboring pixels that are turned on (1-8 for blue, 10-80 for red, 100-800 for green).  so num might be 232.  That is 2 green 3 reds and two blues.  The function uses a for loop.  Each loop variable x is set to num and divided by i than it checks what value was entered and which step the loop is on.  If they match it spits out the number of neighboring pixels of the specified rule set.

With this function I set out to combine the three rule sets starting with ones that I had conceived of in my note book.

visual sketches of rules:

I tried to implement these rules.  The results were mixed, I was able to get interesting results but as the program runs the output gets more and more chaotic. 

rule combination 1

I made several iterations of this rule set and had trouble gaining control.  I than had the idea of applying my multiple rules method to some of the life rule sets I had made previously and was successful.  Below are the results.

 

Ruleset 1

and
Ruleset 2

The result:

Combination of life 2 and life 3.

3 rule set combination

The atmosphere is the last component to add.  Below is a composite of how the gas might look once it is added.

I found several cellular automata machines here is a good one if you want to experiment with them http://www.fourmilab.ch/cellab/manual/chap5.html

Using techniques of mathematical logic, von Neumann was then able to deduce that such self-reproduction should in fact be possible. His proof hinged on the idea that an automaton could have a blueprint for building itself, and that in self reproduction, two steps would be necessary: 1) make an exact copy of the blueprint, and 2) use the blueprint as instructions for making a copy of the automaton. The role of the blueprint is entirely analogous to the way DNA is used in biological self-reproduction, for here the DNA is both copied and used as instructions for building new proteins.

The complexity of a reservoir full of floating machine parts hindered von Neumann from making his proof convincing. The next step came from Stanislaw Ulam, who was working with von Neumann at Los Alamos during those years. Ulam's suggestion was that instead of talking about machine parts in a reservoir, von Neumann should think in terms of an idealized space of cells that could hold finite state-numbers representing different sorts of parts.

Below are von Neumann's theories put into practice as software:

Wikipedia article here

Exploring Precedence of Domains

Question Refinment

My original relational mapping helped me to arrive at domains I wished to study as well as interesting questions within each domain.   The domains and questions I wish to carry forward include: 

1. Can a method be derived for creating order in the massive information soup of the internet?
2. Can games be used as a tool to communicate?  Currently games are a one too many communication platform,  could they be a many to many communication platform?
3. Can simulated environments help us understand our own environment?
4. How can the web be made more accessible?
5. The web allows for the forming of communities,  individuals who join these communities are self motivated, what does this do to a persons self reference?
6. What does the power of creating do to ones self reference?
7. How can computer interfaces be changed to allow for more of the body to be utilized?

 

I am particularly interested in the intersections of these questions. specifically:

1. 1, 2 and 4: Can a game be made that gives order to the internet and makes it more accessible?
   
2. 2, 3, 5  and 6: Can a community based  game about building be designed to make players more conscious of our environment?
3. 4 and 7: How can computer interfaces be changed to allow for greater interactivity and interconnectivity?
   

Inspiration/Precedence:

Each question has a body of existing works and ideas to draw from.

Question 1 inspiration:

Google Image Labeler: is a feature, in form of a game, of Google Image Search that allows the user to label random images to help improve the quality of Google's image search results.(from wikipedea full article here.

"The Glass Bead Game is thus a mode of playing with the total contents and values of our culture; it plays with them as, say, in the great age of the arts a painter might have played with the colors on his palette. All the insights, noble thoughts, and works of art that the human race has produced in its creative eras, all that subsequent periods of scholarly study have reduced to concepts and converted into intellectual values the Glass Bead Game player plays like the organist on an organ. And this organ has attained an almost unimaginable perfection; its manuals and pedals range over the entire intellectual cosmos; its stops are almost beyond number." --Hermann Hesse from the Glass Bead Game Wiki link here

Question 2 inspiration:

This is an example of simple evolutionary software life. It consits of different colored pixels.  Purple pixels are stationary food.  Other colored pixels represent a set of rules, the author calls these bugs.  From the authors page: "The bugs eat their food by moving onto it, and they move strictly according to their limited genome (they have no sense organs to help them detect food).  The best genome is one that keeps a bug moving mostly in straight lines, turning only occasionally; this keeps a bug constantly moving to new areas, rather than exhausting the local food supply and then slowly starving."
Link to authors page (Scott Max)

link to the creator (Karl Sims) web page

Spore is a game where all content is user generated.  The player grows and evolves their species from tiny bacteria to sentiant beings capable of exploring a vast universe. 

New Computer Interface - Greater interaction

Computers consist of three distinct interactions.  Input, processing, output.  Since it's invention the computer has undergone dramatic innovations in each of these ares. Processing has evolved from cogs and gears (Charles Babbbage's Analytical Engine), large wire grids, to vaccum tubes, to transistors, all the way up to the modern micro processor.  The number of computations per second has increased from around 2,00 in the 1970 to almost 1,000,000,000 (1 billion) in todays fastest computers.  Output has evolved from fixed displays, to printouts, to todays modern screens outputting millions of colors.   Inputs have also evolved.  In the beginning we would input data with punch cards.  This was the practice for decades until the terminal was introduced.  The terminal provided a full keyboard  for entering data.  Allowing users to input data in a way that was closer to natural expression with a full English alphabet.   In the 1980s the mouse was invented at Xerox Parc and made popular by apple's Macintosh computer.  Graphical user interfaces were created that complimented the mouses ability to point and click.  Most recently multi touch displays have become popular and seem to be the future of computer interfaces.  All of these technologies rely on and are indeed limited to human finger interaction.   Below are examples of technology that go beyond the fingers.

My thought Machine

Link to my thought machine I built this simple app to aid me in my exploration.  My goal is to derive definitive domains from my broad and varied list of interests and topics.  I did this with a thought machine.  The first iteration of my thought machine was physical.  I used a set of cards with an interest written on each card.  The exercise of relating thoughts consisted of laying the crads out on the floor in a relational web.  This worked well as the results prove in my previous post.  However the activity is physically difficult.  It requires a large area and many cards.  If relationships change while playing (example: a card is laid down whose context changes aspects of the webs orientation) the process of moving cards around is difficult.  Also, the process of listing topics is arduous with physical cards.  I prefer to list my ideas on the computer, in a single file.  In fact that is what I did in the first iteration, I listed my interest in a txt file and once I was satisfied I copied each term onto a separate card.  Documentation s also a challange in the physical version.  I had many cards spread out across a large area of floor.  In order to capture the total form of the web I would have to backup to the point where the terms written on the cards were no longer legible.  To compensate I would take detail shots of the web, highligting areas of interest.  While this works it makes the process of relational mapping longer and more difficult than desired.  The app above is the first shot at remedying these problems.  It takes a txt file as input and creates a "card" for each term that the user can drag around the screen to make relationships.  At any point during the mapping process the user may take a snap shot by hitting the "Enter" key.  This first iteration few functional problems, which I plan to correct in a future iteration.  It also could benifit from some added features, which I'll discuss later.

Below are a few of the results from my mapping

This series shows the progression of one session of mapping.  You can see that at certain points the web shifts forms.  This usually occurs when there is not enough room to carry out a thought or if things are mapped in such a way that does not allow the most accurate relations to be made.

Exploring Domains and ideas

This first step in the mini-thesis process is about finding a topic for exploration.   As an aid to thinking we were asked to diagram our interest and find intersection and relationships.  I choose to use a mind mapping game I have been developing link here. 

I began this process by creating a list of of terms and phrases that encapsulate my interests.  I was liberal in my listing, not limiting the topics to any specific realm.  From this list I made index cards with each topic and laid them out in a relational web looking for semantics.   To further illustrate and solidify he semantics of my web I implemented a defining relational layer in the form of smaller cards with defind relationships: subclass of, superclass of, in the domain of,  property of, same as, different from, etc.  Below are photos of the results.  To make clear the connections that resulted from my efforts I have highlighted what I see as the most interesting relationships.  Please refer to the key below

list of domains and subjects used:

semantic web
artificial intelligence
physical computer interface
accessible
capitalism
semantic
Barrak Obama
The human brain
Alternative energy
games
Community
Communication
Internet
robots
Nature of time and space
extra dimensional objects
the power of creating
animal
system
colony
simulated ecosystem
simulated environment
simulated life
drama
automata
lucy
internet
action
hive
self reference
semantic
sentience
imagination
strategy
happiness
the human spirit
arts
science
technology
medium
media
connectivity
art
nature
Sustainable development
closed system
Relational data
Hierarchy
structured web
tree
web

List of Motivations

Happiness, Progress, Enhancing the Internet, the smeantic web, self exploration, emergent technologies, impact.

Stage 1: layout of original cards.

This is the first iteration of the relational web.  Once I finished, I was inspired to add more terms

Stage 2: expansion

The second iteration provided a more thourough exploration of my interests and ideas.  To strenghthen the semantics of my web I added relational terms

In this third iteration I added still more cards from the semantic card game I was developing (link above).  These cards served to round out my thinking by providing topics that were created outside of the realm of my research.  These cards had picture cards mixed with in with phrase cards, these nicely illustrated sections of the web.  Though it may seem like a random act, introducing subjects that at first seem unrelated to ones line of thinking can be a great way to jog creativity.  Once these cards were laid in I added the relational cards to strengthen the web's semantics

Areas of interest

With my semantic web complete I spent time studying the web lokking for interesting relationships.  Below are detail snap shots.  I have overlaid graphics to highlight my thinking.  Notice the colored dots in the image above; these refer to the areas detailed below.  Please refer to the key below for a full explanation of the graphics.

Commmunication

Questions raised: By allowing everyone an equal oppertunity to express themselves the internet has become a powerful tool for communication and community, however the amount of information is vast and only growing.  Can a method be derived for creating order in the massive information soup of the internet?

 

Games

Questions raised:Can games be used as a tool to communicate?  Currently games are a one way communication platform, what could make them a two way communication tool?

Physical Computer Interface

Questions raised: Currently computer interface relies on fingers for input and eyes for output.   How can computer interfaces be changed to allow for more of the senses to be utilized?  What are the practical implications?  What are the practical forms this might take?  Side Note:  This is something I have been thinking about for a while.  I was disappointed that it ended up so far out on the periphery of the web.  What does being on the periphery of the web mean?

 

Simulated Environments

Questions raised:  Can simulated environments help us understand our own environment?  Can simulated life spawn computer intellegnce?  What if we thought of our environment as an extra dimensional object (a object where the dimension of time was seen in the same space as physical space)? 

Internet Technology and it's future

Questions raised:It is interesting the the "Web" ended up at the center of the relational web.  This seems to imply that it is central to all other subjects.  What are the implications of the internet being central to our self reference?  How can the web be made more accessible?  The web allows for the forming of communities,  individuals who join these communities are self motivated, what does this do to a persons self reference?

the self/the actor

Questions raised: What does the power of creating do to ones self reference?  What is the individuals relationship to capitalism?

Lobby Pet: design document

download pdf:
Download lobbyPetsDoc.pdf

LobbyPet

The LobbyPet is an interactive playmate devised to entertain in the monotonous periods of your day. Just like a pet brings comfort when you get home, the LobbyPet comforts and entertains you while you wait for an elevator, stand in line for food, or various other dull times of the day. Your LobbyPet responds to your voice, so he'll come when you call him. However, he doesn't like it to be too loud, so make sure not to yell at him. He may hide at first when you bring over a large group of people, but if they're nice to him, he may eventually come out to say hi.

By M Bethancourt, Shipra Gupta, & Joe Mauriello

Andi Talks to the LobbyPet

Andi Talking to the lobbyPet from Mouse & the Billionaire on Vimeo.

The LobbyPet Promo Video

lobbyPet from Mouse & the Billionaire on Vimeo.

Image 2, Image 3, Image 4, Image 5

Image 2

e1. Load a sequence of related images into an array and use them to create a linear animation.

view Image 2 exercise 1

e2. Modify the program for exercise 1 to present each frame of animation at a different rate and in a different sequence.

view Image 2 exercise 2

e3. Animate an image by changing more than one of its attributes (e.g., size, position, tint).

view Image 2 exercise 3

Image 3

e1. Load an image and use get() to create a collage by overlaying different sections of the same image.

view Image 3 exercise 1

e2. Load an image and use mouseX and mouseY to read the value of the pixel beneath the cursor. Use this value to change some aspect of the image.

view Image 3 exercise 2

e3. Draw a shape in the display window. Copy a section of the window to another by using get() and set() within a for structure.

view Image 3 exercise 3

Image 4

e1. Load an image and alter it with filter().

view image 4 exercise 1

e2. Load three images and combine them with blend().

view Image 4 exercise 2

e3. Load two images and use copy() with mouseX and mouseY to combine them in a way that reveals the relationship between the images.

view Image 4 exercise 3

Image 5

e1. Write your own image fi lter by modifying the values of pixels[]. 2. Explore different kernels to convolve an image and write a program

view image 5 exercise 1

e2. Explore different kernels to convolve an image and write a program to display your most interesting discovery.

view Image 5 exercise 2

e3. ad an image and use its data to generate an animation that refl ects the original image.

view Image 5 exercise 3

Data 2, Data 3, Data 4

Data 2

e1. Create fi ve char variables and assign a character to each. Write each to the console.

view Data 2 exercise 1

e2. Create two String variables and assign a word to each. Write each to the console.

view Data 2 exercise 2

e3. Store a sentence in a String and write it to the console.

view Data 2 exercise 3

Data 3

e1. Write a program to convert the value of an integer to other data types. Display the conversions in the console.

view Data 3 exercise 1

e2. Load an image and display its height and width to the console using the PImage fields.

view Data 3 exercise 2

e3. Explore the String methods and use one or more of them to reconfi gure two sentences into one variable.

view Data 3 exercise 3

Data 4

e1. Create an array to store the y-coordinates of a sequence of shapes. Draw each shape inside draw() and use the values from the array to set the y-coordinate of each.

view Data 4 exercise 1

e2. Write a function to multiply the values from two arrays together and return the result as a new array. Print the results to the console.

view Data 4 exercise 2

e3. Use a 2D array to store the coordinates for a shape of your own invention. Use a for structure to draw the shape to the display window.

view Data 4 exercise 3

Input 4, Motion 1, Motion 2

Input 4

e1:Change the properties of a shape based on the cursor’s distance to its center.

view Input 4 exercise 1

e2:Use the easing equation to create a shape that acts lazy.

view Input 4 exercise 2

e3:Using the techniques introduced in this unit, create three shapes that each follow the mouse in a different way.

view Input 4 exercise 3

Motion 1

e1:Move two shapes continuously, but constrain their positions to the display window.

view Motion 1 exercise 1

e2:Move three shapes on different curves to create a kinetic composition.

view Motion 1 exercise 2

e3:Use the transformation functions to animate a shape.

view Motion 1 exercise 3

Motion 2

e1:Make a shape move with numbers returned from sin() and cos().

view Motion 2 exercise 1

e2:Develop a kinetic composition using the concept of phase shifting.

view Motion 2 exercise 2

e3:Use code 32-06 as a base for creating a more advanced organism.

view Motion 2 exercise 3