//PROGRAMM WITHOUT NAME 0.456 BETA by Kim Asendorf 2007//
/////////////////////////////////////////////////////////


//pixelLimit
int pixelLimit = 50;


//hauptfarben
int frontFarbe = 0;
color vorneColor = color(frontFarbe);
color hintenColor = color(255);


//speed
int speed = 100;


// ---------------------------------------- SETUP >>>>>>>>>>>>>>>>>>

void setup() {
  size(800, 600);
  smooth();
  frameRate(12);
  PFont fontKB = loadFont("ITCFranklinGothicStd-Book-10.vlw");
  textFont(fontKB, 10);
  gui();
}

// ---------------------------------------- SETUP <<<<<<<<<<<<<<<<<<


//grafical user interface
void gui() {
  background(hintenColor);
  stroke(vorneColor);
  fill(hintenColor);
  rect(0, 0, 799, 449);
  fill(vorneColor);
  rect(0, 450, 799, 20);
  kaubonschen();
  beschreibung();
  menus();
  btns();
}


//schrift
void kaubonschen() {
  noStroke();
  fill(vorneColor);
  text("kaubonschen.com 2007", 696, 598);
}


//btn text
void beschreibung() {
  fill(hintenColor);
  text("FX", 5, 465);
  text("RESET", 745, 465);
  text("DRAW", 690, 465);
  delayAnzeige();
  text("Save COLOR", 400, 465);
}


//fps-delay-anzeige
void delayAnzeige() {
  noStroke();
  fill(vorneColor);
  rect(611, 454, 55, 12);
  fill(hintenColor);
  text("SPEED "+ speed, 610, 465);
}





///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
//Buttons// //Buttons// //Buttons// //Buttons// //Buttons//

//btn variablen
//Buttons insgesamt
int tb = 16;

//mouse over speicher
boolean[] overBtn = new boolean[tb];

//mouse press speicher
boolean[] pressBtn = new boolean[tb];

//btn size
int btnSize = 10;

//btn farben
color btnColor1 = hintenColor;
color btnColor2 = color(127);
color btnColor3 = color(191);
color btnColor4 = color(63);


// --- --- --- --- --- --- --- --- btn koordinaten arrays
// FX Randomizer
int btnRandomX = 20;
int btnRandomY = 455;
int btnRandomNr = 0;

// FX Rotation
int btnRotateX = 35;
int btnRotateY = 455;
int btnRotateNr = 1;

// RESET
int btnResetX = 780;
int btnResetY = 455;
int btnResetNr = 2;

// DRAW
int btnDrawX = 723;
int btnDrawY = 455;
int btnDrawNr = 3;

// SPEED/Delay
int btnSpeedX = 667;
int btnSpeedY = 455;
int btnSpeedNr = 4;

//UMs
// Randomizer - Xmax - rechts
int btnXmaxX = 5;
int btnXmaxY = 490;
int btnXmaxNr = 5;

// Randomizer - Xmin - links
int btnXminX = 5;
int btnXminY = 502;
int btnXminNr = 6;

// Randomizer - Ymax - unten
int btnYmaxX = 5;
int btnYmaxY = 514;
int btnYmaxNr = 7;

// Randomizer - Ymin - oben
int btnYminX = 5;
int btnYminY = 526;
int btnYminNr = 8;

// Rotation - takt
int btnKTaktX = 86;
int btnKTaktY = 490;
int btnKTaktNr = 9;

// Rotation - Geschwindigkeit
int btnKSpeedX = 86;
int btnKSpeedY = 502;
int btnKSpeedNr = 10;

// Rotation - Hšhe
int btnKHoeheX = 86;
int btnKHoeheY = 514;
int btnKHoeheNr = 11;

// Rotation - Hšhe
int btnKBreiteX = 86;
int btnKBreiteY = 526;
int btnKBreiteNr = 12;


//pingpong
int btnPingPongX = 50;
int btnPingPongY = 455;
int btnPingPongNr = 13;

//antimouse
int btnAntimouseX = 65;
int btnAntimouseY = 455;
int btnAntimouseNr = 14;


