Flower Garden

Ground ground;

Player player;

Sun sun;

Moon moon;

KeyManager keymanager;

Flower [] flowers;

float sideLen = 10000;

float time;

float timeScale = 10000;

boolean useLight = true;

int numFlowers = 1000;

​

void setup() {

  size(1000, 500, P3D);

  keymanager = new KeyManager();

  setPerspective();

  frameRate(30);

  newThings();

}

​

void newThings() {

  ground = new Ground(sideLen);

  sun = new Sun(2000, 250);

  moon = new Moon(2000, 50);

  player = new Player();

  newFlowers(numFlowers);

}

​

void setPerspective() {

  float cameraZ = ((height/2.0) / tan(PI*60.0/360.0));

  //perspective(PI/3.0, width/height, cameraZ/10.0, cameraZ*100.0);

  perspective(PI/3.0, width/height, cameraZ/10.0, cameraZ*1000.0);

}

​

void newFlowers(int n) {

  flowers = new Flower[n];

  for (int i = 0; i < n; i++) {

    flowers[i] = new Flower(random(-sideLen/2, sideLen/2), random(-sideLen/2, sideLen/2), 0);

  }

}

​

void setBackground(float time, float timeScale) {

  //cos(PI*time/timeScale)*

  //150, 230, 255

  color dayColor = color(150, 230, 255);

  color nightColor = color(20, 0, 50);

  //lerpColor(nightColor, dayColor, cos(PI*time/timeScale))

  //background(lerpColor(nightColor, dayColor, cos(PI*time/timeScale)));

  background(lerpColor(nightColor, lerpColor(nightColor, dayColor, cos(PI*time/timeScale)), cos(PI*time/timeScale)));

}

​

void draw() {

  time++;

  if (time >= 2*timeScale) {

    time = 0;

  }

  //background(255);

  setBackground(time, timeScale);

  //background(150, 230, 255);

  noStroke();

​

​

  //fill(255, 150, 255);

  //translate(75, 75, 0);

  //player.facing.set(mouseX/100, 0, mouseY/100);

  keyUpdates();

​

​

  //player.rotateWorld();

​

  translate(width/2, height/2, 0);

  rotateX(player.facing.x);

​

  rotateZ(player.facing.z);

  //rotateZ(-mouseX/100.);

  sun.update(time, timeScale, useLight);

  moon.update(time, timeScale, useLight);

  //fill(130, 200, 130); // ground color

  fill(150, 255, 150);

  //translate(player.loc.x, player.loc.y, player.loc.z-player.playerHeight+player.crouchChange-player.jumpHeight);

  player.moveWorld();

  //box(10000, 10000, 1);

  ground.update();

  //player.moveBack();

​

  for (int i = 0; i < flowers.length; i++) {

    flowers[i].update();

  }

}

​

void mousePressed() {

  //flower = new Flower(0, 0, 0);

  //println(player.xRotation);

  sideLen = random(10000);

  numFlowers = (int)random(1500);

  newThings();

​

}

​

void keyPressed() {

  keymanager.pressed();

}

​

void keyReleased() {

  keymanager.released();

}

​

