Merge branch 'main' of https://git.ranaze.com/null/promiscuity into main

game/scenes/Levels/location_level.gd

@@ -33,7 +33,7 @@ var _coord_sync_in_flight := false
 var _queued_coord_sync: Variant = null
 var _locations_refresh_in_flight := false
 var _queued_locations_refresh := false
-var _gather_in_flight := false
+var _interact_in_flight := false
 
 
 func _ready() -> void:
@@ -74,7 +74,7 @@ func _process(_delta: float) -> void:
 
 func _unhandled_input(event: InputEvent) -> void:
 	if event.is_action_pressed("interact"):
-		_try_gather_current_tile()
+		_try_interact_current_tile()
 
 
 func _get_stream_position() -> Vector3:
@@ -110,9 +110,11 @@ func _rebuild_tiles(center: Vector2i) -> void:
 			if not _known_locations.has(coord):
 				continue
 			wanted_keys[coord] = true
+			var location_data := _known_locations[coord] as Dictionary
 			if _tile_nodes.has(coord):
+				_update_tile(coord, location_data)
 				continue
-			_spawn_tile(coord, _get_location_name(coord), _get_location_biome_key(coord))
+			_spawn_tile(coord, location_data)
 
 	for key in _tile_nodes.keys():
 		if wanted_keys.has(key):
@@ -123,7 +125,7 @@ func _rebuild_tiles(center: Vector2i) -> void:
 		_tile_nodes.erase(key)
 
 
-func _spawn_tile(coord: Vector2i, location_name: String, biome_key: String) -> void:
+func _spawn_tile(coord: Vector2i, location_data: Dictionary) -> void:
 	var tile_root := Node3D.new()
 	tile_root.name = "Tile_%d_%d" % [coord.x, coord.y]
 	tile_root.position = _coord_to_world(coord)
@@ -142,6 +144,7 @@ func _spawn_tile(coord: Vector2i, location_name: String, biome_key: String) -> v
 	var tile := _block.duplicate() as MeshInstance3D
 	tile.name = "TileMesh"
 	tile.visible = true
+	var biome_key := String(location_data.get("biomeKey", "plains")).strip_edges()
 	var biome_material := _get_biome_material(tile, biome_key)
 	if biome_material:
 		tile.material_override = biome_material
@@ -149,11 +152,60 @@ func _spawn_tile(coord: Vector2i, location_name: String, biome_key: String) -> v
 
 	tile.add_child(_create_tile_border())
 	if show_tile_labels:
-		tile_root.add_child(_create_tile_label(location_name))
+		tile_root.add_child(_create_tile_label(String(location_data.get("name", ""))))
+	_update_tile_object(tile_root, location_data)
 
 	_tile_nodes[coord] = tile_root
 
 
+func _update_tile(coord: Vector2i, location_data: Dictionary) -> void:
+	var tile_root := _tile_nodes.get(coord) as Node3D
+	if tile_root == null:
+		return
+
+	if show_tile_labels:
+		var label := tile_root.get_node_or_null("LocationNameLabel") as Label3D
+		if label:
+			label.text = String(location_data.get("name", ""))
+
+	_update_tile_object(tile_root, location_data)
+
+
+func _update_tile_object(tile_root: Node3D, location_data: Dictionary) -> void:
+	var existing := tile_root.get_node_or_null("LocationObject")
+	if existing:
+		existing.queue_free()
+
+	var object_data_variant: Variant = location_data.get("locationObject", {})
+	if typeof(object_data_variant) != TYPE_DICTIONARY:
+		return
+
+	var object_data := object_data_variant as Dictionary
+	if object_data.is_empty():
+		return
+
+	var object_root := Node3D.new()
+	object_root.name = "LocationObject"
+	object_root.position = Vector3(0.0, (block_height * 0.5) + 0.6, 0.0)
+	tile_root.add_child(object_root)
+
+	var object_mesh := MeshInstance3D.new()
+	object_mesh.name = "ObjectMesh"
+	object_mesh.mesh = SphereMesh.new()
+	object_mesh.scale = Vector3(0.6, 0.4, 0.6)
+	object_mesh.material_override = _create_object_material(String(object_data.get("objectKey", "")))
+	object_root.add_child(object_mesh)
+
+	var object_label := Label3D.new()
+	object_label.name = "ObjectLabel"
+	object_label.text = _build_object_label(object_data)
+	object_label.position = Vector3(0.0, 0.6, 0.0)
+	object_label.billboard = BaseMaterial3D.BILLBOARD_ENABLED
+	object_label.pixel_size = 0.01
+	object_label.outline_size = 10
+	object_root.add_child(object_label)
+
+
 func _create_tile_border() -> MeshInstance3D:
 	var top_y := 0.5 + border_height_bias
 	var corners := [
@@ -204,6 +256,34 @@ func _create_tile_label(location_name: String) -> Label3D:
 	return label
 
 
+func _create_object_material(object_key: String) -> StandardMaterial3D:
+	var material := StandardMaterial3D.new()
+	material.roughness = 1.0
+	material.metallic = 0.0
+
+	if object_key.contains("grass"):
+		material.albedo_color = Color(0.28, 0.68, 0.25, 1.0)
+	elif object_key.contains("wood"):
+		material.albedo_color = Color(0.54, 0.36, 0.18, 1.0)
+	elif object_key.contains("stone"):
+		material.albedo_color = Color(0.55, 0.57, 0.6, 1.0)
+	else:
+		material.albedo_color = Color(0.85, 0.75, 0.3, 1.0)
+
+	return material
+
+
+func _build_object_label(object_data: Dictionary) -> String:
+	var object_name := String(object_data.get("name", "")).strip_edges()
+	var state_variant: Variant = object_data.get("state", {})
+	var remaining_quantity := 0
+	if typeof(state_variant) == TYPE_DICTIONARY:
+		remaining_quantity = int((state_variant as Dictionary).get("remainingQuantity", 0))
+	if object_name.is_empty():
+		object_name = "Object"
+	return "%s x%d" % [object_name, remaining_quantity]
+
+
 func _ensure_selected_location_exists(coord: Vector2i) -> void:
 	if _known_locations.has(coord):
 		return
@@ -211,7 +291,7 @@ func _ensure_selected_location_exists(coord: Vector2i) -> void:
 		"id": "",
 		"name": _selected_location_name(coord),
 		"biomeKey": "plains",
-		"resources": []
+		"locationObject": {}
 	}
 
 
@@ -233,6 +313,7 @@ func _load_existing_locations() -> void:
 	if _character_id.is_empty():
 		push_warning("Selected character is missing an id; cannot load visible locations.")
 		_locations_loaded = true
+		_locations_refresh_in_flight = false
 		return
 
 	var request := HTTPRequest.new()
@@ -247,6 +328,7 @@ func _load_existing_locations() -> void:
 		push_warning("Failed to request visible locations: %s" % err)
 		request.queue_free()
 		_locations_loaded = true
+		_locations_refresh_in_flight = false
 		return
 
 	var result: Array = await request.request_completed
@@ -258,12 +340,14 @@ func _load_existing_locations() -> void:
 	if result_code != HTTPRequest.RESULT_SUCCESS or response_code < 200 or response_code >= 300:
 		push_warning("Failed to load visible locations (%s/%s): %s" % [result_code, response_code, response_body])
 		_locations_loaded = true
