Пример #1
0
    private void ReceiveSummon(byte[] buffer)
    {
        int startIndex     = SocketInfo.ExecutionOrderStartIndex;
        int executionOrder = ByteConverter.ToInt(buffer, ref startIndex);
        int playerNumber   = ByteConverter.ToInt(buffer, ref startIndex);

        Debug.Log(LogType.Test, "<Color=Blue> this playerNumber : " + this.playerNumber + " , packet playerNumber : " + playerNumber + "</Color>");
        bool isMine = this.playerNumber == playerNumber ? true : false;

        if (executionOrder < MultiBattleDataManager.executionDataOrder)
        {
            return;
        }

        int   summonDeckIndex = ByteConverter.ToInt(buffer, ref startIndex);
        float xPos            = GetSummonXPosition(ByteConverter.ToFloat(buffer, ref startIndex), isMine);
        float yPos            = ByteConverter.ToFloat(buffer, ref startIndex);

        ExecutionData executionData = new ExecutionData()
        {
            type   = ExecutionType.Summon,
            order  = executionOrder,
            isMine = isMine,

            summonDeckIndex = summonDeckIndex,
            position        = new Vector3(xPos, yPos)
        };

        AddExecutionDataToManager(executionData);

        CheckChainingPacket(buffer, ByteConverter.ToInt(buffer, SocketInfo.PacketSizeStartIndex));
    }
Пример #2
0
 public static void EnqueueExecutionData(ExecutionData executionData)
 {
     //Debug.Log(LogType.Test, "<Color=Red> EE Order : " + executionData.order + ", Type : " + executionData.type + "</Color>");
     executionDatas.Enqueue(executionData);
     executionDataOrder++;
     FindMatchingExecutionData();
 }
Пример #3
0
    IEnumerator _Execute(ExecutionData data)
    {
        InstantiateProjectile(data);
        SpendMana(data);

        yield return(null);
    }
Пример #4
0
        private void InitializeData()
        {
            // String url = "https://smartflowspreview.xpertdoc.com/api/v1";
            var url = "https://localhost:8080";

            _api = new DefaultApi(url);

            var login = new Login("USERNAME", "PASSWORD");
            var auth  = _api.AuthenticateLoginPost(login);

            var token = auth.Tokens[0].Token;

            _api.Configuration.AccessToken = token;

            var flows = _api.GetFlows();

            Console.WriteLine(flows.Count);
            flowSelect.DisplayMember = "displayName";
            flowSelect.DataSource    = flows;

            _data = new ExecutionData();
            result.DataBindings.Add("Text", _data, "Result");

            _weather = new Weahter("Gent");
            cityName.DataBindings.Add("Text", _weather, "City");
        }
Пример #5
0
    IEnumerator _Execute(ExecutionData data)
    {
        TriggerAnimation();
        DisplayTelegraph(data);
        SpendMana(data);

        GameObject myRock = InstantiateEffect(data, 0, data.heroPos);

        Travel(true, myRock, data.heroPos, data.executePos, mySettings.otherValues[0], mySettings.otherValues[1]);

        yield return(new WaitForSeconds(mySettings.otherValues[0]));         // wait until the rock travels

        List <Health> outerRing = new List <Health> (activeTelegraph.GetAreaTargets(0).healths);
        List <Health> innerRing = new List <Health> (activeTelegraph.GetAreaTargets(1).healths);

        foreach (Health obj in innerRing)
        {
            outerRing.Remove(obj);
        }

        Damage(data, new MultipleHealths(innerRing.ToArray()), mySettings.damage * mySettings.otherValues [2]);
        Damage(data, new MultipleHealths(outerRing.ToArray()), mySettings.damage);

        ApplyEffect(data, new MultipleHealths(innerRing.ToArray()));
        InstantiateEffect(data, 1);

        HideTelegraph(data);
        if (data.isServer)
        {
            myRock.GetComponent <PooledObject> ().DestroyPooledObject();
        }
    }