void keyUpdates() {

​

  // space

  if (keymanager.keys[32] && player.location.z == 0) {

    player.acceleration.z = -26;

  }

  if (player.acceleration.z != 0) {

    player.location.z += player.acceleration.z;

  }

  if (player.location.z < 0) {

    player.acceleration.z += 2;

  } else {

    player.acceleration.z = 0;

    player.location.z = 0;

  }

​

  // wasd

  if (player.location.z == 0) {

    player.acceleration.x = 0;

    player.acceleration.y = 0;

    if (keymanager.keys[87]) {//w

      player.location.y += cos(player.facing.z)*player.walkingSpeed;

      player.location.x += sin(player.facing.z)*player.walkingSpeed;

      player.acceleration.y += cos(player.facing.z)*player.walkingSpeed;

      player.acceleration.x += sin(player.facing.z)*player.walkingSpeed;

    }

    if (keymanager.keys[83]) {//s

      player.location.y -= cos(player.facing.z)*player.walkingSpeed;

      player.location.x -= sin(player.facing.z)*player.walkingSpeed;

      player.acceleration.y -= cos(player.facing.z)*player.walkingSpeed;

      player.acceleration.x -= sin(player.facing.z)*player.walkingSpeed;

    }

    if (keymanager.keys[65]) {//a

      player.location.x += cos(player.facing.z)*player.walkingSpeed;

      player.location.y -= sin(player.facing.z)*player.walkingSpeed;

      player.acceleration.x += cos(player.facing.z)*player.walkingSpeed;

      player.acceleration.y -= sin(player.facing.z)*player.walkingSpeed;

    }

    if (keymanager.keys[68]) {//d

      player.location.x -= cos(player.facing.z)*player.walkingSpeed;

      player.location.y += sin(player.facing.z)*player.walkingSpeed;

      player.acceleration.x -= cos(player.facing.z)*player.walkingSpeed;

      player.acceleration.y += sin(player.facing.z)*player.walkingSpeed;

    }

  }

  else {

    player.location.add(player.acceleration);

  }

​

​

  // arrows

  if (keymanager.keys[37]) {//left

    player.facing.z += .1;

    //player.loc.y += cos(player.zRotation)*player.walkingSpeed;

    //player.loc.x += sin(player.zRotation)*player.walkingSpeed;

  }

  if (keymanager.keys[38]) {//up

    player.facing.x += .1;

    //player.loc.x += cos(player.zRotation)*player.walkingSpeed;

    //player.loc.y += sin(player.zRotation)*player.walkingSpeed;

  }

  if (keymanager.keys[39]) {//right

    player.facing.z -= .1;

    //player.loc.y -= cos(player.zRotation)*player.walkingSpeed;

    //player.loc.x -= sin(player.zRotation)*player.walkingSpeed;

  }

  if (keymanager.keys[40]) {//down

    player.facing.x -= .1;

    //player.loc.x -= cos(player.zRotation)*player.walkingSpeed;

    //player.loc.y -= sin(player.zRotation)*player.walkingSpeed;

  }

​

  if (player.facing.x < 0) {

    player.facing.x = 0;

  } else if (player.facing.x > PI) {

    player.facing.x = PI;

  }

​

  // wall collision

  float collisionDistance = 500;

  if (player.location.x > sideLen/2-collisionDistance) {

    player.location.x = sideLen/2-collisionDistance;

  } else if (player.location.x < -sideLen/2+collisionDistance) {

    player.location.x = -sideLen/2+collisionDistance;

  }

  if (player.location.y > sideLen/2-collisionDistance) {

    player.location.y = sideLen/2-collisionDistance;

  } else if (player.location.y < -sideLen/2+collisionDistance) {

    player.location.y = -sideLen/2+collisionDistance;

  }

​

  // shift

  if (keymanager.keys[16]) {//shift

    player.crouchChange = player.playerHeight/2;

    player.walkingSpeed = player.regularSpeed/2;

  } else {

    player.crouchChange = 0;

    player.walkingSpeed = player.regularSpeed;

  }

}

​

class Flower {

  PShape top;

  PVector [] points;

  float [] lengths;

  PShape inner;

  PShape stem;

  float x;

  float y;

  float z;

​

  Flower(float x, float y, float z) {

    simpleTopFlower(3);

    this.x = x;

    this.y = y;

    this.z = z;

  }

​