+		_locations_refresh_in_flight = false
 		return
 
 	var parsed: Variant = JSON.parse_string(response_body)
 	if typeof(parsed) != TYPE_ARRAY:
 		push_warning("Visible locations response was not an array.")
 		_locations_loaded = true
+		_locations_refresh_in_flight = false
 		return
 
 	var loaded_count := 0
@@ -283,7 +367,7 @@ func _load_existing_locations() -> void:
 			"id": String(location.get("id", "")).strip_edges(),
 			"name": location_name,
 			"biomeKey": String(location.get("biomeKey", "plains")).strip_edges(),
-			"resources": _parse_location_resources(location.get("resources", []))
+			"locationObject": _parse_location_object(location.get("locationObject", {}))
 		}
 		loaded_count += 1
 
@@ -316,6 +400,102 @@ func _refresh_visible_locations_async() -> void:
 	await _load_existing_locations()
 
 
+func _try_interact_current_tile() -> void:
+	if _interact_in_flight:
+		return
+	if _character_id.is_empty():
+		return
+
+	var location_data: Dictionary = _known_locations.get(_center_coord, {})
+	if location_data.is_empty():
+		push_warning("No known location data for %s." % _center_coord)
+		return
+
+	var location_id := String(location_data.get("id", "")).strip_edges()
+	if location_id.is_empty():
+		push_warning("Current location is missing an id.")
+		return
+
+	var object_data: Dictionary = location_data.get("locationObject", {})
+	if object_data.is_empty():
+		push_warning("Current location has no interactable object.")
+		return
+
+	var object_id := String(object_data.get("id", "")).strip_edges()
+	if object_id.is_empty():
+		push_warning("Current location object is missing an id.")
+		return
+
+	_interact_in_flight = true
+	_interact_with_location_async(location_id, object_id)
+
+
+func _interact_with_location_async(location_id: String, object_id: String) -> void:
+	var request := HTTPRequest.new()
+	add_child(request)
+
+	var headers := PackedStringArray()
+	if not AuthState.access_token.is_empty():
+		headers.append("Authorization: Bearer %s" % AuthState.access_token)
+	headers.append("Content-Type: application/json")
+
+	var body := JSON.stringify({
+		"characterId": _character_id,
+		"objectId": object_id
+	})
+	var err := request.request("%s/%s/interact" % [LOCATION_API_URL, location_id], headers, HTTPClient.METHOD_POST, body)
+	if err != OK:
+		push_warning("Failed to send location interaction request: %s" % err)
+		request.queue_free()
+		_interact_in_flight = false
+		return
+
+	var result: Array = await request.request_completed
+	request.queue_free()
+
+	var result_code: int = result[0]
+	var response_code: int = result[1]
+	var response_body: String = result[3].get_string_from_utf8()
+	if result_code != HTTPRequest.RESULT_SUCCESS or response_code < 200 or response_code >= 300:
+		push_warning("Location interaction failed (%s/%s): %s" % [result_code, response_code, response_body])
+		_interact_in_flight = false
+		return
+
+	var parsed: Variant = JSON.parse_string(response_body)
+	if typeof(parsed) != TYPE_DICTIONARY:
+		push_warning("Location interaction response was not an object.")
+		_interact_in_flight = false
+		return
+
+	var interaction := parsed as Dictionary
+	_apply_interaction_result(location_id, interaction)
+	_interact_in_flight = false
+
+
+func _apply_interaction_result(location_id: String, interaction: Dictionary) -> void:
+	var consumed := bool(interaction.get("consumed", false))
+	var remaining_quantity := int(interaction.get("remainingQuantity", 0))
+
+	for coord_variant in _known_locations.keys():
+		var coord: Vector2i = coord_variant
+		var location_data: Dictionary = _known_locations[coord]
+		if String(location_data.get("id", "")) != location_id:
+			continue
+
+		var updated_location := location_data.duplicate(true)
+		if consumed:
+			updated_location["locationObject"] = {}
+		else:
+			var object_data: Dictionary = updated_location.get("locationObject", {})
+			var state: Dictionary = object_data.get("state", {})
+			state["remainingQuantity"] = remaining_quantity
+			object_data["state"] = state
+			updated_location["locationObject"] = object_data
+		_known_locations[coord] = updated_location
+		_update_tile(coord, updated_location)
+		return
+
+
 func _queue_coord_sync(coord: Vector2i) -> void:
 	if coord == _persisted_coord:
 		return
@@ -353,80 +533,6 @@ func _sync_character_coord_async(coord: Vector2i) -> void:
 		_sync_character_coord(queued_coord)
 
 
-func _try_gather_current_tile() -> void:
-	if _gather_in_flight:
-		return
-	var location_data := _get_location_data(_center_coord)
-	if location_data.is_empty():
-		push_warning("No location data available for current tile.")
-		return
-	var location_id := String(location_data.get("id", "")).strip_edges()
-	if location_id.is_empty():
-		push_warning("Current tile has no location id; cannot gather.")
-		return
-	var resources: Array = location_data.get("resources", [])
-	if resources.is_empty():
-		push_warning("No gatherable resources remain at this location.")
-		return
-	var resource: Dictionary = resources[0]
-	var resource_key := String(resource.get("itemKey", "")).strip_edges()
-	if resource_key.is_empty():
-		push_warning("Current location resource is missing an itemKey.")
-		return
-	_gather_current_tile(location_id, resource_key)
-
-
-func _gather_current_tile(location_id: String, resource_key: String) -> void:
-	_gather_in_flight = true
-	_gather_current_tile_async(location_id, resource_key)
-
-
-func _gather_current_tile_async(location_id: String, resource_key: String) -> void:
-	var request := HTTPRequest.new()
-	add_child(request)
-
-	var headers := PackedStringArray()
-	if not AuthState.access_token.is_empty():
-		headers.append("Authorization: Bearer %s" % AuthState.access_token)
-	headers.append("Content-Type: application/json")
-
-	var body := JSON.stringify({
-		"characterId": _character_id,
-		"resourceKey": resource_key
-	})
-
-	var err := request.request("%s/%s/gather" % [LOCATION_API_URL, location_id], headers, HTTPClient.METHOD_POST, body)
-	if err != OK:
-		push_warning("Failed to request gather action: %s" % err)
-		request.queue_free()
-		_gather_in_flight = false
-		return
-
-	var result: Array = await request.request_completed
-	request.queue_free()
-
-	var result_code: int = result[0]
-	var response_code: int = result[1]
-	var response_body: String = result[3].get_string_from_utf8()
-	if result_code != HTTPRequest.RESULT_SUCCESS or response_code < 200 or response_code >= 300:
-		push_warning("Failed to gather resource (%s/%s): %s" % [result_code, response_code, response_body])
-		_gather_in_flight = false
-		return
-
-	var parsed: Variant = JSON.parse_string(response_body)
-	if typeof(parsed) != TYPE_DICTIONARY:
-		push_warning("Gather response was not a dictionary.")
-		_gather_in_flight = false
-		return
-
-	var gather_response := parsed as Dictionary
-	var remaining_quantity := int(gather_response.get("remainingQuantity", 0))
-	var quantity_granted := int(gather_response.get("quantityGranted", 0))
-	_update_location_resource(_center_coord, resource_key, remaining_quantity)
-	print("Gathered %s x%s at %s." % [resource_key, quantity_granted, _center_coord])
-	_gather_in_flight = false
-
-
 func _get_location_data(coord: Vector2i) -> Dictionary:
 	var value: Variant = _known_locations.get(coord, {})
 	if typeof(value) == TYPE_DICTIONARY:
