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