# GLOOP kollisionsabfrage



## charged (21. Jun 2014)

Guten Tag alle Nutzer. Ich schreibe grad an einem programm in GLOOP mit welchem man einen Avatar durch eine Welt voller zufällig generierter Bäume lenkt  

Hauptklasse :

```
import GLOOP.*;


public class Spiel
{
   
     
    GLKamera dieKamera;
     
    GLLicht dasLicht;
    GLTastatur dieTastatur;
    GLBoden    derBoden;
    GLTextur   texSand;
    GLTextur   texCloud;
    GLHimmel   derHimmel;
    Avatar meinAvatar;
    GLKugel   dieSonne;
    GLVektor  vector;
    baum[] derBaum;
    
      
    // Attribute

    // Konstruktor
    public Spiel()
    {
        int i = 1;
        int j = 46;
        
        
        
        
       
        vector = new GLVektor(10000,10000,10000);
        dasLicht = new GLLicht(vector);
        dieTastatur = new GLTastatur();
        
        texSand = new GLTextur("Sand.jpg");
        texCloud = new GLTextur("Himmel.jpg");
        derBoden = new GLBoden(texSand);
        derHimmel = new GLHimmel(texCloud);
        
        meinAvatar = new Avatar();
        dieSonne = new GLKugel(100,100000,100,10000);
        dieSonne.setzeSelbstleuchten(230,255,0);
        derBaum = new baum[1000];
        int beende = 1;
        
      
       
        
        for(int k=0; k<1000; k++)
       {
           derBaum[k] = new baum(k);
            
       }
       
        
            while (/*!dieTastatur.esc() &&*/ beende != 2 ){
                
                
            while(dieTastatur.links()  ||   dieTastatur.istGedrueckt('a')  ||  dieTastatur.istGedrueckt('A') || dieTastatur.rechts() ||  dieTastatur.istGedrueckt('d')  ||  dieTastatur.istGedrueckt('D') || dieTastatur.oben()   ||  dieTastatur.istGedrueckt('w')  ||  dieTastatur.istGedrueckt('W') || dieTastatur.unten()  ||  dieTastatur.istGedrueckt('s')  ||  dieTastatur.istGedrueckt('S'))
            {
            
            
            if (dieTastatur.links()  ||  dieTastatur.istGedrueckt('a')  ||  dieTastatur.istGedrueckt('A') )
            {
            meinAvatar.bewegeLinks();
           }
            
            if (dieTastatur.rechts() ||  dieTastatur.istGedrueckt('d')  ||  dieTastatur.istGedrueckt('D') )
            {
            meinAvatar.bewegeRechts();
            } 
            if (dieTastatur.oben()   ||  dieTastatur.istGedrueckt('w')  ||  dieTastatur.istGedrueckt('W') )
            {
            meinAvatar.bewegeVor();
            }
            if (dieTastatur.unten()  ||  dieTastatur.istGedrueckt('s')  ||  dieTastatur.istGedrueckt('S') )
            {
            meinAvatar.bewegeZurück();
            }
            if (i < 91 && i > 0)
            {
            meinAvatar.rotierep( );
            i++;
            }
            if (i == j) i = -1;
            if (i > -91 && i <0)
            {
            meinAvatar.rotierem();
            i--;
            }
            if (i == -91)
            {
            i = 1;
            j = 91;
            }
           
             for(int k=0; k <1000; k++)
             {
             if(meinAvatar.gibX()   ==  derBaum[k].gibX()
             || meinAvatar.gibZ()   ==  derBaum[k].gibZ())
             {
               beende = 2 ;
               
             }
             
            }
            Sys.warte(1);
            }
            
            meinAvatar.rotationnull();
            j=46;
            i=1;
            }
            
           
            
          Sys.beenden();
        }
        
}
```


Baumdeklaration


```
import GLOOP.*;

class baum{
    
    
    GLQuader  Stamm;
    GLWuerfel Busch;
    
    
    public baum(int k)
    {
       double rnx;
       double rnz;
       rnx = (Math.random()*500000)-250000;
       rnz = (Math.random()*500000)-250000;
      Stamm = new GLQuader(rnx ,300,rnz,100,600,100)   ;    
      Busch = new GLWuerfel(rnx,1000,rnz,800);
      
      
      Stamm.setzeTextur("Stamm.jpg");
      Busch.setzeTextur("Busch.jpg");
        
      
    }
  
    public double gibX(){
    return Stamm.gibX();
    }
    
    public double gibZ(){
    return Stamm.gibZ();  
   }
}
```


die Klasse des Avatars ist denke ich mal, für folgendes Problem nicht verantwortlich:
Die Kollisionsabfrage funktioniert nicht. irgendjemand eine Idee? 


Ich hatte schon einen Post, allerdings hat sich viel geändert und das Problem ist ein ganz anderes, nur leider kann ich den alten post nicht löschen.


----------



## turtle (22. Jun 2014)

Ich rate dir mal jUnit-Tests durchzuführen, bevor du alles zusammensteckst und dann feststellt, es geht nicht.

