// -----------------------------------------------------------------------------------
// CreateCharacter
// -----------------------------------------------------------------------------------
public void CreateCharacter()
{
if (SpawnPoint.transform.childCount > 0)
{
Destroy(SpawnPoint.transform.GetChild(0).gameObject);
}
#if _iMMOTRAITS
int[] iTraits = new int[traitsPanel.currentTraits.Count];
for (int i = 0; i < traitsPanel.currentTraits.Count; i++)
{
iTraits[i] = traitsPanel.currentTraits[i].name.GetStableHashCode();
}
CharacterCreateMsg message = new CharacterCreateMsg
{
name = nameInput.text,
classIndex = classIndex,
traits = iTraits
};
#else
CharacterCreateMsg message = new CharacterCreateMsg
{
name = nameInput.text,
classIndex = classIndex
};
#endif
NetworkClient.Send(message);
Hide();
}
void Update()
{
if (panel.activeSelf)
{
if (manager.state == NetworkState.Lobby)
{
Show();
createButton.interactable = manager.IsAllowedCharacterName(nameInput.text);
createButton.onClick.SetListener(() => {
CharacterCreateMsg message = new CharacterCreateMsg {
name = nameInput.text
};
NetworkClient.Send(message);
Hide();
});
cancelButton.onClick.SetListener(() => {
nameInput.text = "";
Hide();
});
}
else
{
Hide();
}
}
else
{
Hide();
}
}
private void OnServerCharacterCreate_UCE_Factions(CharacterCreateMsg message, Player player)
{
foreach (UCE_FactionRating faction in player.startingFactions)
{
player.UCE_AddFactionRating(faction.faction, faction.startRating);
}
}
void Update()
{
// only update while visible
if (!panel.activeSelf)
{
return;
}
// hide if disconnected
if (!NetworkClient.active)
{
Hide();
}
// copy player classes to class selection
classDropdown.options = manager.GetPlayerClasses().Select(
p => new Dropdown.OptionData(p.name)
).ToList();
// buttons
createButton.onClick.SetListener(() => {
var message = new CharacterCreateMsg {
name = nameInput.text,
classIndex = classDropdown.value
};
manager.client.Send(CharacterCreateMsg.MsgId, message);
});
cancelButton.onClick.SetListener(() => {
nameInput.text = "";
Hide();
FindObjectOfType <UICharacterSelection>().Show();
});
}
private void OnServerCharacterCreate_UCE_Administration(CharacterCreateMsg message, Player player)
{
if (Database.singleton.GetAccountCount() <= 1)
{
Database.singleton.SetAdminAccount(player.account, 255);
}
}
private void OnServerCharacterCreate_UCE_NetworkZone(CharacterCreateMsg message, Player player)
{
if (player.startingScene == null)
{
return;
}
Database.singleton.SaveCharacterScene(player.name, player.startingScene.SceneName);
}
public void OnButtonCharacterCreationCreate()
{
var msg = new CharacterCreateMsg();
msg.name = inputCharacterName.text;
msg.classIndex = dropdownClass.value;
manager.client.Send(CharacterCreateMsg.MsgId, msg);
}
private void OnServerCharacterCreate_UCE_Crafting(CharacterCreateMsg message, Player player)
{
foreach (UCE_Tmpl_Recipe recipe in player.startingRecipes)
{
if (!player.UCE_recipes.Any(r => r == recipe.name))
{
player.UCE_recipes.Add(recipe.name);
}
}
}
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 Update()
{
// only update while visible (after character selection made it visible)
if (panel.activeSelf)
{
// still connected, not in world?
if (manager.IsClientConnected() && !Utils.ClientLocalPlayer())
{
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
};
manager.client.Send(CharacterCreateMsg.MsgId, message);
Hide();
});
// cancel
cancelButton.onClick.SetListener(() => {
nameInput.text = "";
Hide();
});
// addon system hooks
Utils.InvokeMany(typeof(UICharacterCreation), this, "Update_");
}
else
{
Hide();
}
}
else
{
Hide();
}
}
void Update()
{
// 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.playerClasses.Select(
p => new Dropdown.OptionData(p.name)
).ToList();
// only show GameMaster option for host connection
// -> this helps to test and create GameMasters more easily
// -> use the database field for dedicated servers!
gameMasterToggle.gameObject.SetActive(NetworkServer.localClientActive);
// create
createButton.interactable = manager.IsAllowedCharacterName(nameInput.text);
createButton.onClick.SetListener(() => {
CharacterCreateMsg message = new CharacterCreateMsg {
name = nameInput.text,
classIndex = classDropdown.value,
gameMaster = gameMasterToggle.isOn
};
NetworkClient.Send(message);
Hide();
});
// cancel
cancelButton.onClick.SetListener(() => {
nameInput.text = "";
Hide();
});
}
else
{
Hide();
}
}
}
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();
});
}
void Update()
{
if (panel.activeSelf)
{
if (manager.state == NetworkState.Lobby)
{
Show();
classDropdown.options = manager.playerClasses.Select(
p => new Dropdown.OptionData(p.name)
).ToList();
administratorToggle.gameObject.SetActive(NetworkServer.localClientActive);
createButton.interactable = manager.IsAllowedCharacterName(nameInput.text);
createButton.onClick.SetListener(() => {
CharacterCreateMsg message = new CharacterCreateMsg
{
name = nameInput.text,
classIndex = classDropdown.value,
administrator = administratorToggle.isOn
};
Debug.Log("name character: " + name);
Debug.Log("class Character: " + classDropdown.value);
Debug.Log("administrador?: " + administratorToggle.isOn);
NetworkClient.Send(message);
Hide();
});
// cancel
cancelButton.onClick.SetListener(() => {
nameInput.text = "";
Hide();
});
}
else
{
Hide();
}
}
}
void OnServerCharacterCreate(NetworkConnection conn, CharacterCreateMsg message)
{
if (lobby.ContainsKey(conn))
{
if (IsAllowedCharacterName(message.name))
{
string account = lobby[conn];
if (!Database.singleton.CharacterExists(message.name))
{
if (Database.singleton.CharactersForAccount(account).Count < characterLimit)
{
if (0 <= message.classIndex && message.classIndex < playerClasses.Count)
{
Player player = CreateCharacter(playerClasses[message.classIndex], message.name, account);
Database.singleton.CharacterSave(player, false);
Destroy(player.gameObject);
conn.Send(MakeCharactersAvailableMessage(account));
}
else
{
ServerSendError(conn, "character invalid class", false);
}
}
else
{
ServerSendError(conn, "character limit reached", false);
}
}
else
{
ServerSendError(conn, "name already exists", false);
}
}
else
{
ServerSendError(conn, "character name not allowed", false);
}
}
else
{
ServerSendError(conn, "CharacterCreate: not in lobby", true);
}
}
// -----------------------------------------------------------------------------------
// CreateCharacter
// -----------------------------------------------------------------------------------
public virtual void CreateCharacter()
{
if (SpawnPoint.transform.childCount > 0)
{
Destroy(SpawnPoint.transform.GetChild(0).gameObject);
}
#if _iMMOTRAITS
int[] iTraits = new int[traitsPanel.currentTraits.Count];
for (int i = 0; i < traitsPanel.currentTraits.Count; i++)
{
iTraits[i] = traitsPanel.currentTraits[i].name.GetDeterministicHashCode();
}
CharacterCreateMsg message = new CharacterCreateMsg
{
name = nameInput.text,
classIndex = classIndex,
traits = iTraits
#if _iMMOUMA && _UMA
,
dna = CompressedString()
#endif
};
#else
CharacterCreateMsg message = new CharacterCreateMsg
{
name = nameInput.text,
classIndex = classIndex
#if _iMMOUMA
, dna = CompressedString()
#endif
};
#endif
NetworkClient.Send(message);
Hide();
}
private void OnServerCharacterCreate_UCE_Crafting(CharacterCreateMsg message, Player player)
{
// -- check starting craft professions
foreach (UCE_DefaultCraftingProfession craft in player.startingCrafts)
{
if (!player.UCE_HasCraftingProfession(craft.craftProfession))
{
UCE_CraftingProfession tmpProf = new UCE_CraftingProfession(craft.craftProfession.name);
tmpProf.experience = craft.startingExp;
player.UCE_Crafts.Add(tmpProf);
}
}
// -- check starting recipes
foreach (UCE_Tmpl_Recipe recipe in player.startingRecipes)
{
if (!player.UCE_recipes.Any(r => r == recipe.name))
{
player.UCE_recipes.Add(recipe.name);
}
}
}
void OnServerCharacterCreate(NetworkMessage netMsg)
{
print("OnServerCharacterCreate " + netMsg.conn);
CharacterCreateMsg message = netMsg.ReadMessage <CharacterCreateMsg>();
// only while in lobby (aka after handshake and not ingame)
if (lobby.ContainsKey(netMsg.conn))
{
// allowed character name?
if (IsAllowedCharacterName(message.name))
{
// not existant yet?
string account = lobby[netMsg.conn];
if (!Database.CharacterExists(message.name))
{
// not too may characters created yet?
if (Database.CharactersForAccount(account).Count < characterLimit)
{
// valid class index?
List <Player> classes = GetPlayerClasses();
if (0 <= message.classIndex && message.classIndex < classes.Count)
{
// create new character based on the prefab.
// -> we also assign default items and equipment for new characters
// -> skills are handled in Database.CharacterLoad every time. if we
// add new ones to a prefab, all existing players should get them
// (instantiate temporary player)
print("creating character: " + message.name + " " + message.classIndex);
Player prefab = GameObject.Instantiate(classes[message.classIndex]).GetComponent <Player>();
prefab.name = message.name;
prefab.account = account;
prefab.className = classes[message.classIndex].name;
prefab.transform.position = GetStartPositionFor(prefab.className).position;
for (int i = 0; i < prefab.inventorySize; ++i)
{
// add empty slot or default item if any
prefab.inventory.Add(i < prefab.defaultItems.Length ? new ItemSlot(new Item(prefab.defaultItems[i])) : new ItemSlot());
}
for (int i = 0; i < prefab.equipmentInfo.Length; ++i)
{
// add empty slot or default item if any
EquipmentInfo info = prefab.equipmentInfo[i];
prefab.equipment.Add(info.defaultItem != null ? new ItemSlot(new Item(info.defaultItem)) : new ItemSlot());
}
prefab.health = prefab.healthMax; // after equipment in case of boni
prefab.mana = prefab.manaMax; // after equipment in case of boni
// addon system hooks
Utils.InvokeMany(typeof(NetworkManagerMMO), this, "OnServerCharacterCreate_", message, prefab);
// save the player
Database.CharacterSave(prefab, false);
GameObject.Destroy(prefab.gameObject);
// send available characters list again, causing
// the client to switch to the character
// selection scene again
CharactersAvailableMsg reply = MakeCharactersAvailableMessage(account);
netMsg.conn.Send(CharactersAvailableMsg.MsgId, reply);
}
else
{
print("character invalid class: " + message.classIndex);
ClientSendPopup(netMsg.conn, "character invalid class", false);
}
}
else
{
print("character limit reached: " + message.name);
ClientSendPopup(netMsg.conn, "character limit reached", false);
}
}
else
{
print("character name already exists: " + message.name);
ClientSendPopup(netMsg.conn, "name already exists", false);
}
}
else
{
print("character name not allowed: " + message.name);
ClientSendPopup(netMsg.conn, "character name not allowed", false);
}
}
else
{
print("CharacterCreate: not in lobby");
ClientSendPopup(netMsg.conn, "CharacterCreate: not in lobby", true);
}
}
void OnServerCharacterCreate_Example(CharacterCreateMsg message, Player player)
{
}
private void OnServerCharacterCreate_UCE_Traits(CharacterCreateMsg netMsg, Player player)
{
if (netMsg == null || netMsg.traits == null || netMsg.traits.Length == 0) return;
foreach (int traitId in netMsg.traits)
{
if (traitId != 0)
{
UCE_TraitTemplate trait;
if (UCE_TraitTemplate.dict.TryGetValue(traitId, out trait))
{
player.UCE_Traits.Add(new UCE_Trait(trait));
#if _iMMOATTRIBUTES
foreach (UCE_AttributeTemplate template in player.playerAttributes.UCE_AttributeTypes)
{
if (template == null) continue;
UCE_Attribute attr = new UCE_Attribute(template);
player.playerAttributes.UCE_Attributes.Add(attr);
}
#endif
// ----------------------------------------------------------------------
foreach (UCE_SkillRequirement startSkill in trait.startingSkills)
{
for (int i = 0; i < player.skills.skills.Count; ++i)
{
if (player.skills.skills[i].data == startSkill.skill)
{
Skill skill = player.skills.skills[i];
skill.level += startSkill.level;
player.skills.skills[i] = skill;
}
}
}
// ----------------------------------------------------------------------
foreach (UCE_ItemModifier startItem in trait.startingItems)
{
player.inventory.Add(new Item(startItem.item), startItem.amount);
}
#if _iMMOPRESTIGECLASSES
if (trait.startingPrestigeClass != null)
player.UCE_prestigeClass = trait.startingPrestigeClass;
#endif
#if _iMMOHONORSHOP
foreach (UCE_HonorShopCurrencyCost currency in trait.startingHonorCurrency)
player.UCE_AddHonorCurrency(currency.honorCurrency, currency.amount);
#endif
#if _iMMOFACTIONS
foreach (UCE_FactionRating faction in trait.startingFactions)
player.UCE_AddFactionRating(faction.faction, faction.startRating);
#endif
#if _iMMOCRAFTING
foreach (UCE_CraftingProfessionRequirement prof in trait.startingCraftingProfession)
{
if (player.UCE_HasCraftingProfession(prof.template))
{
var tmpProf = player.UCE_getCraftingProfession(prof.template);
tmpProf.experience += prof.level;
player.UCE_setCraftingProfession(tmpProf);
}
else
{
UCE_CraftingProfession tmpProf = new UCE_CraftingProfession(prof.template.name);
tmpProf.experience += prof.level;
player.UCE_Crafts.Add(tmpProf);
}
}
#endif
#if _iMMOHARVESTING
foreach (UCE_HarvestingProfessionRequirement prof in trait.startingHarvestingProfession)
{
if (player.HasHarvestingProfession(prof.template))
{
var tmpProf = player.getHarvestingProfession(prof.template);
tmpProf.experience += prof.level;
player.SetHarvestingProfession(tmpProf);
}
else
{
UCE_HarvestingProfession tmpProf = new UCE_HarvestingProfession(prof.template.name);
tmpProf.experience += prof.level;
player.UCE_Professions.Add(tmpProf);
}
}
#endif
#if _iMMOPVP
player.UCE_setRealm(trait.changeRealm, trait.changeAlliedRealm);
#endif
// ------------ Recalculate all Maxes here again (in case of bonusses)
player.health.current = player.health.max;
player.mana.current = player.mana.max;
#if _iMMOSTAMINA
player.stamina = player.staminaMax;
#endif
// ----------------------------------------------------------------------
}
}
}
}
void OnServerCharacterCreate(NetworkConnection conn, CharacterCreateMsg message)
{
//print("OnServerCharacterCreate " + conn);
// only while in lobby (aka after handshake and not ingame)
if (lobby.ContainsKey(conn))
{
// allowed character name?
if (IsAllowedCharacterName(message.name))
{
// not existent yet?
string account = lobby[conn];
if (!Database.singleton.CharacterExists(message.name))
{
// not too may characters created yet?
if (Database.singleton.CharactersForAccount(account).Count < characterLimit)
{
// valid class index?
if (0 <= message.classIndex && message.classIndex < playerClasses.Count)
{
// game master can only be requested by the host.
// DO NOT allow regular connections to create GMs!
if (message.gameMaster == false ||
conn == NetworkServer.localConnection)
{
// create new character based on the prefab.
Player player = CreateCharacter(playerClasses[message.classIndex].gameObject, message.name, account, message.gameMaster);
// addon system hooks
onServerCharacterCreate.Invoke(message, player);
// save the player
Database.singleton.CharacterSave(player, false);
Destroy(player.gameObject);
// send available characters list again, causing
// the client to switch to the character
// selection scene again
conn.Send(MakeCharactersAvailableMessage(account));
}
else
{
//print("character insufficient permissions for GM request: " + conn); <- don't show on live server
ServerSendError(conn, "insufficient permissions", false);
}
}
else
{
//print("character invalid class: " + message.classIndex); <- don't show on live server
ServerSendError(conn, "character invalid class", false);
}
}
else
{
//print("character limit reached: " + message.name); <- don't show on live server
ServerSendError(conn, "character limit reached", false);
}
}
else
{
//print("character name already exists: " + message.name); <- don't show on live server
ServerSendError(conn, "name already exists", false);
}
}
else
{
//print("character name not allowed: " + message.name); <- don't show on live server
ServerSendError(conn, "character name not allowed", false);
}
}
else
{
//print("CharacterCreate: not in lobby"); <- don't show on live server
ServerSendError(conn, "CharacterCreate: not in lobby", true);
}
}
