// Firebeasty

​

//////////////////////

///GLOBAL VARIABLES///

//////////////////////

​

let vol = 0.1;

let volumeSlider;

​

let p1;

let p2;

let vel;

let pVel;

let sign = 0;

let pSign = 0;

let failCounter = 0;

​

let active = 0;

​

let vitals = 99.9;

let pvitals;

let vitalsShift = 0.0;

​

let gelBlobs = [];

let currentSyringe= [];

let sutures = [];

let ultrasoundPings = [];

let cuts = [];

let smallCuts = [];

let smallTumors = [];

​

let syringePx;

let syringePy;

​

let numCutsStart = 50; //Starting Cuts

let numSmallCutsStart = 4; //Starting small cuts

let numSmallTumorsStart = 5;

​

let heading1;

let heading2;

let headingChange;

let headingTolerance = 0.125;

let starTraces = [];

let starCheck = 0;

let starUse = 0;

let healingIndex;

let healingLabel;

let healingConfidence;

​

let shapeClassifier;

let canvas;

let inputImage

​

let toolList = [];

let toolWheel = [];

let toolIndex = 0;

let toolTemp;

let toolKeys = [0,0,0,0];

​

let spritesGel = [];

let spriteSyringes = [];

​

​

//////////////////

//// PRELOAD  ////

//////////////////

​

function preload() {

  //// SOUNDS ////

    //music

    soundMusic = loadSound("sounds/operation.mp3");

    //voices

    soundStarting = loadSound("sounds/starting.wav");

​

    //sfx

    soundGel = loadSound("sounds/gel.wav");

    soundStitch = loadSound("sounds/stitch.wav");

    soundSmallSuccess = loadSound("sounds/success1.wav");

    soundBigSuccess = loadSound("sounds/success2.wav");

    soundLaser = loadSound("sounds/laser.wav");

    soundUltra = loadSound("sounds/ultrasound.wav");

    soundCutting = loadSound("sounds/cutting.wav");

    soundHealingOn = loadSound("sounds/healingOn.wav");

​

    soundFail = loadSound("sounds/fail.wav");

​

  //// ICONS ////

    //tools

    toolList = [

      iconGel = loadImage("tools/gel.png"), //0

      iconSyringe = loadImage("tools/syringe.png"), //1

      iconSuture = loadImage("tools/suture.png"), //2

      iconDrain = loadImage("tools/drain.png"), //3

      iconLaser = loadImage("tools/laser.png"), //4

      iconUltrasound = loadImage("tools/ultrasound.png"), //5

      iconScalpel = loadImage("tools/scalpel.png"), //6

      iconForceps = loadImage("tools/forceps.png"),//7

      iconStar = loadImage("tools/forceps.png"),//8

    ];

    //Tool Wheel

  for (i = 0; i < 10; i++) {

    toolWheel.push(loadImage("tools/wheel/toolwheel_"+i+".png"));

  }

  //// SPRITES ////

    //SmallCuts

    spriteSmallCut = loadImage('sprites/smallCuts/smallCut.png');

    //GelBlobs

    for (i = 1; i < 4; i++) {

      spritesGel.push(loadImage("sprites/gelBlobs/gel_"+i+".png"));

    }

    //Syringe & Serums

    for (i = 1; i < 3; i++) {

     spriteSyringes.push(loadImage("sprites/syringes/syringe_"+i+".png"));

    }

    spriteStabilizer = loadImage("sprites/serums/stabilizer_1.png");

    //SmallTumors

    spriteSmallTumor = loadImage("sprites/tumors/smallTumor_1.png");

​

}//End of Preload//

​

​

​

//////////////////////

/////// SETUP ////////

//////////////////////

​

function setup() {

​

​

 // cursor(CROSS);

  noCursor();

​

  canvas = createCanvas(960 , 720);

  frameRate(60);

  pixelDensity(1);

  angleMode(DEGREES);

  volumeSlider = createSlider(0.0,1.0,0.2,0.05);

  volumeSlider.parent('#volumeSlider');

  soundMusic.loop();

​

  //Initialize Cuts

  for (i = 0; i < numCutsStart; i++) {

    cuts.push(new cut(random(100,width-100),random(100,height-100),random(360))); // cut(x,y,angle,length)

  }

  //Initialize Small Cuts

  for (i = 0; i < numSmallCutsStart; i++) {

    smallCuts.push(new smallCut(random(50,width-50),random(50,height-50),random(360),random(20,80))); // smallcut(x,y,angle,length)

  }

  //Initialize Small Tumors

  for (i = 0; i < numSmallTumorsStart; i++) {

    smallTumors.push(new smallTumor(random(100,width-100),random(100,height-100),random(25,35)));

  }

  //Healing Touch ML5

    let options = {

      inputs: [128, 96, 4],

      task: "imageClassification",

    };

  shapeClassifier = ml5.neuralNetwork(options);

  const modelDetails = {

    model: 'ml5/healingTouch/model.json',

    metadata: 'ml5/healingTouch/model_meta.json',

    weights: 'ml5/healingTouch/model.weights.bin'

  }

  inputImage = createGraphics(128,96);

  shapeClassifier.load(modelDetails, modelLoaded);

  //Starting the Operation!

  soundStarting.play();

}//End of Setup//

​

​

//////////////////////

/////// DRAW  ////////

//////////////////////

​

function draw() {

  outputVolume(vol*log(volumeSlider.value()+1.0));

​

  //Healing Touch Judgement

  if (starCheck == 1 && starUse == 0){

    fill(255);

    rect(0,0,width,height);

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

      stroke(0);

      strokeWeight(16);

      line(starTraces[i][0],starTraces[i][1],starTraces[i][2],starTraces[i][3]);

    }

    classifyImage();

  }

 vitals += vitalsShift;

  vitals = constrain(vitals,0.0,99.9);

  vitalsShift = 0.0;

​

  if(mouseX < 0 || mouseX > width || mouseY < 0 || mouseY > height){

    active = 0;

  } else {

    active = 1;

  }

​

  //Fail Shakes

  if (failCounter > 0) {

    translate(

      random(-failCounter, failCounter),

      random(-failCounter, failCounter)

    );

    failCounter -= 0.5;

  }

  noStroke();

  background("rgb(211,85,154)");

  fill("rgb(254,167,189)");

  ellipse(width/2,height/2,width,height);

    fill("rgb(255,206,218)");

  ellipse(width/2,height/2,width*0.8,height*0.8);

​

  // Draw Cuts

​

  if(cuts.length > 0) {

    for(i = cuts.length-1; i>=0; i--){

      if(cuts[i].o < 0) {

        cuts.splice(i, 1);

      }

    }

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

      cuts[i].display();

     vitalsShift -= 0.002;

    }

  }

  //Draw Small Cuts

 if(smallCuts.length > 0){

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

      smallCuts[i].display();

      vitalsShift -= 0.0005;

    }

  }

  //Draw Small Tumors

  if(smallTumors.length > 0){

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

      smallTumors[i].display();

      vitalsShift -= 0.0005;

    }

  }

​

  //Draw Gelblobs

  if (mouseIsPressed && toolIndex === 0 && active == 1){

    gelBlobs.push(new gelBlob(mouseX,mouseY));

  }

  for (i = gelBlobs.length-1; i >= 0; i--){

    gelBlobs[i].update();

    gelBlobs[i].display();

        vitalsShift += 0.0008;

    if (gelBlobs[i].dead()) {

      gelBlobs.splice(i,1);

    }

  }

   if (toolIndex === 0) {

    let smallCutIntersections = {}; //Empty object to hold # of gelBlob intersections on each small cut index

    for (let smallCut in smallCuts) {

      for (let gelBlob of gelBlobs) {

        if (smallCutIntersections[smallCut] === undefined ) {

          smallCutIntersections[smallCut] = 0;

        }

        smallCutIntersections[smallCut] += gelBlob.intersects(smallCuts[smallCut]) && smallCuts[smallCut].o === 255 ? 1 : 0;

      }

    }

​

    let listOfAllSmallCutIntersections = Object.values(smallCutIntersections);

    let removeSmallCutIndex = listOfAllSmallCutIntersections.indexOf(max(listOfAllSmallCutIntersections));

    if (max(listOfAllSmallCutIntersections) > 0 ) {

      soundSmallSuccess.play();

      smallCuts[removeSmallCutIndex].fade();  //If intersection threshold met, clears the relavent small cut

    }

  }

  if(smallCuts.length > 0) {

    for(i = smallCuts.length-1; i>=0; i--){

      if(smallCuts[i].o < 0) {

        smallCuts.splice(i, 1);

      }

    }

  }

​

  //Draw Sutures

​

  if (sutures.length > 0) {

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

      sutures[i].display();

    }

  }

​

​

  //Suture Velocity Detection

  if (mouseIsPressed && [2,6,8].indexOf(toolIndex)!=-1 && active == 1) {

   // angleMode(degrees);

    let velX = createVector(pmouseX, pmouseY); //movedX

    let velY = createVector(mouseX, mouseY);

    let cursorVel = p5.Vector.sub(velY, p1).mag();

    heading1 = (p5.Vector.sub(velY, velX).heading()+180)/360+1;

    if(heading2 != undefined){

      let headingDifference = ((heading1-heading2)%1);

      fill(255);

      if(headingDifference > headingTolerance && headingDifference < (1-headingTolerance) && cursorVel > 20){

        velChange();

      }

    }

    let velCP = velX.cross(velY).z;

    if (abs(velCP) > 0) {

      stroke("blue");

    } else {

      stroke(0);

    }

​

    //Suture, Scalpel and Healing Touch Guide line

    if(toolIndex == 8){

      strokeWeight(4);

    } else {

    strokeWeight(2);

    }

    line(p1[0], p1[1], mouseX, mouseY);

    heading2 = heading1-1;

  }

​

  //Ultrasound

    for(i = ultrasoundPings.length -1; i>=0; i--) {

      ultrasoundPings[i].update();

      ultrasoundPings[i].display();

      if (ultrasoundPings[i].dead()){

        ultrasoundPings.splice(i,1);

      }

    }

  //Laser

  if (mouseIsPressed && toolIndex === 4 && active == 1) {

    vitalsShift += -0.001;

    let workingLaser = new laser(mouseX,mouseY);

    let smallTumorIntersections = {}; //Empty object to hold # of gelBlob intersections on each small cut index

    for (let smallTumor in smallTumors) {

        if (smallTumorIntersections[smallTumor] === undefined ) {

          smallTumorIntersections[smallTumor] = 0;

        }

        smallTumorIntersections[smallTumor] += workingLaser.intersects(smallTumors[smallTumor]) && smallTumors[smallTumor].o === 255 ? 1 : 0;

    }

​

    let listOfAllSmallTumorIntersections = Object.values(smallTumorIntersections);

    let removeSmallTumorIndex = listOfAllSmallTumorIntersections.indexOf(max(listOfAllSmallTumorIntersections));

    if (max(listOfAllSmallTumorIntersections) > 0 ) {

      soundSmallSuccess.play();

      smallTumors[removeSmallTumorIndex].fade();  //If intersection threshold met, clears the relavent small cut

      smallCuts.push(new smallCut(smallTumors[removeSmallTumorIndex].px-15,smallTumors[removeSmallTumorIndex].py,90,20));

      vitalsShift += -0.3;

    }

  }

  if(smallTumors.length > 0) {

    for(i = smallTumors.length-1; i>=0; i--){

      if(smallTumors[i].o < 0) {

        smallTumors.splice(i, 1);

      }

    }

  }

    //Syringe

  if (toolIndex === 1 && active == 1) {

    let serumProps = [width-300,height-150,90];

    imageMode(CORNER);

    tint(255,255);

    image(spriteStabilizer,serumProps[0],serumProps[1],serumProps[2],serumProps[2]);

    if(syringePx > serumProps[0] + 10 && syringePx < serumProps[0] + serumProps[2] - 10 && syringePy > serumProps[1] + 10 && syringePy < serumProps[1] + serumProps[2] - 10 && mouseIsPressed) {

      currentSyringe[0].px = serumProps[0]+serumProps[2]/2;

      currentSyringe[0].py = serumProps[1]+20;

      currentSyringe[0].fill();

      currentSyringe[0].display();

    } else {    

      if(currentSyringe.length == 1 && mouseIsPressed){

​

        if(currentSyringe[0].fillAmount > 0){

          vitalsShift += 0.24;

          currentSyringe[0].empty();

          currentSyringe[0].display();

        }

​

        if (currentSyringe[0].fillAmount == 0) {

          currentSyringe = [];

        }

      }

    }

  }

  //Healing Touch Overlay ⭐

  if (toolIndex === 8) {

    fill("rgba(0,169,255,0.41)");

    rect(0,0,width,height);

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

      stroke(255);

      strokeWeight(0.5);

      line(starTraces[i][0],starTraces[i][1],starTraces[i][2],starTraces[i][3]);

    }

  }

  //Tool Wheel

  imageMode(CENTER);

  let toolWheelX = 120;

  let toolWheelY = height-120;

  let toolWheelO = map(dist(toolWheelX,toolWheelY,mouseX,mouseY),100,150,70,200,true); //Lower tool wheel opacity when cursor is near

  tint(255, toolWheelO);

  image(toolWheel[toolIndex],toolWheelX,toolWheelY,250,250);

  // tint(255, 200);

