/// <summary>
/// Triggered When New Character is Created.
/// </summary>
/// <param name="e"></param>
/// <param name="sender"></param>
/// <param name="args"></param>
public static void OnCharacterCreation(DOLEvent e, object sender, EventArgs args)
{
// Only act if enabled.
if (!START_AS_BASE_CLASS)
{
return;
}
// Check Args
var chArgs = args as CharacterEventArgs;
if (chArgs == null)
{
return;
}
DOLCharacters ch = chArgs.Character;
// Revert to Base Class.
var chClass = ScriptMgr.FindCharacterBaseClass(ch.Class);
if (chClass != null && chClass.ID != ch.Class)
{
ch.Class = chClass.ID;
}
}
/// <summary>
/// Add newly created player to startup guild.
/// </summary>
/// <param name="e"></param>
/// <param name="sender"></param>
/// <param name="args"></param>
public static void AddNewbieToStarterGuild(DOLEvent e, object sender, EventArgs args)
{
if (!STARTING_GUILD)
{
return;
}
// Check Args
var chArgs = args as CharacterEventArgs;
if (chArgs == null)
{
return;
}
DOLCharacters ch = chArgs.Character;
Account account = chArgs.GameClient.Account;
if ((ePrivLevel)account.PrivLevel == ePrivLevel.Player)
{
var guildname = LanguageMgr.GetTranslation(ServerProperties.Properties.SERV_LANGUAGE, string.Format("Guild.StartupGuild.{0}", GlobalConstants.RealmToName((eRealm)ch.Realm)));
ch.GuildID = GuildMgr.GuildNameToGuildID(guildname);
if (ch.GuildID != "")
{
ch.GuildRank = 8;
}
}
}
/// <summary>
/// Loads a player from the DB
/// </summary>
/// <param name="accountindex">Index of the character within the account</param>
public void LoadPlayer(DOLCharacters dolChar, string playerClass)
{
m_activeCharIndex = 0;
foreach (var ch in Account.Characters)
{
if (ch.ObjectId == dolChar.ObjectId)
{
break;
}
m_activeCharIndex++;
}
Assembly gasm = Assembly.GetAssembly(typeof(GameServer));
GamePlayer player = null;
try
{
player = (GamePlayer)gasm.CreateInstance(playerClass, false, BindingFlags.CreateInstance, null, new object[] { this, dolChar }, null, null);
}
catch (Exception e)
{
if (log.IsErrorEnabled)
{
log.Error("LoadPlayer", e);
}
}
if (player == null)
{
foreach (Assembly asm in ScriptMgr.Scripts)
{
try
{
player = (GamePlayer)asm.CreateInstance(playerClass, false, BindingFlags.CreateInstance, null, new object[] { this, dolChar }, null, null);
}
catch (Exception e)
{
if (log.IsErrorEnabled)
{
log.Error("LoadPlayer", e);
}
}
if (player != null)
{
break;
}
}
}
if (player == null)
{
log.ErrorFormat("Could not instantiate player class '{0}', using GamePlayer instead!", playerClass);
player = new GamePlayer(this, dolChar);
}
Thread.MemoryBarrier();
Player = player;
}
/// <summary>
/// Gets the level of the specified spec
/// </summary>
/// <param name="playerChar">Character to check</param>
/// <param name="specName">Spec name (use Specs enum)</param>
/// <returns>The level of the spec (0 if not found; 1 if spec found, but no level)</returns>
public static byte GetCharacterSpecLevel(DOLCharacters playerChar, string specName)
{
string[] playerspecs = playerChar.SerializedSpecs.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
string[] specInfo;
byte specLevel = 0;
foreach (string spec in playerspecs)
{
if (spec.StartsWith(specName))
{
specInfo = spec.Split(new char[] { '|' });
if (specInfo.Length < 2)
{
specLevel = 1;
}
else
{
byte.TryParse(specInfo[1], out specLevel);
}
}
}
return(specLevel);
}
/// <summary>
/// Gets the level of the specified ability
/// </summary>
/// <param name="playerChar">Character to check</param>
/// <param name="abilityName">Ability name (use Abilities enum)</param>
/// <returns>The level of the ability (0 if not found; 1 if ability found, but no level)</returns>
public static byte GetCharacterAbilityLevel(DOLCharacters playerChar, string abilityName)
{
string[] abilities = playerChar.SerializedAbilities.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
string[] abilityInfo;
byte abilityLevel = 0;
foreach (string ability in abilities)
{
if (ability.StartsWith(abilityName))
{
abilityInfo = ability.Split(new char[] { '|' });
if (abilityInfo.Length < 2)
{
abilityLevel = 1;
}
else
{
byte.TryParse(abilityInfo[1], out abilityLevel);
}
}
}
return(abilityLevel);
}
/// <summary>
/// Triggered When New Character is Created.
/// </summary>
/// <param name="e"></param>
/// <param name="sender"></param>
/// <param name="args"></param>
public static void OnCharacterCreation(DOLEvent e, object sender, EventArgs args)
{
// Check Args
var chArgs = args as CharacterEventArgs;
if (chArgs == null)
{
return;
}
DOLCharacters ch = chArgs.Character;
// Add all Crafting skills at level 1
var collectionAllCraftingSkills = new List <string>();
foreach (int craftingSkillId in Enum.GetValues(typeof(eCraftingSkill)))
{
if (craftingSkillId > 0)
{
collectionAllCraftingSkills.Add(string.Format("{0}|1", craftingSkillId));
if (craftingSkillId == (int)eCraftingSkill._Last)
{
break;
}
}
}
// Set Primary Skill to Basic.
ch.SerializedCraftingSkills = string.Join(";", collectionAllCraftingSkills);
ch.CraftingPrimarySkill = (int)eCraftingSkill.BasicCrafting;
}
/// <summary>
/// Change location on character selection if it has any wrong values...
/// </summary>
public static void CharacterSelection(DOLEvent ev, object sender, EventArgs args)
{
// Check Args
var chArgs = args as CharacterEventArgs;
if (chArgs == null)
{
return;
}
DOLCharacters ch = chArgs.Character;
// check if location looks ok.
if (ch.Xpos == 0 && ch.Ypos == 0 && ch.Zpos == 0)
{
// This character needs to be fixed !
CharacterCreation(ev, sender, args);
GameServer.Database.SaveObject(ch);
return;
}
// check if bind looks ok.
if (ch.BindXpos == 0 && ch.BindYpos == 0 && ch.BindZpos == 0)
{
// This Bind needs to be fixed !
BindCharacter(ch);
GameServer.Database.SaveObject(ch);
}
}
protected GamePlayer CreateMockGamePlayer()
{
DOLCharacters character = null;
Account account = GameServer.Database.SelectObject <Account>("");
Assert.IsNotNull(account);
foreach (DOLCharacters charact in account.Characters)
{
if (charact != null)
{
character = charact;
}
}
Assert.IsNotNull(character);
GameClient client = new GameClient(GameServer.Instance);
client.Version = GameClient.eClientVersion.Version1105;
client.Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
client.Account = account;
client.PacketProcessor = new DOL.GS.PacketHandler.PacketProcessor(client);
client.Out = new DOL.GS.PacketHandler.PacketLib1105(client);
client.Player = new GamePlayer(client, character);
Assert.IsNotNull(client.Player, "GamePlayer instance created");
return(client.Player);
}
/// <summary>
/// Triggered When New Character is Created.
/// </summary>
/// <param name="e"></param>
/// <param name="sender"></param>
/// <param name="args"></param>
public static void OnCharacterCreation(DOLEvent e, object sender, EventArgs args)
{
// Check Args
var chArgs = args as CharacterEventArgs;
if (chArgs == null)
{
return;
}
DOLCharacters ch = chArgs.Character;
// Property BPS
if (STARTING_BPS > 0)
{
ch.BountyPoints = STARTING_BPS;
}
// Property Money
if (STARTING_MONEY > 0)
{
long value = STARTING_MONEY;
ch.Copper = Money.GetCopper(value);
ch.Silver = Money.GetSilver(value);
ch.Gold = Money.GetGold(value);
ch.Platinum = Money.GetPlatinum(value);
}
// Property Realm Level
if (STARTING_REALM_LEVEL > 0)
{
int realmLevel = STARTING_REALM_LEVEL;
long rpamount = 0;
if (realmLevel < GamePlayer.REALMPOINTS_FOR_LEVEL.Length)
{
rpamount = GamePlayer.REALMPOINTS_FOR_LEVEL[realmLevel];
}
// thanks to Linulo from http://daoc.foren.4players.de/viewtopic.php?t=40839&postdays=0&postorder=asc&start=0
if (rpamount == 0)
{
rpamount = (long)(25.0 / 3.0 * (realmLevel * realmLevel * realmLevel) - 25.0 / 2.0 * (realmLevel * realmLevel) + 25.0 / 6.0 * realmLevel);
}
ch.RealmPoints = rpamount;
ch.RealmLevel = realmLevel;
}
// Property Starting Level
if (STARTING_LEVEL > 1 && ch.Experience < GamePlayer.GetExperienceAmountForLevel(STARTING_LEVEL - 1))
{
ch.Experience = GamePlayer.GetExperienceAmountForLevel(STARTING_LEVEL - 1);
ch.Level = STARTING_LEVEL;
}
// Default 2 Respec Realm Skill
ch.RespecAmountRealmSkill += 2;
}
/// <summary>
/// Binds character to current location
/// </summary>
/// <param name="ch"></param>
public static void BindCharacter(DOLCharacters ch)
{
ch.BindRegion = ch.Region;
ch.BindHeading = ch.Direction;
ch.BindXpos = ch.Xpos;
ch.BindYpos = ch.Ypos;
ch.BindZpos = ch.Zpos;
}
public void LoadPlayer(int accountindex, string playerClass)
{
// refreshing Account to load any changes from the DB
GameServer.Database.FillObjectRelations(m_account);
DOLCharacters dolChar = m_account.Characters[accountindex];
LoadPlayer(dolChar, playerClass);
}
/// <summary>
/// Loads a player from the DB
/// </summary>
/// <param name="accountindex">Index of the character within the account</param>
public void LoadPlayer(int accountindex, string playerClass)
{
m_activeCharIndex = accountindex;
GamePlayer player = null;
// refreshing Account to load any changes from the DB
GameServer.Database.FillObjectRelations(m_account);
DOLCharacters dolChar = m_account.Characters[m_activeCharIndex];
Assembly gasm = Assembly.GetAssembly(typeof(GameServer));
try
{
player = (GamePlayer)gasm.CreateInstance(playerClass, false, BindingFlags.CreateInstance, null, new object[] { this, dolChar }, null, null);
}
catch (Exception e)
{
if (log.IsErrorEnabled)
{
log.Error("LoadPlayer", e);
}
}
if (player == null)
{
foreach (Assembly asm in ScriptMgr.Scripts)
{
try
{
player = (GamePlayer)asm.CreateInstance(playerClass, false, BindingFlags.CreateInstance, null, new object[] { this, dolChar }, null, null);
}
catch (Exception e)
{
if (log.IsErrorEnabled)
{
log.Error("LoadPlayer", e);
}
}
if (player != null)
{
break;
}
}
}
if (player == null)
{
log.ErrorFormat("Could not instantiate player class '{0}', using GamePlayer instead!", playerClass);
player = new GamePlayer(this, dolChar);
}
Thread.MemoryBarrier();
Player = player;
}
/// <summary>
/// Change location on character creation
/// </summary>
public static void CharacterCreation(DOLEvent ev, object sender, EventArgs args)
{
// Check Args
var chArgs = args as CharacterEventArgs;
if (chArgs == null)
{
return;
}
DOLCharacters ch = chArgs.Character;
try
{
var availableLocation = GetAllStartupLocationForCharacter(ch, chArgs.GameClient.Version);
StartupLocation dbStartupLocation = null;
// get the first entry according to Tutorial Enabling.
foreach (var location in availableLocation)
{
if (ServerProperties.Properties.DISABLE_TUTORIAL && location.ClientRegionID == TUTORIAL_REGIONID)
{
continue;
}
dbStartupLocation = location;
break;
}
if (dbStartupLocation == null)
{
log.WarnFormat(
"startup location not found: account={0}; char name={1}; region={2}; realm={3}; class={4} ({5}); race={6} ({7}); version={8}",
ch.AccountName, ch.Name, ch.Region, ch.Realm, ch.Class, (eCharacterClass)ch.Class, ch.Race, (eRace)ch.Race, chArgs.GameClient.Version);
}
else
{
ch.Xpos = dbStartupLocation.XPos;
ch.Ypos = dbStartupLocation.YPos;
ch.Zpos = dbStartupLocation.ZPos;
ch.Region = dbStartupLocation.Region;
ch.Direction = dbStartupLocation.Heading;
BindCharacter(ch);
}
}
catch (Exception e)
{
if (log.IsErrorEnabled)
{
log.ErrorFormat(
"StartupLocations script: error changing location. account={0}; char name={1}; region={2}; realm={3}; class={4} ({5}); race={6} ({7}); version={8}; {9}",
ch.AccountName, ch.Name, ch.Region, ch.Realm, ch.Class, (eCharacterClass)ch.Class, ch.Race, (eRace)ch.Race, chArgs.GameClient.Version, e);
}
}
}
/// <summary>
/// Kicks an active playing character from the server
/// </summary>
/// <param name="cha">the character</param>
private void KickCharacter(DOLCharacters cha)
{
GameClient playingclient = WorldMgr.GetClientByPlayerName(cha.Name, true, false);
if (playingclient != null)
{
playingclient.Out.SendPlayerQuit(true);
playingclient.Disconnect();
}
}
public static IList <StartupLocation> GetAllStartupLocationForCharacter(DOLCharacters ch, GameClient.eClientVersion cli)
{
return(m_cachedLocations.Where(sl => sl.MinVersion <= (int)cli)
.Where(sl => sl.ClassID == 0 || sl.ClassID == ch.Class)
.Where(sl => sl.RaceID == 0 || sl.RaceID == ch.Race)
.Where(sl => sl.RealmID == 0 || sl.RealmID == ch.Realm)
.Where(sl => sl.ClientRegionID == 0 || sl.ClientRegionID == ch.Region)
.OrderByDescending(sl => sl.MinVersion).ThenByDescending(sl => sl.ClientRegionID)
.ThenByDescending(sl => sl.RealmID).ThenByDescending(sl => sl.ClassID)
.ThenByDescending(sl => sl.RaceID).ToList());
}
private static void UpdateCharacterPosition(DOLCharacters character, int region, int x, int y, int z, int heading)
{
character.Region = region;
character.BindRegion = region;
character.Xpos = x;
character.BindXpos = x;
character.Ypos = y;
character.BindYpos = y;
character.Zpos = z;
character.BindZpos = z;
character.BindHeading = heading;
}
/// <summary>
/// Check if Custom Creation Points Distribution is Valid.
/// </summary>
/// <param name="character"></param>
/// <param name="stats"></param>
/// <param name="points"></param>
/// <returns></returns>
public static bool IsCustomPointsDistributionValid(DOLCharacters character, IDictionary <eStat, int> stats, out int points)
{
ICharacterClass charClass = ScriptMgr.FindCharacterClass(character.Class);
if (charClass != null)
{
points = 0;
// check if each stat is valid.
foreach (var stat in stats.Keys)
{
int raceAmount = GlobalConstants.STARTING_STATS_DICT[(eRace)character.Race][stat];
int classAmount = 0;
for (int level = character.Level; level > 5; level--)
{
if (charClass.PrimaryStat != eStat.UNDEFINED && charClass.PrimaryStat == stat)
{
classAmount++;
}
if (charClass.SecondaryStat != eStat.UNDEFINED && charClass.SecondaryStat == stat && (level - 6) % 2 == 0)
{
classAmount++;
}
if (charClass.TertiaryStat != eStat.UNDEFINED && charClass.TertiaryStat == stat && (level - 6) % 3 == 0)
{
classAmount++;
}
}
int above = stats[stat] - raceAmount - classAmount;
// Miss Some points...
if (above < 0)
{
return(false);
}
points += above;
points += Math.Max(0, above - 10); // two points used
points += Math.Max(0, above - 15); // three points used
}
return(points == MaxStartingBonusPoints);
}
points = -1;
return(false);
}
/// <summary>
/// Returns an account name with a given character name
/// </summary>
/// <param name="charname">the charactername</param>
/// <returns>the account name or null</returns>
private string GetAccountName(string charname)
{
GameClient client = WorldMgr.GetClientByPlayerName(charname, true, false);
if (client != null)
{
return(client.Account.Name);
}
DOLCharacters ch = GameServer.Database.SelectObjects <DOLCharacters>("`Name` = @Name", new QueryParameter("@Name", charname)).FirstOrDefault();
if (ch != null)
{
return(ch.AccountName);
}
else
{
return(null);
}
}
/// <summary>
/// Returns an account name with a given character name
/// </summary>
/// <param name="charname">the charactername</param>
/// <returns>the account name or null</returns>
private string GetAccountName(string charname)
{
GameClient client = WorldMgr.GetClientByPlayerName(charname, true, false);
if (client != null)
{
return(client.Account.Name);
}
DOLCharacters ch = GameServer.Database.SelectObject <DOLCharacters>("Name='" + GameServer.Database.Escape(charname) + "'");
if (ch != null)
{
return(ch.AccountName);
}
else
{
return(null);
}
}
/*
* public static List<Spell> GetCharacterSpells(DOLCharacters playerChar)
* {
* string[] playerspecs = playerChar.SerializedSpecs.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
* //ist<Styles.Style> charStyles = new List<DOL.GS.Styles.Style>(30);
* List<Spell> charStyles = new List<Spell>(150);
* List<Spell> specStyles;
* string specName;
* byte specLevel;
*
* foreach (string specInfo in playerspecs)
* {
* if (specInfo.Contains("|"))
* {
* specName = specInfo.Split(new char[] { '|' })[0];
* if (!byte.TryParse(specInfo.Split(new char[] { '|' })[1], out specLevel))
* specLevel = 50;
* }
* else
* {
* specName = specInfo;
* specLevel = 50;
* }
*
* specStyles = SkillBase.GetSpellList(specName);
*
*
* for (int i = specStyles.Count - 1; i >= 0; i--)
* {
* specStyles.RemoveAt(i);
* }
*
* charStyles.AddRange(specStyles);
* }
*
* return charStyles;
* }
*/
/// <summary>
/// Gets the list of styles
/// </summary>
/// <param name="playerChar">Character to check</param>
/// <returns>List of styles</returns>
public static List <Styles.Style> GetCharacterStyles(DOLCharacters playerChar)
{
string[] playerspecs = playerChar.SerializedSpecs.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
List <Styles.Style> charStyles = new List <DOL.GS.Styles.Style>(30);
List <Styles.Style> specStyles;
string specName;
byte specLevel;
foreach (string specInfo in playerspecs)
{
if (specInfo.Contains("|"))
{
specName = specInfo.Split(new char[] { '|' })[0];
if (!byte.TryParse(specInfo.Split(new char[] { '|' })[1], out specLevel))
{
specLevel = 50;
}
}
else
{
specName = specInfo;
specLevel = 50;
}
specStyles = SkillBase.GetStyleList(specName, playerChar.Class);
for (int i = specStyles.Count - 1; i >= 0; i--)
{
if (specLevel < specStyles[i].SpecLevelRequirement)
{
specStyles.RemoveAt(i);
}
}
charStyles.AddRange(specStyles);
}
return(charStyles);
}
/// <summary>
/// Apply the effect.
/// </summary>
/// <param name="target"></param>
/// <param name="effectiveness"></param>
public override void ApplyEffectOnTarget(GameLiving target, double effectiveness)
{
GamePlayer player = Caster as GamePlayer;
if (player == null)
{
return;
}
if (player.InCombat || GameRelic.IsPlayerCarryingRelic(player) || player.IsMoving)
{
return;
}
SendEffectAnimation(player, 0, false, 1);
UniPortalEffect effect = new UniPortalEffect(this, 1000);
effect.Start(player);
DOLCharacters character = player.DBCharacter;
player.MoveTo((ushort)character.BindRegion, character.BindXpos, character.BindYpos, character.BindZpos, (ushort)character.BindHeading);
}
public void HandlePacket(GameClient client, GSPacketIn packet)
{
string name = packet.ReadString(30);
string select = string.Format("Name = '{0}'", GameServer.Database.Escape(name));
DOLCharacters character = GameServer.Database.SelectObject <DOLCharacters>(select);
bool nameExists = (character != null);
// Bad Name check.
ArrayList invalidNames = GameServer.Instance.InvalidNames;
foreach (string invalidName in invalidNames)
{
if (invalidName.StartsWith("/") && invalidName.EndsWith("/"))
{
// Regex matching
string re = invalidName.Replace("/", "");
Match match = Regex.Match(name.ToLower(), re, RegexOptions.IgnoreCase);
if (match.Success)
{
nameExists = true;
break;
}
}
else
{
// "Normal" complete partial match
if (name.ToLower().Contains(invalidName.ToLower()))
{
nameExists = true;
break;
}
}
}
client.Out.SendDupNameCheckReply(name, nameExists);
}
/// <summary>
/// Add starter equipment to the character
/// </summary>
/// <param name="c">The character</param>
public static void AddEquipment(DOLCharacters c)
{
Hashtable usedSlots = new Hashtable();
// 0 = for all classes, then quickcheck if it contains the classid
var items = GameServer.Database.SelectObjects <StarterEquipment>("`Class` = '0' OR `Class` LIKE '%" + c.Class + "%'");
foreach (StarterEquipment item in items)
{
if (item.Template == null)
{
GameServer.Instance.Logger.Error("StartupEquipment.cs error adding starter equipment for class " + c.Class + " cannot find itemtemplate for " + item.TemplateID);
continue;
}
// deeper check if item is suitable to classid
if (!Util.IsEmpty(item.Class, true))
{
int charClass;
bool isFind = false;
foreach (string currentItem in item.Class.SplitCSV(true))
{
int.TryParse(currentItem, out charClass);
if (charClass == c.Class)
{
isFind = true;
break;
}
}
if (!isFind)
{
continue;
}
}
InventoryItem inventoryItem = GameInventoryItem.Create <ItemTemplate>(item.Template);
inventoryItem.OwnerID = c.ObjectId;
inventoryItem.Realm = c.Realm;
//if equipable item, equip
foreach (eInventorySlot slot in GameLivingInventory.EQUIP_SLOTS)
{
if (slot == (eInventorySlot)inventoryItem.Item_Type)
{
eInventorySlot chosenSlot = eInventorySlot.FirstEmptyBackpack;
if (slot == eInventorySlot.LeftHandWeapon && (eObjectType)inventoryItem.Object_Type != eObjectType.Shield && usedSlots.ContainsKey(eInventorySlot.RightHandWeapon) == false)
{
chosenSlot = eInventorySlot.RightHandWeapon;
}
else
{
chosenSlot = slot;
}
if (usedSlots.ContainsKey(chosenSlot))
{
GameServer.Instance.Logger.Error("Cannot add item " + item.TemplateID + " to class " + item.Class + " already an item for that slot assigned!");
continue;
}
inventoryItem.SlotPosition = (int)chosenSlot;
usedSlots[chosenSlot] = true;
if (c.ActiveWeaponSlot == 0)
{
switch (inventoryItem.SlotPosition)
{
case Slot.RIGHTHAND:
c.ActiveWeaponSlot = (byte)GamePlayer.eActiveWeaponSlot.Standard;
break;
case Slot.TWOHAND:
c.ActiveWeaponSlot = (byte)GamePlayer.eActiveWeaponSlot.TwoHanded;
break;
case Slot.RANGED:
c.ActiveWeaponSlot = (byte)GamePlayer.eActiveWeaponSlot.Distance;
break;
}
}
}
}
if (inventoryItem.SlotPosition == 0)
{
//otherwise stick the item in the backpack
for (int i = (int)eInventorySlot.FirstBackpack; i < (int)eInventorySlot.LastBackpack; i++)
{
if (usedSlots[i] == null)
{
inventoryItem.SlotPosition = i;
usedSlots[i] = true;
break;
}
}
}
GameServer.Database.AddObject(inventoryItem);
}
}
private bool CreateCharacter(CreationCharacterData pdata, GameClient client, int accountSlot)
{
Account account = client.Account;
var ch = new DOLCharacters();
ch.AccountName = account.Name;
ch.Name = pdata.CharName;
if (pdata.CustomMode == 0x01)
{
ch.EyeSize = (byte)pdata.EyeSize;
ch.LipSize = (byte)pdata.LipSize;
ch.EyeColor = (byte)pdata.EyeColor;
ch.HairColor = (byte)pdata.HairColor;
ch.FaceType = (byte)pdata.FaceType;
ch.HairStyle = (byte)pdata.HairStyle;
ch.MoodType = (byte)pdata.MoodType;
ch.CustomisationStep = 2; // disable config button
if (log.IsDebugEnabled)
{
log.Debug("Disable Config Button");
}
}
ch.Level = 1;
// Set Realm and Class
ch.Realm = pdata.Realm;
ch.Class = pdata.Class;
// Set Account Slot, Gender
ch.AccountSlot = accountSlot + ch.Realm * 100;
ch.Gender = pdata.Gender;
// Set Race
ch.Race = pdata.Race;
ch.CreationModel = pdata.CreationModel;
ch.CurrentModel = ch.CreationModel;
ch.Region = pdata.Region;
ch.Strength = pdata.Strength;
ch.Dexterity = pdata.Dexterity;
ch.Constitution = pdata.Constitution;
ch.Quickness = pdata.Quickness;
ch.Intelligence = pdata.Intelligence;
ch.Piety = pdata.Piety;
ch.Empathy = pdata.Empathy;
ch.Charisma = pdata.Charisma;
// defaults
ch.CreationDate = DateTime.Now;
ch.Endurance = 100;
ch.MaxEndurance = 100;
ch.Concentration = 100;
ch.MaxSpeed = GamePlayer.PLAYER_BASE_SPEED;
if (log.IsDebugEnabled)
{
log.DebugFormat("Creation {0} character, class:{1}, realm:{2}", client.Version, ch.Class, ch.Realm);
}
// Is class disabled ?
int occurences = 0;
List <string> disabled_classes = Properties.DISABLED_CLASSES.SplitCSV(true);
occurences = (from j in disabled_classes
where j == ch.Class.ToString()
select j).Count();
if (occurences > 0 && (ePrivLevel)client.Account.PrivLevel == ePrivLevel.Player)
{
if (log.IsDebugEnabled)
{
log.DebugFormat("Client {0} tried to create a disabled classe: {1}", client.Account.Name, (eCharacterClass)ch.Class);
}
return(true);
}
// check if race disabled
List <string> disabled_races = Properties.DISABLED_RACES.SplitCSV(true);
occurences = (from j in disabled_races
where j == ch.Race.ToString()
select j).Count();
if (occurences > 0 && (ePrivLevel)client.Account.PrivLevel == ePrivLevel.Player)
{
if (log.IsDebugEnabled)
{
log.DebugFormat("Client {0} tried to create a disabled race: {1}", client.Account.Name, (eRace)ch.Race);
}
return(true);
}
// If sending invalid Class ID
if (!Enum.IsDefined(typeof(eCharacterClass), (eCharacterClass)ch.Class))
{
if (log.IsErrorEnabled)
{
log.ErrorFormat("{0} tried to create a character with wrong class ID: {1}, realm:{2}", client.Account.Name, ch.Class, ch.Realm);
}
if (ServerProperties.Properties.BAN_HACKERS)
{
client.BanAccount(string.Format("Autoban character create class: id:{0} realm:{1} name:{2} account:{3}", ch.Class, ch.Realm, ch.Name, account.Name));
client.Disconnect();
return(false);
}
return(true);
}
// check if client tried to create invalid char
if (!IsCharacterValid(ch))
{
if (log.IsWarnEnabled)
{
log.WarnFormat("{0} tried to create invalid character:\nchar name={1}, gender={2}, race={3}, realm={4}, class={5}, region={6}" +
"\nstr={7}, con={8}, dex={9}, qui={10}, int={11}, pie={12}, emp={13}, chr={14}", ch.AccountName, ch.Name, ch.Gender,
ch.Race, ch.Realm, ch.Class, ch.Region, ch.Strength, ch.Constitution, ch.Dexterity, ch.Quickness, ch.Intelligence, ch.Piety, ch.Empathy, ch.Charisma);
}
return(true);
}
//Save the character in the database
GameServer.Database.AddObject(ch);
// Fire the character creation event
// This is Where Most Creation Script should take over to update any data they would like !
GameEventMgr.Notify(DatabaseEvent.CharacterCreated, null, new CharacterEventArgs(ch, client));
//write changes
GameServer.Database.SaveObject(ch);
// Log creation
AuditMgr.AddAuditEntry(client, AuditType.Account, AuditSubtype.CharacterCreate, "", pdata.CharName);
client.Account.Characters = null;
if (log.IsInfoEnabled)
{
log.InfoFormat("Character {0} created on Account {1}!", pdata.CharName, account);
}
// Reload Account Relations
GameServer.Database.FillObjectRelations(client.Account);
return(true);
}
public override void SendCharacterOverview(eRealm realm)
{
if (realm < eRealm._FirstPlayerRealm || realm > eRealm._LastPlayerRealm)
{
throw new Exception($"CharacterOverview requested for unknown realm {realm}");
}
int firstSlot = (byte)realm * 100;
var enableRealmSwitcherBit = GameServer.ServerRules.IsAllowedCharsInAllRealms(m_gameClient) ? 1 : 0;
using (GSTCPPacketOut pak = new GSTCPPacketOut(GetPacketCode(eServerPackets.CharacterOverview1126)))
{
pak.WriteIntLowEndian((uint)enableRealmSwitcherBit); // 0x01 & 0x02 are flags
pak.WriteIntLowEndian(0);
pak.WriteIntLowEndian(0);
pak.WriteIntLowEndian(0);
if (m_gameClient.Account.Characters == null || m_gameClient.Account.Characters.Length == 0)
{
SendTCP(pak);
return;
}
Dictionary <int, DOLCharacters> charsBySlot = new Dictionary <int, DOLCharacters>();
foreach (DOLCharacters c in m_gameClient.Account.Characters)
{
try
{
charsBySlot.Add(c.AccountSlot, c);
}
catch (Exception ex)
{
log.Error($"SendCharacterOverview - Duplicate char in slot? Slot: {c.AccountSlot}, Account: {c.AccountName}", ex);
}
}
var itemsByOwnerID = new Dictionary <string, Dictionary <eInventorySlot, InventoryItem> >();
if (charsBySlot.Any())
{
var filterBySlotPosition = DB.Column(nameof(InventoryItem.SlotPosition)).IsGreaterOrEqualTo((int)eInventorySlot.MinEquipable)
.And(DB.Column(nameof(InventoryItem.SlotPosition)).IsLessOrEqualTo((int)eInventorySlot.MaxEquipable));
var allItems = DOLDB <InventoryItem> .SelectObjects(DB.Column(nameof(InventoryItem.OwnerID)).IsIn(charsBySlot.Values.Select(c => c.ObjectId)).And(filterBySlotPosition));
foreach (InventoryItem item in allItems)
{
try
{
if (!itemsByOwnerID.ContainsKey(item.OwnerID))
{
itemsByOwnerID.Add(item.OwnerID, new Dictionary <eInventorySlot, InventoryItem>());
}
itemsByOwnerID[item.OwnerID].Add((eInventorySlot)item.SlotPosition, item);
}
catch (Exception ex)
{
log.Error($"SendCharacterOverview - Duplicate item on character? OwnerID: {item.OwnerID}, SlotPosition: {item.SlotPosition}, Account: {m_gameClient.Account.Name}", ex);
}
}
}
// send each characters
for (int i = firstSlot; i < (firstSlot + 10); i++)
{
DOLCharacters c = null;
if (!charsBySlot.TryGetValue(i, out c))
{
pak.WriteByte(0);
continue;
}
Dictionary <eInventorySlot, InventoryItem> charItems = null;
if (!itemsByOwnerID.TryGetValue(c.ObjectId, out charItems))
{
charItems = new Dictionary <eInventorySlot, InventoryItem>();
}
byte extensionTorso = 0;
byte extensionGloves = 0;
byte extensionBoots = 0;
InventoryItem item = null;
if (charItems.TryGetValue(eInventorySlot.TorsoArmor, out item))
{
extensionTorso = item.Extension;
}
if (charItems.TryGetValue(eInventorySlot.HandsArmor, out item))
{
extensionGloves = item.Extension;
}
if (charItems.TryGetValue(eInventorySlot.FeetArmor, out item))
{
extensionBoots = item.Extension;
}
string locationDescription = string.Empty;
Region region = WorldMgr.GetRegion((ushort)c.Region);
if (region != null)
{
locationDescription = m_gameClient.GetTranslatedSpotDescription(region, c.Xpos, c.Ypos, c.Zpos);
}
string classname = "";
if (c.Class != 0)
{
classname = ((eCharacterClass)c.Class).ToString();
}
string racename = m_gameClient.RaceToTranslatedName(c.Race, c.Gender);
charItems.TryGetValue(eInventorySlot.RightHandWeapon, out InventoryItem rightHandWeapon);
charItems.TryGetValue(eInventorySlot.LeftHandWeapon, out InventoryItem leftHandWeapon);
charItems.TryGetValue(eInventorySlot.TwoHandWeapon, out InventoryItem twoHandWeapon);
charItems.TryGetValue(eInventorySlot.DistanceWeapon, out InventoryItem distanceWeapon);
charItems.TryGetValue(eInventorySlot.HeadArmor, out InventoryItem helmet);
charItems.TryGetValue(eInventorySlot.HandsArmor, out InventoryItem gloves);
charItems.TryGetValue(eInventorySlot.FeetArmor, out InventoryItem boots);
charItems.TryGetValue(eInventorySlot.TorsoArmor, out InventoryItem torso);
charItems.TryGetValue(eInventorySlot.Cloak, out InventoryItem cloak);
charItems.TryGetValue(eInventorySlot.LegsArmor, out InventoryItem legs);
charItems.TryGetValue(eInventorySlot.ArmsArmor, out InventoryItem arms);
ushort rightHandColor = 0;
if (rightHandWeapon != null)
{
rightHandColor = (ushort)(rightHandWeapon.Emblem != 0 ? rightHandWeapon.Emblem : rightHandWeapon.Color);
}
ushort helmetColor = 0;
if (helmet != null)
{
helmetColor = (ushort)(helmet.Emblem != 0 ? helmet.Emblem : helmet.Color);
}
ushort glovesColor = 0;
if (gloves != null)
{
glovesColor = (ushort)(gloves.Emblem != 0 ? gloves.Emblem : gloves.Color);
}
ushort bootsColor = 0;
if (boots != null)
{
bootsColor = (ushort)(boots.Emblem != 0 ? boots.Emblem : boots.Color);
}
ushort leftHandWeaponColor = 0;
if (leftHandWeapon != null)
{
leftHandWeaponColor = (ushort)(leftHandWeapon.Emblem != 0 ? leftHandWeapon.Emblem : leftHandWeapon.Color);
}
ushort torsoColor = 0;
if (torso != null)
{
torsoColor = (ushort)(torso.Emblem != 0 ? torso.Emblem : torso.Color);
}
ushort cloakColor = 0;
if (cloak != null)
{
cloakColor = (ushort)(cloak.Emblem != 0 ? cloak.Emblem : cloak.Color);
}
ushort legsColor = 0;
if (legs != null)
{
legsColor = (ushort)(legs.Emblem != 0 ? legs.Emblem : legs.Color);
}
ushort armsColor = 0;
if (arms != null)
{
armsColor = (ushort)(arms.Emblem != 0 ? arms.Emblem : arms.Color);
}
pak.WriteByte((byte)c.Level);
pak.WritePascalStringIntLE(c.Name, 0x18);
pak.WriteIntLowEndian(0x18);
pak.WriteByte(1); // always 1 ?
pak.WriteByte(c.EyeSize); // seems to be : 0xF0 = eyes, 0x0F = nose
pak.WriteByte(c.LipSize); // seems to be : 0xF0 = lips, 0xF = jaw
pak.WriteByte(c.EyeColor); // seems to be : 0xF0 = eye color, 0x0F = skin tone
pak.WriteByte(c.HairColor);
pak.WriteByte(c.FaceType); // seems to be : 0xF0 = face
pak.WriteByte(c.HairStyle); // seems to be : 0xF0 = hair
pak.WriteByte((byte)((extensionBoots << 4) | extensionGloves));
pak.WriteByte((byte)((extensionTorso << 4) | (c.IsCloakHoodUp ? 0x1 : 0x0)));
pak.WriteByte(c.CustomisationStep); //1 = auto generate config, 2= config ended by player, 3= enable config to player
pak.WriteByte(c.MoodType);
pak.Fill(0x0, 13);
pak.WritePascalStringIntLE(locationDescription, 0x18);
pak.WritePascalStringIntLE(classname, 0x18);
pak.WritePascalStringIntLE(racename, 0x18);
pak.WriteShortLowEndian((ushort)c.CurrentModel);
pak.WriteByte((byte)c.Region);
if (region == null || (int)m_gameClient.ClientType > region.Expansion)
{
pak.WriteByte(0x00);
}
else
{
pak.WriteByte((byte)(region.Expansion + 1)); //0x04-Cata zone, 0x05 - DR zone
}
pak.WriteShortLowEndian((ushort)(helmet != null ? helmet.Model : 0));
pak.WriteShortLowEndian((ushort)(gloves != null ? gloves.Model : 0));
pak.WriteShortLowEndian((ushort)(boots != null ? boots.Model : 0));
pak.WriteShortLowEndian(rightHandColor);
pak.WriteShortLowEndian((ushort)(torso != null ? torso.Model : 0));
pak.WriteShortLowEndian((ushort)(cloak != null ? cloak.Model : 0));
pak.WriteShortLowEndian((ushort)(legs != null ? legs.Model : 0));
pak.WriteShortLowEndian((ushort)(arms != null ? arms.Model : 0));
pak.WriteShortLowEndian(helmetColor);
pak.WriteShortLowEndian(glovesColor);
pak.WriteShortLowEndian(bootsColor);
pak.WriteShortLowEndian(leftHandWeaponColor);
pak.WriteShortLowEndian(torsoColor);
pak.WriteShortLowEndian(cloakColor);
pak.WriteShortLowEndian(legsColor);
pak.WriteShortLowEndian(armsColor);
//weapon models
pak.WriteShortLowEndian((ushort)(rightHandWeapon != null ? rightHandWeapon.Model : 0));
pak.WriteShortLowEndian((ushort)(leftHandWeapon != null ? leftHandWeapon.Model : 0));
pak.WriteShortLowEndian((ushort)(twoHandWeapon != null ? twoHandWeapon.Model : 0));
pak.WriteShortLowEndian((ushort)(distanceWeapon != null ? distanceWeapon.Model : 0));
pak.WriteByte((byte)c.Strength);
pak.WriteByte((byte)c.Quickness);
pak.WriteByte((byte)c.Constitution);
pak.WriteByte((byte)c.Dexterity);
pak.WriteByte((byte)c.Intelligence);
pak.WriteByte((byte)c.Piety);
pak.WriteByte((byte)c.Empathy); // ?
pak.WriteByte((byte)c.Charisma); // ?
pak.WriteByte((byte)c.Class);
pak.WriteByte((byte)c.Realm); // ok?
pak.WriteByte((byte)((((c.Race & 0x10) << 2) + (c.Race & 0x0F)) | (c.Gender << 4)));
if (c.ActiveWeaponSlot == (byte)GameLiving.eActiveWeaponSlot.TwoHanded)
{
pak.WriteByte(0x02);
pak.WriteByte(0x02);
}
else if (c.ActiveWeaponSlot == (byte)GameLiving.eActiveWeaponSlot.Distance)
{
pak.WriteByte(0x03);
pak.WriteByte(0x03);
}
else
{
pak.WriteByte((byte)(rightHandWeapon != null ? 0x00 : 0xFF));
pak.WriteByte((byte)(leftHandWeapon != null ? 0x01 : 0xFF));
}
pak.WriteByte(0); // SI = 1, Classic = 0
pak.WriteByte((byte)c.Constitution); // ok
pak.WriteByte(0); // unknown
}
SendTCP(pak);
}
}
public void LoadPlayer(DOLCharacters dolChar)
{
LoadPlayer(dolChar, Properties.PLAYER_CLASS);
}
/// <summary>
/// Command Handling Tests.
/// </summary>
/// <param name="client"></param>
/// <param name="args"></param>
public void OnCommand(GameClient client, string[] args)
{
// Needs all arguments
if (args.Length < 6)
{
DisplaySyntax(client);
return;
}
// Parse Arguments
int version;
int regionId;
int realmId;
int classId;
int raceId;
if (!int.TryParse(args[1], out version))
{
DisplaySyntax(client);
return;
}
if (!int.TryParse(args[2], out regionId))
{
DisplaySyntax(client);
return;
}
if (!int.TryParse(args[3], out realmId))
{
DisplaySyntax(client);
return;
}
if (!int.TryParse(args[4], out classId))
{
DisplaySyntax(client);
return;
}
if (!int.TryParse(args[5], out raceId))
{
DisplaySyntax(client);
return;
}
// Build a temp character with given params.
var chtmp = new DOLCharacters();
chtmp.AllowAdd = false;
chtmp.Region = regionId;
chtmp.Realm = realmId;
chtmp.Class = classId;
chtmp.Race = raceId;
// Test params againt database value and return results.
var locs = StartupLocations.GetAllStartupLocationForCharacter(chtmp, (GameClient.eClientVersion)version);
if (locs.Count < 1)
{
DisplayMessage(client, "No configuration for startup locations found with these constraints !");
}
else
{
foreach (StartupLocation l in locs)
{
DisplayMessage(client, string.Format("--- Loc Id:{0}, X:{1}, Y:{2}, Z:{3}, Head:{4}, Region:{5}", l.StartupLoc_ID, l.XPos, l.YPos, l.ZPos, l.Heading, l.Region));
}
}
}
/// <summary>
/// Check if a Character Needs update based to packet data
/// </summary>
/// <param name="pdata">packet data</param>
/// <param name="client">client</param>
/// <param name="character">db character</param>
/// <returns>True if character need refreshment false if no refresh needed.</returns>
private bool CheckCharacterForUpdates(CreationCharacterData pdata, GameClient client, DOLCharacters character)
{
int newModel = character.CurrentModel;
if (pdata.CustomMode == 1 || pdata.CustomMode == 2 || pdata.CustomMode == 3)
{
bool flagChangedStats = false;
if (Properties.ALLOW_CUSTOMIZE_FACE_AFTER_CREATION)
{
character.EyeSize = (byte)pdata.EyeSize;
character.LipSize = (byte)pdata.LipSize;
character.EyeColor = (byte)pdata.EyeColor;
character.HairColor = (byte)pdata.HairColor;
character.FaceType = (byte)pdata.FaceType;
character.HairStyle = (byte)pdata.HairStyle;
character.MoodType = (byte)pdata.MoodType;
}
if (pdata.CustomMode != 3 && client.Version >= GameClient.eClientVersion.Version189)
{
var stats = new Dictionary <eStat, int>();
stats[eStat.STR] = pdata.Strength; // Strength
stats[eStat.DEX] = pdata.Dexterity; // Dexterity
stats[eStat.CON] = pdata.NewConstitution; // New Constitution
stats[eStat.QUI] = pdata.Quickness; // Quickness
stats[eStat.INT] = pdata.Intelligence; // Intelligence
stats[eStat.PIE] = pdata.Piety; // Piety
stats[eStat.EMP] = pdata.Empathy; // Empathy
stats[eStat.CHR] = pdata.Charisma; // Charisma
// check for changed stats.
flagChangedStats |= stats[eStat.STR] != character.Strength;
flagChangedStats |= stats[eStat.CON] != character.Constitution;
flagChangedStats |= stats[eStat.DEX] != character.Dexterity;
flagChangedStats |= stats[eStat.QUI] != character.Quickness;
flagChangedStats |= stats[eStat.INT] != character.Intelligence;
flagChangedStats |= stats[eStat.PIE] != character.Piety;
flagChangedStats |= stats[eStat.EMP] != character.Empathy;
flagChangedStats |= stats[eStat.CHR] != character.Charisma;
if (flagChangedStats)
{
ICharacterClass charClass = ScriptMgr.FindCharacterClass(character.Class);
if (charClass != null)
{
int points;
bool valid = IsCustomPointsDistributionValid(character, stats, out points);
// Hacking attemp ?
if (points > MAX_STARTING_BONUS_POINTS)
{
if ((ePrivLevel)client.Account.PrivLevel == ePrivLevel.Player)
{
if (ServerProperties.Properties.BAN_HACKERS)
{
client.BanAccount(string.Format("Autoban Hack char update : Wrong allowed points:{0}", points));
}
client.Disconnect();
return(false);
}
}
// Error in setting points
if (!valid)
{
return(true);
}
if (Properties.ALLOW_CUSTOMIZE_STATS_AFTER_CREATION)
{
// Set Stats, valid is ok.
character.Strength = stats[eStat.STR];
character.Constitution = stats[eStat.CON];
character.Dexterity = stats[eStat.DEX];
character.Quickness = stats[eStat.QUI];
character.Intelligence = stats[eStat.INT];
character.Piety = stats[eStat.PIE];
character.Empathy = stats[eStat.EMP];
character.Charisma = stats[eStat.CHR];
if (log.IsInfoEnabled)
{
log.InfoFormat("Character {0} Stats updated in cache!", character.Name);
}
if (client.Player != null)
{
foreach (var stat in stats.Keys)
{
client.Player.ChangeBaseStat(stat, (short)(stats[stat] - client.Player.GetBaseStat(stat)));
}
if (log.IsInfoEnabled)
{
log.InfoFormat("Character {0} Player Stats updated in cache!", character.Name);
}
}
}
}
else if (log.IsErrorEnabled)
{
log.ErrorFormat("No CharacterClass with ID {0} found", character.Class);
}
}
}
if (pdata.CustomMode == 2) // change player customization
{
if (client.Account.PrivLevel == 1 && ((pdata.CreationModel >> 11) & 3) == 0)
{
if (ServerProperties.Properties.BAN_HACKERS) // Player size must be > 0 (from 1 to 3)
{
client.BanAccount(string.Format("Autoban Hack char update : zero character size in model:{0}", newModel));
client.Disconnect();
return(false);
}
return(true);
}
character.CustomisationStep = 2; // disable config button
if (Properties.ALLOW_CUSTOMIZE_FACE_AFTER_CREATION)
{
if (pdata.CreationModel != character.CreationModel)
{
character.CurrentModel = newModel;
}
if (log.IsInfoEnabled)
{
log.InfoFormat("Character {0} face properties configured by account {1}!", character.Name, client.Account.Name);
}
}
}
else if (pdata.CustomMode == 3) //auto config -- seems someone thinks this is not possible?
{
character.CustomisationStep = 3; // enable config button to player
}
//Save the character in the database
GameServer.Database.SaveObject(character);
}
return(false);
}
/// <summary>
/// Verify whether created character is valid
/// </summary>
/// <param name="ch">The character to check</param>
/// <returns>True if valid</returns>
public static bool IsCharacterValid(DOLCharacters ch)
{
bool valid = true;
try
{
if ((eRealm)ch.Realm < eRealm._FirstPlayerRealm || (eRealm)ch.Realm > eRealm._LastPlayerRealm)
{
if (log.IsWarnEnabled)
{
log.WarnFormat("Wrong realm: {0} on character creation from Account: {1}", ch.Realm, ch.AccountName);
}
valid = false;
}
if (ch.Level != 1)
{
if (log.IsWarnEnabled)
{
log.WarnFormat("Wrong level: {0} on character creation from Account: {1}", ch.Level, ch.AccountName);
}
valid = false;
}
if (!GlobalConstants.STARTING_CLASSES_DICT.ContainsKey((eRealm)ch.Realm) || !GlobalConstants.STARTING_CLASSES_DICT[(eRealm)ch.Realm].Contains((eCharacterClass)ch.Class))
{
if (log.IsWarnEnabled)
{
log.WarnFormat("Wrong class: {0}, realm:{1} on character creation from Account: {2}", ch.Class, ch.Realm, ch.AccountName);
}
valid = false;
}
if (!GlobalConstants.RACES_CLASSES_DICT.ContainsKey((eRace)ch.Race) || !GlobalConstants.RACES_CLASSES_DICT[(eRace)ch.Race].Contains((eCharacterClass)ch.Class))
{
if (log.IsWarnEnabled)
{
log.WarnFormat("Wrong race: {0}, class:{1} on character creation from Account: {2}", ch.Race, ch.Class, ch.AccountName);
}
valid = false;
}
int pointsUsed;
var stats = new Dictionary <eStat, int> {
{ eStat.STR, ch.Strength }, { eStat.CON, ch.Constitution }, { eStat.DEX, ch.Dexterity }, { eStat.QUI, ch.Quickness },
{ eStat.INT, ch.Intelligence }, { eStat.PIE, ch.Piety }, { eStat.EMP, ch.Empathy }, { eStat.CHR, ch.Charisma },
};
valid &= IsCustomPointsDistributionValid(ch, stats, out pointsUsed);
if (pointsUsed != MAX_STARTING_BONUS_POINTS)
{
if (log.IsWarnEnabled)
{
log.WarnFormat("Points used: {0} on character creation from Account: {1}", pointsUsed, ch.AccountName);
}
valid = false;
}
eGender gender = ch.Gender == 0 ? eGender.Male : eGender.Female;
if (GlobalConstants.RACE_GENDER_CONSTRAINTS_DICT.ContainsKey((eRace)ch.Race) && GlobalConstants.RACE_GENDER_CONSTRAINTS_DICT[(eRace)ch.Race] != gender)
{
if (log.IsWarnEnabled)
{
log.WarnFormat("Wrong Race gender: {0}, race: {1} on character creation from Account: {2}", ch.Gender, ch.Race, ch.AccountName);
}
valid = false;
}
if (GlobalConstants.CLASS_GENDER_CONSTRAINTS_DICT.ContainsKey((eCharacterClass)ch.Class) && GlobalConstants.CLASS_GENDER_CONSTRAINTS_DICT[(eCharacterClass)ch.Class] != gender)
{
if (log.IsWarnEnabled)
{
log.WarnFormat("Wrong class gender: {0}, class:{1} on character creation from Account: {2}", ch.Gender, ch.Class, ch.AccountName);
}
valid = false;
}
}
catch (Exception e)
{
if (log.IsErrorEnabled)
{
log.ErrorFormat("CharacterCreation error on account {0}, slot {1}. Exception:{2}", ch.AccountName, ch.AccountSlot, e);
}
valid = false;
}
return(valid);
}
public void OnCommand(GameClient client, string[] args)
{
if (args.Length < 2)
{
DisplaySyntax(client);
return;
}
switch (args[1].ToLower())
{
#region Create
case "create":
{
if (args.Length < 4)
{
DisplaySyntax(client);
return;
}
string AccountName = args[2].ToLower();
string Password = args[3];
foreach (char c in AccountName.ToCharArray())
{
if ((c < '0' || c > '9') && (c < 'a' || c > 'z'))
{
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.InvalidAccountName"));
return;
}
}
if (AccountName.Length < 4 || Password.Length < 4)
{
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.InvalidAccountNameOrPassword"));
return;
}
Account account = GetAccount(AccountName);
if (account != null)
{
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.AccountNameAlreadyRegistered"));
return;
}
account = new Account();
account.Name = AccountName;
account.Password = PacketHandler.Client.v168.LoginRequestHandler.CryptPassword(Password);
account.PrivLevel = (uint)ePrivLevel.Player;
account.Realm = (int)eRealm.None;
account.CreationDate = DateTime.Now;
account.Language = ServerProperties.Properties.SERV_LANGUAGE;
GameServer.Database.AddObject(account);
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.AccountCreated"));
}
break;
#endregion Create
#region ChangePassword
case "changepassword":
{
if (args.Length < 4)
{
DisplaySyntax(client);
return;
}
string accountname = args[2];
string newpass = args[3];
Account acc = GetAccount(accountname);
if (acc == null)
{
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.AccountNotFound", accountname));
return;
}
acc.Password = LoginRequestHandler.CryptPassword(newpass);
GameServer.Database.SaveObject(acc);
// Log change
AuditMgr.AddAuditEntry(client, AuditType.Account, AuditSubtype.AccountPasswordChange, "", (client.Player != null ? client.Player.Name : ""));
}
break;
#endregion ChangePassword
#region Delete
case "delete":
{
if (args.Length < 3)
{
DisplaySyntax(client);
return;
}
string AccountName = args[2];
Account acc = GetAccount(AccountName);
if (acc == null)
{
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.AccountNotFound", AccountName));
return;
}
KickAccount(acc);
GameServer.Database.DeleteObject(acc);
// Log change
AuditMgr.AddAuditEntry(client, AuditType.Account, AuditSubtype.AccountDelete, "acct=" + AccountName, (client.Player != null ? client.Player.Name : ""));
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.AccountDeleted", acc.Name));
return;
}
#endregion Delete
#region DeleteCharacter
case "deletecharacter":
{
if (args.Length < 3)
{
DisplaySyntax(client);
return;
}
string charname = args[2];
DOLCharacters cha = GetCharacter(charname);
if (cha == null)
{
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.CharacterNotFound", charname));
return;
}
KickCharacter(cha);
GameServer.Database.DeleteObject(cha);
// Log change
AuditMgr.AddAuditEntry(client, AuditType.Character, AuditSubtype.CharacterDelete, "char=" + charname, (client.Player != null ? client.Player.Name : ""));
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.CharacterDeleted", cha.Name));
return;
}
#endregion DeleteCharacter
#region MoveCharacter
case "movecharacter":
{
if (args.Length < 4)
{
DisplaySyntax(client);
return;
}
string charname = args[2];
string accountname = args[3];
DOLCharacters cha = GetCharacter(charname);
if (cha == null)
{
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.CharacterNotFound", charname));
return;
}
Account acc = GetAccount(accountname);
if (acc == null)
{
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.AccountNotFound", accountname));
return;
}
int firstAccountSlot = 0;
switch ((eRealm)cha.Realm)
{
case eRealm.Albion:
firstAccountSlot = 1 * 8;
break;
case eRealm.Midgard:
firstAccountSlot = 2 * 8;
break;
case eRealm.Hibernia:
firstAccountSlot = 3 * 8;
break;
default:
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.CharNotFromValidRealm"));
return;
}
int freeslot = 0;
for (freeslot = firstAccountSlot; freeslot < firstAccountSlot + 8; freeslot++)
{
bool found = false;
foreach (DOLCharacters ch in acc.Characters)
{
if (ch.Realm == cha.Realm && ch.AccountSlot == freeslot)
{
found = true;
break;
}
}
if (!found)
{
break;
}
}
if (freeslot == 0)
{
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.AccountHasNoFreeSlots", accountname));
return;
}
GameClient playingclient = WorldMgr.GetClientByPlayerName(cha.Name, true, false);
if (playingclient != null)
{
playingclient.Out.SendPlayerQuit(true);
playingclient.Disconnect();
}
cha.AccountName = acc.Name;
cha.AccountSlot = freeslot;
GameServer.Database.SaveObject(cha);
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.CharacterMovedToAccount", cha.Name, acc.Name));
return;
}
#endregion MoveCharacter
#region Status
case "status":
{
if (args.Length < 4)
{
DisplaySyntax(client);
return;
}
string accountname = args[2];
Account acc = GetAccount(accountname);
if (acc == null)
{
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.AccountNotFound", accountname));
return;
}
int status = -1;
try { status = Convert.ToInt32(args[3]); } catch (Exception) { DisplaySyntax(client); return; }
if (status >= 0 && status < 256)
{
acc.Status = status;
GameServer.Database.SaveObject(acc);
DisplayMessage(client, "Account " + acc.Name + " Status is now set to : " + acc.Status);
}
else
{
DisplaySyntax(client);
}
return;
}
#endregion Status
#region Unban
case "unban":
{
if (args.Length < 3)
{
DisplaySyntax(client);
return;
}
string accountname = args[2];
Account acc = GetAccount(accountname);
if (acc == null)
{
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.AccountNotFound", accountname));
return;
}
var banacc = GameServer.Database.SelectObjects <DBBannedAccount>("(`Type` = @TypeA OR `Type` = @TypeB) AND `Account` = @Account", new[] { new QueryParameter("@TypeA", "A"), new QueryParameter("@TypeB", "B"), new QueryParameter("@Account", accountname) });
if (banacc.Count == 0)
{
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.AccountNotFound", accountname));
return;
}
try
{
GameServer.Database.DeleteObject(banacc);
}
catch (Exception) { DisplaySyntax(client); return; }
DisplayMessage(client, "Account " + accountname + " unbanned!");
return;
}
#endregion Unban
#region AccountName
case "accountname":
{
if (args.Length < 3)
{
DisplaySyntax(client);
return;
}
string CharName = args[2];
DOLCharacters Char = GetCharacter(CharName);
if (Char == null)
{
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.CharacterNotFound", CharName));
return;
}
string AccName = GetAccountName(Char.Name);
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.AccNameForChar", Char.Name, AccName));
return;
}
#endregion AccountName
}
}
