Snake mit Bluej

[Thommi]

Hey,
ich bräuchte eure Hilfe bei einem kleinen Problem mit BlueJ, einem Programm mit dem Schülern der Umgang mit Java beigebracht werden soll

Erstmal ganz am anfang: Ich bin ein blutiger Anfänger und deshalb nicht wundern wenn manche sachen unnötog kompliziert sind

Ich hab jetzt seit fast einem Jahr Informatik in der Schule, und dachte mit,, ich könnte auch mal ein Spiel Programmieren und bin dann eben bei dem Handyklassiker Snake gelandet. Aber jetzt zum Thema.

Ich muss die Schlange ja irgendwie zum "kriechen" bekommen, also dass jedes Segment auf den Platz des vorherigen aufrückt, das erste Segment ist steuerbar. Dazu übernehm ich einfach die Koordinaten und setzte sie in ein array und die Segmente rufen diese dann auf.

public void bewegeOben(int Zeit)
    {
         
        if(y>0) 
        {
         x = x;
         y = y - 10 * Zeit ;
         q.setzePosition((int)x, (int)y);
         y=b;  
          ort[0]=x;
          ort[1]=b-10;

}

mit der Funktion steuer ich das erste Segment, entsprechende Methoden gibt es eben auch für links, recht und unten.
Die koordinaten des punktes werden jetzt eben im array gespeichert.

Hiermit rufe ich sie auf, eben abhängig das wievielte Segment es ist und speicher dann auch gleich die Positionen.

 public void Krieche(int n1, int n2, int p)
     {
        q.setzePosition(ort[n1],ort[n2]);
        ort[n1]=ort[p*2];
        ort[n2]=ort[p*2+1];
     }

Wenn ich jetzt die Schlange bewegen will springen erst alle nachfolgenden Segmente zu (0,0) und schließlich auch das erste Segment, ich hab allerdings keine ahnung woran das liegt.
Ich hänge mal meine bisherige Arbeit noch an, vielleicht kann mir jemand helfen.

 

[JavaMeetsBlueJ]

Hi, allen Lesern würde es gut tun, wenn du vielleicht mal ein bischen mehr Code posten würdest, damit man auch Zusammenhänge erkennen kann.

Dein Code ist mir nicht ganz schlüssig. Wieso codest du sowas wie

x=x;

?

MfG

 

[Thommi]

frag mich nicht einfach übersichtlichkeit, wenn ich da schon x und y definier dann schreib ich halt das x noch mal hin mit den zusammmenhängen ist es schon ein bisschen schwierig; das ganze ist eigentlich auf nur 3 Klassen aufgebaut, ich kann die ja mal alle posten:

Erst mal die Hauptklasse:

import java.util.Random;

public class SPIEL implements ITuWas, ITastatur
{   
    private Rechteck Spielfeld;
    private KÖRPER Körper;
    private Taktgeber takt,takt1,takt2,takt3;
    private Taste Pause,Wiederaufnahme,Neustart;
    int a,b,Level,z;
    Bild bild;
    Tastatur t;
    
    public SPIEL()
    {
        Zeichnung.setzeFenstergroesse(1100,800);
        
        Spielfeld = new Rechteck (700,500);
        //bild = new Bild(50,500, "rahmen.jpg");
        Körper = new KÖRPER();
        a=190;
        b=210;
        
        Level= 400;
        
        takt = new Taktgeber();
        takt.setzteZeitZwischenAktionen(Level);
        takt.setzeLink(this);
        takt.setzeID(10);
        
        takt1 = new Taktgeber();
        takt1.setzteZeitZwischenAktionen(Level);
        takt1.setzeLink(this);
        takt1.setzeID(20);
        
        takt2 = new Taktgeber();
        takt2.setzteZeitZwischenAktionen(Level);
        takt2.setzeLink(this);
        takt2.setzeID(30);
        
        takt3 = new Taktgeber();
        takt3.setzteZeitZwischenAktionen(Level);
        takt3.setzeLink(this);
        takt3.setzeID(40);
        
        t= new Tastatur();
        t.setzeLink(this);
        t.meldeAnTaste('w', "up");
        t.meldeAnTaste('a', "left");
        t.meldeAnTaste('s', "down");
        t.meldeAnTaste('d', "right");
        t.meldeAnTaste('+', "lvlup");
        t.meldeAnTaste('-', "lvldown");
        
        StartSchlange();
        z=0;
        
        Pause = new Taste ("Pause", 700, 100, 150,50);
        Pause.setzeLink(this);
        Pause.setzeID(1000);
        
        Neustart = new Taste ("Neustart", 700, 200, 150,50);
        Neustart.setzeLink(this);
        Neustart.setzeID(50);
        
        Wiederaufnahme = new Taste ("Fortfahren", 700, 300, 150,50);
        Wiederaufnahme.setzeLink(this);
        Wiederaufnahme.setzeID(90);
        
        //SchnickSchnack = new Taste ("SchnickSchnack", 700, 100, 150,50);
        //SchnickSchnack.setzeLink(this);
        //SchnickSchnack.setzeID(60);
        
        //SchnickSchnack = new Taste ("SchnickSchnack", 700, 100, 150,50);
        //SchnickSchnack.setzeLink(this);
        //SchnickSchnack.setzeID(70);
        
        //SchnickSchnack = new Taste ("SchnickSchnack", 700, 100, 150,50);
        //SchnickSchnack.setzeLink(this);
        //SchnickSchnack.setzeID(80);
        
        
       
              
    }
    
    public void tastenAktion(String r)
       {
        if(r.equals("up"))
        {
           Up();
        }
        if(r.equals("down"))
        {
            Down();
        }
        if(r.equals("left"))
        {
            Left();
        }
        if(r.equals("right"))
        {
            Right();
        }
        if(r.equals("lvlup"))
        {
            if(Level>100)
            {
                Level=Level-100;
            }
        }
        if(r.equals("lvldown"))
        {
            if(Level<1000)
            {
                Level=Level+100;
            }
        }
       }
    
    public void tuWas(int ID)
    {
        if(ID == 10) 
        {
            ticke();
        }
        else if(ID == 20) 
        {
           ticke1();
        }
        else if(ID == 30)
        {
            ticke2();
        }
        else if(ID == 40)
        {
            ticke3();
        }
        else if(ID == 1000)
        {
            Stoppe();
        }
        else if(ID == 50)
        {
            //Neustart();
        }
        else if(ID == 60)
        {
            //SchnickSchnackMethode();
        }
        else if(ID == 70)
        {
           //SchnickSchnackMethode();
        }
        else if(ID == 80)
        {
            //SchnickSchnackMethode();
        }
        else if(ID == 90)
        {
            //Fortfahren();
        }
    }
    
         private void ticke()
       {
         Körper.bewegeO(1);
         z=1;
       }
       private void ticke1()
       {
         Körper.bewegeU(1);
         z=2;
       }
       private void ticke2()
       {
         Körper.bewegeL(1);
         z=3;
       }
       private void ticke3()
       {
         Körper.bewegeR(1);
         z=4;
       }
    
    public void Up ()
    {
        if(z==1 || z==2 )
       {
       }
        else
       {
            takt1.stop();
            takt2.stop();
            takt3.stop();
            takt.endlos();
       }
    }
    public void Down ()
    {
        if(z==2 || z==1)
       {
       }
        else
      {
            takt.stop();
            takt2.stop();
            takt3.stop();
            takt1.endlos();
       }
    }
    public void Left ()
    {
        
        if(z==3 || z==4)
        {
        }
        else
       {
        takt1.stop();
        takt3.stop();
        takt.stop();
        takt2.endlos();
       }
    }
    
    public void Right ()
    {
       if(z==4 || z==3)
        {
        }
       else
       {takt1.stop();
        takt2.stop();
        takt.stop();
        takt3.endlos();
       }
    }
    
    public void StartSchlange()
    {
      
          for(int i=0; i<5; i++)
         {
             SEGMENT n = new SEGMENT(200-i*10,210,Körper);
             Körper.fuegeSegmentHinzu(n);
        }
    }
    
    public void Wachse ()
    {
        
            SEGMENT n = new SEGMENT(a,b,Körper);
            Körper.fuegeSegmentHinzu(n);
        
     }
    
    public void Stoppe()
    {
            takt.stop();
            takt1.stop();
            takt2.stop();
            takt3.stop();
    }
     
}

Die bezieht sich dann eben auf

public class KÖRPER
{
    private SEGMENT[] s;
    private int anzahl;
    
    
    public KÖRPER ()
    {
        anzahl = 0;
        s = new SEGMENT[1000];
    
    }
    
    public void fuegeSegmentHinzu (SEGMENT elementNeu)
    {
        if (anzahl < 1000)
        {
         s[anzahl] = elementNeu;
         anzahl = anzahl + 1;
        }
    }
    
    public void bewegeO(int Zeit)
    {
        s[0].bewegeOben(Zeit);
        for(int i=0;i<anzahl-1;i++)
        {
            s[i+1].Krieche(i*2,1+i*2,i+1);
        }
       
    }
    
    public void bewegeU(int Zeit)
    {
        s[0].bewegeUnten(Zeit);
    }
    
    public void bewegeL(int Zeit)
    {
        s[0].bewegeLinks(Zeit);
    }
    
    public void bewegeR(int Zeit)
    {
        s[0].bewegeRechts(Zeit);
    }

und auf

import java.util.Random;
public class SEGMENT 
{
    private Quadrat q;
    private int x;
    private int y;
    private int[] ort;
    //anzahl der koordinaten
    int b;

      
    
   
    public SEGMENT(int xStart, int yStart, KÖRPER r)
    {
        x= xStart;
        y= yStart;
        q=new Quadrat(x, y, 10);
        ort=new int[10000000];
        b=0;
      
    }
    
    public void bewegeOben(int Zeit)
    {
         
        if(y>0) 
        {
         x = x;
         y = y - 10 * Zeit ;
         q.setzePosition((int)x, (int)y);
         y=b;  
          ort[0]=x;
          ort[1]=b-10;
         
        }
    }   
    public void bewegeUnten(int Zeit)
    {
         if(x<600 && y<400 && x>-1 && y>-1) 
        {
         x = x ;
         y = y +10 * Zeit ;
         q.setzePosition((int)x, (int)y);
         // ort[0]=x;
         //ort[1]=y-10;
       }
      
    }   
    public void bewegeLinks(int Zeit)
    {
         if(x<600 && y<400 && x>-1 && y>-1) 
       {
        x = x - 10 * Zeit;
        y = y;
        q.setzePosition((int)x, (int)y);
        //ort[0]=x+10;
        // ort[1]=y;
       }
    }   
    public void bewegeRechts(int Zeit)
    {
        if(x<600 && y<400 && x>-1 && y>-1) 
       {
        x = x + 10 * Zeit;
        y = y;
        q.setzePosition((int)x, (int)y);
        //ort[0]=x-10;
        // ort[1]=y;
       }
    }  
    
    public void Krieche(int n1, int n2, int p)
     {
        q.setzePosition(ort[n1],ort[n2]);
        ort[n1]=ort[p*2];
        ort[n2]=ort[p*2+1];
     }
    
     }

Falls ein paar ungereimtheiten drin sind, liegt das unteranderem daran dass ich einfach noch nicht fertig bin und jetzt erst einamal die bewegung "zum laufen" bringen will

Im voraus danke an alle die mir helfen

 

[JavaMeetsBlueJ]

Also ich habe jetzt nicht she rviel davon gelesen, aber was dir später und auch jetzt schon viel schreibarbeit erspart und den Code lesbarer macht ist der verkettet Konstruktoraufruf:

statt

        takt1 = new Taktgeber();
        takt1.setzteZeitZwischenAktionen(Level);
        takt1.setzeLink(this);
        takt1.setzeID(20);
        
        takt2 = new Taktgeber();
        takt2.setzteZeitZwischenAktionen(Level);
        takt2.setzeLink(this);
        takt2.setzeID(30);
        
        takt3 = new Taktgeber();
        takt3.setzteZeitZwischenAktionen(Level);
        takt3.setzeLink(this);
        takt3.setzeID(40);

Gestalte den Konstruktor folgend:
Einen Parameterlosen Konstruktor

public Taktgeber()
{
  setzteZeitZwischenAktionen(Level);
  setzeLink(this);


}

Und einen mit Parameter:

public Taktgeber( int id)
{
 this();
 setzeID(id);

}

Das this() ruft denjenigen Konstruktor auf, der dieselbe Paramneterliste besitzt, in dem Fall also den ohne Argumente.

Dann musst du nur folgende Aufrufe machen:

        takt1 = new Taktgeber(20);

        takt2 = new Taktgeber(30);

        takt3 = new Taktgeber(40);

Auch wenn ich dir deine Frage nicht beantworten konnte, hoffe ich mal, dass dir das ein klein wenig hilft

MfG

 

[Thommi]

Hat schon ein wenig geholfen, danke habs ein bisschen übersichtlicher hinbekommen, (wirklich nur ein bisschen aber immerhin)
Aber wie gesagt ist das leider nicht das hauptproblem aber auf jedenfall trotzdem danke

 

[bigbonghit420]

hi

kann mir jmd pls ein spiel programmieren
mit sas

 

[mrBrown]

hi

kann mir jmd pls ein spiel programmieren
mit sas

Bitte keine Jahre alten Threads ausgraben, sondern einen neuen eröffnen.

 

[natnael.michael]

Hey,
Hast du noch den ganzen Quelltext

 

[mrBrown]

Hey,
Hast du noch den ganzen Quelltext

Auch an dich der Hinweis: Bitte keine Jahre alten Threads ausgraben, sondern einen neuen eröffnen.