L1: Project Folt

from UBpygame import *
from random import *

## ECRAN
window_size = (400, 640)
window = initialize(window_size[0], window_size[1], "Folt")
delai = 300
delai_short = 100
delai_win = 500

## VARIABLES
# Couleurs
WHITE = (255, 255, 255)
GREY = (50, 50, 50)
BLACK = (0, 0, 0)
BLUE = (0, 0, 255)

# Menu
menu_height = 100
menu_spacing = 5

# Grid
grid_size = (5, 7)
grid = []
for i in range(grid_size[0]):
    grid.append([])
    for j in range(grid_size[1]):
        grid[i].append(0)

# Cases
case_size = (window_size[0]//grid_size[0], (window_size[1] - menu_height)//grid_size[1])
small_case_size = (3/4) * case_size[0], (3/4) * case_size[1]
tip_case_size = (1/4) * case_size[0], (1/4) * case_size[1]
tip_case_inner_size = tip_case_size[0] - 5, tip_case_size[1] - 5
tip_cte = 1

current_case = ((grid_size[0] - 1)//2, (grid_size[1] - 1)//2)
grid[current_case[0]][current_case[1]] = randint(1, 2)

case_ammount = 3
next_cases = []
last_case = (0, 0)

# Interaction
interaction={'up':False, 'down':False, 'left':False, 'right':False}

# Score
score = 0
score_max = 15

game_finished = False
game_already_finished = False
game_won_msg = "You WIN"
game_lost_msg = "Game Over"

# Rectangles
menu_bar_bg = create_rectangle((0, 0), window_size[0], menu_height, GREY)
draw_rectangle(menu_bar_bg)

grid_bg = create_rectangle((0, menu_height), window_size[0], window_size[1] - menu_height, WHITE)
draw_rectangle(grid_bg)

## FUNCTION: METTRE A JOUR LA LISTE DES PROCHAINES CASES
def case_next(l):
    while (len(l) < case_ammount):
        l.append(randint(1, 2))

## FUNCTION: DESSINER L'ECRAN
def draw_screen():
    global game_finished

    # Dessiner les 3 prochaines cases
    draw_rectangle(grid_bg)
    draw_rectangle(menu_bar_bg)
    for i in range (len(next_cases)):
        if(next_cases[i] == 1):
            small_case_rec = create_rectangle((menu_spacing*2 + i*(small_case_size[0] + menu_spacing), (menu_height - small_case_size[1])/2), small_case_size[0], small_case_size[1], BLACK)
        elif(next_cases[i] == 2):
            small_case_rec = create_rectangle((menu_spacing*2 + i*(small_case_size[0] + menu_spacing), (menu_height - small_case_size[1])/2), small_case_size[0], small_case_size[1], BLUE)
        draw_rectangle(small_case_rec)

    # Dessiner les cases
    for i in range (grid_size[0]):
        for j in range (grid_size[1]):
            if (grid[i][j] == 1):
                case_rec = create_rectangle((i * case_size[0], menu_height + j * case_size[1]), case_size[0], case_size[1], BLACK)
                draw_rectangle(case_rec)
            elif (grid[i][j] == 2):
                case_rec = create_rectangle((i * case_size[0], menu_height + j * case_size[1]), case_size[0], case_size[1], BLUE)
                draw_rectangle(case_rec)

    # Dessiner petite casse montrant la casse actuelle
    small_case_rec = create_rectangle((current_case[0] * case_size[0] + case_size[0]/2 - tip_case_size[0]/2, menu_height + current_case[1] * case_size[1] + case_size[1]/2 - tip_case_size[1]/2), tip_case_size[0], tip_case_size[1], WHITE)
    draw_rectangle(small_case_rec)

    c = 0
    case = grid[current_case[0]][current_case[1]]
    if (case == 1):
        c = BLACK
    elif (case == 2):
        c = BLUE

    small_case_inner_rec = create_rectangle((current_case[0] * case_size[0] + case_size[0]/2 - tip_case_inner_size[0]//2 - tip_cte, menu_height + current_case[1] * case_size[1] + case_size[1]/2 - tip_case_inner_size[1]//2 - tip_cte), tip_case_inner_size[0] + tip_cte, tip_case_inner_size[1] + tip_cte, c)
    draw_rectangle(small_case_inner_rec)

    # Dessiner le score
    sc = str(score) + " / " + str(score_max)
    tw, th = text_size(sc, 50)
    draw_text(sc, (3*window_size[0]/4 - (tw/2), (menu_height - th)/2), BLACK, 50)

    if (game_finished == True):
        if (score >= score_max):
            tw, th = text_size(game_won_msg, 100)
            for i in range(0, 256, 5):
                draw_text(game_won_msg, (window_size[0]/2 - tw/2, window_size[1]/2 - th/2), (255-i, 255, 255-i), 100)
                refresh_window()
                delay(delai_short)
            delay(delai_win)
            game_finished = False
        else:
            tw, th = text_size(game_lost_msg, 80)
            for i in range(0, 256, 5):
                draw_text(game_lost_msg, (window_size[0]/2 - tw/2, window_size[1]/2 - th/2), (255, 255-i, 255-i), 80)
                refresh_window()
                delay(delai_short)
            delay(delai_win)
            game_finished = False

    refresh_window()

def draw_animation_next_case(pos, cmd):
    c = 0

    if (grid[pos[0]][pos[1]] == 1):
        c = BLACK
    elif (grid[pos[0]][pos[1]] == 2):
        c = BLUE

    if(cmd["up"]):
        i = 0
        while(i < case_size[1]):
            case_rec = create_rectangle((pos[0] * case_size[0], menu_height + pos[1] * case_size[1] + case_size[1] - i), case_size[0], i, c)
            draw_rectangle(case_rec)
            refresh_window()
            i += 3
    if(cmd["down"]):
        i = 0
        while(i < case_size[1]):
            case_rec = create_rectangle((pos[0] * case_size[0], menu_height + pos[1] * case_size[1]), case_size[0], i, c)
            draw_rectangle(case_rec)
            refresh_window()
            i += 3
    if(cmd["right"]):
        i = 0
        while(i < case_size[1]):
            case_rec = create_rectangle((pos[0] * case_size[0], menu_height + pos[1] * case_size[1]), i, case_size[1], c)
            draw_rectangle(case_rec)
            refresh_window()
            i += 3
    if(cmd["left"]):
        i = 0
        while(i < case_size[1]):
            case_rec = create_rectangle((pos[0] * case_size[0] + case_size[0] - i, menu_height + pos[1] * case_size[1]), i, case_size[1], c)
            draw_rectangle(case_rec)
            refresh_window()
            i += 3

def list_neighbors(pos):
    if (pos[1] > 0):
        u = (pos[0], pos[1] - 1)
    else:
        u = None
    if (pos[1] < grid_size[1] - 1):
        d = (pos[0], pos[1] + 1)
    else:
        d = None
    if (pos[0] < grid_size[0] - 1):
        l = (pos[0] + 1, pos[1])
    else:
        l = None
    if (pos[0] > 0):
        r = (pos[0] - 1, pos[1])
    else:
        r = None
    return(u, d, l, r)

def count_neighbors(pos, c):
    grid[pos[0]][pos[1]] = 3
    n = 1
    for i in list_neighbors(pos):
        if(i != None and grid[i[0]][i[1]] == c):
            n = n + count_neighbors(i, c)
    return(n)

def check_neighbors(pos, c):
    global score

    a = count_neighbors(pos, c)
    if (a > 2):
        for i in range (grid_size[0]):
            for j in range (grid_size[1]):
                if (grid[i][j] == 3):
                    grid[i][j] = 0
        score += a - 1
    else:
        for i in range (grid_size[0]):
            for j in range (grid_size[1]):
                if (grid[i][j] == 3):
                    grid[i][j] = c
    grid[pos[0]][pos[1]] = c

def game_lost(pos):
    c = grid[pos[0]][pos[1]]
    n = 0

    for i in list_neighbors(pos):
        if (i == None):
            n += 1
        elif(grid[i[0]][i[1]] != 0):
            n += 1
    if (n == 4):
        return(True)
    else:
        return(False)


## FUNCTION: GERER LA GRILLE
def handle_grid(pos, cmd):
    global game_finished, game_already_finished

    # Mettre a jour la grille
    grid[pos[0]][pos[1]] = next_cases[0]

    # Mettre a jour la liste des prochaines cases
    del(next_cases[0])
    case_next(next_cases)

    # S'occuper des cases adjacentes
    check_neighbors(pos, grid[pos[0]][pos[1]])

    # Verifier si le joueur a perdu, ou gagner
    if(game_lost(pos) != False):
        game_finished = True
        if (game_already_finished == True):
            game_already_finished = False
        else:
            game_already_finished = True

    if (score >= score_max and game_already_finished == False):
        game_finished = True
        game_already_finished = True

    draw_animation_next_case(pos, cmd)
    draw_screen()

## FUNCTION: GERER LES INTERACTIONS
def handle_interaction():
    global current_case

    k_up, k_down, k_left, k_right = False, False, False, False

    if (is_key_pressed(K_UP)):
        if (current_case[1] > 0 and grid[current_case[0]][current_case[1] - 1] == 0):
            last_case = current_case
            current_case = (current_case[0], current_case[1] - 1)
            k_up = True
    elif (is_key_pressed(K_DOWN)):
        if (current_case[1] < grid_size[1] - 1 and grid[current_case[0]][current_case[1] + 1] == 0):
            last_case = current_case
            current_case = (current_case[0], current_case[1] + 1)
            k_down = True
    elif (is_key_pressed(K_LEFT)):
        if (current_case[0] > 0 and grid[current_case[0] - 1][current_case[1]] == 0):
            last_case = current_case
            current_case = (current_case[0] - 1, current_case[1])
            k_left = True
    elif (is_key_pressed(K_RIGHT)):
        if (current_case[0] < grid_size[0] - 1 and grid[current_case[0] + 1][current_case[1]] == 0):
            last_case = current_case
            current_case = (current_case[0] + 1, current_case[1])
            k_right = True

    return({'up':k_up, 'down':k_down, 'left':k_left, 'right':k_right})

## FUNCTION: GERER LES ANIMATIONS
def handle_animation(cmd):
    global current_case
    global game_finished

    if (cmd['up']):
        handle_grid(current_case, cmd)
        delay(delai)

    if (cmd['down']):
        handle_grid(current_case, cmd)
        delay(delai)

    if (cmd['left']):
        handle_grid(current_case, cmd)
        delay(delai)

    if (cmd['right']):
        handle_grid(current_case, cmd)
        delay(delai)

## FUNCTION: LE JEU ET SA FENETRE
def Folt():
    global interaction

    case_next(next_cases)
    draw_screen()

    ## ECRAN
    while(not is_any_quit_event()):
        interaction = handle_interaction()
        handle_animation(interaction)
        refresh_window()
    uninitialize()

Folt()