public ServiceCommandOutput <object> ExecuteCommand(ClientCommand command) { if (command == null) { throw new ArgumentNullException("command"); } if (command.IsValid() == false) { throw new InvalidDataException("One or more mandatory values missing for command: " + command.Command); } var dictionary = command.GetAttributeDictionary <JsonPropertyAttribute>("PropertyName"); var builder = new StringBuilder(); builder.Append(dictionary["command"]); foreach (var key in dictionary.Keys) { if (key == "command") { continue; } if (dictionary[key] == null) { continue; } builder.AppendFormat(@" /{0}:{1}", key, dictionary[key]); } return(ExecuteCommand(builder.ToString())); }
public GameActCommands(ControlSettings controlSettings, HashSet <Keys> pressedKeys) { Systems = HorizontalMove = VerticalMove = ClientCommand.Idle; if (controlSettings == null || pressedKeys == null) { return; } foreach (var key in pressedKeys) { if (controlSettings.ControlMap.TryGetValue(key, out var command)) { switch (command) { case ClientCommand.OpenFire: case ClientCommand.ActivateShield: Systems = command; break; case ClientCommand.MoveRight: case ClientCommand.MoveLeft: HorizontalMove = command; break; case ClientCommand.MoveUp: case ClientCommand.MoveDown: VerticalMove = command; break; default: throw new ArgumentException($"Unknown command {command}"); } } } }
private void Accept() { ClientCommand command = new ClientCommand(ClientCommand.CommandType.AcceptTrade); RpgClientConnection.Instance.AddClientCommand(command); this.TradeRequest.TradeOffer1.Accepted = true; }
private static object FormatToolTip(ClientCommand command, string toolTip, CommandToolTipStyle toolTipStyle) { if (command == null) { throw new ArgumentNullException("command"); } if (toolTipStyle == CommandToolTipStyle.None || string.IsNullOrEmpty(toolTip)) { return(null); } if (toolTipStyle != CommandToolTipStyle.AlwaysWithKeyGesture && toolTipStyle != CommandToolTipStyle.EnabledWithKeyGesture) { return(toolTip); } if (command.UICommand.InputGestures.Count > 0) { KeyGesture keyGesture = command.UICommand.InputGestures[0] as KeyGesture; if (keyGesture != null && keyGesture.DisplayString.Length > 0) { toolTip = string.Format(ToolTipKeyGestureFormat, toolTip, keyGesture.DisplayString); } } return(toolTip); }
/// <summary> /// 为一个运行时的 Command 生成 TextBox 控件。 /// </summary> /// <param name="command"></param> /// <returns></returns> protected static TextBox CreateTextBox(ClientCommand command) { var textBox = new TipTextBox() { Width = 150, VerticalAlignment = VerticalAlignment.Center, Margin = new Thickness(2), EmptyValue = command.Label, ToolTip = command.Meta.ToolTip.Translate() }; //当TextBox的值改变时,通知命令进行新的输入值 textBox.TextChanged += (o, e) => { var txt = textBox.Text; if (txt == textBox.EmptyValue) { txt = string.Empty; } SetTextBoxParameter(command, txt); }; //支持UI Test AutomationProperties.SetName(textBox, command.Label); return(textBox); }
protected override void OnActive(ISession session) { AppendLine($"{session} 用户上线"); _session = session; ClientCommand.RaiseCanExecuteChanged(); base.OnActive(session); }
/// <summary> /// When we received data from one of our players. /// </summary> public void OnDataReceived(NetIncomingMessage message) { ClientCommand command = (ClientCommand)message.ReadByte(); switch (command) { case ClientCommand.ActionPackage: OnActionPackage(message); break; case ClientCommand.StartGame: try { ChampionTypes champ = (ChampionTypes)message.ReadUInt32(); AddClient(message.SenderConnection, champ); } catch (Exception e) { ILogger.Log("Start game packet badly formatted: " + e.ToString(), LogPriority.Error); } break; default: Debug.Fail("Invalid client command."); ILogger.Log("Invalid client command received: " + command, LogPriority.Warning); break; } }
public override void OnKeyDown(OpenTK.Input.KeyboardKeyEventArgs e) { base.OnKeyDown(e); if (e.Key == Key.Escape) { StateWindow.Instance.PopState(); this.Destroy(); return; } else if (e.Key == OpenTK.Input.Key.Enter && e.Alt) { Renderer.SetFulscreen(Renderer.GetFulscreen() ? false : true); } else { if (e.Key == Key.Space) { ClientCommand command = new ClientCommand(ClientCommand.CommandType.ActionTrigger); RpgClientConnection.Instance.AddClientCommand(command); } else if (e.Key == Key.Enter) { RpgClientConnection.Instance.CloseMessageBox(); } else if (e.Key == Key.LShift) { ClientCommand command = new ClientCommand(ClientCommand.CommandType.ToggleRunning); command.SetParameter("Running", true); RpgClientConnection.Instance.AddClientCommand(command); } } }
public async Task <IActionResult> PutClientCommand(int id, ClientCommand clientCommand) { if (id != clientCommand.Id) { return(BadRequest()); } _context.Entry(clientCommand).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ClientCommandExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <ActionResult <ClientCommand> > PostClientCommand(ClientCommand clientCommand) { _context.ClientCommands.Add(clientCommand); await _context.SaveChangesAsync(); return(CreatedAtAction("GetClientCommand", new { id = clientCommand.Id }, clientCommand)); }
/** * <summary> * Send a move command to the server * </summary> * * <param name="direction"></param> * <param name="speed"></param> * * <returns> * void * </returns> */ private void SendMoveCommand(string direction, int speed) { // Make connection to the server IPEndPoint endPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9050); try { //string json = "[{\"command\": \"move-left\"}]"; ClientCommand command = new ClientCommand(); // Convert data into json string ClientMoveData clientData = new ClientMoveData(); string data = JsonConvert.SerializeObject(clientData); // Convert command into json string command.ID = ClientCommandID.MOVE; command.Data = data; string json = JsonConvert.SerializeObject(command); // Convert json string to bytes and send over to the server. Byte[] sendBytes = Encoding.ASCII.GetBytes(json); this.client.Send(sendBytes, sendBytes.Length, endPoint); } catch (Exception e) { Debug.Log(e.ToString()); } }
/// <summary> /// Modifier un client en base /// </summary> /// <param name="p">Client à modifier</param> public void ModifierClient(Client cli) { // Contôle des champs ClientCommand clientCmd = new ClientCommand(contexte); clientCmd.Modifier(cli); }
protected override FrameworkElement CreateCommandUI(ClientCommand cmd) { var textBox = CreateTextBox(cmd); var btn = this.CreateButton(cmd); this.PrepareControls(textBox, btn); //在textBox上按下回车时,执行命令。 textBox.KeyDown += (o, e) => { if (e.Key == Key.Enter) { cmd.TryExecute(textBox); } }; var panel = new DockPanel(); panel.Children.Add(btn); panel.Children.Add(new Separator()); panel.Children.Add(textBox); Border border = new Border(); border.BorderThickness = new Thickness(1); border.BorderBrush = new SolidColorBrush(Colors.Silver); border.Child = panel; return(border); }
protected override FrameworkElement CreateCommandUI(ClientCommand cmd) { var textBox = CreateTextBox(cmd); if (this.TriggerMode == TextBoxCommandTriggerMode.EnterPressed) { //在textBox上按下回车时,执行命令。 textBox.KeyDown += (o, e) => { if (e.Key == Key.Enter) { cmd.TryExecute(textBox); } }; } else { textBox.TextChanged += (o, e) => { cmd.TryExecute(textBox); }; } return(textBox); }
private void ReceiveCommandCallback(PyDataType packet) { ClientCommand command = packet; if (command.Command == "QC") { Log.Debug("Received QueueCheck command"); // send player position on the queue this.Socket.Send(new PyInteger(this.ConnectionManager.LoginQueue.Count())); // send low level version exchange required this.SendLowLevelVersionExchange(); // wait for a new low level version exchange again this.Socket.SetReceiveCallback(ReceiveLowLevelVersionExchangeCallback); } else if (command.Command == "VK") { Log.Debug("Received VipKey command"); // next is the placebo challenge this.Socket.SetReceiveCallback(ReceiveCryptoRequestCallback); } else { throw new Exception("Received unknown data!"); } }
public override void OnMouseDown(MouseButtonEventArgs e) { base.OnMouseDown(e); if (ContentSelectable()) { if (e.Button == MouseButton.Left || e.Button == MouseButton.Right) { Vector2 mouse = GetLocalMousePosition(); int slotSize = GetContentWidth() / 5; mouse.X /= slotSize; mouse.Y /= slotSize; int itemIndex = (int)mouse.X + ((int)mouse.Y * 5); if (itemIndex >= 0 && itemIndex < _shopData.ShopItems.Count) { if (e.Button == MouseButton.Left) { ClientCommand command = new ClientCommand(ClientCommand.CommandType.BuyShopItem); command.SetParameter("ItemIndex", itemIndex); command.SetParameter("Count", 1); RpgClientConnection.Instance.AddClientCommand(command); } else if (e.Button == MouseButton.Right) { Vector2 mousePos = StateWindow.Instance.GetMousePosition(); ItemClickOptionsPanel.OptionType optionType = ItemClickOptionsPanel.OptionType.Buy; int itemID = _shopData.ShopItems[itemIndex].ItemID; ItemClickOptionsPanel optionPanel = new ItemClickOptionsPanel((int)mousePos.X, (int)mousePos.Y, optionType, itemIndex, itemID, -1, _gameState); GameState.Instance.AddControl(optionPanel); } } } } }
public override async Task Execute(ClientCommand commandData) { Player p = application.Players.Find(x => x.Name == commandData.Sender.Username); if (p == null) { p = application.AddPlayer(commandData.SenderIdString, commandData.Sender.Username); } string challengeName = commandData.Arguments[0]; string postingPlayerId = p.DiscordId; string identifier = Regex.Replace(challengeName, "[^0-9]", ""); int weaponId = 0; //if (identifier.Length < 1) // await commandData.Respond($"You forgot a number in the title {Emotes.ERROR}"); if (!int.TryParse(commandData.Arguments[1], out weaponId)) { await commandData.Respond($"Invalid input in selected weapon {Emotes.ERROR}"); } else { Weapon weapon = (Weapon)weaponId; string weaponShort = Regex.Replace(weapon.ToString(), "[^A-Z]", ""); identifier += weaponShort; identifier = MakeUniqueIdentifier(identifier); application.AddChallenge(challengeName, weapon, postingPlayerId, identifier); await commandData.Respond($"`{challengeName} ({identifier})`{Emotes.WeaponsArray[(int)weapon]} created"); } }
/// <summary> /// Dialogs the processor. /// </summary> /// <param name="args">The args.</param> protected void DialogProcessor(ClientPipelineArgs args) { if (!args.IsPostBack) { // Show the modal dialog if it is not a post back string id = this.ItemID; string fldName = string.Empty; Item itm = Factory.GetDatabase("master").Items[this.ItemID]; if (itm != null) { fldName = itm.Fields[this.FieldID].Name; } var priceXmlPath = args.Properties["priceXmlPath"] as string; ClientCommand clientCommand = Sitecore.Context.ClientPage.ClientResponse.ShowModalDialog( @"/sitecore/shell/Applications/PriceMatrixQuantityEditor.aspx?priceXmlPath=" + priceXmlPath + "&itemid=" + id + "&fieldName=" + fldName, "400", "250", string.Empty, true); // Sitecore. // Suspend the pipeline to wait for a postback and resume from another processor // args.WaitForPostBack(); } else { // the result of a dialog is handled because a post back has occurred string res = args.Result; // Show an alert message box with the value from the modal dialog Sitecore.Context.ClientPage.ClientResponse.Alert(res); } }
private void CreateCmd_VisibleChanged(object sender, EventArgs e) { if (((CreateCmd)sender).Visible) { clientCommand = new ClientCommand(); } }
public override void Close() { Instance = null; ClientCommand command = new ClientCommand(ClientCommand.CommandType.CloseBank); RpgClientConnection.Instance.AddClientCommand(command); base.Close(); }
public object ExecuteAsync(ClientCommand <MT, T> com, string key) { StartWait(); object r = com.ExecuteSafe(this, key); WaitBroadcasting(); return(r); }
public Client(string ip, string user, string password, int port = 22) { this.ip = ip; this.user = user; this.password = password; this.port = port; client = new SshClient(ip, port, user, password); client.ConnectionInfo.Timeout = TimeSpan.FromSeconds(2); Commands = new ClientCommand(this); }
public CommandStruct(QueryRunner instance, Plugin class_, MethodInfo methodName, ClientCommand command, ServerGroups serverGroups = null) { Ts3Instance = instance; Class = class_; Method = methodName; Command = command; ServerGroups = serverGroups ?? new ServerGroups(); }
private Task SendCommand(ClientCommand command) { return(Task.Run(() => { BinaryFormatter formatter = new BinaryFormatter(); formatter.Serialize(client.GetStream(), command); })); }
/// <summary> /// 为运行时的Command生成一个按钮 /// </summary> /// <param name="command"></param> /// <returns></returns> protected Button CreateButton(ClientCommand command) { var btn = new Button(); btn.CommandParameter = this.Context.CommandArg; ButtonCommand.SetCommand(btn, command.UICommand); return(btn); }
/// <summary> /// 为运行时的Command生成一个菜单项 /// </summary> /// <param name="command"></param> /// <returns></returns> protected MenuItem CreateMenuItem(ClientCommand command) { MenuItem menuItem = new MenuItem(); menuItem.CommandParameter = this.Context.CommandArg; MenuItemCommand.SetCommand(menuItem, command.UICommand); return(menuItem); }
public void Send(ClientCommand _command, string _data) { byte[] packet = System.Text.Encoding.Unicode.GetBytes(_command.ToString() + ";" + _data); try { client.Send(packet, packet.Length, SocketFlags.None); } catch (Exception e) { MessageBox.Show("Hálózati hiba az üzenet küldése során!\n" + e.Message, "Hiba!", MessageBoxButtons.OK, MessageBoxIcon.Error); } }
private void LetClientIn(int i) { if (clientsStatus [i] == false) { ICommand client = new ClientCommand(this, i); client.GoIn(); clientsStatus[i] = true; } }
/// <summary> /// 设置命令 /// </summary> /// <param name="id"></param> /// <param name="clientId"></param> /// <param name="command"></param> public static void SetCommand(int id, string clientId, ClientCommand command) { var cmdFile = GetClientCommandFile(id, clientId); File.WriteAllText(cmdFile, JsonConvert.SerializeObject(command, new JsonSerializerSettings { Formatting = Formatting.Indented, }), Encoding.UTF8); }
protected override void OnInActive(ISession session) { AppendLine($"{session} 用户下线"); if (_session == session) { _session = null; ClientCommand.RaiseCanExecuteChanged(); } base.OnInActive(session); }
/// <summary> /// Creates a new Command instance /// </summary> /// <param name="condition"></param> /// <param name="clientExecution">The method that will be executed</param> /// <param name="serverExecution"></param> /// <param name="applyServerResult"></param> /// <param name="comandType">The CommandType of this Command</param> /// <param name="networkValueType">The type of the value that is returned by the Execution delegate, if the command doesn't returns a value, you can set this to null to limit network data transfer</param> /// <param name="dataTransferOptions">Defines options for network packet transmission</param> /// <param name="frequency">Defines the frequency at which the current command will be processed</param> public Command(Condition condition, ClientCommand clientExecution, ServerCommand serverExecution, ApplyServerCommand applyServerResult, CommandType comandType, Type networkValueType, DataTransferOptions dataTransferOptions, ExecutionFrequency frequency) { if (networkValueType != null && !networkValueType.IsValueType && networkValueType != typeof(string) && networkValueType != typeof(byte[])) throw new CoreException("DataType must be a ValueType."); LocalId = _count++; Condition = condition; ClientExecution = clientExecution; ServerExecution = serverExecution; ApplyServerResult = applyServerResult; Type = comandType; NetworkValueType = networkValueType; TransferOptions = dataTransferOptions; Frequency = frequency; }
public static Command CreateLocalAndServerCommand(Condition condition, ClientCommand clientCommand, ServerCommand serverCommand, Type typeOfDataExchanged, DataTransferOptions dataTransferOptions) { return new Command(condition, clientCommand, serverCommand, null, CommandType.LocalAndServer, typeOfDataExchanged, dataTransferOptions, ExecutionFrequency.FullUpdate60Hz); }
public static Command CreateLocalCommand(ClientCommand clientCommand) { return CreateLocalCommand(null, clientCommand, ExecutionFrequency.FullUpdate60Hz); }
public static Command CreateLocalAndServerCommand(ClientCommand clientCommand, ServerCommand serverCommand, Type typeOfDataExchanged, DataTransferOptions dataTransferOptions) { return CreateLocalAndServerCommand(clientCommand, serverCommand, typeOfDataExchanged, dataTransferOptions); }
public static Command CreateLocalAndServerCommand(Condition condition, ClientCommand clientCommand, ServerCommand serverCommand, ApplyServerCommand applyServerResult, Type typeOfDataExchanged, DataTransferOptions dataTransferOptions, ExecutionFrequency frequency) { return new Command(condition, clientCommand, serverCommand, applyServerResult, CommandType.LocalAndServer, typeOfDataExchanged, dataTransferOptions, frequency); }
internal void OnCommand(Client client, ClientCommand cmd, string[] tokens) { if (Command != null) Command.Invoke(client, new CommandEventArgs(client, cmd, tokens)); }
public static Command CreateLocalAndServerCommand(ClientCommand clientCommand, ServerCommand serverCommand, ApplyServerCommand applyServerResult, Type typeOfDataExchanged, DataTransferOptions dataTransferOptions) { return CreateLocalAndServerCommand(null, clientCommand, serverCommand, applyServerResult, typeOfDataExchanged, dataTransferOptions, ExecutionFrequency.FullUpdate60Hz); }
public static Command CreateLocalCommand(ClientCommand clientCommand, ExecutionFrequency frequency) { return CreateLocalCommand(null, clientCommand, frequency); }
private void sendNotification(ClientCommand command, long timeinseconds, string hint) { foreach (string registrationid in registrationIDList) { Console.Out.WriteLine("New notification sending"); Console.Out.WriteLine("Command: " + command.ToString()); Console.Out.WriteLine("Remaining seconds: " + timeinseconds.ToString()); Console.Out.WriteLine("Hint: " + hint); writeConsole("New notification sending"); writeConsole("Command: " + command.ToString()); writeConsole("Remaining seconds: " + timeinseconds.ToString()); writeConsole("Hint: " + hint); JavaScriptSerializer serializer = new JavaScriptSerializer(); SocketData data = new SocketData(command.ToString(), timeinseconds.ToString(), hint); String jsonstring = serializer.Serialize(data); Console.Out.WriteLine("JsonString: " + jsonstring); pushBroker.QueueNotification(new GcmNotification().ForDeviceRegistrationId(registrationid) .WithJson(jsonstring)); } }
public ClientCommandEventArgs(Client Client, ClientCommand cmd, string[] tokens) : base(Client) { this.Command = cmd; this.Tokens = tokens; }
public static Command CreateLocalCommand(Condition condition, ClientCommand clientCommand) { return new Command(condition, clientCommand, null, null, CommandType.Local, null, DataTransferOptions.None, ExecutionFrequency.FullUpdate60Hz); }
public CommandEventArgs(Client client, ClientCommand command, string[] tokens) { Client = client; Tokens = tokens; Command = command; }
public string[] DecodeCmdStringArray(byte[] _data) { string argsString = System.Text.Encoding.UTF8.GetString(_data); string[] args = argsString.Split(new char[] { ';' }); try { this.CurrClientCommand = (ClientCommand)Enum.Parse(typeof(ClientCommand), args[0]); } catch { Console.WriteLine("Wrong Command Nr: "+args[0]); } args = args.Where(w => w != args[0]).ToArray(); return args; }
private void SendCommand(ClientCommand command, Action<NetBuffer> setValues) { NetOutgoingMessage msg = client.CreateMessage(); msg.Write((byte)command); if (setValues != null) { setValues(msg); } client.SendMessage(msg, NetDeliveryMethod.ReliableOrdered); }