import pygame
import sys
pygame.init()

CLOCK = pygame.time.Clock()
SCREEN = pygame.display.set_mode((1000, 800))
BLACK = (0,0,0)
BACKGROUND = pygame.image.load("images/back.png")

G_X, G_Y = 100, 800
G_GRAVITY = 1
G_JUMP_HEIGHT = 20
g_y_velocity = 20
g_jumping = False
g_facing_right = True

K_X, K_Y = 300, 700
K_GRAVITY = 1
K_JUMP_HEIGHT = 20
k_y_velocity = 20
k_jumping = False
k_facing_right = True

def get_image(sheet,frame_w, frame_h, width, height, scale, color):
    image = pygame.Surface((width, height)).convert_alpha()
    image.blit(sheet, (0,0),((frame_w*width),(frame_h*height), width, height))
    image = pygame.transform.scale(image, (width*scale, height*scale)).convert_alpha()
    if color is not None:
        image.set_colorkey(color)
    return image

# GOBLIN
goblin = pygame.image.load("images/GoblinWorker/GoblinWorker.png").convert_alpha()
STANDING_SURFACE = get_image(goblin, 1, 1, 48, 48, 3, BLACK)

frame_0 = get_image(goblin, 0,0, 48, 48, 3, BLACK)
frame_1 = get_image(goblin, 4,2 , 48, 48, 3, BLACK)
walk_a = get_image(goblin, 5, 1, 48, 48, 3, BLACK)
walk_b = get_image(goblin, 0, 2, 48, 48, 3, BLACK)

# KNIGHT
knight = pygame.image.load("images/sprites/knight.png").convert_alpha()
K_STAND = get_image(knight, 2, 0, 32, 32, 3, BLACK)
k_walk_a = get_image(knight, 1, 2, 32, 32, 3, BLACK)
k_walk_b = get_image(knight, 5, 2, 32, 32, 3, BLACK)


k_jump_start = get_image(knight, 3, 5, 32, 32, 3, BLACK)
k_jump_apex  = get_image(knight, 4, 5, 32, 32, 3, BLACK)
k_jump_fall  = get_image(knight, 5, 5, 32, 32, 3, BLACK)

# SPRITES / WORLD
door_image = pygame.image.load("images/door.png")
door_rect = door_image.get_rect(center = (800, 700))
wall_image = pygame.image.load("images/wall.png")
wall_right = pygame.Rect(1000, 0, 1, 800)
wall_left = pygame.Rect(0, 0, 1, 800)
wall_bottom = pygame.Rect(0, 800, 1000, 1)
wall_up = pygame.Rect(0, 0, 1000, 1)

#PLATFORM
platform_image = pygame.image.load("images/sprites/platforms.png")
platform = get_image(platform_image, 0, 0, 16, 9, 3, BLACK)
platform_rect = platform.get_rect(topleft=(400, 700))

# ANIMATION
g_anim_counter = 0
k_anim_counter = 0
ANIM_SPEED = 8

