Kivy : Les bases

(actualisé le ) par wlaidet

Boutons, labels et TextInput

Dans cet onglet, vous allez voir :

  • Créer et utilser des boutons, labels et inputs
  • Gérer une liste de boutons

Comment insérer et utiliser un bouton, un label et un input.

N’oubliez pas que vous pouvez afficher tous les attributs et méthodes d’un objet avec un print(dir(OBJET)) :

from kivy.uix.button import Button

print(dir(Button))

Télécharger

[’__class__’, ’__delattr__’, ’__dict__’, ’__doc__’, ’__eq__’, ’__events__’, ’__format__’,
’__getattribute__’, ’__hash__’, ’__init__’, ’__metaclass__’, ’__module__’, ’__new__’,
’__proxy_getter’, ’__proxy_setter’, ’__pyx_vtable__’, ’__reduce__’, ’__reduce_ex__’,
’__repr__’, ’__self__’, ’__setattr__’, ’__sizeof__’, ’__str__’, ’__subclasshook__’,
’__weakref__’, ’_create_label’, ’_do_press’, ’_do_release’, ’_font_properties’,
’_trigger_texture_update’, ’add_widget’, ’anchors’, ’background_color’,
’background_disabled_down’, ’background_disabled_normal’, ’background_down’,
’background_normal’, ’bind’, ’bold’, ’border’, ’canvas’, ’center’, ’center_x’, ’center_y’,
’children’, ’clear_widgets’, ’cls’, ’collide_point’, ’collide_widget’, ’color’, ’create_property’,
’disabled’, ’disabled_color’, ’dispatch’, ’events’, ’font_name’, ’font_size’, ’get_center_x’,
’get_center_y’, ’get_parent_window’, ’get_property_observers’, ’get_right’,
’get_root_window’, ’get_top’, ’getter’, ’halign’, ’height’, ’id’, ’ids’, ’is_event_type’, ’italic’,
’last_touch’, ’line_height’, ’markup’, ’max_lines’, ’mipmap’, ’on_disabled’, ’on_opacity’,
’on_press’, ’on_ref_press’, ’on_release’, ’on_touch_down’, ’on_touch_move’,
’on_touch_up’, ’opacity’, ’padding’, ’padding_x’, ’padding_y’, ’parent’, ’pos’, ’pos_hint’,
’properties’, ’property’, ’proxy_ref’, ’refs’, ’register_event_type’, ’remove_widget’, ’right’,
’set_center_x’, ’set_center_y’, ’set_right’, ’set_top’, ’setter’, ’shorten’, ’size’, ’size_hint’,
’size_hint_x’, ’size_hint_y’, ’state’, ’text’, ’text_size’, ’texture’, ’texture_size’,
’texture_update’, ’to_local’, ’to_parent’, ’to_widget’, ’to_window’, ’top’, ’trigger_action’,
’uid’, ’unbind’, ’unregister_event_types’, ’valign’, ’width’, ’x’, ’y’]

Boutons, Labels et Inputs : exemples

Une vidéo pour expliquer :

Le code correspondant :

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.button import Button
from kivy.uix.label import Label
from kivy.uix.textinput import TextInput

class Exemple(BoxLayout):
    def build(self):
        self.orientation='vertical'
        self.spacing=20
        self.Un_Bouton()
        self.Un_Label()
        self.Un_Input()

    def Un_Bouton(self):
        #On cree un bouton:
        self.Bouton1=Button()
        #On lui donne des proprietes:
        #Un texte:
        self.Bouton1.text='Texte du bouton'
        #Une taille en pourcentages:
        self.Bouton1.size_hint=(0.5,0.15)
        #Une position:
        self.Bouton1.pos_hint={'right': 0.75}
        #Une couleur de fond:
        self.Bouton1.background_color=[0,1,0,1]
        #On l'associe a une fonction:
        self.Bouton1.bind(on_press=self.Une_Fonction_Bouton)
        #On l'ajoute au layout principal:
        self.add_widget(self.Bouton1)

    def Un_Label(self):
        #On cree un label avec toutes ses proprietes:
        self.Label1=Label(text="Du texte pour mon label",font_size=30, color=[1,0,0,1])
        #On l'ajoute au layout principal:
        self.add_widget(self.Label1)

    def Un_Input(self):
        #On cree un Input avec des ses proprietes:
        self.Input1 = TextInput(text="Texte initial",font_size=30)
        #On ajoute des proprietes (une largeur de 50% et une hauteur de 20%)
        self.Input1.size_hint_x=0.5
        self.Input1.size_hint_y=0.2
        #On l'ajoute au layout principal:
        self.add_widget(self.Input1)
   
    def Une_Fonction_Bouton(self,instance):
        #On peut changer le texte du bouton:
        #la variable "instance" correspond au bouton qui a ete presse
        instance.text="Bravo !"
        #On peut changer le texte du label:
        self.Label1.text="Bravo !"+"Le texte du bouton est: "+self.Bouton1.text

