mirror of
https://github.com/SashLilac/cambridge.git
synced 2024-11-22 14:39:02 -06:00
188 lines
4.7 KiB
Lua
188 lines
4.7 KiB
Lua
local Object = require 'libs.classic'
|
|
|
|
local Piece = Object:extend()
|
|
|
|
function Piece:new(shape, rotation, position, block_offsets, gravity, lock_delay, skin, colour, big)
|
|
self.shape = shape
|
|
self.rotation = rotation
|
|
self.position = position
|
|
self.block_offsets = block_offsets
|
|
self.gravity = gravity
|
|
self.lock_delay = lock_delay
|
|
self.skin = skin
|
|
self.colour = colour
|
|
self.ghost = false
|
|
self.locked = false
|
|
self.big = big
|
|
end
|
|
|
|
-- Functions that return a new piece to test in rotation systems.
|
|
|
|
function Piece:withOffset(offset)
|
|
return Piece(
|
|
self.shape, self.rotation,
|
|
{x = self.position.x + offset.x, y = self.position.y + offset.y},
|
|
self.block_offsets, self.gravity, self.lock_delay, self.skin, self.colour, self.big
|
|
)
|
|
end
|
|
|
|
function Piece:withRelativeRotation(rot)
|
|
local new_rot = self.rotation + rot
|
|
while new_rot < 0 do new_rot = new_rot + 4 end
|
|
while new_rot >= 4 do new_rot = new_rot - 4 end
|
|
return Piece(
|
|
self.shape, new_rot, self.position,
|
|
self.block_offsets, self.gravity, self.lock_delay, self.skin, self.colour, self.big
|
|
)
|
|
end
|
|
|
|
-- Functions that return predicates relative to a grid.
|
|
|
|
function Piece:getBlockOffsets()
|
|
return self.block_offsets[self.shape][self.rotation + 1]
|
|
end
|
|
|
|
function Piece:occupiesSquare(x, y)
|
|
local offsets = self:getBlockOffsets()
|
|
for index, offset in pairs(offsets) do
|
|
local new_offset = {x = self.position.x + offset.x, y = self.position.y + offset.y}
|
|
if new_offset.x == x and new_offset.y == y then
|
|
return true
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
function Piece:isMoveBlocked(grid, offset)
|
|
local moved_piece = self:withOffset(offset)
|
|
return not grid:canPlacePiece(moved_piece)
|
|
end
|
|
|
|
function Piece:isDropBlocked(grid)
|
|
return self:isMoveBlocked(grid, { x=0, y=1 })
|
|
end
|
|
|
|
-- Procedures to actually do stuff to pieces.
|
|
|
|
function Piece:setOffset(offset)
|
|
self.position.x = self.position.x + offset.x
|
|
self.position.y = self.position.y + offset.y
|
|
return self
|
|
end
|
|
|
|
function Piece:setRelativeRotation(rot)
|
|
new_rot = self.rotation + rot
|
|
while new_rot < 0 do new_rot = new_rot + 4 end
|
|
while new_rot >= 4 do new_rot = new_rot - 4 end
|
|
self.rotation = new_rot
|
|
return self
|
|
end
|
|
|
|
function Piece:moveInGrid(step, squares, grid, instant)
|
|
local moved = false
|
|
for x = 1, squares do
|
|
if grid:canPlacePiece(self:withOffset(step)) then
|
|
moved = true
|
|
self:setOffset(step)
|
|
if instant then
|
|
self:dropToBottom(grid)
|
|
end
|
|
else
|
|
break
|
|
end
|
|
end
|
|
if moved and step.y == 0 then playSE("move") end
|
|
return self
|
|
end
|
|
|
|
function Piece:dropSquares(dropped_squares, grid)
|
|
self:moveInGrid({ x = 0, y = 1 }, dropped_squares, grid)
|
|
end
|
|
|
|
function Piece:dropToBottom(grid)
|
|
local piece_y = self.position.y
|
|
self:dropSquares(math.huge, grid)
|
|
self.gravity = 0
|
|
if self.position.y > piece_y then
|
|
if self.ghost == false then playSE("bottom") end
|
|
-- self.lock_delay = 0
|
|
end
|
|
return self
|
|
end
|
|
|
|
function Piece:lockIfBottomed(grid)
|
|
if self:isDropBlocked(grid) then
|
|
self.locked = true
|
|
end
|
|
return self
|
|
end
|
|
|
|
function Piece:addGravity(gravity, grid, classic_lock)
|
|
gravity = gravity / (self.big and 2 or 1)
|
|
local new_gravity = self.gravity + gravity
|
|
if self:isDropBlocked(grid) then
|
|
if classic_lock then
|
|
self.gravity = new_gravity
|
|
else
|
|
self.gravity = 0
|
|
self.lock_delay = self.lock_delay + 1
|
|
end
|
|
elseif not (
|
|
self:isMoveBlocked(grid, { x=0, y=-1 }) and gravity < 0
|
|
) then
|
|
local dropped_squares = math.floor(math.abs(new_gravity))
|
|
if gravity >= 0 then
|
|
local new_frac_gravity = new_gravity - dropped_squares
|
|
self.gravity = new_frac_gravity
|
|
self:dropSquares(dropped_squares, grid)
|
|
if self:isDropBlocked(grid) then
|
|
playSE("bottom")
|
|
end
|
|
else
|
|
local new_frac_gravity = new_gravity + dropped_squares
|
|
self.gravity = new_frac_gravity
|
|
self:moveInGrid({ x=0, y=-1 }, dropped_squares, grid)
|
|
if self:isMoveBlocked(grid, { x=0, y=-1 }) then
|
|
playSE("bottom")
|
|
end
|
|
end
|
|
else
|
|
self.gravity = 0
|
|
end
|
|
return self
|
|
end
|
|
|
|
-- Procedures for drawing.
|
|
|
|
function Piece:draw(opacity, brightness, grid, partial_das)
|
|
if opacity == nil then opacity = 1 end
|
|
if brightness == nil then brightness = 1 end
|
|
love.graphics.setColor(brightness, brightness, brightness, opacity)
|
|
local offsets = self:getBlockOffsets()
|
|
local gravity_offset = 0
|
|
if config.gamesettings.smooth_movement == 1 and
|
|
grid ~= nil and not self:isDropBlocked(grid) then
|
|
gravity_offset = self.gravity * 16
|
|
end
|
|
if partial_das == nil then partial_das = 0 end
|
|
for index, offset in pairs(offsets) do
|
|
local x = self.position.x + offset.x
|
|
local y = self.position.y + offset.y
|
|
if self.big then
|
|
love.graphics.draw(
|
|
blocks[self.skin][self.colour],
|
|
64+x*32+partial_das*2, 16+y*32+gravity_offset*2,
|
|
0, 2, 2
|
|
)
|
|
else
|
|
love.graphics.draw(
|
|
blocks[self.skin][self.colour],
|
|
64+x*16+partial_das, 16+y*16+gravity_offset
|
|
)
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
return Piece
|