//saveColor
int btnSaveColorX = 385;
int btnSaveColorY = 455;
int btnSaveColorNr = 15;


//class btn Buttons
// (X, Y, btnNr)
Btn Btn0 = new Btn(btnRandomX, btnRandomY, btnRandomNr);
Btn Btn1 = new Btn(btnRotateX, btnRotateY, btnRotateNr);
Btn Btn2 = new Btn(btnResetX, btnResetY, btnResetNr);
Btn Btn3 = new Btn(btnDrawX, btnDrawY, btnDrawNr);
Btn Btn4 = new Btn(btnSpeedX, btnSpeedY, btnSpeedNr);

Btn Btn5 = new Btn(btnXmaxX, btnXmaxY, btnXmaxNr);
Btn Btn6 = new Btn(btnXminX, btnXminY, btnXminNr);
Btn Btn7 = new Btn(btnYmaxX, btnYmaxY, btnYmaxNr);
Btn Btn8 = new Btn(btnYminX, btnYminY, btnYminNr);

Btn Btn9 = new Btn(btnKTaktX, btnKTaktY, btnKTaktNr);
Btn Btn10 = new Btn(btnKSpeedX, btnKSpeedY, btnKSpeedNr);
Btn Btn11 = new Btn(btnKHoeheX, btnKHoeheY, btnKHoeheNr);
Btn Btn12 = new Btn(btnKBreiteX, btnKBreiteY, btnKBreiteNr);

Btn Btn13 = new Btn(btnPingPongX, btnPingPongY, btnPingPongNr);

Btn Btn14 = new Btn(btnAntimouseX, btnAntimouseY, btnAntimouseNr);

Btn Btn15 = new Btn(btnSaveColorX, btnSaveColorY, btnSaveColorNr);

///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
// btn form
///////////////////////////////////////////////////////////////////////////////////////////////////
// Klasse Schalter
class Schalter {
  int xpos, ypos, btnNr;
}

//BTN
class Btn extends Schalter {
  Btn(int x, int y, int nr) {
    xpos = x;
    ypos = y;
    btnNr = nr;
  }
  void display() {
    noStroke();
    rect(xpos, ypos, btnSize, btnSize);
  }
  void update(int x, int y) {
    if (updateBtn(xpos, ypos, btnSize, btnSize)) {
      overBtn[btnNr] = true;
    } 
    else {
      overBtn[btnNr] = false;
    }
  }
  void rollOver() {
    fill(btnColor1);
    display();
    if ((overBtn[btnNr] == true)&&(mousePressed == true)) {
      fill(btnColor2);
      display();
      if (mouseButton == LEFT) {
        pressBtn[btnNr] = true;
      }
      if (mouseButton == RIGHT) {
        pressBtn[btnNr] = false;
      }
    }
    if (overBtn[btnNr] == true) {
      fill(btnColor3);
      display();
    }
    if (pressBtn[btnNr] == true) {
      fill(btnColor4);
      display();
    }
  }
}


//position updater
boolean updateBtn(int x, int y, int width, int height) {
  if (mouseX >= x && mouseX <= x+width && mouseY >= y && mouseY <= y+height) {
    return true;
  } 
  else {
    return false;
  }
}

void update(int x, int y) {
  Btn0.update(mouseX, mouseY);
  Btn1.update(mouseX, mouseY);
  Btn2.update(mouseX, mouseY);
  Btn3.update(mouseX, mouseY);
  Btn4.update(mouseX, mouseY);
  Btn5.update(mouseX, mouseY);
  Btn6.update(mouseX, mouseY);
  Btn7.update(mouseX, mouseY);
  Btn8.update(mouseX, mouseY);
  Btn9.update(mouseX, mouseY);
  Btn10.update(mouseX, mouseY);
  Btn11.update(mouseX, mouseY);
  Btn12.update(mouseX, mouseY);
  Btn13.update(mouseX, mouseY);
  Btn14.update(mouseX, mouseY);
  Btn15.update(mouseX, mouseY);
}