class ExempleApp(App):

    def build(self):
        Layout=Exemple()
        Layout.build()
        return Layout
if __name__ == '__main__':
    ExempleApp().run()

Télécharger

Les liens Kivy pour connaître toutes les propriétés de ces trois objets :

Gérer une liste de boutons :

Vous devez créer de nombreux boutons ?

Pour cela, rien de tel qu’une boucle et une liste de boutons.

Une vidéo d’explication :

Voici le code :

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.button import Button

class Exemple(BoxLayout):
    def build(self):
        self.orientation='vertical'
        self.spacing=20
        self.Mes_Boutons()

    def Mes_Boutons(self):
        #On cree une liste pour les boutons:
        self.Liste_Boutons=[]
        #On fait tourner une boucle pour creer 10 boutons:
        for i in range(0,10):
            #On ajoute un bouton dans la liste:
            self.Liste_Boutons.append(Button())
            #On lui donne un texte qui depend de i:
            self.Liste_Boutons[i].text="Bouton "+str(i)
            #On lui donne un identite "id" pour le retrouver hors de la liste:
            self.Liste_Boutons[i].id="B"+str(i)
            #On lui associe une fonction:
            self.Liste_Boutons[i].bind(on_press=self.Une_Fonction_Bouton)
            #On ajoute le bouton au layout principal:
            self.add_widget(self.Liste_Boutons[i])
       
        #On ajoute une couleur de fond au dernier bouton:
        self.Liste_Boutons[9].background_color=[0,1,0,1]
   
    def Une_Fonction_Bouton(self,instance):
        #instance correspond au bouton qui vient d'etre active:
        #On change la couleur des neuf premiers boutons:
        for i in range(0,9):
            self.Liste_Boutons[i].background_color=[0.5,0.5,0.5,1] #En gris
        #On change la couleur du bouton active si ce n'est pas le dernier:
        if instance.id!="B9":
            instance.background_color=[1,0,0,1] #En rouge

class Exemple_De_Liste_BoutonsApp(App):

    def build(self):
        root=Exemple()
        root.build()
        return root
if __name__ == '__main__':
    Exemple_De_Liste_BoutonsApp().run()

Télécharger

++++

Les Layout

Dans cet onglet, vous trouverez :

Les types de Layout

  • BoxLayout
  • GridLayout
  • FloatLayout
  • Emboîtement de plusieurs Layout

Tous les Layout sont des Widget, ils ont donc un canvas et des propriétés correspondantes.

Un lien vers Kivy pour trouver tous les types de Layout : Layout

Par exemple, pour une BoxLayout :

from kivy.uix.boxlayout import BoxLayout

print(dir(BoxLayout))

Télécharger

Le résultat :

