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

=== Assistant: Perfeito! ===
Perfeito! Pelo que você descreveu, você quer transformar a simulação em algo mais “dinâmico e seletivo”, quase como um sistema com interações “realistas” entre partículas:
* Colina = falsos: partículas falsas permanecem “paradas” ou “em colinas” até serem atingidas.
* Bobina queima falsos: a bobina (uma carga especial) interage e elimina ou empurra os falsos.
* Adicionar massa: cada carga agora terá massa que afeta a aceleração (F = ma).
* Acerte as massas conforme o toque: quando a bobina toca outra carga, há efeito de expansão/repulsão proporcional à massa da carga atingida.

Vou criar uma versão adaptada do seu código com esses elementos:

<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("Simulação Bobina vs Falsos")
clock = pygame.time.Clock()

k = 1000

class Charge:
    def __init__(self, x, y, q, radius=10, mass=1, is_fake=False, is_coil=False):
        self.x = x
        self.y = y
        self.q = q
        self.radius = radius
        self.mass = mass
        self.vx = 0
        self.vy = 0
        self.fx = 0
        self.fy = 0
        self.wait_time = random.uniform(0, 2)
        self.is_fake = is_fake   # colina / falso
        self.is_coil = is_coil   # bobina especial

    def draw(self, screen):
        if self.is_coil:
            color = (255, 165, 0)  # laranja para bobina
        elif self.is_fake:
            color = (128, 128, 128)  # cinza para falsos
        else:
            color = (255, 0, 0) if self.q > 0 else (0, 0, 255)
        pygame.draw.circle(screen, color, (int(self.x), int(self.y)), self.radius)
        force_magnitude = math.hypot(self.fx, self.fy)
        if force_magnitude != 0:
            scale = 0.05
            pygame.draw.line(
                screen, (0, 255, 0),
                (int(self.x), int(self.y)),
                (int(self.x + self.fx '' scale), int(self.y + self.fy '' scale)), 2
            )

charges = [
    Charge(300, 300, 5, mass=2),
    Charge(500, 300, -5, mass=3),
    Charge(400, 500, 10, mass=4, is_fake=True),
    Charge(200, 400, 20, mass=5, is_coil=True)
]

def update_forces(charges, dt):
    for c in charges:
        c.fx, c.fy = 0, 0

    # Força Coulomb entre pares
    for i, c1 in enumerate(charges):
        for j, c2 in enumerate(charges):
            if i >= j:
                continue
            dx = c2.x - c1.x
            dy = c2.y - c1.y
            r_squared = dx'''2 + dy'''2
            if r_squared == 0:
                continue
            fraction = random.uniform(0.3, 0.7)
            force = k '' c1.q '' c2.q / r_squared * fraction
            angle = math.atan2(dy, dx)
            fx = force * math.cos(angle)
            fy = force * math.sin(angle)
            c1.fx += fx
            c1.fy += fy
            c2.fx -= fx
            c2.fy -= fy

    for c in charges:
        if c.wait_time > 0:
            c.wait_time -= dt
            continue

        # Aceleração depende da massa
        c.vx += (c.fx / c.mass) * dt
        c.vy += (c.fy / c.mass) * dt

        # Flutuação aleatória
        c.vx += random.uniform(-5, 5) * dt
        c.vy += random.uniform(-5, 5) * dt

        c.x += c.vx * dt
        c.y += c.vy * dt

        # Limites da tela
        if c.x < c.radius: c.x = c.radius; c.vx *= -0.5
        if c.x > WIDTH - c.radius: c.x = WIDTH - c.radius; c.vx *= -0.5
        if c.y < c.radius: c.y = c.radius; c.vy *= -0.5
        if c.y > HEIGHT - c.radius: c.y = HEIGHT - c.radius; c.vy *= -0.5

    # Bobina interage com falsos
    for coil in [c for c in charges if c.is_coil]:
        for fake in [c for c in charges if c.is_fake]:
            dx = fake.x - coil.x
            dy = fake.y - coil.y
            dist = math.hypot(dx, dy)
            if dist < coil.radius + fake.radius + 20:  # toque / alcance da bobina
                # Expansão / repulsão proporcional à massa do falso
                repel_strength = 300 / fake.mass
                angle = math.atan2(dy, dx)
                fake.vx += math.cos(angle) '' repel_strength '' dt
                fake.vy += math.sin(angle) '' repel_strength '' dt

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
            charges.append(Charge(x, y, q, mass=random.randint(1,5)))

    screen.fill((255, 255, 255))
    update_forces(charges, dt)
    for c in charges:
        c.draw(screen)
    pygame.display.flip()

pygame.quit()

</syntaxhighlight>

===== 1. Falsos (colina): aparecem em cinza e podem ser empurrados pela bobina. =====
# Bobina laranja: “queima” falsos ao tocá-los, empurrando-os com força proporcional à massa.
# Massa das partículas: afeta a aceleração, tornando o movimento mais realista.
# Toque/expansão: quanto mais próximo o falso da bobina, mais rápido ele é repelido.

Se quiser, posso adicionar um efeito visual de “queima”, onde os falsos mudam de cor ou desaparecem quando a bobina toca, para reforçar a ideia de “eliminação”.

Quer que eu faça isso?