enemy.go

package main

import (
	"math"
	"math/rand"
	"time"

	termbox "github.com/nsf/termbox-go"
)

type iEnemy interface {
	getPosition() (x, y int)
	setPosition(x, y int)
	getDisplayFormat() (rune, termbox.Attribute)
	think(p *player) (int, int)
	move(x, y int)
	hasCaptured(p *player)
	eval(p *player, x, y int) float64
}
type enemy struct {
	x            int
	y            int
	char         rune
	color        termbox.Attribute
	waitingTime  int
	oneActionInN int
	canMove      func(int, int) bool
	strategy
	underRune
}
type hunter struct {
	enemy
}
type ghost struct {
	enemy
}
type assassin struct {
	enemy
}

type strategy interface {
	eval(p *player, x, y int) float64
}
type assault struct{}
type tricky struct{}
type ambush struct{}

type underRune struct {
	char    rune
	fgColor termbox.Attribute
	bgColor termbox.Attribute
}

func (e *enemy) getPosition() (x, y int) {
	return e.x, e.y
}
func (e *enemy) setPosition(x, y int) {
	e.x, e.y = x, y
}

func (e *enemy) getDisplayFormat() (rune, termbox.Attribute) {
	return e.char, e.color
}

func control(s stage, p *player) error {
	for _, e := range s.enemies {
		e.move(e.think(p))
		e.hasCaptured(p)
	}
	if err := termbox.Flush(); err != nil {
		return err
	}
	time.Sleep(s.gameSpeed)
	return nil
}

func (e *enemy) think(p *player) (int, int) {
	x, y := e.getPosition()
	// Calculate the evaluation value for movement
	up := e.eval(p, x, y-1)
	down := e.eval(p, x, y+1)
	left := e.eval(p, x-1, y)
	right := e.eval(p, x+1, y)

	// The evaluation value is the distance between the player and the enemy
	// So prefer lower (closer) values
	if up <= down && up <= left && up <= right {
		return x, y - 1 // up
	} else if down <= left && down <= right {
		return x, y + 1 // down
	} else if left <= right {
		return x - 1, y // left
	} else {
		return x + 1, y // right
	}
}

func (e *enemy) move(x, y int) {
	e.waitingTime--
	if e.waitingTime <= 0 && e.canMove(x, y) {
		winWidth, _ := termbox.Size()
		// Set the original character in the original cell
		termbox.SetCell(e.x, e.y, e.underRune.char, e.underRune.fgColor, e.underRune.bgColor)
		// Retains destination cell information
		// Because it is necessary to set the original character at the next move
		cell := termbox.CellBuffer()[(winWidth*y)+x]
		e.setPosition(x, y)
		e.underRune.char = cell.Ch
		e.underRune.fgColor = cell.Fg
		e.underRune.bgColor = cell.Bg
		termbox.SetCell(x, y, e.char, e.color, e.color)
		e.waitingTime = e.oneActionInN
	}
}

func (e *enemy) hasCaptured(p *player) {
	if e.x == p.x && e.y == p.y {
		p.state = lose
	}
}

func (e *enemy) eval(p *player, x, y int) float64 {
	if !e.canMove(x, y) {
		// Returns a large enough value if it can't move
		return 1000
	}
	return e.strategy.eval(p, x, y)
}
func (s *assault) eval(p *player, x, y int) float64 {
	// Distance between two points
	return math.Sqrt(math.Pow(float64(p.y-y), 2) + math.Pow(float64(p.x-x), 2))
}
func (s *tricky) eval(p *player, x, y int) float64 {
	if random(0, 5) == 0 {
		return float64(random(0, 30))
	} else {
		return math.Sqrt(math.Pow(float64(p.y-y), 2) + math.Pow(float64(p.x-x), 2))
	}
}
func (s *ambush) eval(p *player, x, y int) float64 {
	// Implement the logic for calculating the evaluation value.
	return float64(random(0, 30))
}

// Return a value between min and max
// e.g. random(0, 3) returns 0,1,2,3
func random(min, max int) int {
	rand.New(rand.NewSource(time.Now().UnixNano()))
	return rand.Intn(max-min+1) + min
}

type iEnemyBuilder interface {
	displayFormat(rune, string) iEnemyBuilder
	speed(int) iEnemyBuilder
	strategize(strategy) iEnemyBuilder
	movable(func(int, int) bool) iEnemyBuilder
	defaultHunter() iEnemyBuilder
	defaultGhost() iEnemyBuilder
	defaultAssassin() iEnemyBuilder
	build() iEnemy
}
type enemyBuilder struct {
	x                int
	y                int
	char             rune
	color            termbox.Attribute
	underRuneBgColor termbox.Attribute
	waitingTime      int
	oneActionInN     int
	canMove          func(int, int) bool
	strategy         strategy
}

func (eb *enemyBuilder) displayFormat(r rune, s string) iEnemyBuilder {
	eb.char = r
	switch s {
	case "RED":
		eb.color = termbox.ColorRed
	case "CYAN":
		eb.color = termbox.ColorCyan
	case "DARK_GRAY":
		eb.color = termbox.ColorDarkGray
	}
	return eb
}
func (eb *enemyBuilder) speed(i int) iEnemyBuilder {
	eb.waitingTime = i
	eb.oneActionInN = i
	return eb
}
func (eb *enemyBuilder) movable(fn func(int, int) bool) iEnemyBuilder {
	eb.canMove = fn
	return eb
}
func (eb *enemyBuilder) strategize(s strategy) iEnemyBuilder {
	eb.strategy = s
	return eb
}

func (eb *enemyBuilder) defaultHunter() iEnemyBuilder {
	fn := func(x, y int) bool {
		return !isCharWall(x, y) && !isCharEnemy(x, y)
	}
	return eb.displayFormat(chHunter, "RED").speed(1).movable(fn).strategize(&assault{})
}
func (eb *enemyBuilder) defaultGhost() iEnemyBuilder {
	fn := func(x, y int) bool {
		return !isCharBoundary(x, y) && !isCharEnemy(x, y)
	}
	return eb.displayFormat(chGhost, "CYAN").speed(2).movable(fn).strategize(&assault{})
}
func (eb *enemyBuilder) defaultAssassin() iEnemyBuilder {
	fn := func(x, y int) bool {
		return !isCharWall(x, y) && !isCharEnemy(x, y)
	}
	return eb.displayFormat(chAssassin, "DARK_GRAY").speed(1).movable(fn).strategize(&assault{})
}

func newEnemyBuilder() iEnemyBuilder {
	return &enemyBuilder{}
}

func (eb *enemyBuilder) build() iEnemy {
	return &enemy{
		x:            eb.x,
		y:            eb.y,
		char:         eb.char,
		color:        eb.color,
		waitingTime:  eb.waitingTime,
		oneActionInN: eb.oneActionInN,
		canMove:      eb.canMove,
		strategy:     eb.strategy,
		underRune:    underRune{bgColor: termbox.ColorBlack},
	}
}