import pygame
from pygame.locals import *
import os, sys
import math
import random

##commentaires
#TO DO
#ameliorer la physique de la boule!!!
#mettre une AUTRE texture au background
#penser au guy
#pense a l ia
#coder le controle souris 
#penser au menu pour configurer le bouzin et stocker dans une cfg
# un joueur qui passe sur un autre joueur doit lui prendre sa balle
#la mort prend effet mais le joueur n'est pas remplace par un carre rouge sil bouge !
#remplacer les tableaux pas des tuple !!
#essayer de limiter a un les test de collisions (a chaque fois qune boule touche un bord, le test est effectue trois fois)
#si un joueur meurt, incrementer le score du lanceur
#preparer un bonus qd un joueur meurt


##Explications supplementaires
#balle_pos renseigne par son numero de cellule le num de la balle , et la valeur de la cellule renseigne le joueur qui la

class Bonus:
	def __init__(self):
		pass








class Bords:
	def __init__(self):
		self.image1 = pygame.image.load(os.path.join('media', 'bord_hori.png'))
		self.image2 = pygame.image.load(os.path.join('media', 'bord_verti.png'))
		self.image1 = self.image1.convert(self.image1)
		self.image2 = self.image2.convert(self.image2)
		self.image3 =self.image1 #hori
		self.image4 = self.image2#verti
		self.rect1 = self.image1.get_rect()
		self.rect2 = self.image2.get_rect()
		self.rect3 = self.image3.get_rect()
		self.rect4 = self.image4.get_rect()
		self.rect1.topleft = [0,0] #haut
		self.rect2.topleft = [0,0]#droite wtf ???
		self.rect3.topleft = [0,598]#gauche
		self.rect4.topleft = [598,0]#droite
		
	

