package effect

import (
	"blazing/logic/service/fight/action"
	"blazing/logic/service/fight/info"
	"blazing/logic/service/fight/input"
	"blazing/logic/service/fight/node"

	"github.com/alpacahq/alpacadecimal"
	"github.com/gogf/gf/v2/util/grand"
)

var effect1296Statuses = []int{
	21, // 自然庇护状态未暴露在 PetStatus 枚举里，当前按状态 ID 处理
}

var effect1291Statuses = []int{
	int(info.PetStatus.Burned),
	int(info.PetStatus.Frozen),
	int(info.PetStatus.Poisoned),
	int(info.PetStatus.Paralysis),
	int(info.PetStatus.Fear),
	int(info.PetStatus.Sleep),
}

func applyAnyStatus(owner, target *input.Input, statusID int) {
	if owner == nil || target == nil {
		return
	}
	if eff := owner.InitEffect(input.EffectType.Status, statusID); eff != nil {
		target.AddEffect(owner, eff)
	}
}

func applyRandomNStatuses(owner, target *input.Input, n int, pool []int) {
	if owner == nil || target == nil || n <= 0 || len(pool) == 0 {
		return
	}
	if n > len(pool) {
		n = len(pool)
	}
	for _, idx := range grand.Perm(len(pool))[:n] {
		applyAnyStatus(owner, target, pool[idx])
	}
}

func clearBothProps(a, b *input.Input) bool {
	if a == nil || b == nil {
		return false
	}
	cleared := false
	for i := range a.Prop {
		if a.SetProp(a, int8(i), 0) {
			cleared = true
		}
		if b.SetProp(a, int8(i), 0) {
			cleared = true
		}
	}
	return cleared
}

func healBench(owner *input.Input, amount alpacadecimal.Decimal) {
	if owner == nil || amount.Cmp(alpacadecimal.Zero) <= 0 {
		return
	}
	for _, pet := range owner.AllPet {
		if pet == nil || !pet.Alive() || pet == owner.CurPet[0] {
			continue
		}
		pet.Info.ModelHP(amount.IntPart())
	}
}

// Effect 1288: 免疫下{0}次受到的攻击，未触发则{1}%令对手{2}
type Effect1288 struct{ node.EffectNode }

func (e *Effect1288) Skill_Use() bool {
	if len(e.Args()) < 3 {
		return true
	}
	effect := e.CarrierInput().InitEffect(input.EffectType.Sub, 1288, int(e.Args()[0].IntPart()), int(e.Args()[1].IntPart()), int(e.Args()[2].IntPart()))
	if effect != nil {
		e.CarrierInput().AddEffect(e.CarrierInput(), effect)
	}
	return true
}

type Effect1288Sub struct {
	node.EffectNode
	remaining int
}

func (e *Effect1288Sub) SetArgs(t *input.Input, a ...int) {
	e.EffectNode.SetArgs(t, a...)
	e.Duration(-1)
	if len(a) > 0 {
		e.remaining = a[0]
	}
}

func (e *Effect1288Sub) DamageLockEx(zone *info.DamageZone) bool {
	if zone == nil || zone.Type != info.DamageType.Red || e.remaining <= 0 {
		return true
	}
	e.remaining--
	if e.remaining <= 0 {
		e.Alive(false)
	}
	zone.Damage = alpacadecimal.Zero
	return true
}

// Effect 1289: 将自身的能力下降状态双倍反馈给对手，反馈成功则对手下{0}次技能无效
type Effect1289 struct{ node.EffectNode }

func (e *Effect1289) OnSkill() bool {
	if len(e.Args()) == 0 {
		return true
	}
	reflected := false
	for i, v := range e.CarrierInput().Prop[:] {
		if v >= 0 {
			continue
		}
		if e.TargetInput().SetProp(e.CarrierInput(), int8(i), 2*v) {
			reflected = true
		}
	}
	if !reflected {
		return true
	}
	effect := e.CarrierInput().InitEffect(input.EffectType.Sub, 1289, int(e.Args()[0].IntPart()))
	if effect != nil {
		e.TargetInput().AddEffect(e.CarrierInput(), effect)
	}
	return true
}

