From 9bfeab66e105e8a4cd7e54c15b41cff9f68c4d30 Mon Sep 17 00:00:00 2001
From: Atemo <capucrath@gmail.com>
Date: Tue, 12 May 2026 14:31:15 +0200
Subject: [PATCH] Archive - Testing the implementation for learning purposes of
 a "dictionary" format style in rAthena script engine, using an AI agent

---
 doc/script_commands.txt                       |  524 +-
 npc/scripts_test.conf                         |    7 +
 npc/test/callnpcsub_multireturn_tests.txt     |  189 +
 npc/test/mdarray_dyn_dict_only_tests.txt      |  293 +
 .../mdarray_dyn_empty_assignment_tests.txt    |  112 +
 .../mdarray_dyn_literal_empty_table_tests.txt |  243 +
 .../mdarray_dyn_literal_integer_key_tests.txt |  146 +
 npc/test/mdarray_dyn_string_debug_tests.txt   |  195 +
 src/map/script.cpp                            | 5526 ++++++++++++-----
 src/map/script.hpp                            |    2 +
 10 files changed, 5745 insertions(+), 1492 deletions(-)
 create mode 100644 npc/test/callnpcsub_multireturn_tests.txt
 create mode 100644 npc/test/mdarray_dyn_dict_only_tests.txt
 create mode 100644 npc/test/mdarray_dyn_empty_assignment_tests.txt
 create mode 100644 npc/test/mdarray_dyn_literal_empty_table_tests.txt
 create mode 100644 npc/test/mdarray_dyn_literal_integer_key_tests.txt
 create mode 100644 npc/test/mdarray_dyn_string_debug_tests.txt

diff --git a/doc/script_commands.txt b/doc/script_commands.txt
index 18bca372d74..738b91c2ad5 100644
--- a/doc/script_commands.txt
+++ b/doc/script_commands.txt
@@ -581,6 +581,37 @@ variables. Once you set it to that, the variable is as good as forgotten
 forever, and no trace remains of it even if it was stored with character or
 account data.
 
+Dynamic variables
+-----------------
+
+A variable can be declared as dynamic with the 'dyn' command. Dynamic variables
+are intended for temporary script data that may contain both integer and string
+values under the same base variable, including multidimensional dictionary-like
+arrays.
+
+Example:
+	dyn .@user;
+	.@user["name"] = "Bob";
+	.@user["age"] = 20;
+
+Unlike normal variables, the value type of each dynamic element is decided by
+the value assigned to that element. A dynamic variable does not need the '$'
+postfix to store strings.
+
+Dynamic variables currently only support temporary scopes:
+	.@name  - scope dynamic variable
+	@name   - temporary character dynamic variable
+	.name   - NPC dynamic variable
+	$@name  - temporary global dynamic variable
+	'name   - instance variable
+
+Permanent variables ('name', '$name', '#name', '##name') should not be used as
+dynamic multidimensional arrays unless persistence support has explicitly been
+implemented for them.
+
+Reading a missing dynamic value returns 0. Use 'getarraykeys' or
+'getarraysize' to test which dictionary entries actually exist.
+
 Some variables are special, that is, they are already defined for you by the
 scripting engine. You can see the full list in 'src/map/script_constants.hpp', which
 is a file you should read, since it also allows you to replace lots of numbered
@@ -672,6 +703,14 @@ Note:
  !! In order to copy arrays between variables the use of 'copyarray' function is still
  !! required.
 
+Dynamic dictionaries declared with 'dyn' support assigning the empty dictionary
+literal '[]' to create or clear a branch:
+
+	dyn .@a;
+	.@a["list"] = [];
+
+Other dynamic literals are normally used with 'dyn <variable> = [ ... ];'.
+
 Strings
 -------
 
@@ -687,7 +726,8 @@ same name. You can tell between the specific variables of an array with an
 
 <variable name>[<array index>]
 
-All variable types can be used as arrays.
+All variable types can be used as arrays. Integer arrays return 0 for missing
+elements and string arrays return an empty string.
 
 Variables stored in this way, inside an array, are also called 'array elements'.
 Arrays are specifically useful for storing a set of similar data (like several
@@ -718,6 +758,91 @@ Arrays can naturally store strings:
 the '$', normally denoting a string variable, before the square brackets that
 denotes an array index.
 
+
+Dynamic dictionary variables
+----------------------------
+
+Traditional rAthena arrays remain one-dimensional and keep the legacy behavior
+where a variable without an explicit index refers to index 0:
+
+	.@a = 1;
+	.@a[0] == .@a; // true for legacy arrays
+
+Dynamic dictionaries are a separate runtime storage declared with the 'dyn'
+command. They are intended for temporary, dictionary-like data that may contain
+integer values, string values, empty dictionaries and nested dictionaries under
+the same base variable.
+
+	dyn .@user;
+	.@user["name"] = "Bob";
+	.@user["age"] = 20;
+	.@user["items"][0]["id"] = 501;
+
+Dynamic variables are dictionaries only. The root itself is not a scalar value,
+and assigning a scalar directly to a dynamic variable is an error:
+
+	dyn .@a;
+	.@a = 1; // error
+
+Use an indexed path to store values:
+
+	.@a[0] = 1;
+	.@a["key"] = "value";
+
+Dynamic dictionaries are sparse and non-rectangular. A path may exist without
+requiring any sibling or parent scalar value to exist:
+
+	dyn .@a;
+	.@a[1] = 5;
+	.@a[2][101] = 7;
+	.@a["config"]["map"] = "prt_gld";
+
+Keys are typed. Integer key 0 and string key "0" are different keys:
+
+	dyn .@a;
+	.@a[0] = "integer key";
+	.@a["0"] = "string key";
+
+Empty dictionary branches can be created or cleared with the empty dynamic
+literal '[]':
+
+	dyn .@a;
+	.@a["list"] = [];
+	getarraysizedyn(.@a["list"]); // returns 0
+
+Dynamic literals can be used to initialize large dictionary structures. They use
+square brackets with key/value pairs. Keys may be string literals, non-negative
+integer literals or parenthesized expressions that evaluate to a string or
+non-negative integer key.
+
+	dyn .data = [
+		"Prontera": [
+			"prtg_cas01": [
+				"agitend": "Agit#prtg_cas01::OnAgitEnd",
+				"eventkillmob": "Agit#prtg_cas01::OnAgitBreak",
+				"warp": [
+					"map": "prt_gld",
+					"x": 134,
+					"y": 65,
+				],
+			],
+		],
+	];
+
+	.@region$ = "Prontera";
+	dyn .@cfg = [
+		(.@region$): [
+			0: "integer child",
+			"0": "string child",
+		],
+	];
+
+A missing dynamic leaf reads as the default value 0. Reading a missing path does
+not create it. Use 'getarraykeys', 'getarraysizedyn' or 'getdyntype' to inspect
+which dictionary branches actually exist.
+
+Use 'del' to remove a dynamic key or branch.
+
 Variable References
 -------------------
 
@@ -1402,6 +1527,164 @@ Examples:
 
 ---------------------------------------
 
+*dyn <temporary variable>;
+*dyn <temporary variable> = [<dynamic literal>];
+
+Declares a variable as dynamic. Dynamic variables are dictionary-only values and
+are separate from legacy one-dimensional arrays. A dynamic variable does not use
+the '$' postfix to decide the type of its values; each leaf value keeps the type
+of the value assigned to it.
+
+Only root variables can be declared dynamic. Indexed declarations are invalid:
+
+	dyn .@a;      // OK
+	dyn .@a[0];   // error
+	dyn .@a["x"]; // error
+
+Supported temporary scopes are:
+	.@var, @var, .var, $@var, 'var
+
+Permanent variables are not supported as dynamic dictionaries unless persistence
+support has explicitly been implemented for them.
+
+If the variable is not already dynamic, 'dyn' clears any previous legacy array
+content and creates an empty dynamic dictionary. If the variable is already
+dynamic, 'dyn <variable>;' is idempotent and does not clear it.
+
+	.@a = 1;
+	dyn .@a;
+	getdyntype(.@a);        // 1
+	getarraysizedyn(.@a);   // 0
+
+	dyn .@a;
+	.@a["x"] = 1;
+	dyn .@a;                // does not clear .@a
+	.@a["x"];              // still 1
+
+When a dynamic literal is supplied, the previous dynamic dictionary is replaced:
+
+	dyn .@a;
+	.@a["old"] = 1;
+	dyn .@a = [
+		"new": 2,
+	];
+	.@a["old"]; // 0
+	.@a["new"]; // 2
+
+Dynamic variables are dictionaries only. Direct scalar assignment to the root is
+an error:
+
+	dyn .@a;
+	.@a = 1; // error
+
+Store values under keys instead:
+
+	.@a[0] = 1;
+	.@a["name"] = "Bob";
+
+Dynamic literal syntax:
+
+	dyn .@a = [
+		"string_key": "value",
+		0: "integer key",
+		0x10: "hex integer key",
+		(.@expr$): "expression key",
+		"empty": [],
+	];
+
+Integer literal keys must be non-negative. Parenthesized key expressions must
+evaluate to either a string key or a non-negative integer key.
+
+---------------------------------------
+
+*setarraydyn <dynamic variable or branch>,<value>{,<value>...<value>};
+
+Writes a sequence of values under a dynamic dictionary branch using consecutive
+integer keys. The target must be dynamic. Use this for dynamic dictionaries; use
+'setarray' for legacy one-dimensional arrays.
+
+	dyn .@a;
+	setarraydyn .@a["list"], "a", "b", "c";
+
+This is equivalent to:
+
+	.@a["list"][0] = "a";
+	.@a["list"][1] = "b";
+	.@a["list"][2] = "c";
+
+A starting numeric child key may be supplied:
+
+	setarraydyn .@a["list"][5], "x", "y";
+
+This writes:
+
+	.@a["list"][5] = "x";
+	.@a["list"][6] = "y";
+
+To create or clear an empty dictionary branch, assign the empty literal '[]':
+
+	.@a["list"] = [];
+
+---------------------------------------
+
+*getarraysizedyn(<dynamic variable or branch>)
+
+Returns the number of direct keys under a dynamic dictionary path. The target
+must be dynamic. Use 'getarraysize' for legacy one-dimensional arrays.
+
+	dyn .@a;
+	.@a[1] = 5;
+	.@a[2][101] = 7;
+	getarraysizedyn(.@a);    // returns 2: keys 1 and 2
+	getarraysizedyn(.@a[2]); // returns 1: key 101
+
+Empty dictionary branches have size 0:
+
+	.@a["empty"] = [];
+	getarraysizedyn(.@a["empty"]); // returns 0
+
+---------------------------------------
+
+*getdyntype(<variable>)
+
+Returns whether a variable is dynamic.
+
+Return values:
+	0 - not dynamic
+	1 - dynamic dictionary
+
+Examples:
+
+	.@a = 1;
+	getdyntype(.@a); // 0
+
+	dyn .@a;
+	getdyntype(.@a); // 1
+
+---------------------------------------
+
+*del <dynamic variable or branch>;
+
+Deletes a dynamic dictionary branch or leaf. Deleting a missing key is allowed
+and does nothing.
+
+	dyn .@a;
+	.@a["list"] = "a";
+	.@a["truc"] = "b";
+	del .@a["truc"];
+
+After this, only the 'list' key remains under .@a.
+
+Deleting the root dynamic variable removes the dynamic dictionary itself. After
+that, getdyntype() returns 0 for that variable.
+
+	dyn .@a;
+	.@a["x"] = 1;
+	del .@a;
+	getdyntype(.@a); // 0
+
+---------------------------------------
+
 *getvariableofnpc(<variable>,"<npc name>")
 
 Returns a reference to a NPC variable (. prefix) from the target NPC.
@@ -1730,6 +2013,21 @@ Note:
  !! call it. That is to say, any functions should be placed above scripts or NPCs
  !! (or loaded in a separate file first) before attempting to call them directly.
 
+
+Multiple return values are supported through 'return' and can be read with
+'getreturn' and 'getreturncount'. When a function is used in an expression, only
+the first returned value is used for compatibility.
+
+	function%TAB%script%TAB%F_GetInfo%TAB%{
+		return "Bob", 20, "Knight";
+	}
+
+	.@name$ = callfunc("F_GetInfo"); // receives only "Bob"
+	callfunc "F_GetInfo";
+	debugmes getreturn(0); // Bob
+	debugmes getreturn(1); // 20
+	debugmes getreturn(2); // Knight
+
 ---------------------------------------
 
 *callsub <label>{,<argument>,...<argument>};
@@ -1788,6 +2086,31 @@ S_DunWarp:
 	}
 	close;
 
+
+---------------------------------------
+
+*callnpcsub "<npc name>","<label>"{,<argument>,...<argument>};
+
+Calls a label from another NPC as a subroutine. Arguments are available in the
+called label through 'getarg', and the label must return with 'return' to resume
+the caller. The attached RID is preserved, and the called NPC receives its own
+isolated .@ scope.
+
+Labels whose name starts with 'On' are not allowed through this command. Event
+labels should continue to be triggered through the normal event system.
+
+Example:
+
+	callnpcsub "WOE_CONTROL", "S_GetCastleInfo", "prtg_cas01";
+	.@castle$ = getreturn(0);
+	.@owner = getreturn(1);
+
+In the target NPC:
+
+	S_GetCastleInfo:
+		.@map$ = getarg(0);
+		return getcastlename(.@map$), getcastledata(.@map$, 1);
+
 ---------------------------------------
 
 *getarg(<index>{,<default_value>})
@@ -1861,18 +2184,53 @@ Example:
 
 ---------------------------------------
 
-*return {<value>};
+*return {<value>{,<value>...}};
+
+This command causes the script execution to leave a previously called function
+with callfunc, a label called with callsub, or a label called with callnpcsub,
+and return to the location where the call originated from.
+
+A return statement may supply no value, one value, or multiple values. Returned
+values replace the previous return buffer. The first returned value remains
+compatible with the traditional function-call form:
+
+	function%TAB%script%TAB%F_Test%TAB%{
+		return 10, "text", 30;
+	}
+
+	.@first = callfunc("F_Test"); // receives 10
+	callfunc "F_Test";
+	debugmes getreturncount(); // 3
+	debugmes getreturn(0);     // 10
+	debugmes getreturn(1);     // text
+	debugmes getreturn(2);     // 30
+
+Using this command outside of functions or labels referenced by callsub or
+callnpcsub will result in an error and termination of the script.
+
+---------------------------------------
+
+*getreturn(<index>)
+
+Returns a value from the most recent return buffer. The return buffer is replaced
+by each callfunc, callsub or callnpcsub call. Indexes start at 0.
+
+	callsub S_Info;
+	.@name$ = getreturn(0);
+	.@level = getreturn(1);
+
+	S_Info:
+		return "Bob", 99;
 
-This command causes the script execution to leave previously called function
-with callfunc or script with callsub and return to the location, where the call
-originated from. Optionally a return value can be supplied, when the call was
-done using the function form.
+---------------------------------------
+
+*getreturncount()
 
-Using this command outside of functions or scripts referenced by callsub will
-result in error and termination of the script.
+Returns the number of values in the most recent return buffer.
 
-	callfunc "<your function>";// when nothing is returned
-	set <variable>,callfunc("<your function>");// when a value is being returned
+	callfunc "F_Test";
+	for (.@i = 0; .@i < getreturncount(); .@i++)
+		debugmes getreturn(.@i);
 
 ---------------------------------------
 
@@ -2299,8 +2657,8 @@ Example:
 
 *setarray <array name>[<first value>],<value>{,<value>...<value>};
 
-This command will allow you to quickly fill up an array in one go. Check the
-Kafra scripts in the distribution to see this used a lot.
+This command will allow you to quickly fill up a legacy one-dimensional array in
+one go. Check the Kafra scripts in the distribution to see this used a lot.
 
     setarray .@array[0], 100, 200, 300, 400, 500, 600;
 
@@ -2316,6 +2674,9 @@ will produce:
  .@array[1]=300
  .@array[2]=150
 
+This command is legacy 1D only. It must not be used with dynamic dictionaries.
+Use 'setarraydyn' for variables declared with 'dyn'.
+
 ---------------------------------------
 
 *cleararray <array name>[<first value to alter>],<value>,<number of values to set>;
@@ -2330,6 +2691,10 @@ This command will change many array values at the same time to the same value.
     // This will make elements 1 and 2 change to 345
     cleararray .@array[1],345,2;
 
+For dictionary-style multidimensional arrays, this command remains intended for
+linear integer ranges. Prefer assigning individual dictionary entries or using
+'setarray' on a dictionary path when filling sequential children.
+
 See 'setarray'.
 
 ---------------------------------------
@@ -2363,22 +2728,32 @@ New Array:
 Notice that .@array[4] and .@array[5] won't be copied to the second array, and it will return a
 0.
 
+This command copies linear integer array ranges. For dictionary-style
+multidimensional arrays, copy individual entries or copy a sequential child
+range by addressing the corresponding integer child path. Destination and source
+variables must still have compatible value types unless they are dynamic
+variables.
+
 ---------------------------------------
 
 *deletearray <array name>[<first value>]{,<how much to delete>};
 
-This command will delete a specified number of array elements totally from an
-array, shifting all the elements beyond this towards the beginning.
+This command will delete a specified number of array elements totally from a
+legacy one-dimensional array, shifting all the elements beyond this towards the
+beginning.
 
     // This will delete array element 0, and move all the other array elements
     // up one place.
     deletearray .@array[0],1
 
 // This would delete array elements numbered 1, 2 and 3, leave element 0 in its
-// place, and move the other elements ups, so there are no gaps.
+// place, and move the other elements up, so there are no gaps.
 
     deletearray .@array[1],3
 
+This command is legacy 1D only. Use 'del' to remove keys or branches from a
+dynamic dictionary.
+
 ---------------------------------------
 
 *inarray <array name>,<value>;
@@ -2402,6 +2777,8 @@ It will return -1 if the value is not found.
 	inarray(.@array[0], 800);
 	//return -1 because 800 is not an element of the array .@array
 
+This command is legacy 1D only and must not be used with dynamic dictionaries.
+
 For more details, see the sample in 'doc/sample/inarray.txt'.
 
 ---------------------------------------
@@ -2490,40 +2867,103 @@ Whatever it returns is determined by type.
 
 *getarraysize(<array name>)
 
-This function returns highest index of the array that is filled.
-Notice that zeros and empty strings at the end of this array are not
-counted towards this number.
+For legacy one-dimensional arrays, this function returns the highest filled
+index plus one. Zeros and empty strings at the end of the array are not counted.
 
-For example:
+Examples:
 
-    setarray .@array[0], 100, 200, 300, 400, 500, 600;
-    set .@arraysize,getarraysize(.@array);
+    .@a[0] = 10;
+    .@a[2] = 30;
+    getarraysize(.@a); // returns 3
 
-This will make .@arraysize == 6. But if you try this:
+This command is legacy 1D only. It must not be used with dynamic dictionaries.
+Use 'getarraysizedyn' for variables declared with 'dyn'.
 
-    setarray .@array[0], 100, 200, 300, 400, 500, 600, 0;
-    set .@arraysize,getarraysize(.@array);
+---------------------------------------
 
-.@arraysize will still equal 6, even though you've set 7 values.
+*getelementofarray(<array name>,<key>{,<key>...})
 
----------------------------------------
+This command retrieves the value of the element of the given array at the given
+index or key path. This is equivalent to using bracket syntax:
+
+    <array name>[<key>]
+    <array name>[<key0>][<key1>]
 
-*getelementofarray(<array name>,<index>)
+The short bracket form is internally converted into a call to
+getelementofarray when the script is loaded.
+
+Examples:
 
-This command retrieves the value of the element of given array at given index.
-This is equivalent to using:
+    .@a[0][1] = 10;
+    getelementofarray(.@a, 0, 1);
 
-    <array name>[<index>]
+    .@a["truc"]["age"] = 20;
+    getelementofarray(.@a, "truc", "age");
 
-The reason for this is, that this short form is internally converted into a call
-to getelementofarray, when the script is loaded.
+This command is also useful when passing arrays to functions or accessing
+another NPC's arrays:
 
-Also useful when passing arrays to functions or accessing another npc's arrays:
     getelementofarray(getarg(0),<index>)
     getelementofarray(getvariableofnpc(.var, "testNPC"),<index>)
 
 ---------------------------------------
 
+*getarraykeys(<dynamic variable or branch>,<output keys array$>{,<output types array>})
+
+Returns the direct child keys that exist below a dynamic dictionary path. The
+keys are written into <output keys array$> and the return value is the number of
+keys written. If <output types array> is supplied, it receives the type of each
+key. This command is intended for dynamic dictionaries declared with 'dyn'.
+
+Key type values:
+	0 - integer key
+	1 - string key
+
+Examples:
+
+    dyn .@a;
+    .@a["truc"][0]["age"] = 20;
+    .@a["truc"][0]["level"] = 99;
+
+    .@count = getarraykeys(.@a["truc"][0], .@keys$, .@types);
+
+After this call, .@keys$ contains the direct keys under .@a["truc"][0], and
+.@types contains their key types. Integer keys are returned as strings in the
+keys array, with type 0 in the type array.
+
+The order of returned keys is not guaranteed. Sort them in script if a stable
+order is required.
+
+---------------------------------------
+
+*dyntostring(<dynamic variable or branch>)
+
+Returns a debug string representation of a dynamic dictionary branch or leaf,
+using the same format as the dynamic literal syntax. This is intended for
+debugging and inspection.
+
+	dyn .@a = [
+		"name": "Bob",
+		"items": [
+			0: 501,
+		],
+	];
+	debugmes dyntostring(.@a);
+
+Example output:
+
+	[
+		"name": "Bob",
+		"items": [
+			0: 501,
+		],
+	]
+
+The output is limited for safety. Very large structures may be truncated and a
+warning may be printed to the server console.
+
+---------------------------------------
+
 *readparam(<parameter number>{,"<character name>"})
 *readparam(<parameter number>{,<char_id>})
 
@@ -8246,6 +8686,20 @@ will not be displayed anywhere else.
 
 ---------------------------------------
 
+*debugdyn <dynamic variable or branch>;
+
+Prints a dynamic dictionary branch or leaf to the server console using the same
+format as 'dyntostring'. This is useful when inspecting large dynamic
+structures without storing the result in a script string first.
+
+	dyn .@a = [
+		"name": "Bob",
+		"age": 20,
+	];
+	debugdyn .@a;
+
+---------------------------------------
+
 *errormes "<message>";
 
 This command will send an error message to the server console (map-server window). It
@@ -11441,7 +11895,7 @@ Notes:
 
 ---------------------------------------
 
-*mesemotion(<emotion_id>);
+*mesemotion(<emotion_id>);
 
 Generates an emotion type string that can be used with an NPCs mes command.
 This allows NPC dialogue to display a client-side emotion icon inline with the message.
@@ -11452,7 +11906,7 @@ This command requires packet version 2023-03-02 or newer.
 
 Examples:
 
-	mes mesemotion(ET_SMILE) + " Hello there!"; // Displays an NPC message with a smile emotion icon before the text.
+	mes mesemotion(ET_SMILE) + " Hello there!"; // Displays an NPC message with a smile emotion icon before the text.
 
 ---------------------------------------
 
diff --git a/npc/scripts_test.conf b/npc/scripts_test.conf
index 650e9b4d45c..e2f887f92df 100644
--- a/npc/scripts_test.conf
+++ b/npc/scripts_test.conf
@@ -6,3 +6,10 @@
 npc: npc/test/infinite_warp.txt
 npc: npc/test/OnInterInit.txt
 npc: npc/test/npc_test_checkweight.txt
