# Pyramide



## Hendrik-HSV (26. Nov 2015)

Hey Leute   Ich würde gerne so eine Pyramide wie im Anhang programmieren, sodass der Nutzer eingeben kann aus wie vielen Blöcken das 'Fundament' besteht und der Farbverlauf soll auch so sein wie gezeigt ((new Color(255, 0, 0)Farbe vom untersten Block) und ((new Color(255, 220, 220)Farbe vom obersten Block) die Blöcke sollen 'GRects' aus dem ACM paket sein. Vielen Dank schonmal!


----------



## neulii (26. Nov 2015)

Und deine Frage wäre dann was?


----------



## Hendrik-HSV (26. Nov 2015)

Meine Frage wäre wie ich sowas programmiere


----------



## Joose (26. Nov 2015)

Hendrik-HSV hat gesagt.:


> ......die Blöcke sollen 'GRects' aus dem ACM paket sein



Was sind "GRects" und was ist das "ACM Paket"?



Hendrik-HSV hat gesagt.:


> Meine Frage wäre wie ich sowas programmiere



Dann fange doch einfach mal an Code zu schreiben. 
Fange damit an zuerst einen Stein zu zeichen, dann zwei nebeneinander.
Danach eine Pyramide aus 3 Steinen.
Wenn das funktioniert sollte es ein leichtes eine größere zu Zeichnen.

Wenn du eine konkrete Frage hast helfen wir dir gerne weiter.


----------



## Hendrik-HSV (26. Nov 2015)

Mein Problem ist ja dass der Nutzer eingeben soll wie viele Steine das Fundament hat und demnach die pyramide ausgegeben werden soll. Eine pyramide zu zeichnen bekomme ich auch hin. Also das ist die Aufgabenstellung:

This assignment would have been way cooler if we actually used Scheme as our programming language of choice, but alas... Java it is. Anyway, your assignment is to write a program Pyramid that extends GraphicsProgram. The program is supposed to draw a pyramid with rectangles, as such:






Before drawing the pyramid, it should ask the user for the number of bricks in the bottom layer. Also, as you can see in the picture, each layer of bricks should have a different colour. The bottom layer uses plain red (new Color(255, 0, 0)), while the top layer uses a very bright red (new Color(255, 220, 220)). The layers in between should smoothly interpolate from plain red to very bright red.


----------



## Khal Drogo (26. Nov 2015)

Und wo genau hängst du jetzt beim Programmieren? Was funktioniert bis jetzt, wie sieht dein Algorithmus aus, ...?

Mit freundlichen Grüßen
Xelsarion


----------



## Hendrik-HSV (26. Nov 2015)

```
import java.awt.Color;

import acm.graphics.GRect;
import acm.program.GraphicsProgram;

public class Pyramid extends GraphicsProgram {
    public void run() {
        int n = readInt("Enter the number of bricks in the bottom layer: ");
        int i = 0;
while(i<n)
        for (i = 0; i < n; ++i) {
            GRect Bottom = new GRect(50*i, 500-(i*20), 50, 20 );
            Bottom.setFilled(true);
            Bottom.setColor(new Color(255, 220, 220));
            add(Bottom);
           
            GRect Bottom2 = new GRect(50*i, 500-(i*20), 50, 20 );
            Bottom2.setFilled(false);
            add(Bottom2);
        }
       
    }
}

Möglichkeit 1 da erstelle ich mir ja eine Art Treppe aber wie bekomme ich jetzt die Schichten hin
```


----------



## Hendrik-HSV (26. Nov 2015)

```
import java.awt.Color;

import acm.graphics.GRect;
import acm.program.GraphicsProgram;

public class Pyramid extends GraphicsProgram {
    public void run() {
        int n = readInt("Enter the number of bricks in the bottom layer: ");
        int i = 0;
        for (i = 0; i < n; ++i) {
            GRect Bottom = new GRect(50*i, 500, 50, 20 );
            Bottom.setFilled(true);
            Bottom.setColor(new Color(255, 220, 220));
            add(Bottom);
           
            GRect Bottom2 = new GRect(50*i, 500, 50, 20 );
            Bottom2.setFilled(false);
            add(Bottom2);
        }
       
    }
}
und das wäre Möglichkeit 2 da hab ich dann nur die unterste Schicht
```


----------



## Khal Drogo (26. Nov 2015)

Warum erstellst du zwei Blöcke in einem Schleifendurchlauf?
Passt deine Farbe so nicht, da musst du wohl etwas mit der Zählvariable arbeiten.
Welche Funktion soll dein _while(i<n)_ in Möglichkeit 1 übernehmen?
Musst du deine x- & y-Parameter anders anpassen, da es so nicht funktionieren kann.
Mit freundlichen Grüßen
Xelsarion


----------



## Hendrik-HSV (26. Nov 2015)

1.Die 2 Blöcke erstelle ich weil ich bei dem 'true' Block ja nur einen roten bekommen, ohne die schwarze Umrandung
2. Die Farbe passt nicht, allerdings habe ich da auch noch nicht dran gearbeitet 
3. Ich glaube das while ist unnötig oder? 
4. Wie muss ich die denn ändern?


----------



## Khal Drogo (26. Nov 2015)

zu 3.) Du wirst (vermutlich) zwei Schleifen schachteln müssen, allerdings ist die while-Schleife an der Stelle deplatziert und dürfte auch nicht wirklich funktionieren, wie du es vermutlich beabsichtigt hast.
zu 4.) Mal dir das ganze mal für n = 1, n = 2, ... auf, dann solltest du eine Regelmäßigkeit feststellen, die du dann mittels einer mathematischen Funktion darstellen können solltest. Das ganze musst du dann nur noch implementieren.