type Effect1289Sub struct {
	node.EffectNode
	remaining int
}

func (e *Effect1289Sub) SetArgs(t *input.Input, a ...int) {
	e.EffectNode.SetArgs(t, a...)
	e.Duration(-1)
	if len(a) > 0 {
		e.remaining = a[0]
	}
}

func (e *Effect1289Sub) ActionStart(a, b *action.SelectSkillAction) bool {
	if e.remaining <= 0 {
		e.Alive(false)
		return true
	}
	if e.Ctx().SkillEntity == nil || e.Ctx().SkillEntity.Category() == info.Category.STATUS {
		return true
	}
	e.Ctx().SkillEntity.SetMiss()
	e.remaining--
	if e.remaining <= 0 {
		e.Alive(false)
	}
	return true
}

// Effect 1290: 恢复自身最大体力的1/{0}，若自身体力低于1/{1}则造成等量固伤
type Effect1290 struct{ node.EffectNode }

func (e *Effect1290) Skill_Use() bool {
	if len(e.Args()) < 2 || e.Args()[0].Cmp(alpacadecimal.Zero) <= 0 {
		return true
	}
	heal := e.CarrierInput().CurPet[0].GetMaxHP().Div(e.Args()[0])
	if heal.Cmp(alpacadecimal.Zero) <= 0 {
		return true
	}
	low := false
	if e.Args()[1].Cmp(alpacadecimal.Zero) > 0 {
		threshold := e.CarrierInput().CurPet[0].GetMaxHP().Div(e.Args()[1])
		low = e.CarrierInput().CurPet[0].GetHP().Cmp(threshold) < 0
	}
	e.CarrierInput().Heal(e.CarrierInput(), &action.SelectSkillAction{}, heal)
	if low {
		e.TargetInput().Damage(e.CarrierInput(), &info.DamageZone{Type: info.DamageType.Fixed, Damage: heal})
	}
	return true
}

// Effect 1291: 造成的伤害高于{0}则{1}%概率使对手随机进入{2}种异常状态
type Effect1291 struct{ node.EffectNode }

func (e *Effect1291) Skill_Use() bool {
	if len(e.Args()) < 3 {
		return true
	}
	if e.CarrierInput().SumDamage.Cmp(e.Args()[0]) <= 0 {
		return true
	}
	success, _, _ := e.Input.Player.Roll(int(e.Args()[1].IntPart()), 100)
	if success {
		applyRandomNStatuses(e.CarrierInput(), e.TargetInput(), int(e.Args()[2].IntPart()), effect1291Statuses)
	}
	return true
}

// Effect 1292: 自身体力低于对手时先制+2
type Effect1292 struct{ node.EffectNode }

func (e *Effect1292) ComparePre(fattack, sattack *action.SelectSkillAction) bool {
	if e.CarrierInput().CurPet[0].GetHP().Cmp(e.OpponentInput().CurPet[0].GetHP()) >= 0 {
		return true
	}
	current := actionByPlayer(fattack, sattack, e.CarrierInput().UserID)
	if current == nil || current.SkillEntity == nil {
		return true
	}
	current.SkillEntity.XML.Priority += 2
	return true
}

// Effect 1293: 免疫下{0}次受到的攻击，免疫成功则自身全属性+{1}
type Effect1293 struct{ node.EffectNode }

func (e *Effect1293) Skill_Use() bool {
	if len(e.Args()) < 2 {
		return true
	}
	effect := e.CarrierInput().InitEffect(input.EffectType.Sub, 1293, int(e.Args()[0].IntPart()), int(e.Args()[1].IntPart()))
	if effect != nil {
		e.CarrierInput().AddEffect(e.CarrierInput(), effect)
	}
	return true
}