Mit Tests weisst du dann nämlich schon mal, das deine Kollisionsabfrage funktioniert, was sie derzeit nicht  tut.
Mein Test macht den Kollisionstest "nur" mit einem Baum, sollte aber trotzdem funktionieren.

Deine Probleme sind

Du erstellst einen Baum an "zufälliger" Position,beispielsweise (127849.625, 200230.78) Dann ist es natürlich auch sehr unwahrscheinlich, das dein Avatar dicht neben einem Baum-Stamm steht. Das wäre erst möglich, wenn sich der Avatar wirklich bewegen könnte. Das ist aber für einen Test schlecht, weil du dann bei jedem Test rumrennen musst, bis die Kollisionsabfrage zuschlägt.

Für einen Test besser, finde ich, wäre, wenn ich EINEN Baum genau positionieren kann. Das habe ich mal gemacht und festgestellt, das deine if-Abfrage immer noch nicht stimmt.
Überhaupt verstehe ich vieles von deinem Code nicht, beispielsweise warum der Konstruktor Baum einen Parameter int k hat? Ich habe das geändert und mal die Position "von aussen" reingereicht.

Dann solltest du dich an Konventionen halten und Variable mit einem Kleinbuchstaben, Klassen dagegen mit einem Grossbuchstaben beginnen.


```
import static org.junit.Assert.assertEquals;

import org.junit.Test;

import GLOOP.GLBoden;
import GLOOP.GLHimmel;
import GLOOP.GLKamera;
import GLOOP.GLKugel;
import GLOOP.GLLicht;
import GLOOP.GLQuader;
import GLOOP.GLTastatur;
import GLOOP.GLTextur;
import GLOOP.GLVektor;
import GLOOP.GLWuerfel;
import GLOOP.Sys;

public class TestStammBauch {
	private float NEAR_TOLERANCE = 70F;

	@Test
	public void testAvatarPostion() {
		Avatar meinAvatar = new Avatar();
		Baum derBaum = new Baum(50000, 50000);
		int beende = -1;

		float diffX = Math.abs(meinAvatar.gibX() - derBaum.gibX());
		float diffZ = Math.abs(meinAvatar.gibZ() - derBaum.gibZ());
		System.out.println(diffX + ":" + diffZ);
		if ((diffX <= NEAR_TOLERANCE) || (diffZ <= NEAR_TOLERANCE)) {
			beende = 2;
		}
		assertEquals(2, beende);
	}

	@Test
	public void testAvatarXBoundary() {
		Avatar meinAvatar = new Avatar();
		Baum derBaum = new Baum(50070, 50000);
		int beende = -1;

		float diffX = Math.abs(meinAvatar.gibX() - derBaum.gibX());
		float diffZ = Math.abs(meinAvatar.gibZ() - derBaum.gibZ());
		System.out.println(diffX + ":" + diffZ);
		if ((diffX <= NEAR_TOLERANCE) || (diffZ <= NEAR_TOLERANCE)) {
			beende = 2;
		}
		assertEquals(2, beende);
	}

	@Test
	public void testAvatarZBoundary() {
		Avatar meinAvatar = new Avatar();
		Baum derBaum = new Baum(50000, 50070);
		int beende = -1;

		float diffX = Math.abs(meinAvatar.gibX() - derBaum.gibX());
		float diffZ = Math.abs(meinAvatar.gibZ() - derBaum.gibZ());
		System.out.println(diffX + ":" + diffZ);
		if ((diffX <= NEAR_TOLERANCE) || (diffZ <= NEAR_TOLERANCE)) {
			beende = 2;
		}
		assertEquals(2, beende);
	}

	@Test
	public void testAvatarSligthlyOff() {
		Avatar meinAvatar = new Avatar();
		Baum derBaum = new Baum(50071, 50071);
		int beende = -1;

		float diffX = Math.abs(meinAvatar.gibX() - derBaum.gibX());
		float diffZ = Math.abs(meinAvatar.gibZ() - derBaum.gibZ());
		System.out.println(diffX + ":" + diffZ);
		if ((diffX <= NEAR_TOLERANCE) || (diffZ <= NEAR_TOLERANCE)) {
			beende = 2;
		}
		assertEquals(-1, beende);
	}
}

class Avatar {

	private GLQuader meinBauch;
	private int x;
	private int y;
	private int z;

	public Avatar() {
		x = 50000;
		y = 210;
		z = 50000;
		meinBauch = new GLQuader(x, y, z, 40, 120, 80);
	}

	public int gibX() {
		return x;
	}

	public int gibZ() {
		return z;
	}

	public GLQuader getMeinBauch() {
		return meinBauch;
	}
}

class Baum {
	GLQuader stamm;
	GLWuerfel busch;

	public Baum(int x, int z) {
		stamm = new GLQuader(x, 300, z, 100, 600, 100);
	}

	public float gibZ() {
		return stamm.gibZ();
	}

	public float gibX() {
		return stamm.gibX();
	}

	public GLQuader getStamm() {
		return stamm;
	}

}
```


----------

