from grafik import *
from ttastatur import *
import math

#+++++++++++++++++++++++++++++++++++++++++++++#
# SQUASH                                      #
# fuer Unterrichtszwecke entworfen            #
# Version: 1.1 (13.04.2004)                   #
# Autoren: Jeanine Umlang, Clemens Wagner     #
#+++++++++++++++++++++++++++++++++++++++++++++#

class TSpielfeld(TZeichenblatt):
    def __init__(self):
        # Konstruktor der Superklasse aufrufen
        # Breite und Höhe wird festegelegtt
        TZeichenblatt.__init__(self)
        print self.holeBreite()
        print self.holeHoehe()
        # Raster erstellen (25 Zeilen, 20 Spalten)
        self.Raster = TRaster(self.holeBreite(),self.holeHoehe(),25,20)
        # Liste für die Bausteine iniitialisierenn
        self.Bausteine = []
        # Bausteine erzeugen und in die Liste eintragen
        # Dabei wird eine ganze Zeile von Spalte 0 bis Spaltenanzahl...
        for i in range(0,self.Raster.holeSpalten()):
            # ...in Zeile 4-5...
            for j in range(4,6):
                # ...mit Bausteinen gefuellt:
                # Baustein erzeugen und in die Liste schreiben
                self.Bausteine.append(TBaustein(self))
                # Bausteinposition fuer aktuelle Rasterzelle ausrechnen
                bp=self.Raster.umrechnen(j,i)
                # Bausteinkoordinaten setzen
                self.Bausteine[len(self.Bausteine)-1].setzePos(bp[0],bp[1],bp[2],bp[3])
                # Baustein anzeigen
                self.Bausteine[len(self.Bausteine)-1].zeigen()

    def holeBausteine(self):
        # gibt die aktuelle Bausteinliste zurueck
        return self.Bausteine

    def loescheBaustein(self,b):
        # loescht einen Baustein aus der Liste, vom Bildschirm und aus dem Speicher
        b.loeschen()
        self.Bausteine.remove(b)

class TBaustein(TRechteck):
    # Spezialisierung der Klasse TRechteck
    # Die Farben sind festgelegt
    def __init__(self,SF):
        TRechteck.__init__(self,SF)
        self.Farbe.setzeFarbname("schwarz")
        self.Fuellfarbe.setzeFarbname("gruen")
        
class TRaster:
    # Das Raster ermoeglicht eine einfachere Positionierung der Bausteine nach
    # Zeilen und Spalten. Die notwendigen Koordinaten koennen vom Raster ermittelt
    # werden. (umrechnen)
    def __init__(self,Breite,Hoehe,Zeilen,Spalten):
        self.Breite = Breite
        self.Hoehe = Hoehe
        self.Spalten = Spalten
        self.Zeilen = Zeilen

    def umrechnen(self,Zeile,Spalte):
        rest = (self.Breite % self.Spalten)/2
        x1=(self.Breite/self.Spalten)*Spalte+rest
        y1=(self.Hoehe/self.Zeilen)*Zeile
        x2=(self.Breite/self.Spalten)*(Spalte+1)+rest
        y2=(self.Hoehe/self.Zeilen)*(Zeile+1)
        r = [x1,y1,x2,y2]
        return r

    def holeZeilen(self):
        return self.Zeilen

    def holeSpalten(self):
        return self.Spalten
       
