/// <summary>
/// Constructor for client support
/// </summary>
/// <param name="sizeOfRawBuffer"> The size of the raw buffer </param>
/// <param name="userArg"> A Reference to the Users arguments </param>
/// <param name="messageHandler"> Reference to the user defined message handler method </param>
/// <param name="closeHandler"> Reference to the user defined close handler method </param>
/// <param name="errorHandler"> Reference to the user defined error handler method </param>
public SocketClient(int sizeOfRawBuffer, object userArg,
MessageHandler messageHandler, CloseHandler closeHandler,
ErrorHandler errorHandler, ConnectHandler connectHandler)
{
// Create the raw buffer
this.SizeOfRawBuffer = sizeOfRawBuffer;
this.RawBuffer = new Byte[this.SizeOfRawBuffer];
// Save the user argument
this.userArg = userArg;
// Set the handler methods
this.messageHandler = messageHandler;
this.closeHandler = closeHandler;
this.errorHandler = errorHandler;
this.connectHandler = connectHandler;
// Set the async socket method handlers
this.callbackReadMethod = new AsyncCallback(ReceiveComplete);
this.callbackWriteMethod = new AsyncCallback(SendComplete);
this.callbackWriteHeadMethod = new AsyncCallback(SendHead);
this.m_Connected = true;
// Init the dispose flag
this.disposed = false;
}
static void StartConsumers()
{
var messageHandler = new MessageHandler();
//Start four consumers.
var consumer1 = new Consumer("Consumer1", "group1").Subscribe("SampleTopic").Start(messageHandler);
var consumer2 = new Consumer("Consumer2", "group1").Subscribe("SampleTopic").Start(messageHandler);
var consumer3 = new Consumer("Consumer3", "group1").Subscribe("SampleTopic").Start(messageHandler);
var consumer4 = new Consumer("Consumer4", "group1").Subscribe("SampleTopic").Start(messageHandler);
//Below to wait for consumer balance.
var scheduleService = ObjectContainer.Resolve<IScheduleService>();
var waitHandle = new ManualResetEvent(false);
var taskId = scheduleService.ScheduleTask(() =>
{
var c1AllocatedQueueIds = consumer1.GetCurrentQueues().Select(x => x.QueueId);
var c2AllocatedQueueIds = consumer2.GetCurrentQueues().Select(x => x.QueueId);
var c3AllocatedQueueIds = consumer3.GetCurrentQueues().Select(x => x.QueueId);
var c4AllocatedQueueIds = consumer4.GetCurrentQueues().Select(x => x.QueueId);
if (c1AllocatedQueueIds.Count() == 1 && c2AllocatedQueueIds.Count() == 1 && c3AllocatedQueueIds.Count() == 1 && c4AllocatedQueueIds.Count() == 1)
{
Console.WriteLine(string.Format("Consumer message queue allocation result: c1:{0}, c2:{1}, c3:{2}, c4:{3}",
string.Join(",", c1AllocatedQueueIds),
string.Join(",", c2AllocatedQueueIds),
string.Join(",", c3AllocatedQueueIds),
string.Join(",", c4AllocatedQueueIds)));
waitHandle.Set();
}
}, 1000, 1000);
waitHandle.WaitOne();
scheduleService.ShutdownTask(taskId);
}
public App()
: base()
{
handler = new MOCKMessageHandler();
handler.connectTo("127.0.0.1", 50000);
//handler.sendRequest("SET_NAME,BrendanRusso");
Debug.WriteLine(handler.getResponse());
handler.sendRequest("PUT,BrendanRusso,3,1");
Debug.WriteLine(handler.getResponse());
player1Window = new MainWindow();
player2Window = new MainWindow();
player1Window.Title = "Player 1 Window";
player2Window.Title = "Player 2 Window";
player2Window.enableIpSet();
//Wires handlers
wireHandlers(player1Window);
wireHandlers(player2Window);
player1Window.AddSetNameMenuItemHandler(HandleSetNamePlayer1MenuItem);
player2Window.AddSetNameMenuItemHandler(HandleSetNamePlayer2MenuItem);
//player1Window.AddIPAddressMenuItemHandler(HandleIPAddressMenuItem);
//player1Window.GameBoard.AddMouseHandler(HandleMouseEvent);
player1Window.Show();
player2Window.Show();
}
public void Run_in_test()
{
var streamer = EnvelopeStreamer.CreateDefault(typeof(CreateCustomer), typeof(CustomerCreated));
var builder = new CqrsEngineBuilder(streamer);
var account = new MemoryAccount();
var nuclear = account.CreateNuclear();
var inbox = account.CreateInbox("input");
var sender = account.CreateSimpleSender(streamer, "input");
var handler = new MessageHandler();
handler.WireToLambda<CreateCustomer>(customer => Consume(customer, nuclear, sender));
handler.WireToLambda<CustomerCreated>(m => Console.WriteLine("Created!"));
builder.Handle(inbox, handler.HandleEnvelope);
using (var engine = builder.Build())
{
sender.SendOne(new CreateCustomer
{
CustomerId = 1,
CustomerName = "Rinat Abdullin"
});
engine.RunForever();
}
}
public App()
: base()
{
// create long-lived objects
handler = new MOCKMessageHandler();
player1Window = new MainWindow();
player1Window.Title = "Player1";
player2Window = new MainWindow();
player2Window.Title = "Player2";
timer = new DispatcherTimer();
timer.Interval = TimeSpan.FromSeconds(1);
// wire up event handler
player1Window.AddIPAddressMenuItemHandler(HandleIPAddressMenuItemForPlayer1);
player2Window.AddIPAddressMenuItemHandler(HandleIPAddressMenuItemForPlayer2);
player1Window.AddNameMenuItemHandler(HandleNameMenuItemForPlayer1);
player2Window.AddNameMenuItemHandler(HandleNameMenuItemForPlayer2);
player1Window.GameBoard.AddMouseHandler(HandleMouseEventForPlayer1);
player2Window.GameBoard.AddMouseHandler(HandleMouseEventForPlayer2);
// show the Views
player1Window.Show();
player2Window.Show();
timer.Start();
}
public void AddSessionHandler(SocketAsyncEventArgs e,NetInterface netif,MessageHandler handler)
{
long sessionID = Convert.ToInt64(e.UserToken);
SessionHandler sh = new SessionHandler(sessionID,e, netif, handler);
m_dicSessionHandler.Add(sessionID,sh);
PushSessionBuffer(e);
}
public static void RegisterTriggerRule(MessageHandler c, TestTriggerCondition f)
{
lock (hashMutex)
{
hash.Add(c, f);
}
}
public IDisposable Subscribe(MessageHandler messageHandler)
{
lock (_handlers)
{
_handlers.Add(messageHandler);
_handlersSnapshot = _handlers.ToArray();
if (_underlying == null)
{
_underlying = OnRegister(message =>
{
lock (_handlers)
{
foreach (var handler in _handlersSnapshot)
{
handler(message);
}
}
});
}
}
return new AnonymousDisposable(() =>
{
lock (_handlers)
{
_handlers.Remove(messageHandler);
_handlersSnapshot = _handlers.ToArray();
if (_handlers.Count == 0)
{
_underlying.Dispose();
_underlying = null;
}
}
});
}
ConnectorConfig(MessageHandler handler)
{
m_bAutoReConnect = false;
m_iAutoTime = 0;
m_handler = handler;
//m_Connectact = NULL;
}
static void StartConsumers()
{
var messageHandler = new MessageHandler();
//Start four consumers.
var consumerSetting = new ConsumerSetting { HeartbeatBrokerInterval = 1000, UpdateTopicQueueCountInterval = 1000, RebalanceInterval = 1000 };
var consumer1 = new Consumer("Consumer1", "group1", consumerSetting).Subscribe("SampleTopic").SetMessageHandler(messageHandler).Start();
var consumer2 = new Consumer("Consumer2", "group1", consumerSetting).Subscribe("SampleTopic").SetMessageHandler(messageHandler).Start();
var consumer3 = new Consumer("Consumer3", "group1", consumerSetting).Subscribe("SampleTopic").SetMessageHandler(messageHandler).Start();
var consumer4 = new Consumer("Consumer4", "group1", consumerSetting).Subscribe("SampleTopic").SetMessageHandler(messageHandler).Start();
//Below to wait for consumer balance.
_logger.Info("Start consumer load balance, please wait for a moment.");
var scheduleService = ObjectContainer.Resolve<IScheduleService>();
var waitHandle = new ManualResetEvent(false);
var taskId = scheduleService.ScheduleTask("WaitQueueAllocationComplete", () =>
{
var c1AllocatedQueueIds = consumer1.GetCurrentQueues().Select(x => x.QueueId);
var c2AllocatedQueueIds = consumer2.GetCurrentQueues().Select(x => x.QueueId);
var c3AllocatedQueueIds = consumer3.GetCurrentQueues().Select(x => x.QueueId);
var c4AllocatedQueueIds = consumer4.GetCurrentQueues().Select(x => x.QueueId);
if (c1AllocatedQueueIds.Count() == 1 && c2AllocatedQueueIds.Count() == 1 && c3AllocatedQueueIds.Count() == 1 && c4AllocatedQueueIds.Count() == 1)
{
_logger.Info(string.Format("Consumer load balance finished. Queue allocation result: c1:{0}, c2:{1}, c3:{2}, c4:{3}",
string.Join(",", c1AllocatedQueueIds),
string.Join(",", c2AllocatedQueueIds),
string.Join(",", c3AllocatedQueueIds),
string.Join(",", c4AllocatedQueueIds)));
waitHandle.Set();
}
}, 1000, 1000);
waitHandle.WaitOne();
scheduleService.ShutdownTask(taskId);
}
public ConnectionHandler(Client mainForm)
{
this.mainForm = mainForm;
ServerSocket = new TcpClient();
messageHandler = new MessageHandler();
PacketManager.DefineOpcodeHandlers();
}
public ShellViewModel(IEventAggregator eventAggregator, MessageHandler messageHandler)
{
this.eventAggregator = eventAggregator;
LogMessages = new BindableCollection<LogEntry>();
ViewAttached += OnViewAttachedEventHandler;
}
public static void AddListener(MessageHandler handler)
{
lock (s_mutex)
{
Message += handler;
}
}
public SessionHandler(long sessionID, object sessionObject, NetInterface netIF,MessageHandler del)
{
m_sessionID = sessionID;
m_sessionObject = sessionObject;
m_interface = netIF;
m_handler = del;
}
public static void RemoveListener(MessageHandler handler)
{
lock (s_mutex)
{
Message -= handler;
}
}
public IDisposable Subscribe(ISelectionExpression selectionExpression, MessageHandler messageHandler)
{
// We could share the subscription here based on the selectionExpression. However, we'd need
// to make ISelectionExpression and its sub types have structural comparison. It isn't
// obvious that there will be any sharing.
return OnRegister(selectionExpression, messageHandler);
}
/// <summary>
/// Initializes a new instance of the <see cref="TcpChannel" /> class.
/// </summary>
/// <param name="readBuffer">Buffer used for our reading.</param>
/// <param name="encoder">Used to encode messages before they are put in the MicroMessage body of outbound messages.</param>
/// <param name="decoder">
/// Used to decode the body of incoming MicroMessages. The <c>MessageReceived</c> delegate will be
/// overridden by this class.
/// </param>
public TcpChannel(IBufferSlice readBuffer, IMessageEncoder encoder, IMessageDecoder decoder) {
if (readBuffer == null) throw new ArgumentNullException("readBuffer");
if (encoder == null) throw new ArgumentNullException("encoder");
if (decoder == null) throw new ArgumentNullException("decoder");
_readArgs = new SocketAsyncEventArgs();
_readArgs.SetBuffer(readBuffer.Buffer, readBuffer.Offset, readBuffer.Capacity);
_readArgs.Completed += OnReadCompleted;
_readArgsWrapper = new SocketAsyncEventArgsWrapper(_readArgs);
_encoder = encoder;
_decoder = decoder;
_decoder.MessageReceived = OnMessageReceived;
_writeArgs = new SocketAsyncEventArgs();
_writeArgs.Completed += OnSendCompleted;
_writeArgsWrapper = new SocketAsyncEventArgsWrapper(_writeArgs);
_sendCompleteAction = (channel, message) => { };
_disconnectAction = (channel, exception) => { };
ChannelFailure = (channel, error) => HandleDisconnect(SocketError.ProtocolNotSupported);
RemoteEndpoint = EmptyEndpoint.Instance;
ChannelId = GuidFactory.Create().ToString();
Data = new ChannelData();
}
/// <summary>
/// Receive one message from the broadcast buffer.
/// </summary>
/// <param name="handler"> to be called for each message received. </param>
/// <returns> the number of messages that have been received. </returns>
public virtual int Receive(MessageHandler handler)
{
var messagesReceived = 0;
var receiver = _receiver;
var lastSeenLappedCount = receiver.LappedCount();
if (receiver.ReceiveNext())
{
if (lastSeenLappedCount != receiver.LappedCount())
{
throw new InvalidOperationException("Unable to keep up with broadcast buffer");
}
var length = receiver.Length();
var capacity = _scratchBuffer.Capacity;
if (length > capacity)
{
throw new InvalidOperationException($"Buffer required size {length:D} but only has {capacity:D}");
}
var msgTypeId = receiver.TypeId();
_scratchBuffer.PutBytes(0, receiver.Buffer(), receiver.Offset(), length);
if (!receiver.Validate())
{
throw new InvalidOperationException("Unable to keep up with broadcast buffer");
}
handler(msgTypeId, _scratchBuffer, 0, length);
messagesReceived = 1;
}
return messagesReceived;
}
public void CalculateMaxDispatchUsers_Returns7AsStub()
{
var handler = new MessageHandler( new Mock<IRepository>().Object );
var result = handler.CalculateMaxDispatchUsers();
Assert.AreEqual( 7, result );
}
public static void UnregisterTriggerRule(MessageHandler c, TestTriggerCondition f)
{
lock (hashMutex)
{
if (hash.ContainsKey(c) && hash[c] == f)
hash.Remove(c);
}
}
/// <summary>
/// Add a new handler to the handler queue.
/// </summary>
/// <returns>A registration. Dispose to unregister.</returns>
public IDisposable AddHandler(MessageHandler handler)
{
lock (handlersLock)
{
handlers.Add(handler);
return new HandlerRegistration(this, handler);
}
}
private void On(MessageHandler handler, string msg)
{
// check for subsriptions, if some, do some!
if (handler != null)
handler(this, msg);
SimpleErrorLogger.Trace(msg);
}
public void Connect(MessageHandler handler)
{
ThrowIfDisposed();
var wasStarted = Interlocked.CompareExchange(ref _started, 1, 0);
if (wasStarted != 0) return;
_lookupTimer = new System.Threading.Timer(LookupTask, handler, TimeSpan.Zero, _options.LookupPeriod);
}
/// <summary>
/// Start listening to run messages, returning the current list of messages.
/// </summary>
/// <param name="handler">The <see cref="MessageHandler" /> called when a message is added</param>
/// <returns>The current list of messages</returns>
public string[] StartListening( MessageHandler handler )
{
lock ( _alMessages )
{
Message += handler;
return AllMessages;
}
}
protected override void BackgroundDispatchAndWait (MessageHandler handler)
{
if (InvokeBackgroundDispatchAndWaitImmediately) {
handler.Invoke ();
} else {
BackgroundDispatchersQueued.Add (handler);
}
}
public void Send_Click(object sender, EventArgs e)
{
MessageHandler msgHandler = new MessageHandler();
if (!(String.IsNullOrEmpty(messageBox.Text)))
msgHandler.SendMessage(currentlyLoggedUserID, visitedUserId, "", Server.HtmlEncode(messageBox.Text));
messageBox.Text = string.Empty;
Response.Redirect(Request.RawUrl);
}
public DebuggerWindow(DebuggerPlugin plugin)
{
Plugin = plugin;
DebuggerMessageHandler = new MessageHandler(this);
Plugin.RegisterMessageHandler(DebuggerMessageHandler);
_breakPointSetter = new BreakPointSetter(this);
_interactive = new Interactive(this);
InitializeComponent();
}
IEnumerator Start()
{
Application.runInBackground = true;
id = System.Guid.NewGuid().ToString();
lastPos = new PlayerPosition (id, 0, 0, 0);
posQ.AddPosition (new PlayerPosition (id, 0, 0, 0));
mh = new MessageHandler ();
yield return StartCoroutine(mh.startListening ());
}
public void Initialise(UserInterface userInterface)
{
UserInterface = userInterface;
Connection = gameObject.AddComponent<Connection>();
MessageHandler = new MessageHandler(Connection);
Messenger = new Messenger(Connection);
MessageHandler.OnAny += MessageHandler_OnMessage;
}
public SocketIO(Socket client, int bufferSize, MessageHandler mh, CloseHandler ch, ErrorHandler eh, string ip, int port)
: this(bufferSize, mh, ch, eh)
{
this.ip = ip;
this.port = port;
clientSocket = client;
ns = tcpClient.GetStream();
Receive();
}
protected virtual void BackgroundDispatchAndWait(MessageHandler handler)
{
DispatchService.BackgroundDispatchAndWait(handler);
}
public void SetEventDefaultHandler(MessageHandler functionsMessageHandler)
{
this.handler = functionsMessageHandler;
}
public void setIncomingMessageHandler(MessageHandler messageHandler)
{
this.incomingHandler = messageHandler;
}
protected virtual void GuiSyncDispatch(MessageHandler handler)
{
DispatchService.GuiSyncDispatch(handler);
}
/// <summary>
/// Initialization logic on app startup
/// </summary>
public override async Task Init()
{
AuthEndpoint = new IPEndPoint(NetUtility.Resolve(Globals.Values.DefaultAuthAddress),
Globals.Values.DefaultAuthPort); // Find the address of the auth server
TokenKeys = new Token();
// Create new instance of configs. Parameter is "application Id". It has to be same on client and server.
Config = new NetPeerConfiguration(Globals.Strings.NetworkID);
// Create message handler (So events are initialized, but don't start it)
Handler = new MessageHandler(this);
// Create new client, with previously created configs
NetClient = new NetClient(Config);
NetClient.Start();
Handler.Start();
// ReSharper disable BitwiseOperatorOnEnumWithoutFlags
Config.EnableMessageType(NetIncomingMessageType.ConnectionApproval
| NetIncomingMessageType.Data
| NetIncomingMessageType.ConnectionLatencyUpdated
| NetIncomingMessageType.StatusChanged
| NetIncomingMessageType.UnconnectedData);
// Listen for init response from auth server containing token keys
Client.Events.Network.Auth.InitReceived.AddHandler(args =>
{
TokenKeys.Username = args.Username;
TokenKeys.UUID = args.UUID;
TokenKeys.PrivateKey = args.PrivateKey;
TokenKeys.PublicKey = args.PublicKey;
});
// Listen for verification result from the auth server
Client.Events.Network.Auth.Verified.AddHandler(async args =>
{
if (args.Verified)
{
Debug.WriteLine("Session verification Successful");
await Join(host, port, TokenKeys.Username, TokenKeys.UUID, TokenKeys.PublicKey);
// Start connection process with game server once it gets session verification from the auth server
}
else
{
Debug.WriteLine("Session verification failed");
}
});
// Block place received message is invoked when the network message is received.
// If it is cancelled, it will not call the block placed message.
Client.Events.Network.Game.BlockPlaceMessageReceived.AddHandler(
args =>
{
Client.Events.Game.Level.BlockPlaced.Invoke(
new EventManager.GameEvents.LevelEvents.BlockPlacedEventArgs(args.Level, args.X, args.Y, args.Z,
args.Type, args.Level.Tiles[args.X, args.Y, args.Z].Type));
}, EventPriority.InternalFinal);
Client.Events.Game.Level.BlockPlaced.AddHandler(args =>
{
if (args.Level != null)
{
args.Level.Tiles.Tiles[args.X, args.Y, args.Z] = new Tile(args.Type);
}
});
await base.Init();
}
public ActionResult Callback(Entities.Request.PostModel postModel)
{
//此处的URL格式类型为：http://sdk.weixin.senparc.com/Open/Callback/$APPID$， 在RouteConfig中进行了配置，你也可以用自己的格式，只要和开放平台设置的一致。
//处理微信普通消息，可以直接使用公众号的MessageHandler。此处的URL也可以直接填写公众号普通的URL，如本Demo中的/Weixin访问地址。
var logPath = Server.MapPath(string.Format("~/App_Data/Open/{0}/", DateTime.Now.ToString("yyyy-MM-dd")));
if (!Directory.Exists(logPath))
{
Directory.CreateDirectory(logPath);
}
postModel.Token = component_Token;
postModel.EncodingAESKey = component_EncodingAESKey; //根据自己后台的设置保持一致
postModel.AppId = component_AppId; //根据自己后台的设置保持一致
var maxRecordCount = 10;
MessageHandler <CustomMessageContext> messageHandler = null;
try
{
var checkPublish = false; //是否在“全网发布”阶段
if (checkPublish)
{
messageHandler = new OpenCheckMessageHandler(Request.InputStream, postModel, 10);
}
else
{
messageHandler = new CustomMessageHandler(Request.InputStream, postModel, maxRecordCount);
}
messageHandler.RequestDocument.Save(Path.Combine(logPath,
string.Format("{0}_Request_{1}.txt", DateTime.Now.Ticks, messageHandler.RequestMessage.FromUserName)));
messageHandler.Execute(); //执行
if (messageHandler.ResponseDocument != null)
{
var ticks = DateTime.Now.Ticks;
messageHandler.ResponseDocument.Save(Path.Combine(logPath,
string.Format("{0}_Response_{1}.txt", ticks,
messageHandler.RequestMessage.FromUserName)));
//记录加密后的日志
//if (messageHandler.UsingEcryptMessage)
//{
// messageHandler.FinalResponseDocument.Save(Path.Combine(logPath,
// string.Format("{0}_Response_Final_{1}.txt", ticks,
// messageHandler.RequestMessage.FromUserName)));
//}
}
return(new FixWeixinBugWeixinResult(messageHandler));
}
catch (Exception ex)
{
using (
TextWriter tw =
new StreamWriter(Server.MapPath("~/App_Data/Open/Error_" + DateTime.Now.Ticks + ".txt")))
{
tw.WriteLine("ExecptionMessage:" + ex.Message);
tw.WriteLine(ex.Source);
tw.WriteLine(ex.StackTrace);
//tw.WriteLine("InnerExecptionMessage:" + ex.InnerException.Message);
if (messageHandler.ResponseDocument != null)
{
tw.WriteLine(messageHandler.ResponseDocument.ToString());
}
if (ex.InnerException != null)
{
tw.WriteLine("========= InnerException =========");
tw.WriteLine(ex.InnerException.Message);
tw.WriteLine(ex.InnerException.Source);
tw.WriteLine(ex.InnerException.StackTrace);
}
tw.Flush();
tw.Close();
return(Content(""));
}
}
}
public RemoteDependencyAnalyzerClient(IUpdateableConfigProvider configProvider, string serviceAddress, MessageHandler traceMessageHandler)
: base(configProvider, traceMessageHandler)
{
_serviceAddress = serviceAddress ?? throw new ArgumentNullException(nameof(serviceAddress));
}
/// <summary>
/// Registers a handler on the receive endpoint that is completed after the specified handler is
/// executed and canceled if the test is canceled.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="configurator"></param>
/// <param name="handler"></param>
/// <returns></returns>
protected Task <ConsumeContext <T> > Handler <T>(IReceiveEndpointConfigurator configurator, MessageHandler <T> handler)
where T : class
{
return(BusTestHarness.Handler(configurator, handler));
}
static void Main(string[] args)
{
SerialPort _serialPort = new SerialPort("COM2", 9600, Parity.None, 8, StopBits.One);
_serialPort.Handshake = Handshake.None;
_serialPort.ReadTimeout = 1000;
_serialPort.WriteTimeout = 1000;
_serialPort.Open();
MessageHandler my_message_handler = new MessageHandler();
LynxaMessageInfo lynxa_message_info = new LynxaMessageInfo();
const string fileName = "LynxaMessage.dat";
BinaryWriter writer = new BinaryWriter(File.Open(fileName, FileMode.Create));
while (true)
{
try
{
int data = _serialPort.ReadByte();
if (data != -1)
{
writer.Write((byte)data);
lynxa_message_info = my_message_handler.ParsePacket((byte)data);
if (lynxa_message_info != null)
{
Console.WriteLine("------------------------------------");
LynxaMessageId lynxa_message_id = (LynxaMessageId)lynxa_message_info.messageId;
switch (lynxa_message_id)
{
case LynxaMessageId.GnggaMessage100Id:
GnggaMessage_100 nmeaRecord_100 = GnggaMessage_100.Parser.ParseFrom(lynxa_message_info.payloadBuffer);
Console.WriteLine("Nmea Record Received:");
Console.WriteLine($"epochTime:{nmeaRecord_100.EpochTime}");
Console.WriteLine($"LatitudeMinutes:{nmeaRecord_100.LatitudeMinutes}");
Console.WriteLine($"LatitudeDegrees:{nmeaRecord_100.LatitudeDegrees}");
Console.WriteLine($"LatitudeCardinalAscii:{nmeaRecord_100.LatitudeCardinalAscii}");
Console.WriteLine($"longitudeMinutes:{nmeaRecord_100.LongitudeMinutes}");
Console.WriteLine($"longitudeDegrees:{nmeaRecord_100.LongitudeDegrees}");
Console.WriteLine($"longitudeCardinalAscii:{nmeaRecord_100.LongitudeCardinalAscii}");
Console.WriteLine($"numberOfSatellitesInUse:{nmeaRecord_100.NumberOfSatellitesInUse}");
break;
case LynxaMessageId.WifiStationList102Id:
WifiStationList_102 wifiStationList_102 = WifiStationList_102.Parser.ParseFrom(lynxa_message_info.payloadBuffer);
Console.WriteLine($"epochTime:{wifiStationList_102.EpochTime}");
Console.WriteLine($"Number of Wifi Stations:{wifiStationList_102.NumberStationsFound}");
for (int i = 0; i < wifiStationList_102.NumberStationsFound; i++)
{
Console.Write($"BSSID:");
Console.Write($"{wifiStationList_102.WifiStations[i].Bssid[0]}:");
Console.Write($"{wifiStationList_102.WifiStations[i].Bssid[1]}:");
Console.Write($"{wifiStationList_102.WifiStations[i].Bssid[2]}:");
Console.Write($"{wifiStationList_102.WifiStations[i].Bssid[3]}:");
Console.Write($"{wifiStationList_102.WifiStations[i].Bssid[4]}:");
Console.Write($"{wifiStationList_102.WifiStations[i].Bssid[5]}\r\n");
Console.WriteLine($"RSSI:{wifiStationList_102.WifiStations[i].Rssi}");
}
break;
case LynxaMessageId.ModemParameters103Id:
ModemParameters_103 modemParameters_103 = ModemParameters_103.Parser.ParseFrom(lynxa_message_info.payloadBuffer);
Console.WriteLine("ModemParameters Received:");
Console.WriteLine($"epochTime:{modemParameters_103.EpochTime}");
Console.WriteLine($"CellId:{modemParameters_103.CellId}");
Console.WriteLine($"PLMN:{modemParameters_103.Plmn}");
Console.WriteLine($"TAC:{modemParameters_103.Tac}");
var result = LynxaDeviceMessageTranslator.TranslateModemParameters(modemParameters_103);
Console.WriteLine($"MCC:{result.MCC}");
Console.WriteLine($"MNC:{result.MNC}");
Console.WriteLine($"LAC:{result.LAC}");
break;
}
}
}
}
catch (TimeoutException te)
{
//do nothing
if (Console.KeyAvailable)
{
//save file and exit
writer.Close();
break;
}
}
}
}
public static void Main()
{
// preliminary tests
Console.WriteLine("Running preliminary tests...");
// testing unkown card equality
Card unknownCard = new UnknownCard();
Card card = new UnitCard(0, "Test Card", Faction.NONE, "Some text", "Some more text", 0, 0, 0, new AbilityList());
Console.WriteLine("Testing UnknownCard == Card: {0}", unknownCard == card ? "Success" : "Fail");
// testing cardloader
CardLoader cl = new CardLoader();
Card c = cl.GetByID("Mercenary Phantasm");
Console.WriteLine("Successfully Loaded Card.");
// BEGIN NETWORKING
//find local IP
IPHostEntry ipEntry = Dns.GetHostEntry(Dns.GetHostName());
IPAddress ipAddr = ipEntry.AddressList[0];
//consts
string HostName = ipAddr.ToString(); //by default, is using same local IP addr as server; assuming above process is deterministic
const int Port = 4011;
//setup the connection
Socket socket = new Socket(AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
socket.Connect(HostName, Port);
SocketManager socketManager = new SocketManager(socket, "</file>");
//setup game objects
GameManager gm;
Player localPlayer;
//join a game and do all the setup
Console.WriteLine("Press Enter to join a game...");
Console.ReadLine();
socketManager.Send("<file type='joinMatch'><deck id='myxorStarter'/></file>");
// get the matchStart message
Console.WriteLine("Waiting for match start...");
XmlDocument matchStartDoc;
do
{
matchStartDoc = socketManager.ReceiveXml();
}while(matchStartDoc == null);
// init the gamestate accordingly
Console.WriteLine("Initializing game state...");
int localPlayerIndex = 0;
List <XmlElement> playerIds = new List <XmlElement>();
foreach (XmlElement e in matchStartDoc.GetElementsByTagName("playerIds"))
{
if (e.Attributes["side"].Value == "local")
{
localPlayerIndex = playerIds.Count;
}
playerIds.Add(e);
}
List <XmlElement> laneIds = new List <XmlElement>();
foreach (XmlElement e in matchStartDoc.GetElementsByTagName("laneIds"))
{
laneIds.Add(e);
}
gm = new GameManager(playerIds: playerIds.ToArray(), laneIds: laneIds.ToArray());
localPlayer = gm.Players[localPlayerIndex];
// get the turnStart message
Console.WriteLine("Waiting for turn start...");
XmlDocument turnStartDoc;
do
{
turnStartDoc = socketManager.ReceiveXml();
}while(turnStartDoc == null);
Console.WriteLine("Applying turn start deltas...");
ProcessDeltas(turnStartDoc, cl, true);
// print the gamestate
foreach (Player p in gm.Players)
{
Console.WriteLine("\n{0} player has hand: {1}\n...deck: {2}\n", p == localPlayer? "Local" : "Enemy", p.Hand, p.Deck);
}
for (int i = 0; i < 10; i++)
{
// send a game action
Console.WriteLine("Press Enter to send a Player Action...");
Console.ReadLine();
XmlDocument playerActionDoc = MessageHandler.NewEmptyMessage("gameAction");
XmlElement playerActionElement = new PlayUnitCardAction(localPlayer.Hand[0] as UnitCard, gm.Lanes[0], 0, 0).ToXml(playerActionDoc);
playerActionDoc.DocumentElement.AppendChild(playerActionElement);
playerActionElement = new PlayUnitCardAction(localPlayer.Hand[1] as UnitCard, gm.Lanes[0], 0, 1).ToXml(playerActionDoc);
playerActionDoc.DocumentElement.AppendChild(playerActionElement);
socketManager.SendXml(playerActionDoc);
SimpleGetResponse(socketManager, true);
// end the turn and get back the end of turn deltas
Console.WriteLine("Press Enter to end turn...");
Console.Read();
socketManager.Send("<file type='lockInTurn'></file>");
Console.WriteLine("Waiting for response from server...");
SimpleGetResponse(socketManager, true);
}
// end the test
Console.WriteLine("Press Enter to disconnect...");
Console.ReadLine();
}
public void setOutgoingMessageHandler(MessageHandler messageHandler)
{
this.outgoingdHandler = messageHandler;
}
public async Task SetInputMessageHandlerAsync(string inputName, MessageHandler messageHandler, object userContext)
{
await ModuleClient.SetInputMessageHandlerAsync(inputName, messageHandler, userContext);
Log.Information($"Message Handler Set for {inputName}");
}
protected DependencyAnalyzerBase(IUpdateableConfigProvider configProvider, MessageHandler traceMessageHandler)
{
ConfigProvider = configProvider ?? throw new ArgumentNullException(nameof(configProvider));
TraceMessageHandler = traceMessageHandler;
}
protected virtual void GuiBackgroundDispatch(MessageHandler handler)
{
DispatchService.BackgroundDispatch(handler);
}
public EnemyController()
{
this.random = new Random();
this.messageHandler = new MessageHandler();
}
protected virtual void BackgroundDispatch(MessageHandler handler)
{
DispatchService.BackgroundDispatch(() => RunInternal());
}
protected void Add(IConnection conn, MessageHandler handler)
{
conn.OnMessageReceived += handler;
_Connections[conn.Name] = conn;
}
public DependencyAnalyzerFactory(ITypeDependencyEnumerator typeDependencyEnumerator, MessageHandler traceMessageHandler)
{
_typeDependencyEnumerator = typeDependencyEnumerator ?? throw new ArgumentNullException(nameof(typeDependencyEnumerator));
_traceMessageHandler = traceMessageHandler;
_configProviderFactory = new ConfigProviderFactory(_traceMessageHandler);
}
/// <inheritdoc/>
public void Register <TRecipient, TMessage, TToken>(TRecipient recipient, TToken token, MessageHandler <TRecipient, TMessage> handler)
where TRecipient : class
where TMessage : class
where TToken : IEquatable <TToken>
{
lock (this.recipientsMap)
{
// Get the <TMessage, TToken> registration list for this recipient
Mapping <TMessage, TToken> mapping = GetOrAddMapping <TMessage, TToken>();
var key = new Recipient(recipient);
ref DictionarySlim <TToken, object>?map = ref mapping.GetOrAddValueRef(key);
map ??= new DictionarySlim <TToken, object>();
// Add the new registration entry
ref object?registeredHandler = ref map.GetOrAddValueRef(token);
public void SendMessageToClient(string message)
{
MessageHandler.HandleSendingToAll(writer, message, netManager);
}
public abstract void onRegisterMessages(MessageHandler messageHandler);
/// <inheritdoc/>
public void Register <TRecipient, TMessage, TToken>(TRecipient recipient, TToken token, MessageHandler <TRecipient, TMessage> handler)
where TRecipient : class
where TMessage : class
where TToken : IEquatable <TToken>
{
lock (this.recipientsMap)
{
Type2 type2 = new Type2(typeof(TMessage), typeof(TToken));
// Get the conditional table for the pair of type arguments, or create it if it doesn't exist
ref RecipientsTable?mapping = ref this.recipientsMap.GetOrAddValueRef(type2);
mapping ??= new RecipientsTable();
// Get or create the handlers dictionary for the target recipient
var map = Unsafe.As <DictionarySlim <TToken, object> >(mapping.GetValue(recipient, _ => new DictionarySlim <TToken, object>()));
// Add the new registration entry
ref object?registeredHandler = ref map.GetOrAddValueRef(token);
static Backend()
{
messageHandler = new MessageHandler();
}
static void ShowMessage(string message, MessageHandler handler)
{
handler(message);
}
public void SendMessageToClient(string message, NetPeer peer)
{
MessageHandler.HandleSendingMessage(writer, message, peer);
}
public virtual void Disconnect(string reason, bool sendDisconnect = true)
{
MessageHandler?.Disconnect(reason, sendDisconnect);
Close();
}
public void ParseGameDataMessages(Byte[] frameData, Function <Byte, Byte> userMessageCallback)
{
Int64 gameDataStartOffset = fileStream.Position - frameData.Length;
// read game data frame into memory
bitBuffer = new BitBuffer(frameData);
readingGameData = true;
try
{
BeginMessageLog(gameDataStartOffset, frameData);
// start parsing messages
while (true)
{
Int32 messageFrameOffset = bitBuffer.CurrentByte;
Byte messageId = bitBuffer.ReadByte();
String messageName = Enum.GetName(typeof(MessageId), messageId);
if (messageName == null) // a user message, presumably
{
messageName = FindMessageIdString(messageId);
}
LogMessage(messageId, messageName, messageFrameOffset);
MessageHandler messageHandler = FindMessageHandler(messageId);
// Handle the conversion of user message id's.
// Used by demo writing to convert to the current network protocol.
if (messageId > 64 && userMessageCallback != null)
{
Byte newMessageId = userMessageCallback(messageId);
if (newMessageId != messageId)
{
// write the new id to the bitbuffer
bitBuffer.SeekBytes(-1);
bitBuffer.RemoveBytes(1);
bitBuffer.InsertBytes(new Byte[] { newMessageId });
}
}
// unknown message
if (messageHandler == null)
{
throw new ApplicationException(String.Format("Cannot find message handler for message id \"[{0}] {1}\"", messageId, messageName));
}
// callback takes priority over length
if (messageHandler.Callback != null)
{
messageHandler.Callback();
}
else if (messageHandler.Length != -1)
{
Seek(messageHandler.Length);
}
else
{
// user messages
if (messageId >= 64)
{
// All non-engine user messages start with a byte that is the number of bytes in the message remaining.
Byte length = bitBuffer.ReadByte();
Seek(length);
}
else
{
throw new ApplicationException(String.Format("Unknown message id \"{0}\"", messageId));
}
}
// Check if we've reached the end of the frame, or if any of the messages have called SkipGameDataFrame (readingGameData will be false).
if (bitBuffer.CurrentByte == bitBuffer.Length || !readingGameData)
{
break;
}
}
}
finally
{
readingGameData = false;
}
}
public static void BackgroundDispatch(MessageHandler cb)
{
QueueBackground(new GenericMessageContainer(cb, false));
}
/// <summary>
/// Unregisters the client status message handler.
/// </summary>
private void UnregisterMessageHandler()
{
MessageHandler.Unregister(_clientStatusHandler);
_clientStatusHandler.StatusUpdated -= SetStatusByClient;
_clientStatusHandler.UserStatusUpdated -= SetUserStatusByClient;
}
public void RegisterMessageCallback(Type msgType, MessageHandler handler)
{
}
