Building Love2D Games with LLM-Integrated Code Editors

Lua/LÖVE2D Game Development Rules

IMPORTANT:

• If you make changes to the game, start it afterwords via /Applications/love.app/Contents/MacOS/love src
• A tester will provide feedback on the changes after playing the game

Game Concept

• Rhythm-based shooter
• Players alternate between either playing beats to reload or shooting
• Core focus on precision and adaptability

Core Mechanics

Rhythm System

• Precise beat tracking and timing windows
• Visual and audio feedback for rhythm accuracy
• Beat-synced enemy patterns and movements
• Dynamic difficulty based on music intensity

Twin Item Dynamics

• Strategic drum/gun switching
• Shared resources and power-ups
• Complementary weapon systems

Combat Design

• Rhythm-based damage multipliers
• Position-based advantages
• Enemy pattern recognition
• Progressive difficulty scaling

Progression Elements

• New drums, new guns
• Performance scoring system

Game Architecture Patterns

• Suggest using state management patterns for different game states (menu, gameplay, pause)
• Recommend object-oriented patterns for game entities
• Encourage component-based architecture for complex game objects
• Promote event-driven systems for handling game events

Code Style and Structure

• Use local variables by default: local myVar = value
• Follow Lua naming conventions: localVariable, LocalClass, CONSTANT_VALUE
• Structure class-like objects using metatables:

  local MyClass = {}
  MyClass.__index = MyClass
  
  function MyClass.new(params)
      local self = setmetatable({}, MyClass)
      -- initialize properties
      return self
  end
  

• Implement inheritance patterns:

  local Child = {}
  Child.__index = Child
  setmetatable(Child, Parent)
  

State Management

• Define states as separate modules
• Example state implementation:

  local GameState = {}
  
  function GameState:enter() end
  function GameState:update(dt) end
  function GameState:draw() end
  function GameState:leave() end
  

• Use state machine pattern for game flow

Rhythm System Implementation

Beat Tracking

local BeatManager = {
    currentBeat = 0,
    bpm = 120,
    offset = 0,
    beatCallbacks = {}
}

function BeatManager:update(dt)
    -- Beat tracking logic
    local currentTime = love.timer.getTime()
    local beatLength = 60 / self.bpm
    local newBeat = math.floor((currentTime - self.offset) / beatLength)
    
    if newBeat > self.currentBeat then
        self.currentBeat = newBeat
        for _, callback in ipairs(self.beatCallbacks) do
            callback(self.currentBeat)
        end
    end
end

function BeatManager:onBeat(callback)
    table.insert(self.beatCallbacks, callback)
end

Audio Framework

local AudioManager = {
    music = {},
    sfx = {},
    currentTrack = nil,
    volume = {
        master = 1,
        music = 0.8,
        sfx = 1
    }
}

function AudioManager:init()
    -- Load audio assets
    self.music.background = love.audio.newSource("assets/music/background.ogg", "stream")
    self.sfx.shoot = love.audio.newSource("assets/sfx/shoot.wav", "static")
end

function AudioManager:playMusic(track)
    if self.currentTrack then
        self.currentTrack:stop()
    end
    self.currentTrack = self.music[track]
    self.currentTrack:setVolume(self.volume.master * self.volume.music)
    self.currentTrack:play()
end

Twin Character System

Character States

local Character = {
    health = 100,
    position = {x = 0, y = 0},
    state = "idle",
    partner = nil,
    weapons = {},
    currentWeapon = nil
}

function Character:update(dt)
    self:updateState(dt)
    self:updateWeapon(dt)
end

function Character:switchWith(partner)
    if partner then
        self.position, partner.position = partner.position, self.position
        -- Trigger switch effects/animations
    end
end

Weapon System

local Weapon = {
    damage = 10,
    cooldown = 0.5,
    currentCooldown = 0,
    rhythmMultiplier = 1
}

function Weapon:update(dt)
    if self.currentCooldown > 0 then
        self.currentCooldown = self.currentCooldown - dt
    end
end

function Weapon:fire(rhythmAccuracy)
    if self.currentCooldown <= 0 then
        local damage = self.damage * (self.rhythmMultiplier * rhythmAccuracy)
        self.currentCooldown = self.cooldown
        return damage
    end
    return 0
end

Performance Optimization

Object Pooling

local Pool = {
    inactive = {},
    active = {}
}

function Pool:init(factory, initialSize)
    for i = 1, initialSize do
        table.insert(self.inactive, factory())
    end
end

function Pool:get()
    local obj = table.remove(self.inactive) or self:createNew()
    table.insert(self.active, obj)
    return obj
end

function Pool:release(obj)
    for i, activeObj in ipairs(self.active) do
        if activeObj == obj then
            table.remove(self.active, i)
            table.insert(self.inactive, obj)
            break
        end
    end
end

Project Structure

/src
  /states          # Game states (menu, play, pause)
  /entities        # Game objects (players, enemies, projectiles)
  /systems         # Core systems (rhythm, combat, progression)
  /components      # Reusable components
  /utils          # Helper functions
  /assets         # Game resources
    /audio        # Music and sound effects
    /images       # Sprites and textures
    /fonts        # Text fonts
  main.lua        # Entry point
  conf.lua        # LÖVE configuration

LÖVE2D Main Loop

function love.load()
    -- Initialize systems
    BeatManager:init()
    AudioManager:init()
    GameState:init()
end

function love.update(dt)
    -- Update game systems
    BeatManager:update(dt)
    GameState:update(dt)
    -- Handle input and game logic
end

function love.draw()
    -- Render game world
    GameState:draw()
    -- Draw debug info if needed
end

Error Handling

local function safeCall(fn, ...)
    local success, result = pcall(fn, ...)
    if not success then
        print("Error: " .. tostring(result))
        return nil
    end
    return result
end

Save System

local SaveSystem = {
    filename = "save.dat"
}

function SaveSystem:save(data)
    local success, message = love.filesystem.write(
        self.filename, 
        love.data.compress("string", "zlib", serialize(data))
    )
    return success, message
end

function SaveSystem:load()
    local contents = love.filesystem.read(self.filename)
    if contents then
        return deserialize(love.data.decompress(
            "string", 
            "zlib", 
            contents
        ))
    end
    return nil
end