mirror of
https://github.com/SashLilac/cambridge-modpack.git
synced 2024-11-23 07:59:01 -06:00
390 lines
12 KiB
Lua
390 lines
12 KiB
Lua
local GameMode = require 'tetris.modes.gamemode'
|
|
local History6RollsRandomizer = require 'tetris.randomizers.history_6rolls'
|
|
|
|
local MarathonSTGame = GameMode:extend()
|
|
|
|
MarathonSTGame.name = "Marathon ST"
|
|
MarathonSTGame.hash = "MarathonST"
|
|
MarathonSTGame.tagline = "Grade points are heavily boosted! Can you make it to the end?"
|
|
|
|
function MarathonSTGame:new()
|
|
self.super:new()
|
|
|
|
self.roll_frames = 0
|
|
self.combo = 1
|
|
self.randomizer = History6RollsRandomizer()
|
|
self.grade = 0
|
|
self.grade_points = 0
|
|
self.grade_point_decay_counter = 0
|
|
self.grade_point_multiplier = 100
|
|
self.section_start_time = 0
|
|
self.section_boosts = 0
|
|
self.section_boost_status = { [0] = false }
|
|
self.boost_message_time = 0
|
|
|
|
self.lock_drop = true
|
|
self.lock_hard_drop = true
|
|
self.enable_hard_drop = true
|
|
self.enable_hold = true
|
|
self.next_queue_length = 3
|
|
end
|
|
|
|
function MarathonSTGame:getSpeedLevel()
|
|
return self.level + self.section_boosts * 100
|
|
end
|
|
|
|
function MarathonSTGame:getARE()
|
|
local speed_level = self:getSpeedLevel()
|
|
if speed_level < 800 then return 27
|
|
elseif speed_level < 1000 then return 18
|
|
elseif speed_level < 1800 then return 14
|
|
elseif speed_level < 2000 then return 8
|
|
elseif speed_level < 2200 then return 7
|
|
else return 6 end
|
|
end
|
|
|
|
function MarathonSTGame:getLineARE()
|
|
local speed_level = self:getSpeedLevel()
|
|
if speed_level < 600 then return 27
|
|
elseif speed_level < 800 then return 18
|
|
elseif speed_level < 1000 then return 14
|
|
elseif speed_level < 2000 then return 8
|
|
elseif speed_level < 2200 then return 7
|
|
else return 6 end
|
|
end
|
|
|
|
function MarathonSTGame:getDasLimit()
|
|
local speed_level = self:getSpeedLevel()
|
|
if speed_level < 500 then return 14
|
|
elseif speed_level < 2000 then return 9
|
|
else return 7 end
|
|
end
|
|
|
|
function MarathonSTGame:getLockDelay()
|
|
local speed_level = self:getSpeedLevel()
|
|
if speed_level < 1200 then return 30
|
|
elseif speed_level < 1400 then return 26
|
|
elseif speed_level < 1600 then return 22
|
|
elseif speed_level < 1800 then return 18
|
|
elseif speed_level < 2000 then return 17
|
|
else return 15 end
|
|
end
|
|
|
|
function MarathonSTGame:getLineClearDelay()
|
|
local speed_level = self:getSpeedLevel()
|
|
if speed_level < 500 then return 40
|
|
elseif speed_level < 600 then return 25
|
|
elseif speed_level < 800 then return 16
|
|
elseif speed_level < 1000 then return 12
|
|
elseif speed_level < 2000 then return 6
|
|
elseif speed_level < 2200 then return 5
|
|
else return 4 end
|
|
end
|
|
|
|
function MarathonSTGame:getGravity()
|
|
if (self.level < 30) then return 4/256
|
|
elseif (self.level < 35) then return 6/256
|
|
elseif (self.level < 40) then return 8/256
|
|
elseif (self.level < 50) then return 10/256
|
|
elseif (self.level < 60) then return 12/256
|
|
elseif (self.level < 70) then return 16/256
|
|
elseif (self.level < 80) then return 32/256
|
|
elseif (self.level < 90) then return 48/256
|
|
elseif (self.level < 100) then return 64/256
|
|
elseif (self.level < 120) then return 80/256
|
|
elseif (self.level < 140) then return 96/256
|
|
elseif (self.level < 160) then return 112/256
|
|
elseif (self.level < 170) then return 128/256
|
|
elseif (self.level < 200) then return 144/256
|
|
elseif (self.level < 220) then return 4/256
|
|
elseif (self.level < 230) then return 32/256
|
|
elseif (self.level < 233) then return 64/256
|
|
elseif (self.level < 236) then return 96/256
|
|
elseif (self.level < 239) then return 128/256
|
|
elseif (self.level < 243) then return 160/256
|
|
elseif (self.level < 247) then return 192/256
|
|
elseif (self.level < 251) then return 224/256
|
|
elseif (self.level < 300) then return 1
|
|
elseif (self.level < 330) then return 2
|
|
elseif (self.level < 360) then return 3
|
|
elseif (self.level < 400) then return 4
|
|
elseif (self.level < 420) then return 5
|
|
elseif (self.level < 450) then return 4
|
|
elseif (self.level < 500) then return 3
|
|
else return 20 end
|
|
end
|
|
|
|
function MarathonSTGame:advanceOneFrame()
|
|
if self.clear then
|
|
self.roll_frames = self.roll_frames + 1
|
|
if self.roll_frames < 0 then
|
|
if self.roll_frames + 1 == 0 then
|
|
switchBGM("credit_roll", "gm3")
|
|
return true
|
|
end
|
|
return false
|
|
end
|
|
if self.roll_frames > 3694 then
|
|
switchBGM(nil)
|
|
self.completed = true
|
|
end
|
|
elseif self.ready_frames == 0 then
|
|
self.frames = self.frames + 1
|
|
end
|
|
return true
|
|
end
|
|
|
|
function MarathonSTGame:onPieceEnter()
|
|
if self.level % 100 ~= 99 and not self.clear and self.frames ~= 0 then
|
|
self.level = self.level + 1
|
|
end
|
|
end
|
|
|
|
function MarathonSTGame:onPieceLock(piece, cleared_row_count)
|
|
MarathonSTGame.super:onPieceLock(piece, cleared_row_count)
|
|
self:updateGrade(cleared_row_count)
|
|
self:updateSectionTimes(self.level, self.level + cleared_row_count)
|
|
self.level = math.min(self.level + cleared_row_count, 1500)
|
|
if self.level == 1500 and not self.clear then
|
|
self.clear = true
|
|
self.grid:clear()
|
|
self.roll_frames = -150
|
|
switchBGM(nil)
|
|
end
|
|
end
|
|
|
|
local section_boost_requirements = {
|
|
[0] = frameTime(0,60), frameTime(0,57), frameTime(0,54), frameTime(0,51), frameTime(0,48),
|
|
frameTime(0,45), frameTime(0,42), frameTime(0,39), frameTime(0,36)
|
|
}
|
|
|
|
function MarathonSTGame:updateSectionTimes(old_level, new_level)
|
|
if self.clear then return end
|
|
if math.floor(old_level / 100) < math.floor(new_level / 100) then
|
|
-- record new section
|
|
local section_time = self.frames - self.section_start_time
|
|
table.insert(self.section_times, section_time)
|
|
self.section_start_time = self.frames
|
|
if (
|
|
old_level >= 600 and
|
|
math.floor(self:getSpeedLevel() / 100) % 2 == 0 and
|
|
section_time <= section_boost_requirements[self.section_boosts]
|
|
) then
|
|
self.section_boosts = self.section_boosts + 1
|
|
table.insert(self.section_boost_status, true)
|
|
self.grade_point_multiplier = self.grade_point_multiplier + (
|
|
self.section_boosts == 9 and 12 or 11
|
|
)
|
|
self.boost_message_time = 180
|
|
else
|
|
table.insert(self.section_boost_status, false)
|
|
end
|
|
end
|
|
end
|
|
|
|
local grade_point_bonuses = {
|
|
{10, 20, 40, 50},
|
|
{10, 20, 30, 40},
|
|
{10, 20, 30, 40},
|
|
{10, 15, 30, 40},
|
|
{10, 15, 20, 40},
|
|
{5, 15, 20, 30},
|
|
{5, 10, 20, 30},
|
|
{5, 10, 15, 30},
|
|
{5, 10, 15, 30},
|
|
{5, 10, 15, 30},
|
|
{2, 12, 13, 30},
|
|
}
|
|
|
|
local grade_point_decays = {
|
|
125, 80, 80, 50, 45, 45, 45,
|
|
40, 40, 40, 40, 40, 30, 30, 30,
|
|
20, 20, 20, 20, 20,
|
|
15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
|
|
10, 10
|
|
}
|
|
|
|
local combo_multipliers = {
|
|
{1.0, 1.0, 1.0, 1.0},
|
|
{1.0, 1.2, 1.4, 1.5},
|
|
{1.0, 1.2, 1.5, 1.8},
|
|
{1.0, 1.4, 1.6, 2.0},
|
|
{1.0, 1.4, 1.7, 2.2},
|
|
{1.0, 1.4, 1.8, 2.3},
|
|
{1.0, 1.4, 1.9, 2.4},
|
|
{1.0, 1.5, 2.0, 2.5},
|
|
{1.0, 1.5, 2.1, 2.6},
|
|
{1.0, 2.0, 2.5, 3.0},
|
|
}
|
|
|
|
function MarathonSTGame:whilePieceActive()
|
|
if self.clear then return end
|
|
if self.combo <= 1 then
|
|
self.grade_point_decay_counter = self.grade_point_decay_counter + 1
|
|
end
|
|
if self.grade_point_decay_counter >= grade_point_decays[self.grade + 1] then
|
|
self.grade_point_decay_counter = 0
|
|
self.grade_points = math.max(0, self.grade_points - 1)
|
|
end
|
|
end
|
|
|
|
function MarathonSTGame:updateGrade(cleared_lines)
|
|
if cleared_lines == 0 then
|
|
self.combo = 1
|
|
else
|
|
self.grade_points = self.grade_points + (
|
|
math.ceil(
|
|
grade_point_bonuses[math.min(self.grade + 1, 11)][math.min(cleared_lines, 4)] *
|
|
combo_multipliers[math.min(self.combo, 10)][math.min(cleared_lines, 4)] *
|
|
(self.grade_point_multiplier / 100) ^ (self.section_boosts == 9 and 2 or 1) *
|
|
(self.clear and 2 or 1)
|
|
)
|
|
)
|
|
if self.grade_points >= 100 and self.grade < 33 then
|
|
self.grade_points = 0
|
|
self.grade = self.grade + 1
|
|
end
|
|
if cleared_lines > 1 then
|
|
self.combo = self.combo + 1
|
|
end
|
|
end
|
|
end
|
|
|
|
local master_grades = { "M", "MK", "MJ", "MV", "MO", "MM" }
|
|
|
|
function MarathonSTGame:getLetterGrade()
|
|
if self.grade < 9 then
|
|
return tostring(9 - self.grade)
|
|
elseif self.grade < 18 then
|
|
return "S" .. tostring(self.grade - 8)
|
|
elseif self.grade < 27 then
|
|
return "M" .. tostring(self.grade - 17)
|
|
elseif self.grade < 33 then
|
|
return master_grades[self.grade - 26]
|
|
elseif self.grade >= 33 and (not self.completed or self.section_boosts < 9) then
|
|
return "MM+"
|
|
else
|
|
return "GM"
|
|
end
|
|
end
|
|
|
|
local function rollOpacityFunction(game, block, x, y, age)
|
|
if game.section_boosts == 9 then
|
|
return 0.5, 0.5, 0.5, 1 - age / 4, age >= 4 and 0 or 0.64
|
|
else
|
|
local fade_out_frames = 300 - game.section_boosts * 30
|
|
if age < fade_out_frames then
|
|
return 0.5, 0.5, 0.5, 1, 0.64
|
|
elseif age >= fade_out_frames + 60 then
|
|
return 0.5, 0.5, 0.5, 0, 0
|
|
else
|
|
return 0.5, 0.5, 0.5, 1 - (age - fade_out_frames) / 60, 0.64
|
|
end
|
|
end
|
|
end
|
|
|
|
function MarathonSTGame:swapMusic(level)
|
|
if self.ready_frames ~= 0 then return end
|
|
local bgm_table = {
|
|
0, 480, 500, 680,
|
|
700, 880, 900, 1080,
|
|
1100, 1280, 1300, 1480
|
|
}
|
|
for entry, lvl in ipairs(bgm_table) do
|
|
if (level >= lvl and self.bgm_progression < entry) then
|
|
if entry % 2 == 0 then
|
|
fadeoutBGM(0.5)
|
|
else
|
|
switchBGMLoop(0.5 * (entry - 1) + 1)
|
|
end
|
|
self.bgm_progression = entry
|
|
end
|
|
end
|
|
end
|
|
|
|
function MarathonSTGame:drawGrid()
|
|
if self.clear and not (self.game_over or self.completed) then
|
|
self.grid:drawCustom(rollOpacityFunction, self)
|
|
else
|
|
self.grid:draw()
|
|
end
|
|
if self.level < 100 then
|
|
self:drawGhostPiece()
|
|
end
|
|
end
|
|
|
|
function MarathonSTGame:sectionColourFunction(section)
|
|
if self.section_boost_status[section] then
|
|
return {0, 1, 0, 1}
|
|
else
|
|
return {1, 1, 1, 1}
|
|
end
|
|
end
|
|
|
|
function MarathonSTGame:drawScoringInfo()
|
|
love.graphics.setColor(1, 1, 1, 1)
|
|
|
|
if config["side_next"] then
|
|
love.graphics.printf("NEXT", 240, 72, 40, "left")
|
|
else
|
|
love.graphics.printf("NEXT", 64, 40, 40, "left")
|
|
end
|
|
|
|
local text_x = config["side_next"] and 316 or 240
|
|
|
|
love.graphics.setFont(font_3x5_2)
|
|
love.graphics.print(
|
|
self.das.direction .. " " ..
|
|
self.das.frames .. " " ..
|
|
strTrueValues(self.prev_inputs)
|
|
)
|
|
love.graphics.printf("GRADE", text_x, 120, 40, "left")
|
|
love.graphics.printf("GRADE POINTS", text_x, 180, 120, "left")
|
|
if self.level >= 600 then
|
|
love.graphics.printf("MULTIPLIER", text_x, 240, 80, "left")
|
|
end
|
|
if self.boost_message_time > 0 then
|
|
love.graphics.setColor(
|
|
self.boost_message_time % 4 < 2 and
|
|
{0.3, 1, 0.3, 1} or
|
|
{1, 1, 1, 1}
|
|
)
|
|
love.graphics.printf("BOOSTED!!", 310, 263, 120, "left")
|
|
love.graphics.setColor(1, 1, 1, 1)
|
|
self.boost_message_time = self.boost_message_time - 1
|
|
end
|
|
love.graphics.printf("LEVEL", text_x, 320, 40, "left")
|
|
|
|
local current_section = math.floor(self.level / 100) + 1
|
|
self:drawSectionTimesWithSplits(current_section, 15)
|
|
|
|
love.graphics.setFont(font_3x5_3)
|
|
love.graphics.printf(self:getLetterGrade(), text_x, 140, 90, "left")
|
|
love.graphics.printf(self.grade_points, text_x, 200, 90, "left")
|
|
if self.level >= 600 then
|
|
love.graphics.printf(string.format("%.02f", self.grade_point_multiplier / 100) .. "x", text_x, 260, 90, "left")
|
|
end
|
|
love.graphics.printf(self.level, text_x, 340, 50, "right")
|
|
love.graphics.printf(self.clear and self.level or self:getSectionEndLevel(), text_x, 370, 50, "right")
|
|
|
|
love.graphics.setFont(font_8x11)
|
|
love.graphics.printf(formatTime(self.frames), 64, 420, 160, "center")
|
|
end
|
|
|
|
function MarathonSTGame:getHighscoreData()
|
|
return {
|
|
grade = self.grade,
|
|
level = self.level,
|
|
frames = self.frames,
|
|
}
|
|
end
|
|
|
|
function MarathonSTGame:getSectionEndLevel()
|
|
return math.floor(self.level / 100 + 1) * 100
|
|
end
|
|
|
|
function MarathonSTGame:getBackground()
|
|
return math.floor(self.level / 100)
|
|
end
|
|
|
|
return MarathonSTGame |