コミット: 8644bb1382647546d344a7cfeccf9dddec24b614 - ikemen_go (git)

Go で書き直した Ikemen

コミットメタ情報

• リビジョン: 8644bb1382647546d344a7cfeccf9dddec24b614 (tree)
• 日時: 2019-02-20 17:55:52
• 作者: neatunsou <sisiy4excite@gmai...>
• コミッター: neatunsou

ログメッセージ

Windblade氏の更新を適応

変更サマリ

• modified: LICENSE.txt
• modified: get.sh
• modified: src/char.go
• modified: src/common.go
• modified: src/font.go
• modified: src/script.go
• modified: src/system.go

差分

--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -1,7 +1,10 @@
-MIT License
+?ｿMIT License
 
 Original work Copyright (c) 2016 Suehiro
 Modified work Copyright (c) 2018 K4thos
+Modified work Copyright (c) 2018 ShinLucho
+Modified work Copyright (c) 2018 NeatUnsou
+Modified work Copyright (c) 2019 Windblade
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -22,20 +25,27 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 
 
-以下に定める条件に従い、本ソフトウェアおよび関連文書のファイル（以下「ソフトウェア」）
-の複製を取得するすべての人に対し、ソフトウェアを無制限に扱うことを無償で許可します。
-これには、ソフトウェアの複製を使用、複写、変更、結合、掲載、頒布、サブライセンス、および
-または販売する権利、およびソフトウェアを提供する相手に同じことを許可する権利も無制限に含まれます。
+窶ｻNote
+Data files below, font Following files contain content created by a third party,
+It is not covered by this license.
 
-上記の著作権表示および本許諾表示を、ソフトウェアのすべての複製または重要な部分に記載するものとします。
 
-ソフトウェアは「現状のまま」で、明示であるか暗黙であるかを問わず、何らの保証もなく提供されます。
-ここでいう保証とは、商品性、特定の目的への適合性、および権利非侵害についての保証も含みますが、
-それに限定されるものではありません。 作者または著作権者は、契約行為、不法行為、またはそれ以外であろうと、
-ソフトウェアに起因または関連し、あるいはソフトウェアの使用またはその他の扱いによって生じる一切の請求、損害、
-その他の義務について何らの責任も負わないものとします。
 
 
-※注意
-data以下のファイル, font以下のファイルには第三者が作成したコンテンツを含んでいるため、
-このライセンスの対象外となります。
+莉･荳九↓螳壹ａ繧区擅莉ｶ縺ｫ蠕薙＞縲∵悽繧ｽ繝輔ヨ繧ｦ繧ｧ繧｢縺翫ｈ縺ｳ髢｢騾｣譁?嶌縺ｮ繝輔ぃ繧､繝ｫ?井ｻ･荳九?後た繝輔ヨ繧ｦ繧ｧ繧｢縲搾ｼ
+縺ｮ隍?｣ｽ繧貞叙蠕励☆繧九☆縺ｹ縺ｦ縺ｮ莠ｺ縺ｫ蟇ｾ縺励?√た繝輔ヨ繧ｦ繧ｧ繧｢繧堤┌蛻ｶ髯舌↓謇ｱ縺?％縺ｨ繧堤┌蜆溘〒險ｱ蜿ｯ縺励∪縺吶?
+縺薙ｌ縺ｫ縺ｯ縲√た繝輔ヨ繧ｦ繧ｧ繧｢縺ｮ隍?｣ｽ繧剃ｽｿ逕ｨ縲∬､??縲∝､画峩縲∫ｵ仙粋縲∵軸霈峨???貞ｸ??√し繝悶Λ繧､繧ｻ繝ｳ繧ｹ縲√♀繧医?
+縺ｾ縺溘?雋ｩ螢ｲ縺吶ｋ讓ｩ蛻ｩ縲√♀繧医?繧ｽ繝輔ヨ繧ｦ繧ｧ繧｢繧呈署萓帙☆繧狗嶌謇九↓蜷後§縺薙→繧定ｨｱ蜿ｯ縺吶ｋ讓ｩ蛻ｩ繧ら┌蛻ｶ髯舌↓蜷ｫ縺ｾ繧後∪縺吶?
+
+荳願ｨ倥?闡嶺ｽ懈ｨｩ陦ｨ遉ｺ縺翫ｈ縺ｳ譛ｬ險ｱ隲ｾ陦ｨ遉ｺ繧偵?√た繝輔ヨ繧ｦ繧ｧ繧｢縺ｮ縺吶∋縺ｦ縺ｮ隍?｣ｽ縺ｾ縺溘?驥崎ｦ√↑驛ｨ蛻?↓險倩ｼ峨☆繧九ｂ縺ｮ縺ｨ縺励∪縺吶?
+
+繧ｽ繝輔ヨ繧ｦ繧ｧ繧｢縺ｯ縲檎樟迥ｶ縺ｮ縺ｾ縺ｾ縲阪〒縲∵?遉ｺ縺ｧ縺ゅｋ縺区囓鮟吶〒縺ゅｋ縺九ｒ蝠上ｏ縺壹?∽ｽ輔ｉ縺ｮ菫晁ｨｼ繧ゅ↑縺乗署萓帙＆繧後∪縺吶?
+縺薙％縺ｧ縺?≧菫晁ｨｼ縺ｨ縺ｯ縲∝膚蜩∵?ｧ縲∫音螳壹?逶ｮ逧?∈縺ｮ驕ｩ蜷域?ｧ縲√♀繧医?讓ｩ蛻ｩ髱樔ｾｵ螳ｳ縺ｫ縺､縺?※縺ｮ菫晁ｨｼ繧ょ性縺ｿ縺ｾ縺吶′縲
+縺昴ｌ縺ｫ髯仙ｮ壹＆繧後ｋ繧ゅ?縺ｧ縺ｯ縺ゅｊ縺ｾ縺帙ｓ縲 菴懆??∪縺溘?闡嶺ｽ懈ｨｩ閠??縲∝･醍ｴ?｡檎ぜ縲∽ｸ肴ｳ戊｡檎ぜ縲√∪縺溘?縺昴ｌ莉･螟悶〒縺ゅｍ縺?→縲
+繧ｽ繝輔ヨ繧ｦ繧ｧ繧｢縺ｫ襍ｷ蝗?縺ｾ縺溘?髢｢騾｣縺励?√≠繧九＞縺ｯ繧ｽ繝輔ヨ繧ｦ繧ｧ繧｢縺ｮ菴ｿ逕ｨ縺ｾ縺溘?縺昴?莉悶?謇ｱ縺?↓繧医▲縺ｦ逕溘§繧倶ｸ?蛻??隲区ｱゅ?∵錐螳ｳ縲
+縺昴?莉悶?鄒ｩ蜍吶↓縺､縺?※菴輔ｉ縺ｮ雋ｬ莉ｻ繧りｲ?繧上↑縺?ｂ縺ｮ縺ｨ縺励∪縺吶?
+
+
+窶ｻ豕ｨ諢
+data莉･荳九?繝輔ぃ繧､繝ｫ, font莉･荳九?繝輔ぃ繧､繝ｫ縺ｫ縺ｯ隨ｬ荳芽??′菴懈?縺励◆繧ｳ繝ｳ繝?Φ繝?ｒ蜷ｫ繧薙〒縺?ｋ縺溘ａ縲
+縺薙?繝ｩ繧､繧ｻ繝ｳ繧ｹ縺ｮ蟇ｾ雎｡螟悶→縺ｪ繧翫∪縺吶?

