game.py

import pygame as pg
from settings import *
from building import *
from unit import *
import math
from pygame.sprite import Sprite


class Groups:
    """The group class contains all pygame groups."""
    def __init__(self):
        # Draw-Collisions.
        self.all_sprites = pg.sprite.Group()
        self.collision_sprites = pg.sprite.Group()
        self.mouse_group = pg.sprite.Group()
        # Units.
        self.units = pg.sprite.Group()
        self.selected_units = pg.sprite.Group()
        self.enemy_units = pg.sprite.Group()
        self.projectiles = pg.sprite.Group()
        # Ghosts.
        self.ghost_building = pg.sprite.Group()
        self.ghost_plate = pg.sprite.Group()
        self.current_run = pg.sprite.Group()
        # GUIs.
        self.all_buttons = pg.sprite.Group()
        self.panels = []
        # Maps.
        self.map_walls = pg.sprite.Group()
        self.map_iron = pg.sprite.Group()
        self.map_food = pg.sprite.Group()
        # Buildings.
        self.buildings = pg.sprite.Group()
        self.construction = pg.sprite.Group()
        self.cities = pg.sprite.Group()
        self.walls = pg.sprite.Group()
        self.plates = pg.sprite.Group()
        self.towers = pg.sprite.Group()


class Resource:
    """The resource class tracks all resource statistics."""
    def __init__(self, main):
        self.main = main
        # Initialize starting resources.
        self.food = FOOD_START
        self.iron = IRON_START
        self.gold = GOLD_START
        self.creed = CREED_START
        # Initialize starting resource income.
        self.food_income = 0
        self.iron_income = 0
        self.gold_income = 0

    def income(self):
        """Add resources to storage for each resource tick."""
        if self.main.clock.resource_time >= 1:
            # Distribute resources and reset tick.
            self.food += self.food_income
            self.iron += self.iron_income
            self.gold += self.gold_income
            self.main.clock.resource_time = self.main.clock.resource_time - 1
            # Refresh and print statistics.
            print("%s food, %s iron, and %s gold has distributed at %s seconds."
                  % (self.food_income, self.iron_income, self.gold_income, round(self.main.clock.irl_time, 1)))
            self.refresh()

    def deduct(self, cost):
        """Subtract resources based on cost of object constructed."""
        self.food -= cost[0]
        self.iron -= cost[1]
        self.gold -= cost[2]
        self.refresh()

    def is_valid(self, cost):
        """Check if game has minimum resources to construct object."""
        return self.food >= cost[0] and self.iron >= cost[1] and self.gold >= cost[2]

    def refresh(self):
        """Refresh resource income and GUI panels."""
        # Standard update of income.
        if self.main.alive():
            self.food_income = FOOD_INCOME  # TODO: Configure income based on resource nodes captured.
            self.iron_income = IRON_INCOME  # TODO: Configure income based on resource nodes captured.
            self.gold_income = len(self.main.g.cities)
        else:
            self.food_income = 0
            self.iron_income = 0
            self.gold_income = 0
        # If no cities, provide enough income to build one city.
        if self.food < CITY_F and not self.main.alive():
            self.food_income = FOOD_INCOME
        if self.iron < CITY_I and not self.main.alive():
            self.iron_income = IRON_INCOME
        if self.gold < CITY_G and not self.main.alive():
            self.gold_income = GOLD_INCOME
        # Update GUI panels.
        for panel in self.main.g.panels:
            panel.refresh_panel()


class HotKey:  # TODO: Github code cleanup.
    def __init__(self, game):
        self.game = game
        self.hotkey_numbers = ['1', '2', '3', '4', '5', '6', '7', '8', '9']
        self.hotkey_group = {}
        self.new_group()

    def new_group(self):
        """Creates the hotkey groups"""
        for number in self.hotkey_numbers:
            self.hotkey_group[number] = pg.sprite.Group()

    def get(self, num):
        """Gets a specific hotkey group."""
        return self.hotkey_group.get(num)

    def check_events(self, event):
        """Checks to see if we are utilizing hotkeys."""
        if self.game.is_ctrl_pressed and pg.key.name(event.key) in self.hotkey_numbers:
            self.add_unit_hotkey(pg.key.name(event.key))
        elif pg.key.name(event.key) in self.hotkey_numbers:
            self.select_hotkey(pg.key.name(event.key))

    def add_unit_hotkey(self, num):
        """Adds the units into the hotkey group."""
        self.get(num).empty()
        for unit in self.game.g.selected_units:
            if len(self.get(num)) < MAX_HOTKEY_SELECTION:
                pg.sprite.Group.add(self.get(num), unit)
        print(str(self.get(num)))

    def select_hotkey(self, num):
        """Selects the units in the hotkey group."""
        self.game.deselect_units()
        for unit in self.get(num):
            unit.select_button()  # TODO: Debug button knight class missing.


class Runner(Sprite):
    """This class runs from point A to point B and tried to spawn a building every frame of the way."""
    def __init__(self, game):
        pg.sprite.Sprite.__init__(self)
        self.game = game
        # Image Information
        self.image = pg.image.load(RUNNER)
        self.size = self.image.get_rect().size
        self.rect = self.image.get_rect()
        # Movement slope information
        self.start_x = 0
        self.start_y = 0
        self.move_x = 0
        self.move_y = 0
        self.move_slope = 0
        self.move_quadrant = 0
        self.move_counter = 0
        # Spawn plate information
        self.radius = RUNNER_RADIUS
        self.speed = RUNNER_SPEED
        self.buffer = RUNNER_BUFFER
        self.collided_circle = None
        self.collided_ghosts = None
        self.is_running = False

    def run(self, start_x, start_y, move_x, move_y):
        """This makes the runner spawn plates."""
        self.reset_runner(start_x, start_y, move_x, move_y)
        while self.is_running:
            self.set_move_slope()
            self.collision_detection()

    def set_move_slope(self):
        """This calculates the movement slope and what quadrant our sprite is moving towards."""
        # Checks to see if we made it to the move location. Stops within general vicinity (buffer).
        if self.game.arrived_at_location(self):
            self.is_running = False
        self.game.slope_movement_logic(self)

    def collision_detection(self):
        """We spawn a ghost plate any time the runner is not colliding with a ghost plate or ghost wall."""
        self.collided_circle = pg.sprite.spritecollide(self, self.game.g.current_run, False, collided=self.game.circol)\
            + pg.sprite.spritecollide(self, self.game.g.ghost_building, False)
        if not self.collided_circle:
            PlateGhost(self.game, self)

    def reset_runner(self, start_x, start_y, move_x, move_y):
        """We reset the runner back to ghost-wall position and prepare it for multiple wall running"""
        self.is_running = True
        self.start_x = start_x
        self.start_y = start_y
        self.move_x = move_x
        self.move_y = move_y
        self.rect.centerx = start_x
        self.rect.centery = start_y
        self.game.g.current_run.empty()
        self.move_counter = 0