Modifications

Emir/Champs.py

-import pygame as py
-
-#class Champs:
-
-class Champs:
-
-    def __init__(self,coordonnee[]):
-        cooX = coordonnee[0]
-        cooY = coordonnee[1]
-        #taille height
-        #taille width
-        temperature
-        tauxEau
-        TauxInsecte
-        Construction[]
-
-    def image_graphique(self, image):
-        #selectionne l'image à afficher
-
-    def MouseHover(self):
-    #afficher le prix et la hitbox du champs
-
-
-    def debloquer(self):
-    #si le joueur à acheté et a débloquer ou pas
-    
-    
-
-    def plantation(self):
-    #info sur la plante choisi
-        
-    #méthode optionnelle   
-    def menu_des_plantations(self);
-    #menu deroulant ou fenetre qui affiche
-    #les trucs qu'on peut planter
-
-    def getcoordonee(self):
-    #Accesseur
-    
-    def stringAffichage(self):
-    #Affichage de toutes les infos
+import pygame as py
+
+#class Champs:
+
+class Champs:
+
+    def __init__(self,coordonnee[]):
+        cooX = coordonnee[0]
+        cooY = coordonnee[1]
+        #taille height
+        #taille width
+        temperature
+        tauxEau
+        TauxInsecte
+        Construction[]
+
+    def image_graphique(self, image):
+        #selectionne l'image à afficher
+
+    def MouseHover(self):
+    #afficher le prix et la hitbox du champs
+
+
+    def debloquer(self):
+    #si le joueur à acheté et a débloquer ou pas
+    
+    
+
+    def plantation(self):
+    #info sur la plante choisi
+        
+    #méthode optionnelle   
+    def menu_des_plantations(self);
+    #menu deroulant ou fenetre qui affiche
+    #les trucs qu'on peut planter
+
+    def getcoordonee(self):
+    #Accesseur
+    
+    def stringAffichage(self):
+    #Affichage de toutes les infos

Emir/teste pygame.py

-import pygame as pg
-
-
-#tour par tour
-
-tour_fini = false;
-
-def TourParTour(self):
-    while not tour_fini:
-        if(BoutonEstClicker)
-            tour_fini = true;
-            tourParTour(BoutonActiver)
-        elif(BoutonExitClicker):
-            quitter le jeu
-        
-    return tour_fini
-
-continuer = true
-
-#Boucle de jeu
-while not tour_fini : 
-    res = TourParTour(BoolBtnValider)
-    if(res):
-        Tour_score +=1
+import pygame as pg
+
+
+#tour par tour
+
+tour_fini = false;
+
+def TourParTour(self):
+    while not tour_fini:
+        if(BoutonEstClicker)
+            tour_fini = true;
+            tourParTour(BoutonActiver)
+        elif(BoutonExitClicker):
+            quitter le jeu
+        
+    return tour_fini
+
+continuer = true
+
+#Boucle de jeu
+while not tour_fini : 
+    res = TourParTour(BoolBtnValider)
+    if(res):
+        Tour_score +=1

Léo/Champs.py

 import pygame
-
-police = pygame.font.SysFont("Alef", 22) #pygame.font.get_fonts() -> liste des fonts
+import numpy as np
 
 class Champs:
     def __init__ (self, tempature, humidite, tempsAvantMaturation, pos, image):
         self.temperature = tempature
         self.humidite = humidite
         self.TAM = tempsAvantMaturation
-        self.pos = pos
+        self.pos = np.array(pos)
         self.image = image
+        self.imageSize = np.array(self.image.get_size())
         self.rect = pygame.rect.Rect(self.pos, self.image.get_rect().size)
+        self.rectScale = self.rect
+        self.police = pygame.font.SysFont("Alef", 22) #pygame.font.get_fonts() -> liste des fonts
+        self.imgZoom = pygame.transform.scale(self.image, self.imageSize)
+
+    def draw (self, screen, camera):
+        scaleImage = camera.scaleImage(self.image)
 
-    def draw (self, screen):
-        screen.blit(self.image, self.pos)
+        if scaleImage: # != None
+            self.imgZoom = scaleImage
+            self.rectScale = pygame.rect.Rect(camera.convertLocation(self.pos), self.imgZoom.get_size())
+        
+        screen.blit(self.imgZoom, camera.convertLocation(self.pos))
+
+    def changeText (self, camera):
+        scaleText = camera.scaleImage(self.text)
+        if scaleText:
+            self.zoomText = scaleText
 
 class Houblon (Champs):
     def __init__ (self, pos):
         super().__init__(0, 0, 0, pos, pygame.image.load('../assets/champ.png'))
+        self.text = self.police.render("Température : " + str(self.temperature), False, (0,0,0))
+        self.zoomText = self.text
 
-    def showInfo (self, screen):
-        text = police.render("Température : " + str(self.temperature), False, (0,0,0))
+    def showInfo (self, screen, camera):
+        pygame.draw.rect(screen, (255, 255, 255), pygame.rect.Rect(camera.convertLocation(self.pos), np.array(self.rect.size)*0.75*abs(camera.zoom)))
+        self.changeText(camera)
 
