null/promiscuity
2
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Keeping logic within microservice boundaries
Deploy Promiscuity Auth API / deploy (push) Successful in 45s
Details
Deploy Promiscuity Character API / deploy (push) Successful in 57s
Details
Deploy Promiscuity Inventory API / deploy (push) Successful in 45s
Details
Deploy Promiscuity Locations API / deploy (push) Successful in 58s
Details
k8s smoke test / test (push) Successful in 8s
Details

Browse Source
This commit is contained in:
admin
2026-03-20 09:11:44 -05:00
parent 1320e0a0ac
commit 8ce6a05710
19 changed files with 720 additions and 531 deletions
Download Patch File Download Diff File Expand all files Collapse all files
microservices/CharacterApi/Services/CharacterStore.cs
-445
View File
@@ -1,5 +1,4 @@
using CharacterApi.Models;
using MongoDB.Bson;
using MongoDB.Driver;
namespace CharacterApi.Services;
@@ -7,51 +6,6 @@ namespace CharacterApi.Services;
public class CharacterStore
{
private readonly IMongoCollection<Character> _col;
private readonly IMongoCollection<BsonDocument> _locations;
private const string CoordIndexName = "coord_x_1_coord_y_1";
private const int WorldSeed = 1729;
private static readonly string[] BiomeOrder = ["plains", "forest", "wetlands", "rocky", "desert"];
private static readonly Dictionary<string, BiomeDefinition> Biomes = new()
{
["plains"] = new("plains", 3.0, new()
{
["forest"] = 1.7,
["wetlands"] = 0.9,
["rocky"] = 0.8,
["desert"] = 0.4
}),
["forest"] = new("forest", 3.4, new()
{
["plains"] = 1.6,
["wetlands"] = 1.3,
["rocky"] = 0.5,
["desert"] = 0.1
}),
["wetlands"] = new("wetlands", 3.1, new()
{
["forest"] = 1.5,
["plains"] = 1.1,
["rocky"] = 0.2,
["desert"] = 0.05
}),
["rocky"] = new("rocky", 3.0, new()
{
["plains"] = 1.2,
["forest"] = 0.6,
["desert"] = 1.1,
["wetlands"] = 0.1
}),
["desert"] = new("desert", 3.2, new()
{
["rocky"] = 1.4,
["plains"] = 0.8,
["forest"] = 0.1,
["wetlands"] = 0.05
})
};
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)
{
@@ -60,8 +14,6 @@ public class CharacterStore
var client = new MongoClient(cs);
var db = client.GetDatabase(dbName);
_col = db.GetCollection<Character>("Characters");
_locations = db.GetCollection<BsonDocument>("Locations");
EnsureLocationCoordIndexes();
var ownerIndex = Builders<Character>.IndexKeys.Ascending(c => c.OwnerUserId);
_col.Indexes.CreateOne(new CreateIndexModel<Character>(ownerIndex));
@@ -83,370 +35,6 @@ public class CharacterStore
return result.ModifiedCount > 0 || result.MatchedCount > 0;
}
public Task<List<VisibleLocation>> GetVisibleLocationsAsync(Character character) =>
GetVisibleLocationsInternalAsync(character, ensureGenerated: false);
public async Task<VisibleLocationResult> GetOrCreateVisibleLocationsAsync(Character character)
{
var generatedCount = await EnsureVisibleLocationsExistAsync(character);
var locations = await GetVisibleLocationsInternalAsync(character, ensureGenerated: true);
return new VisibleLocationResult(locations, generatedCount);
}
private async Task<List<VisibleLocation>> GetVisibleLocationsInternalAsync(Character character, bool ensureGenerated)
{
var radius = character.VisionRadius > 0 ? character.VisionRadius : 3;
var minX = character.Coord.X - radius;
var maxX = character.Coord.X + radius;
var minY = character.Coord.Y - radius;
var maxY = character.Coord.Y + radius;
var filter = Builders<BsonDocument>.Filter.And(
Builders<BsonDocument>.Filter.Gte("coord.x", minX),
Builders<BsonDocument>.Filter.Lte("coord.x", maxX),
Builders<BsonDocument>.Filter.Gte("coord.y", minY),
Builders<BsonDocument>.Filter.Lte("coord.y", maxY)
);
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();
}
private async Task<int> EnsureVisibleLocationsExistAsync(Character character)
{
var radius = character.VisionRadius > 0 ? character.VisionRadius : 3;
var generatedCount = 0;
for (var x = character.Coord.X - radius; x <= character.Coord.X + radius; x++)
{
for (var y = character.Coord.Y - radius; y <= character.Coord.Y + radius; y++)
{
if (await EnsureLocationStateAsync(x, y))
generatedCount += 1;
}
}
return generatedCount;
}
private async Task<bool> EnsureLocationStateAsync(int x, int y)
{
var filter = Builders<BsonDocument>.Filter.And(
Builders<BsonDocument>.Filter.Eq("coord.x", x),
Builders<BsonDocument>.Filter.Eq("coord.y", y)
);
var existing = await _locations.Find(filter).FirstOrDefaultAsync();
if (existing is not null)
{
await BackfillLocationStateAsync(existing);
return false;
}
var biomeKey = await DetermineBiomeKeyAsync(x, y);
var update = Builders<BsonDocument>.Update
.SetOnInsert("_id", ObjectId.GenerateNewId())
.SetOnInsert("name", DefaultLocationName(x, y))
.SetOnInsert("coord", new BsonDocument
{
{ "x", x },
{ "y", y }
})
.SetOnInsert("biomeKey", biomeKey)
.SetOnInsert("locationObject", CreateLocationObjectValueForBiome(biomeKey, x, y))
.SetOnInsert("locationObjectResolved", true)
.SetOnInsert("createdUtc", DateTime.UtcNow);
try
{
var result = await _locations.UpdateOneAsync(filter, update, new UpdateOptions { IsUpsert = true });
return result.UpsertedId is not null;
}
catch (MongoWriteException ex) when (ex.WriteError.Category == ServerErrorCategory.DuplicateKey)
{
return false;
}
}
private async Task BackfillLocationStateAsync(BsonDocument document)
{
var coord = document.GetValue("coord", new BsonDocument()).AsBsonDocument;
var x = coord.GetValue("x", 0).ToInt32();
var y = coord.GetValue("y", 0).ToInt32();
var updates = new List<UpdateDefinition<BsonDocument>>();
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 (!objectResolved)
{
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;
var id = document.GetValue("_id").AsObjectId;
await _locations.UpdateOneAsync(
Builders<BsonDocument>.Filter.Eq("_id", id),
Builders<BsonDocument>.Update.Combine(updates));
}
private async Task<string> DetermineBiomeKeyAsync(int x, int y)
{
if (x == 0 && y == 0)
return "plains";
var neighbors = await LoadNeighborBiomeKeysAsync(x, y);
var baseBiome = DetermineBaseBiomeKey(x, y);
if (neighbors.Count == 0)
return baseBiome;
var dominantNeighbor = neighbors
.GroupBy(key => key)
.OrderByDescending(group => group.Count())
.ThenBy(group => group.Key)
.First().Key;
var bestBiome = baseBiome;
var bestScore = double.NegativeInfinity;
foreach (var candidate in BiomeOrder)
{
var score = candidate == baseBiome ? 2.5 : 0.35;
if (candidate == dominantNeighbor)
score += 1.8;
foreach (var neighbor in neighbors)
{
if (!Biomes.TryGetValue(neighbor, out var neighborDefinition))
continue;
if (candidate == neighbor)
score += neighborDefinition.ContinuationWeight;
else if (neighborDefinition.TransitionWeights.TryGetValue(candidate, out var transitionWeight))
score += transitionWeight;
}
score += StableNoise(x, y, StableHash(candidate)) * 0.25;
if (score > bestScore)
{
bestScore = score;
bestBiome = candidate;
}
}
return bestBiome;
}
private async Task<List<string>> LoadNeighborBiomeKeysAsync(int x, int y)
{
var coords = new[] { (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),
Builders<BsonDocument>.Filter.Eq("coord.y", coord.Item2)))
.ToList();
var filter = Builders<BsonDocument>.Filter.Or(filters);
var neighbors = await _locations.Find(filter).ToListAsync();
return neighbors
.Where(doc => doc.Contains("biomeKey"))
.Select(doc => doc.GetValue("biomeKey", "plains").AsString)
.Where(key => !string.IsNullOrWhiteSpace(key))
.ToList();
}
private static string DetermineBaseBiomeKey(int x, int y)
{
var temperature = StableNoise(x, y, 101);
var moisture = StableNoise(x, y, 202);
var ruggedness = StableNoise(x, y, 303);
if (ruggedness > 0.74)
return "rocky";
if (moisture > 0.72 && temperature < 0.75)
return "wetlands";
if (moisture > 0.56)
return "forest";
if (moisture < 0.22 && temperature > 0.58)
return "desert";
return "plains";
}
private static BsonValue CreateLocationObjectValueForBiome(string biomeKey, int x, int y)
{
var roll = StableNoise(x, y, 401);
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)
}
};
}
private static BsonDocument? TryMigrateLegacyResource(BsonDocument document)
{
if (!document.TryGetValue("resources", out var resourcesValue) || resourcesValue is not BsonArray resources)
return null;
foreach (var resourceValue in resources)
{
if (resourceValue is not BsonDocument resource)
continue;
var remainingQuantity = resource.GetValue("remainingQuantity", 0).ToInt32();
if (remainingQuantity <= 0)
continue;
var itemKey = NormalizeItemKey(resource.GetValue("itemKey", "").AsString);
var gatherQuantity = Math.Max(1, resource.GetValue("gatherQuantity", 1).ToInt32());
return CreateGatherableObjectDocument(itemKey, remainingQuantity, gatherQuantity);
}
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()
{
var indexes = _locations.Indexes.List().ToList();
foreach (var index in indexes)
{
var name = index.GetValue("name", "").AsString;
if (name == "_id_")
continue;
var keyDoc = index.GetValue("key", new BsonDocument()).AsBsonDocument;
if (IsLegacyCoordIndex(keyDoc) || IsUnexpectedCoordIndex(keyDoc))
_locations.Indexes.DropOne(name);
}
var coordIndex = new BsonDocument { { "coord.x", 1 }, { "coord.y", 1 } };
var coordIndexOptions = new CreateIndexOptions { Unique = true, Name = CoordIndexName };
_locations.Indexes.CreateOne(new CreateIndexModel<BsonDocument>(coordIndex, coordIndexOptions));
}
private static bool IsLegacyCoordIndex(BsonDocument keyDoc) =>
keyDoc.ElementCount == 2 &&
keyDoc.TryGetValue("Coord.X", out var xValue) &&
xValue.IsInt32 && xValue.AsInt32 == 1 &&
keyDoc.TryGetValue("Coord.Y", out var yValue) &&
yValue.IsInt32 && yValue.AsInt32 == 1;
private static bool IsUnexpectedCoordIndex(BsonDocument keyDoc)
{
var hasLower = keyDoc.Contains("coord.x") || keyDoc.Contains("coord.y");
var hasUpper = keyDoc.Contains("Coord.X") || keyDoc.Contains("Coord.Y");
return hasUpper || (hasLower && !(keyDoc.Contains("coord.x") && keyDoc.Contains("coord.y")));
}
public async Task<bool> DeleteForOwnerAsync(string id, string ownerUserId, bool allowAnyOwner)
{
var filter = Builders<Character>.Filter.Eq(c => c.Id, id);
@@ -456,37 +44,4 @@ public class CharacterStore
var result = await _col.DeleteOneAsync(filter);
return result.DeletedCount > 0;
}
private static string DefaultLocationName(int x, int y)
{
if (x == 0 && y == 0)
return "Origin";
return $"Location {x},{y}";
}
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;
}
}
}