building.py

import pygame as pg
from pygame.sprite import Sprite
from settings import *
from pygame.math import Vector2
from pygame.color import THECOLORS
from unit import *
import math
import random

# Put this into the __init__ to see the effects.
# self.colorkey = self.image.get_at((0, 0)) - this can make the image transparent based on pixel!
# self.image.set_colorkey(self.colorkey)


# =============================================== Ghost Class ================================================== #
class Ghost(Sprite):
    def __init__(self, game):
        # Group information
        # self.groups = game.all_sprites, game.ghosts
        pg.sprite.Sprite.__init__(self)
        self.game = game
        self.cost = []

        # Image information
        self.image_valid = pg.image.load(BLANK_BUILDING)
        self.image_invalid = pg.image.load(BLANK_BUILDING)
        self.image = self.image_valid

        # Location mapping
        self.size = self.image.get_rect().size
        self.rect = self.image.get_rect()
        self.rect.x = pg.mouse.get_pos()[0] - (self.size[0] / 2) - self.game.camera.x
        self.rect.y = pg.mouse.get_pos()[1] - (self.size[1] / 2) - self.game.camera.y
        self.is_valid = True
        self.alpha_surface = None

    def update(self):
        """This fires every single frame."""
        self.update_rect()
        self.check_valid()
        self.child_update()

    def child_init(self, building_valid, building_invalid):
        """Child class initializations."""
        self.game.g.all_sprites.add(self)
        self.image_valid = pg.image.load(building_valid)
        self.image_invalid = pg.image.load(building_invalid)
        self.image = self.image_valid
        self.rect = self.image.get_rect()
        self.size = self.image.get_rect().size
        self.game.is_ghost_building = True

    def update_rect(self):
        """Updates the rect of the image. Makes it transparent."""
        self.rect.x = pg.mouse.get_pos()[0] - (self.size[0] / 2) - self.game.camera.x
        self.rect.y = pg.mouse.get_pos()[1] - (self.size[1] / 2) - self.game.camera.y
        self.image.set_alpha(TRANSPARENCY)

    def delete(self):
        """Deletes self."""
        pg.sprite.spritecollide(self, self.game.g.ghost_building, True)

    def collision_detection(self, any_colliding, city_territory=None, wall_colliding=None):
        """Checks ghost to see if it is valid. If obstacle detected, it's invalid."""
        if (any_colliding or wall_colliding or not city_territory) and self.image == self.image_valid:
            self.image = self.image_invalid
            self.is_valid = False
            self.hide_color_key()
        elif (not any_colliding and city_territory and not wall_colliding) and self.image == self.image_invalid:
            self.image = self.image_valid
            self.is_valid = True

    def construction_calculations(self, building, *proxy_cost):
        self.game.resource.deduct(self.cost)

    def check_valid(self):
        """This is too complicated for the parent class since each child has unique collision requirements."""
        pass

    def child_update(self):
        pass

    def draw_circle(self):
        pass

    def activate_runner(self):
        pass

    def hide_color_key(self):
        pass


class CityGhost(Ghost):
    def __init__(self, game):
        super().__init__(game)
        self.child_init(CITY_VALID, CITY_INVALID)
        self.cost = [CITY_F, CITY_I, CITY_G]

    def construct_building(self):
        if self.is_valid and self.game.resource.is_valid(self.cost):
            self.construction_calculations(Construction(
                self.game, self.rect.x + (self.size[0] / 2) + self.game.camera.x,
                self.rect.y + (self.size[1] / 2) + self.game.camera.y))

    def check_valid(self):
        """Cannot overlap with anything in order for it to build."""
        self.collision_detection(pg.sprite.spritecollide(self, self.game.g.collision_sprites, False), 1)


