Marathon 2020 section colour function fixed

Sound effects can still be changed, and #7 can still be reopened.

README.md

@@ -29,6 +29,7 @@ The following people in no particular order also helped with the project:
 - [2Tie](https://github.com/2Tie)
 - [nightmareci](https://github.com/nightmareci)
 - [MyPasswordIsWeak](https://github.com/MyPasswordIsWeak)
+- [Dr Ocelot](https://github.com/Dr-Ocelot)
 
 ![Cambridge Logo](https://cdn.discordapp.com/attachments/625496179433668635/763363717730664458/Icon_2.png)
 

SOURCES.md

@@ -8,7 +8,7 @@ Some of the assets are used without proper licenses. We aim to have fully licens
 Backgrounds
 -----------
 
-1. Title: "Motus Glacies." Contributed by Daniel "Explo" McCarthy.
+1. Title: Original picrute found on the Wikipedia article for Cambridge
 
 1. *Gameplay level 0: "Quantum foam." Alex Sukontsev. https://www.flickr.com/photos/control9/14957509814/
 2. *Gameplay level 1: No name. http://www.onekind.tv/univision-mqb/q5mqh5brlvuuj2nhdx7ch7eum183uu
@@ -34,6 +34,14 @@ Backgrounds
 Backgrounds marked with a * are placeholders that will be replaced in later versions due to incompatible licenses. We are generally aiming for public domain background images, but will also accept backgrounds given proper licenses to be included within Cambridge.
 
 
+Sounds
+------
+
+All piece sounds are (c) 2020 Damian Yerrick.
+Other sounds from:
+- NullpoMino
+- DTET, (c) 2003 Mihys.
+
 Music
 -----
 

load/graphics.lua

@@ -1,27 +1,27 @@
 backgrounds = {
-	[0] = love.graphics.newImage("res/backgrounds/0-quantum-foam.png"),
+	[0] = love.graphics.newImage("res/backgrounds/0.png"),
-	love.graphics.newImage("res/backgrounds/100-big-bang.png"),
+	love.graphics.newImage("res/backgrounds/100.png"),
-	love.graphics.newImage("res/backgrounds/200-spiral-galaxy.png"),
+	love.graphics.newImage("res/backgrounds/200.png"),
-	love.graphics.newImage("res/backgrounds/300-sun-and-dust.png"),
+	love.graphics.newImage("res/backgrounds/300.png"),
-	love.graphics.newImage("res/backgrounds/400-earth-and-moon.png"),
+	love.graphics.newImage("res/backgrounds/400.png"),
-	love.graphics.newImage("res/backgrounds/500-cambrian-explosion.png"),
+	love.graphics.newImage("res/backgrounds/500.png"),
-	love.graphics.newImage("res/backgrounds/600-dinosaurs.png"),
+	love.graphics.newImage("res/backgrounds/600.png"),
-	love.graphics.newImage("res/backgrounds/700-asteroid.png"),
+	love.graphics.newImage("res/backgrounds/700.png"),
-	love.graphics.newImage("res/backgrounds/800-human-fire.png"),
+	love.graphics.newImage("res/backgrounds/800.png"),
-	love.graphics.newImage("res/backgrounds/900-early-civilization.png"),
+	love.graphics.newImage("res/backgrounds/900.png"),
-	love.graphics.newImage("res/backgrounds/1000-vikings.png"),
+	love.graphics.newImage("res/backgrounds/1000.png"),
-	love.graphics.newImage("res/backgrounds/1100-crusades.png"),
+	love.graphics.newImage("res/backgrounds/1100.png"),
-	love.graphics.newImage("res/backgrounds/1200-genghis-khan.png"),
+	love.graphics.newImage("res/backgrounds/1200.png"),
-	love.graphics.newImage("res/backgrounds/1300-black-death.png"),
+	love.graphics.newImage("res/backgrounds/1300.png"),
-	love.graphics.newImage("res/backgrounds/1400-columbus-discovery.png"),
+	love.graphics.newImage("res/backgrounds/1400.png"),
-	love.graphics.newImage("res/backgrounds/1500-aztecas.png"),
+	love.graphics.newImage("res/backgrounds/1500.png"),
-	love.graphics.newImage("res/backgrounds/1600-telescope.png"),
+	love.graphics.newImage("res/backgrounds/1600.png"),
-	love.graphics.newImage("res/backgrounds/1700-american-revolution.png"),
+	love.graphics.newImage("res/backgrounds/1700.png"),
-	love.graphics.newImage("res/backgrounds/1800-railways.png"),
+	love.graphics.newImage("res/backgrounds/1800.png"),
-	love.graphics.newImage("res/backgrounds/1900-world-wide-web.png"),
+	love.graphics.newImage("res/backgrounds/1900.png"),
-	title = love.graphics.newImage("res/backgrounds/title_v0.1.png"),
+	title = love.graphics.newImage("res/backgrounds/title.png"),
-	input_config = love.graphics.newImage("res/backgrounds/options-pcb.png"),
+	input_config = love.graphics.newImage("res/backgrounds/options-input.png"),
-	game_config = love.graphics.newImage("res/backgrounds/options-gears.png"),
+	game_config = love.graphics.newImage("res/backgrounds/options-game.png"),
 }
 
 blocks = {

load/sounds.lua

@@ -20,6 +20,8 @@ sounds = {
 	fall = love.audio.newSource("res/se/fall.wav", "static"),
 	ready = love.audio.newSource("res/se/ready.wav", "static"),
 	go = love.audio.newSource("res/se/go.wav", "static"),
+	irs = love.audio.newSource("res/se/irs.wav", "static"),
+	ihs = love.audio.newSource("res/se/ihs.wav", "static"),
 }
 
 function playSE(sound, subsound)
@@ -30,7 +32,7 @@ function playSE(sound, subsound)
 		end
 		sounds[sound]:play()
 	else
-		sounds[sound][subsound]:setVolume(0.1)
+		sounds[sound][subsound]:setVolume(0.6)
 		if sounds[sound][subsound]:isPlaying() then
 			sounds[sound][subsound]:stop()
 		end

main.lua

@@ -15,7 +15,12 @@ function love.load()
 
 	love.window.setMode(love.graphics.getWidth(), love.graphics.getHeight(), {resizable = true});
 
-	if not config.gamesettings then config.gamesettings = {} end
+	if not config.gamesettings then
+		config.gamesettings = {}
+		config["das_last_key"] = false
+	else
+		config["das_last_key"] = config.gamesettings.das_last_key == 2
+	end
 	for _, option in ipairs(GameConfigScene.options) do
 		if not config.gamesettings[option[1]] then
 			config.gamesettings[option[1]] = 1

scene/game_config.lua

@@ -9,6 +9,9 @@ ConfigScene.options = {
 	{"manlock",			"Manual locking",{"Per ruleset","Per gamemode","Harddrop", "Softdrop"}},
 	{"piece_colour", "Piece Colours", {"Per ruleset","Arika"			 ,"TTC"}},
 	{"world_reverse","A Button Rotation", {"Left"				 ,"Auto"		,"Right"}},
+	{"next_se", "Next Piece SFX", {"On", "Off"}},
+	{"das_last_key", "DAS Switch", {"Default", "Instant"}},
+	{"synchroes_allowed", "Synchroes", {"Per ruleset", "On", "Off"}}
 }
 local optioncount = #ConfigScene.options
 
@@ -24,6 +27,7 @@ function ConfigScene:new()
 end
 
 function ConfigScene:update()
+	config["das_last_key"] = config.gamesettings.das_last_key == 2
 end
 
 function ConfigScene:render()

scene/input_config.lua

@@ -32,6 +32,7 @@ function ConfigScene:new()
 	self.input_state = 1
 	self.set_inputs = newSetInputs()
 	self.new_input = {}
+	self.axis_timer = 0
 
 	DiscordRPC:update({
 		details = "In menus",
@@ -63,6 +64,8 @@ function ConfigScene:render()
 		love.graphics.print("press key or joystick input for " .. configurable_inputs[self.input_state] .. ", tab to skip" .. (config.input and ", escape to cancel" or ""), 0, 0)
 		love.graphics.print("function keys (F1, F2, etc.), escape, and tab can't be changed", 0, 20)
 	end
+
+	self.axis_timer = self.axis_timer + 1
 end
 
 local function addJoystick(input, name)
@@ -118,7 +121,7 @@ function ConfigScene:onInputPress(e)
 				self.new_input.joysticks[e.name].buttons[e.button] = configurable_inputs[self.input_state]
 				self.input_state = self.input_state + 1
 			elseif e.type == "joyaxis" then
-				if math.abs(e.value) >= 0.5 then
+				if (e.axis ~= self.last_axis or self.axis_timer > 30) and math.abs(e.value) >= 1 then
 					addJoystick(self.new_input, e.name)
 					if not self.new_input.joysticks[e.name].axes then
 						self.new_input.joysticks[e.name].axes = {}
@@ -128,10 +131,12 @@ function ConfigScene:onInputPress(e)
 					end
 					self.set_inputs[configurable_inputs[self.input_state]] =
 						"jaxis " ..
-						(e.value >= 0.5 and "+" or "-") .. e.axis ..
+						(e.value >= 1 and "+" or "-") .. e.axis ..
 						" " .. string.sub(e.name, 1, 10) .. (string.len(e.name) > 10 and "..." or "")
-					self.new_input.joysticks[e.name].axes[e.axis][e.value >= 0.5 and "positive" or "negative"] = configurable_inputs[self.input_state]
+					self.new_input.joysticks[e.name].axes[e.axis][e.value >= 1 and "positive" or "negative"] = configurable_inputs[self.input_state]
 					self.input_state = self.input_state + 1
+					self.last_axis = e.axis
+					self.axis_timer = 0
 				end
 			elseif e.type == "joyhat" then
 				if e.direction ~= "c" then

tetris/components/grid.lua

@@ -230,6 +230,15 @@ function Grid:checkForBravo(cleared_row_count)
 	return true
 end
 
+function Grid:checkStackHeight()
+	for i = 0, 23 do
+		for j = 0, 9 do
+			if self:isOccupied(j, i) then return 24 - i end
+		end
+	end
+	return 0
+end
+
 function Grid:checkSecretGrade()
 	local sgrade = 0
 	for i=23,5,-1 do
@@ -310,7 +319,32 @@ function Grid:draw()
 	end
 end
 
-function Grid:drawInvisible(opacity_function, garbage_opacity_function)
+function Grid:drawOutline()
+	for y = 5, 24 do
+		for x = 1, 10 do
+			if self.grid[y][x] ~= empty 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
+					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
+					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
+
+function Grid:drawInvisible(opacity_function, garbage_opacity_function, lock_flash, brightness)
+	lock_flash = lock_flash == nil and true or lock_flash
+	brightness = brightness == nil and 0.5 or brightness
 	for y = 5, 24 do
 		for x = 1, 10 do
 			if self.grid[y][x] ~= empty then
@@ -321,22 +355,24 @@ function Grid:drawInvisible(opacity_function, garbage_opacity_function)
 				else
 					opacity = opacity_function(self.grid_age[y][x])
 				end
-				love.graphics.setColor(0.5, 0.5, 0.5, opacity)
+				love.graphics.setColor(brightness, brightness, brightness, opacity)
 				love.graphics.draw(blocks[self.grid[y][x].skin][self.grid[y][x].colour], 48+x*16, y*16)
-				if opacity > 0 and self.grid[y][x].colour ~= "X" then
+				if lock_flash then
-					love.graphics.setColor(0.64, 0.64, 0.64)
+					if opacity > 0 and self.grid[y][x].colour ~= "X" then
-					love.graphics.setLineWidth(1)
+						love.graphics.setColor(0.64, 0.64, 0.64)
-					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

@@ -78,12 +78,15 @@ function Piece:setRelativeRotation(rot)
 	return self
 end
 
-function Piece:moveInGrid(step, squares, grid)
+function Piece:moveInGrid(step, squares, grid, instant)
 	local moved = false
 	for x = 1, squares do
 		if grid:canPlacePiece(self:withOffset(step)) then
 			moved = true
 			self:setOffset(step)
+			if instant then
+				self:dropToBottom(grid)
+			end
 		else
 			break
 		end

tetris/modes/big_a2.lua

@@ -250,7 +250,7 @@ end
 
 function MarathonA2Game:drawGrid(ruleset)
 	if self.clear and not (self.completed or self.game_over) then
-		self.grid:drawInvisible(self.rollOpacityFunction)
+		self.grid:drawInvisible(self.rollOpacityFunction, nil, false)
 	else
 		self.grid:draw()
 		if self.piece ~= nil and self.level < 100 then

tetris/modes/gamemode.lua

@@ -43,7 +43,14 @@ function GameMode:new()
 	self.draw_section_times = false
 	self.draw_secondary_section_times = false
 	self.big_mode = false
+	self.irs = true
+	self.ihs = true
 	self.rpc_details = "In game"
+	self.SGnames = {
+		"9", "8", "7", "6", "5", "4", "3", "2", "1",
+		"S1", "S2", "S3", "S4", "S5", "S6", "S7", "S8", "S9",
+		"GM"
+	}
 	-- variables related to configurable parameters
 	self.drop_locked = false
 	self.hard_drop_locked = false
@@ -94,10 +101,20 @@ function GameMode:update(inputs, ruleset)
 	if self.completed then return end
 
 	-- advance one frame
-	if self:advanceOneFrame(inputs) == false then return end
+	if self:advanceOneFrame(inputs, ruleset) == false then return end
 
 	self:chargeDAS(inputs, self:getDasLimit(), self.getARR())
 
+	-- set attempt flags
+	if inputs["left"] or inputs["right"] then self:onAttemptPieceMove(self.piece) end
+	if
+		inputs["rotate_left"] or inputs["rotate_right"] or
+		inputs["rotate_left2"] or inputs["rotate_right2"] or
+		inputs["rotate_180"]
+	then
+		self:onAttemptPieceRotate(self.piece)
+	end
+	
 	if self.piece == nil then
 		self:processDelays(inputs, ruleset)
 	else
@@ -105,7 +122,7 @@ function GameMode:update(inputs, ruleset)
 		self:whilePieceActive()
 		local gravity = self:getGravity()
 
-		if self.enable_hold and inputs["hold"] == true and self.held == false then
+		if self.enable_hold and inputs["hold"] == true and self.held == false and self.prev_inputs["hold"] == false then
 			self:hold(inputs, ruleset)
 			self.prev_inputs = inputs
 			return
@@ -198,6 +215,8 @@ end
 
 -- event functions
 function GameMode:whilePieceActive() end
+function GameMode:onAttemptPieceMove(piece) end
+function GameMode:onAttemptPieceRotate(piece) end
 function GameMode:onPieceLock(piece, cleared_row_count) 
 	playSE("lock")
 end
@@ -205,9 +224,7 @@ end
 function GameMode:onLineClear(cleared_row_count) end
 
 function GameMode:onPieceEnter() end
-function GameMode:onHold() 
+function GameMode:onHold() end
-	playSE("hold")
-end
 
 function GameMode:onSoftDrop(dropped_row_count)
 	self.drop_bonus = self.drop_bonus + 1 * dropped_row_count
@@ -221,30 +238,66 @@ function GameMode:onGameOver()
 	switchBGM(nil)
 end
 
-function GameMode:chargeDAS(inputs)
+-- DAS functions
-	if inputs[self.das.direction] == true then
+
-		local das_frames = self.das.frames + 1
+function GameMode:startRightDAS()
-		if das_frames >= self:getDasLimit() then
+	self.move = "right"
-			if self.das.direction == "left" then
+	self.das = { direction = "right", frames = 0 }
-				self.move = (self:getARR() == 0 and "speed" or "") .. "left"
+	if self:getDasLimit() == 0 then
-				self.das.frames = self:getDasLimit() - self:getARR()
+		self:continueDAS()
-			elseif self.das.direction == "right" then
+	end
-				self.move = (self:getARR() == 0 and "speed" or "") .. "right"
+end
-				self.das.frames = self:getDasLimit() - self:getARR()
+
-			end
+function GameMode:startLeftDAS()
-		else
+	self.move = "left"
-			self.move = "none"
+	self.das = { direction = "left", frames = 0 }
-			self.das.frames = das_frames
+	if self:getDasLimit() == 0 then
+		self:continueDAS()
+	end
+end
+
+function GameMode:continueDAS()
+	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
-	elseif inputs["right"] == true then
-		self.move = "right"
-		self.das = { direction = "right", frames = 0 }
-	elseif inputs["left"] == true then
-		self.move = "left"
-		self.das = { direction = "left", frames = 0 }
 	else
 		self.move = "none"
-		self.das = { direction = "none", frames = -1 }
+		self.das.frames = das_frames
+	end
+end
+
+function GameMode:stopDAS()
+	self.move = "none"
+	self.das = { direction = "none", frames = -1 }
+end
+
+function GameMode:chargeDAS(inputs)
+	if config["das_last_key"] then
+		if inputs["right"] == true and self.das.direction ~= "right" and not self.prev_inputs["right"] then
+			self:startRightDAS()
+		elseif inputs["left"] == true and self.das.direction ~= "left" and not self.prev_inputs["left"] then
+			self:startLeftDAS()
+		elseif inputs[self.das.direction] == true then
+			self:continueDAS()
+		else
+			self:stopDAS()
+		end
+	else  -- default behaviour, das first key pressed
+		if inputs[self.das.direction] == true then
+			self:continueDAS()
+		elseif inputs["right"] == true then
+			self:startRightDAS()
+		elseif inputs["left"] == true then
+			self:startLeftDAS()
+		else
+			self:stopDAS()
+		end
 	end
 end
 
@@ -268,6 +321,18 @@ function GameMode:processDelays(inputs, ruleset, drop_speed)
 		end
 	elseif self.lcd > 0 then
 		self.lcd = self.lcd - 1
+		if ruleset.are_cancel and
+			(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 self.lcd == 0 then
 			self.grid:clearClearedRows()
 			playSE("fall")
@@ -277,6 +342,17 @@ function GameMode:processDelays(inputs, ruleset, drop_speed)
 		end
 	elseif self.are > 0 then
 		self.are = self.are - 1
+		if ruleset.are_cancel and
+			(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 self.are == 0 then
 			self:initializeOrHold(inputs, ruleset)
 		end
@@ -284,8 +360,8 @@ function GameMode:processDelays(inputs, ruleset, drop_speed)
 end
 
 function GameMode:initializeOrHold(inputs, ruleset)
-	if self.enable_hold and inputs["hold"] == true then
+	if self.ihs and self.enable_hold and inputs["hold"] == true then
-		self:hold(inputs, ruleset)
+		self:hold(inputs, ruleset, true)
 	else
 		self:initializeNextPiece(inputs, ruleset, self.next_queue[1])
 	end
@@ -296,7 +372,7 @@ function GameMode:initializeOrHold(inputs, ruleset)
 	end
 end
 
-function GameMode:hold(inputs, ruleset)
+function GameMode:hold(inputs, ruleset, ihs)
 	local data = copy(self.hold_queue)
 	if self.piece == nil then
 		self.hold_queue = self.next_queue[1]
@@ -315,6 +391,8 @@ function GameMode:hold(inputs, ruleset)
 		self:initializeNextPiece(inputs, ruleset, data, false)
 	end
 	self.held = true
+	if ihs then playSE("ihs")
+	else playSE("hold") end
 	self:onHold()
 end
 
@@ -324,7 +402,8 @@ 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.big_mode
+		self.lock_drop, self.lock_hard_drop, self.big_mode,
+		self.irs
 	)
 	if self.lock_drop then
 		self.drop_locked = true
@@ -336,7 +415,7 @@ 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()
+	if config.gamesettings.next_se == 1 then self:playNextSound() end
 end
 
 function GameMode:playNextSound()
@@ -388,7 +467,7 @@ function GameMode:drawNextQueue(ruleset)
 			drawPiece(next_piece, skin, ruleset.block_offsets[next_piece][rotation], -16+i*80, -32)
 		end
 	end
-	if self.hold_queue ~= nil then
+	if self.hold_queue ~= nil and self.enable_hold then
 		local hold_color = self.held and 0.6 or 1
 		self:setHoldOpacity(1, hold_color)
 		drawPiece(
@@ -445,6 +524,10 @@ function GameMode:drawSectionTimes(current_section)
 	love.graphics.printf(formatTime(self.frames - self.section_start_time), section_x, 40 + 20 * current_section, 90, "left")
 end
 
+function GameMode:sectionColourFunction(section)
+	return { 1, 1, 1, 1 }
+end
+
 function GameMode:drawSectionTimesWithSecondary(current_section)
 	local section_x = 530
 	local section_secondary_x = 440
@@ -456,9 +539,11 @@ function GameMode:drawSectionTimesWithSecondary(current_section)
 	end
 
 	for section, time in pairs(self.secondary_section_times) do
+		love.graphics.setColor(self:sectionColourFunction(section))
 		if section > 0 then
 			love.graphics.printf(formatTime(time), section_secondary_x, 40 + 20 * section, 90, "left")
 		end
+		love.graphics.setColor(1, 1, 1, 1)
 	end
 
 	local current_x

tetris/modes/marathon_2020.lua

@@ -144,6 +144,7 @@ function Marathon2020Game:advanceOneFrame()
 		if self.roll_frames < 0 then
 			return false
 		elseif self.roll_frames > 4000 then
+			if self.grade >= 30 and self.section_cool_count >= 20 then self.grade = 31 end
 			self.completed = true
 		end
 	elseif self.ready_frames == 0 then
@@ -248,6 +249,7 @@ function Marathon2020Game:updateGrade(cleared_lines)
 end
 
 function Marathon2020Game:getTotalGrade()
+	if self.grade + self.section_cool_count > 50 then return "GM" end
 	return self.grade + self.section_cool_count
 end
 
@@ -325,10 +327,10 @@ function Marathon2020Game:checkClear(level)
 end
 
 function Marathon2020Game:updateSectionTimes(old_level, new_level)
-	function sectionCool()
+	function sectionCool(section)
 		self.section_cool_count = self.section_cool_count + 1
 		self.delay_level = math.min(20, self.delay_level + 1)
-		table.insert(self.section_status, "cool")
+		if section < 10 then table.insert(self.section_status, "cool") end
 		self.cool_timer = 300
 	end
 
@@ -346,7 +348,7 @@ function Marathon2020Game:updateSectionTimes(old_level, new_level)
 		table.insert(self.section_times, section_time)
 		self.section_start_time = self.frames
 
-		if section > 4 then self.delay_level = math.min(20, self.delay_level + 1) end
+		if section > 5 then self.delay_level = math.min(20, self.delay_level + 1) end
 		self:checkTorikan(section)
 		self:checkClear(new_level)
 
@@ -355,11 +357,11 @@ function Marathon2020Game:updateSectionTimes(old_level, new_level)
 			self.secondary_section_times[section] < self.secondary_section_times[section - 1] + 120 and
 			self.secondary_section_times[section] < cool_cutoffs[section]
 		) then
-			sectionCool()
+			sectionCool(section)
 		elseif self.section_status[section - 1] == "cool" then
 			table.insert(self.section_status, "none")
 		elseif section <= 19 and self.secondary_section_times[section] < cool_cutoffs[section] then
-			sectionCool()
+			sectionCool(section)
 		else
 			table.insert(self.section_status, "none")
 		end
@@ -392,7 +394,6 @@ Marathon2020Game.mRollOpacityFunction = function(age)
 end
 
 function Marathon2020Game:qualifiesForMRoll()
-	return false -- until I actually have grading working
 --[[
 
 GM-roll requirements
@@ -403,6 +404,8 @@ You qualify for the GM roll if you:
 - in less than 13:30.00 total.
 
 ]]--
+	
+	return self.level >= 2020 and self:getTotalGrade() == 50 and self.frames <= frameTime(13,30)
 end
 
 function Marathon2020Game:drawGrid()
@@ -420,6 +423,14 @@ function Marathon2020Game:drawGrid()
 	end
 end
 
+function Marathon2020Game:sectionColourFunction(section)
+	if self.section_status[section] == "cool" then
+		return { 0, 1, 0, 1 }
+	else
+		return { 1, 1, 1, 1 }
+	end
+end
+
 function Marathon2020Game:drawScoringInfo()
 	Marathon2020Game.super.drawScoringInfo(self)
 

tetris/modes/marathon_a2.lua

@@ -310,12 +310,12 @@ MarathonA2Game.mRollOpacityFunction = function(age)
 	else return 1 - age / 4 end
 end
 
-function MarathonA2Game:drawGrid(ruleset)
+function MarathonA2Game:drawGrid()
 	if self.clear and not (self.completed or self.game_over) then
 		if self:qualifiesForMRoll() then
-			self.grid:drawInvisible(self.mRollOpacityFunction)
+			self.grid:drawInvisible(self.mRollOpacityFunction, nil, false)
 		else
-			self.grid:drawInvisible(self.rollOpacityFunction)
+			self.grid:drawInvisible(self.rollOpacityFunction, nil, false)
 		end
 	else
 		self.grid:draw()

tetris/modes/marathon_a3.lua

@@ -231,8 +231,8 @@ function MarathonA3Game:updateSectionTimes(old_level, new_level)
 end
 
 function MarathonA3Game:updateScore(level, drop_bonus, cleared_lines)
+	self:updateGrade(cleared_lines)
 	if not self.clear then	
-		self:updateGrade(cleared_lines)
 		if cleared_lines > 0 then
 			self.combo = self.combo + (cleared_lines - 1) * 2
 			self.score = self.score + (
@@ -448,7 +448,7 @@ function MarathonA3Game:drawScoringInfo()
 	love.graphics.setFont(font_3x5_3)
 	love.graphics.printf(self.score, 240, 220, 90, "left")
 	if self.roll_frames > 3238 then love.graphics.setColor(1, 0.5, 0, 1)
-	elseif self.clear then love.graphics.setColor(0, 1, 0, 1) end
+	elseif self.level >= 999 and self.clear then love.graphics.setColor(0, 1, 0, 1) end
 	love.graphics.printf(self:getLetterGrade(), 240, 140, 90, "left")
 	love.graphics.setColor(1, 1, 1, 1)
 	love.graphics.printf(self.level, 240, 340, 40, "right")

tetris/modes/marathon_ax4.lua

@@ -146,7 +146,7 @@ function MarathonAX4Game:drawScoringInfo()
 		strTrueValues(self.prev_inputs)
 	)
 	love.graphics.printf("NEXT", 64, 40, 40, "left")
-	love.graphics.printf("TIME LEFT", 240, 250, 80, "left")
+	if self.lines < 150 then love.graphics.printf("TIME LEFT", 240, 250, 80, "left") end
 	love.graphics.printf("LINES", 240, 320, 40, "left")
 
 	local current_section = math.floor(self.lines / 10) + 1
@@ -161,7 +161,7 @@ function MarathonAX4Game:drawScoringInfo()
 	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")
+	if self.lines < 150 then love.graphics.printf(formatTime(time_left), 240, 270, 160, "left") end
 	love.graphics.setColor(1, 1, 1, 1)
 end
 

tetris/modes/phantom_mania.lua

@@ -139,7 +139,7 @@ end
 
 function PhantomManiaGame:drawGrid()
 	if not (self.game_over or self.clear) then
-		self.grid:drawInvisible(self.rollOpacityFunction)
+		self.grid:drawInvisible(self.rollOpacityFunction, nil, false)
 	else
 		self.grid:draw()
 	end

tetris/modes/phantom_mania2.lua

@@ -255,7 +255,7 @@ PhantomMania2Game.garbageOpacityFunction = function(age)
 end
 
 function PhantomMania2Game:drawGrid()
-	if not (self.game_over or (self.clear and self.level < 1300)) then
+	if not (self.game_over) then
 		self.grid:drawInvisible(self.rollOpacityFunction, self.garbageOpacityFunction)
 	else
 		self.grid:draw()
@@ -291,7 +291,7 @@ function PhantomMania2Game:setHoldOpacity()
 	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)
+		self.super:setHoldOpacity(1, self.held and 0.6 or 1)
 	end
 end
 

tetris/modes/phantom_mania_n.lua

@@ -0,0 +1,22 @@
+local PhantomManiaGame = require 'tetris.modes.phantom_mania'
+
+local PhantomManiaNGame = PhantomManiaGame:extend()
+
+PhantomManiaNGame.name = "Phantom Mania N"
+PhantomManiaNGame.hash = "PhantomManiaN"
+PhantomManiaNGame.tagline = "The old mode from Nullpomino, for Ti-ARS and SRS support."
+
+function PhantomManiaNGame:new()
+	PhantomManiaNGame.super:new()
+	
+	self.SGnames = {
+		"M1",  "M2",  "M3",  "M4",  "M5",  "M6",  "M7",  "M8",  "M9",
+		"M10", "M11", "M12", "M13", "M14", "M15", "M16", "M17", "M18",
+		"GM"
+	}
+
+	self.next_queue_length = 3
+	self.enable_hold = true
+end
+
+return PhantomManiaNGame

tetris/modes/survival_a2.lua

@@ -159,8 +159,9 @@ function SurvivalA2Game:drawScoringInfo()
 	love.graphics.setFont(font_3x5_3)
 	love.graphics.printf(self.score, text_x, 220, 90, "left")
 	if self.roll_frames > 2968 then love.graphics.setColor(1, 0.5, 0, 1)
-	elseif self.clear then love.graphics.setColor(0, 1, 0, 1) end
+	elseif self.level >= 999 and self.clear then love.graphics.setColor(0, 1, 0, 1) end
 	if self:getLetterGrade() ~= "" then love.graphics.printf(self:getLetterGrade(), text_x, 140, 90, "left") end
+	love.graphics.setColor(1, 1, 1, 1)
 	love.graphics.printf(self.level, text_x, 340, 40, "right")
 	love.graphics.printf(self:getSectionEndLevel(), text_x, 370, 40, "right")
 	if sg >= 5 then

tetris/modes/survival_a3.lua

@@ -243,7 +243,7 @@ function SurvivalA3Game:drawScoringInfo()
 
 	love.graphics.setFont(font_3x5_3)
 	if self.roll_frames > 3238 then love.graphics.setColor(1, 0.5, 0, 1)
-		elseif self.clear then love.graphics.setColor(0, 1, 0, 1) end
+		elseif self.level >= 1300 and self.clear then love.graphics.setColor(0, 1, 0, 1) end
 	love.graphics.printf(getLetterGrade(math.floor(self.grade)), text_x, 140, 90, "left")
 	love.graphics.setColor(1, 1, 1, 1)
 	love.graphics.printf(self.score, text_x, 220, 90, "left")

tetris/rulesets/arika.lua

@@ -97,11 +97,11 @@ function ARS:attemptWallkicks(piece, new_piece, rot_dir, grid)
 
 	-- kick right, kick left
 	if (grid:canPlacePiece(new_piece:withOffset({x=1, y=0}))) then
+		self:onPieceRotate(piece, grid)
 		piece:setRelativeRotation(rot_dir):setOffset({x=1, 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)
+		piece:setRelativeRotation(rot_dir):setOffset({x=-1, y=0})
 	end
 
 end
@@ -112,9 +112,9 @@ end
 
 function ARS:get180RotationValue() 
 	if config.gamesettings.world_reverse == 3 then
-		return 3
-	else
 		return 1
+	else
+		return 3
 	end
 end
 

tetris/rulesets/arika_ace.lua

@@ -1,5 +1,5 @@
 local Piece = require 'tetris.components.piece'
-local Ruleset = require 'tetris.rulesets.ruleset'
+local Ruleset = require 'tetris.rulesets.arika_ti'
 
 local ARS = Ruleset:extend()
 
@@ -39,137 +39,16 @@ ARS.big_spawn_positions = {
 	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 == 0
-		   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
+		if piece.manipulations >= 128 then
 			piece.locked = true
 		end
 	end
@@ -179,20 +58,13 @@ 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
+		if piece.manipulations >= 128 then
 			piece.locked = true
 		end
 	end
+	if piece.floorkick >= 1 then
+		piece.floorkick = piece.floorkick + 1
+	end
 end
 
-function ARS:get180RotationValue()
-	if config.gamesettings.world_reverse == 3 then
-		return 3
-	else
-		return 1
-    end
-end
-
-function ARS:getDefaultOrientation() return 3 end  -- downward facing pieces by default
-
 return ARS

tetris/rulesets/arika_ace2.lua

@@ -1,5 +1,5 @@
 local Piece = require 'tetris.components.piece'
-local Ruleset = require 'tetris.rulesets.ruleset'
+local Ruleset = require 'tetris.rulesets.arika_ti'
 
 local ARS = Ruleset:extend()
 
@@ -26,137 +26,16 @@ ARS.big_spawn_positions = {
 	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 == 0
-		   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
+		if piece.manipulations >= 128 then
 			piece.locked = true
 		end
 	end
@@ -166,20 +45,13 @@ 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
+		if piece.manipulations >= 128 then
 			piece.locked = true
 		end
 	end
+	if piece.floorkick >= 1 then
+		piece.floorkick = piece.floorkick + 1
+	end
 end
 
-function ARS:get180RotationValue() 
-	if config.gamesettings.world_reverse == 3 then
-		return 3
-	else
-		return 1
-    end
-end
-
-function ARS:getDefaultOrientation() return 3 end  -- downward facing pieces by default
-
 return ARS

tetris/rulesets/arika_srs.lua

@@ -1,22 +1,10 @@
 local Piece = require 'tetris.components.piece'
-local Ruleset = require 'tetris.rulesets.ruleset'
+local Ruleset = require 'tetris.rulesets.ti_srs'
 
 local SRS = Ruleset:extend()
 
 SRS.name = "ACE-SRS"
 SRS.hash = "ACE Standard"
-SRS.world = true
-SRS.colourscheme = {
-	I = "C",
-	L = "O",
-	J = "B",
-	S = "G",
-	Z = "R",
-	O = "Y",
-	T = "M",
-}
-SRS.softdrop_lock = false
-SRS.harddrop_lock = true
 
 SRS.spawn_positions = {
 	I = { x=5, y=2 },
@@ -38,137 +26,11 @@ SRS.big_spawn_positions = {
 	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= 1, y=-2}, {x=-2, y= 1}},
-		[2]={},
-		[3]={{x= 2, y= 0}, {x=-1, 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]={},
-	},
-	[2]={
-		[0]={},
-		[1]={{x=-2, y= 0}, {x= 1, y= 0}, {x=-2, y=-1}, {x= 1, y= 1}},
-		[3]={{x= 2, y= 0}, {x=-1, y= 0}, {x= 2, y=-1}, {x=-1, y= 1}},
-	},
-	[3]={
-		[0]={{x=-2, y= 0}, {x= 1, y= 0}, {x=-2, y=-1}, {x= 1, y= 2}},
-		[1]={},
-		[2]={{x= 1, y= 0}, {x=-2, y= 0}, {x= 1, y=-2}, {x=-2, y= 1}},
-	},
-};
-
--- 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
+		if piece.manipulations >= 128 then
 			piece.locked = true
 		end
 	end
@@ -178,18 +40,10 @@ 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
+		if piece.manipulations >= 128 then
 			piece.locked = true
 		end
 	end
 end
 
-function SRS:get180RotationValue() 
-	if config.gamesettings.world_reverse == 1 then
-		return 1
-	else
-		return 3
-	end
-end
-
 return SRS

tetris/rulesets/arika_ti.lua

@@ -1,77 +1,11 @@
 local Piece = require 'tetris.components.piece'
-local Ruleset = require 'tetris.rulesets.ruleset'
+local Ruleset = require 'tetris.rulesets.arika'
 
 local ARS = Ruleset:extend()
 
 ARS.name = "Ti-ARS"
 ARS.hash = "ArikaTI"
 
-ARS.spawn_positions = {
-	I = { x=5, y=4 },
-	J = { x=4, y=5 },
-	L = { x=4, y=5 },
-	O = { x=5, y=5 },
-	S = { x=4, y=5 },
-	T = { x=4, y=5 },
-	Z = { x=4, y=5 },
-}
-
-ARS.big_spawn_positions = {
-	I = { x=3, y=2 },
-	J = { x=2, y=3 },
-	L = { x=2, y=3 },
-	O = { x=3, y=3 },
-	S = { x=2, y=3 },
-	T = { x=2, y=3 },
-	Z = { x=2, y=3 },
-}
-
-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)
@@ -100,43 +34,48 @@ function ARS:attemptWallkicks(piece, new_piece, rot_dir, grid)
 
 	if piece.shape == "I" then
 		-- special kick rules for I
-		if new_piece.rotation == 0 or new_piece.rotation == 2 then
+		if (new_piece.rotation == 0 or new_piece.rotation == 2) and 
+		(piece:isMoveBlocked(grid, {x=-1, y=0}) or piece:isMoveBlocked(grid, {x=1, y=0})) then
 			-- kick right, right2, left
 			if grid:canPlacePiece(new_piece:withOffset({x=1, y=0})) then
+				self:onPieceRotate(piece, grid)
 				piece:setRelativeRotation(rot_dir):setOffset({x=1, y=0})
-				self:onPieceRotate(piece, grid)
 			elseif grid:canPlacePiece(new_piece:withOffset({x=2, y=0})) then
+				self:onPieceRotate(piece, grid)
 				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)
+				piece:setRelativeRotation(rot_dir):setOffset({x=-1, y=0})
 			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:setRelativeRotation(rot_dir):setOffset({x=0, y=-1})
 				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:setRelativeRotation(rot_dir):setOffset({x=0, y=-2})
 				piece.floorkick = 1
 			end
 		end
 	else
 		-- kick right, kick left
 		if grid:canPlacePiece(new_piece:withOffset({x=1, y=0})) then
+			self:onPieceRotate(piece, grid)
 			piece:setRelativeRotation(rot_dir):setOffset({x=1, y=0})
 		elseif grid:canPlacePiece(new_piece:withOffset({x=-1, y=0})) then
+			self:onPieceRotate(piece, grid)
 			piece:setRelativeRotation(rot_dir):setOffset({x=-1, y=0})
 		elseif piece.shape == "T"
 		   and new_piece.rotation == 0
 		   and piece.floorkick == 0
+		   and piece:isDropBlocked(grid)
 		   and grid:canPlacePiece(new_piece:withOffset({x=0, y=-1}))
 		then
 			-- T floorkick
 			piece.floorkick = piece.floorkick + 1
+			self:onPieceRotate(piece, grid)
 			piece:setRelativeRotation(rot_dir):setOffset({x=0, y=-1})
 		end
 	end
@@ -149,16 +88,15 @@ end
 
 function ARS:onPieceDrop(piece, grid)
 	piece.lock_delay = 0 -- step reset
-end
+	if piece.floorkick >= 2 and piece:isDropBlocked(grid) then
-
+		piece.locked = true
-function ARS:get180RotationValue() 
-	if config.gamesettings.world_reverse == 3 then
-		return 3
-	else
-		return 1
 	end
 end
 
-function ARS:getDefaultOrientation() return 3 end  -- downward facing pieces by default
+function ARS:onPieceRotate(piece, grid)
+	if piece.floorkick >= 1 then
+		piece.floorkick = piece.floorkick + 1
+	end
+end
 
 return ARS

tetris/rulesets/cambridge.lua

@@ -384,9 +384,9 @@ function CRS:attemptWallkicks(piece, new_piece, rot_dir, grid)
 	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)
-			self:onPieceRotate(piece, grid)
 			return
 		end
 	end

tetris/rulesets/ruleset.lua

@@ -21,6 +21,7 @@ Ruleset.softdrop_lock = true
 Ruleset.harddrop_lock = false
 
 Ruleset.enable_IRS_wallkicks = false
+Ruleset.are_cancel = false
 
 -- Component functions.
 
@@ -114,8 +115,8 @@ function Ruleset:attemptRotate(new_inputs, piece, grid, initial)
 	local new_piece = piece:withRelativeRotation(rot_dir)
 
 	if (grid:canPlacePiece(new_piece)) then
-		piece:setRelativeRotation(rot_dir)
 		self:onPieceRotate(piece, grid)
+		piece:setRelativeRotation(rot_dir)
 	else
 		if not(initial and self.enable_IRS_wallkicks == false) then
 			self:attemptWallkicks(piece, new_piece, rot_dir, grid)
@@ -127,16 +128,16 @@ function Ruleset:attemptWallkicks(piece, new_piece, rot_dir, grid)
 	-- do nothing in default ruleset
 end
 
-function Ruleset:movePiece(piece, grid, move)
+function Ruleset:movePiece(piece, grid, move, instant)
 	local x = piece.position.x
 	if move == "left" then
-		piece:moveInGrid({x=-1, y=0}, 1, grid)
+		piece:moveInGrid({x=-1, y=0}, 1, grid, false)
-	elseif move == "speedleft" then
-		piece:moveInGrid({x=-1, y=0}, 10, grid)
 	elseif move == "right" then
-		piece:moveInGrid({x=1, y=0}, 1, grid)
+		piece:moveInGrid({x=1, y=0}, 1, grid, false)
+	elseif move == "speedleft" then
+		piece:moveInGrid({x=-1, y=0}, 10, grid, instant)
 	elseif move == "speedright" then
-		piece:moveInGrid({x=1, y=0}, 10, grid)
+		piece:moveInGrid({x=1, y=0}, 10, grid, instant)
 	end
 	if piece.position.x ~= x then
 		self:onPieceMove(piece, grid)
@@ -180,7 +181,7 @@ 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
+	drop_locked, hard_drop_locked, big, irs
 )
 	local spawn_positions
 	if big then
@@ -196,7 +197,14 @@ function Ruleset:initializePiece(
 	}, self.block_offsets, 0, 0, data.skin, colours[data.shape], big)
 
 	self:onPieceCreate(piece)
-	self:rotatePiece(inputs, piece, grid, {}, true)
+	if irs then
+		if inputs.rotate_left or inputs.rotate_left2 or
+		   inputs.rotate_right or inputs.rotate_right2 or
+		   inputs.rotate_180 then
+			playSE("irs")
+		end
+		self:rotatePiece(inputs, piece, grid, {}, true)
+	end
 	self:dropPiece(inputs, piece, grid, gravity, drop_speed, drop_locked, hard_drop_locked)
 	return piece
 end
@@ -210,8 +218,16 @@ function Ruleset:processPiece(
 	drop_locked, hard_drop_locked,
 	hard_drop_enabled, additive_gravity
 )
-	self:rotatePiece(inputs, piece, grid, prev_inputs, false)
+
-	self:movePiece(piece, grid, move)
+	local synchroes_allowed = ({not self.world, true, false})[config.gamesettings.synchroes_allowed]
+
+	if synchroes_allowed then
+		self:rotatePiece(inputs, piece, grid, prev_inputs, false)
+		self:movePiece(piece, grid, move, gravity >= 20)
+	else
+		self:movePiece(piece, grid, move, gravity >= 20)
+		self:rotatePiece(inputs, piece, grid, prev_inputs, false)
+	end
 	self:dropPiece(
 		inputs, piece, grid, gravity, drop_speed, drop_locked, hard_drop_locked,
 		hard_drop_enabled, additive_gravity

tetris/rulesets/standard_exp.lua

@@ -1,112 +1,22 @@
 local Piece = require 'tetris.components.piece'
-local Ruleset = require 'tetris.rulesets.ruleset'
+local Ruleset = require 'tetris.rulesets.arika_srs'
 
 local SRS = Ruleset:extend()
 
 SRS.name = "Guideline SRS"
 SRS.hash = "Standard"
-SRS.world = true
-SRS.colourscheme = {
-	I = "C",
-	L = "O",
-	J = "B",
-	S = "G",
-	Z = "R",
-	O = "Y",
-	T = "M",
-}
-SRS.softdrop_lock = false
-SRS.harddrop_lock = true
 
 SRS.enable_IRS_wallkicks = true
 
-SRS.spawn_positions = {
+function SRS:check_new_low(piece)
-	I = { x=5, y=2 },
+	for _, block in pairs(piece:getBlockOffsets()) do
-	J = { x=4, y=3 },
+		local y = piece.position.y + block.y
-	L = { x=4, y=3 },
+		if y > piece.lowest_y then
-	O = { x=5, y=3 },
+			piece.manipulations = 0
-	S = { x=4, y=3 },
+			piece.lowest_y = y
-	T = { x=4, y=3 },
+		end
-	Z = { x=4, y=3 },
+	end
-}
+end
-
-SRS.big_spawn_positions = {
-	I = { x=3, y=0 },
-	J = { x=2, y=1 },
-	L = { x=2, y=1 },
-	O = { x=3, 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]={
@@ -131,16 +41,6 @@ SRS.wallkicks_line = {
 	},
 };
 
-function SRS:check_new_low(piece)
-	for _, block in pairs(piece:getBlockOffsets()) do
-		local y = piece.position.y + block.y
-		if y > piece.lowest_y then
-			piece.manipulations = 0
-			piece.lowest_y = y
-		end
-	end
-end
-
 -- Component functions.
 
 function SRS:attemptWallkicks(piece, new_piece, rot_dir, grid)
@@ -203,4 +103,6 @@ function SRS:onPieceRotate(piece, grid)
 	end
 end
 
+function SRS:get180RotationValue() return 2 end
+
 return SRS

tetris/rulesets/ti_srs.lua

@@ -147,9 +147,9 @@ function SRS:attemptWallkicks(piece, new_piece, rot_dir, grid)
 	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)
-			self:onPieceRotate(piece, grid)
 			return
 		end
 	end