public ClientSession(INetworkClient client) { // set last received lastPacketReceive = DateTime.Now.Ticks; // lag mode _random = new Random((int)client.ClientId); // initialize lagging mode bool isLagMode = System.Configuration.ConfigurationManager.AppSettings["LagMode"].ToLower() == "true"; // initialize network client _client = client; // absolutely new instantiated Client has no SessionId SessionId = 0; // register for NetworkClient events _client.MessageReceived += OnNetworkClientMessageReceived; // start observer for receiving packets _receiveQueue = new ConcurrentQueue<byte[]>(); _receiveQueueObservable = Observable.Interval(new TimeSpan(0, 0, 0, 0, (isLagMode ? 1000 : 10))) .Subscribe(x => HandlePackets()); }
public bool UpdateLastInfo(IDatabase database, INetworkClient client) { var t2 = Functions.Time(); return(false); //database.ExecuteNonQuery($"UPDATE characters SET last_connection={t2} WHERE character_id={Id}") == 1; }
public GeolocalizationService(INetworkClient client, IButterflyMobileClient butterflyMobileClient) : base() { this.butterflyMobileClient = butterflyMobileClient; this.geolocalizationBackgroundWorker = new GeolocalizationBackgroundWorker(client, butterflyMobileClient); }
protected virtual ClientSession IntializeNewSession(INetworkClient client) { ClientSession session = new ClientSession(client); client.SetClientSession(session); return(session); }
/// <summary> /// Connect to specified debugger endpoint. /// </summary> /// <param name="uri">URI identifying the endpoint to connect to.</param> public void Connect(Uri uri) { Utilities.ArgumentNotNull("uri", uri); LiveLogger.WriteLine("Debugger connecting to URI: {0}", uri); Close(); lock (this._networkClientLock) { var connection_attempts = 0; const int MAX_ATTEMPTS = 5; while (true) { connection_attempts++; try { // TODO: This currently results in a call to the synchronous TcpClient // constructor, which is a blocking call, and can take a couple of seconds // to connect (with timeouts and retries). This code is running on the UI // thread. Ideally this should be connecting async, or moved off the UI thread. this._networkClient = this._networkClientFactory.CreateNetworkClient(uri); // Unclear if the above can succeed and not be connected, but check for safety. // The code needs to either break out the while loop, or hit the retry logic // in the exception handler. if (this._networkClient.Connected) { LiveLogger.WriteLine("Debugger connected successfully"); break; } else { throw new SocketException(); } } catch (Exception ex) { if (ex.IsCriticalException()) { throw; } LiveLogger.WriteLine("Connection attempt {0} failed with: {1}", connection_attempts, ex); if (this._isClosed || connection_attempts >= MAX_ATTEMPTS) { throw; } else { // See above TODO. This should be moved off the UI thread or posted to retry // without blocking in the meantime. For now, this seems the lesser of two // evils. (The other being the debugger failing to attach on launch if the // debuggee socket wasn't open quickly enough). System.Threading.Thread.Sleep(200); } } } } Task.Factory.StartNew(this.ReceiveAndDispatchMessagesWorker); Task.Factory.StartNew(this.SendPacketsWorker); }
public WorldInteraction(WorldModel world) { m_Network = ServiceRegistry.GetService<INetworkClient>(); m_UserInterface = ServiceRegistry.GetService<UserInterfaceService>(); m_World = world; }
public MainWindow(IButterflyWPFClient wpfClient, ISnackbarController snackbarController, INetworkClient networkClient, IRegionManager regionManager) { InitializeComponent(); Snackbar = this.MainSnackbar; networkClient.Connected += (sender, socket) => { snackbarController.Enqueue($"Podłączono do serwera {socket.RemoteEndPoint}"); }; networkClient.Disconnected += (sender, socket) => { snackbarController.Enqueue($"Rozłączono od serwera {socket.RemoteEndPoint}"); }; try { wpfClient.Start(); } catch (Exception ex) { snackbarController.Enqueue(ex); } }
internal Client(INetworkClient client, MatchConfig config) : base(client, config) { CurrentInput = new MatchInput(config); InputContext = new MatchInputContext(CurrentInput); NetworkClient.OnRecievedInputs += OnRecievedInputs; NetworkClient.OnRecievedState += OnRecievedState; }
public WorldInteraction(WorldModel world) { m_Network = UltimaServices.GetService <INetworkClient>(); m_UserInterface = UltimaServices.GetService <UserInterfaceService>(); World = world; }
internal static RequestClient Start(INetworkClient networkClient) { var client = new RequestClient(networkClient); client.StartReceiving(); return(client); }
/// <summary> /// Close connection. /// </summary> public void Close() { lock (_networkClientLock) { if (_networkClient != null) { _networkClient.Dispose(); _networkClient = null; } } }
protected override void Initialize() { base.Initialize(); Container.Register(Window); _network = Container.Resolve <INetworkClient>(); }
public static void OnAuthenticationTicketMessage(INetworkClient client, AuthenticationTicketMessage im) { client.Send(new AuthenticationTicketAcceptedMessage()); var accountId = client.GetEntity().GetComponent <AccountComponent>().AccountId; client.Send(new AccountCapabilitiesMessage(accountId)); }
/// <summary> /// Read a Base64 encoded line. /// </summary> /// <param name="client">The client to read from.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>The decoded Base64 string.</returns> async Task <string> ReadBase64EncodedLineAsync(INetworkClient client, CancellationToken cancellationToken) { var text = await client.ReadLineAsync(Encoding.ASCII, cancellationToken).ConfigureAwait(false); return(text == null ? String.Empty : Encoding.UTF8.GetString(Convert.FromBase64String(text))); }
public WorldCursor(WorldModel model) { _network = Service.Get <INetworkClient>(); _userInterface = Service.Get <UserInterfaceService>(); _input = Service.Get <IInputService>(); _world = model; InternalRegisterInteraction(); }
public User(INetworkClient _client) { this.client = _client; this.UserVariables = new Dictionary <string, IUserVariable>(); client.DataReceived += OnDataReceived; client.UserDisconnected += OnDisconnected; LogManager.GetCurrentClassLogger().Debug($"User connected!"); }
public void Remove(INetworkClient client) { lock (mutex) { clients.Remove(client.Id); client.Dispose(); } }
/// <summary> /// Constructor. /// </summary> /// <param name="options">The server options.</param> /// <param name="tcpClient">The TCP client that the session is connected with.</param> /// <param name="networkClient">The network client to use for communications.</param> internal SmtpSessionContext(ISmtpServerOptions options, TcpClient tcpClient, INetworkClient networkClient) { ServerOptions = options; Transaction = new SmtpMessageTransaction(); RemoteEndPoint = tcpClient.Client.RemoteEndPoint; NetworkClient = networkClient; Properties = new Dictionary <string, object>(); }
public override Task <DemoRpcMessageResponse> ProcessRequestOnClient(INetworkClient client, DemoRpcMessage request) { Debug.Log($"Client got message: {request.message}"); return(Task.FromResult(new DemoRpcMessageResponse() { success = true, })); }
public void OnReceived(INetworkClient client, Packet receivedPacket) { string dataReceived = StringFromByteArr(receivedPacket.PacketRaw); Program.AddLog("Received: " + dataReceived); Program.g_MsgReceiver.ReceivedMsg(dataReceived); return; }
public Task HandleAsync(INetworkClient client, ServerPacket packet) { client.IsReady = true; this.logger.LogDebug("Hello Packet Received"); this.messageBus.Send("hello", client); return(Task.CompletedTask); }
public override Task <DemoRpcSetUsernameResponse> ProcessRequestOnClient(INetworkClient client, DemoRpcSetUsername request) { return(Task.FromResult(new DemoRpcSetUsernameResponse() { success = false, errorMessage = "Not supported" })); }
protected override void Initialize() { base.Initialize(); Container.Register(Window); _network = Container.Resolve<INetworkClient>(); }
public MainWindowViewModel(IButterflyWPFClient wpfClient, INetworkClient netClient, WPFPingPacketHandler pingPacket) : base(wpfClient, netClient, pingPacket) { this.wpfClient.Start(); this.ClickCommand = new DelegateCommand(this.Send); }
public override void ReceivedPacket(INetworkClient client, AgentServerPacket packet) { Logger.Info("Received opcode: " + packet.Opcode + " (" + packet.Opcode.ToHex() + ")"); switch (packet.Opcode) { case AgentServerOpcodes.Hello: { var unk0 = packet.Data.ReadUInt32(); client.Account.ClientInstance = packet.Data.ReadUInt32(); client.Account.Id = packet.Data.ReadUInt32(); var charId = (uint)0; /*Database.ExecuteScalar<long>( * "SELECT characterid FROM clientinstances " + * "WHERE Accountid=" + client.Account.Id + " AND clientinst=" + * client.Account.ClientInstance);*/ client.Character = new Character(charId); client.Character.LoadDetailsFromDatabase(Database); new ConanStream() .WriteUInt32(0x00050000) .Send(client); new ConanStream() .WriteUInt16(AgentServerRespondsOpcodes.Ox0014) .WriteArrayPrependLengthUInt16(new ConanStream() .WriteUInt32(client.Account.ClientInstance) .WriteUInt32(0x00000000) .WriteString(client.Character.Name.Length > 0 ? client.Character.Name : "Character" + client.Account.ClientInstance)) .Send(client); // "<localized category=20000 token=\"welcome_message\">" SendSystemMessage(client, Settings.WelcomeString); SendSystemMessage(client, Statics.BuildInfo.Replace("\n", "<br />")); new ConanStream() .WriteUInt16(AgentServerRespondsOpcodes.Ox003C) .WriteArrayPrependLengthUInt16(new ConanStream() .WriteByte(0x04) .WriteUInt32(0x0000232a) .WriteString("~Trial") .WriteUInt32(0x00008044) .WriteUInt16(0x0000)) .Send(client); break; } default: { Logger.Warning("Unknown packet: " + packet); break; } } }
/// <summary> /// Writes a line to the client stream. /// </summary> /// <param name="client">The stream to write the line to.</param> /// <param name="text">The text to write to the client stream.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>A task which asynchronously performs the operation.</returns> public static Task WriteLineAsync(this INetworkClient client, string text, CancellationToken cancellationToken = default) { if (client == null) { throw new ArgumentNullException(nameof(client)); } return(WriteLineAsync(client, text, Encoding.ASCII, cancellationToken)); }
public WorldCursor(WorldModel model) { m_Network = ServiceRegistry.GetService <INetworkClient>(); m_UserInterface = ServiceRegistry.GetService <UserInterfaceService>(); m_Input = ServiceRegistry.GetService <InputManager>(); m_World = model; InternalRegisterInteraction(); }
/// <summary> /// Read a line from the byte stream. /// </summary> /// <param name="client">The stream to write the line to.</param> /// <param name="text">The text to write to the client stream.</param> /// <param name="encoding">The encoding to use when converting the bytes to a text representation.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>A task which asynchronously performs the operation.</returns> public static Task WriteLineAsync(this INetworkClient client, string text, Encoding encoding, CancellationToken cancellationToken = default(CancellationToken)) { if (client == null) { throw new ArgumentNullException(nameof(client)); } return(client.WriteAsync(encoding.GetBytes(text + Environment.NewLine), cancellationToken)); }
public InsecureNetworkNotification( INetworkClient networkClient, InsecureWifiNotificationViewModel insecureWifiNotificationViewModel, IEventAggregator eventAggregator) { _eventAggregator = eventAggregator; _insecureWifiNotificationViewModel = insecureWifiNotificationViewModel; networkClient.WifiChangeDetected += OnWifiChangeDetected; }
public WorldCursor(WorldModel model) { m_Network = ServiceRegistry.GetService<INetworkClient>(); m_UserInterface = ServiceRegistry.GetService<UserInterfaceService>(); m_Input = ServiceRegistry.GetService<InputManager>(); m_World = model; InternalRegisterInteraction(); }
public LocationApplicationService(IGatewayClient gatewayClient, ISensorClient sensorClient, INetworkClient networkClient, IMapper mapper, INetworkLocationClient networkLocationClient) { _sensorClient = sensorClient; _gatewayClient = gatewayClient; _networkClient = networkClient; _mapper = mapper; _networkLocationClient = networkLocationClient; }
void Connect(string endpoint) { client = NetworkFactory.CreateNetworkClient <TcpNetworkClient> (); //client = NetworkFactory.CreateNetworkClient<RoomClientBridge> (); client.MessageHandler += (msg) => { RecieveMessage(msg); }; client.Connect(endpoint); }
/// <summary> /// Initializes a new instance of the <see cref="Channel{TController}"/> class. /// </summary> /// <param name="controller">The controller.</param> /// <param name="networkClient">The e.</param> public Channel(INetworkClient networkClient, IMessageParser messageParser, IMessageSerializer messageSerializer, ChannelControllerFactory <TChannelController> channelControllerFactory = null) { this.ChannelControllerFactory = channelControllerFactory ?? new ChannelControllerFactory <TChannelController>(); this.InitializeNetworkClient(networkClient); this.InitializeSerializer(messageSerializer); this.InitializeNotifier(); this.InitializeParser(messageParser); this.InitializeController(); }
/// <summary> /// Writes a byte array to the underlying client stream. /// </summary> /// <param name="client">The stream to write the line to.</param> /// <param name="buffer">The byte array buffer to write to the client stream.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>A task which asynchronously performs the operation.</returns> public static Task WriteAsync(this INetworkClient client, byte[] buffer, CancellationToken cancellationToken = default) { if (client == null) { throw new ArgumentNullException(nameof(client)); } return(client.WriteAsync(new [] { new ArraySegment <byte>(buffer) }, cancellationToken)); }
/// <summary> /// Read a line from the byte stream. /// </summary> /// <param name="client">The stream to read a line from.</param> /// <param name="timeout">The timeout to use whilst waiting for a line to be read.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>The string that was read from the stream.</returns> public static Task <IReadOnlyList <ArraySegment <byte> > > ReadLineAsync(this INetworkClient client, TimeSpan timeout, CancellationToken cancellationToken = default(CancellationToken)) { if (client == null) { throw new ArgumentNullException(nameof(client)); } return(ReadLineAsync(client, cancellationToken).WithTimeout(timeout, cancellationToken)); }
public WorldInput(WorldModel world) { World = world; m_Network = ServiceRegistry.GetService<INetworkClient>(); m_UserInterface = ServiceRegistry.GetService<UserInterfaceService>(); m_Input = ServiceRegistry.GetService<InputManager>(); MousePick = new MousePicking(); }
public WorldInput(WorldModel world) { // parent reference World = world; // service references m_Network = ServiceRegistry.GetService<INetworkClient>(); m_UserInterface = ServiceRegistry.GetService<UserInterfaceService>(); m_Input = ServiceRegistry.GetService<InputManager>(); // local instances MousePick = new MousePicking(); m_Macros = new MacroEngine(); }
// ============================================================================================================ // Ctor, Initialization, Dispose, Update // ============================================================================================================ public WorldModel() { Service.Add<WorldModel>(this); m_Engine = Service.Get<UltimaGame>(); m_Network = Service.Get<INetworkClient>(); m_UserInterface = Service.Get<UserInterfaceService>(); Entities = new EntityManager(this); Entities.Reset(true); Effects = new EffectManager(this); Statics = new StaticManager(); Input = new WorldInput(this); Interaction = new WorldInteraction(this); Client = new WorldClient(this); }
public void AddSession(INetworkClient customClient) { Logger.Log.Info(Language.Instance.GetMessageFromKey("NEW_CONNECT") + customClient.ClientId); ClientSession session = IntializeNewSession(customClient); customClient.SetClientSession(session); if (session != null && IsWorldServer) { if (!_sessions.TryAdd(customClient.ClientId, session)) { Logger.Log.WarnFormat(Language.Instance.GetMessageFromKey("FORCED_DISCONNECT"), customClient.ClientId); customClient.Disconnect(); _sessions.TryRemove(customClient.ClientId, out session); return; } } }
public DownloadSlotViewModel(DownloadSlot downloadSlot, INetworkClient downloadingClient, IFileStreamClient fileStreamClient) { if (downloadSlot == null) throw new ArgumentNullException("downloadSlot"); if (downloadingClient == null) throw new ArgumentNullException("downloadingClient"); if (fileStreamClient == null) throw new ArgumentNullException("fileStreamClient"); this.downloadSlot = downloadSlot; this.downloadingClient = downloadingClient; this.fileStreamClient = fileStreamClient; this.downloadingClient.OnBlockDownloaded += downloadingClientOnBlockDownloaded; this.downloadingClient.OnError += downloadingClientOnError; this.downloadingClient.OnRestore += downloadingClientOnRestore; this.downloadingClient.OnComplete += downloadingClientOnComplete; }
public void OnSent(INetworkClient client, SendStatus status) { switch (status) { case SendStatus.SUCCESS: Debug.WriteLine("SEND Success"); break; case SendStatus.FAIL_CONNECTION_CLOSING: Debug.WriteLine("SEND failed due to connection closing"); break; case SendStatus.FAIL_INVALID_PACKET: Debug.WriteLine("SEND failed due to invalid socket"); break; case SendStatus.FAIL_NOT_CONNECTED: Debug.WriteLine("SEND failed due to no connection"); break; case SendStatus.FAIL_SOCKET_ERROR: Debug.WriteLine("SEND Socket Error"); break; } }
public NachrichtenDispo(INetworkClient networkClient) { _networkClient = networkClient; // Rx :) incomingMessages = Observable.FromEventPattern<MessageReceivedEventHandler, MessageReceivedEventArgs>( h => _networkClient.MessageReceivedEvent += h, h => _networkClient.MessageReceivedEvent -= h) .Select(x => x.EventArgs.Content) .Where(ValidateMessage) .Where(x => GetMessageType(x) == MessageType.Reply) .Select(ParseResponse); incomingEvents = Observable.FromEventPattern<MessageReceivedEventHandler, MessageReceivedEventArgs>( h => _networkClient.MessageReceivedEvent += h, h => _networkClient.MessageReceivedEvent -= h) .Select(x => x.EventArgs.Content) .Where(ValidateMessage) .Where(x => GetMessageType(x) == MessageType.Event) .Select(ParseEvent); }
public TopMenuGump() : base(0, 0) { IsUncloseableWithRMB = true; IsMoveable = true; // maximized view AddControl(new ResizePic(this, 0, 0, 9200, 610, 27), 1); AddControl(new Button(this, 5, 3, 5540, 5542, 0, 2, 0), 1); ((Button)LastControl).GumpOverID = 5541; // buttons are 2443 small, 2445 big // 30, 93, 201, 309, 417, 480, 543 // map, paperdollB, inventoryB, journalB, chat, help, < ? > AddControl(new Button(this, 30, 3, 2443, 2443, ButtonTypes.Activate, 0, (int)Buttons.Map), 1); ((Button)LastControl).Caption = "<basefont color=#000000>Map"; AddControl(new Button(this, 93, 3, 2445, 2445, ButtonTypes.Activate, 0, (int)Buttons.Paperdoll), 1); ((Button)LastControl).Caption = "<basefont color=#000000>Paperdoll"; AddControl(new Button(this, 201, 3, 2445, 2445, ButtonTypes.Activate, 0, (int)Buttons.Inventory), 1); ((Button)LastControl).Caption = "<basefont color=#000000>Inventory"; AddControl(new Button(this, 309, 3, 2445, 2445, ButtonTypes.Activate, 0, (int)Buttons.Journal), 1); ((Button)LastControl).Caption = "<basefont color=#000000>Journal"; AddControl(new Button(this, 417, 3, 2443, 2443, ButtonTypes.Activate, 0, (int)Buttons.Chat), 1); ((Button)LastControl).Caption = "<basefont color=#000000>Chat"; AddControl(new Button(this, 480, 3, 2443, 2443, ButtonTypes.Activate, 0, (int)Buttons.Help), 1); ((Button)LastControl).Caption = "<basefont color=#000000>Help"; AddControl(new Button(this, 543, 3, 2443, 2443, ButtonTypes.Activate, 0, (int)Buttons.Question), 1); ((Button)LastControl).Caption = "<basefont color=#000000>Debug"; // minimized view AddControl(new ResizePic(this, 0, 0, 9200, 30, 27), 2); AddControl(new Button(this, 5, 3, 5537, 5539, 0, 1, 0), 2); ((Button)LastControl).GumpOverID = 5538; m_UserInterface = ServiceRegistry.GetService<UserInterfaceService>(); m_World = ServiceRegistry.GetService<WorldModel>(); m_Client = ServiceRegistry.GetService<INetworkClient>(); MetaData.Layer = UILayer.Over; }
public void RemoveSession(INetworkClient client) { ClientSession session; _sessions.TryRemove(client.ClientId, out session); // check if session hasnt been already removed if (session != null) { session.IsDisposing = true; if (IsWorldServer) { if (session.HasSelectedCharacter) { if (session.Character.Hp < 1) { session.Character.Hp = 1; } if (ServerManager.Instance.Groups.Any(s => s.IsMemberOfGroup(session.Character.CharacterId))) { ServerManager.Instance.GroupLeave(session); } session.Character.Save(); // only remove the character from map if the character has been set session.CurrentMap?.Broadcast(session, session.Character.GenerateOut(), ReceiverType.AllExceptMe); } } session.Destroy(); client.Disconnect(); Logger.Log.Info(Language.Instance.GetMessageFromKey("DISCONNECT") + client.ClientId); session = null; } }
private void BuildGump() { m_UserInterface = ServiceRegistry.GetService<UserInterfaceService>(); m_World = ServiceRegistry.GetService<WorldModel>(); m_Client = ServiceRegistry.GetService<INetworkClient>(); IsMoveable = true; SaveOnWorldStop = true; GumpLocalID = Mobile.Serial; if (Mobile.IsClientEntity) { AddControl(new GumpPic(this, 0, 0, 0x07d0, 0)); // HELP AddControl(new Button(this, 185, 44 + 27 * 0, 0x07ef, 0x07f0, ButtonTypes.Activate, 0, (int)Buttons.Help)); ((Button)LastControl).GumpOverID = 0x07f1; // OPTIONS AddControl(new Button(this, 185, 44 + 27 * 1, 0x07d6, 0x07d7, ButtonTypes.Activate, 0, (int)Buttons.Options)); ((Button)LastControl).GumpOverID = 0x07d8; // LOG OUT AddControl(new Button(this, 185, 44 + 27 * 2, 0x07d9, 0x07da, ButtonTypes.Activate, 0, (int)Buttons.LogOut)); ((Button)LastControl).GumpOverID = 0x07db; // QUESTS AddControl(new Button(this, 185, 44 + 27 * 3, 0x57b5, 0x57b7, ButtonTypes.Activate, 0, (int)Buttons.Quests)); ((Button)LastControl).GumpOverID = 0x57b6; // SKILLS AddControl(new Button(this, 185, 44 + 27 * 4, 0x07df, 0x07e0, ButtonTypes.Activate, 0, (int)Buttons.Skills)); ((Button)LastControl).GumpOverID = 0x07e1; // GUILD AddControl(new Button(this, 185, 44 + 27 * 5, 0x57b2, 0x57b4, ButtonTypes.Activate, 0, (int)Buttons.Guild)); ((Button)LastControl).GumpOverID = 0x57b3; // PEACE / WAR m_IsWarMode = Mobile.Flags.IsWarMode; int[] btngumps = m_IsWarMode ? WarModeBtnGumps : PeaceModeBtnGumps; m_WarModeBtn = (Button)AddControl(new Button(this, 185, 44 + 27 * 6, btngumps[0], btngumps[1], ButtonTypes.Activate, 0, (int)Buttons.PeaceWarToggle)); ((Button)LastControl).GumpOverID = btngumps[2]; // STATUS AddControl(new Button(this, 185, 44 + 27 * 7, 0x07eb, 0x07ec, ButtonTypes.Activate, 0, (int)Buttons.Status)); ((Button)LastControl).GumpOverID = 0x07ed; // Virtue menu AddControl(new GumpPic(this, 80, 8, 0x0071, 0)); LastControl.MouseDoubleClickEvent += VirtueMenu_MouseDoubleClickEvent; // Special moves book // AddControl(new GumpPic(this, 158, 200, 0x2B34, 0)); // LastControl.MouseDoubleClickEvent += SpecialMoves_MouseDoubleClickEvent; // equipment slots for hat/earrings/neck/ring/bracelet AddControl(new EquipmentSlot(this, 2, 76, Mobile, EquipLayer.Helm)); AddControl(new EquipmentSlot(this, 2, 76 + 22 * 1, Mobile, EquipLayer.Earrings)); AddControl(new EquipmentSlot(this, 2, 76 + 22 * 2, Mobile, EquipLayer.Neck)); AddControl(new EquipmentSlot(this, 2, 76 + 22 * 3, Mobile, EquipLayer.Ring)); AddControl(new EquipmentSlot(this, 2, 76 + 22 * 4, Mobile, EquipLayer.Bracelet)); // Paperdoll control! AddControl(new PaperDollInteractable(this, 8, 21) { SourceEntity = Mobile }); } else { AddControl(new GumpPic(this, 0, 0, 0x07d1, 0)); // Paperdoll AddControl(new PaperDollInteractable(this, 8, 21) { SourceEntity = Mobile }); } // name and title AddControl(new HtmlGumpling(this, 36, 262, 180, 42, 0, 0, string.Format("<span color=#aaa style='font-family:uni0;'>{0}", Mobile.Name))); AddControl(new HtmlGumpling(this, 35, 262, 180, 42, 0, 0, string.Format("<span color=#222 style='font-family:uni0;'>{0}", Mobile.Name))); }
/// <summary> /// Receive callback /// </summary> /// <param name="client">client</param> /// <param name="receivedPacket">received packet</param> public void OnReceived(INetworkClient client, Packet receivedPacket) { ParallelPacket receivedParallelPacket = new ParallelPacket(receivedPacket); switch (receivedParallelPacket.PacketType) { case ParallelPacketType.DATA: if (ReceiveType == ReceiveType.BURST) { OnParallelClientReceived(this, receivedParallelPacket); } else if (m_receiveType == ReceiveType.SEQUENTIAL) { lock (m_receiveLock) { m_receivedQueue.Enqueue(receivedParallelPacket); while (!m_receivedQueue.IsEmpty() && m_curReceivedPacketId + 1 == m_receivedQueue.Peek().PacketID) { ParallelPacket curPacket = m_receivedQueue.Dequeue(); m_curReceivedPacketId = curPacket.PacketID; if (m_curReceivedPacketId == long.MaxValue) { m_curReceivedPacketId = -1; } OnParallelClientReceived(this, curPacket); } } } break; case ParallelPacketType.IDENTITY_REQUEST: PacketSerializer<IdentityResponse> serializer = new PacketSerializer<IdentityResponse>(new IdentityResponse(Guid,MaxSocketCount)); ParallelPacket sendPacket=new ParallelPacket(-1,ParallelPacketType.IDENTITY_RESPONSE,serializer.PacketRaw); client.Send(sendPacket.PacketRaw); break; case ParallelPacketType.READY: lock (m_sendLock) { m_pendingClientSet.Add(client); if (m_pendingClientSet.Count > 0 && (m_errorPacketSet.Count > 0 || m_packetQueue.Count > 0)) m_sendReadyEvent.SetEvent(); } break; } }
private void SetUpIoC() { _networkClient = new NetworkClient(); _nachrichtenDispo = new NachrichtenDispo(_networkClient); _basicClient = new BasicClient(NachrichtenDispo); }
/// <summary> /// Initialises a new instance of the <see cref="IrcClient"/> class. /// </summary> /// <param name="client"> /// The client. /// </param> /// <param name="logger"> /// The logger. /// </param> /// <param name="ircConfiguration"> /// The configuration Helper. /// </param> /// <param name="password"> /// The password. /// </param> public IrcClient(INetworkClient client, ILogger logger, IIrcConfiguration ircConfiguration, string password) { this.nickname = ircConfiguration.Nickname; this.networkClient = client; this.logger = logger; this.syncLogger = logger.CreateChildLogger("Sync"); this.username = ircConfiguration.Username; this.realName = ircConfiguration.RealName; this.password = password; this.networkClient.DataReceived += this.NetworkClientOnDataReceived; this.ReceivedMessage += this.OnMessageReceivedEvent; this.clientCapabilities = new List<string> { "sasl", "account-notify", "extended-join", "multi-prefix" }; this.authToServices = ircConfiguration.AuthToServices; if (!this.authToServices) { this.logger.Warn("Services authentication is disabled!"); this.clientCapabilities.Remove("sasl"); this.clientCapabilities.Remove("account-notify"); this.clientCapabilities.Remove("extended-join"); } this.userCache = new Dictionary<string, IrcUser>(); this.channels = new Dictionary<string, IrcChannel>(); this.connectionRegistrationSemaphore = new Semaphore(0, 1); this.syncLogger.Debug("ctor() acquired connectionRegistration semaphore."); this.RegisterConnection(null); }
public PaperDollGump(Mobile parent) : base(parent.Serial, 0) { Parent = parent; m_UserInterface = ServiceRegistry.GetService<UserInterfaceService>(); m_World = ServiceRegistry.GetService<WorldModel>(); m_Client = ServiceRegistry.GetService<INetworkClient>(); IsMovable = true; if (parent == (Mobile)WorldModel.Entities.GetPlayerObject()) { AddControl(new GumpPic(this, 0, 0, 0x07d0, 0)); // HELP AddControl(new Button(this, 185, 44 + 27*0, 0x07ef, 0x07f0, ButtonTypes.Activate, 0, (int) Buttons.Help)); ((Button) LastControl).GumpOverID = 0x07f1; // OPTIONS AddControl(new Button(this, 185, 44 + 27*1, 0x07d6, 0x07d7, ButtonTypes.Activate, 0, (int) Buttons.Options)); ((Button) LastControl).GumpOverID = 0x07d8; // LOG OUT AddControl(new Button(this, 185, 44 + 27*2, 0x07d9, 0x07da, ButtonTypes.Activate, 0, (int) Buttons.LogOut)); ((Button) LastControl).GumpOverID = 0x07db; // QUESTS AddControl(new Button(this, 185, 44 + 27*3, 0x57b5, 0x57b7, ButtonTypes.Activate, 0, (int) Buttons.Quests)); ((Button) LastControl).GumpOverID = 0x57b6; // SKILLS AddControl(new Button(this, 185, 44 + 27*4, 0x07df, 0x07e0, ButtonTypes.Activate, 0, (int) Buttons.Skills)); ((Button) LastControl).GumpOverID = 0x07e1; // GUILD AddControl(new Button(this, 185, 44 + 27*5, 0x57b2, 0x57b4, ButtonTypes.Activate, 0, (int) Buttons.Guild)); ((Button) LastControl).GumpOverID = 0x57b3; // PEACE / WAR AddControl(new Button(this, 185, 44 + 27*6, 0x07e5, 0x07e6, ButtonTypes.Activate, 0, (int) Buttons.PeaceWarToggle)); ((Button) LastControl).GumpOverID = 0x07e7; // STATUS AddControl(new Button(this, 185, 44 + 27*7, 0x07eb, 0x07ec, ButtonTypes.Activate, 0, (int) Buttons.Status)); ((Button) LastControl).GumpOverID = 0x07ed; // Paperdoll AddControl(new PaperDollInteractable(this, 8, 21) { SourceEntity = Parent }); } else { AddControl(new GumpPic(this, 0, 0, 0x07d1, 0)); // Paperdoll AddControl(new PaperDollInteractable(this, 8, 21) { SourceEntity = Parent }); } }
public void RemoveClient(INetworkClient client) { this.clients.Remove(client); }
public void AddClient(INetworkClient client) { this.clients.Add(client); }
/// <summary> /// Disconnect callback /// </summary> /// <param name="client">client</param> public void OnDisconnect(INetworkClient client) { lock (m_generalLock) { m_clientSet.Remove(client); lock (m_sendLock) { m_pendingClientSet.Remove(client); } CurSocketCount--; if (CurSocketCount <= 0) { lock (m_sendLock) { m_packetQueue.Clear(); m_pendingPacketSet.Clear(); m_errorPacketSet.Clear(); } lock (m_receiveLock) { m_receivedQueue.Clear(); } m_sendReadyEvent.SetEvent(); IsConnectionAlive = false; Task t = new Task(delegate() { OnParallelClientDisconnect(this); }); t.Start(); } } }
/// <summary> /// Ensures the client. /// </summary> /// <param name="applicationIdentifier">The application identifier.</param> private void EnsureClient(string applicationIdentifier) { if (this.networkClient == null) { this.networkClient = this.factory.CreateNetworkClient(applicationIdentifier); this.networkClient.HostConnected += (sender, host) => this.OnHostConnected(host); this.networkClient.HostDisconnected += (sender, host) => this.OnHostDisconnected(host); this.networkClient.HostDiscovered += (sender, host) => this.OnHostDiscovered(host); this.networkClient.MessageReceived += (sender, message) => this.OnClientMessageReceived(message); } }
public void OnDisconnect(INetworkClient client) { tbHostname.Enabled = true; tbPort.Enabled = true; btnConnect.Text = "Connect"; tbSend.Enabled = false; btnSend.Enabled = false; MessageBox.Show("Disconnected from the server!"); }
/// <summary> /// Send callback /// </summary> /// <param name="client">client</param> /// <param name="status">send status</param> public void OnSent(INetworkClient client, SendStatus status, Packet sentPacket) { ParallelPacket sentParallelPacket = ParallelPacket.FromPacket(sentPacket); if (sentParallelPacket.PacketType == ParallelPacketType.DATA) { lock (m_sendLock) { m_pendingPacketSet.Remove(sentParallelPacket); if (status == SendStatus.SUCCESS || status == SendStatus.FAIL_INVALID_PACKET) { m_pendingClientSet.Add(client); } if (status != SendStatus.SUCCESS) { m_errorPacketSet.Add(sentParallelPacket); } if (m_pendingClientSet.Count > 0 && (m_errorPacketSet.Count > 0 || m_packetQueue.Count > 0)) m_sendReadyEvent.SetEvent(); } Task t = new Task(delegate() { OnParallelClientSent(this, status, sentParallelPacket); }); t.Start(); } }
/// <summary> /// Connect to specified debugger endpoint. /// </summary> /// <param name="uri">URI identifying the endpoint to connect to.</param> public void Connect(Uri uri) { Utilities.ArgumentNotNull("uri", uri); Close(); lock (_networkClientLock) { _networkClient = _networkClientFactory.CreateNetworkClient(uri); } Task.Factory.StartNew(ReceiveAndDispatchMessagesWorker); Task.Factory.StartNew(SendPacketsWorker); }
public void OnConnected(INetworkClient client, ConnectStatus status) { MessageBox.Show("Connected to the server!"); }
/// <summary> /// Connect to specified debugger endpoint. /// </summary> /// <param name="uri">URI identifying the endpoint to connect to.</param> public void Connect(Uri uri) { Utilities.ArgumentNotNull("uri", uri); LiveLogger.WriteLine("Debugger connecting to URI: {0}", uri); Close(); lock (_networkClientLock) { int connection_attempts = 0; const int MAX_ATTEMPTS = 5; while (true) { connection_attempts++; try { // TODO: This currently results in a call to the synchronous TcpClient // constructor, which is a blocking call, and can take a couple of seconds // to connect (with timeouts and retries). This code is running on the UI // thread. Ideally this should be connecting async, or moved off the UI thread. _networkClient = _networkClientFactory.CreateNetworkClient(uri); // Unclear if the above can succeed and not be connected, but check for safety. // The code needs to either break out the while loop, or hit the retry logic // in the exception handler. if (_networkClient.Connected) { LiveLogger.WriteLine("Debugger connected successfully"); break; } else { throw new SocketException(); } } catch (Exception ex) { if (ex.IsCriticalException()) { throw; } LiveLogger.WriteLine("Connection attempt {0} failed with: {1}", connection_attempts, ex); if (_isClosed || connection_attempts >= MAX_ATTEMPTS) { throw; } else { // See above TODO. This should be moved off the UI thread or posted to retry // without blocking in the meantime. For now, this seems the lesser of two // evils. (The other being the debugger failing to attach on launch if the // debuggee socket wasn't open quickly enough). System.Threading.Thread.Sleep(200); } } } } Task.Factory.StartNew(ReceiveAndDispatchMessagesWorker); Task.Factory.StartNew(SendPacketsWorker); }
protected virtual ClientSession IntializeNewSession(INetworkClient client) { ClientSession session = new ClientSession(client); client.SetClientSession(session); return session; }
public void OnReceived(INetworkClient client, Packet receivedPacket) { string sendString = StringFromByteArr(receivedPacket.GetPacket()) + "\r\n"; AddMsg(sendString); }