[Firefox64]

Tag zusammen!

ich hätte da Folgendes Prob...
Ich muss für die Schule Minesweeper nach Programmierern...
So eigentlich jetzt nicht soooo komplex nur die sache hat nen paar Haken und ich daddel seit Stunden rum...

Problem 1:
Wenn man ein Kästchen auswählt muss er ja gucken wieviele Minen drumherrum sind...
Blöd nur das das array auch die Felder auf der Gegenüberliegenden Seite wertet...
(Feld[8][1] ist ja genau neben Feld[1][1] im array aber in Mienesweeper nunmal nicht -.- hoffe ihr versteht wie ich das meine)...

Problem 2:
Markieren; Mann kann ja so ein Fähnchen setzen da wo man glaubt das da ne Mine ist...
Wie "frezze" ich das Feld so das man es nicht mehr ändern kann...

sind noch weit mehr Probleme da aber das sind die beiden wo mir nix mehr einfällt...


need help

euer FF64

[urga]

wirklich in C ?

weil dann wärs ja Feld[0][0] und Feld[7][0] oder?
aber nach welcher formel bitte kommst du denn von (0,0) nach (7,0) ???
und zu 2: welches toolkit verwendest du denn (wenns wirklich C ist)? [ Link nur für registrierte Mitglieder sichtbar. Bitte einloggen oder neu registrieren ]

und:

FLAME ON
[ Link nur für registrierte Mitglieder sichtbar. Bitte einloggen oder neu registrieren ]

ich würd' nen admin bitten diesen thread zu löschen.
FLAME OFF

[.Ash]

ich glaube er checkt immer array[i][i+1], [i][i-1],[i+1][i] usw

bei array[i][0-1] wird dann wohl bei [i][7] gecheckt, was ja auf der anderen seite liegt.

ich würde da da einfach ne bedingung vor der abfrage machen und gut ist. wenn die nicht erfüllt ist, wird die jeweilige seite einfach nicht gecheckt.

[urga]

seid wann ist 0-1 == 7 ???

[.Ash]

Zitat von urga

seid wann ist 0-1 == 7 ???

ach kein Plan was er sich da zurecht gecodet hat. anders kann ich mir das aber nicht erklären.

[urga]

hier mal was konstruktives. ich finde die funktion etwas "unelegant" aber sie tut was sie soll. und das nach 6 bier
wem eine elegantere (und/oder kürzere) version gelingt, bitte posten!

    
  private Point[] getNeigbours (int x, int y) {
      int count = 8; // 8 potentielle nachbarn
      // this.size ist das ausmass des spielfeldes
      // also im fall von 15x15 == 15
      if (x == 0 || x == this.size - 1) count -= 3;
      if (y == 0 || y == this.size - 1) count -= 3;
      if (count == 2) count = 3; // falls einer der die 4 eckpunkte geklickt
      Point[] ps = new Point[count];

      Point[] tmp = new Point[8];
      int cnt = 0;
      tmp[cnt++] = new Point (x + 1, y + 1);
      tmp[cnt++] = new Point (x - 1, y - 1);
      tmp[cnt++] = new Point (x - 1, y + 1);
      tmp[cnt++] = new Point (x + 1, y - 1);

      tmp[cnt++] = new Point (x + 1, y);
      tmp[cnt++] = new Point (x - 1, y);
      tmp[cnt++] = new Point (x, y + 1);
      tmp[cnt++] = new Point (x, y - 1);

      cnt = 0;
      foreach (Point p in tmp) {
        if (p.X >= 0 && p.X < this.size && p.Y >= 0 && p.Y < this.size) {
          ps[cnt++] = p;
        }
      }
      return ps;
    } // getNeigbours()

ich verzichte hier bewusst auf generische typen wie List<T>, da es ja um C als zielsprache geht.

[kramido]

Effizientere Lösung:
Prüfung direkt beim Erstellen der Punkt-Objekte. Ansonsten sollte das so funktionieren.

Und noch eine Frage:
Wer benutzt ohne Geschwindigkeitsoptimierung Post/Präfixoperatoren?!

 ps[cnt++]

Welcher Anfänger kann dir hier sagen, ob zuerst zugegriffen oder inkrementiert wird?

[urga]

Prüfung direkt beim Erstellen der Punkt-Objekte.

ja stimmt schon. aber eine kaskade

if (x + 1 < this.size && y + 1 < this.size) {
 ps[cnt++] = new Point (x + 1, y + 1);
}
// ..... 7 weitere vergleiche .....

finde ich noch uneleganter. bzw. fehleranfälliger.
und das bisschen overhead auf dem stack (8x2x sizeof (int)) ist wohl verkraftbar.

Welcher Anfänger kann dir hier sagen, ob zuerst zugegriffen oder inkrementiert wird?

wer spricht denn hier von anfänger? der autor hat immerhin den "[TUT] Wie werde ich Programierer?" thread gestartet.

[kramido]

Zitat von urga

wer spricht denn hier von anfänger? der autor hat immerhin den "[TUT] Wie werde ich Programierer?" thread gestartet.

Entschuldige, mein Fehler! Ich nehme alles zurück und behaupte das Gegenteil!

Zitat von urga

ja stimmt schon. aber eine kaskade
[code]
finde ich noch uneleganter. bzw. fehleranfälliger.
und das bisschen overhead auf dem stack (8x2x sizeof (int)) ist wohl verkraftbar.

Tendentiell ja. Aber das Instanzieren jedes Objekts verbrät leider mehr Rechenzeit als ne Abfrage zuvor. Ich bin da eher minimalistisch beim Speicherbedarf/bei der Rechenzeit.