提交: 9144d50cc5991de50c5fa680345d5ae5a1a98834 - ikemen_go (git)

Go で書き直した Ikemen

Commit MetaInfo

• 修订版: 9144d50cc5991de50c5fa680345d5ae5a1a98834 (tree)
• 时间: 2016-12-19 00:56:20
• 作者: SUEHIRO <supersuehiro@user...>
• Commiter: SUEHIRO

Log Message

ステートコントローラーのところを書いていく

更改概述

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

差异

--- a/src/bytecode.go
+++ b/src/bytecode.go
@@ -66,6 +66,7 @@ const (
 	OC_pop
 	OC_dup
 	OC_swap
+	OC_run
 	OC_jmp8
 	OC_jz8
 	OC_jnz8
@@ -177,7 +178,6 @@ const (
 	OC_numpartner
 	OC_ailevel
 	OC_palno
-	OC_matchover
 	OC_hitcount
 	OC_uniqhitcount
 	OC_hitpausetime
@@ -359,6 +359,7 @@ const (
 	OC_ex_loseko
 	OC_ex_losetime
 	OC_ex_drawgame
+	OC_ex_matchover
 	OC_ex_matchno
 	OC_ex_tickspersecond
 )
@@ -626,6 +627,7 @@ func (_ BytecodeExp) blor(v1 *BytecodeValue, v2 BytecodeValue) {
 }
 func (be BytecodeExp) run(c *Char, scpn int) BytecodeValue {
 	sys.bcStack.Clear()
+	orgc := c
 	for i := 1; i <= len(be); i++ {
 		switch be[i-1] {
 		case OC_jz8, OC_jnz8:
@@ -649,15 +651,13 @@ func (be BytecodeExp) run(c *Char, scpn int) BytecodeValue {
 		case OC_jmp:
 			i += int(*(*int32)(unsafe.Pointer(&be[i]))) + 4
 		case OC_int8:
-			sys.bcStack.Push(BytecodeValue{VT_Int, float64(int8(be[i]))})
+			sys.bcStack.Push(BytecodeInt(int32(int8(be[i]))))
 			i++
 		case OC_int:
-			sys.bcStack.Push(BytecodeValue{VT_Int,
-				float64(*(*int32)(unsafe.Pointer(&be[i])))})
+			sys.bcStack.Push(BytecodeInt(*(*int32)(unsafe.Pointer(&be[i]))))
 			i += 4
 		case OC_float:
-			sys.bcStack.Push(BytecodeValue{VT_Float,
-				float64(*(*float32)(unsafe.Pointer(&be[i])))})
+			sys.bcStack.Push(BytecodeFloat(*(*float32)(unsafe.Pointer(&be[i]))))
 			i += 4
 		case OC_blnot:
 			be.blnot(sys.bcStack.Top())
@@ -715,17 +715,34 @@ func (be BytecodeExp) run(c *Char, scpn int) BytecodeValue {
 		case OC_blor:
 			v2 := sys.bcStack.Pop()
 			be.blor(sys.bcStack.Top(), v2)
+		case OC_ifelse:
+			v3 := sys.bcStack.Pop()
+			v2 := sys.bcStack.Pop()
+			if sys.bcStack.Top().ToB() {
+				*sys.bcStack.Top() = v2
+			} else {
+				*sys.bcStack.Top() = v3
+			}
 		case OC_pop:
 			sys.bcStack.Pop()
 		case OC_dup:
 			sys.bcStack.Dup()
 		case OC_swap:
 			sys.bcStack.Swap()
+		case OC_run:
+			l := int(*(*int32)(unsafe.Pointer(&be[i])))
+			sys.bcStack.Push(be[i+4:i+4+l].run(c, scpn))
+			i += 4 + l
 		case OC_time:
 			sys.bcStack.Push(BytecodeInt(c.time()))
+		case OC_alive:
+			sys.bcStack.Push(BytecodeBool(c.alive()))
+		case OC_random:
+			sys.bcStack.Push(BytecodeInt(Rand(0, 999)))
 		default:
 			unimplemented()
 		}
+		c = orgc
 	}
 	return sys.bcStack.Pop()
 }
@@ -783,7 +800,7 @@ func (scb *StateControllerBase) add(id byte, exp []BytecodeExp) {
 	}
 }
 func (scb StateControllerBase) run(c *Char, ps *int32,
-	f func(byte, []BytecodeExp)) bool {
+	f func(byte, []BytecodeExp) bool) bool {
 	(*ps)--
 	if *ps > 0 {
 		return false
@@ -804,8 +821,8 @@ func (scb StateControllerBase) run(c *Char, ps *int32,
 			if !exp[0].evalB(c, scb.playerNo) {
 				return false
 			}
-		} else {
-			f(id, exp)
+		} else if !f(id, exp) {
+			break
 		}
 	}
 	*ps = scb.persistent
@@ -828,7 +845,7 @@ const (
 )
 
 func (sc stateDef) Run(c *Char, ps *int32) bool {
-	StateControllerBase(sc).run(c, ps, func(id byte, exp []BytecodeExp) {
+	StateControllerBase(sc).run(c, ps, func(id byte, exp []BytecodeExp) bool {
 		switch id {
 		case stateDef_hitcountpersist:
 			if !exp[0].evalB(c, sc.playerNo) {
@@ -865,6 +882,7 @@ func (sc stateDef) Run(c *Char, ps *int32) bool {
 		case stateDef_poweradd:
 			c.addPower(exp[0].evalI(c, sc.playerNo))
 		}
+		return true
 	})
 	return false
 }
@@ -879,7 +897,7 @@ const (
 
 func (sc hitBy) Run(c *Char, ps *int32) bool {
 	time := int32(1)
-	StateControllerBase(sc).run(c, ps, func(id byte, exp []BytecodeExp) {
+	StateControllerBase(sc).run(c, ps, func(id byte, exp []BytecodeExp) bool {
 		switch id {
 		case hitBy_time:
 			time = exp[0].evalI(c, sc.playerNo)
@@ -888,6 +906,7 @@ func (sc hitBy) Run(c *Char, ps *int32) bool {
 		case hitBy_value2:
 			unimplemented()
 		}
+		return true
 	})
 	return false
 }
@@ -896,7 +915,7 @@ type notHitBy hitBy
 
 func (sc notHitBy) Run(c *Char, ps *int32) bool {
 	time := int32(1)
-	StateControllerBase(sc).run(c, ps, func(id byte, exp []BytecodeExp) {
+	StateControllerBase(sc).run(c, ps, func(id byte, exp []BytecodeExp) bool {
 		switch id {
 		case hitBy_time:
 			time = exp[0].evalI(c, sc.playerNo)
@@ -905,15 +924,273 @@ func (sc notHitBy) Run(c *Char, ps *int32) bool {
 		case hitBy_value2:
 			unimplemented()
 		}
+		return true
 	})
 	return false
 }
 
 type assertSpecial StateControllerBase
 
+const (
+	assertSpecial_flag byte = iota
+	assertSpecial_flag_g
+)
+
 func (sc assertSpecial) Run(c *Char, ps *int32) bool {
-	StateControllerBase(sc).run(c, ps, func(id byte, exp []BytecodeExp) {
+	StateControllerBase(sc).run(c, ps, func(id byte, exp []BytecodeExp) bool {
+		switch id {
+		case assertSpecial_flag:
+			unimplemented()
+		case assertSpecial_flag_g:
+			sys.specialFlag |= GlobalSpecialFlag(exp[0].evalI(c, sc.playerNo))
+		}
+		return true
+	})
+	return false
+}
+
+type playSnd StateControllerBase
+
+const (
+	playSnd_value = iota
+	playSnd_channel
+	playSnd_lowpriority
+	playSnd_pan
+	playSnd_abspan
+	playSnd_volume
+	playSnd_freqmul
+	playSnd_loop
+)
+
+func (sc playSnd) Run(c *Char, ps *int32) bool {
+	f, lw, lp := false, false, false
+	var g, n, ch, vo int32 = -1, 0, -1, 0
+	if sys.cgi[sc.playerNo].ver[0] == 1 {
+		vo = 100
+	}
+	var p, fr float32 = 0, 1
+	x := &c.pos[0]
+	StateControllerBase(sc).run(c, ps, func(id byte, exp []BytecodeExp) bool {
+		switch id {
+		case playSnd_value:
+			f = exp[0].evalB(c, sc.playerNo)
+			g = exp[1].evalI(c, sc.playerNo)
+			if len(exp) > 2 {
+				n = exp[2].evalI(c, sc.playerNo)
+			}
+		case playSnd_channel:
+			ch = exp[0].evalI(c, sc.playerNo)
+		case playSnd_lowpriority:
+			lw = exp[0].evalB(c, sc.playerNo)
+		case playSnd_pan:
+			p = exp[0].evalF(c, sc.playerNo)
+		case playSnd_abspan:
+			x = nil
+			p = exp[0].evalF(c, sc.playerNo)
+		case playSnd_volume:
+			vo = exp[0].evalI(c, sc.playerNo)
+		case playSnd_freqmul:
+			fr = exp[0].evalF(c, sc.playerNo)
+		case playSnd_loop:
+			lp = exp[0].evalB(c, sc.playerNo)
+		}
+		return true
+	})
+	c.playSound(f, lw, lp, g, n, ch, vo, p, fr, x)
+	return false
+}
+
+type changeState StateControllerBase
+
+const (
+	changeState_value byte = iota
+	changeState_ctrl
+	changeState_anim
+)
+
+func (sc changeState) Run(c *Char, ps *int32) bool {
+	var v, a, ctrl int32 = -1, -1, -1
+	StateControllerBase(sc).run(c, ps, func(id byte, exp []BytecodeExp) bool {
+		switch id {
+		case changeState_value:
+			v = exp[0].evalI(c, sc.playerNo)
+		case changeState_ctrl:
+			ctrl = exp[0].evalI(c, sc.playerNo)
+		case changeState_anim:
+			a = exp[0].evalI(c, sc.playerNo)
+		}
+		return true
+	})
+	c.changeState(v, a, ctrl)
+	return true
+}
+
+type selfState changeState
+
+func (sc selfState) Run(c *Char, ps *int32) bool {
+	var v, a, ctrl int32 = -1, -1, -1
+	StateControllerBase(sc).run(c, ps, func(id byte, exp []BytecodeExp) bool {
+		switch id {
+		case changeState_value:
+			v = exp[0].evalI(c, sc.playerNo)
+		case changeState_ctrl:
+			ctrl = exp[0].evalI(c, sc.playerNo)
+		case changeState_anim:
+			a = exp[0].evalI(c, sc.playerNo)
+		}
+		return true
+	})
+	c.selfState(v, a, ctrl)
+	return true
+}
+
+type tagIn StateControllerBase
+
+const (
+	tagIn_stateno = iota
+	tagIn_partnerstateno
+)
+
+func (sc tagIn) Run(c *Char, ps *int32) bool {
+	var p *Char
+	sn := int32(-1)
+	ret := false
+	StateControllerBase(sc).run(c, ps, func(id byte, exp []BytecodeExp) bool {
+		if p == nil {
+			p = c.partner(0)
+			if p == nil {
+				return false
+			}
+		}
+		switch id {
+		case tagIn_stateno:
+			sn = exp[0].evalI(c, sc.playerNo)
+		case tagIn_partnerstateno:
+			if psn := exp[0].evalI(c, sc.playerNo); psn >= 0 {
+				if sn >= 0 {
+					c.changeState(sn, -1, -1)
+				}
+				p.standby = false
+				p.changeState(psn, -1, -1)
+				ret = true
+			} else {
+				return false
+			}
+		}
+		return true
+	})
+	return ret
+}
+
+type tagOut StateControllerBase
+
+const (
+	tagOut_ = iota
+)
+
+func (sc tagOut) Run(c *Char, ps *int32) bool {
+	StateControllerBase(sc).run(c, ps, func(id byte, exp []BytecodeExp) bool {
+		switch id {
+		case tagOut_:
+			c.standby = true
+		}
+		return true
+	})
+	return true
+}
+
+type destroySelf StateControllerBase
+
+const (
+	destroySelf_recursive = iota
+	destroySelf_removeexplods
+)
+
+func (sc destroySelf) Run(c *Char, ps *int32) bool {
+	rec, rem := false, false
+	StateControllerBase(sc).run(c, ps, func(id byte, exp []BytecodeExp) bool {
+		switch id {
+		case destroySelf_recursive:
+			rec = exp[0].evalB(c, sc.playerNo)
+		case destroySelf_removeexplods:
+			rem = exp[0].evalB(c, sc.playerNo)
+		}
+		return true
+	})
+	return c.destroySelf(rec, rem)
+}
+
+type changeAnim StateControllerBase
+
+const (
+	changeAnim_elem byte = iota
+	changeAnim_value
+)
+
+func (sc changeAnim) Run(c *Char, ps *int32) bool {
+	var elem int32
+	setelem := false
+	StateControllerBase(sc).run(c, ps, func(id byte, exp []BytecodeExp) bool {
+		switch id {
+		case changeAnim_elem:
+			elem = exp[0].evalI(c, sc.playerNo)
+			setelem = true
+		case changeAnim_value:
+			c.changeAnim(exp[0].evalI(c, sc.playerNo))
+			if setelem {
+				c.setAnimElem(elem)
+			}
+		}
+		return true
+	})
+	return false
+}
+
+type changeAnim2 changeAnim
+
+func (sc changeAnim2) Run(c *Char, ps *int32) bool {
+	var elem int32
+	setelem := false
+	StateControllerBase(sc).run(c, ps, func(id byte, exp []BytecodeExp) bool {
+		switch id {
+		case changeAnim_elem:
+			elem = exp[0].evalI(c, sc.playerNo)
+			setelem = true
+		case changeAnim_value:
+			c.changeAnim2(exp[0].evalI(c, sc.playerNo))
+			if setelem {
+				c.setAnimElem(elem)
+			}
+		}
+		return true
+	})
+	return false
+}
+
+type helper StateControllerBase
+
+const (
+	helper_helpertype byte = iota
+	helper_name
+)
+
+func (sc helper) Run(c *Char, ps *int32) bool {
+	var h *Char
+	StateControllerBase(sc).run(c, ps, func(id byte, exp []BytecodeExp) bool {
+		if h == nil {
+			h = c.newHelper()
+			if h == nil {
+				return false
+			}
+		}
+		switch id {
+		case helper_helpertype:
+			h.player = exp[0].evalB(c, sc.playerNo)
+		case helper_name:
+			h.name = string(*(*[]byte)(unsafe.Pointer(&exp[0])))
+		}
 		unimplemented()
+		return true
 	})
 	return false
 }

--- a/src/char.go
+++ b/src/char.go
@@ -5,6 +5,36 @@ import (
 	"strings"
 )
 
+type CharSpecialFlag uint32
+
+const (
+	CSF_nostandguard CharSpecialFlag = 1 << iota
+	CSF_nocrouchguard
+	CSF_noairguard
+	CSF_noshadow
+	CSF_invisible
+	CSF_unguardable
+	CSF_nojugglecheck
+	CSF_noautoturn
+	CSF_nowalk
+)
+
+type GlobalSpecialFlag uint32
+
+const (
+	GSF_intro GlobalSpecialFlag = 1 << iota
+	GSF_roundnotover
+	GSF_nomusic
+	GSF_nobardisplay
+	GSF_nobg
+	GSF_nofg
+	GSF_globalnoshadow
+	GSF_timerfreeze
+	GSF_nokosnd
+	GSF_nokoslow
+	GSF_noko
+)
+
 type CharData struct {
 	life    int32
 	power   int32
@@ -279,6 +309,9 @@ type Char struct {
 	sprpriority int32
 	juggle      int32
 	size        CharSize
+	pos         [2]float32
+	vel         [2]float32
+	standby     bool
 }
 
 func newChar(n, idx int) (c *Char) {
@@ -554,14 +587,20 @@ func (c *Char) setJuggle(juggle int32) {
 	c.juggle = juggle
 }
 func (c *Char) setXV(xv float32) {
-	unimplemented()
+	c.vel[0] = xv
 }
 func (c *Char) setYV(yv float32) {
-	unimplemented()
+	c.vel[1] = yv
 }
 func (c *Char) changeAnim(animNo int32) {
 	unimplemented()
 }
+func (c *Char) changeAnim2(animNo int32) {
+	unimplemented()
+}
+func (c *Char) setAnimElem(e int32) {
+	unimplemented()
+}
 func (c *Char) setCtrl(ctrl bool) {
 	unimplemented()
 }
@@ -572,3 +611,47 @@ func (c *Char) time() int32 {
 	unimplemented()
 	return 0
 }
+func (c *Char) alive() bool {
+	unimplemented()
+	return false
+}
+func (c *Char) playSound(f, lw, lp bool, g, n, ch, vo int32,
+	p, fr float32, x *float32) {
+	unimplemented()
+}
+func (c *Char) changeState(no, anim, ctrl int32) {
+	unimplemented()
+}
+func (c *Char) selfState(no, anim, ctrl int32) {
+	unimplemented()
+}
+func (c *Char) partner(n int32) *Char {
+	n = Max(0, n)
+	if int(n) > len(sys.chars)/2-2 {
+		return nil
+	}
+	var p int
+	if int(n) == c.playerNo>>1 {
+		p = c.playerNo + 2
+	} else {
+		p = c.playerNo&1 + int(n)<<1
+		if int(n) > c.playerNo>>1 {
+			p += 2
+		}
+	}
+	if len(sys.chars[p]) > 0 {
+		return sys.chars[p][0]
+	}
+	return nil
+}
+func (c *Char) destroySelf(recursive, removeexplods bool) bool {
+	if c.helperIndex <= 0 {
+		return false
+	}
+	unimplemented()
+	return true
+}
+func (c *Char) newHelper() *Char {
+	unimplemented()
+	return nil
+}

--- a/src/common.go
+++ b/src/common.go
@@ -150,6 +150,9 @@ func Atof(str string) float64 {
 	return f
 }
 func readDigit(d string) (int32, bool) {
+	if len(d) == 0 || (len(d) >= 2 && d[0] == '0') {
+		return 0, false
+	}
 	for _, c := range d {
 		if c < '0' || c > '9' {
 			return 0, false

--- a/src/compiler.go
+++ b/src/compiler.go
@@ -310,7 +310,6 @@ func (c *Compiler) kakkotojiru(in *string) error {
 	if c.token != ")" {
 		return Error(c.token + "の前に')'がありません")
 	}
-	c.token = c.tokenizer(in)
 	return nil
 }
 func (c *Compiler) expValue(out *BytecodeExp, in *string) (BytecodeValue,
@@ -324,9 +323,56 @@ func (c *Compiler) expValue(out *BytecodeExp, in *string) (BytecodeValue,
 	if !sys.ignoreMostErrors {
 		defer func() { c.usiroOp = false }()
 	}
+	var be1, be2, be3 BytecodeExp
+	var bv1, bv2, bv3 BytecodeValue
+	var err error
 	switch c.token {
 	case "time":
 		out.append(OC_time)
+	case "alive":
+		out.append(OC_alive)
+	case "ifelse":
+		if c.tokenizer(in) != "(" {
+			return BytecodeSF(), Error(c.token + "の次に'('がありません")
+		}
+		c.token = c.tokenizer(in)
+		if bv1, err = c.expBoolOr(&be1, in); err != nil {
+			return BytecodeSF(), err
+		}
+		if c.token != "," {
+			return BytecodeSF(), Error("','がありません")
+		}
+		c.token = c.tokenizer(in)
+		if bv2, err = c.expBoolOr(&be2, in); err != nil {
+			return BytecodeSF(), err
+		}
+		if c.token != "," {
+			return BytecodeSF(), Error("','がありません")
+		}
+		c.token = c.tokenizer(in)
+		if bv3, err = c.expBoolOr(&be3, in); err != nil {
+			return BytecodeSF(), err
+		}
+		if err := c.kakkotojiru(in); err != nil {
+			return BytecodeSF(), err
+		}
+		if bv1.IsSF() || bv2.IsSF() || bv3.IsSF() {
+			out.append(be1...)
+			out.appendValue(bv1)
+			out.append(be2...)
+			out.appendValue(bv2)
+			out.append(be3...)
+			out.appendValue(bv3)
+			out.append(OC_ifelse)
+		} else {
+			if bv1.ToB() {
+				bv = bv2
+			} else {
+				bv = bv3
+			}
+		}
+	case "random":
+		out.append(OC_random)
 	default:
 		println(c.token)
 		unimplemented()
@@ -409,14 +455,14 @@ func (c *Compiler) expPow(out *BytecodeExp, in *string) (BytecodeValue,
 			if err != nil {
 				return BytecodeSF(), err
 			}
-			if !bv.IsSF() && !bv2.IsSF() {
-				out.pow(&bv, bv2, c.playerNo)
-			} else {
+			if bv.IsSF() || bv2.IsSF() {
 				out.appendValue(bv)
 				out.append(be...)
 				out.appendValue(bv2)
 				out.append(OC_pow)
 				bv = BytecodeSF()
+			} else {
+				out.pow(&bv, bv2, c.playerNo)
 			}
 		} else {
 			break
@@ -523,19 +569,20 @@ func (c *Compiler) expRange(out *BytecodeExp, in *string,
 		if err := c.kakkotojiru(in); err != nil {
 			return err
 		}
-		if !bv.IsSF() && !bv2.IsSF() {
+		c.token = c.tokenizer(in)
+		if bv.IsSF() || bv2.IsSF() {
+			out.appendValue(*bv)
+			out.append(be2...)
+			out.appendValue(bv2)
+			out.append(opc)
+			*bv = BytecodeSF()
+		} else {
 			switch opc {
 			case OC_eq:
 				out.eq(bv, bv2)
 			case OC_ne:
 				out.ne(bv, bv2)
 			}
-		} else {
-			out.appendValue(*bv)
-			out.append(be2...)
-			out.appendValue(bv2)
-			out.append(opc)
-			*bv = BytecodeSF()
 		}
 		return nil
 	}
@@ -546,23 +593,7 @@ func (c *Compiler) expRange(out *BytecodeExp, in *string,
 		return Error("]か)がありません")
 	}
 	c.token = c.tokenizer(in)
-	if !bv.IsSF() && !bv2.IsSF() && !bv3.IsSF() {
-		tmp := *bv
-		if open == "(" {
-			out.gt(&tmp, bv2)
-		} else {
-			out.ge(&tmp, bv2)
-		}
-		if close == ")" {
-			out.lt(bv, bv3)
-		} else {
-			out.le(bv, bv3)
-		}
-		bv.SetB(tmp.ToB() && bv.ToB())
-		if opc == OC_ne {
-			bv.SetB(!bv.ToB())
-		}
-	} else {
+	if bv.IsSF() || bv2.IsSF() || bv3.IsSF() {
 		var op1, op2, op3 OpCode
 		if opc == OC_ne {
 			if open == "(" {
@@ -600,6 +631,22 @@ func (c *Compiler) expRange(out *BytecodeExp, in *string,
 		out.append(op2)
 		out.append(op3)
 		*bv = BytecodeSF()
+	} else {
+		tmp := *bv
+		if open == "(" {
+			out.gt(&tmp, bv2)
+		} else {
+			out.ge(&tmp, bv2)
+		}
+		if close == ")" {
+			out.lt(bv, bv3)
+		} else {
+			out.le(bv, bv3)
+		}
+		bv.SetB(tmp.ToB() && bv.ToB())
+		if opc == OC_ne {
+			bv.SetB(!bv.ToB())
+		}
 	}
 	return nil
 }
@@ -653,14 +700,14 @@ func (_ *Compiler) expOneOpSub(out *BytecodeExp, in *string, bv *BytecodeValue,
 	if err != nil {
 		return err
 	}
-	if !bv.IsSF() && !bv2.IsSF() {
-		opf(bv, bv2)
-	} else {
+	if bv.IsSF() || bv2.IsSF() {
 		out.appendValue(*bv)
 		out.append(be...)
 		out.appendValue(bv2)
 		out.append(opc)
 		*bv = BytecodeSF()
+	} else {
+		opf(bv, bv2)
 	}
 	return nil
 }
@@ -853,7 +900,7 @@ func (c *Compiler) stateParam(is IniSection, name string,
 	return nil
 }
 func (c *Compiler) scAdd(sc *StateControllerBase, id byte,
-	data string, vt ValueType, numArg int) error {
+	data string, vt ValueType, numArg int, topbe ...BytecodeExp) error {
 	bes := []BytecodeExp{}
 	for n := 1; n <= numArg; n++ {
 		var be BytecodeExp
@@ -871,7 +918,7 @@ func (c *Compiler) scAdd(sc *StateControllerBase, id byte,
 			break
 		}
 	}
-	sc.add(id, bes)
+	sc.add(id, append(topbe, bes...))
 	return nil
 }
 func (c *Compiler) stateDef(is IniSection, sbc *StateBytecode) error {
@@ -1063,6 +1110,287 @@ func (c *Compiler) notHitBy(is IniSection, sbc *StateBytecode,
 func (c *Compiler) assertSpecial(is IniSection, sbc *StateBytecode,
 	sc *StateControllerBase) (StateController, error) {
 	return assertSpecial(*sc), c.stateSec(is, func() error {
+		foo := func(data string) error {
+			switch data {
+			case "nostandguard":
+				sc.add(assertSpecial_flag, sc.iToExp(int32(CSF_nostandguard)))
+			case "nocrouchguard":
+				sc.add(assertSpecial_flag, sc.iToExp(int32(CSF_nocrouchguard)))
+			case "noairguard":
+				sc.add(assertSpecial_flag, sc.iToExp(int32(CSF_noairguard)))
+			case "noshadow":
+				sc.add(assertSpecial_flag, sc.iToExp(int32(CSF_noshadow)))
+			case "invisible":
+				sc.add(assertSpecial_flag, sc.iToExp(int32(CSF_invisible)))
+			case "unguardable":
+				sc.add(assertSpecial_flag, sc.iToExp(int32(CSF_unguardable)))
+			case "nojugglecheck":
+				sc.add(assertSpecial_flag, sc.iToExp(int32(CSF_nojugglecheck)))
+			case "noautoturn":
+				sc.add(assertSpecial_flag, sc.iToExp(int32(CSF_noautoturn)))
+			case "nowalk":
+				sc.add(assertSpecial_flag, sc.iToExp(int32(CSF_nowalk)))
+			case "intro":
+				sc.add(assertSpecial_flag_g, sc.iToExp(int32(GSF_intro)))
+			case "roundnotover":
+				sc.add(assertSpecial_flag_g, sc.iToExp(int32(GSF_roundnotover)))
+			case "nomusic":
+				sc.add(assertSpecial_flag_g, sc.iToExp(int32(GSF_nomusic)))
+			case "nobardisplay":
+				sc.add(assertSpecial_flag_g, sc.iToExp(int32(GSF_nobardisplay)))
+			case "nobg":
+				sc.add(assertSpecial_flag_g, sc.iToExp(int32(GSF_nobg)))
+			case "nofg":
+				sc.add(assertSpecial_flag_g, sc.iToExp(int32(GSF_nofg)))
+			case "globalnoshadow":
+				sc.add(assertSpecial_flag_g, sc.iToExp(int32(GSF_globalnoshadow)))
+			case "timerfreeze":
+				sc.add(assertSpecial_flag_g, sc.iToExp(int32(GSF_timerfreeze)))
+			case "nokosnd":
+				sc.add(assertSpecial_flag_g, sc.iToExp(int32(GSF_nokosnd)))
+			case "nokoslow":
+				sc.add(assertSpecial_flag_g, sc.iToExp(int32(GSF_nokoslow)))
+			case "noko":
+				sc.add(assertSpecial_flag_g, sc.iToExp(int32(GSF_noko)))
+			default:
+				return Error(data + "が無効な値です")
+			}
+			return nil
+		}
+		f := false
+		if err := c.stateParam(is, "flag", func(data string) error {
+			f = true
+			return foo(data)
+		}); err != nil {
+			return err
+		}
+		if !f {
+			return Error("flagが指定されていません")
+		}
+		if err := c.stateParam(is, "flag2", func(data string) error {
+			return foo(data)
+		}); err != nil {
+			return err
+		}
+		if err := c.stateParam(is, "flag3", func(data string) error {
+			return foo(data)
+		}); err != nil {
+			return err
+		}
+		return nil
+	})
+}
+func (c *Compiler) playSnd(is IniSection, sbc *StateBytecode,
+	sc *StateControllerBase) (StateController, error) {
+	return playSnd(*sc), c.stateSec(is, func() error {
+		f := false
+		if err := c.stateParam(is, "value", func(data string) error {
+			f = true
+			fflg := false
+			if len(data) > 0 {
+				switch data[0] {
+				case 'F', 'f':
+					fflg = true
+					data = data[1:]
+				case 'S', 's':
+					data = data[1:]
+				}
+			}
+			return c.scAdd(sc, playSnd_value, data, VT_Int, 2,
+				sc.iToExp(Btoi(fflg))...)
+		}); err != nil {
+			return err
+		}
+		if !f {
+			return Error("valueが指定されていません")
+		}
+		if err := c.stateParam(is, "channel", func(data string) error {
+			return c.scAdd(sc, playSnd_channel, data, VT_Int, 1)
+		}); err != nil {
+			return err
+		}
+		if err := c.stateParam(is, "lowpriority", func(data string) error {
+			return c.scAdd(sc, playSnd_lowpriority, data, VT_Bool, 1)
+		}); err != nil {
+			return err
+		}
+		if err := c.stateParam(is, "pan", func(data string) error {
+			return c.scAdd(sc, playSnd_pan, data, VT_Float, 1)
+		}); err != nil {
+			return err
+		}
+		if err := c.stateParam(is, "abspan", func(data string) error {
+			return c.scAdd(sc, playSnd_abspan, data, VT_Float, 1)
+		}); err != nil {
+			return err
+		}
+		var volname string
+		if sys.cgi[c.playerNo].ver[0] == 1 {
+			volname = "volumescale"
+		} else {
+			volname = "volume"
+		}
+		if err := c.stateParam(is, volname, func(data string) error {
+			return c.scAdd(sc, playSnd_volume, data, VT_Int, 1)
+		}); err != nil {
+			return err
+		}
+		if err := c.stateParam(is, "freqmul", func(data string) error {
+			return c.scAdd(sc, playSnd_freqmul, data, VT_Float, 1)
+		}); err != nil {
+			return err
+		}
+		if err := c.stateParam(is, "loop", func(data string) error {
+			return c.scAdd(sc, playSnd_loop, data, VT_Bool, 1)
+		}); err != nil {
+			return err
+		}
+		return nil
+	})
+}
+func (c *Compiler) changeStateSub(is IniSection,
+	sc *StateControllerBase) error {
+	f := false
+	if err := c.stateParam(is, "value", func(data string) error {
+		f = true
+		return c.scAdd(sc, changeState_value, data, VT_Int, 1)
+	}); err != nil {
+		return err
+	}
+	if !f {
+		return Error("valueが指定されていません")
+	}
+	if err := c.stateParam(is, "ctrl", func(data string) error {
+		return c.scAdd(sc, changeState_ctrl, data, VT_Int, 1)
+	}); err != nil {
+		return err
+	}
+	if err := c.stateParam(is, "anim", func(data string) error {
+		return c.scAdd(sc, changeState_anim, data, VT_Int, 1)
+	}); err != nil {
+		return err
+	}
+	return nil
+}
+func (c *Compiler) changeState(is IniSection, sbc *StateBytecode,
+	sc *StateControllerBase) (StateController, error) {
+	return changeState(*sc), c.stateSec(is, func() error {
+		return c.changeStateSub(is, sc)
+	})
+}
+func (c *Compiler) selfState(is IniSection, sbc *StateBytecode,
+	sc *StateControllerBase) (StateController, error) {
+	return selfState(*sc), c.stateSec(is, func() error {
+		return c.changeStateSub(is, sc)
+	})
+}
+func (c *Compiler) tagIn(is IniSection, sbc *StateBytecode,
+	sc *StateControllerBase) (StateController, error) {
+	return tagIn(*sc), c.stateSec(is, func() error {
+		f := false
+		if err := c.stateParam(is, "stateno", func(data string) error {
+			f = true
+			return c.scAdd(sc, tagIn_stateno, data, VT_Int, 1)
+		}); err != nil {
+			return err
+		}
+		if !f {
+			return Error("statenoが指定されていません")
+		}
+		f = false
+		if err := c.stateParam(is, "partnerstateno", func(data string) error {
+			f = true
+			return c.scAdd(sc, tagIn_partnerstateno, data, VT_Int, 1)
+		}); err != nil {
+			return err
+		}
+		if !f {
+			sc.add(tagIn_partnerstateno, sc.iToExp(-1))
+		}
+		return nil
+	})
+}
+func (c *Compiler) tagOut(is IniSection, sbc *StateBytecode,
+	sc *StateControllerBase) (StateController, error) {
+	return tagOut(*sc), c.stateSec(is, func() error {
+		sc.add(tagOut_, nil)
+		return nil
+	})
+}
+func (c *Compiler) destroySelf(is IniSection, sbc *StateBytecode,
+	sc *StateControllerBase) (StateController, error) {
+	return destroySelf(*sc), c.stateSec(is, func() error {
+		if err := c.stateParam(is, "recursive", func(data string) error {
+			return c.scAdd(sc, destroySelf_recursive, data, VT_Bool, 1)
+		}); err != nil {
+			return err
+		}
+		if err := c.stateParam(is, "removeexplods", func(data string) error {
+			return c.scAdd(sc, destroySelf_removeexplods, data, VT_Bool, 1)
+		}); err != nil {
+			return err
+		}
+		return nil
+	})
+}
+func (c *Compiler) changeAnimSub(is IniSection,
+	sc *StateControllerBase) error {
+	if err := c.stateParam(is, "elem", func(data string) error {
+		return c.scAdd(sc, changeAnim_elem, data, VT_Int, 1)
+	}); err != nil {
+		return err
+	}
+	f := false
+	if err := c.stateParam(is, "value", func(data string) error {
+		f = true
+		return c.scAdd(sc, changeAnim_value, data, VT_Int, 1)
+	}); err != nil {
+		return err
+	}
+	if !f {
+		return Error("valueが指定されていません")
+	}
+	return nil
+}
+func (c *Compiler) changeAnim(is IniSection, sbc *StateBytecode,
+	sc *StateControllerBase) (StateController, error) {
+	return changeAnim(*sc), c.stateSec(is, func() error {
+		return c.changeAnimSub(is, sc)
+	})
+}
+func (c *Compiler) changeAnim2(is IniSection, sbc *StateBytecode,
+	sc *StateControllerBase) (StateController, error) {
+	return changeAnim2(*sc), c.stateSec(is, func() error {
+		return c.changeAnimSub(is, sc)
+	})
+}
+func (c *Compiler) helper(is IniSection, sbc *StateBytecode,
+	sc *StateControllerBase) (StateController, error) {
+	return helper(*sc), c.stateSec(is, func() error {
+		if err := c.stateParam(is, "helpertype", func(data string) error {
+			if len(data) == 0 {
+				return Error("値が指定されていません")
+			}
+			switch strings.ToLower(data)[0] {
+			case 'n':
+			case 'p':
+				sc.add(helper_helpertype, sc.iToExp(1))
+			default:
+				return Error(data + "が無効な値です")
+			}
+			return nil
+		}); err != nil {
+			return err
+		}
+		if err := c.stateParam(is, "name", func(data string) error {
+			if len(data) < 2 || data[0] != '"' || data[len(data)-1] != '"' {
+				return Error("\"で囲まれていません")
+			}
+			sc.add(helper_name, sc.beToExp(BytecodeExp(data[1:len(data)-1])))
+			return nil
+		}); err != nil {
+			return err
+		}
 		unimplemented()
 		return nil
 	})
@@ -1130,6 +1458,24 @@ func (c *Compiler) stateCompile(bc *Bytecode, filename, def string) error {
 						scf = c.notHitBy
 					case "assertspecial":
 						scf = c.assertSpecial
+					case "playsnd":
+						scf = c.playSnd
+					case "changestate":
+						scf = c.changeState
+					case "selfstate":
+						scf = c.selfState
+					case "tagin":
+						scf = c.tagIn
+					case "tagout":
+						scf = c.tagOut
+					case "destroyself":
+						scf = c.destroySelf
+					case "changeanim":
+						scf = c.changeAnim
+					case "changeanim2":
+						scf = c.changeAnim2
+					case "helper":
+						scf = c.helper
 					default:
 						println(data)
 						unimplemented()
@@ -1159,7 +1505,7 @@ func (c *Compiler) stateCompile(bc *Bytecode, filename, def string) error {
 					}
 				default:
 					tn, ok := readDigit(name[7:])
-					if !ok || tn <= 0 || tn > 65536 {
+					if !ok || tn < 1 || tn > 65536 {
 						errmes(Error("トリガー名 (" + name + ") が不正です"))
 					}
 					if len(trigger) < int(tn) {
@@ -1208,12 +1554,10 @@ func (c *Compiler) stateCompile(bc *Bytecode, filename, def string) error {
 			}
 			var texp BytecodeExp
 			for i, e := range triggerall {
-				if len(e) > 0 {
-					texp.append(e...)
-					if i < len(triggerall)-1 {
-						texp.append(OC_jz8, 0)
-						texp.append(OC_pop)
-					}
+				texp.append(e...)
+				if i < len(triggerall)-1 {
+					texp.append(OC_jz8, 0)
+					texp.append(OC_pop)
 				}
 			}
 			if allUtikiri {
@@ -1232,18 +1576,16 @@ func (c *Compiler) stateCompile(bc *Bytecode, filename, def string) error {
 					oldlen := len(te)
 					for j := len(tr) - 1; j >= 0; j-- {
 						tmp := tr[j]
-						if len(tmp) > 0 {
-							if j < len(tr)-1 {
-								if len(te) > int(math.MaxUint8-1) {
-									tmp.appendJmp(OC_jz, int32(len(te)+1))
-									tmp.append(OC_pop)
-								} else {
-									tmp.append(OC_jz8, OpCode(len(te)+1))
-									tmp.append(OC_pop)
-								}
+						if j < len(tr)-1 {
+							if len(te) > int(math.MaxUint8-1) {
+								tmp.appendJmp(OC_jz, int32(len(te)+1))
+								tmp.append(OC_pop)
+							} else {
+								tmp.append(OC_jz8, OpCode(len(te)+1))
+								tmp.append(OC_pop)
 							}
-							te = append(tmp, te...)
 						}
+						te = append(tmp, te...)
 					}
 					if len(te) == oldlen {
 						te = nil

--- a/src/system.go
+++ b/src/system.go
@@ -94,6 +94,7 @@ type System struct {
 	ignoreMostErrors            bool
 	stringPool                  [MaxSimul * 2]StringPool
 	bcStack                     BytecodeStack
+	specialFlag                 GlobalSpecialFlag
 }
 
 func (s *System) init(w, h int32) *lua.LState {