import java.applet.*; import java.awt.*; import java.awt.image.*; import java.awt.event.*; import java.io.*; import java.net.*; import java.text.*; import java.util.*; import java.util.zip.*; import netscape.javascript.*; import javax.comm.*; import javax.sound.midi.*; import javax.sound.midi.spi.*; import javax.sound.sampled.*; import javax.sound.sampled.spi.*; import javax.xml.parsers.*; import javax.xml.transform.*; import javax.xml.transform.dom.*; import javax.xml.transform.sax.*; import javax.xml.transform.stream.*; import org.xml.sax.*; import org.xml.sax.ext.*; import org.xml.sax.helpers.*; public class WheelOfMisfortune extends BApplet {BFont fontA;
ArcBall arcball;

String students[] = {
  "Brent",
  "Christopher",
  "Daniel",
  "Danielle",
  "Esin",
  "Garo",
  "Jonah",
  "Kenneth",
  "Kyle",
  "Manuel",
  "Mathew",
  "Noah",
  "Susan",
  "Tak",
  "William"};

int nStudents;
float angVel = 0.05f;
float slowing = 0.99f;
float rot;
int sel;

int buttonLeft = 20;
int buttonTop = 20;
int buttonWidth = 90;
int buttonHeight = 30;
boolean trackingPress;
boolean buttonHighlight;

void setup() {
  size(400, 400);
  
  fontA = loadFont("ISOCPEUR.vlw");
  nStudents = students.length;
  arcball = new ArcBall(width/2, height/2, width);
  spin();
}

void loop() {
  // Set the font and its size (in units of pixels)
  background(40);
  

  //  int y = 45;  // Horizontal position of the type
  //  int l = 35;  // Leading (spaces between lines)

  //  line(y, 60, width, 60);
  //  int choice = int(random(nStudents));

  

  push();
  translate(width/2, height/2, 100);
  
  arcball.run();
  rot += angVel;
  if (rot > TWO_PI)
    rot -= TWO_PI;
  angVel = angVel * slowing;
  
  push();
  rotateY(rot);
  
  sel = (int)(((TWO_PI - rot) / TWO_PI) * nStudents);
  drawStudents();
  pop();
  line(0,0, 100, 0);
  stroke(153, 153, 0, 100);
  fill(153, 153, 0, 50);
  
  beginShape(TRIANGLES);
  vertex(0, 0, 0);
  vertex(100, 0, 0);
  vertex(100 * cos(TWO_PI / nStudents), 0, 100 * sin(TWO_PI / nStudents));
  endShape();
  
  pop();
  
  drawButton();
}

void spin() {
  angVel += 0.05f + random(0.4f);
}

void drawButton() {
  push();
  translate(buttonLeft, buttonTop);
  if (buttonHighlight) {
    fill(153, 153, 0, 150);
  }
  else {
    fill(153, 153, 0, 50);
  }
  rect(0, 0, buttonWidth, buttonHeight);
  translate(16, 24);
  text("spin", 0, 0);
  pop();
}

boolean mouseInButton() {
  if (mouseX < buttonLeft) return false;
  if (mouseX > buttonLeft + buttonWidth) return false;
  if (mouseY < buttonTop) return false;
  if (mouseY > buttonTop + buttonHeight) return false;
  return true;
}

void drawStudents() {
  float incAngle = TWO_PI / nStudents;

  push();
  
  //stroke(255, 255, 255, 100);
  alpha(100);

  for (int i = 0; i < nStudents; i++) {
    if (i == sel) {
      textFont(fontA, 54);
      fill(200, 0, 0, 220);
    }
    else {
      textFont(fontA, 44);
      fill(255, 255, 255, 70);
    }
    
    text(students[i], 10, 0);
    textFont(fontA, 44);
    stroke(0, 0, 0, 50);
    line(0, 0, 100, 0);
    rotateY(incAngle);
  }

  pop();

}

void mousePressed()
{
  arcball.mousePressed();
  if (mouseInButton()) {
    trackingPress = true;
    buttonHighlight = true;
  }
}

void mouseDragged()
{
  arcball.mouseDragged();
  if (trackingPress && mouseInButton()) {
    buttonHighlight = true;
  }
  else {
    buttonHighlight = false;
  }
}

void mouseReleased() {
  if (trackingPress) {
    if (mouseInButton()) {
      spin();
    }
  }
  trackingPress = false;
  buttonHighlight = false;
}

// Copy what's below exactly.
class ArcBall
{
  float center_x, center_y, radius;
  Vec3 v_down, v_drag;
  Quat q_now, q_down, q_drag;
  Vec3[] axisSet;
  int axis;

  ArcBall(float center_x, float center_y, float radius)
  {
    this.center_x = center_x;
    this.center_y = center_y;
    this.radius = radius;

    v_down = new Vec3();
    v_drag = new Vec3();

    q_now = new Quat();
    q_down = new Quat();
    q_drag = new Quat();

  axisSet = new Vec3[] {new Vec3(1.0f, 0.0f, 0.0f), new Vec3(0.0f, 1.0f, 0.0f), new Vec3(0.0f, 0.0f, 1.0f)};
    axis = -1;  // no constraints...
  }

  void mousePressed()
  {
    v_down = mouse_to_sphere(mouseX, mouseY);
    q_down.set(q_now);
    q_drag.reset();
  }

  void mouseDragged()
  {
    v_drag = mouse_to_sphere(mouseX, mouseY);
    q_drag.set(Vec3.dot(v_down, v_drag), Vec3.cross(v_down, v_drag));
  }

  void run()
  {
    q_now = Quat.mul(q_drag, q_down);
    applyQuat2Matrix(q_now);
  }

  Vec3 mouse_to_sphere(float x, float y)
  {
    Vec3 v = new Vec3();
    v.x = (x - center_x) / radius;
    v.y = (y - center_y) / radius;

    float mag = v.x * v.x + v.y * v.y;
    if (mag > 1.0f)
    {
      v.normalize();
    }
    else
    {
      v.z = sqrt(1.0f - mag);
    }

    return (axis == -1) ? v : constrain_vector(v, axisSet[axis]);
  }

  Vec3 constrain_vector(Vec3 vector, Vec3 axis)
  {
    Vec3 res = new Vec3();
    res.sub(vector, Vec3.mul(axis, Vec3.dot(axis, vector)));
    res.normalize();
    return res;
  }

  void applyQuat2Matrix(Quat q)
  {
    // instead of transforming q into a matrix and applying it...

    float[] aa = q.getValue();
    rotate(aa[0], aa[1], aa[2], aa[3]);
  }
}

static class Vec3
{
  float x, y, z;

  Vec3()
  {
  }

  Vec3(float x, float y, float z)
  {
    this.x = x;
    this.y = y;
    this.z = z;
  }

  void normalize()
  {
    float length = length();
    x /= length;
    y /= length;
    z /= length;
  }

  float length()
  {
    return (float) Math.sqrt(x * x + y * y + z * z);
  }

  static Vec3 cross(Vec3 v1, Vec3 v2)
  {
    Vec3 res = new Vec3();
    res.x = v1.y * v2.z - v1.z * v2.y;
    res.y = v1.z * v2.x - v1.x * v2.z;
    res.z = v1.x * v2.y - v1.y * v2.x;
    return res;
  }

  static float dot(Vec3 v1, Vec3 v2)
  {
    return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
  }

  static Vec3 mul(Vec3 v, float d)
  {
    Vec3 res = new Vec3();
    res.x = v.x * d;
    res.y = v.y * d;
    res.z = v.z * d;
    return res;
  }

  void sub(Vec3 v1, Vec3 v2)
  {
    x = v1.x - v2.x;
    y = v1.y - v2.y;
    z = v1.z - v2.z;
  }
}

static class Quat
{
  float w, x, y, z;

  Quat()
  {
    reset();
  }

  Quat(float w, float x, float y, float z)
  {
    this.w = w;
    this.x = x;
    this.y = y;
    this.z = z;
  }

  void reset()
  {
    w = 1.0f;
    x = 0.0f;
    y = 0.0f;
    z = 0.0f;
  }

  void set(float w, Vec3 v)
  {
    this.w = w;
    x = v.x;
    y = v.y;
    z = v.z;
  }

  void set(Quat q)
  {
    w = q.w;
    x = q.x;
    y = q.y;
    z = q.z;
  }

  static Quat mul(Quat q1, Quat q2)
  {
    Quat res = new Quat();
    res.w = q1.w * q2.w - q1.x * q2.x - q1.y * q2.y - q1.z * q2.z;
    res.x = q1.w * q2.x + q1.x * q2.w + q1.y * q2.z - q1.z * q2.y;
    res.y = q1.w * q2.y + q1.y * q2.w + q1.z * q2.x - q1.x * q2.z;
    res.z = q1.w * q2.z + q1.z * q2.w + q1.x * q2.y - q1.y * q2.x;
    return res;
  }

  float[] getValue()
  {
    // transforming this quat into an angle and an axis vector...

    float[] res = new float[4];

    float sa = (float) Math.sqrt(1.0f - w * w);
    if (sa < EPSILON)
    {
      sa = 1.0f;
    }

    res[0] = (float) Math.acos(w) * 2.0f;
    res[1] = x / sa;
    res[2] = y / sa;
    res[3] = z / sa;

    return res;
  }
}

}