Skip to content

P
pre-release-database-cdb
Commit 5d44546e authored by wind2009's avatar wind2009
Browse files
Options

remove library

parent 96be04a5
Show whitespace changes
Inline Side-by-side
Showing with 0 additions and 4968 deletions
script/constant.lua deleted 100644 → 0
View file @ 96be04a5
--min/max value
MIN_ID =128 --0x80, by DataManager::GetDesc()
MAX_ID =268435455 --28 bits, by DataManager::GetDesc()
MAX_COUNTER =65535 --max number for adding/removing counters, by card::add_counter(), field::remove_counter()
MAX_PARAMETER =0xffff
--Locations 区域
LOCATION_DECK =0x01 --卡组
LOCATION_HAND =0x02 --手牌
LOCATION_MZONE =0x04 --主要怪兽区(0-4)+额外怪兽区(5-6)
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 --弹回卡组并洗牌
--Sequences (for Duel.SendtoDeck)
SEQ_DECKTOP =0 --弹回卡组顶端
SEQ_DECKBOTTOM =1 --弹回卡组底端
SEQ_DECKSHUFFLE =2 --弹回卡组并洗牌（洗牌前暂时放在底端）
--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 --连接
--组合类型
TYPES_TOKEN_MONSTER =0x4011
TYPES_NORMAL_TRAP_MONSTER =0x111
TYPES_EFFECT_TRAP_MONSTER =0x121
--Attributes 属性
ATTRIBUTE_ALL =0x7f --All
ATTRIBUTE_EARTH =0x01 --地
ATTRIBUTE_WATER =0x02 --水
ATTRIBUTE_FIRE =0x04 --炎
ATTRIBUTE_WIND =0x08 --风
ATTRIBUTE_LIGHT =0x10 --光
ATTRIBUTE_DARK =0x20 --暗
ATTRIBUTE_DIVINE =0x40 --神
--Races 种族
RACE_ALL =0x3ffffff --全种族
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 --电子界
RACE_ILLUSION =0x2000000 --幻想魔
--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 --超量素材随着超量怪兽离场
REASON_MAINTENANCE =0x40000000 --维持代价
REASON_ACTION =0x80000000 --攻击宣言之际等
--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_SYNCHRO_MATERIAL =0x11 --特殊召唤并作为同调素材（黑羽-东云之东风检查）
SUMMON_VALUE_DARK_SANCTUARY =0x12 --暗黑圣域
SUMMON_VALUE_MONSTER_REBORN =0x13 --死者苏生（千年的启示）
SUMMON_VALUE_MASK_CHANGE =0x14 --
SUMMON_VALUE_ASSAULT_MODE =0x15 --
SUMMON_VALUE_LV =0x1000 --对应LV怪兽的效果
SUMMON_VALUE_GLADIATOR =0x2000 --剑斗兽
SUMMON_VALUE_EVOLTILE =0x4000 --进化虫
SUMMON_VALUE_DARK_FUSION =SUMMON_TYPE_FUSION|0x16 --
SUMMON_VALUE_FOSSIL_FUSION =SUMMON_TYPE_FUSION|0x17 --
SUMMON_VALUE_FUTURE_FUSION =SUMMON_TYPE_FUSION|0x18 --
--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_TO_HAND_WITHOUT_CONFIRM =0x800000 --非公开的卡被效果加入手卡但未给对方确认
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 --N/A
--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 --连锁发生时的守备力
--Summon info
SUMMON_INFO_CODE =0x01
SUMMON_INFO_CODE2 =0x02
SUMMON_INFO_TYPE =0x04
SUMMON_INFO_LEVEL =0x08
SUMMON_INFO_RANK =0x10
SUMMON_INFO_ATTRIBUTE =0x20
SUMMON_INFO_RACE =0x40
SUMMON_INFO_ATTACK =0x80
SUMMON_INFO_DEFENSE =0x100
SUMMON_INFO_REASON_EFFECT =0x200
SUMMON_INFO_REASON_PLAYER =0x400
--========== 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 --除了返回场上以外，从不同区域移动到怪兽区或魔法区
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)
RESETS_WITHOUT_TEMP_REMOVE =0x56e0000 --RESETS_STANDARD-RESET_TEMP_REMOVE-RESET_LEAVE+RESET_OVERLAY
--========== 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固定為某個玩家的視角所見的自己/對方(SetAbsoluteRange()專用)
EFFECT_FLAG_IGNORE_IMMUNE =0x0080 --无视效果免疫
EFFECT_FLAG_SET_AVAILABLE =0x0100 --裡側狀態可發動的效果、影响场上里侧的卡的永續型效果
EFFECT_FLAG_CAN_FORBIDDEN =0x0200 --可被禁止令停止適用的效果（與EFFECT_FLAG_CANNOT_DISABLE並用）
EFFECT_FLAG_CANNOT_DISABLE =0x0400 --效果不会被无效
EFFECT_FLAG_PLAYER_TARGET =0x0800 --含有"以玩家为对象"的特性（精靈之鏡）、影響玩家的永續型效果(SetTargetRange()改成指定玩家)
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 --N/A
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_ACTIVATE_CONDITION =0x20000000 --诱发效果即将发动时检查条件（手卡诱发之外的无此标记的诱发效果为触发事件时检查）
EFFECT_FLAG_CVAL_CHECK =0x40000000 --N/A
EFFECT_FLAG_IMMEDIATELY_APPLY =0x80000000 --卡在发动时效果就立即适用
EFFECT_FLAG2_REPEAT_UPDATE =0x0001 --最后计算的攻击力上升
EFFECT_FLAG2_COF =0x0002 --通常魔法卡在MP1以外发动（邪恶的仪式的特殊处理）
EFFECT_FLAG2_WICKED =0x0004 --神之化身/恐惧之源的攻击力变化最后计算
EFFECT_FLAG2_OPTION =0x0008 --子機
--========== 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_DIVINE_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 --设置自身守备力、守备力变成X特殊召唤、持续改变守备力
EFFECT_SET_DEFENSE_FINAL =106 --暂时改变守备力（所有置入连锁的效果）
EFFECT_SET_BASE_DEFENSE =107 --设置自身原本守备力、持续改变原本守备力
EFFECT_REVERSE_UPDATE =108 --倒置增减攻击力、防御力（天邪鬼）
EFFECT_SWAP_AD =109 --交换攻守(超級漏洞人)
EFFECT_SWAP_BASE_AD =110 --交换原本攻守
EFFECT_SET_BASE_ATTACK_FINAL =111 --暂时改变原本攻击力
EFFECT_SET_BASE_DEFENSE_FINAL =112 --暂时改变原本防御力
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_EXTRA_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_INVOLVING_BATTLE_DAMAGE =314 --改变此卡的战斗产生的战斗伤害
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_CHANGE_DAMAGE等）
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 --此卡的超量素材也能用于仪式召唤
EFFECT_CHANGE_GRAVE_ATTRIBUTE =365 --墓地的卡将会改变属性（升级转变）
EFFECT_CHANGE_GRAVE_RACE =366 --墓地的卡将会改变种族（升级转变）
EFFECT_ACTIVATION_COUNT_LIMIT =367 --reserve
EFFECT_LIMIT_SPECIAL_SUMMON_POSITION =368 --不能以特定表示形式特殊召唤
EFFECT_TUNER =369 --同调召唤时可以当作调整（百檎龙-苹果鳞虫）
EFFECT_KAISER_COLOSSEUM =370 --皇帝斗技场
EFFECT_REPLACE_DAMAGE =371 --伤害由特定行动代替
EFFECT_FLAG_EFFECT =0x20000000 --标记类效果，即RegisterFlagEffect()创建的效果
--下面是诱发效果的诱发事件、时点 （如果是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_LEAVE_GRAVE =1031 --离开墓地时
EVENT_LEAVE_DECK =1032 --离开卡组或额外卡组时
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_SPSUMMON_SUCCESS_G_P =1117 --EFFECT_SPSUMMON_PROC_G特殊召唤成功前(只能使用EFFECT_TYPE_CONTINUOUS)
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 --自訂事件
--Category 效果分类（表示这个效果将要发生什么事，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_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 =-2147483648
HALF_DAMAGE =-2147483647
--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 --请选择要操作的卡
HINTMSG_FIELD_FIRST =575 --请选择场上的卡（按取消可选择其他区域的卡）
--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 --N/A
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_CHAIN =0x40000000 --同一连锁中使用次数
EFFECT_COUNT_CODE_SINGLE =0x1 --同一张卡的多个效果公共使用次数
--特殊选项
DUEL_TEST_MODE =0x01 --测试模式(目前暫無)
DUEL_ATTACK_FIRST_TURN =0x02 --第一回合可以攻击(用于残局)
DUEL_OLD_REPLAY =0x04 --旧录像
DUEL_OBSOLETE_RULING =0x08 --使用舊規則
DUEL_PSEUDO_SHUFFLE =0x10 --不洗牌
DUEL_TAG_MODE =0x20 --双打PP
DUEL_SIMPLE_AI =0x40 --AI(用于残局)
DUEL_RETURN_DECK_TOP =0x80 --回卡组洗切的卡放到卡组最上方（不洗牌模式下曾经的默认行为）
--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
--Special cards
CARD_MARINE_DOLPHIN =78734254 --海洋海豚(double name)
CARD_TWINKLE_MOSS =13857930 --光輝苔蘚(double name)
CARD_QUESTION =38723936 --谜题
--Special flag effect id
FLAG_ID_CHAINING =1
FLAG_ID_UNION =2
FLAG_ID_NO_NORMAL_DRAW =3
FLAG_ID_ALLURE_QUEEN =4
\ No newline at end of file
script/procedure.lua deleted 100644 → 0
View file @ 96be04a5
--Fusion check functions
Auxiliary.FCheckAdditional=nil
Auxiliary.FGoalCheckAdditional=nil
--Ritual check functions
Auxiliary.RCheckAdditional=nil
Auxiliary.RGCheckAdditional=nil
--Gemini Summon
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(Auxiliary.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
--Synchro Summon
function Auxiliary.Tuner(f,...)
local ext_params={...}
return function(target,syncard)
return target:IsTuner(syncard) 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
---Synchro monster, 1 tuner + min to max monsters
---@param c Card
---@param f1 function|nil
---@param f2 function|nil
---@param minc integer
---@param maxc? integer
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,minct,maxct)
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=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
if smat and smat:IsTuner(c) 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,minct,maxct)
return function(e,tp,eg,ep,ev,re,r,rp,chk,c,smat,mg,min,max)
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
local g=nil
if smat and smat:IsTuner(c) 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
---@param c Card
---@param f1 function|nil
---@param f2 function|nil
---@param f3 function|nil
---@param f4 function|nil
---@param minc integer
---@param maxc integer
---@param gc? function
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:IsFaceupEx() 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.GetSynchroMaterial(tp):Filter(Auxiliary.SynMaterialFilter,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,minct,maxct,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=minct
local maxc=maxct
if min then
local exct=0
if f2 then exct=exct+1 end
if f3 then exct=exct+1 end
if min-exct>minc then minc=min-exct end
if max-exct<maxc then maxc=max-exct end
if minc>maxc then return false end
end
if smat and not smat:IsCanBeSynchroMaterial(c) then return false end
local tp=c:GetControler()
local mg
local mgchk=false
if mg1 then
mg=mg1:Filter(Card.IsCanBeSynchroMaterial,nil,c)
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,minct,maxct,gc)
return function(e,tp,eg,ep,ev,re,r,rp,chk,c,smat,mg1,min,max)
local minc=minct
local maxc=maxct
if min then
local exct=0
if f2 then exct=exct+1 end
if f3 then exct=exct+1 end
if min-exct>minc then minc=min-exct end
if max-exct<maxc then maxc=max-exct end
if minc>maxc then return false end
end
::SynMixTargetSelectStart::
local g=Group.CreateGroup()
local mg
local mgchk=false
if mg1 then
mg=mg1:Filter(Card.IsCanBeSynchroMaterial,nil,c)
mgchk=true
else
mg=Auxiliary.GetSynMaterials(tp,c)
end
if smat~=nil then mg:AddCard(smat) end
local c1
local c2
local c3
local cancel=Duel.IsSummonCancelable()
Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_SMATERIAL)
c1=mg:Filter(Auxiliary.SynMixFilter1,nil,f1,f2,f3,f4,minc,maxc,c,mg,smat,gc,mgchk):SelectUnselect(g,tp,false,cancel,1,1)
if not c1 then return false end
g:AddCard(c1)
if f2 then
Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_SMATERIAL)
c2=mg:Filter(Auxiliary.SynMixFilter2,g,f2,f3,f4,minc,maxc,c,mg,smat,c1,gc,mgchk):SelectUnselect(g,tp,false,cancel,1,1)
if not c2 then return false end
if g:IsContains(c2) then goto SynMixTargetSelectStart end
g:AddCard(c2)
if f3 then
Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_SMATERIAL)
c3=mg:Filter(Auxiliary.SynMixFilter3,g,f3,f4,minc,maxc,c,mg,smat,c1,c2,gc,mgchk):SelectUnselect(g,tp,false,cancel,1,1)
if not c3 then return false end
if g:IsContains(c3) then goto SynMixTargetSelectStart end
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,c1,c2,c3)
else
mg2:Sub(g)
end
local cg=mg2:Filter(Auxiliary.SynMixCheckRecursive,g4,tp,g4,mg2,i,minc,maxc,c,g,smat,gc,mgchk)
if cg:GetCount()==0 then break end
local finish=Auxiliary.SynMixCheckGoal(tp,g4,minc,i,c,g,smat,gc,mgchk)
Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_SMATERIAL)
local c4=cg:SelectUnselect(g+g4,tp,finish,cancel,minc,maxc)
if not c4 then
if finish then break
else return false end
end
if g:IsContains(c4) or g4:IsContains(c4) then goto SynMixTargetSelectStart end
g4:AddCard(c4)
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,maxct,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)
or minc==0 and Auxiliary.SynMixFilter4(c,nil,1,1,syncard,mg,smat,c1,nil,nil,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)
or minc==0 and Auxiliary.SynMixFilter4(c,nil,1,1,syncard,mg,smat,c1,c2,nil,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,c1,c2,c3)
else
mg:Sub(sg)
end
return Auxiliary.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
-- the material is in hand and don't has extra synchro material effect itself
-- that mean some other tuner added it as material
function Auxiliary.SynMixHandFilter(c,tp,syncard)
if not c:IsLocation(LOCATION_HAND) then return false end
local le={c:IsHasEffect(EFFECT_EXTRA_SYNCHRO_MATERIAL,tp)}
for _,te in pairs(le) do
local tf=te:GetValue()
if Auxiliary.GetValueType(tf)=="function" then
if tf(te,syncard) then return false end
else
if tf~=0 then return false end
end
end
return true
end
function Auxiliary.SynMixHandCheck(g,tp,syncard)
local hg=g:Filter(Auxiliary.SynMixHandFilter,nil,tp,syncard)
local hct=hg:GetCount()
if hct>0 then
local found=false
for c in Auxiliary.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
return true
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
if not (mgchk or Auxiliary.SynMixHandCheck(g,tp,syncard)) then return false end
for c in Auxiliary.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
--Xyz Summon
function Auxiliary.XyzAlterFilter(c,alterf,xyzc,e,tp,alterop)
return alterf(c,e,tp,xyzc) and c:IsCanBeXyzMaterial(xyzc) and Duel.GetLocationCountFromEx(tp,tp,c,xyzc)>0
and Auxiliary.MustMaterialCheck(c,tp,EFFECT_MUST_BE_XMATERIAL) and (not alterop or alterop(e,tp,0,c))
end
---Xyz monster, lv k*n
---@param c Card
---@param f function|nil
---@param lv integer
---@param ct integer
---@param alterf? function
---@param alterdesc? string
---@param maxct? integer
---@param alterop? function
function Auxiliary.AddXyzProcedure(c,f,lv,ct,alterf,alterdesc,maxct,alterop)
if not maxct then maxct=ct end
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.XyzConditionAlter(f,lv,ct,maxct,alterf,alterdesc,alterop))
e1:SetTarget(Auxiliary.XyzTargetAlter(f,lv,ct,maxct,alterf,alterdesc,alterop))
e1:SetOperation(Auxiliary.XyzOperationAlter(f,lv,ct,maxct,alterf,alterdesc,alterop))
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,minct,maxct)
--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=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
return Duel.CheckXyzMaterial(c,f,lv,minc,maxc,og)
end
end
function Auxiliary.XyzTarget(f,lv,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 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,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()
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.XyzConditionAlter(f,lv,minct,maxct,alterf,alterdesc,alterop)
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,alterop) 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
return Duel.CheckXyzMaterial(c,f,lv,minc,maxc,og)
end
end
function Auxiliary.XyzTargetAlter(f,lv,minct,maxct,alterf,alterdesc,alterop)
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 altg=mg:Filter(Auxiliary.XyzAlterFilter,nil,alterf,c,e,tp,alterop)
local b1=Duel.CheckXyzMaterial(c,f,lv,minc,maxc,og)
local b2=(not min or min<=1) and #altg>0
local g=nil
local cancel=Duel.IsSummonCancelable()
if b2 and (not b1 or Duel.SelectYesNo(tp,alterdesc)) then
e:SetLabel(1)
Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_XMATERIAL)
local tc=altg:SelectUnselect(nil,tp,false,cancel,1,1)
if tc then
g=Group.FromCards(tc)
if alterop then alterop(e,tp,1,tc) end
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.XyzOperationAlter(f,lv,minct,maxct,alterf,alterdesc,alterop)
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 monster, any condition
---@param c Card
---@param f function|nil
---@param gf function|nil
---@param minc integer
---@param maxc integer
---@param alterf? function
---@param alterdesc? string
---@param alterop? function
function Auxiliary.AddXyzProcedureLevelFree(c,f,gf,minc,maxc,alterf,alterdesc,alterop)
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.XyzLevelFreeConditionAlter(f,gf,minc,maxc,alterf,alterdesc,alterop))
e1:SetTarget(Auxiliary.XyzLevelFreeTargetAlter(f,gf,minc,maxc,alterf,alterdesc,alterop))
e1:SetOperation(Auxiliary.XyzLevelFreeOperationAlter(f,gf,minc,maxc,alterf,alterdesc,alterop))
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 (not c:IsOnField() or 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=Duel.GetMustMaterial(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=Duel.GetMustMaterial(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.XyzLevelFreeConditionAlter(f,gf,minct,maxct,alterf,alterdesc,alterop)
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,alterop)
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=Duel.GetMustMaterial(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.XyzLevelFreeTargetAlter(f,gf,minct,maxct,alterf,alterdesc,alterop)
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=Duel.GetMustMaterial(tp,EFFECT_MUST_BE_XMATERIAL)
local altg=mg:Filter(Auxiliary.XyzAlterFilter,nil,alterf,c,e,tp,alterop)
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 #altg>0
local g=nil
local cancel=Duel.IsSummonCancelable()
if b2 and (not b1 or Duel.SelectYesNo(tp,alterdesc)) then
e:SetLabel(1)
Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_XMATERIAL)
local tc=altg:SelectUnselect(nil,tp,false,cancel,1,1)
if tc then
g=Group.FromCards(tc)
if alterop then alterop(e,tp,1,tc) end
end
else
e:SetLabel(0)
Duel.SetSelectedCard(sg)
Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_XMATERIAL)
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.XyzLevelFreeOperationAlter(f,gf,minct,maxct,alterf,alterdesc,alterop)
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
--Fusion Summon
---Fusion monster, mixed materials (fixed count)
---@param fcard Card
---@param sub boolean Can be fusion summoned with substitute material
---@param insf boolean Can be fusion summoned with no material (Instant Fusion)
---@param ... number|function|table
function Auxiliary.AddFusionProcMix(fcard,sub,insf,...)
if fcard: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,subm,mg,sg) return val[i](c,fc,subm,mg,sg) and not c:IsHasEffect(6205579) end
elseif type(val[i])=='table' then
fun[i]=function(c,fc,subm,mg,sg)
for _,fcode in ipairs(val[i]) do
if type(fcode)=='function' then
if fcode(c,fc,subm,mg,sg) and not c:IsHasEffect(6205579) then return true end
elseif type(fcode)=='number' then
if c:IsFusionCode(fcode) or (subm and c:CheckFusionSubstitute(fc)) then return true end
end
end
return false
end
for _,fcode in ipairs(val[i]) do
if type(fcode)=='number' then mat[fcode]=true end
end
elseif type(val[i])=='number' then
fun[i]=function(c,fc,subm) return c:IsFusionCode(val[i]) or (subm and c:CheckFusionSubstitute(fc)) end
mat[val[i]]=true
end
end
local mt=getmetatable(fcard)
if mt.material==nil then
mt.material=mat
end
if mt.material_count==nil then
mt.material_count={#fun,#fun}
end
for index,_ in pairs(mat) do
Auxiliary.AddCodeList(fcard,index)
end
local e1=Effect.CreateEffect(fcard)
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)))
fcard: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, can use substitute (Hex-Sealed Fusion)
--chkf&0x200: Not fusion summon, can't use substitute ("Contact Fusion", Neos 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 hexsealed=chkfnf&0x100>0
local notfusion=chkfnf&0x200>0
local sub2=(sub or hexsealed) and not notfusion
local mg=g:Filter(Auxiliary.FConditionFilterMix,c,c,sub2,notfusion,table.unpack(funs))
if gc then
if not mg:IsContains(gc) then return false end
Duel.SetSelectedCard(gc)
end
return mg:CheckSubGroup(Auxiliary.FCheckMixGoal,#funs,#funs,tp,c,sub2,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 hexsealed=chkfnf&0x100>0
local notfusion=chkfnf&0x200>0
local sub2=(sub or hexsealed) and not notfusion
local cancel=notfusion and Duel.GetCurrentChain()==0
local mg=eg:Filter(Auxiliary.FConditionFilterMix,c,c,sub2,notfusion,table.unpack(funs))
if gc then Duel.SetSelectedCard(gc) end
Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_FMATERIAL)
local sg=mg:SelectSubGroup(tp,Auxiliary.FCheckMixGoal,cancel,#funs,#funs,tp,c,sub2,chkfnf,table.unpack(funs))
if sg then
Duel.SetFusionMaterial(sg)
else
Duel.SetFusionMaterial(Group.CreateGroup())
end
end
end
function Auxiliary.FConditionFilterMix(c,fc,sub,notfusion,...)
local check_type=notfusion and SUMMON_TYPE_SPECIAL or SUMMON_TYPE_FUSION
if not c:IsCanBeFusionMaterial(fc,check_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)
function Auxiliary.FCheckMixGoal(sg,tp,fc,sub,chkfnf,...)
local chkf=chkfnf&0xff
local not_fusion=chkfnf&(0x100|0x200)>0
if not not_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))
and (not Auxiliary.FGoalCheckAdditional or Auxiliary.FGoalCheckAdditional(tp,sg,fc))
end
---Fusion monster, mixed material * minc to maxc + material + ...
---@param fcard Card
---@param sub boolean Can be fusion summoned with substitute material
---@param insf boolean Can be fusion summoned with no material (Instant Fusion)
---@param fun1 number|function|table
---@param minc integer
---@param maxc integer
---@param ... number|function|table
function Auxiliary.AddFusionProcMixRep(fcard,sub,insf,fun1,minc,maxc,...)
if fcard: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,subm) return val[i](c,fc,subm) and not c:IsHasEffect(6205579) end
elseif type(val[i])=='table' then
fun[i]=function(c,fc,subm)
for _,fcode in ipairs(val[i]) do
if type(fcode)=='function' then
if fcode(c,fc,subm) and not c:IsHasEffect(6205579) then return true end
elseif type(fcode)=='number' then
if c:IsFusionCode(fcode) or (subm and c:CheckFusionSubstitute(fc)) then return true end
end
end
return false
end
for _,fcode in ipairs(val[i]) do
if type(fcode)=='number' then mat[fcode]=true end
end
elseif type(val[i])=='number' then
fun[i]=function(c,fc,subm) return c:IsFusionCode(val[i]) or (subm and c:CheckFusionSubstitute(fc)) end
mat[val[i]]=true
end
end
local mt=getmetatable(fcard)
if mt.material==nil then
mt.material=mat
end
if mt.material_count==nil then
mt.material_count={#fun+minc-1,#fun+maxc-1}
end
for index,_ in pairs(mat) do
Auxiliary.AddCodeList(fcard,index)
end
local e1=Effect.CreateEffect(fcard)
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)))
fcard: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 hexsealed=chkfnf&0x100>0
local notfusion=chkfnf&0x200>0
local sub2=(sub or hexsealed) and not notfusion
local mg=g:Filter(Auxiliary.FConditionFilterMix,c,c,sub2,notfusion,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,sub2,chkfnf,fun1,minc,maxc,table.unpack(funs))
end
local sg=Group.CreateGroup()
return mg:IsExists(Auxiliary.FSelectMixRep,1,nil,tp,mg,sg,c,sub2,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 hexsealed=chkfnf&0x100>0
local notfusion=chkfnf&0x200>0
local sub2=(sub or hexsealed) and not notfusion
local cancel=notfusion and Duel.GetCurrentChain()==0
local mg=eg:Filter(Auxiliary.FConditionFilterMix,c,c,sub2,notfusion,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,sub2,chkfnf,fun1,minc,maxc,table.unpack(funs))
if cg:GetCount()==0 then break end
local finish=Auxiliary.FCheckMixRepGoal(tp,sg,c,sub2,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,cancel,minc+#funs,maxc+#funs)
if not tc then
if not finish then sg:Clear() end
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)
local ct2=sg:FilterCount(fun1,g,fc,false)
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) then
g:AddCard(c)
sub=sub and fun2(c,fc,false)
local res=Auxiliary.FCheckMixRep(sg,g,fc,sub,chkf,fun1,minc,maxc,...)
g:RemoveCard(c)
return res
end
return false
end
function Auxiliary.FCheckMixRepGoalCheck(tp,sg,fc,chkfnf)
local not_fusion=chkfnf&(0x100|0x200)>0
if not not_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 Auxiliary.FGoalCheckAdditional and not Auxiliary.FGoalCheckAdditional(tp,sg,fc) then return false end
return true
end
function Auxiliary.FCheckMixRepGoal(tp,sg,fc,sub,chkfnf,fun1,minc,maxc,...)
local chkf=chkfnf&0xff
if sg:GetCount()<minc+#{...} or sg:GetCount()>maxc+#{...} then return false end
if not (chkf==PLAYER_NONE or Duel.GetLocationCountFromEx(tp,tp,sg,fc)>0) then return false end
if Auxiliary.FCheckAdditional and not Auxiliary.FCheckAdditional(tp,sg,fc) then return false end
if not Auxiliary.FCheckMixRepGoalCheck(tp,sg,fc,chkfnf) then return false end
local g=Group.CreateGroup()
return Auxiliary.FCheckMixRep(sg,g,fc,sub,chkf,fun1,minc,maxc,...)
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) then
g:AddCard(c)
local subf=sub and f(c,fc,false)
local t={...}
table.remove(t,i)
local res=cond(tp,mg,sg,g,fc,subf,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) then
g:AddCard(c)
local subf1=sub and fun1(c,fc,false)
local res=cond(tp,mg,sg,g,fc,subf1,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 and Auxiliary.FCheckMixRepGoalCheck(tp,g,fc,chkfnf) 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) then
g:AddCard(c)
local subf2=sub and fun2(c,fc,false)
local res=Auxiliary.FCheckSelectMixRep(tp,mg,sg,g,fc,subf2,chkf,fun1,minc,maxc,...)
g:RemoveCard(c)
return res
end
elseif maxc>0 and fun1(c,fc,sub) then
g:AddCard(c)
local subf1=sub and fun1(c,fc,false)
local res=Auxiliary.FCheckSelectMixRep(tp,mg,sg,g,fc,subf1,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
---@param c Card
---@param code1 integer
---@param code2 integer
---@param sub boolean
---@param insf boolean
function Auxiliary.AddFusionProcCode2(c,code1,code2,sub,insf)
Auxiliary.AddFusionProcMix(c,sub,insf,code1,code2)
end
---Fusion monster, name + name + name
---@param c Card
---@param code1 integer
---@param code2 integer
---@param code3 integer
---@param sub boolean
---@param insf boolean
function Auxiliary.AddFusionProcCode3(c,code1,code2,code3,sub,insf)
Auxiliary.AddFusionProcMix(c,sub,insf,code1,code2,code3)
end
---Fusion monster, name + name + name + name
---@param c Card
---@param code1 integer
---@param code2 integer
---@param code3 integer
---@param code4 integer
---@param sub boolean
---@param insf boolean
function Auxiliary.AddFusionProcCode4(c,code1,code2,code3,code4,sub,insf)
Auxiliary.AddFusionProcMix(c,sub,insf,code1,code2,code3,code4)
end
---Fusion monster, name * n
---@param c Card
---@param code1 integer
---@param cc integer
---@param sub boolean
---@param insf boolean
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
---@param c Card
---@param code1 integer|table
---@param minc integer
---@param maxc integer
---@param sub boolean
---@param insf boolean
function Auxiliary.AddFusionProcCodeRep2(c,code1,minc,maxc,sub,insf)
Auxiliary.AddFusionProcMixRep(c,sub,insf,code1,minc,maxc)
end
---Fusion monster, name + condition * n
---@param c Card
---@param code1 integer|table
---@param f function|table
---@param cc integer
---@param sub boolean
---@param insf boolean
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
---@param c Card
---@param f1 function|table
---@param f2 function|table
---@param insf boolean
function Auxiliary.AddFusionProcFun2(c,f1,f2,insf)
Auxiliary.AddFusionProcMix(c,false,insf,f1,f2)
end
---Fusion monster, condition * n
---@param c Card
---@param f function|table
---@param cc integer
---@param insf boolean
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
---@param c Card
---@param f function|table
---@param minc integer
---@param maxc integer
---@param insf boolean
function Auxiliary.AddFusionProcFunRep2(c,f,minc,maxc,insf)
Auxiliary.AddFusionProcMixRep(c,false,insf,f,minc,maxc)
end
---Fusion monster, condition1 + condition2 * n
---@param c Card
---@param f1 function|table
---@param f2 function|table
---@param cc integer
---@param insf boolean
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
---@param c Card
---@param code1 integer|table
---@param f function|table
---@param minc integer
---@param maxc integer
---@param sub boolean
---@param insf boolean
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
---@param c Card
---@param code1 integer|table
---@param code2 integer|table
---@param f function|table
---@param minc integer
---@param maxc integer
---@param sub boolean
---@param insf boolean
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
---@param c Card
---@param attr integer
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,fe)
return c:IsFaceup() and not c:IsImmuneToEffect(fe) 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)
or Auxiliary.FGoalCheckAdditional and not Auxiliary.FGoalCheckAdditional(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
local fe=fc:IsHasEffect(81788994)
exg=Duel.GetMatchingGroup(Auxiliary.FShaddollExFilter,tp,0,LOCATION_MZONE,mg,c,attr,fe)
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
local fe=fc:IsHasEffect(81788994)
exg=Duel.GetMatchingGroup(Auxiliary.FShaddollExFilter,tp,0,LOCATION_MZONE,mg,c,attr,fe)
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,Auxiliary.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
--Fusion Summon Effect
function Auxiliary.FMaterialFilter(c,e,tp)
return c:IsCanBeFusionMaterial()
end
function Auxiliary.FMaterialRemoveFilter(c,e,tp)
return c:IsAbleToRemove()
end
function Auxiliary.FMaterialToGraveFilter(c,e,tp)
return c:IsAbleToGrave()
end
function Auxiliary.FMaterialToGrave(mat)
Duel.SendtoGrave(mat,REASON_EFFECT+REASON_MATERIAL+REASON_FUSION)
end
function Auxiliary.FMaterialRemove(mat)
Duel.Remove(mat,POS_FACEUP,REASON_EFFECT+REASON_MATERIAL+REASON_FUSION)
end
function Auxiliary.FMaterialToDeck(mat)
Duel.SendtoDeck(mat,nil,2,REASON_EFFECT+REASON_MATERIAL+REASON_FUSION)
end
---Add Fusion Summon with table `params`.
---@param c Card
---@param params table
---@return Effect
function Auxiliary.AddFusionEffectProcUltimate(c,params)
--filter,mat_location,mat_filter,mat_operation,gc,reg,get_extra_mat,include_this_card
--grave_filter,grave_operation,removed_filter,removed_operation,deck_filter,deck_operation,extra_filter,extra_operation
--get_fcheck,get_gcheck,get_fgoalcheck,foperation,fcheck,gcheck,fgoalcheck,spsummon_nocheck
--category,opinfo,mat_operation2,foperation2
if params.mat_location==nil then params.mat_location=LOCATION_HAND+LOCATION_MZONE end
if params.mat_filter==nil then params.mat_filter=Auxiliary.FMaterialFilter end
if params.mat_operation==nil then params.mat_operation=Auxiliary.FMaterialToGrave end
if params.grave_filter==nil then params.grave_filter=Auxiliary.FMaterialRemoveFilter end
if params.grave_operation==nil then params.grave_operation=Auxiliary.FMaterialRemove end
if params.removed_operation==nil then params.removed_operation=params.mat_operation end
if params.deck_filter==nil then params.deck_filter=Auxiliary.FMaterialToGraveFilter end
if params.deck_operation==nil then params.deck_operation=params.mat_operation end
if params.extra_filter==nil then params.extra_filter=Auxiliary.FMaterialToGraveFilter end
if params.extra_operation==nil then params.extra_operation=params.mat_operation end
if params.spsummon_nocheck==nil then params.spsummon_nocheck=false end
if params.category==nil then params.category=0 end
local e1=Effect.CreateEffect(c)
e1:SetCategory(CATEGORY_SPECIAL_SUMMON|CATEGORY_FUSION_SUMMON|params.category)
e1:SetTarget(Auxiliary.FusionEffectUltimateTarget(params))
e1:SetOperation(Auxiliary.FusionEffectUltimateOperation(params))
if params.reg~=false then
e1:SetType(EFFECT_TYPE_ACTIVATE)
e1:SetCode(EVENT_FREE_CHAIN)
c:RegisterEffect(e1)
end
return e1
end
Auxiliary.FMaterialBase=nil
function Auxiliary.FusionEffectUltimateFilter(c,e,tp,mg,chkf,params)
--mg,gc,f1,f2,get_fcheck,spsummon_nocheck
if not c:IsType(TYPE_FUSION) then return false end
if not c:IsCanBeSpecialSummoned(e,SUMMON_TYPE_FUSION,tp,params.spsummon_nocheck,false) then return false end
if params.filter1 and not params.filter1(c) then return false end
if params.filter2 and not params.filter2(c) then return false end
if params.get_fcheck then Auxiliary.FCheckAdditional=params.get_fcheck(c,e,tp) end
local res=c:CheckFusionMaterial(mg,params.gc,chkf)
if params.get_fcheck then Auxiliary.FCheckAdditional=nil end
return res
end
function Auxiliary.FusionEffectUltimateMatFilter(c,e,tp,f)
return not c:IsImmuneToEffect(e) and not f or f(c,e,tp)
end
function Auxiliary.FusionEffectUltimateMatLocFilter(c,e,tp,loc,f)
return not c:IsLocation(loc) or (not f or f(c,e,tp))
end
function Auxiliary.FusionEffectUltimateTarget(params)
return function(e,tp,eg,ep,ev,re,r,rp,chk)
if chk==0 then
local chkf=tp
local gc
if params.include_this_card then
gc=e:GetHandler()
end
local mgall,mgbase=Duel.GetFusionMaterial(tp,params.mat_location)
local mgex=Group.CreateGroup()
if params.get_extra_mat then mgex=params.get_extra_mat(e,tp,eg,ep,ev,re,r,rp) end
mgall:Merge(mgex)
mgbase:Merge(mgex)
local mg1=mgall:Filter(Auxiliary.FusionEffectUltimateMatFilter,nil,e,tp,params.mat_filter)
:Filter(Auxiliary.FusionEffectUltimateMatLocFilter,nil,e,tp,LOCATION_GRAVE,params.grave_filter)
:Filter(Auxiliary.FusionEffectUltimateMatLocFilter,nil,e,tp,LOCATION_REMOVED,params.removed_filter)
:Filter(Auxiliary.FusionEffectUltimateMatLocFilter,nil,e,tp,LOCATION_DECK,params.deck_filter)
:Filter(Auxiliary.FusionEffectUltimateMatLocFilter,nil,e,tp,LOCATION_EXTRA,params.extra_filter)
if gc then mg1:AddCard(gc) end
Auxiliary.FMaterialBase=mgbase:Filter(Auxiliary.IsInGroup,nil,mg1)
Auxiliary.FCheckAdditional=params.fcheck
Auxiliary.GCheckAdditional=params.gcheck
if params.get_gcheck then
Auxiliary.GCheckAdditional=params.get_gcheck(e,tp,nil)
end
Auxiliary.FGoalCheckAdditional=params.fgoalcheck
local res=Duel.IsExistingMatchingCard(Auxiliary.FusionEffectUltimateFilter,tp,LOCATION_EXTRA,0,1,nil,e,tp,mg1,chkf,{
filter1=params.filter,
gc=gc,
get_fcheck=params.get_fcheck,
spsummon_nocheck=params.spsummon_nocheck
})
Auxiliary.FCheckAdditional=nil
Auxiliary.GCheckAdditional=nil
if not res then
local ce=Duel.GetChainMaterial(tp)
if ce~=nil then
local fgroup=ce:GetTarget()
local mg2=fgroup(ce,e,tp):Filter(Auxiliary.FusionEffectUltimateMatFilter,nil,e,tp,params.mat_filter)
local mf=ce:GetValue()
res=Duel.IsExistingMatchingCard(Auxiliary.FusionEffectUltimateFilter,tp,LOCATION_EXTRA,0,1,nil,e,tp,mg2,chkf,{
filter1=params.filter,
filter2=mf,
gc=gc,
get_fcheck=params.get_fcheck
})
end
end
Auxiliary.FMaterialBase=nil
Auxiliary.FGoalCheckAdditional=nil
return res
end
Duel.SetOperationInfo(0,CATEGORY_SPECIAL_SUMMON,nil,1,tp,LOCATION_EXTRA)
if params.mat_operation==Auxiliary.FMaterialRemove
or params.grave_operation==Auxiliary.FMaterialRemove
or params.deck_operation==Auxiliary.FMaterialRemove then
Duel.SetOperationInfo(0,CATEGORY_REMOVE,nil,1,tp,params.mat_location)
e:SetCategory(e:GetCategory()|CATEGORY_REMOVE)
end
if params.mat_operation==Auxiliary.FMaterialToDeck
or params.grave_operation==Auxiliary.FMaterialToDeck
or params.deck_operation==Auxiliary.FMaterialToDeck then
Duel.SetOperationInfo(0,CATEGORY_TODECK,nil,1,tp,params.mat_location)
e:SetCategory(e:GetCategory()|CATEGORY_TODECK)
end
if params.mat_location&LOCATION_DECK>0 then
e:SetCategory(e:GetCategory()|CATEGORY_DECKDES)
end
if params.opinfo then
params.opinfo(e,tp)
end
end
end
---
---@param params table
---@return function
function Auxiliary.FusionEffectUltimateOperation(params)
return function(e,tp,eg,ep,ev,re,r,rp)
local chkf=tp
local gc
if params.include_this_card then
gc=e:GetHandler()
if gc:IsOnField() and gc:IsFacedown() or not gc:IsRelateToEffect(e) or gc:IsImmuneToEffect(e) then return end
end
local mgall,mgbase=Duel.GetFusionMaterial(tp,params.mat_location)
local mgex=Group.CreateGroup()
if params.get_extra_mat then mgex=params.get_extra_mat(e,tp,eg,ep,ev,re,r,rp) end
mgall:Merge(mgex)
mgbase:Merge(mgex)
local mg1=mgall:Filter(Auxiliary.FusionEffectUltimateMatFilter,nil,e,tp,params.mat_filter)
:Filter(Auxiliary.FusionEffectUltimateMatLocFilter,nil,e,tp,LOCATION_GRAVE,params.grave_filter)
:Filter(Auxiliary.FusionEffectUltimateMatLocFilter,nil,e,tp,LOCATION_REMOVED,params.removed_filter)
:Filter(Auxiliary.FusionEffectUltimateMatLocFilter,nil,e,tp,LOCATION_DECK,params.deck_filter)
:Filter(Auxiliary.FusionEffectUltimateMatLocFilter,nil,e,tp,LOCATION_EXTRA,params.extra_filter)
if gc then mg1:AddCard(gc) end
Auxiliary.FMaterialBase=mgbase:Filter(Auxiliary.IsInGroup,nil,mg1)
Auxiliary.FCheckAdditional=params.fcheck
Auxiliary.GCheckAdditional=params.gcheck
if params.get_gcheck then
Auxiliary.GCheckAdditional=params.get_gcheck(e,tp,nil)
end
Auxiliary.FGoalCheckAdditional=params.fgoalcheck
local sg1=Duel.GetMatchingGroup(Auxiliary.FusionEffectUltimateFilter,tp,LOCATION_EXTRA,0,nil,e,tp,mg1,chkf,{
filter1=params.filter,
gc=gc,
get_fcheck=params.get_fcheck,
spsummon_nocheck=params.spsummon_nocheck
})
Auxiliary.FCheckAdditional=nil
Auxiliary.GCheckAdditional=nil
local mg2=nil
local sg2=nil
local ce=Duel.GetChainMaterial(tp)
if ce then
local fgroup=ce:GetTarget()
mg2=fgroup(ce,e,tp):Filter(Auxiliary.FusionEffectUltimateMatFilter,nil,e,tp,params.mat_filter)
local mf=ce:GetValue()
sg2=Duel.GetMatchingGroup(Auxiliary.FusionEffectUltimateFilter,tp,LOCATION_EXTRA,0,nil,e,tp,mg2,chkf,{
filter1=params.filter,
filter2=mf,
gc=gc,
get_fcheck=params.get_fcheck
})
end
if sg1:GetCount()>0 or (sg2~=nil and sg2:GetCount()>0) then
local sg=sg1:Clone()
if sg2 then sg:Merge(sg2) end
Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_SPSUMMON)
local tg=sg:Select(tp,1,1,nil)
local tc=tg:GetFirst()
Auxiliary.FCheckAdditional=params.fcheck
Auxiliary.GCheckAdditional=params.gcheck
if params.get_gcheck then
Auxiliary.GCheckAdditional=params.get_gcheck(e,tp,tc)
end
if params.get_fcheck then Auxiliary.FCheckAdditional=params.get_fcheck(tc,e,tp) end
if sg1:IsContains(tc) and (sg2==nil or not sg2:IsContains(tc) or ce and not Duel.SelectYesNo(tp,ce:GetDescription())) then
local mat1=Duel.SelectFusionMaterial(tp,tc,mg1,gc,chkf)
tc:SetMaterial(mat1)
if params.mat_operation2 then params.mat_operation2(e,tp,mat1) end
if params.grave_operation~=params.mat_operation then
local mat=mat1:Filter(Card.IsLocation,nil,LOCATION_GRAVE)
mat1:Sub(mat)
params.grave_operation(mat)
end
if params.removed_operation~=params.mat_operation then
local mat=mat1:Filter(Card.IsLocation,nil,LOCATION_REMOVED)
mat1:Sub(mat)
params.removed_operation(mat)
end
if params.deck_operation~=params.mat_operation then
local mat=mat1:Filter(Card.IsLocation,nil,LOCATION_DECK)
mat1:Sub(mat)
params.deck_operation(mat)
end
if params.extra_operation~=params.mat_operation then
local mat=mat1:Filter(Card.IsLocation,nil,LOCATION_EXTRA)
mat1:Sub(mat)
params.extra_operation(mat)
end
params.mat_operation(mat1)
Duel.BreakEffect()
Duel.SpecialSummon(tc,SUMMON_TYPE_FUSION,tp,tp,params.spsummon_nocheck,false,POS_FACEUP)
elseif ce and mg2 then
local mat2=Duel.SelectFusionMaterial(tp,tc,mg2,gc,chkf)
local fop=ce:GetOperation()
fop(ce,e,tp,tc,mat2)
end
tc:CompleteProcedure()
if params.foperation then params.foperation(e,tp,tc) end
end
Auxiliary.FCheckAdditional=nil
Auxiliary.GCheckAdditional=nil
Auxiliary.FGoalCheckAdditional=nil
Auxiliary.FMaterialBase=nil
if params.foperation2 then params.foperation2(e,tp,eg,ep,ev,re,r,rp) end
end
end
function Auxiliary.AddFusionEffectProc(c,filter,mat_location,mat_filter,mat_operation,params)
if params==nil then params={} end
params.filter=filter
params.mat_location=mat_location
params.mat_filter=mat_filter
params.mat_operation=mat_operation
return Auxiliary.AddFusionEffectProcUltimate(c,params)
end
--Contact Fusion
function Auxiliary.AddContactFusionProcedure(c,filter,self_location,opponent_location,mat_operation,...)
self_location=self_location or 0
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:SetTarget(Auxiliary.ContactFusionTarget(filter,self_location,opponent_location))
e2:SetOperation(Auxiliary.ContactFusionOperation(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.ContactFusionTarget(filter,self_location,opponent_location)
return function(e,tp,eg,ep,ev,re,r,rp,chk,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)
if #g>0 then
g:KeepAlive()
e:SetLabelObject(g)
return true
else return false end
end
end
function Auxiliary.ContactFusionOperation(mat_operation,operation_params)
return function(e,tp,eg,ep,ev,re,r,rp,c)
local g=e:GetLabelObject()
c:SetMaterial(g)
mat_operation(g,table.unpack(operation_params))
g:DeleteGroup()
end
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
local hg=g:Filter(Card.IsLocation,nil,LOCATION_GRAVE+LOCATION_REMOVED)
if hg:GetCount()>0 then
Duel.HintSelection(hg)
end
Duel.SendtoDeck(g,nil,SEQ_DECKSHUFFLE,REASON_COST)
end
end
--Ritual Summon
function Auxiliary.AddRitualProcUltimate(c,filter,level_function,greater_or_equal,summon_location,grave_filter,mat_filter,pause,extra_operation,extra_target)
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,extra_target))
e1:SetOperation(Auxiliary.RitualUltimateOperation(filter,level_function,greater_or_equal,summon_location,grave_filter,mat_filter,extra_operation))
if not pause then
c:RegisterEffect(e1)
end
return e1
end
---@param g Group
---@param c Card
---@param lv integer
---@return boolean
function Auxiliary.RitualCheckGreater(g,c,lv)
Duel.SetSelectedCard(g)
return g:CheckWithSumGreater(Card.GetRitualLevel,lv,c)
end
---@param g Group
---@param c Card
---@param lv integer
---@return boolean
function Auxiliary.RitualCheckEqual(g,c,lv)
return g:CheckWithSumEqual(Card.GetRitualLevel,lv,#g,#g,c)
end
---@param g Group
---@param tp integer
---@param c Card
---@param lv integer
---@param greater_or_equal string
---|"'Greater'"
---|"'Equal'"
---@return boolean
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
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,extra_target)
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
if extra_target then
extra_target(e,tp,eg,ep,ev,re,r,rp)
end
end
end
function Auxiliary.RitualUltimateOperation(filter,level_function,greater_or_equal,summon_location,grave_filter,mat_filter,extra_operation)
return function(e,tp,eg,ep,ev,re,r,rp)
::RitualUltimateSelectStart::
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()
local mat
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)
mat=mg:SelectSubGroup(tp,Auxiliary.RitualCheck,true,1,lv,tp,tc,lv,greater_or_equal)
Auxiliary.GCheckAdditional=nil
if not mat then goto RitualUltimateSelectStart end
tc:SetMaterial(mat)
Duel.ReleaseRitualMaterial(mat)
Duel.BreakEffect()
Duel.SpecialSummon(tc,SUMMON_TYPE_RITUAL,tp,tp,false,true,POS_FACEUP)
tc:CompleteProcedure()
end
if extra_operation then
extra_operation(e,tp,eg,ep,ev,re,r,rp,tc,mat)
end
end
end
--Ritual Summon, geq fixed lv
function Auxiliary.AddRitualProcGreater(c,filter,summon_location,grave_filter,mat_filter,pause,extra_operation,extra_target)
return Auxiliary.AddRitualProcUltimate(c,filter,Card.GetOriginalLevel,"Greater",summon_location,grave_filter,mat_filter,pause,extra_operation,extra_target)
end
function Auxiliary.AddRitualProcGreaterCode(c,code1,summon_location,grave_filter,mat_filter,pause,extra_operation,extra_target)
Auxiliary.AddCodeList(c,code1)
return Auxiliary.AddRitualProcGreater(c,Auxiliary.FilterBoolFunction(Card.IsCode,code1),summon_location,grave_filter,mat_filter,pause,extra_operation,extra_target)
end
--Ritual Summon, equal to fixed lv
function Auxiliary.AddRitualProcEqual(c,filter,summon_location,grave_filter,mat_filter,pause,extra_operation,extra_target)
return Auxiliary.AddRitualProcUltimate(c,filter,Card.GetOriginalLevel,"Equal",summon_location,grave_filter,mat_filter,pause,extra_operation,extra_target)
end
function Auxiliary.AddRitualProcEqualCode(c,code1,summon_location,grave_filter,mat_filter,pause,extra_operation,extra_target)
Auxiliary.AddCodeList(c,code1)
return Auxiliary.AddRitualProcEqual(c,Auxiliary.FilterBoolFunction(Card.IsCode,code1),summon_location,grave_filter,mat_filter,pause,extra_operation,extra_target)
end
--Ritual Summon, equal to monster lv
function Auxiliary.AddRitualProcEqual2(c,filter,summon_location,grave_filter,mat_filter,pause,extra_operation,extra_target)
return Auxiliary.AddRitualProcUltimate(c,filter,Card.GetLevel,"Equal",summon_location,grave_filter,mat_filter,pause,extra_operation,extra_target)
end
function Auxiliary.AddRitualProcEqual2Code(c,code1,summon_location,grave_filter,mat_filter,pause,extra_operation,extra_target)
Auxiliary.AddCodeList(c,code1)
return Auxiliary.AddRitualProcEqual2(c,Auxiliary.FilterBoolFunction(Card.IsCode,code1),summon_location,grave_filter,mat_filter,pause,extra_operation,extra_target)
end
function Auxiliary.AddRitualProcEqual2Code2(c,code1,code2,summon_location,grave_filter,mat_filter,pause,extra_operation,extra_target)
Auxiliary.AddCodeList(c,code1,code2)
return Auxiliary.AddRitualProcEqual2(c,Auxiliary.FilterBoolFunction(Card.IsCode,code1,code2),summon_location,grave_filter,mat_filter,pause,extra_operation,extra_target)
end
--Ritual Summon, geq monster lv
function Auxiliary.AddRitualProcGreater2(c,filter,summon_location,grave_filter,mat_filter,pause,extra_operation,extra_target)
return Auxiliary.AddRitualProcUltimate(c,filter,Card.GetLevel,"Greater",summon_location,grave_filter,mat_filter,pause,extra_operation,extra_target)
end
function Auxiliary.AddRitualProcGreater2Code(c,code1,summon_location,grave_filter,mat_filter,pause,extra_operation,extra_target)
Auxiliary.AddCodeList(c,code1)
return Auxiliary.AddRitualProcGreater2(c,Auxiliary.FilterBoolFunction(Card.IsCode,code1),summon_location,grave_filter,mat_filter,pause,extra_operation,extra_target)
end
function Auxiliary.AddRitualProcGreater2Code2(c,code1,code2,summon_location,grave_filter,mat_filter,pause,extra_operation,extra_target)
Auxiliary.AddCodeList(c,code1,code2)
return Auxiliary.AddRitualProcGreater2(c,Auxiliary.FilterBoolFunction(Card.IsCode,code1,code2),summon_location,grave_filter,mat_filter,pause,extra_operation,extra_target)
end
--Pendulum Summon
--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(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
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(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,Auxiliary.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:UseCountLimit(tp)
else
Auxiliary.PendulumChecklist=Auxiliary.PendulumChecklist|(0x1<<tp)
end
sg:Merge(g)
Duel.HintSelection(Group.FromCards(c))
Duel.HintSelection(Group.FromCards(rpz))
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
---@param c Card
---@param f function|nil
---@param min integer
---@param max? integer
---@param gf? function
---@return Effect
function Auxiliary.AddLinkProcedure(c,f,min,max,gf)
if max==nil then max=c:GetLink() end
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)
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)
return e1
end
function Auxiliary.LConditionFilter(c,f,lc,e)
return (c:IsFaceup() or not c:IsOnField() or e:IsHasProperty(EFFECT_FLAG_SET_AVAILABLE))
and c:IsCanBeLinkMaterial(lc) and (not f or f(c))
end
function Auxiliary.LExtraFilter(c,f,lc,tp)
if c:IsOnField() and c:IsFacedown() 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,e)
local mg=Duel.GetMatchingGroup(Auxiliary.LConditionFilter,tp,LOCATION_MZONE,0,nil,f,lc,e)
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(Auxiliary.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,lc,tp))
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 Auxiliary.Next(mg) do
local le={tc:IsHasEffect(EFFECT_EXTRA_LINK_MATERIAL,tp)}
for _,te in pairs(le) do
local sg=mg:Filter(Auxiliary.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,minct,maxct,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=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
local tp=c:GetControler()
local mg=nil
if og then
mg=og:Filter(Auxiliary.LConditionFilter,nil,f,c,e)
else
mg=Auxiliary.GetLinkMaterials(tp,f,c,e)
end
if lmat~=nil then
if not Auxiliary.LConditionFilter(lmat,f,c,e) then return false end
mg:AddCard(lmat)
end
local fg=Duel.GetMustMaterial(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,minct,maxct,gf)
return function(e,tp,eg,ep,ev,re,r,rp,chk,c,og,lmat,min,max)
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
local mg=nil
if og then
mg=og:Filter(Auxiliary.LConditionFilter,nil,f,c,e)
else
mg=Auxiliary.GetLinkMaterials(tp,f,c,e)
end
if lmat~=nil then
if not Auxiliary.LConditionFilter(lmat,f,c,e) then return false end
mg:AddCard(lmat)
end
local fg=Duel.GetMustMaterial(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,minct,maxct,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
--Must use X as material
function Auxiliary.MustMaterialCheck(v,tp,code)
local g=Duel.GetMustMaterial(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
return Duel.CheckMustMaterial(tp,v,code)
end
function Auxiliary.MustMaterialCounterFilter(c,g)
return not g:IsContains(c)
end
--Summon Condition
--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
--sp_summon condition for /Assault Mode
function Auxiliary.AssaultModeLimit(e,se,sp,st)
return st==SUMMON_TYPE_SPECIAL+SUMMON_VALUE_ASSAULT_MODE or se:GetHandler():IsCode(80280737)
end
--sp_summon condition for Masked HERO
function Auxiliary.MaskChangeLimit(e,se,sp,st)
return st==SUMMON_TYPE_SPECIAL+SUMMON_VALUE_MASK_CHANGE or se:GetHandler():IsCode(21143940)
end
--sp_summon condition for Evil HERO
function Auxiliary.DarkFusionLimit(e,se,sp,st)
return se:GetHandler():IsCode(94820406)
or st==SUMMON_VALUE_DARK_FUSION
or (Duel.IsPlayerAffectedByEffect(sp,72043279) and st&SUMMON_TYPE_FUSION==SUMMON_TYPE_FUSION)
end
--sp_summon condition for Fossil
function Auxiliary.FossilFusionLimit(e,se,sp,st)
return st==SUMMON_VALUE_FOSSIL_FUSION or se:GetHandler():IsCode(59419719)
or not e:GetHandler():IsLocation(LOCATION_EXTRA)
end
\ No newline at end of file
script/utility.lua deleted 100644 → 0
View file @ 96be04a5
Auxiliary={}
aux=Auxiliary
POS_FACEUP_DEFENCE=POS_FACEUP_DEFENSE
POS_FACEDOWN_DEFENCE=POS_FACEDOWN_DEFENSE
RACE_CYBERS=RACE_CYBERSE
NULL_VALUE=-10
function GetID()
local offset=self_code<100000000 and 1 or 100
return self_table,self_code,offset
end
--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)
local 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)
width=width or 1
local f,m=fieldargs(field,width)
return (r>>f)&m
end
function bit.replace(r,v,field,width)
width=width or 1
local f,m=fieldargs(field,width)
return (r&~(m<<f))|((v&m)<< f)
end
---Subgroup check function
---@param sg Group
---@param c Card|nil
---@param g Group
---@return boolean
Auxiliary.GCheckAdditional=function(sg,c,g) return true end
--the table of xyz number
Auxiliary.xyz_number={}
function Auxiliary.GetXyzNumber(v)
local id
if Auxiliary.GetValueType(v)=="Card" then id=v:GetCode() end
if Auxiliary.GetValueType(v)=="number" then id=v end
return Auxiliary.xyz_number[id]
end
--iterator for getting playerid of current turn player and the other player
function Auxiliary.TurnPlayers()
local i=0
return function()
i=i+1
if i==1 then return Duel.GetTurnPlayer() end
if i==2 then return 1-Duel.GetTurnPlayer() end
end
end
Auxiliary.idx_table=table.pack(1,2,3,4,5,6,7,8)
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
---Duel.SelectOption with option condition
---Return value starts from 1, different from Duel.SelectOption
---@param tp integer
---@param ... table {condition, option[, value]}
---@return integer
function Auxiliary.SelectFromOptions(tp,...)
local options={...}
local ops={}
local opvals={}
for i=1,#options do
if options[i][1] then
table.insert(ops,options[i][2])
table.insert(opvals,options[i][3] or i)
end
end
if #ops==0 then return nil end
local select=Duel.SelectOption(tp,table.unpack(ops))
return opvals[select+1]
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+0xd7e0000+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.EnableNeosReturn(c,operation,set_category)
--return
local e1=Effect.CreateEffect(c)
e1:SetDescription(1193)
e1:SetCategory(CATEGORY_TODECK)
e1:SetType(EFFECT_TYPE_FIELD+EFFECT_TYPE_TRIGGER_F)
e1:SetCode(EVENT_PHASE+PHASE_END)
e1:SetRange(LOCATION_MZONE)
e1:SetCountLimit(1)
e1:SetCondition(Auxiliary.NeosReturnConditionForced)
e1:SetTarget(Auxiliary.NeosReturnTargetForced(set_category))
e1:SetOperation(operation)
c:RegisterEffect(e1)
local e2=e1:Clone()
e2:SetType(EFFECT_TYPE_FIELD+EFFECT_TYPE_TRIGGER_O)
e2:SetCondition(Auxiliary.NeosReturnConditionOptional)
e2:SetTarget(Auxiliary.NeosReturnTargetOptional(set_category))
c:RegisterEffect(e2)
return e1,e2
end
function Auxiliary.NeosReturnConditionForced(e,tp,eg,ep,ev,re,r,rp)
return not e:GetHandler():IsHasEffect(42015635)
end
function Auxiliary.NeosReturnTargetForced(set_category)
return function(e,tp,eg,ep,ev,re,r,rp,chk)
if chk==0 then return true end
Duel.SetOperationInfo(0,CATEGORY_TODECK,e:GetHandler(),1,0,0)
if set_category then set_category(e,tp,eg,ep,ev,re,r,rp) end
end
end
function Auxiliary.NeosReturnConditionOptional(e,tp,eg,ep,ev,re,r,rp)
return e:GetHandler():IsHasEffect(42015635)
end
function Auxiliary.NeosReturnTargetOptional(set_category)
return function(e,tp,eg,ep,ev,re,r,rp,chk)
if chk==0 then return e:GetHandler():IsAbleToExtra() end
Duel.SetOperationInfo(0,CATEGORY_TODECK,e:GetHandler(),1,0,0)
if set_category then set_category(e,tp,eg,ep,ev,re,r,rp) end
end
end
function Auxiliary.IsUnionState(effect)
local c=effect:GetHandler()
return c:IsHasEffect(EFFECT_UNION_STATUS) and c:GetEquipTarget()
end
--set EFFECT_EQUIP_LIMIT after equipping
function Auxiliary.SetUnionState(c)
local eset={c:IsHasEffect(EFFECT_UNION_LIMIT)}
if #eset==0 then return end
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
--uc: the union monster to be equipped, tc: the target monster
function Auxiliary.CheckUnionEquip(uc,tc,exclude_modern_count)
local modern_count,old_count=tc:GetUnionCount()
if exclude_modern_count then modern_count=modern_count-exclude_modern_count end
if uc.old_union then return modern_count==0
else return old_count==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
---@param c Card
---@param filter function
function Auxiliary.EnableUnionAttribute(c,filter)
local equip_limit=Auxiliary.UnionEquipLimit(filter)
--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(Auxiliary.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(equip_limit)
c:RegisterEffect(e2)
--equip
local equip_filter=Auxiliary.UnionEquipFilter(filter)
local e3=Effect.CreateEffect(c)
e3:SetDescription(1068)
e3:SetProperty(EFFECT_FLAG_CARD_TARGET)
e3:SetCategory(CATEGORY_EQUIP)
e3:SetType(EFFECT_TYPE_IGNITION)
e3:SetRange(LOCATION_MZONE)
e3:SetTarget(Auxiliary.UnionEquipTarget(equip_filter))
e3:SetOperation(Auxiliary.UnionEquipOperation(equip_filter))
c:RegisterEffect(e3)
--unequip
local e4=Effect.CreateEffect(c)
e4:SetDescription(1152)
e4:SetCategory(CATEGORY_SPECIAL_SUMMON)
e4:SetType(EFFECT_TYPE_IGNITION)
e4:SetRange(LOCATION_SZONE)
e4:SetTarget(Auxiliary.UnionUnequipTarget)
e4:SetOperation(Auxiliary.UnionUnequipOperation)
c:RegisterEffect(e4)
end
function Auxiliary.UnionEquipFilter(filter)
return function(c,tp)
local ct1,ct2=c:GetUnionCount()
return c:IsFaceup() and ct2==0 and c:IsControler(tp) and filter(c)
end
end
function Auxiliary.UnionEquipLimit(filter)
return function(e,c)
return (c:IsControler(e:GetHandlerPlayer()) and filter(c)) or e:GetHandler():GetEquipTarget()==c
end
end
function Auxiliary.UnionEquipTarget(equip_filter)
return function(e,tp,eg,ep,ev,re,r,rp,chk,chkc)
local c=e:GetHandler()
if chkc then return chkc:IsLocation(LOCATION_MZONE) and equip_filter(chkc,tp) end
if chk==0 then return c:GetFlagEffect(FLAG_ID_UNION)==0 and Duel.GetLocationCount(tp,LOCATION_SZONE)>0
and Duel.IsExistingTarget(equip_filter,tp,LOCATION_MZONE,0,1,c,tp) end
Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_EQUIP)
local g=Duel.SelectTarget(tp,equip_filter,tp,LOCATION_MZONE,0,1,1,c,tp)
Duel.SetOperationInfo(0,CATEGORY_EQUIP,g,1,0,0)
c:RegisterFlagEffect(FLAG_ID_UNION,RESET_EVENT+0x7e0000+RESET_PHASE+PHASE_END,0,1)
end
end
function Auxiliary.UnionEquipOperation(equip_filter)
return function(e,tp,eg,ep,ev,re,r,rp)
local c=e:GetHandler()
local tc=Duel.GetFirstTarget()
if not c:IsRelateToEffect(e) or c:IsFacedown() then return end
if not tc:IsRelateToEffect(e) or not equip_filter(tc,tp) then
Duel.SendtoGrave(c,REASON_RULE)
return
end
if not Duel.Equip(tp,c,tc,false) then return end
Auxiliary.SetUnionState(c)
end
end
function Auxiliary.UnionUnequipTarget(e,tp,eg,ep,ev,re,r,rp,chk)
local c=e:GetHandler()
if chk==0 then return c:GetFlagEffect(FLAG_ID_UNION)==0 and Duel.GetLocationCount(tp,LOCATION_MZONE)>0
and c:GetEquipTarget() and c:IsCanBeSpecialSummoned(e,0,tp,true,false) end
Duel.SetOperationInfo(0,CATEGORY_SPECIAL_SUMMON,c,1,0,0)
c:RegisterFlagEffect(FLAG_ID_UNION,RESET_EVENT+0x7e0000+RESET_PHASE+PHASE_END,0,1)
end
function Auxiliary.UnionUnequipOperation(e,tp,eg,ep,ev,re,r,rp)
local c=e:GetHandler()
if not c:IsRelateToEffect(e) then return end
Duel.SpecialSummon(c,0,tp,tp,true,false,POS_FACEUP)
end
function Auxiliary.EnableChangeCode(c,code,location,condition)
Auxiliary.AddCodeList(c,code)
local loc=c:GetOriginalType()&TYPE_MONSTER~=0 and LOCATION_MZONE or LOCATION_SZONE
loc=location or loc
if condition==nil then condition=Auxiliary.TRUE end
local e1=Effect.CreateEffect(c)
e1:SetType(EFFECT_TYPE_SINGLE)
e1:SetProperty(EFFECT_FLAG_SINGLE_RANGE)
e1:SetCode(EFFECT_CHANGE_CODE)
e1:SetRange(loc)
e1:SetCondition(condition)
e1:SetValue(code)
c:RegisterEffect(e1)
return e1
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.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
--Extra Deck summon count
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
--Fusion Monster is unnecessary to use this
function Auxiliary.AddMaterialCodeList(c,...)
if c:IsStatus(STATUS_COPYING_EFFECT) then return end
local mat={}
for _,code in ipairs{...} do
mat[code]=true
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
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.GetMaterialListCount(c)
if not c.material_count then return 0,0 end
return c.material_count[1],c.material_count[2]
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.AddSetNameMonsterList(c,...)
if c:IsStatus(STATUS_COPYING_EFFECT) then return end
if c.setcode_monster_list==nil then
local mt=getmetatable(c)
mt.setcode_monster_list={}
for i,scode in ipairs{...} do
mt.setcode_monster_list[i]=scode
end
else
for i,scode in ipairs{...} do
c.setcode_monster_list[i]=scode
end
end
end
function Auxiliary.IsSetNameMonsterListed(c,setcode)
if not c.setcode_monster_list then return false end
for i,scode in ipairs(c.setcode_monster_list) do
if setcode&0xfff==scode&0xfff and setcode&scode==setcode then return true end
end
return false
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.IsTypeInText(c,type)
return c.has_text_type and type&c.has_text_type==type
end
function Auxiliary.GetAttributeCount(g)
if #g==0 then return 0 end
local att=0
for tc in Auxiliary.Next(g) do
att=att|tc:GetAttribute()
end
local ct=0
while att~=0 do
if att&0x1~=0 then ct=ct+1 end
att=att>>1
end
return ct
end
function Auxiliary.IsInGroup(c,g)
return g:IsContains(c)
end
--Get the row index (from the viewpoint of controller)
function Auxiliary.GetLocalRow(location,sequence)
if location==LOCATION_SZONE then
if 0<=sequence and sequence<=4 then
return 0
else
return NULL_VALUE
end
elseif location==LOCATION_MZONE then
if 0<=sequence and sequence<=4 then
return 1
elseif 5<=sequence and sequence<=6 then
return 2
else
return NULL_VALUE
end
else
return NULL_VALUE
end
end
--Get the global row index (from the viewpoint of 0)
function Auxiliary.GetGlobalRow(p,location,sequence)
local row=Auxiliary.GetLocalRow(location,sequence)
if row<0 then
return NULL_VALUE
end
if p==0 then
return row
else
return 4-row
end
end
--Get the column index (from the viewpoint of controller)
function Auxiliary.GetLocalColumn(location,sequence)
if location==LOCATION_SZONE then
if 0<=sequence and sequence<=4 then
return sequence
else
return NULL_VALUE
end
elseif location==LOCATION_MZONE then
if 0<=sequence and sequence<=4 then
return sequence
elseif sequence==5 then
return 1
elseif sequence==6 then
return 3
else
return NULL_VALUE
end
else
return NULL_VALUE
end
end
--Get the global column index (from the viewpoint of 0)
function Auxiliary.GetGlobalColumn(p,location,sequence)
local column=Auxiliary.GetLocalColumn(location,sequence)
if column<0 then
return NULL_VALUE
end
if p==0 then
return column
else
return 4-column
end
end
---Get the global row and column index of c
---@param c Card
---@return integer
---@return integer
function Auxiliary.GetFieldIndex(c)
local cp=c:GetControler()
local loc=c:GetLocation()
local seq=c:GetSequence()
return Auxiliary.GetGlobalRow(cp,loc,seq),Auxiliary.GetGlobalColumn(cp,loc,seq)
end
---Check if c is adjacent to (i,j)
---@param c Card
---@param i integer
---@param j integer
---@return boolean
function Auxiliary.AdjacentFilter(c,i,j)
local row,column=Auxiliary.GetFieldIndex(c)
if row<0 or column<0 then
return false
end
return (row==i and math.abs(column-j)==1) or (math.abs(row-i)==1 and column==j)
end
---Get the card group adjacent to (i,j)
---@param tp integer
---@param location1 integer
---@param location2 integer
---@param i integer
---@param j integer
---@return Group
function Auxiliary.GetAdjacentGroup(tp,location1,location2,i,j)
return Duel.GetMatchingGroup(Auxiliary.AdjacentFilter,tp,location1,location2,nil,i,j)
end
---Get the column index of card c (from the viewpoint of p)
---@param c Card
---@param p? integer default: 0
---@return integer
function Auxiliary.GetColumn(c,p)
p=p or 0
local cp=c:GetControler()
local loc=c:GetLocation()
local seq=c:GetSequence()
local column=Auxiliary.GetGlobalColumn(cp,loc,seq)
if column<0 then
return NULL_VALUE
end
if p==0 then
return column
else
return 4-column
end
end
--return the column of monster zone seq (from the viewpoint of controller)
function Auxiliary.MZoneSequence(seq)
return Auxiliary.GetLocalColumn(LOCATION_MZONE,seq)
end
--return the column of spell/trap zone seq (from the viewpoint of controller)
function Auxiliary.SZoneSequence(seq)
return Auxiliary.GetLocalColumn(LOCATION_SZONE,seq)
end
--generate the value function of EFFECT_CHANGE_BATTLE_DAMAGE on monsters
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
--filter for "negate the effects of a face-up monster" (無限泡影/Infinite Impermanence)
function Auxiliary.NegateMonsterFilter(c)
return c:IsFaceup() and not c:IsDisabled() and (c:IsType(TYPE_EFFECT) or c:GetOriginalType()&TYPE_EFFECT~=0)
end
--filter for "negate the effects of an Effect Monster" (エフェクト・ヴェーラー/Effect Veiler)
function Auxiliary.NegateEffectMonsterFilter(c)
return c:IsFaceup() and not c:IsDisabled() and c:IsType(TYPE_EFFECT)
end
--filter for "negate the effects of a face-up card"
function Auxiliary.NegateAnyFilter(c)
if c:IsType(TYPE_TRAPMONSTER) then
return c:IsFaceup()
elseif c:IsType(TYPE_SPELL+TYPE_TRAP) then
return c:IsFaceup() and not c:IsDisabled()
else
return Auxiliary.NegateMonsterFilter(c)
end
end
--alias for compatibility
Auxiliary.disfilter1=Auxiliary.NegateAnyFilter
--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_DAMAGE_STEP_END + this monster is releate to battle
function Auxiliary.dsercon(e,tp,eg,ep,ev,re,r,rp)
local c=e:GetHandler()
return c:IsRelateToBattle() or c:IsStatus(STATUS_BATTLE_DESTROYED)
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:IsPreviousControler(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:IsPreviousControler(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(FLAG_ID_CHAINING)==0 then
e:GetHandler():RegisterFlagEffect(FLAG_ID_CHAINING,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+RESETS_STANDARD+RESET_PHASE+PHASE_END,0,1)
end
tc=eg:GetNext()
end
end
--for EVENT_BE_MATERIAL effect releated to the summoned monster
function Auxiliary.CreateMaterialReasonCardRelation(c,te)
local e1=Effect.CreateEffect(c)
e1:SetType(EFFECT_TYPE_SINGLE+EFFECT_TYPE_CONTINUOUS)
e1:SetCode(EVENT_BE_MATERIAL)
e1:SetProperty(EFFECT_FLAG_CANNOT_DISABLE)
e1:SetOperation(Auxiliary.MaterialReasonCardReg)
e1:SetLabelObject(te)
c:RegisterEffect(e1)
end
function Auxiliary.MaterialReasonCardReg(e,tp,eg,ep,ev,re,r,rp)
local c=e:GetHandler()
local te=e:GetLabelObject()
c:GetReasonCard():CreateEffectRelation(te)
end
--the player tp has token on the field
function Auxiliary.tkfcon(e,tp)
if tp==nil and e~=nil then tp=e:GetHandlerPlayer() end
return Duel.IsExistingMatchingCard(Card.IsType,tp,LOCATION_ONFIELD,0,1,nil,TYPE_TOKEN)
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 c=e:GetHandler()
local typ=c:GetSpecialSummonInfo(SUMMON_INFO_TYPE)
return c:IsSummonType(SUMMON_VALUE_GLADIATOR) or (typ&TYPE_MONSTER~=0 and c:IsSpecialSummonSetCard(0x19))
end
--sp_summon condition for evolsaur monsters
function Auxiliary.evospcon(e,tp,eg,ep,ev,re,r,rp)
local c=e:GetHandler()
local typ=c:GetSpecialSummonInfo(SUMMON_INFO_TYPE)
return c:IsSummonType(SUMMON_VALUE_EVOLTILE) or (typ&TYPE_MONSTER~=0 and c:IsSpecialSummonSetCard(0x304e))
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)
end
end
--Necrovalley test for effect with not certain target or not certain action
function Auxiliary.NecroValleyNegateCheck(v)
if not Duel.IsChainDisablable(0) then return false end
local g=Group.CreateGroup()
if Auxiliary.GetValueType(v)=="Card" then g:AddCard(v) end
if Auxiliary.GetValueType(v)=="Group" then g:Merge(v) end
if g:IsExists(Card.IsHasEffect,1,nil,EFFECT_NECRO_VALLEY) then
Duel.NegateEffect(0)
return true
end
return false
end
--Ursarctic common summon from hand effect
function Auxiliary.AddUrsarcticSpSummonEffect(c)
local e1=Effect.CreateEffect(c)
e1:SetCategory(CATEGORY_SPECIAL_SUMMON)
e1:SetType(EFFECT_TYPE_QUICK_O)
e1:SetCode(EVENT_FREE_CHAIN)
e1:SetRange(LOCATION_HAND)
e1:SetHintTiming(0,TIMINGS_CHECK_MONSTER+TIMING_MAIN_END)
e1:SetCondition(Auxiliary.UrsarcticSpSummonCondition)
e1:SetCost(Auxiliary.UrsarcticSpSummonCost)
e1:SetTarget(Auxiliary.UrsarcticSpSummonTarget)
e1:SetOperation(Auxiliary.UrsarcticSpSummonOperation)
c:RegisterEffect(e1)
return e1
end
function Auxiliary.UrsarcticSpSummonCondition(e,tp,eg,ep,ev,re,r,rp)
return Duel.GetCurrentPhase()==PHASE_MAIN1 or Duel.GetCurrentPhase()==PHASE_MAIN2
end
function Auxiliary.UrsarcticReleaseFilter(c)
return c:IsLevelAbove(7) and c:IsLocation(LOCATION_HAND)
end
function Auxiliary.UrsarcticExCostFilter(c,tp)
return c:IsAbleToRemoveAsCost() and (c:IsHasEffect(16471775,tp) or c:IsHasEffect(89264428,tp))
end
function Auxiliary.UrsarcticSpSummonCost(e,tp,eg,ep,ev,re,r,rp,chk)
local g1=Duel.GetReleaseGroup(tp,true):Filter(Auxiliary.UrsarcticReleaseFilter,e:GetHandler())
local g2=Duel.GetMatchingGroup(Auxiliary.UrsarcticExCostFilter,tp,LOCATION_GRAVE,0,nil,tp)
g1:Merge(g2)
if chk==0 then return g1:GetCount()>0 end
Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_RELEASE)
local tc=g1:Select(tp,1,1,nil):GetFirst()
local te=tc:IsHasEffect(16471775,tp) or tc:IsHasEffect(89264428,tp)
if te then
te:UseCountLimit(tp)
Duel.Remove(tc,POS_FACEUP,REASON_EFFECT+REASON_REPLACE)
else
Duel.Release(tc,REASON_COST)
end
end
function Auxiliary.UrsarcticSpSummonTarget(e,tp,eg,ep,ev,re,r,rp,chk)
if chk==0 then return Duel.GetLocationCount(tp,LOCATION_MZONE)>0
and e:GetHandler():IsCanBeSpecialSummoned(e,0,tp,false,false) end
Duel.SetOperationInfo(0,CATEGORY_SPECIAL_SUMMON,e:GetHandler(),1,0,0)
end
function Auxiliary.UrsarcticSpSummonOperation(e,tp,eg,ep,ev,re,r,rp)
local c=e:GetHandler()
if c:IsRelateToEffect(e) then
Duel.SpecialSummon(c,0,tp,tp,false,false,POS_FACEUP)
end
local e1=Effect.CreateEffect(c)
e1:SetType(EFFECT_TYPE_FIELD)
e1:SetProperty(EFFECT_FLAG_PLAYER_TARGET)
e1:SetCode(EFFECT_CANNOT_SPECIAL_SUMMON)
e1:SetTargetRange(1,0)
e1:SetTarget(Auxiliary.UrsarcticSpSummonLimit)
e1:SetReset(RESET_PHASE+PHASE_END)
Duel.RegisterEffect(e1,tp)
end
function Auxiliary.UrsarcticSpSummonLimit(e,c)
return c:IsLevel(0)
end
--Drytron common summon effect
function Auxiliary.AddDrytronSpSummonEffect(c,func)
local e1=Effect.CreateEffect(c)
e1:SetType(EFFECT_TYPE_IGNITION)
e1:SetRange(LOCATION_HAND+LOCATION_GRAVE)
e1:SetCost(Auxiliary.DrytronSpSummonCost)
e1:SetTarget(Auxiliary.DrytronSpSummonTarget)
e1:SetOperation(Auxiliary.DrytronSpSummonOperation(func))
c:RegisterEffect(e1)
Duel.AddCustomActivityCounter(97148796,ACTIVITY_SPSUMMON,Auxiliary.DrytronCounterFilter)
return e1
end
function Auxiliary.DrytronCounterFilter(c)
return not c:IsSummonableCard()
end
function Auxiliary.DrytronCostFilter(c,tp)
return (c:IsSetCard(0x154) or c:IsType(TYPE_RITUAL)) and c:IsType(TYPE_MONSTER) and Duel.GetMZoneCount(tp,c)>0
and (c:IsControler(tp) or c:IsFaceup())
end
function Auxiliary.DrytronExtraCostFilter(c,tp)
return c:IsAbleToRemove() and c:IsHasEffect(89771220,tp)
end
function Auxiliary.DrytronSpSummonCost(e,tp,eg,ep,ev,re,r,rp,chk)
e:SetLabel(100)
local g1=Duel.GetReleaseGroup(tp,true):Filter(Auxiliary.DrytronCostFilter,e:GetHandler(),tp)
local g2=Duel.GetMatchingGroup(Auxiliary.DrytronExtraCostFilter,tp,LOCATION_GRAVE,0,nil,tp)
g1:Merge(g2)
if chk==0 then return #g1>0 and Duel.GetCustomActivityCount(97148796,tp,ACTIVITY_SPSUMMON)==0 end
local e1=Effect.CreateEffect(e:GetHandler())
e1:SetType(EFFECT_TYPE_FIELD)
e1:SetCode(EFFECT_CANNOT_SPECIAL_SUMMON)
e1:SetProperty(EFFECT_FLAG_PLAYER_TARGET+EFFECT_FLAG_OATH)
e1:SetTargetRange(1,0)
e1:SetTarget(Auxiliary.DrytronSpSummonLimit)
e1:SetReset(RESET_PHASE+PHASE_END)
Duel.RegisterEffect(e1,tp)
--cant special summon summonable card check
local e2=Effect.CreateEffect(e:GetHandler())
e2:SetType(EFFECT_TYPE_FIELD)
e2:SetCode(97148796)
e2:SetProperty(EFFECT_FLAG_PLAYER_TARGET+EFFECT_FLAG_OATH)
e2:SetTargetRange(1,0)
e2:SetReset(RESET_PHASE+PHASE_END)
Duel.RegisterEffect(e2,tp)
Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_RELEASE)
local rg=g1:Select(tp,1,1,nil)
local tc=rg:GetFirst()
local te=tc:IsHasEffect(89771220,tp)
if te then
te:UseCountLimit(tp)
Duel.Remove(tc,POS_FACEUP,REASON_EFFECT+REASON_REPLACE)
else
Auxiliary.UseExtraReleaseCount(rg,tp)
Duel.Release(tc,REASON_COST)
end
end
function Auxiliary.DrytronSpSummonLimit(e,c,sump,sumtype,sumpos,targetp,se)
return c:IsSummonableCard()
end
function Auxiliary.DrytronSpSummonTarget(e,tp,eg,ep,ev,re,r,rp,chk)
local res=e:GetLabel()==100 or Duel.GetLocationCount(tp,LOCATION_MZONE)>0
if chk==0 then
e:SetLabel(0)
return res and e:GetHandler():IsCanBeSpecialSummoned(e,0,tp,false,true,POS_FACEUP_DEFENSE)
end
e:SetLabel(0)
Duel.SetOperationInfo(0,CATEGORY_SPECIAL_SUMMON,e:GetHandler(),1,0,0)
end
function Auxiliary.DrytronSpSummonOperation(func)
return function(e,tp,eg,ep,ev,re,r,rp)
local c=e:GetHandler()
if not c:IsRelateToEffect(e) then return end
if Duel.SpecialSummon(c,0,tp,tp,false,true,POS_FACEUP_DEFENSE)~=0 then
c:CompleteProcedure()
func(e,tp)
end
end
end
---The `nolimit` parameter for Special Summon effects of Drytron cards
---@param c Card
---@return boolean
function Auxiliary.DrytronSpSummonType(c)
return c:IsType(TYPE_SPSUMMON)
end
---The `nolimit` parameter for Special Summon effects of Dragon, Xyz monsters where Soul Drain Dragon is available
---(Soul Drain Dragon, Level 8/LIGHT/Dragon/4000/0)
---@param c Card
---@return boolean
function Auxiliary.DragonXyzSpSummonType(c)
return c:GetOriginalCode()==55735315
end
---The `nolimit` parameter for Special Summon effects of Triamid cards
---@param c Card
---@return boolean
function Auxiliary.TriamidSpSummonType(c)
return c:IsType(TYPE_SPSUMMON)
end
--additional destroy effect for the Labrynth field
function Auxiliary.LabrynthDestroyOp(e,tp,res)
local c=e:GetHandler()
local chk=not c:IsStatus(STATUS_ACT_FROM_HAND) and c:IsSetCard(0x117e) and c:GetType()==TYPE_TRAP and e:IsHasType(EFFECT_TYPE_ACTIVATE)
local exc=nil
if c:IsStatus(STATUS_LEAVE_CONFIRMED) then exc=c end
local te=Duel.IsPlayerAffectedByEffect(tp,33407125)
if chk and te
and Duel.IsExistingMatchingCard(nil,tp,LOCATION_ONFIELD,LOCATION_ONFIELD,1,exc)
and Duel.SelectYesNo(tp,Auxiliary.Stringid(33407125,0)) then
if res>0 then Duel.BreakEffect() end
Duel.Hint(HINT_CARD,0,33407125)
Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_DESTROY)
local dg=Duel.SelectMatchingCard(tp,nil,tp,LOCATION_ONFIELD,LOCATION_ONFIELD,1,1,exc)
Duel.HintSelection(dg)
Duel.Destroy(dg,REASON_EFFECT)
te:UseCountLimit(tp)
end
end
--shortcut for Gizmek cards
function Auxiliary.AtkEqualsDef(c)
if not c:IsType(TYPE_MONSTER) or c:IsType(TYPE_LINK) then return false end
if c:GetAttack()~=c:GetDefense() then return false end
return c:IsLocation(LOCATION_MZONE) or c:GetTextAttack()>=0 and c:GetTextDefense()>=0
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
---Check if there is space in mzone after tp releases g by reason
---@param g Group
---@param tp integer
---@param reason? integer
---@return boolean
function Auxiliary.mzctcheckrel(g,tp,reason)
reason=reason or REASON_COST
return Duel.GetMZoneCount(tp,g)>0 and Duel.CheckReleaseGroupEx(tp,Auxiliary.IsInGroup,#g,reason,false,nil,g)
end
--used for "except this card"
function Auxiliary.ExceptThisCard(e)
local c=e:GetHandler()
if c:IsRelateToChain() 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 Auxiliary.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
function Auxiliary.CheckGroupRecursive(c,sg,g,f,min,max,ext_params)
sg:AddCard(c)
if Auxiliary.GCheckAdditional and not Auxiliary.GCheckAdditional(sg,c,g) 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) 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
---
---@param g Group
---@param f function
---@param min? integer
---@param max? integer
---@param ... any
---@return boolean
function Group.CheckSubGroup(g,f,min,max,...)
min=min or 1
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)) then return false end
if #sg>=min and #sg<=max and f(sg,...) and (not Auxiliary.GCheckAdditional or Auxiliary.GCheckAdditional(sg,nil,g)) then return true end
local eg=g:Clone()
for c in Auxiliary.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
---
---@param g Group
---@param tp integer
---@param f function
---@param cancelable boolean
---@param min? integer
---@param max? integer
---@param ... any
---@return Group
function Group.SelectSubGroup(g,tp,f,cancelable,min,max,...)
Auxiliary.SubGroupCaptured=Group.CreateGroup()
min=min or 1
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 Auxiliary.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 Auxiliary.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
---Create a table of filter functions
---@param f function
---@param list table
---@return table
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) 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
---
---@param g Group
---@param checks table
---@param f? function
---@param ... any
---@return boolean
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
---
---@param g Group
---@param tp integer
---@param checks table
---@param cancelable? boolean
---@param f? function
---@param ... any
---@return Group
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
--for effects that player usually select card from field, avoid showing panel
function Auxiliary.SelectCardFromFieldFirst(tp,f,player,s,o,min,max,ex,...)
local ext_params={...}
local g=Duel.GetMatchingGroup(f,player,s,o,ex,table.unpack(ext_params))
local fg=g:Filter(Card.IsOnField,nil)
g:Sub(fg)
if #fg>=min and #g>0 then
local last_hint=Duel.GetLastSelectHint(tp)
Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_FIELD_FIRST)
local sg=fg:CancelableSelect(tp,min,max,nil)
if sg then
return sg
else
Duel.Hint(HINT_SELECTMSG,tp,last_hint)
end
end
return Duel.SelectMatchingCard(tp,f,player,s,o,min,max,ex,table.unpack(ext_params))
end
function Auxiliary.SelectTargetFromFieldFirst(tp,f,player,s,o,min,max,ex,...)
local ext_params={...}
local g=Duel.GetMatchingGroup(f,player,s,o,ex,table.unpack(ext_params)):Filter(Card.IsCanBeEffectTarget,nil)
local fg=g:Filter(Card.IsOnField,nil)
g:Sub(fg)
if #fg>=min and #g>0 then
local last_hint=Duel.GetLastSelectHint(tp)
Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_FIELD_FIRST)
local sg=fg:CancelableSelect(tp,min,max,nil)
if sg then
Duel.SetTargetCard(sg)
return sg
else
Duel.Hint(HINT_SELECTMSG,tp,last_hint)
end
end
return Duel.SelectTarget(tp,f,player,s,o,min,max,ex,table.unpack(ext_params))
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
function Auxiliary.nbtg(e,tp,eg,ep,ev,re,r,rp,chk)
if chk==0 then return Auxiliary.nbcon(tp,re) end
Duel.SetOperationInfo(0,CATEGORY_NEGATE,eg,1,0,0)
if re:GetHandler():IsRelateToEffect(re) then
Duel.SetOperationInfo(0,CATEGORY_REMOVE,eg,1,0,0)
end
if re:GetActivateLocation()==LOCATION_GRAVE then
e:SetCategory(e:GetCategory()|CATEGORY_GRAVE_ACTION)
else
e:SetCategory(e:GetCategory()&~CATEGORY_GRAVE_ACTION)
end
end
--condition of "negate activation and return to deck"
function Auxiliary.ndcon(tp,re)
local rc=re:GetHandler()
return re:IsHasType(EFFECT_TYPE_ACTIVATE) or not rc:IsRelateToEffect(re) or rc:IsAbleToDeck()
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 0x0001<<(16*p+seq)
else
return 0
end
elseif loc == LOCATION_SZONE then
if seq<=4 then
return 0x0100<<(16*p+seq)
else
return 0
end
else
return 0
end
end
--use the count limit of Lair of Darkness if the tributes are not selected by Duel.SelectReleaseGroup
function Auxiliary.UseExtraReleaseCount(g,tp)
local eg=g:Filter(Auxiliary.ExtraReleaseFilter,nil,tp)
for ec in Auxiliary.Next(eg) do
local te=ec:IsHasEffect(EFFECT_EXTRA_RELEASE_NONSUM,tp)
if te then te:UseCountLimit(tp) end
end
end
function Auxiliary.ExtraReleaseFilter(c,tp)
return c:IsControler(1-tp) and c:IsHasEffect(EFFECT_EXTRA_RELEASE_NONSUM,tp)
end
--
function Auxiliary.GetCappedLevel(c)
local lv=c:GetLevel()
if lv>MAX_PARAMETER then
return MAX_PARAMETER
else
return lv
end
end
--
function Auxiliary.GetCappedAttack(c)
local x=c:GetAttack()
if x>MAX_PARAMETER then
return MAX_PARAMETER
else
return x
end
end
--when this card is sent to grave, record the reason effect
--to check whether the reason effect do something simultaneously
--so the "while this card is in your GY" condition isn't met
function Auxiliary.AddThisCardInGraveAlreadyCheck(c)
local e1=Effect.CreateEffect(c)
e1:SetType(EFFECT_TYPE_SINGLE+EFFECT_TYPE_CONTINUOUS)
e1:SetCode(EVENT_TO_GRAVE)
e1:SetCondition(Auxiliary.ThisCardInGraveAlreadyCheckReg)
c:RegisterEffect(e1)
return e1
end
function Auxiliary.ThisCardInGraveAlreadyCheckReg(e,tp,eg,ep,ev,re,r,rp)
--condition of continous effect will be checked before other effects
if re==nil then return false end
if e:GetLabelObject()~=nil then return false end
if (r&REASON_EFFECT)>0 then
e:SetLabelObject(re)
local e1=Effect.CreateEffect(e:GetHandler())
e1:SetType(EFFECT_TYPE_FIELD+EFFECT_TYPE_CONTINUOUS)
e1:SetCode(EVENT_CHAIN_END)
e1:SetProperty(EFFECT_FLAG_CANNOT_DISABLE)
e1:SetOperation(Auxiliary.ThisCardInGraveAlreadyReset1)
e1:SetLabelObject(e)
Duel.RegisterEffect(e1,tp)
local e2=e1:Clone()
e2:SetCode(EVENT_BREAK_EFFECT)
e2:SetOperation(Auxiliary.ThisCardInGraveAlreadyReset2)
e2:SetReset(RESET_CHAIN)
e2:SetLabelObject(e1)
Duel.RegisterEffect(e2,tp)
elseif (r&REASON_MATERIAL)>0 or not re:IsActivated() and (r&REASON_COST)>0 then
e:SetLabelObject(re)
local reset_event=EVENT_SPSUMMON
if re:GetCode()~=EFFECT_SPSUMMON_PROC then reset_event=EVENT_SUMMON end
local e1=Effect.CreateEffect(e:GetHandler())
e1:SetType(EFFECT_TYPE_FIELD+EFFECT_TYPE_CONTINUOUS)
e1:SetCode(reset_event)
e1:SetProperty(EFFECT_FLAG_CANNOT_DISABLE)
e1:SetOperation(Auxiliary.ThisCardInGraveAlreadyReset1)
e1:SetLabelObject(e)
Duel.RegisterEffect(e1,tp)
end
return false
end
function Auxiliary.ThisCardInGraveAlreadyReset1(e)
--this will run after EVENT_SPSUMMON_SUCCESS
e:GetLabelObject():SetLabelObject(nil)
e:Reset()
end
function Auxiliary.ThisCardInGraveAlreadyReset2(e)
local e1=e:GetLabelObject()
e1:GetLabelObject():SetLabelObject(nil)
e1:Reset()
e:Reset()
end
--Player p place g on the top of Deck in any order
function Auxiliary.PlaceCardsOnDeckTop(p,g,reason)
if reason==nil then reason=REASON_EFFECT end
Duel.SendtoDeck(g,nil,SEQ_DECKTOP,reason)
local rg=Duel.GetOperatedGroup()
local og=rg:Filter(Card.IsLocation,nil,LOCATION_DECK)
local ct1=og:FilterCount(Card.IsControler,nil,p)
local ct2=og:FilterCount(Card.IsControler,nil,1-p)
if ct1>1 then
Duel.SortDecktop(p,p,ct1)
end
if ct2>1 then
Duel.SortDecktop(p,1-p,ct2)
end
return #rg
end
--Player p place g on the bottom of Deck in any order
function Auxiliary.PlaceCardsOnDeckBottom(p,g,reason)
if reason==nil then reason=REASON_EFFECT end
Duel.SendtoDeck(g,nil,SEQ_DECKTOP,reason)
local rg=Duel.GetOperatedGroup()
local og=rg:Filter(Card.IsLocation,nil,LOCATION_DECK)
local ct1=og:FilterCount(Card.IsControler,nil,p)
local ct2=og:FilterCount(Card.IsControler,nil,1-p)
if ct1>0 then
if ct1>1 then
Duel.SortDecktop(p,p,ct1)
end
for i=1,ct1 do
local tc=Duel.GetDecktopGroup(p,1):GetFirst()
Duel.MoveSequence(tc,SEQ_DECKBOTTOM)
end
end
if ct2>0 then
if ct2>1 then
Duel.SortDecktop(p,1-p,ct2)
end
for i=1,ct2 do
local tc=Duel.GetDecktopGroup(1-p,1):GetFirst()
Duel.MoveSequence(tc,SEQ_DECKBOTTOM)
end
end
return #rg
end
--The event is triggered multiple times in a chain
--but only 1 event with EVENT_CUSTOM+code will be triggered at EVENT_CHAIN_END, or immediately if not in chain
--NOTE: re,r,rp,ep,ev of that custom event ARE NOT releated to the real event that trigger this custom event
function Auxiliary.RegisterMergedDelayedEvent(c,code,event,g)
local mt=getmetatable(c)
if mt[event]==true then return end
mt[event]=true
if not g then g=Group.CreateGroup() end
g:KeepAlive()
local ge1=Effect.CreateEffect(c)
ge1:SetType(EFFECT_TYPE_FIELD+EFFECT_TYPE_CONTINUOUS)
ge1:SetCode(event)
ge1:SetLabel(code)
ge1:SetLabelObject(g)
ge1:SetOperation(Auxiliary.MergedDelayEventCheck1)
Duel.RegisterEffect(ge1,0)
local ge2=ge1:Clone()
ge2:SetCode(EVENT_CHAIN_END)
ge2:SetOperation(Auxiliary.MergedDelayEventCheck2)
Duel.RegisterEffect(ge2,0)
end
function Auxiliary.MergedDelayEventCheck1(e,tp,eg,ep,ev,re,r,rp)
local g=e:GetLabelObject()
g:Merge(eg)
if Duel.GetCurrentChain()==0 and not Duel.CheckEvent(EVENT_CHAIN_END) then
local _eg=g:Clone()
Duel.RaiseEvent(_eg,EVENT_CUSTOM+e:GetLabel(),re,r,rp,ep,ev)
g:Clear()
end
end
function Auxiliary.MergedDelayEventCheck2(e,tp,eg,ep,ev,re,r,rp)
local g=e:GetLabelObject()
if #g>0 then
local _eg=g:Clone()
Duel.RaiseEvent(_eg,EVENT_CUSTOM+e:GetLabel(),re,r,rp,ep,ev)
g:Clear()
end
end
--B.E.S. remove counter
function Auxiliary.EnableBESRemove(c)
local e1=Effect.CreateEffect(c)
e1:SetDescription(10)
e1:SetCategory(CATEGORY_DESTROY)
e1:SetType(EFFECT_TYPE_SINGLE+EFFECT_TYPE_TRIGGER_F)
e1:SetCode(EVENT_DAMAGE_STEP_END)
e1:SetRange(LOCATION_MZONE)
e1:SetCondition(Auxiliary.RemoveCondtion)
e1:SetTarget(Auxiliary.RemoveTarget)
e1:SetOperation(Auxiliary.RemoveOperation)
c:RegisterEffect(e1)
end
function Auxiliary.RemoveCondtion(e,tp,eg,ep,ev,re,r,rp)
local c=e:GetHandler()
return c:IsRelateToBattle()
end
function Auxiliary.RemoveTarget(e,tp,eg,ep,ev,re,r,rp,chk)
if chk==0 then return true end
if not e:GetHandler():IsCanRemoveCounter(tp,0x1f,1,REASON_EFFECT) then
Duel.SetOperationInfo(0,CATEGORY_DESTROY,e:GetHandler(),1,0,0)
end
end
function Auxiliary.RemoveOperation(e,tp,eg,ep,ev,re,r,rp)
local c=e:GetHandler()
if c:IsRelateToEffect(e) then
if c:IsCanRemoveCounter(tp,0x1f,1,REASON_EFFECT) then
c:RemoveCounter(tp,0x1f,1,REASON_EFFECT)
else
Duel.Destroy(c,REASON_EFFECT)
end
end
end
--The operation function of "destroy during End Phase"
function Auxiliary.EPDestroyOperation(e,tp,eg,ep,ev,re,r,rp)
local tc=e:GetLabelObject()
if Auxiliary.GetValueType(tc)=="Card" or Auxiliary.GetValueType(tc)=="Group" then
Duel.Destroy(tc,REASON_EFFECT,LOCATION_GRAVE)
end
end
--
function Auxiliary.NegateSummonCondition()
return Duel.GetReadyChain()==0
end
---Check if all cards in g have the same Attribute/Race
---@param g Group
---@param f function Like Card.GetAttribute, must return binary value
---@return boolean
function Auxiliary.SameValueCheck(g,f)
if #g<=1 then return true end
if #g==2 then return f(g:GetFirst())&f(g:GetNext())~=0 end
local tc=g:GetFirst()
local v=f(tc)
tc=g:GetNext()
while tc do
v=v&f(tc)
if v==0 then return false end
tc=g:GetNext()
end
return v~=0
end
---
---@param tp integer
---@return boolean
function Auxiliary.IsPlayerCanNormalDraw(tp)
return Duel.GetDrawCount(tp)>0 and Duel.GetFieldGroupCount(tp,LOCATION_DECK,0)>0
and Duel.GetFlagEffect(tp,FLAG_ID_NO_NORMAL_DRAW)==0
end
---
---@param e Effect
---@param tp integer
---@param property? integer
function Auxiliary.GiveUpNormalDraw(e,tp,property)
property=property or 0
local c=e:GetHandler()
local e1=Effect.CreateEffect(c)
e1:SetType(EFFECT_TYPE_FIELD)
e1:SetProperty(EFFECT_FLAG_PLAYER_TARGET|property)
e1:SetCode(EFFECT_DRAW_COUNT)
e1:SetTargetRange(1,0)
e1:SetReset(RESET_PHASE+PHASE_DRAW)
e1:SetValue(0)
Duel.RegisterEffect(e1,tp)
Duel.RegisterFlagEffect(tp,FLAG_ID_NO_NORMAL_DRAW,RESET_PHASE+PHASE_DRAW,property,1)
end
---Add EFFECT_TYPE_ACTIVATE effect to Equip Spell Cards
---@param c Card
---@param is_self boolean
---@param is_opponent boolean
---@param filter function
---@param eqlimit function|nil
---@param pause? boolean
---@param skip_target? boolean
function Auxiliary.AddEquipSpellEffect(c,is_self,is_opponent,filter,eqlimit,pause,skip_target)
local value=(type(eqlimit)=="function") and eqlimit or 1
if pause==nil then pause=false end
if skip_target==nil then skip_target=false end
--Activate
local e1=Effect.CreateEffect(c)
e1:SetCategory(CATEGORY_EQUIP)
e1:SetType(EFFECT_TYPE_ACTIVATE)
e1:SetCode(EVENT_FREE_CHAIN)
e1:SetProperty(EFFECT_FLAG_CARD_TARGET+EFFECT_FLAG_CONTINUOUS_TARGET)
if not skip_target then
e1:SetTarget(Auxiliary.EquipSpellTarget(is_self,is_opponent,filter,eqlimit))
end
e1:SetOperation(Auxiliary.EquipSpellOperation(eqlimit))
if not pause then
c:RegisterEffect(e1)
end
--Equip limit
local e2=Effect.CreateEffect(c)
e2:SetType(EFFECT_TYPE_SINGLE)
e2:SetCode(EFFECT_EQUIP_LIMIT)
e2:SetProperty(EFFECT_FLAG_CANNOT_DISABLE)
e2:SetValue(value)
c:RegisterEffect(e2)
return e1
end
function Auxiliary.EquipSpellTarget(is_self,is_opponent,filter,eqlimit)
local loc1=is_self and LOCATION_MZONE or 0
local loc2=is_opponent and LOCATION_MZONE or 0
return function(e,tp,eg,ep,ev,re,r,rp,chk,chkc)
if chkc then return chkc:IsLocation(LOCATION_MZONE) and chkc:IsFaceup() and (not eqlimit or eqlimit(e,chkc)) end
if chk==0 then return Duel.IsExistingTarget(filter,tp,loc1,loc2,1,nil) end
Duel.Hint(HINT_SELECTMSG,tp,HINTMSG_EQUIP)
Duel.SelectTarget(tp,filter,tp,loc1,loc2,1,1,nil)
Duel.SetOperationInfo(0,CATEGORY_EQUIP,e:GetHandler(),1,0,0)
end
end
function Auxiliary.EquipSpellOperation(eqlimit)
return function (e,tp,eg,ep,ev,re,r,rp)
local c=e:GetHandler()
local tc=Duel.GetFirstTarget()
if c:IsRelateToEffect(e) and tc:IsRelateToEffect(e) and tc:IsFaceup() and (not eqlimit or eqlimit(e,tc)) then
Duel.Equip(tp,c,tc)
end
end
end
---If this face-up card would leave the field, banish it instead.
---@param c Card
---@param condition? function
function Auxiliary.AddBanishRedirect(c,condition)
if type(condition)~="function" then
condition=Auxiliary.BanishRedirectCondition
end
local e1=Effect.CreateEffect(c)
e1:SetType(EFFECT_TYPE_SINGLE)
e1:SetCode(EFFECT_LEAVE_FIELD_REDIRECT)
e1:SetProperty(EFFECT_FLAG_CANNOT_DISABLE+EFFECT_FLAG_CAN_FORBIDDEN)
e1:SetCondition(condition)
e1:SetValue(LOCATION_REMOVED)
c:RegisterEffect(e1)
end
---
---@param e Effect
function Auxiliary.BanishRedirectCondition(e)
return e:GetHandler():IsFaceup()
end
---Check if c has a equip card equipped by the effect of itself.
---@param c Card
---@param id integer
---@return boolean
function Auxiliary.IsSelfEquip(c,id)
return c:GetEquipGroup():IsExists(Card.GetFlagEffect,1,nil,id)
end
---Orcustrated Babel
---@param c Card
---@return boolean
function Auxiliary.OrcustratedBabelFilter(c)
return c:IsOriginalSetCard(0x11b) and
(c:IsLocation(LOCATION_MZONE) and c:IsAllTypes(TYPE_LINK+TYPE_MONSTER) or c:IsLocation(LOCATION_GRAVE) and c:IsType(TYPE_MONSTER))
end
---Golden Allure Queen
---@param c Card
---@return boolean
function Auxiliary.GoldenAllureQueenFilter(c)
return c:IsOriginalSetCard(0x3)
end
--The table of all "become quick effects"
Auxiliary.quick_effect_filter={}
Auxiliary.quick_effect_filter[90351981]=Auxiliary.OrcustratedBabelFilter
Auxiliary.quick_effect_filter[95937545]=Auxiliary.GoldenAllureQueenFilter
---Check if the effect of c becomes a Quick Effect.
---@param c Card
---@param tp integer
---@param code integer
---@return boolean
function Auxiliary.IsCanBeQuickEffect(c,tp,code)
local filter=Auxiliary.quick_effect_filter[code]
return Duel.IsPlayerAffectedByEffect(tp,code)~=nil and filter~=nil and filter(c)
end
\ No newline at end of file
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