class Balle(pygame.sprite.Sprite):
	image = None

	def __init__(self, initial_position):
		pygame.sprite.Sprite.__init__(self)
		if self.image is None:
			self.image1 = pygame.image.load(os.path.join('media', 'balle1.png'))
			self.image2 = pygame.image.load(os.path.join('media', 'balle2.png'))
			self.image3 = pygame.image.load(os.path.join('media', 'balle3.png'))
			self.image4 = pygame.image.load(os.path.join('media', 'balle4.png'))
		self.image1 = self.image1.convert(self.image1)
		self.image2 = self.image2.convert(self.image2)
		self.image3 = self.image3.convert(self.image3)
		self.image4 = self.image4.convert(self.image4)
		self.image =self.image2
		self.rect = self.image.get_rect()
		self.rect.topleft = initial_position
		self.rect2 =self.rect
		self.vitesse = 0 #normalement sans vitesse initiale
		self.angle_p = []  #angle positif
		self.angle_n =[]	#angle negatif
		
		self.a = 0
		self.b = 0
		self.ecran = pygame.display.get_surface()
		self.ecran = self.ecran.get_rect()
		self.variable = True
		self.attente = 0 ##animation de la balle
		self.mouv = 0
	
	def mvposition(self):
		
		if self.vitesse > 2.75 : #pour optimiser creer une autre fonction quon active lorsque la vitesse change
			self.image = self.image1
		elif self.vitesse <= 2.75 :
			self.image = self.image2
		
		self.rect = self.rect.move(self.a, self.b)
	
	
	def mouvement(self):
		
		repere2 = self.rect.topleft
		self.repere2 = repere2
		
		if self.vitesse == 0:
			pass
		elif self.mouv ==0:
			self.image = self.image1
			self.rect = self.image.get_rect()
			self.rect.topleft = repere2
			self.mvposition()
			self.attente = self.attente + 1
			if self.attente>3:
				self.attente = 0
				self.mouv = 1
		elif self.mouv == 1:
			self.image = self.image2
			self.rect = self.image.get_rect()
			self.rect.topleft = repere2
			self.mvposition()	
			self.attente = self.attente + 1
			if self.attente>3:
				self.attente = 0
				self.mouv = 2
		elif self.mouv == 2:
			self.image = self.image3
			self.rect = self.image.get_rect()
			self.rect.topleft = repere2
			self.mvposition()	
			self.attente = self.attente + 1
			if self.attente>3:
				self.attente = 0
				self.mouv = 3
		elif self.mouv == 3:
			self.image = self.image4
			self.rect = self.image.get_rect()
			self.rect.topleft = repere2
			self.mvposition()	
			self.attente = self.attente + 1
			if self.attente>3:
				self.attente = 0
				self.mouv = 0
	
	
	
	
	def verification_vitesse(self):
		
		if self.vitesse < 1.5 :
			self.vitesse = 0
			
			
	
	def rebond_horizontale_haut(self):
		
		
		
		self.angle = 45
		self.temp = (math.pi*self.angle)/180
		self.a= math.cos(self.temp)*(-1)*self.vitesse
		self.b = math.sin(self.temp)*self.vitesse
		self.vitesse =self.vitesse - 0.25
		self.verification_vitesse()
		
	def rebond_horizontale_bas(self):
		
		
		
		self.angle = -45
		self.temp = (math.pi*self.angle)/180
		self.a= math.cos(self.temp)*self.vitesse
		self.b = math.sin(self.temp)*self.vitesse
		self.vitesse =self.vitesse - 0.25
		self.verification_vitesse()
		
	def rebond_verticale_gauche(self):
		
		self.angle = 45
		
	
		self.temp = (math.pi*self.angle)/180
		self.a= math.cos(self.temp)*self.vitesse
		self.b = math.sin(self.temp)*self.vitesse
		self.vitesse =self.vitesse - 0.25
		self.verification_vitesse()
		
	def rebond_verticale_droite(self):
		
		self.angle = -45
		
	
		self.temp = (math.pi*self.angle)/180
		self.a= math.cos(self.temp)*(-1)*self.vitesse
		self.b = math.sin(self.temp)*self.vitesse
		self.vitesse =self.vitesse - 0.25
		self.verification_vitesse()
		
	
		
	def vitesse(self):
		
		return(self.vitesse)
	
	def rectangle(self):
	
		return(self.rect)
	def rectangle2(self, a):
		self.rect = a
		
	def lancer(self, direction):
		vitesse_lance = 10
		repere = self.rect.topleft
		self.rect = self.rect2
		#self.rect = self.image.get_rect()
		self.rect.topleft = repere
		
		
		if direction[0]==1: ##up
			self.a =0
			self.b=-1
			
			
		elif direction[1]==1:##down
			self.a =0
			self.b=1
			self.rect = self.rect.move(0,55)
			
		elif direction[2]==1:##left
			self.a =-1
			self.b=0
			
			
		elif direction[3]==1:##right
			self.a =1
			self.b=0
			self.rect = self.rect.move(34,0)
			
		self.vitesse = vitesse_lance
		self.a =self.a*self.vitesse
		self.b = self.b*self.vitesse
		self.mouvement()
			
	
		
