Move all init and config into GoRetro from GoEscape

component_animator.go

@@ -99,6 +99,8 @@ func NewSequence(
 
 	var seq Sequence
 
+	filepath = Config.DataDir + filepath
+
 	// Get a list of frames
 	files, err := ioutil.ReadDir(filepath)
 	if err != nil {

component_bounder_screen.go

@@ -25,8 +25,8 @@ func (bounder *bounderScreen) onUpdate() error {
 
 	// If the position is outside the screen bounds then set it as inactive
 	// and mark for deletion
-	if b.Position.X > ScreenWidth || b.Position.X < 0 ||
+	if b.Position.X > float64(Config.ScreenWidth) || b.Position.X < 0 ||
-		b.Position.Y > ScreenHeight || b.Position.Y < 0 {
+		b.Position.Y > float64(Config.ScreenHeight) || b.Position.Y < 0 {
 		b.Active = false
 		b.Delete = true
 	}

component_bounder_screen_resetting.go

@@ -25,17 +25,17 @@ func (bounder *bounderScreenResetting) onUpdate() error {
 
 	// If any position exceeds the screen dimensions, wrap it to the
 	// opposite side
-	if b.Position.X > ScreenWidth {
+	if b.Position.X > float64(Config.ScreenWidth) {
 		b.Position.X = 0
 	}
 	if b.Position.X < 0 {
-		b.Position.X = ScreenWidth
+		b.Position.X = float64(Config.ScreenWidth)
 	}
-	if b.Position.Y > ScreenHeight {
+	if b.Position.Y > float64(Config.ScreenHeight) {
 		b.Position.Y = 0
 	}
 	if b.Position.Y < 0 {
-		b.Position.Y = ScreenWidth
+		b.Position.Y = float64(Config.ScreenWidth)
 	}
 
 	return nil

component_mover_keyboard.go

@@ -43,7 +43,7 @@ func (mover *moverKeyboard) onUpdate() error {
 	}
 	cRight := Circle{
 		Radius: 1,
-		Center: Vector{X: ScreenWidth, Y: mover.container.Position.Y},
+		Center: Vector{X: float64(Config.ScreenWidth), Y: mover.container.Position.Y},
 	}
 	cTop := Circle{
 		Radius: 1,
@@ -51,7 +51,7 @@ func (mover *moverKeyboard) onUpdate() error {
 	}
 	cBottom := Circle{
 		Radius: 1,
-		Center: Vector{X: mover.container.Position.X, Y: ScreenHeight},
+		Center: Vector{X: mover.container.Position.X, Y: float64(Config.ScreenHeight)},
 	}
 
 	// Handle direction keys and check of we collide.

component_sprite_renderer.go

@@ -23,6 +23,7 @@ func NewSpriteRenderer(container *Element, renderer *sdl.Renderer, filename stri
 	sr := &spriteRenderer{}
 	var err error
 
+	filename = Config.DataDir + filename
 	sr.tex, err = loadTextureFromBMP(filename, renderer)
 	if err != nil {
 		panic(err)

goretro.go

@@ -1,17 +1,126 @@
 package GoRetro
 
-import "time"
+import (
+	"fmt"
+	"time"
 
-const (
+	"github.com/veandco/go-sdl2/sdl"
-	ScreenWidth  = 1024
-	ScreenHeight = 768
-
-	TargetTicksPerSecond   = 60
-	DebugStatePrintSeconds = 1
-
-	dataDir = "data/"
 )
 
+var Config struct {
+	ScreenWidth  int32
+	ScreenHeight int32
+
+	TargetTicksPerSecond   float64
+	DebugStatePrintSeconds float64
+
+	DataDir string
+}
+
 var Delta float64
 var LastDebugStatePrint time.Time
 var DebugTick bool
+
+func Init() (*sdl.Renderer, *sdl.Window) {
+	if err := sdl.Init(sdl.INIT_EVERYTHING); err != nil {
+		fmt.Println("initializing SDL:", err)
+		return nil, nil
+	}
+
+	fmt.Printf("%d x %d", Config.ScreenWidth, Config.ScreenHeight)
+
+	window, err := sdl.CreateWindow(
+		"GoEscape",
+		sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED,
+		Config.ScreenWidth, Config.ScreenHeight,
+		sdl.WINDOW_OPENGL)
+	if err != nil {
+		fmt.Println("initializing window:", err)
+		return nil, nil
+	}
+
+	renderer, err := sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED)
+	if err != nil {
+		fmt.Println("initializing renderer:", err)
+		return nil, nil
+	}
+
+	TexList = make(map[string]*sdl.Texture)
+
+	LastDebugStatePrint = time.Now()
+
+	return renderer, window
+}
+
+func Tick(renderer *sdl.Renderer) bool {
+	if time.Since(LastDebugStatePrint).Seconds() > Config.DebugStatePrintSeconds {
+		DebugTick = true
+		LastDebugStatePrint = time.Now()
+	} else {
+		DebugTick = false
+	}
+
+	frameStartTime := time.Now()
+
+	for event := sdl.PollEvent(); event != nil; event = sdl.PollEvent() {
+		switch event.(type) {
+		case *sdl.QuitEvent:
+			return false
+		}
+	}
+
+	renderer.SetDrawColor(0, 0, 0, 255)
+	renderer.Clear()
+
+	var maxZ = 0
+	for _, elem := range Elements {
+		if elem.Active {
+			err := elem.Update()
+			if err != nil {
+				fmt.Println("updating element:", err)
+				return false
+			}
+			if elem.ZIndex > maxZ {
+				maxZ = elem.ZIndex
+			}
+		}
+	}
+	for z := 0; z <= maxZ; z++ {
+		for _, elem := range Elements {
+			if elem.ZIndex == z {
+				if elem.Active {
+					err := elem.Draw()
+					if err != nil {
+						fmt.Println("drawing element:", err)
+						return false
+					}
+				}
+			}
+		}
+	}
+
+	if err := CheckCollisions(); err != nil {
+		fmt.Println("checking collisions:", err)
+		return false
+	}
+
+	renderer.Present()
+
+	var truncate int = 0
+	for i, elem := range Elements {
+		if elem.Delete {
+			copy(Elements[i:], Elements[i+1:])
+			truncate++
+		}
+	}
+	Elements = Elements[:len(Elements)-truncate]
+
+	if DebugTick {
+		fmt.Printf("TPS: %d\n", 1000000/(time.Since(frameStartTime).Microseconds()+1))
+		fmt.Printf("Elements: %d\n", len(Elements))
+
+	}
+
+	Delta = time.Since(frameStartTime).Seconds() * Config.TargetTicksPerSecond
+	return true
+}