pixel-examples/community/amidakuji/game.go

775 lines
21 KiB
Go

package main
import (
"encoding/json"
"errors"
"fmt"
"io/ioutil"
"log"
"math"
"math/rand"
"os"
"reflect"
"strings"
"sync"
"time"
"unsafe"
gg "github.com/faiface/pixel/examples/community/amidakuji/glossary"
"github.com/faiface/pixel/examples/community/amidakuji/glossary/jukebox"
glfw "github.com/go-gl/glfw/v3.2/glfw"
"github.com/faiface/pixel"
"github.com/faiface/pixel/pixelgl"
"github.com/faiface/pixel/text"
"github.com/sqweek/dialog"
"golang.org/x/image/colornames"
)
// Actor updates and draws itself. It acts as a game object.
type Actor interface {
Drawer
Updater
}
// Drawer draws itself.
type Drawer interface {
Draw()
}
// Updater updates itself.
type Updater interface {
Update()
}
// -------------------------------------------------------------------------
// Core game
// game is a path finder.
// Also it manages and draws everything about...
type game struct {
// something system, somthing runtime
window *pixelgl.Window // lazy init
bg pixel.RGBA
camera *gg.Camera // lazy init
fpsw *gg.FPSWatch
dtw gg.DtWatch
vsync <-chan time.Time // lazy init
// game state
isRefreshedLadder bool
isRefreshedNametags bool
isScalpelMode bool
// drawings
mutex sync.Mutex // It is unsafe to access any refd; ptrd object without a critical section.
nPlayers int
ladder *Ladder
scalpel *Scalpel
paths []Path
emojis []pixel.Sprite
nametagPicks Nametags
nametagPrizes Nametags
atlas *text.Atlas
galaxy *gg.Galaxy
explosions *gg.Explosions
// other user settings
fontSize float64
winWidth float64 // The screen width, not the game width.
winHeight float64
initialZoomLevel float64
initialRotateDegree float64
}
type gameConfig struct {
nParticipants int
nLevel int
winWidth float64
winHeight float64
width float64
height float64
initialZoomLevel float64
initialRotateDegree float64
paddingTop float64
paddingRight float64
paddingBottom float64
paddingLeft float64
fontSize float64
nametagPicks []string
nametagPrizes []string
}
// init game
func newGame(cfg gameConfig) *game {
newEmojis := func(nParticipants int) (emojis []pixel.Sprite) {
emojis = make([]pixel.Sprite, nParticipants)
const dir = "emoji"
randomNames, err := gg.AssetDir(dir) // The order is random because they're from a map.
if err != nil {
return nil
}
nRandomNames := len(randomNames)
for participant := 0; participant < nParticipants; participant++ {
emojis[participant] = *gg.NewSprite(dir + "/" + randomNames[participant%nRandomNames]) // val, not ptr
}
return emojis
}
g := game{
bg: gg.RandomNiceColor(),
fpsw: gg.NewFPSWatchSimple(pixel.V(cfg.winWidth, cfg.winHeight), gg.Top, gg.Right),
isRefreshedLadder: false,
isRefreshedNametags: false,
isScalpelMode: false,
nPlayers: cfg.nParticipants,
ladder: NewLadder(
cfg.nParticipants, cfg.nLevel,
cfg.width, cfg.height,
cfg.paddingTop, cfg.paddingRight,
cfg.paddingBottom, cfg.paddingLeft,
),
scalpel: &Scalpel{},
paths: make([]Path, cfg.nParticipants),
emojis: newEmojis(cfg.nParticipants),
nametagPicks: make([]Nametag, cfg.nParticipants), // val, not ptr
nametagPrizes: make([]Nametag, cfg.nParticipants), // val, not ptr
atlas: gg.NewAtlas(
"", cfg.fontSize,
[]rune(strings.Join(cfg.nametagPicks, "")+strings.Join(cfg.nametagPrizes, "")),
), // A prepared set of images of characters or symbols to be drawn.
galaxy: gg.NewGalaxy(cfg.width, cfg.height, 400),
explosions: gg.NewExplosions(cfg.width, cfg.width, nil, 5),
initialZoomLevel: cfg.initialZoomLevel,
initialRotateDegree: cfg.initialRotateDegree,
winWidth: cfg.winWidth,
winHeight: cfg.winHeight,
}
// init paths
g.ResetPaths()
// copy nametags
copyNametagPicks := func(dstNametags []Nametag, srcNames []string) {
positions := g.ladder.PtsAtLevelOfPicks()
for i := 0; i < cfg.nParticipants; i++ {
posAdjust := positions[i]
posAdjust.Y += 5
posAdjust.X -= 60
dstNametags[i] = *NewNametagSimple(
g.atlas, "", posAdjust,
gg.Middle, gg.Right,
) // val, not ptr
if i < len(srcNames) {
dstNametags[i].desc = srcNames[i]
}
}
}
copyNametagPrizes := func(dstNametags []Nametag, srcNames []string) {
positions := g.ladder.PtsAtLevelOfPrizes()
for i := 0; i < cfg.nParticipants; i++ {
posAdjust := positions[i]
posAdjust.Y += 5
posAdjust.X += 15
dstNametags[i] = *NewNametagSimple(
g.atlas, "", posAdjust,
gg.Middle, gg.Left,
) // val, not ptr
if i < len(srcNames) {
dstNametags[i].desc = srcNames[i]
}
}
}
copyNametagPicks(g.nametagPicks, cfg.nametagPicks)
copyNametagPrizes(g.nametagPrizes, cfg.nametagPrizes)
// log.Println(g.nametagPicks[1].desc) //
return &g
}
func (g *game) Draw() {
g.mutex.Lock()
defer g.mutex.Unlock()
// This was originally an argument of this function.
var t pixel.BasicTarget
t = g.window
// ---------------------------------------------------
// 1. canvas a game world
t.SetMatrix(g.camera.Transform())
// Draw()s in an order.
g.galaxy.Draw(t)
g.ladder.Draw(t)
for iPath := range g.paths {
g.paths[iPath].Draw(t)
}
g.nametagPicks.Draw(t)
g.nametagPrizes.Draw(t)
if g.explosions.IsExploding() {
g.explosions.Draw(t)
}
for iEmoji := range g.emojis {
g.emojis[iEmoji].Draw(
t, pixel.IM.
Scaled(pixel.ZV, 2).
Rotated(pixel.ZV, -g.camera.Angle()).
Moved(g.paths[iEmoji].PosTip()),
)
}
if g.isScalpelMode {
g.scalpel.Draw(t)
}
if g.isScalpelMode {
UpdateDrawUnprojekt(g.window, g.ladder.bound, colornames.Blue, g.camera.Transform())
UpdateDrawUnprojekt2(g.window, g.ladder.bound, colornames.Red, *g.camera)
}
// ---------------------------------------------------
// 2. canvas a screen
t.SetMatrix(pixel.IM)
// Draw()s in an order.
g.fpsw.Draw(g.window)
if g.isScalpelMode {
UpdateDrawProjekt(g.window, g.ladder.bound, colornames.Black, g.camera.Transform())
}
}
func (g *game) Update(dt float64) {
g.mutex.Lock()
defer g.mutex.Unlock()
// The camera would and should update every frame.
g.camera.Update(dt)
// Update only if there is a need.
// isRefreshedLadder be set to false if there was an update to the ladder or its scalpel.
if !g.isRefreshedLadder {
g.ladder.Update()
g.scalpel.Update(*g.ladder)
g.isRefreshedLadder = true
}
// Only update when there is a need.
if !g.isRefreshedNametags {
g.nametagPicks.Update()
g.nametagPrizes.Update()
g.isRefreshedNametags = true
}
// Only currently animating paths need to update each frame.
for iPath := range g.paths {
if g.paths[iPath].IsAnimating() {
g.paths[iPath].Update(g.ladder.colors[iPath])
}
}
// As long as it doesn't hurt the framerate.
if g.fpsw.GetFPS() >= 10 {
g.galaxy.Update(dt)
}
// Only update when there is at least one (animating) explosion.
if g.explosions.IsExploding() {
g.explosions.Update(dt)
}
}
func (g *game) OnResize(width, height float64) {
g.camera.SetScreenBound(pixel.R(0, 0, width, height))
g.fpsw.SetPos(pixel.V(width, height), gg.Top, gg.Right)
// g.explosions.SetBound(width, height)
}
// -------------------------------------------------------------------------
// Single path
// ClearPath of a participant.
func (g *game) ClearPath(participant int) {
g.paths[participant] = *NewPathEmpty()
}
// ResetPath of a participant.
func (g *game) ResetPath(participant int) {
// GeneratePath contains a path-finding algorithm. This function is used as a path finder.
GeneratePath := func(g *game, participant int) Path {
const icol int = 0 // level
irow := participant // participant
grid := g.ladder.grid
route := []pixel.Vec{}
prize := -1
for level := icol; level < g.ladder.nLevel; level++ {
route = append(route, grid[irow][level])
prize = irow
if irow+1 < g.ladder.nParticipants {
if g.ladder.bridges[irow][level] {
irow++ // cross the bridge ... to the left (south)
route = append(route, grid[irow][level])
prize = irow
continue
}
}
if irow-1 >= 0 {
if g.ladder.bridges[irow-1][level] {
irow-- // cross the bridge ... to the right (north)
route = append(route, grid[irow][level])
prize = irow
continue
}
}
}
// log.Println(participant, prize, irow) //
// A path found here is called a route or roads.
return *NewPath(route, &prize) // val, not ptr
}
g.paths[participant] = GeneratePath(g, participant) // path-find
g.paths[participant].OnPassedEachPoint = func(pt pixel.Vec, dir pixel.Vec) {
g.explosions.ExplodeAt(pt, dir.Scaled(2))
}
}
func (g *game) AnimatePath(participant int) {
g.paths[participant].Animate()
}
func (g *game) AnimatePathInTime(participant int, sec float64) {
g.paths[participant].AnimateInTime(sec)
}
// -------------------------------------------------------------------------
// All paths
func (g *game) ResetPaths() {
g.mutex.Lock()
defer g.mutex.Unlock()
for participant := 0; participant < g.nPlayers; participant++ {
g.ResetPath(participant)
}
}
// AnimatePaths in order.
func (g *game) AnimatePaths(thunkAnimatePath func(participant int)) {
g.mutex.Lock()
defer g.mutex.Unlock()
for participant := 0; participant < g.nPlayers; participant++ {
participantCurr := participant
participantNext := participant + 1
prize := g.paths[participantCurr].GetPrize()
title := "Result"
caption := fmt.Sprint(
" 👆 Pick\t(No. ", participantCurr+1, ")\t", g.nametagPicks[participantCurr], "\t",
"\r\n", "\r\n",
" 🎁 Prize\t(No. ", prize+1, ")\t", g.nametagPrizes[prize], "\t",
"\r\n",
)
g.paths[participant].OnFinishedAnimation = func() {
if g.window.Monitor() == nil {
dialog.Message("%s", caption).Title(title).Info()
}
if participantNext < g.nPlayers {
thunkAnimatePath(participantNext)
}
g.paths[participantCurr].OnFinishedAnimation = nil
}
}
thunkAnimatePath(0)
}
// -------------------------------------------------------------------------
// Game controls
func (g *game) Reset() {
g.ladder.Reset()
g.ResetPaths()
g.isRefreshedLadder = false
}
// Shuffle in an approximate time.
func (g *game) Shuffle(times, inMillisecond int) {
speed := g.galaxy.Speed()
g.galaxy.SetSpeed(speed * 10)
{
i := 0
for range time.Tick(
(time.Millisecond * time.Duration(inMillisecond)) / time.Duration(times),
) {
g.bg = gg.RandomNiceColor()
g.Reset()
i++
if i >= times {
break
}
}
}
g.galaxy.SetSpeed(speed)
}
// Pause the game.
func (g *game) Pause() {
for i := range g.paths {
if g.paths[i].IsAnimating() {
g.paths[i].Pause()
}
}
}
// Resume after pause.
func (g *game) Resume() {
g.dtw.Dt()
for i := range g.paths {
if g.paths[i].IsAnimating() {
g.paths[i].Resume()
}
}
}
func (g *game) SetFullScreenMode(on bool) {
if on {
monitor := pixelgl.PrimaryMonitor()
width, height := monitor.Size()
// log.Println(monitor.VideoModes()) //
g.window.SetMonitor(monitor)
go func(width, height float64) {
g.OnResize(width, height)
}(width, height)
} else if !on { // off
g.window.SetMonitor(nil)
} else {
panic(errors.New("it may be thread"))
}
}
// -------------------------------------------------------------------------
// Read only methods
// WindowDeep is a hacky way to access a window in deep.
// It returns (window *glfw.Window) which is an unexported member inside a (*pixelgl.Window).
// Read only argument game ignores the pass lock by value warning.
func (g game) WindowDeep() (baseWindow *glfw.Window) {
return *(**glfw.Window)(unsafe.Pointer(reflect.Indirect(reflect.ValueOf(g.window)).FieldByName("window").UnsafeAddr()))
}
// Read only argument game ignores the pass lock by value warning.
func (g game) BridgesCount() (sum int) {
for _, row := range g.ladder.bridges {
for _, col := range row {
if col {
sum++
}
}
}
return sum
}
// -------------------------------------------------------------------------
// Run on main thread
// Run the game window and its event loop on main thread.
func (g *game) Run() {
pixelgl.Run(func() {
g.RunLazyInit()
g.RunEventLoop()
})
}
func (g *game) RunLazyInit() {
// This window will show up as soon as it is created.
win, err := pixelgl.NewWindow(pixelgl.WindowConfig{
Title: title + " (" + version + ")",
Icon: nil,
Bounds: pixel.R(0, 0, g.winWidth, g.winHeight),
Monitor: nil,
Resizable: true,
// Undecorated: true,
VSync: false,
})
if err != nil {
panic(err)
}
win.SetSmooth(true)
MoveWindowToCenterOfPrimaryMonitor := func(win *pixelgl.Window) {
vmodes := pixelgl.PrimaryMonitor().VideoModes()
vmodesLast := vmodes[len(vmodes)-1]
biggestResolution := pixel.R(0, 0, float64(vmodesLast.Width), float64(vmodesLast.Height))
win.SetPos(biggestResolution.Center().Sub(win.Bounds().Center()))
}
MoveWindowToCenterOfPrimaryMonitor(win)
// lazy init vars
g.window = win
g.camera = gg.NewCamera(g.ladder.bound.Center(), g.window.Bounds())
// register callback
windowGL := g.WindowDeep()
windowGL.SetSizeCallback(func(_ *glfw.Window, width int, height int) {
g.OnResize(float64(width), float64(height))
})
// time manager
g.vsync = time.Tick(time.Second / 120)
g.fpsw.Start()
g.dtw.Start()
// so-called loading
{
g.window.Clear(colornames.Brown)
screenCenter := g.window.Bounds().Center()
txt := text.New(screenCenter, gg.NewAtlas("", 36, nil))
txt.WriteString("Loading...")
txt.Draw(g.window, pixel.IM)
g.window.Update()
}
g.NextFrame(g.dtw.Dt()) // Give it a blood pressure.
g.NextFrame(g.dtw.Dt()) // Now the oxygenated blood will start to pump through its vein.
// Do whatever you want after that...
// from user setting
g.camera.Zoom(float64(g.initialZoomLevel))
g.camera.Rotate(g.initialRotateDegree)
}
func (g *game) RunEventLoop() {
for g.window.Closed() != true { // Your average event loop in main thread.
// Notice that all function calls as go routine are non-blocking, but the others will block the main thread.
// ---------------------------------------------------
// 0. dt
dt := g.dtw.Dt()
// ---------------------------------------------------
// 1. handling events
g.HandlingEvents(dt)
// ---------------------------------------------------
// 2. move on
g.NextFrame(dt)
// log.Println(g.window.Closed()) //
} // for
} // func
func (g *game) HandlingEvents(dt float64) {
// Notice that all function calls as go routine are non-blocking, but the others will block the main thread.
// system
if g.window.JustReleased(pixelgl.KeyEscape) {
g.window.SetClosed(true)
}
if g.window.JustReleased(pixelgl.KeySpace) {
g.Pause()
dialog.Message("%s", "Pause").Title("PPAP").Info()
g.Resume()
}
if g.window.JustReleased(pixelgl.KeyTab) {
if g.window.Monitor() == nil {
g.SetFullScreenMode(true)
} else {
g.SetFullScreenMode(false)
}
}
// scalpel mode
if g.window.JustReleased(pixelgl.MouseButtonRight) {
go func() {
g.isScalpelMode = !g.isScalpelMode
}()
}
if g.window.JustReleased(pixelgl.MouseButtonLeft) {
// ---------------------------------------------------
if !jukebox.IsPlaying() {
jukebox.Play()
}
// ---------------------------------------------------
posWin := g.window.MousePosition()
posGame := g.camera.Unproject(posWin)
go func() {
g.explosions.ExplodeAt(pixel.V(posGame.X, posGame.Y), pixel.V(10, 10))
}()
// ---------------------------------------------------
if g.isScalpelMode {
// strTitle := fmt.Sprint(posGame.X, ", ", posGame.Y) //
strDlg := fmt.Sprint(
"number of bridges: ", g.BridgesCount(), "\r\n", "\r\n",
"camera angle in degree: ", (g.camera.Angle()/math.Pi)*180, "\r\n", "\r\n",
"camera coordinates: ", g.camera.XY().X, g.camera.XY().Y, "\r\n", "\r\n",
"game clock: ", g.dtw.GetTimeStarted(), "\r\n", "\r\n",
"starfield speed: ", g.galaxy.Speed(), "\r\n", "\r\n",
"mouse click coords in screen pos: ", posWin.X, posWin.Y, "\r\n", "\r\n",
"mouse click coords in game pos: ", posGame.X, posGame.Y,
)
go func() {
// g.window.SetTitle(strTitle) //
dialog.Message("%s", strDlg).Title("MouseButtonLeft").Info()
}()
}
}
// game ctrl
if g.window.JustReleased(pixelgl.Key1) { // shuffle
go func() {
g.Shuffle(10, 750)
}()
}
if g.window.JustReleased(pixelgl.Key2) { // find path slow
go func() {
g.ResetPaths()
g.AnimatePaths(g.AnimatePath)
}()
}
if g.window.JustReleased(pixelgl.Key3) { // find path fast
go func() {
g.ResetPaths()
g.AnimatePaths(func(participant int) {
g.AnimatePathInTime(participant, 1)
})
}()
}
// camera
if g.window.JustReleased(pixelgl.KeyEnter) {
go func() {
g.camera.Rotate(-90)
}()
}
if g.window.Pressed(pixelgl.KeyRight) {
go func(dt float64) { // This camera will go diagonal while the case is in middle of rotating the camera.
g.camera.Move(pixel.V(1000*dt, 0).Rotated(-g.camera.Angle()))
}(dt)
}
if g.window.Pressed(pixelgl.KeyLeft) {
go func(dt float64) {
g.camera.Move(pixel.V(-1000*dt, 0).Rotated(-g.camera.Angle()))
}(dt)
}
if g.window.Pressed(pixelgl.KeyUp) {
go func(dt float64) {
g.camera.Move(pixel.V(0, 1000*dt).Rotated(-g.camera.Angle()))
}(dt)
}
if g.window.Pressed(pixelgl.KeyDown) {
go func(dt float64) {
g.camera.Move(pixel.V(0, -1000*dt).Rotated(-g.camera.Angle()))
}(dt)
}
{ // if scrolled
zoomLevel := g.window.MouseScroll().Y
go func() {
g.camera.Zoom(zoomLevel)
}()
}
}
func (g *game) NextFrame(dt float64) {
// ---------------------------------------------------
// 1. update - calc state of game objects each frame
g.Update(dt)
g.fpsw.Poll()
// ---------------------------------------------------
// 2. draw on window
g.window.Clear(g.bg) // clear canvas
g.Draw() // then draw
// ---------------------------------------------------
// 3. update window - always end with it
g.window.Update()
<-g.vsync
}
// -------------------------------------------------------------------------
// On compile
const title = "AMIDA KUJI"
var version = "undefined"
// -------------------------------------------------------------------------
// Entry point
func main() {
defer func() {
err := jukebox.Finalize()
if err != nil {
log.Fatal(err)
}
}()
rand.Seed(time.Now().UnixNano())
conf := askConf()
if conf == nil {
conf = map[string]interface{}{
"window_width": 800.0,
"window_height": 800.0,
"max_player": 10.0,
"max_level": 100.0,
"width": 1500.0,
"height": 1500.0,
"zoom": -4.0,
"rotate_degree": 270.0,
"margin_top": 50.0,
"margin_right": 100.0,
"margin_bottom": 50.0,
"margin_left": 200.0,
"font_size": 28.0,
"picks": []interface{}{"Bulbasaur", "Ivysaur", "Venusaur", "Charmander", "Charmeleon", "Charizard", "Squirtle", "Wartortle", "Blastoise", "Caterpie", "Metapod", "Butterfree", "Weedle", "Kakuna", "Beedrill", "Pidgey", "Pidgeotto", "Pidgeot", "Rattata"},
"prizes": []interface{}{"TM88", "TM89", "TM90", "TM91", "TM92", "HM01", "HM02", "HM03", "HM04", "HM05", "HM06"},
}
}
newGame(gameConfig{
winWidth: conf["window_width"].(float64),
winHeight: conf["window_height"].(float64),
nParticipants: int(conf["max_player"].(float64)),
nLevel: int(conf["max_level"].(float64)),
width: conf["width"].(float64),
height: conf["height"].(float64),
initialZoomLevel: conf["zoom"].(float64),
initialRotateDegree: conf["rotate_degree"].(float64),
paddingTop: conf["margin_top"].(float64),
paddingRight: conf["margin_right"].(float64),
paddingBottom: conf["margin_bottom"].(float64),
paddingLeft: conf["margin_left"].(float64),
fontSize: conf["font_size"].(float64),
nametagPicks: gg.ItfsToStrs(conf["picks"].([]interface{})),
nametagPrizes: gg.ItfsToStrs(conf["prizes"].([]interface{})),
}).Run()
}
func askConf() (conf map[string]interface{}) {
for { // Load JSON
cwd, _ := os.Getwd()
filepath, err := dialog.File().Title("Load User Settings").
Filter("JSON Format (*.json)", "json").
Filter("All Files (*.*)", "*").
SetStartDir(cwd).Load()
if err != nil {
if err.Error() == "Cancelled" {
conf = nil
break
}
dialog.Message("%s", "Invalid file path."+"\r\n"+"\r\n"+fmt.Sprint(err)).Title("Failed to load JSON").Error()
continue
}
bytes, err := ioutil.ReadFile(filepath)
if err != nil {
dialog.Message("%s", "Could not read the file."+"\r\n"+"\r\n"+fmt.Sprint(err)).Title("Failed to load JSON").Error()
continue
}
err = json.Unmarshal(bytes, &conf)
if err != nil {
dialog.Message("%s", "The file is not valid JSON format."+"\r\n"+"\r\n"+fmt.Sprint(err)).Title("Failed to load JSON").Error()
continue
}
break
}
return
}