More GDScript fixes
This commit is contained in:
@@ -448,26 +448,21 @@ static func isTruthy(viewCounts2: Variant, v) -> bool:
|
||||
if (((v as Variant) is StoryNode)):
|
||||
var node: StoryNode = (v as StoryNode)
|
||||
return viewCounts2.__get(node) > 0
|
||||
|
||||
if true:
|
||||
var _g: Variant = Type._typeof(v)
|
||||
match (_g._index):
|
||||
1, 2:
|
||||
return v > 0
|
||||
3:
|
||||
return v
|
||||
_:
|
||||
if (((v as Variant) is String)):
|
||||
var val: String = (v as String)
|
||||
match (val):
|
||||
"false":
|
||||
return false
|
||||
"true":
|
||||
return true
|
||||
_:
|
||||
assert(false, str("" + str(v) + ": " + str(Type._typeof(v)) + " cannot be coerced to a boolean"))
|
||||
if (((v as Variant) is bool)):
|
||||
return v
|
||||
else:
|
||||
if (((v as Variant) is int) || ((v as Variant) is float)):
|
||||
return v > 0
|
||||
else:
|
||||
if (((v as Variant) is String)):
|
||||
if (v == "false"):
|
||||
return false
|
||||
else:
|
||||
assert(false, str("" + str(v) + ": " + str(Type._typeof(v)) + " cannot be coerced to a boolean"))
|
||||
return v.length > 0
|
||||
|
||||
assert(false, str("" + str(v) + " cannot be coerced to a boolean"))
|
||||
|
||||
return false
|
||||
|
||||
static func valueOf(viewCounts2: Variant, val):
|
||||
var tempResult
|
||||
|
||||
351
hank-godot/scripts/HParser.gd
Normal file
351
hank-godot/scripts/HParser.gd
Normal file
@@ -0,0 +1,351 @@
|
||||
class_name HParser
|
||||
|
||||
static var symbols: Array[Variant] = []
|
||||
static var choices: int = 0
|
||||
|
||||
var buffers: Array[HankBuffer] = []
|
||||
var ast: Array[Variant] = []
|
||||
|
||||
func _init() -> void:
|
||||
choices = 0
|
||||
symbols.push_back({
|
||||
"key": "INCLUDE ",
|
||||
"value": HParser.include
|
||||
})
|
||||
symbols.push_back({
|
||||
"key": "<-",
|
||||
"value": HParser.thread
|
||||
})
|
||||
symbols.push_back({
|
||||
"key": "->",
|
||||
"value": HParser.divert
|
||||
})
|
||||
symbols.push_back({
|
||||
"key": "===",
|
||||
"value": HParser.knot
|
||||
})
|
||||
symbols.push_back({
|
||||
"key": "==",
|
||||
"value": HParser.knot
|
||||
})
|
||||
symbols.push_back({
|
||||
"key": "=",
|
||||
"value": HParser.stitch
|
||||
})
|
||||
symbols.push_back({
|
||||
"key": "~",
|
||||
"value": HParser.haxeLine
|
||||
})
|
||||
symbols.push_back({
|
||||
"key": "```",
|
||||
"value": HParser.haxeBlock
|
||||
})
|
||||
symbols.push_back({
|
||||
"key": "-",
|
||||
"value": HParser.gather
|
||||
})
|
||||
symbols.push_back({
|
||||
"key": "*",
|
||||
"value": HParser.choice
|
||||
})
|
||||
symbols.push_back({
|
||||
"key": "+",
|
||||
"value": HParser.choice
|
||||
})
|
||||
symbols.push_back({
|
||||
"key": "#",
|
||||
"value": HParser.tag
|
||||
})
|
||||
|
||||
func parseString(h: String) -> Array[Variant]:
|
||||
var stringBuffer: HankBuffer = HankBuffer.Dummy(h)
|
||||
var parsedAST: Array[Variant] = ([] as Array[Variant])
|
||||
|
||||
while true:
|
||||
var position: Position = stringBuffer.position()
|
||||
stringBuffer.skipWhitespace("")
|
||||
if (stringBuffer.isEmpty()):
|
||||
break
|
||||
var expr: Variant = HParser.parseExpr(stringBuffer, position)
|
||||
match (expr._index):
|
||||
0:
|
||||
var _g: String = expr.path
|
||||
var file: String = _g
|
||||
assert(false, str("cannot include files from within an embedded Hank block"))
|
||||
6:
|
||||
pass
|
||||
_:
|
||||
parsedAST.push_back({
|
||||
"position": position,
|
||||
"expr": expr
|
||||
})
|
||||
if !(!stringBuffer.isEmpty()):
|
||||
break
|
||||
|
||||
return parsedAST
|
||||
|
||||
func parseFile(f: String, files = null, includedFile: bool = false) -> Array[Variant]:
|
||||
var directory: String = ""
|
||||
var tempNumber
|
||||
var startIndex: int = -1
|
||||
|
||||
if (startIndex < 0):
|
||||
tempNumber = f.rfind("/")
|
||||
else:
|
||||
var tempString
|
||||
var endIndex: int = startIndex + f.length()
|
||||
if (endIndex < 0):
|
||||
tempString = f.substr(0)
|
||||
else:
|
||||
tempString = f.substr(0, endIndex)
|
||||
tempNumber = (tempString).rfind("/")
|
||||
|
||||
var lastSlashIdx: int = tempNumber
|
||||
|
||||
if (lastSlashIdx != -1):
|
||||
directory = f.substr(0, lastSlashIdx + 1)
|
||||
f = f.substr(lastSlashIdx + 1)
|
||||
|
||||
if true:
|
||||
var _this: Array[HankBuffer] = self.buffers
|
||||
var x: HankBuffer = HankBuffer.FromFile(directory + f, files)
|
||||
if true:
|
||||
_this.insert(0, x)
|
||||
null
|
||||
|
||||
while (self.buffers.size() > 0):
|
||||
var position: Position = self.buffers[0].position()
|
||||
self.buffers[0].skipWhitespace("")
|
||||
if (self.buffers[0].isEmpty()):
|
||||
var _this: Array[HankBuffer] = self.buffers
|
||||
var x: HankBuffer = self.buffers[0]
|
||||
var index: int = _this.find(x)
|
||||
if (index >= 0):
|
||||
_this.remove_at(index)
|
||||
true
|
||||
else:
|
||||
false
|
||||
else:
|
||||
var expr: Variant = HParser.parseExpr(self.buffers[0], position)
|
||||
match (expr._index):
|
||||
0:
|
||||
var _g: String = expr.path
|
||||
var file: String = _g
|
||||
self.parseFile(directory + file, files, true)
|
||||
6:
|
||||
pass
|
||||
_:
|
||||
self.ast.push_back({
|
||||
"position": position,
|
||||
"expr": expr
|
||||
})
|
||||
|
||||
var parsedAST: Array[Variant] = self.ast
|
||||
|
||||
if (!includedFile):
|
||||
self.ast = ([] as Array[Variant])
|
||||
|
||||
return parsedAST
|
||||
|
||||
static func parseExpr(buffer: HankBuffer, position: Position) -> Variant:
|
||||
var line: Variant = buffer.peekLine("")
|
||||
|
||||
match (line._index):
|
||||
0:
|
||||
var _g: String = line.v
|
||||
var line2: String = _g
|
||||
if (StringTools.trim(line2).length() == 0):
|
||||
return { "_index": 6 }
|
||||
var _g2: int = 0
|
||||
var _g1: Array[Variant] = symbols
|
||||
while (_g2 < _g1.size()):
|
||||
var rule: Variant = _g1[_g2]
|
||||
_g2 += 1
|
||||
var symbol: String = rule.get("key")
|
||||
var rule2 = rule.get("value")
|
||||
if (StringTools.startsWith(StringTools.trim(line2), symbol)):
|
||||
buffer.skipWhitespace("")
|
||||
return rule2.call(buffer, position)
|
||||
return HParser.output(buffer, position)
|
||||
1:
|
||||
assert(false, str("Tried to parse expr when no lines were left in file"))
|
||||
|
||||
return null
|
||||
|
||||
static func lineTokens(buffer: HankBuffer, n: int, position: Position, throwOnMismatch: bool = true, rtrim: bool = true) -> Array[String]:
|
||||
var line: String = Extensions.unwrap(buffer.takeLine(""))
|
||||
|
||||
if (rtrim):
|
||||
var tempRight
|
||||
var l: int = line.length()
|
||||
var r: int = 0
|
||||
while (r < l && StringTools.isSpace(line, l - r - 1)):
|
||||
r += 1
|
||||
if (r > 0):
|
||||
tempRight = line.substr(0, l - r)
|
||||
else:
|
||||
tempRight = line
|
||||
line = tempRight
|
||||
|
||||
var tokens: Array[String] = Array(Array(line.split(" ")), Variant.Type.TYPE_STRING, "", null)
|
||||
|
||||
if (tokens.size() != n):
|
||||
if (throwOnMismatch):
|
||||
assert(false, str("Wrong number of tokens at " + str(position) + ": " + str(tokens.size()) + " tokens provided--should be " + str(n) + ".\nLine: `" + line + "`\nTokens: " + str(tokens)))
|
||||
else:
|
||||
return tokens.slice(0, n)
|
||||
|
||||
return tokens
|
||||
|
||||
static func include(buffer: HankBuffer, position: Position) -> Variant:
|
||||
var tokens: Array[String] = HParser.lineTokens(buffer, 2, position, true, true)
|
||||
|
||||
return { "_index": 0, "path": tokens[1] }
|
||||
|
||||
static func divert(buffer: HankBuffer, position: Position) -> Variant:
|
||||
var line: String = Extensions.unwrap(buffer.takeLine(""))
|
||||
var _g: Array[String] = ([] as Array[String])
|
||||
var _g1: int = 0
|
||||
var _g2: Array[String] = Array(Array(line.split("->")), Variant.Type.TYPE_STRING, "", null)
|
||||
|
||||
while (_g1 < _g2.size()):
|
||||
var t: String = _g2[_g1]
|
||||
_g1 += 1
|
||||
_g.push_back(StringTools.trim(t))
|
||||
|
||||
var targets: Array[String] = (_g).slice(1)
|
||||
|
||||
return { "_index": 2, "targets": targets }
|
||||
|
||||
static func thread(buffer: HankBuffer, position: Position) -> Variant:
|
||||
buffer.drop("<-")
|
||||
buffer.skipWhitespace("")
|
||||
|
||||
var tokens: Array[String] = HParser.lineTokens(buffer, 1, position, true, true)
|
||||
|
||||
return { "_index": 3, "target": tokens[0] }
|
||||
|
||||
static func output(buffer: HankBuffer, position: Position) -> Variant:
|
||||
return { "_index": 1, "o": Output.parse(buffer, false) }
|
||||
|
||||
static func knot(buffer: HankBuffer, position: Position) -> Variant:
|
||||
buffer.drop("==")
|
||||
|
||||
if (buffer.peekAhead(0, 1) == "="):
|
||||
buffer.drop("=")
|
||||
|
||||
buffer.skipWhitespace("")
|
||||
|
||||
var tokens: Array[String] = HParser.lineTokens(buffer, 1, position, false, true)
|
||||
|
||||
return { "_index": 4, "name": tokens[0] }
|
||||
|
||||
static func stitch(buffer: HankBuffer, position: Position) -> Variant:
|
||||
buffer.drop("=")
|
||||
buffer.skipWhitespace("")
|
||||
|
||||
var tokens: Array[String] = HParser.lineTokens(buffer, 1, position, false, true)
|
||||
|
||||
return { "_index": 5, "name": tokens[0] }
|
||||
|
||||
static func haxeLine(buffer: HankBuffer, position: Position) -> Variant:
|
||||
buffer.drop("~")
|
||||
|
||||
return { "_index": 7, "haxe": Extensions.unwrap(buffer.takeLine("lr")) }
|
||||
|
||||
static func gather(buffer: HankBuffer, position: Position) -> Variant:
|
||||
var depth: int = buffer.countConsecutive("-")
|
||||
|
||||
buffer.skipWhitespace("")
|
||||
|
||||
var label: Variant = buffer.expressionIfNext("(", ")")
|
||||
|
||||
buffer.skipWhitespace("\n")
|
||||
|
||||
return { "_index": 9, "label": label, "depth": depth, "expr": { "_index": 6 } }
|
||||
|
||||
static func choice(buffer: HankBuffer, position: Position) -> Variant:
|
||||
var symbol: String = buffer.peek(1)
|
||||
var onceOnly: bool = symbol == "*"
|
||||
var depth: int = buffer.countConsecutive(symbol)
|
||||
|
||||
buffer.skipWhitespace("")
|
||||
|
||||
var label: Variant = buffer.expressionIfNext("(", ")")
|
||||
|
||||
buffer.skipWhitespace("")
|
||||
|
||||
var condition: Variant = buffer.expressionIfNext("{", "}?")
|
||||
|
||||
buffer.skipWhitespace("")
|
||||
|
||||
var output: Output = Output.parse(buffer, false)
|
||||
var divertTarget: Variant = output.takeInlineDivert()
|
||||
|
||||
choices += 1
|
||||
|
||||
var tempNumber: int = choices - 1
|
||||
|
||||
return { "_index": 10, "c": {
|
||||
"id": tempNumber,
|
||||
"onceOnly": onceOnly,
|
||||
"label": label,
|
||||
"condition": condition,
|
||||
"depth": depth,
|
||||
"output": output,
|
||||
"divertTarget": divertTarget,
|
||||
"tags": ([] as Array[String])
|
||||
} }
|
||||
|
||||
static func tag(buffer: HankBuffer, position: Position) -> Variant:
|
||||
buffer.drop("#")
|
||||
|
||||
var tagLine: String = Extensions.unwrap(buffer.takeLine("lr"))
|
||||
var tags: Array[String] = Extensions.tokenize(tagLine)
|
||||
var expr: Variant = HParser.parseExpr(buffer, position)
|
||||
|
||||
if (expr._index == 10):
|
||||
var _g: Variant = expr.c
|
||||
var c: Variant = _g
|
||||
c.set("tags", tags)
|
||||
else:
|
||||
haxe_Log.trace.call("Warning! Can't apply tags to " + str(expr), {
|
||||
"fileName": "../hank/HParser.hx",
|
||||
"lineNumber": 234,
|
||||
"className": "hank.HParser",
|
||||
"methodName": "tag"
|
||||
})
|
||||
|
||||
return expr
|
||||
|
||||
static func haxeBlock(buffer: HankBuffer, position: Position) -> Variant:
|
||||
buffer.drop("```\n")
|
||||
|
||||
var rawContents: String = Extensions.unwrap(buffer.takeUntil((["```"] as Array[String]), false, true)).get("output")
|
||||
var processedContents: String = ""
|
||||
var blockBuffer: HankBuffer = HankBuffer.Dummy(rawContents)
|
||||
|
||||
while true:
|
||||
var nextLine: String = Extensions.unwrap(blockBuffer.takeLine("lr"))
|
||||
if (nextLine == ",,,"):
|
||||
var embeddedHankBlock: String = Extensions.unwrap(blockBuffer.takeUntil(([",,,"] as Array[String]), false, true)).get("output")
|
||||
processedContents += "story.runEmbeddedHank(\"" + HParser.escapeQuotes(embeddedHankBlock) + "\"); "
|
||||
else:
|
||||
if (StringTools.startsWith(nextLine, ",")):
|
||||
nextLine = StringTools.trim(nextLine.substr(1))
|
||||
processedContents += "story.runEmbeddedHank(\"" + HParser.escapeQuotes(nextLine) + "\"); "
|
||||
else:
|
||||
processedContents += nextLine + " "
|
||||
if !(!blockBuffer.isEmpty()):
|
||||
break
|
||||
|
||||
return { "_index": 8, "haxe": processedContents }
|
||||
|
||||
static func escapeQuotes(s: String) -> String:
|
||||
var escaped: String = s
|
||||
|
||||
escaped = StringTools.replace(escaped, "'", "\\'")
|
||||
escaped = StringTools.replace(escaped, "\"", "\\\"")
|
||||
|
||||
return escaped
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -9,7 +9,7 @@ var storyTree: StoryNode
|
||||
var viewCounts: Variant
|
||||
var nodeScopes: Array[StoryNode]
|
||||
var altInstances: Variant = haxe_ds_ObjectMap.new()
|
||||
var parser: Parser
|
||||
var parser: HParser
|
||||
var embedMode: EmbedMode.EmbedMode = EmbedMode.EmbedMode.Tunnel
|
||||
var embeddedBlocks: Array[Story] = []
|
||||
var parent: Variant = { "_index": 1 }
|
||||
@@ -17,7 +17,7 @@ var choicesTaken: Array[int] = []
|
||||
var weaveDepth: int = 0
|
||||
var storedFrame: Variant = { "_index": 1 }
|
||||
|
||||
func _init(r: Random, p: Parser, ast2: Array[Variant], st: StoryNode, sc: Array[StoryNode], vc: Variant, hi: HInterface) -> void:
|
||||
func _init(r: Random, p: HParser, ast2: Array[Variant], st: StoryNode, sc: Array[StoryNode], vc: Variant, hi: HInterface) -> void:
|
||||
self.insertionHooks = haxe_ds_StringMap.new()
|
||||
self.random = r
|
||||
self.parser = p
|
||||
@@ -341,6 +341,8 @@ func nextChoiceFrame() -> Variant:
|
||||
self.weaveDepth = fallback.get("choiceInfo").get("depth") + 1
|
||||
return self.nextFrame()
|
||||
|
||||
return null
|
||||
|
||||
func traceChoiceArray(choices: Array[Variant]) -> void:
|
||||
var _g: int = 0
|
||||
|
||||
@@ -367,14 +369,14 @@ func traceChoiceArray(choices: Array[Variant]) -> void:
|
||||
tempRight = result
|
||||
haxe_Log.trace.call("" + ChoiceExtension.toString(choiceInfo) + ": #" + tempRight, {
|
||||
"fileName": "../hank/Story.hx",
|
||||
"lineNumber": 373,
|
||||
"lineNumber": 374,
|
||||
"className": "hank.Story",
|
||||
"methodName": "traceChoiceArray"
|
||||
})
|
||||
|
||||
haxe_Log.trace.call("---", {
|
||||
"fileName": "../hank/Story.hx",
|
||||
"lineNumber": 375,
|
||||
"lineNumber": 376,
|
||||
"className": "hank.Story",
|
||||
"methodName": "traceChoiceArray"
|
||||
})
|
||||
@@ -439,6 +441,8 @@ func fallbackChoice() -> Variant:
|
||||
else:
|
||||
assert(false, str("there is no fallback choice!"))
|
||||
|
||||
return null
|
||||
|
||||
func gotoNextGather() -> void:
|
||||
var gatherIndex: int = ASTExtension.findNextGather(self.ast, self.currentFile(), self.exprIndex + 1, self.weaveDepth)
|
||||
|
||||
@@ -758,7 +762,7 @@ static func FromAST(script: String, ast2: Array[Variant], randomSeed = null) ->
|
||||
var nodeScopes2: Array[StoryNode] = ([storyTree2] as Array[StoryNode])
|
||||
var viewCounts2: Variant = storyTree2.createViewCounts()
|
||||
var hInterface2: HInterface = HInterface.new(storyTree2, viewCounts2)
|
||||
var story: Story = Story.new(random2, Parser.new(), ast2, storyTree2, nodeScopes2, viewCounts2, hInterface2)
|
||||
var story: Story = Story.new(random2, HParser.new(), ast2, storyTree2, nodeScopes2, viewCounts2, hInterface2)
|
||||
|
||||
hInterface2.setStory(story)
|
||||
hInterface2.addVariable("story", story)
|
||||
@@ -768,7 +772,7 @@ static func FromAST(script: String, ast2: Array[Variant], randomSeed = null) ->
|
||||
return story
|
||||
|
||||
static func FromFile(script: String, files = null, randomSeed = null) -> Story:
|
||||
var parser2: Parser = Parser.new()
|
||||
var parser2: HParser = HParser.new()
|
||||
var ast2: Array[Variant] = parser2.parseFile(script, files, false)
|
||||
|
||||
return Story.FromAST(script, ast2, randomSeed)
|
||||
|
||||
@@ -46,6 +46,7 @@
|
||||
"IntIterator.gd",
|
||||
"HankBuffer.gd",
|
||||
"HankAssert.gd",
|
||||
"HParser.gd",
|
||||
"HInterface.gd",
|
||||
"Extensions.gd",
|
||||
"Exception.gd",
|
||||
@@ -53,7 +54,7 @@
|
||||
"CallStack.gd",
|
||||
"Alt.gd"
|
||||
],
|
||||
"id": 29,
|
||||
"id": 33,
|
||||
"wasCached": false,
|
||||
"version": 1
|
||||
}
|
||||
Reference in New Issue
Block a user