public override async Task ExecuteAsync(ExecutionContext context, ExecutionBranchContext branchContext) { await base.ExecuteAsync(context, branchContext); /* * var handle = context.Reader.Read<uint>(); * * RegisterHandle(handle, context, branchContext); */ var state = true; if (Imagination > 0 || !IsEnemyFaction) { state = context.Reader.ReadBit(); } if (state) { await ActionTrue.ExecuteAsync(context, branchContext); } else { await ActionFalse.ExecuteAsync(context, branchContext); } }
public override async Task ExecuteAsync(ExecutionContext context, ExecutionBranchContext branchContext) { await base.ExecuteAsync(context, branchContext); var length = context.Reader.Read <uint>(); var targets = new GameObject[length]; for (var i = 0; i < length; i++) { var id = context.Reader.Read <ulong>(); if (!context.Associate.Zone.TryGetGameObject((long)id, out var target)) { Logger.Error($"{context.Associate} sent invalid AreaOfEffect target: {id}"); continue; } targets[i] = target; } foreach (var target in targets) { await Action.ExecuteAsync(context, new ExecutionBranchContext(target)); } }
public override Task CalculateAsync(NpcExecutionContext context, ExecutionBranchContext branchContext) { var syncId = context.Associate.GetComponent <SkillComponent>().ClaimSyncId(); context.Writer.Write(syncId); if (branchContext.Target is Player player) { player.SendChatMessage($"Delay. [{context.SkillSyncId}] [{syncId}]"); } Task.Run(async() => { await Task.Delay(Delay); context = context.Copy(); await Action.CalculateAsync(context, branchContext); context.Sync(syncId); if (branchContext.Target is Player sPlayer) { sPlayer.SendChatMessage($"Sync. [{context.SkillSyncId}] [{syncId}]"); } }); return(Task.CompletedTask); }
/// <summary> /// Calculate a server preformed skill /// </summary> /// <param name="associate">Executioner</param> /// <param name="writer">Data to be sent to clients</param> /// <param name="skillId">Skill to execute</param> /// <param name="syncId">Sync Id</param> /// <param name="calculatingPosition">Where position calculations are done from</param> /// <param name="target">Explicit target</param> /// <returns>Context</returns> public async Task <NpcExecutionContext> CalculateAsync(GameObject associate, BitWriter writer, int skillId, uint syncId, Vector3 calculatingPosition, GameObject target = default) { target ??= associate; var context = new NpcExecutionContext(target, writer, skillId, syncId, calculatingPosition); if (!SkillRoots.TryGetValue(skillId, out var root)) { Logger.Debug($"Failed to find skill: {skillId}"); return(context); } context.Root = root; var branchContext = new ExecutionBranchContext(target); try { await root.CalculateAsync(context, branchContext); } catch (Exception e) { Logger.Error(e); } return(context); }
public override async Task CalculateAsync(NpcExecutionContext context, ExecutionBranchContext branchContext) { context.Associate.Transform.LookAt(branchContext.Target.Transform.Position); await branchContext.Target.NetFavorAsync(); context.Writer.Align(); context.Writer.Write <ushort>(0); context.Writer.WriteBit(false); context.Writer.WriteBit(false); context.Writer.WriteBit(true); context.Writer.Write(0); var success = context.IsValidTarget(branchContext.Target) && context.Alive; var damage = (uint)(success ? MinDamage : 0); context.Writer.Write(damage); context.Writer.WriteBit(success); if (success) { await PlayFxAsync("onhit", branchContext.Target, 1000); var stats = branchContext.Target.GetComponent <Stats>(); stats.Damage(damage, context.Associate, EffectHandler); await OnSuccess.CalculateAsync(context, branchContext); } }
public override async Task ExecuteAsync(ExecutionContext context, ExecutionBranchContext branchContext) { await base.ExecuteAsync(context, branchContext); var value = context.Reader.Read <float>(); var defaultValue = Behaviors.ToArray()[0].Value; if (value <= defaultValue) { value = defaultValue; } foreach (var(behavior, mark) in Behaviors.ToArray().Reverse()) { if (value < mark) { continue; } await behavior.ExecuteAsync(context, branchContext); break; } }
public override BehaviorExecutionParameters SerializeStart(BitWriter writer, NpcExecutionContext context, ExecutionBranchContext branchContext) { writer.WriteBit(false); if (branchContext.Target is Player target) { var targetDirection = context.Associate.Transform.Position - target.Transform.Position; var rotation = targetDirection.QuaternionLookRotation(Vector3.UnitY); // Forward, currently unused _ = rotation.VectorMultiply(Vector3.UnitX); // Handled in the background Task.Run(() => { target.Message(new KnockbackMessage { Associate = target, Caster = context.Associate, Originator = context.Associate, KnockbackTime = 0, Vector = Vector3.UnitY * Strength }); }); } return(base.SerializeStart(writer, context, branchContext)); }
public override async Task ExecuteAsync(ExecutionContext context, ExecutionBranchContext branchContext) { await base.ExecuteAsync(context, branchContext); branchContext.Duration = ActionDuration * 1000; await Action.ExecuteAsync(context, branchContext); }
public override async Task ExecuteAsync(ExecutionContext context, ExecutionBranchContext branchContext) { await base.ExecuteAsync(context, branchContext); var handle = context.Reader.Read <uint>(); RegisterHandle(handle, context, branchContext); }
public override async Task CalculateAsync(NpcExecutionContext context, ExecutionBranchContext branchContext) { context.MinRange = MinRange; context.MaxRange = MaxRange; context.SkillTime = SkillTime; await Behavior.CalculateAsync(context, branchContext); }
public override async Task ExecuteAsync(ExecutionContext context, ExecutionBranchContext branchContext) { await base.ExecuteAsync(context, branchContext); var chainIndex = context.Reader.Read <uint>(); await Behaviors[chainIndex - 1].ExecuteAsync(context, branchContext); }
public override async Task CalculateAsync(NpcExecutionContext context, ExecutionBranchContext branchContext) { // TODO context.Writer.Write(1); await Behaviors[1 - 1].CalculateAsync(context, branchContext); }
/// <summary> /// Wrapper to call the generic typed version of this method /// </summary> /// <param name="context">The global context to use</param> /// <param name="branchContext">The branch context to use</param> /// <returns><c>BehaviorExecutionParameters</c> gained by serializing the start skill</returns> public override BehaviorExecutionParameters SerializeStart(BitWriter writer, NpcExecutionContext context, ExecutionBranchContext branchContext) { var behaviorExecutionParameters = CreateInstance(context, branchContext); SerializeStart(writer, behaviorExecutionParameters); return(behaviorExecutionParameters); }
/// <summary> /// Deserializes a sync skill bitstream using the provided context and branch context /// </summary> /// <param name="context">The global context to use</param> /// <param name="branchContext">The branch context to use</param> /// <returns><c>BehaviorExecutionParameters</c> gained by deserializing the sync skill</returns> public override BehaviorExecutionParameters DeserializeSync(BitReader reader, ExecutionContext context, ExecutionBranchContext branchContext) { var behaviorExecutionParameters = CreateInstance(context, branchContext); DeserializeSync(reader, behaviorExecutionParameters); return(behaviorExecutionParameters); }
public override async Task CalculateAsync(NpcExecutionContext context, ExecutionBranchContext branchContext) { if (StunCaster == 1) { return; } context.Writer.WriteBit(false); }
public BehaviorExecutionParameters(ExecutionContext context, ExecutionBranchContext branchContext) { Context = context; BranchContext = new ExecutionBranchContext { Duration = branchContext.Duration, Target = branchContext.Target }; }
public override BehaviorExecutionParameters SerializeStart(BitWriter writer, NpcExecutionContext context, ExecutionBranchContext branchContext) { if (StunCaster != 1) { writer.WriteBit(false); } return(base.SerializeStart(writer, context, branchContext)); }
public override async Task CalculateAsync(NpcExecutionContext context, ExecutionBranchContext branchContext) { if (branchContext.Target is Player player) { player.SendChatMessage($"Verified: [{Action.Id}] {Action.BehaviorId}"); } await Action.CalculateAsync(context, branchContext); }
public override BehaviorExecutionParameters DeserializeStart(BitReader reader, ExecutionContext context, ExecutionBranchContext branchContext) { if (StunCaster != 1 && branchContext.Target != context.Associate) { reader.ReadBit(); } return(base.DeserializeStart(reader, context, branchContext)); }
/// <summary> /// Wrapper to call the generic typed version of this method /// </summary> /// <param name="context">The global context to use</param> /// <param name="branchContext">The branch context to use</param> /// <returns><c>BehaviorExecutionParameters</c> gained by serializing the start skill</returns> public override BehaviorExecutionParameters SerializeStart(NpcExecutionContext context, ExecutionBranchContext branchContext) { var behaviorExecutionParameters = new T { Context = context, BranchContext = branchContext }; SerializeStart(behaviorExecutionParameters); return(behaviorExecutionParameters); }
/// <summary> /// Deserializes a sync skill bitstream using the provided context and branch context /// </summary> /// <param name="context">The global context to use</param> /// <param name="branchContext">The branch context to use</param> /// <returns><c>BehaviorExecutionParameters</c> gained by deserializing the sync skill</returns> public override BehaviorExecutionParameters DeserializeSync(ExecutionContext context, ExecutionBranchContext branchContext) { var behaviorExecutionParameters = new T { Context = context, BranchContext = branchContext }; DeserializeSync(behaviorExecutionParameters); return(behaviorExecutionParameters); }
public override async Task CalculateAsync(NpcExecutionContext context, ExecutionBranchContext branchContext) { context.Writer.Write(branchContext.Target); var count = ProjectileCount == 0 ? 1 : ProjectileCount; for (var i = 0; i < count; i++) { CalculateProjectile(context, branchContext.Target); } }
public override async Task ExecuteAsync(ExecutionContext context, ExecutionBranchContext branchContext) { await base.ExecuteAsync(context, branchContext); if (StunCaster == 1 || branchContext.Target == context.Associate) { return; } context.Reader.ReadBit(); }
public override async Task ExecuteAsync(ExecutionContext context, ExecutionBranchContext branchContext) { await base.ExecuteAsync(context, branchContext); if (!branchContext.Target.TryGetComponent <Stats>(out var stats)) { return; } stats.Health = (uint)((int)stats.Health + Health); }
public override Task DismantleAsync(ExecutionContext context, ExecutionBranchContext branchContext) { if (!context.Associate.TryGetComponent <Stats>(out var stats)) { return(Task.CompletedTask); } stats.MaxHealth -= (uint)Life; stats.MaxArmor -= (uint)Armor; stats.MaxImagination -= (uint)Imagination; return(Task.CompletedTask); }
public override async Task ExecuteAsync(ExecutionContext context, ExecutionBranchContext branchContext) { await base.ExecuteAsync(context, branchContext); var target = context.Reader.ReadGameObject(context.Associate.Zone); var count = ProjectileCount == 0 ? 1 : ProjectileCount; for (var i = 0; i < count; i++) { StartProjectile(context, target); } }
public override async Task ExecuteAsync(ExecutionContext context, ExecutionBranchContext branchContext) { await base.ExecuteAsync(context, branchContext); context.Reader.Align(); context.Reader.Read <ushort>(); var failImmune = context.Reader.ReadBit(); if (!failImmune) { var unknown = context.Reader.ReadBit(); if (!unknown) { context.Reader.ReadBit(); } } context.Reader.Read <uint>(); var damage = context.Reader.Read <uint>(); if (branchContext == default) { Logger.Error("Invalid Brash Context!"); throw new Exception("Invalid!"); } if (branchContext.Target == default || !branchContext.Target.TryGetComponent <Stats>(out var stats)) { Logger.Error($"Invalid target: {branchContext.Target}"); } else { var _ = Task.Run(() => { stats.Damage(damage, context.Associate); }); } var success = context.Reader.ReadBit(); if (success) { await OnSuccess.ExecuteAsync(context, branchContext); } }
protected void RegisterHandle(uint handle, ExecutionContext context, ExecutionBranchContext branchContext) { context.RegisterHandle(handle, async reader => { var newBranchContext = new ExecutionBranchContext(branchContext.Target) { Duration = branchContext.Duration }; context.Reader = reader; await SyncAsync(context, newBranchContext); }); }
public override async Task CalculateAsync(NpcExecutionContext context, ExecutionBranchContext branchContext) { if (branchContext.Target != context.Associate) { context.Writer.WriteBit(false); } if (InterruptBlock == 0) { context.Writer.WriteBit(false); } context.Writer.WriteBit(false); }
public override async Task ExecuteAsync(ExecutionContext context, ExecutionBranchContext branchContext) { await base.ExecuteAsync(context, branchContext); var array = new[] { HitAction, HitActionEnemy, HitActionFaction }; if (array.All(b => b?.BehaviorId == 0)) { return; } var handle = context.Reader.Read <uint>(); RegisterHandle(handle, context, branchContext); }