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

=== Assistant: Perfeito! ===
Perfeito! Pelo que você descreveu, você quer um comportamento mais químico/dinâmico das partículas, com várias regras simultâneas:
# Lados opostos atuam como ímãs: partículas são atraídas para os lados opostos.
# Segunda vítima dispersa ao toque: partículas próximas umas das outras interagem, fazendo uma dispersão controlada.
# Desfoque no centro: mantém partículas próximas do centro sem travar, permitindo que reações químicas internas continuem vivas.
# Dispersão e reaglomeração: partículas se dividem acima do valor neutro, gerando troca de “parcerias químicas”.
# Químicas vivas: partículas internas (alquimia) continuam sendo visíveis e interativas.

Vou montar um código Python/Pygame atualizado que implementa 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("Interação Química Dinâmica")
clock = pygame.time.Clock()

TILE_SIZE = 40

=== cores base ===
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):
        # cor adaptativa
        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):
        # Atração pelos lados opostos (ímas)
        dx_left = 0 - self.x
        dx_right = WIDTH - self.x
        force_x = dx_left''0.1 + dx_right''0.1
        dy_top = 0 - self.y
        dy_bottom = HEIGHT - self.y
        force_y = dy_top''0.1 + dy_bottom''0.1
        self.vx += force_x*dt
        self.vy += force_y*dt

        # Interação com outras 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

        # Desfoque no centro: fricção suave
        dxc = center[0]-self.x
        dyc = center[1]-self.y
        dist_center = math.hypot(dxc, dyc)
        if dist_center<50:
            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
        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)
cesium_active=False

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)
            elif event.key==pygame.K_c:
                cesium_active = not cesium_active

    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. Ímãs laterais: partículas são atraídas pelos lados opostos da tela. =====
# Dispersão controlada ao toque: partículas próximas se repelem suavemente.
# Desfoque no centro: fricção aumenta próximo ao centro para manter as “químicas vivas”.
# Dispersão e reaglomeração: partículas internas continuam a movimentar-se e se reorganizar.
# Cores adaptativas e alquimia visível.

Se quiser, posso fazer uma versão ainda mais química, onde partículas se ligam temporariamente em pares neutros ou positivos/negativos, simulando troca de parcerias químicas, com cores pulsando conforme a interação.

Quer que eu faça isso?