added now functional cannon needs projectiles (and alot more)

game/tower.py

@@ -1,5 +1,6 @@
 import pygame as pg
 from game.util import *
+import math
 
 class Tower(pg.sprite.Sprite):
     def __init__(self, game, pos, tile_pos, type, range, level=1):
@@ -12,6 +13,12 @@ class Tower(pg.sprite.Sprite):
 
         self.range = range
         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
@@ -19,8 +26,17 @@ class Tower(pg.sprite.Sprite):
         self.action = ""
         self.set_action('shoot')
 
-    def update(self, enemies):
+    def update(self, enemy_group):
         self.animation.update()
+        self.pick_target(enemy_group)
+        self.rotate()
+
+        if self.fire_cooldown > 0:
+            self.fire_cooldown -= 1
+
+        if self.target is not None and self.fire_cooldown == 0:
+            print("shoot fired")
+            self.shoot()
 
     def set_action(self, action):
         if action != self.action:
@@ -33,15 +49,16 @@ class Tower(pg.sprite.Sprite):
         ))
 
         anim_img = self.animation.img()
+        rotated_img = pg.transform.rotate(anim_img, self.angle)
         scaled_image = pg.transform.scale(
-          anim_img,
+          rotated_img,
             (
-                int(anim_img.get_width() * camera.zoom),
-                int(anim_img.get_height() * camera.zoom)
+                int(rotated_img.get_width() * camera.zoom),
+                int(rotated_img.get_height() * camera.zoom)
             )
         )
 
-        rect = scaled_image.get_rect(center=screen_pos)
+        self.rect = scaled_image.get_rect(center=screen_pos)
 
         if self.selected:
             scaled_range = int(self.range * camera.zoom)
@@ -50,7 +67,40 @@ class Tower(pg.sprite.Sprite):
             range_rect = range_surf.get_rect(center=screen_pos)
             surf.blit(range_surf, range_rect)
 
-        surf.blit(scaled_image, rect)
+        surf.blit(scaled_image, self.rect)
+    
+    def rotate(self):
+        if self.target is None:
+            # print("no target")
+            return  # keep last angle, or reset to a default — your call
+
+        tower_world_pos = pg.Vector2(
+            tile_to_pixel(self.tile_pos, self.game.tilemap.tile_size, True)
+        )
+        direction = self.target.pos - tower_world_pos
+        self.angle = math.degrees(math.atan2(-direction[1], direction[0])) -90
+        # print(f"angle {self.angle}")
+        
+    def pick_target(self, enemy_group):
+        closest = None
+        closest_dist = float('inf')
+
+        tower_world_pos = pg.Vector2(
+            tile_to_pixel(self.tile_pos, self.game.tilemap.tile_size, True)
+        )
+
+        for enemy in enemy_group:
+            distance = tower_world_pos.distance_to(enemy.pos)
+            if distance <= self.range and distance < closest_dist:
+                closest = enemy
+                closest_dist = distance
+
+        self.target = closest  # explicitly None if nothing in range
+    
+    def shoot(self):
+        self.target.take_damage(self.damage)
+        self.animation.play_animation()
+        self.fire_cooldown = self.fire_rate
 
 class TowerGroup(pg.sprite.Group):
     def render(self, surf, camera):