class WallGhost(Ghost):
    """Finally, it's done. Not yet, it's going to get ugly."""
    def __init__(self, game):
        super().__init__(game)
        self.child_init(WALL_VALID, WALL_INVALID)
        self.cost = [WALL_F, WALL_I, WALL_G]
        self.radius = WALL_MIN_BOOM
        self.collided_circle = []

    def construct_building(self):
        """Needs to also factor in plate cost. Ignore for now."""
        self.cost = [WALL_F, WALL_I, WALL_G]
        if self.game.g.ghost_plate:
            for plate in self.game.g.ghost_plate:
                self.cost[0] += WALL_F
                self.cost[1] += WALL_I
                self.cost[2] += WALL_G
            if self.is_valid and self.game.resource.is_valid(self.cost):
                self.construction_calculations2(WallBuilding(self.game))
                for plate in self.game.g.ghost_plate:
                    plate.spawn_plate()
        else:
            if self.is_valid and self.game.resource.is_valid(self.cost):
                self.construction_calculations2(WallBuilding(self.game))

    def construction_calculations2(self, building, *proxy_cost):
        self.game.resource.deduct(self.cost)

    def check_valid(self):
        """Can overlap the map, other buildings, and itself. Has minimum distance necessary from other walls"""
        # Something about collision with city territory circle. If mouse cursor over city territory, print something

        self.radius = WALL_CIRCLE_RESTRICT
        self.collision_detection(
            pg.sprite.spritecollide(self.game.mouse, self.game.g.collision_sprites, False),
            pg.sprite.spritecollide(self.game.mouse, self.game.g.cities, False, collided=self.game.circol),
            pg.sprite.spritecollide(self, self.game.g.walls, False, collided=self.game.circol))

    def draw_circle(self):
        """Creates circle around ghost wall sprite. Active during debugging."""
        if self.collided_circle:
            pg.draw.circle(self.game.screen, THECOLORS['lightyellow1'],
                           ((self.rect.center[0] + self.game.camera.x), (self.rect.center[1] + self.game.camera.y)),
                           self.radius, 1)

    def child_update(self):
        """This fires every frame. Creates a circle boom and either spawns or deletes plates."""
        if not self.game.is_shift_pressed:
            self.circle_boom()
            if self.collided_circle:
                self.activate_runner()
            if not self.collided_circle:
                self.game.delete_ghost_plates()


    def circle_boom(self):
        """A circle grows in size until it collides with walls. Also has min radius from other walls."""
        self.collided_circle = None
        self.radius = WALL_MIN_BOOM
        while self.radius < WALL_MAX_BOOM:
            if not self.collided_circle:
                self.radius += WALL_ITERATION_BOOM
                self.collided_circle = pg.sprite.spritecollide(
                    self, self.game.g.walls, False, collided=self.game.circol)
            else:
                break

    def activate_runner(self):
        """Tells the runner to spawn ghost plates while running to every wall in our self.collided_circle"""
        self.game.delete_ghost_plates()
        self.game.pass_length = len(self.collided_circle)
        for num, wall in enumerate(self.collided_circle, start=1):
            if self.game.is_alt_pressed and self.game.random_number != num:
                continue
            self.game.runner.run(self.rect.centerx, self.rect.centery, wall.rect.centerx, wall.rect.centery)


class PlateGhost(Ghost):
    def __init__(self, game, runner):
        super().__init__(game)
        self.runner = runner
        self.game.g.ghost_plate.add(self)
        self.game.g.current_run.add(self)
        self.cost = [WALL_F, WALL_I, WALL_G]
        self.colorkey = None
        # Rotation
        self.child_init()
        # Image information
        self.rect = self.image.get_rect()
        self.rect.centerx = self.runner.rect.centerx
        self.rect.centery = self.runner.rect.centery
        self.size = self.image.get_rect().size
        self.image.set_alpha(80)

    def child_init(self, *blank):
        """We calculate rotation, rotate the image, redefine rect, hide black filler, and make transparent."""
        # Check to see if wall is valid first, if that's not valid then plates are not valid.
        for wall in self.game.g.ghost_building:
            self.is_valid = wall.is_valid

        # I split rotating the image it into two statements for better image accuracy placement.
        rotate = math.degrees(math.atan2((self.runner.start_x - self.runner.move_x),
                                         (self.runner.start_y - self.runner.move_y)))
        if -1 <= self.runner.move_slope <= 1:
            if self.is_valid:
                self.image = pg.image.load(PLATE_HORIZONTAL_VALID)
            else:
                self.image = pg.image.load(PLATE_HORIZONTAL_INVALID)
            self.image = pg.transform.rotate(self.image.convert(), rotate - 90)
        else:
            if self.is_valid:
                self.image = pg.image.load(PLATE_VERTICAL_VALID)
            else:
                self.image = pg.image.load(PLATE_VERTICAL_INVALID)
            self.image = pg.transform.rotate(self.image.convert(), rotate)
        # Hides the black-filler from the rotation. If infinite slope, we skip.
        if rotate != 180 and rotate != 0:
            self.colorkey = self.image.get_at((0, 0))
            self.image.set_colorkey(self.colorkey)

    def spawn_plate(self):
        PlateBuilding(self.game, self.image, self.rect, self.size)