//start buttons
void btns() {
  Btn0.rollOver();
  Btn1.rollOver();
  Btn2.rollOver();
  Btn3.rollOver();
  Btn4.rollOver();
  Btn5.rollOver();
  Btn6.rollOver();
  Btn7.rollOver();
  Btn8.rollOver();
  Btn9.rollOver();
  Btn10.rollOver();
  Btn11.rollOver();
  Btn12.rollOver();
  Btn13.rollOver();
  Btn14.rollOver();
  Btn15.rollOver();
}

///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
//btn press
void btnPress() {
  startZucker();
  startKreis();
  startPingpong();
  startAntimouse();
  startReset();
  startFps();
  startRandomRight();
  startRandomLeft();
  startRandomDown();
  startRandomUp();
  startRotateTakt();
  startRotateSpeed();
  startRotateHoehe();
  startRotateBreite();
  startSaveColor();
}


//start zucker
void startZucker() {
  if (pressBtn[btnRandomNr] == true) {
    zucker();
    Mrechteck();
    letzterWert();
    anfang();
  }
}


//start kreis
void startKreis() {
  if (pressBtn[btnRotateNr] == true) {
    kreis();
    Mrechteck();
    letzterWert();
    anfang();
  }
}


//start pingpong
void startPingpong() {
  if (pressBtn[btnPingPongNr] == true) {
    pingpong();
    Mrechteck();
    letzterWert();
    anfang();
  }
}


//start antimouse
void startAntimouse() {
  if (pressBtn[btnAntimouseNr] == true) {
    mouseTest();
    if (mouseInside == true) {
      antimouse();
      Mrechteck();
      letzterWert();
      anfang();
    }
  }
}


//start SAVE COLOR
void startSaveColor() {
  if (pressBtn[btnSaveColorNr] == true) {
    saveColor = true;
  }
  else {
    saveColor = false;
  }
}


// RESET RESET RESET RESET RESET RESET RESET RESET RESET RESET RESET
void startReset() {
  if (pressBtn[btnResetNr] == true) {
    gui();
    pressBtn[btnRandomNr] = false;
    pressBtn[btnRotateNr] = false;
    mp = 0;
    rechteckAltX = 0;
    rechteckAltY = 0;
    pressBtn[btnResetNr] = false;
    pressBtn[btnDrawNr] = false;
    zuckerReset();
    kreisReset();
  }
}


//zeichnen
void zeichnen() {
  if(pressBtn[btnDrawNr] == false) {
    gui();
  } 
}


//FPS Šnderung STARTEN
void startFps() {
  if ((overBtn[btnSpeedNr] == true)&&(mousePressed == true)&&(mouseButton == LEFT)) {
    if (speed < 100) {
      speed = speed + 1;
    }
    pressBtn[btnSpeedNr] = false;
  }
  if ((overBtn[btnSpeedNr] == true)&&(mousePressed == true)&&(mouseButton == RIGHT)) {
    if (speed > 1) {
      speed = speed - 1;
    }
    pressBtn[btnSpeedNr] = false;
  }
}


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


////UNTERMEN†//UNTERMEN†//UNTERMEN†//UNTERMEN†//UNTERMEN†//UNTERMEN†//UNTERMEN†//UNTERMEN†//UNTERME >
//N†//UNTERMEN†//UNTERMEN†//UNTERMEN†//UNTERMEN†//UNTERMEN†//UNTERMEN†//UNTERMEN†//UNTERMEN†//UNTER >
//MEN†//UNTERMEN†//UNTERMEN†//UNTERMEN†//UNTERMEN†//UNTERMEN†//UNTERMEN†MEN†//UNTERMEN†//UNTERMEN†/ >




//Random
//Right
void startRandomRight() {
  if ((overBtn[btnXmaxNr] == true)&&(mousePressed == true)&&(mouseButton == LEFT)) {
    if (grossX < 100) {
      grossX = grossX + 1;
    }
    pressBtn[btnXmaxNr] = false;
  }
  if ((overBtn[btnXmaxNr] == true)&&(mousePressed == true)&&(mouseButton == RIGHT)) {
    if (grossX > 0) {
      grossX = grossX - 1;
    }
    pressBtn[btnXmaxNr] = false;
  }
}

