tris

Documentation

Index

• Variables
• type Bag
  • func NewBag() Bag
  • func (b Bag) Next(n int) (Bag, Field)
  • func (b Bag) Pick() (Bag, Placement)
  • func (b Bag) Randomize() Bag
  • func (b Bag) Swap(p Placement) (Bag, Placement)
• type Field
  • func NewField(h, w int) Field
  • func (f Field) Add(p Placement) Field
  • func (f Field) H() int
  • func (f Field) Lines() (int, Field)
  • func (f Field) String() (output string)
  • func (f Field) W() int
• type Kicks
  • func (ks Kicks) Try(p, np Placement, f Field) Placement
• type Piece
• type Placement
  • func (p Placement) Collide(f Field) bool
  • func (p Placement) Color() int
  • func (p Placement) Field(h, w int) (Field, bool)
  • func (p Placement) Floor(f Field) bool
  • func (p Placement) Move(f Field, rot Rotation, x, y int) (np Placement, floor, topout bool)
  • func (p Placement) Points() []Point
• type Point
  • func (p Point) Add(q Point) Point
• type Rotation

Variables

var (
	EmptyPiece = Piece{}
	IPiece     = Piece{0x0F00, 0x4444, 0x00F0, 0x2222}
	JPiece     = Piece{0x1700, 0x6220, 0x0740, 0x2230}
	LPiece     = Piece{0x4700, 0x2260, 0x0710, 0x3220}
	OPiece     = Piece{0x6600, 0x6600, 0x6600, 0x6600}
	SPiece     = Piece{0x6300, 0x2640, 0x0630, 0x1320}
	TPiece     = Piece{0x2700, 0x2620, 0x0720, 0x2320}
	ZPiece     = Piece{0x3600, 0x4620, 0x0360, 0x2310}
)

A table that represents each piece from https://tetris.fandom.com/wiki/SRS in binary starting with 1 top left going per row, here in hexadecimal shorthand.

var K3CW = Kicks{
	0: {{X: 0, Y: 0}, {X: -1, Y: 0}, {X: -1, Y: -1}, {X: 0, Y: 2}, {X: -1, Y: 2}},
	1: {{X: 0, Y: 0}, {X: 1, Y: 0}, {X: 1, Y: 1}, {X: 0, Y: -2}, {X: 1, Y: -2}},
	2: {{X: 0, Y: 0}, {X: 1, Y: 0}, {X: 1, Y: -1}, {X: 0, Y: 2}, {X: 1, Y: 2}},
	3: {{X: 0, Y: 0}, {X: -1, Y: 0}, {X: -1, Y: 1}, {X: 0, Y: -2}, {X: -1, Y: -2}},
}

Kics for all pieces except I and O pieces

var LCW = Kicks{
	0: {{X: 0, Y: 0}, {X: -2, Y: 0}, {X: 1, Y: 0}, {X: -2, Y: 1}, {X: 1, Y: -2}},
	1: {{X: 0, Y: 0}, {X: -1, Y: 0}, {X: 2, Y: 0}, {X: -1, Y: -2}, {X: 2, Y: 1}},
	2: {{X: 0, Y: 0}, {X: 2, Y: 0}, {X: -1, Y: 0}, {X: 2, Y: -1}, {X: -1, Y: 2}},
	3: {{X: 0, Y: 0}, {X: 1, Y: 0}, {X: -2, Y: 0}, {X: 1, Y: 2}, {X: -2, Y: -1}},
}

Long Bar (I piece) Kicks

var LockDelay = time.Second / 2

var ReferenceBag = Bag{IPiece, JPiece, LPiece, OPiece, SPiece, TPiece, ZPiece}

var Swapped bool

Types

type Bag

type Bag []Piece

func NewBag

func NewBag() Bag

func (Bag) Next

func (b Bag) Next(n int) (Bag, Field)

func (Bag) Pick

func (b Bag) Pick() (Bag, Placement)

func (Bag) Randomize

func (b Bag) Randomize() Bag

func (Bag) Swap

func (b Bag) Swap(p Placement) (Bag, Placement)

type Field

type Field [][]int

var HoldBox Field

func NewField

func NewField(h, w int) Field

func (Field) Add

func (f Field) Add(p Placement) Field

Add merges the Field and Piece together

func (Field) H

func (f Field) H() int

func (Field) Lines

func (f Field) Lines() (int, Field)

Lines counts the number of lines that is completed and returns a Field with them removed

func (Field) String

func (f Field) String() (output string)

func (Field) W

func (f Field) W() int

type Kicks

type Kicks map[Rotation][]Point

As at the bottom of https://tetris.fandom.com/wiki/SRS but Y inverse because we start Y at the top

func (Kicks) Try

func (ks Kicks) Try(p, np Placement, f Field) Placement

Try all possible kicks

type Piece

type Piece [4]uint16

A piece contains a value per rotation

var HoldPiece Piece

type Placement

type Placement struct {
	X    int
	Y    int
	Rot  Rotation
	Lock time.Time
	// contains filtered or unexported fields
}

a placement is the combination of a piece and where it exactly is on the board we use this both for the actual piece and for checking hypothetical positions

func (Placement) Collide

func (p Placement) Collide(f Field) bool

Collide checks if any squares of the Placement and the Field overlap

func (Placement) Color

func (p Placement) Color() int

func (Placement) Field

func (p Placement) Field(h, w int) (Field, bool)

Field translates the Placement into a Field format When it gets out of the board, we return that to the caller with a bool

func (Placement) Floor

func (p Placement) Floor(f Field) bool

Floor checks if the piece touches something underneath it

func (Placement) Move

func (p Placement) Move(f Field, rot Rotation, x, y int) (np Placement, floor, topout bool)

Move tries the move indicated by the parameters, applies kicks to fix when it doesn't work, and returns if the piece is on the floor or topping out

func (Placement) Points

func (p Placement) Points() []Point

Points transforms the piece to a list of coordinates

type Point

type Point struct {
	X, Y int
}

func (Point) Add

func (p Point) Add(q Point) Point

Add adds two points together

type Rotation

type Rotation int

const (
	Spawn Rotation = iota
	Clockwise
	Flip
	CounterClockwise
)