--min/max value
MIN_ID		=1000		--4 digits, 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	--超量素材随着超量怪兽离场
--Location Reason
LOCATION_REASON_TOFIELD		=0x1	--Duel.GetLocationCount()預設值,凱薩競技場
LOCATION_REASON_CONTROL		=0x2	--Card.IsControlerCanBeChanged()使用
--Summon Type --召唤类型
SUMMON_TYPE_NORMAL		=0x10000000 --通常召唤(EFFECT_SUMMON_PROC,EFFECT_SET_PROC 可用Value修改數值)
SUMMON_TYPE_ADVANCE		=0x11000000 --上级召唤
SUMMON_TYPE_DUAL		=0x12000000	--再度召唤（二重）
SUMMON_TYPE_FLIP		=0x20000000	--翻转召唤
SUMMON_TYPE_SPECIAL		=0x40000000	--特殊召唤(EFFECT_SPSUMMON_PROC,EFFECT_SPSUMMON_PROC_G 可用Value修改數值)
SUMMON_TYPE_FUSION		=0x43000000	--融合召唤
SUMMON_TYPE_RITUAL		=0x45000000	--仪式召唤
SUMMON_TYPE_SYNCHRO		=0x46000000	--同调召唤
SUMMON_TYPE_XYZ			=0x49000000	--超量召唤
SUMMON_TYPE_PENDULUM	=0x4a000000 --灵摆召唤
SUMMON_TYPE_LINK		=0x4c000000 --连接召唤
--Summon Value --特定的召唤方式
SUMMON_VALUE_SELF					=0x1	--自身效果或条件
SUMMON_VALUE_BLACK_GARDEN			=0x10	--黑色花园
SUMMON_VALUE_SYNCHRO_MATERIAL		=0x11	--特殊召唤并作为同调素材（黑羽-东云之东风检查）
SUMMON_VALUE_DARK_SANCTUARY			=0x12	--暗黑圣域
SUMMON_VALUE_MONSTER_REBORN			=0x13	--死者苏生（千年的启示）
SUMMON_VALUE_LV						=0x1000	--对应LV怪兽的效果
SUMMON_VALUE_GLADIATOR				=0x2000	--剑斗兽
SUMMON_VALUE_EVOLTILE				=0x4000	--进化虫
SUMMON_VALUE_NOUVELLEZ				=0x8000	--新式魔厨
--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	--连锁发生时的守备力
--========== 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_CANNOT_NEGATE	=0x0200		--含有"此效果不會被無效"的敘述
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_COF					=0x20000000 --N/A
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_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			=0x80000000
HALF_DAMAGE				=0x80000001
--Hint Message	--提示消息，显示在窗口的上面
HINTMSG_RELEASE			=500	--请选择要解放的卡
HINTMSG_DISCARD			=501	--请选择要丢弃的手牌
HINTMSG_DESTROY			=502	--请选择要破坏的卡
HINTMSG_REMOVE			=503	--请选择要除外的卡
HINTMSG_TOGRAVE			=504	--请选择要送去墓地的卡
HINTMSG_RTOHAND			=505	--请选择要返回手牌的卡
HINTMSG_ATOHAND			=506	--请选择要加入手牌的卡
HINTMSG_TODECK			=507	--请选择要返回卡组的卡
HINTMSG_SUMMON			=508	--请选择要召唤的卡
HINTMSG_SPSUMMON		=509	--请选择要特殊召唤的卡
HINTMSG_SET				=510	--请选择要盖放的卡
HINTMSG_FMATERIAL		=511	--请选择要作为融合素材的卡
HINTMSG_SMATERIAL		=512	--请选择要作为同调素材的卡
HINTMSG_XMATERIAL		=513	--请选择要作为超量素材的卡
HINTMSG_FACEUP			=514	--请选择表侧表示的卡
HINTMSG_FACEDOWN		=515	--请选择里侧表示的卡
HINTMSG_ATTACK			=516	--请选择攻击表示的怪兽
HINTMSG_DEFENSE			=517	--请选择守备表示的怪兽
HINTMSG_EQUIP			=518	--请选择要装备的卡
HINTMSG_REMOVEXYZ		=519	--请选择要取除的超量素材
HINTMSG_CONTROL			=520	--请选择要改变控制权的怪兽
HINTMSG_DESREPLACE		=521	--请选择要代替破坏的卡
HINTMSG_FACEUPATTACK	=522	--请选择表侧攻击表示的怪兽
HINTMSG_FACEUPDEFENSE	=523	--请选择表侧守备表示的怪兽
HINTMSG_FACEDOWNATTACK	=524	--请选择里侧攻击表示的怪兽
HINTMSG_FACEDOWNDEFENSE	=525	--请选择里侧守备表示的怪兽
HINTMSG_CONFIRM			=526	--请选择给对方确认的卡
HINTMSG_TOFIELD			=527	--请选择要放置到场上的卡
HINTMSG_POSCHANGE		=528	--请选择要改变表示形式的怪兽
HINTMSG_SELF			=529	--请选择自己的卡
HINTMSG_OPPO			=530	--请选择对方的卡
HINTMSG_TRIBUTE			=531	--请选择上级召唤用需要解放的怪兽
HINTMSG_DEATTACHFROM	=532	--请选择要取除超量素材的怪兽
HINTMSG_LMATERIAL   	=533	--请选择要作为连接素材的卡
HINTMSG_ATTACKTARGET	=549	--请选择攻击的对象
HINTMSG_EFFECT			=550	--请选择要发动的效果
HINTMSG_TARGET			=551	--请选择效果的对象
HINTMSG_COIN			=552	--请选择硬币的正反面
HINTMSG_DICE			=553	--请选择骰子的结果
HINTMSG_CARDTYPE		=554	--请选择一个种类
HINTMSG_OPTION			=555	--请选择一个选项
HINTMSG_RESOLVEEFFECT	=556	--请选择要发动/处理的效果
HINTMSG_SELECT			=560	--请选择
HINTMSG_POSITION		=561	--请选择表示形式
HINTMSG_ATTRIBUTE		=562	--请选择要宣言的属性
HINTMSG_RACE			=563	--请选择要宣言的种族
HINTMSG_CODE			=564	--请宣言一个卡名
HINGMSG_NUMBER			=565	--请选择一个数字
HINGMSG_LVRANK			=567	--请宣言一个等级
HINTMSG_RESOLVECARD		=568	--请选择要处理效果的卡
HINTMSG_ZONE			=569	--请选择[%ls]的位置
HINTMSG_DISABLEZONE		=570	--请选择要变成不能使用的卡片区域
HINTMSG_TOZONE			=571	--请选择要移动到的位置
HINTMSG_COUNTER			=572	--请选择要放置指示物的卡
HINTMSG_DISABLE			=573	--请选择要无效的卡
HINTMSG_OPERATECARD		=574	--请选择要操作的卡
--Select	--请选择
SELECT_HEADS				=60	--正面
SELECT_TAILS				=61	--反面
--Timing	--提示时点，可以给freechain卡片增加自动提示时点
TIMING_DRAW_PHASE			=0x1			--抽卡阶段时点
TIMING_STANDBY_PHASE		=0x2        	--准备阶段时点
TIMING_MAIN_END				=0x4        	--主要阶段结束时点
TIMING_BATTLE_START			=0x8        	--战斗阶段开始时点
TIMING_BATTLE_END			=0x10       	--战斗阶段结束时点
TIMING_END_PHASE			=0x20       	--结束阶段时点
TIMING_SUMMON				=0x40       	--召唤时点
TIMING_SPSUMMON				=0x80       	--特殊召唤时点
TIMING_FLIPSUMMON			=0x100      	--翻转召唤时点
TIMING_MSET					=0x200			--放置怪兽时点
TIMING_SSET					=0x400      	--放置魔陷时点
TIMING_POS_CHANGE			=0x800      	--表示形式变更时点
TIMING_ATTACK				=0x1000     	--攻击宣言时点
TIMING_DAMAGE_STEP			=0x2000     	--伤害步骤时点
TIMING_DAMAGE_CAL			=0x4000     	--伤害计算时点
TIMING_CHAIN_END			=0x8000     	--连锁结束时点
TIMING_DRAW					=0x10000    	--抽卡时点（不是抽卡阶段
TIMING_DAMAGE				=0x20000    	--造成伤害时点
TIMING_RECOVER				=0x40000		--回复时点
TIMING_DESTROY				=0x80000    	--破坏时点
TIMING_REMOVE				=0x100000   	--除外时点
TIMING_TOHAND				=0x200000   	--加入手牌时点（检索、回收等）
TIMING_TODECK				=0x400000   	--回卡组时点
TIMING_TOGRAVE				=0x800000   	--进墓地时点
TIMING_BATTLE_PHASE			=0x1000000  	--战斗阶段时点
TIMING_EQUIP				=0x2000000  	--装备时点
TIMING_BATTLE_STEP_END		=0x4000000  	--戰鬥步驟結束時
TIMING_BATTLED				=0x8000000  	--伤害计算后时点
----组合时点
TIMINGS_CHECK_MONSTER       =0x1c0 -- 怪兽正面上场
--Global flag	--特殊标记
GLOBALFLAG_DECK_REVERSE_CHECK	=0x1		--卡组翻转标记
GLOBALFLAG_BRAINWASHING_CHECK	=0x2		--洗脑解除标记
GLOBALFLAG_SCRAP_CHIMERA		=0x4		--废铁奇美拉标记
GLOBALFLAG_DELAYED_QUICKEFFECT	=0x8		--N/A
GLOBALFLAG_DETACH_EVENT			=0x10		--EVENT_DETACH_MATERIAL
GLOBALFLAG_MUST_BE_SMATERIAL	=0x20		--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	--谜题

---@meta

---@class Card
---@field discard_effect Effect
---@field star_knight_summon_effect Effect
Card = {}

---@class Duel
Duel = {}

---@class Effect
Effect = {}

---@class Group
Group = {}

---@class Debug
Debug = {}

-----

---仪式怪兽的解放过滤条件
---@return boolean
---@param c Card
---@param tp integer
function Card.mat_filter(c,tp) end

---素材检查（烙印融合）
---@param tp integer
---@param sg Group
---@param fc Card
function Card.branded_fusion_check(tp,sg,fc) end

---素材检查（电子负载融合）
---@param tp integer
---@param sg Group
---@param fc Card
function Card.cyber_fusion_check(tp,sg,fc) end

---素材检查（破坏剑士融合）
---@param tp integer
---@param sg Group
---@param fc Card
function Card.destruction_swordsman_fusion_check(tp,sg,fc) end

---素材检查（至爱接触）
---@param tp integer
---@param sg Group
---@param fc Card
function Card.hero_fusion_check(tp,sg,fc) end

---素材检查（真红眼融合）
---@param tp integer
---@param sg Group
---@param fc Card
function Card.red_eyes_fusion_check(tp,sg,fc) end

---素材检查（奇迹同调融合）
---@param tp integer
---@param sg Group
---@param fc Card
function Card.synchro_fusion_check(tp,sg,fc) end

---素材检查（究极融合）
---@param tp integer
---@param sg Group
---@param fc Card
function Card.ultimate_fusion_check(tp,sg,fc) end

---当作装备卡装备（异热同心武器）
---@param c Card
---@param tp integer
---@param tc Card
function Card.zw_equip_monster(c,tp,tc) end


---返回c的当前卡号（可能因为效果改变）
---@return integer
---@return integer|nil
---@param c Card
function Card.GetCode(c) end

---返回c的卡片记载的卡号
---@return integer
---@param c Card
function Card.GetOriginalCode(c) end

---返回c规则上的卡号（这张卡规则上当作...使用）
---@return integer
---@return integer
---@param c Card
function Card.GetOriginalCodeRule(c) end

---返回c作为融合素材时的卡号（包括c原本的卡号）
---@return integer
---@return integer|nil
---@return ...|nil
---@param c Card
function Card.GetFusionCode(c) end

---返回c作为link素材的卡号（包括c原本的卡号）
---@return integer
---@return integer|nil
---@return ...|nil
---@param c Card
function Card.GetLinkCode(c) end

---检查c作为融合素材时能否当作卡号为code的卡，额外参数是其他code
---@return boolean
---@param c Card
---@param code integer
---@param ...? integer
function Card.IsFusionCode(c,code,...) end

---检查c作为link素材时能否当作卡号为code的卡，额外参数是其他code
---@return boolean
---@param c Card
---@param code integer
---@param ...? integer
function Card.IsLinkCode(c,code,...) end

---检查c是否是卡名含有setname的卡
---@return boolean
---@param c Card
---@param ... integer
function Card.IsSetCard(c,...) end

---检查c是否是原本卡名含有setname的卡
---@return boolean
---@param c Card
---@param ... integer
function Card.IsOriginalSetCard(c,...) end

---检查c位置变化之前是否是名字含有setname的卡
---@return boolean
---@param c Card
---@param ... integer
function Card.IsPreviousSetCard(c,...) end

---检查c作为融合素材时能否当作名字含有setname的卡
---@return boolean
---@param c Card
---@param ... integer
function Card.IsFusionSetCard(c,...) end

---检查c作为link素材时能否当作名字含有setname的卡
---@return boolean
---@param c Card
---@param ... integer
function Card.IsLinkSetCard(c,...) end

---返回c的当前类型
---@return integer
---@param c Card
function Card.GetType(c) end

---返回c的卡片记载的类型
---@return integer
---@param c Card
function Card.GetOriginalType(c) end

---返回c用作融合素材时的类型（与GetType的区别在于对于魔陷区的怪兽卡，返回其原本类型）
---@return integer
---@param c Card
function Card.GetFusionType(c) end

---返回c用作同调素材时的类型（与GetType的区别在于对于魔陷区的怪兽卡，返回其原本类型）
---@return integer
---@param c Card
function Card.GetSynchroType(c) end

---返回c用作同调素材时的类型（与GetType的区别在于对于魔陷区的怪兽卡，返回其原本类型）
---@return integer
---@param c Card
function Card.GetXyzType(c) end

---返回c用作link素材时的类型（与GetType的区别在于对于魔陷区的怪兽卡，返回其原本类型）
---@return integer
---@param c Card
function Card.GetLinkType(c) end

---返回c的当前等级
---@return integer
---@param c Card
function Card.GetLevel(c) end

---返回c的当前阶级
---@return integer
---@param c Card
function Card.GetRank(c) end

---返回c的连接标记数量
---@return integer
---@param c Card
function Card.GetLink(c) end

---返回c的对于同调怪兽sc的同调用等级
---此函数除了某些特定卡如调节支援士，返回值与Card.GetLevel(c)相同
---@return integer
---@param c Card
---@param sc Card
function Card.GetSynchroLevel(c,sc) end

---返回c的对于仪式怪兽rc仪式解放等级
---此函数除了某些特定卡如仪式供物，返回值与Card.GetLevel(c)相同
---@return integer
---@param c Card
---@param rc Card
function Card.GetRitualLevel(c,rc) end

---返回c的卡片记载的等级
---@return integer
---@param c Card
function Card.GetOriginalLevel(c) end

---返回c的卡片记载的阶级
---@return integer
---@param c Card
function Card.GetOriginalRank(c) end

---检查c对于XYZ怪兽xyzc的XYZ用等级是否是lv
---@return boolean
---@param c Card
---@param xyzc Card
---@param lv integer
function Card.IsXyzLevel(c,xyzc,lv) end

---返回c的左灵摆刻度
---@return integer
---@param c Card
function Card.GetLeftScale(c) end

---返回c的原本的左灵摆刻度
---@return integer
---@param c Card
function Card.GetOriginalLeftScale(c) end

---返回c的右灵摆刻度
---@return integer
---@param c Card
function Card.GetRightScale(c) end

---返回c的原本的右灵摆刻度
---@return integer
---@param c Card
function Card.GetOriginalRightScale(c) end

---返回c的当前灵摆刻度。如果在左灵摆区域则返回左刻度，在右灵摆区域或是不在灵摆区域则返回右刻度
---@return integer
---@param c Card
function Card.GetCurrentScale(c) end

---检查c是否是连接标记为 dir 的卡
---@return boolean
---@param c Card
---@param dir integer
function Card.IsLinkMarker(c,dir) end

---返回c所连接区的卡片组
---@return Group
---@param c Card
function Card.GetLinkedGroup(c) end

---返回c所连接区的怪兽卡数量
---@return integer
---@param c Card
function Card.GetLinkedGroupCount(c) end

---返回c的[以 player 来看的场上的]连接区域
---@return integer
---@param c Card
---@param player? integer default: c:GetControler()
function Card.GetLinkedZone(c,player) end

---返回和c互相连接状态的卡片组
---@return Group
---@param c Card
function Card.GetMutualLinkedGroup(c) end

---返回和c互相连接状态的卡片组的数量
---@return integer
---@param c Card
function Card.GetMutualLinkedGroupCount(c) end

---返回[以 player 来看的]与卡片 c 互相连接的卡 所在的区域
---@return integer
---@param c Card
---@param player? integer default: c:GetControler()
function Card.GetMutualLinkedZone(c,player) end

---检查c是否是连接状态
---@return boolean
---@param c Card
function Card.IsLinkState(c) end

---检查c是否是额外连接状态
---@return boolean
---@param c Card
function Card.IsExtraLinkState(c) end

---返回与c同一纵列的c以外的卡片组，后2个参数会计算卡片c左边 left 列 和右边 right 列的所有卡，
---比如c在中间的格子，那么 c:GetColumnGroup(2,2) 就相当于获取了除场地魔法以外的 场上的所有卡
---@return Group
---@param c Card
---@param left? integer default: 0
---@param right? integer default: 0
function Card.GetColumnGroup(c,left,right) end

---用法同上，只是返回的是卡片的数量
---@return integer
---@param c Card
---@param left? integer default: 0
---@param right? integer default: 0
function Card.GetColumnGroupCount(c,left,right) end

