@tanagram/cli 0.4.14 → 0.4.19

package/tui/puzzle.go

@@ -1,694 +0,0 @@
-package tui
-
-import (
-	"encoding/json"
-	"fmt"
-	"math"
-	"os"
-	"strings"
-
-	tea "github.com/charmbracelet/bubbletea"
-	"github.com/charmbracelet/lipgloss"
-)
-
-// PieceType represents the type of tangram piece
-type PieceType string
-
-const (
-	LargeTriangle  PieceType = "large-triangle"
-	MediumTriangle PieceType = "medium-triangle"
-	SmallTriangle  PieceType = "small-triangle"
-	Square         PieceType = "square"
-	Parallelogram  PieceType = "parallelogram"
-)
-
-// Position represents x,y coordinates
-type Position struct {
-	X int
-	Y int
-}
-
-// TangramPiece represents a single tangram piece
-type TangramPiece struct {
-	ID       int
-	Type     PieceType
-	Color    lipgloss.Color
-	Position Position
-	Rotation int // 0, 90, 180, 270
-	Flipped  bool
-}
-
-// PuzzleModel is the Bubble Tea model for the puzzle editor
-type PuzzleModel struct {
-	pieces        []TangramPiece
-	selectedIndex int
-	canvasWidth   int
-	canvasHeight  int
-	width         int
-	height        int
-}
-
-// NewPuzzleModel creates a new puzzle editor model
-func NewPuzzleModel() PuzzleModel {
-	// Define the 7 tangram pieces with initial scattered positions
-	pieces := []TangramPiece{
-		{ID: 1, Type: SmallTriangle, Color: "#BA68C8", Position: Position{2, 1}, Rotation: 0, Flipped: false},
-		{ID: 2, Type: SmallTriangle, Color: "#FFB74D", Position: Position{20, 1}, Rotation: 0, Flipped: false},
-		{ID: 3, Type: MediumTriangle, Color: "#42A5F5", Position: Position{38, 1}, Rotation: 0, Flipped: false},
-		{ID: 4, Type: LargeTriangle, Color: "#EF4444", Position: Position{2, 10}, Rotation: 0, Flipped: false},
-		{ID: 5, Type: LargeTriangle, Color: "#FF9800", Position: Position{32, 10}, Rotation: 0, Flipped: false},
-		{ID: 6, Type: Square, Color: "#7E57C2", Position: Position{62, 1}, Rotation: 0, Flipped: false},
-		{ID: 7, Type: Parallelogram, Color: "#66BB6A", Position: Position{62, 10}, Rotation: 0, Flipped: false},
-	}
-
-	return PuzzleModel{
-		pieces:        pieces,
-		selectedIndex: 0,
-		canvasWidth:   120,
-		canvasHeight:  45,
-	}
-}
-
-// Init initializes the model
-func (m PuzzleModel) Init() tea.Cmd {
-	return nil
-}
-
-// Update handles messages
-func (m PuzzleModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
-	switch msg := msg.(type) {
-	case tea.KeyMsg:
-		switch msg.String() {
-		case "ctrl+c", "q", "esc":
-			return m, tea.Quit
-		case "left", "h":
-			// Select previous piece
-			m.selectedIndex = (m.selectedIndex - 1 + len(m.pieces)) % len(m.pieces)
-		case "right", "l":
-			// Select next piece
-			m.selectedIndex = (m.selectedIndex + 1) % len(m.pieces)
-		case "up", "k":
-			// Move selected piece up
-			if m.pieces[m.selectedIndex].Position.Y > 0 {
-				m.pieces[m.selectedIndex].Position.Y--
-			}
-		case "down", "j":
-			// Move selected piece down
-			if m.pieces[m.selectedIndex].Position.Y < m.canvasHeight-15 {
-				m.pieces[m.selectedIndex].Position.Y++
-			}
-		case "shift+left", "H":
-			// Move selected piece left
-			if m.pieces[m.selectedIndex].Position.X > 0 {
-				m.pieces[m.selectedIndex].Position.X--
-			}
-		case "shift+right", "L":
-			// Move selected piece right
-			if m.pieces[m.selectedIndex].Position.X < m.canvasWidth-35 {
-				m.pieces[m.selectedIndex].Position.X++
-			}
-		case "r":
-			// Rotate 90° clockwise
-			m.pieces[m.selectedIndex].Rotation = (m.pieces[m.selectedIndex].Rotation + 90) % 360
-		case "R":
-			// Rotate 90° counter-clockwise
-			m.pieces[m.selectedIndex].Rotation = (m.pieces[m.selectedIndex].Rotation - 90 + 360) % 360
-		case "[":
-			// Rotate 45° counter-clockwise (fine rotation)
-			m.pieces[m.selectedIndex].Rotation = (m.pieces[m.selectedIndex].Rotation - 45 + 360) % 360
-		case "]":
-			// Rotate 45° clockwise (fine rotation)
-			m.pieces[m.selectedIndex].Rotation = (m.pieces[m.selectedIndex].Rotation + 45) % 360
-		case "f":
-			// Flip piece
-			m.pieces[m.selectedIndex].Flipped = !m.pieces[m.selectedIndex].Flipped
-		case "e":
-			// Export configuration to console
-			m.exportConfig()
-		case "s":
-			// Save configuration to file
-			m.saveConfig()
-		case "o":
-			// Open/load configuration from file
-			m.loadConfig()
-		}
-	case tea.WindowSizeMsg:
-		m.width = msg.Width
-		m.height = msg.Height
-	}
-	return m, nil
-}
-
-// View renders the UI
-func (m PuzzleModel) View() string {
-	// Create canvas with piece IDs (0 = empty, 1-7 = piece IDs)
-	canvas := make([][]int, m.canvasHeight)
-	for i := range canvas {
-		canvas[i] = make([]int, m.canvasWidth)
-	}
-
-	// Render pieces (in order, so later pieces appear on top)
-	for idx, piece := range m.pieces {
-		m.renderPieceToCanvas(&canvas, piece, idx)
-	}
-
-	// Convert canvas to styled string with smooth edges
-	var lines []string
-	for y, row := range canvas {
-		var line strings.Builder
-		for x := range row {
-			char, color := m.getCellDisplay(canvas, x, y)
-			if color != "" {
-				style := lipgloss.NewStyle().Foreground(color)
-				line.WriteString(style.Render(string(char)))
-			} else {
-				line.WriteRune(char)
-			}
-		}
-		lines = append(lines, line.String())
-	}
-
-	canvasOutput := strings.Join(lines, "\n")
-
-	// Border for canvas
-	canvasBorder := lipgloss.NewStyle().
-		Border(lipgloss.RoundedBorder()).
-		BorderForeground(lipgloss.Color("#8B5CF6")).
-		Padding(0, 1)
-
-	borderedCanvas := canvasBorder.Render(canvasOutput)
-
-	// Title
-	titleStyle := lipgloss.NewStyle().
-		Bold(true).
-		Foreground(lipgloss.Color("#FFFFFF")).
-		Background(lipgloss.Color("#8B5CF6")).
-		Padding(0, 2)
-
-	title := titleStyle.Render(" TANAGRAM PUZZLE EDITOR ")
-
-	// Selected piece info
-	selectedPiece := m.pieces[m.selectedIndex]
-	infoStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#AAAAAA"))
-
-	info := infoStyle.Render(fmt.Sprintf(
-		"  Piece #%d (%s) @ (%d,%d) • %d° • Flipped:%t",
-		selectedPiece.ID,
-		m.shortType(selectedPiece.Type),
-		selectedPiece.Position.X,
-		selectedPiece.Position.Y,
-		selectedPiece.Rotation,
-		selectedPiece.Flipped,
-	))
-
-	// Piece legend - compact version
-	var legendParts []string
-	for idx, piece := range m.pieces {
-		pieceStyle := lipgloss.NewStyle().Foreground(piece.Color).Bold(true)
-		marker := " "
-		if idx == m.selectedIndex {
-			marker = "▶"
-		}
-		legendParts = append(legendParts, fmt.Sprintf("%s%s%d",
-			marker,
-			pieceStyle.Render("█"),
-			piece.ID,
-		))
-	}
-	legendStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("#888888"))
-	legend := legendStyle.Render("  Pieces: " + strings.Join(legendParts, " "))
-
-	// Controls help - more compact
-	helpStyle := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("#666666")).
-		Italic(true)
-
-	help := helpStyle.Render(
-		"  ←→/hl:select  ↑↓/kj:move  H/L:move left/right  r/R:90°  [/]:45°  f:flip  s:save  o:load  e:export  q:quit",
-	)
-
-	// Combine all parts with consistent spacing
-	return lipgloss.JoinVertical(lipgloss.Left,
-		"",
-		title,
-		info,
-		"",
-		borderedCanvas,
-		"",
-		legend,
-		help,
-		"",
-	)
-}
-
-// shortType returns abbreviated type name
-func (m PuzzleModel) shortType(t PieceType) string {
-	switch t {
-	case LargeTriangle:
-		return "Lg△"
-	case MediumTriangle:
-		return "Md△"
-	case SmallTriangle:
-		return "Sm△"
-	case Square:
-		return "□"
-	case Parallelogram:
-		return "▱"
-	default:
-		return string(t)
-	}
-}
-
-// renderPieceToCanvas renders a piece to the canvas by piece ID
-func (m PuzzleModel) renderPieceToCanvas(canvas *[][]int, piece TangramPiece, pieceIndex int) {
-	// Get piece shape based on type and rotation
-	points := m.getPiecePoints(piece)
-
-	// Fill the piece area with piece index + 1 (so 0 remains empty)
-	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
-		}
-	}
-}
-
-// getCellDisplay returns the character and color for a cell
-func (m PuzzleModel) getCellDisplay(canvas [][]int, x, y int) (rune, lipgloss.Color) {
-	pieceID := canvas[y][x]
-
-	// Empty cell - subtle grid pattern
-	if pieceID == 0 {
-		// Show very faint grid lines
-		if x%5 == 0 || y%5 == 0 {
-			return '·', lipgloss.Color("#444444")
-		}
-		return ' ', ""
-	}
-
-	pieceIndex := pieceID - 1
-	piece := m.pieces[pieceIndex]
-	isSelected := pieceIndex == m.selectedIndex
-
-	// Check if this is an edge cell
-	isEdge := m.isEdgeCell(canvas, x, y, pieceID)
-
-	// Use different characters for edges and fills to create depth
-	var char rune
-	if isSelected {
-		// Selected piece has lighter fill to show it's active
-		if isEdge {
-			char = '█' // Solid edge
-		} else {
-			char = '▓' // Lighter fill
-		}
-	} else {
-		// Normal pieces are all solid
-		char = '█'
-	}
-
-	return char, piece.Color
-}
-
-// isEdgeCell checks if a cell is on the edge of its piece
-func (m PuzzleModel) isEdgeCell(canvas [][]int, x, y int, pieceID int) bool {
-	// Check all 4 directions
-	directions := []struct{ dx, dy int }{
-		{-1, 0}, {1, 0}, {0, -1}, {0, 1},
-	}
-
-	for _, dir := range directions {
-		nx, ny := x+dir.dx, y+dir.dy
-
-		// Out of bounds = edge
-		if ny < 0 || ny >= len(canvas) || nx < 0 || nx >= len(canvas[0]) {
-			return true
-		}
-
-		// Different piece or empty = edge
-		if canvas[ny][nx] != pieceID {
-			return true
-		}
-	}
-
-	return false
-}
-
-// getPiecePoints returns the relative points for a piece based on its type and rotation
-func (m PuzzleModel) getPiecePoints(piece TangramPiece) []Position {
-	var basePoints []Position
-
-	// Generate pieces in "true" square proportions (before aspect ratio correction)
-	switch piece.Type {
-	case SmallTriangle:
-		// Small right triangle - 8x8 in true proportions
-		height := 8
-		for y := 0; y < height; y++ {
-			// Right triangle: width decreases by 1 each row
-			for x := 0; x <= height-1-y; x++ {
-				basePoints = append(basePoints, Position{x, y})
-			}
-		}
-	case MediumTriangle:
-		// Medium right triangle - 10x10 in true proportions
-		height := 10
-		for y := 0; y < height; y++ {
-			for x := 0; x <= height-1-y; x++ {
-				basePoints = append(basePoints, Position{x, y})
-			}
-		}
-	case LargeTriangle:
-		// Large right triangle - 14x14 in true proportions
-		height := 14
-		for y := 0; y < height; y++ {
-			for x := 0; x <= height-1-y; x++ {
-				basePoints = append(basePoints, Position{x, y})
-			}
-		}
-	case Square:
-		// Square - 9x9 in true proportions (between small and medium triangle)
-		size := 9
-		for y := 0; y < size; y++ {
-			for x := 0; x < size; x++ {
-				basePoints = append(basePoints, Position{x, y})
-			}
-		}
-	case Parallelogram:
-		// Parallelogram in true proportions
-		height := 5
-		baseLength := 11
-		for y := 0; y < height; y++ {
-			// Slant offset decreases as we go down
-			offset := height - 1 - y
-			for x := 0; x < baseLength; x++ {
-				basePoints = append(basePoints, Position{x + offset, y})
-			}
-		}
-	}
-
-	// Apply rotation FIRST (on true proportions)
-	rotatedPoints := m.rotatePoints(basePoints, piece.Rotation)
-
-	// Fill any gaps in the rotated shape
-	rotatedPoints = m.fillShape(rotatedPoints)
-
-	// Apply flip
-	if piece.Flipped {
-		rotatedPoints = m.flipPoints(rotatedPoints)
-	}
-
-	// THEN apply aspect ratio correction (stretch horizontally by 2x)
-	aspectCorrectedPoints := make([]Position, 0, len(rotatedPoints)*2)
-	for _, p := range rotatedPoints {
-		// Each point becomes 2 points horizontally
-		aspectCorrectedPoints = append(aspectCorrectedPoints, Position{p.X * 2, p.Y})
-		aspectCorrectedPoints = append(aspectCorrectedPoints, Position{p.X*2 + 1, p.Y})
-	}
-
-	return aspectCorrectedPoints
-}
-
-// fillShape fills in any gaps in a rotated shape using scan-line fill
-func (m PuzzleModel) fillShape(points []Position) []Position {
-	if len(points) == 0 {
-		return points
-	}
-
-	// Create a map of existing points for fast lookup
-	pointMap := make(map[Position]bool)
-	for _, p := range points {
-		pointMap[p] = true
-	}
-
-	// Find bounding box
-	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
-		}
-	}
-
-	// Fill horizontally (row by row)
-	filledMap := make(map[Position]bool)
-	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 (column by column) to catch any remaining gaps
-	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
-		}
-	}
-
-	// Convert map back to slice
-	filledPoints := make([]Position, 0, len(filledMap))
-	for p := range filledMap {
-		filledPoints = append(filledPoints, p)
-	}
-
-	return filledPoints
-}
-
-// rotatePoints rotates points by the given angle (0, 90, 180, 270)
-func (m PuzzleModel) 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)
-
-	// Find center of points
-	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 {
-		// Translate to origin
-		x := float64(p.X) - centerX
-		y := float64(p.Y) - centerY
-
-		// Rotate
-		newX := x*cos - y*sin
-		newY := x*sin + y*cos
-
-		// Translate back
-		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
-}
-
-// flipPoints flips points horizontally
-func (m PuzzleModel) flipPoints(points []Position) []Position {
-	if len(points) == 0 {
-		return points
-	}
-
-	// Find max X
-	maxX := points[0].X
-	for _, p := range points {
-		if p.X > maxX {
-			maxX = p.X
-		}
-	}
-
-	// Flip horizontally
-	var flipped []Position
-	for _, p := range points {
-		flipped = append(flipped, Position{
-			X: maxX - p.X,
-			Y: p.Y,
-		})
-	}
-
-	return flipped
-}
-
-// exportConfig prints the current configuration
-func (m PuzzleModel) exportConfig() {
-	fmt.Println("\n=== TANGRAM CONFIGURATION ===")
-	for _, piece := range m.pieces {
-		fmt.Printf("Piece #%d (%s): Position(%d, %d), Rotation: %d°, Flipped: %t\n",
-			piece.ID,
-			piece.Type,
-			piece.Position.X,
-			piece.Position.Y,
-			piece.Rotation,
-			piece.Flipped,
-		)
-	}
-	fmt.Println("============================\n")
-}
-
-// saveConfig saves the current configuration to a JSON file
-func (m *PuzzleModel) saveConfig() {
-	// Create a simplified structure for saving
-	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
-	for _, piece := range m.pieces {
-		savedPieces = append(savedPieces, SavedPiece{
-			ID:       piece.ID,
-			Type:     string(piece.Type),
-			Position: piece.Position,
-			Rotation: piece.Rotation,
-			Flipped:  piece.Flipped,
-		})
-	}
-
-	data, err := json.MarshalIndent(savedPieces, "", "  ")
-	if err != nil {
-		fmt.Printf("\n❌ Error saving configuration: %v\n", err)
-		return
-	}
-
-	filename := "tanagram-config.json"
-	err = os.WriteFile(filename, data, 0644)
-	if err != nil {
-		fmt.Printf("\n❌ Error writing file: %v\n", err)
-		return
-	}
-
-	fmt.Printf("\n✓ Configuration saved to %s\n", filename)
-}
-
-// loadConfig loads a configuration from a JSON file
-func (m *PuzzleModel) loadConfig() {
-	filename := "tanagram-config.json"
-
-	data, err := os.ReadFile(filename)
-	if err != nil {
-		fmt.Printf("\n❌ Error reading file: %v\n", err)
-		fmt.Println("   Make sure tanagram-config.json exists in the current directory")
-		return
-	}
-
-	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 {
-		fmt.Printf("\n❌ Error parsing configuration: %v\n", err)
-		return
-	}
-
-	// Update piece positions, rotations, and flips
-	for i, saved := range savedPieces {
-		if i < len(m.pieces) && saved.ID == m.pieces[i].ID {
-			m.pieces[i].Position = saved.Position
-			m.pieces[i].Rotation = saved.Rotation
-			m.pieces[i].Flipped = saved.Flipped
-		}
-	}
-
-	fmt.Printf("\n✓ Configuration loaded from %s\n", filename)
-}
-
-// RunPuzzleEditor displays the puzzle editor
-func RunPuzzleEditor() error {
-	model := NewPuzzleModel()
-	p := tea.NewProgram(model, tea.WithAltScreen())
-
-	_, err := p.Run()
-	if err != nil {
-		return fmt.Errorf("error running puzzle editor: %w", err)
-	}
-
-	return nil
-}