+
+npc: npc/test/mdarray_dyn_literal_integer_key_tests.txt
+npc: npc/test/mdarray_dyn_literal_empty_table_tests.txt
+npc: npc/test/mdarray_dyn_dict_only_tests.txt
+npc: npc/test/mdarray_dyn_empty_assignment_tests.txt
+npc: npc/test/mdarray_dyn_string_debug_tests.txt
+npc: npc/test/callnpcsub_multireturn_tests.txt
diff --git a/npc/test/callnpcsub_multireturn_tests.txt b/npc/test/callnpcsub_multireturn_tests.txt
new file mode 100644
index 00000000000..043b7f1975a
--- /dev/null
+++ b/npc/test/callnpcsub_multireturn_tests.txt
@@ -0,0 +1,189 @@
+//============================================================
+// npc/custom/callnpcsub_multireturn_tests.txt
+// Tests for callnpcsub and multiple return values.
+//============================================================
+// Load with:
+// npc: npc/custom/callnpcsub_multireturn_tests.txt
+//============================================================
+
+function	script	MR_ASSERT	{
+	.@ok = getarg(0);
+	.@msg$ = getarg(1);
+
+	if (.@ok)
+		debugmes "[OK] " + .@msg$;
+	else
+		debugmes "[FAIL] " + .@msg$;
+
+	return;
+}
+
+function	script	F_MR_Basic	{
+	return "Bob", 20, "Knight";
+}
+
+function	script	F_MR_Empty	{
+	return;
+}
+
+function	script	F_MR_One	{
+	return 123;
+}
+
+prontera,158,184,4	script	mr_test_runner	4_F_KAFRA1,{
+	mes "[mr_test_runner]";
+	mes "Runs callnpcsub / multiple-return tests.";
+	next;
+
+OnInit:
+	callsub S_CallFuncMultiple;
+	callsub S_CallFunc1;
+	callsub S_CallSubMultiple;
+	callsub S_CallNpcSubMultiple;
+	callsub S_EmptyAndSingleReturn;
+	callsub S_ReturnOverwrite;
+	callsub S_CallNpc2;
+	callsub S_ManualErrorChecks;
+	end;
+
+	mes "Done. Check the console for [OK]/[FAIL].";
+	close;
+
+S_CallFuncMultiple:
+	debugmes "-- S_CallFuncMultiple";
+
+	callfunc "F_MR_Basic";
+	.@count = getreturncount();
+	.@r0$ = getreturn(0);
+	.@r1 = getreturn(1);
+	.@r2$ = getreturn(2);
+
+	callfunc "MR_ASSERT", .@count == 3, "callfunc return count == 3";
+	callfunc "MR_ASSERT", .@r0$ == "Bob", "callfunc return[0] == Bob";
+	callfunc "MR_ASSERT", .@r1 == 20, "callfunc return[1] == 20";
+	callfunc "MR_ASSERT", .@r2$ == "Knight", "callfunc return[2] == Knight";
+
+	return;
+
+S_CallFunc1:
+	debugmes "-- S_CallFunc1";
+
+	.@name$ = callfunc("F_MR_Basic");
+	.@count = getreturncount();
+	.@age = getreturn(1);
+
+	callfunc "MR_ASSERT", .@name$ == "Bob", "direct callfunc expression gets first return";
+	callfunc "MR_ASSERT", .@count == 3, "return buffer still has 3 values";
+	callfunc "MR_ASSERT", .@age == 20, "getreturn still reads second value";
+
+	return;
+
+S_CallSubMultiple:
+	debugmes "-- S_CallSubMultiple";
+
+	callsub S_LocalInfo, "Prontera";
+	.@count = getreturncount();
+	.@r0$ = getreturn(0);
+	.@r1 = getreturn(1);
+	.@r2$ = getreturn(2);
+
+	callfunc "MR_ASSERT", .@count == 3, "callsub return count == 3";
+	callfunc "MR_ASSERT", .@r0$ == "Prontera", "callsub return[0]";
+	callfunc "MR_ASSERT", .@r1 == 100, "callsub return[1]";
+	callfunc "MR_ASSERT", .@r2$ == "local", "callsub return[2]";
+
+	return;
+
+S_LocalInfo:
+	.@name$ = getarg(0);
+	return .@name$, 100, "local";
+
+S_CallNpcSubMultiple:
+	debugmes "-- S_CallNpcSubMultiple";
+
+	callnpcsub "MR_TARGET", "S_GetInfo", "prtg_cas01";
+	.@count = getreturncount();
+	.@map$ = getreturn(0);
+	.@region$ = getreturn(1);
+	.@x = getreturn(2);
+	.@y = getreturn(3);
+
+	callfunc "MR_ASSERT", .@count == 4, "callnpcsub return count == 4";
+	callfunc "MR_ASSERT", .@map$ == "prtg_cas01", "callnpcsub return[0] map";
+	callfunc "MR_ASSERT", .@region$ == "Prontera", "callnpcsub return[1] region";
+	callfunc "MR_ASSERT", .@x == 134, "callnpcsub return[2] x";
+	callfunc "MR_ASSERT", .@y == 65, "callnpcsub return[3] y";
+
+	return;
+
+S_EmptyAndSingleReturn:
+	debugmes "-- S_EmptyAndSingleReturn";
+
+	callfunc "F_MR_Empty";
+	.@empty_count = getreturncount();
+
+	callfunc "F_MR_One";
+	.@one_count = getreturncount();
+	.@one_value = getreturn(0);
+
+	callfunc "MR_ASSERT", .@empty_count == 0, "return; gives zero return values";
+	callfunc "MR_ASSERT", .@one_count == 1, "single return count == 1";
+	callfunc "MR_ASSERT", .@one_value == 123, "single return value == 123";
+
+	return;
+
+S_ReturnOverwrite:
+	debugmes "-- S_ReturnOverwrite";
+
+	callfunc "F_MR_Basic";
+	.@first_count = getreturncount();
+
+	callfunc "F_MR_One";
+	.@second_count = getreturncount();
+	.@second_value = getreturn(0);
+
+	callfunc "MR_ASSERT", .@first_count == 3, "initial return count == 3";
+	callfunc "MR_ASSERT", .@second_count == 1, "second call overwrites return buffer";
+	callfunc "MR_ASSERT", .@second_value == 123, "second call return[0] == 123";
+
+	return;
+
+S_CallNpc2:
+	debugmes "-- S_CallNpc2";
+
+	.@local_value = 10;
+	callnpcsub "MR_TARGET", "S_ScopeTest", .@local_value;
+	.@r0 = getreturn(0);
+	.@r1 = getreturn(1);
+
+	callfunc "MR_ASSERT", .@local_value == 10, "caller .@ scope was not modified";
+	callfunc "MR_ASSERT", .@r0 == 11, "target received argument and returned arg + 1";
+	callfunc "MR_ASSERT", .@r1 == 99, "target .@ local scope worked";
+
+	return;
+
+S_ManualErrorChecks:
+	debugmes "-- S_ManualErrorChecks";
+	debugmes "Manual checks that should ERROR + stop script:";
+	debugmes "  callnpcsub \"MR_TARGET\", \"OnInit\";";
+	debugmes "  callnpcsub \"MissingNPC\", \"S_Label\";";
+	debugmes "  callnpcsub \"MR_TARGET\", \"S_Missing\";";
+	debugmes "  callfunc \"F_MR_One\"; getreturn(99);";
+	return;
+}
+
+-	script	MR_TARGET	-1,{
+	end;
+
+S_GetInfo:
+	.@map$ = getarg(0);
+	return .@map$, "Prontera", 134, 65;
+
+S_ScopeTest:
+	.@v = getarg(0);
+	.@local_only = 99;
+	return .@v + 1, .@local_only;
+
+OnInit:
+	end;
+}
diff --git a/npc/test/mdarray_dyn_dict_only_tests.txt b/npc/test/mdarray_dyn_dict_only_tests.txt
new file mode 100644
index 00000000000..ad2697c8308
--- /dev/null
+++ b/npc/test/mdarray_dyn_dict_only_tests.txt
@@ -0,0 +1,293 @@
+//============================================================
+// npc/custom/mdarray_dyn_dict_only_tests.txt
+// Regression tests for strict dictionary-only dyn model.
+//============================================================
+//
+// Requires:
+// - dyn creates an empty dictionary
+// - getdyntype: 0 = not dyn, 1 = dyn dictionary
+// - scalar assignment to dyn root is forbidden
+// - path = [] creates/clears an empty dynamic dictionary branch
+// - del deletes a dynamic key/branch or clears the root dictionary
+//
+// Load with:
+// npc: npc/custom/mdarray_dyn_dict_only_tests.txt
+//============================================================
+
+function	script	MD_DICT_ONLY_ASSERT	{
+	.@ok = getarg(0);
+	.@msg$ = getarg(1);
+
+	if (.@ok)
+		debugmes "[OK] " + .@msg$;
+	else
+		debugmes "[FAIL] " + .@msg$;
+
+	return;
+}
+
+prontera,155,184,4	script	mdarray_dyn_dict_only	4_F_KAFRA1,{
+	mes "[mdarray_dyn_dict_only]";
+	mes "Runs strict dyn dictionary-only tests.";
+	next;
+
+OnInit:
+	callsub S_DynCreatesEmptyDict;
+	callsub S_DynIsIdempotent;
+	callsub S_String;
+	callsub S_ChildAssignment;
+	callsub S_EmptyBranchAssignment;
+	callsub S_DelBranch;
+	callsub S_DelRoot;
+	callsub S_DelMissing;
+	callsub S_NestedDel;
+	callsub S_SetArrayDynStillWorks;
+	callsub S_GetArrayKeysAfterDel;
+	callsub S_ManualErrorChecks;
+	end;
+
+	mes "Done. Check the console for [OK]/[FAIL].";
+	close;
+
+//------------------------------------------------------------
+// dyn .@a creates an empty dictionary, not a scalar.
+//------------------------------------------------------------
+S_DynCreatesEmptyDict:
+	debugmes "-- S_DynCreatesEmptyDict";
+
+	.@legacy = 123;
+	callfunc "MD_DICT_ONLY_ASSERT", getdyntype(.@legacy) == 0, "legacy variable is not dyn";
+
+	dyn .@a;
+
+	callfunc "MD_DICT_ONLY_ASSERT", getdyntype(.@a) == 1, "dyn root is dictionary";
+	callfunc "MD_DICT_ONLY_ASSERT", getarraysizedyn(.@a) == 0, "new dyn dictionary is empty";
+
+	return;
+
+//------------------------------------------------------------
+// dyn .@a is idempotent when .@a is already dyn.
+//------------------------------------------------------------
+S_DynIsIdempotent:
+	debugmes "-- S_DynIsIdempotent";
+
+	dyn .@a;
+	.@a["x"] = 1;
+
+	dyn .@a;
+
+	callfunc "MD_DICT_ONLY_ASSERT", getarraysizedyn(.@a) == 1, "dyn redeclare does not clear existing dyn";
+	callfunc "MD_DICT_ONLY_ASSERT", .@a["x"] == 1, "dyn redeclare keeps value";
+
+	return;
+
+//------------------------------------------------------------
+// dyn .@a = [...] is assignment and overwrites previous dyn.
+//------------------------------------------------------------
+S_String:
+	debugmes "-- S_String";
+
+	dyn .@a;
+	.@a["old"] = 1;
+
+	dyn .@a = [
+		"new": 2,
+	];
+
+	callfunc "MD_DICT_ONLY_ASSERT", getarraysizedyn(.@a) == 1, "literal assignment resets previous dyn dictionary";
+	callfunc "MD_DICT_ONLY_ASSERT", .@a["old"] == 0, "old key removed by literal assignment";
+	callfunc "MD_DICT_ONLY_ASSERT", .@a["new"] == 2, "new key exists after literal assignment";
+
+	return;
+
+//------------------------------------------------------------
+// Indexed assignment auto-creates dictionary branches.
+//------------------------------------------------------------
+S_ChildAssignment:
+	debugmes "-- S_ChildAssignment";
+
+	dyn .@a;
+
+	.@a["list"][0] = "a";
+	.@a["list"][1] = "b";
+	.@a["meta"]["count"] = 2;
+
+	callfunc "MD_DICT_ONLY_ASSERT", getarraysizedyn(.@a) == 2, "root has list and meta";
+	callfunc "MD_DICT_ONLY_ASSERT", getarraysizedyn(.@a["list"]) == 2, "list has two numeric children";
+	callfunc "MD_DICT_ONLY_ASSERT", .@a["list"][0] == "a", "list[0] == a";
+	callfunc "MD_DICT_ONLY_ASSERT", .@a["list"][1] == "b", "list[1] == b";
+	callfunc "MD_DICT_ONLY_ASSERT", .@a["meta"]["count"] == 2, "meta.count == 2";
+
+	return;
+
+//------------------------------------------------------------
+// path = [] creates or clears an empty dictionary branch.
+//------------------------------------------------------------
+S_EmptyBranchAssignment:
+	debugmes "-- S_EmptyBranchAssignment";
+
+	dyn .@a;
+
+	.@a["list"][0] = "a";
+	.@a["list"][1] = "b";
+
+	callfunc "MD_DICT_ONLY_ASSERT", getarraysizedyn(.@a["list"]) == 2, "list starts with two children";
+
+	.@a["list"] = [];
+
+	callfunc "MD_DICT_ONLY_ASSERT", getdyntype(.@a["list"]) == 1, "list remains a dictionary after []";
+	callfunc "MD_DICT_ONLY_ASSERT", getarraysizedyn(.@a["list"]) == 0, "list is now empty";
+	callfunc "MD_DICT_ONLY_ASSERT", .@a["list"][0] == 0, "old list[0] removed";
+	callfunc "MD_DICT_ONLY_ASSERT", getarraysizedyn(.@a) == 1, "root still has explicit empty list branch";
+
+	.@a["list"][0] = "c";
+	callfunc "MD_DICT_ONLY_ASSERT", .@a["list"][0] == "c", "empty branch can be filled again";
+
+	return;
+
+//------------------------------------------------------------
+// del removes a scalar leaf key.
+//------------------------------------------------------------
+S_DelBranch:
+	debugmes "-- S_DelBranch";
+
+	dyn .@a;
+
+	.@a["list"] = "a";
+	.@a["truc"] = "b";
+
+	callfunc "MD_DICT_ONLY_ASSERT", getarraysizedyn(.@a) == 2, "root starts with two scalar leaves";
+
+	del .@a["truc"];
+
+	callfunc "MD_DICT_ONLY_ASSERT", getarraysizedyn(.@a) == 1, "root has one key after del";
+	callfunc "MD_DICT_ONLY_ASSERT", .@a["list"] == "a", "list leaf remains";
+	callfunc "MD_DICT_ONLY_ASSERT", .@a["truc"] == 0, "deleted key reads as default 0";
+
+	return;
+
+//------------------------------------------------------------
+// del .@a clears the root dictionary but keeps it dynamic.
+//------------------------------------------------------------
+S_DelRoot:
+	debugmes "-- S_DelRoot";
+
+	dyn .@a;
+
+	.@a["x"] = 1;
+	.@a["y"][0] = 2;
+
+	callfunc "MD_DICT_ONLY_ASSERT", getarraysizedyn(.@a) == 2, "root starts with two keys";
+
+	del .@a;
+
+	callfunc "MD_DICT_ONLY_ASSERT", getdyntype(.@a) == 0, "root is no longer dyn after del";
+
+	return;
+
+//------------------------------------------------------------
+// Deleting a missing key is a no-op.
+//------------------------------------------------------------
+S_DelMissing:
+	debugmes "-- S_DelMissing";
+
+	dyn .@a;
+
+	.@a["x"] = 1;
+
+	del .@a["missing"];
+	del .@a["missing"]["deep"];
+
+	callfunc "MD_DICT_ONLY_ASSERT", getarraysizedyn(.@a) == 1, "missing del does not create or remove keys";
+	callfunc "MD_DICT_ONLY_ASSERT", .@a["x"] == 1, "existing key remains after missing del";
+
+	return;
+
+//------------------------------------------------------------
+// Deleting a dictionary branch removes all descendants.
+//------------------------------------------------------------
+S_NestedDel:
+	debugmes "-- S_NestedDel";
+
+	dyn .@a;
+
+	.@a["user"]["name"] = "Bob";
+	.@a["user"]["age"] = 20;
+	.@a["other"] = 5;
+
+	callfunc "MD_DICT_ONLY_ASSERT", getarraysizedyn(.@a["user"]) == 2, "user starts with two children";
+
+	del .@a["user"];
+
+	callfunc "MD_DICT_ONLY_ASSERT", getarraysizedyn(.@a) == 1, "only other remains at root";
+	callfunc "MD_DICT_ONLY_ASSERT", .@a["user"]["name"] == 0, "user.name removed";
+	callfunc "MD_DICT_ONLY_ASSERT", .@a["user"]["age"] == 0, "user.age removed";
+	callfunc "MD_DICT_ONLY_ASSERT", .@a["other"] == 5, "other remains";
+
+	return;
+
+//------------------------------------------------------------
+// setarraydyn with values remains valid.
+//------------------------------------------------------------
+S_SetArrayDynStillWorks:
+	debugmes "-- S_SetArrayDynStillWorks";
+
+	dyn .@a;
+
+	setarraydyn .@a["list"], "a", "b", "c";
+
+	callfunc "MD_DICT_ONLY_ASSERT", getarraysizedyn(.@a["list"]) == 3, "setarraydyn created three children";
+	callfunc "MD_DICT_ONLY_ASSERT", .@a["list"][0] == "a", "list[0] == a";
+	callfunc "MD_DICT_ONLY_ASSERT", .@a["list"][1] == "b", "list[1] == b";
+	callfunc "MD_DICT_ONLY_ASSERT", .@a["list"][2] == "c", "list[2] == c";
+
+	.@a["list"] = [];
+
+	callfunc "MD_DICT_ONLY_ASSERT", getarraysizedyn(.@a["list"]) == 0, "[] clears setarraydyn branch";
+
+	return;
+
+//------------------------------------------------------------
+// getarraykeys should reflect del and [] accurately.
+//------------------------------------------------------------
+S_GetArrayKeysAfterDel:
+	debugmes "-- S_GetArrayKeysAfterDel";
+
+	dyn .@a;
+
+	.@a[0] = "zero";
+	.@a["0"] = "string-zero";
+	.@a["empty"] = [];
+	.@a["remove"] = 1;
+
+	del .@a["remove"];
+
+	.@count = getarraykeys(.@a, .@keys$, .@types);
+
+	debugmes "root key count after del = " + .@count;
+	for (.@i = 0; .@i < .@count; .@i++)
+		debugmes "key[" + .@i + "]=" + .@keys$[.@i] + " type=" + .@types[.@i];
+
+	callfunc "MD_DICT_ONLY_ASSERT", .@count == 3, "root has int 0, string 0, and empty";
+	callfunc "MD_DICT_ONLY_ASSERT", .@a[0] == "zero", "integer key 0 remains";
+	callfunc "MD_DICT_ONLY_ASSERT", .@a["0"] == "string-zero", "string key 0 remains";
+	callfunc "MD_DICT_ONLY_ASSERT", getarraysizedyn(.@a["empty"]) == 0, "empty branch remains";
+
+	return;
+
+//------------------------------------------------------------
+// Manual error checks. Do not run here because they stop the script.
+//------------------------------------------------------------
+S_ManualErrorChecks:
+	debugmes "-- S_ManualErrorChecks";
+	debugmes "Manual checks that should ERROR + stop script:";
+	debugmes "  dyn .@bad; .@bad = 1;";
+	debugmes "  dyn .@bad; mes .@bad;";
+	debugmes "  dyn .@bad; .@bad[0] = 1; mes .@bad;";
+	debugmes "  dyn .@bad; setarray .@bad, 1, 2;";
+	debugmes "  dyn .@bad; getarraysize(.@bad);";
+	debugmes "  dyn .@bad; inarray(.@bad, 1);";
+	debugmes "  dyn .@bad; countinarray(.@bad, 1);";
+	debugmes "  dyn .@bad[0];";
+	return;
+}
diff --git a/npc/test/mdarray_dyn_empty_assignment_tests.txt b/npc/test/mdarray_dyn_empty_assignment_tests.txt
new file mode 100644
index 00000000000..c3014008222
--- /dev/null
+++ b/npc/test/mdarray_dyn_empty_assignment_tests.txt
@@ -0,0 +1,112 @@
+//============================================================
+// npc/custom/mdarray_dyn_empty_assignment_tests.txt
+// Regression tests for dynamic empty table assignment: path = [];
+//============================================================
+//
+// Load with:
+// npc: npc/custom/mdarray_dyn_empty_assignment_tests.txt
+//============================================================
+
+function	script	MD_EMPTY_ASSIGN_ASSERT	{
+	.@ok = getarg(0);
+	.@msg$ = getarg(1);
+
+	if (.@ok)
+		debugmes "[OK] " + .@msg$;
+	else
+		debugmes "[FAIL] " + .@msg$;
+
+	return;
+}
+
+prontera,156,184,4	script	mdemptyassign_test	4_F_KAFRA1,{
+	mes "[mdemptyassign_test]";
+	mes "Runs dyn empty assignment tests.";
+	next;
+
+OnInit:
+	sleep 1000;
+	callsub S_String1;
+	callsub S_String2;
+	callsub S_String3;
+	callsub S_ClearExistingBranch;
+	callsub S_String5;
+	end;
+
+	mes "Done. Check the console for [OK]/[FAIL].";
+	close;
+
+S_String1:
+	debugmes "-- S_String1";
+
+	dyn .@a;
+	.@a["old"] = 1;
+
+	.@a = [];
+
+	callfunc "MD_EMPTY_ASSIGN_ASSERT", getdyntype(.@a) == 1, ".@a = [] keeps/creates dyn dict";
+	callfunc "MD_EMPTY_ASSIGN_ASSERT", getarraysizedyn(.@a) == 0, ".@a = [] clears root dict";
+	callfunc "MD_EMPTY_ASSIGN_ASSERT", .@a["old"] == 0, "old key removed";
+
+	return;
+
+S_String2:
+	debugmes "-- S_String2";
+
+	dyn .@a;
+	.@a["list"][0] = "a";
+	.@a["list"][1] = "b";
+
+	.@a["list"] = [];
+
+	callfunc "MD_EMPTY_ASSIGN_ASSERT", getdyntype(.@a["list"]) == 1, "branch is dyn dict after []";
+	callfunc "MD_EMPTY_ASSIGN_ASSERT", getarraysizedyn(.@a["list"]) == 0, "branch is empty after []";
+	callfunc "MD_EMPTY_ASSIGN_ASSERT", .@a["list"][0] == 0, "old child 0 removed";
+	callfunc "MD_EMPTY_ASSIGN_ASSERT", getarraysizedyn(.@a) == 1, "root still has explicit empty branch";
+
+	return;
+
+S_String3:
+	debugmes "-- S_String3";
+
+	dyn .@a;
+	.@a["user"]["items"][0]["id"] = 501;
+	.@a["user"]["items"][1]["id"] = 502;
+
+	.@a["user"]["items"] = [];
+
+	callfunc "MD_EMPTY_ASSIGN_ASSERT", getdyntype(.@a["user"]["items"]) == 1, "deep branch is dict after []";
+	callfunc "MD_EMPTY_ASSIGN_ASSERT", getarraysizedyn(.@a["user"]["items"]) == 0, "deep branch empty after []";
+	callfunc "MD_EMPTY_ASSIGN_ASSERT", .@a["user"]["items"][0]["id"] == 0, "deep old child removed";
+
+	return;
+
+S_ClearExistingBranch:
+	debugmes "-- S_ClearExistingBranch";
+
+	dyn .@a;
+	setarraydyn .@a["letters"], "a", "b", "c";
+
+	callfunc "MD_EMPTY_ASSIGN_ASSERT", getarraysizedyn(.@a["letters"]) == 3, "letters starts with 3 values";
+
+	.@a["letters"] = [];
+
+	callfunc "MD_EMPTY_ASSIGN_ASSERT", getarraysizedyn(.@a["letters"]) == 0, "letters cleared by []";
+	.@a["letters"][0] = "z";
+	callfunc "MD_EMPTY_ASSIGN_ASSERT", .@a["letters"][0] == "z", "letters can be filled again";
+
+	return;
+
+S_String5:
+	debugmes "-- S_String5";
+
+	dyn .@a;
+
+	// This is a normal string, not a table literal.
+	.@a["text"] = "[]";
+
+	callfunc "MD_EMPTY_ASSIGN_ASSERT", .@a["text"] == "[]", "string \"[]\" remains a scalar string";
+	callfunc "MD_EMPTY_ASSIGN_ASSERT", getarraysizedyn(.@a) == 1, "root has one scalar key";
+
+	return;
+}
diff --git a/npc/test/mdarray_dyn_literal_empty_table_tests.txt b/npc/test/mdarray_dyn_literal_empty_table_tests.txt
new file mode 100644
index 00000000000..0f8232010b0
--- /dev/null
+++ b/npc/test/mdarray_dyn_literal_empty_table_tests.txt
@@ -0,0 +1,243 @@
+//============================================================
+// npc/custom/mdarray_dyn_literal_empty_table_tests.txt
+// Regression tests for dyn literal empty tables and unsigned integer keys.
+//============================================================
+//
+// Requires:
+// - dyn literal support
+// - integer literal keys
+// - empty table literals []
+//
+// Load with:
+// npc: npc/custom/mdarray_dyn_literal_empty_table_tests.txt
+//============================================================
+
+function	script	MD_EMPTY_ASSERT	{
+	.@ok = getarg(0);
+	.@msg$ = getarg(1);
+
+	if (.@ok)
+		debugmes "[OK] " + .@msg$;
+	else
+		debugmes "[FAIL] " + .@msg$;
+
+	return;
+}
+
+prontera,154,184,4	script	mdlit_empty_table_test	4_F_KAFRA1,{
+	mes "[mdlit_empty_table_test]";
+	mes "Runs dyn literal empty-table tests.";
+	next;
+OnInit:
+	callsub S_RootEmpty;
+	callsub S_NestedEmpty;
+	callsub S_IntegerKeys;
+	callsub S_StringZeroVsIntegerZero;
+	callsub S_ExpressionKeys;
+	callsub S_EmptyThenFill;
+	callsub S_FillThenEmptyOverwrite;
+	callsub S_WoeLikeConfig;
+	callsub S_ManualNegativeKeyChecks;
+	end;
+
+	mes "Done. Check the console for [OK]/[FAIL].";
+	close;
+
+S_RootEmpty:
+	debugmes "-- S_RootEmpty";
+
+	dyn .@a = [];
+
+	callfunc "MD_EMPTY_ASSERT", getdyntype(.@a) == 2, "root [] creates a dyn dictionary";
+	callfunc "MD_EMPTY_ASSERT", getarraysizedyn(.@a) == 0, "root [] has size 0";
+
+	return;
+
+S_NestedEmpty:
+	debugmes "-- S_NestedEmpty";
+
+	dyn .@a = [
+		"empty": [],
+		"container": [
+			"child": [],
+		],
+	];
+
+	callfunc "MD_EMPTY_ASSERT", getdyntype(.@a) == 2, "root is dict";
+	callfunc "MD_EMPTY_ASSERT", getarraysizedyn(.@a) == 2, "root has two keys";
+	callfunc "MD_EMPTY_ASSERT", getdyntype(.@a["empty"]) == 2, "nested empty branch is dict";
+	callfunc "MD_EMPTY_ASSERT", getarraysizedyn(.@a["empty"]) == 0, "nested empty branch size 0";
+	callfunc "MD_EMPTY_ASSERT", getdyntype(.@a["container"]["child"]) == 2, "deep empty branch is dict";
+	callfunc "MD_EMPTY_ASSERT", getarraysizedyn(.@a["container"]["child"]) == 0, "deep empty branch size 0";
+
+	return;
+
+S_IntegerKeys:
+	debugmes "-- S_IntegerKeys";
+
+	dyn .@a = [
+		0: "zero",
+		1: "one",
+		123: "one-two-three",
+		0x10: "sixteen",
+	];
+
+	callfunc "MD_EMPTY_ASSERT", .@a[0] == "zero", "integer key 0";
+	callfunc "MD_EMPTY_ASSERT", .@a[1] == "one", "integer key 1";
+	callfunc "MD_EMPTY_ASSERT", .@a[123] == "one-two-three", "integer key 123";
+	callfunc "MD_EMPTY_ASSERT", .@a[16] == "sixteen", "hex integer key 0x10";
+	callfunc "MD_EMPTY_ASSERT", getarraysizedyn(.@a) == 4, "root has 4 integer keys";
+
+	return;
+
+S_StringZeroVsIntegerZero:
+	debugmes "-- S_StringZeroVsIntegerZero";
+
+	dyn .@a = [
+		0: "integer-zero",
+		"0": "string-zero",
+	];
+
+	callfunc "MD_EMPTY_ASSERT", .@a[0] == "integer-zero", "integer 0 value";
+	callfunc "MD_EMPTY_ASSERT", .@a["0"] == "string-zero", "string \"0\" value";
+	callfunc "MD_EMPTY_ASSERT", .@a[0] != .@a["0"], "integer 0 and string \"0\" are distinct";
+
+	return;
+
+S_ExpressionKeys:
+	debugmes "-- S_ExpressionKeys";
+
+	.@i = 5;
+	.@k$ = "name";
+
+	dyn .@a = [
+		(.@i): "five",
+		(.@i + 1): "six",
+		(.@k$): "Bob",
+	];
+
+	callfunc "MD_EMPTY_ASSERT", .@a[5] == "five", "parenthesized integer expression key";
+	callfunc "MD_EMPTY_ASSERT", .@a[6] == "six", "parenthesized arithmetic expression key";
+	callfunc "MD_EMPTY_ASSERT", .@a["name"] == "Bob", "parenthesized string expression key";
+
+	return;
+
+S_EmptyThenFill:
+	debugmes "-- S_EmptyThenFill";
+
+	dyn .@a = [
+		"list": [],
+	];
+
+	callfunc "MD_EMPTY_ASSERT", getdyntype(.@a["list"]) == 2, "list starts as empty dict";
+	callfunc "MD_EMPTY_ASSERT", getarraysizedyn(.@a["list"]) == 0, "list empty size 0";
+	debugmes "size test = " + getarraysizedyn(.@a);
+
+	.@a["list"][0] = "a";
+	.@a["list"][1] = "b";
+
+	callfunc "MD_EMPTY_ASSERT", getdyntype(.@a["list"]) == 2, "		getdyntype is dict";
+
+	callfunc "MD_EMPTY_ASSERT", .@a["list"][0] == "a", "empty dict later receives child 0";
+	callfunc "MD_EMPTY_ASSERT", .@a["list"][1] == "b", "empty dict later receives child 1";
+	callfunc "MD_EMPTY_ASSERT", getarraysizedyn(.@a["list"]) == 2, "list size after fill is 2";
+
+	.@a["list"] = 0;
+	callfunc "MD_EMPTY_ASSERT", getdyntype(.@a["list"]) == 2, "list starts as empty dict";
+	callfunc "MD_EMPTY_ASSERT", getarraysizedyn(.@a["list"]) == 0, "list empty size 0";
+	debugmes "size test = " + getarraysizedyn(.@a);
+
+je voudrais changer 3 choses:
+1. ne plus autoriser le scalaire avec dyn
+```
+dyn .@a;
+
+.@a = 1;	// error
+.@a[0] = 1;	// ok
+```
+(donc ajuster aussi getdyntype)
+
+2. à la place de `= 0` pour supprimer une valeur/dictionnaire, je veux implementer une commande. On pourrait l'appeler `del`?
+```
+dyn .@a;
+
+.@a["list"] = "a";
+.@a["truc"] = "b";
+
+del .@a["truc"];// "truc" supprimé, il ne reste que "list"
+del .@a;// tout est supprimé
+```
+c'est l'équivalent de `deletearray`, mais pour dyn
+
+3. Implenter `[]`
+```
+dyn .@a;
+
+.@a["list"][0] = "a";
+.@a["list"][0] = "b";
+
+.@a["list"] = [];	// la clé "list" existe mais array vide
+```
+
+Fourni moi un patch basé sur le fichier joint. Mais avant cela, as tu besoin de clarifications?
+
+	return;
+
+S_FillThenEmptyOverwrite:
+	debugmes "-- S_FillThenEmptyOverwrite";
+
+	dyn .@a = [
+		"list": [
+			0: "a",
+			1: "b",
+		],
+	];
+
+	callfunc "MD_EMPTY_ASSERT", getarraysizedyn(.@a["list"]) == 2, "list starts with 2 children";
+
+	// setarraydyn .@a["list"];
+	// .@a = [];
+
+	callfunc "MD_EMPTY_ASSERT", getdyntype(.@a["list"]) == 2, "setarraydyn without values keeps branch as dict";
+	callfunc "MD_EMPTY_ASSERT", getarraysizedyn(.@a["list"]) == 0, "setarraydyn without values clears branch to empty dict";
+
+	return;
+
+S_WoeLikeConfig:
+	debugmes "-- S_WoeLikeConfig";
+
+	.@region$ = "Prontera";
+	.@castle$ = "prtg_cas01";
+
+	dyn .data = [
+		(.@region$): [
+			(.@castle$): [
+				"agitend": "Agit#prtg_cas01::OnAgitEnd",
+				"eventkillmob": "Agit#prtg_cas01::OnAgitBreak",
+				"warp": [
+					"map": "prt_gld",
+					"x": 134,
+					"y": 65,
+				],
+				"empty_meta": [],
+				0: "integer-child",
+			],
+		],
+	];
+
+	callfunc "MD_EMPTY_ASSERT", .data["Prontera"]["prtg_cas01"]["agitend"] == "Agit#prtg_cas01::OnAgitEnd", "woe-like agitend";
+	callfunc "MD_EMPTY_ASSERT", .data["Prontera"]["prtg_cas01"]["warp"]["map"] == "prt_gld", "woe-like warp map";
+	callfunc "MD_EMPTY_ASSERT", .data["Prontera"]["prtg_cas01"]["warp"]["x"] == 134, "woe-like warp x";
+	callfunc "MD_EMPTY_ASSERT", .data["Prontera"]["prtg_cas01"][0] == "integer-child", "integer child under string path";
+	callfunc "MD_EMPTY_ASSERT", getdyntype(.data["Prontera"]["prtg_cas01"]["empty_meta"]) == 2, "empty_meta is dict";
+	callfunc "MD_EMPTY_ASSERT", getarraysizedyn(.data["Prontera"]["prtg_cas01"]["empty_meta"]) == 0, "empty_meta size 0";
+
+	return;
+
+S_ManualNegativeKeyChecks:
+	debugmes "-- S_ManualNegativeKeyChecks";
+	debugmes "The following scripts should fail at parse/runtime and are not executed here:";
+	debugmes "  dyn .@bad = [ -1: \"bad\" ];     // parse error: negative literal key";
+	debugmes "  .@i = -1; dyn .@bad = [ (.@i): \"bad\" ]; // runtime error: negative key";
+	return;
+}
diff --git a/npc/test/mdarray_dyn_literal_integer_key_tests.txt b/npc/test/mdarray_dyn_literal_integer_key_tests.txt
new file mode 100644
index 00000000000..4bbc410eb50
--- /dev/null
+++ b/npc/test/mdarray_dyn_literal_integer_key_tests.txt
@@ -0,0 +1,146 @@
+//============================================================
+// npc/custom/mdarray_dyn_literal_integer_key_tests.txt
+// Regression tests for dyn literal integer keys.
+//============================================================
+//
+// Requires dyn literal support.
+// Tests:
+// - integer literal keys: 0, 1, 123
+// - signed integer keys: -1
+// - string key "0" remains distinct from integer key 0
+// - parenthesized expression keys still work
+// - nested integer keys
+//
+// Load with:
+// npc: npc/custom/mdarray_dyn_literal_integer_key_tests.txt
+//============================================================
+
+function	script	MD_LIT_INT_ASSERT	{
+	.@ok = getarg(0);
+	.@msg$ = getarg(1);
+
+	if (.@ok)
+		debugmes "[OK] " + .@msg$;
+	else
+		debugmes "[FAIL] " + .@msg$;
+
+	return;
+}
+
+prontera,153,184,4	script	mdlit_intkey_test	4_F_KAFRA1,{
+	mes "[mdlit_intkey_test]";
+	mes "Runs dyn literal integer-key tests.";
+	next;
+OnInit:
+	callsub S_IntegerRootKeys;
+	callsub S_IntegerNestedKeys;
+	callsub S_StringZeroVsIntegerZero;
+	callsub S_ExpressionKeys;
+	callsub S_MixedLiteral;
+	end;
+
+	mes "Done. Check the console for [OK]/[FAIL].";
+	close;
+
+S_IntegerRootKeys:
+	debugmes "-- S_IntegerRootKeys";
+
+	dyn .@a = [
+		0: "zero",
+		1: "one",
+		123: "one-two-three",
+		// -1: "minus-one",
+	];
+	// dyn .@a;
+	// .@a[-1] = 1;
+	
+
+	callfunc "MD_LIT_INT_ASSERT", .@a[0] == "zero", "integer key 0";
+	callfunc "MD_LIT_INT_ASSERT", .@a[1] == "one", "integer key 1";
+	callfunc "MD_LIT_INT_ASSERT", .@a[123] == "one-two-three", "integer key 123";
+	// callfunc "MD_LIT_INT_ASSERT", .@a[-1] == "minus-one", "integer key -1 if negative keys are enabled";
+
+	callfunc "MD_LIT_INT_ASSERT", getarraysizedyn(.@a) == 3, "root has 3 integer keys";
+
+	return;
+
+S_IntegerNestedKeys:
+	debugmes "-- S_IntegerNestedKeys";
+
+	dyn .@a = [
+		0: [
+			1: [
+				2: "deep",
+			],
+		],
+		10: [
+			20: 30,
+		],
+	];
+
+	callfunc "MD_LIT_INT_ASSERT", .@a[0][1][2] == "deep", "nested integer path [0][1][2]";
+	callfunc "MD_LIT_INT_ASSERT", .@a[10][20] == 30, "nested integer path [10][20]";
+	callfunc "MD_LIT_INT_ASSERT", getarraysizedyn(.@a[0][1]) == 1, "nested branch [0][1] has one key";
+
+	return;
+
+S_StringZeroVsIntegerZero:
+	debugmes "-- S_StringZeroVsIntegerZero";
+
+	dyn .@a = [
+		0: "integer-zero",
+		"0": "string-zero",
+	];
+
+	callfunc "MD_LIT_INT_ASSERT", .@a[0] == "integer-zero", "integer 0 value";
+	callfunc "MD_LIT_INT_ASSERT", .@a["0"] == "string-zero", "string \"0\" value";
+	callfunc "MD_LIT_INT_ASSERT", .@a[0] != .@a["0"], "integer 0 and string \"0\" are distinct";
+
+	return;
+
+S_ExpressionKeys:
+	debugmes "-- S_ExpressionKeys";
+
+	.@i = 5;
+	.@k$ = "name";
+
+	dyn .@a = [
+		(.@i): "five",
+		(.@i + 1): "six",
+		(.@k$): "Bob",
+	];
+
+	callfunc "MD_LIT_INT_ASSERT", .@a[5] == "five", "parenthesized integer expression key";
+	callfunc "MD_LIT_INT_ASSERT", .@a[6] == "six", "parenthesized arithmetic expression key";
+	callfunc "MD_LIT_INT_ASSERT", .@a["name"] == "Bob", "parenthesized string expression key";
+
+	return;
+
+S_MixedLiteral:
+	debugmes "-- S_MixedLiteral";
+
+	.@region$ = "Prontera";
+	.@castle$ = "prtg_cas01";
+
+	dyn .data = [
+		(.@region$): [
+			(.@castle$): [
+				"agitend": "Agit#prtg_cas01::OnAgitEnd",
+				"eventkillmob": "Agit#prtg_cas01::OnAgitBreak",
+				"warp": [
+					"map": "prt_gld",
+					"x": 134,
+					"y": 65,
+				],
+				0: "integer-child",
+			],
+		],
+	];
+
+	callfunc "MD_LIT_INT_ASSERT", .data["Prontera"]["prtg_cas01"]["agitend"] == "Agit#prtg_cas01::OnAgitEnd", "string/expression region path";
+	callfunc "MD_LIT_INT_ASSERT", .data["Prontera"]["prtg_cas01"]["warp"]["map"] == "prt_gld", "nested warp map";
+	callfunc "MD_LIT_INT_ASSERT", .data["Prontera"]["prtg_cas01"]["warp"]["x"] == 134, "nested warp x";
+	callfunc "MD_LIT_INT_ASSERT", .data["Prontera"]["prtg_cas01"][0] == "integer-child", "integer child under string path";
+
+	return;
+}
diff --git a/npc/test/mdarray_dyn_string_debug_tests.txt b/npc/test/mdarray_dyn_string_debug_tests.txt
new file mode 100644
index 00000000000..85a45c3f563
--- /dev/null
+++ b/npc/test/mdarray_dyn_string_debug_tests.txt
@@ -0,0 +1,195 @@
+//============================================================
+// npc/custom/mdarray_dyn_string_debug_tests.txt
+// Regression tests for dyntostring() and debugdyn.
+//============================================================
+//
+// Requires:
+// - dyn dictionary-only model
+// - dyn literal support
+// - dyntostring(<dyn variable or branch>)
+// - debugdyn <dyn variable or branch>
+//
+// Load with:
+// npc: npc/custom/mdarray_dyn_string_debug_tests.txt
+//============================================================
+
+function	script	MD_STRDBG_ASSERT	{
+	.@ok = getarg(0);
+	.@msg$ = getarg(1);
+
+	if (.@ok)
+		debugmes "[OK] " + .@msg$;
+	else
+		debugmes "[FAIL] " + .@msg$;
+
+	return;
+}
+
+prontera,157,184,4	script	mdarray_dyn_string_debug	4_F_KAFRA1,{
+	mes "[mdarray_dyn_string_debug]";
+	mes "Runs dyntostring/debugdyn tests.";
+	next;
+
+OnInit:
+	sleep 2000;
+	callsub S_BasicDump;
+	callsub S_Escaping;
+	callsub S_EmptyTables;
+	callsub S_IntegerAndStringKeys;
+	callsub S_BranchDump;
+	callsub S_MissingPathDump;
+	callsub S_NodeLimit;
+	callsub S_DebugDyn;
+	end;
+
+	mes "Done. Check console for [OK]/[FAIL].";
+	close;
+
+S_BasicDump:
+	debugmes "-- S_BasicDump";
+
+	dyn .@a = [
+		"name": "Bob",
+		"age": 20,
+		"items": [
+			0: 501,
+			1: 502,
+		],
+	];
+
+	.@s$ = dyntostring(.@a);
+	debugmes .@s$;
+
+	callfunc "MD_STRDBG_ASSERT", compare(.@s$, "[") == 1, "dump contains table open";
+	callfunc "MD_STRDBG_ASSERT", compare(.@s$, "\"name\": \"Bob\"") == 1, "dump contains name";
+	callfunc "MD_STRDBG_ASSERT", compare(.@s$, "\"age\": 20") == 1, "dump contains age";
+	callfunc "MD_STRDBG_ASSERT", compare(.@s$, "\"items\": [") == 1, "dump contains nested items";
+	callfunc "MD_STRDBG_ASSERT", compare(.@s$, "0: 501") == 1, "dump contains integer key 0";
+	callfunc "MD_STRDBG_ASSERT", compare(.@s$, "1: 502") == 1, "dump contains integer key 1";
+
+	return;
+
+S_Escaping:
+	debugmes "-- S_Escaping";
+
+	dyn .@a;
+	.@a["quote"] = "He said \"Hello\"";
+	.@a["slash"] = "a\\b";
+	.@a["line"] = "a\nb";
+
+	.@s$ = dyntostring(.@a);
+	debugmes .@s$;
+
+	callfunc "MD_STRDBG_ASSERT", compare(.@s$, "\\\"Hello\\\"") == 1, "dump escapes quotes";
+	callfunc "MD_STRDBG_ASSERT", compare(.@s$, "a\\\\b") == 1, "dump escapes backslash";
+	callfunc "MD_STRDBG_ASSERT", compare(.@s$, "a\\nb") == 1, "dump escapes newline";
+
+	return;
+
+S_EmptyTables:
+	debugmes "-- S_EmptyTables";
+
+	dyn .@a = [
+		"empty": [],
+		"filled": [
+			"x": 1,
+		],
+	];
+
+	.@s$ = dyntostring(.@a);
+	debugmes .@s$;
+
+	callfunc "MD_STRDBG_ASSERT", compare(.@s$, "\"empty\": []") == 1, "dump contains empty table";
+	callfunc "MD_STRDBG_ASSERT", compare(.@s$, "\"filled\": [") == 1, "dump contains filled table";
+
+	.@branch$ = dyntostring(.@a["empty"]);
+	callfunc "MD_STRDBG_ASSERT", .@branch$ == "[]", "empty branch dumps as []";
+
+	return;
+
+S_IntegerAndStringKeys:
+	debugmes "-- S_IntegerAndStringKeys";
+
+	dyn .@a = [
+		0: "integer-zero",
+		"0": "string-zero",
+		10: "ten",
+		"name": "Bob",
+	];
+
+	.@s$ = dyntostring(.@a);
+	debugmes .@s$;
+
+	callfunc "MD_STRDBG_ASSERT", compare(.@s$, "0: \"integer-zero\"") == 1, "dump contains integer 0 key";
+	callfunc "MD_STRDBG_ASSERT", compare(.@s$, "\"0\": \"string-zero\"") == 1, "dump contains string 0 key";
+	callfunc "MD_STRDBG_ASSERT", compare(.@s$, "10: \"ten\"") == 1, "dump contains integer 10 key";
+
+	return;
+
+S_BranchDump:
+	debugmes "-- S_BranchDump";
+
+	dyn .@a = [
+		"user": [
+			"name": "Bob",
+			"age": 20,
+		],
+		"other": 123,
+	];
+
+	.@s$ = dyntostring(.@a["user"]);
+	debugmes .@s$;
+
+	callfunc "MD_STRDBG_ASSERT", compare(.@s$, "\"name\": \"Bob\"") == 1, "branch dump contains name";
+	callfunc "MD_STRDBG_ASSERT", compare(.@s$, "\"age\": 20") == 1, "branch dump contains age";
+	callfunc "MD_STRDBG_ASSERT", compare(.@s$, "\"other\"") == 0, "branch dump does not contain sibling";
+
+	.@leaf$ = dyntostring(.@a["other"]);
+	callfunc "MD_STRDBG_ASSERT", .@leaf$ == "123", "scalar leaf dumps as scalar";
+
+	return;
+
+S_MissingPathDump:
+	debugmes "-- S_MissingPathDump";
+
+	dyn .@a;
+	.@s$ = dyntostring(.@a["missing"]);
+
+	callfunc "MD_STRDBG_ASSERT", .@s$ == "0", "missing path dumps as default 0";
+
+	return;
+
+S_NodeLimit:
+	debugmes "-- S_NodeLimit";
+
+	dyn .@a;
+
+	for (.@i = 0; .@i < 105; .@i++)
+		.@a[.@i] = .@i;
+
+	.@s$ = dyntostring(.@a);
+	debugmes .@s$;
+
+	callfunc "MD_STRDBG_ASSERT", compare(.@s$, "\"...\": \"<max nodes reached>\"") == 1, "dump contains max nodes marker";
+	callfunc "MD_STRDBG_ASSERT", compare(.@s$, "99: 99") == 1, "dump contains node 99";
+	callfunc "MD_STRDBG_ASSERT", compare(.@s$, "104: 104") == 0, "dump truncates before node 104";
+
+	return;
+
+S_DebugDyn:
+	debugmes "-- S_DebugDyn";
+
+	dyn .@a = [
+		"debug": "ok",
+		"nested": [
+			0: "value",
+		],
+	];
+
+	debugdyn .@a;
+	debugdyn .@a["nested"];
+
+	callfunc "MD_STRDBG_ASSERT", 1, "debugdyn executed; check console output manually";
+
+	return;
+}
diff --git a/src/map/script.cpp b/src/map/script.cpp
index 3ba32613130..b7498267982 100644
--- a/src/map/script.cpp
+++ b/src/map/script.cpp
@@ -13,6 +13,11 @@
 #include <cmath>
 #include <csetjmp>
 #include <cstdlib> // atoi, strtol, strtoll, exit
+#include <string>
+#include <algorithm>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
 
 #ifdef PCRE_SUPPORT
 #include <pcre.h> // preg_match
@@ -244,8 +249,20 @@ static int32 parse_options = 0;
 DBMap* script_get_label_db(void) { return scriptlabel_db; }
 DBMap* script_get_userfunc_db(void) { return userfunc_db; }
 
+// Per-script label positions used by callnpcsub. rAthena labels are normally
+// resolved during parsing and are not stored in script_code, so we keep a small
+// side table keyed by script_code*.
+static std::unordered_map<script_code*, std::unordered_map<std::string, int32>> script_code_label_positions;
+static std::unordered_map<std::string, int32> parser_current_label_positions;
+
+// Last multiple return values per running script state. The normal expression
+// return value remains the first returned value for backward compatibility.
+static std::unordered_map<script_state*, std::vector<script_data>> script_return_values;
+
 // important buildin function references for usage in scripts
 static int32 buildin_set_ref = 0;
+static int32 buildin_dyn_ref = 0;
+static int32 buildin_setarraydyn_ref = 0;
 static int32 buildin_callsub_ref = 0;
 static int32 buildin_callfunc_ref = 0;
 static int32 buildin_getelementofarray_ref = 0;
@@ -562,6 +579,7 @@ static void script_reportdata(struct script_data* data)
 
 
 /// Reports on the console information about the current built-in function.
+
 static void script_reportfunc(struct script_state* st)
 {
 	int32 params, id;
@@ -854,6 +872,7 @@ void set_label(int32 l,int32 pos, const char* script_pos_cur)
 	}
 	str_data[l].type=(str_data[l].type == C_USERFUNC ? C_USERFUNC_POS : C_POS);
 	str_data[l].label=pos;
+	parser_current_label_positions[get_str(l)] = pos;
 	for(i=str_data[l].backpatch;i>=0 && i!=0x00ffffff;){
 		int32 next=GETVALUE(script_buf,i);
 		script_buf[i-1]=(str_data[l].type == C_USERFUNC ? C_USERFUNC_POS : C_POS);
@@ -954,6 +973,29 @@ static int32 add_word(const char* p)
 }
 
 /// Parses a function call.
+/// Returns true when the first argument of dyn is visibly indexed in source code.
+/// Runtime references cannot reliably distinguish `.@a` from legacy `.@a[0]`,
+/// so this parse-time guard is required to forbid declarations such as
+/// `dyn .@a[0];` and `dyn(.@a["key"]);`.
+static bool parse_dyn_first_arg_is_indexed(const char* p)
+{
+	const char* q = skip_space(p);
+
+	if (q == nullptr)
+		return false;
+
+	if (*q == '(')
+		q = skip_space(q + 1);
+
+	if (q == nullptr)
+		return false;
+
+	q = skip_word(q);
+	q = skip_space(q);
+
+	return q != nullptr && *q == '[';
+}
+
 /// The argument list can have parenthesis or not.
 /// The number of arguments is checked.
 static
@@ -1002,6 +1044,10 @@ const char* parse_callfunc(const char* p, int32 require_paren, int32 is_custom)
 
 	p = skip_word(p);
 	p = skip_space(p);
+
+	if (str_data[func].type == C_FUNC && strcmp(get_str(func), "dyn") == 0 && parse_dyn_first_arg_is_indexed(p))
+		disp_error_message("parse_callfunc: dyn expects a root variable, not an indexed array element", p);
+
 	syntax.curly[syntax.curly_count].type = TYPE_ARGLIST;
 	syntax.curly[syntax.curly_count].count = 0;
 	if( *p == ';' )
