As I mentioned on my previous post, Swiftris’ gravity is different than the http://en.wikipedia.org/wiki/Tetris#Gravity and that annoys anyone who played Tetris enough.
On the original Switris source, the gravity/collapsing behavior is implemented in ‘removeCompletedLines()’ which is called (weirdly) from within GameViewController’s implementation of the ‘gameShapeDidLand()’. Let’s start by just reimplementing removeCompletedLines() without changing its interface.
Here is the original implementation:
func removeCompletedLines() -> (linesRemoved: Array<Array<Block>>, fallenBlocks: Array<Array<Block>>) { var removedLines = Array<Array<Block>>() for var row = (NumRows - 1) ; row > 0 ; row-- { var rowOfBlocks = Array<Block>() for column in 0..<NumColumns { //if block not null if let block = blockArray[column, row] { //add to the rowOfBlocks rowOfBlocks.append(block) } } //if amount of blocks equals the number of Columns if rowOfBlocks.count == NumColumns { removedLines.append(rowOfBlocks) for block in rowOfBlocks { blockArray[block.col, block.row] = nil } } } if removedLines.count == 0 { return ([],[]) } let pointsEarned = removedLines.count * PointsPerLine * level score += pointsEarned if score >= level * LevelThreshold { level += 1 delegate?.gameDidLevelUp(self) } var fallenBlocks = Array<Array<Block>>() for column in 0..<NumColumns { var fallenBlocksArray = Array<Block>() for var row = (removedLines[0][0]).row - 1; row > 0; row-- { if let block = blockArray[column, row] { var newRow = row //falls independently? while (newRow < (NumRows-1) && blockArray[column, newRow+1] == nil) { newRow++ } block.row = newRow blockArray[column, row] = nil blockArray[column, newRow] = block fallenBlocksArray.append(block) } } if fallenBlocksArray.count > 0 { fallenBlocks.append(fallenBlocksArray) } } return (removedLines, fallenBlocks) }
and this is my implementation (different name but same signatures so you can just replace in GameViewController):
func removeFullLines() -> (linesRemoved: Array<Array<Block>>, fallenBlocks: Array<Array<Block>>) { // Just so we can mock the original signature var externalRemovedBlocks = Array<Array<Block>>() var removedBlocks = Array<Block>() // Just so we can mock the original signature var externalFallenBlocks = Array<Array<Block>>() var fallenBlocks = Array<Block>() //Iterating from bottom of the Tetris grid; this is the summary of that loop: // -> dropHeight = 0 (number of dropped rows to that point in the loop) // for rows, bottom up // if row is full // -> save that row's blocks to removedBlocks // -> set nil for the whole row // -> incread dropHeight // else (row is not full) // if dropHeight > 0 // -> lower that row by dropHeight rows var dropHeight:Int = 0 for var row = (NumRows - 1) ; row > 0 ; row-- { if isRowFilled(row) { for column in 0..<NumColumns { //save row (we know its not null because its filled) removedBlocks.append(blockArray[column, row]!) //set nil blockArray[column, row] = nil } //increase drop height dropHeight += 1 } else { if dropHeight > 0 { //lower row by drop height for column in 0..<NumColumns { if let block = blockArray[column, row] { block.row += dropHeight blockArray[column, row] = nil blockArray[column, block.row] = block fallenBlocks.append(block) } } } } } externalRemovedBlocks.append(removedBlocks) externalFallenBlocks.append(fallenBlocks) if dropHeight == 0 { return ([],[]) } let pointsEarned = dropHeight * PointsPerLine * level score += pointsEarned if score >= level * LevelThreshold { level += 1 delegate?.gameDidLevelUp(self) } return (externalRemovedBlocks, externalFallenBlocks) }
As you can see, the original Gravity is a lot simpler and makes the game harder & more fun. Also, note that ‘removeFullLines()’ has unnecessary complexity on its return values (Array of Arrays instead of simple Arrays) – we’ll fix that later.
And there’s a little problem with simply replacing ‘removeCompletedLines()’ by ‘removeFullLines()’; removeFullLines returns all fallen blocks in the same/first subarray of fallenBlocks; where the original one would return on subarray for each column. This causes a problem since the blockIdx within each of the subarrays is used to time a animation on the GameScene side so everything will work fine but the game will lock for a few seconds every time you fill a line (linear to the full amount of blocks falling), I plan to provide a way better fix for this later but for now this solves the immediate problem:
// ... func collapsingLines(linesToRemove: Array<Array<Block>>, fallenBlocks: Array<Array<Block>>, completion:() -> ()) { // ... // ... let delay = (NSTimeInterval(columnIdx) * 0.05) + (NSTimeInterval(blockIdx) * 0.05) /// ... }
To this:
// ... func collapsingLines(linesToRemove: Array<Array<Block>>, fallenBlocks: Array<Array<Block>>, completion:() -> ()) { // ... // ... let delay = (NSTimeInterval(columnIdx) * 0.05) + (NSTimeInterval(1) * 0.05) /// ... }
Now the game works as it should but the architecture of it is still a mess and all my fixes are basically hacks inside it. For my next post I’ll try to redesign/cleanup.. let’s hope for the best.