提交: 69c6b071d0f95f00f038e2d1741857babaf7b623 - ikemen_go (git)

Go で書き直した Ikemen

Commit MetaInfo

• 修订版: 69c6b071d0f95f00f038e2d1741857babaf7b623 (tree)
• 时间: 2016-12-12 00:20:43
• 作者: SUEHIRO <supersuehiro@user...>
• Commiter: SUEHIRO

Log Message

ステートコントローラーのバイトコードを考えた

更改概述

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

差异

--- a/src/bytecode.go
+++ b/src/bytecode.go
@@ -56,11 +56,7 @@ const (
 type OpCode byte
 
 const (
-	OC_var0     OpCode = 0
-	OC_sysvar0  OpCode = 60
-	OC_fvar0    OpCode = 65
-	OC_sysfvar0 OpCode = 105
-	OC_var      OpCode = iota + 110
+	OC_var OpCode = iota + 110
 	OC_sysvar
 	OC_fvar
 	OC_sysfvar
@@ -190,6 +186,9 @@ const (
 	OC_hitvel_y
 	OC_roundno
 	OC_roundsexisted
+	OC_matchno
+	OC_ishometeam
+	OC_tickspersecond
 	OC_parent
 	OC_root
 	OC_helper
@@ -201,7 +200,12 @@ const (
 	OC_p2
 	OC_const_
 	OC_gethitvar_
+	OC_stagevar_
 	OC_ex_
+	OC_var0     OpCode = 0
+	OC_sysvar0  OpCode = 60
+	OC_fvar0    OpCode = 65
+	OC_sysfvar0 OpCode = 105
 )
 const (
 	OC_const_data_life OpCode = iota
@@ -329,6 +333,11 @@ const (
 	OC_gethitvar_fall_envshake_phase
 )
 const (
+	OC_stagevar_info_author OpCode = iota
+	OC_stagevar_info_displayname
+	OC_stagevar_info_name
+)
+const (
 	OC_ex_name OpCode = iota
 	OC_ex_authorname
 	OC_ex_p2name
@@ -350,15 +359,6 @@ const (
 	OC_ex_loseko
 	OC_ex_losetime
 	OC_ex_drawgame
-	OC_ex_matchno
-	OC_ex_ishometeam
-	OC_ex_tickspersecond
-	OC_ex_stagevar_
-)
-const (
-	OC_ex_stagevar_info_author OpCode = iota
-	OC_ex_stagevar_info_displayname
-	OC_ex_stagevar_info_name
 )
 
 type StringPool struct {
@@ -385,11 +385,16 @@ func (sp *StringPool) Add(s string) int {
 type BytecodeExp []OpCode
 
 func (be *BytecodeExp) appendFloat(f float32) {
-	*be = append(append(*be, OC_float),
-		(*(*[4]OpCode)(unsafe.Pointer(&f)))[:]...)
+	*be = append(*be, (*(*[4]OpCode)(unsafe.Pointer(&f)))[:]...)
 }
 func (be *BytecodeExp) appendInt(i int32) {
-	*be = append(append(*be, OC_int), (*(*[4]OpCode)(unsafe.Pointer(&i)))[:]...)
+	*be = append(*be, (*(*[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(t ValueType, v float64) (ok bool) {
 	if math.IsNaN(v) {
@@ -397,11 +402,13 @@ func (be *BytecodeExp) AppendValue(t ValueType, v float64) (ok bool) {
 	}
 	switch t {
 	case VT_Float:
+		*be = append(*be, OC_float)
 		be.appendFloat(float32(v))
 	case VT_Int:
 		if v >= -128 || v <= 127 {
 			*be = append(*be, OC_int8, OpCode(v))
 		} else {
+			*be = append(*be, OC_int)
 			be.appendInt(int32(v))
 		}
 	case VT_Bool:
@@ -415,11 +422,79 @@ func (be *BytecodeExp) AppendValue(t ValueType, v float64) (ok bool) {
 	}
 	return true
 }
+func (be BytecodeExp) run(c *Char) (t ValueType, v float64) {
+	unimplemented()
+	return VT_Int, 0
+}
+func (be BytecodeExp) eval(c *Char) float64 {
+	_, v := be.run(c)
+	return v
+}
+
+type StateController interface {
+	Run(c *Char) (changeState bool)
+}
+
+const (
+	SCID_trigger byte = 0
+	SCID_const   byte = 128
+)
+
+type StateControllerBase []byte
+
+func (scb StateControllerBase) beToExp(be ...BytecodeExp) []BytecodeExp {
+	return be
+}
+func (scb StateControllerBase) fToExp(f ...float32) (exp []BytecodeExp) {
+	for _, v := range f {
+		var be BytecodeExp
+		be.appendFloat(v)
+		exp = append(exp, be)
+	}
+	return
+}
+func (scb StateControllerBase) iToExp(i ...int32) (exp []BytecodeExp) {
+	for _, v := range i {
+		var be BytecodeExp
+		be.appendInt(v)
+		exp = append(exp, be)
+	}
+	return
+}
+func (scb *StateControllerBase) add(id byte, exp []BytecodeExp) {
+	*scb = append(*scb, id, byte(len(exp)))
+	for _, e := range exp {
+		l := int32(len(e))
+		*scb = append(*scb, (*(*[4]byte)(unsafe.Pointer(&l)))[:]...)
+		*scb = append(*scb, (*(*[]byte)(unsafe.Pointer(&e)))...)
+	}
+}
+func (scb StateControllerBase) run(f func(byte, []BytecodeExp) bool) bool {
+	for i := 0; i < len(scb); {
+		id := scb[i]
+		i++
+		n := scb[i]
+		i++
+		exp := make([]BytecodeExp, n)
+		for m := byte(0); m < n; m++ {
+			l := *(*int32)(unsafe.Pointer(&scb[i]))
+			i += 4
+			exp[m] = (*(*BytecodeExp)(unsafe.Pointer(&scb)))[i : i+int(l)]
+			i += int(l)
+		}
+		if !f(id, exp) {
+			return false
+		}
+	}
+	return true
+}
 
 type StateBytecode struct {
 	stateType StateType
 	moveType  MoveType
 	physics   StateType
+	stateDef  StateController
+	ctrls     []StateController
 }
 
 func newStateBytecode() *StateBytecode {

--- a/src/char.go
+++ b/src/char.go
@@ -276,6 +276,8 @@ type Char struct {
 	playerno    int
 	keyctrl     bool
 	player      bool
+	sprpriority int32
+	juggle      int32
 	size        CharSize
 }
 
@@ -533,3 +535,21 @@ func (c *Char) load(def string) error {
 	}
 	return nil
 }
+func (c *Char) clearHitCount() {
+	unimplemented()
+}
+func (c *Char) clearMoveHit() {
+	unimplemented()
+}
+func (c *Char) clearHitDef() {
+	unimplemented()
+}
+func (c *Char) faceP2() {
+	unimplemented()
+}
+func (c *Char) setXV(xv float32) {
+	unimplemented()
+}
+func (c *Char) setYV(yv float32) {
+	unimplemented()
+}

--- a/src/compiler.go
+++ b/src/compiler.go
@@ -8,6 +8,72 @@ import (
 
 const kuuhaktokigou = " !=<>()|&+-*/%,[]^|:\"\t\r\n"
 
+type stateDef StateControllerBase
+
+const (
+	stateDef_hitcountpersist byte = iota + 1
+	stateDef_movehitpersist
+	stateDef_hitdefpersist
+	stateDef_sprpriority
+	stateDef_facep2
+	stateDef_juggle
+	stateDef_velset
+	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
+)
+
+func (sd stateDef) Run(c *Char) bool {
+	StateControllerBase(sd).run(func(id byte, exp []BytecodeExp) bool {
+		switch id {
+		case stateDef_hitcountpersist, stateDef_hitcountpersist_c:
+			if id == stateDef_hitcountpersist_c || exp[0].eval(c) == 0 {
+				c.clearHitCount()
+			}
+		case stateDef_movehitpersist, stateDef_movehitpersist_c:
+			if id == stateDef_movehitpersist_c || exp[0].eval(c) == 0 {
+				c.clearMoveHit()
+			}
+		case stateDef_hitdefpersist, stateDef_hitdefpersist_c:
+			if id == stateDef_hitdefpersist_c || exp[0].eval(c) == 0 {
+				c.clearHitDef()
+			}
+		case stateDef_sprpriority:
+			c.sprpriority = int32(exp[0].eval(c))
+		case stateDef_sprpriority_c:
+			c.sprpriority = exp[0].toI()
+		case stateDef_facep2, stateDef_facep2_c:
+			if id == stateDef_facep2_c || exp[0].eval(c) != 0 {
+				c.faceP2()
+			}
+		case stateDef_juggle:
+			c.juggle = int32(exp[0].eval(c))
+		case stateDef_juggle_c:
+			c.juggle = exp[0].toI()
+		case stateDef_velset:
+			c.setXV(float32(exp[0].eval(c)))
+			if len(exp) > 1 {
+				c.setYV(float32(exp[1].eval(c)))
+				if len(exp) > 2 {
+					exp[2].eval(c)
+				}
+			}
+		case stateDef_velset_c:
+			c.setXV(exp[0].toF())
+			if len(exp) > 1 {
+				c.setYV(exp[1].toF())
+			}
+		}
+		unimplemented()
+		return true
+	})
+	return false
+}
+
 type ExpFunc func(out *BytecodeExp, in *string) (ValueType, float64, error)
 type Compiler struct{ cmdl *CommandList }
 
@@ -147,16 +213,34 @@ func (c *Compiler) typedExp(ef ExpFunc, out *BytecodeExp, in *string,
 	out.AppendValue(t, v)
 	return math.NaN(), nil
 }
-func (c *Compiler) fullExpression(out *BytecodeExp, in *string,
-	vt ValueType) (float64, error) {
-	v, err := c.typedExp(c.expBoolOr, out, in, vt)
+func (c *Compiler) argExpression(in *string,
+	vt ValueType) (BytecodeExp, float64, error) {
+	var be BytecodeExp
+	v, err := c.typedExp(c.expBoolOr, &be, in, vt)
 	if err != nil {
-		return 0, err
+		return nil, 0, err
+	}
+	oldin := *in
+	if token := c.tokenizer(in); len(token) > 0 {
+		if token == "," {
+			*in = oldin
+		} else {
+			return nil, 0, Error(token + "が不正です")
+		}
+	}
+	return be, v, nil
+}
+func (c *Compiler) fullExpression(in *string,
+	vt ValueType) (BytecodeExp, float64, error) {
+	var be BytecodeExp
+	v, err := c.typedExp(c.expBoolOr, &be, in, vt)
+	if err != nil {
+		return nil, 0, err
 	}
 	if token := c.tokenizer(in); len(token) > 0 {
-		return 0, Error(token + "が不正です")
+		return nil, 0, Error(token + "が不正です")
 	}
-	return v, nil
+	return be, v, nil
 }
 func (c *Compiler) parseSection(lines []string, i *int,
 	sctrl func(name, data string) error) (IniSection, error) {
@@ -243,8 +327,54 @@ 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 {
+	bes, vs := []BytecodeExp{}, []float64{}
+	for n := 1; n <= numArg; n++ {
+		var be BytecodeExp
+		var v float64
+		var err error
+		if n < numArg {
+			be, v, err = c.argExpression(&data, vt)
+		} else {
+			be, v, err = c.fullExpression(&data, vt)
+		}
+		if err != nil {
+			return err
+		}
+		bes = append(bes, be)
+		vs = append(vs, v)
+	}
+	cns := true
+	for i, v := range vs {
+		if math.IsNaN(v) {
+			cns = false
+		} else {
+			bes[i].AppendValue(vt, v)
+		}
+	}
+	if cns {
+		if vt == VT_Float {
+			floats := make([]float32, len(vs))
+			for i := range floats {
+				floats[i] = float32(vs[i])
+			}
+			sc.add(id+SCID_const, sc.fToExp(floats...))
+		} else {
+			ints := make([]int32, len(vs))
+			for i := range ints {
+				ints[i] = int32(vs[i])
+			}
+			sc.add(id+SCID_const, sc.iToExp(ints...))
+		}
+	} else {
+		sc.add(id, bes)
+	}
+	return nil
+}
 func (c *Compiler) stateDef(is IniSection, sbc *StateBytecode) error {
 	return c.stateSec(is, func() error {
+		var sc StateControllerBase
 		if err := c.stateParam(is, "type", func(data string) error {
 			if len(data) == 0 {
 				return Error("値が指定されていません")
@@ -309,15 +439,99 @@ func (c *Compiler) stateDef(is IniSection, sbc *StateBytecode) error {
 		}); err != nil {
 			return err
 		}
+		b := false
 		if err := c.stateParam(is, "hitcountpersist", func(data string) error {
-			var be BytecodeExp
-			v, err := c.fullExpression(&be, &data, VT_Bool)
-			unimplemented()
+			b = true
+			be, v, err := c.fullExpression(&data, VT_Bool)
+			if err != nil {
+				return err
+			}
+			if math.IsNaN(v) {
+				sc.add(stateDef_hitcountpersist, sc.beToExp(be))
+			} else if v == 0 { // falseのときだけクリアする
+				sc.add(stateDef_hitcountpersist_c, nil)
+			}
 			return nil
 		}); err != nil {
 			return err
 		}
+		if !b {
+			sc.add(stateDef_hitcountpersist_c, nil)
+		}
+		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 math.IsNaN(v) {
+				sc.add(stateDef_movehitpersist, sc.beToExp(be))
+			} else if v == 0 { // falseのときだけクリアする
+				sc.add(stateDef_movehitpersist_c, nil)
+			}
+			return nil
+		}); err != nil {
+			return err
+		}
+		if !b {
+			sc.add(stateDef_movehitpersist_c, nil)
+		}
+		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 math.IsNaN(v) {
+				sc.add(stateDef_hitdefpersist, sc.beToExp(be))
+			} else if v == 0 { // falseのときだけクリアする
+				sc.add(stateDef_hitdefpersist_c, nil)
+			}
+			return nil
+		}); err != nil {
+			return err
+		}
+		if !b {
+			sc.add(stateDef_hitdefpersist_c, nil)
+		}
+		if err := c.stateParam(is, "sprpriority", func(data string) error {
+			return c.scAdd(&sc, stateDef_sprpriority, data, VT_Int, 1)
+		}); err != nil {
+			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 math.IsNaN(v) {
+				sc.add(stateDef_facep2, sc.beToExp(be))
+			} else if v != 0 {
+				sc.add(stateDef_facep2_c, nil)
+			}
+			return nil
+		}); err != nil {
+			return err
+		}
+		b = false
+		if err := c.stateParam(is, "juggle", func(data string) error {
+			b = true
+			return c.scAdd(&sc, stateDef_juggle, data, VT_Int, 1)
+		}); err != nil {
+			return err
+		}
+		if !b {
+			sc.add(stateDef_juggle_c, sc.iToExp(0))
+		}
+		if err := c.stateParam(is, "velset", func(data string) error {
+			return c.scAdd(&sc, stateDef_velset, data, VT_Float, 3)
+		}); err != nil {
+			return err
+		}
 		unimplemented()
+		sbc.stateDef = stateDef(sc)
 		return nil
 	})
 }