@@ -1079,24 +1125,27 @@ static void parse_nextline(bool first, const char* p)
  */
 void parse_variable_sub_push(int32 word, const char *p2)
 {
-	if( p2 ) { // Process the variable index
-		const char *p3 = nullptr;
+	if (p2) { // Process one or more array indexes
+		const char* p3 = p2;
 
 		// Push the getelementofarray method into the stack
 		add_scriptl(buildin_getelementofarray_ref);
 		add_scriptc(C_ARG);
 		add_scriptl(word);
 
-		// Process the sub-expression for this assignment
-		p3 = parse_subexpr(p2 + 1, 1);
-		p3 = skip_space(p3);
+		while (p3 && *p3 == '[') {
+			// Process this index sub-expression
+			p3 = parse_subexpr(p3 + 1, 1);
+			p3 = skip_space(p3);
+
+			if (*p3 != ']')
+				disp_error_message("Missing closing ']' parenthesis for the variable assignment.", p3);
 
-		if( *p3 != ']' ) // Closing parenthesis is required for this script
-			disp_error_message("Missing closing ']' parenthesis for the variable assignment.", p3);
+			p3 = skip_space(p3 + 1);
+		}
 
 		// Push the closing function stack operator onto the stack
 		add_scriptc(C_FUNC);
-		p3++;
 	} else // No array index, simply push the variable or value onto the stack
 		add_scriptl(word);
 }
@@ -1128,15 +1177,19 @@ const char* parse_variable(const char* p) {
 		return nullptr;
 	}
 
-	if( *p == '[' ) {// array variable so process the array as appropriate
-		int32 i,j;
-		for( p2 = p, i = 0, j = 1; p; ++ i ) {
-			if( *p ++ == ']' && --(j) == 0 ) break;
-			if( *p == '[' ) ++ j;
-		}
+	if (*p == '[') {// array variable so process one or more array index groups
+		p2 = p;
+		while (p && *p == '[') {
+			int32 i, j;
+			for (i = 0, j = 1, ++p; p; ++i) {
+				if (*p == '[') ++j;
+				else if (*p == ']' && --j == 0) { ++p; break; }
+				++p;
+			}
 
-		if( !(p = skip_space(p)) ) {// end of line or invalid characters remaining
-			disp_error_message("Missing right expression or closing bracket for variable.", p);
+			if (!(p = skip_space(p))) {// end of line or invalid characters remaining
+				disp_error_message("Missing right expression or closing bracket for variable.", p);
+			}
 		}
 	}
 
@@ -1393,16 +1446,18 @@ const char* parse_simpleexpr(const char *p)
 
 		p=skip_word(p);
 		if( *p == '[' ){
-			// array(name[i] => getelementofarray(name,i) )
+			// array(name[i][j][k] => getelementofarray(name,i,j,k) )
 			add_scriptl(buildin_getelementofarray_ref);
 			add_scriptc(C_ARG);
 			add_scriptl(l);
 
-			p=parse_subexpr(p+1,-1);
-			p=skip_space(p);
-			if( *p != ']' )
-				disp_error_message("parse_simpleexpr: unmatched ']'",p);
-			++p;
+			while (*p == '[') {
+				p = parse_subexpr(p + 1, -1);
+				p = skip_space(p);
+				if (*p != ']')
+					disp_error_message("parse_simpleexpr: unmatched ']'", p);
+				p = skip_space(p + 1);
+			}
 			add_scriptc(C_FUNC);
 		}else
 			add_scriptl(l);
@@ -1489,6 +1544,349 @@ const char* parse_expr(const char *p)
 	return p;
 }
 
+
+/*==========================================
+ * Dynamic table literal parser
+ *------------------------------------------
+ * This parser handles a rAthena-specific literal form that is only accepted in
+ * a dyn declaration:
+ *
+ *     dyn .data = [
+ *         "key": "value",
+ *         (expr$): [ "nested": 1 ],
+ *     ];
+ *
+ * It deliberately does not make '[' a general expression literal.  Outside of
+ * this very specific context, '[' keeps its normal meaning as an array index.
+ */
+static const char* parse_dyn_literal_skip_string(const char* p)
+{
+	if (*p != '"')
+		return p;
+
+	++p;
+	while (*p && *p != '"') {
+		if ((unsigned char)p[-1] <= 0x7e && *p == '\\') {
+			p = skip_escaped_c(p);
+			continue;
+		}
+		if (*p == '\n')
+			disp_error_message("parse_dyn_literal: unexpected newline in string key", p);
+		++p;
+	}
+	if (!*p)
+		disp_error_message("parse_dyn_literal: unexpected eof in string key", p);
+	return p + 1;
+}
+
+static const char* parse_dyn_literal_skip_paren_expr(const char* p)
+{
+	if (*p != '(')
+		return p;
+
+	int32 depth = 1;
+	++p;
+	while (*p && depth > 0) {
+		if (*p == '"') {
+			p = parse_dyn_literal_skip_string(p);
+			continue;
+		}
+		if (*p == '(')
+			++depth;
+		else if (*p == ')')
+			--depth;
+		++p;
+	}
+	if (depth != 0)
+		disp_error_message("parse_dyn_literal: unmatched ')' in key expression", p);
+	return p;
+}
+
+static const char* parse_dyn_literal_skip_number(const char* p)
+{
+	const char* q = p;
+
+	// Integer literal keys follow rAthena array-index rules: only non-negative
+	// integer literals are accepted here. Use a parenthesized expression if a
+	// runtime value is needed; negative results will still be rejected at runtime.
+	if (*q == '-' || *q == '+')
+		disp_error_message("parse_dyn_literal: integer literal keys must be non-negative and unsigned", p);
+
+	if (q[0] == '0' && q[1] == 'x') {
+		q += 2;
+		if (!ISXDIGIT(*q))
+			disp_error_message("parse_dyn_literal: expected hexadecimal digit after 0x", p);
+		while (ISXDIGIT(*q))
+			++q;
+	} else {
+		if (!ISDIGIT(*q))
+			disp_error_message("parse_dyn_literal: expected decimal digit", p);
+		while (ISDIGIT(*q))
+			++q;
+	}
+	return q;
+}
+
+static const char* parse_dyn_literal_skip_key(const char* p)
+{
+	p = skip_space(p);
+	if (*p == '"')
+		return parse_dyn_literal_skip_string(p);
+	if (*p == '(')
+		return parse_dyn_literal_skip_paren_expr(p);
+	if (ISDIGIT(*p))
+		return parse_dyn_literal_skip_number(p);
+	if (*p == '-' || *p == '+')
+		disp_error_message("parse_dyn_literal: integer literal keys must be non-negative and unsigned", p);
+	disp_error_message("parse_dyn_literal: expected string key, integer key, or parenthesized key expression", p);
+	return p;
+}
+
+struct parse_dyn_literal_key {
+	const char* p;
+	bool integer_literal;
+};
+
+static parse_dyn_literal_key parse_dyn_literal_make_key(const char* p)
+{
+	p = skip_space(p);
+	return { p, is_number(p) };
+}
+
+static void parse_dyn_literal_emit_key(const parse_dyn_literal_key& key)
+{
+	/*
+	 * String keys and parenthesized expression keys were already emitted by
+	 * parse_subexpr(). Integer literal keys are handled the same way, but are
+	 * tracked explicitly so the dyn literal grammar documents and preserves the
+	 * intended distinction between:
+	 *
+	 *     0:   "value"   // integer key 0
+	 *     "0": "value"   // string key "0"
+	 *     (.@i): value   // runtime expression key
+	 */
+	parse_subexpr(key.p, -1);
+}
+
+static void parse_dyn_literal_emit_ref(int32 root_word, const std::vector<parse_dyn_literal_key>& keys)
+{
+	if (keys.empty()) {
+		add_scriptl(root_word);
+		return;
+	}
+
+	add_scriptl(buildin_getelementofarray_ref);
+	add_scriptc(C_ARG);
+	add_scriptl(root_word);
+
+	for (const parse_dyn_literal_key& key : keys)
+		parse_dyn_literal_emit_key(key);
+
+	add_scriptc(C_FUNC);
+}
+
+static void parse_dyn_literal_emit_dyn_decl(int32 root_word)
+{
+	add_scriptl(buildin_dyn_ref);
+	add_scriptc(C_ARG);
+	add_scriptl(root_word);
+	add_scriptc(C_FUNC);
+}
+
+static void parse_dyn_literal_emit_empty_dict(int32 root_word, const std::vector<parse_dyn_literal_key>& keys)
+{
+	/*
+	 * setarraydyn with no values is used internally by the literal parser to
+	 * create an explicit empty dictionary at the target path. This preserves the
+	 * distinction between a missing/default scalar and an empty dictionary.
+	 */
+	add_scriptl(buildin_setarraydyn_ref);
+	add_scriptc(C_ARG);
+	parse_dyn_literal_emit_ref(root_word, keys);
+	add_scriptc(C_FUNC);
+}
+
+static const char* parse_dyn_literal_emit_set(int32 root_word, const std::vector<parse_dyn_literal_key>& keys, const char* value)
+{
+	add_scriptl(buildin_set_ref);
+	add_scriptc(C_ARG);
+	parse_dyn_literal_emit_ref(root_word, keys);
+	const char* end = parse_subexpr(value, -1);
+	add_scriptc(C_FUNC);
+	return end;
+}
+
+static const char* parse_dyn_literal_table(const char* p, int32 root_word, std::vector<parse_dyn_literal_key>& keys)
+{
+	p = skip_space(p);
+	if (*p != '[')
+		disp_error_message("parse_dyn_literal: expected '['", p);
+	p = skip_space(p + 1);
+
+	if (*p == ']') {
+		parse_dyn_literal_emit_empty_dict(root_word, keys);
+		return p + 1;
+	}
+
+	while (*p) {
+		const char* key = skip_space(p);
+		const char* key_end = parse_dyn_literal_skip_key(key);
+		p = skip_space(key_end);
+		if (*p != ':')
+			disp_error_message("parse_dyn_literal: expected ':' after key", p);
+		p = skip_space(p + 1);
+
+		keys.push_back(parse_dyn_literal_make_key(key));
+		if (*p == '[') {
+			p = parse_dyn_literal_table(p, root_word, keys);
+		} else {
+			const char* value = p;
+			p = parse_dyn_literal_emit_set(root_word, keys, value);
+		}
+		keys.pop_back();
+
+		p = skip_space(p);
+		if (*p == ',') {
+			p = skip_space(p + 1);
+			if (*p == ']') {
+				++p;
+				return p;
+			}
+			continue;
+		}
+		if (*p == ']') {
+			++p;
+			return p;
+		}
+		disp_error_message("parse_dyn_literal: expected ',' or ']'", p);
+	}
+
+	disp_error_message("parse_dyn_literal: unexpected eof", p);
+	return p;
+}
+
+static const char* parse_dyn_literal_statement(const char* p)
+{
+	const char* word_end = skip_word(p);
+	if ((size_t)(word_end - p) != 3 || strncmp(p, "dyn", 3) != 0)
+		return nullptr;
+
+	p = skip_space(word_end);
+	if (p == nullptr || *p == 0)
+		return nullptr;
+
+	const char* root = p;
+	const char* root_end = skip_word(root);
+	if (root_end == root)
+		return nullptr;
+
+	const char* q = skip_space(root_end);
+	if (*q != '=')
+		return nullptr;
+	q = skip_space(q + 1);
+	if (*q != '[')
+		return nullptr;
+
+	int32 root_word = add_word(root);
+	if (str_data[root_word].type == C_FUNC || str_data[root_word].type == C_USERFUNC || str_data[root_word].type == C_USERFUNC_POS)
+		disp_error_message("parse_dyn_literal: dyn target cannot have the same name as a function or label", root);
+
+	parse_dyn_literal_emit_dyn_decl(root_word);
+
+	std::vector<parse_dyn_literal_key> keys;
+	// A literal declaration is an assignment, not a no-op redeclaration.
+	// Clear any previous dynamic dictionary before filling it with literal entries.
+	parse_dyn_literal_emit_empty_dict(root_word, keys);
+	p = parse_dyn_literal_table(q, root_word, keys);
+	p = skip_space(p);
+	if (*p != ';')
+		disp_error_message("parse_dyn_literal: expected ';' after literal", p);
+	return p + 1;
+}
+
+/*
+ * Parses explicit empty dynamic dictionary assignment:
+ *
+ *     .@a = [];
+ *     .@a["branch"] = [];
+ *
+ * This is intentionally limited to the empty literal. Non-empty literals are
+ * still only supported by the dyn declaration syntax for now:
+ *
+ *     dyn .@a = [ "key": "value" ];
+ */
+static const char* parse_dyn_empty_assignment_statement(const char* p)
+{
+	const char* lhs = skip_space(p);
+	const char* q = lhs;
+
+	if (q == nullptr || *q == 0)
+		return nullptr;
+
+	// Avoid stealing the dedicated dyn literal grammar.
+	const char* word_end = skip_word(q);
+	if ((size_t)(word_end - q) == 3 && strncmp(q, "dyn", 3) == 0)
+		return nullptr;
+
+	// Find the top-level '='. The left side is parsed later by parse_subexpr(),
+	// so we only need enough scanning to identify '= [] ;'.
+	int32 paren = 0;
+	int32 bracket = 0;
+	while (*q) {
+		if (*q == '"') {
+			q = parse_dyn_literal_skip_string(q);
+			continue;
+		}
+		if (*q == '(')
+			++paren;
+		else if (*q == ')' && paren > 0)
+			--paren;
+		else if (*q == '[')
+			++bracket;
+		else if (*q == ']' && bracket > 0)
+			--bracket;
+		else if (*q == '=' && paren == 0 && bracket == 0)
+			break;
+		else if ((*q == ';' || *q == '\n') && paren == 0 && bracket == 0)
+			return nullptr;
+		++q;
+	}
+
+	if (*q != '=')
+		return nullptr;
+
+	const char* rhs = skip_space(q + 1);
+	if (rhs == nullptr || rhs[0] != '[')
+		return nullptr;
+	rhs = skip_space(rhs + 1);
+	if (rhs == nullptr || rhs[0] != ']')
+		return nullptr;
+	rhs = skip_space(rhs + 1);
+	if (rhs == nullptr || rhs[0] != ';')
+		disp_error_message("parse_dyn_literal: expected ';' after empty dynamic table assignment", rhs);
+
+	add_scriptl(buildin_setarraydyn_ref);
+	add_scriptc(C_ARG);
+
+	/*
+	 * parse_subexpr() has no explicit end pointer. If we pass the original
+	 * source pointer directly, it will continue past the left-hand side and may
+	 * try to parse the "= []" part as a normal expression. That is exactly
+	 * what makes statements such as:
+	 *
+	 *     .@a["list"] = [];
+	 *
+	 * fail with "parse_simpleexpr: unexpected character" on '['. Compile the
+	 * left-hand side from an isolated temporary string so only the reference
+	 * expression is emitted as the first argument of setarraydyn.
+	 */
+	std::string lhs_expr(lhs, q - lhs);
+	parse_subexpr(lhs_expr.c_str(), -1);
+	add_scriptc(C_FUNC);
+
+	return rhs + 1;
+}
+
 /*==========================================
  * Analysis of the line
  *------------------------------------------*/
@@ -1497,6 +1895,14 @@ const char* parse_line(const char* p)
 	const char* p2;
 
 	p=skip_space(p);
+	if ((p2 = parse_dyn_literal_statement(p)) != nullptr) {
+		p = parse_syntax_close(p2);
+		return p;
+	}
+	if ((p2 = parse_dyn_empty_assignment_statement(p)) != nullptr) {
+		p = parse_syntax_close(p2);
+		return p;
+	}
 	if(*p==';') {
 		//Close decision for if(); for(); while();
 		p = parse_syntax_close(p + 1);
@@ -2257,6 +2663,8 @@ static void add_buildin_func(void)
 			str_data[n].deprecated = (buildin_func[i].deprecated != nullptr);
 
 			if (!strcmp(buildin_func[i].name, "setr")) buildin_set_ref = n;
+			else if (!strcmp(buildin_func[i].name, "dyn")) buildin_dyn_ref = n;
+			else if (!strcmp(buildin_func[i].name, "setarraydyn")) buildin_setarraydyn_ref = n;
 			else if (!strcmp(buildin_func[i].name, "callsub")) buildin_callsub_ref = n;
 			else if (!strcmp(buildin_func[i].name, "callfunc")) buildin_callfunc_ref = n;
 			else if( !strcmp(buildin_func[i].name, "getelementofarray") ) buildin_getelementofarray_ref = n;
@@ -2487,6 +2895,7 @@ struct script_code* parse_script_( const char *src, const char *file, int32 line
 		return nullptr;// empty script
 
 	memset(&syntax,0,sizeof(syntax));
+	parser_current_label_positions.clear();
 
 	script_buf=(unsigned char *)aMalloc(SCRIPT_BLOCK_SIZE*sizeof(unsigned char));
 	script_pos=0;
@@ -2513,6 +2922,7 @@ struct script_code* parse_script_( const char *src, const char *file, int32 line
 			if(str_data[j].type == C_NOP) str_data[j].type = C_NAME;
 		for(j=0; j<size; j++)
 			linkdb_final(&syntax.curly[j].case_label);
+		parser_current_label_positions.clear();
 		return nullptr;
 	}
 
@@ -2657,6 +3067,8 @@ struct script_code* parse_script_( const char *src, const char *file, int32 line
 	code->script_size = script_size;
 	code->local.vars = nullptr;
 	code->local.arrays = nullptr;
+	script_code_label_positions[code] = parser_current_label_positions;
+	parser_current_label_positions.clear();
 	return code;
 }
 
@@ -2671,11 +3083,163 @@ static bool script_rid2sd_( struct script_state *st, map_session_data** sd, cons
 		ShowError("%s: fatal error ! player not attached!\n",func);
 		script_reportfunc(st);
 		script_reportsrc(st);
-		st->state = END;
+		st->state = END;
 		return false;
 	}
 }
 
+
+struct script_array_dynamic_value {
+	bool is_string = false;
+	int64 num = 0;
+	std::string str;
+};
+
+struct script_array_shape_info;
+static script_array_shape_info* script_array_dynamic_shape_get(script_state* st, map_session_data* sd, int64 uid, const char* name, reg_db* ref);
+static script_array_shape_info* script_array_shape_get_by_name(script_state* st, map_session_data* sd, const char* name, reg_db* ref, int32 id);
+static bool script_array_dynamic_reference_is_child(script_array_shape_info* shape, uint32 idx);
+static script_array_dynamic_value* script_array_dynamic_get_value(script_state* st, map_session_data* sd, int64 uid, const char* name, reg_db* ref);
+static bool script_array_is_dynamic_ref(script_state* st, map_session_data* sd, int64 uid, const char* name, reg_db* ref);
+
+
+/*
+ * -----------------------------------------------------------------------------
+ * Support des tableaux multidimensionnels / dictionnaires de script
+ * -----------------------------------------------------------------------------
+ * rAthena encode historiquement un élément de tableau sous la forme :
+ *   reference_uid(id_variable, index_1d)
+ * où index_1d est un entier unique. Cette représentation ne permet pas de
+ * stocker directement une coordonnée comme ["truc"][0]["age"].
+ *
+ * Le code ci-dessous ajoute donc une table de correspondance par variable :
+ *   coordonnée typée -> slot interne uint32
+ *
+ * Exemple :
+ *   .@a["truc"][0]["age"]
+ * est représenté comme la coordonnée :
+ *   { string:"truc", int:0, string:"age" }
+ * puis converti en un slot interne, par exemple 42. Le reste du moteur voit
+ * alors une référence classique :
+ *   reference_uid(id_de_.@a, 42)
+ *
+ * Important :
+ * - les clés entières et string sont typées, donc [0] et ["0"] sont distinctes ;
+ * - le slot 0 reste réservé à la référence racine de la variable ;
+ * - les slots hashés commencent à 1 ;
+ * - les clés string sont, pour l'instant, réservées aux variables temporaires
+ *   (.@, @, ., $@) afin d'éviter les problèmes de sauvegarde SQL des variables
+ *   permanentes ;
+ * - la table coord_to_slot ne stocke que les cellules réellement utilisées : une
+ *   lecture d'une valeur absente doit rester une valeur par défaut rAthena
+ *   (0 ou "") et ne doit pas créer une nouvelle entrée.
+ *
+ * Le support `dyn`, lorsqu'il est présent dans la branche, repose sur le même
+ * principe de slot interne, mais stocke en plus le type réel de la valeur
+ * (entier ou string). Cela permet à une variable déclarée dynamique de contenir
+ * à la fois des nombres et des chaînes, tout en conservant l'ancien moteur de
+ * références 1D en dessous.
+ */
+struct script_array_key {
+	// Type de la clé pour distinguer .@a[0] de .@a["0"].
+	bool is_string = false;
+
+	// Valeur utilisée quand la clé est numérique. Les indices négatifs sont
+	// refusés avant d'arriver ici.
+	uint64 num = 0;
+
+	// Valeur utilisée quand la clé est une chaîne. La chaîne vide "" est une
+	// clé valide et ne doit pas être confondue avec une clé inexistante.
+ 	std::string str;
+
+	bool operator==(const script_array_key& other) const {
+		return is_string == other.is_string && (is_string ? str == other.str : num == other.num);
+	}
+};
+
+struct script_array_key_hash {
+	// Hash d'une clé unique. Un sel différent est utilisé selon le type afin de
+	// limiter les collisions entre la clé entière 0 et la clé string "0".
+	size_t operator()(const script_array_key& key) const {
+		size_t h = key.is_string
+			? std::hash<std::string>()(key.str)
+			: std::hash<uint64>()(key.num);
+
+		size_t salt = key.is_string
+			? static_cast<size_t>(0x9e3779b9u)
+			: static_cast<size_t>(0x85ebca6bu);
+
+		return h ^ (salt + (h << 6) + (h >> 2));
+	}
+};
+
+struct script_array_coord_hash {
+	// Hash d'une coordonnée complète, par exemple ["truc"][0]["age"].
+	// On combine le hash de chaque clé dans l'ordre : ["a"][1] doit être
+	// différent de [1]["a"].
+	size_t operator()(const std::vector<script_array_key>& coords) const {
+		size_t h = static_cast<size_t>(2166136261u);
+		script_array_key_hash key_hasher;
+
+		for (const script_array_key& key : coords) {
+			size_t kh = key_hasher(key);
+			h ^= kh + static_cast<size_t>(0x9e3779b9u) + (h << 6) + (h >> 2);
+		}
+
+		return h;
+	}
+};
+ 
+// Les slots multidimensionnels doivent rester dans une plage sûre pour reference_uid().
+// SCRIPT_MAX_ARRAYSIZE peut valoir presque UINT32_MAX selon les branches, ce qui
+// produit des UID avec bit de signe haut et peut rendre les lectures/?itures
+// incoh?ntes sur certains chemins. On r?rve donc une plage haute mais sign?
+// positive pour les cellules hash?. Les indices 1D natifs continuent ?tiliser
+// leurs valeurs normales et sont ?t?par script_array_member_exists().
+#define SCRIPT_ARRAY_MD_SLOT_START 0x7ffffffeU
+#define SCRIPT_DYN_STRING_MAX_NODES 100U
+#define SCRIPT_DYN_STRING_MAX_BYTES 65535U
+
+struct script_array_shape_info {
+	// Taille maximale observée pour les dimensions numériques. Les dimensions
+	// contenant au moins une clé string gardent 0 ici, car elles ne peuvent pas
+	// être représentées comme une taille linéaire classique.
+	std::vector<uint64> dims;
+
+	// Correspondance principale : coordonnée typée -> slot interne.
+	// C'est ce slot qui est injecté dans reference_uid(id, slot).
+	std::unordered_map<std::vector<script_array_key>, uint32, script_array_coord_hash> coord_to_slot;
+
+	// Correspondance inverse utilisée par getarraysize/getarraykeys et par les
+	// nettoyages de branches : slot interne -> coordonnée typée.
+	std::unordered_map<uint32, std::vector<script_array_key>> slot_to_coord;
+
+	// Le slot 0 est réservé à la variable racine (.@a).
+	// Les cellules hashées multidimensionnelles/string-key sont allouées depuis
+	// le haut de la plage positive int32. Ne pas utiliser SCRIPT_MAX_ARRAYSIZE
+	// ici : dans cette branche il vaut UINT_MAX - 1. Un slot supérieur à
+	// INT32_MAX rend reference_uid(id, slot) négatif et peut produire des
+	// écritures/lectures invisibles, par exemple .@a[2][101] lu à 0.
+	// Cela évite aussi les collisions avec les tableaux 1D classiques
+	// (.@a[1], .@a[2], ...).
+	uint32 next_slot = SCRIPT_ARRAY_MD_SLOT_START;
+
+	// Dynamic variables declared with `dyn <var>;` store typed values here.
+	bool dynamic = false;
+
+	// false = scalar state (root value only), true = dictionary state (child keys only).
+	// A dynamic variable is always in exactly one of these states.
+	bool dynamic_dict = false;
+
+	std::unordered_map<uint32, script_array_dynamic_value> dynamic_values;
+
+	// Slots explicitly marked as empty dictionaries. Without this, a branch like
+	// .@a["empty"] = [] would be indistinguishable from a missing/default scalar.
+	std::unordered_set<uint32> dynamic_empty_dicts;
+};
+
+static uint32 script_array_count_child_keys(script_state* st, map_session_data* sd, const char* name, reg_db* ref, int32 id, script_array_shape_info* shape, const std::vector<script_array_key>& prefix);
+
 /**
  * Dereferences a variable/constant, replacing it with a copy of the value.
  * @param st Script state
@@ -2711,6 +3275,79 @@ struct script_data *get_val_(struct script_state* st, struct script_data* data,
 		}
 	}
 
+	if (script_array_is_dynamic_ref(st, sd, reference_getuid(data), name, data->ref)) {
+		script_array_shape_info* shape = script_array_dynamic_shape_get(st, sd, reference_getuid(data), name, data->ref);
+		uint32 dyn_idx = script_getvaridx(reference_getuid(data));
+
+		if (shape != nullptr && dyn_idx == 0 && shape->dynamic_dict) {
+			ShowError("script:get_val: dynamic variable '%s' is a dictionary and cannot be read as a scalar.\n", name);
+			script_reportsrc(st);
+			st->state = END;
+			data->type = C_INT;
+			data->u.num = 0;
+			data->ref = nullptr;
+			return data;
+		}
+
+		if (shape != nullptr && dyn_idx != 0 && !shape->dynamic_dict) {
+			ShowError("script:get_val: dynamic variable '%s' is a scalar and cannot be indexed.\n", name);
+			script_reportsrc(st);
+			st->state = END;
+			data->type = C_INT;
+			data->u.num = 0;
+			data->ref = nullptr;
+			return data;
+		}
+
+		if (shape != nullptr && dyn_idx != 0 && shape->dynamic_empty_dicts.find(dyn_idx) != shape->dynamic_empty_dicts.end()) {
+			ShowError("script:get_val: dynamic branch '%s' is a dictionary and cannot be read as a scalar.\n", name);
+			script_reportsrc(st);
+			st->state = END;
+			data->type = C_INT;
+			data->u.num = 0;
+			data->ref = nullptr;
+			return data;
+		}
+
+		if (shape != nullptr && dyn_idx != 0) {
+			auto coord_it = shape->slot_to_coord.find(dyn_idx);
+			if (coord_it != shape->slot_to_coord.end() && script_array_count_child_keys(st, sd, name, data->ref, script_getvarid(reference_getuid(data)), shape, coord_it->second) > 0) {
+				ShowError("script:get_val: dynamic branch '%s' is a dictionary and cannot be read as a scalar.\n", name);
+				script_reportsrc(st);
+				st->state = END;
+				data->type = C_INT;
+				data->u.num = 0;
+				data->ref = nullptr;
+				return data;
+			}
+		}
+
+		script_array_dynamic_value* dyn = script_array_dynamic_get_value(st, sd, reference_getuid(data), name, data->ref);
+		if (dyn != nullptr && dyn->is_string) {
+			data->type = dyn->str.empty() ? C_CONSTSTR : C_STR;
+			data->u.str = dyn->str.empty() ? const_cast<char*>("") : aStrdup(dyn->str.c_str());
+		}
+		else {
+			data->type = C_INT;
+			data->u.num = dyn != nullptr ? dyn->num : 0;
+		}
+		data->ref = nullptr;
+		return data;
+	}
+
+	{
+		script_array_shape_info* shape = script_array_shape_get_by_name(st, sd, name, data->ref, script_getvarid(reference_getuid(data)));
+		if (shape != nullptr && !shape->dynamic && script_array_dynamic_reference_is_child(shape, script_getvaridx(reference_getuid(data)))) {
+			ShowError("script:get_val: multidimensional/string-key array access on '%s' requires dyn.\n", name);
+			script_reportsrc(st);
+			st->state = END;
+			data->type = C_INT;
+			data->u.num = 0;
+			data->ref = nullptr;
+			return data;
+		}
+	}
+
 	if( postfix == '$' ) {// string variable
 
 		switch( prefix ) {
@@ -2840,6 +3477,8 @@ struct script_data *get_val(struct script_state* st, struct script_data* data)
 }
 
 struct script_data* push_val2(struct script_stack* stack, enum c_op type, int64 val, struct reg_db* ref);
+/// Pushes a value into the stack
+#define push_val(stack,type,val) push_val2(stack, type, val, nullptr)
 
 const char* get_val2_str( struct script_state* st, int64 uid, struct reg_db* ref ){
 	push_val2( st->stack, C_NAME, uid, ref );
@@ -3076,930 +3715,2028 @@ struct reg_db *script_array_src(struct script_state *st, map_session_data *sd, c
 	return nullptr;
 }
 
-/**
- * Processes a array member modification, and update data accordingly
- *
- * @param src[in,out] Variable source database. If the array database doesn't exist, it is created.
- * @param num[in]     Variable ID
- * @param empty[in]   Whether the modified member is empty (needs to be removed)
- **/
-void script_array_update(struct reg_db *src, int64 num, bool empty)
-{
-	struct script_array *sa = nullptr;
-	int32 id = script_getvarid(num);
-	uint32 index = script_getvaridx(num);
 
-	if (!src->arrays) {
-		src->arrays = idb_alloc(DB_OPT_BASE);
-	} else {
-		sa = static_cast<script_array *>(idb_get(src->arrays, id));
-	}
+static std::unordered_map<uint64, script_array_shape_info> script_array_shapes;
 
-	if( sa ) {
-		uint32 i;
+// Retourne l'identite stable du conteneur de variables.
+//
+// Important : il ne faut PAS utiliser l'adresse de `reg_db` directement pour les
+// variables .@. Pendant un callsub/callfunc, rAthena reutilise le meme objet
+// `st->stack->scope`, mais remplace ses pointeurs `vars`/`arrays` par ceux du
+// nouveau scope. Si la cle multiarray est basee sur l'adresse de `reg_db`, le
+// nettoyage du scope appele efface aussi les metadonnees du scope appelant.
+// Cela produisait exactement le symptome suivant :
+//   .@a[2][101] vaut 7 avant un callfunc d'assert, puis redevient 0 apres.
+//
+// Le pointeur `vars` est propre a chaque scope effectif et reste donc le meilleur
+// identifiant. `arrays` sert de secours, puis `src` en dernier recours.
+static uintptr_t script_array_shape_src_identity(const reg_db* src) {
+	if (src == nullptr)
+		return 0;
+	if (src->vars != nullptr)
+		return (uintptr_t)src->vars;
+	if (src->arrays != nullptr)
+		return (uintptr_t)src->arrays;
+	return (uintptr_t)src;
+}
+
+// Supprime toutes les metadonnees multiarray/dyn attachees a un conteneur de
+// variables precis. Voir script_array_shape_src_identity() pour la raison du
+// choix `vars/arrays` plutot que l'adresse de reg_db.
+static void script_array_shape_erase_src(const reg_db* src) {
+	uintptr_t identity = script_array_shape_src_identity(src);
+	if (identity == 0)
+		return;
 
-		// search
-		for(i = 0; i < sa->size; i++) {
-			if( sa->members[i] == index )
-				break;
-		}
+	uint32 src_key = (uint32)identity;
+	for (auto it = script_array_shapes.begin(); it != script_array_shapes.end();) {
+		if ((uint32)(it->first >> 32) == src_key)
+			it = script_array_shapes.erase(it);
+		else
+			++it;
+	}
+}
 
-		// if existent
-		if( i != sa->size ) {
-			// if empty, we gotta remove it
-			if( empty ) {
-				script_array_remove_member(src, sa, i);
-			}
-		} else if( !empty ) { /* new entry */
-			script_array_add_member(sa,index);
-			// we do nothing if its empty, no point in modifying array data for a new empty member
+// Construit une cle unique pour retrouver les metadonnees d'une variable.
+// On combine l'identite du conteneur reel (scope/local/player/global) et l'id
+// de variable.
+static uint64 script_array_shape_key(const reg_db* src, int32 id) {
+	return ((uint64)(uint32)script_array_shape_src_identity(src) << 32) ^ (uint32)id;
+}
+
+// Les clés string ne sont autorisées que pour les variables temporaires.
+// Les variables permanentes nécessiteraient une persistance SQL dédiée.
+static bool script_array_allows_string_keys(const char* name) {
+	return name != nullptr && (name[0] == '@' || name[0] == '.' || (name[0] == '$' && name[1] == '@') || name[0] == '\'');
+}
+
+bool clear_reg(struct script_state* st, map_session_data* sd, int64 num, const char* name, struct reg_db* ref);
+static bool script_array_member_exists(script_state* st, map_session_data* sd, const char* name, reg_db* ref, int32 id, uint32 idx);
+
+// Retrouve le reg_db qui contient réellement la variable référencée.
+// C’est indispensable pour que deux variables de même nom dans deux scopes
+// différents n’utilisent pas les mêmes métadonnées multidimensionnelles.
+static reg_db* script_array_src_data(script_state* st, map_session_data* sd, script_data* data) {
+	if (data == nullptr || !data_isreference(data))
+		return nullptr;
+
+	const char* name = get_str(reference_getid(data));
+	return script_array_src(st, sd, name, reference_getref(data));
+}
+
+static script_array_shape_info* script_array_shape_get(script_state* st, map_session_data* sd, script_data* data) {
+	reg_db* src = script_array_src_data(st, sd, data);
+	if (src == nullptr)
+		return nullptr;
+
+	auto it = script_array_shapes.find(script_array_shape_key(src, reference_getid(data)));
+	if (it == script_array_shapes.end())
+		return nullptr;
+
+	return &it->second;
+}
+
+static script_array_shape_info& script_array_shape_ensure(script_state* st, map_session_data* sd, script_data* data) {
+	reg_db* src = script_array_src_data(st, sd, data);
+	return script_array_shapes[script_array_shape_key(src, reference_getid(data))];
+}
+
+static script_array_shape_info* script_array_shape_get_by_name(script_state* st, map_session_data* sd, const char* name, reg_db* ref, int32 id) {
+	reg_db* src = script_array_src(st, sd, name, ref);
+	if (src == nullptr)
+		return nullptr;
+
+	auto it = script_array_shapes.find(script_array_shape_key(src, id));
+	if (it == script_array_shapes.end())
+		return nullptr;
+
+	return &it->second;
+}
+
+static script_array_shape_info& script_array_shape_ensure_by_name(script_state* st, map_session_data* sd, const char* name, reg_db* ref, int32 id) {
+	reg_db* src = script_array_src(st, sd, name, ref);
+	return script_array_shapes[script_array_shape_key(src, id)];
+}
+
+static script_array_shape_info* script_array_dynamic_shape_get(script_state* st, map_session_data* sd, int64 uid, const char* name, reg_db* ref) {
+	int32 id = script_getvarid(uid);
+
+	// Chemin normal : on resout la variable a partir du conteneur fourni par la reference.
+	script_array_shape_info* shape = script_array_shape_get_by_name(st, sd, name, ref, id);
+	if (shape != nullptr && shape->dynamic)
+		return shape;
+
+	// Certaines references racines (.@a sans index) peuvent perdre le pointeur ref
+	// pendant l'evaluation d'une expression. Pour les variables dynamiques, on refait
+	// donc une resolution explicite du conteneur courant avant de retomber sur le
+	// moteur classique. Ce fallback est volontairement limite aux variables temporaires.
+	if (name != nullptr && script_array_allows_string_keys(name)) {
+		reg_db* src = script_array_src(st, sd, name, nullptr);
+		if (src != nullptr) {
+			auto it = script_array_shapes.find(script_array_shape_key(src, id));
+			if (it != script_array_shapes.end() && it->second.dynamic)
+				return &it->second;
 		}
-	} else if ( !empty ) { // we only move to create if not empty
-		sa = ers_alloc(array_ers, struct script_array);
-		sa->id = id;
-		sa->members = nullptr;
-		sa->size = 0;
-		script_array_add_member(sa,index);
-		idb_put(src->arrays, id, sa);
 	}
+
+	return nullptr;
 }
 
-/**
- * Stores the value of a script variable
- *
- * @param st:    current script state.
- * @param sd:    current character data.
- * @param num:   variable identifier.
- * @param name:  variable name.
- * @param value: new value.
- * @param ref:   variable container, in case of a npc/scope variable reference outside the current scope.
- * @return: 0 failure, 1 success.
- *
- * TODO: return values are screwed up, have been for some time (reaad: years), e.g. some functions return 1 failure and success.
- *------------------------------------------*/
-bool set_reg_str( struct script_state* st, map_session_data* sd, int64 num, const char* name, const char* value, struct reg_db *ref ){
-	char prefix = name[0];
-	size_t vlen = 0;
+static bool script_array_is_dynamic_ref(script_state* st, map_session_data* sd, int64 uid, const char* name, reg_db* ref) {
+	return script_array_dynamic_shape_get(st, sd, uid, name, ref) != nullptr;
+}
 
-	if( !script_check_RegistryVariableLength( 0, name, &vlen ) ){
-		ShowError( "set_reg: Variable name length is too long (aid: %d, cid: %d): '%s' sz=%" PRIuPTR "\n", sd ? sd->status.account_id : -1, sd ? sd->status.char_id : -1, name, vlen );
+static script_array_dynamic_value* script_array_dynamic_get_value(script_state* st, map_session_data* sd, int64 uid, const char* name, reg_db* ref) {
+	script_array_shape_info* shape = script_array_dynamic_shape_get(st, sd, uid, name, ref);
+	if (shape == nullptr)
+		return nullptr;
+
+	auto it = shape->dynamic_values.find(script_getvaridx(uid));
+	return it != shape->dynamic_values.end() ? &it->second : nullptr;
+}
+
+static bool script_array_slot_has_string_key(script_array_shape_info* shape, uint32 slot) {
+	if (shape == nullptr)
 		return false;
-	}
 
-	if( !is_string_variable( name ) ){
-		// integer variable
+	auto it = shape->slot_to_coord.find(slot);
+	if (it == shape->slot_to_coord.end())
 		return false;
-	}
 
-	switch( prefix ){
-		case '@':
-			pc_setregstr( sd, num, value );
+	for (const script_array_key& key : it->second) {
+		if (key.is_string)
 			return true;
-		case '$':
-			return mapreg_setregstr( num, value );
-		case '#':
-			return ( name[1] == '#' ) ? pc_setaccountreg2str( sd, num, value ) : pc_setaccountregstr( sd, num, value );
-		case '.': {
-				struct reg_db *n = ( ref ) ? ref : ( name[1] == '@' ) ? &st->stack->scope : &st->script->local;
+	}
 
-				if( n ){
-					if( value[0] ){
-						i64db_put( n->vars, num, aStrdup( value ) );
+	return false;
+}
 
-						if( script_getvaridx( num ) ){
-							script_array_update( n, num, false );
-						}
-					}else{
-						i64db_remove( n->vars, num );
+static uint32 script_array_total_size_from_dims(const std::vector<uint64>& dims) {
+	if (dims.empty())
+		return 0;
 
-						if( script_getvaridx( num ) ){
-							script_array_update( n, num, true );
-						}
-					}
-				}
+	uint64 total = 1;
+	for (uint64 dim : dims) {
+		if (dim == 0)
+			return 0;
+		if (total > ((uint64)SCRIPT_MAX_ARRAYSIZE - 1) / dim)
+			return SCRIPT_MAX_ARRAYSIZE;
+		total *= dim;
+	}
+
+	return total >= SCRIPT_MAX_ARRAYSIZE ? SCRIPT_MAX_ARRAYSIZE : (uint32)total;
+}
+
+// Convertit les arguments de script en clés typées.
+// Nombre -> clé entière, string -> clé string. Cette fonction applique aussi
+// les garde-fous : pas d’indice négatif et pas de clé string sur persistantes.
+static bool script_array_collect_keys(script_state* st, int32 first_arg, int32 last_arg, const char* name, std::vector<script_array_key>& out, const char* func) {
+	out.clear();
+	for (int32 i = first_arg; i <= last_arg; ++i) {
+		script_data* val = get_val(st, script_getdata(st, i));
+		script_array_key key;
+
+		if (data_isstring(val)) {
+			if (!script_array_allows_string_keys(name)) {
+				ShowWarning("script:%s: string array keys are only supported for temporary variables (.@, @, ., $@, ') for now.\n", func);
+				return false;
 			}
-			return true;
-		case '\'': {
-				struct reg_db *src = nullptr;
+			key.is_string = true;
+			key.str = conv_str(st, val);
+		}
+		else {
+			int64 idx = conv_num64(st, val);
+			if (idx < 0) {
+				ShowWarning("script:%s: negative multidimensional array index (%" PRId64 ").\n", func, idx);
+				return false;
+			}
+			key.is_string = false;
+			key.num = (uint64)idx;
+		}
 
-				if( ref ){
-					src = ref;
-				}else{
-					std::shared_ptr<s_instance_data> idata = util::umap_find(instances, script_instancegetid(st));
+		out.push_back(key);
+	}
+	return true;
+}
 
-					if (idata)
-						src = &idata->regs;
-				}
+// Résout une coordonnée multidimensionnelle en slot interne.
+// Si la coordonnée existe déjà, on réutilise son slot. Sinon on crée un nouveau
+// slot, sans déplacer les anciennes valeurs : le tableau reste sparse.
+static bool script_array_resolve_hash_auto(script_state* st, map_session_data* sd, script_data* data, const char* name, int32 id, const std::vector<script_array_key>& indices, uint32& out, const char* func) {
+	if (indices.empty())
+		return false;
 
-				if( src ){
-					bool empty;
+	// Compatibilité 1D : un accès purement numérique à une seule dimension
+	// reste stocké dans le slot rAthena natif pour les variables classiques.
+	// Exception importante : pour une variable déclarée dyn, le slot 0 est
+	// réservé au scalaire racine (.@a). Donc .@a[0] doit être une vraie
+	// cellule enfant distincte, hashée comme les clés string. Sans cette
+	// exception, .@a[0] et .@a deviennent le même emplacement interne :
+	// .@a[0] = 123; .@a["name"] = "Bob" supprime alors .@a[0] en effaçant
+	// le scalaire racine.
+	if (indices.size() == 1 && !indices[0].is_string) {
+		if (indices[0].num >= SCRIPT_MAX_ARRAYSIZE) {
+			ShowWarning("script:%s: 1D array index out of range (%" PRIu64 ").\n", func, indices[0].num);
+			return false;
+		}
 
-					if( value[0] ){
-						i64db_put( src->vars, num, aStrdup( value ) );
-						empty = false;
-					}else{
-						i64db_remove( src->vars, num );
-						empty = true;
-					}
+		script_array_shape_info* existing_shape = script_array_shape_get(st, sd, data);
+		if (existing_shape == nullptr || !existing_shape->dynamic) {
+			out = (uint32)indices[0].num;
+			return true;
+		}
 
-					if( script_getvaridx( num ) != 0 ){
-						script_array_update( src, num, empty );
-					}
-				}else{
-					ShowError( "script_set_reg: cannot write instance variable '%s', NPC not in a instance!\n", name );
-					script_reportsrc( st );
-				}
+	}
 
-				return true;
-			}
-		default:
-			return pc_setglobalreg_str( sd, num, value );
+	bool uses_dictionary_syntax = indices.size() > 1;
+	for (const script_array_key& key : indices) {
+		if (key.is_string) {
+			uses_dictionary_syntax = true;
+			break;
+		}
 	}
-}
 
-bool set_reg_num( struct script_state* st, map_session_data* sd, int64 num, const char* name, int64 value, struct reg_db *ref ){
-	char prefix = name[0];
-	size_t vlen = 0;
+	if (uses_dictionary_syntax) {
+		if (!script_array_allows_string_keys(name)) {
+			ShowError("script:%s: multidimensional/string-key arrays are only supported for temporary variables (.@, @, ., $@, ') for now. Variable '%s' is persistent.\n", func, name);
+			st->state = END;
+			return false;
+		}
 
-	if( !script_check_RegistryVariableLength( 0, name, &vlen ) ){
-		ShowError( "set_reg: Variable name length is too long (aid: %d, cid: %d): '%s' sz=%" PRIuPTR "\n", sd ? sd->status.account_id : -1, sd ? sd->status.char_id : -1, name, vlen );
-		return false;
+		script_array_shape_info* existing_shape = script_array_shape_get(st, sd, data);
+		if (existing_shape == nullptr || !existing_shape->dynamic) {
+			// Keep resolving the reference so setarraydyn can turn the root into dyn,
+			// but normal reads/writes through this non-dyn reference will be rejected.
+		}
 	}
 
-	if( is_string_variable( name ) ){
-		// string variable
+	if (indices.size() > SCRIPT_MAX_ARRAY_DIMENSIONS) {
+		ShowWarning("script:%s: too many array dimensions (max %u).\n", func, SCRIPT_MAX_ARRAY_DIMENSIONS);
 		return false;
 	}
 
-	if( str_data[script_getvarid(num)].type == C_PARAM ){
-		if( pc_setparam( sd, str_data[script_getvarid(num)].val, value ) == 0 ){
-			if( st != nullptr ) {
-				ShowError( "script_set_reg: failed to set param '%s' to %" PRId64 ".\n", name, value );
-				script_reportsrc( st );
-				st->state = END;
-			}
+	script_array_shape_info& shape = script_array_shape_ensure(st, sd, data);
+
+	// Dictionary semantics: arrays are sparse and non-rectangular.
+	// A previous access like .@a[2][101] must not force every later access
+	// to have exactly two indices. Keep dims only as a best-effort max-depth
+	// helper for legacy nd commands.
+	if (shape.dims.size() < indices.size())
+		shape.dims.resize(indices.size(), 0);
+
+	for (size_t i = 0; i < indices.size(); ++i) {
+		if (indices[i].is_string)
+			continue;
 
+		if (indices[i].num == UINT64_MAX) {
+			ShowWarning("script:%s: multidimensional array index is too large.\n", func);
 			return false;
 		}
 
+		uint64 required = indices[i].num + 1;
+		if (shape.dims[i] < required)
+			shape.dims[i] = required;
+	}
+
+	auto it = shape.coord_to_slot.find(indices);
+	if (it != shape.coord_to_slot.end()) {
+		out = it->second;
 		return true;
 	}
 
-	switch( prefix ){
-		case '@':
-			pc_setreg( sd, num, value );
-			return true;
-		case '$':
-			return mapreg_setreg( num, value );
-		case '#':
-			return ( name[1] == '#' ) ? pc_setaccountreg2(sd, num, value) :	pc_setaccountreg( sd, num, value );
-		case '.': {
-				struct reg_db *n = ( ref ) ? ref : ( name[1] == '@' ) ? &st->stack->scope : &st->script->local;
+	// Les slots multidimensionnels partagent le meme espace d'index que les
+	// arrays 1D historiques. On les alloue depuis le haut de la plage et on
+	// saute les slots deja utilises, sinon .@a[2][101] pourrait ecraser .@a[1].
+	if (shape.next_slot == 1 || shape.next_slot > SCRIPT_ARRAY_MD_SLOT_START)
+		shape.next_slot = SCRIPT_ARRAY_MD_SLOT_START;
 
-				if( n ){
-					if( value != 0 ){
-						i64db_i64put( n->vars, num, value );
+	while (shape.next_slot > 0) {
+		uint32 slot = shape.next_slot--;
 
-						if( script_getvaridx( num ) ){
-							script_array_update( n, num, false );
-						}
-					}else{
-						i64db_remove( n->vars, num );
+		// Ne jamais réutiliser un slot déjà associé à une coordonnée hashée.
+		if (shape.slot_to_coord.find(slot) != shape.slot_to_coord.end())
+			continue;
 
-						if( script_getvaridx( num ) ){
-							script_array_update( n, num, true );
-						}
-					}
-				}
-			}
-			return true;
-		case '\'': {
-				struct reg_db *src = nullptr;
+		// Ne jamais écraser un élément 1D classique déjà présent. C'est
+		// important pour les scripts qui mélangent .@a[1] et .@a[2][101].
+		if (script_array_member_exists(st, sd, name, reference_getref(data), id, slot))
+			continue;
 
-				if( ref ){
-					src = ref;
-				}else{
-					std::shared_ptr<s_instance_data> idata = util::umap_find(instances, script_instancegetid(st));
+		shape.coord_to_slot[indices] = slot;
+		shape.slot_to_coord[slot] = indices;
+		out = slot;
+		return true;
+ 	}
 
-					if (idata)
-						src = &idata->regs;
-				}
+	ShowWarning("script:%s: multidimensional array has too many used cells (max %u).\n", func, SCRIPT_ARRAY_MD_SLOT_START);
+	return false;
+}
 
-				if( src ){
-					bool empty;
+static bool script_array_resolve_hash_auto(script_state* st, map_session_data* sd, script_data* data, int32 first_arg, int32 last_arg, uint32& out, const char* func) {
+	const char* name = get_str(reference_getid(data));
+	std::vector<script_array_key> indices;
+	if (!script_array_collect_keys(st, first_arg, last_arg, name, indices, func))
+		return false;
 
-					if( value != 0 ){
-						i64db_i64put( src->vars, num, value );
-						empty = false;
-					}else{
-						i64db_remove( src->vars, num );
-						empty = true;
-					}
+	return script_array_resolve_hash_auto(st, sd, data, name, reference_getid(data), indices, out, func);
+}
 
-					if( script_getvaridx( num ) != 0 ){
-						script_array_update( src, num, empty );
-					}
-				}else{
-					ShowError( "script_set_reg: cannot write instance variable '%s', NPC not in a instance!\n", name );
-					script_reportsrc( st );
-				}
+static bool script_array_advance_last_dimension(std::vector<script_array_key>& coords, const std::vector<uint64>& dims, uint64 add) {
+	if (coords.empty() || dims.empty() || coords.size() != dims.size() || coords.back().is_string)
+		return false;
 
-				return true;
-			}
-		default:
-			return pc_setglobalreg( sd, num, value );
-	}
-}
+	if (UINT64_MAX - coords.back().num < add)
+		return false;
 
-bool set_var_str( map_session_data* sd, const char* name, const char* val ){
-	return set_reg_str( nullptr, sd, reference_uid( add_str( name ), 0 ), name, val, nullptr );
+	coords.back().num += add;
+	if (dims.back() != 0 && coords.back().num >= dims.back())
+		return false;
+
+	return true;
 }
 
-bool clear_reg( struct script_state* st, map_session_data* sd, int64 num, const char* name, struct reg_db *ref ){
-	if( is_string_variable( name ) ){
-		return set_reg_str( st, sd, num, name, "", ref );
-	}else{
-		return set_reg_num( st, sd, num, name, 0, ref );
+
+static bool script_array_member_exists(script_state* st, map_session_data* sd, const char* name, reg_db* ref, int32 id, uint32 idx) {
+	reg_db* src = script_array_src(st, sd, name, ref);
+	if (src == nullptr || src->arrays == nullptr)
+		return false;
+
+	script_array* sa = static_cast<script_array*>(idb_get(src->arrays, id));
+	if (sa == nullptr)
+		return false;
+
+	for (uint32 i = 0; i < sa->size; ++i) {
+		if (sa->members[i] == idx)
+			return true;
 	}
-}
 
-void setd_sub_num( struct script_state* st, map_session_data* sd, const char* varname, int32 elem, int64 value, struct reg_db* ref ){
-	set_reg_num( st, sd, reference_uid( add_str( varname ), elem ), varname, value, ref );
+	return false;
 }
 
-void setd_sub_str( struct script_state* st, map_session_data* sd, const char* varname, int32 elem, const char* value, struct reg_db* ref ){
-	set_reg_str( st, sd, reference_uid( add_str( varname ), elem ), varname, value, ref );
+static uint32 script_array_member_count(script_state* st, map_session_data* sd, const char* name, reg_db* ref, int32 id) {
+	reg_db* src = script_array_src(st, sd, name, ref);
+	if (src == nullptr || src->arrays == nullptr)
+		return 0;
+
+	script_array* sa = static_cast<script_array*>(idb_get(src->arrays, id));
+	return sa != nullptr ? sa->size : 0;
 }
 
-/**
- * Converts the data to a string
- * @param st
- * @param data
- * @param sd
- */
-const char* conv_str_(struct script_state* st, struct script_data* data, map_session_data *sd)
-{
-	char* p;
+// Renvoie vrai si la cellule racine / index 0 contient une valeur non-defaut.
+// En rAthena legacy, var et var[0] designent le meme emplacement, mais cet
+// emplacement n'est pas toujours enregistre dans script_array.members. Sans ce
+// correctif, getarraysize(.@a) peut retourner 0 apres ".@a = 99" ou
+// ".@a[0] = 123", alors que le comportement attendu est 1.
+static bool script_array_root_value_nondefault(script_state* st, map_session_data* sd, const char* name, reg_db* ref, int32 id) {
+	if (name == nullptr)
+		return false;
 
-	get_val_(st, data, sd);
-	if( data_isstring(data) )
-	{// nothing to convert
+	int64 uid = reference_uid(id, 0);
+
+	// Les variables dynamiques stockent aussi le scalaire racine dans le slot 0.
+	if (script_array_is_dynamic_ref(st, sd, uid, name, ref)) {
+		script_array_dynamic_value* dyn = script_array_dynamic_get_value(st, sd, uid, name, ref);
+		if (dyn == nullptr)
+			return false;
+		return dyn->is_string ? !dyn->str.empty() : dyn->num != 0;
 	}
-	else if( data_isint(data) )
-	{// int32 -> string
-		CREATE(p, char, ITEM_NAME_LENGTH);
-		snprintf(p, ITEM_NAME_LENGTH, "%" PRId64 "", data->u.num);
-		p[ITEM_NAME_LENGTH-1] = '\0';
-		data->type = C_STR;
-		data->u.str = p;
+
+	char prefix = name[0];
+	char postfix = name[strlen(name) - 1];
+
+	if (postfix == '$') {
+		const char* value = nullptr;
+
+		switch (prefix) {
+			case '@':
+				if (sd != nullptr)
+					value = pc_readregstr(sd, uid);
+				break;
+			case '$':
+				value = mapreg_readregstr(uid);
+				break;
+			case '#':
+				if (sd != nullptr)
+					value = (name[1] == '#') ? pc_readaccountreg2str(sd, uid) : pc_readaccountregstr(sd, uid);
+				break;
+			case '.': {
+				struct DBMap* n = ref ? ref->vars : name[1] == '@' ? st->stack->scope.vars : st->script->local.vars;
+				if (n)
+					value = (const char*)i64db_get(n, uid);
+				break;
+			}
+			case '\'': {
+				struct DBMap* n = nullptr;
+				if (ref)
+					n = ref->vars;
+				else {
+					std::shared_ptr<s_instance_data> idata = util::umap_find(instances, script_instancegetid(st));
+					if (idata)
+						n = idata->regs.vars;
+				}
+				if (n)
+					value = (const char*)i64db_get(n, uid);
+				break;
+			}
+			default:
+				if (sd != nullptr)
+					value = pc_readglobalreg_str(sd, uid);
+				break;
+		}
+
+		return value != nullptr && value[0] != '\0';
 	}
-	else if( data_isreference(data) )
-	{// reference -> string
-		//##TODO when does this happen (check get_val) [FlavioJS] -- at getd!!
-		data->type = C_CONSTSTR;
-		data->u.str = reference_getname(data);
+
+	int64 value = 0;
+
+	switch (prefix) {
+		case '@':
+			if (sd != nullptr)
+				value = pc_readreg(sd, uid);
+			break;
+		case '$':
+			value = mapreg_readreg(uid);
+			break;
+		case '#':
+			if (sd != nullptr)
+				value = (name[1] == '#') ? pc_readaccountreg2(sd, uid) : pc_readaccountreg(sd, uid);
+			break;
+		case '.': {
+			struct DBMap* n = ref ? ref->vars : name[1] == '@' ? st->stack->scope.vars : st->script->local.vars;
+			if (n)
+				value = i64db_i64get(n, uid);
+			break;
+		}
+		case '\'': {
+			struct DBMap* n = nullptr;
+			if (ref)
+				n = ref->vars;
+			else {
+				std::shared_ptr<s_instance_data> idata = util::umap_find(instances, script_instancegetid(st));
+				if (idata)
+					n = idata->regs.vars;
+			}
+			if (n)
+				value = i64db_i64get(n, uid);
+			break;
+		}
+		default:
+			if (sd != nullptr)
+				value = pc_readglobalreg(sd, uid);
+			break;
 	}
-	else
-	{// unsupported data type
-		ShowError("script:conv_str: cannot convert to string, defaulting to \"\"\n");
-		script_reportdata(data);
-		script_reportsrc(st);
-		data->type = C_CONSTSTR;
-		data->u.str = const_cast<char *>("");
+
+	return value != 0;
+}
+
+static uint32 script_array_native_member_count(script_state* st, map_session_data* sd, const char* name, reg_db* ref, int32 id, script_array_shape_info* shape) {
+	reg_db* src = script_array_src(st, sd, name, ref);
+	if (src == nullptr || src->arrays == nullptr)
+		return 0;
+
+	script_array* sa = static_cast<script_array*>(idb_get(src->arrays, id));
+	if (sa == nullptr)
+		return 0;
+
+	uint32 count = 0;
+	for (uint32 i = 0; i < sa->size; ++i) {
+		uint32 slot = sa->members[i];
+		// Les cellules multidimensionnelles ont aussi un slot dans script_array.members.
+		// On ne doit pas les compter comme des enfants 1D directs.
+		if (shape != nullptr && shape->slot_to_coord.find(slot) != shape->slot_to_coord.end())
+			continue;
+		count++;
 	}
-	return data->u.str;
+
+	return count;
 }
 
-const char* conv_str(struct script_state* st, struct script_data* data)
-{
-	return conv_str_(st, data, nullptr);
+// Indique si une coordonnée appartient à une branche donnée.
+// Exemple : ["truc"][101] commence par ["truc"].
+static bool script_array_coord_starts_with(const std::vector<script_array_key>& coords, const std::vector<script_array_key>& prefix) {
+	if (coords.size() < prefix.size())
+		return false;
+
+	for (size_t i = 0; i < prefix.size(); ++i) {
+		if (!(coords[i] == prefix[i]))
+			return false;
+	}
+
+	return true;
 }
 
-/**
- * Converts the data to an int32
- * @param st
- * @param data
- * @param sd
- */
-int64 conv_num_(struct script_state* st, struct script_data* data, map_session_data *sd)
-{
-	get_val_(st, data, sd);
-	if( data_isint(data) )
-	{// nothing to convert
+static bool script_array_coord_has_live_subtree(script_state* st, map_session_data* sd, const char* name, reg_db* ref, int32 id, script_array_shape_info* shape, const std::vector<script_array_key>& prefix) {
+	if (shape == nullptr)
+		return false;
+
+	for (const auto& entry : shape->coord_to_slot) {
+		const std::vector<script_array_key>& coords = entry.first;
+
+		if (!script_array_coord_starts_with(coords, prefix))
+			continue;
+
+		if (shape->dynamic) {
+			if (shape->dynamic_values.find(entry.second) != shape->dynamic_values.end())
+				return true;
+			if (shape->dynamic_empty_dicts.find(entry.second) != shape->dynamic_empty_dicts.end())
+				return true;
+		}
+		else if (script_array_member_exists(st, sd, name, ref, id, entry.second))
+			return true;
 	}
-	else if( data_isstring(data) )
-	{// string -> int32
-		// the result does not overflow or underflow, it is capped instead
-		// ex: 999999999999 is capped to INT_MAX (2147483647)
-		char* p = data->u.str;
-		int64 num;
-		bool error;
 
-		errno = 0;
-		num = strtoll(data->u.str, nullptr, 10);// change radix to 0 to support octal numbers "o377" and hex numbers "0xFF"
-		error = (errno == ERANGE);
+	return false;
+}
 
-		if( num < SCRIPT_INT_MIN || ( error && num == INT64_MIN ) ){
-			num = SCRIPT_INT_MIN;
-			ShowError( "script:conv_num: underflow detected, capping value to %" PRId64 "", SCRIPT_INT_MIN );
-			script_reportdata(data);
-			script_reportsrc(st);
-		}else if( num > SCRIPT_INT_MAX || ( error && num == INT64_MAX ) ){
-			num = SCRIPT_INT_MAX;
-			ShowError( "script:conv_num: overflow detected, capping value to %" PRId64 "", SCRIPT_INT_MAX );
-			script_reportdata(data);
-			script_reportsrc(st);
+// Compte uniquement les enfants directs réellement stockés sous un préfixe.
+// Les valeurs par défaut lues implicitement ne sont pas comptées.
+static uint32 script_array_count_child_keys(script_state* st, map_session_data* sd, const char* name, reg_db* ref, int32 id, script_array_shape_info* shape, const std::vector<script_array_key>& prefix) {
+	if (shape == nullptr)
+		return 0;
+
+	std::vector<script_array_key> keys;
+
+	for (const auto& entry : shape->coord_to_slot) {
+		const std::vector<script_array_key>& coords = entry.first;
+
+		if (coords.size() <= prefix.size() || !script_array_coord_starts_with(coords, prefix))
+			continue;
+
+		std::vector<script_array_key> child_prefix = prefix;
+		child_prefix.push_back(coords[prefix.size()]);
+
+		if (!script_array_coord_has_live_subtree(st, sd, name, ref, id, shape, child_prefix))
+			continue;
+
+		bool exists = false;
+		for (const script_array_key& key : keys) {
+			if (key == coords[prefix.size()]) {
+				exists = true;
+				break;
+			}
 		}
 
-		if( data->type == C_STR )
-			aFree(p);
-		data->type = C_INT;
-		data->u.num = num;
+		if (!exists)
+			keys.push_back(coords[prefix.size()]);
 	}
-#if 0
-	// FIXME this function is being used to retrieve the position of labels and
-	// probably other stuff [FlavioJS]
-	else
-	{// unsupported data type
-		ShowError("script:conv_num: cannot convert to number, defaulting to 0\n");
-		script_reportdata(data);
-		script_reportsrc(st);
-		data->type = C_INT;
-		data->u.num = 0;
+
+	return (uint32)keys.size();
+}
+
+static bool script_array_md_pruning = false;
+
+static void script_array_prepare_dict_assignment(script_state* st, map_session_data* sd, int64 num, const char* name, struct reg_db* ref, bool nondefault_value) {
+	if (script_array_md_pruning || script_getvaridx(num) == 0)
+		return;
+
+	reg_db* src = script_array_src(st, sd, name, ref);
+	if (src == nullptr)
+		return;
+
+	auto shape_it = script_array_shapes.find(script_array_shape_key(src, script_getvarid(num)));
+	if (shape_it == script_array_shapes.end())
+		return;
+
+	script_array_shape_info& shape = shape_it->second;
+	auto coord_it = shape.slot_to_coord.find(script_getvaridx(num));
+	std::vector<script_array_key> coord;
+
+	if (coord_it != shape.slot_to_coord.end()) {
+		coord = coord_it->second;
+	} else if (!shape.dynamic && script_getvaridx(num) != 0) {
+		// Les indices 1D numeriques restent stockes dans leur slot natif.
+		// Pour appliquer la semantique dictionnaire, on reconstruit donc le
+		// prefixe [idx] meme s'il n'existe pas dans slot_to_coord.
+		script_array_key native_key;
+		native_key.is_string = false;
+		native_key.num = script_getvaridx(num);
+		coord.push_back(native_key);
+	} else {
+ 		return;
+	}
+	std::vector<uint32> slots_to_delete;
+
+	// Cas particulier des variables dynamiques : leurs valeurs ne sont pas
+	// stockees dans les registres numeriques/string classiques, mais dans
+	// shape.dynamic_values. Si un chemin non-dyn passe tout de meme par ici
+	// (ancien opcode, setarray, ou fallback), il faut supprimer les scalaires
+	// parents/enfants dans dynamic_values, sinon .@a["truc"] garde son
+	// ancienne valeur apres .@a["truc"][101] = 8.
+	if (shape.dynamic) {
+		for (size_t len = 1; len < coord.size(); ++len) {
+			std::vector<script_array_key> parent(coord.begin(), coord.begin() + len);
+			auto parent_it = shape.coord_to_slot.find(parent);
+			if (parent_it != shape.coord_to_slot.end() && shape.dynamic_values.find(parent_it->second) != shape.dynamic_values.end())
+				slots_to_delete.push_back(parent_it->second);
+		}
+
+		for (const auto& entry : shape.coord_to_slot) {
+			if (entry.first.size() > coord.size() && script_array_coord_starts_with(entry.first, coord))
+				slots_to_delete.push_back(entry.second);
+		}
+
+		for (uint32 slot : slots_to_delete) {
+			shape.dynamic_values.erase(slot);
+			shape.dynamic_empty_dicts.erase(slot);
+			auto old = shape.slot_to_coord.find(slot);
+			if (old != shape.slot_to_coord.end()) {
+				shape.coord_to_slot.erase(old->second);
+				shape.slot_to_coord.erase(old);
+			}
+		}
+
+		if (!nondefault_value) {
+			shape.dynamic_values.erase(script_getvaridx(num));
+			shape.dynamic_empty_dicts.erase(script_getvaridx(num));
+			shape.coord_to_slot.erase(coord);
+			shape.slot_to_coord.erase(script_getvaridx(num));
+		}
+
+		return;
+	}
+
+	// Python-like semantics: when a child is assigned, parent scalar values become dictionaries.
+	for (size_t len = 1; len < coord.size(); ++len) {
+		std::vector<script_array_key> parent(coord.begin(), coord.begin() + len);
+		
+		if (parent.size() == 1 && !parent[0].is_string && parent[0].num < SCRIPT_MAX_ARRAYSIZE) {
+			uint32 native_parent = (uint32)parent[0].num;
+			if (script_array_member_exists(st, sd, name, ref, script_getvarid(num), native_parent))
+				slots_to_delete.push_back(native_parent);
+			continue;
+		}
+
+		auto parent_it = shape.coord_to_slot.find(parent);
+		if (parent_it != shape.coord_to_slot.end() && script_array_member_exists(st, sd, name, ref, script_getvarid(num), parent_it->second)) {
+			slots_to_delete.push_back(parent_it->second);
+		}
+		else if (parent.size() == 1 && !parent[0].is_string && parent[0].num < SCRIPT_MAX_ARRAYSIZE) {
+			uint32 parent_slot = (uint32)parent[0].num;
+			if (script_array_member_exists(st, sd, name, ref, script_getvarid(num), parent_slot))
+				slots_to_delete.push_back(parent_slot);
+		}
+	}
+
+	// When a scalar is assigned, all previous children below that key disappear.
+	for (const auto& entry : shape.coord_to_slot) {
+		if (entry.first.size() > coord.size() && script_array_coord_starts_with(entry.first, coord))
+			slots_to_delete.push_back(entry.second);
+	}
+
+	script_array_md_pruning = true;
+	for (uint32 slot : slots_to_delete)
+		clear_reg(st, sd, reference_uid(script_getvarid(num), slot), name, ref);
+	script_array_md_pruning = false;
+
+	for (uint32 slot : slots_to_delete) {
+		auto old = shape.slot_to_coord.find(slot);
+		if (old != shape.slot_to_coord.end()) {
+			shape.coord_to_slot.erase(old->second);
+			shape.slot_to_coord.erase(old);
+		}
+	}
+
+	if (!nondefault_value) {
+		shape.coord_to_slot.erase(coord);
+		shape.slot_to_coord.erase(script_getvaridx(num));
 	}
-#endif
-	return data->u.num;
 }
 
-int64 conv_num64(struct script_state* st, struct script_data* data)
-{
-	return conv_num_(st, data, nullptr);
+
+static bool script_array_dynamic_reference_is_child(script_array_shape_info* shape, uint32 idx) {
+	return shape != nullptr && idx != 0 && shape->slot_to_coord.find(idx) != shape->slot_to_coord.end();
 }
 
-int32 conv_num(struct script_state* st, struct script_data* data)
-{
-	return static_cast<int32>(conv_num_(st, data, nullptr));
+static bool script_array_dynamic_stop_bad_state(script_state* st, const char* func, const char* name, const char* what) {
+	ShowError("script:%s: invalid access to dynamic variable '%s': %s.\n", func, name ? name : "<unknown>", what);
+	script_reportsrc(st);
+	st->state = END;
+	return false;
 }
 
-//
-// Stack operations
-//
+static void script_array_clear_all_members(script_state* st, map_session_data* sd, const char* name, reg_db* ref, int32 id) {
+	reg_db* src = script_array_src(st, sd, name, ref);
+	if (src == nullptr)
+		return;
 
-/// Increases the size of the stack
-void stack_expand(struct script_stack* stack)
-{
-	stack->sp_max += 64;
-	stack->stack_data = (struct script_data*)aRealloc(stack->stack_data,
-			stack->sp_max * sizeof(stack->stack_data[0]) );
-	memset(stack->stack_data + (stack->sp_max - 64), 0,
-			64 * sizeof(stack->stack_data[0]) );
-}
+	std::vector<uint32> members;
+	if (src->arrays != nullptr) {
+		script_array* sa = static_cast<script_array*>(idb_get(src->arrays, id));
+		if (sa != nullptr) {
+			for (uint32 i = 0; i < sa->size; ++i)
+				members.push_back(sa->members[i]);
+		}
+	}
 
-/// Pushes a value into the stack
-#define push_val(stack,type,val) push_val2(stack, type, val, nullptr)
+	// The legacy root value (index 0) may exist without being listed in sa->members.
+	members.push_back(0);
 
-/// Pushes a value into the stack (with reference)
-struct script_data* push_val2(struct script_stack* stack, enum c_op type, int64 val, struct reg_db *ref)
-{
-	if( stack->sp >= stack->sp_max )
-		stack_expand(stack);
-	stack->stack_data[stack->sp].type  = type;
-	stack->stack_data[stack->sp].u.num = val;
-	stack->stack_data[stack->sp].ref   = ref;
-	stack->sp++;
-	return &stack->stack_data[stack->sp-1];
+	script_array_md_pruning = true;
+	for (uint32 slot : members)
+		clear_reg(st, sd, reference_uid(id, slot), name, ref);
+	script_array_md_pruning = false;
 }
 
-/// Pushes a string into the stack
-struct script_data* push_str(struct script_stack* stack, enum c_op type, char* str)
-{
-	if( stack->sp >= stack->sp_max )
-		stack_expand(stack);
-	stack->stack_data[stack->sp].type  = type;
-	stack->stack_data[stack->sp].u.str = str;
-	stack->stack_data[stack->sp].ref   = nullptr;
-	stack->sp++;
-	return &stack->stack_data[stack->sp-1];
-}
+static bool script_array_dynamic_store_value(script_state* st, map_session_data* sd, int64 uid, const char* name, reg_db* ref, script_data* value) {
+	script_array_shape_info* shape = script_array_dynamic_shape_get(st, sd, uid, name, ref);
+	if (shape == nullptr)
+		return false;
 
-/// Pushes a retinfo into the stack
-struct script_data* push_retinfo(struct script_stack* stack, struct script_retinfo* ri, struct reg_db *ref)
-{
-	if( stack->sp >= stack->sp_max )
-		stack_expand(stack);
-	stack->stack_data[stack->sp].type = C_RETINFO;
-	stack->stack_data[stack->sp].u.ri = ri;
-	stack->stack_data[stack->sp].ref  = ref;
-	stack->sp++;
-	return &stack->stack_data[stack->sp-1];
-}
+	uint32 slot = script_getvaridx(uid);
+	bool nondefault = true;
+	script_array_dynamic_value dyn;
+	script_data* val = get_val(st, value);
 
-/// Pushes a copy of the target position into the stack
-struct script_data* push_copy(struct script_stack* stack, int32 pos)
-{
-	switch( stack->stack_data[pos].type ) {
-		case C_CONSTSTR:
-			return push_str(stack, C_CONSTSTR, stack->stack_data[pos].u.str);
-			break;
-		case C_STR:
-			return push_str(stack, C_STR, aStrdup(stack->stack_data[pos].u.str));
-			break;
-		case C_RETINFO:
-			ShowFatalError("script:push_copy: can't create copies of C_RETINFO. Exiting...\n");
-			exit(1);
-			break;
-		default:
-			return push_val2(
-				stack,stack->stack_data[pos].type,
-				stack->stack_data[pos].u.num,
-				stack->stack_data[pos].ref
-			);
-			break;
+	if (data_isstring(val)) {
+		dyn.is_string = true;
+		dyn.str = conv_str(st, val);
+		nondefault = !dyn.str.empty();
+	}
+	else {
+		dyn.is_string = false;
+		dyn.num = conv_num64(st, val);
+		nondefault = dyn.num != 0;
 	}
-}
-
-/// Removes the values in indexes [start,end] from the stack.
-/// Adjusts all stack pointers.
-void pop_stack(struct script_state* st, int32 start, int32 end)
-{
-	struct script_stack* stack = st->stack;
-	struct script_data* data;
-	int32 i;
-
-	if( start < 0 )
-		start = 0;
-	if( end > stack->sp )
-		end = stack->sp;
-	if( start >= end )
-		return;// nothing to pop
 
-	// free stack elements
-	for( i = start; i < end; i++ )
-	{
-		data = &stack->stack_data[i];
-		if( data->type == C_STR )
-			aFree(data->u.str);
-		if( data->type == C_RETINFO ) {
-			struct script_retinfo* ri = data->u.ri;
+	if (slot == 0) {
+		ShowError("script:set: dynamic variable '%s' is a dictionary and cannot be assigned a scalar value. Use [] or del for dictionary operations.\n", name);
+		script_reportsrc(st);
+		st->state = END;
+		return false;
+	} else {
+		// Writing any child makes the variable a dictionary and removes the root scalar.
+		shape->dynamic_dict = true;
+		shape->dynamic_values.erase(0);
+		shape->dynamic_empty_dicts.erase(0);
+
+		auto coord_it = shape->slot_to_coord.find(slot);
+		if (coord_it != shape->slot_to_coord.end()) {
+			const std::vector<script_array_key>& coord = coord_it->second;
+			std::vector<uint32> slots_to_delete;
+
+			// Parent scalars become dictionaries.
+			for (size_t len = 1; len < coord.size(); ++len) {
+				std::vector<script_array_key> parent(coord.begin(), coord.begin() + len);
+				auto parent_it = shape->coord_to_slot.find(parent);
+				if (parent_it != shape->coord_to_slot.end() && shape->dynamic_values.find(parent_it->second) != shape->dynamic_values.end())
+					slots_to_delete.push_back(parent_it->second);
+			}
 
-			if (ri->scope.vars) {
-				script_free_vars(ri->scope.vars);
-				ri->scope.vars = nullptr;
+			// A scalar overwrite removes its children.
+			for (const auto& entry : shape->coord_to_slot) {
+				if (entry.first.size() > coord.size() && script_array_coord_starts_with(entry.first, coord))
+					slots_to_delete.push_back(entry.second);
 			}
-			if (ri->scope.arrays) {
-				ri->scope.arrays->destroy(ri->scope.arrays, script_free_array_db);
-				ri->scope.arrays = nullptr;
+
+			for (uint32 delete_slot : slots_to_delete) {
+				shape->dynamic_values.erase(delete_slot);
+				shape->dynamic_empty_dicts.erase(delete_slot);
+				auto old = shape->slot_to_coord.find(delete_slot);
+				if (old != shape->slot_to_coord.end()) {
+					shape->coord_to_slot.erase(old->second);
+					shape->slot_to_coord.erase(old);
+				}
 			}
-			if( data->ref )
-				aFree(data->ref);
-			aFree(ri);
 		}
-		data->type = C_NOP;
 	}
 
-	// move the rest of the elements
-	if( stack->sp > end )
-	{
-		memmove(&stack->stack_data[start], &stack->stack_data[end], sizeof(stack->stack_data[0])*(stack->sp - end));
-		for( i = start + stack->sp - end; i < stack->sp; ++i )
-			stack->stack_data[i].type = C_NOP;
-	}
+	shape->dynamic_empty_dicts.erase(slot);
+	if (nondefault)
+		shape->dynamic_values[slot] = dyn;
+	else
+		shape->dynamic_values.erase(slot);
 
-	// adjust stack pointers
-	if( st->start > end ){
-		st->start -= end - start;
-	}else if( st->start > start ){
-		st->start = start;
-	}
-	
-	if( st->end > end ){
-		st->end -= end - start;
-	}else if( st->end > start ){
-		st->end = start;
-	}
-	
-	if( stack->defsp > end ){
-		stack->defsp -= end - start;
-	}else if( stack->defsp > start ){
-		stack->defsp = start;
-	}
-	
-	stack->sp -= end - start;
+	return true;
 }
 
-///
-///
-///
+static bool script_array_dyn_string_append(std::string& out, const std::string& text, bool& truncated) {
+	if (truncated)
+		return true;
 
-/*==========================================
- * Release script dependent variable, dependent variable of function
- *------------------------------------------*/
-void script_free_vars(struct DBMap* storage)
-{
-	if( storage ) {
-		// destroy the storage construct containing the variables
-		db_destroy(storage);
+	if (out.size() + text.size() > SCRIPT_DYN_STRING_MAX_BYTES) {
+		const char* suffix = "\n...<truncated>";
+		size_t suffix_len = strlen(suffix);
+		if (out.size() < SCRIPT_DYN_STRING_MAX_BYTES) {
+			size_t remaining = SCRIPT_DYN_STRING_MAX_BYTES - out.size();
+			if (remaining > suffix_len)
+				out.append(text, 0, remaining - suffix_len);
+			out += suffix;
+		}
+		truncated = true;
+		return true;
 	}
-}
-
-void script_free_code(struct script_code* code)
-{
-	nullpo_retv(code);
 
-	if (code->instances)
-		script_stop_scriptinstances(code);
-	script_free_vars(code->local.vars);
-	if (code->local.arrays)
-		code->local.arrays->destroy(code->local.arrays, script_free_array_db);
-	aFree(code->script_buf);
-	aFree(code);
+	out += text;
+	return true;
 }
 
-/// Creates a new script state.
-///
-/// @param script Script code
-/// @param pos Position in the code
-/// @param rid Who is running the script (attached player)
-/// @param oid Where the code is being run (npc 'object')
-/// @return Script state
-struct script_state* script_alloc_state(struct script_code* rootscript, int32 pos, int32 rid, int32 oid)
-{
-	struct script_state* st;
+static std::string script_array_dyn_string_indent(uint32 depth) {
+	return std::string((size_t)depth, '\t');
+}
 
-	st = ers_alloc(st_ers, struct script_state);
-	st->stack = ers_alloc(stack_ers, struct script_stack);
-	st->stack->sp = 0;
-	st->stack->sp_max = 64;
-	CREATE(st->stack->stack_data, struct script_data, st->stack->sp_max);
-	st->stack->defsp = st->stack->sp;
-	st->stack->scope.vars = i64db_alloc(DB_OPT_RELEASE_DATA);
-	st->stack->scope.arrays = nullptr;
-	st->state = RUN;
-	st->script = rootscript;
-	st->pos = pos;
-	st->rid = rid;
-	st->oid = oid;
-	st->sleep.timer = INVALID_TIMER;
-	st->npc_item_flag = battle_config.item_enabled_npc;
-	
-	if( st->script->instances != USHRT_MAX )
-		st->script->instances++;
-	else {
-		npc_data *nd = map_id2nd(oid);
+static std::string script_array_dyn_string_escape(const std::string& text) {
+	std::string out;
+	out.reserve(text.size() + 8);
 
-		ShowError("Over 65k instances of '%s' script are being run!\n",nd ? nd->name : "unknown");
+	for (unsigned char c : text) {
+		switch (c) {
+			case '\\': out += "\\\\"; break;
+			case '"': out += "\\\""; break;
+			case '\n': out += "\\n"; break;
+			case '\r': out += "\\r"; break;
+			case '\t': out += "\\t"; break;
+			default:
+				if (c < 32) {
+					char buf[8];
+					snprintf(buf, sizeof(buf), "\\x%02X", c);
+					out += buf;
+				} else {
+					out += (char)c;
+				}
+				break;
+		}
 	}
 
-	if (!st->script->local.vars)
-		st->script->local.vars = i64db_alloc(DB_OPT_RELEASE_DATA);
+	return out;
+}
 
-	st->id = next_id++;
-	active_scripts++;
+static std::string script_array_dyn_key_to_string(const script_array_key& key) {
+	if (key.is_string)
+		return "\"" + script_array_dyn_string_escape(key.str) + "\"";
 
-	idb_put(st_db, st->id, st);
+	char buf[32];
+	snprintf(buf, sizeof(buf), "%" PRIu64, key.num);
+	return std::string(buf);
+}
 
-	return st;
+static bool script_array_dyn_key_less(const script_array_key& a, const script_array_key& b) {
+	if (a.is_string != b.is_string)
+		return !a.is_string; // integer keys first, then string keys.
+
+	if (a.is_string)
+		return a.str < b.str;
+
+	return a.num < b.num;
 }
 
-/// Frees a script state.
-///
-/// @param st Script state
-void script_free_state(struct script_state* st)
-{
-	if (idb_exists(st_db, st->id)) {
-		map_session_data *sd = st->rid ? map_id2sd(st->rid) : nullptr;
+static std::vector<script_array_key> script_array_dyn_direct_child_keys(script_state* st, map_session_data* sd, const char* name, reg_db* ref, int32 id, script_array_shape_info* shape, const std::vector<script_array_key>& prefix) {
+	std::vector<script_array_key> keys;
 
-		if (st->bk_st) // backup was not restored
-			ShowDebug("script_free_state: Previous script state lost (rid=%d, oid=%d, state=%d, bk_npcid=%d).\n", st->bk_st->rid, st->bk_st->oid, st->bk_st->state, st->bk_npcid);
+	if (shape == nullptr)
+		return keys;
 
-		if (sd && sd->st == st) { // Current script is aborted.
-			if(sd->state.using_fake_npc) {
-				clif_clearunit_single( sd->npc_id, CLR_OUTSIGHT, *sd );
-				sd->state.using_fake_npc = 0;
-			}
-			sd->st = nullptr;
-			sd->npc_id = 0;
-		}
+	for (const auto& entry : shape->coord_to_slot) {
+		const std::vector<script_array_key>& coords = entry.first;
 
-		if (st->sleep.timer != INVALID_TIMER)
-			delete_timer(st->sleep.timer, run_script_timer);
-		if (st->stack) {
-			script_free_vars(st->stack->scope.vars);
-			if (st->stack->scope.arrays)
-				st->stack->scope.arrays->destroy(st->stack->scope.arrays, script_free_array_db);
-			pop_stack(st, 0, st->stack->sp);
-			aFree(st->stack->stack_data);
-			ers_free(stack_ers, st->stack);
-			st->stack = nullptr;
-		}
-		if (st->script && st->script->instances != USHRT_MAX && --st->script->instances == 0) {
-			if (st->script->local.vars && !db_size(st->script->local.vars)) {
-				script_free_vars(st->script->local.vars);
-				st->script->local.vars = nullptr;
-			}
-			if (st->script->local.arrays && !db_size(st->script->local.arrays)) {
-				st->script->local.arrays->destroy(st->script->local.arrays, script_free_array_db);
-				st->script->local.arrays = nullptr;
+		if (coords.size() <= prefix.size() || !script_array_coord_starts_with(coords, prefix))
+			continue;
+
+		std::vector<script_array_key> child_prefix = prefix;
+		child_prefix.push_back(coords[prefix.size()]);
+
+		if (!script_array_coord_has_live_subtree(st, sd, name, ref, id, shape, child_prefix))
+			continue;
+
+		bool exists = false;
+		for (const script_array_key& key : keys) {
+			if (key == coords[prefix.size()]) {
+				exists = true;
+				break;
 			}
 		}
-		st->pos = -1;
 
-		idb_remove(st_db, st->id);
-		ers_free(st_ers, st);
-		if (--active_scripts == 0)
-			next_id = 0;
+		if (!exists)
+			keys.push_back(coords[prefix.size()]);
 	}
+
+	std::sort(keys.begin(), keys.end(), script_array_dyn_key_less);
+	return keys;
 }
 
-//
-// Main execution unit
-//
-/*==========================================
- * Read command
- *------------------------------------------*/
-c_op get_com(unsigned char *script,int32 *pos)
-{
-	int32 i = 0, j = 0;
+static bool script_array_dyn_serialize_value(script_state* st, map_session_data* sd, const char* name, reg_db* ref, int32 id, script_array_shape_info* shape, const std::vector<script_array_key>& prefix, std::string& out, uint32 depth, uint32& nodes, bool& truncated);
 
-	if(script[*pos]>=0x80){
-		return C_INT;
-	}
-	while(script[*pos]>=0x40){
-		i=script[(*pos)++]<<j;
-		j+=6;
-	}
-	return (c_op)(i+(script[(*pos)++]<<j));
-}
+static bool script_array_dyn_serialize_scalar(const script_array_dynamic_value& value, std::string& out, bool& truncated) {
+	if (value.is_string)
+		return script_array_dyn_string_append(out, "\"" + script_array_dyn_string_escape(value.str) + "\"", truncated);
 
-/*==========================================
- *  Income figures
- *------------------------------------------*/
-int64 get_num(unsigned char *script,int32 *pos)
-{
-	int32 i, end;
-	int64 value;
-
-	// Find the end of the data
-	for( i = 0; script[*pos+i] >= 0xc0; i++ ) ; // do nothing just find it
-
-	end = i; // store the end for later
-	value = 0; // initialize empty value
+	char buf[32];
+	snprintf(buf, sizeof(buf), "%" PRId64, value.num);
+	return script_array_dyn_string_append(out, buf, truncated);
+}
 
-	// If more than one byte of data exists
-	for( ; i > 0; i-- ){
-		value |= (int64)( script[*pos+i] & (int64)0x3f );
-		value <<= 6;
-	}
+static bool script_array_dyn_serialize_table(script_state* st, map_session_data* sd, const char* name, reg_db* ref, int32 id, script_array_shape_info* shape, const std::vector<script_array_key>& prefix, std::string& out, uint32 depth, uint32& nodes, bool& truncated) {
+	std::vector<script_array_key> keys = script_array_dyn_direct_child_keys(st, sd, name, ref, id, shape, prefix);
 
-	// Put our last piece of data into the return value
-	value |= (script[*pos+i] & (int64)0x3f);
+	if (!script_array_dyn_string_append(out, "[", truncated))
+		return false;
 
-	*pos += end + 1; // one byte after the last byte of data
+	if (keys.empty())
+		return script_array_dyn_string_append(out, "]", truncated);
 
-	return value;
-}
+	if (!script_array_dyn_string_append(out, "\n", truncated))
+		return false;
 
-/// Ternary operators
-/// test ? if_true : if_false
-void op_3(struct script_state* st, int32 op)
-{
-	struct script_data* data;
-	int32 flag = 0;
+	for (const script_array_key& key : keys) {
+		if (nodes >= SCRIPT_DYN_STRING_MAX_NODES) {
+			ShowWarning("script:dyntostring: output truncated after %u dynamic nodes.\n", SCRIPT_DYN_STRING_MAX_NODES);
+			script_array_dyn_string_append(out, script_array_dyn_string_indent(depth + 1) + "\"...\": \"<max nodes reached>\",\n", truncated);
+			truncated = true;
+			break;
+		}
 
-	data = script_getdatatop(st, -3);
-	get_val(st, data);
+		std::vector<script_array_key> child_prefix = prefix;
+		child_prefix.push_back(key);
 
-	if( data_isstring(data) )
-		flag = data->u.str[0];// "" -> false
-	else if( data_isint(data) )
-		flag = data->u.num == 0 ? 0 : 1;// 0 -> false
-	else
-	{
-		ShowError("script:op_3: invalid data for the ternary operator test\n");
-		script_reportdata(data);
-		script_reportsrc(st);
-		script_removetop(st, -3, 0);
-		script_pushnil(st);
-		return;
-	}
-	if( flag )
-		script_pushcopytop(st, -2);
-	else
-		script_pushcopytop(st, -1);
-	script_removetop(st, -4, -1);
-}
+		++nodes;
+		if (!script_array_dyn_string_append(out, script_array_dyn_string_indent(depth + 1) + script_array_dyn_key_to_string(key) + ": ", truncated))
+			return false;
 
-/// Binary string operators
-/// s1 EQ s2 -> i
-/// s1 NE s2 -> i
-/// s1 GT s2 -> i
-/// s1 GE s2 -> i
-/// s1 LT s2 -> i
-/// s1 LE s2 -> i
-/// s1 ADD s2 -> s
-void op_2str(struct script_state* st, int32 op, const char* s1, const char* s2)
-{
-	int32 a = 0;
+		if (!script_array_dyn_serialize_value(st, sd, name, ref, id, shape, child_prefix, out, depth + 1, nodes, truncated))
+			return false;
 
-	switch(op){
-		case C_EQ: a = (strcmp(s1,s2) == 0); break;
-		case C_NE: a = (strcmp(s1,s2) != 0); break;
-		case C_GT: a = (strcmp(s1,s2) >  0); break;
-		case C_GE: a = (strcmp(s1,s2) >= 0); break;
-		case C_LT: a = (strcmp(s1,s2) <  0); break;
-		case C_LE: a = (strcmp(s1,s2) <= 0); break;
-		case C_ADD:
-			{
-				char* buf = (char *)aMalloc((strlen(s1)+strlen(s2)+1)*sizeof(char));
-				strcpy(buf, s1);
-				strcat(buf, s2);
-				script_pushstr(st, buf);
-				return;
-			}
-		default:
-			ShowError("script:op2_str: unexpected string operator %s\n", script_op2name(op));
-			script_reportsrc(st);
-			script_pushnil(st);
-			st->state = END;
-			return;
+		if (!script_array_dyn_string_append(out, ",\n", truncated))
+			return false;
 	}
 
-	script_pushint(st,a);
+	return script_array_dyn_string_append(out, script_array_dyn_string_indent(depth) + "]", truncated);
 }
 
-/// Binary number operators
-/// i OP i -> i
-void op_2num( struct script_state* st, int32 op, int64 i1, int64 i2 ){
-	int64 ret;
-
-	switch( op ) {
-		case C_AND:  ret = i1 & i2;		break;
-		case C_OR:   ret = i1 | i2;		break;
-		case C_XOR:  ret = i1 ^ i2;		break;
-		case C_LAND: ret = (i1 && i2);	break;
-		case C_LOR:  ret = (i1 || i2);	break;
-		case C_EQ:   ret = (i1 == i2);	break;
-		case C_NE:   ret = (i1 != i2);	break;
-		case C_GT:   ret = (i1 >  i2);	break;
-		case C_GE:   ret = (i1 >= i2);	break;
-		case C_LT:   ret = (i1 <  i2);	break;
-		case C_LE:   ret = (i1 <= i2);	break;
-		case C_R_SHIFT: ret = i1>>i2;	break;
-		case C_L_SHIFT: ret = i1<<i2;	break;
-		case C_DIV:
-		case C_MOD:
-			if( i2 == 0 )
-			{
-				ShowError("script:op_2num: division by zero detected op=%s i1=%" PRId64 " i2=%" PRId64 "\n", script_op2name(op), i1, i2);
-				script_reportsrc(st);
-				script_pushnil(st);
-				st->state = END;
-				return;
-			}
-			else if( op == C_DIV )
-				ret = i1 / i2;
-			else//if( op == C_MOD )
-				ret = i1 % i2;
-			break;
-		default:
-			bool overflow;
-
-			// operators that can overflow/underflow
-			switch( op ) {
-				case C_ADD: overflow = util::safe_addition( i1, i2, ret ); break;
-				case C_SUB: overflow = util::safe_substraction( i1, i2, ret ); break;
-				case C_MUL: overflow = util::safe_multiplication( i1, i2, ret ); break;
-				default:
-					ShowError("script:op_2num: unexpected number operator %s i1=%" PRId64 " i2=%" PRId64 "\n", script_op2name(op), i1, i2);
-					script_reportsrc(st);
-					script_pushnil(st);
-					return;
-			}
+static bool script_array_dyn_serialize_value(script_state* st, map_session_data* sd, const char* name, reg_db* ref, int32 id, script_array_shape_info* shape, const std::vector<script_array_key>& prefix, std::string& out, uint32 depth, uint32& nodes, bool& truncated) {
+	if (shape == nullptr || !shape->dynamic)
+		return script_array_dyn_string_append(out, "0", truncated);
 
-			if( overflow ){
-				ShowWarning("script:op_2num: overflow detected op=%s i1=%" PRId64 " i2=%" PRId64 "\n", script_op2name(op), i1, i2);
-				script_reportsrc(st);
-				script_pushnil(st);
-				st->state = END;
-				return;
-			}
+	if (depth > SCRIPT_MAX_ARRAY_DIMENSIONS) {
+		ShowWarning("script:dyntostring: maximum dynamic depth %u reached.\n", SCRIPT_MAX_ARRAY_DIMENSIONS);
+		script_array_dyn_string_append(out, "\"<max depth reached>\"", truncated);
+		truncated = true;
+		return true;
 	}
-	script_pushint(st, ret);
-}
-
-/// Binary operators
-void op_2(struct script_state *st, int32 op)
-{
-	struct script_data* left, leftref;
-	struct script_data* right;
 
-	leftref.type = C_NOP;
-
-	left = script_getdatatop(st, -2);
-	right = script_getdatatop(st, -1);
+	uint32 slot = 0;
+	bool has_slot = prefix.empty();
 
-	if (st->op2ref) {
-		if (data_isreference(left)) {
-			leftref = *left;
+	if (!prefix.empty()) {
+		auto slot_it = shape->coord_to_slot.find(prefix);
+		if (slot_it != shape->coord_to_slot.end()) {
+			slot = slot_it->second;
+			has_slot = true;
 		}
-
-		st->op2ref = 0;
 	}
 
-	get_val(st, left);
-	get_val(st, right);
-
-	// automatic conversions
-	switch( op )
-	{
-		case C_ADD:
-			if( data_isint(left) && data_isstring(right) )
-			{// convert int-string to string-string
-				conv_str(st, left);
-			}
-			else if( data_isstring(left) && data_isint(right) )
-			{// convert string-int32 to string-string
-				conv_str(st, right);
-			}
-			break;
+	if (has_slot) {
+		auto value_it = shape->dynamic_values.find(slot);
+		if (value_it != shape->dynamic_values.end())
+			return script_array_dyn_serialize_scalar(value_it->second, out, truncated);
 	}
 
-	if( data_isstring(left) && data_isstring(right) )
-	{// ss => op_2str
-		op_2str(st, op, left->u.str, right->u.str);
-		script_removetop(st, leftref.type == C_NOP ? -3 : -2, -1);// pop the two values before the top one
-
-		if (leftref.type != C_NOP)
-		{
-			if (left->type == C_STR) // don't free C_CONSTSTR
-				aFree(left->u.str);
-			*left = leftref;
-		}
-	}
-	else if( data_isint(left) && data_isint(right) )
-	{// ii => op_2num
-		int64 i1 = left->u.num;
-		int64 i2 = right->u.num;
+	std::vector<script_array_key> keys = script_array_dyn_direct_child_keys(st, sd, name, ref, id, shape, prefix);
+	if (!keys.empty() || prefix.empty() || (has_slot && shape->dynamic_empty_dicts.find(slot) != shape->dynamic_empty_dicts.end()))
+		return script_array_dyn_serialize_table(st, sd, name, ref, id, shape, prefix, out, depth, nodes, truncated);
 
-		script_removetop(st, leftref.type == C_NOP ? -2 : -1, 0);
-		op_2num(st, op, i1, i2);
+	return script_array_dyn_string_append(out, "0", truncated);
+}
 
-		if (leftref.type != C_NOP)
-			*left = leftref;
-	}
-	else
-	{// invalid argument
-		ShowError("script:op_2: invalid data for operator %s\n", script_op2name(op));
-		script_reportdata(left);
-		script_reportdata(right);
-		script_reportsrc(st);
-		script_removetop(st, -2, 0);
-		script_pushnil(st);
+static bool script_array_dyn_build_string(script_state* st, map_session_data* sd, script_data* data, const char* name, int32 id, uint32 idx, std::string& out, bool& truncated) {
+	script_array_shape_info* shape = script_array_dynamic_shape_get(st, sd, reference_uid(id, 0), name, reference_getref(data));
+	if (shape == nullptr || !shape->dynamic) {
+		ShowError("script:dyntostring: variable '%s' is not dynamic.\n", name);
 		st->state = END;
+		return false;
 	}
-}
 
-/// Unary operators
-/// NEG i -> i
-/// NOT i -> i
-/// LNOT i -> i
-void op_1(struct script_state* st, int32 op)
-{
-	struct script_data* data;
+	std::vector<script_array_key> prefix;
+	if (idx != 0) {
+		auto prefix_it = shape->slot_to_coord.find(idx);
+		if (prefix_it == shape->slot_to_coord.end()) {
+			// Missing dynamic path: keep read-default behavior for debug output.
+			out = "0";
+			return true;
+		}
+		prefix = prefix_it->second;
+	}
 
-	data = script_getdatatop(st, -1);
-	get_val(st, data);
+	uint32 nodes = 0;
+	return script_array_dyn_serialize_value(st, sd, name, reference_getref(data), id, shape, prefix, out, 0, nodes, truncated);
+}
 
-	if( !data_isint(data) )
-	{// not a number
-		ShowError("script:op_1: argument is not a number (op=%s)\n", script_op2name(op));
+static bool script_array_builtin_resolve_ref(script_state* st, int32 arg, script_data*& data, const char*& name, int32& id, uint32& idx, map_session_data*& sd, const char* func) {
+	data = script_getdata(st, arg);
+	if (!data_isreference(data)) {
+		ShowError("script:%s: not a variable\n", func);
 		script_reportdata(data);
-		script_reportsrc(st);
 		script_pushnil(st);
 		st->state = END;
-		return;
+		return false;
 	}
 
-	int64 i1 = data->u.num;
-	script_removetop(st, -1, 0);
-	switch( op )
-	{
-		case C_NEG: i1 = -i1; break;
-		case C_NOT: i1 = ~i1; break;
-		case C_LNOT: i1 = !i1; break;
-		default:
-			ShowError("script:op_1: unexpected operator %s i1=%" PRId64 "\n", script_op2name(op), i1);
-			script_reportsrc(st);
-			script_pushnil(st);
-			st->state = END;
-			return;
+	id = reference_getid(data);
+	idx = reference_getindex(data);
+	name = get_str(id);
+
+	if (not_server_variable(*name)) {
+		if (!script_rid2sd(sd))
+			return false;
 	}
-	script_pushint(st, i1);
-}
 
+	return true;
+}
 
-/// Checks the type of all arguments passed to a built-in function.
-///
+/**
+ * Processes a array member modification, and update data accordingly
+ *
+ * @param src[in,out] Variable source database. If the array database doesn't exist, it is created.
+ * @param num[in]     Variable ID
+ * @param empty[in]   Whether the modified member is empty (needs to be removed)
+ **/
+void script_array_update(struct reg_db *src, int64 num, bool empty)
+{
+	struct script_array *sa = nullptr;
+	int32 id = script_getvarid(num);
+	uint32 index = script_getvaridx(num);
+
+	if (!src->arrays) {
+		src->arrays = idb_alloc(DB_OPT_BASE);
+	} else {
+		sa = static_cast<script_array *>(idb_get(src->arrays, id));
+	}
+
+	if( sa ) {
+		uint32 i;
+
+		// search
+		for(i = 0; i < sa->size; i++) {
+			if( sa->members[i] == index )
+				break;
+		}
+
+		// if existent
+		if( i != sa->size ) {
+			// if empty, we gotta remove it
+			if( empty ) {
+				script_array_remove_member(src, sa, i);
+			}
+		} else if( !empty ) { /* new entry */
+			script_array_add_member(sa,index);
+			// we do nothing if its empty, no point in modifying array data for a new empty member
+		}
+	} else if ( !empty ) { // we only move to create if not empty
+		sa = ers_alloc(array_ers, struct script_array);
+		sa->id = id;
+		sa->members = nullptr;
+		sa->size = 0;
+		script_array_add_member(sa,index);
+		idb_put(src->arrays, id, sa);
+	}
+}
+
+/**
+ * Stores the value of a script variable
+ *
+ * @param st:    current script state.
+ * @param sd:    current character data.
+ * @param num:   variable identifier.
+ * @param name:  variable name.
+ * @param value: new value.
+ * @param ref:   variable container, in case of a npc/scope variable reference outside the current scope.
+ * @return: 0 failure, 1 success.
+ *
+ * TODO: return values are screwed up, have been for some time (reaad: years), e.g. some functions return 1 failure and success.
+ *------------------------------------------*/
+bool set_reg_str( struct script_state* st, map_session_data* sd, int64 num, const char* name, const char* value, struct reg_db *ref ){
+	char prefix = name[0];
+	size_t vlen = 0;
+
+	if( !script_check_RegistryVariableLength( 0, name, &vlen ) ){
+		ShowError( "set_reg: Variable name length is too long (aid: %d, cid: %d): '%s' sz=%" PRIuPTR "\n", sd ? sd->status.account_id : -1, sd ? sd->status.char_id : -1, name, vlen );
+		return false;
+	}
+
+	if( !is_string_variable( name ) ){
+		// integer variable
+		return false;
+	}
+
+	if (script_getvaridx(num) != 0)
+		script_array_prepare_dict_assignment(st, sd, num, name, ref, value != nullptr && value[0] != '\0');
+
+	switch( prefix ){
+		case '@':
+			pc_setregstr( sd, num, value );
+			return true;
+		case '$':
+			return mapreg_setregstr( num, value );
+		case '#':
+			return ( name[1] == '#' ) ? pc_setaccountreg2str( sd, num, value ) : pc_setaccountregstr( sd, num, value );
+		case '.': {
+				struct reg_db *n = ( ref ) ? ref : ( name[1] == '@' ) ? &st->stack->scope : &st->script->local;
+
+				if( n ){
+					if( value[0] ){
+						i64db_put( n->vars, num, aStrdup( value ) );
+
+						if( script_getvaridx( num ) ){
+							script_array_update( n, num, false );
+						}
+					}else{
+						i64db_remove( n->vars, num );
+
+						if( script_getvaridx( num ) ){
+							script_array_update( n, num, true );
+						}
+					}
+				}
+			}
+			return true;
+		case '\'': {
+				struct reg_db *src = nullptr;
+
+				if( ref ){
+					src = ref;
+				}else{
+					std::shared_ptr<s_instance_data> idata = util::umap_find(instances, script_instancegetid(st));
+
+					if (idata)
+						src = &idata->regs;
+				}
+
+				if( src ){
+					bool empty;
+
+					if( value[0] ){
+						i64db_put( src->vars, num, aStrdup( value ) );
+						empty = false;
+					}else{
+						i64db_remove( src->vars, num );
+						empty = true;
+					}
+
+					if( script_getvaridx( num ) != 0 ){
+						script_array_update( src, num, empty );
+					}
+				}else{
+					ShowError( "script_set_reg: cannot write instance variable '%s', NPC not in a instance!\n", name );
+					script_reportsrc( st );
+				}
+
+				return true;
+			}
+		default:
+			return pc_setglobalreg_str( sd, num, value );
+	}
+}
+
+bool set_reg_num( struct script_state* st, map_session_data* sd, int64 num, const char* name, int64 value, struct reg_db *ref ){
+	char prefix = name[0];
+	size_t vlen = 0;
+
+	if( !script_check_RegistryVariableLength( 0, name, &vlen ) ){
+		ShowError( "set_reg: Variable name length is too long (aid: %d, cid: %d): '%s' sz=%" PRIuPTR "\n", sd ? sd->status.account_id : -1, sd ? sd->status.char_id : -1, name, vlen );
+		return false;
+	}
+
+	if( is_string_variable( name ) ){
+		// string variable
+		return false;
+	}
+
+	if( str_data[script_getvarid(num)].type == C_PARAM ){
+		if( pc_setparam( sd, str_data[script_getvarid(num)].val, value ) == 0 ){
+			if( st != nullptr ) {
+				ShowError( "script_set_reg: failed to set param '%s' to %" PRId64 ".\n", name, value );
+				script_reportsrc( st );
+				st->state = END;
+			}
+
+			return false;
+		}
+
+		return true;
+	}
+
+	if (script_getvaridx(num) != 0)
+		script_array_prepare_dict_assignment(st, sd, num, name, ref, value != 0);
+
+	switch( prefix ){
+		case '@':
+			pc_setreg( sd, num, value );
+			return true;
+		case '$':
+			return mapreg_setreg( num, value );
+		case '#':
+			return ( name[1] == '#' ) ? pc_setaccountreg2(sd, num, value) :	pc_setaccountreg( sd, num, value );
+		case '.': {
+				struct reg_db *n = ( ref ) ? ref : ( name[1] == '@' ) ? &st->stack->scope : &st->script->local;
+
+				if( n ){
+					if( value != 0 ){
+						i64db_i64put( n->vars, num, value );
+
+						if( script_getvaridx( num ) ){
+							script_array_update( n, num, false );
+						}
+					}else{
+						i64db_remove( n->vars, num );
+
+						if( script_getvaridx( num ) ){
+							script_array_update( n, num, true );
+						}
+					}
+				}
+			}
+			return true;
+		case '\'': {
+				struct reg_db *src = nullptr;
+
+				if( ref ){
+					src = ref;
+				}else{
+					std::shared_ptr<s_instance_data> idata = util::umap_find(instances, script_instancegetid(st));
+
+					if (idata)
+						src = &idata->regs;
+				}
+
+				if( src ){
+					bool empty;
+
+					if( value != 0 ){
+						i64db_i64put( src->vars, num, value );
+						empty = false;
+					}else{
+						i64db_remove( src->vars, num );
+						empty = true;
+					}
+
+					if( script_getvaridx( num ) != 0 ){
+						script_array_update( src, num, empty );
+					}
+				}else{
+					ShowError( "script_set_reg: cannot write instance variable '%s', NPC not in a instance!\n", name );
+					script_reportsrc( st );
+				}
+
+				return true;
+			}
+		default:
+			return pc_setglobalreg( sd, num, value );
+	}
+}
+
+bool set_var_str( map_session_data* sd, const char* name, const char* val ){
+	return set_reg_str( nullptr, sd, reference_uid( add_str( name ), 0 ), name, val, nullptr );
+}
+
+bool clear_reg( struct script_state* st, map_session_data* sd, int64 num, const char* name, struct reg_db *ref ){
+	if( is_string_variable( name ) ){
+		return set_reg_str( st, sd, num, name, "", ref );
+	}else{
+		return set_reg_num( st, sd, num, name, 0, ref );
+	}
+}
+
+void setd_sub_num( struct script_state* st, map_session_data* sd, const char* varname, int32 elem, int64 value, struct reg_db* ref ){
+	set_reg_num( st, sd, reference_uid( add_str( varname ), elem ), varname, value, ref );
+}
+
+void setd_sub_str( struct script_state* st, map_session_data* sd, const char* varname, int32 elem, const char* value, struct reg_db* ref ){
+	set_reg_str( st, sd, reference_uid( add_str( varname ), elem ), varname, value, ref );
+}
+
+/**
+ * Converts the data to a string
+ * @param st
+ * @param data
+ * @param sd
+ */
+const char* conv_str_(struct script_state* st, struct script_data* data, map_session_data *sd)
+{
+	char* p;
+
+	get_val_(st, data, sd);
+	if( data_isstring(data) )
+	{// nothing to convert
+	}
+	else if( data_isint(data) )
+	{// int32 -> string
+		CREATE(p, char, ITEM_NAME_LENGTH);
+		snprintf(p, ITEM_NAME_LENGTH, "%" PRId64 "", data->u.num);
+		p[ITEM_NAME_LENGTH-1] = '\0';
+		data->type = C_STR;
+		data->u.str = p;
+	}
+	else if( data_isreference(data) )
+	{// reference -> string
+		//##TODO when does this happen (check get_val) [FlavioJS] -- at getd!!
+		data->type = C_CONSTSTR;
+		data->u.str = reference_getname(data);
+	}
+	else
+	{// unsupported data type
+		ShowError("script:conv_str: cannot convert to string, defaulting to \"\"\n");
+		script_reportdata(data);
+		script_reportsrc(st);
+		data->type = C_CONSTSTR;
+		data->u.str = const_cast<char *>("");
+	}
+	return data->u.str;
+}
+
+const char* conv_str(struct script_state* st, struct script_data* data)
+{
+	return conv_str_(st, data, nullptr);
+}
+
+/**
+ * Converts the data to an int32
+ * @param st
+ * @param data
+ * @param sd
+ */
+int64 conv_num_(struct script_state* st, struct script_data* data, map_session_data *sd)
+{
+	get_val_(st, data, sd);
+	if( data_isint(data) )
+	{// nothing to convert
+	}
+	else if( data_isstring(data) )
+	{// string -> int32
+		// the result does not overflow or underflow, it is capped instead
+		// ex: 999999999999 is capped to INT_MAX (2147483647)
+		char* p = data->u.str;
+		int64 num;
+		bool error;
+
+		errno = 0;
+		num = strtoll(data->u.str, nullptr, 10);// change radix to 0 to support octal numbers "o377" and hex numbers "0xFF"
+		error = (errno == ERANGE);
+
+		if( num < SCRIPT_INT_MIN || ( error && num == INT64_MIN ) ){
+			num = SCRIPT_INT_MIN;
+			ShowError( "script:conv_num: underflow detected, capping value to %" PRId64 "", SCRIPT_INT_MIN );
+			script_reportdata(data);
+			script_reportsrc(st);
+		}else if( num > SCRIPT_INT_MAX || ( error && num == INT64_MAX ) ){
+			num = SCRIPT_INT_MAX;
+			ShowError( "script:conv_num: overflow detected, capping value to %" PRId64 "", SCRIPT_INT_MAX );
+			script_reportdata(data);
+			script_reportsrc(st);
+		}
+
+		if( data->type == C_STR )
+			aFree(p);
+		data->type = C_INT;
+		data->u.num = num;
+	}
+#if 0
+	// FIXME this function is being used to retrieve the position of labels and
+	// probably other stuff [FlavioJS]
+	else
+	{// unsupported data type
+		ShowError("script:conv_num: cannot convert to number, defaulting to 0\n");
+		script_reportdata(data);
+		script_reportsrc(st);
+		data->type = C_INT;
+		data->u.num = 0;
+	}
+#endif
+	return data->u.num;
+}
+
+int64 conv_num64(struct script_state* st, struct script_data* data)
+{
+	return conv_num_(st, data, nullptr);
+}
+
+int32 conv_num(struct script_state* st, struct script_data* data)
+{
+	return static_cast<int32>(conv_num_(st, data, nullptr));
+}
+
+//
+// Stack operations
+//
+
+/// Increases the size of the stack
+void stack_expand(struct script_stack* stack)
+{
+	stack->sp_max += 64;
+	stack->stack_data = (struct script_data*)aRealloc(stack->stack_data,
+			stack->sp_max * sizeof(stack->stack_data[0]) );
+	memset(stack->stack_data + (stack->sp_max - 64), 0,
+			64 * sizeof(stack->stack_data[0]) );
+}
+
+/// Pushes a value into the stack (with reference)
+struct script_data* push_val2(struct script_stack* stack, enum c_op type, int64 val, struct reg_db *ref)
+{
+	if( stack->sp >= stack->sp_max )
+		stack_expand(stack);
+	stack->stack_data[stack->sp].type  = type;
+	stack->stack_data[stack->sp].u.num = val;
+	stack->stack_data[stack->sp].ref   = ref;
+	stack->sp++;
+	return &stack->stack_data[stack->sp-1];
+}
+
+/// Pushes a string into the stack
+struct script_data* push_str(struct script_stack* stack, enum c_op type, char* str)
+{
+	if( stack->sp >= stack->sp_max )
+		stack_expand(stack);
+	stack->stack_data[stack->sp].type  = type;
+	stack->stack_data[stack->sp].u.str = str;
+	stack->stack_data[stack->sp].ref   = nullptr;
+	stack->sp++;
+	return &stack->stack_data[stack->sp-1];
+}
+
+/// Pushes a retinfo into the stack
+struct script_data* push_retinfo(struct script_stack* stack, struct script_retinfo* ri, struct reg_db *ref)
+{
+	if( stack->sp >= stack->sp_max )
+		stack_expand(stack);
+	stack->stack_data[stack->sp].type = C_RETINFO;
+	stack->stack_data[stack->sp].u.ri = ri;
+	stack->stack_data[stack->sp].ref  = ref;
+	stack->sp++;
+	return &stack->stack_data[stack->sp-1];
+}
+
+/// Pushes a copy of the target position into the stack
+struct script_data* push_copy(struct script_stack* stack, int32 pos)
+{
+	switch( stack->stack_data[pos].type ) {
+		case C_CONSTSTR:
+			return push_str(stack, C_CONSTSTR, stack->stack_data[pos].u.str);
+			break;
+		case C_STR:
+			return push_str(stack, C_STR, aStrdup(stack->stack_data[pos].u.str));
+			break;
+		case C_RETINFO:
+			ShowFatalError("script:push_copy: can't create copies of C_RETINFO. Exiting...\n");
+			exit(1);
+			break;
+		default:
+			return push_val2(
+				stack,stack->stack_data[pos].type,
+				stack->stack_data[pos].u.num,
+				stack->stack_data[pos].ref
+			);
+			break;
+	}
+}
+
+static void script_return_value_free(script_data& data)
+{
+	if (data.type == C_STR && data.u.str != nullptr) {
+		aFree(data.u.str);
+		data.u.str = nullptr;
+	}
+	data.type = C_NOP;
+	data.ref = nullptr;
+}
+
+static void script_return_values_clear(script_state* st)
+{
+	auto it = script_return_values.find(st);
+	if (it == script_return_values.end())
+		return;
+
+	for (script_data& data : it->second)
+		script_return_value_free(data);
+
+	it->second.clear();
+}
+
+static script_data script_data_make_owned_copy(script_data* src)
+{
+	script_data out = {};
+	out.type = src->type;
+	out.ref = src->ref;
+
+	if (src->type == C_STR) {
+		out.u.str = aStrdup(src->u.str ? src->u.str : "");
+		out.ref = nullptr;
+	} else if (src->type == C_CONSTSTR) {
+		out.u.str = src->u.str;
+		out.ref = nullptr;
+	} else {
+		out.u.num = src->u.num;
+	}
+
+	return out;
+}
+
+static void script_push_return_value(script_state* st, const script_data& data)
+{
+	switch (data.type) {
+		case C_STR:
+			script_pushstrcopy(st, data.u.str ? data.u.str : "");
+			break;
+		case C_CONSTSTR:
+			script_pushconststr(st, data.u.str ? data.u.str : "");
+			break;
+		case C_INT:
+		case C_POS:
+			script_pushint64(st, data.u.num);
+			break;
+		case C_NAME:
+			push_val2(st->stack, data.type, data.u.num, data.ref);
+			break;
+		default:
+			script_pushnil(st);
+			break;
+	}
+}
+
+/// Removes the values in indexes [start,end] from the stack.
+/// Adjusts all stack pointers.
+void pop_stack(struct script_state* st, int32 start, int32 end)
+{
+	struct script_stack* stack = st->stack;
+	struct script_data* data;
+	int32 i;
+
+	if( start < 0 )
+		start = 0;
+	if( end > stack->sp )
+		end = stack->sp;
+	if( start >= end )
+		return;// nothing to pop
+
+	// free stack elements
+	for( i = start; i < end; i++ )
+	{
+		data = &stack->stack_data[i];
+		if( data->type == C_STR )
+			aFree(data->u.str);
+		if( data->type == C_RETINFO ) {
+			struct script_retinfo* ri = data->u.ri;
+
+			if (ri->scope.vars) {
+				script_array_shape_erase_src(&ri->scope);
+				script_free_vars(ri->scope.vars);
+				ri->scope.vars = nullptr;
+			}
+			if (ri->scope.arrays) {
+				ri->scope.arrays->destroy(ri->scope.arrays, script_free_array_db);
+				ri->scope.arrays = nullptr;
+			}
+			if( data->ref )
+				aFree(data->ref);
+			aFree(ri);
+		}
+		data->type = C_NOP;
+	}
+
+	// move the rest of the elements
+	if( stack->sp > end )
+	{
+		memmove(&stack->stack_data[start], &stack->stack_data[end], sizeof(stack->stack_data[0])*(stack->sp - end));
+		for( i = start + stack->sp - end; i < stack->sp; ++i )
+			stack->stack_data[i].type = C_NOP;
+	}
+
+	// adjust stack pointers
+	if( st->start > end ){
+		st->start -= end - start;
+	}else if( st->start > start ){
+		st->start = start;
+	}
+	
+	if( st->end > end ){
+		st->end -= end - start;
+	}else if( st->end > start ){
+		st->end = start;
+	}
+	
+	if( stack->defsp > end ){
+		stack->defsp -= end - start;
+	}else if( stack->defsp > start ){
+		stack->defsp = start;
+	}
+	
+	stack->sp -= end - start;
+}
+
+///
+///
+///
+
+/*==========================================
+ * Release script dependent variable, dependent variable of function
+ *------------------------------------------*/
+void script_free_vars(struct DBMap* storage)
+{
+	if( storage ) {
+		// destroy the storage construct containing the variables
+		db_destroy(storage);
+	}
+}
+
+void script_free_code(struct script_code* code)
+{
+	nullpo_retv(code);
+
+	if (code->instances)
+		script_stop_scriptinstances(code);
+	script_code_label_positions.erase(code);
+	script_array_shape_erase_src(&code->local);
+	script_free_vars(code->local.vars);
+	if (code->local.arrays)
+		code->local.arrays->destroy(code->local.arrays, script_free_array_db);
+	aFree(code->script_buf);
+	aFree(code);
+}
+
+/// Creates a new script state.
+///
+/// @param script Script code
+/// @param pos Position in the code
+/// @param rid Who is running the script (attached player)
+/// @param oid Where the code is being run (npc 'object')
+/// @return Script state
+struct script_state* script_alloc_state(struct script_code* rootscript, int32 pos, int32 rid, int32 oid)
+{
+	struct script_state* st;
+
+	st = ers_alloc(st_ers, struct script_state);
+	st->stack = ers_alloc(stack_ers, struct script_stack);
+	st->stack->sp = 0;
+	st->stack->sp_max = 64;
+	CREATE(st->stack->stack_data, struct script_data, st->stack->sp_max);
+	st->stack->defsp = st->stack->sp;
+	st->stack->scope.vars = i64db_alloc(DB_OPT_RELEASE_DATA);
+	st->stack->scope.arrays = nullptr;
+	st->state = RUN;
+	st->script = rootscript;
+	st->pos = pos;
+	st->rid = rid;
+	st->oid = oid;
+	st->sleep.timer = INVALID_TIMER;
+	st->npc_item_flag = battle_config.item_enabled_npc;
+	
+	if( st->script->instances != USHRT_MAX )
+		st->script->instances++;
+	else {
+		npc_data *nd = map_id2nd(oid);
+
+		ShowError("Over 65k instances of '%s' script are being run!\n",nd ? nd->name : "unknown");
+	}
+
+	if (!st->script->local.vars)
+		st->script->local.vars = i64db_alloc(DB_OPT_RELEASE_DATA);
+
+	st->id = next_id++;
+	active_scripts++;
+
+	idb_put(st_db, st->id, st);
+
+	return st;
+}
+
+/// Frees a script state.
+///
+/// @param st Script state
+void script_free_state(struct script_state* st)
+{
+	if (idb_exists(st_db, st->id)) {
+		map_session_data *sd = st->rid ? map_id2sd(st->rid) : nullptr;
+
+		if (st->bk_st) // backup was not restored
+			ShowDebug("script_free_state: Previous script state lost (rid=%d, oid=%d, state=%d, bk_npcid=%d).\n", st->bk_st->rid, st->bk_st->oid, st->bk_st->state, st->bk_npcid);
+
+		if (sd && sd->st == st) { // Current script is aborted.
+			if(sd->state.using_fake_npc) {
+				clif_clearunit_single( sd->npc_id, CLR_OUTSIGHT, *sd );
+				sd->state.using_fake_npc = 0;
+			}
+			sd->st = nullptr;
+			sd->npc_id = 0;
+		}
+
+		if (st->sleep.timer != INVALID_TIMER)
+			delete_timer(st->sleep.timer, run_script_timer);
+		if (st->stack) {
+			script_array_shape_erase_src(&st->stack->scope);
+			script_free_vars(st->stack->scope.vars);
+			if (st->stack->scope.arrays)
+				st->stack->scope.arrays->destroy(st->stack->scope.arrays, script_free_array_db);
+			pop_stack(st, 0, st->stack->sp);
+			aFree(st->stack->stack_data);
+			ers_free(stack_ers, st->stack);
+			st->stack = nullptr;
+		}
+		if (st->script && st->script->instances != USHRT_MAX && --st->script->instances == 0) {
+			if (st->script->local.vars && !db_size(st->script->local.vars)) {
+				script_free_vars(st->script->local.vars);
+				st->script->local.vars = nullptr;
+			}
+			if (st->script->local.arrays && !db_size(st->script->local.arrays)) {
+				st->script->local.arrays->destroy(st->script->local.arrays, script_free_array_db);
+				st->script->local.arrays = nullptr;
+			}
+		}
+		st->pos = -1;
+		script_return_values_clear(st);
+		script_return_values.erase(st);
+
+		idb_remove(st_db, st->id);
+		ers_free(st_ers, st);
+		if (--active_scripts == 0)
+			next_id = 0;
+	}
+}
+
+//
+// Main execution unit
+//
+/*==========================================
+ * Read command
+ *------------------------------------------*/
+c_op get_com(unsigned char *script,int32 *pos)
+{
+	int32 i = 0, j = 0;
+
+	if(script[*pos]>=0x80){
+		return C_INT;
+	}
+	while(script[*pos]>=0x40){
+		i=script[(*pos)++]<<j;
+		j+=6;
+	}
+	return (c_op)(i+(script[(*pos)++]<<j));
+}
+
+/*==========================================
+ *  Income figures
+ *------------------------------------------*/
+int64 get_num(unsigned char *script,int32 *pos)
+{
+	int32 i, end;
+	int64 value;
+
+	// Find the end of the data
+	for( i = 0; script[*pos+i] >= 0xc0; i++ ) ; // do nothing just find it
+
+	end = i; // store the end for later
+	value = 0; // initialize empty value
+
+	// If more than one byte of data exists
+	for( ; i > 0; i-- ){
+		value |= (int64)( script[*pos+i] & (int64)0x3f );
+		value <<= 6;
+	}
+
+	// Put our last piece of data into the return value
+	value |= (script[*pos+i] & (int64)0x3f);
+
+	*pos += end + 1; // one byte after the last byte of data
+
+	return value;
+}
+
+/// Ternary operators
+/// test ? if_true : if_false
+void op_3(struct script_state* st, int32 op)
+{
+	struct script_data* data;
+	int32 flag = 0;
+
+	data = script_getdatatop(st, -3);
+	get_val(st, data);
+
+	if( data_isstring(data) )
+		flag = data->u.str[0];// "" -> false
+	else if( data_isint(data) )
+		flag = data->u.num == 0 ? 0 : 1;// 0 -> false
+	else
+	{
+		ShowError("script:op_3: invalid data for the ternary operator test\n");
+		script_reportdata(data);
+		script_reportsrc(st);
+		script_removetop(st, -3, 0);
+		script_pushnil(st);
+		return;
+	}
+	if( flag )
+		script_pushcopytop(st, -2);
+	else
+		script_pushcopytop(st, -1);
+	script_removetop(st, -4, -1);
+}
+
+/// Binary string operators
+/// s1 EQ s2 -> i
+/// s1 NE s2 -> i
+/// s1 GT s2 -> i
+/// s1 GE s2 -> i
+/// s1 LT s2 -> i
+/// s1 LE s2 -> i
+/// s1 ADD s2 -> s
+void op_2str(struct script_state* st, int32 op, const char* s1, const char* s2)
+{
+	int32 a = 0;
+
+	switch(op){
+		case C_EQ: a = (strcmp(s1,s2) == 0); break;
+		case C_NE: a = (strcmp(s1,s2) != 0); break;
+		case C_GT: a = (strcmp(s1,s2) >  0); break;
+		case C_GE: a = (strcmp(s1,s2) >= 0); break;
+		case C_LT: a = (strcmp(s1,s2) <  0); break;
+		case C_LE: a = (strcmp(s1,s2) <= 0); break;
+		case C_ADD:
+			{
+				char* buf = (char *)aMalloc((strlen(s1)+strlen(s2)+1)*sizeof(char));
+				strcpy(buf, s1);
+				strcat(buf, s2);
+				script_pushstr(st, buf);
+				return;
+			}
+		default:
+			ShowError("script:op2_str: unexpected string operator %s\n", script_op2name(op));
+			script_reportsrc(st);
+			script_pushnil(st);
+			st->state = END;
+			return;
+	}
+
+	script_pushint(st,a);
+}
+
+/// Binary number operators
+/// i OP i -> i
+void op_2num( struct script_state* st, int32 op, int64 i1, int64 i2 ){
+	int64 ret;
+
+	switch( op ) {
+		case C_AND:  ret = i1 & i2;		break;
+		case C_OR:   ret = i1 | i2;		break;
+		case C_XOR:  ret = i1 ^ i2;		break;
+		case C_LAND: ret = (i1 && i2);	break;
+		case C_LOR:  ret = (i1 || i2);	break;
+		case C_EQ:   ret = (i1 == i2);	break;
+		case C_NE:   ret = (i1 != i2);	break;
+		case C_GT:   ret = (i1 >  i2);	break;
+		case C_GE:   ret = (i1 >= i2);	break;
+		case C_LT:   ret = (i1 <  i2);	break;
+		case C_LE:   ret = (i1 <= i2);	break;
+		case C_R_SHIFT: ret = i1>>i2;	break;
+		case C_L_SHIFT: ret = i1<<i2;	break;
+		case C_DIV:
+		case C_MOD:
+			if( i2 == 0 )
+			{
+				ShowError("script:op_2num: division by zero detected op=%s i1=%" PRId64 " i2=%" PRId64 "\n", script_op2name(op), i1, i2);
+				script_reportsrc(st);
+				script_pushnil(st);
+				st->state = END;
+				return;
+			}
+			else if( op == C_DIV )
+				ret = i1 / i2;
+			else//if( op == C_MOD )
+				ret = i1 % i2;
+			break;
+		default:
+			bool overflow;
+
+			// operators that can overflow/underflow
+			switch( op ) {
+				case C_ADD: overflow = util::safe_addition( i1, i2, ret ); break;
+				case C_SUB: overflow = util::safe_substraction( i1, i2, ret ); break;
+				case C_MUL: overflow = util::safe_multiplication( i1, i2, ret ); break;
+				default:
+					ShowError("script:op_2num: unexpected number operator %s i1=%" PRId64 " i2=%" PRId64 "\n", script_op2name(op), i1, i2);
+					script_reportsrc(st);
+					script_pushnil(st);
+					return;
+			}
+
+			if( overflow ){
+				ShowWarning("script:op_2num: overflow detected op=%s i1=%" PRId64 " i2=%" PRId64 "\n", script_op2name(op), i1, i2);
+				script_reportsrc(st);
+				script_pushnil(st);
+				st->state = END;
+				return;
+			}
+	}
+	script_pushint(st, ret);
+}
+
+/// Binary operators
+void op_2(struct script_state *st, int32 op)
+{
+	struct script_data* left, leftref;
+	struct script_data* right;
+
+	leftref.type = C_NOP;
+
+	left = script_getdatatop(st, -2);
+	right = script_getdatatop(st, -1);
+
+	if (st->op2ref) {
+		if (data_isreference(left)) {
+			leftref = *left;
+		}
+
+		st->op2ref = 0;
+	}
+
+	get_val(st, left);
+	get_val(st, right);
+
+	// automatic conversions
+	switch( op )
+	{
+		case C_ADD:
+			if( data_isint(left) && data_isstring(right) )
+			{// convert int-string to string-string
+				conv_str(st, left);
+			}
+			else if( data_isstring(left) && data_isint(right) )
+			{// convert string-int32 to string-string
+				conv_str(st, right);
+			}
+			break;
+	}
+
+	if( data_isstring(left) && data_isstring(right) )
+	{// ss => op_2str
+		op_2str(st, op, left->u.str, right->u.str);
+		script_removetop(st, leftref.type == C_NOP ? -3 : -2, -1);// pop the two values before the top one
+
+		if (leftref.type != C_NOP)
+		{
+			if (left->type == C_STR) // don't free C_CONSTSTR
+				aFree(left->u.str);
+			*left = leftref;
+		}
+	}
+	else if( data_isint(left) && data_isint(right) )
+	{// ii => op_2num
+		int64 i1 = left->u.num;
+		int64 i2 = right->u.num;
+
+		script_removetop(st, leftref.type == C_NOP ? -2 : -1, 0);
+		op_2num(st, op, i1, i2);
+
+		if (leftref.type != C_NOP)
+			*left = leftref;
+	}
+	else
+	{// invalid argument
+		ShowError("script:op_2: invalid data for operator %s\n", script_op2name(op));
+		script_reportdata(left);
+		script_reportdata(right);
+		script_reportsrc(st);
+		script_removetop(st, -2, 0);
+		script_pushnil(st);
+		st->state = END;
+	}
+}
+
+/// Unary operators
+/// NEG i -> i
+/// NOT i -> i
+/// LNOT i -> i
+void op_1(struct script_state* st, int32 op)
+{
+	struct script_data* data;
+
+	data = script_getdatatop(st, -1);
+	get_val(st, data);
+
+	if( !data_isint(data) )
+	{// not a number
+		ShowError("script:op_1: argument is not a number (op=%s)\n", script_op2name(op));
+		script_reportdata(data);
+		script_reportsrc(st);
+		script_pushnil(st);
+		st->state = END;
+		return;
+	}
+
+	int64 i1 = data->u.num;
+	script_removetop(st, -1, 0);
+	switch( op )
+	{
+		case C_NEG: i1 = -i1; break;
+		case C_NOT: i1 = ~i1; break;
+		case C_LNOT: i1 = !i1; break;
+		default:
+			ShowError("script:op_1: unexpected operator %s i1=%" PRId64 "\n", script_op2name(op), i1);
+			script_reportsrc(st);
+			script_pushnil(st);
+			st->state = END;
+			return;
+	}
+	script_pushint(st, i1);
+}
+
+
+/// Checks the type of all arguments passed to a built-in function.
+///
 /// @param st Script state whose stack arguments should be inspected.
 /// @param func Built-in function for which the arguments are intended.
 static void script_check_buildin_argtype(struct script_state* st, int32 func)
@@ -4160,6 +5897,7 @@ int32 run_func(struct script_state *st)
 			st->state = END;
 			return 1;
 		}
+		script_array_shape_erase_src(&st->stack->scope);
 		script_free_vars(st->stack->scope.vars);
 		st->stack->scope.arrays->destroy(st->stack->scope.arrays, script_free_array_db);
 
@@ -5393,41 +7131,234 @@ BUILDIN_FUNC(goto)
 		return SCRIPT_CMD_FAILURE;
 	}
 
-	st->pos = script_getnum(st,2);
-	st->state = GOTO;
+	st->pos = script_getnum(st,2);
+	st->state = GOTO;
+	return SCRIPT_CMD_SUCCESS;
+}
+
+/*==========================================
+ * user-defined function call
+ *------------------------------------------*/
+BUILDIN_FUNC(callfunc)
+{
+	int32 i, j;
+	struct script_retinfo* ri;
+	struct script_code* scr;
+	const char* str = script_getstr(st,2);
+	struct reg_db *ref = nullptr;
+
+	scr = (struct script_code*)strdb_get(userfunc_db, str);
+	if(!scr) {
+		ShowError("buildin_callfunc: Function not found! [%s]\n", str);
+		st->state = END;
+		return SCRIPT_CMD_FAILURE;
+	}
+
+	ref = (struct reg_db *)aCalloc(sizeof(struct reg_db), 2);
+	ref[0].vars = st->stack->scope.vars;
+	if (!st->stack->scope.arrays)
+		st->stack->scope.arrays = idb_alloc(DB_OPT_BASE); // TODO: Can this happen? when?
+	ref[0].arrays = st->stack->scope.arrays;
+	ref[1].vars = st->script->local.vars;
+	if (!st->script->local.arrays)
+		st->script->local.arrays = idb_alloc(DB_OPT_BASE); // TODO: Can this happen? when?
+	ref[1].arrays = st->script->local.arrays;
+
+	for(i = st->start+3, j = 0; i < st->end; i++, j++) {
+		struct script_data* data = push_copy(st->stack,i);
+
+		if (data_isreference(data) && !data->ref) {
+			const char* name = reference_getname(data);
+
+			if (name[0] == '.')
+				data->ref = (name[1] == '@' ? &ref[0] : &ref[1]);
+		}
+	}
+
+	CREATE(ri, struct script_retinfo, 1);
+	ri->script       = st->script;              // script code
+	ri->scope.vars   = st->stack->scope.vars;   // scope variables
+	ri->scope.arrays = st->stack->scope.arrays; // scope arrays
+	ri->pos          = st->pos;                 // script location
+	ri->nargs        = j;                       // argument count
+	ri->defsp        = st->stack->defsp;        // default stack pointer
+	push_retinfo(st->stack, ri, ref);
+
+	st->pos = 0;
+	st->script = scr;
+	st->stack->defsp = st->stack->sp;
+	st->state = GOTO;
+	st->stack->scope.vars = i64db_alloc(DB_OPT_RELEASE_DATA);
+	st->stack->scope.arrays = idb_alloc(DB_OPT_BASE);
+
+	if (!st->script->local.vars)
+		st->script->local.vars = i64db_alloc(DB_OPT_RELEASE_DATA);
+
+	return SCRIPT_CMD_SUCCESS;
+}
+
+/*==========================================
+ * subroutine call
+ *------------------------------------------*/
+BUILDIN_FUNC(callsub)
+{
+	int32 i,j;
+	struct script_retinfo* ri;
+	int32 pos = script_getnum(st,2);
+	struct reg_db *ref = nullptr;
+
+	if( !data_islabel(script_getdata(st,2)) && !data_isfunclabel(script_getdata(st,2)) ) {
+		ShowError("buildin_callsub: Argument is not a label\n");
+		script_reportdata(script_getdata(st,2));
+		st->state = END;
+		return SCRIPT_CMD_FAILURE;
+	}
+
+	ref = (struct reg_db *)aCalloc(sizeof(struct reg_db), 1);
+	ref[0].vars = st->stack->scope.vars;
+	if (!st->stack->scope.arrays)
+		st->stack->scope.arrays = idb_alloc(DB_OPT_BASE); // TODO: Can this happen? when?
+	ref[0].arrays = st->stack->scope.arrays;
+
+	for(i = st->start+3, j = 0; i < st->end; i++, j++) {
+		struct script_data* data = push_copy(st->stack,i);
+
+		if (data_isreference(data) && !data->ref) {
+			const char* name = reference_getname(data);
+
+			if (name[0] == '.' && name[1] == '@')
+				data->ref = &ref[0];
+		}
+	}
+
+	CREATE(ri, struct script_retinfo, 1);
+	ri->script       = st->script;              // script code
+	ri->scope.vars   = st->stack->scope.vars;   // scope variables
+	ri->scope.arrays = st->stack->scope.arrays; // scope arrays
+	ri->pos          = st->pos;                 // script location
+	ri->nargs        = j;                       // argument count
+	ri->defsp        = st->stack->defsp;        // default stack pointer
+	push_retinfo(st->stack, ri, ref);
+
+	st->pos = pos;
+	st->stack->defsp = st->stack->sp;
+	st->state = GOTO;
+	st->stack->scope.vars = i64db_alloc(DB_OPT_RELEASE_DATA);
+	st->stack->scope.arrays = idb_alloc(DB_OPT_BASE);
+
+	return SCRIPT_CMD_SUCCESS;
+}
+
+/// Retrieves an argument provided to callfunc/callsub.
+/// If the argument doesn't exist
+///
+/// getarg(<index>{,<default_value>}) -> <value>
+BUILDIN_FUNC(getarg)
+{
+	struct script_retinfo* ri;
+	int32 idx;
+
+	if( st->stack->defsp < 1 || st->stack->stack_data[st->stack->defsp - 1].type != C_RETINFO )
+	{
+		ShowError("buildin_getarg: No callfunc or callsub!\n");
+		st->state = END;
+		return SCRIPT_CMD_FAILURE;
+	}
+	ri = st->stack->stack_data[st->stack->defsp - 1].u.ri;
+
+	idx = script_getnum(st,2);
+
+	if( idx >= 0 && idx < ri->nargs )
+		push_copy(st->stack, st->stack->defsp - 1 - ri->nargs + idx);
+	else if( script_hasdata(st,3) )
+		script_pushcopy(st, 3);
+	else
+	{
+		ShowError("buildin_getarg: Index (idx=%d) out of range (nargs=%d) and no default value found\n", idx, ri->nargs);
+		st->state = END;
+		return SCRIPT_CMD_FAILURE;
+	}
+	return SCRIPT_CMD_SUCCESS;
+}
+
+
+/// Retrieves a value from the last return statement.
+/// getreturn(<index>) -> <value>
+BUILDIN_FUNC(getreturn)
+{
+	int32 idx = script_getnum(st, 2);
+	auto it = script_return_values.find(st);
+
+	if (idx < 0 || it == script_return_values.end() || idx >= (int32)it->second.size()) {
+		ShowError("script:getreturn: index %d out of range (count=%d).\n", idx, it == script_return_values.end() ? 0 : (int32)it->second.size());
+		st->state = END;
+		return SCRIPT_CMD_FAILURE;
+	}
+
+	script_push_return_value(st, it->second[idx]);
+	return SCRIPT_CMD_SUCCESS;
+}
+
+/// Retrieves the number of values returned by the last return statement.
+/// getreturncount() -> <count>
+BUILDIN_FUNC(getreturncount)
+{
+	auto it = script_return_values.find(st);
+	script_pushint(st, it == script_return_values.end() ? 0 : (int32)it->second.size());
 	return SCRIPT_CMD_SUCCESS;
 }
 
 /*==========================================
- * user-defined function call
+ * NPC-local subroutine call.
+ * callnpcsub "NPCName", "Label"{, args...};
  *------------------------------------------*/
-BUILDIN_FUNC(callfunc)
+BUILDIN_FUNC(callnpcsub)
 {
-	int32 i, j;
+	const char* npc_name = script_getstr(st, 2);
+	const char* label_name = script_getstr(st, 3);
+	npc_data* nd = npc_name2id(npc_name);
 	struct script_retinfo* ri;
-	struct script_code* scr;
-	const char* str = script_getstr(st,2);
-	struct reg_db *ref = nullptr;
+	struct reg_db* ref = nullptr;
+	int32 i, j;
 
-	scr = (struct script_code*)strdb_get(userfunc_db, str);
-	if(!scr) {
-		ShowError("buildin_callfunc: Function not found! [%s]\n", str);
+	if (label_name == nullptr || strncasecmp(label_name, "On", 2) == 0) {
+		ShowError("script:callnpcsub: event labels starting with 'On' are not allowed ('%s').\n", label_name ? label_name : "");
 		st->state = END;
 		return SCRIPT_CMD_FAILURE;
 	}
 
-	ref = (struct reg_db *)aCalloc(sizeof(struct reg_db), 2);
+	if (nd == nullptr || nd->subtype != NPCTYPE_SCRIPT || nd->u.scr.script == nullptr) {
+		ShowError("script:callnpcsub: NPC '%s' not found or has no script.\n", npc_name);
+		st->state = END;
+		return SCRIPT_CMD_FAILURE;
+	}
+
+	auto script_it = script_code_label_positions.find(nd->u.scr.script);
+	if (script_it == script_code_label_positions.end()) {
+		ShowError("script:callnpcsub: no labels registered for NPC '%s'.\n", npc_name);
+		st->state = END;
+		return SCRIPT_CMD_FAILURE;
+	}
+
+	auto label_it = script_it->second.find(label_name);
+	if (label_it == script_it->second.end()) {
+		ShowError("script:callnpcsub: label '%s' not found in NPC '%s'.\n", label_name, npc_name);
+		st->state = END;
+		return SCRIPT_CMD_FAILURE;
+	}
+
+	ref = (struct reg_db*)aCalloc(sizeof(struct reg_db), 2);
 	ref[0].vars = st->stack->scope.vars;
 	if (!st->stack->scope.arrays)
-		st->stack->scope.arrays = idb_alloc(DB_OPT_BASE); // TODO: Can this happen? when?
+		st->stack->scope.arrays = idb_alloc(DB_OPT_BASE);
 	ref[0].arrays = st->stack->scope.arrays;
 	ref[1].vars = st->script->local.vars;
 	if (!st->script->local.arrays)
-		st->script->local.arrays = idb_alloc(DB_OPT_BASE); // TODO: Can this happen? when?
+		st->script->local.arrays = idb_alloc(DB_OPT_BASE);
 	ref[1].arrays = st->script->local.arrays;
 
-	for(i = st->start+3, j = 0; i < st->end; i++, j++) {
-		struct script_data* data = push_copy(st->stack,i);
+	for (i = st->start + 4, j = 0; i < st->end; i++, j++) {
+		struct script_data* data = push_copy(st->stack, i);
 
 		if (data_isreference(data) && !data->ref) {
 			const char* name = reference_getname(data);
@@ -5438,16 +7369,16 @@ BUILDIN_FUNC(callfunc)
 	}
 
 	CREATE(ri, struct script_retinfo, 1);
-	ri->script       = st->script;              // script code
-	ri->scope.vars   = st->stack->scope.vars;   // scope variables
-	ri->scope.arrays = st->stack->scope.arrays; // scope arrays
-	ri->pos          = st->pos;                 // script location
-	ri->nargs        = j;                       // argument count
-	ri->defsp        = st->stack->defsp;        // default stack pointer
+	ri->script       = st->script;
+	ri->scope.vars   = st->stack->scope.vars;
+	ri->scope.arrays = st->stack->scope.arrays;
+	ri->pos          = st->pos;
+	ri->nargs        = j;
+	ri->defsp        = st->stack->defsp;
 	push_retinfo(st->stack, ri, ref);
 
-	st->pos = 0;
-	st->script = scr;
+	st->pos = label_it->second;
+	st->script = nd->u.scr.script;
 	st->stack->defsp = st->stack->sp;
 	st->state = GOTO;
 	st->stack->scope.vars = i64db_alloc(DB_OPT_RELEASE_DATA);
@@ -5459,825 +7390,1296 @@ BUILDIN_FUNC(callfunc)
 	return SCRIPT_CMD_SUCCESS;
 }
 
+/// Returns from the current function, optionaly returning a value from the functions.
+/// Don't use outside script functions.
+///
+/// return;
+/// return <value>;
+BUILDIN_FUNC(return)
+{
+	script_return_values_clear(st);
+
+	if (script_hasdata(st, 2)) {
+		std::vector<script_data>& values = script_return_values[st];
+
+		for (int32 i = 2; i <= script_lastdata(st); ++i) {
+			script_pushcopy(st, i);
+			script_data* data = script_getdatatop(st, -1);
+
+			// Return values are stored as values, not dangling references to a
+			// disappearing .@ scope.
+			if (data_isreference(data))
+				get_val(st, data);
+
+			values.push_back(script_data_make_owned_copy(data));
+			script_removetop(st, -1, 0);
+		}
+
+		if (!values.empty())
+			script_push_return_value(st, values[0]);
+		else
+			script_pushnil(st);
+	} else {
+		script_return_values[st].clear();
+		script_pushnil(st);
+	}
+
+	st->state = RETFUNC;
+	return SCRIPT_CMD_SUCCESS;
+}
+
+/// Returns a random number.
+/// rand(<range>) -> <int64> in the mathematical range [0, <range - 1>]
+/// rand(<min>,<max>) -> <int64> in the mathematical range [<min>, <max>]
+BUILDIN_FUNC(rand)
+{
+	int64 minimum;
+	int64 maximum;
+
+	// min,max
+	if( script_hasdata( st, 3 ) ){
+		minimum = script_getnum64( st, 2 );
+		maximum = script_getnum64( st, 3 );
+
+		if( minimum > maximum ){
+			ShowWarning( "buildin_rand: minimum (%" PRId64 ") is bigger than maximum (%" PRId64 ").\n", minimum, maximum );
+			// rnd_value already fixes this by swapping minimum and maximum automatically
+		}
+	// range
+	}else{
+		minimum = 0;
+		maximum = script_getnum64( st, 2 );
+
+		if( maximum < 0 ){
+			ShowError( "buildin_rand: range (%" PRId64 ") is negative.\n", maximum );
+			st->state = END;
+			return SCRIPT_CMD_FAILURE;
+		}
+
+		// The range version is exclusive maximum
+		maximum -= 1;
+
+		if( maximum < 1 ){
+			ShowError( "buildin_rand: range (%" PRId64 ") is too small. No randomness possible.\n", maximum );
+			st->state = END;
+			return SCRIPT_CMD_FAILURE;
+		}
+	}
+
+	if( minimum == maximum ){
+		ShowError( "buildin_rand: minimum (%" PRId64 ") and maximum (%" PRId64 ") are equal. No randomness possible.\n", minimum, maximum );
+		st->state = END;
+		return SCRIPT_CMD_FAILURE;
+	}
+
+	script_pushint64( st, rnd_value( minimum, maximum ) );
+
+	return SCRIPT_CMD_SUCCESS;
+}
+
+/*==========================================
+ * Warp sd to str,x,y or Random or SavePoint/Save
+ *------------------------------------------*/
+BUILDIN_FUNC(warp)
+{
+	int32 ret;
+	int32 x,y;
+	const char* str;
+	map_session_data* sd;
+
+	if(!script_charid2sd(5, sd))
+		return SCRIPT_CMD_SUCCESS;
+
+	str = script_getstr(st,2);
+	x = script_getnum(st,3);
+	y = script_getnum(st,4);
+
+	if(strcmp(str,"Random")==0)
+		ret = pc_randomwarp(sd,CLR_TELEPORT,true);
+	else if(strcmp(str,"SavePoint")==0 || strcmp(str,"Save")==0)
+		ret = pc_setpos( sd, mapindex_name2id( sd->status.save_point.map ), sd->status.save_point.x, sd->status.save_point.y, CLR_TELEPORT );
+	else
+		ret = pc_setpos(sd,mapindex_name2id(str),x,y,CLR_OUTSIGHT);
+
+	if( ret ) {
+		ShowError("buildin_warp: moving player '%s' to \"%s\",%d,%d failed.\n", sd->status.name, str, x, y);
+		return SCRIPT_CMD_FAILURE;
+	}
+
+	return SCRIPT_CMD_SUCCESS;
+}
+/*==========================================
+ * Warp a specified area
+ *------------------------------------------*/
+static int32 buildin_areawarp_sub(block_list *bl,va_list ap)
+{
+	int32 x2,y2,x3,y3;
+
+	uint32 index = va_arg(ap,uint32);
+	x2 = va_arg(ap,int32);
+	y2 = va_arg(ap,int32);
+	x3 = va_arg(ap,int32);
+	y3 = va_arg(ap,int32);
+
+	if(index == 0)
+		pc_randomwarp((TBL_PC *)bl,CLR_TELEPORT,true);
+	else if(x3 && y3) {
+		int32 max, tx, ty, j = 0;
+		int16 m;
+
+		m = map_mapindex2mapid(index);
+
+		// choose a suitable max number of attempts
+		if( (max = (y3-y2+1)*(x3-x2+1)*3) > 1000 )
+			max = 1000;
+
+		// find a suitable map cell
+		do {
+			tx = rnd_value(x2, x3);
+			ty = rnd_value(y2, y3);
+			j++;
+		} while( map_getcell(m,tx,ty,CELL_CHKNOPASS) && j < max );
+
+		pc_setpos((TBL_PC *)bl,index,tx,ty,CLR_OUTSIGHT);
+	}
+	else
+		pc_setpos((TBL_PC *)bl,index,x2,y2,CLR_OUTSIGHT);
+	return 0;
+}
+
+BUILDIN_FUNC(areawarp)
+{
+	int16 m, x0,y0,x1,y1, x2,y2,x3=0,y3=0;
+	uint32 index;
+	const char *str;
+	const char *mapname;
+
+	mapname = script_getstr(st,2);
+	x0  = script_getnum(st,3);
+	y0  = script_getnum(st,4);
+	x1  = script_getnum(st,5);
+	y1  = script_getnum(st,6);
+	str = script_getstr(st,7);
+	x2  = script_getnum(st,8);
+	y2  = script_getnum(st,9);
+
+	if( script_hasdata(st,10) && script_hasdata(st,11) ) { // Warp area to area
+		if( (x3 = script_getnum(st,10)) < 0 || (y3 = script_getnum(st,11)) < 0 ){
+			x3 = 0;
+			y3 = 0;
+		} else if( x3 && y3 ) {
+			// normalize x3/y3 coordinates
+			if( x3 < x2 ) std::swap(x3,x2);
+			if( y3 < y2 ) std::swap(y3,y2);
+		}
+	}
+
+	if( (m = map_mapname2mapid(mapname)) < 0 )
+		return SCRIPT_CMD_FAILURE;
+
+	if( strcmp(str,"Random") == 0 )
+		index = 0;
+	else if( !(index=mapindex_name2id(str)) )
+		return SCRIPT_CMD_FAILURE;
+
+	map_foreachinallarea(buildin_areawarp_sub, m,x0,y0,x1,y1, BL_PC, index,x2,y2,x3,y3);
+	return SCRIPT_CMD_SUCCESS;
+}
+
+/*==========================================
+ * areapercentheal <map>,<x1>,<y1>,<x2>,<y2>,<hp>,<sp>
+ *------------------------------------------*/
+static int32 buildin_areapercentheal_sub(block_list *bl,va_list ap)
+{
+	int32 hp, sp;
+	hp = va_arg(ap, int32);
+	sp = va_arg(ap, int32);
+	pc_percentheal((TBL_PC *)bl,hp,sp);
+	return 0;
+}
+
+BUILDIN_FUNC(areapercentheal)
+{
+	int32 hp,sp,m;
+	const char *mapname;
+	int32 x0,y0,x1,y1;
+
+	mapname=script_getstr(st,2);
+	x0=script_getnum(st,3);
+	y0=script_getnum(st,4);
+	x1=script_getnum(st,5);
+	y1=script_getnum(st,6);
+	hp=script_getnum(st,7);
+	sp=script_getnum(st,8);
+
+	if( (m=map_mapname2mapid(mapname))< 0)
+		return SCRIPT_CMD_FAILURE;
+
+	map_foreachinallarea(buildin_areapercentheal_sub,m,x0,y0,x1,y1,BL_PC,hp,sp);
+	return SCRIPT_CMD_SUCCESS;
+}
+
+enum e_warpparty_target{
+	WARPPARTY_RANDOM = 0,
+	WARPPARTY_SAVEPOINTALL,
+	WARPPARTY_SAVEPOINT,
+	WARPPARTY_LEADER,
+	WARPPARTY_RANDOMALL,
+	WARPPARTY_RANDOMALLAREA
+};
+
 /*==========================================
- * subroutine call
+ * Warpparty - [Fredzilla] [Paradox924X]
+ * Syntax: warpparty "to_mapname",x,y,Party_ID,{<"from_mapname">,<range x>,<range y>};
+ * If 'from_mapname' is specified, only the party members on that map will be warped
  *------------------------------------------*/
-BUILDIN_FUNC(callsub)
+BUILDIN_FUNC(warpparty)
 {
-	int32 i,j;
-	struct script_retinfo* ri;
-	int32 pos = script_getnum(st,2);
-	struct reg_db *ref = nullptr;
+	TBL_PC *sd = nullptr;
+	TBL_PC *pl_sd;
+	struct party_data* p;
+	int32 mapindex = 0, m = -1, i, rx = 0, ry = 0;
 
-	if( !data_islabel(script_getdata(st,2)) && !data_isfunclabel(script_getdata(st,2)) ) {
-		ShowError("buildin_callsub: Argument is not a label\n");
-		script_reportdata(script_getdata(st,2));
-		st->state = END;
-		return SCRIPT_CMD_FAILURE;
-	}
+	const char* str = script_getstr(st,2);
+	int32 x = script_getnum(st,3);
+	int32 y = script_getnum(st,4);
+	int32 p_id = script_getnum(st,5);
+	const char* str2 = nullptr;
+	if ( script_hasdata(st,6) )
+		str2 = script_getstr(st,6);
+	if (script_hasdata(st, 7))
+		rx = script_getnum(st, 7);
+	if (script_hasdata(st, 8))
+		ry = script_getnum(st, 8);
 
-	ref = (struct reg_db *)aCalloc(sizeof(struct reg_db), 1);
-	ref[0].vars = st->stack->scope.vars;
-	if (!st->stack->scope.arrays)
-		st->stack->scope.arrays = idb_alloc(DB_OPT_BASE); // TODO: Can this happen? when?
-	ref[0].arrays = st->stack->scope.arrays;
+	p = party_search(p_id);
+	if(!p)
+		return SCRIPT_CMD_SUCCESS;
 
-	for(i = st->start+3, j = 0; i < st->end; i++, j++) {
-		struct script_data* data = push_copy(st->stack,i);
+	enum e_warpparty_target type = ( strcmp(str,"Random")==0 ) ? WARPPARTY_RANDOM
+	     : ( strcmp(str,"SavePointAll")==0 ) ? WARPPARTY_SAVEPOINTALL
+		 : ( strcmp(str,"SavePoint")==0 ) ? WARPPARTY_SAVEPOINT
+		 : ( strcmp(str,"Leader")==0 ) ? WARPPARTY_LEADER
+		 : ( strcmp(str,"RandomAll")==0 ) ? WARPPARTY_RANDOMALL
+		 : WARPPARTY_RANDOMALLAREA;
 
-		if (data_isreference(data) && !data->ref) {
-			const char* name = reference_getname(data);
+	switch (type)
+	{
+		case WARPPARTY_SAVEPOINT:
+			//"SavePoint" uses save point of the currently attached player
+			if ( !script_rid2sd(sd) )
+				return SCRIPT_CMD_FAILURE;
+			break;
+		case WARPPARTY_LEADER:
+			for(i = 0; i < MAX_PARTY && !p->party.member[i].leader; i++);
+			if (i == MAX_PARTY || !p->data[i].sd) //Leader not found / not online
+				return SCRIPT_CMD_FAILURE;
+			pl_sd = p->data[i].sd;
+			mapindex = pl_sd->mapindex;
+			m = map_mapindex2mapid(mapindex);
+			x = pl_sd->x;
+			y = pl_sd->y;
+			break;
+		case WARPPARTY_RANDOMALL: {
+			if ( !script_rid2sd(sd) )
+				return SCRIPT_CMD_FAILURE;
 
-			if (name[0] == '.' && name[1] == '@')
-				data->ref = &ref[0];
-		}
-	}
+			mapindex = sd->mapindex;
+			m = map_mapindex2mapid(mapindex);
 
-	CREATE(ri, struct script_retinfo, 1);
-	ri->script       = st->script;              // script code
-	ri->scope.vars   = st->stack->scope.vars;   // scope variables
-	ri->scope.arrays = st->stack->scope.arrays; // scope arrays
-	ri->pos          = st->pos;                 // script location
-	ri->nargs        = j;                       // argument count
-	ri->defsp        = st->stack->defsp;        // default stack pointer
-	push_retinfo(st->stack, ri, ref);
+			struct map_data *mapdata = map_getmapdata(m);
 
-	st->pos = pos;
-	st->stack->defsp = st->stack->sp;
-	st->state = GOTO;
-	st->stack->scope.vars = i64db_alloc(DB_OPT_RELEASE_DATA);
-	st->stack->scope.arrays = idb_alloc(DB_OPT_BASE);
+			if ( mapdata == nullptr || mapdata->getMapFlag(MF_NOWARP) || mapdata->getMapFlag(MF_NOTELEPORT) )
+				return SCRIPT_CMD_FAILURE;
 
-	return SCRIPT_CMD_SUCCESS;
-}
+			i = 0;
+			do {
+				x = rnd_value(1, mapdata->xs - 1);
+				y = rnd_value(1, mapdata->ys - 1);
+			} while ((map_getcell(m,x,y,CELL_CHKNOPASS) || (!battle_config.teleport_on_portal && npc_check_areanpc(1,m,x,y,1))) && (i++) < 1000);
 
-/// Retrieves an argument provided to callfunc/callsub.
-/// If the argument doesn't exist
-///
-/// getarg(<index>{,<default_value>}) -> <value>
-BUILDIN_FUNC(getarg)
-{
-	struct script_retinfo* ri;
-	int32 idx;
+			if (i >= 1000) {
+				ShowError("buildin_warpparty: moving player '%s' to \"%s\",%d,%d failed.\n", sd->status.name, str, x, y);
+				return SCRIPT_CMD_FAILURE;
+			}
+			} break;
+		case WARPPARTY_RANDOMALLAREA:
+			mapindex = mapindex_name2id(str);
+			if (!mapindex) {// Invalid map
+				return SCRIPT_CMD_FAILURE;
+			}
+			m = map_mapindex2mapid(mapindex);
+			break;
+	}
 
-	if( st->stack->defsp < 1 || st->stack->stack_data[st->stack->defsp - 1].type != C_RETINFO )
+	for (i = 0; i < MAX_PARTY; i++)
 	{
-		ShowError("buildin_getarg: No callfunc or callsub!\n");
-		st->state = END;
-		return SCRIPT_CMD_FAILURE;
-	}
-	ri = st->stack->stack_data[st->stack->defsp - 1].u.ri;
+		if( !(pl_sd = p->data[i].sd) || pl_sd->status.party_id != p_id )
+			continue;
 
-	idx = script_getnum(st,2);
+		map_data* mapdata = map_getmapdata(pl_sd->m);
 
-	if( idx >= 0 && idx < ri->nargs )
-		push_copy(st->stack, st->stack->defsp - 1 - ri->nargs + idx);
-	else if( script_hasdata(st,3) )
-		script_pushcopy(st, 3);
-	else
-	{
-		ShowError("buildin_getarg: Index (idx=%d) out of range (nargs=%d) and no default value found\n", idx, ri->nargs);
-		st->state = END;
-		return SCRIPT_CMD_FAILURE;
-	}
-	return SCRIPT_CMD_SUCCESS;
-}
+		if( str2 && strcmp(str2, mapdata->name) != 0 )
+			continue;
 
-/// Returns from the current function, optionaly returning a value from the functions.
-/// Don't use outside script functions.
-///
-/// return;
-/// return <value>;
-BUILDIN_FUNC(return)
-{
-	if( script_hasdata(st,2) )
-	{// return value
-		struct script_data* data;
-		script_pushcopy(st, 2);
-		data = script_getdatatop(st, -1);
-		if( data_isreference(data) ) {
-			const char* name = reference_getname(data);
-			if( name[0] == '.' && name[1] == '@' ) { // scope variable
-				if( !data->ref || data->ref->vars == st->stack->scope.vars )
-					get_val(st, data); // current scope, convert to value
-				if( data->ref && data->ref->vars == st->stack->stack_data[st->stack->defsp-1].u.ri->scope.vars )
-					data->ref = nullptr; // Reference to the parent scope, remove reference pointer
+		if( pc_isdead(pl_sd) )
+			continue;
+
+		e_setpos ret = SETPOS_OK;
+
+		switch( type )
+		{
+		case WARPPARTY_RANDOM:
+			if (!mapdata->getMapFlag(MF_NOWARP))
+				ret = (e_setpos)pc_randomwarp(pl_sd,CLR_TELEPORT);
+		break;
+		case WARPPARTY_SAVEPOINTALL:
+			if (!mapdata->getMapFlag(MF_NORETURN))
+				ret = pc_setpos( pl_sd, mapindex_name2id( pl_sd->status.save_point.map ), pl_sd->status.save_point.x, pl_sd->status.save_point.y, CLR_TELEPORT );
+		break;
+		case WARPPARTY_SAVEPOINT:
+			if (!mapdata->getMapFlag(MF_NORETURN))
+				ret = pc_setpos( pl_sd, mapindex_name2id( sd->status.save_point.map ),sd->status.save_point.x, sd->status.save_point.y, CLR_TELEPORT );
+		break;
+		case WARPPARTY_LEADER:
+			if (p->party.member[i].leader)
+				continue;
+			[[fallthrough]];
+		case WARPPARTY_RANDOMALL:
+			if (pl_sd == sd) {
+				ret = pc_setpos(pl_sd, mapindex, x, y, CLR_TELEPORT);
+				break;
+			}
+			[[fallthrough]];
+		case WARPPARTY_RANDOMALLAREA:
+			if(!mapdata->getMapFlag(MF_NORETURN) && !mapdata->getMapFlag(MF_NOWARP) && pc_job_can_entermap((enum e_job)pl_sd->status.class_, m, pc_get_group_level(pl_sd))){
+				int32 nx = x;
+				int32 ny = y;
+				if (rx || ry) {
+					uint8 attempts = 10;
+
+					do {
+						nx = x + rnd_value(-rx, rx);
+						ny = y + rnd_value(-ry, ry);
+					} while ((--attempts) > 0 && !map_getcell(m, nx, ny, CELL_CHKPASS));
+
+					if (attempts == 0) { //Keep the original coordinates if fails to find a valid cell within the range
+						nx = x;
+						ny = y;
+					}
+				}
+
+				ret = pc_setpos(pl_sd, mapindex, nx, ny, CLR_TELEPORT);
 			}
+			break;
+		}
+
+		if( ret != SETPOS_OK ) {
+			ShowError("buildin_warpparty: moving player '%s' to \"%s\",%d,%d failed.\n", pl_sd->status.name, str, x, y);
+			if ( ( type == WARPPARTY_RANDOMALL || type == WARPPARTY_RANDOMALLAREA ) && (rx || ry) )
+				continue;
+			else
+				return SCRIPT_CMD_FAILURE;
 		}
 	}
-	else
-	{// no return value
-		script_pushnil(st);
-	}
-	st->state = RETFUNC;
+
 	return SCRIPT_CMD_SUCCESS;
 }
 
-/// Returns a random number.
-/// rand(<range>) -> <int64> in the mathematical range [0, <range - 1>]
-/// rand(<min>,<max>) -> <int64> in the mathematical range [<min>, <max>]
-BUILDIN_FUNC(rand)
+/*==========================================
+ * Warpguild - [Fredzilla]
+ * Syntax: warpguild "mapname",x,y,Guild_ID;
+ *------------------------------------------*/
+BUILDIN_FUNC(warpguild)
 {
-	int64 minimum;
-	int64 maximum;
-
-	// min,max
-	if( script_hasdata( st, 3 ) ){
-		minimum = script_getnum64( st, 2 );
-		maximum = script_getnum64( st, 3 );
-
-		if( minimum > maximum ){
-			ShowWarning( "buildin_rand: minimum (%" PRId64 ") is bigger than maximum (%" PRId64 ").\n", minimum, maximum );
-			// rnd_value already fixes this by swapping minimum and maximum automatically
-		}
-	// range
-	}else{
-		minimum = 0;
-		maximum = script_getnum64( st, 2 );
+	TBL_PC *sd = nullptr;
+	TBL_PC *pl_sd;
+	struct s_mapiterator* iter;
+	int32 type, mapindex = 0, m = -1;
 
-		if( maximum < 0 ){
-			ShowError( "buildin_rand: range (%" PRId64 ") is negative.\n", maximum );
-			st->state = END;
-			return SCRIPT_CMD_FAILURE;
-		}
+	const char* str = script_getstr(st,2);
+	int32 x           = script_getnum(st,3);
+	int32 y           = script_getnum(st,4);
+	int32 gid         = script_getnum(st,5);
 
-		// The range version is exclusive maximum
-		maximum -= 1;
+	auto g = guild_search(gid);
+	if( g == nullptr )
+		return SCRIPT_CMD_SUCCESS;
 
-		if( maximum < 1 ){
-			ShowError( "buildin_rand: range (%" PRId64 ") is too small. No randomness possible.\n", maximum );
-			st->state = END;
-			return SCRIPT_CMD_FAILURE;
-		}
+	type = ( strcmp(str,"Random")==0 ) ? 0
+	     : ( strcmp(str,"SavePointAll")==0 ) ? 1
+		 : ( strcmp(str,"SavePoint")==0 ) ? 2
+		 : 3;
+
+	if( type == 2 && !script_rid2sd(sd) )
+	{// "SavePoint" uses save point of the currently attached player
+		return SCRIPT_CMD_SUCCESS;
 	}
 
-	if( minimum == maximum ){
-		ShowError( "buildin_rand: minimum (%" PRId64 ") and maximum (%" PRId64 ") are equal. No randomness possible.\n", minimum, maximum );
-		st->state = END;
-		return SCRIPT_CMD_FAILURE;
+	switch (type) {
+		case 3:
+			mapindex = mapindex_name2id(str);
+			if (!mapindex)
+				return SCRIPT_CMD_FAILURE;
+			m = map_mapindex2mapid(mapindex);
+			break;
 	}
 
-	script_pushint64( st, rnd_value( minimum, maximum ) );
+	iter = mapit_getallusers();
+	for( pl_sd = (TBL_PC*)mapit_first(iter); mapit_exists(iter); pl_sd = (TBL_PC*)mapit_next(iter) )
+	{
+		if( pl_sd->status.guild_id != gid )
+			continue;
+
+		switch( type )
+		{
+		case 0: // Random
+			if(!map_getmapflag(pl_sd->m, MF_NOWARP))
+				pc_randomwarp(pl_sd,CLR_TELEPORT);
+		break;
+		case 1: // SavePointAll
+			if(!map_getmapflag(pl_sd->m, MF_NORETURN))
+				pc_setpos( pl_sd, mapindex_name2id( pl_sd->status.save_point.map ), pl_sd->status.save_point.x, pl_sd->status.save_point.y, CLR_TELEPORT );
+		break;
+		case 2: // SavePoint
+			if(!map_getmapflag(pl_sd->m, MF_NORETURN))
+				pc_setpos( pl_sd, mapindex_name2id( sd->status.save_point.map ),sd->status.save_point.x, sd->status.save_point.y, CLR_TELEPORT );
+		break;
+		case 3: // m,x,y
+			if(!map_getmapflag(pl_sd->m, MF_NORETURN) && !map_getmapflag(pl_sd->m, MF_NOWARP) && pc_job_can_entermap((enum e_job)pl_sd->status.class_, m, pc_get_group_level(pl_sd)))
+				pc_setpos(pl_sd,mapindex,x,y,CLR_TELEPORT);
+		break;
+		}
+	}
+	mapit_free(iter);
 
 	return SCRIPT_CMD_SUCCESS;
 }
 
 /*==========================================
- * Warp sd to str,x,y or Random or SavePoint/Save
+ * Force Heal a player (hp and sp)
  *------------------------------------------*/
-BUILDIN_FUNC(warp)
+BUILDIN_FUNC(heal)
 {
-	int32 ret;
-	int32 x,y;
-	const char* str;
-	map_session_data* sd;
+	TBL_PC *sd;
+	int32 hp,sp;
 
-	if(!script_charid2sd(5, sd))
+	if (!script_charid2sd(4,sd))
 		return SCRIPT_CMD_SUCCESS;
 
-	str = script_getstr(st,2);
-	x = script_getnum(st,3);
-	y = script_getnum(st,4);
+	hp=script_getnum(st,2);
+	sp=script_getnum(st,3);
+	status_heal(sd, hp, sp, 1);
+	return SCRIPT_CMD_SUCCESS;
+}
 
-	if(strcmp(str,"Random")==0)
-		ret = pc_randomwarp(sd,CLR_TELEPORT,true);
-	else if(strcmp(str,"SavePoint")==0 || strcmp(str,"Save")==0)
-		ret = pc_setpos( sd, mapindex_name2id( sd->status.save_point.map ), sd->status.save_point.x, sd->status.save_point.y, CLR_TELEPORT );
-	else
-		ret = pc_setpos(sd,mapindex_name2id(str),x,y,CLR_OUTSIGHT);
+/*==========================================
+ * Force Heal a player (ap)
+ *------------------------------------------*/
+BUILDIN_FUNC(healap)
+{
+	map_session_data* sd;
 
-	if( ret ) {
-		ShowError("buildin_warp: moving player '%s' to \"%s\",%d,%d failed.\n", sd->status.name, str, x, y);
+	if (!script_charid2sd(3, sd))
 		return SCRIPT_CMD_FAILURE;
-	}
 
+	status_heal(sd, 0, 0, script_getnum(st, 2), 1);
 	return SCRIPT_CMD_SUCCESS;
 }
+
 /*==========================================
- * Warp a specified area
+ * Heal a player by item (get vit bonus etc)
  *------------------------------------------*/
-static int32 buildin_areawarp_sub(block_list *bl,va_list ap)
+BUILDIN_FUNC(itemheal)
 {
-	int32 x2,y2,x3,y3;
+	TBL_PC *sd;
+	int32 hp,sp;
 
-	uint32 index = va_arg(ap,uint32);
-	x2 = va_arg(ap,int32);
-	y2 = va_arg(ap,int32);
-	x3 = va_arg(ap,int32);
-	y3 = va_arg(ap,int32);
+	hp=script_getnum(st,2);
+	sp=script_getnum(st,3);
 
-	if(index == 0)
-		pc_randomwarp((TBL_PC *)bl,CLR_TELEPORT,true);
-	else if(x3 && y3) {
-		int32 max, tx, ty, j = 0;
-		int16 m;
+	if(potion_flag==1) {
+		potion_hp = hp;
+		potion_sp = sp;
+		return SCRIPT_CMD_SUCCESS;
+	}
 
-		m = map_mapindex2mapid(index);
+	if (!script_charid2sd(4,sd))
+		return SCRIPT_CMD_SUCCESS;
 
-		// choose a suitable max number of attempts
-		if( (max = (y3-y2+1)*(x3-x2+1)*3) > 1000 )
-			max = 1000;
+	pc_itemheal(sd,sd->itemid,hp,sp);
+	return SCRIPT_CMD_SUCCESS;
+}
 
-		// find a suitable map cell
-		do {
-			tx = rnd_value(x2, x3);
-			ty = rnd_value(y2, y3);
-			j++;
-		} while( map_getcell(m,tx,ty,CELL_CHKNOPASS) && j < max );
+/*==========================================
+ *
+ *------------------------------------------*/
+BUILDIN_FUNC(percentheal)
+{
+	int32 hp,sp;
+	TBL_PC* sd;
 
-		pc_setpos((TBL_PC *)bl,index,tx,ty,CLR_OUTSIGHT);
+	hp=script_getnum(st,2);
+	sp=script_getnum(st,3);
+
+	if(potion_flag==1) {
+		potion_per_hp = hp;
+		potion_per_sp = sp;
+		return SCRIPT_CMD_SUCCESS;
 	}
-	else
-		pc_setpos((TBL_PC *)bl,index,x2,y2,CLR_OUTSIGHT);
-	return 0;
+
+	if (!script_charid2sd(4,sd))
+		return SCRIPT_CMD_SUCCESS;
+
+#ifdef RENEWAL
+	if( sd->sc.getSCE(SC_EXTREMITYFIST) )
+		sp = 0;
+#endif
+
+	if (sd->sc.getSCE(SC_NORECOVER_STATE)) {
+		hp = 0;
+		sp = 0;
+	}
+
+	if (sd->sc.getSCE(SC_BITESCAR))
+		hp = 0;
+
+	pc_percentheal(sd,hp,sp);
+	return SCRIPT_CMD_SUCCESS;
 }
 
-BUILDIN_FUNC(areawarp)
+/*==========================================
+ *
+ *------------------------------------------*/
+BUILDIN_FUNC(jobchange)
 {
-	int16 m, x0,y0,x1,y1, x2,y2,x3=0,y3=0;
-	uint32 index;
-	const char *str;
-	const char *mapname;
+	int32 job, upper=-1;
 
-	mapname = script_getstr(st,2);
-	x0  = script_getnum(st,3);
-	y0  = script_getnum(st,4);
-	x1  = script_getnum(st,5);
-	y1  = script_getnum(st,6);
-	str = script_getstr(st,7);
-	x2  = script_getnum(st,8);
-	y2  = script_getnum(st,9);
+	job=script_getnum(st,2);
+	if( script_hasdata(st,3) )
+		upper=script_getnum(st,3);
 
-	if( script_hasdata(st,10) && script_hasdata(st,11) ) { // Warp area to area
-		if( (x3 = script_getnum(st,10)) < 0 || (y3 = script_getnum(st,11)) < 0 ){
-			x3 = 0;
-			y3 = 0;
-		} else if( x3 && y3 ) {
-			// normalize x3/y3 coordinates
-			if( x3 < x2 ) std::swap(x3,x2);
-			if( y3 < y2 ) std::swap(y3,y2);
-		}
-	}
+	if (pcdb_checkid(job))
+	{
+		TBL_PC* sd;
 
-	if( (m = map_mapname2mapid(mapname)) < 0 )
-		return SCRIPT_CMD_FAILURE;
+		if (!script_charid2sd(4,sd))
+			return SCRIPT_CMD_SUCCESS;
 
-	if( strcmp(str,"Random") == 0 )
-		index = 0;
-	else if( !(index=mapindex_name2id(str)) )
-		return SCRIPT_CMD_FAILURE;
+		pc_jobchange(sd, job, upper);
+	}
 
-	map_foreachinallarea(buildin_areawarp_sub, m,x0,y0,x1,y1, BL_PC, index,x2,y2,x3,y3);
 	return SCRIPT_CMD_SUCCESS;
 }
 
 /*==========================================
- * areapercentheal <map>,<x1>,<y1>,<x2>,<y2>,<hp>,<sp>
+ *
  *------------------------------------------*/
-static int32 buildin_areapercentheal_sub(block_list *bl,va_list ap)
+BUILDIN_FUNC(jobname)
 {
-	int32 hp, sp;
-	hp = va_arg(ap, int32);
-	sp = va_arg(ap, int32);
-	pc_percentheal((TBL_PC *)bl,hp,sp);
-	return 0;
+	int32 class_=script_getnum(st,2);
+	script_pushconststr(st, (char*)job_name(class_));
+	return SCRIPT_CMD_SUCCESS;
 }
 
-BUILDIN_FUNC(areapercentheal)
+/// Get input from the player.
+/// For numeric inputs the value is capped to the range [min,max]. Returns 1 if
+/// the value was higher than 'max', -1 if lower than 'min' and 0 otherwise.
+/// For string inputs it returns 1 if the string was longer than 'max', -1 is
+/// shorter than 'min' and 0 otherwise.
+///
+/// input(<var>{,<min>{,<max>}}) -> <int>
+BUILDIN_FUNC(input)
 {
-	int32 hp,sp,m;
-	const char *mapname;
-	int32 x0,y0,x1,y1;
+	TBL_PC* sd;
+	struct script_data* data;
+	int64 uid;
+	const char* name;
+	int32 min;
+	int32 max;
 
-	mapname=script_getstr(st,2);
-	x0=script_getnum(st,3);
-	y0=script_getnum(st,4);
-	x1=script_getnum(st,5);
-	y1=script_getnum(st,6);
-	hp=script_getnum(st,7);
-	sp=script_getnum(st,8);
+	if( !script_rid2sd(sd) )
+		return SCRIPT_CMD_SUCCESS;
 
-	if( (m=map_mapname2mapid(mapname))< 0)
+	data = script_getdata(st,2);
+	if( !data_isreference(data) ){
+		ShowError("script:input: not a variable\n");
+		script_reportdata(data);
+		st->state = END;
 		return SCRIPT_CMD_FAILURE;
+	}
+	uid = reference_getuid(data);
+	name = reference_getname(data);
+	min = (script_hasdata(st,3) ? script_getnum(st,3) : script_config.input_min_value);
+	max = (script_hasdata(st,4) ? script_getnum(st,4) : script_config.input_max_value);
 
-	map_foreachinallarea(buildin_areapercentheal_sub,m,x0,y0,x1,y1,BL_PC,hp,sp);
+#ifdef SECURE_NPCTIMEOUT
+	sd->npc_idle_type = NPCT_WAIT;
+#endif
+
+	if( !sd->state.menu_or_input )
+	{	// first invocation, display npc input box
+		sd->state.menu_or_input = 1;
+		st->state = RERUNLINE;
+		if( is_string_variable(name) )
+			clif_scriptinputstr( *sd, st->oid );
+		else
+			clif_scriptinput( *sd, st->oid );
+	}
+	else
+	{	// take received text/value and store it in the designated variable
+		sd->state.menu_or_input = 0;
+		if( is_string_variable(name) )
+		{
+			int32 len = (int32)strlen(sd->npc_str);
+			set_reg_str(st, sd, uid, name, sd->npc_str, script_getref(st,2));
+			script_pushint(st, (len > max ? 1 : len < min ? -1 : 0));
+		}
+		else
+		{
+			int32 amount = sd->npc_amount;
+			set_reg_num(st, sd, uid, name, cap_value(amount,min,max), script_getref(st,2));
+			script_pushint(st, (amount > max ? 1 : amount < min ? -1 : 0));
+		}
+		st->state = RUN;
+	}
 	return SCRIPT_CMD_SUCCESS;
 }
 
-enum e_warpparty_target{
-	WARPPARTY_RANDOM = 0,
-	WARPPARTY_SAVEPOINTALL,
-	WARPPARTY_SAVEPOINT,
-	WARPPARTY_LEADER,
-	WARPPARTY_RANDOMALL,
-	WARPPARTY_RANDOMALLAREA
-};
+// declare the copyarray method here for future reference
+BUILDIN_FUNC(copyarray);
+BUILDIN_FUNC(deletearray);
+BUILDIN_FUNC(getarraydims);
+BUILDIN_FUNC(dyn);
+BUILDIN_FUNC(setarraydyn);
+BUILDIN_FUNC(getarraysizedyn);
+BUILDIN_FUNC(getdyntype);
+BUILDIN_FUNC(getarraykeys);
+BUILDIN_FUNC(dyntostring);
+BUILDIN_FUNC(debugdyn);
 
-/*==========================================
- * Warpparty - [Fredzilla] [Paradox924X]
- * Syntax: warpparty "to_mapname",x,y,Party_ID,{<"from_mapname">,<range x>,<range y>};
- * If 'from_mapname' is specified, only the party members on that map will be warped
- *------------------------------------------*/
-BUILDIN_FUNC(warpparty)
+/// Sets the value of a variable.
+/// The value is converted to the type of the variable.
+///
+/// set(<variable>,<value>{,<charid>})
+BUILDIN_FUNC(setr)
 {
-	TBL_PC *sd = nullptr;
-	TBL_PC *pl_sd;
-	struct party_data* p;
-	int32 mapindex = 0, m = -1, i, rx = 0, ry = 0;
-
-	const char* str = script_getstr(st,2);
-	int32 x = script_getnum(st,3);
-	int32 y = script_getnum(st,4);
-	int32 p_id = script_getnum(st,5);
-	const char* str2 = nullptr;
-	if ( script_hasdata(st,6) )
-		str2 = script_getstr(st,6);
-	if (script_hasdata(st, 7))
-		rx = script_getnum(st, 7);
-	if (script_hasdata(st, 8))
-		ry = script_getnum(st, 8);
-
-	p = party_search(p_id);
-	if(!p)
-		return SCRIPT_CMD_SUCCESS;
-
-	enum e_warpparty_target type = ( strcmp(str,"Random")==0 ) ? WARPPARTY_RANDOM
-	     : ( strcmp(str,"SavePointAll")==0 ) ? WARPPARTY_SAVEPOINTALL
-		 : ( strcmp(str,"SavePoint")==0 ) ? WARPPARTY_SAVEPOINT
-		 : ( strcmp(str,"Leader")==0 ) ? WARPPARTY_LEADER
-		 : ( strcmp(str,"RandomAll")==0 ) ? WARPPARTY_RANDOMALL
-		 : WARPPARTY_RANDOMALLAREA;
+	TBL_PC* sd = nullptr;
+	struct script_data* data;
+	//struct script_data* datavalue;
+	int64 num;
+	uint8 pos = 4;
+	const char* name, *command = script_getfuncname(st);
+	char prefix;
 
-	switch (type)
+	data = script_getdata(st,2);
+	//datavalue = script_getdata(st,3);
+	if( !data_isreference(data) )
 	{
-		case WARPPARTY_SAVEPOINT:
-			//"SavePoint" uses save point of the currently attached player
-			if ( !script_rid2sd(sd) )
-				return SCRIPT_CMD_FAILURE;
-			break;
-		case WARPPARTY_LEADER:
-			for(i = 0; i < MAX_PARTY && !p->party.member[i].leader; i++);
-			if (i == MAX_PARTY || !p->data[i].sd) //Leader not found / not online
-				return SCRIPT_CMD_FAILURE;
-			pl_sd = p->data[i].sd;
-			mapindex = pl_sd->mapindex;
-			m = map_mapindex2mapid(mapindex);
-			x = pl_sd->x;
-			y = pl_sd->y;
-			break;
-		case WARPPARTY_RANDOMALL: {
-			if ( !script_rid2sd(sd) )
-				return SCRIPT_CMD_FAILURE;
+		ShowError("script:set: not a variable\n");
+		script_reportdata(script_getdata(st,2));
+		st->state = END;
+		return SCRIPT_CMD_FAILURE;
+	}
 
-			mapindex = sd->mapindex;
-			m = map_mapindex2mapid(mapindex);
+	num = reference_getuid(data);
+	name = reference_getname(data);
+	prefix = *name;
 
-			struct map_data *mapdata = map_getmapdata(m);
+	if (!strcmp(command, "setr"))
+		pos = 5;
 
-			if ( mapdata == nullptr || mapdata->getMapFlag(MF_NOWARP) || mapdata->getMapFlag(MF_NOTELEPORT) )
-				return SCRIPT_CMD_FAILURE;
+	if (not_server_variable(prefix) && !script_charid2sd(pos,sd)) {
+		ShowError("buildin_set: No player attached for player variable '%s'\n", name);
+		return SCRIPT_CMD_FAILURE;
+	}
 
-			i = 0;
-			do {
-				x = rnd_value(1, mapdata->xs - 1);
-				y = rnd_value(1, mapdata->ys - 1);
-			} while ((map_getcell(m,x,y,CELL_CHKNOPASS) || (!battle_config.teleport_on_portal && npc_check_areanpc(1,m,x,y,1))) && (i++) < 1000);
+#if 0
+	if( data_isreference(datavalue) )
+	{// the value being referenced is a variable
+		const char* namevalue = reference_getname(datavalue);
 
-			if (i >= 1000) {
-				ShowError("buildin_warpparty: moving player '%s' to \"%s\",%d,%d failed.\n", sd->status.name, str, x, y);
-				return SCRIPT_CMD_FAILURE;
+		if( !not_array_variable(*namevalue) )
+		{// array variable being copied into another array variable
+			if( sd == nullptr && not_server_variable(*namevalue) && !(sd = script_rid2sd(st)) )
+			{// player must be attached in order to copy a player variable
+				ShowError("script:set: no player attached for player variable '%s'\n", namevalue);
+				return SCRIPT_CMD_SUCCESS;
 			}
-			} break;
-		case WARPPARTY_RANDOMALLAREA:
-			mapindex = mapindex_name2id(str);
-			if (!mapindex) {// Invalid map
-				return SCRIPT_CMD_FAILURE;
+
+			if( is_string_variable(namevalue) != is_string_variable(name) )
+			{// non-matching array value types
+				ShowWarning("script:set: two array variables do not match in type.\n");
+				return SCRIPT_CMD_SUCCESS;
 			}
-			m = map_mapindex2mapid(mapindex);
-			break;
-	}
 
-	for (i = 0; i < MAX_PARTY; i++)
-	{
-		if( !(pl_sd = p->data[i].sd) || pl_sd->status.party_id != p_id )
-			continue;
+			// push the maximum number of array values to the stack
+			push_val(st->stack, C_INT, SCRIPT_MAX_ARRAYSIZE);
 
-		map_data* mapdata = map_getmapdata(pl_sd->m);
+			// call the copy array method directly
+			return buildin_copyarray(st);
+		}
+	}
+#endif
 
-		if( str2 && strcmp(str2, mapdata->name) != 0 )
-			continue;
+	{
+		script_array_shape_info* non_dyn_shape = script_array_shape_get_by_name(st, sd, name, script_getref(st, 2), script_getvarid(num));
+		if (non_dyn_shape != nullptr && !non_dyn_shape->dynamic && script_array_dynamic_reference_is_child(non_dyn_shape, script_getvaridx(num))) {
+			ShowError("script:set: multidimensional/string-key array access on '%s' requires dyn.\n", name);
+			st->state = END;
+			return SCRIPT_CMD_FAILURE;
+		}
+	}
 
-		if( pc_isdead(pl_sd) )
-			continue;
+	if (script_array_is_dynamic_ref(st, sd, num, name, script_getref(st, 2))) {
+		// Store the dynamic value before pushing the command return value.
+		// Some assignments push a copy of the destination reference on the stack;
+		// doing that first can make the RHS access fragile for dynamic scalar strings.
+		script_data old_ret;
+		bool has_old_ret = false;
 
-		e_setpos ret = SETPOS_OK;
+		if (!strcmp(command, "setr") && script_hasdata(st, 4)) {
+			old_ret = *script_getdata(st, 4);
+			has_old_ret = true;
+		}
 
-		switch( type )
-		{
-		case WARPPARTY_RANDOM:
-			if (!mapdata->getMapFlag(MF_NOWARP))
-				ret = (e_setpos)pc_randomwarp(pl_sd,CLR_TELEPORT);
-		break;
-		case WARPPARTY_SAVEPOINTALL:
-			if (!mapdata->getMapFlag(MF_NORETURN))
-				ret = pc_setpos( pl_sd, mapindex_name2id( pl_sd->status.save_point.map ), pl_sd->status.save_point.x, pl_sd->status.save_point.y, CLR_TELEPORT );
-		break;
-		case WARPPARTY_SAVEPOINT:
-			if (!mapdata->getMapFlag(MF_NORETURN))
-				ret = pc_setpos( pl_sd, mapindex_name2id( sd->status.save_point.map ),sd->status.save_point.x, sd->status.save_point.y, CLR_TELEPORT );
-		break;
-		case WARPPARTY_LEADER:
-			if (p->party.member[i].leader)
-				continue;
-			[[fallthrough]];
-		case WARPPARTY_RANDOMALL:
-			if (pl_sd == sd) {
-				ret = pc_setpos(pl_sd, mapindex, x, y, CLR_TELEPORT);
-				break;
-			}
-			[[fallthrough]];
-		case WARPPARTY_RANDOMALLAREA:
-			if(!mapdata->getMapFlag(MF_NORETURN) && !mapdata->getMapFlag(MF_NOWARP) && pc_job_can_entermap((enum e_job)pl_sd->status.class_, m, pc_get_group_level(pl_sd))){
-				int32 nx = x;
-				int32 ny = y;
-				if (rx || ry) {
-					uint8 attempts = 10;
+		if (!script_array_dynamic_store_value(st, sd, num, name, script_getref(st, 2), script_getdata(st, 3)))
+			return SCRIPT_CMD_FAILURE;
 
-					do {
-						nx = x + rnd_value(-rx, rx);
-						ny = y + rnd_value(-ry, ry);
-					} while ((--attempts) > 0 && !map_getcell(m, nx, ny, CELL_CHKPASS));
+		if (has_old_ret) {
+			script_data* old_val = get_val(st, &old_ret);
+			if (data_isstring(old_val))
+				script_pushstrcopy(st, conv_str(st, old_val));
+			else
+				script_pushint(st, conv_num64(st, old_val));
+		}
+		else
+			script_pushcopy(st, 2);
 
-					if (attempts == 0) { //Keep the original coordinates if fails to find a valid cell within the range
-						nx = x;
-						ny = y;
-					}
-				}
+		return SCRIPT_CMD_SUCCESS;
+	}
 
-				ret = pc_setpos(pl_sd, mapindex, nx, ny, CLR_TELEPORT);
-			}
-			break;
-		}
+	if (!is_string_variable(name)) {
+		script_data* value = get_val(st, script_getdata(st, 3));
+		script_array_shape_info* shape = script_array_shape_get_by_name(st, sd, name, script_getref(st, 2), script_getvarid(num));
 
-		if( ret != SETPOS_OK ) {
-			ShowError("buildin_warpparty: moving player '%s' to \"%s\",%d,%d failed.\n", pl_sd->status.name, str, x, y);
-			if ( ( type == WARPPARTY_RANDOMALL || type == WARPPARTY_RANDOMALLAREA ) && (rx || ry) )
-				continue;
-			else
-				return SCRIPT_CMD_FAILURE;
+		// Une variable declaree avec `dyn` accepte les valeurs string et int
+		// dans le meme conteneur. Le warning "il manque $" ne doit donc
+		// s'appliquer qu'aux tableaux numeriques classiques, non dynamiques.
+		if ((shape == nullptr || !shape->dynamic) && data_isstring(value) && script_array_slot_has_string_key(shape, script_getvaridx(num))) {
+			ShowWarning("script:set: assigning a string value to numeric array '%s'. Use '%s$' or declare it with dyn before storing strings.\n", name, name);
 		}
 	}
 
+	if( !strcmp(command, "setr") && script_hasdata(st, 4) ) { // Optional argument used by post-increment/post-decrement constructs to return the previous value
+		if( is_string_variable(name) )
+			script_pushstrcopy(st,script_getstr(st, 4));
+		else
+			script_pushint(st,script_getnum64(st, 4));
+	} else // Return a copy of the variable reference
+		script_pushcopy(st, 2);
+
+	if( is_string_variable(name) )
+		set_reg_str( st, sd, num, name, script_getstr( st, 3 ), script_getref( st, 2 ) );
+	else
+		set_reg_num( st, sd, num, name, script_getnum64( st, 3 ), script_getref( st, 2 ) );
+
 	return SCRIPT_CMD_SUCCESS;
 }
 
-/*==========================================
- * Warpguild - [Fredzilla]
- * Syntax: warpguild "mapname",x,y,Guild_ID;
- *------------------------------------------*/
-BUILDIN_FUNC(warpguild)
+/////////////////////////////////////////////////////////////////////
+/// Array variables
+///
+
+/// Declares a temporary variable as dynamic. Dynamic values may be either int or string.
+/// dyn <variable>;
+BUILDIN_FUNC(dyn)
 {
-	TBL_PC *sd = nullptr;
-	TBL_PC *pl_sd;
-	struct s_mapiterator* iter;
-	int32 type, mapindex = 0, m = -1;
+	script_data* data;
+	const char* name;
+	int32 id;
+	uint32 idx;
+	map_session_data* sd = nullptr;
 
-	const char* str = script_getstr(st,2);
-	int32 x           = script_getnum(st,3);
-	int32 y           = script_getnum(st,4);
-	int32 gid         = script_getnum(st,5);
+	if (!script_array_builtin_resolve_ref(st, 2, data, name, id, idx, sd, "dyn"))
+		return SCRIPT_CMD_FAILURE;
 
-	auto g = guild_search(gid);
-	if( g == nullptr )
-		return SCRIPT_CMD_SUCCESS;
+	if (idx != 0) {
+		ShowError("script:dyn: declaration must target the root variable, not an array element.\n");
+		st->state = END;
+		return SCRIPT_CMD_FAILURE;
+	}
 
-	type = ( strcmp(str,"Random")==0 ) ? 0
-	     : ( strcmp(str,"SavePointAll")==0 ) ? 1
-		 : ( strcmp(str,"SavePoint")==0 ) ? 2
-		 : 3;
+	if (!script_array_allows_string_keys(name)) {
+		ShowError("script:dyn: dynamic variables are only supported for temporary variables (.@, @, ., $@, ') for now.\n");
+		st->state = END;
+		return SCRIPT_CMD_FAILURE;
+	}
 
-	if( type == 2 && !script_rid2sd(sd) )
-	{// "SavePoint" uses save point of the currently attached player
+	script_array_shape_info* existing = script_array_shape_get_by_name(st, sd, name, reference_getref(data), id);
+	if (existing != nullptr && existing->dynamic)
 		return SCRIPT_CMD_SUCCESS;
-	}
 
-	switch (type) {
-		case 3:
-			mapindex = mapindex_name2id(str);
-			if (!mapindex)
-				return SCRIPT_CMD_FAILURE;
-			m = map_mapindex2mapid(mapindex);
-			break;
-	}
+	// First dyn declaration on a legacy variable: clear previous 1D legacy
+	// contents, then initialize as an empty dynamic dictionary.
+	script_array_clear_all_members(st, sd, name, reference_getref(data), id);
 
-	iter = mapit_getallusers();
-	for( pl_sd = (TBL_PC*)mapit_first(iter); mapit_exists(iter); pl_sd = (TBL_PC*)mapit_next(iter) )
-	{
-		if( pl_sd->status.guild_id != gid )
-			continue;
+	script_array_shape_info& shape = script_array_shape_ensure_by_name(st, sd, name, reference_getref(data), id);
+	shape.dims.clear();
+	shape.coord_to_slot.clear();
+	shape.slot_to_coord.clear();
+	shape.next_slot = SCRIPT_ARRAY_MD_SLOT_START;
+	shape.dynamic_values.clear();
+	shape.dynamic_empty_dicts.clear();
+	shape.dynamic = true;
+	shape.dynamic_dict = true;
+	return SCRIPT_CMD_SUCCESS;
+}
 
-		switch( type )
-		{
-		case 0: // Random
-			if(!map_getmapflag(pl_sd->m, MF_NOWARP))
-				pc_randomwarp(pl_sd,CLR_TELEPORT);
-		break;
-		case 1: // SavePointAll
-			if(!map_getmapflag(pl_sd->m, MF_NORETURN))
-				pc_setpos( pl_sd, mapindex_name2id( pl_sd->status.save_point.map ), pl_sd->status.save_point.x, pl_sd->status.save_point.y, CLR_TELEPORT );
-		break;
-		case 2: // SavePoint
-			if(!map_getmapflag(pl_sd->m, MF_NORETURN))
-				pc_setpos( pl_sd, mapindex_name2id( sd->status.save_point.map ),sd->status.save_point.x, sd->status.save_point.y, CLR_TELEPORT );
-		break;
-		case 3: // m,x,y
-			if(!map_getmapflag(pl_sd->m, MF_NORETURN) && !map_getmapflag(pl_sd->m, MF_NOWARP) && pc_job_can_entermap((enum e_job)pl_sd->status.class_, m, pc_get_group_level(pl_sd)))
-				pc_setpos(pl_sd,mapindex,x,y,CLR_TELEPORT);
-		break;
-		}
-	}
-	mapit_free(iter);
 
+/// Converts a dynamic variable or branch into a readable dyn literal string.
+/// dyntostring(<dyn variable or branch>) -> <string>
+BUILDIN_FUNC(dyntostring)
+{
+	script_data* data;
+	const char* name;
+	int32 id;
+	uint32 idx;
+	map_session_data* sd = nullptr;
+
+	if (!script_array_builtin_resolve_ref(st, 2, data, name, id, idx, sd, "dyntostring"))
+		return SCRIPT_CMD_FAILURE;
+
+	std::string out;
+	bool truncated = false;
+	if (!script_array_dyn_build_string(st, sd, data, name, id, idx, out, truncated))
+		return SCRIPT_CMD_FAILURE;
+
+	if (truncated)
+		ShowWarning("script:dyntostring: output was truncated.\n");
+
+	script_pushstrcopy(st, out.c_str());
 	return SCRIPT_CMD_SUCCESS;
 }
 
-/*==========================================
- * Force Heal a player (hp and sp)
- *------------------------------------------*/
-BUILDIN_FUNC(heal)
+/// Dumps a dynamic variable or branch to the map-server console.
+/// debugdyn <dyn variable or branch>;
+BUILDIN_FUNC(debugdyn)
 {
-	TBL_PC *sd;
-	int32 hp,sp;
+	script_data* data;
+	const char* name;
+	int32 id;
+	uint32 idx;
+	map_session_data* sd = nullptr;
 
-	if (!script_charid2sd(4,sd))
-		return SCRIPT_CMD_SUCCESS;
+	if (!script_array_builtin_resolve_ref(st, 2, data, name, id, idx, sd, "debugdyn"))
+		return SCRIPT_CMD_FAILURE;
 
-	hp=script_getnum(st,2);
-	sp=script_getnum(st,3);
-	status_heal(sd, hp, sp, 1);
+	std::string out;
+	bool truncated = false;
+	if (!script_array_dyn_build_string(st, sd, data, name, id, idx, out, truncated))
+		return SCRIPT_CMD_FAILURE;
+
+	if (truncated)
+		ShowWarning("script:debugdyn: output was truncated.\n");
+
+	ShowDebug("script dyn : %d %d : %s\n", st->rid, st->oid, out.c_str());
 	return SCRIPT_CMD_SUCCESS;
 }
 
-/*==========================================
- * Force Heal a player (ap)
- *------------------------------------------*/
-BUILDIN_FUNC(healap)
+/// Returns the amount of dimensions known for a multidimensional array.
+/// getarraydims(<array variable>) -> <int>
+BUILDIN_FUNC(getarraydims)
 {
-	map_session_data* sd;
+	script_data* data;
+	const char* name;
+	int32 id;
+	uint32 idx;
+	map_session_data* sd = nullptr;
 
-	if (!script_charid2sd(3, sd))
+	if (!script_array_builtin_resolve_ref(st, 2, data, name, id, idx, sd, "getarraydims"))
 		return SCRIPT_CMD_FAILURE;
 
-	status_heal(sd, 0, 0, script_getnum(st, 2), 1);
+	script_array_shape_info* shape = script_array_shape_get(st, sd, data);
+	script_pushint(st, shape ? (int32)shape->dims.size() : 1);
 	return SCRIPT_CMD_SUCCESS;
 }
 
-/*==========================================
- * Heal a player by item (get vit bonus etc)
- *------------------------------------------*/
-BUILDIN_FUNC(itemheal)
+
+/// Retrieves the immediate child keys under an array or multidimensional prefix.
+/// getarraykeys(<array or prefix>,<out_keys$>{,<out_types>}) -> key count
+/// out_types: 0 = integer key, 1 = string key.
+BUILDIN_FUNC(getarraykeys)
 {
-	TBL_PC *sd;
-	int32 hp,sp;
+	script_data* data;
+	script_data* out_keys;
+	script_data* out_types = nullptr;
+	const char* name;
+	const char* out_keys_name;
+	const char* out_types_name = nullptr;
+	int32 id, out_keys_id, out_types_id = 0;
+	uint32 idx, out_keys_idx, out_types_idx = 0;
+	map_session_data* sd = nullptr;
 
-	hp=script_getnum(st,2);
-	sp=script_getnum(st,3);
+	if (!script_array_builtin_resolve_ref(st, 2, data, name, id, idx, sd, "getarraykeys"))
+		return SCRIPT_CMD_FAILURE;
+	if (!script_array_builtin_resolve_ref(st, 3, out_keys, out_keys_name, out_keys_id, out_keys_idx, sd, "getarraykeys"))
+		return SCRIPT_CMD_FAILURE;
+	if (!is_string_variable(out_keys_name)) {
+		ShowError("script:getarraykeys: output keys array must be a string array.\n");
+		st->state = END;
+		return SCRIPT_CMD_FAILURE;
+	}
 
-	if(potion_flag==1) {
-		potion_hp = hp;
-		potion_sp = sp;
-		return SCRIPT_CMD_SUCCESS;
+	if (script_hasdata(st, 4)) {
+		if (!script_array_builtin_resolve_ref(st, 4, out_types, out_types_name, out_types_id, out_types_idx, sd, "getarraykeys"))
+			return SCRIPT_CMD_FAILURE;
+		if (is_string_variable(out_types_name)) {
+			ShowError("script:getarraykeys: output types array must be numeric.\n");
+			st->state = END;
+			return SCRIPT_CMD_FAILURE;
+		}
 	}
 
-	if (!script_charid2sd(4,sd))
-		return SCRIPT_CMD_SUCCESS;
+	script_array_shape_info* shape = script_array_dynamic_shape_get(st, sd, reference_uid(id, 0), name, reference_getref(data));
+	if (shape == nullptr || !shape->dynamic) {
+		ShowError("script:getarraykeys: variable '%s' is not dynamic.\n", name);
+		st->state = END;
+		return SCRIPT_CMD_FAILURE;
+	}
+	if (idx == 0 && !shape->dynamic_dict) {
+		ShowError("script:getarraykeys: dynamic variable '%s' is scalar, not a dictionary.\n", name);
+		st->state = END;
+		return SCRIPT_CMD_FAILURE;
+	}
 
-	pc_itemheal(sd,sd->itemid,hp,sp);
+	std::vector<script_array_key> prefix;
+	if (idx != 0) {
+		auto prefix_it = shape->slot_to_coord.find(idx);
+		if (prefix_it != shape->slot_to_coord.end()) {
+			prefix = prefix_it->second;
+		} else {
+			// Reference 1D native utilisee comme prefixe, par exemple getarraykeys(.@a[2]).
+			script_array_key native_key;
+			native_key.is_string = false;
+			native_key.num = idx;
+			prefix.push_back(native_key);
+ 		}
+	}
+
+	if (!prefix.empty() && script_array_count_child_keys(st, sd, name, reference_getref(data), id, shape, prefix) == 0 && shape->dynamic_empty_dicts.find(idx) == shape->dynamic_empty_dicts.end()) {
+		ShowError("script:getarraykeys: dynamic branch '%s' is scalar, not a dictionary.\n", name);
+		st->state = END;
+		return SCRIPT_CMD_FAILURE;
+	}
+
+	std::vector<script_array_key> keys;
+	for (const auto& entry : shape->coord_to_slot) {
+		const std::vector<script_array_key>& coords = entry.first;
+		if (coords.size() <= prefix.size())
+			continue;
+
+		bool matches = true;
+		for (size_t i = 0; i < prefix.size(); ++i) {
+			if (!(coords[i] == prefix[i])) {
+				matches = false;
+				break;
+			}
+		}
+		if (!matches)
+			continue;
+
+		const script_array_key& child = coords[prefix.size()];
+		std::vector<script_array_key> child_prefix = prefix;
+		child_prefix.push_back(child);
+		if (!script_array_coord_has_live_subtree(st, sd, name, reference_getref(data), id, shape, child_prefix))
+			continue;
+		bool exists = false;
+		for (const script_array_key& key : keys) {
+			if (key == child) {
+				exists = true;
+				break;
+			}
+		}
+		if (!exists)
+			keys.push_back(child);
+	}
+
+	for (size_t i = 0; i < keys.size(); ++i) {
+		if (keys[i].is_string) {
+			set_reg_str(st, sd, reference_uid(out_keys_id, out_keys_idx + (uint32)i), out_keys_name, keys[i].str.c_str(), reference_getref(out_keys));
+		}
+		else {
+			char buf[32];
+			snprintf(buf, sizeof(buf), "%" PRIu64, keys[i].num);
+			set_reg_str(st, sd, reference_uid(out_keys_id, out_keys_idx + (uint32)i), out_keys_name, buf, reference_getref(out_keys));
+		}
+
+		if (out_types != nullptr)
+			set_reg_num(st, sd, reference_uid(out_types_id, out_types_idx + (uint32)i), out_types_name, keys[i].is_string ? 1 : 0, reference_getref(out_types));
+	}
+
+	script_pushint(st, (int32)keys.size());
 	return SCRIPT_CMD_SUCCESS;
 }
 
-/*==========================================
- *
- *------------------------------------------*/
-BUILDIN_FUNC(percentheal)
+/// Deletes a dynamic dictionary branch or clears a dynamic dictionary root.
+/// del <dyn variable or branch>;
+BUILDIN_FUNC(del)
 {
-	int32 hp,sp;
-	TBL_PC* sd;
+	script_data* data;
+	const char* name;
+	int32 id;
+	uint32 idx;
+	map_session_data* sd = nullptr;
 
-	hp=script_getnum(st,2);
-	sp=script_getnum(st,3);
+	if (!script_array_builtin_resolve_ref(st, 2, data, name, id, idx, sd, "del"))
+		return SCRIPT_CMD_FAILURE;
 
-	if(potion_flag==1) {
-		potion_per_hp = hp;
-		potion_per_sp = sp;
-		return SCRIPT_CMD_SUCCESS;
+	script_array_shape_info* shape = script_array_dynamic_shape_get(st, sd, reference_uid(id, 0), name, reference_getref(data));
+	if (shape == nullptr || !shape->dynamic) {
+		ShowError("script:del: variable '%s' is not dynamic.\n", name);
+		st->state = END;
+		return SCRIPT_CMD_FAILURE;
 	}
 
-	if (!script_charid2sd(4,sd))
+	if (idx == 0) {
+		shape->dynamic = false;
+		shape->dynamic_dict = false;
+		shape->dynamic_values.clear();
+		shape->dynamic_empty_dicts.clear();
+		shape->coord_to_slot.clear();
+		shape->slot_to_coord.clear();
+		shape->dims.clear();
+		shape->next_slot = SCRIPT_ARRAY_MD_SLOT_START;
 		return SCRIPT_CMD_SUCCESS;
+	}
 
-#ifdef RENEWAL
-	if( sd->sc.getSCE(SC_EXTREMITYFIST) )
-		sp = 0;
-#endif
+	auto coord_it = shape->slot_to_coord.find(idx);
+	if (coord_it == shape->slot_to_coord.end())
+		return SCRIPT_CMD_SUCCESS; // deleting a missing key is a no-op
 
-	if (sd->sc.getSCE(SC_NORECOVER_STATE)) {
-		hp = 0;
-		sp = 0;
+	std::vector<script_array_key> prefix = coord_it->second;
+	std::vector<uint32> slots_to_delete;
+	slots_to_delete.push_back(idx);
+
+	for (const auto& entry : shape->coord_to_slot) {
+		if (entry.second != idx && entry.first.size() > prefix.size() && script_array_coord_starts_with(entry.first, prefix))
+			slots_to_delete.push_back(entry.second);
 	}
 
-	if (sd->sc.getSCE(SC_BITESCAR))
-		hp = 0;
+	for (uint32 slot : slots_to_delete) {
+		shape->dynamic_values.erase(slot);
+		shape->dynamic_empty_dicts.erase(slot);
+
+		auto old = shape->slot_to_coord.find(slot);
+		if (old != shape->slot_to_coord.end()) {
+			shape->coord_to_slot.erase(old->second);
+			shape->slot_to_coord.erase(old);
+		}
+	}
 
-	pc_percentheal(sd,hp,sp);
 	return SCRIPT_CMD_SUCCESS;
 }
 
-/*==========================================
- *
- *------------------------------------------*/
-BUILDIN_FUNC(jobchange)
+/// Returns the type of a dynamic variable or branch.
+/// getdyntype(<variable or branch>) -> 0 not dynamic/dictionary, 1 dynamic dictionary
+BUILDIN_FUNC(getdyntype)
 {
-	int32 job, upper=-1;
-
-	job=script_getnum(st,2);
-	if( script_hasdata(st,3) )
-		upper=script_getnum(st,3);
+	script_data* data;
+	const char* name;
+	int32 id;
+	uint32 idx;
+	map_session_data* sd = nullptr;
 
-	if (pcdb_checkid(job))
-	{
-		TBL_PC* sd;
+	if (!script_array_builtin_resolve_ref(st, 2, data, name, id, idx, sd, "getdyntype"))
+		return SCRIPT_CMD_FAILURE;
 
-		if (!script_charid2sd(4,sd))
-			return SCRIPT_CMD_SUCCESS;
+	script_array_shape_info* shape = script_array_dynamic_shape_get(st, sd, reference_uid(id, 0), name, reference_getref(data));
+	if (shape == nullptr || !shape->dynamic) {
+		script_pushint(st, 0);
+		return SCRIPT_CMD_SUCCESS;
+	}
 
-		pc_jobchange(sd, job, upper);
+	if (idx == 0) {
+		script_pushint(st, 1);
+		return SCRIPT_CMD_SUCCESS;
 	}
 
-	return SCRIPT_CMD_SUCCESS;
-}
+	auto coord_it = shape->slot_to_coord.find(idx);
+	if (coord_it == shape->slot_to_coord.end()) {
+		script_pushint(st, 0);
+		return SCRIPT_CMD_SUCCESS;
+	}
 
-/*==========================================
- *
- *------------------------------------------*/
-BUILDIN_FUNC(jobname)
-{
-	int32 class_=script_getnum(st,2);
-	script_pushconststr(st, (char*)job_name(class_));
+	if (shape->dynamic_empty_dicts.find(idx) != shape->dynamic_empty_dicts.end() ||
+		script_array_count_child_keys(st, sd, name, reference_getref(data), id, shape, coord_it->second) > 0) {
+		script_pushint(st, 1);
+		return SCRIPT_CMD_SUCCESS;
+	}
+
+	script_pushint(st, 0);
 	return SCRIPT_CMD_SUCCESS;
 }
 
-/// Get input from the player.
-/// For numeric inputs the value is capped to the range [min,max]. Returns 1 if
-/// the value was higher than 'max', -1 if lower than 'min' and 0 otherwise.
-/// For string inputs it returns 1 if the string was longer than 'max', -1 is
-/// shorter than 'min' and 0 otherwise.
-///
-/// input(<var>{,<min>{,<max>}}) -> <int>
-BUILDIN_FUNC(input)
+/// Returns the amount of direct child keys in a dynamic dictionary.
+/// getarraysizedyn(<dyn dictionary or branch>) -> <int>
+BUILDIN_FUNC(getarraysizedyn)
 {
-	TBL_PC* sd;
-	struct script_data* data;
-	int64 uid;
+	script_data* data;
 	const char* name;
-	int32 min;
-	int32 max;
+	int32 id;
+	uint32 idx;
+	map_session_data* sd = nullptr;
 
-	if( !script_rid2sd(sd) )
-		return SCRIPT_CMD_SUCCESS;
+	if (!script_array_builtin_resolve_ref(st, 2, data, name, id, idx, sd, "getarraysizedyn"))
+		return SCRIPT_CMD_FAILURE;
 
-	data = script_getdata(st,2);
-	if( !data_isreference(data) ){
-		ShowError("script:input: not a variable\n");
-		script_reportdata(data);
+	script_array_shape_info* shape = script_array_dynamic_shape_get(st, sd, reference_uid(id, 0), name, reference_getref(data));
+	if (shape == nullptr || !shape->dynamic) {
+		ShowError("script:getarraysizedyn: variable '%s' is not dynamic.\n", name);
 		st->state = END;
 		return SCRIPT_CMD_FAILURE;
 	}
-	uid = reference_getuid(data);
-	name = reference_getname(data);
-	min = (script_hasdata(st,3) ? script_getnum(st,3) : script_config.input_min_value);
-	max = (script_hasdata(st,4) ? script_getnum(st,4) : script_config.input_max_value);
-
-#ifdef SECURE_NPCTIMEOUT
-	sd->npc_idle_type = NPCT_WAIT;
-#endif
 
-	if( !sd->state.menu_or_input )
-	{	// first invocation, display npc input box
-		sd->state.menu_or_input = 1;
-		st->state = RERUNLINE;
-		if( is_string_variable(name) )
-			clif_scriptinputstr( *sd, st->oid );
-		else
-			clif_scriptinput( *sd, st->oid );
-	}
-	else
-	{	// take received text/value and store it in the designated variable
-		sd->state.menu_or_input = 0;
-		if( is_string_variable(name) )
-		{
-			int32 len = (int32)strlen(sd->npc_str);
-			set_reg_str(st, sd, uid, name, sd->npc_str, script_getref(st,2));
-			script_pushint(st, (len > max ? 1 : len < min ? -1 : 0));
+	std::vector<script_array_key> prefix;
+	if (idx == 0) {
+		// A dynamic root is always a dictionary in the strict dyn model.
+	} else {
+		auto prefix_it = shape->slot_to_coord.find(idx);
+		if (prefix_it == shape->slot_to_coord.end()) {
+			ShowError("script:getarraysizedyn: invalid dynamic reference for '%s'.\n", name);
+			st->state = END;
+			return SCRIPT_CMD_FAILURE;
 		}
-		else
-		{
-			int32 amount = sd->npc_amount;
-			set_reg_num(st, sd, uid, name, cap_value(amount,min,max), script_getref(st,2));
-			script_pushint(st, (amount > max ? 1 : amount < min ? -1 : 0));
+		prefix = prefix_it->second;
+		if (script_array_count_child_keys(st, sd, name, reference_getref(data), id, shape, prefix) == 0 && shape->dynamic_empty_dicts.find(idx) == shape->dynamic_empty_dicts.end()) {
+			ShowError("script:getarraysizedyn: dynamic branch '%s' is scalar, not a dictionary.\n", name);
+			st->state = END;
+			return SCRIPT_CMD_FAILURE;
 		}
-		st->state = RUN;
 	}
+
+	script_pushint(st, script_array_count_child_keys(st, sd, name, reference_getref(data), id, shape, prefix));
 	return SCRIPT_CMD_SUCCESS;
 }
 
-// declare the copyarray method here for future reference
-BUILDIN_FUNC(copyarray);
-
-/// Sets the value of a variable.
-/// The value is converted to the type of the variable.
-///
-/// set(<variable>,<value>{,<charid>})
-BUILDIN_FUNC(setr)
+/// Sets values under a dynamic dictionary branch, from a numeric child key.
+/// setarraydyn <dyn variable or branch>,<value>{,<value>...};
+BUILDIN_FUNC(setarraydyn)
 {
-	TBL_PC* sd = nullptr;
-	struct script_data* data;
-	//struct script_data* datavalue;
-	int64 num;
-	uint8 pos = 4;
-	const char* name, *command = script_getfuncname(st);
-	char prefix;
+	script_data* data;
+	const char* name;
+	int32 id;
+	uint32 start;
+	map_session_data* sd = nullptr;
 
-	data = script_getdata(st,2);
-	//datavalue = script_getdata(st,3);
-	if( !data_isreference(data) )
-	{
-		ShowError("script:set: not a variable\n");
-		script_reportdata(script_getdata(st,2));
+	if (!script_array_builtin_resolve_ref(st, 2, data, name, id, start, sd, "setarraydyn"))
+		return SCRIPT_CMD_FAILURE;
+
+	if (!script_array_allows_string_keys(name)) {
+		ShowError("script:setarraydyn: dynamic variables are only supported for temporary variables (.@, @, ., $@, ') for now.\n");
 		st->state = END;
 		return SCRIPT_CMD_FAILURE;
 	}
 
-	num = reference_getuid(data);
-	name = reference_getname(data);
-	prefix = *name;
-
-	if (!strcmp(command, "setr"))
-		pos = 5;
-
-	if (not_server_variable(prefix) && !script_charid2sd(pos,sd)) {
-		ShowError("buildin_set: No player attached for player variable '%s'\n", name);
-		return SCRIPT_CMD_FAILURE;
+	script_array_shape_info& shape = script_array_shape_ensure_by_name(st, sd, name, reference_getref(data), id);
+	if (!shape.dynamic) {
+		script_array_clear_all_members(st, sd, name, reference_getref(data), id);
+		shape.dims.clear();
+		shape.coord_to_slot.clear();
+		shape.slot_to_coord.clear();
+		shape.next_slot = SCRIPT_ARRAY_MD_SLOT_START;
+		shape.dynamic_values.clear();
+		shape.dynamic_empty_dicts.clear();
+		shape.dynamic = true;
+		shape.dynamic_dict = true;
+	}
+
+	std::vector<script_array_key> prefix;
+	uint64 dyn_start = 0;
+	bool has_values = script_lastdata(st) >= 3;
+	if (start != 0) {
+		auto prefix_it = shape.slot_to_coord.find(start);
+		if (prefix_it != shape.slot_to_coord.end()) {
+			prefix = prefix_it->second;
+			if (has_values && !prefix.empty() && !prefix.back().is_string) {
+				dyn_start = prefix.back().num;
+				prefix.pop_back();
+			}
+		} else {
+			ShowError("script:setarraydyn: invalid dynamic reference for '%s'.\n", name);
+			st->state = END;
+			return SCRIPT_CMD_FAILURE;
+		}
 	}
 
-#if 0
-	if( data_isreference(datavalue) )
-	{// the value being referenced is a variable
-		const char* namevalue = reference_getname(datavalue);
+	if (!has_values) {
+		// Empty dynamic table assignment. This is used by dyn literals such as:
+		//   dyn .@a = [];
+		//   dyn .@a = [ "empty": [] ];
+		if (start == 0) {
+			shape.dynamic_dict = true;
+			shape.dynamic_values.clear();
+			shape.dynamic_empty_dicts.clear();
+			shape.coord_to_slot.clear();
+			shape.slot_to_coord.clear();
+			shape.dims.clear();
+			shape.next_slot = SCRIPT_ARRAY_MD_SLOT_START;
+			return SCRIPT_CMD_SUCCESS;
+		}
 
-		if( !not_array_variable(*namevalue) )
-		{// array variable being copied into another array variable
-			if( sd == nullptr && not_server_variable(*namevalue) && !(sd = script_rid2sd(st)) )
-			{// player must be attached in order to copy a player variable
-				ShowError("script:set: no player attached for player variable '%s'\n", namevalue);
-				return SCRIPT_CMD_SUCCESS;
-			}
+		shape.dynamic_dict = true;
+		shape.dynamic_values.erase(0);
+		shape.dynamic_empty_dicts.erase(0);
 
-			if( is_string_variable(namevalue) != is_string_variable(name) )
-			{// non-matching array value types
-				ShowWarning("script:set: two array variables do not match in type.\n");
-				return SCRIPT_CMD_SUCCESS;
-			}
+		std::vector<uint32> slots_to_delete;
+		for (size_t len = 1; len < prefix.size(); ++len) {
+			std::vector<script_array_key> parent(prefix.begin(), prefix.begin() + len);
+			auto parent_it = shape.coord_to_slot.find(parent);
+			if (parent_it != shape.coord_to_slot.end())
+				shape.dynamic_values.erase(parent_it->second);
+		}
 
-			// push the maximum number of array values to the stack
-			push_val(st->stack, C_INT, SCRIPT_MAX_ARRAYSIZE);
+		for (const auto& entry : shape.coord_to_slot) {
+			if (entry.first.size() > prefix.size() && script_array_coord_starts_with(entry.first, prefix))
+				slots_to_delete.push_back(entry.second);
+		}
 
-			// call the copy array method directly
-			return buildin_copyarray(st);
+		shape.dynamic_values.erase(start);
+		shape.dynamic_empty_dicts.erase(start);
+		for (uint32 delete_slot : slots_to_delete) {
+			shape.dynamic_values.erase(delete_slot);
+			shape.dynamic_empty_dicts.erase(delete_slot);
+			auto old = shape.slot_to_coord.find(delete_slot);
+			if (old != shape.slot_to_coord.end()) {
+				shape.coord_to_slot.erase(old->second);
+				shape.slot_to_coord.erase(old);
+			}
 		}
+
+		shape.dynamic_empty_dicts.insert(start);
+		return SCRIPT_CMD_SUCCESS;
 	}
-#endif
 
-	if( !strcmp(command, "setr") && script_hasdata(st, 4) ) { // Optional argument used by post-increment/post-decrement constructs to return the previous value
-		if( is_string_variable(name) )
-			script_pushstrcopy(st,script_getstr(st, 4));
-		else
-			script_pushint(st,script_getnum64(st, 4));
-	} else // Return a copy of the variable reference
-		script_pushcopy(st, 2);
+	for (int32 i = 3; i <= script_lastdata(st); ++i) {
+		std::vector<script_array_key> coords = prefix;
+		script_array_key key;
+		key.is_string = false;
+		key.num = dyn_start + (uint64)(i - 3);
+		coords.push_back(key);
 
-	if( is_string_variable(name) )
-		set_reg_str( st, sd, num, name, script_getstr( st, 3 ), script_getref( st, 2 ) );
-	else
-		set_reg_num( st, sd, num, name, script_getnum64( st, 3 ), script_getref( st, 2 ) );
+		uint32 slot;
+		if (!script_array_resolve_hash_auto(st, sd, data, name, id, coords, slot, "setarraydyn"))
+			return SCRIPT_CMD_FAILURE;
+
+		if (!script_array_dynamic_store_value(st, sd, reference_uid(id, slot), name, reference_getref(data), script_getdata(st, i)))
+			return SCRIPT_CMD_FAILURE;
+	}
 
 	return SCRIPT_CMD_SUCCESS;
 }
 
-/////////////////////////////////////////////////////////////////////
-/// Array variables
-///
-
 /// Sets values of an array, from the starting index.
 /// ex: setarray arr[1],1,2,3;
 ///
@@ -6311,6 +8713,64 @@ BUILDIN_FUNC(setarray)
 			return SCRIPT_CMD_SUCCESS;// no player attached
 	}
 
+	if (script_array_is_dynamic_ref(st, sd, reference_uid(id, 0), name, reference_getref(data))) {
+		ShowError("script:setarray: dynamic variables require setarraydyn.\n");
+		st->state = END;
+		return SCRIPT_CMD_FAILURE;
+	}
+
+	script_array_shape_info* shape = script_array_shape_get(st, sd, data);
+	if (shape != nullptr && script_array_dynamic_reference_is_child(shape, start)) {
+		ShowError("script:setarray: multidimensional/string-key array access requires setarraydyn and a dyn variable.\n");
+		st->state = END;
+		return SCRIPT_CMD_FAILURE;
+	}
+
+	if (false) {
+		std::vector<script_array_key> base;
+		uint64 start_index = 0;
+
+		if (start != 0) {
+			auto it = shape->slot_to_coord.find(start);
+			if (it != shape->slot_to_coord.end())
+				base = it->second;
+		}
+
+		// setarray .@a["truc"], "a", "b" writes .@a["truc"][0..1].
+		// setarray .@a["truc"][5], "a", "b" writes .@a["truc"][5..6].
+		if (!base.empty() && !base.back().is_string) {
+			start_index = base.back().num;
+			base.pop_back();
+		}
+
+		for (i = 3; i <= script_lastdata(st); ++i) {
+			uint64 offset = (uint64)(i - 3);
+			if (UINT64_MAX - start_index < offset) {
+				ShowWarning("script:setarray: multidimensional array index is too large.\n");
+				break;
+			}
+
+			std::vector<script_array_key> coords = base;
+			script_array_key key;
+			key.is_string = false;
+			key.num = start_index + offset;
+			coords.push_back(key);
+
+			uint32 slot;
+			if (!script_array_resolve_hash_auto(st, sd, data, name, id, coords, slot, "setarray")) {
+				st->state = END;
+				return SCRIPT_CMD_FAILURE;
+			}
+
+			if (is_string_variable(name))
+				set_reg_str(st, sd, reference_uid(id, slot), name, script_getstr(st, i), reference_getref(data));
+			else
+				set_reg_num(st, sd, reference_uid(id, slot), name, script_getnum64(st, i), reference_getref(data));
+		}
+
+		return SCRIPT_CMD_SUCCESS;
+	}
+
 	end = start + script_lastdata(st) - 2;
 	if( end > SCRIPT_MAX_ARRAYSIZE )
 		end = SCRIPT_MAX_ARRAYSIZE;
@@ -6360,6 +8820,12 @@ BUILDIN_FUNC(cleararray)
 			return SCRIPT_CMD_SUCCESS;// no player attached
 	}
 
+	if (script_array_is_dynamic_ref(st, sd, reference_uid(id, 0), name, reference_getref(data))) {
+		ShowError("script:cleararray: dynamic variables are not supported by cleararray.\n");
+		st->state = END;
+		return SCRIPT_CMD_FAILURE;
+	}
+
 	end = start + script_getnum(st, 4);
 	if( end > SCRIPT_MAX_ARRAYSIZE )
 		end = SCRIPT_MAX_ARRAYSIZE;
@@ -6433,6 +8899,12 @@ BUILDIN_FUNC(copyarray)
 			return SCRIPT_CMD_SUCCESS;// no player attached
 	}
 
+	if (script_array_is_dynamic_ref(st, sd, reference_uid(id1, 0), name1, reference_getref(data1)) || script_array_is_dynamic_ref(st, sd, reference_uid(id2, 0), name2, reference_getref(data2))) {
+		ShowError("script:copyarray: dynamic variables are not supported by copyarray.\n");
+		st->state = END;
+		return SCRIPT_CMD_FAILURE;
+	}
+
 	count = script_getnum(st, 4);
 	if( count > SCRIPT_MAX_ARRAYSIZE - idx1 )
 		count = SCRIPT_MAX_ARRAYSIZE - idx1;
@@ -6483,26 +8955,80 @@ BUILDIN_FUNC(getarraysize)
 {
 	struct script_data* data;
 	const char* name;
+	int32 id;
+	uint32 idx;
 	map_session_data* sd = nullptr;
 
-	data = script_getdata(st, 2);
-	if( !data_isreference(data) )
-	{
-		ShowError("script:getarraysize: not a variable\n");
-		script_reportdata(data);
+	if (!script_array_builtin_resolve_ref(st, 2, data, name, id, idx, sd, "getarraysize")) {
+		// ShowError("script:getarraysize: not a variable\n");
+		// script_reportdata(data);
 		script_pushnil(st);
 		st->state = END;
 		return SCRIPT_CMD_FAILURE;// not a variable
 	}
 
-	name = reference_getname(data);
+	script_array_shape_info* dyn_shape = script_array_dynamic_shape_get(st, sd, reference_uid(id, 0), name, reference_getref(data));
+	if (dyn_shape != nullptr && dyn_shape->dynamic) {
+		ShowError("script:getarraysize: dynamic variables require getarraysizedyn.\n");
+		st->state = END;
+		return SCRIPT_CMD_FAILURE;
+	}
 
-	if( not_server_variable(*name) ){
-		if (!script_rid2sd(sd))
-			return SCRIPT_CMD_SUCCESS;// no player attached
+	std::vector<script_array_key> prefix;
+	script_array_shape_info* shape = script_array_shape_get(st, sd, data);
+
+	if (idx != 0) {
+		if (shape != nullptr) {
+			auto prefix_it = shape->slot_to_coord.find(idx);
+			if (prefix_it != shape->slot_to_coord.end()) {
+				prefix = prefix_it->second;
+			} else {
+				// Reference 1D native utilisee comme prefixe, par ex. getarraysize(.@a[2])
+				// apres .@a[2][101] = 7.
+				script_array_key native_key;
+				native_key.is_string = false;
+				native_key.num = idx;
+				prefix.push_back(native_key);
+			}
+		} else {
+			script_array_key native_key;
+			native_key.is_string = false;
+			native_key.num = idx;
+			prefix.push_back(native_key);
+		}
+	}
+
+	if (script_hasdata(st, 3)) {
+		std::vector<script_array_key> extra;
+		if (!script_array_collect_keys(st, 3, script_lastdata(st), name, extra, "getarraysize")) {
+			script_pushint(st, 0);
+			return SCRIPT_CMD_SUCCESS;
+		}
+		prefix.insert(prefix.end(), extra.begin(), extra.end());
 	}
 
-	script_pushint(st, script_array_highest_key(st, sd, reference_getname(data), reference_getref(data)));
+	if (shape != nullptr) {
+		uint32 count = script_array_count_child_keys(st, sd, name, reference_getref(data), id, shape, prefix);
+
+		if (prefix.empty()) {
+			if (!shape->dynamic)
+				count += script_array_native_member_count(st, sd, name, reference_getref(data), id, shape);
+			// var et var[0] sont identiques en rAthena legacy. Le slot 0 peut
+			// contenir une valeur sans apparaitre dans script_array.members, donc
+			// on l'ajoute explicitement si elle est non-defaut et pas deja comptee.
+			if (!script_array_member_exists(st, sd, name, reference_getref(data), id, 0) && script_array_root_value_nondefault(st, sd, name, reference_getref(data), id))
+				count++;
+		}
+		script_pushint(st, count);
+	}
+	else {
+		uint32 count = prefix.empty() ? script_array_member_count(st, sd, name, reference_getref(data), id) : 0;
+		if (prefix.empty() && !script_array_member_exists(st, sd, name, reference_getref(data), id, 0) && script_array_root_value_nondefault(st, sd, name, reference_getref(data), id))
+			count++;
+		script_pushint(st, count);
+	}
+
+
 	return SCRIPT_CMD_SUCCESS;
 }
 
@@ -6542,6 +9068,12 @@ BUILDIN_FUNC(deletearray)
 			return SCRIPT_CMD_SUCCESS;// no player attached
 	}
 
+	if (script_array_is_dynamic_ref(st, sd, reference_uid(id, 0), name, reference_getref(data))) {
+		ShowError("script:deletearray: dynamic variables are not supported by deletearray.\n");
+		st->state = END;
+		return SCRIPT_CMD_FAILURE;
+	}
+
 	if (!(src = script_array_src(st, sd, name, reference_getref(data)))) {
 		ShowError("script:deletearray: not a array\n");
 		script_reportdata(data);
@@ -6638,31 +9170,85 @@ BUILDIN_FUNC(deletearray)
 BUILDIN_FUNC(getelementofarray)
 {
 	struct script_data* data;
+	const char* name;
 	int32 id;
-	int64 i;
+	uint32 idx;
+	map_session_data* sd = nullptr;
 
-	data = script_getdata(st, 2);
-	if( !data_isreference(data) )
-	{
-		ShowError("script:getelementofarray: not a variable\n");
-		script_reportdata(data);
+	if (!script_array_builtin_resolve_ref(st, 2, data, name, id, idx, sd, "getelementofarray")) {
+		// ShowError("script:getelementofarray: not a variable\n");
+		// script_reportdata(data);
 		script_pushnil(st);
 		st->state = END;
-		return SCRIPT_CMD_SUCCESS;// not a variable
+		// return SCRIPT_CMD_SUCCESS;
+		return SCRIPT_CMD_FAILURE;
 	}
 
-	id = reference_getid(data);
+	std::vector<script_array_key> indices;
+	if (!script_array_collect_keys(st, 3, script_lastdata(st), name, indices, "getelementofarray")) {
+		script_pushnil(st);
+		st->state = END;
+		return SCRIPT_CMD_FAILURE;
+	}
 
-	i = script_getnum(st, 3);
-	if (i < 0 || i >= SCRIPT_MAX_ARRAYSIZE) {
-		ShowWarning("script:getelementofarray: index out of range (%" PRId64 ")\n", i);
-		script_reportdata(data);
+	/*
+	 * Important : le parseur peut produire des appels imbriques a getelementofarray
+	 * pour une expression comme .@a[2][101] :
+	 *
+	 *   getelementofarray( getelementofarray(.@a, 2), 101 )
+	 *
+	 * Dans ce cas, l'argument <array variable> recu ici n'est plus la racine .@a,
+	 * mais une reference partielle .@a[2]. Il faut donc reconstruire le prefixe
+	 * deja contenu dans idx avant d'ajouter les nouveaux indices. Sans cela, le
+	 * second appel resout seulement [101], ce qui lit/ecrit une autre cellule et
+	 * donne des symptomes comme .@a[2][101] qui vaut 0 apres l'assignation.
+	 */
+	if (idx != 0) {
+		script_array_shape_info* shape = script_array_shape_get(st, sd, data);
+		std::vector<script_array_key> prefix;
+
+		if (shape != nullptr) {
+			auto prefix_it = shape->slot_to_coord.find(idx);
+			if (prefix_it != shape->slot_to_coord.end())
+				prefix = prefix_it->second;
+		}
+
+		if (prefix.empty()) {
+			// Reference 1D native, par exemple le premier appel .@a[2].
+			script_array_key native_key;
+			native_key.is_string = false;
+			native_key.num = idx;
+			prefix.push_back(native_key);
+		}
+
+		prefix.insert(prefix.end(), indices.begin(), indices.end());
+		indices.swap(prefix);
+	}
+
+	// Compatibilite rAthena : un seul index numerique depuis la racine reste un
+	// tableau 1D natif. Les references partielles reconstruites ci-dessus ont au
+	// moins deux cles et passent donc par le stockage multidimensionnel.
+	if (indices.size() == 1 && !indices[0].is_string && !script_array_is_dynamic_ref(st, sd, reference_uid(id, 0), name, reference_getref(data))) {
+		if (indices[0].num >= SCRIPT_MAX_ARRAYSIZE) {
+			ShowWarning("script:getelementofarray: array index out of range (%" PRIu64 ").\n", indices[0].num);
+			script_pushnil(st);
+			st->state = END;
+			return SCRIPT_CMD_FAILURE;
+		}
+
+		push_val2(st->stack, C_NAME, reference_uid(id, (uint32)indices[0].num), reference_getref(data));
+		return SCRIPT_CMD_SUCCESS;
+	}
+
+	uint32 linear = 0;
+
+	if (!script_array_resolve_hash_auto(st, sd, data, name, id, indices, linear, "getelementofarray")) {
 		script_pushnil(st);
 		st->state = END;
 		return SCRIPT_CMD_FAILURE;// out of range
 	}
 
-	push_val2(st->stack, C_NAME, reference_uid(id, i), reference_getref(data));
+	push_val2(st->stack, C_NAME, reference_uid(id, linear), reference_getref(data));
 	return SCRIPT_CMD_SUCCESS;
 }
 
@@ -6690,6 +9276,12 @@ BUILDIN_FUNC(inarray)
 	name = reference_getname(data);
 	ref = reference_getref(data);
 
+	if (script_array_is_dynamic_ref(st, sd, reference_uid(reference_getid(data), 0), name, ref)) {
+		ShowError("buildin_inarray: dynamic variables are not supported by inarray; use getarraykeys and explicit loops.\n");
+		st->state = END;
+		return SCRIPT_CMD_FAILURE;
+	}
+
 	if (not_server_variable(*name) && !script_rid2sd(sd))
 		return SCRIPT_CMD_FAILURE;
 
@@ -6776,6 +9368,13 @@ BUILDIN_FUNC(countinarray)
 	if (not_server_variable(*name1) && not_server_variable(*name2) && !script_rid2sd(sd))
 		return SCRIPT_CMD_FAILURE;
 
+	if (script_array_is_dynamic_ref(st, sd, reference_uid(reference_getid(data1), 0), name1, ref1) ||
+	    script_array_is_dynamic_ref(st, sd, reference_uid(reference_getid(data2), 0), name2, ref2)) {
+		ShowError("buildin_countinarray: dynamic variables are not supported by countinarray; use getarraykeys and explicit loops.\n");
+		st->state = END;
+		return SCRIPT_CMD_FAILURE;
+	}
+
 	const uint32 array_size1 = script_array_highest_key(st, sd, name1, ref1);
 	const uint32 array_size2 = script_array_highest_key(st, sd, name2, ref2);
 
@@ -27859,7 +30458,7 @@ BUILDIN_FUNC(mesemotion){
 	// Validates emotion range
 	if (id < ET_SURPRISE || id >= ET_MAX) {
 		ShowError("buildin_mesemotion: Emotion ID %d is invalid.\n", id);
-		st->state = END;
+		st->state = END;
 		return SCRIPT_CMD_FAILURE;
 	}
 
@@ -27940,7 +30539,7 @@ struct script_function buildin_func[] = {
 	BUILDIN_DEF(goto,"l"),
 	BUILDIN_DEF(callsub,"l*"),
 	BUILDIN_DEF(callfunc,"s*"),
-	BUILDIN_DEF(return,"?"),
+	BUILDIN_DEF(return,"*"),
 	BUILDIN_DEF(getarg,"i?"),
 	BUILDIN_DEF(jobchange,"i??"),
 	BUILDIN_DEF(jobname,"i"),
@@ -27957,9 +30556,9 @@ struct script_function buildin_func[] = {
 	BUILDIN_DEF(setarray,"rv*"),
 	BUILDIN_DEF(cleararray,"rvi"),
 	BUILDIN_DEF(copyarray,"rri"),
-	BUILDIN_DEF(getarraysize,"r"),
+	BUILDIN_DEF(getarraysize,"r*"),
 	BUILDIN_DEF(deletearray,"r?"),
-	BUILDIN_DEF(getelementofarray,"ri"),
+	BUILDIN_DEF(getelementofarray,"r*"),
 	BUILDIN_DEF(inarray,"rv"),
 	BUILDIN_DEF(countinarray,"rr"),
 	BUILDIN_DEF(getitem,"vi?"),
@@ -28654,6 +31253,19 @@ struct script_function buildin_func[] = {
 	BUILDIN_DEF(meshyperlink, "ss"),
 	BUILDIN_DEF(mesemotion,"i"),
 
+	BUILDIN_DEF(getarraydims,"r"),
+	BUILDIN_DEF(getarraysizedyn,"r"),
+	BUILDIN_DEF(getarraykeys,"rr?"),
+	BUILDIN_DEF(dyn,"r"),
+	BUILDIN_DEF(dyntostring,"r"),
+	BUILDIN_DEF(debugdyn,"r"),
+	BUILDIN_DEF(getdyntype,"r"),
+	BUILDIN_DEF(del,"r"),
+	BUILDIN_DEF(setarraydyn,"rv*"),
+	BUILDIN_DEF(getreturn,"i"),
+	BUILDIN_DEF(getreturncount,""),
+	BUILDIN_DEF(callnpcsub,"ss*"),
+
 #include <custom/script_def.inc>
 
 	{nullptr,nullptr,nullptr},
diff --git a/src/map/script.hpp b/src/map/script.hpp
index 307470373e6..664477f6b10 100644
--- a/src/map/script.hpp
+++ b/src/map/script.hpp
@@ -132,6 +132,8 @@
 
 /// Maximum amount of elements in script arrays
 #define SCRIPT_MAX_ARRAYSIZE (UINT_MAX - 1)
+/// Maximum amount of dimensions supported by script multidimensional arrays
+#define SCRIPT_MAX_ARRAY_DIMENSIONS 8
 
 enum script_cmd_result {
 	SCRIPT_CMD_SUCCESS = 0, ///when a buildin cmd was correctly done