#!/usr/bin/python3


import tkinter as tk
from tkinter import *
from math import *


## Question 1.1


## Question 1.2



Titre = "Exprimons nos émotions"
(Hauteur,Largeur) = (300,300)
root = tk.Tk()
root.title(Titre)
Dessin = tk.Canvas(root,height=Hauteur,width=Largeur,bg='white')
Dessin.pack()

def disque(x,y,r,couleur):
    p = (x+r,y+r)
    q = (x-r,y-r)
    Dessin.create_oval(p,q,fill=couleur)

## Question 1.3

class État():

    def __init__(self):
        self.yeux=20
        self.heureux=True
        self.affichage()

    def affichage(self):
        Dessin.delete('all')
        # Tête
        (xt,yt)=(Hauteur//2,Largeur//2)
        Rt=Hauteur*.9/2
        disque(xt,yt,Rt,'yellow')
        # Bouche
        (xe,ye)=(Largeur//2,2*Hauteur//3)
        (Rex,Rey)= (40,30)
        Dessin.create_oval(xe-Rex,ye-Rey,xe+Rex,ye+Rey,fill='yellow',width=5)
        if self.heureux:
            d=-20
        else:
            d=20
        (xr,yr)=(Largeur//2,2*Hauteur//3+d)
        (Rrx,Rry)=(70,20)
        Dessin.create_rectangle(xr-Rrx,yr-Rry,xr+Rrx,yr+Rry,fill='yellow',width=0)
        # Œil à droite de l’image
        (xd,yd)=(2*Largeur//3,Hauteur//3)
        disque(xd,yd,self.yeux,'black')
        # Œil à gauche de l’image
        (xg,yg)=(Largeur//3,Hauteur//3)
        disque(xg,yg,self.yeux,'black')

état=État()

#animation()

## Question 1.4

def rendre_heureux():
    état.heureux=True
    état.affichage()

def rendre_malheureux():
    état.heureux=False
    état.affichage()

bouton1 = Button(root,text="Bientôt les vacances",command=rendre_heureux, width=20)
bouton2 = Button(root,text="Interro surprise !",command=rendre_malheureux, width=20)

bouton1.pack()
bouton2.pack()

## Question 1.5

def ouvrir_les_yeux(x):
    état.yeux=int(x)
    état.affichage()

curseur = Scale(root, orient = "horizontal", command=ouvrir_les_yeux, from_=1, to=100,
                length=Largeur,label='Épaisseur')
curseur.set(état.yeux)

curseur.pack()

root.mainloop()

## Question 1.6









#!/usr/bin/python3
import tkinter as tk
from math import *


root = tk.Tk()
root.title("Basket")

Hauteur,Largeur = 500,500
Dessin = tk.Canvas(root,height=Hauteur,width=Largeur,bg='white')
Dessin.pack()

def ballon(x,y,r):
    p=(x-r,y-r)
    q=(x+r,y+r)
    Dessin.create_oval(p,q,fill='orange',outline='black',width=5)
    Dessin.create_line((x,y-r),(x,y+r),width=5)
    Dessin.create_arc(x-2.5*r,y-r, x-.5*r, y+r, extent=80, start=-40, width=5,style='arc')
    Dessin.create_arc(x+2.5*r,y-r, x+.5*r, y+r, extent=80, start=140, width=5,style='arc')

## Question 2.1

class État:

    def __init__(self):
        self.x = Largeur//2 # Pour commencer au
        self.y = Hauteur//2 # centre de l'image
        self.vx = 2.25 # Pour la vitesse, on met
        self.vy = 1.75 # ce qu'on veut
        self.rayon=40
        self.pause=False # Pour la question 5
        self.attrapé=False # Pour la question 6
        self.affichage()

    def  affichage(self):
        Dessin.delete('all')
        ballon(self.x,self.y,self.rayon)

état=État()


## Question 2.2
"""
# Version 1
def tictac():
    état.x = état.x + état.vx
    état.y = état.y + état.vy
    état.affichage()
    Dessin.after(10,tictac)

tictac() # Il faut l'appeler une fois pour le lancer.
"""


## Question 2.3
"""
def tictac():
    if état.x+état.rayon>=Largeur or  état.x-état.rayon<=0:
            état.vx=-état.vx
    if état.y+état.rayon>=Hauteur or état.y-état.rayon<=0:
            état.vy=-état.vy
    état.x = état.x + état.vx
    état.y = état.y + état.vy
    état.affichage()
    Dessin.after(10,tictac)

tictac()
"""

## Question 2.4
"""
def tictac():
    if not état.pause:
        if état.x+état.rayon>=Largeur or  état.x-état.rayon<=0:
            état.vx = -état.vx
        if état.y+état.rayon>=Hauteur or état.y-état.rayon<=0:
            état.vy = -état.vy
        état.x = état.x + état.vx
        état.y = état.y + état.vy
    état.affichage()
    Dessin.after(10,tictac)

def pause(event): # l'argument est obligatoire
    état.pause = not état.pause

root.bind('<space>',pause)
tictac()
"""

## Question 2.5

def tictac():
    if not état.pause and not état.attrapé:
        if état.x+état.rayon>=Largeur or  état.x-état.rayon<=0:
            état.vx = -état.vx
        if état.y+état.rayon>=Hauteur or état.y-état.rayon<=0:
            état.vy = -état.vy
        état.x = état.x + état.vx
        état.y = état.y + état.vy
    état.affichage()
    Dessin.after(10,tictac)

def pause(event): # l'argument est obligatoire
    état.pause = not état.pause

def capture(event):
    dx = état.x - event.x # Le clic est sur le ballon si la distance du centre du
    dy = état.y - event.y # ballon à la position de la souris est inférieure au rayon.
    if dx**2 + dy**2 < état.rayon**2:
        état.attrapé = True
        état.x = event.x
        état.y = event.y

def libérée_délivrée(event):
    état.attrapé = False

def migration(event):
    if état.attrapé:
        état.x = event.x
        état.y = event.y

root.bind('<ButtonPress>',capture)
root.bind('<ButtonRelease>',libérée_délivrée)
root.bind('<Motion>',migration) # Pour déplacer le ballon avec la souris
root.bind('<space>',pause)
tictac()
root.mainloop()





import tkinter as tk
from math import *
from random import randint

def mouvement(a,L):
    L.pop(0)
    L.append(a)

D=50
root = tk.Tk()
root.title("Python")

Hauteur,Largeur = 1000,1000
Dessin = tk.Canvas(root,height=Hauteur,width=Largeur,bg='white')
Dessin.pack()

def disque(x,y,r,c):
    p=(x-r,y-r)
    q=(x+r,y+r)
    Dessin.create_oval(p,q,fill=c)

def carré(i,j,c):
    p=(i*D,j*D)
    q=(i*D+D,j*D+D)
    Dessin.create_rectangle(p,q,fill=c)

def incrément(p):
    (i,j)=p
    N=Hauteur//D
    if état.direction=='N':
        return (i,(j-1)%N)
    elif état.direction=='S':
        return (i,(j+1)%N)
    elif état.direction=='O':
        return ((i-1)%N,j)
    elif état.direction=='E':
        return ((i+1)%N,j)

def position_aléatoire():
    return (randint(0,Largeur//D-1),randint(0,Hauteur//D-1))

class État:

    def __init__(self):
        self.direction = 'E'
        self.pomme = position_aléatoire()
        (i,j)= (Hauteur//(2*D), Largeur//(2*D))
        self.L=[ (i-1,j) , (i,j), (i+1,j) ]
        self.affichage()

    def affichage(self):
        Dessin.delete('all')
        # La pomme
        carré(self.pomme[0],self.pomme[1],'red')
        # La queue
        for p in self.L[:-1]:
            (i,j)=p
            carré(i,j,'green')
        # La tête
        (i,j)=self.L[-1]
        carré(i,j,'black')

    def avance(self):
        p=incrément(self.L[-1])
        if p in self.L:
            raise ValueError("Perdu")
        if p==self.pomme:
            self.L.append(p)
            self.pomme = position_aléatoire()
        else:
            mouvement(p,self.L)

    def mange(self):
        p=incrément(self.L[-1])
        self.L.append(p)

print("Création de l'état")
état=État()


def haut(event):
    état.direction='N'

def bas(event):
    état.direction='S'

def gauche(event):
    état.direction='O'

def droit(event):
    état.direction='E'

root.bind('<Up>',haut)
root.bind('<Down>',bas)
root.bind('<Left>',gauche)
root.bind('<Right>',droit)


def tictac():
    global état
    try:
        état.avance()
    except:
        # La défaite entraîne une erreur
        # On recommence le jeu
        état=État()
    état.affichage()
    Dessin.after(100,tictac)


tictac()
root.mainloop()
