Commit: e6dd36fdd0f712b5d1e3bfe0e611275af82034d5 - ikemen_go (git)

Go で書き直した Ikemen

Commit MetaInfo

• Revisión: e6dd36fdd0f712b5d1e3bfe0e611275af82034d5 (tree)
• Tiempo: 2016-11-30 00:40:54
• Autor: SUEHIRO <supersuehiro@user...>
• Commiter: SUEHIRO

Log Message

グローバル変数をsysに移した

Cambiar Resumen

• modified: run.sh
• add: script/select.lua
• modified: src/anim.go
• modified: src/common.go
• modified: src/font.go
• delete: src/gen/gen.go
• delete: src/generated.go
• modified: src/image.go
• modified: src/input.go
• modified: src/lifebar.go
• modified: src/main.go
• modified: src/render.go
• modified: src/script.go
• modified: src/sound.go
• add: src/system.go

Diferencia incremental

--- a/run.sh
+++ b/run.sh
@@ -3,4 +3,4 @@ GOPATH=$PWD/go
 export GOPATH
 go fmt ./src/*.go
 # godoc -src ./src .* > godoc.txt
-go generate ./src/main.go && go run ./src/*.go
+go run ./src/*.go

--- /dev/null
+++ b/script/select.lua
@@ -0,0 +1,8 @@
+addChar([[
+randomselect
+kfmx
+]])
+
+addStage([[
+SpaceRainbowLowRes.def
+]])

--- a/src/anim.go
+++ b/src/anim.go
@@ -166,7 +166,7 @@ func ReadAnimation(sff *Sff, lines []string, i *int) *Animation {
 				af.Ex[0] = clsn1
 				af.Ex[1] = clsn2
 			}
-			a.frames = AppendAF(a.frames, *af)
+			a.frames = append(a.frames, *af)
 			def1, def2 = true, true
 		case len(line) >= 9 && line[:9] == "loopstart":
 			a.loopstart = int32(len(a.frames))
@@ -399,7 +399,7 @@ func (a *Animation) alpha() int32 {
 	if sa == 1 && da == 255 {
 		return -2
 	}
-	sa = byte(int32(sa) * brightness >> 8)
+	sa = byte(int32(sa) * sys.brightness >> 8)
 	if sa < 5 && da == 255 {
 		return 0
 	}
@@ -483,15 +483,15 @@ func (a *Animation) Draw(window *[4]int32, x, y, xcs, ycs, xs, xbs, ys,
 				y -= float32(int(y/tmp)) * tmp
 			}
 		}
-		rcx, rcy = rcx*widthScale, 0
+		rcx, rcy = rcx*sys.widthScale, 0
 		x, y = -x+xs*float32(a.spr.Offset[0]), -y+ys*float32(a.spr.Offset[1])
 	} else {
-		rcx, rcy = (x+rcx)*widthScale, y*heightScale
+		rcx, rcy = (x+rcx)*sys.widthScale, y*sys.heightScale
 		x, y = AbsF(xs)*float32(a.spr.Offset[0]), AbsF(ys)*float32(a.spr.Offset[1])
 	}
-	a.spr.glDraw(a.pal(pfx), int32(a.mask), x*widthScale, y*heightScale,
-		&a.tile, xs*widthScale, xcs*xbs*h*widthScale, ys*heightScale,
-		xcs*rxadd*widthScale/heightScale, angle, a.alpha(), window,
+	a.spr.glDraw(a.pal(pfx), int32(a.mask), x*sys.widthScale, y*sys.heightScale,
+		&a.tile, xs*sys.widthScale, xcs*xbs*h*sys.widthScale, ys*sys.heightScale,
+		xcs*rxadd*sys.widthScale/sys.heightScale, angle, a.alpha(), window,
 		rcx, rcy, pfx)
 }
 
@@ -547,7 +547,7 @@ type Anim struct {
 func NewAnim(sff *Sff, action string) *Anim {
 	lines, i := SplitAndTrim(action, "\n"), 0
 	a := &Anim{anim: ReadAnimation(sff, lines, &i),
-		window: scrrect, xscl: 1, yscl: 1}
+		window: sys.scrrect, xscl: 1, yscl: 1}
 	if len(a.anim.frames) == 0 {
 		return nil
 	}
@@ -573,18 +573,18 @@ func (a *Anim) SetScale(x, y float32) {
 	a.xscl, a.yscl = x, y
 }
 func (a *Anim) SetWindow(x, y, w, h float32) {
-	a.window[0] = int32((x + float32(gameWidth-320)/2) * widthScale)
-	a.window[1] = int32((y + float32(gameHeight-240)) * heightScale)
-	a.window[2] = int32(w*widthScale + 0.5)
-	a.window[3] = int32(h*heightScale + 0.5)
+	a.window[0] = int32((x + float32(sys.gameWidth-320)/2) * sys.widthScale)
+	a.window[1] = int32((y + float32(sys.gameHeight-240)) * sys.heightScale)
+	a.window[2] = int32(w*sys.widthScale + 0.5)
+	a.window[3] = int32(h*sys.heightScale + 0.5)
 }
 func (a *Anim) Update() {
 	a.anim.Action()
 }
 func (a *Anim) Draw() {
-	if !frameSkip {
-		a.anim.Draw(&a.window, a.x+float32(gameWidth-320)/2,
-			a.y+float32(gameHeight-240), 1, 1, a.xscl, a.xscl, a.yscl,
+	if !sys.frameSkip {
+		a.anim.Draw(&a.window, a.x+float32(sys.gameWidth-320)/2,
+			a.y+float32(sys.gameHeight-240), 1, 1, a.xscl, a.xscl, a.yscl,
 			0, 0, 0, nil, false)
 	}
 }

--- a/src/common.go
+++ b/src/common.go
@@ -15,17 +15,15 @@ const (
 	IErr = ^IMax
 )
 
-var randseed int32
-
 func Random() int32 {
-	w := randseed / 127773
-	randseed = (randseed-w*127773)*16807 - w*2836
-	if randseed <= 0 {
-		randseed += IMax - Btoi(randseed == 0)
+	w := sys.randseed / 127773
+	sys.randseed = (sys.randseed-w*127773)*16807 - w*2836
+	if sys.randseed <= 0 {
+		sys.randseed += IMax - Btoi(sys.randseed == 0)
 	}
-	return randseed
+	return sys.randseed
 }
-func Srand(s int32)             { randseed = s }
+func Srand(s int32)             { sys.randseed = s }
 func Rand(min, max int32) int32 { return min + Random()/(IMax/(max-min+1)+1) }
 func RandI(x, y int32) int32 {
 	if y < x {
@@ -176,29 +174,28 @@ func LoadText(filename string) (string, error) {
 	}
 	return AsciiToString(bytes), nil
 }
-func LoadFile(file *string, deffile string, load func(string) error) error {
-	var fp string
-	isNotExist := func() bool {
-		if _, err := os.Stat(fp); !os.IsNotExist(err) {
-			return false
-		}
-		var pattern string
-		for _, r := range fp {
-			if r >= 'A' && r <= 'Z' || r >= 'a' && r <= 'z' {
-				pattern += "[" + string(unicode.ToLower(r)) +
-					string(unicode.ToLower(r)+'A'-'a') + "]"
-			} else if r == '*' || r == '?' || r == '[' {
-				pattern += "\\" + string(r)
-			} else {
-				pattern += string(r)
-			}
-		}
-		if m, _ := filepath.Glob(pattern); len(m) > 0 {
-			fp = m[0]
-			return false
+func FileExist(filename string) string {
+	if _, err := os.Stat(filename); !os.IsNotExist(err) {
+		return filename
+	}
+	var pattern string
+	for _, r := range filename {
+		if r >= 'A' && r <= 'Z' || r >= 'a' && r <= 'z' {
+			pattern += "[" + string(unicode.ToLower(r)) +
+				string(unicode.ToLower(r)+'A'-'a') + "]"
+		} else if r == '*' || r == '?' || r == '[' {
+			pattern += "\\" + string(r)
+		} else {
+			pattern += string(r)
 		}
-		return true
 	}
+	if m, _ := filepath.Glob(pattern); len(m) > 0 {
+		return m[0]
+	}
+	return ""
+}
+func LoadFile(file *string, deffile string, load func(string) error) error {
+	var fp string
 	*file = strings.Replace(*file, "\\", "/", -1)
 	defdir := filepath.Dir(strings.Replace(deffile, "\\", "/", -1))
 	if defdir == "." {
@@ -208,11 +205,11 @@ func LoadFile(file *string, deffile string, load func(string) error) error {
 	} else {
 		fp = defdir + "/" + *file
 	}
-	if isNotExist() {
+	if fp = FileExist(fp); len(fp) == 0 {
 		_else := false
 		if defdir != "data" {
 			fp = "data/" + *file
-			if isNotExist() {
+			if fp = FileExist(fp); len(fp) == 0 {
 				_else = true
 			}
 		} else {
@@ -221,7 +218,9 @@ func LoadFile(file *string, deffile string, load func(string) error) error {
 		if _else {
 			if defdir != "." {
 				fp = *file
-				isNotExist()
+				if fp = FileExist(fp); len(fp) == 0 {
+					fp = *file
+				}
 			}
 		}
 	}
@@ -373,32 +372,33 @@ func ReadLayout(pre string, is IniSection) *Layout {
 	is.ReadF32(pre+"scale", &l.scale[0], &l.scale[1])
 	return l
 }
-func (l *Layout) DrawAnim(r *[4]int32, x, y, scl float32, ln int16, a *Animation) {
+func (l *Layout) DrawAnim(r *[4]int32, x, y, scl float32, ln int16,
+	a *Animation) {
 	if l.layerno == ln {
 		if l.facing < 0 {
-			x += lifebarFontScale
+			x += sys.lifebarFontScale
 		}
 		if l.vfacing < 0 {
-			y += lifebarFontScale
+			y += sys.lifebarFontScale
 		}
-		a.Draw(r, x+l.offset[0], y+l.offset[1]+float32(gameHeight-240), scl, scl,
-			l.scale[0]*float32(l.facing), l.scale[0]*float32(l.facing),
+		a.Draw(r, x+l.offset[0], y+l.offset[1]+float32(sys.gameHeight-240),
+			scl, scl, l.scale[0]*float32(l.facing), l.scale[0]*float32(l.facing),
 			l.scale[1]*float32(l.vfacing),
-			0, 0, float32(gameWidth-320)/2, nil, false)
+			0, 0, float32(sys.gameWidth-320)/2, nil, false)
 	}
 }
 func (l *Layout) DrawText(x, y, scl float32, ln int16,
 	text string, f *Fnt, b, a int32) {
 	if l.layerno == ln {
 		if l.facing < 0 {
-			x += lifebarFontScale
+			x += sys.lifebarFontScale
 		}
 		if l.vfacing < 0 {
-			y += lifebarFontScale
+			y += sys.lifebarFontScale
 		}
 		f.DrawText(text, (x+l.offset[0])*scl, (y+l.offset[1])*scl,
-			l.scale[0]*lifebarFontScale*float32(l.facing)*scl,
-			l.scale[1]*lifebarFontScale*float32(l.vfacing)*scl, a, b)
+			l.scale[0]*sys.lifebarFontScale*float32(l.facing)*scl,
+			l.scale[1]*sys.lifebarFontScale*float32(l.vfacing)*scl, a, b)
 	}
 }
 
@@ -435,7 +435,7 @@ func (al *AnimLayout) Action() {
 	al.anim.Action()
 }
 func (al *AnimLayout) Draw(x, y float32, layerno int16) {
-	al.lay.DrawAnim(&scrrect, x, y, 1, layerno, &al.anim)
+	al.lay.DrawAnim(&sys.scrrect, x, y, 1, layerno, &al.anim)
 }
 
 type AnimTextSnd struct {

--- a/src/font.go
+++ b/src/font.go
@@ -238,15 +238,16 @@ func (f *Fnt) drawChar(x, y, xscl, yscl float32, bank int32, c rune,
 	if spr == nil {
 		return 0
 	}
-	spr.glDraw(pal, 0, -x*widthScale, -y*heightScale, &notiling,
-		xscl*widthScale, xscl*widthScale, yscl*heightScale, 0, 0,
-		brightness*255>>8|1<<9, &scrrect, 0, 0, nil)
+	spr.glDraw(pal, 0, -x*sys.widthScale, -y*sys.heightScale, &notiling,
+		xscl*sys.widthScale, xscl*sys.widthScale, yscl*sys.heightScale, 0, 0,
+		sys.brightness*255>>8|1<<9, &sys.scrrect, 0, 0, nil)
 	return float32(spr.Size[0]) * xscl
 }
 func (f *Fnt) DrawText(txt string, x, y, xscl, yscl float32, bank int32,
 	align int32) {
-	x += float32(f.offset[0])*xscl + float32(gameWidth-320)/2
-	y += float32(f.offset[1]-int32(f.Size[1])+1)*yscl + float32(gameHeight-240)
+	x += float32(f.offset[0])*xscl + float32(sys.gameWidth-320)/2
+	y += float32(f.offset[1]-int32(f.Size[1])+1)*yscl +
+		float32(sys.gameHeight-240)
 	if align == 0 {
 		x -= float32(f.TextWidth(txt)) * xscl * 0.5
 	} else if align < 0 {
@@ -256,8 +257,8 @@ func (f *Fnt) DrawText(txt string, x, y, xscl, yscl float32, bank int32,
 		bank = 0
 	}
 	pal := f.palettes[bank][:]
-	if allPalFX.Time != 0 {
-		pal = allPalFX.GetFxPal(pal, false)
+	if sys.allPalFX.Time != 0 {
+		pal = sys.allPalFX.GetFxPal(pal, false)
 	}
 	for _, c := range txt {
 		x += f.drawChar(x, y, xscl, yscl, bank, c, pal) +
@@ -276,7 +277,7 @@ func NewTextSprite() *TextSprite {
 	return &TextSprite{align: 1, xscl: 1, yscl: 1}
 }
 func (ts *TextSprite) Draw() {
-	if !frameSkip && ts.fnt != nil {
+	if !sys.frameSkip && ts.fnt != nil {
 		ts.fnt.DrawText(ts.text, ts.x, ts.y, ts.xscl, ts.yscl, ts.bank, ts.align)
 	}
 }

--- a/src/gen/gen.go
+++ /dev/null
@@ -1,42 +0,0 @@
-package main
-
-import "os"
-
-var AppendFunc = [...][2]string{
-	{"I", "int"},
-	{"U32", "uint32"},
-	{"Pal", "[]uint32"},
-	{"AF", "AnimFrame"},
-}
-
-func main() {
-	out, err := os.Create("generated.go")
-	if err != nil {
-		panic(err)
-	}
-	defer out.Close()
-	write := func(str string) {
-		_, err := out.WriteString(str)
-		if err != nil {
-			panic(err)
-		}
-	}
-	write("package main\n\n")
-	for i := range AppendFunc {
-		write("func Append")
-		write(AppendFunc[i][0])
-		write("(slice []")
-		write(AppendFunc[i][1])
-		write(", data ...")
-		write(AppendFunc[i][1])
-		write(") []")
-		write(AppendFunc[i][1])
-		write(" {\n\tm := len(slice)\n\tn := m + len(data)\n")
-		write("\tif n > cap(slice) {\n\t\tnewSlice := make([]")
-		write(AppendFunc[i][1])
-		write(", n+n/4)\n")
-		write("\t\tcopy(newSlice, slice)\n\t\tslice = newSlice\n\t}\n")
-		write("\tslice = slice[:n]\n\tcopy(slice[m:n], data)\n")
-		write("\treturn slice\n}\n")
-	}
-}

--- a/src/generated.go
+++ /dev/null
@@ -1,50 +0,0 @@
-package main
-
-func AppendI(slice []int, data ...int) []int {
-	m := len(slice)
-	n := m + len(data)
-	if n > cap(slice) {
-		newSlice := make([]int, n+n/4)
-		copy(newSlice, slice)
-		slice = newSlice
-	}
-	slice = slice[:n]
-	copy(slice[m:n], data)
-	return slice
-}
-func AppendU32(slice []uint32, data ...uint32) []uint32 {
-	m := len(slice)
-	n := m + len(data)
-	if n > cap(slice) {
-		newSlice := make([]uint32, n+n/4)
-		copy(newSlice, slice)
-		slice = newSlice
-	}
-	slice = slice[:n]
-	copy(slice[m:n], data)
-	return slice
-}
-func AppendPal(slice [][]uint32, data ...[]uint32) [][]uint32 {
-	m := len(slice)
-	n := m + len(data)
-	if n > cap(slice) {
-		newSlice := make([][]uint32, n+n/4)
-		copy(newSlice, slice)
-		slice = newSlice
-	}
-	slice = slice[:n]
-	copy(slice[m:n], data)
-	return slice
-}
-func AppendAF(slice []AnimFrame, data ...AnimFrame) []AnimFrame {
-	m := len(slice)
-	n := m + len(data)
-	if n > cap(slice) {
-		newSlice := make([]AnimFrame, n+n/4)
-		copy(newSlice, slice)
-		slice = newSlice
-	}
-	slice = slice[:n]
-	copy(slice[m:n], data)
-	return slice
-}

--- a/src/image.go
+++ b/src/image.go
@@ -13,8 +13,6 @@ import (
 	"unsafe"
 )
 
-var allPalFX = NewPalFX()
-
 type Texture uint32
 
 func textureFinalizer(t *Texture) {
@@ -65,17 +63,17 @@ func (pl *PaletteList) SetSource(i int, p []uint32) {
 		pl.paletteMap[i] = i
 	} else {
 		for i > len(pl.paletteMap) {
-			pl.paletteMap = AppendI(pl.paletteMap, len(pl.paletteMap))
+			pl.paletteMap = append(pl.paletteMap, len(pl.paletteMap))
 		}
-		pl.paletteMap = AppendI(pl.paletteMap, i)
+		pl.paletteMap = append(pl.paletteMap, i)
 	}
 	if i < len(pl.palettes) {
 		pl.palettes[i] = p
 	} else {
 		for i > len(pl.palettes) {
-			pl.palettes = AppendPal(pl.palettes, nil)
+			pl.palettes = append(pl.palettes, nil)
 		}
-		pl.palettes = AppendPal(pl.palettes, p)
+		pl.palettes = append(pl.palettes, p)
 	}
 }
 func (pl *PaletteList) NewPal() (i int, p []uint32) {
@@ -234,10 +232,10 @@ func LoadFromSff(filename string, g int16, n int16) (*Sprite, error) {
 	}
 	var dummy *Sprite
 	var newSubHeaderOffset []uint32
-	newSubHeaderOffset = AppendU32(newSubHeaderOffset, shofs)
+	newSubHeaderOffset = append(newSubHeaderOffset, shofs)
 	i := 0
 	for ; i < int(h.NumberOfSprites); i++ {
-		newSubHeaderOffset = AppendU32(newSubHeaderOffset, shofs)
+		newSubHeaderOffset = append(newSubHeaderOffset, shofs)
 		f.Seek(int64(shofs), 0)
 		if err := foo(); err != nil {
 			return nil, err
@@ -842,17 +840,17 @@ func (s *Sprite) glDraw(pal []uint32, mask int32, x, y float32, tile *[4]int32,
 	}
 }
 func (s *Sprite) Draw(x, y, xscale, yscale float32, pal []uint32) {
-	x += float32(gameWidth-320)/2 - xscale*float32(s.Offset[0])
-	y += float32(gameHeight-240) - yscale*float32(s.Offset[1])
+	x += float32(sys.gameWidth-320)/2 - xscale*float32(s.Offset[0])
+	y += float32(sys.gameHeight-240) - yscale*float32(s.Offset[1])
 	if xscale < 0 {
 		x *= -1
 	}
 	if yscale < 0 {
 		y *= -1
 	}
-	s.glDraw(pal, 0, -x*widthScale, -y*heightScale, &notiling,
-		xscale*widthScale, xscale*widthScale, yscale*heightScale, 0, 0,
-		brightness*255>>8|1<<9, &scrrect, 0, 0, nil)
+	s.glDraw(pal, 0, -x*sys.widthScale, -y*sys.heightScale, &notiling,
+		xscale*sys.widthScale, xscale*sys.widthScale, yscale*sys.heightScale, 0, 0,
+		sys.brightness*255>>8|1<<9, &sys.scrrect, 0, 0, nil)
 }
 
 type Sff struct {

--- a/src/input.go
+++ b/src/input.go
@@ -426,7 +426,7 @@ type AiInput struct {
 }
 
 func (__ *AiInput) Update() {
-	if introTime != 0 {
+	if sys.introTime != 0 {
 		__.dt, __.at, __.bt, __.ct = 0, 0, 0, 0
 		__.xt, __.yt, __.zt, __.st = 0, 0, 0, 0
 		return

--- a/src/lifebar.go
+++ b/src/lifebar.go
@@ -5,8 +5,6 @@ import (
 	"strings"
 )
 
-var lifebar Lifebar
-
 type WinType int32
 
 const (

--- a/src/main.go
+++ b/src/main.go
@@ -1,104 +1,20 @@
 package main
 
-//go:generate go run ./gen/gen.go
 import (
 	"github.com/Shopify/go-lua"
-	"github.com/go-gl/gl/v2.1/gl"
-	"github.com/go-gl/glfw/v3.2/glfw"
 	"runtime"
-	"time"
 )
 
-var scrrect = [4]int32{0, 0, 320, 240}
-var gameWidth, gameHeight int32 = 320, 240
-var widthScale, heightScale float32 = 1, 1
-var window *glfw.Window
-var gameEnd, frameSkip = false, false
-var redrawWait struct{ nextTime, lastDraw time.Time }
-var brightness int32 = 256
-var introTime, roundTime int32 = 0, -1
-var lifeMul, team1VS2Life float32 = 1, 1
-var turnsRecoveryRate float32 = 1.0 / 300
-var zoomEnable = false
-var zoomMin, zoomMax, zoomSpeed float32 = 1, 1, 1
-var lifebarFontScale float32 = 1
-var debugFont *Fnt
-var debugScript string
-
 func init() {
 	runtime.LockOSThread()
 }
-func setWindowSize(w, h int32) {
-	scrrect[2], scrrect[3] = w, h
-	if scrrect[2]*3 > scrrect[3]*4 {
-		gameWidth, gameHeight = scrrect[2]*3*320/(scrrect[3]*4), 240
-	} else {
-		gameWidth, gameHeight = 320, scrrect[3]*4*240/(scrrect[2]*3)
-	}
-	widthScale = float32(scrrect[2]) / float32(gameWidth)
-	heightScale = float32(scrrect[3]) / float32(gameHeight)
-}
 func chk(err error) {
 	if err != nil {
 		panic(err)
 	}
 }
-func await(fps int) {
-	playSound()
-	if !frameSkip {
-		window.SwapBuffers()
-	}
-	now := time.Now()
-	diff := redrawWait.nextTime.Sub(now)
-	wait := time.Second / time.Duration(fps)
-	redrawWait.nextTime = redrawWait.nextTime.Add(wait)
-	switch {
-	case diff >= 0 && diff < wait+2*time.Millisecond:
-		time.Sleep(diff)
-		fallthrough
-	case now.Sub(redrawWait.lastDraw) > 250*time.Millisecond:
-		fallthrough
-	case diff >= -17*time.Millisecond:
-		redrawWait.lastDraw = now
-		frameSkip = false
-	default:
-		if diff < -150*time.Millisecond {
-			redrawWait.nextTime = now.Add(wait)
-		}
-		frameSkip = true
-	}
-	glfw.PollEvents()
-	gameEnd = window.ShouldClose()
-	if !frameSkip {
-		gl.Viewport(0, 0, int32(scrrect[2]), int32(scrrect[3]))
-		gl.Clear(gl.COLOR_BUFFER_BIT)
-	}
-}
 func main() {
-	chk(glfw.Init())
-	defer glfw.Terminate()
-	glfw.WindowHint(glfw.Resizable, glfw.False)
-	glfw.WindowHint(glfw.ContextVersionMajor, 2)
-	glfw.WindowHint(glfw.ContextVersionMinor, 1)
-	setWindowSize(640, 480)
-	var err error
-	window, err = glfw.CreateWindow(int(scrrect[2]), int(scrrect[3]),
-		"Ikemen GO", nil, nil)
-	chk(err)
-	window.MakeContextCurrent()
-	window.SetKeyCallback(keyCallback)
-	glfw.SwapInterval(1)
-	chk(gl.Init())
-	randseed = int32(time.Now().UnixNano())
-	keyConfig = append(keyConfig, &KeyConfig{-1,
-		int(glfw.KeyUp), int(glfw.KeyDown), int(glfw.KeyLeft), int(glfw.KeyRight),
-		int(glfw.KeyZ), int(glfw.KeyX), int(glfw.KeyC),
-		int(glfw.KeyA), int(glfw.KeyS), int(glfw.KeyD), int(glfw.KeyEnter)})
-	RenderInit()
-	audioOpen()
-	l := lua.NewState()
-	lua.OpenLibraries(l)
-	systemScriptInit(l)
+	l := sys.init(640, 480)
 	if err := lua.DoFile(l, "script/main.lua"); err != nil {
 		switch err.(type) {
 		case lua.RuntimeError:

--- a/src/render.go
+++ b/src/render.go
@@ -145,7 +145,7 @@ func drawQuads(x1, y1, x2, y2, x3, y3, x4, y4, r, g, b, a, pers float32) {
 	gl.Vertex2f(x4, y4)
 	if pers != 1 {
 		n := int((1 - (pers * pers)) * AbsF(x1-x2) *
-			float32(scrrect[3]>>5) / (AbsF(y1-y4) + float32(scrrect[3]>>5)))
+			float32(sys.scrrect[3]>>5) / (AbsF(y1-y4) + float32(sys.scrrect[3]>>5)))
 		for i := 1; i < n; i++ {
 			gl.TexCoord2f(float32(i)/float32(n), 1)
 			gl.Vertex2f(x1+(x2-x1)*float32(i)/float32(n),
@@ -177,17 +177,18 @@ func rmTileHSub(x1, y1, x2, y2, x3, y3, x4, y4, xtw, xbw, xts, xbs float32,
 				x4d = x3d - xtw
 				x1d = x2d - xbw
 				if topdist < 0 {
-					if x1d >= float32(scrrect[2]) && x2d >= float32(scrrect[2]) &&
-						x3d >= float32(scrrect[2]) && x4d >= float32(scrrect[2]) {
+					if x1d >= float32(sys.scrrect[2]) &&
+						x2d >= float32(sys.scrrect[2]) && x3d >= float32(sys.scrrect[2]) &&
+						x4d >= float32(sys.scrrect[2]) {
 						break
 					}
 				} else if x1d <= 0 && x2d <= 0 && x3d <= 0 && x4d <= 0 {
 					break
 				}
 				if (0 < x1d || 0 < x2d) &&
-					(x1d < float32(scrrect[2]) || x2d < float32(scrrect[2])) ||
+					(x1d < float32(sys.scrrect[2]) || x2d < float32(sys.scrrect[2])) ||
 					(0 < x3d || 0 < x4d) &&
-						(x3d < float32(scrrect[2]) || x4d < float32(scrrect[2])) {
+						(x3d < float32(sys.scrrect[2]) || x4d < float32(sys.scrrect[2])) {
 					drawQuads(x1d, y1, x2d, y2, x3d, y3, x4d, y4, r, g, b, a, pers)
 				}
 			}
@@ -196,17 +197,17 @@ func rmTileHSub(x1, y1, x2, y2, x3, y3, x4, y4, xtw, xbw, xts, xbs float32,
 	n := (*tl)[2]
 	for {
 		if topdist > 0 {
-			if x1 >= float32(scrrect[2]) && x2 >= float32(scrrect[2]) &&
-				x3 >= float32(scrrect[2]) && x4 >= float32(scrrect[2]) {
+			if x1 >= float32(sys.scrrect[2]) && x2 >= float32(sys.scrrect[2]) &&
+				x3 >= float32(sys.scrrect[2]) && x4 >= float32(sys.scrrect[2]) {
 				break
 			}
 		} else if x1 <= 0 && x2 <= 0 && x3 <= 0 && x4 <= 0 {
 			break
 		}
 		if (0 < x1 || 0 < x2) &&
-			(x1 < float32(scrrect[2]) || x2 < float32(scrrect[2])) ||
+			(x1 < float32(sys.scrrect[2]) || x2 < float32(sys.scrrect[2])) ||
 			(0 < x3 || 0 < x4) &&
-				(x3 < float32(scrrect[2]) || x4 < float32(scrrect[2])) {
+				(x3 < float32(sys.scrrect[2]) || x4 < float32(sys.scrrect[2])) {
 			drawQuads(x1, y1, x2, y2, x3, y3, x4, y4, r, g, b, a, pers)
 		}
 		if (*tl)[2] != 1 && n != 0 {
@@ -254,14 +255,14 @@ func rmTileSub(w, h uint16, x, y float32, tl *[4]int32,
 			}
 			y4d = y3d
 			if ys*(float32(h)+float32((*tl)[1])) < 0 {
-				if y1d <= float32(-scrrect[3]) && y4d <= float32(-scrrect[3]) {
+				if y1d <= float32(-sys.scrrect[3]) && y4d <= float32(-sys.scrrect[3]) {
 					break
 				}
 			} else if y1d >= 0 && y4d >= 0 {
 				break
 			}
 			if (0 > y1d || 0 > y4d) &&
-				(y1d > float32(-scrrect[3]) || y4d > float32(-scrrect[3])) {
+				(y1d > float32(-sys.scrrect[3]) || y4d > float32(-sys.scrrect[3])) {
 				rmTileHSub(x1d, y1d, x2d, y2d, x3d, y3d, x4d, y4d, x3d-x4d, x2d-x1d,
 					(x3d-x4d)/float32(w), (x2d-x1d)/float32(w), tl,
 					rcx, r, g, b, a, pers)
@@ -272,14 +273,14 @@ func rmTileSub(w, h uint16, x, y float32, tl *[4]int32,
 		n := (*tl)[3]
 		for {
 			if ys*(float32(h)+float32((*tl)[1])) > 0 {
-				if y1 <= float32(-scrrect[3]) && y4 <= float32(-scrrect[3]) {
+				if y1 <= float32(-sys.scrrect[3]) && y4 <= float32(-sys.scrrect[3]) {
 					break
 				}
 			} else if y1 >= 0 && y4 >= 0 {
 				break
 			}
 			if (0 > y1 || 0 > y4) &&
-				(y1 > float32(-scrrect[3]) || y4 > float32(-scrrect[3])) {
+				(y1 > float32(-sys.scrrect[3]) || y4 > float32(-sys.scrrect[3])) {
 				rmTileHSub(x1, y1, x2, y2, x3, y3, x4, y4, x3-x4, x2-x1,
 					(x3-x4)/float32(w), (x2-x1)/float32(w), tl, rcx, r, g, b, a, pers)
 			}
@@ -306,10 +307,10 @@ func rmMainSub(a int32, size [2]uint16, x, y float32, tl *[4]int32,
 	gl.MatrixMode(gl.PROJECTION)
 	gl.PushMatrix()
 	gl.LoadIdentity()
-	gl.Ortho(0, float64(scrrect[2]), 0, float64(scrrect[3]), -1, 1)
+	gl.Ortho(0, float64(sys.scrrect[2]), 0, float64(sys.scrrect[3]), -1, 1)
 	gl.MatrixMode(gl.MODELVIEW)
 	gl.PushMatrix()
-	gl.Translated(0, float64(scrrect[3]), 0)
+	gl.Translated(0, float64(sys.scrrect[3]), 0)
 	switch {
 	case trans == -1:
 		gl.Uniform1fARB(a, 1)
@@ -382,7 +383,7 @@ func rmInitSub(size [2]uint16, x, y *float32, tile *[4]int32, xts float32,
 	gl.Enable(gl.BLEND)
 	gl.Enable(gl.TEXTURE_2D)
 	gl.Enable(gl.SCISSOR_TEST)
-	gl.Scissor((*window)[0], scrrect[3]-((*window)[1]+(*window)[3]),
+	gl.Scissor((*window)[0], sys.scrrect[3]-((*window)[1]+(*window)[3]),
 		(*window)[2], (*window)[3])
 	return
 }

--- a/src/script.go
+++ b/src/script.go
@@ -66,11 +66,11 @@ func scriptCommonInit(l *lua.State) {
 		return 0
 	})
 	luaRegister(l, "playBGM", func(l *lua.State) int {
-		bgm.Open(strArg(l, 1))
+		sys.bgm.Open(strArg(l, 1))
 		return 0
 	})
 	luaRegister(l, "setRoundTime", func(l *lua.State) int {
-		roundTime = int32(numArg(l, 1))
+		sys.roundTime = int32(numArg(l, 1))
 		return 0
 	})
 }
@@ -229,9 +229,17 @@ func systemScriptInit(l *lua.State) {
 		a.Draw()
 		return 0
 	})
+	luaRegister(l, "addChar", func(l *lua.State) int {
+		sys.sel.AddCahr(strArg(l, 1))
+		return 0
+	})
+	luaRegister(l, "addStage", func(l *lua.State) int {
+		lua.Errorf(l, strArg(l, 1))
+		return 0
+	})
 	luaRegister(l, "refresh", func(*lua.State) int {
-		await(60)
-		if gameEnd {
+		sys.await(60)
+		if sys.gameEnd {
 			lua.Errorf(l, "<game end>")
 		}
 		return 0
@@ -241,7 +249,7 @@ func systemScriptInit(l *lua.State) {
 		if err != nil {
 			lua.Errorf(l, err.Error())
 		}
-		lifebar = *lb
+		sys.lifebar = *lb
 		return 0
 	})
 	luaRegister(l, "loadDebugFont", func(l *lua.State) int {
@@ -249,39 +257,39 @@ func systemScriptInit(l *lua.State) {
 		if err != nil {
 			lua.Errorf(l, err.Error())
 		}
-		debugFont = f
+		sys.debugFont = f
 		return 0
 	})
 	luaRegister(l, "setDebugScript", func(l *lua.State) int {
-		debugScript = strArg(l, 1)
+		sys.debugScript = strArg(l, 1)
 		return 0
 	})
 	luaRegister(l, "setLifeMul", func(l *lua.State) int {
-		lifeMul = float32(numArg(l, 1))
+		sys.lifeMul = float32(numArg(l, 1))
 		return 0
 	})
 	luaRegister(l, "setTeam1VS2Life", func(l *lua.State) int {
-		team1VS2Life = float32(numArg(l, 1))
+		sys.team1VS2Life = float32(numArg(l, 1))
 		return 0
 	})
 	luaRegister(l, "setTurnsRecoveryRate", func(l *lua.State) int {
-		turnsRecoveryRate = float32(numArg(l, 1))
+		sys.turnsRecoveryRate = float32(numArg(l, 1))
 		return 0
 	})
 	luaRegister(l, "setZoom", func(l *lua.State) int {
-		zoomEnable = boolArg(l, 1)
+		sys.zoomEnable = boolArg(l, 1)
 		return 0
 	})
 	luaRegister(l, "setZoomMin", func(l *lua.State) int {
-		zoomMin = float32(numArg(l, 1))
+		sys.zoomMin = float32(numArg(l, 1))
 		return 0
 	})
 	luaRegister(l, "setZoomMax", func(l *lua.State) int {
-		zoomMax = float32(numArg(l, 1))
+		sys.zoomMax = float32(numArg(l, 1))
 		return 0
 	})
 	luaRegister(l, "setZoomSpeed", func(l *lua.State) int {
-		zoomSpeed = float32(numArg(l, 1))
+		sys.zoomSpeed = float32(numArg(l, 1))
 		return 0
 	})
 }

--- a/src/sound.go
+++ b/src/sound.go
@@ -16,29 +16,23 @@ const (
 	audioFrequency = 48000
 )
 
-var mixer = newMixer()
-var bgm = newVorbis()
-var audioContext *openal.Context
-var nullSndBuf [audioOutLen * 2]int16
-var sounds = newSounds()
-
-func audioOpen() {
-	if audioContext == nil {
+func (s *System) audioOpen() {
+	if s.audioContext == nil {
 		device := openal.OpenDevice("")
 		if device == nil {
 			chk(openal.Err())
 		}
-		audioContext = device.CreateContext()
+		s.audioContext = device.CreateContext()
 		chk(device.Err())
-		audioContext.Activate()
-		go soundWrite()
+		s.audioContext.Activate()
+		go s.soundWrite()
 	}
 }
-func soundWrite() {
+func (s *System) soundWrite() {
 	src := NewAudioSource()
 	bgmSrc := NewAudioSource()
 	processed := false
-	for !gameEnd {
+	for !s.gameEnd {
 		if src.Src.State() != openal.Playing {
 			src.Src.Play()
 		}
@@ -52,9 +46,9 @@ func soundWrite() {
 		if src.Src.BuffersProcessed() > 0 {
 			var out []int16
 			select {
-			case out = <-mixer.out:
+			case out = <-s.mixer.out:
 			default:
-				out = nullSndBuf[:]
+				out = s.nullSndBuf[:]
 			}
 			buf := src.Src.UnqueueBuffer()
 			buf.SetDataInt16(openal.FormatStereo16, out, audioFrequency)
@@ -63,7 +57,7 @@ func soundWrite() {
 			processed = true
 		}
 		if bgmSrc.Src.BuffersProcessed() > 0 {
-			out := bgm.read()
+			out := s.bgm.read()
 			buf := bgmSrc.Src.UnqueueBuffer()
 			buf.SetDataInt16(openal.FormatStereo16, out, audioFrequency)
 			out = nil
@@ -75,34 +69,14 @@ func soundWrite() {
 	bgmSrc.Delete()
 	src.Delete()
 	openal.NullContext.Activate()
-	device := audioContext.GetDevice()
-	audioContext.Destroy()
-	audioContext = nil
+	device := s.audioContext.GetDevice()
+	s.audioContext.Destroy()
+	s.audioContext = nil
 	device.CloseDevice()
 }
-func newSounds() (s []*Sound) {
-	s = make([]*Sound, 16)
-	for i := range s {
-		s[i] = &Sound{volume: 256, freqmul: 1}
-	}
-	return
-}
-func GetChannel() *Sound {
-	for i := range sounds {
-		if sounds[i].sound == nil {
-			return sounds[i]
-		}
-	}
-	return nil
-}
-func mixSounds() {
-	for i := range sounds {
-		sounds[i].Mix()
-	}
-}
-func playSound() {
-	if mixer.write() {
-		mixSounds()
+func (s *System) playSound() {
+	if s.mixer.write() {
+		s.sounds.mixSounds()
 	}
 }
 
@@ -114,7 +88,7 @@ type AudioSource struct {
 func NewAudioSource() (s *AudioSource) {
 	s = &AudioSource{Src: openal.NewSource(), bufs: openal.NewBuffers(2)}
 	for i := range s.bufs {
-		s.bufs[i].SetDataInt16(openal.FormatStereo16, nullSndBuf[:],
+		s.bufs[i].SetDataInt16(openal.FormatStereo16, sys.nullSndBuf[:],
 			audioFrequency)
 	}
 	s.Src.QueueBuffers(s.bufs)
@@ -387,7 +361,7 @@ func (v *Vorbis) read() []int16 {
 			v.buf = append(v.buf, v.samToAudioOut(sam)...)
 		}
 	}
-	return nullSndBuf[:]
+	return sys.nullSndBuf[:]
 }
 
 type Wave struct {
@@ -554,7 +528,7 @@ func (s *Snd) Get(group int32, number int32) *Wave {
 	return s.table[[2]int32{group, number}]
 }
 func (s *Snd) Play(g int32, n int32) bool {
-	c := GetChannel()
+	c := sys.sounds.GetChannel()
 	if c == nil {
 		return false
 	}
@@ -575,7 +549,7 @@ func (s *Sound) Mix() {
 	if s.sound == nil {
 		return
 	}
-	s.fidx = mixer.Mix(s.sound.Wav, s.fidx,
+	s.fidx = sys.mixer.Mix(s.sound.Wav, s.fidx,
 		int(s.sound.BytesPerSample), int(s.sound.Channels),
 		float64(s.sound.SamplesPerSec)*float64(s.freqmul), s.loop,
 		float32(s.volume)/256)
@@ -585,3 +559,26 @@ func (s *Sound) Mix() {
 		s.fidx = 0
 	}
 }
+
+type Sounds []*Sound
+
+func newSounds() (s Sounds) {
+	s = Sounds(make([]*Sound, 16))
+	for i := range s {
+		s[i] = &Sound{volume: 256, freqmul: 1}
+	}
+	return
+}
+func (s Sounds) GetChannel() *Sound {
+	for i := range s {
+		if s[i].sound == nil {
+			return s[i]
+		}
+	}
+	return nil
+}
+func (s Sounds) mixSounds() {
+	for i := range s {
+		s[i].Mix()
+	}
+}

--- /dev/null
+++ b/src/system.go
@@ -0,0 +1,188 @@
+package main
+
+import (
+	"github.com/Shopify/go-lua"
+	"github.com/go-gl/gl/v2.1/gl"
+	"github.com/go-gl/glfw/v3.2/glfw"
+	"github.com/timshannon/go-openal/openal"
+	"strings"
+	"time"
+)
+
+var sys = System{
+	randseed:  int32(time.Now().UnixNano()),
+	scrrect:   [4]int32{0, 0, 320, 240},
+	gameWidth: 320, gameHeight: 240,
+	widthScale: 1, heightScale: 1,
+	brightness: 256,
+	introTime:  0, roundTime: -1,
+	lifeMul: 1, team1VS2Life: 1,
+	turnsRecoveryRate: 1.0 / 300,
+	zoomMin:           1, zoomMax: 1, zoomSpeed: 1,
+	lifebarFontScale: 1,
+	mixer:            *newMixer(),
+	bgm:              *newVorbis(),
+	sounds:           newSounds(),
+	allPalFX:         *NewPalFX()}
+
+type System struct {
+	randseed                    int32
+	scrrect                     [4]int32
+	gameWidth, gameHeight       int32
+	widthScale, heightScale     float32
+	window                      *glfw.Window
+	gameEnd, frameSkip          bool
+	redrawWait                  struct{ nextTime, lastDraw time.Time }
+	brightness                  int32
+	introTime, roundTime        int32
+	lifeMul, team1VS2Life       float32
+	turnsRecoveryRate           float32
+	zoomEnable                  bool
+	zoomMin, zoomMax, zoomSpeed float32
+	lifebarFontScale            float32
+	debugFont                   *Fnt
+	debugScript                 string
+	mixer                       Mixer
+	bgm                         Vorbis
+	audioContext                *openal.Context
+	nullSndBuf                  [audioOutLen * 2]int16
+	sounds                      Sounds
+	allPalFX                    PalFX
+	lifebar                     Lifebar
+	sel                         Select
+}
+
+func (s *System) init(w, h int32) *lua.State {
+	chk(glfw.Init())
+	defer glfw.Terminate()
+	glfw.WindowHint(glfw.Resizable, glfw.False)
+	glfw.WindowHint(glfw.ContextVersionMajor, 2)
+	glfw.WindowHint(glfw.ContextVersionMinor, 1)
+	s.setWindowSize(w, h)
+	var err error
+	s.window, err = glfw.CreateWindow(int(s.scrrect[2]), int(s.scrrect[3]),
+		"Ikemen GO", nil, nil)
+	chk(err)
+	s.window.MakeContextCurrent()
+	s.window.SetKeyCallback(keyCallback)
+	glfw.SwapInterval(1)
+	chk(gl.Init())
+	keyConfig = append(keyConfig, &KeyConfig{-1,
+		int(glfw.KeyUp), int(glfw.KeyDown), int(glfw.KeyLeft), int(glfw.KeyRight),
+		int(glfw.KeyZ), int(glfw.KeyX), int(glfw.KeyC),
+		int(glfw.KeyA), int(glfw.KeyS), int(glfw.KeyD), int(glfw.KeyEnter)})
+	RenderInit()
+	s.audioOpen()
+	l := lua.NewState()
+	lua.OpenLibraries(l)
+	systemScriptInit(l)
+	return l
+}
+func (s *System) setWindowSize(w, h int32) {
+	s.scrrect[2], s.scrrect[3] = w, h
+	if s.scrrect[2]*3 > s.scrrect[3]*4 {
+		s.gameWidth, s.gameHeight = s.scrrect[2]*3*320/(s.scrrect[3]*4), 240
+	} else {
+		s.gameWidth, s.gameHeight = 320, s.scrrect[3]*4*240/(s.scrrect[2]*3)
+	}
+	s.widthScale = float32(s.scrrect[2]) / float32(s.gameWidth)
+	s.heightScale = float32(s.scrrect[3]) / float32(s.gameHeight)
+}
+func (s *System) await(fps int) {
+	s.playSound()
+	if !s.frameSkip {
+		s.window.SwapBuffers()
+	}
+	now := time.Now()
+	diff := s.redrawWait.nextTime.Sub(now)
+	wait := time.Second / time.Duration(fps)
+	s.redrawWait.nextTime = s.redrawWait.nextTime.Add(wait)
+	switch {
+	case diff >= 0 && diff < wait+2*time.Millisecond:
+		time.Sleep(diff)
+		fallthrough
+	case now.Sub(s.redrawWait.lastDraw) > 250*time.Millisecond:
+		fallthrough
+	case diff >= -17*time.Millisecond:
+		s.redrawWait.lastDraw = now
+		s.frameSkip = false
+	default:
+		if diff < -150*time.Millisecond {
+			s.redrawWait.nextTime = now.Add(wait)
+		}
+		s.frameSkip = true
+	}
+	glfw.PollEvents()
+	s.gameEnd = s.window.ShouldClose()
+	if !s.frameSkip {
+		gl.Viewport(0, 0, int32(s.scrrect[2]), int32(s.scrrect[3]))
+		gl.Clear(gl.COLOR_BUFFER_BIT)
+	}
+}
+
+type SelectChar struct {
+	def, name            string
+	sportrait, lportrait *Sprite
+}
+type Select struct{ charlist []SelectChar }
+
+func (s *Select) AddCahr(def string) {
+	s.charlist = append(s.charlist, SelectChar{})
+	sc := &s.charlist[len(s.charlist)-1]
+	def = strings.Replace(strings.TrimSpace(strings.Split(",", def)[0]),
+		"\\", "/", -1)
+	if strings.ToLower(def) == "randomselect" {
+		sc.def, sc.name = "randomselect", "Random"
+		return
+	}
+	idx := strings.Index(def, "/")
+	if len(def) >= 4 && strings.ToLower(def[len(def)-4:]) == ".def" {
+		if idx < 0 {
+			return
+		}
+	} else if idx < 0 {
+		def += "/" + def + ".def"
+	} else {
+		def += ".def"
+	}
+	if def[0] != '/' || idx > 0 && strings.Index(def[:idx], ":") < 0 {
+		def = "chars/" + def
+	}
+	if def = FileExist(def); len(def) == 0 {
+		return
+	}
+	str, err := LoadText(def)
+	if err != nil {
+		return
+	}
+	lines, i, info, files := SplitAndTrim(str, "\n"), 0, true, true
+	sprite := ""
+	for i < len(lines) {
+		is, name, _ := ReadIniSection(lines, &i)
+		switch name {
+		case "info":
+			if info {
+				info = false
+				sc.name = is["displayname"]
+				if len(sc.name) == 0 {
+					sc.name = is["name"]
+				}
+			}
+		case "files":
+			if files {
+				files = false
+				sprite = is["sprite"]
+			}
+		}
+	}
+	LoadFile(&sprite, def, func(file string) error {
+		var err error
+		sc.sportrait, err = LoadFromSff(file, 9000, 0)
+		return err
+	})
+	LoadFile(&sprite, def, func(file string) error {
+		var err error
+		sc.lportrait, err = LoadFromSff(file, 9000, 1)
+		return err
+	})
+}