-        pygame.draw.rect(screen, (255, 255, 255), pygame.rect.Rect(self.pos, (self.rect.width*0.75, self.rect.height*0.75)))
-        screen.blit(text, self.pos)
+        screen.blit(self.zoomText, camera.convertLocation(self.pos))
 
 class Buisson (Champs):
     def __init__ (self, pos, prix = 10000):
-        super().__init__(0, 0, 0, pos, pygame.image.load('../assets/buisson.png'))
+        super().__init__(0, 0, 0, pos, pygame.image.load('../assets/buissonCadenas.png'))
         self.prix = prix
+        self.text = self.police.render("Champ disponible à l'achat : " + str(self.prix), False, (0,0,0))
+        self.zoomText = self.text
+
+    def showInfo (self, screen, camera):
+        pygame.draw.rect(screen, (255, 255, 255), pygame.rect.Rect(camera.convertLocation(self.pos), np.array(self.rect.size)*0.75*abs(camera.zoom)))
+        self.changeText(camera)
 
-    def showInfo (self, screen):
-        text = police.render("Champ disponible à l'achat : " + str(self.prix), False, (0,0,0))
+        screen.blit(self.zoomText, camera.convertLocation(self.pos))
 
-        pygame.draw.rect(screen, (255, 255, 255), pygame.rect.Rect(self.pos, (self.rect.width*0.75, self.rect.height*0.75)))
-        screen.blit(text, self.pos)
+    def buyField (self):
+        # Clique sur buisson -> Pop up "Êtes-vous certain ?" -> Oui ? -> Supprime le buisson de la liste et ajoute un Houblon aux mêmes coordonnées
+        return Houblon(self.pos)

Léo/Game.py

 import pygame
 from Champs import *
+import numpy as np
 
-police = pygame.font.SysFont("Alef", 30)
+RAYON_MUR_INVISIBLE = 2000
 
 class Game:
     def __init__ (self, screen):
         self.screen = screen
+        self.screenSize = np.array(self.screen.get_size())
         self.score = 0
         self.money = 10000
+        self.displayMoney = 10000
         self.month = "janvier"
-        self.champs = [Houblon((100,100)), Houblon((400,100)), Houblon((700,100)), Houblon((100,300)), Houblon((400,300)), Houblon((700,300)), Houblon((100,500)), Houblon((400,500)), Buisson((700,500))]
+        self.champs = [Houblon((0,0)), Houblon((-200,0)), Houblon((0,-200)), Buisson((400,0)), Buisson((0,400)), Houblon((1000,1000))]#Houblon((100,100)), Houblon((400,100)), Houblon((700,100)), Houblon((100,300)), Houblon((400,300)), Houblon((700,300)), Houblon((100,500)), Houblon((400,500)), Buisson((700,500))]
         self.clock = pygame.time.Clock()
         self.selectedChamp = None
         self.imageMoney = pygame.image.load("../assets/money.png")
-
+        self.imageMoney = pygame.transform.scale(self.imageMoney, np.array(self.imageMoney.get_size())/3)
+        self.police = pygame.font.SysFont("Alef", 30)
+        self.camera = Camera(np.array(self.screen.get_size())/2)
+        self.background = pygame.image.load('../assets/terre.png')
+        self.background = pygame.transform.scale(self.background, (self.screen.get_width(), self.screen.get_height()))
+        self.pluie = pygame.image.load('../assets/pluie.png')
+        self.pluie = pygame.transform.scale(self.pluie, (200,200))
+        self.frame = 0
+        self.buyFrame = -1000
+    
     def gameLoop (self):
         while True:
-            self.screen.fill((0,0,0))
+            self.screen.blit(self.background, (0,0))
+
+            # Météo
+            pygame.draw.rect(self.screen, (127, 127, 127), (0, self.screen.get_height()*0.80, 200, 200))
+            self.screen.blit(self.pluie, (0, self.screen.get_height()*0.80))
 
             isChamp = False
-            #ici il faudra charger les textures du jeu
+            # Affichage des champs
             for champ in self.champs:
-                champ.draw(self.screen)
+                champ.draw(self.screen, self.camera)
+
+            # Affiche les fps
+            fpsText = self.police.render(("%.0f fps" %(self.clock.get_fps())), True, (180,180,180))
+            self.screen.blit(fpsText, (self.screen.get_width() - fpsText.get_width(), 0))
 
             # somme ajoutée ou enlevée au-dessus puis s'ajoute
-            textMoney = police.render(str(self.money), True, (255,255,255))
-            self.screen.blit(textMoney, (0, self.screen.get_height()-textMoney.get_height()*2))
-            self.screen.blit(self.imageMoney, (textMoney.get_width(), self.screen.get_height()-self.imageMoney.get_height()))
 
