Planetes

# coding: utf8 

from objCelest import ObjCelest, newOC
import numpy as np
from math import *
import pygame
from pygame.locals import *
from random import *

pygame.init()
pygame.display.set_caption("L'art de tourner autour du problème...", "Spine Runtine")
myfont = pygame.font.SysFont("monospace", 15)
fontPause = pygame.font.SysFont("monospace", 30)
winw = 700              # windows width
winh = 700              # windows height
bg = (0,0,0)            # background
myclock = pygame.time.Clock()
fpsLim = 50
userDone = False
UnitPxRange = range(10,1000,1)
UnitPx=float(UnitPxRange[190])
bouge=False

# ======= fonctions
def afficheAide():
   aide=True
   ligne = []
   ligne.append("========== Guide des boutons ===========")
   ligne.append("a : efface toutes les planetes")
   ligne.append("p : met le jeu en pause")
   ligne.append("h : affiche cet aide")
   ligne.append("Echap : quitte le jeu")
   ligne.append("")
   ligne.append("~~~~~~ Gestion de la sourie ~~~~~~")
   ligne.append("Bouton gauche : créer une planète.")
   ligne.append("     Maintenez enfoncé pour une vitesse initiale.")
   ligne.append("     Relachez ou cliquez sur un autre bouton")
   ligne.append("     de la sourie pour l'envoyer")
   ligne.append("Bouton droit : déplace l'écran.")
   ligne.append("     Maintenez enfoncé, déplacez et relachez le bouton.")
   ligne.append("Roulette : zoom")
   ligne.append("")
   ligne.append("Appuyez sur 'p' ou 'echap' pour revenir au jeu.")
   pygame.draw.rect(caneva, (0,0,0), (int(winw/5), 100, 500, len(ligne)*15))
   for i,text in enumerate(ligne):
       text = myfont.render( text, 1 , (0,0,255))
       caneva.blit(text, (int(winw/5), int(100+i*15)))
   pauseFonction(True)

def coord2px(pos, UnitPx, winw, winh):
   """ tranforme les coordonees en px """
   xPx = int(pos[0]*UnitPx + int(winw/2))
   yPx = int(-pos[1]*UnitPx + int(winh/2))

   return np.array([xPx, yPx])

def px2coord(Px, UnitPx, winw, winh):
   """ transforme les px en coordonees """
   posx = float(Px[0] - winw/2)/UnitPx
   posy = -float(Px[1] - winh/2)/UnitPx

   return np.array([posx, posy])

def affichage(listOC, UnitPx, winw, winh, caneva):
   """ affiche les planetes et du texte"""
   for oc in listOC:
       [xPx, yPx] = coord2px(oc.pos, UnitPx, winw, winh)
       color = oc.color
       r = int(oc.r*UnitPx)
       pygame.draw.circle(caneva, color , [xPx, yPx], r, 0)
   # render text
   label = myfont.render("Il y a %d planete(s)" % len(listOC), 1, (0,0,255))
   label2 = myfont.render("Echelle : 1 = %d px" % UnitPx, 1, (0,0,255))
   caneva.blit(label, (10, 10))
   caneva.blit(label2, (10,30))

def drag(listOC, move):
   for oc in listOC:
       oc.pos += move
       oc.posOld += move

def pauseFonction(pause):
   pausetext = fontPause.render("Pause", 1, (255,255,0))
   caneva.blit(pausetext, (winw/2-50, winh/2))
   pygame.display.flip()
   userDone = False
   while pause:
       for event in pygame.event.get():
           if (event.type == pygame.KEYDOWN and event.key == K_p):
               pause = False
           elif (event.type == pygame.QUIT or (event.type == pygame.KEYDOWN and event.key == K_ESCAPE)):
               pause = False
               userDone = True
               pygame.time.wait(10)
   return userDone

# ===== Initialise la fenetre =======================================
caneva = pygame.display.set_mode((winw,winh))
caneva.fill(bg)

