Class Debug

java.lang.Object
hoverball.debug.Debug
Direct Known Subclasses:
Break, Circle, Line, Text, X

public abstract class Debug
extends java.lang.Object
Die Klasse Debug stellt die Basis-Klasse für das Graphical Debugging dar. Beim Programmieren von Java-Units hast Du die Möglichkeit, mit dem debug(...)-Befehl grafische Elemente auf dem Screen darzustellen. Diese Elemente sind Objekte der Klasse Debug (oder einer abgeleiteten Klasse) und können auf vielfältige Weise erzeugt und definiert werden:

  • Du benutzt die vordefinierten Debugs aus diesem Package.

  • Debugs sind rekursiv verschachtelbar. Jedes Debug enthält ein (zunächst leeres) Array von Sub-Debugs debugs, welches mit beliebig vielen weiteren Debugs belegt werden kann. Somit entsteht ein rekursiver Baum von Debug-Objekten. Ein Debug zeichnet zuerst sich selbst und anschließend das Array seiner Sub-Debugs.

    Die Zeichenfarbe der Debugs wird dabei vererbt. Die Sub-Debugs eines blauen Debugs sind ebenfalls alle blau, solange sie nicht selbst eine eigene Zeichenfarbe definieren. Mit der Variablen color hast Du die Möglichkeit, eine Zeichenfarbe für Dein Debug anzugeben oder die durchlässige Zeichenfarbe null zu wählen.

    Du kannst also Dein Debug einfach als Kombination von bekannten Debugs definieren. Folgendes Debug zeichnet ein blaues Dreieck:

    class Triangle extends Debug
    {
       Triangle (Vector a, Vector b, Vector c)
       {
          debugs = new Debug[] { new Line(a,b), new Line(b,c), new Line(c,a) };
          color = Color.blue;
       }
    }
    

  • Du leitest die Klasse Debug ab und definierst Dein eigenes Debug, indem Du die Methode paint(...) überschreibst. Debugs werden relativ zur Unit gespeichert und erst im Moment des Zeichnens in absolute Koordinaten übersetzt. Folgendes Debug markiert einen Punkt mit einem kleinen Kreis:
    class O extends Debug
    {
       private Vector o;                            // relative Position zur Unit
     
       public O (Vector o) { this.o = vector(o); }  // speichere relative Position
     
       public void paint (Graphics g, Color color, Color globe, double scale, Sphere sphere, Matrix base, boolean front)
       {
          Vector p = Vector.mul(o,base);            // berechne absolute Position
          if (front ^ p.z > 0) return;              // falsche Seite? return!
     
          Point P = scale(scale,p);                 // skaliere in AWT-Koordinaten
          g.setColor(color(color,globe,p.z));       // setze Zeichenfarbe
          g.drawOval(P.x-6,P.y-6,12,12);            // zeichne den Kreis!
       }
    }
    

