KIVY

_images/titrevideo.PNG_images/blanc1.png
convert mp4 to webm by EasyHtml5Video.com v3.9.1
Objectif du tutoriel :
OBJECTIF

Construire

  • Afficher une fenêtre, avec un titre et une icône.
  • Déterminer la dimension de la fenêtre pour qu’elle puisse afficher des textes et des images.
  • Inclure dans la fenêtre un canevas (Canvas) pour afficher des images qui peuvent se déplacer à l’aide de la souris.
  • Utiliser les listes pour stocker des données.

Le dossier images kivy contient les images du tutoriel

_images/kivy000.PNG

Pour télécharger les images du dossier images kivy appuyer sur le lien Lien pour télécharger images kivy

Le code du programme:

Affichage du code:

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()