Mit freundlichen Grüßen
Xelsarion


----------



## Hendrik-HSV (26. Nov 2015)

Irgendwie stehe ich gerade ein wenig auf dem schlauch.. Wie bekomme ich denn die beiden Möglichkeiten überhaupt erstmal zusammen?  also so dass sich das nach oben baut und gleichzeitig die Spalten füllt?


----------



## Khal Drogo (26. Nov 2015)

```
// Pseudocode
for(int y = 0; y < pyramidenhoehe; y++) {
  for(int x = 0; x < pyramidenbreite; x++) {
    setzeBlockMitRichtigerFarbe(f(x), g(y), blockbreite, blockhoehe);
  }
}
```
f(x) ist deine Funktion für die x-Koordinate der Blöcke, g(y) die Funktion für die y-Koordinate.

Mit freundlichen Grüßen
Xelsarion


----------



## Hendrik-HSV (26. Nov 2015)

Aber was ist denn meine Funktion für die x & y Koordinate? wenn ich das jetzt so habe gibt er mir eine Blockreihe ganz oben und eine weiter unten aus?
Tut mir leid wenn ich ein wenig anstrengend bin, bin leider noch ein ziemlicher anfänger


----------



## Khal Drogo (26. Nov 2015)

Ich sitze gerade in einer Vorlesung, kann gerne später nochmal versuchen, dir zu helfen. Ich will dir die Lösung aber auch nicht vorgeben, da du sonst nichts dabei lernst  Wie gesagt, zeichne dir das ganze auf, überleg dir, welche Werte die Koordinaten haben und wie du das mit deinen zwei Schleifen realisieren kannst. 

Mit freundlichen Grüßen
Xelsarion


----------



## Hendrik-HSV (26. Nov 2015)

```
for (int y = 0; y < n ; y++) {
for (int x = 0; x < n; x++) {
GRect Bottom = new GRect(200- (x * 50), 50+ (y * 25), 50, 50);
Bottom.setFilled(true);
Bottom.setColor(new Color(255, 0, 0));
add(Bottom);

GRect Bottom2 = new GRect(200- (x * 50), 50+ (y * 25), 50, 50);
Bottom2.setFilled(false);
add(Bottom2);
```

Also wenn ich das jetzt so habe gibt er mir ein Viereck und keine Pyramide aus & das viereck hat immer 5 Blöcke in die Breite  wie bekomme ich es jetzt hin dass die anzahl der Blöcke von stufe zu stufe weniger werden und einrücken?


