Commit: bf71913ba3881dad1e6a10babde2ba0f12084d88 - ikemen_go (git)

Go で書き直した Ikemen

Commit MetaInfo

• Revision: bf71913ba3881dad1e6a10babde2ba0f12084d88 (tree)
• Zeit: 2016-12-21 01:45:39
• Autor: SUEHIRO <supersuehiro@user...>
• Commiter: SUEHIRO

Log Message

旧式トリガーのところを書くのが大変だった

Ändern Zusammenfassung

• modified: src/bytecode.go
• modified: src/char.go
• modified: src/common.go
• modified: src/compiler.go
• modified: src/image.go
• modified: src/system.go

Diff

--- a/src/bytecode.go
+++ b/src/bytecode.go
@@ -5,7 +5,7 @@ import (
 	"unsafe"
 )
 
-type StateType uint32
+type StateType int32
 
 const (
 	ST_S StateType = 1 << iota
@@ -19,7 +19,7 @@ const (
 	ST_P = ST_U
 )
 
-type AttackType uint32
+type AttackType int32
 
 const (
 	AT_NA AttackType = 1 << (iota + 6)
@@ -33,7 +33,7 @@ const (
 	AT_HP
 )
 
-type MoveType uint32
+type MoveType int32
 
 const (
 	MT_I MoveType = 1 << (iota + 15)
@@ -67,6 +67,7 @@ const (
 	OC_dup
 	OC_swap
 	OC_run
+	OC_jsf8
 	OC_jmp8
 	OC_jz8
 	OC_jnz8
@@ -187,7 +188,6 @@ const (
 	OC_hitfall
 	OC_hitvel_x
 	OC_hitvel_y
-	OC_roundno
 	OC_roundsexisted
 	OC_parent
 	OC_root
@@ -361,8 +361,10 @@ const (
 	OC_ex_drawgame
 	OC_ex_matchover
 	OC_ex_matchno
+	OC_ex_roundno
 	OC_ex_ishometeam
 	OC_ex_tickspersecond
+	OC_ex_timemod
 )
 
 type StringPool struct {
@@ -636,6 +638,16 @@ func (be BytecodeExp) run(c *Char, scpn int) BytecodeValue {
 	orgc := c
 	for i := 1; i <= len(be); i++ {
 		switch be[i-1] {
+		case OC_jsf8:
+			if sys.bcStack.Top().IsSF() {
+				if be[i] == 0 {
+					i = len(be)
+				} else {
+					i += int(uint8(be[i])) + 1
+				}
+			} else {
+				i++
+			}
 		case OC_jz8, OC_jnz8:
 			if sys.bcStack.Top().ToB() == (be[i-1] == OC_jz8) {
 				i++
@@ -749,10 +761,16 @@ func (be BytecodeExp) run(c *Char, scpn int) BytecodeValue {
 			sys.bcStack.Push(BytecodeBool(c.alive()))
 		case OC_random:
 			sys.bcStack.Push(BytecodeInt(Rand(0, 999)))
+		case OC_roundstate:
+			sys.bcStack.Push(BytecodeInt(c.roundState()))
 		case OC_anim:
 			sys.bcStack.Push(BytecodeInt(c.animNo()))
 		case OC_animtime:
 			sys.bcStack.Push(BytecodeInt(c.animTime()))
+		case OC_animelemtime:
+			sys.bcStack.Push(BytecodeInt(c.animElemTime(sys.bcStack.Pop().ToI())))
+		case OC_ex_:
+			be.run_ex(c, scpn, &i)
 		default:
 			unimplemented()
 		}
@@ -760,6 +778,13 @@ func (be BytecodeExp) run(c *Char, scpn int) BytecodeValue {
 	}
 	return sys.bcStack.Pop()
 }
+func (be BytecodeExp) run_ex(c *Char, scpn int, i *int) {
+	(*i)++
+	switch be[*i-1] {
+	case OC_ex_matchover:
+		sys.bcStack.Push(BytecodeBool(sys.matchOver()))
+	}
+}
 func (be BytecodeExp) evalF(c *Char, scpn int) float32 {
 	return be.run(c, scpn).ToF()
 }
@@ -1316,6 +1341,23 @@ func (sc ctrlSet) Run(c *Char, ps *int32) bool {
 	return false
 }
 
+type hitDef StateControllerBase
+
+const (
+	hitDef_ byte = iota
+)
+
+func (sc hitDef) Run(c *Char, ps *int32) bool {
+	StateControllerBase(sc).run(c, ps, func(id byte, exp []BytecodeExp) bool {
+		switch id {
+		case hitDef_:
+		}
+		unimplemented()
+		return true
+	})
+	return false
+}
+
 type StateBytecode struct {
 	stateType StateType
 	moveType  MoveType

--- a/src/char.go
+++ b/src/char.go
@@ -296,26 +296,26 @@ func (cm *CharMovement) init() {
 	cm.down.friction_threshold = 0.05
 }
 
-type Reaction1 int32
+type Reaction int32
 
 const (
-	AT_Light Reaction1 = iota
-	AT_Medium
-	AT_Hard
-	AT_Back
-	AT_Up
-	AT_Diagup
-	AT_Unknown
+	RA_Light Reaction = iota
+	RA_Medium
+	RA_Hard
+	RA_Back
+	RA_Up
+	RA_Diagup
+	RA_Unknown
 )
 
-type Reaction2 int32
+type HitType int32
 
 const (
-	R2_None Reaction2 = iota
-	R2_High
-	R2_Low
-	R2_Trip
-	R2_Unknown
+	HT_None HitType = iota
+	HT_High
+	HT_Low
+	HT_Trip
+	HT_Unknown
 )
 
 type AiuchiType int32
@@ -327,7 +327,7 @@ const (
 )
 
 type Fall struct {
-	animtype       Reaction1
+	animtype       Reaction
 	xvelocity      float32
 	yvelocity      float32
 	recover        int32
@@ -341,23 +341,23 @@ type Fall struct {
 }
 
 func (f *Fall) clear() {
-	*f = Fall{animtype: AT_Unknown, xvelocity: float32(math.NaN()),
+	*f = Fall{animtype: RA_Unknown, xvelocity: float32(math.NaN()),
 		yvelocity: -4.5}
 }
 func (f *Fall) setDefault() {
-	*f = Fall{animtype: AT_Unknown, xvelocity: float32(math.NaN()),
+	*f = Fall{animtype: RA_Unknown, xvelocity: float32(math.NaN()),
 		yvelocity: -4.5, recover: 1, recovertime: 4, kill: 1, envshake_freq: 60,
 		envshake_ampl: -4, envshake_phase: float32(math.NaN())}
 }
 
 type HitDef struct {
-	attr                       uint32
-	reversal_attr              uint32
-	hitflag                    uint32
-	guardflag                  uint32
+	attr                       int32
+	reversal_attr              int32
+	hitflag                    int32
+	guardflag                  int32
 	affectteam                 int32
-	animtype                   Reaction1
-	air_animtype               Reaction1
+	animtype                   Reaction
+	air_animtype               Reaction
 	priority                   int32
 	bothhittype                AiuchiType
 	hitdamage                  int32
@@ -371,8 +371,8 @@ type HitDef struct {
 	sparkxy                    [2]float32
 	hitsound                   [2]int32
 	guardsound                 [2]int32
-	ground_type                Reaction2
-	air_type                   Reaction2
+	ground_type                HitType
+	air_type                   HitType
 	ground_slidetime           int32
 	guard_slidetime            int32
 	ground_hittime             int32
@@ -432,19 +432,19 @@ type HitDef struct {
 	snap                       [2]float32
 	snapt                      int32
 	fall                       Fall
+	playerNo                   int
 	kill                       bool
 	guard_kill                 bool
 	forcenofall                bool
 	lhit                       bool
-	playerNo                   int
 }
 
 func (hd *HitDef) clear() {
-	*hd = HitDef{hitflag: uint32(ST_S | ST_C | ST_A | ST_F), affectteam: 1,
-		animtype: AT_Light, air_animtype: AT_Unknown, priority: 4,
+	*hd = HitDef{hitflag: int32(ST_S | ST_C | ST_A | ST_F), affectteam: 1,
+		animtype: RA_Light, air_animtype: RA_Unknown, priority: 4,
 		bothhittype: AT_Hit, sparkno: IErr, guard_sparkno: IErr,
 		hitsound: [2]int32{IErr, -1}, guardsound: [2]int32{IErr, -1},
-		ground_type: R2_High, air_type: R2_Unknown, air_hittime: 20,
+		ground_type: HT_High, air_type: HT_Unknown, air_hittime: 20,
 		yaccel: float32(math.NaN()), guard_velocity: float32(math.NaN()),
 		airguard_velocity: [2]float32{float32(math.NaN()),
 			float32(math.NaN())},
@@ -466,11 +466,249 @@ func (hd *HitDef) clear() {
 	hd.fall.setDefault()
 }
 func (hd *HitDef) invalidate(stateType StateType) {
-	hd.attr = hd.attr&^(uint32(AT_NA)-1) | uint32(stateType) | 0x80000000
-	hd.reversal_attr |= 0x80000000
+	hd.attr = hd.attr&^(int32(AT_NA)-1) | int32(stateType) | -1<<31
+	hd.reversal_attr |= -1 << 31
 	hd.lhit = false
 }
 
+type GetHitVar struct {
+	hitBy          [][2]int32
+	hit1           [2]int32
+	hit2           [2]int32
+	attr           int32
+	_type          HitType
+	airanimtype    Reaction
+	groundanimtype Reaction
+	airtype        HitType
+	groundtype     HitType
+	damage         int32
+	hitcount       int32
+	fallcount      int32
+	hitshaketime   int32
+	hittime        int32
+	slidetime      int32
+	ctrltime       int32
+	xvel           float32
+	yvel           float32
+	yaccel         float32
+	hitid          int32
+	xoff           float32
+	yoff           float32
+	fall           Fall
+	playerNo       int
+	fallf          bool
+	guarded        bool
+	p2getp1state   bool
+	forcestand     bool
+}
+
+func (ghv *GetHitVar) clear() {
+	*ghv = GetHitVar{_type: -1, hittime: -1, yaccel: float32(math.NaN()),
+		xoff: ghv.xoff, yoff: ghv.yoff, hitid: -1, playerNo: -1}
+	ghv.fall.clear()
+}
+func (ghv *GetHitVar) clearOff() {
+	ghv.xoff, ghv.yoff = 0, 0
+}
+func (ghv GetHitVar) getYaccel() float32 {
+	if math.IsNaN(float64(ghv.yaccel)) {
+		return 0.35
+	}
+	return ghv.yaccel
+}
+func (ghv GetHitVar) idMatch(id int32) bool {
+	for _, v := range ghv.hitBy {
+		if v[0] == id {
+			return true
+		}
+	}
+	return false
+}
+func (ghv GetHitVar) getJuggle(id, defaultJuggle int32) int32 {
+	for _, v := range ghv.hitBy {
+		if v[0] == id {
+			return v[1]
+		}
+	}
+	return defaultJuggle
+}
+func (ghv *GetHitVar) dropId(id int32) {
+	for i, v := range ghv.hitBy {
+		if v[0] == id {
+			ghv.hitBy = append(ghv.hitBy[:i], ghv.hitBy[i+1:]...)
+			break
+		}
+	}
+}
+func (ghv *GetHitVar) addId(id, juggle int32) {
+	ghv.dropId(id)
+	ghv.hitBy = append(ghv.hitBy, [2]int32{id, juggle})
+}
+
+type HitOverride struct {
+	attr     int32
+	stateno  int32
+	time     int32
+	playerNo int
+	forceair bool
+}
+
+func (ho *HitOverride) clear() {
+	*ho = HitOverride{stateno: -1, playerNo: -1}
+}
+
+type aimgImage struct {
+	anim           Animation
+	pos, scl, ascl [2]float32
+	angle          float32
+	angleset, old  bool
+}
+
+type AfterImage struct {
+	time       int32
+	length     int32
+	postbright [3]int32
+	add        [3]int32
+	mul        [3]float32
+	timegap    int32
+	framegap   int32
+	alpha      [2]int32
+	palfx      []PalFX
+	imgs       [64]aimgImage
+	imgidx     int
+	restgap    int32
+	reccount   int32
+}
+
+func newAfterImage() *AfterImage {
+	ai := &AfterImage{palfx: make([]PalFX, sys.afterImageMax)}
+	for i := range ai.palfx {
+		ai.palfx[i].enable, ai.palfx[i].negType = true, true
+	}
+	ai.clear()
+	ai.timegap = 0
+	return ai
+}
+func (ai *AfterImage) clear() {
+	ai.time = 0
+	ai.length = 20
+	if len(ai.palfx) > 0 {
+		ai.palfx[0].eColor = 1
+		ai.palfx[0].eInvertall = false
+		ai.palfx[0].eAdd = [3]int32{30, 30, 30}
+		ai.palfx[0].eMul = [3]int32{120, 120, 220}
+	}
+	ai.postbright = [3]int32{0, 0, 0}
+	ai.add = [3]int32{10, 10, 25}
+	ai.mul = [3]float32{0.65, 0.65, 0.75}
+	ai.timegap = 1
+	ai.framegap = 6
+	ai.alpha = [2]int32{-1, 0}
+	ai.imgidx = 0
+	ai.restgap = 0
+	ai.reccount = 0
+}
+func (ai *AfterImage) setPalColor(color int32) {
+	if len(ai.palfx) > 0 {
+		ai.palfx[0].eColor = float32(Max(0, Min(256, color))) / 256
+	}
+}
+func (ai *AfterImage) setPalInvertall(invertall bool) {
+	if len(ai.palfx) > 0 {
+		ai.palfx[0].eInvertall = invertall
+	}
+}
+func (ai *AfterImage) setPalBrightR(addr int32) {
+	if len(ai.palfx) > 0 {
+		ai.palfx[0].eAdd[0] = addr
+	}
+}
+func (ai *AfterImage) setPalBrightG(addg int32) {
+	if len(ai.palfx) > 0 {
+		ai.palfx[0].eAdd[1] = addg
+	}
+}
+func (ai *AfterImage) setPalBrightB(addb int32) {
+	if len(ai.palfx) > 0 {
+		ai.palfx[0].eAdd[2] = addb
+	}
+}
+func (ai *AfterImage) setPalContrastR(mulr int32) {
+	if len(ai.palfx) > 0 {
+		ai.palfx[0].eMul[0] = mulr
+	}
+}
+func (ai *AfterImage) setPalContrastG(mulg int32) {
+	if len(ai.palfx) > 0 {
+		ai.palfx[0].eMul[1] = mulg
+	}
+}
+func (ai *AfterImage) setPalContrastB(mulb int32) {
+	if len(ai.palfx) > 0 {
+		ai.palfx[0].eMul[2] = mulb
+	}
+}
+func (ai *AfterImage) setupPalFX() {
+	pb := ai.postbright
+	for i := 1; i < len(ai.palfx); i++ {
+		ai.palfx[i].eColor = ai.palfx[i-1].eColor
+		ai.palfx[i].eInvertall = ai.palfx[i-1].eInvertall
+		ai.palfx[i].eAdd[0] = ai.palfx[i-1].eAdd[0] + pb[0]
+		ai.palfx[i].eAdd[1] = ai.palfx[i-1].eAdd[1] + pb[1]
+		ai.palfx[i].eAdd[2] = ai.palfx[i-1].eAdd[2] + pb[2]
+		pb = [3]int32{0, 0, 0}
+		ai.palfx[i].eMul[0] = int32(float32(ai.palfx[i-1].eMul[0]) * ai.mul[0])
+		ai.palfx[i].eMul[1] = int32(float32(ai.palfx[i-1].eMul[1]) * ai.mul[1])
+		ai.palfx[i].eMul[2] = int32(float32(ai.palfx[i-1].eMul[2]) * ai.mul[2])
+	}
+}
+
+type Projectile struct {
+	hitdef        HitDef
+	id            int32
+	anim          int32
+	hitanim       int32
+	remanim       int32
+	cancelanim    int32
+	scale         [2]float32
+	clsnscale     [2]float32
+	remove        bool
+	removetime    int32
+	velocity      [2]float32
+	remvelocity   [2]float32
+	accel         [2]float32
+	velmul        [2]float32
+	hits          int32
+	misstime      int32
+	priority      int32
+	prioritypoint int32
+	sprpriority   int32
+	edgebound     int32
+	stagebound    int32
+	heightbound   [2]int32
+	pos           [2]float32
+	facing        int32
+	shadow        [3]int32
+	supermovetime int32
+	pausemovetime int32
+	ani           *Animation
+	timemiss      int32
+	hitpause      int32
+	oldPos        [2]float32
+	newPos        [2]float32
+	aimg          AfterImage
+	palfx         *PalFX
+}
+
+func (p *Projectile) clear() {
+	*p = Projectile{id: IErr, hitanim: -1, remanim: IErr, cancelanim: IErr,
+		scale: [2]float32{1, 1}, clsnscale: [2]float32{1, 1}, remove: true,
+		removetime: -1, velmul: [2]float32{1, 1}, hits: 1, priority: 1,
+		prioritypoint: 1, sprpriority: 3, edgebound: 40, stagebound: 40,
+		heightbound: [2]int32{-240, 1}, facing: 1}
+	p.hitdef.clear()
+}
+
 type CharGlobalInfo struct {
 	def              string
 	displayname      string
@@ -851,6 +1089,10 @@ func (c *Char) helperInit(h *Char, st int32, pt PosType, x, y float32,
 	facing int32, ownpal bool) {
 	unimplemented()
 }
+func (c *Char) roundState() int32 {
+	unimplemented()
+	return 0
+}
 func (c *Char) animNo() int32 {
 	unimplemented()
 	return 0
@@ -859,3 +1101,7 @@ func (c *Char) animTime() int32 {
 	unimplemented()
 	return 0
 }
+func (c *Char) animElemTime(e int32) int32 {
+	unimplemented()
+	return 0
+}

--- a/src/common.go
+++ b/src/common.go
@@ -79,7 +79,7 @@ func IsFinite(f float32) bool {
 func Atoi(str string) int32 {
 	n := int32(0)
 	str = strings.TrimSpace(str)
-	if len(str) >= 0 {
+	if len(str) > 0 {
 		var a string
 		if str[0] == '-' || str[0] == '+' {
 			a = str[1:]

--- a/src/compiler.go
+++ b/src/compiler.go
@@ -196,6 +196,25 @@ func (c *Compiler) operator(in *string) error {
 	}
 	return nil
 }
+func (c *Compiler) integer2(in *string) (int32, error) {
+	istr := c.token
+	c.token = c.tokenizer(in)
+	minus := istr == "-"
+	if minus {
+		istr = c.token
+		c.token = c.tokenizer(in)
+	}
+	for _, c := range istr {
+		if c < '0' || c > '9' {
+			return 0, Error(istr + "が整数でありません")
+		}
+	}
+	i := Atoi(istr)
+	if minus {
+		i *= -1
+	}
+	return i, nil
+}
 func (c *Compiler) number(token string) BytecodeValue {
 	f, err := strconv.ParseFloat(token, 64)
 	if err != nil && f == 0 {
@@ -312,6 +331,165 @@ func (c *Compiler) kakkotojiru(in *string) error {
 	}
 	return nil
 }
+func (c *Compiler) kyuushiki(in *string) (not bool, err error) {
+	for {
+		if c.token == "!=" {
+			not = true
+			break
+		} else if len(c.token) > 0 {
+			if c.token[len(c.token)-1] == '=' {
+				break
+			}
+		} else {
+			return false, Error("'='か'!='がありません")
+		}
+		c.token = c.tokenizer(in)
+	}
+	c.token = c.tokenizer(in)
+	return
+}
+func (c *Compiler) intRange(in *string) (minop OpCode, maxop OpCode,
+	min, max int32, err error) {
+	switch c.token {
+	case "(":
+		minop = OC_gt
+	case "[":
+		minop = OC_ge
+	default:
+		err = Error("'['か'('がありません")
+		return
+	}
+	integer := func() (int32, error) {
+		c.token = c.tokenizer(in)
+		minus := false
+		for c.token == "-" || c.token == "+" {
+			minus = minus || c.token == "-"
+			c.token = c.tokenizer(in)
+		}
+		if len(c.token) == 0 || c.token[0] < '0' || c.token[0] > '9' {
+			return 0, Error("数字の読み込みエラーです")
+		}
+		i := Atoi(c.token)
+		if minus {
+			i *= -1
+		}
+		return i, nil
+	}
+	if min, err = integer(); err != nil {
+		return
+	}
+	i := strings.Index(*in, ",")
+	if i < 0 {
+		err = Error("','がありません")
+		return
+	}
+	*in = (*in)[i+1:]
+	if max, err = integer(); err != nil {
+		return
+	}
+	i = strings.IndexAny(*in, "])")
+	if i < 0 {
+		err = Error("']'か')'がありません")
+		return
+	}
+	if (*in)[i] == ')' {
+		maxop = OC_lt
+	} else {
+		maxop = OC_le
+	}
+	*in = (*in)[i+1:]
+	c.token = c.tokenizer(in)
+	return
+}
+func (c *Compiler) kyuushikiThroughNeo(_range bool, in *string) {
+	i := 0
+	for ; i < len(*in); i++ {
+		if (*in)[i] >= '0' && (*in)[i] <= '9' || (*in)[i] == '-' ||
+			_range && ((*in)[i] == '[' || (*in)[i] == '(') {
+			break
+		}
+	}
+	*in = (*in)[i:]
+	c.token = c.tokenizer(in)
+}
+func (c *Compiler) kyuushikiSuperDX(out *BytecodeExp, in *string,
+	hissu bool) error {
+	comma := c.token == ","
+	if comma {
+		c.token = c.tokenizer(in)
+	}
+	var opc OpCode
+	switch c.token {
+	case "<":
+		opc = OC_lt
+		c.kyuushikiThroughNeo(false, in)
+	case ">":
+		opc = OC_gt
+		c.kyuushikiThroughNeo(false, in)
+	case "<=":
+		opc = OC_le
+		c.kyuushikiThroughNeo(false, in)
+	case ">=":
+		opc = OC_ge
+		c.kyuushikiThroughNeo(false, in)
+	default:
+		opc = OC_eq
+		hikaku := false
+		switch c.token {
+		case "!=":
+			opc = OC_ne
+			hikaku = true
+		case "=":
+			hikaku = true
+		default:
+			if hissu && !comma {
+				return Error("比較演算子がありません")
+			}
+		}
+		if hikaku {
+			c.kyuushikiThroughNeo(true, in)
+		}
+		if c.token == "[" || c.token == "(" {
+			minop, maxop, min, max, err := c.intRange(in)
+			if err != nil {
+				return err
+			}
+			if opc == OC_ne {
+				if minop == OC_gt {
+					minop = OC_le
+				} else {
+					minop = OC_lt
+				}
+				if maxop == OC_lt {
+					minop = OC_ge
+				} else {
+					minop = OC_gt
+				}
+			}
+			out.append(OC_dup)
+			out.appendValue(BytecodeInt(min))
+			out.append(minop)
+			out.append(OC_swap)
+			out.appendValue(BytecodeInt(max))
+			out.append(maxop)
+			if opc == OC_ne {
+				out.append(OC_blor)
+			} else {
+				out.append(OC_bland)
+			}
+			c.usiroOp = comma || hikaku
+			return nil
+		}
+	}
+	n, err := c.integer2(in)
+	if err != nil {
+		return err
+	}
+	out.appendValue(BytecodeInt(n))
+	out.append(opc)
+	c.usiroOp = true
+	return nil
+}
 func (c *Compiler) expValue(out *BytecodeExp, in *string) (BytecodeValue,
 	error) {
 	c.usiroOp, c.norange = true, false
@@ -325,6 +503,8 @@ func (c *Compiler) expValue(out *BytecodeExp, in *string) (BytecodeValue,
 	}
 	var be1, be2, be3 BytecodeExp
 	var bv1, bv2, bv3 BytecodeValue
+	var n int32
+	var be BytecodeExp
 	var err error
 	switch c.token {
 	case "-":
@@ -405,10 +585,34 @@ func (c *Compiler) expValue(out *BytecodeExp, in *string) (BytecodeValue,
 		}
 	case "random":
 		out.append(OC_random)
+	case "roundstate":
+		out.append(OC_roundstate)
+	case "matchover":
+		out.append(OC_ex_, OC_ex_matchover)
 	case "anim":
 		out.append(OC_anim)
 	case "animtime":
 		out.append(OC_animtime)
+	case "animelem":
+		if _, err = c.kyuushiki(in); err != nil {
+			return BytecodeSF(), err
+		}
+		if c.token == "-" {
+			return BytecodeSF(), Error("マイナスが付くとエラーです")
+		}
+		if n, err = c.integer2(in); err != nil {
+			return BytecodeSF(), err
+		}
+		if n <= 0 {
+			return BytecodeSF(), Error("animelemのは0より大きくなければいけません")
+		}
+		out.appendValue(BytecodeInt(n))
+		out.append(OC_animelemtime)
+		if err = c.kyuushikiSuperDX(&be, in, false); err != nil {
+			return BytecodeSF(), err
+		}
+		out.append(OC_jsf8, OpCode(len(be)))
+		out.append(be...)
 	default:
 		println(c.token)
 		unimplemented()
@@ -1525,6 +1729,17 @@ func (c *Compiler) ctrlSet(is IniSection, sbc *StateBytecode,
 		return c.paramValue(is, sc, "value", ctrlSet_value, VT_Bool, 1, true)
 	})
 }
+func (c *Compiler) hitDefSub(is IniSection,
+	sc *StateControllerBase) error {
+	unimplemented()
+	return nil
+}
+func (c *Compiler) hitDef(is IniSection, sbc *StateBytecode,
+	sc *StateControllerBase) (StateController, error) {
+	return hitDef(*sc), c.stateSec(is, func() error {
+		return c.hitDefSub(is, sc)
+	})
+}
 func (c *Compiler) stateCompile(bc *Bytecode, filename, def string) error {
 	var lines []string
 	if err := LoadFile(&filename, def, func(filename string) error {
@@ -1568,6 +1783,7 @@ func (c *Compiler) stateCompile(bc *Bytecode, filename, def string) error {
 				strings.SplitN(lines[i], ";", 2)[0]))
 			if len(line) < 7 || line[0] != '[' || line[len(line)-1] != ']' ||
 				line[1:7] != "state " {
+				i--
 				break
 			}
 			i++
@@ -1610,6 +1826,8 @@ func (c *Compiler) stateCompile(bc *Bytecode, filename, def string) error {
 						scf = c.powerAdd
 					case "ctrlset":
 						scf = c.ctrlSet
+					case "hitdef":
+						scf = c.hitDef
 					default:
 						println(data)
 						unimplemented()

--- a/src/image.go
+++ b/src/image.go
@@ -28,8 +28,16 @@ func NewTexture() (t *Texture) {
 }
 
 type PalFX struct {
-	Time  int32
-	Remap []int
+	Time       int32
+	Remap      []int
+	Invertall  bool
+	negType    bool
+	enable     bool
+	eInvertall bool
+	enegType   bool
+	eAdd       [3]int32
+	eMul       [3]int32
+	eColor     float32
 }
 
 func NewPalFX() *PalFX { return &PalFX{} }

--- a/src/system.go
+++ b/src/system.go
@@ -33,7 +33,8 @@ var sys = System{
 	listenPort:       "7500",
 	loader:           *newLoader(),
 	numSimul:         [2]int{2, 2},
-	numTurns:         [2]int{2, 2}}
+	numTurns:         [2]int{2, 2},
+	afterImageMax:    8}
 
 type TeamMode int32
 
@@ -80,6 +81,7 @@ type System struct {
 	inputRemap                  [MaxSimul * 2]int
 	listenPort                  string
 	round                       int32
+	matchWins                   [2]int32
 	wins                        [2]int32
 	rexisted                    [2]int32
 	draws                       int32
@@ -95,6 +97,7 @@ type System struct {
 	stringPool                  [MaxSimul * 2]StringPool
 	bcStack                     BytecodeStack
 	specialFlag                 GlobalSpecialFlag
+	afterImageMax               int
 }
 
 func (s *System) init(w, h int32) *lua.LState {
@@ -190,6 +193,9 @@ func (s *System) synchronize() error {
 	}
 	return nil
 }
+func (s *System) matchOver() bool {
+	return s.wins[0] >= s.matchWins[0] || s.wins[1] >= s.matchWins[1]
+}
 
 type SelectChar struct {
 	def, name            string