mirror of
https://github.com/SashLilac/cambridge.git
synced 2024-11-22 08:39:03 -06:00
1084 lines
29 KiB
Lua
1084 lines
29 KiB
Lua
local Object = require 'libs.classic'
|
|
require 'funcs'
|
|
|
|
local playedReadySE = false
|
|
local playedGoSE = false
|
|
|
|
local Grid = require 'tetris.components.grid'
|
|
local Randomizer = require 'tetris.randomizers.randomizer'
|
|
local BagRandomizer = require 'tetris.randomizers.bag'
|
|
local binser = require 'libs.binser'
|
|
|
|
local GameMode = Object:extend()
|
|
|
|
GameMode.name = ""
|
|
GameMode.hash = ""
|
|
GameMode.tagline = ""
|
|
GameMode.rollOpacityFunction = function(age) return 0 end
|
|
|
|
function GameMode:new()
|
|
self.replay_inputs = {}
|
|
self.random_low, self.random_high = love.math.getRandomSeed()
|
|
self.random_state = love.math.getRandomState()
|
|
self.save_replay = config.gamesettings.save_replay == 1
|
|
|
|
self.grid = Grid(10, 24)
|
|
self.randomizer = Randomizer()
|
|
self.piece = nil
|
|
self.ready_frames = 100
|
|
self.frames = 0
|
|
self.game_over_frames = 0
|
|
self.score = 0
|
|
self.level = 0
|
|
self.lines = 0
|
|
self.squares = 0
|
|
self.drop_bonus = 0
|
|
self.are = 0
|
|
self.lcd = 0
|
|
self.das = { direction = "none", frames = -1 }
|
|
self.move = "none"
|
|
self.prev_inputs = {}
|
|
self.next_queue = {}
|
|
self.game_over = false
|
|
self.clear = false
|
|
self.completed = false
|
|
-- configurable parameters
|
|
self.lock_drop = false
|
|
self.lock_hard_drop = false
|
|
self.instant_hard_drop = false
|
|
self.instant_soft_drop = true
|
|
self.enable_hold = false
|
|
self.enable_hard_drop = true
|
|
self.next_queue_length = 1
|
|
self.additive_gravity = true
|
|
self.classic_lock = false
|
|
self.draw_section_times = false
|
|
self.draw_secondary_section_times = false
|
|
self.big_mode = false
|
|
self.irs = true
|
|
self.ihs = true
|
|
self.square_mode = false
|
|
self.immobile_spin_bonus = false
|
|
self.rpc_details = "In game"
|
|
self.SGnames = {
|
|
"9", "8", "7", "6", "5", "4", "3", "2", "1",
|
|
"S1", "S2", "S3", "S4", "S5", "S6", "S7", "S8", "S9",
|
|
"GM"
|
|
}
|
|
-- variables related to configurable parameters
|
|
self.drop_locked = false
|
|
self.hard_drop_locked = false
|
|
self.lock_on_soft_drop = false
|
|
self.lock_on_hard_drop = false
|
|
self.cleared_block_table = {}
|
|
self.last_lcd = 0
|
|
self.used_randomizer = nil
|
|
self.hold_queue = nil
|
|
self.held = false
|
|
self.section_start_time = 0
|
|
self.section_times = { [0] = 0 }
|
|
self.secondary_section_times = { [0] = 0 }
|
|
end
|
|
|
|
function GameMode:getARR() return 1 end
|
|
function GameMode:getDropSpeed() return 1 end
|
|
function GameMode:getARE() return 25 end
|
|
function GameMode:getLineARE() return 25 end
|
|
function GameMode:getLockDelay() return 30 end
|
|
function GameMode:getLineClearDelay() return 40 end
|
|
function GameMode:getDasLimit() return 15 end
|
|
function GameMode:getDasCutDelay() return 0 end
|
|
function GameMode:getGravity() return 1/64 end
|
|
|
|
function GameMode:getNextPiece(ruleset)
|
|
local shape = self.used_randomizer:nextPiece()
|
|
return {
|
|
skin = self:getSkin(),
|
|
shape = shape,
|
|
orientation = ruleset:getDefaultOrientation(shape),
|
|
}
|
|
end
|
|
|
|
function GameMode:getSkin()
|
|
return "2tie"
|
|
end
|
|
|
|
function GameMode:initialize(ruleset)
|
|
-- generate next queue
|
|
self.used_randomizer = (
|
|
table.equalvalues(
|
|
table.keys(ruleset.colourscheme),
|
|
self.randomizer.possible_pieces
|
|
) and
|
|
self.randomizer or BagRandomizer(table.keys(ruleset.colourscheme))
|
|
)
|
|
self.ruleset = ruleset
|
|
for i = 1, math.max(self.next_queue_length, 1) do
|
|
table.insert(self.next_queue, self:getNextPiece(ruleset))
|
|
end
|
|
self.lock_on_soft_drop = ({ruleset.softdrop_lock, self.instant_soft_drop, false, true })[config.gamesettings.manlock]
|
|
self.lock_on_hard_drop = ({ruleset.harddrop_lock, self.instant_hard_drop, true, false})[config.gamesettings.manlock]
|
|
end
|
|
|
|
function GameMode:saveReplay()
|
|
-- Save replay.
|
|
local replay = {}
|
|
replay["inputs"] = self.replay_inputs
|
|
replay["random_low"] = self.random_low
|
|
replay["random_high"] = self.random_high
|
|
replay["random_state"] = self.random_state
|
|
replay["mode"] = self.name
|
|
replay["ruleset"] = self.ruleset.name
|
|
replay["timer"] = self.frames
|
|
replay["score"] = self.score
|
|
replay["level"] = self.level
|
|
replay["lines"] = self.lines
|
|
replay["gamesettings"] = config.gamesettings
|
|
replay["secret_inputs"] = self.secret_inputs
|
|
replay["delayed_auto_shift"] = config.das
|
|
replay["auto_repeat_rate"] = config.arr
|
|
replay["das_cut_delay"] = config.dcd
|
|
replay["timestamp"] = os.time()
|
|
replay["pause_count"] = self.pause_count
|
|
replay["pause_time"] = self.pause_time
|
|
if love.filesystem.getInfo("replays") == nil then
|
|
love.filesystem.createDirectory("replays")
|
|
end
|
|
local init_name = string.format("replays/%s.crp", os.date("%Y-%m-%d_%H-%M-%S"))
|
|
local replay_name = init_name
|
|
local replay_number = 0
|
|
while true do
|
|
if love.filesystem.getInfo(replay_name, "file") then
|
|
replay_number = replay_number + 1
|
|
replay_name = string.format("%s (%d)", init_name, replay_number)
|
|
else
|
|
break
|
|
end
|
|
end
|
|
love.filesystem.write(replay_name, binser.serialize(replay))
|
|
end
|
|
|
|
function GameMode:addReplayInput(inputs)
|
|
-- check if inputs have changed since last frame
|
|
if not equals(self.prev_inputs, inputs) then
|
|
-- insert new inputs into replay inputs table
|
|
local new_inputs = {}
|
|
new_inputs["inputs"] = {}
|
|
new_inputs["frames"] = 1
|
|
for key, value in pairs(inputs) do
|
|
new_inputs["inputs"][key] = value
|
|
end
|
|
self.replay_inputs[#self.replay_inputs + 1] = new_inputs
|
|
else
|
|
-- add 1 to input frame counter
|
|
self.replay_inputs[#self.replay_inputs]["frames"] = self.replay_inputs[#self.replay_inputs]["frames"] + 1
|
|
end
|
|
end
|
|
|
|
function GameMode:update(inputs, ruleset)
|
|
if self.game_over or self.completed then
|
|
if self.save_replay and self.game_over_frames == 0 then
|
|
self:saveReplay()
|
|
end
|
|
self.game_over_frames = self.game_over_frames + 1
|
|
return
|
|
end
|
|
|
|
if config.gamesettings.diagonal_input == 2 then
|
|
if inputs["left"] or inputs["right"] then
|
|
inputs["up"] = false
|
|
inputs["down"] = false
|
|
elseif inputs["down"] then
|
|
inputs["up"] = false
|
|
end
|
|
end
|
|
|
|
if self.save_replay then self:addReplayInput(inputs) end
|
|
|
|
-- advance one frame
|
|
if self:advanceOneFrame(inputs, ruleset) == false then return end
|
|
|
|
self:chargeDAS(inputs, self:getDasLimit(), self:getARR())
|
|
|
|
-- set attempt flags
|
|
if inputs["left"] or inputs["right"] then self:onAttemptPieceMove(self.piece, self.grid) end
|
|
if (
|
|
inputs["rotate_left"] or inputs["rotate_right"] or
|
|
inputs["rotate_left2"] or inputs["rotate_right2"] or
|
|
inputs["rotate_180"]
|
|
) then
|
|
self:onAttemptPieceRotate(self.piece, self.grid)
|
|
end
|
|
|
|
if self.piece == nil then
|
|
self:processDelays(inputs, ruleset)
|
|
else
|
|
-- perform active frame actions such as fading out the next queue
|
|
self:whilePieceActive()
|
|
|
|
if self.enable_hold and inputs["hold"] == true and self.held == false and self.prev_inputs["hold"] == false then
|
|
self:hold(inputs, ruleset)
|
|
self.prev_inputs = inputs
|
|
return
|
|
end
|
|
|
|
if (self.lock_drop or (
|
|
not ruleset.are or self:getARE() == 0
|
|
)) and inputs["down"] ~= true then
|
|
self.drop_locked = false
|
|
end
|
|
|
|
if (self.lock_hard_drop or (
|
|
not ruleset.are or self:getARE() == 0
|
|
)) and inputs["up"] ~= true then
|
|
self.hard_drop_locked = false
|
|
end
|
|
|
|
-- diff vars to use in checks
|
|
local piece_y = self.piece.position.y
|
|
local piece_x = self.piece.position.x
|
|
local piece_rot = self.piece.rotation
|
|
|
|
ruleset:processPiece(
|
|
inputs, self.piece, self.grid, self:getGravity(), self.prev_inputs,
|
|
(
|
|
inputs.up and self.lock_on_hard_drop and not self.hard_drop_locked
|
|
) and "none" or self.move,
|
|
self:getLockDelay(), self:getDropSpeed(),
|
|
self.drop_locked, self.hard_drop_locked,
|
|
self.enable_hard_drop, self.additive_gravity, self.classic_lock
|
|
)
|
|
|
|
local piece_dy = self.piece.position.y - piece_y
|
|
local piece_dx = self.piece.position.x - piece_x
|
|
local piece_drot = self.piece.rotation - piece_rot
|
|
|
|
-- das cut
|
|
if (
|
|
(piece_dy ~= 0 and (inputs.up or inputs.down)) or
|
|
(piece_drot ~= 0 and (
|
|
inputs.rotate_left or inputs.rotate_right or
|
|
inputs.rotate_left2 or inputs.rotate_right2 or
|
|
inputs.rotate_180
|
|
))
|
|
) then
|
|
self:dasCut()
|
|
end
|
|
|
|
if (piece_dx ~= 0) then
|
|
self.piece.last_rotated = false
|
|
self:onPieceMove(self.piece, self.grid, piece_dx)
|
|
end
|
|
if (piece_dy ~= 0) then
|
|
self.piece.last_rotated = false
|
|
self:onPieceDrop(self.piece, self.grid, piece_dy)
|
|
end
|
|
if (piece_drot ~= 0) then
|
|
self.piece.last_rotated = true
|
|
self:onPieceRotate(self.piece, self.grid, piece_drot)
|
|
end
|
|
|
|
if inputs["up"] == true and
|
|
self.piece:isDropBlocked(self.grid) and
|
|
not self.hard_drop_locked then
|
|
self:onHardDrop(piece_dy)
|
|
if self.lock_on_hard_drop then
|
|
self.piece_hard_dropped = true
|
|
self.piece.locked = true
|
|
end
|
|
end
|
|
|
|
if inputs["down"] == true then
|
|
if not (
|
|
self.piece:isDropBlocked(self.grid) and
|
|
piece_drot ~= 0
|
|
) then
|
|
self:onSoftDrop(piece_dy)
|
|
end
|
|
if self.piece:isDropBlocked(self.grid) and
|
|
not self.drop_locked and
|
|
self.lock_on_soft_drop
|
|
then
|
|
self.piece.locked = true
|
|
self.piece_soft_locked = true
|
|
end
|
|
end
|
|
|
|
if self.piece.locked == true then
|
|
-- spin detection, immobile only for now
|
|
if self.immobile_spin_bonus and
|
|
self.piece.last_rotated and (
|
|
self.piece:isDropBlocked(self.grid) and
|
|
self.piece:isMoveBlocked(self.grid, { x=-1, y=0 }) and
|
|
self.piece:isMoveBlocked(self.grid, { x=1, y=0 }) and
|
|
self.piece:isMoveBlocked(self.grid, { x=0, y=-1 })
|
|
) then
|
|
self.piece.spin = true
|
|
end
|
|
|
|
self.grid:applyPiece(self.piece)
|
|
|
|
-- mark squares (can be overridden)
|
|
if self.square_mode then
|
|
self.squares = self.squares + self.grid:markSquares()
|
|
end
|
|
|
|
local cleared_row_count = self.grid:getClearedRowCount()
|
|
self:onPieceLock(self.piece, cleared_row_count)
|
|
self:updateScore(self.level, self.drop_bonus, cleared_row_count)
|
|
|
|
self.cleared_block_table = self.grid:markClearedRows()
|
|
self.piece = nil
|
|
if self.enable_hold then
|
|
self.held = false
|
|
end
|
|
|
|
if cleared_row_count > 0 then
|
|
local row_count_names = {"single","double","triple","quad"}
|
|
playSE("erase",row_count_names[cleared_row_count] or "quad")
|
|
self.lcd = self:getLineClearDelay()
|
|
self.last_lcd = self.lcd
|
|
self.are = (
|
|
ruleset.are and self:getLineARE() or 0
|
|
)
|
|
if self.lcd == 0 then
|
|
self.grid:clearClearedRows()
|
|
self:afterLineClear(cleared_row_count)
|
|
if self.are == 0 then
|
|
self:initializeOrHold(inputs, ruleset)
|
|
end
|
|
end
|
|
self:onLineClear(cleared_row_count)
|
|
else
|
|
if self:getARE() == 0 or not ruleset.are then
|
|
self:initializeOrHold(inputs, ruleset)
|
|
else
|
|
self.are = self:getARE()
|
|
end
|
|
end
|
|
end
|
|
end
|
|
self.prev_inputs = inputs
|
|
end
|
|
|
|
function GameMode:updateScore() end
|
|
|
|
function GameMode:advanceOneFrame()
|
|
if self.clear then
|
|
self.completed = true
|
|
elseif self.ready_frames == 0 then
|
|
self.frames = self.frames + 1
|
|
end
|
|
end
|
|
|
|
-- event functions
|
|
function GameMode:whilePieceActive() end
|
|
function GameMode:onAttemptPieceMove(piece, grid) end
|
|
function GameMode:onAttemptPieceRotate(piece, grid) end
|
|
function GameMode:onPieceMove(piece, grid, dx) end
|
|
function GameMode:onPieceRotate(piece, grid, drot) end
|
|
function GameMode:onPieceDrop(piece, grid, dy) end
|
|
function GameMode:onPieceLock(piece, cleared_row_count)
|
|
playSE("lock")
|
|
end
|
|
|
|
function GameMode:onLineClear(cleared_row_count) end
|
|
function GameMode:afterLineClear(cleared_row_count) end
|
|
|
|
function GameMode:onPieceEnter() end
|
|
function GameMode:onHold() end
|
|
|
|
function GameMode:onSoftDrop(dropped_row_count)
|
|
self.drop_bonus = self.drop_bonus + (
|
|
(self.piece.big and 2 or 1) * dropped_row_count
|
|
)
|
|
end
|
|
|
|
function GameMode:onHardDrop(dropped_row_count)
|
|
self:onSoftDrop(dropped_row_count * 2)
|
|
end
|
|
|
|
function GameMode:onGameOver()
|
|
switchBGM(nil)
|
|
local alpha = 0
|
|
local animation_length = 120
|
|
if self.game_over_frames < animation_length then
|
|
-- Show field for a bit, then fade out.
|
|
alpha = math.pow(2048, self.game_over_frames/animation_length - 1)
|
|
elseif self.game_over_frames < 2 * animation_length then
|
|
-- Keep field hidden for a short time, then pop it back in (for screenshots).
|
|
alpha = 1
|
|
end
|
|
love.graphics.setColor(0, 0, 0, alpha)
|
|
love.graphics.rectangle(
|
|
"fill", 64, 80,
|
|
16 * self.grid.width, 16 * (self.grid.height - 4)
|
|
)
|
|
end
|
|
|
|
function GameMode:onGameComplete()
|
|
self:onGameOver()
|
|
end
|
|
|
|
function GameMode:onExit() end
|
|
|
|
-- DAS functions
|
|
|
|
function GameMode:startRightDAS()
|
|
self.move = "right"
|
|
self.das = { direction = "right", frames = 0 }
|
|
if self:getDasLimit() == 0 then
|
|
self:continueDAS()
|
|
end
|
|
end
|
|
|
|
function GameMode:startLeftDAS()
|
|
self.move = "left"
|
|
self.das = { direction = "left", frames = 0 }
|
|
if self:getDasLimit() == 0 then
|
|
self:continueDAS()
|
|
end
|
|
end
|
|
|
|
function GameMode:continueDAS()
|
|
local das_frames = self.das.frames + 1
|
|
if das_frames >= self:getDasLimit() then
|
|
if self.das.direction == "left" then
|
|
self.move = (self:getARR() == 0 and "speed" or "") .. "left"
|
|
self.das.frames = self:getDasLimit() - self:getARR()
|
|
elseif self.das.direction == "right" then
|
|
self.move = (self:getARR() == 0 and "speed" or "") .. "right"
|
|
self.das.frames = self:getDasLimit() - self:getARR()
|
|
end
|
|
else
|
|
self.move = "none"
|
|
self.das.frames = das_frames
|
|
end
|
|
end
|
|
|
|
function GameMode:stopDAS()
|
|
self.move = "none"
|
|
self.das = { direction = "none", frames = -1 }
|
|
end
|
|
|
|
function GameMode:chargeDAS(inputs)
|
|
if config.gamesettings.das_last_key == 2 then
|
|
if inputs["right"] == true and self.das.direction ~= "right" and not self.prev_inputs["right"] then
|
|
self:startRightDAS()
|
|
elseif inputs["left"] == true and self.das.direction ~= "left" and not self.prev_inputs["left"] then
|
|
self:startLeftDAS()
|
|
elseif inputs[self.das.direction] == true then
|
|
self:continueDAS()
|
|
else
|
|
self:stopDAS()
|
|
end
|
|
else -- default behaviour, das first key pressed
|
|
if inputs[self.das.direction] == true then
|
|
self:continueDAS()
|
|
elseif inputs["right"] == true then
|
|
self:startRightDAS()
|
|
elseif inputs["left"] == true then
|
|
self:startLeftDAS()
|
|
else
|
|
self:stopDAS()
|
|
end
|
|
end
|
|
end
|
|
|
|
function GameMode:dasCut()
|
|
self.das.frames = math.max(
|
|
self.das.frames - self:getDasCutDelay(),
|
|
-(self:getDasCutDelay() + 1)
|
|
)
|
|
end
|
|
|
|
function GameMode:areCancel(inputs, ruleset)
|
|
if ruleset.are_cancel and strTrueValues(inputs) ~= "" and
|
|
not self.prev_inputs.up and
|
|
(self.piece_hard_dropped or
|
|
(self.piece_soft_locked and not self.prev_inputs.down)) then
|
|
self.lcd = 0
|
|
self.are = 0
|
|
end
|
|
end
|
|
|
|
function GameMode:checkBufferedInputs(inputs)
|
|
if (
|
|
config.gamesettings.buffer_lock ~= 1 and
|
|
not self.prev_inputs["up"] and inputs["up"] and
|
|
self.enable_hard_drop
|
|
) then
|
|
self.buffer_hard_drop = true
|
|
end
|
|
if (
|
|
config.gamesettings.buffer_lock ~= 1 and
|
|
not self.prev_inputs["down"] and inputs["down"]
|
|
) then
|
|
self.buffer_soft_drop = true
|
|
end
|
|
end
|
|
|
|
function GameMode:processDelays(inputs, ruleset, drop_speed)
|
|
if self.ready_frames == 100 then
|
|
playedReadySE = false
|
|
playedGoSE = false
|
|
end
|
|
if self.ready_frames > 0 then
|
|
self:checkBufferedInputs(inputs)
|
|
if not playedReadySE then
|
|
playedReadySE = true
|
|
playSEOnce("ready")
|
|
end
|
|
self.ready_frames = self.ready_frames - 1
|
|
if self.ready_frames == 50 and not playedGoSE then
|
|
playedGoSE = true
|
|
playSEOnce("go")
|
|
end
|
|
if self.ready_frames == 0 then
|
|
self:initializeOrHold(inputs, ruleset)
|
|
end
|
|
elseif self.lcd > 0 then
|
|
self:checkBufferedInputs(inputs)
|
|
self.lcd = self.lcd - 1
|
|
self:areCancel(inputs, ruleset)
|
|
if self.lcd == 0 then
|
|
local cleared_row_count = self.grid:getClearedRowCount()
|
|
self.grid:clearClearedRows()
|
|
self:afterLineClear(cleared_row_count)
|
|
playSE("fall")
|
|
if self.are == 0 then
|
|
self:initializeOrHold(inputs, ruleset)
|
|
end
|
|
end
|
|
elseif self.are > 0 then
|
|
self:checkBufferedInputs(inputs)
|
|
self.are = self.are - 1
|
|
self:areCancel(inputs, ruleset)
|
|
if self.are == 0 then
|
|
self:initializeOrHold(inputs, ruleset)
|
|
end
|
|
end
|
|
end
|
|
|
|
function GameMode:initializeOrHold(inputs, ruleset)
|
|
if (
|
|
(self.frames == 0 or (ruleset.are and self:getARE() ~= 0))
|
|
and self.ihs or false
|
|
) and self.enable_hold and inputs["hold"] == true then
|
|
self:hold(inputs, ruleset, true)
|
|
else
|
|
self:initializeNextPiece(inputs, ruleset, self.next_queue[1])
|
|
end
|
|
self:onPieceEnter()
|
|
self:onEnterOrHold(inputs, ruleset)
|
|
end
|
|
|
|
function GameMode:hold(inputs, ruleset, ihs)
|
|
local data = copy(self.hold_queue)
|
|
if self.piece == nil then
|
|
self.hold_queue = self.next_queue[1]
|
|
table.remove(self.next_queue, 1)
|
|
table.insert(self.next_queue, self:getNextPiece(ruleset))
|
|
else
|
|
self.hold_queue = {
|
|
skin = self.piece.skin,
|
|
shape = self.piece.shape,
|
|
orientation = ruleset:getDefaultOrientation(self.piece.shape),
|
|
}
|
|
end
|
|
if data == nil then
|
|
self:initializeNextPiece(inputs, ruleset, self.next_queue[1])
|
|
else
|
|
self:initializeNextPiece(inputs, ruleset, data, false)
|
|
end
|
|
self.held = true
|
|
self:onHold()
|
|
if ihs then
|
|
playSE("ihs")
|
|
else
|
|
playSE("hold")
|
|
self:onEnterOrHold(inputs, ruleset)
|
|
end
|
|
end
|
|
|
|
function GameMode:onEnterOrHold(inputs, ruleset)
|
|
if not self.grid:canPlacePiece(self.piece) then
|
|
self.game_over = true
|
|
return
|
|
elseif self.piece:isDropBlocked(self.grid) then
|
|
playSE("bottom")
|
|
end
|
|
ruleset:dropPiece(
|
|
inputs, self.piece, self.grid, self:getGravity(),
|
|
self:getDropSpeed(), self.drop_locked, self.hard_drop_locked
|
|
)
|
|
end
|
|
|
|
function GameMode:initializeNextPiece(
|
|
inputs, ruleset, piece_data, generate_next_piece
|
|
)
|
|
if not self.buffer_soft_drop and self.lock_drop or (
|
|
not ruleset.are or self:getARE() == 0
|
|
) then
|
|
self.drop_locked = true
|
|
end
|
|
if not self.buffer_hard_drop and self.lock_hard_drop or (
|
|
not ruleset.are or self:getARE() == 0
|
|
) then
|
|
self.hard_drop_locked = true
|
|
end
|
|
self.piece = ruleset:initializePiece(
|
|
inputs, piece_data, self.grid, self:getGravity(),
|
|
self.prev_inputs, self.move,
|
|
self:getLockDelay(), self:getDropSpeed(),
|
|
self.drop_locked, self.hard_drop_locked, self.big_mode,
|
|
(
|
|
self.frames == 0 or (ruleset.are and self:getARE() ~= 0)
|
|
) and self.irs or false
|
|
)
|
|
if config.gamesettings.buffer_lock == 3 then
|
|
if self.buffer_hard_drop then
|
|
local prev_y = self.piece.position.y
|
|
self.piece:dropToBottom(self.grid)
|
|
self.piece.locked = self.lock_on_hard_drop
|
|
self:onHardDrop(self.piece.position.y - prev_y)
|
|
end
|
|
if (
|
|
self.buffer_soft_drop and
|
|
self.lock_on_soft_drop and
|
|
self:getGravity() >= self.grid.height - 4
|
|
) then
|
|
self.piece.locked = true
|
|
end
|
|
end
|
|
self.piece_hard_dropped = false
|
|
self.piece_soft_locked = false
|
|
self.buffer_hard_drop = false
|
|
self.buffer_soft_drop = false
|
|
if generate_next_piece == nil then
|
|
table.remove(self.next_queue, 1)
|
|
table.insert(self.next_queue, self:getNextPiece(ruleset))
|
|
end
|
|
self:playNextSound(ruleset)
|
|
end
|
|
|
|
function GameMode:playNextSound(ruleset)
|
|
playSE("blocks", ruleset.next_sounds[self.next_queue[1].shape])
|
|
end
|
|
|
|
function GameMode:getHighScoreData()
|
|
return {
|
|
score = self.score
|
|
}
|
|
end
|
|
|
|
function GameMode:animation(x, y, skin, colour)
|
|
-- Animation progress where 0 = start and 1 = end
|
|
local progress = 1
|
|
if self.last_lcd ~= 0 then
|
|
progress = (self.last_lcd - self.lcd) / self.last_lcd
|
|
end
|
|
-- Convert progress through the animation into an alpha value, with easing
|
|
local alpha = 1 - progress ^ 2
|
|
return {
|
|
1, 1, 1,
|
|
alpha,
|
|
skin, colour,
|
|
48 + x * 16, y * 16
|
|
}
|
|
end
|
|
|
|
function GameMode:canDrawLCA()
|
|
return self.lcd > 0
|
|
end
|
|
|
|
function GameMode:drawLineClearAnimation()
|
|
-- animation function
|
|
-- params: block x, y, skin, colour
|
|
-- returns: table with RGBA, skin, colour, x, y
|
|
|
|
-- Quadratic Fadeout (default)
|
|
--[[
|
|
function animation(x, y, skin, colour)
|
|
-- Animation progress where 0 = start and 1 = end
|
|
local progress = 1
|
|
if self.last_lcd ~= 0 then
|
|
progress = (self.last_lcd - self.lcd) / self.last_lcd
|
|
end
|
|
-- Convert progress through the animation into an alpha value, with easing
|
|
local alpha = 1 - progress ^ 2
|
|
return {
|
|
1, 1, 1,
|
|
alpha,
|
|
skin, colour,
|
|
48 + x * 16, y * 16
|
|
}
|
|
end
|
|
--]]
|
|
|
|
-- Flashy Fadeout
|
|
--[[
|
|
function animation(x, y, skin, colour)
|
|
-- Animation progress where 0 = start and 1 = end
|
|
local progress = 1
|
|
if self.last_lcd ~= 0 then
|
|
progress = (self.last_lcd - self.lcd) / self.last_lcd
|
|
end
|
|
-- Change this number to change "bounciness"
|
|
local bounce = 13
|
|
-- Convert progress through the animation into an alpha value
|
|
local alpha = 0
|
|
-- Cutoff is arbitrary: corresponds to level 500 in Marathon A2
|
|
if self.last_lcd > 25 then
|
|
-- Goes up and down: looks better when animation is long
|
|
alpha = 1 - (bounce * progress^3 - 1.5 * bounce * progress^2 + (0.5 * bounce + 1) * progress)
|
|
else
|
|
-- Always decreasing: looks better when animation is short
|
|
alpha = 1 - progress * progress
|
|
end
|
|
return {
|
|
1, 1, 1,
|
|
alpha,
|
|
skin, colour,
|
|
48 + x * 16, y * 16
|
|
}
|
|
end
|
|
--]]
|
|
|
|
-- Fadeout
|
|
--[[
|
|
function animation(x, y, skin, colour)
|
|
return {
|
|
1, 1, 1,
|
|
-0.25 + 1.25 * (self.lcd / self.last_lcd),
|
|
skin, colour,
|
|
48 + x * 16, y * 16
|
|
}
|
|
end
|
|
--]]
|
|
|
|
-- Flash
|
|
--[[
|
|
function animation(x, y, skin, colour)
|
|
return {
|
|
1, 1, 1,
|
|
self.lcd % 6 < 3 and 1 or 0.25,
|
|
skin, colour,
|
|
48 + x * 16, y * 16
|
|
}
|
|
end
|
|
--]]
|
|
|
|
-- TGM1 pop-out
|
|
--[[
|
|
function animation(x, y, skin, colour)
|
|
local p = 0.5
|
|
local l = (
|
|
(self.last_lcd - self.lcd) / self.last_lcd
|
|
)
|
|
local dx = l * (x - (1 + self.grid.width) / 2)
|
|
local dy = l * (y - (1 + self.grid.height) / 2)
|
|
return {
|
|
1, 1, 1, 1, skin, colour,
|
|
48 + (x + dx) * 16,
|
|
(y + dy) * 16 + (464 / (p - 1)) * l * (p - l)
|
|
}
|
|
end
|
|
--]]
|
|
|
|
for y, row in pairs(self.cleared_block_table) do
|
|
for x, block in pairs(row) do
|
|
local animation_table = self:animation(x, y, block.skin, block.colour)
|
|
love.graphics.setColor(
|
|
animation_table[1], animation_table[2],
|
|
animation_table[3], animation_table[4]
|
|
)
|
|
love.graphics.draw(
|
|
blocks[animation_table[5]][animation_table[6]],
|
|
animation_table[7], animation_table[8]
|
|
)
|
|
end
|
|
end
|
|
end
|
|
|
|
function GameMode:drawPiece()
|
|
if self.piece ~= nil then
|
|
local b = (
|
|
self.classic_lock and
|
|
(
|
|
self.piece:isDropBlocked(self.grid) and
|
|
1 - self.piece.gravity or 1
|
|
) or
|
|
1 - (self.piece.lock_delay / self:getLockDelay())
|
|
)
|
|
self.piece:draw(1, 0.25 + 0.75 * b, self.grid)
|
|
end
|
|
end
|
|
|
|
function GameMode:drawGhostPiece(ruleset)
|
|
if self.piece == nil or not self.grid:canPlacePiece(self.piece) then
|
|
return
|
|
end
|
|
local ghost_piece = self.piece:withOffset({x=0, y=0})
|
|
ghost_piece.ghost = true
|
|
ghost_piece:dropToBottom(self.grid)
|
|
ghost_piece:draw(0.5)
|
|
end
|
|
|
|
function GameMode:drawNextQueue(ruleset)
|
|
local colourscheme
|
|
if table.equalvalues(
|
|
self.used_randomizer.possible_pieces,
|
|
{"I", "J", "L", "O", "S", "T", "Z"}
|
|
) then
|
|
colourscheme = ({ruleset.colourscheme, ColourSchemes.Arika, ColourSchemes.TTC})[config.gamesettings.piece_colour]
|
|
else
|
|
colourscheme = ruleset.colourscheme
|
|
end
|
|
function drawPiece(piece, skin, offsets, pos_x, pos_y)
|
|
for index, offset in pairs(offsets) do
|
|
local x = offset.x + ruleset:getDrawOffset(piece, rotation).x + ruleset.spawn_positions[piece].x
|
|
local y = offset.y + ruleset:getDrawOffset(piece, rotation).y + 4.7
|
|
love.graphics.draw(blocks[skin][colourscheme[piece]], pos_x+x*16, pos_y+y*16)
|
|
end
|
|
end
|
|
for i = 1, self.next_queue_length do
|
|
self:setNextOpacity(i)
|
|
local next_piece = self.next_queue[i].shape
|
|
local skin = self.next_queue[i].skin
|
|
local rotation = self.next_queue[i].orientation
|
|
if config.side_next then -- next at side
|
|
drawPiece(next_piece, skin, ruleset.block_offsets[next_piece][rotation], 192, -16+i*48)
|
|
else -- next at top
|
|
drawPiece(next_piece, skin, ruleset.block_offsets[next_piece][rotation], -16+i*80, -32)
|
|
end
|
|
end
|
|
if self.hold_queue ~= nil and self.enable_hold then
|
|
self:setHoldOpacity()
|
|
drawPiece(
|
|
self.hold_queue.shape,
|
|
self.hold_queue.skin,
|
|
ruleset.block_offsets[self.hold_queue.shape][self.hold_queue.orientation],
|
|
-16, -32
|
|
)
|
|
end
|
|
return false
|
|
end
|
|
|
|
function GameMode:setNextOpacity(i)
|
|
love.graphics.setColor(1, 1, 1, 1)
|
|
end
|
|
|
|
function GameMode:setHoldOpacity()
|
|
local colour = self.held and 0.6 or 1
|
|
love.graphics.setColor(colour, colour, colour, 1)
|
|
end
|
|
|
|
function GameMode:getBackground()
|
|
return 0
|
|
end
|
|
|
|
function GameMode:getHighscoreData()
|
|
return {}
|
|
end
|
|
|
|
function GameMode:drawGrid()
|
|
self.grid:draw()
|
|
end
|
|
|
|
function GameMode:drawScoringInfo()
|
|
love.graphics.setColor(1, 1, 1, 1)
|
|
love.graphics.setFont(font_3x5_2)
|
|
|
|
if config["side_next"] then
|
|
love.graphics.printf("NEXT", 240, 72, 40, "left")
|
|
else
|
|
love.graphics.printf("NEXT", 64, 40, 40, "left")
|
|
end
|
|
|
|
love.graphics.print(
|
|
self.das.direction .. " " ..
|
|
self.das.frames .. " " ..
|
|
strTrueValues(self.prev_inputs) ..
|
|
self.drop_bonus
|
|
)
|
|
|
|
love.graphics.setFont(font_8x11)
|
|
love.graphics.printf(formatTime(self.frames), 64, 420, 160, "center")
|
|
end
|
|
|
|
function GameMode:drawSectionTimes(current_section)
|
|
local section_x = 530
|
|
|
|
for section, time in pairs(self.section_times) do
|
|
if section > 0 then
|
|
love.graphics.printf(formatTime(time), section_x, 40 + 20 * section, 90, "left")
|
|
end
|
|
end
|
|
|
|
love.graphics.printf(formatTime(self.frames - self.section_start_time), section_x, 40 + 20 * current_section, 90, "left")
|
|
end
|
|
|
|
function GameMode:sectionColourFunction(section)
|
|
return { 1, 1, 1, 1 }
|
|
end
|
|
|
|
function GameMode:drawSectionTimesWithSecondary(current_section, section_limit)
|
|
section_limit = section_limit or math.huge
|
|
local section_x = 530
|
|
local section_secondary_x = 440
|
|
|
|
for section, time in pairs(self.section_times) do
|
|
if section > 0 then
|
|
love.graphics.printf(formatTime(time), section_x, 40 + 20 * section, 90, "left")
|
|
end
|
|
end
|
|
|
|
for section, time in pairs(self.secondary_section_times) do
|
|
love.graphics.setColor(self:sectionColourFunction(section))
|
|
if section > 0 then
|
|
love.graphics.printf(formatTime(time), section_secondary_x, 40 + 20 * section, 90, "left")
|
|
end
|
|
love.graphics.setColor(1, 1, 1, 1)
|
|
end
|
|
|
|
local current_x
|
|
if table.getn(self.section_times) < table.getn(self.secondary_section_times) then
|
|
current_x = section_x
|
|
else
|
|
current_x = section_secondary_x
|
|
end
|
|
|
|
if current_section <= section_limit then
|
|
love.graphics.printf(formatTime(self.frames - self.section_start_time), current_x, 40 + 20 * current_section, 90, "left")
|
|
end
|
|
end
|
|
|
|
function GameMode:drawSectionTimesWithSplits(current_section, section_limit)
|
|
section_limit = section_limit or math.huge
|
|
|
|
local section_x = 440
|
|
local split_x = 530
|
|
|
|
local split_time = 0
|
|
|
|
for section, time in pairs(self.section_times) do
|
|
if section > 0 then
|
|
love.graphics.setColor(self:sectionColourFunction(section))
|
|
love.graphics.printf(formatTime(time), section_x, 40 + 20 * section, 90, "left")
|
|
love.graphics.setColor(1, 1, 1, 1)
|
|
split_time = split_time + time
|
|
love.graphics.printf(formatTime(split_time), split_x, 40 + 20 * section, 90, "left")
|
|
end
|
|
end
|
|
|
|
if (current_section <= section_limit) then
|
|
love.graphics.printf(formatTime(self.frames - self.section_start_time), section_x, 40 + 20 * current_section, 90, "left")
|
|
love.graphics.printf(formatTime(self.frames), split_x, 40 + 20 * current_section, 90, "left")
|
|
end
|
|
end
|
|
|
|
function GameMode:drawBackground()
|
|
local id = self:getBackground()
|
|
if type(id) == "number" then id = clamp(id, 0, #backgrounds) end
|
|
love.graphics.setColor(1, 1, 1, 1)
|
|
love.graphics.draw(
|
|
backgrounds[id],
|
|
0, 0, 0,
|
|
0.5, 0.5
|
|
)
|
|
end
|
|
|
|
function GameMode:drawFrame()
|
|
-- game frame
|
|
if self.grid.width == 10 and self.grid.height == 24 then
|
|
love.graphics.draw(misc_graphics["frame"], 48, 64)
|
|
else
|
|
love.graphics.setColor(174/255, 83/255, 76/255, 1)
|
|
love.graphics.setLineWidth(8)
|
|
love.graphics.line(
|
|
60,76,
|
|
68+16*self.grid.width,76,
|
|
68+16*self.grid.width,84+16*(self.grid.height-4),
|
|
60,84+16*(self.grid.height-4),
|
|
60,76
|
|
)
|
|
love.graphics.setColor(203/255, 137/255, 111/255, 1)
|
|
love.graphics.setLineWidth(4)
|
|
love.graphics.line(
|
|
60,76,
|
|
68+16*self.grid.width,76,
|
|
68+16*self.grid.width,84+16*(self.grid.height-4),
|
|
60,84+16*(self.grid.height-4),
|
|
60,76
|
|
)
|
|
love.graphics.setLineWidth(1)
|
|
love.graphics.setColor(0, 0, 0, 200)
|
|
love.graphics.rectangle(
|
|
"fill", 64, 80,
|
|
16 * self.grid.width, 16 * (self.grid.height - 4)
|
|
)
|
|
end
|
|
end
|
|
|
|
function GameMode:drawReadyGo()
|
|
-- ready/go graphics
|
|
love.graphics.setColor(1, 1, 1, 1)
|
|
|
|
if self.ready_frames <= 100 and self.ready_frames > 52 then
|
|
love.graphics.draw(misc_graphics["ready"], 144 - 50, 240 - 14)
|
|
elseif self.ready_frames <= 50 and self.ready_frames > 2 then
|
|
love.graphics.draw(misc_graphics["go"], 144 - 27, 240 - 14)
|
|
end
|
|
end
|
|
|
|
function GameMode:drawCustom() end
|
|
|
|
function GameMode:drawIfPaused()
|
|
love.graphics.setFont(font_3x5_3)
|
|
love.graphics.printf("PAUSED!", 64, 160, 160, "center")
|
|
end
|
|
|
|
-- transforms specified in here will transform the whole screen
|
|
-- if you want a transform for a particular component, push the
|
|
-- default transform by using love.graphics.push(), do your
|
|
-- transform, and then love.graphics.pop() at the end of that
|
|
-- component's draw call!
|
|
function GameMode:transformScreen() end
|
|
|
|
function GameMode:draw(paused)
|
|
self:transformScreen()
|
|
self:drawBackground()
|
|
self:drawFrame()
|
|
self:drawGrid()
|
|
self:drawPiece()
|
|
if self:canDrawLCA() then
|
|
self:drawLineClearAnimation()
|
|
end
|
|
self:drawNextQueue(self.ruleset)
|
|
self:drawScoringInfo()
|
|
self:drawReadyGo()
|
|
self:drawCustom()
|
|
|
|
love.graphics.setColor(1, 1, 1, 1)
|
|
love.graphics.setFont(font_3x5_2)
|
|
if config.gamesettings.display_gamemode == 1 then
|
|
love.graphics.printf(
|
|
self.name .. " - " .. self.ruleset.name,
|
|
0, 460, 640, "left"
|
|
)
|
|
end
|
|
|
|
if paused then
|
|
self:drawIfPaused()
|
|
end
|
|
|
|
if self.completed then
|
|
self:onGameComplete()
|
|
elseif self.game_over then
|
|
self:onGameOver()
|
|
end
|
|
end
|
|
|
|
return GameMode
|