"""
# represente un oiseau
"""
class Jeu():

    """
    # intialise jeu
    """
    def __init__(self):
        # envol caut faux tant qu'on ne lache pas la souris
        self.enVol=False

        # liste des planetes [x,y,rayon,masse]
        self.planetes=[[200,200,20,-100000]]
        self.planetes+=[[400,300,40,400000]]
        # masse negative
        self.planetes+=[[300,300,25,-200000]]

        # la vitesse initiale
        self.commande=[0,0]
        # norme maximale de la vitesse initiale
        self.vMax=100

        # attributs par defaut
        self.x=100
        self.y=300
        self.vx=0
        self.vy=0
        self.ax=0
        self.ay=9
        self.dt=0.1

        # trajectoire sauvee
        self.traj=[]

    """
    # modifier commande initiale quand on bouge la souris
    """
    def setCommande(self,x,y):
        # utilise la vitesse maximale
        vMax=self.vMax

        # gere vitesse max
        d=x*x+y*y
        # on reduit la vitesse a vmax si elle est trop grande
        if (d>vMax*vMax):
            from math import sqrt
            d=sqrt(d)
            x=vMax*x/d
            y=vMax*y/d

        # sauve la commande due a la souris
        self.commande[0]=x
        self.commande[1]=y

    """
    # met a jour l acceleration du fait de l'influence des planetes
    """
    def setAcceleration(self):

        self.ax=0
        self.ay=0
        # pour chaque planete
        for planete in self.planetes:

            # calcul distance entre balle et planete
            direction=[planete[0]-self.x,planete[1]-self.y]
            dcarre=direction[0]*direction[0]+direction[1]*direction[1]
            from math import sqrt
            d=sqrt(dcarre)

            #si la distance est plus petite que le rayon => crash
            if (d<planete[2]):
                self.enVol=False
                return

            # calcul de la force de gravite exercee en 1 / s^2
            direction[0]=direction[0]/(d*d*d)
            direction[1]=direction[1]/(d*d*d)
            #print(direction[0])
            #print(direction[1])

            # ajoute contribution a l'acceleration
            masse=planete[3]
            self.ax+=masse*direction[0]
            self.ay+=masse*direction[1]

    """
    # initiliase balle positionne
    """
    def initialise(self,x,y):
        # n'est pas en vol
        self.enVol=False

        # position initiale
        self.x=x
        self.y=y

    """
    # faire evoluer l'oiseau
    """
    def evoluer(self):
        #l ien vers la souris
        global mouse

        # si est envol => met a jour la position
        if (self.enVol):

            #calcule acceleration en fonction des planetes
            self.setAcceleration()
            self.vx=self.vx+self.ax*self.dt
            self.vy=self.vy+self.ay*self.dt
            self.x=self.x+self.vx*self.dt
            self.y=self.y+self.vy*self.dt

            #met a jour trajectorie faite
            self.traj+=[[self.x,self.y]]

        else:
            #si on est en mode souris, modifie la vitesse
            if(mouse):
                souris=pygame.mouse.get_pos()
                self.setCommande(souris[0]-self.x,souris[1]-self.y)


    """
    # lance l'oiseau avec vitesse initiale commande
    """
    def lancer(self):
        # uniquement s'il n'est pas enVol
        if not(self.enVol):

            vitesse=[0,0]
            # met la vitesse a partir de la commande
            vitesse[0]=-self.commande[0]
            vitesse[1]=-self.commande[1]

            # met la vitesse a partir de la commande
            self.vx=vitesse[0]
            self.vy=vitesse[1]

            # reinitialise commande
            self.commande=[0,0]
            self.traj=[]

            # met envol
            self.enVol=True

    """
    # dessiner oiseau et planetes
    """
    def dessiner(self):
        WHITE = (0xFF, 0xFF, 0xFF)
        RED = (0xFF, 0x00, 0x00)
        BLUE = (0x00, 0x00, 0xFF)
        GREEN = (0x00, 0xFF, 0x00)
        BLACK = (0x00, 0x00, 0x00)
        screen.fill(WHITE)

        #dessine commande
        if (not(self.enVol)):
            #si la commande existe
            if not((self.commande[0]==0)and(self.commande[1]==0)):
                pygame.draw.line(screen,RED,[self.x,self.y],[self.x+self.commande[0],self.y+self.commande[1]],5)

        #dessine balle
        if (not(self.enVol)):
            pygame.draw.ellipse(screen,BLUE,(jeu.x-5,jeu.y-5,10,10))
        else:
            pygame.draw.ellipse(screen,RED,(jeu.x-5,jeu.y-5,10,10))

        # dessine sol
        # pygame.draw.line(screen,BLACK,[0,400],[700,400],5)


        # dessine trajectoire
        for i in range(len(self.traj)-1):
            pygame.draw.line(screen,GREEN,self.traj[i],self.traj[i+1],2)

        # dessine planete
        for planete in self.planetes:

            # si la masse est positive
            if (planete[3]>0):
                couleur=BLACK
            else:
                couleur=BLUE

            # dessin de la planete
            x=planete[0]
            y=planete[1]
            rayon = planete[2]
            pygame.draw.ellipse(screen,couleur,(x-rayon,y-rayon,2*rayon,2*rayon))




import pygame
pygame.init()
size = (700, 500)
screen = pygame.display.set_mode(size)
pygame.display.set_caption("Moteur")


# boolean tant que non fini
done = False
mouse=False
jeu=Jeu()
# gestion horloge
clock = pygame.time.Clock()

# -------- boucle de jeu
while not done:

    # --- gestion evenementss
    for event in pygame.event.get():

        # quitter
        if event.type == pygame.QUIT:
            done = True

        # cliquer souris
        if event.type == pygame.MOUSEBUTTONDOWN:
            # si on clique en vol
            #if (jeu.enVol):
            souris=pygame.mouse.get_pos()
            jeu.initialise(souris[0],souris[1])
            mouse=True

        # lacher souris
        if event.type == pygame.MOUSEBUTTONUP:
            jeu.lancer()
            mouse=False


    # --- evolution jeu
    jeu.evoluer()

    # --- dessin
    jeu.dessiner()


    # --- mise a jour graphique
    pygame.display.flip()
    # --- attente
    clock.tick(60)

pygame.quit()


