private void Update_UCE_LogoutTimer()
{
Player player = Player.localPlayer;
if (!player)
{
return;
}
if (player.state == "IDLE")
{
_logoutTimer += cacheTimerInterval;
}
else
{
_logoutTimer = 0;
UCE_UI_LogoutTimer_Popup.singleton.Hide();
}
if (_logoutTimer > logoutKickTime)
{
NetworkManagerMMO.Quit();
}
else if (_logoutTimer > logoutWarningTime)
{
UCE_UI_LogoutTimer_Popup.singleton.Show();
}
}
private void Start()
{
m_Raycaster = GameObject.Find("Canvas").GetComponent <GraphicRaycaster>();
m_EventSystem = GameObject.Find("EventSystem").GetComponent <EventSystem>();
network = GameObject.Find("NetworkManager").GetComponent <NetworkManagerMMO>();
popup = GameObject.Find("Popup").GetComponent <UIPopup>();
}
// -----------------------------------------------------------------------------------
// Use
// @Server
// -----------------------------------------------------------------------------------
public override void Use(Player player, int inventoryIndex)
{
ItemSlot slot = player.inventory[inventoryIndex];
// -- Only activate if enough charges left
if (decreaseAmount == 0 || slot.amount >= decreaseAmount)
{
// always call base function too
base.Use(player, inventoryIndex);
// -- Decrease Amount
if (decreaseAmount != 0)
{
slot.DecreaseAmount(decreaseAmount);
player.inventory[inventoryIndex] = slot;
}
// -- Determine Teleportation Target
if (teleportToClosestSpawnpoint)
{
Transform target = NetworkManagerMMO.GetNearestStartPosition(player.transform.position);
player.UCE_Warp(target.position);
}
else
{
teleportationTarget.OnTeleport(player);
}
}
}
// -------------------------------------------------------------------------------
// Show
// -------------------------------------------------------------------------------
public void Show()
{
cancelButton.onClick.SetListener(() => {
NetworkManagerMMO.Quit();
});
panel.SetActive(true);
}
void Update()
{
// show while in lobby and while not creating a character
if (manager.state == NetworkState.Lobby && !uiCharacterCreation.IsVisible())
{
panel.SetActive(true);
// characters available message received already?
if (manager.charactersAvailableMsg != null)
{
CharactersAvailableMsg.CharacterPreview[] characters = manager.charactersAvailableMsg.characters;
// start button: calls AddPLayer which calls OnServerAddPlayer
// -> button sends a request to the server
// -> if we press button again while request hasn't finished
// then we will get the error:
// 'ClientScene::AddPlayer: playerControllerId of 0 already in use.'
// which will happen sometimes at low-fps or high-latency
// -> internally ClientScene.AddPlayer adds to localPlayers
// immediately, so let's check that first
startButton.gameObject.SetActive(manager.selection != -1);
startButton.onClick.SetListener(() => {
// add player
CharacterSelectMsg message = new CharacterSelectMsg {
index = manager.selection
};
ClientScene.AddPlayer(manager.client.connection, message);
// clear character selection previews
manager.ClearPreviews();
// make sure we can't select twice and call AddPlayer twice
panel.SetActive(false);
});
// delete button
deleteButton.gameObject.SetActive(manager.selection != -1);
deleteButton.onClick.SetListener(() => {
CharacterDeleteMsg message = new CharacterDeleteMsg {
index = manager.selection
};
manager.client.Send(CharacterDeleteMsg.MsgId, message);
});
// create button
createButton.interactable = characters.Length < manager.characterLimit;
createButton.onClick.SetListener(() => {
panel.SetActive(false);
uiCharacterCreation.Show();
});
// quit button
quitButton.onClick.SetListener(() => { NetworkManagerMMO.Quit(); });
}
}
else
{
panel.SetActive(false);
}
}
// -----------------------------------------------------------------------------------
// UCE_Load_WorldEvents
// -----------------------------------------------------------------------------------
public void UCE_Load_WorldEvents()
{
#if _MYSQL && _SERVER
var table = ExecuteReaderMySql("SELECT `name`, `count` FROM uce_worldevents");
foreach (var row in table)
{
string name = (string)row[0];
int count = (int)row[1];
if (!string.IsNullOrWhiteSpace(name) && count != 0)
{
NetworkManagerMMO.UCE_SetWorldEventCount(name, count);
}
}
#elif _SQLITE && _SERVER
var table = connection.Query <uce_worldevents>("SELECT `name`, `count` FROM uce_worldevents");
foreach (var row in table)
{
string name = row.name;
int count = row.count;
if (!string.IsNullOrWhiteSpace(name) && count != 0)
{
NetworkManagerMMO.UCE_SetWorldEventCount(name, count);
}
}
#endif
}
void Update()
{
if (manager == null)
{
manager = NetworkManager.singleton as NetworkManagerMMO;
}
// only show while offline
// AND while in handshake since we don't want to show nothing while
// trying to login and waiting for the server's response
if (manager.state == NetworkState.Offline || manager.state == NetworkState.Handshake)
{
panel.SetActive(true);
// status
if (manager.IsConnecting())
{
statusText.text = "Connecting...";
}
else if (manager.state == NetworkState.Handshake)
{
statusText.text = "Handshake...";
}
else
{
statusText.text = "";
}
// buttons. interactable while network is not active
// (using IsConnecting is slightly delayed and would allow multiple clicks)
registerButton.interactable = !manager.isNetworkActive;
registerButton.onClick.SetListener(() => { uiPopup.Show(registerMessage); });
loginButton.interactable = !manager.isNetworkActive && manager.IsAllowedAccountName(accountInput.text);
loginButton.onClick.SetListener(() => { manager.StartClient(); });
hostButton.interactable = Application.platform != RuntimePlatform.WebGLPlayer && !manager.isNetworkActive && manager.IsAllowedAccountName(accountInput.text);
hostButton.onClick.SetListener(() => { manager.StartHost(); });
cancelButton.gameObject.SetActive(manager.IsConnecting());
cancelButton.onClick.SetListener(() => { manager.StopClient(); });
dedicatedButton.interactable = Application.platform != RuntimePlatform.WebGLPlayer && !manager.isNetworkActive;
dedicatedButton.onClick.SetListener(() => { manager.StartServer(); });
quitButton.onClick.SetListener(() => { NetworkManagerMMO.Quit(); });
// inputs
manager.loginAccount = accountInput.text;
manager.loginPassword = passwordInput.text;
// copy servers to dropdown; copy selected one to networkmanager ip/port.
serverDropdown.interactable = !manager.isNetworkActive;
serverDropdown.options = manager.serverList.Select(
sv => new Dropdown.OptionData(sv.name)
).ToList();
manager.networkAddress = manager.serverList[serverDropdown.value].ip;
}
else
{
panel.SetActive(false);
}
}
public void CmdShutdown()
{
// validate: only for GMs
if (!player.isGameMaster)
{
return;
}
NetworkManagerMMO.Quit();
}
string UpdateServer_DEAD(Player player)
{
// events sorted by priority (e.g. target doesn't matter if we died)
if (EventRespawn(player))
{
// revive to closest spawn, with 50% health, then go to idle
Transform start = NetworkManagerMMO.GetNearestStartPosition(player.transform.position);
player.movement.Warp(start.position); // recommended over transform.position
player.Revive(0.5f);
return("IDLE");
}
if (EventMoveStart(player))
{
// if a player gets killed while sliding down a slope or while in
// the air then he might continue to move after dead. it's fine as
// long as we don't allow client input to control the move.
return("DEAD");
}
if (EventMoveEnd(player))
{
} // don't care
if (EventSkillFinished(player))
{
} // don't care
if (EventDied(player))
{
} // don't care
if (EventCancelAction(player))
{
} // don't care
if (EventTradeStarted(player))
{
} // don't care
if (EventTradeDone(player))
{
} // don't care
if (EventCraftingStarted(player))
{
} // don't care
if (EventCraftingDone(player))
{
} // don't care
if (EventTargetDisappeared(player))
{
} // don't care
if (EventTargetDied(player))
{
} // don't care
if (EventSkillRequest(player))
{
} // don't care
return("DEAD"); // nothing interesting happened
}
void Update()
{
Player player = Player.localPlayer;
if (player != null)
{
panel.SetActive(true);
inventoryButton.onClick.SetListener(() => {
inventoryPanel.SetActive(!inventoryPanel.activeSelf);
});
equipmentButton.onClick.SetListener(() => {
equipmentPanel.SetActive(!equipmentPanel.activeSelf);
});
skillsButton.onClick.SetListener(() => {
skillsPanel.SetActive(!skillsPanel.activeSelf);
});
characterInfoButton.onClick.SetListener(() => {
characterInfoPanel.SetActive(!characterInfoPanel.activeSelf);
});
questsButton.onClick.SetListener(() => {
questsPanel.SetActive(!questsPanel.activeSelf);
});
craftingButton.onClick.SetListener(() => {
craftingPanel.SetActive(!craftingPanel.activeSelf);
});
partyButton.onClick.SetListener(() => {
partyPanel.SetActive(!partyPanel.activeSelf);
});
guildButton.onClick.SetListener(() => {
guildPanel.SetActive(!guildPanel.activeSelf);
});
itemMallButton.onClick.SetListener(() => {
itemMallPanel.SetActive(!itemMallPanel.activeSelf);
});
quitButton.onClick.SetListener(() => {
NetworkManagerMMO.Quit();
});
}
else
{
panel.SetActive(false);
}
}
void Awake()
{
// NetworkManager.singleton is null for some reason
manager = FindObjectOfType <NetworkManagerMMO>();
// button onclicks
createButton.onClick.SetListener(() => {
Hide();
FindObjectOfType <UICharacterCreation>().Show();
});
quitButton.onClick.SetListener(() => { Application.Quit(); });
}
void Awake()
{
// NetworkManager.singleton is null for some reason
manager = FindObjectOfType <NetworkManagerMMO>();
// button onclicks
btnQuit.onClick.SetListener(() => { Application.Quit(); });
btnLogin.onClick.SetListener(() => { manager.StartClient(); });
btnRegister.onClick.SetListener(() => { FindObjectOfType <UIPopup>().Show(registerMessage); });
btnHost.onClick.SetListener(() => { manager.StartHost(); });
btnCancel.onClick.SetListener(() => { manager.StopClient(); });
btnDedicated.onClick.SetListener(() => { manager.StartServer(); });
}
void Update()
{
if (manager == null)
{
manager = NetworkManager.singleton as NetworkManagerMMO;
}
// only update while visible (after character selection made it visible)
if (panel.activeSelf)
{
// still in lobby?
if (manager.state == NetworkState.Lobby)
{
Show();
// copy player classes to class selection
classDropdown.options = manager.GetPlayerClasses().Select(
p => new Dropdown.OptionData(p.name)
).ToList();
// create
createButton.interactable = manager.IsAllowedCharacterName(nameInput.text);
createButton.onClick.SetListener(() =>
{
CharacterCreateMsg message = new CharacterCreateMsg
{
name = nameInput.text,
classIndex = classDropdown.value
};
NetworkClient.Send(message);
Hide();
});
// cancel
cancelButton.onClick.SetListener(() =>
{
nameInput.text = "";
Hide();
});
}
else
{
Hide();
}
}
else
{
Hide();
}
}
void Start()
{
if (manager == null)
{
manager = NetworkManager.singleton as NetworkManagerMMO;
}
// load last server by name in case order changes some day.
if (PlayerPrefs.HasKey("LastServer"))
{
string last = PlayerPrefs.GetString("LastServer", "");
serverDropdown.value = manager.serverList.FindIndex(s => s.name == last);
}
}
// -----------------------------------------------------------------------------------
// Start
// -----------------------------------------------------------------------------------
private void Start()
{
#if _iMMOWORLDEVENTS
if (worldEvent != null)
{
_defaultVisible = NetworkManagerMMO.UCE_CheckWorldEvent(worldEvent, minEventCount, maxEventCount);
}
else
{
_defaultVisible = _visible;
}
#else
_defaultVisible = _visible;
#endif
}
// -----------------------------------------------------------------------------------
// UCE_Load_WorldEvents
// -----------------------------------------------------------------------------------
public void UCE_Load_WorldEvents()
{
var table = connection.Query <worldevents>("SELECT `name`, `count` FROM uce_worldevents");
foreach (var row in table)
{
string name = row.name;
int count = row.count;
if (!string.IsNullOrWhiteSpace(name) && count != 0)
{
NetworkManagerMMO.UCE_SetWorldEventCount(name, count);
}
}
}
// -----------------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------------
public override void Apply(Entity caster, int skillLevel)
{
// apply only to alive people
if (caster.isAlive)
{
// -- Determine Teleportation Target
if (teleportToClosestSpawnpoint)
{
Transform target = NetworkManagerMMO.GetNearestStartPosition(caster.transform.position);
((Player)caster).UCE_Warp(target.position);
}
else
{
teleportationTarget.OnTeleport((Player)caster);
}
}
}
// -----------------------------------------------------------------------------------
// Update
// -----------------------------------------------------------------------------------
private void Update()
{
if (!init)
{
manager = FindObjectOfType <NetworkManagerMMO>();
cacheSpawnPrefabs = manager.spawnPrefabs;
// make sure we are the server and have objects in the spawnable prefabs list
if (cacheSpawnPrefabs.Count == 0 || !NetworkServer.active || init)
{
return;
}
OnSpawn();
init = true;
}
}
void Awake()
{
// NetworkManager.singleton is null for some reason
manager = FindObjectOfType <NetworkManagerMMO>();
// button onclicks
createButton.onClick.SetListener(() => {
var msg = new CharacterCreateMsg {
name = inputCharacterName.text,
classIndex = dropdownClass.value
};
manager.client.Send(CharacterCreateMsg.MsgId, msg);
});
cancelButton.onClick.SetListener(() => {
inputCharacterName.text = "";
Hide();
FindObjectOfType <UICharacterSelection>().Show();
});
}
// -----------------------------------------------------------------------------------
// Apply
// -----------------------------------------------------------------------------------
public override void Apply(Entity caster, int skillLevel)
{
foreach (string member in ((Player)caster).party.members)
{
Player player = UCE_Tools.FindOnlinePlayerByName(member);
// -- Teleport everybody but not the caster
if (player != null && player != (Player)caster)
{
// -- Check Distance
if (maxDistanceToCaster <= 0 || Utils.ClosestDistance(caster, caster.target) <= maxDistanceToCaster || member == ((Player)caster).party.master)
{
// -- Determine Teleportation Target
if (teleportToClosestSpawnpoint)
{
Transform target = NetworkManagerMMO.GetNearestStartPosition(player.transform.position);
player.UCE_Warp(target.position);
}
else
{
teleportationTarget.OnTeleport(player);
}
}
player = null;
}
}
// -- Teleport the caster now
if (teleportToClosestSpawnpoint)
{
Transform target = NetworkManagerMMO.GetNearestStartPosition(((Player)caster).transform.position);
((Player)caster).UCE_Warp(target.position);
}
else
{
teleportationTarget.OnTeleport(((Player)caster));
}
}
