Enum EffectTemplate 

pub enum EffectTemplate {
    Draw {
        count: u8,
    },
    DealDamage {
        amount: u8,
        cancelable: bool,
    },
    AddPower {
        amount: i32,
        duration_turn: bool,
    },
    AddPowerIfTargetLevelAtLeast {
        amount: i32,
        min_level: u8,
        duration_turn: bool,
    },
    AddPowerByLevel {
        multiplier: i32,
        duration_turn: bool,
    },
    AddPowerIfBattleOpponentLevelAtLeast {
        amount: i32,
        min_level: u8,
        duration_turn: bool,
    },
    AddSoulIfBattleOpponentLevelAtLeast {
        amount: i32,
        min_level: u8,
        duration_turn: bool,
    },
    AddPowerIfBattleOpponentLevelExact {
        amount: i32,
        level: u8,
        duration_turn: bool,
    },
    AddPowerIfOtherAttackerMatches {
        amount: i32,
        duration_turn: bool,
        attacker_card_ids: Vec<CardId>,
    },
    AddSoul {
        amount: i32,
        duration_turn: bool,
    },
    AddSoulIfMiddleCenter {
        amount: i32,
    },
    AddLevel {
        amount: i32,
        duration_turn: bool,
    },
    FacingOpponentAddSoul {
        amount: i32,
    },
    CannotFrontalAttack {
        duration_turn: bool,
    },
    CannotBecomeReverse {
        duration_turn: bool,
    },
    CannotBeChosenByOpponentEffects {
        duration_turn: bool,
    },
    CannotMoveStagePosition {
        duration_turn: bool,
    },
    CannotPlayEventsFromHand {
        duration_turn: bool,
    },
    CannotPlayBackupFromHand {
        duration_turn: bool,
    },
    CannotStandDuringStandPhase {
        duration_turn: bool,
    },
    BattleOpponentMoveToMemoryOnReverse {
        duration_turn: bool,
    },
    EncoreStockCost {
        cost: u8,
        duration_turn: bool,
    },
    GrantAbilityDef {
        ability: Box<AbilityDef>,
        duration: GrantDuration,
    },
    FacingOpponentCannotMoveStagePosition,
    SelfCannotBecomeReverseIfFacingOpponent {
        max_level: Option<u8>,
        max_cost: Option<u8>,
        level_gt_source_level: bool,
    },
    SelfCannotFrontalAttackIfFacingOpponentHigherLevel,
    ConditionalAddPower {
        amount: i32,
        turn: Option<ConditionTurn>,
        zone_count: Option<ZoneCountCondition>,
        require_source_marker: bool,
        per_source_marker: bool,
        per_zone_count: bool,
        exclude_source: bool,
        target_ids: Vec<CardId>,
    },
    ConditionalAddLevel {
        amount: i32,
        turn: Option<ConditionTurn>,
        zone_count: Option<ZoneCountCondition>,
        require_source_marker: bool,
        per_source_marker: bool,
        per_zone_count: bool,
        exclude_source: bool,
        target_ids: Vec<CardId>,
    },
    TimedConditionalAddPower {
        amount: i32,
        duration_turn: bool,
        turn: Option<ConditionTurn>,
        zone_count: Option<ZoneCountCondition>,
        require_source_marker: bool,
        per_source_marker: bool,
        per_zone_count: bool,
        exclude_source: bool,
        target_ids: Vec<CardId>,
    },
    ConditionalCannotSideAttack {
        turn: Option<ConditionTurn>,
        zone_count: Option<ZoneCountCondition>,
        require_source_marker: bool,
        exclude_source: bool,
    },
    CannotSideAttack {
        duration_turn: bool,
    },
    MoveToMarker {
        target_ids: Vec<CardId>,
    },
    MoveTopDeckToMarker,
    MoveToHand,
    MoveToWaitingRoom,
    MoveToStock,
    MoveToClock,
    MoveToMemory,
    MoveToDeckBottom,
    MoveWaitingRoomCardToSourceSlot {
        target_ids: Vec<CardId>,
    },
    RecycleWaitingRoomToDeckShuffle,
    ResetStockFromDeckTop {
        target: TargetSide,
    },
    Heal,
    HealIfSourcePlayedFromHandThisTurn,
    RestTarget,
    StandTarget,
    StockCharge {
        count: u8,
    },
    MillTop {
        target: TargetSide,
        count: u8,
    },
    MoveStageSlot {
        slot: u8,
    },
    MoveThisToOpenCenter {
        require_facing: bool,
    },
    MoveThisToOpenBack,
    SwapStageSlots,
    RandomDiscardFromHand {
        target: TargetSide,
        count: u8,
    },
    RandomMill {
        target: TargetSide,
        count: u8,
    },
    RevealZoneTop {
        target: TargetSide,
        zone: TargetZone,
        count: u8,
        audience: RevealAudience,
    },
    RevealTopIfLevelAtLeastMoveThisToHand {
        min_level: u8,
    },
    RevealTopIfLevelAtLeastRestThis {
        min_level: u8,
    },
    RevealTopIfLevelAtLeastMoveTopToStock {
        min_level: u8,
    },
    LookTopDeckReorder {
        count: u8,
    },
    LookTopCardTopOrWaitingRoom,
    LookTopCardTopOrBottom,
    SearchTopDeckToHandLevelAtLeastMillRest {
        look_count: u8,
        choose_count: u8,
        min_level: u8,
    },
    RevealTopAndSalvageByRevealedLevel {
        count: u8,
        climax_level: u8,
    },
    ChangeController,
    CounterBackup {
        power: i32,
    },
    CounterDamageReduce {
        amount: u8,
    },
    CounterDamageCancel,
    TriggerIcon {
        icon: TriggerIcon,
    },
    BattleOpponentReverseIf {
        max_level: Option<u8>,
        max_cost: Option<u8>,
        level_gt_opponent_level: bool,
    },
    BattleOpponentMoveToDeckBottomIf {
        max_level: Option<u8>,
        max_cost: Option<u8>,
        level_gt_opponent_level: bool,
    },
    BattleOpponentMoveToStockThenBottomStockToWaitingRoomIf {
        max_level: Option<u8>,
        max_cost: Option<u8>,
        level_gt_opponent_level: bool,
    },
    BattleOpponentMoveToClockAfterClockTopToWaitingRoomIf {
        max_level: Option<u8>,
        max_cost: Option<u8>,
        level_gt_opponent_level: bool,
    },
    BattleOpponentMoveToMemoryIf {
        max_level: Option<u8>,
        max_cost: Option<u8>,
        level_gt_opponent_level: bool,
    },
    BattleOpponentMoveToClockIf {
        max_level: Option<u8>,
        max_cost: Option<u8>,
        level_gt_opponent_level: bool,
    },
    BattleOpponentMoveIf {
        destination: BattleOpponentMoveDestination,
        prelude: Option<BattleOpponentMovePreludeAction>,
        max_level: Option<u8>,
        max_cost: Option<u8>,
        level_gt_opponent_level: bool,
    },
    BattleOpponentTopDeckToStockIf {
        min_level: u8,
    },
    Brainstorm {
        reveal_count: u8,
        per_climax: u8,
        mode: BrainstormMode,
    },
    SetTriggerCheckCount {
        count: u8,
    },
    RestThisIfNoOtherRestCenter,
    CannotUseAutoEncoreForPlayer {
        target: TargetSide,
    },
    ConditionalAddSoul {
        amount: i32,
        turn: Option<ConditionTurn>,
        zone_count: Option<ZoneCountCondition>,
        require_source_marker: bool,
        per_source_marker: bool,
        per_zone_count: bool,
        exclude_source: bool,
        target_ids: Vec<CardId>,
    },
    SetTerminalOutcome {
        outcome: TerminalOutcomeSpec,
    },
    ApplyRuleOverride {
        kind: RuleOverrideKind,
    },
}