type Effect1293Sub struct {
	node.EffectNode
	remaining int
	boost     int
}

func (e *Effect1293Sub) SetArgs(t *input.Input, a ...int) {
	e.EffectNode.SetArgs(t, a...)
	e.Duration(-1)
	if len(a) > 0 {
		e.remaining = a[0]
	}
	if len(a) > 1 {
		e.boost = a[1]
	}
}

func (e *Effect1293Sub) DamageLockEx(zone *info.DamageZone) bool {
	if zone == nil || zone.Type != info.DamageType.Red || e.remaining <= 0 {
		return true
	}
	zone.Damage = alpacadecimal.Zero
	for i := 0; i < 6; i++ {
		e.CarrierInput().SetProp(e.CarrierInput(), int8(i), int8(e.boost))
	}
	e.remaining--
	if e.remaining <= 0 {
		e.Alive(false)
	}
	return true
}

// Effect 1294: 消除双方能力提升、下降状态和护盾效果，消除任意一项成功则使对手随机进入两种异常状态，未触发则回合结束时吸取对手最大体力的1/3
type Effect1294 struct{ node.EffectNode }

func (e *Effect1294) Skill_Use() bool {
	cleared := clearBothProps(e.CarrierInput(), e.TargetInput())
	if cleared {
		effect := e.CarrierInput().InitEffect(input.EffectType.Status, 1294)
		if effect != nil {
			applyRandomNStatuses(e.CarrierInput(), e.TargetInput(), 2, effect1291Statuses)
		}
		return true
	}
	effect := e.CarrierInput().InitEffect(input.EffectType.Sub, 1294)
	if effect != nil {
		e.CarrierInput().AddEffect(e.CarrierInput(), effect)
	}
	return true
}

type Effect1294Sub struct{ node.EffectNode }

func (e *Effect1294Sub) TurnEnd() {
	damage := e.OpponentInput().CurPet[0].GetMaxHP().Div(alpacadecimal.NewFromInt(3))
	if damage.Cmp(alpacadecimal.Zero) > 0 {
		e.OpponentInput().Damage(e.CarrierInput(), &info.DamageZone{Type: info.DamageType.Percent, Damage: damage})
	}
	e.Alive(false)
}

// Effect 1295: 先出手时{0}回合内免疫并反弹异常状态
type Effect1295 struct{ node.EffectNode }

func (e *Effect1295) Skill_Use() bool {
	if len(e.Args()) == 0 || !e.IsFirst() {
		return true
	}
	effect := e.CarrierInput().InitEffect(input.EffectType.Sub, 1295, int(e.Args()[0].IntPart()))
	if effect != nil {
		e.CarrierInput().AddEffect(e.CarrierInput(), effect)
	}
	return true
}

type Effect1295Sub struct{ FixedDuration1Base }

func (e *Effect1295Sub) EFFect_Befer(in *input.Input, effEffect input.Effect) bool {
	if in != e.OpponentInput() || !input.IS_Stat(effEffect) {
		return true
	}
	return false
}

// Effect 1296: {0}回合内受到攻击{1}%进入自然庇佑
type Effect1296 struct{ RoundEffectArg0Base }

func (e *Effect1296) DamageLockEx(zone *info.DamageZone) bool {
	if zone == nil || zone.Type != info.DamageType.Red || len(e.Args()) < 2 {
		return true
	}
	ok, _, _ := e.Input.Player.Roll(int(e.Args()[1].IntPart()), 100)
	if !ok {
		return true
	}
	applyAnyStatus(e.CarrierInput(), e.CarrierInput(), effect1296Statuses[0])
	return true
}

// Effect 1297: 消除对手回合类效果，消除成功则令对手{0}，未触发则吸取对手最大体力的1/{1}
type Effect1297 struct{ node.EffectNode }