[’__class__’, ’__delattr__’, ’__dict__’, ’__doc__’, ’__eq__’, ’__events__’, ’__format__’,
’__getattribute__’, ’__hash__’, ’__init__’, ’__metaclass__’, ’__module__’, ’__new__’,
’__proxy_getter’, ’__proxy_setter’, ’__pyx_vtable__’, ’__reduce__’, ’__reduce_ex__’,
’__repr__’, ’__self__’, ’__setattr__’, ’__sizeof__’, ’__str__’, ’__subclasshook__’,
’add_widget’, ’bind’, ’canvas’, ’center’, ’center_x’, ’center_y’, ’children’, ’clear_widgets’,
’cls’, ’collide_point’, ’collide_widget’, ’create_property’, ’disabled’, ’dispatch’, ’do_layout’,
’events’, ’get_center_x’, ’get_center_y’, ’get_parent_window’, ’get_property_observers’,
’get_right’, ’get_root_window’, ’get_top’, ’getter’, ’height’, ’id’, ’ids’, ’is_event_type’,
’on_disabled’, ’on_opacity’, ’on_touch_down’, ’on_touch_move’, ’on_touch_up’,
’opacity’, ’orientation’, ’padding’, ’parent’, ’pos’, ’pos_hint’, ’properties’, ’property’,
’proxy_ref’, ’register_event_type’, ’remove_widget’, ’right’, ’set_center_x’,
’set_center_y’, ’set_right’, ’set_top’, ’setter’, ’size’, ’size_hint’, ’size_hint_x’,
’size_hint_y’, ’spacing’, ’to_local’, ’to_parent’, ’to_widget’, ’to_window’, ’top’, ’uid’,
’unbind’, ’unregister_event_types’, ’width’, ’x’, ’y’]

Les BoxLayout

Le lien vers Kivy.org : BoxLayout

Un exemple en vidéo :

Voici le code correspondant :

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.button import Button
 
class Exemple(BoxLayout):
    def build(self):
        self.orientation='vertical'
        self.spacing=20 #Espace entre les objets contenus
        self.padding=50 #Marges interieures du Layout
        self.Mes_Boutons()
 
    def Mes_Boutons(self):
        #On cree une liste pour les boutons:
        self.Liste_Boutons=[]
        #On fait tourner une boucle pour creer 10 boutons:
        for i in range(0,10):
            #On ajoute un bouton dans la liste:
            self.Liste_Boutons.append(Button(text="Bouton "+str(i)))
            #On lui associe une fonction:
            self.Liste_Boutons[i].bind(on_press=self.Une_Fonction_Bouton)
            #On ajoute le bouton au layout principal:
            self.add_widget(self.Liste_Boutons[i])
 
    def Une_Fonction_Bouton(self,instance):
        #instance correspond au bouton qui vient d'etre active:
        instance.background_color=[0,0,1,1] #En bleu
 
class Exemple_De_BoxLayoutApp(App):
 
    def build(self):
        root=Exemple()
        root.build()
        return root
if __name__ == '__main__':
    Exemple_De_BoxLayoutApp().run()

Télécharger

Les GridLayout

Le lien vers Kivy.org : GridLayout

Un exemple de code :

from kivy.app import App
from kivy.uix.gridlayout import GridLayout
from kivy.uix.button import Button
 
class Exemple(GridLayout):
    def build(self):
        self.cols=5 #Nombre maximum de colonnes
        self.spacing=5 #Espace entre les objets contenus
        self.padding=10 #Marges interieures du Layout
        self.Mes_Boutons()
 
    def Mes_Boutons(self):
        #On cree une liste pour les boutons:
        self.Liste_Boutons=[]
        #On fait tourner une boucle pour creer 10 boutons:
        for i in range(0,10):
            #On ajoute un bouton dans la liste:
            self.Liste_Boutons.append(Button(text="Bouton "+str(i)))
            #On lui associe une fonction:
            self.Liste_Boutons[i].bind(on_press=self.Une_Fonction_Bouton)
            #On ajoute le bouton au layout principal:
            self.add_widget(self.Liste_Boutons[i])
 
    def Une_Fonction_Bouton(self,instance):
        #instance correspond au bouton qui vient d'etre active:
        instance.background_color=[0,0,1,1] #En bleu
 
class Exemple_De_GridLayoutApp(App):
 
    def build(self):
        root=Exemple()
        root.build()
        return root
if __name__ == '__main__':
    Exemple_De_GridLayoutApp().run()

Télécharger

Les FloatLayout :

Le lien vers Kivy.org : FoatLayout

Un exemple :

Le code correspondant :

from kivy.app import App
from kivy.uix.floatlayout import FloatLayout
from kivy.uix.button import Button
 
