

PImage iceFloe;


abstract class GameObjects {

  //Bewegungsvektoren

  PVector v ;
  PVector s ;

  //hier gibt es nun ein globalX das aber nur für die GameItems eine Rolle spielt
  //was sind GameItems? siehe unten nach IceBerg
  float globalX;

  //sizeX und sizeY sind für die größe der Bilder die wir laden
  //wird erst später festgelegt sobald ein Objekt erstellt wird uns sein Bild lädt
  float sizeX;
  float sizeY;
  //Eisberge kriegen eine ID um sie voneinander zu unterscheiden bei der Collision
  int id;

  GameWorld gameWorld;


  GameObjects(GameWorld _gameWorld, float x, float y) {

    s = new PVector(x, y);
    gameWorld = _gameWorld;
  }

  abstract void animate(float deltaTimeSeconds);
  abstract void collisionDetection(float deltaTimeSeconds);
  abstract void draw();
}





class IceBerg extends GameObjects {

  boolean mirrored=false;
  //Vector für die Bewegung mit der Spielwelt
  PVector shift = new PVector(gameWorld.xShift, 0.0);
  // shrinkValue wird im draw jeden Frame von sizeX und sizeY subtrahiert
  float shrinkValue;
  // growValue wird immer wenn eine Kolision stattfindet zu sizeX und sizeY addiert
  float growValue;
  //bewaffnet zeigt für jeden Eisberg an ob er bewaffnet ist oder nicht, bewaffnetTime speichert den Zeitpunkt, an dem ein Eisberg den Eispickel aufgesammelt hat
  //(benötigt für Zeitbegrenzung), maxBewaffnetTime ist die Zeit die der Eispickel aktiv bleibt
  boolean bewaffnet = false;
  //wird true sobald sie gecrasht sind
  boolean iceBergCrash = false;
  float bewaffnetTime =0.0;
  float maxBewaffnetTime = 5.0;
  float crashTime = 0;

  int minimalSize = 25;

  // ausgewählter Character
  int characterChoosed;

  int shrinkCollisionCount;

  //Für Lebensanzeige gesamte health und aktuelle health
  int health = 100;
  int actualHealth = 100;
  PImage character;
  PImage eyes;
  //Werte für Booster einsatz
  float normalDrag = 0.9;
  float boostedDrag = 0.96;
  float drag;
  boolean boosted = false;
  float boostedTime = 0.0;
  float maxBoostedTime = 5.0;
  int eyeLookupX;
  int eyeLookupY;

  float defaultSizeX;
  float defaultSizeY;

  PVector colliderCenter1 = new PVector(0, 0);
  PVector colliderCenter2 = new PVector(0, 0);


  IceBerg(GameWorld _gameWorld, float _x, float _y, int _id) {
    super(_gameWorld, _x, _y);
    v = new PVector(0.0, 0.0);
    id = _id;
    if (id == 1) {
      characterChoosed = currentCharacter1;
    } else {
      characterChoosed = currentCharacter2;
    }
    switch(characterChoosed) {
    case 1: 
      {
        character = character1;
        eyes = eyes1;
        break;
      }
    case 2: 
      {
        character = character2;
        eyes = eyes2;
        break;
      }
    case 3: 
      {
        character = character3;
        eyes = eyes3;
        break;
      }
    case 4: 
      {
        character = character4;
        eyes = eyes4;
        break;
      }
    }
    defaultSizeX = ScreenWidth/12.8;
    defaultSizeY = ScreenWidth/12.8;
    sizeX = defaultSizeX;
    sizeY = defaultSizeY;
    shrinkValue = 0.1;
    growValue = 4;
  }


