funciona!

main.go

@@ -1,7 +1,9 @@
 package main
 
 import (
+	"fmt"
 	"math"
+	"math/rand"
 
 	rl "github.com/gen2brain/raylib-go/raylib"
 )
@@ -10,6 +12,8 @@ import (
 type magnet struct {
     pos rl.Vector2
     color rl.Color
+    force float32
+    radius float32
 }
 
 type state struct {
@@ -18,6 +22,13 @@ type state struct {
     magnetsDistance float32
 }
 
+type ball struct {
+    pos rl.Vector2
+    originGrid rl.Vector2
+    radius float32
+    speed rl.Vector2
+}
+
 func main() {
 
     state := state{
@@ -30,29 +41,33 @@ func main() {
         "raylib [core] example - basic window",
     )
 	defer rl.CloseWindow()
-	rl.SetTargetFPS(60)
+	// rl.SetTargetFPS(60)
 
     const RADIUS = 10 
+    const FORCE = 8
 
     magnets := []magnet{
         {
-            // pos: rl.Vector2{X: 100, Y: 100},
-            color: rl.NewColor(255, 0, 0, 255),
+            color: rl.Red,
+            radius: RADIUS,
+            force: FORCE,
         },
         {
-            // pos: rl.Vector2{X: 200, Y: 200},
-            color: rl.NewColor(0, 255, 0, 255),
+            color: rl.Green,
+            radius: RADIUS,
+            force: FORCE,
         },
         {
-            // pos: rl.Vector2{X: 200, Y: 100},
-            color: rl.NewColor(0, 0, 255, 255),
+            color: rl.Blue,
+            radius: RADIUS,
+            force: FORCE,
         },
     }
 
     // pocisionar imas no meio da tela
     xCenter := float32(state.windowWidth / 2)
     yCenter := float32(state.windowHeight / 2)
-    magnetsDistance := float32(100)
+    var magnetsDistance float32 = 80
     for i := range magnets {
         angle := 2.0 * math.Pi * float64(i) / float64(len(magnets))
 
@@ -63,24 +78,44 @@ func main() {
     }
 
     
-    verticalGrids := 10
-    horizontalGrids := 10
+    verticalGrids := 60
+    horizontalGrids := 60
 
     grid := make([][]rl.Color, verticalGrids)
     for i := range grid {
         grid[i] = make([]rl.Color, horizontalGrids)
         for j := range grid[i] {
-            grid[i][j] = rl.NewColor(10, 10, 10, 255)
+            grid[i][j] = rl.Black
         }
     }
 
-    ball := rl.Vector2{0, 0}
-
+    // ball := ball{
+    //     pos: rl.Vector2{0, 0},
+    //     originGrid: rl.Vector2{X: 0, Y: 0},
+    // }
+    //
     gridSize := rl.Vector2{
         X: float32(state.windowWidth / int32(verticalGrids)),
         Y: float32(state.windowHeight / int32(horizontalGrids)),
     }
 
+    var fallingBall *ball
+    fallingBall = nil
+
+    var fallingBallOrder []rl.Vector2
+    for y := range grid {
+        for x := range grid[y] {
+            fallingBallOrder = append(fallingBallOrder, rl.Vector2{
+                X: float32(x),
+                Y: float32(y),
+            })
+        }
+    }
+    rand.Shuffle(len(fallingBallOrder), func(i, j int) {
+        fallingBallOrder[i], fallingBallOrder[j] = 
+        fallingBallOrder[j], fallingBallOrder[i]
+    })
+
 	for !rl.WindowShouldClose() {
 		rl.BeginDrawing()
 		rl.ClearBackground(rl.Black)
@@ -94,11 +129,78 @@ func main() {
                 rl.DrawRectangleV(pos, gridSize, grid[y][x])
             }
         }
-
         for i := range magnets {
+            rl.DrawCircleV(magnets[i].pos, RADIUS+2, rl.Black)
             rl.DrawCircleV(magnets[i].pos, RADIUS, magnets[i].color)
         }
-        rl.DrawCircleV(ball, RADIUS/2, rl.NewColor(100, 100, 100, 255))
+
+        if len(fallingBallOrder) == 0 {
+            rl.EndDrawing()
+            continue
+        } 
+
+        if fallingBall == nil {
+            next := fallingBallOrder[0]
+            fallingBallOrder = fallingBallOrder[1:]
+            x := next.X * gridSize.X + gridSize.X/2
+            y := next.Y * gridSize.Y + gridSize.Y/2
+            fallingBall = &ball{
+                pos: rl.Vector2{X: x, Y: y},
+                originGrid: next,
+                radius: RADIUS/2,
+            }
+        } 
+
+        magnetsPull := rl.Vector2{}
+        var ballMass float32 = 1
+        var gravConst float32 = 8
+
+        for _, magnet := range magnets {
+            direction := rl.Vector2Normalize(
+                rl.Vector2Subtract(fallingBall.pos, magnet.pos),
+            )
+            distance := rl.Vector2Distance(magnet.pos, fallingBall.pos)
+            force := gravConst * (ballMass * magnet.force) / distance
+
+            acceleration := rl.Vector2Scale(direction, -force)
+
+            magnetsPull = rl.Vector2Add(magnetsPull, acceleration)
+        }
+
+        // fmt.Println(magnetsPull)
+        fallingBall.speed = rl.Vector2Add(fallingBall.speed, magnetsPull)
+        fallingBall.pos = rl.Vector2Add(fallingBall.speed, fallingBall.pos)
+        rl.DrawCircleV(
+            fallingBall.pos, fallingBall.radius+1, rl.Black,
+        )
+        rl.DrawCircleV(
+            fallingBall.pos, fallingBall.radius, 
+            rl.NewColor(100, 100, 100, 255),
+        )
+        for _, magnet := range magnets {
+            distance := rl.Vector2Distance(fallingBall.pos, magnet.pos)
+            if distance < magnet.radius + fallingBall.radius {
+                x := fallingBall.originGrid.X
+                y := fallingBall.originGrid.Y
+                grid[int(y)][int(x)] = magnet.color
+                fallingBall = nil
+                break
+            }
+        }
+
         rl.EndDrawing()
 	}
+
+    stat := make(map[rl.Color]int)
+    stat[rl.Red] = 0
+    stat[rl.Green] = 0
+    stat[rl.Blue] = 0
+
+    for y := range grid {
+        for x := range grid[y] {
+            stat[grid[y][x]] += 1
+        }
+    }
+
+    fmt.Println(stat)
 }