last_light/render/grid.go

package render

import (
	"mvvasilev/last_light/util"

	"github.com/gdamore/tcell/v2"
	"github.com/gdamore/tcell/v2/views"
	"github.com/google/uuid"
)

type Grid struct {
	id uuid.UUID

	internalCellSize   util.Size
	numCellsHorizontal uint16
	numCellsVertical   uint16
	position           util.Position
	style              tcell.Style

	northBorder rune
	westBorder  rune
	eastBorder  rune
	southBorder rune

	internalVerticalBorder   rune
	internalHorizontalBorder rune

	nwCorner rune
	swCorner rune
	seCorner rune
	neCorner rune

	verticalDownwardsTJunction rune
	verticalUpwardsTJunction   rune
	horizontalLeftTJunction    rune
	horizontalRightTJunction   rune
	crossJunction              rune

	fillRune rune
}

func CreateSimpleGrid(
	x, y uint16,
	cellWidth, cellHeight uint16,
	numCellsHorizontal, numCellsVertical uint16,
	borderRune, fillRune rune,
	style tcell.Style,
) Grid {
	return CreateGrid(
		x, y, cellWidth, cellHeight, numCellsHorizontal, numCellsVertical,
		borderRune, borderRune, borderRune, borderRune,
		borderRune, fillRune, borderRune, borderRune,
		borderRune, borderRune, borderRune, borderRune,
		borderRune, borderRune, borderRune, borderRune,
		style,
	)
}

// '┌', '─', '┬', '┐',
// '│', '#', '│', '│',
// '├', '─', '┼', '┤',
// '└', '─', '┴', '┘',
func CreateGrid(
	x uint16,
	y uint16,
	cellWidth uint16,
	cellHeight uint16,
	numCellsHorizontal uint16,
	numCellsVertical uint16,
	nwCorner, northBorder, verticalDownwardsTJunction, neCorner,
	westBorder, fillRune, internalVerticalBorder, eastBorder,
	horizontalRightTJunction, internalHorizontalBorder, crossJunction, horizontalLeftTJunction,
	swCorner, southBorder, verticalUpwardsTJunction, seCorner rune,
	style tcell.Style,
) Grid {
	return Grid{
		id:                         uuid.New(),
		internalCellSize:           util.SizeOf(cellWidth, cellHeight),
		numCellsHorizontal:         numCellsHorizontal,
		numCellsVertical:           numCellsVertical,
		position:                   util.PositionAt(x, y),
		style:                      style,
		northBorder:                northBorder,
		eastBorder:                 eastBorder,
		southBorder:                southBorder,
		westBorder:                 westBorder,
		internalVerticalBorder:     internalVerticalBorder,
		internalHorizontalBorder:   internalHorizontalBorder,
		nwCorner:                   nwCorner,
		seCorner:                   seCorner,
		swCorner:                   swCorner,
		neCorner:                   neCorner,
		verticalDownwardsTJunction: verticalDownwardsTJunction,
		verticalUpwardsTJunction:   verticalUpwardsTJunction,
		horizontalRightTJunction:   horizontalRightTJunction,
		horizontalLeftTJunction:    horizontalLeftTJunction,
		fillRune:                   fillRune,

		crossJunction: crossJunction,
	}
}

func (g Grid) UniqueId() uuid.UUID {
	return g.id
}

// C###T###T###C
// #   #   #   #
// #   #   #   #
// #   #   #   #
// T###X###X###T
// #   #   #   #
// #   #   #   #
// #   #   #   #
// T###X###X###T
// #   #   #   #
// #   #   #   #
// #   #   #   #
// C###T###T###C
func (g Grid) drawBorders(v views.View) {
	iCellSizeWidth := g.internalCellSize.Width()
	iCellSizeHeight := g.internalCellSize.Height()
	width := 1 + (iCellSizeWidth * int(g.numCellsHorizontal)) + (int(g.numCellsHorizontal))
	height := 1 + (iCellSizeHeight * int(g.numCellsVertical)) + (int(g.numCellsVertical))
	x := g.position.X()
	y := g.position.Y()

	v.SetContent(x, y, g.nwCorner, nil, g.style)
	v.SetContent(x+width-1, y, g.neCorner, nil, g.style)
	v.SetContent(x, y+height-1, g.swCorner, nil, g.style)
	v.SetContent(x+width-1, y+height-1, g.seCorner, nil, g.style)

	for w := 1; w < width-1; w++ {

		for iw := 1; iw < int(g.numCellsVertical); iw++ {
			if w%(iCellSizeWidth+1) == 0 {
				v.SetContent(x+w, y+(iw*iCellSizeHeight+iw), g.crossJunction, nil, g.style)
				continue
			}

			v.SetContent(x+w, y+(iw*iCellSizeHeight+iw), g.internalHorizontalBorder, nil, g.style)
		}

		if w%(iCellSizeWidth+1) == 0 {
			v.SetContent(x+w, y, g.verticalDownwardsTJunction, nil, g.style)
			v.SetContent(x+w, y+height-1, g.verticalUpwardsTJunction, nil, g.style)
			continue
		}

		v.SetContent(x+w, y, g.northBorder, nil, g.style)
		v.SetContent(x+w, y+height-1, g.southBorder, nil, g.style)
	}

	for h := 1; h < height-1; h++ {

		for ih := 1; ih < int(g.numCellsHorizontal); ih++ {
			if h%(iCellSizeHeight+1) == 0 {
				v.SetContent(x+(ih*iCellSizeHeight+ih), y+h, g.crossJunction, nil, g.style)
				continue
			}

			v.SetContent(x+(ih*iCellSizeHeight+ih), y+h, g.internalVerticalBorder, nil, g.style)
		}

		if h%(iCellSizeHeight+1) == 0 {
			v.SetContent(x, y+h, g.horizontalRightTJunction, nil, g.style)
			v.SetContent(x+width-1, y+h, g.horizontalLeftTJunction, nil, g.style)
			continue
		}

		v.SetContent(x, y+h, g.westBorder, nil, g.style)
		v.SetContent(x+width-1, y+h, g.eastBorder, nil, g.style)
	}
}

func (g Grid) drawFill(v views.View) {

}

func (g Grid) Draw(v views.View) {
	g.drawBorders(v)
	g.drawFill(v)
}