  // für jeden Eisberg wird laufend geprüft, ob er mit etwas anderem kollidiert
  void collisionDetection(float deltaTimeSeconds) {
    shrinkValue=0.01;

    for (int i = 0; i < gameWorld.gameObjects.size(); i++) {
      // Collider von Items sind Kreise, nur Collider von Eisschollen sind Vierecksens
      float colliderRadius1;
      float colliderRadius2;
      float distanze;

      //zuerst wird geprüft ob mit einer Eissccholle kollidiert wird
      //Quelle für Kreis Rechteck Kollision im folgenden if clause: https://www.youtube.com/watch?v=Z5ykb5QtY-Y
      if (gameWorld.gameObjects.get(i) instanceof IceFloe) {
        float colliderRadiusBerg = sizeX*0.65/2; //passt gut in die eisberg form
        PVector colliderCenterBerg = new PVector(s.x, s.y+10);         
        IceFloe floe = (IceFloe)gameWorld.gameObjects.get(i);

        //1. Fall Kreismittelpunkt liegt innerhalb des Rechtecks
        if (colliderCenterBerg.x > floe.linksR && colliderCenterBerg.x < floe.rechtsR) {
          if (colliderCenterBerg.y > floe.obenR && colliderCenterBerg.y < floe.untenR) {
            //liegt eine Kollission mit einer Eisscholle vor und diese ist bereits lang genug im spiel ( ready for collect)
            //so wird sie eingesammelt (Eisberg wächst und eisscholle verschwindet)
            if (floe.readyForCollect == true) {
              gameWorld.gameObjects.remove(i);
              grow();
              break;
            }
          }
        }

        //2.Fall Eckpunkt liegt im Kreis
        colliderRadiusBerg = sizeX*0.4/2; //sieht besser aus wenns überlappt, daher kleinerer Radius als zuvor
        float distRO = dist(floe.rechtsR, floe.obenR, colliderCenterBerg.x, colliderCenterBerg.y);
        float distRU = dist(floe.rechtsR, floe.untenR, colliderCenterBerg.x, colliderCenterBerg.y);
        float distLO = dist(floe.linksR, floe.obenR, colliderCenterBerg.x, colliderCenterBerg.y);
        float distLU = dist(floe.linksR, floe.untenR, colliderCenterBerg.x, colliderCenterBerg.y);
        if (distRO < colliderRadiusBerg || distRU < colliderRadiusBerg || distLO < colliderRadiusBerg || distLU < colliderRadiusBerg) {
          if (floe.readyForCollect == true) {
            gameWorld.gameObjects.remove(i);
            grow();
            break;
          }
        }

        // 3. Fall Kreis überschneidet einen Rand des Rechtecks
        colliderRadiusBerg = sizeX*0.6/2;
        if (colliderCenterBerg.x > floe.linksR && colliderCenterBerg.x < floe.rechtsR ) {
          if (floe.obenR - colliderRadiusBerg  < colliderCenterBerg.y && floe.obenR + colliderRadiusBerg > colliderCenterBerg.y) {
            //Kreis schneidet oberen Rand
            if (floe.readyForCollect == true) {
              gameWorld.gameObjects.remove(i);
              grow();
              break;
            }
          }
          if (floe.untenR - colliderRadiusBerg < colliderCenterBerg.y && floe.untenR + colliderRadiusBerg > colliderCenterBerg.y) {
            //Kreis schneidet unteren Rand
            if (floe.readyForCollect == true) {
              gameWorld.gameObjects.remove(i);
              grow();
              break;
            }
          }
        }
        if (colliderCenterBerg.y > floe.obenR && colliderCenterBerg.y < floe.untenR ) {
          if (floe.linksR-colliderRadiusBerg < colliderCenterBerg.x && floe.linksR + colliderRadiusBerg > colliderCenterBerg.x) {
            //Kreis schneidet linken Rand
            if (floe.readyForCollect == true) {
              gameWorld.gameObjects.remove(i);
              grow();
              break;
            }
          }
          if (floe.rechtsR-colliderRadiusBerg < colliderCenterBerg.x && floe.rechtsR + colliderRadiusBerg > colliderCenterBerg.x) {
            //Kreis schneidet rechten Rand
            if (floe.readyForCollect == true) {
              gameWorld.gameObjects.remove(i);
              grow();
              break;
            }
          }
        }
      }

      //es wird geprüft ob mit einem anderen Eisberg kollidiert wird
      if (gameWorld.gameObjects.get(i) instanceof IceBerg) {
        if (id !=gameWorld.gameObjects.get(i).id) {  //nicht mit sich selbst kollidieren
          colliderRadius1 = sizeX*0.65/2; //passt gut in die eisberg form
          colliderRadius2 = gameWorld.gameObjects.get(i).sizeX*0.65/2;
          colliderCenter1 = new PVector(s.x, s.y+10);
          colliderCenter2 = new PVector(gameWorld.gameObjects.get(i).s.x, gameWorld.gameObjects.get(i).s.y+10);
          distanze = dist(colliderCenter1.x, colliderCenter1.y, colliderCenter2.x, colliderCenter2.y);
          float allowed = colliderRadius1+colliderRadius2;
          float deltaV = 1;

          //Multiplikator für die Geschwindigkeitsänderung in Abhängigkeit von der Größe
          float sizeMult1 = map( sizeX, minimalSize, defaultSizeX, 5, 1);
          float sizeMult2 = map( gameWorld.gameObjects.get(i).sizeX, minimalSize, defaultSizeX, 5, 1);

          //für den jeweils größeren Eisberg soll sich bei der Kollision nichts ändern,
          //der kleinere Eisberg soll entsprechend seiner größe stärker abprallen
          if (colliderRadius1 > colliderRadius2) {
            sizeMult1 = 1;
          } else if (colliderRadius1 == colliderRadius2) {
            sizeMult1 = 1;
            sizeMult2 = 1;
          } else {
            sizeMult2 = 1;
          }

          if (distanze < allowed) {

            // wenn die Eisberge sich berühren prallen sie so voneinander ab
            if (s.x > gameWorld.gameObjects.get(i).s.x) {
              v.x += deltaV * sizeMult1;
              gameWorld.gameObjects.get(i).v.x -= deltaV * sizeMult2;
              if (s.y>gameWorld.gameObjects.get(i).s.y) {
                v.y += deltaV * sizeMult1;
                gameWorld.gameObjects.get(i).v.y -= deltaV * sizeMult2;
              } else {
                v.y -= deltaV * sizeMult1;
                gameWorld.gameObjects.get(i).v.y += deltaV * sizeMult2;
              }
            }
            if (s.x < gameWorld.gameObjects.get(i).s.x) {
              v.x -= deltaV * sizeMult1;
              gameWorld.gameObjects.get(i).v.x += deltaV * sizeMult2;
              if (s.y>gameWorld.gameObjects.get(i).s.y) {
                v.y += deltaV * sizeMult1;
                gameWorld.gameObjects.get(i).v.y -= deltaV * sizeMult2;
              } else {
                v.y -= deltaV * sizeMult1;
                gameWorld.gameObjects.get(i).v.y += deltaV * sizeMult2;
              }
            }
            if ( s.x == gameWorld.gameObjects.get(i).s.x) {
              if (s.y>gameWorld.gameObjects.get(i).s.y) {
                v.y+= deltaV * sizeMult1;
                gameWorld.gameObjects.get(i).v.y -= deltaV * sizeMult2;
              } else {
                v.y -= deltaV * sizeMult1;
                gameWorld.gameObjects.get(i).v.y += deltaV * sizeMult2;
              }
            }
            //Handling von iceBergColission sollte ein Eisberg bewaffnet sein
            IceBerg otherIceBerg = (IceBerg)gameWorld.gameObjects.get(i);
            iceBergCollision(otherIceBerg, deltaTimeSeconds);
            crashTime = gameWorld.timeElapsed;
            iceBergCrash = true;
          }
        }
      } 
      if (gameWorld.gameObjects.get(i) instanceof Rand) {
        Rand rand = (Rand)gameWorld.gameObjects.get(i);
        if (!rand.isEnd) {
          if (rand.s.y < ScreenHeight/2 && s.y - sizeY*0.65/2 <= gameWorld.randColliderMin) {
            v.y += 1;
          } else if (rand.s.y > ScreenHeight/2 && s.y + sizeY*0.65/2 >= gameWorld.randColliderMax) {
            v.y -= 1;
          }
        }
      } 
      if (gameWorld.gameObjects.get(i) instanceof Dampfer) {
        Dampfer dampfer = (Dampfer)gameWorld.gameObjects.get(i);
        if (dampfer.s.x-dampfer.sizeX/2 <= s.x + sizeX/2 && dampfer.s.x+dampfer.sizeX/2 > s.x - sizeX/2 && dampfer.s.y + dampfer.sizeY/2 >= s.y - sizeY/2 && dampfer.s.y < s.y + sizeY/2) {
          v.x -= 5;
          if (dampfer.s.y < s.y) {
            v.y += 6;
          } else {
            v.y -= 6;
          }
          if (shrinkCollisionCount == 0) {
            shrink(deltaTimeSeconds);
          }
          shrinkCollisionCount = 1;
          growValue = 4; //wieder zurücksetzen
        } else {
          shrinkCollisionCount = 0;
        }
      } else {
        //es handelt sich weder um Eisberg noch um Eisscholle -> Items
        colliderRadius1 = sizeX*0.65/2;
        colliderRadius2 = gameWorld.gameObjects.get(i).sizeX/2;
        PVector colliderCenter1 = new PVector(s.x, s.y+10);
        PVector colliderCenter2 = new PVector(gameWorld.gameObjects.get(i).s.x, gameWorld.gameObjects.get(i).s.y);
        distanze = dist(colliderCenter1.x, colliderCenter1.y, colliderCenter2.x, colliderCenter2.y);
        float allowed = colliderRadius1+colliderRadius2;

        if (distanze<allowed) {
          //beim Einsammeln der IcePick wird ein Eisberg bewaffnet, das Item verschwindet und die Wirkungszeit 5sec beginnt abzulaufen
          if  (gameWorld.gameObjects.get(i) instanceof IcePick) {
            bewaffnet = true;
            //gameWorld.pickNeeded=true;
            bewaffnetTime=deltaTimeSeconds;
            gameWorld.gameObjects.remove(i);
            break;
          }
          //der booster beschleunigt den Eisberg nach Einsammeln für 5 Sekunden (Trägheit wird reduziert)
          if  (gameWorld.gameObjects.get(i) instanceof Booster) {
            boosted = true;  
            boostedTime=deltaTimeSeconds;
            gameWorld.gameObjects.remove(i);
            break;
          }
          //Warmes Wasser erhöht die Schrumpfgeschwindigkeit des Eisbergs solange er sich darin aufhält
          if  (gameWorld.gameObjects.get(i) instanceof WarmWater) {
            shrinkValue=0.08 + map(schwierigkeit, 0, 2, 0, 0.03);
          } else {
            shrinkValue = 0.03+ 0.01 * schwierigkeit;
          }
        }
      }
    }
  }


