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

=== Assistant: Perfeito! ===
Perfeito! Você quer adicionar uma faísca ou efeito de explosão dentro da bobina, que ao tocar outras cargas novas (falsos ou recém-criadas) provoca interação imediata. Podemos fazer isso visualmente com pequenos flashes ou partículas saindo da bobina e aplicando uma repulsão instantânea às cargas atingidas.

Aqui está uma versão adaptada do código com faíscas internas na bobina:

<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("Bobina com Faíscas Interativas")
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
        self.is_coil = is_coil
        self.sparks = []

    def draw(self, screen):
        # Cor da carga
        if self.is_coil:
            color = (255, 165, 0)
        elif self.is_fake:
            color = (128, 128, 128)
        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)

        # Vetor de força
        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
            )

        # Desenhar faíscas da bobina
        for spark in self.sparks:
            pygame.draw.circle(screen, (255, 255, 0), (int(spark[0]), int(spark[1])), 3)

    def update_sparks(self, dt):
        # Atualiza posição das faíscas
        new_sparks = []
        for spark in self.sparks:
            x, y, vx, vy, life = spark
            life -= dt
            if life > 0:
                x += vx * dt
                y += vy * dt
                new_sparks.append([x, y, vx, vy, life])
        self.sparks = new_sparks

    def emit_sparks(self, n=5):
        for _ in range(n):
            angle = random.uniform(0, 2*math.pi)
            speed = random.uniform(50, 150)
            vx = math.cos(angle) * speed
            vy = math.sin(angle) * speed
            life = random.uniform(0.2, 0.5)
            self.sparks.append([self.x, self.y, vx, vy, life])

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

    # Atualizar posições e massa
    for c in charges:
        if c.wait_time > 0:
            c.wait_time -= dt
            continue
        c.vx += (c.fx / c.mass) * dt
        c.vy += (c.fy / c.mass) * dt
        c.vx += random.uniform(-5,5)*dt
        c.vy += random.uniform(-5,5)*dt
        c.x += c.vx * dt
        c.y += c.vy * dt

        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 emite faíscas
        if c.is_coil:
            c.emit_sparks(n=3)
            c.update_sparks(dt)

            # Faíscas atingem falsos e novas cargas
            for spark in c.sparks:
                sx, sy = spark[0], spark[1]
                for target in [ch for ch in charges if ch.is_fake or not ch.is_coil]:
                    dx = target.x - sx
                    dy = target.y - sy
                    dist = math.hypot(dx, dy)
                    if dist < target.radius+2:
                        # Empurra a carga atingida
                        repel_strength = 200 / target.mass
                        angle = math.atan2(dy, dx)
                        target.vx += math.cos(angle)''repel_strength''dt
                        target.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((0,0,0))
    update_forces(charges, dt)
    for c in charges:
        c.draw(screen)
    pygame.display.flip()

pygame.quit()

</syntaxhighlight>

===== 1. Faíscas internas na bobina: pequenas partículas amarelas saem da bobina constantemente. =====
# Interação instantânea: se uma faísca toca uma carga nova ou falso, ela é empurrada imediatamente.
# Repulsão proporcional à massa: cargas mais pesadas são menos afetadas.
# Mantém forças Coulomb, massa e flutuação.
# Visualização escura com faíscas amarelas para contraste.

Se quiser, posso fazer a faísca explodir em “mini-partículas” com cores diferentes ao tocar falsos, criando um efeito visual ainda mais intenso de “queima” e expansão.

Quer que eu faça isso?