Effect template used by ability definitions.

Variants

Draw

Draw cards.

Fields

count: u8

Number of cards to draw.

DealDamage

Deal damage (optionally cancelable).

Fields

amount: u8

Damage amount to deal.

cancelable: bool

Whether damage can be canceled by revealing a climax.

AddPower

Add power for a duration.

Fields

amount: i32

Power magnitude to add.

duration_turn: bool

If true, expires at end of turn; otherwise lasts while on stage.

AddPowerIfTargetLevelAtLeast

Add power when the target’s level is at least a threshold.

Fields

amount: i32

Power magnitude to add.

min_level: u8

Minimum level threshold for the target.

duration_turn: bool

If true, expires at end of turn; otherwise lasts while on stage.

AddPowerByLevel

Add power scaled by the target’s level for a duration.

Fields

multiplier: i32

Power multiplier per (computed) level.

duration_turn: bool

If true, expires at end of turn; otherwise lasts while on stage.

AddPowerIfBattleOpponentLevelAtLeast

Add power to the source card if its battle opponent’s level is at least a threshold.

Fields

amount: i32

Power magnitude to add.

min_level: u8

Minimum level threshold for the battle opponent.

duration_turn: bool

If true, expires at end of turn; otherwise lasts while on stage.

AddSoulIfBattleOpponentLevelAtLeast

