/// <summary>
/// Disbatch a message to a game object with instructions on locality of the disbatch
/// </summary>
public static void DisbatchMessage <EventType>(EventType message, FFPacketInstructionFlags instructions, GameObject go)
{
instructions |= FFPacketInstructionFlags.MessageBoardGameObjectSend;
var packet = new FFPacket <EventType>(instructions, typeof(EventType).Name, message, BaseMessageBoard.LocalIdEntry(go.GetInstanceID()));
DisbatchPacket(packet);
}
/// <inheritdoc />
public void SendSpecialEffect(IWorldEntity entity, int specialEffectId, bool sfxNoFollow)
{
if (entity is IPlayerEntity playerEntity)
{
if (playerEntity.PlayerData.Mode.HasFlag(ModeType.TRANSPARENT_MODE))
{
return;
}
}
using var packet = new FFPacket();
packet.StartNewMergedPacket(entity.Id, SnapshotType.CREATESFXOBJ);
packet.Write(specialEffectId);
if (sfxNoFollow)
{
packet.Write(entity.Object.Position.X); // X
packet.Write(entity.Object.Position.Y); // Y
packet.Write(entity.Object.Position.Z); // Z
}
else
{
packet.Write(0f); // X
packet.Write(0f); // Y
packet.Write(0f); // Z
}
packet.Write(false); // Flag
SendToVisible(packet, entity, sendToPlayer: true);
}
/// <inheritdoc />
public void SendQuestDialogs(IPlayerEntity player, IEnumerable <DialogLink> newQuests, IEnumerable <DialogLink> currentQuests)
{
if (newQuests != null || currentQuests != null)
{
using var packet = new FFPacket();
if (newQuests != null)
{
foreach (DialogLink newQuestLink in newQuests)
{
packet.StartNewMergedPacket(player.Id, SnapshotType.RUNSCRIPTFUNC);
packet.Write((short)DialogOptions.FUNCTYPE_NEWQUEST);
packet.Write(newQuestLink.Title);
packet.Write(newQuestLink.Id);
packet.Write(0);
packet.Write(newQuestLink.QuestId.GetValueOrDefault());
}
}
if (currentQuests != null)
{
foreach (DialogLink currentQuestLink in currentQuests)
{
packet.StartNewMergedPacket(player.Id, SnapshotType.RUNSCRIPTFUNC);
packet.Write((short)DialogOptions.FUNCTYPE_CURRQUEST);
packet.Write(currentQuestLink.Title);
packet.Write(currentQuestLink.Id);
packet.Write(0);
packet.Write(currentQuestLink.QuestId.GetValueOrDefault());
}
}
SendToPlayer(player, packet);
}
}
/// <summary>
/// Sends a NPC dialog to a player.
/// </summary>
/// <param name="player">Player</param>
/// <param name="text">Npc dialog text</param>
/// <param name="dialogLinks">Npc dialog links</param>
public static void SendDialog(IPlayerEntity player, string text, IEnumerable <DialogLink> dialogLinks)
{
using (var packet = new FFPacket())
{
packet.StartNewMergedPacket(player.Id, SnapshotType.RUNSCRIPTFUNC);
packet.Write((short)DialogOptions.FUNCTYPE_REMOVEALLKEY);
packet.StartNewMergedPacket(player.Id, SnapshotType.RUNSCRIPTFUNC);
packet.Write((short)DialogOptions.FUNCTYPE_SAY);
packet.Write(text);
packet.Write(0); // quest id
foreach (DialogLink link in dialogLinks)
{
packet.StartNewMergedPacket(player.Id, SnapshotType.RUNSCRIPTFUNC);
packet.Write((short)DialogOptions.FUNCTYPE_ADDKEY);
packet.Write(link.Title);
packet.Write(link.Id);
packet.Write(0);
packet.Write(0);
}
player.Connection.Send(packet);
}
}
public void OnNPCInteraction(FFPacket packet)
{
var objectId = packet.Read <int>();
var dialogKey = packet.Read <string>();
var global1 = packet.Read <int>();
var global2 = packet.Read <int>();
var srcId = packet.Read <int>();
var destId = packet.Read <int>();
var npc = this.Player.GetSpawnedObjectById <Npc>(objectId);
if (npc != null && npc.Dialog != null)
{
if (dialogKey == "BYE")
{
var byeLink = npc.Dialog.Links.Where(x => x.Id == dialogKey).FirstOrDefault();
npc.SendNormalChatTo(byeLink?.Text, this.Player);
npc.SendCloseDialogTo(this.Player);
}
else
{
npc.SendDialogTo(this.Player, dialogKey);
}
}
}
public override void SendToLocalGameObject(FFBasePacket package, GameObject go)
{
FFPacket <EventType> sentPackage = (FFPacket <EventType>)package;
FFPacket <EventType> .Decrypt(ref sentPackage.message);
switch (package.packetInstructions)
{
case FFPacketInstructionFlags.MessageBoardGameObjectSend:
FFMessageBoard <EventType> .SendToLocal(sentPackage.message, go);
break;
case FFPacketInstructionFlags.MessageBoardGameObjectSendDown:
FFMessageBoard <EventType> .SendToLocalDown(sentPackage.message, go);
break;
case FFPacketInstructionFlags.MessageBoardGameObjectSendUp:
FFMessageBoard <EventType> .SendToLocalUp(sentPackage.message, go);
break;
case FFPacketInstructionFlags.MessageBoardGameObjectSendToAllConnected:
FFMessageBoard <EventType> .SendToLocalToAllConnected(sentPackage.message, go);
break;
default:
break;
}
}
public static void SendMoverBehavior(IEntity entity, Vector3 beginPosition, Vector3 destinationPosition,
float angle, uint state, uint stateFlag, uint motion, int motionEx, int loop, uint motionOption,
long tickCount)
{
using (var packet = new FFPacket())
{
packet.StartNewMergedPacket(entity.Id, SnapshotType.MOVERBEHAVIOR);
packet.Write(beginPosition.X);
packet.Write(beginPosition.Y);
packet.Write(beginPosition.Z);
packet.Write(destinationPosition.X);
packet.Write(destinationPosition.Y);
packet.Write(destinationPosition.Z);
packet.Write(angle);
packet.Write(state);
packet.Write(stateFlag);
packet.Write(motion);
packet.Write(motionEx);
packet.Write(loop);
packet.Write(motionOption);
packet.Write(tickCount);
SendToVisible(packet, entity, sendToPlayer: false);
}
}
internal void SendMoverMoved(Vector3 direction, int motionEx, int loop, int motionOption, long tick, byte frame, float turnAngle)
{
using (var packet = new FFPacket())
{
packet.StartNewMergedPacket(this.ObjectId, SnapshotType.MOVERMOVED2);
packet.Write(this.Position.X);
packet.Write(this.Position.Y);
packet.Write(this.Position.Z);
packet.Write(direction.X);
packet.Write(direction.Y);
packet.Write(direction.Z);
packet.Write(this.Angle);
packet.Write(this.AngleFly);
packet.Write(this.FlightSpeed);
packet.Write(turnAngle);
packet.Write((uint)this.MovingFlags);
packet.Write((int)this.MotionFlags);
packet.Write(this.ActionFlags);
packet.Write(motionEx);
packet.Write(loop);
packet.Write(motionOption);
packet.Write(tick);
packet.Write(frame);
base.SendToVisible(packet);
}
}
/// <inheritdoc />
public void SendPlayerRevival(IPlayerEntity player)
{
using var packet = new FFPacket();
packet.StartNewMergedPacket(player.Id, SnapshotType.REVIVAL_TO_LODESTAR);
SendToVisible(packet, player, sendToPlayer: true);
}
/// <inheritdoc />
public void SendDespawnObjectTo(IPlayerEntity player, IWorldEntity entityToDespawn)
{
using var packet = new FFPacket();
packet.StartNewMergedPacket(entityToDespawn.Id, SnapshotType.DEL_OBJ);
SendToPlayer(player, packet);
}
/// <inheritdoc />
public void SendWelcome(IWorldClient client, uint sessionId)
{
using var packet = new FFPacket(PacketType.WELCOME);
packet.Write(sessionId);
client.Send(packet);
}
public override bool SendToLocalEntry(FFBasePacket package, string entry)
{
FFPacket <EventType> sentPackage = (FFPacket <EventType>)package;
FFPacket <EventType> .Decrypt(ref sentPackage.message);
return(FFMessageBoard <EventType> .SendToLocal(sentPackage.message, entry));
}
/// <inheritdoc />
public void SendTradeOk(IPlayerEntity player, uint traderId)
{
using var packet = new FFPacket();
packet.StartNewMergedPacket(traderId, SnapshotType.TRADEOK);
SendToPlayer(player, packet);
}
/// <inheritdoc />
public void SendTradeRequestCancel(IPlayerEntity player, IPlayerEntity target)
{
using var packet = new FFPacket();
packet.StartNewMergedPacket(player.Id, SnapshotType.CONFIRMTRADECANCEL);
SendToPlayer(target, packet);
}
/// <inheritdoc />
public void SendTradeConsent(IPlayerEntity player)
{
using var packet = new FFPacket();
packet.StartNewMergedPacket(0, SnapshotType.TRADECONSENT);
SendToPlayer(player, packet);
}
/// <inheritdoc />
public void SendTradeLastConfirm(IPlayerEntity player)
{
using var packet = new FFPacket();
packet.StartNewMergedPacket(0, SnapshotType.TRADELASTCONFIRM);
SendToPlayer(player, packet);
}
// Used to unpack messages from the net
public override bool SendToLocal(FFBasePacket package)
{
FFPacket <EventType> sentPackage = (FFPacket <EventType>)package;
FFPacket <EventType> .Decrypt(ref sentPackage.message);
return(FFMessage <EventType> .SendToLocal(sentPackage.message));
}
public void SendMessageBoardEntry <MessageType>(MessageType message, string entry, bool varifiedPacket)
{
FFPacket <MessageType> packet =
new FFPacket <MessageType>(FFPacketInstructionFlags.MessageBoardEntry,
typeof(MessageType).ToString(), message, entry);
SendNetPacket(packet, varifiedPacket);
}
public void SendGameAllConnectedObject <MessageType>(MessageType message, ulong netId, bool varifiedPacket)
{
FFPacket <MessageType> packet =
new FFPacket <MessageType>(FFPacketInstructionFlags.MessageBoardGameObjectSendToAllConnected,
typeof(MessageType).ToString(), message, netId.ToString());
SendNetPacket(packet, varifiedPacket);
}
public void SendSkillCancellation(IPlayerEntity player)
{
using var packet = new FFPacket();
packet.StartNewMergedPacket(player.Id, SnapshotType.CLEAR_USESKILL);
SendToPlayer(player, packet);
}
public override uint Inspect(FFServer.ClientSocket clientSocket, FFBasePacket incommingPacket)
{
FFPacket <ClientSyncTimeEvent> packet = (FFPacket <ClientSyncTimeEvent>)incommingPacket;
packet.message.serverLifeTime = FFServer.serverTime;
clientSocket.SendNetPacket <ClientSyncTimeEvent>(packet, false);
return(1); // return zero to to have this inspector pass this message
}
public static void SendTradeOk(IPlayerEntity player, uint traderId)
{
using (var packet = new FFPacket())
{
packet.StartNewMergedPacket(traderId, SnapshotType.TRADEOK);
player.Connection.Send(packet);
}
}
/// <summary>
/// Sends the despawn object to the current player.
/// </summary>
/// <param name="player">Current player</param>
/// <param name="entityToDespawn">Entity to despawn</param>
public static void SendDespawnObjectTo(IPlayerEntity player, IEntity entityToDespawn)
{
using (var packet = new FFPacket())
{
packet.StartNewMergedPacket(entityToDespawn.Id, SnapshotType.DEL_OBJ);
player.Connection.Send(packet);
}
}
/// <summary>
/// Send greetings to the client.
/// </summary>
public override void Greetings()
{
var packet = new FFPacket();
packet.WriteHeader(PacketType.WELCOME);
packet.Write(this.sessionId);
this.Send(packet);
}
/// <inheritdoc />
public void SendPlayerSetLevel(IPlayerEntity player, int level)
{
using var packet = new FFPacket();
packet.StartNewMergedPacket(player.Id, SnapshotType.SETLEVEL);
packet.Write((short)level);
SendToVisible(packet, player);
}
/// <summary>
/// Sends a request telling the player can join the world.
/// </summary>
/// <param name="client"></param>
public static void SendJoinWorld(NetUser client)
{
using (var packet = new FFPacket())
{
packet.WriteHeader(PacketType.PRE_JOIN);
client.Send(packet);
}
}
public static void SendToNet <EventType>(FFPacket <EventType> netPacket, bool varifiedPacket)
{
// any Data scrambling which is based on type needs to happen here. It is unscrambled
// in
FFPacket <EventType> .Encrypt(ref netPacket.message);
//FFClient.SendPacket(netPacket, varifiedPacket);
return;
}
/// <inheritdoc />
public void SendJoinWorld(IClusterClient client)
{
using (var packet = new FFPacket())
{
packet.WriteHeader(PacketType.PRE_JOIN);
client.Send(packet);
}
}
internal void SendDespawnObject(WorldObject worldObject)
{
using (var packet = new FFPacket())
{
packet.StartNewMergedPacket(worldObject.ObjectId, SnapshotType.DEL_OBJ);
this.Send(packet);
}
}
public static void SendTradeLastConfirm(IPlayerEntity player)
{
using (var packet = new FFPacket())
{
packet.StartNewMergedPacket(0, SnapshotType.TRADELASTCONFIRM);
player.Connection.Send(packet);
}
}
private static void SendClientSyncTimeEvent(bool isDistorsionSync)
{
ClientSyncTimeEvent e;
e.serverLifeTime = -1;
e.isDistortionSyncEvent = isDistorsionSync;
e.clientSendTime = clientTimeNoDistortion;
FFPacket<ClientSyncTimeEvent> packet = new FFPacket<ClientSyncTimeEvent>(
FFPacketInstructionFlags.Message | FFPacketInstructionFlags.Immediate,
typeof(ClientSyncTimeEvent).ToString(), e);
FFMessageSystem.SendToNet<ClientSyncTimeEvent>(packet, false);
}
