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

=== Assistant: Perfeito! ===
Perfeito! Pelo que você descreveu, você quer um comportamento ainda mais “químico e dinâmico” das partículas:
* Fricção seletiva: apenas partículas pequenas ou “menores” sofrem desaceleração e permanecem latentes.
* Centro como jockey: o centro atua como referência, mas não interfere na fricção ou na dispersão; ele guia a balança sem ser meio ativo.
* Balanço ativo: partículas não latentes se movimentam, “balançam” e interagem, formando aglomerações que depois se dispersam.
* Fim da união: as partículas que aglomeram no final do ciclo se dispersam novamente, permitindo reorganização química contínua.

Vou criar um código atualizado que implementa isso, mantendo:
* Mosaico com chassis.
* Partículas grandes (bobina) e pequenas (menores).
* Interações de atração/repulsão.
* Dispersão de partículas internas (“alquimia”).
* Fricção seletiva para menores latentes.

<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("Partículas Químicas Dinâmicas com Balanço")
clock = pygame.time.Clock()

TILE_SIZE = 40

=== cores ===
PROTON = (255,50,50)
ELECTRON = (50,50,255)
NEUTRAL = (180,180,180)
COIL = (255,165,0)
ALCHEMY = (255,255,100)

=== mosaico ===
mosaic = []
for i in range(WIDTH // TILE_SIZE):
    row = []
    for j in range(HEIGHT // TILE_SIZE):
        choices = random.choices([PROTON, ELECTRON, 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, q=5, mass=1, radius=12, is_coil=False):
        self.x = x
        self.y = y
        self.q = q
        self.vx = random.uniform(-50,50)
        self.vy = random.uniform(-50,50)
        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.q>0:
            intensity = min(255,50+int(abs(self.vx+self.vy)))
            color = (intensity,50,50)
        elif self.q<0:
            intensity = min(255,50+int(abs(self.vx+self.vy)))
            color = (50,50,intensity)
        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):
        # Lados opostos atraem: balança ativa
        dx_left = 0 - self.x
        dx_right = WIDTH - self.x
        dy_top = 0 - self.y
        dy_bottom = HEIGHT - self.y
        self.vx += (dx_left''0.1 + dx_right''0.1)*dt
        self.vy += (dy_top''0.1 + dy_bottom''0.1)*dt

        # Interação entre partículas: dispersão ao toque
        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<30:
                repel = 200/(dist+0.1)
                angle = math.atan2(dy,dx)
                self.vx -= math.cos(angle)''repel''dt
                self.vy -= math.sin(angle)''repel''dt

        # Fricção seletiva: partículas menores latentes
        if self.radius<=12:
            self.vx *= 0.6
            self.vy *= 0.6
        else:
            self.vx *= 0.85
            self.vy *= 0.85

        # 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 (alquimia)
        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=8):
        for _ in range(n):
            angle=random.uniform(0,2*math.pi)
            speed=random.uniform(100,250)
            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,q=5),
    Particle(200,200,q=-5),
    Particle(600,400,q=5),
    Particle(400,500,radius=20,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()
            q=5 if event.button==1 else -5
            particles.append(Particle(x,y,q))
        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)

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

pygame.quit()

</syntaxhighlight>

===== 1. Fricção seletiva para partículas menores: permanecem latentes. =====
# Centro como jockey: serve de referência, não interfere na fricção ou dispersão.
# Balanço ativo: partículas maiores balançam e interagem com os lados opostos.
# Aglomeração e dispersão: partículas se agrupam e se dispersam, mantendo química dinâmica.
# Partículas internas (alquimia) continuam visíveis e interativas.
# Mosaico com chassis múltiplos e cores adaptativas.

Se você quiser, posso adicionar a troca de parcerias químicas automaticamente: partículas neutras ou positivas/negativas podem formar pares temporários, trocar cargas ou cores, simulando reaglomeração química viva.

Quer que eu faça isso?