Add soul to the source card if its battle opponent’s level is at least a threshold.

Fields

amount: i32

Soul magnitude to add.

min_level: u8

Minimum level threshold for the battle opponent.

duration_turn: bool

If true, expires at end of turn; otherwise lasts while on stage.

AddPowerIfBattleOpponentLevelExact

Add power to the source card if its battle opponent’s level matches exactly.

Fields

amount: i32

Power magnitude to add.

level: u8

Required battle opponent level.

duration_turn: bool

If true, expires at end of turn; otherwise lasts while on stage.

AddPowerIfOtherAttackerMatches

Add power when another attacking character matches one of the provided card ids.

Fields

amount: i32

Power magnitude to add.

duration_turn: bool

If true, expires at end of turn; otherwise lasts while on stage.

attacker_card_ids: Vec<CardId>

Allowed attacker card ids to match against.

AddSoul

Add soul for a duration.

Fields

amount: i32

Soul magnitude to add.

duration_turn: bool

If true, expires at end of turn; otherwise lasts while on stage.

AddSoulIfMiddleCenter

Add soul while this card occupies the middle center-stage position.

Fields

amount: i32

Soul magnitude to add.

AddLevel

Add level for a duration.

Fields

amount: i32

Level magnitude to add.

duration_turn: bool

If true, expires at end of turn; otherwise lasts while on stage.

FacingOpponentAddSoul

Continuous-style soul modifier applied to the character facing the source card.

Fields

amount: i32

Soul magnitude to add.

CannotFrontalAttack

Disallow frontal attacks for a duration.

Fields

duration_turn: bool

If true, expires at end of turn; otherwise lasts while on stage.

CannotBecomeReverse

Prevent becoming REVERSE in battle for a duration.

Fields

duration_turn: bool

If true, expires at end of turn; otherwise lasts while on stage.

CannotBeChosenByOpponentEffects

Prevent being chosen by opponent effects for a duration.

Fields

duration_turn: bool

If true, expires at end of turn; otherwise lasts while on stage.

CannotMoveStagePosition

Prevent moving to another stage position for a duration.

Fields

duration_turn: bool

If true, expires at end of turn; otherwise lasts while on stage.

CannotPlayEventsFromHand

Prevent playing events from hand for a duration.

Fields

duration_turn: bool

If true, expires at end of turn; otherwise lasts while on stage.

CannotPlayBackupFromHand

Prevent playing backups from hand for a duration.

Fields

duration_turn: bool

If true, expires at end of turn; otherwise lasts while on stage.

CannotStandDuringStandPhase

Prevent standing during stand phase for a duration.

Fields

duration_turn: bool

If true, expires at end of turn; otherwise lasts while on stage.

BattleOpponentMoveToMemoryOnReverse

Move this card’s battle opponent to memory when it becomes REVERSE in battle.

Fields

duration_turn: bool

If true, expires at end of turn; otherwise lasts while on stage.

EncoreStockCost

Set encore stock cost for target character.

Fields

cost: u8

Stock cost to pay for encore.

duration_turn: bool

If true, expires at end of turn; otherwise lasts while on stage.

