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