150 lines
4.3 KiB
Plaintext
150 lines
4.3 KiB
Plaintext
python early hide:
|
|
import inspect
|
|
__register_params = frozenset(inspect.signature(renpy.register_statement).parameters).difference({"name", "parse"})
|
|
def register_decorator(cls):
|
|
"""
|
|
A class decorator which registers a new statement.
|
|
|
|
The name of the statement will be the class name unless a `name` class attribute is present, which should be a string.
|
|
|
|
The `parse` method should be a static method that returns an object which will be passed to the other methods as `self`.
|
|
Returning an instance of the class is disabled for now.
|
|
"""
|
|
# security
|
|
def raiser(*args, **kwargs):
|
|
raise TypeError("Returning an instance of the class is disabled")
|
|
cls.__init__ = raiser
|
|
|
|
name = getattr(cls, "name", cls.__name__)
|
|
parse = getattr(cls, "parse", cls) # left in
|
|
renpy.register_statement(name,
|
|
parse=parse,
|
|
**{k:getattr(cls, k) for k in __register_params.intersection(vars(cls))})
|
|
return cls
|
|
|
|
@register_decorator
|
|
class dynamic:
|
|
block = "possible"
|
|
|
|
@staticmethod
|
|
def parse(l):
|
|
rv = {}
|
|
|
|
def parse_simple(ll):
|
|
target = ll.require(ll.name, "variable name")
|
|
if target in rv:
|
|
ll.error(f"Variable {target} already set in the same dynamic block")
|
|
ll.require("=", "equals sign")
|
|
expression = ll.simple_expression()
|
|
ll.expect_eol()
|
|
rv[target] = expression
|
|
|
|
if l.match(":"):
|
|
l.expect_block("dynamic block")
|
|
l.expect_eol()
|
|
ll = l.subblock_lexer()
|
|
while ll.advance():
|
|
parse_simple(ll)
|
|
else:
|
|
parse_simple(l)
|
|
|
|
return rv
|
|
|
|
def execute(self):
|
|
evaled = {n: eval(e) for n, e in self.items()}
|
|
renpy.dynamic(**evaled)
|
|
|
|
python early:
|
|
def parse_chibi(l):
|
|
who = l.simple_expression()
|
|
action = l.simple_expression()
|
|
|
|
return (who, action)
|
|
|
|
def execute_chibi(p):
|
|
print(f"{p}")
|
|
who, action = p
|
|
func = eval(f"{who}_chibi.{action}")
|
|
|
|
# print(f"Execution: {who} {action}")
|
|
|
|
def lint_chibi(p):
|
|
who, action = p
|
|
try:
|
|
chibi = eval(f"{who}_chibi")
|
|
except Exception:
|
|
renpy.error(f"Character chibi not defined: {who}")
|
|
|
|
def predict_chibi(p):
|
|
who, action = p
|
|
|
|
chibi = eval(f"{who}_chibi")
|
|
doll = eval(f"{who}")
|
|
|
|
layers = (
|
|
l[0] for pose in chibi.poses.keys()
|
|
for k in doll.states.values() if k[0] and k[2]
|
|
for l in k[0].get_layers(k[0]._hash, subpath=posixpath.join("chibi", pose)).values()
|
|
)
|
|
|
|
return layers
|
|
|
|
renpy.register_statement(
|
|
name="chibi",
|
|
parse=parse_chibi,
|
|
execute=execute_chibi,
|
|
lint=lint_chibi,
|
|
predict=predict_chibi,
|
|
)
|
|
|
|
def parse_random(l):
|
|
l.require(":")
|
|
l.expect_eol()
|
|
|
|
ll = l.subblock_lexer()
|
|
blocks = []
|
|
|
|
while ll.advance():
|
|
with ll.catch_error():
|
|
weight = 1.0
|
|
condition = "True"
|
|
|
|
if ll.keyword("block"):
|
|
ll.expect_block("block")
|
|
|
|
block = ll.subblock_lexer().renpy_block()
|
|
|
|
if ll.keyword("weight"):
|
|
weight = float(ll.require(ll.float))
|
|
|
|
if ll.keyword("if"):
|
|
ll.expect_block("if block")
|
|
condition = ll.require(ll.python_expression)
|
|
else:
|
|
block = ll.renpy_statement()
|
|
|
|
blocks.append((block, weight, condition))
|
|
|
|
return {"blocks": blocks}
|
|
|
|
def next_random(p):
|
|
blocks = [(block, weight) for block, weight, condition in p["blocks"] if eval(condition)]
|
|
total_weight = sum(weight for _, weight in blocks)
|
|
n = renpy.random.random() * total_weight
|
|
|
|
for block, weight in blocks:
|
|
if n <= weight:
|
|
break
|
|
else:
|
|
n -= weight
|
|
|
|
return block
|
|
|
|
renpy.register_statement(
|
|
name="random",
|
|
block=True,
|
|
predict_all=True,
|
|
parse=parse_random,
|
|
next=next_random,
|
|
)
|