----------



## Joose (26. Nov 2015)

Lager doch bitte den Code zum Zeichnen der Blöcke in eine Methode aus. Dadurch musst du in Zukunft immer nur eine Rechnung anpassen außerdem ist der gepostete Code der beiden verschachtelten Schleifen dann kürzer und einfacher 

```
add(createGRect(x, y, true));
add(createGRect(x, y, false));
.....
public GRect createGRect(int x, int y, boolean filled) {
   GRect rect = new GRect(200- (x * 50), 50+ (y * 25), 50, 50);
   rect.setFilled(filled);
   return rect;
}
```



Hendrik-HSV hat gesagt.:


> ```
> for (int y = 0; y < n ; y++) {
> for (int x = 0; x < n; x++) {
> ........
> ```





Hendrik-HSV hat gesagt.:


> Also wenn ich das jetzt so habe gibt er mir ein Viereck und keine Pyramide aus


Logisch, beide Schleife laufen von 0 bis n.



Hendrik-HSV hat gesagt.:


> das viereck hat immer 5 Blöcke in die Breite



Wahrscheinlich weil du n auf 5 gesetzt hast 



Hendrik-HSV hat gesagt.:


> wie bekomme ich es jetzt hin dass die anzahl der Blöcke von stufe zu stufe weniger werden und einrücken?



Immer wenn du die Reihe erhöhst muss du entweder die Grenzbedingung von der inneren Schleife reduzieren, oder den Startwert der inneren Schleife erhöhen.
Ich würde eher dazu tendieren den Startwert zu erhöhen!

Tipp: Schau erstmal das du die Aufgabe löst die jeweils nächste Reihe immer einen Stein weniger hat. Wenn du dann diese Treppe hast kann man sich um die Einrückung kümmern.


----------



## Hendrik-HSV (26. Nov 2015)

Also n habe ich oben in der Eingabe, also wird n auf das gesetzt was der Nutzer eingibt, trotzdem haben ich egal bei welcher Zahl 5 Blöcke. und wenn ich den Startwert (also x+1) erhöhe werden von den 5 Spalten 2 weiß..

Und das mit der Treppe ist ja mein größtes Problem  wenn ich die erstmal hätte würde ich das einrücken bestimmt hinbekommen.


----------



## Khal Drogo (26. Nov 2015)

Hendrik-HSV hat gesagt.:


> Und das mit der Treppe ist ja mein größtes Problem  wenn ich die erstmal hätte würde ich das einrücken bestimmt hinbekommen.





Joose hat gesagt.:


> Immer wenn du die Reihe erhöhst muss du entweder die Grenzbedingung von der inneren Schleife reduzieren, oder den Startwert der inneren Schleife erhöhen.
> Ich würde eher dazu tendieren den Startwert zu erhöhen!


Einfach pro Stufe einen weniger zeichnen..

Mit freundlichen Grüßen
Xelsarion


----------



## Hendrik-HSV (26. Nov 2015)

Aber wie mache ich das denn dass ich einen weniger zeichne? 
Ist mein code denn vom ding her überhaupt richtig? weil die Ausgabe ist nicht so ganz das erwartete Resultat


----------



## Joose (26. Nov 2015)

Hendrik-HSV hat gesagt.:


> Also n habe ich oben in der Eingabe, also wird n auf das gesetzt was der Nutzer eingibt,


Ignoriere die Usereingabe mal komplett und verwende stattdessen fixe Werte!



Hendrik-HSV hat gesagt.:


> trotzdem haben ich egal bei welcher Zahl 5 Blöcke.


Dann dürftest du "n" anscheinend fix auf 5 setzen, da im Code nicht ersichtlich ist wo du n setzt, kann man diesbezüglich nur raten 



Hendrik-HSV hat gesagt.:


> und wenn ich den Startwert (also x+1) erhöhe werden von den 5 Spalten 2 weiß..



Was heißt "x+1" wo schreibst du das hin?
Bei deinem Code oben hast du x jedesmal mit 0 initialisiert. Du sollest es beim 1.mal mit 0 initialisieren, beim 2.mal mit 1, beim 3.mal mit 2 usw.


