Match-3 related algorithms?

BlitzMax Forums/BlitzMax Beginners Area/Match-3 related algorithms?
darkhog
(Posted 2015) [#1]
Mainly how do you check for valid moves and "rebuild" board after move is done.

This is a little bit special for me. My Mom loves games like that and I would love to make for her such game as a x-mas gift. But without knowing necessary algorithms I can't.
Derron
(Posted 2015) [#2]
Valid moves: if the move creates a connection of at least 3 connected objects (same color or specialities) it is valid.

Rebuild: just move the upcoming objects down one grid cell ... if all stones are no longer able to move down, you finished your first iteration. Next step is to check for connections again. if there was a connection, start again: removing connections, moving down, checking for connections ...

After this is done, your _turn_ is finished (important for things like combos counts).

I am pretty sure that there was a match-3-source-code posted somewhere in the forums. Above approach was just based on thoughts I had when starting to write a medieval _columns_-like game. This is not match3, but it is the same "ruleset" (except the way a user controls the game board).

Just found some small "monkey conversion" sample of that game (no special moves activated - just as demonstration of the particle effect on the torch and the title screen (press ESC)):
"play" online: http://digidea.de/dev/knb/

The relevant monkey source is this (there is surely a better way to do things - but the conversion is based on code I wrote about 9 or 10 years ago - same for the graphics).
Strict
Import diddy


Class TKnB_Block Extends Sprite
	Field maxDx:Float			= 10.0
	Field maxDy:Float			= 10.0
	Field target:Vector2D		= null

	Field _rotate:Bool			= False
	Field _blockType:Int		= 0
	Field _blockColor:Int		= 0

	'is it marked to get deleted
	Field _markedForDeletion:Bool=False
	'when was it marked
	Field _markedForDeletionTime:Int
	'milliseconds until animation finished
	Field _deletionAnimationDuration:Int = 1000
	'milliseconds of delay until animation starts after marking for deletion
	Field _deletionAnimationDelay:Int = 200
	'by default this is the explosion thing
	Field _deletionAnimationSprite:Sprite = Null

	Global blockBaseName:String = "BLOCK"


	Method New(blockColor:Int=1, blockType:Int=0, x:Float=0.0, y:Float=0.0)
		Self.x = x
		Self.y = y
		Self.alpha = 1
		'Self.SetHitBox( -img.w2 + 2, - img.h2 + 1, img.w - 2, img.h - 1)
		Self.visible = True
		
		Self._deletionAnimationSprite = New Sprite(diddyGame.images.Find("fx_explosion"), x, y)		
		Self._deletionAnimationSprite.SetFrame(0, 15, 35, False, False)
		Self._deletionAnimationDuration = 16 * 35 + 25 'add some milliseconds afterwards
		
		Self.SetType(blockType)
		Self.SetColor(blockColor)
		Self.AssignImage()
	End
	
	
	Method SetType:Void(blockType:Int)
		Self._blockType = blockType
	End


	Method SetColor:Void(blockColor:Int)
		Self._blockColor = blockColor
	End
	
	Method AssignImage:Void()
		Self.image = diddyGame.images.Find(blockBaseName + (_blockType*10 + _blockColor))
	End


	'a negative speed rotates counter-clockwise
	Method SetRotation:Void(speed:Float, loop:Bool=True, length:Int=0)
		rotationLength = length
		rotationLoop = loop
		rotationSpeed = speed
		SetRotate(True)
	End
	
	
	Method SetRotate:Void(rotate:Bool)
		_rotate = rotate
		'reset rotation if not rotating
		If _rotate Then rotation = 0
	End


	Method MarkForDeletion:Bool()
		If _markedForDeletion Then Return False
		_markedForDeletion = True
		_markedForDeletionTime = Millisecs()

		Self.scaleCounter = 50.0
		Self.scaleXSpeed = -0.01
		Self.scaleYSpeed = -0.01
		SetRotation(Rnd(-1,1)*0.25, True)

		Return True
	End


	Method MoveTo:Void(x:Float, y:Float, animateMovement:Int)
		If Not animateMovement Then Self.SetPosition(x,y)
		Self.SetTarget(x,y)
	End
	

	Method SetPosition:Void(x:Float, y:Float)
		Self.x = x
		Self.y = y
	End
	
	
	Method SetTarget:Void(x:Float, y:Float)
		If Not target 
			target = New Vector2D(x,y)
		Else
			target.Set(x,y)
		endif
		'adjust to no movement or movement in the right direction
		AdjustMovementSpeed()
	End
	
	
	Method HasTarget:Bool()
		Return target <> Null
	End
	
	
	Method IsMoving:Bool()
		If dx <> 0 Or dy <> 0 Then Return True
		Return False
	End

	
	Method AdjustMovementSpeed:Void()
		'reset to nothing
		dx = 0
		dy = 0
		If HasTarget()
			'assign new speed according to position
			If Floor(target.x - x) > 0 Then dx = maxDx
			If Floor(target.x - x) < 0 Then dx = -maxDx
	
			If Floor(target.y - y) > 0 Then dy = maxDy
			If Floor(target.y - y) < 0 Then dy = -maxDy
		Endif
	End


	'returns if object has a target and still has to get there	
	Method HasToMove:Bool()
		If Not HasTarget() Then Return False

		'moving to left/right but reached target already
		If dx > 0 And target.x <= x Then Return False
		If dx < 0 And target.x >= x Then Return False
		'moving to top/bottom but reached target already
		If dy > 0 And target.y <= y Then Return False
		If dy < 0 And target.y >= y Then Return False

		Return True		
	End
	
	
	Method HasReachedTarget:Bool()
		If Not HasTarget() Then Return False
		If dx > 0 And x < target.x Then Return False
		If dx < 0 And x > target.x Then Return False
		If dy > 0 And y < target.y Then Return False
		If dy < 0 And y > target.y Then Return False
		Return True
	End Method
	
	
	Method ReachTarget:Void()
		If HasTarget()
			Self.x = target.x
			Self.y = target.y

			Self.target = Null
		Endif

		Self.dx = 0
		Self.dy = 0
	End
	
	
	'returns a value 0.0 - 1.0 easing in/out at the start/end
	Function SmoothStep:Float(val:Float)
		Return val*val * (3.0 - 2.0*val)
	End


	Method CanConnect:Bool(otherBlock:TKnB_Block)
		If Not otherBlock Then Return False
		
		'same color is ok
		If otherBlock._blockColor = _blockColor Then Return True
		'joker
		If otherBlock._blockColor = 10 Or _blockColor = 10 Then Return True
		
		Return False
	End
	
	
	'a block is dying as long it got marked and animation is playing
	Method IsDying:Bool()
		Return (_markedForDeletion And Not IsDead())
	End
	
	
	'a block is dead as soon as it got marked and animation should be finished
	Method IsDead:Bool()
		If Not _markedForDeletion Then Return False
		If _markedForDeletionTime + _deletionAnimationDuration + _deletionAnimationDelay < Millisecs() Then Return True
		Return False
	End
	
	
	Method PlayDeletionAnimation:Bool()
		If Not IsDying() Then Return False
		If _markedForDeletionTime + _deletionAnimationDelay < Millisecs() Then Return True
		
		Return False
	End
	

	Method Update:Bool()
		If IsDead() Then Return False
		
		UpdateAnimation()
		If _rotate Then ManageRotation()
		ManageScale()

		'move if needed and allowed
		If HasToMove() Then Move()
		'start / stop moving if needed so		
		If HasReachedTarget() Then ReachTarget()

		'take care of dying animation (and included delay)
		If PlayDeletionAnimation() And _deletionAnimationSprite Then _deletionAnimationSprite.UpdateAnimation()

		Return True
	End


	'override draw to reposition dying effects
	Method Draw:Void()
		Super.Draw(0,0)
	End
	
	
	'return a "random" type of a given list (adjusted by specific chances)
	Function GetRandomType:Int(availableTypes:Int[])
		Local rndType:Int = availableTypes[ Rnd(availableTypes.Length) ]
		Select rndType
			Case 1		Return (Rnd(100)<5)*1	'sword
			Case 2		Return (Rnd(100)<5)*2	'bomb
			Case 3		Return (Rnd(100)<5)*3	'clock
			Case 4		Return (Rnd(100)<5)*4	'axe upper
			Default		Return rndType
		End
	End
End




Class TKnB_PlayerBlocks
	Field blocks:TKnB_Block[3]
	Field slotW:Int, slotH:Int
	Field currentTargetY:Float = 0
	Field lastTargetY:Float = 0
	Field dropped:Bool = False
	Field _fallSpeedBackup:Float= 0
	Field _fallSpeedModified:Bool = False
	
	
	
	Method New(maxColor:Int, availableTypes:Int[], slotW:Int, slotH:Int, fallSpeed:Float)
		Self.blocks[0] = New TKnB_Block(Rnd(maxColor), TKnB_Block.GetRandomType(availableTypes) )
		Self.blocks[1] = New TKnB_Block(Rnd(maxColor), TKnB_Block.GetRandomType(availableTypes) )
		Self.blocks[2] = New TKnB_Block(Rnd(maxColor), TKnB_Block.GetRandomType(availableTypes) )
		Self.slotW = slotW
		Self.slotH = slotH
		Self.SetFallSpeed(fallSpeed, True)
	End
	
	
	
	Method SetFallSpeed:Void(speed:Float, setInitialValue:Bool=False)
		If setInitialValue Then _fallSpeedBackup = speed

		blocks[0].maxDy = speed
		blocks[1].maxDy = speed
		blocks[2].maxDy = speed
		blocks[0].AdjustMovementSpeed()
		blocks[1].AdjustMovementSpeed()
		blocks[2].AdjustMovementSpeed()
	End


	
	Method MoveTo:Void(x:Float, y:Float, animateMovement:Int)
		blocks[0].MoveTo(x, y + 0 * slotH, animateMovement)
		blocks[1].MoveTo(x, y + 1 * slotH, animateMovement)
		blocks[2].MoveTo(x, y + 2 * slotH, animateMovement)
	End
	


	Method SetPosition:Void(x:Float, y:Float)
		Self.blocks[0].SetPosition(x, y + 0 * slotH)
		Self.blocks[1].SetPosition(x, y + 1 * slotH)
		Self.blocks[2].SetPosition(x, y + 2 * slotH)
	End
	
	

	Method SwitchBlocks:Void(direction:Int=0)
		Local startX:Float = GetX()
		Local startY:Float = GetY()
		Local block:TKnB_Block

		'0 1 2 => 2 0 1
		If direction = 0
			block = Self.blocks[2]
			Self.blocks[2] = Self.blocks[1]
			Self.blocks[1] = Self.blocks[0]
			Self.blocks[0] = block
		'0 1 2 => 1 2 0
		Else
			block = Self.blocks[0]
			Self.blocks[0] = Self.blocks[1]
			Self.blocks[1] = Self.blocks[2]
			Self.blocks[2] = block
		Endif
		'move positions
		MoveTo(startX, startY, False)
	End
	
	

	Method GetY:Float()
		Return Self.blocks[0].y
	End



	Method GetX:Float()
		Return Self.blocks[0].x
	End



	Method GetH:Float()
		Return 3 * slotH
	End

	
	
	Method Draw:Void()
		Self.blocks[0].Draw()
		Self.blocks[1].Draw()
		Self.blocks[2].Draw()
	End
	


	Method SetTargetY:Void(targetY:Float)
		Self.lastTargetY = Self.currentTargetY
		Self.currentTargetY = targetY

		Self.blocks[0].SetTarget(GetX(), currentTargetY - 2 * slotH)
		Self.blocks[1].SetTarget(GetX(), currentTargetY - 1 * slotH)
		Self.blocks[2].SetTarget(GetX(), currentTargetY - 0 * slotH)
	End
	
	
	
	Method HandleFallspeedModifier:Void()
		If MouseDown(MOUSE_RIGHT) 
			SetFallSpeed(Min(_fallSpeedBackup*3, 5.0))
			_fallSpeedModified = True
		Elseif _fallSpeedModified
			SetFallSpeed(_fallSpeedBackup)
			_fallSpeedModified = False
		Endif
	End



	Method Update:Void()
		'do not update when dropped
		If dropped Then Return
		
		If blocks[2].HasReachedTarget() 
			dropped = True
			Return
		Endif
		
		HandleFallspeedModifier()
		
		blocks[0].Update()
		blocks[1].Update()
		blocks[2].Update()
	End
End




'base class for statistics in games
Class TKnB_GameStats
	'Records-Werte koennten auch aus Highscore gelesen werden ?!
	Field combos:Int				'combos current turn
	Field combosMax:Int			'combos - maxima current game
	Field combosRecord:Int			'combos - maxima all time
	
	Field cleared:Int				'blocks cleared current turn
	Field clearedMax:Int			'blocks cleared a turn - maxima this game
	Field clearedRecord:Int		'blocks cleared a turn - maxima all time

	Field score:Int					'current score
	Field scoreTurn:Int			'score this turn
	Field scoreRecord:Int			'score record all time

	Field _currentTurn:Int = 0
	

	Method AddScore:Void(amount:Int)
		score += amount
		scoreTurn += amount

		If score > scoreRecord Then scoreRecord = score
	End


	Method AddCombo:Void(amount:Int=1)
		combos += amount

		If combos > combosMax Then combosMax = combos
		If combos > combosRecord Then combosRecord = combos
	End


	Method AddCleared:Void(amount:Int=1)
		cleared += amount

		If cleared > clearedMax Then clearedMax = combos
		If cleared > clearedRecord Then clearedRecord = combos
	End
	
	

	Method NextTurn:Void()
		scoreTurn = 0
		cleared = 0
		combos = 0
	End
End




'holding collapse blocks
Class TKnB_BlockGroup
	Field blocks:List<TKnB_Block> = New List<TKnB_Block>
	Field _markedForDeletion:Bool	'marker to skip groups during "for .. = eachin list"
	Field _combo:Bool				'was this group created because of a combo deletion?

	Method AddBlock:Void(block:TKnB_Block)
		blocks.AddLast(block)
	End Method	
	
	Method MarkForDeletion:Void()
		_markedForDeletion = True
	End
	
	Method SetCombo:Void(value:Bool)
		_combo = value
	End
	
	Method IsCombo:Bool()
		Return _combo
	End
End




Class TKnB_Board
	'=== GRAPHICAL PROPERTIES ===
	Field backgroundImage:GameImage
	Field overlayImage:GameImage
	Field selectorImage:GameImage
	Field x:Int, y:Int
	Field slotW:Int, slotH:Int
	Field _nextBlocksX:Float, _nextBlocksY:Float

	'=== LOGICAL PROPERTIES ===
	Field stats:TKnB_GameStats
	Field slotColCount:Int=1	'left to right
	Field slotRowCount:Int=1	'top to bottom
	Field slots:TKnB_Block[][]
	Field deleteGroups:List<TKnB_BlockGroup> = New List<TKnB_BlockGroup>	'list containing groups of blocks for deletion
	Field _nextTurnTime:Int = 0				'time when next turn can start
	Field _nextTurnDelay:Int = 1000			'milliseconds to wait until next turn starts
	Field _nextBlocks:TKnB_PlayerBlocks		'the next blocks a player gets
	Field _playerBlocks:TKnB_PlayerBlocks		'the blocks a player currently controls
	Field _paused:Bool = False
	'position of the playerBlocks
	Field playerBlocksCol:Int=1
	Field playerBlocksColOld:Int=1
	Field playerBlocksRow:Int = 1
	Field playerBlocksRowOld:Int = 1
	'state
	Field speed:Int = 1
	Field movingBlocksCount:Int = 0
	Field dyingBlocksCount:Int = 0
	Field deletedBlocksCount:Int = 0
	Field turnStarted:Bool = False
	Field changedSlots:Bool = False
	Field maxColors:Int
	Field _maxColorsInitialValue:Int	= 3
	Field _speedInitialValue:Int		= 1
	
	'scores for EACH block destroyed - by kind
	Const SCORE_SINGLE:Int = 0
	Const SCORE_TIME:Int   = 1
	Const SCORE_SWORD:Int  = 2
	Const SCORE_BOMB:Int   = 3
	'multipliers for each CHAIN destroyed
	Const SCORE_MULTIPLIER_CHAIN3:Float = 1.0
	Const SCORE_MULTIPLIER_CHAIN4:Float = 1.5
	Const SCORE_MULTIPLIER_CHAIN5:Float = 2.0



	Method New(x:Int, y:Int, slotCountX:Int, slotCountY:Int)
		Self.x = x
		Self.y = y
		Self.slotColCount = slotCountX
		Self.slotRowCount = slotCountY
		Reset()
	End
	
	
	
	Method Reset:Void()
		stats = New TKnB_GameStats
		maxColors = _maxColorsInitialValue
		speed = _speedInitialValue
		'resets slots
		Self.SetSlotCount(Self.slotColCount, Self.slotRowCount)
	End


	
	Method SetNextBlocksXY:Void(x:Float, y:Float)
		Self._nextBlocksX = x
		Self._nextBlocksY = y
	End



	Method SetBackground:Void(image:GameImage)
		Self.backgroundImage = image
	End



	Method SetOverlay:Void(image:GameImage)
		Self.overlayImage = image
	End


	
	Method SetSlotCount:Void(cols:Int=-1, rows:Int=-1)
		If cols > 0 Then Self.slotColCount = cols
		If rows > 0 Then Self.slotRowCount = rows

		Self.slots = New TKnB_Block[cols][]
	    For Local i:Int = 0 Until cols
	        Self.slots[i] = New TKnB_Block[rows]
   		Next

		Print "board has now: "+Self.slotColCount+"x"+Self.slotRowCount+" slots."
	End
	
	

	Method SetSlotDimension:Void(width:Int, height:Int)
		Self.slotW = width
		Self.slotH = height
	End
	
	
	
	Method IsValidSlot:Bool(col:Int, row:Int)
		If col < 0 Or col >= Self.slotColCount Then Return False
		If row < 0 Or row >= Self.slotRowCount Then Return False
		Return True
	End
	
	
	
	Method SetSlot:Bool(block:TKnB_Block, col:Int, row:Int, animateMovement:Int=False)
		If Not IsValidSlot(col, row) Then Return False

		Self.slots[col][row] = block
		'move block to right pixel coordinates
		If block Then block.MoveTo(GetSlotCenterX(col), GetSlotCenterY(row), animateMovement)

		changedSlots = True

		Return True
	End Method
	
	
	
	Method GetSlotCenterX:Float(col:Int)
		Return x + col * slotW + Floor(slotW/2)
	End



	Method GetSlotCenterY:Float(row:Int)
		Return y + row * slotH + Floor(slotH/2)
	End



	'return the col of an absolute x-coordinate
	Method GetCol:Float(x:Float)
		Return Clamp(Int((x- Self.x) / Self.slotW), 0, slotColCount-1) 
	End



	'return the row of an absolute y-coordinate
	Method GetRow:Float(y:Float)
		Return Clamp(Int((y- Self.y) / Self.slotH), 0, slotRowCount-1)
	End

	
	
	'returns the next used slot ... starting on top traversing down
	Method GetNextOccupiedSlotRow:Int(col:Int, startRow:Int=0)
		'loop through rows
		For Local i:Int = startRow Until Self.slotRowCount
			'if slot is occupied
			If Self.slots[col][i] Then Return i
		Next
		Return -1
	End Method
	
	

	Method GetBlock:TKnB_Block(col:Int, row:Int)
		If Not IsValidSlot(col, row) Then Return Null
		
		Return Self.slots[col][row]
	End	
	
	
	
	Method MoveBlock:Bool(srcCol:Int, srcRow:Int, targetCol:Int, targetRow:Int)
		SetSlot(Self.slots[srcCol][srcRow], targetCol, targetRow, True)
		SetSlot(Null, srcCol, srcRow)

		Return True
	End Method
	
	
	
	'==== COLLAPSE LOGIC ====
	
	Method CollapseBlocks:Bool()
		Local collapsedSomething:Bool = False
		Local collapsedAmount:Int = 0
		Local currentBlock:TKnB_Block
		Repeat
			collapsedSomething = False
			For Local i:Int = 0 Until Self.slotColCount
				'start at bottom - to avoid moving them down 1 step each loop
				'also skip blocks at the bottom line (they cannot drop)
				For Local j:Int = Self.slotRowCount-1 To 0 Step -1
					currentBlock = Self.GetBlock(i,j)
					'skip nonexisting
					If Not currentBlock Then Continue
					
					'block can drop down till next free slot
					Local nextOccupiedSlotRow:Int = GetNextOccupiedSlotRow(i, j+1)
					Local collapseToRow:Int = nextOccupiedSlotRow -1		
					'if there was no occupied slot until lowest row... 
					If nextOccupiedSlotRow = -1 Then collapseToRow = Self.slotRowCount-1

					If collapseToRow > j
						MoveBlock(i, j, i, collapseToRow)
						collapsedAmount += 1
						collapsedSomething = True
					Endif
				Next
			Next
		
			'seems not needed
			'check if 3 or more are connected
			'If collapsedSomething Then Self.CheckBlockConnections()
		Until collapsedSomething = False
		Return (collapsedAmount > 0)
	End Method	
	
	
	Const DIRECTION_COLUMN:Int = 1
	Const DIRECTION_ROW:Int = 2
	Const DIRECTION_DIAGONAL_UP_RIGHT:Int = 3
	Const DIRECTION_DIAGONAL_UP_LEFT:Int = 4


	Method GetConnectedBlocks:TKnB_Block[](col:Int, row:Int, direction:Int)
		Local blocks:TKnB_Block[]
		Local block:TKnB_Block = Self.GetBlock(col, row)
		If Not block Then Return blocks

		blocks.Resize(blocks.Length+1)
		blocks[blocks.Length] = block
		
		Local hits :Int = 1 'the original block is hit number 1
		For Local i:Int = 1 To 5
			Select direction
				Case DIRECTION_COLUMN
					col += 1
				Case DIRECTION_ROW
					row += 1
				Case DIRECTION_DIAGONAL_UP_RIGHT
					col += 1
					row += 1
				Case DIRECTION_DIAGONAL_UP_LEFT
					col -= 1
					row += 1
			End Select
			'no block means - connection ended
			If Not Self.GetBlock(col, row) Then Return blocks

			'ask one of the blocks if colors/specials allow connection
			If Not Self.GetBlock(col,row).CanConnect(block) Then Return blocks

			blocks.Resize(blocks.Length+1)
			blocks[blocks.Length] = Self.GetBlock(col,row)

			hits += 1
		Next
		Return blocks
	End Method


	Method CheckBlockConnections:Int()
		Local hits:Int = 0
		Local hitBlocks:TKnB_Block[]
		For Local i:Int = 0 Until Self.slotColCount
			For Local j:Int = 0 Until Self.slotRowCount
				For Local direction:Int = 1 To 4
					hitBlocks = GetConnectedBlocks(i, j, direction)
					'mark for deletion
					If hitBlocks.Length >= 3
						Local deleteGroup:TKnB_BlockGroup = New TKnB_BlockGroup()
						For Local block:TKnB_Block = Eachin hitBlocks
							If Not block.MarkForDeletion() Then Continue
							
							deleteGroup.AddBlock(block)
							hits += 1
						Next
						'only adds if there is a block in it
						AddDeleteGroup(deleteGroup)
					Endif
				Next
			Next
		Next
		Return hits
	End Method



	Method AddDeleteGroup:Bool(group:TKnB_BlockGroup)
		If group.blocks.Count() = 0 Then Return False

		'if not the first group added, it is a combo deletion
		If deleteGroups.Count() > 0 Then group.SetCombo(True)

		deleteGroups.AddLast(group)

		Return True
	End
	
	
	
	Method RemoveDeleteGroup:Bool(group:TKnB_BlockGroup)
		If Not deleteGroups Then Return False
		If Not deleteGroups.Contains(group) Then Return False
		deleteGroups.RemoveEach(group)
		Return True
	End



	Method SetPlayerBlocksToSlots:Void()
		If Not _playerBlocks Then Return
		
		'set current player blocks to board ones
		'instead of just setting the blocks with all its adjusted settings (DX, effects..)
		'we create new ones
		For Local i:Int = 0 To 2
			SetSlot(New TKnB_Block(_playerBlocks.blocks[i]._blockColor, _playerBlocks.blocks[i]._blockType), GetCol(_playerBlocks.blocks[i].x), GetRow(_playerBlocks.blocks[i].y))
			'SetSlot(_playerBlocks.blocks[i], GetCol(_playerBlocks.blocks[i].x), GetRow(_playerBlocks.blocks[i].y))
		Next
		'remove current player blocks
		_playerBlocks = Null
	End
	
	
	Method HasBlockInRow:Bool(row:Int, colStart:Int=0, colEnd:Int=-1)
		If row < 0 Then Return False
		
		If colEnd=-1 Then colEnd = slotColCount
		Local minCol:Int = Min(colStart, colEnd)
		Local maxCol:Int = Max(colStart, colEnd)
		
		For Local i:Int = minCol To maxCol
			If GetBlock(i, row) <> Null Then Return True
		Next
		Return False
	End
	

		
	'returns whether the current turn can end or not
	Method CanEndTurn:Bool()
		'if no turn was started, we cannot end it :D
		If Not Self.turnStarted Then Return False
		'if there are still blocks dying (animation)
		If dyingBlocksCount > 0 Then Return False
		'still blocks moving?
		If movingBlocksCount > 0 Then Return False
		'if there are still player blocks (level still running?)
		If Self._playerBlocks Then Return False
		
		Return True
	End
		
		
	'returns whether the next turn could start
	Method CanStartTurn:Bool()
		'if turn was started, we cannot start again
		If Self.turnStarted Then Return False
		'if there are still blocks dying (animation)
		If Self._nextTurnTime > Millisecs() Then Return False
		'if there are still player blocks (level still running?)
		If Self._playerBlocks Then Return False
		
		Return True
	End
			

	Method StartTurn:Void()
		turnStarted = True
		
		'set new "current" blockgroup
		_playerBlocks = _nextBlocks
		If _playerBlocks 
			_playerBlocks.MoveTo( GetSlotCenterX(slotColCount/2), GetSlotCenterY(0) - 3*slotH, False)
			_playerBlocks.SetFallSpeed(speed, True)

		Endif
		'set new "next" blockgroup
		Self._nextBlocks = New TKnB_PlayerBlocks(Self.maxColors, [0,1], Self.slotW, Self.slotH, Self.speed)
		Self._nextBlocks.MoveTo(_nextBlocksX, _nextBlocksY, False)
		
		'reset temp vars
		playerBlocksColOld = slotColCount/2
		playerBlocksCol = slotColCount/2
		playerBlocksRow = 1
		playerBlocksRowOld = 1
	End Method

	
	'called as soon as a "turn" ends (all chainreactions ended, ready
	'for next block-group)
	Method EndTurn:Void()
		'set turn ended
		Self.turnStarted = False
		'set delay until next turn
		Self._nextTurnTime = Millisecs() + Self._nextTurnDelay

		'=== CHECK FOR NEW RECORDS (combos) ===
		stats.NextTurn()
		'remove last turn's delete groups
		deleteGroups.Clear()


		'=== RESET OLD VARS ===
		deletedBlocksCount = 0
		dyingBlocksCount = 0
		movingBlocksCount = 0
	End Method
	
	
	Method GetSelectorRow:Int()
		Local result:Int = GetNextOccupiedSlotRow(playerBlocksCol) - 1
		'GetNextOccupiedSlotRow returns -1 if no slot was occupied -1 = -2
		If result = -2 Then result = slotRowCount-1
		Return result
	End
		

	Method Update:Void()
		If _paused Then Return

		'==== HANDLE BLOCKS ====
		'controllable Blocks dropped - convert to board blocks
		'afterwards it might be possible that an turn ends
		If _playerBlocks And _playerBlocks.dropped Then SetPlayerBlocksToSlots()

		If CanEndTurn()
			EndTurn()
		Elseif CanStartTurn()
			StartTurn()		
		Else
			'==== HANDLE PLAYER BLOCKS GROUP ====
			If _playerBlocks
				'switch block order
				If MouseHit(MOUSE_MIDDLE)
					_playerBlocks.SwitchBlocks(0)
				Elseif MouseHit(MOUSE_LEFT) 
					_playerBlocks.SwitchBlocks(1)
				Endif

				playerBlocksColOld = playerBlocksCol
				playerBlocksCol = GetCol( MouseX() )
				
				playerBlocksRowOld = playerBlocksRow
				playerBlocksRow = GetRow(_playerBlocks.GetY() +_playerBlocks.GetH())

				'has playerblock moved slots?
				If playerBlocksCol <> playerBlocksColOld Or playerBlocksRow <> playerBlocksRow
					Local reachable:Bool = True
					'check all 3 player blocks if they could move to the target
					If reachable And HasBlockInRow(playerBlocksRow-2, playerBlocksColOld, playerBlocksCol) Then reachable = False
					If reachable And HasBlockInRow(playerBlocksRow-1, playerBlocksColOld, playerBlocksCol) Then reachable = False
					If reachable And HasBlockInRow(playerBlocksRow  , playerBlocksColOld, playerBlocksCol) Then reachable = False

					If reachable
						_playerBlocks.SetPosition(GetSlotCenterX(playerBlocksCol), _playerBlocks.GetY())
					Else
						'revert
						playerBlocksCol = playerBlocksColOld
					Endif
				Endif

					'adjust target of the blocks
					Local targetSlot:Int = GetNextOccupiedSlotRow(playerBlocksCol, playerBlocksRow)
					If targetSlot = -1 'ground
						_playerBlocks.SetTargetY( GetSlotCenterY(slotRowCount-1) )
					Else
						_playerBlocks.SetTargetY( GetSlotCenterY(targetSlot-1) )
					Endif

					
				'only move if rest finished
				If movingBlocksCount=0 And dyingBlocksCount=0 Then _playerBlocks.Update()
			Endif


			'==== HANDLE BOARD BLOCKS ====
			UpdateBlocks() 
			If movingBlocksCount=0 And dyingBlocksCount=0 
				CollapseBlocks()
				CheckBlockConnections()
			Endif
		Endif	
	End


	Method UpdateBlocks:Bool()
		'=== RESET OLD VARS ===
		dyingBlocksCount = 0
		movingBlocksCount = 0

		'=== UPDATE BLOCKS ===
		Local deletedBlock:Bool=False
		For Local i:Int = 0 Until Self.slotColCount
			For Local j:Int = 0 To Self.slotRowCount
				If Self.slots[i][j] 
					'delete dead blocks
					If Not Self.slots[i][j].Update() 
						Self.slots[i][j] = Null
						deletedBlock = True
						
						stats.AddScore(10)
						stats.AddCleared(1)
						
						'increase count of removed blocks in this turn
						deletedBlocksCount += 1
					Else
						'increase count if already dying
						If Self.slots[i][j].IsDying() Then dyingBlocksCount += 1
						'increase count if moving
						If Self.slots[i][j].HasToMove() Then movingBlocksCount += 1
					Endif
				Endif
			Next
		Next
		

		'=== UPDATE DELETE GROUPS ===
		For Local deleteGroup:TKnB_BlockGroup = Eachin deleteGroups
			'skip dead groups
			If deleteGroup._markedForDeletion Then Continue
			
			Local allBlocksDead:Bool = True
			For Local block:TKnB_Block = Eachin deleteGroup.blocks
				If Not block.IsDead() Then allBlocksDead = False
			Next
			If allBlocksDead 
				If deleteGroup.IsCombo() Then stats.AddCombo(1)
				deleteGroup.MarkForDeletion()
			Endif
		Next
		
		Return deletedBlock
	End
	
	
	Method DrawSelector:Void()
		If selectorImage Then selectorImage.Draw(GetSlotCenterX(playerBlocksCol), GetSlotCenterY(GetSelectorRow()))
	End

	
	Method DrawBlocks:Void()
		For Local i:Int = 0 Until Self.slotColCount
			For Local j:Int = 0 To Self.slotRowCount
				If Self.slots[i][j] Then Self.slots[i][j].Draw()
			Next
		Next
	End
	
	
	Method Draw:Void()
		If backgroundImage Then backgroundImage.Draw(x, y)
		
		DrawBlocks()
		If _playerBlocks Then _playerBlocks.Draw()
		If _nextBlocks Then _nextBlocks.Draw()
		DrawSelector()
	
		If overlayImage Then overlayImage.Draw(x,y)		
	End
	

	Method DrawDebug:Void()
		For Local i:Int = 0 Until Self.slotColCount
			DrawRect(GetSlotCenterX(i), 50, 1, 500)
		Next
		For Local i:Int = 0 Until Self.slotRowCount
			DrawRect(170, GetSlotCenterY(i), 420, 1)
		Next


		If _playerBlocks 
			SetColor 0,255,0
			DrawRect(170, GetSlotCenterY(GetRow(_playerBlocks.GetY()+_playerBlocks.GetH()))-3, 420, 6)
			If _playerBlocks.blocks[2].HasTarget()
				SetColor 255,0,0
				DrawRect(170, _playerBlocks.blocks[2].target.y -2, 420, 4)
			Endif
			SetColor 255,255,255
		Endif
	End
End
bye
Ron
degac
(Posted 2015) [#3]
Hi

In C:\BlitzMax150\samples\birdie\games there's a simple 3-match game.
You can check it how it works.