Search for Bluemap markers (#44)

Closes #44.

Author: alicerunsonfedora

MCMaps/Legacy/Views/Sidebar/CartographyMapSidebar.swift

@@ -113,6 +113,15 @@ struct CartographyMapSidebar: View {
                 PinnedLibrarySection(pins: results.pins, viewModel: $viewModel, file: $file)
             }
 
+            if !results.integratedData.isEmpty {
+                GroupedPinsSection(
+                    name: "From Integrations",
+                    pins: results.integratedData,
+                    viewModel: $viewModel,
+                    file: $file
+                )
+            }
+
             GroupedPinsSection(
                 pins: results.structures,
                 viewModel: $viewModel,

MCMaps/Red Window/Routing/RedWindowRoute.swift

@@ -62,7 +62,7 @@ extension RedWindowRoute {
         case .allPins: "All Pins"
         case .allPinsCompact: "Library"
         case .search: "Search"
-        case let .pin(pin): "Pin"
+        case .pin: "Pin"
         }
     }
 

MCMaps/Red Window/Views/Search/RedWindowSearchLandmarkResultCell.swift

@@ -25,12 +25,15 @@ struct RedWindowSearchLandmarkResultCell: View {
         /// The landmark represents a player-created pin.
         case pin
 
+        /// The landmark represents a pin pulled from integrations.
+        case integratedPin
+
         /// A symbol representation for the landmark.
         var symbol: String {
             switch self {
             case .biome: "mountain.2"
             case .structure: "building.2.crop.circle"
-            case .pin: "mappin"
+            case .pin, .integratedPin: "mappin"
             }
         }
     }

MCMaps/Red Window/Views/Search/RedWindowSearchView.swift

@@ -93,7 +93,6 @@ struct RedWindowSearchView: View {
     }
 
     private func resultList(for result: CartographySearchService.SearchResult) -> some View {
-        let currentLoc = redWindowEnvironment.mapCenterCoordinate
         return List {
             Section {
                 ForEach(result.pins) { pin in
@@ -105,31 +104,57 @@ struct RedWindowSearchView: View {
             } header: {
                 Text("Your Pinned Places")
             }
-            Section {
-                ForEach(result.biomes) { biome in
-                    RedWindowSearchLandmarkResultCell(
-                        request: $pinCreationRequest,
-                        landmark: biome,
-                        landmarkType: .biome
-                    )
-                }
-                ForEach(result.structures) { structure in
-                    RedWindowSearchLandmarkResultCell(
-                        request: $pinCreationRequest,
-                        landmark: structure,
-                        landmarkType: .structure
-                    )
-                }
-                if result.structures.isEmpty, result.biomes.isEmpty {
-                    ContentUnavailableView.search(text: query)
-                }
-            } header: {
-                Text("Biomes and Structures")
-            } footer: {
-                Text(
-                    "Relative where you are on the map (\(currentLoc.accessibilityReadout))."
+            if file.integrations.enabled {
+                integratedSection(data: result.integratedData)
+            }
+            biomesAndStructures(result: result)
+        }
+    }
+
+    private func integratedSection(data: [CartographyMapPin]) -> some View {
+        Section {
+            ForEach(data) { pin in
+                RedWindowSearchLandmarkResultCell(
+                    request: $pinCreationRequest,
+                    landmark: pin,
+                    landmarkType: .integratedPin
                 )
             }
+            if data.isEmpty {
+                ContentUnavailableView.search(text: query)
+            }
+        } header: {
+            Text("From Integrations")
+        }
+    }
+
+    private func biomesAndStructures(result: CartographySearchService.SearchResult) -> some View {
+        let currentLoc = redWindowEnvironment.mapCenterCoordinate
+
+        return Section {
+            ForEach(result.biomes) { biome in
+                RedWindowSearchLandmarkResultCell(
+                    request: $pinCreationRequest,
+                    landmark: biome,
+                    landmarkType: .biome
+                )
+            }
+            ForEach(result.structures) { structure in
+                RedWindowSearchLandmarkResultCell(
+                    request: $pinCreationRequest,
+                    landmark: structure,
+                    landmarkType: .structure
+                )
+            }
+            if result.structures.isEmpty, result.biomes.isEmpty {
+                ContentUnavailableView.search(text: query)
+            }
+        } header: {
+            Text("Biomes and Structures")
+        } footer: {
+            Text(
+                "Relative where you are on the map (\(currentLoc.accessibilityReadout))."
+            )
         }
     }
 }

MCMaps/Resources/Alidade.docc/Changelogs/Changelog-Unreleased.md

@@ -25,6 +25,7 @@ time as new versions and features are added.
 - Players can now enable Realtime Sync for Bluemap to get realtime updates
   for player locations. Server and death markers sync independently of
   players.
+- Players can now search for markers from Bluemap in the search views.
 
 ### Map
 

MCMaps/Resources/AppIcon-RedWindow.icon/icon.json

@@ -2,14 +2,15 @@
   "color-space-for-untagged-svg-colors" : "display-p3",
   "fill" : {
     "linear-gradient" : [
-      "srgb:0.41233,0.61333,0.72654,1.00000",
-      "srgb:0.16708,0.40676,0.52647,1.00000"
+      "srgb:0.24121,0.62164,0.72654,1.00000",
+      "srgb:0.10620,0.36519,0.52647,1.00000"
     ]
   },
   "groups" : [
     {
       "layers" : [
         {
+          "glass" : true,
           "image-name" : "Icon-2.png",
           "name" : "Icon-2",
           "position" : {
@@ -21,10 +22,13 @@
           }
         },
         {
+          "blend-mode" : "normal",
+          "fill" : "none",
           "glass" : true,
           "hidden" : false,
           "image-name" : "Icon.png",
           "name" : "Icon",
+          "opacity" : 0.8,
           "position-specializations" : [
             {
               "value" : {

MCMaps/Resources/Localizable.xcstrings

@@ -218,6 +218,9 @@
     },
     "From Finder" : {
 
+    },
+    "From Integrations" : {
+
     },
     "From Photos" : {
 

MCMaps/Shared/Services/CartographySearchService.swift

@@ -6,8 +6,8 @@
 //
 
 import CubiomesKit
-import MCMap
 import Foundation
+import MCMap
 
 /// A service that searches and filters content in Minecraft worlds and `.mcmap` files.
 class CartographySearchService {
@@ -34,6 +34,9 @@ class CartographySearchService {
         /// The pins that matched a given query.
         var pins: [CartographyMapPin]
 
+        /// The integration data that matched a given query.
+        var integratedData: [CartographyMapPin]
+
         /// The coordinates that matched a given query.
         ///
         /// This is typically populated when the query represents a coordinate that can be quickly jumped to, such as
@@ -48,14 +51,15 @@ class CartographySearchService {
 
         /// Whether the search results are completely empty.
         var isEmpty: Bool {
-            pins.isEmpty && coordinates.isEmpty && structures.isEmpty && biomes.isEmpty
+            pins.isEmpty && coordinates.isEmpty && structures.isEmpty && biomes.isEmpty && integratedData.isEmpty
         }
 
         init() {
             self.pins = []
             self.coordinates = []
             self.structures = []
             self.biomes = []
+            self.integratedData = []
         }
     }
 
@@ -80,48 +84,25 @@ class CartographySearchService {
     /// - Parameter filters: The filters to apply in this search.
     func search(for query: Query, in context: SearchContext, filters: SearchFilterGroup? = nil) async -> SearchResult {
         var results = SearchResult()
+        var integratedMarkers = [CartographyMapPin]()
+
+        if context.file.supportedFeatures.contains(.integrations), context.file.integrations.bluemap.enabled {
+            integratedMarkers.append(contentsOf: await getBluemapMarkers(in: context))
+        }
 
         if let matches = query.matches(of: Constants.coordinateRegex).first?.output {
             if let x = Double(matches.1), let y = Double(matches.2) {
                 results.coordinates.append(CGPoint(x: x, y: y))
             }
         }
 
-        for pin in context.file.pins {
-            let nameMatches = pin.name.lowercased().contains(query.lowercased())
-            if let filters = filters, !filters.isEmpty {
-                if filters.matchTags(for: pin).isEmpty { continue }
-                if !nameMatches, !query.isEmpty { continue }
-                results.pins.append(pin)
-                continue
-            }
-
-            if !nameMatches { continue }
-            results.pins.append(pin)
-        }
+        let playerPins = filterPins(context.file.pins, by: query, filters: filters)
+        let filteredMarkers = filterPins(integratedMarkers, by: query, filters: filters)
+        results.pins = playerPins
+        results.integratedData = filteredMarkers
 
         if let structure = MinecraftStructure(string: query) {
-            let foundStructures = context.world.findStructures(
-                ofType: structure,
-                at: context.position,
-                inRadius: searchRadius,
-                dimension: context.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)
-            }
+            searchStructures(context, structure, &results)
         }
 
         results.biomes = searchBiomes(
@@ -135,6 +116,51 @@ class CartographySearchService {
         return results
     }
 
+    private func getBluemapMarkers(in context: SearchContext) 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 { (_, marker) in
+                    CartographyMapPin(
+                        named: marker.label,
+                        at: CGPoint(x: marker.position.x, y: marker.position.z),
+                        color: .gray
+                    )
+                }
+            }
+        } catch {
+            return []
+        }
+    }
+
+    private func filterPins(
+        _ pins: [CartographyMapPin],
+        by query: Query,
+        filters: SearchFilterGroup? = nil
+    ) -> [CartographyMapPin] {
+        var newPins = [CartographyMapPin]()
+        for pin in pins {
+            let nameMatches = pin.name.lowercased().contains(query.lowercased())
+            if let filters = filters, !filters.isEmpty {
+                if filters.matchTags(for: pin).isEmpty { continue }
+                if !nameMatches, !query.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
@@ -162,4 +188,32 @@ class CartographySearchService {
         }
         return biomes
     }
+
+    private func searchStructures(
+        _ context: SearchContext,
+        _ structure: MinecraftStructure,
+        _ results: inout SearchResult
+    ) {
+        let foundStructures = context.world.findStructures(
+            ofType: structure,
+            at: context.position,
+            inRadius: searchRadius,
+            dimension: context.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)
+        }
+    }
 }