##README : meme systeme qu'avant
##
## seule l'initialisation du systeme change (un autre type de structure)

class Ressort():

        # un ressort est defini a partir de deux objets et une elongation
        def __init__(self,a,b,k_elong):
                self.pt_a=a
                self.pt_b=b
                self.k=k_elong
                self.d0=a.distance(b)

	#retourne force exercee sur a
        def forceA(self):
                dis=self.pt_a.distance(self.pt_b)
                f=self.k*(self.d0-dis)
                ax=(self.pt_a.x-self.pt_b.x)*f/dis
                ay=(self.pt_a.y-self.pt_b.y)*f/dis
                return (ax,ay)
                
        #retourne force exercee sur B
        def forceB(self):
                return(-self.forceA)

        def longueur(self):
                return self.pt_a.distance(self.pt_b)

        def metreAJourAcc(self):
                fa=self.forceA()
                #mise a jour force A
                self.pt_a.ax+=fa[0]
                self.pt_a.ay+=fa[1]
                #mise a jour force B
                self.pt_b.ax-=fa[0]
                self.pt_b.ay-=fa[1]
	

# un objet capable d'évoluer
class Objet():

        def __init__(self,dx,dy):
                self.x=dx
                self.y=dy
                self.vx=0
                self.vy=0
                self.ax=0
                self.ay=-9
                self.dt=0.1
                self.trajX=[self.x]
                self.trajY=[self.y]

        

        def accelerer(self,accX,accY):
                self.ax=accX
                self.ay=accY

        def evoluer(self):
                #frottement
                self.ax+=-self.vx*0.5
                self.ay+=-self.vy*0.5

                #mise à jour
                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

                alpha=0.9
                
                if (self.y<0):
                        self.vy=-alpha*self.vy
                        self.y=0
               
        def afficher(self):
                print("(x,y): "+str(self.x)+","+str(self.y)+"  vx,vy: "+str(self.vx)+","+str(self.vy))

        #calcul distance en self et objet o 
        def distance(self,O):
                dx=(O.x-self.x)
                dy=(O.y-self.y)
                d2=dx*dx+dy*dy
                from math import sqrt
                return sqrt(d2)
        


class Systeme():

        # un systeme est des objets et des ressorts
        def __init__(self):
                self.ressorts=[]
                self.objets=[]

        # executer
        def evoluer(self):
                # initialiser a a g
                for objet in self.objets:
                        objet.ax=0
                        objet.ay=-9
                
                # pour chaque ressort
                for ressort in self.ressorts:
                        ressort.metreAJourAcc()

                # mettre à jour objet
                for objet in self.objets:
                        objet.evoluer()

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

                #dessine des objets
                for o in self.objets:
                        coordX=o.x
                        coordY=400-o.y
                        pygame.draw.ellipse(screen,RED,(coordX-5,coordY-5,10,10))
        
                for r in self.ressorts:
                        coordX=r.pt_a.x
                        coordY=400-r.pt_a.y
                        coordX2=r.pt_b.x
                        coordY2=400-r.pt_b.y

                        pygame.draw.line(screen,BLACK,[coordX,coordY],[coordX2,coordY2],2)
                
         
                

        # initialisation
        def initialiser(self, nombre):
                from math import cos, sin,pi
                x0=200
                y0=200
                l=100
                
                #creation des objets
                for i in range(0,nombre):
                        t=(pi*2*i)/nombre
                        x=x0+l*cos(t)
                        y=y0+l*sin(t)
                        o=Objet(x,y)
                        self.objets+=[o]

                #creation des ressorts
                for i in range(0,nombre):
                        o1=self.objets[i]
                        n=i+1
                        if (n>=nombre):
                                n=n-nombre
                        o2=self.objets[n]
                        r=Ressort(o1,o2,2)
                        self.ressorts+=[r]

                #creation des ressorts
                for i in range(0,nombre):
                        o1=self.objets[i]
                        n=i+2
                        if (n>=nombre):
                                n=n-nombre
                        o2=self.objets[n]
                        r=Ressort(o1,o2,2)
                        self.ressorts+=[r]


# -------- creation du systeme
systeme=Systeme()
systeme.initialiser(10)

#---------- pygame

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




#creation des elements
done = False
mousedown=False
mouse=False
sourisX=-1
sourisY=-1


# on creer une horloge pour réguler la vitesse de la boucle de jeu
clock = pygame.time.Clock()

# -------- Boucle principale -----------
# tant que le jeu n'est pas fini
while not done:
         # --- on traite les evenements
        for event in pygame.event.get():
                if event.type == pygame.QUIT:
                        done = True 
        
                #s'il a appuye sur la souris        
                if event.type == pygame.MOUSEBUTTONDOWN:
                        mouse=True
                if event.type == pygame.MOUSEBUTTONUP:
                        mouse=False
                               
                    
        # --- on fait evoluer le jeu
        systeme.evoluer()
        
        # --- on dessine le jeu
        systeme.dessiner()
        
        # on inverse les affichages (double buffering)
        pygame.display.flip()
        # --- on demande d'attendre ce qu'il faut pour un FPS de 60
        clock.tick(60)
# -------- Fin Boucle principale -----------


pygame.quit()