public void Process(IPalBot bot, IPacketMap pkt)
{
if (pkt is Message && bot.EnablePlugins)
{
var msg = (Message)pkt;
ProcessMessage(bot, msg);
broadcast.BroadcastMessage(bot, msg);
return;
}
if (packets == null)
{
LoadPacketReflectors();
}
var reflected = packets.Where(t => t.Command == pkt.Command).ToArray();
foreach (var reflect in reflected)
{
try
{
reflect.Method.Invoke(reflect.Instance, new object[] { pkt, bot });
}
catch (Exception ex)
{
broadcast.BroadcastException(ex, $"Error running packet watcher {reflect.Command}");
}
}
}
public bool Validate(IPacketMap packet)
{
foreach (var watch in Watchers ?? new string[0])
{
if (watch != packet.Command)
{
continue;
}
OnFound.SetResult(packet);
return(true);
}
foreach (var cancel in Cancelrs ?? new string[0])
{
if (cancel != packet.Command)
{
continue;
}
OnFound.SetException(new PacketException(packet));
return(true);
}
return(false);
}
public IPacket Unmap(IPacketMap map)
{
if (!PacketMaps.ContainsKey(map.Command))
{
return(null); //No packet mappers for type
}
var mapper = PacketMaps[map.Command];
if (mapper.Payloads != null && mapper.Payloads.Count > 1)
{
return(null); //Cannot map a packet that has multiple payload accessors.
}
var packet = new Packet
{
Command = map.Command,
Headers = new Dictionary <string, string>()
};
foreach (var header in mapper.Headers)
{
packet[header.Key] = header.Value.GetValue(map).ToString();
}
if (mapper.Payloads != null)
{
packet.Payload = reflection.ChangeType <byte[]>(mapper.Payloads[0].GetValue(map));
}
return(packet);
}
public async Task <bool> Write(IPacketMap map)
{
var packet = packetMapper.Unmap(map);
if (packet == null)
{
return(false);
}
return(await Write(packet));
}
public bool Validate(IPacketMap packet)
{
foreach (var watch in Watchers ?? new PacketResponse[0])
{
if (watch.Command == packet.Command)
{
watch.Packet = packet;
OnFound.SetResult(watch);
return(true);
}
}
return(false);
}
private bool CheckCanel(IPacketMap packet)
{
if (!(packet is T2))
{
return(false);
}
if (CancelValidator != null && !CancelValidator((T2)packet))
{
return(false);
}
OnFound.SetException(new PacketException(packet));
return(true);
}
public void Process(IPacketMap map)
{
foreach (var watch in watches.ToArray())
{
try
{
if (watch.Validate(map))
{
watches.Remove(watch);
}
}
catch (Exception ex)
{
broadcast.BroadcastException(ex, "Error running validator for " + map.Command);
}
}
}
public bool Validate(IPacketMap packet)
{
if (CheckCanel(packet))
{
return(true);
}
if (!(packet is T))
{
return(false);
}
if (Validator != null && !Validator((T)packet))
{
return(false);
}
OnFound.SetResult((T)packet);
return(true);
}
public bool Validate(IPacketMap packet)
{
if (!(packet is T))
{
return(false);
}
if (!PacketCommand.Equals(packet.Command, StringComparison.CurrentCultureIgnoreCase))
{
return(false);
}
if (Validator != null && !Validator((T)packet))
{
return(false);
}
OnFound.SetResult((T)packet);
return(true);
}
public void ProcessPacket(PalBot bot, IPacketMap packet)
{
if (packetHandlers == null)
{
LoadHandlers();
}
var handlers = packetHandlers.Where(t => t.Handlers.ContainsKey(packet.Command.ToUpper()));
foreach (var handler in handlers)
{
var method = handler.Handlers[packet.Command.ToUpper()];
try
{
method.Invoke(handler.Instance, new object[] { packet, bot });
}
catch (Exception ex)
{
broadcast.BroadcastException(ex, $"Error processing handler {method.Name} for {packet.Command.ToUpper()}");
}
}
}
public PacketException(IPacketMap map)
{
Packet = map;
}
