mirror of
https://github.com/mvvasilev/last_light.git
synced 2025-04-19 20:59:51 +03:00
145 lines
2.3 KiB
Go
145 lines
2.3 KiB
Go
package engine
|
|
|
|
import (
|
|
"math"
|
|
"math/rand"
|
|
)
|
|
|
|
type Positioned struct {
|
|
pos Position
|
|
}
|
|
|
|
func WithPosition(pos Position) Positioned {
|
|
return Positioned{
|
|
pos: pos,
|
|
}
|
|
}
|
|
|
|
func (wp *Positioned) Position() Position {
|
|
return wp.pos
|
|
}
|
|
|
|
func (wp *Positioned) SetPosition(pos Position) {
|
|
wp.pos = pos
|
|
}
|
|
|
|
type Position struct {
|
|
x int
|
|
y int
|
|
}
|
|
|
|
func PositionAt(x int, y int) Position {
|
|
return Position{int(x), int(y)}
|
|
}
|
|
|
|
func (p Position) X() int {
|
|
return p.x
|
|
}
|
|
|
|
func (p Position) Y() int {
|
|
return p.y
|
|
}
|
|
|
|
func (p Position) XY() (int, int) {
|
|
return p.x, p.y
|
|
}
|
|
|
|
func (p Position) DistanceSquared(pos Position) int {
|
|
return (pos.x-p.x)*(pos.x-p.x) + (pos.y-p.y)*(pos.y-p.y)
|
|
}
|
|
|
|
func (p Position) Distance(pos Position) int {
|
|
return int(math.Floor(math.Sqrt(float64(p.DistanceSquared(pos)))))
|
|
}
|
|
|
|
func (p Position) Equals(other Position) bool {
|
|
return p.x == other.x && p.y == other.y
|
|
}
|
|
|
|
func (p Position) WithOffset(xOffset int, yOffset int) Position {
|
|
p.x = p.x + xOffset
|
|
p.y = p.y + yOffset
|
|
return p
|
|
}
|
|
|
|
type Sized struct {
|
|
size Size
|
|
}
|
|
|
|
func WithSize(size Size) Sized {
|
|
return Sized{
|
|
size: size,
|
|
}
|
|
}
|
|
|
|
// Checks if the provided coordinates fit within the sized struct, [0, N)
|
|
func (ws *Sized) FitsWithin(x, y int) bool {
|
|
return 0 <= x && x < ws.size.width && 0 <= y && y < ws.size.height
|
|
}
|
|
|
|
func (ws *Sized) Size() Size {
|
|
return ws.size
|
|
}
|
|
|
|
type Size struct {
|
|
width int
|
|
height int
|
|
}
|
|
|
|
func SizeOf(width int, height int) Size {
|
|
return Size{int(width), int(height)}
|
|
}
|
|
|
|
func (s Size) Width() int {
|
|
return s.width
|
|
}
|
|
|
|
func (s Size) Height() int {
|
|
return s.height
|
|
}
|
|
|
|
func (s Size) WH() (int, int) {
|
|
return s.width, s.height
|
|
}
|
|
|
|
func (s Size) Area() int {
|
|
return s.width * s.height
|
|
}
|
|
|
|
func (s Size) AsArrayIndex(x, y int) int {
|
|
return y*s.width + x
|
|
}
|
|
|
|
func (s Size) Contains(x, y int) bool {
|
|
return 0 <= x && x < s.width && 0 <= y && y < s.height
|
|
}
|
|
|
|
func LimitIncrement(i int, limit int) int {
|
|
if (i + 1) > limit {
|
|
return i
|
|
}
|
|
|
|
return i + 1
|
|
}
|
|
|
|
func LimitDecrement(i int, limit int) int {
|
|
if (i - 1) < limit {
|
|
return i
|
|
}
|
|
|
|
return i - 1
|
|
}
|
|
|
|
func RandInt(min, max int) int {
|
|
return min + rand.Intn(max-min)
|
|
}
|
|
|
|
func MapSlice[S ~[]E, E any, R any](slice S, mappingFunc func(e E) R) []R {
|
|
newSlice := make([]R, 0, len(slice))
|
|
|
|
for _, el := range slice {
|
|
newSlice = append(newSlice, mappingFunc(el))
|
|
}
|
|
|
|
return newSlice
|
|
}
|