-- Simple timer module for delayed actions local Timer = {} Timer.timers = {} -- Stores { id = unique_id, time_left = t, callback = func } Timer.next_id = 1 -- Update all active timers -- dt: delta time since last update function Timer.update(dt) local timers_to_remove = {} local callbacks_to_run = {} -- Iterate through timers and decrease time_left for id, timer in pairs(Timer.timers) do timer.time_left = timer.time_left - dt if timer.time_left <= 0 then table.insert(callbacks_to_run, timer.callback) timers_to_remove[id] = true -- Mark for removal end end -- Remove finished timers for id, _ in pairs(timers_to_remove) do Timer.timers[id] = nil end -- Run callbacks *after* iterating and removing to avoid issues for _, callback in ipairs(callbacks_to_run) do callback() end end -- Schedule a function to run after a delay -- delay: time in seconds -- callback: function to execute -- Returns: timer id (can be used for cancellation) function Timer.after(delay, callback) if type(delay) ~= "number" or delay < 0 then error("Timer delay must be a non-negative number", 2) end if type(callback) ~= "function" then error("Timer callback must be a function", 2) end local id = Timer.next_id Timer.next_id = Timer.next_id + 1 Timer.timers[id] = { id = id, time_left = delay, callback = callback } return id end -- Cancel a scheduled timer -- id: the id returned by Timer.after function Timer.cancel(id) if Timer.timers[id] then Timer.timers[id] = nil return true end return false end -- Get remaining time for a timer function Timer.getTimeLeft(id) if Timer.timers[id] then return Timer.timers[id].time_left end return nil end return Timer -- Player module local Timer = require("timer") local Player = {} Player.__index = Player -- Player constants local DEFAULT_SPEED = 100 -- pixels per second local DASH_SPEED_MULTIPLIER = 3 local DASH_DURATION = 0.3 -- seconds local DASH_COOLDOWN = 1.5 -- seconds local KILL_DELAY = 0.8 -- seconds -- Creates a new player instance function Player.new(id, x, y) local self = setmetatable({}, Player) self.id = id self.x = x or 0 self.y = y or 0 self.width = 20 -- Example size self.height = 20 -- Example size self.speed = DEFAULT_SPEED self.dash_speed = DEFAULT_SPEED * DASH_SPEED_MULTIPLIER self.dash_duration = DASH_DURATION self.dash_cooldown = DASH_COOLDOWN self.is_alive = true self.can_move = true self.is_dashing = false self.dash_timer = 0 -- Time remaining for current dash self.dash_cooldown_timer = 0 -- Time remaining until dash is available self.dash_dx = 0 -- Dash direction x component (normalized) self.dash_dy = 0 -- Dash direction y component (normalized) self.kill_timer_id = nil -- ID of the timer scheduling this player's death return self end -- Update player state function Player:update(dt) if not self.is_alive then return end -- Update dash cooldown if self.dash_cooldown_timer > 0 then self.dash_cooldown_timer = math.max(0, self.dash_cooldown_timer - dt) end -- Update dash state if self.is_dashing then self.dash_timer = self.dash_timer - dt if self.dash_timer <= 0 then self:stop_dash() else -- Move while dashing self.x = self.x + self.dash_dx * self.dash_speed * dt self.y = self.y + self.dash_dy * self.dash_speed * dt -- Add boundary checks if needed end end end -- Basic movement (if not dashing and allowed) function Player:move(dx, dy, dt) if self.is_alive and self.can_move and not self.is_dashing then local dist = math.sqrt(dx*dx + dy*dy) if dist > 0 then local nx = dx / dist local ny = dy / dist self.x = self.x + nx * self.speed * dt self.y = self.y + ny * self.speed * dt -- Add boundary checks if needed end end end -- Start dashing in a given direction function Player:start_dash(dx, dy) if self.is_alive and self.can_move and not self.is_dashing and self.dash_cooldown_timer <= 0 then local dist = math.sqrt(dx*dx + dy*dy) if dist > 0 then self.is_dashing = true self.dash_timer = self.dash_duration self.dash_cooldown_timer = self.dash_cooldown self.dash_dx = dx / dist self.dash_dy = dy / dist print(string.format("Player %s started dashing towards (%.2f, %.2f)", self.id, self.dash_dx, self.dash_dy)) end end end -- Stop the current dash function Player:stop_dash() if self.is_dashing then self.is_dashing = false self.dash_timer = 0 print(string.format("Player %s stopped dashing.", self.id)) end end -- Immobilize the player and schedule their death function Player:schedule_kill() if not self.is_alive or self.kill_timer_id then return end -- Already scheduled or dead print(string.format("Player %s immobilized!", self.id)) self.can_move = false self:stop_dash() -- Stop dashing if hit while dashing -- Schedule the kill self.kill_timer_id = Timer.after(KILL_DELAY, function() self:kill() end) print(string.format("Player %s kill scheduled in %.2f seconds (Timer ID: %s)", self.id, KILL_DELAY, self.kill_timer_id)) end -- Kill the player function Player:kill() if self.is_alive then print(string.format("Player %s has been killed.", self.id)) self.is_alive = false self.can_move = false self.is_dashing = false self.kill_timer_id = nil -- Clear timer id as it has executed or is irrelevant now -- Add any other death logic (e.g., visual effects, score changes) end end -- Check if player is ready to dash function Player:can_dash() return self.is_alive and self.can_move and not self.is_dashing and self.dash_cooldown_timer <= 0 end -- Simple Axis-Aligned Bounding Box collision check function Player:collides_with(other_player) if not self.is_alive or not other_player.is_alive then return false end return self.x < other_player.x + other_player.width and self.x + self.width > other_player.x and self.y < other_player.y + other_player.height and self.y + self.height > other_player.y end return Player -- Game logic module local Player = require("player") local Timer = require("timer") local Game = {} Game.players = {} -- Initialize the game state function Game.load() print("Loading game...") Game.players = { Player.new("P1", 50, 50), Player.new("P2", 200, 150) } Game.last_update_time = os.clock() -- Use os.clock for delta time calculation print("Game loaded.") end -- Check for collisions between players function Game.check_collisions() for i = 1, #Game.players do for j = i + 1, #Game.players do local p1 = Game.players[i] local p2 = Game.players[j] if p1:collides_with(p2) then -- Check dash collision logic if p1.is_dashing and p2.is_alive and p2.can_move then print(string.format("Collision: Dashing Player %s hit Player %s", p1.id, p2.id)) p2:schedule_kill() p1:stop_dash() -- Stop dash on hit end if p2.is_dashing and p1.is_alive and p1.can_move then print(string.format("Collision: Dashing Player %s hit Player %s", p2.id, p1.id)) p1:schedule_kill() p2:stop_dash() -- Stop dash on hit end end end end end -- Update the game state -- dt: delta time since last frame function Game.update(dt) -- Update timers first Timer.update(dt) -- Simulate input (replace with actual input handling) -- Example: Make P1 dash towards P2 if 'd' is pressed (conceptual) -- if input.is_key_pressed('d') and Game.players[1]:can_dash() then -- local p1 = Game.players[1] -- local p2 = Game.players[2] -- p1:start_dash(p2.x - p1.x, p2.y - p1.y) -- end -- Update players for _, player in ipairs(Game.players) do player:update(dt) -- Simulate basic movement for players if not dashing/immobilized -- Example: Move P2 randomly slightly if alive and can move if player.id == "P2" and player.is_alive and player.can_move then player:move(math.random(-1, 1), math.random(-1, 1), dt) end end -- Check for collisions and handle dash hits Game.check_collisions() -- Print player status periodically for debugging -- print_player_status() -- Call this less frequently if needed end -- Simple function to print player states local function print_player_status() print("--- Player Status ---") for _, p in ipairs(Game.players) do local status = string.format("Player %s: Pos(%.1f, %.1f), Alive: %s, CanMove: %s, Dashing: %s (%.2fs left), Cooldown: %.2fs, KillTimer: %s", p.id, p.x, p.y, tostring(p.is_alive), tostring(p.can_move), tostring(p.is_dashing), p.dash_timer, p.dash_cooldown_timer, tostring(p.kill_timer_id and Timer.getTimeLeft(p.kill_timer_id) or "None")) print(status) end print("---------------------") end -- Run a simple simulation loop function Game.run_simulation(duration) print("\n--- Starting Simulation ---") Game.load() local elapsed_time = 0 local tick_rate = 1/60 -- Simulate 60 FPS -- Initial status print_player_status() -- Simulate P1 dashing towards P2 immediately local p1 = Game.players[1] local p2 = Game.players[2] if p1:can_dash() then p1:start_dash(p2.x - p1.x, p2.y - p1.y) end while elapsed_time < duration do local current_time = os.clock() local dt = current_time - Game.last_update_time -- Prevent large dt spikes if debugging/pausing dt = math.min(dt, 0.1) if dt >= tick_rate then Game.update(tick_rate) -- Update with fixed step Game.last_update_time = current_time elapsed_time = elapsed_time + tick_rate -- Print status every second or so for clarity if math.fmod(elapsed_time, 1.0) < tick_rate then print(string.format("\n--- Time: %.2f ---", elapsed_time)) print_player_status() end -- Check if simulation should end early (e.g., only one player left) local alive_count = 0 for _, p in ipairs(Game.players) do if p.is_alive then alive_count = alive_count + 1 end end if alive_count <= 1 and #Game.players > 1 then print("\nSimulation ending early: One player remaining.") break end else -- Yield CPU briefly if running too fast (crude sleep) -- In a real game loop, use proper timing/vsync if os.execute("sleep 0.001") == nil then -- fallback for systems without sleep or where it fails local wait_until = os.clock() + 0.001 while os.clock() < wait_until do end end end end print("\n--- Final Status ---") print_player_status() print("--- Simulation Ended ---") end return Game -- Main script to run the game simulation -- Set package path to include current directory for requires package.path = package.path .. ";./?.lua" local Game = require("game") print("Starting main script...") -- Run the simulation for a few seconds Game.run_simulation(5) -- Simulate for 5 seconds print("Main script finished.")