tetris/modes/speed.lua

@@ -14,9 +14,9 @@ function LudicrousSpeed:new()
     self.super:new()
 
     self.time_limit = 300
-    self.delays = {}
+    self.pps = {}
-    self.last_piece = 0
     self.pps_limit = 1
+    self.pieces = 0
 
     self.randomizer = Bag7Randomizer()
 
@@ -28,16 +28,6 @@ function LudicrousSpeed:new()
     self.next_queue_length = 6
 end
 
-local function mean(t)
-    local sum = 0
-    
-    for _, v in ipairs(t) do
-        sum = sum + v
-    end
-
-    return sum / #t
-end
-
 function LudicrousSpeed:getGravity()
     if self.lines < 180 then
         return (0.8 - (math.floor(self.lines / 10) * 0.007)) ^ -math.floor(self.lines / 10) / 60
@@ -52,31 +42,41 @@ function LudicrousSpeed:getARR() return config.arr end
 function LudicrousSpeed:getDasCutDelay() return config.dcd end
 function LudicrousSpeed:getDropSpeed() return 20 end
 
-function LudicrousSpeed:getPPS()
+local function mean(t)
-    if #self.delays == 0 then return 0 end
+    local sum = 0
-    local delays = copy(self.delays)
+    local count = 0
-    delays[#delays + 1] = self.frames - self.last_piece
+  
-    return (mean(delays) / 60) ^ -1
+    for k, v in pairs(t) do
+        if type(v) == 'number' then
+            sum = sum + v
+            count = count + 1
+        end
+    end
+
+    return (sum / count)
 end
 
 function LudicrousSpeed:advanceOneFrame()
     if self.ready_frames == 0 then
         self.frames = self.frames + 1
-        if self:getPPS() < self.pps_limit then
+        if mean(self.pps) * 60 < self.pps_limit then
             self.time_limit = self.time_limit - 1
             self.game_over = self.time_limit <= 0
         else self.time_limit = 300 end
+        if self.frames ~= 0 then
+            if table.getn(self.pps) == 750 then
+                table.remove(self.pps, 1)
+                table.insert(self.pps, self.pieces)
+            else table.insert(self.pps, self.pieces) end
+            self.pieces = 0
+        end
     end
     return true
 end
 
-function LudicrousSpeed:onPieceLock(...)
+function LudicrousSpeed:onPieceLock()
-    self.super:onPieceLock(...)
+    self.super:onPieceLock()
-    self.delays[#self.delays + 1] = self.frames - self.last_piece
+    self.pieces = self.pieces + 1
-    if #self.delays >= 25 then
-        table.remove(self.delays, 1)
-    end
-    self.last_piece = self.frames
 end
 
 function LudicrousSpeed:onLineClear(cleared_row_count)
@@ -114,7 +114,7 @@ function LudicrousSpeed:drawScoringInfo()
     
     love.graphics.setFont(font_3x5_3)
 	love.graphics.printf(self.lines, text_x, 140, 80, "left")
-    love.graphics.printf(string.format("%.02f", self:getPPS()), text_x, 200, 80, "left")
+    love.graphics.printf(string.format("%.02f", self.frames > 0 and mean(self.pps) * 60 or 0), text_x, 200, 80, "left")
     love.graphics.printf(string.format("%.02f", self.pps_limit), text_x, 260, 80, "left")
 
     love.graphics.setFont(font_8x11)

tetris/modes/survival_gte.lua

@@ -56,25 +56,6 @@ function SurvivalGTEGame:onLineClear(cleared_row_count)
     self.completed = self.lines >= 300
 end
 
-local function getLowestBlockY(offsets)
-    local res = -math.huge
-    for _, o in pairs(offsets) do
-        if o.y > res then
-            res = o.y
-        end
-    end
-    return res
-end
-
-function SurvivalGTEGame:onEnterOrHold(...)
-    while (
-        getLowestBlockY(self.piece:getBlockOffsets()) + self.piece.position.y
-    ) < 4 do
-        self.piece.position.y = self.piece.position.y + 1
-    end
-    self.super.onEnterOrHold(self, ...)
-end
-
 function SurvivalGTEGame:advanceOneFrame()
     if self.ready_frames == 0 then
         self.frames = self.frames + 1

tetris/rulesets/trans.lua

@@ -21,34 +21,28 @@ function Trans:attemptRotate(new_inputs, piece, grid, initial)
     end
 
     local new_piece = piece:withRelativeRotation(rot_dir)
-
-    if initial then
-	    if (grid:canPlacePiece(new_piece)) then
-		    self:onPieceRotate(piece, grid)
-            piece:setRelativeRotation(rot_dir)
-        end
-	else
-		self:attemptWallkicks(piece, new_piece, rot_dir, grid)
-	end
-end
-
-function Trans:attemptWallkicks(piece, new_piece, rot_dir, grid)
     local pieces = {"I", "J", "L", "O", "S", "T", "Z"}
     repeat
         new_piece.shape = pieces[math.random(7)]
     until piece.shape ~= new_piece.shape
 
-    local offsets = {{x=0, y=0}, {x=1, y=0}, {x=-1, y=0}}
+	if (grid:canPlacePiece(new_piece)) then
-    for _, o in pairs(offsets) do
+		self:onPieceRotate(piece, grid)
-        local kicked_piece = new_piece:withOffset(o)
+        piece:setRelativeRotation(rot_dir)
-        if (grid:canPlacePiece(kicked_piece)) then
+        piece.shape = new_piece.shape
-            self:onPieceRotate(piece, grid)
+	else
-            piece:setRelativeRotation(rot_dir)
+		if not(initial and self.enable_IRS_wallkicks == false) then
-            piece:setOffset(o)
+			if (grid:canPlacePiece(new_piece:withOffset({x=1, y=0}))) then
-            piece.shape = new_piece.shape
+                self:onPieceRotate(piece, grid)
-            return
+                piece:setRelativeRotation(rot_dir):setOffset({x=1, y=0})
-        end
+                piece.shape = new_piece.shape
-    end
+            elseif (grid:canPlacePiece(new_piece:withOffset({x=-1, y=0}))) then
+                self:onPieceRotate(piece, grid)
+                piece:setRelativeRotation(rot_dir):setOffset({x=-1, y=0})
+                piece.shape = new_piece.shape
+            end
+		end
+	end
 end
 
 return Trans