LoafyLemon
9d76d6088f
* Added IfExpr Action. * Added string evals for If func. * Added reset_action method for RoomObject class. * Added new actions appropriate for room relevant objects. * Fixed a potential issue with reset_variables method within Events class. * Fixed single button radius calculation in wheel menu * Fixed crash if a null list of actions was supplied to create_wheelmenu method. * Converted intro to use wheel menu actions. * Split existing room object labels where it made sense.
423 lines
15 KiB
Plaintext
423 lines
15 KiB
Plaintext
init python:
|
|
if renpy.android:
|
|
settings.default("crashdefendersetting", 0)
|
|
|
|
# Attempts at fixing the texture leak plaguing
|
|
# android devices, mainly running on Android11 & Android 12.
|
|
class Android11TextureLeakFix(NoRollback):
|
|
def __init__(self, limit=100):
|
|
self.statements = 0
|
|
|
|
self.set_mode(settings.get("crashdefendersetting"))
|
|
|
|
def set_mode(self, mode):
|
|
if mode == 3:
|
|
self.limit = 15
|
|
elif mode == 2:
|
|
self.limit = 25
|
|
elif mode == 1:
|
|
self.limit = 55
|
|
else:
|
|
self.limit = 0
|
|
|
|
def __call__(self, name):
|
|
if renpy.is_init_phase() or self.limit == 0:
|
|
return
|
|
|
|
self.statements += 1
|
|
|
|
if self.statements > self.limit:
|
|
self.statements = 0
|
|
|
|
# Big thanks to Andykl (https://github.com/Andykl)
|
|
# for finding the issue and inventing this workaround.
|
|
# https://github.com/renpy/renpy/issues/3643
|
|
|
|
cache = renpy.display.im.cache
|
|
cache_size = cache.get_total_size()
|
|
cache_limit = cache.cache_limit * 0.95
|
|
|
|
if cache_size >= cache_limit:
|
|
if config.developer:
|
|
print(f"Cache limit reached, purging cache... ({cache_size}/{cache_limit})\n{renpy.get_filename_line()}")
|
|
|
|
cache.clear()
|
|
|
|
if renpy.game.interface is not None:
|
|
if config.developer:
|
|
print(f"Statements limit reached, cleaning textures... ({self.limit})\n{renpy.get_filename_line()}")
|
|
|
|
renpy.game.interface.full_redraw = True
|
|
renpy.game.interface.restart_interaction = True
|
|
|
|
if renpy.display.draw is not None:
|
|
renpy.display.draw.kill_textures()
|
|
|
|
renpy.display.render.free_memory()
|
|
|
|
crashdefender = Android11TextureLeakFix()
|
|
|
|
config.statement_callbacks.append(crashdefender)
|
|
|
|
python early hide:
|
|
import functools
|
|
|
|
if renpy.windows:
|
|
# On windows, Renpy does not support backslashes in some of its functions,
|
|
# but because the code needs to be platform-independent,
|
|
# we require to monkey patch those functions in order
|
|
# to remain compatible with all platforms without losing functionality.
|
|
|
|
@renpy.pure
|
|
def _loadable(filename):
|
|
filename = filename.replace("\\", "/")
|
|
|
|
return renpy.loader.loadable(filename)
|
|
|
|
renpy.loadable = _loadable
|
|
|
|
# renpy.list_files does not use cached results, let's fix that.
|
|
|
|
@functools.cache
|
|
def _list_files(common=False):
|
|
rv = [fn for dir, fn in renpy.loader.listdirfiles(common) if not fn.startswith("saves/")]
|
|
rv.sort()
|
|
return rv
|
|
|
|
renpy.list_files = _list_files
|
|
|
|
# Default focus behaviour restarts the interaction whenever
|
|
# any element that contains a tooltip is being hovered or unhovered.
|
|
# Restarting interactions in a short timespan causes massive lag spikes,
|
|
# in order to fix it, we'll refresh just the tooltip screen and skip the rest.
|
|
|
|
def set_focused(widget, arg, screen):
|
|
global _tooltip
|
|
renpy.display.focus.argument = arg
|
|
renpy.display.focus.screen_of_focused = screen
|
|
|
|
if screen is not None:
|
|
renpy.display.focus.screen_of_focused_names = { screen.screen_name[0], screen.tag }
|
|
else:
|
|
renpy.display.focus.screen_of_focused_names = set()
|
|
|
|
renpy.game.context().scene_lists.focused = widget
|
|
renpy.display.tts.displayable(widget)
|
|
|
|
# Figure out the tooltip.
|
|
|
|
_tooltip = widget._get_tooltip() if widget else None
|
|
|
|
# setattr(renpy.store, "widget", widget) # DEBUG
|
|
|
|
# if renpy.display.focus.tooltip != new_tooltip:
|
|
# renpy.display.focus.tooltip = new_tooltip
|
|
# renpy.display.focus.capture_focus("tooltip")
|
|
|
|
# renpy.exports.restart_interaction()
|
|
|
|
# if renpy.display.focus.tooltip is not None:
|
|
# renpy.display.focus.last_tooltip = renpy.display.focus.tooltip
|
|
# renpy.display.focus.screen_of_last_focused_names = renpy.display.focus.screen_of_focused_names
|
|
|
|
renpy.display.focus.set_focused = set_focused
|
|
|
|
# Add callbacks for label calls and jumps, we use them for the event class
|
|
# in order to figure out if the event was completed or if it's just a call,
|
|
# and also for debugging.
|
|
# class _CallException(Exception):
|
|
|
|
# from_current = False
|
|
|
|
# def __init__(self, label, args, kwargs, from_current=False):
|
|
# Exception.__init__(self)
|
|
|
|
# self.label = label
|
|
# self.args = args
|
|
# self.kwargs = kwargs
|
|
# self.from_current = from_current
|
|
|
|
# for i in renpy.config.call_callbacks:
|
|
# i(label, args, kwargs)
|
|
|
|
# def __reduce__(self):
|
|
# return (_CallException, (self.label, self.args, self.kwargs, self.from_current))
|
|
|
|
# class _JumpException(Exception):
|
|
|
|
# def __init__(self, label):
|
|
# for i in renpy.config._label_callbacks:
|
|
# i(label)
|
|
|
|
# class _JumpOutException(Exception):
|
|
|
|
# def __init__(self, label):
|
|
# for i in renpy.config._label_callbacks:
|
|
# i(label)
|
|
|
|
# renpy.game.CONTROL_EXCEPTIONS = tuple(list(renpy.game.CONTROL_EXCEPTIONS) + [_CallException, _JumpException, _JumpOutException])
|
|
# renpy.game.CallException = _CallException
|
|
# renpy.game.JumpException = _JumpException
|
|
# renpy.game.JumpOutException = _JumpOutException
|
|
|
|
# class _Call(renpy.ast.Call):
|
|
# def execute(self):
|
|
# statement_name("call")
|
|
|
|
# label = self.label
|
|
# if self.expression:
|
|
# label = renpy.python.py_eval(label)
|
|
|
|
# rv = renpy.game.context().call(label, return_site=self.next.name)
|
|
# next_node(rv)
|
|
# renpy.game.context().abnormal = True
|
|
|
|
# if self.arguments:
|
|
# args, kwargs = self.arguments.evaluate()
|
|
# renpy.store._args = args
|
|
# renpy.store._kwargs = kwargs
|
|
# else:
|
|
# renpy.store._args = None
|
|
# renpy.store._kwargs = None
|
|
|
|
# setattr(store, "_last_label_call", label)
|
|
|
|
# if config.developer:
|
|
# last_label = getattr(store, "_last_label_jump", None)
|
|
# caller_id = renpy.get_filename_line()
|
|
# print(f"Called '{stdcol.PURPLE}{label}{stdcol.END}' from '{stdcol.PURPLE}{last_label}{stdcol.END}' with ARGS:'{stdcol.YELLOW}{args}{stdcol.END}' KWARGS:'{stdcol.YELLOW}{kwargs}{stdcol.END}' caller '{stdcol.BLUE}{caller_id}{stdcol.END}'...")
|
|
|
|
# class _Jump(renpy.ast.Jump):
|
|
# def execute(self):
|
|
|
|
# statement_name("jump")
|
|
|
|
# target = self.target
|
|
# if self.expression:
|
|
# target = renpy.python.py_eval(target)
|
|
|
|
# rv = renpy.game.script.lookup(target)
|
|
# renpy.game.context().abnormal = True
|
|
|
|
# next_node(rv)
|
|
|
|
# setattr(store, "_last_label_jump", target)
|
|
|
|
# if config.developer:
|
|
# last_label = getattr(store, "_last_label_jump", None)
|
|
# caller_id = renpy.get_filename_line()
|
|
# print(f"Jumped '{stdcol.PURPLE}{target}{stdcol.END}' from '{stdcol.PURPLE}{last_label}{stdcol.END}' with ARGS:'{stdcol.YELLOW}{args}{stdcol.END}' KWARGS:'{stdcol.YELLOW}{kwargs}{stdcol.END}' caller '{stdcol.BLUE}{caller_id}{stdcol.END}'...")
|
|
|
|
# renpy.ast.Call = _Call
|
|
# renpy.ast.Jump = _Jump
|
|
|
|
default _last_label = None
|
|
|
|
python early:
|
|
def catch_label_call(label, abnormal):
|
|
if config.developer:
|
|
# last_label = renpy.game.context().come_from_label <- Doesn't work as expected, other methods are just as unreliable.
|
|
# from '{stdcol.PURPLE}{last_label}{stdcol.END}'
|
|
caller_id = renpy.get_filename_line()
|
|
print(f"Reached '{stdcol.PURPLE}{label}{stdcol.END}' caller '{stdcol.BLUE}{caller_id}{stdcol.END}'...")
|
|
|
|
setattr(store, "_last_label", label)
|
|
|
|
renpy.config.label_callbacks.append(catch_label_call)
|
|
|
|
# def catch_label_call(label, args, kwargs):
|
|
# # Used in event queue system to differentiate jumps from calls.
|
|
# if config.developer:
|
|
# last_label = getattr(store, "_last_label_jump", None)
|
|
# caller_id = renpy.get_filename_line()
|
|
# print(f"Called '{stdcol.PURPLE}{label}{stdcol.END}' from '{stdcol.PURPLE}{last_label}{stdcol.END}' with ARGS:'{stdcol.YELLOW}{args}{stdcol.END}' KWARGS:'{stdcol.YELLOW}{kwargs}{stdcol.END}' caller '{stdcol.BLUE}{caller_id}{stdcol.END}'...")
|
|
|
|
# setattr(store, "_last_label_call", label)
|
|
|
|
# def catch_label_jump(label):
|
|
# # if getattr(store, "_last_label_call", None) == label:
|
|
# # return
|
|
|
|
# if config.developer:
|
|
# last_label = getattr(store, "_last_label_jump", None)
|
|
# caller_id = renpy.get_filename_line()
|
|
# print(f"Jumped '{stdcol.PURPLE}{label}{stdcol.END}' from '{stdcol.PURPLE}{last_label}{stdcol.END}' caller '{stdcol.BLUE}{caller_id}{stdcol.END}'...")
|
|
|
|
# setattr(store, "_last_label_jump", label)
|
|
|
|
# renpy.config.call_callbacks = [catch_label_call] # CallException callback
|
|
# renpy.config._label_callbacks = [catch_label_jump] # JumpException and JumpOutException callbacks; Please note this is not the same as `config.label_callbacks`
|
|
|
|
init -100 python:
|
|
# Due to the sheer number of Doll-type objects we create and keep per each character,
|
|
# we have to use each and every optimization technique we can get our hands on.
|
|
# The below code implements revertable __slots__ support, which reduces memory,
|
|
# without losing any functionality relevant to the objects that are using it.
|
|
#
|
|
# The code is taken from a PR proposed by Andykl:
|
|
# https://github.com/renpy/renpy/pull/3282
|
|
|
|
class _RevertableObject(_object):
|
|
# Reimplementation of the Ren'py class,
|
|
# but with slots support.
|
|
def __new__(cls, *args, **kwargs):
|
|
self = super(_RevertableObject, cls).__new__(cls)
|
|
|
|
log = renpy.game.log
|
|
if log is not None:
|
|
log.mutated[id(self)] = None
|
|
|
|
return self
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
if (args or kwargs) and renpy.config.developer:
|
|
raise TypeError("object() takes no parameters.")
|
|
|
|
__setattr__ = renpy.revertable.mutator(object.__setattr__) # type: ignore
|
|
__delattr__ = renpy.revertable.mutator(object.__delattr__) # type: ignore
|
|
|
|
def _clean(self):
|
|
return None
|
|
|
|
def _compress(self, clean):
|
|
return clean
|
|
|
|
def _rollback(self, compressed):
|
|
pass
|
|
|
|
class SlottedObject(_RevertableObject):
|
|
__slots__ = ()
|
|
|
|
def __init_subclass__(cls):
|
|
if renpy.config.developer:
|
|
if hasattr(cls, "__getstate__"):
|
|
raise TypeError("slotted_object subclasses can't have "
|
|
"__getstate__ method. Use __reduce__ instead.")
|
|
|
|
for slot in cls.__dict__.get("__slots__", ()):
|
|
if slot.startswith("__") and not slot.endswith("__"):
|
|
raise ValueError("slotted_object __slots__ can not be mangled. "
|
|
"If you need it, mangle it by yourself.")
|
|
|
|
def _clean(self):
|
|
rv = object.__reduce_ex__(self, 2)[2]
|
|
# We need to make a copy of __dict__ to avoid its futher mutations.
|
|
|
|
# No attributes are set
|
|
if rv is None:
|
|
rv = { }
|
|
|
|
# Only __dict__ have attributes
|
|
elif isinstance(rv, dict):
|
|
rv = rv.copy()
|
|
|
|
# Only __slots__ have attributes
|
|
elif rv[0] is None:
|
|
rv = rv[1]
|
|
|
|
# Otherwise it is (__dict__, __slots__), so merge it together
|
|
else:
|
|
rv = dict(rv[0], **rv[1])
|
|
|
|
return rv
|
|
|
|
def _rollback(self, compressed):
|
|
if hasattr(self, "__dict__"):
|
|
self.__dict__.clear()
|
|
|
|
for k, v in compressed.items():
|
|
setattr(self, k, v)
|
|
|
|
# The original does not support nested actions.
|
|
# Nor does it support string expressions evaluated at runtime.
|
|
@renpy.pure
|
|
def If(expression, true=None, false=None):
|
|
|
|
if isinstance(expression, Action):
|
|
expression = expression()
|
|
elif isinstance(expression, str):
|
|
expression = eval(expression)
|
|
|
|
return true if expression else false
|
|
|
|
@renpy.pure
|
|
class IfExpr(Action):
|
|
def __init__(self, expr, true=None, false=None):
|
|
self.expr = expr
|
|
self.true = true
|
|
self.false = false
|
|
|
|
def __call__(self):
|
|
result = If(self.expr, self.true, self.false)
|
|
|
|
if isinstance(result, Action):
|
|
return result()
|
|
return result
|
|
|
|
# Adds support for nested stores for replay scope
|
|
def _call_replay(label, scope={}):
|
|
renpy.display.focus.clear_focus()
|
|
|
|
renpy.game.log.complete()
|
|
|
|
old_log = renpy.game.log
|
|
renpy.game.log = renpy.python.RollbackLog()
|
|
|
|
sb = renpy.python.StoreBackup()
|
|
renpy.python.clean_stores()
|
|
|
|
context = renpy.execution.Context(True)
|
|
renpy.game.contexts.append(context)
|
|
|
|
if renpy.display.interface is not None:
|
|
renpy.display.interface.enter_context()
|
|
|
|
# This has to be here, to ensure the scope stuff works.
|
|
renpy.exports.execute_default_statement()
|
|
|
|
for k, v in renpy.config.replay_scope.items():
|
|
stores = k.split(".")
|
|
current_obj = renpy.store
|
|
|
|
for store in stores[:-1]:
|
|
current_obj = getattr(current_obj, store)
|
|
|
|
setattr(current_obj, stores[-1], v)
|
|
|
|
for k, v in scope.items():
|
|
stores = k.split(".")
|
|
current_obj = renpy.store
|
|
|
|
for store in stores[:-1]:
|
|
current_obj = getattr(current_obj, store)
|
|
|
|
setattr(current_obj, stores[-1], v)
|
|
|
|
renpy.store._in_replay = label
|
|
|
|
try:
|
|
|
|
context.goto_label("_start_replay")
|
|
renpy.execution.run_context(False)
|
|
|
|
except renpy.game.EndReplay:
|
|
pass
|
|
|
|
finally:
|
|
|
|
context.pop_all_dynamic()
|
|
|
|
renpy.game.contexts.pop()
|
|
renpy.game.log = old_log
|
|
sb.restore()
|
|
|
|
if renpy.game.interface and renpy.game.interface.restart_interaction and renpy.game.contexts:
|
|
renpy.game.contexts[-1].scene_lists.focused = None
|
|
|
|
renpy.config.skipping = None
|
|
|
|
if renpy.config.after_replay_callback:
|
|
renpy.config.after_replay_callback()
|
|
|
|
renpy.call_replay = _call_replay
|