class Soldat(pygame.sprite.Sprite) :
	
	image = None

	def __init__(self, initial_position, couleur):
		pygame.sprite.Sprite.__init__(self)
		if couleur ==0: #vert
			self.image = True
			self.down1 = pygame.image.load(os.path.join('media', 'down1.png'))
			self.down2 = pygame.image.load(os.path.join('media', 'down2.png'))
			self.down3 = pygame.image.load(os.path.join('media', 'down3.png'))
			self.down4 = pygame.image.load(os.path.join('media', 'down4.png'))
			self.up1 = pygame.image.load(os.path.join('media', 'up1.png'))
			self.up2 = pygame.image.load(os.path.join('media', 'up2.png'))
			self.up3 = pygame.image.load(os.path.join('media', 'up3.png'))
			self.up4 = pygame.image.load(os.path.join('media', 'up4.png'))
			self.right1 = pygame.image.load(os.path.join('media', 'right1.png'))
			self.right2 = pygame.image.load(os.path.join('media', 'right2.png'))
			self.right3 = pygame.image.load(os.path.join('media', 'right3.png'))
			self.right4 = pygame.image.load(os.path.join('media', 'right4.png'))
			self.left1 = pygame.image.load(os.path.join('media', 'left1.png'))
			self.left2 = pygame.image.load(os.path.join('media', 'left2.png'))
			self.left3 = pygame.image.load(os.path.join('media', 'left3.png'))
			self.left4 = pygame.image.load(os.path.join('media', 'left4.png'))
			
		elif couleur == 1: #bleu cyan
			self.image = True
			self.down1 = pygame.image.load(os.path.join('media', 'down11.png'))
			self.down2 = pygame.image.load(os.path.join('media', 'down22.png'))
			self.down3 = pygame.image.load(os.path.join('media', 'down33.png'))
			self.down4 = pygame.image.load(os.path.join('media', 'down44.png'))
			self.up1 = pygame.image.load(os.path.join('media', 'up11.png'))
			self.up2 = pygame.image.load(os.path.join('media', 'up22.png'))
			self.up3 = pygame.image.load(os.path.join('media', 'up33.png'))
			self.up4 = pygame.image.load(os.path.join('media', 'up44.png'))
			self.right1 = pygame.image.load(os.path.join('media', 'right11.png'))
			self.right2 = pygame.image.load(os.path.join('media', 'right22.png'))
			self.right3 = pygame.image.load(os.path.join('media', 'right33.png'))
			self.right4 = pygame.image.load(os.path.join('media', 'right44.png'))
			self.left1 = pygame.image.load(os.path.join('media', 'left11.png'))
			self.left2 = pygame.image.load(os.path.join('media', 'left22.png'))
			self.left3 = pygame.image.load(os.path.join('media', 'left33.png'))
			self.left4 = pygame.image.load(os.path.join('media', 'left44.png'))
		elif couleur ==2:
			self.image = True
			self.down1 = pygame.image.load(os.path.join('media', 'down111.png'))
			self.down2 = pygame.image.load(os.path.join('media', 'down222.png'))
			self.down3 = pygame.image.load(os.path.join('media', 'down333.png'))
			self.down4 = pygame.image.load(os.path.join('media', 'down444.png'))
			self.up1 = pygame.image.load(os.path.join('media', 'up111.png'))
			self.up2 = pygame.image.load(os.path.join('media', 'up222.png'))
			self.up3 = pygame.image.load(os.path.join('media', 'up333.png'))
			self.up4 = pygame.image.load(os.path.join('media', 'up444.png'))
			self.right1 = pygame.image.load(os.path.join('media', 'right111.png'))
			self.right2 = pygame.image.load(os.path.join('media', 'right222.png'))
			self.right3 = pygame.image.load(os.path.join('media', 'right333.png'))
			self.right4 = pygame.image.load(os.path.join('media', 'right444.png'))
			self.left1 = pygame.image.load(os.path.join('media', 'left111.png'))
			self.left2 = pygame.image.load(os.path.join('media', 'left222.png'))
			self.left3 = pygame.image.load(os.path.join('media', 'left333.png'))
			self.left4 = pygame.image.load(os.path.join('media', 'left444.png'))
		
		
		self.down1 = self.down1.convert(self.down1)
		self.down2 = self.down2.convert(self.down2)
		self.down3 = self.down3.convert(self.down3)
		self.down4 = self.down4.convert(self.down4)
		self.up1 = self.up1.convert(self.up1)
		self.up2 = self.up2.convert(self.up2)
		self.up3 = self.up3.convert(self.up3)
		self.up4 = self.up4.convert(self.up4)
		self.right1 = self.right1.convert(self.right1)
		self.right2 = self.right2.convert(self.right2)
		self.right3 = self.right3.convert(self.right3)
		self.right4 = self.right4.convert(self.right4)
		self.left1 = self.left1.convert(self.left1)
		self.left2 = self.left2.convert(self.left2)
		self.left3 = self.left3.convert(self.left3)
		self.left4 = self.left4.convert(self.left4)
		self.image = self.down1
		self.rect = self.image.get_rect()
		self.rect.topleft = initial_position
		
		self.vitesse = 3 ## vitesse du mec
		self.deplacement = 0
		self.mouv = 1
		self.attente = 0
		self.vie = 100
		self.inballe = False ##si le joueur a une balle ou pas
		
		self.repere = self.rect.topleft
		self.mort = False
		
		
	def mouvement(self, tableau):
		
		repere = self.rect.topleft
		self.repere = repere
		
		if self.mort == False :
		
			if tableau == (1,0,0,0):
				if self.mouv == 1:
					self.image = self.up1
					self.rect = self.image.get_rect()
					self.rect.topleft = repere
					self.UP()
					self.attente = self.attente + 1
					if self.attente>7:
						self.attente = 0
						self.mouv = 2
				elif self.mouv == 2:
					self.image = self.up2
					self.rect = self.image.get_rect()
					self.rect.topleft = repere
					self.UP()
					self.attente = self.attente + 1
					if self.attente>7:
						self.attente = 0
						self.mouv = 3
				elif self.mouv == 3:
					self.image = self.up3
					self.rect = self.image.get_rect()
					self.rect.topleft = repere
					self.UP()
					self.attente = self.attente + 1
					if self.attente>7:
						self.attente = 0
						self.mouv = 4
				elif self.mouv == 4:
					self.image = self.up4
					self.rect = self.image.get_rect()
					self.rect.topleft = repere
					self.UP()
					self.attente = self.attente + 1
					if self.attente>7:
						self.attente = 0
						self.mouv = 1
			elif tableau == (0,1,0,0) :
				if self.mouv == 1:
					self.image = self.down1
					self.rect = self.image.get_rect()
					self.rect.topleft = repere
					self.DOWN()
					self.attente = self.attente + 1
					if self.attente>7:
						self.attente = 0
						self.mouv = 2
				elif self.mouv == 2:
					self.image = self.down2
					self.rect = self.image.get_rect()
					self.rect.topleft = repere
					self.DOWN()
					self.attente = self.attente + 1
					if self.attente>7:
						self.attente = 0
						self.mouv = 3
				elif self.mouv == 3:
					self.image = self.down3
					self.rect = self.image.get_rect()
					self.rect.topleft = repere
					self.DOWN()
					self.attente = self.attente + 1
					if self.attente>7:
						self.attente = 0
						self.mouv = 4
				elif self.mouv == 4:
					self.image = self.down4
					self.rect = self.image.get_rect()
					self.rect.topleft = repere
					self.DOWN()
					self.attente = self.attente + 1
					if self.attente>7:
						self.attente = 0
						self.mouv = 1
			elif tableau == (0,0,1,0):
				if self.mouv == 1:
					self.image = self.left1
					self.rect = self.image.get_rect()
					self.rect.topleft = repere
					self.LEFT()
					self.attente = self.attente + 1
					if self.attente>7:
						self.attente = 0
						self.mouv = 2
				elif self.mouv == 2:
					self.image = self.left2
					self.rect = self.image.get_rect()
					self.rect.topleft = repere
					self.LEFT()
					self.attente = self.attente + 1
					if self.attente>7:
						self.attente = 0
						self.mouv = 3
				elif self.mouv == 3:
					self.image = self.left3
					self.rect = self.image.get_rect()
					self.rect.topleft = repere
					self.LEFT()
					self.attente = self.attente + 1
					if self.attente>7:
						self.attente = 0
						self.mouv = 4
				elif self.mouv == 4:
					self.image = self.left4
					self.rect = self.image.get_rect()
					self.rect.topleft = repere
					self.LEFT()
					self.attente = self.attente + 1
					if self.attente>7:
						self.attente = 0
						self.mouv = 1
			elif tableau == (0,0,0,1):
				if self.mouv == 1:
					self.image = self.right1
					self.rect = self.image.get_rect()
					self.rect.topleft = repere
					self.RIGHT()
					self.attente = self.attente + 1
					if self.attente>7:
						self.attente = 0
						self.mouv = 2
				elif self.mouv == 2:
					self.image = self.right2
					self.rect = self.image.get_rect()
					self.rect.topleft = repere
					self.RIGHT()
					self.attente = self.attente + 1
					if self.attente>7:
						self.attente = 0
						self.mouv = 3
				elif self.mouv == 3:
					self.image = self.right3
					self.rect = self.image.get_rect()
					self.rect.topleft = repere
					self.RIGHT()
					self.attente = self.attente + 1
					if self.attente>7:
						self.attente = 0
						self.mouv = 4
				elif self.mouv == 4:
					self.image = self.right4
					self.rect = self.image.get_rect()
					self.rect.topleft = repere
					self.RIGHT()
					self.attente = self.attente + 1
					if self.attente>7:
						self.attente = 0
						self.mouv = 1
					
					
		
					
	def UP(self):
		
		self.rect = self.rect.move(0, -(self.vitesse))
		
		
	def DOWN(self):
		self.rect = self.rect.move(0, self.vitesse)
		
	def LEFT(self):
		self.rect = self.rect.move(-(self.vitesse), 0)
	def RIGHT(self):
		self.rect = self.rect.move(self.vitesse,0)
	
	def Vie(self):
		lol=2
	
	
	def MORT(self): #En attendant un vrai sprite de sang..
		self.image = pygame.Surface([15, 15])
		self.image.fill([250,0,0])
		self.rect = self.image.get_rect()
		self.rect.topleft = self.repere
		self.mort = True
	
	def checkmort(self):
		return(self.mort)
	
		
	def rectangle(self):
		return(self.rect)
		
	
	
	def collision(self):
		a=600
		
		if self.rect.right >= a :
			self.LEFT()
		if self.rect.top<= 0:
			self.DOWN()
		if self.rect.left<=0 :
			self.RIGHT()
		if self.rect.bottom >=a :
			self.UP()
			
