class Vec
{
  float posX;
  float posY;
  /*
  *    CLASS KONSTRUKTOR
  */
  Vec(float x, float y)
  {
    posX = x;
    posY = y;
  }
  
  Vec(Vec Vector)
  {
    posX = Vector.getX();
    posY = Vector.getY();
  }
  
  void setVec(float x, float y)
  {
    posX = x;
    posY = y;
  }
  
  void printXY()
  {
    println("x-wert: " + posX + " y-wert: " + posY);
  }
  
  float getX()
  {
    return posX;
  }
  
  float getY()
  {
    return posY;
  }
  
  /////////////////////////////////////////////////
  // FUNKTIONEN: Rechenoperationen
  /////////////////////////////////////////////////
  
  // Skalarprodukt
  float dot(Vec vector)
  {
    float dotproduct;
    dotproduct = this.getX() * vector.getX() + this.getY() * vector.getY();
    return dotproduct;
  }

  // Addition
  Vec addVec(Vec vector)
  {
    Vec sumVec = new Vec(this.getX()+vector.getX(), this.getY()+vector.getY());
    return sumVec;
  }

  // Subtraktion
  Vec subVec(Vec vector)
  {
    Vec difVec = new Vec(this.getX()-vector.getX(), this.getY()-vector.getY());
    return difVec;
  }

  // Multiplikation mit Vektor
  Vec multVec(Vec vector)
  {
    Vec prodVec = new Vec(this.getX()*vector.getX(), this.getY()*vector.getY());
    return prodVec;
  }
  
  // Errechnen des Skalierungsfaktors um von this auf vector zu gelangen; this, vector sind parallel
  float getVecScale(Vec vector)
  {
    float vecScale;
    // vector.getY könnte positiv sein und zu vecScale führen
    if (vector.getX() == 0)
    {
      vecScale = 0;
    } else
    {
      vecScale = this.getX() / vector.getX();  
    }
    return vecScale;
  }
  
  // Division
  Vec divVec(Vec vector)
  {
    if (vector.getX()==0 || vector.getY()==0)
    {
      println("Vectordivision durch null!"); 
    }
    Vec quotVec = new Vec(this.getX()/vector.getX(), this.getY()/vector.getY());
    return quotVec;
  }

  // Multiplikation mit Float
  Vec multVecFloat(float n1)
  {
    Vec prodVec = new Vec(this.getX()*n1, this.getY()*n1);
    return prodVec;
  }


  // Einheitsvektor
  Vec makeUnit()          // gibt normalenvektor mit L=1 zurück
  {  
    float unitX = this.getX() / sqrt ( sq(this.getX()) + sq(this.getY()));
    float unitY = this.getY() / sqrt ( sq(this.getX()) + sq(this.getY()));
    
    Vec unitVec = new Vec(unitX, unitY);
    return unitVec;
  }
 
 // Vektor um 90° drehen
 Vec rotateV90()
 {
   float rotX = this.getX();
   float rotY = this.getY();
   
   Vec rotVec = new Vec(rotY, -rotX);
   return rotVec;
 }
 
 
  /////////////////////////////////////////////////
  // FUNKTIONEN: Berechnungen
  /////////////////////////////////////////////////

  Vec intersect(Vec p1, Vec p2, Vec thisStart)    // p1, p2 gehören zu v1, p3 ist der Startpunkt von this
  {
    boolean doIntersect = false;
    float p1x, p1y, p2x, p2y, p3x, p3y, 
          r1x, r1y, r2x, r2y, t2, 
          intersectX, intersectY;
    Vec intersectP;                               // Rückgabewert
    
    // Punkte des Vectors
    p1x = p1.getX();
    p1y = p1.getY();
    p2x = p2.getX();
    p2y = p2.getY();
    
    // Punkte des Rays
    r1x = thisStart.getX();
    r1y = thisStart.getY();
    r2x = thisStart.getX() + this.getX();
    r2y = thisStart.getY() + this.getY();
    
      
    // Berechnung von t2
    // p1x + t1 * (p2x - p1x) = r1x + t2 * (r2x-r1x)   // Gleichsetzen der Geradengleichungen für polygonkante und ray
    // p1y + t1 * (p2y - p1y) = r1y + t2 * (r2y-r1y)

    t2 = ( (r1y - p1y)*(p2x-p1x) - (r1x-p1x)*(p2y-p1y) ) / ( (r2x-r1x)*(p2y-p1y) - (r2y-r1y)*(p2x-p1x) );
  
    intersectX = r1x + t2 * (r2x - r1x);
    intersectY = r1y + t2 * (r2y - r1y);
    // intersectX = p1x + t1 * (p2x - p1x);
    // intersectY = p1y + t1 * (p2y - p1y);
    
 
    if (t2>0)
    {
      intersectP = new Vec(intersectX, intersectY);
      return intersectP;
    }
    else 
    {
      intersectP = new Vec(0, 0);
      return intersectP;
    }
  }


  Vec reflect(Vec VectorN)
  {
    //vres = v1 - vn * (2 * v1 . vn)
    Vec resVec = new Vec( this.subVec( VectorN.multVecFloat(2*this.dot(VectorN)) ));
    return resVec;
  }
}