afterLineClear func added and splits time draw fix

it's already handled by the rulesets anyhow

README.md

@@ -1,11 +1,11 @@
-![Cambridge Banner](https://cdn.discordapp.com/attachments/764432435802013709/767724895076614154/cambridge_logo_lt.png)
+![Cambridge Banner](https://t-sp.in/public/img/cambridge.png)
 
 Cambridge
 =========
 
 Welcome to Cambridge, the next open-source falling-block game engine!
 
-This fork is written and maintained exclusively by [SashLilac](https://github.com/SashLilac), [joezeng](https://github.com/joezeng) and [Oshisaure](https://github.com/oshisaure)!
+The project is written and maintained exclusively by [SashLilac](https://github.com/SashLilac), [joezeng](https://github.com/joezeng) and [Oshisaure](https://github.com/oshisaure)!
 
 Join our Discord server for help and a welcoming community! https://discord.gg/mteMJw4
 
@@ -40,7 +40,13 @@ Playing the game
 
 You do not need LÖVE on Windows, as it comes bundled with the program.  
 
-To get the stable release, simply download the ZIP in the latest release. All assets needed are bundled with the executable.
+#### Stable release
+
+To get the stable release, simply download either `cambridge-win32.zip` (32-bit) or `cambridge-windows.zip` (64-bit) in the [latest release](https://github.com/sashlilac/cambridge/releases/latest).  
+
+All assets needed are bundled with the executable.
+
+#### Bleeding edge
 
 If you want the bleeding edge version, download [this](https://github.com/SashLilac/cambridge/archive/master.zip).
 
@@ -82,13 +88,7 @@ It should run automatically!
 
 ## Installing modpacks
 
-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.
+For instructions on how to install modpacks, go to [this](https://github.com/SashLilac/cambridge-modpack) mod pack to get a taste of the mod potential.
 
 License
 -------

libs/bigint/bigint.lua

@@ -55,14 +55,8 @@ function bigint.new(num)
         __pow = function(lhs, rhs)
             return bigint.exponentiate(lhs, rhs)
         end,
-        __eq = function(lhs, rhs)
-            return bigint.compare(lhs, rhs, "==")
-        end,
-        __lt = function(lhs, rhs)
-            return bigint.compare(lhs, rhs, "<")
-        end,
-        __le = function(lhs, rhs)
-            return bigint.compare(lhs, rhs, "<=")
+        __tostring = function()
+            return bigint.unserialize(self, "s")
         end
     })
 
@@ -88,7 +82,8 @@ function bigint.check(big, force)
         assert(type(big.sign) == "string", "bigint is unsigned")
         for _, digit in pairs(big.digits) do
             assert(type(digit) == "number", digit .. " is not a number")
-            assert(digit < 10, digit .. " is greater than or equal to 10")
+            assert(digit <= 9 and digit >= 0, digit .. " is not between 0 and 9")
+            assert(math.floor(digit) == digit, digit .. " is not an integer")
         end
     end
     return true
@@ -103,6 +98,12 @@ function bigint.abs(big)
     return result
 end
 
+-- Return the number of digits in the big
+function bigint.digits(big)
+    bigint.check(big)
+    return #big.digits
+end
+
 -- Convert a big to a number or string
 function bigint.unserialize(big, output_type, precision)
     bigint.check(big)
@@ -137,7 +138,7 @@ function bigint.unserialize(big, output_type, precision)
         -- Unserialization to human-readable form or scientific notation only
         -- requires reading the first few digits
         if (precision == nil) then
-            precision = 3
+            precision = math.min(#big.digits, 3)
         else
             assert(precision > 0, "Precision cannot be less than 1")
             assert(math.floor(precision) == precision,
@@ -146,17 +147,18 @@ function bigint.unserialize(big, output_type, precision)
 
         -- num is the first (precision + 1) digits, the first being separated by
         -- a decimal point from the others
-        num = num .. big.digits[1]
+        num = num .. math.floor(big.digits[1])
         if (precision > 1) then
             num = num .. "."
             for i = 1, (precision - 1) do
-                num = num .. big.digits[i + 1]
+                num = num .. math.floor(big.digits[i + 1])
             end
         end
 
         if ((output_type == "human-readable")
         or (output_type == "human")
-        or (output_type == "h")) then
+        or (output_type == "h"))
+        and (#big.digits >= 3 and #big.digits <= 10002) then
             -- Human-readable output contributed by 123eee555
 
             local name
@@ -435,7 +437,6 @@ function bigint.multiply(big1, big2)
     return result
 end
 
-
 -- Raise a big to a positive integer or big power (TODO: negative integer power)
 function bigint.exponentiate(big, power)
     -- Type checking for big done by bigint.multiply
@@ -446,13 +447,23 @@ function bigint.exponentiate(big, power)
     if (bigint.compare(exp, bigint.new(0), "==")) then
         return bigint.new(1)
     elseif (bigint.compare(exp, bigint.new(1), "==")) then
-        return big
+        return big:clone()
     else
-        local result = big:clone()
+        local result = bigint.new(1)
+        local base = big:clone()
 
-        while (bigint.compare(exp, bigint.new(1), ">")) do
-            result = bigint.multiply(result, big)
-            exp = bigint.subtract(exp, bigint.new(1))
+        while (true) do
+            if (bigint.compare(
+                bigint.modulus(exp, bigint.new(2)), bigint.new(1), "=="
+            )) then
+                result = bigint.multiply(result, base)
+            end
+            if (bigint.compare(exp, bigint.new(1), "==")) then
+                break
+            else
+                exp = bigint.divide(exp, bigint.new(2))
+                base = bigint.multiply(base, base)
+            end
         end
 
         return result
@@ -468,7 +479,7 @@ function bigint.divide_raw(big1, big2)
     if (bigint.compare(big1, big2, "==")) then
         return bigint.new(1), bigint.new(0)
     elseif (bigint.compare(big1, big2, "<")) then
-        return bigint.new(0), bigint.new(0)
+        return bigint.new(0), big1:clone()
     else
         assert(bigint.compare(big2, bigint.new(0), "!="), "error: divide by zero")
         assert(big1.sign == "+", "error: big1 is not positive")
@@ -476,54 +487,35 @@ function bigint.divide_raw(big1, big2)
 
         local result = bigint.new()
 
-        local dividend = bigint.new() -- Dividend of a single operation, not the
-                                      -- dividend of the overall function
-        local divisor = big2:clone()
-        local factor = 1
+        local dividend = bigint.new() -- Dividend of a single operation
 
-        -- Walk left to right among digits in the dividend, like in long
-        -- division
-        for _, digit in pairs(big1.digits) do
-            dividend.digits[#dividend.digits + 1] = digit
+        local neg_zero = bigint.new(0)
+        neg_zero.sign = "-"
 
-            -- The dividend is smaller than the divisor, so a zero is appended
-            -- to the result and the loop ends
-            if (bigint.compare(dividend, divisor, "<")) then
-                if (#result.digits > 0) then -- Don't add leading zeroes
-                    result.digits[#result.digits + 1] = 0
-                end
-            else
-                -- Find the maximum number of divisors that fit into the
-                -- dividend
-                factor = 0
-                while (bigint.compare(divisor, dividend, "<=")) do
-                    divisor = bigint.add(divisor, big2)
-                    factor = factor + 1
+        for i = 1, #big1.digits do
+            -- Fixes a negative zero bug
+            if (#dividend.digits ~= 0) and (bigint.compare(dividend, neg_zero, "==")) then
+                dividend = bigint.new()
             end
             
-                -- Append the factor to the result
-                if (factor == 10) then
-                    -- Fixes a weird bug that introduces a new bug if fixed by
-                    -- changing the comparison in the while loop to "<="
-                    result.digits[#result.digits] = 1
-                    result.digits[#result.digits + 1] = 0
-                else
-                    result.digits[#result.digits + 1] = factor
+            table.insert(dividend.digits, big1.digits[i])
+            
+            local factor = bigint.new(0)
+            while bigint.compare(dividend, big2, ">=") do
+                dividend = bigint.subtract(dividend, big2)
+                factor = bigint.add(factor, bigint.new(1))
             end
 
-                -- Subtract the divisor from the dividend to obtain the
-                -- remainder, which is the new dividend for the next loop
-                dividend = bigint.subtract(dividend,
-                                           bigint.subtract(divisor, big2))
-
-                -- Reset the divisor
-                divisor = big2:clone()
+            for i = 0, #factor.digits - 1 do
+                result.digits[#result.digits + 1 - i] = factor.digits[i + 1]
+            end
         end
 
+        -- Remove leading zeros from result
+        while (result.digits[1] == 0) do
+            table.remove(result.digits, 1)
         end
 
-        -- The remainder of the final loop is returned as the function's
-        -- overall remainder
         return result, dividend
     end
 end

scene/game.lua

@@ -83,6 +83,7 @@ function GameScene:render()
 	end
 
 	self.game:drawGrid()
+	if self.game.lcd > 0 then self.game:drawLineClearAnimation() end
 	self.game:drawPiece()
 	self.game:drawNextQueue(self.ruleset)
 	self.game:drawScoringInfo()

scene/game_config.lua

@@ -11,7 +11,7 @@ ConfigScene.options = {
 	{"manlock", "Manual Locking", false, {"Per ruleset", "Per gamemode", "Harddrop", "Softdrop"}},
 	{"piece_colour", "Piece Colours", false, {"Per ruleset", "Arika", "TTC"}},
 	{"world_reverse", "A Button Rotation", false, {"Left", "Auto", "Right"}},
-	{"spawn_positions", "Spawn Positions", false, {"In field", "Out of field"}},
+	{"spawn_positions", "Spawn Positions", false, {"Per ruleset", "In field", "Out of field"}},
 	{"display_gamemode", "Display Gamemode", false, {"On", "Off"}},
 	{"das_last_key", "DAS Switch", false, {"Default", "Instant"}},
 	{"smooth_movement", "Smooth Piece Drop", false, {"On", "Off"}},
@@ -103,7 +103,7 @@ function ConfigScene:onInputPress(e)
 		else
 			playSE("cursor")
 			sld = self[self.options[self.highlight][4]]
-			sld.value = math.max(sld.min, math.min(sld.max, (sld:getValue() - 3) / (sld.max - sld.min)))
+			sld.value = math.max(sld.min, math.min(sld.max, (sld:getValue() - 5) / (sld.max - sld.min)))
 		end
 	elseif e.input == "right" or e.scancode == "right" then
 		if not self.options[self.highlight][3] then
@@ -113,7 +113,7 @@ function ConfigScene:onInputPress(e)
 		else
 			playSE("cursor")
 			sld = self[self.options[self.highlight][4]]
-			sld.value = math.max(sld.min, math.min(sld.max, (sld:getValue() + 3) / (sld.max - sld.min)))--math.max(0, (math.floor(sld:getValue())+2)/(sld.max-sld.min))
+			sld.value = math.max(sld.min, math.min(sld.max, (sld:getValue() + 5) / (sld.max - sld.min)))--math.max(0, (math.floor(sld:getValue())+2)/(sld.max-sld.min))
 		end
 	elseif e.input == "menu_back" or e.scancode == "delete" or e.scancode == "backspace" then
 		loadSave()

tetris/components/grid.lua

@@ -111,18 +111,24 @@ function Grid:getClearedRowCount()
 end
 
 function Grid:markClearedRows()
+	local block_table = {}
 	for row = 1, self.height do
 		if self:isRowFull(row) then
+			block_table[row] = {}
 			for x = 1, self.width do
+				block_table[row][x] = {
+					skin = self.grid[row][x].skin,
+					colour = self.grid[row][x].colour,
+				}
 				self.grid[row][x] = {
 					skin = self.grid[row][x].skin,
 					colour = "X"
 				}
-				self.grid_age[row][x] = 0
+				--self.grid_age[row][x] = 0
 			end
 		end
 	end
-	return true
+	return block_table
 end
 
 function Grid:clearClearedRows()
@@ -388,7 +394,8 @@ end
 function Grid:draw()
 	for y = 5, self.height do
 		for x = 1, self.width do
-			if self.grid[y][x] ~= empty then
+			if blocks[self.grid[y][x].skin] and
+			blocks[self.grid[y][x].skin][self.grid[y][x].colour] then
 				if self.grid_age[y][x] < 2 then
 					love.graphics.setColor(1, 1, 1, 1)
 					love.graphics.draw(blocks[self.grid[y][x].skin]["F"], 48+x*16, y*16)
@@ -396,7 +403,8 @@ function Grid:draw()
 					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)
+						love.graphics.setColor(0, 0, 0, 0)
+						--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
@@ -427,10 +435,12 @@ end
 function Grid:drawOutline()
 	for y = 5, self.height do
 		for x = 1, self.width do
+			--[[
 			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)
@@ -459,7 +469,8 @@ function Grid:drawInvisible(opacity_function, garbage_opacity_function, lock_fla
 		for x = 1, self.width do
 			if self.grid[y][x] ~= empty then
 				if self.grid[y][x].colour == "X" then
-					opacity = 1 - self.grid_age[y][x] / 15
+					opacity = 0
+					--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
@@ -506,7 +517,8 @@ function Grid:drawCustom(colour_function, gamestate)
 			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
+					A = 0
+					--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)

tetris/components/piece.lua

@@ -104,9 +104,8 @@ function Piece:dropToBottom(grid)
 	self:dropSquares(math.huge, grid)
 	self.gravity = 0
 	if self.position.y > piece_y then
-		-- if it got dropped any, also reset lock delay
 		if self.ghost == false then playSE("bottom") end
-		self.lock_delay = 0
+		-- self.lock_delay = 0
 	end
 	return self
 end

tetris/modes/gamemode.lua

@@ -45,6 +45,7 @@ function GameMode:new(secret_inputs)
 	self.enable_hard_drop = true
 	self.next_queue_length = 1
 	self.additive_gravity = true
+	self.classic_lock = false
 	self.draw_section_times = false
 	self.draw_secondary_section_times = false
 	self.big_mode = false
@@ -63,6 +64,7 @@ function GameMode:new(secret_inputs)
 	self.hard_drop_locked = false
 	self.lock_on_soft_drop = false
 	self.lock_on_hard_drop = false
+	self.cleared_block_table = {}
 	self.used_randomizer = nil
 	self.hold_queue = nil
 	self.held = false
@@ -177,11 +179,15 @@ function GameMode:update(inputs, ruleset)
 			return
 		end
 
-		if self.lock_drop and inputs["down"] ~= true then
+		if (self.lock_drop or (
+			not ruleset.are or self:getARE() == 0
+		)) and inputs["down"] ~= true then
 			self.drop_locked = false
 		end
 
-		if self.lock_hard_drop and inputs["up"] ~= true then
+		if (self.lock_hard_drop or (
+			not ruleset.are or self:getARE() == 0
+		)) and inputs["up"] ~= true then
 			self.hard_drop_locked = false
 		end
 
@@ -193,7 +199,7 @@ function GameMode:update(inputs, ruleset)
 			inputs, self.piece, self.grid, self:getGravity(), self.prev_inputs,
 			self.move, self:getLockDelay(), self:getDropSpeed(),
 			self.drop_locked, self.hard_drop_locked,
-			self.enable_hard_drop, self.additive_gravity
+			self.enable_hard_drop, self.additive_gravity, self.classic_lock
 		)
 
 		local piece_dy = self.piece.position.y - piece_y
@@ -244,7 +250,7 @@ function GameMode:update(inputs, ruleset)
 			self:onPieceLock(self.piece, cleared_row_count)
 			self:updateScore(self.level, self.drop_bonus, cleared_row_count)
 
-			self.grid:markClearedRows()
+			self.cleared_block_table = self.grid:markClearedRows()
 			self.piece = nil
 			if self.enable_hold then
 				self.held = false
@@ -258,6 +264,7 @@ function GameMode:update(inputs, ruleset)
 				)
 				if self.lcd == 0 then
 					self.grid:clearClearedRows()
+					self:afterLineClear(cleared_row_count)
 					if self.are == 0 then
 						self:initializeOrHold(inputs, ruleset)
 					end
@@ -294,6 +301,7 @@ function GameMode:onPieceLock(piece, cleared_row_count)
 end
 
 function GameMode:onLineClear(cleared_row_count) end
+function GameMode:afterLineClear(cleared_row_count) end
 
 function GameMode:onPieceEnter() end
 function GameMode:onHold() end
@@ -425,7 +433,9 @@ function GameMode:processDelays(inputs, ruleset, drop_speed)
 		self.lcd = self.lcd - 1
 		self:areCancel(inputs, ruleset)
 		if self.lcd == 0 then
+			local cleared_row_count = self.grid:getClearedRowCount()
 			self.grid:clearClearedRows()
+			self:afterLineClear(cleared_row_count)
 			playSE("fall")
 			if self.are == 0 then
 				self:initializeOrHold(inputs, ruleset)
@@ -513,10 +523,14 @@ function GameMode:initializeNextPiece(inputs, ruleset, piece_data, generate_next
 	if self.buffer_soft_drop then
 		self.buffer_soft_drop = false
 	end
-	if self.lock_drop then
+	if self.lock_drop or (
+		not ruleset.are or self:getARE() == 0
+	) then
 		self.drop_locked = true
 	end
-	if self.lock_hard_drop then
+	if self.lock_hard_drop or (
+		not ruleset.are or self:getARE() == 0
+	) then
 		self.hard_drop_locked = true
 	end
 	if generate_next_piece == nil then
@@ -536,14 +550,87 @@ function GameMode:getHighScoreData()
 	}
 end
 
+function GameMode:animation(x, y, skin, colour)
+	return {
+		1, 1, 1,
+		-0.25 + 1.25 * (self.lcd / self:getLineClearDelay()),
+		skin, colour,
+		48 + x * 16, y * 16
+	}
+end
+
+function GameMode:drawLineClearAnimation()
+	-- animation function
+	-- params: block x, y, skin, colour
+	-- returns: table with RGBA, skin, colour, x, y
+	
+	-- Fadeout (default)
+	--[[
+	function animation(x, y, skin, colour)
+		return {
+			1, 1, 1,
+			-0.25 + 1.25 * (self.lcd / self:getLineClearDelay()),
+			skin, colour,
+			48 + x * 16, y * 16
+		}
+	end
+	--]]
+
+	-- Flash
+	--[[
+	function animation(x, y, skin, colour)
+		return {
+			1, 1, 1,
+			self.lcd % 6 < 3 and 1 or 0.25,
+			skin, colour,
+			48 + x * 16, y * 16
+		}
+	end
+	--]]
+
+	-- TGM1 pop-out
+	--[[
+	function animation(x, y, skin, colour)
+		local p = 0.5
+		local l = (
+			(self:getLineClearDelay() - self.lcd) / self:getLineClearDelay()
+		)
+		local dx = l * (x - (1 + self.grid.width) / 2)
+		local dy = l * (y - (1 + self.grid.height) / 2)
+		return {
+			1, 1, 1, 1, skin, colour,
+			48 + (x + dx) * 16,
+			(y + dy) * 16 + (464 / (p - 1)) * l * (p - l)
+		}
+	end
+	--]]
+
+	for y, row in pairs(self.cleared_block_table) do
+		for x, block in pairs(row) do
+			local animation_table = self:animation(x, y, block.skin, block.colour)
+			love.graphics.setColor(
+				animation_table[1], animation_table[2],
+				animation_table[3], animation_table[4]
+			)
+			love.graphics.draw(
+				blocks[animation_table[5]][animation_table[6]],
+				animation_table[7], animation_table[8]
+			)
+		end
+	end
+end
+
 function GameMode:drawPiece()
 	if self.piece ~= nil then
-		self.piece:draw(
-			1,
-			self:getLockDelay() == 0 and 1 or
-			(0.25 + 0.75 * math.max(1 - self.piece.gravity, 1 - (self.piece.lock_delay / self:getLockDelay()))),
-			self.grid
+		local b = (
+			self.classic_lock and
+			(
+				self.piece:isDropBlocked(self.grid) and
+				1 - self.piece.gravity or 1
+			) or
+			1 - (self.piece.lock_delay / self:getLockDelay())
 		)
+		self.piece:draw(1, 0.25 + 0.75 * b, self.grid)
 	end
 end
 
@@ -676,7 +763,9 @@ function GameMode:drawSectionTimesWithSecondary(current_section, section_limit)
 	end
 end
 
-function GameMode:drawSectionTimesWithSplits(current_section)
+function GameMode:drawSectionTimesWithSplits(current_section, section_limit)
+	section_limit = section_limit or math.huge
+	
 	local section_x = 440
 	local split_x = 530
 
@@ -690,9 +779,12 @@ function GameMode:drawSectionTimesWithSplits(current_section)
 		end
 	end
 	
+	if (current_section <= section_limit) then
+		love.graphics.setColor(self:sectionColourFunction(current_section))
 		love.graphics.printf(formatTime(self.frames - self.section_start_time), section_x, 40 + 20 * current_section, 90, "left")
 		love.graphics.printf(formatTime(self.frames), split_x, 40 + 20 * current_section, 90, "left")
 	end
+end
 
 function GameMode:drawCustom() end
 

tetris/modes/marathon_a2.lua

@@ -171,7 +171,6 @@ function MarathonA2Game:updateSectionTimes(old_level, new_level)
 		self.section_start_time = self.frames
 		self.section_tetrises[math.floor(old_level / 100)] = self.tetris_count
 		self.tetris_count = 0
-		print(self.section_tetrises[math.floor(old_level / 100)])
 	end
 end
 

tetris/rulesets/arika_ace.lua

@@ -18,6 +18,7 @@ ARS.colourscheme = {
 
 ARS.softdrop_lock = false
 ARS.harddrop_lock = true
+ARS.spawn_above_field = true
 
 function ARS:onPieceCreate(piece, grid)
 	piece.floorkick = 0

tetris/rulesets/arika_ace2.lua

@@ -5,6 +5,7 @@ local ARS = Ruleset:extend()
 
 ARS.name = "ACE-ARS2"
 ARS.hash = "ArikaACE2"
+ARS.spawn_above_field = true
 
 function ARS:onPieceCreate(piece, grid)
 	piece.floorkick = 0

tetris/rulesets/arika_srs.lua

@@ -17,6 +17,7 @@ SRS.colourscheme = {
 }
 SRS.softdrop_lock = false
 SRS.harddrop_lock = true
+SRS.spawn_above_field = true
 
 SRS.MANIPULATIONS_MAX = 128
 

tetris/rulesets/ruleset.lua

@@ -23,6 +23,7 @@ Ruleset.harddrop_lock = false
 Ruleset.enable_IRS_wallkicks = false
 Ruleset.are_cancel = false
 Ruleset.are = true
+Ruleset.spawn_above_field = false
 
 Ruleset.next_sounds = {
 		I = "I",
@@ -208,8 +209,11 @@ function Ruleset:dropPiece(
 	end
 end
 
-function Ruleset:lockPiece(piece, grid, lock_delay)
-	if piece:isDropBlocked(grid) and piece.gravity >= 1 and piece.lock_delay >= lock_delay then
+function Ruleset:lockPiece(piece, grid, lock_delay, classic_lock)
+	if piece:isDropBlocked(grid) and (
+		(classic_lock and piece.gravity >= 1) or
+		(not classic_lock and piece.lock_delay >= lock_delay)
+	) then
 		piece.locked = true
 	end
 end
@@ -243,10 +247,17 @@ function Ruleset:initializePiece(
 		end
 	end
 
-	local spawn_dy = (
-		config.gamesettings.spawn_positions == 2 and
+	local spawn_dy
+	if (config.gamesettings.spawn_positions == 1) then
+		spawn_dy = (
+			self.spawn_above_field and 2 or 0
+		)
+	else
+		spawn_dy = (
+			config.gamesettings.spawn_positions == 3 and
 			2 or 0
 		)
+	end
 
 	local piece = Piece(data.shape, data.orientation - 1, {
 		x = spawn_x and spawn_x or spawn_positions[data.shape].x,
@@ -278,7 +289,7 @@ function Ruleset:processPiece(
 	inputs, piece, grid, gravity, prev_inputs,
 	move, lock_delay, drop_speed,
 	drop_locked, hard_drop_locked,
-	hard_drop_enabled, additive_gravity
+	hard_drop_enabled, additive_gravity, classic_lock
 )
 
 	local synchroes_allowed = ({not self.world, true, false})[config.gamesettings.synchroes_allowed]
@@ -294,7 +305,7 @@ function Ruleset:processPiece(
 		inputs, piece, grid, gravity, drop_speed, drop_locked, hard_drop_locked,
 		hard_drop_enabled, additive_gravity
 	)
-	self:lockPiece(piece, grid, lock_delay)
+	self:lockPiece(piece, grid, lock_delay, classic_lock)
 end
 
 function Ruleset:onPieceMove(piece) end