AI Script for Player Interaction in Lua

This document outlines a Lua script to create a simple AI script capable of wandering, searching for players, attacking, taking cover, and retreating.

Function Overview

Key Features:

• Wander: Move randomly in the environment.
• Search: Look for nearby players.
• Attack: Engage with detected players.
• Take Cover: Move to safe locations if under attack.
• Retreat: Move away when health is low.

Required Imports

While standard Lua does not require imports for simple scripts, if you are integrating with a game engine (like Love2D or Defold), ensure relevant libraries are included for movement and detection functionalities.

Main Function

AI = {}
AI.__index = AI

function AI:new(name, position, health)
    -- Create a new AI instance
    local instance = setmetatable({}, AI)
    instance.name = name
    instance.position = position  -- {x, y}
    instance.health = health
    instance.aggressive = true      -- AI starts in aggressive mode
    return instance
end

-- Wander method to move the AI randomly in the environment
function AI:wander()
    -- Modify position randomly within movement limits
    self.position.x = self.position.x + math.random(-1, 1)
    self.position.y = self.position.y + math.random(-1, 1)
end

-- Search method to find nearby players
function AI:search(players)
    for _, player in ipairs(players) do
        local distance = self:calculateDistance(player.position)
        if distance < 5 then  -- Example detection range
            return player  -- Found a player
        end
    end
    return nil  -- No player found
end

-- Attack method to engage player
function AI:attack(player)
    player.health = player.health - 1  -- Example attack reduces player health
end

-- Take cover method for safety
function AI:takeCover()
    -- Move to a cover position (for simplicity, move back by one)
    self.position.x = self.position.x - 1
end

-- Retreat method to escape from danger
function AI:retreat()
    self.position.x = self.position.x + 5  -- Move away
end

-- Calculate distance from the AI to another position
function AI:calculateDistance(targetPosition)
    return math.sqrt(
        (targetPosition.x - self.position.x) ^ 2 +
        (targetPosition.y - self.position.y) ^ 2
    )
end

-- Main AI decision loop
function AI:update(players)
    self:wander()  -- Always wander

    local player = self:search(players)
    if player then
        if self.health < 20 then
            self:retreat()  -- Retreat if health is low
        else
            self:attack(player)  -- Attack if a player is found
        end
    elseif self.health < 50 then
        self:takeCover()  -- Take cover if health is medium
    end
end

Explanation of Functions

• new(name, position, health): Constructs a new AI object with specified attributes.
• wander(): Moves the AI randomly, simulating wandering behavior.
• search(players): Checks proximity to a list of players and returns the nearest one if within range.
• attack(player): Reduces the health of the target player.
• takeCover(): Adjusts the AI’s position to simulate taking cover.
• retreat(): Moves the AI away from danger by a specified distance.
• calculateDistance(targetPosition): Computes the Euclidean distance from the AI position to a target position.
• update(players): Central control loop for decision making, integrating wandering, searching, attacking, and taking cover logic.

Usage Example

-- Example usage
local players = {
    {position = {x = 10, y = 10}, health = 10},
    {position = {x = 15, y = 15}, health = 15}
}

local ai = AI:new("AI Warrior", {x = 0, y = 0}, 100)

while true do
    ai:update(players)
    
    -- Print AI and player positions for reference 
    print(ai.name .. " Position: (" .. ai.position.x .. ", " .. ai.position.y .. ")")
    for i, player in ipairs(players) do
        print("Player " .. i .. " Position: (" .. player.position.x .. ", " .. player.position.y .. ") Health: " .. player.health)
    end
end

Conclusion

This Lua script provides a foundational AI behavior system for interaction in a game environment. Expand on these methods as required, integrating with your specific game engine's functionality. Consider exploring courses on the Enterprise DNA Platform to enhance your data analysis and scripting skills.