@@ -434,48 +540,28 @@ func _get_location_data(coord: Vector2i) -> Dictionary:
 	return {}
 
 
-func _get_location_name(coord: Vector2i) -> String:
+func _parse_location_object(value: Variant) -> Dictionary:
-	var location_data := _get_location_data(coord)
+	if typeof(value) != TYPE_DICTIONARY:
-	return String(location_data.get("name", "Location %d,%d" % [coord.x, coord.y]))
+		return {}
 
+	var object_data := value as Dictionary
+	var state_value: Variant = object_data.get("state", {})
+	var state: Dictionary = {}
+	if typeof(state_value) == TYPE_DICTIONARY:
+		var raw_state := state_value as Dictionary
+		state = {
+			"itemKey": String(raw_state.get("itemKey", "")).strip_edges(),
+			"remainingQuantity": int(raw_state.get("remainingQuantity", 0)),
+			"gatherQuantity": int(raw_state.get("gatherQuantity", 1))
+		}
 
-func _get_location_biome_key(coord: Vector2i) -> String:
+	return {
-	var location_data := _get_location_data(coord)
+		"id": String(object_data.get("id", "")).strip_edges(),
-	return String(location_data.get("biomeKey", "plains")).strip_edges()
+		"objectType": String(object_data.get("objectType", "")).strip_edges(),
-
+		"objectKey": String(object_data.get("objectKey", "")).strip_edges(),
-
+		"name": String(object_data.get("name", "")).strip_edges(),
-func _parse_location_resources(resources_value: Variant) -> Array:
+		"state": state
-	var results: Array = []
+	}
-	if typeof(resources_value) != TYPE_ARRAY:
-		return results
-	for entry in resources_value:
-		if typeof(entry) != TYPE_DICTIONARY:
-			continue
-		var resource := entry as Dictionary
-		results.append({
-			"itemKey": String(resource.get("itemKey", "")).strip_edges(),
-			"remainingQuantity": int(resource.get("remainingQuantity", 0)),
-			"gatherQuantity": int(resource.get("gatherQuantity", 1))
-		})
-	return results
-
-
-func _update_location_resource(coord: Vector2i, resource_key: String, remaining_quantity: int) -> void:
-	var location_data := _get_location_data(coord)
-	if location_data.is_empty():
-		return
-	var resources: Array = location_data.get("resources", [])
-	var updated_resources: Array = []
-	for entry in resources:
-		if typeof(entry) != TYPE_DICTIONARY:
-			continue
-		var resource := (entry as Dictionary).duplicate()
-		if String(resource.get("itemKey", "")).strip_edges() == resource_key:
-			resource["remainingQuantity"] = remaining_quantity
-		if int(resource.get("remainingQuantity", 0)) > 0:
-			updated_resources.append(resource)
-	location_data["resources"] = updated_resources
-	_known_locations[coord] = location_data
 
 
 func _get_biome_material(tile: MeshInstance3D, biome_key: String) -> Material:

microservices/CharacterApi/Models/VisibleLocation.cs

@@ -19,6 +19,6 @@ public class VisibleLocation
     [BsonElement("biomeKey")]
     public string BiomeKey { get; set; } = "plains";
 
-    [BsonElement("resources")]
+    [BsonElement("locationObject")]
-    public List<VisibleLocationResource> Resources { get; set; } = [];
+    public VisibleLocationObject? LocationObject { get; set; }
 }

microservices/CharacterApi/Models/VisibleLocationObject.cs

@@ -0,0 +1,21 @@
+using MongoDB.Bson.Serialization.Attributes;
+
+namespace CharacterApi.Models;
+
+public class VisibleLocationObject
+{
+    [BsonElement("id")]
+    public string Id { get; set; } = string.Empty;
+
+    [BsonElement("objectType")]
+    public string ObjectType { get; set; } = string.Empty;
+
+    [BsonElement("objectKey")]
+    public string ObjectKey { get; set; } = string.Empty;
+
+    [BsonElement("name")]
+    public string Name { get; set; } = string.Empty;
+
+    [BsonElement("state")]
+    public VisibleLocationObjectState State { get; set; } = new();
+}

microservices/CharacterApi/Models/VisibleLocationObjectState.cs

@@ -0,0 +1,15 @@
+using MongoDB.Bson.Serialization.Attributes;
+
+namespace CharacterApi.Models;
+
+public class VisibleLocationObjectState
+{
+    [BsonElement("itemKey")]
+    public string ItemKey { get; set; } = string.Empty;
+
+    [BsonElement("remainingQuantity")]
+    public int RemainingQuantity { get; set; }
+
+    [BsonElement("gatherQuantity")]
+    public int GatherQuantity { get; set; } = 1;
+}

microservices/CharacterApi/Services/CharacterStore.cs

