#Globale Variabeln initiieren

w = 0
h = 0
board = [[archiv:ef:ef:minecraft:projekt:maximandrin:start:0]]
piece = [[archiv:ef:ef:minecraft:projekt:maximandrin:start:0]]
pieceX = 0
pieceY = 0
color = DIAMOND_BLOCK
isRunning = False
origin = player.position()
score = 0



#Generelle Funktionen

def startTetris():
    player.say("startTetris")
    global w
    global h
    global board
    global piece
    global pieceX
    global pieceY
    global isRunning
    global origin
    global score
    
    #Grösse der Spielfläche
    w = 9
    h = 15
    
    #erstellen einer zweidimensionalen Liste zum Speichern der Spielfläche
    # (0/1) (1/1)
    # (0/0) (1/0)
    board = []
    for i in range(w):
        temparr = range(h)
        board[i] = temparr
        for j in range(h):
            board[i][j] = 0
    
    #erstellen des ersten Tetrominos
    pieceX = Math.round(w/2) - 2
    pieceY = h - 1
    getPiece()
    
    #Spieler zentrieren und Agenten wegteleportieren
    agent.teleport_to_player()
    player.teleport(agent.get_position())
    origin = player.position()
    command = "tp ~ ~ ~ facing ~ ~" + h/3 + " ~10"
    player.execute(command)
    agent.teleport(pos(0, -10, 0), SOUTH)
    
    #"Spielkonsole" bauen
    makeBoard(w - 1, h - 1)
    
    #Spiel starten
    isRunning = True
    score = 0
    gameloop()

player.on_chat("start", startTetris)



def makeBoard(w, h):
    #Plattform bauen
    blocks.fill(GLASS, pos(-1, -1, -1), pos(1, -1, 1))
    blocks.fill(GLASS_PANE, pos(-1, 0, -1), pos(1, 0, -1))
    blocks.fill(GLASS_PANE, pos(-1, 0, 1), pos(1, 0, 1))
    blocks.place(GLASS_PANE, pos(-1, 0, 0))
    blocks.place(GLASS_PANE, pos(1, 0, 0))
    
    #Bildschirm bauen
    n = Math.round(w / 2)
    o = Math.round(w/2%1)
    blocks.fill(BLACK_CONCRETE, pos(-n, 0, 11), pos(n+o, h, 11))
    blocks.fill(POLISHED_ANDESITE, pos(-n-1, -1, 11), pos(-n-1, h+1, 9))
    blocks.fill(POLISHED_ANDESITE, pos(n+o+1, -1, 11), pos(n+o+1, h+1, 9))
    blocks.fill(POLISHED_ANDESITE, pos(-n-1, -1, 11), pos(n+o+1, -1, 9))
    blocks.fill(POLISHED_ANDESITE, pos(-n-1, h+1, 11), pos(n+o+1, h+1, 9))
    blocks.fill(AIR, pos(-n, 0, 9), pos(n+o, h, 10))
    blocks.fill(GLASS, pos(-n, 0, 9), pos(n+o, h, 9))



def stopTetris():
    global isRunning
    
    #Aus gameloop() ausbrechen
    isRunning = False

player.on_chat("stop", stopTetris)



def getPiece():
    global piece
    global color
    global pieceX
    
    #Eines der Tetrominos wählen
    n = Math.random() * 7
    if n < 1:
        #I
        piece = [[0,1,0,0],[0,1,0,0],[0,1,0,0],[0,1,0,0]]
        color = LIGHT_BLUE_WOOL
    elif n < 2:
        #O
        piece = [[1,1],[1,1]]
        color = YELLOW_WOOL
        pieceX = pieceX + 1
    elif n < 3:
        #T
        piece = [[0,1,0],[1,1,0],[0,1,0]]
        color = PURPLE_WOOL
    elif n < 4:
        #S
        piece = [[1,0,0],[1,1,0],[0,1,0]]
        color = RED_WOOL
    elif n < 5:
        #2
        piece = [[0,1,0],[1,1,0],[1,0,0]]
        color = LIME_WOOL
    elif n < 6:
        #L
        piece = [[1,1,0],[0,1,0],[0,1,0]]
        color = ORANGE_WOOL
    elif n < 7:
        #J
        piece = [[0,1,0],[0,1,0],[1,1,0]]
        color = BLUE_WOOL



