KxGame/Kg.SeaTime
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

1111

Browse Source
This commit is contained in:
Putoo
2026-05-25 18:41:27 +08:00
parent 590f7c5290
commit 0afbf6e39a
32 changed files with 2137 additions and 101 deletions
Download Patch File Download Diff File Expand all files Collapse all files

377
Service/Application.Domain/Services/Service/Map/GameMapService.cs
View File

@@ -6,7 +6,7 @@ public class GameMapService(ISqlSugarClient DbClient, IRedisCache redis) : IGame
public async Task<game_city> GetCityInfo(int cityId)
{
string key = string.Format(BaseCache.BaseCacheKeys, "MapCityData", "CityData");
string key = string.Format(BaseCache.BaseCacheKeys, "CityData", "CityInfo");
var data = await redis.GetHashAsync<game_city>(key, cityId.ToString());
if (data == null)
{
@@ -18,9 +18,53 @@ public class GameMapService(ISqlSugarClient DbClient, IRedisCache redis) : IGame
return data;
}
public async Task<List<game_city>> GetCityData()
{
string key = string.Format(BaseCache.BaseCacheKeys, "CityData", "CityData");
var data = await redis.GetAsync<List<game_city>>(key);
if (data == null)
{
var db = DbClient.AsTenant().GetConnectionWithAttr<game_city>();
data = await db.Queryable<game_city>().ToListAsync();
await redis.SetAsync(key, data);
}
return data;
}
public async Task<List<game_city_map>> GetCityMap(int cityId)
{
string key = string.Format(BaseCache.BaseCacheKeys, "CityData", "CityMap");
var data = await redis.GetHashAsync<List<game_city_map>>(key, cityId.ToString());
if (data == null)
{
var db = DbClient.AsTenant().GetConnectionWithAttr<game_city_map>();
data = await db.Queryable<game_city_map>().Where(it => it.cityId == cityId).ToListAsync();
await redis.AddHashAsync(key, cityId.ToString(), data);
}
return data;
}
public async Task<List<game_city_map>> GetCityShowMap(int cityId)
{
string key = string.Format(BaseCache.BaseCacheKeys, "CityData", "CityShowMap");
var data = await redis.GetHashAsync<List<game_city_map>>(key, cityId.ToString());
if (data == null)
{
var db = DbClient.AsTenant().GetConnectionWithAttr<game_city_map>();
data = await db.Queryable<game_city_map>().Where(it => it.cityId == cityId && it.show == 1).ToListAsync();
await redis.AddHashAsync(key, cityId.ToString(), data);
}
return data;
}
public async Task<game_city_map> GetMapInfo(string mapId)
{
string key = string.Format(BaseCache.BaseCacheKeys, "MapCityData", "MapData");
string key = string.Format(BaseCache.BaseCacheKeys, "CityData", "MapData");
var data = await redis.GetHashAsync<game_city_map>(key, mapId);
if (data == null)
{
@@ -32,19 +76,6 @@ public class GameMapService(ISqlSugarClient DbClient, IRedisCache redis) : IGame
return data;
}
public async Task<List<game_city_map>> GetMapCity(int cityId)
{
string key = string.Format(BaseCache.BaseCacheKeys, "MapCityData", "CityShowMap");
var data = await redis.GetHashAsync<List<game_city_map>>(key, cityId.ToString());
if (data == null)
{
var db = DbClient.AsTenant().GetConnectionWithAttr<game_city_map>();
data = await db.Queryable<game_city_map>().Where(it => it.cityId == cityId && it.show == 1).ToListAsync();
await redis.AddHashAsync(key, cityId.ToString(), data);
}
return data;
}
public async Task<int> GetMapCityByMapId(string mapId)
{
@@ -61,7 +92,7 @@ public class GameMapService(ISqlSugarClient DbClient, IRedisCache redis) : IGame
public async Task<List<game_city_npc>> GetMapNpc(string mapId)
{
string key = string.Format(BaseCache.BaseCacheKeys, "MapCityData", "NpcData");
string key = string.Format(BaseCache.BaseCacheKeys, "CityData", "NpcData");
var data = await redis.GetHashAsync<List<game_city_npc>>(key, mapId);
if (data == null)
{
@@ -75,7 +106,7 @@ public class GameMapService(ISqlSugarClient DbClient, IRedisCache redis) : IGame
public async Task<game_city_npc> GetNpcInfo(int npcId)
{
string key = string.Format(BaseCache.BaseCacheKeys, "MapCityData", "NpcInfo");
string key = string.Format(BaseCache.BaseCacheKeys, "CityData", "NpcInfo");
var data = await redis.GetHashAsync<game_city_npc>(key, npcId.ToString());
if (data == null)
{
@@ -131,6 +162,119 @@ public class GameMapService(ISqlSugarClient DbClient, IRedisCache redis) : IGame
}
}
public async Task<bool> UpdateUserOnMap(unit_user_online data, string mapId)
{
data.mapId = mapId;
data.upTime = TimeAssist.GetTimeStampNum;
string key = string.Format(UserCache.BaseCacheKey, "UserOnline");
if (await redis.AddHashAsync(key, data.userId, data))
{
var db = DbClient.AsTenant().GetConnectionWithAttr<unit_user_online>();
await db.Updateable<unit_user_online>(data).ExecuteCommandAsync();
}
return true;
}
public async Task SetUserMapDefult(string userId)
{
var userMap = await GetUserOnMap(userId);
var MapInfo = await GetMapInfo(userMap.mapId);
if (MapInfo != null)
{
await UpdateUserOnMap(userMap, MapInfo.retMap);
}
}
public async Task<game_city_map> GetToMapInfo(string userId, string toMap, bool isUpUserMap = true,
bool isChangeCity = false)
{
bool result = false;
var onMapUser = await GetUserOnMap(userId);
var onMap = onMapUser.mapId;
var onMapInfo = await GetMapInfo(onMap);
var mapInfo = await GetMapInfo(toMap);
if (onMap == toMap) //相同地图不更新
{
if (isUpUserMap)
{
await UpdateUserOnMap(onMapUser, toMap);
}
return mapInfo;
}
else
{
//更新挂机,结束挂机
}
if (mapInfo == null)
{
var myOnMap = await GetMapInfo(onMap);
return myOnMap;
}
if (isChangeCity)
{
result = true;
}
else
{
if (mapInfo.show == 1)
{
result = true;
}
else
{
string[] onMaps = onMap.Split('_');
int onMapX = Convert.ToInt32(onMaps[0]);
int onMapY = Convert.ToInt32(onMaps[1]);
if (onMapX == mapInfo.x)
{
if (onMapY == (mapInfo.y - 1) || onMapY == (mapInfo.y + 1))
{
result = true;
}
}
else
{
if (onMapY == mapInfo.y)
{
if (onMapX == (mapInfo.x - 1) || onMapX == (mapInfo.x + 1))
{
result = true;
}
}
}
}
//当传送有效时，此处判断是否跨城市
if (result)
{
result = onMapInfo.cityId == mapInfo.cityId;
}
}
if (isUpUserMap && result)
{
result = await UpdateUserOnMap(onMapUser, toMap);
}
if (result)
{
if (mapInfo.lockTime > 0)
{
// await SetUserMapLock(userId, (int)mapInfo.lockTime); //增加地图锁定
}
return mapInfo;
}
else
{
return onMapInfo;
}
}
#endregion
#region 其他相关
@@ -141,7 +285,7 @@ public class GameMapService(ISqlSugarClient DbClient, IRedisCache redis) : IGame
long time = TimeExtend.GetTimeStampBySeconds(DateTime.Now.AddMinutes(0 - GameConfig.OnLineTime));
var data = await db.Queryable<unit_user_online>().Where(it => it.upTime > time && it.mapId == mapId)
.WhereIF(noUser.Count > 0, it => !noUser.Contains(it.userId))
.OrderByDescending(it=>it.upTime)
.OrderByDescending(it => it.upTime)
.ToListAsync();
List<UserModel> result = new List<UserModel>();
@@ -168,11 +312,204 @@ public class GameMapService(ISqlSugarClient DbClient, IRedisCache redis) : IGame
{
var data = await GetMapUser(mapId, area, showArea, noUser);
total = data.Count;
return data.Skip((page - 1) * limit) // 跳过前面的页
.Take(limit) // 取当前页
return data.Skip((page - 1) * limit) // 跳过前面的页
.Take(limit) // 取当前页
.ToList();
}
#endregion
#region 自动寻路
private async Task<List<game_city>> GetCityDataExcludeParent()
{
string key = string.Format(BaseCache.BaseCacheKeys, "MapPathData", "CityParent");
var data = await redis.GetAsync<List<game_city>>(key);
if (data == null)
{
var db = DbClient.AsTenant().GetConnectionWithAttr<game_city>();
data = await db.Queryable<game_city>().Where(it => it.parent != 0).ToListAsync();
await redis.SetAsync(key, data);
}
return data;
}
private async Task<List<game_city_map>> GetAllMaoToData()
{
string key = string.Format(BaseCache.BaseCacheKeys, "MapPathData", "CityInterCityPortal");
if (await redis.ExistsAsync(key))
{
return await redis.GetAsync<List<game_city_map>>(key);
}
List<game_city_map> result = new List<game_city_map>();
var cityData = await GetCityDataExcludeParent();
foreach (var item in cityData)
{
if (!string.IsNullOrEmpty(item.toMap))
{
var map = await GetMapInfo(item.toMap);
if (map != null)
{
result.Add(map);
}
}
}
await redis.SetAsync(key, result);
return result;
}
/// <summary>
/// 城市信息
/// </summary>
/// <returns></returns>
private async Task<List<CityNode>> GetCityNode()
{
string key = string.Format(BaseCache.BaseCacheKeys, "MapPathData", "CityNode");
var data = await redis.GetAsync<List<CityNode>>(key);
if (data == null)
{
data = new List<CityNode>();
var cityData = await GetCityDataExcludeParent(); //获取所有城市
foreach (var city in cityData)
{
var mdMap = await GetMapInfo(city.toMap);
if (mdMap != null)
{
var cityTemp = new CityNode(city.cityId, city.cityName, new Point((int)mdMap.x, (int)mdMap.y),
mdMap.mapName, (int)city.x_s, (int)city.x_e, (int)city.y_s, (int)city.y_e);
data.Add(cityTemp);
}
}
await redis.SetAsync(key, data);
}
return data;
}
/// <summary>
/// 城市网络
/// </summary>
/// <returns></returns>
private async Task<Dictionary<int, List<game_city_map>>> GetCityRoadNetwork()
{
string key = string.Format(BaseCache.BaseCacheKeys, "MapPathData", "CityRoadNetwork");
var data = await redis.GetAsync<Dictionary<int, List<game_city_map>>>(key);
if (data == null)
{
data = new Dictionary<int, List<game_city_map>>();
var cityData = await GetCityDataExcludeParent(); //获取所有城市
foreach (var city in cityData)
{
//添加地图
var mapData = await GetCityMap(city.cityId);
data.Add(city.cityId, mapData);
}
await redis.SetAsync(key, data);
}
return data;
}
/// <summary>
/// 传送点信息
/// </summary>
/// <returns></returns>
private async Task<List<InterCityPortal>> GetCityInterCityPortal()
{
string key = string.Format(BaseCache.BaseCacheKeys, "CityData", "CityInterCityPortal");
var data = await redis.GetAsync<List<InterCityPortal>>(key);
if (data == null)
{
data = new List<InterCityPortal>();
var toAddr = await GetAllMaoToData(); //获取所有传送点
var cityData = await GetCityDataExcludeParent(); //获取所有城市
foreach (var item in toAddr)
{
var toMapInfo = await GetMapInfo(item.retMap);
//获取反向传送点
var retAddr = cityData.Find(it => it.cityId == (int)item.cityId);
data.Add(new InterCityPortal(item.mapId, (int)item.cityId, new Point((int)item.x, (int)item.y),
(int)toMapInfo.cityId, item.mapName, 1, retAddr.toMap));
}
await redis.SetAsync(key, data);
}
return data;
}
private async Task<List<MapLine>> FinderMapLine(Point start, Point end)
{
//初始化
var globalNetwork = new GlobalRoadNetwork();
//注册城市
var NodeData = await GetCityNode();
NodeData.ForEach(item => { globalNetwork.AddCity(item); });
//注册传送点
var CityInterCityPortal = await GetCityInterCityPortal();
CityInterCityPortal.ForEach(item => { globalNetwork.AddPortal(item); });
var pathFinder = new CrossCityPathFinder(globalNetwork); //初始化寻找器
//注册城市网络
List<CityRoadNetwork> NetworkData = new List<CityRoadNetwork>();
var NetworkCityData = await GetCityRoadNetwork();
foreach (var cityNet in NetworkCityData)
{
var cityNetwork = new CityRoadNetwork(cityNet.Key);
foreach (var map in cityNet.Value)
{
cityNetwork.AddWalkablePoint((int)map.x, (int)map.y);
}
NetworkData.Add(cityNetwork);
}
NetworkData.ForEach(item => { pathFinder.AddCityRoadNetwork(item); });
//获取所有城市ID
var cityData = await GetCityDataExcludeParent();
List<int> cityRoute = cityData.Select(it => it.cityId).ToList();
var path = pathFinder.FindCrossCityPath(start, end);
List<MapLine> result = new List<MapLine>();
if (path != null)
{
foreach (var item in path)
{
if (item.StepType == PathStepType.Move)
{
MapLine line = new MapLine();
line.x = item.Position.X;
line.y = item.Position.Y;
line.mapId = $"{line.x}_{line.y}";
result.Add(line);
}
}
}
return result;
}
public async Task<List<MapLine>> CreateAutoMap(string start, string end)
{
//获取所有起始点
var startMap = await GetMapInfo(start);
var endMap = await GetMapInfo(end);
Point startPoint = new Point((int)startMap.x, (int)startMap.y);
Point endPoint = new Point((int)endMap.x, (int)endMap.y);
var result = await FinderMapLine(startPoint, endPoint);
if (result.Count > 0)
{
result.RemoveAt(0);
}
return result;
}
#endregion
}