TGM3 cool system change

More Green Orange line
Fix Arika SRS
2025-05-13 20:21:25 -05:00 · 2020-11-06 14:01:28 -05:00 · 2020-11-05 16:21:58 -05:00 · 2020-11-04 22:46:45 -05:00 · 2020-11-04 16:58:11 -05:00 · 2020-11-04 16:57:44 -05:00
36 changed files with 1330 additions and 371 deletions
--- a/README.md
+++ b/README.md
@@ -12,40 +12,24 @@ Join our Discord server for help and a welcoming community! https://discord.gg/m
 Credits
 -------

- [Lilla Oshisaure](https://www.youtube.com/user/LeSpyroshisaure) for their amazing contributions to my life in general!
+- [Lilla Oshisaure](https://www.youtube.com/user/LeSpyroshisaure) for being my co-dev!
 - [The Tetra Legends Discord](http://discord.com/invite/7hMx5r2) for supporting me and playtesting!
+- [The Absolute Plus](https://discord.gg/6Gf2awJ) for being another source of motivation!
 - [joezeng](https://github.com/joezeng) for the original project.
- [Hailey](https://github.com/haileylgbt) for some miscellaneous assets.
- 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.
+
+The following people in no particular order also helped with the project:
+- [Hailey](https://github.com/haileylgbt)
+- CylinderKnot
+- MarkGamed7794
+- [Mizu](https://github.com/rexxt)
+- MattMayuga
+- Kitaru
+- switchpalacecorner

 ![Cambridge Logo](https://cdn.discordapp.com/attachments/625496179433668635/763363717730664458/Icon_2.png)

-Installation instructions
-------------------------
-
-Pre-built releases are available on the releases page.
-
-### Windows
-
-Unzip the exe file and run it directly. All assets are currently bundled inside the executable.
-
-### macOS
-
-For the time being, the file `cambridge.love` only works on the command line. Install `love` with [Homebrew](https://brew.sh), and run:
-
-    $ love cambridge.love
-
-### Linux
-
-Same as macOS, except install `love` with your favourite package manager.
-
-
-Running from source
-------------------
-
-If you want the bleeding-edge release, you can also clone the code straight from this repository.
+Playing the game
+----------------

 ### macOS, Linux

@@ -55,12 +39,27 @@ Clone the repository in git:

    git clone https://github.com/SashLilac/cambridge

+Alternatively, download the source code ZIP in the latest release.
+
 Then, navigate to the root directory that you just cloned, and type:

    love .

 It should run automatically!

+## Windows
+
+You do not need LÖVE on Windows, as it comes bundled with the program. Download the source code ZIP in the latest release, or if you want the bleeding edge version, download [this](https://github.com/SashLilac/cambridge/archive/master.zip).
+
+Extract the ZIP, open a Command Prompt at the folder you extracted Cambridge to, then run this command:
+
+    dist\windows\love.exe .
+
+Alternatively, if you're on a 32-bit system, run this instead:
+
+    dist\win32\love.exe .
+
+32-bit systems do not support rich presence integration.

 License
 -------
--- a/main.lua
+++ b/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
--- a/res/img/bonew.png
+++ b/res/img/bonew.png
--- a/scene/mode_select.lua
+++ b/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

--- a/tetris/components/grid.lua
+++ b/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 {
-			skin = self.grid[23][col].skin,
-			colour = "X"
-		}
+		self.grid[24][col] = (self.grid[23][col] == empty) and empty or block
 	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)
@@ -214,9 +235,9 @@ function Grid:checkSecretGrade()
            validLine = false
        end
        if(validLine) then
-                    sgrade = sgrade + 1
+                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
--- a/tetris/components/piece.lua
+++ b/tetris/components/piece.lua
@@ -98,7 +98,7 @@ end

 function Piece:dropToBottom(grid)
 	local piece_y = self.position.y
-	self:dropSquares(24, grid)
+	self:dropSquares(math.huge, grid)
 	self.gravity = 0
 	if self.position.y > piece_y then
 		-- if it got dropped any, also reset lock delay
--- a/tetris/modes/4wide.lua
+++ b/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
--- a/tetris/modes/big_a2.lua
+++ b/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
-    cleared_lines = cleared_lines / 2
-    self:updateGrade(cleared_lines)
-	if cleared_lines > 0 then
-		self.score = self.score + (
-			(math.ceil((level + cleared_lines) / 4) + 2 * drop_bonus) *
-			cleared_lines * self.combo * self.bravo
-		)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + 2 * (cleared_lines - 1)
-	else
+	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) + drop_bonus) *
+				cleared_lines * self.combo * self.bravo
+			)
+		else
+			self.combo = 1
+		end
 		self.drop_bonus = 0
-		self.combo = 1
-	end
-end
-
-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
+		self.grid:drawInvisible(self.rollOpacityFunction)
 	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")
--- a/tetris/modes/ck.lua
+++ b/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.frames = 55 * 60
+	self.level = 0

 	self.randomizer = History6RollsRandomizer()

@@ -173,16 +172,17 @@ function SurvivalCKGame:onPieceLock(piece, cleared_row_count)
 end

 function SurvivalCKGame:updateScore(level, drop_bonus, cleared_lines)
-	if cleared_lines > 0 then
-		self.score = self.score + (
-			(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
-			cleared_lines * (cleared_lines * 2 - 1) * (self.combo * 2 - 1)
-		)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + cleared_lines - 1
-	else
+	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 * self.combo
+			)
+		else
+			self.combo = 1
+		end
 		self.drop_bonus = 0
-		self.combo = 1
 	end
 end

@@ -309,7 +309,7 @@ end

 function SurvivalCKGame:getHighscoreData()
 	return {
-		grade = self:getLetterGrade(),
+		grade = self.grade,
 		level = self.level,
 		frames = self.frames,
 	}
--- a/tetris/modes/demon_mode.lua
+++ b/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,16 +187,17 @@ function DemonModeGame:updateSectionTimes(old_level, new_level)
 end

 function DemonModeGame:updateScore(level, drop_bonus, cleared_lines)
-	if cleared_lines > 0 then
-		self.score = self.score + (
-			(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
-			cleared_lines * (cleared_lines * 2 - 1) * (self.combo * 2 - 1)
-		)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + cleared_lines - 1
-	else
+	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 * self.combo
+			)
+		else
+			self.combo = 1
+		end
 		self.drop_bonus = 0
-		self.combo = 1
 	end
 end

--- a/tetris/modes/gamemode.lua
+++ b/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:setHoldOpacity() love.graphics.setColor(1, 1, 1, 1) end
+function GameMode:setNextOpacity(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: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)
--- a/tetris/modes/interval_training.lua
+++ b/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,12 +104,10 @@ 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

-function IntervalTrainingGame:drawGrid(ruleset)
+function IntervalTrainingGame:drawGrid()
 	self.grid:draw()
 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")
--- a/tetris/modes/marathon_2020.lua
+++ b/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")
--- a/tetris/modes/marathon_a1.lua
+++ b/tetris/modes/marathon_a1.lua
@@ -137,44 +137,44 @@ 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 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.combo * self.bravo
-		)
-        self.lines = self.lines + cleared_lines
-	else
+	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.combo * self.bravo
+			)
+		else
+			self.combo = 1
+		end
 		self.drop_bonus = 0
-		self.combo = 1
 	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
-			self.gm_conditions["level900"] = true
+		if self.score >= 126000 and self.frames <= frameTime(13,30) then
+			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")
--- a/tetris/modes/marathon_a2.lua
+++ b/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,35 +126,33 @@ function MarathonA2Game:onPieceEnter()
 	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) + drop_bonus) *
+				cleared_lines * self.combo * self.bravo
+			)
+		else
+			self.combo = 1
+		end
+		self.drop_bonus = 0
+	else self.lines = self.lines + cleared_lines 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()
+		if self:qualifiesForMRoll() then self.grade = 32 end
        self.roll_frames = -150
    end
 end

-function MarathonA2Game:updateScore(level, drop_bonus, cleared_lines)
-    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.score = self.score + (
-			(math.ceil((level + cleared_lines) / 4) + 2 * 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
-end
-
 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
@@ -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")
--- a/tetris/modes/marathon_a3.lua
+++ b/tetris/modes/marathon_a3.lua
@@ -17,7 +17,7 @@ MarathonA3Game.tagline = "The game gets faster way more quickly! Can you get all
 function MarathonA3Game:new()
    MarathonA3Game.super:new()
 	
-    self.speed_level = 0
+	self.speed_level = 0
 	self.roll_frames = 0
    self.combo = 1
 	self.grade = 0
@@ -29,6 +29,7 @@ function MarathonA3Game:new()
 	self.section_start_time = 0
 	self.section_70_times = { [0] = 0 }
 	self.section_times = { [0] = 0 }
+	self.section_cool = false
    
 	self.randomizer = History6RollsRandomizer()

@@ -45,6 +46,8 @@ self.SGnames = {
 	
 	self.coolregret_message = "COOL!!"
 	self.coolregret_timer = 0
+	
+	self.torikan_passed = false
 end

 function MarathonA3Game:getARE()
@@ -149,6 +152,7 @@ function MarathonA3Game:onPieceEnter()
        self:updateSectionTimes(self.level, self.level + 1)
        self.level = self.level + 1
        self.speed_level = self.speed_level + 1
+		self.torikan_passed = self.level >= 500 and true or false
    end
 end

@@ -166,10 +170,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
+	end
 end

 local cool_cutoffs = {
@@ -192,48 +196,53 @@ function MarathonA3Game:updateSectionTimes(old_level, new_level)
 		table.insert(self.section_times, section_time)
 		self.section_start_time = self.frames

+		self.speed_level = self.section_cool and self.speed_level + 100 or self.speed_level
+
 		if section_time > regret_cutoffs[section] then
 			self.section_cool_grade = self.section_cool_grade - 1
 			table.insert(self.section_status, "regret")
 			self.coolregret_message = "REGRET!!"
 			self.coolregret_timer = 300
-		elseif section <= 9 and self.section_status[section - 1] == "cool" and
-		self.section_70_times[section] < self.section_70_times[section - 1] + 120 then
+		elseif self.section_cool then
 			self.section_cool_grade = self.section_cool_grade + 1
-			self.speed_level = self.speed_level + 100
 			table.insert(self.section_status, "cool")
-			self.coolregret_message = "COOL!!"
-			self.coolregret_timer = 300
-		elseif self.section_status[section - 1] == "cool" then
-			table.insert(self.section_status, "none")
-		elseif section <= 9 and self.section_70_times[section] < cool_cutoffs[section] then
-			self.section_cool_grade = self.section_cool_grade + 1
-			self.speed_level = self.speed_level + 100
-			table.insert(self.section_status, "cool")
-			self.coolregret_message = "COOL!!"
-			self.coolregret_timer = 300
 		else
 			table.insert(self.section_status, "none")
 		end
-	elseif section <= 9 and old_level % 100 < 70 and new_level % 100 >= 70 then
+
+		self.section_cool = false
+	elseif old_level % 100 < 70 and new_level % 100 >= 70 then
 		-- record section 70 time
 		section_70_time = self.frames - self.section_start_time
 		table.insert(self.section_70_times, section_70_time)
+
+		if section <= 9 and self.section_status[section - 1] == "cool" and
+                self.section_70_times[section] < self.section_70_times[section - 1] + 120 then
+			self.section_cool = true
+			self.coolregret_message = "COOL!!"
+                        self.coolregret_timer = 300
+                elseif self.section_status[section - 1] == "cool" then self.section_cool = false
+                elseif section <= 9 and self.section_70_times[section] < cool_cutoffs[section] then
+			self.section_cool = true
+			self.coolregret_message = "COOL!!"
+                        self.coolregret_timer = 300
+		end
 	end
 end

 function MarathonA3Game:updateScore(level, drop_bonus, cleared_lines)
-    self:updateGrade(cleared_lines)
-	if cleared_lines > 0 then
-		self.score = self.score + (
-			(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
-			cleared_lines * (cleared_lines * 2 - 1) * (self.combo * 2 - 1)
-		)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + cleared_lines - 1
-	else
+	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 * self.combo
+			)
+		else
+			self.combo = 1
+		end
 		self.drop_bonus = 0
-		self.combo = 1
 	end
 end

@@ -427,7 +436,7 @@ function MarathonA3Game:drawScoringInfo()
 		current_x = section_70_x
 	end

-	love.graphics.printf(formatTime(self.frames - self.section_start_time), current_x, 40 + 20 * current_section, 90, "left")
+	if not self.clear then love.graphics.printf(formatTime(self.frames - self.section_start_time), current_x, 40 + 20 * current_section, 90, "left") end
 	
 	if(self.coolregret_timer > 0) then
                love.graphics.printf(self.coolregret_message, 64, 400, 160, "center")
@@ -436,7 +445,10 @@ function MarathonA3Game:drawScoringInfo()

 	love.graphics.setFont(font_3x5_3)
 	love.graphics.printf(self.score, 240, 220, 90, "left")
+	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(self:getLetterGrade(), 240, 140, 90, "left")
+	love.graphics.setColor(1, 1, 1, 1)
 	love.graphics.printf(self.level, 240, 340, 40, "right")
 	love.graphics.printf(self:getSectionEndLevel(), 240, 370, 40, "right")
 	if sg >= 5 then
--- a/tetris/modes/marathon_ax4.lua
+++ b/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
--- a/tetris/modes/phantom_mania.lua
+++ b/tetris/modes/phantom_mania.lua
@@ -117,16 +117,17 @@ function PhantomManiaGame:onLineClear(cleared_row_count)
 end

 function PhantomManiaGame:updateScore(level, drop_bonus, cleared_lines)
-	if cleared_lines > 0 then
-		self.score = self.score + (
-			(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
-			cleared_lines * (cleared_lines * 2 - 1) * (self.combo * 2 - 1)
-		)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + cleared_lines - 1
-	else
+	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 * self.combo
+			)
+		else
+			self.combo = 1
+		end
 		self.drop_bonus = 0
-		self.combo = 1
 	end
 end

--- a/tetris/modes/phantom_mania2.lua
+++ b/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,16 +181,17 @@ function PhantomMania2Game:onHold()
 end

 function PhantomMania2Game:updateScore(level, drop_bonus, cleared_lines)
-	if cleared_lines > 0 then
-		self.score = self.score + (
-			(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
-			cleared_lines * (cleared_lines * 2 - 1) * (self.combo * 2 - 1)
-		)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + cleared_lines - 1
-	else
+	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 * self.combo
+			)
+		else
+			self.combo = 1
+		end
 		self.drop_bonus = 0
-		self.combo = 1
 	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")
--- a/tetris/modes/race_40.lua
+++ b/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")
--- a/tetris/modes/scoredrain.lua
+++ b/tetris/modes/scoredrain.lua
@@ -0,0 +1,189 @@
+require 'funcs'
+
+local GameMode = require 'tetris.modes.gamemode'
+local Piece = require 'tetris.components.piece'
+
+local History6RollsRandomizer = require 'tetris.randomizers.history_6rolls_35bag'
+
+local ScoreDrainGame = GameMode:extend()
+
+ScoreDrainGame.name = "Score Drain"
+ScoreDrainGame.hash = "ScoreDrain"
+ScoreDrainGame.tagline = "Your score goes down over time! Avoid hitting 0 points, or your game is over!"
+
+function ScoreDrainGame:new()
+	self.super:new()
+	
+	self.score = 2500
+	self.drain_rate = 50
+	self.combo = 1
+	self.randomizer = History6RollsRandomizer()
+	
+	self.lock_drop = true
+    self.lock_hard_drop = true
+	self.enable_hold = true
+	self.next_queue_length = 3
+end
+
+function ScoreDrainGame:getARE()
+        if self.level < 700 then return 27
+    elseif self.level < 800 then return 18
+    elseif self.level < 1000 then return 14
+    elseif self.level < 1100 then return 8
+    elseif self.level < 1200 then return 7
+    else return 6 end
+end
+
+function ScoreDrainGame:getLineARE()
+        if self.level < 600 then return 27
+    elseif self.level < 700 then return 18
+    elseif self.level < 800 then return 14
+    elseif self.level < 1100 then return 8
+    elseif self.level < 1200 then return 7
+    else return 6 end
+end
+
+function ScoreDrainGame:getDasLimit()
+        if self.level < 500 then return 15
+    elseif self.level < 900 then return 9
+    else return 7 end
+end
+
+function ScoreDrainGame:getLineClearDelay()
+        if self.level < 500 then return 40
+    elseif self.level < 600 then return 25
+    elseif self.level < 700 then return 16
+    elseif self.level < 800 then return 12
+    elseif self.level < 1100 then return 6
+    elseif self.level < 1200 then return 5
+    else return 4 end
+end
+
+function ScoreDrainGame:getLockDelay()
+        if self.level < 900 then return 30
+    elseif self.level < 1100 then return 17
+    else return 15 end
+end
+
+function ScoreDrainGame: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 ScoreDrainGame:advanceOneFrame()
+	if self.ready_frames == 0 then
+		self.frames = self.frames + 1
+		self.score = math.max(0, self.score - self.drain_rate / 60)
+		self.game_over = self.score <= 0 and true or false
+	end
+	return true
+end
+
+function ScoreDrainGame:onPieceEnter()
+	if (self.level % 100 ~= 99) and self.frames ~= 0 then
+        self.level = self.level + 1
+    end
+end
+
+local cleared_row_levels = {1, 2, 4, 6}
+
+function ScoreDrainGame:onLineClear(cleared_row_count)
+	local new_level = self.level + cleared_row_levels[cleared_row_count]
+	self.drain_rate = math.floor(self.level / 100) < math.floor(new_level / 100) and self.drain_rate * 1.5 or self.drain_rate
+	self.level = new_level
+end
+
+function ScoreDrainGame:updateScore(level, drop_bonus, 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 * self.combo
+		)
+	else
+		self.combo = 1
+	end
+	self.drop_bonus = 0
+end
+
+function ScoreDrainGame:drawGrid()
+	self.grid:draw()
+	if self.piece ~= nil and self.level < 100 then
+		self:drawGhostPiece(ruleset)
+	end
+end
+
+function ScoreDrainGame: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("DRAIN RATE", 240, 90, 80, "left")
+	love.graphics.printf("SCORE", 240, 170, 40, "left")
+	love.graphics.printf("TIME LEFT", 240, 250, 80, "left")
+	love.graphics.printf("LEVEL", 240, 320, 40, "left")
+
+	love.graphics.setFont(font_3x5_3)
+	love.graphics.printf(math.floor(self.drain_rate).."/s", 240, 110, 120, "left")
+	local frames_left = self.score / self.drain_rate * 60
+	if frames_left <= 600 and frames_left % 4 < 2 and not self.game_over then love.graphics.setColor(1, 0.3, 0.3, 1) end
+	love.graphics.printf(formatTime(frames_left), 240, 270, 120, "left")
+	love.graphics.setColor(1, 1, 1, 1)
+	love.graphics.printf(math.floor(self.score), 240, 190, 90, "left")
+	love.graphics.printf(self.level, 240, 340, 50, "right")
+	love.graphics.printf(self:getSectionEndLevel(), 240, 370, 50, "right")
+
+	love.graphics.setFont(font_8x11)
+	love.graphics.printf(formatTime(self.frames), 64, 420, 160, "center")
+end
+
+function ScoreDrainGame:getHighscoreData()
+	return {
+		level = self.level,
+		frames = self.frames,
+	}
+end
+
+function ScoreDrainGame:getSectionEndLevel()
+	return math.floor(self.level / 100 + 1) * 100
+end
+
+function ScoreDrainGame:getBackground()
+	return math.floor(self.level / 100)
+end
+
+return ScoreDrainGame
--- a/tetris/modes/strategy.lua
+++ b/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,16 +98,17 @@ function StrategyGame:onLineClear(cleared_row_count)
 end

 function StrategyGame:updateScore(level, drop_bonus, cleared_lines)
-	if cleared_lines > 0 then
-		self.score = self.score + (
-			(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
-			cleared_lines * (cleared_lines * 2 - 1) * (self.combo * 2 - 1)
-		)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + cleared_lines - 1
-	else
+	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 * self.combo
+			)
+		else
+			self.combo = 1
+		end
 		self.drop_bonus = 0
-		self.combo = 1
 	end
 end

@@ -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

--- a/tetris/modes/survival_2020.lua
+++ b/tetris/modes/survival_2020.lua
@@ -174,16 +174,17 @@ function Survival2020Game:onLineClear(cleared_row_count)
 end

 function Survival2020Game:updateScore(level, drop_bonus, cleared_lines)
-	if cleared_lines > 0 then
-		self.score = self.score + (
-			(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
-			cleared_lines * (cleared_lines * 2 - 1) * (self.combo * 2 - 1)
-		)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + cleared_lines - 1
-	else
+	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 * self.combo
+			)
+		else
+			self.combo = 1
+		end
 		self.drop_bonus = 0
-		self.combo = 1
 	end
 end

--- a/tetris/modes/survival_a1.lua
+++ b/tetris/modes/survival_a1.lua
@@ -109,44 +109,45 @@ 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
+		self.level = new_level
 		end
 	end
 end

 function SurvivalA1Game:updateScore(level, drop_bonus, cleared_lines)
-	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.score = self.score + (
-			(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
-			cleared_lines * self.bravo * self.combo
-		)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + (cleared_lines - 1) * 2
-	else
+	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.combo * self.bravo
+			)
+		else
+			self.combo = 1
+		end
 		self.drop_bonus = 0
-		self.combo = 1
 	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
-			self.gm_conditions["level900"] = true
+		if self.score >= 126000 and self.frames <= frameTime(13,30) then
+			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")
--- a/tetris/modes/survival_a2.lua
+++ b/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,17 +108,18 @@ function SurvivalA2Game:onLineClear(cleared_row_count)
 end

 function SurvivalA2Game:updateScore(level, drop_bonus, cleared_lines)
-	if self.grid:checkForBravo(cleared_lines) then self.bravo = 4 else self.bravo = 1 end
-	if cleared_lines > 0 then
-		self.score = self.score + (
-			(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
-			cleared_lines * self.bravo * self.combo
-		)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + (cleared_lines - 1) * 2
-	else
+	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
-		self.combo = 1
 	end
 end

@@ -156,6 +157,8 @@ function SurvivalA2Game:drawScoringInfo()

 	love.graphics.setFont(font_3x5_3)
 	love.graphics.printf(self.score, text_x, 220, 90, "left")
+	if self.roll_frames > 2968 then love.graphics.setColor(1, 0.5, 0, 1)
+	elseif self.clear then love.graphics.setColor(0, 1, 0, 1) end
 	if self:getLetterGrade() ~= "" then love.graphics.printf(self:getLetterGrade(), text_x, 140, 90, "left") end
 	love.graphics.printf(self.level, text_x, 340, 40, "right")
 	love.graphics.printf(self:getSectionEndLevel(), text_x, 370, 40, "right")
--- a/tetris/modes/survival_a3.lua
+++ b/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,16 +166,17 @@ function SurvivalA3Game:onPieceLock(piece, cleared_row_count)
 end

 function SurvivalA3Game:updateScore(level, drop_bonus, cleared_lines)
-	if cleared_lines > 0 then
-		self.score = self.score + (
-			(math.ceil((level + cleared_lines) / 4) + drop_bonus) *
-			cleared_lines * (cleared_lines * 2 - 1) * (self.combo * 2 - 1)
-		)
-		self.lines = self.lines + cleared_lines
-		self.combo = self.combo + cleared_lines - 1
-	else
+	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 * self.combo
+			)
+		else
+			self.combo = 1
+		end
 		self.drop_bonus = 0
-		self.combo = 1
 	end
 end

@@ -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
--- a/tetris/modes/tgmplus.lua
+++ b/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
--- a/tetris/modes/unrefactored_modes/pacer_test.lua
+++ b/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
--- a/tetris/rulesets/arika_srs.lua
+++ b/tetris/rulesets/arika_srs.lua
@@ -18,8 +18,6 @@ SRS.colourscheme = {
 SRS.softdrop_lock = false
 SRS.harddrop_lock = true

-SRS.enable_IRS_wallkicks = true
-
 SRS.spawn_positions = {
 	I = { x=5, y=2 },
 	J = { x=4, y=3 },
--- a/tetris/rulesets/crap.lua
+++ b/tetris/rulesets/crap.lua
@@ -0,0 +1,173 @@
+local Piece = require 'tetris.components.piece'
+local Ruleset = require 'tetris.rulesets.ruleset'
+
+local CRAP = Ruleset:extend()
+
+CRAP.name = "C.R.A.P."
+CRAP.hash = "Completely Random Auto-Positioner"
+CRAP.world = true
+CRAP.colors={"C","O","M","R","G","Y","B"}
+CRAP.colourscheme = {
+    I = CRAP.colors[math.ceil(math.random(7))],
+    L = CRAP.colors[math.ceil(math.random(7))],
+    J = CRAP.colors[math.ceil(math.random(7))],
+    S = CRAP.colors[math.ceil(math.random(7))],
+    Z = CRAP.colors[math.ceil(math.random(7))],
+    O = CRAP.colors[math.ceil(math.random(7))],
+    T = CRAP.colors[math.ceil(math.random(7))],
+}
+CRAP.softdrop_lock = true
+CRAP.harddrop_lock = false
+
+CRAP.enable_IRS_wallkicks = true
+
+CRAP.spawn_positions = {
+	I = { x=5, y=4 },
+	J = { x=4, y=5 },
+	L = { x=4, y=5 },
+	O = { x=5, y=5 },
+	S = { x=4, y=5 },
+	T = { x=4, y=5 },
+	Z = { x=4, y=5 },
+}
+
+CRAP.big_spawn_positions = {
+	I = { x=3, y=2 },
+	J = { x=2, y=3 },
+	L = { x=2, y=3 },
+	O = { x=3, y=3 },
+	S = { x=2, y=3 },
+	T = { x=2, y=3 },
+	Z = { x=2, y=3 },
+}
+
+CRAP.block_offsets = {
+	I={
+		{ {x=0, y=0}, {x=-1, y=0}, {x=-2, y=0}, {x=1, y=0} },
+		{ {x=0, y=0}, {x=0, y=-1}, {x=0, y=1}, {x=0, y=2} },
+		{ {x=0, y=1}, {x=-1, y=1}, {x=-2, y=1}, {x=1, y=1} },
+		{ {x=-1, y=0}, {x=-1, y=-1}, {x=-1, y=1}, {x=-1, y=2} },
+	},
+	J={
+		{ {x=0, y=0}, {x=-1, y=0}, {x=1, y=0}, {x=-1, y=-1} },
+		{ {x=0, y=0}, {x=0, y=-1}, {x=0, y=1} , {x=1, y=-1} },
+		{ {x=0, y=0}, {x=1, y=0}, {x=-1, y=0}, {x=1, y=1} },
+		{ {x=0, y=0}, {x=0, y=1}, {x=0, y=-1}, {x=-1, y=1} },
+	},
+	L={
+		{ {x=0, y=0}, {x=-1, y=0}, {x=1, y=0}, {x=1, y=-1} },
+		{ {x=0, y=0}, {x=0, y=-1}, {x=0, y=1}, {x=1, y=1} },
+		{ {x=0, y=0}, {x=1, y=0}, {x=-1, y=0}, {x=-1, y=1} },
+		{ {x=0, y=0}, {x=0, y=1}, {x=0, y=-1}, {x=-1, y=-1} },
+	},
+	O={
+		{ {x=0, y=0}, {x=-1, y=0}, {x=-1, y=-1}, {x=0, y=-1} },
+		{ {x=0, y=0}, {x=-1, y=0}, {x=-1, y=-1}, {x=0, y=-1} },
+		{ {x=0, y=0}, {x=-1, y=0}, {x=-1, y=-1}, {x=0, y=-1} },
+		{ {x=0, y=0}, {x=-1, y=0}, {x=-1, y=-1}, {x=0, y=-1} },
+	},
+	S={
+		{ {x=1, y=-1}, {x=0, y=-1}, {x=0, y=0}, {x=-1, y=0} },
+		{ {x=1, y=1}, {x=1, y=0}, {x=0, y=0}, {x=0, y=-1} },
+		{ {x=-1, y=1}, {x=0, y=1}, {x=0, y=0}, {x=1, y=0} },
+		{ {x=-1, y=-1}, {x=-1, y=0}, {x=0, y=0}, {x=0, y=1} },
+	},
+	T={
+		{ {x=0, y=0}, {x=-1, y=0}, {x=1, y=0}, {x=0, y=-1} },
+		{ {x=0, y=0}, {x=0, y=-1}, {x=0, y=1}, {x=1, y=0} },
+		{ {x=0, y=0}, {x=1, y=0}, {x=-1, y=0}, {x=0, y=1} },
+		{ {x=0, y=0}, {x=0, y=1}, {x=0, y=-1}, {x=-1, y=0} },
+	},
+	Z={
+		{ {x=-1, y=-1}, {x=0, y=-1}, {x=0, y=0}, {x=1, y=0} },
+		{ {x=1, y=-1}, {x=1, y=0}, {x=0, y=0}, {x=0, y=1} },
+		{ {x=1, y=1}, {x=0, y=1}, {x=0, y=0}, {x=-1, y=0} },
+		{ {x=-1, y=1}, {x=-1, y=0}, {x=0, y=0}, {x=0, y=-1} },
+	}
+}
+
+-- Component functions.
+
+function CRAP:attemptRotate(new_inputs, piece, grid, initial)
+	local rot_dir = 0
+	
+	if (new_inputs["rotate_left"] or new_inputs["rotate_left2"]) then
+		rot_dir = 3
+	elseif (new_inputs["rotate_right"] or new_inputs["rotate_right2"]) then
+		rot_dir = 1
+	elseif (new_inputs["rotate_180"]) then
+		rot_dir = self:get180RotationValue()
+	end
+
+	if rot_dir == 0 then return end
+    if self.world and config.gamesettings.world_reverse == 2 then
+        rot_dir = 4 - rot_dir
+    end
+	
+	local new_piece = piece:withRelativeRotation(rot_dir)
+	
+	self:attemptWallkicks(piece, new_piece, rot_dir, grid)
+end
+
+function CRAP:attemptWallkicks(piece, new_piece, rot_dir, grid)
+
+	for i=1,20 do
+		dx=math.floor(math.random(11))-5
+		dy=math.floor(math.random(11))-5
+		if grid:canPlacePiece(new_piece:withOffset({x=dx, y=dy})) then
+			piece:setRelativeRotation(rot_dir):setOffset({x=dx, y=dy})
+			self:onPieceRotate(piece, grid)
+			return
+		end
+	end
+	
+end
+
+function CRAP:onPieceCreate(piece, grid)
+	CRAP:randomizeColours()
+	piece.manipulations = 0
+	piece.rotations = 0
+end
+
+function CRAP:onPieceDrop(piece, grid)
+	CRAP:randomizeColours()
+	piece.lock_delay = 0 -- step reset
+end
+
+function CRAP:onPieceMove(piece, grid)
+	CRAP:randomizeColours()
+	piece.lock_delay = 0 -- move reset
+	if piece:isDropBlocked(grid) then
+		piece.manipulations = piece.manipulations + 1
+		if piece.manipulations >= 10 then
+			piece.locked = true
+		end
+	end
+end
+
+function CRAP:onPieceRotate(piece, grid)
+	CRAP:randomizeColours()
+	piece.lock_delay = 0 -- rotate reset
+	if piece:isDropBlocked(grid) then
+		piece.rotations = piece.rotations + 1
+		if piece.rotations >= 8 then
+			piece.locked = true
+		end
+	end
+end
+
+function CRAP:get180RotationValue() return 2 end
+
+function CRAP:randomizeColours()
+	CRAP.colourscheme = {
+		I = CRAP.colors[math.ceil(math.random(7))],
+		L = CRAP.colors[math.ceil(math.random(7))],
+		J = CRAP.colors[math.ceil(math.random(7))],
+		S = CRAP.colors[math.ceil(math.random(7))],
+		Z = CRAP.colors[math.ceil(math.random(7))],
+		O = CRAP.colors[math.ceil(math.random(7))],
+		T = CRAP.colors[math.ceil(math.random(7))],
+	}
+end
+
+return CRAP
--- a/tetris/rulesets/dtet.lua
+++ b/tetris/rulesets/dtet.lua
@@ -0,0 +1,153 @@
+local Piece = require 'tetris.components.piece'
+local Ruleset = require 'tetris.rulesets.ruleset'
+
+local DTET = Ruleset:extend()
+
+DTET.name = "D.R.S."
+DTET.hash = "DTET"
+
+DTET.spawn_positions = {
+	I = { x=5, y=4 },
+	J = { x=4, y=5 },
+	L = { x=4, y=5 },
+	O = { x=5, y=5 },
+	S = { x=4, y=5 },
+	T = { x=4, y=5 },
+	Z = { x=4, y=5 },
+}
+
+DTET.big_spawn_positions = {
+	I = { x=3, y=2 },
+	J = { x=2, y=3 },
+	L = { x=2, y=3 },
+	O = { x=3, y=3 },
+	S = { x=2, y=3 },
+	T = { x=2, y=3 },
+	Z = { x=2, y=3 },
+}
+
+DTET.block_offsets = {
+	I={
+		{ {x=0, y=0}, {x=-1, y=0}, {x=-2, y=0}, {x=1, y=0} },
+        { {x=-1, y=-1}, {x=-1, y=-2}, {x=-1, y=0}, {x=-1, y=1} },
+		{ {x=0, y=0}, {x=-1, y=0}, {x=-2, y=0}, {x=1, y=0} },
+        { {x=0, y=-1}, {x=0, y=-2}, {x=0, y=0}, {x=0, y=1} },
+	},
+	J={
+        { {x=0, y=-1}, {x=-1, y=-1}, {x=1, y=-1}, {x=1, y=0} },
+		{ {x=0, y=-1}, {x=0, y=-2}, {x=0, y=0}, {x=-1, y=0} },
+        { {x=0, y=0}, {x=-1, y=0}, {x=1, y=0}, {x=-1, y=-1} },
+		{ {x=0, y=-1}, {x=1, y=-2}, {x=0, y=-2}, {x=0, y=0} },
+	},
+	L={
+        { {x=0, y=-1}, {x=-1, y=-1}, {x=1, y=-1}, {x=-1, y=0} },
+		{ {x=0, y=-1}, {x=-1, y=-2}, {x=0, y=-2}, {x=0, y=0} },
+        { {x=0, y=0}, {x=-1, y=0}, {x=1, y=0}, {x=1, y=-1} },
+	    { {x=0, y=-2}, {x=0, y=-1}, {x=1, y=0}, {x=0, y=0} },
+	},
+	O={
+		{ {x=0, y=0}, {x=-1, y=0}, {x=-1, y=-1}, {x=0, y=-1} },
+		{ {x=0, y=0}, {x=-1, y=0}, {x=-1, y=-1}, {x=0, y=-1} },
+		{ {x=0, y=0}, {x=-1, y=0}, {x=-1, y=-1}, {x=0, y=-1} },
+		{ {x=0, y=0}, {x=-1, y=0}, {x=-1, y=-1}, {x=0, y=-1} },
+	},
+	S={
+		{ {x=1, y=-1}, {x=0, y=-1}, {x=0, y=0}, {x=-1, y=0} },
+		{ {x=-1, y=-2}, {x=-1, y=-1}, {x=0, y=-1}, {x=0, y=0} },
+		{ {x=-1, y=0}, {x=0, y=0}, {x=0, y=-1}, {x=1, y=-1} },
+		{ {x=1, y=0}, {x=1, y=-1}, {x=0, y=-1}, {x=0, y=-2} },
+	},
+	T={
+		{ {x=0, y=-1}, {x=-1, y=-1}, {x=1, y=-1}, {x=0, y=0} },
+		{ {x=0, y=-1}, {x=0, y=0}, {x=-1, y=-1}, {x=0, y=-2} },
+        { {x=0, y=0}, {x=-1, y=0}, {x=1, y=0}, {x=0, y=-1} },
+		{ {x=0, y=-1}, {x=0, y=0}, {x=1, y=-1}, {x=0, y=-2} },
+	},
+	Z={
+		{ {x=1, y=0}, {x=0, y=0}, {x=0, y=-1}, {x=-1, y=-1} },
+		{ {x=-1, y=0}, {x=-1, y=-1}, {x=0, y=-1}, {x=0, y=-2} },
+		{ {x=1, y=0}, {x=0, y=0}, {x=0, y=-1}, {x=-1, y=-1} },
+		{ {x=1, y=-2}, {x=1, y=-1}, {x=0, y=-1}, {x=0, y=0} },
+	}
+}
+
+-- clockwise kicks: {{x=1, y=0}, {x=-1, y=0}, {x=0, y=1}, {x=1, y=1}, {x=-1, y=1}},
+-- counterclockwise kicks: {{x=-1, y=0}, {x=1, y=0}, {x=0, y=1}, {x=-1, y=1}, {x=1, y=1}},
+
+DTET.wallkicks_3x3 = {
+	[0]={
+		[1]={{x=1, y=0}, {x=-1, y=0}, {x=0, y=1}, {x=1, y=1}, {x=-1, y=1}},
+		[2]={{x=-1, y=0}, {x=1, y=0}, {x=0, y=1}, {x=-1, y=1}, {x=1, y=1}},
+		[3]={{x=-1, y=0}, {x=1, y=0}, {x=0, y=1}, {x=-1, y=1}, {x=1, y=1}},
+	},
+	[1]={
+		[0]={{x=-1, y=0}, {x=1, y=0}, {x=0, y=1}, {x=-1, y=1}, {x=1, y=1}},
+		[2]={{x=1, y=0}, {x=-1, y=0}, {x=0, y=1}, {x=1, y=1}, {x=-1, y=1}},
+		[3]={{x=-1, y=0}, {x=1, y=0}, {x=0, y=1}, {x=-1, y=1}, {x=1, y=1}},
+	},
+	[2]={
+		[0]={{x=-1, y=0}, {x=1, y=0}, {x=0, y=1}, {x=-1, y=1}, {x=1, y=1}},
+		[1]={{x=-1, y=0}, {x=1, y=0}, {x=0, y=1}, {x=-1, y=1}, {x=1, y=1}},
+		[3]={{x=1, y=0}, {x=-1, y=0}, {x=0, y=1}, {x=1, y=1}, {x=-1, y=1}},
+	},
+	[3]={
+		[0]={{x=1, y=0}, {x=-1, y=0}, {x=0, y=1}, {x=1, y=1}, {x=-1, y=1}},
+		[1]={{x=-1, y=0}, {x=1, y=0}, {x=0, y=1}, {x=-1, y=1}, {x=1, y=1}},
+		[2]={{x=-1, y=0}, {x=1, y=0}, {x=0, y=1}, {x=-1, y=1}, {x=1, y=1}},
+	},
+};
+
+DTET.wallkicks_line = {
+	[0]={
+		[1]={{x=1, y=0}, {x=-1, y=0}, {x=0, y=1}, {x=1, y=1}, {x=-1, y=1}},
+		[2]={{x=-1, y=0}, {x=1, y=0}, {x=0, y=1}, {x=-1, y=1}, {x=1, y=1}},
+		[3]={{x=-1, y=0}, {x=1, y=0}, {x=0, y=1}, {x=-1, y=1}, {x=1, y=1}},
+	},
+	[1]={
+		[0]={{x=-1, y=0}, {x=1, y=0}, {x=0, y=1}, {x=-1, y=1}, {x=1, y=1}},
+		[2]={{x=1, y=0}, {x=-1, y=0}, {x=0, y=1}, {x=1, y=1}, {x=-1, y=1}},
+		[3]={{x=-1, y=0}, {x=1, y=0}, {x=0, y=1}, {x=-1, y=1}, {x=1, y=1}},
+	},
+	[2]={
+		[0]={{x=-1, y=0}, {x=1, y=0}, {x=0, y=1}, {x=-1, y=1}, {x=1, y=1}},
+		[1]={{x=1, y=0}, {x=-1, y=0}, {x=0, y=1}, {x=1, y=1}, {x=-1, y=1}},
+		[3]={{x=-1, y=0}, {x=1, y=0}, {x=0, y=1}, {x=-1, y=1}, {x=1, y=1}},
+	},
+	[3]={
+		[0]={{x=1, y=0}, {x=-1, y=0}, {x=0, y=1}, {x=1, y=1}, {x=-1, y=1}},
+		[1]={{x=-1, y=0}, {x=1, y=0}, {x=0, y=1}, {x=-1, y=1}, {x=1, y=1}},
+		[2]={{x=-1, y=0}, {x=1, y=0}, {x=0, y=1}, {x=-1, y=1}, {x=1, y=1}},
+	},
+};
+
+function DTET:attemptWallkicks(piece, new_piece, rot_dir, grid)
+
+	local kicks
+	if piece.shape == "O" then
+		return
+	elseif piece.shape == "I" then
+		kicks = DTET.wallkicks_line[piece.rotation][new_piece.rotation]
+	else
+		kicks = DTET.wallkicks_3x3[piece.rotation][new_piece.rotation]
+	end
+
+	assert(piece.rotation ~= new_piece.rotation)
+
+	for idx, offset in pairs(kicks) do
+		kicked_piece = new_piece:withOffset(offset)
+		if grid:canPlacePiece(kicked_piece) then
+			piece:setRelativeRotation(rot_dir)
+			piece:setOffset(offset)
+			self:onPieceRotate(piece, grid)
+			return
+		end
+	end
+end
+
+function DTET:onPieceDrop(piece, grid)
+	piece.lock_delay = 0 -- step reset
+end
+
+function DTET:getDefaultOrientation() return 1 end
+
+return DTET
--- a/tetris/rulesets/eheart.lua
+++ b/tetris/rulesets/eheart.lua
@@ -0,0 +1,45 @@
+local Piece = require 'tetris.components.piece'
+local ARS = require 'tetris.rulesets.arika'
+
+local EHeart = ARS:extend()
+
+EHeart.name = "E-Heart ARS"
+EHeart.hash = "EHeartARS"
+
+function EHeart:attemptWallkicks(piece, new_piece, rot_dir, grid)
+
+	-- I and O don't kick
+	if (piece.shape == "I" or piece.shape == "O") then return end
+
+	-- center column rule (kicks)
+	local offsets = new_piece:getBlockOffsets()
+        table.sort(offsets, function(A, B) return A.y < B.y or A.y == B.y and A.x < B.y end)
+        for index, offset in pairs(offsets) do
+            if grid:isOccupied(piece.position.x + offset.x, piece.position.y + offset.y) then
+		-- individual checks for all 9 cells, in the given order
+                if offset.y < 0 then
+			if offset.x < 0 then self:lateralKick(1, piece, new_piece, rot_dir, grid)
+			elseif offset.x == 0 then return
+			elseif offset.x > 0 then self:lateralKick(-1, piece, new_piece, rot_dir, grid) end
+		elseif offset.y == 0 then
+			if offset.x < 0 then self:lateralKick(1, piece, new_piece, rot_dir, grid)
+                        elseif offset.x == 0 then return
+                        elseif offset.x > 0 then self:lateralKick(-1, piece, new_piece, rot_dir, grid) end
+                elseif offset.y > 0 then
+			if offset.x < 0 then self:lateralKick(1, piece, new_piece, rot_dir, grid)
+                        elseif offset.x == 0 then return
+                        elseif offset.x > 0 then self:lateralKick(-1, piece, new_piece, rot_dir, grid) end
+                end
+            end
+        end
+
+end
+
+function EHeart:lateralKick(dx, piece, new_piece, rot_dir, grid)
+	if (grid:canPlacePiece(new_piece:withOffset({x=dx, y=0}))) then
+		piece:setRelativeRotation(rot_dir):setOffset({x=dx, y=0})
+		self:onPieceRotate(piece, grid)
+	end
+end
+
+return EHeart
--- a/tetris/rulesets/pptprs.lua
+++ b/tetris/rulesets/pptprs.lua
@@ -0,0 +1,102 @@
+local Piece = require 'tetris.components.piece'
+local SRS = require 'tetris.rulesets.standard_exp'
+
+local PPTPRS = SRS:extend()
+
+PPTPRS.name = "PPTPRS"
+PPTPRS.hash = "Puyo Tetris Pentos"
+
+PPTPRS.block_offsets = {
+	I={
+		{ {x=0, y=0}, {x=-1, y=0}, {x=-2, y=0}, {x=1, y=0}, {x=-3, y=0} },
+		{ {x=0, y=0}, {x=0, y=-1}, {x=0, y=1}, {x=0, y=2}, {x=0, y=-2} },
+		{ {x=0, y=1}, {x=-1, y=1}, {x=-2, y=1}, {x=1, y=1}, {x=2, y=1} },
+		{ {x=-1, y=0}, {x=-1, y=-1}, {x=-1, y=1}, {x=-1, y=2}, {x=-1, y=3} },
+	},
+	J={
+		{ {x=0, y=0}, {x=-1, y=0}, {x=1, y=0}, {x=-1, y=-1}, {x=0, y=1} },
+		{ {x=0, y=0}, {x=0, y=-1}, {x=0, y=1} , {x=1, y=-1}, {x=-1, y=0} },
+		{ {x=0, y=0}, {x=1, y=0}, {x=-1, y=0}, {x=1, y=1}, {x=0, y=-1} },
+		{ {x=0, y=0}, {x=0, y=1}, {x=0, y=-1}, {x=-1, y=1}, {x=1, y=0} },
+	},
+	L={
+		{ {x=0, y=0}, {x=-1, y=0}, {x=1, y=0}, {x=1, y=-1}, {x=-1, y=1} },
+		{ {x=0, y=0}, {x=0, y=-1}, {x=0, y=1}, {x=1, y=1}, {x=-1, y=-1} },
+		{ {x=0, y=0}, {x=1, y=0}, {x=-1, y=0}, {x=-1, y=1}, {x=1, y=-1} },
+		{ {x=0, y=0}, {x=0, y=1}, {x=0, y=-1}, {x=-1, y=-1}, {x=1, y=1} },
+	},
+	O={
+		{ {x=0, y=0}, {x=-1, y=0}, {x=-1, y=-1}, {x=0, y=-1}, {x=-1, y=1} },
+		{ {x=0, y=0}, {x=-1, y=0}, {x=-1, y=-1}, {x=0, y=-1}, {x=-2, y=-1} },
+		{ {x=0, y=0}, {x=-1, y=0}, {x=-1, y=-1}, {x=0, y=-1}, {x=0, y=-2} },
+		{ {x=0, y=0}, {x=-1, y=0}, {x=-1, y=-1}, {x=0, y=-1}, {x=1, y=0} },
+	},
+	S={
+		{ {x=1, y=-1}, {x=0, y=-1}, {x=0, y=0}, {x=-1, y=0}, {x=-2, y=0} },
+		{ {x=1, y=1}, {x=1, y=0}, {x=0, y=0}, {x=0, y=-1}, {x=0, y=-2} },
+		{ {x=-1, y=1}, {x=0, y=1}, {x=0, y=0}, {x=1, y=0}, {x=2, y=0} },
+		{ {x=-1, y=-1}, {x=-1, y=0}, {x=0, y=0}, {x=0, y=1}, {x=0, y=2} },
+	},
+	T={
+		{ {x=0, y=0}, {x=-1, y=0}, {x=1, y=0}, {x=0, y=-1}, {x=0, y=-2} },
+		{ {x=0, y=0}, {x=0, y=-1}, {x=0, y=1}, {x=1, y=0}, {x=2, y=0} },
+		{ {x=0, y=0}, {x=1, y=0}, {x=-1, y=0}, {x=0, y=1}, {x=0, y=2} },
+		{ {x=0, y=0}, {x=0, y=1}, {x=0, y=-1}, {x=-1, y=0}, {x=-2, y=0} },
+	},
+	Z={
+		{ {x=-1, y=-1}, {x=0, y=-1}, {x=0, y=0}, {x=1, y=0}, {x=1, y=1} },
+		{ {x=1, y=-1}, {x=1, y=0}, {x=0, y=0}, {x=0, y=1}, {x=-1, y=1} },
+		{ {x=1, y=1}, {x=0, y=1}, {x=0, y=0}, {x=-1, y=0}, {x=-1, y=-1} },
+		{ {x=-1, y=1}, {x=-1, y=0}, {x=0, y=0}, {x=0, y=-1}, {x=1, y=-1} },
+	}
+}
+
+PPTPRS.wallkicks_O = {
+	[0]={
+		[1]={{x=0, y=1}},
+		[2]={{x=0, y=1}},
+		[3]={{x=-1, y=0}},
+	},
+	[1]={
+                [0]={{x=0, y=-1}},
+                [2]={{x=-1, y=0}},
+                [3]={{x=-1, y=0}},
+        },
+	[2]={
+                [0]={{x=0, y=-1}},
+                [1]={{x=1, y=0}},
+                [3]={{x=0, y=-1}},
+        },
+	[3]={
+                [0]={{x=1, y=0}},
+                [1]={{x=1, y=0}},
+                [2]={{x=0, y=1}},
+        },
+}
+
+function PPTPRS:attemptWallkicks(piece, new_piece, rot_dir, grid)
+	local kicks
+
+	if piece.shape == "O" then
+		kicks = PPTPRS.wallkicks_O[piece.rotation][new_piece.rotation]
+	elseif piece.shape == "I" then
+		kicks = SRS.wallkicks_line[piece.rotation][new_piece.rotation]
+	else
+		kicks = SRS.wallkicks_3x3[piece.rotation][new_piece.rotation]
+	end
+
+	assert(piece.rotation ~= new_piece.rotation)
+
+	for idx, offset in pairs(kicks) do
+		kicked_piece = new_piece:withOffset(offset)
+		if grid:canPlacePiece(kicked_piece) then
+			piece:setRelativeRotation(rot_dir)
+			piece:setOffset(offset)
+			self:onPieceRotate(piece, grid)
+			return
+		end
+	end
+
+end
+
+return PPTPRS
--- a/tetris/rulesets/ruleset.lua
+++ b/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 = {}

--- a/tetris/rulesets/ti_srs.lua
+++ b/tetris/rulesets/ti_srs.lua
@@ -18,8 +18,6 @@ SRS.colourscheme = {
 SRS.softdrop_lock = false
 SRS.harddrop_lock = true

-SRS.enable_IRS_wallkicks = true
-
 SRS.spawn_positions = {
 	I = { x=5, y=4 },
 	J = { x=4, y=5 },
Author	SHA1	Message	Date
Ishaan Bhardwaj	f52da36bf7	TGM3 cool system change	2020-11-06 14:01:28 -05:00
Ishaan Bhardwaj	76142c1dff	More Green Orange line	2020-11-05 16:21:58 -05:00
Ishaan Bhardwaj	a3458e2413	Fix Arika SRS	2020-11-04 22:46:45 -05:00
Ishaan Bhardwaj	7eba9c012f	Merge branch 'master' of https://github.com/sashlilac/cambridge	2020-11-04 16:58:11 -05:00
Ishaan Bhardwaj	4d2868b7b6	Small changes.	2020-11-04 16:57:44 -05:00
Ishaan Bhardwaj	2e6fcd232b	Update README.md	2020-11-04 08:42:42 -05:00
Ishaan Bhardwaj	10833f2ec1	Score drain changes	2020-11-03 23:20:41 -05:00
Ishaan Bhardwaj	abb2b9491e	Preparing for v0.2.1	2020-11-03 23:04:47 -05:00
Ishaan Bhardwaj	062ab2005e	v0.2 release commit - hold piece darken	2020-11-03 16:56:08 -05:00
Ishaan Bhardwaj	468025fc80	last commit to core modes before release	2020-11-03 12:17:36 -05:00
Ishaan Bhardwaj	c8544975d6	Fix interval training	2020-11-03 11:55:30 -05:00
Ishaan Bhardwaj	6776229bfb	Small push to Cambridge modes	2020-11-03 11:52:52 -05:00
Ishaan Bhardwaj	84b4dc5073	World Bone Blocks	2020-11-03 10:58:21 -05:00
Ishaan Bhardwaj	35dafb6615	keep leaving debug code in new commits	2020-11-02 22:51:16 -05:00
Ishaan Bhardwaj	3641d85fcb	Major changes, including modpack support	2020-11-02 22:47:58 -05:00
Ishaan Bhardwaj	9b89c4d1de	G/O line fix	2020-11-02 21:17:13 -05:00
Ishaan Bhardwaj	2dba120919	Green line and orange line for TAP Master	2020-11-02 20:43:10 -05:00
Ishaan Bhardwaj	9224f271b1	Hotfix for last	2020-11-02 16:20:22 -05:00
Ishaan Bhardwaj	febb5d546c	Score overhauls	2020-11-02 16:12:05 -05:00
Ishaan Bhardwaj	c6482c423e	4w optimization and green/orange line adding for applicable modes	2020-11-02 13:46:16 -05:00
Ishaan Bhardwaj	6beb313c6b	Debug fixes	2020-11-02 12:44:15 -05:00
Ishaan Bhardwaj	eb70f55b6e	TGM2 fixes and cool fixes	2020-11-02 12:21:12 -05:00
Ishaan Bhardwaj	0badcde9ad	Basset: the only person to leave debug code in a repo	2020-11-01 13:44:35 -05:00
Ishaan Bhardwaj	6f39b591d3	Hotfix for TGM+	2020-11-01 13:28:13 -05:00
Ishaan Bhardwaj	129237f0b0	TGM+	2020-11-01 13:24:52 -05:00
Ishaan Bhardwaj	741c246244	second lol	2020-11-01 12:04:07 -05:00
Ishaan Bhardwaj	b5937af8b2	lol	2020-11-01 12:01:26 -05:00
Ishaan Bhardwaj	33b8533d8e	Fixes to TAP M-roll requirements	2020-11-01 11:06:43 -05:00
Ishaan Bhardwaj	69959ff687	TA Death level advance formula is very bugged	2020-10-30 21:36:05 -04:00
Ishaan Bhardwaj	f91cd99dfd	Minor fixes to TGM modes	2020-10-30 21:28:39 -04:00
Ishaan Bhardwaj	be59727ca5	Some demon mode fixes	2020-10-30 13:09:49 -04:00
Ishaan Bhardwaj	cca295066c	Fix.	2020-10-29 23:05:49 -04:00
Ishaan Bhardwaj	f2862b4d93	Some score fixes for core TGM modes	2020-10-29 23:03:54 -04:00
Ishaan Bhardwaj	2aafd30253	Fixed secret grade detection	2020-10-29 22:14:34 -04:00
Ishaan Bhardwaj	b27ba335ba	Improved secret grade	2020-10-29 21:40:50 -04:00
Ishaan Bhardwaj	33244736b8	Secret grade for sprint? Also ARR and DAS change so remember to change it in the lua file	2020-10-29 20:56:18 -04:00
Ishaan Bhardwaj	285108ca08	ACTUALLY fixed TI Master torikan	2020-10-26 14:07:09 -04:00
Ishaan Bhardwaj	4b1fed727c	Update marathon_a3.lua	2020-10-26 14:03:09 -04:00
Ishaan Bhardwaj	9fca272e8d	Update ck.lua	2020-10-24 09:12:12 -04:00
Ishaan Bhardwaj	5a21c8244b	Update README.md	2020-10-23 21:28:32 -04:00
Ishaan Bhardwaj	4923b2e2d4	Removed debug code	2020-10-23 21:23:45 -04:00