Quellcode

Autor: Timo Münzing

Spielname: Genesis

Zweck: Jahresarbeit(15 Punkte)/ Win2005 (Platz 9)

//Die importierten Klassen:

import java.awt.*;

import java.applet.*;

import java.awt.event.*;

//Die Hauptklasse:

public class Genesis extends Applet implements KeyListener

{

//Assoziationen:

Spielplan plan = new Spielplan();

AktivesBauteil bau = new AktivesBauteil(plan);

//Variablendeklarierung: In score wird der aktuelle Punktestand geladen,

//in linien wie viele Linien schon abgebaut wurden und der Zustand sagt

//aus, in welcher Phase des Spiels wir uns befinden

private int score, linien, zustand=0;

//Die init-Methode wird insgesamt einmal durchlaufen

public void init()

{

//den KeyListener registrieren

addKeyListener(this);

setSize(600,600);

}

//Die wichtigste Mezhode: paint(), in der der Grundleghende Ablauf des

//Programms geregelt wird

public void paint(Graphics g)

{

//Der Wert des Zustands gibt die Phase/den Bereich des Spiels an, in der

//wir uns befinden: 0-Anfangsvideo, dem das Hauptmenü folgt_1-Das Spiel

//selbst_2-Spiel vorbei, also Game Over_3-Die Anleitung_4-Beschreibung

//zum Spiel_5-Das Optionsmenü_

switch(zustand)

{

case 0:

{

//Anfangsvideo wird gezeichnet

plan.anfang(g);

break;

}

case 1:

{

//Spielplan wird gezeichnet

plan.zeichnen(g, bau);

//Falls das Bauteil fertig ist, also nicht mehr bewegt werden kann,

// ist bau.getFertig() true

if(bau.getFertig())

{

//Es werden die nötigen Abfragen/Zeichnungen vorgenommen, falls

//Linien vollständig sind, das Bauteil wieder bewegbar gemacht

//und score und linien werden aktuallisiert

plan.vollstaendig(g, bau);

bau.setFertigFalse();

score=plan.getPunkte();

linien=plan.getLines();

}

//Falls die maximale Bewegungsanzahl erreicht wurde, wird das

//Bauteil fallen gelasst

if(bau.bewegungen())

{

bau.fallenLassen(plan);

}

//Es wird im Spielplan abgefragt, ob man gameOver ist und die dann

//nötigen Veränderungen im Plan vorgenommen

plan.gameOver(g);

//Falls festgestellt wurde, dass man gameOver ist, werden die

//nötigen Veränderungen am Bauteil vorgenommen und der Zustand

//auf 2 gesetzt

if(plan.getOver())

{

bau.gameOver();

zustand=2;

}

break;

}

case 2:

{

//case 2 ist nur der Vollständigkeit/Übersicht halber angegeben,

//könnte an dieser Stelle auch weggelassen werden

break;

}

case 3:

{

//Die Anleitung wird gezeichnet

plan.anleitung(g);

break;

}

case 4:

{

//Die Beschreibung wird gezeichnet

plan.beschreibung(g);

break;

}

case 5:

{

//Das Optionsmenü wird gezeichnet

plan.optionen(g, bau);

}

//Diese Methode wird bei einem Tastendruck aufgerufen. Ihr wird als

//Parameter eine Variable des Typs KeyEvent übergeben, in der alle

//wichtigen Informationen (z.B. welche Taste gedrückt wurde) gespeichert

//werden.

public void keyPressed(KeyEvent e)

{

//Der Variable key wird der "KeyCode" zugewiesen um in den Abfragen mir

//der Variable arbeiten zu können

int key = e.getKeyCode();

//Je nach dem welcher Zustand gerade ist wird auf die Taste, die gedrückt

//wurde anders reagiert. Im folgenden wird also im aktuellen Zustand

//danach gefragt, welche Taste gedrückt wurde.

if(zustand==0)

{

//Der Zustand 0 ist ja das Anfangsvideo/Hauptmenü, man bestimmt also

//mit den Tastendrucken, welcher Zustand als nächstes kommt -->

//Zustandsvariable bekommt also neuen Wert und Paint wird erneut

//ausgeführt

if(key == KeyEvent.VK_F5)

{

zustand=1;

repaint();

}

if(key == KeyEvent.VK_F6)

{

zustand=3;

repaint();

}

if(key == KeyEvent.VK_F7)

{

zustand=5;

repaint();

}

if(key == KeyEvent.VK_F8)

{

zustand=4;

repaint();

}

if(key == KeyEvent.VK_F9)

{

repaint();

}

//Der Zweck der folgenden Methoden wird bereits durch ihren Namen dargestellt:

if(zustand==1)

{

//Das Spiel selbst

if(key == KeyEvent.VK_RIGHT)

{

bau.rechtsBewegen(plan);

repaint();

}

if(key == KeyEvent.VK_LEFT)

{

bau.linksBewegen(plan);

repaint();

}

if(key == KeyEvent.VK_UP)

{

bau.hochGedrueckt(plan);

repaint();

}

if(key == KeyEvent.VK_DOWN)

{

bau.natuerlicheBewegung(plan);

repaint();

}

if(key == KeyEvent.VK_F1)

{

bau.fallenLassen(plan);

repaint();

}

if(zustand==2)

{

//Das Spiel ist aus - Game Over

if(key == KeyEvent.VK_F5)

{

//Zurücksetzen der nötigen Variablen auf den Ausgangszustand

zustand=0;

plan.neu();

bau.neu(plan);

bau.setUserErlaubteBew();

repaint();

}

if(zustand==3 || zustand==4)

{

//Zustand 3 = Anleitung, Zustand 4 = Beschreibung

if(key == KeyEvent.VK_F5)

{

zustand=0;

repaint();

}

if(zustand==5)

{

//Das Optionsmenü

if(key == KeyEvent.VK_F1)

{

bau.setErlaubteBew(-1);

repaint();

}

if(key == KeyEvent.VK_F2)

{

bau.setErlaubteBew(1);

repaint();

}

if(key == KeyEvent.VK_F3)

{

plan.aendereBlackout();

repaint();

}

if(key == KeyEvent.VK_F4)

{

plan.aendereSchwererStein();

repaint();

}

if(key == KeyEvent.VK_F5)

{

zustand=0;

repaint();

}

//Die folgenden beiden Methoden müssen im Programm vorhanden sein, da der

//KeyListener implementiert wurde, sind in diesem Spiel jedoch ohne Funktion

//keyTyped wird immer beim Drücken einer Zeichentaste aufgerufen (also nicht

//beim Drücken einer Funktionstaste)

public void keyTyped(KeyEvent e){}

//keyReleased wird aufgerufen, wenn eine Taste losgelassen wird

public void keyReleased(KeyEvent e){}

}

//Die Klasse, die für die einzlnen Bausteine verantwortlich ist: allerdings gibt

//es nur ein Objekt dieser Klasse, das jeweils aktive Bauteil, da das in diesem

//Kontext Programmieraufwand spart (siehe Dokumentation)

class AktivesBauteil

{

//zusammensetzungBau[][] gibt den aktuellen Aufbau des Teils in einem 3*3

//großen Quadrat an

private int[][]zusammensetzungBau = new int [3][3];

//zusammensetzungBau2[][] ist als Übergangsspeicher nötig, wenn man das

//Bauteil dreht(siehe weiter unten)

private int[][]zusammensetzungBau2 = new int[3][3];

//fertig gibt an, ob das Bauteil noch bewegt wrden kann (nimmt den wert true

//an, wenn es ganz unten ist), endeBewegungen sagt, ob die maximale Anzahl an

//Bewegungen überschritten wurde, blacknow ob es bei dieser Bewegung einen

//BlackOut gibt, die restlichen Variablennamen lassen deren Verwendung ja

//eindeutig erkennen

private boolean bewegbar=true, rechtsMoeglich=true, linksMoeglich=true, hochMoeglich=true, fertig=false, endeBewegungen=false, blacknow=false;

//Die art sagt aus, wie das Bateil bis su seinem Zurüksetzen aussehen soll,

//es wird also je nach Wert dieser Variable aufgebaut, artwähler hilft

//hierbei, damit zum beispiel manche Teile öfter erscheinen

private int art, artwähler, x_pos, y_pos, bewegungen, erlaubteBew=50, userErlaubteBew=50, anzSteine;

//Konstruktor(dem ein Objekt des Typs Spielplan übergeben wird):

AktivesBauteil(Spielplan spPlan)

{

neu(spPlan);

}

//Diese Methode wird aufgerufen, wenn ein "neues Bauteil" erstellt werden

//soll. Dieses neue Bauteil ist dann aber kein neues Objekt, sondern dem

//bereits bestehenden werden wieder neue Werte zugewiesen. Der Methode muss

//auch ein Objekt des Typs Spielplan übergeben werden, da im Spielplan

//gespeichert ist, ob der User den BlackOut und SchwererStein Modus ein oder

//uasgeschaltet ist.

public void neu(Spielplan spPlan)

{

//Wenn das Bauteil wieder neu erscheint, müssen die Variablen ja

//bestimmte Anfangswerte bekommen:

bewegungen=0;

endeBewegungen=false;

x_pos=(int)(Math.random()*26)+1;

y_pos=1;

//wenn der Blackoutmodus eingeschaltet ist, gibt es eine mathematische

//Wahrscheinlichkeit von 1/10, dass dieser beim aktuellen Bauteil auch

//eintritt.

if(spPlan.getBlackout())

{

blacknow=false;

if((int)(Math.random()*10)==9)

{

blacknow=true;

}

//hier gilt gleiches wie beim Blackout, nur dass hier der

//schwereSteinmodus abgefragt wird und bei dessem Eintritt

//die Bewegungsmöglichkeiten halbiert werden

if(spPlan.getSchwererStein())

{

if((int)(Math.random()*10)==9)

{

bewegungen=erlaubteBew/2;

}

//wenn ein neues Bauteil auf dem Schirm erscheint, wird natürlich die

//Steinanzahl erhöht

anzSteine++;

//Die Anzahl der erlaubten Bewegungen wird immer nach 20 Steinen

//um 1 verringert

if(anzSteine%20==0 && erlaubteBew>9)

{

erlaubteBew--;

}

//Über die folgenden Befehle wird bewirkt, dass bestimmte Teile öfters

//vorkommen:

artwähler = (int)(Math.random()*22)+1;

if(artwähler<=2)art=1;else

if(artwähler<=5) art=2;else

if(artwähler<=8) art=3;else

if(artwähler<=11) art=4;else

if(artwähler<=14) art=5;else

if(artwähler<=17) art=6;else

if(artwähler<=20) art=7;else

if(artwähler<=21) art=8;else

if(artwähler<=23) art=9;

//Festlegung des Aussehens: Zuerst bekommen alle Stellen des 3*3 Feldes

//des Bauteils den Wert 100...

for(int i=0; i<3; i++)

{

for(int j=0; j<3; j++)

{

zusammensetzungBau[i][j]=100;

}

//...dann bekommt das Feld je nach Wert von art verschiedene Stellen auf

//eine andere Zahl gesetzt, wodurch das Bauteil entsteht, und vom Programm

//durch die verschiedenen Zahlen auch unterschieden werden kann. (Genauere

//Erläuterungen hierzu sind in der Dokumentation zu finden)

switch(art)

{

case 1:

{

zusammensetzungBau[0][1]=1;

zusammensetzungBau[0][2]=1;

zusammensetzungBau[1][0]=1;

zusammensetzungBau[1][1]=1;

}

break;

case 2:

{

zusammensetzungBau[1][2]=2;

zusammensetzungBau[2][2]=2;

zusammensetzungBau[2][1]=2;

}

break;

case 3:

{

zusammensetzungBau[1][0]=3;

zusammensetzungBau[1][1]=3;

zusammensetzungBau[1][2]=3;

}

break;

case 4:

{

zusammensetzungBau[1][0]=4;

zusammensetzungBau[1][2]=4;

zusammensetzungBau[2][0]=4;

zusammensetzungBau[2][1]=4;

zusammensetzungBau[2][2]=4;

}

break;

case 5:

{

zusammensetzungBau[1][1]=5;

zusammensetzungBau[2][0]=5;

zusammensetzungBau[2][1]=5;

zusammensetzungBau[2][2]=5;

}

break;

case 6:

{

zusammensetzungBau[1][2]=6;

zusammensetzungBau[2][0]=6;

zusammensetzungBau[2][1]=6;

zusammensetzungBau[2][2]=6;

}

break;

case 7:

{

zusammensetzungBau[0][0]=7;

zusammensetzungBau[0][1]=7;

zusammensetzungBau[0][2]=7;

zusammensetzungBau[1][2]=7;

}

break;

case 8:

{

zusammensetzungBau[0][1]=8;

zusammensetzungBau[1][0]=8;

zusammensetzungBau[1][1]=8;

zusammensetzungBau[1][2]=8;

zusammensetzungBau[2][1]=8;

}

break;

case 9:

{

zusammensetzungBau[1][0]=9;

zusammensetzungBau[1][1]=9;

zusammensetzungBau[2][1]=9;

zusammensetzungBau[2][2]=9;

}

break;

}

//Die natürliche Bewegung ist die Bewegung des Bauteils um eins nach unten /

//es muss ein Objekt des Typs Spielplan übergeben werden, da diese Bewegung

//ja auf dem Spielpan stattfindet (wie auch bei den folgenden Bewegungen)

public void natuerlicheBewegung(Spielplan plan)

{

//rundsätzlich ist das Bauteil bewegbar und die Beegungen nehmen um ein zu

bewegbar=true;

bewegungen++;

//Abfragen, ob nach unten bewegt werden darf:

for(int i=2; i>=0; i--)

{

for(int j=0; j<3; j++)

{

//Abfrage nur nötig, wenn an der Stelle, die bewegt werden soll,

//nicht 100, also keine leere Stelle ist

if(zusammensetzungBau[j][i]!=100)

{

//2 Fälle zu beachten: entweder das unterste Stück, dann i=2...

if(i==2)

{

//wenn ein Punkt unter dieser Stelle schon etwas ist, ist

//dieses Bauteil nun unbewegbar

if(plan.getZusammensetzungPlan(x_pos+j, y_pos+i+1)!=0)

{

bewegbar=false;

j=3;

i=0;

}

//...oder die Stelle darüber, die allerdings nur abgefragt werden

//muss, falls unter dieser Stelle leer ist

else

{

//wenn ein Punkt unter dieser Stelle schon etwas ist, das kein

//Bestandteil des Bauteils ist, ist Teil unbewegbar

if(zusammensetzungBau[j][i+1]==100)

{

if(plan.getZusammensetzungPlan(x_pos+j,y_pos+i+1)!=0)

{

bewegbar=false;

j=3;

i=0;

}

//falls das Teil bewegbar ist, so sinkt es um eine Stelle nach unten

//(y_pos), die Angaben auf dem Spielplan werden durch die neuen Angaben

//ersetzt und die oberste Reihe des Bauteils wird auf dem Spielplan wieder

//auf leer gesetzt, falls sich nicht ein anderes Teil im Einzugsbereich

//befindet (genaueres kann zum besseren Verständnis in der Dokumentation

//nachgelesen werden)

if(bewegbar)

{

y_pos=y_pos+1;

ersetzen(plan);

for(int i=0; i<3; i++)

{

if(plan.getFrei(x_pos+i,y_pos-1))

{

plan.setZusammensetzungPlan(x_pos+i, y_pos-1, 0);

}

//falls das Teil nicht bewegbar ist, wurd due Stelle als nicht frei

//makiert und das Teil wird abgespeichert...

else

{

for(int i=0; i<3; i++)

{

for(int j=0; j<3; j++)

{

if(zusammensetzungBau[i][j]!=100)

{

plan.setFreiFalse(x_pos+i, y_pos+j);

plan.setTeile(x_pos+i, y_pos+j, 50+anzSteine);

}

//...falls das der Fall ist, dann ist das Teil auch fertig und muss

//zurückgesetzt (mit der Methode neu()) werden

fertig=true;

neu(plan);

}

//rechtsBewegung()/linksBewegung() sind aufgebaut wie natuerlicheBewegung(),

//zuerst wird abgefragt, ob die Bewegung möglich ist, danachwird sie

//ausgeführt. Unterschiedlich sind natürlich nur die Bereiche, die abgefragt

//werden. Falls die Bewegung nicht möglich sein sollt, so wird automatisch

//eine natürliche Bewegung ausgeführt.

public void rechtsBewegen(Spielplan plan)

{

bewegungen++;

for(int i=2; i>=0; i--)

{

for(int j=0; j<3; j++)

{

if(zusammensetzungBau[i][j]!=100)

{

if(i==2)

{

if(plan.getZusammensetzungPlan(x_pos+3, y_pos+j)!=0)

{

rechtsMoeglich=false;

j=3;

i=0;

}

else

{

if(zusammensetzungBau[i+1][j]==100)

{

if(plan.getZusammensetzungPlan(x_pos+i+1,y_pos+j)!=0)

{

rechtsMoeglich=false;

j=3;

i=0;

}

if(rechtsMoeglich)

{

x_pos=x_pos+1;

ersetzen(plan);

for(int i=0; i<3; i++)

{

if(plan.getFrei(x_pos-1,y_pos+i))

{

plan.setZusammensetzungPlan(x_pos-1, y_pos+i, 0);

}

else

{

natuerlicheBewegung(plan);

}

rechtsMoeglich=true;

}

public void linksBewegen(Spielplan plan)

{

bewegungen++;

for(int i=0; i<3; i++)

{

for(int j=0; j<3; j++)

{

if(zusammensetzungBau[i][j]!=100)

{

if(i==0)

{

if(plan.getZusammensetzungPlan(x_pos-1, y_pos+j)!=0)

{

linksMoeglich=false;

j=3;

i=3;

}

else

{

if(zusammensetzungBau[i-1][j]==100)

{

if(plan.getZusammensetzungPlan(x_pos+i-1,y_pos+j)!=0)

{

linksMoeglich=false;

j=3;

i=3;

}

if(linksMoeglich==true)

{

x_pos=x_pos-1;

ersetzen(plan);

for(int i=0; i<3; i++)

{

if(plan.getFrei(x_pos+3,y_pos+i))

{

plan.setZusammensetzungPlan(x_pos+3, y_pos+i, 0);

}

else

{

natuerlicheBewegung(plan);

}

linksMoeglich=true;

}

//erseten lässt das Bauteil auf den Spielplan in der neuen Position des 3*3

//Quadrates abbilden

public void ersetzen(Spielplan plan)

{

for(int i=0; i<3; i++)

{

for(int j=0; j<3; j++)

{

//Je nachdem was an der Stelle des Bauteilquadrates ist, wird die

//Stelle im Spielplan mit dem jeweilgien Wert des Bauteils makiert

//oder als frei gekennzeichnet (Wert 0)

if(zusammensetzungBau[i][j]!=100)

{

plan.setZusammensetzungPlan(x_pos+i, y_pos+j, zusammensetzungBau[i][j]);

}

else

{

if(plan.getFrei(x_pos+i,y_pos+j))

{

plan.setZusammensetzungPlan(x_pos+i, y_pos+j, 0);

}

//wenn man nach unten drückt, so soll eine "natürliche Bewegung"

//durchgeführt werden

public void runterGedrueckt(Spielplan plan)

{

for(int i=0; i<2; i++)

{

if(bewegbar==true)

{

this.natuerlicheBewegung(plan);

}

//wenn man das Teil fallen lassen will, so lässt man natürliche Bewegungen

//ausühren und zwar bis es nicht mehr bewegbar ist

public void fallenLassen(Spielplan plan)

{

this.natuerlicheBewegung(plan);

}

while(bewegbar==true);

}

//wenn man hoch drückt, so soll sich das Bauteil drehen

public void hochGedrueckt(Spielplan plan)

{

//Dies zählt ebenfalls als Bewegung, also wird bewegungen um ein erhöht

bewegungen++;

//Zuerst fragen wir ab, ob wir überhaupt drehen dürfen, dies ist der Fall,

//wenn sich im Einzugsquadrat des Bauteils auf dem Spielplan keine Wände

//oder anderes Bauteil befindet

for(int i=0; i<3; i++)

{

for(int j=0; j<3; j++)

{

if(plan.getFrei(x_pos+i,y_pos+j)==false)

{

hochMoeglich=false;

i=3;

j=3;

}

//Falls die Drehung möglich ist, wird in zusammensetzungBau2[][] das neue

//Aussehen gespeichert...

if(hochMoeglich==true)

{

for(int i=0; i<3; i++)

{

zusammensetzungBau2[i][0]=zusammensetzungBau[0][2-i];

zusammensetzungBau2[i][2]=zusammensetzungBau[2][2-i];

}

zusammensetzungBau2[0][1]=zusammensetzungBau[1][2];

zusammensetzungBau2[2][1]=zusammensetzungBau[1][0];

zusammensetzungBau2[1][1]=zusammensetzungBau[1][1];

//...und danach wieder in zusammensetzungBau[][] zurückgespeichert...

for(int i=0; i<3; i++)

{

for(int j=0; j<3; j++)

{

zusammensetzungBau[i][j]=zusammensetzungBau2[i][j];

}

//...und die neue Anordnung auf dem Spielplan gezeichnet

ersetzen(plan);

}

//für den nächsten Drehversuch wird hochMoeglich wieder auf true gesetzt,

//damit man oben wieder abfragen kann, ob das auch wirklich möglich ist,

//da hochMoeglich ja wieder auf false gesetzt wird, wenn es nicht möglich

//ist

hochMoeglich=true;

}

//Methode zum Abfragen, ob noch Bewegungen erlaubt sind

public boolean bewegungen()

{

if(bewegungen>=erlaubteBew)

{

endeBewegungen=true;

}

return endeBewegungen;

}

//wenn man gameOver ist, dann werden die eraubte Bewegungen wieder auf die

//vom User erlaubten gesetzt und die Anzahl der Steine auf 0 zurückgesetzt

public void gameOver()

{

erlaubteBew = userErlaubteBew;

anzSteine = 0;

}

//Verändern des Wertes von erlaubten Bewegungen, falls der veränderte Wert

//noch mindesten 1 oder größer ist

public void setErlaubteBew(int zahl)

{

if(erlaubteBew+zahl>0)

{

erlaubteBew=erlaubteBew+zahl;

}

//alles weiete sind get- und set-Methoden, die für sich spechen

public void setUserErlaubteBew()

{

erlaubteBew=userErlaubteBew;

}

public void setFertigFalse()

{

fertig=false;

}

public boolean getFertig()

{

return fertig;

}

public boolean getBlacknow()

{

return blacknow;

}

public int getBewegungen()

{

return bewegungen;

}

public int getErlaubteBew()

{

return erlaubteBew;

}

class Spielplan

{

//zusammensetzungPlan[][] gibt den Aufbau des Spielplans so an, dass er nach

//verschiedenen Arten von Teilen unterschieden werden kann

private int[][]zusammensetzungPlan = new int [32][31];

//teile[][] gibt den Aufbau so an, dass auch Teile gleicher Art voneinander

//unterschieden werden können, aber man kann dafür nicht die Art des Bauteils

//direkt bestimmen

private int[][]teile = new int [32][31];

//voll1[] bis voll3[] gibt an, ob und wo Reihen vollständig sind

private boolean[]voll1 = new boolean[30];

private boolean[]voll2 = new boolean[30];

private boolean[]voll3 = new boolean[30];

//frei gibt einfach nur an, ob ein Bereich des Plans belegt ist oder nicht

private boolean[][]frei = new boolean [32][31];

//nötig, damit nicht Reihen im oberen Bereich des Bildschirms sich

//verschieben, wenn links oder rechts des Sockels Reihen abgebaut werden

private boolean[][]verschiebbarRechts = new boolean [32][31];

private boolean[][]verschiebbarLinks = new boolean [32][31];

//Der Verwendungszweck dieser Variablen ist bereits an ihrem Namen zu erkennen

private int pktStand, lineStand, pktMenge, zeichnungsHilfe, highScore, pktWertigkeit;

//vollstaendig1 bis vollstaendig3 werden benutzt um voll1[] bis voll3[] die

//richtigen Werte zuzuschreiben, punkte sagt aus, ob man in dem aktuellen

//Spielzug Punkte bekommt, gameOver wird true, wenn man eben Game Over ist,

//into sagt aus, ob man bei der Rückkehr zum Hauptmenü das Intro sieht und

//blackou und schwererStein geben natürlich an, ob diese Modi an oder

//ausgeschaltet sind

private boolean vollstaendig1, vollstaendig2, vollstaendig3, vollstaendigeReihe, punkte, gameOver, intro=true, blackout, schwererStein, weitereVerschiebungsabfragen=false;

//Die Fonts sind die verschiedenen Schriftarten

Font klein = new Font("Serif", Font.BOLD, 15);

Font klein2 = new Font("Serif", Font.BOLD, 20);

Font ganzKlein = new Font("Serif", Font.BOLD, 12);

Font titel = new Font("sansSerif", Font.BOLD, 50);

Font unter = new Font("Dialog", Font.BOLD, 26);

Font game = new Font("Serif", Font.BOLD, 80);

Font game2 = new Font("Serif", Font.BOLD, 26);

//Konstruktor:

Spielplan()

{

neu();

}

//neu() lässt die nötigen Variablen ihre Grundwerte zuweisen und gibt den

//Feldern somit ihr "Aussehen" (siehe Dokumentation)

public void neu()

{

for(int i=0; i<32; i++)

{

for(int j=0; j<31; j++)

{

frei[i][j]=true;

zusammensetzungPlan[i][j]=0;

gameOver=false;

}

for(int i=0; i<31 ;i++)

{

zusammensetzungPlan[0][i]=50;

zusammensetzungPlan[31][i]=50;

frei[0][i]=false;

frei[31][i]=false;

}

for(int i=0; i<32 ;i++)

{

zusammensetzungPlan[i][30]=50;

frei[i][30]=false;

}

for(int i=20; i<30; i++)

{

for(int j=11; j<21 ;j++)

{

zusammensetzungPlan[j][i]=50;

frei[j][i]=false;

}

pktStand=0;

lineStand=0;

pktWertigkeit=10;

}

//zeichnen gibt, wie der Name schon erwarten lässt, den Spielplan auf dem

//Bildschirm aus

public void zeichnen(Graphics g, AktivesBauteil bau)

{

//Der "Rahmen" des Spielplans:

g.setColor(new Color(10,50,80));

g.fillRect(0,0,1000,1000);

g.setColor(Color.white);

g.fillRect(100,200,320,310);

//Nun wird zu jedem Quadrat des Spielplans die zusammensetzung abgefragt,

//und je nach Wert von dieser, bekommt das entsprechende Quadrat auf dem

//Bildschirm eine andere Farbe

for(int i=0; i<32; i++)

{

for(int j=0; j<31; j++)

{

switch(zusammensetzungPlan[i][j])

{

case 1:

{

g.setColor(Color.blue);

g.fillRect(i*10+100, j*10+200, 10, 10);

g.setColor(Color.black);

break;

}

case 2:

{

g.setColor(Color.red);

g.fillRect(i*10+100, j*10+200, 10, 10);

g.setColor(Color.black);

break;

}

case 3:

{

g.setColor(Color.yellow);

g.fillRect(i*10+100, j*10+200, 10, 10);

g.setColor(Color.black);

break;

}

case 4:

{

g.setColor(Color.gray);

g.fillRect(i*10+100, j*10+200, 10, 10);

g.setColor(Color.black);

break;

}

case 5:

{

g.setColor(Color.green);

g.fillRect(i*10+100, j*10+200, 10, 10);

g.setColor(Color.black);

break;

}

case 6:

{

g.setColor(Color.pink);

g.fillRect(i*10+100, j*10+200, 10, 10);

g.setColor(Color.black);

break;

}

case 7:

{

g.setColor(Color.darkGray);

g.fillRect(i*10+100, j*10+200, 10, 10);

g.setColor(Color.black);

break;

}

case 8:

{

g.setColor(Color.orange);

g.fillRect(i*10+100, j*10+200, 10, 10);

g.setColor(Color.black);

break;

}

case 9:

{

g.setColor(Color.magenta);

g.fillRect(i*10+100, j*10+200, 10, 10);

g.setColor(Color.black);

break;

}

case 50:

{

g.setColor(Color.black);

g.fillRect(i*10+100, j*10+200, 10, 10);

break;

}

//falls es aber in diesem Spielzug einen Black Out gibt, so wird das

//Spielfeld schwarz:

if(bau.getBlacknow() && blackout)

{

g.setColor(Color.black);

g.fillRect(100,200,320,310);

}

//Zeichnung der Spielfeldumgebeung

g.setColor(Color.white);

g.fillRect(440, 180, 120, 50);

g.fillRect(440, 280, 120, 50);

g.fillRect(440, 380, 120, 50);

g.fillRect(440, 480, 120, 50);

g.setFont(titel);

g.drawString("Genesis", 160, 130);

g.setColor(new Color(230,230,230));

g.fillRect(110, 200, 300, 20);

g.setColor(Color.black);

g.drawLine(110, 250, 410, 250);

g.setFont(klein);

g.drawString("Bewegungen: "+(bau.getErlaubteBew()-bau.getBewegungen()), 445, 210);

g.drawString("Punkte: "+pktStand, 455, 310);

g.drawString("Linien: "+lineStand, 455, 410);

g.drawString("heutige", 455, 500);

g.drawString("Highscore", 443, 520);

g.drawString(": "+highScore, 515, 509);

}

//Abfrage, ob eine Reihe vollständig ist --> eine exaktere Erklrung befindet

//sich in der Dokumentation

public void vollstaendig(Graphics g, AktivesBauteil bau)

{

//Die nachfolgenden Variablen bekommen nun die Werte, auf die die

//nachfolgende Sequenz ausgerichtet ist

punkte=false;

vollstaendig1=true;

vollstaendig2=true;

vollstaendig3=true;

//Im folgenden wird oft auf die für Zählschleifen typischen

//Variablennamen i und j verzichtet und durch x und y ersetzt,

//da diese hier die x und y Werte auf dem Spielplan wiedergeben

for(int y=0; y<30; y++)

{

voll1[y]=false;

voll2[y]=false;

voll3[y]=false;

}

//Zurst werden nur die Reihen bis zur Höhe des Sockels abgefragt

for(int y=20; y<30; y++)

{

for(int x=1; x<11; x++)

{

//Für jeden y Wert, in der Höhe des Sockels angefangen und nach

//unten fortgesetzt, wird zu jedem x Wert abgefragt, ob das

//entsprechde Quadrat besetzt ist oder nicht - ist eines nicht

//besetzt, so kann ja auch diese Reihe nicht vollständig sein /

//Zuerst wird die linke Seite, dann die um den Wert 20

//verschobene rechte Seite abgefragt

if(zusammensetzungPlan[x][y]==0)

{

vollstaendig1=false;

}

if(zusammensetzungPlan[x+20][y]==0)

{

vollstaendig2=false;

}

//falls eine Reihe vollständig ist, so wird dies in voll1[] oder

//voll2[] festgehalten

if(vollstaendig1)

{

voll1[y]=true;

}

if(vollstaendig2)

{

voll2[y]=true;

}

vollstaendig1=true;

vollstaendig2=true;

}

//danach wird diese Abfrage mit dem, was über dem Sockel liegt

//durchgeführt

for(int y=3; y<20; y++)

{

//Es wird nach selben System wie oben abgefragt und gespeichert, ob

//und wo Reihen vollständig sind

for(int x=1; x<31; x++)

{

if(zusammensetzungPlan[x][y]==0)

{

vollstaendig3=false;

}

if(vollstaendig3)

{

voll3[y]=true;

}

vollstaendig3=true;

}

//Bevor nun die Teile verschoben werden,muss zuerst festgelegt

//werden, welche verschoben werden können (siehe Dokumentation)

//aber nur, wenn auch verschoben wird

vollstaendigeReihe=false;

for(int i=5; i<30; i++)

{

if(voll1[i]||voll2[i]||voll3[i])

{

i=30;

vollstaendigeReihe=true;

}

if(vollstaendigeReihe)

{

for(int k=0; k<32; k++)

{

for(int j=0; j<31; j++)

{

verschiebbarRechts[k][j]=true;

verschiebbarLinks[k][j]=true;

}

for(int k=1; k<21; k++)

{

if(frei[k][19]==false)

{

verschiebbarRechts[k][19]=false;

}

for(int k=11; k<31; k++)

{

if(frei[k][19]==false)

{

verschiebbarLinks[k][19]=false;

}

verschiebbarkeitFestlegen(verschiebbarRechts);

verschiebbarkeitFestlegen(verschiebbarLinks);

//Nun werden die vollständigen Reihen im spielbaren Bereich

//abgefragt und bearbeitet

for(int i=5; i<30; i++)

{

//Abfrage links des Sockels

if(voll1[i])

{

lineStand++;

//alle 10 Linien wird dir Punktwertigkeit verdoppelt

if(lineStand%10==0)

{

pktWertigkeit=pktWertigkeit*2;

}

//für jede vollständige Reihe wird die Punktmenge um 1 erhöht

pktMenge++;

//Falls eine Reihe vollständig war, wir der ganze zyklus noch

//mal durchlaufen, daher wird punkte auf true gesetzt

punkte=true;

//Effekt des Linienabbaus

g.setColor(new Color(10,100,210));

g.fillRect(110, i*10+200, 100, 10);

pause();

g.setColor(Color.white);

g.fillRect(110, i*10+200, 100, 10);

pause();

//Zuweisung der neuen Koordinaten der verschobenen Teile zum

//Spielplan (da sehr koplex in der Dokumentation ausführlich

//mit Abbildungen erläutert)

for(int j=i; j>4; j--)

{

for(int k=1; k<11; k++)

{

if(verschiebbarLinks[k][j-1]&&verschiebbarLinks[k][j])

{

zusammensetzungPlan[k][j]=zusammensetzungPlan[k][j-1];

frei[k][j]=frei[k][j-1];

teile[k][j]=teile[k][j-1];

zusammensetzungPlan[k][j-1]=0;

frei[k][j-1]=true;

teile[k][j]=0;

}

for(int j=19; j>4; j--)

{

for(int k=11; k<31; k++)

{

if(verschiebbarLinks[k][j-1]&&verschiebbarLinks[k][j])

{

zusammensetzungPlan[k][j]=zusammensetzungPlan[k][j-1];

frei[k][j]=frei[k][j-1];

teile[k][j]=teile[k][j-1];

zusammensetzungPlan[k][j-1]=0;

frei[k][j-1]=true;

teile[k][j]=0;

}

zeichnen(g, bau);

}

//Abfrage rechts des Sockels - Funktioniert wie oben, nur eben

//verschoben

if(voll2[i])

{

lineStand++;

if(lineStand%10==0)

{

pktWertigkeit=pktWertigkeit*2;

}

pktMenge++;

punkte=true;

g.setColor(new Color(100,10,110));

g.fillRect(310, i*10+200, 100, 10);

pause();

g.setColor(Color.white);

g.fillRect(310, i*10+200, 100, 10);

pause();

for(int j=i; j>4; j--)

{

for(int k=21; k<31; k++)

{

if(verschiebbarRechts[k][j-1]&&verschiebbarRechts[k][j])

{

zusammensetzungPlan[k][j]=zusammensetzungPlan[k][j-1];

frei[k][j]=frei[k][j-1];

teile[k][j]=teile[k][j-1];

zusammensetzungPlan[k][j-1]=0;

frei[k][j-1]=true;

teile[k][j]=0;

}

for(int j=19; j>4; j--)

{

for(int k=1; k<21; k++)

{

if(verschiebbarRechts[k][j-1]&&verschiebbarRechts[k][j])

{

zusammensetzungPlan[k][j]=zusammensetzungPlan[k][j-1];

frei[k][j]=frei[k][j-1];

teile[k][j]=teile[k][j-1];

zusammensetzungPlan[k][j-1]=0;

frei[k][j-1]=true;

teile[k][j]=0;

}

zeichnen(g, bau);

}

//Abfrage über dem Sockel - funktioniert wie oben, nur ohne

//Eckabfragen

if(voll3[i])

{

lineStand++;

if(lineStand%10==0)

{

pktWertigkeit=pktWertigkeit*2;

}

pktMenge=pktMenge+3;

punkte=true;

g.setColor(new Color(20,180,10));

g.fillRect(110, i*10+200, 300, 10);

pause();

g.setColor(Color.white);

g.fillRect(110, i*10+200, 300, 10);

pause();

for(int j=i; j>3; j--)

{

for(int k=1; k<31; k++)

{

zusammensetzungPlan[k][j]=zusammensetzungPlan[k][j-1];

frei[k][j]=frei[k][j-1];

}

zeichnen(g, bau);

}

while(punkte);

//Ermittlung der durch diesen Spielzug erreichten Punkte, abhängig von

//der Mengen der Linien, die auf einmal abgenaut wurden und der Menge an

//Linien ide bereits insgesamt abgebaut wurden

for(int i=1; i<=pktMenge; i++)

{

pktStand=pktStand+pktWertigkeit*i;

}

pktMenge=0;

}

//Methode, die festlegt, was verschoben werden darf, ausgehend von den

//bereits festgelegten Stellen, die nicht für das entsprechende Feld

//als unbewegbar festgelegt wurden.

public void verschiebbarkeitFestlegen(boolean[][]feld)

{

weitereVerschiebungsabfragen=false;

for(int k=1; k<31; k++)

{

for(int j=29; j>3; j--)

{

if(feld[k][j]==false)

{

for(int l=-2; l<=2; l++)

{

for(int m=-2; m<=2; m++)

{

if(teile[k+l][j+m]==teile[k][j])

{

if(feld[k+l][j+m])

{

feld[k+l][j+m]=false;

weitereVerschiebungsabfragen=true;

}

if(frei[k+l][j+m-1]==false)

{

if(feld[k+l][j+m-1])

{

feld[k+l][j+m-1]=false;

weitereVerschiebungsabfragen=true;

}

while(weitereVerschiebungsabfragen);

}

//Abfrage ob man Game Over ist(wenn in den obersten Reihen ein Stück nicht

//mehr frei ist), und falls das der Fall ist die Ausgabe dessen auf dem

//Bildschirm und Zuweisung der Variablen mit den nötigen Werten

public void gameOver(Graphics g)

{

for(int i=1; i<30; i++)

{

for(int j=0; j<5; j++)

{

if(frei[i][j]==false)

{

g.setFont(unter);

g.setColor(Color.white);

g.drawString("Game Over", 190, 550);

g.setFont(klein);

g.drawString("Drücke F5 um zum Hauptmenü zurückzukehren", 105, 580);

j=6;

i=30;

gameOver=true;

//Falls die erreichten Punkte höher sind als der High Score,

//werden diese als High Score gespeichert

if(highScore<pktStand)

{

highScore=pktStand;

}

//Zeichnen des Intros und des Hauptbildschirms

public void anfang(Graphics g)

{

//Falls das Intro gezeigt wereden soll, so wird es gezeigt (nicht der

//Fall, falls man beispielsweise aus dem Optionsmenü ins Hauptmenü

//zurückkehrt)

if(intro)

{

//zeichnen des Hintergrunds

g.setColor(new Color(100, 120, 180));

g.fillRect(0, 0, 600, 600);

//zeichnungsHilfe wird für den Effekt des Erscheinens verwendet

zeichnungsHilfe=101;

//Titel wird angezeigt, aber von einem Viereck überdeckt und nur

//langsam (durch pause2()) aufgedeckt

while(zeichnungsHilfe<280)

{

g.setColor(new Color(200, 220, 230));

g.setFont(game);

g.drawString("Genesis", 120, 160);

g.setFont(game2);

g.drawString("Die Schöpfung", 280, 210);

zeichnungsHilfe++;

g.setColor(new Color(100, 120, 180));

g.fillRect(0, zeichnungsHilfe, 600, 600);

pause2();

}

//Zeichnend der einzelnen Bausteine mit Pausen

g.setColor(Color.magenta);

g.fillRect(170, 300, 10, 30);

g.fillRect(160, 320, 10, 10);

pause1();

g.setColor(Color.yellow);

g.fillRect(265, 300, 10, 30);

pause1();

g.setColor(Color.darkGray);

g.fillRect(370, 300, 10, 30);

g.fillRect(380, 320, 10, 10);

pause1();

g.setColor(Color.blue);

g.fillRect(165, 380, 10, 20);

g.fillRect(175, 370, 10, 20);

pause1();

g.setColor(Color.orange);

g.fillRect(265, 375, 10, 30);

g.fillRect(255, 385, 30, 10);

pause1();

g.setColor(Color.pink);

g.fillRect(380, 380, 10, 20);

g.fillRect(370, 370, 10, 20);

pause1();

g.setColor(Color.gray);

g.fillRect(165, 450, 10, 20);

g.fillRect(175, 460, 10, 10);

g.fillRect(185, 450, 10, 20);

pause1();

g.setColor(Color.red);

g.fillRect(260, 450, 10, 20);

g.fillRect(270, 460, 10, 10);

pause1();

g.setColor(Color.green);

g.fillRect(360, 460, 30, 10);

g.fillRect(370, 450, 10, 10);

pause3();

}

//Im Normalfall soll das Intro ein sein, also wird es angeschaltet, falls

//es aus war

else

{

intro=true;

}

//Zeichnen des Hauptbildschirms

g.setColor(new Color(200, 230, 230));

g.fillRect(0, 0, 600, 600);

g.setColor(Color.black);

g.setFont(klein);

g.drawString("Drücke...", 130, 60);

g.drawString("...F5 um das Spiel zu starten", 150, 130);

g.drawString("...F6 um die Anleitung zu lesen", 150, 230);

g.drawString("...F7 um die Optionen aufzurufen", 150, 330);

g.drawString("...F8 um die Beschreibung zu lesen", 150, 430);

g.drawString("...F9 um die Anfangsgrafik noch mal zu sehen", 150, 530);

}

//Zeichnen der verschiedenen Menüs, die Variable intro wird jeweils auf false

//gesetzt, da das Intro beim zurückkehren zum Hauptmenü ja nicht gezeigt

//werden soll

public void anleitung(Graphics g)

{

intro=false;

g.setColor(new Color(60, 250, 100));

g.fillRect(0, 0, 600, 600);

g.setColor(Color.black);

g.setFont(klein);

g.drawString("Nach diesen Regeln funktioniert das Spiel:", 30, 50);

pause1();

g.drawString("- Ziel ist es so viele Reihen wie möglich zu vervollständigen.", 50, 100);

pause3();g.drawString("- Für jede vervollständigte Reihe erhält man anfangs 10 Punkte (immer nach", 50, 140);

pause3();g.drawString(" 10 Reihen verdoppelt sich dieser Wert), aber schafft man es mehrere Reihen", 50, 160);

pause3();g.drawString(" auf einmal abzubauen, so ist die 2. doppeltwertig, die 3. sogar dreifach.", 50, 180);

pause3();g.drawString("- Schafft man es eine große Reihe zu vervollständigen, also über die Breite", 50, 220);

pause3();g.drawString(" des gesamten Spielfeldes, so werden die Punkte verdreifacht.", 50, 240);

pause3();g.drawString("- Jeder Stein darf nur eine bestimmte Anzahl mal bewegt werden, die genaue", 50, 280);

pause3();g.drawString(" Anzahl steht im Rechten Bereich neben dem Spielfeld, genau wie die Punkte,", 50, 300);

pause3();g.drawString(" die Linien und der Highscore. Die erlaubte Bewegungszahl sinkt alle 20", 50, 320);

pause3();g.drawString(" Steine um eins und beginnt bei 50, falls nichts anderes eingestellt ist.", 50, 340);

pause3();g.drawString("- Sobald das Spielfeld zu sehen ist muss nur eine Richtungstaste betätigt", 50, 380);

pause3();g.drawString(" werden um den ersten Stein anzeigen zu lassen. Dies kostet bereits eine", 50, 400);

pause3();g.drawString(" Bewegung!", 50, 420);

pause3();g.drawString("- Sobald ein Stein auf dem Boden aufgesetzt hat und fest sitzt muss erneut", 50, 460);

pause3();g.drawString(" eine Richtungstaste betätigt werden um den nächsten Stein anzeigen zu lassen.", 50, 480);

pause3();g.drawString("- Rechts, Links, Unten verschieben den Stein in die jeweilige Richtung.", 50, 520);

pause3();g.drawString(" Oben dreht den Stein (was auch als Bewegung gilt!).", 50, 540);

pause3();g.drawString(" F1 lässt den Stein direkt zu Boden fallen.", 50, 560);

pause3();g.drawString("Drücke F5 um zum Auswahlbildschirm zurückzukehren", 150, 590);

}

public void beschreibung(Graphics g)

{

intro=false;

g.setColor(new Color(255, 200, 25));

g.fillRect(0, 0, 600, 600);

g.setColor(Color.black);

g.setFont(klein2);

g.drawString("Was ist das besondere an diesem Spiel?", 10, 30);

g.setFont(klein);

g.drawString("Das besondere an diesem Spiel ist, dass es mehr auf Stategie und Taktik aufgebaut", 30, 70);

g.drawString("ist, als ähnliche Spiele. Man hat immer viel Zeit zu überlegen, da es keine", 30, 90);

g.drawString("ständigen Bewegungen gibt. So ist der Spieler in der Lage sein gesamtes Können im", 30, 110);

g.drawString("taktischen und strategischen Bereich zu zeigen, ohne dass er in Hektik verfallen", 30, 130);

g.drawString("muss.", 30, 150);

g.drawString(" Der unebene untere Bereich des Spielfeldes lässt dem Spieler ebenfalls viel Raum", 30, 170);

g.drawString("für taktitische Überlegungen und die begrenzte Bewegungsanzahl für einen Stein", 30, 190);

g.drawString("fordert überlegtes Spielen des Spielers.", 30, 210);

g.drawString(" Durch diese Punkte sind die, für viele Spieler, negativen Seiten ähnlicher Spiele", 30, 230);

g.drawString("aus dem Weg geräumt und das Spielprinzip so verändert, dass es den Spieler", 30, 250);

g.drawString("(hoffentlich) lange fesselt", 30, 270);

g.setFont(klein2);

g.drawString("Wieso heißt das Spiel Genesis?", 10, 310);

g.setFont(klein);

g.drawString("Das Spiel heißt Genesis, weil es meine erste Schöpfung, also mein erstes", 30, 350);

g.drawString("selbstprogrammiertes Spiel war, dass auch in der Lage ist einem Spieler über längere", 30, 370);

g.drawString("Zeit die Langeweile zu vetreiben, und das ist ja die Hauptaufgabe eines Spieles.", 30, 390);

g.setFont(klein2);

g.drawString("Wer ist der Autor?", 10, 440);

g.setFont(klein);

g.drawString("Das bin ich, Timo Münzing. Ich wurde 1987 geboren und mache im Moment mein", 30, 480);

g.drawString("Abitur an einem informationstechnischem Gamnasium.", 30, 500);

g.setFont(klein2);

g.drawString("Und nun viel Spaß beim Spielen", 120, 550);

g.setFont(klein);

g.drawString("Timo", 480, 550);

g.drawString("Münzing", 490, 565);

g.setFont(ganzKlein);

g.drawString("Drücke F5 um zum Auswahlbildschirm zurückzukehren", 102, 575);

}

public void optionen(Graphics g, AktivesBauteil bau)

{

intro=false;

g.setColor(new Color(255, 244, 133));

g.fillRect(0, 0, 600, 600);

g.setColor(Color.black);

g.setFont(klein2);

g.drawString("Optionen", 240, 30);

g.setFont(klein);

g.drawString("Um die Einstellungen für die maximalen Bewegungen eines Steines zu ändern, drücke", 10, 70);

g.drawString("F1 um den Wert zu verringern, oder", 50, 110);

g.drawString("F2 um den Wert zu erhöhen", 50, 130);

g.drawString("Momentan eingestellter Anfangswert für die maximalen Bewegungen: "+bau.getErlaubteBew(), 10, 160);

g.drawString("Um den Schwierigkeitsgrad für das Spiel zu erhöhen, kann der Modus Blackout, indem", 10, 220);

g.drawString("bei jedem Stein eine 10% Chance besteht, dass der untere Bereich des Bildschirmes", 10, 250);

g.drawString("schwarz wird, bis der Stein unten wieder aufsetzt, durch F3 eingeschaltet werden.", 10, 280);

if(blackout)

{g.drawString("Momentane Einstellung für Blackout: ein", 30, 320);}

else

{g.drawString("Momentane Einstellung für Blackout: aus", 30, 320);}

g.drawString("Ebenfalls um den Schwierigkeitsgrad für das Spiel zu erhöhen, kann der Modus schwerer", 10, 380);

g.drawString("Stein, indem jeder Stein eine 10% Chance besitzt, dass seine erlaubten Bewegungen um", 10, 410);

g.drawString("die Hälfte reduziert werden, mit Hilfe von F4 eingeschaltet werden.", 10, 440);

if(schwererStein)

{g.drawString("Momentane Einstellung für schwerer Stein: ein", 30, 480);}

else

{g.drawString("Momentane Einstellung für schwerer Stein: aus", 30, 480);}

g.drawString("Drücke F5 um zum Auswahlbildschirm zurückzukehren", 110, 550);

}

//Änderungsmethoden

public void aendereBlackout()

{

if(blackout)

{

blackout=false;

}

else

{

blackout=true;

}

public void aendereSchwererStein()

{

if(schwererStein)

{

schwererStein=false;

}

else

{

schwererStein=true;

}

//Die Pausen verschiedener Länge

public void pause()

{

try {Thread.sleep(250);}

catch (InterruptedException e){}

}

public void pause1()

{

try {Thread.sleep(400);}

catch (InterruptedException e){}

}

public void pause2()

{

try {Thread.sleep(40);}

catch (InterruptedException e){}

}

public void pause3()

{

try {Thread.sleep(1500);}

catch (InterruptedException e){}

}

//set und getmethoden dieser Klasse

public void setTeile(int par_x, int par_y, int wert)

{

teile[par_x][par_y]=wert;

}

public void setZusammensetzungPlan(int par_x, int par_y, int wert)

{

zusammensetzungPlan[par_x][par_y]=wert;

}

public int getZusammensetzungPlan(int par_x, int par_y)

{

return zusammensetzungPlan[par_x][par_y];

}

public void setFreiFalse(int par_x, int par_y)

{

frei[par_x][par_y]=false;

}

public boolean getFrei(int par_x, int par_y)

{

return frei[par_x][par_y];

}

public boolean getOver()

{

return gameOver;

}

public int getLines()

{

return lineStand;

}

public int getPunkte()

{

return pktStand;

}

public boolean getSchwererStein()

{

return schwererStein;

}

public boolean getBlackout()

{

return blackout;

}