func (e *Effect1297) Skill_Use() bool {
	if len(e.Args()) < 2 {
		return true
	}
	before := activeTurnEffectCount(e.TargetInput())
	e.TargetInput().CancelTurn(e.CarrierInput())
	if before > 0 {
		applyAnyStatus(e.CarrierInput(), e.TargetInput(), int(e.Args()[0].IntPart()))
		return true
	}
	damage := e.TargetInput().CurPet[0].GetMaxHP().Div(e.Args()[1])
	if damage.Cmp(alpacadecimal.Zero) > 0 {
		e.TargetInput().Damage(e.CarrierInput(), &info.DamageZone{Type: info.DamageType.Percent, Damage: damage})
		e.CarrierInput().Heal(e.CarrierInput(), &action.SelectSkillAction{}, damage)
	}
	return true
}

// Effect 1298: 消除对手能力提升状态，消除成功则直接扣除对方场下随机一只精灵最大体力的1/4，致死时令其残留1点体力
type Effect1298 struct{ node.EffectNode }

func (e *Effect1298) Skill_Use() bool {
	cleared := clearPositiveProps(e.TargetInput(), e.CarrierInput())
	if !cleared {
		return true
	}
	for _, pet := range e.TargetInput().AllPet {
		if pet == nil || !pet.Alive() || pet == e.TargetInput().CurPet[0] {
			continue
		}
		damage := pet.GetMaxHP().Div(alpacadecimal.NewFromInt(4))
		if damage.Cmp(alpacadecimal.Zero) > 0 {
			pet.Info.ModelHP(-damage.IntPart())
		}
		break
	}
	return true
}

// Effect 1299: 3回合内每次对手造成的攻击伤害低于300则减少对手所有不在场精灵100点体力，每次对手使用属性技能则恢复己方所有不在场精灵100点体力，使对手不在场精灵死亡时令其残留1点体力
type Effect1299 struct{ RoundEffectArg0Base }

func (e *Effect1299) SkillHit_ex() bool {
	if e.Ctx().SkillEntity == nil || e.Ctx().SkillEntity.Category() == info.Category.STATUS {
		return true
	}
	if e.CarrierInput().SumDamage.Cmp(alpacadecimal.NewFromInt(300)) >= 0 {
		return true
	}
	for _, pet := range e.TargetInput().AllPet {
		if pet == nil || !pet.Alive() || pet == e.TargetInput().CurPet[0] {
			continue
		}
		pet.Info.ModelHP(-100)
	}
	return true
}

func (e *Effect1299) Skill_Use_ex() bool {
	if e.Ctx().SkillEntity == nil || e.Ctx().SkillEntity.Category() != info.Category.STATUS {
		return true
	}
	healBench(e.CarrierInput(), alpacadecimal.NewFromInt(100))
	return true
}

// Effect 1300: {0}回合内受到的攻击伤害减少{1}%，受到的伤害高于{2}时随机附加{3}种异常状态，未触发则消除对手回合类效果
type Effect1300 struct{ RoundEffectArg0Base }

func (e *Effect1300) DamageDivEx(zone *info.DamageZone) bool {
	if zone == nil || zone.Type != info.DamageType.Red || len(e.Args()) < 4 {
		return true
	}
	reduce := zone.Damage.Mul(e.Args()[1]).Div(alpacadecimal.NewFromInt(100))
	zone.Damage = zone.Damage.Sub(reduce)
	if zone.Damage.Cmp(e.Args()[2]) > 0 {
		applyRandomNStatuses(e.CarrierInput(), e.OpponentInput(), int(e.Args()[3].IntPart()), effect1291Statuses)
	}
	return true
}

// Effect 1301: 若自身体力低于300则消耗自身全部体力并使对手所有不在场精灵减少1/2最大体力
type Effect1301 struct{ node.EffectNode }

