pylint fixes

Issue #8 (pylint problem resolved with this change)

Upgrade system not done, only simplel upgrading added

editor.py

@@ -12,7 +12,7 @@ class Editor():
         self.screen = pg.display.set_mode(WINDOW_SIZE)
         self.clock = pg.time.Clock()
 
-        self.width, self.height = pg.display.get_surface().get_size()       
+        self.width, self.height = pg.display.get_surface().get_size()        
         self.tilemap = Tilemap(self, 16)
         self.display = pg.Surface((WINDOW_SIZE[0] / RENDER_SCALE, WINDOW_SIZE[1] / RENDER_SCALE))
 

game/screens/game_play.py

@@ -34,7 +34,6 @@ class GamePlay(BaseScreen):
         self.center = (self.game_surface.get_width() /2, self.game_surface.get_height() /2)
         self.movment = [False, False, False, False]
         self.selected = None
-        self.notunselect = True
 
         self.map = 'desert'
         self.path = 'assets/maps/' + str(self.map) + '.json'
@@ -72,17 +71,31 @@ class GamePlay(BaseScreen):
             text="Cancel",
             manager=self.game.ui_manager
         )
+        self.upgrade_button = pgi.elements.UIButton(
+            relative_rect=pg.Rect(
+                self.width - 200,
+                self.height -100,
+                150,
+                50
+            ),
+
+            text="Upgrade Tower",
+            manager=self.game.ui_manager
+        )
         self.buy_button.hide()
         self.cancel_button.hide()
+        self.upgrade_button.hide()
         self.bought = False
         self.elements = [
             self.buy_button,
-            self.cancel_button
+            self.cancel_button,
+            self.upgrade_button
         ]
 
         self.mpos = (0, 0)
         self.tile_pos = None
         self.tile_pos_decimal = (0, 0)
+        self.movement_keys = {pg.K_a: 0, pg.K_d: 1, pg.K_w: 2, pg.K_s: 3}
 
     def process_event(self, event):
         """Handle mouse clicks, keyboard input, and UI button presses.
@@ -109,57 +122,46 @@ class GamePlay(BaseScreen):
         else:
             self.tile_pos = None
 
-        if event.type == pgi.UI_BUTTON_PRESSED:
+        self.tile_pos = (int(self.tile_pos_decimal[0]), int(self.tile_pos_decimal[1]))
+        if event.type == pg.MOUSEBUTTONDOWN:
+            if event.button == 1 and self.tile_pos is not None:
+                if game_rect.collidepoint(self.mpos):
+                    # only clear and reselect when clicking inside the game surface
+                    self.clear_selection()
+                    self.selected = self.select_tower(self.tile_pos)
+                    if self.selected is not None:
+                        self.selected.selected = True
+
+                if self.bought and self.game.tilemap.placeable(self.tile_pos):
+                    if not any(tw.tile_pos == self.tile_pos for tw in self.tower_group):
+                        tower = Tower(self.game, self.mpos, self.tile_pos, 'cannon')
+                        self.tower_group.add(tower)
+                        self.bought = False
+
+            elif event.button == 3 and self.tile_pos is not None:
+                for tower in self.tower_group:
+                    if tower.tile_pos == self.tile_pos:
+                        tower.kill()
+
+        elif event.type == pgi.UI_BUTTON_PRESSED:
             if event.ui_element == self.buy_button:
                 self.bought = True
                 # self.tower = Tower(self.game, self.mpos, self.tile_pos, 'cannon')
             if event.ui_element == self.cancel_button:
                 self.bought = False
+            if event.ui_element == self.upgrade_button:
+                if self.selected:
+                    self.selected.upgrade()
 
-        self.tile_pos = (int(self.tile_pos_decimal[0]), int(self.tile_pos_decimal[1]))
-        if event.type == pg.MOUSEBUTTONDOWN:
-            if self.tile_pos is not None:
-                if event.button == 1:
-                    self.selected = self.select_turret(self.tile_pos)
-                    self.clear_selection()
-                    if self.selected is not None:
-                        print(f'selected: {self.selected}')
-                        self.selected.selected = True
-                    print(f'{self.selected}')
-                    if self.bought:
-                        if self.game.tilemap.placeable(self.tile_pos):
-                            if not any(tw.tile_pos == self.tile_pos for tw in self.tower_group):
-                                tower = Tower(self.game, self.mpos, self.tile_pos, 'cannon', 40)
-                                self.tower_group.add(tower)
-                                self.bought = False
-                if event.button == 3:
-                    for tower in self.tower_group:
-                        if tower.tile_pos == self.tile_pos:
-                            tower.kill()
+        elif event.type == pg.KEYDOWN and event.key in self.movement_keys:
+            self.movment[self.movement_keys[event.key]] = True
+        elif event.type == pg.KEYUP and event.key in self.movement_keys:
+            self.movment[self.movement_keys[event.key]] = False
 
-        if event.type == pg.KEYDOWN:
-            if event.key == pg.K_a:
-                self.movment[0] = True
-            if event.key == pg.K_d:
-                self.movment[1] = True
-            if event.key == pg.K_w:
-                self.movment[2] = True
-            if event.key == pg.K_s:
-                self.movment[3] = True
-
-            if event.key == pg.K_q:
-                self.camera.zoom_offset(self.center, -0.25)
-            if event.key == pg.K_e:
-                self.camera.zoom_offset(self.center ,0.25)
-        if event.type == pg.KEYUP:
-            if event.key == pg.K_a:
-                self.movment[0] = False
-            if event.key == pg.K_d:
-                self.movment[1] = False
-            if event.key == pg.K_w:
-                self.movment[2] = False
-            if event.key == pg.K_s:
-                self.movment[3] = False
+        elif event.type == pg.KEYDOWN and event.key == pg.K_q:
+            self.camera.zoom_offset(self.center, -0.25)
+        elif event.type == pg.KEYDOWN and event.key == pg.K_e:
+            self.camera.zoom_offset(self.center, 0.25)
 
     def update(self, dt):
         """Update enemies, towers, and camera position.
