-- Simple 3D Vector library local Vector = {} Vector.__index = Vector function Vector.new(x, y, z) return setmetatable({ x = x or 0, y = y or 0, z = z or 0 }, Vector) end function Vector:__add(other) return Vector.new(self.x + other.x, self.y + other.y, self.z + other.z) end function Vector:__sub(other) return Vector.new(self.x - other.x, self.y - other.y, self.z - other.z) end function Vector:__mul(scalar) return Vector.new(self.x * scalar, self.y * scalar, self.z * scalar) end function Vector:__div(scalar) if scalar == 0 then error("Division by zero") end return Vector.new(self.x / scalar, self.y / scalar, self.z / scalar) end function Vector:magnitude() return math.sqrt(self.x^2 + self.y^2 + self.z^2) end function Vector:normalize() local mag = self:magnitude() if mag == 0 then return Vector.new(0, 0, 0) end return self / mag end function Vector.distance(v1, v2) return (v2 - v1):magnitude() end -- Check if v2 is within an axis-aligned bounding box centered at v1 function Vector.within_box(v1, v2, half_extents) local diff = v2 - v1 return math.abs(diff.x) <= half_extents.x and math.abs(diff.y) <= half_extents.y and math.abs(diff.z) <= half_extents.z end function Vector:__tostring() return string.format("Vector(%.2f, %.2f, %.2f)", self.x, self.y, self.z) end return Vector -- Configuration for the magnet effect local config = { magnet_range = { x = 35, y = 35, z = 35 }, -- Full dimensions of the box magnet_strength = 5, -- Arbitrary strength factor for the pull update_interval = 0.1, -- How often to check for tools (in seconds) visual_box_color = { r = 0, g = 1, b = 1, a = 0.3 }, -- Cyan, semi-transparent tool_identifier = "tool", -- How to identify tools (e.g., by name prefix, type, tag) } -- Calculate half extents for easier box checks config.magnet_half_extents = { x = config.magnet_range.x / 2, y = config.magnet_range.y / 2, z = config.magnet_range.z / 2, } return config -- Placeholder for Game/Engine Specific Functions --[[ This module simulates interactions with a hypothetical game engine. Replace these functions with actual API calls from your specific environment. ]] local GameInterface = {} -- Simulates getting the player's current position function GameInterface.get_player_position() -- Replace with actual game API call -- Example: return engine.player:get_position() -- For demonstration, return a static position or one that changes over time -- return require("vector").new(0, 0, 0) -- Simulate movement local t = os.time() return require("vector").new(math.sin(t * 0.1) * 10, 1.7, math.cos(t * 0.1) * 10) end -- Simulates finding nearby objects that are tools function GameInterface.find_nearby_tools(center_pos, range_vector) -- Replace with actual game API call for spatial query -- Example: return engine.world:find_objects_in_box(center_pos, range_vector, { type = "tool" }) -- For demonstration, return a list of dummy tool objects local Vector = require("vector") local tools = {} local tool_positions = { Vector.new(5, 1, 5), Vector.new(-10, 2, 15), Vector.new(20, 0, -5), -- Inside range if player near origin Vector.new(40, 40, 40), -- Outside range } for i, pos in ipairs(tool_positions) do table.insert(tools, { id = "tool_" .. i, name = "Generic Tool " .. i, type = "tool", -- Assuming tools have a type property position = pos, -- Placeholder function to simulate applying force/velocity apply_force = function(self, force_vector) print(string.format("Applying force %s to %s", force_vector, self.id)) -- In a real engine, this would affect the object's physics state -- self.position = self.position + force_vector * 0.1 -- Simplified movement end, -- Placeholder function to get current position get_position = function(self) return self.position end }) end return tools end -- Simulates drawing a box in the game world function GameInterface.draw_debug_box(center_pos, size_vector, color) -- Replace with actual game API call for debug drawing -- Example: engine.debug_renderer:draw_box(center_pos, size_vector, color) print(string.format("Drawing debug box at %s, size %s, color R:%.1f G:%.1f B:%.1f A:%.1f", center_pos, require("vector").new(size_vector.x, size_vector.y, size_vector.z), color.r, color.g, color.b, color.a )) end return GameInterface -- Core Magnet Logic local Vector = require("vector") local config = require("config") local GameInterface = require("game_interface") local Magnet = {} local time_since_last_update = 0 local visual_box_enabled = true -- Function to apply magnet pull to a single tool local function apply_magnet_pull(tool, center_pos) local tool_pos = tool:get_position() -- Use method if available, else access property -- Check if the tool is within the defined box range if Vector.within_box(center_pos, tool_pos, config.magnet_half_extents) then local direction_to_center = (center_pos - tool_pos):normalize() local distance = Vector.distance(center_pos, tool_pos) -- Optional: Make strength inversely proportional to distance (stronger when closer) -- local strength_factor = 1 / (distance + 1) -- Add 1 to avoid division by zero/extreme force local force = direction_to_center * config.magnet_strength -- * strength_factor -- Apply the force/velocity change using the game interface if tool.apply_force then tool:apply_force(force) else print(string.format("Warning: Tool %s does not have an apply_force method.", tool.id or tool.name)) end end end -- Main update function, called periodically (e.g., every frame or fixed interval) function Magnet.update(dt) time_since_last_update = time_since_last_update + dt if time_since_last_update >= config.update_interval then time_since_last_update = 0 local player_pos = GameInterface.get_player_position() -- Find tools within a slightly larger range to ensure we catch those near the edge -- Using the magnet range itself for simplicity here local potential_tools = GameInterface.find_nearby_tools(player_pos, config.magnet_range) for _, tool in ipairs(potential_tools) do -- Optional: Add more specific checks if needed (e.g., tool.is_attractable) if tool.type == config.tool_identifier or string.find(tool.name or "", config.tool_identifier) then local current_tool_pos = tool:get_position() if current_tool_pos then apply_magnet_pull(tool, player_pos) else print(string.format("Warning: Could not get position for tool %s", tool.id or tool.name)) end end end -- Draw the visual range box if enabled if visual_box_enabled then GameInterface.draw_debug_box(player_pos, config.magnet_range, config.visual_box_color) end end end function Magnet.toggle_visual_box(enable) visual_box_enabled = enable if not visual_box_enabled then -- Optional: Add code here to explicitly remove the box if the drawing API requires it print("Magnet visual box disabled.") else print("Magnet visual box enabled.") end end function Magnet.set_range(x, y, z) config.magnet_range = { x = x, y = y, z = z } config.magnet_half_extents = { x = x / 2, y = y / 2, z = z / 2 } print(string.format("Magnet range set to %.1f x %.1f x %.1f", x, y, z)) end return Magnet -- Main script to run the magnet effect local Magnet = require("magnet") --[[ This is the main loop or update hook for your game/environment. You'll need to integrate this call into your existing game loop. 'dt' (delta time) is the time elapsed since the last frame/update. If your environment doesn't provide dt, you might need to calculate it or adjust the Magnet.update logic to not rely on it (e.g., run on a fixed timer). ]] -- Example of how you might call the update function in a game loop local function game_update_loop(dt) -- Update other game systems... -- Update the magnet system Magnet.update(dt) -- Render frame, etc... end -- --- Simulation --- -- If you're running this standalone, you can simulate a game loop: local running = true local last_time = os.clock() print("Starting Magnet Simulation (Press Ctrl+C to stop)") print("Magnet effect active. Visual box should be drawn.") -- Example: Toggle visual box off after 5 seconds -- Replace with actual game event triggers or commands -- Timer.after(5, function() Magnet.toggle_visual_box(false) end) while running do local current_time = os.clock() local dt = current_time - last_time last_time = current_time -- Simulate game update game_update_loop(dt) -- Basic throttle to avoid busy-waiting -- In a real game, this would be handled by the engine's frame limiter/vsync if os.execute("sleep 0.05") == nil then -- Non-portable sleep, works on Linux/macOS -- Handle potential errors or use a different sleep mechanism if needed -- For Windows, you might need a different approach or library for sleep -- If no sleep is available, this will run as fast as possible. end -- Simple exit condition (e.g., for testing) - normally handled by game state -- if current_time > 10 then running = false end end print("Magnet Simulation Stopped.")