private async Task <JsonRpc> GetJsonRpcAsync(Task <Stream> rpcStreamTask)
        {
            var stream = await rpcStreamTask;
            var target = new TerminalEvent(this.package, this);

            return(JsonRpc.Attach(stream, target));
        }
Esempio n. 2
0
    void Awake()
    {
        OnMouseClickEvent     = new MouseClickEvent();
        OnEnvChangeShapeEvent = new EnvChangeShapeEvent();

        OnStaticCaseItemEvent   = new StaticCaseItemEvent();
        OnRightButtonClickEvent = new RightButtonClickEvent();

        OnDoorEvent = new DoorEvent();
        OnCaseEvent = new CaseEvent();

        OnNextQuestEvent = new NextQuestEvent();
        //OnDialogEvent = new QuestDialogEvent();
        OnUseOnPlayerEvent = new UseOnPlayerEvent();
        OnStartDialogEvent = new StartDialogEvent();

        OnTerminalOpen  = new TerminalEvent();
        OnTerminalClose = new TerminalEvent();

        OnChangeSpriteEvent = new ChangeSpriteEvent();

        OnNewTicEvent     = new NewTicEvent();
        OnAddBuffEvent    = new AddBuffEvent();
        OnRemoveBuffEvent = new RemoveBuffEvent();
    }
Esempio n. 3
0
        public async Task <bool> SendCustom(string cmd)
        {
            bool timeout = await Task.Run(() => { return(Wait(ref _Completed, CompletionTimeout)); });

            if (timeout)
            {
                Log(new TimeoutException(), Default.msgControllerTimeout);
                return(false);
            }
            CommandExecutionCompleted = false;
            try
            {
                Port.WriteLine(cmd);
            }
            catch (Exception e)
            {
                Log(e, string.Format("{0} Info: {1}", Default.msgPortWriteError, cmd));
                return(false);
            }
            TerminalQueue.Enqueue(() => { TerminalEvent?.Invoke(this, new TerminalEventArgs(cmd)); });
            return(await Task.Run(() => { return !Wait(ref _Completed, CompletionTimeout); }));
        }
Esempio n. 4
0
 private void ParseLine(string line)
 {
     Trace("Parser invoked");
     TerminalQueue.Enqueue(() => { TerminalEvent?.Invoke(this, new TerminalEventArgs(line)); });
     if (line.EndsWith(ErrorDesignator))
     {
         new Thread(DeviceErrorThreadStart).Start(new TerminalEventArgs(line));
         return;
     }
     if (IsConnected)
     {
         if (line.Length == ConnectionSignature.Length)
         {
             if (line.SequenceEqual(ConnectionSignature))
             {
                 OnUnexpectedDisconnect();
                 return;
             }
         }
         if (!CommandExecutionCompleted)
         {
             if (line.Length == CompletionSignature.Length)
             {
                 if (line.SequenceEqual(CompletionSignature))
                 {
                     CommandExecutionCompleted = true;
                     return;
                 }
             }
         }
         if (AcquisitionInProgress)
         {
             if (line.Length == EndOfAcquisitionSignature.Length)
             {
                 if (line.SequenceEqual(EndOfAcquisitionSignature))
                 {
                     AcquisitionInProgress = false;
                     return;
                 }
             }
             try
             {
                 string[] parsed = line.Split(Splitter);
                 byte     c      = byte.Parse(parsed[0], NumberStyles.HexNumber, CultureInfo.InvariantCulture);
                 float    v      = float.Parse(parsed[1].Trim(ToTrim), CultureInfo.InvariantCulture);
                 DataQueue.Enqueue(() =>
                 {
                     AcquisitionDataReceived?.Invoke(this, new AcquisitionEventArgs(c, v));
                 });
             }
             catch (Exception exc)
             {
                 new Thread(DataErrorEventThreadStart).Start(new DataErrorEventArgs(exc, line));
             }
         }
         else
         {
             if (line.Length == AcquisitionSignature.Length)
             {
                 if (line.SequenceEqual(AcquisitionSignature))
                 {
                     AcquisitionInProgress = true;
                     return;
                 }
             }
         }
     }
     else
     {
         if (line.Length == ConnectionSignature.Length)
         {
             if (line.SequenceEqual(ConnectionSignature))
             {
                 IsConnected = true;
                 return;
             }
         }
     }
 }