Пример #6
0
        private async Task WriteResponseAsync(HttpResponse response, HttpResponseMessage httpResponse,
                                              ExecutionData executionData)
        {
            var traceId = executionData.Request.HttpContext.TraceIdentifier;
            var method  = executionData.Route.Method.ToUpperInvariant();

            if (!string.IsNullOrWhiteSpace(executionData.RequestId))
            {
                response.Headers.Add("Request-ID", executionData.RequestId);
            }

            if (!string.IsNullOrWhiteSpace(executionData.ResourceId) && executionData.Route.Method == "post")
            {
                response.Headers.Add("Resource-ID", executionData.ResourceId);
            }

            if (!string.IsNullOrWhiteSpace(executionData.TraceId))
            {
                response.Headers.Add("Trace-ID", executionData.TraceId);
            }

            if (!httpResponse.IsSuccessStatusCode)
            {
                _logger.LogInformation($"Received an invalid response ({httpResponse.StatusCode}) to HTTP " +
                                       $"{method} request from: {executionData.Route.Downstream} [Trace ID: {traceId}]");
                await SetErrorResponseAsync(response, httpResponse, executionData);

                return;
            }

            _logger.LogInformation($"Received the successful response ({httpResponse.StatusCode}) to HTTP " +
                                   $"{method} request from:{executionData.Route.Downstream} [Trace ID: {traceId}]");
            await SetSuccessResponseAsync(response, httpResponse, executionData);
        }
        public Task InvokeAsync(HttpRequestMessage request, ExecutionData data)
        {
            var context = JsonConvert.SerializeObject(_contextBuilder.Build(data));

            request.Headers.TryAddWithoutValidation("Correlation-Context", context);

            return(Task.CompletedTask);
        }
Пример #8
0
        public string Build(ExecutionData executionData)
        {
            var tracer      = _serviceProvider.GetService <ITracer>();
            var spanContext = tracer is null ? string.Empty :
                              tracer.ActiveSpan is null ? string.Empty : tracer.ActiveSpan.Context.ToString();

            return(spanContext);
        }
Пример #9
0
    protected void Damage(ExecutionData data, MultipleHealths myTargets)
    {
        if (!data.isServer)
        {
            return;
        }

        Damage(data, myTargets, mySettings.damage);
    }
Пример #10
0
    public TelegraphController activeTelegraph; //put this as a child of skill object

    //--------------------------------------------------------------EXECUTE BLOCK
    public void ExecuteSkill(ExecutionData data)
    {
        if (isServer)
        {
            data.myType = this.GetType().Name;
            print(SkillName + " activated from skillmasterclass");
            StartCoroutine(Execute(data));
        }
    }
