282 lines
8.7 KiB
Go
282 lines
8.7 KiB
Go
package main
|
|
|
|
import (
|
|
"math"
|
|
"sync"
|
|
|
|
gg "github.com/faiface/pixel-examples/community/amidakuji/glossary"
|
|
|
|
"github.com/faiface/pixel"
|
|
"github.com/faiface/pixel/imdraw"
|
|
)
|
|
|
|
// Path is for animating a path to the prize in a ladder.
|
|
type Path struct {
|
|
imd *imdraw.IMDraw // shared variable
|
|
mutex sync.Mutex // synchronize
|
|
//
|
|
roads []pixel.Vec // A list of vectors - each vector for a position where a road starts.
|
|
prize *int
|
|
tip *pixel.Vec
|
|
tipDir pixel.Vec
|
|
iroad int
|
|
//
|
|
watchAnim gg.DtWatch // When it started to animate.
|
|
timeLimitAnimInSec float64
|
|
animateInTime bool
|
|
isAnimating bool
|
|
|
|
// -----------------------------------------------------------
|
|
// exported callbacks(listeners) regarding animation
|
|
|
|
// callback on reaching the prize level of a ladder.
|
|
OnFinishedAnimation func()
|
|
|
|
// callback when the animating 'tip' passes a point of a road.
|
|
// pt: a point(road) just passed.
|
|
// dir: ...
|
|
// dir is a normalized vector. (pixel.ZV) is passed if the direction can't be found.
|
|
// dir can be different depending on how fast this Path is updated.
|
|
OnPassedEachPoint func(pt pixel.Vec, dir pixel.Vec)
|
|
}
|
|
|
|
// NewPath is a contructor.
|
|
func NewPath(_roads []pixel.Vec, _prize *int) *Path {
|
|
newTip := func() *pixel.Vec {
|
|
if _roads != nil {
|
|
if len(_roads) > 0 {
|
|
v := _roads[0]
|
|
return &v
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
return &Path{
|
|
roads: _roads,
|
|
prize: _prize,
|
|
tip: newTip(),
|
|
tipDir: pixel.ZV,
|
|
}
|
|
}
|
|
|
|
// NewPathEmpty is a contructor.
|
|
func NewPathEmpty() *Path {
|
|
return &Path{}
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Important methods
|
|
|
|
// Draw guarantees the thread safety, though it's not a necessary condition.
|
|
// It is quite dangerous to access this struct's member (imdraw) directly from outside these methods.
|
|
func (path *Path) Draw(t pixel.Target) {
|
|
path.mutex.Lock()
|
|
defer path.mutex.Unlock()
|
|
|
|
if path.imd == nil { // isInvisible set to true.
|
|
return // An empty image is drawn.
|
|
}
|
|
|
|
path.imd.Draw(t)
|
|
}
|
|
|
|
// Update animates a path. A path is drawn on an imdraw.
|
|
func (path *Path) Update(color pixel.RGBA) {
|
|
var (
|
|
iroad = len(path.roads) - 1
|
|
from = path.roads[len(path.roads)-1]
|
|
to = path.roads[len(path.roads)-1]
|
|
dir = pixel.ZV
|
|
)
|
|
|
|
if path.isAnimating {
|
|
// get where it is abstract // get a scalar
|
|
dt := path.watchAnim.DtSinceStart()
|
|
const distPerSec = 500
|
|
scalarProgress := dt * distPerSec
|
|
// log.Println(dt, path.Len(), scalarProgress) //
|
|
|
|
if path.animateInTime { // overwrite scalarProgress
|
|
fromLot := pixel.V(0, 0)
|
|
toPrize := pixel.V(path.Len(), 0)
|
|
percentagePointPerSec := 1 / path.timeLimitAnimInSec
|
|
scalarProgress = pixel.Lerp(fromLot, toPrize, dt*percentagePointPerSec).X
|
|
// log.Println(dt, path.Len(), scalarProgress, dt*percentagePointPerSec) //
|
|
}
|
|
|
|
// get where it is concrete // turn a scalar into a set of vectors
|
|
iroad, from, to, dir = path.FindRoadByDist(scalarProgress)
|
|
if iroad > path.iroad {
|
|
if path.OnPassedEachPoint != nil {
|
|
go path.OnPassedEachPoint(from, dir)
|
|
}
|
|
}
|
|
path.iroad = iroad
|
|
// log.Println(iroad, len(path.roads), iroad == len(path.roads)-1, path.isAnimating) //
|
|
if iroad >= len(path.roads)-1 { // the end
|
|
path.isAnimating = false
|
|
// log.Println(path.Len(), dt) //
|
|
if path.OnFinishedAnimation != nil {
|
|
go path.OnFinishedAnimation()
|
|
} // callback
|
|
}
|
|
}
|
|
|
|
// lock before imdraw update
|
|
path.mutex.Lock()
|
|
defer path.mutex.Unlock()
|
|
|
|
// imdraw (a state machine)
|
|
if path.imd == nil { // lazy creation
|
|
path.imd = imdraw.New(nil)
|
|
}
|
|
imd := path.imd
|
|
imd.Clear()
|
|
|
|
// draw path
|
|
imd.Color = color
|
|
imd.EndShape = imdraw.RoundEndShape
|
|
for i := 0; i < iroad; i++ {
|
|
imd.Push(path.roads[i], path.roads[i+1])
|
|
imd.Line(9)
|
|
}
|
|
imd.Push(from, to)
|
|
imd.Line(9)
|
|
|
|
// save where the tip is
|
|
path.tip = &to
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Read only methods
|
|
|
|
// IsAnimating determines whether this Path is about to be updated or not.
|
|
// Pass lock by value warning from (path Path) should be ignored,
|
|
// because a Path here is just passed as a read only argument.
|
|
func (path Path) IsAnimating() bool {
|
|
return path.isAnimating
|
|
}
|
|
|
|
// GetPrize is just an average getter.
|
|
// It returns -1 if the receiver is not initialized with that member(prize).
|
|
// Pass lock by value warning from (path Path) should be ignored,
|
|
// because a Path here is just passed as a read only argument.
|
|
func (path Path) GetPrize() int {
|
|
if path.prize == nil {
|
|
return -1
|
|
}
|
|
return *path.prize
|
|
}
|
|
|
|
// PosTip returns a vector that tells you how far the animating path currently has reached.
|
|
// A non-ptr Path as a read only argument passes lock by value within itself but that seems totally fine.
|
|
func (path Path) PosTip() (v pixel.Vec) {
|
|
return *path.tip
|
|
}
|
|
|
|
// Len returns the total length of all roads.
|
|
// A non-ptr Path as a read only argument passes lock by value within itself but that seems totally fine.
|
|
func (path Path) Len() (sum float64) {
|
|
for i := 0; i < len(path.roads)-1; i++ {
|
|
sum += math.Abs(path.roads[i].Sub(path.roads[i+1]).Len())
|
|
}
|
|
return
|
|
}
|
|
|
|
// FindRoadByDist converts a scalar into a set of vectors.
|
|
// A non-ptr Path as a read only argument passes lock by value within itself but that seems totally fine.
|
|
//
|
|
// Returns
|
|
// iroad: The index of a road found.
|
|
// road: The vector representation of a road found. A road is a line from pt A to B, and that vector points to where pt A is.
|
|
// pos: A position(point) found which is in the middle of that found road(line).
|
|
// dirVecNormalized: A direction as a normalized vector. This vector always has a length of 1.
|
|
func (path Path) FindRoadByDist(distProgress float64) (iroad int, road pixel.Vec, pos pixel.Vec, dirVecNormalized pixel.Vec) {
|
|
lengthOfTraveledRoads := float64(0.0)
|
|
for iroad = 0; iroad < len(path.roads)-1; iroad++ {
|
|
var lengthOfThisRoad float64
|
|
iroadNext := iroad + 1
|
|
lengthOfThisRoad = math.Abs(path.roads[iroad].Sub(path.roads[iroadNext]).Len())
|
|
lengthOfTraveledRoads += lengthOfThisRoad
|
|
// For loop breaker: distProgress is somewhere between the total length of a path.
|
|
if lengthOfTraveledRoads > distProgress {
|
|
scalar := lengthOfThisRoad - (lengthOfTraveledRoads - distProgress)
|
|
if path.roads[iroad].Y == path.roads[iroadNext].Y &&
|
|
path.roads[iroad].X < path.roads[iroadNext].X { // to the bottom (east)
|
|
pos = path.roads[iroad]
|
|
pos.X += scalar
|
|
dirVecNormalized = pixel.V(1, 0)
|
|
} else if path.roads[iroad].X == path.roads[iroadNext].X &&
|
|
path.roads[iroad].Y > path.roads[iroadNext].Y { // to the left (south)
|
|
pos = path.roads[iroad]
|
|
pos.Y -= scalar
|
|
dirVecNormalized = pixel.V(0, -1)
|
|
} else if path.roads[iroad].X == path.roads[iroadNext].X &&
|
|
path.roads[iroad].Y < path.roads[iroadNext].Y { // to the right (north)
|
|
pos = path.roads[iroad]
|
|
pos.Y += scalar
|
|
dirVecNormalized = pixel.V(0, 1)
|
|
} else if path.roads[iroad].Y == path.roads[iroadNext].Y &&
|
|
path.roads[iroad].X > path.roads[iroadNext].X { // to the top (west)
|
|
// Placed at the end of an elif statement,
|
|
// since this case is of no possibility unless the path finding is going reverse.
|
|
pos = path.roads[iroad]
|
|
pos.X -= scalar
|
|
dirVecNormalized = pixel.V(-1, 0)
|
|
} else {
|
|
panic("unhandled exception: it may be a diagonal bridge")
|
|
} // elif
|
|
return iroad, path.roads[iroad], pos, dirVecNormalized
|
|
} // if - for loop breaker
|
|
} // for
|
|
|
|
// coming down to here means that the case is (road == pos)
|
|
from := iroad - 1
|
|
to := iroad
|
|
if iroad == 0 {
|
|
from = iroad
|
|
to = iroad + 1
|
|
}
|
|
if from < 0 || to >= len(path.roads) {
|
|
dirVecNormalized = pixel.ZV
|
|
} else {
|
|
dirVecNormalized = gg.Direction(path.roads[from], path.roads[to])
|
|
}
|
|
return iroad, path.roads[iroad], path.roads[iroad], dirVecNormalized
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Methods that write to itself
|
|
|
|
// Animate a path.
|
|
func (path *Path) Animate() {
|
|
path.watchAnim.Start()
|
|
path.animateInTime = false
|
|
path.isAnimating = true
|
|
}
|
|
|
|
// AnimateInTime animates a path in given time.
|
|
func (path *Path) AnimateInTime(sec float64) {
|
|
path.watchAnim.Start()
|
|
path.timeLimitAnimInSec = sec
|
|
path.animateInTime = true
|
|
path.isAnimating = true
|
|
}
|
|
|
|
// Pause a path's clock.
|
|
func (path *Path) Pause() {
|
|
if path.watchAnim.IsStarted() {
|
|
path.watchAnim.Dt()
|
|
}
|
|
}
|
|
|
|
// Resume after pause.
|
|
func (path *Path) Resume() {
|
|
if path.watchAnim.IsStarted() {
|
|
started := path.watchAnim.GetTimeStarted()
|
|
dtPause := path.watchAnim.DtNano()
|
|
path.watchAnim.SetTimeStarted(started.Add(dtPause))
|
|
// log.Println(dtPause, started, path.watchAnim.GetTimeStarted()) //
|
|
}
|
|
}
|