debugando

main.go

@@ -18,22 +18,23 @@ type magnet struct {
 }
 
 
-type quadnode struct {
+type quadtree struct {
     // pos, size rl.Vector2
     pos, size rl.Vector2
     magnet *magnet
-    parent *quadnode
+    parent *quadtree
-    nodes []*quadnode
+    nodes []*quadtree
     mass float32
+    debug string
 }
 
 
-func (q *quadnode) isOutside(magnet rl.Vector2) bool {
+func (q *quadtree) isOutside(magnet rl.Vector2) bool {
     return magnet.X < q.pos.X || magnet.X >= q.pos.X + q.size.X ||
     magnet.Y < q.pos.Y || magnet.Y >= q.pos.Y + q.size.Y
 }
 
-func (q *quadnode) isOccupied() (bool, *magnet) {
+func (q *quadtree) isOccupied() (bool, *magnet) {
     if q.magnet == nil {
         return false, nil
     } else {
@@ -41,7 +42,7 @@ func (q *quadnode) isOccupied() (bool, *magnet) {
     }
 }
 
-func (q *quadnode) insertMagnet(magnets ...*magnet) {
+func (q *quadtree) insertMagnet(magnets ...*magnet) {
     for _, magnet := range magnets {
 
         for _, node := range q.nodes {
@@ -50,59 +51,66 @@ func (q *quadnode) insertMagnet(magnets ...*magnet) {
             }
             if occupied, occupyingMagnet := node.isOccupied(); occupied {
                 node.subdivide()
-                node.insertMagnet(occupyingMagnet)
+                node.magnet = nil
-            }
                 node.insertMagnet(magnet)
+                node.insertMagnet(occupyingMagnet)
+                break
+            }
             node.magnet = magnet
             break
         }
     }
 }
 
-func newQuadTreeRoot() *quadnode {
+func newQuadTreeRoot() *quadtree {
-    temp := &quadnode{
+    temp := &quadtree{
         pos: rl.NewVector2(0, 0),
         size: rl.NewVector2(windowWidth, windowHeight),
         nodes: nil,
+        debug: "root",
     }
     temp.subdivide()
     return temp
 }
 
-func (q *quadnode) subdivide() {
+func (q *quadtree) subdivide() {
     halfX := q.size.X/2 
     halfY := q.size.Y/2 
     halfSize := rl.NewVector2(halfX, halfY)
 
-    q.nodes = []*quadnode{
+    q.nodes = []*quadtree{
         {
             pos: q.pos,
             size: halfSize,
             parent: q,
             magnet: nil,
+            debug: "topleft",
         },
         {
             pos: rl.NewVector2(q.pos.X + halfX, q.pos.Y),
             size: halfSize,
             parent: q,
             magnet: nil,
+            debug: "topright",
         },
         {
             pos: rl.NewVector2(q.pos.X, q.pos.Y + halfY),
             size: halfSize,
             parent: q,
             magnet: nil,
+            debug: "bottomleft",
         },
         {
             pos: rl.NewVector2(q.pos.X + halfX, q.pos.Y + halfY),
             size: halfSize,
             parent: q,
             magnet: nil,
+            debug: "bottomright",
         },
     }
 }
 
-func (q *quadnode) drawBoundaries() {
+func (q *quadtree) drawBoundaries() {
     if q.nodes == nil {
         return
     }
@@ -119,7 +127,7 @@ func (q *quadnode) drawBoundaries() {
 }
 
 // parâmetros
-const initalMagnetCount = 20
+const initalMagnetCount = 5
 const windowWidth = 700
 const windowHeight = 700
 const magnetRadius = 5 
@@ -184,6 +192,22 @@ func (m *magnet) update(magnets []*magnet) {
     m.pos = newPos
 }
 
+func (q *quadtree) parents() []*quadtree {
+    if q.parent == nil {
+        return nil
+    }
+    return append(q.parent.parents(), q.parent)
+}
+
+func (q *quadtree) printMagnets() {
+    for _, node := range q.nodes {
+        node.printMagnets()
+        if occupied, _ := node.isOccupied(); occupied {
+            fmt.Println(node.magnet.pos, node.parents())
+        }
+    }
+}
+
 func newMagnet(x, y, mass float32) *magnet {
     newMagnet := magnet{
         pos: rl.Vector2{X: x, Y: y},
@@ -199,6 +223,7 @@ func newMagnet(x, y, mass float32) *magnet {
     return &newMagnet
 }
 
+
 func randomMagnets(n int) []*magnet {
     var magnets []*magnet
 
@@ -219,10 +244,20 @@ func main() {
 	defer rl.CloseWindow()
 	rl.SetTargetFPS(60)
 
-    magnets := randomMagnets(initalMagnetCount)
+    // magnets := randomMagnets(initalMagnetCount)
+
+    magnets := []*magnet{
+        newMagnet(383, 130, 1),
+        newMagnet(540, 291, 1),
+        newMagnet(122, 490, 1),
+        newMagnet(324, 370, 1),
+        newMagnet(156, 482, 1),
+    }
 
     quadtree := newQuadTreeRoot()
     quadtree.insertMagnet(magnets...)
+    quadtree.printMagnets()
+    fmt.Println()
 
     pause := true
 
@@ -240,8 +275,10 @@ func main() {
         {
             if rl.IsKeyPressed(rl.KeyR) {
                 magnets = randomMagnets(initalMagnetCount)
-                quadtree := newQuadTreeRoot()
+                quadtree = newQuadTreeRoot()
                 quadtree.insertMagnet(magnets...)
+                quadtree.printMagnets()
+                fmt.Println()
             }
             if rl.IsKeyPressed(rl.KeyW) {
                 magnets = append(magnets, randomMagnets(100)...)