  void iceBergCollision(IceBerg otherIceBerg, float deltaTimeSeconds) {
    //bei einer Kollision mit einem bewaffneten Eisberg verliert der betroffene Eisberg Eis - er schrumpft also
    if (bewaffnet == false) {
      if (otherIceBerg.bewaffnet == true) {
        shrink(deltaTimeSeconds);
      }
    }
  }

  void grow() {
    if (sizeX<=defaultSizeX) {
      sizeX = min(sizeX+growValue, defaultSizeX);
      sizeY = min(sizeY+growValue, defaultSizeY);
    }
  }

  void shrink(float deltaTimeSeconds) {
    //println("schrumpfe" + deltaTimeSeconds);
    sizeX -= growValue;
    sizeY -= growValue;
    gameWorld.createRandomIceFlow(s.x - gameWorld.xShift, s.x, s.y);
  }

  void animate(float deltaTimeSeconds) {

    if (deltaTimeSeconds - crashTime >= 0.5) {
      iceBergCrash = false;
    }

    actualHealth = round( map(sizeX, minimalSize, defaultSizeX, 0, 100));

    //Zurücksetzen der Bewaffnung nach Ablauf der maximalen Dauer der IcePick
    if (deltaTimeSeconds - bewaffnetTime >= maxBewaffnetTime) {
      bewaffnet = false;
    }

    if (deltaTimeSeconds - boostedTime >= maxBoostedTime) {
      boosted = false;
    }
    eyeLookupX = round(map(sizeX, defaultSizeX, minimalSize, 0, 25));
    eyeLookupY = round(map(sizeX, defaultSizeX, minimalSize, 0, 10));
  }

