public static void GameMapMovementMessageTreatment(Message message, byte[] packetDatas, AccountUC account)
{
GameMapMovementMessage msg = (GameMapMovementMessage)message;
using (BigEndianReader reader = new BigEndianReader(packetDatas))
{
msg.Deserialize(reader);
}
List <uint> keys = new List <uint>();
foreach (short s in msg.keyMovements)
{
keys.Add((uint)s);
}
MovementPath clientMovement = MapMovementAdapter.GetClientMovement(keys);
BlueSheep.Core.Fight.Entity entity = null;
foreach (BlueSheep.Core.Fight.Entity en in account.Map.Entities)
{
if (en.Id == msg.actorId)
{
entity = en;
}
}
if (entity != null)
{
(account.Map.Entities[account.Map.Entities.IndexOf(entity)]).CellId = clientMovement.CellEnd.CellId;
}
//GameRolePlayGroupMonsterInformations e = null;
foreach (MonsterGroup en in account.Map.List)
{
if (en.m_contextualId == msg.actorId)
{
en.m_cellId = clientMovement.CellEnd.CellId;
}
}
//if (e != null)
//{
// account.Map.List.RemoveAt(i);
// account.Map.List.Add(new GameRolePlayGroupMonsterInformations(msg.actorId, e.look, new EntityDispositionInformations((short)clientMovement.CellEnd.CellId, e.disposition.direction), e.keyRingBonus, e.hasHardcoreDrop, e.hasAVARewardToken, e.staticInfos, e.ageBonus, e.lootShare, e.alignmentSide));
//}
//if (msg.actorId == account.Map.Character.Id)
//{
// account.Wait(100, 200);
// using (BigEndianWriter writer = new BigEndianWriter())
// {
// GameMapMovementConfirmMessage newmsg = new GameMapMovementConfirmMessage();
// newmsg.Serialize(writer);
// MessagePackaging pack = new MessagePackaging(writer);
// pack.Pack((int)newmsg.ProtocolID);
// account.SocketManager.Send(pack.Writer.Content);
// }
//}
// if (account.Fight.flag != 0)
// {
// account.Fight.LaunchFight(account.Fight.flag);
// }
//}
}
private void Map_MapMovement(GameMapMovementMessage message)
{
if (message.ActorId != _account.Character.Id || message.KeyMovements[0] != _path.CellStart.CellId)
{
return;
}
_account.Character.Map.MapMovement -= Map_MapMovement;
_account.Character.Status = CharacterStatus.Moving;
MovementVelocity.MovementTypeEnum type;
if (_path.Cells.Count >= 4) // Need check pods
{
type = MovementVelocity.MovementTypeEnum.WALKING;
}
else
{
type = MovementVelocity.MovementTypeEnum.RUNNING;
}
var time = MovementVelocity.GetPathVelocity(_path, type);
_account.PerformAction(() =>
{
_account.Network.SendToServer(new GameMapMovementConfirmMessage());
OnMovementFinished(true);
}, (int)time);
}
private void HandleGameMapMovementMessage(IAccount account, GameMapMovementMessage message)
{
// The player has moved.
Console.WriteLine($"GameMapMovementMessage[{message.ActorId}]CharacterId[{account.Character.Id}]");
lock (CheckLock)
{
var clientMovement = MapMovementAdapter.GetClientMovement(message.KeyMovements.Select(s => (uint)s).ToList());
if (message.ActorId == account.Character.Id)
{
account.Character.CellId = clientMovement.CellEnd.CellId;
}
else if (Players.Find(x => x.Id == message.ActorId) != null)
{
Players.Find(x => x.Id == message.ActorId).CellId = clientMovement.CellEnd.CellId;
}
else if (Entities.Find(x => x.Id == message.ActorId) != null)
{
Entities.Find(x => x.Id == message.ActorId).CellId = clientMovement.CellEnd.CellId;
}
else if (Monsters.Find(x => x.Id == message.ActorId) != null)
{
Monsters.Find(x => x.Id == message.ActorId).CellId = clientMovement.CellEnd.CellId;
}
//else
//Logger.Default.Log($"ActorId[{message.ActorId}] not found");
//Monsters.Add(new MonsterGroup(new GroupMonsterStaticInformations(), message.ActorId, clientMovement.CellEnd.CellId));
}
UpdateMapControl();
OnMapMovement(message);
}
private void HandleGameMapMovementMessage(IAccount account, GameMapMovementMessage message)
{
lock (CheckLock)
{
var clientMovement =
MapMovementAdapter.GetClientMovement(message.KeyMovements.Select(s => (uint)s).ToList());
if (Players.Find(x => x.Id == message.ActorId) != null)
{
Players.Find(x => x.Id == message.ActorId).CellId = clientMovement.CellEnd.CellId;
}
if (Entities.Find(x => x.Id == message.ActorId) != null)
{
Entities.Find(x => x.Id == message.ActorId).CellId = clientMovement.CellEnd.CellId;
}
if (Monsters.Find(x => x.Id == message.ActorId) != null)
{
Monsters.Find(x => x.Id == message.ActorId).CellId = clientMovement.CellEnd.CellId;
}
if (message.ActorId == account.Character.Id)
{
account.Character.CellId = clientMovement.CellEnd.CellId;
}
}
UpdateMapControl();
OnMapMovement(message);
}
private void Map_MapMovement(GameMapMovementMessage message)
{
if (message.ActorId != _account.Character.Id)
{
return; // packet doesn't match the move requested.
}
Console.WriteLine($"Receiving[GameMapMovementMessage] Destination {message.KeyMovements[message.KeyMovements.Count-1]}");
_account.Character.Map.MapMovement -= Map_MapMovement;
if (_account.Character.Status != CharacterStatus.Fighting)
{
_account.PerformAction(() =>
{
_account.Network.SendToServer(new GameMapMovementConfirmMessage());
OnMovementFinished(true);
},
(int)MovementVelocity.GetPathVelocity(_path,
_path.Cells.Count >= 4
? MovementVelocity.MovementTypeEnum.WALKING
: MovementVelocity.MovementTypeEnum.RUNNING));
}
else
{
OnMovementFinished(true);
}
}
private void HandleMapComplementaryInformationsDataMessage(GameMapMovementMessage message, ConnectedHost source)
{
if (fight != null)
{
fight.Update(message);
}
}
private void HandleMapComplementaryInformationsDataMessage(GameMapMovementMessage message, ConnectedHost source)
{
if (message.actorId == this.Id)
{
CellId = message.keyMovements.Last();
}
OnUpdated();
}
private void GameMapMovementMessageHandler(DofusClient Client, GameMapMovementMessage Message)
{
if (Message.ActorId == Client.Account.Character.Id)
{
Client.Account.Character.Status = Utils.Enums.CharacterStatus.Moving;
Client.Account.Character.CellId = Message.KeyMovements.Last();
}
}
private void GameMapMovementMessageHandler(DofusClient client, GameMapMovementMessage message)
{
if (message.ActorId == client.Account.Character.Id)
{
client.Account.Character.Status = CharacterStatus.Moving;
client.Account.Character.CellId = message.KeyMovements.Last();
}
client.Account.Character.MapData.RefreshActor(message.ActorId, message.KeyMovements.Last());
}
public static Task HandleGameMapMovementMessage(Account account, GameMapMovementMessage message)
=> Task.Run(() =>
{
if (account.State == Enums.AccountStates.FIGHTING)
{
account.Game.Fight.Update(message);
account.Extensions.CharacterCreation.Update(message);
}
});
public static Task HandleGameMapMovementMessage(Account account, GameMapMovementMessage message)
=> Task.Run(() =>
{
if (account.State == AccountStates.FIGHTING)
{
return;
}
account.Game.Map.Update(message);
account.Game.Managers.Movements.Update(message);
account.Extensions.CharacterCreation.Update(message);
});
public void HandleGameMapMovementMessage(Bot bot, GameMapMovementMessage message)
{
if (message.actorId == PartyLeaderId && Character.Id != message.actorId)
{
//foreach (FFight ffight in GetOtherFFights().Where(plug => Party != null && Party.Any(member => member.id == plug.Character.Id)))
if (message.keyMovements.Length > 0)
{
LastLeaderCell = message.keyMovements.Last();
Character.SendInformation("Follow leader in {0}s : {1} => 1 cell from {2}", (500.0m * Id) / 1000.0m, Character.Cell, Character.Map.Cells[message.keyMovements.Last()]);
Character.MoveIfNeededThenAction(message.keyMovements.Last(), null, 500 * Id, 1, true);
}
}
}
private void HandleGameMapMovementMessage(IAccount account, GameMapMovementMessage message)
{
if (Account.Character.Status != CharacterStatus.Fighting)
{
return;
}
var clientMovement = MapMovementAdapter.GetClientMovement(message.KeyMovements.Select(k => (uint)k).ToList());
var fighter = (Fighter)GetFighter(message.ActorId);
if (fighter != null)
{
fighter.CellId = clientMovement.CellEnd.CellId;
}
}
public static void HandleGameMapMovementMessage(Bot bot, GameMapMovementMessage message)
{
if (bot.Character == null || bot.Character.Context == null)
{
logger.Error("Context is null as processing movement");
return;
}
ContextActor actor = null;
bool fightActor = false;
if (bot.Character.IsFighting())
{
actor = bot.Character.Fight.GetActor(message.actorId);
}
if (actor == null)
{
actor = bot.Character.Context.GetActor(message.actorId);
}
else
{
fightActor = true;
}
if (actor == null)
{
logger.Error("Actor {0} not found (known : {1})", message.actorId, String.Join(",", fightActor ? bot.Character.Fight.Actors : bot.Character.Context.Actors)); // only a log for the moment until context are fully handled
return;
}
// just to update the position. If in fight, better update immediately to be sure that the next action take the mouvement into account
if (message.keyMovements.Length == 1)
{
actor.UpdatePosition(message.keyMovements[0]);
}
else
{
Path path = Path.BuildFromServerCompressedPath(bot.Character.Map, message.keyMovements);
if (path.IsEmpty())
{
logger.Warn("Try to start moving with an empty path");
return;
}
var movement = new MovementBehavior(path, actor.GetAdaptedVelocity(path));
movement.Start(DateTime.Now + TimeSpan.FromMilliseconds(EstimatedMovementLag));
actor.NotifyStartMoving(movement);
}
}
public void Update(GameMapMovementMessage message)
{
if (!IsDoingTutorial || message.ActorId != _account.Game.Character.Id)
{
return;
}
if (_currentStepNumber != 1 && _currentStepNumber != 7)
{
return;
}
ValidateCurrentStep();
}
public static void GameMapMovementMessageTreatment(Message message, byte[] packetDatas, AccountUC account)
{
GameMapMovementMessage msg = (GameMapMovementMessage)message;
using (BigEndianReader reader = new BigEndianReader(packetDatas))
{
msg.Deserialize(reader);
}
MovementPath clientMovement = MapMovementAdapter.GetClientMovement(msg.keyMovements.Select <short, uint>(k => (uint)k).ToList());
if (account.state == Enums.Status.Fighting)
{
account.FightData.UpdateFighterCell(msg.actorId, clientMovement.CellEnd.CellId);
}
}
private void HandleGameMapMovementMessage(IAccount account, GameMapMovementMessage message)
{
lock (CheckLock)
{
var clientMovement =
MapMovementAdapter.GetClientMovement(message.KeyMovements.Select(s => (uint)s).ToList());
var entity = Entities.FirstOrDefault(e => e.Id == message.ActorId);
if (entity != null)
{
((Entity.Entity)Entities[Entities.IndexOf(entity)]).CellId = clientMovement.CellEnd.CellId;
}
if (message.ActorId == account.Character.Id)
{
account.Character.CellId = clientMovement.CellEnd.CellId;
}
}
OnMapMovement(message);
}
public void Update(GameMapMovementMessage message)
{
var fighter = GetFighter(message.ActorId);
if (fighter != null)
{
fighter.Update(message);
if (fighter.ContextualId == PlayedFighter?.ContextualId)
{
PlayedFighterMoving?.Invoke(message.KeyMovements.Select(c => (short)c).ToList());
}
else
{
FightersUpdated?.Invoke();
}
}
}
public void Update(GameMapMovementMessage message)
{
foreach (FighterModel fighter in Defenders)
{
if (fighter.ContextualId == message.actorId)
{
fighter.CellId = message.keyMovements.Last();
break;
}
}
foreach (FighterModel fighter in Challengers)
{
if (fighter.ContextualId == message.actorId)
{
fighter.CellId = message.keyMovements.Last();
break;
}
}
}
public static void GameMapMovementMessageTreatment(Message message, byte[] packetDatas, AccountUC account)
{
GameMapMovementMessage msg = (GameMapMovementMessage)message;
using (BigEndianReader reader = new BigEndianReader(packetDatas))
{
msg.Deserialize(reader);
}
MovementPath clientMovement = MapMovementAdapter.GetClientMovement(msg.keyMovements.Select <short, uint>(k => (uint)k).ToList());
if (account.state == Enums.Status.Fighting)
{
BFighter fighter = account.Fight.GetFighter(msg.actorId);
if (fighter != null)
{
//account.Log(new BotTextInformation("GameMap Ancienne cellid of " + fighter.Id + " = " + fighter.CellId));
fighter.CellId = clientMovement.CellEnd.CellId;
//account.Log(new BotTextInformation("GameMap Nouvelle cellid of " + fighter.Id + " = " + fighter.CellId));
}
}
}
public Task Update(GameMapMovementMessage message)
=> Task.Run(async() =>
{
if (_currentPath != null && message.ActorId == _account.Game.Character.Id &&
message.KeyMovements[0] == _currentPath[0] &&
_currentPath.Contains((short)message.KeyMovements.Last()))
{
// TODO: Not sure if this is the best way to handle the account's state,
// Also not sure if this is the best way to handle map changements
_account.State = AccountStates.MOVING;
await Task.Delay(PathDuration.Calculate(_currentPath));
// In case the account was disconnected/disposed
if (_account == null || _account.State == AccountStates.DISCONNECTED)
{
return;
}
await _account.Network.SendMessageAsync(new GameMapMovementConfirmMessage());
_account.State = AccountStates.NONE;
if (_neighbourMapId == 0)
{
OnMovementFinished(true);
}
else
{
_currentPath = null; // Needs to be cleared
// Handle the map change request
if (_neighbourMapId != 0)
{
await _account.Network.SendMessageAsync(new ChangeMapMessage((uint)_neighbourMapId));
_neighbourMapId = 0;
}
;
}
}
});
public static void GameMapMovementMessageTreatment(Message message, byte[] packetDatas, AccountUC account)
{
GameMapMovementMessage msg = (GameMapMovementMessage)message;
using (BigEndianReader reader = new BigEndianReader(packetDatas))
{
msg.Deserialize(reader);
}
List <uint> keys = new List <uint>();
foreach (short s in msg.keyMovements)
{
keys.Add((uint)s);
}
MovementPath clientMovement = MapMovementAdapter.GetClientMovement(keys);
account.MapData.UpdateEntityCell(msg.actorId, clientMovement.CellEnd.CellId);
if (account.Map.Moving && msg.actorId == account.MapData.Character.contextualId)
{
account.Map.ConfirmMove();
}
}
private void HandleMapComplementaryInformationsDataMessage(GameMapMovementMessage message, ConnectedHost source)
{
GroupOfMonstersModel value;
if (Monsters.TryGetValue(message.actorId, out value))
{
value.CellId = message.keyMovements[message.keyMovements.Length - 1];
}
CharacterModel mvalue;
if (Characters.TryGetValue(message.actorId, out mvalue))
{
mvalue.CellId = message.keyMovements[message.keyMovements.Length - 1];
}
ActorModel _value;
if (Actors.TryGetValue(message.actorId, out _value))
{
_value.CellId = message.keyMovements[message.keyMovements.Length - 1];
}
OnUpdated();
}
public static void HandleGameMapMovementMessage(Bot bot, GameMapMovementMessage message)
{
var actor = bot.Character.Context.GetContextActor(message.actorId);
if (actor == null)
{
logger.Error("Actor {0} not found", message.actorId); // only a log for the moment until context are fully handled
}
else
{
var path = Path.BuildFromServerCompressedPath(bot.Character.Map, message.keyMovements);
if (path.IsEmpty())
{
logger.Warn("Try to start moving with an empty path");
return;
}
var movement = new MovementBehavior(path, actor.GetAdaptedVelocity(path));
movement.Start(DateTime.Now + TimeSpan.FromMilliseconds(EstimatedMovementLag));
actor.NotifyStartMoving(movement);
}
}
public void Update(GameMapMovementMessage message)
{
CellId = (short)message.KeyMovements.Last();
}
private void OnMapMovement(GameMapMovementMessage message)
{
MapMovement?.Invoke(message);
}
