Commit: b197271a2d7f79884eeecb100e4af0d883f54bee - ikemen_go (git)

Go で書き直した Ikemen

Commit MetaInfo

• Révision: b197271a2d7f79884eeecb100e4af0d883f54bee (tree)
• l'heure: 2016-12-08 00:30:47
• Auteur: SUEHIRO <supersuehiro@user...>
• Commiter: SUEHIRO

Message de Log

コマンドの読み込みとステートのパーズ少し

Change Summary

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

Modification

--- a/src/compiler.go
+++ b/src/compiler.go
@@ -5,17 +5,64 @@ import (
 	"strings"
 )
 
-type ByteCode struct{}
+type StateByteCode struct{}
+type ByteCode struct{ states map[int32]StateByteCode }
 
 func newByteCode() *ByteCode {
-	return &ByteCode{}
+	return &ByteCode{states: make(map[int32]StateByteCode)}
 }
 
-type Compiler struct{ ver [2]int16 }
+type Compiler struct{ cmdl *CommandList }
 
 func newCompiler() *Compiler {
 	return &Compiler{}
 }
+func (c *Compiler) parseSection(lines []string, i *int,
+	f func(name, data string) error) (IniSection, error) {
+	is := NewIniSection()
+	unimplemented()
+	return is, nil
+}
+func (c *Compiler) stateCompile(bc *ByteCode, filename, def string) error {
+	var lines []string
+	if err := LoadFile(&filename, def, func(filename string) error {
+		str, err := LoadText(filename)
+		if err != nil {
+			return err
+		}
+		lines = SplitAndTrim(str, "\n")
+		return nil
+	}); err != nil {
+		return err
+	}
+	i := 0
+	errmes := func(err error) error {
+		return Error(fmt.Sprintf("%v:%v:\n%v", filename, i+1, err.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])
+		}
+		if len(line) < 11 || line[0] != '[' || line[len(line)-1] != ']' ||
+			line[1:10] != "statedef " {
+			continue
+		}
+		n := Atoi(line[11:])
+		if existInThisFile[n] {
+			continue
+		}
+		existInThisFile[n] = true
+		i++
+		is, err := c.parseSection(lines, &i, nil)
+		if err != nil {
+			return errmes(err)
+		}
+		unimplemented()
+	}
+	return nil
+}
 func (c *Compiler) Compile(n int, def string) (*ByteCode, error) {
 	bc := newByteCode()
 	str, err := LoadText(def)
@@ -63,8 +110,9 @@ func (c *Compiler) Compile(n int, def string) (*ByteCode, error) {
 			sys.chars[n][0].cmd[i] = *NewCommandList(b)
 		}
 	}
-	cl, remap, defaults := &sys.chars[n][0].cmd[n], true, true
-	ckr := NewCommandKeyRemap()
+	c.cmdl = &sys.chars[n][0].cmd[n]
+	remap, defaults, ckr := true, true, NewCommandKeyRemap()
+	var cmds []IniSection
 	for i < len(lines) {
 		is, name, _ := ReadIniSection(lines, &i)
 		switch name {
@@ -100,9 +148,45 @@ func (c *Compiler) Compile(n int, def string) (*ByteCode, error) {
 		case "defaults":
 			if defaults {
 				defaults = false
+				is.ReadI32("command.time", &c.cmdl.DefaultTime)
+				var i32 int32
+				if is.ReadI32("command.buffer.time", &i32) {
+					c.cmdl.DefaultBufferTime = Max(1, i32)
+				}
+			}
+		default:
+			if len(name) >= 7 && name[:7] == "command" {
+				cmds = append(cmds, is)
 			}
 		}
 	}
-	unimplemented()
+	for _, is := range cmds {
+		cm, err := ReadCommand(is["name"], is["command"], ckr)
+		if err != nil {
+			return nil, Error(cmd + ":\nname = " + is["name"] +
+				"\ncommand = " + is["command"] + "\n" + err.Error())
+		}
+		is.ReadI32("time", &cm.time)
+		var i32 int32
+		if is.ReadI32("buffer.time", &i32) {
+			cm.buftime = Max(1, i32)
+		}
+		c.cmdl.Add(*cm)
+	}
+	for _, s := range st {
+		if len(s) > 0 {
+			if err := c.stateCompile(bc, s, def); err != nil {
+				return nil, err
+			}
+		}
+	}
+	if err := c.stateCompile(bc, cmd, def); err != nil {
+		return nil, err
+	}
+	if len(stcommon) > 0 {
+		if err := c.stateCompile(bc, stcommon, def); err != nil {
+			return nil, err
+		}
+	}
 	return bc, nil
 }