  void updateV() {
    //Steuert spieler 2
    if (id==2) {
      if (gameWorld.pressingUP ==true) {

        if (boosted==true) {
          v.y -=1;
        } else {
          v.y -=0.6;
        }
      }
      if (gameWorld.pressingDOWN ==true) {
        if (boosted==true) {
          v.y +=1;
        } else {
          v.y +=0.6;
        }
      }
      if (gameWorld.pressingLEFT ==true) {
        if (boosted==true) {
          v.x -=1.15;
        } else {
          v.x -=0.75;
        }
      }
      if (gameWorld.pressingRIGHT ==true) {
        if (boosted==true) {
          v.x +=1.1;
        } else {
          v.x +=0.7;
        }
      }
      if (gameWorld.pressingRIGHT == false && gameWorld.pressingLEFT == false && gameWorld.pressingUP == false && gameWorld.pressingDOWN == false) {
        v.x-=0.2;
      }
    }

    //Steuert speieler 1
    if (id==1) {
      if (gameWorld.pressingW ==true) {
        if (boosted==true) {
          v.y -=1;
        } else {
          v.y -=0.6;
        }
      }
      if (gameWorld.pressingS ==true) {
        if (boosted==true) {
          v.y +=1;
        } else {
          v.y +=0.6;
        }
      }
      if (gameWorld.pressingA ==true) {
        if (boosted==true) {
          v.x -=1.15;
        } else {
          v.x -=0.75;
        }
      }
      if (gameWorld.pressingD ==true) {
        if (boosted==true) {
          v.x +=1.1;
        } else {
          v.x +=0.7;
        }
      }
      if (gameWorld.pressingW == false && gameWorld.pressingA == false && gameWorld.pressingS == false && gameWorld.pressingD == false) {
        v.x-=0.2;
      }
    }
  }

