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);
}
}
