Knowledge BaseScriptingAdvanced Scripting

Advanced Scripting Techniques

Take your scripting skills to the next level with advanced patterns and methods

Advanced Scripting Overview
Powerful techniques to enhance your Valex scripts

Once you've mastered the basics of scripting, these advanced techniques will help you create more powerful, efficient, and flexible scripts. This guide covers complex patterns, optimization strategies, and advanced features available in the Valex scripting environment.

Advanced Design Patterns

Using proper design patterns will make your scripts more maintainable, reusable, and efficient. Here are some advanced patterns that work well in the Valex environment:

Module Pattern

-- Create a self-contained module
local MyModule = {}

-- Private variables (not accessible outside)
local privateVar = "hidden"

-- Private function
local function privateFunction()
    return "Called private function"
end

-- Public methods
function MyModule.initialize()
    print("Module initialized")
    return true
end

function MyModule.doSomething()
    print("Using " .. privateVar)
    return privateFunction()
end

-- Return the module
return MyModule

-- Usage:
-- local module = require("MyModule")
-- module.initialize()
-- module.doSomething()

Observer Pattern

-- Observer Pattern for event handling
local EventSystem = {}
local listeners = {}

function EventSystem.subscribe(eventName, callback)
    listeners[eventName] = listeners[eventName] or {}
    table.insert(listeners[eventName], callback)
end

function EventSystem.unsubscribe(eventName, callback)
    if not listeners[eventName] then return end
    
    for i, func in ipairs(listeners[eventName]) do
        if func == callback then
            table.remove(listeners[eventName], i)
            break
        end
    end
end

function EventSystem.emit(eventName, ...)
    if not listeners[eventName] then return end
    
    for _, callback in ipairs(listeners[eventName]) do
        callback(...)
    end
end

-- Usage example
local function onHealthChange(newHealth)
    print("Health changed to: " .. newHealth)
end

EventSystem.subscribe("healthChanged", onHealthChange)

-- When health changes in game:
EventSystem.emit("healthChanged", 75)

State Machine Pattern

-- State Machine for managing complex behavior
local StateMachine = {
    currentState = nil,
    states = {}
}

function StateMachine.addState(name, enterFn, updateFn, exitFn)
    StateMachine.states[name] = {
        enter = enterFn or function() end,
        update = updateFn or function() end,
        exit = exitFn or function() end
    }
end

function StateMachine.changeState(newState)
    if StateMachine.currentState then
        StateMachine.states[StateMachine.currentState].exit()
    end
    
    StateMachine.currentState = newState
    StateMachine.states[newState].enter()
end

function StateMachine.update()
    if StateMachine.currentState then
        StateMachine.states[StateMachine.currentState].update()
    end
end

-- Usage example
StateMachine.addState(
    "idle",
    function() print("Entering idle state") end,
    function() print("Updating idle state") end,
    function() print("Exiting idle state") end
)

StateMachine.addState(
    "combat",
    function() print("Entering combat state") end,
    function() print("Updating combat state") end,
    function() print("Exiting combat state") end
)

StateMachine.changeState("idle")
StateMachine.update()
StateMachine.changeState("combat")

Performance Optimization

Optimizing Your Scripts

Advanced scripts often perform complex operations that can impact performance. Use these tips to ensure your scripts run efficiently:

  • Cache results: Store the results of expensive operations rather than recalculating them repeatedly.
  • Use local variables: Local variables are faster to access than global ones.
  • Optimize loops: Avoid creating objects inside loops and pre-calculate loop invariants.
  • Reduce memory reads/writes: Minimize the number of memory operations, especially in hot loops.
  • Profile your code: Use timing functions to identify bottlenecks in your script.
  • Use appropriate intervals: Don't run tasks more frequently than necessary.
-- Example of performance measurement
local function measurePerformance(fn, name, iterations)
    iterations = iterations or 1000
    name = name or "Function"
    
    local startTime = valex.getTime()
    
    for i = 1, iterations do
        fn()
    end
    
    local endTime = valex.getTime()
    local duration = endTime - startTime
    local average = duration / iterations
    
    print(name .. " - Total: " .. duration .. "ms, Avg: " .. average .. "ms per call")
    return average
end

-- Usage example
measurePerformance(function()
    -- Your code here
    local sum = 0
    for i = 1, 1000 do
        sum = sum + i
    end
end, "Sum calculation", 100)