SG!!!!

- History 4-rolls, history 6-rolls and history 6-rolls 35-bag no longer deal S, Z or O as their first piece
- Added a 7-bag randomiser with the same behaviour (bag7noSZOstart)
- Tweaked the "35-bag" part of the history 6-rolls 35-bag randomiser to work closer to what it's supposed to be
- Switched Marathon AX4's randomiser from history 6-rolls to 7-bag no SZO start

CONTRIBUTING.md

@@ -1,47 +1,3 @@
-Coding conventions
-------------------
-
-* Use tabs to indent, spaces to align.
-	* Specifically, spaces should not appear at the beginning of a line, and tabs should not appear _except_ at the beginning of a line.
-	* The sole exception is in a multiline `if` statement; the initial `if` should have four spaces before it to align it with an `elseif` on the next line. For example:
-
-```lua
-	---- 4 spaces
-	    if self.level <  900 then return 12
-	elseif self.level < 1200 then return 8
-	else return 6 end
-```
-
-* Comments at the end of lines of code must be one line long. Multi-line comments must appear in their own block.
-
-```lua
-	if self.piece:isDropBlocked(self.grid) then
-		-- this is a comment that appears in a block of its own, separate from any code
-		-- consecutive multiline comments must have the same indentation level and
-		-- not appear next on the same line as actual code
-		self.drop_bonus = math.min(self.drop_bonus - 1, 0) -- comments at the end of a line must stay on that line
-	else                                                            
-		if piece_dy >= 1 then                                       -- basically
-			self.drop_bonus = self.drop_bonus + piece_dy * 20       -- this sort of
-		end                                                         -- multiline comment
-		self.drop_bonus = self.drop_bonus + 1                       -- is completely
-	end                                                             -- unacceptable
-```
-
-* Use `snake_case` for variables, `camelCase` for functions.
-
-```lua
-	function MyGameMode:on_activate_bleep_bloop()
-		-- no, bad, use "onActivateBleepBloop"
-		local bleepBloopFrames = 240
-		-- this is also bad, use "bleep_bloop_frames"
-		local bleep_bloop_bonus = self.lock_delay * 150
-		self.bleepBloopSubscore = self.bleepBloopSubscore + bleep_bloop_bonus
-		-- member variables are also variables, this should be "bleep_bloop_subscore"
-	end
-```
-
-
 Contributor's License Agreement
 -------------------------------
 
