13 files changed, 807 insertions, 0 deletions
diff --git a/src/sims/dynamics/Body.scala b/src/sims/dynamics/Body.scala
new file mode 100644
index 0000000..d5b2a0e
--- /dev/null
+++ b/src/sims/dynamics/Body.scala
@@ -0,0 +1,143 @@
+/*
+ * Simple Mechanics Simulator (SiMS)
+ * copyright (c) 2009 Jakob Odersky
+ * made available under the MIT License
+*/
+
+package sims.dynamics
+
+import sims.geometry._
+import sims.dynamics.joints._
+
+/**Ein 2-Dimensionaler Koerper besteht aus mehreren Formen. Im gegensatz zu letzteren, enthaelt ein Koerper dynamische Informationen (v, F, etc...).
+ * @param shps zu dem Koerper gehoerende Formen.*/
+class Body(shps: Shape*){
+  
+  /**Einzigartige Identifikationsnummer dieses Koerpers.*/
+  val uid = Body.nextUid
+  
+  /**Formen aus denen dieser Koerper besteht.*/
+  val shapes: List[Shape] = shps.toList
+  
+  //Formen werden bei Initialisierung eingefuegt
+  for (s <- shapes) {
+    s.body = this
+    s.refLocalPos = s.pos - pos
+    s.rotation0 = s.rotation
+  }
+  
+  private var isFixed: Boolean = false
+  
+  /**Gibt an ob dieser Koerper fixiert ist.*/
+  def fixed = isFixed
+  
+  /**Fixiert oder unfixiert diesen Koerper.*/
+  def fixed_=(value: Boolean) = {
+    if (value) {linearVelocity = Vector2D.Null; angularVelocity = 0.0}
+    isFixed = value
+  } 
+  
+  /**Gibt an ob die Eigenschaften dieses Koerpers ueberwacht werden sollen.
+   * @see World#monitors*/
+  var monitor: Boolean = false
+  
+  /**Ermittelt die Position dieses Koerpers. Die Position entspricht dem Schwerpunkt.
+   * @return Position dieses Koerpers*/
+  def pos: Vector2D = // Shwerpunkt = sum(pos*mass)/M
+    (Vector2D.Null /: shapes)((v: Vector2D, s: Shape) => v + s.pos * s.mass) /
+    (0.0 /: shapes)((i: Double, s: Shape) => i + s.mass)
+  
+  /**Setzt die Position dieses Koerpers und verschiebt dadurch die Positionen seiner Formen.
+   * @param newPos neue Position*/
+  def pos_=(newPos: Vector2D) = {
+    val stepPos = pos
+    shapes.foreach((s: Shape) => s.pos = s.pos - stepPos + newPos)
+  }
+  
+  /**Enthaelt die aktuelle Rotation dieses Koerpers.*/
+  private var _rotation: Double = 0.0 //shapes(0).rotation
+  
+  /**Ergibt die aktuelle Rotation dieses Koerpers.
+   * @return aktuelle Rotation dieses Koerpers*/
+  def rotation: Double = _rotation
+  
+  /**Setzt die Rotation dieses Koerpers. Dazu werden auch die Positionen und Rotationen seiner Formen entsprechend veraendert.
+   * @param r neue Rotation*/
+  def rotation_=(newRotation: Double) = {
+    _rotation = newRotation
+    val stepPos = pos
+    for (s <- shapes) {
+      s.rotation = newRotation + s.rotation0
+      s.pos = stepPos + (s.refLocalPos rotate (newRotation))
+    }  
+  }
+  
+  /**Lineargeschwindigkeit dieses Koerpers.*/
+  var linearVelocity: Vector2D = Vector2D.Null
+  
+  /**Winkelgeschwindigkeit dieses Koerpers.*/
+  var angularVelocity: Double = 0
+  
+  /**Lineargeschwindigkeit des gegebenen Punktes auf diesem Koerper. In Weltkoordinaten.*/
+  def velocityOfPoint(point: Vector2D) = linearVelocity + ((point - pos).leftNormal * angularVelocity)
+  
+  /**Resultierende Kraft auf den Schwerpunkt dieses Koerpers.*/
+  var force: Vector2D = Vector2D.Null
+  
+  /**Resultierender Drehmoment zu dem Schwerpunkt dieses Koerpers.*/
+  var torque: Double = 0
+  
+  /**Ergibt die Masse dieses Koerpers. Die Masse ist gleich die Summe aller Massen seiner Formen.
+   * @return Masse des Koerpers*/
+  def mass: Double = if (fixed) Double.PositiveInfinity else (0.0 /: shapes)((i: Double, s: Shape) => i + s.mass)
+  
+  /**Ergibt den Traegheitsmoment zu dem Schwerpunkt dieses Koerpers. Der Traegheitsmoment wird mit Hilfe des Steinerschen Satzes errechnet.
+   * @return Traegheitsmoment relativ zu dem Schwerpunkt dieses Koerpers*/
+  def I: Double = if (fixed) Double.PositiveInfinity else
+    (0.0 /: (for (s <- shapes) yield (s.I + s.mass * ((s.pos - pos) dot (s.pos - pos)))))(_+_)
+  
+  /**Wendet eine Kraft auf den Schwerpunkt dieses Koerpers an.
+   * @param force anzuwendender Kraftvektor*/
+  def applyForce(force: Vector2D) = if (!fixed) this.force += force
+  
+  /**Wendet eine Kraft auf einen Punkt dieses Koerpers an. Achtung: der gegebene Punkt wird nicht auf angehoerigkeit dieses
+   * Koerpers ueberprueft.
+   * @param force anzuwendender Kraftvektor
+   * @param point Ortsvektor des Punktes auf den die Kraft wirken soll (gegeben in Weltkoordinaten).*/
+  def applyForce(force: Vector2D, point: Vector2D) = if (!fixed) {this.force += force; torque += (point - pos) cross force}
+  
+  /**Wendet einen Impuls auf den Schwerpunkt dieses Koerpers an.
+   * @param impulse anzuwendender Impulsvektor*/  
+  def applyImpulse(impulse: Vector2D) = if (!fixed) linearVelocity += impulse / mass
+  
+  /**Wendet einen Impuls auf einen Punkt dieses Koerpers an. Achtung: der gegebene Punkt wird nicht auf angehoerigkeit dieses
+   * Koerpers ueberprueft.
+   * @param impulse anzuwendender Impulsvektor
+   * @param point Ortsvektor des Punktes auf den der Impuls wirken soll (gegeben in Weltkoordinaten).*/
+  def applyImpulse(impulse: Vector2D, point: Vector2D) = if (!fixed) {linearVelocity += impulse / mass; angularVelocity += ((point - pos) cross impulse) / I}
+  
+  /**Ueberprueft ob der gegebene Punkt <code>point</code> sich in diesem Koerper befindet.*/
+  def contains(point: Vector2D) = shapes.exists(_.contains(point))
+  
+  override def toString: String = {
+    "Body" + uid + "	" + shapes + "	fixed=" + fixed + "	m=" + mass + "	I=" + I + 	"	pos=" + pos + "	rot=" + rotation + "	v=" + linearVelocity + "	w=" + angularVelocity + "	F=" + force + "	tau=" + torque
+  }
+  
+  /**Erstellt einen neuen Koerper der zusaetzlich die Form <code>s</code> enthaelt.
+   * @param s zusaetzliche Form
+   * @return neuer Koerper*/
+  def ^(s: Shape) = new Body((s :: shapes): _*)
+  
+  /**Erstellt einen neuen Koerper der zusaetzlich die Formen von dem Koerper <code>b</code> enthaelt.
+   * @param b Koerper mit zusaetzlichen Formen
+   * @return neuer Koerper*/
+  def ^(b: Body) = {
+    val shapes = this.shapes ::: b.shapes
+    new Body(shapes: _*)
+  }
+}
+
+object Body {
+  private var uidCounter = -1
+  private def nextUid = {uidCounter += 1; uidCounter}
+}
+\ No newline at end of file
diff --git a/src/sims/dynamics/Circle.scala b/src/sims/dynamics/Circle.scala
new file mode 100644
index 0000000..26f3ad4
--- /dev/null
+++ b/src/sims/dynamics/Circle.scala
@@ -0,0 +1,37 @@
+/*
+ * Simple Mechanics Simulator (SiMS)
+ * copyright (c) 2009 Jakob Odersky
+ * made available under the MIT License
+*/
+
+package sims.dynamics
+
+import sims.geometry._
+import sims.collision._
+
+/**
+ * Circle ist die Definition eines Kreises.
+ * @param radius Radius dieses Kreises
+ * @param density Dichte dieses Kreises
+ */
+case class Circle(radius: Double,					// Radius
+                  density: Double) extends Shape{	// Dichte
+  
+  val volume = Math.Pi * radius * radius
+  
+  val I = mass * radius * radius / 2
+  
+  // AABB(Zentrum - Radius, Zentrum + Radius)
+  def AABB = new AABB(pos - Vector2D(radius,radius),
+                      pos + Vector2D(radius,radius))
+  
+  def project(axis: Vector2D) = if (axis.x != 0) Projection(axis,
+                                                            (pos.project(axis).x / axis.x) - radius,
+                                                            (pos.project(axis).x / axis.x) + radius)
+                                else Projection(axis,
+                                                (pos.project(axis).y / axis.y) - radius,
+                                                (pos.project(axis).y / axis.y) + radius)
+  
+  //Ist der gegebene punkt im Radius dieses kreises?
+  def contains(point: Vector2D) = (point - pos).length <= radius
+}
diff --git a/src/sims/dynamics/Constraint.scala b/src/sims/dynamics/Constraint.scala
new file mode 100644
index 0000000..74c2af3
--- /dev/null
+++ b/src/sims/dynamics/Constraint.scala
@@ -0,0 +1,19 @@
+/*
+ * Simple Mechanics Simulator (SiMS)
+ * copyright (c) 2009 Jakob Odersky
+ * made available under the MIT License
+*/
+
+package sims.dynamics
+
+/**Randbedingungen erben von dem Trait <code>Constraint</code>.
+ * Fuer jeden Constraint koennen Position und Geschwindigkeit korrigiert werden.
+ * Ihre Implementierung wurde von Erin Catto's box2d inspiriert.*/
+trait Constraint {
+  
+  /**Korrigiert die Geschwindigkeit der Koerper damit diese den Randbedingungen entsprechen.*/
+  def correctVelocity(h: Double): Unit
+  
+  /**Korrigiert die Position der Koerper damit diese den Randbedingungen entsprechen.*/
+  def correctPosition(h: Double): Unit
+}
diff --git a/src/sims/dynamics/Rectangle.scala b/src/sims/dynamics/Rectangle.scala
new file mode 100644
index 0000000..adaa634
--- /dev/null
+++ b/src/sims/dynamics/Rectangle.scala
@@ -0,0 +1,40 @@
+/*
+ * Simple Mechanics Simulator (SiMS)
+ * copyright (c) 2009 Jakob Odersky
+ * made available under the MIT License
+*/
+
+package sims.dynamics
+
+import sims.geometry._
+import sims.collision._
+
+/**Rechteck ist eine Art Polygon.
+ * @param halfWidth halbe Breite dieses Rechtecks
+ * @param halfHeight halbe Hoehe dieses Rechtecks
+ * @param density dichte dieses Rechtecks
+ */
+case class Rectangle(halfWidth: Double,
+                     halfHeight : Double,
+                     density: Double) extends Shape with ConvexPolygon{
+  
+  val volume = halfWidth * halfHeight * 4
+  
+  val I = 1.0 / 12.0  * mass * ((2 * halfWidth) * (2 * halfWidth) + (2 * halfHeight) * (2 * halfHeight))
+  
+  /**Ergibt Vektoren vom Zentrum dieses Rectecks bis zu den Ecken.
+   * Erste Ecke entspricht der Ecke oben rechts bei einer Rotation von 0.
+   * Folgende Ecken sind gegen den Uhrzeigersinn geordnet.
+   * @return Vektoren vom Zentrum dieses Rectecks bis zu den Ecken*/
+  def halfDiags: Array[Vector2D] = Array(Vector2D(halfWidth, halfHeight),
+                                         Vector2D(-halfWidth, halfHeight),
+                                         Vector2D(-halfWidth, -halfHeight),
+                                         Vector2D(halfWidth, -halfHeight)) map (_ rotate rotation)
+  
+  /**Ergibt die Ortsvektoren der Ecken dieses Rechtecks. 
+   * Erste Ecke entspricht der Ecke oben rechts bei einer Rotation von 0.
+   * Folgende Ecken sind gegen den Uhrzeigersinn geordnet.
+   * @return Ortsvektoren der Ecken dieses Rechtecks*/
+  def vertices = for (h <- halfDiags) yield pos + h
+  
+} 
+\ No newline at end of file
diff --git a/src/sims/dynamics/RegularPolygon.scala b/src/sims/dynamics/RegularPolygon.scala
new file mode 100644
index 0000000..c5b8a13
--- /dev/null
+++ b/src/sims/dynamics/RegularPolygon.scala
@@ -0,0 +1,35 @@
+/*
+ * Simple Mechanics Simulator (SiMS)
+ * copyright (c) 2009 Jakob Odersky
+ * made available under the MIT License
+*/
+
+package sims.dynamics
+
+import Math._
+import sims.geometry._
+
+/**Ein regelmaessiges Polygon mit <code>n</code> Seiten, dass der Kreis mit radius <code>radius</code> umschreibt.
+ * @param n Anzahl der Seiten.
+ * @param radius Radius des umschreibenden Kreises.
+ * @param density Dichte.
+ */
+case class RegularPolygon(n: Int, radius: Double, density: Double) extends Shape with ConvexPolygon{
+  require(n >= 3, "Polygon must have at least 3 sides.")
+  
+  /**Hoehe eines der konstituierneden Dreiecke des Polygons.*/
+  private val h: Double = radius * cos(Pi / n)
+  /**Halbe Breite eines der konstituierneden Dreiecke des Polygons.*/
+  private val b: Double = radius * sin(Pi / n)
+  
+  def halfDiags = (for (i: Int <- (0 until n).toArray) yield (Vector2D(0, radius) rotate (2 * Pi * i / n))) map (_ rotate rotation)
+  
+  def vertices = for (h <- halfDiags) yield pos + h
+  
+  val volume = n * h * b
+  
+  /**Traegheitsmoment eines der konstituierneden Dreiecke im Zentrum des Polygons.*/
+  private val Ic: Double = density * b * (3 * b + 16) * h * h * h * h / 54
+  
+  val I = n * Ic
+}
diff --git a/src/sims/dynamics/Shape.scala b/src/sims/dynamics/Shape.scala
new file mode 100644
index 0000000..f57bbc6
--- /dev/null
+++ b/src/sims/dynamics/Shape.scala
@@ -0,0 +1,93 @@
+/*
+ * Simple Mechanics Simulator (SiMS)
+ * copyright (c) 2009 Jakob Odersky
+ * made available under the MIT License
+*/
+
+package sims.dynamics
+
+import sims.geometry._
+import sims.collision._
+
+/**
+* Eine abstrakte Form.
+*/
+abstract class Shape{
+  
+  /**Einzigartige Identifikationsnummer.*/
+  val uid: Int = Shape.nextUid
+  
+  /**Kollisionsfaehigkeit.*/
+  var collidable: Boolean = true
+  
+  /**Teil der Stosszahl bei einer Kollision zwischen dieser Form und einer anderen.
+   * Die Stosszahl wird aus dem Produkt der beiden Teile der Formen errechnet.*/
+  var restitution: Double = 0.7
+  
+  /**Teil des Reibungskoeffizienten bei einer Kollision zwischen dieser Form und einer anderen.
+   * Der Reibungskoeffizient wird aus dem Produkt der beiden Teile der Formen errechnet.*/
+  var friction: Double = 0.707
+  
+  /**Position des Schwerpunktes in Welt.*/
+  var pos: Vector2D = Vector2D.Null
+  
+  /**Rotation. Entspricht Laenge des Rotationsvektors.*/
+  var rotation: Double = 0
+  
+  /**Initiale Rotation. (Rotation ohne Koerper)*/
+  var rotation0 = 0.0
+  
+  /**Referenzposition in Koerper. Wird zur Rotation von Formen in Koerpern verwendet.*/
+  var refLocalPos: Vector2D = Vector2D.Null
+  
+  /**Dichte. (Masse pro Flaeche)*/
+  val density: Double
+  
+  /**Volumen. Entspricht eigentlich der Flaeche dieser Form (in 2D) wird aber zum Errechnen der Masse verwendet.*/
+  val volume: Double
+  
+  /**Errechnet die Masse dieser Form. Masse ist gleich Volumen mal Dichte.
+   @return Masse der Form*/
+  def mass = volume * density
+  
+  /**Errechnet Traegheitsmoment zum Schwerpunkt dieser Form.
+   @return Traegheitsmoment zum Schwerpunkt*/
+  val I: Double
+  
+  /**Beinhaltender Koerper.	Sollte nicht selbst bei Initialisierung definiert werden.*/
+  var body: Body = _
+  
+  /**Gibt das umfassende AABB dieser Form zurueck.
+   @return umfassendes AABB*/
+  def AABB: AABB
+  
+  /**Ergibt die Projektion dieser Form auf eine Gerade gegeben durch den
+   * Richtungsvektor <code>axis</code>.
+   * @param axis Richtungsvektor der Geraden
+   * @return Projektion dieser Form*/
+  def project(axis: Vector2D): Projection
+  
+  /**Ermittelt ob der gebene Punkt <code>point</code> in dieser Form enthalten ist.*/
+  def contains(point: Vector2D): Boolean
+  
+  /**Baut einen Koerper aus dieser Form.
+   @return ein Koerper bestehend aus dieser Form. */
+  def asBody = new Body(this)
+  
+  /**Formen mit denen diese Form nicht Kollidiert.*/
+  val transientShapes: collection.mutable.Set[Shape] = collection.mutable.Set()
+  
+  /**Erstellt einen Koerper aus dieser Form und der Form <code>s</code>.*/
+  def ^(s: Shape) = new Body(this, s)
+  
+  /**Erstellt einen Koerper aus dieser Form und den Formen des Koerpers <code>b</code>.*/
+  def ^(b: Body) = {
+    val shapes = this :: b.shapes
+    new Body(shapes: _*)
+  }
+}
+
+object Shape {
+  private var uidCounter = -1
+  private def nextUid = {uidCounter += 1; uidCounter}
+}
diff --git a/src/sims/dynamics/World.scala b/src/sims/dynamics/World.scala
new file mode 100644
index 0000000..d7ac8ae
--- /dev/null
+++ b/src/sims/dynamics/World.scala
@@ -0,0 +1,163 @@
+/*
+ * Simple Mechanics Simulator (SiMS)
+ * copyright (c) 2009 Jakob Odersky
+ * made available under the MIT License
+*/
+
+package sims.dynamics
+
+import sims.geometry._
+import sims.collision._
+import sims.dynamics.joints._
+import scala.collection.mutable._
+
+/**Eine Welt enthaelt und Simuliert ein System aus Koerpern und Verbindungen.*/
+class World {
+  
+  /**Zeitschritt in dem diese Welt die Simulation vorranschreiten laesst.*/
+  var timeStep: Double = 1.0 / 60
+  
+  /**Anzahl der Constraint-Korrekturen pro Zeitschritt.*/
+  var iterations: Int = 10
+  
+  /**Schwerkraft die in dieser Welt herrscht.*/
+  var gravity = Vector2D(0, -9.81)
+  
+  /**Alle Koerper die diese Welt simuliert.*/
+  val bodies = new ArrayBuffer[Body]
+  
+  /**Alle Verbindungen die diese Welt simuliert.*/
+  val joints = new ArrayBuffer[Joint]
+  
+  /**Ueberwachungsfunktionen fuer Koerper.
+   * <p>
+   * Das erste Element des Tuples ist die Ueberschrift und das zweite Element, der Wert.*/
+  val monitors = new ArrayBuffer[(String, Body => String)]
+  
+  /**Kollisionsdetektor dieser Welt.*/
+  val detector: Detector = new GridDetector(this)
+  
+  /**Warnung wenn Koerper schneller als Lichtgeschwindigkeit.*/
+  var overCWarning = false
+  
+  /**Kollisionerkennung.*/
+  var enableCollisionDetection = true
+  
+  /**Positionskorrekturen.*/
+  var enablePositionCorrection = true
+  
+  /**Die minimale, nicht als null geltende Geschwindigkeit.*/
+  var minLinearVelocity: Double = 0.0001
+  
+  /**Die minimale, nicht als null geltende Winkelgeschwindigkeit.*/
+  var minAngularVelocity: Double = 0.0001
+  
+  /**Ergibt alle Formen aus allen Koerpern in dieser Welt.*/
+  def shapes = for (b <- bodies; s <- b.shapes) yield s
+  
+  /**Fuegt dieser Welt einen Koerper hinzu.*/
+  def +=(body: Body) = bodies += body
+  
+  /**Fuegt dieser Welt eine Verbindung hinzu.*/
+  def +=(joint: Joint): Unit = joints += joint
+  
+  /**Fuegt dieser Welt ein vorangefertigtes System vaus Koerpern und Verbindungen hinzu.*/
+  def +=(p: prefabs.Prefab): Unit = {
+    for (b <- p.bodies) this += b
+    for (j <- p.joints) this += j
+  }
+  
+  def ++=(bs: Seq[Body]) = for(b <- bs) this += b
+  
+  /**Entfernt den gegebenen Koerper aus dieser Welt.*/
+  def -=(body: Body): Unit = bodies -= body
+  
+  /**Entfernt die gegebene Verbindung aus dieser Welt.*/
+  def -=(joint: Joint): Unit = joints -= joint
+  
+  /**Entfernt das gegebene System aus Koerpern und Verbindungen aus dieser Welt.*/
+  def -=(p: prefabs.Prefab): Unit = {
+    for (b <- p.bodies) this -= b
+    for (j <- p.joints) this -= j
+  }
+  
+  def --=(bs: Seq[Body]) = for(b <- bs) this -= b
+  
+  /**Entfernt alle Koerper, Verbindungen und Ueberwachungsfunktionen dieser Welt.*/
+  def clear() = {joints.clear(); bodies.clear(); monitors.clear()}
+  
+  /**Aktuelle Zeit in Sekunden dieser Welt. Nach jedem Zeitschritt wird die Zeit erhoeht.*/
+  var time: Double = 0.0
+  
+  /**Simuliert einen von <code>timeStep</code> angegebenen Zeitschritt.
+   * Ihre Aufgabe ist es die Koerper dieser Welt so zu simulieren wie diese sich in einer Welt mit den gegebenen
+   * Bedingungen verhalten wuerden.
+   * <p>
+   * Der Zeitschritt wird in folgenden Phasen ausgefuehrt:
+   * <ol>
+   * <li>Kraefte wirken auf die Koerper (z.B Schwerkraft, andere Kraftfaehige Objekte).</li>
+   * <li>Beschleunigungen werden integriert.</li>
+   * <li>Geschwindigkeiten werden korrigiert.</li>
+   * <li>Geschwindigkeiten werden integriert.</li>
+   * <li>Positionen werden korrigiert.</li>
+   * <li>Die Methode <code>postStep()</code> wird ausgefuehrt.</li>
+   * </ol>*/
+  def step() = {
+    time += timeStep
+    
+    //Kraftobjekte
+    for (j <- joints) j match {case f: ForceJoint => f.applyForce; case _ => ()}
+    
+    //integriert v
+    for (b <- bodies) {
+      val m = b.mass
+      b.applyForce(gravity * b.mass)
+      val a = b.force / b.mass
+      val alpha = b.torque / b.I
+      b.linearVelocity = b.linearVelocity + a * timeStep
+      b.angularVelocity = b.angularVelocity + alpha * timeStep
+    }
+    
+    //korrigiert v
+    for (i <- 0 until iterations){
+      for(c <- joints) c.correctVelocity(timeStep)
+      if (enableCollisionDetection) for (c <- detector.collisions) c.correctVelocity(timeStep)
+    }
+     
+    //integriert pos
+    for (b <- bodies) {
+      //warning when body gets faster than speed of light
+      if (b.linearVelocity.length >= 300000000) overCWarning = true
+      if (b.linearVelocity.length < minLinearVelocity) b.linearVelocity = Vector2D.Null
+      if (b.angularVelocity.abs < minAngularVelocity) b.angularVelocity = 0.0
+      b.pos = b.pos + b.linearVelocity * timeStep
+      b.rotation = b.rotation + b.angularVelocity * timeStep
+      b.force = Vector2D.Null
+      b.torque = 0.0   
+    }
+    
+    //korrigiert pos
+    if (enablePositionCorrection) for (i <- 0 until iterations){
+      for (c <- joints) c.correctPosition(timeStep)
+      if (enableCollisionDetection) for (c <- detector.collisions) c.correctPosition(timeStep)
+    }
+    
+    postStep()
+  }
+  
+  /**Wird nach jedem Zeitschritt ausgefuehrt.*/
+  def postStep() = {}
+  
+  /**Ergibt Informationen ueber diese Welt.*/
+  def info = {
+    "Bodies = " + bodies.length + "\n" +
+    "Shapes = " + shapes.length + "\n" +
+    "Joints = " + joints.length + "\n" +
+    "Collisions = " + detector.collisions.length + "\n" +
+    "Monitors = " +  monitors.length + "\n" +
+    "Gravity = " + gravity + "m/s^2\n" +
+    "Timestep = " + timeStep + "s\n" +
+    "Time = " + time + "s\n" +
+    "Iterations = " + iterations
+  }
+}
diff --git a/src/sims/dynamics/joints/DistanceJoint.scala b/src/sims/dynamics/joints/DistanceJoint.scala
new file mode 100644
index 0000000..2d5633f
--- /dev/null
+++ b/src/sims/dynamics/joints/DistanceJoint.scala
@@ -0,0 +1,76 @@
+/*
+ * Simple Mechanics Simulator (SiMS)
+ * copyright (c) 2009 Jakob Odersky
+ * made available under the MIT License
+*/
+
+package sims.dynamics.joints
+
+import sims.geometry._
+
+/** DistanceJoints halten die Bindungspunkte auf ihren Bindungskoerpern bei einem konstanten Abstand.
+ * @param node1 erster Koerper der Verbindung
+ * @param anchor1 Bindungspunkt auf Koerper eins
+ * @param node2 zweiter Koerper der Verbindung
+ * @param anchor2 Bindungspunkt auf Koerper zwei*/
+case class DistanceJoint(node1: Body, anchor1: Vector2D, node2: Body, anchor2: Vector2D) extends  Joint{
+  def this(node1: Body, node2: Body) = this(node1, node1.pos, node2, node2.pos)
+  
+  /**Abstand der beiden Bindungspunkte bei initialisierung (der gewollte Abstand).*/
+  val distance = (anchor2 - anchor1).length
+  
+  private val a1 = anchor1 - node1.pos
+  private val a2 = anchor2 - node2.pos
+  private val initRotation1 = node1.rotation
+  private val initRotation2 = node2.rotation
+  
+  /**Ergibt den Bindungspunkt auf Koerper eins.*/
+  def connection1 = (a1 rotate (node1.rotation - initRotation1)) + node1.pos
+  
+  /**Ergibt den Bindungspunkt auf Koerper zwei.*/
+  def connection2 = (a2 rotate (node2.rotation - initRotation2)) + node2.pos
+  
+  /**Relative Position der Bindungspunkte.*/
+  def x = connection2 - connection1
+  
+  /**Relative Geschwindigkeit der Bindungspunkte.*/
+  def v = node2.velocityOfPoint(connection2) - node1.velocityOfPoint(connection1)
+  
+  /* x = connection2 - connection1
+     * C = ||x|| - L
+     * u = x / ||x||
+     * v = v2 + w2 cross r2 - v1 - w1 cross r1
+     * Cdot = u dot v
+     * J = [-u	-(r1 cross u)	u	(r2 cross u)]
+     * 1/m = J * M^-1 * JT
+     * = 1/m1 * u * u + 1/m2 * u * u + 1/I1 * (r1 cross u)^2 + 1/I2 * (r2 cross u)^2*/
+  override def correctVelocity(h: Double) = {
+    val x = this.x	//relativer Abstand
+    val v = this.v	//relative Geschwindigkeit
+    val r1 = (connection1 - node1.pos)	//Abstand Punkt-Schwerpunkt, Koerper 1
+    val r2 = (connection2 - node2.pos)	//Abstand Punkt-Schwerpunkt, Koerper 2
+    val cr1 = r1 cross x.unit	//Kreuzprodukt
+    val cr2 = r2 cross x.unit	//Kreuzprodukt
+    val Cdot = x.unit dot v	//Velocity-Constraint
+    val invMass = 1/node1.mass + 1/node1.I * cr1 * cr1 + 1/node2.mass + 1/node2.I * cr2 * cr2	//=J M^-1 JT
+    val m = if (invMass == 0.0) 0.0 else 1/invMass	//Test um Nulldivision zu vermeiden
+    val lambda = -m * Cdot	//=-JV/JM^-1JT
+    val impulse = x.unit * lambda	//P=J lambda
+    node1.applyImpulse(-impulse, connection1)
+    node2.applyImpulse(impulse, connection2) 
+  }
+  
+  override def correctPosition(h: Double) = {
+    val C = x.length - distance
+    val cr1 = (connection1 - node1.pos) cross x.unit
+    val cr2 = (connection2 - node2.pos) cross x.unit
+    val invMass = 1/node1.mass + 1/node1.I * cr1 * cr1 + 1/node2.mass + 1/node2.I * cr2 * cr2
+    val m = if (invMass == 0.0) 0.0 else 1/invMass
+    val impulse = -x.unit * m * C
+    node1.pos -= impulse / node1.mass
+    node2.pos += impulse / node2.mass
+    node1.rotation -= ((connection1 - node1.pos) cross impulse) / node1.I
+    node2.rotation += ((connection2 - node2.pos) cross impulse) / node2.I
+  }
+  
+}
+\ No newline at end of file
diff --git a/src/sims/dynamics/joints/ForceJoint.scala b/src/sims/dynamics/joints/ForceJoint.scala
new file mode 100644
index 0000000..fa17eac
--- /dev/null
+++ b/src/sims/dynamics/joints/ForceJoint.scala
@@ -0,0 +1,14 @@
+/*
+ * Simple Mechanics Simulator (SiMS)
+ * copyright (c) 2009 Jakob Odersky
+ * made available under the MIT License
+*/
+
+package sims.dynamics.joints
+
+/**Eine Verbindung die Kraft auf ihre Bindungskoerper ausueben kann.*/
+trait ForceJoint {
+  
+  /**Uebt eine Kraft auf die Bindungskoerper aus.*/
+  def applyForce(): Unit
+}
diff --git a/src/sims/dynamics/joints/Joint.scala b/src/sims/dynamics/joints/Joint.scala
new file mode 100644
index 0000000..9690af2
--- /dev/null
+++ b/src/sims/dynamics/joints/Joint.scala
@@ -0,0 +1,27 @@
+/*
+ * Simple Mechanics Simulator (SiMS)
+ * copyright (c) 2009 Jakob Odersky
+ * made available under the MIT License
+*/
+
+package sims.dynamics.joints
+
+import sims.geometry._
+import sims.dynamics._
+
+/**Joints sind Verbindungen die die Bewegung zwischen zwei Koerpern einschraenken.
+ * Ihre Implementierung wurde von Erin Catto's box2d inspiriert.*/
+abstract class Joint extends Constraint{
+  
+  /**Erster Koerper der Verbindung.*/
+  val node1: Body
+  
+  /**Zweiter Koerper der Verbindung.*/
+  val node2: Body
+  
+  /**Korrigiert die Geschwindigkeit der Koerper damit diese den Randbedingungen der Verbindung entsprechen.*/
+  def correctVelocity(h: Double): Unit
+  
+  /**Korrigiert die Position der Koerper damit diese den Randbedingungen der Verbindung entsprechen.*/
+  def correctPosition(h: Double): Unit
+}
+\ No newline at end of file
diff --git a/src/sims/dynamics/joints/RevoluteJoint.scala b/src/sims/dynamics/joints/RevoluteJoint.scala
new file mode 100644
index 0000000..7a7ae1c
--- /dev/null
+++ b/src/sims/dynamics/joints/RevoluteJoint.scala
@@ -0,0 +1,55 @@
+/*
+ * Simple Mechanics Simulator (SiMS)
+ * copyright (c) 2009 Jakob Odersky
+ * made available under the MIT License
+*/
+
+package sims.dynamics.joints
+
+import sims.geometry._
+import sims.math._
+import sims.dynamics._
+import Math._
+
+/**Ein Gelenk, dass zwei Koerper an einem Punkt verbindet. Inspiriert von JBox2D.*/
+case class RevoluteJoint(node1: Body, node2: Body, anchor: Vector2D) extends Joint{
+  private val a1 = anchor - node1.pos
+  private val a2 = anchor - node2.pos
+  private val initRotation1 = node1.rotation
+  private val initRotation2 = node2.rotation
+  def connection1 = (a1 rotate (node1.rotation - initRotation1)) + node1.pos
+  def connection2 = (a2 rotate (node2.rotation - initRotation2)) + node2.pos
+  
+  def x = connection2 - connection1
+  def v = node2.velocityOfPoint(connection2) - node1.velocityOfPoint(connection1)
+  
+  /* x = connection2 - connection1
+   * C = x
+   * Cdot = v = v2 - v1 = v2 + (w2 cross r2) - v1 - (w1 cross r1)
+   * J = [-I -r1_skew I r2_skew ] ?????
+   */
+  def correctVelocity(h: Double) = {
+    val m1 = node1.mass
+    val m2 = node2.mass
+    val I1 = node1.I
+    val I2 = node2.I
+    val r1 = connection1 - node1.pos
+    val r2 = connection2 - node2.pos
+   
+    val K1 = new Matrix22(1/m1 + 1/m2,	0,
+                          0,			1/m1 + 1/m2)
+    val K2 = new Matrix22(1/I1 * r1.x * r1.x,	-1/I1 * r1.x * r1.y,
+                          -1/I1 * r1.x * r1.y,	1/I1 * r1.x * r1.x)
+    val K3 = new Matrix22(1/I2 * r2.x * r2.x,	-1/I2 * r2.x * r2.y,
+                          -1/I2 * r2.x * r2.y,	1/I2 * r2.x * r2.x)
+    val pivotMass = (K1 + K2 + K3).invert
+    val cdot = v
+    val p = pivotMass * cdot
+    node1.applyImpulse(p, connection1)
+    node2.applyImpulse(-p, connection2)
+  }
+  
+  def correctPosition(h: Double) = {
+    
+  }
+}
diff --git a/src/sims/dynamics/joints/SpringJoint.scala b/src/sims/dynamics/joints/SpringJoint.scala
new file mode 100644
index 0000000..f03b35d
--- /dev/null
+++ b/src/sims/dynamics/joints/SpringJoint.scala
@@ -0,0 +1,60 @@
+/*
+ * Simple Mechanics Simulator (SiMS)
+ * copyright (c) 2009 Jakob Odersky
+ * made available under the MIT License
+*/
+
+package sims.dynamics.joints
+
+import sims.geometry._
+
+/**Eine Hooksche Feder.
+ * @param node1 erster Koerper der Verbindung
+ * @param anchor1 Bindungspunkt auf Koerper eins
+ * @param node2 zweiter Koerper der Verbindung
+ * @param anchor2 Bindungspunkt auf Koerper zwei
+ * @param springConstant Federkonstante
+ * @param initialLength Initiallaenge
+ */
+case class SpringJoint(node1: Body, anchor1: Vector2D, node2: Body, anchor2: Vector2D, springConstant: Double, initialLength: Double) extends Joint with ForceJoint{
+  
+  def this(node1: Body, anchor1: Vector2D, node2: Body, anchor2: Vector2D, springConstant: Double) = {
+    this(node1: Body, anchor1, node2: Body, anchor2, springConstant: Double, (anchor2 - anchor1).length)
+  }
+  
+  def this(node1: Body, node2: Body, springConstant: Double, initialLength: Double) = {
+    this(node1: Body, node1.pos, node2: Body, node2.pos, springConstant: Double, initialLength: Double)
+  }
+  def this(node1: Body, node2: Body, springConstant: Double) = {
+    this(node1: Body, node1.pos, node2: Body, node2.pos, springConstant: Double, (node2.pos - node1.pos).length)
+  }
+  
+  private val a1 = anchor1 - node1.pos
+  private val a2 = anchor2 - node2.pos
+  private val initRotation1 = node1.rotation
+  private val initRotation2 = node2.rotation
+  
+  /**Ergibt den Bindungspunkt auf Koerper eins.*/
+  def connection1 = (a1 rotate (node1.rotation - initRotation1)) + node1.pos
+  
+  /**Ergibt den Bindungspunkt auf Koerper zwei.*/
+  def connection2 = (a2 rotate (node2.rotation - initRotation2)) + node2.pos
+  
+  /**Daempfung.*/
+  var damping = 0.0
+  
+  /**Relative Position der Bindungspunkte.*/
+  def x = connection2 - connection1
+  
+  /**Ergibt die Federkraft nach dem Hookschen Gesetz.*/
+  def force = (x.length - initialLength) * springConstant
+  
+  /**Uebt die Federkraft auf die Bindungspunkte aus.*/
+  def applyForce() = {
+    node1.applyForce(x.unit * force - ((node1 velocityOfPoint connection1) * damping) project x, connection1)
+    node2.applyForce(-x.unit * force - ((node2 velocityOfPoint connection2) * damping) project x, connection2)
+  }
+  
+  def correctPosition(h: Double) = ()
+  def correctVelocity(h: Double) = ()
+}
+\ No newline at end of file
diff --git a/src/sims/dynamics/joints/test/UnitCircleJoint.scala b/src/sims/dynamics/joints/test/UnitCircleJoint.scala
new file mode 100644
index 0000000..64f613c
--- /dev/null
+++ b/src/sims/dynamics/joints/test/UnitCircleJoint.scala
@@ -0,0 +1,45 @@
+/*
+ * Simple Mechanics Simulator (SiMS)
+ * copyright (c) 2009 Jakob Odersky
+ * made available under the MIT License
+*/
+
+package sims.dynamics.joints.test
+
+import sims.dynamics._
+import sims.geometry._
+
+class UnitCircleJoint(body: Body, anchor: Vector2D) extends Joint{
+  
+  val node1 = body
+  val node2 = body
+  
+  private val a = anchor - body.pos
+  private val initRotation = body.rotation
+  def connection = (a rotate (body.rotation - initRotation)) + body.pos
+  def x = connection
+  def v = body.velocityOfPoint(connection)
+
+  /*
+   * C = ||x|| - 1
+   * Cdot = x/||x|| dot v = u dot v
+   * J = [u	(r cross u)]
+   */
+  def correctVelocity(h: Double) = {
+    val r = connection - body.pos
+    val u = x.unit
+    val cr = r cross u
+    val mc = 1.0/(1/body.mass + 1/body.I * cr * cr)
+    val lambda = -mc * (u dot v)
+    val Pc = u * lambda
+    
+    val vupdate = u * lambda / body.mass
+    val wupdate = (r cross u) * lambda / body.I
+    
+    println("dv = " + vupdate + "	dw = " + wupdate)
+    body.linearVelocity = body.linearVelocity +  u * lambda / body.mass
+    body.angularVelocity = body.angularVelocity + (r cross u) * lambda / body.I 
+  }
+  
+  def correctPosition(h: Double) = {}
+}