  void simpleTopFlower(float scale) {

    color innerColor = color(random(255),random(255),random(255));

    color topColor = color(random(100, 255),random(100, 255),random(100, 255));

    innerColor = color(red(topColor)-random(100), green(topColor)-random(100), blue(topColor)-random(100));

    stem = createShape();

    stem.setStroke(color(random(50, 150), random(150, 250), random(50, 150)));

    stem.setStroke(true);

    stem.setFill(false);

    stem.beginShape();

    stem.strokeWeight(random(2));

    stem.vertex(0, 0, 0);

    int joints = (int)random(5);

    float x = 0;

    float y = 0;

    float z = 0;

    for(int i = 0; i < joints; i++) {

      x += random(-10*scale, 10*scale);

      y += random(-10*scale, 10*scale);

      z += random(1*scale, 10*scale);

      stem.vertex(x, y, z);

    }

    stem.endShape();

    float[] heights = new float[10];

    lengths = new float[10];

    for (int i = 0; i < lengths.length; i++) {

      lengths[i] = random(5*scale, 15*scale);

      //println(lengths[i]);

    }

    top = createShape();

    top.setStroke(false);

    top.setFill(color(255, 150, 200));

    top.setFill(topColor);

    top.beginShape();

    for (int i = 0; i < lengths.length; i++) {

      heights[i] = random(-10, 10);

      top.vertex(x+lengths[i]*cos(2*PI*i/lengths.length), 

        y+lengths[i]*sin(2*PI*i/lengths.length), z+heights[i]);

    }

    top.endShape(CLOSE);

​

    float temp;

    for (int i = 0; i < lengths.length; i++) {

      temp = random(2*scale, 8*scale);

      if (lengths[i] > temp) {

        lengths[i] = temp;

      }

    }

    inner = createShape();

    inner.setStroke(false);

    inner.setFill(color(255, 225, 150));

    inner.setFill(innerColor);

    inner.beginShape();

    for (int i = 0; i < lengths.length; i++) {

      inner.vertex(x+lengths[i]*cos(2*PI*i/lengths.length), 

        y+lengths[i]*sin(2*PI*i/lengths.length), z+1+7);

    }

    inner.endShape();

  }

​

​

  void tempFlower() {

    points = new PVector[20];

    for (int i = 0; i < points.length; i++) {

      points[i] = new PVector();

    }

    top = createShape();

    top.beginShape();

    for (int i = 0; i < points.length; i++) {

      top.vertex(points[i].x, points[i].y, 

        points[i].z);

    }

    top.endShape(CLOSE);

    top.setFill(color(255, 150, 200));

  }

​

  void update() {

    translate(x, y, z);

    shape(stem);

    shape(top);

    shape(inner);

    if (false) {

      for (int i = 0; i < lengths.length; i++) {

        point(i, lengths[i], 0);

      }

    }

    //for(PVector p : points) {

    //  point(p.x, p.y, p.z);

    //}

    translate(-x, -y, -z);

  }

​

  void testupdate() {

    fill(color(255, 150, 200));

    beginShape();

    for (int i = 0; i < lengths.length; i++) {

      vertex(lengths[i]*sin(2*PI*i/lengths.length), 

        lengths[i]*sin(2*PI*i/lengths.length), 0);

    }

    endShape(CLOSE);

  }

}

​

class Ground {

  PShape terrain;

  float sideLen;

  Ground(float sideLen) {

    //g = createShape(ELLIPSE, 0, 0, 1000, 1000);

    terrain = createShape(GROUP);

    this.sideLen = sideLen;

    terrain.addChild(createGround(sideLen));

    terrain.addChild(createWalls(sideLen, 1000));

  }

  PImage groundTexture(float lenSide) {

    int sideLen = (int)lenSide/8;

    PImage img = createImage(sideLen, sideLen, RGB);

    for(int i = 0; i < sideLen; i++) {

      for (int j = 0; j < sideLen; j++) {

        noiseDetail(100, .5);

        if (noise(i/10, j/10) < .5) {

          img.pixels[i*sideLen+j] = color(150, 255, 130);

        }

        else {

          img.pixels[i*sideLen+j] = color(255, 0, 0);

        }

        //img.pixels[i*sideLen+j] = color(random(255), random(255), random(255));

      }

    }

    img.updatePixels();

    img.save("GROUND");

    return img;

  }

  PShape createGround(float sideLen) {

    PShape g = createShape(RECT, -sideLen/2, -sideLen/2, sideLen, sideLen);

    //g.setFill(color(100, 150, 100));

    g.setFill(color(150, 255, 130));

    //PShape g = createShape();

    //g.beginShape();

    //g.vertex(-sideLen/2, -sideLen/2, 0, -sideLen/8, -sideLen/8);

    //g.vertex(-sideLen/2, sideLen/2, 0, -sideLen/8, sideLen/8);

    //g.vertex(sideLen/2, sideLen/2, 0, sideLen/8, sideLen/8);

    //g.vertex(sideLen/2, -sideLen/2, 0, sideLen/8, -sideLen/8);

    //g.texture(groundTexture(sideLen));

    //g.endShape(CLOSE);

    //g.setFill(color(0, 255, 0));

    g.setStroke(false);

    return g;

  }

