Editing Openai/68c9bd38-1494-8003-92de-0fcfb17eb8dc (section)

=== Assistant: Perfeito! ===
Perfeito! Pelo que você descreveu, você quer criar partículas tipo cúpula que interagem de forma selecionada:
* Algumas partículas capturam outras (atração intensa).
* Outras repelentes (se afastam de partículas específicas).
* Cores distintas para cada tipo, para identificar facilmente.
* Movimentação mais intensa (mais velocidade, mais dinâmica).
* Mantendo dispersão de partículas internas e mosaico.

Vou montar um código Python/Pygame completo com essas regras:

<syntaxhighlight lang="python">import pygame
import math
import random

pygame.init()
WIDTH, HEIGHT = 800, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Cúpulas Químicas Dinâmicas")
clock = pygame.time.Clock()

TILE_SIZE = 40

=== cores base para tipos de cúpula ===
ATTRACT = (255, 50, 50)      # vermelho intenso: captura
REPEL = (50, 50, 255)        # azul intenso: repele
NEUTRAL = (180,180,180)      # cinza
COIL = (255,165,0)            # laranja
ALCHEMY = (255,255,100)       # partículas internas

=== mosaico ===
mosaic = []
for i in range(WIDTH // TILE_SIZE):
    row = []
    for j in range(HEIGHT // TILE_SIZE):
        choices = random.choices([ATTRACT, REPEL, NEUTRAL], [0.3,0.3,0.4], k=random.choice([1,2]))
        row.append(choices)
    mosaic.append(row)

class Particle:
    def __init__(self, x, y, kind="ATTRACT", mass=1, radius=14, is_coil=False):
        self.x = x
        self.y = y
        self.kind = kind  # ATTRACT, REPEL, NEUTRAL
        self.vx = random.uniform(-150,150)  # maior movimentação
        self.vy = random.uniform(-150,150)
        self.mass = mass
        self.radius = radius
        self.is_coil = is_coil
        self.inner_particles = []

    def draw(self, screen):
        if self.is_coil:
            color = COIL
        elif self.kind=="ATTRACT":
            color = ATTRACT
        elif self.kind=="REPEL":
            color = REPEL
        else:
            color = NEUTRAL
        pygame.draw.circle(screen, color, (int(self.x), int(self.y)), self.radius)

        for p in self.inner_particles:
            pygame.draw.circle(screen,ALCHEMY,(int(p[0]),int(p[1])),3)

    def update(self, dt, center, particles):
        # interação entre partículas
        for p in particles:
            if p==self:
                continue
            dx = p.x - self.x
            dy = p.y - self.y
            dist = math.hypot(dx, dy)
            if dist==0: dist=0.1

            # cúpulas de captura: atraem
            if self.kind=="ATTRACT":
                force = 400/dist
                self.vx += dx/dist''force''dt
                self.vy += dy/dist''force''dt

            # cúpulas repulsivas
            elif self.kind=="REPEL":
                if dist<150:
                    force = 300/(dist)
                    self.vx -= dx/dist''force''dt
                    self.vy -= dy/dist''force''dt

            # neutras apenas se dispersam levemente
            elif self.kind=="NEUTRAL":
                if dist<50:
                    force = 50/(dist)
                    self.vx -= dx/dist''force''dt
                    self.vy -= dy/dist''force''dt

        # centro como jockey: apenas referência
        dx_center = center[0]-self.x
        dy_center = center[1]-self.y
        dist_center = math.hypot(dx_center,dy_center)
        if dist_center<30:
            self.vx *= 0.8
            self.vy *= 0.8
        else:
            self.vx *= 0.9
            self.vy *= 0.9

        # atualizar posição
        self.x += self.vx*dt
        self.y += self.vy*dt
        self.x = max(self.radius,min(WIDTH-self.radius,self.x))
        self.y = max(self.radius,min(HEIGHT-self.radius,self.y))

        # partículas internas
        new_inner=[]
        for p in self.inner_particles:
            px,py,vx,vy,life = p
            life -= dt
            if life>0:
                px += vx*dt
                py += vy*dt
                new_inner.append([px,py,vx,vy,life])
        self.inner_particles = new_inner

    def emit_inner(self,n=10):
        for _ in range(n):
            angle=random.uniform(0,2*math.pi)
            speed=random.uniform(200,400)
            vx = math.cos(angle)*speed
            vy = math.sin(angle)*speed
            life = random.uniform(0.5,1.2)
            self.inner_particles.append([self.x,self.y,vx,vy,life])

=== setup ===
particles=[
    Particle(400,300,"ATTRACT"),
    Particle(200,200,"REPEL"),
    Particle(600,400,"NEUTRAL"),
    Particle(400,500,is_coil=True)
]

center = (WIDTH//2, HEIGHT//2)
running = True

while running:
    dt = clock.tick(60)/1000
    for event in pygame.event.get():
        if event.type==pygame.QUIT:
            running=False
        elif event.type==pygame.MOUSEBUTTONDOWN:
            x,y=pygame.mouse.get_pos()
            kind=random.choice(["ATTRACT","REPEL","NEUTRAL"])
            particles.append(Particle(x,y,kind))
        elif event.type==pygame.KEYDOWN:
            if event.key==pygame.K_SPACE:
                for p in particles:
                    if p.is_coil:
                        p.emit_inner(20)

    for p in particles:
        p.update(dt,center,particles)

    # desenhar mosaico
    for i in range(len(mosaic)):
        for j in range(len(mosaic[0])):
            cell = mosaic[i][j]
            if len(cell)==1:
                color = cell[0]
            else:
                color = tuple(min(255,sum(c)//len(c)) for c in zip(*cell))
            pygame.draw.rect(screen,color,(i''TILE_SIZE,j''TILE_SIZE,TILE_SIZE,TILE_SIZE))

    # desenhar partículas
    for p in particles:
        p.draw(screen)

    pygame.draw.circle(screen,(50,50,50),center,5)
    pygame.display.flip()

pygame.quit()

</syntaxhighlight>

===== 1. Cúpulas de captura (vermelhas): atraem outras partículas próximas. =====
# Cúpulas repulsivas (azuis): afastam outras partículas dentro de 150px.
# Cúpulas neutras (cinza): dispersão leve.
# Movimentação intensa: partículas se movem rapidamente, criando dinâmica química viva.
# Partículas internas (alquimia) continuam visíveis e interativas.
# Mosaico ativo e centro como jockey.

Se quiser, posso adicionar ainda uma função de “fusão temporária”, onde duas cúpulas que se encontram podem trocar cores e propriedades por alguns segundos, simulando reação química dinâmica.

Quer que eu faça isso?