@@ -13,87 +13,45 @@ public class CharacterStore
     private static readonly string[] BiomeOrder = ["plains", "forest", "wetlands", "rocky", "desert"];
     private static readonly Dictionary<string, BiomeDefinition> Biomes = new()
     {
-        ["plains"] = new BiomeDefinition(
+        ["plains"] = new("plains", 3.0, new()
-            "plains",
-            3.0,
-            new Dictionary<string, double>
         {
             ["forest"] = 1.7,
             ["wetlands"] = 0.9,
             ["rocky"] = 0.8,
             ["desert"] = 0.4
-            },
-            new[]
-            {
-                new ResourceRule("grass", 180, 420, 12),
-                new ResourceRule("wood", 25, 90, 3),
-                new ResourceRule("stone", 10, 40, 2)
         }),
-        ["forest"] = new BiomeDefinition(
+        ["forest"] = new("forest", 3.4, new()
-            "forest",
-            3.4,
-            new Dictionary<string, double>
         {
             ["plains"] = 1.6,
             ["wetlands"] = 1.3,
             ["rocky"] = 0.5,
             ["desert"] = 0.1
-            },
-            new[]
-            {
-                new ResourceRule("wood", 220, 520, 6),
-                new ResourceRule("grass", 90, 220, 8),
-                new ResourceRule("stone", 15, 45, 2)
         }),
-        ["wetlands"] = new BiomeDefinition(
+        ["wetlands"] = new("wetlands", 3.1, new()
-            "wetlands",
-            3.1,
-            new Dictionary<string, double>
         {
             ["forest"] = 1.5,
             ["plains"] = 1.1,
             ["rocky"] = 0.2,
             ["desert"] = 0.05
-            },
-            new[]
-            {
-                new ResourceRule("grass", 260, 600, 15),
-                new ResourceRule("wood", 40, 120, 4)
         }),
-        ["rocky"] = new BiomeDefinition(
+        ["rocky"] = new("rocky", 3.0, new()
-            "rocky",
-            3.0,
-            new Dictionary<string, double>
         {
             ["plains"] = 1.2,
             ["forest"] = 0.6,
             ["desert"] = 1.1,
             ["wetlands"] = 0.1
-            },
-            new[]
-            {
-                new ResourceRule("stone", 220, 540, 8),
-                new ResourceRule("wood", 10, 40, 2),
-                new ResourceRule("grass", 20, 70, 4)
         }),
-        ["desert"] = new BiomeDefinition(
+        ["desert"] = new("desert", 3.2, new()
-            "desert",
-            3.2,
-            new Dictionary<string, double>
         {
             ["rocky"] = 1.4,
             ["plains"] = 0.8,
             ["forest"] = 0.1,
             ["wetlands"] = 0.05
-            },
-            new[]
-            {
-                new ResourceRule("stone", 80, 220, 5),
-                new ResourceRule("grass", 5, 25, 2)
         })
     };
 
     public sealed record VisibleLocationResult(List<VisibleLocation> Locations, int GeneratedCount);
+    private sealed record BiomeDefinition(string Key, double ContinuationWeight, Dictionary<string, double> TransitionWeights);
 
     public CharacterStore(IConfiguration cfg)
     {
@@ -125,10 +83,8 @@ public class CharacterStore
         return result.ModifiedCount > 0 || result.MatchedCount > 0;
     }
 
-    public Task<List<VisibleLocation>> GetVisibleLocationsAsync(Character character)
+    public Task<List<VisibleLocation>> GetVisibleLocationsAsync(Character character) =>
-    {
+        GetVisibleLocationsInternalAsync(character, ensureGenerated: false);
-        return GetVisibleLocationsInternalAsync(character, ensureGenerated: false);
-    }
 
     public async Task<VisibleLocationResult> GetOrCreateVisibleLocationsAsync(Character character)
     {
@@ -153,6 +109,13 @@ public class CharacterStore
         );
 
         var documents = await _locations.Find(filter).ToListAsync();
+        if (ensureGenerated)
+        {
+            foreach (var document in documents)
+                await BackfillLocationStateAsync(document);
+            documents = await _locations.Find(filter).ToListAsync();
+        }
+
         return documents.Select(MapVisibleLocation).ToList();
     }
 
@@ -173,39 +136,6 @@ public class CharacterStore
         return generatedCount;
     }
 
-    private static string DefaultLocationName(int x, int y)
-    {
-        if (x == 0 && y == 0)
-            return "Origin";
-        return $"Location {x},{y}";
-    }
-
-    private static VisibleLocation MapVisibleLocation(BsonDocument document)
-    {
-        var coord = document.GetValue("coord", new BsonDocument()).AsBsonDocument;
-        var idValue = document.GetValue("_id", BsonNull.Value);
-        string? id = null;
-        if (!idValue.IsBsonNull)
-        {
-            id = idValue.BsonType == BsonType.ObjectId
-                ? idValue.AsObjectId.ToString()
-                : idValue.ToString();
-        }
-
-        return new VisibleLocation
-        {
-            Id = id,
-            Name = document.GetValue("name", "").AsString,
-            Coord = new LocationCoord
-            {
-                X = coord.GetValue("x", 0).ToInt32(),
-                Y = coord.GetValue("y", 0).ToInt32()
-            },
-            BiomeKey = document.GetValue("biomeKey", "plains").AsString,
-            Resources = MapVisibleLocationResources(document)
-        };
-    }
-
     private async Task<bool> EnsureLocationStateAsync(int x, int y)
     {
         var filter = Builders<BsonDocument>.Filter.And(
@@ -230,7 +160,8 @@ public class CharacterStore
                 { "y", y }
             })
             .SetOnInsert("biomeKey", biomeKey)
-            .SetOnInsert("resources", BuildResourcesDocument(biomeKey, x, y))
+            .SetOnInsert("locationObject", CreateLocationObjectValueForBiome(biomeKey, x, y))
+            .SetOnInsert("locationObjectResolved", true)
             .SetOnInsert("createdUtc", DateTime.UtcNow);
 
         try
@@ -254,11 +185,17 @@ public class CharacterStore
         var biomeKey = document.GetValue("biomeKey", BsonNull.Value).IsBsonNull
             ? await DetermineBiomeKeyAsync(x, y)
             : document.GetValue("biomeKey", "plains").AsString;
+        var objectResolved = document.TryGetValue("locationObjectResolved", out var resolvedValue) &&
+            resolvedValue.ToBoolean();
 
         if (!document.Contains("biomeKey"))
             updates.Add(Builders<BsonDocument>.Update.Set("biomeKey", biomeKey));
-        if (!document.Contains("resources"))
+        if (!objectResolved)
-            updates.Add(Builders<BsonDocument>.Update.Set("resources", BuildResourcesDocument(biomeKey, x, y)));
+        {
+            var locationObject = TryMigrateLegacyResource(document) ?? CreateLocationObjectValueForBiome(biomeKey, x, y);
+            updates.Add(Builders<BsonDocument>.Update.Set("locationObject", locationObject));
+            updates.Add(Builders<BsonDocument>.Update.Set("locationObjectResolved", true));
+        }
 
         if (updates.Count == 0)
             return;
@@ -317,14 +254,7 @@ public class CharacterStore
 
     private async Task<List<string>> LoadNeighborBiomeKeysAsync(int x, int y)
     {
-        var coords = new[]
+        var coords = new[] { (x - 1, y), (x + 1, y), (x, y - 1), (x, y + 1) };
-        {
-            (x - 1, y),
-            (x + 1, y),
-            (x, y - 1),
-            (x, y + 1)
-        };
-
         var filters = coords.Select(coord =>
             Builders<BsonDocument>.Filter.And(
                 Builders<BsonDocument>.Filter.Eq("coord.x", coord.Item1),
@@ -357,68 +287,131 @@ public class CharacterStore
         return "plains";
     }
 
-    private static BsonArray BuildResourcesDocument(string biomeKey, int x, int y)
+    private static BsonValue CreateLocationObjectValueForBiome(string biomeKey, int x, int y)
     {
-        if (!Biomes.TryGetValue(biomeKey, out var biome))
+        var roll = StableNoise(x, y, 401);
-            biome = Biomes["plains"];
+        return biomeKey switch
+        {
+            "forest" => roll switch
+            {
+                < 0.35 => BsonNull.Value,
+                < 0.80 => CreateGatherableObjectDocument("wood", 60, 3),
+                < 0.95 => CreateGatherableObjectDocument("grass", 120, 10),
+                _ => CreateGatherableObjectDocument("stone", 40, 2)
+            },
+            "rocky" => roll switch
+            {
+                < 0.60 => BsonNull.Value,
+                < 0.90 => CreateGatherableObjectDocument("stone", 40, 2),
+                _ => CreateGatherableObjectDocument("wood", 60, 3)
+            },
+            "wetlands" => roll switch
+            {
+                < 0.40 => BsonNull.Value,
+                < 0.90 => CreateGatherableObjectDocument("grass", 120, 10),
+                _ => CreateGatherableObjectDocument("wood", 60, 3)
+            },
+            "desert" => roll switch
+            {
+                < 0.70 => BsonNull.Value,
+                < 0.95 => CreateGatherableObjectDocument("stone", 40, 2),
+                _ => CreateGatherableObjectDocument("wood", 60, 3)
+            },
+            _ => roll switch
+            {
+                < 0.50 => BsonNull.Value,
+                < 0.85 => CreateGatherableObjectDocument("grass", 120, 10),
+                _ => CreateGatherableObjectDocument("wood", 60, 3)
+            }
+        };
+    }
 
-        var resources = new BsonArray();
+    private static BsonDocument? TryMigrateLegacyResource(BsonDocument document)
-        foreach (var rule in biome.ResourceRules)
     {
-            var roll = StableNoise(x, y, StableHash(rule.ItemKey));
+        if (!document.TryGetValue("resources", out var resourcesValue) || resourcesValue is not BsonArray resources)
-            var quantity = rule.MinQuantity + (int)Math.Round(roll * (rule.MaxQuantity - rule.MinQuantity));
+            return null;
-            if (quantity <= 0)
+
+        foreach (var resourceValue in resources)
+        {
+            if (resourceValue is not BsonDocument resource)
                 continue;
 
-            resources.Add(new BsonDocument
+            var remainingQuantity = resource.GetValue("remainingQuantity", 0).ToInt32();
-            {
+            if (remainingQuantity <= 0)
-                { "itemKey", rule.ItemKey },
-                { "remainingQuantity", quantity },
-                { "gatherQuantity", rule.GatherQuantity }
-            });
-        }
-
-        return resources;
-    }
-
-    private static double StableNoise(int x, int y, int salt)
-    {
-        var value = Math.Sin((x * 12.9898) + (y * 78.233) + ((WorldSeed + salt) * 0.1597)) * 43758.5453;
-        return value - Math.Floor(value);
-    }
-
-    private static int StableHash(string value)
-    {
-        unchecked
-        {
-            var hash = 23;
-            foreach (var c in value)
-                hash = (hash * 31) + c;
-            return hash;
-        }
-    }
-
-    private static List<VisibleLocationResource> MapVisibleLocationResources(BsonDocument document)
-    {
-        if (!document.TryGetValue("resources", out var resourcesValue) || resourcesValue.BsonType != BsonType.Array)
-            return [];
-
-        var results = new List<VisibleLocationResource>();
-        foreach (var value in resourcesValue.AsBsonArray)
-        {
-            if (value.BsonType != BsonType.Document)
                 continue;
 
-            var resource = value.AsBsonDocument;
+            var itemKey = NormalizeItemKey(resource.GetValue("itemKey", "").AsString);
-            results.Add(new VisibleLocationResource
+            var gatherQuantity = Math.Max(1, resource.GetValue("gatherQuantity", 1).ToInt32());
-            {
+            return CreateGatherableObjectDocument(itemKey, remainingQuantity, gatherQuantity);
-                ItemKey = resource.GetValue("itemKey", "").AsString,
-                RemainingQuantity = resource.GetValue("remainingQuantity", 0).ToInt32(),
-                GatherQuantity = resource.GetValue("gatherQuantity", 1).ToInt32()
-            });
         }
 
-        return results;
+        return null;
+    }
+
+    private static BsonDocument CreateGatherableObjectDocument(string itemKey, int remainingQuantity, int gatherQuantity)
+    {
+        var normalizedItemKey = NormalizeItemKey(itemKey);
+        return new BsonDocument
+        {
+            { "id", Guid.NewGuid().ToString("N") },
+            { "objectType", "gatherable" },
+            { "objectKey", $"{normalizedItemKey}_node" },
+            { "name", HumanizeItemKey(normalizedItemKey) },
+            {
+                "state", new BsonDocument
+                {
+                    { "itemKey", normalizedItemKey },
+                    { "remainingQuantity", remainingQuantity },
+                    { "gatherQuantity", gatherQuantity }
+                }
+            }
+        };
+    }
+
+    private static VisibleLocation MapVisibleLocation(BsonDocument document)
+    {
+        var coord = document.GetValue("coord", new BsonDocument()).AsBsonDocument;
+        var locationObject = MapVisibleLocationObject(document.GetValue("locationObject", BsonNull.Value));
+        var idValue = document.GetValue("_id", BsonNull.Value);
+        string? id = null;
+        if (!idValue.IsBsonNull)
+        {
+            id = idValue.BsonType == BsonType.ObjectId ? idValue.AsObjectId.ToString() : idValue.ToString();
+        }
+
+        return new VisibleLocation
+        {
+            Id = id,
+            Name = document.GetValue("name", "").AsString,
+            Coord = new LocationCoord
+            {
+                X = coord.GetValue("x", 0).ToInt32(),
+                Y = coord.GetValue("y", 0).ToInt32()
+            },
+            BiomeKey = document.GetValue("biomeKey", "plains").AsString,
+            LocationObject = locationObject
+        };
+    }
+
+    private static VisibleLocationObject? MapVisibleLocationObject(BsonValue value)
+    {
+        if (value.IsBsonNull || value is not BsonDocument document)
+            return null;
+
+        var stateDoc = document.GetValue("state", new BsonDocument()).AsBsonDocument;
+        return new VisibleLocationObject
+        {
+            Id = document.GetValue("id", "").AsString,
+            ObjectType = document.GetValue("objectType", "").AsString,
+            ObjectKey = document.GetValue("objectKey", "").AsString,
+            Name = document.GetValue("name", "").AsString,
+            State = new VisibleLocationObjectState
+            {
+                ItemKey = stateDoc.GetValue("itemKey", "").AsString,
+                RemainingQuantity = stateDoc.GetValue("remainingQuantity", 0).ToInt32(),
+                GatherQuantity = stateDoc.GetValue("gatherQuantity", 1).ToInt32()
+            }
+        };
     }
 
     private void EnsureLocationCoordIndexes()
@@ -435,11 +428,7 @@ public class CharacterStore
                 _locations.Indexes.DropOne(name);
         }
 
-        var coordIndex = new BsonDocument
+        var coordIndex = new BsonDocument { { "coord.x", 1 }, { "coord.y", 1 } };
-        {
-            { "coord.x", 1 },
-            { "coord.y", 1 }
-        };
         var coordIndexOptions = new CreateIndexOptions { Unique = true, Name = CoordIndexName };
         _locations.Indexes.CreateOne(new CreateIndexModel<BsonDocument>(coordIndex, coordIndexOptions));
     }
@@ -462,22 +451,42 @@ public class CharacterStore
     {
         var filter = Builders<Character>.Filter.Eq(c => c.Id, id);
         if (!allowAnyOwner)
-        {
+            filter = Builders<Character>.Filter.And(filter, Builders<Character>.Filter.Eq(c => c.OwnerUserId, ownerUserId));
-            filter = Builders<Character>.Filter.And(
-                filter,
-                Builders<Character>.Filter.Eq(c => c.OwnerUserId, ownerUserId)
-            );
-        }
 
         var result = await _col.DeleteOneAsync(filter);
         return result.DeletedCount > 0;
     }
 
-    private sealed record ResourceRule(string ItemKey, int MinQuantity, int MaxQuantity, int GatherQuantity);
+    private static string DefaultLocationName(int x, int y)
-
+    {
-    private sealed record BiomeDefinition(
+        if (x == 0 && y == 0)
-        string Key,
+            return "Origin";
-        double ContinuationWeight,
+        return $"Location {x},{y}";
-        Dictionary<string, double> TransitionWeights,
+    }
-        IReadOnlyList<ResourceRule> ResourceRules);
+
+    private static string NormalizeItemKey(string itemKey) => itemKey.Trim().ToLowerInvariant();
+
+    private static string HumanizeItemKey(string itemKey)
+    {
+        return string.Join(" ", itemKey.Split('_', StringSplitOptions.RemoveEmptyEntries)
+            .Where(part => part.Length > 0)
+            .Select(part => char.ToUpperInvariant(part[0]) + part[1..]));
+    }
+
+    private static double StableNoise(int x, int y, int salt)
+    {
+        var value = Math.Sin((x * 12.9898) + (y * 78.233) + ((WorldSeed + salt) * 0.1597)) * 43758.5453;
+        return value - Math.Floor(value);
+    }
+
+    private static int StableHash(string value)
+    {
+        unchecked
+        {
+            var hash = 17;
+            foreach (var ch in value)
+                hash = (hash * 31) + ch;
+            return hash;
+        }
+    }
 }

microservices/LocationsApi/Controllers/LocationsController.cs

@@ -94,40 +94,42 @@ public class LocationsController : ControllerBase
         return Ok("Updated");
     }
 
-    [HttpPost("{id}/gather")]
+    [HttpPost("{id}/interact")]
     [Authorize(Roles = "USER,SUPER")]
-    public async Task<IActionResult> Gather(string id, [FromBody] GatherResourceRequest req)
+    public async Task<IActionResult> Interact(string id, [FromBody] InteractLocationObjectRequest req)
     {
         if (string.IsNullOrWhiteSpace(req.CharacterId))
             return BadRequest("characterId required");
-        if (string.IsNullOrWhiteSpace(req.ResourceKey))
+        if (string.IsNullOrWhiteSpace(req.ObjectId))
-            return BadRequest("resourceKey required");
+            return BadRequest("objectId required");
 
         var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
         if (string.IsNullOrWhiteSpace(userId))
             return Unauthorized();
 
         var allowAnyOwner = User.IsInRole("SUPER");
-        var gather = await _locations.GatherResourceAsync(id, req.CharacterId, req.ResourceKey, userId, allowAnyOwner);
+        var interact = await _locations.InteractWithObjectAsync(id, req.CharacterId, req.ObjectId, userId, allowAnyOwner);
-        if (gather.Status == GatherStatus.LocationNotFound)
+        if (interact.Status == InteractStatus.LocationNotFound)
             return NotFound("Location not found");
-        if (gather.Status == GatherStatus.CharacterNotFound)
+        if (interact.Status == InteractStatus.CharacterNotFound)
             return NotFound("Character not found");
-        if (gather.Status == GatherStatus.Forbidden)
+        if (interact.Status == InteractStatus.Forbidden)
             return Forbid();
-        if (gather.Status == GatherStatus.Invalid)
+        if (interact.Status == InteractStatus.Invalid)
             return BadRequest("Character is not at the target location");
-        if (gather.Status == GatherStatus.ResourceNotFound)
+        if (interact.Status == InteractStatus.ObjectNotFound)
-            return NotFound("Resource not found at location");
+            return NotFound("Location object not found");
-        if (gather.Status == GatherStatus.ResourceDepleted)
+        if (interact.Status == InteractStatus.UnsupportedObjectType)
-            return Conflict("Resource is depleted");
+            return BadRequest("Location object type is not supported");
+        if (interact.Status == InteractStatus.ObjectConsumed)
+            return Conflict("Location object is consumed");
 
         var inventoryBaseUrl = (_configuration["Services:InventoryApiBaseUrl"] ?? "http://localhost:5003").TrimEnd('/');
         var token = Request.Headers.Authorization.ToString();
         var grantBody = JsonSerializer.Serialize(new
         {
-            itemKey = gather.ResourceKey,
+            itemKey = interact.ItemKey,
-            quantity = gather.QuantityGranted
+            quantity = interact.QuantityGranted
         });
 
         var client = _httpClientFactory.CreateClient();
@@ -142,17 +144,21 @@ public class LocationsController : ControllerBase
         var responseBody = await response.Content.ReadAsStringAsync();
         if (!response.IsSuccessStatusCode)
         {
-            await _locations.RestoreGatheredResourceAsync(id, gather.ResourceKey, gather.QuantityGranted);
+            if (interact.PreviousObject is not null)
+                await _locations.RestoreObjectInteractionAsync(id, interact.PreviousObject);
             return StatusCode((int)response.StatusCode, responseBody);
         }
 
-        return Ok(new GatherResourceResponse
+        return Ok(new InteractLocationObjectResponse
         {
             LocationId = id,
             CharacterId = req.CharacterId,
-            ResourceKey = gather.ResourceKey,
+            ObjectId = interact.ObjectId,
-            QuantityGranted = gather.QuantityGranted,
+            ObjectType = interact.ObjectType,
-            RemainingQuantity = gather.RemainingQuantity,
+            ItemKey = interact.ItemKey,
+            QuantityGranted = interact.QuantityGranted,
+            RemainingQuantity = interact.RemainingQuantity,
+            Consumed = interact.Consumed,
             InventoryResponseJson = responseBody
         });
     }

microservices/LocationsApi/Models/InteractLocationObjectRequest.cs

@@ -0,0 +1,8 @@
+namespace LocationsApi.Models;
+
+public class InteractLocationObjectRequest
+{
+    public string CharacterId { get; set; } = string.Empty;
+
+    public string ObjectId { get; set; } = string.Empty;
+}

microservices/LocationsApi/Models/InteractLocationObjectResponse.cs

@@ -0,0 +1,22 @@
+namespace LocationsApi.Models;
+
+public class InteractLocationObjectResponse
+{
+    public string LocationId { get; set; } = string.Empty;
+
+    public string CharacterId { get; set; } = string.Empty;
+
+    public string ObjectId { get; set; } = string.Empty;
+
+    public string ObjectType { get; set; } = string.Empty;
+
+    public string ItemKey { get; set; } = string.Empty;
+
+    public int QuantityGranted { get; set; }
+
+    public int RemainingQuantity { get; set; }
+
+    public bool Consumed { get; set; }
+
+    public string InventoryResponseJson { get; set; } = string.Empty;
+}

microservices/LocationsApi/Models/Location.cs

@@ -21,6 +21,12 @@ public class Location
     [BsonElement("resources")]
     public List<LocationResource> Resources { get; set; } = [];
 
+    [BsonElement("locationObject")]
+    public LocationObject? LocationObject { get; set; }
+
+    [BsonElement("locationObjectResolved")]
+    public bool LocationObjectResolved { get; set; }
+
     [BsonElement("createdUtc")]
     public DateTime CreatedUtc { get; set; } = DateTime.UtcNow;
 }

microservices/LocationsApi/Models/LocationObject.cs

@@ -0,0 +1,21 @@
+using MongoDB.Bson.Serialization.Attributes;
+
+namespace LocationsApi.Models;
+
+public class LocationObject
+{
+    [BsonElement("id")]
+    public string Id { get; set; } = Guid.NewGuid().ToString("N");
+
+    [BsonElement("objectType")]
+    public string ObjectType { get; set; } = "gatherable";
+
+    [BsonElement("objectKey")]
+    public string ObjectKey { get; set; } = string.Empty;
+
+    [BsonElement("name")]
+    public string Name { get; set; } = string.Empty;
+
+    [BsonElement("state")]
+    public LocationObjectState State { get; set; } = new();
+}

microservices/LocationsApi/Models/LocationObjectState.cs

@@ -0,0 +1,15 @@
+using MongoDB.Bson.Serialization.Attributes;
+
+namespace LocationsApi.Models;
+
+public class LocationObjectState
+{
+    [BsonElement("itemKey")]
+    public string ItemKey { get; set; } = string.Empty;
+
+    [BsonElement("remainingQuantity")]
+    public int RemainingQuantity { get; set; }
+
+    [BsonElement("gatherQuantity")]
+    public int GatherQuantity { get; set; } = 1;
+}

microservices/LocationsApi/Services/LocationStore.cs

@@ -77,6 +77,36 @@ public class LocationStore
                                     }
                                 }
                             },