class Exemple(FloatLayout):
    def build(self):
        #On cree quatre boutons avec tailles et positions:
        self.Bouton_Haut=Button(text="Je suis en haut",size_hint=(.5, .25),
    pos_hint={'x':.25, 'y':.75})
        self.Bouton_Gauche=Button(text="Je suis gauche",size_hint=(.25, .5),
    pos_hint={'x':0, 'y':.25})
        self.Bouton_Droit=Button(text="Je suis droite",size_hint=(.25, .5),
    pos_hint={'x':.75, 'y':.25})
        self.Bouton_Bas=Button(text="Je suis en bas",size_hint=(.5, .25),
    pos_hint={'x':.25, 'y':0})
        #On place les boutons dans le FloatLayout grace aux positions et aux tailles:
        self.add_widget(self.Bouton_Haut)
        self.add_widget(self.Bouton_Gauche)
        self.add_widget(self.Bouton_Droit)
        self.add_widget(self.Bouton_Bas)
 
class Exemple_De_FloatLayoutApp(App):
 
    def build(self):
        root=Exemple()
        root.build()
        return root
if __name__ == '__main__':
    Exemple_De_FloatLayoutApp().run()

Télécharger

Emboîter les Layout :

Le code correspondant :

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.gridlayout import GridLayout
from kivy.uix.floatlayout import FloatLayout
from kivy.uix.button import Button
 
class Exemple(FloatLayout):
    def build(self):
        #Une grille pour le haut :
        self.Haut_Layout=GridLayout(cols=5,size_hint=(0.6,0.7),pos_hint={'x':.2, 'y':.3})
        #Avec des boutons:
        self.Mes_Boutons()
        #On l'ajoute a la fenetre principal:
        self.add_widget(self.Haut_Layout)
        #Une box pour le bas:
        self.Bas_Layout=BoxLayout(orientation='vertical',size_hint=(.5, .3))
        #Un bouton dedans:
        Bouton=Button(text="Je suis en bas")
        self.Bas_Layout.add_widget(Bouton)
        self.add_widget(self.Bas_Layout)
 
    def Mes_Boutons(self):
        #On cree une liste pour les boutons:
        self.Liste_Boutons=[]
        #On fait tourner une boucle pour creer 10 boutons:
        for i in range(0,10):
            #On ajoute un bouton dans la liste:
            self.Liste_Boutons.append(Button(text="Bouton "+str(i)))
            #On lui associe une fonction:
            self.Liste_Boutons[i].bind(on_press=self.Une_Fonction_Bouton)
            #On ajoute le bouton au layout du haut:
            self.Haut_Layout.add_widget(self.Liste_Boutons[i])
 
    def Une_Fonction_Bouton(self,instance):
        #instance correspond au bouton qui vient d'etre active:
        instance.background_color=[0,0,1,1] #En bleu
 
class Exemple_De_GridLayoutApp(App):
 
    def build(self):
        root=Exemple()
        root.build()
        return root
if __name__ == '__main__':
    Exemple_De_GridLayoutApp().run()

Télécharger

++++

Ecrans et menus déroulants

Vous trouverez dans cet onglet :

Gérer plusieurs écrans

  • ScreenManager

Créer des menus déroulants

  • DropDown
  • Spinner

Gérer plusieurs écrans

Un exemple :

from kivy.app import App
from kivy.uix.screenmanager import ScreenManager, Screen
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.button import Button

# On construit deux ecrans : Un Menu et un Game
class MenuScreen(Screen):
    def build(self):
        #Le nom de l'ecran
        self.name='Menu'
        #On cree le contenu:
        Menu_Layout = BoxLayout(padding=20,spacing=10,orientation='vertical')
        #On cree un premier bouton:
        self.Bouton_Niveau1=Button(text='Vers le niveau 1')
        self.Bouton_Niveau1.bind(on_press=self.Vers_Game)
        #On ajoute le bouton dans l'affichage:
        Menu_Layout.add_widget(self.Bouton_Niveau1)
        #On cree un deuxieme bouton:
        self.Bouton_Niveau2=Button(text='Vers le niveau 2')
        self.Bouton_Niveau2.bind(on_press=self.Vers_Game)
        #On ajoute le bouton dans l'affichage:
        Menu_Layout.add_widget(self.Bouton_Niveau2)
       
        #On ajoute le Layout dans l'ecran de menu
        self.add_widget(Menu_Layout)
        #On ajoute l'ecran menu dans le ScreenManager:
        sm.add_widget(self)
   
    #Une fonction pour aller a l'ecran du jeu:
    def Vers_Game(self,instance):
        sm.current='Game'