+            if self.money < self.displayMoney:
+                self.displayMoney -= 100 # Si quelque chose coûte moins que 100, changer par -= min(100, self.displayMoney - self.money)
+            elif self.money > self.displayMoney:
+                self.displayMoney += 100 # Si quelque chose coûte moins que 100, changer par -= min(100, self.money - self.displayMoney)
+
+            textMoney = self.police.render(str(self.displayMoney), True, (255,255,255))
+            self.screen.blit(textMoney, (210, self.screen.get_height()-textMoney.get_height()*2))
+            self.screen.blit(self.imageMoney, (220+textMoney.get_width(), self.screen.get_height()-self.imageMoney.get_height()))
+
+            print(self.clock.get_time())
+            print(self.clock.get_rawtime())
 
             for event in pygame.event.get():
                 if event.type == pygame.QUIT or event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
                     exit()
                 elif event.type == pygame.MOUSEMOTION:
+                    if event.buttons[2] == 1: #maintenir enfoncé clic droit
+                        self.camera.setPosition(np.array(event.rel))
+
                     for champ in self.champs:
-                        if champ.rect.contains(*event.pos,0,0):
+                        if champ.rectScale.contains(event.pos[0],event.pos[1],0,0):
                             self.selectedChamp = champ
                             isChamp = True
                 
                     if not isChamp:
                         self.selectedChamp = None
+                
+                elif event.type == pygame.MOUSEWHEEL:
+                    self.camera.zoomInOut(event.y)
+
+                # Achat d'un champ
+                elif event.type == pygame.MOUSEBUTTONDOWN:
+                    if event.button == 1:
+                        for champ in self.champs:
+                            if isinstance(champ, Buisson):
+                                if champ.rectScale.contains(event.pos[0],event.pos[1],0,0):
+                                    if self.money >= champ.prix:
+                                        self.moneyChange = self.police.render(str(-champ.prix), True, (255,0,0))
+
+                                        self.buyFrame = self.frame
+                                    
+                                        self.champs.append(champ.buyField())
+                                        self.champs.remove(champ)
+                                        self.money -= champ.prix
+                                    else:
+                                        self.moneyError()
+                                    
+
+            if self.frame < self.buyFrame + 100:
+                self.screen.blit(self.moneyChange, (210, self.screen.get_height()-textMoney.get_height()*4-(self.frame-self.buyFrame)*1.25))
 
             if self.selectedChamp:
-                self.selectedChamp.showInfo(self.screen)
-            
+                self.selectedChamp.showInfo(self.screen, self.camera)
+
+            pygame.display.update()
+            self.clock.tick(50)
+            self.frame += 1
+
+    def moneyError (self):
+        loop = True
+        while loop:
+            popUp = pygame.draw.rect(self.screen, (0,0,0), (self.screenSize/3, self.screenSize/3))
+
+            for event in pygame.event.get(pygame.MOUSEBUTTONDOWN):
+                if popUp.contains((*event.pos,0,0)):
+                    loop = False
+                    break
 
             pygame.display.update()
-            self.clock.tick(60)
+            self.clock.tick(50)
+                
+
+class Camera:
+    def __init__ (self, screenMid):
+        self.mid = screenMid
+        self.zoom = 1 # zoom actuel
+        self.lastZoom = 1.1 # dernier zoom
+        self.position = np.array([0,0]) # position du point visé (ici le milieu de l'écran)
+
+    def convertLocation (self, c1:np.array)->np.array: # Convertie les coordonnées de l'écran en coordonnées sur le jeu
+        c2 = (c1 * self.zoom) + self.mid + (self.position * self.zoom)
+        return c2
+
+    def changeScreenLocation (self, c2:np.array)->np.array: # Convertie les coordonnées du jeu en coordonnées de l'écran
+        c1 = (c2 - self.mid - (self.position / self.zoom)) / self.zoom
+        return c1
+
+    def zoomInOut (self, y): # Zoom en fonction de la molette
+        self.lastZoom = self.zoom
+        self.zoom += y*0.1
+
+        self.zoom = np.clip(self.zoom, 0.3, 2) # zoom min max
+
+    def setPosition (self, positionRelative): # Calcule la nouvelle position de l'écran
+        newPos = self.position + positionRelative
+
+        # Pour faire un carré (mur invisible) : 
+        self.position = np.clip(newPos, [-1000, -1000], [1000, 1000])
+
+        # Pour faire un cercle :
+        #if np.linalg.norm(newPos) < RAYON_MUR_INVISIBLE:
+            #self.position = newPos
+
+    def __repr__ (self):
+        return f"Zoom = {self.zoom}\nPosition = {self.position}\n"
+
+    def scaleImage (self, img): # Change le zoom d'une image si nécessaire
+        if self.zoom != self.lastZoom:
+            return pygame.transform.scale(img, np.array(img.get_size())*self.zoom)
+
+        return None
\ No newline at end of file

Léo/T3.py

-import pygame, time
+import pygame
 pygame.init()
 
 from datetime import date
@@ -53,10 +53,5 @@ while inMenu:
         elif event.type == pygame.QUIT or event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
             exit(0)
 
-Game.Game(screen).gameLoop()
-
-#après l'appui de start
-#time.sleep(2)
-#screen.fill((0,0,0))
-#pygame.display.flip()
-#time.sleep(2)
\ No newline at end of file
+# à l'appui du bouton start
+Game.Game(screen).gameLoop()
\ No newline at end of file