class TowerGhost(Ghost):
    def __init__(self, game):
        super().__init__(game)
        self.child_init(TOWER_VALID, TOWER_INVALID)
        self.cost = [TOWER_F, TOWER_I, TOWER_G]
        self.colorkey = self.image.get_at((0, 0))
        self.image.set_colorkey(self.colorkey)

    def construct_building(self):
        if self.is_valid and self.game.resource.is_valid(self.cost):
            self.construction_calculations(TowerBuilding(self.game))

    def check_valid(self):
        """Should be strict. Can overlap the map, other buildings, but not itself."""
        # wtf is this
        collision1 = pg.sprite.spritecollide(self, self.game.g.towers, False)
        collision1 += pg.sprite.spritecollide(self.game.mouse, self.game.g.collision_sprites, False)
        collision1 += pg.sprite.spritecollide(self, self.game.g.map_walls, False)
        self.collision_detection(
            collision1, pg.sprite.spritecollide(self.game.mouse, self.game.g.cities, False, collided=self.game.circol))

    def hide_color_key(self):
        self.colorkey = self.image.get_at((0, 0))
        self.image.set_colorkey(self.colorkey)


class KnightGhost(Ghost):
    def __init__(self, game):
        super().__init__(game)
        self.child_init(KNIGHT_VALID, KNIGHT_INVALID)
        self.cost = [KNIGHT_F, KNIGHT_I, KNIGHT_G]
        self.rect = pg.Rect(1, 1, 1, 1)

    def construct_building(self):
        if self.is_valid and self.game.resource.is_valid(self.cost):
            self.construction_calculations(Knight(self.game))

    def check_valid(self):
        """Should be not strict. Can overlap the map, other buildings, and itself."""
        self.collision_detection(
            pg.sprite.spritecollide(self.game.mouse, self.game.g.collision_sprites, False),
            pg.sprite.spritecollide(self.game.mouse, self.game.g.cities, False, collided=self.game.circol))


# ============================================= Construction Class ================================================ #
class Construction(Sprite):
    """Construction delay for building cities or workshops."""
    def __init__(self, game, x, y):
        # Group information
        self.groups = game.g.all_sprites, game.g.collision_sprites, game.g.construction
        pg.sprite.Sprite.__init__(self, self.groups)
        self.game = game
        self.cost = []
        self.is_built = False
        self.tick = 0
        self.alpha_surface = None

        # Image information
        self.image = pg.image.load(CITY_VALID)
        self.size = self.image.get_rect().size
        self.rect = self.image.get_rect()
        for ghost in self.game.g.ghost_building:
            self.rect.x = ghost.rect.x
            self.rect.y = ghost.rect.y

        self.radius = CITY_MAX_RADIUS
        self.surf1 = pg.Surface((self.radius * 2, self.radius * 2))
        self.surf1.fill(TRANSPARENT)
        self.surf1.set_colorkey(TRANSPARENT)
        self.surf1.set_alpha(TERRITORY_SHADE)
        self.circle_init(x, y)

    def circle_init(self, x, y):
        pg.draw.circle(self.surf1, THECOLORS['lightcyan1'], (
            round((self.rect.center[0] + self.game.camera.x) + self.radius - x),
            round((self.rect.center[1] + self.game.camera.y) + self.radius - y)), self.radius)

    def draw_circle(self):
        self.game.screen.blit(self.surf1, ((self.rect.center[0] + self.game.camera.x) - self.radius,
                                                 (self.rect.center[1] + self.game.camera.y) - self.radius, 50, 50))

    def update(self):
        self.surf1.set_alpha(TERRITORY_SHADE)

        self.build_tick()
        self.build_building()

    def delete(self):
        """Deletes self after construction is complete."""
        pg.sprite.spritecollide(self, self.game.g.construction, True)

    def build_tick(self):
        self.image.set_alpha((self.tick * 75) + 25)
        self.tick += RESOURCE_TICK

    def build_building(self):
        """I am speed building cities"""
        if self.tick > CONSTRUCT_TIME:
            CityBuilding(self.game, self.rect.x, self.rect.y, self.surf1)
            self.game.resource.refresh()
            self.delete()