#Durchgehend wiederholende Funktion die Spiel "steuert"

def gameloop():
    global isRunning
    frame = 0
    
    #Wiederholen bis Spieler "stop" schreibt
    while isRunning:
        #Bei Bewegung den Tetromino bewegen
        movedDirection = playerMoved()
        if movedDirection[0] != "":
            movePiece(movedDirection[0], movedDirection[1])
            player.teleport(origin)
        
        #Alle 20 Durchläufe den Tetromino nach unten bewegen
        if frame % 20 == 0:
            moveDown()
        frame += 1



#Bewegen der Tetrominos

def playerMoved():
    
    #neue und alte Position vergleichen
    cPos = player.position()
    if origin.to_string() == cPos.to_string():
        return ["", ""]
    else:
        #Richtung bestimmen
        x = origin.get_value(Axis.X) - cPos.get_value(Axis.X)
        y = origin.get_value(Axis.Y) - cPos.get_value(Axis.Y)
        z = origin.get_value(Axis.Z) - cPos.get_value(Axis.Z)
        if x < 0:
            return ["x", "+"]
        elif x > 0:
            return ["x", "-"]
        elif y != 0:
            return ["y", "+"]
        elif z < 0:
            return ["z", "+"]
        else:
            return ["z", "-"]



def movePiece(direction, sign):
    player.say("movePiece")
    global piece
    
    #Je nach Richtung richtige Bewegung ausführen
    if direction == "x" and sign == "-":
        move(-1)
    elif direction == "x" and sign == "+":
        move(1)
    elif direction == "y":
        moveToBottom()
    elif direction == "z" and sign == "-":
        rotateLeft()
    else:
        rotateRight()



def move(n):
    player.say("move")
    global piece
    global pieceX
    global pieceY
    
    #X Wert des Tetrominos ändern
    newX = pieceX + n
    if not checkCollisions(piece, newX, pieceY, False):
        checkCollisions(piece, newX, pieceY, True)



def moveDown():
    player.say("moveDown")
    global piece
    global pieceX
    global pieceY
    
    #Y Wert des Tetrominos ändern
    newY = pieceY - 1
    checkCollisions(piece, pieceX, newY, True)



def moveToBottom():
    player.say("moveToBottom")
    global piece
    global pieceX
    global pieceY
    global board
    
    #Y Wert des Tetrominos senken bis Kollision stattfindet
    newY = pieceY
    while not checkCollisions(piece, pieceX, newY, False):
        newY = newY - 1
    for i in range(piece.length):
        for j in range(piece.length):
            if piece[i][j] == 1 and pieceY < h - 1:
                blocks.place(AIR, positions.add(origin, pos(-w/2+pieceX+i, pieceY+j, 10)))
    pieceY = newY + 1
    placePiece()



def rotateLeft():
    player.say("rotateLeft")
    global piece
    global pieceX
    global pieceY
    tempPiece = []
    newPiece = []
    for i in range(piece.length):
        tr = range(piece.length)
        tempPiece[i] = tr
        newPiece[i] = tr
        for j in range(piece.length):
            tempPiece[i][j] = 0
            newPiece[i][j] = 0
    newPiece = piece
    tPiece = piece
    
    #gedrehtes Tetromino in neue Liste speichern
    for i in range(piece.length):
        for j in range(piece.length):
            tempPiece[i][j] = tPiece[i][piece.length-1-j]
    for i in range(piece.length):
        for j in range(piece.length):
            newPiece[j][i] = tempPiece[i][j]
    piece = tPiece
    if not checkCollisions(newPiece, pieceX, pieceY, False):
        checkCollisions(newPiece, pieceX, pieceY, True)



def rotateRight():
    player.say("rotateRight")
    global piece
    global pieceX
    global pieceY
    tempPiece = []
    newPiece = []
    for i in range(piece.length):
        tr = range(piece.length)
        tempPiece[i] = tr
        newPiece[i] = tr
        for j in range(piece.length):
            tempPiece[i][j] = 0
            newPiece[i][j] = 0
    newPiece = piece
    
    #gedrehtes Tetromino in neue Liste speichern
    for i in range(piece.length):
        for j in range(piece.length):
            tempPiece[j][i] = piece[i][j]
    for i in range(tempPiece.length):
        for j in range(tempPiece.length):
            newPiece[i][tempPiece.length-1-j] = tempPiece[i][j]
    checkCollisions(newPiece, pieceX, pieceY, True)