Пример #11
0
        public object Build(ExecutionData executionData)
        {
            var tracer      = _serviceProvider.GetService <ITracer>();
            var spanContext = tracer is null ? string.Empty :
                              tracer.ActiveSpan is null ? string.Empty : tracer.ActiveSpan.Context.ToString();

            var name = string.Empty;

            if (executionData.Route.Config is {} &&
Пример #12
0
    protected GameObject InstantiateEffect(ExecutionData data, int index, Vector3 position)
    {
        if (!data.isServer)
        {
            return(null);
        }
        GameObject myObj = effectPools [index].Spawn(position);

        return(myObj);
    }
Пример #13
0
        public Execution(ExecutionData data)
        {
            MessageDescriptor d = ExecutionData.Descriptor;

            foreach (FieldDescriptor f in d.Fields)
            {
                fields.Add(f.Name, data[f]);
            }

            this.id = this[EXECUTION_ID];
        }
Пример #14
0
    protected GameObject InstantiateEffectOverTelegraph(ExecutionData data, int index)
    {
        if (!data.isServer)
        {
            return(null);
        }
        GameObject myObj = InstantiateEffect(data, index, activeTelegraph.transform.position);

        myObj.transform.parent = activeTelegraph.transform;
        return(myObj);
    }
Пример #15
0
    private void AddExecutionDataToManager(ExecutionData executionData)
    {
        if (MultiBattleDataManager.executionDataOrder == executionData.order)
        {
            MultiBattleDataManager.EnqueueExecutionData(executionData);
        }

        if (MultiBattleDataManager.executionDataOrder < executionData.order)
        {
            MultiBattleDataManager.AddOutOfSequenceData(executionData);
        }
    }
Пример #16
0
    protected void InstantiateProjectile(ExecutionData data)            //is only possible for Directional skils, spawns a projectile in the said direction
    {
        if (!data.isServer)
        {
            return;
        }

        GameObject myProjectile = Projectiles [0].Spawn(data.heroPos + (Projectiles [0].myObject.GetComponentInChildren <AdvancedProjectile> ().myHeight *Vector3.up), data.executeRot);

        myProjectile.GetComponentInChildren <AdvancedProjectile> ().damage = mySettings.damage;
        myProjectile.GetComponentInChildren <AdvancedProjectile> ().mySide = self.mySide;
    }
Пример #17
0
    IEnumerator _Execute(ExecutionData data)
    {
        TriggerAnimation();
        DisplayTelegraph(data);

        SpendMana(data);
        Damage(data);
        ApplyEffect(data);

        yield return(new WaitForSeconds(mySettings.damageOverTime));

        HideTelegraph(data);
    }
Пример #18
0
        public void Invoke(HttpClient client, ExecutionData data)
        {
            var context = new CorrelationContext
            {
                CorrelationId = data.RequestId,
                UserId        = data.UserId,
                Role          = data.Claims.FirstOrDefault(c => c.Key == ClaimTypes.Role).Value,
                Claims        = data.Claims
            };

            client.DefaultRequestHeaders.TryAddWithoutValidation("Correlation-Context",
                                                                 JsonConvert.SerializeObject(context));
        }
Пример #19
0
    public static ExecutionData DequeueExecutionData()
    {
        ExecutionData executionData = executionDatas.Dequeue();

        Debug.Log(LogType.Test, "<Color=Red> DD Order : " + executionData.order + ", Type : " + executionData.type + "</Color>");

        if ((MultiBattle.Instance.enemyNetworkingState == EnemyNetworkingState.Connected) && executionData.order > 0 && executionData.order % 10 == 0)
        {
            MultiBattle.Instance.SetSynchronized(false);
            client.SendSynchronizationPacket();
        }

        return(executionData);
    }
Пример #20
0
        /// <summary>
        /// Initializes a new instance of the <see cref="AutoStoreScanManager"/> class.
        /// </summary>
        /// <param name="executionData"></param>
        /// <!-- Badly formed XML comment ignored for member "M:HP.ScalableTest.PluginSupport.Scan.ScanActivityManager.#ctor(HP.ScalableTest.Framework.Plugin.PluginExecutionData)" -->
        public AutoStoreScanManager(PluginExecutionData executionData) : base(executionData)
        {
            _activityData = ExecutionData.GetMetadata <AutoStoreActivityData>();

            _activityData.AuthProvider = (_activityData.AutoStoreAuthentication == true) ? AuthenticationProvider.AutoStore : AuthenticationProvider.Auto;

            ScanOptions   = _activityData.ScanOptions;
            _documentName = FilePrefix.ToString();

            if (ScanLog != null)
            {
                ScanLog.Ocr = _activityData.UseOcr;
            }
        }
Пример #21
0
        private async Task SendTyping(ExecutionData job)
        {
            var acc = "";

            try
            {
                var convData = await InitConversation(job);
                await SendMessage(convData, "", isTyping : true);
            }
            catch (Exception ex)
            {
                Diagnostic.Log += $"\r\n\r\nPush error while [{acc}]: " + ex.Message;
            }
        }
Пример #22
0
        private async Task PerformUpdate(ExecutionData job)
        {
            Console.WriteLine("Queue item processing");
            //Console.WriteLine($"Executing Push for: {job.UserInfo.ChannelId}:{job.UserInfo.User.Id}");
            if (!job.IsContinuation)
            {
                await SendTyping(job);

                job.Portfolio = new PortfolioState();
                await investService.LoadPortfolio(job.UserInfo, job.Portfolio);
            }

            if (job.Portfolio?.Status == Api.StockStatus.Success)
            {
                await SendTyping(job);

                if (!job.IsContinuation)
                {
                    job.Portfolio.Prices = new Dictionary <int, Api.Price>();
                }

                var missing = await investService.LoadPrices(job.Portfolio);

                if (missing.Any())
                {
                    //Console.WriteLine($"Not all prices loaded yet. Waiting for [{string.Join(", ", missing)}]");
                    var jobContinue = new ExecutionData
                    {
                        ExecutionTimex = new Timex.Timex {
                            Value = DateTime.UtcNow.AddMinutes(1)
                        },
                        IsContinuation = true,
                        UserInfo       = job.UserInfo,
                        Detailed       = job.Detailed,
                        Portfolio      = job.Portfolio // use the same instance
                    };
                    queue.Add(jobContinue);
                    StoreQueue();
                    return;
                }
                else
                {
                    PrintSuggestions(job);
                }
            }
            else
            {
                PrintTexts(job, "Portfolio not loaded with status: " + job.Portfolio?.Status);
            }
        }
Пример #23
0
        public async Task <ExecutionData> ProcessAsync(RouteConfig routeConfig, HttpRequest request,
                                                       HttpResponse response, RouteData data)
        {
            request.Headers.TryGetValue(ContentTypeHeader, out var contentType);
            var contentTypeValue = contentType.ToString().ToLowerInvariant();

            if (string.IsNullOrWhiteSpace(contentTypeValue) || contentTypeValue.Contains(ContentTypeTextPlain))
            {
                contentTypeValue = ContentTypeApplicationJson;
            }

            var(requestId, resourceId, traceId) = GenerateIds(request, routeConfig);
            var route       = routeConfig.Route;
            var skipPayload = route.Use == "downstream" && (string.IsNullOrWhiteSpace(route.DownstreamMethod) ||
                                                            route.DownstreamMethod == "get" ||
                                                            route.DownstreamMethod == "delete");

            var hasTransformations = !skipPayload && _payloadTransformer.HasTransformations(requestId, route);
            var payload            = hasTransformations
                ? _payloadTransformer.Transform(await _payloadBuilder.BuildRawAsync(request),
                                                resourceId, route, request, data)
                : null;

            var executionData = new ExecutionData
            {
                RequestId   = requestId,
                ResourceId  = resourceId,
                TraceId     = traceId,
                UserId      = request.HttpContext.User?.Identity?.Name,
                Claims      = request.HttpContext.User?.Claims?.ToDictionary(c => c.Type, c => c.Value) ?? EmptyClaims,
                ContentType = contentTypeValue,
                Route       = routeConfig.Route,
                Request     = request,
                Response    = response,
                Data        = data,
                Downstream  = _downstreamBuilder.GetDownstream(routeConfig, request, data),
                Payload     = payload?.Payload,
                HasPayload  = hasTransformations
            };

            if (skipPayload || payload is null)
            {
                return(executionData);
            }

            executionData.ValidationErrors = await _payloadValidator.GetValidationErrorsAsync(payload);

            return(executionData);
        }
Пример #24
0
        public async Task <bool> TryValidate(ExecutionData executionData, HttpResponse httpResponse)
        {
            if (executionData.IsPayloadValid)
            {
                return(true);
            }

            var response = new { errors = executionData.ValidationErrors };
            var payload  = JsonConvert.SerializeObject(response);

            httpResponse.ContentType = "application/json";
            await httpResponse.WriteAsync(payload);

            return(false);
        }
Пример #25
0
    private void Command(ExecutionData executionData)
    {
        switch (executionData.type)
        {
        case ExecutionType.Attack:
            OnAttack();
            return;

        case ExecutionType.Summon:
            OnSummon(executionData.summonDeckIndex, executionData.position, executionData.isMine);
            return;

        case ExecutionType.Skill:
            OnSkill(executionData.isMine);
            return;
        }
    }
Пример #26
0
        private async Task PrintTexts(ExecutionData job, params string[] texts)
        {
            var acc = "";

            try
            {
                var convData = await InitConversation(job);

                foreach (var text in texts)
                {
                    await SendMessage(convData, text);
                }
            }
            catch (Exception ex)
            {
                Diagnostic.Log += $"\r\n\r\nPush error while [{acc}]: " + ex.Message;
            }
        }
Пример #27
0
 public async Task ExecuteAsync(ExecutionData executionData)
 {
     var message = executionData.Payload;
     var route   = executionData.Route;
     var context = new CorrelationContext
     {
         Id           = executionData.RequestId,
         Name         = executionData.Route.RoutingKey,
         ResourceId   = executionData.ResourceId,
         UserId       = executionData.UserId,
         ConnectionId = executionData.Request.HttpContext.Connection.Id,
         CreatedAt    = DateTime.UtcNow,
         TraceId      = executionData.Request.HttpContext.TraceIdentifier
     };
     await _busClient.PublishAsync(message, ctx => ctx.UseMessageContext(context)
                                   .UsePublishConfiguration(c =>
                                                            c.OnDeclaredExchange(e => e.WithName(route.Exchange)).WithRoutingKey(route.RoutingKey)));
 }
Пример #28
0
    }                                              //same as damage but heals, custom values can also be used

    protected void ApplyEffect(ExecutionData data) //Aplies status effect
    {
        if (!data.isServer)
        {
            return;
        }

        switch (mySettings.skillType)
        {
        case SkillSettings.Types.Area:
            ApplyEffect(data, areaTargets);
            break;

        case SkillSettings.Types.Targeted:
            ApplyEffect(data, new MultipleHealths(new Health[] { data.target.GetComponent <Health> () }));
            break;
        }
    }
Пример #29
0
    //--------------------------------------------------------------DAMAGE & OTHER EFFECTS STUFF
    //damages the target based on skill type (target/area/instant(self)/directional(same as area)/toggle(self))
    //any one of this can be added for more control:
    //-target-	//self/target/areatargets/areatargets[id]	pass the built in variable
    //-value-		//any other value in otherValues array		pass the index in the array
    protected void Damage(ExecutionData data)
    {
        if (!data.isServer)
        {
            return;
        }

        switch (mySettings.skillType)
        {
        case SkillSettings.Types.Area:
            Damage(data, areaTargets);
            break;

        case SkillSettings.Types.Targeted:
            Damage(data, new MultipleHealths(new Health[] { data.target.GetComponent <Health> () }));
            break;
        }
    }
Пример #30
0
    //over head effect for targeted, ground telegrapgh for area and directional,
    //There wont be any telegraphs for instant and toggle. There will be amazingly advanced vectors for vector stuff (hopefully)

    public void HideTelegraph(ExecutionData data)
    {
        if (!data.isServer && this.GetType().Name != data.myType)
        {
            print("F**k you UNet, WRONG RPC TYPE... correcting " + this.GetType().Name + " >> " + data.myType);
            ((SkillMasterClass)GetComponent(data.myType)).HideTelegraph(data);
            return;
        }
        try {
            activeTelegraph.HideTelegraph();
            print(gameObject.name + " HideTelegraph");
            if (data.isServer)
            {
                RpcHideTelegraph(data);
            }
        } catch (System.Exception e) {
            Debug.LogError(e.StackTrace);
        }
    }