class GameScreen(Screen):#Le deuxieme ecran : Game
    def build(self):
        self.name='Game'
        Game_Layout=Jeu()#On creer le contenu
        Game_Layout.build()
        self.add_widget(Game_Layout)#On ajoute le contenu dans l'ecran
        sm.add_widget(self)#On ajoute l'ecran menu dans le ScreenManager

class Jeu(BoxLayout):#Le contenu de lecran du jeu

    def build(self):
        self.orientation='horizontal'
        self.spacing=20
        #On cree un bouton:
        self.Bouton_Menu=Button(text='Retour au menu', size_hint=(0.2,0.2))
        self.Bouton_Menu.bind(on_press=self.Vers_Menu)
        #On ajoute le bouton dans l'affichage:
        self.add_widget(self.Bouton_Menu)
   
    #Une fonction pour aller a l'ecran du menu:
    def Vers_Menu(self,instance):
        sm.current='Menu'
 
sm = ScreenManager()# Create the screen manager, il est forcement global

class ScreenApp(App):

    def build(self):
        Menu=MenuScreen()#On definit l'ecran menu
        Menu.build()#On le construit
        Game=GameScreen()#On definit l'ecran jeu
        Game.build()#On le construit
        sm.current='Menu'#On envoie en premier l'ecran du menu grace a son nom
        return sm

if __name__ == '__main__':
    ScreenApp().run()

Télécharger

Créer un menu déroulant : Les DropDown

Par Benjamin :

Le code :

from kivy.uix.dropdown import DropDown
from kivy.uix.button import Button
from kivy.base import runTouchApp


dropdown = DropDown()
for index in range(10):

    btn = Button(text='Value %d' % index, size_hint_y=None, height=44)

    btn.bind(on_release=lambda btn: dropdown.select(btn.text))

    dropdown.add_widget(btn)


mainbutton = Button(text='Hello', size_hint=(None, None))

mainbutton.bind(on_release=dropdown.open)

dropdown.bind(on_select=lambda instance, x: setattr(mainbutton, 'text', x))

runTouchApp(mainbutton)

Télécharger

La suite prochainement....

++++

Dessiner sur le canvas :

La suite prochainement....

++++

Fonds d’écrans

Vous trouverez ici :

  • Des images en fond d’écran
  • Un canvas en fond d’écran

Des images en fond d’écran :

Un résumé en vidéo :

Si le fond reste le même tout le long de l’exécution du programme, alors un il suffit d’utiliser un FloatLayout :

import kivy
from kivy.app import App
from kivy.uix.floatlayout import FloatLayout
from kivy.uix.button import Button
from kivy.uix.image import Image

class FondApp(App):
 
    def build(self):
        #On cree un Layout racine:
        self.Fond=FloatLayout()
        #On importe des images pour le fond avec des options d'etirement
        self.Img1=Image(source='Jungle.jpg',allow_stretch=True,keep_ratio=False)
       
        #On cree un bouton:
        self.Bouton1=Button(text='Un bouton',size_hint=(.3, .5))
        self.Bouton1.bind(on_press=self.une_fonction_bouton)
       
        #On ajoute l'image et le bouton dans la FloatLayout racine:
        self.Fond.add_widget(self.Img1)
        self.Fond.add_widget(self.Bouton1)
       
        #On affiche la racine:
        return self.Fond
 
    def une_fonction_bouton(self,instance):#Pour le bouton
        print("coucou")
 
if __name__ == '__main__':
    FondApp().run()

Télécharger

Avec une image variable :

import kivy
from kivy.app import App
from kivy.uix.floatlayout import FloatLayout
from kivy.uix.button import Button
from kivy.uix.image import Image

