KGF logo pygame

import math
import time
from functools import lru_cache
import random

import pygame

import pygame.gfxdraw

draw_circle = pygame.draw.circle

pygame.init()
pygame.key.set_repeat(500, 100)

W, H = (900,) * 2
FPS = 60

SPEED = 5

FONT_SIZE = 350
TEXT = 'K.G.F'
# TEXT = '100-made/50-in/50-pygame'
TRAIL_LENGTH = 50
TRAIL_SPEED = 4
LINE_THICKNESS = 3
START_SCALE = 1.5 * 4
END_SCALE = 1
SCALE_TRANSITION = 10
PARTICLES_PER_FLAME = 5

window = pygame.display.set_mode((W, H), pygame.NOFRAME)
screen = pygame.Surface((W, H))
clock = pygame.time.Clock()

# font = pygame.font.Font('font.otf', FONT_SIZE)
_color = (80, 20, 10)


def get_surf(_text):
    s = pygame.Surface((W, H), pygame.SRCALPHA)
    y = 0
    for i in _text.split('/'):
        try:
            k = int(i.split('-')[0])
            font = pygame.font.Font('font.otf', k)
            surf = font.render(i.split('-')[1], True, 'white')
        except ValueError:
            font = pygame.font.Font('font.otf', FONT_SIZE)
            surf = font.render(i, True, 'white')
        # pygame.draw.rect(surf, 'white', (0, 0, *surf.get_size()), 5)
        # surf.fill('white')
        s.blit(surf, surf.get_rect(midtop=(W // 2, y)))
        y += surf.get_height()
    return s.subsurface(s.get_bounding_rect())


# text = font.render(TEXT, True, 'white')
text = get_surf(TEXT)

texture = pygame.image.load('texture-dark.png').convert()
text.blit(texture, (0, 0), special_flags=pygame.BLEND_RGBA_MULT)
text.set_colorkey((0, 0, 0))
text = text.convert_alpha()

# text_overlay = pygame.Surface(text.get_size())
text_overlay_alpha = 255
# text_overlay.set_alpha(text_overlay_alpha)

text_gold_overlay = pygame.Surface(text.get_size())
text_gold_overlay.set_colorkey((0, 0, 0))

offset_x = W / 2 - text.get_width() / 2
offset_y = H / 2 - text.get_height() / 2 - 20

mask = pygame.mask.from_surface(text)
masks = mask.connected_components()
outlines = [i.outline() for i in masks]
for i in outlines:
    for j in range(len(i)):
        i[j] = (i[j][0] + offset_x, i[j][1] + offset_y)


@lru_cache(maxsize=200)
def get_diluted_color(r, g, b, k):
    return r // k, g // k, b // k


@lru_cache(maxsize=200)
def get_point_color(value):
    r, g, b = 255, 50, 0
    k = 0.7
    r += value * k
    g += value * k
    # b += value * k
    r = round(r)
    g = round(g)
    b = round(b)
    if r > 255:
        r = 255
    if g > 255:
        g = 255
    if b > 255:
        b = 255
    return r, g, b


class FlameParticle:
    alpha_layer_qty = 2
    alpha_glow_difference_constant = 1

    def __init__(self, x=W // 2, y=H // 2, r=5, rate=5.0):
        self.x = x
        self.y = y
        self.r = r
        self.original_r = r
        self.alpha_layers = FlameParticle.alpha_layer_qty
        self.alpha_glow = FlameParticle.alpha_glow_difference_constant
        max_surf_size = 2 * self.r * self.alpha_layers * self.alpha_layers * self.alpha_glow
        self.surf = pygame.Surface((max_surf_size, max_surf_size), pygame.SRCALPHA)
        # self.burn_rate = 0.1 * random.randint(1, 4)
        self.burn_rate = random.uniform(0.1, 0.4) / (5 / rate)
        self.alive = True
        self.dx = 5 / self.r ** 1.5
        self.rate = rate

    def update(self, dt):
        # self.y -= 5 - self.r
        self.y -= self.rate * dt / self.r
        self.dx = self.rate / self.r ** 1.5
        self.dx += random.randint(-self.r, self.r)
        self.x += self.dx * dt
        # self.x += random.randint(-self.r, self.r)
        self.original_r -= self.burn_rate * dt
        self.r = round(self.original_r)
        if self.r <= 0:
            self.alive = False
            self.r = 1

    @staticmethod
    @lru_cache(100)
    def get_color_yellow(radius):
        # return 50
        return 200 - round(radius) * 40

    def draw(self, surf):
        # max_surf_size = 2 * self.r * self.alpha_layers * self.alpha_layers * self.alpha_glow
        self.surf.fill((0, 0, 0, 0))
        # self.surf = pygame.Surface((max_surf_size, max_surf_size), pygame.SRCALPHA)
        for i in range(self.alpha_layers, -1, -1):
            alpha = 255 - i * (255 // self.alpha_layers - 5)
            if alpha <= 0:
                alpha = 0
            radius = self.r * i * i * self.alpha_glow
            draw_circle(self.surf, (255, self.get_color_yellow(self.r), 0, alpha), (self.surf.get_width() / 2, self.surf.get_height() / 2), radius)
        surf.blit(self.surf, self.surf.get_rect(center=(self.x, self.y)))


class Flame:
    def __init__(self, x=W // 2, y=H // 2, rate=5):
        self.x = x
        self.y = y
        self.flame_intensity = PARTICLES_PER_FLAME
        self.flame_particles = []
        self.timer = time.time()
        self.alive = True
        self.c = 10
        self.rate = rate
        for i in range(self.flame_intensity):
            self.flame_particles.append(FlameParticle(self.x + random.randint(-5, 5), self.y, self.radius(), self.rate))

    @staticmethod
    def radius():
        return random.randint(1, 5)

    def draw_flame(self, surf, dt):
        c = 0
        for i in self.flame_particles:
            i.update(dt)
            i.draw(surf)
            if i.original_r <= 0:
                i.alive = False
                self.c += 1
                c += 1
        self.flame_particles = [i for i in self.flame_particles if i.alive]
        if self.c > 5:
            if not self.flame_particles:
                self.alive = False
        else:
            pass
            # self.flame_particles.extend([FlameParticle(self.x + random.randint(-5, 5), self.y, self.radius()) for _ in range(c)])


class BackgroundFlameParticle:
    alpha_layer_qty = 2
    alpha_glow_difference_constant = 1

    def __init__(self, x=W // 2, y=H // 2, r=5, rate=5.0):
        self.x = random.randint(-250, W)
        self.y = y + random.randint(-50, 50)
        self.r = r
        self.original_r = r
        self.alpha_layers = FlameParticle.alpha_layer_qty
        self.alpha_glow = FlameParticle.alpha_glow_difference_constant
        max_surf_size = 2 * self.r * self.alpha_layers * self.alpha_layers * self.alpha_glow
        self.surf = pygame.Surface((max_surf_size, max_surf_size), pygame.SRCALPHA)
        # self.burn_rate = 0.1 * random.randint(1, 4)
        self.burn_rate = random.uniform(0.1, 0.4) / (5 / rate)
        self.alive = True
        self.dx = 5 / self.r ** 1.5
        self.rate = rate
        self.dr = random.uniform(-0.5, 5)

    def update(self, dt):
        # self.y -= 5 - self.r
        self.y -= 10 * dt / self.r
        self.dx = 5 / self.r ** 1.5
        # self.dx += random.uniform(-self.r / 4, self.r / 4)
        # self.dx += self.dr * math.sin(time.time())
        self.dx += self.dr
        # self.dx += random.randint(-self.r // 2, self.r // 2)
        self.x += self.dx * dt
        # self.x += random.randint(-self.r, self.r)
        self.original_r -= self.burn_rate * dt
        self.r = round(self.original_r)
        if self.r <= 0:
            self.alive = False
            self.r = 1

    @staticmethod
    @lru_cache(100)
    def get_color_yellow(radius):
        # return 50
        return 0
        return 200 - round(radius) * 40

    def draw(self, surf):
        # max_surf_size = 2 * self.r * self.alpha_layers * self.alpha_layers * self.alpha_glow
        self.surf.fill((0, 0, 0, 0))
        # self.surf = pygame.Surface((max_surf_size, max_surf_size), pygame.SRCALPHA)
        for i in range(self.alpha_layers, -1, -1):
            alpha = 255 - i * (255 // self.alpha_layers - 5)
            if alpha <= 0:
                alpha = 0
            radius = self.r * i * i * self.alpha_glow
            draw_circle(self.surf, (200, self.get_color_yellow(self.r), 0, alpha), (self.surf.get_width() / 2, self.surf.get_height() / 2), radius)
        surf.blit(self.surf, self.surf.get_rect(center=(self.x, self.y)))


class BackgroundFlame:
    def __init__(self, x=W // 2, y=H, rate=5.0):
        self.x = x
        self.y = y
        self.flame_intensity = PARTICLES_PER_FLAME
        self.flame_particles = []
        self.timer = time.time()
        self.alive = True
        self.c = 10
        self.rate = rate
        self.frame = 0
        for i in range(self.flame_intensity):
            self.flame_particles.append(BackgroundFlameParticle(self.x + random.randint(-5, 5), self.y, self.radius(), self.rate))

    @staticmethod
    def radius():
        return random.randint(1, 3)

    def draw_flame(self, surf, dt):
        c = 0
        for i in self.flame_particles:
            i.update(dt)
            i.draw(surf)
            if i.original_r <= 0:
                i.alive = False
                self.c += 1
                c += 1
        self.flame_particles = [i for i in self.flame_particles if i.alive]
        if self.frame % 50 == 0:
            self.flame_particles.append(BackgroundFlameParticle(self.x + random.randint(-5, 5), self.y, self.radius(), self.rate))
        self.frame += 1
        if len(self.flame_particles) > 50:
            if not self.flame_particles:
                self.alive = False
        else:
            pass
            # self.flame_particles.extend([FlameParticle(self.x + random.randint(-5, 5), self.y, self.radius()) for _ in range(c)])


def main_game():
    global text_overlay_alpha, text, screen, text_gold_overlay
    m = max([len(i) for i in outlines])
    values = [0 for _ in outlines]
    flames = [Flame(W // 2, H // 2)]
    c = 0
    to_add = []
    size = START_SCALE
    line_width = 5
    dt = 1
    alpha_dt = 2
    background_flames = []
    bg = pygame.image.load('bg.png').convert()
    while True:
        size += (END_SCALE - size) * dt / SCALE_TRANSITION
        if size < END_SCALE:
            size = END_SCALE
        events = pygame.event.get()
        for e in events:
            if e.type == pygame.QUIT:
                quit()
            if e.type == pygame.KEYDOWN:
                if e.key == pygame.K_ESCAPE:
                    quit()
                if e.key == pygame.K_r:
                    text_gold_overlay = pygame.Surface(text.get_size())
                    line_width = 5
                    text_overlay_alpha = 255
                    size = START_SCALE
                    values = [0 for _ in outlines]
                    flames = [Flame(W // 2, H // 2)]
                    c = 0
                    alpha_dt = 2
                if e.key == pygame.K_e:
                    values = [0 for _ in outlines]
                    flames = [Flame(W // 2, H // 2)]
                    c = 0
                    text_overlay_alpha = 0
                    alpha_dt = -2
        # display.fill(0)
        # screen.fill(0)
        screen.blit(bg, (0, 0))
        for i in background_flames:
            i.draw_flame(screen, dt)

        _text = text.copy()
        _text.blit(text_gold_overlay, (0, 0), special_flags=pygame.BLEND_RGB_ADD)
        _text.set_alpha(255 - text_overlay_alpha)
        screen.blit(_text, (offset_x, offset_y))
        # if text_overlay_alpha:
        # screen.blit(text_overlay, (offset_x, offset_y), special_flags=pygame.BLEND_RGBA_SUB)
        text_overlay_alpha -= alpha_dt * dt
        if text_overlay_alpha < 0:
            text_overlay_alpha = 0
        # text_overlay.set_alpha(text_overlay_alpha)

        flames = [i for i in flames if i.alive]
        flames.extend(to_add)
        to_add.clear()
        for i in range(len(values)):
            if values[i] > m:
                values[i] += 5
                line_width -= 0.01
                if line_width < 1:
                    line_width = 1
            try:
                start = values[i] - TRAIL_LENGTH
                if start < 0:
                    start = 0
                points = outlines[i][start:values[i] + 2]
                k = len(points)
                draw_line = pygame.draw.line
                for _i in range(k - 1):
                    draw_line(screen, get_point_color(k - _i), points[_i], points[_i + 1], line_width.__round__() * 0 + LINE_THICKNESS)
                c += 1
                if c % 3 == 0:
                    c = 0
                    try:
                        x, y = outlines[i][values[i]]
                        to_add.append(Flame(x, y, rate=5))
                    except IndexError:
                        pass
                if c % 2 == 0:
                    x, y = outlines[i][values[i]]
                    r1 = 5
                    draw_circle(text_gold_overlay, get_diluted_color(255, 255, 0, 5), (x - offset_x, y - offset_y), r1)
                values[i] += round(TRAIL_SPEED * dt)
            except (ValueError, IndexError):
                pass

        for i in flames:
            i.draw_flame(screen, dt)

        background_flames = [i for i in background_flames if i.alive]
        if len(background_flames) < 20:
            background_flames.append(BackgroundFlame(rate=0.1))

        screen1 = pygame.transform.scale_by(screen, size)
        window.blit(screen1, screen1.get_rect(center=(W / 2, H / 2)))
        pygame.display.update()
        dt = FPS * clock.tick(FPS * 0) / 1000
        if dt > 5:
            dt = 5
        # print(clock.get_fps())


main_game()