  void draw() {

    imageMode(CENTER);

    sizeX -= shrinkValue;
    sizeY -= shrinkValue;

    //Charakter schaut nach rechts
    if (v.x>=0.1) {

      image(character, s.x, s.y, sizeX, sizeY);
      image(eyes, s.x-eyeLookupX, s.y+eyeLookupY, defaultSizeX, defaultSizeX);
      if (bewaffnet==true) {     

        image(icePick, s.x-sizeX/4, s.y, 80, 80);//+sizeX/4
      }

      //noStroke(); //for collission debugging
      //circle(s.x, s.y+10, sizeX*0.65);
      //strokeWeight(5);
    }

    //circle(s.x,s.y+5,sizeX*5/6); debug Kreis

    //Charakter schaut nach links
    if (v.x<0.1) {
      pushMatrix();
      //spiegeln
      scale(-1, 1);
      //Falls der Charakter bewaffnet ist, tint (später sollte dann eine IcePick am Charakter zu sehen sein)

      image(character, -s.x, s.y, sizeX, sizeY);
      image(eyes, -s.x-eyeLookupX, s.y+eyeLookupY, defaultSizeX, defaultSizeX);
      if (bewaffnet==true) {     
        image(icePick, -s.x-sizeX/4, s.y, 80, 80);
      }

      popMatrix();

      //line(colliderCenter1.x, colliderCenter1.y, colliderCenter2.x, colliderCenter2.y);// collission debugging
      //noStroke();
      //circle(s.x, s.y+10, sizeX*0.65);
      //strokeWeight(5);
    }


    //Geschwindigkeit berechnen
    updateV();

    // Position aktualisieren
    s.x += v.x;
    s.y += v.y;

    //Verhindern, dass die Eisberge aus dem Bildschirm schwimmen
    if (s.x<=sizeX/2) {
      v.x+=8;
    }
    if (s.x >= ScreenWidth-sizeX/2) {
      v.x-=8;
    }


    //Trägheit 

    drag = normalDrag;

    v.x *= drag;
    v.y *= drag;

    return;
  }
}


// Ich habe hier eine Elternklasse GameItems erstellt. Für alle Elemente die man einsammeln kann oder die 
// auf dem Weg erscheinen. Es geht hauptsächlich darum um den globalX Wert und den s.x für alle Elemente gleich 
// anzulegen und falls man noch ein paar Funktionen möchte die alle gemeinsam haben 

class GameItems extends GameObjects {

  Boolean readyForCollect;
  float startTime;
  float readyTime = 1;

  GameItems(GameWorld _gameWorld, float _x, float _y) {
    super(_gameWorld, _x, _y);
    globalX = s.x;
    readyForCollect = false;
    startTime = gameWorld.timeElapsed;
  }

  void animate(float deltaTimeSeconds) {
    if (gameWorld.timeElapsed - startTime > readyTime) {
      readyForCollect = true;
    }
    s.x = globalX + gameWorld.xShift;
  }

  void collisionDetection(float deltaTimeSeconds) {
  }

  void draw() {
  }
}


class WarmWater extends GameItems {

  int rand ;
  int imageDrawed;
  Boolean changed;

  WarmWater(GameWorld _gameWorld, float _x, float _y, int _sizeX, int _sizeY) {
    super(_gameWorld, _x, _y);
    //rand = int(random(150, 320));
    sizeX = _sizeX;
    sizeY = _sizeY;
    imageDrawed = 0;
    changed = false;
  }

