Commit: c24afe66fb38fcbcd13f561f6f55e2a92acbffcf - ikemen_go (git)

Go で書き直した Ikemen

Commit MetaInfo

• Revisão: c24afe66fb38fcbcd13f561f6f55e2a92acbffcf (tree)
• Hora: 2016-12-10 00:34:59
• Autor: SUEHIRO <supersuehiro@user...>
• Commiter: SUEHIRO

Mensagem de Log

式の処理を書き始める

Mudança Sumário

• modified: src/compiler.go
• modified: src/input.go
• modified: src/script.go
• modified: src/system.go

Diff

--- a/src/compiler.go
+++ b/src/compiler.go
@@ -5,24 +5,370 @@ import (
 	"strings"
 )
 
-type StateByteCode struct{}
+const kuuhaktokigou = " !=<>()|&+-*/%,[]^|:\"\t\r\n"
+
+type StateType int32
+
+const (
+	ST_S StateType = 1 << iota
+	ST_C
+	ST_A
+	ST_L
+	ST_N
+	ST_U
+	ST_D = ST_L
+	ST_F = ST_N
+	ST_P = ST_U
+)
+
+type AttackType int32
+
+const (
+	AT_NA AttackType = 1 << (iota + 6)
+	AT_NT
+	AT_NP
+	AT_SA
+	AT_ST
+	AT_SP
+	AT_HA
+	AT_HT
+	AT_HP
+)
+
+type MoveType int32
+
+const (
+	MT_I MoveType = 1 << (iota + 15)
+	MT_H
+	MT_A   = MT_I + 1
+	MT_U   = MT_H + 1
+	MT_MNS = MT_I
+	MT_PLS = MT_H
+)
+
+type ValueType int
+
+const (
+	VT_Any ValueType = iota
+	VT_Float
+	VT_Int
+	VT_Bool
+)
+
+type ByteExp []byte
+type StateByteCode struct {
+	stateType StateType
+	moveType  MoveType
+	physics   StateType
+}
+
+func newStateByteCode() *StateByteCode {
+	return &StateByteCode{stateType: ST_S, moveType: MT_I, physics: ST_N}
+}
+
 type ByteCode struct{ states map[int32]StateByteCode }
 
 func newByteCode() *ByteCode {
 	return &ByteCode{states: make(map[int32]StateByteCode)}
 }
 
+type ExpFunc func(out *ByteExp, in *string) (ValueType, error)
 type Compiler struct{ cmdl *CommandList }
 
 func newCompiler() *Compiler {
 	return &Compiler{}
 }
