public void Connect(string deviceName)
{
var detector = new PortDetector();
var ports = detector.GetUdpPorts("Albion-Online");
foreach (var port in ports)
{
_udpPorts.Add(port);
}
var builder = ReceiverBuilder.Create();
IncomeLowEventsSource = new IncomeLowEventsSource(builder);
OutcomeLowEventsSource = new OutcomeLowEventsSource(builder);
_receiver = builder.Build();
_device = CaptureDeviceList.Instance.Single(d => d.Name == deviceName);
_device.Open(DeviceMode.Promiscuous, (int)TimeSpan.FromSeconds(1).TotalMilliseconds);
foreach (var udpPort in _udpPorts)
{
IPortListener portListener = new PortListener(_device, udpPort, ChannelProtocol.UDP);
_udps.Add(portListener);
portListener.DataCaptured += Udp_OnData;
portListener.Connect();
}
_device.StartCapture();
EventsSource = new EventsSource(IncomeLowEventsSource, BuffRepository, Avatar);
Connected?.Invoke();
}
private static void Main(string[] args)
{
ReceiverBuilder builder = ReceiverBuilder.Create();
builder.AddRequestHandler(new MoveRequestHandler());
builder.AddEventHandler(new MoveEventHandler());
builder.AddEventHandler(new NewCharacterEventHandler());
receiver = builder.Build();
Console.WriteLine("Start");
CaptureDeviceList devices = CaptureDeviceList.Instance;
foreach (var device in devices)
{
new Thread(() =>
{
Console.WriteLine($"Open... {device.Description}");
device.OnPacketArrival += new PacketArrivalEventHandler(PacketHandler);
device.Open(DeviceMode.Promiscuous, 1000);
device.StartCapture();
})
.Start();
}
Console.Read();
}
public IncomeLowEventsSource(ReceiverBuilder builder)
{
foreach (EventCodes code in Enum.GetValues(typeof(EventCodes)))
{
switch (code)
{
case EventCodes.Move:
break;
case EventCodes.ChatMessage:
case EventCodes.ChatSay:
case EventCodes.ChatWhisper:
case EventCodes.SystemMessage:
case EventCodes.UtilityTextMessage:
case EventCodes.HealthUpdate:
var eventHandler = new CustomEventHandler(code);
eventHandler.OnEvent += EventHandler_OnEvent;
builder.AddEventHandler(eventHandler);
break;
default:
var eventHandler2 = new CustomEventHandler(code);
eventHandler2.OnEvent += EventHandler_OnEvent;
builder.AddEventHandler(eventHandler2);
break;
}
}
}
public async Task <LoopSession> Start()
{
int?port;
ReceiverService loop =
new ReceiverBuilder()
.WithDefinition(new LoopMessages())
.Build(hooks);
TcpSocket client = pool.New();
TcpSocket server = pool.New();
client.Bind();
server.Bind(out port);
server.Listen(1);
IPEndPoint endpoint = new IPEndPoint(IPAddress.Loopback, port.Value);
Task <TcpSocketAccept> accept = server.Accept();
client.Connect(endpoint, null);
PeerHash peer = PeerHash.Random();
TcpSocketAccept accepted = await accept;
NetworkConnection receiver = pool.Create(accepted.Connection, NetworkDirection.Incoming, accepted.GetRemote());
loop.StartProcessing(peer, receiver);
return(new LoopSession(client, loop));
}
public static bool StartNetworkCapture(MainWindowViewModel mainWindowViewModel, TrackingController trackingController)
{
try
{
_mainWindowViewModel = mainWindowViewModel;
builder = ReceiverBuilder.Create();
//builder.AddResponseHandler(new UseLootChestEventHandler(trackingController));
builder.AddEventHandler(new NewSimpleItemEventHandler(trackingController));
builder.AddEventHandler(new NewEquipmentItemEventHandler(trackingController));
builder.AddEventHandler(new OtherGrabbedLootEventHandler(trackingController));
builder.AddEventHandler(new InventoryDeleteItemEventHandler(trackingController));
builder.AddEventHandler(new InventoryPutItemEventHandler(trackingController));
builder.AddEventHandler(new TakeSilverEventHandler(trackingController));
builder.AddEventHandler(new UpdateFameEventHandler(trackingController));
builder.AddEventHandler(new UpdateMoneyEventHandler(trackingController));
builder.AddEventHandler(new UpdateReSpecPointsEventHandler(trackingController));
builder.AddEventHandler(new UpdateCurrencyEventHandler(trackingController));
builder.AddEventHandler(new DiedEventHandler(trackingController));
builder.AddEventHandler(new NewLootChestEventHandler(trackingController));
builder.AddEventHandler(new LootChestOpenedEventHandler(trackingController));
builder.AddEventHandler(new InCombatStateUpdateEventHandler(trackingController));
builder.AddEventHandler(new NewShrineEventHandler(trackingController));
builder.AddRequestHandler(new UseShrineEventHandler(trackingController));
builder.AddResponseHandler(new ChangeClusterResponseHandler(trackingController));
builder.AddEventHandler(new HealthUpdateEventHandler(trackingController));
builder.AddEventHandler(new PartyDisbandedEventHandler(trackingController));
builder.AddEventHandler(new PartyChangedOrderEventHandler(trackingController));
builder.AddResponseHandler(new PartyMakeLeaderEventHandler(trackingController));
builder.AddEventHandler(new NewCharacterEventHandler(trackingController));
builder.AddEventHandler(new SiegeCampClaimStartEventHandler(trackingController));
builder.AddEventHandler(new NewMobEventHandler(trackingController));
builder.AddEventHandler(new LeaveEventHandler(trackingController));
builder.AddEventHandler(new CharacterEquipmentChangedEventHandler(trackingController));
builder.AddEventHandler(new ActiveSpellEffectsUpdateEventHandler(trackingController));
builder.AddEventHandler(new PartySilverGainedEventHandler(trackingController));
builder.AddEventHandler(new UpdateFactionStandingEventHandler(trackingController));
//builder.AddResponseHandler(new TestHandler());
//builder.AddEventHandler(new TestHandler2());
//builder.AddRequestHandler(new TestHandler3());
builder.AddResponseHandler(new JoinResponseHandler(trackingController, _mainWindowViewModel));
_receiver = builder.Build();
_capturedDevices.AddRange(CaptureDeviceList.Instance);
return(StartDeviceCapture());
}
catch (Exception e)
{
ConsoleManager.WriteLineForError(MethodBase.GetCurrentMethod().DeclaringType, e);
Log.Error(MethodBase.GetCurrentMethod().DeclaringType, e);
_mainWindowViewModel.SetErrorBar(Visibility.Visible, LanguageController.Translation("PACKET_HANDLER_ERROR_MESSAGE"));
_mainWindowViewModel.StopTracking();
return(false);
}
}
private void StartReceiver()
{
ReceiverHooks hooks = new ReceiverHooks
{
OnMessageReceived = data => Coordinator?.Handle(data)
};
Receiver =
new ReceiverBuilder()
.WithDefinition(new MessageDefinition())
.Build(hooks);
}
public void ThenBuilderCreatesValidReceiver()
{
// Arrange
Receiver settingReceiver = CreateDefaultReceiverSettings();
// Act
IReceiver receiver = new ReceiverBuilder().SetSettings(settingReceiver).Build();
// Assert
Assert.NotNull(receiver);
Assert.IsType <FileReceiver>(receiver);
}
public void CreateReceiver(MonoBehaviour target, ReceiverBuilder receivers)
{
var provider = ReceiverComponentBuilder.FindProvider(target, type, ReceiverComponentBuilder.TypeProvider);
if (provider != null)
{
DelegateReceiverCreator.Create(provider, this, target, receivers);
}
else
{
Debug.LogError($"Unable to find {nameof(Provider)}<{type.GetFriendlyName()}> for {target.GetType().Name} named '{target.name}'", target);
}
}
public static void StopNetworkCapture()
{
foreach (var device in _capturedDevices.Where(device => device.Started))
{
Task.Run(() =>
{
device.StopCapture();
device.Close();
builder = null;
});
}
_capturedDevices.Clear();
}
private static Agent CreateAgentBaseFromSettings(IRegistry registry, AgentConfig config)
{
string agentLogTag = $"{config.Type} Agent {config.Name}";
if (config.Settings == null)
{
throw new ArgumentNullException(nameof(config.Settings), $@"{agentLogTag} hasn't got valid Settings");
}
if (config.Settings.Receiver?.Type == null)
{
throw new ArgumentNullException(nameof(config.Settings.Receiver.Type), $@"{agentLogTag} hasn't got a Receiver.Type");
}
if (config.Settings.Transformer?.Type == null)
{
throw new ArgumentNullException(nameof(config.Settings.Transformer.Type), $@"{agentLogTag} hasn't got a Transformer.Type");
}
if (config.Settings.StepConfiguration?.NormalPipeline != null &&
config.Settings.StepConfiguration.NormalPipeline.Count(s => s?.Type == null) > 0)
{
throw new ArgumentNullException(
nameof(config.Settings.StepConfiguration.NormalPipeline),
$@"{agentLogTag} has one ore more Steps in the NormalPipeline without a Type");
}
if (config.Settings.StepConfiguration?.ErrorPipeline != null &&
config.Settings.StepConfiguration.ErrorPipeline?.Count(s => s?.Type == null) > 0)
{
throw new ArgumentNullException(
nameof(config.Settings.StepConfiguration.ErrorPipeline),
$@"{agentLogTag} has one or more Steps in the ErrorPipeline without a Type");
}
IReceiver receiver =
new ReceiverBuilder()
.SetSettings(config.Settings.Receiver)
.Build();
return(new Agent(
config: config,
receiver: receiver,
transformerConfig: config.Settings.Transformer,
exceptionHandler: ExceptionHandlerRegistry.GetHandler(config.Type),
stepConfiguration: config.Settings.StepConfiguration ?? GetDefaultStepConfigurationForAgentType(config.Type),
journalLogger: new JournalDatastoreLogger(registry.CreateDatastoreContext)));
}
public static bool StartNetworkCapture(MainWindowViewModel mainWindowViewModel, TrackingController trackingController, ValueCountUpTimer valueCountUpTimerTimer)
{
try
{
_mainWindowViewModel = mainWindowViewModel;
builder = ReceiverBuilder.Create();
builder.AddEventHandler(new TakeSilverEventHandler());
builder.AddEventHandler(new UpdateFameEventHandler(trackingController, valueCountUpTimerTimer.FameCountUpTimer));
builder.AddEventHandler(new UpdateMoneyEventHandler(trackingController, valueCountUpTimerTimer.SilverCountUpTimer));
builder.AddEventHandler(new UpdateReSpecPointsEventHandler(trackingController, valueCountUpTimerTimer.ReSpecPointsCountUpTimer));
builder.AddEventHandler(new DiedEventHandler(trackingController));
builder.AddEventHandler(new NewLootChestEventHandler(trackingController));
builder.AddEventHandler(new LootChestOpenedEventHandler(trackingController));
builder.AddEventHandler(new InCombatStateUpdateEventHandler(trackingController));
builder.AddEventHandler(new NewShrineEventHandler(trackingController));
builder.AddResponseHandler(new ChangeClusterResponseHandler());
builder.AddEventHandler(new HealthUpdateEventHandler(trackingController));
builder.AddEventHandler(new PartyDisbandedEventHandler());
builder.AddEventHandler(new NewCharacterEventHandler());
builder.AddEventHandler(new PartySilverGainedEventHandler());
//builder.AddEventHandler(new NewLootEventHandler());
//builder.AddResponseHandler(new TestHandler());
//builder.AddEventHandler(new TestHandler2());
//builder.AddRequestHandler(new TestHandler3());
builder.AddResponseHandler(new JoinResponseHandler(trackingController, _mainWindowViewModel));
_receiver = builder.Build();
_capturedDevices.AddRange(CaptureDeviceList.Instance);
return(StartDeviceCapture());
}
catch (Exception e)
{
Log.Error(nameof(StartDeviceCapture), e);
_mainWindowViewModel.SetErrorBar(Visibility.Visible, LanguageController.Translation("PACKET_HANDLER_ERROR_MESSAGE"));
_mainWindowViewModel.StopTracking();
return(false);
}
}
/// <summary>
/// Returns an action that invokes the getter chain and passes the result
/// to the given delegate.
/// </summary>
public Action <T> Wrap <T>(Delegate d, ReceiverBuilder receivers)
{
IDelegateProvider getter = new DelegateGetter(d);
for (int i = accessors.Length - 1; i >= 0; i--)
{
if (typeof(Provider).IsAssignableFrom(accessors[i].Method.ReturnType))
{
getter = new ProviderGetter(accessors[i], getter, receivers);
}
else
{
getter = new ReflectionGetterMethod(accessors[i], getter);
}
}
return(getter.GetTypedDelegate <T>());
}
public Action <T> CreateDelegate <T>(object target, ReceiverBuilder receivers)
{
var d = method.CreateDelegate(Expression.GetActionType(methodType), target);
if (getters != null)
{
return(getters.Wrap <T>(d, receivers));
}
try
{
return((Action <T>)d);
}
catch (Exception e)
{
var obj = target as Component;
Debug.LogError($"Receiver creation failed for {obj.name} ({obj.GetType().Name}:{method.Name}) when casting from {d.GetType().GetFriendlyName()} to {typeof(Action<T>).GetFriendlyName()}: {e.Message} {e.StackTrace}", obj);
return(null);
}
}
public OutcomeLowEventsSource(ReceiverBuilder builder)
{
foreach (OperationCodes code in Enum.GetValues(typeof(OperationCodes)))
{
switch (code)
{
case OperationCodes.Ping:
case OperationCodes.Unused:
//case OperationCodes.CastCancel:
//case OperationCodes.QueryGuildPlayerStats:
//case OperationCodes.ChannelingCancel:
//case OperationCodes.RatingDoRate:
break;
default:
var requestHandler = new CustomRequestHandler(code);
requestHandler.OnEvent += RequestHandler_OnEvent;
builder.AddRequestHandler(requestHandler);
break;
}
}
}
private DelegateReceiverCreator(ReceiverCreator receiverCreator, object Target, ReceiverBuilder receivers)
{
this.receiverCreator = receiverCreator;
this.target = Target;
this.receivers = receivers;
}
public static void Create(Provider provider, ReceiverCreator receiverCreator, object target, ReceiverBuilder receivers)
{
var delegateProvider = new DelegateReceiverCreator(receiverCreator, target, receivers);
provider.Register(delegateProvider);
}
