Skip to content

Y
ygopro-THC-cards
Commit 694d0c7b authored by tsubaki's avatar tsubaki
Browse files
Options

1.999zyu update delete

parent 97071f63
Pipeline #10617 passed with stage
    in 50 seconds
    Hide whitespace changes
    Inline Side-by-side
    Showing with 0 additions and 3360 deletions
    script/constant.lua deleted 100644 → 0
    View file @ 97071f63
    --min/max value
    MIN_ID =1000 --4 digit, by DataManager::GetDesc()
    MAX_ID =268435455 --9 digit, by DataManager::GetDesc()
    MAX_COUNTER =65535 --max number for adding/removing counters, by card::add_counter(), field::remove_counter()
    --Locations 区域
    LOCATION_DECK =0x01 --卡组
    LOCATION_HAND =0x02 --手牌
    LOCATION_MZONE =0x04 --怪兽区
    LOCATION_SZONE =0x08 --魔陷区(0~4)+场地区(5)
    LOCATION_GRAVE =0x10 --墓地
    LOCATION_REMOVED =0x20 --除外区
    LOCATION_EXTRA =0x40 --额外
    LOCATION_OVERLAY =0x80 --超量素材
    LOCATION_ONFIELD =0x0c --场上（LOCATION_MZONE+LOCATION_SZONE）
    --Locations (for redirect) 若在重定向类效果中指定LOCATION_DECK则为弹回卡组顶部
    LOCATION_DECKBOT =0x10001 --弹回卡组底部
    LOCATION_DECKSHF =0x20001 --弹回卡组并洗牌
    --Locations of spell cards
    LOCATION_FZONE =0x100 --场地区
    LOCATION_PZONE =0x200 --灵摆区
    --Positions 表示形式
    POS_FACEUP_ATTACK =0x1 --表侧攻击
    POS_FACEDOWN_ATTACK =0x2 --(reserved)
    POS_FACEUP_DEFENSE =0x4 --表侧守备
    POS_FACEDOWN_DEFENSE =0x8 --里侧守备
    POS_FACEUP =0x5 --正面表示
    POS_FACEDOWN =0xa --背面表示
    POS_ATTACK =0x3 --攻击表示
    POS_DEFENSE =0xc --守备表示
    NO_FLIP_EFFECT =0x10000--不发动反转效果
    --Types 卡片类型
    TYPE_MONSTER =0x1 --怪兽卡
    TYPE_SPELL =0x2 --魔法卡
    TYPE_TRAP =0x4 --陷阱卡
    TYPE_NORMAL =0x10 --通常怪兽
    TYPE_EFFECT =0x20 --效果
    TYPE_FUSION =0x40 --融合
    TYPE_RITUAL =0x80 --仪式
    TYPE_TRAPMONSTER =0x100 --陷阱怪兽
    TYPE_SPIRIT =0x200 --灵魂
    TYPE_UNION =0x400 --同盟
    TYPE_DUAL =0x800 --二重
    TYPE_TUNER =0x1000 --调整
    TYPE_SYNCHRO =0x2000 --同调
    TYPE_TOKEN =0x4000 --衍生物
    TYPE_QUICKPLAY =0x10000 --速攻
    TYPE_CONTINUOUS =0x20000 --永续
    TYPE_EQUIP =0x40000 --装备
    TYPE_FIELD =0x80000 --场地
    TYPE_COUNTER =0x100000 --反击
    TYPE_FLIP =0x200000 --翻转
    TYPE_TOON =0x400000 --卡通
    TYPE_XYZ =0x800000 --超量
    TYPE_PENDULUM =0x1000000 --灵摆
    TYPE_SPSUMMON =0x2000000 --特殊召唤
    TYPE_LINK =0x4000000 --连接
    --Attributes 属性
    ATTRIBUTE_EARTH =0x01 --地
    ATTRIBUTE_WATER =0x02 --水
    ATTRIBUTE_FIRE =0x04 --炎
    ATTRIBUTE_WIND =0x08 --风
    ATTRIBUTE_LIGHT =0x10 --光
    ATTRIBUTE_DARK =0x20 --暗
    ATTRIBUTE_DIVINE =0x40 --神
    --Races 种族
    RACE_ALL =0x1ffffff --全种族
    RACE_WARRIOR =0x1 --战士
    RACE_SPELLCASTER =0x2 --魔法师
    RACE_FAIRY =0x4 --天使
    RACE_FIEND =0x8 --恶魔
    RACE_ZOMBIE =0x10 --不死
    RACE_MACHINE =0x20 --机械
    RACE_AQUA =0x40 --水
    RACE_PYRO =0x80 --炎
    RACE_ROCK =0x100 --岩石
    RACE_WINDBEAST =0x200 --鸟兽
    RACE_PLANT =0x400 --植物
    RACE_INSECT =0x800 --昆虫
    RACE_THUNDER =0x1000 --雷
    RACE_DRAGON =0x2000 --龙
    RACE_BEAST =0x4000 --兽
    RACE_BEASTWARRIOR =0x8000 --兽战士
    RACE_DINOSAUR =0x10000 --恐龙
    RACE_FISH =0x20000 --鱼
    RACE_SEASERPENT =0x40000 --海龙
    RACE_REPTILE =0x80000 --爬虫类
    RACE_PSYCHO =0x100000 --念动力
    RACE_DIVINE =0x200000 --幻神兽
    RACE_CREATORGOD =0x400000 --创造神
    RACE_WYRM =0x800000 --幻龙
    RACE_CYBERSE =0x1000000 --电子界
    --Reason 卡片到当前位置的原因
    REASON_DESTROY =0x1 --破坏
    REASON_RELEASE =0x2 --解放
    REASON_TEMPORARY =0x4 --暂时
    REASON_MATERIAL =0x8 --作为融合/同调/超量素材或用於儀式/升級召喚
    REASON_SUMMON =0x10 --召唤
    REASON_BATTLE =0x20 --战斗破坏
    REASON_EFFECT =0x40 --效果
    REASON_COST =0x80 --用於代價或無法支付代價而破壞
    REASON_ADJUST =0x100 --调整（御前试合）
    REASON_LOST_TARGET =0x200 --失去装备对象
    REASON_RULE =0x400 --规则
    REASON_SPSUMMON =0x800 --特殊召唤
    REASON_DISSUMMON =0x1000 --召唤失败
    REASON_FLIP =0x2000 --翻转
    REASON_DISCARD =0x4000 --丢弃
    REASON_RDAMAGE =0x8000 --回復轉換後的傷害
    REASON_RRECOVER =0x10000 --傷害轉換後的回復
    REASON_RETURN =0x20000 --回到墓地
    REASON_FUSION =0x40000 --用於融合召喚
    REASON_SYNCHRO =0x80000 --用於同调召喚
    REASON_RITUAL =0x100000 --用於仪式召喚
    REASON_XYZ =0x200000 --用於超量召喚
    REASON_REPLACE =0x1000000 --代替
    REASON_DRAW =0x2000000 --抽卡
    REASON_REDIRECT =0x4000000 --改变去向（大宇宙，带菌等）
    REASON_REVEAL =0x8000000 --翻开卡组（森罗）
    REASON_LINK =0x10000000 --用于连接召唤
    REASON_LOST_OVERLAY =0x20000000 --超量素材随着超量怪兽离场
    --Location Reason
    LOCATION_REASON_TOFIELD =0x1 --Duel.GetLocationCount()預設值,凱薩競技場
    LOCATION_REASON_CONTROL =0x2 --Card.IsControlerCanBeChanged()使用
    --Summon Type --召唤类型
    SUMMON_TYPE_NORMAL =0x10000000 --通常召唤(EFFECT_SUMMON_PROC,EFFECT_SET_PROC 可用Value修改數值)
    SUMMON_TYPE_ADVANCE =0x11000000 --上级召唤
    SUMMON_TYPE_DUAL =0x12000000 --再度召唤（二重）
    SUMMON_TYPE_FLIP =0x20000000 --翻转召唤
    SUMMON_TYPE_SPECIAL =0x40000000 --特殊召唤(EFFECT_SPSUMMON_PROC,EFFECT_SPSUMMON_PROC_G 可用Value修改數值)
    SUMMON_TYPE_FUSION =0x43000000 --融合召唤
    SUMMON_TYPE_RITUAL =0x45000000 --仪式召唤
    SUMMON_TYPE_SYNCHRO =0x46000000 --同调召唤
    SUMMON_TYPE_XYZ =0x49000000 --超量召唤
    SUMMON_TYPE_PENDULUM =0x4a000000 --灵摆召唤
    SUMMON_TYPE_LINK =0x4c000000 --连接召唤
    --Summon Value --特定的召唤方式
    SUMMON_VALUE_SELF =0x1 --自身效果或条件
    SUMMON_VALUE_BLACK_GARDEN =0x10 --黑色花园
    SUMMON_VALUE_SYNCHRO_MATERIAL =0x11 --特殊召唤并作为同调素材（黑羽-东云之东风检查）
    SUMMON_VALUE_DARK_SANCTUARY =0x12 --暗黑圣域
    SUMMON_VALUE_LV =0x1000 --对应LV怪兽的效果
    SUMMON_VALUE_GLADIATOR =0x2000 --剑斗兽
    SUMMON_VALUE_EVOLTILE =0x4000 --进化虫
    --Status --卡片当前状态
    STATUS_DISABLED =0x0001 --效果被无效
    STATUS_TO_ENABLE =0x0002 --将变成有效
    STATUS_TO_DISABLE =0x0004 --将变成无效
    STATUS_PROC_COMPLETE =0x0008 --完成正规召唤（解除苏生限制）
    STATUS_SET_TURN =0x0010 --在本回合覆盖
    STATUS_NO_LEVEL =0x0020 --无等级
    STATUS_BATTLE_RESULT =0x0040 --傷害計算結果預計要破壞的怪獸
    STATUS_SPSUMMON_STEP =0x0080 --效果特召處理中
    STATUS_FORM_CHANGED =0x0100 --改变过表示形式
    STATUS_SUMMONING =0x0200 --召唤中
    STATUS_EFFECT_ENABLED =0x0400 --卡片準備就緒(不在移動、召喚、魔法陷阱發動中)
    STATUS_SUMMON_TURN =0x0800 --在本回合召喚/SET
    STATUS_DESTROY_CONFIRMED =0x1000 --破坏确定
    STATUS_LEAVE_CONFIRMED =0x2000 --連鎖處理完後送去墓地的魔法陷阱
    STATUS_BATTLE_DESTROYED =0x4000 --战斗破坏确定後尚未移動
    STATUS_COPYING_EFFECT =0x8000 --复制效果
    STATUS_CHAINING =0x10000 --正在連鎖串中
    STATUS_SUMMON_DISABLED =0x20000 --召唤无效後尚未移動
    STATUS_ACTIVATE_DISABLED =0x40000 --发动无效後尚未移動
    STATUS_EFFECT_REPLACED =0x80000 --效果被替代(红莲霸权)
    STATUS_FUTURE_FUSION =0x100000 --未来融合特殊召唤(不触发融合素材效果)
    STATUS_ATTACK_CANCELED =0x200000 --若其為攻擊者，則攻擊中止
    STATUS_INITIALIZING =0x400000 --初始化..
    STATUS_ACTIVATED =0x800000 --N/A
    STATUS_JUST_POS =0x1000000 --已改變表示形式(用於STATUS_CONTINUOUS_POS判定)
    STATUS_CONTINUOUS_POS =0x2000000 --改變後再次設定成其他表示形式
    STATUS_FORBIDDEN =0x4000000 --不能play
    STATUS_ACT_FROM_HAND =0x8000000 --從手牌发动
    STATUS_OPPO_BATTLE =0x10000000 --和對手的怪兽戰鬥
    STATUS_FLIP_SUMMON_TURN =0x20000000 --在本回合反转召唤
    STATUS_SPSUMMON_TURN =0x40000000 --在本回合特殊召唤
    --Assume
    ASSUME_CODE =1
    ASSUME_TYPE =2
    ASSUME_LEVEL =3
    ASSUME_RANK =4
    ASSUME_ATTRIBUTE =5
    ASSUME_RACE =6
    ASSUME_ATTACK =7
    ASSUME_DEFENSE =8
    --Link Marker
    LINK_MARKER_BOTTOM_LEFT =0x001 -- ↙
    LINK_MARKER_BOTTOM =0x002 -- ↓
    LINK_MARKER_BOTTOM_RIGHT =0x004 -- ↘
    LINK_MARKER_LEFT =0x008 -- ←
    LINK_MARKER_RIGHT =0x020 -- →
    LINK_MARKER_TOP_LEFT =0x040 -- ↖
    LINK_MARKER_TOP =0x080 -- ↑
    LINK_MARKER_TOP_RIGHT =0x100 -- ↗
    --Counter --指示物
    COUNTER_WITHOUT_PERMIT =0x1000 --可以放置在非特定對象的指示物
    COUNTER_NEED_ENABLE =0x2000 --在卡片本身放置上述指示物的標記(卡片守衛)
    --Phase --阶段
    PHASE_DRAW =0x01 --抽卡阶段
    PHASE_STANDBY =0x02 --准备阶段
    PHASE_MAIN1 =0x04 --主要阶段1
    PHASE_BATTLE_START =0x08 --战斗阶段开始
    PHASE_BATTLE_STEP =0x10 --战斗步驟
    PHASE_DAMAGE =0x20 --伤害步驟
    PHASE_DAMAGE_CAL =0x40 --伤害计算时
    PHASE_BATTLE =0x80 --战斗阶段結束
    PHASE_MAIN2 =0x100 --主要阶段2
    PHASE_END =0x200 --结束阶段
    --Player --玩家
    PLAYER_NONE =2 --2个玩家都不是
    PLAYER_ALL =3 --2个玩家都是
    --Chain info --连锁信息
    CHAININFO_CHAIN_COUNT =0x01 --连锁数
    CHAININFO_TRIGGERING_EFFECT =0x02 --连锁的效果
    CHAININFO_TRIGGERING_PLAYER =0x04 --连锁的玩家
    CHAININFO_TRIGGERING_CONTROLER =0x08 --连锁的卡的控制者
    CHAININFO_TRIGGERING_LOCATION =0x10 --连锁的位置
    CHAININFO_TRIGGERING_SEQUENCE =0x20 --连锁的位置的编号（指怪兽和魔陷区的格子）
    CHAININFO_TARGET_CARDS =0x40 --连锁的效果的对象（以下3个需要在target函数里设置）
    CHAININFO_TARGET_PLAYER =0x80 --连锁的效果的对象（玩家）
    CHAININFO_TARGET_PARAM =0x100 --连锁的效果的参数值
    CHAININFO_DISABLE_REASON =0x200 --无效的原因
    CHAININFO_DISABLE_PLAYER =0x400 --无效的玩家
    CHAININFO_CHAIN_ID =0x800 --连锁ID
    CHAININFO_TYPE =0x1000 --连锁类型
    CHAININFO_EXTTYPE =0x2000 --连锁额外类型
    CHAININFO_TRIGGERING_POSITION =0x4000 --连锁发生时的表示形式
    CHAININFO_TRIGGERING_CODE =0x8000 --连锁发生时的密码
    CHAININFO_TRIGGERING_CODE2 =0x10000 --连锁发生时的其他密码
    CHAININFO_TRIGGERING_LEVEL =0x40000 --连锁发生时的等级
    CHAININFO_TRIGGERING_RANK =0x80000 --连锁发生时的阶级
    CHAININFO_TRIGGERING_ATTRIBUTE =0x100000 --连锁发生时的属性
    CHAININFO_TRIGGERING_RACE =0x200000 --连锁发生时的种族
    CHAININFO_TRIGGERING_ATTACK =0x400000 --连锁发生时的攻击力
    CHAININFO_TRIGGERING_DEFENSE =0x800000 --连锁发生时的守备力
    --========== Reset ========== --重置条件（注意：重置条件可以多个相加）
    RESET_SELF_TURN =0x10000000 --自己回合的階段重置
    RESET_OPPO_TURN =0x20000000 --对方回合的階段重置
    RESET_PHASE =0x40000000 --阶段结束重置(一般和上面那些阶段配合使用)
    RESET_CHAIN =0x80000000 --连锁结束重置
    RESET_EVENT =0x1000 --指定的條件下重置(一般和下面这些事件配合使用)
    RESET_CARD =0x2000 --重置Owner為指定卡片的效果
    RESET_CODE =0x4000 --重置指定Code的single效果(不含EFFECT_FLAG_SINGLE_RANGE)
    RESET_COPY =0x8000 --重置以复制取得的效果
    RESET_DISABLE =0x00010000 --效果无效重置(只適用於owner==handler的效果)
    RESET_TURN_SET =0x00020000 --变里侧重置
    RESET_TOGRAVE =0x00040000 --去墓地重置(以下皆為事件觸發前重置)
    RESET_REMOVE =0x00080000 --除外重置
    RESET_TEMP_REMOVE =0x00100000 --暂时除外重置
    RESET_TOHAND =0x00200000 --回手牌或加入手牌重置
    RESET_TODECK =0x00400000 --回卡组重置
    RESET_LEAVE =0x00800000 --从场上移到其他位置/超量叠放重置
    RESET_TOFIELD =0x01000000 --到场上重置(move_to_field())
    RESET_CONTROL =0x02000000 --控制者变更重置
    RESET_OVERLAY =0x04000000 --超量叠放重置
    RESET_MSCHANGE =0x08000000 --从怪兽区到魔法区，或者从魔法区到怪兽区(move_to_field()、寶玉獸)
    ----组合时点
    RESETS_STANDARD =0x1fe0000 --RESET_TOFIELD+RESET_LEAVE+RESET_TODECK+RESET_TOHAND+RESET_TEMP_REMOVE+RESET_REMOVE+RESET_TOGRAVE+RESET_TURN_SET
    RESETS_REDIRECT =0xc7e0000 --RESETS_STANDARD+RESET_OVERLAY+RESET_MSCHANGE-RESET_TOFIELD-RESET_LEAVE (EFFECT_LEAVE_FIELD_REDIRECT)
    --========== Types ========== --效果类型（定义效果触发类型，和codes一起使用）
    EFFECT_TYPE_SINGLE =0x0001 --自己状态变化时触发
    EFFECT_TYPE_FIELD =0x0002 --场上所有卡状态变化时触发
    EFFECT_TYPE_EQUIP =0x0004 --装备效果
    EFFECT_TYPE_ACTIONS =0x0008 --触发型，以下類型會自動添加此屬性（对峙的G）
    EFFECT_TYPE_ACTIVATE =0x0010 --魔陷发动
    EFFECT_TYPE_FLIP =0x0020 --翻转效果
    EFFECT_TYPE_IGNITION =0x0040 --起动效果
    EFFECT_TYPE_TRIGGER_O =0x0080 --诱发选发效果
    EFFECT_TYPE_QUICK_O =0x0100 --诱发即时效果
    EFFECT_TYPE_TRIGGER_F =0x0200 --诱发必发效果
    EFFECT_TYPE_QUICK_F =0x0400 --诱发即时必发效果（熊猫龙等）
    EFFECT_TYPE_CONTINUOUS =0x0800 --由事件觸發的輔助用效果/永續效果
    EFFECT_TYPE_XMATERIAL =0x1000 --作为超量素材时超量怪兽获得的效果（十二兽）
    EFFECT_TYPE_GRANT =0x2000 --使其他卡片获得效果（天气模样）
    EFFECT_TYPE_TARGET =0x4000 --影响持续取的对象的效果（基本只用于魔陷）
    --========== Flags ========== --效果的特殊性质
    EFFECT_FLAG_INITIAL =0x0001 --可以发动的
    EFFECT_FLAG_FUNC_VALUE =0x0002 --此效果的Value属性是函数
    EFFECT_FLAG_COUNT_LIMIT =0x0004 --发动次数限制
    EFFECT_FLAG_FIELD_ONLY =0x0008 --此效果是注册给全局环境的
    EFFECT_FLAG_CARD_TARGET =0x0010 --取对象效果
    EFFECT_FLAG_IGNORE_RANGE =0x0020 --影响所有区域的卡（大宇宙）
    EFFECT_FLAG_ABSOLUTE_TARGET =0x0040 --Target Range不会因为控制权的改变而改变
    EFFECT_FLAG_IGNORE_IMMUNE =0x0080 --无视效果免疫
    EFFECT_FLAG_SET_AVAILABLE =0x0100 --影响场上里侧的卡/裡側狀態可發動
    EFFECT_FLAG_CANNOT_NEGATE =0x0200 --含有"此效果不會被無效"的敘述
    EFFECT_FLAG_CANNOT_DISABLE =0x0400 --效果不会被无效
    EFFECT_FLAG_PLAYER_TARGET =0x0800 --以玩家为对象
    EFFECT_FLAG_BOTH_SIDE =0x1000 --双方都能使用（部分场地，弹压）
    EFFECT_FLAG_COPY_INHERIT =0x2000 --若由复制的效果產生則继承其Reset属性
    EFFECT_FLAG_DAMAGE_STEP =0x4000 --可以在伤害步骤发动
    EFFECT_FLAG_DAMAGE_CAL =0x8000 --可以在伤害计算时发动
    EFFECT_FLAG_DELAY =0x10000 --場合型誘發效果、用於永續效果的EFFECT_TYPE_CONTINUOUS、神之化身/恐惧之源的攻击力变化最后计算
    EFFECT_FLAG_SINGLE_RANGE =0x20000 --只对自己有效
    EFFECT_FLAG_UNCOPYABLE =0x40000 --不能复制（效果外文本）
    EFFECT_FLAG_OATH =0x80000 --誓约效果
    EFFECT_FLAG_SPSUM_PARAM =0x100000 --指定召喚/规则特殊召唤的位置和表示形式(熔岩魔神)
    EFFECT_FLAG_REPEAT =0x200000 --神之化身的攻击力重复计算
    EFFECT_FLAG_NO_TURN_RESET =0x400000 --发条等“这张卡在场上只能发动一次”的效果
    EFFECT_FLAG_EVENT_PLAYER =0x800000 --视为对方玩家的效果（动作？）
    EFFECT_FLAG_OWNER_RELATE =0x1000000 --与效果owner关联的效果
    EFFECT_FLAG_CANNOT_INACTIVATE =0x2000000 --發動不會被無效
    EFFECT_FLAG_CLIENT_HINT =0x4000000 --客户端提示
    EFFECT_FLAG_CONTINUOUS_TARGET =0x8000000 --建立持續對象的永續魔法、永續陷阱、早埋系以外的裝備魔法卡
    EFFECT_FLAG_LIMIT_ZONE =0x10000000 --限制魔法·陷阱卡发动时可以放置的区域
    EFFECT_FLAG_COF =0x20000000 --N/A
    EFFECT_FLAG_CVAL_CHECK =0x40000000 --N/A
    EFFECT_FLAG_IMMEDIATELY_APPLY =0x80000000 --卡在发动时效果就立即适用
    EFFECT_FLAG2_NAGA =0x0001 --N/A
    EFFECT_FLAG2_COF =0x0002 --通常魔法卡在MP1以外发动（邪恶的仪式的特殊处理）
    --========== Codes ========== --对永续性效果表示效果类型(EFFECT开头)，对诱发型效果表示触发效果的事件/时点(EVENT开头)
    EFFECT_IMMUNE_EFFECT =1 --效果免疫
    EFFECT_DISABLE =2 --效果无效（技能抽取）
    EFFECT_CANNOT_DISABLE =3 --效果不能被无效
    EFFECT_SET_CONTROL =4 --设置控制权
    EFFECT_CANNOT_CHANGE_CONTROL =5 --不能改变控制权
    EFFECT_CANNOT_ACTIVATE =6 --玩家不能发动效果
    EFFECT_CANNOT_TRIGGER =7 --卡不能发动效果
    EFFECT_DISABLE_EFFECT =8 --效果无效（聖杯）
    EFFECT_DISABLE_CHAIN =9 --在連鎖串中無效(processor.cpp)
    EFFECT_DISABLE_TRAPMONSTER =10 --陷阱怪兽无效
    EFFECT_CANNOT_INACTIVATE =12 --发动不能被无效
    EFFECT_CANNOT_DISEFFECT =13 --效果處理時不能被无效
    EFFECT_CANNOT_CHANGE_POSITION =14 --不能改变表示形式
    EFFECT_TRAP_ACT_IN_HAND =15 --陷阱可以从手牌发动
    EFFECT_TRAP_ACT_IN_SET_TURN =16 --陷阱可以在盖放的回合发动
    EFFECT_REMAIN_FIELD =17 --X回合内留在场上（光之护封剑等）
    EFFECT_MONSTER_SSET =18 --怪兽可以在魔陷区放置
    EFFECT_CANNOT_SUMMON =20 --不能召唤怪兽
    EFFECT_CANNOT_FLIP_SUMMON =21 --不能翻转召唤怪兽
    EFFECT_CANNOT_SPECIAL_SUMMON =22 --不能特殊召唤怪兽
    EFFECT_CANNOT_MSET =23 --不能覆盖怪兽
    EFFECT_CANNOT_SSET =24 --不能覆盖魔陷
    EFFECT_CANNOT_DRAW =25 --不能抽卡
    EFFECT_CANNOT_DISABLE_SUMMON =26 --召唤不会无效
    EFFECT_CANNOT_DISABLE_SPSUMMON =27 --特殊召唤不会无效
    EFFECT_SET_SUMMON_COUNT_LIMIT =28 --限制每回合放置怪兽次数
    EFFECT_EXTRA_SUMMON_COUNT =29 --增加召唤（通常召唤）次数
    EFFECT_SPSUMMON_CONDITION =30 --特殊召唤条件
    EFFECT_REVIVE_LIMIT =31 --有苏生限制的怪獸(Card.EnableReviveLimit())
    EFFECT_SUMMON_PROC =32 --召唤规则效果
    EFFECT_LIMIT_SUMMON_PROC =33 --召唤规则限制
    EFFECT_SPSUMMON_PROC =34 --特殊召唤规则
    EFFECT_EXTRA_SET_COUNT =35 --增加盖放（通常召唤）次数
    EFFECT_SET_PROC =36 --放置（通常召唤）规则
    EFFECT_LIMIT_SET_PROC =37 --放置（通常召唤）规则限制
    EFFECT_DEVINE_LIGHT =38 --神圣光辉（魔术礼帽）
    EFFECT_CANNOT_DISABLE_FLIP_SUMMON =39 --翻转召唤不会无效
    EFFECT_INDESTRUCTABLE =40 --不会被破坏
    EFFECT_INDESTRUCTABLE_EFFECT =41 --不会被效果破坏
    EFFECT_INDESTRUCTABLE_BATTLE =42 --不会被战斗破坏
    EFFECT_UNRELEASABLE_SUM =43 --不能做上级召唤的祭品
    EFFECT_UNRELEASABLE_NONSUM =44 --不能做上级召唤以外的祭品
    EFFECT_DESTROY_SUBSTITUTE =45 --必選的代替破壞(此卡被破壞時用其他卡代替)
    EFFECT_CANNOT_RELEASE =46 --不能进行解放行为
    EFFECT_INDESTRUCTABLE_COUNT =47 --一回合几次不会被破坏
    EFFECT_UNRELEASABLE_EFFECT =48 --不能被解放
    EFFECT_DESTROY_REPLACE =50 --可選的代替破壞(將破壞改成其他動作)
    EFFECT_RELEASE_REPLACE =51 --代替解放
    EFFECT_SEND_REPLACE =52 --可以不送去XX而送去OO（甜点城堡等）
    EFFECT_CANNOT_DISCARD_HAND =55 --不能丢弃手牌
    EFFECT_CANNOT_DISCARD_DECK =56 --不能把卡组的卡送去墓地
    EFFECT_CANNOT_USE_AS_COST =57 --不能作为COST使用
    EFFECT_CANNOT_PLACE_COUNTER =58 --不能放置counter
    EFFECT_CANNOT_TO_GRAVE_AS_COST =59 --不能作为COST送去墓地
    EFFECT_LEAVE_FIELD_REDIRECT =60 --离场时重新指定去向
    EFFECT_TO_HAND_REDIRECT =61 --回手牌时重新指定去向
    EFFECT_TO_DECK_REDIRECT =62 --回卡组时重新指定去向
    EFFECT_TO_GRAVE_REDIRECT =63 --去墓地时重新指定去向
    EFFECT_REMOVE_REDIRECT =64 --除外时重新指定去向
    EFFECT_CANNOT_TO_HAND =65 --不能加入手牌
    EFFECT_CANNOT_TO_DECK =66 --不能回卡组
    EFFECT_CANNOT_REMOVE =67 --不能除外
    EFFECT_CANNOT_TO_GRAVE =68 --不能去墓地
    EFFECT_CANNOT_TURN_SET =69 --不能变里侧
    EFFECT_CANNOT_BE_BATTLE_TARGET =70 --不能成为攻击对象
    EFFECT_CANNOT_BE_EFFECT_TARGET =71 --不能成为效果对象
    EFFECT_IGNORE_BATTLE_TARGET =72 --不能成为攻击对象-鶸型（传说的渔人）
    EFFECT_CANNOT_DIRECT_ATTACK =73 --不能直接攻击
    EFFECT_DIRECT_ATTACK =74 --可以直接攻击
    EFFECT_DUAL_STATUS =75 --二重状态
    EFFECT_EQUIP_LIMIT =76 --装备对象限制
    EFFECT_DUAL_SUMMONABLE =77 --可以再度召唤
    EFFECT_UNION_LIMIT =78 --
    EFFECT_REVERSE_DAMAGE =80 --伤害变回复
    EFFECT_REVERSE_RECOVER =81 --回复变伤害
    EFFECT_CHANGE_DAMAGE =82 --改变伤害数值
    EFFECT_REFLECT_DAMAGE =83 --反射伤害
    EFFECT_CANNOT_ATTACK =85 --不能攻击
    EFFECT_CANNOT_ATTACK_ANNOUNCE =86 --不能攻击宣言
    EFFECT_CANNOT_CHANGE_POS_E =87 --不会被卡的效果变成守备表示（攻击性云魔物）
    EFFECT_ACTIVATE_COST =90 --发动代价（魔力之枷）
    EFFECT_SUMMON_COST =91 --召唤代价
    EFFECT_SPSUMMON_COST =92 --特殊召唤代价（暴君龙）
    EFFECT_FLIPSUMMON_COST =93 --翻转召唤代价
    EFFECT_MSET_COST =94 --怪兽放置代价
    EFFECT_SSET_COST =95 --魔陷放置代价
    EFFECT_ATTACK_COST =96 --攻击代价（霞之谷猎鹰）
    EFFECT_UPDATE_ATTACK =100 --改变攻击力（攻击力增加/减少）
    EFFECT_SET_ATTACK =101 --设置攻击力(永續型效果、攻擊力變成X特殊召喚)
    EFFECT_SET_ATTACK_FINAL =102 --设置最终攻击力(所有入連鎖的改變攻擊力)
    EFFECT_SET_BASE_ATTACK =103 --设置原本攻击力
    EFFECT_UPDATE_DEFENSE =104 --改变防御力
    EFFECT_SET_DEFENSE =105 --设置防御力
    EFFECT_SET_DEFENSE_FINAL =106 --设置最终防御力
    EFFECT_SET_BASE_DEFENSE =107 --设置原本防御力
    EFFECT_REVERSE_UPDATE =108 --倒置改变攻击力、防御力（天邪鬼）
    EFFECT_SWAP_AD =109 --交换攻防(超級漏洞人)
    EFFECT_SWAP_BASE_AD =110 --交换原本攻防
    EFFECT_SWAP_ATTACK_FINAL =111 --N/A
    EFFECT_SWAP_DEFENSE_FINAL =112 --N/A
    EFFECT_ADD_CODE =113 --增加卡名
    EFFECT_CHANGE_CODE =114 --改变卡名
    EFFECT_ADD_TYPE =115 --增加卡片种类（types）
    EFFECT_REMOVE_TYPE =116 --删除卡片种类
    EFFECT_CHANGE_TYPE =117 --改变卡片种类
    EFFECT_ADD_RACE =120 --增加种族
    EFFECT_REMOVE_RACE =121 --删除种族
    EFFECT_CHANGE_RACE =122 --改变种族
    EFFECT_ADD_ATTRIBUTE =125 --增加属性
    EFFECT_REMOVE_ATTRIBUTE =126 --删除属性
    EFFECT_CHANGE_ATTRIBUTE =127 --改变属性
    EFFECT_UPDATE_LEVEL =130 --改变等级
    EFFECT_CHANGE_LEVEL =131 --设置等级
    EFFECT_UPDATE_RANK =132 --改变阶级
    EFFECT_CHANGE_RANK =133 --设置阶级
    EFFECT_UPDATE_LSCALE =134 --改变左刻度
    EFFECT_CHANGE_LSCALE =135 --设置左刻度
    EFFECT_UPDATE_RSCALE =136 --改变右刻度
    EFFECT_CHANGE_RSCALE =137 --设置右刻度
    EFFECT_SET_POSITION =140 --設定表示形式
    EFFECT_SELF_DESTROY =141 --不入連鎖的破壞（罪系列等）
    EFFECT_SELF_TOGRAVE =142 --不入連鎖的送墓
    EFFECT_DOUBLE_TRIBUTE =150 --可以作为2个祭品
    EFFECT_DECREASE_TRIBUTE =151 --减少祭品
    EFFECT_DECREASE_TRIBUTE_SET =152 --减少放置怪兽的祭品
    EFFECT_EXTRA_RELEASE =153 --必須使用的代替解放（灵魂交错）
    EFFECT_TRIBUTE_LIMIT =154 --祭品限制
    EFFECT_EXTRA_RELEASE_SUM =155 --代替召唤解放（帝王的烈旋）
    EFFECT_TRIPLE_TRIBUTE =156 --N/A
    EFFECT_ADD_EXTRA_TRIBUTE =157 --增加可使用的祭品（真龙）
    EFFECT_EXTRA_RELEASE_NONSUM =158 --代替效果COST的解放（闇黒世界）
    EFFECT_PUBLIC =160 --公开手牌
    EFFECT_COUNTER_PERMIT =0x10000--允许放置指示物类型
    EFFECT_COUNTER_LIMIT =0x20000--允许放置指示物数量
    EFFECT_RCOUNTER_REPLACE =0x30000--代替取除指示物
    EFFECT_LPCOST_CHANGE =170 --改变生命值代价數值
    EFFECT_LPCOST_REPLACE =171 --以其他動作代替生命值代价
    EFFECT_SKIP_DP =180 --跳过抽卡阶段
    EFFECT_SKIP_SP =181 --跳过准备阶段
    EFFECT_SKIP_M1 =182 --跳过主要阶段1
    EFFECT_SKIP_BP =183 --跳过战斗阶段
    EFFECT_SKIP_M2 =184 --跳过主要阶段2
    EFFECT_CANNOT_BP =185 --不能进入战斗阶段
    EFFECT_CANNOT_M2 =186 --不能进入主要阶段2
    EFFECT_CANNOT_EP =187 --不能进入结束阶段
    EFFECT_SKIP_TURN =188 --跳过整个回合
    EFFECT_DEFENSE_ATTACK =190 --可以守备表示攻击
    EFFECT_MUST_ATTACK =191 --必须攻击
    EFFECT_FIRST_ATTACK =192 --必须第一个攻击
    EFFECT_ATTACK_ALL =193 --可以攻击所有怪兽
    EFFECT_EXTRA_ATTACK =194 --增加攻击次数
    EFFECT_MUST_BE_ATTACKED =195 --N/A
    EFFECT_ONLY_BE_ATTACKED =196 --只能攻击此卡
    EFFECT_ATTACK_DISABLED =197 --攻击已被無效(Duel.NegateAttack()成功的標記)
    EFFECT_NO_BATTLE_DAMAGE =200 --不会给对方造成战斗伤害
    EFFECT_AVOID_BATTLE_DAMAGE =201 --不会对自己造成战斗伤害
    EFFECT_REFLECT_BATTLE_DAMAGE =202 --反弹战斗伤害
    EFFECT_PIERCE =203 --贯穿伤害
    EFFECT_BATTLE_DESTROY_REDIRECT =204 --战斗破坏时重新指定去向
    EFFECT_BATTLE_DAMAGE_TO_EFFECT =205 --战斗伤害视为效果伤害
    EFFECT_BOTH_BATTLE_DAMAGE =206 --战斗伤害由双方承受
    EFFECT_ALSO_BATTLE_DAMAGE =207 --对自己的战斗伤害让对方也承受
    EFFECT_CHANGE_BATTLE_DAMAGE =208 --改变战斗伤害
    EFFECT_TOSS_COIN_REPLACE =220 --重新抛硬币
    EFFECT_TOSS_DICE_REPLACE =221 --重新掷骰子
    EFFECT_FUSION_MATERIAL =230 --指定融合素材的條件
    EFFECT_CHAIN_MATERIAL =231 --玩家受到連鎖物質的效果影響
    EFFECT_SYNCHRO_MATERIAL =232 --可以当作同调素材
    EFFECT_XYZ_MATERIAL =233 --可以当作超量素材
    EFFECT_FUSION_SUBSTITUTE =234 --代替融合素材
    EFFECT_CANNOT_BE_FUSION_MATERIAL =235--不能做融合素材
    EFFECT_CANNOT_BE_SYNCHRO_MATERIAL =236--不能做同调素材
    EFFECT_SYNCHRO_MATERIAL_CUSTOM =237--自定义Tuner的同调过程
    EFFECT_CANNOT_BE_XYZ_MATERIAL =238--不能做超量素材
    EFFECT_CANNOT_BE_LINK_MATERIAL =239--不能做连接素材
    EFFECT_SYNCHRO_LEVEL =240--做同调素材时的等级
    EFFECT_RITUAL_LEVEL =241--做仪式祭品时的等级
    EFFECT_XYZ_LEVEL =242--做超量素材时的等级
    EFFECT_EXTRA_RITUAL_MATERIAL =243--在墓地当做仪式祭品
    EFFECT_NONTUNER =244--同时当作调整以外的怪兽（幻影王 幽骑）
    EFFECT_OVERLAY_REMOVE_REPLACE =245--代替去除超量素材
    EFFECT_SCRAP_CHIMERA =246--废铁奇美拉
    EFFECT_TUNE_MAGICIAN_X =247--调弦之魔术师超量素材限制
    EFFECT_TUNE_MAGICIAN_F =248--调弦之魔术师融合素材限制
    EFFECT_PRE_MONSTER =250 --可存取怪獸的各項數值(Card.AddMonsterAttribute()專用)
    EFFECT_MATERIAL_CHECK =251 --检查素材
    EFFECT_DISABLE_FIELD =260 --无效区域（扰乱王等）
    EFFECT_USE_EXTRA_MZONE =261 --怪兽区域封锁
    EFFECT_USE_EXTRA_SZONE =262 --魔法区域封锁
    EFFECT_MAX_MZONE =263 --怪獸区格數上限
    EFFECT_MAX_SZONE =264 --魔陷区格數上限
    EFFECT_MUST_USE_MZONE =265 --必须使用怪兽区的格子
    EFFECT_HAND_LIMIT =270 --手牌数量限制
    EFFECT_DRAW_COUNT =271 --抽卡阶段的抽卡数
    EFFECT_SPIRIT_DONOT_RETURN =280 --灵魂怪兽不返回手牌
    EFFECT_SPIRIT_MAYNOT_RETURN =281 --灵魂怪兽可以不返回手牌
    EFFECT_CHANGE_ENVIRONMENT =290 --改变场地
    EFFECT_NECRO_VALLEY =291 --王家长眠之谷
    EFFECT_FORBIDDEN =292 --不能Play(禁止令)
    EFFECT_NECRO_VALLEY_IM =293 --不受「王家长眠之谷」的影响
    EFFECT_REVERSE_DECK =294 --翻转卡组
    EFFECT_REMOVE_BRAINWASHING =295 --洗脑解除
    EFFECT_BP_TWICE =296 --2次战斗阶段
    EFFECT_UNIQUE_CHECK =297 --場上只能存在1張(Card.SetUniqueOnField()專用)
    EFFECT_MATCH_KILL =300 --Match胜利(胜利龙)
    EFFECT_SYNCHRO_CHECK =310 --基因组斗士
    EFFECT_QP_ACT_IN_NTPHAND =311 --对方回合从自己手卡发动（失乐的圣女）
    EFFECT_MUST_BE_SMATERIAL =312 --必须作为同调素材（波动龙 声子龙）
    EFFECT_TO_GRAVE_REDIRECT_CB =313 --重新指定去向(寶玉獸)
    EFFECT_CHANGE_LEVEL_FINAL =314 --N/A
    EFFECT_CHANGE_RANK_FINAL =315 --N/A
    EFFECT_MUST_BE_FMATERIAL =316 --必须作为融合素材
    EFFECT_MUST_BE_XMATERIAL =317 --必须作为超量素材
    EFFECT_MUST_BE_LMATERIAL =318 --必须作为连接素材
    EFFECT_SPSUMMON_PROC_G =320 --P召唤规则
    EFFECT_SPSUMMON_COUNT_LIMIT =330 --特殊召唤次数限制
    EFFECT_LEFT_SPSUMMON_COUNT =331 --剩餘召喚次數(召喚限制網)
    EFFECT_CANNOT_SELECT_BATTLE_TARGET =332 --對手不能選擇為攻擊對象
    EFFECT_CANNOT_SELECT_EFFECT_TARGET =333 --對手不能選擇為效果對象
    EFFECT_ADD_SETCODE =334 --视为「XX」字段的效果
    EFFECT_NO_EFFECT_DAMAGE =335 --玩家已受到"效果傷害變成0"的效果影響
    EFFECT_UNSUMMONABLE_CARD =336 --N/A
    EFFECT_DISABLE_CHAIN_FIELD =337 --N/A
    EFFECT_DISCARD_COST_CHANGE =338 --反制陷阱捨棄手牌的代價改變(解放之阿里阿德涅)
    EFFECT_HAND_SYNCHRO =339 --用手牌的怪獸當作同步素材
    EFFECT_ADD_FUSION_CODE =340 --作为融合素材时可以当作某一卡名(融合识别)
    EFFECT_ADD_FUSION_SETCODE =341 --作为融合素材时可以当作某一字段(魔玩具改造)
    EFFECT_RISE_TO_FULL_HEIGHT =342 --N/A
    EFFECT_ONLY_ATTACK_MONSTER =343 --只能攻擊X
    EFFECT_MUST_ATTACK_MONSTER =344 --若攻擊則必須攻擊X
    EFFECT_PATRICIAN_OF_DARKNESS =345 --由對手選擇攻擊對象(黑暗貴族)
    EFFECT_EXTRA_ATTACK_MONSTER =346 --對怪獸攻擊X次
    EFFECT_UNION_STATUS =347 --同盟状态
    EFFECT_OLDUNION_STATUS =348 --旧同盟状态
    EFFECT_ADD_FUSION_ATTRIBUTE =349 --reserve
    EFFECT_REMOVE_FUSION_ATTRIBUTE =350 --reserve
    EFFECT_CHANGE_FUSION_ATTRIBUTE =351 --用作融合素材时的属性
    EFFECT_EXTRA_FUSION_MATERIAL =352 --增加融合素材(万溶炼金师)
    EFFECT_TUNER_MATERIAL_LIMIT =353 --同调素材限制
    EFFECT_ADD_LINK_CODE =354 --用作连接素材时的卡名
    EFFECT_ADD_LINK_SETCODE =355 --reserve
    EFFECT_ADD_LINK_ATTRIBUTE =356 --用作连接素材时的属性
    EFFECT_ADD_LINK_RACE =357 --用作连接素材时的种族
    EFFECT_EXTRA_LINK_MATERIAL =358 --手卡的连接素材
    EFFECT_QP_ACT_IN_SET_TURN =359 --速攻魔法可以在盖放的回合发动
    EFFECT_EXTRA_PENDULUM_SUMMON =360 --extra pendulum summon
    EFFECT_MATERIAL_LIMIT =361 --
    EFFECT_SET_BATTLE_ATTACK =362 --战斗的伤害计算用设置的攻击力进行
    EFFECT_SET_BATTLE_DEFENSE =363 --战斗的伤害计算用设置的守备力进行
    EFFECT_OVERLAY_RITUAL_MATERIAL =364 --此卡的超量素材也能用于仪式召唤
    --下面是诱发效果的诱发事件、时点 （如果是TYPE_SINGLE则自己发生以下事件后触发，如果TYPE_FIELD则场上任何卡发生以下事件都触发）
    EVENT_STARTUP =1000 --N/A
    EVENT_FLIP =1001 --翻转时
    EVENT_FREE_CHAIN =1002 --自由时点（强脱等，还有昴星团等诱发即时效果）
    EVENT_DESTROY =1010 --確定被破壞的卡片移動前
    EVENT_REMOVE =1011 --除外时
    EVENT_TO_HAND =1012 --加入手牌时
    EVENT_TO_DECK =1013 --回卡组时
    EVENT_TO_GRAVE =1014 --送去墓地时(不含REASON_RETURN)
    EVENT_LEAVE_FIELD =1015 --离场时
    EVENT_CHANGE_POS =1016 --表示形式变更时
    EVENT_RELEASE =1017 --解放时
    EVENT_DISCARD =1018 --丢弃手牌时
    EVENT_LEAVE_FIELD_P =1019 --離場的卡片移動前
    EVENT_CHAIN_SOLVING =1020 --连锁处理开始时（EVENT_CHAIN_ACTIVATING之後）
    EVENT_CHAIN_ACTIVATING =1021 --连锁处理准备中
    EVENT_CHAIN_SOLVED =1022 --连锁处理结束时
    EVENT_CHAIN_ACTIVATED =1023 --N/A
    EVENT_CHAIN_NEGATED =1024 --连锁发动无效时（EVENT_CHAIN_ACTIVATING之後）
    EVENT_CHAIN_DISABLED =1025 --连锁效果无效时
    EVENT_CHAIN_END =1026 --连锁串结束时
    EVENT_CHAINING =1027 --效果发动时
    EVENT_BECOME_TARGET =1028 --成为效果对象时
    EVENT_DESTROYED =1029 --被破坏时
    EVENT_MOVE =1030 --移動卡片(急兔馬)
    EVENT_ADJUST =1040 --adjust_all()调整後（御前试合）
    EVENT_BREAK_EFFECT =1050 --Duel.BreakEffect()被调用时
    EVENT_SUMMON_SUCCESS =1100 --通常召唤成功时
    EVENT_FLIP_SUMMON_SUCCESS =1101 --翻转召唤成功时
    EVENT_SPSUMMON_SUCCESS =1102 --特殊召唤成功时
    EVENT_SUMMON =1103 --召唤之际（怪兽还没上场、神宣等时点）
    EVENT_FLIP_SUMMON =1104 --翻转召唤之际
    EVENT_SPSUMMON =1105 --特殊召唤之际
    EVENT_MSET =1106 --放置怪兽时
    EVENT_SSET =1107 --放置魔陷时
    EVENT_BE_MATERIAL =1108 --作为融合/仪式同调/超量素材时
    EVENT_BE_PRE_MATERIAL =1109 --将要作为融合/仪式同调/超量素材时
    EVENT_DRAW =1110 --抽卡时
    EVENT_DAMAGE =1111 --造成战斗/效果伤害时
    EVENT_RECOVER =1112 --回复生命值时
    EVENT_PREDRAW =1113 --抽卡阶段通常抽卡前
    EVENT_SUMMON_NEGATED =1114 --召唤被无效时
    EVENT_FLIP_SUMMON_NEGATED =1115 --反转召唤被无效时
    EVENT_SPSUMMON_NEGATED =1116 --特殊召唤被无效时
    EVENT_CONTROL_CHANGED =1120 --控制权变更
    EVENT_EQUIP =1121 --装备卡装备时
    EVENT_ATTACK_ANNOUNCE =1130 --攻击宣言时
    EVENT_BE_BATTLE_TARGET =1131 --被选为攻击对象时
    EVENT_BATTLE_START =1132 --伤害步骤开始时（反转前）
    EVENT_BATTLE_CONFIRM =1133 --伤害计算前（反转後）
    EVENT_PRE_DAMAGE_CALCULATE =1134 --伤害计算时（羽斬）
    EVENT_DAMAGE_CALCULATING =1135 --N/A
    EVENT_PRE_BATTLE_DAMAGE =1136 --即将产生战斗伤害(只能使用EFFECT_TYPE_CONTINUOUS)
    EVENT_BATTLE_END =1137 --N/A
    EVENT_BATTLED =1138 --伤害计算后（异女、同反转效果时点）
    EVENT_BATTLE_DESTROYING =1139 --以战斗破坏怪兽送去墓地时（BF-苍炎之修罗）
    EVENT_BATTLE_DESTROYED =1140 --被战斗破坏送去墓地时（杀人番茄等）
    EVENT_DAMAGE_STEP_END =1141 --伤害步骤结束时
    EVENT_ATTACK_DISABLED =1142 --攻击无效时（翻倍机会）
    EVENT_BATTLE_DAMAGE =1143 --造成战斗伤害时
    EVENT_TOSS_DICE =1150 --掷骰子的结果产生后
    EVENT_TOSS_COIN =1151 --抛硬币的结果产生后
    EVENT_TOSS_COIN_NEGATE =1152 --重新抛硬币
    EVENT_TOSS_DICE_NEGATE =1153 --重新掷骰子
    EVENT_LEVEL_UP =1200 --等级上升时
    EVENT_PAY_LPCOST =1201 --支付生命值时
    EVENT_DETACH_MATERIAL =1202 --去除超量素材时
    EVENT_RETURN_TO_GRAVE =1203 --回到墓地时
    EVENT_TURN_END =1210 --回合结束时
    EVENT_PHASE =0x1000 --阶段结束时
    EVENT_PHASE_START =0x2000 --阶段开始时
    EVENT_ADD_COUNTER =0x10000 --增加指示物时
    EVENT_REMOVE_COUNTER =0x20000 --去除指示物时(A指示物)，Card.RemoveCounter()必須手動觸發此事件
    EVENT_CUSTOM =0x10000000 --自訂事件
    --Categorys 效果分类（表示这个效果将要发生什么事，OperationInfo设置了效果分类才能触发针对这一类型发动的卡，如破坏->星尘龙
    CATEGORY_DESTROY =0x1 --破坏效果
    CATEGORY_RELEASE =0x2 --解放效果
    CATEGORY_REMOVE =0x4 --除外效果
    CATEGORY_TOHAND =0x8 --回手牌效果
    CATEGORY_TODECK =0x10 --回卡组效果
    CATEGORY_TOGRAVE =0x20 --送去墓地效果
    CATEGORY_DECKDES =0x40 --包含從卡组送去墓地或特殊召唤效果
    CATEGORY_HANDES =0x80 --捨棄手牌效果
    CATEGORY_SUMMON =0x100 --含召唤的效果
    CATEGORY_SPECIAL_SUMMON =0x200 --含特殊召唤的效果
    CATEGORY_TOKEN =0x400 --含衍生物效果
    CATEGORY_GRAVE_ACTION =0x800 --包含特殊召喚以外移動墓地的卡的效果（屋敷わらし）
    CATEGORY_POSITION =0x1000 --改变表示形式效果
    CATEGORY_CONTROL =0x2000 --改变控制权效果
    CATEGORY_DISABLE =0x4000 --使效果无效效果
    CATEGORY_DISABLE_SUMMON =0x8000 --无效召唤效果
    CATEGORY_DRAW =0x10000 --抽卡效果
    CATEGORY_SEARCH =0x20000 --检索卡组效果
    CATEGORY_EQUIP =0x40000 --装备效果
    CATEGORY_DAMAGE =0x80000 --伤害效果
    CATEGORY_RECOVER =0x100000 --回复效果
    CATEGORY_ATKCHANGE =0x200000 --改变攻击效果
    CATEGORY_DEFCHANGE =0x400000 --改变防御效果
    CATEGORY_COUNTER =0x800000 --指示物效果
    CATEGORY_COIN =0x1000000 --硬币效果
    CATEGORY_DICE =0x2000000 --骰子效果
    CATEGORY_LEAVE_GRAVE =0x4000000 --涉及墓地的效果(王家長眠之谷)
    CATEGORY_LVCHANGE =0x8000000 --改变等级效果（为THC兼容性保留）
    --CATEGORY_GRAVE_SPSUMMON =0x8000000 --包含從墓地特殊召喚的效果（屋敷わらし、冥神）
    CATEGORY_NEGATE =0x10000000 --使发动无效效果
    CATEGORY_ANNOUNCE =0x20000000 --發動時宣言卡名的效果
    CATEGORY_FUSION_SUMMON =0x40000000 --融合召唤效果（暴走魔法阵）
    CATEGORY_TOEXTRA =0x80000000 --回额外卡组效果
    --Hint
    HINT_EVENT =1
    HINT_MESSAGE =2
    HINT_SELECTMSG =3
    HINT_OPSELECTED =4
    HINT_EFFECT =5
    HINT_RACE =6
    HINT_ATTRIB =7
    HINT_CODE =8
    HINT_NUMBER =9
    HINT_CARD =10
    HINT_ZONE =11
    --Card Hint
    CHINT_TURN =1
    CHINT_CARD =2
    CHINT_RACE =3
    CHINT_ATTRIBUTE =4
    CHINT_NUMBER =5
    CHINT_DESC =6
    --Opcode
    OPCODE_ADD =0x40000000
    OPCODE_SUB =0x40000001
    OPCODE_MUL =0x40000002
    OPCODE_DIV =0x40000003
    OPCODE_AND =0x40000004
    OPCODE_OR =0x40000005
    OPCODE_NEG =0x40000006
    OPCODE_NOT =0x40000007
    OPCODE_ISCODE =0x40000100
    OPCODE_ISSETCARD =0x40000101
    OPCODE_ISTYPE =0x40000102
    OPCODE_ISRACE =0x40000103
    OPCODE_ISATTRIBUTE =0x40000104
    --
    DOUBLE_DAMAGE =0x80000000
    HALF_DAMAGE =0x80000001
    --Hint Message --提示消息，显示在窗口的上面
    HINTMSG_RELEASE =500 --请选择要解放的卡
    HINTMSG_DISCARD =501 --请选择要丢弃的手牌
    HINTMSG_DESTROY =502 --请选择要破坏的卡
    HINTMSG_REMOVE =503 --请选择要除外的卡
    HINTMSG_TOGRAVE =504 --请选择要送去墓地的卡
    HINTMSG_RTOHAND =505 --请选择要返回手牌的卡
    HINTMSG_ATOHAND =506 --请选择要加入手牌的卡
    HINTMSG_TODECK =507 --请选择要返回卡组的卡
    HINTMSG_SUMMON =508 --请选择要召唤的卡
    HINTMSG_SPSUMMON =509 --请选择要特殊召唤的卡
    HINTMSG_SET =510 --请选择要盖放的卡
    HINTMSG_FMATERIAL =511 --请选择要作为融合素材的卡
    HINTMSG_SMATERIAL =512 --请选择要作为同调素材的卡
    HINTMSG_XMATERIAL =513 --请选择要作为超量素材的卡
    HINTMSG_FACEUP =514 --请选择表侧表示的卡
    HINTMSG_FACEDOWN =515 --请选择里侧表示的卡
    HINTMSG_ATTACK =516 --请选择攻击表示的怪兽
    HINTMSG_DEFENSE =517 --请选择守备表示的怪兽
    HINTMSG_EQUIP =518 --请选择要装备的卡
    HINTMSG_REMOVEXYZ =519 --请选择要取除的超量素材
    HINTMSG_CONTROL =520 --请选择要改变控制权的怪兽
    HINTMSG_DESREPLACE =521 --请选择要代替破坏的卡
    HINTMSG_FACEUPATTACK =522 --请选择表侧攻击表示的怪兽
    HINTMSG_FACEUPDEFENSE =523 --请选择表侧守备表示的怪兽
    HINTMSG_FACEDOWNATTACK =524 --请选择里侧攻击表示的怪兽
    HINTMSG_FACEDOWNDEFENSE =525 --请选择里侧守备表示的怪兽
    HINTMSG_CONFIRM =526 --请选择给对方确认的卡
    HINTMSG_TOFIELD =527 --请选择要放置到场上的卡
    HINTMSG_POSCHANGE =528 --请选择要改变表示形式的怪兽
    HINTMSG_SELF =529 --请选择自己的卡
    HINTMSG_OPPO =530 --请选择对方的卡
    HINTMSG_TRIBUTE =531 --请选择上级召唤用需要解放的怪兽
    HINTMSG_DEATTACHFROM =532 --请选择要取除超量素材的怪兽
    HINTMSG_LMATERIAL =533 --请选择要作为连接素材的卡
    HINTMSG_ATTACKTARGET =549 --请选择攻击的对象
    HINTMSG_EFFECT =550 --请选择要发动的效果
    HINTMSG_TARGET =551 --请选择效果的对象
    HINTMSG_COIN =552 --请选择硬币的正反面
    HINTMSG_DICE =553 --请选择骰子的结果
    HINTMSG_CARDTYPE =554 --请选择一个种类
    HINTMSG_OPTION =555 --请选择一个选项
    HINTMSG_RESOLVEEFFECT =556 --请选择要发动/处理的效果
    HINTMSG_SELECT =560 --请选择
    HINTMSG_POSITION =561 --请选择表示形式
    HINTMSG_ATTRIBUTE =562 --请选择要宣言的属性
    HINTMSG_RACE =563 --请选择要宣言的种族
    HINTMSG_CODE =564 --请宣言一个卡名
    HINGMSG_NUMBER =565 --请选择一个数字
    HINGMSG_LVRANK =567 --请宣言一个等级
    HINTMSG_RESOLVECARD =568 --请选择要处理效果的卡
    HINTMSG_ZONE =569 --请选择[%ls]的位置
    HINTMSG_DISABLEZONE =570 --请选择要变成不能使用的卡片区域
    HINTMSG_TOZONE =571 --请选择要移动到的位置
    HINTMSG_COUNTER =572 --请选择要放置指示物的卡
    HINTMSG_DISABLE =573 --请选择要无效的卡
    HINTMSG_OPERATECARD =574 --请选择要操作的卡
    --Select --请选择
    SELECT_HEADS =60 --正面
    SELECT_TAILS =61 --反面
    --Timing --提示时点，可以给freechain卡片增加自动提示时点
    TIMING_DRAW_PHASE =0x1 --抽卡阶段时点
    TIMING_STANDBY_PHASE =0x2 --准备阶段时点
    TIMING_MAIN_END =0x4 --主要阶段结束时点
    TIMING_BATTLE_START =0x8 --战斗阶段开始时点
    TIMING_BATTLE_END =0x10 --战斗阶段结束时点
    TIMING_END_PHASE =0x20 --结束阶段时点
    TIMING_SUMMON =0x40 --召唤时点
    TIMING_SPSUMMON =0x80 --特殊召唤时点
    TIMING_FLIPSUMMON =0x100 --翻转召唤时点
    TIMING_MSET =0x200 --放置怪兽时点
    TIMING_SSET =0x400 --放置魔陷时点
    TIMING_POS_CHANGE =0x800 --表示形式变更时点
    TIMING_ATTACK =0x1000 --攻击宣言时点
    TIMING_DAMAGE_STEP =0x2000 --伤害步骤时点
    TIMING_DAMAGE_CAL =0x4000 --伤害计算时点
    TIMING_CHAIN_END =0x8000 --连锁结束时点
    TIMING_DRAW =0x10000 --抽卡时点（不是抽卡阶段
    TIMING_DAMAGE =0x20000 --造成伤害时点
    TIMING_RECOVER =0x40000 --回复时点
    TIMING_DESTROY =0x80000 --破坏时点
    TIMING_REMOVE =0x100000 --除外时点
    TIMING_TOHAND =0x200000 --加入手牌时点（检索、回收等）
    TIMING_TODECK =0x400000 --回卡组时点
    TIMING_TOGRAVE =0x800000 --进墓地时点
    TIMING_BATTLE_PHASE =0x1000000 --战斗阶段时点
    TIMING_EQUIP =0x2000000 --装备时点
    TIMING_BATTLE_STEP_END =0x4000000 --戰鬥步驟結束時
    TIMING_BATTLED =0x8000000 --伤害计算后时点
    ----组合时点
    TIMINGS_CHECK_MONSTER =0x1c0 -- 怪兽正面上场
    --Global flag --特殊标记
    GLOBALFLAG_DECK_REVERSE_CHECK =0x1 --卡组翻转标记
    GLOBALFLAG_BRAINWASHING_CHECK =0x2 --洗脑解除标记
    GLOBALFLAG_SCRAP_CHIMERA =0x4 --废铁奇美拉标记
    GLOBALFLAG_DELAYED_QUICKEFFECT =0x8 --N/A
    GLOBALFLAG_DETACH_EVENT =0x10 --EVENT_DETACH_MATERIAL
    GLOBALFLAG_MUST_BE_SMATERIAL =0x20 --必须作为同调素材（波动龙 声子龙）
    GLOBALFLAG_SPSUMMON_COUNT =0x40 --玩家的特殊召唤次数限制
    GLOBALFLAG_XMAT_COUNT_LIMIT =0x80 --超量素材数量限制标记（光天使 天座）
    GLOBALFLAG_SELF_TOGRAVE =0x100 --不入連鎖的送墓檢查(EFFECT_SELF_TOGRAVE)
    GLOBALFLAG_SPSUMMON_ONCE =0x200 --1回合只能特殊召喚1次(Card.SetSPSummonOnce())
    GLOBALFLAG_TUNE_MAGICIAN =0x400 --超量素材检查标记（调弦之魔术师）
    --count_code
    EFFECT_COUNT_CODE_OATH =0x10000000 --发动次数限制(誓约次数, 发动被无效不计数)
    EFFECT_COUNT_CODE_DUEL =0x20000000 --决斗中使用次数
    EFFECT_COUNT_CODE_SINGLE =0x1 --同一张卡的多个效果公共使用次数
    --特殊选项
    DUEL_TEST_MODE =0x01 --测试模式(目前暫無)
    DUEL_ATTACK_FIRST_TURN =0x02 --第一回合可以攻击(用于残局)
    DUEL_NO_CHAIN_HINT =0x04 --N/A
    DUEL_OBSOLETE_RULING =0x08 --使用舊規則
    DUEL_PSEUDO_SHUFFLE =0x10 --不洗牌
    DUEL_TAG_MODE =0x20 --双打PP
    DUEL_SIMPLE_AI =0x40 --AI(用于残局)
    --Activity counter
    --global: 1-6 (binary: 5,6)
    --custom: 1-5,7 (binary: 1-5)
    ACTIVITY_SUMMON =1 --
    ACTIVITY_NORMALSUMMON =2 --
    ACTIVITY_SPSUMMON =3 --
    ACTIVITY_FLIPSUMMON =4 --
    ACTIVITY_ATTACK =5 --
    ACTIVITY_BATTLE_PHASE =6 -- not available in custom counter
    ACTIVITY_CHAIN =7 -- only available in custom counter
    --cards with double names
    CARD_MARINE_DOLPHIN =78734254 --海洋海豚
    CARD_TWINKLE_MOSS =13857930 --光輝苔蘚
    CARD_QUESTION =38723936 --谜题
    script/utility.lua deleted 100644 → 0
    View file @ 97071f63
    Auxiliary={}
    aux=Auxiliary
    POS_FACEUP_DEFENCE=POS_FACEUP_DEFENSE
    POS_FACEDOWN_DEFENCE=POS_FACEDOWN_DEFENSE
    RACE_CYBERS=RACE_CYBERSE
    --the lua version of the bit32 lib, which is deprecated in lua 5.3
    bit={}
    function bit.band(a,b)
    return a&b
    end
    function bit.bor(a,b)
    return a|b
    end
    function bit.bxor(a,b)
    return a~b
    end
    function bit.lshift(a,b)
    return a<<b
    end
    function bit.rshift(a,b)
    return a>>b
    end
    function bit.bnot(a)
    return ~a
    end
    local function fieldargs(f,width)
    w=width or 1
    assert(f>=0,"field cannot be negative")
    assert(w>0,"width must be positive")
    assert(f+w<=32,"trying to access non-existent bits")
    return f,~(-1<<w)
    end
    function bit.extract(r,field,width)
    local f,m=fieldargs(field,width)
    return (r>>f)&m
    end
    function bit.replace(r,v,field,width)
    local f,m=fieldargs(field,width)
    return (r&~(m<<f))|((v&m)<< f)
    end
    function Auxiliary.Stringid(code,id)
    return code*16+id
    end
    function Auxiliary.Next(g)
    local first=true
    return function()
    if first then first=false return g:GetFirst()
    else return g:GetNext() end
    end
    end
    function Auxiliary.NULL()
    end
    function Auxiliary.TRUE()
    return true
    end
    function Auxiliary.FALSE()
    return false
    end
    function Auxiliary.AND(...)
    local function_list={...}
    return function(...)
    local res=false
    for i,f in ipairs(function_list) do
    res=f(...)
    if not res then return res end
    end
    return res
    end
    end
    function Auxiliary.OR(...)
    local function_list={...}
    return function(...)
    local res=false
    for i,f in ipairs(function_list) do
    res=f(...)
    if res then return res end
    end
    return res
    end
    end
    function Auxiliary.NOT(f)
    return function(...)
    return not f(...)
    end
    end
    function Auxiliary.BeginPuzzle(effect)
    local e1=Effect.GlobalEffect()
    e1:SetType(EFFECT_TYPE_FIELD+EFFECT_TYPE_CONTINUOUS)
    e1:SetCode(EVENT_TURN_END)
    e1:SetCountLimit(1)
    e1:SetOperation(Auxiliary.PuzzleOp)
    Duel.RegisterEffect(e1,0)
    local e2=Effect.GlobalEffect()
    e2:SetType(EFFECT_TYPE_FIELD)
    e2:SetProperty(EFFECT_FLAG_PLAYER_TARGET)
    e2:SetCode(EFFECT_SKIP_DP)
    e2:SetTargetRange(1,0)
    Duel.RegisterEffect(e2,0)
    local e3=Effect.GlobalEffect()
    e3:SetType(EFFECT_TYPE_FIELD)
    e3:SetProperty(EFFECT_FLAG_PLAYER_TARGET)
    e3:SetCode(EFFECT_SKIP_SP)
    e3:SetTargetRange(1,0)
    Duel.RegisterEffect(e3,0)
    end
    function Auxiliary.PuzzleOp(e,tp)
    Duel.SetLP(0,0)
    end
    function Auxiliary.IsDualState(effect)
    local c=effect:GetHandler()
    return not c:IsDisabled() and c:IsDualState()
    end
    function Auxiliary.IsNotDualState(effect)
    local c=effect:GetHandler()
    return c:IsDisabled() or not c:IsDualState()
    end
    function Auxiliary.DualNormalCondition(effect)
    local c=effect:GetHandler()
    return c:IsFaceup() and not c:IsDualState()
    end
    function Auxiliary.EnableDualAttribute(c)
    local e1=Effect.CreateEffect(c)
    e1:SetType(EFFECT_TYPE_SINGLE)
    e1:SetCode(EFFECT_DUAL_SUMMONABLE)
    c:RegisterEffect(e1)
    local e2=Effect.CreateEffect(c)
    e2:SetType(EFFECT_TYPE_SINGLE)
    e2:SetCode(EFFECT_ADD_TYPE)
    e2:SetProperty(EFFECT_FLAG_SINGLE_RANGE+EFFECT_FLAG_IGNORE_IMMUNE)
    e2:SetRange(LOCATION_MZONE+LOCATION_GRAVE)
    e2:SetCondition(aux.DualNormalCondition)
    e2:SetValue(TYPE_NORMAL)
    c:RegisterEffect(e2)
    local e3=e2:Clone()
    e3:SetCode(EFFECT_REMOVE_TYPE)
    e3:SetValue(TYPE_EFFECT)
    c:RegisterEffect(e3)
    end
    --register effect of return to hand for Spirit monsters
    function Auxiliary.EnableSpiritReturn(c,event1,...)
    local e1=Effect.CreateEffect(c)
    e1:SetType(EFFECT_TYPE_SINGLE+EFFECT_TYPE_CONTINUOUS)
    e1:SetCode(event1)
    e1:SetProperty(EFFECT_FLAG_CANNOT_DISABLE)
    e1:SetOperation(Auxiliary.SpiritReturnReg)
    c:RegisterEffect(e1)
    for i,event in ipairs{...} do
    local e2=e1:Clone()
    e2:SetCode(event)
    c:RegisterEffect(e2)
    end
    end
    function Auxiliary.SpiritReturnReg(e,tp,eg,ep,ev,re,r,rp)
    local c=e:GetHandler()
    local e1=Effect.CreateEffect(c)
    e1:SetType(EFFECT_TYPE_FIELD+EFFECT_TYPE_TRIGGER_F)
    e1:SetDescription(1104)
    e1:SetCategory(CATEGORY_TOHAND)
    e1:SetCode(EVENT_PHASE+PHASE_END)
    e1:SetRange(LOCATION_MZONE)
    e1:SetCountLimit(1)
    e1:SetReset(RESET_EVENT+0xd6e0000+RESET_PHASE+PHASE_END)
    e1:SetCondition(Auxiliary.SpiritReturnConditionForced)
    e1:SetTarget(Auxiliary.SpiritReturnTargetForced)
    e1:SetOperation(Auxiliary.SpiritReturnOperation)
    c:RegisterEffect(e1)
    local e2=e1:Clone()
    e2:SetType(EFFECT_TYPE_FIELD+EFFECT_TYPE_TRIGGER_O)
    e2:SetCondition(Auxiliary.SpiritReturnConditionOptional)
    e2:SetTarget(Auxiliary.SpiritReturnTargetOptional)
    c:RegisterEffect(e2)
    end
    function Auxiliary.SpiritReturnConditionForced(e,tp,eg,ep,ev,re,r,rp)
    local c=e:GetHandler()
    return not c:IsHasEffect(EFFECT_SPIRIT_DONOT_RETURN) and not c:IsHasEffect(EFFECT_SPIRIT_MAYNOT_RETURN)
    end
    function Auxiliary.SpiritReturnTargetForced(e,tp,eg,ep,ev,re,r,rp,chk)
    if chk==0 then return true end
    Duel.SetOperationInfo(0,CATEGORY_TOHAND,e:GetHandler(),1,0,0)
    end
    function Auxiliary.SpiritReturnConditionOptional(e,tp,eg,ep,ev,re,r,rp)
    local c=e:GetHandler()
    return not c:IsHasEffect(EFFECT_SPIRIT_DONOT_RETURN) and c:IsHasEffect(EFFECT_SPIRIT_MAYNOT_RETURN)
    end
    function Auxiliary.SpiritReturnTargetOptional(e,tp,eg,ep,ev,re,r,rp,chk)
    if chk==0 then return e:GetHandler():IsAbleToHand() end
    Duel.SetOperationInfo(0,CATEGORY_TOHAND,e:GetHandler(),1,0,0)
    end
    function Auxiliary.SpiritReturnOperation(e,tp,eg,ep,ev,re,r,rp)
    local c=e:GetHandler()
    if c:IsRelateToEffect(e) then
    Duel.SendtoHand(c,nil,REASON_EFFECT)
    end
    end
    function Auxiliary.IsUnionState(effect)
    local c=effect:GetHandler()
    return c:IsHasEffect(EFFECT_UNION_STATUS)
    end
    --set EFFECT_EQUIP_LIMIT after equipping
    function Auxiliary.SetUnionState(c)
    local eset={c:IsHasEffect(EFFECT_UNION_LIMIT)}
    local e0=Effect.CreateEffect(c)
    e0:SetType(EFFECT_TYPE_SINGLE)
    e0:SetCode(EFFECT_EQUIP_LIMIT)
    e0:SetProperty(EFFECT_FLAG_CANNOT_DISABLE)
    e0:SetValue(eset[1]:GetValue())
    e0:SetReset(RESET_EVENT+RESETS_STANDARD)
    c:RegisterEffect(e0)
    local e1=Effect.CreateEffect(c)
    e1:SetType(EFFECT_TYPE_SINGLE)
    e1:SetCode(EFFECT_UNION_STATUS)
    e1:SetProperty(EFFECT_FLAG_CANNOT_DISABLE)
    e1:SetReset(RESET_EVENT+RESETS_STANDARD)
    c:RegisterEffect(e1)
    if c.old_union then
    local e2=e1:Clone()
    e2:SetCode(EFFECT_OLDUNION_STATUS)
    c:RegisterEffect(e2)
    end
    end
    function Auxiliary.CheckUnionEquip(uc,tc)
    ct1,ct2=tc:GetUnionCount()
    if uc.old_union then return ct1==0
    else return ct2==0 end
    end
    --EFFECT_DESTROY_SUBSTITUTE filter for modern union monsters
    function Auxiliary.UnionReplaceFilter(e,re,r,rp)
    return r&(REASON_BATTLE+REASON_EFFECT)~=0
    end
    --add effect to modern union monsters
    function Auxiliary.EnableUnionAttribute(c,f)
    --destroy sub
    local e1=Effect.CreateEffect(c)
    e1:SetType(EFFECT_TYPE_EQUIP)
    e1:SetProperty(EFFECT_FLAG_IGNORE_IMMUNE)
    e1:SetCode(EFFECT_DESTROY_SUBSTITUTE)
    e1:SetValue(aux.UnionReplaceFilter)
    c:RegisterEffect(e1)
    --limit
    local e2=Effect.CreateEffect(c)
    e2:SetType(EFFECT_TYPE_SINGLE)
    e2:SetCode(EFFECT_UNION_LIMIT)
    e2:SetProperty(EFFECT_FLAG_CANNOT_DISABLE)
    e2:SetValue(f)
    c:RegisterEffect(e2)
    end
    function Auxiliary.TargetEqualFunction(f,value,...)
    local ext_params={...}
    return function(effect,target)
    return f(target,table.unpack(ext_params))==value
    end
    end
    function Auxiliary.TargetBoolFunction(f,...)
    local ext_params={...}
    return function(effect,target)
    return f(target,table.unpack(ext_params))
    end
    end
    function Auxiliary.FilterEqualFunction(f,value,...)
    local ext_params={...}
    return function(target)
    return f(target,table.unpack(ext_params))==value
    end
    end
    function Auxiliary.FilterBoolFunction(f,...)
    local ext_params={...}
    return function(target)
    return f(target,table.unpack(ext_params))
    end
    end
    function Auxiliary.Tuner(f,...)
    local ext_params={...}
    return function(target)
    return target:IsType(TYPE_TUNER) and (not f or f(target,table.unpack(ext_params)))
    end
    end
    function Auxiliary.NonTuner(f,...)
    local ext_params={...}
    return function(target,syncard)
    return target:IsNotTuner(syncard) and (not f or f(target,table.unpack(ext_params)))
    end
    end
    function Auxiliary.GetValueType(v)
    local t=type(v)
    if t=="userdata" then
    local mt=getmetatable(v)
    if mt==Group then return "Group"
    elseif mt==Effect then return "Effect"
    else return "Card" end
    else return t end
    end
    function Auxiliary.GetMustMaterialGroup(tp,code)
    local g=Group.CreateGroup()
    local ce={Duel.IsPlayerAffectedByEffect(tp,code)}
    for _,te in ipairs(ce) do
    local tc=te:GetHandler()
    if tc then g:AddCard(tc) end
    end
    return g
    end
    function Auxiliary.MustMaterialCheck(v,tp,code)
    local g=Auxiliary.GetMustMaterialGroup(tp,code)
    if not v then
    if code==EFFECT_MUST_BE_XMATERIAL and Duel.IsPlayerAffectedByEffect(tp,67120578) then return false end
    return #g==0
    end
    local t=Auxiliary.GetValueType(v)
    for tc in Auxiliary.Next(g) do
    if (t=="Card" and v~=tc)
    or (t=="Group" and not v:IsContains(tc)) then return false end
    end
    return true
    end
    function Auxiliary.MustMaterialCounterFilter(c,g)
    return not g:IsContains(c)
    end
    --Synchro monster, 1 tuner + min to max monsters
    function Auxiliary.AddSynchroProcedure(c,f1,f2,minc,maxc)
    if maxc==nil then maxc=99 end
    local e1=Effect.CreateEffect(c)
    e1:SetDescription(1164)
    e1:SetType(EFFECT_TYPE_FIELD)
    e1:SetCode(EFFECT_SPSUMMON_PROC)
    e1:SetProperty(EFFECT_FLAG_CANNOT_DISABLE+EFFECT_FLAG_UNCOPYABLE)
    e1:SetRange(LOCATION_EXTRA)
    e1:SetCondition(Auxiliary.SynCondition(f1,f2,minc,maxc))
    e1:SetTarget(Auxiliary.SynTarget(f1,f2,minc,maxc))
    e1:SetOperation(Auxiliary.SynOperation(f1,f2,minc,maxc))
    e1:SetValue(SUMMON_TYPE_SYNCHRO)
    c:RegisterEffect(e1)
    end
    function Auxiliary.SynCondition(f1,f2,minc,maxc)
    return function(e,c,smat,mg,min,max)
    if c==nil then return true end
    if c:IsType(TYPE_PENDULUM) and c:IsFaceup() then return false end
    local minc=minc
    local maxc=maxc
    if min then
    if min>minc then minc=min end
    if max<maxc then maxc=max end
    if minc>maxc then return false end
    end
    if smat and smat:IsType(TYPE_TUNER) and (not f1 or f1(smat)) then
    return Duel.CheckTunerMaterial(c,smat,f1,f2,minc,maxc,mg) end
    return Duel.CheckSynchroMaterial(c,f1,f2,minc,maxc,smat,mg)
    end
    end
    function Auxiliary.SynTarget(f1,f2,minc,maxc)
    return function(e,tp,eg,ep,ev,re,r,rp,chk,c,smat,mg,min,max)
    local minc=minc
    local maxc=maxc
    if min then
    if min>minc then minc=min end
    if max<maxc then maxc=max end
    if minc>maxc then return false end
    end
    local g=nil
    if smat and smat:IsType(TYPE_TUNER) and (not f1 or f1(smat)) then
    g=Duel.SelectTunerMaterial(c:GetControler(),c,smat,f1,f2,minc,maxc,mg)
    else
    g=Duel.SelectSynchroMaterial(c:GetControler(),c,f1,f2,minc,maxc,smat,mg)
    end
    if g then
    g:KeepAlive()
    e:SetLabelObject(g)
    return true
    else return false end
    end
    end
    function Auxiliary.SynOperation(f1,f2,minct,maxc)
    return function(e,tp,eg,ep,ev,re,r,rp,c,smat,mg,min,max)
    local g=e:GetLabelObject()
    c:SetMaterial(g)
    Duel.SendtoGrave(g,REASON_MATERIAL+REASON_SYNCHRO)
    g:DeleteGroup()
    end
    end
    --Synchro monster, 1 tuner + 1 monster
    --backward compatibility
    function Auxiliary.AddSynchroProcedure2(c,f1,f2)
    Auxiliary.AddSynchroProcedure(c,f1,f2,1,1)
    end
    --Synchro monster, f1~f3 each 1 MONSTER + f4 min to max monsters
    function Auxiliary.AddSynchroMixProcedure(c,f1,f2,f3,f4,minc,maxc,gc)
    local e1=Effect.CreateEffect(c)
    e1:SetDescription(1164)
    e1:SetType(EFFECT_TYPE_FIELD)
    e1:SetCode(EFFECT_SPSUMMON_PROC)
    e1:SetProperty(EFFECT_FLAG_CANNOT_DISABLE+EFFECT_FLAG_UNCOPYABLE)
    e1:SetRange(LOCATION_EXTRA)
    e1:SetCondition(Auxiliary.SynMixCondition(f1,f2,f3,f4,minc,maxc,gc))
    e1:SetTarget(Auxiliary.SynMixTarget(f1,f2,f3,f4,minc,maxc,gc))
    e1:SetOperation(Auxiliary.SynMixOperation(f1,f2,f3,f4,minc,maxc,gc))
    e1:SetValue(SUMMON_TYPE_SYNCHRO)
    c:RegisterEffect(e1)
    end
    function Auxiliary.SynMaterialFilter(c,syncard)
    return c:IsFaceup() and c:IsCanBeSynchroMaterial(syncard)
    end
    function Auxiliary.SynLimitFilter(c,f,e,syncard)
    return f and not f(e,c,syncard)
    end
    function Auxiliary.GetSynchroLevelFlowerCardian(c)
    return 2
    end
    function Auxiliary.GetSynMaterials(tp,syncard)
    local mg=Duel.GetMatchingGroup(Auxiliary.SynMaterialFilter,tp,LOCATION_MZONE,LOCATION_MZONE,nil,syncard)
    if mg:IsExists(Card.GetHandSynchro,1,nil) then
    local mg2=Duel.GetMatchingGroup(Card.IsCanBeSynchroMaterial,tp,LOCATION_HAND,0,nil,syncard)
    if mg2:GetCount()>0 then mg:Merge(mg2) end
    end
    return mg
    end
    function Auxiliary.SynMixCondition(f1,f2,f3,f4,minc,maxc,gc)
    return function(e,c,smat,mg1,min,max)
    if c==nil then return true end
    if c:IsType(TYPE_PENDULUM) and c:IsFaceup() then return false end
    local minc=minc
    local maxc=maxc
    if min then
    if min>minc then minc=min end
    if max<maxc then maxc=max end
    if minc>maxc then return false end
    end
    local tp=c:GetControler()
    local mg
    local mgchk=false
    if mg1 then
    mg=mg1
    mgchk=true
    else
    mg=Auxiliary.GetSynMaterials(tp,c)
    end
    if smat~=nil then mg:AddCard(smat) end
    return mg:IsExists(Auxiliary.SynMixFilter1,1,nil,f1,f2,f3,f4,minc,maxc,c,mg,smat,gc,mgchk)
    end
    end
    function Auxiliary.SynMixTarget(f1,f2,f3,f4,minc,maxc,gc)
    return function(e,tp,eg,ep,ev,re,r,rp,chk,c,smat,mg1,min,max)
    local minc=minc
    local maxc=maxc
    if min then
    if min>minc then minc=min end
    if max<maxc then maxc=max end
    if minc>maxc then return false end
    end
    local g=Group.CreateGroup()
    local mg
    if mg1 then
    mg=mg1
    else
    mg=Auxiliary.GetSynMaterials(tp,c)
    end
    if smat~=nil then mg:AddCard(smat) end
    Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_SMATERIAL)
    local c1=mg:FilterSelect(tp,Auxiliary.SynMixFilter1,1,1,nil,f1,f2,f3,f4,minc,maxc,c,mg,smat,gc):GetFirst()
    g:AddCard(c1)
    if f2 then
    Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_SMATERIAL)
    local c2=mg:FilterSelect(tp,Auxiliary.SynMixFilter2,1,1,c1,f2,f3,f4,minc,maxc,c,mg,smat,c1,gc):GetFirst()
    g:AddCard(c2)
    if f3 then
    Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_SMATERIAL)
    local c3=mg:FilterSelect(tp,Auxiliary.SynMixFilter3,1,1,Group.FromCards(c1,c2),f3,f4,minc,maxc,c,mg,smat,c1,c2,gc):GetFirst()
    g:AddCard(c3)
    end
    end
    local g4=Group.CreateGroup()
    for i=0,maxc-1 do
    local mg2=mg:Clone()
    if f4 then
    mg2=mg2:Filter(f4,g,c)
    else
    mg2:Sub(g)
    end
    local cg=mg2:Filter(Auxiliary.SynMixCheckRecursive,g4,tp,g4,mg2,i,minc,maxc,c,g,smat,gc)
    if cg:GetCount()==0 then break end
    local minct=1
    if Auxiliary.SynMixCheckGoal(tp,g4,minc,i,c,g,smat,gc) then
    minct=0
    end
    Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_SMATERIAL)
    local tg=cg:Select(tp,minct,1,nil)
    if tg:GetCount()==0 then break end
    g4:Merge(tg)
    end
    g:Merge(g4)
    if g:GetCount()>0 then
    g:KeepAlive()
    e:SetLabelObject(g)
    return true
    else return false end
    end
    end
    function Auxiliary.SynMixOperation(f1,f2,f3,f4,minct,maxc,gc)
    return function(e,tp,eg,ep,ev,re,r,rp,c,smat,mg,min,max)
    local g=e:GetLabelObject()
    c:SetMaterial(g)
    Duel.SendtoGrave(g,REASON_MATERIAL+REASON_SYNCHRO)
    g:DeleteGroup()
    end
    end
    function Auxiliary.SynMixFilter1(c,f1,f2,f3,f4,minc,maxc,syncard,mg,smat,gc,mgchk)
    return (not f1 or f1(c,syncard)) and mg:IsExists(Auxiliary.SynMixFilter2,1,c,f2,f3,f4,minc,maxc,syncard,mg,smat,c,gc,mgchk)
    end
    function Auxiliary.SynMixFilter2(c,f2,f3,f4,minc,maxc,syncard,mg,smat,c1,gc,mgchk)
    if f2 then
    return f2(c,syncard,c1) and mg:IsExists(Auxiliary.SynMixFilter3,1,Group.FromCards(c1,c),f3,f4,minc,maxc,syncard,mg,smat,c1,c,gc,mgchk)
    else
    return mg:IsExists(Auxiliary.SynMixFilter4,1,c1,f4,minc,maxc,syncard,mg,smat,c1,nil,nil,gc,mgchk)
    end
    end
    function Auxiliary.SynMixFilter3(c,f3,f4,minc,maxc,syncard,mg,smat,c1,c2,gc,mgchk)
    if f3 then
    return f3(c,syncard,c1,c2) and mg:IsExists(Auxiliary.SynMixFilter4,1,Group.FromCards(c1,c2,c),f4,minc,maxc,syncard,mg,smat,c1,c2,c,gc,mgchk)
    else
    return mg:IsExists(Auxiliary.SynMixFilter4,1,Group.FromCards(c1,c2),f4,minc,maxc,syncard,mg,smat,c1,c2,nil,gc,mgchk)
    end
    end
    function Auxiliary.SynMixFilter4(c,f4,minc,maxc,syncard,mg1,smat,c1,c2,c3,gc,mgchk)
    if f4 and not f4(c,syncard,c1,c2,c3) then return false end
    local sg=Group.FromCards(c1,c)
    sg:AddCard(c1)
    if c2 then sg:AddCard(c2) end
    if c3 then sg:AddCard(c3) end
    local mg=mg1:Clone()
    if f4 then
    mg=mg:Filter(f4,sg,syncard)
    else
    mg:Sub(sg)
    end
    return aux.SynMixCheck(mg,sg,minc-1,maxc-1,syncard,smat,gc,mgchk)
    end
    function Auxiliary.SynMixCheck(mg,sg1,minc,maxc,syncard,smat,gc,mgchk)
    local tp=syncard:GetControler()
    local sg=Group.CreateGroup()
    if minc==0 and Auxiliary.SynMixCheckGoal(tp,sg1,0,0,syncard,sg,smat,gc,mgchk) then return true end
    if maxc==0 then return false end
    return mg:IsExists(Auxiliary.SynMixCheckRecursive,1,nil,tp,sg,mg,0,minc,maxc,syncard,sg1,smat,gc,mgchk)
    end
    function Auxiliary.SynMixCheckRecursive(c,tp,sg,mg,ct,minc,maxc,syncard,sg1,smat,gc,mgchk)
    sg:AddCard(c)
    ct=ct+1
    local res=Auxiliary.SynMixCheckGoal(tp,sg,minc,ct,syncard,sg1,smat,gc,mgchk)
    or (ct<maxc and mg:IsExists(Auxiliary.SynMixCheckRecursive,1,sg,tp,sg,mg,ct,minc,maxc,syncard,sg1,smat,gc,mgchk))
    sg:RemoveCard(c)
    ct=ct-1
    return res
    end
    function Auxiliary.SynMixCheckGoal(tp,sg,minc,ct,syncard,sg1,smat,gc,mgchk)
    if ct<minc then return false end
    local g=sg:Clone()
    g:Merge(sg1)
    if Duel.GetLocationCountFromEx(tp,tp,g,syncard)<=0 then return false end
    if gc and not gc(g) then return false end
    if smat and not g:IsContains(smat) then return false end
    if not Auxiliary.MustMaterialCheck(g,tp,EFFECT_MUST_BE_SMATERIAL) then return false end
    if not g:CheckWithSumEqual(Card.GetSynchroLevel,syncard:GetLevel(),g:GetCount(),g:GetCount(),syncard)
    and (not g:IsExists(Card.IsHasEffect,1,nil,89818984)
    or not g:CheckWithSumEqual(Auxiliary.GetSynchroLevelFlowerCardian,syncard:GetLevel(),g:GetCount(),g:GetCount(),syncard))
    then return false end
    local hg=g:Filter(Card.IsLocation,nil,LOCATION_HAND)
    local hct=hg:GetCount()
    if hct>0 and not mgchk then
    local found=false
    for c in aux.Next(g) do
    local he,hf,hmin,hmax=c:GetHandSynchro()
    if he then
    found=true
    if hf and hg:IsExists(Auxiliary.SynLimitFilter,1,c,hf,he,syncard) then return false end
    if (hmin and hct<hmin) or (hmax and hct>hmax) then return false end
    end
    end
    if not found then return false end
    end
    for c in aux.Next(g) do
    local le,lf,lloc,lmin,lmax=c:GetTunerLimit()
    if le then
    local lct=g:GetCount()-1
    if lloc then
    local llct=g:FilterCount(Card.IsLocation,c,lloc)
    if llct~=lct then return false end
    end
    if lf and g:IsExists(Auxiliary.SynLimitFilter,1,c,lf,le,syncard) then return false end
    if (lmin and lct<lmin) or (lmax and lct>lmax) then return false end
    end
    end
    return true
    end
    --Checking Tune Magician
    function Auxiliary.TuneMagicianFilter(c,e)
    local f=e:GetValue()
    return f(e,c)
    end
    function Auxiliary.TuneMagicianCheckX(c,sg,ecode)
    local eset={c:IsHasEffect(ecode)}
    for _,te in pairs(eset) do
    if sg:IsExists(Auxiliary.TuneMagicianFilter,1,c,te) then return true end
    end
    return false
    end
    function Auxiliary.TuneMagicianCheckAdditionalX(ecode)
    return function(g)
    return not g:IsExists(Auxiliary.TuneMagicianCheckX,1,nil,g,ecode)
    end
    end
    function Auxiliary.XyzAlterFilter(c,alterf,xyzc,e,tp,op)
    return alterf(c) and c:IsCanBeXyzMaterial(xyzc) and Duel.GetLocationCountFromEx(tp,tp,c,xyzc)>0 and Auxiliary.MustMaterialCheck(c,tp,EFFECT_MUST_BE_XMATERIAL) and (not op or op(e,tp,0,c))
    end
    --Xyz monster, lv k*n
    function Auxiliary.AddXyzProcedure(c,f,lv,ct,alterf,desc,maxct,op)
    local e1=Effect.CreateEffect(c)
    e1:SetDescription(1165)
    e1:SetType(EFFECT_TYPE_FIELD)
    e1:SetCode(EFFECT_SPSUMMON_PROC)
    e1:SetProperty(EFFECT_FLAG_CANNOT_DISABLE+EFFECT_FLAG_UNCOPYABLE)
    e1:SetRange(LOCATION_EXTRA)
    if not maxct then maxct=ct end
    if alterf then
    e1:SetCondition(Auxiliary.XyzCondition2(f,lv,ct,maxct,alterf,desc,op))
    e1:SetTarget(Auxiliary.XyzTarget2(f,lv,ct,maxct,alterf,desc,op))
    e1:SetOperation(Auxiliary.XyzOperation2(f,lv,ct,maxct,alterf,desc,op))
    else
    e1:SetCondition(Auxiliary.XyzCondition(f,lv,ct,maxct))
    e1:SetTarget(Auxiliary.XyzTarget(f,lv,ct,maxct))
    e1:SetOperation(Auxiliary.XyzOperation(f,lv,ct,maxct))
    end
    e1:SetValue(SUMMON_TYPE_XYZ)
    c:RegisterEffect(e1)
    end
    --Xyz Summon(normal)
    function Auxiliary.XyzCondition(f,lv,minc,maxc)
    --og: use special material
    return function(e,c,og,min,max)
    if c==nil then return true end
    if c:IsType(TYPE_PENDULUM) and c:IsFaceup() then return false end
    local tp=c:GetControler()
    local minc=minc
    local maxc=maxc
    if min then
    if min>minc then minc=min end
    if max<maxc then maxc=max end
    if minc>maxc then return false end
    end
    return Duel.CheckXyzMaterial(c,f,lv,minc,maxc,og)
    end
    end
    function Auxiliary.XyzTarget(f,lv,minc,maxc)
    return function(e,tp,eg,ep,ev,re,r,rp,chk,c,og,min,max)
    if og and not min then
    return true
    end
    local minc=minc
    local maxc=maxc
    if min then
    if min>minc then minc=min end
    if max<maxc then maxc=max end
    end
    local g=Duel.SelectXyzMaterial(tp,c,f,lv,minc,maxc,og)
    if g then
    g:KeepAlive()
    e:SetLabelObject(g)
    return true
    else return false end
    end
    end
    function Auxiliary.XyzOperation(f,lv,minc,maxc)
    return function(e,tp,eg,ep,ev,re,r,rp,c,og,min,max)
    if og and not min then
    local sg=Group.CreateGroup()
    local tc=og:GetFirst()
    while tc do
    local sg1=tc:GetOverlayGroup()
    sg:Merge(sg1)
    tc=og:GetNext()
    end
    Duel.SendtoGrave(sg,REASON_RULE)
    c:SetMaterial(og)
    Duel.Overlay(c,og)
    else
    local mg=e:GetLabelObject()
    local sg=Group.CreateGroup()
    local tc=mg:GetFirst()
    while tc do
    local sg1=tc:GetOverlayGroup()
    sg:Merge(sg1)
    tc=mg:GetNext()
    end
    Duel.SendtoGrave(sg,REASON_RULE)
    c:SetMaterial(mg)
    Duel.Overlay(c,mg)
    mg:DeleteGroup()
    end
    end
    end
    --Xyz summon(alterf)
    function Auxiliary.XyzCondition2(f,lv,minc,maxc,alterf,desc,op)
    return function(e,c,og,min,max)
    if c==nil then return true end
    if c:IsType(TYPE_PENDULUM) and c:IsFaceup() then return false end
    local tp=c:GetControler()
    local mg=nil
    if og then
    mg=og
    else
    mg=Duel.GetFieldGroup(tp,LOCATION_MZONE,0)
    end
    if (not min or min<=1) and mg:IsExists(Auxiliary.XyzAlterFilter,1,nil,alterf,c,e,tp,op) then
    return true
    end
    local minc=minc
    local maxc=maxc
    if min then
    if min>minc then minc=min end
    if max<maxc then maxc=max end
    if minc>maxc then return false end
    end
    return Duel.CheckXyzMaterial(c,f,lv,minc,maxc,og)
    end
    end
    function Auxiliary.XyzTarget2(f,lv,minc,maxc,alterf,desc,op)
    return function(e,tp,eg,ep,ev,re,r,rp,chk,c,og,min,max)
    if og and not min then
    return true
    end
    local minc=minc
    local maxc=maxc
    if min then
    if min>minc then minc=min end
    if max<maxc then maxc=max end
    end
    local mg=nil
    if og then
    mg=og
    else
    mg=Duel.GetFieldGroup(tp,LOCATION_MZONE,0)
    end
    local b1=Duel.CheckXyzMaterial(c,f,lv,minc,maxc,og)
    local b2=(not min or min<=1) and mg:IsExists(Auxiliary.XyzAlterFilter,1,nil,alterf,c,e,tp,op)
    local g=nil
    if b2 and (not b1 or Duel.SelectYesNo(tp,desc)) then
    e:SetLabel(1)
    Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_XMATERIAL)
    g=mg:FilterSelect(tp,Auxiliary.XyzAlterFilter,1,1,nil,alterf,c,e,tp,op)
    if op then op(e,tp,1,g:GetFirst()) end
    else
    e:SetLabel(0)
    g=Duel.SelectXyzMaterial(tp,c,f,lv,minc,maxc,og)
    end
    if g then
    g:KeepAlive()
    e:SetLabelObject(g)
    return true
    else return false end
    end
    end
    function Auxiliary.XyzOperation2(f,lv,minc,maxc,alterf,desc,op)
    return function(e,tp,eg,ep,ev,re,r,rp,c,og,min,max)
    if og and not min then
    local sg=Group.CreateGroup()
    local tc=og:GetFirst()
    while tc do
    local sg1=tc:GetOverlayGroup()
    sg:Merge(sg1)
    tc=og:GetNext()
    end
    Duel.SendtoGrave(sg,REASON_RULE)
    c:SetMaterial(og)
    Duel.Overlay(c,og)
    else
    local mg=e:GetLabelObject()
    if e:GetLabel()==1 then
    local mg2=mg:GetFirst():GetOverlayGroup()
    if mg2:GetCount()~=0 then
    Duel.Overlay(c,mg2)
    end
    else
    local sg=Group.CreateGroup()
    local tc=mg:GetFirst()
    while tc do
    local sg1=tc:GetOverlayGroup()
    sg:Merge(sg1)
    tc=mg:GetNext()
    end
    Duel.SendtoGrave(sg,REASON_RULE)
    end
    c:SetMaterial(mg)
    Duel.Overlay(c,mg)
    mg:DeleteGroup()
    end
    end
    end
    function Auxiliary.AddXyzProcedureLevelFree(c,f,gf,minc,maxc,alterf,desc,op)
    local e1=Effect.CreateEffect(c)
    e1:SetDescription(1165)
    e1:SetType(EFFECT_TYPE_FIELD)
    e1:SetCode(EFFECT_SPSUMMON_PROC)
    e1:SetProperty(EFFECT_FLAG_CANNOT_DISABLE+EFFECT_FLAG_UNCOPYABLE)
    e1:SetRange(LOCATION_EXTRA)
    if alterf then
    e1:SetCondition(Auxiliary.XyzLevelFreeCondition2(f,gf,minc,maxc,alterf,desc,op))
    e1:SetTarget(Auxiliary.XyzLevelFreeTarget2(f,gf,minc,maxc,alterf,desc,op))
    e1:SetOperation(Auxiliary.XyzLevelFreeOperation2(f,gf,minc,maxc,alterf,desc,op))
    else
    e1:SetCondition(Auxiliary.XyzLevelFreeCondition(f,gf,minc,maxc))
    e1:SetTarget(Auxiliary.XyzLevelFreeTarget(f,gf,minc,maxc))
    e1:SetOperation(Auxiliary.XyzLevelFreeOperation(f,gf,minc,maxc))
    end
    e1:SetValue(SUMMON_TYPE_XYZ)
    c:RegisterEffect(e1)
    end
    --Xyz Summon(level free)
    function Auxiliary.XyzLevelFreeFilter(c,xyzc,f)
    return c:IsFaceup() and c:IsCanBeXyzMaterial(xyzc) and (not f or f(c,xyzc))
    end
    function Auxiliary.XyzLevelFreeGoal(g,tp,xyzc,gf)
    return (not gf or gf(g)) and Duel.GetLocationCountFromEx(tp,tp,g,xyzc)>0
    end
    function Auxiliary.XyzLevelFreeCondition(f,gf,minct,maxct)
    return function(e,c,og,min,max)
    if c==nil then return true end
    if c:IsType(TYPE_PENDULUM) and c:IsFaceup() then return false end
    local tp=c:GetControler()
    local minc=minct
    local maxc=maxct
    if min then
    minc=math.max(minc,min)
    maxc=math.min(maxc,max)
    end
    if maxc<minc then return false end
    local mg=nil
    if og then
    mg=og:Filter(Auxiliary.XyzLevelFreeFilter,nil,c,f)
    else
    mg=Duel.GetMatchingGroup(Auxiliary.XyzLevelFreeFilter,tp,LOCATION_MZONE,0,nil,c,f)
    end
    local sg=Auxiliary.GetMustMaterialGroup(tp,EFFECT_MUST_BE_XMATERIAL)
    if sg:IsExists(Auxiliary.MustMaterialCounterFilter,1,nil,mg) then return false end
    Duel.SetSelectedCard(sg)
    Auxiliary.GCheckAdditional=Auxiliary.TuneMagicianCheckAdditionalX(EFFECT_TUNE_MAGICIAN_X)
    local res=mg:CheckSubGroup(Auxiliary.XyzLevelFreeGoal,minc,maxc,tp,c,gf)
    Auxiliary.GCheckAdditional=nil
    return res
    end
    end
    function Auxiliary.XyzLevelFreeTarget(f,gf,minct,maxct)
    return function(e,tp,eg,ep,ev,re,r,rp,chk,c,og,min,max)
    if og and not min then
    return true
    end
    local minc=minct
    local maxc=maxct
    if min then
    if min>minc then minc=min end
    if max<maxc then maxc=max end
    end
    local mg=nil
    if og then
    mg=og:Filter(Auxiliary.XyzLevelFreeFilter,nil,c,f)
    else
    mg=Duel.GetMatchingGroup(Auxiliary.XyzLevelFreeFilter,tp,LOCATION_MZONE,0,nil,c,f)
    end
    local sg=Auxiliary.GetMustMaterialGroup(tp,EFFECT_MUST_BE_XMATERIAL)
    Duel.SetSelectedCard(sg)
    Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_XMATERIAL)
    local cancel=Duel.IsSummonCancelable()
    Auxiliary.GCheckAdditional=Auxiliary.TuneMagicianCheckAdditionalX(EFFECT_TUNE_MAGICIAN_X)
    local g=mg:SelectSubGroup(tp,Auxiliary.XyzLevelFreeGoal,cancel,minc,maxc,tp,c,gf)
    Auxiliary.GCheckAdditional=nil
    if g and g:GetCount()>0 then
    g:KeepAlive()
    e:SetLabelObject(g)
    return true
    else return false end
    end
    end
    function Auxiliary.XyzLevelFreeOperation(f,gf,minct,maxct)
    return function(e,tp,eg,ep,ev,re,r,rp,c,og,min,max)
    if og and not min then
    local sg=Group.CreateGroup()
    local tc=og:GetFirst()
    while tc do
    local sg1=tc:GetOverlayGroup()
    sg:Merge(sg1)
    tc=og:GetNext()
    end
    Duel.SendtoGrave(sg,REASON_RULE)
    c:SetMaterial(og)
    Duel.Overlay(c,og)
    else
    local mg=e:GetLabelObject()
    if e:GetLabel()==1 then
    local mg2=mg:GetFirst():GetOverlayGroup()
    if mg2:GetCount()~=0 then
    Duel.Overlay(c,mg2)
    end
    else
    local sg=Group.CreateGroup()
    local tc=mg:GetFirst()
    while tc do
    local sg1=tc:GetOverlayGroup()
    sg:Merge(sg1)
    tc=mg:GetNext()
    end
    Duel.SendtoGrave(sg,REASON_RULE)
    end
    c:SetMaterial(mg)
    Duel.Overlay(c,mg)
    mg:DeleteGroup()
    end
    end
    end
    --Xyz summon(level free&alterf)
    function Auxiliary.XyzLevelFreeCondition2(f,gf,minct,maxct,alterf,desc,op)
    return function(e,c,og,min,max)
    if c==nil then return true end
    if c:IsType(TYPE_PENDULUM) and c:IsFaceup() then return false end
    local tp=c:GetControler()
    local mg=nil
    if og then
    mg=og
    else
    mg=Duel.GetFieldGroup(tp,LOCATION_MZONE,0)
    end
    local altg=mg:Filter(Auxiliary.XyzAlterFilter,nil,alterf,c,e,tp,op):Filter(Auxiliary.MustMaterialCheck,nil,tp,EFFECT_MUST_BE_XMATERIAL)
    if (not min or min<=1) and altg:GetCount()>0 then
    return true
    end
    local minc=minct
    local maxc=maxct
    if min then
    if min>minc then minc=min end
    if max<maxc then maxc=max end
    if minc>maxc then return false end
    end
    mg=mg:Filter(Auxiliary.XyzLevelFreeFilter,nil,c,f)
    local sg=Auxiliary.GetMustMaterialGroup(tp,EFFECT_MUST_BE_XMATERIAL)
    if sg:IsExists(Auxiliary.MustMaterialCounterFilter,1,nil,mg) then return false end
    Duel.SetSelectedCard(sg)
    Auxiliary.GCheckAdditional=Auxiliary.TuneMagicianCheckAdditionalX(EFFECT_TUNE_MAGICIAN_X)
    local res=mg:CheckSubGroup(Auxiliary.XyzLevelFreeGoal,minc,maxc,tp,c,gf)
    Auxiliary.GCheckAdditional=nil
    return res
    end
    end
    function Auxiliary.XyzLevelFreeTarget2(f,gf,minct,maxct,alterf,desc,op)
    return function(e,tp,eg,ep,ev,re,r,rp,chk,c,og,min,max)
    if og and not min then
    return true
    end
    local minc=minct
    local maxc=maxct
    if min then
    if min>minc then minc=min end
    if max<maxc then maxc=max end
    end
    local mg=nil
    if og then
    mg=og
    else
    mg=Duel.GetFieldGroup(tp,LOCATION_MZONE,0)
    end
    local sg=Auxiliary.GetMustMaterialGroup(tp,EFFECT_MUST_BE_XMATERIAL)
    local mg2=mg:Filter(Auxiliary.XyzLevelFreeFilter,nil,c,f)
    Duel.SetSelectedCard(sg)
    local b1=mg2:CheckSubGroup(Auxiliary.XyzLevelFreeGoal,minc,maxc,tp,c,gf)
    local b2=(not min or min<=1) and mg:IsExists(Auxiliary.XyzAlterFilter,1,nil,alterf,c,e,tp,op)
    local g=nil
    if b2 and (not b1 or Duel.SelectYesNo(tp,desc)) then
    e:SetLabel(1)
    Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_XMATERIAL)
    g=mg:FilterSelect(tp,Auxiliary.XyzAlterFilter,1,1,nil,alterf,c,e,tp,op)
    if op then op(e,tp,1,g:GetFirst()) end
    else
    e:SetLabel(0)
    Duel.SetSelectedCard(sg)
    Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_XMATERIAL)
    local cancel=Duel.IsSummonCancelable()
    Auxiliary.GCheckAdditional=Auxiliary.TuneMagicianCheckAdditionalX(EFFECT_TUNE_MAGICIAN_X)
    g=mg2:SelectSubGroup(tp,Auxiliary.XyzLevelFreeGoal,cancel,minc,maxc,tp,c,gf)
    Auxiliary.GCheckAdditional=nil
    end
    if g and g:GetCount()>0 then
    g:KeepAlive()
    e:SetLabelObject(g)
    return true
    else return false end
    end
    end
    function Auxiliary.XyzLevelFreeOperation2(f,gf,minct,maxct,alterf,desc,op)
    return function(e,tp,eg,ep,ev,re,r,rp,c,og,min,max)
    if og and not min then
    local sg=Group.CreateGroup()
    local tc=og:GetFirst()
    while tc do
    local sg1=tc:GetOverlayGroup()
    sg:Merge(sg1)
    tc=og:GetNext()
    end
    Duel.SendtoGrave(sg,REASON_RULE)
    c:SetMaterial(og)
    Duel.Overlay(c,og)
    else
    local mg=e:GetLabelObject()
    if e:GetLabel()==1 then
    local mg2=mg:GetFirst():GetOverlayGroup()
    if mg2:GetCount()~=0 then
    Duel.Overlay(c,mg2)
    end
    else
    local sg=Group.CreateGroup()
    local tc=mg:GetFirst()
    while tc do
    local sg1=tc:GetOverlayGroup()
    sg:Merge(sg1)
    tc=mg:GetNext()
    end
    Duel.SendtoGrave(sg,REASON_RULE)
    end
    c:SetMaterial(mg)
    Duel.Overlay(c,mg)
    mg:DeleteGroup()
    end
    end
    end
    --material: names in material list
    --Fusion monster, mixed materials
    function Auxiliary.AddFusionProcMix(c,sub,insf,...)
    if c:IsStatus(STATUS_COPYING_EFFECT) then return end
    local val={...}
    local fun={}
    local mat={}
    for i=1,#val do
    if type(val[i])=='function' then
    fun[i]=function(c,fc,sub,mg,sg) return val[i](c,fc,sub,mg,sg) and not c:IsHasEffect(6205579) end
    elseif type(val[i])=='table' then
    fun[i]=function(c,fc,sub,mg,sg)
    for _,fcode in ipairs(val[i]) do
    if type(fcode)=='function' then
    if fcode(c,fc,sub,mg,sg) and not c:IsHasEffect(6205579) then return true end
    else
    if c:IsFusionCode(fcode) or (sub and c:CheckFusionSubstitute(fc)) then return true end
    end
    end
    return false
    end
    for _,fcode in ipairs(val[i]) do
    if type(fcode)~='function' then mat[fcode]=true end
    end
    else
    fun[i]=function(c,fc,sub) return c:IsFusionCode(val[i]) or (sub and c:CheckFusionSubstitute(fc)) end
    mat[val[i]]=true
    end
    end
    if c.material==nil then
    local mt=getmetatable(c)
    mt.material=mat
    end
    for index,_ in pairs(mat) do
    Auxiliary.AddCodeList(c,index)
    end
    local e1=Effect.CreateEffect(c)
    e1:SetType(EFFECT_TYPE_SINGLE)
    e1:SetProperty(EFFECT_FLAG_CANNOT_DISABLE+EFFECT_FLAG_UNCOPYABLE)
    e1:SetCode(EFFECT_FUSION_MATERIAL)
    e1:SetCondition(Auxiliary.FConditionMix(insf,sub,table.unpack(fun)))
    e1:SetOperation(Auxiliary.FOperationMix(insf,sub,table.unpack(fun)))
    c:RegisterEffect(e1)
    end
    function Auxiliary.FConditionMix(insf,sub,...)
    --g:Material group(nil for Instant Fusion)
    --gc:Material already used
    --chkf: check field, default:PLAYER_NONE
    --chkf&0x100: Not fusion summon
    --chkf&0x200: Concat fusion
    local funs={...}
    return function(e,g,gc,chkfnf)
    if g==nil then return insf and Auxiliary.MustMaterialCheck(nil,e:GetHandlerPlayer(),EFFECT_MUST_BE_FMATERIAL) end
    local c=e:GetHandler()
    local tp=c:GetControler()
    local notfusion=chkfnf&0x100>0
    local concat_fusion=chkfnf&0x200>0
    local sub=(sub or notfusion) and not concat_fusion
    local mg=g:Filter(Auxiliary.FConditionFilterMix,c,c,sub,concat_fusion,table.unpack(funs))
    if gc then
    if not mg:IsContains(gc) then return false end
    Duel.SetSelectedCard(Group.FromCards(gc))
    end
    return mg:CheckSubGroup(Auxiliary.FCheckMixGoal,#funs,#funs,tp,c,sub,chkfnf,table.unpack(funs))
    end
    end
    function Auxiliary.FOperationMix(insf,sub,...)
    local funs={...}
    return function(e,tp,eg,ep,ev,re,r,rp,gc,chkfnf)
    local c=e:GetHandler()
    local tp=c:GetControler()
    local notfusion=chkfnf&0x100>0
    local concat_fusion=chkfnf&0x200>0
    local sub=(sub or notfusion) and not concat_fusion
    local mg=eg:Filter(Auxiliary.FConditionFilterMix,c,c,sub,concat_fusion,table.unpack(funs))
    if gc then Duel.SetSelectedCard(Group.FromCards(gc)) end
    Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_FMATERIAL)
    local sg=mg:SelectSubGroup(tp,Auxiliary.FCheckMixGoal,false,#funs,#funs,tp,c,sub,chkfnf,table.unpack(funs))
    Duel.SetFusionMaterial(sg)
    end
    end
    function Auxiliary.FConditionFilterMix(c,fc,sub,concat_fusion,...)
    local fusion_type=concat_fusion and SUMMON_TYPE_SPECIAL or SUMMON_TYPE_FUSION
    if not c:IsCanBeFusionMaterial(fc,fusion_type) then return false end
    for i,f in ipairs({...}) do
    if f(c,fc,sub) then return true end
    end
    return false
    end
    function Auxiliary.FCheckMix(c,mg,sg,fc,sub,fun1,fun2,...)
    if fun2 then
    sg:AddCard(c)
    local res=false
    if fun1(c,fc,false,mg,sg) then
    res=mg:IsExists(Auxiliary.FCheckMix,1,sg,mg,sg,fc,sub,fun2,...)
    elseif sub and fun1(c,fc,true,mg,sg) then
    res=mg:IsExists(Auxiliary.FCheckMix,1,sg,mg,sg,fc,false,fun2,...)
    end
    sg:RemoveCard(c)
    return res
    else
    return fun1(c,fc,sub,mg,sg)
    end
    end
    --if sg1 is subset of sg2 then not Auxiliary.FCheckAdditional(tp,sg1,fc) -> not Auxiliary.FCheckAdditional(tp,sg2,fc)
    Auxiliary.FCheckAdditional=nil
    function Auxiliary.FCheckMixGoal(sg,tp,fc,sub,chkfnf,...)
    local chkf=chkfnf&0xff
    local concat_fusion=chkfnf&0x200>0
    if not concat_fusion and sg:IsExists(Auxiliary.TuneMagicianCheckX,1,nil,sg,EFFECT_TUNE_MAGICIAN_F) then return false end
    if not Auxiliary.MustMaterialCheck(sg,tp,EFFECT_MUST_BE_FMATERIAL) then return false end
    local g=Group.CreateGroup()
    return sg:IsExists(Auxiliary.FCheckMix,1,nil,sg,g,fc,sub,...) and (chkf==PLAYER_NONE or Duel.GetLocationCountFromEx(tp,tp,sg,fc)>0)
    and (not Auxiliary.FCheckAdditional or Auxiliary.FCheckAdditional(tp,sg,fc))
    end
    --Fusion monster, mixed material * minc to maxc + material + ...
    function Auxiliary.AddFusionProcMixRep(c,sub,insf,fun1,minc,maxc,...)
    if c:IsStatus(STATUS_COPYING_EFFECT) then return end
    local val={fun1,...}
    local fun={}
    local mat={}
    for i=1,#val do
    if type(val[i])=='function' then
    fun[i]=function(c,fc,sub,mg,sg) return val[i](c,fc,sub,mg,sg) and not c:IsHasEffect(6205579) end
    elseif type(val[i])=='table' then
    fun[i]=function(c,fc,sub,mg,sg)
    for _,fcode in ipairs(val[i]) do
    if type(fcode)=='function' then
    if fcode(c,fc,sub,mg,sg) and not c:IsHasEffect(6205579) then return true end
    else
    if c:IsFusionCode(fcode) or (sub and c:CheckFusionSubstitute(fc)) then return true end
    end
    end
    return false
    end
    for _,fcode in ipairs(val[i]) do
    if type(fcode)~='function' then mat[fcode]=true end
    end
    else
    fun[i]=function(c,fc,sub) return c:IsFusionCode(val[i]) or (sub and c:CheckFusionSubstitute(fc)) end
    mat[val[i]]=true
    end
    end
    if c.material==nil then
    local mt=getmetatable(c)
    mt.material=mat
    end
    for index,_ in pairs(mat) do
    Auxiliary.AddCodeList(c,index)
    end
    local e1=Effect.CreateEffect(c)
    e1:SetType(EFFECT_TYPE_SINGLE)
    e1:SetProperty(EFFECT_FLAG_CANNOT_DISABLE+EFFECT_FLAG_UNCOPYABLE)
    e1:SetCode(EFFECT_FUSION_MATERIAL)
    e1:SetCondition(Auxiliary.FConditionMixRep(insf,sub,fun[1],minc,maxc,table.unpack(fun,2)))
    e1:SetOperation(Auxiliary.FOperationMixRep(insf,sub,fun[1],minc,maxc,table.unpack(fun,2)))
    c:RegisterEffect(e1)
    end
    function Auxiliary.FConditionMixRep(insf,sub,fun1,minc,maxc,...)
    local funs={...}
    return function(e,g,gc,chkfnf)
    if g==nil then return insf and Auxiliary.MustMaterialCheck(nil,e:GetHandlerPlayer(),EFFECT_MUST_BE_FMATERIAL) end
    local c=e:GetHandler()
    local tp=c:GetControler()
    local notfusion=chkfnf&0x100>0
    local concat_fusion=chkfnf&0x200>0
    local sub=(sub or notfusion) and not concat_fusion
    local mg=g:Filter(Auxiliary.FConditionFilterMix,c,c,sub,concat_fusion,fun1,table.unpack(funs))
    if gc then
    if not mg:IsContains(gc) then return false end
    local sg=Group.CreateGroup()
    return Auxiliary.FSelectMixRep(gc,tp,mg,sg,c,sub,chkfnf,fun1,minc,maxc,table.unpack(funs))
    end
    local sg=Group.CreateGroup()
    return mg:IsExists(Auxiliary.FSelectMixRep,1,nil,tp,mg,sg,c,sub,chkfnf,fun1,minc,maxc,table.unpack(funs))
    end
    end
    function Auxiliary.FOperationMixRep(insf,sub,fun1,minc,maxc,...)
    local funs={...}
    return function(e,tp,eg,ep,ev,re,r,rp,gc,chkfnf)
    local c=e:GetHandler()
    local tp=c:GetControler()
    local notfusion=chkfnf&0x100>0
    local concat_fusion=chkfnf&0x200>0
    local sub=(sub or notfusion) and not concat_fusion
    local mg=eg:Filter(Auxiliary.FConditionFilterMix,c,c,sub,concat_fusion,fun1,table.unpack(funs))
    local sg=Group.CreateGroup()
    if gc then sg:AddCard(gc) end
    while sg:GetCount()<maxc+#funs do
    local cg=mg:Filter(Auxiliary.FSelectMixRep,sg,tp,mg,sg,c,sub,chkfnf,fun1,minc,maxc,table.unpack(funs))
    if cg:GetCount()==0 then break end
    local finish=Auxiliary.FCheckMixRepGoal(tp,sg,c,sub,chkfnf,fun1,minc,maxc,table.unpack(funs))
    local cancel_group=sg:Clone()
    if gc then cancel_group:RemoveCard(gc) end
    Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_FMATERIAL)
    local tc=cg:SelectUnselect(cancel_group,tp,finish,false,minc+#funs,maxc+#funs)
    if not tc then break end
    if sg:IsContains(tc) then
    sg:RemoveCard(tc)
    else
    sg:AddCard(tc)
    end
    end
    Duel.SetFusionMaterial(sg)
    end
    end
    function Auxiliary.FCheckMixRep(sg,g,fc,sub,chkf,fun1,minc,maxc,fun2,...)
    if fun2 then
    return sg:IsExists(Auxiliary.FCheckMixRepFilter,1,g,sg,g,fc,sub,chkf,fun1,minc,maxc,fun2,...)
    else
    local ct1=sg:FilterCount(fun1,g,fc,sub,mg,sg)
    local ct2=sg:FilterCount(fun1,g,fc,false,mg,sg)
    return ct1==sg:GetCount()-g:GetCount() and ct1-ct2<=1
    end
    end
    function Auxiliary.FCheckMixRepFilter(c,sg,g,fc,sub,chkf,fun1,minc,maxc,fun2,...)
    if fun2(c,fc,sub,mg,sg) then
    g:AddCard(c)
    local sub=sub and fun2(c,fc,false,mg,sg)
    local res=Auxiliary.FCheckMixRep(sg,g,fc,sub,chkf,fun1,minc,maxc,...)
    g:RemoveCard(c)
    return res
    end
    return false
    end
    function Auxiliary.FCheckMixRepGoal(tp,sg,fc,sub,chkfnf,fun1,minc,maxc,...)
    local chkf=chkfnf&0xff
    local concat_fusion=chkfnf&0x200>0
    if not concat_fusion and sg:IsExists(Auxiliary.TuneMagicianCheckX,1,nil,sg,EFFECT_TUNE_MAGICIAN_F) then return false end
    if not Auxiliary.MustMaterialCheck(sg,tp,EFFECT_MUST_BE_FMATERIAL) then return false end
    if sg:GetCount()<minc+#{...} or sg:GetCount()>maxc+#{...} then return false end
    local g=Group.CreateGroup()
    return Auxiliary.FCheckMixRep(sg,g,fc,sub,chkf,fun1,minc,maxc,...) and (chkf==PLAYER_NONE or Duel.GetLocationCountFromEx(tp,tp,sg,fc)>0)
    and (not Auxiliary.FCheckAdditional or Auxiliary.FCheckAdditional(tp,sg,fc))
    end
    function Auxiliary.FCheckMixRepTemplate(c,cond,tp,mg,sg,g,fc,sub,chkfnf,fun1,minc,maxc,...)
    for i,f in ipairs({...}) do
    if f(c,fc,sub,mg,sg) then
    g:AddCard(c)
    local sub=sub and f(c,fc,false,mg,sg)
    local t={...}
    table.remove(t,i)
    local res=cond(tp,mg,sg,g,fc,sub,chkfnf,fun1,minc,maxc,table.unpack(t))
    g:RemoveCard(c)
    if res then return true end
    end
    end
    if maxc>0 then
    if fun1(c,fc,sub,mg,sg) then
    g:AddCard(c)
    local sub=sub and fun1(c,fc,false,mg,sg)
    local res=cond(tp,mg,sg,g,fc,sub,chkfnf,fun1,minc-1,maxc-1,...)
    g:RemoveCard(c)
    if res then return true end
    end
    end
    return false
    end
    function Auxiliary.FCheckMixRepSelectedCond(tp,mg,sg,g,...)
    if g:GetCount()<sg:GetCount() then
    return sg:IsExists(Auxiliary.FCheckMixRepSelected,1,g,tp,mg,sg,g,...)
    else
    return Auxiliary.FCheckSelectMixRep(tp,mg,sg,g,...)
    end
    end
    function Auxiliary.FCheckMixRepSelected(c,...)
    return Auxiliary.FCheckMixRepTemplate(c,Auxiliary.FCheckMixRepSelectedCond,...)
    end
    function Auxiliary.FCheckSelectMixRep(tp,mg,sg,g,fc,sub,chkfnf,fun1,minc,maxc,...)
    local chkf=chkfnf&0xff
    if Auxiliary.FCheckAdditional and not Auxiliary.FCheckAdditional(tp,g,fc) then return false end
    if chkf==PLAYER_NONE or Duel.GetLocationCountFromEx(tp,tp,g,fc)>0 then
    if minc<=0 and #{...}==0 then return true end
    return mg:IsExists(Auxiliary.FCheckSelectMixRepAll,1,g,tp,mg,sg,g,fc,sub,chkfnf,fun1,minc,maxc,...)
    else
    return mg:IsExists(Auxiliary.FCheckSelectMixRepM,1,g,tp,mg,sg,g,fc,sub,chkfnf,fun1,minc,maxc,...)
    end
    end
    function Auxiliary.FCheckSelectMixRepAll(c,tp,mg,sg,g,fc,sub,chkf,fun1,minc,maxc,fun2,...)
    if fun2 then
    if fun2(c,fc,sub,mg,sg) then
    g:AddCard(c)
    local sub=sub and fun2(c,fc,false,mg,sg)
    local res=Auxiliary.FCheckSelectMixRep(tp,mg,sg,g,fc,sub,chkf,fun1,minc,maxc,...)
    g:RemoveCard(c)
    return res
    end
    elseif maxc>0 and fun1(c,fc,sub,mg,sg) then
    g:AddCard(c)
    local sub=sub and fun1(c,fc,false,mg,sg)
    local res=Auxiliary.FCheckSelectMixRep(tp,mg,sg,g,fc,sub,chkf,fun1,minc-1,maxc-1)
    g:RemoveCard(c)
    return res
    end
    return false
    end
    function Auxiliary.FCheckSelectMixRepM(c,tp,...)
    return c:IsControler(tp) and c:IsLocation(LOCATION_MZONE)
    and Auxiliary.FCheckMixRepTemplate(c,Auxiliary.FCheckSelectMixRep,tp,...)
    end
    function Auxiliary.FSelectMixRep(c,tp,mg,sg,fc,sub,chkfnf,...)
    sg:AddCard(c)
    local res=false
    if Auxiliary.FCheckAdditional and not Auxiliary.FCheckAdditional(tp,sg,fc) then
    res=false
    elseif Auxiliary.FCheckMixRepGoal(tp,sg,fc,sub,chkfnf,...) then
    res=true
    else
    local g=Group.CreateGroup()
    res=sg:IsExists(Auxiliary.FCheckMixRepSelected,1,nil,tp,mg,sg,g,fc,sub,chkfnf,...)
    end
    sg:RemoveCard(c)
    return res
    end
    --Fusion monster, name + name
    function Auxiliary.AddFusionProcCode2(c,code1,code2,sub,insf)
    Auxiliary.AddFusionProcMix(c,sub,insf,code1,code2)
    end
    --Fusion monster, name + name + name
    function Auxiliary.AddFusionProcCode3(c,code1,code2,code3,sub,insf)
    Auxiliary.AddFusionProcMix(c,sub,insf,code1,code2,code3)
    end
    --Fusion monster, name + name + name + name
    function Auxiliary.AddFusionProcCode4(c,code1,code2,code3,code4,sub,insf)
    Auxiliary.AddFusionProcMix(c,sub,insf,code1,code2,code3,code4)
    end
    --Fusion monster, name * n
    function Auxiliary.AddFusionProcCodeRep(c,code1,cc,sub,insf)
    local code={}
    for i=1,cc do
    code[i]=code1
    end
    Auxiliary.AddFusionProcMix(c,sub,insf,table.unpack(code))
    end
    --Fusion monster, name * minc to maxc
    function Auxiliary.AddFusionProcCodeRep2(c,code1,minc,maxc,sub,insf)
    Auxiliary.AddFusionProcMixRep(c,sub,insf,code1,minc,maxc)
    end
    --Fusion monster, name + condition * n
    function Auxiliary.AddFusionProcCodeFun(c,code1,f,cc,sub,insf)
    local fun={}
    for i=1,cc do
    fun[i]=f
    end
    Auxiliary.AddFusionProcMix(c,sub,insf,code1,table.unpack(fun))
    end
    --Fusion monster, condition + condition
    function Auxiliary.AddFusionProcFun2(c,f1,f2,insf)
    Auxiliary.AddFusionProcMix(c,false,insf,f1,f2)
    end
    --Fusion monster, condition * n
    function Auxiliary.AddFusionProcFunRep(c,f,cc,insf)
    local fun={}
    for i=1,cc do
    fun[i]=f
    end
    Auxiliary.AddFusionProcMix(c,false,insf,table.unpack(fun))
    end
    --Fusion monster, condition * minc to maxc
    function Auxiliary.AddFusionProcFunRep2(c,f,minc,maxc,insf)
    Auxiliary.AddFusionProcMixRep(c,false,insf,f,minc,maxc)
    end
    --Fusion monster, condition1 + condition2 * n
    function Auxiliary.AddFusionProcFunFun(c,f1,f2,cc,insf)
    local fun={}
    for i=1,cc do
    fun[i]=f2
    end
    Auxiliary.AddFusionProcMix(c,false,insf,f1,table.unpack(fun))
    end
    --Fusion monster, condition1 + condition2 * minc to maxc
    function Auxiliary.AddFusionProcFunFunRep(c,f1,f2,minc,maxc,insf)
    Auxiliary.AddFusionProcMixRep(c,false,insf,f2,minc,maxc,f1)
    end
    --Fusion monster, name + condition * minc to maxc
    function Auxiliary.AddFusionProcCodeFunRep(c,code1,f,minc,maxc,sub,insf)
    Auxiliary.AddFusionProcMixRep(c,sub,insf,f,minc,maxc,code1)
    end
    --Fusion monster, name + name + condition * minc to maxc
    function Auxiliary.AddFusionProcCode2FunRep(c,code1,code2,f,minc,maxc,sub,insf)
    Auxiliary.AddFusionProcMixRep(c,sub,insf,f,minc,maxc,code1,code2)
    end
    --Fusion monster, Shaddoll materials
    function Auxiliary.AddFusionProcShaddoll(c,attr)
    local e1=Effect.CreateEffect(c)
    e1:SetType(EFFECT_TYPE_SINGLE)
    e1:SetProperty(EFFECT_FLAG_CANNOT_DISABLE+EFFECT_FLAG_UNCOPYABLE)
    e1:SetCode(EFFECT_FUSION_MATERIAL)
    e1:SetCondition(Auxiliary.FShaddollCondition(attr))
    e1:SetOperation(Auxiliary.FShaddollOperation(attr))
    c:RegisterEffect(e1)
    end
    function Auxiliary.FShaddollFilter(c,fc,attr)
    return (Auxiliary.FShaddollFilter1(c) or Auxiliary.FShaddollFilter2(c,attr)) and c:IsCanBeFusionMaterial(fc) and not c:IsHasEffect(6205579)
    end
    function Auxiliary.FShaddollExFilter(c,fc,attr)
    return c:IsFaceup() and Auxiliary.FShaddollFilter(c,fc,attr)
    end
    function Auxiliary.FShaddollFilter1(c)
    return c:IsFusionSetCard(0x9d)
    end
    function Auxiliary.FShaddollFilter2(c,attr)
    return c:IsFusionAttribute(attr) or c:IsHasEffect(4904633)
    end
    function Auxiliary.FShaddollSpFilter1(c,fc,tp,mg,exg,attr,chkf)
    return mg:IsExists(Auxiliary.FShaddollSpFilter2,1,c,fc,tp,c,attr,chkf)
    or (exg and exg:IsExists(Auxiliary.FShaddollSpFilter2,1,c,fc,tp,c,attr,chkf))
    end
    function Auxiliary.FShaddollSpFilter2(c,fc,tp,mc,attr,chkf)
    local sg=Group.FromCards(c,mc)
    if sg:IsExists(Auxiliary.TuneMagicianCheckX,1,nil,sg,EFFECT_TUNE_MAGICIAN_F) then return false end
    if not Auxiliary.MustMaterialCheck(sg,tp,EFFECT_MUST_BE_FMATERIAL) then return false end
    if Auxiliary.FCheckAdditional and not Auxiliary.FCheckAdditional(tp,sg,fc) then return false end
    return ((Auxiliary.FShaddollFilter1(c) and Auxiliary.FShaddollFilter2(mc,attr))
    or (Auxiliary.FShaddollFilter2(c,attr) and Auxiliary.FShaddollFilter1(mc)))
    and (chkf==PLAYER_NONE or Duel.GetLocationCountFromEx(tp,tp,sg,fc)>0)
    end
    function Auxiliary.FShaddollCondition(attr)
    return function(e,g,gc,chkf)
    if g==nil then return Auxiliary.MustMaterialCheck(nil,e:GetHandlerPlayer(),EFFECT_MUST_BE_FMATERIAL) end
    local c=e:GetHandler()
    local mg=g:Filter(Auxiliary.FShaddollFilter,nil,c,attr)
    local tp=e:GetHandlerPlayer()
    local fc=Duel.GetFieldCard(tp,LOCATION_FZONE,0)
    local exg=nil
    if fc and fc:IsHasEffect(81788994) and fc:IsCanRemoveCounter(tp,0x16,3,REASON_EFFECT) then
    exg=Duel.GetMatchingGroup(Auxiliary.FShaddollExFilter,tp,0,LOCATION_MZONE,mg,c,attr)
    end
    if gc then
    if not mg:IsContains(gc) then return false end
    return Auxiliary.FShaddollSpFilter1(gc,c,tp,mg,exg,attr,chkf)
    end
    return mg:IsExists(Auxiliary.FShaddollSpFilter1,1,nil,c,tp,mg,exg,attr,chkf)
    end
    end
    function Auxiliary.FShaddollOperation(attr)
    return function(e,tp,eg,ep,ev,re,r,rp,gc,chkf)
    local c=e:GetHandler()
    local mg=eg:Filter(Auxiliary.FShaddollFilter,nil,c,attr)
    local fc=Duel.GetFieldCard(tp,LOCATION_FZONE,0)
    local exg=nil
    if fc and fc:IsHasEffect(81788994) and fc:IsCanRemoveCounter(tp,0x16,3,REASON_EFFECT) then
    exg=Duel.GetMatchingGroup(Auxiliary.FShaddollExFilter,tp,0,LOCATION_MZONE,mg,c,attr)
    end
    local g=nil
    if gc then
    g=Group.FromCards(gc)
    mg:RemoveCard(gc)
    else
    Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_FMATERIAL)
    g=mg:FilterSelect(tp,Auxiliary.FShaddollSpFilter1,1,1,nil,c,tp,mg,exg,attr,chkf)
    mg:Sub(g)
    end
    if exg and exg:IsExists(Auxiliary.FShaddollSpFilter2,1,nil,c,tp,g:GetFirst(),attr,chkf)
    and (mg:GetCount()==0 or (exg:GetCount()>0 and Duel.SelectYesNo(tp,aux.Stringid(81788994,0)))) then
    fc:RemoveCounter(tp,0x16,3,REASON_EFFECT)
    Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_FMATERIAL)
    local sg=exg:FilterSelect(tp,Auxiliary.FShaddollSpFilter2,1,1,nil,c,tp,g:GetFirst(),attr,chkf)
    g:Merge(sg)
    else
    Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_FMATERIAL)
    local sg=mg:FilterSelect(tp,Auxiliary.FShaddollSpFilter2,1,1,nil,c,tp,g:GetFirst(),attr,chkf)
    g:Merge(sg)
    end
    Duel.SetFusionMaterial(g)
    end
    end
    function Auxiliary.AddContactFusionProcedure(c,filter,self_location,opponent_location,mat_operation,...)
    local self_location=self_location or 0
    local opponent_location=opponent_location or 0
    local operation_params={...}
    local e2=Effect.CreateEffect(c)
    e2:SetType(EFFECT_TYPE_FIELD)
    e2:SetCode(EFFECT_SPSUMMON_PROC)
    e2:SetProperty(EFFECT_FLAG_CANNOT_DISABLE+EFFECT_FLAG_UNCOPYABLE)
    e2:SetRange(LOCATION_EXTRA)
    e2:SetCondition(Auxiliary.ContactFusionCondition(filter,self_location,opponent_location))
    e2:SetOperation(Auxiliary.ContactFusionOperation(filter,self_location,opponent_location,mat_operation,operation_params))
    c:RegisterEffect(e2)
    return e2
    end
    function Auxiliary.ContactFusionMaterialFilter(c,fc,filter)
    return c:IsCanBeFusionMaterial(fc,SUMMON_TYPE_SPECIAL) and (not filter or filter(c,fc))
    end
    function Auxiliary.ContactFusionCondition(filter,self_location,opponent_location)
    return function(e,c)
    if c==nil then return true end
    if c:IsType(TYPE_PENDULUM) and c:IsFaceup() then return false end
    local tp=c:GetControler()
    local mg=Duel.GetMatchingGroup(Auxiliary.ContactFusionMaterialFilter,tp,self_location,opponent_location,c,c,filter)
    return c:CheckFusionMaterial(mg,nil,tp|0x200)
    end
    end
    function Auxiliary.ContactFusionOperation(filter,self_location,opponent_location,mat_operation,operation_params)
    return function(e,tp,eg,ep,ev,re,r,rp,c)
    local mg=Duel.GetMatchingGroup(Auxiliary.ContactFusionMaterialFilter,tp,self_location,opponent_location,c,c,filter)
    local g=Duel.SelectFusionMaterial(tp,c,mg,nil,tp|0x200)
    c:SetMaterial(g)
    mat_operation(g,table.unpack(operation_params))
    end
    end
    function Auxiliary.AddRitualProcUltimate(c,filter,level_function,greater_or_equal,summon_location,grave_filter,mat_filter)
    summon_location=summon_location or LOCATION_HAND
    local e1=Effect.CreateEffect(c)
    e1:SetCategory(CATEGORY_SPECIAL_SUMMON)
    e1:SetType(EFFECT_TYPE_ACTIVATE)
    e1:SetCode(EVENT_FREE_CHAIN)
    e1:SetTarget(Auxiliary.RitualUltimateTarget(filter,level_function,greater_or_equal,summon_location,grave_filter,mat_filter))
    e1:SetOperation(Auxiliary.RitualUltimateOperation(filter,level_function,greater_or_equal,summon_location,grave_filter,mat_filter))
    c:RegisterEffect(e1)
    return e1
    end
    function Auxiliary.RitualCheckGreater(g,c,lv)
    Duel.SetSelectedCard(g)
    return g:CheckWithSumGreater(Card.GetRitualLevel,lv,c)
    end
    function Auxiliary.RitualCheckEqual(g,c,lv)
    return g:CheckWithSumEqual(Card.GetRitualLevel,lv,#g,#g,c)
    end
    Auxiliary.RCheckAdditional=nil
    function Auxiliary.RitualCheck(g,tp,c,lv,greater_or_equal)
    return Auxiliary["RitualCheck"..greater_or_equal](g,c,lv) and Duel.GetMZoneCount(tp,g,tp)>0 and (not c.mat_group_check or c.mat_group_check(g,tp))
    and (not Auxiliary.RCheckAdditional or Auxiliary.RCheckAdditional(tp,g,c))
    end
    function Auxiliary.RitualCheckAdditionalLevel(c,rc)
    local raw_level=c:GetRitualLevel(rc)
    local lv1=raw_level&0xffff
    local lv2=raw_level>>16
    if lv2>0 then
    return math.min(lv1,lv2)
    else
    return lv1
    end
    end
    Auxiliary.RGCheckAdditional=nil
    function Auxiliary.RitualCheckAdditional(c,lv,greater_or_equal)
    if greater_or_equal=="Equal" then
    return function(g)
    return (not Auxiliary.RGCheckAdditional or Auxiliary.RGCheckAdditional(g)) and g:GetSum(Auxiliary.RitualCheckAdditionalLevel,c)<=lv
    end
    else
    return function(g,ec)
    if ec then
    return (not Auxiliary.RGCheckAdditional or Auxiliary.RGCheckAdditional(g,ec)) and g:GetSum(Auxiliary.RitualCheckAdditionalLevel,c)-Auxiliary.RitualCheckAdditionalLevel(ec,c)<=lv
    else
    return not Auxiliary.RGCheckAdditional or Auxiliary.RGCheckAdditional(g)
    end
    end
    end
    end
    function Auxiliary.RitualUltimateFilter(c,filter,e,tp,m1,m2,level_function,greater_or_equal,chk)
    if bit.band(c:GetType(),0x81)~=0x81 or (filter and not filter(c,e,tp,chk)) or not c:IsCanBeSpecialSummoned(e,SUMMON_TYPE_RITUAL,tp,false,true) then return false end
    local mg=m1:Filter(Card.IsCanBeRitualMaterial,c,c)
    if m2 then
    mg:Merge(m2)
    end
    if c.mat_filter then
    mg=mg:Filter(c.mat_filter,c,tp)
    else
    mg:RemoveCard(c)
    end
    local lv=level_function(c)
    Auxiliary.GCheckAdditional=Auxiliary.RitualCheckAdditional(c,lv,greater_or_equal)
    local res=mg:CheckSubGroup(Auxiliary.RitualCheck,1,lv,tp,c,lv,greater_or_equal)
    Auxiliary.GCheckAdditional=nil
    return res
    end
    function Auxiliary.RitualExtraFilter(c,f)
    return c:GetLevel()>0 and f(c) and c:IsType(TYPE_MONSTER) and c:IsAbleToRemove()
    end
    function Auxiliary.RitualUltimateTarget(filter,level_function,greater_or_equal,summon_location,grave_filter,mat_filter)
    return function(e,tp,eg,ep,ev,re,r,rp,chk)
    if chk==0 then
    local mg=Duel.GetRitualMaterial(tp)
    if mat_filter then mg=mg:Filter(mat_filter,nil,e,tp,true) end
    local exg=nil
    if grave_filter then
    exg=Duel.GetMatchingGroup(Auxiliary.RitualExtraFilter,tp,LOCATION_GRAVE,0,nil,grave_filter)
    end
    return Duel.IsExistingMatchingCard(Auxiliary.RitualUltimateFilter,tp,summon_location,0,1,nil,filter,e,tp,mg,exg,level_function,greater_or_equal,true)
    end
    Duel.SetOperationInfo(0,CATEGORY_SPECIAL_SUMMON,nil,1,tp,summon_location)
    if grave_filter then
    Duel.SetOperationInfo(0,CATEGORY_REMOVE,nil,0,tp,LOCATION_GRAVE)
    end
    end
    end
    function Auxiliary.RitualUltimateOperation(filter,level_function,greater_or_equal,summon_location,grave_filter,mat_filter)
    return function(e,tp,eg,ep,ev,re,r,rp)
    local mg=Duel.GetRitualMaterial(tp)
    if mat_filter then mg=mg:Filter(mat_filter,nil,e,tp) end
    local exg=nil
    if grave_filter then
    exg=Duel.GetMatchingGroup(Auxiliary.RitualExtraFilter,tp,LOCATION_GRAVE,0,nil,grave_filter)
    end
    Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_SPSUMMON)
    local tg=Duel.SelectMatchingCard(tp,Auxiliary.NecroValleyFilter(Auxiliary.RitualUltimateFilter),tp,summon_location,0,1,1,nil,filter,e,tp,mg,exg,level_function,greater_or_equal)
    local tc=tg:GetFirst()
    if tc then
    mg=mg:Filter(Card.IsCanBeRitualMaterial,tc,tc)
    if exg then
    mg:Merge(exg)
    end
    if tc.mat_filter then
    mg=mg:Filter(tc.mat_filter,tc,tp)
    else
    mg:RemoveCard(tc)
    end
    Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_RELEASE)
    local lv=level_function(tc)
    Auxiliary.GCheckAdditional=Auxiliary.RitualCheckAdditional(tc,lv,greater_or_equal)
    local mat=mg:SelectSubGroup(tp,Auxiliary.RitualCheck,false,1,lv,tp,tc,lv,greater_or_equal)
    Auxiliary.GCheckAdditional=nil
    tc:SetMaterial(mat)
    Duel.ReleaseRitualMaterial(mat)
    Duel.BreakEffect()
    Duel.SpecialSummon(tc,SUMMON_TYPE_RITUAL,tp,tp,false,true,POS_FACEUP)
    tc:CompleteProcedure()
    end
    end
    end
    --Ritual Summon, geq fixed lv
    function Auxiliary.AddRitualProcGreater(c,filter,summon_location,grave_filter,mat_filter)
    return Auxiliary.AddRitualProcUltimate(c,filter,Card.GetOriginalLevel,"Greater",summon_location,grave_filter,mat_filter)
    end
    function Auxiliary.AddRitualProcGreaterCode(c,code1,summon_location,grave_filter,mat_filter)
    Auxiliary.AddCodeList(c,code1)
    return Auxiliary.AddRitualProcGreater(c,Auxiliary.FilterBoolFunction(Card.IsCode,code1),summon_location,grave_filter,mat_filter)
    end
    --Ritual Summon, equal to fixed lv
    function Auxiliary.AddRitualProcEqual(c,filter,summon_location,grave_filter,mat_filter)
    return Auxiliary.AddRitualProcUltimate(c,filter,Card.GetOriginalLevel,"Equal",summon_location,grave_filter,mat_filter)
    end
    function Auxiliary.AddRitualProcEqualCode(c,code1,summon_location,grave_filter,mat_filter)
    Auxiliary.AddCodeList(c,code1)
    return Auxiliary.AddRitualProcEqual(c,Auxiliary.FilterBoolFunction(Card.IsCode,code1),summon_location,grave_filter,mat_filter)
    end
    --Ritual Summon, equal to monster lv
    function Auxiliary.AddRitualProcEqual2(c,filter,summon_location,grave_filter,mat_filter)
    return Auxiliary.AddRitualProcUltimate(c,filter,Card.GetLevel,"Equal",summon_location,grave_filter,mat_filter)
    end
    function Auxiliary.AddRitualProcEqual2Code(c,code1,summon_location,grave_filter,mat_filter)
    Auxiliary.AddCodeList(c,code1)
    return Auxiliary.AddRitualProcEqual2(c,Auxiliary.FilterBoolFunction(Card.IsCode,code1),summon_location,grave_filter,mat_filter)
    end
    function Auxiliary.AddRitualProcEqual2Code2(c,code1,code2,summon_location,grave_filter,mat_filter)
    Auxiliary.AddCodeList(c,code1,code2)
    return Auxiliary.AddRitualProcEqual2(c,Auxiliary.FilterBoolFunction(Card.IsCode,code1,code2),summon_location,grave_filter,mat_filter)
    end
    --Ritual Summon, geq monster lv
    function Auxiliary.AddRitualProcGreater2(c,filter,summon_location,grave_filter,mat_filter)
    return Auxiliary.AddRitualProcUltimate(c,filter,Card.GetLevel,"Greater",summon_location,grave_filter,mat_filter)
    end
    function Auxiliary.AddRitualProcGreater2Code(c,code1,summon_location,grave_filter,mat_filter)
    Auxiliary.AddCodeList(c,code1)
    return Auxiliary.AddRitualProcGreater2(c,Auxiliary.FilterBoolFunction(Card.IsCode,code1),summon_location,grave_filter,mat_filter)
    end
    function Auxiliary.AddRitualProcGreater2Code2(c,code1,code2,summon_location,grave_filter,mat_filter)
    Auxiliary.AddCodeList(c,code1,code2)
    return Auxiliary.AddRitualProcGreater2(c,Auxiliary.FilterBoolFunction(Card.IsCode,code1,code2),summon_location,grave_filter,mat_filter)
    end
    --add procedure to Pendulum monster, also allows registeration of activation effect
    function Auxiliary.EnablePendulumAttribute(c,reg)
    if not Auxiliary.PendulumChecklist then
    Auxiliary.PendulumChecklist=0
    local ge1=Effect.GlobalEffect()
    ge1:SetType(EFFECT_TYPE_FIELD+EFFECT_TYPE_CONTINUOUS)
    ge1:SetCode(EVENT_PHASE_START+PHASE_DRAW)
    ge1:SetOperation(Auxiliary.PendulumReset)
    Duel.RegisterEffect(ge1,0)
    end
    local e1=Effect.CreateEffect(c)
    e1:SetDescription(1163)
    e1:SetType(EFFECT_TYPE_FIELD)
    e1:SetCode(EFFECT_SPSUMMON_PROC_G)
    e1:SetProperty(EFFECT_FLAG_CANNOT_DISABLE+EFFECT_FLAG_UNCOPYABLE)
    e1:SetRange(LOCATION_PZONE)
    e1:SetCondition(Auxiliary.PendCondition())
    e1:SetOperation(Auxiliary.PendOperation())
    e1:SetValue(SUMMON_TYPE_PENDULUM)
    c:RegisterEffect(e1)
    --register by default
    if reg==nil or reg then
    local e2=Effect.CreateEffect(c)
    e2:SetDescription(1160)
    e2:SetType(EFFECT_TYPE_ACTIVATE)
    e2:SetCode(EVENT_FREE_CHAIN)
    e2:SetRange(LOCATION_HAND)
    c:RegisterEffect(e2)
    end
    end
    function Auxiliary.PendulumReset(e,tp,eg,ep,ev,re,r,rp)
    Auxiliary.PendulumChecklist=0
    end
    function Auxiliary.PConditionExtraFilterSpecific(c,e,tp,lscale,rscale,te)
    if not te then return true end
    local f=te:GetValue()
    return not f or f(te,c,e,tp,lscale,rscale)
    end
    function Auxiliary.PConditionExtraFilter(c,e,tp,lscale,rscale,eset)
    for _,te in ipairs(eset) do
    if Auxiliary.PConditionExtraFilterSpecific(c,e,tp,lscale,rscale,te) then return true end
    end
    return false
    end
    function Auxiliary.PConditionFilter(c,e,tp,lscale,rscale,eset)
    local lv=0
    if c.pendulum_level then
    lv=c.pendulum_level
    else
    lv=c:GetLevel()
    end
    local bool=Auxiliary.PendulumSummonableBool(c)
    return (c:IsLocation(LOCATION_HAND) or (c:IsFaceup() and c:IsType(TYPE_PENDULUM)))
    and lv>lscale and lv<rscale and c:IsCanBeSpecialSummoned(e,SUMMON_TYPE_PENDULUM,tp,bool,bool)
    and not c:IsForbidden()
    and (Auxiliary.PendulumChecklist&(0x1<<tp)==0 or Auxiliary.PConditionExtraFilter(c,e,tp,lscale,rscale,eset))
    end
    function Auxiliary.PendCondition()
    return function(e,c,og)
    if c==nil then return true end
    local tp=c:GetControler()
    local eset={Duel.IsPlayerAffectedByEffect(tp,EFFECT_EXTRA_PENDULUM_SUMMON)}
    if Auxiliary.PendulumChecklist&(0x1<<tp)~=0 and #eset==0 then return false end
    local rpz=Duel.GetFieldCard(tp,LOCATION_PZONE,1)
    if rpz==nil or c==rpz then return false end
    local lscale=c:GetLeftScale()
    local rscale=rpz:GetRightScale()
    if lscale>rscale then lscale,rscale=rscale,lscale end
    local loc=0
    if Duel.GetLocationCount(tp,LOCATION_MZONE)>0 then loc=loc+LOCATION_HAND end
    if Duel.GetLocationCountFromEx(tp,tp,nil,TYPE_PENDULUM)>0 then loc=loc+LOCATION_EXTRA end
    if loc==0 then return false end
    local g=nil
    if og then
    g=og:Filter(Card.IsLocation,nil,loc)
    else
    g=Duel.GetFieldGroup(tp,loc,0)
    end
    return g:IsExists(Auxiliary.PConditionFilter,1,nil,e,tp,lscale,rscale,eset)
    end
    end
    function Auxiliary.PendOperationCheck(ft1,ft2,ft)
    return function(g)
    local exg=g:Filter(Card.IsLocation,nil,LOCATION_EXTRA)
    local mg=g-exg
    return #g<=ft and #exg<=ft2 and #mg<=ft1
    end
    end
    function Auxiliary.PendOperation()
    return function(e,tp,eg,ep,ev,re,r,rp,c,sg,og)
    local rpz=Duel.GetFieldCard(tp,LOCATION_PZONE,1)
    local lscale=c:GetLeftScale()
    local rscale=rpz:GetRightScale()
    if lscale>rscale then lscale,rscale=rscale,lscale end
    local eset={Duel.IsPlayerAffectedByEffect(tp,EFFECT_EXTRA_PENDULUM_SUMMON)}
    local tg=nil
    local loc=0
    local ft1=Duel.GetLocationCount(tp,LOCATION_MZONE)
    local ft2=Duel.GetLocationCountFromEx(tp,tp,nil,TYPE_PENDULUM)
    local ft=Duel.GetUsableMZoneCount(tp)
    local ect=c29724053 and Duel.IsPlayerAffectedByEffect(tp,29724053) and c29724053[tp]
    if ect and ect<ft2 then ft2=ect end
    if Duel.IsPlayerAffectedByEffect(tp,59822133) then
    if ft1>0 then ft1=1 end
    if ft2>0 then ft2=1 end
    ft=1
    end
    if ft1>0 then loc=loc|LOCATION_HAND end
    if ft2>0 then loc=loc|LOCATION_EXTRA end
    if og then
    tg=og:Filter(Card.IsLocation,nil,loc):Filter(Auxiliary.PConditionFilter,nil,e,tp,lscale,rscale,eset)
    else
    tg=Duel.GetMatchingGroup(Auxiliary.PConditionFilter,tp,loc,0,nil,e,tp,lscale,rscale,eset)
    end
    local ce=nil
    local b1=Auxiliary.PendulumChecklist&(0x1<<tp)==0
    local b2=#eset>0
    if b1 and b2 then
    local options={1163}
    for _,te in ipairs(eset) do
    table.insert(options,te:GetDescription())
    end
    local op=Duel.SelectOption(tp,table.unpack(options))
    if op>0 then
    ce=eset[op]
    end
    elseif b2 and not b1 then
    local options={}
    for _,te in ipairs(eset) do
    table.insert(options,te:GetDescription())
    end
    local op=Duel.SelectOption(tp,table.unpack(options))
    ce=eset[op+1]
    end
    if ce then
    tg=tg:Filter(Auxiliary.PConditionExtraFilterSpecific,nil,e,tp,lscale,rscale,ce)
    end
    Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_SPSUMMON)
    Auxiliary.GCheckAdditional=Auxiliary.PendOperationCheck(ft1,ft2,ft)
    local g=tg:SelectSubGroup(tp,aux.TRUE,true,1,math.min(#tg,ft))
    Auxiliary.GCheckAdditional=nil
    if not g then return end
    if ce then
    Duel.Hint(HINT_CARD,0,ce:GetOwner():GetOriginalCode())
    ce:Reset()
    else
    Auxiliary.PendulumChecklist=Auxiliary.PendulumChecklist|(0x1<<tp)
    end
    sg:Merge(g)
    Duel.HintSelection(Group.FromCards(c))
    Duel.HintSelection(Group.FromCards(rpz))
    end
    end
    --enable revive limit for monsters that are also pendulum sumonable from certain locations (Odd-Eyes Revolution Dragon)
    function Auxiliary.EnableReviveLimitPendulumSummonable(c, loc)
    if c:IsStatus(STATUS_COPYING_EFFECT) then return end
    c:EnableReviveLimit()
    local mt=getmetatable(c)
    if loc==nil then loc=0xff end
    mt.psummonable_location=loc
    --complete procedure on pendulum summon success
    local e1=Effect.CreateEffect(c)
    e1:SetProperty(EFFECT_FLAG_CANNOT_DISABLE+EFFECT_FLAG_UNCOPYABLE)
    e1:SetType(EFFECT_TYPE_SINGLE+EFFECT_TYPE_CONTINUOUS)
    e1:SetCode(EVENT_SPSUMMON_SUCCESS)
    e1:SetOperation(Auxiliary.PSSCompleteProcedure)
    c:RegisterEffect(e1)
    end
    function Auxiliary.PendulumSummonableBool(c)
    return c.psummonable_location~=nil and c:GetLocation()&c.psummonable_location>0
    end
    function Auxiliary.PSSCompleteProcedure(e,tp,eg,ep,ev,re,r,rp)
    local c=e:GetHandler()
    if c:IsSummonType(SUMMON_TYPE_PENDULUM) then
    c:CompleteProcedure()
    end
    end
    --Link Summon
    function Auxiliary.AddLinkProcedure(c,f,min,max,gf)
    local e1=Effect.CreateEffect(c)
    e1:SetDescription(1166)
    e1:SetType(EFFECT_TYPE_FIELD)
    e1:SetCode(EFFECT_SPSUMMON_PROC)
    e1:SetProperty(EFFECT_FLAG_CANNOT_DISABLE+EFFECT_FLAG_UNCOPYABLE)
    e1:SetRange(LOCATION_EXTRA)
    if max==nil then max=c:GetLink() end
    e1:SetCondition(Auxiliary.LinkCondition(f,min,max,gf))
    e1:SetTarget(Auxiliary.LinkTarget(f,min,max,gf))
    e1:SetOperation(Auxiliary.LinkOperation(f,min,max,gf))
    e1:SetValue(SUMMON_TYPE_LINK)
    c:RegisterEffect(e1)
    end
    function Auxiliary.LConditionFilter(c,f,lc)
    return (c:IsFaceup() or not c:IsOnField()) and c:IsCanBeLinkMaterial(lc) and (not f or f(c))
    end
    function Auxiliary.LExtraFilter(c,f,lc,tp)
    if c:IsLocation(LOCATION_ONFIELD) and not c:IsFaceup() then return false end
    if not c:IsCanBeLinkMaterial(lc) or f and not f(c) then return false end
    local le={c:IsHasEffect(EFFECT_EXTRA_LINK_MATERIAL,tp)}
    for _,te in pairs(le) do
    local tf=te:GetValue()
    local related,valid=tf(te,lc,nil,c,tp)
    if related then return true end
    end
    return false
    end
    function Auxiliary.GetLinkCount(c)
    if c:IsType(TYPE_LINK) and c:GetLink()>1 then
    return 1+0x10000*c:GetLink()
    else return 1 end
    end
    function Auxiliary.GetLinkMaterials(tp,f,lc)
    local mg=Duel.GetMatchingGroup(Auxiliary.LConditionFilter,tp,LOCATION_MZONE,0,nil,f,lc)
    local mg2=Duel.GetMatchingGroup(Auxiliary.LExtraFilter,tp,LOCATION_HAND+LOCATION_SZONE,LOCATION_ONFIELD,nil,f,lc,tp)
    if mg2:GetCount()>0 then mg:Merge(mg2) end
    return mg
    end
    function Auxiliary.LCheckOtherMaterial(c,mg,lc,tp)
    local le={c:IsHasEffect(EFFECT_EXTRA_LINK_MATERIAL,tp)}
    local res1=false
    local res2=true
    for _,te in pairs(le) do
    local f=te:GetValue()
    local related,valid=f(te,lc,mg,c,tp)
    if related then res2=false end
    if related and valid then res1=true end
    end
    return res1 or res2
    end
    function Auxiliary.LUncompatibilityFilter(c,sg,lc,tp)
    local mg=sg:Filter(aux.TRUE,c)
    return not Auxiliary.LCheckOtherMaterial(c,mg,lc,tp)
    end
    function Auxiliary.LCheckGoal(sg,tp,lc,gf,lmat)
    return sg:CheckWithSumEqual(Auxiliary.GetLinkCount,lc:GetLink(),#sg,#sg)
    and Duel.GetLocationCountFromEx(tp,tp,sg,lc)>0 and (not gf or gf(sg))
    and not sg:IsExists(Auxiliary.LUncompatibilityFilter,1,nil,sg,lc,tp)
    and (not lmat or sg:IsContains(lmat))
    end
    function Auxiliary.LExtraMaterialCount(mg,lc,tp)
    for tc in aux.Next(mg) do
    local le={tc:IsHasEffect(EFFECT_EXTRA_LINK_MATERIAL,tp)}
    for _,te in pairs(le) do
    local sg=mg:Filter(aux.TRUE,tc)
    local f=te:GetValue()
    local related,valid=f(te,lc,sg,tc,tp)
    if related and valid then
    te:UseCountLimit(tp)
    end
    end
    end
    end
    function Auxiliary.LinkCondition(f,minc,maxc,gf)
    return function(e,c,og,lmat,min,max)
    if c==nil then return true end
    if c:IsType(TYPE_PENDULUM) and c:IsFaceup() then return false end
    local minc=minc
    local maxc=maxc
    if min then
    if min>minc then minc=min end
    if max<maxc then maxc=max end
    if minc>maxc then return false end
    end
    local tp=c:GetControler()
    local mg=nil
    if og then
    mg=og:Filter(Auxiliary.LConditionFilter,nil,f,c)
    else
    mg=Auxiliary.GetLinkMaterials(tp,f,c)
    end
    if lmat~=nil then
    if not Auxiliary.LConditionFilter(lmat,f,c) then return false end
    mg:AddCard(lmat)
    end
    local fg=Auxiliary.GetMustMaterialGroup(tp,EFFECT_MUST_BE_LMATERIAL)
    if fg:IsExists(Auxiliary.MustMaterialCounterFilter,1,nil,mg) then return false end
    Duel.SetSelectedCard(fg)
    return mg:CheckSubGroup(Auxiliary.LCheckGoal,minc,maxc,tp,c,gf,lmat)
    end
    end
    function Auxiliary.LinkTarget(f,minc,maxc,gf)
    return function(e,tp,eg,ep,ev,re,r,rp,chk,c,og,lmat,min,max)
    local minc=minc
    local maxc=maxc
    if min then
    if min>minc then minc=min end
    if max<maxc then maxc=max end
    if minc>maxc then return false end
    end
    local mg=nil
    if og then
    mg=og:Filter(Auxiliary.LConditionFilter,nil,f,c)
    else
    mg=Auxiliary.GetLinkMaterials(tp,f,c)
    end
    if lmat~=nil then
    if not Auxiliary.LConditionFilter(lmat,f,c) then return false end
    mg:AddCard(lmat)
    end
    local fg=Auxiliary.GetMustMaterialGroup(tp,EFFECT_MUST_BE_LMATERIAL)
    Duel.SetSelectedCard(fg)
    Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_LMATERIAL)
    local cancel=Duel.IsSummonCancelable()
    local sg=mg:SelectSubGroup(tp,Auxiliary.LCheckGoal,cancel,minc,maxc,tp,c,gf,lmat)
    if sg then
    sg:KeepAlive()
    e:SetLabelObject(sg)
    return true
    else return false end
    end
    end
    function Auxiliary.LinkOperation(f,minc,maxc,gf)
    return function(e,tp,eg,ep,ev,re,r,rp,c,og,lmat,min,max)
    local g=e:GetLabelObject()
    c:SetMaterial(g)
    Auxiliary.LExtraMaterialCount(g,c,tp)
    Duel.SendtoGrave(g,REASON_MATERIAL+REASON_LINK)
    g:DeleteGroup()
    end
    end
    function Auxiliary.EnableExtraDeckSummonCountLimit()
    if Auxiliary.ExtraDeckSummonCountLimit~=nil then return end
    Auxiliary.ExtraDeckSummonCountLimit={}
    Auxiliary.ExtraDeckSummonCountLimit[0]=1
    Auxiliary.ExtraDeckSummonCountLimit[1]=1
    local ge1=Effect.GlobalEffect()
    ge1:SetType(EFFECT_TYPE_CONTINUOUS+EFFECT_TYPE_FIELD)
    ge1:SetCode(EVENT_PHASE_START+PHASE_DRAW)
    ge1:SetOperation(Auxiliary.ExtraDeckSummonCountLimitReset)
    Duel.RegisterEffect(ge1,0)
    end
    function Auxiliary.ExtraDeckSummonCountLimitReset()
    Auxiliary.ExtraDeckSummonCountLimit[0]=1
    Auxiliary.ExtraDeckSummonCountLimit[1]=1
    end
    function Auxiliary.IsMaterialListCode(c,code)
    return c.material and c.material[code]
    end
    function Auxiliary.IsMaterialListSetCard(c,setcode)
    if not c.material_setcode then return false end
    if type(c.material_setcode)=='table' then
    for i,scode in ipairs(c.material_setcode) do
    if setcode&0xfff==scode&0xfff and setcode&scode==setcode then return true end
    end
    else
    return setcode&0xfff==c.material_setcode&0xfff and setcode&c.material_setcode==setcode
    end
    return false
    end
    function Auxiliary.IsMaterialListType(c,type)
    return c.material_type and type&c.material_type==type
    end
    function Auxiliary.AddCodeList(c,...)
    if c:IsStatus(STATUS_COPYING_EFFECT) then return end
    if c.card_code_list==nil then
    local mt=getmetatable(c)
    mt.card_code_list={}
    for _,code in ipairs{...} do
    mt.card_code_list[code]=true
    end
    else
    for _,code in ipairs{...} do
    c.card_code_list[code]=true
    end
    end
    end
    function Auxiliary.IsCodeListed(c,code)
    return c.card_code_list and c.card_code_list[code]
    end
    function Auxiliary.IsCounterAdded(c,counter)
    if not c.counter_add_list then return false end
    for i,ccounter in ipairs(c.counter_add_list) do
    if counter==ccounter then return true end
    end
    return false
    end
    function Auxiliary.IsInGroup(c,g)
    return g:IsContains(c)
    end
    --return the column of card c (from the viewpoint of p)
    function Auxiliary.GetColumn(c,p)
    local seq=c:GetSequence()
    if c:IsLocation(LOCATION_MZONE) then
    if seq==5 then seq=1 elseif seq==6 then seq=3 end
    elseif c:IsLocation(LOCATION_SZONE) then
    if seq>4 then return nil end
    else return nil end
    if c:IsControler(p or 0) then return seq else return 4-seq end
    end
    --return the column of monster zone seq (from the viewpoint of controller)
    function Auxiliary.MZoneSequence(seq)
    if seq==5 then return 1 end
    if seq==6 then return 3 end
    return seq
    end
    --return the column of spell/trap zone seq (from the viewpoint of controller)
    function Auxiliary.SZoneSequence(seq)
    if seq>4 then return nil end
    return seq
    end
    function Auxiliary.ChangeBattleDamage(player,value)
    return function(e,damp)
    if player==0 then
    if e:GetOwnerPlayer()==damp then
    return value
    else
    return -1
    end
    elseif player==1 then
    if e:GetOwnerPlayer()==1-damp then
    return value
    else
    return -1
    end
    end
    end
    end
    --card effect disable filter(target)
    function Auxiliary.disfilter1(c)
    return c:IsFaceup() and not c:IsDisabled() and (not c:IsType(TYPE_NORMAL) or c:GetOriginalType()&TYPE_EFFECT~=0)
    end
    --condition of EVENT_BATTLE_DESTROYING
    function Auxiliary.bdcon(e,tp,eg,ep,ev,re,r,rp)
    local c=e:GetHandler()
    return c:IsRelateToBattle()
    end
    --condition of EVENT_BATTLE_DESTROYING + opponent monster
    function Auxiliary.bdocon(e,tp,eg,ep,ev,re,r,rp)
    local c=e:GetHandler()
    return c:IsRelateToBattle() and c:IsStatus(STATUS_OPPO_BATTLE)
    end
    --condition of EVENT_BATTLE_DESTROYING + to_grave
    function Auxiliary.bdgcon(e,tp,eg,ep,ev,re,r,rp)
    local c=e:GetHandler()
    local bc=c:GetBattleTarget()
    return c:IsRelateToBattle() and bc:IsLocation(LOCATION_GRAVE) and bc:IsType(TYPE_MONSTER)
    end
    --condition of EVENT_BATTLE_DESTROYING + opponent monster + to_grave
    function Auxiliary.bdogcon(e,tp,eg,ep,ev,re,r,rp)
    local c=e:GetHandler()
    local bc=c:GetBattleTarget()
    return c:IsRelateToBattle() and c:IsStatus(STATUS_OPPO_BATTLE) and bc:IsLocation(LOCATION_GRAVE) and bc:IsType(TYPE_MONSTER)
    end
    --condition of EVENT_TO_GRAVE + destroyed by opponent
    function Auxiliary.dogcon(e,tp,eg,ep,ev,re,r,rp)
    local c=e:GetHandler()
    return c:GetPreviousControler()==tp and c:IsReason(REASON_DESTROY) and rp==1-tp
    end
    --condition of EVENT_TO_GRAVE + destroyed by opponent + from field
    function Auxiliary.dogfcon(e,tp,eg,ep,ev,re,r,rp)
    local c=e:GetHandler()
    return c:IsPreviousLocation(LOCATION_ONFIELD) and c:GetPreviousControler()==tp
    and c:IsReason(REASON_DESTROY) and rp==1-tp
    end
    --condition of "except the turn this card was sent to the Graveyard"
    function Auxiliary.exccon(e)
    return Duel.GetTurnCount()~=e:GetHandler():GetTurnID() or e:GetHandler():IsReason(REASON_RETURN)
    end
    --condition of checking battle phase availability
    function Auxiliary.bpcon(e,tp,eg,ep,ev,re,r,rp)
    return Duel.IsAbleToEnterBP() or (Duel.GetCurrentPhase()>=PHASE_BATTLE_START and Duel.GetCurrentPhase()<=PHASE_BATTLE)
    end
    --condition of free chain effects changing ATK/DEF
    function Auxiliary.dscon(e,tp,eg,ep,ev,re,r,rp)
    return Duel.GetCurrentPhase()~=PHASE_DAMAGE or not Duel.IsDamageCalculated()
    end
    --flag effect for spell counter
    function Auxiliary.chainreg(e,tp,eg,ep,ev,re,r,rp)
    if e:GetHandler():GetFlagEffect(1)==0 then
    e:GetHandler():RegisterFlagEffect(1,RESET_EVENT+RESETS_STANDARD-RESET_TURN_SET+RESET_CHAIN,0,1)
    end
    end
    --default filter for EFFECT_CANNOT_BE_BATTLE_TARGET
    function Auxiliary.imval1(e,c)
    return not c:IsImmuneToEffect(e)
    end
    --filter for EFFECT_INDESTRUCTABLE_EFFECT + self
    function Auxiliary.indsval(e,re,rp)
    return rp==e:GetHandlerPlayer()
    end
    --filter for EFFECT_INDESTRUCTABLE_EFFECT + opponent
    function Auxiliary.indoval(e,re,rp)
    return rp==1-e:GetHandlerPlayer()
    end
    --filter for EFFECT_CANNOT_BE_EFFECT_TARGET + self
    function Auxiliary.tgsval(e,re,rp)
    return rp==e:GetHandlerPlayer()
    end
    --filter for EFFECT_CANNOT_BE_EFFECT_TARGET + opponent
    function Auxiliary.tgoval(e,re,rp)
    return rp==1-e:GetHandlerPlayer()
    end
    --filter for non-zero ATK
    function Auxiliary.nzatk(c)
    return c:IsFaceup() and c:GetAttack()>0
    end
    --filter for non-zero DEF
    function Auxiliary.nzdef(c)
    return c:IsFaceup() and c:GetDefense()>0
    end
    --flag effect for summon/sp_summon turn
    function Auxiliary.sumreg(e,tp,eg,ep,ev,re,r,rp)
    local tc=eg:GetFirst()
    local code=e:GetLabel()
    while tc do
    if tc:GetOriginalCode()==code then
    tc:RegisterFlagEffect(code,RESET_EVENT+0x1ec0000+RESET_PHASE+PHASE_END,0,1)
    end
    tc=eg:GetNext()
    end
    end
    --sp_summon condition for fusion monster
    function Auxiliary.fuslimit(e,se,sp,st)
    return st&SUMMON_TYPE_FUSION==SUMMON_TYPE_FUSION
    end
    --sp_summon condition for ritual monster
    function Auxiliary.ritlimit(e,se,sp,st)
    return st&SUMMON_TYPE_RITUAL==SUMMON_TYPE_RITUAL
    end
    --sp_summon condition for synchro monster
    function Auxiliary.synlimit(e,se,sp,st)
    return st&SUMMON_TYPE_SYNCHRO==SUMMON_TYPE_SYNCHRO
    end
    --sp_summon condition for xyz monster
    function Auxiliary.xyzlimit(e,se,sp,st)
    return st&SUMMON_TYPE_XYZ==SUMMON_TYPE_XYZ
    end
    --sp_summon condition for pendulum monster
    function Auxiliary.penlimit(e,se,sp,st)
    return st&SUMMON_TYPE_PENDULUM==SUMMON_TYPE_PENDULUM
    end
    --sp_summon condition for link monster
    function Auxiliary.linklimit(e,se,sp,st)
    return st&SUMMON_TYPE_LINK==SUMMON_TYPE_LINK
    end
    --effects inflicting damage to tp
    function Auxiliary.damcon1(e,tp,eg,ep,ev,re,r,rp)
    local e1=Duel.IsPlayerAffectedByEffect(tp,EFFECT_REVERSE_DAMAGE)
    local e2=Duel.IsPlayerAffectedByEffect(tp,EFFECT_REVERSE_RECOVER)
    local rd=e1 and not e2
    local rr=not e1 and e2
    local ex,cg,ct,cp,cv=Duel.GetOperationInfo(ev,CATEGORY_DAMAGE)
    if ex and (cp==tp or cp==PLAYER_ALL) and not rd and not Duel.IsPlayerAffectedByEffect(tp,EFFECT_NO_EFFECT_DAMAGE) then
    return true
    end
    ex,cg,ct,cp,cv=Duel.GetOperationInfo(ev,CATEGORY_RECOVER)
    return ex and (cp==tp or cp==PLAYER_ALL) and rr and not Duel.IsPlayerAffectedByEffect(tp,EFFECT_NO_EFFECT_DAMAGE)
    end
    --filter for the immune effect of qli monsters
    function Auxiliary.qlifilter(e,te)
    if te:IsActiveType(TYPE_MONSTER) and te:IsActivated() then
    local lv=e:GetHandler():GetLevel()
    local ec=te:GetOwner()
    if ec:IsType(TYPE_LINK) then
    return false
    elseif ec:IsType(TYPE_XYZ) then
    return ec:GetOriginalRank()<lv
    else
    return ec:GetOriginalLevel()<lv
    end
    else
    return false
    end
    end
    --sp_summon condition for gladiator beast monsters
    function Auxiliary.gbspcon(e,tp,eg,ep,ev,re,r,rp)
    local st=e:GetHandler():GetSummonType()
    return st&SUMMON_VALUE_GLADIATOR>0
    end
    --sp_summon condition for evolsaur monsters
    function Auxiliary.evospcon(e,tp,eg,ep,ev,re,r,rp)
    local st=e:GetHandler():GetSummonType()
    return st&SUMMON_VALUE_EVOLTILE>0
    end
    --filter for necro_valley test
    function Auxiliary.NecroValleyFilter(f)
    return function(target,...)
    return (not f or f(target,...)) and not (target:IsHasEffect(EFFECT_NECRO_VALLEY) and Duel.IsChainDisablable(0))
    end
    end
    --shortcut for self-banish costs
    function Auxiliary.bfgcost(e,tp,eg,ep,ev,re,r,rp,chk)
    if chk==0 then return e:GetHandler():IsAbleToRemoveAsCost() end
    Duel.Remove(e:GetHandler(),POS_FACEUP,REASON_COST)
    end
    --check for cards with different names
    function Auxiliary.dncheck(g)
    return g:GetClassCount(Card.GetCode)==#g
    end
    --check for cards with different levels
    function Auxiliary.dlvcheck(g)
    return g:GetClassCount(Card.GetLevel)==#g
    end
    --check for cards with different ranks
    function Auxiliary.drkcheck(g)
    return g:GetClassCount(Card.GetRank)==#g
    end
    --check for cards with different links
    function Auxiliary.dlkcheck(g)
    return g:GetClassCount(Card.GetLink)==#g
    end
    --check for cards with different attributes
    function Auxiliary.dabcheck(g)
    return g:GetClassCount(Card.GetAttribute)==#g
    end
    --check for cards with different races
    function Auxiliary.drccheck(g)
    return g:GetClassCount(Card.GetRace)==#g
    end
    --check for group with 2 cards, each card match f with a1/a2 as argument
    function Auxiliary.gfcheck(g,f,a1,a2)
    if #g~=2 then return false end
    local c1=g:GetFirst()
    local c2=g:GetNext()
    return f(c1,a1) and f(c2,a2) or f(c2,a1) and f(c1,a2)
    end
    --check for group with 2 cards, each card match f1 with a1, f2 with a2 as argument
    function Auxiliary.gffcheck(g,f1,a1,f2,a2)
    if #g~=2 then return false end
    local c1=g:GetFirst()
    local c2=g:GetNext()
    return f1(c1,a1) and f2(c2,a2) or f1(c2,a1) and f2(c1,a2)
    end
    function Auxiliary.mzctcheck(g,tp)
    return Duel.GetMZoneCount(tp,g)>0
    end
    function Auxiliary.mzctcheckrel(g,tp)
    return Duel.GetMZoneCount(tp,g)>0 and Duel.CheckReleaseGroup(tp,Auxiliary.IsInGroup,#g,nil,g)
    end
    --used for "except this card"
    function Auxiliary.ExceptThisCard(e)
    local c=e:GetHandler()
    if c:IsRelateToEffect(e) then return c else return nil end
    end
    --used for multi-linked zone(zone linked by two or more link monsters)
    function Auxiliary.GetMultiLinkedZone(tp)
    local f=function(c)
    return c:IsFaceup() and c:IsType(TYPE_LINK)
    end
    local lg=Duel.GetMatchingGroup(f,tp,LOCATION_MZONE,LOCATION_MZONE,nil)
    local multi_linked_zone=0
    local single_linked_zone=0
    for tc in aux.Next(lg) do
    local zone=tc:GetLinkedZone(tp)&0x7f
    multi_linked_zone=single_linked_zone&zone|multi_linked_zone
    single_linked_zone=single_linked_zone~zone
    end
    return multi_linked_zone
    end
    Auxiliary.SubGroupCaptured=nil
    Auxiliary.GCheckAdditional=nil
    function Auxiliary.CheckGroupRecursive(c,sg,g,f,min,max,ext_params)
    sg:AddCard(c)
    if Auxiliary.GCheckAdditional and not Auxiliary.GCheckAdditional(sg,c,g,f,min,max,ext_params) then
    sg:RemoveCard(c)
    return false
    end
    local res=(#sg>=min and #sg<=max and f(sg,table.unpack(ext_params)))
    or (#sg<max and g:IsExists(Auxiliary.CheckGroupRecursive,1,sg,sg,g,f,min,max,ext_params))
    sg:RemoveCard(c)
    return res
    end
    function Auxiliary.CheckGroupRecursiveCapture(c,sg,g,f,min,max,ext_params)
    sg:AddCard(c)
    if Auxiliary.GCheckAdditional and not Auxiliary.GCheckAdditional(sg,c,g,f,min,max,ext_params) then
    sg:RemoveCard(c)
    return false
    end
    local res=#sg>=min and #sg<=max and f(sg,table.unpack(ext_params))
    if res then
    Auxiliary.SubGroupCaptured:Clear()
    Auxiliary.SubGroupCaptured:Merge(sg)
    else
    res=#sg<max and g:IsExists(Auxiliary.CheckGroupRecursiveCapture,1,sg,sg,g,f,min,max,ext_params)
    end
    sg:RemoveCard(c)
    return res
    end
    function Group.CheckSubGroup(g,f,min,max,...)
    local min=min or 1
    local max=max or #g
    if min>max then return false end
    local ext_params={...}
    local sg=Duel.GrabSelectedCard()
    if #sg>max or #(g+sg)<min then return false end
    if #sg==max and (not f(sg,...) or Auxiliary.GCheckAdditional and not Auxiliary.GCheckAdditional(sg,nil,g,f,min,max,ext_params)) then return false end
    if #sg>=min and #sg<=max and f(sg,...) and (not Auxiliary.GCheckAdditional or Auxiliary.GCheckAdditional(sg,nil,g,f,min,max,ext_params)) then return true end
    local eg=g:Clone()
    for c in aux.Next(g-sg) do
    if Auxiliary.CheckGroupRecursive(c,sg,eg,f,min,max,ext_params) then return true end
    eg:RemoveCard(c)
    end
    return false
    end
    function Group.SelectSubGroup(g,tp,f,cancelable,min,max,...)
    Auxiliary.SubGroupCaptured=Group.CreateGroup()
    local min=min or 1
    local max=max or #g
    local ext_params={...}
    local sg=Group.CreateGroup()
    local fg=Duel.GrabSelectedCard()
    if #fg>max or min>max or #(g+fg)<min then return nil end
    for tc in aux.Next(fg) do
    fg:SelectUnselect(sg,tp,false,false,min,max)
    end
    sg:Merge(fg)
    local finish=(#sg>=min and #sg<=max and f(sg,...))
    while #sg<max do
    local cg=Group.CreateGroup()
    local eg=g:Clone()
    for c in aux.Next(g-sg) do
    if not cg:IsContains(c) then
    if Auxiliary.CheckGroupRecursiveCapture(c,sg,eg,f,min,max,ext_params) then
    cg:Merge(Auxiliary.SubGroupCaptured)
    else
    eg:RemoveCard(c)
    end
    end
    end
    cg:Sub(sg)
    finish=(#sg>=min and #sg<=max and f(sg,...))
    if #cg==0 then break end
    local cancel=not finish and cancelable
    local tc=cg:SelectUnselect(sg,tp,finish,cancel,min,max)
    if not tc then break end
    if not fg:IsContains(tc) then
    if not sg:IsContains(tc) then
    sg:AddCard(tc)
    if #sg==max then finish=true end
    else
    sg:RemoveCard(tc)
    end
    elseif cancelable then
    return nil
    end
    end
    if finish then
    return sg
    else
    return nil
    end
    end
    function Auxiliary.CreateChecks(f,list)
    local checks={}
    for i=1,#list do
    checks[i]=function(c) return f(c,list[i]) end
    end
    return checks
    end
    function Auxiliary.CheckGroupRecursiveEach(c,sg,g,f,checks,ext_params)
    if not checks[1+#sg](c) then
    return false
    end
    sg:AddCard(c)
    if Auxiliary.GCheckAdditional and not Auxiliary.GCheckAdditional(sg,c,g,f,min,max,ext_params) then
    sg:RemoveCard(c)
    return false
    end
    local res
    if #sg==#checks then
    res=f(sg,table.unpack(ext_params))
    else
    res=g:IsExists(Auxiliary.CheckGroupRecursiveEach,1,sg,sg,g,f,checks,ext_params)
    end
    sg:RemoveCard(c)
    return res
    end
    function Group.CheckSubGroupEach(g,checks,f,...)
    if f==nil then f=Auxiliary.TRUE end
    if #g<#checks then return false end
    local ext_params={...}
    local sg=Group.CreateGroup()
    return g:IsExists(Auxiliary.CheckGroupRecursiveEach,1,sg,sg,g,f,checks,ext_params)
    end
    function Group.SelectSubGroupEach(g,tp,checks,cancelable,f,...)
    if cancelable==nil then cancelable=false end
    if f==nil then f=Auxiliary.TRUE end
    local ct=#checks
    local ext_params={...}
    local sg=Group.CreateGroup()
    local finish=false
    while #sg<ct do
    local cg=g:Filter(Auxiliary.CheckGroupRecursiveEach,sg,sg,g,f,checks,ext_params)
    if #cg==0 then break end
    local tc=cg:SelectUnselect(sg,tp,false,cancelable,ct,ct)
    if not tc then break end
    if not sg:IsContains(tc) then
    sg:AddCard(tc)
    if #sg==ct then finish=true end
    else
    sg:Clear()
    end
    end
    if finish then
    return sg
    else
    return nil
    end
    end
    --condition of "negate activation and banish"
    function Auxiliary.nbcon(tp,re)
    local rc=re:GetHandler()
    return Duel.IsPlayerCanRemove(tp)
    and (not rc:IsRelateToEffect(re) or rc:IsAbleToRemove())
    end
    --send to deck of contact fusion
    function Auxiliary.tdcfop(c)
    return function(g)
    local cg=g:Filter(Card.IsFacedown,nil)
    if cg:GetCount()>0 then
    Duel.ConfirmCards(1-c:GetControler(),cg)
    end
    Duel.SendtoDeck(g,nil,2,REASON_COST)
    end
    end
    --return the global index of the zone in (p,loc,seq)
    function Auxiliary.SequenceToGlobal(p,loc,seq)
    if p~=0 and p~=1 then
    return 0
    end
    if loc==LOCATION_MZONE then
    if seq<=6 then
    return 0x1<<(16*p+seq)
    else
    return 0
    end
    elseif loc == LOCATION_SZONE then
    if seq<=4 then
    return 0x10<<(16*p+seq)
    else
    return 0
    end
    else
    return 0
    end
    end
    Markdown is supported
    0% or
    You are about to add 0 people to the discussion. Proceed with caution.
    Finish editing this message first!
    Please register or to comment