fix: enhance entry positioning with collision detection and fallback mechanism

Author: thatmlopsguy

mkdocs_tech_radar/templates/radar_inline.html

@@ -531,7 +531,11 @@ <h2>{{ title }}</h2>
                 .attr("fill", textPrimary);
         });
 
-        // Function to get position for an entry
+        // Function to get position for an entry with collision detection
+        const usedPositions = [];
+        const minDistance = 30; // Minimum distance between points
+        const maxAttempts = 50; // Maximum attempts to find a non-overlapping position
+
         function getEntryPosition(entry) {
             const quadrantIndex = entry.quadrant;
             const ringIndex = entry.ring;
@@ -540,13 +544,75 @@ <h2>{{ title }}</h2>
             const baseAngle = quadrantIndex * Math.PI / 2;
             const quadrantAngle = Math.PI / 2;
 
-            // Random angle within the quadrant
-            const angle = baseAngle + (Math.random() - 0.5) * quadrantAngle * 0.8;
+            // Calculate ring boundaries
+            const innerRadius = ringIndex > 0 ? ringRadii[ringIndex - 1] : 0;
+            const outerRadius = ringRadii[ringIndex];
+
+            let bestPosition = null;
+            let attempts = 0;
+
+            while (attempts < maxAttempts) {
+                // Generate random angle within the quadrant
+                const angle = baseAngle + (Math.random() - 0.5) * quadrantAngle * 0.8;
+
+                // Generate random radius within the ring
+                const entryRadius = innerRadius + (outerRadius - innerRadius) * (0.2 + Math.random() * 0.6);
+
+                const candidatePosition = {
+                    x: center.x + entryRadius * Math.cos(angle - Math.PI / 2),
+                    y: center.y + entryRadius * Math.sin(angle - Math.PI / 2)
+                };
+
+                // Check for collisions with existing positions
+                let hasCollision = false;
+                for (const usedPos of usedPositions) {
+                    const distance = Math.sqrt(
+                        Math.pow(candidatePosition.x - usedPos.x, 2) +
+                        Math.pow(candidatePosition.y - usedPos.y, 2)
+                    );
+                    if (distance < minDistance) {
+                        hasCollision = true;
+                        break;
+                    }
+                }
+
+                if (!hasCollision) {
+                    bestPosition = candidatePosition;
+                    break;
+                }
+
+                attempts++;
+            }
+
+            // If we couldn't find a collision-free position, use grid-based fallback
+            if (!bestPosition) {
+                bestPosition = getGridBasedPosition(quadrantIndex, ringIndex);
+            }
+
+            // Store the position for future collision detection
+            usedPositions.push(bestPosition);
+            return bestPosition;
+        }
+
+        // Fallback grid-based positioning for when collision detection fails
+        function getGridBasedPosition(quadrantIndex, ringIndex) {
+            const entriesInQuadrantRing = config.entries.filter(e =>
+                e.quadrant === quadrantIndex && e.ring === ringIndex
+            );
+            const entryIndex = entriesInQuadrantRing.length;
+
+            // Calculate angle for the quadrant
+            const baseAngle = quadrantIndex * Math.PI / 2;
+            const quadrantAngle = Math.PI / 2;
+
+            // Distribute entries evenly within the quadrant
+            const angleStep = quadrantAngle * 0.8 / Math.max(entriesInQuadrantRing.length + 1, 4);
+            const angle = baseAngle - quadrantAngle * 0.4 + angleStep * (entryIndex + 1);
 
-            // Random radius within the ring
+            // Calculate ring boundaries
             const innerRadius = ringIndex > 0 ? ringRadii[ringIndex - 1] : 0;
             const outerRadius = ringRadii[ringIndex];
-            const entryRadius = innerRadius + (outerRadius - innerRadius) * (0.2 + Math.random() * 0.6);
+            const entryRadius = innerRadius + (outerRadius - innerRadius) * 0.5;
 
             return {
                 x: center.x + entryRadius * Math.cos(angle - Math.PI / 2),