public Vector2 GetPosition(LiteNetLibIdentity identity)
{
// find players within range
switch (AxisMode)
{
case EAxisMode.XZ:
return(new Vector2(identity.transform.position.x, identity.transform.position.z));
case EAxisMode.XY:
return(new Vector2(identity.transform.position.x, identity.transform.position.y));
}
return(Vector2.zero);
}
public override async UniTask <bool> DeserializeClientReadyData(LiteNetLibIdentity playerIdentity, long connectionId, NetDataReader reader)
{
string userId = reader.GetString();
string accessToken = reader.GetString();
string selectCharacterId = reader.GetString();
if (ServerUserHandlers.TryGetPlayerCharacter(connectionId, out _))
{
if (LogError)
{
Logging.LogError(LogTag, "User trying to hack: " + userId);
}
Transport.ServerDisconnect(connectionId);
return(false);
}
ValidateAccessTokenResp validateAccessTokenResp = await DbServiceClient.ValidateAccessTokenAsync(new ValidateAccessTokenReq()
{
UserId = userId,
AccessToken = accessToken
});
if (!validateAccessTokenResp.IsPass)
{
if (LogError)
{
Logging.LogError(LogTag, "Invalid access token for user: "******"Not ready to spawn player: " + userId);
}
// Add to pending list to spawn player later when map server is ready to instantiate object
pendingSpawnPlayerCharacters.Add(new PendingSpawnPlayerCharacter()
{
connectionId = connectionId,
userId = userId,
selectCharacterId = selectCharacterId
});
return(false);
}
SetPlayerReadyRoutine(connectionId, userId, selectCharacterId).Forget();
return(true);
}
public override void DeserializeClientReadyExtra(LiteNetLibIdentity playerIdentity, long connectionId, NetDataReader reader)
{
if (LogDev)
{
Debug.Log("[LanRpgNetworkManager] Deserializing client ready extra");
}
var playerCharacterData = new PlayerCharacterData().DeserializeCharacterData(reader);
BasePlayerCharacterEntity entityPrefab = playerCharacterData.GetEntityPrefab() as BasePlayerCharacterEntity;
// If it is not allow this character data, disconnect user
if (entityPrefab == null)
{
Debug.LogError("[LanRpgNetworkManager] Cannot find player character with entity Id: " + playerCharacterData.EntityId);
return;
}
if (!SceneManager.GetActiveScene().name.Equals(playerCharacterData.CurrentMapName))
{
playerCharacterData.CurrentPosition = teleportPosition.HasValue ? teleportPosition.Value : CurrentMapInfo.startPosition;
}
var identity = Assets.NetworkSpawn(entityPrefab.Identity.HashAssetId, playerCharacterData.CurrentPosition, Quaternion.identity, 0, connectionId);
var playerCharacterEntity = identity.GetComponent <BasePlayerCharacterEntity>();
playerCharacterData.CloneTo(playerCharacterEntity);
// Summon saved summons
for (var i = 0; i < playerCharacterEntity.Summons.Count; ++i)
{
var summon = playerCharacterEntity.Summons[i];
summon.Summon(playerCharacterEntity, summon.Level, summon.summonRemainsDuration, summon.Exp, summon.CurrentHp, summon.CurrentMp);
playerCharacterEntity.Summons[i] = summon;
}
// Notify clients that this character is spawn or dead
if (!playerCharacterEntity.IsDead())
{
playerCharacterEntity.RequestOnRespawn();
}
else
{
playerCharacterEntity.RequestOnDead();
}
// Load world for first character (host)
if (playerCharacters.Count == 0)
{
var worldSaveData = new WorldSaveData();
worldSaveData.LoadPersistentData(playerCharacterEntity.Id, playerCharacterEntity.CurrentMapName);
StartCoroutine(SpawnBuildingsAndHarvestables(worldSaveData));
}
// Register player, will use registered player to send chat / player messages
RegisterPlayerCharacter(connectionId, playerCharacterEntity);
}
public override async UniTask <bool> DeserializeClientReadyData(LiteNetLibIdentity playerIdentity, long connectionId, NetDataReader reader)
{
await UniTask.Yield();
var deviceUniqueIdentifier = reader.GetString();
var character = NewCharacter(reader);
if (character == null)
{
Debug.LogError("Cannot create new character for player " + connectionId);
return(false);
}
Assets.NetworkSpawn(character.gameObject, 0, connectionId);
RegisterCharacter(character, deviceUniqueIdentifier);
return(true);
}
public override void DeserializeClientReadyExtra(LiteNetLibIdentity playerIdentity, NetPeer peer, NetDataReader reader)
{
if (playerIdentity == null)
{
return;
}
var playerCharacterEntity = playerIdentity.GetComponent <PlayerCharacterEntity>();
playerCharacterEntity.DeserializeCharacterData(reader);
// Notify clients that this character is spawn or dead
if (playerCharacterEntity.CurrentHp > 0)
{
playerCharacterEntity.RequestOnRespawn(true);
}
else
{
playerCharacterEntity.RequestOnDead(true);
}
}
protected void UpdatePointClickInput()
{
var isPointerOverUI = CacheUISceneGameplay != null && CacheUISceneGameplay.IsPointerOverUIObject();
if (Input.GetMouseButtonDown(0))
{
isMouseDragOrHoldOrOverUI = false;
mouseDownTime = Time.unscaledTime;
mouseDownPosition = Input.mousePosition;
}
var isMouseDragDetected = (Input.mousePosition - mouseDownPosition).magnitude > DETECT_MOUSE_DRAG_DISTANCE;
var isMouseHoldDetected = Time.unscaledTime - mouseDownTime > DETECT_MOUSE_HOLD_DURATION;
if (!isMouseDragOrHoldOrOverUI && (isMouseDragDetected || isMouseHoldDetected || isPointerOverUI))
{
isMouseDragOrHoldOrOverUI = true;
}
if (!isPointerOverUI && Input.GetMouseButtonUp(0) && !isMouseDragOrHoldOrOverUI)
{
var targetCamera = CacheGameplayCameraControls != null ? CacheGameplayCameraControls.targetCamera : Camera.main;
CharacterEntity.SetTargetEntity(null);
LiteNetLibIdentity targetIdentity = null;
Vector3? targetPosition = null;
var layerMask = 0;
if (gameInstance.nonTargetingLayers.Length > 0)
{
foreach (var nonTargetingLayer in gameInstance.nonTargetingLayers)
{
layerMask = layerMask | ~(nonTargetingLayer.Mask);
}
}
else
{
layerMask = -1;
}
RaycastHit[] hits = Physics.RaycastAll(targetCamera.ScreenPointToRay(Input.mousePosition), 100f, layerMask);
foreach (var hit in hits)
{
var hitTransform = hit.transform;
targetPosition = hit.point;
var playerEntity = hitTransform.GetComponent <PlayerCharacterEntity>();
var monsterEntity = hitTransform.GetComponent <MonsterCharacterEntity>();
var npcEntity = hitTransform.GetComponent <NpcEntity>();
var itemDropEntity = hitTransform.GetComponent <ItemDropEntity>();
CharacterEntity.SetTargetEntity(null);
if (playerEntity != null && playerEntity.CurrentHp > 0)
{
targetPosition = playerEntity.CacheTransform.position;
targetIdentity = playerEntity.Identity;
CharacterEntity.SetTargetEntity(playerEntity);
break;
}
else if (monsterEntity != null && monsterEntity.CurrentHp > 0)
{
targetPosition = monsterEntity.CacheTransform.position;
targetIdentity = monsterEntity.Identity;
CharacterEntity.SetTargetEntity(monsterEntity);
break;
}
else if (npcEntity != null)
{
targetPosition = npcEntity.CacheTransform.position;
targetIdentity = npcEntity.Identity;
CharacterEntity.SetTargetEntity(npcEntity);
break;
}
else if (itemDropEntity != null)
{
targetPosition = itemDropEntity.CacheTransform.position;
targetIdentity = itemDropEntity.Identity;
CharacterEntity.SetTargetEntity(itemDropEntity);
break;
}
}
if (targetPosition.HasValue)
{
if (CacheUISceneGameplay != null && CacheUISceneGameplay.uiNpcDialog != null)
{
CacheUISceneGameplay.uiNpcDialog.Hide();
}
queueUsingSkill = null;
if (targetIdentity != null)
{
destination = null;
}
else
{
destination = targetPosition.Value;
CharacterEntity.PointClickMovement(targetPosition.Value);
}
}
}
}
public override void DeserializeClientReadyExtra(LiteNetLibIdentity playerIdentity, long connectionId, NetDataReader reader)
{
if (LogDev)
{
Debug.Log("[LanRpgNetworkManager] Deserializing client ready extra");
}
PlayerCharacterData playerCharacterData = new PlayerCharacterData().DeserializeCharacterData(reader);
BasePlayerCharacterEntity entityPrefab = playerCharacterData.GetEntityPrefab() as BasePlayerCharacterEntity;
// If it is not allow this character data, disconnect user
if (entityPrefab == null)
{
Debug.LogError("[LanRpgNetworkManager] Cannot find player character with entity Id: " + playerCharacterData.EntityId);
return;
}
if (!CurrentMapInfo.Id.Equals(playerCharacterData.CurrentMapName))
{
playerCharacterData.CurrentPosition = teleportPosition.HasValue ? teleportPosition.Value : CurrentMapInfo.startPosition;
}
GameObject spawnObj = Instantiate(entityPrefab.gameObject, playerCharacterData.CurrentPosition, Quaternion.identity);
BasePlayerCharacterEntity playerCharacterEntity = spawnObj.GetComponent <BasePlayerCharacterEntity>();
playerCharacterData.CloneTo(playerCharacterEntity);
Assets.NetworkSpawn(spawnObj, 0, connectionId);
// Set user Id
playerCharacterEntity.UserId = playerCharacterEntity.Id;
// Enable GM commands in Singleplayer / LAN mode
// TODO: Don't use fixed user level
if (enableGmCommands == EnableGmCommandType.Everyone)
{
playerCharacterEntity.UserLevel = 1;
}
// Load world / storage for first character (host)
if (playerCharacters.Count == 0)
{
if (enableGmCommands == EnableGmCommandType.HostOnly)
{
playerCharacterEntity.UserLevel = 1;
}
// Load and Spawn buildings
worldSaveData.LoadPersistentData(playerCharacterEntity.Id, playerCharacterEntity.CurrentMapName);
foreach (BuildingSaveData building in worldSaveData.buildings)
{
CreateBuildingEntity(building, true);
}
// Load storage data
storageSaveData.LoadPersistentData(playerCharacterEntity.Id);
foreach (StorageCharacterItem storageItem in storageSaveData.storageItems)
{
StorageId storageId = new StorageId(storageItem.storageType, storageItem.storageOwnerId);
if (!storageItems.ContainsKey(storageId))
{
storageItems[storageId] = new List <CharacterItem>();
}
storageItems[storageId].Add(storageItem.characterItem);
}
// Spawn harvestables
HarvestableSpawnArea[] harvestableSpawnAreas = FindObjectsOfType <HarvestableSpawnArea>();
foreach (HarvestableSpawnArea harvestableSpawnArea in harvestableSpawnAreas)
{
harvestableSpawnArea.SpawnAll();
}
}
// Summon saved summons
for (int i = 0; i < playerCharacterEntity.Summons.Count; ++i)
{
CharacterSummon summon = playerCharacterEntity.Summons[i];
summon.Summon(playerCharacterEntity, summon.Level, summon.summonRemainsDuration, summon.Exp, summon.CurrentHp, summon.CurrentMp);
playerCharacterEntity.Summons[i] = summon;
}
// Notify clients that this character is spawn or dead
if (!playerCharacterEntity.IsDead())
{
playerCharacterEntity.RequestOnRespawn();
}
else
{
playerCharacterEntity.RequestOnDead();
}
// Register player, will use registered player to send chat / player messages
RegisterPlayerCharacter(connectionId, playerCharacterEntity);
}
private IEnumerator SetPlayerReadyRoutine(long connectionId, string userId, string accessToken, string selectCharacterId)
{
// Validate access token
ValidateAccessTokenJob validateAccessTokenJob = new ValidateAccessTokenJob(Database, userId, accessToken);
validateAccessTokenJob.Start();
yield return(StartCoroutine(validateAccessTokenJob.WaitFor()));
if (!validateAccessTokenJob.result)
{
if (LogError)
{
Debug.LogError("[Map Server] Invalid access token for user: "******"[Map Server] Cannot find select character: " + selectCharacterId + " for user: "******"[Map Server] Cannot find player character with entity Id: " + playerCharacterData.EntityId);
}
Transport.ServerDisconnect(connectionId);
}
else
{
// Spawn character entity and set its data
LiteNetLibIdentity identity = Assets.NetworkSpawn(entityPrefab.Identity.HashAssetId, playerCharacterData.CurrentPosition, Quaternion.identity, 0, connectionId);
BasePlayerCharacterEntity playerCharacterEntity = identity.GetComponent <BasePlayerCharacterEntity>();
playerCharacterData.CloneTo(playerCharacterEntity);
// Summon saved summons
for (int i = 0; i < playerCharacterEntity.Summons.Count; ++i)
{
CharacterSummon summon = playerCharacterEntity.Summons[i];
summon.Summon(playerCharacterEntity, summon.Level, summon.summonRemainsDuration, summon.Exp, summon.CurrentHp, summon.CurrentMp);
playerCharacterEntity.Summons[i] = summon;
}
// Load user level
GetUserLevelJob loadUserLevelJob = new GetUserLevelJob(Database, userId);
loadUserLevelJob.Start();
yield return(StartCoroutine(loadUserLevelJob.WaitFor()));
playerCharacterEntity.UserLevel = loadUserLevelJob.result;
// Notify clients that this character is spawn or dead
if (!playerCharacterEntity.IsDead())
{
playerCharacterEntity.RequestOnRespawn();
}
else
{
playerCharacterEntity.RequestOnDead();
}
RegisterPlayerCharacter(connectionId, playerCharacterEntity);
// Load party data, if this map-server does not have party data
if (playerCharacterEntity.PartyId > 0)
{
if (!parties.ContainsKey(playerCharacterEntity.PartyId))
{
yield return(StartCoroutine(LoadPartyRoutine(playerCharacterEntity.PartyId)));
}
if (parties.ContainsKey(playerCharacterEntity.PartyId))
{
PartyData party = parties[playerCharacterEntity.PartyId];
SendCreatePartyToClient(playerCharacterEntity.ConnectionId, party);
SendAddPartyMembersToClient(playerCharacterEntity.ConnectionId, party);
}
else
{
playerCharacterEntity.ClearParty();
}
}
// Load guild data, if this map-server does not have guild data
if (playerCharacterEntity.GuildId > 0)
{
if (!guilds.ContainsKey(playerCharacterEntity.GuildId))
{
yield return(StartCoroutine(LoadGuildRoutine(playerCharacterEntity.GuildId)));
}
if (guilds.ContainsKey(playerCharacterEntity.GuildId))
{
GuildData guild = guilds[playerCharacterEntity.GuildId];
playerCharacterEntity.GuildRole = guild.GetMemberRole(playerCharacterEntity.Id);
SendCreateGuildToClient(playerCharacterEntity.ConnectionId, guild);
SendAddGuildMembersToClient(playerCharacterEntity.ConnectionId, guild);
SendSetGuildMessageToClient(playerCharacterEntity.ConnectionId, guild);
SendSetGuildRolesToClient(playerCharacterEntity.ConnectionId, guild);
SendSetGuildMemberRolesToClient(playerCharacterEntity.ConnectionId, guild);
SendSetGuildSkillLevelsToClient(playerCharacterEntity.ConnectionId, guild);
SendGuildLevelExpSkillPointToClient(playerCharacterEntity.ConnectionId, guild);
}
else
{
playerCharacterEntity.ClearGuild();
}
}
// Set user data to map server
UserCharacterData userData = new UserCharacterData();
userData.userId = userId;
userData.id = playerCharacterEntity.Id;
userData.characterName = playerCharacterEntity.CharacterName;
userData.dataId = playerCharacterEntity.DataId;
userData.level = playerCharacterEntity.Level;
userData.currentHp = playerCharacterEntity.CurrentHp;
userData.maxHp = playerCharacterEntity.CacheMaxHp;
userData.currentMp = playerCharacterEntity.CurrentMp;
userData.maxMp = playerCharacterEntity.CacheMaxMp;
usersById[userData.id] = userData;
// Add map user to central server and chat server
UpdateMapUser(CentralAppServerRegister, UpdateUserCharacterMessage.UpdateType.Add, userData);
if (ChatNetworkManager.IsClientConnected)
{
UpdateMapUser(ChatNetworkManager.Client, UpdateUserCharacterMessage.UpdateType.Add, userData);
}
LiteNetLibPlayer player = Players[connectionId];
foreach (LiteNetLibIdentity spawnedObject in Assets.SpawnedObjects.Values)
{
if (spawnedObject.ConnectionId == player.ConnectionId)
{
continue;
}
if (spawnedObject.ShouldAddSubscriber(player))
{
spawnedObject.AddSubscriber(player);
}
}
}
}
}
}
