import pygame
import random
import math
import time

pygame.init()

WIDTH, HEIGHT = 1200, 800
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Blob Battle: Wrapping Squares")
clock = pygame.time.Clock()
font = pygame.font.SysFont(None, 48)

WHITE = (255, 255, 255)
PLAYER1_COLOR = (100, 200, 255)
PLAYER2_COLOR = (255, 100, 150)

START_SIZE = 20
GROWTH_FACTOR = 0.1
FOOD_COUNT = 400  # Increased food count
MOVING_FOOD_COUNT = 30
BASE_SPEED = 4
WINNING_SIZE = 3000

controls = {
    'player1': {'up': pygame.K_w, 'down': pygame.K_s, 'left': pygame.K_a, 'right': pygame.K_d, 'sprint': pygame.K_e},
    'player2': {'up': pygame.K_UP, 'down': pygame.K_DOWN, 'left': pygame.K_LEFT, 'right': pygame.K_RIGHT, 'sprint': pygame.K_RSHIFT}
}

class Blob:
    def __init__(self, x, y, color, keys):
        self.x = x
        self.y = y
        self.size = START_SIZE
        self.color = color
        self.keys = keys
        self.alive = True

    def move(self, keys_pressed):
        scale = START_SIZE / self.size
        speed = max(1.5, BASE_SPEED * scale ** 0.5)
        if self.keys.get('sprint') and keys_pressed[self.keys['sprint']]:
            speed += max(0.5, 2 * scale)
            if self.size > 10:
                self.size -= 0.015  # Increased size loss when sprinting

        if self.size > 50:
            speed -= self.size / 1000  # The bigger you are, the slower you move

        if keys_pressed[self.keys['up']]: self.y -= speed
        if keys_pressed[self.keys['down']]: self.y += speed
        if keys_pressed[self.keys['left']]: self.x -= speed
        if keys_pressed[self.keys['right']]: self.x += speed

        if self.x < -self.size:
            self.x = WIDTH + self.size
            self.y = HEIGHT - self.y
        elif self.x > WIDTH + self.size:
            self.x = -self.size
            self.y = HEIGHT - self.y
        if self.y < -self.size:
            self.y = HEIGHT + self.size
            self.x = WIDTH - self.x
        elif self.y > HEIGHT + self.size:
            self.y = -self.size
            self.x = WIDTH - self.x

    def grow(self, amount):
        self.size += amount * GROWTH_FACTOR

    def draw(self, surface):
        rect = pygame.Rect(int(self.x - self.size / 2), int(self.y - self.size / 2), self.size, self.size)
        pygame.draw.rect(surface, self.color, rect)
        outline_rect = pygame.Rect(int(self.x - self.size / 2) + 2, int(self.y - self.size / 2) + 2, self.size - 4, self.size - 4)
        pygame.draw.rect(surface, WHITE, outline_rect)

    def can_eat(self, other):
        if self.size > other.size * 1.3:
            self_rect = pygame.Rect(self.x - self.size / 2, self.y - self.size / 2, self.size, self.size)
            other_rect = pygame.Rect(other.x - other.size / 2, other.y - other.size / 2, other.size, other.size)
            return self_rect.colliderect(other_rect)
        return False

class Food:
    def __init__(self):
        self.size = random.randint(5, 12)  # Increased size range
        self.x = random.randint(self.size, WIDTH - self.size)
        self.y = random.randint(self.size, HEIGHT - self.size)
        self.color = (255, 255, 255)

    def draw(self, surface):
        rect = pygame.Rect(int(self.x - self.size / 2), int(self.y - self.size / 2), self.size, self.size)
        pygame.draw.rect(surface, self.color, rect)

class MovingFood:
    def __init__(self):
        self.size = random.randint(8, 16)
        self.x = random.randint(self.size, WIDTH - self.size)
        self.y = random.randint(self.size, HEIGHT - self.size)
        angle = random.uniform(0, 2 * math.pi)
        speed = random.uniform(0.3, 1.5)
        self.vx = math.cos(angle) * speed
        self.vy = math.sin(angle) * speed
        self.color = (random.randint(100, 255), random.randint(100, 255), random.randint(100, 255))
        self.is_boss = random.random() < 0.1  # 10% chance of being the larger moving food

    def move(self):
        self.x += self.vx
        self.y += self.vy

        if self.x < -self.size:
            self.x = WIDTH + self.size
            self.y = HEIGHT - self.y
        elif self.x > WIDTH + self.size:
            self.x = -self.size
            self.y = HEIGHT - self.y
        if self.y < -self.size:
            self.y = HEIGHT + self.size
            self.x = WIDTH - self.x
        elif self.y > HEIGHT + self.size:
            self.y = -self.size
            self.x = WIDTH - self.x

    def grow(self, amount):
        self.size += amount * GROWTH_FACTOR

    def draw(self, surface):
        rect = pygame.Rect(int(self.x - self.size / 2), int(self.y - self.size / 2), int(self.size), int(self.size))
        pygame.draw.rect(surface, self.color, rect)

    def can_eat(self, other):
        if self.size > other.size * 1.3:
            self_rect = pygame.Rect(self.x - self.size / 2, self.y - self.size / 2, self.size, self.size)
            other_rect = pygame.Rect(other.x - other.size / 2, other.y - other.size / 2, other.size, other.size)
            return self_rect.colliderect(other_rect)
        return False

