/*
* Engine Alpha ist eine anfängerorientierte 2D-Gaming Engine.
*
* Copyright (c) 2011 - 2014 Michael Andonie and contributors.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package ea.internal.collision;
import ea.*;
/**
* Ein Collider ist die abstrakte Form einer <i>Umgebung in der Zeichenebene</i>. Durch das
* Vergleichen von verschiedenen Collidern l�sst sich eine effektive <i>Collision Detection</i>
* erm�glichen, also das Pr�fen auf Kollisionen zweier <code>#ea.Raum</code>-Objekte.
*
* @author Andonie
*/
public abstract class Collider implements Cloneable {
/**
* Der Offset dieses Colliders. Die Verwendung des Offsets hängt von den implementierenden
* Subklassen ab.
*
* @see #offsetSetzen(ea.Vektor)
*/
protected Vektor offset = Vektor.NULLVEKTOR;
/**
* Logische Abfrage für die Kollision zweier Boxen.
*
* @param b1
* Box 1
* @param b2
* Box 2
* @param p1
* Position von Box 1 auf der Zeichenebene
* @param p2
* Position von Box 2 auf der Zeichenebene
*
* @return <code>true</code>, wenn sich beide Boxen bei aktueller Belegung schneiden, sonst
* <code>false</code>.
*/
public static boolean boxboxCollision (BoxCollider b1, BoxCollider b2, Punkt p1, Punkt p2) {
return ((b2.offset.y + p2.y) < (p1.y + b1.offset.y + b1.diagonale.y) && (p2.y + b2.offset.y + b2.diagonale.y) > p1.y + b1.offset.y) &&
(b2.offset.x + p2.x + b2.diagonale.x) > p1.x + b2.offset.x && b2.offset.x + p2.x < (p1.x + b1.offset.x + b1.diagonale.x);
}
/**
* Logische Abfrage für die Kollision zweier Kreise.
*
* @param s1
* Kreis 1
* @param s2
* Kreis 2
* @param p1
* Position von Kreis 1 auf der Zeichenebene
* @param p2
* Position von Kreis 2 auf der Zeichenebene
*
* @return <code>true</code>, wenn sich beide Kreise bei aktueller Belegung schneiden, sonst
* <code>false</code>.
*/
public static boolean spheresphereCollision (SphereCollider s1, SphereCollider s2, Punkt p1, Punkt p2) {
float r1 = s1.durchmesser / 2, r2 = s2.durchmesser / 2;
float dx = (s1.offset.x + p1.x + r1) - (s2.offset.x + p2.x + r2), dy = (s1.offset.y + p1.y + r1) - (s2.offset.y + p2.y + r2);
float summeRadien = (s1.durchmesser + s2.durchmesser) / 2;
//System.out.println("Sphere-Sphere Collision: dx=" + dx + " - dy=" + dy + " - sumRad=" + summeRadien);
return (dx * dx) + (dy * dy) <= summeRadien * summeRadien;
}
/**
* Logische Abfrage für die Kollision eines Kreises mit einer Box.
*
* @param sphere
* Der Kreis
* @param box
* Die Box
* @param ps
* Position von Sphere
* @param pb
* Position von Box
*
* @return <code>true</code>, wenn sich Kreis und Box schneiden, sonst <code>false</code>.
*/
public static boolean sphereboxCollision (SphereCollider sphere, BoxCollider box, Punkt ps, Punkt pb) {
sphere.modelsphere.positionSetzen(ps.verschobenerPunkt(sphere.offset));
for (Dreieck d : sphere.modelsphere.formen()) {
Punkt[] punkte = d.punkte();
for (int i = 0; i < punkte.length; i++) {
if (punkte[i].realX() >= box.offset.x + pb.x && punkte[i].realY() >= box.offset.y + pb.y && punkte[i].realX() <= (box.offset.x + pb.x + box.diagonale.x) && punkte[i].realY() <= (box.offset.y + pb.y + box.diagonale.y)) {
return true;
}
}
}
return false;
}
/**
* Setzt den Offset dieses Colliders neu. <br /><i>Erläuterung</i><br /> Zunächst liegen
* Position vom <code>Raum</code>-Objekt und dem Collider direkt aufeinander. Der Offset wird
* also relativ zur aktuellen Position des <code>Raum</code>-Objektes in der Zeichenebene
* hinzugerechnet, um die endgültige Position des Colliders für die Kollisionsabfragen
* festzulegen.
*
* @param os
* Der neue Offset für diesen Collider.
*
* @see #offset()
*/
public final void offsetSetzen (Vektor os) {
this.offset = os;
}
/**
* Gibt den Offset dieses Vektors relativ zum zugehörigen <code>Raum</code> an.
*
* @return Der Offset dieses Vektors relativ zum zugehörigen <code>Raum</code> an.
*/
public final Vektor offset () {
return offset;
}
/**
* Prüft, ob dieser Collider sich mit einem weiteren Collider schneidet.
*
* @param other
* Ein zweiter Collider.
*
* @return <code>true</code>, falls sich dieser Collider mit dem zweiten Collider schneidet.
* Schneiden sich dieser Collider und der zweite Collider nicht, so gibt diese Funktion
* <code>false</code> zurück.
*/
public abstract boolean verursachtCollision (Punkt positionThis, Punkt positionOther, Collider other);
/**
* Gibt zurück, ob dieser Collider ein <code>NullCollider</code> ist, also nur
* <code>false</code> zur�ckgeben kann.
*
* @return <code>true</code>, falls dieser Collider ein <i>Null-Collider</i> ist, sonst
* <code>false</code>.
*/
public abstract boolean istNullCollider ();
/**
* Gibt eine visuelle Interpretation dieses Colliders als <code>Raum-Objekt</code> aus.
* @param color Die (Füll)Farbe, in der das grafische Objekt ggf. dargestellt werden soll.
* @param p Der Punkt, an dem das zugehörige Objekt derzeit ist.
* @return Ein-Raum-Objekt, das den Collider ideal annähert in Form, Position und Größe. <b>Das ausgegebene
* Objekt ist <u>nicht</u> an der Wurzel angemeldet und wird damit nicht ohne Weiteres grafisch dargestellt.</b>
*/
public abstract Raum visualize(Punkt p, Farbe color);
/**
* Überschriebene Clone-Methode für effizientes, <b>tiefgehendes</b> klonen von Collidern. Das
* bedeutet, dass auch tiefer liegende Referenzen <b>frisch geklont</b> werden, bis in die
* tiefste Referenzebene.
*/
@Override
public abstract Collider clone ();
}