chore: clean up code/comments (#1)

cardinal/config.go

@@ -3,38 +3,33 @@ package main
 import (
 	"github.com/argus-labs/starter-game-template/cardinal/utils"
 	"github.com/argus-labs/world-engine/cardinal/ecs"
-	"github.com/rs/zerolog/log"
 	"os"
 )
 
 type Config struct {
 	CardinalPort string
-	World        *ecs.World
+	Mode         string
+	RedisAddr    string
+	RedisPass    string
 }
 
-var (
-	EnvRedisMode     = os.Getenv("REDIS_MODE")
-	EnvRedisAddr     = os.Getenv("REDIS_ADDR")
-	EnvRedisPassword = os.Getenv("REDIS_PASSWORD")
-	EnvCardinalPort  = os.Getenv("CARDINAL_PORT")
-)
-
 func GetConfig() Config {
-	if EnvRedisMode == "normal" {
-		return Config{
-			CardinalPort: EnvCardinalPort,
-			World:        utils.NewWorld(EnvRedisAddr, EnvRedisPassword),
-		}
-	} else if EnvRedisMode == "embedded" {
-		return Config{
-			CardinalPort: EnvCardinalPort,
-			World:        utils.NewEmbeddedWorld(),
-		}
-	} else {
-		log.Log().Msg("REDIS_MODE is not set, using fallback - embedded")
-		return Config{
-			CardinalPort: EnvCardinalPort,
-			World:        utils.NewEmbeddedWorld(),
-		}
+	mode := os.Getenv("REDIS_MODE")
+	redisAddr := os.Getenv("REDIS_ADDR")
+	redisPassword := os.Getenv("REDIS_PASSWORD")
+	cardinalPort := os.Getenv("CARDINAL_PORT")
+
+	return Config{
+		CardinalPort: cardinalPort,
+		Mode:         mode,
+		RedisAddr:    redisAddr,
+		RedisPass:    redisPassword,
+	}
+}
+
+func NewWorld(cfg Config) *ecs.World {
+	if cfg.Mode == "normal" {
+		utils.NewWorld(cfg.RedisAddr, cfg.RedisPass)
 	}
+	return utils.NewEmbeddedWorld()
 }

cardinal/main.go

@@ -6,9 +6,9 @@ import (
 	"github.com/argus-labs/starter-game-template/cardinal/read"
 	"github.com/argus-labs/starter-game-template/cardinal/system"
 	"github.com/argus-labs/starter-game-template/cardinal/tx"
-	"github.com/argus-labs/starter-game-template/cardinal/utils"
 	"github.com/argus-labs/world-engine/cardinal/server"
 	"github.com/rs/zerolog"
+	"github.com/rs/zerolog/log"
 	"time"
 )
 
@@ -19,32 +19,41 @@ func main() {
 
 	// TODO: In production, you should set DEPLOY_MODE=production
 	// and set REDIS_ADDR and REDIS_PASSWORD to use a real Redis instance.
-	// Otherwise, by default cardinal will run using an in-memory "miniredis"
-	world := cfg.World
+	// Otherwise, by default cardinal will run using an in-memory redis.
+	world := NewWorld(cfg)
 
 	// Register components
 	// NOTE: You must register your components here,
 	// otherwise it will show an error when you try to use them in a system.
-	utils.Must(world.RegisterComponents(
+	err := world.RegisterComponents(
 		component.Player,
 		component.Health,
-	))
+	)
+	if err != nil {
+		log.Fatal().Err(err)
+	}
 
 	// Register transactions
 	// NOTE: You must register your transactions here,
 	// otherwise it will show an error when you try to use them in a system.
-	utils.Must(world.RegisterTransactions(
+	err = world.RegisterTransactions(
 		tx.CreatePlayer,
 		tx.AttackPlayer,
-	))
+	)
+	if err != nil {
+		log.Fatal().Err(err)
+	}
 
 	// Register read endpoints
 	// NOTE: You must register your read endpoints here,
 	// otherwise it will not be accessible.
-	utils.Must(world.RegisterReads(
+	err = world.RegisterReads(
 		read.Archetype,
 		read.Constant,
-	))
+	)
+	if err != nil {
+		log.Fatal().Err(err)
+	}
 
 	// Each system executes deterministically in the order they are added.
 	// This is a neat feature that can be strategically used for systems that depends on the order of execution.
@@ -55,7 +64,11 @@ func main() {
 	world.AddSystem(system.PlayerSpawnerSystem)
 
 	// Load game state
-	utils.Must(world.LoadGameState())
+	err = world.LoadGameState()
+	if err != nil {
+		log.Fatal().Err(err)
+	}
+
 	world.StartGameLoop(context.Background(), time.Second)
 
 	// TODO: When launching to production, you should enable signature verification.

cardinal/utils/world.go

@@ -34,9 +34,9 @@ func NewWorld(addr string, password string) *ecs.World {
 }
 
 // NewEmbeddedWorld is the most convenient way to run the game
-// because it doesn't require spinning up Redis in a container
-// it runs a Redis server as a part of the Go process
-// However, it will not work with Cardinal Editor.
+// because it doesn't require spinning up Redis in a container.
+// It runs a Redis server as a part of the Go process.
+// NOTE: worlds with embedded redis are incompatible with Cardinal Editor.
 func NewEmbeddedWorld() *ecs.World {
 	log.Log().Msg("Running in embedded mode, using embedded miniredis")
 	return inmem.NewECSWorld()