Java lernen durch Ausprobieren!

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Zuletzt angesehen:
api:projects:minesweeper:start

Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

Link zu dieser Vergleichsansicht

Nächste Überarbeitung		Vorhergehende Überarbeitung
api:projects:minesweeper:start [2020/12/28 15:34] – angelegt Martin Pabstapi:projects:minesweeper:start [2021/12/29 11:29] (aktuell) – Externe Bearbeitung 127.0.0.1
Zeile 1: Zeile 1:
 ====== Minesweeper ====== ====== Minesweeper ======
-{{ :api:projects:minesweeper:pasted:20201228-152802.png }}+{{ :api:projects:minesweeper:pasted:20201228-152802.png?300}}
 Im Spiele-Klassiker Minesweeper versteckt der Computer in einem Spielfeld aus kleinen quadratischen Feldern hinter einzelnen Felder Minen. Der Spieler hat die Aufgabe, die verminten Felder mit Fahnen zu markieren. Er kann einzelne Felder aufdecken (linke Maustaste), hat aber verloren, wenn er auf eine Mine stößt. Als Hinweis dafür, wo sich die Minen befinden, schreibt der Computer in jedes aufgedeckte Feld die Anzahl der Minen, die sich in den acht angrenzenden Felder befinden. Ist sich der Spieler sicher, dass sich in einem Feld eine Mine befindet, so kann er mit der rechten Maustaste eine Fahne setzen bzw. wieder löschen. Der Computer stellt ihm aber nur so viele Fahnen zur Verfügung, wie er Minen versteckt hat. \\ \\  Im Spiele-Klassiker Minesweeper versteckt der Computer in einem Spielfeld aus kleinen quadratischen Feldern hinter einzelnen Felder Minen. Der Spieler hat die Aufgabe, die verminten Felder mit Fahnen zu markieren. Er kann einzelne Felder aufdecken (linke Maustaste), hat aber verloren, wenn er auf eine Mine stößt. Als Hinweis dafür, wo sich die Minen befinden, schreibt der Computer in jedes aufgedeckte Feld die Anzahl der Minen, die sich in den acht angrenzenden Felder befinden. Ist sich der Spieler sicher, dass sich in einem Feld eine Mine befindet, so kann er mit der rechten Maustaste eine Fahne setzen bzw. wieder löschen. Der Computer stellt ihm aber nur so viele Fahnen zur Verfügung, wie er Minen versteckt hat. \\ \\ 
