939 lines
39 KiB
C#
939 lines
39 KiB
C#
using Amazon.Runtime.Internal;
|
|
using Amazon.Runtime.Internal.Transform;
|
|
using GameServer;
|
|
using Newtonsoft.Json;
|
|
using NLog.LayoutRenderers;
|
|
using Org.BouncyCastle.Asn1.Ocsp;
|
|
using ServerCommon;
|
|
using ServerCore; using ServerBase;
|
|
using System;
|
|
using System.Collections.Concurrent;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using static ClientToGameReq.Types;
|
|
|
|
namespace GameServer
|
|
{
|
|
public class WorldMapTree
|
|
{
|
|
public int WorldMetaId { get; }
|
|
public string WorldMapFileName { get; }
|
|
|
|
public Dictionary<int, LandMapTree> ChildLandMapTrees = new();
|
|
public Dictionary<string, AnchorTree> Anchors = new();
|
|
|
|
public WorldMapTree(int worldMetaId, string worldMapFileName)
|
|
{
|
|
WorldMetaId = worldMetaId;
|
|
WorldMapFileName = worldMapFileName;
|
|
}
|
|
}
|
|
|
|
public class LandMapTree
|
|
{
|
|
public int LandId { get; }
|
|
public string LandMapFileName { get; }
|
|
public WorldMapTree ParentWorldMapTree { get; }
|
|
|
|
public BuildingMapTree? ChildBuildingMapTree;
|
|
public Dictionary<string, AnchorTree> Anchors = new();
|
|
|
|
public LandMapTree(int landMetaId, string landMapFileName, WorldMapTree parentWorldMapTree)
|
|
{
|
|
LandId = landMetaId;
|
|
LandMapFileName = landMapFileName;
|
|
ParentWorldMapTree = parentWorldMapTree;
|
|
}
|
|
}
|
|
|
|
public class BuildingMapTree
|
|
{
|
|
public int BuildingMetaId { get; }
|
|
public string BuildingMapFileName { get; }
|
|
public LandMapTree ParentLandMapTree { get; }
|
|
|
|
public Dictionary<int, RoomMapTree> ChildRoomMapTrees = new();
|
|
public Dictionary<string, AnchorTree> Anchors = new();
|
|
|
|
public BuildingMapTree(int buildingMetaId, string buildingMapFileName, LandMapTree parentLandMapTree)
|
|
{
|
|
BuildingMetaId = buildingMetaId;
|
|
BuildingMapFileName = buildingMapFileName;
|
|
ParentLandMapTree = parentLandMapTree;
|
|
}
|
|
}
|
|
|
|
public class RoomMapTree
|
|
{
|
|
public int InstanceMetaId { get; }
|
|
public string RoomMapFileName { get; }
|
|
public BuildingMapTree ParentBuildingMapTree { get; }
|
|
public string OwnerGuid { get; set; } = string.Empty;
|
|
public string MyhomeGuid { get; set; } = string.Empty;
|
|
public string InstanceName { get; set; } = string.Empty;
|
|
public int ThumbnailImageId { get; set; }
|
|
public int ListImageId { get; set; }
|
|
public int EnterPlayerCount { get; set; }
|
|
|
|
public Dictionary<string, AnchorTree> Anchors = new();
|
|
public List<string> UgcNpcs = new();
|
|
|
|
public RoomMapTree(int instanceMetaId, string roomMapFileName, BuildingMapTree parentBuildingMapTree)
|
|
{
|
|
InstanceMetaId = instanceMetaId;
|
|
RoomMapFileName = roomMapFileName;
|
|
ParentBuildingMapTree = parentBuildingMapTree;
|
|
}
|
|
}
|
|
|
|
public class PersonalRoom
|
|
{
|
|
public Dictionary<string, AnchorTree> Anchors = new();
|
|
}
|
|
|
|
public class AnchorTree
|
|
{
|
|
public string ParentMapFileName;
|
|
public string AnchorGuid;
|
|
public Pos AnchorPos;
|
|
public AnchorProp AnchorProp = new();
|
|
|
|
public AnchorTree(string parentMapFileName, string anchorGuid, Pos anchorPos)
|
|
{
|
|
ParentMapFileName = parentMapFileName;
|
|
AnchorGuid = anchorGuid;
|
|
AnchorPos = anchorPos;
|
|
}
|
|
}
|
|
|
|
public partial class MapManager
|
|
{
|
|
private static readonly MapManager _instance = new();
|
|
static MapManager() { }
|
|
private MapManager() { }
|
|
public static MapManager Instance { get { return _instance; } }
|
|
|
|
ConcurrentDictionary<string, WorldMapTree> WorldMapTrees = new();
|
|
ConcurrentDictionary<string, LandMapTree> LandMapTrees = new();
|
|
ConcurrentDictionary<string, BuildingMapTree> BuildingMapTrees = new();
|
|
ConcurrentDictionary<string, RoomMapTree> RoomMapTrees = new();
|
|
ConcurrentDictionary<string, AnchorTree> AnchorTrees = new();
|
|
|
|
ConcurrentDictionary<string, PersonalRoom> PersonalRooms = new();
|
|
ConcurrentDictionary<string, MyhomeUgcInfo> m_myhome_ugc_infos = new();
|
|
|
|
List<Pos> BotStartPos = new();
|
|
|
|
public void Load()
|
|
{
|
|
foreach (var world_meta_data in MetaData.Instance._WorldMetaTable.Values)
|
|
{
|
|
var world_map_file_name = world_meta_data.MapPath;
|
|
if (!MapDataTable.Instance.getMapData(world_map_file_name, out var world_map_data))
|
|
{
|
|
Log.getLogger().error($"Not Exist MapData !!! : fileName:{world_map_file_name}");
|
|
continue;
|
|
}
|
|
|
|
var world_map_tree = new WorldMapTree(world_meta_data.Id, world_map_file_name);
|
|
if (!WorldMapTrees.TryAdd(world_map_file_name, world_map_tree))
|
|
{
|
|
WorldMapTrees.TryGetValue(world_map_file_name, out var duplicate_map_tree);
|
|
Log.getLogger().error($"Exist WorldMapFile:{world_map_file_name} - WorldMetaId:{world_meta_data.Id}, WorldMetaId:{duplicate_map_tree?.WorldMetaId}");
|
|
continue;
|
|
}
|
|
|
|
foreach (var anchor in world_map_data.Anchors)
|
|
{
|
|
var new_anchor_pos = anchor.Position.toPos();
|
|
new_anchor_pos.Angle = (int)(anchor.Rotation.Yaw);
|
|
|
|
var anchor_tree = new AnchorTree(world_map_file_name, anchor.GUID, new_anchor_pos);
|
|
|
|
anchor_tree.AnchorProp.TableId = anchor.TableID;
|
|
if (anchor.MannequinItems.Count > 0)
|
|
anchor_tree.AnchorProp.Mannequins = anchor.MannequinItems.ToList();
|
|
|
|
world_map_tree.Anchors.TryAdd(anchor.GUID, anchor_tree);
|
|
AnchorTrees.TryAdd(anchor.GUID, anchor_tree);
|
|
}
|
|
|
|
// Land
|
|
foreach (var land_name in world_map_data.LandNames)
|
|
{
|
|
var land_map_file_name = $"{land_name}.land";
|
|
if (!MapDataTable.Instance.getMapData(land_map_file_name, out var land_map_data))
|
|
{
|
|
Log.getLogger().error($"Not Exist MapData !!! : fileName:{land_map_file_name} or CHECK LandData.xlsx");
|
|
continue;
|
|
}
|
|
|
|
if (land_map_data.MapFileType != MapFileType.Land)
|
|
continue;
|
|
|
|
var land_meta_id = land_map_data.MapMetaId;
|
|
|
|
var land_map_tree = new LandMapTree(land_meta_id, land_map_file_name, world_map_tree);
|
|
if (!LandMapTrees.TryAdd(land_map_file_name, land_map_tree))
|
|
{
|
|
LandMapTrees.TryGetValue(land_map_file_name, out var duplicate_map_tree);
|
|
Log.getLogger().error($"Exist LandMapFile:{land_map_file_name} - fileName:{world_map_file_name}, fileName:{duplicate_map_tree?.ParentWorldMapTree.WorldMapFileName}");
|
|
continue;
|
|
}
|
|
|
|
world_map_tree.ChildLandMapTrees.Add(land_meta_id, land_map_tree);
|
|
|
|
foreach (var anchor in land_map_data.Anchors)
|
|
{
|
|
var new_anchor_position = TransformHelper.rotate(anchor.Position, land_map_data.Rotation);
|
|
|
|
new_anchor_position.X += land_map_data.Position.X;
|
|
new_anchor_position.Y += land_map_data.Position.Y;
|
|
new_anchor_position.Z += land_map_data.Position.Z;
|
|
|
|
var new_anchor_pos = new_anchor_position.toPos();
|
|
new_anchor_pos.Angle = (int)(land_map_data.Rotation.Yaw + anchor.Rotation.Yaw);
|
|
|
|
var anchor_tree = new AnchorTree(land_map_file_name, anchor.GUID, new_anchor_pos);
|
|
|
|
anchor_tree.AnchorProp.TableId = anchor.TableID;
|
|
if (anchor.MannequinItems.Count > 0)
|
|
anchor_tree.AnchorProp.Mannequins = anchor.MannequinItems.ToList();
|
|
|
|
land_map_tree.Anchors.TryAdd(anchor.GUID, anchor_tree);
|
|
AnchorTrees.TryAdd(anchor.GUID, anchor_tree);
|
|
}
|
|
|
|
// Building
|
|
foreach (var building_data in land_map_data.BuildingDatas)
|
|
{
|
|
var building_map_file_name = Path.GetFileName(building_data.BuildingName);
|
|
if (!MapDataTable.Instance.getMapData(building_map_file_name, out var building_map_data))
|
|
{
|
|
Log.getLogger().error($"Not Exist MapData !!! : fileName:{building_map_file_name} or CHECK BuildingData.xlsx");
|
|
continue;
|
|
}
|
|
|
|
if (building_map_data.MapFileType != MapFileType.Building)
|
|
continue;
|
|
|
|
var building_meta_id = building_map_data.MapMetaId;
|
|
|
|
var building_map_tree = new BuildingMapTree(building_meta_id, building_map_file_name, land_map_tree);
|
|
if (!BuildingMapTrees.TryAdd(building_map_file_name, building_map_tree))
|
|
{
|
|
BuildingMapTrees.TryGetValue(building_map_file_name, out var duplicate_map_tree);
|
|
Log.getLogger().error($"Exist BuildingMapFile:{building_map_file_name} - filename:{land_map_file_name}, fileName:{duplicate_map_tree?.ParentLandMapTree.LandMapFileName}");
|
|
continue;
|
|
}
|
|
|
|
land_map_tree.ChildBuildingMapTree = building_map_tree;
|
|
|
|
foreach (var anchor in building_map_data.Anchors)
|
|
{
|
|
var new_anchor_position = TransformHelper.rotate(anchor.Position, building_map_data.Rotation);
|
|
|
|
new_anchor_position.X += building_data.Position.X;
|
|
new_anchor_position.Y += building_data.Position.Y;
|
|
new_anchor_position.Z += building_data.Position.Z;
|
|
|
|
new_anchor_position = TransformHelper.rotate(new_anchor_position, land_map_data.Rotation);
|
|
|
|
new_anchor_position.X += land_map_data.Position.X;
|
|
new_anchor_position.Y += land_map_data.Position.Y;
|
|
new_anchor_position.Z += land_map_data.Position.Z;
|
|
|
|
var new_anchor_pos = new_anchor_position.toPos();
|
|
new_anchor_pos.Angle = (int)(building_map_data.Rotation.Yaw + land_map_data.Rotation.Yaw + anchor.Rotation.Yaw);
|
|
|
|
var anchor_tree = new AnchorTree(building_map_file_name, anchor.GUID, new_anchor_pos);
|
|
|
|
anchor_tree.AnchorProp.TableId = anchor.TableID;
|
|
if (anchor.MannequinItems.Count > 0)
|
|
anchor_tree.AnchorProp.Mannequins = anchor.MannequinItems.ToList();
|
|
|
|
building_map_tree.Anchors.TryAdd(anchor.GUID, anchor_tree);
|
|
AnchorTrees.TryAdd(anchor.GUID, anchor_tree);
|
|
}
|
|
|
|
foreach (var room_data in building_map_data.RoomDatas)
|
|
{
|
|
var room_map_file_name = Path.GetFileName(room_data.RoomName);
|
|
if (!MapDataTable.Instance.getMapData(room_map_file_name, out var room_map_data))
|
|
{
|
|
Log.getLogger().error($"Not Exist MapData !!! : fileName:{room_map_file_name} or CHECK InstanceData.xlsx");
|
|
continue;
|
|
}
|
|
|
|
if (room_map_data.MapFileType != MapFileType.Instance)
|
|
continue;
|
|
|
|
var instance_meta_id = room_map_data.MapMetaId;
|
|
if (!MetaData.Instance._IndunTable.TryGetValue(instance_meta_id, out var indun_meta_data))
|
|
{
|
|
Log.getLogger().error($"Failed to MetaData.TryGetValue() !!! : instanceMetaId:{instance_meta_id}");
|
|
continue;
|
|
}
|
|
|
|
var room_map_tree = new RoomMapTree(instance_meta_id, room_map_file_name, building_map_tree);
|
|
if (!RoomMapTrees.TryAdd(room_map_file_name, room_map_tree))
|
|
{
|
|
RoomMapTrees.TryGetValue(room_map_file_name, out var duplicate_map_tree);
|
|
Log.getLogger().error($"Exist RoomMapFile:{room_map_file_name} - fileName:{building_map_file_name}, fileName:{duplicate_map_tree?.ParentBuildingMapTree.BuildingMapFileName}");
|
|
continue;
|
|
}
|
|
|
|
if (!building_map_tree.ChildRoomMapTrees.TryAdd(indun_meta_data.Building_Socket_, room_map_tree))
|
|
{
|
|
building_map_tree.ChildRoomMapTrees.TryGetValue(indun_meta_data.Building_Socket_, out var duplicate_room_map_tree);
|
|
Log.getLogger().error($"Exist Floor !!! buildingMetaId:{building_meta_id}, floor:{indun_meta_data.Building_Socket_} - fileName:{room_map_tree.RoomMapFileName}, fileName:{duplicate_room_map_tree?.RoomMapFileName}");
|
|
continue;
|
|
}
|
|
|
|
foreach (var anchor in room_map_data.Anchors)
|
|
{
|
|
var new_anchor_position = TransformHelper.rotate(anchor.Position, room_map_data.Rotation);
|
|
|
|
new_anchor_position.X += room_data.Position.X;
|
|
new_anchor_position.Y += room_data.Position.Y;
|
|
new_anchor_position.Z += room_data.Position.Z;
|
|
|
|
new_anchor_position = TransformHelper.rotate(new_anchor_position, building_map_data.Rotation);
|
|
|
|
new_anchor_position.X += building_data.Position.X;
|
|
new_anchor_position.Y += building_data.Position.Y;
|
|
new_anchor_position.Z += building_data.Position.Z;
|
|
|
|
new_anchor_position = TransformHelper.rotate(new_anchor_position, land_map_data.Rotation);
|
|
|
|
new_anchor_position.X += land_map_data.Position.X;
|
|
new_anchor_position.Y += land_map_data.Position.Y;
|
|
new_anchor_position.Z += land_map_data.Position.Z;
|
|
|
|
var new_anchor_pos = new_anchor_position.toPos();
|
|
new_anchor_pos.Angle = (int)(room_map_data.Rotation.Yaw + building_map_data.Rotation.Yaw + land_map_data.Rotation.Yaw + anchor.Rotation.Yaw);
|
|
|
|
var anchor_tree = new AnchorTree(room_map_file_name, anchor.GUID, new_anchor_pos);
|
|
|
|
anchor_tree.AnchorProp.TableId = anchor.TableID;
|
|
if (anchor.MannequinItems.Count > 0)
|
|
anchor_tree.AnchorProp.Mannequins = anchor.MannequinItems.ToList();
|
|
|
|
room_map_tree.Anchors.TryAdd(anchor.GUID, anchor_tree);
|
|
AnchorTrees.TryAdd(anchor.GUID, anchor_tree);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
LoadPersonal(ServerCommon.Constant.DRESS_ROOM_INSTANCE_META_ID);
|
|
LoadPersonal(ServerCommon.Constant.EDIT_ROOM_INSTANCE_META_ID);
|
|
|
|
loadMyhomeUgcInfo();
|
|
}
|
|
|
|
void LoadPersonal(int instanceId)
|
|
{
|
|
if (!MetaData.Instance._IndunTable.TryGetValue(instanceId, out var instanceData))
|
|
{
|
|
Log.getLogger().error($"Not Found InstanceData:{instanceId}");
|
|
return;
|
|
}
|
|
|
|
if (!MapDataTable.Instance.getMapData(instanceData.RoomFile, out var personalMapData))
|
|
{
|
|
Log.getLogger().error($"Not Exist MapData {instanceData.RoomFile}");
|
|
return;
|
|
}
|
|
|
|
var warp_pos = MapHelper.getWarpPos(instanceData.ContentsType);
|
|
|
|
personalMapData.Position.X = warp_pos.X;
|
|
personalMapData.Position.Y = warp_pos.Y;
|
|
personalMapData.Position.Z = warp_pos.Z;
|
|
|
|
var personalRoom = new PersonalRoom();
|
|
|
|
foreach (var anchor in personalMapData.Anchors)
|
|
{
|
|
var newAnchorPosition = TransformHelper.rotate(anchor.Position, personalMapData.Rotation);
|
|
newAnchorPosition.X += personalMapData.Position.X;
|
|
newAnchorPosition.Y += personalMapData.Position.Y;
|
|
newAnchorPosition.Z += personalMapData.Position.Z;
|
|
|
|
var new_anchor_pos = newAnchorPosition.toPos();
|
|
new_anchor_pos.Angle = (int)(personalMapData.Rotation.Yaw + anchor.Rotation.Yaw);
|
|
|
|
var anchorTree = new AnchorTree(instanceData.RoomFile, anchor.GUID, new_anchor_pos);
|
|
anchorTree.AnchorProp.TableId = anchor.TableID;
|
|
if (anchor.MannequinItems.Count > 0)
|
|
anchorTree.AnchorProp.Mannequins = anchor.MannequinItems.ToList();
|
|
|
|
personalRoom.Anchors.TryAdd(anchor.GUID, anchorTree);
|
|
AnchorTrees.TryAdd(anchor.GUID, anchorTree);
|
|
}
|
|
|
|
PersonalRooms.TryAdd(instanceData.RoomFile, personalRoom);
|
|
}
|
|
|
|
bool loadMyhomeUgcInfo()
|
|
{
|
|
// 기본 마이홈
|
|
var default_myhome_ugc_info_file_name = MetaHelper.GameConfigMeta.MyHomeDefaultSaveFileName;
|
|
if (!loadMyhomeFile(default_myhome_ugc_info_file_name))
|
|
return false;
|
|
|
|
// TestUser
|
|
foreach (var meta_data in MetaData.Instance.m_test_user_initial_meta_datas.Values)
|
|
{
|
|
if (meta_data.MyhomeFile == string.Empty)
|
|
continue;
|
|
|
|
if (!loadMyhomeUgcInfoFile(meta_data.MyhomeFile))
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool loadMyhomeFile(string myhomeFileName)
|
|
{
|
|
var map_data_folder_path = Path.GetFullPath("resource/map/DefaultMap", Environment.CurrentDirectory);
|
|
var myhome_file_path = Path.Combine(map_data_folder_path, myhomeFileName);
|
|
|
|
if (!File.Exists(myhome_file_path))
|
|
{
|
|
Log.getLogger().warn($"{myhome_file_path} not exist !!!");
|
|
return false;
|
|
}
|
|
|
|
var myhome_file_data = File.ReadAllText(myhome_file_path);
|
|
var myhome_map_data = JsonConvert.DeserializeObject<MyhomeMapData>(myhome_file_data);
|
|
if (myhome_map_data == null)
|
|
{
|
|
Log.getLogger().warn($"{myhome_file_path} convert fail !!!");
|
|
return false;
|
|
}
|
|
|
|
var myhome_ugc_info = new MyhomeUgcInfo();
|
|
|
|
myhome_ugc_info.RoomType = myhome_map_data.roomtype;
|
|
|
|
foreach (var framework in myhome_map_data.Frameworks)
|
|
{
|
|
var ugcFrameworkInfo = new UgcFrameworkInfo();
|
|
|
|
ugcFrameworkInfo.InteriorItemId = framework.tableid;
|
|
ugcFrameworkInfo.Floor = framework.Floor;
|
|
ugcFrameworkInfo.Coordinate = new();
|
|
ugcFrameworkInfo.Coordinate.X = (float)framework.Position.X;
|
|
ugcFrameworkInfo.Coordinate.Y = (float)framework.Position.Y;
|
|
ugcFrameworkInfo.Coordinate.Z = (float)framework.Position.Z;
|
|
ugcFrameworkInfo.Rotation = new();
|
|
ugcFrameworkInfo.Rotation.Pitch = (float)framework.Rotation.Pitch;
|
|
ugcFrameworkInfo.Rotation.Yaw = (float)framework.Rotation.Yaw;
|
|
ugcFrameworkInfo.Rotation.Roll = (float)framework.Rotation.Roll;
|
|
|
|
myhome_ugc_info.FrameworkInfos.Add(ugcFrameworkInfo);
|
|
}
|
|
|
|
foreach (var anchor in myhome_map_data.Anchors)
|
|
{
|
|
var ugcAnchorInfo = new UgcAnchorInfo();
|
|
|
|
ugcAnchorInfo.AnchorGuid = anchor.GUID;
|
|
ugcAnchorInfo.AnchorType = anchor.Type;
|
|
ugcAnchorInfo.TableId = anchor.TableID;
|
|
ugcAnchorInfo.EntityGuid = anchor.EntityGuid;
|
|
ugcAnchorInfo.Coordinate = new();
|
|
ugcAnchorInfo.Coordinate.X = (float)anchor.Position.X;
|
|
ugcAnchorInfo.Coordinate.Y = (float)anchor.Position.Y;
|
|
ugcAnchorInfo.Coordinate.Z = (float)anchor.Position.Z;
|
|
ugcAnchorInfo.Rotation = new();
|
|
ugcAnchorInfo.Rotation.Pitch = (float)anchor.Rotation.Pitch;
|
|
ugcAnchorInfo.Rotation.Yaw = (float)anchor.Rotation.Yaw;
|
|
ugcAnchorInfo.Rotation.Roll = (float)anchor.Rotation.Roll;
|
|
|
|
myhome_ugc_info.AnchorInfos.Add(ugcAnchorInfo);
|
|
}
|
|
|
|
if (!m_myhome_ugc_infos.TryAdd(myhomeFileName, myhome_ugc_info))
|
|
{
|
|
Log.getLogger().warn($"{myhomeFileName} add fail !!!");
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool loadMyhomeUgcInfoFile(string myhomeUgcInfoFileName)
|
|
{
|
|
var map_data_folder_path = Path.GetFullPath("resource/map/DefaultMap", Environment.CurrentDirectory);
|
|
var myhome_ugc_info_file_path = Path.Combine(map_data_folder_path, myhomeUgcInfoFileName);
|
|
|
|
if (!File.Exists(myhome_ugc_info_file_path))
|
|
{
|
|
Log.getLogger().warn($"{myhome_ugc_info_file_path} not exist !!!");
|
|
return false;
|
|
}
|
|
|
|
var myhome_ugc_info_file_data = File.ReadAllText(myhome_ugc_info_file_path);
|
|
var myhome_ugc_info = JsonConvert.DeserializeObject<MyhomeUgcInfo>(myhome_ugc_info_file_data);
|
|
if (myhome_ugc_info == null)
|
|
{
|
|
Log.getLogger().warn($"{myhome_ugc_info_file_path} convert fail !!!");
|
|
return false;
|
|
}
|
|
|
|
if (!m_myhome_ugc_infos.TryAdd(myhomeUgcInfoFileName, myhome_ugc_info))
|
|
{
|
|
Log.getLogger().warn($"{myhomeUgcInfoFileName} add fail !!!");
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public bool UpdateProp(string anchorGuid, AnchorProp prop)
|
|
{
|
|
if (!AnchorTrees.TryGetValue(anchorGuid, out var anchorTree))
|
|
return false;
|
|
|
|
anchorTree.AnchorProp.TableId = prop.TableId;
|
|
anchorTree.AnchorProp.GuidByType = prop.GuidByType;
|
|
anchorTree.AnchorProp.Mannequins = prop.Mannequins;
|
|
|
|
return true;
|
|
}
|
|
|
|
public void GetMapAnchorList(string mapFileName, out List<AnchorTree> anchorList)
|
|
{
|
|
anchorList = new List<AnchorTree>();
|
|
|
|
switch (Path.GetExtension(mapFileName))
|
|
{
|
|
case ".zone":
|
|
{
|
|
if (!WorldMapTrees.TryGetValue(mapFileName, out var worldMapTree))
|
|
return;
|
|
|
|
anchorList = worldMapTree.Anchors.Values.ToList();
|
|
}
|
|
break;
|
|
case ".land":
|
|
{
|
|
if (!LandMapTrees.TryGetValue(mapFileName, out var landMapTree))
|
|
return;
|
|
|
|
anchorList = landMapTree.Anchors.Values.ToList();
|
|
}
|
|
break;
|
|
case ".build":
|
|
{
|
|
if (!BuildingMapTrees.TryGetValue(mapFileName, out var buildMapTree))
|
|
return;
|
|
|
|
anchorList = buildMapTree.Anchors.Values.ToList();
|
|
}
|
|
break;
|
|
case ".room":
|
|
{
|
|
if (!RoomMapTrees.TryGetValue(mapFileName, out var roomMapTree))
|
|
return;
|
|
|
|
anchorList = roomMapTree.Anchors.Values.ToList();
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
Log.getLogger().error($"{mapFileName} is not map file");
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
public void GetMapAnchorListForMapCreate(string mapFileName, out List<AnchorTree> anchorList)
|
|
{
|
|
anchorList = new List<AnchorTree>();
|
|
|
|
switch (Path.GetExtension(mapFileName))
|
|
{
|
|
case ".zone":
|
|
{
|
|
if (!WorldMapTrees.TryGetValue(mapFileName, out var world))
|
|
return;
|
|
|
|
anchorList.AddRange(world.Anchors.Values);
|
|
|
|
foreach (var land in world.ChildLandMapTrees.Values)
|
|
{
|
|
anchorList.AddRange(land.Anchors.Values);
|
|
|
|
var building = land.ChildBuildingMapTree;
|
|
if (building == null)
|
|
continue;
|
|
|
|
anchorList.AddRange(building.Anchors.Values);
|
|
}
|
|
}
|
|
break;
|
|
case ".room":
|
|
{
|
|
if (PersonalRooms.TryGetValue(mapFileName, out var personalRoom))
|
|
{
|
|
anchorList.AddRange(personalRoom.Anchors.Values);
|
|
return;
|
|
}
|
|
|
|
if (!RoomMapTrees.TryGetValue(mapFileName, out var room))
|
|
return;
|
|
|
|
anchorList.AddRange(room.Anchors.Values);
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
Log.getLogger().error($"{mapFileName} is not map create file");
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
public Pos GetStartPos(string mapFileName)
|
|
{
|
|
Pos startPos = new();
|
|
|
|
var startPosAnchorGuid = MapDataTable.Instance.GetRoomStartPosAnchorGuid(mapFileName);
|
|
|
|
if (!AnchorTrees.TryGetValue(startPosAnchorGuid, out var startPosAnchor))
|
|
{
|
|
return startPos;
|
|
}
|
|
|
|
startPos.X = startPosAnchor.AnchorPos.X;
|
|
startPos.Y = startPosAnchor.AnchorPos.Y;
|
|
startPos.Z = startPosAnchor.AnchorPos.Z + 100;
|
|
|
|
return startPos;
|
|
}
|
|
|
|
public bool GetWorldMapTree(string mapFileName, [MaybeNullWhen(false)] out WorldMapTree worldMapTree)
|
|
{
|
|
return WorldMapTrees.TryGetValue(mapFileName, out worldMapTree);
|
|
}
|
|
|
|
public bool GetLandMapTree(int landMetaId, [MaybeNullWhen(false)] out LandMapTree landMapTree)
|
|
{
|
|
landMapTree = null;
|
|
|
|
if (!MetaData.Instance._LandTable.TryGetValue(landMetaId, out var landData))
|
|
{
|
|
var err_msg = $"Failed to MetaData.TryGetValue() !!! : LandMetaId:{landMetaId}";
|
|
Log.getLogger().error(err_msg);
|
|
|
|
return false;
|
|
}
|
|
|
|
return LandMapTrees.TryGetValue(landData.LandFile, out landMapTree);
|
|
}
|
|
|
|
public bool GetBuildingMapTree(int buildingMetaId, [MaybeNullWhen(false)] out BuildingMapTree buildingMapTree)
|
|
{
|
|
buildingMapTree = null;
|
|
|
|
if (!MetaData.Instance._BuildingTable.TryGetValue(buildingMetaId, out var buildingData))
|
|
{
|
|
var err_msg = $"Failed to MetaData.TryGetValue() !!! : BuildingMetaId:{buildingMetaId}";
|
|
Log.getLogger().error(err_msg);
|
|
|
|
return false;
|
|
}
|
|
|
|
return BuildingMapTrees.TryGetValue(buildingData.BuildingFile, out buildingMapTree);
|
|
}
|
|
|
|
public bool getRoomMapTree(string myhomeGuid, [MaybeNullWhen(false)] out RoomMapTree roomMapTree)
|
|
{
|
|
if (!RoomMapTrees.TryGetValue(myhomeGuid, out roomMapTree))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
public List<int> getLandMetaIds()
|
|
{
|
|
var land_meta_ids = new List<int>();
|
|
|
|
foreach (var land_map_tree in LandMapTrees.Values)
|
|
{
|
|
land_meta_ids.Add(land_map_tree.LandId);
|
|
}
|
|
|
|
return land_meta_ids;
|
|
}
|
|
|
|
public List<int> getBuildingMetaIds()
|
|
{
|
|
var building_meta_ids = new List<int>();
|
|
|
|
foreach (var building_map_tree in BuildingMapTrees.Values)
|
|
{
|
|
building_meta_ids.Add(building_map_tree.BuildingMetaId);
|
|
}
|
|
|
|
return building_meta_ids;
|
|
}
|
|
|
|
public bool tryGetLandChildBuildingMetaId(int landMetaId, out int childBuildingMetaId)
|
|
{
|
|
childBuildingMetaId = 0;
|
|
|
|
if (!GetLandMapTree(landMetaId, out var land_map_tree))
|
|
return false;
|
|
|
|
if (land_map_tree.ChildBuildingMapTree == null)
|
|
return false;
|
|
|
|
childBuildingMetaId = land_map_tree.ChildBuildingMapTree.BuildingMetaId;
|
|
|
|
return true;
|
|
}
|
|
|
|
public void ExchangeMannequinDisplayItem(string anchorGuid, List<int> displayItemIds)
|
|
{
|
|
if (!AnchorTrees.TryGetValue(anchorGuid, out var anchorTree))
|
|
return;
|
|
|
|
anchorTree.AnchorProp.Mannequins = displayItemIds;
|
|
anchorTree.AnchorProp.IsMannequinsChanged = true;
|
|
}
|
|
|
|
public bool getParentMapFileName(string anchorGuid, [MaybeNullWhen(false)] out string parentMapFileName)
|
|
{
|
|
parentMapFileName = null;
|
|
|
|
if (!AnchorTrees.TryGetValue(anchorGuid, out var anchorTree))
|
|
return false;
|
|
|
|
parentMapFileName = anchorTree.ParentMapFileName;
|
|
return true;
|
|
}
|
|
|
|
public bool getDefaultMyhomeUgcInfo(string myhomeUgcInfoFileName, [MaybeNullWhen(false)] out MyhomeUgcInfo myhomeUgcInfo)
|
|
{
|
|
return m_myhome_ugc_infos.TryGetValue(myhomeUgcInfoFileName, out myhomeUgcInfo);
|
|
}
|
|
|
|
public void addRoomMaptree(BuildingMapTree buildingMapTree, int floor, RoomMapTree roomMapTree)
|
|
{
|
|
buildingMapTree.ChildRoomMapTrees[floor] = roomMapTree;
|
|
RoomMapTrees[roomMapTree.RoomMapFileName] = roomMapTree;
|
|
}
|
|
|
|
public async Task<Result> tryAddRoomMapTreeFromDb(BuildingFloorDoc buildingFloorDoc)
|
|
{
|
|
var result = new Result();
|
|
var err_msg = string.Empty;
|
|
|
|
var building_floor_attrib = buildingFloorDoc.getAttrib<BuildingFloorAttrib>();
|
|
NullReferenceCheckHelper.throwIfNull(building_floor_attrib, () => $"building_floor_attrib is null !!!");
|
|
|
|
(result, var myhome_attrib) = await MyhomeHelper.getEnterMyhomeAttribFromDynamoDb(building_floor_attrib.OwnerGuid, building_floor_attrib.MyhomeGuid);
|
|
if (result.isFail() || null == myhome_attrib)
|
|
{
|
|
err_msg = $"Failed to getSelectedMyhomeUgcInfoFromDynamoDb() !!! : {result.toBasicString()}";
|
|
Log.getLogger().error(err_msg);
|
|
|
|
return result;
|
|
}
|
|
|
|
(result, var myhome_ugc_info) = await MyhomeHelper.getMyhomeUgcInfo(myhome_attrib);
|
|
if (result.isFail() || null == myhome_ugc_info)
|
|
{
|
|
err_msg = $"Failed to getMyhomeUgcInfo() !!! : {result.toBasicString()}";
|
|
Log.getLogger().error(err_msg);
|
|
|
|
return result;
|
|
}
|
|
|
|
result = MyhomeHelper.getMyhomeInstanceId(myhome_ugc_info.RoomType, out var instance_meta_id);
|
|
if (result.isFail())
|
|
{
|
|
err_msg = $"Fail to getMyhomeInstanceId() !!! : {result.toBasicString()}";
|
|
Log.getLogger().error(err_msg);
|
|
|
|
return result;
|
|
}
|
|
|
|
if (!MetaData.Instance._IndunTable.TryGetValue(instance_meta_id, out var indun_meta_data))
|
|
{
|
|
err_msg = $"Failed to MetaData.TryGetValue() !!! : instanceMetaId:{instance_meta_id}";
|
|
result.setFail(ServerErrorCode.InstanceMetaDataNotFound, err_msg);
|
|
Log.getLogger().error(result.toBasicString());
|
|
|
|
return result;
|
|
}
|
|
|
|
if (!GetBuildingMapTree(building_floor_attrib.BuildingMetaId, out var building_map_tree))
|
|
{
|
|
err_msg = $"Failed to GetBuildingMapTree() !!! : BuildingMetaId:{building_floor_attrib.BuildingMetaId}";
|
|
result.setFail(ServerErrorCode.BuildingMapTreeDataNotFound, err_msg);
|
|
Log.getLogger().error(result.toBasicString());
|
|
|
|
return result;
|
|
}
|
|
|
|
var server_logic = GameServerApp.getServerLogic();
|
|
var db_client = server_logic.getDynamoDbClient();
|
|
NullReferenceCheckHelper.throwIfNull(db_client, () => $"db_client is null !!!");
|
|
|
|
var location_unique_id = server_logic.getMap().makeLOCATION_UNIQUE_IDByMetaIdWithLocationTargetType(LocationTargetType.Instance, building_floor_attrib.MyhomeGuid);
|
|
|
|
var npc_location_in_target_doc = new NpcLocationInTargetDoc(location_unique_id, building_floor_attrib.MyhomeGuid);
|
|
var query_config = db_client.makeQueryConfigForReadByPKOnly(npc_location_in_target_doc.getPK());
|
|
|
|
(result, var read_docs) = await db_client.simpleQueryDocTypesWithQueryOperationConfig<NpcLocationInTargetDoc>(query_config);
|
|
if (result.isFail())
|
|
{
|
|
err_msg = $"Failed to simpleQueryDocTypesWithQueryOperationConfig() !!! : {result.toBasicString()}";
|
|
Log.getLogger().error(err_msg);
|
|
|
|
return result;
|
|
}
|
|
NullReferenceCheckHelper.throwIfNull(read_docs, () => $"read_docs is null !!!");
|
|
|
|
var ugc_npc_guids = new List<string>();
|
|
|
|
foreach (var read_doc in read_docs)
|
|
{
|
|
var npc_location_in_target_attrib = read_doc.getAttrib<NpcLocationInTargetAttrib>();
|
|
NullReferenceCheckHelper.throwIfNull(npc_location_in_target_attrib, () => $"npc_location_in_target_attrib is null !!!");
|
|
|
|
ugc_npc_guids.Add(npc_location_in_target_attrib.NpcUniqueId);
|
|
}
|
|
|
|
var room_map_tree = new RoomMapTree(instance_meta_id, building_floor_attrib.MyhomeGuid, building_map_tree);
|
|
|
|
room_map_tree.OwnerGuid = building_floor_attrib.OwnerGuid;
|
|
room_map_tree.MyhomeGuid = building_floor_attrib.MyhomeGuid;
|
|
room_map_tree.InstanceName = building_floor_attrib.InstanceName;
|
|
room_map_tree.ThumbnailImageId = building_floor_attrib.ThumbnailImageId;
|
|
room_map_tree.ListImageId = building_floor_attrib.ListImageId;
|
|
room_map_tree.EnterPlayerCount = building_floor_attrib.EnterPlayerCount;
|
|
room_map_tree.UgcNpcs = ugc_npc_guids;
|
|
|
|
building_map_tree.ChildRoomMapTrees[building_floor_attrib.Floor] = room_map_tree;
|
|
|
|
RoomMapTrees[room_map_tree.RoomMapFileName] = room_map_tree;
|
|
|
|
return result;
|
|
}
|
|
|
|
public bool tryRemoveRoomMapTree(int building_meta_id, int floor, [MaybeNullWhen(false)] out RoomMapTree removedRoomMapTree)
|
|
{
|
|
removedRoomMapTree = default;
|
|
|
|
if (!GetBuildingMapTree(building_meta_id, out var building_map_tree))
|
|
return false;
|
|
|
|
if (!building_map_tree.ChildRoomMapTrees.Remove(floor, out var room_map_tree))
|
|
return false;
|
|
|
|
return RoomMapTrees.TryRemove(room_map_tree.RoomMapFileName, out removedRoomMapTree);
|
|
}
|
|
|
|
public Result modifyFloorLinkedInfo(ModifyFloorLinkedInfo modifyFloorLinkedInfo)
|
|
{
|
|
var result = new Result();
|
|
var err_msg = string.Empty;
|
|
|
|
if (!GetBuildingMapTree(modifyFloorLinkedInfo.BuildingId, out var building_map_tree))
|
|
{
|
|
err_msg = $"Failed to GetBuildingMapTree() !!! : BuildingMetaId:{modifyFloorLinkedInfo.BuildingId}";
|
|
result.setFail(ServerErrorCode.BuildingMapTreeDataNotFound, err_msg);
|
|
Log.getLogger().error(result.toBasicString());
|
|
|
|
return result;
|
|
}
|
|
|
|
if (!building_map_tree.ChildRoomMapTrees.TryGetValue(modifyFloorLinkedInfo.Floor, out var room_map_tree))
|
|
{
|
|
err_msg = $"Failed to ChildRoomMapTrees.TryGetValue() !!! : floor:{modifyFloorLinkedInfo.Floor}";
|
|
result.setFail(ServerErrorCode.BuildingMapTreeChildRoomNotFound, err_msg);
|
|
Log.getLogger().error(result.toBasicString());
|
|
|
|
return result;
|
|
}
|
|
|
|
switch (modifyFloorLinkedInfo.ModifyType)
|
|
{
|
|
case ModifyType.Add:
|
|
{
|
|
room_map_tree.UgcNpcs.AddRange(modifyFloorLinkedInfo.FloorLinkedInfo.UgcNpcGuids);
|
|
}
|
|
break;
|
|
case ModifyType.Delete:
|
|
{
|
|
foreach (var ugc_npc_guid in modifyFloorLinkedInfo.FloorLinkedInfo.UgcNpcGuids)
|
|
{
|
|
room_map_tree.UgcNpcs.Remove(ugc_npc_guid);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public Result tryGetUsingFloorCountByLandMetaId(int landMetaId, out int usingFloorCount)
|
|
{
|
|
var result = new Result();
|
|
var err_msg = string.Empty;
|
|
|
|
usingFloorCount = 0;
|
|
|
|
if (!GetLandMapTree(landMetaId, out var land_map_tree))
|
|
{
|
|
err_msg = $"Failed to GetLandMapTree() !!! : LandMetaId:{landMetaId}";
|
|
result.setFail(ServerErrorCode.LandMapTreeDataNotFound, err_msg);
|
|
Log.getLogger().error(result.toBasicString());
|
|
|
|
return result;
|
|
}
|
|
|
|
var building_map_tree = land_map_tree.ChildBuildingMapTree;
|
|
if (building_map_tree == null)
|
|
{
|
|
err_msg = $"Not Exist LandMapTree ChildBuilding !!! : LandMap:{land_map_tree.LandMapFileName}";
|
|
result.setFail(ServerErrorCode.LandMapTreeChildBuildingNotFound, err_msg);
|
|
Log.getLogger().error(result.toBasicString());
|
|
|
|
return result;
|
|
}
|
|
|
|
return tryGetUsingFloorCountByBuildingMetaId(building_map_tree.BuildingMetaId, out usingFloorCount);
|
|
}
|
|
|
|
public Result tryGetUsingFloorCountByBuildingMetaId(int buildingMetaId, out int usingFloorCount)
|
|
{
|
|
var result = new Result();
|
|
var err_msg = string.Empty;
|
|
|
|
usingFloorCount = 0;
|
|
|
|
if (!GetBuildingMapTree(buildingMetaId, out var building_map_tree))
|
|
{
|
|
err_msg = $"Failed to GetBuildingMapTree() !!! : BuildingMetaId:{buildingMetaId}";
|
|
result.setFail(ServerErrorCode.BuildingMapTreeDataNotFound, err_msg);
|
|
Log.getLogger().error(result.toBasicString());
|
|
|
|
return result;
|
|
}
|
|
|
|
usingFloorCount = building_map_tree.ChildRoomMapTrees.Count;
|
|
|
|
return result;
|
|
}
|
|
}
|
|
}
|