--- a/get.sh
+++ b/get.sh
@@ -5,6 +5,8 @@ go get -u github.com/go-gl/glfw/v3.2/glfw
 go get -u github.com/go-gl/gl/v2.1/gl
 go get -u github.com/jfreymuth/go-vorbis/ogg/vorbis
 go get -u github.com/timshannon/go-openal/openal
+go get -u github.com/K4thos/glfont
+go get -u github.com/flopp/go-findfont
 go get -u github.com/faiface/beep
 go get -u github.com/hajimehoshi/oto
 go get -u github.com/hajimehoshi/go-mp3

--- a/src/char.go
+++ b/src/char.go
@@ -2354,7 +2354,11 @@ func (c *Char) leftEdge() float32 {
 	return sys.cam.ScreenPos[0] / c.localscl
 }
 func (c *Char) lose() bool {
-	return sys.winTeam == 1^c.teamside
+	if c.roundState() > 2 {
+		return sys.winTeam != c.teamside
+	} else {
+		return false
+	}
 }
 func (c *Char) loseKO() bool {
 	return c.lose() && sys.finish == FT_KO
@@ -2564,7 +2568,11 @@ func (c *Char) win() bool {
 	if c.teamside >= 2 {
 		return false
 	}
-	return sys.winTeam == c.playerNo&1
+	if c.roundState() > 2 {
+		return sys.winTeam == c.playerNo&1
+	} else {
+		return false
+	}
 }
 func (c *Char) winKO() bool {
 	return c.win() && sys.finish == FT_KO
@@ -2644,6 +2652,8 @@ func (c *Char) playSound(f, lowpriority, loop bool, g, n, chNo, vol int32,
 		}
 	}
 }