---返回[以 player 来看的] location 范围内与 c 同一纵列[包含左边 left 列和右边 right 列]的区域，
---location 的值是 LOCATION_MZONE,LOCATION_SZONE,LOCATIOIN_ONFIELD
---@return integer
---@param c Card
---@param location integer
---@param left? integer
---@param right? integer
---@param player? integer
function Card.GetColumnZone(c,location,left,right,player) end

---检查与c同一纵列的区域是否全都有卡
---@return boolean
---@param c Card
function Card.IsAllColumn(c) end

---返回c的当前属性
---注：对某些多属性怪兽如光与暗之龙，此函数的返回值可能是几个属性的组合值
---@return integer
---@param c Card
function Card.GetAttribute(c) end

---返回c的卡片记载的属性
---@return integer
---@param c Card
function Card.GetOriginalAttribute(c) end

---返回c[由player融合召唤时]用作融合素材时的属性
---@return integer
---@param c Card
---@param player? integer
function Card.GetFusionAttribute(c,player) end

---返回c[由player连接召唤时]用作连接素材时的属性
---@return integer
---@param c Card
---@param player? integer
function Card.GetLinkAttribute(c,player) end

---检查c在墓地中会变成什么属性。
---第二个参数可选，指示假设送去墓地是由于哪个玩家。
---@return integer
---@param c Card
---@param reasonPlayer? integer
function Card.GetAttributeInGrave(c,reasonPlayer) end

---返回c的当前种族
---注：对某些多种族怪兽如动画效果的魔术猿，此函数的返回值可能是几个种族的组合值
---@return integer
---@param c Card
function Card.GetRace(c) end

---返回c的卡片记载的种族
---@return integer
---@param c Card
function Card.GetOriginalRace(c) end

---返回c[由player连接召唤时]作为连接素材时的种族
---@return integer
---@param c Card
---@param player? integer
function Card.GetLinkRace(c,player) end

---检查c在墓地中会变成什么种族。
---第二个参数可选，指示假设送去墓地是由于哪个玩家。
---@return integer
---@param c Card
---@param reasonPlayer? integer
function Card.GetRaceInGrave(c,reasonPlayer) end

---返回c的当前攻击力
---@return integer
---@param c Card
function Card.GetAttack(c) end

---返回c的原本攻击力
---@return integer
---@param c Card
function Card.GetBaseAttack(c) end

---返回c的卡片记载的攻击力，返回值是负数表示是"?"
---@return integer
---@param c Card
function Card.GetTextAttack(c) end

---返回c的当前守备力
---@return integer
---@param c Card
function Card.GetDefense(c) end

---返回c的原本守备力
---@return integer
---@param c Card
function Card.GetBaseDefense(c) end

---返回c的卡片记载的守备力，返回值是负数表示是"?"
---@return integer
---@param c Card
function Card.GetTextDefense(c) end

---返回c位置变化之前在场上的卡号
---@return integer
---@return integer|nil
---@param c Card
function Card.GetPreviousCodeOnField(c) end

---返回c位置变化之前在场上的类型
---@return integer
---@param c Card
function Card.GetPreviousTypeOnField(c) end

---返回c位置变化之前在场上的等级
---@return integer
---@param c Card
function Card.GetPreviousLevelOnField(c) end

---返回c位置变化之前在场上的阶级
---@return integer
---@param c Card
function Card.GetPreviousRankOnField(c) end

---返回c位置变化之前在场上的属性
---@return integer
---@param c Card
function Card.GetPreviousAttributeOnField(c) end

---返回c位置变化之前在场上的种族
---@return integer
---@param c Card
function Card.GetPreviousRaceOnField(c) end

---返回c位置变化之前在场上的攻击力
---@return integer
---@param c Card
function Card.GetPreviousAttackOnField(c) end

---返回c位置变化之前在场上的守备力
---@return integer
---@param c Card
function Card.GetPreviousDefenseOnField(c) end

---返回c位置变化之前在场上叠放的卡片数量
---@return integer
---@param c Card
function Card.GetPreviousOverlayCountOnField(c) end

---返回c的持有者
---@return integer
---@param c Card
function Card.GetOwner(c) end

---返回c的当前控制者
---@return integer
---@param c Card
function Card.GetControler(c) end

---返回c的位置变化之前的控制者
---@return integer
---@param c Card
function Card.GetPreviousControler(c) end

---设置c来到当前位置的原因为reason
---@return boolean
---@param c Card
---@param reason integer
function Card.SetReason(c,reason) end

---返回c的位置变化原因
---@return integer
---@param c Card
function Card.GetReason(c) end

---返回导致c的位置变化的卡
---此函数仅在某卡被战斗破坏时，因为上级召唤被解放，或者成为特殊召唤使用的素材时有效
---@return Card
---@param c Card
function Card.GetReasonCard(c) end

---返回导致c的位置变化的玩家
---@return integer
---@param c Card
function Card.GetReasonPlayer(c) end

---返回导致c的位置变化的效果
---@return Effect
---@param c Card
function Card.GetReasonEffect(c) end

---返回c当前的表示形式
---@return integer
---@param c Card
function Card.GetPosition(c) end

---返回c位置变化前的表示形式
---@return integer
---@param c Card
function Card.GetPreviousPosition(c) end

---返回c在本次战斗发生之前的表示形式
---@return integer
---@param c Card
function Card.GetBattlePosition(c) end

---返回c当前的所在位置
---@return integer
---@param c Card
function Card.GetLocation(c) end

---返回c位置变化前的所在的位置
---@return integer
---@param c Card
function Card.GetPreviousLocation(c) end

---返回c在当前位置的序号
---在场上时，序号代表所在的格子，从左往右分别是0-4，场地魔法格的序号为5，左右灵摆区域为6-7
---在其它地方时，序号表示的是第几张卡，最下面的卡的序号为0
---@return integer
---@param c Card
function Card.GetSequence(c) end

---返回c位置变化前的序号
---@return integer
---@param c Card
function Card.GetPreviousSequence(c) end

---检查c是否被卡名含有setname的卡特殊召唤
---@return boolean
---@param c Card
---@param ... integer
function Card.IsSpecialSummonSetCard(c,...) end

---返回c的特殊召唤的信息
---SUMMON_INFO_CODE
---SUMMON_INFO_CODE2
---SUMMON_INFO_TYPE
---SUMMON_INFO_LEVEL
---SUMMON_INFO_RANK
---SUMMON_INFO_ATTRIBUTE
---SUMMON_INFO_RACE
---SUMMON_INFO_ATTACK
---SUMMON_INFO_DEFENSE
---SUMMON_INFO_REASON_EFFET
---@return ...
---@param c Card
---@param ... integer
function Card.GetSpecialSummonInfo(c,...) end

---返回c的召唤/特殊召唤的方式
---@return integer
---@param c Card
function Card.GetSummonType(c) end

---返回c的召唤/特殊召唤的位置
---@return integer
---@param c Card
function Card.GetSummonLocation(c) end

---返回召唤/特殊召唤 c 上场的玩家
---@return integer
---@param c Card
function Card.GetSummonPlayer(c) end

---返回c位置变化的目的地
---此函数仅在处理位置转移代替效果时有效
---@return integer
---@param c Card
function Card.GetDestination(c) end

---返回c离场时因改变去向的效果（如大宇宙）的目的地
---@return integer
---@param c Card
function Card.GetLeaveFieldDest(c) end

---返回c转移到当前位置的回合
---@return integer
---@param c Card
function Card.GetTurnID(c) end

---返回c转移到当前位置的时间标识
---此数值唯一，越小表示c是越早出现在那个位置
---卡片从里侧翻开也会改变此数值
---@return integer
---@param c Card
function Card.GetFieldID(c) end

---返回c转移到当前位置的真实的时间标识
---卡片从里侧翻开不会改变此数值
---@return integer
---@param c Card
function Card.GetRealFieldID(c) end

---检查c是否在规则上当做code使用
---@return boolean
---@param c Card
---@param code integer
function Card.IsOriginalCodeRule(c,code) end

---检查c的卡号是否是 code1[, 或者为 code2...]
---@return boolean
---@param c Card
---@param code1 integer
---@param code2? integer
---@param ...? integer
function Card.IsCode(c,code1,code2,...) end

---检查c是否属于类型type
---@return boolean
---@param c Card
---@param type integer
function Card.IsType(c,type) end

---检查c用作融合素材时是否属于类型type（与IsType的区别在于对于魔陷区的怪兽卡，用其原本类型作判断）
---@return boolean
---@param c Card
---@param type integer
function Card.IsFusionType(c,type) end

---检查c用作同调素材时是否属于类型type（与IsType的区别在于对于魔陷区的怪兽卡，用其原本类型作判断）
---@return boolean
---@param c Card
---@param type integer
function Card.IsSynchroType(c,type) end

---检查c用作XYZ素材时是否属于类型type（与IsType的区别在于对于魔陷区的怪兽卡，用其原本类型作判断）
---@return boolean
---@param c Card
---@param type integer
function Card.IsXyzType(c,type) end

---检查c用作连接素材时是否属于类型type（与IsType的区别在于对于魔陷区的怪兽卡，用其原本类型作判断）
---@return boolean
---@param c Card
---@param type integer
function Card.IsLinkType(c,type) end

---检查c是否是等级 level1[, 或者为 level2...]
---@return boolean
---@param c Card
---@param level1 integer
---@param level2? integer
---@param ...? integer
function Card.IsLevel(c,level1,level2,...) end

---检查c是否是阶级 rank1[, 或者为 rank2...]
---@return boolean
---@param c Card
---@param rank1 integer
---@param rank2? integer
---@param ...? integer
function Card.IsRank(c,rank1,rank2,...) end

---检查c的连接标记数量是否是 link1[, 或者为 link2...]
---@return boolean
---@param c Card
---@param link1 integer
---@param link2? integer
---@param ...? integer
function Card.IsLink(c,link1,link2,...) end

---检查c的攻击力是否是 atk1[, 或者为 atk2...]，如果c不是怪兽卡，或者不在 LOCATION_MZONE 则都返回false
---@return boolean
---@param c Card
---@param atk1 integer
---@param atk2? integer
---@param ...? integer
function Card.IsAttack(c,atk1,atk2,...) end

---检查c的守备力是否是 def1[, 或者为 def2...]，如果c不是怪兽卡，或者不在 LOCATION_MZONE 则都返回false
---@return boolean
---@param c Card
---@param def integer
---@param atk2? integer
---@param ...? integer
function Card.IsDefense(c,def,atk2,...) end

---检查c是否属于种族race
---@return boolean
---@param c Card
---@param race integer
function Card.IsRace(c,race) end

---检查c[由player连接召唤时]用作连接素材时是否属于种族race
---@return boolean
---@param c Card
---@param race integer
---@param player? integer
function Card.IsLinkRace(c,race,player) end

---检查c是否属于属性attribute
---@return boolean
---@param c Card
---@param attribute integer
function Card.IsAttribute(c,attribute) end

---检查c[由player融合召唤时]用作融合素材是否属于属性attribute
---@return boolean
---@param c Card
---@param attribute integer
---@param player? integer
function Card.IsFusionAttribute(c,attribute,player) end

---检查c[由player连接召唤时]用作连接素材是否属于属性attribute
---@return boolean
---@param c Card
---@param attribute integer
---@param player? integer
function Card.IsLinkAttribute(c,attribute,player) end

---检查c是否有attribute以外的属性
---（如暗黑神鸟同时具有暗和风属性，not IsAttribute(暗)是false，但IsNonAttribute(暗)是true）
---@return boolean
---@param c Card
---@param attribute integer
function Card.IsNonAttribute(c,attribute) end

---检查c原本是否为融合·同调·XYZ·连接怪兽。这个函数只检查类型，不关心被检查的怪兽的现状。
---@return boolean
---@param c Card
function Card.IsExtraDeckMonster(c) end

---检查c是否包含原因reason
---@return boolean
---@param c Card
---@param reason integer
function Card.IsReason(c,reason) end

---检查c的召唤类型是否是sumtype
---@return boolean
---@param c Card
---@param sumtype integer
function Card.IsSummonType(c,sumtype) end

---检查c召唤·特殊召唤的位置是否为loc
---@return boolean
---@param c Card
---@param loc integer
function Card.IsSummonLocation(c,loc) end

---检查将c召唤·特殊召唤的玩家是否为player
---@return boolean
---@param c Card
---@param player integer
function Card.IsSummonPlayer(c,player) end

---检查c是否包含某个状态码
---@return boolean
---@param c Card
---@param status integer
function Card.IsStatus(c,status) end

---检查c是否可以当成非调整来使用
---@return boolean
---@param c Card
function Card.IsNotTuner(c) end

---检查c是否是调整怪兽。
---除了检查TYPE_TUNER以外，还会检查其身上所有能让其变为调整怪兽的效果。
---@return boolean
---@param c Card
function Card.IsTuner(c) end

---给c设置或者取消状态码
---除非妳清楚的了解每个状态码的含意，否则不要轻易使用此函数
---@param c Card
---@param state integer
---@param enable boolean
function Card.SetStatus(c,state,enable) end

---检查c属否处于再召唤状态
---@return boolean
---@param c Card
function Card.IsDualState(c) end

---把c设置成再召唤状态
---@param c Card
function Card.EnableDualState(c) end

---设置c的回合计数器（光之护封剑等）
---@param c Card
---@param counter integer
function Card.SetTurnCounter(c,counter) end

---返回c的回合计数器
---@return integer
---@param c Card
function Card.GetTurnCounter(c) end

---把g中的所有卡作为c的素材（上级召唤，特殊召唤）
---@param c Card
---@param g Group|nil
function Card.SetMaterial(c,g) end

---返回c出场使用的素材
---@return Group
---@param c Card
function Card.GetMaterial(c) end

---返回c出场使用的素材数量
---@return integer
---@param c Card
function Card.GetMaterialCount(c) end

---返回c当前装备着的卡片组
---@return Group
---@param c Card
function Card.GetEquipGroup(c) end

---返回c当前装备着的卡片数量
---@return integer
---@param c Card
function Card.GetEquipCount(c) end

---返回c当前的装备对象
---@return Card
---@param c Card
function Card.GetEquipTarget(c) end

---返回c之前的装备对象
---@return Card
---@param c Card
function Card.GetPreviousEquipTarget(c) end

---检查c2是否是c1的正确的装备对象
---##由EFFECT_EQUIP_LIMIT效果或同盟状态确定
---@return boolean
---@param c1 Card
---@param c2 Card
function Card.CheckEquipTarget(c1,c2) end

---检查ec是否为c的有效同盟装备对象。会检查EFFECT_UNION_LIMIT影响和新旧同盟影响。
---@return Card
---@param c Card
---@param ec Card
function Card.CheckUnionTarget(c,ec) end

---返回c当前装备的同盟卡数量、旧同盟卡数量
---@return integer
---@return integer
---@param c Card
function Card.GetUnionCount(c) end

---返回c当前叠放着的卡片组
---@return Group
---@param c Card
function Card.GetOverlayGroup(c) end

---返回c当前叠放着的卡片数量
---@return integer
---@param c Card
function Card.GetOverlayCount(c) end

---返回以c为XYZ素材的卡
---@return Card
---@param c Card
function Card.GetOverlayTarget(c) end

---检查玩家player能否以reason为原因，至少移除c叠放的count张卡
---@return boolean
---@param c Card
---@param player integer
---@param count integer
---@param reason integer
function Card.CheckRemoveOverlayCard(c,player,count,reason) end

---以reason为原因，让玩家player移除c叠放的min-max张卡，返回值表示移除的数量
---@return integer
---@param c Card
---@param player integer
---@param min integer
---@param max integer
---@param reason integer
function Card.RemoveOverlayCard(c,player,min,max,reason) end

---返回c本回合攻击过的卡片组
---@return Group
---@param c Card
function Card.GetAttackedGroup(c) end

---返回c本回合攻击过的卡片数量
---@return integer
---@param c Card
function Card.GetAttackedGroupCount(c) end

---返回c本回合攻击过的次数
---注：如果此值与上一个函数的返回值不同，那么说明此卡本回合进行过直接攻击
---@return integer
---@param c Card
function Card.GetAttackedCount(c) end

---返回与c本回合进行过战斗的卡片组
---进行过战斗指发生过伤害的计算，用于剑斗兽等卡的判定
---@return Group
---@param c Card
function Card.GetBattledGroup(c) end

---返回与c本回合进行过战斗的的卡片数量
---@return integer
---@param c Card
function Card.GetBattledGroupCount(c) end

---返回c本回合攻击宣言的次数
---注：攻击被无效不会被计入攻击过的次数，但是会计入攻击宣言的次数
---@return integer
---@param c Card
function Card.GetAttackAnnouncedCount(c) end

---检查c是否直接攻击过
---@return boolean
---@param c Card
function Card.IsDirectAttacked(c) end

---把c2作为c1的永续对象
---c1和c2的联系会在c1或c2任意一卡离场或变成里侧表示时reset
---@param c1 Card
---@param c2 Card
function Card.SetCardTarget(c1,c2) end

---返回c当前所有的永续对象
---@return Group
---@param c Card
function Card.GetCardTarget(c) end

---返回c当前第一个永续对象，没有则返回 nil
---@return Card
---@param c Card
function Card.GetFirstCardTarget(c) end

---返回c当前的永续对象的数量
---@return integer
---@param c Card
function Card.GetCardTargetCount(c) end

---检查c2是否取c1为永续对象
---@return boolean
---@param c1 Card
---@param c2 Card
function Card.IsHasCardTarget(c1,c2) end

---取消c2为c1的永续对象
---@param c1 Card
---@param c2 Card
function Card.CancelCardTarget(c1,c2) end

---返回取c作为永续对象的所有卡
---@return Group
---@param c Card
function Card.GetOwnerTarget(c) end

---返回取c作为永续对象的卡的数量
---@return integer
---@param c Card
function Card.GetOwnerTargetCount(c) end

---返回c的“卡片发动”的效果，即类型为EFFECT_TYPE_ACTIVATE的效果
---仅对魔法和陷阱有效
---@return Effect
---@return ...? Effect
---@param c Card
function Card.GetActivateEffect(c) end