+                            {
+                                "locationObject", new BsonDocument
+                                {
+                                    { "bsonType", new BsonArray { "object", "null" } },
+                                    {
+                                        "properties", new BsonDocument
+                                        {
+                                            { "id", new BsonDocument { { "bsonType", "string" } } },
+                                            { "objectType", new BsonDocument { { "bsonType", "string" } } },
+                                            { "objectKey", new BsonDocument { { "bsonType", "string" } } },
+                                            { "name", new BsonDocument { { "bsonType", "string" } } },
+                                            {
+                                                "state", new BsonDocument
+                                                {
+                                                    { "bsonType", new BsonArray { "object", "null" } },
+                                                    {
+                                                        "properties", new BsonDocument
+                                                        {
+                                                            { "itemKey", new BsonDocument { { "bsonType", "string" } } },
+                                                            { "remainingQuantity", new BsonDocument { { "bsonType", "int" }, { "minimum", 0 } } },
+                                                            { "gatherQuantity", new BsonDocument { { "bsonType", "int" }, { "minimum", 1 } } }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            },
+                            { "locationObjectResolved", new BsonDocument { { "bsonType", new BsonArray { "bool", "null" } } } },
                             { "createdUtc", new BsonDocument { { "bsonType", "date" } } }
                         }
                     }
@@ -126,54 +156,79 @@ public class LocationStore
         return result.ModifiedCount > 0;
     }
 
-    public sealed record GatherResult(GatherStatus Status, string ResourceKey = "", int QuantityGranted = 0, int RemainingQuantity = 0);
+    public sealed record InteractResult(
+        InteractStatus Status,
+        string ObjectId = "",
+        string ObjectType = "",
+        string ItemKey = "",
+        int QuantityGranted = 0,
+        int RemainingQuantity = 0,
+        bool Consumed = false,
+        LocationObject? PreviousObject = null);
 
-    public async Task<GatherResult> GatherResourceAsync(string locationId, string characterId, string resourceKey, string userId, bool allowAnyOwner)
+    public async Task<InteractResult> InteractWithObjectAsync(string locationId, string characterId, string objectId, string userId, bool allowAnyOwner)
     {
-        var normalizedKey = resourceKey.Trim().ToLowerInvariant();
         var location = await _col.Find(l => l.Id == locationId).FirstOrDefaultAsync();
         if (location is null)
-            return new GatherResult(GatherStatus.LocationNotFound);
+            return new InteractResult(InteractStatus.LocationNotFound);
+
+        location = await EnsureLocationMetadataAsync(location);
 
         var character = await _characters.Find(c => c.Id == characterId).FirstOrDefaultAsync();
         if (character is null)
-            return new GatherResult(GatherStatus.CharacterNotFound);
+            return new InteractResult(InteractStatus.CharacterNotFound);
         if (!allowAnyOwner && character.OwnerUserId != userId)
-            return new GatherResult(GatherStatus.Forbidden);
+            return new InteractResult(InteractStatus.Forbidden);
         if (character.Coord.X != location.Coord.X || character.Coord.Y != location.Coord.Y)
-            return new GatherResult(GatherStatus.Invalid);
+            return new InteractResult(InteractStatus.Invalid);
 
-        var resource = location.Resources.FirstOrDefault(r => NormalizeItemKey(r.ItemKey) == normalizedKey);
+        var locationObject = location.LocationObject;
-        if (resource is null)
+        if (locationObject is null)
-            return new GatherResult(GatherStatus.ResourceNotFound);
+            return new InteractResult(InteractStatus.ObjectNotFound);
-        if (resource.RemainingQuantity <= 0)
+        if (!string.Equals(locationObject.Id, objectId, StringComparison.Ordinal))
-            return new GatherResult(GatherStatus.ResourceDepleted);
+            return new InteractResult(InteractStatus.ObjectNotFound);
+        if (!string.Equals(locationObject.ObjectType, "gatherable", StringComparison.OrdinalIgnoreCase))
+            return new InteractResult(InteractStatus.UnsupportedObjectType);
+        if (locationObject.State.RemainingQuantity <= 0)
+            return new InteractResult(InteractStatus.ObjectConsumed);
 
-        var quantityGranted = Math.Min(resource.GatherQuantity, resource.RemainingQuantity);
+        var quantityGranted = Math.Min(locationObject.State.GatherQuantity, locationObject.State.RemainingQuantity);
-        var filter = Builders<Location>.Filter.And(
+        var remainingQuantity = locationObject.State.RemainingQuantity - quantityGranted;
+        var objectFilter = Builders<Location>.Filter.And(
             Builders<Location>.Filter.Eq(l => l.Id, locationId),
-            Builders<Location>.Filter.ElemMatch(l => l.Resources, r => r.ItemKey == resource.ItemKey && r.RemainingQuantity >= quantityGranted)
+            Builders<Location>.Filter.Eq("locationObject.id", locationObject.Id),
+            Builders<Location>.Filter.Eq("locationObject.state.remainingQuantity", locationObject.State.RemainingQuantity)
         );
-        var update = Builders<Location>.Update.Inc("resources.$.remainingQuantity", -quantityGranted);
-        var result = await _col.UpdateOneAsync(filter, update);
-        if (result.ModifiedCount == 0)
-            return new GatherResult(GatherStatus.ResourceDepleted);
 
-        return new GatherResult(
+        UpdateDefinition<Location> update;
-            GatherStatus.Ok,
+        if (remainingQuantity <= 0)
-            resource.ItemKey,
+        {
-            quantityGranted,
+            update = Builders<Location>.Update.Unset("locationObject");
-            resource.RemainingQuantity - quantityGranted);
+        }
+        else
+        {
+            update = Builders<Location>.Update.Set("locationObject.state.remainingQuantity", remainingQuantity);
         }
 
-    public async Task RestoreGatheredResourceAsync(string locationId, string resourceKey, int quantity)
+        var result = await _col.UpdateOneAsync(objectFilter, update);
+        if (result.ModifiedCount == 0)
+            return new InteractResult(InteractStatus.ObjectConsumed);
+
+        return new InteractResult(
+            InteractStatus.Ok,
+            locationObject.Id,
+            locationObject.ObjectType,
+            locationObject.State.ItemKey,
+            quantityGranted,
+            Math.Max(0, remainingQuantity),
+            remainingQuantity <= 0,
+            CloneLocationObject(locationObject));
+    }
+
+    public async Task RestoreObjectInteractionAsync(string locationId, LocationObject previousObject)
     {
-        var normalizedKey = NormalizeItemKey(resourceKey);
+        var filter = Builders<Location>.Filter.Eq(l => l.Id, locationId);
-        var filter = Builders<Location>.Filter.And(
+        var update = Builders<Location>.Update.Set(l => l.LocationObject, previousObject);
-            Builders<Location>.Filter.Eq(l => l.Id, locationId),
-            Builders<Location>.Filter.ElemMatch(l => l.Resources, r => r.ItemKey == normalizedKey)
-        );
-        var update = Builders<Location>.Update.Inc("resources.$.remainingQuantity", quantity);
         await _col.UpdateOneAsync(filter, update);
     }
 
@@ -222,31 +277,15 @@ public class LocationStore
         );
         var existing = _col.Find(filter).FirstOrDefault();
         if (existing is not null)
-        {
-            var updates = new List<UpdateDefinition<Location>>();
-            if (string.IsNullOrWhiteSpace(existing.BiomeKey))
-                updates.Add(Builders<Location>.Update.Set(l => l.BiomeKey, "plains"));
-            if (existing.Resources.Count == 0)
-                updates.Add(Builders<Location>.Update.Set(l => l.Resources, new List<LocationResource>
-                {
-                    new() { ItemKey = "wood", RemainingQuantity = 100, GatherQuantity = 3 },
-                    new() { ItemKey = "grass", RemainingQuantity = 500, GatherQuantity = 10 }
-                }));
-            if (updates.Count > 0)
-                _col.UpdateOne(filter, Builders<Location>.Update.Combine(updates));
             return;
-        }
 
         var origin = new Location
         {
             Name = "Origin",
             Coord = new Coord { X = 0, Y = 0 },
-            BiomeKey = "plains",
+            BiomeKey = DetermineBiomeKey(0, 0),
-            Resources =
+            LocationObject = CreateLocationObjectForBiome(DetermineBiomeKey(0, 0), 0, 0),
-            [
+            LocationObjectResolved = true,
-                new LocationResource { ItemKey = "wood", RemainingQuantity = 100, GatherQuantity = 3 },
-                new LocationResource { ItemKey = "grass", RemainingQuantity = 500, GatherQuantity = 10 }
-            ],
             CreatedUtc = DateTime.UtcNow
         };
 
@@ -262,6 +301,150 @@ public class LocationStore
 
     private static string NormalizeItemKey(string itemKey) => itemKey.Trim().ToLowerInvariant();
 
+    private async Task<Location> EnsureLocationMetadataAsync(Location location)
+    {
+        if (!string.IsNullOrWhiteSpace(location.BiomeKey) && location.LocationObjectResolved)
+            return location;
+
+        var biomeKey = location.BiomeKey;
+        if (string.IsNullOrWhiteSpace(biomeKey))
+            biomeKey = DetermineBiomeKey(location.Coord.X, location.Coord.Y);
+
+        var migratedObject = TryMigrateLegacyResources(location) ?? CreateLocationObjectForBiome(biomeKey, location.Coord.X, location.Coord.Y);
+        var filter = Builders<Location>.Filter.And(
+            Builders<Location>.Filter.Eq(l => l.Id, location.Id)
+        );
+        var update = Builders<Location>.Update
+            .Set(l => l.BiomeKey, biomeKey)
+            .Set(l => l.LocationObjectResolved, true)
+            .Set(l => l.LocationObject, migratedObject);
+        await _col.UpdateOneAsync(filter, update);
+        location.BiomeKey = biomeKey;
+        location.LocationObject = migratedObject;
+        location.LocationObjectResolved = true;
+        return location;
+    }
+
+    private static LocationObject? TryMigrateLegacyResources(Location location)
+    {
+        var legacyResource = location.Resources.FirstOrDefault(r => r.RemainingQuantity > 0);
+        if (legacyResource is null)
+            return null;
+
+        return CreateGatherableObject(
+            legacyResource.ItemKey,
+            legacyResource.RemainingQuantity,
+            legacyResource.GatherQuantity);
+    }
+
+    private static string DetermineBiomeKey(int x, int y)
+    {
+        if (x == 0 && y == 0)
+            return "plains";
+
+        var regionX = FloorDiv(x, 4);
+        var regionY = FloorDiv(y, 4);
+        var roll = Math.Abs(HashCode.Combine(regionX, regionY, 7919)) % 100;
+        if (roll < 35)
+            return "plains";
+        if (roll < 60)
+            return "forest";
+        if (roll < 80)
+            return "rocky";
+        if (roll < 92)
+            return "wetlands";
+        return "desert";
+    }
+
+    private static LocationObject? CreateLocationObjectForBiome(string biomeKey, int x, int y)
+    {
+        var roll = Math.Abs(HashCode.Combine(x, y, 1543)) % 100;
+        return biomeKey switch
+        {
+            "forest" => roll switch
+            {
+                < 35 => null,
+                < 80 => CreateGatherableObject("wood", 60, 3),
+                < 95 => CreateGatherableObject("grass", 120, 10),
+                _ => CreateGatherableObject("stone", 40, 2)
+            },
+            "rocky" => roll switch
+            {
+                < 60 => null,
+                < 90 => CreateGatherableObject("stone", 40, 2),
+                _ => CreateGatherableObject("wood", 60, 3)
+            },
+            "wetlands" => roll switch
+            {
+                < 40 => null,
+                < 90 => CreateGatherableObject("grass", 120, 10),
+                _ => CreateGatherableObject("wood", 60, 3)
+            },
+            "desert" => roll switch
+            {
+                < 70 => null,
+                < 95 => CreateGatherableObject("stone", 40, 2),
+                _ => CreateGatherableObject("wood", 60, 3)
+            },
+            _ => roll switch
+            {
+                < 50 => null,
+                < 85 => CreateGatherableObject("grass", 120, 10),
+                _ => CreateGatherableObject("wood", 60, 3)
+            }
+        };
+    }
+
+    private static LocationObject CreateGatherableObject(string itemKey, int remainingQuantity, int gatherQuantity)
+    {
+        var normalizedItemKey = NormalizeItemKey(itemKey);
+        return new LocationObject
+        {
+            Id = Guid.NewGuid().ToString("N"),
+            ObjectType = "gatherable",
+            ObjectKey = $"{normalizedItemKey}_node",
+            Name = HumanizeItemKey(normalizedItemKey),
+            State = new LocationObjectState
+            {
+                ItemKey = normalizedItemKey,
+                RemainingQuantity = remainingQuantity,
+                GatherQuantity = gatherQuantity
+            }
+        };
+    }
+
+    private static string HumanizeItemKey(string itemKey)
+    {
+        return string.Join(" ", itemKey.Split('_', StringSplitOptions.RemoveEmptyEntries)
+            .Select(part => char.ToUpperInvariant(part[0]) + part[1..]));
+    }
+
+    private static int FloorDiv(int value, int divisor)
+    {
+        var quotient = value / divisor;
+        var remainder = value % divisor;
+        if (remainder != 0 && ((remainder < 0) != (divisor < 0)))
+            quotient -= 1;
+        return quotient;
+    }
+
+    private static LocationObject CloneLocationObject(LocationObject source)
+    {
+        return new LocationObject
+        {
+            Id = source.Id,
+            ObjectType = source.ObjectType,
+            ObjectKey = source.ObjectKey,
+            Name = source.Name,
+            State = new LocationObjectState
+            {
+                ItemKey = source.State.ItemKey,
+                RemainingQuantity = source.State.RemainingQuantity,
+                GatherQuantity = source.State.GatherQuantity
+            }
+        };
+    }
+
     [MongoDB.Bson.Serialization.Attributes.BsonIgnoreExtraElements]
     private class CharacterDocument
     {
@@ -275,13 +458,14 @@ public class LocationStore
     }
 }
 
-public enum GatherStatus
+public enum InteractStatus
 {
     Ok,
     LocationNotFound,
     CharacterNotFound,
     Forbidden,
     Invalid,
-    ResourceNotFound,
+    ObjectNotFound,
-    ResourceDepleted
+    UnsupportedObjectType,
+    ObjectConsumed
 }