  void animate(float deltaTimeSeconds) {

    super.animate(deltaTimeSeconds);
    //sizeX=rand-20;
    //sizeY=rand-20;/*
    /*if (deltaTimeSeconds % 2 <= 0.3) {
     if (!changed) { 
     if (imageDrawed < 2) { 
     imageDrawed++;
     } else {
     imageDrawed = 0;
     }
     changed = true;
     }
     } else if (changed) {
     changed = false;
     }*/
  }

  void collisionDetection(float deltaTimeSeconds) {
  }

  void draw() {
    /*fill(245, 225, 175, 125);
     noStroke();
     rectMode(CENTER);
     
     rect(globalX, s.y, rand, rand);
     rectMode(CORNER);
     */
    image(warmWater3, globalX, s.y, sizeX, sizeY);
  }
}

class IceFloe extends GameItems {

  float endSizeX;
  float endSizeY;
  Boolean crash; 
  float startX;
  float startY;
  float endX;
  float endY;
  float rechtsR;
  float linksR;
  float obenR;
  float untenR;
  float drawedX;
  float drawedY;

  IceFloe(GameWorld _gameWorld, float _x, float _y) {
    super(_gameWorld, _x, _y);
    crash = false;
    iceFloe = loadImage("assets/icefloe_01.png");
    endSizeX = iceFloe.width/2 * ScreenWidth/1920;
    endSizeY = iceFloe.height/2 * ScreenWidth/1920;
    sizeX = 0;
    sizeY = 0;
    rechtsR = s.x + endSizeX/2;
    linksR = s.x - endSizeX/2;
    obenR = s.y - endSizeY/2;
    untenR = s.y + endSizeY/2;
  } 

  IceFloe(GameWorld _gameWorld, float _startX, float _startY, float _endX, float _endY, Boolean _crash) {
    super(_gameWorld, _startX, _startY);
    crash = _crash;
    iceFloe = loadImage("assets/icefloe_01.png");
    endSizeX = iceFloe.width/2;
    endSizeY = iceFloe.height/2;
    sizeX = 0;
    sizeY = 0;
    startX = _startX;
    startY = _startY;
    endX = _endX;
    endY = _endY;
    drawedX = startX;
    drawedY = startY;
    rechtsR = s.x + endSizeX/2;
    linksR = s.x - endSizeX/2;
    obenR = s.y - endSizeY/2;
    untenR = s.y + endSizeY/2;
  }

  void animate(float deltaTimeSeconds) {
    super.animate(deltaTimeSeconds);

    rechtsR = s.x + endSizeX/2;
    linksR = s.x - endSizeX/2;

    if (crash == true) {

      if (sizeX < endSizeX) {
        sizeX += (deltaTimeSeconds-startTime)*4;
      } else {
        sizeX = endSizeX;
      }
      if (sizeY < endSizeY) {
        sizeY += (deltaTimeSeconds-startTime)*4;
      } else {
        sizeY = endSizeY;
      }
      if (startX < endX && drawedX < endX) {
        drawedX = startX + (deltaTimeSeconds-startTime)*120;
      } else if (startX > endX && drawedX > endX) {
        drawedX = startX - (deltaTimeSeconds-startTime)*120;
      } else {
        drawedX = endX;
      }
      if (startY < endY && drawedY < endY) {
        drawedY = startY + (deltaTimeSeconds-startTime)*120;
      } else if (startY > endY && drawedY > endY) {
        drawedY = startY - (deltaTimeSeconds-startTime)*120;
      } else {
        drawedY = endY;
      }
      globalX = drawedX;
      s.y = drawedY;
      rechtsR = drawedX + gameWorld.xShift + endSizeX/2;
      linksR = drawedX + gameWorld.xShift - endSizeX/2;
      obenR = s.y - endSizeY/2;
      untenR = s.y + endSizeY/2;
    } else {
      if (sizeX < endSizeX) {
        sizeX += (deltaTimeSeconds-startTime)*2;
      } else {
        sizeX = endSizeX;
      }
      if (sizeY < endSizeY) {
        sizeY += (deltaTimeSeconds-startTime)*2;
      } else {
        sizeY = endSizeY;
      }
    }
  }

  void collisionDetection(float deltaTimeSeconds) {
  }