+func (c *Compiler) tokenizer(in *string) string {
+	*in = strings.TrimSpace(*in)
+	if len(*in) == 0 {
+		return ""
+	}
+	switch (*in)[0] {
+	case '=':
+		*in = (*in)[1:]
+		return "="
+	case ':':
+		if len(*in) >= 2 && (*in)[1] == '=' {
+			*in = (*in)[2:]
+			return ":="
+		}
+		*in = (*in)[1:]
+		return ":"
+	case '!':
+		if len(*in) >= 2 && (*in)[1] == '=' {
+			*in = (*in)[2:]
+			return "!="
+		}
+		*in = (*in)[1:]
+		return "!"
+	case '>':
+		if len(*in) >= 2 && (*in)[1] == '=' {
+			*in = (*in)[2:]
+			return ">="
+		}
+		*in = (*in)[1:]
+		return ">"
+	case '<':
+		if len(*in) >= 2 && (*in)[1] == '=' {
+			*in = (*in)[2:]
+			return "<="
+		}
+		*in = (*in)[1:]
+		return "<"
+	case '~':
+		*in = (*in)[1:]
+		return "~"
+	case '&':
+		if len(*in) >= 2 && (*in)[1] == '&' {
+			*in = (*in)[2:]
+			return "&&"
+		}
+		*in = (*in)[1:]
+		return "&"
+	case '^':
+		if len(*in) >= 2 && (*in)[1] == '^' {
+			*in = (*in)[2:]
+			return "^^"
+		}
+		*in = (*in)[1:]
+		return "^"
+	case '|':
+		if len(*in) >= 2 && (*in)[1] == '|' {
+			*in = (*in)[2:]
+			return "||"
+		}
+		*in = (*in)[1:]
+		return "|"
+	case '+':
+		*in = (*in)[1:]
+		return "+"
+	case '-':
+		*in = (*in)[1:]
+		return "-"
+	case '*':
+		if len(*in) >= 2 && (*in)[1] == '*' {
+			*in = (*in)[2:]
+			return "**"
+		}
+		*in = (*in)[1:]
+		return "*"
+	case '/':
+		*in = (*in)[1:]
+		return "/"
+	case '%':
+		*in = (*in)[1:]
+		return "%"
+	case ',':
+		*in = (*in)[1:]
+		return ","
+	case '(':
+		*in = (*in)[1:]
+		return "("
+	case ')':
+		*in = (*in)[1:]
+		return ")"
+	case '[':
+		*in = (*in)[1:]
+		return "["
+	case ']':
+		*in = (*in)[1:]
+		return "]"
+	case '"':
+		*in = (*in)[1:]
+		return "\""
+	}
+	ia := strings.IndexAny(*in, kuuhaktokigou)
+	if ia < 0 {
+		ia = len(*in)
+	}
+	token := (*in)[:ia]
+	*in = (*in)[ia:]
+	return token
+}
+func (c *Compiler) expBoolOr(out *ByteExp, in *string) (ValueType, error) {
+	unimplemented()
+	return 0, nil
+}
+func (c *Compiler) typedExp(ef ExpFunc, out *ByteExp, in *string,
+	vt ValueType) error {
+	t, err := ef(out, in)
+	if err != nil {
+		return err
+	}
+	unimplemented()
+	return nil
+}
+func (c *Compiler) fullExpression(out *ByteExp, in *string,
+	vt ValueType) error {
+	if err := c.typedExp(c.expBoolOr, out, in, vt); err != nil {
+		return err
+	}
+	if token := c.tokenizer(in); len(token) > 0 {
+		return Error(token + "が不正です")
+	}
+	return nil
+}
 func (c *Compiler) parseSection(lines []string, i *int,
-	f func(name, data string) error) (IniSection, error) {
+	sctrl func(name, data string) error) (IniSection, error) {
 	is := NewIniSection()
-	unimplemented()
+	for ; *i < len(lines); (*i)++ {
+		line := strings.ToLower(strings.TrimSpace(
+			strings.SplitN(lines[*i], ";", 2)[0]))
+		if len(line) > 0 && line[0] == '[' {
+			(*i)--
+			break
+		}
+		var name, data string
+		if len(line) >= 3 && strings.ToLower(line[:3]) == "var" {
+			name, data = "var", line
+		} else if len(line) >= 4 && strings.ToLower(line[:4]) == "fvar" {
+			name, data = "fvar", line
+		} else if len(line) >= 6 && strings.ToLower(line[:6]) == "sysvar" {
+			name, data = "sysvar", line
+		} else if len(line) >= 7 && strings.ToLower(line[:7]) == "sysfvar" {
+			name, data = "sysfvar", line
+		} else {
+			ia := strings.IndexAny(line, "= \t")
+			if ia > 0 {
+				name = strings.ToLower(line[:ia])
+				ia = strings.Index(line, "=")
+				if ia >= 0 {
+					data = strings.TrimSpace(line[ia+1:])
+				}
+			}
+		}
+		if len(name) > 0 {
+			_, ok := is[name]
+			if ok && (len(name) < 7 || name[:7] != "trigger") {
+				if sys.ignoreMostErrors {
+					continue
+				}
+				return nil, Error(name + "が重複しています")
+			}
+			if sctrl != nil {
+				switch name {
+				case "type", "persistent", "ignorehitpause":
+				default:
+					if len(name) < 7 || name[:7] != "trigger" {
+						is[name] = data
+						continue
+					}
+				}
+				if err := sctrl(name, data); err != nil {
+					return nil, err
+				}
+			} else {
+				is[name] = data
+			}
+		}
+	}
 	return is, nil
 }
