API

ModGame

The modding library.

This file contains all the functions needed to modify and extend AwSW. Please note that it contains minor spoilers

This file is free software under the MIT license.

class modloader.modgame.AWSWEndingHooks(base_)

The ending hooks for the game

get_ending_picker_menu()

Get Chapter 5’s menu on who to go to the fireworks.

Get an instance of AWSWMenuHooks for use of making new choices on who to go to the festival with.

Returns:An instance of AWSWMenuHooks

get_post_izumi_node()

Get the post-true Izumi’s tear scene

Returns:A renpy.ast.Say node object.

hook_post_evil_ending(node)

Hook node to the post-evil ending node

Todo

Program this.

hook_post_true_ending(node)

Hook node to the post-true ending node

Returns:An ASTHook instance

hook_route_ending(route)

Hook node to the end of all routes

Todo

Program this.

class modloader.modgame.AWSWHomeHook(base_)

Hook the menu found in the player’s apartment.

base

AWSWModBase – An instance of the mod base

addAnswerMachineCheckHook(dest_node)

Check if the answering machine’s output.

Return true if the dialog should pop up and return false if it shouldn’t.

Parameters:dest_node – Can be either a renpy.ast.Node or a function.

TODO: Program this

addAnswerMachineScene(dest_node)

Add a hook before the answering machine plays

Parameters:dest_node – Can be either a renpy.ast.Node or a function. Called after the machine check returns true

add_route(title, route_hook, condition='True')

Add a route to the chapter menu

The route will only appear if the condition evaluate to true.

Parameters:

• title (str) – The human-readable menu option
• route_hook (Node) – The renpy.ast.Node object to change to
• condition (str) – The Python string to evaluate if the option should appear

hook_chapter_1(hook)

Hook a node to the start of Chapter 1

Parameters:hook (Node) – The node to hook

hook_chapter_change(hook)

Hook a change of the chapters

Parameters:hook – A renpy.ast.Node object or function

class modloader.modgame.AWSWModBase

The modding framework base.

This class contains all the base functions needed to edit the AST, screens, and screen language.

ending_hooks

AWSWEndingHooks – An instance of the AWSWEndingHooks.

home_hook

AWSWHomeHook – An instance of the AWSWHOmeHook

get_ending_hooks()

Get the ending hook class

Returns:An instance of AWSWEndingHooks

get_home_hook()

Get the home hook class

Returns:The AWSWHomeHook object

get_menu_hook(menu)

Get the equivalent AWSWMenuHook object

Returns:The equivalent AWSWMenuHook object

search_peak_if(node, type_, max_depth=200, skip=0)

Search recursively for a node type.

This enters if statement blocks in order to find your specified node type

Parameters:

• node (Node) – The starting node
• type (Node) – A subclass, not an instance, of a renpy.ast.Node object
• maxBeforeFailure (int) – How many nodes to iterate through before giving up

Returns:

A renpy.ast.Node object or None if not found

modloader.modgame.sprnt(str_)

Print an encoded string to stdout

Encode the string in UTF-8 before printing it out to stdout. This helps avoid Unicode errors though should not be required post v1.7

Parameters:string (str) – The string to be printed

ModAST

Get and modify nodes in the AST tree

This file is free software under the MIT license

class modloader.modast.ASTHook(loc, hook_func_=None, from_op_=None)

A custom renpy.ast.Node that acts as a hook between

other node objects.

Note

Don’t instantiate this class directly. Ren’Py uses an internal serial for the call stack and other uses. This class emulates that at the base class.

hook_func

A function that’s called when the node is executed. If the function returns a non-None value, the next node will be skipped.

from_op

The original node before hooking

old_next

The original next node before hooking was done

exec_continue()

Continue

execute()

Execute hook after node is called

unhook()

Remove the hook

class modloader.modast.MenuHook(menu_, base_)

A hook class for editing a specific menu

add_item(label, hook, condition='True')

Add a new choice to the menu

Parameters:

