v0.3-beta4

tetris/rulesets/randompieces.lua

@@ -0,0 +1,205 @@
+local Ruleset = require 'tetris.rulesets.ruleset'
+local Piece = require 'tetris.components.piece'
+
+local RandomPieces = Ruleset:extend()
+
+RandomPieces.name = "Random Pieces"
+RandomPieces.hash = "RandomPieces"
+
+function RandomPieces:generateBlockOffsets()
+    function containsPoint(points, p)
+        for _, point in pairs(points) do
+            if point.x == p.x and point.y == p.y then
+                return true
+            end
+        end
+        return false
+    end
+    
+    local offsets = {}
+    for i = 1, 4 do
+        local generated_offset = {}
+        repeat
+            generated_offset = {
+                x = math.random(-1, 1),
+                y = math.random(-2, 0)
+            }
+        until not containsPoint(offsets, generated_offset)
+        offsets[i] = generated_offset
+    end
+
+    return offsets
+end
+
+RandomPieces.pieces = 1
+
+RandomPieces.spawn_positions = {
+    { x=4, y=5 }
+}
+
+RandomPieces.big_spawn_positions = {
+    { x=2, y=3 }
+}
+
+RandomPieces.draw_offsets = {
+    { x=0, y=0 }
+}
+
+RandomPieces.next_sounds = {
+    "O"
+}
+
+RandomPieces.colourscheme = {
+    "F"
+}
+
+RandomPieces.block_offsets = {
+    {
+        { {x=0, y=0} },
+        { {x=0, y=0} },
+        { {x=0, y=0} },
+        { {x=0, y=0} },
+    }
+}
+
+function RandomPieces:initializePiece(
+	inputs, data, grid, gravity, prev_inputs,
+	move, lock_delay, drop_speed,
+	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
+		spawn_positions = self.big_spawn_positions
+	else
+		spawn_positions = self.spawn_positions
+	end
+	local colours = ({self.colourscheme, ColourSchemes.Arika, ColourSchemes.TTC})[config.gamesettings.piece_colour]
+	
+	local spawn_x
+	if (grid.width ~= 10) then
+		local percent = spawn_positions[data.shape].x / 10
+		for i = 0, grid.width - 1 do
+			if i / grid.width >= percent then
+				spawn_x = i
+				break
+			end
+		end
+	end
+
+	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,
+		y = spawn_positions[data.shape].y - spawn_dy
+	}, self.block_offsets, 0, 0, data.skin, colours[data.shape], big)
+    
+    local offsets = self:generateBlockOffsets()
+    piece.getBlockOffsets = function()
+        return offsets
+    end
+    piece.withOffset = function(self, offset)
+        local piece = Piece(
+            self.shape, self.rotation,
+            {x = self.position.x + offset.x, y = self.position.y + offset.y},
+            self.block_offsets, self.gravity, self.lock_delay, self.skin, self.colour, self.big
+        )
+        local offsets = self:getBlockOffsets()
+        piece.getBlockOffsets = function()
+            return offsets
+        end
+        piece.draw = function(self, opacity, brightness, grid, partial_das)
+            if self.ghost then return false end
+            if opacity == nil then opacity = 1 end
+            if brightness == nil then brightness = 1 end
+            love.graphics.setColor(brightness, brightness, brightness, opacity)
+            local offsets = self:getBlockOffsets()
+            local gravity_offset = 0
+            if config.gamesettings.smooth_movement == 1 and 
+               grid ~= nil and not self:isDropBlocked(grid) then
+                gravity_offset = self.gravity * 16
+            end
+            if partial_das == nil then partial_das = 0 end
+            for index, offset in pairs(offsets) do
+                local x = self.position.x + offset.x
+                local y = self.position.y + offset.y
+                if self.big then
+                    love.graphics.draw(
+                        blocks[self.skin][self.colour],
+                        64+x*32+partial_das*2, 16+y*32+gravity_offset*2,
+                        0, 2, 2
+                    )
+                else
+                    love.graphics.draw(
+                        blocks[self.skin][self.colour],
+                        64+x*16+partial_das, 16+y*16+gravity_offset
+                    )
+                end
+            end
+            return false
+        end
+        return piece
+    end
+
+	self:onPieceCreate(piece)
+	if irs then
+		self:rotatePiece(inputs, piece, grid, {}, true)
+		if (data.orientation - 1) ~= piece.rotation then
+			playSE("irs")
+		end
+	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
+
+function RandomPieces:attemptRotate(new_inputs, piece, grid, initial)
+    
+    if not (
+        new_inputs.rotate_left or new_inputs.rotate_left2 or
+        new_inputs.rotate_right or new_inputs.rotate_right2 or
+        new_inputs.rotate_180
+    ) then
+        return
+    end
+    
+    local new_piece = piece:withOffset({x=0, y=0})
+    local offsets = self:generateBlockOffsets()
+    new_piece.getBlockOffsets = function()
+        return offsets
+    end
+    
+    if (grid:canPlacePiece(new_piece)) then
+        piece.getBlockOffsets = function()
+            return offsets
+        end
+		self:onPieceRotate(piece, grid)
+	else
+		if not(initial and self.enable_IRS_wallkicks == false) then
+			self:attemptWallkicks(piece, new_piece, offsets, grid)
+		end
+    end
+end
+
+function RandomPieces:onPieceDrop(piece) piece.lock_delay = 0 end
+function RandomPieces:onPieceMove(piece) piece.lock_delay = 0 end
+function RandomPieces:onPieceRotate(piece) piece.lock_delay = 0 end
+
+return RandomPieces