private unsafe void OnChatMessage(XivChatType type, uint senderid, ref SeString sender, ref SeString message, ref bool isHandled)
{
if (type != XivChatType.ErrorMessage)
{
return;
}
if (Common.LastCommand == null || Common.LastCommand->StringPtr == null)
{
return;
}
var lastCommandStr = Encoding.UTF8.GetString(Common.LastCommand->StringPtr, (int)Common.LastCommand->BufUsed);
if (!(lastCommandStr.StartsWith("/target ") || lastCommandStr.StartsWith("/ziel ") || lastCommandStr.StartsWith("/cibler ")))
{
return;
}
var match = regex.Match(message.TextValue);
if (!match.Success)
{
return;
}
var searchName = match.Groups[1].Value.ToLowerInvariant();
GameObject closestMatch = null;
var closestDistance = float.MaxValue;
var player = Service.ClientState.LocalPlayer;
foreach (var actor in Service.Objects)
{
if (actor == null)
{
continue;
}
if (actor.Name.TextValue.ToLowerInvariant().Contains(searchName) &&
((GameObjectStruct *)actor.Address)->GetIsTargetable())
{
var distance = Vector3.Distance(player.Position, actor.Position);
if (closestMatch == null)
{
closestMatch = actor;
closestDistance = distance;
continue;
}
if (closestDistance > distance)
{
closestMatch = actor;
closestDistance = distance;
}
}
}
if (closestMatch != null)
{
isHandled = true;
Service.Targets.SetTarget(closestMatch);
}
}
private void ChatOnOnChatMessage(XivChatType type, uint senderid, ref SeString sender, ref SeString message, ref bool ishandled)
{
if (ishandled)
{
return; // don't process a message that's been handled.
}
if (type == XivChatType.RetainerSale)
{
this.Discord.MessageQueue.Enqueue(new QueuedRetainerItemSaleEvent
{
ChatType = type,
Message = message,
Sender = sender
});
}
else
{
this.Discord.MessageQueue.Enqueue(new QueuedChatEvent
{
ChatType = type,
Message = message,
Sender = sender
});
}
}
private void HandleChat(XivChatType type, uint senderId, ref SeString sender, ref SeString message, ref bool isHandled)
{
try {
if ((ushort)type != 2105)
{
return;
}
if (message.TextValue == Service.ClientState.ClientLanguage switch
{
ClientLanguage.German => "Bitte um das Beutegut würfeln.",
ClientLanguage.French => "Veuillez lancer les dés pour le butin.",
ClientLanguage.Japanese => "ロットを行ってください。",
ClientLanguage.ChineseSimplified => "请掷骰。",
_ => "Cast your lot."
})
{
if (Service.Condition[ConditionFlag.WatchingCutscene] ||
Service.Condition[ConditionFlag.WatchingCutscene78] ||
Service.Condition[ConditionFlag.OccupiedInCutSceneEvent])
{
Service.Framework.Update -= TryOpenAfterCutsceneFrameworkUpdate;
Service.Framework.Update += TryOpenAfterCutsceneFrameworkUpdate;
}
else
{
TryOpenWindow();
}
}
} catch (Exception ex) {
//EN: You cast a glamour.
//FR: Vous projetez un mirage.
//DE: Du projizierst ein
//JP: の外見を武具投影した。
private void OnChatMessage(XivChatType type, uint senderId, ref SeString sender, ref SeString message, ref bool isHandled)
{
if (!this.configuration.enabled)
{
return;
}
if ((message.TextValue.Contains("You cast a glamour.") | message.TextValue.Contains("の外見を武具投影した") |
message.TextValue.Contains("Vous projetez un mirage.") | message.TextValue.Contains("Du projizierst ein")) &
(type & XivChatType.SystemMessage) == XivChatType.SystemMessage)
{
isHandled = true;
return;
}
if (!this.configuration.plateEnabled)
{
return;
}
if ((message.TextValue.Contains("Glamours projected from plate ") | message.TextValue.Contains("により武具投影が行われました") |
message.TextValue.Contains("a été projetée sur votre équipement.") | message.TextValue.Contains("Die Projektionsplatte ")) &
(type & XivChatType.SystemMessage) == XivChatType.SystemMessage)
{
isHandled = true;
return;
}
}
public string getName(SeString sender, XivChatType type, SeString message)
{
var pName = _pluginInterface.ClientState.LocalPlayer.Name;
if (sender.Payloads.Count > 0)
{
if (sender.Payloads[0].Type == PayloadType.Player)
{
var pPayload = (PlayerPayload)sender.Payloads[0];
pName = pPayload.PlayerName;
}
if (sender.Payloads[0].Type == PayloadType.Icon && sender.Payloads[1].Type == PayloadType.Player)
{
var pPayload = (PlayerPayload)sender.Payloads[1];
pName = pPayload.PlayerName;
}
}
if (type == XivChatType.StandardEmote || type == XivChatType.CustomEmote)
{
if (message.Payloads[0].Type == PayloadType.Player)
{
var pPayload = (PlayerPayload)message.Payloads[0];
pName = pPayload.PlayerName;
}
}
return(pName);
}
private void OnChatMessage(XivChatType type, uint senderId, ref SeString sender, ref SeString message, ref bool isHandled)
{
if (!_pluginConfig.Enabled)
{
return;
}
try
{
if (isHandled || !(sender.Payloads.SingleOrDefault(x => x.Type == PayloadType.Player) is PlayerPayload playerPayload))
{
return;
}
if (_pluginConfig.VoidList.Any(x =>
x.HomeworldId == playerPayload.World.RowId &&
x.Name == playerPayload.PlayerName))
{
isHandled = true;
}
}
catch (Exception)
{
// Ignore exception
}
}
public OnChatMessageArgs(XivChatType type, uint senderId, SeString sender, SeString message)
{
this.Type = type;
this.SenderId = senderId;
this.Sender = sender;
this.Message = message;
}
private void *PrintMessageDetour(RaptureLogModule *raptureLogModule, XivChatType xivChatType, IntPtr senderName, IntPtr message, uint senderId, byte param)
{
try {
if (chatTypes.Contains(xivChatType))
{
// Need to hook it manually to handle changing the name until API4
var stdSender = StdString.ReadFromPointer(senderName);
var parsedSender = SeString.Parse(stdSender.RawData);
if (Parse(ref parsedSender))
{
stdSender.RawData = parsedSender.Encode();
var allocatedString = Service.LibcFunction.NewString(stdSender.RawData);
var retVal = printChatHook.Original(raptureLogModule, xivChatType, allocatedString.Address, message, senderId, param);
allocatedString.Dispose();
return(retVal);
}
}
} catch (Exception ex) {
SimpleLog.Error(ex);
}
return(printChatHook.Original(raptureLogModule, xivChatType, senderName, message, senderId, param));
}
public void Tran(XivChatType type, string messageString, string senderName)
{
string output = Translate(messageString);
if (injectChat == true)
{
PrintChat(type, senderName, lTr + output + rTr);
}
foreach (var tab in items)
{
if (tab.Logs[ConvertForArray(type.ToString())] && tab.Config[2])
{
ChatText tmp = new ChatText();
tmp.Time = GetTime();
tmp.ChannelShort = GetChannelName(type.ToString());
tmp.Channel = type.ToString();
tmp.Sender = senderName;
TextTypes translate = new TextTypes();
translate.Text = lTr + output + rTr;
translate.Type = PayloadType.RawText;
tmp.Text.Add(translate);
tab.Chat.Add(tmp);
}
}
}
private void HandleChatMessage(XivChatType type, uint senderId, ref SeString sender, ref SeString message, ref bool isHandled)
{
if (chatTypes.Contains(type))
{
Parse(ref message);
}
}
private void ChatOnOnChatMessage(XivChatType type, uint senderId, ref SeString sender, ref SeString message, ref bool isHandled)
{
if (Config.style == 2)
{
if (sender.Payloads.Count > 0)
{
sender.Payloads.Insert(0, FormatTextStyle(type));
}
else
{
message.Payloads.Insert(0, FormatTextStyle(type));
}
}
else if (Config.style == 1)
{
message.Payloads.Insert(0, FormatTextStyle(type));
}
/*
* foreach (var payload in message.Payloads)
* {
* if (payload is TextPayload textPayload)
* {
* textPayload.Text = $"({(int)type}/{type}) {textPayload.Text}";
* break;
* }
* }
*/
}
private void HandleChatMessage(XivChatType type, uint senderId, ref SeString sender, ref SeString message, ref bool isHandled)
{
if ((int)type == 61 && sender != null && !string.IsNullOrWhiteSpace(sender.TextValue))
{
//PluginLog.Log($"senderid:{senderId} | type:{type} | sender:{sender.TextValue} | {message.TextValue}");
synthesizer.SpeakAsync($"{sender.TextValue} says: {message.TextValue}");
}
}
private void ChatOnOnChatMessage(
XivChatType type, uint senderid, ref SeString sender, ref SeString message, ref bool ishandled)
{
if (type == XivChatType.Echo && message.TextValue == "DALAMUD")
{
this.hasPassed = true;
}
}
public void PrintChat(XivChatType type, string senderName, string messageString)
{
var chat = new XivChatEntry
{
Type = type, Name = senderName, MessageBytes = Encoding.UTF8.GetBytes(messageString)
};
pluginInterface.Framework.Gui.Chat.PrintChat(chat);
}
public void Tran(XivChatType type, string messageString, string senderName)
{
string output = Translate(messageString);
if (injectChat == true)
{
PrintChat(type, "[TRN] " + senderName, output);
}
this.chatText += "\n" + senderName + ": " + output;
}
private void ChatOnOnChatMessage(XivChatType type, uint senderId, ref SeString sender, ref SeString message,
ref bool isHandled)
{
foreach (var payload in message.Payloads)
{
if (payload is TextPayload textPayload)
{
textPayload.Text = LeetSpeakify(textPayload.Text);
}
}
}
private void PrintChat(XivChatType type, string senderName, SeString messageSeString)
{
var chat = new XivChatEntry
{
Type = type,
Name = senderName,
MessageBytes = messageSeString.Encode()
};
_pluginInterface.Framework.Gui.Chat.PrintChat(chat);
}
private void PrintChat(XivChatType type, string senderName, SeString messageSeString)
{
var chat = new XivChatEntry
{
Type = type,
Name = senderName,
Message = messageSeString
};
Chat.PrintChat(chat);
}
private void OnChatMessage(XivChatType type, uint senderId, ref StdString sender,
ref StdString message, ref bool isHandled) {
if (type == XivChatType.GatheringSystemMessage && senderId == 0) {
var cmdMatch = this.CommandRegex.Match(message.Value).Groups["command"];
if (cmdMatch.Success) {
// Yes, it's a chat command.
var command = cmdMatch.Value;
if (ProcessCommand(command)) isHandled = true;
}
}
}
public Plugin(CommandManager command)
{
this.Config = (Configuration)this.Interface.GetPluginConfig() ?? new Configuration();
this.Config.Initialize(this.Interface);
// sanity check - ensure there are no invalid types leftover from past versions.
foreach (DiscordChannelConfig config in this.Config.ChannelConfigs.Values)
{
for (int i = 0; i < config.ChatTypes.Count; i++)
{
XivChatType xct = config.ChatTypes[i];
if ((int)xct > 127)
{
config.ChatTypes[i] = (XivChatType)((int)xct & 0x7F);
this.Config.Save();
}
try
{
xct.GetInfo();
}
catch (ArgumentException)
{
PluginLog.Error($"Removing invalid chat type before it could cause problems ({(int)xct}){xct}.");
config.ChatTypes.RemoveAt(i--);
this.Config.Save();
}
}
}
this.DiscordBridgeProvider = new DiscordBridgeProvider(this.Interface, new DiscordBridgeAPI(this));
this.Discord = new DiscordHandler(this);
// Task t = this.Discord.Start(); // bot won't start if we just have this
Task.Run(async() => // makes the bot actually start
{
await this.Discord.Start();
});
this.ui = new PluginUI(this);
this.Interface.UiBuilder.Draw += this.ui.Draw;
this.Chat.ChatMessage += ChatOnOnChatMessage;
this.State.CfPop += ClientStateOnCfPop;
this.commandManager = new PluginCommandManager <Plugin>(this, command);
if (string.IsNullOrEmpty(this.Config.DiscordToken))
{
this.Chat.PrintError("The Discord Bridge plugin was installed successfully." +
"Please use the \"/pdiscord\" command to set it up.");
}
}
private void OnXivMessage(XivChatType type, uint senderId, ref SeString sender, ref SeString message, ref bool isHandled)
{
var obj = new JObject();
obj["type"] = (ushort)type;
obj["senderId"] = senderId;
obj["sender"] = sender?.TextValue;
obj["message"] = message?.TextValue;
obj["isHandled"] = isHandled;
Plugin.server.WebSocketServices[Endpoint].Sessions.Broadcast(obj.ToString());
}
public static XivChatTypeInfo GetInfo(this XivChatType type)
{
// if (type == XivChatType.TellOutgoing)
// type = XivChatType.TellIncoming;
if (TypeInfoDict.TryGetValue((XivChatType)((int)type & 0x7F), out var info))
{
return(info);
}
throw new ArgumentException($"No info mapping for chat type. {nameof(type)} ({(int)type}){type}");
}
private void CheckMesssage(XivChatType type, uint senderId, ref SeString sender, ref SeString message, ref bool isHandled)
{
if (type != XivChatType.ErrorMessage)
{
return;
}
if (message.TextValue == searchString)
{
Plugin.XivCommon.Functions.Chat.SendMessage("/t <r>");
isHandled = true;
}
}
public SeString getName(SeString sender, XivChatType type, SeString message)
{
var playerPayload = sender.Payloads.SingleOrDefault(x => x is PlayerPayload) as PlayerPayload;
if (type is XivChatType.StandardEmote)
{
playerPayload = message.Payloads.FirstOrDefault(x => x is PlayerPayload) as PlayerPayload;
}
var pName = playerPayload == default(PlayerPayload) ? ClientState.LocalPlayer.Name.TextValue : playerPayload.PlayerName;
PluginLog.Log(pName);
return(pName);
}
public MapLink(TeleporterPlugin plugin, XivChatType type, MapLinkPayload payload, string senderName, SeString message)
{
_plugin = plugin;
ChatType = type;
Location = new Vector2(payload.XCoord, payload.YCoord);
PlaceName = payload.PlaceName;
TerritoryId = payload.TerritoryType.RowId;
SenderName = senderName;
Message = message.TextValue;
Data = message.Encode();
Aetheryte = GetClosestAetheryte();
Payload = new MapLinkPayload(_plugin.Interface.Data, payload.TerritoryType.RowId, payload.Map.RowId, payload.RawX, payload.RawY);
}
public static XivChatTypeInfo GetInfo(this XivChatType type)
{
if (type == XivChatType.TellOutgoing)
{
type = XivChatType.TellIncoming;
}
if (TypeInfoDict.TryGetValue(type, out var info))
{
return(info);
}
throw new ArgumentException("No info mapping for chat type.", nameof(type));
}
private void ChatOnOnChatMessage(XivChatType type, uint senderId, ref SeString sender, ref SeString message,
ref bool isHandled)
{
if (!_configuration.Enabled)
{
return;
}
foreach (var payload in message.Payloads)
{
if (payload is TextPayload textPayload)
{
textPayload.Text = _profanityFilter.CensorString(textPayload.Text);
}
}
}
public ChannelSettings GetChannelSettings(XivChatType type)
{
if (ChannelSettingsTable.ContainsKey((int)type))
{
return(ChannelSettingsTable[(int)type]);
}
else if (ChannelSettingsTable.ContainsKey(127 & (int)type))
{
return(ChannelSettingsTable[127 & (int)type]);
}
else
{
return(ChannelSettingsTable[0]);
}
}
private IntPtr HandlePrintMessageDetour(IntPtr manager, XivChatType chattype, IntPtr pSenderName, IntPtr pMessage,
uint senderid, IntPtr parameter)
{
IntPtr retVal = IntPtr.Zero;
try {
var senderName = StdString.ReadFromPointer(pSenderName);
var message = StdString.ReadFromPointer(pMessage);
Log.Debug($"HandlePrintMessageDetour {manager} - [{chattype}] [{BitConverter.ToString(message.RawData).Replace("-", " ")}] {message.Value} from {senderName.Value}");
// Log.Debug($"Got message bytes {BitConverter.ToString(messageBytes.Bytes).Replace("-", " ")}");
var originalMessageData = (byte[])message.RawData.Clone();
// Call events
var isHandled = false;
OnChatMessage?.Invoke(chattype, senderid, ref senderName, ref message, ref isHandled);
var messagePtr = pMessage;
OwnedStdString allocatedString = null;
if (!FastByteArrayCompare(originalMessageData, message.RawData))
{
allocatedString = this.dalamud.Framework.Libc.NewString(message.RawData);
Log.Debug(
$"HandlePrintMessageDetour String modified: {originalMessageData}({messagePtr}) -> {message}({allocatedString.Address})");
messagePtr = allocatedString.Address;
}
// Print the original chat if it's handled.
if (!isHandled)
{
retVal = this.printMessageHook.Original(manager, chattype, pSenderName, messagePtr, senderid, parameter);
}
if (this.baseAddress == IntPtr.Zero)
{
this.baseAddress = manager;
}
allocatedString?.Dispose();
} catch (Exception ex) {
Log.Error(ex, "Exception on OnChatMessage hook.");
retVal = this.printMessageHook.Original(manager, chattype, pSenderName, pMessage, senderid, parameter);
}
return(retVal);
}
private void OnCheckMessageHandled(XivChatType type, uint senderId, ref SeString sender, ref SeString message, ref bool isHandled)
{
if (type == XivChatType.ErrorMessage && senderId == 0)
{
var cmdMatch = this.currentLangCommandRegex.Match(message.TextValue).Groups["command"];
if (cmdMatch.Success)
{
// Yes, it's a chat command.
var command = cmdMatch.Value;
if (ProcessCommand(command))
{
isHandled = true;
}
}
}
}