Die Farbe des Debugs wird bestimmt durch die Farbangabe im debug(...)-Befehl der Unit oder durch die Farbe der Unit selbst, falls der Aufruf ohne Farbangabe erfolgte.

  • Field Summary

    Fields 
    Modifier and Type Field Description
    java.awt.Color color
    Farbe des Debugs
    Debug[] debugs
    Array der Sub-Debugs
  • Constructor Summary

    Constructors 
    Constructor Description
    Debug()
    Leerer Konstruktor.
  • Method Summary

    Modifier and Type Method Description
    static java.awt.Color color​(java.awt.Color color, java.awt.Color globe, double z)
    Ermittelt die Zeichenfarbe für eine bestimmte Tiefe.
    void paint​(java.awt.Graphics g, java.awt.Color color, java.awt.Color globe, double scale, Sphere sphere, Matrix base, boolean front)
    Frei für das Zeichnen des Debugs auf einen AWT-Graphics-Context.
    static java.awt.Point scale​(double scale, Vector v)
    Ermittelt die AWT-Koordinaten eines Vektors für eine bestimmte Skalierung.
    static Vector vector​(Vector v)
    Liest und korrigiert einen Vektor.

    Methods inherited from class java.lang.Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
  • Field Details

    • color

      public java.awt.Color color
      Farbe des Debugs
    • debugs

      public Debug[] debugs
      Array der Sub-Debugs
  • Constructor Details

    • Debug

      public Debug()
      Leerer Konstruktor.
  • Method Details

    • vector

      public static Vector vector​(Vector v)
      Liest und korrigiert einen Vektor.

      Diese Methode wird sinnvoll im Konstruktor eines Debugs aufgerufen, wenn es darum geht, Positionsvektoren zu übernehmen und zu speichern. Der übergebene Vektor wird kopiert und auf die Länge 1 normiert - somit ist er auf die Skalierung der paint(...)-Methode genau zugeschnitten. Falls der Vektor den Wert (0,0,0) oder null hatte, liefert die Methode den "sphärischen Nullvektor" (0,0,1).

      Parameters:
      v - Vektor
      Returns:
      den korrigierten Vektor
    • scale

      public static java.awt.Point scale​(double scale, Vector v)
      Ermittelt die AWT-Koordinaten eines Vektors für eine bestimmte Skalierung.

      Der Hoverball-Screen ist so orientiert, dass die x-Achse nach oben, die y-Achse nach links und die z-Achse nach vorne ("aus dem Bildschirm heraus") zeigt. Diese Methode projiziert das 3D-Koordinatensystem der Sphäre auf das 2D-Koordinatensystem eines AWT-Graphics-Contexts. Dabei muss angegeben werden, mit wie vielen Pixeln die Einheitslänge skaliert werden soll. Der Koordinatenursprung wird nicht verschoben.

      Parameters:
      scale - Skalierung (in Pixel)
      v - Vektor
      Returns:
      die AWT-Koordinaten
    • color

      public static java.awt.Color color​(java.awt.Color color, java.awt.Color globe, double z)
      Ermittelt die Zeichenfarbe für eine bestimmte Tiefe.

      Um einen perspektivischen Effekt bei der Darstellung der Sphäre zu erzielen, werden Objekte, die weiter im Hintergrund liegen, etwas blasser gezeichnet. Diese Methode ermittelt die reale Zeichenfarbe einer Farbe für eine bestimmte Tiefe. Der Tiefenwert soll zwischen -1 und 1 liegen und der z-Koordinate der normierten Positionsvektoren entsprechen.

      Parameters:
      color - Farbe des Debug
      globe - Farbe der Sphäre
      z - Tiefe
      Returns:
      die reale Zeichenfarbe
    • paint

      public void paint​(java.awt.Graphics g, java.awt.Color color, java.awt.Color globe, double scale, Sphere sphere, Matrix base, boolean front)
      Frei für das Zeichnen des Debugs auf einen AWT-Graphics-Context.

      Diese Methode ist für das Zeichnen des Debugs mit richtiger Perspektive und Farbabstufung verantwortlich. Hierfür können die Methoden scale(...) und color(...) sowie die Klassen aus dem Package hoverball.math gute Dienste leisten. Beachte noch Folgendes:

      • Das Koordinatensystem des Graphics-Contexts ist bereits so verschoben, dass der (0,0)-Punkt in der Mitte der Sphäre liegt.

      • Das Skalierungsmaß ist so gewählt, dass es den Sphären-Radius (anstatt der Hoverball-Einheitslänge) in Pixeln angibt. Das bedeutet, dass Vektoren der Länge 1 unabhängig von der Größe der Sphäre gleich auf die Sphären-Oberfläche skaliert werden.

      • Die Perspektive der Unit wird mit der Matrix base an die Methode übergeben. Um Vektoren aus der Sicht der Unit in die richtige Perspektive zu bringen, reicht eine einfache Multiplikation mit der Matrix base.

      • Vorderseite und Rückseite der Sphäre werden getrennt gezeichnet, um den richtigen Überlappungseffekt von Vordergrund vor Hintergrund zu erzielen. Die Methode paint(...) wird jeweils zweimal aufgerufen. Dabei wird ein Parameter front übergeben, der angibt, ob gerade die Vorderseite oder die Rückseite der Sphäre gezeichnet wird, und der beim Zeichnen des Debugs berücksichtigt werden sollte.
      Parameters:
      g - Graphics-Context
      color - Farbe des Debugs
      globe - Farbe der Sphäre
      scale - Skalierung (Sphären-Radius in Pixeln)
      sphere - Sphäre des Spiels
      base - Matrix der Perspektive
      front - Vorderseite?