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

[’__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()

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

• Les boutons
• Les labels
• Les TextInput

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

++++

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

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

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

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

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

++++

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

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)

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

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

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

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

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

La suite prochainement....