# =============================================== Building Class ================================================== #
class Building(Sprite):
    def __init__(self, game):
        self.groups = game.g.all_sprites, game.g.collision_sprites, game.g.buildings
        pg.sprite.Sprite.__init__(self, self.groups)
        self.game = game
        self.cost = []
        self.refund_amount = []
        # Image information
        self.image = pg.image.load(BLANK_BUILDING)
        self.size = self.image.get_rect().size
        self.rect = self.image.get_rect()

    def update(self):
        """This fires every single frame."""
        self.child_update()

    def child_inits(self, image, food_cost, iron_cost, gold_cost, food_refund, iron_refund, gold_refund):
        """Fills out the inits for child classes."""
        self.image = pg.image.load(image)
        self.size = self.image.get_rect().size
        self.rect = self.image.get_rect()
        for ghost in self.game.g.ghost_building:
            self.rect.centerx = ghost.rect.centerx
            self.rect.centery = ghost.rect.centery
        self.cost = [food_cost, iron_cost, gold_cost]
        self.refund_amount = [food_refund, iron_refund, gold_refund]
        self.child_inits_specific()

    def delete(self):
        """Deletes self."""
        pg.sprite.spritecollide(self.game.mouse, self.game.g.buildings, True)

    def child_update(self):
        """Specific updates for child classes."""
        pass

    def child_inits_specific(self):
        """Specific inits for child classes."""
        pass

    def refund_resources(self):
        """Refunds resources based on child class."""
        pass


class CityBuilding(Building):
    def __init__(self, game, x, y, surf1):
        super().__init__(game)
        self.child_inits(CITY_VALID, CITY_F, CITY_I, CITY_G, CITY_F_R, CITY_I_R, CITY_G_R)
        pg.sprite.Group.add(self.game.g.cities, self)
        self.radius = CITY_START_RADIUS
        self.surf1 = surf1
        self.rect.x = x
        self.rect.y = y

    def child_update(self):
        if self.radius < CITY_MAX_RADIUS:
            self.radius += 2

    def draw_circle(self):
        pg.draw.circle(self.game.screen, THECOLORS['lightcyan1'],
                       ((self.rect.center[0] + self.game.camera.x), (self.rect.center[1] + self.game.camera.y)),
                       round(self.radius), 3)

    def draw_territory(self):
        self.surf1.set_alpha(25)
        self.game.screen.blit(
            self.surf1, ((self.rect.center[0] + self.game.camera.x) - CITY_MAX_RADIUS,
                         (self.rect.center[1] + self.game.camera.y) - CITY_MAX_RADIUS, 0, 0))


class WallBuilding(Building):
    """Major experimenting. Do walls today."""
    def __init__(self, game):
        super().__init__(game)
        self.child_inits(WALL_VALID, WALL_F, WALL_I, WALL_G, WALL_F_R, WALL_I_R, WALL_G_R)
        pg.sprite.Group.add(self.game.g.walls, self)
        self.radius = 400
        self.collided_circle = None

    def child_update(self):
        """ This lags
        self.collided_circle = pg.sprite.groupcollide(
            self.game.walls, self.game.walls, False, False,
            collided=self.game.circol)
        """

    def radius_draw(self):
        for collided in self.collided_circle:
            pg.draw.circle(
                self.game.screen, THECOLORS['lightcyan1'],
                ((collided.rect.center[0] + self.game.camera.x), (collided.rect.center[1] + self.game.camera.y)),
                collided.radius, 1)


