kivy

from kivy.app import App
from kivy.core.window import Window
from kivy.core.window import WindowBase
from kivy.uix.floatlayout import FloatLayout
from kivy.uix.image import Image
from kivy.graphics import Rectangle
from kivy.uix.widget import Widget
from kivy.clock import Clock
from kivy.uix.label import Label
from kivy.animation import Animation
from kivy.uix.screenmanager import ScreenManager, Screen
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.button import Button
from kivy.core.audio import SoundLoader
import random

#On declare deux ecrans 'Menu' et 'Jeu'
class MenuScreen(Screen):
    def build(self):
        self.name='Menu'#On donne un nom a l'ecran
        #Une image de fond:
        self.add_widget(Image(source='fond01.png',allow_stretch=True,keep_ratio=False))
        #On definie un layout pour cet ecran:
        Menu_Layout = BoxLayout(padding=100,spacing=10,orientation='vertical')
        #On construit un bouton pour lancer le jeu:
        self.b_jouer=Button(text='Jouer')
        self.b_jouer.font_size=Window.size[0]*0.05
        self.b_jouer.background_color=[0,0,0,0.2]
        self.b_jouer.bind(on_press=self.Jouer)
        #On ajoute le bouton dans l'affichage:
        Menu_Layout.add_widget(self.b_jouer)
        #On cree un bouton sans commande
        self.b_sans_commande=Button(text='Programme en Kivy ')
        self.b_sans_commande.font_size=Window.size[0]*0.05
        self.b_sans_commande.background_color=[0,0,0,0.2]
        self.b_sans_commande.bind(on_press=self.Sans_commande)
        #On ajoute le bouton dans l'affichage:
        Menu_Layout.add_widget(self.b_sans_commande)
        #On ajoute ce layout dans l'ecran:
        self.add_widget(Menu_Layout)

    def Jouer(self,instance):#Fonction de transition vers 'Jeu'
        JEU=JEUScreen()
        JEU.build()#On construit l'ecran 'JEU'
        sm.add_widget(JEU)#On ajoute l'ecran dans le screen manager
        sm.current='JEU'#On definit 'JEU' comme ecran courant
    
    def Sans_commande(self, instance):
        pass

class JEUScreen(Screen):
    def build(self):
        self.name='JEU'#On donne un nom a l'ecran
        JEU_Layout=Jeu()#Creation du jeu
        JEU_Layout.debut()#Initialisation du jeu
        self.add_widget(JEU_Layout)#On l'ajoute dans l'ecran

class Balle(Widget):
    def __init__(self,canvas):
        self.dy=-10
        self.dx=2
        self.canvas=canvas
        #Taille et position aleatoire:
        self.size=(Window.size[0]*0.05,Window.size[1]*0.1)
        self.x = random.randint(0,int(Window.size[0]-self.size[0]))
        self.y=Window.size[1]-100
        #Ajout de l'image du balle:
        with self.canvas:
            self.dessin = Rectangle(source='balle.png',size=self.size, pos=self.pos)
        #Detection des mouvements:
        self.bind(pos=self.update_canvas)
 
    def update_canvas(self, *args):
        self.dessin.pos = self.pos
 
    def move(self):
        #On recalcule les positions:
        self.y=self.y+self.dy
        self.x=self.x+self.dx
        self.redescendre()
        #On teste la fin de la chute:
        if self.y<=0-self.size[1]:
            self.y=Window.size[1]
            self.x=random.randint(0,int(Window.size[0]-self.size[0]))
    def redescendre(self):
        #On recalcule les positions:
        if self.y>Window.size[1] or self.y<0:
            self.dy=-self.dy
        if self.x<0 or self.x>Window.size[0]:
            self.dx=-self.dx
    
    def prise(self):
        self.y=Window.size[1]*0.2  
        self.dy=-self.dy
                
    
    def prise_fin(self,dt):#Retour  en haut:
        self.y=0-self.size[1]#
        self.dessin.source='balle.png'   #
        self.dy=-10    #On relance la déscente
 
class plaque(Widget):
    def __init__(self,canvas):
        self.canvas=canvas
        #Taille et position:
        self.size=(Window.size[0]*0.1,Window.size[1]*0.1)
        self.pos=(0,Window.size[1]*0.02)
        #Ajout de l'image (add_wiget fonctionne aussi):
        with self.canvas:
            self.dessin = Rectangle(source='plaque.png',size=self.size, pos=self.pos)
        #On associe le mouvement avec l'image:
        self.bind(pos=self.update_canvas)
 
    def update_canvas(self, *args):#Mise a jour des positions de l'image:
        self.dessin.pos = self.pos
 
class Jeu(FloatLayout):
    def debut(self):
        #On recupere la taille de l'ecran:
        self.size=Window.size
         #Une image de fond:
        self.add_widget(Image(source='fond02.png',allow_stretch=True,keep_ratio=False))
        #Un label pour le score:
        self.score=0#Creation de la variable score
        self.label=Label(text='Score : '+str(self.score),markup=True)
        #Taille de la police en fonction de l'ecran:
        self.label.font_size=self.size[0]*0.05
        #Le label ne doit pas ecraser tout l'ecran:
        self.label.size_hint=(None,None)
        #Position du label vers le centre de l'ecran:
        self.label.pos=(Window.size[0]*0.47,Window.size[1]*0.45)
        self.label.color=[0,0,0,1]
        #On ajoute le label dans l'ecran du jeu:
        self.add_widget(self.label)
        self.plaque=plaque(self.canvas)
        #Creation des balles:
        self.balles=[]
        for i in range(0,5):#On ajoute les balles
            self.balles.append(Balle(self.canvas))
        
        #Creation des chiffres pour de depart:
        self.compteur_anim=3
        self.chiffre=Image(source='3.png',allow_stretch=True,keep_ratio=False)
        self.chiffre.size_hint=(0,0)
        self.chiffre.pos=self.center
        self.add_widget(self.chiffre)
        #Lancement de l'animation start:
        self.animation_start()
        
        #Depart de l'horloge du jeu:
        Clock.schedule_interval(self.update_chute, 4.0/100.0)
 
    def update_chute(self,dt):
        for balle in self.balles:
            balle.move()
            if balle.collide_widget(self.plaque):
                    balle.prise()#Animation de la capture
                    self.score+=1
                    self.label.text='Score : '+str(self.score)
                    
 
    def on_touch_move(self,touch):#Deplacement de la plaque
        if touch.y<self.size[1]/3:
            self.plaque.center_x=touch.x
    
    def animation_start(self):#Depart de l'animation start
        anim = Animation(pos=(0,0),size=self.size,t='in_quad',duration=0.8)
        anim += Animation(pos=self.center,size=(0,0),duration=0.8)
        anim.bind(on_complete=self.animation_next)
        #Depart de l'animation:
        anim.start(self.chiffre)
        
    def animation_next(self,animation,widget):#Animation suivante:
        self.compteur_anim-=1
        if self.compteur_anim==0:
            self.remove_widget(self.chiffre)
        else:
            self.chiffre.source=str(self.compteur_anim)+'.png'
            self.animation_start()  
    
# Creation du screen manager
sm = ScreenManager()

class BalleApp(App):
    def build(self):
        Menu=MenuScreen()#Creation de l'ecran 'Menu'
        Menu.build()#Construction de l'ecran 'Menu'
        #On ajoute l'ecran dans le screen manager
        sm.add_widget(Menu)
        sm.current='Menu'#On definit 'Menu' comme ecran courant
        return sm #On envoie le screen manager pour affichage
 
if __name__ == '__main__':
    BalleApp().run()