  PShape createWalls(float sideLen, float h) {

    sideLen /= 2;

    color wallColor = color(100);

    PShape w = createShape(GROUP);

    PShape temp = createShape();

    temp.setStroke(false);

    temp.setFill(wallColor);

    temp.beginShape();

    temp.vertex(-sideLen, -sideLen, 0);

    temp.vertex(-sideLen, -sideLen, h);

    temp.vertex(sideLen, -sideLen, h);

    temp.vertex(sideLen, -sideLen, 0);

    temp.endShape(CLOSE);

    w.addChild(temp);

    temp = createShape();

    temp.setStroke(false);

    temp.setFill(wallColor);

    temp.beginShape();

    temp.vertex(sideLen, sideLen, 0);

    temp.vertex(sideLen, sideLen, h);

    temp.vertex(sideLen, -sideLen, h);

    temp.vertex(sideLen, -sideLen, 0);

    temp.endShape(CLOSE);

    w.addChild(temp);

    temp = createShape();

    temp.setStroke(false);

    temp.setFill(wallColor);

    temp.beginShape();

    temp.vertex(sideLen, sideLen, 0);

    temp.vertex(sideLen, sideLen, h);

    temp.vertex(-sideLen, sideLen, h);

    temp.vertex(-sideLen, sideLen, 0);

    temp.endShape(CLOSE);

    w.addChild(temp);

    temp = createShape();

    temp.setStroke(false);

    temp.setFill(wallColor);

    temp.beginShape();

    temp.vertex(-sideLen, -sideLen, 0);

    temp.vertex(-sideLen, -sideLen, h);

    temp.vertex(-sideLen, sideLen, h);

    temp.vertex(-sideLen, sideLen, 0);

    temp.endShape(CLOSE);

    w.addChild(temp);

    float towerSide = 100;

    w.addChild(makeTower(-sideLen-towerSide, -sideLen-towerSide, 2*towerSide, h+2*towerSide, towerSide/3, wallColor));

    w.addChild(makeTower(sideLen+towerSide, -sideLen-towerSide, 2*towerSide, h+2*towerSide, towerSide/3, wallColor));

    w.addChild(makeTower(sideLen+towerSide, sideLen+towerSide, 2*towerSide, h+2*towerSide, towerSide/3, wallColor));

    w.addChild(makeTower(-sideLen-towerSide, sideLen+towerSide, 2*towerSide, h+2*towerSide, towerSide/3, wallColor));

​

    return w;

  }

  PShape makeTower(float x, float y, float sideWidth, float h, float topH, color wallColor) {

    PShape tower = createShape(GROUP);

    PShape wall = createShape();

    wall.setStroke(false);

    wall.setFill(wallColor);

    wall.beginShape();

    wall.vertex(x-sideWidth/2, y-sideWidth/2, 0);

    wall.vertex(x-sideWidth/2, y-sideWidth/2, h);

    wall.vertex(x-sideWidth/2, y+sideWidth/2, h);

    wall.vertex(x-sideWidth/2, y+sideWidth/2, 0);

    wall.endShape(CLOSE);

    tower.addChild(wall);

    wall = createShape();

    wall.setStroke(false);

    wall.setFill(wallColor);

    wall.beginShape();

    wall.vertex(x+sideWidth/2, y-sideWidth/2, 0);

    wall.vertex(x+sideWidth/2, y-sideWidth/2, h);

    wall.vertex(x+sideWidth/2, y+sideWidth/2, h);

    wall.vertex(x+sideWidth/2, y+sideWidth/2, 0);

    wall.endShape(CLOSE);

    tower.addChild(wall);

    wall = createShape();

    wall.setStroke(false);

    wall.setFill(wallColor);

    wall.beginShape();

    wall.vertex(x+sideWidth/2, y+sideWidth/2, 0);

    wall.vertex(x+sideWidth/2, y+sideWidth/2, h);

    wall.vertex(x-sideWidth/2, y+sideWidth/2, h);

    wall.vertex(x-sideWidth/2, y+sideWidth/2, 0);

    wall.endShape(CLOSE);

    tower.addChild(wall);

    wall = createShape();

    wall.setStroke(false);

    wall.setFill(wallColor);

    wall.beginShape();

    wall.vertex(x+sideWidth/2, y-sideWidth/2, 0);

    wall.vertex(x+sideWidth/2, y-sideWidth/2, h);

    wall.vertex(x-sideWidth/2, y-sideWidth/2, h);

    wall.vertex(x-sideWidth/2, y-sideWidth/2, 0);

    wall.endShape(CLOSE);

    tower.addChild(wall);

    return tower;

  }

