Scripting 2.0: Lua Script Engine

gamedata/configs/mod_script_amx.ltx

@@ -0,0 +1,3 @@
+![common]
+script 						= xr.compiler, xr.lua, amx, _G, _g_patches, xr.classes, xr.processes, dxml_core
+>class_registrators 			= amx.registrator.register

gamedata/scripts/amx/init.lua

@@ -0,0 +1,13 @@
+-- Anomaly Modded eXes Entrypoint
+-- Extends base X-Ray script functionality
+
+--- Setup unlocalizer data model
+require(_PACKAGE .. ".unlocalize")
+
+--- Patch xr/lua compiler with modded exes extensions
+require(_PACKAGE .. ".lua")
+
+--- Export registrator from module to allow foo.bar.baz syntax in script.ltx
+return {
+   registrator = require(_PACKAGE .. ".registrator")
+}

gamedata/scripts/amx/lua/init.lua

@@ -0,0 +1,20 @@
+-- AMX Lua Compiler
+-- Patches unlocalization onto the base XR Lua compiler
+
+local xr_lua = require("xr.lua")
+local unlocalize = require(_PACKAGE .. ".unlocalize").unlocalize
+
+function xr_lua.loadstring(src, namespace_name, script_name)
+   if namespace_name then
+      print("* [" .. _PACKAGE .. "] compiling " .. namespace_name)
+   end
+
+   return xr_lua.compile(
+      unlocalize(src, namespace_name),
+      namespace_name,
+      script_name
+   )
+end
+
+-- Run unit tests
+require("amx.lua.tests")

gamedata/scripts/amx/lua/tests.lua

@@ -0,0 +1,110 @@
+local run_tests = require("tests.util").run_tests
+local unlocalize_with = require("amx.lua.unlocalize").unlocalize_with
+
+local SRC = {
+   declare_function = [[
+local function x(a, b, c) -- define a function
+   return a, b, c
+end
+   ]],
+
+   declare_var_single = [[
+local a -- declare a single var
+   ]],
+
+   define_var_single = [[
+local a = 1 -- define a single var
+   ]],
+   declare_var_multi = [[
+local a, b, c -- declare multiple vars
+   ]],
+   define_var_multi = [[
+local a, b, c = 1, 2, 3 -- define multiple vars
+   ]],
+   declare_var_single_sequence = [[
+local a; local b; local c; -- declare a sequence of vars
+   ]],
+   define_var_single_sequence = [[
+local a = 1; local b = 2; local c = 3; define a sequence of vars
+   ]],
+}
+
+local PASSES = {
+   declare_function = [[
+function x(a, b, c) -- define a function
+   return a, b, c
+end
+   ]],
+
+   declare_var_single = [[
+a = nil -- declare a single var
+   ]],
+
+   define_var_single = [[
+a = 1 -- define a single var
+   ]],
+   declare_var_multi = [[
+a, b, c = nil -- declare multiple vars
+   ]],
+   define_var_multi = [[
+a, b, c = 1, 2, 3 -- define multiple vars
+   ]],
+}
+
+local FAILS = {
+   declare_var_single_sequence = [[
+a = nil; b = nil; c = nil; -- declare a sequence of vars
+   ]],
+   define_var_single_sequence = [[
+a = 1; b = 2; c = 3; -- define a sequence of vars
+   ]],
+}
+
+local unlocalizer = {"x", "a", "b", "c"}
+
+local tests = {}
+
+local ERR_MISMATCHED =
+[[Mismatched unlocalizer output
+src:
+%s
+unlocalized:
+%s
+target:
+%s]]
+
+for k,targ in pairs(PASSES) do
+   tests[k] = function()
+      local src = SRC[k]
+      local res = unlocalize_with(src, unlocalizer)
+
+      if res == targ then
+         return true
+      else
+         return false, string.format(ERR_MISMATCHED, v, res, targ)
+      end
+   end
+end
+
+local ERR_UNEXPECTED =
+[[Unexpected unlocalizer output
+src:
+%s
+unlocalized:
+%s
+target:
+%s]]
+
+for k,targ in pairs(FAILS) do
+   tests[k .. " (unsupported)"] = function()
+      local src = SRC[k]
+      local res = unlocalize_with(src, unlocalizer)
+      if res ~= targ then
+         return true
+      else
+         return false, string.format(ERR_UNEXPECTED, src, res, targ)
+      end
+   end
+end
+
+run_tests("amx/lua", tests)

gamedata/scripts/amx/lua/unlocalize.lua