GrantAbilityDef

Grant an ability definition to the target for a limited duration.

Fields

ability: Box<AbilityDef>

Ability definition to grant.

duration: GrantDuration

Duration for which the ability is granted.

FacingOpponentCannotMoveStagePosition

Continuous-style movement lock applied to the character facing the source card.

SelfCannotBecomeReverseIfFacingOpponent

Continuous-style self protection from becoming REVERSE while facing a matching opponent.

Fields

max_level: Option<u8>

Optional maximum opponent level allowed.

max_cost: Option<u8>

Optional maximum opponent cost allowed.

level_gt_source_level: bool

If true, require opponent level to exceed the source level.

SelfCannotFrontalAttackIfFacingOpponentHigherLevel

Continuous-style self restriction while facing a higher-level opponent.

ConditionalAddPower

Conditional continuous-style power modifier.

Fields

amount: i32

Power magnitude to add.

turn: Option<ConditionTurn>

Optional turn condition.

zone_count: Option<ZoneCountCondition>

Optional zone-count condition.

require_source_marker: bool

Whether the source must have at least one marker.

per_source_marker: bool

If true, scale magnitude by the number of markers under the source.

per_zone_count: bool

If true, scale magnitude by the zone-count value.

exclude_source: bool

If true, skip applying the modifier to the source card itself.

target_ids: Vec<CardId>

Optional target card-id filter.

ConditionalAddLevel

Conditional continuous-style level modifier.

Fields

amount: i32

Level magnitude to add.

turn: Option<ConditionTurn>

Optional turn condition.

zone_count: Option<ZoneCountCondition>

Optional zone-count condition.

require_source_marker: bool

Whether the source must have at least one marker.

per_source_marker: bool

If true, scale magnitude by the number of markers under the source.

per_zone_count: bool

If true, scale magnitude by the zone-count value.

exclude_source: bool

If true, skip applying the modifier to the source card itself.

target_ids: Vec<CardId>

Optional target card-id filter.

TimedConditionalAddPower

Conditional power modifier with explicit duration (usable by non-continuous abilities).

Fields

amount: i32

Power magnitude to add.

duration_turn: bool

If true, expires at end of turn; otherwise lasts while on stage.

turn: Option<ConditionTurn>

Optional turn condition.

zone_count: Option<ZoneCountCondition>

Optional zone-count condition.

require_source_marker: bool

Whether the source must have at least one marker.

per_source_marker: bool

If true, scale magnitude by the number of markers under the source.

per_zone_count: bool

If true, scale magnitude by the zone-count value.

exclude_source: bool

If true, skip applying the modifier to the source card itself.

target_ids: Vec<CardId>

Optional target card-id filter.

ConditionalCannotSideAttack

Conditional continuous-style cannot-side-attack modifier.

Fields

turn: Option<ConditionTurn>

Optional turn condition.

zone_count: Option<ZoneCountCondition>

Optional zone-count condition.

require_source_marker: bool

Whether the source must have at least one marker.

exclude_source: bool

If true, skip applying the modifier to the source card itself.

CannotSideAttack

Disallow side attacks for a duration.

Fields

duration_turn: bool

If true, expires at end of turn; otherwise lasts while on stage.

MoveToMarker

Move target card under the source card as a marker.

Fields

target_ids: Vec<CardId>

Optional target card-id filter.

MoveTopDeckToMarker

Move the top card of your deck under this card as a marker.

MoveToHand

Move target to hand.

MoveToWaitingRoom

Move target to waiting room.

MoveToStock

Move target to stock.

MoveToClock

Move target to clock.

MoveToMemory

Move target to memory.

MoveToDeckBottom

Move target to the bottom of deck.

MoveWaitingRoomCardToSourceSlot

Move a waiting-room card to the source card’s stage slot.

Fields

target_ids: Vec<CardId>

Optional target card-id filter.

RecycleWaitingRoomToDeckShuffle

Return all cards from waiting room to deck, then shuffle.

ResetStockFromDeckTop

Move all stock to waiting room, then refill stock from deck top by the same count.

Fields

target: TargetSide

Side whose stock is reset.

Heal