----------



## Khal Drogo (26. Nov 2015)

Ich kann es schlecht testen. Warum ist deine erste Koordinate _200 - 50x_? Das kommt mir schon mal inkorrekt vor. 
Mit den Angaben von @Joose hast du eigentlich alles, was du brauchst.

Mit freundlichen Grüßen
Xelsarion


----------



## Hendrik-HSV (26. Nov 2015)

Also ich zeig euch einfach nochmal meinen kompletten code

```
import java.awt.Color;

import acm.graphics.GRect;
import acm.program.GraphicsProgram;

public class Pyramid extends GraphicsProgram {
    public void run() {
        int n = readInt("Enter the number of bricks in the bottom layer: ");

        for (int y = 0; y < n; y++) {
            for (int x = 0; x < n; x++) {
                GRect Bottom = new GRect(200 - (x * 50), 50 + (y * 25), 50, 50);
                Bottom.setFilled(true);
                Bottom.setColor(new Color(255, 0, 0));
                add(Bottom);

                GRect Bottom2 = new GRect(200 - (x * 50), 50 + (y * 25), 50, 50);
                Bottom2.setFilled(false);
                add(Bottom2);

            }
        }

    }

}
```

Das Ist das mein Ergebnis wenn ich in diesen Code '10' eingebe


----------



## Joose (26. Nov 2015)

Hendrik-HSV hat gesagt.:


> Also ich zeig euch einfach nochmal meinen kompletten code



Wie schon weiter oben gesagt, lagere doch den Code zum Erstellen in eine Methode aus.
Dadurch verringert sich der Inhalt der Schleife und wird lesbarer und verständlicher!



Hendrik-HSV hat gesagt.:


> Das Ist das mein Ergebnis wenn ich in diesen Code '10' eingebe



Das passt ja auch 
Deine Berechnung von X ist einfach fehlerhaft.
1.Schleifendurchlaufe => 200 - 0 * 50
2.Schleifendurchlaufe => 200 - 1 * 50
3.Schleifendurchlaufe => 200 - 2 * 50
4.Schleifendurchlaufe => 200 - 3 * 50
5.Schleifendurchlaufe => 200 - 4 * 50
6.Schleifendurchlaufe => 200 - 5 * 50
7.Schleifendurchlaufe => 200 - 6 * 50
8.Schleifendurchlaufe => 200 - 7 * 50
9.Schleifendurchlaufe => 200 - 8 * 50
10.Schleifendurchlaufe => 200 - 9 * 50

Mit Hilfe des Debuggers und/oder Konsoleausgaben wäre dir das schon aufgefallen 
Die Hälfte deiner Blöcke wird nicht sichtbar gezeichnet. Außerdem sind deine Blöcke quadratisch, und überlagern sich jeweils (ganz gut zu erkennen an der letzten Reihe)


Hier ein angepasster Code

```
static final int BLOCK_HEIGHT = 25;
static final int BLOCK_WIDTH = 25;

static final int MARGIN_LEFT = 200;
static final int MARGIN_TOP = 50;

public void run() {
   int n = readInt("Enter the number of bricks in the bottom layer: ");

   for (int y = 0; y < n; y++) {
     for (int x = 0; x < n; x++) {
       add(createRect(x, y, true));
       add(createRect(x, y, false));
     }
   }
}

public GRect createRect(int x, int y, boolean filled) {
   int xKoordinate = MARGIN_LEFT + (x * 50);
   int yKoordinate = MARGIN_TOP + (y * 25);
 
   System.out.println("X: " + yKoordinate + ", Y: " + yKoordinate);

   GRect rect = new GRect(xKoordinate, yKoordinate, BLOCK_WIDTH, BLOCK_HEIGHT);
   rect.setFilled(filled);
   if(filled) {
     // farbe ändern
     rect.setColor(new Color(255, 0, 0));
   }
   return rect;
}
```