• label (str) – The option’s label
• hook – Either a renpy.ast.Node or a function to be executed after the menu choice has been selected
• condition (str) – A Python string to evaluate to determine whether or not the choice should be shown

Returns:

None if hook is a renpy.ast.Node or a ASTHook if hook is a function

delete_item(label)

Delete a choice from the menu

Parameters:label (str) – The label to search for

get_item(label)

Get a choice from the menu

Parameters:label (str) – The label to search for Returns:A three-element tuple where the format is (label, condition, block). Label is the visible label given to the user, condition is a Python statement that determines whether or not to show the choice, and block is SL code

get_items()

Get all the items in the menu

Returns:A list of three-element tuples where the format is (label, condition, block), where label is the visible label given to the user, condition is a Python statement that determines whether or not to show the choice, and block is SL code

get_option_code(label)

Get a choice’s SL code from the menu

Parameters:choice (str) – The choice to get

set_conditional(item, new_cond)

Change the conditional statement for item

Returns:True if successful and False if not

set_item(item, new_block)

Change the statement for item

Returns:True if successful and False if not

modloader.modast.add_menu_option(menu, option, node)

Add a dialog option to a given menu

Parameters:

• menu (Menu) – The menu to modify
• option (str) – The option’s text
• node (Node) – The node to execute if the node is selected

modloader.modast.call_hook(node, dest_node, func=None, return_node=None)

Hook func to node and once executed, redirect execution to

dest_node

Parameters:

• node (Node) – The node to hook
• dest_node (Node) – the node to go after node is executed
• func (function) – The function to call

Returns:

An ASTHook object

modloader.modast.disable_bytecode_cache()

Disable bytecode cache

modloader.modast.disable_slast_cache()

Disable SLAst’s load cache

modloader.modast.find_all_hide(hide_name)

Find a list of renpy.ast.Hide nodes based on a string

This searches the entire AST tree for the all the instances of the specified statement.

Parameters:hide_name (str) – The string to search in Hide nodes Returns:A list of renpy.ast.Node nodes

modloader.modast.find_all_show(show_name)

Find a list of renpy.ast.Show nodes based on a string

This searches the entire AST tree for the all the instances of the specified statement.

Parameters:show_name (str) – The string to search in Show nodes Returns:A list of renpy.ast.Node nodes

modloader.modast.find_in_source_code(line_number, file_name)

Find a node by line number and file name

Note

Line numbers and file names can change between versions. Use the function as a last resort only.

Parameters:

• line_number (int) – The line number
• file_name (str) – The file name

Returns:

The node or None if it doesn’t meet the criteria provided

modloader.modast.find_jump_target(target_label, one=True)

Find a jump node (all if one is False) which is bound to the target_label

Parameters:target_label (str) – The target label’s name Returns:Union[Node, List[Node]]

modloader.modast.find_label(label)

Find a label based off of its name

Parameters:label (str) – The label’s name Returns:A renpy.ast.Label object

modloader.modast.find_menu(needle)

Find menus based off a single menu choice

This searches the entire AST tree to find the menu choice.

Parameters:needle – The menu choice to look for. If needle is a string, search for the string. If needle is a list of strings, the program automatically enters multisearch mode Returns:A list of matching menus

modloader.modast.find_python_statement(statement, all=False)

Find a specific Python node in the entire AST

Parameters:

• statement (str) – The Python statement to look for
• all (bool) – If you want to return all such python statements or just one. Defaults to False.

Returns:

The Python node if found, None if not Or a list of nodes which satisfy the conditions

modloader.modast.find_say(needle)

Find a renpy.ast.Say node based on what is said

This searches the entire AST tree for the specified statement.

Parameters:needle (str) – The statement to search for Returns:A renpy.ast.Node node

modloader.modast.get_node_after_nodes(node, location)

Get the location``th node after ``node

Note

This skips ASTHook nodes

Parameters:

• node (Node) – The starting search node
• location (int) – The number of nodes to skip

Returns:

A renpy.ast.Node object

modloader.modast.get_renpy_global(key)

Get a Ren’Py global

