public static bool forbiddenInContext(this IEffect effect, EffectContext context)
{
//if the Dictionary doesnt exist yet, build it
if (contextForbidDict == null)
{
buildContextForbidDict();
}
//look up the effect
Contexts C;
if (contextForbidDict.TryGetValue(effect.GetType(), out C))
{
switch (context)
{
case EffectContext.playerCard: return(C.playerCard);
case EffectContext.tower: return(C.tower);
case EffectContext.enemyCard: return(C.enemyCard);
case EffectContext.enemyUnit: return(C.enemyUnit);
default: Debug.LogWarning("Unknown Context"); return(true);
}
}
else
{
Debug.LogError("Could not find " + effect.XMLName + " in the forbidden context dict!");
return(true);
}
}
/// <inheritdoc/>
public override void Initialize(EffectContext effectContext, TransformGraph transformGraph)
{
var path = Windows.ApplicationModel.Package.Current.InstalledLocation.Path;
effectContext.LoadPixelShader(GUID_RipplePixelShader, NativeFile.ReadAllBytes(path + "\\Ripple.cso"));
transformGraph.SetSingleTransformNode(this);
}
public override void Play(EffectContext context)
{
var position = context.GetRequiredFeature <PositionFeature>().Position;
var clip = Clips.RandomElement();
AudioSource.PlayClipAtPoint(clip, position, Volume);
}
public static void Apply(EffectData effectData, EffectContext ctx)
{
var effect = Create(effectData);
BattleLog.Write($"Applying Effect of {effectData.EffectType} to {ctx.Target.MembersDescriptions()}");
effect.Apply(ctx);
}
public void StaticChange(EffectContext context, decimal value)
{
if (!StaticEffect.ContainsKey(context))
{
StaticEffect[context] = value;
}
else
{
StaticEffect[context] += value;
}
Invoke(context);
if (context == StaticEffectContext.Attack)
{
Invoke(StaticEffectContext.CriticalDamage);
}
// We not to need update hp when hp is updated(maybe character change), process already exec in HandleSpecific
void Invoke(EffectContext c)
{
try { InvokeStatic(c, HandleSpecific(c, out var newValue) ? newValue : StaticEffect[c]); }
catch (ApplicationInvalidOperationException e) { Invoke((EffectContext)e.CustomData); }
catch (InvalidOperationException) { }
}
}
public override void Play(EffectContext context)
{
foreach (var effect in Effects)
{
effect.Play(context);
}
}
public static void PlayIfPresent(this Effect effect, EffectContext context)
{
if (effect != null)
{
effect.Play(context);
}
}
public void Apply(EffectContext ctx)
{
Attacker = ctx.Source;
Target = ctx.Target;
//PROPOSALS SHOULD NOT GO THROUGH THE EVENT SYSTEM
Message.Publish(new Proposed <Attack> {
Message = this
});
var applicableTargets = Target.Members.Where(x => x.IsConscious()).ToArray();
var selectedTarget = _hitsRandomTarget && applicableTargets.Any() ? (Target) new Single(applicableTargets.Random()) : (Target) new Multiple(applicableTargets);
foreach (var member in selectedTarget.Members)
{
if (member.State[TemporalStatType.Evade] > 0)
{
member.State.AdjustEvade(-1);
}
else
{
Effect.Apply(Attacker, member);
}
}
Message.Publish(new Finished <Attack> {
Message = this
});
}
public void Apply(EffectContext ctx)
{
Source = ctx.Source;
Target = ctx.Target;
if (Condition())
{
Effect.Apply(ctx);
}
}
public override void Play(EffectContext context)
{
var position = context.GetRequiredFeature <PositionFeature>().Position;
// Check if color features are present
var color = context.GetOptionalFeature <ColorFeature>();
var gradient = context.GetOptionalFeature <GradientFeature>();
var minMaxColor = context.GetOptionalFeature <MinMaxColorFeature>();
var minMaxGradient = context.GetOptionalFeature <MinMaxGradientFeature>();
// If more than one are provided,
this.CheckIncompatibleFeatures(color, gradient, minMaxColor, minMaxGradient);
var instance = ParticlePrefab.Clone(position);
if (color != null)
{
SetParticleColor(instance, color.Color);
}
if (gradient != null)
{
SetParticleColor(instance, gradient.Gradient);
}
if (minMaxColor != null)
{
SetParticleColor(instance, minMaxColor);
}
if (minMaxGradient != null)
{
SetParticleColor(instance, minMaxGradient);
}
var material = context.GetOptionalFeature <MaterialFeature>();
if (material != null)
{
var renderer = instance.GetComponent <ParticleSystemRenderer>();
renderer.sharedMaterial = material.Material;
}
OnDefaultSetupFinished(instance, context);
if (!ForceDestroyOnFinished)
{
return;
}
var main = instance.main;
main.stopAction = ParticleSystemStopAction.Destroy;
if (!main.playOnAwake)
{
instance.Play();
}
}
public void Apply(EffectContext ctx)
{
var newContext = new EffectContext(
ctx.Source,
new Multiple(ctx.Target.Members.Except(ctx.Source).ToArray()),
ctx.PlayerState,
ctx.BattleMembers);
_origin.Apply(newContext);
}
public override bool Apply(IActionLog log, EffectContext context)
{
context.SFX.Trigger("ChargeUp", context.Target.GetNominalPosition());
if (context?.Target != null && Ability != null &&
!context.Target.HasData(Ability.GetType()))
{
context.Target.Data.Add(Ability.Duplicate());
}
return(false);
}
public ReplayEffectsController(
ILogger <ReplayEffectsController> logger,
ILogger <RecordHandler> handlerLogger,
EffDbContext dbContext,
EffectContext effCtx,
AuthorsController ctr,
IEnumerable <ControllerBase> controllers)
: base(logger, handlerLogger, dbContext, effCtx)
{
Authors = ctr;
Controllers = controllers;
}
public CommandGenerator(CommandBuffer commandBuffer, RendererSystemContext rendererContext, VoiceContext voiceContext, MixContext mixContext, EffectContext effectContext, SinkContext sinkContext, SplitterContext splitterContext, PerformanceManager performanceManager)
{
_commandBuffer = commandBuffer;
_rendererContext = rendererContext;
_voiceContext = voiceContext;
_mixContext = mixContext;
_effectContext = effectContext;
_sinkContext = sinkContext;
_splitterContext = splitterContext;
_performanceManager = performanceManager;
_commandBuffer.GenerateClearMixBuffer(Constants.InvalidNodeId);
}
public override void Play(EffectContext context)
{
var controller = TimeController.Instance;
if (UseTimeControllerIfPresent && controller != null)
{
controller.RegisterTimedService(Duration, CreateTimeMeta(), priority: ServicePriority);
}
else
{
context.StartCoroutine(PlayDefault());
}
}
private float LoadLoopDuration(EffectContext context)
{
switch (LoopDuration.Source)
{
case PropertySource.Effect:
return(LoopDuration.Value.Evaluate());
case PropertySource.Context:
return(context.GetRequiredFeatureWithTags <FloatFeature>(LoopDuration.TagName).Value);
default:
throw new ArgumentOutOfRangeException();
}
}
private ParticleSystem.MinMaxCurve LoadPitch(EffectContext context)
{
switch (Pitch.Source)
{
case PropertySource.Effect:
return(Pitch.Value);
case PropertySource.Context:
return(context.GetRequiredFeatureWithTags <MinMaxCurveFeature>(Pitch.TagName).Curve);
default:
throw new ArgumentOutOfRangeException();
}
}
public void CheckTriggers(TriggerEvent evt, GameState gameState, List<WaitingTrigger> TriggersFound)
{
if(type.triggers.Count == 0)
return;
EffectContext context = new EffectContext(gameState, this, evt, null);
foreach (TriggeredAbility ability in type.triggers)
{
if (ability.WillTrigger(evt.type, context))
{
TriggersFound.Add(new WaitingTrigger(evt, ability, this, position));
}
}
}
public float Evaluate(EffectContext context)
{
switch (Source)
{
case PropertySource.Effect:
return(Value.Evaluate());
case PropertySource.Context:
return(context.GetRequiredFeatureWithTags <FloatFeature>(TagName).Value);
default:
throw new ArgumentOutOfRangeException();
}
}
public override void Play(EffectContext context)
{
var position = context.GetOptionalFeature <PositionFeature>();
var clip = Clips.RandomElement();
AudioController controller;
if (UseAudioControllerIfPresent && (controller = AudioController.Instance) != null)
{
PlayWithController(position, context, clip, controller);
}
else
{
var pos = position == null ? context.Host.transform.position : position.Position;
PlayStandalone(pos, clip, context);
}
}
public override void Play(EffectContext context)
{
if (UseShakeControllerIfPresent)
{
var f = context.GetOptionalFeature <ObjectFeature <ObjectShakeController> >();
if (f != null)
{
f.Value.RegisterTimedService(
Duration.Evaluate(context),
new ShakeMeta()
);
return;
}
}
PlayStandalone(context);
}
public AudioRenderSystem(AudioRendererManager manager, IWritableEvent systemEvent)
{
_manager = manager;
_terminationEvent = new ManualResetEvent(false);
_dspMemoryPoolState = MemoryPoolState.Create(MemoryPoolState.LocationType.Dsp);
_voiceContext = new VoiceContext();
_mixContext = new MixContext();
_sinkContext = new SinkContext();
_splitterContext = new SplitterContext();
_effectContext = new EffectContext();
_commandProcessingTimeEstimator = null;
_systemEvent = systemEvent;
_behaviourContext = new BehaviourContext();
_totalElapsedTicksUpdating = 0;
_sessionId = 0;
}
public void OnDrawFrame(IGL10 gl)
{
try
{
if (!MInitialized)
{
//Only need to do this once
MEffectContext = EffectContext.CreateWithCurrentGlContext();
MTexRenderer.Init();
LoadTextures();
MInitialized = true;
}
if (MCurrentEffect != PhotoFilter.None || MCustomEffect != null)
{
//if an effect is chosen initialize it and apply it to the texture
InitEffect();
ApplyEffect();
}
RenderResult();
if (!IsSaveImage)
{
return;
}
MFilterBitmap = BitmapUtil.CreateBitmapFromGlSurface(this, gl);
SetSourceBitmap(MFilterBitmap);
Log.Debug("ImageFilterView", "onDrawFrame: " + MFilterBitmap);
IsSaveImage = false;
if (MOnSaveBitmap != null)
{
new Handler(Looper.MainLooper).Post(new Runnable(Run));
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public void OnDrawFrame(IGL10 gl)
{
if (!_isInitialised)
{
_effectContext = EffectContext.CreateWithCurrentGlContext();
Renderer.Init();
LoadTextures();
_isInitialised = true;
}
if (CurrentEffect != Resource.Id.none)
{
InitialiseEffect();
ApplyEffect();
}
RenderResult();
}
protected override bool BeginRenderEffectOverride(Texture texture, RenderContext renderContext)
{
if (_refresh)
{
_effectContext = new EffectContext();
_refresh = false;
}
RectangleF rect = renderContext.OccupiedTransformedBounds;
SizeF frameSize = new SizeF(rect.Width, rect.Height);
_effectContext.ExtraParameters = GetShaderParameters();
_effectContext.ShaderEffect = _shaderEffectName;
Vector4 lastFrameData = new Vector4(rect.Width, rect.Height, 0.0f, 0.0f);
_effectContext.StartRender(renderContext, frameSize, texture, CROP_FULLSIZE, 0, lastFrameData);
return(true);
}
public static Vector3 GetOffset(EffectContext context, float time, PingPongValues values, ShakeMode mode,
ContinousModularFloat intensity, ShakeDimension dimensions)
{
Vector3 direction;
switch (mode)
{
case ShakeMode.PingPong:
direction = Vector3.one;
values.Affect(ref direction);
break;
case ShakeMode.Random:
direction = new Vector3(
UnityEngine.Random.value,
UnityEngine.Random.value,
UnityEngine.Random.value
);
break;
default:
throw new ArgumentOutOfRangeException("mode", mode, null);
}
direction.Normalize();
if ((dimensions & ShakeDimension.FirstDimension) != ShakeDimension.FirstDimension)
{
direction.x = 0;
}
if ((dimensions & ShakeDimension.SecondDimension) != ShakeDimension.SecondDimension)
{
direction.y = 0;
}
if ((dimensions & ShakeDimension.ThirdDimension) != ShakeDimension.ThirdDimension)
{
direction.z = 0;
}
return(direction * intensity.Evaluate(context, time));
}
//EffectContext _effectContext;
public override void Initialize(EffectContext effectContext, TransformGraph transformGraph)
{
//WARNING : as soon as TransformGraph.SetSingleTransformNode is called it chain calls the
//SetDrawInformation via a callbac. Unfortunately this is too early because the code below
//within this method is used to populate stateful data needed by the SetDrawInformation call.
//transformGraph.SetSingleTransformNode(this);
var path = Windows.ApplicationModel.Package.Current.InstalledLocation.Path;
byte[] vertexShaderBytecode = NativeFile.ReadAllBytes(path + "\\WaveEffect.cso");
effectContext.LoadVertexShader(GUID_WaveVertexShader, vertexShaderBytecode);
// Only generate the vertex buffer if it has not already been initialized.
vertexBuffer = effectContext.FindVertexBuffer(GUID_WaveVertexBuffer);
if (vertexBuffer == null)
{
//InitializeVertexBuffer(effectContext);
var mesh = GenerateMesh();
// Updating geometry every time the effect is rendered can be costly, so it is
// recommended that vertex buffer remain static if possible (which it is in this
// sample effect).
using (var stream = DataStream.Create(mesh, true, true))
{
var vbProp = new VertexBufferProperties(1, VertexUsage.Static, stream);
var cvbProp = new CustomVertexBufferProperties(vertexShaderBytecode, new[] {
new InputElement("MESH_POSITION", 0, SharpDX.DXGI.Format.R32G32_Float, 0, 0),
}, Utilities.SizeOf <Vector2>());
// The GUID is optional, and is provided here to register the geometry globally.
// As mentioned above, this avoids duplication if multiple versions of the effect
// are created.
vertexBuffer = new VertexBuffer(effectContext, GUID_WaveVertexBuffer, vbProp, cvbProp);
}
}
PrepareForRender(ChangeType.Properties | ChangeType.Context);
transformGraph.SetSingleTransformNode(this);
}
public void Apply(EffectContext ctx)
{
ctx.Target.Members.ForEach(m =>
{
var amount = Mathf.CeilToInt(_damage.Calculate(ctx.Source, m) * m.State.Damagability());
if (m.State.Damagability() < 0.01)
{
BattleLog.Write($"{m.Name} is Invincible");
}
else if (amount < 1)
{
BattleLog.Write($"Dealing {amount} to {m.Name}");
}
else
{
BattleLog.Write($"Dealing {amount} to {m.Name}");
}
m.State.TakeDamage(amount);
});
}
public override void Play(EffectContext context)
{
var controller = context.GetRequiredFeature <ObjectFeature <FOVController> >().Value;
FOVMeta meta;
switch (Mode)
{
case ValueControlMode.Constant:
meta = new ConstantFOVMeta(ConstantFOV);
break;
case ValueControlMode.Animated:
meta = new AnimatedFOVMeta(AnimatedFOV);
break;
default:
throw new ArgumentOutOfRangeException();
}
controller.RegisterTimedService(Duration, meta, priority: ServicePriority);
}
private bool HandleSpecific(EffectContext context, out decimal value)
{
if (context.Equals(StaticEffectContext.CriticalDamage))
{
var criticalDamage = SafeReadStaticEffect(StaticEffectContext.CriticalDamage) ?? 0;
var attack = SafeReadStaticEffect(StaticEffectContext.Attack) ?? 0;
value = (int)(criticalDamage + attack * .8m);
return(true);
}
if (context.Equals(StaticEffectContext.Hp))
{
var hp = SafeReadStaticEffect(StaticEffectContext.Hp) ?? 0;
var hpRate = SafeReadStaticEffect(StaticEffectContext.HpRate) ?? 0;
var baseHp = _character.Get() !.BaseEffect.First(x => x.Context.Equals(StaticEffectContext.Hp)).Value;
value = (int)(hp + baseHp * hpRate);
return(true);
}
if (context.Equals(StaticEffectContext.HpRate))
{
throw new ApplicationInvalidOperationException(StaticEffectContext.Hp);
}
// It should process by equipment itself
if (context.Equals(StaticEffectContext.WeaponAttack) ||
context.Equals(StaticEffectContext.WeaponAttackRate) ||
context.Equals(StaticEffectContext.GearDefense) ||
context.Equals(StaticEffectContext.GearDefenseRate))
{
Console.WriteLine($"WARN: Context {context} not handle correctly");
value = 0;
throw new InvalidOperationException();
}
value = 0;
return(false);
}
public override bool Apply(IActionLog log, EffectContext context)
{
if (Exit.TravelTo != null && context.Target != null)
{
if (context.State is BasicGameState <MapStage> )
{
var bgstate = (BasicGameState <MapStage>)context.State;
if (bgstate.Elements.Remove(context.Target))
{
Exit.TravelTo.Elements.Add(context.Target);
Exit.TravelTo.Map[Exit.CellIndex].PlaceInCell(context.Target);
if (context.Target == bgstate.Controlled)
{
// Change the current stage
bgstate.Stage = Exit.TravelTo;
}
}
return(true);
}
}
return(false);
}
public override TriggerItem get(EffectContext context)
{
return value;
}
public override TriggerItem get(EffectContext context)
{
return TriggerItem.create(context.self);
}
public override int get(EffectContext context)
{
return a.get(context) * b.get(context);
}
public override TriggerItem get(EffectContext context)
{
return context.trigger_target;
}
public override TriggerItem get(EffectContext context)
{
return context.trigger_source;
}
public override bool Test(TriggerItem item, EffectContext context)
{
return item.position == context.target.position;
}
public abstract int get(EffectContext context);
public override int get(EffectContext context)
{
List<Minion> list = context.gameState.getMinions(test, context);
return list.Count;
}
public void ApplyEffect(Effect_Base effect, EffectContext context)
{
if( effect != null )
effect.Apply(context);
}
public override bool Test(TriggerItem item, EffectContext context)
{
return item.permanent.isEnemy != context.self.isEnemy;
}
public override bool Test(TriggerItem item, EffectContext context)
{
return item.minionType != null && item.minionType.awakenType != null;
}
public override bool Test(TriggerItem item, EffectContext context)
{
foreach(Property_TriggerItem mtype in mtypes)
{
if (item.minionType == mtype.get(context).minionType)
return true;
}
return false;
}
public bool WillTrigger(TriggerType triggerType, EffectContext context)
{
if (type != triggerType)
return false;
if (sourceTest != null && !sourceTest.Test(context.trigger_source, context))
return false;
if (targetTest != null && !targetTest.Test(context.trigger_target, context))
return false;
return true;
}
public override bool Test(TriggerItem item, EffectContext context)
{
return item.permanent == context.self;
}
public override int get(EffectContext context)
{
if (context.textChanges == null)
return value;
else
return context.textChanges.Apply_int(value);
}
public abstract TriggerItem get(EffectContext context);
public abstract bool Test(TriggerItem item, EffectContext context);
public void Apply(EffectContext context)
{
effect.Apply(context);
}
public override int get(EffectContext context)
{
return context.gameState.GetResourceAmount(type);
}
public List<Minion> getMinions(TriggerItemTest test, EffectContext context)
{
List<Minion> result = new List<Minion>();
foreach (KeyValuePair<Point, Minion> kv in minions)
{
if (test.Test(TriggerItem.create(kv.Value), context))
{
result.Add(kv.Value);
}
}
return result;
}
