Introduce CartographySearchService_v2

This new search service conforms to the AlidadeSearchEngine protocol,
allowing it to inherit all the new features from it, including improved
query parsing. This should also help address ALD-22, as
AlidadeSearchEngine adds support for filtering by dimension.

Author: alicerunsonfedora

Alidade.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -8,7 +8,7 @@
       buildArchitectures = "Automatic">
       <BuildActionEntries>
          <BuildActionEntry
-            buildForTesting = "YES"
+            buildForTesting = "NO"
             buildForRunning = "YES"
             buildForProfiling = "YES"
             buildForArchiving = "YES"
@@ -27,25 +27,9 @@
       buildConfiguration = "Release"
       selectedDebuggerIdentifier = ""
       selectedLauncherIdentifier = "Xcode.IDEFoundation.Launcher.PosixSpawn"
-      shouldUseLaunchSchemeArgsEnv = "YES">
-      <TestPlans>
-         <TestPlanReference
-            reference = "container:AllTests.xctestplan"
-            default = "YES">
-         </TestPlanReference>
-      </TestPlans>
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      shouldAutocreateTestPlan = "YES">
       <Testables>
-         <TestableReference
-            skipped = "NO"
-            parallelizable = "YES">
-            <BuildableReference
-               BuildableIdentifier = "primary"
-               BlueprintIdentifier = "950402DF2D4D522200F51903"
-               BuildableName = "MCMapsTests.xctest"
-               BlueprintName = "MCMapsTests"
-               ReferencedContainer = "container:MCMaps.xcodeproj">
-            </BuildableReference>
-         </TestableReference>
          <TestableReference
             skipped = "NO"
             parallelizable = "YES">

MCMaps.xcodeproj/xcshareddata/xcschemes/Alidade.xcscheme

@@ -0,0 +1,25 @@
+//
+//  MinecraftWorldDimension+AlidadeSearchQuery.swift
+//  MCMaps
+//
+//  Created by Marquis Kurt on 19-10-2025.
+//
+
+import AlidadeSearchEngine
+import CubiomesKit
+
+extension MinecraftWorld.Dimension {
+    init?(query: AlidadeSearchQuery) {
+        guard let dimension = query.dimension else { return nil }
+        switch dimension.localizedLowercase {
+        case "overworld":
+            self = .overworld
+        case "nether":
+            self = .nether
+        case "end":
+            self = .end
+        default:
+            return nil
+        }
+    }
+}

MCMaps/Shared/Extensions/MinecraftWorldDimension+AlidadeSearchQuery.swift

@@ -10,6 +10,7 @@ import Foundation
 import MCMap
 
 /// A service that searches and filters content in Minecraft worlds and `.mcmap` files.