---返回c的可以发动时机正确的“卡的发动”的效果，neglect_con=true则无视发动条件，neglect_cost=true则无视发动cost
---copy_info=false或者自由时点的效果则只返回这个效果 e
---否则还返回这个效果的触发时点的信息 e,eg,ep,ev,re,r,rp
---@return Effect
---@return Group|nil
---@return integer|nil
---@return integer|nil
---@return Effect|nil
---@return integer|nil
---@return integer|nil
---@param c Card
---@param neglect_con boolean
---@param neglect_cost boolean
---@param copy_info boolean
function Card.CheckActivateEffect(c,neglect_con,neglect_cost,copy_info) end

---如果卡片 c 受到同调素材限制效果 EFFECT_TUNER_MATERIAL_LIMIT 影响，则返回 Effect e,function target,int value,int min,int max ;否则返回nil
---@return nil|Effect
---@return function|nil
---@return integer|nil
---@return integer|nil
---@return integer|nil
---@param c Card
function Card.GetTunerLimit(c) end

---如果卡片 c 受到手卡同调效果 EFFECT_HAND_SYNCHRO 影响，则返回 Effect e,function target,int min,int max ;否则返回nil
---@return nil|Effect
---@return function|nil
---@return integer|nil
---@return integer|nil
---@param c Card
function Card.GetHandSynchro(c) end

---把效果e注册给c，返回效果的全局id，并设置e的Handler为c
---默认情况下注册时如果c带有免疫e的效果那么注册会失败
---如果forced为true则不会检查c对e的免疫效果
---@return integer
---@param c Card
---@param e Effect
---@param forced? boolean default: false
function Card.RegisterEffect(c,e,forced) end

---检查c是否受到效果种类是code的效果的影响
---没有则返回nil
---有则返回那些效果
---@return Effect
---@return ...? Effect
---@param c Card
---@param code integer
---@param player? integer
function Card.IsHasEffect(c,code,player) end

---以重置类型为reset_type、重置种类为reset_code手动重置c受到的效果的影响
---reset_type只能是以下类型，对应的重置种类为
---RESET_EVENT       发生事件重置        reset_code为事件
---RESET_PHASE       阶段结束重置        reset_code为阶段
---RESET_CODE        重置指定code的效果  reset_code为效果的种类code，只能重置EFFECT_TYPE_SINGLE的永续型效果
---RESET_COPY        重置复制的效果      reset_code为copy_id
---RESET_CARD        重置卡片的效果      reset_code为效果owner的卡号
---@param c Card
---@param reset_code integer
---@param reset_type integer
function Card.ResetEffect(c,reset_code,reset_type) end

---返回c受到影响的种类是code的效果的数量
---@return integer
---@param c Card
---@param code integer
function Card.GetEffectCount(c,code) end

---为c注册一个标识用效果
---注：注册给卡的标识用效果不会用于系统，
---即使code与内置效果code重合也不会影响，
---并且类型总是EFFECT_TYPE_SINGLE，reset方法，property和一般的效果相同，
---并且不会无效化，不受卡的免疫效果影响
---@return Effect
---@param c Card
---@param code integer
---@param reset_flag integer
---@param property integer
---@param reset_count integer
---@param label? integer
---@param desc? integer
function Card.RegisterFlagEffect(c,code,reset_flag,property,reset_count,label,desc) end

---返回c的种类是code的标识效果的数量
---@return integer
---@param c Card
---@param code integer
function Card.GetFlagEffect(c,code) end

---手动清除c的种类是code的标识效果
---@param c Card
---@param code integer
function Card.ResetFlagEffect(c,code) end

---返回c是否存在种类为code的标识效果，若有则设置第一个的Label属性为label
---@return boolean
---@param c Card
---@param code integer
---@param label integer
function Card.SetFlagEffectLabel(c,code,label) end

---返回c的种类为code的每个标识效果的Label，没有此效果则返回nil
---@return integer
---@return ...? integer
---@param c Card
---@param code integer
function Card.GetFlagEffectLabel(c,code) end

---为c1建立与c2的联系，此联系仅会由于c1发生RESET_EVENT的事件reset
---@param c1 Card
---@param c2 Card
---@param reset_flag integer
function Card.CreateRelation(c1,c2,reset_flag) end

---手动释放c1对于c2的联系
---@param c1 Card
---@param c2 Card
function Card.ReleaseRelation(c1,c2) end

---为卡片c和效果e建立联系
---@param c Card
---@param e Effect
function Card.CreateEffectRelation(c,e) end

---手动释放c与效果e的联系
---@param c Card
---@param e Effect
function Card.ReleaseEffectRelation(c,e) end

---清空c所有联系的效果
---@param c Card
function Card.ClearEffectRelation(c) end

---检查c是否和效果e有联系
---注：每次发动进入连锁的效果时，发动效果的卡，以及发动效果时指定的对象
---（用Duel.SetTargetCard或者Duel.SelectTarget指定的，包括取对象和不取对象）
---会自动与那个效果建立联系，一旦离场，联系会重置
---@return boolean
---@param c Card
---@param e Effect
function Card.IsRelateToEffect(c,e) end

---检查c是否和连锁chainc有联系
---注：每次发动进入连锁的效果时，发动效果的卡，以及发动效果时指定的对象
---（用Duel.SetTargetCard或者Duel.SelectTarget指定的，包括取对象和不取对象）
---会自动与那个效果建立联系，一旦离场，联系会重置
---@return boolean
---@param c Card
---@param chainc? integer default: 0
function Card.IsRelateToChain(c,chainc) end

---检查c1是否和c2有联系
---@return boolean
---@param c1 Card
---@param c2 Card
function Card.IsRelateToCard(c1,c2) end

---检查c是否和本次战斗关联
---注：此效果通常用于伤害计算后伤害阶段结束前，用于检查战斗的卡是否离场过
---@return boolean
---@param c Card
function Card.IsRelateToBattle(c) end

---为c添加卡号是code的卡的可复制的效果，并且添加额外的reset条件
---返回值是表示复制效果的代号id
---@return integer
---@param c Card
---@param code integer
---@param reset_flag integer
---@param reset_count? integer default: 1
function Card.CopyEffect(c,code,reset_flag,reset_count) end

---把c的效果替换为卡号是code的卡的效果，并且添加额外的reset条件
---返回值是表示替换效果的代号id
---@return integer
---@param c Card
---@param code integer
---@param reset_flag integer
---@param reset_count? integer default: 1
function Card.ReplaceEffect(c,code,reset_flag,reset_count) end

---为c添加苏生限制
---##实际上是不可复制、不会被无效的EFFECT_UNSUMMONABLE_CARD和EFFECT_REVIVE_LIMIT效果
---@param c Card
function Card.EnableReviveLimit(c) end

---使c完成正规的召唤手续
---##此函数也可通过 c:SetStatus(STATUS_PROC_COMPLETE,true)实现
---@param c Card
function Card.CompleteProcedure(c) end

---检查c是否处于无效状态
---@return boolean
---@param c Card
function Card.IsDisabled(c) end

---检查c是否是可被[效果 e]破坏的
---@return boolean
---@param c Card
---@param e? Effect
function Card.IsDestructable(c,e) end

---检查c是否是可通常召唤的卡
---@return boolean
---@param c Card
function Card.IsSummonableCard(c) end

---检查c是否能以正规方法特殊召唤。
---c必须有可特殊召唤的方式。
---@return boolean
---@param c Card
function Card.IsSpecialSummonableCard(c) end

---检查c是否是可[用 sum_type 方式]融合召唤的卡
---@return boolean
---@param c Card
---@param sum_type? integer
function Card.IsFusionSummonableCard(c,sum_type) end

---检查是否可以对c[用 sum_type 方式]进行特殊召唤手续
---@return boolean
---@param c Card
---@param sum_type? integer
function Card.IsSpecialSummonable(c,sum_type) end

---检查是否可以以tuner作为调整，场上的卡[或mg]为同调素材对c进行同调召唤手续
---如果tuner是nil，此函数与Card.IsSpecialSummonable作用相同
---@return boolean
---@param c Card
---@param tuner Card|nil
---@param mg? Group
function Card.IsSynchroSummonable(c,tuner,mg) end

---检查是否可以在场上的卡[或mg][中选出 min-max 个XYZ素材]对c进行XYZ召唤手续
---如果mg为nil，此函数与 c:IsSpecialSummonable(SUMMON_TYPE_XYZ)作用相同
---@return boolean
---@param c Card
---@param mg Group|nil
---@param min? integer default: 0
---@param max? integer default: 0
function Card.IsXyzSummonable(c,mg,min,max) end

---检查是否可以在场上的卡[或mg][中选出 min-max 个连接素材]对c进行连接召唤手续
---如果mg为nil，此函数与 c:IsSpecialSummonable(SUMMON_TYPE_LINK)作用相同
---@return boolean
---@param c Card
---@param mg Group|nil
---@param min? integer default: 0
---@param max? integer default: 0
function Card.IsLinkSummonable(c,mg,min,max) end

---检查c是否可以进行通常召唤（不包含通常召唤的set)，ignore_count=true则不检查召唤次数限制
---e~=nil则检查c是否可以以效果e进行通常召唤，min表示至少需要的祭品数（用于区分妥协召唤与上级召唤）,zone 表示必须要召唤到的区域
---@return boolean
---@param c Card
---@param ignore_count boolean
---@param e Effect|nil
---@param min? integer default: 0
---@param zone? integer default: 0x1f
function Card.IsSummonable(c,ignore_count,e,min,zone) end

---检查c是否可进行通常召唤的set，ignore_count=true则不检查召唤次数限制
---e~=nil则检查c是否可以以效果e进行通常召唤的set，min表示至少需要的祭品数（用于区分妥协召唤set与上级召唤set）,zone 表示必须要放置到的区域
---@return boolean
---@param c Card
---@param ignore_count boolean
---@param e Effect|nil
---@param min? integer default: 0
---@param zone? integer default: 0x1f
function Card.IsMSetable(c,ignore_count,e,min,zone) end

---检查c是否可以set到魔法陷阱区，ignore_field=true则无视魔陷区格子是否能使用的限制
---@return boolean
---@param c Card
---@param ignore_field? boolean default: false
function Card.IsSSetable(c,ignore_field) end

---检查c是否可以被玩家sumplayer用效果e[以sumtype方式和sumpos表示形式]特殊召唤[到玩家 toplayer 的区域zone]
---如果nocheck是true则不检查c的召唤条件，如果nolimit是true则不检查c的苏生限制
---@return boolean
---@param c Card
---@param e Effect
---@param sumtype integer
---@param sumplayer integer
---@param nocheck boolean
---@param nolimit boolean
---@param sumpos? integer default: POS_FACEUP
---@param toplayer? integer default: sumplayer
---@param zone? integer default: 0xff
function Card.IsCanBeSpecialSummoned(c,e,sumtype,sumplayer,nocheck,nolimit,sumpos,toplayer,zone) end

---检查c是否可以送去手卡
---注：仅当卡片或者玩家受到“不能加入手卡”的效果的影响时（如雷王）此函数才返回false
---##以下几个函数类似
---@return boolean
---@param c Card
function Card.IsAbleToHand(c) end

---检查c是否可以送去卡组
---@return boolean
---@param c Card
function Card.IsAbleToDeck(c) end

---检查c是否可以送去额外卡组
---对于非融合、同调等额外怪兽或者非灵摆怪兽此函数均返回false
---@return boolean
---@param c Card
function Card.IsAbleToExtra(c) end

---检查c是否可以送去墓地
---@return boolean
---@param c Card
function Card.IsAbleToGrave(c) end

---检查c是否可以被玩家player除外
---@return boolean
---@param c Card
---@param player? integer
---@param pos? integer
---@param reason? integer
function Card.IsAbleToRemove(c,player,pos,reason) end

---检查c是否可以作为cost送去手卡
---注：此函数会在Card.IsAbleToHand的基础上追加检测c的实际目的地
---当c送往手卡会被送去其它地方时（如缩退回路适用中，或者c是融合、同调 等额外怪兽的一种），此函数返回false
---##以下几个函数类似
---@return boolean
---@param c Card
function Card.IsAbleToHandAsCost(c) end

---检查c是否可以作为cost送去卡组
---@return boolean
---@param c Card
function Card.IsAbleToDeckAsCost(c) end

---检查c是否可以作为cost送去额外卡组，主卡组的灵摆卡会返回false
---@return boolean
---@param c Card
function Card.IsAbleToExtraAsCost(c) end

---检查c是否可以作为cost送去卡组或额外卡组（用于新宇侠、剑斗兽融合怪兽的召唤手续检测）等价于 (c:IsAbleToDeckAsCost() or c:IsAbleToExtraAsCost())
---@return boolean
---@param c Card
function Card.IsAbleToDeckOrExtraAsCost(c) end

---检查c是否可以作为cost送去墓地
---@return boolean
---@param c Card
function Card.IsAbleToGraveAsCost(c) end

---检查c是否可以作为cost除外
---@return boolean
---@param c Card
function Card.IsAbleToRemoveAsCost(c) end

---检查c是否可以被以原因reason解放（非上级召唤用）
---@return boolean
---@param c Card
---@param reason? integer default: REASON_COST
function Card.IsReleasable(c,reason) end

---检查c是否可以被效果解放
---@return boolean
---@param c Card
function Card.IsReleasableByEffect(c) end

---检查c是否可以以reason原因丢弃
---注：此函数仅用于检测，
---以REASON_DISCARD作为原因把一张手卡送墓并不会导致那张卡不能丢弃
---@return boolean
---@param c Card
---@param reason? integer default: REASON_COST
function Card.IsDiscardable(c,reason) end

---检查c是否可以攻击
---@return boolean
---@param c Card
function Card.IsAttackable(c) end

---检查c是否可以连续攻击，c的攻击宣言次数>=ac则返回false
---monsteronly = true 则表示只能对怪兽攻击
---注：当c因为闪光之双剑等效果进行过多次攻击之后此函数返回false
---@return boolean
---@param c Card
---@param ac? integer
---@param monsteronly? boolean
function Card.IsChainAttackable(c,ac,monsteronly) end

---检查c是否是表侧表示
---@return boolean
---@param c Card
function Card.IsFaceup(c) end

---检查c是否是表侧表示，在手卡墓地主卡组等处始终返回true
---@return boolean
---@param c Card
function Card.IsFaceupEx(c) end

---检查c是否是攻击表示
---@return boolean
---@param c Card
function Card.IsAttackPos(c) end

---检查c是否是里侧表示
---@return boolean
---@param c Card
function Card.IsFacedown(c) end

---检查c是否是守备表示
---@return boolean
---@param c Card
function Card.IsDefensePos(c) end

---检查c是否是表示形式pos
---@return boolean
---@param c Card
---@param pos integer
function Card.IsPosition(c,pos) end

---检查c位置变化之前是否是表示形式pos
---@return boolean
---@param c Card
---@param pos integer
function Card.IsPreviousPosition(c,pos) end

---检查c的当前控制着是否是controler
---@return boolean
---@param c Card
---@param controler integer
function Card.IsControler(c,controler) end

---检查c的上一个控制者是否为player
---@return boolean
---@param c Card
---@param player integer
function Card.IsPreviousControler(c,player) end

---检查c是否在场
---注：当怪兽召唤，反转召唤，特殊召唤时召唤成功之前，此函数返回false
---@return boolean
---@param c Card
function Card.IsOnField(c) end

---检查c当前位置是否是location
---注：当怪兽召唤，反转召唤，特殊召唤时召唤成功之前，
---并且location=LOCATION_MZONE时，此函数返回false
---@return boolean
---@param c Card
---@param location integer
function Card.IsLocation(c,location) end

---检查c之前的位置是否是location
---@return boolean
---@param c Card
---@param location integer
function Card.IsPreviousLocation(c,location) end

---检查c是否是等级level以下（至少为1）
---@return boolean
---@param c Card
---@param level integer
function Card.IsLevelBelow(c,level) end

---检查c是否是等级level以上
---@return boolean
---@param c Card
---@param level integer
function Card.IsLevelAbove(c,level) end

---检查c是否是阶级rank以下（至少为1）
---@return boolean
---@param c Card
---@param rank integer
function Card.IsRankBelow(c,rank) end

---检查c是否是阶级rank以上
---@return boolean
---@param c Card
---@param rank integer
function Card.IsRankAbove(c,rank) end

---检查c是否连接标记数量是link以下（至少为1）
---@return boolean
---@param c Card
---@param link integer
function Card.IsLinkBelow(c,link) end

---检查c是否连接标记数量是link以上
---@return boolean
---@param c Card
---@param link integer
function Card.IsLinkAbove(c,link) end

---检查c是否是攻击力atk以下（至少为0）
---@return boolean
---@param c Card
---@param atk integer
function Card.IsAttackBelow(c,atk) end

---检查c是否是攻击力atk以上
---@return boolean
---@param c Card
---@param atk integer
function Card.IsAttackAbove(c,atk) end

---检查c是否是守备力def以下（至少为0）
---@return boolean
---@param c Card
---@param def integer
function Card.IsDefenseBelow(c,def) end

---检查c是否是守备力def以上
---@return boolean
---@param c Card
---@param def integer
function Card.IsDefenseAbove(c,def) end

---检查c是否处于公开状态
---@return boolean
---@param c Card
function Card.IsPublic(c) end

---检查c是否处于被宣言禁止状态
---@return boolean
---@param c Card
function Card.IsForbidden(c) end

---检查c是否可以改变控制权
---注：仅当卡收到了“不能改变控制权”的效果的影响时，此函数返回false
---@return boolean
---@param c Card
function Card.IsAbleToChangeControler(c) end

---检查c的控制权是否可以改变。
---ignore_mzone=true 会忽视转移控制权后的玩家场上是否有空格位， zone 表示必须要使用的位置
---@return boolean
---@param c Card
---@param ignore_mzone? boolean default: false
---@param zone? integer default: 0xff
function Card.IsControlerCanBeChanged(c,ignore_mzone,zone) end

