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)); }
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(); }
IEnumerator _Execute(ExecutionData data) { InstantiateProjectile(data); SpendMana(data); yield return(null); }
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"); }
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(); } }
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); }
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); }
protected void Damage(ExecutionData data, MultipleHealths myTargets) { if (!data.isServer) { return; } Damage(data, myTargets, mySettings.damage); }
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)); } }
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 {} &&
protected GameObject InstantiateEffect(ExecutionData data, int index, Vector3 position) { if (!data.isServer) { return(null); } GameObject myObj = effectPools [index].Spawn(position); return(myObj); }
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]; }
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); }
private void AddExecutionDataToManager(ExecutionData executionData) { if (MultiBattleDataManager.executionDataOrder == executionData.order) { MultiBattleDataManager.EnqueueExecutionData(executionData); } if (MultiBattleDataManager.executionDataOrder < executionData.order) { MultiBattleDataManager.AddOutOfSequenceData(executionData); } }
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; }
IEnumerator _Execute(ExecutionData data) { TriggerAnimation(); DisplayTelegraph(data); SpendMana(data); Damage(data); ApplyEffect(data); yield return(new WaitForSeconds(mySettings.damageOverTime)); HideTelegraph(data); }
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)); }
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); }
/// <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; } }
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; } }
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); } }
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); }
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); }
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; } }
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; } }
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))); }
} //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; } }
//--------------------------------------------------------------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; } }
//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); } }