//left
void startRandomLeft() {
  if ((overBtn[btnXminNr] == true)&&(mousePressed == true)&&(mouseButton == LEFT)) {
    if (kleinX > -100) {
      kleinX = kleinX - 1;
    }
    pressBtn[btnXminNr] = false;
  }
  if ((overBtn[btnXminNr] == true)&&(mousePressed == true)&&(mouseButton == RIGHT)) {
    if (kleinX < 0) {
      kleinX = kleinX + 1;
    }
    pressBtn[btnXminNr] = false;
  }
}

//Down
void startRandomDown() {
  if ((overBtn[btnYmaxNr] == true)&&(mousePressed == true)&&(mouseButton == LEFT)) {
    if (grossY < 100) {
      grossY = grossY + 1;
    }
    pressBtn[btnYmaxNr] = false;
  }
  if ((overBtn[btnYmaxNr] == true)&&(mousePressed == true)&&(mouseButton == RIGHT)) {
    if (grossY > 0) {
      grossY = grossY - 1;
    }
    pressBtn[btnYmaxNr] = false;
  }
}

//Up
void startRandomUp() {
  if ((overBtn[btnYminNr] == true)&&(mousePressed == true)&&(mouseButton == LEFT)) {
    if (kleinY > -100) {
      kleinY = kleinY - 1;
    }
    pressBtn[btnYminNr] = false;
  }
  if ((overBtn[btnYminNr] == true)&&(mousePressed == true)&&(mouseButton == RIGHT)) {
    if (kleinY < 0) {
      kleinY = kleinY + 1;
    }
    pressBtn[btnYminNr] = false;
  }
}



//Rotation
//Takt
void startRotateTakt() {
  if ((overBtn[btnKTaktNr] == true)&&(mousePressed == true)&&(mouseButton == LEFT)) {
    if (KTakt < 100) {
      KTakt = KTakt + 1;
    }
    pressBtn[btnKTaktNr] = false;
  }
  if ((overBtn[btnKTaktNr] == true)&&(mousePressed == true)&&(mouseButton == RIGHT)) {
    if (KTakt > -100) {
      KTakt = KTakt - 1;
    }
    pressBtn[btnKTaktNr] = false;
  }
}

//Richtung/Speed
void startRotateSpeed() {
  if ((overBtn[btnKSpeedNr] == true)&&(mousePressed == true)&&(mouseButton == LEFT)) {
    if (KGeschwindigkeit < 10) {
      KGeschwindigkeit = KGeschwindigkeit + 0.01;
    }
    pressBtn[btnKSpeedNr] = false;
  }
  if ((overBtn[btnKSpeedNr] == true)&&(mousePressed == true)&&(mouseButton == RIGHT)) {
    if (KGeschwindigkeit > -10) {
      KGeschwindigkeit = KGeschwindigkeit - 0.01;
    }
    pressBtn[btnKSpeedNr] = false;
  }
}

//hšhe
void startRotateHoehe() {
  if ((overBtn[btnKHoeheNr] == true)&&(mousePressed == true)&&(mouseButton == LEFT)) {
    if (KRadiusHoehe < 100) {
      KRadiusHoehe = KRadiusHoehe + 1;
    }
    pressBtn[btnKHoeheNr] = false;
  }
  if ((overBtn[btnKHoeheNr] == true)&&(mousePressed == true)&&(mouseButton == RIGHT)) {
    if (KRadiusHoehe > -100) {
      KRadiusHoehe = KRadiusHoehe - 1;
    }
    pressBtn[btnKHoeheNr] = false;
  }
}

//breite
void startRotateBreite() {
  if ((overBtn[btnKBreiteNr] == true)&&(mousePressed == true)&&(mouseButton == LEFT)) {
    if (KRadiusBreite < 100) {
      KRadiusBreite = KRadiusBreite + 1;
    }
    pressBtn[btnKBreiteNr] = false;
  }
  if ((overBtn[btnKBreiteNr] == true)&&(mousePressed == true)&&(mouseButton == RIGHT)) {
    if (KRadiusBreite > -100) {
      KRadiusBreite = KRadiusBreite + 1;
    }
    pressBtn[btnKBreiteNr] = false;
  }
}


