# coding=utf-8
# OBJET BRICK

class Brick():
    #attribut de classe un dictionnaire de couleurs
    COLORS = {1: "#000000", 2: "#f00020", 3: "#000000"}

    def __init__(self, x, y, hits):# le constructeur
        self.w = 75 # attribut longueur
        self.h = 20 # attreibut largeur
        self.pos = PVector(x, y) # attribut position
        self.hits = hits #attribut clé pour la couleur
        self.col = Brick.COLORS[hits] # la couleur

    # méthode pour afficher la brique
    def display(self):
        fill(self.col)
        stroke("#ffffff") # couleur du bord
        strokeWeight(2)# épaisseur des bords
        rect(self.pos.x, self.pos.y, self.w, self.h)






# coding=utf-8
# OBJET BALLE


class Ball():
    def __init__(self):# le constructeur
        self.r = 10 #attribut rayon
        self.vel = PVector(1, 1)*4 # attribut vitesse
        self.dir = PVector(1, 1) # attribut direction
        self.pos = PVector(width/2, height/2) # attribut position



    # méthode pour l'actualisation de la position
    def update(self):
        self.pos.x += self.vel.x*self.dir.x
        self.pos.y += self.vel.y*self.dir.y

    # méthode pour afficher la balle ellipse(x,y,diamètre horizontal, diamètre vertical)
    def display(self):
        fill("#000000")
        noStroke()
        ellipse(self.pos.x, self.pos.y, self.r*2, self.r*2)

    #méthode pour les collision avec les bords
    def checkEdges(self):
        # bord droit
        if (self.pos.x > width - self.r and self.dir.x > 0):
            self.dir.x *= -1 # on change le signe de la direction
        # bord gauche
        if (self.pos.x < self.r and self.dir.x < 0):
            self.dir.x *= -1
        # bord haut
        if (self.pos.y < self.r and self.dir.y < 0):
            self.dir.y *= -1
        # bord bas
        if (self.pos.y > height - self.r and self.dir.y > 0):
            self.dir.y *= -1

    # méthode pour détecter la collision avec le paddle
    def meets(self, paddle):
        if (self.pos.y < paddle.pos.y and
            self.pos.y > paddle.pos.y - self.r and
            self.pos.x > paddle.pos.x - self.r and
            self.pos.x < paddle.pos.x + paddle.w + self.r):
            return True
        else:
            return False





# coding=utf-8
# OBJET PADDLE


class Paddle():
    def __init__(self): # constructeur
        self.w = 120  # attribut longueur du paddle
        self.h = 15   # attribut largeur du paddle
        # la position du paddle avec un objet Pvector
        self.pos = PVector(width/2 - self.w/2, height - 40)
        self.isMovingLeft = False  # booléen pour mouvement à gauche
        self.isMovingRight = False  # idem à droite
        self.stepSize = 20   # pas pour le déplacement

    # méthode premettant l'affichage
    def display(self):
        fill("#f00020") # couleur de remplissage
        noStroke()  # pas de "bord"
        # affichage du rectangle rect(x,y,longueur, largeur)
        rect(self.pos.x, self.pos.y, self.w, self.h)

    # méthode pour actualiser l'affichage des déplacements
    def update(self):
        if self.isMovingLeft:
            self.move(-self.stepSize)
        elif self.isMovingRight:
            self.move(self.stepSize)

     # méthode qui gère le déplacement
    def move(self, step):
        self.pos.x +=step

    # méthode qui gère les collisions avec les bords
    def checkEdges(self):
        if self.pos.x <= 0:
            self.pos.x = 0
        elif self.pos.x + self.w >= width:
            self.pos.x = width - self.w