project-ely/main.go

package main

import (
	"fmt"
	"log"
	"os"

	"gitea.wisellama.rocks/Project-Ely/project-ely/internal/config"
	"gitea.wisellama.rocks/Project-Ely/project-ely/internal/game"
	"gitea.wisellama.rocks/Project-Ely/project-ely/internal/game/entity"
	"gitea.wisellama.rocks/Project-Ely/project-ely/internal/game/sprite"
	"gitea.wisellama.rocks/Project-Ely/project-ely/internal/vector"
	"gitea.wisellama.rocks/Wisellama/gosimpleconf"
	"github.com/veandco/go-sdl2/sdl"
)

func main() {
	var err error

	// Read configuration
	configMap, err := config.Configure("game.conf")
	if err != nil {
		log.Fatalf("error during configure: %v\n", err)
	}

	// Setup logging
	writeToFile := gosimpleconf.Bool(configMap["log.writeToFile"])
	logFilename := configMap["log.file"]
	logWriter, err := config.SetupLogging(writeToFile, logFilename)
	if err != nil {
		log.Fatalf("error setting up logging: %v\n", err)
	}
	defer logWriter.Cleanup()

	// Start everything with the SDL goroutine context
	log.Printf("=== Starting %v ===", configMap["game.title"])
	sdl.Main(func() {
		err = run(configMap)
	})

	exitcode := 0
	if err != nil {
		log.Printf("ERROR: %v\n", err)
		exitcode = 1
	}

	os.Exit(exitcode)
}

func run(configMap gosimpleconf.ConfigMap) error {
	var err error

	err = game.SdlInit()
	if err != nil {
		return err
	}
	defer game.SdlQuit()

	gameWindow, err := game.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
	}
	defer sprite.CleanupSpriteCache()

	entity.DefinePenguinAnimations()

	penguin := entity.NewPenguin(renderer)
	p2 := entity.NewPenguin(renderer)
	p2.SetPosition(&vector.Vec2F{X: 100, Y: 100})
	p2.SetAnimation(entity.PENGUIN_WALK_LEFT)

	keystates := make(map[sdl.Keycode]bool)

	running := true
	for running {
		var event sdl.Event
		sdl.Do(func() {
			event = sdl.PollEvent()
		})
		for event != nil {
			switch e := event.(type) {
			case *sdl.QuitEvent:
				running = false
			case *sdl.KeyboardEvent:
				if e.Keysym.Sym == sdl.K_ESCAPE {
					log.Println("Esc quitting")
					running = false
				}

				// Key states (just set a boolean whether the key is actively being pressed)
				if e.Type == sdl.KEYDOWN {
					keystates[e.Keysym.Sym] = true
				} else if e.Type == sdl.KEYUP {
					keystates[e.Keysym.Sym] = false
				}
			}

			sdl.Do(func() {
				event = sdl.PollEvent()
			})
		}

		if keystates[sdl.K_d] {
			penguin.MoveRight()
		} else if keystates[sdl.K_a] {
			penguin.MoveLeft()
		} else {
			penguin.StopHorizontal()
		}

		if keystates[sdl.K_w] {
			penguin.MoveUp()
		} else if keystates[sdl.K_s] {
			penguin.MoveDown()
		} else {
			penguin.StopVertical()
		}

		if !keystates[sdl.K_a] && !keystates[sdl.K_d] && !keystates[sdl.K_w] && !keystates[sdl.K_s] {
			penguin.StopMove()
		}

		// 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)
			}
		})

		// Everything else
		err = penguin.Update()
		if err != nil {
			log.Printf("error updating: %v\n", err)
		}
		err = penguin.Draw()
		if err != nil {
			log.Printf("error drawing: %v\n", err)
		}

		err = p2.Update()
		if err != nil {
			log.Printf("error updating: %v\n", err)
		}
		err = p2.Draw()
		if err != nil {
			log.Printf("error drawing: %v\n", err)
		}

		// Draw
		sdl.Do(func() {
			renderer.Present()
			sdl.Delay(16) // 60 FPS, well ok 62.5 FPS
		})
	}

	return nil
}