@@ -206,7 +208,7 @@ class GamePlay(BaseScreen):
 
         surface.blit(self.game_surface, (0, self.height/6))
 
-    def select_turret(self, tile_pos):
+    def select_tower(self, tile_pos):
         """Return the tower at tile_pos, or ``None`` if the tile is empty.
 
         Args:
@@ -224,25 +226,3 @@ class GamePlay(BaseScreen):
         """Deselect all towers."""
         for tower in self.tower_group:
             tower.selected = False
-
-    #private helpers jsut within class (planned not sure yet)
-    def _remove_tower_at(self, tile_pos):
-        """Remove the tower at tile_pos on right click, if one exists.
-
-        Args:
-            tile_pos (tuple[int, int]): Grid position to remove from.
-        """
-
-    def _handle_keydown(self, key):
-        """Set movement flags and trigger zoom on key press.
-
-        Args:
-            key (int): pygame key constant.
-        """
-
-    def _handle_keyup(self, key):
-        """Clear movement flags on key release.
-
-        Args:
-            key (int): pygame key constant.
-        """

game/tower.py

@@ -2,6 +2,7 @@
 import math
 import pygame as pg
 from game.util import tile_to_pixel
+from game.upgrade_data import UPGRADE_DATA
 
 class Tower(pg.sprite.Sprite):
     # pylint: disable=too-many-instance-attributes
@@ -20,23 +21,25 @@ class Tower(pg.sprite.Sprite):
         pos (tuple): World-space pixel centre position.
         tile_pos (tuple): Grid position the tower occupies.
     """
-    def __init__(self, game, pos, tile_pos, type, range, level=1):
+    def __init__(self, game, pos, tile_pos, tower_type, level=1):
         super().__init__()
         self.game = game
-        self.type = type
-        self.image = self.game.assets[type]
+        self.type = tower_type
+        self.image = self.game.assets[tower_type]
         self.rect = self.image.get_rect()
         self.rect.center = pos
 
-        self.range = range
+        self.level = level
+
+        self.range = UPGRADE_DATA[self.type][self.level]["range"]
+        self.fire_rate = UPGRADE_DATA[self.type][self.level]["fire_rate"]
+        self.damage = UPGRADE_DATA[self.type][self.level]["damage"]
+
         self.selected = False
         self.angle = 0
         self.target = None
 
-        self.fire_rate = 180      # frames between shots — tune to taste
         self.fire_cooldown = 0
-        self.damage = 50
-
         self.pos = pos
         self.tile_pos = tile_pos
         self.level = level
@@ -152,6 +155,19 @@ class Tower(pg.sprite.Sprite):
         self.animation.play_animation()
         self.fire_cooldown = self.fire_rate
 
+    def upgrade(self):
+        """Upgrade the tower by one Level"""
+        print("upgrade")
+        next_level = self.level + 1
+        data = UPGRADE_DATA[self.type]
+        if next_level not in data:
+            return
+
+        self.level = next_level
+        self.damage    = data[next_level]['damage']
+        self.fire_rate = data[next_level]['fire_rate']
+        self.range     = data[next_level]['range']
+
 class TowerGroup(pg.sprite.Group):
     """Sprite group that delegates rendering and updates to each tower."""
 

game/upgrade_data.py

@@ -0,0 +1,9 @@
+"""Upgrade Data module - Stores data for tower upgrades"""
+
+UPGRADE_DATA = {
+    'cannon': {
+        1: {'damage': 30,  'fire_rate': 180, 'range': 40},
+        2: {'damage': 50,  'fire_rate': 140, 'range': 50},
+        3: {'damage': 80, 'fire_rate': 120, 'range': 65},
+    }
+}

main.py

@@ -1,5 +1,6 @@
+"""Starting File"""
 from game.game import Game
-from editor import Editor
+# from editor import Editor
 
 #initialise Game or Editor
 game = Game()
@@ -8,4 +9,4 @@ game = Game()
 
 #run game or editor
 game.run()
-# editor.run()
+# editor.run()