class TowerBuilding(Building):
    def __init__(self, game):
        super().__init__(game)
        self.child_inits(TOWER_VALID, TOWER_F, TOWER_I, TOWER_G, TOWER_F_R, TOWER_I_R, TOWER_G_R)
        pg.sprite.Group.add(self.game.g.towers, self)
        pg.sprite.Group.remove(self.game.g.collision_sprites, self)
        self.colorkey = self.image.get_at((0, 0))
        self.image.set_colorkey(self.colorkey)
        self.radius = TOWER_RADIUS
        self.enemies_in_range = None

    def child_update(self):
        self.shoot_enemies()

    def child_inits_specific(self):
        """Rotate the tower."""
        self.image = pg.transform.rotate(self.image.convert(), 45)
        self.rect.x -= 13
        self.rect.y -= 13
        self.rect.width += 27
        self.rect.height += 27

    def shoot_enemies(self):
        """This shoots bullets at enemy groups."""
        self.enemies_in_range = None
        self.enemies_in_range = pg.sprite.spritecollide(self, self.game.g.enemy_units, False, collided=self.game.circol)
        if self.enemies_in_range:
            for enemy in self.enemies_in_range:
                """We only want to shoot the first enemy"""
                if random.randint(1, TOWER_SHOOT_LIKELIHOOD) == 1:
                    TowerArrow(self.game, self.rect.centerx, self.rect.centery, enemy.rect.centerx, enemy.rect.centery,
                               self.game.g.enemy_units)
                break


class PlateBuilding(Building):
    def __init__(self, game, image, rect, size):
        super().__init__(game)
        pg.sprite.Group.add(self.game.g.plates, self)
        pg.sprite.Group.remove(self.game.g.all_sprites, self)
        self.child_inits(image, WALL_F, WALL_I, WALL_G, WALL_F_R, WALL_I_R, WALL_G_R)
        self.rect = rect
        self.size = size
        self.image.set_alpha(500)

    def child_inits(self, image, food_cost, iron_cost, gold_cost, food_refund, iron_refund, gold_refund):
        """Plates has its own child_inits because it is unqiue from other buildigns."""
        self.image = image
        self.cost = [food_cost, iron_cost, gold_cost]
        self.refund_amount = [food_refund, iron_refund, gold_refund]


class TowerArrow(Sprite):
    """This is an arrow projectile, spawned by tower. It can be used for friendly/foe."""
    def __init__(self, game, start_x, start_y, move_x, move_y, enemy_group):
        self.groups = game.g.all_sprites, game.g.projectiles
        pg.sprite.Sprite.__init__(self, self.groups)
        self.game = game
        # Image Information
        self.image = pg.image.load(TOWER_ARROW)
        self.size = self.image.get_rect().size
        self.rect = self.image.get_rect()
        # Movement slope information.
        self.start_x = start_x
        self.start_y = start_y
        self.rect.x = start_x
        self.rect.y = start_y
        self.move_x = move_x
        self.move_y = move_y
        self.speed = TOWER_ARROW_SPEED
        self.overlap = TOWER_ARROW_EXTRA_OVERLAP
        self.buffer = TOWER_ARROW_SPEED
        self.move_slope = 0
        self.move_quadrant = 0
        self.move_counter = 0
        # Target information
        self.enemy_group = enemy_group

    def update(self):
        """This fires every single frame."""
        self.set_move_slope()
        self.collision_detection()

    def set_move_slope(self):
        """This calculates the movement toward a given target."""
        if self.game.arrived_at_location(self):
            self.overlap_decay()
        self.game.slope_movement_logic(self)

    def collision_detection(self):
        """If colliding with an enemy, deal damage and delete projectile."""
        collision = pg.sprite.spritecollide(self, self.enemy_group, False)
        for obj in collision:
            obj.health -= TOWER_ARROW_DAMAGE/len(collision)
            pg.sprite.spritecollide(self, self.game.g.projectiles, True)
            if obj.health <= 0:
                obj.delete()
            break

    def overlap_decay(self):
        """If projectile misses its target, it flies extra until it decays."""
        self.overlap -= 1
        if self.overlap == 0:
            pg.sprite.spritecollide(self, self.game.g.projectiles, True)
        self.move_x = self.rect.x + (self.move_x - self.start_x)
        self.move_y = self.rect.y + (self.move_y - self.start_y)