Love2D 尝试生成一个内部有块的块，但在移走一些块后，它会渲染比预期更多的块

Question

我创建了一个基本的块生成器，一个块是充满正方形的区域，当玩家从 0,0 移动几个块时它可以正常工作，但是在移动 4 个块之后它会渲染超过一个块而不是一个，我不是确定我做错了什么，我已经尝试改变一些值，但我还是感到头疼。

这是完整的代码，您可以使用 love2D 复制并粘贴到 VSCODE 中，看看会发生什么。

我认为主要问题出在 check_boarders 函数周围，因为这是检查玩家是否在块内的函数。

function Key_input(key)
    if love.keyboard.isDown(key) then
        return 1
    else
        return 0
    end
end

function love.load()
    Camera = require "camera"
    Cam = Camera()
    Basic_Player = {}
    Basic_Player.X = 100
    Basic_Player.Y = 100
    Basic_Player.Speed = 15

    Movement = {}
end


function love.update(dt)
    Movement.X = Key_input("d") - Key_input("a")
    Movement.Y = Key_input("s") - Key_input("w")

    

    Basic_Player.X = Basic_Player.X + Movement.X * Basic_Player.Speed
    Basic_Player.Y = Basic_Player.Y + Movement.Y * Basic_Player.Speed
    
    Cam:lookAt(Basic_Player.X,Basic_Player.Y)

    X, Y = Cam:position() -- Set cam position to global values
end

function love.draw()
    love.graphics.setBackgroundColor(0.5,0.5,0.9)
    Cam:attach() -- Renders the player and world inside its own scene
        generate_world(10,0)

        love.graphics.setColor( 0,0,1, 1 )
        love.graphics.rectangle("fill",Basic_Player.X,Basic_Player.Y,30,30)
        love.graphics.setColor( 1,1,1, 1 )
        
    Cam:detach()
    love.graphics.setColor( 1,0,0, 1 ) --Stays on the screen
    love.graphics.print(X .. " / " .. Y  ,300,400)
    love.graphics.print(love.timer.getFPS( )  ,300,450)
    love.graphics.setColor( 1,1,1, 1 )

end

function old_generate_world(_world_size, _seed) -- Before optimization
    local _chunk_size = 30
    local _block_size = 30
    for i = 0, _world_size - 1 do
        for f = 0, _world_size - 1 do
            local x_val = (_chunk_size * _block_size) * i -- Position value for actually building the chunks
            local y_val = (_chunk_size * _block_size) * f

            gen_chunk(_chunk_size,_block_size,_seed,{X = x_val ,Y = y_val })
        end
    end
end

function generate_world(_world_size, _seed)
    local _chunk_size = 10 -- Chunk size width and height
    local _block_size = 30 -- block size inside the chunk
    for i = 0, _world_size - 1 do -- loop through world size
        for f = 0, _world_size - 1 do
            local x_val = (_chunk_size * _block_size) * i -- Position value for actually building the chunks
            local y_val = (_chunk_size * _block_size) * f

            local chunk_x_local_size = 0 -- To make sure we get a length for when i and f = 0
            local chunk_y_local_size = 0

            if i == 0 then -- To make sure the size of the chunk isnt zero
                chunk_x_local_size = _chunk_size * _block_size  -- Get length of chunk when i = 0
            else
                chunk_x_local_size = x_val
            end

            if f == 0 then -- ditto
                chunk_y_local_size = _chunk_size * _block_size  
            else
                chunk_y_local_size = y_val
            end

            -- Checks if the player is inside a chunk if true draw it.
            if Check_boarders({X = X,Y = Y},{X = x_val,Y = y_val}, {X = chunk_x_local_size, Y = chunk_y_local_size}) then
                gen_chunk(_chunk_size,_block_size,_seed,{X = x_val ,Y = y_val }) -- Actually generate the chunk
            end
                
            love.graphics.setColor( 0,1,0, 1 )
            love.graphics.rectangle("fill",x_val,y_val,15,15)
            love.graphics.setColor( 1,1,1, 1 )

        end
    end
end

function Check_boarders(player_pos, boarder_pos, chunk_length) -- Checks player position is inside the boarder of the currently generated chunk

    if player_pos.X > boarder_pos.X and player_pos.X < boarder_pos.X + chunk_length.X then -- Check if the player is greater then top left and less then top right
        if player_pos.Y > boarder_pos.Y and player_pos.Y < boarder_pos.Y + chunk_length.Y then -- check if player is greater then top and less then bottom left
            return true
        end
    end
    return false
    
end

function gen_chunk(chunk_size,block_size,seed,position) -- chunk size is how many blocks inside the chunk, block size is self explain, seed n/a, pos starting chunk position
    for i = 0, chunk_size - 1 do
        for e = 0, chunk_size - 1 do -- loop until chunk size is met this is the amount of blocks being created
            love.graphics.rectangle("fill",position.X + i * block_size,position.Y + e * block_size,block_size - 1,block_size - 1)
        end
    end
    love.graphics.setColor( 1,0,0, 1 )
    love.graphics.rectangle("fill",position.X ,position.Y,6,6)
    love.graphics.setColor( 1,1,1, 1 )    
end

您将需要这个camera.lua脚本，只需创建它并将其粘贴到其中即可：

local _PATH = (...):match('^(.*[%./])[^%.%/]+$') or ''
local cos, sin = math.cos, math.sin

local camera = {}
camera.__index = camera

-- Movement interpolators (for camera locking/windowing)
camera.smooth = {}

function camera.smooth.none()
    return function(dx,dy) return dx,dy end
