mirror of
https://github.com/JohnBreaux/Boat-Battle.git
synced 2024-11-15 05:25:57 +00:00
694 lines
23 KiB
GDScript
694 lines
23 KiB
GDScript
extends Control
|
|
|
|
# Hello, god class. Though, as an optional module, it's not the worst it could be.
|
|
# Smells of feature creep, because it absolutely is one.
|
|
|
|
var debug_canvas
|
|
|
|
var debug_active = false
|
|
var menu_moving = false
|
|
var menu_position = 0.0
|
|
var menu_velocity = 4
|
|
|
|
var history : Array = []
|
|
var history_pos = 0
|
|
|
|
# Controls whether to print to the screen
|
|
var echo = true
|
|
|
|
# Controls whether the player is allowed to cheat:
|
|
var cheats = false
|
|
var cheat_code = "989172bdaff124fc237b3f904a1886b91dc3ae718da15a6055ff416284f39a58"
|
|
|
|
onready var expression = Expression.new()
|
|
|
|
# metadata: args list, help blurb, and cheatmap accessed by function name
|
|
enum {ARGS, HELPTEXT, IS_CHEAT}
|
|
var command_metadata = {
|
|
# command_id [args "Help text" is cheat]
|
|
"command_help": [" [command]", "Print information about command.\n", false],
|
|
"command_history": ["", "Print the history log.\n", false],
|
|
"command_perf": [" stat", "Print performance info (fps, nodes, proctime, ... )\n", false],
|
|
|
|
"command_list": [" [path]", "List children of path, or of present working node.\n", false],
|
|
"command_start": [" filename", "Load PackedScene filename.tscn as child.\n", true ],
|
|
"command_kill": [" name", "Kill child node with matching name.\n", true ],
|
|
|
|
"command_pwd": ["", "Print the Present Working Node.\n", false],
|
|
"command_cd": [" path", "Change the Present Working Node to path.\n", false],
|
|
|
|
"command_print": [" string", "Print string to the in-game debug console.\n", false],
|
|
"command_clear": ["", "Clear the debug output.\n", false],
|
|
# !EXTREMELY DANGER {
|
|
"command_emit": [" signal [message]", "Emit a message on MessageBus.signal without validation.\n", true ],
|
|
"command_call": [" func [args ...]", "Call func(...) with arguments args.\n", true ],
|
|
"command_exec": [" expression ...", "Evaluate an arbitrary expression, and print the result.\n", true ],
|
|
# }
|
|
"command_listprops": ["", "List properties of the Present Working Node\n", true ],
|
|
"command_getprop": [" prop", "Get the value of property prop\n", true ],
|
|
"command_setprop": [" prop value", "Set the property prop to value.\n", true ],
|
|
|
|
"command_script": [" path", "Load and execute a script at user://scripts/<name>\n", false],
|
|
"command_echo": [" on/off", "Controls whether lines should be printed to the screen\n", true ],
|
|
"command_cheat": [" [password]", "Controls whether cheats are enabled, using a fun code\n", false],
|
|
|
|
"command_restart": ["", "Kill the current scene tree and plant a new Root.\n", true ],
|
|
"command_exit": ["", "Quits the program.\n", false],
|
|
|
|
"command_empty": ["", "No Operation.\n", false],
|
|
}
|
|
|
|
# List of debug commands accessed by alias
|
|
# The first alias is the canonical alias, aka command name
|
|
var commands = {
|
|
# [alias array]: "func_name"
|
|
["help", "h"]: "command_help",
|
|
["hist", "history"]: "command_history",
|
|
["perf", "performance"]: "command_perf",
|
|
|
|
["list", "ls", "l"]: "command_list",
|
|
["start", "open", "o"]: "command_start",
|
|
["kill", "stop", "k"]: "command_kill",
|
|
|
|
["pwd", "pwn"]: "command_pwd",
|
|
["cd", "cn"]: "command_cd",
|
|
|
|
["print", "p"]: "command_print",
|
|
["clear","cls"]: "command_clear",
|
|
|
|
["emit", "e"]: "command_emit",
|
|
["call", "func"]: "command_call",
|
|
["exec", "_", "$", ">"]: "command_exec",
|
|
|
|
["listprops", "lsp"]: "command_listprops",
|
|
["getprop","get", "g"]: "command_getprop",
|
|
["setprop","set", "s"]: "command_setprop",
|
|
|
|
["script", "sh"]: "command_script",
|
|
["@echo"]: "command_echo",
|
|
["cheat", "*"]: "command_cheat",
|
|
|
|
["restart", "killall"]: "command_restart",
|
|
["exit", "quit"]: "command_exit",
|
|
|
|
["", "#"]: "command_empty"
|
|
}
|
|
|
|
#List of all of Godot's builtin types
|
|
const types:Array = [
|
|
"nil", "bool","int","float","String","Vector2","Rect2",
|
|
"Vector3","Transform2D","Plane","Quat","AABB","Basis","Transform",
|
|
"Color","NodePath","RID","Object","Dictionary","Array","PoolByteArray",
|
|
"PoolIntArray","PoolRealArray","PoolStringArray","PoolVector2Array",
|
|
"PoolVector3Array","PoolColorAray"
|
|
]
|
|
|
|
onready var present_working_node = get_node("/root/Main")
|
|
|
|
# positions when the menu is hidden/active
|
|
var menu_hidden = Transform2D(Vector2(1,0), Vector2(0,1), Vector2(0,-170))
|
|
var menu_active = Transform2D(Vector2(1,0), Vector2(0,1), Vector2(0, 0))
|
|
|
|
# signals
|
|
# clear_in: clear the debug input
|
|
signal clear_in
|
|
# clear_out: clear the debug output
|
|
signal clear_out
|
|
# print_text(text): Send text to the Out buffer
|
|
signal print_text(text)
|
|
# history_event(text): Send text to the In buffer
|
|
signal history_event(text)
|
|
|
|
# Inherited functions:
|
|
# _ready: Called when the node enters the scene tree for the first time.
|
|
# params: none
|
|
# returns: void
|
|
func _ready():
|
|
debug_canvas = get_node("debug_canvas")
|
|
debug_canvas.set_transform(menu_hidden) #initialize the debug menu as hidden
|
|
command_help([""])
|
|
debug_print_line("> ")
|
|
|
|
# _process: Called every frame. Controls slide-in animation and focus-grabbing
|
|
# params: delta: elapsed time
|
|
# returns: void
|
|
func _process(delta):
|
|
if (debug_active && menu_position < 1):
|
|
# Move the menu down
|
|
menu_position += menu_velocity * delta;
|
|
menu_moving = true
|
|
$debug_canvas/VBoxContainer/LineEdit.grab_focus()
|
|
elif (!debug_active && menu_position > 0):
|
|
# Move the menu up
|
|
menu_position -= menu_velocity * delta;
|
|
menu_moving = true
|
|
# Clear the input box
|
|
emit_signal("clear_in")
|
|
elif (menu_position < 0 || menu_position > 1):
|
|
menu_position = round(menu_position)
|
|
menu_moving = true
|
|
else:
|
|
menu_moving = false
|
|
if menu_moving:
|
|
debug_canvas.set_transform(menu_hidden.interpolate_with(menu_active, menu_position))
|
|
|
|
# _input: Process user input related to the debug menu
|
|
# params: event: The input event which triggered _input call
|
|
# returns: void
|
|
func _input(event):
|
|
if event.is_action_pressed("ui_debug_open"):
|
|
# open debug menu
|
|
debug_active = !debug_active;
|
|
# Hand the keyboard focus to the next valid focus
|
|
if (!debug_active) && find_next_valid_focus(): find_next_valid_focus().grab_focus()
|
|
if event.is_action_pressed("ui_debug_up") and debug_active:
|
|
#traverse history up
|
|
history_move(-1)
|
|
pass
|
|
if event.is_action_pressed("ui_debug_down") and debug_active:
|
|
#traverse history down
|
|
history_move(+1)
|
|
|
|
# Command-processing functions:
|
|
# _on_LineEdit_text_entered: process incoming text line
|
|
# params: line: Line of text entered by user
|
|
# returns: void
|
|
func _on_LineEdit_text_entered(line):
|
|
emit_signal("clear_in")
|
|
debug_print_line(line + "\n")
|
|
var command = line.split(' ', true, 1)
|
|
if execute_command(command):
|
|
history_append(line)
|
|
else:
|
|
debug_print_line("dbg: command not found: " + command[0] + "\n")
|
|
debug_print_line("> ")
|
|
|
|
# execute_command: execute a line of text as a command
|
|
# params: command: partially tokenized PoolStringArray ["command_alias", "parameters ..."]
|
|
# returns: name of executed function, or null if nothing executed
|
|
func execute_command(command):
|
|
var command_func = parse(command[0])
|
|
if command_func and is_command_allowed(command_func):
|
|
call(command_func, command)
|
|
else:
|
|
command_func = null
|
|
return command_func
|
|
|
|
# is_command_allowed: Test if the command is allowed (not cheating, or cheating is on)
|
|
# params: command_func: the name of the function to be executed
|
|
# returns: true if command is valid, or false if command is cheat and cheating is disabled
|
|
func is_command_allowed(command_func):
|
|
# return true if cheats or on, or command is not cheat
|
|
return cheats or not command_metadata[command_func][IS_CHEAT]
|
|
|
|
# History_related helper functions:
|
|
# history_append: add a line of text to the history
|
|
# params: text: line of text (unparsed command) to add to history
|
|
# returns: void
|
|
func history_append(text):
|
|
history.resize(history_pos + 2)
|
|
history[history_pos] = text
|
|
history[history_pos + 1] = ""
|
|
history_pos += 1
|
|
|
|
# history_move: Traverse the history and update the user input box
|
|
# params: rel_pos: amount to move, relative to the current history_pos
|
|
# returns: void
|
|
func history_move(rel_pos):
|
|
var new_pos = history_pos + rel_pos
|
|
if new_pos >= 0 and new_pos < history.size():
|
|
history_pos = new_pos;
|
|
if history[history_pos]:
|
|
emit_signal("history_event", history[history_pos])
|
|
else:
|
|
emit_signal("clear_in")
|
|
|
|
# Debug-related helper functions:
|
|
# debug_print_line: request printing of c-escaped text to debug output
|
|
# params: string: Text string to print
|
|
# returns: void
|
|
func debug_print_line(string):
|
|
if echo:
|
|
emit_signal("print_text", string.c_unescape())
|
|
|
|
# get_pwn: get the present working node if valid, otherwise cd to root
|
|
func get_pwn():
|
|
if !is_instance_valid(present_working_node):
|
|
debug_print_line("Node freed, traversing to /root/\n")
|
|
present_working_node = get_node("/root/")
|
|
return present_working_node
|
|
|
|
|
|
# complete_path: complete a relative or absolute path, and returns the node it refers to
|
|
# params: path: relative or absolute path to a node
|
|
# returns: void
|
|
func complete_path(path):
|
|
if path.is_rel_path(): # convert to absolute path
|
|
path = String(get_pwn().get_path()) + "/" + path
|
|
var node = get_node(path)
|
|
if node:
|
|
return node
|
|
return null
|
|
|
|
# Command-lookup functions:
|
|
# parse: parse command name and return associated func name
|
|
# params: alias: alias of a command
|
|
# returns: name of command function
|
|
func parse(alias):
|
|
var key = lookup(alias)
|
|
if key:
|
|
return commands[key]
|
|
return null
|
|
|
|
# name_lookup: find key associated with function name
|
|
# params: command_name: alias of a command
|
|
# returns: key: Array containing all aliases of the given command
|
|
func lookup(alias):
|
|
for key in commands.keys():
|
|
if alias in key:
|
|
return key
|
|
return null
|
|
|
|
# get_canonical: find the canonical name for a command
|
|
# params: alias: alias of a command
|
|
# returns: name: canonical name for a command
|
|
func get_canonical(alias):
|
|
var names = lookup(alias)
|
|
if names:
|
|
return names[0]
|
|
return null
|
|
|
|
# get_usage: Construct the usage string for a command
|
|
# params: alias: alias of a command
|
|
# returns: usage string for the command, formatted for printing
|
|
func get_usage(alias):
|
|
return "Usage: " + alias + command_metadata[parse(alias)][0] + "\n"
|
|
|
|
# String casting functions
|
|
# variant_to_string: Cast arbitrary GDScript Variant to String
|
|
# params: variant: variant to cast
|
|
# returns: String representing the Variant as closely as possible
|
|
func variant_to_string(variant):
|
|
var res
|
|
match typeof(variant):
|
|
TYPE_NIL:
|
|
res = "null"
|
|
TYPE_OBJECT: #No conversion from object to string; a unique case.
|
|
if (variant):
|
|
res = variant.to_string()
|
|
else:
|
|
res = "Object = null"
|
|
_:
|
|
res = String(variant)
|
|
return res
|
|
|
|
# string_to_variant: Cast a string to a specified GDScript type
|
|
# params: string: string to be cast
|
|
# type: type to cast string to
|
|
# returns: GDScript Variant of given type
|
|
func string_to_variant(string, type):
|
|
var res = null
|
|
var list = listify_string(string)
|
|
match type:
|
|
TYPE_NIL:
|
|
res = null
|
|
TYPE_BOOL:
|
|
match string.to_lower():
|
|
"true", "1", "ok", "on":
|
|
res = true
|
|
_:
|
|
res = false
|
|
TYPE_INT:
|
|
res = int(string)
|
|
TYPE_REAL:
|
|
res = float(string)
|
|
TYPE_STRING:
|
|
res = string
|
|
TYPE_COLOR:
|
|
res = Color(string)
|
|
TYPE_NODE_PATH:
|
|
res = NodePath(string)
|
|
TYPE_ARRAY:
|
|
res = list
|
|
TYPE_RAW_ARRAY:
|
|
res = PoolByteArray(list)
|
|
TYPE_INT_ARRAY:
|
|
res = PoolIntArray(list)
|
|
TYPE_REAL_ARRAY:
|
|
res = PoolRealArray(list)
|
|
TYPE_STRING_ARRAY:
|
|
res = list
|
|
TYPE_COLOR_ARRAY:
|
|
res = PoolColorArray(list)
|
|
_:
|
|
debug_print_line("No cast from String to %s\n" % types[typeof(type)])
|
|
return res
|
|
|
|
# listify_string: takes a string and turns it into a list, by splitting on commas and/or spaces
|
|
# params: string: string to be made into a list
|
|
# returns: PoolStringArray containing substrings of the list
|
|
func listify_string(string):
|
|
var res = []
|
|
if string.findn(', ') > -1:
|
|
res = string.split(', ', true, 0)
|
|
elif string.findn(',') > -1:
|
|
res = string.split(',', true, 0)
|
|
else:
|
|
res = string.split(' ', true, 0)
|
|
return res
|
|
|
|
# file_exists: checks if a file exists at path
|
|
# params: path: string denoting the path to a file
|
|
# returns: bool denoting file's presence at path
|
|
func file_exists(path):
|
|
var D = Directory.new()
|
|
return D.file_exists(path)
|
|
|
|
|
|
# Commands. All commands take in a parameter called command,
|
|
# which contains a partially tokenized command
|
|
# start: Loads scene from res://scenes/*.tscn by filename, and starts it
|
|
func command_start (command):
|
|
if command.size() > 1:
|
|
var path = "res://scenes/%s.tscn" % command[1]
|
|
var pack = load(path) if file_exists(path) else null
|
|
# Check if the resource was opened
|
|
if pack:
|
|
get_pwn().add_child(pack.instance());
|
|
debug_print_line("started '%s'\n" % command[1])
|
|
else:
|
|
debug_print_line("Path not found: %s\n" % "res://scenes/%s.tscn" % command[1])
|
|
else:
|
|
debug_print_line(get_usage(command[0]))
|
|
|
|
# stop: kills a child of current working node
|
|
func command_kill (command):
|
|
if command.size() > 1:
|
|
var node = get_pwn().find_node(command[1], false, false)
|
|
if node:
|
|
if String(node.get_path()).match("*Debug*"):
|
|
debug_print_line("I'm sorry, Dave. I'm afraid I can't do that.\n")
|
|
else:
|
|
node.queue_free()
|
|
debug_print_line("%s killed\n" % command[1])
|
|
else:
|
|
debug_print_line("%s: %s not found.\n" % [command[0], command[1]])
|
|
else:
|
|
debug_print_line(get_usage(command[0]))
|
|
|
|
# list: Lists children of node
|
|
func command_list (command):
|
|
var node = null
|
|
if (command.size() > 1):
|
|
node = complete_path(command[1])
|
|
if (!node):
|
|
node = get_pwn()
|
|
var children = node.get_children()
|
|
var names = []
|
|
for i in range (children.size()):
|
|
names.append(children[i].name)
|
|
debug_print_line(String(names) + "\n")
|
|
|
|
# restart: Kills the current tree and replants Root
|
|
func command_restart (_command):
|
|
MessageBus.emit_signal("return_to_title")
|
|
|
|
# print: prints a message to the in-game debug console
|
|
func command_print(command):
|
|
if command.size() > 1:
|
|
debug_print_line(command[1])
|
|
else:
|
|
debug_print_line("\n")
|
|
|
|
# emit: emits a message onto the MessageBus
|
|
func command_emit (command):
|
|
if command.size() > 1:
|
|
var mbus_signal = command[1].split(' ', true, 1)
|
|
match mbus_signal.size():
|
|
2:
|
|
debug_print_line("Message: %s (%s)" % mbus_signal)
|
|
MessageBus.emit_signal(mbus_signal[0], mbus_signal[1])
|
|
1:
|
|
debug_print_line("Message: %s" % mbus_signal)
|
|
MessageBus.emit_signal(mbus_signal[0])
|
|
0: debug_print_line(get_usage(command[0]))
|
|
else:
|
|
debug_print_line(get_usage(command[0]))
|
|
|
|
# clear: clears the debug output
|
|
func command_clear (_command):
|
|
emit_signal("clear_out");
|
|
|
|
# pwd: print the present working node's path
|
|
func command_pwd (_command):
|
|
debug_print_line(String(get_pwn().get_path()) + "\n")
|
|
|
|
# cd: change the present working node
|
|
func command_cd (command):
|
|
if command.size() > 1:
|
|
var node = complete_path(command[1])
|
|
if node:
|
|
present_working_node = node
|
|
else:
|
|
debug_print_line (get_canonical(command[0]) + ': no such node: ' + command[1] + '\n')
|
|
else:
|
|
debug_print_line(get_usage(command[0]))
|
|
|
|
# help: Prints help dialogue
|
|
func command_help (command):
|
|
if (command.size() == 1):
|
|
debug_print_line("Valid commands:\n")
|
|
for key in commands:
|
|
# if command is allowed in current context, print it
|
|
if is_command_allowed(commands[key]):
|
|
debug_print_line(key[0] + " ")
|
|
debug_print_line("\n")
|
|
else:
|
|
var command_func = parse(command[1])
|
|
if command_func in command_metadata and is_command_allowed(command_func):
|
|
var text = command_metadata[command_func]
|
|
var aliases = String(lookup(command[1]))
|
|
debug_print_line("%s%s:\n Aliases: %s\n %s" % [command[1], text[ARGS], aliases, text[HELPTEXT]])
|
|
else:
|
|
debug_print_line("%s: command not found: %s\n" % [command[0], command[1]])
|
|
|
|
# exit: request program exit
|
|
func command_exit(_command):
|
|
MessageBus.emit_signal("quit")
|
|
|
|
# call: call arbitrary member function of present working node
|
|
func command_call(command):
|
|
if command.size() > 1:
|
|
var call_ret = null
|
|
var call_args = []
|
|
var call_cmd = command[1].split(' ', true, 1)
|
|
if call_cmd.size() > 1:
|
|
call_args = call_cmd[1].split(' ', false, 0)
|
|
if get_pwn().has_method(call_cmd[0]):
|
|
call_ret = get_pwn().callv(call_cmd[0], call_args)
|
|
else:
|
|
debug_print_line("We're sorry, but your call could not be completed as dialed.\n"
|
|
+ "Please hang up and try your call again.\n")
|
|
return
|
|
debug_print_line("%s\n" % variant_to_string(call_ret))
|
|
else:
|
|
debug_print_line(get_usage(command[0]))
|
|
|
|
# exec: execute an arbitrary GDScript expression as present working node
|
|
func command_exec(command):
|
|
if command.size() > 1:
|
|
var res
|
|
var err = expression.parse(command[1])
|
|
if err == OK:
|
|
res = expression.execute([], get_pwn(), false);
|
|
if expression.has_execute_failed():
|
|
debug_print_line("%s: command not found: %s " % [command[0], command[1]])
|
|
res = ""
|
|
else:
|
|
res = expression.get_error_text()
|
|
debug_print_line("%s\n" % variant_to_string(res))
|
|
else:
|
|
debug_print_line(get_usage(command[0]))
|
|
|
|
# listprops: list properties (variables) of present working node
|
|
func command_listprops(_command):
|
|
var props = ""
|
|
var proplist = get_pwn().get_property_list()
|
|
proplist.sort_custom(self, "propSort")
|
|
for prop in proplist:
|
|
if prop["name"]:
|
|
props += "%s %s\n" % [types[prop["type"]], prop["name"]]
|
|
pass
|
|
debug_print_line(props)
|
|
pass
|
|
# propsort: sort props by type, alphabetically
|
|
func propSort(a, b):
|
|
if a["type"] == b["type"]:
|
|
return a["name"] < b["name"]
|
|
return types[a["type"]].to_lower() < types[b["type"]].to_lower()
|
|
|
|
# getprop: get the value of a named property of the present working node
|
|
func command_getprop(command):
|
|
if command.size() > 1:
|
|
var res = get_pwn().get(command[1])
|
|
debug_print_line(variant_to_string(res) + "\n")
|
|
else:
|
|
debug_print_line(get_usage(command[0]))
|
|
|
|
# setprop: set the value of a named property of the present working node
|
|
func command_setprop(command):
|
|
if command.size() > 1:
|
|
var prop = command[1].split(' ', true, 1)
|
|
if prop.size() > 1 && prop[0].is_valid_identifier():
|
|
var type = typeof(get_pwn().get(prop[0]))
|
|
var variant = string_to_variant(prop[1], type)
|
|
if typeof(variant) > TYPE_NIL:
|
|
get_pwn().set(prop[0], string_to_variant(prop[1], type))
|
|
else:
|
|
debug_print_line(get_usage(command[0]))
|
|
|
|
# history: print the command history
|
|
func command_history(_command):
|
|
var lnum = 0
|
|
for line in history:
|
|
if line:
|
|
debug_print_line("%2d: %s\n" % [lnum, line])
|
|
lnum += 1
|
|
#debug_print_line("history_pos = " + String(history_pos) + "\n")
|
|
|
|
# perf: Print the value of a Godot Engine performance counter
|
|
func command_perf(command):
|
|
if command.size() > 1:
|
|
var stat = perf(command[1])
|
|
if stat:
|
|
debug_print_line("%s\n" % String(stat))
|
|
else:
|
|
debug_print_line("null\n")
|
|
else:
|
|
debug_print_line(get_usage(command[0]))
|
|
|
|
# script: run a script from user://scripts/
|
|
func command_script(command):
|
|
var script = []
|
|
if (command.size() > 1):
|
|
var path = "user://scripts/" + command[1]
|
|
var f = File.new()
|
|
var err = f.open(path, File.READ)
|
|
if err == OK:
|
|
# Read the file
|
|
while not f.eof_reached():
|
|
script.push_back(f.get_line())
|
|
f.close()
|
|
# Save state and turn off echo
|
|
var state = {"echo": echo,
|
|
"pwn": present_working_node,
|
|
"history_pos": history_pos,
|
|
"history": history,
|
|
"expression": expression,
|
|
"cheats": cheats}
|
|
echo = false
|
|
# Execute the script
|
|
for cmd in script:
|
|
cmd = cmd.split(' ', true, 1)
|
|
execute_command(cmd)
|
|
# Restore state
|
|
echo = state["echo"]
|
|
present_working_node = state["pwn"]
|
|
history_pos = state["history_pos"]
|
|
history = state["history"]
|
|
expression = state["expression"]
|
|
cheats = state["cheats"]
|
|
else:
|
|
debug_print_line("File not found: " + command[1] + "\n")
|
|
else:
|
|
debug_print_line(get_usage(command[0]))
|
|
|
|
# echo: enable and disable echoing commands and their outputs to the terminal
|
|
func command_echo(command):
|
|
if command.size() > 1:
|
|
echo = string_to_variant(command[1], TYPE_BOOL)
|
|
else:
|
|
debug_print_line(get_usage(command[0]))
|
|
|
|
# cheat: Disable cheats, or enable them if you say the magic word
|
|
func command_cheat(command):
|
|
# check if there's more than one input to the command:
|
|
if command.size() > 1:
|
|
# hash the password
|
|
var code = command[1].sha256_text()
|
|
if code == cheat_code:
|
|
debug_print_line("Cheats enabled.\n")
|
|
cheats = true
|
|
return
|
|
debug_print_line("Ah ah ah, you didn't say the magic word!\n")
|
|
cheats = false
|
|
debug_print_line("Cheats disabled.\n")
|
|
pass
|
|
|
|
# look-up table for performance monitor -> index pairs
|
|
# See https://docs.godotengine.org/en/stable/classes/class_performance.html
|
|
const monitor_lookup = {
|
|
# Time
|
|
"time:fps": 0,
|
|
"time:process": 1,
|
|
"time:physics process": 2,
|
|
# Memory
|
|
"memory:static": 3,
|
|
"memory:dynamic": 4,
|
|
"memory:static max": 5,
|
|
"memory:dynamic max": 6,
|
|
"memory:message buffer max": 7,
|
|
# Objects
|
|
"object:count": 8,
|
|
"object:resource count": 9,
|
|
"object:node count": 10,
|
|
"object:orphan node count": 11,
|
|
# Render
|
|
"render:objects in frame": 12,
|
|
"render:vertices in frame": 13,
|
|
"render:material changes in frame": 14,
|
|
"render:shader changes in frame": 15,
|
|
"render:surface changes in frame": 16,
|
|
"render:draw calls in frame": 17,
|
|
"render:2d items in frame": 18,
|
|
"render:2d draw calls in frame": 19,
|
|
"render:video memory used": 20,
|
|
"render:texture memory used": 21,
|
|
"render:vertex memory used": 22,
|
|
"render:total video memory used": 23,
|
|
# Physics2D
|
|
"physics2d:active objects": 24,
|
|
"physics2d:collision pairs": 25,
|
|
"physics2d:island count":26,
|
|
# Physics3D
|
|
"physics3d:active objects": 27,
|
|
"physics3d:collision pairs": 28,
|
|
"physics3d:island count": 29,
|
|
# Audio
|
|
"audio:output latency": 30
|
|
}
|
|
|
|
# Get a performance counter given a string
|
|
func perf(attribute):
|
|
if attribute.is_valid_integer():
|
|
return Performance.get_monitor(int(attribute))
|
|
if attribute in monitor_lookup:
|
|
return Performance.get_monitor(monitor_lookup[attribute.to_lower()])
|
|
# Shortcut to popular counters
|
|
match attribute.to_lower():
|
|
"fps":
|
|
return Performance.get_monitor(Performance.TIME_FPS)
|
|
"proctime":
|
|
return Performance.get_monitor(Performance.TIME_PROCESS)
|
|
"objects":
|
|
return Performance.get_monitor(Performance.OBJECT_COUNT)
|
|
"nodes":
|
|
return Performance.get_monitor(Performance.OBJECT_NODE_COUNT)
|
|
"resources":
|
|
return Performance.get_monitor(Performance.OBJECT_RESOURCE_COUNT)
|
|
return ""
|
|
|
|
# empty: No command
|
|
func command_empty(_command):
|
|
pass
|