class TSchlaeger(TRechteck):
    def __init__(self,SF):
        # Aufruf der Superklasse
        TRechteck.__init__(self,SF)
        self.Spielfeld = SF
        # Geschwindigkeit in X-Richtung
        self.Vx=20
        # Breite und Hoehe
        self.Breite=80
        self.Hoehe=10
        # Startkoordinaten berechen (Mitte des unteren Spielfeldrandes)
        x1=self.Spielfeld.holeBreite()/2-self.Breite/2
        y1=self.Spielfeld.holeHoehe()-self.Hoehe-2
        x2=x1+self.Breite
        y2=y1+self.Hoehe
        # Startkoordinaten setzen
        self.setzePos(x1,y1,x2,y2)
        # Schlaeger einfaerben        
        self.Farbe.setzeFarbname("blau")
        self.Fuellfarbe.setzeFarbname("blau")
        # Schlaeger anzeigen
        self.zeigen()

    def nachLinks(self):
        # Diese Methode wird von der Klasse TTastatur aufgerufen
        # Schlaeger nach Links versetzen (um Vx)
        # Kollisionsabfrage am linken Rand
        if((self.holeX1Pos()-self.Vx)>=0):
            self.posVersetzenUm((-1)*self.Vx,0)
            self.zeigen()
        else:
            # beim Erreichen des linken Rands den Schlaeger ganz an den Rand setzen
            self.setzePos(0,self.Spielfeld.holeHoehe()-self.Hoehe-2,self.Breite,Spielfeld.holeHoehe()-2)
            self.zeigen()

    def nachRechts(self):
        # Diese Methode wird von der Klasse TTastatur aufgerufen
        # Schlaeger nach Rechts versetzen (um Vx)
        # Kollisionsabfrage am linken Rand
        if((self.holeX2Pos()+self.Vx)self.Spielfeld.holeBreite()):
            self.Vx=self.Vx*(-1)
        # ------- mit Schlaegeroberflaeche:
        if((self.holeY2Pos()+self.Vy)>self.Schlaeger.holeY1Pos()):
            if((self.holeMx()>=self.Schlaeger.holeX1Pos()) and (self.holeMx()<=self.Schlaeger.holeX2Pos())):
                self.Vy=self.Vy*(-1)
            else:
                # ------- unterer Rand erreicht:
                # (negatives) Spielende
                self.Spielende = -1
        #------- mit oberem Rand:
        if((self.holeY1Pos()+self.Vy)<0):
            self.Vy=self.Vy*(-1)
        # ------ mit den Bausteinen:
        #------- Bausteinliste abholen
        bausteine = self.Spielfeld.holeBausteine()
        #---- alle Bausteine weg?
        if (len(bausteine)) == 0:
            #---- (positives) Spielende 
            self.Spielende = 1
        #------- für alle Bausteine (b)::
        for b in bausteine:
            # ---- Mittelpunkt wird innerhalb der umgebenden Box sein
            if (self.holeMy()+self.Vy >= b.holeY1Pos()-self.holeRadius() and self.holeMy()+self.Vy <= b.holeY2Pos()+self.holeRadius()):
                if (self.holeMx()+self.Vx >= b.holeX1Pos()-self.holeRadius() and self.holeMx()+self.Vx <= b.holeX2Pos()+self.holeRadius()):
                    # ---- Mittelpunkt des Balls wird unter oder über dem Baustein sein:
                    if (self.holeMx()+self.Vx >= b.holeX1Pos() and self.holeMx()+self.Vx <= b.holeX2Pos()):
                        self.Vy=self.Vy*(-1)
                        self.Spielfeld.loescheBaustein(b)              
                    # ---- Mittelpunkt des Balls wird links oder rechts neben dem Baustein sein:
                    if (self.holeMy()+self.Vy >= b.holeY1Pos() and self.holeMy()+self.Vy <= b.holeY2Pos()):
                        self.Vx=self.Vx*(-1)
                        self.Spielfeld.loescheBaustein(b)

        # Ball versetzen
        self.posVersetzenUm(self.Vx,self.Vy)
        # Ball an neuer Position anzeigen
        self.zeigen()

    def pruefeSpielende(self):
        # gibt Spielende zurueck (fuer das Abbruchkriterium)
        return self.Spielende

    
                    
# -- MAIN --------------------------------------------

# der eigentliche Spielablauf:
def start():
    # bewegen ... solange kein Spielende
    while not ((ball.pruefeSpielende()==1) or (ball.pruefeSpielende()==-1)):
        ball.bewegen()

    # Schnickschnack am Spielende.. :)    
    Endtext=TText(Spielfeld)
    Endtext.setzePos(10,10)
    Endtext.setzeFont("Arial",25)
    if ball.pruefeSpielende()==1:
        Endtext.setzeText("Gratulation! Du hast gewonnen!")
    else:
        Endtext.setzeText("leider verloren... ")
    Endtext.zeigen()
    
# leeres Fenster erzeugen
fenster=Tkinter.Tk()
fenster.wm_title("Squash V1.1")
# Spielfeld, Schlaeger, Tastatur und Ball erzeugen
Spielfeld=TSpielfeld()
Schlaeger=TSchlaeger(Spielfeld)
tastatur=TTastatur(fenster,Schlaeger)
ball=TBall(Schlaeger,Spielfeld)
# Spielfeld im Fenster anordnen
Spielfeld.pack()

# Startbutton erzeugen
startBtn = Tkinter.Button(text="starten...",command=start)
# Startbutton im Fenster anordnen
startBtn.pack(expand=1,fill="x",padx=4,pady=4)      
    
# Kontrolle an das Fenster uebergeben
fenster.mainloop()