//MEN†S starten
void menus() {
  menuRandom();
  menuKreis();
  menuFarben();
}



//GUI RANDOM
void menuRandom() {
  noStroke();
  fill(vorneColor);
  rect(0, 472, 80, 70);
  fill(hintenColor);
  text("RANDOMIZER", 5, 485);
  text("Xmax = "+ grossX, 20, 499);
  text("Xmin = "+ kleinX, 20, 511);
  text("Ymax = "+ grossY, 20, 523);
  text("Ymin = "+ kleinY, 20, 535);
}



//GUI KREIS
void menuKreis() {
  noStroke();
  fill(vorneColor);
  rect(81, 472, 80, 70);
  fill(hintenColor);
  text("ROTATION", 86, 485);
  KRhythm = round(KTakt);
  text("rhythm = "+ KRhythm, 101, 499);
  KDirection = round(KGeschwindigkeit*100);
  text("direction = "+ KDirection, 101, 511);
  text("hight = "+ KRadiusHoehe, 101, 523);
  text("width = "+ KRadiusBreite, 101, 535);
}


//GUI FARBEN
void menuFarben() {
  noStroke();
  fill(vorneColor);
  rect(200, 472, 230, 70);
  fill(hintenColor);
  text("COLOR (up/down)", 202, 485);
  text("red (q/w) = "+ rotVorne, 202, 499);
  text("green (a/s) = "+ grunVorne, 202, 511);
  text("blue (y/x) = "+ blauVorne, 202, 523);
  text("alpha (1/2) = "+ transVorne, 202, 535);
}


////UNTERMEN†//UNTERMEN†//UNTERMEN†//UNTERMEN†//UNTERMEN†//UNTERMEN†//UNTERMEN†//UNTERMEN†//UNTERME <
//N†//UNTERMEN†//UNTERMEN†//UNTERMEN†//UNTERMEN†//UNTERMEN†//UNTERMEN†//UNTERMEN†//UNTERMEN†//UNTER <
//MEN†//UNTERMEN†//UNTERMEN†//UNTERMEN†//UNTERMEN†//UNTERMEN†//UNTERMEN†MEN†//UNTERMEN†//UNTERMEN†/ <


//variablen
int rechteckX;
int rechteckY;
int rechteckAltX = 0;
int rechteckAltY = 0;


//variablen speicher
//neu
int[] rX = new int[pixelLimit+1];
int[] rY = new int[pixelLimit+1];

int aktuellX, aktuellY;


//variablen randomizer
//neu
int[] rXneu = new int[pixelLimit+1];
int[] rYneu = new int[pixelLimit+1];



//variable mouse clicks
int mp = 0;



//farben speicher
int[] rotRect = new int[pixelLimit+1];
int[] grunRect = new int[pixelLimit+1];
int[] blauRect = new int[pixelLimit+1];
int[] transRect = new int[pixelLimit+1];



//form
//--rechteck per mouse
void rechteck() {
  stroke(drawColor);
  line(rechteckAltX, rechteckAltY, rechteckX, rechteckY);
  noStroke();
  fill(drawColor);
  rect(rechteckX, rechteckY, 20, 10);
}



///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
//aktuelle position als anfang setzen

//neu
void anfang() {
  for (int i = mp; i >= 0; i = i-1) {
    rX[i] = rXneu[i];
    rY[i] = rYneu[i];
    rechteckAltX = aktuellX;
    rechteckAltY = aktuellY;
  }
}




//letzten wert ermitteln

//NEU mit for schleife
void letzterWert() {
  if (mp > 0) {
    aktuellX = rXneu[mp-1];
    aktuellY = rYneu[mp-1];
  }
}





///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
boolean saveColor = false;