@@ -0,0 +1,121 @@
+-- Unlocalizer for xr/lua scripts
+
+local DEBUG = false
+
+local function string_trim(s, v)
+   if v == nil then
+      v = " \t\n\r\f\v"
+   end
+   local pattern = string.format("^[%s]*([^%s]*)[%s]*$", v, v, v)
+   return string.match(s, pattern)
+end
+
+local function contains(lst, a)
+   for _,b in ipairs(lst) do
+      if a == b then
+         return true
+      end
+   end
+
+   return false
+end
+
+local function unlocalize_with(src, unlocalizer)
+   local unlocal_performed = false
+
+   local temp = src
+   local tokens = {}
+   for line in string.gmatch(temp, "[^\n\r]+") do
+      table.insert(tokens, line)
+   end
+
+   for i,s in ipairs(tokens) do
+      s = string_trim(s, "\n\r")
+      tokens[i] = s
+
+      if s == "" then
+         goto next_token
+      end
+
+      -- local function x(a,b,c)
+      local _, _, c, d, e, f, g = string.match(
+         s,
+         [[^(local)([\t ]+)(function)([\t ]+)([_a-zA-Z].*)([\t ]*)(%(.*)$]]
+      )
+
+      if e then
+         if contains(unlocalizer, e)  then
+            if DEBUG then
+               print("[unlocal_regex] found variable " .. e .. " to unlocal")
+            end
+            tokens[i] = c .. d .. e .. f .. g
+            unlocal_performed = true
+         end
+         goto next_token
+      end
+
+      -- local a = ...
+      -- local a
+      -- local a,b,c = ... (if one of a,b,c is in unlocalizers list - all of them will be unlocalized)
+      -- local x; local y; - unsupported yet
+      local c = string.match(s, [[^local%s+(.*)]]) or ""
+      if #c > 0 then
+         local r = [[(.*)--.*]]
+         local nc = string.match(c, r)
+         if nc then
+            c = nc
+         end
+      end
+
+      local variables = string.match(c, [[^([^=]+)]])
+      local values = string.match(c, [[=([^=]+)$]])
+      if variables then
+         for v in string.gmatch(variables, "[^, ]+") do
+            v = string_trim(v)
+            if contains(unlocalizer, v) then
+               unlocal_performed = true
+               if DEBUG then
+                  print("found variable", v, "to unlocal")
+               end
+               s = c
+               if not values then
+                  local lhs, rhs = string.match(s, [[([^-]+)(%-%-[^-]*)]])
+                  if lhs and rhs then
+                     s = lhs .. "= nil " .. rhs
+                  else
+                     s = s .. "= nil"
+                  end
+               end
+               tokens[i] = s
+               break
+            end
+         end
+      end
+
+      ::next_token::
+   end
+
+   if unlocal_performed then
+      return table.concat(tokens, "\n")
+   end
+
+   return src
+end
+
+local function unlocalize(src, namespace_name)
+   if not namespace_name then
+      return src
+   end
+
+   local unlocalizer = require("amx.unlocalize").get(namespace_name)
+   if not unlocalizer then
+      return src
+   end
+
+   return unlocalize_with(src, unlocalizer)
+end
+
+return {
+   unlocalize_with = unlocalize_with,
+   unlocalize = unlocalize,
+}

gamedata/scripts/amx/registrator.lua

@@ -0,0 +1,33 @@
+-- AMX Class Registrator
+-- Add custom classes for registration here
+
+local function cs_register(factory, ...)
+   factory:register(...)
+end
+
+local function c_register(factory, ...)
+   if editor() == false then
+      factory:register(...)
+   end
+end
+
+local function s_register(factory, ...)
+   factory:register(...)
+end
+
+local function register(object_factory)
+   cs_register(
+      object_factory,
+      "CWeaponSSRS",
+      "se_item.se_weapon_magazined",
+      "_WP_SSRS",
+      "wpn_ssrs_s"
+   )
+end
+
+return {
+   cs_register = cs_register,
+   c_register = c_register,
+   s_register = s_register,
+   register = register,
+}

gamedata/scripts/amx/unlocalize.lua

@@ -0,0 +1,68 @@
+-- AMX Unlocalizer Storage
+-- Loads unlocalizers from disk and exposes them via `get`
+
+local unlocalizers = {}
+
+local function update()
+   local fs = getFS()
+   local list = fs:file_list_open(
+      "$game_config$",
+      "unlocalizers\\",
+      bit_or(
+         FS.FS_ListFiles,
+         FS.FS_RootOnly
+      )
+   )
+
+   if not list then
+      return
+   end
+
+   local count = list:Size() or 0
+   if count == 0 then
+      return
+   end
+
+   for i=1,count do
+      local id = list:GetAt(i - 1)
+
+      if #id < 4 then
+         goto next_filename
+      end
+
+      if string.sub(id, #id - 3, #id) ~= ".ltx" then
+         goto next_filename
+      end
+
+      print("opening file:", id)
+
+      local config = ini_file("unlocalizers\\" .. id)
+      config:section_for_each(function(section)
+         local name = string.lower(section)
+         local count = config:line_count(name)
+         for j=0,count-1 do
+            local res, sec = config:r_line(name, j)
+            if not res then
+               goto next_line
+            end
+            unlocalizers[name] = unlocalizers[name] or {}
+            table.insert(unlocalizers[name], sec)
+
+            ::next_line::
+         end
+      end)
+
+      ::next_filename::
+   end
+end
+
+local function get(k)
+   return unlocalizers[k]
+end
+
+update()
+
+return {
+   update = update,
+   get = get
+}