@@ -50,3 +6,93 @@ By contributing source code or other assets (e.g. music, artwork, graphics) to C
 You also waive all moral rights to your contributions insofar as they are used in the Cambridge repository or in any code or works deriving therefrom.
 
 (Notwithstanding the above clause, I will still make my best effort to provide sufficient attribution to all contributions. At the very least you'll get documentation of your contributions under SOURCES, and probably a special place in the credit roll as well.)
+
+
+Git / Repo conventions
+----------------------
+
+In general, use `kebab-case` for branch names. Also, make sure they're concise and descriptive - like 2 or 3 words is usually good.
+
+```
+* badbeef (badBranchName) This branch name is bad.
+| * defaced (another_bad_branch_name) This branch name is also bad because it uses snake case.
+|/
+| * deadcab (generic) This branch name isn't very descriptive.
+|/
+| * bac0040 (this-long-winded-branch-name-that-could-be-its-own-commit-message) Self-explanatory.
+|/
+| * 600db01 (good-branch-name) This branch name is good.
+|/
+* 0000420 (HEAD -> master, tag: v0.6.9) This is a sexy root commit.
+```
+
+The top line of a commit message should generally be one full sentence long, without too many subordinate clauses. Don't sweat 50/72, but try not go over about 100 characters either.
+* If the message starts with a verb, it should be written in the past tense, as a description of what the commit _did_ to the commit tree. (e.g. _Made_ a change, _Fixed_ a bug, _Added_ a feature)
+* Alternatively, include a description (in the present tense) of what is now true thanks to this commit. (e.g. "The Puyo Puyo mode can now support up to 50 players.")
+
+```
+* 800000d (message-too-long) Made multiplayer stuff play well with the new v0.2.5 server by fixing a problem the client was having with sending multiple 4-KB packets within 2 milliseconds of each other.
+| * defaced (not-descriptive-enough) Fixed stuff.
+|/
+| * bad0003 (present-tense) Lengthens the retry period of the server connection to 15 seconds.
+|/
+| * bad0004 (imperative-mood) Force the credit roll to end after 67 seconds if no input is detected.
+|/
+| * 600d001 (good-commit-summary) Made the Jenny Marathon mode not top out randomly at level 600.
+| * 600d002 (also-good) Backgrounds don't suck anymore.
+|/
+* 1234567 (HEAD -> master, tag: v0.4.2) Updated docs in preparation for a new release.
+```
+
+When making pull requests, always include:
+
+* A title that works well as a commit title, since that's what's going to appear when it's merged.
+* A full description of the problem that the pull request solves or the feature that it implements.
+	* If the whole purpose of the pull request is to resolve a particular issue and nothing else, "Fixes #[issue number]" counts as a full description. Otherwise if there's anything else in the pull request, make a short note of "also [did this other thing]".
+
+
+Coding conventions
+------------------
+
+Use tabs to indent, spaces to align.
+
+* Specifically, spaces should not appear at the beginning of a line, and tabs should not appear _except_ at the beginning of a line.
+* The sole exception is in a multiline `if` statement; the initial `if` should have four spaces before it to align it with an `elseif` on the next line. For example:
+
+```lua
+	---- 4 spaces
+	    if self.level <  900 then return 12
+	elseif self.level < 1200 then return 8
+	else return 6 end
+```
+
+Comments at the end of lines of code must be one line long. Multi-line comments must appear in their own block.
+
+```lua
+	if not self.piece:isDropBlocked(self.grid) then
+		-- this is a comment that appears in a block of its own, separate from any code
+		-- consecutive multiline comments must have the same indentation level and
+		-- not appear next on the same line as actual code
+		self.drop_bonus = 0 -- comments at the end of a line must stay on that line
+	else                                                            
+		if piece_dy >= 1 then                                       -- basically
+			self.drop_bonus = self.drop_bonus + piece_dy * 20       -- this sort of
+		end                                                         -- multiline comment
+		self.drop_bonus = self.drop_bonus + 1                       -- is completely
+	end                                                             -- unacceptable
+```
+
+Use `snake_case` for variables, `camelCase` for functions.
+
+```lua
+	function MyGameMode:on_activate_bleep_bloop()
+		-- no, bad, use "onActivateBleepBloop"
+		
+		local bleepBloopFrames = 240
+		-- this is also bad, use "bleep_bloop_frames"
+		
+		local bleep_bloop_bonus = self.lock_delay * 150
+		self.bleepBloopSubscore = self.bleepBloopSubscore + bleep_bloop_bonus
+		-- this should be self."bleep_bloop_subscore", member variables are also variables
+	end
+```

README.md

@@ -3,6 +3,14 @@ Cambridge
 
 Welcome to Cambridge, the next open-source falling-block game engine!
 
+This fork is written and maintained exclusively by [SashLilac](https://github.com/SashLilac) and [Oshisaure](https://github.com/oshisaure)!
+
+Credits
+-------
+
+- [Lilla Oshisaure](https://www.youtube.com/user/LeSpyroshisaure) for their amazing contributions to my life in general!
+- [The Tetra Legends Discord](http://discord.com/invite/7hMx5r2) for supporting me and playtesting!
+- [joezeng](https://github.com/joezeng) for the original project.
 
 Installation instructions
 -------------------------
@@ -15,7 +23,7 @@ Unzip the exe file and run it directly. All assets are currently bundled inside
 
 ### macOS
 
-For the time being, the file `cambridge.love` only works on the command line. Install `love` with [https://brew.sh/](Homebrew), and run:
+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
 
@@ -35,7 +43,7 @@ If you haven't already, install `love` with your favourite package manager (Home
 
 Clone the repository in git:
 
-    git clone https://github.com/joezeng/cambridge
+    git clone https://github.com/SashLilac/cambridge
 
 Then, navigate to the root directory that you just cloned, and type:
 

conf.lua

@@ -1,6 +1,8 @@
 function love.conf(t)
 	t.identity = "cambridge"
 
+	t.console = true
+
 	t.window.title = "Cambridge"
 	t.window.width = 640
 	t.window.height = 480

docs/gamemodes.md

@@ -1,13 +1,26 @@
 Game modes
 ==========
 
-There are several classes of game modes.
+There are several classes of game modes. The modes that originate from other games are organized by suffix:
 
+* The "C" series stand for "Classic" games, games that were produced before around 1992-1993 and generally have no wallkicks or lock delay.
+    * C84 - The original version from the Electronika 60.
+    * C88 - Sega Tetris.
+    * C89 - Nintendo / NES Tetris.
+* The "A" series stand for "Arika" games, or games in the Tetris the Grand Master series.
+    * A1 - Tetris The Grand Master (the original from 1998).
+    * A2 - Tetris The Absolute The Grand Master 2 PLUS.
+    * A3 - Tetris The Grand Master 3 Terror-Instinct.
+    * AX - Tetris The Grand Master ACE (X for Xbox).
+* The "G" series stand for "Guideline" games, or games that follow the Tetris Guideline.
+    * GF - Tetris Friends (2007-2019)
+    * GJ - Tetris Online Japan (2005-2011)
+* N stands for Nullpomino, only used for Phantom Mania N.
 
 MARATHON
 --------
 
-Modes in which the goal is to play as well as possible over a limited game interval, to ultimately achieve the title of Grand Master.
+Modes in which the goal is to play as well as possible over a limited game interval.
 
 * **MARATHON 2020**: 2020 levels of pure pain. Can you make it all the way?
 
@@ -15,6 +28,8 @@ From other games:
 * **MARATHON A1**: Tetris the Grand Master 1.
 * **MARATHON A2**: Tetris the Grand Master 2 (TAP Master).
 * **MARATHON A3**: Tetris the Grand Master 3 (no exams).
+* **MARATHON AX4**: Another mode from TGM Ace.
+* **MARATHON C89**: Nintendo NES Tetris. Can you transition and make it to the killscreen?
 
 
 SURVIVAL
@@ -30,6 +45,14 @@ From other games:
 * **SURVIVAL A3**: Ti Shirase.
 
 
+RACE
+----
+
+Modes with no levels, just a single timed goal.
+
+* **Race 40**: How fast can you clear 40 lines? No limits, no holds barred.
+
+
 PHANTOM MANIA
 -------------
 
@@ -40,6 +63,7 @@ Modes where pieces turn invisible as soon as you lock them. One of Cambridge's s
 * **Phantom Mania 2**: Phantom Mania but way faster! Can you face a mode where even the garbage and the next preview turn invisible?
 
 
+
 OTHER MODES
 -----------
 
@@ -47,4 +71,6 @@ OTHER MODES
 
 * **TetrisGram™ Pacer Test**: is a multi-stage piece-placing ability test that progressively gets more difficult as it continues.
 
-* **Interval Training**: 30 seconds per section. 20G. 15 frames of lock delay. How long can you last?
+* **Interval Training**: 30 seconds per section. 20G. 15 frames of lock delay. How long can you last?
+
+* **Demon Mode**: An original mode from Oshisaure! Can you push through the ever faster levels and not get denied?

funcs.lua

@@ -1,4 +1,5 @@
 function copy(t)
+	-- returns deep copy of t (as opposed to the shallow copy you get from var = t)
 	if type(t) ~= "table" then return t end
     local meta = getmetatable(t)
     local target = {}
@@ -7,7 +8,8 @@ function copy(t)
     return target
 end
 
-function st(tbl)
+function strTrueValues(tbl)
+	-- returns a concatenation of all the keys in tbl with value true, separated with spaces
 	str = ""
 	for k, v in pairs(tbl) do
 		if v == true then
@@ -17,14 +19,16 @@ function st(tbl)
 	return str
 end
 
-function sp(m, s, f)
+function frameTime(min, sec, hth)
-	if m == nil then m = 0 end
+	-- returns a time in frames from a time in minutes-seconds-hundredths format
-	if s == nil then s = 0 end
+	if min == nil then min = 0 end
-	if f == nil then f = 0 end
+	if sec == nil then sec = 0 end
-	return m*3600 + s*60 + math.ceil(f * 0.6)
+	if hth == nil then hth = 0 end
+	return min*3600 + sec*60 + math.ceil(hth * 0.6)
 end
 
 function vAdd(v1, v2)
+	-- returns the sum of vectors v1 and v2
 	return {
 		x = v1.x + v2.x,
 		y = v1.y + v2.y
@@ -32,6 +36,7 @@ function vAdd(v1, v2)
 end
 
 function vNeg(v)
+	-- returns the opposite of vector v
 	return {
 		x = -v.x,
 		y = -v.y
@@ -39,14 +44,18 @@ function vNeg(v)
 end
 
 function formatTime(frames)
+	-- returns a mm:ss:hh (h=hundredths) representation of the time in frames given 
 	if frames < 0 then return formatTime(0) end
-	str = string.format("%02d", math.floor(frames / 3600)) .. ":"
+	local min, sec, hund
-		.. string.format("%02d", math.floor(frames / 60) % 60) .. "."
+	min  = math.floor(frames/3600)
-		.. string.format("%02d", math.floor(frames / 0.6) % 100)
+	sec  = math.floor(frames/60) % 60
+	hund = math.floor(frames/.6) % 100
+	str = string.format("%02d:%02d.%02d", min, sec, hund)
 	return str
 end
 
 function formatBigNum(number)
+	-- returns a string representing a number with commas as thousands separator (e.g. 12,345,678)
 	local s = string.format("%d", number)
 	local pos = string.len(s) % 3
 	if pos == 0 then pos = 3 end

load/graphics.lua

@@ -20,6 +20,7 @@ backgrounds = {
 	love.graphics.newImage("res/backgrounds/1800-railways.png"),
 	love.graphics.newImage("res/backgrounds/1900-world-wide-web.png"),
 	title = love.graphics.newImage("res/backgrounds/title_v0.1.png"),
+    input_config = love.graphics.newImage("res/backgrounds/options-gears.png")
 }
 
 blocks = {
@@ -49,6 +50,12 @@ blocks = {
 	}
 }
 
+for name, blockset in pairs(blocks) do
+	for shape, image in pairs(blockset) do
+		image:setFilter("nearest")
+	end
+end
+
 misc_graphics = {
 	frame = love.graphics.newImage("res/img/frame.png"),
 	ready = love.graphics.newImage("res/img/ready.png"),

scene.lua

@@ -7,6 +7,7 @@ function Scene:update() end
 function Scene:render() end
 function Scene:onKeyPress() end
 
+ExitScene = require "scene.exit"
 GameScene = require "scene.game"
 ModeSelectScene = require "scene.mode_select"
 InputConfigScene = require "scene.input_config"

scene/exit.lua

@@ -0,0 +1,23 @@
+local ExitScene = Scene:extend()
+require 'load.save'
+
+ExitScene.title = "Exit Game"
+
+function ExitScene:new()
+end
+
+function ExitScene:update()
+    love.event.quit()
+end
+
+function ExitScene:render()
+end
+
+function ExitScene:changeOption(rel)
+end
+
+function ExitScene:onKeyPress(e)
+end
+
+return ExitScene
+

scene/game.lua

@@ -57,11 +57,21 @@ end
 
 function GameScene:onKeyPress(e)
 	if (self.game.completed) and
-		e.scancode == "return" and e.isRepeat == false then
+		(e.scancode == "return" or e.scancode == "escape") and e.isRepeat == false then
 		highscore_entry = self.game:getHighscoreData()
 		highscore_hash = self.game.hash .. "-" .. self.ruleset.hash
 		submitHighscore(highscore_hash, highscore_entry)
 		scene = ModeSelectScene()
+    elseif (e.scancode == config.input.retry) then
+        -- fuck this, this is hacky but the way this codebase is setup prevents anything else
+        -- it seems like all the values that get touched in the child gamemode class
+        -- stop being linked to the values of the GameMode superclass because of how `mt.__index` works
+        -- not even sure this is the actual problem, but I don't want to have to rebuild everything about 
+        -- the core organisation of everything. this hacky way will have to do until someone figures out something.
+        love.keypressed("escape", "escape", false)
+        love.keypressed("return", "return", false)
+    elseif e.scancode == "escape" then
+        scene = ModeSelectScene()
 	end
 end
 

scene/input_config.lua

@@ -15,6 +15,7 @@ local configurable_inputs = {
     "rotate_right2",
     "rotate_180",
     "hold",
+    "retry",
 }
 
 function ConfigScene:new()
@@ -27,6 +28,13 @@ function ConfigScene:update()
 end
 
 function ConfigScene:render()
+	love.graphics.setColor(1, 1, 1, 1)
+	love.graphics.draw(
+		backgrounds["input_config"],
+		0, 0, 0,
+		0.5, 0.5
+	)
+    
 	love.graphics.setFont(font_3x5_2)
 	for i, input in pairs(configurable_inputs) do
 		if config.input[input] then

scene/mode_select.lua

@@ -8,27 +8,33 @@ current_ruleset = 1
 game_modes = {
 	require 'tetris.modes.marathon_2020',
 	require 'tetris.modes.survival_2020',
-	require 'tetris.modes.strategy',
+	--require 'tetris.modes.strategy',
-	require 'tetris.modes.interval_training',
+	--require 'tetris.modes.interval_training',
-	require 'tetris.modes.pacer_test',
+	--require 'tetris.modes.pacer_test',
-	require 'tetris.modes.demon_mode',
+	--require 'tetris.modes.demon_mode',
 	require 'tetris.modes.phantom_mania',
 	require 'tetris.modes.phantom_mania2',
 	require 'tetris.modes.phantom_mania_n',
-	require 'tetris.modes.ligne',
+	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.marathon_l1',
+	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_srs',
 	require 'tetris.rulesets.standard_exp',
 	--require 'tetris.rulesets.bonkers',
 	--require 'tetris.rulesets.shirase',
@@ -95,6 +101,8 @@ function ModeSelectScene:onKeyPress(e)
 	elseif (e.scancode == config.input["left"] or e.scancode == "left") or
 		(e.scancode == config.input["right"] or e.scancode == "right") then
 		self:switchSelect()
+    elseif e.scancode == "escape" then
+        scene = TitleScene()
 	end
 end
 

scene/title.lua

@@ -3,6 +3,7 @@ local TitleScene = Scene:extend()
 local main_menu_screens = {
 	ModeSelectScene,
 	InputConfigScene,
+    ExitScene,
 }
 
 function TitleScene:new()
@@ -43,6 +44,8 @@ function TitleScene:onKeyPress(e)
 		self:changeOption(-1)
 	elseif (e.scancode == config.input["down"] or e.scancode == "down") and e.isRepeat == false then
 		self:changeOption(1)
+    elseif e.scancode == "escape" and e.isRepeat == false then
+        love.event.quit()
 	end
 end
 

tetris/components/grid.lua

@@ -3,6 +3,7 @@ local Object = require 'libs.classic'
 local Grid = Object:extend()
 
 local empty = { skin = "", colour = "" }
+local oob = { skin = "", colour = "" }
 
 function Grid:new()
 	self.grid = {}
@@ -26,8 +27,15 @@ function Grid:clear()
 	end
 end
 
+function Grid:getCell(x, y)
+    if x < 1 or x > 10 or y > 24 then return oob
+    elseif y < 1 then return empty
+    else return self.grid[y][x]
+    end
+end
+
 function Grid:isOccupied(x, y)
-	return self.grid[y+1][x+1] ~= empty
+	return self:getCell(x+1, y+1) ~= empty
 end
 
 function Grid:isRowFull(row)
@@ -38,11 +46,32 @@ function Grid:isRowFull(row)
 end
 
 function Grid:canPlacePiece(piece)
+	if piece.big then
+		return self:canPlaceBigPiece(piece)
+	end
+
 	local offsets = piece:getBlockOffsets()
 	for index, offset in pairs(offsets) do
 		local x = piece.position.x + offset.x
 		local y = piece.position.y + offset.y
-		if x >= 10 or x < 0 or y >= 24 or y < 0 or self.grid[y+1][x+1] ~= empty then
+		if self:isOccupied(x, y) then
+			return false
+		end
+	end
+	return true
+end
+
+function Grid:canPlaceBigPiece(piece)
+	local offsets = piece:getBlockOffsets()
+	for index, offset in pairs(offsets) do
+		local x = piece.position.x + offset.x
+		local y = piece.position.y + offset.y
+        if (
+           self:isOccupied(x * 2 + 0, y * 2 + 0)
+        or self:isOccupied(x * 2 + 1, y * 2 + 0)
+        or self:isOccupied(x * 2 + 0, y * 2 + 1)
+        or self:isOccupied(x * 2 + 1, y * 2 + 1)
+		) then
 			return false
 		end
 	end
@@ -50,11 +79,16 @@ function Grid:canPlacePiece(piece)
 end
 
 function Grid:canPlacePieceInVisibleGrid(piece)
+	if piece.big then
+		return self:canPlaceBigPiece(piece)
+		-- forget canPlaceBigPieceInVisibleGrid for now
+	end
+
 	local offsets = piece:getBlockOffsets()
 	for index, offset in pairs(offsets) do
 		local x = piece.position.x + offset.x
 		local y = piece.position.y + offset.y
-		if x >= 10 or x < 0 or y >= 24 or y < 4 or self.grid[y+1][x+1] ~= empty then
+		if y < 4 or self:isOccupied(x, y) ~= empty then
 			return false
 		end
 	end
@@ -116,17 +150,84 @@ function Grid:copyBottomRow()
 end
 
 function Grid:applyPiece(piece)
+	if piece.big then
+		self:applyBigPiece(piece)
+		return
+	end
 	offsets = piece:getBlockOffsets()
 	for index, offset in pairs(offsets) do
 		x = piece.position.x + offset.x
 		y = piece.position.y + offset.y
-		self.grid[y+1][x+1] = {
+		if y + 1 > 0 then
-			skin = piece.skin,
+			self.grid[y+1][x+1] = {
-			colour = piece.shape
+				skin = piece.skin,
-		}
+				colour = piece.shape
+			}
+		end
 	end
 end
 
+function Grid:applyBigPiece(piece)
+	offsets = piece:getBlockOffsets()
+	for index, offset in pairs(offsets) do
+		x = piece.position.x + offset.x
+		y = piece.position.y + offset.y
+		for a = 1, 2 do
+			for b = 1, 2 do
+                if y*2+a > 0 then
+                    self.grid[y*2+a][x*2+b] = {
+                        skin = piece.skin,
+                        colour = piece.shape
+                    }
+                end
+			end
+		end
+	end
+end
+
+function Grid:checkForBravo(cleared_row_count)
+	for i = 0, 23 - cleared_row_count do
+                for j = 0, 9 do
+                        if self:isOccupied(j, i) then return false end
+                end
+        end
+	return true
+end
+
+function Grid:checkSecretGrade()
+    local sgrade = 0
+    for i=23,5,-1 do
+        local validLine = true
+        local emptyCell = 0
+        if i > 13 then
+            emptyCell = 23-i
+        end
+        if i <= 13 then
+            emptyCell = i-5
+        end
+        for j=0,9 do
+            if (not self:isOccupied(j,i) and j ~= emptyCell) or (j == emptyCell and self:isOccupied(j,i)) then
+                validLine = false
+            end
+        end
+        if not self:isOccupied(emptyCell,i-1) then
+            validLine = false
+        end
+        if(validLine) then
+                    sgrade = sgrade + 1
+        else
+            -- return sgrade
+        end
+    end
+    --[[
+    if(sgrade == 0) then return ""
+    elseif(sgrade < 10) then return 10-sgrade
+    elseif(sgrade < 19) then return "S"..(sgrade-9) end
+    return "GM"
+    --]]
+    return sgrade
+end
+
 function Grid:update()
 	for y = 1, 24 do
 		for x = 1, 10 do
@@ -148,19 +249,21 @@ function Grid:draw()
 					love.graphics.setColor(0.5, 0.5, 0.5, 1)
 					love.graphics.draw(blocks[self.grid[y][x].skin][self.grid[y][x].colour], 48+x*16, y*16)
 				end
-				love.graphics.setColor(0.8, 0.8, 0.8, 1)
+				if self.grid[y][x].skin ~= "bone" then
-				love.graphics.setLineWidth(1)
+					love.graphics.setColor(0.8, 0.8, 0.8, 1)
-				if y > 1 and self.grid[y-1][x] == empty then
+					love.graphics.setLineWidth(1)
-					love.graphics.line(48.0+x*16, -0.5+y*16, 64.0+x*16, -0.5+y*16)
+					if y > 1 and self.grid[y-1][x] == empty then
-				end
+						love.graphics.line(48.0+x*16, -0.5+y*16, 64.0+x*16, -0.5+y*16)
-				if y < 24 and self.grid[y+1][x] == empty then
+					end
-					love.graphics.line(48.0+x*16, 16.5+y*16, 64.0+x*16, 16.5+y*16)
+					if y < 24 and self.grid[y+1][x] == empty then
-				end
+						love.graphics.line(48.0+x*16, 16.5+y*16, 64.0+x*16, 16.5+y*16)
-				if x > 1 and self.grid[y][x-1] == empty then
+					end
-					love.graphics.line(47.5+x*16, -0.0+y*16, 47.5+x*16, 16.0+y*16)
+					if x > 1 and self.grid[y][x-1] == empty then
-				end
+						love.graphics.line(47.5+x*16, -0.0+y*16, 47.5+x*16, 16.0+y*16)
-				if x < 10 and self.grid[y][x+1] == empty then
+					end
-					love.graphics.line(64.5+x*16, -0.0+y*16, 64.5+x*16, 16.0+y*16)
+					if x < 10 and self.grid[y][x+1] == empty then
+						love.graphics.line(64.5+x*16, -0.0+y*16, 64.5+x*16, 16.0+y*16)
+					end
 				end
 			end
 		end

tetris/components/piece.lua

@@ -2,7 +2,7 @@ local Object = require 'libs.classic'
 
 local Piece = Object:extend()
 
-function Piece:new(shape, rotation, position, block_offsets, gravity, lock_delay, skin)
+function Piece:new(shape, rotation, position, block_offsets, gravity, lock_delay, skin, big)
 	self.shape = shape
 	self.rotation = rotation
 	self.position = position
@@ -12,6 +12,7 @@ function Piece:new(shape, rotation, position, block_offsets, gravity, lock_delay
 	self.skin = skin
 	self.ghost = false
 	self.locked = false
+	self.big = big
 end
 
 -- Functions that return a new piece to test in rotation systems.
@@ -20,7 +21,7 @@ function Piece:withOffset(offset)
 	return Piece(
 		self.shape, self.rotation,
 		{x = self.position.x + offset.x, y = self.position.y + offset.y},
-		self.block_offsets, self.gravity, self.lock_delay, self.skin
+		self.block_offsets, self.gravity, self.lock_delay, self.skin, self.big
 	)
 end
 
@@ -30,7 +31,7 @@ function Piece:withRelativeRotation(rot)
 	while new_rot >= 4 do new_rot = new_rot - 4 end
 	return Piece(
 		self.shape, new_rot, self.position,
-		self.block_offsets, self.gravity, self.lock_delay, self.skin
+		self.block_offsets, self.gravity, self.lock_delay, self.skin, self.big
 	)
 end
 
@@ -96,7 +97,7 @@ end
 
 function Piece:dropToBottom(grid)
 	local piece_y = self.position.y
-	self:dropSquares(20, grid)
+	self:dropSquares(24, grid)
 	self.gravity = 0
 	if self.position.y > piece_y then
 		-- if it got dropped any, also reset lock delay
@@ -138,14 +139,25 @@ function Piece:draw(opacity, brightness, grid, partial_das)
 	love.graphics.setColor(brightness, brightness, brightness, opacity)
 	local offsets = self:getBlockOffsets()
 	local gravity_offset = 0
-	if grid ~= nil and not self:isDropBlocked(grid) then
+	--if grid ~= nil and not self:isDropBlocked(grid) then
-		gravity_offset = self.gravity * 16
+	--	gravity_offset = self.gravity * 16
-	end
+	--end
 	if partial_das == nil then partial_das = 0 end
 	for index, offset in pairs(offsets) do
 		local x = self.position.x + offset.x
 		local y = self.position.y + offset.y
-		love.graphics.draw(blocks[self.skin][self.shape], 64+x*16+partial_das, 16+y*16+gravity_offset)
+		if self.big then
+			love.graphics.draw(
+				blocks[self.skin][self.shape],
+				64+x*32+partial_das*2, 16+y*32+gravity_offset*2,
+				0, 2, 2
+			)
+		else
+			love.graphics.draw(
+				blocks[self.skin][self.shape],
+				64+x*16+partial_das, 16+y*16+gravity_offset
+			)
+		end
 	end
 	return false
 end

tetris/modes/big_a2.lua

@@ -0,0 +1,365 @@
+require 'funcs'
+
+local GameMode = require 'tetris.modes.gamemode'
+local Piece = require 'tetris.components.piece'
+
+local History6RollsRandomizer = require 'tetris.randomizers.history_6rolls'
+
+local MarathonA2Game = GameMode:extend()
+
+MarathonA2Game.name = "Big A2"
+MarathonA2Game.hash = "BigA2"
+MarathonA2Game.tagline = "The points don't matter! Can you reach the invisible roll? Big mode too!"
+
+
+
+
+function MarathonA2Game:new()
+    self.super: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()
+
+    self.lock_drop = false
+	self.enable_hold = false
+	self.next_queue_length = 1
+end
+
+function MarathonA2Game:getARE()
+        if self.level < 700 then return 27
+    elseif self.level < 800 then return 18
+    else return 14 end
+end
+
+function MarathonA2Game:getLineARE()
+        if self.level < 600 then return 27
+    elseif self.level < 700 then return 18
+    elseif self.level < 800 then return 14
+    else return 8 end
+end
+
+function MarathonA2Game:getDasLimit()
+        if self.level < 500 then return 15
+    elseif self.level < 900 then return 9
+    else return 7 end
+end
+
+function MarathonA2Game: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
+    else return 6 end
+end
+
+function MarathonA2Game:getLockDelay()
+        if self.level < 900 then return 30
+    else return 17 end
+end
+
+function MarathonA2Game: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 MarathonA2Game:advanceOneFrame()
+	if self.clear then
+		self.roll_frames = self.roll_frames + 1
+		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
+	end
+	return true
+end
+
+function MarathonA2Game: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 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)
+    cleared_lines = cleared_lines / 2
+    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
+		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
+
+local grade_point_bonuses = {
+	{10, 20, 40, 50},
+	{10, 20, 30, 40},
+	{10, 20, 30, 40},
+	{10, 15, 30, 40},
+	{10, 15, 20, 40},
+	{5, 15, 20, 30},
+	{5, 10, 20, 30},
+	{5, 10, 15, 30},
+	{5, 10, 15, 30},
+	{5, 10, 15, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+	{2, 12, 13, 30},
+}
+
+local grade_point_decays = {
+	125, 80, 80, 50, 45, 45, 45,
+	40, 40, 40, 40, 40, 30, 30, 30,
+	20, 20, 20, 20, 20,
+	15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+	10, 10
+}
+
+local combo_multipliers = {
+	{1.0, 1.0, 1.0, 1.0},
+	{1.2, 1.4, 1.5, 1.0},
+	{1.2, 1.5, 1.8, 1.0},
+	{1.4, 1.6, 2.0, 1.0},
+	{1.4, 1.7, 2.2, 1.0},
+	{1.4, 1.8, 2.3, 1.0},
+	{1.4, 1.9, 2.4, 1.0},
+	{1.5, 2.0, 2.5, 1.0},
+	{1.5, 2.1, 2.6, 1.0},
+	{2.0, 2.5, 3.0, 1.0},
+}
+
+local grade_conversion = {
+	[0] = 0,
+	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
+}
+
+function MarathonA2Game:updateGrade(cleared_lines)
+	if self.clear then return end
+	if cleared_lines == 0 then
+		self.grade_point_decay_counter = self.grade_point_decay_counter + 1
+		if self.grade_point_decay_counter >= grade_point_decays[self.grade + 1] then
+			self.grade_point_decay_counter = 0
+			self.grade_points = math.max(0, self.grade_points - 1)
+		end
+	else
+		self.grade_points = self.grade_points + (
+			math.ceil(
+				grade_point_bonuses[self.grade + 1][cleared_lines] *
+				combo_multipliers[math.min(self.combo, 10)][cleared_lines]
+			) * (1 + math.floor(self.level / 250))
+		)
+		if self.grade_points >= 100 and self.grade < 31 then
+			self.grade_points = 0
+			self.grade = self.grade + 1
+		end
+	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
+
+MarathonA2Game.rollOpacityFunction = function(age)
+	if age < 240 then return 1
+	elseif age > 300 then return 0
+	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
+			self:drawGhostPiece(ruleset)
+		end
+	end
+end
+
+function MarathonA2Game: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("GRADE", 240, 120, 40, "left")
+	love.graphics.printf("SCORE", 240, 200, 40, "left")
+	love.graphics.printf("LEVEL", 240, 320, 40, "left")
+
+	love.graphics.setFont(font_3x5_3)
+	love.graphics.printf(self:getLetterGrade(), 240, 140, 90, "left")
+	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")
+
+	love.graphics.setFont(font_8x11)
+	love.graphics.printf(formatTime(self.frames), 64, 420, 160, "center")
+end
+
+function MarathonA2Game:getHighscoreData()
+	return {
+		grade = grade_conversion[self.grade],
+		score = self.score,
+		level = self.level,
+		frames = self.frames,
+	}
+end
+
+function MarathonA2Game:getSectionEndLevel()
+	if self.level >= 900 then return 999
+	else return math.floor(self.level / 100 + 1) * 100 end
+end
+
+function MarathonA2Game:getBackground()
+	return math.floor(self.level / 100)
+end
+
+return MarathonA2Game

tetris/modes/demon_mode.lua

@@ -104,7 +104,7 @@ function DemonModeGame:advanceOneFrame()
 	if self.clear then
 		self.roll_frames = self.roll_frames + 1
 		if self.roll_frames < 0 then
-			return
+			return false
 		elseif self.roll_frames >= 1337 then
 			self.completed = true
 		end
@@ -159,7 +159,7 @@ function DemonModeGame:updateSectionTimes(old_level, new_level)
 			end
 		elseif old_level < 100 then
 			-- If section time is under cutoff, skip to level 500.
-			if self.frames < sp(1,00) then
+			if self.frames < frameTime(1,00) then
 				self.level = 500
 				self.grade = 5
 				self.section_tries = 0
@@ -226,7 +226,7 @@ function DemonModeGame:drawScoringInfo()
 	love.graphics.print(
 		self.das.direction .. " " ..
 		self.das.frames .. " " ..
-		st(self.prev_inputs)
+		strTrueValues(self.prev_inputs)
 	)
 	love.graphics.printf("NEXT", 64, 40, 40, "left")
 	love.graphics.printf("GRADE", 240, 120, 40, "left")

tetris/modes/gamemode.lua

@@ -36,8 +36,10 @@ function GameMode:new()
 	self.enable_hold = false
 	self.enable_hard_drop = true
 	self.next_queue_length = 1
+	self.additive_gravity = true
 	self.draw_section_times = false
 	self.draw_secondary_section_times = false
+	self.big_mode = false
 	-- variables related to configurable parameters
 	self.drop_locked = false
 	self.hard_drop_locked = false
@@ -48,13 +50,6 @@ function GameMode:new()
 	self.secondary_section_times = { [0] = 0 }
 end
 
-function GameMode:initialize()
-	-- after all the variables are initialized, run initialization procedures
-	for i = 1, 30 do
-		table.insert(self.next_queue, self:getNextPiece(ruleset))
-	end
-end
-
 function GameMode:getARR() return 1 end
 function GameMode:getDropSpeed() return 1 end
 function GameMode:getARE() return 25 end
@@ -73,6 +68,7 @@ end
 
 function GameMode:initialize(ruleset)
 	-- generate next queue
+    self:new()
 	for i = 1, self.next_queue_length do
 		table.insert(self.next_queue, self:getNextPiece(ruleset))
 	end
@@ -119,7 +115,8 @@ function GameMode:update(inputs, ruleset)
 		ruleset:processPiece(
 			inputs, self.piece, self.grid, self:getGravity(), self.prev_inputs,
 			self.move, self:getLockDelay(), self:getDropSpeed(),
-			self.drop_locked, self.hard_drop_locked, self.enable_hard_drop
+			self.drop_locked, self.hard_drop_locked,
+			self.enable_hard_drop, self.additive_gravity
 		)
 
 		local piece_dy = self.piece.position.y - piece_y
@@ -298,7 +295,7 @@ function GameMode:initializeNextPiece(inputs, ruleset, piece_data, generate_next
 		inputs, piece_data, self.grid, gravity,
 		self.prev_inputs, self.move,
 		self:getLockDelay(), self:getDropSpeed(),
-		self.lock_drop, self.lock_hard_drop
+		self.lock_drop, self.lock_hard_drop, self.big_mode
 	)
 	if self.lock_drop then
 		self.drop_locked = true
@@ -345,8 +342,8 @@ end
 function GameMode:drawNextQueue(ruleset)
 	function drawPiece(piece, skin, offsets, pos_x, pos_y)
 		for index, offset in pairs(offsets) do
-			local x = ruleset.spawn_positions[piece].x + offset.x
+			local x = offset.x + ruleset.spawn_positions[piece].x
-			local y = ruleset.spawn_positions[piece].y + offset.y
+			local y = offset.y + 4.7
 			love.graphics.draw(blocks[skin][piece], pos_x+x*16, pos_y+y*16)
 		end
 	end
@@ -389,7 +386,7 @@ function GameMode:drawScoringInfo()
 	love.graphics.print(
 		self.das.direction .. " " ..
 		self.das.frames .. " " ..
-		st(self.prev_inputs) ..
+		strTrueValues(self.prev_inputs) ..
 		self.drop_bonus
 	)
 

tetris/modes/interval_training.lua

@@ -120,7 +120,7 @@ function IntervalTrainingGame:drawScoringInfo()
 	love.graphics.print(
 		self.das.direction .. " " ..
 		self.das.frames .. " " ..
-		st(self.prev_inputs)
+		strTrueValues(self.prev_inputs)
 	)
 	love.graphics.printf("NEXT", 64, 40, 40, "left")
 	love.graphics.printf("TIME LEFT", 240, 250, 80, "left")
@@ -134,7 +134,7 @@ 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 < sp(0,10) and time_left % 4 < 2 then
+	if not self.game_over and not self.clear 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")

tetris/modes/konoha.lua

@@ -0,0 +1,190 @@
+require 'funcs'
+
+local GameMode = require 'tetris.modes.gamemode'
+local Piece = require 'tetris.components.piece'
+
+local KonohaRandomizer = require 'tetris.randomizers.bag_konoha'
+
+local KonohaGame = GameMode:extend()
+
+KonohaGame.name = "All Clear A4"
+KonohaGame.hash = "AllClearA4"
+KonohaGame.tagline = "Get as many bravos as you can under the time limit!"
+
+function KonohaGame:new()
+	KonohaGame.super:new()
+
+	self.randomizer = KonohaRandomizer()
+	self.bravos = 0
+    self.last_bonus_amount = 0
+    self.last_bonus_display_time = 0
+	self.time_limit = 10800
+	self.big_mode = true
+	
+	self.enable_hold = true
+	self.next_queue_length = 3
+end
+
+function KonohaGame:getARE()
+	    if self.level < 300  then return 30
+	elseif self.level < 400  then return 25
+	elseif self.level < 500  then return 20
+	elseif self.level < 600  then return 17
+	elseif self.level < 800  then return 15
+	elseif self.level < 900  then return 13
+	elseif self.level < 1000 then return 10
+	elseif self.level < 1300 then return 8
+	else return 6 end
+end
+
+function KonohaGame:getLineARE()
+	return self:getARE()
+end
+
+function KonohaGame:getDasLimit()
+	    if self.level < 500  then return 10
+	elseif self.level < 800  then return 9
+	elseif self.level < 1000 then return 8
+	else return 7 end
+end
+
+function KonohaGame:getLineClearDelay()
+	    if self.level < 200  then return 14
+	elseif self.level < 500  then return 9
+	elseif self.level < 800  then return 8
+	elseif self.level < 1000 then return 7
+	else return 6 end
+end
+
+function KonohaGame:getLockDelay()
+	    if self.level < 500  then return 30
+	elseif self.level < 600  then return 25
+	elseif self.level < 700  then return 23
+	elseif self.level < 800  then return 20
+	elseif self.level < 900  then return 17
+	elseif self.level < 1000 then return 15
+	elseif self.level < 1200 then return 13
+	elseif self.level < 1300 then return 10
+	else return 8 end
+end
+
+function KonohaGame:getGravity()
+	    if (self.level < 30)  then return 4/256
+	elseif (self.level < 35)  then return 8/256
+	elseif (self.level < 40)  then return 12/256
+	elseif (self.level < 50)  then return 16/256
+	elseif (self.level < 60)  then return 32/256
+	elseif (self.level < 70)  then return 48/256
+	elseif (self.level < 80)  then return 64/256
+	elseif (self.level < 90)  then return 128/256
+	elseif (self.level < 100) then return 192/256
+	elseif (self.level < 120) then return 1
+	elseif (self.level < 140) then return 2
+	elseif (self.level < 160) then return 3
+	elseif (self.level < 170) then return 4
+	elseif (self.level < 200) then return 5
+	else return 20 end
+end
+
+function KonohaGame:getSection()
+	return math.floor(level / 100) + 1
+end
+
+function KonohaGame:getSectionEndLevel()
+	return math.floor(self.level / 100 + 1) * 100
+end
+
+function KonohaGame:advanceOneFrame()
+	if self.ready_frames == 0 then
+		self.time_limit = self.time_limit - 1
+		self.frames = self.frames + 1
+	end
+	if self.time_limit <= 0 then
+		self.game_over = true
+	end
+    self.last_bonus_display_time = self.last_bonus_display_time - 1
+end
+
+function KonohaGame:onPieceEnter()
+	if (self.level % 100 ~= 99) and self.frames ~= 0 then
+		self.level = self.level + 1
+	end
+end
+
+function KonohaGame:drawGrid(ruleset)
+	self.grid:draw()
+	if self.piece ~= nil and self.level < 100 then
+		self:drawGhostPiece(ruleset)
+	end
+end
+
+local cleared_row_levels = {2, 4, 6, 12}
+local bravo_bonus = {300, 480, 660, 900}
+local non_bravo_bonus = {0, 0, 20, 40}
+local bravo_ot_bonus = {0, 60, 120, 180}
+
+function KonohaGame:onLineClear(cleared_row_count)
+    local oldtime = self.time_limit
+	
+    self.level = self.level + cleared_row_levels[cleared_row_count / 2]
+	if self.grid:checkForBravo(cleared_row_count) then
+		self.bravos = self.bravos + 1
+		if self.level < 1000 then self.time_limit = self.time_limit + bravo_bonus[cleared_row_count / 2]
+		else self.time_limit = self.time_limit + bravo_ot_bonus[cleared_row_count / 2]
+		end
+		if self.bravos == 11 then self.randomizer.allowrepeat = true end
+	elseif self.level < 1000 then
+		self.time_limit = self.time_limit + non_bravo_bonus[cleared_row_count / 2]
+	end
+    
+    local bonus = self.time_limit - oldtime
+    if bonus > 0 then
+        self.last_bonus_amount = bonus
+        self.last_bonus_display_time = 120
+    end
+end
+
+function KonohaGame:getBackground()
+	return math.floor(self.level / 100)
+end
+
+function KonohaGame: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("TIME LIMIT", 240, 120, 120, "left")
+	love.graphics.printf("BRAVOS", 240, 200, 50, "left")
+	love.graphics.printf("LEVEL", 240, 320, 40, "left")
+	
+	love.graphics.setFont(font_3x5_3)
+	if not self.game_over and self.time_limit < frameTime(0,10) and self.time_limit % 4 < 2 then
+                love.graphics.setColor(1, 0.3, 0.3, 1)
+        end
+	love.graphics.printf(formatTime(self.time_limit), 240, 140, 120, "right")
+	love.graphics.setColor(1, 1, 1, 1)
+    if self.last_bonus_display_time > 0 then
+        love.graphics.printf("+"..formatTime(self.last_bonus_amount), 240, 160, 120, "right")
+    end
+	love.graphics.printf(self.bravos, 240, 220, 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 KonohaGame:getHighscoreData()
+	return {
+		bravos = self.bravos,
+		level = self.level,
+		frames = self.frames,
+	}
+end
+
+return KonohaGame

tetris/modes/marathon_2020.lua

@@ -151,11 +151,11 @@ function Marathon2020Game:advanceOneFrame()
 end
 
 local cool_cutoffs = {
-	sp(0,45,00), sp(0,41,50), sp(0,38,50), sp(0,35,00), sp(0,32,50),
+	frameTime(0,45,00), frameTime(0,41,50), frameTime(0,38,50), frameTime(0,35,00), frameTime(0,32,50),
-	sp(0,29,20), sp(0,27,20), sp(0,24,80), sp(0,22,80), sp(0,20,60),
+	frameTime(0,29,20), frameTime(0,27,20), frameTime(0,24,80), frameTime(0,22,80), frameTime(0,20,60),
-	sp(0,19,60), sp(0,19,40), sp(0,19,40), sp(0,18,40), sp(0,18,20),
+	frameTime(0,19,60), frameTime(0,19,40), frameTime(0,19,40), frameTime(0,18,40), frameTime(0,18,20),
-	sp(0,16,20), sp(0,16,20), sp(0,16,20), sp(0,16,20), sp(0,16,20),
+	frameTime(0,16,20), frameTime(0,16,20), frameTime(0,16,20), frameTime(0,16,20), frameTime(0,16,20),
-	sp(0,15,20)
+	frameTime(0,15,20)
 }
 
 local levels_for_cleared_rows = { 1, 2, 4, 6 }
@@ -284,11 +284,11 @@ function Marathon2020Game:sectionPassed(old_level, new_level)
 end
 
 function Marathon2020Game:checkTorikan(section)
-	if section == 5 and self.frames < sp(6,00,00) then self.torikan_passed[500] = true end
+	if section == 5 and self.frames < frameTime(6,00,00) then self.torikan_passed[500] = true end
-	if section == 9 and self.frames < sp(8,30,00) then self.torikan_passed[900] = true end
+	if section == 9 and self.frames < frameTime(8,30,00) then self.torikan_passed[900] = true end
-	if section == 10 and self.frames < sp(8,45,00) then self.torikan_passed[1000] = true end
+	if section == 10 and self.frames < frameTime(8,45,00) then self.torikan_passed[1000] = true end
-	if section == 15 and self.frames < sp(11,30,00) then self.torikan_passed[1500] = true end
+	if section == 15 and self.frames < frameTime(11,30,00) then self.torikan_passed[1500] = true end
-	if section == 19 and self.frames < sp(13,15,00) then self.torikan_passed[1900] = true end
+	if section == 19 and self.frames < frameTime(13,15,00) then self.torikan_passed[1900] = true end
 end
 
 function Marathon2020Game:checkClear(level)

tetris/modes/marathon_a1.lua

@@ -23,6 +23,11 @@ function MarathonA1Game:new()
 		level500 = false,
 		level999 = false
     }
+    self.SGnames = {
+        "9", "8", "7", "6", "5", "4", "3", "2", "1",
+        "S1", "S2", "S3", "S4", "S5", "S6", "S7", "S8", "S9",
+        "GM"
+    }
     
 	self.randomizer = History4RollsRandomizer()
 
@@ -155,15 +160,15 @@ end
 
 function MarathonA1Game:checkGMRequirements(old_level, new_level)
 	if old_level < 300 and new_level >= 300 then
-		if self.score > 12000 and self.frames <= sp(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 <= sp(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 <= sp(13,30) then
+		if self.score > 126000 and self.frames <= frameTime(13,30) then
 			self.gm_conditions["level900"] = true
 		end
 	end
@@ -184,13 +189,17 @@ function MarathonA1Game:drawScoringInfo()
 	love.graphics.print(
 		self.das.direction .. " " ..
 		self.das.frames .. " " ..
-		st(self.prev_inputs)
+		strTrueValues(self.prev_inputs)
 	)
 	love.graphics.printf("NEXT", 64, 40, 40, "left")
 	love.graphics.printf("GRADE", 240, 120, 40, "left")
 	love.graphics.printf("SCORE", 240, 200, 40, "left")
 	love.graphics.printf("NEXT RANK", 240, 260, 90, "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")
@@ -202,7 +211,10 @@ function MarathonA1Game:drawScoringInfo()
 	love.graphics.printf(getRankForScore(self.score).next, 240, 280, 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

tetris/modes/marathon_a2.lua

@@ -27,6 +27,12 @@ function MarathonA2Game:new()
 	self.section_times = { [0] = 0 }
 	self.section_tetrises = { [0] = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
     
+    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
@@ -260,7 +266,7 @@ function MarathonA2Game:qualifiesForMRoll()
 	local section_average = 0
 	for section = 0, 4 do
 		section_average = section_average + self.section_times[section]
-		if self.section_times[section] > sp(1,05) then
+		if self.section_times[section] > frameTime(1,05) then
 			return false
 		end
 	end
@@ -273,7 +279,7 @@ function MarathonA2Game:qualifiesForMRoll()
 			return false
 		end
 	end
-	if self.grade < 17 or self.frames > sp(8,45) then
+	if self.grade < 17 or self.frames > frameTime(9,30) then
 		return false
 	end
 	return true
@@ -325,18 +331,25 @@ function MarathonA2Game:drawScoringInfo()
 	love.graphics.print(
 		self.das.direction .. " " ..
 		self.das.frames .. " " ..
-		st(self.prev_inputs)
+		strTrueValues(self.prev_inputs)
 	)
 	love.graphics.printf("NEXT", 64, 40, 40, "left")
 	love.graphics.printf("GRADE", 240, 120, 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:getLetterGrade(), 240, 140, 90, "left")
 	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")

tetris/modes/marathon_a3.lua

@@ -32,10 +32,19 @@ function MarathonA3Game:new()
     
 	self.randomizer = History6RollsRandomizer()
 
+self.SGnames = {
+        "9", "8", "7", "6", "5", "4", "3", "2", "1",
+        "S1", "S2", "S3", "S4", "S5", "S6", "S7", "S8", "S9",
+        "GM"
+    }
+	
     self.lock_drop = true
     self.lock_hard_drop = true
 	self.enable_hold = true
 	self.next_queue_length = 3
+	
+	self.coolregret_message = "COOL!!"
+	self.coolregret_timer = 0
 end
 
 function MarathonA3Game:getARE()
@@ -67,7 +76,9 @@ function MarathonA3Game:getLineClearDelay()
     elseif self.speed_level < 600 then return 25
     elseif self.speed_level < 700 then return 16
     elseif self.speed_level < 800 then return 12
-    else return 6 end
+    elseif self.speed_level < 1100 then return 6
+    elseif self.speed_level < 1200 then return 5
+    else return 4 end
 end
 
 function MarathonA3Game:getLockDelay()
@@ -117,7 +128,7 @@ function MarathonA3Game:advanceOneFrame()
 			if self.roll_frames + 1 == 0 then
 				switchBGM("credit_roll", "gm3")
 			end
-			return
+			return false
 		elseif self.roll_frames > 3238 then
 			if self:qualifiesForMRoll() then
 				self.roll_points = self.roll_points + 160
@@ -158,13 +169,13 @@ function MarathonA3Game:onLineClear(cleared_row_count)
 end
 
 local cool_cutoffs = {
-	sp(0,52), sp(0,52), sp(0,49), sp(0,45), sp(0,45),
+	frameTime(0,52), frameTime(0,52), frameTime(0,49), frameTime(0,45), frameTime(0,45),
-	sp(0,42), sp(0,42), sp(0,38), sp(0,38), 
+	frameTime(0,42), frameTime(0,42), frameTime(0,38), frameTime(0,38), 
 }
 
 local regret_cutoffs = {
-	sp(0,90), sp(0,75), sp(0,75), sp(0,68), sp(0,60),
+	frameTime(0,90), frameTime(0,75), frameTime(0,75), frameTime(0,68), frameTime(0,60),
-	sp(0,60), sp(0,50), sp(0,50), sp(0,50), sp(0,50),
+	frameTime(0,60), frameTime(0,50), frameTime(0,50), frameTime(0,50), frameTime(0,50),
 }
 
 function MarathonA3Game:updateSectionTimes(old_level, new_level)
@@ -180,17 +191,23 @@ function MarathonA3Game:updateSectionTimes(old_level, new_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] + 1000 then
+		self.section_70_times[section] < self.section_70_times[section - 1] + 120 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
@@ -370,12 +387,16 @@ function MarathonA3Game:drawScoringInfo()
 	love.graphics.print(
 		self.das.direction .. " " ..
 		self.das.frames .. " " ..
-		st(self.prev_inputs)
+		strTrueValues(self.prev_inputs)
 	)
 	love.graphics.printf("NEXT", 64, 40, 40, "left")
 	love.graphics.printf("GRADE", 240, 120, 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
 
 	-- draw section time data
 	current_section = math.floor(self.level / 100) + 1
@@ -403,13 +424,21 @@ function MarathonA3Game:drawScoringInfo()
 	end
 
 	love.graphics.printf(formatTime(self.frames - self.section_start_time), current_x, 40 + 20 * current_section, 90, "left")
+	
+	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(self.score, 240, 220, 90, "left")
 	love.graphics.printf(self:getLetterGrade(), 240, 140, 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

tetris/modes/marathon_ax4.lua

@@ -3,22 +3,20 @@ require 'funcs'
 local GameMode = require 'tetris.modes.gamemode'
 local Piece = require 'tetris.components.piece'
 
-local History6RollsRandomizer = require 'tetris.randomizers.history_6rolls'
+local Bag7NoSZOStartRandomizer = require 'tetris.randomizers.bag7noSZOstart'
 
-local MarathonL1Game = GameMode:extend()
+local MarathonAX4Game = GameMode:extend()
 
-MarathonL1Game.name = "Line Attack"
+MarathonAX4Game.name = "Marathon AX4"
-MarathonL1Game.hash = "MarathonL1"
+MarathonAX4Game.hash = "MarathonAX4"
-MarathonL1Game.tagline = "Can you clear the time hurdles when the game goes this fast?"
+MarathonAX4Game.tagline = "Can you clear the time hurdles when the game goes this fast?"
 
 
-
+function MarathonAX4Game:new()
-
+	MarathonAX4Game.super:new()
-function MarathonL1Game:new()
-	MarathonL1Game.super:new()
 
 	self.roll_frames = 0
-	self.randomizer = History6RollsRandomizer()
+	self.randomizer = Bag7NoSZOStartRandomizer()
 
 	self.section_time_limit = 3600
 	self.section_start_time = 0
@@ -30,7 +28,7 @@ function MarathonL1Game:new()
 	self.next_queue_length = 3
 end
 
-function MarathonL1Game:getARE()
+function MarathonAX4Game:getARE()
 	    if self.lines < 10 then return 18
 	elseif self.lines < 40 then return 14
 	elseif self.lines < 60 then return 12
@@ -40,24 +38,24 @@ function MarathonL1Game:getARE()
 	else return 6 end
 end
 
-function MarathonL1Game:getLineARE()
+function MarathonAX4Game:getLineARE()
 	return self:getARE()
 end
 
-function MarathonL1Game:getDasLimit()
+function MarathonAX4Game:getDasLimit()
 	    if self.lines < 20 then return 10
 	elseif self.lines < 50 then return 9
 	elseif self.lines < 70 then return 8
 	else return 7 end
 end
 
-function MarathonL1Game:getLineClearDelay()
+function MarathonAX4Game:getLineClearDelay()
 	    if self.lines < 10 then return 14
 	elseif self.lines < 30 then return 9
 	else return 5 end
 end
 
-function MarathonL1Game:getLockDelay()
+function MarathonAX4Game:getLockDelay()
 		if self.lines < 10 then return 28
 	elseif self.lines < 20 then return 24
 	elseif self.lines < 30 then return 22
@@ -67,15 +65,15 @@ function MarathonL1Game:getLockDelay()
 	else return 13 end
 end
 
-function MarathonL1Game:getGravity()
+function MarathonAX4Game:getGravity()
 	return 20
 end
 
-function MarathonL1Game:getSection()
+function MarathonAX4Game:getSection()
 	return math.floor(level / 100) + 1
 end
 
-function MarathonL1Game:advanceOneFrame()
+function MarathonAX4Game:advanceOneFrame()
 	if self.clear then
 		self.roll_frames = self.roll_frames + 1
 		if self.roll_frames < 0 then		
@@ -94,7 +92,7 @@ function MarathonL1Game:advanceOneFrame()
 	return true
 end
 
-function MarathonL1Game:onLineClear(cleared_row_count)
+function MarathonAX4Game:onLineClear(cleared_row_count)
 	if not self.clear then
 		local new_lines = self.lines + cleared_row_count
 		self:updateSectionTimes(self.lines, new_lines)
@@ -106,11 +104,11 @@ function MarathonL1Game:onLineClear(cleared_row_count)
 	end
 end
 
-function MarathonL1Game:getSectionTime()
+function MarathonAX4Game:getSectionTime()
 	return self.frames - self.section_start_time
 end
 
-function MarathonL1Game:updateSectionTimes(old_lines, new_lines)
+function MarathonAX4Game:updateSectionTimes(old_lines, new_lines)
 	if math.floor(old_lines / 10) < math.floor(new_lines / 10) then
 		-- record new section
 		table.insert(self.section_times, self:getSectionTime())
@@ -119,23 +117,23 @@ function MarathonL1Game:updateSectionTimes(old_lines, new_lines)
 	end
 end
 
-function MarathonL1Game:onPieceEnter()
+function MarathonAX4Game:onPieceEnter()
 	self.section_clear = false
 end
 
-function MarathonL1Game:drawGrid(ruleset)
+function MarathonAX4Game:drawGrid(ruleset)
 	self.grid:draw()
 end
 
-function MarathonL1Game:getHighscoreData()
+function MarathonAX4Game:getHighscoreData()
 	return {
 		lines = self.lines,
 		frames = self.frames,
 	}
 end
 
-function MarathonL1Game:drawScoringInfo()
+function MarathonAX4Game:drawScoringInfo()
-	MarathonL1Game.super.drawScoringInfo(self)
+	MarathonAX4Game.super.drawScoringInfo(self)
 
 	love.graphics.setColor(1, 1, 1, 1)
 
@@ -143,7 +141,7 @@ function MarathonL1Game:drawScoringInfo()
 	love.graphics.print(
 		self.das.direction .. " " ..
 		self.das.frames .. " " ..
-		st(self.prev_inputs)
+		strTrueValues(self.prev_inputs)
 	)
 	love.graphics.printf("NEXT", 64, 40, 40, "left")
 	love.graphics.printf("TIME LEFT", 240, 250, 80, "left")
@@ -158,19 +156,19 @@ function MarathonL1Game: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 < sp(0,10) and time_left % 4 < 2 then
+	if not self.game_over and not self.clear 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")
 	love.graphics.setColor(1, 1, 1, 1)
 end
 
-function MarathonL1Game:getSectionEndLines()
+function MarathonAX4Game:getSectionEndLines()
 	return math.floor(self.lines / 10 + 1) * 10
 end
 
-function MarathonL1Game:getBackground()
+function MarathonAX4Game:getBackground()
 	return math.floor(self.lines / 10)
 end
 
-return MarathonL1Game
+return MarathonAX4Game

tetris/modes/marathon_c89.lua

@@ -0,0 +1,185 @@
+require 'funcs'
+
+local GameMode = require 'tetris.modes.gamemode'
+local Piece = require 'tetris.components.piece'
+
+local Randomizer = require 'tetris.randomizers.randomizer'
+
+local MarathonC89Game = GameMode:extend()
+
+MarathonC89Game.name = "Marathon C89"
+MarathonC89Game.hash = "MarathonC89"
+MarathonC89Game.tagline = "Can you play fast enough to reach the killscreen?"
+
+
+function MarathonC89Game:new()
+    MarathonC89Game.super:new()
+    
+	self.randomizer = Randomizer()
+
+	self.ready_frames = 1
+	self.waiting_frames = 72
+
+	self.start_level = 12
+	self.level = 12
+
+    self.lock_drop = true
+    self.enable_hard_drop = false
+	self.enable_hold = false
+	self.next_queue_length = 1
+	self.additive_gravity = false
+end
+
+function MarathonC89Game:getDropSpeed() return 1/2 end
+function MarathonC89Game:getDasLimit() return 16 end
+function MarathonC89Game:getARR() return 6 end
+
+function MarathonC89Game:getARE() return 6 end
+function MarathonC89Game:getLineARE() return 6 end
+function MarathonC89Game:getLineClearDelay() return 30 end
+function MarathonC89Game:getLockDelay() return 0 end
+
+function MarathonC89Game:chargeDAS(inputs)
+	if inputs[self.das.direction] == true and
+		self.prev_inputs[self.das.direction] == true and
+		not inputs["down"] and
+		self.piece ~= nil
+	then
+		local das_frames = self.das.frames + 1
+		if das_frames >= self:getDasLimit() then
+			if self.das.direction == "left" then
+				self.move = (self:getARR() == 0 and "speed" or "") .. "left"
+				self.das.frames = self:getDasLimit() - self:getARR()
+			elseif self.das.direction == "right" then
+				self.move = (self:getARR() == 0 and "speed" or "") .. "right"
+				self.das.frames = self:getDasLimit() - self:getARR()
+			end
+		else
+			self.move = "none"
+			self.das.frames = das_frames
+		end
+	elseif inputs["right"] == true then
+		self.das.direction = "right"
+		if not inputs["down"] and self.piece ~= nil then
+			self.move = "right"
+			self.das.frames = 0
+		else 
+			self.move = "none"
+		end
+	elseif inputs["left"] == true then
+		self.das.direction = "left"
+		if not inputs["down"] and self.piece ~= nil then
+			self.move = "left"
+			self.das.frames = 0
+		else 
+			self.move = "none"
+		end
+	else
+		self.move = "none"
+	end
+
+	if self.das.direction == "left" and self.piece ~= nil and self.piece:isMoveBlocked(self.grid, {x=-1, y=0}) or
+		self.das.direction == "right" and self.piece ~= nil and self.piece:isMoveBlocked(self.grid, {x=1, y=0})
+	then
+		self.das.frames = self:getDasLimit()
+	end
+
+	if inputs["down"] == false and self.prev_inputs["down"] == true then
+		self.drop_bonus = 0
+	end
+end
+
+local gravity_table = {
+	[0] =
+	1366/65536,  1525/65536,  1725/65536,  1986/65536,  2341/65536,
+	2850/65536,  3641/65536,  5042/65536,  8192/65536,  10923/65536,
+	13108/65536, 13108/65536, 13108/65536, 16384/65536, 16384/65536,
+	16384/65536, 21846/65536, 21846/65536, 21846/65536
+}
+
+function MarathonC89Game:getGravity()
+	if self.waiting_frames > 0 then return 0 end
+	    if self.level >= 29 then return 1
+	elseif self.level >= 19 then return 1/2
+	else return gravity_table[self.level] end
+end
+
+function MarathonC89Game:advanceOneFrame()
+	if self.waiting_frames > 0 then
+		self.waiting_frames = self.waiting_frames - 1
+	else
+		self.frames = self.frames + 1
+	end
+	return true
+end
+
+function MarathonC89Game:onPieceLock()
+	self.score = self.score + self.drop_bonus
+	self.drop_bonus = 0
+end
+
+local cleared_line_scores = { 40, 100, 300, 1200 }
+
+function MarathonC89Game:getLevelForLines()
+	if self.start_level < 10 then
+		return math.max(self.start_level, math.floor(self.lines / 10))
+	elseif self.start_level < 16 then
+		return math.max(self.start_level, self.start_level + math.floor((self.lines - 100) / 10))
+	else
+		return math.max(self.start_level, math.floor((self.lines - 60) / 10))
+	end
+end
+
+function MarathonC89Game:updateScore(level, drop_bonus, cleared_lines)
+	if cleared_lines > 0 then
+		self.score = self.score + cleared_line_scores[cleared_lines] * (self.level + 1)
+		self.lines = self.lines + cleared_lines
+		self.level = self:getLevelForLines()
+	else
+		self.drop_bonus = 0
+		self.combo = 1
+	end
+end
+
+function MarathonC89Game:drawGrid()
+	self.grid:draw()
+	if self.piece ~= nil and self.level < 100 then
+		self:drawGhostPiece(ruleset)
+	end
+end
+
+function MarathonC89Game:drawScoringInfo()
+	MarathonC89Game.super.drawScoringInfo(self)
+	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("LINES", 240, 120, 40, "left")
+	love.graphics.printf("SCORE", 240, 200, 40, "left")
+
+	love.graphics.setFont(font_3x5_3)
+	love.graphics.printf(self.lines, 240, 140, 90, "left")
+	love.graphics.printf(self.score, 240, 220, 90, "left")
+
+	love.graphics.setFont(font_8x11)
+	love.graphics.printf(formatTime(self.frames), 64, 420, 160, "center")
+end
+
+
+function MarathonC89Game:getBackground()
+	return math.min(self.level, 19)
+end
+
+function MarathonC89Game:getHighscoreData()
+	return {
+		score = self.score,
+		level = self.level,
+	}
+end
+
+return MarathonC89Game

tetris/modes/phantom_mania.lua

@@ -61,15 +61,15 @@ function PhantomManiaGame:getGravity()
 end
 
 function PhantomManiaGame:hitTorikan(old_level, new_level)
-	if old_level < 300 and new_level >= 300 and self.frames > sp(2,28) then
+	if old_level < 300 and new_level >= 300 and self.frames > frameTime(2,28) then
 		self.level = 300
 		return true
 	end
-	if old_level < 500 and new_level >= 500 and self.frames > sp(3,38) then
+	if old_level < 500 and new_level >= 500 and self.frames > frameTime(3,38) then
 		self.level = 500
 		return true
 	end
-	if old_level < 800 and new_level >= 800 and self.frames > sp(5,23) then
+	if old_level < 800 and new_level >= 800 and self.frames > frameTime(5,23) then
 		self.level = 800
 		return true
 	end

tetris/modes/phantom_mania2.lua

@@ -25,6 +25,8 @@ function PhantomMania2Game:new()
 	self.combo = 1
 	self.hold_age = 0
 	self.queue_age = 0
+	self.roll_points = 0
+
 	self.randomizer = History6RollsRandomizer()
 
 	self.lock_drop = true
@@ -84,19 +86,19 @@ function PhantomMania2Game:getNextPiece(ruleset)
 end
 
 function PhantomMania2Game:hitTorikan(old_level, new_level)
-	if old_level < 300 and new_level >= 300 and self.frames > sp(2,02) then
+	if old_level < 300 and new_level >= 300 and self.frames > frameTime(2,02) then
 		self.level = 300
 		return true
 	end
-	if old_level < 500 and new_level >= 500 and self.frames > sp(3,03) then
+	if old_level < 500 and new_level >= 500 and self.frames > frameTime(3,03) then
 		self.level = 500
 		return true
 	end
-	if old_level < 800 and new_level >= 800 and self.frames > sp(4,45) then
+	if old_level < 800 and new_level >= 800 and self.frames > frameTime(4,45) then
 		self.level = 800
 		return true
 	end
-	if old_level < 1000 and new_level >= 1000 and self.frames > sp(5,38) then
+	if old_level < 1000 and new_level >= 1000 and self.frames > frameTime(5,38) then
 		self.level = 1000
 		return true
 	end
@@ -135,7 +137,7 @@ function PhantomMania2Game:onPieceEnter()
 end
 
 local cleared_row_levels = {1, 2, 4, 6}
-local cleared_row_points = {0.02, 0.05, 0.15, 0.6}
+local cleared_row_points = {2, 6, 15, 40}
 
 function PhantomMania2Game:onLineClear(cleared_row_count)
 	if not self.clear then
@@ -144,6 +146,7 @@ function PhantomMania2Game:onLineClear(cleared_row_count)
 		if new_level >= 1300 or self:hitTorikan(self.level, new_level) then
 			if new_level >= 1300 then
 				self.level = 1300
+				self.big_mode = true
 			end
 			self.clear = true
 			self.grid:clear()
@@ -152,6 +155,12 @@ function PhantomMania2Game:onLineClear(cleared_row_count)
 			self.level = math.min(new_level, 1300)
 		end
 		self:advanceBottomRow(-cleared_row_count)
+	else
+		self.roll_points = self.roll_points + cleared_row_points[cleared_row_count / 2]
+		if self.roll_points >= 100 then
+			self.roll_points = self.roll_points - 100
+			self.grade = self.grade + 1
+		end
 	end
 end
 
@@ -179,15 +188,15 @@ end
 
 
 local cool_cutoffs = {
-	sp(0,36), sp(0,36), sp(0,36), sp(0,36), sp(0,36),
+	frameTime(0,36), frameTime(0,36), frameTime(0,36), frameTime(0,36), frameTime(0,36),
-	sp(0,30), sp(0,30), sp(0,30), sp(0,30), sp(0,30),
+	frameTime(0,30), frameTime(0,30), frameTime(0,30), frameTime(0,30), frameTime(0,30),
-	sp(0,27), sp(0,27), sp(0,27),
+	frameTime(0,27), frameTime(0,27), frameTime(0,27),
 }
 
 local regret_cutoffs = {
-	sp(0,50), sp(0,50), sp(0,50), sp(0,50), sp(0,50),
+	frameTime(0,50), frameTime(0,50), frameTime(0,50), frameTime(0,50), frameTime(0,50),
-	sp(0,40), sp(0,40), sp(0,40), sp(0,40), sp(0,40),
+	frameTime(0,40), frameTime(0,40), frameTime(0,40), frameTime(0,40), frameTime(0,40),
-	sp(0,35), sp(0,35), sp(0,35),
+	frameTime(0,35), frameTime(0,35), frameTime(0,35),
 }
 
 function PhantomMania2Game:updateSectionTimes(old_level, new_level)
@@ -225,7 +234,7 @@ PhantomMania2Game.garbageOpacityFunction = function(age)
 end
 
 function PhantomMania2Game:drawGrid()
-	if not (self.game_over or self.clear) then
+	if not (self.game_over or (self.clear and self.level < 1300)) then
 		self.grid:drawInvisible(self.rollOpacityFunction, self.garbageOpacityFunction)
 	else
 		self.grid:draw()
@@ -243,7 +252,7 @@ local function getLetterGrade(grade)
 end
 
 function PhantomMania2Game:setNextOpacity(i)
-	if self.level > 1000 then
+	if self.level > 1000 and self.level < 1300 then
 		local hidden_next_pieces = math.floor(self.level / 100) - 10
 		if i < hidden_next_pieces then
 			love.graphics.setColor(1, 1, 1, 0)
@@ -258,7 +267,7 @@ function PhantomMania2Game:setNextOpacity(i)
 end
 
 function PhantomMania2Game:setHoldOpacity()
-	if self.level > 1000 then
+	if self.level > 1000 and self.level < 1300 then
 		love.graphics.setColor(1, 1, 1, 1 - math.min(1, self.hold_age / 15))
 	else
 		love.graphics.setColor(1, 1, 1, 1)

tetris/modes/race_40.lua

@@ -5,17 +5,15 @@ local Piece = require 'tetris.components.piece'
 
 local History6RollsRandomizer = require 'tetris.randomizers.history_6rolls'
 
-local LigneGame = GameMode:extend()
+local Race40Game = GameMode:extend()
 
-LigneGame.name = "Ligne"
+Race40Game.name = "Race 40"
-LigneGame.hash = "Ligne"
+Race40Game.hash = "Race40"
-LigneGame.tagline = "How fast can you clear 40 lines?"
+Race40Game.tagline = "How fast can you clear 40 lines?"
 
 
-
+function Race40Game:new()
-
+	Race40Game.super:new()
-function LigneGame:new()
-	LigneGame.super:new()
 
 	self.lines = 0
 	self.line_goal = 40
@@ -32,39 +30,39 @@ function LigneGame:new()
 	self.next_queue_length = 3
 end
 
-function LigneGame:getDropSpeed()
+function Race40Game:getDropSpeed()
 	return 20
 end
 
-function LigneGame:getARR()
+function Race40Game:getARR()
 	return 0
 end
 
-function LigneGame:getARE()
+function Race40Game:getARE()
 	return 0
 end
 
-function LigneGame:getLineARE()
+function Race40Game:getLineARE()
 	return self:getARE()
 end
 
-function LigneGame:getDasLimit()
+function Race40Game:getDasLimit()
 	return 6
 end
 
-function LigneGame:getLineClearDelay()
+function Race40Game:getLineClearDelay()
 	return 0
 end
 
-function LigneGame:getLockDelay()
+function Race40Game:getLockDelay()
 	return 15
 end
 
-function LigneGame:getGravity()
+function Race40Game:getGravity()
 	return 1/64
 end
 
-function LigneGame:advanceOneFrame()
+function Race40Game:advanceOneFrame()
 	if self.clear then
 		self.roll_frames = self.roll_frames + 1
 		if self.roll_frames > 150 then
@@ -77,11 +75,11 @@ function LigneGame:advanceOneFrame()
 	return true
 end
 
-function LigneGame:onPieceLock()
+function Race40Game:onPieceLock()
 	self.pieces = self.pieces + 1
 end
 
-function LigneGame:onLineClear(cleared_row_count)
+function Race40Game:onLineClear(cleared_row_count)
 	if not self.clear then
 		self.lines = self.lines + cleared_row_count
 		if self.lines >= self.line_goal then
@@ -90,22 +88,22 @@ function LigneGame:onLineClear(cleared_row_count)
 	end
 end
 
-function LigneGame:drawGrid(ruleset)
+function Race40Game:drawGrid(ruleset)
 	self.grid:draw()
 	if self.piece ~= nil then
 		self:drawGhostPiece(ruleset)
 	end
 end
 
-function LigneGame:getHighscoreData()
+function Race40Game:getHighscoreData()
 	return {
 		level = self.level,
 		frames = self.frames,
 	}
 end
 
-function LigneGame:drawScoringInfo()
+function Race40Game:drawScoringInfo()
-	LigneGame.super.drawScoringInfo(self)
+	Race40Game.super.drawScoringInfo(self)
 	love.graphics.setColor(1, 1, 1, 1)
 
 	local text_x = config["side_next"] and 320 or 240
@@ -124,8 +122,8 @@ function LigneGame:drawScoringInfo()
 	love.graphics.printf(math.max(0, self.line_goal - self.lines), text_x, 340, 40, "left")
 end
 
-function LigneGame:getBackground()
+function Race40Game:getBackground()
 	return 2
 end
 
-return LigneGame
+return Race40Game

tetris/modes/survival_2020.lua

@@ -102,15 +102,15 @@ function Survival2020Game:getNextPiece(ruleset)
 end
 
 function Survival2020Game:hitTorikan(old_level, new_level)
-	if old_level < 500 and new_level >= 500 and self.frames > sp(3,00) then
+	if old_level < 500 and new_level >= 500 and self.frames > frameTime(3,00) then
 		self.level = 500
 		return true
 	end
-	if old_level < 1000 and new_level >= 1000 and self.frames > sp(5,00) then
+	if old_level < 1000 and new_level >= 1000 and self.frames > frameTime(5,00) then
 		self.level = 1000
 		return true
 	end
-	if old_level < 1500 and new_level >= 1500 and self.frames > sp(7,00) then
+	if old_level < 1500 and new_level >= 1500 and self.frames > frameTime(7,00) then
 		self.level = 1500
 		return true
 	end
@@ -193,7 +193,7 @@ function Survival2020Game:updateSectionTimes(old_level, new_level)
 		section_time = self.frames - self.section_start_time
 		table.insert(self.section_times, section_time)
 		self.section_start_time = self.frames
-		if section_time <= sp(0,30) then
+		if section_time <= frameTime(0,30) then
 			self.grade = self.grade + 2
 		else
 			self.grade = self.grade + 1

tetris/modes/survival_a1.lua

@@ -25,6 +25,12 @@ function SurvivalA1Game:new()
 		level999 = false
     }
     
+    self.SGnames = {
+        "9", "8", "7", "6", "5", "4", "3", "2", "1",
+        "S1", "S2", "S3", "S4", "S5", "S6", "S7", "S8", "S9",
+        "GM"
+    }
+    
 	self.randomizer = History4RollsRandomizer()
 
     self.lock_drop = false
@@ -125,15 +131,15 @@ end
 
 function SurvivalA1Game:checkGMRequirements(old_level, new_level)
 	if old_level < 300 and new_level >= 300 then
-		if self.score > 12000 and self.frames <= sp(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 <= sp(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 <= sp(13,30) then
+		if self.score > 126000 and self.frames <= frameTime(13,30) then
 			self.gm_conditions["level900"] = true
 		end
 	end
@@ -151,13 +157,17 @@ function SurvivalA1Game:drawScoringInfo()
 	love.graphics.print(
 		self.das.direction .. " " ..
 		self.das.frames .. " " ..
-		st(self.prev_inputs)
+		strTrueValues(self.prev_inputs)
 	)
 	love.graphics.printf("NEXT", 64, 40, 40, "left")
 	love.graphics.printf("GRADE", 240, 120, 40, "left")
 	love.graphics.printf("SCORE", 240, 200, 40, "left")
 	love.graphics.printf("NEXT RANK", 240, 260, 90, "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")
@@ -169,6 +179,9 @@ function SurvivalA1Game:drawScoringInfo()
 	love.graphics.printf(getRankForScore(self.score).next, 240, 280, 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")

tetris/modes/survival_a2.lua

@@ -19,6 +19,12 @@ function SurvivalA2Game:new()
 	self.roll_frames = 0
 	self.combo = 1
 	self.randomizer = History6RollsRandomizer()
+    
+    self.SGnames = {
+        "9", "8", "7", "6", "5", "4", "3", "2", "1",
+        "S1", "S2", "S3", "S4", "S5", "S6", "S7", "S8", "S9",
+        "GM"
+    }
 
 	self.lock_drop = true
 end
@@ -62,7 +68,7 @@ function SurvivalA2Game:getGravity()
 end
 
 function SurvivalA2Game:hitTorikan(old_level, new_level)
-	if old_level < 500 and new_level >= 500 and self.frames > sp(3,25) then
+	if old_level < 500 and new_level >= 500 and self.frames > frameTime(3,25) then
 		self.level = 500
 		return true
 	end
@@ -132,18 +138,25 @@ function SurvivalA2Game:drawScoringInfo()
 	love.graphics.print(
 		self.das.direction .. " " ..
 		self.das.frames .. " " ..
-		st(self.prev_inputs)
+		strTrueValues(self.prev_inputs)
 	)
 	love.graphics.printf("NEXT", 64, 40, 40, "left")
 	love.graphics.printf("GRADE", text_x, 120, 40, "left")
 	love.graphics.printf("SCORE", text_x, 200, 40, "left")
 	love.graphics.printf("LEVEL", text_x, 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, text_x, 220, 90, "left")
 	love.graphics.printf(self:getLetterGrade(), text_x, 140, 90, "left")
 	love.graphics.printf(self.level, text_x, 340, 40, "right")
 	love.graphics.printf(self:getSectionEndLevel(), text_x, 370, 40, "right")
+    if sg >= 5 then
+        love.graphics.printf(self.SGnames[sg], 240, 450, 180, "left")
+    end
 end
 
 function SurvivalA2Game:getSectionEndLevel()

tetris/modes/survival_a3.lua

@@ -24,10 +24,19 @@ function SurvivalA3Game:new()
 	self.roll_frames = 0
 	self.combo = 1
 	self.randomizer = History6RollsRandomizer()
+    
+    self.SGnames = {
+        "S1", "S2", "S3", "S4", "S5", "S6", "S7", "S8", "S9",
+        "m1", "m2", "m3", "m4", "m5", "m6", "m7", "m8", "m9",
+        "GM"
+    }
 
 	self.lock_drop = true
 	self.enable_hold = true
 	self.next_queue_length = 3
+
+	self.coolregret_message = "COOL!!"
+	self.coolregret_timer = 0
 end
 
 function SurvivalA3Game:getARE()
@@ -44,13 +53,14 @@ function SurvivalA3Game:getLineARE()
 end
 
 function SurvivalA3Game:getDasLimit()
-	    if self.level < 200 then return 9
+	    if self.level < 100 then return 9
 	elseif self.level < 500 then return 7
 	else return 5 end
 end
 
 function SurvivalA3Game:getLineClearDelay()
-	return self:getLineARE() - 2
+	if self.level < 1300 then return self:getLineARE() - 2
+	else return 6 end
 end
 
 function SurvivalA3Game:getLockDelay()
@@ -60,7 +70,8 @@ function SurvivalA3Game:getLockDelay()
 	elseif self.level < 600 then return 13
 	elseif self.level < 1100 then return 12
 	elseif self.level < 1200 then return 10
-	else return 8 end
+	elseif self.level < 1300 then return 8
+	else return 15 end
 end
 
 function SurvivalA3Game:getGravity()
@@ -84,11 +95,11 @@ function SurvivalA3Game:getNextPiece(ruleset)
 end
 
 function SurvivalA3Game:hitTorikan(old_level, new_level)
-	if old_level < 500 and new_level >= 500 and self.frames > sp(2,28) then
+	if old_level < 500 and new_level >= 500 and self.frames > frameTime(2,28) then
 		self.level = 500
 		return true
 	end
-	if old_level < 1000 and new_level >= 1000 and self.frames > sp(4,56) then
+	if old_level < 1000 and new_level >= 1000 and self.frames > frameTime(4,56) then
 		self.level = 1000
 		return true
 	end
@@ -133,6 +144,7 @@ function SurvivalA3Game:onLineClear(cleared_row_count)
 			end
 			self.clear = true
 			self.grid:clear()
+			self.big_mode = true
 			self.roll_frames = -150
 		else
 			self.level = math.min(new_level, 1300)
@@ -165,8 +177,11 @@ function SurvivalA3Game:updateSectionTimes(old_level, new_level)
 		section_time = self.frames - self.section_start_time
 		table.insert(self.section_times, section_time)
 		self.section_start_time = self.frames
-		if section_time <= sp(1,00) then
+		if section_time <= frameTime(1,00) then
 			self.grade = self.grade + 1
+		else
+			self.coolregret_message = "REGRET!!"
+			self.coolregret_timer = 300
 		end
 	end
 end
@@ -188,10 +203,8 @@ end
 local function getLetterGrade(grade)
 	if grade == 0 then
 		return "1"
-	elseif grade <= 9 then
-		return "S" .. tostring(grade)
 	else
-		return "M" .. tostring(grade - 9)
+		return "S" .. tostring(grade)
 	end
 end
 
@@ -206,6 +219,15 @@ function SurvivalA3Game:drawScoringInfo()
 	love.graphics.printf("GRADE", text_x, 120, 40, "left")
 	love.graphics.printf("SCORE", text_x, 200, 40, "left")
 	love.graphics.printf("LEVEL", text_x, 320, 40, "left")
+    local sg = self.grid:checkSecretGrade()
+    if sg >= 5 then 
+        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
 
 	local current_section = math.floor(self.level / 100) + 1
 	self:drawSectionTimesWithSplits(current_section)
@@ -219,6 +241,9 @@ function SurvivalA3Game:drawScoringInfo()
 	else
 		love.graphics.printf(math.floor(self.level / 100 + 1) * 100, text_x, 370, 50, "right")
 	end
+    if sg >= 5 then
+        love.graphics.printf(self.SGnames[sg], 240, 450, 180, "left")
+    end
 end
 
 function SurvivalA3Game:getBackground()

tetris/randomizers/bag5.lua

@@ -0,0 +1,17 @@
+local Randomizer = require 'tetris.randomizers.randomizer'
+
+local Bag5Randomizer = Randomizer:extend()
+
+function Bag5Randomizer:initialize()
+	self.bag = {"I", "J", "L", "O", "T"}
+end
+
+function Bag5Randomizer:generatePiece()
+	if next(self.bag) == nil then
+		self.bag = {"I", "J", "L", "O", "T"}
+	end
+	local x = math.random(table.getn(self.bag))
+	return table.remove(self.bag, x)
+end
+
+return Bag5Randomizer

tetris/randomizers/bag5alt.lua

@@ -0,0 +1,24 @@
+local Randomizer = require 'tetris.randomizers.randomizer'
+
+local Bag5AltRandomizer = Randomizer:extend()
+
+function Bag5AltRandomizer:initialize()
+	self.bag = {"I", "J", "L", "O", "T"}
+	self.prev = nil
+end
+
+function Bag5AltRandomizer:generatePiece()
+	if next(self.bag) == nil then
+		self.bag = {"I", "J", "L", "O", "T"}
+	end
+	local x = math.random(table.getn(self.bag))
+	local temp = table.remove(self.bag, x)
+	if temp == self.prev then
+		local y = math.random(table.getn(self.bag))
+		temp = table.remove(self.bag, y)
+	end
+	self.prev = temp
+	return temp
+end
+
+return Bag5AltRandomizer

tetris/randomizers/bag7noSZOstart.lua

@@ -0,0 +1,31 @@
+local Randomizer = require 'tetris.randomizers.randomizer'
+
+local Bag7NoSZOStartRandomizer = Randomizer:extend()
+
+function Bag7NoSZOStartRandomizer:shuffleBag()
+    local b = self.bag
+    local ln = #b
+    for i = 1, ln do
+        local j = math.random(i, ln)
+        b[i], b[j] = b[j], b[i]
+    end
+end
+
+local function isnotSZO(x) return not(x == "S" or x == "Z" or x == "O") end 
+
+function Bag7NoSZOStartRandomizer:initialize()
+	self.bag = {"I", "J", "L", "O", "S", "T", "Z"}
+    repeat
+        self:shuffleBag()
+    until isnotSZO(self.bag[7])
+end
+
+function Bag7NoSZOStartRandomizer:generatePiece()
+	if #self.bag == 0 then
+		self.bag = {"I", "J", "L", "O", "S", "T", "Z"}
+        self:shuffleBag()
+	end
+	return table.remove(self.bag)
+end
+
+return Bag7NoSZOStartRandomizer

tetris/randomizers/bag_konoha.lua

@@ -0,0 +1,28 @@
+local Randomizer = require 'tetris.randomizers.randomizer'
+
+local BagKonoha = Randomizer:extend()
+
+function BagKonoha:initialize()
+	self.bag = {"I", "J", "L", "O", "T"}
+	self.prev = nil
+	self.allowrepeat = false
+	self.generated = 0
+end
+
+function BagKonoha:generatePiece()
+	self.generated = self.generated + 1
+	if #self.bag == 0 then
+		self.bag = {"I", "J", "L", "O", "T"}
+	end
+	local x = math.random(#self.bag)
+	local temp = table.remove(self.bag, x)
+	if temp == self.prev and not self.allowrepeat then
+		local y = math.random(#self.bag)
+		table.insert(self.bag, temp) -- should insert at the end of the bag, bag[y] doesnt change
+		temp = table.remove(self.bag, y)
+	end
+	self.prev = temp
+	return temp
+end
+
+return BagKonoha

tetris/randomizers/history_4rolls.lua

@@ -3,17 +3,23 @@ local Randomizer = require 'tetris.randomizers.randomizer'
 local History4RollsRandomizer = Randomizer:extend()
 
 function History4RollsRandomizer:initialize()
-	self.history = {"Z", "S", "Z", "S"}
+	self.history = {"Z", "Z", "Z", "Z"}
+    self.first = true
 end
 
 function History4RollsRandomizer:generatePiece()
-	local shapes = {"I", "J", "L", "O", "S", "T", "Z"}
+    if self.first then
-	for i = 1, 4 do
+        self.first = false
-		local x = math.random(7)
+        return self:updateHistory(({"L", "J", "I", "T"})[math.random(4)])
-		if not inHistory(shapes[x], self.history) or i == 4 then
+    else
-			return self:updateHistory(shapes[x])
+        local shapes = {"I", "J", "L", "O", "S", "T", "Z"}
-		end
+        for i = 1, 4 do
-	end
+            local x = math.random(7)
+            if not inHistory(shapes[x], self.history) or i == 4 then
+                return self:updateHistory(shapes[x])
+            end
+        end
+    end
 end
 
 function History4RollsRandomizer:updateHistory(shape)

tetris/randomizers/history_6rolls.lua

@@ -4,16 +4,22 @@ local History6RollsRandomizer = Randomizer:extend()
 
 function History6RollsRandomizer:initialize()
 	self.history = {"Z", "S", "Z", "S"}
+    self.first = true
 end
 
 function History6RollsRandomizer:generatePiece()
-	local shapes = {"I", "J", "L", "O", "S", "T", "Z"}
+    if self.first then
-	for i = 1, 6 do
+        self.first = false
-		local x = math.random(7)
+        return self:updateHistory(({"L", "J", "I", "T"})[math.random(4)])
-		if not inHistory(shapes[x], self.history) or i == 6 then
+    else
-			return self:updateHistory(shapes[x])
+        local shapes = {"I", "J", "L", "O", "S", "T", "Z"}
-		end
+        for i = 1, 6 do
-	end
+            local x = math.random(7)
+            if not inHistory(shapes[x], self.history) or i == 6 then
+                return self:updateHistory(shapes[x])
+            end
+        end
+    end
 end
 
 function History6RollsRandomizer:updateHistory(shape)

tetris/randomizers/history_6rolls_35bag.lua

@@ -1,38 +1,70 @@
 local Randomizer = require 'tetris.randomizers.randomizer'
 
-local History6RollsRandomizer = Randomizer:extend()
+local History6Rolls35PoolRandomizer = Randomizer:extend()
 
-function History6RollsRandomizer:initialize()
+function History6Rolls35PoolRandomizer:initialize()
+    self.first = true
 	self.history = {"Z", "S", "Z", "S"}
-	self.bag_counts = {
+	self.pool = {
-		I = 5, J = 5, L = 5, O = 5, S = 3, T = 5, Z = 3
+		"I", "I", "I", "I", "I",
+        "T", "T", "T", "T", "T",
+        "L", "L", "L", "L", "L",
+        "J", "J", "J", "J", "J",
+        "S", "S", "S", "S", "S",
+        "Z", "Z", "Z", "Z", "Z",
+        "O", "O", "O", "O", "O",
 	}
+    self.droughts = {
+        I = 0,
+        T = 0,
+        L = 0,
+        J = 0,
+        S = 0,
+        Z = 0,
+        O = 0,
+    }
 end
 
-function History6RollsRandomizer:getBagPiece(n)
+function History6Rolls35PoolRandomizer:generatePiece()
-	for shape, count in pairs(self.bag_counts) do
+    local index, x
-		n = n - count
+    if self.first then
-		if n <= 0 then
+        local prevent = {"S", "Z", "O"}
-			return shape
+        repeat
-		end
+            index = math.random(#self.pool)
-	end
+            x = self.pool[index]
+        until not inHistory(x, prevent)
+        self.first = false
+    else
+        for i = 1, 6 do
+            index = math.random(#self.pool)
+            x = self.pool[index]
+            if not inHistory(x, self.history) or i == 6 then
+                break
+            end
+        end
+    end
+    self.pool[index] = self:updateHistory(x)
+    return x
 end
 
-function History6RollsRandomizer:generatePiece()
+function History6Rolls35PoolRandomizer:updateHistory(shape)
-	for i = 1, 6 do
+	table.remove(self.history, 1)
-		local x = self:getBagPiece(math.random(31))
-		if not inHistory(x, self.history) or i == 6 then
-			return self:updateHistory(x)
-		end
-	end
-end
-
-function History6RollsRandomizer:updateHistory(shape)
-	self.bag_counts[shape] = self.bag_counts[shape] - 1
-	local replaced_piece = table.remove(self.history, 1)
 	table.insert(self.history, shape)
-	self.bag_counts[replaced_piece] = self.bag_counts[replaced_piece] + 1
+
-	return shape
+    local highdrought
+    local highdroughtcount = 0
+    for k, v in pairs(self.droughts) do 
+        if k == shape then
+            self.droughts[k] = 0
+        else
+            self.droughts[k] = v + 1
+            if v >= highdroughtcount then
+                highdrought = k
+                highdroughtcount = v
+            end
+        end
+    end
+	return highdrought
 end
 
 function inHistory(piece, history)
@@ -44,4 +76,4 @@ function inHistory(piece, history)
 	return false
 end
 
-return History6RollsRandomizer
+return History6Rolls35PoolRandomizer

tetris/randomizers/randomizer.lua

@@ -4,15 +4,10 @@ local Randomizer = Object:extend()
 
 function Randomizer:new()
 	self:initialize()
-	self.next_queue = {}
-	for i = 1, 30 do
-		table.insert(self.next_queue, self:generatePiece())
-	end
 end
 
 function Randomizer:nextPiece()
-	table.insert(self.next_queue, self:generatePiece())
+	return self:generatePiece()
-	return table.remove(self.next_queue, 1)
 end
 
 function Randomizer:initialize()

tetris/rulesets/arika.lua

@@ -16,6 +16,16 @@ ARS.spawn_positions = {
 	Z = { x=4, y=5 },
 }
 
+ARS.big_spawn_positions = {
+	I = { x=2, y=2 },
+	J = { x=2, y=3 },
+	L = { x=2, y=3 },
+	O = { x=2, y=3 },
+	S = { x=2, y=3 },
+	T = { x=2, y=3 },
+	Z = { x=2, y=3 },
+}
+
 ARS.block_offsets = {
 	I={
 		{ {x=0, y=0}, {x=-1, y=0}, {x=-2, y=0}, {x=1, y=0} },
@@ -71,11 +81,19 @@ function ARS:attemptWallkicks(piece, new_piece, rot_dir, grid)
 		piece.shape == "J" or piece.shape == "T" or piece.shape == "L"
 	) and (
 		piece.rotation == 0 or piece.rotation == 2
-	) and (
+	) then
-		grid:isOccupied(piece.position.x, piece.position.y) or
+        local offsets = new_piece:getBlockOffsets()
-		grid:isOccupied(piece.position.x, piece.position.y - 1) or
+        table.sort(offsets, function(A, B) return A.y < B.y or A.y == B.y and A.x < B.y end)
-		grid:isOccupied(piece.position.x, piece.position.y - 2)
+        for index, offset in pairs(offsets) do
-	) then return end
+            if grid:isOccupied(piece.position.x + offset.x, piece.position.y + offset.y) then
+                if offset.x == 0 then
+                    return 
+                else
+                    break
+                end
+            end
+        end
+    end
 
 	-- kick right, kick left
 	if (grid:canPlacePiece(new_piece:withOffset({x=1, y=0}))) then

tetris/rulesets/arika_ace.lua

@@ -0,0 +1,178 @@
+local Piece = require 'tetris.components.piece'
+local Ruleset = require 'tetris.rulesets.ruleset'
+
+local ARS = Ruleset:extend()
+
+ARS.name = "ACE-ARS"
+ARS.hash = "ArikaACE"
+
+ARS.spawn_positions = {
+	I = { x=5, y=2 },
+	J = { x=4, y=3 },
+	L = { x=4, y=3 },
+	O = { x=5, y=3 },
+	S = { x=4, y=3 },
+	T = { x=4, y=3 },
+	Z = { x=4, y=3 },
+}
+
+ARS.big_spawn_positions = {
+	I = { x=2, y=0 },
+	J = { x=2, y=1 },
+	L = { x=2, y=1 },
+	O = { x=2, y=1 },
+	S = { x=2, y=1 },
+	T = { x=2, y=1 },
+	Z = { x=2, y=1 },
+}
+
+ARS.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=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} },
+	},
+	J={
+		{ {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} },
+		{ {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} },
+	},
+	L={
+		{ {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} },
+		{ {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} },
+	},
+	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=-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} },
+	},
+	T={
+		{ {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} },
+		{ {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} },
+	},
+	Z={
+		{ {x=0, y=-1}, {x=-1, y=-1}, {x=1, y=0}, {x=0, y=0} },
+		{ {x=0, y=-1}, {x=0, y=0}, {x=1, y=-2}, {x=1, y=-1} },
+		{ {x=0, y=-1}, {x=-1, y=-1}, {x=1, y=0}, {x=0, y=0} },
+		{ {x=0, y=-1}, {x=0, y=0}, {x=1, y=-2}, {x=1, y=-1} },
+	}
+}
+
+
+-- Component functions.
+
+function ARS:attemptWallkicks(piece, new_piece, rot_dir, grid)
+
+	-- O doesn't kick
+	if (piece.shape == "O") then return end
+
+	-- center column rule
+	if (
+		piece.shape == "J" or piece.shape == "T" or piece.shape == "L"
+	) and (
+		piece.rotation == 0 or piece.rotation == 2
+	) then
+        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
+                if offset.x == 0 then
+                    return 
+                else
+                    break
+                end
+            end
+        end
+    end
+
+	if piece.shape == "I" then
+		-- special kick rules for I
+		if new_piece.rotation == 0 or new_piece.rotation == 2 then
+			-- kick right, right2, left
+			if grid:canPlacePiece(new_piece:withOffset({x=1, y=0})) then
+				piece:setRelativeRotation(rot_dir):setOffset({x=1, y=0})
+				self:onPieceRotate(piece, grid)
+			elseif grid:canPlacePiece(new_piece:withOffset({x=2, y=0})) then
+				piece:setRelativeRotation(rot_dir):setOffset({x=2, y=0})
+				self:onPieceRotate(piece, grid)
+			elseif grid:canPlacePiece(new_piece:withOffset({x=-1, y=0})) then
+				piece:setRelativeRotation(rot_dir):setOffset({x=-1, y=0})
+				self:onPieceRotate(piece, grid)
+			end
+		elseif piece:isDropBlocked(grid) and (new_piece.rotation == 1 or new_piece.rotation == 3) and piece.floorkick == 0 then
+			-- kick up, up2
+			if grid:canPlacePiece(new_piece:withOffset({x=0, y=-1})) then
+				piece:setRelativeRotation(rot_dir):setOffset({x=0, y=-1})
+				self:onPieceRotate(piece, grid)
+				piece.floorkick = 1
+			elseif grid:canPlacePiece(new_piece:withOffset({x=0, y=-2})) then
+				piece:setRelativeRotation(rot_dir):setOffset({x=0, y=-2})
+				self:onPieceRotate(piece, grid)
+				piece.floorkick = 1
+			end
+		end
+	else
+        -- kick right, kick left
+        if grid:canPlacePiece(new_piece:withOffset({x=1, y=0})) then
+            piece:setRelativeRotation(rot_dir):setOffset({x=1, y=0})
+        elseif grid:canPlacePiece(new_piece:withOffset({x=-1, y=0})) then
+            piece:setRelativeRotation(rot_dir):setOffset({x=-1, y=0})
+        elseif piece.shape == "T"
+           and new_piece.rotation == 1
+           and piece.floorkick == 0
+           and grid:canPlacePiece(new_piece:withOffset({x=0, y=-1}))
+        then
+            -- T floorkick
+            piece.floorkick = piece.floorkick + 1
+            piece:setRelativeRotation(rot_dir):setOffset({x=0, y=-1})
+        end
+	end
+
+end
+
+function ARS:onPieceCreate(piece, grid)
+	piece.floorkick = 0
+	piece.manipulations = 0
+end
+
+function ARS:onPieceDrop(piece, grid)
+	piece.lock_delay = 0 -- step reset
+end
+
+function ARS:onPieceMove(piece, grid)
+	piece.lock_delay = 0 -- move reset
+	if piece:isDropBlocked(grid) then
+		piece.manipulations = piece.manipulations + 1
+		if piece.manipulations >= 127 then
+			piece.locked = true
+		end
+	end
+end
+
+function ARS:onPieceRotate(piece, grid)
+	piece.lock_delay = 0 -- rotate reset
+	if piece:isDropBlocked(grid) then
+		piece.manipulations = piece.manipulations + 1
+		if piece.manipulations >= 127 then
+			piece.locked = true
+		end
+	end
+end
+
+function ARS:get180RotationValue() return config["reverse_rotate"] and 1 or 3 end
+function ARS:getDefaultOrientation() return 3 end  -- downward facing pieces by default
+
+return ARS

tetris/rulesets/arika_srs.lua

@@ -0,0 +1,177 @@
+local Piece = require 'tetris.components.piece'
+local Ruleset = require 'tetris.rulesets.ruleset'
+
+local SRS = Ruleset:extend()
+
+SRS.name = "ACE-SRS"
+SRS.hash = "ACE Standard"
+
+SRS.enable_IRS_wallkicks = true
+
+SRS.spawn_positions = {
+	I = { x=5, y=2 },
+	J = { x=4, y=3 },
+	L = { x=4, y=3 },
+	O = { x=5, y=3 },
+	S = { x=4, y=3 },
+	T = { x=4, y=3 },
+	Z = { x=4, y=3 },
+}
+
+SRS.big_spawn_positions = {
+	I = { x=2, y=0 },
+	J = { x=2, y=1 },
+	L = { x=2, y=1 },
+	O = { x=2, y=1 },
+	S = { x=2, y=1 },
+	T = { x=2, y=1 },
+	Z = { x=2, y=1 },
+}
+
+SRS.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} },
+	}
+}
+
+SRS.wallkicks_3x3 = {
+	[0]={
+		[1]={{x=-1, y=0}, {x=-1, y=-1}, {x=0, y=2}, {x=-1, y=2}},
+		[2]={{x=0, y=1}, {x=0, y=-1}},
+		[3]={{x=1, y=0}, {x=1, y=-1}, {x=0, y=2}, {x=1, y=2}},
+	},
+	[1]={
+		[0]={{x=1, y=0}, {x=1, y=1}, {x=0, y=-2}, {x=1, y=-2}},
+		[2]={{x=1, y=0}, {x=1, y=1}, {x=0, y=-2}, {x=1, y=-2}},
+		[3]={{x=0, y=1}, {x=0, y=-1}},
+	},
+	[2]={
+		[0]={{x=0, y=1}, {x=0, y=-1}},
+		[1]={{x=-1, y=0}, {x=-1, y=-1}, {x=0, y=2}, {x=-1, y=2}},
+		[3]={{x=1, y=0}, {x=1, y=-1}, {x=0, y=2}, {x=1, y=2}},
+	},
+	[3]={
+		[0]={{x=-1, y=0}, {x=-1, y=1}, {x=0, y=-2}, {x=-1, y=-2}},
+		[1]={{x=0, y=1}, {x=0, y=-1}},
+		[2]={{x=-1, y=0}, {x=-1, y=1}, {x=0, y=-2}, {x=-1, y=-2}},
+	},
+};
+
+SRS.wallkicks_line = {
+	[0]={
+		[1]={{x=-2, y=0}, {x=1, y=0}, {x=-2, y=1}, {x=1, y=-2}},
+		[2]={},
+		[3]={{x=-1, y=0}, {x=2, y=0}, {x=-1, y=-2}, {x=2, y=1}},
+	},
+	[1]={
+		[0]={{x=2, y=0}, {x=-1, y=0}, {x=2, y=-1}, {x=-1, y=2}},
+		[2]={{x=-1, y=0}, {x=2, y=0}, {x=-1, y=-2}, {x=2, y=1}},
+		[3]={{x=0, y=1}, {x=0, y=-1}, {x=0, y=2}, {x=0, y=-2}},
+	},
+	[2]={
+		[0]={},
+		[1]={{x=1, y=0}, {x=-2, y=0}, {x=1, y=2}, {x=-2, y=-1}},
+		[3]={{x=2, y=0}, {x=-1, y=0}, {x=2, y=-1}, {x=-1, y=2}},
+	},
+	[3]={
+		[0]={{x=1, y=0}, {x=-2, y=0}, {x=1, y=2}, {x=-2, y=-1}},
+		[1]={{x=0, y=1}, {x=0, y=-1}, {x=0, y=2}, {x=0, y=-2}},
+		[2]={{x=-2, y=0}, {x=1, y=0}, {x=-2, y=1}, {x=1, y=-2}},
+	},
+};
+
+-- Component functions.
+
+function SRS:attemptWallkicks(piece, new_piece, rot_dir, grid)
+
+	local kicks
+	if piece.shape == "O" then
+		return
+	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
+
+function SRS:onPieceCreate(piece, grid)
+	piece.manipulations = 0
+end
+
+function SRS:onPieceDrop(piece, grid)
+	piece.lock_delay = 0 -- step reset
+end
+
+function SRS:onPieceMove(piece, grid)
+	piece.lock_delay = 0 -- move reset
+	if piece:isDropBlocked(grid) then
+		piece.manipulations = piece.manipulations + 1
+		if piece.manipulations >= 127 then
+			piece.locked = true
+		end
+	end
+end
+
+function SRS:onPieceRotate(piece, grid)
+	piece.lock_delay = 0 -- rotate reset
+	if piece:isDropBlocked(grid) then
+		piece.manipulations = piece.manipulations + 1
+		if piece.manipulations >= 127 then
+			piece.locked = true
+		end
+	end
+end
+
+return SRS

tetris/rulesets/arika_ti.lua

@@ -16,6 +16,16 @@ ARS.spawn_positions = {
 	Z = { x=4, y=5 },
 }
 
+ARS.big_spawn_positions = {
+	I = { x=2, y=2 },
+	J = { x=2, y=3 },
+	L = { x=2, y=3 },
+	O = { x=2, y=3 },
+	S = { x=2, y=3 },
+	T = { x=2, y=3 },
+	Z = { x=2, y=3 },
+}
+
 ARS.block_offsets = {
 	I={
 		{ {x=0, y=0}, {x=-1, y=0}, {x=-2, y=0}, {x=1, y=0} },
@@ -74,11 +84,19 @@ function ARS:attemptWallkicks(piece, new_piece, rot_dir, grid)
 		piece.shape == "J" or piece.shape == "T" or piece.shape == "L"
 	) and (
 		piece.rotation == 0 or piece.rotation == 2
-	) and (
+	) then
-		grid:isOccupied(piece.position.x, piece.position.y) or
+        local offsets = new_piece:getBlockOffsets()
-		grid:isOccupied(piece.position.x, piece.position.y - 1) or
+        table.sort(offsets, function(A, B) return A.y < B.y or A.y == B.y and A.x < B.y end)
-		grid:isOccupied(piece.position.x, piece.position.y - 2)
+        for index, offset in pairs(offsets) do
-	) then return end
+            if grid:isOccupied(piece.position.x + offset.x, piece.position.y + offset.y) then
+                if offset.x == 0 then
+                    return 
+                else
+                    break
+                end
+            end
+        end
+    end
 
 	if piece.shape == "I" then
 		-- special kick rules for I
@@ -106,14 +124,21 @@ function ARS:attemptWallkicks(piece, new_piece, rot_dir, grid)
 				piece.floorkick = 1
 			end
 		end
-	elseif piece.shape ~= "I" then
+	else
-			-- kick right, kick left
+        -- kick right, kick left
-			if (grid:canPlacePiece(new_piece:withOffset({x=1, y=0}))) then
+        if grid:canPlacePiece(new_piece:withOffset({x=1, y=0})) then
-				piece:setRelativeRotation(rot_dir):setOffset({x=1, y=0})
+            piece:setRelativeRotation(rot_dir):setOffset({x=1, y=0})
-			elseif (grid:canPlacePiece(new_piece:withOffset({x=-1, y=0}))) then
+        elseif grid:canPlacePiece(new_piece:withOffset({x=-1, y=0})) then
-				piece:setRelativeRotation(rot_dir):setOffset({x=-1, y=0})
+            piece:setRelativeRotation(rot_dir):setOffset({x=-1, y=0})
-			end
+        elseif piece.shape == "T"
-		else
+           and new_piece.rotation == 1
+           and piece.floorkick == 0
+           and grid:canPlacePiece(new_piece:withOffset({x=0, y=-1}))
+        then
+            -- T floorkick
+            piece.floorkick = piece.floorkick + 1
+            piece:setRelativeRotation(rot_dir):setOffset({x=0, y=-1})
+        end
 	end
 
 end

tetris/rulesets/cambridge.lua

@@ -16,6 +16,16 @@ CRS.spawn_positions = {
 	Z = { x=4, y=4 },
 }
 
+CRS.big_spawn_positions = {
+	I = { x=2, y=2 },
+	J = { x=2, y=3 },
+	L = { x=2, y=3 },
+	O = { x=2, y=3 },
+	S = { x=2, y=2 },
+	T = { x=2, y=3 },
+	Z = { x=2, y=2 },
+}
+
 CRS.block_offsets = {
 	I={
 		{ {x=0, y=0}, {x=-1, y=0}, {x=-2, y=0}, {x=1, y=0} },

tetris/rulesets/ruleset.lua

@@ -72,10 +72,17 @@ function Ruleset:movePiece(piece, grid, move)
 	end
 end
 
-function Ruleset:dropPiece(inputs, piece, grid, gravity, drop_speed, drop_locked, hard_drop_locked, hard_drop_enabled)
+function Ruleset:dropPiece(
+	inputs, piece, grid, gravity, drop_speed, drop_locked, hard_drop_locked,
+	hard_drop_enabled, additive_gravity
+)
 	local y = piece.position.y
 	if inputs["down"] == true and drop_locked == false then
-		piece:addGravity(gravity + drop_speed, grid)
+		if additive_gravity then
+			piece:addGravity(gravity + drop_speed, grid)
+		else
+			piece:addGravity(math.max(gravity, drop_speed), grid)
+		end
 	elseif inputs["up"] == true and hard_drop_enabled == true then
 		if hard_drop_locked == true or piece:isDropBlocked(grid) then
 			piece:addGravity(gravity, grid)
@@ -102,12 +109,19 @@ function Ruleset:getDefaultOrientation() return 1 end
 function Ruleset:initializePiece(
 	inputs, data, grid, gravity, prev_inputs,
 	move, lock_delay, drop_speed,
-	drop_locked, hard_drop_locked
+	drop_locked, hard_drop_locked, big
 )
+	local spawn_positions
+	if big then
+		spawn_positions = self.big_spawn_positions
+	else
+		spawn_positions = self.spawn_positions
+	end
 	local piece = Piece(data.shape, data.orientation - 1, {
-		x = self.spawn_positions[data.shape].x,
+		x = spawn_positions[data.shape].x,
-		y = self.spawn_positions[data.shape].y
+		y = spawn_positions[data.shape].y
-	}, self.block_offsets, 0, 0, data.skin)
+	}, self.block_offsets, 0, 0, data.skin, big)
+
 	self:onPieceCreate(piece)
 	self:rotatePiece(inputs, piece, grid, {}, true)
 	self:dropPiece(inputs, piece, grid, gravity, drop_speed, drop_locked, hard_drop_locked)
@@ -120,11 +134,15 @@ function Ruleset:onPieceCreate(piece) end
 function Ruleset:processPiece(
 	inputs, piece, grid, gravity, prev_inputs,
 	move, lock_delay, drop_speed,
-	drop_locked, hard_drop_locked, hard_drop_enabled
+	drop_locked, hard_drop_locked,
+	hard_drop_enabled, additive_gravity
 )
 	self:rotatePiece(inputs, piece, grid, prev_inputs, false)
 	self:movePiece(piece, grid, move)
-	self:dropPiece(inputs, piece, grid, gravity, drop_speed, drop_locked, hard_drop_locked, hard_drop_enabled)
+	self:dropPiece(
+		inputs, piece, grid, gravity, drop_speed, drop_locked, hard_drop_locked,
+		hard_drop_enabled, additive_gravity
+	)
 	self:lockPiece(piece, grid, lock_delay)
 end
 

tetris/rulesets/standard_exp.lua

@@ -3,19 +3,29 @@ local Ruleset = require 'tetris.rulesets.ruleset'
 
 local SRS = Ruleset:extend()
 
-SRS.name = "SRS"
+SRS.name = "Guideline SRS"
 SRS.hash = "Standard"
 
 SRS.enable_IRS_wallkicks = true
 
 SRS.spawn_positions = {
-	I = { x=5, y=4 },
+	I = { x=5, y=2 },
-	J = { x=4, y=5 },
+	J = { x=4, y=3 },
-	L = { x=4, y=5 },
+	L = { x=4, y=3 },
-	O = { x=5, y=5 },
+	O = { x=5, y=3 },
-	S = { x=4, y=5 },
+	S = { x=4, y=3 },
-	T = { x=4, y=5 },
+	T = { x=4, y=3 },
-	Z = { x=4, y=5 },
+	Z = { x=4, y=3 },
+}
+
+SRS.big_spawn_positions = {
+	I = { x=2, y=0 },
+	J = { x=2, y=1 },
+	L = { x=2, y=1 },
+	O = { x=2, y=1 },
+	S = { x=2, y=1 },
+	T = { x=2, y=1 },
+	Z = { x=2, y=1 },
 }
 
 SRS.block_offsets = {

tetris/rulesets/ti_srs.lua

@@ -0,0 +1,177 @@
+local Piece = require 'tetris.components.piece'
+local Ruleset = require 'tetris.rulesets.ruleset'
+
+local SRS = Ruleset:extend()
+
+SRS.name = "Ti-World"
+SRS.hash = "Bad I-kicks"
+
+SRS.enable_IRS_wallkicks = true
+
+SRS.spawn_positions = {
+	I = { x=5, y=2 },
+	J = { x=4, y=3 },
+	L = { x=4, y=3 },
+	O = { x=5, y=3 },
+	S = { x=4, y=3 },
+	T = { x=4, y=3 },
+	Z = { x=4, y=3 },
+}
+
+SRS.big_spawn_positions = {
+	I = { x=2, y=0 },
+	J = { x=2, y=1 },
+	L = { x=2, y=1 },
+	O = { x=2, y=1 },
+	S = { x=2, y=1 },
+	T = { x=2, y=1 },
+	Z = { x=2, y=1 },
+}
+
+SRS.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} },
+	}
+}
+
+SRS.wallkicks_3x3 = {
+	[0]={
+		[1]={{x=-1, y=0}, {x=-1, y=-1}, {x=0, y=2}, {x=-1, y=2}},
+		[2]={{x=0, y=1}, {x=0, y=-1}},
+		[3]={{x=1, y=0}, {x=1, y=-1}, {x=0, y=2}, {x=1, y=2}},
+	},
+	[1]={
+		[0]={{x=1, y=0}, {x=1, y=1}, {x=0, y=-2}, {x=1, y=-2}},
+		[2]={{x=1, y=0}, {x=1, y=1}, {x=0, y=-2}, {x=1, y=-2}},
+		[3]={{x=0, y=1}, {x=0, y=-1}},
+	},
+	[2]={
+		[0]={{x=0, y=1}, {x=0, y=-1}},
+		[1]={{x=-1, y=0}, {x=-1, y=-1}, {x=0, y=2}, {x=-1, y=2}},
+		[3]={{x=1, y=0}, {x=1, y=-1}, {x=0, y=2}, {x=1, y=2}},
+	},
+	[3]={
+		[0]={{x=-1, y=0}, {x=-1, y=1}, {x=0, y=-2}, {x=-1, y=-2}},
+		[1]={{x=0, y=1}, {x=0, y=-1}},
+		[2]={{x=-1, y=0}, {x=-1, y=1}, {x=0, y=-2}, {x=-1, y=-2}},
+	},
+};
+
+SRS.wallkicks_line = {
+	[0]={
+		[1]={{x=-2, y=0}, {x=1, y=0}, {x=-2, y=1}, {x=1, y=-2}},
+		[2]={},
+		[3]={{x=-1, y=0}, {x=2, y=0}, {x=-1, y=-2}, {x=2, y=1}},
+	},
+	[1]={
+		[0]={{x=2, y=0}, {x=-1, y=0}, {x=2, y=-1}, {x=-1, y=2}},
+		[2]={{x=-1, y=0}, {x=2, y=0}, {x=-1, y=-2}, {x=2, y=1}},
+		[3]={{x=0, y=1}, {x=0, y=-1}, {x=0, y=2}, {x=0, y=-2}},
+	},
+	[2]={
+		[0]={},
+		[1]={{x=1, y=0}, {x=-2, y=0}, {x=1, y=2}, {x=-2, y=-1}},
+		[3]={{x=2, y=0}, {x=-1, y=0}, {x=2, y=-1}, {x=-1, y=2}},
+	},
+	[3]={
+		[0]={{x=1, y=0}, {x=-2, y=0}, {x=1, y=2}, {x=-2, y=-1}},
+		[1]={{x=0, y=1}, {x=0, y=-1}, {x=0, y=2}, {x=0, y=-2}},
+		[2]={{x=-2, y=0}, {x=1, y=0}, {x=-2, y=1}, {x=1, y=-2}},
+	},
+};
+
+-- Component functions.
+
+function SRS:attemptWallkicks(piece, new_piece, rot_dir, grid)
+
+	local kicks
+	if piece.shape == "O" then
+		return
+	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
+
+function SRS:onPieceCreate(piece, grid)
+	piece.manipulations = 0
+end
+
+function SRS:onPieceDrop(piece, grid)
+	piece.lock_delay = 0 -- step reset
+end
+
+function SRS:onPieceMove(piece, grid)
+	piece.lock_delay = 0 -- move reset
+	if piece:isDropBlocked(grid) then
+		piece.manipulations = piece.manipulations + 1
+		if piece.manipulations >= 8 then
+			piece.locked = true
+		end
+	end
+end
+
+function SRS:onPieceRotate(piece, grid)
+	piece.lock_delay = 0 -- rotate reset
+	if piece:isDropBlocked(grid) then
+		piece.manipulations = piece.manipulations + 1
+		if piece.manipulations >= 8 then
+			piece.locked = true
+		end
+	end
+end
+
+return SRS