+func (c *Compiler) stateSec(is IniSection, f func() error) error {
+	if err := f(); err != nil {
+		return err
+	}
+	if !sys.ignoreMostErrors {
+		var str string
+		for k, _ := range is {
+			if len(str) > 0 {
+				str += ", "
+			}
+			str += k
+		}
+		if len(str) > 0 {
+			return Error(str + "は無効なキー名です")
+		}
+	}
+	return nil
+}
+func (c *Compiler) stateParam(is IniSection, name string,
+	f func(string) error) error {
+	data, ok := is[name]
+	if ok {
+		if err := f(data); err != nil {
+			return Error(name + ": " + err.Error())
+		}
+		delete(is, name)
+	}
+	return nil
+}
+func (c *Compiler) stateDef(is IniSection, sbc *StateByteCode) error {
+	return c.stateSec(is, func() error {
+		if err := c.stateParam(is, "type", func(data string) error {
+			if len(data) == 0 {
+				return Error("値が指定されていません")
+			}
+			switch strings.ToLower(data)[0] {
+			case 's':
+				sbc.stateType = ST_S
+			case 'c':
+				sbc.stateType = ST_C
+			case 'a':
+				sbc.stateType = ST_A
+			case 'l':
+				sbc.stateType = ST_L
+			case 'u':
+				sbc.stateType = ST_U
+			default:
+				return Error(data + "が無効な値です")
+			}
+			return nil
+		}); err != nil {
+			return err
+		}
+		if err := c.stateParam(is, "movetype", func(data string) error {
+			if len(data) == 0 {
+				return Error("値が指定されていません")
+			}
+			switch strings.ToLower(data)[0] {
+			case 'i':
+				sbc.moveType = MT_I
+			case 'a':
+				sbc.moveType = MT_A
+			case 'h':
+				sbc.moveType = MT_H
+			case 'u':
+				sbc.moveType = MT_U
+			default:
+				return Error(data + "が無効な値です")
+			}
+			return nil
+		}); err != nil {
+			return err
+		}
+		if err := c.stateParam(is, "physics", func(data string) error {
+			if len(data) == 0 {
+				return Error("値が指定されていません")
+			}
+			switch strings.ToLower(data)[0] {
+			case 's':
+				sbc.physics = ST_S
+			case 'c':
+				sbc.physics = ST_C
+			case 'a':
+				sbc.physics = ST_A
+			case 'n':
+				sbc.physics = ST_N
+			case 'u':
+				sbc.physics = ST_U
+			default:
+				return Error(data + "が無効な値です")
+			}
+			return nil
+		}); err != nil {
+			return err
+		}
+		if err := c.stateParam(is, "hitcountpersist", func(data string) error {
+			unimplemented()
+			return nil
+		}); err != nil {
+			return err
+		}
+		unimplemented()
+		return nil
+	})
+}
 func (c *Compiler) stateCompile(bc *ByteCode, filename, def string) error {
 	var lines []string
 	if err := LoadFile(&filename, def, func(filename string) error {
@@ -41,10 +387,8 @@ func (c *Compiler) stateCompile(bc *ByteCode, filename, def string) error {
 	}
 	existInThisFile := make(map[int32]bool)
 	for ; i < len(lines); i++ {
-		line := strings.ToLower(lines[i])
-		if idx := strings.Index(line, ";"); idx >= 0 {
-			line = strings.TrimSpace(line[:idx])
-		}
+		line := strings.ToLower(strings.TrimSpace(
+			strings.SplitN(lines[i], ";", 2)[0]))
 		if len(line) < 11 || line[0] != '[' || line[len(line)-1] != ']' ||
 			line[1:10] != "statedef " {
 			continue
@@ -59,6 +403,10 @@ func (c *Compiler) stateCompile(bc *ByteCode, filename, def string) error {
 		if err != nil {
 			return errmes(err)
 		}
+		sbc := newStateByteCode()
+		if err := c.stateDef(is, sbc); err != nil {
+			return errmes(err)
+		}
 		unimplemented()
 	}
 	return nil

--- a/src/input.go
+++ b/src/input.go
@@ -428,12 +428,21 @@ func (ni *NetInput) Close() { unimplemented() }
 func (ni *NetInput) Input(cb *CommandBuffer, i int, facing int32) {
 	unimplemented()
 }
+func (ni *NetInput) Stop() { unimplemented() }
+func (ni *NetInput) Synchronize() error {
+	unimplemented()
+	return nil
+}
 
 type FileInput struct{ ib []InputBits }
 
-func (ni *FileInput) Close() { unimplemented() }
-func (ni *FileInput) Input(cb *CommandBuffer, i int, facing int32) {
+func (fi *FileInput) Close() { unimplemented() }
+func (fi *FileInput) Input(cb *CommandBuffer, i int, facing int32) {
+	unimplemented()
+}
+func (fi *FileInput) Synchronize() error {
 	unimplemented()
+	return nil
 }
 
 type AiInput struct {

--- a/src/script.go
+++ b/src/script.go
@@ -381,6 +381,10 @@ func systemScriptInit(l *lua.LState) {
 		l.Push(lua.LNumber(sys.sel.SetStageNo(int(numArg(l, 1)))))
 		return 1
 	})
+	luaRegister(l, "selectStage", func(*lua.LState) int {
+		sys.sel.SelectStage(int(numArg(l, 1)))
+		return 0
+	})
 	luaRegister(l, "setTeamMode", func(*lua.LState) int {
 		tn := int(numArg(l, 1))
 		if tn < 1 || tn > 2 {
@@ -433,6 +437,10 @@ func systemScriptInit(l *lua.LState) {
 		l.Push(lua.LNumber(ret))
 		return 1
 	})
+	luaRegister(l, "getStageName", func(*lua.LState) int {
+		l.Push(lua.LString(sys.sel.GetStageName(int(numArg(l, 1)))))
+		return 1
+	})
 	luaRegister(l, "refresh", func(*lua.LState) int {
 		sys.await(60)
 		if sys.gameEnd {
@@ -545,4 +553,64 @@ func systemScriptInit(l *lua.LState) {
 		sys.loadStart()
 		return 0
 	})
+	luaRegister(l, "game", func(l *lua.LState) int {
+		if sys.gameEnd {
+			l.Push(lua.LNumber(-1))
+			return 1
+		}
+		winp := int32(0)
+		sys.rexisted = [2]int32{0, 0}
+		mw := sys.rexisted
+		for i := range sys.lifebar.wi {
+			sys.lifebar.wi[i].clear()
+		}
+		sys.draws = 0
+		load := func() error {
+			sys.loader.runTread()
+			for sys.loader.state != LS_Complete {
+				if sys.loader.state == LS_Error {
+					return sys.loader.err
+				}
+				sys.await(60)
+			}
+			return nil
+		}
+		fight := func() (int32, error) {
+			if err := load(); err != nil {
+				return -1, err
+			}
+			unimplemented()
+			if sys.round == 1 {
+				if sys.tmode[1] == TM_Turns {
+					mw[0] = int32(sys.numTurns[1])
+				} else {
+					mw[0] = sys.lifebar.ro.match_wins
+				}
+				if sys.tmode[0] == TM_Turns {
+					mw[1] = int32(sys.numTurns[0])
+				} else {
+					mw[1] = sys.lifebar.ro.match_wins
+				}
+			}
+			unimplemented()
+			return winp, nil
+		}
+		if sys.netInput != nil {
+			sys.netInput.Stop()
+		}
+		defer sys.synchronize()
+		for {
+			var err error
+			if winp, err = fight(); err != nil {
+				l.RaiseError(err.Error())
+			}
+			if winp < 0 || sys.tmode[0] != TM_Turns && sys.tmode[1] != TM_Turns ||
+				sys.wins[0] >= mw[0] || sys.wins[1] >= mw[1] || sys.gameEnd {
+				break
+			}
+			unimplemented()
+		}
+		l.Push(lua.LNumber(winp))
+		return 1
+	})
 }

--- a/src/system.go
+++ b/src/system.go
@@ -83,6 +83,7 @@ type System struct {
 	round                       int32
 	wins                        [2]int32
 	rexisted                    [2]int32
+	draws                       int32
 	loader                      Loader
 	chars                       [MaxSimul * 2][]*Char
 	cgi                         [MaxSimul * 2]CharGlobalInfo
@@ -173,6 +174,14 @@ func (s *System) loadStart() {
 	s.loaderReset()
 	s.loader.runTread()
 }
+func (s *System) synchronize() error {
+	if s.fileInput != nil {
+		return s.fileInput.Synchronize()
+	} else if s.netInput != nil {
+		return s.netInput.Synchronize()
+	}
+	return nil
+}
 
 type SelectChar struct {
 	def, name            string
@@ -224,6 +233,16 @@ func (s *Select) SetStageNo(n int) int {
 	return s.curStageNo
 }
 func (s *Select) SelectStage(n int) { s.selectedStageNo = n }
+func (s *Select) GetStageName(n int) string {
+	n %= len(s.stagelist) + 1
+	if n < 0 {
+		n += len(s.stagelist) + 1
+	}
+	if n == 0 {
+		return "Random"
+	}
+	return s.stagelist[n-1].name
+}
 func (s *Select) AddCahr(def string) {
 	s.charlist = append(s.charlist, SelectChar{})
 	sc := &s.charlist[len(s.charlist)-1]
@@ -297,7 +316,7 @@ func (s *Select) AddStage(def string) error {
 	}); err != nil {
 		return err
 	}
-	i, info := 0, false
+	i, info := 0, true
 	s.stagelist = append(s.stagelist, SelectStage{})
 	ss := &s.stagelist[len(s.stagelist)-1]
 	ss.def = def