+@available(*, deprecated, message: "Use v2 of the search engine.")
 class CartographySearchService {
     /// The type of query used to initiate searches.
     typealias Query = String

MCMaps/Shared/Services/CartographySearchService.swift

@@ -0,0 +1,181 @@
+//
+//  CartographySearchService_v2.swift
+//  MCMaps
+//
+//  Created by Marquis Kurt on 19-10-2025.
+//
+
+import AlidadeSearchEngine
+import CubiomesKit
+import MCMap
+import Foundation
+
+class CartographySearchService_v2 {
+    struct Context: Sendable {
+        var world: MinecraftWorld
+        var file: CartographyMapFile
+        var position: MinecraftPoint = .zero
+        var dimension: MinecraftWorld.Dimension = .overworld
+    }
+
+    struct SearchResult: Sendable {
+        var pins: [CartographyMapPin] = []
+        var integratedData: [CartographyMapPin] = []
+        var biomes: [CartographyMapPin] = []
+        var structures: [CartographyMapPin] = []
+
+        var isEmpty: Bool {
+            [pins, integratedData, biomes, structures].allSatisfy(\.isEmpty)
+        }
+    }
+
+    private enum Constants {
+        static let defaultSearchRadius: Int32 = 20
+    }
+
+    var searchRadius: Int32 = Constants.defaultSearchRadius
+
+    init() {
+        self.searchRadius = Constants.defaultSearchRadius
+    }
+}
+
+extension CartographySearchService_v2: AlidadeSearchEngine {
+    func search(query: AlidadeSearchQuery, in context: Context) async -> SearchResult {
+        var results = SearchResult()
+        var position = context.position
+        var dimension = context.dimension
+        var integratedMarkers = [CartographyMapPin]()
+
+        if let origin = query.origin {
+            position = MinecraftPoint(cgPoint: origin)
+        }
+
+        if let translatedDim = MinecraftWorld.Dimension(query: query) {
+            dimension = translatedDim
+        }
+
+        if context.file.supportedFeatures.contains(.integrations), context.file.integrations.bluemap.enabled {
+            integratedMarkers.append(contentsOf: await getBluemapMarkers(in: context))
+        }
+
+        let playerPins = filterPins(context.file.pins, by: query)
+        let filteredMarkers = filterPins(integratedMarkers, by: query)
+        results.pins = playerPins
+        results.integratedData = filteredMarkers
+
+        if let structure = MinecraftStructure(string: query.request) {
+            searchStructures(at: position, context, structure, dimension, &results)
+        }
+
+        results.biomes = searchBiomes(
+            query: query.request,
+            mcVersion: context.file.manifest.worldSettings.version,
+            world: context.world,
+            pos: position,
+            dimension: dimension
+        )
+
+        return results
+    }
+
+    private func getBluemapMarkers(in context: Context) async -> [CartographyMapPin] {
+        let service = CartographyIntegrationService(
+            serviceType: .bluemap,
+            integrationSettings: context.file.integrations)
+        do {
+            let results: BluemapResults? = try await service.sync(dimension: context.dimension)
+            guard let markers = results?.markers else {
+                return []
+            }
+            let allMarkers = markers.map(\.value)
+            return allMarkers.flatMap { group in
+                group.markers.map { (id, marker) in
+                    CartographyMapPin(
+                        named: marker.label,
+                        at: CGPoint(x: marker.position.x, y: marker.position.z),
+                        color: .gray,
+                        alternateIDs: [id]
+                    )
+                }
+            }
+        } catch {
+            return []
+        }
+    }
+
+    private func filterPins(_ pins: [CartographyMapPin], by query: AlidadeSearchQuery) -> [CartographyMapPin] {
+        var newPins = [CartographyMapPin]()
+        for pin in pins {
+            let nameMatches = pin.name.lowercased().contains(query.request.lowercased())
+            if !query.tags.isEmpty, let tags = pin.tags {
+                if tags.isDisjoint(with: query.tags) { continue }
+                if !nameMatches, !query.request.isEmpty { continue }
+                newPins.append(pin)
+                continue
+            }
+
+            if !nameMatches { continue }
+            newPins.append(pin)
+        }
+        return newPins
+    }
+
+    private func searchBiomes(
+        query: String, mcVersion: String, world: MinecraftWorld, pos: Point3D<Int32>,
+        dimension: MinecraftWorld.Dimension
+    ) -> [CartographyMapPin] {
+        guard let biome = MinecraftBiome(localizedString: query, mcVersion: mcVersion) else {
+            return []
+        }
+        let foundBiomes = world.findBiomes(
+            ofType: biome,
+            at: pos,
+            inRadius: 8000,
+            dimension: dimension
+        )
+        let name = biome.localizedString(for: world.version)
+        var biomes = foundBiomes.map { foundBiome in
+            CartographyMapPin(
+                named: name,
+                at: CGPoint(x: Double(foundBiome.x), y: Double(foundBiome.z)))
+        }
+
+        let cgPointOrigin = CGPoint(x: Double(pos.x), y: Double(pos.z))
+        biomes.sort { first, second in
+            first.position
+                .manhattanDistance(to: cgPointOrigin) < second.position.manhattanDistance(to: cgPointOrigin)
+        }
+        return biomes
+    }
+
+    private func searchStructures(
+        at position: MinecraftPoint,
+        _ context: Context,
+        _ structure: MinecraftStructure,
+        _ dimension: MinecraftWorld.Dimension,
+        _ results: inout SearchResult
+    ) {
+        let foundStructures = context.world.findStructures(
+            ofType: structure,
+            at: position,
+            inRadius: searchRadius,
+            dimension: dimension
+        )
+        for foundStruct in foundStructures {
+            results.structures
+                .append(
+                    CartographyMapPin(
+                        named: structure.name,
+                        at: CGPoint(x: Double(foundStruct.x), y: Double(foundStruct.z)),
+                        color: structure.pinColor)
+                )
+        }
+
+        let cgPointOrigin = CGPoint(minecraftPoint: context.position)
+        results.structures.sort { first, second in
+            first.position
+                .manhattanDistance(to: cgPointOrigin) < second.position.manhattanDistance(to: cgPointOrigin)
+        }
+    }
+}

MCMaps/Shared/Services/CartographySearchService_v2.swift

@@ -0,0 +1,117 @@
+//
+//  CartographySearchServiceV2Tests.swift
+//  MCMaps
+//
+//  Created by Marquis Kurt on 19-10-2025.
+//
+
+import AlidadeSearchEngine
+import CubiomesKit
+import Foundation
+import MCMap
+import Testing
+
+@testable import Alidade
+
+struct CartographySearchServiceV2Tests {
+    typealias SearchContext = CartographySearchService_v2.Context
+
+    @Test("Empty query")
+    func searchReturnsNoResultsOnEmptyQuery() async throws {
+        let world = try MinecraftWorld(version: "1.21.3", seed: 123)
+        let file = CartographyMapFile(withManifest: .sampleFile)
+        let service = CartographySearchService_v2()
+
+        let results = await service.search(query: "", in: SearchContext(world: world, file: file))
+        #expect(results.isEmpty)
+    }
+
+    @Test(arguments: ["Spawn", "spawn", "Spa", "awn"])
+    func searchReturnsPinsByName(query: AlidadeSearchQuery) async throws {
+        let world = try MinecraftWorld(version: "1.21.3", seed: 123)
+        let file = CartographyMapFile(withManifest: .sampleFile)
+        let service = CartographySearchService_v2()
+
+        let results = await service.search(query: query, in: SearchContext(world: world, file: file))
+        #expect(results.pins.count == 1)
+        #expect(results.pins.first?.name == "Spawn")
+        #expect(results.pins.first?.position == .zero)
+    }
+
+    @Test(arguments: ["#Tag test", "#Tag"])
+    func searchReturnsPinsWithTag(query: AlidadeSearchQuery) async throws {
+        let world = try MinecraftWorld(version: "1.21.3", seed: 123)
+        var file = CartographyMapFile(withManifest: .sampleFile)
+        let service = CartographySearchService_v2()
+
+        file.pins.append(contentsOf: [
+            CartographyMapPin(named: "Testing", at: CGPoint(x: 12, y: 12), tags: ["Tag", "Forest"]),
+            CartographyMapPin(named: "Testing Grounds", at: CGPoint(x: 10, y: 10), tags: ["Base"]),
+            CartographyMapPin(named: "Test Test", at: CGPoint(x: 11, y: 11), tags: ["Tag"])
+        ])
+
+        let results = await service.search(query: query, in: SearchContext(world: world, file: file))
+        #expect(results.pins.count == 2)
+        #expect(results.pins.allSatisfy { $0.tags?.contains("Tag") != false })
+    }
+
+    @Test func searchReturnsNearbyStructures() async throws {
+        let world = try MinecraftWorld(version: "1.21.3", seed: 123)
+        let file = CartographyMapFile(withManifest: .sampleFile)
+        let service = CartographySearchService_v2()
+
+        let results = await service.search(
+            query: "mineshaft",
+            in: SearchContext(
+                world: world,
+                file: file,
+                position: MinecraftPoint(x: 113, y: 15, z: 430)))
+        #expect(results.structures.count == 11)
+        #expect(results.structures.allSatisfy { $0.name == "Mineshaft" })
+    }
+
+    @Test func searchReturnsNearbyBiomes() async throws {
+        let world = try MinecraftWorld(version: "1.21.3", seed: 123)
+        let file = CartographyMapFile(withManifest: .sampleFile)
+        let service = CartographySearchService_v2()
+        let results = await service.search(
+            query: "Frozen River",
+            in: SearchContext(world: world, file: file, position: .zero))
+        #expect(!results.biomes.isEmpty)
+    }
+
+    @Test func searchReturnsNearbyBiomesRelativeToFilteredOrigin() async throws {
+        let world = try MinecraftWorld(version: "1.21.3", seed: 123)
+        let file = CartographyMapFile(withManifest: .sampleFile)
+        let service = CartographySearchService_v2()
+        let context = SearchContext(world: world, file: file, position: .zero)
+
+        let originResults = await service.search(query: "Frozen River", in: context)
+        
+        let results = await service.search(
+            query: "Frozen River @{1000, 1000}",
+            in: context)
+
+        #expect(originResults.biomes.map(\.position) != results.biomes.map(\.position))
+    }
+
+    @Test func searchReturnsBiomeResultsRelativeToDimensionInQuery() async throws {
+        let world = try MinecraftWorld(version: "1.21.3", seed: 123)
+        let file = CartographyMapFile(withManifest: .sampleFile)
+        let service = CartographySearchService_v2()
+        let context = SearchContext(world: world, file: file, position: .zero, dimension: .nether)
+
+        let results = await service.search(query: "dimension: Overworld Frozen River", in: context)
+        #expect(!results.isEmpty)
+    }
+
+    @Test func searchReturnsStructureResultsRelativeToDimensionInQuery() async throws {
+        let world = try MinecraftWorld(version: "1.21.3", seed: 123)
+        let file = CartographyMapFile(withManifest: .sampleFile)
+        let service = CartographySearchService_v2()
+        let context = SearchContext(world: world, file: file, position: .zero, dimension: .overworld)
+
+        let results = await service.search(query: "dimension: Nether Bastion", in: context)
+        #expect(!results.isEmpty)
+    }
+}