//redraw!! NEU mit for schleife
void Mrechteck() {
  zeichnen();
  grenzen();
  for (int i = mp-1; i >= 0; i = i-1) {
    if (saveColor == true) {
      stroke(rotRect[i], grunRect[i], blauRect[i], transRect[i]);
    }
    else {
      stroke(vorneColor);
    }
    if (i == 0) {
      line(0, 0, rXneu[i], rYneu[i]);
    } 
    else {
      line(rXneu[i-1], rYneu[i-1], rXneu[i], rYneu[i]);
    }
    noStroke();
    if (saveColor == true) {
      fill(rotRect[i], grunRect[i], blauRect[i], transRect[i]);
    }
    else {
      fill(drawColor);
    }
    rect(rXneu[i], rYneu[i], 20, 10);
  }
}





///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
//werte speichern

//SPEICHERN NEU mit for schleife
void speichern() {
  if ((mousePressed == true)&&(mp < pixelLimit)) {
    rX[mp] = mouseX;
    rY[mp] = mouseY;
    rXneu[mp] = mouseX;
    rYneu[mp] = mouseY;
    rotRect[mp] = rotVorne;
    grunRect[mp] = grunVorne;
    blauRect[mp] = blauVorne;
    transRect[mp] = transVorne;
  }
}



//rechteck per klick
void klick() {
  if ((mousePressed == true)&&(mp < pixelLimit)&&(mouseY <= 438)&&(mouseY >= 2)&&(mouseX <= 778)&&(mouseX >= 2)) {
    rechteckX = mouseX;
    rechteckY = mouseY;
    rechteck();
    rechteckAltX = rechteckX;
    rechteckAltY = rechteckY;
    mp = mp + 1;
  }
}



///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
//variablen transformieren
///////////////////////////////////////////////////////////////////////////////////////////////////
//zucker (Randomizer)
//spannweite
int kleinX = -10;
int grossX = 10;
int kleinY = -10;
int grossY = 10;


//variablen RESET
void zuckerReset() {
  kleinX = -10;
  grossX = 10;
  kleinY = -10;
  grossY = 10;
}



//DER ZUCKER NEU mit for schleife
void zucker() {
  for (int i = mp; i >= 0; i = i-1) {
    rXneu[i] = rX[i] + round(random(kleinX, grossX));
    rYneu[i] = rY[i] + round(random(kleinY, grossY));
  }
}



//kreis
//geschwindigkeit
float KTakt = 1;
float KGeschwindigkeit = 0.05;
float KRadiusHoehe = 3;
float KRadiusBreite = 3;
int KDirection;
int KRhythm;


//variablen RESET
void kreisReset() {
  KTakt = 1;
  KGeschwindigkeit = 0.05;
  KRadiusHoehe = 3;
  KRadiusBreite = 3;
}


//DER KREIS NEU mit for schleife
void kreis() {
  KTakt = KTakt + KGeschwindigkeit;
  for (int i = mp; i >= 0; i = i-1) {
    rXneu[i] = rX[i] + round(sin(KTakt)*KRadiusBreite);
    rYneu[i] = rY[i] + round(cos(KTakt)*KRadiusHoehe);
  }
}


//pingpong
int ppX = 2;
int ppY = 2;
boolean[] ppXabfrage = new boolean[pixelLimit+1];
boolean[] ppYabfrage = new boolean[pixelLimit+1];


void pingpong() {
  for (int i = mp; i >= 0; i = i-1) {
    if ((rXneu[i] < borderXmax)&&(ppXabfrage[i] == false)) {
      rXneu[i] = rX[i] + ppX;
    }
    if ((rXneu[i] > bordermin)&&(ppXabfrage[i] == true)) {
      rXneu[i] = rX[i] - ppX;
    }
    if (rXneu[i] == borderXmax) {
      ppXabfrage[i] = true;
    }
    if (rXneu[i] == bordermin) {
      ppXabfrage[i] = false;
    }
    if ((rYneu[i] < borderYmax)&&(ppYabfrage[i] == false)) {
      rYneu[i] = rY[i] + ppY;
    }
    if ((rYneu[i] > bordermin)&&(ppYabfrage[i] == true)) {
      rYneu[i] = rY[i] - ppY;
    }
    if (rYneu[i] == borderYmax) {
      ppYabfrage[i] = true;
    }
    if (rYneu[i] == bordermin) {
      ppYabfrage[i] = false;
    }
  }
}