---为c放置count个countertype类型的指示物，singly为true表示逐个添加至上限为止
---@return boolean
---@param c Card
---@param countertype integer
---@param count integer
---@param singly? integer default: false
function Card.AddCounter(c,countertype,count,singly) end

---让玩家player以原因reason移除c上的count个countertype类型的指示物， countertype=0 则清除c的所有指示物
---@param c Card
---@param player integer
---@param countertype integer
---@param count integer
---@param reason integer
function Card.RemoveCounter(c,player,countertype,count,reason) end

---返回c上的countertype类型的指示物的数量， countertype=0 则返回c上所有类型的指示物数量之和
---@return integer
---@param c Card
---@param countertype integer
function Card.GetCounter(c,countertype) end

---允许c[在位置location]放置那个需要“可以放置”才能放置的指示物countertype
---location的默认值与c的种类有关，灵摆怪兽需要指定能否在怪兽区域或灵摆区域放置指示物
---@param c Card
---@param countertype integer
---@param location? integer
function Card.EnableCounterPermit(c,countertype,location) end

---设定c放置countertype类型指示物的上限
---@param c Card
---@param countertype integer
---@param count integer
function Card.SetCounterLimit(c,countertype,count) end

---检查c是否可以用效果改变表示形式
---@return boolean
---@param c Card
function Card.IsCanChangePosition(c) end

---检查c是否可以转成里侧表示
---@return boolean
---@param c Card
function Card.IsCanTurnSet(c) end

---检查c是否可以[逐个(singly=true)在 location 区域]放置count个countertype类型的指示物
---@return boolean
---@param c Card
---@param countertype integer
---@param count integer
---@param singly? integer default: false
---@param location? integer
function Card.IsCanAddCounter(c,countertype,count,singly,location) end

---检查玩家player是否可以以原因reason移除c上的count个countertype类型的指示物
---@return boolean
---@param c Card
---@param player integer
---@param countertype integer
---@param count integer
---@param reason integer
function Card.IsCanRemoveCounter(c,player,countertype,count,reason) end

---检查c上是否可以放置countertype类型的指示物
---@return boolean
---@param c Card
---@param countertype integer
function Card.IsCanHaveCounter(c,countertype) end

---检查c是否可以作为XYZ素材
---@return boolean
---@param c Card
---@param player? integer
function Card.IsCanOverlay(c,player) end

---检查c是否可以成为[融合怪兽fc的]融合素材
---@return boolean
---@param c Card
---@param fc? Card
function Card.IsCanBeFusionMaterial(c,fc) end

---检查c是否可以成为[以 tuner 为调整的同调怪兽sc的]同调素材
---@return boolean
---@param c Card
---@param sc? Card
---@param tuner? Card
function Card.IsCanBeSynchroMaterial(c,sc,tuner) end

---检查c是否可以作为[仪式怪兽sc的]仪式素材,没有指定sc的场合，必须填nil
---@return boolean
---@param c Card
---@param sc Card|nil
function Card.IsCanBeRitualMaterial(c,sc) end

---检查c是否可以成为[XYZ怪兽sc的]XYZ素材,没有指定sc的场合，必须填nil
---@return boolean
---@param c Card
---@param sc Card|nil
function Card.IsCanBeXyzMaterial(c,sc) end

---检查c是否可以成为[连接怪兽sc的]连接素材,没有指定sc的场合，必须填nil
---@return boolean
---@param c Card
---@param sc Card|nil
function Card.IsCanBeLinkMaterial(c,sc) end

---检查场上[或g]是否包含了c需要[必须包含gc在内]的一组融合素材
---##根据c的种类为EFFECT_FUSION_MATERIAL的效果的Condition函数检查
---@return boolean
---@param c Card
---@param g? Group|nil
---@param gc? Card|nil
---@param chkf? integer default: PLAYER_NONE
---@param not_material? boolean default: false
function Card.CheckFusionMaterial(c,g,gc,chkf,not_material) end

---检查c能否代替融合怪兽fc的记述卡名的素材
---@return boolean
---@param c Card
---@param fc Card
function Card.CheckFusionSubstitute(c,fc) end

---检查c是否免疫效果e（即不受效果e的影响）
---@return boolean
---@param c Card
---@param e Effect
function Card.IsImmuneToEffect(c,e) end

---检查c的效果是否能被e无效。
---已经被无效的卡，或原本就没有效果的卡，或不受e影响的卡不能被无效。
---第三个参数可选，指示其是否为怪兽效果。
---@return boolean
---@param c Card
---@param e Effect
---@param isMonsterEffect? boolean
function Card.IsCanBeDisabledByEffect(c,e,isMonsterEffect) end

---检查c是否可以成为效果[e的]对象
---@return boolean
---@param c Card
---@param e? Effect
function Card.IsCanBeEffectTarget(c,e) end

---检查c1是否可以成为c2的攻击目标
---@return boolean
---@param c1 Card
---@param c2 Card
function Card.IsCanBeBattleTarget(c1,c2) end

---为魔陷卡c添加怪兽数值,type 为怪兽类型，不能是没有等级的怪兽
---注：在数据库中有记录的数值视为原本数值
---@param c Card
---@param type integer
---@param attribute? integer
---@param race? integer
---@param level? integer
---@param atk? integer
---@param def? integer
function Card.AddMonsterAttribute(c,type,attribute,race,level,atk,def) end

---取消送墓确定状态，cancel=false则重新设置送墓确定状态
---注：送墓确定状态指的是在场上发动的不留场的魔法和陷阱后，这些卡片的状态
---送墓确定状态中的卡无法返回手卡和卡组，并且连锁结束时送去墓地
---此函数的作用是取消此状态使其留场，用于光之护封剑和废铁稻草人等卡
---@param c Card
---@param cancel? boolean default: true
function Card.CancelToGrave(c,cancel) end

---返回通常召唤c所需要的祭品的最小和最大数量
---@return integer
---@return integer
---@param c Card
function Card.GetTributeRequirement(c) end

---返回与c进行战斗的卡，没有则返回nil
---@return Card
---@param c Card
function Card.GetBattleTarget(c) end

---返回c可攻击的卡片组以及能否直接攻击
---@return Group
---@return boolean
---@param c Card
function Card.GetAttackableTarget(c) end

---为c设置类型为type的卡片提示信息
---type只能为以下值，对应的value类型为
---CHINT_TURN              回合数
---CHINT_CARD              卡片id
---CHINT_RACE              种族
---CHINT_ATTRIBUTE         属性
---CHINT_NUMBER            数字
---CHINT_DESC              描述
---@param c Card
---@param type integer
---@param value integer
function Card.SetHint(c,type,value) end

---设置c在卡组中正面表示（POS_FACEUP_DEFENSE）
---@param c Card
function Card.ReverseInDeck(c) end

---设置c以unique_code只能在场上[或怪兽区域或魔陷区域，由unique_location决定]只能存在1张,function 的返回值类型必须是int
---s不为0会检查自己场上的唯一性，o不为0则检查对方场上的唯一性
---@param c Card
---@param s integer
---@param o integer
---@param unique_code function|integer
---@param unique_location? integer default: LOCATIOIN_ONFIELD
function Card.SetUniqueOnField(c,s,o,unique_code,unique_location) end

---检查c在check_player场上的唯一性
---@return boolean
---@param c Card
---@param check_player integer
---@param check_location? integer default: LOCATION_ONFIELD
---@param icard? Card|nil
function Card.CheckUniqueOnField(c,check_player,check_location,icard) end

---重置c受到的卡号为code1[, code2...]的卡片的效果的影响
---@param c Card
---@param code1? integer
---@param ...? any
function Card.ResetNegateEffect(c,code1,...) end

---把c的assume_type的数值当作assume_value使用（基因组斗士）
---@param c Card
---@param assume_type integer
---@param assume_value integer
function Card.AssumeProperty(c,assume_type,assume_value) end

---设置c一回合只能进行1次特殊召唤（灵兽，波动龙）
---相同的spsummon_code共用1个次数
---@param c Card
---@param spsummon_code integer
function Card.SetSPSummonOnce(c,spsummon_code) end

---设置全局标记global_flag
---@param global_flag integer
function Duel.EnableGlobalFlag(global_flag) end

---返回玩家player的当前LP
---@return integer
---@param player integer
function Duel.GetLP(player) end

---设置玩家player的当前LP为lp
---@param player integer
---@param lp integer
function Duel.SetLP(player,lp) end

---返回当前的回合玩家是否为playerid
---@return boolean
---@param playerid integer
function Duel.IsTurnPlayer(playerid) end

---返回当前的回合玩家
---@return integer
function Duel.GetTurnPlayer() end

---返回[player所经过的]当前的回合数
---@return integer
---@param player? integer
function Duel.GetTurnCount(player) end

---返回玩家player每回合的规则抽卡数量
---@return integer
---@param player integer
function Duel.GetDrawCount(player) end

---把效果e作为玩家player的效果注册给全局环境
---@param e Effect
---@param player integer
function Duel.RegisterEffect(e,player) end

---为玩家player注册全局环境下的标识效果，并返回这个效果
---此效果总是影响玩家的(EFFECT_FLAG_PLAYER_TARGET)并且不会被无效化
---其余部分与Card.RegisterFlagEffect相同
---@return Effect
---@param player integer
---@param code integer
---@param reset_flag integer
---@param property integer
---@param reset_count integer default: 1
---@param label? integer
function Duel.RegisterFlagEffect(player,code,reset_flag,property,reset_count,label) end

---返回玩家 player 的 code 标识效果的数量
---@return integer
---@param player integer
---@param code integer
function Duel.GetFlagEffect(player,code) end

---手动reset玩家player的 code 标识效果
---@param player integer
---@param code integer
function Duel.ResetFlagEffect(player,code) end

---返回player是否存在种类为code的标识效果，若有则设置第一个的Label属性为label
---@return boolean
---@param player integer
---@param code integer
---@param label integer
function Duel.SetFlagEffectLabel(player,code,label) end

---返回玩家player的种类为code的每个标识效果的Label，没有此效果则返回nil
---@return integer
---@return ...? integer
---@param player integer
---@param code integer
function Duel.GetFlagEffectLabel(player,code) end

---以reason原因破坏targets去dest，返回值是实际被破坏的数量
---如果reason包含REASON_RULE，则破坏事件将不会检查卡片是否免疫效果，
---不会触发代破效果并且无视“不能破坏”
---如果设置reason_player，则视为被玩家reason_player移动
---@return integer
---@param targets Card|Group
---@param reason integer
---@param dest? integer
---@param reason_player? integer
function Duel.Destroy(targets,reason,dest,reason_player) end

---以reason原因，pos表示形式除外targets，返回值是实际被操作的数量
---如果reason包含REASON_TEMPORARY，那么视为是暂时除外，可以通过Duel.ReturnToField返回到场上
---如果设置reason_player，则视为被玩家reason_player移动
---@return integer
---@param targets Card|Group
---@param pos integer
---@param reason integer
---@param reason_player? integer
function Duel.Remove(targets,pos,reason,reason_player) end

---以reason原因把targets送去墓地，返回值是实际被操作的数量
---如果设置reason_player，则视为被玩家reason_player移动
---@return integer
---@param targets Card|Group
---@param reason integer
---@param reason_player? integer
function Duel.SendtoGrave(targets,reason,reason_player) end

---以reason原因把targets送去玩家player的手卡，返回值是实际被操作的数量
---如果player是nil则返回卡的持有者的手卡
---如果设置reason_player，则视为被玩家reason_player移动
---@return integer
---@param targets Card|Group
---@param player integer|nil
---@param reason integer
---@param reason_player? integer
function Duel.SendtoHand(targets,player,reason,reason_player) end

---以reason原因把targets送去玩家player的卡组，返回值是实际被操作的数量
---如果player是nil则返回卡的持有者的卡组
---如果seq=0，则是返回卡组最顶端；seq=1则是返回卡组最底端；
---其余情况则是返回最顶端并且标记需要洗卡组
---如果设置reason_player，则视为被玩家reason_player移动
---如果设置send_activating，则可以移动发动中的魔法陷阱卡
---@return integer
---@param targets Card|Group
---@param player integer|nil
---@param seq integer
---@param reason integer
---@param reason_player? integer
---@param send_activating? boolean
function Duel.SendtoDeck(targets,player,seq,reason,reason_player,send_activating) end

---以reason原因把灵摆卡targets表侧表示送去玩家player的额外卡组，返回值是实际被操作的数量
---如果player是nil则返回卡的持有者的额外卡组
---@return integer
---@param targets Card|Group
---@param player integer|nil
---@param reason integer
function Duel.SendtoExtraP(targets,player,reason) end

---此函数返回之前一次卡片操作实际操作的卡片组。包括
---Duel.Destroy, Duel.Remove, Duel.SendtoGrave, 
---Duel.SendtoHand, Duel.SendtoDeck, Duel.SendtoExtraP, Duel.Release, 
---Duel.ChangePosition, Duel.SpecialSummon, Duel.DiscardDeck
---@return Group
function Duel.GetOperatedGroup() end

---让玩家 player 以效果e对c[在区域 zone]进行通常召唤(非set)，至少使用min个祭品
---如果e=nil,那么就按照一般的通常召唤规则进行通常召唤
---如果ignore_count=true，则忽略每回合的通常召唤次数限制
---@param player integer
---@param c Card
---@param ignore_count boolean
---@param e Effect|nil
---@param min? integer default: 0
---@param zone? integer default: 0x1f
function Duel.Summon(player,c,ignore_count,e,min,zone) end

---让玩家player对c[用 sumtype 方式]进行特殊召唤手续（？）
---@param player integer
---@param c Card
---@param sumtype? integer default: 0
function Duel.SpecialSummonRule(player,c,sumtype) end

---让玩家player以tuner作为调整,场上的卡[或mg]为素材，对c进行同调召唤手续
---@param player integer
---@param c Card
---@param tuner Card|nil
---@param mg? Group|nil
---@param minc? integer default: 0
---@param maxc? integer default: 0
function Duel.SynchroSummon(player,c,tuner,mg,minc,maxc) end

---让玩家player用场上的卡[或mg][选min-max个素材]对c进行XYZ召唤手续
---mg非空且min为0则直接把mg全部作为XYZ素材
---@param player integer
---@param c Card
---@param mg Group|nil
---@param min? integer default: 0
---@param max? integer default: 0
function Duel.XyzSummon(player,c,mg,min,max) end

---让玩家player以mg[中除lcard以外的最少minc，最多maxc张卡]为素材将pcard连接召唤。
---@param player integer
---@param pcard Card
---@param mg Group|nil
---@param lcard? Card
---@param minc? integer
---@param maxc? integer
function Duel.LinkSummon(player,pcard,mg,lcard,minc,maxc) end

---让玩家 player 以效果e对c[在区域 zone]进行通常召唤的Set，至少使用min个祭品
---如果e=nil,那么就按照一般的通常召唤规则进行通常召唤
---如果ignore_count=true，则忽略每回合的通常召唤次数限制
---@param player integer
---@param c Card
---@param ignore_count boolean
---@param e Effect|nil
---@param min? integer default: 0
---@param zone? integer default: 0x1f
function Duel.MSet(player,c,ignore_count,e,min,zone) end

---让玩家player把targets盖放到target_player的魔法陷阱区， confirm 表示是否需要确认
---若targets为Group，则返回成功操作的数量
---@return integer
---@param player integer
---@param targets Card|Group
---@param target_player? integer default: player
---@param confirm? boolean default: true
function Duel.SSet(player,targets,target_player,confirm) end

---根据code新建一个衍生物并返回，该衍生物的拥有者为player
---@return Card
---@param player integer
---@param code integer
function Duel.CreateToken(player,code) end

---让玩家 sumplayer 以sumtype方式，pos表示形式把targets特殊召唤到target_player场上[的区域 zone]
---如果nocheck为true则无视卡的召唤条件，如果nolimit为true则无视卡的苏生限制
---返回值是特殊召唤成功的卡的数量
---@return integer
---@param targets Card|Group
---@param sumtype integer
---@param sumplayer integer
---@param target_player integer
---@param nocheck boolean
---@param nolimit boolean
---@param pos integer
---@param zone? integer default: 0xff
function Duel.SpecialSummon(targets,sumtype,sumplayer,target_player,nocheck,nolimit,pos,zone) end

---此函数是Duel.SpecialSummon的分解过程，只特殊召唤一张卡c ，其他参数用法和 Duel.SpecialSummon 一样
---此函数用于一个效果同时特殊召唤多张参数不同的卡
---此函数必须和Duel.SpecialSummonComplete一起使用
---返回值表示是否特殊召唤成功
---@return boolean
---@param c Card
---@param sumtype integer
---@param sumplayer integer
---@param target_player integer
---@param nocheck boolean
---@param nolimit boolean
---@param pos integer
---@param zone? integer default: 0xff
function Duel.SpecialSummonStep(c,sumtype,sumplayer,target_player,nocheck,nolimit,pos,zone) end

---此函数在确定复数个Duel.SpecialSummonStep调用完毕之后调用，用于触发事件
---@return nil|integer
function Duel.SpecialSummonComplete() end

---检查玩家player能否向卡片c添加count个countertype类型的指示物，如果 player 不是 0或者1，则返回false
---@return boolean
---@param player integer
---@param countertype? integer
---@param count? integer
---@param c? Card
function Duel.IsCanAddCounter(player,countertype,count,c) end

---让玩家player以reason为原因移除场上存在的countertype类型的count个指示物，返回值表示是否成功
---s表示对player来说的己方的可移除指示物的位置，o表示对player来说的对方的可移除指示物的位置
---@return boolean
---@param player integer
---@param s integer
---@param o integer
---@param countertype integer
---@param count integer
---@param reason integer
function Duel.RemoveCounter(player,s,o,countertype,count,reason) end

