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.

1
2
3
4
5
6
7
8
9
10
11
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.

1
2
3
4
5
6
 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

1
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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
        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

1
2
3
4
5
7
public Taktgeber()
{
  setzteZeitZwischenAktionen(Level);
  setzeLink(this);
 
}

Und einen mit Parameter:

1
2
3
4
5
6
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:

1
2
3
4
5
        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