class FondApp(App):
 
    def build(self):
        #On cree un Layout racine:
        root=FloatLayout()
        #On cree un FloatLayout pour une image de fond:
        self.Fond=FloatLayout()
        #On importe des images pour le fond avec des options d'etirement
        self.Img1=Image(source='Jungle.jpg',allow_stretch=True,keep_ratio=False)
        self.Img2=Image(source='fee.jpg',allow_stretch=True,keep_ratio=False)
        #On l'insert dans le layout
        self.Fond.add_widget(self.Img1)
        #On cree un bouton pour changer le fond:
        self.Bouton1=Button(text='Fond2',size_hint=(.3, .5))
        self.Bouton1.bind(on_press=self.une_fonction_bouton)
       
        #On ajoute le layout et le bouton dans la FloatLayout racine:
        root.add_widget(self.Fond)
        root.add_widget(self.Bouton1)
       
        #On affiche la racine:
        return root
 
    def une_fonction_bouton(self,instance):#Pour le bouton
        if instance.text=='Fond2':
            self.Fond.remove_widget(self.Img1)
            self.Fond.add_widget(self.Img2)
            instance.text='Fond1'
        else:
            self.Fond.remove_widget(self.Img2)
            self.Fond.add_widget(self.Img1)
            instance.text='Fond2'
 
if __name__ == '__main__':
    FondApp().run()

Télécharger

Un canvas en fond d’écran :

La suite prochainement....

++++

Déplacements et collisions :

Dans cet onglet vous trouverez :

  • 1) Déplacer une balle en touchant l’écran
  • 2) Déplacer en boucle une balle avec des rebonds
  • 3) Mouvements et collisions entre objets :

1) Déplacer une balle en touchant l’écran

from kivy.app import App
from kivy.graphics import Line, Color, Rectangle, Ellipse
from kivy.uix.widget import Widget
from kivy.clock import Clock
 
 
class Balle(Widget):
    def __init__(self,canvas):
        self.x=50
        self.y=20
        self.canvas=canvas
        self.size=(50,50)
        self.color=[1,0,0,0.5]#Rouge
        with self.canvas:
            Color(self.color[0],self.color[1],self.color[2],0.5)
            self.disque=Ellipse(pos=self.pos, size=self.size)
       
        #On associe les modifications de position a une fonction update:
        self.bind(pos=self.update_disque)

    def update_disque(self, *args):
        #On redefinie les position du disque sur le canvas:
        self.disque.pos = self.pos
 
class Jeu(Widget):
 
    def debut(self):
        #On cree la balle:
        self.balle=Balle(self.canvas)
 
    def on_touch_move(self, touch):
        #On teste si le point de l'ecran presse est sur la balle:
        if self.balle.collide_point(touch.x,touch.y):
            #On modifie les coordonnees de la balle en fonction du centre de l'objet:
            self.balle.x = touch.x-self.balle.size[0]/2
            self.balle.y = touch.y-self.balle.size[1]/2
 
    def on_touch_up(self, touch):
        #On teste si le point de l'ecran relache est sur la balle:
        if self.balle.collide_point(touch.x,touch.y):
            #On change les coordonnees de la balle:
            self.balle.pos=(100,100)
 
class MyApp(App):
 
    def build(self):
        Jeu1=Jeu()
        Jeu1.debut()
        return Jeu1
 
if __name__ == '__main__':
    MyApp().run()

Télécharger

2) Déplacer en boucle une balle avec des rebonds :

from kivy.app import App
from kivy.graphics import Line, Color, Rectangle, Ellipse
from kivy.uix.widget import Widget
from kivy.clock import Clock
from kivy.uix.floatlayout import FloatLayout
from kivy.core.window import Window #On importe les donnees d'ecran
 
class Balle(Widget):
    def __init__(self,canvas,pos_x,pos_y,screen):
        self.dx = 1 #Deplacement horizontal
        self.dy = -5 #Deplacement vertical
        self.pos=(pos_x,pos_y)
        self.canvas=canvas
        self.size=(50,50)
        self.screen=screen #Taille de l'ecran
        #On dessine la balle:
        with self.canvas:
 
            Color(0,1,0,0.5)#vert
 
            self.disque=Ellipse(pos=self.pos, size=self.size)
           
        #On associe les modifications de position a une fonction update:
        self.bind(pos=self.update_disque)

    def update_disque(self, *args):
        #On redefinie les positions du disque sur le canvas:
        self.disque.pos = self.pos
 
    def move(self):
        #On teste si la balle touche le sol:
        if  self.pos[1]<0 or self.pos[1]+self.size[1]>self.screen[1]:
            self.dy=-1*self.dy
        #On recalcule les positions:
        self.pos = (self.dx + self.pos[0],self.dy +self.pos[1])
 
