allow users to define a variable number of lines in font_config

README.md

@@ -434,6 +434,8 @@ The font configuration JSON file informs Poryscript how many pixels wide each ch
 
 `cursorOverlapWidth` can be used to ensure there is always enough room for the cursor icon to be displayed in the text box. (This "cursor icon" is the small icon that's shown when the player needs to press A to advance the text box.)
 
+`numLines` is the number of lines displayed within a single message box. If editing text for a taller space, this can be adjusted in `font_config.json`.
+
 The length of a line can optionally be specified as the third parameter to `format()` if a font id was specified as the second parameter.
 
 ```

font_config.json

@@ -3,6 +3,7 @@
   "fonts": {
     "1_latin_rse": {
       "maxLineLength": 208,
+      "numLines": 2,
       "cursorOverlapWidth": 0,
       "widths": {
         " ": 3,
@@ -177,6 +178,7 @@
     },
     "1_latin_frlg": {
       "maxLineLength": 208,
+      "numLines": 2,
       "cursorOverlapWidth": 10,
       "widths": {
         " ": 6,

parser/formattext.go

@@ -19,6 +19,7 @@ type Fonts struct {
 	Widths             map[string]int `json:"widths"`
 	CursorOverlapWidth int            `json:"cursorOverlapWidth"`
 	MaxLineLength      int            `json:"maxLineLength"`
+	NumLines           int            `json:"numLines"`
 }
 
 // LoadFontConfig reads a font width config JSON file.
@@ -40,7 +41,7 @@ const testFontID = "TEST"
 
 // FormatText automatically inserts line breaks into text
 // according to in-game text box widths.
-func (fc *FontConfig) FormatText(text string, maxWidth int, cursorOverlapWidth int, fontID string) (string, error) {
+func (fc *FontConfig) FormatText(text string, maxWidth int, cursorOverlapWidth int, fontID string, numLines int) (string, error) {
 	if !fc.isFontIDValid(fontID) && len(fontID) > 0 && fontID != testFontID {
 		validFontIDs := make([]string, len(fc.Fonts))
 		i := 0
@@ -56,7 +57,7 @@ func (fc *FontConfig) FormatText(text string, maxWidth int, cursorOverlapWidth i
 	var formattedSb strings.Builder
 	var curLineSb strings.Builder
 	curWidth := 0
-	isFirstLine := true
+	curLineNum := 0
 	isFirstWord := true
 	spaceCharWidth := fc.getRunePixelWidth(' ', fontID)
 	pos, word := fc.getNextWord(text)
@@ -71,7 +72,7 @@ func (fc *FontConfig) FormatText(text string, maxWidth int, cursorOverlapWidth i
 			curWidth = 0
 			formattedSb.WriteString(curLineSb.String())
 			if fc.isAutoLineBreak(word) {
-				if isFirstLine {
+				if fc.isFirstLine(curLineNum) {
 					formattedSb.WriteString(`\n`)
 				} else {
 					formattedSb.WriteString(`\l`)
@@ -80,10 +81,8 @@ func (fc *FontConfig) FormatText(text string, maxWidth int, cursorOverlapWidth i
 				formattedSb.WriteString(word)
 			}
 			formattedSb.WriteByte('\n')
-			if fc.isParagraphBreak(word) {
-				isFirstLine = true
-			} else {
-				isFirstLine = false
+			if !fc.isParagraphBreak(word) {
+				curLineNum++
 			}
 			isFirstWord = true
 			curLineSb.Reset()
@@ -98,17 +97,19 @@ func (fc *FontConfig) FormatText(text string, maxWidth int, cursorOverlapWidth i
 			// it could span multiple words. The true solution would require optimistically trying to fit all
 			// remaining words onto the same line, rather than only looking at the current word + cursor. However,
 			// this is "good enough" and likely works for almost all actual use cases in practice.
-			if len(nextWord) > 0 && (!isFirstLine || fc.isParagraphBreak(nextWord)) {
+			if len(nextWord) > 0 && (fc.isFirstLine(curLineNum) == false || fc.isParagraphBreak(nextWord)) {
 				nextWidth += cursorOverlapWidth
 			}
 			if nextWidth > maxWidth && curLineSb.Len() > 0 {
 				formattedSb.WriteString(curLineSb.String())
-				if isFirstLine {
-					formattedSb.WriteString(`\n`)
-					isFirstLine = false
-				} else {
+
+				if fc.shouldUseLineFeed(curLineNum, numLines) {
 					formattedSb.WriteString(`\l`)
+				} else {
+					formattedSb.WriteString(`\n`)
 				}
+
+				curLineNum++
 				formattedSb.WriteByte('\n')
 				isFirstWord = false
 				curLineSb.Reset()
@@ -133,6 +134,14 @@ func (fc *FontConfig) FormatText(text string, maxWidth int, cursorOverlapWidth i
 	return formattedSb.String(), nil
 }
 
+func (fc *FontConfig) isFirstLine(curLineNum int) bool {
+	return curLineNum == 0
+}
+
+func (fc *FontConfig) shouldUseLineFeed(curLineNum int, numLines int) bool {
+	return (curLineNum >= (numLines - 1))
+}
+
 func (fc *FontConfig) getNextWord(text string) (int, string) {
 	escape := false
 	endPos := 0

parser/parser.go

@@ -52,6 +52,8 @@ type Parser struct {
 	defaultFontID           string
 	fonts                   *FontConfig
 	maxLineLength           int
+	numLines                int
+	cursorOverlapWidth      int
 	compileSwitches         map[string]string
 	constants               map[string]string
 	enableEnvironmentErrors bool
@@ -1075,46 +1077,86 @@ func (p *Parser) parseFormatStringOperator() (token.Token, string, string, error
 	}
 
 	maxTextLength := p.maxLineLength
+	numLines := p.numLines
+	cursorOverlapWidth := p.cursorOverlapWidth
+	paramValue := ""
+
+	namedParameters := map[string]func(){
+		"fontId": func() {
+			fontID = paramValue
+			fontIdToken = p.peekToken
+		},
+		"maxLineLength": func() {
+			num, _ := strconv.ParseInt(paramValue, 0, 64)
+			maxTextLength = int(num)
+		},
+		"numLines": func() {
+			num, _ := strconv.ParseInt(paramValue, 0, 64)
+			numLines = int(num)
+		},
+		"cursorOverlapWidth": func() {
+			num, _ := strconv.ParseInt(paramValue, 0, 64)
+			cursorOverlapWidth = int(num)
+		},
+	}
+
+	for !p.peekTokenIs(token.RPAREN) {
+		if !p.peekTokenIs(token.COMMA) {
+			return token.Token{}, "", "", NewParseError(p.peekToken, fmt.Sprintf("invalid format() parameter '%s'. Expected a comma", p.peekToken.Literal))
+		}
 
-	if p.peekTokenIs(token.COMMA) {
 		p.nextToken()
-		if p.peekTokenIs(token.STRING) {
+
+		if p.peekTokenIs(token.INT) {
+			num, _ := strconv.ParseInt(p.peekToken.Literal, 0, 64)
+			maxTextLength = int(num)
 			p.nextToken()
-			fontID = p.curToken.Literal
-			fontIdToken = p.curToken
-			if p.peekTokenIs(token.COMMA) {
-				p.nextToken()
-				if err := p.expectPeek(token.INT); err != nil {
-					return token.Token{}, "", "", NewParseError(p.peekToken, fmt.Sprintf("invalid format() maxLineLength '%s'. Expected integer", p.peekToken.Literal))
-				}
-				num, _ := strconv.ParseInt(p.curToken.Literal, 0, 64)
-				maxTextLength = int(num)
-			}
-		} else if p.peekTokenIs(token.INT) {
+			continue
+		}
+
+		paramName := p.peekToken.Literal
+		_, ok := namedParameters[paramName]
+		if !ok {
+			fontID = p.peekToken.Literal
+			fontIdToken = p.peekToken
 			p.nextToken()
-			num, _ := strconv.ParseInt(p.curToken.Literal, 0, 64)
-			maxTextLength = int(num)
-			if p.peekTokenIs(token.COMMA) {
-				p.nextToken()
-				if err := p.expectPeek(token.STRING); err != nil {
-					return token.Token{}, "", "", NewParseError(p.peekToken, fmt.Sprintf("invalid format() fontId '%s'. Expected string", p.peekToken.Literal))
-				}
-				fontID = p.curToken.Literal
-				fontIdToken = p.curToken
-			}
-		} else {
-			return token.Token{}, "", "", NewParseError(p.peekToken, fmt.Sprintf("invalid format() parameter '%s'. Expected either fontId (string) or maxLineLength (integer)", p.peekToken.Literal))
+			continue
 		}
+
+		p.nextToken()
+
+		if !p.peekTokenIs(token.ASSIGN) {
+			return token.Token{}, "", "", NewParseError(p.peekToken, fmt.Sprintf("invalid format() parameter '%s'. Expected an equals sign", p.peekToken.Literal))
+		}
+
+		p.nextToken()
+		paramValue = p.peekToken.Literal
+
+		setNamedParameters, ok := namedParameters[paramName]
+
+		if !ok {
+			return token.Token{}, "", "", NewParseError(p.curToken, fmt.Sprintf("invalid format() parameter '%s'. Expected one of the following: fontId (string), maxLineLength (integer), cursorOverlapWidth (integer), numLines (integer).", paramName))
+		}
+		setNamedParameters()
+		p.nextToken()
 	}
 	if err := p.expectPeek(token.RPAREN); err != nil {
-		return token.Token{}, "", "", NewParseError(p.peekToken, "missing closing parenthesis ')' for format()")
+		return token.Token{}, "", "", NewParseError(p.curToken, "missing closing parenthesis ')' for format()")
 	}
 
 	if maxTextLength <= 0 {
 		maxTextLength = p.fonts.Fonts[fontID].MaxLineLength
 	}
 
-	formatted, err := p.fonts.FormatText(textToken.Literal, maxTextLength, p.fonts.Fonts[fontID].CursorOverlapWidth, fontID)
+	if numLines <= 0 {
+		numLines = p.fonts.Fonts[fontID].NumLines
+	}
+
+	if cursorOverlapWidth <= 0 {
+		cursorOverlapWidth = p.fonts.Fonts[fontID].CursorOverlapWidth
+	}
+
+	formatted, err := p.fonts.FormatText(textToken.Literal, maxTextLength, cursorOverlapWidth, fontID, numLines)
 	if err != nil && p.enableEnvironmentErrors {
 		return token.Token{}, "", "", NewParseError(fontIdToken, err.Error())
 	}