​

  //Vitals

  let vitalsFill;

  if(vitalsShift > 0){

    vitalsFill = "rgb(0,255,0)"; //Green if Healing

  } else if (vitalsShift == 0) {

    vitalsFill = "cyan"; //Cyan if Stable

  } else {

    vitalsFill = 255; //White if moving

  }

  fill(vitalsFill);

  stroke(0);

  strokeWeight(3);

  textSize(50);

  textFont('B612 Mono');

  text(("💟"+floor(vitals))+"%",5,55);

  //Cursor Image

  tint(255, 126);

  new pointer(mouseX,mouseY).display();

  imageMode(CENTER);

  if(toolIndex < 8){

    image(toolList[toolIndex], mouseX + 25, mouseY, 50, 50);

  }  

} //End of Draw//

​

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

​

//////////////////////

//// Interactions ////

//////////////////////

​

////Mouse Click Interactions////

function mousePressed() {

  //Gel

  if (toolIndex === 0 && active == 1) {

    soundGel.loop();

  }

  //Syringe

    if(toolIndex === 1) {

      syringePx = mouseX;

      syringePy = mouseY;

      if(currentSyringe.length == 0) {

      currentSyringe.push(new syringe());

      }

        currentSyringe[0].px = syringePx;

        currentSyringe[0].py = syringePy;

    }

    if(toolIndex !== 1){

      currentSyringe = [];

    }

  //Sutures

  if (toolIndex === 2) {

    p1 = [mouseX, mouseY];

  }

  //Laser

  if (toolIndex === 4 && active == 1) {

    soundLaser.loop();

  }

  //Ultrasound

  if (toolIndex === 5 && active == 1) {

    soundUltra.play();

    ultrasoundPings.push(new ultrasoundPing(mouseX,mouseY));

​

    //////TEST/////

    smallTumors.push(new smallTumor(mouseX,mouseY));

  }

​

  //Scalpel

  if (toolIndex === 6) {

    p1 = [mouseX, mouseY];

    soundCutting.loop();

  }

  //Healing Touch

  if (toolIndex === 8) {

    p1 = [mouseX, mouseY];

  }  

​

}

​

////Mouse Release Interactions////

function mouseReleased() {

  //Gel

  if (toolIndex === 0){

    soundGel.stop();    

  }

  //Sutures

  if (toolIndex === 2) {

    p2 = [mouseX, mouseY];

    sutures.push(new suture(p1, p2));

    let cutIntersections = {}; //Empty object to hold # of suture intersections on each cut index

    for (let cut in cuts) {

      for (let suture of sutures) {

        if (cutIntersections[cut] === undefined) {

          cutIntersections[cut] = 0;

        }

        cutIntersections[cut] += suture.intersects(cuts[cut]) && cuts[cut].o === 255 ? 1 : 0;

      }

    }

​

    let listOfAllCutIntersections = Object.values(cutIntersections);

    let removeCutIndex = listOfAllCutIntersections.indexOf(max(listOfAllCutIntersections));

​

    sutures = []; // clear sutures when done drawing

​

​

    if (max(listOfAllCutIntersections) > 3) {

      soundBigSuccess.play();

      vitalsShift += -0.5;

      cuts[removeCutIndex].fade();     //If intersection threshold met, clears the relavent cut

    } else {

      failedAction();                  //If intersection threshold NOT met, notify fail

      vitalsShift += -1.0;

    }

  }

​

  //Laser

  if (toolIndex === 4){

    soundLaser.stop();    

  }

  //Scalpel

  if (toolIndex === 6 && active == 1) {

    p2 = [mouseX, mouseY];

    let cutVector = createVector(p2[0]-p1[0],p2[1]-p1[1]);

    let cutLength = dist(p1[0],p1[1],p2[0],p2[1]);

    if(cutLength >= 100) {

      cuts.push(new cut(p1[0],p1[1],cutVector.heading()+90,constrain(cutLength,150,500)));

      vitalsShift += -3.0;

    }

    if(cutLength <= 100) {

      smallCuts.push(new smallCut(p1[0],p1[1],cutVector.heading()+90,constrain(cutLength,20,75)));

      vitalsShift += -2.0;

    }

    failedAction();

  } soundCutting.stop();

  //Healing Touch

  if (toolIndex === 8) {

    p2 = [mouseX, mouseY];

    starTraces.push([p1[0],p1[1],p2[0],p2[1]]);

    soundStitch.play();

    starCheck = true;

    }

}