# GAME LOOP
while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            sys.exit()

    keys_pressed = pygame.key.get_pressed()
    
    prev_G_Y = G_Y
    prev_K_Y = K_Y

    g_moving = False
    if keys_pressed[pygame.K_d]:
        G_X += 5
        g_facing_right = True
        g_moving = True
    if keys_pressed[pygame.K_a]:
        G_X -= 5
        g_facing_right = False
        g_moving = True
    if keys_pressed[pygame.K_SPACE] and not g_jumping:
        g_jumping = True
        g_y_velocity = G_JUMP_HEIGHT


    k_moving = False
    if keys_pressed[pygame.K_KP6]:
        K_X += 5
        k_facing_right = True
        k_moving = True
    if keys_pressed[pygame.K_KP4]:
        K_X -= 5
        k_facing_right = False
        k_moving = True
    if keys_pressed[pygame.K_KP8] and not k_jumping:
        k_jumping = True
        k_y_velocity = K_JUMP_HEIGHT


    SCREEN.blit(wall_image, wall_right)
    SCREEN.blit(wall_image, wall_left)
    SCREEN.blit(wall_image, wall_up)
    SCREEN.blit(wall_image, wall_bottom)
    SCREEN.blit(BACKGROUND, (0, 0))
    SCREEN.blit(door_image, door_rect)
    SCREEN.blit(platform, platform_rect)
    
    if g_jumping:
        G_Y -= g_y_velocity
        g_y_velocity -= G_GRAVITY
        if g_y_velocity < -G_JUMP_HEIGHT:
            g_jumping = False
            g_y_velocity = G_JUMP_HEIGHT

    if k_jumping:
        K_Y -= k_y_velocity
        k_y_velocity -= K_GRAVITY
        if k_y_velocity < -K_JUMP_HEIGHT:
            k_jumping = False
            k_y_velocity = K_JUMP_HEIGHT

    g_anim_counter = g_anim_counter + 1 if g_moving else 0
    k_anim_counter = k_anim_counter + 1 if k_moving else 0

    if g_jumping:
        g_surface = frame_1
    elif g_moving:
        g_frame_index = (g_anim_counter // ANIM_SPEED) % 2
        g_surface = walk_a if g_frame_index == 0 else walk_b
    else:
        g_surface = STANDING_SURFACE

    if not g_facing_right:
        g_surface = pygame.transform.flip(g_surface, True, False).convert_alpha()

    g_rect = g_surface.get_rect(center=(G_X, G_Y))


    if k_jumping:
        up_thresh = K_JUMP_HEIGHT // 3
        down_thresh = -up_thresh
        if k_y_velocity > up_thresh:
            k_surface = k_jump_start
        elif k_y_velocity > down_thresh:
            k_surface = k_jump_apex
        else:
            k_surface = k_jump_fall
    elif k_moving:
        k_frame_index = (k_anim_counter // ANIM_SPEED) % 2
        k_surface = k_walk_a if k_frame_index == 0 else k_walk_b
    else:
        k_surface = K_STAND

    if not k_facing_right:
        k_surface = pygame.transform.flip(k_surface, True, False).convert_alpha()

    k_rect = k_surface.get_rect(center=(K_X, K_Y))

    
    if g_rect.colliderect(wall_right):
        G_X -= 5
    if g_rect.colliderect(wall_left):
        G_X += 5
    if g_rect.colliderect(wall_bottom):
        G_Y -= 5
    if g_rect.colliderect(wall_up):
        G_Y += 5

    if k_rect.colliderect(wall_right):
        K_X -= 5
    if k_rect.colliderect(wall_left):
        K_X += 5

    # Goblin
    if g_rect.colliderect(platform_rect):
        if g_y_velocity < 0:
            G_Y = platform_rect.top - (g_rect.height / 2)
            g_jumping = False
            g_y_velocity = 0
        else:
            G_Y = platform_rect.bottom + (g_rect.height / 2)
            g_y_velocity = 0
    else:
        pass

    # Knight
    if k_rect.colliderect(platform_rect):
        if k_y_velocity < 0:
            K_Y = platform_rect.top - (k_rect.height / 2)
            k_jumping = False
            k_y_velocity = 0
        else:
            K_Y = platform_rect.bottom + (k_rect.height / 2)
            k_y_velocity = 0
    else:
        pass
    SCREEN.blit(g_surface, g_rect)
    SCREEN.blit(k_surface, k_rect)

    if g_rect.colliderect(door_rect) and keys_pressed[pygame.K_e]:
        print("Goblin wins!")
        pygame.quit()
        sys.exit()
    if k_rect.colliderect(door_rect) and keys_pressed[pygame.K_KP5]:
        print("Knight wins!") 
        pygame.quit()
        sys.exit()

    pygame.display.update()
    CLOCK.tick(60)