---检查玩家player以reason为原因是否能移除场上的countertype类型的count个指示物
---s表示对player来说的己方的可移除指示物的位置，o表示对player来说的对方的可移除指示物的位置
---@return boolean
---@param player integer
---@param s integer
---@param o integer
---@param countertype integer
---@param count integer
---@param reason integer
function Duel.IsCanRemoveCounter(player,s,o,countertype,count,reason) end

---返回场上存在的countertype类型的指示物的数量
---s表示对player来说的己方的可移除指示物的位置，o表示对player来说的对方的可移除指示物的位置
---@return integer
---@param player integer
---@param s integer
---@param o integer
---@param countertype integer
function Duel.GetCounter(player,s,o,countertype) end

---改变targets的表示形式返回实际操作的数量，若只有2个参数，则不管什么表示形式，都变成 第二个参数 代表的形式
---表侧攻击表示 = au
---里侧攻击表示 = ad
---表侧守备表示 = du
---里侧守备表示 = dd
---如果noflip=true则不触发反转效果（但会触发反转时的诱发效果）
---如果setavailable=true则对象之后变成里侧也发动反转效果
---@return integer
---@param targets Card|Group
---@param au integer
---@param ad? integer default: au
---@param du? integer default: au
---@param dd? integer default: au
---@param noflip? boolean default: false
---@param setavailable? boolean default: false
function Duel.ChangePosition(targets,au,ad,du,dd,noflip,setavailable) end

---以reason原因解放targets ，返回值是实际解放的数量
---如果reason含有REASON_COST，则不会检查卡片是否不受效果影响
---如果设置reason_player，则视为被玩家reason_player移动
---@return integer
---@param targets Card|Group
---@param reason integer
---@param reason_player? integer
function Duel.Release(targets,reason,reason_player) end

---让玩家move_player把c移动的target_player的场上，返回值表示是否成功
---dest只能是LOCATION_MZONE或者LOCATION_SZONE，pos表示可选表示形式， enable 表示是否立刻适用c的效果
---@return boolean
---@param c Card
---@param move_player integer
---@param target_player integer
---@param dest integer
---@param pos integer
---@param enable boolean
---@param zone? integer
function Duel.MoveToField(c,move_player,target_player,dest,pos,enable,zone) end

---把c以表示形式pos返回到场上[的区域 zone]，pos默认值是离场前的表示形式，返回值表示是否成功
---c必须是以REASON_TEMPORARY原因离场，并且离场后没有离开过那个位置
---@return boolean
---@param c Card
---@param pos? integer
---@param zone? integer default: 0xff
function Duel.ReturnToField(c,pos,zone) end

---移动c的序号，通常用于在场上换格子或者在卡组中移动到最上方或者最下方
---@param c Card
---@param seq integer
function Duel.MoveSequence(c,seq) end

---交换c1和c2的位置
---@param c1 Card
---@param c2 Card
function Duel.SwapSequence(c1,c2) end

---发动效果e（？）
---@param e Effect
function Duel.Activate(e) end

---设定连锁条件，f的函数原型为 bool f(e,ep,tp)
---e表示要限制连锁的效果，ep表示要限制连锁的玩家，tp表示发动该效果的玩家
---在cost或者target处理中调用此函数可以限制可以连锁的效果的种类（如超融合）
---如果f返回false表示不能连锁，一旦设置连锁条件后发生了新的连锁那么连锁条件将会解除
---@param f function
function Duel.SetChainLimit(f) end

---功能同Duel.SetChainLimit，但是此函数设定的连锁条件直到连锁结束才会解除
---@param f function
function Duel.SetChainLimitTillChainEnd(f) end

---返回玩家player受到的连锁素材的效果，此函数仅用于融合类卡的效果
---@return Effect|nil
---@param player integer
function Duel.GetChainMaterial(player) end

---确认玩家player卡组最上方count张卡
---@param player integer
---@param count integer
function Duel.ConfirmDecktop(player,count) end

---确认玩家player额外卡组里侧的卡 最上方count张卡
---@param player integer
---@param count integer
function Duel.ConfirmExtratop(player,count) end

---给玩家player确认targets
---@param player integer
---@param targets Card|Group
function Duel.ConfirmCards(player,targets) end

---让玩家sort_player对玩家target_player的卡组最上方count张卡进行排序，最先选的卡在最上面，然后下面是第二张选择的卡，以此类推
---最多只能排序16张卡
---@param sort_player integer
---@param target_player integer
---@param count integer
function Duel.SortDecktop(sort_player,target_player,count) end

---检查当前是否是event时点
---若get_info=true并且是正确的时点，则还返回触发时点的信息 eg,ep,ev,re,r,rp
---@return boolean
---@return Group 可能为空
---@return integer 可能为空
---@return integer 可能为空 
---@return Effect 可能为空
---@return integer 可能为空
---@return integer 可能为空
---@param event integer
---@param get_info? boolean
function Duel.CheckEvent(event,get_info) end

---以eg,ep,ev,re,r,rp触发一个时点 code
---@param eg Group|Card
---@param code integer
---@param re Effect
---@param r integer
---@param rp integer
---@param ep integer
---@param ev integer
function Duel.RaiseEvent(eg,code,re,r,rp,ep,ev) end

---以eg,ep,ev,re,r,rp为卡片ec触发一个单体时点 code
---@param ec Card
---@param code integer
---@param re Effect
---@param r integer
---@param rp integer
---@param ep integer
---@param ev integer
function Duel.RaiseSingleEvent(ec,code,re,r,rp,ep,ev) end

---检查当前是否是timing提示时点
---@return boolean
---@param timing integer
function Duel.CheckTiming(timing) end

---检查场地卡号是否是code [，来源玩家是否是 player][，生效区域是否在 loc 内]
---场地卡号指当前生效的场地卡的卡号，或者海神的巫女把场地变化效果的值
---来源玩家指当前生效的场地卡的控制者，或者海神的巫女等卡的控制者
---@return boolean
---@param code integer
---@param player? integer default: PLAYER_ALL
---@param loc? integer default: LOCATION_ONFIELD
function Duel.IsEnvironment(code,player,loc) end

---当前效果处理完令player以win_reason决斗胜利
---@param player integer
---@param win_reason integer
function Duel.Win(player,win_reason) end

---让玩家player以原因reason抽count张卡，返回实际抽的卡的数量
---如果reason含有REASON_RULE则此次抽卡不受“不能抽卡”的效果的影响
---@return integer
---@param player integer
---@param count integer
---@param reason integer
function Duel.Draw(player,count,reason) end

---以reason原因给与玩家player造成value的伤害，返回实际收到的伤害值
---如果受到伤害变成回复等效果的影响时，返回值为0.
---is_step为true则是伤害/恢复LP过程的分解，需要调用Duel.RDComplete()触发时点
---@return integer
---@param player integer
---@param value integer
---@param reason integer
---@param is_step? boolean default: false
function Duel.Damage(player,value,reason,is_step) end

---以reason原因使玩家player回复value的LP，返回实际的回复值
---如果受到回复变成伤害等效果的影响时，返回值为0.
---is_step为true则是伤害/恢复LP过程的分解，需要调用Duel.RDComplete()触发时点
---@return integer
---@param player integer
---@param value integer
---@param reason integer
---@param is_step? boolean default: false
function Duel.Recover(player,value,reason,is_step) end

---在调用Duel.Damage/Duel.Recover时，若is_step参数为true，则需调用此函数触发时点
function Duel.RDComplete() end

---把c1作为玩家player的装备卡装备给c2，返回值表示是否成功
---up=false则保持装备卡之前的表示形式
---is_step=true则是装备过程的分解，需要配合Duel.EquipComplete使用
---@return boolean
---@param player integer
---@param c1 Card
---@param c2 Card
---@param up? boolean default: true
---@param is_step? boolean default: false
function Duel.Equip(player,c1,c2,up,is_step) end

---在调用Duel.Equip时，若is_step参数为true，则需调用此函数触发时点
function Duel.EquipComplete() end

---让玩家 player [直到 reset_count 次 reset_phase 时][在区域 zone]
---得到 targets 的控制权，返回值表示是否成功
---@return boolean
---@param targets Card|Group
---@param player integer
---@param reset_phase? integer default: 0
---@param reset_count? integer default: 0
---@param zone? integer default: 0xff
function Duel.GetControl(targets,player,reset_phase,reset_count,zone) end

---交换targets1与targets2的控制权，返回值表示是否成功
---第三个第四个参数同 Duel.GetControl
---@return boolean
---@param targets1 Card|Group
---@param targets2 Card|Group
---@param reset_phase? integer default: 0
---@param reset_count? integer default: 0
function Duel.SwapControl(targets1,targets2,reset_phase,reset_count) end

---检查玩家player是否能支付cost点lp，must_pay表示不能用代替支付的效果
---@return boolean
---@param player integer
---@param cost integer
---@param must_pay? boolean default: false
function Duel.CheckLPCost(player,cost,must_pay) end

---让玩家player支付cost点lp，must_pay表示不能用代替支付的效果
---@param player integer
---@param cost integer
---@param must_pay? boolean default: false
function Duel.PayLPCost(player,cost,must_pay) end

---以原因reason把玩家player的卡组最上端count张卡送去墓地，返回实际转移的数量
---@return integer
---@param player integer
---@param count integer
---@param reason integer
function Duel.DiscardDeck(player,count,reason) end

---过滤函数让玩家player选择并以reason原因丢弃满足筛选条件f兵不等于ex的min-max张手卡
---第7个参数开始为额外参数
---@return integer
---@param player integer
---@param f function|nil
---@param min integer
---@param max integer
---@param reason integer
---@param ex Card|Group|nil
---@param ... any
function Duel.DiscardHand(player,f,min,max,reason,ex,...) end

---使下一个操作不检查是否需要洗切卡组或手卡
---注：如果不调用此函数，
---除了调用Duel.DiscardDeck和Duel.Draw之外从卡组中取出卡或者把卡加入手卡
---或者把卡加入卡组（非最上端或最底端）时，系统会自动在效果处理结束时洗切卡组或手卡
---如果不希望如此，比如从卡组顶端除外一张卡等操作，那么需要调用此函数
---此函数仅保证紧接着的一次操作不会进行洗卡检测
---@param disable? boolean default: true
function Duel.DisableShuffleCheck(disable) end

---关闭卡片的自爆检查。不传参或传true为关闭，传false为启用自爆检查
---@param enabled? boolean default: true
function Duel.DisableSelfDestroyCheck(enabled) end

---启用选择卡组时显示真实序号
---@param enabled? boolean default: true
function Duel.PreserveSelectDeckSequence(enabled) end

---手动洗切玩家player的卡组
---注：会重置洗卡检测的状态
---@param player integer
function Duel.ShuffleDeck(player) end

---手动洗切玩家player的额外卡组
---@param player integer
function Duel.ShuffleExtra(player) end

---手动洗切玩家player的手卡
---注：会重置洗卡检测的状态
---@param player integer
function Duel.ShuffleHand(player) end

---洗切覆盖的卡片组 g （实例：魔术礼帽），若g中有表侧表示的卡，则此函数无效
---此函数现在可以洗切魔陷区的覆盖卡
---@param g Group
function Duel.ShuffleSetCard(g) end

---将攻击怪兽变为c
---若 ignore_count=true 则原来的攻击怪兽不视为攻击过
---@param c Card
---@param ignore_count? boolean default: false
function Duel.ChangeAttacker(c,ignore_count) end

---将攻击对象变为c，c为nil表示直接攻击，返回值表示是否成功转移攻击对象
---@return boolean
---@param c Card|nil
function Duel.ChangeAttackTarget(c) end

---令c1与c2进行战斗伤害计算（c1 攻击 c2）
---若 new_attack=true 则视为 攻击的卡进行过攻击宣言（？）
---@param c1 Card
---@param c2 Card
---@param new_attack? boolean default: false
function Duel.CalculateDamage(c1,c2,new_attack) end

---返回玩家player在本次战斗中受到的伤害
---@return integer
---@param player integer
function Duel.GetBattleDamage(player) end

---把玩家player在本次战斗中受到的伤害变成value，若 check=false 则原本战斗伤害就算为0也改变伤害
---@param player integer
---@param value integer
---@param check? boolean default: true
function Duel.ChangeBattleDamage(player,value,check) end

---把连锁chainc的对象换成g
---@param chainc integer
---@param g Group
function Duel.ChangeTargetCard(chainc,g) end

---把连锁chainc的对象玩家换成player
---@param chainc integer
---@param player integer
function Duel.ChangeTargetPlayer(chainc,player) end

---把连锁chainc的参数换成param
---@param chainc integer
---@param param integer
function Duel.ChangeTargetParam(chainc,param) end

---中断当前效果，使之后的效果处理视为不同时处理，此函数会造成错时点
function Duel.BreakEffect() end

---把连锁chainc的效果的处理函数换成f，用于实现“把效果变成”等的效果
---f(e,tp,eg,ep,ev,re,r,rp)
---@param chainc integer
---@param f function
function Duel.ChangeChainOperation(chainc,f) end

---使连锁chainc的发动无效，返回值表示是否成功
---@return boolean
---@param chainc integer
function Duel.NegateActivation(chainc) end

---使连锁chainc的效果无效，返回值表示是否成功
---@return boolean
---@param chainc integer
---@param forced? boolean
function Duel.NegateEffect(chainc,forced) end

---使和卡片c有关的连锁都无效化，发生reset事件则重置,reset 默认包含 RESET_CHAIN
---@param c Card
---@param reset integer
function Duel.NegateRelatedChain(c,reset) end

---使正在召唤·反转召唤·特殊召唤的targets的召唤无效
---@param targets Card|Group
function Duel.NegateSummon(targets) end

---手动增加1次玩家[对于卡片c]的已经通常召唤过的次数
---@param c? Card
function Duel.IncreaseSummonedCount(c) end

---检查回合玩家本回合是否还能通常召唤[卡片c]
---@return boolean
---@param c? Card
function Duel.CheckSummonedCount(c) end

---返回玩家player的场上location可用的[区域 zone 里的]空格数
---location只能是LOCATION_MZONE或者LOCATION_SZONE
---reason为LOCATION_REASON_TOFIELD或LOCATION_REASON_CONTROL
---##第三个第四个额外参数与凯撒斗技场等限制格子的效果有关
---@return integer
---@param player integer
---@param location integer
---@param use_player? integer
---@param reason? integer
---@param zone? integer default: 0xff
function Duel.GetLocationCount(player,location,use_player,reason,zone) end

---返回玩家player场上[targets 离开后]可用的[区域 zone 里的]怪兽区数量
---##第三个第四个额外参数与凯撒斗技场等限制格子的效果有关
---@return integer
---@return integer zone
---@param player integer
---@param targets? Group|Card
---@param use_player? integer
---@param reason? integer
---@param zone? integer default: 0xff
function Duel.GetMZoneCount(player,targets,use_player,reason,zone) end

---返回玩家player场上[假如因玩家 reason_player 的原因让 targets 离场后，把卡片 sc 在 zone 区域特殊召唤]可用的 能让额外卡组的怪兽 出场的空格数
---@return integer
---@param player integer
---@param reason_player? integer default: player
---@param targets? Group|Card|nil
---@param sc? Card|integer
---@param zone? integer default: 0xff
function Duel.GetLocationCountFromEx(player,reason_player,targets,sc,zone) end

---返回玩家player场上[对于 use_player 来说]可用的怪兽区数量（？）
---@return integer
---@param player integer
---@param use_player? integer
function Duel.GetUsableMZoneCount(player,use_player) end

---返回以玩家player来看的 s_range 和 o_range 区域的处于连接状态的卡片组[其实只要后面2个参数不为0就行，只要不为0，都会变成LOCATION_MZONE]（？）
---@return Group
---@param player integer
---@param s_range integer
---@param o_range integer
function Duel.GetLinkedGroup(player,s_range,o_range) end

---返回以玩家player来看的 s_range 和 o_range 区域的处于连接状态的卡片的数量（？）
---@return integer
---@param player integer
---@param s_range integer
---@param o_range integer
function Duel.GetLinkedGroupCount(player,s_range,o_range) end

---返回以玩家player来看的所有连接区域
---@return integer
---@param player integer
function Duel.GetLinkedZone(player) end

---返回玩家player的场上位于location序号为seq的卡，常用于获得场地区域·灵摆区域的卡
---注：召唤·反转召唤·特殊召唤 之际 的卡无法获取
---@return Card
---@param player integer
---@param location integer
---@param seq integer
function Duel.GetFieldCard(player,location,seq) end

---检查玩家player的场上位于location序号为seq的空格是否可用
---@return boolean
---@param player integer
---@param location integer
---@param seq integer
function Duel.CheckLocation(player,location,seq) end

---返回当前的连锁个数（即正在处理的连锁序号）
---@return integer
function Duel.GetCurrentChain() end

---返回当前已执行Target函数的连锁个数
---@return integer
function Duel.GetReadyChain() end

---返回连锁chainc的信息，如果chainc=0，则返回当前正在处理的连锁的信息
---此函数根据传入的参数个数按顺序返回相应数量的返回值参数可以是:
---CHAININFO_CHAIN_COUNT               连锁序号
---CHAININFO_TRIGGERING_EFFECT         连锁的效果
---CHAININFO_TRIGGERING_PLAYER         连锁的玩家
---CHAININFO_TRIGGERING_CONTROLER      连锁发生位置所属玩家
---CHAININFO_TRIGGERING_LOCATION       连锁发生位置
---CHAININFO_TRIGGERING_SEQUENCE       连锁发生的位置的序号
---CHAININFO_TARGET_CARDS              连锁的对象卡片组
---CHAININFO_TARGET_PLAYER             连锁的对象玩家
---CHAININFO_TARGET_PARAM              连锁的对象参数
---CHAININFO_DISABLE_REASON            连锁被无效的原因效果
---CHAININFO_DISABLE_PLAYER            连锁被无效的原因玩家
---CHAININFO_CHAIN_ID                  连锁的唯一标识
---CHAININFO_TYPE                      连锁卡片的类型（怪兽·魔法·陷阱）
---CHAININFO_EXTTYPE                   连锁卡片的具体类型（例如同调怪兽·永续魔法·反击陷阱）
---举例：
---Duel.GetChainInfo(0,CHAININFO_TRIGGERING_LOCATION,CHAININFO_TARGET_CARDS)
---将会返回当前连锁发生的位置和对象卡
---@return ...
---@param chainc integer
---@param ... any
function Duel.GetChainInfo(chainc,...) end