# ===== Initialise les planetes =====================================
listOC = [] # Contient la liste des objets celestes
# listOC(masse, vitesse, position)
listOC.append(ObjCelest(1.0,  [0.,0.],  [0.,0]))
listOC.append(ObjCelest(0.01, [0,0.8],    [-1.5,0]))
listOC.append(ObjCelest(0.001, [0,1.175],    [-1.6,0]))
new = newOC(0, np.array([0.,0.]), np.array([0.,0.]), 0) # contient la planète en formation lors d'un clic


# ===== affiche l'aide ==============================================
afficheAide()
# ===== Et c'est partie !!! =========================================
# pas de temps
dt = 1e-2

# Premier pas de temps
for oc in listOC:
   oc.vitesse4pos(oc.v,dt)

while not userDone:

   myclock.tick(fpsLim)

   # Quel bouton de la sourie est appuye
   if (pygame.mouse.get_pressed()[0]): # bouton gauche
       # Bouton gauche, ajout d'une planete
       # On stock temporairement sa vitesse (utilisateur), jusqu'a ce que le bouton soit relache
       [posxtmp, posytmp] = px2coord(pygame.mouse.get_pos(), UnitPx, winw, winh)
       vx = (posxtmp - posxNew) * 1
       vy = (posytmp - posyNew) * 1
       mass = pi * (10/UnitPx)**2
       new = newOC(mass, [vx, vy], [posxNew, posyNew], 1)
   elif pygame.mouse.get_pressed()[2]: # bouton droit
       # On stock temporairement jusqu'ou on veut se deplacer, jusqu'a ce que le bouton soit relache
       [posxBougetmp, posyBougetmp] = px2coord(pygame.mouse.get_pos(), UnitPx, winw, winh)
       bouge = 1 # booleen pour le deplacement

   # ===== gestion des evenements
   for event in pygame.event.get():

       if (event.type == pygame.QUIT):
           userDone = True
       elif (event.type == pygame.KEYDOWN):
           if (event.key == K_ESCAPE):
               userDone = True
           elif (event.key == K_h):
               afficheAide()
           elif (event.key == K_a):
               # supprime les objets celestes
               del listOC
               listOC=[]
           elif (event.key == K_p):
               # ===== mise en pause
               pause = True
               userDone = pauseFonction(pause)

       if (event.type == pygame.MOUSEBUTTONDOWN):
           if event.button == 1:
               # Ajout d'une planete, on note les coordonees du clic
               [posxNew, posyNew] = px2coord(event.pos, UnitPx, winw, winh)
           elif event.button == 3:
               # On bouge l'ecran, on note les coordonees du clic
               [posxBouge, posyBouge] = px2coord(event.pos, UnitPx, winw, winh)
           elif event.button == 4 and UnitPx < len(UnitPxRange): # zoom in
               UnitPx = float(UnitPxRange[int(UnitPx)])
           elif event.button == 5 and UnitPx > 10: # zoom out
               UnitPx = float(UnitPxRange[int(UnitPx)-20])
       elif (event.type == pygame.MOUSEBUTTONUP and new.ok): # on relache un bouton donc on creer une planete
           # ajout de la planete
           listOC.append(ObjCelest(new.m, new.v, [posxNew, posyNew]))
           # calcul de sa vitesse et de son premier deplacement
           oc = listOC[-1]
           oc.vitesse4pos(oc.v, dt)
           new = newOC(0, np.array([0.,0.]), np.array([0.,0.]), 0) # remise a zero
       elif (event.type == pygame.MOUSEBUTTONUP and bouge):
           # on bouge (deplace l'ecran)
           movex = posxBougetmp - posxBouge
           movey = posyBougetmp - posyBouge
           drag(listOC, np.array([movex, movey]))
           bouge = False

   # ===== Gestion des collisions ==================================
   # Ne gere qu'une collision par loop
   # sinon risque de supprimer une planetes qui est dans 2 collisions
   # et error not found...
   for oc in listOC:
       collision = oc.collision(listOC)
       if collision != []:
           msum = collision[0].mass + collision[1].mass
           #V0 = (collision[0].pos-collision[0].posOld)/dt
           #V1 = (collision[1].pos-collision[1].posOld)/dt
           #Vf = (collision[0].mass*V0 + collision[1].mass*V1)/(msum)
           #print(Vf)
           if collision[0].mass>collision[1].mass:
               collision[0].mass=msum
               collision[0].r=sqrt(msum/pi)
               listOC.remove(collision[1])
           else:
               collision[1].mass=msum
               collision[1].r=sqrt(msum/pi)
               listOC.remove(collision[0])
           break # on ne gère qu'une collision par loop, donc on s'arrete la.

   # ===== Deplacement =============================================
   for oc in listOC:
       oc.acceleration(listOC)

   for oc in listOC:
       # x(n+1)=2x(n)-x(n-1)-a(n)*dt^2
       oc.posNplusUn = 2*oc.pos - oc.posOld + oc.a * dt**2
       oc.posOld = oc.pos
       oc.pos = oc.posNplusUn

   # ===== Affichage ===============================================
   caneva.fill(bg)
   affichage(listOC, UnitPx, winw, winh, caneva )
   
   if new.ok: # tracer de la planete en cours d'initialisation
       [posxtmpPx, posytmpPx] = coord2px([posxtmp, posytmp], UnitPx, winw, winh)
       [posxNewPx, posyNewPx] = coord2px([posxNew, posyNew], UnitPx, winw, winh)
       pygame.draw.line(caneva, (255,0,255) , [posxNewPx, posyNewPx], [posxtmpPx, posytmpPx], 1)
       pygame.draw.circle(caneva, (255,0,255), [posxNewPx, posyNewPx], int(10), 1)
   
   pygame.display.flip()