//anti-mouse follow
int mouseRange = 70;
int mouseSprung = 3;

void antimouse() {
  for (int i = mp; i >= 0; i = i-1) {
    if ((mouseX < rX[i])&&(rX[i] - mouseX < mouseRange)&&(rY[i] - mouseY < mouseRange)&&(mouseY - rY[i] < mouseRange)) {
      rXneu[i] = rX[i] + mouseSprung;
    }
    if ((mouseX > rX[i])&&(mouseX - rX[i] < mouseRange)&&(rY[i] - mouseY < mouseRange)&&(mouseY - rY[i] < mouseRange)) {
      rXneu[i] = rX[i] - mouseSprung;
    }
    if ((mouseY < rY[i])&&(rY[i] - mouseY < mouseRange)&&(rX[i] - mouseX < mouseRange)&&(mouseX - rX[i] < mouseRange)) {
      rYneu[i] = rY[i] + mouseSprung;
    }
    if ((mouseY > rY[i])&&(mouseY - rY[i] < mouseRange)&&(rX[i] - mouseX < mouseRange)&&(mouseX - rX[i] < mouseRange)) {
      rYneu[i] = rY[i] - mouseSprung;
    }
  }
}



//mouse inside
boolean mouseInside;

void mouseTest() {
  if ((mouseX < 800)&&(mouseX > 0)&&(mouseY < 450)&&(mouseY > 0)) {
    mouseInside = true;
  }
  else {
    mouseInside = false;
  }
}


//GRENZEN mit for schleife
int borderXmax = 778;
int borderYmax = 438;
int bordermin = 2;


void grenzen() {
  for (int i = mp; i >= 0; i = i-1) {
    rXneu[i] = min(borderXmax, rXneu[i]);
    rXneu[i] = max(bordermin, rXneu[i]);
    rYneu[i] = min(borderYmax, rYneu[i]);
    rYneu[i] = max(bordermin, rYneu[i]);
  }
}



//farber keys
int rotVorne = frontFarbe;
int grunVorne = frontFarbe;
int blauVorne = frontFarbe;
int transVorne = 200;
color drawColor = color(rotVorne, grunVorne, blauVorne, transVorne);


int farbSprung = 5;


void farbe() {
  if(keyPressed) {
    if ((key == 'q')&&(rotVorne < 255)) {
      rotVorne = rotVorne + farbSprung;
    }
    if ((key == 'w')&&(rotVorne > 0)) {
      rotVorne = rotVorne - farbSprung;
    }
    if ((key == 'a')&&(grunVorne < 255)) {
      grunVorne = grunVorne + farbSprung;
    }
    if ((key == 's')&&(grunVorne > 0)) {
      grunVorne = grunVorne - farbSprung;
    }
    if ((key == 'y')&&(blauVorne < 255)) {
      blauVorne = blauVorne + farbSprung;
    }
    if ((key == 'x')&&(blauVorne > 0)) {
      blauVorne = blauVorne - farbSprung;
    }
    if ((key == '1')&&(transVorne < 255)) {
      transVorne = transVorne + farbSprung;
    }
    if ((key == '2')&&(transVorne > 0)) {
      transVorne = transVorne - farbSprung;
    }
    drawColor = color(rotVorne, grunVorne, blauVorne, transVorne);
  }
}


//test
void ausgabe() {
  println();
  //println(pressBtn[4]);
  //line(400, 0, 400, 450);
  //line(0, 225, 800, 225);
}



//DRAW HAUPTSCHLEIFE
void draw() {
  update(mouseX, mouseY);
  menus();
  btns();
  speichern();
  klick();
  btnPress();
  ausgabe();
  delayAnzeige();
  farbe();
}


//www.kaubonschen.com