end

function camera.smooth.linear(speed)
    assert(type(speed) == "number", "Invalid parameter: speed = "..tostring(speed))
    return function(dx,dy, s)
        -- normalize direction
        local d = math.sqrt(dx*dx+dy*dy)
        local dts = math.min((s or speed) * love.timer.getDelta(), d) -- prevent overshooting the goal
        if d > 0 then
            dx,dy = dx/d, dy/d
        end

        return dx*dts, dy*dts
    end
end

function camera.smooth.damped(stiffness)
    assert(type(stiffness) == "number", "Invalid parameter: stiffness = "..tostring(stiffness))
    return function(dx,dy, s)
        local dts = love.timer.getDelta() * (s or stiffness)
        return dx*dts, dy*dts
    end
end


local function new(x,y, zoom, rot, smoother)
    x,y  = x or love.graphics.getWidth()/2, y or love.graphics.getHeight()/2
    zoom = zoom or 1
    rot  = rot or 0
    smoother = smoother or camera.smooth.none() -- for locking, see below
    return setmetatable({x = x, y = y, scale = zoom, rot = rot, smoother = smoother}, camera)
end

function camera:lookAt(x,y)
    self.x, self.y = x, y
    return self
end

function camera:move(dx,dy)
    self.x, self.y = self.x + dx, self.y + dy
    return self
end

function camera:position()
    return self.x, self.y
end

function camera:rotate(phi)
    self.rot = self.rot + phi
    return self
end

function camera:rotateTo(phi)
    self.rot = phi
    return self
end

function camera:zoom(mul)
    self.scale = self.scale * mul
    return self
end

function camera:zoomTo(zoom)
    self.scale = zoom
    return self
end

function camera:attach(x,y,w,h, noclip)
    x,y = x or 0, y or 0
    w,h = w or love.graphics.getWidth(), h or love.graphics.getHeight()

    self._sx,self._sy,self._sw,self._sh = love.graphics.getScissor()
    if not noclip then
        love.graphics.setScissor(x,y,w,h)
    end

    local cx,cy = x+w/2, y+h/2
    love.graphics.push()
    love.graphics.translate(cx, cy)
    love.graphics.scale(self.scale)
    love.graphics.rotate(self.rot)
    love.graphics.translate(-self.x, -self.y)
end

function camera:detach()
    love.graphics.pop()
    love.graphics.setScissor(self._sx,self._sy,self._sw,self._sh)
end

function camera:draw(...)
    local x,y,w,h,noclip,func
    local nargs = select("#", ...)
    if nargs == 1 then
        func = ...
    elseif nargs == 5 then
        x,y,w,h,func = ...
    elseif nargs == 6 then
        x,y,w,h,noclip,func = ...
    else
        error("Invalid arguments to camera:draw()")
    end

    self:attach(x,y,w,h,noclip)
    func()
    self:detach()
end

-- world coordinates to camera coordinates
function camera:cameraCoords(x,y, ox,oy,w,h)
    ox, oy = ox or 0, oy or 0
    w,h = w or love.graphics.getWidth(), h or love.graphics.getHeight()

    -- x,y = ((x,y) - (self.x, self.y)):rotated(self.rot) * self.scale + center
    local c,s = cos(self.rot), sin(self.rot)
    x,y = x - self.x, y - self.y
    x,y = c*x - s*y, s*x + c*y
    return x*self.scale + w/2 + ox, y*self.scale + h/2 + oy
end

-- camera coordinates to world coordinates
function camera:worldCoords(x,y, ox,oy,w,h)
    ox, oy = ox or 0, oy or 0
    w,h = w or love.graphics.getWidth(), h or love.graphics.getHeight()

    -- x,y = (((x,y) - center) / self.scale):rotated(-self.rot) + (self.x,self.y)
    local c,s = cos(-self.rot), sin(-self.rot)
    x,y = (x - w/2 - ox) / self.scale, (y - h/2 - oy) / self.scale
    x,y = c*x - s*y, s*x + c*y
    return x+self.x, y+self.y
end

function camera:mousePosition(ox,oy,w,h)
    local mx,my = love.mouse.getPosition()
    return self:worldCoords(mx,my, ox,oy,w,h)
end

-- camera scrolling utilities
function camera:lockX(x, smoother, ...)
    local dx, dy = (smoother or self.smoother)(x - self.x, self.y, ...)
    self.x = self.x + dx
    return self
end

function camera:lockY(y, smoother, ...)
    local dx, dy = (smoother or self.smoother)(self.x, y - self.y, ...)
    self.y = self.y + dy
    return self
end

function camera:lockPosition(x,y, smoother, ...)
    return self:move((smoother or self.smoother)(x - self.x, y - self.y, ...))
end

function camera:lockWindow(x, y, x_min, x_max, y_min, y_max, smoother, ...)
    -- figure out displacement in camera coordinates
    x,y = self:cameraCoords(x,y)
    local dx, dy = 0,0
    if x < x_min then
        dx = x - x_min
    elseif x > x_max then
        dx = x - x_max
    end
    if y < y_min then
        dy = y - y_min
    elseif y > y_max then
        dy = y - y_max
    end

    -- transform displacement to movement in world coordinates
    local c,s = cos(-self.rot), sin(-self.rot)
    dx,dy = (c*dx - s*dy) / self.scale, (s*dx + c*dy) / self.scale

    -- move
    self:move((smoother or self.smoother)(dx,dy,...))
end

-- the module
return setmetatable({new = new, smooth = camera.smooth},
    {__call = function(_, ...) return new(...) end})