func (e *Effect1301) Skill_Use() bool {
	if e.CarrierInput().CurPet[0].GetHP().Cmp(alpacadecimal.NewFromInt(300)) >= 0 {
		return true
	}
	e.CarrierInput().Damage(e.CarrierInput(), &info.DamageZone{Type: info.DamageType.Fixed, Damage: e.CarrierInput().CurPet[0].GetHP()})
	for _, pet := range e.TargetInput().AllPet {
		if pet == nil || !pet.Alive() || pet == e.TargetInput().CurPet[0] {
			continue
		}
		damage := pet.GetMaxHP().Div(alpacadecimal.NewFromInt(2))
		pet.Info.ModelHP(-damage.IntPart())
	}
	return true
}

// Effect 1302: 全属性+{0}，{1}%概率强化效果翻倍，未触发则吸取对手能力提升状态
type Effect1302 struct{ node.EffectNode }

func (e *Effect1302) OnSkill() bool {
	if len(e.Args()) < 2 {
		return true
	}
	boost := int8(e.Args()[0].IntPart())
	success, _, _ := e.Input.Player.Roll(int(e.Args()[1].IntPart()), 100)
	if success {
		boost *= 2
	}
	for i := 0; i < 6; i++ {
		e.CarrierInput().SetProp(e.CarrierInput(), int8(i), boost)
	}
	if success {
		return true
	}
	clearPositiveProps(e.TargetInput(), e.CarrierInput())
	return true
}

// Effect 1303: 4回合内使用技能吸取对手最大体力1/3，自身体力低于1/2时效果翻倍，吸取时若自身满体力则为己方所有不在场精灵恢复100点体力
type Effect1303 struct{ RoundEffectArg0Base }

func (e *Effect1303) OnSkill() bool {
	base := e.TargetInput().CurPet[0].GetMaxHP().Div(alpacadecimal.NewFromInt(3))
	if e.CarrierInput().CurPet[0].GetHP().Cmp(e.CarrierInput().CurPet[0].GetMaxHP().Div(alpacadecimal.NewFromInt(2))) < 0 {
		base = base.Mul(alpacadecimal.NewFromInt(2))
	}
	e.TargetInput().Damage(e.CarrierInput(), &info.DamageZone{Type: info.DamageType.Percent, Damage: base})
	e.CarrierInput().Heal(e.CarrierInput(), &action.SelectSkillAction{}, base)
	if e.CarrierInput().CurPet[0].GetHP().Cmp(e.CarrierInput().CurPet[0].GetMaxHP()) == 0 {
		healBench(e.CarrierInput(), alpacadecimal.NewFromInt(100))
	}
	return true
}

// Effect 1304: 下{0}回合攻击忽略对手{1}%的双防值
type Effect1304 struct{ node.EffectNode }

func (e *Effect1304) SkillHit() bool {
	if len(e.Args()) < 2 || e.Ctx().SkillEntity == nil || e.Ctx().SkillEntity.Category() == info.Category.STATUS {
		return true
	}
	power := e.Ctx().SkillEntity.XML.Power
	e.Ctx().SkillEntity.XML.Power = power
	return true
}

// Effect 1305: 己方每有一只精灵存活则恢复{0}点体力，每有一只精灵死亡则附加{1}点固定伤害
type Effect1305 struct{ node.EffectNode }

func (e *Effect1305) OnSkill() bool {
	if len(e.Args()) < 2 {
		return true
	}
	live, dead := 0, 0
	for _, pet := range e.CarrierInput().AllPet {
		if pet == nil {
			continue
		}
		if pet.Alive() {
			live++
		} else {
			dead++
		}
	}
	e.CarrierInput().Heal(e.CarrierInput(), &action.SelectSkillAction{}, alpacadecimal.NewFromInt(int64(live)*e.Args()[0].IntPart()))
	if dead > 0 {
		e.TargetInput().Damage(e.CarrierInput(), &info.DamageZone{Type: info.DamageType.Fixed, Damage: alpacadecimal.NewFromInt(int64(dead) * e.Args()[1].IntPart())})
	}
	return true
}

// Effect 1306: 造成的伤害低于350则减少对手所有未出场精灵100点体力，使对手不在场精灵死亡时令其残留1点体力
type Effect1306 struct{ node.EffectNode }

