488 lines
13 KiB
GDScript
488 lines
13 KiB
GDScript
class_name HInterface
|
|
|
|
var BOOLEAN_OPS: Array[String] = ["&&", "||", "!"]
|
|
var parser: Parser
|
|
var interp: HankInterp
|
|
var viewCounts: Variant
|
|
|
|
func _init(storyTree: StoryNode, viewCounts2: Variant) -> void:
|
|
self.parser = Parser.new()
|
|
|
|
if true:
|
|
var op: String = "*"
|
|
self.parser.opPriority.__set(op, -2)
|
|
if true:
|
|
var op: String = "&"
|
|
self.parser.opPriority.__set(op, -2)
|
|
if true:
|
|
var op: String = "->"
|
|
self.parser.opPriority.__set(op, -2)
|
|
|
|
self.interp = HankInterp.new(self)
|
|
|
|
if true:
|
|
var v = func(v) -> bool:
|
|
return HInterface.isTruthy(viewCounts2, v)
|
|
self.interp.variables.__set("_isTruthy", v)
|
|
if true:
|
|
var v = func(val):
|
|
return HInterface.valueOf(viewCounts2, val)
|
|
self.interp.variables.__set("_valueOf", v)
|
|
if true:
|
|
var variables: Variant = self.interp.variables
|
|
var v = func(name: String):
|
|
return HInterface.resolveInScope(variables, name)
|
|
self.interp.variables.__set("_resolve", v)
|
|
if true:
|
|
var variables: Variant = self.interp.variables
|
|
var v = func(container, name: String):
|
|
return HInterface.resolveField(variables, container, name)
|
|
self.interp.variables.__set("_resolveField", v)
|
|
|
|
self.viewCounts = viewCounts2
|
|
|
|
func setStory(story: Story) -> void:
|
|
self.interp.setStory(story)
|
|
|
|
func addVariable(identifier: String, value) -> void:
|
|
var this1: Variant = self.interp.variables
|
|
|
|
this1.__set(identifier, value)
|
|
|
|
value
|
|
|
|
func getVariable(identifier: String):
|
|
var this1: Variant = self.interp.variables
|
|
var tempResult = this1.__get(identifier)
|
|
|
|
return tempResult
|
|
|
|
func runEmbeddedHaxe(h: String, scope: Array[Variant]) -> void:
|
|
var this1: Variant = self.interp.variables
|
|
|
|
this1.__set("scope", scope)
|
|
|
|
scope
|
|
var expr: Variant = self.parser.parseString(h, "hscript")
|
|
|
|
expr = self.transmute(expr)
|
|
self.interp.execute(expr)
|
|
|
|
func expr(h: String, scope: Array[Variant]):
|
|
var this1: Variant = self.interp.variables
|
|
|
|
this1.__set("scope", scope)
|
|
|
|
scope
|
|
var expr: Variant = self.parser.parseString(h, "hscript")
|
|
|
|
expr = self.transmute(expr)
|
|
|
|
var val = self.interp.expr(expr)
|
|
|
|
if (val == null):
|
|
assert(false, str("Expression " + h + " evaluated to null"))
|
|
|
|
var val2 = HInterface.valueOf(self.viewCounts, val)
|
|
|
|
return val2
|
|
|
|
func cond(h: String, scope: Array[Variant]) -> bool:
|
|
var val = self.expr(h, scope)
|
|
|
|
return HInterface.isTruthy(self.viewCounts, val)
|
|
|
|
func evaluateExpr(h: String, scope: Array[Variant]) -> String:
|
|
return str(self.expr(h, scope))
|
|
|
|
func boolify(expr: Variant) -> Variant:
|
|
var newExpr = self.transmute(expr)
|
|
|
|
return { "_index": 8, "e": { "_index": 1, "v": "_isTruthy" }, "params": ([newExpr] as Array[Variant]) }
|
|
|
|
func valify(expr: Variant) -> Variant:
|
|
return { "_index": 8, "e": { "_index": 1, "v": "_valueOf" }, "params": ([self.transmute(expr)] as Array[Variant]) }
|
|
|
|
func transmute(expr: Variant):
|
|
if (expr == null):
|
|
return null
|
|
|
|
var tempResult
|
|
|
|
match (expr._index):
|
|
1:
|
|
var _g: String = expr.v
|
|
if true:
|
|
var name: String = _g
|
|
tempResult = { "_index": 8, "e": { "_index": 1, "v": "_resolve" }, "params": ([{ "_index": 0, "c": { "_index": 2, "s": name } }] as Array[Variant]) }
|
|
2:
|
|
var _g: String = expr.n
|
|
var _g1 = expr.t
|
|
var _g2 = expr.e
|
|
if true:
|
|
var name: String = _g
|
|
var nested = _g2
|
|
if true:
|
|
if true:
|
|
var this1: Variant = self.interp.variables
|
|
var v = null
|
|
this1.__set(name, v)
|
|
v
|
|
tempResult = { "_index": 6, "op": "=", "e1": { "_index": 1, "v": name }, "e2": self.transmute(nested) }
|
|
3:
|
|
var _g: Variant = expr.e
|
|
if true:
|
|
var nested: Variant = _g
|
|
tempResult = { "_index": 3, "e": self.transmute(nested) }
|
|
4:
|
|
var _g: Array[Variant] = expr.e
|
|
var nestedExpressions: Array[Variant] = _g
|
|
var tempArray
|
|
if true:
|
|
var _g2: Array[Variant] = ([] as Array[Variant])
|
|
if true:
|
|
var _g1: int = 0
|
|
while (_g1 < nestedExpressions.size()):
|
|
var nested: Variant = nestedExpressions[_g1]
|
|
_g1 += 1
|
|
_g2.push_back(self.transmute(nested))
|
|
tempArray = _g2
|
|
tempResult = { "_index": 4, "e": tempArray }
|
|
5:
|
|
var _g: Variant = expr.e
|
|
var _g1: String = expr.f
|
|
if true:
|
|
var nested: Variant = _g
|
|
var f: String = _g1
|
|
tempResult = { "_index": 8, "e": { "_index": 1, "v": "_resolveField" }, "params": ([self.transmute(nested), { "_index": 0, "c": { "_index": 2, "s": f } }] as Array[Variant]) }
|
|
6:
|
|
var _g: String = expr.op
|
|
var _g1: Variant = expr.e1
|
|
var _g2: Variant = expr.e2
|
|
if true:
|
|
var op: String = _g
|
|
var e1: Variant = _g1
|
|
var e2: Variant = _g2
|
|
if (self.BOOLEAN_OPS.find(op) != -1):
|
|
tempResult = { "_index": 6, "op": op, "e1": self.boolify(e1), "e2": self.boolify(e2) }
|
|
else:
|
|
if (op == "="):
|
|
tempResult = { "_index": 6, "op": op, "e1": e1, "e2": e2 }
|
|
else:
|
|
tempResult = { "_index": 6, "op": op, "e1": self.valify(e1), "e2": self.valify(e2) }
|
|
7:
|
|
var _g: String = expr.op
|
|
var _g1: bool = expr.prefix
|
|
var _g2: Variant = expr.e
|
|
if true:
|
|
var op: String = _g
|
|
var prefix: bool = _g1
|
|
var e: Variant = _g2
|
|
if (self.BOOLEAN_OPS.find(op) != -1):
|
|
tempResult = { "_index": 7, "op": op, "prefix": prefix, "e": self.boolify(e) }
|
|
else:
|
|
tempResult = expr
|
|
8:
|
|
var _g: Variant = expr.e
|
|
var _g1: Array[Variant] = expr.params
|
|
if true:
|
|
var e: Variant = _g
|
|
var params: Array[Variant] = _g1
|
|
if true:
|
|
if (e._index == 5):
|
|
var _g2: Variant = e.e
|
|
var _g3: String = e.f
|
|
if true:
|
|
var innerE: Variant = _g2
|
|
var f: String = _g3
|
|
if true:
|
|
var obj = self.interp.expr(innerE)
|
|
if (obj != null):
|
|
return expr
|
|
else:
|
|
pass
|
|
var tempArray1
|
|
if true:
|
|
var _g2: Array[Variant] = ([] as Array[Variant])
|
|
if true:
|
|
var _g3: int = 0
|
|
while (_g3 < params.size()):
|
|
var ex: Variant = params[_g3]
|
|
_g3 += 1
|
|
_g2.push_back(self.transmute(ex))
|
|
tempArray1 = _g2
|
|
tempResult = { "_index": 8, "e": self.transmute(e), "params": tempArray1 }
|
|
9:
|
|
var _g: Variant = expr.cond
|
|
var _g1: Variant = expr.e1
|
|
var _g2 = expr.e2
|
|
if true:
|
|
var cond: Variant = _g
|
|
var e1: Variant = _g1
|
|
var e2 = _g2
|
|
if true:
|
|
if (e2 == null):
|
|
e2 = { "_index": 0, "c": { "_index": 2, "s": "" } }
|
|
tempResult = { "_index": 9, "cond": self.boolify(cond), "e1": self.transmute(e1), "e2": self.transmute(e2) }
|
|
10:
|
|
var _g: Variant = expr.cond
|
|
var _g1: Variant = expr.e
|
|
if true:
|
|
var cond: Variant = _g
|
|
var e: Variant = _g1
|
|
tempResult = { "_index": 10, "cond": self.boolify(cond), "e": self.transmute(e) }
|
|
11:
|
|
var _g: String = expr.v
|
|
var _g1: Variant = expr.it
|
|
var _g2: Variant = expr.e
|
|
if true:
|
|
var v: String = _g
|
|
var it: Variant = _g1
|
|
var e: Variant = _g2
|
|
tempResult = { "_index": 11, "v": v, "it": self.transmute(it), "e": self.transmute(e) }
|
|
14:
|
|
var _g: Array[Variant] = expr.args
|
|
var _g1: Variant = expr.e
|
|
var _g2 = expr.name
|
|
var _g3 = expr.ret
|
|
if true:
|
|
var args: Array[Variant] = _g
|
|
var e: Variant = _g1
|
|
var name = _g2
|
|
var ret = _g3
|
|
tempResult = { "_index": 14, "args": args, "e": self.transmute(e), "name": name, "ret": ret }
|
|
15:
|
|
var _g = expr.e
|
|
if true:
|
|
var e = _g
|
|
tempResult = { "_index": 15, "e": self.transmute(e) }
|
|
16:
|
|
var _g: Variant = expr.e
|
|
var _g1: Variant = expr.index
|
|
if true:
|
|
var e: Variant = _g
|
|
var index: Variant = _g1
|
|
tempResult = { "_index": 16, "e": self.transmute(e), "index": self.transmute(index) }
|
|
17:
|
|
var _g: Array[Variant] = expr.e
|
|
if true:
|
|
var e: Array[Variant] = _g
|
|
var tempArray2
|
|
if true:
|
|
var _g2: Array[Variant] = ([] as Array[Variant])
|
|
if true:
|
|
var _g1: int = 0
|
|
while (_g1 < e.size()):
|
|
var ex: Variant = e[_g1]
|
|
_g1 += 1
|
|
_g2.push_back(self.transmute(ex))
|
|
tempArray2 = _g2
|
|
tempResult = { "_index": 17, "e": tempArray2 }
|
|
18:
|
|
var _g: String = expr.cl
|
|
var _g1: Array[Variant] = expr.params
|
|
if true:
|
|
var cl: String = _g
|
|
var params: Array[Variant] = _g1
|
|
var tempArray3
|
|
if true:
|
|
var _g2: Array[Variant] = ([] as Array[Variant])
|
|
if true:
|
|
var _g3: int = 0
|
|
while (_g3 < params.size()):
|
|
var ex: Variant = params[_g3]
|
|
_g3 += 1
|
|
_g2.push_back(self.transmute(ex))
|
|
tempArray3 = _g2
|
|
tempResult = { "_index": 18, "cl": cl, "params": tempArray3 }
|
|
19:
|
|
var _g: Variant = expr.e
|
|
if true:
|
|
var e: Variant = _g
|
|
tempResult = { "_index": 19, "e": self.transmute(e) }
|
|
20:
|
|
var _g: Variant = expr.e
|
|
var _g1: String = expr.v
|
|
var _g2 = expr.t
|
|
var _g3: Variant = expr.ecatch
|
|
if true:
|
|
var e: Variant = _g
|
|
var v: String = _g1
|
|
var t = _g2
|
|
var ecatch: Variant = _g3
|
|
tempResult = { "_index": 20, "e": self.transmute(e), "v": v, "t": t, "ecatch": self.transmute(ecatch) }
|
|
21:
|
|
var _g: Array[Variant] = expr.fl
|
|
var fl: Array[Variant] = _g
|
|
var tempArray4
|
|
if true:
|
|
var _g2: Array[Variant] = ([] as Array[Variant])
|
|
if true:
|
|
var _g1: int = 0
|
|
while (_g1 < fl.size()):
|
|
var pair: Variant = fl[_g1]
|
|
_g1 += 1
|
|
_g2.push_back({
|
|
"name": pair.get("name"),
|
|
"e": self.transmute(pair.get("e"))
|
|
})
|
|
tempArray4 = _g2
|
|
tempResult = { "_index": 21, "fl": tempArray4 }
|
|
22:
|
|
var _g: Variant = expr.cond
|
|
var _g1: Variant = expr.e1
|
|
var _g2: Variant = expr.e2
|
|
if true:
|
|
var cond: Variant = _g
|
|
var e1: Variant = _g1
|
|
var e2: Variant = _g2
|
|
tempResult = { "_index": 22, "cond": self.boolify(cond), "e1": self.transmute(e1), "e2": self.transmute(e2) }
|
|
23:
|
|
var _g: Variant = expr.e
|
|
var _g1: Array[Variant] = expr.cases
|
|
var _g2 = expr.defaultExpr
|
|
if true:
|
|
var e: Variant = _g
|
|
var cases: Array[Variant] = _g1
|
|
var defaultExpr = _g2
|
|
var tempArray5
|
|
if true:
|
|
var _g3: Array[Variant] = ([] as Array[Variant])
|
|
if true:
|
|
var _g4: int = 0
|
|
while (_g4 < cases.size()):
|
|
var arm: Variant = cases[_g4]
|
|
_g4 += 1
|
|
var tempArray6
|
|
if true:
|
|
var _g5: Array[Variant] = ([] as Array[Variant])
|
|
if true:
|
|
var _g6: int = 0
|
|
var _g7: Array[Variant] = arm.get("values")
|
|
while (_g6 < _g7.size()):
|
|
var value: Variant = _g7[_g6]
|
|
_g6 += 1
|
|
_g5.push_back(self.transmute(value))
|
|
tempArray6 = _g5
|
|
_g3.push_back({
|
|
"values": tempArray6,
|
|
"expr": self.transmute(arm.get("expr"))
|
|
})
|
|
tempArray5 = _g3
|
|
tempResult = { "_index": 23, "e": self.transmute(e), "cases": tempArray5, "defaultExpr": self.transmute(defaultExpr) }
|
|
24:
|
|
var _g: Variant = expr.cond
|
|
var _g1: Variant = expr.e
|
|
if true:
|
|
var cond: Variant = _g
|
|
var e: Variant = _g1
|
|
tempResult = { "_index": 24, "cond": self.boolify(cond), "e": self.transmute(e) }
|
|
25:
|
|
var _g: String = expr.name
|
|
var _g1: Array[Variant] = expr.args
|
|
var _g2: Variant = expr.e
|
|
if true:
|
|
var name: String = _g
|
|
var args: Array[Variant] = _g1
|
|
var e: Variant = _g2
|
|
var tempArray7
|
|
if true:
|
|
var _g3: Array[Variant] = ([] as Array[Variant])
|
|
if true:
|
|
var _g4: int = 0
|
|
while (_g4 < args.size()):
|
|
var arg: Variant = args[_g4]
|
|
_g4 += 1
|
|
_g3.push_back(self.transmute(arg))
|
|
tempArray7 = _g3
|
|
tempResult = { "_index": 25, "name": name, "args": tempArray7, "e": self.transmute(e) }
|
|
26:
|
|
var _g: Variant = expr.e
|
|
var _g1: Variant = expr.t
|
|
if true:
|
|
var e: Variant = _g
|
|
var t: Variant = _g1
|
|
tempResult = { "_index": 26, "e": self.transmute(e), "t": t }
|
|
_:
|
|
tempResult = expr
|
|
|
|
return tempResult
|
|
|
|
static func resolveInScope(variables: Variant, name: String):
|
|
var scope: Array[Variant] = (variables.__get("scope") as Array[Variant])
|
|
var _g: int = 0
|
|
|
|
while (_g < scope.size()):
|
|
var container = scope[_g]
|
|
_g += 1
|
|
if true:
|
|
var _g2: Variant = HInterface.resolve(variables, container, name)
|
|
match (_g2._index):
|
|
0:
|
|
var _g3 = _g2.v
|
|
var v = _g3
|
|
return v
|
|
1:
|
|
pass
|
|
|
|
assert(false, str("Could not resolve " + name + " in scope " + str(scope) + "."))
|
|
|
|
static func resolveField(variables: Variant, container, name: String):
|
|
return Extensions.unwrap(HInterface.resolve(variables, container, name))
|
|
|
|
static func resolve(variables: Variant, container, name: String) -> Variant:
|
|
if (variables.exists(name)):
|
|
return { "_index": 0, "v": variables.__get(name) }
|
|
else:
|
|
if (((container as Variant) is StoryNode)):
|
|
var node: StoryNode = (container as StoryNode)
|
|
return node.resolve(name)
|
|
else:
|
|
var val = container.get(name)
|
|
if (val != null):
|
|
return { "_index": 0, "v": val }
|
|
else:
|
|
return { "_index": 1 }
|
|
|
|
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 (((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:
|
|
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
|
|
|
|
if (((val as Variant) is StoryNode)):
|
|
var node: StoryNode = (val as StoryNode)
|
|
tempResult = viewCounts2.__get(node)
|
|
else:
|
|
tempResult = val
|
|
|
|
return tempResult
|
|
|
|
static func viewCountOf(viewCounts2: Variant, val) -> Variant:
|
|
var tempResult
|
|
|
|
if (((val as Variant) is StoryNode)):
|
|
var node: StoryNode = (val as StoryNode)
|
|
tempResult = { "_index": 0, "v": viewCounts2.__get(node) }
|
|
else:
|
|
tempResult = { "_index": 1 }
|
|
|
|
return tempResult
|