class Jeu(FloatLayout):
 
    def build(self):
        #On recupere la taille de l'ecran:
        self.size=Window.size
        #On cree les balles:
        self.balle1=Balle(self.canvas,self.size[0]*0.2,self.size[1]*0.8,self.size)
        self.balle2=Balle(self.canvas,self.size[0]*0.6,self.size[1]*0.6,self.size)
 
    def update(self, dt):
        #On deplace les balles:
        self.balle1.move()
        self.balle2.move()
 
class MyApp(App):
 
    def build(self):
        Jeu1=Jeu()
        Jeu1.build()
        #On appelle Jeu1.update() tous les centiemes de seconde
        Clock.schedule_interval(Jeu1.update, 1.0/100.0)
        return Jeu1
 
 
if __name__ == '__main__':
    MyApp().run()

Télécharger

3) Mouvements et collisions entre objets :

Chaque Widget possède une méthode : collide_widget.

from kivy.app import App
from kivy.graphics import Line, Color, Rectangle, Ellipse
from kivy.uix.widget import Widget
from kivy.clock import Clock
from kivy.uix.floatlayout import FloatLayout
from kivy.core.window import Window #On importe les donnees d'ecran
 
class Raquette(Widget):
    def __init__(self,canvas,posX,posY,screen):
        self.x=posX
        self.y=posY
        self.canvas=canvas
        self.size=(50,screen[1]*0.3)
        with self.canvas:
            Color(1,0,0,0.5)
            self.rect=Rectangle(pos=self.pos, size=self.size)
        #On associe les modifications de position a une fonction update:
        self.bind(pos=self.update_rect)

    def update_rect(self, *args):
        #On redefinie les position du disque sur le canvas:
        self.rect.pos = self.pos
 
class Balle(Widget):
    def __init__(self,canvas,pos_x,pos_y,screen):
        self.dx = 4 #Deplacement horizontal
        self.dy = 0 #Deplacement vertical
        self.pos=(pos_x,pos_y)
        self.canvas=canvas
        self.size=(50,50)
        self.screen=screen #Taille de l'ecran
        #On dessine la balle:
        with self.canvas:
            Color(0,1,0,0.5)
            self.disque=Ellipse(pos=self.pos, size=self.size)
        #On associe les modifications de position a une fonction update:
        self.bind(pos=self.update_disque)

    def update_disque(self, *args):
        #On redefinie les position du disque sur le canvas:
        self.disque.pos = self.pos
 
    def move(self):
        #On teste le rbond de la balle a droite:
        if self.x+self.size[0]>self.screen[0]:
            self.dx=-1*self.dx
        #On recalcule les positions:
        self.pos = (self.dx + self.pos[0],self.dy +self.pos[1])

 
class Jeu(FloatLayout):
 
    def build(self):
        #On recupere la taille de l'ecran:
        self.size=Window.size
        #On cree les balles:
        self.balle=Balle(self.canvas,self.size[0]*0.5,self.size[1]*0.5,self.size)
        self.raquette=Raquette(self.canvas,self.size[0]*0.2,self.size[1]*0.1,self.size)
 
    def update(self, dt):
        #On teste si la balle touche la raquette:
        if self.balle.collide_widget(self.raquette):
            #On change la direction de la balle:
            self.balle.dx=-1*self.balle.dx
            #On decale la balle pour eviter le probleme de colle:
            self.balle.x=self.raquette.x+self.raquette.size[0]
        #On deplace les balles:
        self.balle.move()
   
    def on_touch_move(self, touch):
        #On teste si le point de l'ecran presse est sur la raquette:
        if self.raquette.collide_point(touch.x,touch.y):
            #On modifie les coordonnees de la raquette en fonction du centre de l'objet:
            self.raquette.x = touch.x-self.raquette.size[0]/2
            self.raquette.y = touch.y-self.raquette.size[1]/2
 
class MyApp(App):
 
    def build(self):
        Jeu1=Jeu()
        Jeu1.build()
        #On appelle Jeu1.update() tous les centiemes de seconde
        Clock.schedule_interval(Jeu1.update, 1.0/100.0)
        return Jeu1
 
 
if __name__ == '__main__':
    MyApp().run()

Télécharger

La suite prochainement....