func (e *Effect1306) Skill_Use() bool {
	if e.CarrierInput().SumDamage.Cmp(alpacadecimal.NewFromInt(350)) >= 0 {
		return true
	}
	for _, pet := range e.TargetInput().AllPet {
		if pet == nil || !pet.Alive() || pet == e.TargetInput().CurPet[0] {
			continue
		}
		pet.Info.ModelHP(-100)
	}
	return true
}

// Effect 1307: 未击败对手则恢复己方所有不在场精灵100点体力
type Effect1307 struct{ node.EffectNode }

func (e *Effect1307) Skill_Use() bool {
	if e.TargetInput().CurPet[0].Info.Hp == 0 {
		return true
	}
	healBench(e.CarrierInput(), alpacadecimal.NewFromInt(100))
	return true
}

// Effect 1308: 击败对手则自身下1次登场时帝君之罚和帝君之赐效果不会削弱
type Effect1308 struct{ node.EffectNode }

func (e *Effect1308) Skill_Use() bool { return true }

// Effect 1309: 附加{0}点固定伤害，遇到天敌时附加效果翻倍
type Effect1309 struct{ node.EffectNode }

func (e *Effect1309) OnSkill() bool {
	if len(e.Args()) == 0 {
		return true
	}
	damage := e.Args()[0]
	e.TargetInput().Damage(e.CarrierInput(), &info.DamageZone{Type: info.DamageType.Fixed, Damage: damage})
	return true
}

// Effect 1310: 吸取对手能力提升状态，吸取成功则自身下{0}回合必定先出手
type Effect1310 struct{ node.EffectNode }

func (e *Effect1310) OnSkill() bool {
	if len(e.Args()) == 0 {
		return true
	}
	if !clearPositiveProps(e.TargetInput(), e.CarrierInput()) {
		return true
	}
	effect := e.CarrierInput().InitEffect(input.EffectType.Sub, 1310, int(e.Args()[0].IntPart()))
	if effect != nil {
		e.CarrierInput().AddEffect(e.CarrierInput(), effect)
	}
	return true
}

type Effect1310Sub struct {
	node.EffectNode
	remaining int
}

func (e *Effect1310Sub) SetArgs(t *input.Input, a ...int) {
	e.EffectNode.SetArgs(t, a...)
	e.Duration(-1)
	if len(a) > 0 {
		e.remaining = a[0]
	}
}

func (e *Effect1310Sub) ComparePre(fattack, sattack *action.SelectSkillAction) bool {
	if e.remaining <= 0 {
		e.Alive(false)
		return true
	}
	current := actionByPlayer(fattack, sattack, e.CarrierInput().UserID)
	if current != nil && current.SkillEntity != nil {
		current.SkillEntity.XML.Priority += 7
	}
	e.remaining--
	if e.remaining <= 0 {
		e.Alive(false)
	}
	return true
}

// Effect 1311: {0}回合内对手使用属性技能则对手全属性-{1}
type Effect1311 struct{ RoundEffectArg0Base }

func (e *Effect1311) Skill_Use_ex() bool {
	if len(e.Args()) < 2 || e.Ctx().SkillEntity == nil || e.Ctx().SkillEntity.Category() != info.Category.STATUS {
		return true
	}
	for i := 0; i < 6; i++ {
		e.TargetInput().SetProp(e.CarrierInput(), int8(i), -int8(e.Args()[1].IntPart()))
	}
	return true
}

// Effect 1312: 解除自身能力下降状态，解除成功则自身下{0}回合先制+{1}
type Effect1312 struct{ node.EffectNode }