  void update() {

    shape(terrain);

  }

}

​

class KeyManager {

  Boolean[] keys;

  Boolean exists;

  KeyManager() {

    keys = new Boolean[255];

    for(int i = 0; i < keys.length; i++) {

      keys[i] = false;

    }

  }

  void pressed() {

    //println(keyCode);

    keys[keyCode] = true;

  }

  void released() {

    keys[keyCode] = false;

  }

}

​

class Moon {

  float h;

  float sideLen;

  Moon(float h, float sideLen) {

    this.h = h;

    this.sideLen = sideLen;

  }

  void update(float time, float timeScale, boolean useLight) {

    translate(sin(PI*(time/timeScale+1))*10000, 0, cos(PI*(time/timeScale+1))*h);

    fill(255, 255, 255);

    noStroke();

    sphere(sideLen);

    translate(sin(PI*(time/timeScale+1))*-10000, 0, cos(PI*(time/timeScale+1))*-h);

    //pointLight(255, 255, 200, sin(PI*time/timeScale)*10000, 0, cos(PI*time/timeScale)*h);

    if (useLight) {

      pointLight(cos(PI*(time/timeScale+1))*50, cos(PI*(time/timeScale+1))*50, cos(PI*(time/timeScale+1))*100, sin(PI*(time/timeScale+1))*10000, 0, cos(PI*(time/timeScale+1))*h);

    }

  }

}

​

class Player {

  PVector location;

  PVector acceleration;

  PVector facing;

  //PVector facing;

  float jumpHeight = 0;

  float regularSpeed = 20;

  float walkingSpeed = 20;

  float playerHeight = 500;

  float crouchChange = 0;

  Player() {

    location = new PVector(0, 0, 0);

    acceleration = new PVector();

    facing = new PVector(HALF_PI, 0, PI);

  }

  void moveWorld() {

    //rotateZ(facing.z*PI);

    //rotateX(facing.x*PI);

    translate(location.x, location.y, location.z-playerHeight+crouchChange);

  }

  void moveBack() {

    translate(-location.x, -location.y, -(location.z-playerHeight+crouchChange));

  }

  void rotateWorld() {

    rotateZ(facing.z);

    rotateX(facing.x);

  }

}

​

class Sun {

  float h;

  float sideLen;

  Sun(float h, float sideLen) {

    this.h = h;

    this.sideLen = sideLen;

  }

  void update(float time, float timeScale, boolean useLight) {

    translate(sin(PI*time/timeScale)*10000, 0, cos(PI*time/timeScale)*h);

    fill(255, 255, 0);

    noStroke();

    sphere(sideLen);

    translate(sin(PI*time/timeScale)*-10000, 0, cos(PI*time/timeScale)*-h);

    //pointLight(255, 255, 200, sin(PI*time/timeScale)*10000, 0, cos(PI*time/timeScale)*h);

    if (useLight) {

      pointLight(cos(PI*time/timeScale)*255, cos(PI*time/timeScale)*255, cos(PI*time/timeScale)*255, sin(PI*time/timeScale)*10000, 0, cos(PI*time/timeScale)*h);

    }

  }

}