---返回连锁 chainc 的相关参数，如果 chainc=0，则返回当前正在处理的连锁的相关参数
---返回6个参数，eg,ep,ev,re,r,rp
---@return Group
---@return integer
---@return integer
---@return Effect
---@return integer
---@return integer
---@param chainc integer
function Duel.GetChainEvent(chainc) end

---返回当前连锁的所有的对象卡，一般只有一个对象时使用
---##多个对象也能使用，剩下的对象依次按顺序返回，但是很容易记错对象的顺序，所以不建议对多个对象使用
---@return Card
---@return ... Card
function Duel.GetFirstTarget() end

---返回当前连锁所有有关联的对象卡
---@return Group
function Duel.GetTargetsRelateToChain() end

---返回当前的阶段是否为phase
---@param phase integer
---@return boolean
function Duel.IsPhase(phase) end

---返回当前的阶段是否为主要阶段
---@return boolean
function Duel.IsMainPhase() end

---返回当前的阶段是否为战斗阶段
---@return boolean
function Duel.IsBattlePhase() end

---返回当前的阶段
---@return integer
function Duel.GetCurrentPhase() end

---跳过玩家player的phase阶段，并在特定的阶段后reset，reset参数和效果相同
---#value只对phase=PHASE_BATTLE才有用，value=1跳过战斗阶段的结束步骤，用于“变成回合结束阶段”等（招财猫王，闪光弹）
---@param player integer
---@param phase integer
---@param reset_flag integer
---@param reset_count integer
---@param value? integer
function Duel.SkipPhase(player,phase,reset_flag,reset_count,value) end

---用于在伤害阶段检查是否已经计算了战斗伤害
---@return boolean
function Duel.IsDamageCalculated() end

---返回此次战斗攻击的卡
---@return Card
function Duel.GetAttacker() end

---返回此次战斗被攻击的卡，如果返回nil表示是直接攻击
---@return Card
function Duel.GetAttackTarget() end

---返回由player操控的正处于战斗中的怪兽。如果没有战斗或没有目标则会返回nil。
---@return Card
---@return Card
---@param player integer
function Duel.GetBattleMonster(player) end

---无效此次攻击，返回值表示是否成功
---此次攻击已经被其他效果无效或导致攻击的卡不能攻击则返回false
---@return boolean
function Duel.NegateAttack() end

---使攻击卡[或卡片c]可以再进行1次攻击（比如 大开辟，破灭的女王）
---@param c? Card
function Duel.ChainAttack(c) end

---刷新场上的卡的信息
---非特定情况或者不清楚原理请勿使用此函数以免形成死循环
function Duel.Readjust() end

---手动刷新场上[受到卡片c影响]的卡的无效状态
---@param c? Card
function Duel.AdjustInstantly(c) end

---立刻刷新场地信息
function Duel.AdjustAll() end

---返回以player来看的指定位置的卡，s代表以player来看的自己的位置，o代表以player来看的对方的位置
---@return Group
---@param player integer
---@param s integer
---@param o integer
function Duel.GetFieldGroup(player,s,o) end

---同 Duel.GetFieldGroup ，只是返回的是卡的数量
---@return integer
---@param player integer
---@param s integer
---@param o integer
function Duel.GetFieldGroupCount(player,s,o) end

---返回玩家player的卡组最上方的count张卡
---@return Group
---@param player integer
---@param count integer
function Duel.GetDecktopGroup(player,count) end

---返回玩家player的额外卡组表侧表示的卡中最上方的count张卡
---@return Group
---@param player integer
---@param count integer
function Duel.GetExtraTopGroup(player,count) end

---过滤函数，返回以player来看的指定位置满足过滤条件f并且不等于ex的卡
---s代表以player来看的自己的位置，o代表以player来看的对方的位置
---第6个参数开始为额外参数
---@return Group
---@param f function|nil
---@param player integer
---@param s integer
---@param o integer
---@param ex Card|Group|nil
---@param ... any
function Duel.GetMatchingGroup(f,player,s,o,ex,...) end

---过滤函数，返回以player来看的指定位置满足过滤条件f并且不等于ex的卡的数量
---s代表以player来看的自己的位置，o代表以player来看的对方的位置
---第6个参数开始为额外参数
---@return integer
---@param f function|nil
---@param player integer
---@param s integer
---@param o integer
---@param ex Card|Group|nil
---@param ... any
function Duel.GetMatchingGroupCount(f,player,s,o,ex,...) end

---过滤函数，返回以player来看的指定位置满足过滤条件f并且不等于ex的第一张卡,没有则返回nil
---s代表以player来看的自己的位置，o代表以player来看的对方的位置
---第6个参数开始为额外参数
---@return Card
---@param f function|nil
---@param player integer
---@param s integer
---@param o integer
---@param ex Card|Group|nil
---@param ... any
function Duel.GetFirstMatchingCard(f,player,s,o,ex,...) end

---过滤函数，检查以player来看的指定位置是否存在至少count张满足过滤条件f并且不等于ex的卡
---s代表以player来看的自己的位置，o代表以player来看的对方的位置
---第7个参数开始为额外参数
---@return boolean
---@param f function|nil
---@param player integer
---@param s integer
---@param o integer
---@param count integer
---@param ex Card|Group|nil
---@param ... any
function Duel.IsExistingMatchingCard(f,player,s,o,count,ex,...) end

---过滤函数，让玩家sel_player选择以player来看的指定位置满足过滤条件f并且不等于ex的min-max张卡
---s代表以player来看的自己的位置，o代表以player来看的对方的位置
---第9个参数开始为额外参数
---@return Group
---@param sel_player integer
---@param f function|nil
---@param player integer
---@param s integer
---@param o integer
---@param min integer
---@param max integer
---@param ex Card|Group|nil
---@param ... any
function Duel.SelectMatchingCard(sel_player,f,player,s,o,min,max,ex,...) end

---返回玩家player能以原因reason解放的卡片组， use_hand=true 则包括手卡
---@return Group
---@param player integer
---@param use_hand? boolean default: false
---@param reason? integer default: REASON_COST
function Duel.GetReleaseGroup(player,use_hand,reason) end

---返回玩家player能以原因reason解放的卡片数量， use_hand=true 则包括手卡
---@return integer
---@param player integer
---@param use_hand? boolean default: false
---@param reason? integer default: REASON_COST
function Duel.GetReleaseGroupCount(player,use_hand,reason) end

---检查玩家player场上是否存在至少count张满足过滤条件f并且不等于ex的能以原因REASON_COST解放的卡
---第5个参数开始为额外参数
---@return boolean
---@param player integer
---@param f function|nil
---@param count integer
---@param ex Card|Group|nil
---@param ... any
function Duel.CheckReleaseGroup(player,f,count,ex,...) end

---过滤函数，让玩家sel_player从场上选择min-max张不等于ex的满足条件f的能以原因REASON_COST解放的卡
---第6个参数开始为额外参数
---@return Group
---@param sel_player integer
---@param f function|nil
---@param min integer
---@param max integer
---@param ex Card|Group|nil
---@param ... any
function Duel.SelectReleaseGroup(sel_player,f,min,max,ex,...) end

---检查玩家player场上是否存在至少count张满足过滤条件f并且不等于ex的能以原因reason解放的卡，use_hand则包括手卡
---第5个参数开始为额外参数
---@return boolean
---@param player integer
---@param f function|nil
---@param count integer
---@param reason integer
---@param use_hand boolean
---@param ex Card|Group|nil
---@param ... any
function Duel.CheckReleaseGroupEx(player,f,count,reason,use_hand,ex,...) end

---过滤函数，让玩家player从场上选择min-max张满足过滤条件f并且不等于ex的能以原因reason解放的卡，use_hand则包括手卡
---第6个参数开始为额外参数
---@return Group
---@param player integer
---@param f function|nil
---@param min integer
---@param max integer
---@param reason integer
---@param use_hand boolean
---@param ex Card|Group|nil
---@param ... any
function Duel.SelectReleaseGroupEx(player,f,min,max,reason,use_hand,ex,...) end

---返回场上用于通常召唤c可解放（上级召唤用）的卡片组
---@return Group
---@param c Card
function Duel.GetTributeGroup(c) end

---返回场上[或mg中]用于通常召唤c的祭品数量，ex=true则允许对方场上的怪兽（太阳神之翼神龙-球体形）
---此数量不一定等于Duel.GetTributeGroup的返回值中的卡片数量
---因为某些卡可以作为多个祭品来使用
---@return integer
---@param c Card
---@param mg? Group
---@param ex? boolean default: false
function Duel.GetTributeCount(c,mg,ex) end

---判断场上[或mg中]是否存在用于通常召唤c[到toplayer场上的区域 zone]的min[到max]个祭品
---@return Group
---@param c Card
---@param min integer
---@param max? integer|nil default: min
---@param mg? Group|nil
---@param toplayer? integer|nil default: c:GetControler()
---@param zone? integer|nil default: 0x1f
function Duel.CheckTribute(c,min,max,mg,toplayer,zone) end

---让玩家player从场上[或mg中]选择用于通常召唤c的min-max个祭品，召唤到 toplayer 场上
---@return Group
---@param player integer
---@param c Card
---@param min integer
---@param max integer
---@param mg? Group|nil
---@param toplayer? integer|nil default: c:GetControler()
function Duel.SelectTribute(player,c,min,max,mg,toplayer) end

---基本同Duel.GetMatchingGroupCount ，不同之处在于需要追加判定卡片是否能成为当前正在处理的效果的对象
---@return integer
---@param f function|nil
---@param player integer
---@param s integer
---@param o integer
---@param ex Card|Group|nil
---@param ... any
function Duel.GetTargetCount(f,player,s,o,ex,...) end

---基本同Duel.IsExistingMatchingCard ，不同之处在于需要追加判定卡片是否能成为当前正在处理的效果的对象
---@return boolean
---@param f function|nil
---@param player integer
---@param s integer
---@param o integer
---@param count integer
---@param ex Card|Group|nil
---@param ... any
function Duel.IsExistingTarget(f,player,s,o,count,ex,...) end

---基本同Duel.SelectMatchingCard ，不同之处在于此函数会同时将当前正在处理的连锁的对象设置成选择的卡
---@return Group
---@param sel_player integer
---@param f function|nil
---@param player integer
---@param s integer
---@param o integer
---@param min integer
---@param max integer
---@param ex Card|Group|nil
---@param ... any
function Duel.SelectTarget(sel_player,f,player,s,o,min,max,ex,...) end

---返回必须作为素材的卡片组
---@return Group
---@param player integer
---@param ecode integer EFFECT_MUST_BE_FMATERIAL等
function Duel.GetMustMaterial(player,ecode) end

---检查卡片组是否满足必须作为素材的条件
---@return boolean
---@param player integer
---@param cards Group|Card
---@param ecode integer EFFECT_MUST_BE_FMATERIAL等
function Duel.CheckMustMaterial(player,cards,ecode) end

---让玩家player从g中选择一组[必须包含gc在内的]融合怪兽c的融合素材
---##根据c的种类为EFFECT_FUSION_MATERIAL的效果的Operation操作
---@return Group
---@param player integer
---@param c Card
---@param g Group|nil 不能为空
---@param gc? Card|nil
---@param chkf? integer default: PLAYER_NONE
---@param not_material? boolean default: false
function Duel.SelectFusionMaterial(player,c,g,gc,chkf,not_material) end

---设置g为需要使用的融合素材
---@param g Group
function Duel.SetFusionMaterial(g) end

---设置g为需要使用的同调素材
---@param g Group
function Duel.SetSynchroMaterial(g) end

---获取玩家可以作为同调素材的卡片组
---@return Group
---@param player integer
function Duel.GetSynchroMaterial(player) end

---让玩家player从场上[或mg中]选择用于同调c需要的[必须包含smat在内（如果有mg~=nil则忽略此参数）]满足条件的一组素材
---f1是 1 只需要满足的过滤条件，f2是 min-max 只需要满足的过滤条件
---f1,f2 之中，至少有一种为调整的条件
---@return Group
---@param player integer
---@param c Card
---@param f1 function|nil
---@param f2 function|nil
---@param min integer
---@param max integer
---@param smat? Card|nil
---@param mg? Group|nil
function Duel.SelectSynchroMaterial(player,c,f1,f2,min,max,smat,mg) end

---检查场上[或mg中]是否存在一组[必须包括smat在内的（如果有mg~=nil则忽略此参数）]满足条件的卡作为同调召唤c的素材
---f1是 1 只需要满足的过滤条件，f2是 min-max 只需要满足的过滤条件
---f1,f2 之中，至少有一种为调整的条件
---@return boolean
---@param c Card
---@param f1 function|nil
---@param f2 function|nil
---@param min integer
---@param max integer
---@param smat? Card|nil
---@param mg? Group|nil
function Duel.CheckSynchroMaterial(c,f1,f2,min,max,smat,mg) end

---让玩家从场上[或mg中]选择用于同调c需要的满足条件的以tuner作为调整的min-max张卡的一组素材
---f1是 1 只需要满足的过滤条件，f2是 min-max 只需要满足的过滤条件
---@return Group
---@param player integer
---@param c Card
---@param tuner Card
---@param f1 function|nil
---@param f2 function|nil
---@param min integer
---@param max integer
---@param mg? Group|nil
function Duel.SelectTunerMaterial(player,c,tuner,f1,f2,min,max,mg) end

---检查场上[或mg中]是否存在一组以tuner作为调整,并且满足条件的卡作为同调召唤c的素材
---f1是 1 只需要满足的过滤条件，f2是 min-max 只需要满足的过滤条件
---@return boolean
---@param c Card
---@param tuner Card
---@param f1 function|nil
---@param f2 function|nil
---@param min integer
---@param max integer
---@param mg? Group|nil
function Duel.CheckTunerMaterial(c,tuner,f1,f2,min,max,mg) end

---返回玩家player可用的用于仪式召唤素材的卡片组
---包含手上，场上可解放的以及墓地的仪式魔人等卡
---@return Group
---@param player integer
function Duel.GetRitualMaterial(player) end

---Duel.GetRitualMaterial并包含无等级怪兽
---@return Group
---@param player integer
function Duel.GetRitualMaterialEx(player) end

---解放仪式用的素材g，如果是墓地的仪式魔人等卡则除外
---@param g Group
function Duel.ReleaseRitualMaterial(g) end

---返回玩家player可用的用于融合召唤素材的卡片组
---@return Group material_all 包含受EFFECT_EXTRA_FUSION_MATERIAL影响的卡
---@return Group material_base 只取那些区域的卡
---@param player integer
---@param location? integer default: LOCATION_HAND + LOCATION_MZONE
function Duel.GetFusionMaterial(player,location) end

---返回当前进行特殊召唤的行为是否可以回滚并撤销。
---@return boolean
function Duel.IsSummonCancelable() end

---设置Duel.CheckWithSum，Group.CheckSubGroup等函数已选择/必须选择的卡片
---@param cards Card|Group
function Duel.SetSelectedCard(cards) end

---清空并返回由Duel.SetSelectedCard设置的卡片或卡片组。
---@return Group
function Duel.GrabSelectedCard() end

---把当前正在处理的连锁的对象设置成targets
---注，这里的对象指的的广义的对象，包括不取对象的效果可能要处理的对象
---@param targets Card|Group
function Duel.SetTargetCard(targets) end

---把当前正在处理的连锁的对象全部清除
function Duel.ClearTargetCard() end

---把当前正在处理的连锁的对象玩家设置成player
---@param player integer
function Duel.SetTargetPlayer(player) end

---把当前正在处理的连锁的对象参数设置成param
---@param param integer
function Duel.SetTargetParam(param) end

---设置当前处理的连锁的操作信息此操作信息包含了效果处理中确定要处理的效果分类
---比如潜行狙击手需要设置CATEGORY_DICE，但是不能设置CATEGORY_DESTROY，因为不确定
---对于破坏效果，targets需要设置成发动时可能成为连锁的影响对象的卡，
---并设置count为发动时确定的要处理的卡的数量
---比如黑洞发动时，targets需要设定为场上的所有怪兽，count设置成场上的怪的数量
---对于需要移动卡片位置的CATEGORY_SPECIAL_SUMMON,CATEGORY_TOHAND,CATEGORY_TODECK等分类，
---如果要处理的卡是确定的（比如取对象），则设置targets为这些卡，count为数量，
---如果要处理的卡是不确定的（效果处理时才能确定，一般是不取对象的效果），
---	则设置targets为nil，count为预计要处理的卡的数量，
---	target_player为预计要处理的卡的持有者（不确定就为0）
---	target_param为预计要处理的卡的位置
---例如增援：SetOperationInfo(0,CATEGORY_TOHAND,nil,1,tp,LOCATION_DECK)
---操作信息用于很多效果的发动的检测，例如星尘龙，王家长眠之谷等
---@param chainc integer
---@param category integer
---@param targets Card|Group|nil|0
---@param count integer
---@param target_player integer
---@param target_param integer
function Duel.SetOperationInfo(chainc,category,targets,count,target_player,target_param) end

---返回连锁chainc的category分类的操作信息，存在的话，则返回值为5个， chainc=0 则是表示当前连锁
---第一个返回值是false的话表示不存在该分类
---后4个返回值对应Duel.SetOperationInfo的后4个参数：Card|Group targets, int count, int target_player, int target_param
---@return boolean
---@return Group 可能为空
---@return integer 可能为空
---@return integer 可能为空
---@return integer 可能为空
---@param chainc integer
---@param category integer
function Duel.GetOperationInfo(chainc,category) end

---返回连锁chainc包含的操作分类的数量
---@return integer
---@param chainc integer
function Duel.GetOperationCount(chainc) end