--- a/src/input.go
+++ b/src/input.go
@@ -548,7 +548,7 @@ type Command struct {
 }
 
 func newCommand() *Command { return &Command{tamei: -1, time: 1, buftime: 1} }
-func ReadCommand(name, cmdstr string) (*Command, error) {
+func ReadCommand(name, cmdstr string, kr *CommandKeyRemap) (*Command, error) {
 	c := newCommand()
 	c.name = name
 	cmd := strings.Split(cmdstr, ",")
@@ -664,51 +664,51 @@ func ReadCommand(name, cmdstr string) (*Command, error) {
 				tilde = false
 			case 'a':
 				if tilde {
-					ce.key = append(ce.key, CK_na)
+					ce.key = append(ce.key, kr.na)
 				} else {
-					ce.key = append(ce.key, CK_a)
+					ce.key = append(ce.key, kr.a)
 				}
 				tilde = false
 			case 'b':
 				if tilde {
-					ce.key = append(ce.key, CK_nb)
+					ce.key = append(ce.key, kr.nb)
 				} else {
-					ce.key = append(ce.key, CK_b)
+					ce.key = append(ce.key, kr.b)
 				}
 				tilde = false
 			case 'c':
 				if tilde {
-					ce.key = append(ce.key, CK_nc)
+					ce.key = append(ce.key, kr.nc)
 				} else {
-					ce.key = append(ce.key, CK_c)
+					ce.key = append(ce.key, kr.c)
 				}
 				tilde = false
 			case 'x':
 				if tilde {
-					ce.key = append(ce.key, CK_nx)
+					ce.key = append(ce.key, kr.x)
 				} else {
-					ce.key = append(ce.key, CK_x)
+					ce.key = append(ce.key, kr.x)
 				}
 				tilde = false
 			case 'y':
 				if tilde {
-					ce.key = append(ce.key, CK_ny)
+					ce.key = append(ce.key, kr.ny)
 				} else {
-					ce.key = append(ce.key, CK_y)
+					ce.key = append(ce.key, kr.y)
 				}
 				tilde = false
 			case 'z':
 				if tilde {
-					ce.key = append(ce.key, CK_nz)
+					ce.key = append(ce.key, kr.nz)
 				} else {
-					ce.key = append(ce.key, CK_z)
+					ce.key = append(ce.key, kr.z)
 				}
 				tilde = false
 			case 's':
 				if tilde {
-					ce.key = append(ce.key, CK_ns)
+					ce.key = append(ce.key, kr.ns)
 				} else {
-					ce.key = append(ce.key, CK_s)
+					ce.key = append(ce.key, kr.s)
 				}
 				tilde = false
 			case '$':

--- a/src/script.go
+++ b/src/script.go
@@ -81,7 +81,7 @@ func scriptCommonInit(l *lua.LState) {
 		if !ok {
 			userDataError(l, 1, cl)
 		}
-		c, err := ReadCommand(strArg(l, 2), strArg(l, 3))
+		c, err := ReadCommand(strArg(l, 2), strArg(l, 3), NewCommandKeyRemap())
 		if err != nil {
 			l.RaiseError(err.Error())
 		}

--- a/src/system.go
+++ b/src/system.go
@@ -91,6 +91,7 @@ type System struct {
 	numTurns                    [2]int
 	esc                         bool
 	loadMutex                   sync.Mutex
+	ignoreMostErrors            bool
 }
 
 func (s *System) init(w, h int32) *lua.LState {