+
+// Furimuki = Turn around
 func (c *Char) furimuki() {
 	if c.scf(SCF_ctrl) && c.helperIndex == 0 {
 		if c.rdDistX(sys.charList.enemyNear(c, 0, true), c).ToF() < 0 {
@@ -2702,7 +2712,7 @@ func (c *Char) stateChange2() bool {
 	return false
 }
 func (c *Char) changeStateEx(no int32, pn int, anim, ctrl int32) {
-	if c.minus <= 0 && (c.ss.stateType == ST_S || c.ss.stateType == ST_C) {
+	if c.minus <= 0 && (c.ss.stateType == ST_S || c.ss.stateType == ST_C) && !c.sf(CSF_noautoturn) {
 		c.furimuki()
 	}
 	if anim >= 0 {

--- a/src/common.go
+++ b/src/common.go
@@ -241,21 +241,24 @@ func FileExist(filename string) string {
 	}
 	return ""
 }
-func LoadFile(file *string, deffile string, load func(string) error) error {
+
+//SearchFile returns the directory that file is located
+//This search on deffile directory, then it keep looking on other dirs
+func SearchFile(file string, deffile string) string {
 	var fp string
-	*file = strings.Replace(*file, "\\", "/", -1)
+	file = strings.Replace(file, "\\", "/", -1)
 	defdir := filepath.Dir(strings.Replace(deffile, "\\", "/", -1))
-	if defdir == "." || strings.Contains(*file, ":/") {
-		fp = *file
+	if defdir == "." || strings.Contains(file, ":/") {
+		fp = file
 	} else if defdir == "/" {
-		fp = "/" + *file
+		fp = "/" + file
 	} else {
-		fp = defdir + "/" + *file
+		fp = defdir + "/" + file
 	}
 	if fp = FileExist(fp); len(fp) == 0 {
 		_else := false
 		if defdir != "data" {
-			fp = "data/" + *file
+			fp = "data/" + file
 			if fp = FileExist(fp); len(fp) == 0 {
 				_else = true
 			}
@@ -263,18 +266,25 @@ func LoadFile(file *string, deffile string, load func(string) error) error {
 			_else = true
 		}
 		if _else {
-			fp = *file
+			fp = file
 			if fp = FileExist(fp); len(fp) == 0 {
-				fp = *file
+				fp = file
 			}
 		}
 	}
+
+	return fp
+}
+
+func LoadFile(file *string, deffile string, load func(string) error) error {
+	fp := SearchFile(*file, deffile)
 	if err := load(fp); err != nil {
 		return Error(deffile + ":\n" + fp + "\n" + err.Error())
 	}
 	*file = fp
 	return nil
 }
+
 func SplitAndTrim(str, sep string) (ss []string) {
 	ss = strings.Split(str, sep)
 	for i, s := range ss {

--- a/src/font.go
+++ b/src/font.go
@@ -7,78 +7,128 @@ import (
 	"strings"
 	"unsafe"
 
+	"github.com/K4thos/glfont"
+	findfont "github.com/flopp/go-findfont"
 	"github.com/go-gl/gl/v2.1/gl"
 )
 
+// FntCharImage stores sprite and position
 type FntCharImage struct {
 	ofs, w uint16
 	img    []Sprite
 }
+
+// Fnt is a interface for basic font information
 type Fnt struct {
 	images    map[rune]*FntCharImage
 	palettes  [][256]uint32
 	ver, ver2 uint16
+	Type      string
 	Size      [2]uint16
 	Spacing   [2]int32
 	colors    int32
 	offset    [2]int32
+	ttf       *glfont.Font
+	palfx     *PalFX
+	alphaSrc  int32
+	alphaDst  int32
+}
+
+func newFnt() *Fnt {
+	return &Fnt{
+		images: make(map[rune]*FntCharImage),
+		palfx:  newPalFX(),
+	}
 }
 
-func newFnt() *Fnt { return &Fnt{images: make(map[rune]*FntCharImage)} }
 func loadFnt(filename string) (*Fnt, error) {
+
+	if strings.HasSuffix(filename, ".fnt") {
+		return loadFntV1(filename)
+	}
+
+	return loadFntV2(filename)
+}
+
+func loadFntV1(filename string) (*Fnt, error) {
 	f := newFnt()
 	fp, err := os.Open(filename)
+
+	//Check file in "font/"" directory
+	if err != nil {
+		fp, err = os.Open("font/" + filename)
+	}
+
+	//Error opening file
 	if err != nil {
 		return nil, err
 	}
+
 	defer func() { chk(fp.Close()) }()
+
+	//Read header
 	buf := make([]byte, 12)
-	var n int
-	if n, err = fp.Read(buf); err != nil {
+	n, err := fp.Read(buf)
+
+	//Error reading file
+	if err != nil {
 		return nil, err
 	}
+
+	//Error is not a valid fnt file
 	if string(buf[:n]) != "ElecbyteFnt\x00" {
 		return nil, Error("ElecbyteFntではありません")
 	}
+
 	read := func(x interface{}) error {
 		return binary.Read(fp, binary.LittleEndian, x)
 	}
+
 	if err := read(&f.ver); err != nil {
 		return nil, err
 	}
+
 	if err := read(&f.ver2); err != nil {
 		return nil, err
 	}
+
 	var pcxDataOffset, pcxDataLenght, txtDataOffset, txtDataLenght uint32
 	if err := read(&pcxDataOffset); err != nil {
 		return nil, err
 	}
+
 	if err := read(&pcxDataLenght); err != nil {
 		return nil, err
 	}
+
 	if err := read(&txtDataOffset); err != nil {
 		return nil, err
 	}
+
 	if err := read(&txtDataLenght); err != nil {
 		return nil, err
 	}
+
 	spr := newSprite()
 	if err := spr.readPcxHeader(fp, int64(pcxDataOffset)); err != nil {
 		return nil, err
 	}
+
 	fp.Seek(int64(pcxDataOffset)+128, 0)
 	px := make([]byte, pcxDataLenght-128-768)
 	if err := read(px); err != nil {
 		return nil, err
 	}
+
 	spr.Pal = make([]uint32, 256)
 	var rgb [3]byte
 	for i := range spr.Pal {
 		if err := read(rgb[:]); err != nil {
 			return nil, err
 		}
-		spr.Pal[i] = uint32(255)<<24 | uint32(rgb[2])<<16 | uint32(rgb[1])<<8 | uint32(rgb[0])
+		spr.Pal[i] = uint32(rgb[2])<<16 | uint32(rgb[1])<<8 | uint32(rgb[0])
 	}
+
 	px = spr.RlePcxDecode(px)
 	fp.Seek(int64(txtDataOffset), 0)
 	buf = make([]byte, txtDataLenght)
@@ -106,6 +156,7 @@ func loadFnt(filename string) (*Fnt, error) {
 				mapflg = false
 				re := regexp.MustCompile("(\\S+)(?:\\s+(\\S+)(?:\\s+(\\S+))?)?")
 				ofs := uint16(0)
+				w := int32(0)
 				for ; i < len(lines); i++ {
 					if len(lines[i]) > 0 && lines[i][0] == '[' {
 						break
@@ -134,10 +185,10 @@ func loadFnt(filename string) (*Fnt, error) {
 						fci := &FntCharImage{ofs: ofs}
 						f.images[c] = fci
 						if len(cap[3]) > 0 {
-							w := Atoi(cap[3])
+							w = Atoi(cap[3])
 							if w < 0 {
-								ofs = I32ToU16(int32(ofs) - w)
-								w = -w
+								ofs += I32ToU16(int32(ofs) - w)
+								w = 0 - w
 							}
 							fci.w = I32ToU16(w)
 							ofs += fci.w - f.Size[0]
@@ -153,33 +204,7 @@ func loadFnt(filename string) (*Fnt, error) {
 				defflg = false
 				is := NewIniSection()
 				is.Parse(lines, &i)
-				ary := SplitAndTrim(is["size"], ",")
-				if len(ary[0]) > 0 {
-					f.Size[0] = I32ToU16(Atoi(ary[0]))
-				}
-				if len(ary) > 1 && len(ary[1]) > 0 {
-					f.Size[1] = I32ToU16(Atoi(ary[1]))
-				}
-				ary = SplitAndTrim(is["spacing"], ",")
-				if len(ary[0]) > 0 {
-					f.Spacing[0] = Atoi(ary[0])
-				}
-				if len(ary) > 1 && len(ary[1]) > 0 {
-					f.Spacing[1] = Atoi(ary[1])
-				}
-				f.colors = Atoi(is["colors"])
-				if f.colors > 255 {
-					f.colors = 255
-				} else if f.colors < 1 {
-					f.colors = 1
-				}
-				ary = SplitAndTrim(is["offset"], ",")
-				if len(ary[0]) > 0 {
-					f.offset[0] = Atoi(ary[0])
-				}
-				if len(ary) > 1 && len(ary[1]) > 0 {
-					f.offset[1] = Atoi(ary[1])
-				}
+				loadDefInfo(f, filename, is)
 			}
 		}
 	}
@@ -220,8 +245,142 @@ func loadFnt(filename string) (*Fnt, error) {
 			fci.img[i].Offset[0], fci.img[i].Offset[1], fci.img[i].Pal = 0, 0, p[:]
 		}
 	}
+
+	f.SetColor(255, 255, 255, 255, 0)
+
+	return f, nil
+}
+
+func loadFntV2(filename string) (*Fnt, error) {
+	f := newFnt()
+
+	content, err := LoadText(filename)
+
+	//Check file in "font/"" directory
+	if err != nil {
+		content, err = LoadText(filename)
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	lines := SplitAndTrim(string(content), "\n")
+	i := 0
+	var name string
+
+	for ; i < len(lines); i++ {
+		name, _ = SectionName(lines[i])
+		if len(name) > 0 {
+			is := NewIniSection()
+			i++
+			is.Parse(lines, &i)
+			i--
+			switch name {
+			case "def":
+				loadDefInfo(f, filename, is)
+			}
+		}
+	}
+
+	f.SetColor(255, 255, 255, 255, 0)
+
 	return f, nil
 }
+
+func loadDefInfo(f *Fnt, filename string, is IniSection) {
+	f.Type = strings.ToLower(is["type"])
+	ary := SplitAndTrim(is["size"], ",")
+	if len(ary[0]) > 0 {
+		f.Size[0] = I32ToU16(Atoi(ary[0]))
+	}
+	if len(ary) > 1 && len(ary[1]) > 0 {
+		f.Size[1] = I32ToU16(Atoi(ary[1]))
+	}
+	ary = SplitAndTrim(is["spacing"], ",")
+	if len(ary[0]) > 0 {
+		f.Spacing[0] = Atoi(ary[0])
+	}
+	if len(ary) > 1 && len(ary[1]) > 0 {
+		f.Spacing[1] = Atoi(ary[1])
+	}
+	f.colors = Atoi(is["colors"])
+	if f.colors > 255 {
+		f.colors = 255
+	} else if f.colors < 1 {
+		f.colors = 1
+	}
+	ary = SplitAndTrim(is["offset"], ",")
+	if len(ary[0]) > 0 {
+		f.offset[0] = Atoi(ary[0])
+	}
+	if len(ary) > 1 && len(ary[1]) > 0 {
+		f.offset[1] = Atoi(ary[1])
+	}
+
+	if len(is["file"]) > 0 {
+		if f.Type == "truetype" {
+			loadFntTtf(f, filename, is["file"])
+		} else {
+			loadFntSff(f, filename, is["file"])
+		}
+	}
+}
+
+func loadFntTtf(f *Fnt, fontfile string, filename string) {
+	//Search in local directory
+	fileDir := SearchFile(filename, fontfile)
+	//Search in system directory
+	fp := fileDir
+	if fp = FileExist(fp); len(fp) == 0 {
+		var err error
+		fileDir, err = findfont.Find(fileDir)
+		if err != nil {
+			panic(err)
+		}
+		//fmt.Printf("Found font in '%s'\n", fileDir)
+	}
+	//Load ttf
+	ttf, err := glfont.LoadFont(fileDir, int32(f.Size[1]), int(sys.gameWidth), int(sys.gameHeight))
+	if err != nil {
+		panic(err)
+	}
+	f.ttf = ttf
+}
+
+func loadFntSff(f *Fnt, fontfile string, filename string) {
+	fileDir := SearchFile(filename, fontfile)
+	sff, err := loadSff(fileDir, false)
+
+	if err != nil {
+		panic(err)
+	}
+
+	//Load sprites
+	for k, sprite := range sff.sprites {
+		s := sff.getOwnPalSprite(sprite.Group, sprite.Number)
+		offsetX := uint16(s.Offset[0])
+		sizeX := uint16(s.Size[0])
+
+		fci := &FntCharImage{
+			ofs: offsetX,
+			w:   sizeX,
+		}
+		fci.img = make([]Sprite, 1)
+		fci.img[0] = *s
+		f.images[rune(k[1])] = fci
+	}
+
+	//Load palettes
+	f.palettes = make([][256]uint32, sff.header.NumberOfPalettes)
+	for i := 0; i < int(sff.header.NumberOfPalettes); i++ {
+		pal := sff.palList.Get(i)
+		copy(f.palettes[i][:], pal)
+	}
+
+}
+
+//CharWidth returns the width that has a specified character
 func (f *Fnt) CharWidth(c rune) int32 {
 	if c == ' ' {
 		return int32(f.Size[0])
@@ -232,63 +391,135 @@ func (f *Fnt) CharWidth(c rune) int32 {
 	}
 	return int32(fci.w)
 }
+
+//TextWidth returns the width that has a specified text.
+//This depends on each char's width and font spacing
 func (f *Fnt) TextWidth(txt string) (w int32) {
 	for _, c := range txt {
 		w += f.CharWidth(c) + f.Spacing[0]
 	}
 	return
 }
+
+func (f *Fnt) SetColor(r, g, b, alphaSrc, alphaDst float32) {
+
+	rNormalized := Max(0, Min(255, int32(r)))
+	gNormalized := Max(0, Min(255, int32(g)))
+	bNormalized := Max(0, Min(255, int32(b)))
+
+	f.palfx.enable = true
+	f.palfx.eColor = 1
+	f.palfx.eMul = [...]int32{
+		256 * rNormalized >> 8,
+		256 * gNormalized >> 8,
+		256 * bNormalized >> 8,
+	}
+
+	f.alphaSrc = Max(0, Min(255, int32(alphaSrc)))
+	f.alphaDst = Max(0, Min(255, int32(alphaDst)))
+}
+
 func (f *Fnt) getCharSpr(c rune, bank int32) *Sprite {
 	fci := f.images[c]
 	if fci == nil {
 		return nil
 	}
-	return &fci.img[bank]
+
+	if bank < int32(len(fci.img)) {
+		return &fci.img[bank]
+	}
+
+	return &fci.img[0]
+}
+
+func (f *Fnt) calculateTrans() int32 {
+	alphaSrc := int32(sys.brightness * f.alphaSrc >> 8)
+	separator := int32(1 << 9)
+	alphaDst := int32(f.alphaDst << 10)
+
+	return alphaSrc | separator | alphaDst
 }
-func (f *Fnt) drawChar(x, y, xscl, yscl float32, bank int32, c rune) float32 {
+
+func (f *Fnt) drawChar(
+	x, y, xscl, yscl float32,
+	bank int32,
+	c rune,
+	paltex uint32,
+) float32 {
+
 	if c == ' ' {
 		return float32(f.Size[0]) * xscl
 	}
+
 	spr := f.getCharSpr(c, bank)
 	if spr == nil || spr.Tex == nil {
 		return 0
 	}
+
+	//trans := f.calculateTrans()
+
 	RenderMugenPal(*spr.Tex, 0, spr.Size, -x*sys.widthScale,
 		-y*sys.heightScale, &notiling, xscl*sys.widthScale, xscl*sys.widthScale,
 		yscl*sys.heightScale, 1, 0, 0, 0, 0, sys.brightness*255>>8|1<<9, &sys.scrrect,
 		0, 0, false, 1, &[3]float32{0, 0, 0}, &[3]float32{1, 1, 1})
+
 	return float32(spr.Size[0]) * xscl
 }
-func (f *Fnt) DrawText(txt string, x, y, xscl, yscl float32,
-	bank, align int32) {
+
+//DrawText prints on screen a specified text with the current font sprites
+func (f *Fnt) DrawText(
+	txt string,
+	x, y, xscl, yscl float32,
+	bank, align int32,
+) {
+
 	if len(txt) == 0 {
 		return
 	}
+
 	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)
+	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 {
 		x -= float32(f.TextWidth(txt)) * xscl
 	}
+
 	if bank < 0 || len(f.palettes) <= int(bank) {
 		bank = 0
 	}
-	// nil から呼ぶと allPalFX が適用される
-	pal := (*PalFX)(nil).getFxPal(f.palettes[bank][:], false)
+
+	pal := f.palfx.getFxPal(f.palettes[bank][:], false)
 	gl.Enable(gl.TEXTURE_1D)
 	gl.ActiveTexture(gl.TEXTURE1)
 	var paltex uint32
 	gl.GenTextures(1, &paltex)
 	gl.BindTexture(gl.TEXTURE_1D, paltex)
 	gl.PixelStorei(gl.UNPACK_ALIGNMENT, 1)
-	gl.TexImage1D(gl.TEXTURE_1D, 0, gl.RGBA, 256, 0, gl.RGBA, gl.UNSIGNED_BYTE,
-		unsafe.Pointer(&pal[0]))
+	gl.TexImage1D(
+		gl.TEXTURE_1D,
+		0,
+		gl.RGBA,
+		256,
+		0,
+		gl.RGBA,
+		gl.UNSIGNED_BYTE,
+		unsafe.Pointer(&pal[0]),
+	)
 	gl.TexParameteri(gl.TEXTURE_1D, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
 	gl.TexParameteri(gl.TEXTURE_1D, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
+
 	for _, c := range txt {
-		x += f.drawChar(x, y, xscl, yscl, bank, c) + xscl*float32(f.Spacing[0])
+		x += f.drawChar(
+			x,
+			y,
+			xscl,
+			yscl,
+			bank,
+			c,
+			paltex,
+		) + xscl*float32(f.Spacing[0])
 	}
 	gl.DeleteTextures(1, &paltex)
 	gl.Disable(gl.TEXTURE_1D)
@@ -304,8 +535,21 @@ type TextSprite struct {
 func NewTextSprite() *TextSprite {
 	return &TextSprite{align: 1, xscl: 1, yscl: 1}
 }
+
+func (ts *TextSprite) SetColor(r, g, b, alphaSrc, alphaDst float32) {
+	if ts.fnt.Type == "truetype" {
+		//ts.fnt.ttf.SetColor(r, g, b, a)
+	} else {
+		ts.fnt.SetColor(r, g, b, alphaSrc, alphaDst)
+	}
+}
+
 func (ts *TextSprite) Draw() {
 	if !sys.frameSkip && ts.fnt != nil {
-		ts.fnt.DrawText(ts.text, ts.x, ts.y, ts.xscl, ts.yscl, ts.bank, ts.align)
+		if ts.fnt.Type == "truetype" {
+			//ts.fnt.ttf.Printf(ts.x, ts.y, ts.yscl, ts.align, ts.text) //x, y, scale, align, string, printf args
+		} else {
+			ts.fnt.DrawText(ts.text, ts.x, ts.y, ts.xscl, ts.yscl, ts.bank, ts.align)
+		}
 	}
 }

--- a/src/script.go
+++ b/src/script.go
@@ -8,7 +8,7 @@ import (
 	"strings"
 
 	"github.com/go-gl/glfw/v3.2/glfw"
-	"github.com/yuin/gopher-lua"
+	lua "github.com/yuin/gopher-lua"
 )
 
 func luaRegister(l *lua.LState, name string, f func(*lua.LState) int) {
@@ -245,6 +245,29 @@ func scriptCommonInit(l *lua.LState) {
 		sys.teamLifeShare = boolArg(l, 1)
 		return 0
 	})
+
+	// All the lua sprites will be caled by this value
+	luaRegister(l, "setLuaSpriteScale", func(l *lua.LState) int {
+		sys.luaSpriteScale = float64(numArg(l, 1))
+		return 0
+	})
+
+	// All the lua sprites will be caled by this value
+	luaRegister(l, "setLuaSpriteOffsetX", func(l *lua.LState) int {
+		sys.luaSpriteOffsetX = float64(numArg(l, 1))
+		return 0
+	})
+
+	// All the lua sprites will add this value to his position Y
+	luaRegister(l, "setLuaSmallPortraitScale", func(l *lua.LState) int {
+		sys.luaSmallPortraitScale = float32(numArg(l, 1))
+		return 0
+	})
+	// All the lua sprites will add this value to his position Y
+	luaRegister(l, "setLuaBigPortraitScale", func(l *lua.LState) int {
+		sys.luaBigPortraitScale = float32(numArg(l, 1))
+		return 0
+	})
 }
 
 // System Script
@@ -296,7 +319,7 @@ func systemScriptInit(l *lua.LState) {
 		if !ok {
 			userDataError(l, 1, ts)
 		}
-		ts.x, ts.y = float32(numArg(l, 2)), float32(numArg(l, 3))
+		ts.x, ts.y = float32((numArg(l, 2)/sys.luaSpriteScale)+sys.luaSpriteOffsetX), float32(numArg(l, 3)/sys.luaSpriteScale)
 		return 0
 	})
 	luaRegister(l, "textImgSetScale", func(*lua.LState) int {
@@ -304,7 +327,7 @@ func systemScriptInit(l *lua.LState) {
 		if !ok {
 			userDataError(l, 1, ts)
 		}
-		ts.xscl, ts.yscl = float32(numArg(l, 2)), float32(numArg(l, 3))
+		ts.xscl, ts.yscl = float32(numArg(l, 2)/sys.luaSpriteScale), float32(numArg(l, 3)/sys.luaSpriteScale)
 		return 0
 	})
 	luaRegister(l, "textImgDraw", func(*lua.LState) int {
@@ -333,7 +356,7 @@ func systemScriptInit(l *lua.LState) {
 		if !ok {
 			userDataError(l, 1, a)
 		}
-		a.SetPos(float32(numArg(l, 2)), float32(numArg(l, 3)))
+		a.SetPos(float32((numArg(l, 2)/sys.luaSpriteScale)+sys.luaSpriteOffsetX), float32(numArg(l, 3)/sys.luaSpriteScale))
 		return 0
 	})
 	luaRegister(l, "animAddPos", func(*lua.LState) int {
@@ -341,7 +364,7 @@ func systemScriptInit(l *lua.LState) {
 		if !ok {
 			userDataError(l, 1, a)
 		}
-		a.AddPos(float32(numArg(l, 2)), float32(numArg(l, 3)))
+		a.AddPos(float32(numArg(l, 2)/sys.luaSpriteScale), float32(numArg(l, 3)/sys.luaSpriteScale))
 		return 0
 	})
 	luaRegister(l, "animSetTile", func(*lua.LState) int {
@@ -382,7 +405,7 @@ func systemScriptInit(l *lua.LState) {
 		if !ok {
 			userDataError(l, 1, a)
 		}
-		a.SetScale(float32(numArg(l, 2)), float32(numArg(l, 3)))
+		a.SetScale(float32(numArg(l, 2)/sys.luaSpriteScale), float32(numArg(l, 3)/sys.luaSpriteScale))
 		return 0
 	})
 	luaRegister(l, "animSetWindow", func(*lua.LState) int {
@@ -390,8 +413,8 @@ func systemScriptInit(l *lua.LState) {
 		if !ok {
 			userDataError(l, 1, a)
 		}
-		a.SetWindow(float32(numArg(l, 2)), float32(numArg(l, 3)),
-			float32(numArg(l, 4)), float32(numArg(l, 5)))
+		a.SetWindow(float32((numArg(l, 2)/sys.luaSpriteScale)+sys.luaSpriteOffsetX), float32(numArg(l, 3)/sys.luaSpriteScale),
+			float32(numArg(l, 4)/sys.luaSpriteScale), float32(numArg(l, 5)/sys.luaSpriteScale))
 		return 0
 	})
 	luaRegister(l, "animUpdate", func(*lua.LState) int {
@@ -621,7 +644,7 @@ func systemScriptInit(l *lua.LState) {
 					xscl *= c.portrait_scale
 					yscl *= c.portrait_scale
 				}
-				c.lportrait.Draw(x, y, xscl, yscl, c.lportrait.Pal, nil)
+				c.lportrait.Draw(x/float32(sys.luaSpriteScale)+float32(sys.luaSpriteOffsetX), y/float32(sys.luaSpriteScale), xscl/sys.luaBigPortraitScale, yscl/sys.luaBigPortraitScale, c.lportrait.Pal, nil)
 			}
 		}
 		return 0
@@ -639,13 +662,17 @@ func systemScriptInit(l *lua.LState) {
 					offset++
 					if c != nil {
 						if c.sportrait != nil {
-							c.sportrait.Draw(x+float32(i)*sys.sel.cellsize[0],
-								y+float32(j)*sys.sel.cellsize[1], sys.sel.cellscale[0]*c.portrait_scale,
-								sys.sel.cellscale[1]*c.portrait_scale, c.sportrait.Pal, nil)
+							c.sportrait.Draw((x + float32(i)*sys.sel.cellsize[0]),
+								(y+float32(j)*sys.sel.cellsize[1])/float32(sys.luaSpriteScale),
+								(sys.sel.cellscale[0]*c.portrait_scale)/float32(sys.luaSpriteScale),
+								(sys.sel.cellscale[1]*c.portrait_scale)/float32(sys.luaSpriteScale),
+								c.sportrait.Pal, nil)
 						} else if c.def == "randomselect" && sys.sel.randomspr != nil {
 							sys.sel.randomspr.Draw(x+float32(i)*sys.sel.cellsize[0],
-								y+float32(j)*sys.sel.cellsize[1], sys.sel.randomscl[0],
-								sys.sel.randomscl[1], sys.sel.randomspr.Pal, nil)
+								y+float32(j)*sys.sel.cellsize[1]/float32(sys.luaSpriteScale),
+								sys.sel.randomscl[0]/float32(sys.luaSpriteScale),
+								sys.sel.randomscl[1]/float32(sys.luaSpriteScale),
+								sys.sel.randomspr.Pal, nil)
 						}
 					}
 				}
@@ -986,7 +1013,7 @@ func systemScriptInit(l *lua.LState) {
 					xscl *= c.portrait_scale
 					yscl *= c.portrait_scale
 				}
-				c.sportrait.Draw(x, y, xscl, yscl, c.sportrait.Pal, nil)
+				c.sportrait.Draw(x/float32(sys.luaSpriteScale)+float32(sys.luaSpriteOffsetX), y/float32(sys.luaSpriteScale), xscl/sys.luaSmallPortraitScale, yscl/sys.luaSmallPortraitScale, c.sportrait.Pal, nil)
 			}
 		}
 		return 0
@@ -1007,7 +1034,7 @@ func systemScriptInit(l *lua.LState) {
 					xscl *= c.portrait_scale
 					yscl *= c.portrait_scale
 				}
-				c.vsportrait.Draw(x, y, xscl, yscl, c.vsportrait.Pal, nil)
+				c.vsportrait.Draw(x/float32(sys.luaSpriteScale)+float32(sys.luaSpriteOffsetX), y/float32(sys.luaSpriteScale), xscl/sys.luaBigPortraitScale, yscl/sys.luaBigPortraitScale, c.vsportrait.Pal, nil)
 			}
 		}
 		return 0
@@ -1028,7 +1055,7 @@ func systemScriptInit(l *lua.LState) {
 					xscl *= c.portrait_scale
 					yscl *= c.portrait_scale
 				}
-				c.vportrait.Draw(x, y, xscl, yscl, c.vportrait.Pal, nil)
+				c.vportrait.Draw(x/float32(sys.luaSpriteScale)+float32(sys.luaSpriteOffsetX), y/float32(sys.luaSpriteScale), xscl/float32(sys.luaSpriteScale), yscl/float32(sys.luaSpriteScale), c.vportrait.Pal, nil)
 			}
 		}
 		return 0

--- a/src/system.go
+++ b/src/system.go
@@ -15,11 +15,11 @@ import (
 	"github.com/go-gl/gl/v2.1/gl"
 	"github.com/go-gl/glfw/v3.2/glfw"
 	"github.com/timshannon/go-openal/openal"
-	"github.com/yuin/gopher-lua"
+	lua "github.com/yuin/gopher-lua"
 )
 
 const (
-	MaxSimul        = 4
+	MaxSimul        = 8
 	MaxAttachedChar = 2
 	FPS             = 60
 	P1P3Dist        = 25
@@ -59,6 +59,11 @@ var sys = System{
 	audioClose:       make(chan bool, 1),
 	keyInput:         glfw.KeyUnknown,
 	keyString:        "",
+	// Localcoord sceenpack
+	luaSpriteScale:        1,
+	luaSmallPortraitScale: 1,
+	luaBigPortraitScale:   1,
+	luaSpriteOffsetX:      0,
 }
 
 type TeamMode int32
@@ -221,6 +226,11 @@ type System struct {
 	timerCount              []int32
 	cmdFlags                map[string]string
 	quickLaunch             bool
+	// Localcoord sceenpack
+	luaSpriteScale        float64
+	luaSmallPortraitScale float32
+	luaBigPortraitScale   float32
+	luaSpriteOffsetX      float64
 }
 
 func (s *System) init(w, h int32) *lua.LState {