---将chainc的OperationInfo清除。用于如堕天使复制并使用墓地效果之类，卡片效果不应当被响应的情况。
---@param chainc integer
function Duel.ClearOperationInfo(chainc) end

---检查场上[或mg中]是否存在XYZ召唤c的XYZ用等级为lv的min-max个满足条件f的叠放素材
---@return boolean
---@param c Card
---@param f function|nil
---@param lv integer
---@param min integer
---@param max integer
---@param mg Group|nil
function Duel.CheckXyzMaterial(c,f,lv,min,max,mg) end

---让玩家player为XYZ怪兽c从场上[或mg中]选择XYZ用等级为lv的min-max个满足条件f的叠放素材
---@return Group
---@param player integer
---@param c Card
---@param f function|nil
---@param lv integer
---@param min integer
---@param max integer
---@param mg? Group|nil
function Duel.SelectXyzMaterial(player,c,f,lv,min,max,mg) end

---把ocard作为c的叠放卡叠放
---@param c Card
---@param ocard Card|Group
---@param adjust? boolean default: true
function Duel.Overlay(c,ocard,adjust) end

---返回以player来看的指定位置的所有叠放的卡
---s代表以player来看的自己的位置，o代表以player来看的对方的位置
---@return Group
---@param player integer
---@param s integer
---@param o integer
function Duel.GetOverlayGroup(player,s,o) end

---返回以player来看的指定位置的所有叠放的卡的数量
---s代表以player来看的自己的位置，o代表以player来看的对方的位置
---@return integer
---@param player integer
---@param s integer
---@param o integer
function Duel.GetOverlayCount(player,s,o) end

---检查player能否以原因reason移除以player来看的指定位置至少count张卡
---s代表以player来看的自己的位置，o代表以player来看的对方的位置
---@return boolean
---@param player integer
---@param s integer
---@param o integer
---@param count integer
---@param reason integer
function Duel.CheckRemoveOverlayCard(player,s,o,count,reason) end

---让player以reason原因移除以player来看的指定位置的min-max张叠放卡，返回值表示是否成功
---s代表以player来看的自己的位置，o代表以player来看的对方的位置
---@return integer
---@param player integer
---@param s integer
---@param o integer
---@param min integer
---@param max integer
---@param reason integer
function Duel.RemoveOverlayCard(player,s,o,min,max,reason) end

---给玩家player发送hint_type类型的消息提示，提示内容为desc
---@param hint_type integer
---@param player integer
---@param desc integer
function Duel.Hint(hint_type,player,desc) end

---返回上次给玩家player发送的HINT_SELECTMSG类型的提示内容
---@param player integer
---@return integer
function Duel.GetLastSelectHint(player) end

---手动为g显示被选为对象的动画效果
---@param g Group
function Duel.HintSelection(g) end

---让玩家player选择是否发动卡片c的效果[提示文字可以自行用desc替换，desc 用 aux.Stringid 获取]
---@return boolean
---@param player integer
---@param c Card
---@param desc? integer default: 95
function Duel.SelectEffectYesNo(player,c,desc) end

---让玩家player选择是或否
---@return boolean
---@param player integer
---@param desc integer
function Duel.SelectYesNo(player,desc) end

---让玩家选择选项，从第二个参数开始，每一个参数代表一条选项
---返回选择的选项的序号(从0开始)
---@return integer
---@param player integer
---@param desc1 integer
---@param ... any
function Duel.SelectOption(player,desc1,...) end

---此函数只有一个 check_action_permission 操作，不知何用
function Duel.SelectSequence() end

---让玩家player选择c的表示形式并返回
---@return integer
---@param player integer
---@param c Card
---@param pos integer
function Duel.SelectPosition(player,c,pos) end

---让玩家player选择场地。
---@return integer
---@param player integer
---@param count integer
---@param loc1 integer
---@param loc2 integer
---@param zone integer
---@param code? integer
function Duel.SelectField(player,count,loc1,loc2,zone,code) end

---让玩家player选择指定位置满足标记条件filter的count个可用的空格，并返回选择位置的标记
---常用于选择区域不能使用或移动怪兽格子
---##位置标记的定义如下
---##flag = 0;
---##seq为在玩家p，位置l中选择的格子序号
---##for(int32 i = 0; i < count; ++i) {
---##	flag |= 1 << (seq[i] + (p[i] == player ? 0 : 16) + (l[i] == LOCATION_MZONE ? 0 : 8));
---##}
---@return integer
---@param player integer
---@param count integer
---@param s integer
---@param o integer
---@param filter integer
function Duel.SelectDisableField(player,count,s,o,filter) end

---让玩家player从可选的种族中宣言count个种族
---available是所有可选种族的组合值，可以自行组合
---@return integer
---@param player integer
---@param count integer
---@param available integer
function Duel.AnnounceRace(player,count,available) end

---让玩家player从可选的属性中宣言count个属性
---available是所有可选属性的组合值，可以自行组合
---@return integer
---@param player integer
---@param count integer
---@param available integer
function Duel.AnnounceAttribute(player,count,available) end

---让玩家宣言一个[min-max]等级并返回
---@return integer
---@param player integer
---@param min? integer|nil default: 1
---@param max? integer|nil default: 12
---@param ...? integer
function Duel.AnnounceLevel(player,min,max,...) end

---让玩家player宣言一个满足条件的卡片卡号，条件用后缀表达式...表示
---原名AnnounceCardFilter
---@return integer
---@param player integer
---@param ...? integer
function Duel.AnnounceCard(player,...) end

---让玩家player宣言一个卡片类型（怪兽·魔法·陷阱）
---别想着直接宣言 复合类型（永续魔法 等）
---@return integer
---@param player integer
function Duel.AnnounceType(player) end

---让玩家player宣言一个数字
---从第二个参数开始，每一个参数代表一个可宣言的数字
---第一个返回值是宣言的数字，第二个返回值是宣言数字在所有选项中的位置
---@return integer
---@return integer
---@param player integer
---@param number integer
---@param ... any
function Duel.AnnounceNumber(player,number,...) end

---让玩家player宣言硬币的正反面
---@return integer
---@param player integer
function Duel.AnnounceCoin(player) end

---让玩家player投count(<=20)次硬币，返回值为count个结果，0或者1, 正面是 1，反面是0
---若count=-1，投硬币直到出现反面，返回值为投掷次数
---@return ...
---@param player integer
---@param count integer
function Duel.TossCoin(player,count) end

---让玩家player投count1次骰子[，1-player投count2次骰子](count1+count2<=5)
---返回值为count1+count2个结果，1-6
---@return ...
---@param player integer
---@param count1 integer
---@param count2? integer
function Duel.TossDice(player,count1,count2) end

---猜拳，若 repeated=false 则只猜一次；否则就是直到分出胜负为止。返回胜利的玩家号码
---@return integer
---@param repeated? boolean default: true
function Duel.RockPaperScissors(repeated) end

---返回当前投硬币的结果
---@return integer
---@return integer
---@return integer
---@return integer
---@return integer
function Duel.GetCoinResult() end

---返回当前掷骰子的结果
---@return integer
---@return integer
---@return integer
---@return integer
---@return integer
function Duel.GetDiceResult() end

---强行修改投硬币的结果为res ,最多5个参数，res只能是 0 或 1, ，其他全算作 0
---此函数用于永续的EVENT_TOSS_COIN事件中
---@param res integer
---@param ... any
function Duel.SetCoinResult(res,...) end

---强行修改投骰子的结果为res ,最多5个参数，res只能是 1~255, ，其他数字全算作 1
---此函数用于永续的EVENT_TOSS_DICE事件中
---@param res integer
---@param ... any
function Duel.SetDiceResult(res,...) end

---检查player是否受到种类为code的效果影响，如果有就返回该效果，没有则返回nil
---@return Effect|nil
---@return ...
---@param player integer
---@param code integer
function Duel.IsPlayerAffectedByEffect(player,code) end

---检查玩家player是否可以效果抽[count张]卡
---@return boolean
---@param player integer
---@param count? integer default: 0
function Duel.IsPlayerCanDraw(player,count) end

---检查玩家player是否可以把卡组顶端count张卡送去墓地
---@return boolean
---@param player integer
---@param count integer
function Duel.IsPlayerCanDiscardDeck(player,count) end

---检查玩家player是否能作为Cost把count张卡送去墓地。
---@return boolean
---@param player integer
---@param count integer
function Duel.IsPlayerCanDiscardDeckAsCost(player,count) end

---检查玩家player是否可以通常召唤[c，以sumtype方式]
---如果需要可选参数，则必须全部使用
---仅当玩家收到“不能上级召唤”等效果的影响时返回false
---@return boolean
---@param player integer
---@param sumtype? integer
---@param c? Card
function Duel.IsPlayerCanSummon(player,sumtype,c) end

---检查玩家player是否可以[以sumtype的召唤方式将scard]盖放。
---如果要加入后面的可选参数，则所有两个可选参数都必须加上。
---@return boolean
---@param player integer
---@param sumtype? integer
---@param scard? Card
function Duel.IsPlayerCanMSet(player,sumtype,scard) end

---检查玩家player是否可以[将scard]盖放。
---@return boolean
---@param player integer
---@param scard? Card
function Duel.IsPlayerCanSSet(player,scard) end

---检查玩家player能否特殊召唤[c到target_player场上，以sumtype召唤方式，sumpos表示形式]
---如果需要可选参数，则必须全部使用
---@return boolean
---@param player integer
---@param sumtype? integer
---@param sumpos? integer
---@param target_player? integer
---@param c? Card
function Duel.IsPlayerCanSpecialSummon(player,sumtype,sumpos,target_player,c) end

---检查玩家player是否可以反转召唤c
---@return boolean
---@param player integer
---@param c Card
function Duel.IsPlayerCanFlipSummon(player,c) end

---检查玩家player是否可以[以sumtype 方式][以 pos 表示形式]特殊召唤 给定参数的怪兽到target_player场上
---此函数通常用于判定是否可以特招token和陷阱怪兽
---@return boolean
---@param player integer
---@param code integer
---@param setcode? integer|nil
---@param type? integer|nil
---@param atk? integer|nil
---@param def? integer|nil
---@param level? integer|nil
---@param race? integer|nil
---@param attribute? integer|nil
---@param pos? integer default: POS_FACEUP
---@param target_player? integer default: player
---@param sumtype? integer default: 0
---@param zone? integer
function Duel.IsPlayerCanSpecialSummonMonster(player,code,setcode,type,atk,def,level,race,attribute,pos,target_player,sumtype,zone) end

---检查玩家player能否特殊召唤count次
---@return boolean
---@param player integer
---@param count integer
function Duel.IsPlayerCanSpecialSummonCount(player,count) end

---检查玩家player是否能解放[以原因reason解放c]
---@return boolean
---@param player integer
---@param c? Card
---@param reason? integer default: REASON_COST
function Duel.IsPlayerCanRelease(player,c,reason) end

---检查玩家player是否能除外c
---@return boolean
---@param player integer
---@param c? Card
function Duel.IsPlayerCanRemove(player,c) end

---检查玩家是否能把c送去手卡
---@return boolean
---@param player integer
---@param c Card
function Duel.IsPlayerCanSendtoHand(player,c) end

---检查玩家是否能把c送去墓地
---@return boolean
---@param player integer
---@param c? Card
function Duel.IsPlayerCanSendtoGrave(player,c) end

---检查玩家是否能把c送去卡组
---@return boolean
---@param player integer
---@param c Card
function Duel.IsPlayerCanSendtoDeck(player,c) end

---检查玩家player是否有通常召唤外的召唤次数。
---@return boolean
---@param player integer
function Duel.IsPlayerCanAdditionalSummon(player) end

---检查当前是处于连锁处理中，还是不入连锁的效果处理中
---@return boolean
function Duel.IsChainSolving() end

---检查连锁chainc的发动能否被无效
---@return boolean
---@param chainc integer
function Duel.IsChainNegatable(chainc) end

---检查连锁chainc的效果能否被无效
---@return boolean
---@param chainc integer
function Duel.IsChainDisablable(chainc) end

---检查连锁chainc是否已被无效
---@return boolean
---@param chainc integer
function Duel.IsChainDisabled(chainc) end

---检查c是否是连锁chainc的效果的正确的对象
---@return boolean
---@param chainc integer
---@param c Card
function Duel.CheckChainTarget(chainc,c) end

---检查当前连锁中是否存在同名卡的发动，返回true表示无同名卡
---@return boolean
function Duel.CheckChainUniqueness() end

---返回player进行对应的activity_type操作的次数
---@return integer
---@return ...
---@param player integer
---@param activity_type integer
---@param ... any
function Duel.GetActivityCount(player,activity_type,...) end

---检查玩家在当前阶段是否有操作（是否处于阶段开始时，如七皇之剑）
---@return boolean
function Duel.CheckPhaseActivity() end

---设置操作类型为activity_type、代号为counter_id的计数器，放在initial_effect函数内
---f为过滤函数，以Card类型为参数，返回值为false的卡片进行以下类型的操作，计数器增加1（目前最多为1）
---@param counter_id integer
---@param activity_type integer
---@param f function
function Duel.AddCustomActivityCounter(counter_id,activity_type,f) end

---代号为counter_id的计数器的计数，返回player进行以下操作的次数（目前最多为1）
---@return integer
---@param counter_id integer
---@param player integer
---@param activity_type integer
function Duel.GetCustomActivityCount(counter_id,player,activity_type) end

---返回玩家player这回合战斗过的次数
---@return integer
---@param player integer
function Duel.GetBattledCount(player) end

---检查回合玩家能否进入战斗阶段
---@return boolean
function Duel.IsAbleToEnterBP() end

---现世与冥界的逆转专用。把玩家player的卡组和墓地交换
---@param player integer
function Duel.SwapDeckAndGrave(player) end

---救世星龙专用。把c2记述的效果复制给c1
---强制发动的效果可以选择是否发动
---@param c1 Card
---@param c2 Card
function Duel.MajesticCopy(c1,c2) end

---新建一个空效果
---并且效果的Owner为c
---@return Effect
---@param c Card
function Effect.CreateEffect(c) end

---新建一个全局效果
---@return Effect
function Effect.GlobalEffect() end

---新建一个效果e的副本
---@return Effect
---@param e Effect
function Effect.Clone(e) end

---把效果e重置，重置之后不可以再使用此效果
---@param e Effect
function Effect.Reset(e) end

---获取效果e的id
---@return integer
---@param e Effect
function Effect.GetFieldID(e) end

---为效果e设置效果描述
---@param e Effect
---@param desc integer
function Effect.SetDescription(e,desc) end

---为效果e设置Code属性
---@param e Effect
---@param code integer
function Effect.SetCode(e,code) end

---为效果e设置Range属性，即e的生效位置
---@param e Effect
---@param range integer
function Effect.SetRange(e,range) end

---为效果e设置Target Range属性
---	s_range指影响的我方区域
---	o_range值影响的对方区域
---	如果property属性中指定了EFFECT_FLAG_ABSOLUTE_RANGE标志，
---		那么s_range指玩家1受到影响的区域，o_range指玩家2受到影响的区域
---	如果这是一个召唤(覆盖)/限制召唤(覆盖)/特殊召唤手续
---	(EFFECT_SUMMON_PROC/EFFECT_LIMIT_SUMMON_PROC/EFFECT_SPSUMMON_PROC等)的效果，
---		并且property指定了EFFECT_FLAG_SPSUM_PARAM标志，
---		那么s_range表示特殊召唤到的哪个玩家的场地，
---	o_range表示可选择的表示形式
---@param e Effect
---@param s_range integer
---@param o_range integer
function Effect.SetTargetRange(e,s_range,o_range) end

---设置target range属性并设置 EFFECT_FLAG_ABSOLUTE_TARGET 标志
---	playerid != 0 s_range和o_range反转
---@param e Effect
---@param playerid integer
---@param s_range integer
---@param o_range integer
function Effect.SetAbsoluteRange(e,playerid,s_range,o_range) end

---设置一回合可以发动的次数count（仅触发型效果有效），相同的code(不等于0或1时)共用1个次数
---code包含以下数值具有特殊的性质
---EFFECT_COUNT_CODE_OATH          誓约使用次数
---EFFECT_COUNT_CODE_DUEL          决斗中使用次数
---EFFECT_COUNT_CODE_SINGLE        同一张卡多个效果公共使用次数（不限制同名卡）
---@param e Effect
---@param count integer default: 1
---@param code? integer default: 0
function Effect.SetCountLimit(e,count,code) end

---设置reset参数
---@param e Effect
---@param reset_flag integer
---@param reset_count? integer default: 1
function Effect.SetReset(e,reset_flag,reset_count) end

---为效果e设置Type属性
---@param e Effect
---@param type integer
function Effect.SetType(e,type) end

---设置Property属性
---@param e Effect
---@param prop1 integer
---@param prop2? integer
function Effect.SetProperty(e,prop1,prop2) end

---设置Label属性
---@param e Effect
---@param ... integer
function Effect.SetLabel(e,...) end

---设置LabelObject属性
---@param e Effect
---@param labelobject Card|Group|Effect
function Effect.SetLabelObject(e,labelobject) end

---设置Category属性
---@param e Effect
---@param cate integer
function Effect.SetCategory(e,cate) end

---设置提示时点，第二个和第三个参数分别表示 自己 和对方的回合
---@param e Effect
---@param s_time integer
---@param o_time? integer default: s_time
function Effect.SetHintTiming(e,s_time,o_time) end

---设置Condition属性
---@param e Effect
---@param con_func function
function Effect.SetCondition(e,con_func) end

---设置Target属性
---@param e Effect
---@param targ_func function
function Effect.SetTarget(e,targ_func) end

---设置Cost属性
---@param e Effect
---@param cost_func function
function Effect.SetCost(e,cost_func) end

---设置Value属性
---@param e Effect
---@param val function|integer|boolean
function Effect.SetValue(e,val) end

---设置Operation属性
---@param e Effect
---@param op_func nil|function
function Effect.SetOperation(e,op_func) end