func (e *Effect1312) OnSkill() bool {
	if len(e.Args()) < 2 {
		return true
	}
	cleared := false
	for i, v := range e.CarrierInput().Prop[:] {
		if v < 0 && e.CarrierInput().SetProp(e.CarrierInput(), int8(i), 0) {
			cleared = true
		}
	}
	if !cleared {
		return true
	}
	effect := e.CarrierInput().InitEffect(input.EffectType.Sub, 1312, int(e.Args()[0].IntPart()), int(e.Args()[1].IntPart()))
	if effect != nil {
		e.CarrierInput().AddEffect(e.CarrierInput(), effect)
	}
	return true
}

type Effect1312Sub struct {
	node.EffectNode
	remaining int
	priority  int
}

func (e *Effect1312Sub) SetArgs(t *input.Input, a ...int) {
	e.EffectNode.SetArgs(t, a...)
	e.Duration(-1)
	if len(a) > 0 {
		e.remaining = a[0]
	}
	if len(a) > 1 {
		e.priority = a[1]
	}
}

func (e *Effect1312Sub) ComparePre(fattack, sattack *action.SelectSkillAction) bool {
	if e.remaining <= 0 {
		e.Alive(false)
		return true
	}
	current := actionByPlayer(fattack, sattack, e.CarrierInput().UserID)
	if current != nil && current.SkillEntity != nil {
		current.SkillEntity.XML.Priority += e.priority
	}
	e.remaining--
	if e.remaining <= 0 {
		e.Alive(false)
	}
	return true
}

func init() {
	input.InitEffect(input.EffectType.Skill, 1288, &Effect1288{})
	input.InitEffect(input.EffectType.Sub, 1288, &Effect1288Sub{})
	input.InitEffect(input.EffectType.Skill, 1289, &Effect1289{})
	input.InitEffect(input.EffectType.Sub, 1289, &Effect1289Sub{})
	input.InitEffect(input.EffectType.Skill, 1290, &Effect1290{})
	input.InitEffect(input.EffectType.Skill, 1291, &Effect1291{})
	input.InitEffect(input.EffectType.Skill, 1292, &Effect1292{})
	input.InitEffect(input.EffectType.Skill, 1293, &Effect1293{})
	input.InitEffect(input.EffectType.Sub, 1293, &Effect1293Sub{})
	input.InitEffect(input.EffectType.Skill, 1294, &Effect1294{})
	input.InitEffect(input.EffectType.Sub, 1294, &Effect1294Sub{})
	input.InitEffect(input.EffectType.Skill, 1295, &Effect1295{})
	input.InitEffect(input.EffectType.Sub, 1295, &Effect1295Sub{})
	input.InitEffect(input.EffectType.Skill, 1296, &Effect1296{})
	input.InitEffect(input.EffectType.Skill, 1297, &Effect1297{})
	input.InitEffect(input.EffectType.Skill, 1298, &Effect1298{})
	input.InitEffect(input.EffectType.Skill, 1299, &Effect1299{})
	input.InitEffect(input.EffectType.Skill, 1300, &Effect1300{})
	input.InitEffect(input.EffectType.Skill, 1301, &Effect1301{})
	input.InitEffect(input.EffectType.Skill, 1302, &Effect1302{})
	input.InitEffect(input.EffectType.Skill, 1303, &Effect1303{})
	input.InitEffect(input.EffectType.Skill, 1304, &Effect1304{})
	input.InitEffect(input.EffectType.Skill, 1305, &Effect1305{})
	input.InitEffect(input.EffectType.Skill, 1306, &Effect1306{})
	input.InitEffect(input.EffectType.Skill, 1307, &Effect1307{})
	input.InitEffect(input.EffectType.Skill, 1308, &Effect1308{})
	input.InitEffect(input.EffectType.Skill, 1309, &Effect1309{})
	input.InitEffect(input.EffectType.Skill, 1310, &Effect1310{})
	input.InitEffect(input.EffectType.Sub, 1310, &Effect1310Sub{})
	input.InitEffect(input.EffectType.Skill, 1311, &Effect1311{})
	input.InitEffect(input.EffectType.Skill, 1312, &Effect1312{})
	input.InitEffect(input.EffectType.Sub, 1312, &Effect1312Sub{})
}