public override void Open()
{
base.Open();
ContextRoleplayHandler.SendNpcDialogQuestionMessage(Character.Client, CurrentMessage, CurrentMessage == NpcBank.Message ?
new[] { NpcBank.ReplyInfos, NpcBank.ReplyConsult } : new[] { NpcBank.ReplyInfos }, Character.Bank.GetAccessPrice().ToString());
}
public override void Execute(TriggerBase trigger)
{
var target = GetTarget(trigger);
var template = trigger.Get <SpellTemplate>("spell");
var level = trigger.Get <int>("level");
var spell = target.Spells.GetSpell(template.Id);
if (spell == null)
{
trigger.ReplyError("Spell {0} not found", trigger.Bold(spell));
return;
}
if (!spell.ByLevel.ContainsKey(level))
{
trigger.ReplyError("Level {0} not found. Give a level between {1} and {2}", trigger.Bold(level),
trigger.Bold(spell.ByLevel.Keys.Min()), trigger.Bold(spell.ByLevel.Keys.Max()));
return;
}
spell.CurrentLevel = (byte)level;
trigger.ReplyBold("{0}'s spell {1} is now level {2}", target, spell.Template.Name, level);
ContextRoleplayHandler.SendSpellModifySuccessMessage(target.Client, spell);
}
private void OnReady(Trader trader, bool isready)
{
InventoryHandler.SendExchangeIsReadyMessage(Crafter.Character.Client,
trader, isready);
InventoryHandler.SendExchangeIsReadyMessage(Receiver.Character.Client,
trader, isready);
if (Receiver.Kamas > Receiver.Character.Inventory.Kamas)
{
InventoryHandler.SendExchangeCraftResultMessage(Clients, ExchangeCraftResultEnum.CRAFT_FAILED);
FirstTrader.ToggleReady(false);
SecondTrader.ToggleReady(false);
return;
}
if (Crafter.ReadyToApply && Receiver.ReadyToApply)
{
Craft();
Crafter.Character.Inventory.AddKamas(-Receiver.Character.Inventory.SubKamas((int)Receiver.Kamas));
Receiver.SetKamas(0);
ContextRoleplayHandler.SendJobExperienceOtherPlayerUpdateMessage(Receiver.Character.Client, Crafter.Character, Job);
FirstTrader.ToggleReady(false);
SecondTrader.ToggleReady(false);
}
}
public override void Reply(short replyId)
{
if (replyId == NpcBank.ReplyConsult)
{
var accessPrice = Character.Bank.GetAccessPrice();
if (Character.Kamas < accessPrice)
{
Character.SendInformationMessage(TextInformationTypeEnum.TEXT_INFORMATION_ERROR, 82);
}
else
{
Character.Inventory.SubKamas(accessPrice);
var dialog = new BankDialog(Character);
dialog.Open();
}
Close();
}
else if (replyId == NpcBank.ReplyInfos)
{
CurrentMessage = NpcBank.InfosMessage;
ContextRoleplayHandler.SendNpcDialogQuestionMessage(Character.Client, CurrentMessage, new short[0]);
}
else
{
Close();
}
}
public int DowngradeSpell(CharacterSpell spell, bool send = true)
{
if (!HasSpell(spell.Id))
{
return(0);
}
if (spell.CurrentLevel <= 1)
{
return(0);
}
spell.CurrentLevel -= 1;
Owner.SpellsPoints += spell.CurrentLevel;
if (!send)
{
return(spell.CurrentLevel);
}
InventoryHandler.SendSpellListMessage(Owner.Client, true);
ContextRoleplayHandler.SendSpellModifySuccessMessage(Owner.Client, spell);
Owner.RefreshStats();
return(spell.CurrentLevel);
}
public static void SelectCharacter(Client client, int id)
{
CharacterRecord characterRecord = client.Account.Characters.FirstOrDefault(character => character.Id == id);
if (characterRecord != null)
{
CharacterEngine character = new CharacterEngine(characterRecord, client);
client.Character = character;
client.Send(new CharacterSelectedSuccessMessage(character.GetCharacterBaseInformations));
ContextRoleplayHandler.SendEmoteListMessage(client, new sbyte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 19, 21, 22, 23, 24 });
ChatHandler.SendEnabledChannelsMessage(client, new sbyte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 });
InventoryHandler.SendInventoryContentMessage(client, new ObjectItem[0], character.Kamas); //TODO Get the characters items
InventoryHandler.SendInventoryWeightMessage(client, 0, character.MaxPods);
InventoryHandler.SendSpellListMessage(client);
PvPHandler.SendAlignmentRankUpdateMessage(client, 1);
PvPHandler.SendAlignmentSubAreasListMessage(client);
SendSetCharacterRestrictionsMessage(client);
SendLifePointsRegenBeginMessage(client, 10);
SendCharacterStatsListMessage(client);
client.Character.SendLoginMessage();
/*if (tutorial == true)
* {
* character.CurrentMapId = 35651584; //mapid of the tutorial map
* character.CellId = 324;
* client.Send(new QuestStartedMessage(489)); //start the tutorial quest
* }*/
}
else
{
client.Send(new CharacterSelectedErrorMessage());
}
}
protected override void OnAccept()
{
ContextRoleplayHandler.SendGameRolePlayPlayerFightFriendlyAnsweredMessage(base.Source.Client, base.Target, base.Source, base.Target, true);
Fight fight = Singleton <FightManager> .Instance.CreateDuel(base.Source.Map);
fight.BlueTeam.AddFighter(base.Source.CreateFighter(fight.BlueTeam));
fight.RedTeam.AddFighter(base.Target.CreateFighter(fight.RedTeam));
fight.StartPlacement();
}
public override void Open()
{
base.Open();
ContextRoleplayHandler.SendNpcDialogQuestionMessage(Character.Client, CurrentMessage,
Character.Level >= 200
? new[] { PrestigeNpc.ReplyPrestigeAcceptId, PrestigeNpc.ReplyPrestigeDenyId }
: new short[0]);
}
public virtual void ChangeMessage(NpcMessage message)
{
this.CurrentMessage = message;
System.Collections.Generic.IEnumerable <short> replies = (
from entry in message.Replies
where entry.CriteriaExpression == null || entry.CriteriaExpression.Eval(this.Character)
select(short) entry.ReplyId).Distinct <short>();
ContextRoleplayHandler.SendNpcDialogQuestionMessage(this.Character.Client, this.CurrentMessage, replies, new string[0]);
}
private void OnLevelChanged(int lastLevel, int newLevel)
{
ContextRoleplayHandler.SendJobLevelUpMessage(Owner.Client, this);
var sumLevel = Owner.Jobs.Sum(x => x.Level);
var diff = newLevel - lastLevel;
var weightBonus = JobManager.Instance.GetWeightBonus(sumLevel - diff, sumLevel);
Owner.Stats[PlayerFields.Weight].Base += weightBonus;
}
public virtual void ChangeMessage(NpcMessage message)
{
CurrentMessage = message;
var replies = message.Replies.
Where(entry => entry.CanShow(Npc, Character)).
Select(entry => (short)entry.ReplyId).Distinct();
ContextRoleplayHandler.SendNpcDialogQuestionMessage(Character.Client, CurrentMessage, replies);
}
public CharacterSpell LearnSpell(SpellTemplate template)
{
var record = SpellManager.Instance.CreateSpellRecord(Owner.Record, template);
var spell = new CharacterSpell(record);
m_spells.Add(spell.Id, spell);
ContextRoleplayHandler.SendSpellModifySuccessMessage(Owner.Client, spell);
return(spell);
}
public override void Open()
{
base.Open();
ContextRoleplayHandler.SendNpcDialogQuestionMessage(Character.Client, CurrentMessage,
Character.AlignmentSide !=
AlignmentSideEnum.ALIGNMENT_NEUTRAL
? new[] { NpcAlignement.ReplyBecomeNeutre }
: new[]
{
NpcAlignement.ReplyBecomeAngel,
NpcAlignement.ReplyBecomeEvil
});
}
private void OnReady(Trader trader, bool isready)
{
InventoryHandler.SendExchangeIsReadyMessage(Crafter.Character.Client,
trader, isready);
InventoryHandler.SendExchangeIsReadyMessage(Receiver.Character.Client,
trader, isready);
if (Receiver.Kamas > Receiver.Character.Inventory.Kamas)
{
InventoryHandler.SendExchangeCraftResultMessage(Clients, ExchangeCraftResultEnum.CRAFT_FAILED);
return;
}
if (Crafter.ReadyToApply && Receiver.ReadyToApply)
{
ApplyAllRunes();
if (Receiver.Kamas > 0)
{
Crafter.Character.Inventory.AddKamas(-Receiver.Character.Inventory.SubKamas((int)Receiver.Kamas));
Receiver.SetKamas(0);
}
ContextRoleplayHandler.SendJobExperienceOtherPlayerUpdateMessage(Receiver.Character.Client, Crafter.Character, Job);
}
else if (trader == Receiver && !isready) // stop the trade
{
foreach (var item in Crafter.Items.OfType <PlayerTradeItem>().ToArray())
{
if (Crafter.Character == item.Owner)
{
Crafter.MoveItemToInventory(item, 0);
}
else if (item.Owner == Receiver.Character)
{
RuneCrafter.MoveItemFromBag(item.PlayerItem, Receiver, 0);
}
}
/*
* if (Rune != null && Rune.Trader == Receiver)
* Rune.Trader.MoveItem(Rune.Guid, (int) -Rune.Stack);
*
* var itemToImprove = ItemToImprove;
* Crafter.MoveItem(itemToImprove.Guid, (int) -itemToImprove.Stack);
* Receiver.MoveItem(itemToImprove.Guid, (int) itemToImprove.Stack);*/
}
}
public void Enter(WorldObject obj)
{
foreach (SimpleClient client in Clients)
{
ContextRoleplayHandler.SendSnapshotMessage(client, new Snapshot[] { new AddObjectSnapshot(obj.GetObjectType()) });
}
if (obj is Character)
{
Clients.Add((obj as Character).Client);
}
Objects.Add(obj);
obj.Position.Map = this;
}
public static void HandleGameRolePlayPlayerFightRequestMessage(WorldClient client, GameRolePlayPlayerFightRequestMessage message)
{
var target = client.Character.Map.GetActor <Character>((int)message.targetId);
if (target == null)
{
return;
}
if (message.friendly)
{
var reason = client.Character.CanRequestFight(target);
if (reason != FighterRefusedReasonEnum.FIGHTER_ACCEPTED)
{
SendChallengeFightJoinRefusedMessage(client, client.Character, reason);
}
else
{
var fightRequest = new FightRequest(client.Character, target);
fightRequest.Open();
}
}
else // agression
{
var reason = client.Character.CanAgress(target);
if (reason != FighterRefusedReasonEnum.FIGHTER_ACCEPTED)
{
SendChallengeFightJoinRefusedMessage(client, client.Character, reason);
}
else
{
foreach (var character in target.Map.GetAllCharacters().Where(x => x != target && x != client.Character))
{
ContextRoleplayHandler.SendGameRolePlayAggressionMessage(character.Client, client.Character, target);
}
//<b>%1</b> agresse <b>%2</b>
var fight = FightManager.Instance.CreateAgressionFight(target.Map,
client.Character.AlignmentSide, target.AlignmentSide);
fight.ChallengersTeam.AddFighter(client.Character.CreateFighter(fight.ChallengersTeam));
fight.DefendersTeam.AddFighter(target.CreateFighter(fight.DefendersTeam));
fight.StartPlacement();
}
}
}
protected override void OnAccept()
{
if (Source.Map != Target.Map)
{
ContextRoleplayHandler.SendGameRolePlayPlayerFightFriendlyAnsweredMessage(Source.Client, Target, Source, Target, false);
return;
}
ContextRoleplayHandler.SendGameRolePlayPlayerFightFriendlyAnsweredMessage(Source.Client, Target, Source, Target, true);
var fight = FightManager.Instance.CreateDuel(Source.Map);
fight.DefendersTeam.AddFighter(Source.CreateFighter(fight.DefendersTeam));
fight.ChallengersTeam.AddFighter(Target.CreateFighter(fight.ChallengersTeam));
fight.StartPlacement();
}
public static void HandleGameFightSpectatePlayerRequestMessage(WorldClient client, GameFightSpectatePlayerRequestMessage message)
{
if (client.Character.IsFighting())
{
return;
}
var player = World.Instance.GetCharacter((int)message.playerId);
if (player == null)
{
return;
}
if (!client.Character.FriendsBook.IsFriend(player.Account.Id) && !client.Character.Guild.Members.Any(x => x.Character?.Id == player.Id))
{
return;
}
if (!player.IsFighting())
{
SendChallengeFightJoinRefusedMessage(client, client.Character, FighterRefusedReasonEnum.TOO_LATE);
return;
}
var fight = FightManager.Instance.GetFight(player.Fight.Id);
if (fight == null)
{
SendChallengeFightJoinRefusedMessage(client, client.Character, FighterRefusedReasonEnum.TOO_LATE);
return;
}
if (!fight.IsStarted)
{
return;
}
if (!fight.CanSpectatorJoin(client.Character) || client.Character.IsInFight())
{
return;
}
ContextRoleplayHandler.SendCurrentMapMessage(client, fight.Map.Id);
fight.AddSpectator(client.Character.CreateSpectator(fight));
}
public void Open()
{
InventoryHandler.SendExchangeStartOkMulticraftCrafterMessage(Crafter.Character.Client, Skill.SkillTemplate);
InventoryHandler.SendExchangeStartOkMulticraftCustomerMessage(Receiver.Character.Client, Skill.SkillTemplate, Job);
ContextRoleplayHandler.SendJobExperienceOtherPlayerUpdateMessage(Receiver.Character.Client, Crafter.Character, Job);
Crafter.Character.SetDialoger(Crafter);
Receiver.Character.SetDialoger(Receiver);
Crafter.ItemMoved += OnItemMoved;
Receiver.ItemMoved += OnItemMoved;
Crafter.ReadyStatusChanged += OnReady;
Receiver.ReadyStatusChanged += OnReady;
Receiver.KamasChanged += OnKamasChanged;
}
public bool CanBoostSpell(Spell spell, ushort level, bool send = true)
{
if (Owner.IsFighting())
{
if (send)
{
ContextRoleplayHandler.SendSpellModifyFailureMessage(Owner.Client);
}
return(false);
}
if (spell.CurrentLevel == level || level > 6)
{
if (send)
{
ContextRoleplayHandler.SendSpellModifyFailureMessage(Owner.Client);
}
return(false);
}
if (Owner.SpellsPoints < CalculateSpellPoints(level, spell.CurrentLevel))
{
if (send)
{
ContextRoleplayHandler.SendSpellModifyFailureMessage(Owner.Client);
}
return(false);
}
if (spell.ByLevel[level].MinPlayerLevel > Owner.Level)
{
if (send)
{
ContextRoleplayHandler.SendSpellModifyFailureMessage(Owner.Client);
}
return(false);
}
return(true);
}
public static void CommonCharacterBasicInformations(WorldClient client)
{
CharacterHandler.SendCharacterSelectedSuccessMessage(client);
ContextHandler.SendNotificationListMessage(client, new int[] { 2147483647 });
InventoryHandler.SendInventoryContentMessage(client);
ShortcutHandler.SendShortcutBarContentMessage(client, ShortcutBarEnum.GENERAL_SHORTCUT_BAR);
ShortcutHandler.SendShortcutBarContentMessage(client, ShortcutBarEnum.SPELL_SHORTCUT_BAR);
ContextRoleplayHandler.SendEmoteListMessage(client, (
from entry in Enumerable.Range(0, 21)
select(byte) entry).ToList <byte>());
PvPHandler.SendAlignmentRankUpdateMessage(client);
if (client.Character.Guild != null)
{
GuildHandler.SendGuildMembershipMessage(client, client.Character.GuildMember);
GuildHandler.SendGuildInformationsGeneralMessage(client, client.Character.Guild);
GuildHandler.SendGuildInformationsMembersMessage(client, client.Character.Guild);
if (client.Character.Guild.Alliance != null)
{
AllianceHandler.SendAllianceMembershipMessage(client, client.Character.Guild.Alliance);
AllianceHandler.SendAllianceInsiderInfoMessage(client, client.Character.Guild.Alliance);
}
}
ChatHandler.SendEnabledChannelsMessage(client, new sbyte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13 }, new sbyte[0]);
InventoryHandler.SendSpellListMessage(client, true);
InitializationHandler.SendSetCharacterRestrictionsMessage(client);
InventoryHandler.SendInventoryWeightMessage(client);
FriendHandler.SendFriendWarnOnConnectionStateMessage(client, client.Character.FriendsBook.WarnOnConnection);
FriendHandler.SendFriendWarnOnLevelGainStateMessage(client, client.Character.FriendsBook.WarnOnLevel);
GuildHandler.SendGuildMemberWarnOnConnectionStateMessage(client, client.Character.WarnOnGuildConnection);
AchievementHandler.SendAchievementListMessage(client, client.Character.Record.FinishedAchievements, client.Character.Achievement.GetRewardableAchievements());
client.Character.SendConnectionMessages();
ContextRoleplayHandler.SendGameRolePlayArenaUpdatePlayerInfosMessage(client);
CharacterHandler.SendCharacterCapabilitiesMessage(client);
client.WorldAccount.LastConnection = new System.DateTime?(System.DateTime.Now);
client.WorldAccount.LastIp = client.IP;
client.WorldAccount.ConnectedCharacter = new int?(client.Character.Id);
client.Character.Record.LastUsage = new System.DateTime?(System.DateTime.Now);
ServerBase <WorldServer> .Instance.DBAccessor.Database.Update(client.WorldAccount);
ServerBase <WorldServer> .Instance.DBAccessor.Database.Update(client.Character.Record);
}
public void Leave(WorldObject obj)
{
if (!Objects.Contains(obj))
{
return;
}
if (obj is Character)
{
Clients.Remove((obj as Character).Client);
}
Objects.Remove(obj);
foreach (SimpleClient client in Clients)
{
ContextRoleplayHandler.SendSnapshotMessage(client, new Snapshot[] { new RemoveObjectSnapshot((uint)obj.GetHashCode()) });
}
}
public override void ExecuteRemove(TriggerBase trigger)
{
var gameTrigger = trigger as GameTrigger;
var character = gameTrigger != null ? gameTrigger.Character : null;
if (character == null)
{
return;
}
var elementId = trigger.Get <int>("elementId");
var mapSrc = character.Map;
var interactive = InteractiveManager.Instance.GetOneSpawn(x => x.MapId == mapSrc.Id && x.Id == elementId);
WorldServer.Instance.IOTaskPool.AddMessage(() =>
{
InteractiveManager.Instance.RemoveInteractiveSpawn(interactive);
ContextRoleplayHandler.SendMapComplementaryInformationsDataMessage(character.Client);
});
trigger.ReplyBold("Delete Interactive {0} on map {1}", elementId, mapSrc.Id);
}
public bool BoostSpell(int id, ushort level)
{
var spell = GetSpell(id);
if (spell == null)
{
ContextRoleplayHandler.SendSpellModifyFailureMessage(Owner.Client);
return(false);
}
if (!CanBoostSpell(spell, level))
{
return(false);
}
Owner.SpellsPoints -= (ushort)CalculateSpellPoints(level, spell.CurrentLevel);
spell.CurrentLevel = (byte)level;
ContextRoleplayHandler.SendSpellModifySuccessMessage(Owner.Client, spell);
return(true);
}
public virtual void Open()
{
Character.SetDialog(this);
ContextRoleplayHandler.SendNpcDialogCreationMessage(Character.Client, Npc);
}
public static void HandleGameFightJoinRequestMessage(WorldClient client, GameFightJoinRequestMessage message)
{
if (client.Character.IsFighting())
{
return;
}
var fight = FightManager.Instance.GetFight(message.fightId);
if (fight == null)
{
SendChallengeFightJoinRefusedMessage(client, client.Character, FighterRefusedReasonEnum.TOO_LATE);
return;
}
if (client.Character.Map.Id != ArenaManager.KolizeumMapId && fight.Map != client.Character.Map)
{
SendChallengeFightJoinRefusedMessage(client, client.Character, FighterRefusedReasonEnum.WRONG_MAP);
return;
}
if (message.fighterId == 0 && fight.CanSpectatorJoin(client.Character) && !client.Character.IsInFight())
{
if (client.Character.Map.Id == ArenaManager.KolizeumMapId)
{
ContextRoleplayHandler.SendCurrentMapMessage(client, fight.Map.Id);
}
fight.AddSpectator(client.Character.CreateSpectator(fight));
}
if (fight.IsStarted)
{
return;
}
FightTeam team;
if (fight.ChallengersTeam.Leader.Id == message.fighterId)
{
team = fight.ChallengersTeam;
}
else if (fight.DefendersTeam.Leader.Id == message.fighterId)
{
team = fight.DefendersTeam;
}
else
{
SendChallengeFightJoinRefusedMessage(client, client.Character, FighterRefusedReasonEnum.WRONG_MAP);
return;
}
FighterRefusedReasonEnum error;
if ((error = team.CanJoin(client.Character)) != FighterRefusedReasonEnum.FIGHTER_ACCEPTED)
{
SendChallengeFightJoinRefusedMessage(client, client.Character, error);
}
else
{
team.AddFighter(client.Character.CreateFighter(team));
}
}
public static void CommonCharacterSelection(WorldClient client, CharacterRecord character)
{
if (character.IsDeleted)
{
return;
}
// Check if we also have a world account
if (client.WorldAccount == null)
{
var account = AccountManager.Instance.FindById(client.Account.Id) ??
AccountManager.Instance.CreateWorldAccount(client);
client.WorldAccount = account;
}
// update tokens
if (client.WorldAccount.Tokens + client.WorldAccount.NewTokens <= 0)
{
client.WorldAccount.Tokens = 0;
}
else
{
client.WorldAccount.Tokens += client.WorldAccount.NewTokens;
}
client.WorldAccount.NewTokens = 0;
client.Character = new Character(character, client);
client.Character.LoadRecord();
ContextHandler.SendNotificationListMessage(client, new[] { 0x7FFFFFFF });
BasicHandler.SendBasicTimeMessage(client);
SendCharacterSelectedSuccessMessage(client);
if (client.Character.Inventory.Presets.Any())
{
InventoryHandler.SendInventoryContentAndPresetMessage(client);
}
else
{
InventoryHandler.SendInventoryContentMessage(client);
}
ShortcutHandler.SendShortcutBarContentMessage(client, ShortcutBarEnum.GENERAL_SHORTCUT_BAR);
ContextRoleplayHandler.SendEmoteListMessage(client, client.Character.Emotes.Select(x => (byte)x));
// Jobs
ContextRoleplayHandler.SendJobDescriptionMessage(client, client.Character);
ContextRoleplayHandler.SendJobExperienceMultiUpdateMessage(client, client.Character);
ContextRoleplayHandler.SendJobCrafterDirectorySettingsMessage(client, client.Character);
PvPHandler.SendAlignmentRankUpdateMessage(client, client.Character);
ChatHandler.SendEnabledChannelsMessage(client, new sbyte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13 }, new sbyte[] { });
ChatHandler.SendChatSmileyExtraPackListMessage(client, client.Character.SmileyPacks.ToArray());
InventoryHandler.SendSpellListMessage(client, true);
ShortcutHandler.SendShortcutBarContentMessage(client, ShortcutBarEnum.SPELL_SHORTCUT_BAR);
InitializationHandler.SendSetCharacterRestrictionsMessage(client, client.Character);
InventoryHandler.SendInventoryWeightMessage(client);
FriendHandler.SendFriendWarnOnConnectionStateMessage(client, client.Character.FriendsBook.WarnOnConnection);
FriendHandler.SendFriendWarnOnLevelGainStateMessage(client, client.Character.FriendsBook.WarnOnLevel);
GuildHandler.SendGuildMemberWarnOnConnectionStateMessage(client, client.Character.WarnOnGuildConnection);
//Guild
if (client.Character.GuildMember != null)
{
GuildHandler.SendGuildMembershipMessage(client, client.Character.GuildMember);
}
//Mount
if (client.Character.EquippedMount != null)
{
MountHandler.SendMountSetMessage(client, client.Character.EquippedMount.GetMountClientData());
MountHandler.SendMountXpRatioMessage(client, client.Character.EquippedMount.GivenExperience);
if (client.Character.IsRiding)
{
MountHandler.SendMountRidingMessage(client, client.Character.IsRiding);
}
}
client.Character.SendConnectionMessages();
//Don't know why ?
ActionsHandler.SendSequenceNumberRequestMessage(client);
//Start Cinematic
if ((DateTime.Now - client.Character.Record.CreationDate).TotalSeconds <= 30)
{
BasicHandler.SendCinematicMessage(client, 10);
}
ContextRoleplayHandler.SendGameRolePlayArenaUpdatePlayerInfosMessage(client, client.Character);
SendCharacterCapabilitiesMessage(client);
ContextRoleplayHandler.SendAlmanachCalendarDateMessage(client);
//Loading complete
SendCharacterLoadingCompleteMessage(client);
BasicHandler.SendServerExperienceModificatorMessage(client);
// Update LastConnection and Last Ip
client.WorldAccount.LastConnection = DateTime.Now;
client.WorldAccount.LastIp = client.IP;
client.WorldAccount.ConnectedCharacter = character.Id;
WorldServer.Instance.DBAccessor.Database.Execute(string.Format(WorldAccountRelator.UpdateNewTokens, 0));
WorldServer.Instance.DBAccessor.Database.Update(client.WorldAccount);
}
public override void Open()
{
base.Open();
ContextRoleplayHandler.SendNpcDialogQuestionMessage(Character.Client, CurrentMessage, new[] { (short)NpcDofus.ReplyId });
}
protected override void OnOpen()
{
ContextRoleplayHandler.SendGameRolePlayPlayerFightFriendlyRequestedMessage(Source.Client, Target, Source, Target);
ContextRoleplayHandler.SendGameRolePlayPlayerFightFriendlyRequestedMessage(Target.Client, Source, Source, Target);
}
protected override void OnCancel()
{
ContextRoleplayHandler.
SendGameRolePlayPlayerFightFriendlyAnsweredMessage(Target.Client, Source, Source, Target, false);
}