Parameters:key (str) – The dictionary key Returns:The value put into the key or None if it doesn’t exist

modloader.modast.get_screen(scr, nodes=None)

Get a screen based off of its name

Parameters:

• scr (str) – The screen’s name
• nodes (list) – A list of screen variants. If None, default to all screens

Returns:

A renpy.display.screen.Screen object

modloader.modast.get_slscreen(scr, nodes=None)

Get a screen’s executable based off of its name

Parameters:

• scr (str) – The screen’s name
• nodes (list) – A list of screen variants. If None, default to all screens

Returns:

A renpy.display.screen.Screen object

modloader.modast.hook_label(label, func)

Hook a function to a label

Parameters:

• label (renpy.ast.Label) – The label
• func (function) – The function to be hooked

Returns:

An ASTHook object

modloader.modast.hook_opcode(node, func)

Hook func to node

Parameters:

• node (Node) – The node object for the function to hook
• func (function) – The function to be executed when the node is executed

Todo

Check if a hook already exists and make the code more cohesive

Returns:An ASTHook object

modloader.modast.jump_ret(node, dest_node, return_node, func=None)

Hook func to node and once executed, redirect execution to

dest_node and allow return_node to be executed after dest_node returns

Parameters:

• node (Node) – The node to hook
• dest_node (Node) – The node to go after node is executed
• return_node (Node) – The node that is executed after dest_node returns
• func (function) – The function hook

Returns:

An ASTHook object

modloader.modast.remove_slif(scr, comparison)

Remove a block (equivalent to a Node) from a renpy.sl2.slast.SLIf object

Parameters:

• scr (SLScreen) – The SLScreen node to start the search
• comparison (str) – The comparison string for the expression

Returns:

True if removed, False if not

modloader.modast.search_for_node_type(node, type_, max_depth=200)

Search for a specific type of node

Parameters:

• node (Node) – The node to start the search
• type (class) – The node class, not an instance of the class, to search for
• max_depth (int) – The number of nodes to search before giving up Defaults to 200. The higher the number, the slower the process

Returns:

A renpy.ast.Node object if a match occurs or None if no match occurs

modloader.modast.search_for_node_with_criteria(node, func, max_depth=200)

Search for a node and check with func

If func returns a truthy value, return the node. Else, skip it

Parameters:

• node (Node) – The node to start the search
• func (function) – Function to check for the given node. Given one argument, node (of type renpy.ast.Node), which is the node that is at the current depth. Do not make the functions complex or it will slow down the game significantly.
• max_depth (int) – The number of nodes to search before giving up Defaults to 200. The higher the number, the slower the process

Returns:

A renpy.ast.Node object if a match occurs or None if no match occurs

modloader.modast.set_renpy_global(key, val)

Set a Ren’Py glboal

Ren’Py globals can be used during execution of rpy.

Parameters:

• key (str) – The dictionary key
• val (str) – The value of the dictionary object

modloader.modast.unhook_label(label)

Unhook a hook from a label

Parameters:label (str) – The label’s name

ModClass

This file is free software under the MIT license

class modloader.modclass.Mod

The Mod class

This is supposed to act like a superclass for mods. Execution order is as follows: mod_load() -> mod_complete()

mod_complete()

Executes when all mods are loaded

This method is useful for dependency loading but can be left empty otherwise

mod_info()

Get the mod info

Returns:A tuple with the name, version, author, and (optionally) if the mod is NSFW

mod_load()

Executes when the mod is loaded

This is where you put patcher code.

See also

mod_complete()

modloader.modclass.loadable_mod(modclass)

Annotation to add a Mod subclass to the mod list

Parameters:modclass (Mod) – The Mod class, not an instance of the Mod class Raises:Exception – If the given class is not a subclass of Mod

ModInfo

This file is free software under the MIT license

modloader.modinfo.add_mod(mod_name, mod)

Add a mod in the registry

modloader.modinfo.get_mods()

Get the mods in the registry

modloader.modinfo.reset_mods()

Remove all mods from the registry