Heal (move top clock to waiting room).

HealIfSourcePlayedFromHandThisTurn

Heal only if the source card was played from hand this turn and remains on stage.

RestTarget

Rest the target.

StandTarget

Stand the target.

StockCharge

Stock charge by count.

Fields

count: u8

Number of cards to stock-charge.

MillTop

Mill top cards from deck.

Fields

target: TargetSide

Side whose deck is milled.

count: u8

Number of cards to mill.

MoveStageSlot

Move target to a specific stage slot.

Fields

slot: u8

Stage slot index.

MoveThisToOpenCenter

Move the source card to the first open center-stage slot.

Fields

require_facing: bool

Whether the source must currently be facing an opponent.

MoveThisToOpenBack

Move the source card to the first open back-stage slot.

SwapStageSlots

Swap two stage slots.

RandomDiscardFromHand

Random discard from hand.

Fields

target: TargetSide

Side whose hand is discarded from.

count: u8

Number of cards to discard.

RandomMill

Random mill from deck.

Fields

target: TargetSide

Side whose deck is milled.

count: u8

Number of cards to mill.

RevealZoneTop

Reveal the top of a zone.

Fields

target: TargetSide

Side whose zone is revealed.

zone: TargetZone

Zone to reveal cards from.

count: u8

Number of cards to reveal.

audience: RevealAudience

Reveal visibility audience.

RevealTopIfLevelAtLeastMoveThisToHand

Reveal the top card of your deck; if its level is at least min_level, move this card to hand. (Climax is treated as level 0.)

Fields

min_level: u8

Minimum level threshold for success.

RevealTopIfLevelAtLeastRestThis

Reveal the top card of your deck; if its level is at least min_level, rest this card. (Climax is treated as level 0.)

Fields

min_level: u8

Minimum level threshold for success.

RevealTopIfLevelAtLeastMoveTopToStock

Reveal the top card of your deck; if its level is at least min_level, move that revealed card to stock. (Climax is treated as level 0.)

Fields

min_level: u8

Minimum level threshold for success.

LookTopDeckReorder

Look at the top count cards of your deck and reorder them on top.

Fields

count: u8

Number of cards to look at and reorder.

LookTopCardTopOrWaitingRoom

Look at the top card and either leave it on top or move it to waiting room.

LookTopCardTopOrBottom

Look at the top card and either leave it on top or move it to deck bottom.

SearchTopDeckToHandLevelAtLeastMillRest

Look at top cards, move up to choose_count cards with level at least min_level to hand, and send the rest to waiting room.

Fields

look_count: u8

Number of cards to look at from the top of deck.

choose_count: u8

Maximum number of cards to move to hand.

min_level: u8

Minimum level threshold for cards eligible to move to hand.

RevealTopAndSalvageByRevealedLevel

Reveal top deck card, then salvage up to count waiting-room characters with level at most the revealed card’s level.

Fields

count: u8

Number of cards to salvage.

climax_level: u8

Level to treat a climax as during level comparisons.

ChangeController

Change controller of a card.

CounterBackup

Counter backup (power).

Fields

power: i32

Power magnitude to add.

CounterDamageReduce

Counter damage reduction.

Fields

amount: u8

Damage reduction magnitude.

CounterDamageCancel

Counter damage cancel.

TriggerIcon

Resolve a trigger icon effect directly.

Fields

icon: TriggerIcon

Trigger icon to resolve.

BattleOpponentReverseIf

Reverse this card’s current battle opponent when a condition is met.

Fields

max_level: Option<u8>

Optional maximum opponent level allowed.

max_cost: Option<u8>

Optional maximum opponent cost allowed.

level_gt_opponent_level: bool

If true, require this card’s level to exceed opponent level.

BattleOpponentMoveToDeckBottomIf

Move this card’s current battle opponent to the bottom of deck when a condition is met.

Fields

max_level: Option<u8>

Optional maximum opponent level allowed.

max_cost: Option<u8>

Optional maximum opponent cost allowed.

level_gt_opponent_level: bool

If true, require this card’s level to exceed opponent level.

BattleOpponentMoveToStockThenBottomStockToWaitingRoomIf

