luminos / grid.go

package main

import (
	"bytes"
	"strconv"

	ff "github.com/firefly-zero/firefly-go/firefly"
)

type Grid struct {
	NumRows int
	NumCols int
	Grid    [][]int
}

func (grid *Grid) Initialize() {
	grid.NumRows = CONFIG.Grid.Rows
	grid.NumCols = CONFIG.Grid.Columns
	grid.Grid = make([][]int, grid.NumRows)
	for i := range grid.Grid {
		grid.Grid[i] = make([]int, grid.NumCols)
	}
}

// Prints Game state for debug purposes
func (grid *Grid) Print() {
	for row := 0; row < CONFIG.Grid.Rows; row++ {
		var b bytes.Buffer
		b.WriteString(strconv.Itoa(row))
		b.WriteString(":\t")
		for col := 0; col < CONFIG.Grid.Columns; col++ {
			b.WriteString(strconv.Itoa(grid.Grid[row][col]))
		}
		ff.LogDebug(b.String())
	}
}

func (grid *Grid) Render() {
	// TODO: implement proper offset configuration, so the grid is displayed centered

	for row := 0; row < grid.NumRows; row++ {
		for col := 0; col < grid.NumCols; col++ {
			cellValue := grid.Grid[row][col]

			// cellValue 0 means empty cell / no block
			if cellValue == 0 {
				ff.DrawRect(
					ff.P(col*CELLSIZE+OFFSET, row*CELLSIZE),
					ff.S(CELLSIZE-1, CELLSIZE-1),
					ff.Style{
						FillColor:   CONFIG.Grid.FillColor,
						StrokeColor: CONFIG.Grid.StrokeColor,
						StrokeWidth: 1,
					},
				)
			} else {
				// cellValue > 0 means a block; here we determine the color
				color := grid.getCellColor(cellValue)

				ff.DrawRect(
					ff.P(col*CELLSIZE+OFFSET, row*CELLSIZE),
					ff.S(CELLSIZE-1, CELLSIZE-1),
					ff.Style{
						FillColor:   color,
						StrokeColor: color,
						StrokeWidth: 1,
					},
				)
			}
		}
	}
}

func (grid *Grid) getCellColor(cellValue int) ff.Color {
	var color ff.Color

	// if the cellValue < 10, then we are in single player mode
	// and each distinct cellValue is supposed to get a dedicated
	// color as configured per block type
	if cellValue < 10 {
		return *COLORS[cellValue]
	} else if CONFIG.GameMode == MultiplayerCoop {
		// but in multiplayer mode, blocks of a player have the same color
		// player1 has cellValues 11, 12, 13, 14, 15, 16, 17 - he gets COLORS[1]
		// player2 has cellValues 21, 22, 23, 24, 25, 26, 27 - he gets COLORS[2]
		// playerN has cellValues N1, N2, NN, N4, N5, N6, N7 - he gets COLORS[N]
		// ... as len(COLORS) == 8 this would break with more than 8 players
		return *COLORS[cellValue/10]
	}
	return color
}

func (grid *Grid) IsCellOutside(row, column int) bool {
	if row >= 0 && row < grid.NumRows && column >= 0 && column < grid.NumCols {
		return false
	}
	return true
}

func (grid *Grid) IsCellEmpty(row, column int) bool {
	return grid.Grid[row][column] == 0
}

func (grid *Grid) IsRowFull(row int) bool {
	for column := 0; column < grid.NumCols; column++ {
		if grid.Grid[row][column] == 0 {
			return false
		}
	}
	return true
}

func (grid *Grid) ClearRow(row int) {
	for column := 0; column < grid.NumCols; column++ {
		grid.Grid[row][column] = 0
	}
}

func (grid *Grid) ClearFullRows() int {
	completed := 0
	for row := grid.NumRows - 1; row >= 0; row-- {
		if grid.IsRowFull(row) {
			grid.ClearRow(row)
			completed++
		} else if completed > 0 {
			grid.MoveRowDown(row, completed)
		}
	}
	return completed
}

func (grid *Grid) MoveRowDown(row, numRows int) {
	for column := 0; column < grid.NumCols; column++ {
		grid.Grid[row+numRows][column] = grid.Grid[row][column]
		grid.Grid[row][column] = 0
	}
}

func (grid *Grid) LockBlock(tiles []Position, blockID int, player *Player) {
	// In MultiplayerCoop we add a multiple of 10 (playerOffset) to the blockID
	// to identify which player locked the block (e.g. to color the blocks accordingly)
	//
	// player1 has cellValues 11, 12, 13, 14, 15, 16, 17 - he gets COLORS[1]
	// player2 has cellValues 21, 22, 23, 24, 25, 26, 27 - he gets COLORS[2]
	// playerN has cellValues N1, N2, NN, N4, N5, N6, N7 - he gets COLORS[N]
	playerOffset := 0
	if CONFIG.GameMode == MultiplayerCoop {
		playerOffset = (player.playerNum + 1) * 10
	}

	for _, tile := range tiles {
		grid.Grid[tile.Row][tile.Column] = blockID + playerOffset
	}
}

// CanFitBlock checks if a block's tiles can fit in the grid
func (grid *Grid) CanFitBlock(tiles []Position) bool {
	for _, tile := range tiles {
		if grid.IsCellOutside(tile.Row, tile.Column) {
			return false
		}
		if !grid.IsCellEmpty(tile.Row, tile.Column) {
			return false
		}
	}
	return true
}