-Hat der Spieler alle Felder des Spielfeldes entweder aufgedeckt oder mit Fahnen markiert, so hat ist das Spiel gewonnen.+Hat der Spieler alle Felder des Spielfeldes entweder aufgedeckt oder mit Fahnen markiert, so hat ist das Spiel gewonnen. \\ \\  
 +Etwas weiter unten findest Du das gesamte Spiel zum Ausprobieren und verändern. Ich habe die einzelnen Entwicklungsschritte dokumentiert und mit ausführlichen Erklärungen versehen: 
 +  * [[.zelle:start|Die Klasse Zelle]] 
 +  * [[.spielfeld:start|Die Klasse Spielfeld]] 
 +  * Die Klasse Minesweeper 
 + 
 + 
 +<HTML> 
 +<div class="java-online" style="height: 620px; width: 100%" data-java-online="{'withBottomPanel': true, 'id': 'Minesweeper', 'speed': 'max'}"> 
 + 
 +<script type="text/plain" title="Minesweeper.java"> 
 +// Hauptprogramm 
 +new World(645, 800); 
 + 
 +// Der Konstruktor der Klasse Minesweeper initialisiert das Spiel, 
 +// danach wird die Anwendung durch Ereignisse (click, mouseup) und die 
 +// act-Methode von Minesweeper weiter vorangebracht. 
 +new Minesweeper(); 
 + 
 +// Mit dem Aufruf der Methode setZustand der Klasse Minesweeper wird der 
 +// Übergang von einem Zustand zum nächsten herbeigeführt. 
 +enum Zustand { 
 +   vor_dem_spiel, intro, spiel_läuft, spiel_gewonnen, spiel_verloren 
 +} 
 + 
 +// Hauptklasse der Anwendung 
 +class Minesweeper extends Actor { 
 +    
 +   private Spielfeld spielfeld;                            // Das Spielfeld-Objekt enthält und verwaltet alle Zellen 
 +    
 +   // Der linke rote Zähler zeigt die Differenz aus der Anzahl der Minen und  
 +   // der Flaggen. 
 +   private Counter minenCounter = new Counter(100, 50); 
 + 
 +   // Der rechte rote Zähler zählt die verstrichenen Sekunden.  
 +   private Counter sekundenCounter = new Counter(645 - 100 - 3 * 32, 50); 
 + 
 +   // Die Smiley-Grafik in der Mitte 
 +   private Smiley smiley; 
 + 
 +   // Zustand, in dem sich das Spiel gerade befindet 
 +   private Zustand zustand = Zustand.vor_dem_spiel; 
 + 
 +   // Text am unteren Rand des Grafikbereichs zur Ausgabe von Status- und Hilfstexten 
 +   private Text text; 
 + 
 +   // Zähler, mit dem jeweils 30 verstrichene Frames (d.h. 1 Sekunde) gezählt werden. 
 +   // Je 30 Frames wird eine Sekunde hochgezählt. 
 +   private int frameCounter = 30; 
 + 
 +   Minesweeper() { 
 +      super(); 
 + 
 +      spielfeld = new Spielfeld(20, 20, 40, this); 
 +      spielfeld.init(); 
 + 
 +      text = new Text(322, 750, 32, ""); 
 +      text.setAlignment(Alignment.center); 
 +      text.setFillColor(Color.white); 
 + 
 +      this.smiley = new Smiley(305, 50, this); 
 +      setZustand(Zustand.spiel_läuft);  
 +   } 
 + 
 +   public void act() { 
 +      // Zähle die Frames: 
 +      if(--frameCounter <= 0) { 
 +         // 30 Frames (d.h. 1 Sekunde) sind verstrichen 
 +         frameCounter = 30; 
 +         if(zustand == Zustand.intro) { 
 +            spielfeld.zufälligeZelleKlicken(); 
 +         } else if(zustand == Zustand.spiel_läuft) { 
 +            sekundenCounter.add(1);  // Verstrichene Sekunden hochzählen 
 +         } 
 +      } 
 +   } 
 + 
 +   public Counter getMinenCounter() { 
 +      return minenCounter; 
 +   } 
 + 
 +   public Zustand getZustand() { 
 +      return zustand; 
 +   } 
 + 
 +   /** 
 +    * Alle Zustandsübergänge werden durch Aufrufen dieser Methode herbeigeführt. 
 +    */ 
 +   public void setZustand(Zustand neuerZustand) { 
 + 
 +      zustand = neuerZustand; // Im Attribut zustand ist immer der aktuelle Zustand gespeichert. 
 +       
 +      switch(neuerZustand) { 
 +         case Zustand.intro : // intro  
 +            text.setText("Klicke auf den Smiley, um zu beginnen."); 
 +            break; 
 +         case Zustand.spiel_läuft : // Spiel läuft  
 +            text.setText(""); 
 +            spielfeld.löschen();    // Spielfeld fürs neue Spiel bereitmachen 
 +            spielfeld.init(); 
 +            sekundenCounter.set(0); 
 +            minenCounter.set(spielfeld.getMinenAnzahl()); 
 +            smiley.showSmile(); 
 +            break; 
 +         case Zustand.spiel_gewonnen : // Spiel gewonnen  
 +            smiley.showFaceWithSunglasses(); 
 +            text.setText("Gewonnen! Smiley => neues Spiel."); 
 +            break; 
 +         case Zustand.spiel_verloren : // Spiel verloren 
 +            smiley.showCryingFace(); 
 +            spielfeld.allesAufdecken();  
 +            text.setText("Schade! Smiley => neues Spiel."); 
 +            break; 
 +            default :  
 +                
 +            } 
 + 
 +   } 
 + 
 +   /** 
 +    * Durch Klick auf den Smiley kann ein neues Spiel gestartet werden. Diese 
 +    * Methode wird durch die Methode Smiley.onMouseDown aufgerufen. 
 +    */ 
 +   public void onSmileyKlicked() { 
 +      if(zustand != Zustand.spiel_läuft) { 
 +         setZustand(Zustand.spiel_läuft);  
 +      }  
 +   } 
 + 
 +} 
 +</script> 
 + 
 +<script type="text/plain" title="Spielfeld.java"> 
 +/** 
 + * Ein Objekt der Klasse Spielfeld enthält und verwaltet alle Zellen. 
 + */ 
 +class Spielfeld { 
 +    
 +   private Zelle[][] zellen;    // Erste Koordinate: Spalte (x), zweite Koordinate: Zeilen (y) 
 +   private int spalten;         // Anzahl der Spalten des Spielfelds 
 +   private int zeilen;          // Anzahl der Zeilen des Spielfelds 
 +   private int minenAnzahl;     // Anzahl der vesteckten Minen 
 +   private Minesweeper minesweeper;   // Das Spielfeld "kennt" das Minesweeper-Objekt und kann dessen öffentliche Methoden aufrufen. 
 + 
 +   Spielfeld(int spalten, int zeilen, int minenAnzahl, Minesweeper minesweeper) { 
 +      this.spalten = spalten; 
 +      this.zeilen = zeilen; 
 +      this.minesweeper = minesweeper; 
 +      this.minenAnzahl = minenAnzahl; 
 +      zellen = new Zelle[spalten][zeilen]; 
 +   } 
 + 
 +   /** 
 +    * Instanziere alle Zellen und "verstecke" dabei die Minen 
 +    */ 
 +   public void init() { 
 +      // Erzeuge zunächst Zellen ohne Minen. 
 +      for(int spalte = 0; spalte < spalten; spalte++) { 
 +         for(int zeile = 0; zeile < zeilen; zeile++) { 
 +             
 +            zellen[spalte][zeile] = new Zelle(this, ZellBild.hintergrund_leer, spalte, zeile); 
 + 
 +         } 
 +      } 
 + 
 +      // "Verstecke" die Minen 
 +      for(int i = 0; i < minenAnzahl; i++) { 
 +         boolean fertig = false; 
 +         while(!fertig) { 
 +            int spalte = Math.floor(Math.random() * spalten); 
 +            int zeile = Math.floor(Math.random() * zeilen); 
 +            Zelle zelle = zellen[spalte][zeile]; 
 +            if(zelle.getInhalt() != ZellBild.mine) { 
 +               zelle.setZustand(ZellBild.mine, true, false); 
 +               fertig = true; 
 +            } 
 +         }  
 +      } 
 + 
 + 
 +      // Zähle für jede nicht-Minen-Zelle die Nachbarminen und stelle die  
 +      // Anzahl als Zahlengrafik dar. 
 +      for(int spalte = 0; spalte < spalten; spalte++) { 
 +         for(int zeile = 0; zeile < zeilen; zeile++) { 
 +             
 +            Zelle zelle = zellen[spalte][zeile]; 
 +            if(zelle.getInhalt() == ZellBild.hintergrund_leer) { 
 +               int nachbarbomben = zähleNachbarMinen(zelle); 
 +               if(nachbarbomben > 0) { 
 +                  zelle.setZustand(ZellBild.zahl_0 + nachbarbomben, true, false); 
 +               } 
 +            } 
 + 
 +         } 
 +      } 
 +   } 
 + 
 +   public Minesweeper getMinesweeper() { 
 +      return minesweeper; 
 +   } 
 + 
 +   public int getMinenAnzahl() { 
 +      return minenAnzahl; 
 +   } 
 + 
 +   private int zähleNachbarMinen(Zelle zelle) { 
 +      int nachbarMinen = 0; 
 +      for(int dx = -1; dx <= 1; dx++) { 
 +         for(int dy = -1; dy <= 1; dy++) { 
 +            if(dx != 0 || dy != 0) { 
 +               int spalte = zelle.getSpalte() + dx; 
 +               int zeile = zelle.getZeile() + dy; 
 +               if(spalte >= 0 && spalte < spalten && zeile >= 0 && zeile < zeilen) { 
 +                  if(zellen[spalte][zeile].getInhalt() == ZellBild.mine) { 
 +                     nachbarMinen++; 
 +                  }; 
 +               } 
 +            } 
 +         } 
 +      } 
 +      return nachbarMinen; 
 +   } 
 + 
 +   /** 
 +    * Zerstört alle Zellen des Spielfelds 
 +    */ 
 +   public void löschen() { 
 +      for(int spalte = 0; spalte < spalten; spalte++) { 
 +         for(int zeile = 0; zeile < zeilen; zeile++) { 
 + 
 +            zellen[spalte][zeile].destroy(); 
 +            zellen[spalte][zeile] = null; 
 + 
 +         } 
 +      } 
 +   } 
 + 
 +   /** 
 +    * Berechnet die x-Koordinate des Pixels am linken Rand der übergebenen Spalte. 
 +    */ 
 +   public double spalteToX(int spalte) { 
 +      return 21 + 32 * spalte; 
 +   } 
 + 
 +   /** 
 +    * Berechnet die y-Koordinate des Pixels am oberen Rand der übergebenen Zeile. 
 +    */ 
 +   public double zeileToY(int zeile) { 
 +      return 116 + 32 * zeile; 
 +   } 
 + 
 +   /** 
 +    * Wird von Zelle.onMouseUp aufgerufen und deckt die Zelle auf.  
 +    * Enthält sie keine Mine und enthalten auch die Nachbarzellen keine Minen, so werden 
 +    * rekursiv alle benachbarten Zellen aufgedeckt, die ebenfalls keine Minen enthalten  
 +    * und deren Nachbarzellen ebenfalls keine Minen enthalten.  
 +    */ 
 +   public void klickAufZelle(Zelle zelle) { 
 +      zelle.aufdecken(); 
 +      if(zelle.getInhalt() == ZellBild.hintergrund_leer) { 
 +         // Falls weder die Zelle noch die Nachbarzellen Minen enthalten, 
 +         // dann untersuche die acht benachbarten Zellen: 
 +         for(int dx = -1; dx <= 1; dx++) { 
 +            for(int dy = -1; dy <= 1; dy++) { 
 +               if(dx != 0 || dy != 0) { 
 +                  int spalte = zelle.getSpalte() + dx; 
 +                  int zeile = zelle.getZeile() + dy; 
 +                  if(spalte >= 0 && spalte < spalten && zeile >= 0 && zeile < zeilen) { 
 +                     // Hole das benachbarte Zellen-Objekt 
 +                     Zelle zelle = zellen[spalte][zeile]; 
 +                     if(zelle.istZugedeckt()) {  
 +                        klickAufZelle(zelle); 
 +                     } 
 +                  } 
 +               } 
 +            } 
 +         } 
 +      } 
 +   } 
 + 
 +   /** 
 +    * Fürs Intro: Zufällige Zelle öffnen 
 +    */ 
 +   public void zufälligeZelleKlicken() { 
 +      int spalte = Math.floor(Math.random() * spalten); 
 +      int zeile = Math.floor(Math.random() * zeilen); 
 +      klickAufZelle(zellen[spalte][zeile]); 
 +   } 
 + 
 +   /** 
 +    * Markiere die Zelle mit einer Fahne 
 +    */ 
 +   public void setFahne(Zelle zelle) { 
 +      if(minesweeper.getMinenCounter().getNumber() > 0) { 
 +         zelle.setZustand(zelle.getInhalt(), true, true); 
 +         minesweeper.getMinenCounter().add(-1); 
 +      } 
 +   } 
 + 
 +   /** 
 +    * Entferne die Fahnen-Markierung der Zelle 
 +    */ 
 +   public void löscheFahne(Zelle zelle) { 
 +      zelle.setZustand(zelle.getInhalt(), true, false); 
 +      minesweeper.getMinenCounter().add(1); 
 +   } 
 + 
 +   /** 
 +    * Nachdem das Spiel verloren ist, werden alle Zellen aufgedeckt. 
 +    */ 
 +   public void allesAufdecken() { 
 +      for(int spalte = 0; spalte < spalten; spalte++) { 
 +         for(int zeile = 0; zeile < zeilen; zeile++) { 
 +             
 +            Zelle zelle = zellen[spalte][zeile]; 
 +            if(zelle.istZugedeckt()) { 
 +               if(zelle.hatFahne()) { 
 +                  if(zelle.getInhalt() == ZellBild.mine) { 
 +                     zelle.setZustand(ZellBild.mine_entschärft, false, false); 
 +                  } else { 
 +                     zelle.setZustand(ZellBild.hintergrund_leer, false, false); 
 +                  } 
 +               } else { 
 +                  zelle.aufdecken(); 
 +               } 
 +            } 
 + 
 +         } 
 +      } 
 + 
 +   } 
 + 
 +   /** 
 +    * Gibt genau dann true zurück, wenn alle Minen markiert und alle anderen 
 +    * Zellen aufgedeckt sind. 
 +    */ 
 +   public boolean alleAufgedeckt() { 
 +      for(int spalte = 0; spalte < spalten; spalte++) { 
 +         for(int zeile = 0; zeile < zeilen; zeile++) {  
 +            Zelle zelle = zellen[spalte][zeile]; 
 +            if(zelle.istZugedeckt() && !zelle.hatFahne()) return false; 
 +         } 
 +      }  
 +      return true; 
 +   } 
 + 
 +} 
 +</script> 
 + 
 +<script type="text/plain" title="Zelle.java"> 
 +// Indizes der Sprites für die verschiedenen Zellbilder 
 +class ZellBild { 
 +   static int mine = 0; 
 +   static int mine_entschärft = 1; 
 +   static int mine_explodiert = 2;  
 +   static int fahne = 3; 
 +   static int zahl_0 = 5; 
 +   static int zahl_8 = 13; 
 +   static int hintergrund_leer = 15; 
 +   static int zugedeckt = 16; 
 +} 
 + 
 +/** 
 + * Die Klasse Zelle repräsentiert eine quadratische Zelle des Spielfeldes. Sie wird mithilfe von  
 + * zwei Sprites gezeichnet: dem Hintergrund (Zell-Objekt ist selbst ein Sprite) und dem Vordergrund  
 + * (gleichnamiges Attribut). 
 + */ 
 +class Zelle extends Sprite { 
 +    
 +   private int inhalt;          // Sprite-Index des Zell-Bildes, siehe Klasse ZellBild 
 + 
 +   private boolean zugedeckt;   // == true, solange die Zelle noch nicht aufgedeckt ist 
 +   private boolean fahne;       // == true, falls die Zelle mit einer Fahne markiert ist 
 + 
 +   private Sprite vordergrund; 
 + 
 +   // Jede Zelle "kennt" das Spielfeld, auf dem sie platziert ist, und kann damit dessen 
 +   // öffentliche Methoden aufrufen. 
 +   private Spielfeld spielfeld; 
 + 
 +   private int spalte;          // Position der Zelle auf dem Spielfeld 
 +   private int zeile; 
 + 
 +   Zelle(Spielfeld spielfeld, int zustand, int spalte, int zeile) { 
 +      super(spielfeld.spalteToX(spalte), spielfeld.zeileToY(zeile), SpriteLibrary.Minesweeper, ZellBild.hintergrund_leer, ScaleMode.nearest_neighbour); 
 +      vordergrund = new Sprite(spielfeld.spalteToX(spalte), spielfeld.zeileToY(zeile), SpriteLibrary.Minesweeper, ZellBild.zugedeckt, ScaleMode.nearest_neighbour); 
 +      this.spielfeld = spielfeld; 
 +      this.spalte = spalte; 
 +      this.zeile = zeile; 
 +      setZustand(zustand, true, false); 
 +   } 
 + 
 +   public int getInhalt() { 
 +      return inhalt; 
 +   } 
 + 
 +   public int getZeile() { 
 +      return zeile; 
 +   } 
 + 
 +   public int getSpalte() { 
 +      return spalte; 
 +   } 
 + 
 +   public boolean istZugedeckt() { 
 +      return zugedeckt; 
 +   } 
 + 
 +   public boolean hatFahne() { 
 +      return fahne; 
 +   } 
 + 
 +   /** 
 +    * Ändert sich der Zustand der Zelle, so sorgt die Methode setZustand dafür, 
 +    * dass die Bilder der Sprites entsprechend gesetzt werden. 
 +    */ 
 +   public void setZustand(int inhalt, boolean zugedeckt, boolean fahne) { 
 +      if(zugedeckt) { 
 +         if(fahne) { 
 +            vordergrund.setImageIndex(ZellBild.fahne); 
 +         } else { 
 +            vordergrund.setImageIndex(ZellBild.zugedeckt); 
 +         } 
 +      } else { 
 +         vordergrund.setImageIndex(inhalt); 
 +      } 
 +      this.zugedeckt = zugedeckt; 
 +      this.fahne = fahne; 
 +      this.inhalt = inhalt; 
 +   } 
 + 
 +   public void destroy() { 
 +      super.destroy(); 
 +      vordergrund.destroy(); 
 +   } 
 + 
 +   /** 
 +    * Wird vom Browser aufgerufen, wenn der Mauszeiger sich von außen in die Zelle hineinbewegt 
 +    */ 
 +   public void onMouseEnter(double x, double y) { 
 +      if(zugedeckt && getSpielZustand() == Zustand.spiel_läuft) { 
 +         vordergrund.tint("#ff8080"); 
 +         getWorld().setCursor("pointer"); 
 +      } 
 +   } 
 + 
 +   /** 
 +    * Wird vom Browser aufgerufen, wenn der Mauszeiger sich aus der Zelle 
 +    * hinausbewegt. 
 +    */ 
 +   public void onMouseLeave(double x, double y) { 
 +      vordergrund.tint("#ffffff");  
 +      getWorld().setCursor("default"); 
 +   } 
 +    
 +   /** 
 +    * Wird vom Browser aufgerufen, wenn eine der Maustasten nach unten gedrückt wird. 
 +    */ 
 +   public void onMouseDown(double x, double y, int key) { 
 +      vordergrund.tint("#ff0000"); 
 +   } 
 + 
 +   /** 
 +    * Wird vom Browser aufgerufen, wenn eine der Maustasten losgelassen wird. 
 +    */ 
 +   public void onMouseUp(double x, double y, int key) { 
 +      if(getSpielZustand() != Zustand.spiel_läuft) return; 
 + 
 +      if(key == 0) {  // linke Maustaste, also aufdecken 
 +         if(fahne) return;  
 +         // Mine erwischt? 
 +         if(inhalt == ZellBild.mine) { 
 +            inhalt = ZellBild.mine_explodiert; 
 +            setZustand(inhalt, zugedeckt, fahne); 
 +            spielfeld.getMinesweeper().setZustand(Zustand.spiel_verloren); 
 +            return; 
 +         } 
 +         spielfeld.klickAufZelle(this);  
 +      } else { 
 +         // Rechte Maustaste => Fahne setzen oder löschen 
 +         if(zugedeckt) { 
 +            if(!fahne) { 
 +               spielfeld.setFahne(this); 
 +            } else { 
 +               spielfeld.löscheFahne(this); 
 +            } 
 +         } 
 +      } 
 + 
 +      // Spiel gewonnen? 
 +      if(spielfeld.alleAufgedeckt()) { 
 +         spielfeld.getMinesweeper().setZustand(Zustand.spiel_gewonnen); 
 +      } 
 +          
 +   } 
 + 
 +   public void aufdecken() { 
 +      setZustand(inhalt, false, false); 
 +   } 
 + 
 +   public Zustand getSpielZustand() { 
 +      return spielfeld.getMinesweeper().getZustand(); 
 +   } 
 +} 
 +</script> 
 + 
 +<script type="text/plain" title="Smiley.java"> 
 +/** 
 + * Das Smiley-Objekt stellt den Smiley über dem Spielfeld dar. 
 + */ 
 +class Smiley extends Sprite { 
 + 
 +   private Minesweeper minesweeper; 
 +    
 +   Smiley(int x, int y, Minesweeper minesweeper) { 
 +      super(x, y, SpriteLibrary.Minesweeper, 18, ScaleMode.nearest_neighbour); 
 +      this.minesweeper = minesweeper; 
 +      scale(2); 
 +   } 
 + 
 +   public void onMouseDown(double x, double y, int key) { 
 +      minesweeper.onSmileyKlicked(); 
 +   } 
 + 
 +   public void showSmile() { 
 +      this.setImageIndex(18); 
 +   } 
 + 
 +   public void showCryingFace() { 
 +      this.setImageIndex(17); 
 +   } 
 + 
 +   public void showFaceWithSunglasses() { 
 +      this.setImageIndex(19); 
 +   } 
 + 
 +   public void onMouseEnter(double x, double y) { 
 +      if(minesweeper.getZustand() != Zustand.spiel_läuft) {  
 +         getWorld().setCursor("pointer"); 
 +         tint("#b0b0b0"); 
 +      } 
 +   } 
 + 
 +   public void onMouseLeave(double x, double y) { 
 +      getWorld().setCursor("default"); 
 +      tint("#ffffff"); 
 +   } 
 +} 
 +</script> 
 + 
 +<script type="text/plain" title="Counter.java"> 
 +/** 
 + * Ein Objekt dieser Klasse stellt einen roten dreistelligen Zähler dar. 
 + */ 
 +class Counter extends Group { 
 +    
 +   private Sprite[] digits = new Sprite[3];  // je Ziffer ein Sprite 
 +   private int number = 0; // Zahl, die der Counter gerade darstellt 
 +    
 +   Counter(int x, int y) { 
 +      super(); 
 +      for(int i = 0; i < 3; i++) { 
 +         digits[i] = new Sprite(x + 32 * i, y, SpriteLibrary.Minesweeper, 22); 
 +      } 
 +   } 
 +    
 +   /** 
 +    * Stellt die übergebene Zahl auf dem Bildschirm dar. 
 +    */ 
 +   public void set(int number) { 
 +      this.number = number; 
 +      for(int i = 0; i < 3; i++) { 
 +         digits[2 - i].setImageIndex(22 + number % 10); 
 +         number /= 10; 
 +      } 
 +   } 
 + 
 +   public int getNumber() { 
 +      return number; 
 +   } 
 + 
 +   public void add(int n) { 
 +      set(number + n); 
 +   } 
 + 
 +} 
 +</script> 
 + 
 + 
 +</div> 
 + 
 +</HTML> 
  
  
api/projects/minesweeper/start.1609166076.txt.gz · Zuletzt geändert: 2021/12/29 11:29 (Externe Bearbeitung)
Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki