+
\ No newline at end of file
diff --git a/doc/graphyx$content.html b/doc/graphyx$content.html
new file mode 100644
index 0000000..b78a5ec
--- /dev/null
+++ b/doc/graphyx$content.html
@@ -0,0 +1,21 @@
+
+
+ All classes and objects in graphyx
+
+
+
+
\ No newline at end of file
diff --git a/doc/graphyx$package.html b/doc/graphyx$package.html
new file mode 100644
index 0000000..ce0ccc2
--- /dev/null
+++ b/doc/graphyx$package.html
@@ -0,0 +1,14 @@
+
+
+ List of classes and objects in package graphyx
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/graphyx/actors$content.html b/doc/graphyx/actors$content.html
new file mode 100644
index 0000000..03856e4
--- /dev/null
+++ b/doc/graphyx/actors$content.html
@@ -0,0 +1,100 @@
+
+
+ All classes and objects in graphyx.actors
+
+
+
+
\ No newline at end of file
diff --git a/doc/graphyx/actors$package.html b/doc/graphyx/actors$package.html
new file mode 100644
index 0000000..c79a9d8
--- /dev/null
+++ b/doc/graphyx/actors$package.html
@@ -0,0 +1,22 @@
+
+
+ List of classes and objects in package graphyx.actors
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/graphyx/actors/GUIActor.html b/doc/graphyx/actors/GUIActor.html
new file mode 100644
index 0000000..2dbb266
--- /dev/null
+++ b/doc/graphyx/actors/GUIActor.html
@@ -0,0 +1,162 @@
+
+
+ class GUIActor in graphyx.actors
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/graphyx/actors/PhysicsActor.html b/doc/graphyx/actors/PhysicsActor.html
new file mode 100644
index 0000000..53f230e
--- /dev/null
+++ b/doc/graphyx/actors/PhysicsActor.html
@@ -0,0 +1,202 @@
+
+
+ class PhysicsActor in graphyx.actors
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/graphyx/actors/SetWorld.html b/doc/graphyx/actors/SetWorld.html
new file mode 100644
index 0000000..2eacdd1
--- /dev/null
+++ b/doc/graphyx/actors/SetWorld.html
@@ -0,0 +1,276 @@
+
+
+ class SetWorld in graphyx.actors
+
+
+
+
+ The default hashing algorithm is platform dependent.
+ Note that it is allowed for two objects to have identical hash
+ codes (o1.hashCode.equals(o2.hashCode)) yet not be
+ equal (o1.equals(o2) returns false). A
+ degenerate implementation could always return 0.
+ However, it is required that if two objects are equal
+ (o1.equals(o2) returns true) that they
+ have identical hash codes
+ (o1.hashCode.equals(o2.hashCode)). Therefore, when
+ overriding this method, be sure to verify that the behavior is
+ consistent with the equals method.
+
It is reflexive: for any instance x of type Any,
+ x.equals(x) should return true.
+
It is symmetric: for any instances x and y of type
+ Any, x.equals(y) should return true if and only
+ if y.equals(x) returns true.
+
It is transitive: for any instances
+ x, y, and z of type AnyRef
+ if x.equals(y) returns true and
+ y.equals(z) returns
+ true, then x.equals(z) should return true.
+
+
+
+ If you override this method, you should verify that
+ your implementation remains an equivalence relation.
+ Additionally, when overriding this method it is often necessary to
+ override hashCode to ensure that objects that are
+ "equal" (o1.equals(o2) returns true)
+ hash to the same Int
+ (o1.hashCode.equals(o2.hashCode)).
+
+ Parameters
arg0 - the object to compare against this object for equality.
+ Returns
true if the receiver object is equivalent to the argument; false otherwise.
+
+
\ No newline at end of file
diff --git a/doc/graphyx/graphics$content.html b/doc/graphyx/graphics$content.html
new file mode 100644
index 0000000..b9d8189
--- /dev/null
+++ b/doc/graphyx/graphics$content.html
@@ -0,0 +1,332 @@
+
+
+ All classes and objects in graphyx.graphics
+
+
+
+
\ No newline at end of file
diff --git a/doc/graphyx/graphics$package.html b/doc/graphyx/graphics$package.html
new file mode 100644
index 0000000..94f5f77
--- /dev/null
+++ b/doc/graphyx/graphics$package.html
@@ -0,0 +1,43 @@
+
+
+ List of classes and objects in package graphyx.graphics
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/graphyx/graphics/GraphicalAABB.html b/doc/graphyx/graphics/GraphicalAABB.html
new file mode 100644
index 0000000..6855bd7
--- /dev/null
+++ b/doc/graphyx/graphics/GraphicalAABB.html
@@ -0,0 +1,355 @@
+
+
+ class GraphicalAABB in graphyx.graphics
+
+
+
+
+ The default hashing algorithm is platform dependent.
+ Note that it is allowed for two objects to have identical hash
+ codes (o1.hashCode.equals(o2.hashCode)) yet not be
+ equal (o1.equals(o2) returns false). A
+ degenerate implementation could always return 0.
+ However, it is required that if two objects are equal
+ (o1.equals(o2) returns true) that they
+ have identical hash codes
+ (o1.hashCode.equals(o2.hashCode)). Therefore, when
+ overriding this method, be sure to verify that the behavior is
+ consistent with the equals method.
+
It is reflexive: for any instance x of type Any,
+ x.equals(x) should return true.
+
It is symmetric: for any instances x and y of type
+ Any, x.equals(y) should return true if and only
+ if y.equals(x) returns true.
+
It is transitive: for any instances
+ x, y, and z of type AnyRef
+ if x.equals(y) returns true and
+ y.equals(z) returns
+ true, then x.equals(z) should return true.
+
+
+
+ If you override this method, you should verify that
+ your implementation remains an equivalence relation.
+ Additionally, when overriding this method it is often necessary to
+ override hashCode to ensure that objects that are
+ "equal" (o1.equals(o2) returns true)
+ hash to the same Int
+ (o1.hashCode.equals(o2.hashCode)).
+
+ Parameters
arg0 - the object to compare against this object for equality.
+ Returns
true if the receiver object is equivalent to the argument; false otherwise.
+
+
\ No newline at end of file
diff --git a/doc/graphyx/graphics/GraphicalBody.html b/doc/graphyx/graphics/GraphicalBody.html
new file mode 100644
index 0000000..8b3c88d
--- /dev/null
+++ b/doc/graphyx/graphics/GraphicalBody.html
@@ -0,0 +1,383 @@
+
+
+ class GraphicalBody in graphyx.graphics
+
+
+
+
+ The default hashing algorithm is platform dependent.
+ Note that it is allowed for two objects to have identical hash
+ codes (o1.hashCode.equals(o2.hashCode)) yet not be
+ equal (o1.equals(o2) returns false). A
+ degenerate implementation could always return 0.
+ However, it is required that if two objects are equal
+ (o1.equals(o2) returns true) that they
+ have identical hash codes
+ (o1.hashCode.equals(o2.hashCode)). Therefore, when
+ overriding this method, be sure to verify that the behavior is
+ consistent with the equals method.
+
It is reflexive: for any instance x of type Any,
+ x.equals(x) should return true.
+
It is symmetric: for any instances x and y of type
+ Any, x.equals(y) should return true if and only
+ if y.equals(x) returns true.
+
It is transitive: for any instances
+ x, y, and z of type AnyRef
+ if x.equals(y) returns true and
+ y.equals(z) returns
+ true, then x.equals(z) should return true.
+
+
+
+ If you override this method, you should verify that
+ your implementation remains an equivalence relation.
+ Additionally, when overriding this method it is often necessary to
+ override hashCode to ensure that objects that are
+ "equal" (o1.equals(o2) returns true)
+ hash to the same Int
+ (o1.hashCode.equals(o2.hashCode)).
+
+ Parameters
arg0 - the object to compare against this object for equality.
+ Returns
true if the receiver object is equivalent to the argument; false otherwise.
+
+
\ No newline at end of file
diff --git a/doc/graphyx/graphics/GraphicalCircle.html b/doc/graphyx/graphics/GraphicalCircle.html
new file mode 100644
index 0000000..1cf6174
--- /dev/null
+++ b/doc/graphyx/graphics/GraphicalCircle.html
@@ -0,0 +1,369 @@
+
+
+ class GraphicalCircle in graphyx.graphics
+
+
+
+
+ The default hashing algorithm is platform dependent.
+ Note that it is allowed for two objects to have identical hash
+ codes (o1.hashCode.equals(o2.hashCode)) yet not be
+ equal (o1.equals(o2) returns false). A
+ degenerate implementation could always return 0.
+ However, it is required that if two objects are equal
+ (o1.equals(o2) returns true) that they
+ have identical hash codes
+ (o1.hashCode.equals(o2.hashCode)). Therefore, when
+ overriding this method, be sure to verify that the behavior is
+ consistent with the equals method.
+
It is reflexive: for any instance x of type Any,
+ x.equals(x) should return true.
+
It is symmetric: for any instances x and y of type
+ Any, x.equals(y) should return true if and only
+ if y.equals(x) returns true.
+
It is transitive: for any instances
+ x, y, and z of type AnyRef
+ if x.equals(y) returns true and
+ y.equals(z) returns
+ true, then x.equals(z) should return true.
+
+
+
+ If you override this method, you should verify that
+ your implementation remains an equivalence relation.
+ Additionally, when overriding this method it is often necessary to
+ override hashCode to ensure that objects that are
+ "equal" (o1.equals(o2) returns true)
+ hash to the same Int
+ (o1.hashCode.equals(o2.hashCode)).
+
+ Parameters
arg0 - the object to compare against this object for equality.
+ Returns
true if the receiver object is equivalent to the argument; false otherwise.
+
+
\ No newline at end of file
diff --git a/doc/graphyx/graphics/GraphicalCollision.html b/doc/graphyx/graphics/GraphicalCollision.html
new file mode 100644
index 0000000..4d8c1e9
--- /dev/null
+++ b/doc/graphyx/graphics/GraphicalCollision.html
@@ -0,0 +1,363 @@
+
+
+ class GraphicalCollision in graphyx.graphics
+
+
+
+
+ The default hashing algorithm is platform dependent.
+ Note that it is allowed for two objects to have identical hash
+ codes (o1.hashCode.equals(o2.hashCode)) yet not be
+ equal (o1.equals(o2) returns false). A
+ degenerate implementation could always return 0.
+ However, it is required that if two objects are equal
+ (o1.equals(o2) returns true) that they
+ have identical hash codes
+ (o1.hashCode.equals(o2.hashCode)). Therefore, when
+ overriding this method, be sure to verify that the behavior is
+ consistent with the equals method.
+
It is reflexive: for any instance x of type Any,
+ x.equals(x) should return true.
+
It is symmetric: for any instances x and y of type
+ Any, x.equals(y) should return true if and only
+ if y.equals(x) returns true.
+
It is transitive: for any instances
+ x, y, and z of type AnyRef
+ if x.equals(y) returns true and
+ y.equals(z) returns
+ true, then x.equals(z) should return true.
+
+
+
+ If you override this method, you should verify that
+ your implementation remains an equivalence relation.
+ Additionally, when overriding this method it is often necessary to
+ override hashCode to ensure that objects that are
+ "equal" (o1.equals(o2) returns true)
+ hash to the same Int
+ (o1.hashCode.equals(o2.hashCode)).
+
+ Parameters
arg0 - the object to compare against this object for equality.
+ Returns
true if the receiver object is equivalent to the argument; false otherwise.
+
+
\ No newline at end of file
diff --git a/doc/graphyx/graphics/GraphicalDistanceJoint.html b/doc/graphyx/graphics/GraphicalDistanceJoint.html
new file mode 100644
index 0000000..bb001e3
--- /dev/null
+++ b/doc/graphyx/graphics/GraphicalDistanceJoint.html
@@ -0,0 +1,356 @@
+
+
+ class GraphicalDistanceJoint in graphyx.graphics
+
+
+
+
+ The default hashing algorithm is platform dependent.
+ Note that it is allowed for two objects to have identical hash
+ codes (o1.hashCode.equals(o2.hashCode)) yet not be
+ equal (o1.equals(o2) returns false). A
+ degenerate implementation could always return 0.
+ However, it is required that if two objects are equal
+ (o1.equals(o2) returns true) that they
+ have identical hash codes
+ (o1.hashCode.equals(o2.hashCode)). Therefore, when
+ overriding this method, be sure to verify that the behavior is
+ consistent with the equals method.
+
It is reflexive: for any instance x of type Any,
+ x.equals(x) should return true.
+
It is symmetric: for any instances x and y of type
+ Any, x.equals(y) should return true if and only
+ if y.equals(x) returns true.
+
It is transitive: for any instances
+ x, y, and z of type AnyRef
+ if x.equals(y) returns true and
+ y.equals(z) returns
+ true, then x.equals(z) should return true.
+
+
+
+ If you override this method, you should verify that
+ your implementation remains an equivalence relation.
+ Additionally, when overriding this method it is often necessary to
+ override hashCode to ensure that objects that are
+ "equal" (o1.equals(o2) returns true)
+ hash to the same Int
+ (o1.hashCode.equals(o2.hashCode)).
+
+ Parameters
arg0 - the object to compare against this object for equality.
+ Returns
true if the receiver object is equivalent to the argument; false otherwise.
+
+
\ No newline at end of file
diff --git a/doc/graphyx/graphics/GraphicalPair.html b/doc/graphyx/graphics/GraphicalPair.html
new file mode 100644
index 0000000..27ad098
--- /dev/null
+++ b/doc/graphyx/graphics/GraphicalPair.html
@@ -0,0 +1,363 @@
+
+
+ class GraphicalPair in graphyx.graphics
+
+
+
+
+ The default hashing algorithm is platform dependent.
+ Note that it is allowed for two objects to have identical hash
+ codes (o1.hashCode.equals(o2.hashCode)) yet not be
+ equal (o1.equals(o2) returns false). A
+ degenerate implementation could always return 0.
+ However, it is required that if two objects are equal
+ (o1.equals(o2) returns true) that they
+ have identical hash codes
+ (o1.hashCode.equals(o2.hashCode)). Therefore, when
+ overriding this method, be sure to verify that the behavior is
+ consistent with the equals method.
+
It is reflexive: for any instance x of type Any,
+ x.equals(x) should return true.
+
It is symmetric: for any instances x and y of type
+ Any, x.equals(y) should return true if and only
+ if y.equals(x) returns true.
+
It is transitive: for any instances
+ x, y, and z of type AnyRef
+ if x.equals(y) returns true and
+ y.equals(z) returns
+ true, then x.equals(z) should return true.
+
+
+
+ If you override this method, you should verify that
+ your implementation remains an equivalence relation.
+ Additionally, when overriding this method it is often necessary to
+ override hashCode to ensure that objects that are
+ "equal" (o1.equals(o2) returns true)
+ hash to the same Int
+ (o1.hashCode.equals(o2.hashCode)).
+
+ Parameters
arg0 - the object to compare against this object for equality.
+ Returns
true if the receiver object is equivalent to the argument; false otherwise.
+
+
\ No newline at end of file
diff --git a/doc/graphyx/graphics/GraphicalRectangle.html b/doc/graphyx/graphics/GraphicalRectangle.html
new file mode 100644
index 0000000..264601b
--- /dev/null
+++ b/doc/graphyx/graphics/GraphicalRectangle.html
@@ -0,0 +1,376 @@
+
+
+ class GraphicalRectangle in graphyx.graphics
+
+
+
+
+ The default hashing algorithm is platform dependent.
+ Note that it is allowed for two objects to have identical hash
+ codes (o1.hashCode.equals(o2.hashCode)) yet not be
+ equal (o1.equals(o2) returns false). A
+ degenerate implementation could always return 0.
+ However, it is required that if two objects are equal
+ (o1.equals(o2) returns true) that they
+ have identical hash codes
+ (o1.hashCode.equals(o2.hashCode)). Therefore, when
+ overriding this method, be sure to verify that the behavior is
+ consistent with the equals method.
+
It is reflexive: for any instance x of type Any,
+ x.equals(x) should return true.
+
It is symmetric: for any instances x and y of type
+ Any, x.equals(y) should return true if and only
+ if y.equals(x) returns true.
+
It is transitive: for any instances
+ x, y, and z of type AnyRef
+ if x.equals(y) returns true and
+ y.equals(z) returns
+ true, then x.equals(z) should return true.
+
+
+
+ If you override this method, you should verify that
+ your implementation remains an equivalence relation.
+ Additionally, when overriding this method it is often necessary to
+ override hashCode to ensure that objects that are
+ "equal" (o1.equals(o2) returns true)
+ hash to the same Int
+ (o1.hashCode.equals(o2.hashCode)).
+
+ Parameters
arg0 - the object to compare against this object for equality.
+ Returns
true if the receiver object is equivalent to the argument; false otherwise.
+
+
\ No newline at end of file
diff --git a/doc/graphyx/graphics/GraphicalRegularPolygon.html b/doc/graphyx/graphics/GraphicalRegularPolygon.html
new file mode 100644
index 0000000..a86cedf
--- /dev/null
+++ b/doc/graphyx/graphics/GraphicalRegularPolygon.html
@@ -0,0 +1,376 @@
+
+
+ class GraphicalRegularPolygon in graphyx.graphics
+
+
+
+
+ The default hashing algorithm is platform dependent.
+ Note that it is allowed for two objects to have identical hash
+ codes (o1.hashCode.equals(o2.hashCode)) yet not be
+ equal (o1.equals(o2) returns false). A
+ degenerate implementation could always return 0.
+ However, it is required that if two objects are equal
+ (o1.equals(o2) returns true) that they
+ have identical hash codes
+ (o1.hashCode.equals(o2.hashCode)). Therefore, when
+ overriding this method, be sure to verify that the behavior is
+ consistent with the equals method.
+
It is reflexive: for any instance x of type Any,
+ x.equals(x) should return true.
+
It is symmetric: for any instances x and y of type
+ Any, x.equals(y) should return true if and only
+ if y.equals(x) returns true.
+
It is transitive: for any instances
+ x, y, and z of type AnyRef
+ if x.equals(y) returns true and
+ y.equals(z) returns
+ true, then x.equals(z) should return true.
+
+
+
+ If you override this method, you should verify that
+ your implementation remains an equivalence relation.
+ Additionally, when overriding this method it is often necessary to
+ override hashCode to ensure that objects that are
+ "equal" (o1.equals(o2) returns true)
+ hash to the same Int
+ (o1.hashCode.equals(o2.hashCode)).
+
+ Parameters
arg0 - the object to compare against this object for equality.
+ Returns
true if the receiver object is equivalent to the argument; false otherwise.
+
+
\ No newline at end of file
diff --git a/doc/graphyx/graphics/GraphicalRevoluteJoint.html b/doc/graphyx/graphics/GraphicalRevoluteJoint.html
new file mode 100644
index 0000000..3d0ab61
--- /dev/null
+++ b/doc/graphyx/graphics/GraphicalRevoluteJoint.html
@@ -0,0 +1,336 @@
+
+
+ class GraphicalRevoluteJoint in graphyx.graphics
+
+
+
+
+ The default hashing algorithm is platform dependent.
+ Note that it is allowed for two objects to have identical hash
+ codes (o1.hashCode.equals(o2.hashCode)) yet not be
+ equal (o1.equals(o2) returns false). A
+ degenerate implementation could always return 0.
+ However, it is required that if two objects are equal
+ (o1.equals(o2) returns true) that they
+ have identical hash codes
+ (o1.hashCode.equals(o2.hashCode)). Therefore, when
+ overriding this method, be sure to verify that the behavior is
+ consistent with the equals method.
+
It is reflexive: for any instance x of type Any,
+ x.equals(x) should return true.
+
It is symmetric: for any instances x and y of type
+ Any, x.equals(y) should return true if and only
+ if y.equals(x) returns true.
+
It is transitive: for any instances
+ x, y, and z of type AnyRef
+ if x.equals(y) returns true and
+ y.equals(z) returns
+ true, then x.equals(z) should return true.
+
+
+
+ If you override this method, you should verify that
+ your implementation remains an equivalence relation.
+ Additionally, when overriding this method it is often necessary to
+ override hashCode to ensure that objects that are
+ "equal" (o1.equals(o2) returns true)
+ hash to the same Int
+ (o1.hashCode.equals(o2.hashCode)).
+
+ Parameters
arg0 - the object to compare against this object for equality.
+ Returns
true if the receiver object is equivalent to the argument; false otherwise.
+
+
\ No newline at end of file
diff --git a/doc/graphyx/graphics/GraphicalSpringJoint.html b/doc/graphyx/graphics/GraphicalSpringJoint.html
new file mode 100644
index 0000000..5cf80cf
--- /dev/null
+++ b/doc/graphyx/graphics/GraphicalSpringJoint.html
@@ -0,0 +1,356 @@
+
+
+ class GraphicalSpringJoint in graphyx.graphics
+
+
+
+
+ The default hashing algorithm is platform dependent.
+ Note that it is allowed for two objects to have identical hash
+ codes (o1.hashCode.equals(o2.hashCode)) yet not be
+ equal (o1.equals(o2) returns false). A
+ degenerate implementation could always return 0.
+ However, it is required that if two objects are equal
+ (o1.equals(o2) returns true) that they
+ have identical hash codes
+ (o1.hashCode.equals(o2.hashCode)). Therefore, when
+ overriding this method, be sure to verify that the behavior is
+ consistent with the equals method.
+
It is reflexive: for any instance x of type Any,
+ x.equals(x) should return true.
+
It is symmetric: for any instances x and y of type
+ Any, x.equals(y) should return true if and only
+ if y.equals(x) returns true.
+
It is transitive: for any instances
+ x, y, and z of type AnyRef
+ if x.equals(y) returns true and
+ y.equals(z) returns
+ true, then x.equals(z) should return true.
+
+
+
+ If you override this method, you should verify that
+ your implementation remains an equivalence relation.
+ Additionally, when overriding this method it is often necessary to
+ override hashCode to ensure that objects that are
+ "equal" (o1.equals(o2) returns true)
+ hash to the same Int
+ (o1.hashCode.equals(o2.hashCode)).
+
+ Parameters
arg0 - the object to compare against this object for equality.
+ Returns
true if the receiver object is equivalent to the argument; false otherwise.
+
+
\ No newline at end of file
diff --git a/doc/graphyx/graphics/GraphicalWorld.html b/doc/graphyx/graphics/GraphicalWorld.html
new file mode 100644
index 0000000..d04da4e
--- /dev/null
+++ b/doc/graphyx/graphics/GraphicalWorld.html
@@ -0,0 +1,439 @@
+
+
+ class GraphicalWorld in graphyx.graphics
+
+
+
+
+ The default hashing algorithm is platform dependent.
+ Note that it is allowed for two objects to have identical hash
+ codes (o1.hashCode.equals(o2.hashCode)) yet not be
+ equal (o1.equals(o2) returns false). A
+ degenerate implementation could always return 0.
+ However, it is required that if two objects are equal
+ (o1.equals(o2) returns true) that they
+ have identical hash codes
+ (o1.hashCode.equals(o2.hashCode)). Therefore, when
+ overriding this method, be sure to verify that the behavior is
+ consistent with the equals method.
+
It is reflexive: for any instance x of type Any,
+ x.equals(x) should return true.
+
It is symmetric: for any instances x and y of type
+ Any, x.equals(y) should return true if and only
+ if y.equals(x) returns true.
+
It is transitive: for any instances
+ x, y, and z of type AnyRef
+ if x.equals(y) returns true and
+ y.equals(z) returns
+ true, then x.equals(z) should return true.
+
+
+
+ If you override this method, you should verify that
+ your implementation remains an equivalence relation.
+ Additionally, when overriding this method it is often necessary to
+ override hashCode to ensure that objects that are
+ "equal" (o1.equals(o2) returns true)
+ hash to the same Int
+ (o1.hashCode.equals(o2.hashCode)).
+
+ Parameters
arg0 - the object to compare against this object for equality.
+ Returns
true if the receiver object is equivalent to the argument; false otherwise.
+
+
\ No newline at end of file
diff --git a/doc/graphyx/graphics/Scene$object.html b/doc/graphyx/graphics/Scene$object.html
new file mode 100644
index 0000000..e884f9f
--- /dev/null
+++ b/doc/graphyx/graphics/Scene$object.html
@@ -0,0 +1,82 @@
+
+
+ object Scene in graphyx.graphics
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/graphyx/graphics/Scene.html b/doc/graphyx/graphics/Scene.html
new file mode 100644
index 0000000..06bbfe1
--- /dev/null
+++ b/doc/graphyx/graphics/Scene.html
@@ -0,0 +1,439 @@
+
+
+ class Scene in graphyx.graphics
+
+
+
+
+ The default hashing algorithm is platform dependent.
+ Note that it is allowed for two objects to have identical hash
+ codes (o1.hashCode.equals(o2.hashCode)) yet not be
+ equal (o1.equals(o2) returns false). A
+ degenerate implementation could always return 0.
+ However, it is required that if two objects are equal
+ (o1.equals(o2) returns true) that they
+ have identical hash codes
+ (o1.hashCode.equals(o2.hashCode)). Therefore, when
+ overriding this method, be sure to verify that the behavior is
+ consistent with the equals method.
+
It is reflexive: for any instance x of type Any,
+ x.equals(x) should return true.
+
It is symmetric: for any instances x and y of type
+ Any, x.equals(y) should return true if and only
+ if y.equals(x) returns true.
+
It is transitive: for any instances
+ x, y, and z of type AnyRef
+ if x.equals(y) returns true and
+ y.equals(z) returns
+ true, then x.equals(z) should return true.
+
+
+
+ If you override this method, you should verify that
+ your implementation remains an equivalence relation.
+ Additionally, when overriding this method it is often necessary to
+ override hashCode to ensure that objects that are
+ "equal" (o1.equals(o2) returns true)
+ hash to the same Int
+ (o1.hashCode.equals(o2.hashCode)).
+
+ Parameters
arg0 - the object to compare against this object for equality.
+ Returns
true if the receiver object is equivalent to the argument; false otherwise.
+
+
\ No newline at end of file
diff --git a/doc/graphyx/gui$content.html b/doc/graphyx/gui$content.html
new file mode 100644
index 0000000..b402d3b
--- /dev/null
+++ b/doc/graphyx/gui$content.html
@@ -0,0 +1,142 @@
+
+
+ All classes and objects in graphyx.gui
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/graphyx/gui$package.html b/doc/graphyx/gui$package.html
new file mode 100644
index 0000000..d822a38
--- /dev/null
+++ b/doc/graphyx/gui$package.html
@@ -0,0 +1,25 @@
+
+
+ List of classes and objects in package graphyx.gui
+
+
+
+
\ No newline at end of file
diff --git a/doc/graphyx/gui/BodyPopup.html b/doc/graphyx/gui/BodyPopup.html
new file mode 100644
index 0000000..d8fb284
--- /dev/null
+++ b/doc/graphyx/gui/BodyPopup.html
@@ -0,0 +1,251 @@
+
+
+ class BodyPopup in graphyx.gui
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/graphyx/gui/Container.html b/doc/graphyx/gui/Container.html
new file mode 100644
index 0000000..aeb0e25
--- /dev/null
+++ b/doc/graphyx/gui/Container.html
@@ -0,0 +1,181 @@
+
+
+ class Container in graphyx.gui
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/graphyx/gui/ControlPanel.html b/doc/graphyx/gui/ControlPanel.html
new file mode 100644
index 0000000..5352ba1
--- /dev/null
+++ b/doc/graphyx/gui/ControlPanel.html
@@ -0,0 +1,295 @@
+
+
+ class ControlPanel in graphyx.gui
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/graphyx/gui/GrabbedBody.html b/doc/graphyx/gui/GrabbedBody.html
new file mode 100644
index 0000000..4d9f028
--- /dev/null
+++ b/doc/graphyx/gui/GrabbedBody.html
@@ -0,0 +1,141 @@
+
+
+ class GrabbedBody in graphyx.gui
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/graphyx/gui/GravityPanel.html b/doc/graphyx/gui/GravityPanel.html
new file mode 100644
index 0000000..ca9b299
--- /dev/null
+++ b/doc/graphyx/gui/GravityPanel.html
@@ -0,0 +1,292 @@
+
+
+ class GravityPanel in graphyx.gui
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/graphyx/gui/InfoPanel.html b/doc/graphyx/gui/InfoPanel.html
new file mode 100644
index 0000000..94dd11f
--- /dev/null
+++ b/doc/graphyx/gui/InfoPanel.html
@@ -0,0 +1,198 @@
+
+
+ class InfoPanel in graphyx.gui
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/graphyx/gui/MainFrame.html b/doc/graphyx/gui/MainFrame.html
new file mode 100644
index 0000000..fbc978a
--- /dev/null
+++ b/doc/graphyx/gui/MainFrame.html
@@ -0,0 +1,161 @@
+
+
+ class MainFrame in graphyx.gui
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/graphyx/gui/MainPanel.html b/doc/graphyx/gui/MainPanel.html
new file mode 100644
index 0000000..a02c4c1
--- /dev/null
+++ b/doc/graphyx/gui/MainPanel.html
@@ -0,0 +1,329 @@
+
+
+ class MainPanel in graphyx.gui
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/graphyx/gui/OptionsPanel.html b/doc/graphyx/gui/OptionsPanel.html
new file mode 100644
index 0000000..b4f3ec6
--- /dev/null
+++ b/doc/graphyx/gui/OptionsPanel.html
@@ -0,0 +1,625 @@
+
+
+ class OptionsPanel in graphyx.gui
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/graphyx/gui/PopupMenu.html b/doc/graphyx/gui/PopupMenu.html
new file mode 100644
index 0000000..96c8a2e
--- /dev/null
+++ b/doc/graphyx/gui/PopupMenu.html
@@ -0,0 +1,207 @@
+
+
+ class PopupMenu in graphyx.gui
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/graphyx/gui/ShapeInfoPanel.html b/doc/graphyx/gui/ShapeInfoPanel.html
new file mode 100644
index 0000000..452968a
--- /dev/null
+++ b/doc/graphyx/gui/ShapeInfoPanel.html
@@ -0,0 +1,262 @@
+
+
+ class ShapeInfoPanel in graphyx.gui
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/graphyx/gui/WorldPanel.html b/doc/graphyx/gui/WorldPanel.html
new file mode 100644
index 0000000..959812e
--- /dev/null
+++ b/doc/graphyx/gui/WorldPanel.html
@@ -0,0 +1,638 @@
+
+
+ class WorldPanel in graphyx.gui
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/graphyx/tests$content.html b/doc/graphyx/tests$content.html
new file mode 100644
index 0000000..c136e55
--- /dev/null
+++ b/doc/graphyx/tests$content.html
@@ -0,0 +1,188 @@
+
+
+ All classes and objects in graphyx.tests
+
+
+
+
\ No newline at end of file
diff --git a/doc/graphyx/tests$package.html b/doc/graphyx/tests$package.html
new file mode 100644
index 0000000..b3a9adc
--- /dev/null
+++ b/doc/graphyx/tests$package.html
@@ -0,0 +1,30 @@
+
+
+ List of classes and objects in package graphyx.tests
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/graphyx/tests/Cup$object.html b/doc/graphyx/tests/Cup$object.html
new file mode 100644
index 0000000..b3c46a8
--- /dev/null
+++ b/doc/graphyx/tests/Cup$object.html
@@ -0,0 +1,169 @@
+
+
+ object Cup in graphyx.tests
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/graphyx/tests/Net$object.html b/doc/graphyx/tests/Net$object.html
new file mode 100644
index 0000000..3bf8f69
--- /dev/null
+++ b/doc/graphyx/tests/Net$object.html
@@ -0,0 +1,169 @@
+
+
+ object Net in graphyx.tests
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/graphyx/tests/Test.html b/doc/graphyx/tests/Test.html
new file mode 100644
index 0000000..78cec07
--- /dev/null
+++ b/doc/graphyx/tests/Test.html
@@ -0,0 +1,190 @@
+
+
+ trait Test in graphyx.tests
+
+
+
+
+ The default representation is platform dependent.
+
+ Returns
a string representation of the object.
+
+
+
+
+
+
+
+
+
+
+
SiMS
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/index.html b/doc/index.html
new file mode 100644
index 0000000..33257d7
--- /dev/null
+++ b/doc/index.html
@@ -0,0 +1,14 @@
+
+
+ SiMS
+
+
+
+
\ No newline at end of file
diff --git a/doc/modules.html b/doc/modules.html
new file mode 100644
index 0000000..8edb9c7
--- /dev/null
+++ b/doc/modules.html
@@ -0,0 +1,34 @@
+
+
+ List of all packages
+
+
+
Axis Aligned Bounding Boxes, kurz AABBs, sind Rechtecke die eine bestimmte Form umhuellen.
+ Da AABBs nach den X- und Y-Achsen orientiert sind, ermoeglichen sie eine schnelle
+ und einfache Feststellung ob zwei AABBs sich ueberschneiden.
+
\ No newline at end of file
diff --git a/doc/sims/collision$package.html b/doc/sims/collision$package.html
new file mode 100644
index 0000000..0871d60
--- /dev/null
+++ b/doc/sims/collision$package.html
@@ -0,0 +1,30 @@
+
+
+ List of classes and objects in package sims.collision
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/sims/collision/AABB.html b/doc/sims/collision/AABB.html
new file mode 100644
index 0000000..d4759f1
--- /dev/null
+++ b/doc/sims/collision/AABB.html
@@ -0,0 +1,309 @@
+
+
+ class AABB in sims.collision
+
+
+
+
Axis Aligned Bounding Boxes, kurz AABBs, sind Rechtecke die eine bestimmte Form umhuellen.
+ Da AABBs nach den X- und Y-Achsen orientiert sind, ermoeglichen sie eine schnelle
+ und einfache Feststellung ob zwei AABBs sich ueberschneiden.
+
+ Parameters
minVertex - Ortsvektor der minimalen Ecke des AABBs
maxVertex - Ortsvektor der maximalen Ecke des AABBs
+ The default hashing algorithm is platform dependent.
+ Note that it is allowed for two objects to have identical hash
+ codes (o1.hashCode.equals(o2.hashCode)) yet not be
+ equal (o1.equals(o2) returns false). A
+ degenerate implementation could always return 0.
+ However, it is required that if two objects are equal
+ (o1.equals(o2) returns true) that they
+ have identical hash codes
+ (o1.hashCode.equals(o2.hashCode)). Therefore, when
+ overriding this method, be sure to verify that the behavior is
+ consistent with the equals method.
+
It is reflexive: for any instance x of type Any,
+ x.equals(x) should return true.
+
It is symmetric: for any instances x and y of type
+ Any, x.equals(y) should return true if and only
+ if y.equals(x) returns true.
+
It is transitive: for any instances
+ x, y, and z of type AnyRef
+ if x.equals(y) returns true and
+ y.equals(z) returns
+ true, then x.equals(z) should return true.
+
+
+
+ If you override this method, you should verify that
+ your implementation remains an equivalence relation.
+ Additionally, when overriding this method it is often necessary to
+ override hashCode to ensure that objects that are
+ "equal" (o1.equals(o2) returns true)
+ hash to the same Int
+ (o1.hashCode.equals(o2.hashCode)).
+
+ Parameters
arg0 - the object to compare against this object for equality.
+ Returns
true if the receiver object is equivalent to the argument; false otherwise.
+
+
\ No newline at end of file
diff --git a/doc/sims/collision/CircleCollision.html b/doc/sims/collision/CircleCollision.html
new file mode 100644
index 0000000..d305be6
--- /dev/null
+++ b/doc/sims/collision/CircleCollision.html
@@ -0,0 +1,409 @@
+
+
+ class CircleCollision in sims.collision
+
+
+
+
+ The default hashing algorithm is platform dependent.
+ Note that it is allowed for two objects to have identical hash
+ codes (o1.hashCode.equals(o2.hashCode)) yet not be
+ equal (o1.equals(o2) returns false). A
+ degenerate implementation could always return 0.
+ However, it is required that if two objects are equal
+ (o1.equals(o2) returns true) that they
+ have identical hash codes
+ (o1.hashCode.equals(o2.hashCode)). Therefore, when
+ overriding this method, be sure to verify that the behavior is
+ consistent with the equals method.
+
It is reflexive: for any instance x of type Any,
+ x.equals(x) should return true.
+
It is symmetric: for any instances x and y of type
+ Any, x.equals(y) should return true if and only
+ if y.equals(x) returns true.
+
It is transitive: for any instances
+ x, y, and z of type AnyRef
+ if x.equals(y) returns true and
+ y.equals(z) returns
+ true, then x.equals(z) should return true.
+
+
+
+ If you override this method, you should verify that
+ your implementation remains an equivalence relation.
+ Additionally, when overriding this method it is often necessary to
+ override hashCode to ensure that objects that are
+ "equal" (o1.equals(o2) returns true)
+ hash to the same Int
+ (o1.hashCode.equals(o2.hashCode)).
+
+ Parameters
arg0 - the object to compare against this object for equality.
+ Returns
true if the receiver object is equivalent to the argument; false otherwise.
+
+
\ No newline at end of file
diff --git a/doc/sims/collision/Collision.html b/doc/sims/collision/Collision.html
new file mode 100644
index 0000000..8b97de9
--- /dev/null
+++ b/doc/sims/collision/Collision.html
@@ -0,0 +1,259 @@
+
+
+ class Collision in sims.collision
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/sims/collision/Detector.html b/doc/sims/collision/Detector.html
new file mode 100644
index 0000000..7aaa1e4
--- /dev/null
+++ b/doc/sims/collision/Detector.html
@@ -0,0 +1,133 @@
+
+
+ class Detector in sims.collision
+
+
+
+
Ergibt alle Kollisionen zwischen Formen der Welt world.
+
+
+
+
+
+
+
+
+
+
+
+
SiMS
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/sims/collision/GridDetector.html b/doc/sims/collision/GridDetector.html
new file mode 100644
index 0000000..43dc1f6
--- /dev/null
+++ b/doc/sims/collision/GridDetector.html
@@ -0,0 +1,311 @@
+
+
+ class GridDetector in sims.collision
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/sims/collision/Overlap.html b/doc/sims/collision/Overlap.html
new file mode 100644
index 0000000..f76df7e
--- /dev/null
+++ b/doc/sims/collision/Overlap.html
@@ -0,0 +1,276 @@
+
+
+ class Overlap in sims.collision
+
+
+
+
+ The default hashing algorithm is platform dependent.
+ Note that it is allowed for two objects to have identical hash
+ codes (o1.hashCode.equals(o2.hashCode)) yet not be
+ equal (o1.equals(o2) returns false). A
+ degenerate implementation could always return 0.
+ However, it is required that if two objects are equal
+ (o1.equals(o2) returns true) that they
+ have identical hash codes
+ (o1.hashCode.equals(o2.hashCode)). Therefore, when
+ overriding this method, be sure to verify that the behavior is
+ consistent with the equals method.
+
It is reflexive: for any instance x of type Any,
+ x.equals(x) should return true.
+
It is symmetric: for any instances x and y of type
+ Any, x.equals(y) should return true if and only
+ if y.equals(x) returns true.
+
It is transitive: for any instances
+ x, y, and z of type AnyRef
+ if x.equals(y) returns true and
+ y.equals(z) returns
+ true, then x.equals(z) should return true.
+
+
+
+ If you override this method, you should verify that
+ your implementation remains an equivalence relation.
+ Additionally, when overriding this method it is often necessary to
+ override hashCode to ensure that objects that are
+ "equal" (o1.equals(o2) returns true)
+ hash to the same Int
+ (o1.hashCode.equals(o2.hashCode)).
+
+ Parameters
arg0 - the object to compare against this object for equality.
+ Returns
true if the receiver object is equivalent to the argument; false otherwise.
+
+
\ No newline at end of file
diff --git a/doc/sims/collision/Pair.html b/doc/sims/collision/Pair.html
new file mode 100644
index 0000000..15b53bf
--- /dev/null
+++ b/doc/sims/collision/Pair.html
@@ -0,0 +1,257 @@
+
+
+ class Pair in sims.collision
+
+
+
+
It is reflexive: for any instance x of type Any,
+ x.equals(x) should return true.
+
It is symmetric: for any instances x and y of type
+ Any, x.equals(y) should return true if and only
+ if y.equals(x) returns true.
+
It is transitive: for any instances
+ x, y, and z of type AnyRef
+ if x.equals(y) returns true and
+ y.equals(z) returns
+ true, then x.equals(z) should return true.
+
+
+
+ If you override this method, you should verify that
+ your implementation remains an equivalence relation.
+ Additionally, when overriding this method it is often necessary to
+ override hashCode to ensure that objects that are
+ "equal" (o1.equals(o2) returns true)
+ hash to the same Int
+ (o1.hashCode.equals(o2.hashCode)).
+
+ Parameters
arg0 - the object to compare against this object for equality.
+ Returns
true if the receiver object is equivalent to the argument; false otherwise.
+ The default hashing algorithm is platform dependent.
+ Note that it is allowed for two objects to have identical hash
+ codes (o1.hashCode.equals(o2.hashCode)) yet not be
+ equal (o1.equals(o2) returns false). A
+ degenerate implementation could always return 0.
+ However, it is required that if two objects are equal
+ (o1.equals(o2) returns true) that they
+ have identical hash codes
+ (o1.hashCode.equals(o2.hashCode)). Therefore, when
+ overriding this method, be sure to verify that the behavior is
+ consistent with the equals method.
+
+
+
\ No newline at end of file
diff --git a/doc/sims/collision/PolyCircleCollision.html b/doc/sims/collision/PolyCircleCollision.html
new file mode 100644
index 0000000..eb30399
--- /dev/null
+++ b/doc/sims/collision/PolyCircleCollision.html
@@ -0,0 +1,409 @@
+
+
+ class PolyCircleCollision in sims.collision
+
+
+
+
+ The default hashing algorithm is platform dependent.
+ Note that it is allowed for two objects to have identical hash
+ codes (o1.hashCode.equals(o2.hashCode)) yet not be
+ equal (o1.equals(o2) returns false). A
+ degenerate implementation could always return 0.
+ However, it is required that if two objects are equal
+ (o1.equals(o2) returns true) that they
+ have identical hash codes
+ (o1.hashCode.equals(o2.hashCode)). Therefore, when
+ overriding this method, be sure to verify that the behavior is
+ consistent with the equals method.
+
It is reflexive: for any instance x of type Any,
+ x.equals(x) should return true.
+
It is symmetric: for any instances x and y of type
+ Any, x.equals(y) should return true if and only
+ if y.equals(x) returns true.
+
It is transitive: for any instances
+ x, y, and z of type AnyRef
+ if x.equals(y) returns true and
+ y.equals(z) returns
+ true, then x.equals(z) should return true.
+
+
+
+ If you override this method, you should verify that
+ your implementation remains an equivalence relation.
+ Additionally, when overriding this method it is often necessary to
+ override hashCode to ensure that objects that are
+ "equal" (o1.equals(o2) returns true)
+ hash to the same Int
+ (o1.hashCode.equals(o2.hashCode)).
+
+ Parameters
arg0 - the object to compare against this object for equality.
+ Returns
true if the receiver object is equivalent to the argument; false otherwise.
+
+
\ No newline at end of file
diff --git a/doc/sims/collision/PolyCollision.html b/doc/sims/collision/PolyCollision.html
new file mode 100644
index 0000000..dbfe30b
--- /dev/null
+++ b/doc/sims/collision/PolyCollision.html
@@ -0,0 +1,469 @@
+
+
+ class PolyCollision in sims.collision
+
+
+
+
+ The default hashing algorithm is platform dependent.
+ Note that it is allowed for two objects to have identical hash
+ codes (o1.hashCode.equals(o2.hashCode)) yet not be
+ equal (o1.equals(o2) returns false). A
+ degenerate implementation could always return 0.
+ However, it is required that if two objects are equal
+ (o1.equals(o2) returns true) that they
+ have identical hash codes
+ (o1.hashCode.equals(o2.hashCode)). Therefore, when
+ overriding this method, be sure to verify that the behavior is
+ consistent with the equals method.
+
It is reflexive: for any instance x of type Any,
+ x.equals(x) should return true.
+
It is symmetric: for any instances x and y of type
+ Any, x.equals(y) should return true if and only
+ if y.equals(x) returns true.
+
It is transitive: for any instances
+ x, y, and z of type AnyRef
+ if x.equals(y) returns true and
+ y.equals(z) returns
+ true, then x.equals(z) should return true.
+
+
+
+ If you override this method, you should verify that
+ your implementation remains an equivalence relation.
+ Additionally, when overriding this method it is often necessary to
+ override hashCode to ensure that objects that are
+ "equal" (o1.equals(o2) returns true)
+ hash to the same Int
+ (o1.hashCode.equals(o2.hashCode)).
+
+ Parameters
arg0 - the object to compare against this object for equality.
+ Returns
true if the receiver object is equivalent to the argument; false otherwise.
+
+
\ No newline at end of file
diff --git a/doc/sims/dynamics$content.html b/doc/sims/dynamics$content.html
new file mode 100644
index 0000000..256ead8
--- /dev/null
+++ b/doc/sims/dynamics$content.html
@@ -0,0 +1,146 @@
+
+
+ All classes and objects in sims.dynamics
+
+
+
Randbedingungen erben von dem Trait Constraint.
+ Fuer jeden Constraint koennen Position und Geschwindigkeit korrigiert werden.
+ Ihre Implementierung wurde von Erin Catto's box2d inspiriert.
+
\ No newline at end of file
diff --git a/doc/sims/dynamics$package.html b/doc/sims/dynamics$package.html
new file mode 100644
index 0000000..b2430c2
--- /dev/null
+++ b/doc/sims/dynamics$package.html
@@ -0,0 +1,26 @@
+
+
+ List of classes and objects in package sims.dynamics
+
+
+
+
\ No newline at end of file
diff --git a/doc/sims/dynamics/Body$object.html b/doc/sims/dynamics/Body$object.html
new file mode 100644
index 0000000..fe5fec2
--- /dev/null
+++ b/doc/sims/dynamics/Body$object.html
@@ -0,0 +1,75 @@
+
+
+ object Body in sims.dynamics
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/sims/dynamics/Body.html b/doc/sims/dynamics/Body.html
new file mode 100644
index 0000000..20abf83
--- /dev/null
+++ b/doc/sims/dynamics/Body.html
@@ -0,0 +1,659 @@
+
+
+ class Body in sims.dynamics
+
+
+
+
Erstellt einen neuen Koerper der zusaetzlich die Formen von dem Koerper b enthaelt.
+
+ Parameters
b - Koerper mit zusaetzlichen Formen
+ Returns
neuer Koerper
+
+
+
+
+
+
+
+
+
+
+
SiMS
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/sims/dynamics/Circle$object.html b/doc/sims/dynamics/Circle$object.html
new file mode 100644
index 0000000..086b684
--- /dev/null
+++ b/doc/sims/dynamics/Circle$object.html
@@ -0,0 +1,82 @@
+
+
+ object Circle in sims.dynamics
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/sims/dynamics/Circle.html b/doc/sims/dynamics/Circle.html
new file mode 100644
index 0000000..d6807a8
--- /dev/null
+++ b/doc/sims/dynamics/Circle.html
@@ -0,0 +1,456 @@
+
+
+ class Circle in sims.dynamics
+
+
+
+
+ The default hashing algorithm is platform dependent.
+ Note that it is allowed for two objects to have identical hash
+ codes (o1.hashCode.equals(o2.hashCode)) yet not be
+ equal (o1.equals(o2) returns false). A
+ degenerate implementation could always return 0.
+ However, it is required that if two objects are equal
+ (o1.equals(o2) returns true) that they
+ have identical hash codes
+ (o1.hashCode.equals(o2.hashCode)). Therefore, when
+ overriding this method, be sure to verify that the behavior is
+ consistent with the equals method.
+
It is reflexive: for any instance x of type Any,
+ x.equals(x) should return true.
+
It is symmetric: for any instances x and y of type
+ Any, x.equals(y) should return true if and only
+ if y.equals(x) returns true.
+
It is transitive: for any instances
+ x, y, and z of type AnyRef
+ if x.equals(y) returns true and
+ y.equals(z) returns
+ true, then x.equals(z) should return true.
+
+
+
+ If you override this method, you should verify that
+ your implementation remains an equivalence relation.
+ Additionally, when overriding this method it is often necessary to
+ override hashCode to ensure that objects that are
+ "equal" (o1.equals(o2) returns true)
+ hash to the same Int
+ (o1.hashCode.equals(o2.hashCode)).
+
+ Parameters
arg0 - the object to compare against this object for equality.
+ Returns
true if the receiver object is equivalent to the argument; false otherwise.
Randbedingungen erben von dem Trait Constraint.
+ Fuer jeden Constraint koennen Position und Geschwindigkeit korrigiert werden.
+ Ihre Implementierung wurde von Erin Catto's box2d inspiriert.
+
+
\ No newline at end of file
diff --git a/doc/sims/dynamics/Rectangle.html b/doc/sims/dynamics/Rectangle.html
new file mode 100644
index 0000000..a002d40
--- /dev/null
+++ b/doc/sims/dynamics/Rectangle.html
@@ -0,0 +1,431 @@
+
+
+ class Rectangle in sims.dynamics
+
+
+
+
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.
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.
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.
+
+ Returns
Vektoren vom Zentrum dieses Rectecks bis zu den Ecken
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.
+ The default hashing algorithm is platform dependent.
+ Note that it is allowed for two objects to have identical hash
+ codes (o1.hashCode.equals(o2.hashCode)) yet not be
+ equal (o1.equals(o2) returns false). A
+ degenerate implementation could always return 0.
+ However, it is required that if two objects are equal
+ (o1.equals(o2) returns true) that they
+ have identical hash codes
+ (o1.hashCode.equals(o2.hashCode)). Therefore, when
+ overriding this method, be sure to verify that the behavior is
+ consistent with the equals method.
+
It is reflexive: for any instance x of type Any,
+ x.equals(x) should return true.
+
It is symmetric: for any instances x and y of type
+ Any, x.equals(y) should return true if and only
+ if y.equals(x) returns true.
+
It is transitive: for any instances
+ x, y, and z of type AnyRef
+ if x.equals(y) returns true and
+ y.equals(z) returns
+ true, then x.equals(z) should return true.
+
+
+
+ If you override this method, you should verify that
+ your implementation remains an equivalence relation.
+ Additionally, when overriding this method it is often necessary to
+ override hashCode to ensure that objects that are
+ "equal" (o1.equals(o2) returns true)
+ hash to the same Int
+ (o1.hashCode.equals(o2.hashCode)).
+
+ Parameters
arg0 - the object to compare against this object for equality.
+ Returns
true if the receiver object is equivalent to the argument; false otherwise.
+
+
\ No newline at end of file
diff --git a/doc/sims/dynamics/RegularPolygon.html b/doc/sims/dynamics/RegularPolygon.html
new file mode 100644
index 0000000..764f13c
--- /dev/null
+++ b/doc/sims/dynamics/RegularPolygon.html
@@ -0,0 +1,419 @@
+
+
+ class RegularPolygon in sims.dynamics
+
+
+
+
+ The default hashing algorithm is platform dependent.
+ Note that it is allowed for two objects to have identical hash
+ codes (o1.hashCode.equals(o2.hashCode)) yet not be
+ equal (o1.equals(o2) returns false). A
+ degenerate implementation could always return 0.
+ However, it is required that if two objects are equal
+ (o1.equals(o2) returns true) that they
+ have identical hash codes
+ (o1.hashCode.equals(o2.hashCode)). Therefore, when
+ overriding this method, be sure to verify that the behavior is
+ consistent with the equals method.
+
It is reflexive: for any instance x of type Any,
+ x.equals(x) should return true.
+
It is symmetric: for any instances x and y of type
+ Any, x.equals(y) should return true if and only
+ if y.equals(x) returns true.
+
It is transitive: for any instances
+ x, y, and z of type AnyRef
+ if x.equals(y) returns true and
+ y.equals(z) returns
+ true, then x.equals(z) should return true.
+
+
+
+ If you override this method, you should verify that
+ your implementation remains an equivalence relation.
+ Additionally, when overriding this method it is often necessary to
+ override hashCode to ensure that objects that are
+ "equal" (o1.equals(o2) returns true)
+ hash to the same Int
+ (o1.hashCode.equals(o2.hashCode)).
+
+ Parameters
arg0 - the object to compare against this object for equality.
+ Returns
true if the receiver object is equivalent to the argument; false otherwise.
+
+
\ No newline at end of file
diff --git a/doc/sims/dynamics/Shape.html b/doc/sims/dynamics/Shape.html
new file mode 100644
index 0000000..c62245d
--- /dev/null
+++ b/doc/sims/dynamics/Shape.html
@@ -0,0 +1,559 @@
+
+
+ class Shape in sims.dynamics
+
+
+
+
Teil des Reibungskoeffizienten bei einer Kollision zwischen dieser Form und einer anderen.
+ Der Reibungskoeffizient wird aus dem Produkt der beiden Teile der Formen errechnet.
Teil der Stosszahl bei einer Kollision zwischen dieser Form und einer anderen.
+ Die Stosszahl wird aus dem Produkt der beiden Teile der Formen errechnet.
Teil der Stosszahl bei einer Kollision zwischen dieser Form und einer anderen.
+ Die Stosszahl wird aus dem Produkt der beiden Teile der Formen errechnet.
Teil des Reibungskoeffizienten bei einer Kollision zwischen dieser Form und einer anderen.
+ Der Reibungskoeffizient wird aus dem Produkt der beiden Teile der Formen errechnet.
Erstellt einen Koerper aus dieser Form und den Formen des Koerpers b.
+
+
+
+
+
+
+
+
+
+
+
+
SiMS
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/sims/dynamics/World.html b/doc/sims/dynamics/World.html
new file mode 100644
index 0000000..df1948a
--- /dev/null
+++ b/doc/sims/dynamics/World.html
@@ -0,0 +1,692 @@
+
+
+ class World in sims.dynamics
+
+
+
+
Simuliert einen von timeStep 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.
Simuliert einen von timeStep 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.
+
+ Der Zeitschritt wird in folgenden Phasen ausgefuehrt:
+
+
Kraefte wirken auf die Koerper (z.B Schwerkraft, andere Kraftfaehige Objekte).
+
+
\ No newline at end of file
diff --git a/doc/sims/dynamics/joints$content.html b/doc/sims/dynamics/joints$content.html
new file mode 100644
index 0000000..4652a21
--- /dev/null
+++ b/doc/sims/dynamics/joints$content.html
@@ -0,0 +1,101 @@
+
+
+ All classes and objects in sims.dynamics.joints
+
+
+
+
\ No newline at end of file
diff --git a/doc/sims/dynamics/joints$package.html b/doc/sims/dynamics/joints$package.html
new file mode 100644
index 0000000..dde0590
--- /dev/null
+++ b/doc/sims/dynamics/joints$package.html
@@ -0,0 +1,22 @@
+
+
+ List of classes and objects in package sims.dynamics.joints
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/sims/dynamics/joints/DistanceJoint.html b/doc/sims/dynamics/joints/DistanceJoint.html
new file mode 100644
index 0000000..80a0f2d
--- /dev/null
+++ b/doc/sims/dynamics/joints/DistanceJoint.html
@@ -0,0 +1,481 @@
+
+
+ class DistanceJoint in sims.dynamics.joints
+
+
+
+
+ The default hashing algorithm is platform dependent.
+ Note that it is allowed for two objects to have identical hash
+ codes (o1.hashCode.equals(o2.hashCode)) yet not be
+ equal (o1.equals(o2) returns false). A
+ degenerate implementation could always return 0.
+ However, it is required that if two objects are equal
+ (o1.equals(o2) returns true) that they
+ have identical hash codes
+ (o1.hashCode.equals(o2.hashCode)). Therefore, when
+ overriding this method, be sure to verify that the behavior is
+ consistent with the equals method.
+
It is reflexive: for any instance x of type Any,
+ x.equals(x) should return true.
+
It is symmetric: for any instances x and y of type
+ Any, x.equals(y) should return true if and only
+ if y.equals(x) returns true.
+
It is transitive: for any instances
+ x, y, and z of type AnyRef
+ if x.equals(y) returns true and
+ y.equals(z) returns
+ true, then x.equals(z) should return true.
+
+
+
+ If you override this method, you should verify that
+ your implementation remains an equivalence relation.
+ Additionally, when overriding this method it is often necessary to
+ override hashCode to ensure that objects that are
+ "equal" (o1.equals(o2) returns true)
+ hash to the same Int
+ (o1.hashCode.equals(o2.hashCode)).
+
+ Parameters
arg0 - the object to compare against this object for equality.
+ Returns
true if the receiver object is equivalent to the argument; false otherwise.
+
+
\ No newline at end of file
diff --git a/doc/sims/dynamics/joints/Joint.html b/doc/sims/dynamics/joints/Joint.html
new file mode 100644
index 0000000..a577cde
--- /dev/null
+++ b/doc/sims/dynamics/joints/Joint.html
@@ -0,0 +1,194 @@
+
+
+ class Joint in sims.dynamics.joints
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/sims/dynamics/joints/RevoluteJoint.html b/doc/sims/dynamics/joints/RevoluteJoint.html
new file mode 100644
index 0000000..b3059de
--- /dev/null
+++ b/doc/sims/dynamics/joints/RevoluteJoint.html
@@ -0,0 +1,419 @@
+
+
+ class RevoluteJoint in sims.dynamics.joints
+
+
+
+
+ The default hashing algorithm is platform dependent.
+ Note that it is allowed for two objects to have identical hash
+ codes (o1.hashCode.equals(o2.hashCode)) yet not be
+ equal (o1.equals(o2) returns false). A
+ degenerate implementation could always return 0.
+ However, it is required that if two objects are equal
+ (o1.equals(o2) returns true) that they
+ have identical hash codes
+ (o1.hashCode.equals(o2.hashCode)). Therefore, when
+ overriding this method, be sure to verify that the behavior is
+ consistent with the equals method.
+
It is reflexive: for any instance x of type Any,
+ x.equals(x) should return true.
+
It is symmetric: for any instances x and y of type
+ Any, x.equals(y) should return true if and only
+ if y.equals(x) returns true.
+
It is transitive: for any instances
+ x, y, and z of type AnyRef
+ if x.equals(y) returns true and
+ y.equals(z) returns
+ true, then x.equals(z) should return true.
+
+
+
+ If you override this method, you should verify that
+ your implementation remains an equivalence relation.
+ Additionally, when overriding this method it is often necessary to
+ override hashCode to ensure that objects that are
+ "equal" (o1.equals(o2) returns true)
+ hash to the same Int
+ (o1.hashCode.equals(o2.hashCode)).
+
+ Parameters
arg0 - the object to compare against this object for equality.
+ Returns
true if the receiver object is equivalent to the argument; false otherwise.
+
+
\ No newline at end of file
diff --git a/doc/sims/dynamics/joints/SpringJoint.html b/doc/sims/dynamics/joints/SpringJoint.html
new file mode 100644
index 0000000..ba601bb
--- /dev/null
+++ b/doc/sims/dynamics/joints/SpringJoint.html
@@ -0,0 +1,551 @@
+
+
+ class SpringJoint in sims.dynamics.joints
+
+
+
+
+
+ case
+ class
+ SpringJoint(val node1 : Body, val anchor1 : Vector2D, val node2 : Body, val anchor2 : Vector2D, val springConstant : Double, val initialLength : Double)
+
+ The default hashing algorithm is platform dependent.
+ Note that it is allowed for two objects to have identical hash
+ codes (o1.hashCode.equals(o2.hashCode)) yet not be
+ equal (o1.equals(o2) returns false). A
+ degenerate implementation could always return 0.
+ However, it is required that if two objects are equal
+ (o1.equals(o2) returns true) that they
+ have identical hash codes
+ (o1.hashCode.equals(o2.hashCode)). Therefore, when
+ overriding this method, be sure to verify that the behavior is
+ consistent with the equals method.
+
It is reflexive: for any instance x of type Any,
+ x.equals(x) should return true.
+
It is symmetric: for any instances x and y of type
+ Any, x.equals(y) should return true if and only
+ if y.equals(x) returns true.
+
It is transitive: for any instances
+ x, y, and z of type AnyRef
+ if x.equals(y) returns true and
+ y.equals(z) returns
+ true, then x.equals(z) should return true.
+
+
+
+ If you override this method, you should verify that
+ your implementation remains an equivalence relation.
+ Additionally, when overriding this method it is often necessary to
+ override hashCode to ensure that objects that are
+ "equal" (o1.equals(o2) returns true)
+ hash to the same Int
+ (o1.hashCode.equals(o2.hashCode)).
+
+ Parameters
arg0 - the object to compare against this object for equality.
+ Returns
true if the receiver object is equivalent to the argument; false otherwise.
+
+
\ No newline at end of file
diff --git a/doc/sims/geometry$content.html b/doc/sims/geometry$content.html
new file mode 100644
index 0000000..e3cf2bb
--- /dev/null
+++ b/doc/sims/geometry$content.html
@@ -0,0 +1,111 @@
+
+
+ All classes and objects in sims.geometry
+
+
+
+
\ No newline at end of file
diff --git a/doc/sims/geometry$package.html b/doc/sims/geometry$package.html
new file mode 100644
index 0000000..c3a4d63
--- /dev/null
+++ b/doc/sims/geometry$package.html
@@ -0,0 +1,23 @@
+
+
+ List of classes and objects in package sims.geometry
+
+
+
Ueberprueft ob sich der gegebene Punkt point in diesem Polygon befindet.
+
+ Hierzu wird eine Halbgerade von dem Punkt in Richtung der X-Achse gezogen (koennte aber auch beliebig sein).
+ Dann wird die Anzahl der Ueberschneidungen der Halbgeraden mit den Seiten und Ecken des Polygons ermittelt.
+ Ist die Anzahl der Ueberschneidungen ungerade, so befindet sich der Punkt in dem Polygon.
+ Es gibt jedoch Ausnahmen, und zwar wenn die Halbgerade eine Ecke ueberschneidet, ueberschneidet sie sowohl auch zwei Seiten.
+ Daher wird eine generelle Anzahl von Uerberschneidungen errechnet, gegeben durch die Anzahl der Ueberschneidungen mit den Seiten minus
+ die mit den Ecken.
+ Diese Zahl wird dann wie oben geschildert geprueft.
+
+
+
+
+
+
+
+
+
+
+
+
SiMS
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/sims/geometry/Projection$object.html b/doc/sims/geometry/Projection$object.html
new file mode 100644
index 0000000..4b01917
--- /dev/null
+++ b/doc/sims/geometry/Projection$object.html
@@ -0,0 +1,82 @@
+
+
+ object Projection in sims.geometry
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/sims/geometry/Projection.html b/doc/sims/geometry/Projection.html
new file mode 100644
index 0000000..3599777
--- /dev/null
+++ b/doc/sims/geometry/Projection.html
@@ -0,0 +1,328 @@
+
+
+ class Projection in sims.geometry
+
+
+
+
+ The default hashing algorithm is platform dependent.
+ Note that it is allowed for two objects to have identical hash
+ codes (o1.hashCode.equals(o2.hashCode)) yet not be
+ equal (o1.equals(o2) returns false). A
+ degenerate implementation could always return 0.
+ However, it is required that if two objects are equal
+ (o1.equals(o2) returns true) that they
+ have identical hash codes
+ (o1.hashCode.equals(o2.hashCode)). Therefore, when
+ overriding this method, be sure to verify that the behavior is
+ consistent with the equals method.
+
It is reflexive: for any instance x of type Any,
+ x.equals(x) should return true.
+
It is symmetric: for any instances x and y of type
+ Any, x.equals(y) should return true if and only
+ if y.equals(x) returns true.
+
It is transitive: for any instances
+ x, y, and z of type AnyRef
+ if x.equals(y) returns true and
+ y.equals(z) returns
+ true, then x.equals(z) should return true.
+
+
+
+ If you override this method, you should verify that
+ your implementation remains an equivalence relation.
+ Additionally, when overriding this method it is often necessary to
+ override hashCode to ensure that objects that are
+ "equal" (o1.equals(o2) returns true)
+ hash to the same Int
+ (o1.hashCode.equals(o2.hashCode)).
+
+ Parameters
arg0 - the object to compare against this object for equality.
+ Returns
true if the receiver object is equivalent to the argument; false otherwise.
+
+
\ No newline at end of file
diff --git a/doc/sims/geometry/Ray$object.html b/doc/sims/geometry/Ray$object.html
new file mode 100644
index 0000000..199fc55
--- /dev/null
+++ b/doc/sims/geometry/Ray$object.html
@@ -0,0 +1,82 @@
+
+
+ object Ray in sims.geometry
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/sims/geometry/Ray.html b/doc/sims/geometry/Ray.html
new file mode 100644
index 0000000..558153d
--- /dev/null
+++ b/doc/sims/geometry/Ray.html
@@ -0,0 +1,334 @@
+
+
+ class Ray in sims.geometry
+
+
+
+
Ueberprueft ob diese Halbgerade den gegebenen Punkt enthaelt.
+
+ Hierzu wird der Vektor von dem Ursprungspunkt zu dem zu ueberpruefenden Punkt gebildet. Dieser wird dann mit dem Richtungsvektor
+ auf Kolinearitaet geprueft.
Ueberprueft ob diese Halbgerade den gegebenen Punkt enthaelt.
+
+ Hierzu wird der Vektor von dem Ursprungspunkt zu dem zu ueberpruefenden Punkt gebildet. Dieser wird dann mit dem Richtungsvektor
+ auf Kolinearitaet geprueft.
+ The default hashing algorithm is platform dependent.
+ Note that it is allowed for two objects to have identical hash
+ codes (o1.hashCode.equals(o2.hashCode)) yet not be
+ equal (o1.equals(o2) returns false). A
+ degenerate implementation could always return 0.
+ However, it is required that if two objects are equal
+ (o1.equals(o2) returns true) that they
+ have identical hash codes
+ (o1.hashCode.equals(o2.hashCode)). Therefore, when
+ overriding this method, be sure to verify that the behavior is
+ consistent with the equals method.
+
It is reflexive: for any instance x of type Any,
+ x.equals(x) should return true.
+
It is symmetric: for any instances x and y of type
+ Any, x.equals(y) should return true if and only
+ if y.equals(x) returns true.
+
It is transitive: for any instances
+ x, y, and z of type AnyRef
+ if x.equals(y) returns true and
+ y.equals(z) returns
+ true, then x.equals(z) should return true.
+
+
+
+ If you override this method, you should verify that
+ your implementation remains an equivalence relation.
+ Additionally, when overriding this method it is often necessary to
+ override hashCode to ensure that objects that are
+ "equal" (o1.equals(o2) returns true)
+ hash to the same Int
+ (o1.hashCode.equals(o2.hashCode)).
+
+ Parameters
arg0 - the object to compare against this object for equality.
+ Returns
true if the receiver object is equivalent to the argument; false otherwise.
+
+
\ No newline at end of file
diff --git a/doc/sims/geometry/Segment.html b/doc/sims/geometry/Segment.html
new file mode 100644
index 0000000..2cc0453
--- /dev/null
+++ b/doc/sims/geometry/Segment.html
@@ -0,0 +1,441 @@
+
+
+ class Segment in sims.geometry
+
+
+
+
+ The default hashing algorithm is platform dependent.
+ Note that it is allowed for two objects to have identical hash
+ codes (o1.hashCode.equals(o2.hashCode)) yet not be
+ equal (o1.equals(o2) returns false). A
+ degenerate implementation could always return 0.
+ However, it is required that if two objects are equal
+ (o1.equals(o2) returns true) that they
+ have identical hash codes
+ (o1.hashCode.equals(o2.hashCode)). Therefore, when
+ overriding this method, be sure to verify that the behavior is
+ consistent with the equals method.
+
It is reflexive: for any instance x of type Any,
+ x.equals(x) should return true.
+
It is symmetric: for any instances x and y of type
+ Any, x.equals(y) should return true if and only
+ if y.equals(x) returns true.
+
It is transitive: for any instances
+ x, y, and z of type AnyRef
+ if x.equals(y) returns true and
+ y.equals(z) returns
+ true, then x.equals(z) should return true.
+
+
+
+ If you override this method, you should verify that
+ your implementation remains an equivalence relation.
+ Additionally, when overriding this method it is often necessary to
+ override hashCode to ensure that objects that are
+ "equal" (o1.equals(o2) returns true)
+ hash to the same Int
+ (o1.hashCode.equals(o2.hashCode)).
+
+ Parameters
arg0 - the object to compare against this object for equality.
+ Returns
true if the receiver object is equivalent to the argument; false otherwise.
Ein vertikaler Einheitsvektor mit den Komponenten (0;1).
+
+
+
+
+
+
+
+
+
+
+
+
+
SiMS
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/sims/geometry/Vector2D.html b/doc/sims/geometry/Vector2D.html
new file mode 100644
index 0000000..5e541fb
--- /dev/null
+++ b/doc/sims/geometry/Vector2D.html
@@ -0,0 +1,644 @@
+
+
+ class Vector2D in sims.geometry
+
+
+
+
+ The default hashing algorithm is platform dependent.
+ Note that it is allowed for two objects to have identical hash
+ codes (o1.hashCode.equals(o2.hashCode)) yet not be
+ equal (o1.equals(o2) returns false). A
+ degenerate implementation could always return 0.
+ However, it is required that if two objects are equal
+ (o1.equals(o2) returns true) that they
+ have identical hash codes
+ (o1.hashCode.equals(o2.hashCode)). Therefore, when
+ overriding this method, be sure to verify that the behavior is
+ consistent with the equals method.
+
It is reflexive: for any instance x of type Any,
+ x.equals(x) should return true.
+
It is symmetric: for any instances x and y of type
+ Any, x.equals(y) should return true if and only
+ if y.equals(x) returns true.
+
It is transitive: for any instances
+ x, y, and z of type AnyRef
+ if x.equals(y) returns true and
+ y.equals(z) returns
+ true, then x.equals(z) should return true.
+
+
+
+ If you override this method, you should verify that
+ your implementation remains an equivalence relation.
+ Additionally, when overriding this method it is often necessary to
+ override hashCode to ensure that objects that are
+ "equal" (o1.equals(o2) returns true)
+ hash to the same Int
+ (o1.hashCode.equals(o2.hashCode)).
+
+ Parameters
arg0 - the object to compare against this object for equality.
+ Returns
true if the receiver object is equivalent to the argument; false otherwise.
+
+
\ No newline at end of file
diff --git a/doc/sims/math$content.html b/doc/sims/math$content.html
new file mode 100644
index 0000000..871d764
--- /dev/null
+++ b/doc/sims/math$content.html
@@ -0,0 +1,34 @@
+
+
+ All classes and objects in sims.math
+
+
+
+
\ No newline at end of file
diff --git a/doc/sims/math$package.html b/doc/sims/math$package.html
new file mode 100644
index 0000000..ac34016
--- /dev/null
+++ b/doc/sims/math$package.html
@@ -0,0 +1,16 @@
+
+
+ List of classes and objects in package sims.math
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/sims/math/Matrix22.html b/doc/sims/math/Matrix22.html
new file mode 100644
index 0000000..82cf176
--- /dev/null
+++ b/doc/sims/math/Matrix22.html
@@ -0,0 +1,448 @@
+
+
+ class Matrix22 in sims.math
+
+
+
+
Eine 2x2-dimensionale, quadratische Matrix kann auch mit zwei 2-dimensionalen
+ Vektoren erstellt werden. In diesem Fall repraesentiert jeder Vektor eine Spalte.
Eine 2x2-dimensionale, quadratische Matrix kann auch mit zwei 2-dimensionalen
+ Vektoren erstellt werden. In diesem Fall repraesentiert jeder Vektor eine Spalte.
+ The default hashing algorithm is platform dependent.
+ Note that it is allowed for two objects to have identical hash
+ codes (o1.hashCode.equals(o2.hashCode)) yet not be
+ equal (o1.equals(o2) returns false). A
+ degenerate implementation could always return 0.
+ However, it is required that if two objects are equal
+ (o1.equals(o2) returns true) that they
+ have identical hash codes
+ (o1.hashCode.equals(o2.hashCode)). Therefore, when
+ overriding this method, be sure to verify that the behavior is
+ consistent with the equals method.
+
It is reflexive: for any instance x of type Any,
+ x.equals(x) should return true.
+
It is symmetric: for any instances x and y of type
+ Any, x.equals(y) should return true if and only
+ if y.equals(x) returns true.
+
It is transitive: for any instances
+ x, y, and z of type AnyRef
+ if x.equals(y) returns true and
+ y.equals(z) returns
+ true, then x.equals(z) should return true.
+
+
+
+ If you override this method, you should verify that
+ your implementation remains an equivalence relation.
+ Additionally, when overriding this method it is often necessary to
+ override hashCode to ensure that objects that are
+ "equal" (o1.equals(o2) returns true)
+ hash to the same Int
+ (o1.hashCode.equals(o2.hashCode)).
+
+ Parameters
arg0 - the object to compare against this object for equality.
+ Returns
true if the receiver object is equivalent to the argument; false otherwise.
+
+
\ No newline at end of file
diff --git a/doc/sims/prefabs$content.html b/doc/sims/prefabs$content.html
new file mode 100644
index 0000000..dad597c
--- /dev/null
+++ b/doc/sims/prefabs$content.html
@@ -0,0 +1,54 @@
+
+
+ All classes and objects in sims.prefabs
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/sims/prefabs$package.html b/doc/sims/prefabs$package.html
new file mode 100644
index 0000000..490a2cf
--- /dev/null
+++ b/doc/sims/prefabs$package.html
@@ -0,0 +1,17 @@
+
+
+ List of classes and objects in package sims.prefabs
+
+
+
+
\ No newline at end of file
diff --git a/doc/sims/prefabs/Net.html b/doc/sims/prefabs/Net.html
new file mode 100644
index 0000000..0298260
--- /dev/null
+++ b/doc/sims/prefabs/Net.html
@@ -0,0 +1,232 @@
+
+
+ class Net in sims.prefabs
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/sims/prefabs/Pylon.html b/doc/sims/prefabs/Pylon.html
new file mode 100644
index 0000000..cec9b30
--- /dev/null
+++ b/doc/sims/prefabs/Pylon.html
@@ -0,0 +1,272 @@
+
+
+ class Pylon in sims.prefabs
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/sims/prefabs/Ragdoll.html b/doc/sims/prefabs/Ragdoll.html
new file mode 100644
index 0000000..f7cc846
--- /dev/null
+++ b/doc/sims/prefabs/Ragdoll.html
@@ -0,0 +1,432 @@
+
+
+ class Ragdoll in sims.prefabs
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/sims/util$content.html b/doc/sims/util$content.html
new file mode 100644
index 0000000..48b8a1e
--- /dev/null
+++ b/doc/sims/util$content.html
@@ -0,0 +1,56 @@
+
+
+ All classes and objects in sims.util
+
+
+
Objekt mit Hiflsfunktionen fuer komfortables Positionieren von Koerpern.
+
+
+
+
\ No newline at end of file
diff --git a/doc/sims/util$package.html b/doc/sims/util$package.html
new file mode 100644
index 0000000..61c5bdc
--- /dev/null
+++ b/doc/sims/util$package.html
@@ -0,0 +1,18 @@
+
+
+ List of classes and objects in package sims.util
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/sims/util/Polar.html b/doc/sims/util/Polar.html
new file mode 100644
index 0000000..7f3f444
--- /dev/null
+++ b/doc/sims/util/Polar.html
@@ -0,0 +1,302 @@
+
+
+ class Polar in sims.util
+
+
+
+
+ The default hashing algorithm is platform dependent.
+ Note that it is allowed for two objects to have identical hash
+ codes (o1.hashCode.equals(o2.hashCode)) yet not be
+ equal (o1.equals(o2) returns false). A
+ degenerate implementation could always return 0.
+ However, it is required that if two objects are equal
+ (o1.equals(o2) returns true) that they
+ have identical hash codes
+ (o1.hashCode.equals(o2.hashCode)). Therefore, when
+ overriding this method, be sure to verify that the behavior is
+ consistent with the equals method.
+
It is reflexive: for any instance x of type Any,
+ x.equals(x) should return true.
+
It is symmetric: for any instances x and y of type
+ Any, x.equals(y) should return true if and only
+ if y.equals(x) returns true.
+
It is transitive: for any instances
+ x, y, and z of type AnyRef
+ if x.equals(y) returns true and
+ y.equals(z) returns
+ true, then x.equals(z) should return true.
+
+
+
+ If you override this method, you should verify that
+ your implementation remains an equivalence relation.
+ Additionally, when overriding this method it is often necessary to
+ override hashCode to ensure that objects that are
+ "equal" (o1.equals(o2) returns true)
+ hash to the same Int
+ (o1.hashCode.equals(o2.hashCode)).
+
+ Parameters
arg0 - the object to compare against this object for equality.
+ Returns
true if the receiver object is equivalent to the argument; false otherwise.
+
+
\ No newline at end of file
diff --git a/doc/sims/util/RelativeVector.html b/doc/sims/util/RelativeVector.html
new file mode 100644
index 0000000..defc526
--- /dev/null
+++ b/doc/sims/util/RelativeVector.html
@@ -0,0 +1,278 @@
+
+
+ class RelativeVector in sims.util
+
+
+
+