  void draw() {
    /*
      //visuallisierung der Collider-Box zum debuggen
     PVector RechteckLO = new PVector(globalX - sizeX/2+8, s.y - sizeY/2+15);
     PVector RechteckRO = new PVector(globalX  + sizeX/2-8, s.y - sizeY/2+15);
     PVector RechteckLU = new PVector(globalX  - sizeX/2+8, s.y + sizeY/2-15);
     PVector RechteckRU = new PVector(globalX  + sizeX/2-8, s.y + sizeY/2-15);
     strokeWeight(3);
     stroke(255, 0, 0);
     line(RechteckLO.x, RechteckLO.y, RechteckLU.x, RechteckLU.y);
     line(RechteckRO.x, RechteckRO.y, RechteckRU.x, RechteckRU.y);
     line(RechteckLO.x, RechteckLO.y, RechteckRO.x, RechteckRO.y);
     line(RechteckLU.x, RechteckLU.y, RechteckRU.x, RechteckRU.y);
     */
    image(iceFloe, globalX, s.y, sizeX, sizeY);
  }
}

class IcePick extends GameItems {

  float endSizeX;
  float endSizeY;

  IcePick(GameWorld _gameWorld, float _x, float _y) {
    super(_gameWorld, _x, _y);
    endSizeX = ScreenWidth/32;
    endSizeY = ScreenWidth/32;
    sizeX = 0;
    sizeY = 0;
  } 

  void animate(float deltaTimeSeconds) {
    super.animate(deltaTimeSeconds);
    if (sizeX < endSizeX) {
      sizeX += (deltaTimeSeconds-startTime)*2;
    } else {
      sizeX = endSizeX;
    }
    if (sizeY < endSizeY) {
      sizeY += (deltaTimeSeconds-startTime)*2;
    } else {
      sizeY = endSizeY;
    }
  }

  void collisionDetection(float deltaTimeSeconds) {
  }

  void draw() {
    fill(10);
    image(icePick, globalX, s.y, sizeX, sizeY);
    //circle(globalX, s.y, 40);
  }
}

class Booster extends GameItems {
  Booster(GameWorld _gameWorld, float _x, float _y) {
    super(_gameWorld, _x, _y);
  } 
  void animate(float deltaTimeSeconds) {
    super.animate(deltaTimeSeconds);
  }
  void collisionDetection(float deltaTimeSeconds) {
  }
  void draw() {
    //fill(184, 79, 201);
    //circle(globalX, s.y, 30);
    // fill(0);

    image(booster, globalX, s.y, ScreenWidth/48, ScreenWidth/48);
  }
}

class Dampfer extends GameItems {

  float startX;

  Dampfer(GameWorld _gameWorld, float startX, float _y) {
    super(_gameWorld, startX, _y);
    startTime = 0;
    sizeX = dampfer.width/1.5 * ScreenWidth /1920;
    sizeY = dampfer.height/1.5 * ScreenWidth /1920;
  } 
  void animate(float deltaTimeSeconds) {
    super.animate(deltaTimeSeconds);
    if (globalX - sizeX< -gameWorld.xShift + ScreenWidth) 
    {
      if (startTime == 0) {
        startTime = deltaTimeSeconds;
      }
      globalX -= (deltaTimeSeconds-startTime)*1.5;
    }
  }
  void collisionDetection(float deltaTimeSeconds) {
  }
  void draw() {
    //fill(184, 79, 201);
    //circle(globalX, s.y, 30);
    // fill(0);

    image(dampfer, globalX, s.y, sizeX, sizeY);
  }
}


class Rand extends GameItems {
  float posX;
  float posY;
  PImage bild;
  Boolean isEnd;


  Rand(GameWorld _gameWorld, float _x, float _y, PImage _image, Boolean _isEnd) {
    super(_gameWorld, _x, _y);
    posX=_x;
    posY = _y;
    bild = _image;
    isEnd = _isEnd;
    sizeX = bild.width;
    sizeY = bild.height;
    if (aspectRatio ==1.6&isEnd==true) {
      // bild.resize(bild.width/9*10, bild.height/9*10);
      sizeX = bild.width/9*10;
      sizeY = bild.height/9*10;
    }
  } 
  void animate(float deltaTimeSeconds) {
    super.animate(deltaTimeSeconds);
  }
  void collisionDetection(float deltaTimeSeconds) {
  }
  void draw() {
    image(bild, posX, posY, sizeX, sizeY);
  }
}
