Matching Engine

Monkey Forums/Monkey Code/Matching Engine

Why0Why

(Posted 2012) [#1]

I like the way matching is done in the game Dungeon Raid and have enjoyed the game a lot. I am planning on using a similar matching style, but making a much deeper game. This is the base engine. It draws a grid and populates each cell with random numbers from 1-4. Drag your mouse over 2 or more matching adjacent cells to complete a match. Once you release the mouse button, it drops the above cells down and repopulates empty cells.

The community has been so great here that I wanted to post some code that might help someone else. I have commented it fairly well, if anyone has any questions, feel free to ask.


Import mojo

Global IsMouseDown:Bool

Class MyApp Extends App

Field GameGrid:Grid	

	Method OnCreate()
	
		SetUpdateRate( 60 )
		GameGrid = New Grid(10,10,32,32,50,50,0,0)
		
	End Method
	


	Method OnUpdate()
	
	GameGrid.GetCurrentCell(MouseX,MouseY)

	if MouseDown(MOUSE_LEFT) Then
		IsMouseDown=True 
		 ' if the mouse is down, check to see if it is over a different cell then the last update     
        if GameGrid.LastCellLocation <> GameGrid.Get1D(MouseX, MouseY) Then
			' Check to see if there is a match
            if GameGrid.LastCellValue = GameGrid.CurrentCellValue Then
                GameGrid.MatchList.AddLast( GameGrid.Get1D(MouseX, MouseY))
				' This adds the first match to the beginning of the list
				if GameGrid.MatchList.Count=1 Then GameGrid.MatchList.AddFirst(GameGrid.LastCellLocation)
                GameGrid.Matching=True    
            End
        EndIf
        GameGrid.LastCellValue = GameGrid.CurrentCellValue 
		GameGrid.LastCellLocation = GameGrid.Get1D(MouseX, MouseY)	
	EndIf
	
	if Not MouseDown(MOUSE_LEFT) Then
		' If the mouse button is released and there were matches, then clear the match and drop the cells down
		if GameGrid.Matching=True Then GameGrid.RemoveMatches
		IsMouseDown=False
		GameGrid.Matching=False
        GameGrid.MatchList.Clear()
	EndIf
	
	End Method
	


	Method OnRender()
		' Only redraw the grid if there has been a match to save render cycles
		If GameGrid.MatchComplete Then	
			GameGrid.Draw
			GameGrid.MatchComplete=False
		EndIf
			
		SetColor 0, 0, 255
		DrawText("The cell value is " + GameGrid.CurrentCellValue, 400,400,0,0)
		DrawText("MouseX="+MouseX,400,420,0,0)
		DrawText("MouseY="+MouseY,400,430,0,0)
		DrawText("1D Value="+GameGrid.Get1D(MouseX,MouseY),400,440,0,0)
		DrawText("Number Of Matches="+GameGrid.MatchList.Count,400,410,0,0)
	
	End Method
	
End Class

Class Grid
	Field NumXCells:Int ' How many cells across
	Field NumYCells:Int ' How many cells down
	Field CellWidth:Int
	Field CellHeight:Int
	Field xPad:Int ' If you want to put space between the cells, I didn't use this
	Field yPad:Int
	Field StartX:Int ' How far over the grid is from 0
	Field StartY:Int ' How far down the grid is from 0
	Field EndX:Int
	Field EndY:Int
	Field CurrentCellValue:Int
	Field Contents:Int[][]
	Field MatchList:IntList
	Field LastCellLocation:Int=0
	Field LastCellValue:Int
	Field Matching:Bool=False
	Field MatchComplete:Bool=True
	
	Method New(xcells:Int,ycells:Int,cellw:Int,cellh:Int,x:Int,y:Int,padx:Int,pady:Int)
		Local i:Int
		Local j:Int
		Seed=Millisecs()
	
		NumXCells=xcells
		NumYCells=ycells
		CellWidth=cellw
		CellHeight=cellh
		StartX=x
		StartY=y
		xPad=padx
		yPad=pady
		EndX=StartX+(NumXCells*CellWidth)+(xPad*NumXCells)
		EndY=StartY+(NumYCells*CellHeight)+(yPad*NumYCells)
		Contents=AllocateArray(NumXCells,NumYCells)
		
		' Assign a random value from 1-4 to each cell for matching purposes
		For i = 0 to NumXCells-1
			For j  = 0 to NumYCells-1
				Contents[i][j]=Self.AssignCellValue
			Next
		Next
		MatchList = New IntList
	End
	
	Method Draw()
		Local x:Int
		Local y:Int
	
		SetColor 0, 0, 255
		
		'Draw the borders of the grid
		DrawLine(StartX,StartY,EndX,StartY)
		DrawLine(StartX,StartY,StartX,EndY)
		DrawLine(EndX,StartY,EndX,EndX)
		DrawLine(StartX,EndY,EndX,EndY)
		
		For x = 0 to NumXCells-1
			For y  = 0 to NumYCells-1
				SetColor 0, 0, 0
				' Draw Gridlines around the numbers
				DrawLine(StartX,(y*CellHeight)+StartY,EndX,(y*CellHeight)+StartY)
				SetColor 255,255,255
				' Draw the assigned contents to the grid	
				DrawText(Contents[x][y],(StartX+(x*CellWidth)+CellWidth/2),(StartY+(y*CellHeight)+CellHeight/2),.5,.5)
			Next
			SetColor 0, 0, 255
			DrawLine((x*CellWidth)+StartX,StartY,(x*CellWidth)+StartX,EndY)
		Next
		
	End
	
	' Returns the value stored in the grid at the current mouse position
	Method GetCurrentCell(x:Int,y:Int)
		Local currentX:Int
		Local currentY:Int
		
		currentX=((x-StartX)/CellWidth)
		currentY=((y-StartY)/CellHeight)
		
		' Check to be sure the mouse is over the Game Grid
		if currentX >=0 And currentX<=NumXCells-1 And currentY>=0 And currentY<=NumYCells-1 Then
			self.CurrentCellValue=Contents[currentX][currentY]
		Else
			self.CurrentCellValue=0
		EndIf
		
	End
	
	' Returns array position in 1D for easy storing in an intlist
	Method Get1D:Int(x:Int,y:Int)
		Local currentX:Int
		Local currentY:Int
		
		currentX=((x-StartX)/CellWidth)
		currentY=((y-StartY)/CellHeight)
		Return ((currentY*Self.NumXCells)+currentX)
	End
	
	' This removes the matches from the grid and drops the tiles above the match down into matched cells
	Method RemoveMatches()
		Local Temp:Int
		Local x:Int
		local y:Int
		
		' Iterate through the matches stored in the intlist
		For Temp=EachIn MatchList
			' Check to see if we are at the top row, if so, there are no tiles to drop down so just assign a new value
			if Get2Dy(Temp)=0 Then 
				Contents[Get2Dx(Temp)][Get2Dy(Temp)]=Self.AssignCellValue
			Else
				' Assigns the contents of the above cell to the current cell
				For y = 0 to (Get2Dy(Temp)-1)
					Contents[Get2Dx(Temp)][(Get2Dy(Temp)-y)]=Contents[Get2Dx(Temp)][(Get2Dy(Temp)-(y+1))]
				Next	
			EndIf
			Contents[Get2Dx(Temp)][0]=Self.AssignCellValue
		Next
		self.MatchComplete=True
		Self.MatchList.Clear
	End
	
	' Converts the OneD location stored in the intlist and returns the X value
	Method Get2Dx(oneD:Int)	
		Return(oneD Mod Self.NumXCells)
	End
	
	' Converts the OneD location stored in the intlist and returns the Y value
	Method Get2Dy(oneD:Int)
		Return(oneD/Self.NumYCells)	
	End
	
	Method AssignCellValue:Int()
		Return Rnd(1,4)
	End
	
End

' Function to easily initialize a 2D array since Monkey uses an array of 1D arrays instead of traditional multi-dimensional arrays. From muddy_shoes on the Monkey Forums
Function AllocateArray:Int[][]( i:Int, j:Int)
    Local arr:Int[][] = New Int[i][]
	Local ind:Int
    For ind = 0 Until i
        arr[ind] = New Int[j]
    Next
    Return arr		
End


Function Main()

	New MyApp()
	
End Function

Gerry Quinn

(Posted 2012) [#2]

I usually make a Game class (handles game logic) and a GameWindow class (handles UI and drawing). The GameWindow passes user actions to the Game. The App sets the other two classes up and calls Update() and Draw() functions on the GameWindow (and a SetMetrics() function at the start). This separation of functions makes for smaller classes, which is good as your game becomes more elaborate and accretes buttons, menus and suchlike.

I also have handy Point, Size and Rect functions (patterned on Microsoft's old MFC), so for example my GameWindow will have a field cell00:Rect, which cuts down on the number of fields needed. Then I can write (for example):

Function GetCellRect:Rect( cell:Point )
	Local rect:Rect = New Rect( cell00 )
	rect.Offset( cell.x * rect.size.w, cell.y * rect.size.h )
	Return rect
End

That said, your Grid is fine too. To be honest I find myself writing patterns like the above over and over and I always say to myself 'Why not have a Grid class'. On the other hand I also don't mind laying down a bit of boilerplate of this kind when I start a new project - it sort of eases me into it.

Gerry Quinn

(Posted 2012) [#3]

Function GetCellRect( cell:Point )

End

Gerry Quinn

(Posted 2012) [#4]

Function GetCellRect( cell:Point )

End

Gerry Quinn

(Posted 2012) [#5]

Function GetCellRect( cell:Point )

End

NoOdle

(Posted 2012) [#6]

On the other hand I also don't mind laying down a bit of boilerplate of this kind when I start a new project - it sort of eases me into it.

Theres only so many times I can write the same piece of code before I start thinking "Why am I doing this?" I already know how to write it in my head so the challenge and fun disappear... I'm grinding code - a bit like questing in MMO's!

slenkar

(Posted 2012) [#7]

I usually make a Game class (handles game logic) and a GameWindow class (handles UI and drawing).

NoOdle

(Posted 2012) [#8]

I create layers. A layer can be used for anything, background, ui, game logic. Rendered in z order so background could be rendered first, ui layer rendered last. Fairly flexible and works well from the tests I've done. Layers can receive touch events based on a flag and swallow them as appropriate or pass them on to the layer below for checking and so on.

Gerry Quinn

(Posted 2012) [#9]

Sorry about the extra posts - I thought I was editing one post but it seems the forum thought otherwise!

"Theres only so many times I can write the same piece of code before I start thinking "Why am I doing this?""

Generally that's true for me also, but setting up very basic framework stuff at the start of a project is stuff I can do in my sleep and it helps me get into the mood. Also if I did a grid framework I'd be saying to myself "This should also do hex grids". Then I would wonder should it be able to clear a basic grid and if so should it be a quadrangle or a hexagon...

So I'd just end up wasting time compared to just writing a few simple methods...

It's the boring non-game stuff like menus that I like to get into libraries and only do once (though they always get new features added in every new project...)

Why0Why

(Posted 2012) [#10]

This isn't what the final will look like. I just put all of this here like this so it was self contained. Obviously, graphics, sounds and all of the specific stuff will be organized differently. I just wanted the core logic in place and I wanted something that people could run without adding graphics or anything else.