Damit sollte die Blöcke alle korrekt gezeichnet werden.
Damit du eine Treppe hinbekommst, musst du dafür sorgen das "x" nicht jedesmal bei 0 anfängt sondern beim 1.mal mit 0, beim 2.mal mit 1, usw.
Denke dabei das x die Zählervariable der inneren Schleife ist, du hast noch eine äußere Schleife die ebenfalls eine Zählervariable hat


----------



## Hendrik-HSV (26. Nov 2015)

Wenn ich in deinen angepassten code '10' eingebe bekomme ich das her heraus


----------



## Joose (26. Nov 2015)

Hendrik-HSV hat gesagt.:


> Wenn ich in deinen angepassten code '10' eingebe bekomme ich das her heraus



1.) Warum mit so einer großen Pyramide testen? Fange mit einer einfachen an mit der Basis 2
2.) Es sollte auch etwas auf die Konsole geschrieben worden sein, dort kannst du dir die Koordinaten der jeweiligen Blöcke anschauen
3.) Mein Fehler  die BLOCK_WIDTH sollte natürlich 50 sein, außerdem bei der Berechnung von X stand "BLOCK_WIDTH - ..." habe es vorhin noch auf "BLOCK_WIDTH + ..." geändert!


----------



## Hendrik-HSV (26. Nov 2015)

Wie bekomme ich es denn jetzt noch hin dass er von durchgang zu durchgang einen Block weniger ausgibt?


----------



## JStein52 (26. Nov 2015)

Vielleicht hilft dir auch das was hier gesagt wurde weiter (wg. dem Pyramidenalgorithmus, ansonsten malst du ja klötzchen und nicht sterne)
http://www.java-forum.org/thema/sternchenpyramide-mit-for-schleifen-erstellen.168239/


----------



## Khal Drogo (26. Nov 2015)

Hendrik-HSV hat gesagt.:


> Wie bekomme ich es denn jetzt noch hin dass er von durchgang zu durchgang einen Block weniger ausgibt?


Das wurde dir mittlerweile mehrfach beantwortet 

Mit freundlichen Grüßen
Xelsarion


----------



## Joose (27. Nov 2015)

Hendrik-HSV hat gesagt.:


> Wie bekomme ich es denn jetzt noch hin dass er von durchgang zu durchgang einen Block weniger ausgibt?



Wie Xelsarion schon darauf hingewiesen hat, diese Frage wurde schon mehrmals beantwortet.
War so freundlich und habe dir die entsprechenden Stellen rausgesucht.

Lies dir unsere Beiträge bitte aufmerksam durch, da können hilfreiche Sachen drinnen stehen 
Sollte dir etwas unklar sein dann zitiere die entsprechende Stelle und Frage nach.



Joose hat gesagt.:


> Immer wenn du die Reihe erhöhst muss du entweder die Grenzbedingung von der inneren Schleife reduzieren, oder den Startwert der inneren Schleife erhöhen.
> Ich würde eher dazu tendieren den Startwert zu erhöhen!





Joose hat gesagt.:


> Bei deinem Code oben hast du x jedesmal mit 0 initialisiert. Du sollest es beim 1.mal mit 0 initialisieren, beim 2.mal mit 1, beim 3.mal mit 2 usw.





Joose hat gesagt.:


> Damit du eine Treppe hinbekommst, musst du dafür sorgen das "x" nicht jedesmal bei 0 anfängt sondern beim 1.mal mit 0, beim 2.mal mit 1, usw.
> Denke dabei das x die Zählervariable der inneren Schleife ist, du hast noch eine äußere Schleife die ebenfalls eine Zählervariable hat


----------



## Hendrik-HSV (27. Nov 2015)

> Bei deinem Code oben hast du x jedesmal mit 0 initialisiert. Du sollest es beim 1.mal mit 0 initialisieren, beim 2.mal mit 1, beim 3.mal mit 2 usw.


Das habe ich ja verstanden dass ich meine Zählvariable erhöhen muss  allerdings ist mir gerade nicht ganz klar wie.. ich dachte das würde ich mit dem '++i' automatisch machen


----------



## Joose (27. Nov 2015)

Hendrik-HSV hat gesagt.:


> Das habe ich ja verstanden dass ich meine Zählvariable erhöhen muss  .....



Anscheinend nicht wirklich.



Hendrik-HSV hat gesagt.:


> ..... ich dachte das würde ich mit dem '++i' automatisch machen



Damit erhöhst du die *Zählervariable*, davon war aber nicht die Rede, sondern vom *Startwert*



Joose hat gesagt.:


> entweder die Grenzbedingung von der inneren Schleife reduzieren, oder den Startwert der inneren Schleife erhöhen.



Ich habe geschrieben (wie oben nochmals zitiert) : Den Startwert der inneren Schleife erhöhen.

Sobald die innere Schleife abgearbeitet ist kommt die äußere wieder dran, erhöht die Zählervariable und startet dann wieder die innere Schleife.
Jedesmal startet die innere Schleife mit x = 0, aber wie schon 2x geschrieben soll sich dieser Wert ändern.
Beim 1.mal soll x mit 0 initialisiert werden
Beim 2.mal soll x mit 1 initialisiert werden
........

oder du reduzierst die Grenz-/Abbruchbedingung
Beim 1.mal läuft die Schleife bis x < n - 0 erfüllt ist
Beim 2.mal läuft die Schleife bis x < n - 1 erfüllt ist
.........


----------



## Hendrik-HSV (27. Nov 2015)

> Beim 1.mal soll x mit 0 initialisiert werden
> Beim 2.mal soll x mit 1 initialisiert werden


achso, aber dann ist doch x=0 genrell falsch oder nicht? wie schreibe ich denn sowas dass der Wert sich erhöht, also jeden Durchgang neu initialisiert..
Tut mir leid wenn ich hier rüberkomme wie der größte Anfänger


----------



## Joose (27. Nov 2015)

Hendrik-HSV hat gesagt.:


> achso, aber dann ist doch x=0 genrell falsch oder nicht?



Jein für den 1.Durchlauf der inneren passt es ja.
Aber damit du bei allen weiteren Durchläufen andere Startwerte hast musst du natürlich etwas anderes schreiben.

x = ??



Hendrik-HSV hat gesagt.:


> wie schreibe ich denn sowas dass der Wert sich erhöht, also jeden Durchgang neu initialisiert..





Joose hat gesagt.:


> Denke dabei das x die Zählervariable der inneren Schleife ist, du hast noch eine äußere Schleife die ebenfalls eine Zählervariable hat



Du brauchst einen Wert der mit 0 initialisiert wird. Und nach jedem vollständigen Durchlauf der inneren Schleife erhöht wird.
(Bedenke du hast auch eine außere Schleife mit Zählervariable )


----------



## Hendrik-HSV (27. Nov 2015)

```
public GRect createRect(int x, int y, boolean filled) {
       int xKoordinate = MARGIN_LEFT +(x * 50);
       int yKoordinate = MARGIN_TOP - (y * 25);
```


Ahh  also ich habe jetzt x=y gesetzt und habe schonmal diese Treppe.. Wenn ich das jetzt noch einrücken will muss dafür aber doch in der Schleife stehen oder?


----------



## Joose (27. Nov 2015)

Hendrik-HSV hat gesagt.:


> Ahh  also ich habe jetzt x=y gesetzt und habe schonmal diese Treppe



Top 



Hendrik-HSV hat gesagt.:


> ```
> public GRect createRect(int x, int y, boolean filled) {
> int xKoordinate = MARGIN_LEFT +(x * 50);
> int yKoordinate = MARGIN_TOP - (y * 25);
> ...



Genau für die Einrückung musst du nun die Berechnung für die xKoordinate anpassen.
Je nachdem ob du die Steine nach links oder rechts rücken willst musst du etwas addieren oder subtrahieren.


```
int xKoordinate = MARGIN_LEFT + (x * 50) - ??; // wenn die Treppe von links nach rechts AUFsteigt
int xKoordinate = MARGIN_LEFT + (x * 50) + ??; // wenn die Treppe von links nach rechts ABsteigt
```

(Je Reihe beträgt die Einrückung einen halben Block)
Die 1.Reihe (unterste) ist um 0 halbe Blöcke verschoben
Die 2.Reihe ist um einen halben Block verschoben
Die 3.Reihe ist um zwei halbe Blöcke verschoben
Die 4.Reihe ist um drei halbe Blöcke verschoben
.......

Jetzt musst du halt nur noch logisch überlegen wie du dir das ausrechnest 
Überlege es dir, zeichne es dir vl mit Stift+Papier vor, probiere herum und lass dir die Werte auf der Konsole ausgeben.


----------



## Hendrik-HSV (27. Nov 2015)

Ja genau ich muss die jetzt um halbe Blöcke, also bei meinen Blöcken um 25*??, einrücken d.h. um 25*x allerdings ist die Brechnung für die xKoordinate ja außerhalb der Schleife also passt er wenn ich *x rechne ja nur das letzte x an. 
Wie bekomme ich das jetzt in die Schleife?


----------



## Joose (27. Nov 2015)

Hendrik-HSV hat gesagt.:


> Ja genau ich muss die jetzt um halbe Blöcke, also bei meinen Blöcken um 25*??



Genau aber anstatt 25 zu verwenden kannst du auch "BLOCK_WIDTH/2" nehmen 



Hendrik-HSV hat gesagt.:


> d.h. um 25*x allerdings ist die Brechnung für die xKoordinate ja außerhalb der Schleife also passt er wenn ich *x rechne ja nur das letzte x an.



Ich sehe keinen Grund in der Schleife irgendwas "*x" zu rechnen.
Überlege doch wo denn bisher die xKoordinate berechnet wird ..... warum nicht dort die Berechnung anpassen?

Außerdem habe ich dir im Post davor schon gezeigt welche Zeile du anpassen musst.
Das habe ich schon in einem vorherigen Post gemeint. Du sollst die die Antworten von uns AUMERKSAM durchlesen.


----------



## Hendrik-HSV (27. Nov 2015)

> Außerdem habe ich dir im Post davor schon gezeigt welche Zeile du anpassen musst.


ja es ist mir klar was ich ändern muss und wie ich es ändern muss, aber wenn ich da jetzt einfach nur -25 rechne ist das ja quatsch weil ich das dann nur in einer Zeile ändere. Korrigiert mich wenn ich quatsch erzähle


----------



## Joose (27. Nov 2015)

Hendrik-HSV hat gesagt.:


> ja es ist mir klar was ich ändern muss und wie ich es ändern muss .....



Das nehme ich leider nicht an.



Hendrik-HSV hat gesagt.:


> ......, aber wenn ich da jetzt einfach nur -25 rechne ist das ja quatsch .....



Einfach nur "-25" ist auch falsch ... das fehlt noch etwas



Hendrik-HSV hat gesagt.:


> ..... weil ich das dann nur in einer Zeile ändere. Korrigiert mich wenn ich quatsch erzähle



Warum änderst du damit nur an einer Zeile etwas?
Ja eine Codezeile, aber jede Reihe von Blöcken wird dadurch verschoben. Hättest du es ausprobiert wäre es dir aufgefallen.
Würdest du Konsolenausgaben oder den Debugger verwenden (was auch schon mehrmals erwähnt wurde) dann wäre der Ablauf deines Programmes klar geworden.

Du hast 2 verschachtelte Schleifen und in diesen Schleifen wird eine Methode aufgerufen. Dies Methode bekommt als Parameter den x und y Wert übergeben.
Un dieser x und y Wert wird in den Schleifen jeweils erhöht.

==> Die Methode wird sehr oft aufgerufen und immer mit einem anderen x bzw. y Wert!


----------



## Hendrik-HSV (27. Nov 2015)

Ahhhh.. Jetzt ist mir ein Licht aufgegangen.. ich hatte die ganze zeit *x aber das war ja schwachsinn. Jetzt habe ich es auf *y geändert und es funktioniert, die Pyramide ist schonmal da. 
Fehlt nur noch der Farbverlauf....
Der Ansatz da ist ja irgendwie auch klar mit jedem Durchgang muss die Farbe heller werden.. aber wenn ich mit 0 anfange kann das funktionieren?


----------



## Joose (27. Nov 2015)

Warum sollt es nicht funktionieren?
Probiere es einfach mal aus  versuche unterschiedliche Ansätze die deiner Meinung nach passen müsste.
Verwende Konsoleausgaben um die Werte für die Farbe zu kontrollieren usw.


----------



## Hendrik-HSV (27. Nov 2015)

Klar funktioniert das .. Ich hab jetzt +(y*20) aber bekomme ich es hin dass der letzte Block genau 250, 220, 220 hat?


----------



## Khal Drogo (28. Nov 2015)

Klar funktioniert das, wenn du auf der untersten Ebene mit (250, 0, 0) anfängst, ist die Regel für jede einzelne Ebene eben (250, aktuelleEbene * 220 / anzahlEbenen, aktuelleEbene * 220 / anzahlEbenen).





Mit freundlichen Grüßen
Xelsarion


----------



## Hendrik-HSV (29. Nov 2015)

Warum kann ich die varianle n bei der Farbe nicht benutzen?  "n cannot be resolved to a variable"


----------



## Khal Drogo (29. Nov 2015)

Dafür brauchen wir Code..

Mit freundlichen Grüßen
Xelsarion


----------



## Hendrik-HSV (29. Nov 2015)

schon gut das Programm läuft mittlerweile! Vielen vielen Dank schonmal dass ihr es bisher mit mir ausgehalten habt  jetzt hätte ich allerdings ein problem bei einem neuen Programm 

```
public class Tac extends GraphicsProgram {
    public void run() {

        int row = 0;
        int column = 0;
        int i = 0;

        add(new GLine(200, 100, 200, 400));
        add(new GLine(300, 100, 300, 400));
        add(new GLine(100, 200, 400, 200));
        add(new GLine(100, 300, 400, 300));

        for (i = 0; i <= 8; ++i)
            ;
        {
            switch (i) {
            case 0:
            case 2:
            case 4:
            case 6:
            case 8:
                row = readInt("row: ");
                while (row > 3 || column < 1) {
                    row = readInt("row between 1&3");
                }
                column = readInt("column: ");
                while (column > 3 || column < 1) {
                    column = readInt("column between 1&3");
                }
                add(new GLine(100 * column, 100 * row, 100 + 100 * column, 100 + 100 * row));
                add(new GLine(100 * column, 100 + 100 * row, 100 + 100 * column, 100 * row));
                break;

            case 1:
            case 3:
            case 5:
            case 7:
            case 9:
                row = readInt("row: ");
                while (row > 3 || row < 1) {
                    row = readInt("row between 1&3");
                }
                column = readInt("column: ");
                while (column > 3 || column < 1) {
                    column = readInt("column between 1&3");
                }
                GArc A = new GArc(100 * row, 100 * column, 100, 100, 360, 360);
                A.setFilled(false);
                A.setColor(Color.BLACK);
                add(A);
                break;
            }
        }
    }
}
```

Warum funktioniert die Schleife nicht?


----------



## Khal Drogo (29. Nov 2015)

Vielleicht besser ein neues Thema, da neues Problem.
"Warum funktioniert die Schleife nicht?" ist keine gute Problembeschreibung.
Mit freundlichen Grüßen
Xelsarion


----------



## Joose (30. Nov 2015)

Hendrik-HSV hat gesagt.:


> jetzt hätte ich allerdings ein problem bei einem neuen Programm Warum funktioniert die Schleife nicht?



Dann mach bitte deswegen ein neues Thema auf! Da ich nicht annehme das diese Programm viel mit Pyramide am Hut hat (und selbst wenn ist es etwas anderes ).
Und wie @Xelsarion schon gesagt hat: Eine genauere Beschreibung ist hilfreich. Wie sollte es funktionieren, was solltest du bekommen, was bekommst du stattdessen?


----------



## JStein52 (30. Nov 2015)

Ist ja alles gut und schön, aber die Schleife funktioniert. Sie besteht allerdings nur aus einer Leeranweisung. Nimm mal das Semikolon hinter der for-Zeile weg !!!


----------