---设置OwnerPlayer属性为player
---@param e Effect
---@param player? integer default: 0
function Effect.SetOwnerPlayer(e,player) end

---返回效果描述
---@return integer
---@param e Effect
function Effect.GetDescription(e) end

---返回code属性
---@return integer
---@param e Effect
function Effect.GetCode(e) end

---返回Type属性
---@return integer
---@param e Effect
function Effect.GetType(e) end

---返回Property属性
---@return integer
---@return integer
---@param e Effect
function Effect.GetProperty(e) end

---返回Label属性
---@return ... integer
---@param e Effect
function Effect.GetLabel(e) end

---返回LabelObject属性
---@return Card|Group|Effect
---@param e Effect
function Effect.GetLabelObject(e) end

---返回Category属性
---@return integer
---@param e Effect
function Effect.GetCategory(e) end

---返回Owner属性
---@return Card
---@param e Effect
function Effect.GetOwner(e) end

---返回效果在哪一张卡上生效(通常是用Card.RegisterEffect注册该效果的卡)
---@return Card
---@param e Effect
function Effect.GetHandler(e) end

---返回condition属性
---@return function
---@param e Effect
function Effect.GetCondition(e) end

---返回target属性
---@return function
---@param e Effect
function Effect.GetTarget(e) end

---返回cost属性
---@return function
---@param e Effect
function Effect.GetCost(e) end

---返回value属性
---@return function|integer
---@param e Effect
function Effect.GetValue(e) end

---返回operation属性
---@return function
---@param e Effect
function Effect.GetOperation(e) end

---返回e的效果类型（怪兽·魔法·陷阱）
---与发动该效果的卡的类型不一定相同，比如灵摆效果视为魔法卡的效果
---@return integer
---@param e Effect
function Effect.GetActiveType(e) end

---检查e的效果类型（怪兽·魔法·陷阱）是否有type
---@return boolean
---@param e Effect
---@param type integer
function Effect.IsActiveType(e,type) end

---返回OwnerPlayer属性（发动效果、建立效果的玩家）
---若無OwnerPlayer属性，则是Owner的控制者
---@return integer
---@param e Effect
function Effect.GetOwnerPlayer(e) end

---返回当前玩家，一般是Handler的控制者
---@return integer
---@param e Effect
function Effect.GetHandlerPlayer(e) end

---检查效果是否含有标志prop1[和prop2]
---@return boolean
---@param e Effect
---@param prop1 integer
---@param prop2? integer
function Effect.IsHasProperty(e,prop1,prop2) end

---检查效果是否含有效果分类cate
---@return boolean
---@param e Effect
---@param cate integer
function Effect.IsHasCategory(e,cate) end

---检查效果是否属于类型type
---@return boolean
---@param e Effect
---@param type integer
function Effect.IsHasType(e,type) end

---检查效果e能否由player发动
---neglect_loc=true 为不检测发动位置(手卡)， neglect_target=true 为不检测对象要求
---@return boolean
---@param e Effect
---@param player integer
---@param neglect_loc? boolean default: false
---@param neglect_target? boolean default: false
function Effect.IsActivatable(e,player,neglect_loc,neglect_target) end

---检查效果e是否是已发动的效果
---@return boolean
---@param e Effect
function Effect.IsActivated(e) end

---检查效果e是否检查过cost，即是否是被复制的
---@return boolean
---@param e Effect
function Effect.IsCostChecked(e) end

---设置效果e的cost检查标记为b
---@param e Effect
---@param b boolean
function Effect.SetCostCheck(e,b) end

---返回效果e的发动区域
---@return integer
---@param e Effect
function Effect.GetActivateLocation(e) end

---返回效果e的发动区域序号
---@return integer
---@param e Effect
function Effect.GetActivateSequence(e) end

---检测玩家 p 是否还有可以发动的效果 e 的次数
---@return boolean
---@param e Effect
---@param p integer
function Effect.CheckCountLimit(e,p) end

---手动减少玩家 p 对效果 e 的 count 个可用次数[ oath_only 为 该效果是否是 EFFECT_FLAG_OATH]
---@param e Effect
---@param p integer
---@param count? integer default: 1
---@param oath_only? boolean default: false
function Effect.UseCountLimit(e,p,count,oath_only) end

---@class Group
---@operator add(Group|Card): Group

---@class Group
---@operator sub(Group|Card): Group

---新建一个空的卡片组
---@return Group
function Group.CreateGroup() end

---让卡片组持续，把卡片组设置为效果的LabelObject需要设置
---@param g Group
function Group.KeepAlive(g) end

---删除卡片组g
---@param g Group
function Group.DeleteGroup(g) end

---新建卡片组g的副本
---@return Group
---@param g Group
function Group.Clone(g) end

---不定参数，把传入的所有卡组合成一个卡片组并返回，所有参数只能是 Card 类型。
---没有参数时，相当于Group.CreateGroup()
---@return Group
---@param ... Card
function Group.FromCards(...) end

---清空卡片组
---@param g Group
function Group.Clear(g) end

---往g中增加c
---@param g Group
---@param c Card
function Group.AddCard(g,c) end

---把c从g中移除
---@param g Group
---@param c Card
function Group.RemoveCard(g,c) end

---使指针指向下一张卡并返回这张卡，如果不存在则返回nil
---@return Card
---@param g Group
function Group.GetNext(g) end

---返回g中第一张卡，并重置当前指针到g中第一张卡
---如果g中不存在卡则返回nil
---@return Card
---@param g Group
function Group.GetFirst(g) end

---返回g中卡的数量
---@return integer
---@param g Group
function Group.GetCount(g) end

---以g中的每一张卡作为参数调用一次f ,第三个参数开始为额外参数
---@param g Group
---@param f function
---@param ... any
function Group.ForEach(g,f,...) end

---过滤函数，从g中筛选满足筛选条件f并且不等于ex的卡
---从第4个参数开始为额外参数
---@return Group
---@param g Group
---@param f function
---@param ex Card|Group|nil
---@param ... any
function Group.Filter(g,f,ex,...) end

---过滤函数，和Group.Filter基本相同，不同之处在于此函数只返回满足条件的卡的数量
---@return integer
---@param g Group
---@param f function
---@param ex Card|Group|nil
---@param ... any
function Group.FilterCount(g,f,ex,...) end

---过滤函数，让玩家player从g中选择 min-max 张满足筛选条件f并且不等于ex的卡
---从第7个参数开始为额外参数
---@return Group
---@param g Group
---@param player integer
---@param f function
---@param min integer
---@param max integer
---@param ex Card|Group|nil
---@param ... any
function Group.FilterSelect(g,player,f,min,max,ex,...) end

---让玩家player从g中选择min-max张不等于ex的卡
---@return Group
---@param g Group
---@param player integer
---@param min integer
---@param max integer
---@param ex Card|Group|nil
function Group.Select(g,player,min,max,ex) end

---让玩家 player 从 cg 中选择 1 张卡放入 sg ，并返回选的卡。  
---btok 表示是否可以点击完成选择的按钮， cancelable 表示是否可以取消整个选择返回 nil， 
---minc 和 maxc 是客户端的文字缓冲提示，表示需要选择 minc-maxc 张卡，但是这个只是影响视觉效果，并不代表必须要选择那个数量
---@return Card|nil
---@param cg Group
---@param sg Group|nil 已选的卡，可以从中取消选择
---@param player integer
---@param btok boolean default: false
---@param cancelable boolean default: false
---@param minc integer
---@param maxc integer
function Group.SelectUnselect(cg,sg,player,btok,cancelable,minc,maxc) end

---让玩家player从g中随机选择count张卡
---因为是随机选择，所以参数player基本无用，由系统随机选取
---@return Group
---@param g Group
---@param player integer
---@param count integer
function Group.RandomSelect(g,player,count) end

---让玩家player从g中选择min-max张不等于ex的卡，可以取消并返回nil
---@return Group
---@param g Group
---@param player integer
---@param min integer
---@param max integer
---@param ex Card|Group|nil
function Group.CancelableSelect(g,player,min,max,ex) end

---过滤函数，检查g中是否存在至少count张满足筛选条件f并且不等于ex的卡
---从第5个参数开始为额外参数
---@return boolean
---@param g Group
---@param f function
---@param count integer
---@param ex Card|Group|nil
---@param ... any
function Group.IsExists(g,f,count,ex,...) end

---子集求和判定函数，f为返回一个interger值的函数
---检查g中是否存在一个数量为min-max的子集满足以f对子集的每一个元素求值的和等于sum，从第6个参数开始为额外参数
---	比如：g:CheckWithSumEqual(Card.GetSynchroLevel,7,2,99)
---	检查g中是否存在一个子集满足子集的同调用等级之和等于7
---@return boolean
---@param g Group
---@param f function
---@param sum integer
---@param min integer default: 0
---@param max integer
---@param ... any
function Group.CheckWithSumEqual(g,f,sum,min,max,...) end

---让玩家player从g中选取一个数量为min-max的子集使子集的特定函数的和等于sum，从第7个参数开始为额外参数
---@return Group
---@param g Group
---@param player integer
---@param f function
---@param sum integer
---@param min integer
---@param max integer
---@param ... any
function Group.SelectWithSumEqual(g,player,f,sum,min,max,...) end

---子集求和判定函数之二，f为返回一个interger值的函数
---检查g中是否存在一个子集满足以f对子集的每一个元素求值的和刚好大于或者等于sum，从第4个参数开始为额外参数
---比如：g:CheckWithSumGreater(Card.GetRitualLevel,8)
---	检查g中是否存在一个子集满足子集的仪式用等级之和大于等于8
---	注：判定必须是“刚好”大于或者等于
---	以等级为例，要使等级合计大于等于8，可以选择LV1+LV7而不可以选择LV1+LV4+LV4
---@return boolean
---@param g Group
---@param f function
---@param sum integer
---@param ... any
function Group.CheckWithSumGreater(g,f,sum,...) end

---让玩家player从g中选取一个子集使子集的特定函数f的和大于等于sum，从第5个参数开始为额外参数
---@return Group
---@param g Group
---@param player integer
---@param f function
---@param sum integer
---@param ... any
function Group.SelectWithSumGreater(g,player,f,sum,...) end

---f为返回一个interger值的函数，从g中筛选出具有最小的f的值的卡
---第2个返回值为这个最小值，从第3个参数开始为额外参数
---要使用第2个返回值注意检查g非空
---@return Group
---@return integer
---@param g Group
---@param f function
---@param ... any
function Group.GetMinGroup(g,f,...) end

---f为返回一个interger值的函数，从g中筛选出具有最大的f的值的卡
---第2个返回值为这个最大值，从第3个参数开始为额外参数
---要使用第2个返回值注意检查g非空
---@return Group
---@return integer
---@param g Group
---@param f function
---@param ... any
function Group.GetMaxGroup(g,f,...) end

---计算g中所有卡的取值的总和，f为为每张卡的取值函数，从第3个参数开始为额外参数
---@return integer
---@param g Group
---@param f function
---@param ... any
function Group.GetSum(g,f,...) end

---计算g中所有卡的种类数量，f为分类的依据，返回相同的值视为同一种类，从第3个参数开始为额外参数
---比如 g:GetClassCount(Card.GetCode()) 就是计算g中卡名不同的卡的数量
---@return integer
---@param g Group
---@param f function
---@param ... any
function Group.GetClassCount(g,f,...) end

---从g中移除满足筛选条件f并且不等于ex的所有卡，第4个参数开始是额外参数
---@param g Group
---@param f function
---@param ex Card|nil
---@param ... any
function Group.Remove(g,f,ex,...) end

---把g2中的所有卡合并到g1，若g1中原本就有属于g2的卡，那些卡将不会重复
---注：g2本身不会发生变化
---@param g1 Group
---@param g2 Group
function Group.Merge(g1,g2) end

---从g1中移除属于g2中的卡
---注：g2本身不会发生变化
---@param g1 Group
---@param g2 Group
function Group.Sub(g1,g2) end

---判断g1和g2是否相同
---@return boolean
---@param g1 Group
---@param g2 Group
function Group.Equal(g1,g2) end

---检查g中是否存在卡片c
---@return boolean
---@param g Group
---@param c Card
function Group.IsContains(g,c) end

---过滤函数，返回g中满足筛选条件f的第一张卡，若没有则返回nil，从第3个参数开始为额外参数
---@return Card
---@param g Group
---@param f function
---@param ... any
function Group.SearchCard(g,f,...) end

---和 Group.GetClassCount 类似，但是算法不同(使用位运算)
---@return integer
---@param g Group
---@param f function
---@param ... any
function Group.GetBinClassCount(g,f,...) end

---显示消息。
---注意，只会在本地生效，在服务器端不会生效。
---@param msg any
function Debug.Message(msg) end

---添加卡片，将卡号为code的卡片的持有者设置为owner，以表示形式pos放置在player的场上位于location上序号为seq的格子处
---proc=true则完成正规召唤程序(即解除苏生限制)
---@return Card
---@param code integer
---@param owner integer
---@param player integer
---@param location integer
---@param seq integer
---@param pos integer
---@param proc? boolean default: false
function Debug.AddCard(code,owner,player,location,seq,pos,proc) end

---设置玩家信息，基本分为lp，初始手卡为startcount张，每回合抽drawcount张
---在残局当中， playerid ：自己=0,对方=1
---@param playerid integer
---@param lp integer
---@param startcount integer
---@param drawcount integer
function Debug.SetPlayerInfo(playerid,lp,startcount,drawcount) end

---设置卡片c的召唤信息：以 sum_type 方法(通常召唤、特殊召唤等)[从 sum_location]出场
---@param c Card
---@param sum_type integer
---@param sum_location? integer default: 0
function Debug.PreSummon(c,sum_type,sum_location) end

---为target添加装备equip_card ，返回值表示是否成功
---@return boolean
---@param equip_card Card
---@param target Card
function Debug.PreEquip(equip_card,target) end

---把target选为c的永续对象
---@param c Card
---@param target Card
function Debug.PreSetTarget(c,target) end

---为c添加count个counter_type的指示物
---@param c Card
---@param counter_type integer
---@param count? integer default: 0
function Debug.PreAddCounter(c,counter_type,count) end

---以选项flag开始布局
---	flag 残局： DUEL_ATTACK_FIRST_TURN+DUEL_SIMPLE_AI
---		 大师规则1： DUEL_OBSOLETE_RULING
---	rule=5 是大师规则2020
---@param flag integer
---@param rule? integer default: 5
function Debug.ReloadFieldBegin(flag,rule) end

---布局结束
function Debug.ReloadFieldEnd() end

---设置AI的名字，最大长度 100 个字符（1个汉字2个字符）
---@param name string
function Debug.SetAIName(name) end

---显示消息提示框，最大长度 1024 个字符（1个汉字2个字符）
---注意，只会在本地生效，在服务器端不会生效。
---@param msg string
function Debug.ShowHint(msg) end

Auxiliary={}
aux=Auxiliary
POS_FACEUP_DEFENCE=POS_FACEUP_DEFENSE
POS_FACEDOWN_DEFENCE=POS_FACEDOWN_DEFENSE
RACE_CYBERS=RACE_CYBERSE

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
--return the column of card c (from the viewpoint of p)
function Auxiliary.GetColumn(c,p)
	local seq=c:GetSequence()
	if c:IsLocation(LOCATION_MZONE) then
		if seq==5 then
			seq=1
		elseif seq==6 then
			seq=3
		end
	elseif c:IsLocation(LOCATION_SZONE) then
		if seq>4 then
			return nil
		end
	else
		return nil
	end
	if c:IsControler(p or 0) then
		return seq
	else
		return 4-seq
	end
end
--return the column of monster zone seq (from the viewpoint of controller)
function Auxiliary.MZoneSequence(seq)
	if seq==5 then return 1 end
	if seq==6 then return 3 end
	return seq
end
--return the column of spell/trap zone seq (from the viewpoint of controller)
function Auxiliary.SZoneSequence(seq)
	if seq>4 then return nil end
	return seq
end
--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

# 三个残局代码遗留问题

## DEFENSE

不要用 DEFENCE ，现在该用 DEFENSE 。

## 卡片朝向

卡组、额外卡组、手卡的默认朝向应该为朝下。

## 怪兽的攻守

怪兽才需要注意 ATTACK 与 DEFENSE ，且不可不加。

# 三个绑定函数

## PreSummon

### 原型

Debug.PreSummon(卡, 召唤类型[, 从哪个区域特召到场上])

### 召唤类型的可选值

1. SUMMON_TYPE_NORMAL--通常召唤
1. SUMMON_TYPE_ADVANCE--上级召唤
1. SUMMON_TYPE_DUAL--再度召唤（二重）
1. SUMMON_TYPE_FLIP--翻转召唤
1. SUMMON_TYPE_SPECIAL--特殊召唤
1. SUMMON_TYPE_FUSION--融合召唤
1. SUMMON_TYPE_RITUAL--仪式召唤
1. SUMMON_TYPE_SYNCHRO--同调召唤
1. SUMMON_TYPE_XYZ--超量召唤
1. SUMMON_TYPE_PENDULUM--灵摆召唤
1. SUMMON_TYPE_LINK--连接召唤

### 从哪个区域特召到场上的可选值

1. LOCATION_DECK--卡组
1. LOCATION_HAND--手牌
1. LOCATION_MZONE--主要怪兽区(0~4)+额外怪兽区(5~6)
1. LOCATION_SZONE--魔陷区(0~4)+场地区(5)
1. LOCATION_GRAVE--墓地
1. LOCATION_REMOVED--除外区
1. LOCATION_EXTRA--额外
1. LOCATION_OVERLAY--超量素材
1. LOCATION_ONFIELD--场上（LOCATION_MZONE+LOCATION_SZONE）

## PreEquip

### 原型

Debug.PreEquip(装备魔法卡, 怪兽卡)

## PreSetTarget

### 原型

Debug.PreSetTarget(保护卡, 被保护的卡)

### 补充

必须在布局完成之后再使用。