v0.2 release commit - hold piece darken

README.md

@@ -16,6 +16,7 @@ Credits
 - [The Tetra Legends Discord](http://discord.com/invite/7hMx5r2) for supporting me and playtesting!
 - [joezeng](https://github.com/joezeng) for the original project.
 - [Hailey](https://github.com/haileylgbt) for some miscellaneous assets.
+- CylinderKnot for an amazing gamemode.
 - MarkGamed7794 for some miscellaneous contributions.
 - Mizu for the Cambridge logo and the [Cambridge launcher](https://github.com/rexxt/cambridge-launcher).
 - MattMayuga for the Cambridge banner.

main.lua

@@ -30,6 +30,28 @@ function love.load()
 		if config.current_ruleset then current_ruleset = config.current_ruleset end
 		scene = TitleScene()
 	end
+
+	game_modes = {}
+	mode_list = love.filesystem.getDirectoryItems("tetris/modes")
+	for i=1,#mode_list do
+		if(mode_list[i] ~= "gamemode.lua" and mode_list[i] ~= "unrefactored_modes") then
+			game_modes[#game_modes+1] = require ("tetris.modes."..string.sub(mode_list[i],1,-5))
+		end
+	end
+	rulesets = {}
+	rule_list = love.filesystem.getDirectoryItems("tetris/rulesets")
+	for i=1,#rule_list do
+		if(rule_list[i] ~= "ruleset.lua" and rule_list[i] ~= "unrefactored_rulesets") then
+			rulesets[#rulesets+1] = require ("tetris.rulesets."..string.sub(rule_list[i],1,-5))
+		end
+	end
+	--sort mode/rule lists
+	local function padnum(d) return ("%03d%s"):format(#d, d) end
+  	table.sort(game_modes, function(a,b)
+  	return tostring(a.name):gsub("%d+",padnum) < tostring(b.name):gsub("%d+",padnum) end)
+	table.sort(rulesets, function(a,b)
+  	return tostring(a.name):gsub("%d+",padnum) < tostring(b.name):gsub("%d+",padnum) end)
+	
 end
 
 local TARGET_FPS = 60

scene/mode_select.lua

@@ -5,44 +5,6 @@ ModeSelectScene.title = "Game Start"
 current_mode = 1
 current_ruleset = 1
 
-game_modes = {
-	require 'tetris.modes.marathon_2020',
-	require 'tetris.modes.survival_2020',
-	require 'tetris.modes.ck',
-	--require 'tetris.modes.strategy',
-	--require 'tetris.modes.interval_training',
-	--require 'tetris.modes.pacer_test',
-	require 'tetris.modes.demon_mode',
-	require 'tetris.modes.phantom_mania',
-	require 'tetris.modes.phantom_mania2',
-	require 'tetris.modes.phantom_mania_n',
-	require 'tetris.modes.race_40',
-	require 'tetris.modes.marathon_a1',
-	require 'tetris.modes.marathon_a2',
-	require 'tetris.modes.marathon_a3',
-	require 'tetris.modes.marathon_ax4',
-	require 'tetris.modes.marathon_c89',
-	require 'tetris.modes.survival_a1',
-	require 'tetris.modes.survival_a2',
-	require 'tetris.modes.survival_a3',
-	require 'tetris.modes.big_a2',
-	require 'tetris.modes.konoha',
-}
-
-rulesets = {
-	require 'tetris.rulesets.cambridge',
-	require 'tetris.rulesets.arika',
-	require 'tetris.rulesets.arika_ti',
-	require 'tetris.rulesets.ti_srs',
-	require 'tetris.rulesets.arika_ace',
-	require 'tetris.rulesets.arika_ace2',
-	require 'tetris.rulesets.arika_srs',
-	require 'tetris.rulesets.standard_exp',
-	--require 'tetris.rulesets.bonkers',
-	--require 'tetris.rulesets.shirase',
-	--require 'tetris.rulesets.super302',
-}
-
 function ModeSelectScene:new()
 	self.menu_state = {
 		mode = current_mode,
@@ -70,14 +32,14 @@ function ModeSelectScene:render()
 	elseif self.menu_state.select == "ruleset" then
 		love.graphics.setColor(1, 1, 1, 0.25)
 	end
-	love.graphics.rectangle("fill", 20, 78 + 20 * self.menu_state.mode, 240, 22)
+	love.graphics.rectangle("fill", 20, 258, 240, 22)
 
 	if self.menu_state.select == "mode" then
 		love.graphics.setColor(1, 1, 1, 0.25)
 	elseif self.menu_state.select == "ruleset" then
 		love.graphics.setColor(1, 1, 1, 0.5)
 	end
-	love.graphics.rectangle("fill", 340, 78 + 20 * self.menu_state.ruleset, 200, 22)
+	love.graphics.rectangle("fill", 340, 258, 200, 22)
 
 	love.graphics.setColor(1, 1, 1, 1)
 
@@ -85,10 +47,14 @@ function ModeSelectScene:render()
 
 	love.graphics.setFont(font_3x5_2)
 	for idx, mode in pairs(game_modes) do
-		love.graphics.printf(mode.name, 40, 80 + 20 * idx, 200, "left")
+		if(idx >= self.menu_state.mode-9 and idx <= self.menu_state.mode+9) then
+			love.graphics.printf(mode.name, 40, (260 - 20*(self.menu_state.mode)) + 20 * idx, 200, "left")
+		end
 	end
 	for idx, ruleset in pairs(rulesets) do
-		love.graphics.printf(ruleset.name, 360, 80 + 20 * idx, 160, "left")
+		if(idx >= self.menu_state.ruleset-9 and idx <= self.menu_state.ruleset+9) then
+			love.graphics.printf(ruleset.name, 360, (260 - 20*(self.menu_state.ruleset)) + 20 * idx, 160, "left")
+		end
 	end
 end
 

tetris/components/grid.lua

@@ -4,6 +4,7 @@ local Grid = Object:extend()
 
 local empty = { skin = "", colour = "" }
 local oob = { skin = "", colour = "" }
+local block = { skin = "2tie", colour = "X" }
 
 function Grid:new()
 	self.grid = {}
@@ -141,14 +142,34 @@ function Grid:copyBottomRow()
 	self.grid[24] = {empty, empty, empty, empty, empty, empty, empty, empty, empty, empty}
 	self.grid_age[24] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 	for col = 1, 10 do
-		self.grid[24][col] = (self.grid[23][col] == empty) and empty or {
+		self.grid[24][col] = (self.grid[23][col] == empty) and empty or block
-			skin = self.grid[23][col].skin,
-			colour = "X"
-		}
 	end
 	return true
 end
 
+function Grid:garbageRise(row_vals)
+        for row = 1, 23 do
+                self.grid[row] = self.grid[row+1]
+                self.grid_age[row] = self.grid_age[row+1]
+        end
+        self.grid[24] = {empty, empty, empty, empty, empty, empty, empty, empty, empty, empty}
+        self.grid_age[24] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+	for col = 1, 10 do
+		self.grid[24][col] = (row_vals[col] == "e") and empty or block
+	end
+end
+
+function Grid:applyFourWide()
+        for row = 1, 24 do
+                local x = self.grid[row]
+                x[1] = x[1]~=block and block or x[1]
+                x[2] = x[2]~=block and block or x[2]
+                x[3] = x[3]~=block and block or x[3]
+                x[8] = x[8]~=block and block or x[8]
+                x[9] = x[9]~=block and block or x[9]
+                x[10] = x[10]~=block and block or x[10]
+        end
+end
 function Grid:applyPiece(piece)
 	if piece.big then
 		self:applyBigPiece(piece)
@@ -216,7 +237,7 @@ function Grid:checkSecretGrade()
         if(validLine) then
                 sgrade = sgrade + 1
         else
-            -- return sgrade
+            	return sgrade
         end
     end
     --[[
@@ -239,7 +260,7 @@ function Grid:update()
 end
 
 function Grid:draw()
-	for y = 1, 24 do
+	for y = 5, 24 do
 		for x = 1, 10 do
 			if self.grid[y][x] ~= empty then
 				if self.grid_age[y][x] < 1 then
@@ -271,7 +292,7 @@ function Grid:draw()
 end
 
 function Grid:drawInvisible(opacity_function, garbage_opacity_function)
-	for y = 1, 24 do
+	for y = 5, 24 do
 		for x = 1, 10 do
 			if self.grid[y][x] ~= empty then
 				if self.grid[y][x].colour == "X" then

tetris/modes/4wide.lua

@@ -0,0 +1,39 @@
+require 'funcs'
+
+local SurvivalA3Game = require 'tetris.modes.survival_a3'
+
+local FourWideGame = SurvivalA3Game:extend()
+
+FourWideGame.name = "4-wide Simulator"
+FourWideGame.hash = "4wide"
+FourWideGame.tagline = "The board has gotten narrower! Can you survive the increasing speeds?"
+
+function FourWideGame:initialize(ruleset)
+	self.super:initialize(ruleset)
+	self.grid:applyFourWide()
+end
+
+local cleared_row_levels = {1, 2, 4, 6}
+
+function FourWideGame:onLineClear(cleared_row_count)
+	if not self.clear then
+		local new_level = self.level + cleared_row_levels[cleared_row_count]
+		self:updateSectionTimes(self.level, new_level)
+		if new_level >= 1300 or self:hitTorikan(self.level, new_level) then
+            		self.clear = true
+			if new_level >= 1300 then
+				self.level = 1300
+                		self.grid:clear()
+                		self.roll_frames = -150
+            		else
+                		self.game_over = true
+			end
+		else
+			self.level = math.min(new_level, 1300)
+		end
+		self:advanceBottomRow(-cleared_row_count)
+	end
+	self.grid:applyFourWide()
+end
+
+return FourWideGame

tetris/modes/big_a2.lua

@@ -19,13 +19,10 @@ function MarathonA2Game:new()
     self.big_mode = true
 	self.roll_frames = 0
     self.combo = 1
-	self.randomizer = History6RollsRandomizer()
+
 	self.grade = 0
 	self.grade_points = 0
 	self.grade_point_decay_counter = 0
-	self.section_start_time = 0
-	self.section_times = { [0] = 0 }
-	self.section_tetrises = { [0] = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
     
 	self.randomizer = History6RollsRandomizer()
 
@@ -103,11 +100,9 @@ end
 function MarathonA2Game:advanceOneFrame()
 	if self.clear then
 		self.roll_frames = self.roll_frames + 1
+		if self.roll_frames < 0 then return false end
 		if self.roll_frames > 3694 then
 			self.completed = true
-			if self.grade == 32 then
-				self.grade = 33
-			end
 		end
 	elseif self.ready_frames == 0 then
 		self.frames = self.frames + 1
@@ -123,43 +118,29 @@ end
 
 function MarathonA2Game:onLineClear(cleared_row_count)
 	cleared_row_count = cleared_row_count / 2
-    self:updateSectionTimes(self.level, self.level + cleared_row_count)
     self.level = math.min(self.level + cleared_row_count, 999)
     if self.level == 999 and not self.clear then
         self.clear = true
-        if self:qualifiesForMRoll() then
-            self.grade = 32
-        end
         self.grid:clear()
         self.roll_frames = -150
     end
 end
 
 function MarathonA2Game:updateScore(level, drop_bonus, cleared_lines)
-    if self.grid:checkForBravo(cleared_lines) then self.bravo = 4 else self.bravo = 1 end
+	if not self.clear then
 		cleared_lines = cleared_lines / 2
 		self:updateGrade(cleared_lines)
+		if self.grid:checkForBravo(cleared_lines) then self.bravo = 4 else self.bravo = 1 end
 		if cleared_lines > 0 then
+			self.combo = self.combo + (cleared_lines - 1) * 2
 			self.score = self.score + (
-			(math.ceil((level + cleared_lines) / 4) + 2 * drop_bonus) *
+				(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
 				cleared_lines * self.combo * self.bravo
 			)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + 2 * (cleared_lines - 1)
 		else
-		self.drop_bonus = 0
 			self.combo = 1
 		end
-end
+		self.drop_bonus = 0
-
-function MarathonA2Game:updateSectionTimes(old_level, new_level)
-	if self.clear then return end
-	if math.floor(old_level / 100) < math.floor(new_level / 100) or
-	new_level >= 999 then
-		-- record new section
-		section_time = self.frames - self.section_start_time
-		self.section_times[math.floor(old_level / 100)] = section_time
-		self.section_start_time = self.frames
 	end
 end
 
@@ -224,7 +205,7 @@ local grade_conversion = {
 	1, 2, 3, 4, 5, 5, 6, 6, 7, 7,
 	7, 8, 8, 8, 9, 9, 9, 10, 11, 12,
 	12, 12, 13, 13, 14, 14, 15, 15, 16, 16,
-	17, 18, 19
+	17
 }
 
 function MarathonA2Game:updateGrade(cleared_lines)
@@ -249,49 +230,12 @@ function MarathonA2Game:updateGrade(cleared_lines)
 	end
 end
 
-local tetris_requirements = { [0] = 2, 2, 2, 2, 2, 1, 1, 1, 1, 1 }
-
-function MarathonA2Game:qualifiesForMRoll()
-	if not self.clear then return false end
-	-- tetris requirements
-	for section = 0, 9 do
-		if self.section_tetrises[section] < tetris_requirements[section] then
-			return false
-		end
-	end
-	-- section time requirements
-	local section_average = 0
-	for section = 0, 4 do
-		section_average = section_average + self.section_times[section]
-		if self.section_times[section] > frameTime(1,05) then
-			return false
-		end
-	end
-	-- section time average requirements
-	if self.section_times[5] > section_average / 5 then
-		return false
-	end
-	for section = 6, 9 do
-		if self.section_times[section] > self.section_times[section - 1] + 120 then
-			return false
-		end
-	end
-	if self.grade < 17 or self.frames > frameTime(8,45) then
-		return false
-	end
-	return true
-end
-
 function MarathonA2Game:getLetterGrade()
 	local grade = grade_conversion[self.grade]
 	if grade < 9 then
 		return tostring(9 - grade)
 	elseif grade < 18 then
 		return "S" .. tostring(grade - 8)
-	elseif grade == 18 then
-		return "M"
-	else
-		return "GM"
 	end
 end
 
@@ -301,18 +245,9 @@ MarathonA2Game.rollOpacityFunction = function(age)
 	else return 1 - (age - 240) / 60 end
 end
 
-MarathonA2Game.mRollOpacityFunction = function(age)
-	if age > 4 then return 0
-	else return 1 - age / 4 end
-end
-
 function MarathonA2Game:drawGrid(ruleset)
 	if self.clear and not (self.completed or self.game_over) then
-		if self:qualifiesForMRoll() then
-			self.grid:drawInvisible(self.mRollOpacityFunction)
-		else
 		self.grid:drawInvisible(self.rollOpacityFunction)
-		end
 	else
 		self.grid:draw()
 		if self.piece ~= nil and self.level < 100 then
@@ -336,7 +271,10 @@ function MarathonA2Game:drawScoringInfo()
 	love.graphics.printf("LEVEL", 240, 320, 40, "left")
 
 	love.graphics.setFont(font_3x5_3)
+	if self.roll_frames > 3694 then love.graphics.setColor(1, 0.5, 0, 1)
+	elseif self.clear then love.graphics.setColor(0, 1, 0, 1) end
 	love.graphics.printf(self:getLetterGrade(), 240, 140, 90, "left")
+	love.graphics.setColor(1, 1, 1, 1)
 	love.graphics.printf(self.score, 240, 220, 90, "left")
 	love.graphics.printf(self.level, 240, 340, 40, "right")
 	love.graphics.printf(self:getSectionEndLevel(), 240, 370, 40, "right")

tetris/modes/ck.lua

@@ -18,8 +18,7 @@ function SurvivalCKGame:new()
 	self.roll_frames = 0
 	self.combo = 1
 	self.grade = 0
-	self.level = 99
+	self.level = 0
-	self.frames = 55 * 60
 
 	self.randomizer = History6RollsRandomizer()
 
@@ -173,17 +172,18 @@ function SurvivalCKGame:onPieceLock(piece, cleared_row_count)
 end
 
 function SurvivalCKGame:updateScore(level, drop_bonus, cleared_lines)
+	if not self.clear then
 		if cleared_lines > 0 then
+			self.combo = self.combo + (cleared_lines - 1) * 2
 			self.score = self.score + (
 				(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
-			cleared_lines * (cleared_lines * 2 - 1) * (self.combo * 2 - 1)
+				cleared_lines * self.combo
 			)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + cleared_lines - 1
 		else
-		self.drop_bonus = 0
 			self.combo = 1
 		end
+		self.drop_bonus = 0
+	end
 end
 
 function SurvivalCKGame:updateSectionTimes(old_level, new_level)
@@ -309,7 +309,7 @@ end
 
 function SurvivalCKGame:getHighscoreData()
 	return {
-		grade = self:getLetterGrade(),
+		grade = self.grade,
 		level = self.level,
 		frames = self.frames,
 	}

tetris/modes/demon_mode.lua

@@ -167,6 +167,7 @@ function DemonModeGame:updateSectionTimes(old_level, new_level)
 			else
 				self.level = math.min(new_level, 2500)
 				self.skip_failed = true
+				self.grade = self.grade + 1
 			end
 			-- record new section
 			section_time = self.frames - self.section_start_time
@@ -178,6 +179,7 @@ function DemonModeGame:updateSectionTimes(old_level, new_level)
 				self.level = 500
 				self.game_over = true
 			end
+			self.grade = math.min(self.grade + 1, 4)
 		end
 	else
 		self.level = math.min(new_level, 2500)
@@ -185,17 +187,18 @@ function DemonModeGame:updateSectionTimes(old_level, new_level)
 end
 
 function DemonModeGame:updateScore(level, drop_bonus, cleared_lines)
+	if not self.clear then
 		if cleared_lines > 0 then
+			self.combo = self.combo + (cleared_lines - 1) * 2
 			self.score = self.score + (
 				(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
-			cleared_lines * (cleared_lines * 2 - 1) * (self.combo * 2 - 1)
+				cleared_lines * self.combo
 			)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + cleared_lines - 1
 		else
-		self.drop_bonus = 0
 			self.combo = 1
 		end
+		self.drop_bonus = 0
+	end
 end
 
 local letter_grades = {

tetris/modes/gamemode.lua

@@ -366,7 +366,8 @@ function GameMode:drawNextQueue(ruleset)
 		end
 	end
 	if self.hold_queue ~= nil then
-		self:setHoldOpacity()
+		local hold_color = self.held and 0.6 or 1
+		self:setHoldOpacity(1, hold_color)
 		drawPiece(
 			self.hold_queue.shape, 
 			self.hold_queue.skin, 
@@ -377,8 +378,16 @@ function GameMode:drawNextQueue(ruleset)
 	return false
 end
 
-function GameMode:setNextOpacity(i) love.graphics.setColor(1, 1, 1, 1) end
+function GameMode:setNextOpacity(i, j)
-function GameMode:setHoldOpacity() love.graphics.setColor(1, 1, 1, 1) end
+        i = i ~= nil and i or 1
+        j = j ~= nil and j or 1
+        love.graphics.setColor(j, j, j, i)
+end
+function GameMode:setHoldOpacity(i, j)
+	i = i ~= nil and i or 1
+	j = j ~= nil and j or 1
+	love.graphics.setColor(j, j, j, i)
+end
 
 function GameMode:drawScoringInfo()
 	love.graphics.setColor(1, 1, 1, 1)

tetris/modes/interval_training.lua

@@ -3,7 +3,7 @@ require 'funcs'
 local GameMode = require 'tetris.modes.gamemode'
 local Piece = require 'tetris.components.piece'
 
-local History6RollsRandomizer = require 'tetris.randomizers.history_6rolls'
+local History6RollsRandomizer = require 'tetris.randomizers.history_6rolls_35bag'
 
 local IntervalTrainingGame = GameMode:extend()
 
@@ -15,11 +15,12 @@ IntervalTrainingGame.tagline = "Can you clear the time hurdles when the game goe
 
 
 function IntervalTrainingGame:new()
+	self.level = 0
 	IntervalTrainingGame.super:new()
 	self.roll_frames = 0
 	self.combo = 1
 	self.randomizer = History6RollsRandomizer()
-	self.section_time_limit = 1800
+	
 	self.section_start_time = 0
 	self.section_times = { [0] = 0 }
 	self.lock_drop = true
@@ -27,20 +28,26 @@ function IntervalTrainingGame:new()
 	self.next_queue_length = 3
 end
 
+function IntervalTrainingGame:initialize(ruleset)
+	self.section_time_limit = 1800
+	if ruleset.world then self.section_time_limit = 37 * 60 end
+	self.super.initialize(self, ruleset)
+end
+
 function IntervalTrainingGame:getARE()
-	return 4
+	return 6
 end
 
 function IntervalTrainingGame:getLineARE()
-	return 4
+	return 6
 end
 
 function IntervalTrainingGame:getDasLimit()
-	return 6
+	return 7
 end
 
 function IntervalTrainingGame:getLineClearDelay()
-	return 6
+	return 4
 end
 
 function IntervalTrainingGame:getLockDelay()
@@ -61,7 +68,6 @@ function IntervalTrainingGame:advanceOneFrame()
 		if self.roll_frames > 2968 then
 			self.completed = true
 		end
-		return false
 	elseif self.ready_frames == 0 then
 		self.frames = self.frames + 1
 		if self:getSectionTime() >= self.section_time_limit then
@@ -72,14 +78,15 @@ function IntervalTrainingGame:advanceOneFrame()
 end
 
 function IntervalTrainingGame:onPieceEnter()
-	if (self.level % 100 ~= 99 or self.level == 998) and not self.clear and self.frames ~= 0 then
+	if (self.level % 100 ~= 99 and self.level ~= 998) and not self.clear and self.frames ~= 0 then
 		self.level = self.level + 1
 	end
 end
 
 function IntervalTrainingGame:onLineClear(cleared_row_count)
+	local cleared_level_bonus = {1, 2, 4, 6}
 	if not self.clear then
-		local new_level = self.level + cleared_row_count
+		local new_level = self.level + cleared_level_bonus[cleared_row_count]
 		self:updateSectionTimes(self.level, new_level)
 		self.level = math.min(new_level, 999)
 		if self.level == 999 then
@@ -97,8 +104,6 @@ function IntervalTrainingGame:updateSectionTimes(old_level, new_level)
 		-- record new section
 		table.insert(self.section_times, self:getSectionTime())
 		self.section_start_time = self.frames
-	else
-		self.level = math.min(new_level, 999)
 	end
 end
 
@@ -123,7 +128,7 @@ function IntervalTrainingGame:drawScoringInfo()
 		strTrueValues(self.prev_inputs)
 	)
 	love.graphics.printf("NEXT", 64, 40, 40, "left")
-	love.graphics.printf("TIME LEFT", 240, 250, 80, "left")
+	if not self.clear then love.graphics.printf("TIME LEFT", 240, 250, 80, "left") end
 	love.graphics.printf("LEVEL", 240, 320, 40, "left")
 
 	local current_section = math.floor(self.level / 100) + 1
@@ -134,10 +139,10 @@ function IntervalTrainingGame:drawScoringInfo()
 
 	-- draw time left, flash red if necessary
 	local time_left = self.section_time_limit - math.max(self:getSectionTime(), 0)
-	if not self.game_over and not self.clear and time_left < frameTime(0,10) and time_left % 4 < 2 then
+	if not self.game_over and time_left < frameTime(0,10) and time_left % 4 < 2 then
 		love.graphics.setColor(1, 0.3, 0.3, 1)
 	end
-	love.graphics.printf(formatTime(time_left), 240, 270, 160, "left")
+	if not self.clear then love.graphics.printf(formatTime(time_left), 240, 270, 160, "left") end
 
 	love.graphics.setColor(1, 1, 1, 1)
 	love.graphics.printf(self:getSectionEndLevel(), 240, 370, 40, "right")

tetris/modes/marathon_2020.lua

@@ -36,6 +36,8 @@ function Marathon2020Game:new()
 	self.grade_points = 0
 	self.grade_point_decay_counter = 0
 	self.max_grade_points = 0
+
+	self.cool_timer = 0
 end
 
 function Marathon2020Game:getARE()
@@ -327,6 +329,7 @@ function Marathon2020Game:updateSectionTimes(old_level, new_level)
 		self.section_cool_count = self.section_cool_count + 1
 		self.delay_level = math.min(20, self.delay_level + 1)
 		table.insert(self.section_status, "cool")
+		self.cool_timer = 300
 	end
 
 	local section = getSectionForLevel(old_level)
@@ -430,6 +433,11 @@ function Marathon2020Game:drawScoringInfo()
 
 	self:drawSectionTimesWithSecondary(current_section)
 
+	if (self.cool_timer > 0) then
+                love.graphics.printf("COOL!!", 64, 400, 160, "center")
+                self.cool_timer = self.cool_timer - 1
+        end	
+
 	love.graphics.setFont(font_3x5_3)
 	love.graphics.printf(self:getTotalGrade(), text_x, 120, 90, "left")
 	love.graphics.printf(self.grade_points, text_x, 220, 90, "left")

tetris/modes/marathon_a1.lua

@@ -137,15 +137,15 @@ function MarathonA1Game:onLineClear(cleared_row_count)
     self:checkGMRequirements(self.level, self.level + cleared_row_count)
 	if not self.clear then
 		local new_level = math.min(self.level + cleared_row_count, 999)
-		if self.level == 999 then
+		if new_level == 999 then
 			self.clear = true
-		else
-			self.level = new_level
 		end
+		self.level = new_level
 	end
 end
 
 function MarathonA1Game:updateScore(level, drop_bonus, cleared_lines)
+	if not self.clear then
 		if self.grid:checkForBravo(cleared_lines) then
 			self.bravo = 4
 			self.bravos = self.bravos + 1
@@ -156,25 +156,25 @@ function MarathonA1Game:updateScore(level, drop_bonus, cleared_lines)
 				(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
 				cleared_lines * self.combo * self.bravo
 			)
-        self.lines = self.lines + cleared_lines
 		else
-		self.drop_bonus = 0
 			self.combo = 1
 		end
+		self.drop_bonus = 0
+	end
 end
 
 function MarathonA1Game:checkGMRequirements(old_level, new_level)
 	if old_level < 300 and new_level >= 300 then
-		if self.score > 12000 and self.frames <= frameTime(4,15) then
+		if self.score >= 12000 and self.frames <= frameTime(4,15) then
 			self.gm_conditions["level300"] = true
 		end
 	elseif old_level < 500 and new_level >= 500 then
-		if self.score > 40000 and self.frames <= frameTime(7,30) then
+		if self.score >= 40000 and self.frames <= frameTime(7,30) then
 			self.gm_conditions["level500"] = true
 		end
 	elseif old_level < 999 and new_level >= 999 then
-		if self.score > 126000 and self.frames <= frameTime(13,30) then
+		if self.score >= 126000 and self.frames <= frameTime(13,30) then
-			self.gm_conditions["level900"] = true
+			self.gm_conditions["level999"] = true
 		end
 	end
 end
@@ -210,7 +210,7 @@ function MarathonA1Game:drawScoringInfo()
 
 	love.graphics.setFont(font_3x5_3)
 	love.graphics.printf(self.score, 240, 220, 90, "left")
-	if self.gm_conditions["level300"] and self.gm_conditions["level500"] and self.gm_conditions["level900"] then
+	if self.gm_conditions["level300"] and self.gm_conditions["level500"] and self.gm_conditions["level999"] then
 		love.graphics.printf("GM", 240, 140, 90, "left")
 	else
 		love.graphics.printf(getRankForScore(self.score).rank, 240, 140, 90, "left")

tetris/modes/marathon_a2.lua

@@ -33,8 +33,6 @@ function MarathonA2Game:new()
         "GM"
     }
 
-	self.randomizer = History6RollsRandomizer()
-
     self.lock_drop = false
 	self.enable_hold = false
 	self.next_queue_length = 1
@@ -109,6 +107,7 @@ end
 function MarathonA2Game:advanceOneFrame()
 	if self.clear then
 		self.roll_frames = self.roll_frames + 1
+		if self.roll_frames < 0 then return false end
 		if self.roll_frames > 3694 then
 			self.completed = true
 			if self.grade == 32 then
@@ -127,33 +126,31 @@ function MarathonA2Game:onPieceEnter()
 	end
 end
 
-function MarathonA2Game:onLineClear(cleared_row_count)
-    self:updateSectionTimes(self.level, self.level + cleared_row_count)
-    self.level = math.min(self.level + cleared_row_count, 999)
-    if self.level == 999 and not self.clear then
-        self.clear = true
-        if self:qualifiesForMRoll() then
-            self.grade = 32
-        end
-        self.grid:clear()
-        self.roll_frames = -150
-    end
-end
-
 function MarathonA2Game:updateScore(level, drop_bonus, cleared_lines)
+	if not self.clear then
 		self:updateGrade(cleared_lines)
 		if self.grid:checkForBravo(cleared_lines) then self.bravo = 4 else self.bravo = 1 end
 		if cleared_lines > 0 then
+			self.combo = self.combo + (cleared_lines - 1) * 2
 			self.score = self.score + (
-			(math.ceil((level + cleared_lines) / 4) + 2 * drop_bonus) *
+				(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
 				cleared_lines * self.combo * self.bravo
 			)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + (cleared_lines - 1) * 2
 		else
-		self.drop_bonus = 0
 			self.combo = 1
 		end
+		self.drop_bonus = 0
+	else self.lines = self.lines + cleared_lines end
+end
+
+function MarathonA2Game:onLineClear(cleared_row_count)
+    self.level = math.min(self.level + cleared_row_count, 999)
+    if self.level == 999 and not self.clear then
+        self.clear = true
+        self.grid:clear()
+		if self:qualifiesForMRoll() then self.grade = 32 end
+        self.roll_frames = -150
+    end
 end
 
 function MarathonA2Game:updateSectionTimes(old_level, new_level)
@@ -253,7 +250,7 @@ function MarathonA2Game:updateGrade(cleared_lines)
 	end
 end
 
-local tetris_requirements = { [0] = 2, 2, 2, 2, 2, 1, 1, 1, 1, 1 }
+local tetris_requirements = { [0] = 2, 2, 2, 2, 2, 1, 1, 1, 1, 0 }
 
 function MarathonA2Game:qualifiesForMRoll()
 	if not self.clear then return false end
@@ -280,7 +277,7 @@ function MarathonA2Game:qualifiesForMRoll()
 			return false
 		end
 	end
-	if self.grade < 17 or self.frames > frameTime(9,30) then
+	if self.grade < 31 or self.frames > frameTime(8,45) then
 		return false
 	end
 	return true
@@ -344,7 +341,17 @@ function MarathonA2Game:drawScoringInfo()
     end
 
 	love.graphics.setFont(font_3x5_3)
+	if self.clear then
+		if self:qualifiesForMRoll() then
+			if self.lines >= 32 and self.roll_frames > 3694 then love.graphics.setColor(1, 0.5, 0, 1)
+			else love.graphics.setColor(0, 1, 0, 1) end
+		else
+			if self.roll_frames > 3694 then love.graphics.setColor(1, 0.5, 0, 1)
+			else love.graphics.setColor(0, 1, 0, 1) end
+		end
+	end	
 	love.graphics.printf(self:getLetterGrade(), 240, 140, 90, "left")
+	love.graphics.setColor(1, 1, 1, 1)
 	love.graphics.printf(self.score, 240, 220, 90, "left")
 	love.graphics.printf(self.level, 240, 340, 40, "right")
 	love.graphics.printf(self:getSectionEndLevel(), 240, 370, 40, "right")

tetris/modes/marathon_a3.lua

@@ -45,6 +45,8 @@ self.SGnames = {
 	
 	self.coolregret_message = "COOL!!"
 	self.coolregret_timer = 0
+	
+	self.torikan_passed = false
 end
 
 function MarathonA3Game:getARE()
@@ -166,10 +168,10 @@ function MarathonA3Game:onLineClear(cleared_row_count)
         self.grid:clear()
         self.roll_frames = -150
     end
-    if self.level >= 500 and self.frames >= 25200 then
+    if not self.torikan_passed and self.level >= 500 and self.frames >= 25200 then
 	self.level = 500
 	self.game_over = true
-    end
+    elseif self.level >= 500 then self.torikan_passed = true end
 end
 
 local cool_cutoffs = {
@@ -223,18 +225,19 @@ function MarathonA3Game:updateSectionTimes(old_level, new_level)
 end
 
 function MarathonA3Game:updateScore(level, drop_bonus, cleared_lines)
+	if not self.clear then
 		self:updateGrade(cleared_lines)
 		if cleared_lines > 0 then
+			self.combo = self.combo + (cleared_lines - 1) * 2
 			self.score = self.score + (
 				(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
-			cleared_lines * (cleared_lines * 2 - 1) * (self.combo * 2 - 1)
+				cleared_lines * self.combo
 			)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + cleared_lines - 1
 		else
-		self.drop_bonus = 0
 			self.combo = 1
 		end
+		self.drop_bonus = 0
+	end
 end
 
 local grade_point_bonuses = {

tetris/modes/marathon_ax4.lua

@@ -98,6 +98,7 @@ function MarathonAX4Game:onLineClear(cleared_row_count)
 		self:updateSectionTimes(self.lines, new_lines)
 		self.lines = math.min(new_lines, 150)
 		if self.lines == 150 then
+			self.grid:clear()
 			self.clear = true
 			self.roll_frames = -150
 		end

tetris/modes/phantom_mania.lua

@@ -117,17 +117,18 @@ function PhantomManiaGame:onLineClear(cleared_row_count)
 end
 
 function PhantomManiaGame:updateScore(level, drop_bonus, cleared_lines)
+	if not self.clear then
 		if cleared_lines > 0 then
+			self.combo = self.combo + (cleared_lines - 1) * 2
 			self.score = self.score + (
 				(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
-			cleared_lines * (cleared_lines * 2 - 1) * (self.combo * 2 - 1)
+				cleared_lines * self.combo
 			)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + cleared_lines - 1
 		else
-		self.drop_bonus = 0
 			self.combo = 1
 		end
+		self.drop_bonus = 0
+	end
 end
 
 PhantomManiaGame.rollOpacityFunction = function(age)

tetris/modes/phantom_mania2.lua

@@ -16,7 +16,6 @@ PhantomMania2Game.tagline = "The blocks disappear even faster now! Can you make
 
 function PhantomMania2Game:new()
 	PhantomMania2Game.super:new()
-	self.level = 0
 	self.grade = 0
 	self.garbage = 0
 	self.clear = false
@@ -38,6 +37,9 @@ function PhantomMania2Game:new()
 	self.lock_drop = true
 	self.enable_hold = true
 	self.next_queue_length = 3
+
+	self.coolregret_message = ""
+	self.coolregret_timer = 0
 end
 
 function PhantomMania2Game:getARE()
@@ -179,17 +181,18 @@ function PhantomMania2Game:onHold()
 end
 
 function PhantomMania2Game:updateScore(level, drop_bonus, cleared_lines)
+	if not self.clear then
 		if cleared_lines > 0 then
+			self.combo = self.combo + (cleared_lines - 1) * 2
 			self.score = self.score + (
 				(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
-			cleared_lines * (cleared_lines * 2 - 1) * (self.combo * 2 - 1)
+				cleared_lines * self.combo
 			)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + cleared_lines - 1
 		else
-		self.drop_bonus = 0
 			self.combo = 1
 		end
+		self.drop_bonus = 0
+	end
 end
 
 
@@ -213,8 +216,13 @@ function PhantomMania2Game:updateSectionTimes(old_level, new_level)
 		self.section_start_time = self.frames
 		if section_time <= cool_cutoffs[section] then
 			self.grade = self.grade + 2
+			self.coolregret_message = "COOL!!"
+			self.coolregret_timer = 300
 		elseif section_time <= regret_cutoffs[section] then
 			self.grade = self.grade + 1
+		else
+			self.coolregret_message = "REGRET!!"
+			self.coolregret_timer = 300
 		end
 	end
 end
@@ -296,6 +304,11 @@ function PhantomMania2Game:drawScoringInfo()
         love.graphics.printf("SECRET GRADE", 240, 430, 180, "left")
     end
 
+	if(self.coolregret_timer > 0) then
+                love.graphics.printf(self.coolregret_message, 64, 400, 160, "center")
+                self.coolregret_timer = self.coolregret_timer - 1
+        end
+
 	love.graphics.setFont(font_3x5_3)
 	love.graphics.printf(getLetterGrade(math.floor(self.grade)), text_x, 140, 90, "left")
 	love.graphics.printf(self.score, text_x, 220, 90, "left")

tetris/modes/race_40.lua

@@ -22,6 +22,14 @@ function Race40Game:new()
 
 	self.roll_frames = 0
 
+	self.SGnames = {
+        	[0] = "",
+		"9", "8", "7", "6", "5", "4", "3", "2", "1",
+        	"S1", "S2", "S3", "S4", "S5", "S6", "S7", "S8", "S9",
+        	"GM"
+   	}
+	self.upstacked = false
+	
 	self.lock_drop = true
 	self.lock_hard_drop = true
 	self.instant_hard_drop = true
@@ -35,7 +43,7 @@ function Race40Game:getDropSpeed()
 end
 
 function Race40Game:getARR()
-	return 0
+	return 1
 end
 
 function Race40Game:getARE()
@@ -47,7 +55,7 @@ function Race40Game:getLineARE()
 end
 
 function Race40Game:getDasLimit()
-	return 6
+	return 10
 end
 
 function Race40Game:getLineClearDelay()
@@ -55,7 +63,7 @@ function Race40Game:getLineClearDelay()
 end
 
 function Race40Game:getLockDelay()
-	return 15
+	return 30
 end
 
 function Race40Game:getGravity()
@@ -102,6 +110,12 @@ function Race40Game:getHighscoreData()
 	}
 end
 
+function Race40Game:getSecretGrade(sg)
+	if sg == 19 then self.upstacked = true end
+	if self.upstacked then return self.SGnames[14 + math.floor((20 - sg) / 4)]
+	else return self.SGnames[math.floor((sg / 19) * 14)] end
+end
+
 function Race40Game:drawScoringInfo()
 	Race40Game.super.drawScoringInfo(self)
 	love.graphics.setColor(1, 1, 1, 1)
@@ -113,10 +127,17 @@ function Race40Game:drawScoringInfo()
 	love.graphics.printf("LINES", text_x, 320, 40, "left")
 	love.graphics.printf("line/min", text_x, 160, 80, "left")
 	love.graphics.printf("piece/sec", text_x, 220, 80, "left")
+	local sg = self.grid:checkSecretGrade()
+    	if sg >= 7 or self.upstacked then 
+        	love.graphics.printf("SECRET GRADE", 240, 430, 180, "left")
+    	end
 
 	love.graphics.setFont(font_3x5_3)
 	love.graphics.printf(string.format("%.02f", self.lines / math.max(1, self.frames) * 3600), text_x, 180, 80, "left")
 	love.graphics.printf(string.format("%.04f", self.pieces / math.max(1, self.frames) * 60), text_x, 240, 80, "left")
+	if sg >= 7 or self.upstacked then
+        	love.graphics.printf(self:getSecretGrade(sg), 240, 450, 180, "left")
+    	end
 
 	love.graphics.setFont(font_3x5_4)
 	love.graphics.printf(math.max(0, self.line_goal - self.lines), text_x, 340, 40, "left")

tetris/modes/strategy.lua

@@ -16,7 +16,6 @@ StrategyGame.tagline = "You have lots of time to think! Can you use it to place
 
 function StrategyGame:new()
 	StrategyGame.super:new()
-	self.level = 0
 	self.clear = false
 	self.completed = false
 	self.roll_frames = 0
@@ -84,7 +83,7 @@ function StrategyGame:advanceOneFrame()
 end
 
 function StrategyGame:onPieceEnter()
-	if (self.level % 100 ~= 99) and not self.clear and self.frames ~= 0 then
+	if (self.level % 100 ~= 99 and self.level ~= 998) and not self.clear and self.frames ~= 0 then
 		self.level = self.level + 1
 	end
 end
@@ -99,17 +98,18 @@ function StrategyGame:onLineClear(cleared_row_count)
 end
 
 function StrategyGame:updateScore(level, drop_bonus, cleared_lines)
+	if not self.clear then
 		if cleared_lines > 0 then
+			self.combo = self.combo + (cleared_lines - 1) * 2
 			self.score = self.score + (
 				(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
-			cleared_lines * (cleared_lines * 2 - 1) * (self.combo * 2 - 1)
+				cleared_lines * self.combo
 			)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + cleared_lines - 1
 		else
-		self.drop_bonus = 0
 			self.combo = 1
 		end
+		self.drop_bonus = 0
+	end
 end
 
 function StrategyGame:setNextOpacity(i)
@@ -135,11 +135,11 @@ function StrategyGame:drawScoringInfo()
 
 	love.graphics.setFont(font_3x5_3)
 	love.graphics.printf(self.score, text_x, 220, 90, "left")
-	love.graphics.printf(self.level, text_x, 340, 50, "right")
+	love.graphics.printf(self.level, text_x, 340, 40, "right")
 	if self.clear then
-		love.graphics.printf(self.level, text_x, 370, 50, "right")
+		love.graphics.printf(self.level, text_x, 370, 40, "right")
 	else
-		love.graphics.printf(math.floor(self.level / 100 + 1) * 100, text_x, 370, 50, "right")
+		love.graphics.printf(self.level < 900 and math.floor(self.level / 100 + 1) * 100 or 999, text_x, 370, 40, "right")
 	end
 end
 

tetris/modes/survival_2020.lua

@@ -174,17 +174,18 @@ function Survival2020Game:onLineClear(cleared_row_count)
 end
 
 function Survival2020Game:updateScore(level, drop_bonus, cleared_lines)
+	if not self.clear then
 		if cleared_lines > 0 then
+			self.combo = self.combo + (cleared_lines - 1) * 2
 			self.score = self.score + (
 				(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
-			cleared_lines * (cleared_lines * 2 - 1) * (self.combo * 2 - 1)
+				cleared_lines * self.combo
 			)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + cleared_lines - 1
 		else
-		self.drop_bonus = 0
 			self.combo = 1
 		end
+		self.drop_bonus = 0
+	end
 end
 
 function Survival2020Game:updateSectionTimes(old_level, new_level)

tetris/modes/survival_a1.lua

@@ -109,7 +109,7 @@ function SurvivalA1Game:onLineClear(cleared_row_count)
     self:checkGMRequirements(self.level, self.level + cleared_row_count)
 	if not self.clear then
 		local new_level = math.min(self.level + cleared_row_count, 999)
-		if self.level == 999 then
+		if new_level == 999 then
 			self.clear = true
 		else
 		self.level = new_level
@@ -118,35 +118,36 @@ function SurvivalA1Game:onLineClear(cleared_row_count)
 end
 
 function SurvivalA1Game:updateScore(level, drop_bonus, cleared_lines)
+	if not self.clear then
 		if self.grid:checkForBravo(cleared_lines) then
 			self.bravo = 4
 			self.bravos = self.bravos + 1
 		else self.bravo = 1 end
 		if cleared_lines > 0 then
+			self.combo = self.combo + (cleared_lines - 1) * 2
 			self.score = self.score + (
 				(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
-			cleared_lines * self.bravo * self.combo
+				cleared_lines * self.combo * self.bravo
 			)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + (cleared_lines - 1) * 2
 		else
-		self.drop_bonus = 0
 			self.combo = 1
 		end
+		self.drop_bonus = 0
+	end
 end
 
 function SurvivalA1Game:checkGMRequirements(old_level, new_level)
 	if old_level < 300 and new_level >= 300 then
-		if self.score > 12000 and self.frames <= frameTime(4,15) then
+		if self.score >= 12000 and self.frames <= frameTime(4,15) then
 			self.gm_conditions["level300"] = true
 		end
 	elseif old_level < 500 and new_level >= 500 then
-		if self.score > 40000 and self.frames <= frameTime(7,30) then
+		if self.score >= 40000 and self.frames <= frameTime(7,30) then
 			self.gm_conditions["level500"] = true
 		end
 	elseif old_level < 999 and new_level >= 999 then
-		if self.score > 126000 and self.frames <= frameTime(13,30) then
+		if self.score >= 126000 and self.frames <= frameTime(13,30) then
-			self.gm_conditions["level900"] = true
+			self.gm_conditions["level999"] = true
 		end
 	end
 end
@@ -179,7 +180,7 @@ function SurvivalA1Game:drawScoringInfo()
 
 	love.graphics.setFont(font_3x5_3)
 	love.graphics.printf(self.score, 240, 220, 90, "left")
-	if self.gm_conditions["level300"] and self.gm_conditions["level500"] and self.gm_conditions["level900"] then
+	if self.gm_conditions["level300"] and self.gm_conditions["level500"] and self.gm_conditions["level999"] then
 		love.graphics.printf("GM", 240, 140, 90, "left")
 	else
 		love.graphics.printf(getRankForScore(self.score).rank, 240, 140, 90, "left")

tetris/modes/survival_a2.lua

@@ -88,7 +88,7 @@ function SurvivalA2Game:advanceOneFrame()
 end
 
 function SurvivalA2Game:onPieceEnter()
-	if (self.level % 100 ~= 99 or self.level == 998) and not self.clear and self.frames ~= 0 then
+	if (self.level % 100 ~= 99 and self.level ~= 998) and not self.clear and self.frames ~= 0 then
 		self.level = self.level + 1
 	end
 end
@@ -108,18 +108,19 @@ function SurvivalA2Game:onLineClear(cleared_row_count)
 end
 
 function SurvivalA2Game:updateScore(level, drop_bonus, cleared_lines)
+	if not self.clear then
 		if self.grid:checkForBravo(cleared_lines) then self.bravo = 4 else self.bravo = 1 end
 		if cleared_lines > 0 then
+			self.combo = self.combo + (cleared_lines - 1) * 2
 			self.score = self.score + (
 				(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
-			cleared_lines * self.bravo * self.combo
+				cleared_lines * self.combo * self.bravo
 			)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + (cleared_lines - 1) * 2
 		else
-		self.drop_bonus = 0
 			self.combo = 1
 		end
+		self.drop_bonus = 0
+	end
 end
 
 function SurvivalA2Game:getLetterGrade()

tetris/modes/survival_a3.lua

@@ -16,7 +16,6 @@ SurvivalA3Game.tagline = "The blocks turn black and white! Can you make it to le
 
 function SurvivalA3Game:new()
 	SurvivalA3Game.super:new()
-	self.level = 0
 	self.grade = 0
 	self.garbage = 0
 	self.clear = false
@@ -140,7 +139,6 @@ function SurvivalA3Game:onPieceEnter()
 end
 
 local cleared_row_levels = {1, 2, 4, 6}
-local cleared_row_points = {0.02, 0.05, 0.15, 0.6}
 
 function SurvivalA3Game:onLineClear(cleared_row_count)
 	if not self.clear then
@@ -168,17 +166,18 @@ function SurvivalA3Game:onPieceLock(piece, cleared_row_count)
 end
 
 function SurvivalA3Game:updateScore(level, drop_bonus, cleared_lines)
+	if not self.clear then
 		if cleared_lines > 0 then
+			self.combo = self.combo + (cleared_lines - 1) * 2
 			self.score = self.score + (
 				(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
-			cleared_lines * (cleared_lines * 2 - 1) * (self.combo * 2 - 1)
+				cleared_lines * self.combo
 			)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + cleared_lines - 1
 		else
-		self.drop_bonus = 0
 			self.combo = 1
 		end
+		self.drop_bonus = 0
+	end
 end
 
 function SurvivalA3Game:updateSectionTimes(old_level, new_level)
@@ -243,7 +242,10 @@ function SurvivalA3Game:drawScoringInfo()
 	self:drawSectionTimesWithSplits(current_section)
 
 	love.graphics.setFont(font_3x5_3)
+	if self.roll_frames > 3238 then love.graphics.setColor(1, 0.5, 0, 1)
+        elseif self.clear then love.graphics.setColor(0, 1, 0, 1) end
 	love.graphics.printf(getLetterGrade(math.floor(self.grade)), text_x, 140, 90, "left")
+	love.graphics.setColor(1, 1, 1, 1)
 	love.graphics.printf(self.score, text_x, 220, 90, "left")
 	love.graphics.printf(self.level, text_x, 340, 50, "right")
 	if self.clear then

tetris/modes/tgmplus.lua

@@ -0,0 +1,209 @@
+require 'funcs'
+
+local GameMode = require 'tetris.modes.gamemode'
+local Piece = require 'tetris.components.piece'
+
+local History6RollsRandomizer = require 'tetris.randomizers.history_6rolls'
+
+local TGMPlusGame = GameMode:extend()
+
+TGMPlusGame.name = "Marathon A2+"
+TGMPlusGame.hash = "A2Plus"
+TGMPlusGame.tagline = "The garbage rises steadily! Can you make it to level 999?"
+
+function TGMPlusGame:new()
+	TGMPlusGame.super:new()
+
+	self.roll_frames = 0
+	self.combo = 1
+	
+    	self.SGnames = {
+        	"9", "8", "7", "6", "5", "4", "3", "2", "1",
+        	"S1", "S2", "S3", "S4", "S5", "S6", "S7", "S8", "S9",
+        	"GM"
+    	}
+    
+	self.randomizer = History6RollsRandomizer()
+
+    	self.lock_drop = false
+	self.enable_hold = false
+	self.next_queue_length = 1
+
+	self.garbage_queue = 0
+	self.garbage_pos = 0
+	self.garbage_rows = {
+		[0] = {"e", "b", "b", "b", "b", "b", "b", "b", "b", "b"},
+		      {"e", "b", "b", "b", "b", "b", "b", "b", "b", "b"},
+		      {"e", "b", "b", "b", "b", "b", "b", "b", "b", "b"},
+		      {"e", "b", "b", "b", "b", "b", "b", "b", "b", "b"},
+		      {"b", "b", "b", "b", "b", "b", "b", "b", "b", "e"},
+                      {"b", "b", "b", "b", "b", "b", "b", "b", "b", "e"},
+                      {"b", "b", "b", "b", "b", "b", "b", "b", "b", "e"},
+                      {"b", "b", "b", "b", "b", "b", "b", "b", "b", "e"},
+                      {"e", "e", "b", "b", "b", "b", "b", "b", "b", "b"},
+		      {"e", "b", "b", "b", "b", "b", "b", "b", "b", "b"},
+		      {"e", "b", "b", "b", "b", "b", "b", "b", "b", "b"},
+		      {"b", "b", "b", "b", "b", "b", "b", "b", "e", "e"},
+		      {"b", "b", "b", "b", "b", "b", "b", "b", "b", "e"},
+		      {"b", "b", "b", "b", "b", "b", "b", "b", "b", "e"},
+		      {"b", "b", "e", "b", "b", "b", "b", "b", "b", "b"},
+		      {"b", "e", "e", "b", "b", "b", "b", "b", "b", "b"},
+		      {"b", "e", "b", "b", "b", "b", "b", "b", "b", "b"},
+		      {"b", "b", "b", "b", "b", "b", "b", "e", "b", "b"},
+		      {"b", "b", "b", "b", "b", "b", "b", "e", "e", "b"},
+		      {"b", "b", "b", "b", "b", "b", "b", "b", "e", "b"},
+		      {"b", "b", "b", "b", "e", "e", "b", "b", "b", "b"},
+		      {"b", "b", "b", "b", "e", "e", "b", "b", "b", "b"},
+		      {"b", "b", "b", "b", "e", "b", "b", "b", "b", "b"},
+		      {"b", "b", "b", "e", "e", "e", "b", "b", "b", "b"},
+	}
+end
+
+function TGMPlusGame:getARE() return 25 end
+function TGMPlusGame:getDasLimit() return 15 end
+function TGMPlusGame:getLockDelay() return 30 end
+function TGMPlusGame:getLineClearDelay() return 40 end
+
+function TGMPlusGame: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 TGMPlusGame:getGarbageLimit() return 13 - math.floor(self.level / 100) end
+
+function TGMPlusGame:advanceOneFrame()
+	if self.clear then
+		self.roll_frames = self.roll_frames + 1
+		if self.roll_frames > 3694 then
+			self.completed = true
+		end
+	elseif self.ready_frames == 0 then
+		self.frames = self.frames + 1
+	end
+	return true
+end
+
+function TGMPlusGame:onPieceEnter()
+	if (self.level % 100 ~= 99 and self.level ~= 998) and not self.clear and self.frames ~= 0 then
+		self.level = self.level + 1
+	end
+end
+
+function TGMPlusGame:onPieceLock(piece, cleared_row_count)
+	if cleared_row_count == 0 then self:advanceBottomRow() end
+end
+
+function TGMPlusGame:onLineClear(cleared_row_count)
+    self.level = math.min(self.level + cleared_row_count, 999)
+    if self.level == 999 and not self.clear then self.clear = true end
+end
+
+function TGMPlusGame:advanceBottomRow()
+	self.garbage_queue = self.garbage_queue + 1
+	if self.garbage_queue >= self:getGarbageLimit() then
+		self.grid:garbageRise(self.garbage_rows[self.garbage_pos])
+		self.garbage_queue = 0
+		self.garbage_pos = (self.garbage_pos + 1) % 24
+	end
+end
+
+function TGMPlusGame:updateScore(level, drop_bonus, cleared_lines)
+	if not self.clear then
+		if self.grid:checkForBravo(cleared_lines) then self.bravo = 4 else self.bravo = 1 end
+		if cleared_lines > 0 then
+			self.combo = self.combo + (cleared_lines - 1) * 2
+			self.score = self.score + (
+				(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
+				cleared_lines * self.combo * self.bravo
+			)
+		else
+			self.combo = 1
+		end
+		self.drop_bonus = 0
+	end
+end
+
+function TGMPlusGame:drawGrid(ruleset)
+	self.grid:draw()
+	if self.piece ~= nil and self.level < 100 then
+		self:drawGhostPiece(ruleset)
+	end
+end
+
+function TGMPlusGame:getHighscoreData()
+	return {
+		score = self.score,
+		level = self.level,
+		frames = self.frames,
+	}
+end
+
+function TGMPlusGame:getSectionEndLevel()
+	if self.level >= 900 then return 999
+	else return math.floor(self.level / 100 + 1) * 100 end
+end
+
+function TGMPlusGame:getBackground()
+	return math.floor(self.level / 100)
+end
+
+function TGMPlusGame:drawScoringInfo()
+	love.graphics.setColor(1, 1, 1, 1)
+
+	love.graphics.setFont(font_3x5_2)
+	love.graphics.print(
+		self.das.direction .. " " ..
+		self.das.frames .. " " ..
+		strTrueValues(self.prev_inputs)
+	)
+	love.graphics.printf("NEXT", 64, 40, 40, "left")
+	love.graphics.printf("SCORE", 240, 200, 40, "left")
+	love.graphics.printf("LEVEL", 240, 320, 40, "left")
+    local sg = self.grid:checkSecretGrade()
+    if sg >= 5 then 
+        love.graphics.printf("SECRET GRADE", 240, 430, 180, "left")
+    end
+
+	love.graphics.setFont(font_3x5_3)
+	love.graphics.printf(self.score, 240, 220, 90, "left")
+	love.graphics.printf(self.level, 240, 340, 40, "right")
+	love.graphics.printf(self:getSectionEndLevel(), 240, 370, 40, "right")
+    if sg >= 5 then
+        love.graphics.printf(self.SGnames[sg], 240, 450, 180, "left")
+    end
+
+	love.graphics.setFont(font_8x11)
+	love.graphics.printf(formatTime(self.frames), 64, 420, 160, "center")
+end
+
+
+return TGMPlusGame

tetris/modes/unrefactored_modes/pacer_test.lua

@@ -50,9 +50,6 @@ function PacerTest:new()
 end
 
 function PacerTest:initialize(ruleset)
-	for i = 1, 30 do
-		table.insert(self.next_queue, self:getNextPiece(ruleset))
-	end
 	self.level_frames = getLevelFrames(1)
 	switchBGM("pacer_test")
 end

tetris/rulesets/ruleset.lua

@@ -24,6 +24,29 @@ Ruleset.enable_IRS_wallkicks = false
 
 -- Component functions.
 
+function Ruleset:new()
+	blocks["bone"] = (not self.world) and
+	{
+		R = love.graphics.newImage("res/img/bone.png"),
+		O = love.graphics.newImage("res/img/bone.png"),
+		Y = love.graphics.newImage("res/img/bone.png"),
+		G = love.graphics.newImage("res/img/bone.png"),
+		C = love.graphics.newImage("res/img/bone.png"),
+		B = love.graphics.newImage("res/img/bone.png"),
+		M = love.graphics.newImage("res/img/bone.png"),
+		X = love.graphics.newImage("res/img/bone.png"),
+	} or {
+		R = love.graphics.newImage("res/img/bonew.png"),
+		O = love.graphics.newImage("res/img/bonew.png"),
+		Y = love.graphics.newImage("res/img/bonew.png"),
+		G = love.graphics.newImage("res/img/bonew.png"),
+		C = love.graphics.newImage("res/img/bonew.png"),
+		B = love.graphics.newImage("res/img/bonew.png"),
+		M = love.graphics.newImage("res/img/bonew.png"),
+		X = love.graphics.newImage("res/img/bonew.png"),
+	}
+end
+
 function Ruleset:rotatePiece(inputs, piece, grid, prev_inputs, initial)
 	local new_inputs = {}