Move this card’s current battle opponent to stock, then move the bottom stock card to waiting room.

Fields

max_level: Option<u8>

Optional maximum opponent level allowed.

max_cost: Option<u8>

Optional maximum opponent cost allowed.

level_gt_opponent_level: bool

If true, require this card’s level to exceed opponent level.

BattleOpponentMoveToClockAfterClockTopToWaitingRoomIf

Move top opponent clock to waiting room, then move this card’s current battle opponent to clock.

Fields

max_level: Option<u8>

Optional maximum opponent level allowed.

max_cost: Option<u8>

Optional maximum opponent cost allowed.

level_gt_opponent_level: bool

If true, require this card’s level to exceed opponent level.

BattleOpponentMoveToMemoryIf

Move this card’s current battle opponent to memory when a condition is met.

Fields

max_level: Option<u8>

Optional maximum opponent level allowed.

max_cost: Option<u8>

Optional maximum opponent cost allowed.

level_gt_opponent_level: bool

If true, require this card’s level to exceed opponent level.

BattleOpponentMoveToClockIf

Move this card’s current battle opponent to clock when a condition is met.

Fields

max_level: Option<u8>

Optional maximum opponent level allowed.

max_cost: Option<u8>

Optional maximum opponent cost allowed.

level_gt_opponent_level: bool

If true, require this card’s level to exceed opponent level.

BattleOpponentMoveIf

Generalized battle-opponent movement effect.

Fields

destination: BattleOpponentMoveDestination

Destination zone for the battle opponent.

prelude: Option<BattleOpponentMovePreludeAction>

Optional prelude action applied before the destination move.

max_level: Option<u8>

Optional maximum opponent level allowed.

max_cost: Option<u8>

Optional maximum opponent cost allowed.

level_gt_opponent_level: bool

If true, require this card’s level to exceed opponent level.

BattleOpponentTopDeckToStockIf

Put the top card of your deck into your stock if this card’s battle opponent meets level threshold.

Fields

min_level: u8

Minimum opponent level threshold for success.

Brainstorm

Brainstorm resolver (reveal/mill then payoff per climax).

Fields

reveal_count: u8

Number of cards to reveal/mill.

per_climax: u8

Payoff multiplier per climax revealed.

mode: BrainstormMode

Brainstorm payoff mode.

SetTriggerCheckCount

Set the total trigger checks to perform this attack’s trigger step.

Fields

count: u8

Trigger check count to use.

RestThisIfNoOtherRestCenter

Rest the source card if no other rested center-stage character is present.

CannotUseAutoEncoreForPlayer

Prevent a player from using AUTO Encore for the rest of the turn.

Fields

target: TargetSide

Side to apply the restriction to.

ConditionalAddSoul

Conditional continuous-style soul modifier.

Appended to preserve postcard discriminants for existing WSDB payloads.

Fields

amount: i32

Soul magnitude to add.

turn: Option<ConditionTurn>

Optional turn condition.

zone_count: Option<ZoneCountCondition>

Optional zone-count condition.

require_source_marker: bool

Whether the source must have at least one marker.

per_source_marker: bool

If true, scale magnitude by the number of markers under the source.

per_zone_count: bool

If true, scale magnitude by the zone-count value.

exclude_source: bool

If true, skip applying the modifier to the source card itself.

target_ids: Vec<CardId>

Optional target card-id filter.

SetTerminalOutcome

Set terminal game outcome immediately.

Appended to preserve postcard discriminants for existing WSDB payloads.

Fields

outcome: TerminalOutcomeSpec

Terminal outcome to set.

ApplyRuleOverride

Apply a turn-scoped rule-action override.

Appended to preserve postcard discriminants for existing WSDB payloads.

Fields

kind: RuleOverrideKind

Rule override kind to apply.

Trait Implementations

impl Clone for EffectTemplate

fn clone(&self) -> EffectTemplate

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for EffectTemplate

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EffectTemplate

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for EffectTemplate

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for EffectTemplate

fn eq(&self, other: &EffectTemplate) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for EffectTemplate

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for EffectTemplate

impl StructuralPartialEq for EffectTemplate