__main__.py

"""2026-05-10
Counting 04 (Chaos 03)
Polígonos regulares a partir de 4 lados, centralizados.
ericof.com|https://ericof.com/en/sketches/2023-11-06
png
Sketch,py5,CreativeCoding,Poligonos
"""

from random import shuffle
from sketches.utils.draw import canvas
from sketches.utils.draw.formas import _gera_forma
from sketches.utils.draw.grade import cria_grade
from sketches.utils.helpers import sketches as helpers

import py5


sketch = helpers.info_for_sketch(__file__, __doc__)

cor_fundo = py5.color(0)

celula_x = 400
m_celula_x = celula_x / 2
celula_y = 400
m_celula_y = celula_y / 2

inicio = 80

GRADE = cria_grade(*helpers.DIMENSOES.internal, 0, 0, celula_x, celula_y, False)
FORMAS: dict[int, py5.Py5Shape] = {}
ORDEM: list[int] = []
total_celulas = len(GRADE)
lado_min = 4
lado_max = lado_min + total_celulas
mult = 1.5


def calcula_cor(lado: int, total_células: int) -> list[int]:
    """Gera ``lado`` variações da mesma cor base, alterando S e B.

    A cor base é derivada do número de lados via módulos coprimos,
    garantindo distribuição diversa em faixa cromática vibrante
    (sem extremos brancos ou pretos):

    - ``h = (lado · passo + inicio) mod 360`` com ``passo = 360
      / total_células`` — matiz adapta-se ao tamanho da grade,
      percorrendo o círculo cromático ao longo das células. O
      termo ``inicio`` (constante de módulo) desloca o ponto de
      partida da paleta no círculo cromático;
    - ``s_base = 60 + (lado · 7) mod 41`` — saturação base em
      ``[60, 100]``;
    - ``b_base = 50 + (lado · 11) mod 41`` — brilho base em
      ``[50, 90]``.

    Os multiplicadores 7 e 11 e o módulo 41 são coprimos entre si,
    evitando bandas onde saturação e brilho coincidam ciclicamente.

    Para cada índice ``i`` em ``[0, lado)``, S e B recebem um
    deslocamento normalizado por ``lado`` (``delta_norm = (i -
    (lado-1)/2) / lado``, sempre em ``[-0.5, +0.5]``), com ganho
    ``±15`` em S e ``∓10`` em B — produzindo o mesmo "spread"
    visual independentemente do número de lados. O resultado é uma
    sequência monocromática progressiva, adequada para aplicar como
    ``set_fills`` em um shape de ``lado`` vértices.

    :param lado: número de lados do polígono (também o tamanho da
        lista retornada).
    :param total_células: número total de células na grade; define
        o passo angular ``360 / total_células`` da distribuição de
        matiz.
    :returns: lista de ``lado`` valores ``py5.color`` com matiz
        comum e variações progressivas de saturação e brilho.
    """
    passo = 360 / total_células
    h = ((lado * passo) + inicio) % 360
    s_base = 60 + (lado * 7) % 41
    b_base = 50 + (lado * 11) % 41
    cores: list[int] = []
    for i in range(lado):
        delta_norm = (i - (lado - 1) / 2) / lado
        s = s_base + delta_norm * 30
        b = b_base - delta_norm * 20
        cores.append(py5.color(h, s, b))
    return cores


def setup():
    py5.size(*helpers.DIMENSOES.external, py5.P3D)
    py5.rect_mode(py5.CORNERS)
    py5.shape_mode(py5.CORNERS)
    py5.color_mode(py5.HSB, 360, 100, 100)
    for lados in range(lado_min, lado_max):
        forma = _gera_forma(lados)
        rotacao = float(py5.radians(360 / lados / 2))
        forma.set_fills(calcula_cor(lados, total_celulas))
        forma.set_stroke("#FFFFFF")
        forma.set_stroke_weight(4)
        forma.rotate(rotacao)
        FORMAS[lados] = forma
    chaves = list(FORMAS.keys())
    shuffle(chaves)
    ORDEM.extend(chaves)


def draw():
    py5.background(cor_fundo)
    with py5.push():
        py5.translate(*helpers.DIMENSOES.pos_interno, -10)
        for idx, _ in enumerate(GRADE):
            chave = ORDEM[idx]
            forma = FORMAS[chave]
            x, y = 400, 100
            py5.shape(forma, x, y, x + celula_x * mult, y + celula_y * mult)
    # Credits and go
    canvas.sketch_frame(
        sketch,
        cor_fundo,
        "large_transparent_white",
        "transparent_white",
        version=2,
    )


def key_pressed():
    key = py5.key
    if key == " ":
        save_and_close()


def save_and_close():
    py5.no_loop()
    canvas.save_sketch_image(sketch)
    py5.exit_sketch()


if __name__ == "__main__":
    py5.run_sketch()