212 lines
4.7 KiB
Go
212 lines
4.7 KiB
Go
package game
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"log"
|
|
"math/rand"
|
|
"strconv"
|
|
"sync"
|
|
|
|
"git.wisellama.rocks/Project-Ely/project-ely/internal/game/entity/animation"
|
|
"git.wisellama.rocks/Project-Ely/project-ely/internal/game/entity/command"
|
|
"git.wisellama.rocks/Project-Ely/project-ely/internal/game/entity/types"
|
|
"git.wisellama.rocks/Project-Ely/project-ely/internal/game/player"
|
|
"git.wisellama.rocks/Project-Ely/project-ely/internal/game/sprite"
|
|
"git.wisellama.rocks/Project-Ely/project-ely/internal/game/window"
|
|
"git.wisellama.rocks/Project-Ely/project-ely/internal/vector"
|
|
"git.wisellama.rocks/Wisellama/gosimpleconf"
|
|
"github.com/veandco/go-sdl2/sdl"
|
|
)
|
|
|
|
type EntityCmdHandler interface {
|
|
Run()
|
|
CloseRequests()
|
|
CommandRequest() chan command.Command
|
|
DrawRequest() chan bool
|
|
DrawResponse() chan bool
|
|
UpdateRequest() chan bool
|
|
UpdateResponse() chan bool
|
|
}
|
|
|
|
// Run is the main function to start the game.
|
|
func Run(ctx context.Context, configMap gosimpleconf.ConfigMap) error {
|
|
var err error
|
|
|
|
ctx, cancel := context.WithCancel(ctx)
|
|
defer cancel()
|
|
|
|
framerate, err := strconv.ParseFloat(configMap["game.framerate"], 64)
|
|
if err != nil {
|
|
err = fmt.Errorf("error parsing framerate: %w", err)
|
|
return err
|
|
}
|
|
framerateDelay := uint32(1000 / framerate)
|
|
|
|
err = window.SdlInit()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer window.SdlQuit()
|
|
|
|
gameWindow, err := window.NewWindow(configMap["game.title"])
|
|
if err != nil {
|
|
err = fmt.Errorf("failed creating GameWindow: %w", err)
|
|
return err
|
|
}
|
|
defer gameWindow.Cleanup()
|
|
|
|
var renderer *sdl.Renderer
|
|
sdl.Do(func() {
|
|
renderer, err = sdl.CreateRenderer(gameWindow.SdlWindow, -1, sdl.RENDERER_ACCELERATED)
|
|
})
|
|
if err != nil {
|
|
err = fmt.Errorf("failed creating SDL renderer: %w", err)
|
|
return err
|
|
}
|
|
defer func() {
|
|
sdl.Do(func() {
|
|
err = renderer.Destroy()
|
|
if err != nil {
|
|
log.Printf("error destroying renderer: %v\n", err)
|
|
}
|
|
})
|
|
}()
|
|
|
|
err = sprite.InitSpriteCache(renderer)
|
|
if err != nil {
|
|
err = fmt.Errorf("failed in InitSpriteCache: %w", err)
|
|
return err
|
|
}
|
|
|
|
animation.DefineAnimations()
|
|
|
|
inputHandler := window.NewInputHandler(ctx)
|
|
|
|
// Done with main setup, now moving on to creating specific entities
|
|
|
|
entityList := make([]EntityCmdHandler, 0)
|
|
wg := sync.WaitGroup{}
|
|
|
|
// Setup Player 1
|
|
// Let them control a penguin to start with
|
|
player1 := player.NewPlayer(ctx, inputHandler)
|
|
penguinEntity := types.NewPenguin(renderer)
|
|
penguinCmdHandler := command.NewCommandHandler(ctx, &penguinEntity)
|
|
penguinEntity.SetSpeed(2.0)
|
|
entityList = append(entityList, penguinCmdHandler)
|
|
player1.SetEntityChan(penguinCmdHandler.CommandRequest())
|
|
wg.Add(1)
|
|
go func() {
|
|
defer wg.Done()
|
|
penguinCmdHandler.Run()
|
|
}()
|
|
|
|
for i := 0; i < 10; i++ {
|
|
entity := types.NewPenguin(renderer)
|
|
entityCmd := command.NewCommandHandler(ctx, &entity)
|
|
randomPos := vector.Vec2F{X: rand.Float64() * 500, Y: rand.Float64() * -500}
|
|
entity.SetPosition(randomPos)
|
|
entity.SetAnimation(rand.Intn(animation.PENGUIN_NUM_ANIMS))
|
|
entityList = append(entityList, entityCmd)
|
|
|
|
wg.Add(1)
|
|
go func() {
|
|
defer wg.Done()
|
|
entityCmd.Run()
|
|
}()
|
|
}
|
|
|
|
// Start the inputHandler
|
|
wg.Add(1)
|
|
go func() {
|
|
defer wg.Done()
|
|
inputHandler.Run()
|
|
}()
|
|
|
|
// And now starting the main loop
|
|
running := true
|
|
for running {
|
|
// Poll for SDL events
|
|
var event sdl.Event
|
|
sdl.Do(func() {
|
|
event = sdl.PollEvent()
|
|
|
|
for event != nil {
|
|
switch e := event.(type) {
|
|
case *sdl.QuitEvent:
|
|
log.Println("QuitEvent quitting")
|
|
cancel()
|
|
case *sdl.KeyboardEvent:
|
|
if e.Keysym.Sym == sdl.K_ESCAPE {
|
|
log.Println("Esc quitting")
|
|
cancel()
|
|
} else {
|
|
// Publish the event to the inputHandler
|
|
inputHandler.KeyboardChan() <- *e
|
|
}
|
|
}
|
|
|
|
event = sdl.PollEvent()
|
|
}
|
|
})
|
|
|
|
// Allow us to exit early if the context is done
|
|
select {
|
|
case <-ctx.Done():
|
|
running = false
|
|
default:
|
|
// Keep running
|
|
}
|
|
if !running {
|
|
break
|
|
}
|
|
|
|
// Players
|
|
player1.Update()
|
|
|
|
// Background
|
|
sdl.Do(func() {
|
|
err = renderer.SetDrawColor(0, 120, 0, 255)
|
|
if err != nil {
|
|
log.Printf("error in renderer.SetDrawColor: %v\n", err)
|
|
}
|
|
|
|
err = renderer.Clear()
|
|
if err != nil {
|
|
log.Printf("error in renderer.Clear: %v\n", err)
|
|
}
|
|
})
|
|
|
|
// Tell everything to Update and Draw
|
|
for _, e := range entityList {
|
|
e.UpdateRequest() <- true
|
|
e.DrawRequest() <- true
|
|
}
|
|
|
|
// Wait for each entity to finish their Draw and Update commands before proceeding
|
|
for _, e := range entityList {
|
|
<-e.UpdateResponse()
|
|
<-e.DrawResponse()
|
|
}
|
|
|
|
// Draw
|
|
sdl.Do(func() {
|
|
renderer.Present()
|
|
sdl.Delay(framerateDelay)
|
|
})
|
|
}
|
|
|
|
inputHandler.CloseChannels()
|
|
|
|
for _, e := range entityList {
|
|
e.CloseRequests()
|
|
}
|
|
|
|
sprite.CleanupSpriteCache()
|
|
|
|
wg.Wait()
|
|
|
|
return nil
|
|
}
|