def checkCollisions(newPiece, newX, newY, proceed):
    player.say("checkCollisions")
    global board
    
    #Kollisionen finden und testen ob Tetromino zuunterst ist
    #Ohne tempPiece entsteht Error, weil type von newPiece nicht bekannt ist
    tempPiece = [[0]]
    tempPiece = newPiece
    collided = False
    bottom = False
    walls = False
    for i in range(newPiece.length):
        for j in range(newPiece.length):
            if newPiece[i][j] == 1:
                if i + newX >= board.length or i + newX < 0:
                    walls = True
                elif board[i + newX][j + newY] == 1:
                    collided = True
                elif j + newY < 0:
                    bottom = True
    if proceed and not walls :
        if bottom:
            placePiece()
        elif not collided:
            updatePiece(newPiece, newX, newY)
        else:
            placePiece()
    elif bottom or collided or walls:
        player.say("not placed")
        return(True)
    return(False)



#Funktionen zum Ändern des Bildschirms der "Konsole"

def updatePiece(newPiece, newX, newY):
    player.say("updatePiece")
    global board
    global piece
    global pieceX
    global pieceY
    global h
    global color
    for i in range(piece.length):
        for j in range(piece.length):
            if piece[i][j] == 1 and pieceY < h - 1:
                #board[i + pieceX][j + pieceY] = 0
                blocks.place(AIR, positions.add(origin, pos(-w/2+pieceX+i, pieceY+j, 10)))
    for i in range(newPiece.length):
        for j in range(newPiece.length):
            if newPiece[i][j] == 1:
                if newY + j < h:
                    blocks.place(color, positions.add(origin, pos(-w/2+newX+i, newY+j, 10)))
    piece = newPiece
    player.say("Updated Piece")
    pieceX = newX
    pieceY = newY



def placePiece():
    player.say("placePiece")
    global board
    global piece
    global pieceX
    global pieceY
    global score
    global isRunning
    
    #Tetromino zur "board" Liste hinzufügen
    for i in range(piece.length):
        for j in range(piece.length):
            if piece[i][j] == 1:
                board[i + pieceX][j + pieceY] = 1
                if pieceY + j < h:
                    blocks.place(placeColor(color), positions.add(origin, pos(-w/2+pieceX+i, pieceY+j, 10)))
                if pieceY + j >= h:
                    isRunning = False
    
    if isRunning:
        #Neues Tetromino generieren
        score = score + 1
        pieceX = Math.round(w/2) - 2
        pieceY = h - 1
        getPiece()
    else:
        player.say("Zu langsam ☹")
        player.say("score: " + str(score))



def removeRow(y):
    player.say("removeRow")
    global board
    global w
    global h
    
    #alles über der Reihe nach unten schieben
    for i in range(y, h):
        board[i] = board[i+1]
        blocks.clone(positions.add(origin, pos(-w/2, i+1, 10)), positions.add(origin, pos(w/2, i+1, 10)), positions.add(origin, pos(-w/2, i, 10)), CloneMask.REPLACE, CloneMode.NORMAL)
    for i in range(w):
        board[h][i]=0
        blocks.fill(AIR, positions.add(origin, pos(-w/2,h, 10)), positions.add(origin, pos(w/2, h, 10)))



def placeColor(color):
    if color == LIGHT_BLUE_WOOL:
        return(LIGHT_BLUE_CONCRETE)
    elif color == YELLOW_WOOL:
        return(YELLOW_CONCRETE)
    elif color == PURPLE_WOOL:
        return(PURPLE_CONCRETE)
    elif color == LIME_WOOL:
        return(LIME_CONCRETE)
    elif color == RED_WOOL:
        return(RED_CONCRETE)
    elif color == ORANGE_WOOL:
        return(ORANGE_CONCRET)
    else:
        return(BLUE_CONCRETE)