@tanagram/cli 0.4.14 → 0.4.18

package/tui/renderer.go

@@ -1,359 +0,0 @@
-package tui
-
-import (
-	"encoding/json"
-	"math"
-	"os"
-
-	"github.com/charmbracelet/lipgloss"
-)
-
-// TanagramRenderer handles rendering tangram pieces to an ASCII canvas
-type TanagramRenderer struct {
-	width  int
-	height int
-}
-
-// NewTanagramRenderer creates a new renderer with the given dimensions
-func NewTanagramRenderer(width, height int) *TanagramRenderer {
-	return &TanagramRenderer{
-		width:  width,
-		height: height,
-	}
-}
-
-// RenderPiecesToCanvas renders a slice of pieces to an ASCII canvas
-func (r *TanagramRenderer) RenderPiecesToCanvas(pieces []TangramPiece) [][]int {
-	canvas := make([][]int, r.height)
-	for i := range canvas {
-		canvas[i] = make([]int, r.width)
-	}
-
-	// Render each piece
-	for idx, piece := range pieces {
-		r.renderPieceToCanvas(&canvas, piece, idx)
-	}
-
-	return canvas
-}
-
-// renderPieceToCanvas renders a single piece to the canvas
-func (r *TanagramRenderer) renderPieceToCanvas(canvas *[][]int, piece TangramPiece, pieceIndex int) {
-	points := r.getPiecePoints(piece)
-
-	for _, point := range points {
-		x := piece.Position.X + point.X
-		y := piece.Position.Y + point.Y
-
-		if y >= 0 && y < len(*canvas) && x >= 0 && x < len((*canvas)[0]) {
-			(*canvas)[y][x] = pieceIndex + 1
-		}
-	}
-}
-
-// getPiecePoints generates all points for a piece (handles rotation, flip, aspect ratio)
-func (r *TanagramRenderer) getPiecePoints(piece TangramPiece) []Position {
-	var basePoints []Position
-
-	// Generate pieces in "true" square proportions
-	switch piece.Type {
-	case SmallTriangle:
-		height := 8
-		for y := 0; y < height; y++ {
-			for x := 0; x <= height-1-y; x++ {
-				basePoints = append(basePoints, Position{x, y})
-			}
-		}
-	case MediumTriangle:
-		height := 10
-		for y := 0; y < height; y++ {
-			for x := 0; x <= height-1-y; x++ {
-				basePoints = append(basePoints, Position{x, y})
-			}
-		}
-	case LargeTriangle:
-		height := 14
-		for y := 0; y < height; y++ {
-			for x := 0; x <= height-1-y; x++ {
-				basePoints = append(basePoints, Position{x, y})
-			}
-		}
-	case Square:
-		size := 9
-		for y := 0; y < size; y++ {
-			for x := 0; x < size; x++ {
-				basePoints = append(basePoints, Position{x, y})
-			}
-		}
-	case Parallelogram:
-		height := 5
-		baseLength := 11
-		for y := 0; y < height; y++ {
-			offset := height - 1 - y
-			for x := 0; x < baseLength; x++ {
-				basePoints = append(basePoints, Position{x + offset, y})
-			}
-		}
-	}
-
-	// Apply rotation
-	rotatedPoints := r.rotatePoints(basePoints, piece.Rotation)
-
-	// Fill gaps
-	rotatedPoints = r.fillShape(rotatedPoints)
-
-	// Apply flip
-	if piece.Flipped {
-		rotatedPoints = r.flipPoints(rotatedPoints)
-	}
-
-	// Apply aspect ratio correction
-	aspectCorrectedPoints := make([]Position, 0, len(rotatedPoints)*2)
-	for _, p := range rotatedPoints {
-		aspectCorrectedPoints = append(aspectCorrectedPoints, Position{p.X * 2, p.Y})
-		aspectCorrectedPoints = append(aspectCorrectedPoints, Position{p.X*2 + 1, p.Y})
-	}
-
-	return aspectCorrectedPoints
-}
-
-// rotatePoints rotates points by the given angle
-func (r *TanagramRenderer) rotatePoints(points []Position, angle int) []Position {
-	if angle == 0 {
-		return points
-	}
-
-	var rotated []Position
-	rad := float64(angle) * math.Pi / 180.0
-	cos := math.Cos(rad)
-	sin := math.Sin(rad)
-
-	var sumX, sumY int
-	for _, p := range points {
-		sumX += p.X
-		sumY += p.Y
-	}
-	centerX := float64(sumX) / float64(len(points))
-	centerY := float64(sumY) / float64(len(points))
-
-	for _, p := range points {
-		x := float64(p.X) - centerX
-		y := float64(p.Y) - centerY
-
-		newX := x*cos - y*sin
-		newY := x*sin + y*cos
-
-		rotated = append(rotated, Position{
-			X: int(math.Round(newX + centerX)),
-			Y: int(math.Round(newY + centerY)),
-		})
-	}
-
-	// Normalize to positive coordinates
-	minX, minY := rotated[0].X, rotated[0].Y
-	for _, p := range rotated {
-		if p.X < minX {
-			minX = p.X
-		}
-		if p.Y < minY {
-			minY = p.Y
-		}
-	}
-
-	for i := range rotated {
-		rotated[i].X -= minX
-		rotated[i].Y -= minY
-	}
-
-	return rotated
-}
-
-// fillShape fills gaps in rotated shapes
-func (r *TanagramRenderer) fillShape(points []Position) []Position {
-	if len(points) == 0 {
-		return points
-	}
-
-	minX, maxX := points[0].X, points[0].X
-	minY, maxY := points[0].Y, points[0].Y
-	for _, p := range points {
-		if p.X < minX {
-			minX = p.X
-		}
-		if p.X > maxX {
-			maxX = p.X
-		}
-		if p.Y < minY {
-			minY = p.Y
-		}
-		if p.Y > maxY {
-			maxY = p.Y
-		}
-	}
-
-	filledMap := make(map[Position]bool)
-
-	// Fill horizontally
-	for y := minY; y <= maxY; y++ {
-		var xCoords []int
-		for _, p := range points {
-			if p.Y == y {
-				xCoords = append(xCoords, p.X)
-			}
-		}
-		if len(xCoords) == 0 {
-			continue
-		}
-		rowMinX, rowMaxX := xCoords[0], xCoords[0]
-		for _, x := range xCoords {
-			if x < rowMinX {
-				rowMinX = x
-			}
-			if x > rowMaxX {
-				rowMaxX = x
-			}
-		}
-		for x := rowMinX; x <= rowMaxX; x++ {
-			filledMap[Position{x, y}] = true
-		}
-	}
-
-	// Fill vertically
-	for x := minX; x <= maxX; x++ {
-		var yCoords []int
-		for p := range filledMap {
-			if p.X == x {
-				yCoords = append(yCoords, p.Y)
-			}
-		}
-		if len(yCoords) == 0 {
-			continue
-		}
-		colMinY, colMaxY := yCoords[0], yCoords[0]
-		for _, y := range yCoords {
-			if y < colMinY {
-				colMinY = y
-			}
-			if y > colMaxY {
-				colMaxY = y
-			}
-		}
-		for y := colMinY; y <= colMaxY; y++ {
-			filledMap[Position{x, y}] = true
-		}
-	}
-
-	filledPoints := make([]Position, 0, len(filledMap))
-	for p := range filledMap {
-		filledPoints = append(filledPoints, p)
-	}
-
-	return filledPoints
-}
-
-// flipPoints flips points horizontally
-func (r *TanagramRenderer) flipPoints(points []Position) []Position {
-	if len(points) == 0 {
-		return points
-	}
-
-	maxX := points[0].X
-	for _, p := range points {
-		if p.X > maxX {
-			maxX = p.X
-		}
-	}
-
-	var flipped []Position
-	for _, p := range points {
-		flipped = append(flipped, Position{
-			X: maxX - p.X,
-			Y: p.Y,
-		})
-	}
-
-	return flipped
-}
-
-// CanvasToString converts a canvas to a styled string
-func (r *TanagramRenderer) CanvasToString(canvas [][]int, pieces []TangramPiece) string {
-	var lines []string
-	for y, row := range canvas {
-		var line string
-		for x := range row {
-			char, color := r.getCellDisplay(canvas, x, y, pieces)
-			if color != "" {
-				style := lipgloss.NewStyle().Foreground(color)
-				line += style.Render(string(char))
-			} else {
-				line += string(char)
-			}
-		}
-		lines = append(lines, line)
-	}
-	return lipgloss.JoinVertical(lipgloss.Left, lines...)
-}
-
-// getCellDisplay returns the character and color for a cell
-func (r *TanagramRenderer) getCellDisplay(canvas [][]int, x, y int, pieces []TangramPiece) (rune, lipgloss.Color) {
-	pieceID := canvas[y][x]
-
-	if pieceID == 0 {
-		return ' ', ""
-	}
-
-	pieceIndex := pieceID - 1
-	if pieceIndex >= len(pieces) {
-		return ' ', ""
-	}
-
-	piece := pieces[pieceIndex]
-	return '█', piece.Color
-}
-
-// LoadTanagramConfig loads a tangram configuration from a JSON file
-func LoadTanagramConfig(filename string) ([]TangramPiece, error) {
-	data, err := os.ReadFile(filename)
-	if err != nil {
-		return nil, err
-	}
-
-	type SavedPiece struct {
-		ID       int      `json:"id"`
-		Type     string   `json:"type"`
-		Position Position `json:"position"`
-		Rotation int      `json:"rotation"`
-		Flipped  bool     `json:"flipped"`
-	}
-
-	var savedPieces []SavedPiece
-	err = json.Unmarshal(data, &savedPieces)
-	if err != nil {
-		return nil, err
-	}
-
-	// Color mapping for each piece ID
-	colors := map[int]lipgloss.Color{
-		1: "#BA68C8", // Purple
-		2: "#FFB74D", // Orange
-		3: "#42A5F5", // Blue
-		4: "#EF4444", // Red
-		5: "#FF9800", // Orange
-		6: "#7E57C2", // Purple
-		7: "#66BB6A", // Green
-	}
-
-	var pieces []TangramPiece
-	for _, saved := range savedPieces {
-		pieces = append(pieces, TangramPiece{
-			ID:       saved.ID,
-			Type:     PieceType(saved.Type),
-			Color:    colors[saved.ID],
-			Position: saved.Position,
-			Rotation: saved.Rotation,
-			Flipped:  saved.Flipped,
-		})
-	}
-
-	return pieces, nil
-}