def respawn(blob, x, y):
    blob.x = x
    blob.y = y
    blob.size = START_SIZE
    blob.alive = True

player1 = Blob(100, 100, PLAYER1_COLOR, controls['player1'])
player2 = Blob(700, 500, PLAYER2_COLOR, controls['player2'])
players = [player1, player2]

foods = [Food() for _ in range(FOOD_COUNT)]
moving_foods = [MovingFood() for _ in range(MOVING_FOOD_COUNT)]

score_player1 = 0
score_player2 = 0
series_player1 = 0
series_player2 = 0

running = True
game_in_progress = False
countdown_time = 3
countdown_start_time = 0

while running:
    screen.fill((30, 30, 40))
    keys = pygame.key.get_pressed()

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    if not game_in_progress:
        if countdown_start_time == 0:
            countdown_start_time = time.time()
        countdown_elapsed = time.time() - countdown_start_time

        if countdown_elapsed < 1:
            countdown_text = font.render("3", True, WHITE)
        elif countdown_elapsed < 2:
            countdown_text = font.render("2", True, WHITE)
        elif countdown_elapsed < 3:
            countdown_text = font.render("1", True, WHITE)
        elif countdown_elapsed < 4:
            countdown_text = font.render("Go!", True, WHITE)
        else:
            game_in_progress = True
            countdown_start_time = 0
            countdown_text = None

        if countdown_text:
            countdown_rect = countdown_text.get_rect(center=(WIDTH // 2, HEIGHT // 2))
            screen.blit(countdown_text, countdown_rect)

    if game_in_progress:
        for mf in moving_foods:
            mf.move()
            for food in foods[:]:
                if mf.can_eat(food):
                    mf.grow(food.size)
                    foods.remove(food)
                    foods.append(Food())

        for player in players:
            if not player.alive:
                respawn(player, random.randint(100, WIDTH - 100), random.randint(100, HEIGHT - 100))

            player.move(keys)

            for food in foods[:]:
                if player.can_eat(food):
                    player.grow(food.size)
                    foods.remove(food)
                    foods.append(Food())

            for mf in moving_foods[:]:
                if player.can_eat(mf):
                    player.grow(mf.size)
                    moving_foods.remove(mf)
                    moving_foods.append(MovingFood())

        if player1.can_eat(player2) and player2.alive:
            player1.grow(player2.size)
            player1.size *= 0.95  # Reduced size loss when eating player
            player2.alive = False

        elif player2.can_eat(player1) and player1.alive:
            player2.grow(player1.size)
            player2.size *= 0.95  # Reduced size loss when eating player
            player1.alive = False

        for mf in moving_foods:
            if mf.is_boss and mf.can_eat(player1) and player1.alive:
                player1.alive = False
            if mf.is_boss and mf.can_eat(player2) and player2.alive:
                player2.alive = False

        if player1.size >= WINNING_SIZE:
            score_player1 += 1
            game_in_progress = False

        elif player2.size >= WINNING_SIZE:
            score_player2 += 1
            game_in_progress = False

        if score_player1 == 2:
            series_player1 += 1
            score_player1 = 0
            score_player2 = 0
        elif score_player2 == 2:
            series_player2 += 1
            score_player1 = 0
            score_player2 = 0

        for food in foods:
            food.draw(screen)
        for mf in moving_foods:
            mf.draw(screen)
        for player in players:
            if player.alive:
                player.draw(screen)

        score_text = font.render(f"{score_player1}-{score_player2}", True, WHITE)
        screen.blit(score_text, (WIDTH // 2 - score_text.get_width() // 2, 20))

        size_text1 = font.render(f"Size: {int(player1.size)}", True, PLAYER1_COLOR)
        size_text2 = font.render(f"Size: {int(player2.size)}", True, PLAYER2_COLOR)
        screen.blit(size_text1, (20, 20))
        screen.blit(size_text2, (WIDTH - size_text2.get_width() - 20, 20))

        if series_player1 == 1:
            win_text = font.render("Player 1 Wins the Game!", True, WHITE)
            screen.blit(win_text, win_text.get_rect(center=(WIDTH // 2, HEIGHT // 2)))
        elif series_player2 == 1:
            win_text = font.render("Player 2 Wins the Game!", True, WHITE)
            screen.blit(win_text, win_text.get_rect(center=(WIDTH // 2, HEIGHT // 2)))

    pygame.display.flip()
    clock.tick(60)

pygame.quit()