# coding: utf8 

import numpy as np
from math import *
from random import *

class ObjCelest:
   """Definit la class pour tous les objets celestes"""
   nbObjCelest=0
   
   listofcolor=[]
   for i in range(50,250,10):
       for j in range(40,250,10):
           for k in range(50,250,10):
               listofcolor.append((i,j,k))

   def __init__(self, m, v, pos):
       """Initialise les caracteristiques de l'objet celeste
       ID, couleur, masse, rayon, vitesse, acceleration et position.
       Le rayon est déterminer par masse = pi * r**2
       L'acceleration est mise à jour ensuite
       posOld est la position l'instant d'avant"""
       self.r = sqrt(m/pi)
       self.mass = m
       self.v = np.array(v)
       self.a = np.array([0.,0.])
       self.pos = np.array(pos)
       self.posOld = np.array(pos)
       self.ID = ObjCelest.nbObjCelest
       self.color = choice(ObjCelest.listofcolor)
       ObjCelest.nbObjCelest += 1

   def distance(self, obj):
       """ Retourne la distance entre lui est un autre objet"""
       D = sqrt( (self.pos[0]-obj.pos[0])**2 + (self.pos[1]-obj.pos[1])**2)
       return D
   def vitesse4pos(self, v, dt):
       """Mise à jour de la position de l'objet grace à sa vitesse """
       self.pos += v*dt

   def acceleration(self, listOC):
       """Renvoi l'acceleration de l'objet "self" due aux autres objet celestes" """
       self.a = np.array([0.,0.])
       for obj in listOC:
           if obj.ID != self.ID:
               D = self.distance(obj)
               ax =  obj.mass * (obj.pos[0]-self.pos[0]) / D**3
               ay =  obj.mass * (obj.pos[1]-self.pos[1]) / D**3
               self.a += np.array([ax, ay])

   def collision(self, listOC):
       """Détermine si l'objet rentre en collision avec un autre """
       collision=[]
       for oc in listOC:
           if oc.ID != self.ID:
               D = self.distance(oc)
               if (D < self.r + oc.r):
                   collision.append(self)
                   collision.append(oc)
                   return collision
       return collision

class newOC():
   """ nouvel objet celeste en formation """
   def __init__(self, m, v, pos, okornot):
       """ on lui donne une masse, vitesse et position.
       okornot (booleen) permet de le placer ou non sur l'ecran et donc de le prendre en consideration """
       self.m = m
       self.v = v
       self.pos = pos
       self.ok = okornot