​

//// Mouse Velocity Change Interactions ////

function velChange() {

  //Sutures

  if (toolIndex === 2) {

    p2 = [mouseX, mouseY];

    sutures.push(new suture(p1, p2));

​

    soundStitch.play();

    p1 = p2;

  }

  //Healing Touch

  if (toolIndex === 8) {

    p2 = [mouseX, mouseY];

    starTraces.push([p1[0],p1[1],p2[0],p2[1]]);

    soundStitch.play();

    p1 = p2;

  }

}

​

//// Keyboard Interactions ////

function keyTyped() {

  //// Tools ////

  if(keyCode !== SHIFT){

    if (key == 1 && mouseIsPressed != true) {

      toolIndex--;

    } else if (key == 2 && mouseIsPressed != true) {

      toolIndex++;

    }

​

    if (toolIndex < 0) {

      toolIndex = 7;

    } else if (toolIndex > 7) {

      toolIndex = 0;

    }

  }

}

​

function keyPressed() {

  //Tool Wheel

  if(keyCode !== SHIFT && mouseIsPressed != true && toolKeys.reduce(function(a, b) {return a + b; }, 0)<2) {

    if(key.toLowerCase() == 'w' || keyCode === UP_ARROW) {toolKeys[0] = 1; toolKeys[2] = 0;}

    if(key.toLowerCase() == 'a' || keyCode === LEFT_ARROW) {toolKeys[1] = 1; toolKeys[3] = 0;}

    if(key.toLowerCase() == 's' || keyCode === DOWN_ARROW) {toolKeys[2] = 1; toolKeys[0] = 0;}

    if(key.toLowerCase() == 'd' || keyCode === RIGHT_ARROW) {toolKeys[3] = 1; toolKeys[1] = 0;}

  }

  switch(("000" + toolKeys.join('')).slice (-4)) {

    case '1000': toolIndex = 0;

      break;

    case '1001': toolIndex = 1;

      break;

    case '0001': toolIndex = 2;

      break;

    case '0011': toolIndex = 3;

      break;

    case '0010': toolIndex = 4;

      break;

    case '0110': toolIndex = 5;

      break;

    case '0100': toolIndex = 6;

      break;

    case '1100': toolIndex = 7;

      break;

  }

  //Healing Touch  

  if(keyCode === SHIFT){

    //HealingTouch

    if(starUse == 0){

    toolTemp = toolIndex;

    toolIndex = 8;

    starTraces = [];

    } else {

      print("Healing Touch already used this operation.")

      soundFail.play();

    }

  }

}

​

​

function keyReleased() {

  //Tool Wheel

    if(keyCode !== SHIFT) {

    if(key.toLowerCase() == 'w' || keyCode === UP_ARROW) {toolKeys[0] = 0;}

    if(key.toLowerCase() == 'a' || keyCode === LEFT_ARROW) {toolKeys[1] = 0;}

    if(key.toLowerCase() == 's' || keyCode === DOWN_ARROW) {toolKeys[2] = 0;}

    if(key.toLowerCase() == 'd' || keyCode === RIGHT_ARROW) {toolKeys[3] = 0;}

  }

  //Healing Touch

  if (keyCode === SHIFT && !mouseIsPressed && active) {

    toolIndex = toolTemp;

  }

}

​

//// FAILED COMMANDS ////

function failedAction() {

  soundFail.play();

  failCounter = 5;

}

​

​

//// ML5 Functions

function modelLoaded() {

  console.log('Healing Touch Prepared!');

}

​

function classifyImage() {

  inputImage = createGraphics(128,96);

  inputImage.copy(canvas, 0, 0, width, height, 0,0,128,96);

  shapeClassifier.classify({image: inputImage}, gotResults)