class Jeu:
	
	
	
	def __init__(self, largeur=600, hauteur=600):
		
		pygame.init()
		self.largeur = largeur
		self.hauteur = hauteur
		self.screen = pygame.display.set_mode([self.largeur, self.hauteur])
		self.background0 = pygame.image.load(os.path.join('media', 'background.png'))
		self.background0 = self.background0.convert(self.background0)
		
		self.caca = 0 
		self.baballe = 0
		
		self.haut1 = (1,0,0,0)
		self.bas1 = (0,1,0,0)
		self.gauche1 = (0,0,1,0)
		self.droite1 = (0,0,0,1)
		self.vide1 = (0,0,0,0)
		
		
		
		
		##mv_sens conserve la direction du mec
		#self.background = pygame.Surface([self.largeur, self.hauteur])  ##background noir a remplacer par texture, idee : conserver tt les objets dans un tableau !
		#self.background.fill([0,0,0])
		self.barriere = Bords()
		self.boule = Balle([70,75]) 
		self.boule2 = Balle([200,200])
		self.boule3 = Balle([260,270])
		self.joueur = Soldat([300,75], 0)##choix des couleurs soldat
		self.joueur2 = Soldat([500,400], 1)
		self.joueur3 = Soldat([500, 300], 2)
		
		
		
		self.joueur_balle =[[0,1,2],[0,0,0]] #possetion de la balle par un joueur
		
		
		self.haut = self.barriere.rect1
		self.bas = self.barriere.rect3
		self.droite = self.barriere.rect4
		self.gauche = self.barriere.rect2
		
		
	def updates_screen(self):
		
		
		self.screen.blit(self.background0, [0,0])
		self.screen.blit(self.barriere.image1, self.barriere.rect1)
		self.screen.blit(self.barriere.image2, self.barriere.rect2)
		self.screen.blit(self.barriere.image3, self.barriere.rect3)
		self.screen.blit(self.barriere.image4, self.barriere.rect4)
		self.screen.blit(self.joueur3.image, self.joueur3.rect)
		self.screen.blit(self.joueur2.image, self.joueur2.rect)
		self.screen.blit(self.joueur.image, self.joueur.rect)
		self.screen.blit(self.boule.image, self.boule.rect)
		self.screen.blit(self.boule2.image, self.boule2.rect)
		self.screen.blit(self.boule3.image, self.boule3.rect)
		pygame.display.update()
		
	def collision(self): 
		##sa valeur defini le nombre de joueur a tester #caca
		##defini le nombre de balle a tester #baballe
		
		
		if self.caca >=3:
			self.caca = 0
		
			
		while self.caca<3: 
			
			
			if self.caca == 0:
				
				a = self.joueur
			elif self.caca == 1:
				
				a = self.joueur2
			elif self.caca == 2:
				a = self.joueur3
				
			self.rectjoueur = Soldat.rectangle(a)
			
			while self.baballe<3:
			
				if self.baballe==0:
					b = self.boule
				elif self.baballe==1:
					b = self.boule2
				elif self.baballe==2:
					b = self.boule3
			
		
		
			
				
			
		
				#faire une boucle pour changer les noms
				self.rectballe = Balle.rectangle(b)
				
				
				
				
		
				Soldat.collision(a)
		
				#Balle.collision(b)
				
				if self.rectballe.colliderect(self.haut):

					Balle.rebond_horizontale_haut(b)
					
				elif self.rectballe.colliderect(self.bas):
					
					Balle.rebond_horizontale_bas(b)
					
					
				elif self.rectballe.colliderect(self.gauche):

					Balle.rebond_verticale_gauche(b)
					
					
				elif self.rectballe.colliderect(self.droite):
					
					Balle.rebond_verticale_droite(b)
					
				if Soldat.checkmort(a) == False:	
					if self.rectjoueur.colliderect(self.rectballe) == True :
						if Balle.vitesse(b) > 2.75:
							self.mortjoueur[self.caca]=1 
							Soldat.MORT(a)
				
						elif Balle.vitesse(b)<= 2.75 and self.ramassage[self.caca]==0:
							self.ramassage[self.caca] = 1
						#self.ramassage[i]=Soldat.ramasser(a, True)
						#Balle.rectangle2(b, self.rectjoueur)
							self.balle_poss[self.caca]=self.baballe
						
				#if self.balle_poss[baballe]!=9:
					
					#if self.ramassage[0]==1 and caca = 0:
					#self.rectballe = self.rectjoueur
					#if self.ramassage[0]==1 and caca = 0:
					if self.caca == 0 and self.ramassage[self.caca]==1:
						
						if self.balle_poss[self.caca]==0:
							self.boule.rect = self.joueur.rect
						elif self.balle_poss[self.caca]==1:	
							self.boule2.rect = self.joueur.rect
						elif self.balle_poss[self.caca]==2:	
							self.boule3.rect = self.joueur.rect	
					
					if self.caca == 1 and self.ramassage[self.caca]==1:
						
						if self.balle_poss[self.caca]==0:
							self.boule.rect = self.joueur2.rect
						elif self.balle_poss[self.caca]==1:	
							self.boule2.rect = self.joueur2.rect
						elif self.balle_poss[self.caca]==2:	
							self.boule3.rect = self.joueur2.rect	
							
					if self.caca == 2 and self.ramassage[self.caca]==1:
					
						if self.balle_poss[self.caca]==0:
							self.boule.rect = self.joueur3.rect
						elif self.balle_poss[self.caca]==1:	
							self.boule2.rect = self.joueur3.rect
						elif self.balle_poss[self.caca]==2:	
							self.boule3.rect = self.joueur3.rect	
					
				
				
					
				
				self.baballe = self.baballe + 1
			
			self.baballe = 0
			self.caca = self.caca + 1
	
	
	def MainLoop(self):
		
		#mv_direction = [0,0,0,0]##connaitre la direction ds lakel se deplacer
		#mv_sens=[0,0,0,0]##garde en memoire lorientation du joueur
		mv_direction = self.vide1
		mv_direction2 = self.vide1
		#mv_direction2 = [0,0,0,0]
		#mv_sens2=[0,0,0,0]
		
		clock = pygame.time.Clock()
		
		self.mortjoueur = [0,0,0] #inutile pour linstant
		
		self.ramassage= [0,0,0] ##savoir quelle joueur possede une balle
		self.balle_poss =[9,9,9]	##crer un deuxieme tableau ici pour savoir quelle balle a ete ramassee
		
		while 1 :
			clock.tick(60)

			mainprocess.updates_screen()
			
			
			self.collision()
		
			for event in pygame.event.get():
				if event.type == pygame.QUIT: 
						sys.exit()
						
				
					
				elif event.type == KEYDOWN:##gestion des deplacements
					if (event.key == K_ESCAPE):
						sys.exit()
					
					if (event.key == K_UP) and self.mortjoueur[0]==0:  #on pourra mettre una variable pour petmettre de configurer les touches
						
						
						mv_direction = self.haut1
						mv_sens = self.haut1
						
						#mv_direction[0]=1
						#mv_direction[1]=0
						#mv_direction[2]=0
						#mv_direction[3]=0
						#mv_sens[0]=1
						#mv_sens[1]=0
						#mv_sens[2]=0
						#mv_sens[3]=0
						
					elif (event.key == K_DOWN)and self.mortjoueur[0]==0:
						
						mv_direction = self.bas1
						mv_sens = self.bas1
						
						#mv_direction[0]=0
						#mv_direction[1]=1
						#mv_direction[2]=0
						#mv_direction[3]=0
						#mv_sens[0]=0
						#mv_sens[1]=1
						#mv_sens[2]=0
						#mv_sens[3]=0
					elif (event.key == K_LEFT)and self.mortjoueur[0]==0:
						
						mv_direction = self.gauche1
						mv_sens = self.gauche1
						#mv_direction[0]=0
						#mv_direction[1]=0
						#mv_direction[2]=1
						#mv_direction[3]=0
						#mv_sens[0]=0
						#mv_sens[1]=0
						#mv_sens[2]=1
						#mv_sens[3]=0
					elif (event.key == K_RIGHT)and self.mortjoueur[0]==0:
						
						
						mv_direction = self.droite1
						mv_sens = self.droite1
						#mv_direction[0]=0
						#mv_direction[1]=0
						#mv_direction[2]=0
						#mv_direction[3]=1
						#mv_sens[0]=0
						#mv_sens[1]=0
						#mv_sens[2]=0
						#mv_sens[3]=1
						
					elif (event.key == K_RCTRL ):
						#mv_direction[0]=0
						#mv_direction[1]=0
						#mv_direction[2]=0
						#mv_direction[3]=0
						mv_direction = self.vide1
						
					
					if (event.key == K_o)and self.mortjoueur[0]==0 and self.ramassage[0]==1:##reecrire cette partie pour connaitre la balle possede
						#self.ramassage[0]=False ##stock ds un tableau la boule possede
						if self.balle_poss[0]==0:
							Balle.lancer(self.boule, mv_sens)
						elif self.balle_poss[0]==1:
							Balle.lancer(self.boule2, mv_sens)
						elif self.balle_poss[0]==2:
							Balle.lancer(self.boule3, mv_sens)
						#Balle.mouvement(self.boule) 
						self.ramassage[0]=0
						self.balle_poss[0]=9
						
					
					if(event.key == K_w) and self.mortjoueur[1]==0 :
						mv_direction2 = self.haut1
						mv_sens2 = self.haut1
						
					elif (event.key == K_s) and self.mortjoueur[1]==0 :
						mv_direction2 = self.bas1
						mv_sens2 = self.bas1
						
					elif (event.key == K_a) and self.mortjoueur[1]==0 :
						mv_direction2 = self.gauche1
						mv_sens2 = self.gauche1
					elif (event.key == K_d) and self.mortjoueur[1]==0 :
						mv_direction2 = self.droite1
						mv_sens2 = self.droite1
						
					elif (event.key == K_x):
						mv_direction2 = self.vide1
					
					if (event.key == K_t)and self.mortjoueur[1]==0 and self.ramassage[1]==1 :##reecrire cette partie pour connaitre la balle possede
						#self.ramassage[0]=False ##stock ds un tableau la boule possede
						if self.balle_poss[1]==0:
							Balle.lancer(self.boule, mv_sens2)
						elif self.balle_poss[1]==1:
							Balle.lancer(self.boule2, mv_sens2)
						elif self.balle_poss[1]==2:
							Balle.lancer(self.boule3, mv_sens2)
						#Balle.mouvement(self.boule) 
						self.ramassage[1]=0
						self.balle_poss[1]=9
						
						
			
					
					
			self.joueur.mouvement(mv_direction)
			self.joueur2.mouvement(mv_direction2)
			#self.joueur3.mouvement(mv_direction3)#commentaire en attendant limplementation des controles
		
		
		
			self.boule.mvposition()
			self.boule2.mvposition()
			self.boule3.mvposition()
			
			##replace par mv position en attendant une nouvelle animation de la balle
			#self.boule.mouvement()
			#self.boule2.mouvement()
			#self.boule3.mouvement()
			
			mainprocess.updates_screen()
				
					
			
				
				
				

mainprocess = Jeu()
mainprocess.MainLoop()
