Update README.md - loading custom assets

You can now specify an arbitrary number of pieces for a ruleset.
The randomizers will adjust accordingly.
Expect a pento ruleset in the modpack soon!
Also, gamemode skin selection has been refactored.

README.md

@@ -1,10 +1,5 @@
 ![Cambridge Banner](https://cdn.discordapp.com/attachments/764432435802013709/767724895076614154/cambridge_logo_lt.png)
 
-Important notice
-================
-
-![Tetra Online Notice](https://pbs.twimg.com/media/Eo3CkIHW8AEoK_U?format=png&name=small)
-
 Cambridge
 =========
 
@@ -65,6 +60,14 @@ Then, check the mod pack section at the bottom of this page.
 
 If you haven't already, install `love` with your favourite package manager (Homebrew on macOS, your system's default on Linux). **Make sure you're using LÖVE 11, because it won't work with earlier versions!**
 
+#### Downloading a release
+
+You can download the .love file in the latest release, and run it with:
+
+    love cambridge.love
+
+#### Installing from source
+
 Clone the repository in git:
 
 	git clone https://github.com/SashLilac/cambridge
@@ -81,6 +84,8 @@ It should run automatically!
 
 Simply drag your mode, ruleset, and randomizer Lua files into their respective [directory](https://love2d.org/wiki/love.filesystem), and they should appear automatically.  
 
+You can also load custom assets through this way, assuming you preserve the directory structure.  
+
 **WARNING:** The .exe / .love files and the bleeding edge releases have different save directories. Read the above link carefully!
 
 For more detailed instructions, install [this](https://github.com/SashLilac/cambridge-modpack) mod pack to get a taste of the mod potential.

load/graphics.lua

@@ -49,6 +49,18 @@ blocks = {
 		F = love.graphics.newImage("res/img/bone.png"),
 		A = love.graphics.newImage("res/img/bone.png"),
 		X = love.graphics.newImage("res/img/bone.png"),
+	},
+	["gem"] = {
+		R = love.graphics.newImage("res/img/gem1.png"),
+		O = love.graphics.newImage("res/img/gem3.png"),
+		Y = love.graphics.newImage("res/img/gem7.png"),
+		G = love.graphics.newImage("res/img/gem6.png"),
+		C = love.graphics.newImage("res/img/gem2.png"),
+		B = love.graphics.newImage("res/img/gem4.png"),
+		M = love.graphics.newImage("res/img/gem5.png"),
+		F = love.graphics.newImage("res/img/gem9.png"),
+		A = love.graphics.newImage("res/img/gem9.png"),
+		X = love.graphics.newImage("res/img/gem9.png"),
 	}
 }
 

scene/credits.lua

@@ -8,7 +8,9 @@ function CreditsScene:new()
 end
 
 function CreditsScene:update()
+    if love.window.hasFocus() then
         self.frames = self.frames + 1
+    end
     if self.frames >= 4200 then
         playSE("mode_decide")
         scene = TitleScene()

scene/game.lua

@@ -4,12 +4,13 @@ GameScene.title = "Game"
 
 require 'load.save'
 
-function GameScene:new(game_mode, ruleset)
+function GameScene:new(game_mode, ruleset, inputs)
 	self.retry_mode = game_mode
 	self.retry_ruleset = ruleset
-	self.game = game_mode()
+	self.secret_inputs = copy(inputs)
+	self.game = game_mode(self.secret_inputs)
 	self.ruleset = ruleset()
-	self.game:initialize(self.ruleset)
+	self.game:initialize(self.ruleset, self.secret_inputs)
 	self.inputs = {
 		left=false,
 		right=false,
@@ -82,9 +83,9 @@ function GameScene:onInputPress(e)
 		highscore_entry = self.game:getHighscoreData()
 		highscore_hash = self.game.hash .. "-" .. self.ruleset.hash
 		submitHighscore(highscore_hash, highscore_entry)
-		scene = e.input == "retry" and GameScene(self.retry_mode, self.retry_ruleset) or ModeSelectScene()
+		scene = e.input == "retry" and GameScene(self.retry_mode, self.retry_ruleset, self.secret_inputs) or ModeSelectScene()
 	elseif e.input == "retry" then
-		scene = GameScene(self.retry_mode, self.retry_ruleset)
+		scene = GameScene(self.retry_mode, self.retry_ruleset, self.secret_inputs)
 	elseif e.input == "pause" and not (self.game.game_over or self.game.completed) then
 		self.paused = not self.paused
 		if self.paused then pauseBGM()

scene/game_config.lua

@@ -16,6 +16,7 @@ ConfigScene.options = {
 	{"smooth_movement", "Smooth Piece Drop", false, {"On", "Off"}},
 	{"synchroes_allowed", "Synchroes", false, {"Per ruleset", "On", "Off"}},
 	{"diagonal_input", "Diagonal Input", false, {"On", "Off"}},
+	{"buffer_lock", "Buffer Lock Inputs", false, {"On", "Off"}},
 	{"sfx_volume", "SFX", true, "sfxSlider"},
 	{"bgm_volume", "BGM", true, "bgmSlider"},
 }
@@ -55,7 +56,7 @@ function ConfigScene:render()
 	--Lazy check to see if we're on the SFX or BGM slider. Probably will need to be rewritten if more options get added.
 	love.graphics.setColor(1, 1, 1, 0.5)
 	if not ConfigScene.options[self.highlight][3] then
-		love.graphics.rectangle("fill", 20, 98 + self.highlight * 20, 170, 22)
+		love.graphics.rectangle("fill", 25, 98 + self.highlight * 20, 170, 22)
 	else
 		love.graphics.rectangle("fill", 65 + (1+self.highlight-#self.options) * 300, 322, 215, 33)
 	end

scene/mode_select.lua

@@ -11,6 +11,14 @@ function ModeSelectScene:new()
 		ruleset = current_ruleset,
 		select = "mode",
 	}
+	self.secret_inputs = {
+		rotate_left = false,
+		rotate_left2 = false,
+		rotate_right = false,
+		rotate_right2 = false,
+		rotate_180 = false,
+		hold = false,
+	}
 	DiscordRPC:update({
 		details = "In menus",
 		state = "Choosing a mode",
@@ -67,7 +75,7 @@ function ModeSelectScene:onInputPress(e)
 		config.current_ruleset = current_ruleset
 		playSE("mode_decide")
 		saveConfig()
-		scene = GameScene(game_modes[self.menu_state.mode], rulesets[self.menu_state.ruleset])
+		scene = GameScene(game_modes[self.menu_state.mode], rulesets[self.menu_state.ruleset], self.secret_inputs)
 	elseif e.input == "up" or e.scancode == "up" then
 		self:changeOption(-1)
 		playSE("cursor")
@@ -79,6 +87,14 @@ function ModeSelectScene:onInputPress(e)
 		playSE("cursor_lr")
 	elseif e.input == "menu_back" or e.scancode == "delete" or e.scancode == "backspace" then
 		scene = TitleScene()
+	elseif e.input then
+		self.secret_inputs[e.input] = true
+	end
+end
+
+function ModeSelectScene:onInputRelease(e)
+	if e.input == "hold" or (e.input and string.sub(e.input, 1, 7) == "rotate_") then
+		self.secret_inputs[e.input] = false
 	end
 end
 

scene/title.lua

@@ -72,6 +72,7 @@ function TitleScene:render()
 	)
 	love.graphics.print("Happy Holidays!", 320, -100 + self.y_offset)
 
+	love.graphics.setColor(1, 1, 1, 1)
 	love.graphics.print(self.restart_message and "Restart Cambridge..." or "", 0, 0)
 
 	love.graphics.setColor(1, 1, 1, 0.5)
@@ -102,7 +103,7 @@ function TitleScene:onInputPress(e)
 	elseif e.input == "menu_back" or e.scancode == "backspace" or e.scancode == "delete" then
 		love.event.quit()
 	else
-		self.text = self.text .. e.scancode
+		self.text = self.text .. (e.scancode ~= nil and e.scancode or "")
 		if self.text == "ffffff" then
 			self.text_flag = true
 		end

tetris/components/grid.lua

@@ -114,6 +114,7 @@ function Grid:markClearedRows()
 					skin = self.grid[row][x].skin,
 					colour = "X"
 				}
+				self.grid_age[row][x] = 0
 			end
 		end
 	end
@@ -273,6 +274,43 @@ function Grid:checkSecretGrade()
 	return sgrade
 end
 
+function Grid:hasGemBlocks()
+	for y = 1, 24 do
+		for x = 1, 10 do
+			if self.grid[y][x].skin == "gem" then
+				return true
+			end
+		end
+	end
+	return false
+end
+
+function Grid:mirror()
+	local new_grid = {}
+	for y = 1, 24 do
+		new_grid[y] = {}
+		for x = 1, 10 do
+			new_grid[y][x] = empty
+		end
+	end
+
+	for y = 1, 24 do
+		for x = 1, 10 do
+			new_grid[y][x] = self.grid[y][11 - x]
+		end
+	end
+	self.grid = new_grid
+end
+
+function Grid:applyMap(map)
+	for y, row in pairs(map) do
+		for x, block in pairs(row) do
+			self.grid_age[y][x] = 0
+			self.grid[y][x] = block
+		end
+	end
+end
+
 function Grid:update()
 	for y = 1, 24 do
 		for x = 1, 10 do
@@ -293,18 +331,21 @@ function Grid:draw()
 				else
 					if self.grid[y][x].skin == "bone" then
 						love.graphics.setColor(1, 1, 1, 1)
+					elseif self.grid[y][x].colour == "X" then
+						love.graphics.setColor(0.5, 0.5, 0.5, 1 - self.grid_age[y][x] / 15)
 					else
 						love.graphics.setColor(0.5, 0.5, 0.5, 1)
 					end
 					love.graphics.draw(blocks[self.grid[y][x].skin][self.grid[y][x].colour], 48+x*16, y*16)
 				end
-				if self.grid[y][x].skin ~= "bone" then
+				if self.grid[y][x].skin ~= "bone" and self.grid[y][x].colour ~= "X" then
 					love.graphics.setColor(0.8, 0.8, 0.8, 1)
 					love.graphics.setLineWidth(1)
-					if y > 1 and self.grid[y-1][x] == empty then
+					if y > 1 and self.grid[y-1][x] == empty or self.grid[y-1][x].colour == "X" then
 						love.graphics.line(48.0+x*16, -0.5+y*16, 64.0+x*16, -0.5+y*16)
 					end
-					if y < 24 and self.grid[y+1][x] == empty then
+					if y < 24 and self.grid[y+1][x] == empty or
+					(y + 1 > 24 or self.grid[y+1][x].colour == "X") then
 						love.graphics.line(48.0+x*16, 16.5+y*16, 64.0+x*16, 16.5+y*16)
 					end
 					if x > 1 and self.grid[y][x-1] == empty then
@@ -322,13 +363,18 @@ end
 function Grid:drawOutline()
 	for y = 5, 24 do
 		for x = 1, 10 do
-			if self.grid[y][x] ~= empty then
+			if self.grid[y][x].colour == "X" then
+				love.graphics.setColor(0.5, 0.5, 0.5, 1 - self.grid_age[y][x] / 15)
+				love.graphics.draw(blocks[self.grid[y][x].skin][self.grid[y][x].colour], 48+x*16, y*16)
+			end
+			if self.grid[y][x] ~= empty and self.grid[y][x].colour ~= "X" then
 				love.graphics.setColor(0.8, 0.8, 0.8, 1)
 				love.graphics.setLineWidth(1)
-				if y > 1 and self.grid[y-1][x] == empty then
+				if y > 1 and self.grid[y-1][x] == empty or self.grid[y-1][x].colour == "X" then
 					love.graphics.line(48.0+x*16, -0.5+y*16, 64.0+x*16, -0.5+y*16)
 				end
-				if y < 24 and self.grid[y+1][x] == empty then
+				if y < 24 and self.grid[y+1][x] == empty or
+				(y + 1 > 24 or self.grid[y+1][x].colour == "X") then
 					love.graphics.line(48.0+x*16, 16.5+y*16, 64.0+x*16, 16.5+y*16)
 				end
 				if x > 1 and self.grid[y][x-1] == empty then
@@ -349,7 +395,7 @@ function Grid:drawInvisible(opacity_function, garbage_opacity_function, lock_fla
 		for x = 1, 10 do
 			if self.grid[y][x] ~= empty then
 				if self.grid[y][x].colour == "X" then
-					opacity = 1
+					opacity = 1 - self.grid_age[y][x] / 15
 				elseif garbage_opacity_function and self.grid[y][x].colour == "A" then
 					opacity = garbage_opacity_function(self.grid_age[y][x])
 				else
@@ -361,10 +407,11 @@ function Grid:drawInvisible(opacity_function, garbage_opacity_function, lock_fla
 					if opacity > 0 and self.grid[y][x].colour ~= "X" then
 						love.graphics.setColor(0.64, 0.64, 0.64)
 						love.graphics.setLineWidth(1)
-						if y > 1 and self.grid[y-1][x] == empty then
+						if y > 1 and self.grid[y-1][x] == empty or self.grid[y-1][x].colour == "X" then
 							love.graphics.line(48.0+x*16, -0.5+y*16, 64.0+x*16, -0.5+y*16)
 						end
-						if y < 24 and self.grid[y+1][x] == empty then
+						if y < 24 and self.grid[y+1][x] == empty or
+						(y + 1 > 24 or self.grid[y+1][x].colour == "X") then
 							love.graphics.line(48.0+x*16, 16.5+y*16, 64.0+x*16, 16.5+y*16)
 						end
 						if x > 1 and self.grid[y][x-1] == empty then
@@ -380,4 +427,45 @@ function Grid:drawInvisible(opacity_function, garbage_opacity_function, lock_fla
 	end
 end
 
+function Grid:drawCustom(colour_function, gamestate)
+    --[[
+        colour_function: (game, block, x, y, age) -> (R, G, B, A, outlineA)
+        When called, calls the supplied function on every block passing the block itself as argument
+        as well as coordinates and the grid_age value of the same cell.
+        Should return a RGBA colour for the block, as well as the opacity of the stack outline (0 for no outline).
+        
+        gamestate: the gamemode instance itself to pass in colour_function
+    ]]
+	for y = 5, 24 do
+		for x = 1, 10 do
+            local block = self.grid[y][x]
+			if block ~= empty then
+                local R, G, B, A, outline = colour_function(gamestate, block, x, y, self.grid_age[y][x])
+				if self.grid[y][x].colour == "X" then
+					A = 1 - self.grid_age[y][x] / 15
+				end
+				love.graphics.setColor(R, G, B, A)
+				love.graphics.draw(blocks[self.grid[y][x].skin][self.grid[y][x].colour], 48+x*16, y*16)
+                if outline > 0 and self.grid[y][x].colour ~= "X" then
+                    love.graphics.setColor(0.64, 0.64, 0.64, outline)
+                    love.graphics.setLineWidth(1)
+                    if y > 1 and self.grid[y-1][x] == empty or self.grid[y-1][x].colour == "X" then
+						love.graphics.line(48.0+x*16, -0.5+y*16, 64.0+x*16, -0.5+y*16)
+					end
+					if y < 24 and self.grid[y+1][x] == empty or
+					(y + 1 > 24 or self.grid[y+1][x].colour == "X") then
+						love.graphics.line(48.0+x*16, 16.5+y*16, 64.0+x*16, 16.5+y*16)
+					end
+					if x > 1 and self.grid[y][x-1] == empty then
+						love.graphics.line(47.5+x*16, -0.0+y*16, 47.5+x*16, 16.0+y*16)
+					end
+					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
+	end
+end
+
 return Grid

tetris/modes/gamemode.lua

@@ -5,13 +5,14 @@ local playedReadySE = false
 local playedGoSE = false
 
 local Grid = require 'tetris.components.grid'
-local Randomizer = require 'tetris.randomizers.randomizer'
+local Randomizer = require 'tetris.randomizers.bag7'
+local BagRandomizer = require 'tetris.randomizers.bag'
 
 local GameMode = Object:extend()
 
 GameMode.rollOpacityFunction = function(age) return 0 end
 
-function GameMode:new()
+function GameMode:new(secret_inputs)
 	self.grid = Grid()
 	self.randomizer = Randomizer()
 	self.piece = nil
@@ -56,6 +57,7 @@ function GameMode:new()
 	self.hard_drop_locked = false
 	self.lock_on_soft_drop = false
 	self.lock_on_hard_drop = false
+	self.used_randomizer = nil
 	self.hold_queue = nil
 	self.held = false
 	self.section_start_time = 0
@@ -72,17 +74,29 @@ function GameMode:getLineClearDelay() return 40 end
 function GameMode:getDasLimit() return 15 end
 
 function GameMode:getNextPiece(ruleset)
-	
 	return {
-		skin = "2tie",
+		skin = self:getSkin(),
-		shape = self.randomizer:nextPiece(),
+		shape = self.used_randomizer:nextPiece(),
 		orientation = ruleset:getDefaultOrientation(),
 	}
 end
 
-function GameMode:initialize(ruleset)
+function GameMode:getSkin()
+	return "2tie"
+end
+
+function GameMode:initialize(ruleset, secret_inputs)
 	-- generate next queue
-	self:new()
+	self:new(secret_inputs)
+	self.used_randomizer = (
+		ruleset.pieces == self.randomizer.possible_pieces and
+		self.randomizer or
+		(
+			ruleset.pieces == 7 and
+			Randomizer() or
+			BagRandomizer(ruleset.pieces)
+		)
+	)
 	for i = 1, self.next_queue_length do
 		table.insert(self.next_queue, self:getNextPiece(ruleset))
 	end
@@ -162,6 +176,7 @@ function GameMode:update(inputs, ruleset)
 			not self.hard_drop_locked then
 			self:onHardDrop(piece_dy)
 			if self.lock_on_hard_drop then
+				self.piece_hard_dropped = true
 				self.piece.locked = true
 			end
 		end
@@ -193,7 +208,9 @@ function GameMode:update(inputs, ruleset)
 			if cleared_row_count > 0 then
 				playSE("erase")
 				self.lcd = self:getLineClearDelay()
-				self.are = self:getLineARE()
+				self.are = (
+					ruleset.are and self:getLineARE() or 0
+				)
 				if self.lcd == 0 then
 					self.grid:clearClearedRows()
 					if self.are == 0 then
@@ -202,7 +219,7 @@ function GameMode:update(inputs, ruleset)
 				end
 				self:onLineClear(cleared_row_count)
 			else
-				if self:getARE() == 0 then
+				if self:getARE() == 0 or not ruleset.are then
 					self:initializeOrHold(inputs, ruleset)
 				else
 					self.are = self:getARE()
@@ -311,12 +328,27 @@ function GameMode:chargeDAS(inputs)
 	end
 end
 
+function GameMode:areCancel(inputs, ruleset)
+	if ruleset.are_cancel and self.piece_hard_dropped and
+	not self.prev_inputs.up and
+	strTrueValues(inputs) ~= "" then
+		self.lcd = 0
+		self.are = 0
+	end
+end
+
 function GameMode:processDelays(inputs, ruleset, drop_speed)
 	if self.ready_frames == 100 then
 		playedReadySE = false
 		playedGoSE = false
 	end
 	if self.ready_frames > 0 then
+		if not self.prev_inputs["up"] and inputs["up"] and self.enable_hard_drop then
+			self.buffer_hard_drop = true
+		end
+		if not self.prev_inputs["down"] and inputs["down"] then
+			self.buffer_soft_drop = true
+		end
 		if not playedReadySE then
 			playedReadySE = true
 			playSEOnce("ready")
@@ -330,19 +362,14 @@ function GameMode:processDelays(inputs, ruleset, drop_speed)
 			self:initializeOrHold(inputs, ruleset)
 		end
 	elseif self.lcd > 0 then
-		self.lcd = self.lcd - 1
+		if not self.prev_inputs["up"] and inputs["up"] and self.enable_hard_drop then
-		if ruleset.are_cancel and
+			self.buffer_hard_drop = true
-			(self.move == "none" and not self.prev_inputs["up"] and
-			not self.prev_inputs["rotate_left"] and not self.prev_inputs["rotate_left2"] and
-			not self.prev_inputs["rotate_right"] and not self.prev_inputs["rotate_right2"] and
-			not self.prev_inputs["rotate_180"]) and
-			(inputs["left"] or inputs["right"] or inputs["up"] or
-			inputs["rotate_left"] or inputs["rotate_left2"] or
-			inputs["rotate_right"] or inputs["rotate_right2"] or
-			inputs["rotate_180"]) then
-			self.lcd = 0
-			self.are = 0
 		end
+		if not self.prev_inputs["down"] and inputs["down"] then
+			self.buffer_soft_drop = true
+		end
+		self.lcd = self.lcd - 1
+		self:areCancel(inputs, ruleset)
 		if self.lcd == 0 then
 			self.grid:clearClearedRows()
 			playSE("fall")
@@ -351,18 +378,14 @@ function GameMode:processDelays(inputs, ruleset, drop_speed)
 			end
 		end
 	elseif self.are > 0 then
-		self.are = self.are - 1
+		if not self.prev_inputs["up"] and inputs["up"] and self.enable_hard_drop then
-		if ruleset.are_cancel and
+			self.buffer_hard_drop = true
-			(self.move == "none" and not self.prev_inputs["up"] and
-			not self.prev_inputs["rotate_left"] and not self.prev_inputs["rotate_left2"] and
-			not self.prev_inputs["rotate_right"] and not self.prev_inputs["rotate_right2"] and
-			not self.prev_inputs["rotate_180"]) and
-			(inputs["left"] or inputs["right"] or inputs["up"] or
-			inputs["rotate_left"] or inputs["rotate_left2"] or
-			inputs["rotate_right"] or inputs["rotate_right2"] or
-			inputs["rotate_180"]) then
-			self.are = 0
 		end
+		if not self.prev_inputs["down"] and inputs["down"] then
+			self.buffer_soft_drop = true
+		end
+		self.are = self.are - 1
+		self:areCancel(inputs, ruleset)
 		if self.are == 0 then
 			self:initializeOrHold(inputs, ruleset)
 		end
@@ -407,14 +430,31 @@ function GameMode:hold(inputs, ruleset, ihs)
 end
 
 function GameMode:initializeNextPiece(inputs, ruleset, piece_data, generate_next_piece)
+	self.piece_hard_dropped = false
 	local gravity = self:getGravity()
 	self.piece = ruleset:initializePiece(
 		inputs, piece_data, self.grid, gravity,
 		self.prev_inputs, self.move,
 		self:getLockDelay(), self:getDropSpeed(),
 		self.lock_drop, self.lock_hard_drop, self.big_mode,
-		self.irs
+		self.irs, self.buffer_hard_drop, self.buffer_soft_drop,
+		self.lock_on_hard_drop, self.lock_on_soft_drop
 	)
+	if self.piece:isDropBlocked(self.grid) and
+	   self.grid:canPlacePiece(self.piece) then
+		playSE("bottom")
+	end
+	if self.buffer_hard_drop then
+		self.buffer_hard_drop = false
+		self:onHardDrop(self.piece.position.y - (
+			self.big_mode and
+			ruleset.big_spawn_positions[self.piece.shape].y or
+			ruleset.spawn_positions[self.piece.shape].y)
+		)
+	end
+	if self.buffer_soft_drop then
+		self.buffer_soft_drop = false
+	end
 	if self.lock_drop then
 		self.drop_locked = true
 	end
@@ -425,11 +465,11 @@ function GameMode:initializeNextPiece(inputs, ruleset, piece_data, generate_next
 		table.remove(self.next_queue, 1)
 		table.insert(self.next_queue, self:getNextPiece(ruleset))
 	end
-	self:playNextSound()
+	self:playNextSound(ruleset)
 end
 
-function GameMode:playNextSound()
+function GameMode:playNextSound(ruleset)
-	playSE("blocks", self.next_queue[1].shape)
+	playSE("blocks", ruleset.next_sounds[self.next_queue[1].shape])
 end
 
 function GameMode:getHighScoreData()

tetris/modes/phantom_mania2.lua

@@ -86,12 +86,8 @@ function PhantomMania2Game:getGarbageLimit()
 	else return 8 end
 end
 
-function PhantomMania2Game:getNextPiece(ruleset)
+function PhantomMania2Game:getSkin()
-	return {
+	return self.level >= 1000 and "bone" or "2tie"
-		skin = self.level >= 1000 and "bone" or "2tie",
-		shape = self.randomizer:nextPiece(),
-		orientation = ruleset:getDefaultOrientation(),
-	}
 end
 
 function PhantomMania2Game:hitTorikan(old_level, new_level)

tetris/modes/sakura.lua

@@ -0,0 +1,583 @@
+require 'funcs'
+
+local GameMode = require 'tetris.modes.gamemode'
+local Piece = require 'tetris.components.piece'
+
+local SakuraRandomizer = require 'tetris.randomizers.sakura'
+local History6RollsRandomizer = require 'tetris.randomizers.history_6rolls_35bag'
+
+local SakuraGame = GameMode:extend()
+
+SakuraGame.name = "Sakura A3"
+SakuraGame.hash = "SakuraA3"
+SakuraGame.tagline = "Clear away the Gem Blocks as fast as possible!"
+
+local b = {
+    ["r"] = { skin = "2tie", colour = "R" },
+    ["o"] = { skin = "2tie", colour = "O" },
+    ["y"] = { skin = "2tie", colour = "Y" },
+    ["g"] = { skin = "2tie", colour = "G" },
+    ["c"] = { skin = "2tie", colour = "C" },
+    ["b"] = { skin = "2tie", colour = "B" },
+    ["m"] = { skin = "2tie", colour = "M" },
+    ["R"] = { skin = "gem", colour = "R" },
+    ["O"] = { skin = "gem", colour = "O" },
+    ["Y"] = { skin = "gem", colour = "Y" },
+    ["G"] = { skin = "gem", colour = "G" },
+    ["C"] = { skin = "gem", colour = "C" },
+    ["B"] = { skin = "gem", colour = "B" },
+    ["M"] = { skin = "gem", colour = "M" },
+}
+
+local effects = {
+    [4] = "mirror",
+    [8] = "xray",
+    [12] = "color",
+    [13] = "mirror",
+    [16] = "roll",
+    [23] = "big"
+}
+
+local maps = {
+    [1] = {
+        [22] = {nil, nil, b.O, b.R, nil, nil, b.M, b.m, nil, nil},
+        [23] = {nil, b.G, b.c, b.c, b.c, b.c, b.c, b.c, b.Y, nil},
+        [24] = {nil, b.C, b.y, b.y, b.y, b.y, b.y, b.y, b.B, nil},
+    },
+    [2] = {
+        [20] = {nil, nil, nil, nil, b.G, b.b, b.b, b.M, nil, nil},
+        [21] = {nil, nil, nil, nil, b.c, b.c, b.c, b.c, nil, nil},
+        [22] = {nil, nil, nil, nil, nil, b.R, b.Y, b.O, nil, nil},
+        [23] = {nil, b.B, b.c, b.c, b.c, b.c, b.c, b.c, b.c, nil},
+        [24] = {nil, b.b, b.b, b.b, b.b, b.b, b.b, b.b, b.C, nil},
+    },
+    [3] = {
+        [20] = {nil, nil, nil, b.R, b.m, b.o, b.M, nil, nil, nil},
+        [21] = {nil, nil, nil, nil, b.o, b.O, nil, nil, nil, nil},
+        [22] = {nil, nil, nil, nil, b.G, b.Y, nil, nil, nil, nil},
+        [23] = {nil, b.m, b.o, b.m, b.o, b.m, b.o, b.m, b.o, nil},
+        [24] = {nil, b.B, b.m, b.o, b.m, b.o, b.m, b.o, b.C, nil},
+    },
+    [4] = {
+        [21] = {nil, nil, b.O, b.g, b.g, b.g, b.g, nil, nil, nil},
+        [22] = {nil, nil, nil, b.R, b.M, b.b, b.b, nil, nil, nil},
+        [23] = {b.G, nil, b.Y, b.g, b.g, b.g, b.g, b.g, nil, nil},
+        [24] = {b.b, b.C, b.b, b.b, b.b, b.b, b.b, b.b, b.B, nil},
+    },
+    [5] = {
+        [16] = {nil, b.B, b.c, b.y, b.c, b.G, b.c, b.y, b.C, nil},
+        [22] = {nil, nil, b.c, b.y, b.c, b.y, b.c, b.y, nil, nil},
+        [23] = {nil, b.O, b.y, b.c, b.y, b.c, b.y, b.c, b.Y, nil},
+        [24] = {nil, b.R, b.c, b.y, b.c, b.y, b.c, b.y, b.M, nil},
+    },
+    [6] = {
+        [21] = {nil, nil, nil, nil, b.O, b.Y, nil, nil, nil, nil},
+        [22] = {nil, nil, b.R, nil, b.b, b.y, nil, b.M, nil, nil},
+        [23] = {nil, nil, nil, nil, b.y, b.b, nil, nil, nil, nil},
+        [24] = {nil, b.G, b.y, b.b, b.C, b.y, b.b, b.y, b.B, nil},
+    },
+    [7] = {
+        [20] = {nil, b.C, b.G, nil, b.r, b.g, b.r, b.g, nil, nil},
+        [21] = {nil, nil, nil, nil, b.R, b.M, b.g, b.r, nil, nil},
+        [22] = {b.r, nil, nil, nil, b.r, b.g, b.O, b.Y, nil, nil},
+        [23] = {b.g, b.r, b.g, b.r, b.g, b.r, b.g, b.r, nil, nil},
+        [24] = {b.r, b.g, b.r, b.g, b.r, b.g, b.r, b.g, b.B, nil},
+    },
+    [8] = {
+        [15] = {nil, nil, nil, b.B, b.m, b.m, b.m, b.m, b.m, b.C},
+        [16] = {nil, nil, nil, nil, nil, nil, nil, nil, nil, b.m},
+        [17] = {nil, nil, nil, nil, nil, nil, nil, nil, nil, b.m},
+        [18] = {nil, b.Y, b.y, b.y, b.y, b.y, b.y, b.y, b.y, b.G},
+        [21] = {b.b, b.b, b.b, b.b, b.b, b.b, b.O, nil, nil, nil},
+        [22] = {b.b, nil, nil, nil, nil, nil, nil, nil, nil, nil},
+        [23] = {b.M, nil, nil, nil, nil, nil, nil, nil, nil, nil},
+        [24] = {b.o, b.o, b.o, b.o, b.o, b.o, b.o, b.o, b.R, nil},
+    },
+    [9] = {
+        [18] = {nil, nil, nil, b.Y, b.m, b.m, b.m, b.m, nil, nil},
+        [19] = {nil, nil, nil, b.c, b.c, b.c, b.c, b.G, nil, nil},
+        [20] = {b.m, b.m, b.m, b.O, b.M, b.R, nil, nil, nil, nil},
+        [21] = {b.c, b.c, b.c, b.c, b.c, b.c, b.c, b.c, nil, nil},
+        [22] = {b.m, b.m, b.m, b.m, b.m, b.m, b.m, b.m, nil, nil},
+        [23] = {b.c, b.c, b.c, b.c, b.c, b.c, b.c, b.c, b.C, nil},
+        [24] = {b.m, b.m, b.m, b.m, b.m, b.m, b.m, b.m, b.B, nil},
+    },
+    [10] = {
+        [18] = {nil, nil, nil, b.C, b.g, b.g, b.B, nil, nil, nil},
+        [19] = {nil, nil, b.G, b.g, b.g, b.g, b.g, b.Y, nil, nil},
+        [20] = {nil, b.M, b.g, b.g, b.g, b.g, b.g, b.g, b.O, nil},
+        [21] = {nil, nil, nil, nil, b.c, nil, nil, nil, nil, nil},
+        [22] = {nil, nil, nil, nil, b.c, nil, nil, nil, nil, nil},
+        [23] = {nil, nil, nil, nil, b.c, nil, b.o, nil, nil, nil},
+        [24] = {nil, nil, nil, nil, b.R, b.o, b.o, nil, nil, nil},
+    },
+    [11] = {
+        [18] = {nil, nil, nil, nil, b.o, b.o, nil, nil, nil, nil},
+        [19] = {nil, nil, nil, nil, b.R, nil, nil, nil, nil, nil},
+        [20] = {nil, nil, nil, nil, b.r, b.O, nil, nil, nil, nil},
+        [21] = {nil, nil, nil, nil, nil, b.M, nil, nil, nil, nil},
+        [22] = {nil, nil, nil, nil, b.o, b.o, nil, nil, nil, nil},
+        [23] = {nil, nil, nil, nil, b.G, b.Y, nil, nil, nil, nil},
+        [24] = {b.C, b.g, b.g, nil, b.o, b.o, nil, b.g, b.g, b.B},
+    },
+    [12] = {
+        [21] = {nil, nil, nil, nil, nil, nil, nil, b.g, b.g, b.Y},
+        [22] = {nil, nil, b.r, b.G, b.r, nil, nil, nil, b.O, b.g},
+        [23] = {nil, b.r, b.C, b.r, b.B, b.r, nil, nil, nil, b.M},
+        [24] = {b.r, b.r, b.r, b.R, b.r, b.r, b.r, nil, nil, nil},
+    },
+    [13] = {
+        [20] = {b.c, nil, nil, nil, nil, nil, nil, nil, nil, b.B},
+        [21] = {b.c, b.c, nil, nil, nil, nil, nil, nil, b.C, b.c},
+        [22] = {b.c, b.c, b.c, nil, nil, nil, nil, b.G, b.c, b.c},
+        [23] = {b.b, b.b, b.b, b.b, nil, nil, b.Y, b.b, b.b, b.b},
+        [24] = {nil, b.M, b.b, b.b, b.b, b.O, b.b, b.b, b.R, nil},
+    },
+    [14] = {
+        [20] = {nil, nil, nil, b.y, b.r, b.y, nil, nil, nil, nil},
+        [21] = {b.R, nil, nil, b.Y, b.y, b.r, b.G, nil, nil, nil},
+        [22] = {nil, nil, nil, b.y, b.r, b.y, b.r, b.y, b.r, b.B},
+        [23] = {nil, nil, nil, nil, nil, nil, nil, b.O, b.y, b.r},
+        [24] = {nil, nil, nil, nil, nil, nil, b.M, b.y, b.r, b.C},
+    },
+    [15] = {
+        [17] = {nil, nil, b.b, nil, nil, nil, nil, b.b, nil, nil},
+        [18] = {nil, nil, b.b, b.y, b.b, b.b, b.y, b.b, nil, nil},
+        [19] = {nil, nil, nil, b.y, b.b, b.b, b.y, nil, nil, nil},
+        [20] = {nil, nil, nil, nil, b.O, b.Y, nil, nil, nil, nil},
+        [22] = {nil, nil, nil, nil, b.M, b.R, nil, nil, nil, nil},
+        [23] = {nil, nil, nil, b.G, b.y, b.y, b.C, nil, nil, nil},
+        [24] = {nil, nil, b.B, b.y, b.y, b.y, b.y, b.y, nil, nil},
+    },
+    [16] = {
+        [18] = {nil, nil, b.O, nil, nil, nil, nil, b.B, nil, nil},
+        [19] = {nil, nil, b.c, nil, nil, b.G, nil, b.c, nil, nil},
+        [20] = {nil, nil, b.c, nil, b.C, b.R, nil, b.c, nil, nil},
+        [21] = {nil, nil, b.c, nil, nil, nil, nil, b.c, nil, nil},
+        [22] = {nil, nil, b.Y, b.c, b.c, b.c, b.c, b.M, nil, nil},
+    },
+    [17] = {
+        [15] = {b.O, nil, nil, b.g, nil, nil, b.m, nil, nil, b.Y},
+        [16] = {nil, nil, nil, b.g, nil, nil, b.m, nil, nil, nil},
+        [17] = {nil, nil, nil, b.g, nil, nil, b.R, nil, nil, nil},
+        [18] = {nil, nil, nil, b.g, nil, nil, b.m, nil, nil, nil},
+        [19] = {nil, nil, nil, b.M, nil, nil, b.m, nil, nil, nil},
+        [20] = {nil, nil, nil, b.g, nil, nil, b.m, nil, nil, nil},
+        [21] = {nil, nil, nil, b.g, nil, nil, b.G, nil, nil, nil},
+        [22] = {nil, nil, nil, b.g, nil, nil, b.m, nil, nil, nil},
+        [23] = {nil, nil, nil, b.g, nil, nil, b.m, nil, nil, nil},
+        [24] = {nil, b.m, b.m, b.m, b.B, b.C, b.g, b.g, b.g, nil},
+    },
+    [18] = {
+        [19] = {nil, nil, nil, b.y, b.B, b.y, b.y, nil, nil, nil},
+        [20] = {nil, nil, b.y, nil, nil, nil, nil, b.y, nil, nil},
+        [21] = {nil, b.o, nil, nil, b.C, b.R, nil, nil, b.O, nil},
+        [22] = {nil, b.M, nil, nil, b.Y, b.G, nil, nil, b.o, nil},
+        [23] = {nil, b.r, b.o, nil, nil, nil, nil, b.o, b.r, nil},
+        [24] = {nil, b.r, b.r, b.o, b.o, b.o, b.o, b.r, b.r, nil},
+    },
+    [19] = {
+        [15] = {nil, nil, nil, nil, nil, nil, b.O, nil, nil, nil},
+        [16] = {nil, nil, nil, nil, nil, b.o, nil, nil, nil, nil},
+        [17] = {nil, nil, nil, nil, b.o, b.r, b.o, nil, nil, nil},
+        [18] = {nil, b.o, nil, nil, b.o, b.r, b.r, b.o, nil, nil},
+        [19] = {nil, b.o, b.o, nil, nil, b.R, b.r, b.r, nil, nil},
+        [20] = {nil, nil, b.M, b.r, nil, b.r, b.r, b.r, b.r, nil},
+        [21] = {nil, nil, b.r, b.r, b.r, b.r, b.y, b.G, b.o, b.o},
+        [22] = {nil, b.r, b.o, b.y, b.Y, b.y, b.y, b.y, b.y, b.o},
+        [23] = {nil, b.o, b.o, b.y, b.y, b.c, b.c, b.c, b.c, b.C},
+        [24] = {nil, nil, b.o, b.y, b.b, b.b, b.B, b.b, b.b, b.b},
+    },
+    [20] = {
+        [20] = {nil, nil, b.B, b.b, b.b, b.b, b.b, b.b, nil, nil},
+        [21] = {b.c, nil, nil, b.C, b.c, b.c, b.c, nil, nil, b.c},
+        [22] = {b.g, b.g, nil, nil, b.G, b.g, nil, nil, b.g, b.g},
+        [23] = {b.y, b.y, b.o, nil, nil, nil, nil, b.Y, b.y, b.y},
+        [24] = {b.r, b.r, b.r, b.R, nil, nil, b.M, b.r, b.r, b.r},
+    },
+    [21] = {
+        [16] = {nil, nil, b.g, b.g, b.g, b.g, b.g, nil, nil, nil},
+        [17] = {nil, b.g, b.g, b.g, b.g, b.g, b.g, b.B, b.g, nil},
+        [18] = {b.g, b.g, b.g, b.g, b.g, b.g, b.g, b.g, b.C, nil},
+        [19] = {b.g, nil, nil, b.g, b.o, b.o, b.g, nil, nil, b.g},
+        [20] = {nil, b.R, nil, b.g, b.o, b.o, nil, b.M, nil, b.G},
+        [21] = {nil, nil, nil, nil, b.o, b.o, nil, nil, nil, nil},
+        [22] = {nil, nil, nil, nil, b.o, b.o, nil, nil, nil, nil},
+        [23] = {nil, nil, nil, nil, b.o, b.o, nil, nil, nil, nil},
+        [24] = {nil, nil, nil, nil, b.Y, b.O, nil, nil, nil, nil},
+    },
+    [22] = {
+        [15] = {nil, nil, b.b, nil, nil, nil, nil, b.b, nil, nil},
+        [16] = {nil, b.b, b.O, b.b, nil, nil, b.b, b.Y, b.b, nil},
+        [17] = {nil, nil, b.b, nil, nil, nil, nil, b.b, nil, nil},
+        [20] = {nil, nil, nil, nil, b.R, b.M, nil, nil, nil, nil},
+        [23] = {nil, nil, nil, b.b, b.C, b.G, b.b, nil, nil, nil},
+        [24] = {nil, nil, nil, b.b, b.b, b.B, b.b, nil, nil, nil},
+    },
+    [23] = {
+        [13] = {nil, nil, nil, nil, nil, nil, nil, nil, b.c, b.m},
+        [14] = {nil, nil, nil, nil, nil, nil, nil, nil, b.y, b.g},
+        [15] = {b.G, b.B, nil, nil, nil, nil, nil, nil, nil, nil},
+        [16] = {b.r, b.O, nil, nil, nil, nil, nil, nil, nil, nil},
+        [23] = {nil, nil, nil, nil, b.C, b.M, nil, nil, nil, nil},
+        [24] = {nil, nil, nil, nil, b.R, b.Y, nil, nil, nil, nil},
+    },
+    [24] = {
+        [20] = {b.g, b.g, b.g, b.g, b.G, nil, nil, nil, nil, nil},
+        [21] = {nil, nil, nil, nil, nil, b.O, b.y, b.y, b.y, b.Y},
+        [23] = {b.M, b.r, b.r, b.r, b.R, nil, nil, nil, nil, nil},
+        [24] = {nil, nil, nil, nil, nil, b.M, b.r, b.r, b.r, b.R},
+    },
+    [25] = {
+        [18] = {nil, nil, nil, nil, nil, b.B, nil, nil, nil, nil},
+        [19] = {nil, nil, nil, b.G, nil, nil, nil, b.C, nil, nil},
+        [20] = {nil, nil, nil, nil, nil, b.Y, nil, nil, nil, nil},
+        [21] = {nil, nil, nil, b.M, nil, nil, nil, b.O, nil, nil},
+        [22] = {nil, nil, nil, nil, nil, b.R, nil, nil, nil, nil},
+    },
+    [26] = {
+        [13] = {nil, nil, nil, nil, b.r, b.r, nil, nil, nil, nil},
+        [14] = {nil, nil, nil, nil, b.o, b.o, nil, nil, nil, nil},
+        [15] = {nil, nil, nil, nil, b.o, b.o, nil, nil, nil, nil},
+        [16] = {nil, nil, nil, nil, b.o, b.o, nil, nil, nil, nil},
+        [17] = {nil, nil, nil, b.O, b.o, b.o, b.Y, nil, nil, nil},
+        [18] = {nil, nil, b.o, b.c, b.c, b.c, b.c, b.o, nil, nil},
+        [19] = {nil, nil, b.o, b.c, b.c, b.c, b.c, b.o, nil, nil},
+        [20] = {nil, nil, b.o, nil, nil, b.G, nil, b.o, nil, nil},
+        [21] = {nil, nil, b.o, nil, b.M, b.R, nil, b.o, nil, nil},
+        [22] = {nil, nil, b.o, b.b, b.b, b.b, b.B, b.o, nil, nil},
+        [23] = {nil, nil, b.o, b.C, b.b, b.b, b.b, b.o, nil, nil},
+        [24] = {nil, nil, b.o, b.o, b.o, b.o, b.o, b.o, nil, nil},
+    },
+    [27] = {
+        [15] = {nil, b.C, b.o, b.g, b.g, b.g, b.g, b.g, b.B, nil},
+        [16] = {b.g, nil, b.y, b.o, b.g, b.g, b.g, b.g, nil, b.y},
+        [17] = {b.g, b.g, nil, b.y, b.o, b.g, b.g, nil, b.y, b.o},
+        [18] = {b.g, b.g, b.g, nil, b.y, b.o, nil, b.y, b.o, b.g},
+        [19] = {b.g, b.g, b.g, b.o, nil, b.G, b.y, b.o, b.g, b.g},
+        [20] = {b.g, b.g, b.o, b.o, b.Y, nil, b.o, b.g, b.g, b.g},
+        [21] = {b.g, b.o, b.y, nil, b.o, b.O, nil, b.g, b.g, b.g},
+        [22] = {b.o, b.y, nil, b.g, b.g, b.o, b.y, nil, b.g, b.g},
+        [23] = {b.y, nil, b.g, b.g, b.g, b.g, b.o, b.y, nil, b.g},
+        [24] = {nil, b.M, b.g, b.g, b.g, b.g, b.g, b.o, b.R, nil},
+    },
+}
+
+local STAGE_TRANSITION_TIME = 300
+
+function SakuraGame:new(secret_inputs)
+    self.super:new()
+
+    self.randomizer = (
+        (
+            secret_inputs.rotate_left and secret_inputs.rotate_right
+        ) and History6RollsRandomizer() or SakuraRandomizer()
+    )
+    
+    self.current_map = 1
+    self.time_limit = 10800
+    self.cleared_frames = STAGE_TRANSITION_TIME
+    self.stage_frames = 0
+    self.time_extend = 0
+    self.maps_cleared = 0
+    self.map_20_time = 0
+    self.stage_pieces = 0
+    self.grid:applyMap(maps[self.current_map])
+    
+    self.lock_drop = true
+    self.lock_hard_drop = true
+    self.enable_hold = true
+    self.next_queue_length = 3
+end
+
+function SakuraGame:checkRequirements()
+    if self.maps_cleared >= 14 + 2 * (self.current_map - 20) and
+    self.map_20_time <= frameTime(8,00) - frameTime(0,30) * (self.current_map - 20)
+    then 
+        return false
+    end
+    return true
+end
+
+function SakuraGame:getGravity()
+    if self.level < 8   then return 4/256
+elseif self.level < 19  then return 5/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 < 108 then return 4/256
+elseif self.level < 119 then return 5/256
+elseif self.level < 125 then return 6/256
+elseif self.level < 131 then return 8/256
+elseif self.level < 139 then return 12/256
+elseif self.level < 149 then return 32/256
+elseif self.level < 156 then return 48/256
+elseif self.level < 164 then return 80/256
+elseif self.level < 174 then return 112/256
+elseif self.level < 180 then return 128/256
+elseif self.level < 200 then return 144/256
+elseif self.level < 212 then return 16/256
+elseif self.level < 221 then return 48/256
+elseif self.level < 232 then return 80/256
+elseif self.level < 244 then return 112/256
+elseif self.level < 256 then return 144/256
+elseif self.level < 267 then return 176/256
+elseif self.level < 277 then return 192/256
+elseif self.level < 287 then return 208/256
+elseif self.level < 295 then return 224/256
+elseif self.level < 300 then return 240/256
+else return 20 end
+end
+
+function SakuraGame:onLineClear(cleared_row_count)
+    self.level = self.level + cleared_row_count
+    for i = 13, 24 do
+        for j = 1, 10 do
+            local block = self.grid.grid[i][j]
+            if block and block.skin == "gem" and block.colour == "X" then
+                self.time_limit = self.time_limit + 60
+            end
+        end
+    end
+end
+
+function SakuraGame:onPieceEnter()
+    if self.level % 100 ~= 99 and not self.clear and self.stage_frames ~= 0 then
+		self.level = self.level + 1
+	end
+    if effects[self.current_map] == "mirror" and
+       self.stage_pieces % 3 == 0 and self.stage_pieces ~= 0
+       then
+        self.grid:mirror()
+    end
+    self.stage_pieces = self.stage_pieces + 1
+end
+
+function SakuraGame:advanceOneFrame(inputs, ruleset)
+    if self.ready_frames == 0 then
+        if self.lcd > 0 then
+                if self.stage_frames <= frameTime(0,10) then self.time_extend = 600
+            elseif self.stage_frames <= frameTime(0,30) then self.time_extend = 300
+            else self.time_extend = 0 end
+        end
+
+        if not self.grid:hasGemBlocks() or
+        (self.stage_frames >= 3600 and self.current_map <= 20) then
+            self.lcd = 0
+            self.are = 0
+            if self.stage_frames >= 3600 then self.time_extend = 0 end
+            self.piece = nil
+
+            -- transition to next map
+            if self.cleared_frames > 0 then
+                self.cleared_frames = self.cleared_frames - 1
+                if self.time_extend > 0 then
+                    self.time_limit = self.time_limit + 3
+                    self.time_extend = self.time_extend - 3
+                end
+                return false
+            end
+            
+            self.hold_queue = nil
+            if self.current_map > 20 or (self.stage_frames < 3600 and self.current_map <= 20) then self.maps_cleared = self.maps_cleared + 1 end
+            self.stage_frames = -1
+            self.level = 0
+            self.grid:clear()
+            if (self.current_map == 20) then self.map_20_time = self.frames end
+            if self.current_map >= 20 and self:checkRequirements() then
+                self.clear = true
+                self.completed = true
+                return false
+            else
+                self.current_map = self.current_map + 1
+                self.big_mode = effects[self.current_map] == "big"
+                self.ready_frames = 100
+                self.stage_pieces = 0
+                self.grid:applyMap(maps[self.current_map])
+            end
+            
+            -- this is necessary to fix timer
+            self.frames = self.frames - 1
+            self.time_limit = self.time_limit + 1
+        end
+        
+        self.frames = self.frames + 1
+        self.stage_frames = self.stage_frames + 1
+        self.time_limit = math.max(self.time_limit - 1, 0)
+        if self.time_limit <= 0 and self.piece == nil then
+            self.game_over = true
+        end
+
+        if self.piece ~= nil and
+           effects[self.current_map] == "roll" and
+           self.stage_pieces % 4 == 0
+           then
+            self.piece.colour = "F"
+            if self.stage_frames % 30 == 0 then
+                ruleset:attemptRotate(
+                    {[config.gamesettings.world_reverse == 3 or
+                    (ruleset.world and config.gamesettings.world_reverse == 2)
+                    and "rotate_left" or "rotate_right"] = true},
+                    self.piece, self.grid, false
+                )
+            end
+        end
+    else
+        self.cleared_frames = STAGE_TRANSITION_TIME
+        if not self.prev_inputs.hold and inputs.hold then
+            self.hold_queue = table.remove(self.next_queue, 1)
+            table.insert(self.next_queue, self:getNextPiece(ruleset))
+        end
+    end
+    return true
+end
+
+local function colourXRay(game, block, x, y, age)
+    local r, g, b, a = .5,.5,.5
+    if ((game.stage_frames/2 - x) % 30 < 1)
+    or game.stage_frames == 0
+    or game.cleared_frames ~= STAGE_TRANSITION_TIME
+    or game.stage_pieces % 2 == 0
+    then
+        a = 1
+    else
+        a = 1 - age / 4
+    end
+    return r, g, b, a, a
+end
+
+local function colourColor(game, block, x, y, age)
+    local r, g, b, a = .5,.5,.5
+    if game.stage_frames == 0 or game.cleared_frames ~= STAGE_TRANSITION_TIME then
+        a = 1
+    else
+        a = (game.stage_frames/30 + (y + math.abs(x-5.5))/5) % 1
+    end
+    return r, g, b, a, 0
+end
+
+function SakuraGame:drawGrid()
+    if effects[self.current_map] == "xray" then
+        self.grid:drawCustom(colourXRay, self)
+	elseif effects[self.current_map] == "color" then
+        self.grid:drawCustom(colourColor, self)
+	else
+        self.grid:draw()
+        -- if self.piece ~= nil and self.level < 100 then
+            self:drawGhostPiece(ruleset)
+        -- end
+	end
+end
+
+function SakuraGame: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("STAGE", 240, 120, 80, "left")
+    love.graphics.printf("TIME LIMIT", 240, 180, 80, "left")
+    love.graphics.printf("LEVEL", 240, 320, 40, "left")
+    if self.current_map <= 20 then
+        love.graphics.printf("STAGE LIMIT", 240, 240, 100, "left")
+    end
+    if effects[self.current_map] then
+        love.graphics.printf("EFFECT: " .. effects[self.current_map], 240, 300, 160, "left")
+    end
+    if self.randomizer.history then
+        love.graphics.printf("RANDOM PIECES ACTIVE!", 240, 150, 200, "left")
+    end
+
+    love.graphics.setFont(font_3x5_3)
+    love.graphics.setColor(
+        (self.time_limit % 4 < 2 and
+        self.time_limit <= frameTime(0,10) and
+        self.grid:hasGemBlocks() and
+        self.time_limit ~= 0 and
+        self.ready_frames == 0) and
+        { 1, 0.3, 0.3, 1 } or
+        { 1, 1, 1, 1 }
+    )
+    love.graphics.printf(formatTime(self.time_limit), 240, 200, 120, "left")
+    love.graphics.setColor(1, 1, 1, 1)
+    if self.current_map <= 20 then
+        love.graphics.printf(formatTime(3600 - self.stage_frames), 240, 260, 120, "left")
+    end
+    love.graphics.printf(self.level, 240, 340, 40, "right")
+	love.graphics.printf(math.floor((self.level + 100) / 100) * 100, 240, 370, 40, "right")
+
+    love.graphics.setFont(font_8x11)
+    love.graphics.printf(formatTime(self.frames), 64, 420, 160, "center")
+    love.graphics.printf(self.current_map, 290, 110, 80, "left")
+end
+
+function SakuraGame:drawCustom()
+    love.graphics.setColor(1, 1, 1, 1)
+
+    if self.ready_frames ~= 0 and not self.clear then
+        love.graphics.setFont(font_3x5_4)
+        love.graphics.printf("STAGE " .. self.current_map, 64, 170, 160, "center")
+
+        love.graphics.setFont(font_3x5_3)
+        if effects[self.current_map] then
+            love.graphics.printf("EFFECT: " .. effects[self.current_map], 64, 270, 160, "center")
+        end
+    end
+
+    if self.cleared_frames > 0 and
+    (not self.grid:hasGemBlocks() or
+    (self.stage_frames >= 3600 and self.current_map <= 20)) then
+        love.graphics.setFont(font_3x5_2)
+        love.graphics.printf("TIME LIMIT", 64, 180, 160, "center")
+        love.graphics.printf("TIME EXTEND", 64, 240, 160, "center")
+        love.graphics.printf("STAGE TIME", 64, 300, 160, "center")
+        
+        love.graphics.setFont(font_3x5_3)
+        love.graphics.printf("STAGE " .. self.current_map, 64, 100, 160, "center")
+        love.graphics.setColor(
+            self.cleared_frames % 4 < 2 and
+            { 1, 1, 0.3, 1 } or
+            { 1, 1, 1, 1 }
+        )
+        love.graphics.printf(formatTime(self.time_limit), 64, 200, 160, "center")
+        love.graphics.setColor(1, 1, 1, 1)
+        love.graphics.printf(formatTime(self.time_extend), 64, 260, 160, "center")
+        love.graphics.printf(formatTime(self.stage_frames), 64, 320, 160, "center")
+
+        love.graphics.setFont(font_3x5_4)
+        love.graphics.printf((self.stage_frames >= 3600 and self.current_map <= 20) and "" or "CLEAR!", 64, 130, 160, "center")
+    end
+
+    if self.clear then
+        love.graphics.setFont(font_3x5_3)
+        love.graphics.printf("EXCELLENT!", 64, 180, 160, "center")
+
+        love.graphics.setFont(font_3x5_2)
+        if self.current_map ~= 27 then
+            love.graphics.printf("...but let's go\nbetter next time", 64, 220, 160, "center")
+        end
+    end
+end
+
+function SakuraGame:getBackground()
+    return (self.current_map - 1) % 20
+end
+
+function SakuraGame:getHighscoreData()
+    return {
+        maps = self.maps_cleared,
+        current_map = self.current_map,
+        frames = self.frames,
+    }
+end
+
+return SakuraGame

tetris/modes/survival_a3.lua

@@ -92,12 +92,8 @@ function SurvivalA3Game:getGarbageLimit()
 	else return 8 end
 end
 
-function SurvivalA3Game:getNextPiece(ruleset)
+function SurvivalA3Game:getSkin()
-	return {
+	return self.level >= 1000 and "bone" or "2tie"
-		skin = self.level >= 1000 and "bone" or "2tie",
-		shape = self.randomizer:nextPiece(),
-		orientation = ruleset:getDefaultOrientation(),
-	}
 end
 
 function SurvivalA3Game:hitTorikan(old_level, new_level)

tetris/randomizers/bag.lua

@@ -0,0 +1,23 @@
+local Randomizer = require 'tetris.randomizers.randomizer'
+
+local BagRandomizer = Randomizer:extend()
+
+function BagRandomizer:new(pieces)
+    self.bag = {}
+    self.pieces = pieces
+    for i = 1, self.pieces do
+        table.insert(self.bag, i)
+    end
+end
+
+function BagRandomizer:generatePiece()
+	if next(self.bag) == nil then
+		for i = 1, self.pieces do
+            table.insert(self.bag, i)
+        end
+	end
+	local x = math.random(table.getn(self.bag))
+	return table.remove(self.bag, x)
+end
+
+return BagRandomizer

tetris/randomizers/fixed_sequence.lua

@@ -0,0 +1,16 @@
+local Randomizer = require 'tetris.randomizers.randomizer'
+
+local Sequence = Randomizer:extend()
+
+function Sequence:initialize()
+    self.sequence = "IJLOT"
+    self.counter = 0
+end
+
+function Sequence:generatePiece()
+    local piece = string.sub(self.sequence, self.counter + 1, self.counter + 1)
+    self.counter = (self.counter + 1) % string.len(self.sequence)
+    return piece
+end
+
+return Sequence

tetris/randomizers/randomizer.lua

@@ -3,6 +3,7 @@ local Object = require 'libs.classic'
 local Randomizer = Object:extend()
 
 function Randomizer:new()
+	self.possible_pieces = 7
 	self:initialize()
 end
 

tetris/randomizers/sakura.lua

@@ -0,0 +1,10 @@
+local Sequence = require 'tetris.randomizers.fixed_sequence'
+
+local Sakura = Sequence:extend()
+
+function Sakura:initialize()
+    self.super:initialize()
+    self.sequence = "LIJOTSZILJOTISJZLOIJSZTIOJZTLSOZTISOLTJSIZTOJLIZSTOIZLTJOSILTZSOITJLZSTJJISOLJITSLZOIZSJOITSZLJTSZLISTJLZOTIOZSJILTZSOITZJSOLTJSZIOJLZIOJTZIZLOSIZTJOILZSOJIOSZTJILOSSILZOTJIZTSOLZTSOIJTZSILTZOSIJZTOLJISOLJTZSOLTZJSOTILZJTOLZIJSOZTJLOZSTLOZITSOLZTJIOSLZJTO"
+end
+
+return Sakura

tetris/rulesets/arika_srs.lua

@@ -6,6 +6,8 @@ local SRS = Ruleset:extend()
 SRS.name = "ACE-SRS"
 SRS.hash = "ACE Standard"
 
+SRS.MANIPULATIONS_MAX = 128
+
 SRS.spawn_positions = {
 	I = { x=5, y=2 },
 	J = { x=4, y=3 },
@@ -26,23 +28,11 @@ SRS.big_spawn_positions = {
 	Z = { x=2, y=1 },
 }
 
-function SRS:onPieceMove(piece, grid)
-	piece.lock_delay = 0 -- move reset
-	if piece:isDropBlocked(grid) then
-		piece.manipulations = piece.manipulations + 1
-		if piece.manipulations >= 128 then
-			piece:dropToBottom(grid)
-			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 >= 128 then
+		if piece.manipulations >= self.MANIPULATIONS_MAX then
-			piece:dropToBottom(grid)
 			piece.locked = true
 		end
 	end

tetris/rulesets/pairs.lua

@@ -0,0 +1,254 @@
+local Ruleset = require 'tetris.rulesets.ruleset'
+
+local PAIRS = Ruleset:extend()
+
+PAIRS.name = "PAIRS"
+PAIRS.hash = "PAIRS"
+PAIRS.world = true
+
+PAIRS.spawn_positions = {
+    [1] = { x=4, y=4 },
+    [2] = { x=4, y=5 },
+    [3] = { x=4, y=5 },
+    [4] = { x=4, y=5 },
+    [5] = { x=5, y=5 },
+    [6] = { x=5, y=5 },
+    [7] = { x=5, y=5 },
+    [8] = { x=5, y=5 },
+    [9] = { x=5, y=5 },
+    [10] = { x=5, y=5 },
+    [11] = { x=4, y=5 },
+    [12] = { x=4, y=5 },
+    [13] = { x=4, y=5 },
+    [14] = { x=4, y=5 },
+    [15] = { x=4, y=5 },
+    [16] = { x=4, y=5 },
+    [17] = { x=4, y=5 },
+    [18] = { x=4, y=5 },
+}
+
+PAIRS.big_spawn_positions = {
+	[1] = { x=2, y=2 },
+    [2] = { x=2, y=3 },
+    [3] = { x=2, y=3 },
+    [4] = { x=2, y=3 },
+    [5] = { x=3, y=3 },
+    [6] = { x=3, y=3 },
+    [7] = { x=3, y=3 },
+    [8] = { x=3, y=3 },
+    [9] = { x=3, y=3 },
+    [10] = { x=3, y=3 },
+    [11] = { x=2, y=3 },
+    [12] = { x=2, y=3 },
+    [13] = { x=2, y=3 },
+    [14] = { x=2, y=3 },
+    [15] = { x=2, y=3 },
+    [16] = { x=2, y=3 },
+    [17] = { x=2, y=3 },
+    [18] = { x=2, y=3 },
+}
+
+PAIRS.next_sounds = {
+    [1] = "I",
+    [2] = "O",
+    [3] = "S",
+    [4] = "Z",
+    [5] = "L",
+    [6] = "J",
+    [7] = "Z",
+    [8] = "S",
+    [9] = "J",
+    [10] = "L",
+    [11] = "O",
+    [12] = "O",
+    [13] = "T",
+    [14] = "L",
+    [15] = "J",
+    [16] = "T",
+    [17] = "J",
+    [18] = "I"
+}
+
+PAIRS.colourscheme = {
+    [1] = "R",
+    [2] = "C",
+    [3] = "G",
+    [4] = "M",
+    [5] = "O",
+    [6] = "C",
+    [7] = "G",
+    [8] = "M",
+    [9] = "G",
+    [10] = "M",
+    [11] = "Y",
+    [12] = "B",
+    [13] = "M",
+    [14] = "O",
+    [15] = "B",
+    [16] = "G",
+    [17] = "C",
+    [18] = "R"
+}
+
+PAIRS.pieces = 18
+
+PAIRS.block_offsets = {
+    [1]={
+        { {x=-2, y=0}, {x=-1, y=0}, {x=0, y=0}, {x=1, y=0}, {x=2, y=0} },
+        { {x=0, y=-2}, {x=0, y=-1}, {x=0, y=0}, {x=0, y=1}, {x=0, y=2} },
+        { {x=-2, y=0}, {x=-1, y=0}, {x=0, y=0}, {x=1, y=0}, {x=2, y=0} },
+        { {x=0, y=-2}, {x=0, y=-1}, {x=0, y=0}, {x=0, y=1}, {x=0, y=2} },
+    },
+    [2]={
+        { {x=0, y=-1}, {x=0, y=-2}, {x=0, y=0}, {x=1, y=-1}, {x=-1, y=-1} },
+        { {x=0, y=-1}, {x=0, y=-2}, {x=0, y=0}, {x=1, y=-1}, {x=-1, y=-1} },
+        { {x=0, y=-1}, {x=0, y=-2}, {x=0, y=0}, {x=1, y=-1}, {x=-1, y=-1} },
+        { {x=0, y=-1}, {x=0, y=-2}, {x=0, y=0}, {x=1, y=-1}, {x=-1, y=-1} },
+    },
+    [3]={
+        { {x=0, y=-1}, {x=0, y=-2}, {x=0, y=0}, {x=1, y=-2}, {x=-1, y=0} },
+        { {x=0, y=-1}, {x=-1, y=-1}, {x=1, y=-1}, {x=1, y=0}, {x=-1, y=-2} },
+        { {x=0, y=-1}, {x=0, y=-2}, {x=0, y=0}, {x=1, y=-2}, {x=-1, y=0} },
+        { {x=0, y=-1}, {x=-1, y=-1}, {x=1, y=-1}, {x=1, y=0}, {x=-1, y=-2} },
+    },
+    [4]={
+        { {x=0, y=-1}, {x=0, y=-2}, {x=0, y=0}, {x=1, y=0}, {x=-1, y=-2} },
+        { {x=0, y=-1}, {x=-1, y=-1}, {x=1, y=-1}, {x=-1, y=0}, {x=1, y=-2} },
+        { {x=0, y=-1}, {x=0, y=-2}, {x=0, y=0}, {x=1, y=0}, {x=-1, y=-2} },
+        { {x=0, y=-1}, {x=-1, y=-1}, {x=1, y=-1}, {x=-1, y=0}, {x=1, y=-2} },
+    },
+    [5]={
+        { {x=1, y=-1}, {x=-2, y=0}, {x=-1, y=0}, {x=0, y=0}, {x=1, y=0} },
+        { {x=0, y=0}, {x=-1, y=-3}, {x=-1, y=-2}, {x=-1, y=-1}, {x=-1, y=0} },
+        { {x=-2, y=0}, {x=-2, y=-1}, {x=-1, y=-1}, {x=0, y=-1}, {x=1, y=-1} },
+        { {x=-1, y=-3}, {x=0, y=-3}, {x=0, y=-2}, {x=0, y=-1}, {x=0, y=0} },
+    },
+    [6]={
+        { {x=-2, y=-1}, {x=-2, y=0}, {x=-1, y=0}, {x=0, y=0}, {x=1, y=0} },
+        { {x=0, y=-3}, {x=-1, y=-3}, {x=-1, y=-2}, {x=-1, y=-1}, {x=-1, y=0} },
+        { {x=1, y=0}, {x=-2, y=-1}, {x=-1, y=-1}, {x=0, y=-1}, {x=1, y=-1} },
+        { {x=-1, y=0}, {x=0, y=-3}, {x=0, y=-2}, {x=0, y=-1}, {x=0, y=0} },
+    },
+    [7]={
+        { {x=-2, y=-1}, {x=-1, y=-1}, {x=-1, y=0}, {x=0, y=0}, {x=1, y=0} },
+        { {x=0, y=-3}, {x=0, y=-2}, {x=-1, y=-2}, {x=-1, y=-1}, {x=-1, y=0} },
+        { {x=-2, y=-1}, {x=-1, y=-1}, {x=0, y=-1}, {x=0, y=0}, {x=1, y=0} },
+        { {x=-1, y=0}, {x=0, y=-3}, {x=0, y=-2}, {x=0, y=-1}, {x=-1, y=-1} },
+    },
+    [8]={
+        { {x=1, y=-1}, {x=-2, y=0}, {x=-1, y=0}, {x=0, y=0}, {x=0, y=-1} },
+        { {x=0, y=0}, {x=-1, y=-3}, {x=-1, y=-2}, {x=-1, y=-1}, {x=0, y=-1} },
+        { {x=-2, y=0}, {x=-1, y=0}, {x=-1, y=-1}, {x=0, y=-1}, {x=1, y=-1} },
+        { {x=-1, y=-3}, {x=-1, y=-2}, {x=0, y=-2}, {x=0, y=-1}, {x=0, y=0} },
+    },
+    [9]={
+        { {x=-1, y=-1}, {x=-2, y=0}, {x=-1, y=0}, {x=0, y=0}, {x=1, y=0} },
+        { {x=0, y=-2}, {x=-1, y=-3}, {x=-1, y=-2}, {x=-1, y=-1}, {x=-1, y=0} },
+        { {x=0, y=0}, {x=-2, y=-1}, {x=-1, y=-1}, {x=0, y=-1}, {x=1, y=-1} },
+        { {x=-1, y=-1}, {x=0, y=-3}, {x=0, y=-2}, {x=0, y=-1}, {x=0, y=0} },
+    },
+    [10]={
+        { {x=0, y=-1}, {x=-2, y=0}, {x=-1, y=0}, {x=0, y=0}, {x=1, y=0} },
+        { {x=0, y=-1}, {x=-1, y=-3}, {x=-1, y=-2}, {x=-1, y=-1}, {x=-1, y=0} },
+        { {x=-1, y=0}, {x=-2, y=-1}, {x=-1, y=-1}, {x=0, y=-1}, {x=1, y=-1} },
+        { {x=-1, y=-2}, {x=0, y=-3}, {x=0, y=-2}, {x=0, y=-1}, {x=0, y=0} },
+    },
+    [11]={
+        { {x=0, y=0}, {x=-1, y=0}, {x=1, y=0}, {x=0, y=-1}, {x=-1, y=-1} },
+        { {x=0, y=0}, {x=0, y=-1}, {x=0, y=-2}, {x=1, y=-1}, {x=1, y=-2} },
+        { {x=0, y=0}, {x=1, y=-1}, {x=1, y=0}, {x=0, y=-1}, {x=-1, y=-1} },
+        { {x=0, y=0}, {x=0, y=-1}, {x=0, y=-2}, {x=-1, y=-1}, {x=-1, y=0} },
+    },
+    [12]={
+        { {x=0, y=0}, {x=1, y=-1}, {x=1, y=0}, {x=0, y=-1}, {x=-1, y=0} },
+        { {x=0, y=0}, {x=0, y=-1}, {x=0, y=-2}, {x=1, y=-1}, {x=1, y=0} },
+        { {x=0, y=0}, {x=-1, y=0}, {x=1, y=-1}, {x=0, y=-1}, {x=-1, y=-1} },
+        { {x=0, y=0}, {x=0, y=-1}, {x=0, y=-2}, {x=-1, y=-1}, {x=-1, y=-2} },
+    },
+    [13]={
+        { {x=0, y=0}, {x=-1, y=0}, {x=1, y=0}, {x=-1, y=-1}, {x=1, y=-1} },
+        { {x=0, y=0}, {x=0, y=-1}, {x=0, y=-2}, {x=1, y=0}, {x=1, y=-2} },
+        { {x=0, y=-1}, {x=-1, y=0}, {x=1, y=0}, {x=-1, y=-1}, {x=1, y=-1} },
+        { {x=0, y=0}, {x=0, y=-1}, {x=0, y=-2}, {x=-1, y=0}, {x=-1, y=-2} },
+    },
+    [14]={
+        { {x=0, y=-1}, {x=0, y=0}, {x=0, y=-2}, {x=-1, y=-1}, {x=1, y=0} },
+        { {x=0, y=-1}, {x=-1, y=-1}, {x=1, y=-1}, {x=0, y=-2}, {x=-1, y=0} },
+		{ {x=0, y=-1}, {x=0, y=-2}, {x=0, y=0}, {x=1, y=-1}, {x=-1, y=-2} },
+		{ {x=0, y=-1}, {x=1, y=-1}, {x=-1, y=-1}, {x=0, y=0}, {x=1, y=-2} },
+    },
+    [15]={
+        { {x=0, y=-1}, {x=0, y=0}, {x=0, y=-2}, {x=-1, y=0}, {x=1, y=-1} },
+        { {x=0, y=-1}, {x=-1, y=-1}, {x=1, y=-1}, {x=-1, y=-2}, {x=0, y=0} },
+		{ {x=0, y=-1}, {x=0, y=-2}, {x=0, y=0}, {x=1, y=-2}, {x=-1, y=-1} },
+		{ {x=0, y=-1}, {x=1, y=-1}, {x=-1, y=-1}, {x=1, y=0}, {x=0, y=-2} },
+    },
+    [16]={
+        { {x=0, y=0}, {x=0, y=-1}, {x=0, y=-2}, {x=-1, y=0}, {x=1, y=0} },
+        { {x=-1, y=0}, {x=0, y=-1}, {x=-1, y=-2}, {x=-1, y=-1}, {x=1, y=-1} },
+        { {x=0, y=0}, {x=0, y=-1}, {x=0, y=-2}, {x=-1, y=-2}, {x=1, y=-2} },
+        { {x=1, y=0}, {x=0, y=-1}, {x=1, y=-2}, {x=-1, y=-1}, {x=1, y=-1} },
+    },
+    [17]={
+        { {x=0, y=0}, {x=1, y=0}, {x=-1, y=0}, {x=-1, y=-1}, {x=-1, y=-2} },
+        { {x=0, y=-2}, {x=1, y=-2}, {x=-1, y=0}, {x=-1, y=-1}, {x=-1, y=-2} },
+        { {x=0, y=-2}, {x=1, y=0}, {x=-1, y=-2}, {x=1, y=-1}, {x=1, y=-2} },
+        { {x=0, y=0}, {x=1, y=0}, {x=-1, y=0}, {x=1, y=-1}, {x=1, y=-2} },
+    },
+    [18]={
+        { {x=1, y=0}, {x=0, y=0}, {x=0, y=-1}, {x=-1, y=-1}, {x=-1, y=-2} },
+        { {x=-1, y=0}, {x=-1, y=-1}, {x=0, y=-1}, {x=0, y=-2}, {x=1, y=-2} },
+        { {x=-1, y=-2}, {x=0, y=-2}, {x=0, y=-1}, {x=1, y=-1}, {x=1, y=0} },
+		{ {x=1, y=-2}, {x=1, y=-1}, {x=0, y=-1}, {x=0, y=0}, {x=-1, y=0} },
+    },
+}
+
+PAIRS.wallkicks = {
+	{x=1, y=0}, {x=-1, y=0}, {x=2, y=0}, {x=-2, y=0}, {x=0, y=-1}
+}
+
+function PAIRS:attemptWallkicks(piece, new_piece, rot_dir, grid)
+    if (piece.shape == 2) then return end
+    
+    local kicks = PAIRS.wallkicks
+
+	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
+			self:onPieceRotate(piece, grid)
+			piece:setRelativeRotation(rot_dir)
+			piece:setOffset(offset)
+			return
+		end
+	end
+end
+
+function PAIRS:checkNewLow(piece)
+    for _, block in pairs(piece:getBlockOffsets()) do
+        local y = piece.position.y + block.y
+        if y > piece.lowest_y then
+            piece.lock_delay = 0
+            piece.lowest_y = y
+        end
+    end
+end
+
+function PAIRS:onPieceCreate(piece, grid)
+	piece.lowest_y = -math.huge
+end
+
+function PAIRS:onPieceDrop(piece, grid)
+    self:checkNewLow(piece)
+end
+
+function PAIRS:get180RotationValue() 
+	if config.gamesettings.world_reverse == 1 then
+		return 1
+	else
+		return 3
+	end
+end
+
+return PAIRS

tetris/rulesets/ruleset.lua

@@ -22,10 +22,24 @@ Ruleset.harddrop_lock = false
 
 Ruleset.enable_IRS_wallkicks = false
 Ruleset.are_cancel = false
+Ruleset.are = true
+
+Ruleset.next_sounds = {
+		I = "I",
+		L = "L",
+		J = "J",
+		S = "S",
+		Z = "Z",
+		O = "O",
+		T = "T"
+}
+
+Ruleset.pieces = 7
 
 -- Component functions.
 
 function Ruleset:new()
+	
 	if config.gamesettings.piece_colour == 1 then
 		blocks["bone"] = (not self.world) and
 		{
@@ -115,8 +129,8 @@ function Ruleset:attemptRotate(new_inputs, piece, grid, initial)
 	local new_piece = piece:withRelativeRotation(rot_dir)
 
 	if (grid:canPlacePiece(new_piece)) then
-		self:onPieceRotate(piece, grid)
 		piece:setRelativeRotation(rot_dir)
+		self:onPieceRotate(piece, grid)
 	else
 		if not(initial and self.enable_IRS_wallkicks == false) then
 			self:attemptWallkicks(piece, new_piece, rot_dir, grid)
@@ -181,7 +195,9 @@ 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, big, irs
+	drop_locked, hard_drop_locked, big, irs,
+	buffer_hard_drop, buffer_soft_drop,
+	lock_on_hard_drop, lock_on_soft_drop
 )
 	local spawn_positions
 	if big then
@@ -206,6 +222,13 @@ function Ruleset:initializePiece(
 		self:rotatePiece(inputs, piece, grid, {}, true)
 	end
 	self:dropPiece(inputs, piece, grid, gravity, drop_speed, drop_locked, hard_drop_locked)
+	if (buffer_hard_drop and config.gamesettings.buffer_lock == 1) then
+		piece:dropToBottom(grid)
+		if lock_on_hard_drop then piece.locked = true end
+	end
+	if (buffer_soft_drop and lock_on_soft_drop and piece:isDropBlocked(grid) and config.gamesettings.buffer_lock == 1) then
+		piece.locked = true
+	end
 	return piece
 end
 

tetris/rulesets/standard_exp.lua

@@ -8,7 +8,9 @@ SRS.hash = "Standard"
 
 SRS.enable_IRS_wallkicks = true
 
-function SRS:check_new_low(piece)
+SRS.MANIPULATIONS_MAX = 15
+
+function SRS:checkNewLow(piece)
 	for _, block in pairs(piece:getBlockOffsets()) do
 		local y = piece.position.y + block.y
 		if y > piece.lowest_y then
@@ -74,8 +76,8 @@ function SRS:onPieceCreate(piece, grid)
 end
 
 function SRS:onPieceDrop(piece, grid)
-	self:check_new_low(piece)
+	self:checkNewLow(piece)
-	if piece.manipulations >= 15 and piece:isDropBlocked(grid) then
+	if piece.manipulations >= self.MANIPULATIONS_MAX and piece:isDropBlocked(grid) then
 		piece.locked = true
 	else
 		piece.lock_delay = 0 -- step reset
@@ -86,8 +88,7 @@ function SRS:onPieceMove(piece, grid)
 	piece.lock_delay = 0 -- move reset
 	if piece:isDropBlocked(grid) then
 		piece.manipulations = piece.manipulations + 1
-		if piece.manipulations >= 15 then
+		if piece.manipulations >= self.MANIPULATIONS_MAX then
-			piece:dropToBottom(grid)
 			piece.locked = true
 		end
 	end
@@ -95,11 +96,11 @@ end
 
 function SRS:onPieceRotate(piece, grid)
 	piece.lock_delay = 0 -- rotate reset
-	self:check_new_low(piece)
+	self:checkNewLow(piece)
 	piece.manipulations = piece.manipulations + 1
+    if piece.manipulations >= self.MANIPULATIONS_MAX then
+        piece:moveInGrid({ x = 0, y = 1 }, 1, grid)
         if piece:isDropBlocked(grid) then
-		if piece.manipulations >= 15 then
-			piece:dropToBottom(grid)
             piece.locked = true
         end
     end

tetris/rulesets/ti_srs.lua

@@ -18,6 +18,9 @@ SRS.colourscheme = {
 SRS.softdrop_lock = false
 SRS.harddrop_lock = true
 
+SRS.MANIPULATIONS_MAX = 10
+SRS.ROTATIONS_MAX = 8
+
 SRS.spawn_positions = {
 	I = { x=5, y=4 },
 	J = { x=4, y=5 },
@@ -162,15 +165,18 @@ function SRS:onPieceCreate(piece, grid)
 end
 
 function SRS:onPieceDrop(piece, grid)
+    if (piece.manipulations >= self.MANIPULATIONS_MAX or piece.rotations >= self.ROTATIONS_MAX) and piece:isDropBlocked(grid) then
+        piece.locked = true
+    else
         piece.lock_delay = 0 -- step reset
+    end
 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 >= 10 then
+		if piece.manipulations >= self.MANIPULATIONS_MAX then
-			piece:dropToBottom(grid)
 			piece.locked = true
 		end
 	end
@@ -180,8 +186,7 @@ function SRS:onPieceRotate(piece, grid)
 	piece.lock_delay = 0 -- rotate reset
 	if piece:isDropBlocked(grid) then
         piece.rotations = piece.rotations + 1
-		if piece.rotations >= 8 then
+		if piece.rotations >= self.ROTATIONS_MAX then
-			piece:dropToBottom(grid)
 			piece.locked = true
 		end
 	end