Commit: 246d29c0aa4ff5b59a839d75c941cca29d05c0e3 - ikemen_go (git)

Go で書き直した Ikemen

Commit MetaInfo

• Revisión: 246d29c0aa4ff5b59a839d75c941cca29d05c0e3 (tree)
• Tiempo: 2016-12-18 00:00:41
• Autor: SUEHIRO <supersuehiro@user...>
• Commiter: SUEHIRO

Log Message

煩雑になると思ったのでステートコントローラーの定数専用の処理をやめた

Cambiar Resumen

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

Diferencia incremental

--- a/src/bytecode.go
+++ b/src/bytecode.go
@@ -63,6 +63,7 @@ const (
 	OC_int8
 	OC_int
 	OC_float
+	OC_pop
 	OC_dup
 	OC_swap
 	OC_jmp8
@@ -187,7 +188,6 @@ const (
 	OC_hitvel_y
 	OC_roundno
 	OC_roundsexisted
-	OC_matchno
 	OC_ishometeam
 	OC_parent
 	OC_root
@@ -359,6 +359,7 @@ const (
 	OC_ex_loseko
 	OC_ex_losetime
 	OC_ex_drawgame
+	OC_ex_matchno
 	OC_ex_tickspersecond
 )
 
@@ -425,6 +426,15 @@ func (bv *BytecodeValue) SetB(b bool) {
 func BytecodeSF() BytecodeValue {
 	return BytecodeValue{VT_SFalse, math.NaN()}
 }
+func BytecodeFloat(f float32) BytecodeValue {
+	return BytecodeValue{VT_Float, float64(f)}
+}
+func BytecodeInt(i int32) BytecodeValue {
+	return BytecodeValue{VT_Int, float64(i)}
+}
+func BytecodeBool(b bool) BytecodeValue {
+	return BytecodeValue{VT_Bool, float64(Btoi(b))}
+}
 
 type BytecodeStack []BytecodeValue
 
@@ -449,29 +459,19 @@ type BytecodeExp []OpCode
 func (be *BytecodeExp) append(op ...OpCode) {
 	*be = append(*be, op...)
 }
-func (be *BytecodeExp) appendFloat(f float32) {
-	be.append((*(*[4]OpCode)(unsafe.Pointer(&f)))[:]...)
-}
-func (be *BytecodeExp) appendInt(i int32) {
-	be.append((*(*[4]OpCode)(unsafe.Pointer(&i)))[:]...)
-}
-func (be BytecodeExp) toF() float32 {
-	return *(*float32)(unsafe.Pointer(&be[0]))
-}
-func (be BytecodeExp) toI() int32 {
-	return *(*int32)(unsafe.Pointer(&be[0]))
-}
 func (be *BytecodeExp) appendValue(bv BytecodeValue) (ok bool) {
 	switch bv.t {
 	case VT_Float:
 		be.append(OC_float)
-		be.appendFloat(float32(bv.v))
+		f := float32(bv.v)
+		be.append((*(*[4]OpCode)(unsafe.Pointer(&f)))[:]...)
 	case VT_Int:
 		if bv.v >= -128 || bv.v <= 127 {
 			be.append(OC_int8, OpCode(bv.v))
 		} else {
 			be.append(OC_int)
-			be.appendInt(int32(bv.v))
+			i := int32(bv.v)
+			be.append((*(*[4]OpCode)(unsafe.Pointer(&i)))[:]...)
 		}
 	case VT_Bool:
 		if bv.v != 0 {
@@ -484,6 +484,10 @@ func (be *BytecodeExp) appendValue(bv BytecodeValue) (ok bool) {
 	}
 	return true
 }
+func (be *BytecodeExp) appendJmp(op OpCode, addr int32) {
+	be.append(OC_int)
+	be.append((*(*[4]OpCode)(unsafe.Pointer(&addr)))[:]...)
+}
 func (_ BytecodeExp) blnot(v *BytecodeValue) {
 	if v.ToB() {
 		v.v = 0
@@ -624,14 +628,36 @@ func (be BytecodeExp) run(c *Char, scpn int) BytecodeValue {
 	sys.bcStack.Clear()
 	for i := 1; i <= len(be); i++ {
 		switch be[i-1] {
+		case OC_jz8, OC_jnz8:
+			if sys.bcStack.Top().ToB() == (be[i-1] == OC_jz8) {
+				i++
+				break
+			}
+			fallthrough
+		case OC_jmp8:
+			if be[i] == 0 {
+				i = len(be)
+			} else {
+				i += int(uint8(be[i])) + 1
+			}
+		case OC_jz, OC_jnz:
+			if sys.bcStack.Top().ToB() == (be[i-1] == OC_jz) {
+				i += 4
+				break
+			}
+			fallthrough
+		case OC_jmp:
+			i += int(*(*int32)(unsafe.Pointer(&be[i]))) + 4
 		case OC_int8:
 			sys.bcStack.Push(BytecodeValue{VT_Int, float64(int8(be[i]))})
 			i++
 		case OC_int:
-			sys.bcStack.Push(BytecodeValue{VT_Int, float64(be[i:].toI())})
+			sys.bcStack.Push(BytecodeValue{VT_Int,
+				float64(*(*int32)(unsafe.Pointer(&be[i])))})
 			i += 4
 		case OC_float:
-			sys.bcStack.Push(BytecodeValue{VT_Float, float64(be[i:].toF())})
+			sys.bcStack.Push(BytecodeValue{VT_Float,
+				float64(*(*float32)(unsafe.Pointer(&be[i])))})
 			i += 4
 		case OC_blnot:
 			be.blnot(sys.bcStack.Top())
@@ -689,10 +715,14 @@ func (be BytecodeExp) run(c *Char, scpn int) BytecodeValue {
 		case OC_blor:
 			v2 := sys.bcStack.Pop()
 			be.blor(sys.bcStack.Top(), v2)
+		case OC_pop:
+			sys.bcStack.Pop()
 		case OC_dup:
 			sys.bcStack.Dup()
 		case OC_swap:
 			sys.bcStack.Swap()
+		case OC_time:
+			sys.bcStack.Push(BytecodeInt(c.time()))
 		default:
 			unimplemented()
 		}
@@ -710,13 +740,10 @@ func (be BytecodeExp) evalB(c *Char, scpn int) bool {
 }
 
 type StateController interface {
-	Run(c *Char, scpn int) (changeState bool)
+	Run(c *Char, ps *int32) (changeState bool)
 }
 
-const (
-	SCID_trigger byte = 0
-	SCID_const   byte = 128
-)
+const SCID_trigger byte = 255
 
 type StateControllerBase struct {
 	playerNo       int
@@ -728,21 +755,21 @@ type StateControllerBase struct {
 func newStateControllerBase(pn int) *StateControllerBase {
 	return &StateControllerBase{playerNo: pn, persistent: 1}
 }
-func (scb StateControllerBase) beToExp(be ...BytecodeExp) []BytecodeExp {
+func (_ StateControllerBase) beToExp(be ...BytecodeExp) []BytecodeExp {
 	return be
 }
-func (scb StateControllerBase) fToExp(f ...float32) (exp []BytecodeExp) {
+func (_ StateControllerBase) fToExp(f ...float32) (exp []BytecodeExp) {
 	for _, v := range f {
 		var be BytecodeExp
-		be.appendFloat(v)
+		be.appendValue(BytecodeFloat(v))
 		exp = append(exp, be)
 	}
 	return
 }
-func (scb StateControllerBase) iToExp(i ...int32) (exp []BytecodeExp) {
+func (_ StateControllerBase) iToExp(i ...int32) (exp []BytecodeExp) {
 	for _, v := range i {
 		var be BytecodeExp
-		be.appendInt(v)
+		be.appendValue(BytecodeInt(v))
 		exp = append(exp, be)
 	}
 	return
@@ -755,7 +782,12 @@ func (scb *StateControllerBase) add(id byte, exp []BytecodeExp) {
 		scb.code = append(scb.code, (*(*[]byte)(unsafe.Pointer(&e)))...)
 	}
 }
-func (scb StateControllerBase) run(f func(byte, []BytecodeExp) bool) bool {
+func (scb StateControllerBase) run(c *Char, ps *int32,
+	f func(byte, []BytecodeExp)) bool {
+	(*ps)--
+	if *ps > 0 {
+		return false
+	}
 	for i := 0; i < len(scb.code); {
 		id := scb.code[i]
 		i++
@@ -768,17 +800,22 @@ func (scb StateControllerBase) run(f func(byte, []BytecodeExp) bool) bool {
 			exp[m] = (*(*BytecodeExp)(unsafe.Pointer(&scb.code)))[i : i+int(l)]
 			i += int(l)
 		}
-		if !f(id, exp) {
-			return false
+		if id == SCID_trigger {
+			if !exp[0].evalB(c, scb.playerNo) {
+				return false
+			}
+		} else {
+			f(id, exp)
 		}
 	}
+	*ps = scb.persistent
 	return true
 }
 
 type stateDef StateControllerBase
 
 const (
-	stateDef_hitcountpersist byte = iota + 1
+	stateDef_hitcountpersist byte = iota
 	stateDef_movehitpersist
 	stateDef_hitdefpersist
 	stateDef_sprpriority
@@ -788,72 +825,46 @@ const (
 	stateDef_anim
 	stateDef_ctrl
 	stateDef_poweradd
-	stateDef_hitcountpersist_c = stateDef_hitcountpersist + SCID_const
-	stateDef_movehitpersist_c  = stateDef_movehitpersist + SCID_const
-	stateDef_hitdefpersist_c   = stateDef_hitdefpersist + SCID_const
-	stateDef_sprpriority_c     = stateDef_sprpriority + SCID_const
-	stateDef_facep2_c          = stateDef_facep2 + SCID_const
-	stateDef_juggle_c          = stateDef_juggle + SCID_const
-	stateDef_velset_c          = stateDef_velset + SCID_const
-	stateDef_anim_c            = stateDef_anim + SCID_const
-	stateDef_ctrl_c            = stateDef_ctrl + SCID_const
-	stateDef_poweradd_c        = stateDef_poweradd + SCID_const
 )
 
-func (sd stateDef) Run(c *Char, scpn int) bool {
-	StateControllerBase(sd).run(func(id byte, exp []BytecodeExp) bool {
+func (sc stateDef) Run(c *Char, ps *int32) bool {
+	StateControllerBase(sc).run(c, ps, func(id byte, exp []BytecodeExp) {
 		switch id {
-		case stateDef_hitcountpersist, stateDef_hitcountpersist_c:
-			if id == stateDef_hitcountpersist_c || !exp[0].evalB(c, scpn) {
+		case stateDef_hitcountpersist:
+			if !exp[0].evalB(c, sc.playerNo) {
 				c.clearHitCount()
 			}
-		case stateDef_movehitpersist, stateDef_movehitpersist_c:
-			if id == stateDef_movehitpersist_c || !exp[0].evalB(c, scpn) {
+		case stateDef_movehitpersist:
+			if !exp[0].evalB(c, sc.playerNo) {
 				c.clearMoveHit()
 			}
-		case stateDef_hitdefpersist, stateDef_hitdefpersist_c:
-			if id == stateDef_hitdefpersist_c || !exp[0].evalB(c, scpn) {
+		case stateDef_hitdefpersist:
+			if !exp[0].evalB(c, sc.playerNo) {
 				c.clearHitDef()
 			}
 		case stateDef_sprpriority:
-			c.setSprPriority(exp[0].evalI(c, scpn))
-		case stateDef_sprpriority_c:
-			c.setSprPriority(exp[0].toI())
-		case stateDef_facep2, stateDef_facep2_c:
-			if id == stateDef_facep2_c || exp[0].evalB(c, scpn) {
+			c.setSprPriority(exp[0].evalI(c, sc.playerNo))
+		case stateDef_facep2:
+			if exp[0].evalB(c, sc.playerNo) {
 				c.faceP2()
 			}
 		case stateDef_juggle:
-			c.setJuggle(exp[0].evalI(c, scpn))
-		case stateDef_juggle_c:
-			c.setJuggle(exp[0].toI())
+			c.setJuggle(exp[0].evalI(c, sc.playerNo))
 		case stateDef_velset:
-			c.setXV(exp[0].evalF(c, scpn))
+			c.setXV(exp[0].evalF(c, sc.playerNo))
 			if len(exp) > 1 {
-				c.setYV(exp[1].evalF(c, scpn))
+				c.setYV(exp[1].evalF(c, sc.playerNo))
 				if len(exp) > 2 {
-					exp[2].run(c, scpn)
+					exp[2].run(c, sc.playerNo)
 				}
 			}
-		case stateDef_velset_c:
-			c.setXV(exp[0].toF())
-			if len(exp) > 1 {
-				c.setYV(exp[1].toF())
-			}
 		case stateDef_anim:
-			c.changeAnim(exp[0].evalI(c, scpn))
-		case stateDef_anim_c:
-			c.changeAnim(exp[0].toI())
+			c.changeAnim(exp[0].evalI(c, sc.playerNo))
 		case stateDef_ctrl:
-			c.setCtrl(exp[0].evalB(c, scpn))
-		case stateDef_ctrl_c:
-			c.setCtrl(exp[0].toI() != 0)
+			c.setCtrl(exp[0].evalB(c, sc.playerNo))
 		case stateDef_poweradd:
-			c.addPower(exp[0].evalI(c, scpn))
-		case stateDef_poweradd_c:
-			c.addPower(exp[0].toI())
+			c.addPower(exp[0].evalI(c, sc.playerNo))
 		}
-		return true
 	})
 	return false
 }
@@ -861,23 +872,49 @@ func (sd stateDef) Run(c *Char, scpn int) bool {
 type hitBy StateControllerBase
 
 const (
-	_hitBy_value byte = iota
-	_hitBy_value2
+	hitBy_value byte = iota
+	hitBy_value2
 	hitBy_time
-	hitBy_value_c  = _hitBy_value + SCID_const
-	hitBy_value2_c = _hitBy_value2 + SCID_const
-	hitBy_time_c   = hitBy_time + SCID_const
 )
 
-func (nhb hitBy) Run(c *Char, scpn int) bool {
-	unimplemented()
+func (sc hitBy) Run(c *Char, ps *int32) bool {
+	time := int32(1)
+	StateControllerBase(sc).run(c, ps, func(id byte, exp []BytecodeExp) {
+		switch id {
+		case hitBy_time:
+			time = exp[0].evalI(c, sc.playerNo)
+		case hitBy_value:
+			unimplemented()
+		case hitBy_value2:
+			unimplemented()
+		}
+	})
 	return false
 }
 
 type notHitBy hitBy
 
-func (nhb notHitBy) Run(c *Char, scpn int) bool {
-	unimplemented()
+func (sc notHitBy) Run(c *Char, ps *int32) bool {
+	time := int32(1)
+	StateControllerBase(sc).run(c, ps, func(id byte, exp []BytecodeExp) {
+		switch id {
+		case hitBy_time:
+			time = exp[0].evalI(c, sc.playerNo)
+		case hitBy_value:
+			unimplemented()
+		case hitBy_value2:
+			unimplemented()
+		}
+	})
+	return false
+}
+
+type assertSpecial StateControllerBase
+
+func (sc assertSpecial) Run(c *Char, ps *int32) bool {
+	StateControllerBase(sc).run(c, ps, func(id byte, exp []BytecodeExp) {
+		unimplemented()
+	})
 	return false
 }
 

--- a/src/char.go
+++ b/src/char.go
@@ -568,3 +568,7 @@ func (c *Char) setCtrl(ctrl bool) {
 func (c *Char) addPower(power int32) {
 	unimplemented()
 }
+func (c *Char) time() int32 {
+	unimplemented()
+	return 0
+}

--- a/src/common.go
+++ b/src/common.go
@@ -149,6 +149,14 @@ func Atof(str string) float64 {
 	}
 	return f
 }
+func readDigit(d string) (int32, bool) {
+	for _, c := range d {
+		if c < '0' || c > '9' {
+			return 0, false
+		}
+	}
+	return int32(Atof(d)), true
+}
 func Btoi(b bool) int32 {
 	if b {
 		return 1

--- a/src/compiler.go
+++ b/src/compiler.go
@@ -324,7 +324,13 @@ func (c *Compiler) expValue(out *BytecodeExp, in *string) (BytecodeValue,
 	if !sys.ignoreMostErrors {
 		defer func() { c.usiroOp = false }()
 	}
-	unimplemented()
+	switch c.token {
+	case "time":
+		out.append(OC_time)
+	default:
+		println(c.token)
+		unimplemented()
+	}
 	c.token = c.tokenizer(in)
 	return bv, nil
 }
@@ -704,42 +710,47 @@ func (c *Compiler) expBoolOr(out *BytecodeExp, in *string) (BytecodeValue,
 	return c.expOneOp(out, in, c.expBoolXor, "||", out.blor, OC_blor)
 }
 func (c *Compiler) typedExp(ef ExpFunc, in *string,
-	vt ValueType) (BytecodeExp, BytecodeValue, error) {
+	vt ValueType) (BytecodeExp, error) {
 	c.token = c.tokenizer(in)
 	var be BytecodeExp
 	bv, err := ef(&be, in)
 	if err != nil {
-		return nil, BytecodeSF(), err
+		return nil, err
 	}
 	if !bv.IsSF() {
-		if vt == VT_Bool {
+		switch vt {
+		case VT_Float:
+			bv.SetF(bv.ToF())
+		case VT_Int:
+			bv.SetI(bv.ToI())
+		case VT_Bool:
 			bv.SetB(bv.ToB())
 		}
-		return nil, bv, nil
+		be.appendValue(bv)
 	}
-	return be, BytecodeSF(), nil
+	return be, nil
 }
-func (c *Compiler) argExpression(in *string,
-	vt ValueType) (BytecodeExp, BytecodeValue, error) {
-	be, v, err := c.typedExp(c.expBoolOr, in, vt)
+func (c *Compiler) argExpression(in *string, vt ValueType) (BytecodeExp,
+	error) {
+	be, err := c.typedExp(c.expBoolOr, in, vt)
 	if err != nil {
-		return nil, BytecodeSF(), err
+		return nil, err
 	}
 	if len(c.token) > 0 && c.token != "," {
-		return nil, BytecodeSF(), Error(c.token + "が不正です")
+		return nil, Error(c.token + "が不正です")
 	}
-	return be, v, nil
+	return be, nil
 }
-func (c *Compiler) fullExpression(in *string,
-	vt ValueType) (BytecodeExp, BytecodeValue, error) {
-	be, v, err := c.typedExp(c.expBoolOr, in, vt)
+func (c *Compiler) fullExpression(in *string, vt ValueType) (BytecodeExp,
+	error) {
+	be, err := c.typedExp(c.expBoolOr, in, vt)
 	if err != nil {
-		return nil, BytecodeSF(), err
+		return nil, err
 	}
 	if len(c.token) > 0 {
-		return nil, BytecodeSF(), Error(c.token + "が不正です")
+		return nil, Error(c.token + "が不正です")
 	}
-	return be, v, nil
+	return be, nil
 }
 func (c *Compiler) parseSection(lines []string, i *int,
 	sctrl func(name, data string) error) (IniSection, error) {
@@ -843,50 +854,24 @@ func (c *Compiler) stateParam(is IniSection, name string,
 }
 func (c *Compiler) scAdd(sc *StateControllerBase, id byte,
 	data string, vt ValueType, numArg int) error {
-	bes, vs := []BytecodeExp{}, []BytecodeValue{}
+	bes := []BytecodeExp{}
 	for n := 1; n <= numArg; n++ {
 		var be BytecodeExp
-		var v BytecodeValue
 		var err error
 		if n < numArg {
-			be, v, err = c.argExpression(&data, vt)
+			be, err = c.argExpression(&data, vt)
 		} else {
-			be, v, err = c.fullExpression(&data, vt)
+			be, err = c.fullExpression(&data, vt)
 		}
 		if err != nil {
 			return err
 		}
 		bes = append(bes, be)
-		vs = append(vs, v)
-		if n < numArg && c.token != "," {
+		if c.token != "," {
 			break
 		}
 	}
-	cns := true
-	for i, v := range vs {
-		if v.IsSF() {
-			cns = false
-		} else {
-			bes[i].appendValue(v)
-		}
-	}
-	if cns {
-		if vt == VT_Float {
-			floats := make([]float32, len(vs))
-			for i := range floats {
-				floats[i] = float32(vs[i].v)
-			}
-			sc.add(id+SCID_const, sc.fToExp(floats...))
-		} else {
-			ints := make([]int32, len(vs))
-			for i := range ints {
-				ints[i] = int32(vs[i].v)
-			}
-			sc.add(id+SCID_const, sc.iToExp(ints...))
-		}
-	} else {
-		sc.add(id, bes)
-	}
+	sc.add(id, bes)
 	return nil
 }
 func (c *Compiler) stateDef(is IniSection, sbc *StateBytecode) error {
@@ -959,59 +944,32 @@ func (c *Compiler) stateDef(is IniSection, sbc *StateBytecode) error {
 		b := false
 		if err := c.stateParam(is, "hitcountpersist", func(data string) error {
 			b = true
-			be, v, err := c.fullExpression(&data, VT_Bool)
-			if err != nil {
-				return err
-			}
-			if v.IsSF() {
-				sc.add(stateDef_hitcountpersist, sc.beToExp(be))
-			} else if !v.ToB() { // falseのときだけクリアする
-				sc.add(stateDef_hitcountpersist_c, nil)
-			}
-			return nil
+			return c.scAdd(sc, stateDef_hitcountpersist, data, VT_Bool, 1)
 		}); err != nil {
 			return err
 		}
 		if !b {
-			sc.add(stateDef_hitcountpersist_c, nil)
+			sc.add(stateDef_hitcountpersist, sc.iToExp(0))
 		}
 		b = false
 		if err := c.stateParam(is, "movehitpersist", func(data string) error {
 			b = true
-			be, v, err := c.fullExpression(&data, VT_Bool)
-			if err != nil {
-				return err
-			}
-			if v.IsSF() {
-				sc.add(stateDef_movehitpersist, sc.beToExp(be))
-			} else if !v.ToB() { // falseのときだけクリアする
-				sc.add(stateDef_movehitpersist_c, nil)
-			}
-			return nil
+			return c.scAdd(sc, stateDef_movehitpersist, data, VT_Bool, 1)
 		}); err != nil {
 			return err
 		}
 		if !b {
-			sc.add(stateDef_movehitpersist_c, nil)
+			sc.add(stateDef_movehitpersist, sc.iToExp(0))
 		}
 		b = false
 		if err := c.stateParam(is, "hitdefpersist", func(data string) error {
 			b = true
-			be, v, err := c.fullExpression(&data, VT_Bool)
-			if err != nil {
-				return err
-			}
-			if v.IsSF() {
-				sc.add(stateDef_hitdefpersist, sc.beToExp(be))
-			} else if !v.ToB() { // falseのときだけクリアする
-				sc.add(stateDef_hitdefpersist_c, nil)
-			}
-			return nil
+			return c.scAdd(sc, stateDef_hitdefpersist, data, VT_Bool, 1)
 		}); err != nil {
 			return err
 		}
 		if !b {
-			sc.add(stateDef_hitdefpersist_c, nil)
+			sc.add(stateDef_hitdefpersist, sc.iToExp(0))
 		}
 		if err := c.stateParam(is, "sprpriority", func(data string) error {
 			return c.scAdd(sc, stateDef_sprpriority, data, VT_Int, 1)
@@ -1019,16 +977,7 @@ func (c *Compiler) stateDef(is IniSection, sbc *StateBytecode) error {
 			return err
 		}
 		if err := c.stateParam(is, "facep2", func(data string) error {
-			be, v, err := c.fullExpression(&data, VT_Bool)
-			if err != nil {
-				return err
-			}
-			if v.IsSF() {
-				sc.add(stateDef_facep2, sc.beToExp(be))
-			} else if v.ToB() {
-				sc.add(stateDef_facep2_c, nil)
-			}
-			return nil
+			return c.scAdd(sc, stateDef_facep2, data, VT_Bool, 1)
 		}); err != nil {
 			return err
 		}
@@ -1040,7 +989,7 @@ func (c *Compiler) stateDef(is IniSection, sbc *StateBytecode) error {
 			return err
 		}
 		if !b {
-			sc.add(stateDef_juggle_c, sc.iToExp(0))
+			sc.add(stateDef_juggle, sc.iToExp(0))
 		}
 		if err := c.stateParam(is, "velset", func(data string) error {
 			return c.scAdd(sc, stateDef_velset, data, VT_Float, 3)
@@ -1066,14 +1015,14 @@ func (c *Compiler) stateDef(is IniSection, sbc *StateBytecode) error {
 		return nil
 	})
 }
-func (c *Compiler) hitBySub(is IniSection) (attr int32,
-	timebe BytecodeExp, timev BytecodeValue, two bool, err error) {
-	attr = -1
+func (c *Compiler) hitBySub(is IniSection, sc *StateControllerBase) error {
+	attr, two := int32(-1), false
+	var err error
 	if err = c.stateParam(is, "value", func(data string) error {
 		attr, err = c.attr(data, false)
 		return err
 	}); err != nil {
-		return
+		return err
 	}
 	if attr == -1 {
 		if err = c.stateParam(is, "value2", func(data string) error {
@@ -1081,43 +1030,39 @@ func (c *Compiler) hitBySub(is IniSection) (attr int32,
 			attr, err = c.attr(data, false)
 			return err
 		}); err != nil {
-			return
+			return err
 		}
 	}
 	if attr == -1 {
-		err = Error("valueが指定されていません")
-		return
+		return Error("valueが指定されていません")
 	}
-	timev = BytecodeSF()
 	if err = c.stateParam(is, "time", func(data string) error {
-		timebe, timev, err = c.fullExpression(&data, VT_Int)
-		return err
+		return c.scAdd(sc, hitBy_time, data, VT_Int, 1)
 	}); err != nil {
-		return
+		return err
 	}
-	if len(timebe) == 0 && timev.IsSF() {
-		timev.SetI(1)
+	if two {
+		sc.add(hitBy_value2, sc.iToExp(attr))
+	} else {
+		sc.add(hitBy_value, sc.iToExp(attr))
 	}
-	return
+	return nil
 }
 func (c *Compiler) hitBy(is IniSection, sbc *StateBytecode,
 	sc *StateControllerBase) (StateController, error) {
 	return hitBy(*sc), c.stateSec(is, func() error {
-		attr, timebe, timev, two, err := c.hitBySub(is)
-		if err != nil {
-			return err
-		}
-		unimplemented()
-		return nil
+		return c.hitBySub(is, sc)
 	})
 }
 func (c *Compiler) notHitBy(is IniSection, sbc *StateBytecode,
 	sc *StateControllerBase) (StateController, error) {
 	return notHitBy(*sc), c.stateSec(is, func() error {
-		attr, timebe, timev, two, err := c.hitBySub(is)
-		if err != nil {
-			return err
-		}
+		return c.hitBySub(is, sc)
+	})
+}
+func (c *Compiler) assertSpecial(is IniSection, sbc *StateBytecode,
+	sc *StateControllerBase) (StateController, error) {
+	return assertSpecial(*sc), c.stateSec(is, func() error {
 		unimplemented()
 		return nil
 	})
@@ -1171,6 +1116,10 @@ func (c *Compiler) stateCompile(bc *Bytecode, filename, def string) error {
 			sc := newStateControllerBase(c.playerNo)
 			var scf func(is IniSection, sbc *StateBytecode,
 				sc *StateControllerBase) (StateController, error)
+			var triggerall []BytecodeExp
+			allUtikiri := false
+			var trigger [][]BytecodeExp
+			var trexist []int8
 			is, err := c.parseSection(lines, &i, func(name, data string) error {
 				switch name {
 				case "type":
@@ -1179,6 +1128,8 @@ func (c *Compiler) stateCompile(bc *Bytecode, filename, def string) error {
 						scf = c.hitBy
 					case "nothitby":
 						scf = c.notHitBy
+					case "assertspecial":
+						scf = c.assertSpecial
 					default:
 						println(data)
 						unimplemented()
@@ -1188,12 +1139,61 @@ func (c *Compiler) stateCompile(bc *Bytecode, filename, def string) error {
 						sc.persistent = Atoi(data)
 						if sc.persistent > 128 {
 							sc.persistent = 1
+						} else if sc.persistent <= 0 {
+							sc.persistent = math.MaxInt32
 						}
 					}
 				case "ignorehitpause":
 					sc.ignorehitpause = Atoi(data) != 0
+				case "triggerall":
+					be, err := c.fullExpression(&data, VT_Bool)
+					if err != nil {
+						return err
+					}
+					if len(be) == 2 && be[0] == OC_int8 {
+						if be[1] == 0 {
+							allUtikiri = true
+						}
+					} else if !allUtikiri {
+						triggerall = append(triggerall, be)
+					}
 				default:
-					unimplemented()
+					tn, ok := readDigit(name[7:])
+					if !ok || tn <= 0 || tn > 65536 {
+						errmes(Error("トリガー名 (" + name + ") が不正です"))
+					}
+					if len(trigger) < int(tn) {
+						trigger = append(trigger, make([][]BytecodeExp,
+							int(tn)-len(trigger))...)
+						trexist = append(trexist, make([]int8, int(tn)-len(trexist))...)
+					}
+					tn--
+					be, err := c.fullExpression(&data, VT_Bool)
+					if err != nil {
+						if sys.ignoreMostErrors {
+							_break := false
+							for i := 0; i < int(tn); i++ {
+								if trexist[i] == 0 {
+									_break = true
+									break
+								}
+							}
+							if _break {
+								break
+							}
+						}
+						return err
+					}
+					if len(be) == 2 && be[0] == OC_int8 {
+						if be[1] == 0 {
+							trexist[tn] = -1
+						} else if trexist[tn] == 0 {
+							trexist[tn] = 1
+						}
+					} else if !allUtikiri && trexist[tn] >= 0 {
+						trigger[tn] = append(trigger[tn], be)
+						trexist[tn] = 1
+					}
 				}
 				return nil
 			})
@@ -1203,11 +1203,92 @@ func (c *Compiler) stateCompile(bc *Bytecode, filename, def string) error {
 			if scf == nil {
 				return errmes(Error("typeが指定されていません"))
 			}
+			if len(trexist) == 0 || trexist[0] == 0 {
+				return errmes(Error("trigger1がありません"))
+			}
+			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)
+					}
+				}
+			}
+			if allUtikiri {
+				if len(texp) > 0 {
+					texp.appendValue(BytecodeBool(false))
+				}
+			} else {
+				for i, tr := range trigger {
+					if trexist[i] == 0 {
+						break
+					}
+					var te BytecodeExp
+					if trexist[i] < 0 {
+						te.appendValue(BytecodeBool(false))
+					}
+					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)
+								}
+							}
+							te = append(tmp, te...)
+						}
+					}
+					if len(te) == oldlen {
+						te = nil
+					}
+					if len(te) == 0 {
+						if trexist[i] > 0 {
+							if len(texp) > 0 {
+								texp.appendValue(BytecodeBool(true))
+							}
+							break
+						}
+					} else {
+						texp.append(te...)
+						if i < len(trigger)-1 {
+							texp.append(OC_jnz8, 0)
+							texp.append(OC_pop)
+						}
+					}
+				}
+			}
+			if len(texp) > 0 {
+				sc.add(SCID_trigger, sc.beToExp(texp))
+			}
 			sctrl, err := scf(is, sbc, sc)
 			if err != nil {
 				return errmes(err)
 			}
-			sbc.ctrls = append(sbc.ctrls, sctrl)
+			appending := true
+			if len(texp) > 0 {
+			} else if allUtikiri {
+				appending = false
+			} else {
+				appending = false
+				for _, te := range trexist {
+					if te >= 0 {
+						if te > 0 {
+							appending = true
+						}
+						break
+					}
+				}
+			}
+			if appending {
+				sbc.ctrls = append(sbc.ctrls, sctrl)
+			}
 		}
 		_, ok := bc.states[n]
 		if !ok {