290 lines
8.2 KiB
GDScript
290 lines
8.2 KiB
GDScript
class_name Output
|
|
|
|
static var GLUE_ERROR: String = "Error! You cannot glue anything other than more text output to the end of an output line."
|
|
|
|
var parts: Array[Variant] = []
|
|
var diverted: bool = false
|
|
|
|
func _init(parts2 = null) -> void:
|
|
var tempRight
|
|
|
|
if (parts2 != null):
|
|
tempRight = parts2
|
|
else:
|
|
tempRight = ([] as Array[Variant])
|
|
|
|
self.parts = tempRight
|
|
|
|
func isEmpty() -> bool:
|
|
return self.parts.size() == 0
|
|
|
|
func takeInlineDivert() -> Variant:
|
|
if (self.parts.size() == 0):
|
|
return { "_index": 1 }
|
|
|
|
var lastPart: Variant = self.parts[self.parts.size() - 1]
|
|
|
|
if (lastPart._index == 4):
|
|
var _g: String = lastPart.t
|
|
var target: String = _g
|
|
var _this: Array[Variant] = self.parts
|
|
var index: int = _this.find(lastPart)
|
|
if (index >= 0):
|
|
_this.remove_at(index)
|
|
true
|
|
else:
|
|
false
|
|
self.parts = Output.updateLastPart(self.parts, false)
|
|
return { "_index": 0, "v": target }
|
|
else:
|
|
return { "_index": 1 }
|
|
|
|
func format(story: Story, hInterface: HInterface, random: Random, altInstances: Variant, scope: Array[StoryNode], displayToggles: bool) -> String:
|
|
var fullOutput: String = ""
|
|
|
|
self.diverted = false
|
|
|
|
var i: int = 0
|
|
var _g: int = 0
|
|
var _g1: Array[Variant] = self.parts
|
|
|
|
while (_g < _g1.size()):
|
|
var part: Variant = _g1[_g]
|
|
_g += 1
|
|
i += 1
|
|
match (part._index):
|
|
0:
|
|
var _g2: String = part.t
|
|
if true:
|
|
var t: String = _g2
|
|
fullOutput += t
|
|
1:
|
|
var _g2: Alt = part.a
|
|
var a: Alt = _g2
|
|
if (!altInstances.exists(a)):
|
|
var v: AltInstance = AltInstance.new(a.behavior, a.outputs, random)
|
|
altInstances.__set(a, v)
|
|
v
|
|
var nextBranchOutput: Output = altInstances.__get(a).next()
|
|
fullOutput += nextBranchOutput.format(story, hInterface, random, altInstances, scope, displayToggles)
|
|
if (nextBranchOutput.diverted):
|
|
break
|
|
2:
|
|
var _g2: String = part.h
|
|
if true:
|
|
var h: String = _g2
|
|
if true:
|
|
var value: String = story.formatForInsertion(hInterface.expr(h, scope))
|
|
if (StringTools.startsWith(value, ",")):
|
|
var nestedOutput: Output = Output.parse(HankBuffer.Dummy(value.substr(1)), false)
|
|
value = nestedOutput.format(story, hInterface, random, altInstances, scope, displayToggles)
|
|
fullOutput += value
|
|
if (nestedOutput.diverted):
|
|
break
|
|
else:
|
|
fullOutput += value
|
|
3:
|
|
var _g2: String = part.h
|
|
if true:
|
|
var h: String = _g2
|
|
hInterface.runEmbeddedHaxe(h, scope)
|
|
4:
|
|
var _g2: String = part.t
|
|
if true:
|
|
var t: String = _g2
|
|
if true:
|
|
story.divertTo(t)
|
|
self.diverted = true
|
|
fullOutput = Output.appendNextText(story, fullOutput, "")
|
|
break
|
|
5:
|
|
var _g2: Output = part.o
|
|
var _g3: bool = part.invert
|
|
var o: Output = _g2
|
|
var b: bool = _g3
|
|
if (b == displayToggles):
|
|
fullOutput += o.format(story, hInterface, random, altInstances, scope, displayToggles)
|
|
6:
|
|
if (i > 1):
|
|
fullOutput = Output.appendNextText(story, fullOutput, GLUE_ERROR)
|
|
|
|
return fullOutput
|
|
|
|
func startsWithGlue() -> bool:
|
|
return self.parts[0] == { "_index": 6 }
|
|
|
|
static func parse(buffer: HankBuffer, isPartOfAlt: bool = false) -> Output:
|
|
var parts2: Array[Variant] = ([] as Array[Variant])
|
|
var eol: int = buffer.rootIndexOf("\n")
|
|
|
|
if (eol == -1):
|
|
eol = buffer.length()
|
|
|
|
buffer = HankBuffer.Dummy(buffer.take(eol))
|
|
|
|
var findBracketExpression: Variant = buffer.findNestedExpression("[", "]", 0, true)
|
|
|
|
match (findBracketExpression._index):
|
|
0:
|
|
var _g: BufferSlice = findBracketExpression.v
|
|
if true:
|
|
var slice: BufferSlice = _g
|
|
if (slice.start < eol):
|
|
var part1: String = buffer.take(slice.start)
|
|
buffer.take(1)
|
|
var part2: String = buffer.take(slice.length - 2)
|
|
buffer.take(1)
|
|
var parts3: Array[Variant] = Output.parse(HankBuffer.Dummy(part1), false).parts
|
|
parts3.push_back({ "_index": 5, "o": Output.parse(HankBuffer.Dummy(part2), false), "invert": false })
|
|
parts3.push_back({ "_index": 5, "o": Output.parse(buffer, false), "invert": true })
|
|
return Output.new(parts3)
|
|
1:
|
|
pass
|
|
|
|
while (!buffer.isEmpty()):
|
|
var endSegment: int = buffer.length()
|
|
var findBraceExpression: Variant = buffer.findNestedExpression("{", "}", 0, true)
|
|
if (findBraceExpression._index == 0):
|
|
var _g: BufferSlice = findBraceExpression.v
|
|
if true:
|
|
var slice: BufferSlice = _g
|
|
endSegment = slice.start
|
|
else:
|
|
pass
|
|
if (endSegment == buffer.length() || endSegment != 0):
|
|
var peekLine: String = Extensions.unwrap(buffer.peekLine(""))
|
|
if (peekLine.length() < endSegment):
|
|
var text: String = Extensions.unwrap(buffer.takeLine(""))
|
|
if (text.length() > 0):
|
|
Output.parseText(parts2, text)
|
|
break
|
|
else:
|
|
var text: String = buffer.take(endSegment)
|
|
Output.parseText(parts2, text)
|
|
else:
|
|
parts2.push_back(Output.parseBraceExpression(buffer))
|
|
|
|
parts2 = Output.updateLastPart(parts2, isPartOfAlt)
|
|
|
|
return Output.new(parts2)
|
|
|
|
static func parseText(parts2: Array[Variant], text: String) -> void:
|
|
var trimmed: String = StringTools.trim(text)
|
|
|
|
if (StringTools.startsWith(trimmed, "~")):
|
|
parts2.push_back({ "_index": 3, "h": trimmed.substr(1) })
|
|
else:
|
|
var endsWithGlue: bool = false
|
|
if (StringTools.endsWith(trimmed, "<>")):
|
|
endsWithGlue = true
|
|
var tempString
|
|
if true:
|
|
var l: int = text.length()
|
|
var r: int = 0
|
|
while (r < l && StringTools.isSpace(text, l - r - 1)):
|
|
r += 1
|
|
if (r > 0):
|
|
tempString = text.substr(0, l - r)
|
|
else:
|
|
tempString = text
|
|
var tempString1
|
|
if true:
|
|
var l: int = text.length()
|
|
var r: int = 0
|
|
while (r < l && StringTools.isSpace(text, l - r - 1)):
|
|
r += 1
|
|
if (r > 0):
|
|
tempString1 = text.substr(0, l - r)
|
|
else:
|
|
tempString1 = text
|
|
text = (tempString).substr(0, (tempString1).length() - 2)
|
|
if (StringTools.startsWith(trimmed, "<>")):
|
|
parts2.push_back({ "_index": 6 })
|
|
var tempString2
|
|
if true:
|
|
var l: int = text.length()
|
|
var r: int = 0
|
|
while (r < l && StringTools.isSpace(text, r)):
|
|
r += 1
|
|
if (r > 0):
|
|
tempString2 = text.substr(r, l - r)
|
|
else:
|
|
tempString2 = text
|
|
text = (tempString2).substr(2)
|
|
parts2.push_back({ "_index": 0, "t": text })
|
|
if (endsWithGlue):
|
|
parts2.push_back({ "_index": 6 })
|
|
|
|
static func updateLastPart(parts2: Array[Variant], isPartOfAlt: bool) -> Array[Variant]:
|
|
if (parts2.size() > 0):
|
|
var lastPart: Variant = parts2[parts2.size() - 1]
|
|
if (lastPart._index == 0):
|
|
var _g: String = lastPart.t
|
|
var t: String = _g
|
|
parts2.pop_back()
|
|
parts2 = (parts2 + Output.parseLastText(t))
|
|
else:
|
|
pass
|
|
|
|
return parts2
|
|
|
|
static func parseLastText(text: String) -> Array[Variant]:
|
|
var parts2: Array[Variant] = ([] as Array[Variant])
|
|
var tempNumber
|
|
var startIndex: int = -1
|
|
|
|
if (startIndex < 0):
|
|
tempNumber = text.rfind("->")
|
|
else:
|
|
var tempString
|
|
var endIndex: int = startIndex + text.length()
|
|
if (endIndex < 0):
|
|
tempString = text.substr(0)
|
|
else:
|
|
tempString = text.substr(0, endIndex)
|
|
tempNumber = (tempString).rfind("->")
|
|
|
|
var divertIndex: int = tempNumber
|
|
|
|
if (divertIndex != -1):
|
|
if (divertIndex != 0):
|
|
parts2.push_back({ "_index": 0, "t": text.substr(0, divertIndex) })
|
|
var target: String = StringTools.trim(text.substr(divertIndex + 2))
|
|
parts2.push_back({ "_index": 4, "t": target })
|
|
else:
|
|
parts2.push_back({ "_index": 0, "t": text })
|
|
|
|
return parts2
|
|
|
|
static func parseBraceExpression(buffer: HankBuffer) -> Variant:
|
|
if true:
|
|
var _g: Variant = Alt.parse(buffer)
|
|
if (_g._index == 0):
|
|
var _g2: Alt = _g.v
|
|
var altExpression: Alt = _g2
|
|
return { "_index": 1, "a": altExpression }
|
|
else:
|
|
return Output.parseHaxeExpression(buffer)
|
|
|
|
return null
|
|
|
|
static func parseHaxeExpression(buffer: HankBuffer) -> Variant:
|
|
var rawExpression: String = Extensions.unwrap(buffer.findNestedExpression("{", "}", 0, true)).checkValue()
|
|
var hExpression: String = rawExpression.substr(1, rawExpression.length() - 2)
|
|
var checkNext: String = buffer.take(rawExpression.length())
|
|
|
|
return { "_index": 2, "h": hExpression }
|
|
|
|
static func appendNextText(story: Story, fullOutput: String, throwOnFail: String = "") -> String:
|
|
if true:
|
|
var _g: Variant = story.nextFrame()
|
|
if (_g._index == 0):
|
|
var _g2: String = _g.text
|
|
var text: String = _g2
|
|
fullOutput += text
|
|
else:
|
|
if (throwOnFail.length() > 0):
|
|
assert(false, str(throwOnFail))
|
|
|
|
return fullOutput
|