main.go

package main

import (
	"fmt"
	"log"
	"time"

	"github.com/soupstoregames/coda-mud/config"
	"github.com/soupstoregames/coda-mud/servers/telnet"
	"github.com/soupstoregames/coda-mud/services"
	"github.com/soupstoregames/coda-mud/simulation"
	"github.com/soupstoregames/coda-mud/simulation/data/state"
	"github.com/soupstoregames/coda-mud/simulation/data/static"
	"github.com/soupstoregames/go-core/logging"
)

func main() {
	var (
		conf         *config.Config
		staticData   *static.DataWatcher
		stateData    *state.FileSystem
		sim          *simulation.Simulation
		usersManager *services.UsersManager
		err          error
	)

	logging.Info("Starting")

	// load the configuration from environmental variables
	if conf, err = config.Load(); err != nil {
		logging.Fatal(err.Error())
	}

	// create the simulation
	sim = simulation.NewSimulation()

	// create the static data loader
	staticData = static.NewDataWatcher(conf.DataPath, sim)
	logging.SubscribeToErrorChan(staticData.Errors)

	// create a persister to save the simulation state
	if stateData, err = state.NewFileSystem(conf); err != nil {
		logging.Fatal(err.Error())
	}

	// create the users service for managing login details
	usersManager = services.NewUsersManager()

	// load the static data
	if err := staticData.InitialLoad(); err != nil {
		logging.Fatal(err.Error())
	}

	// start watching for changes to the static data folder
	staticData.Watch()

	// load the saved state
	loadState(stateData, usersManager, sim)

	// set the @spawn room
	sim.SetSpawnRoom("@spawn", 1)

	// set up save timing for simulation state
	startSaveSimulationTicker(usersManager, sim, stateData)

	// start the simulation
	sim.Start()

	// start the telnet server
	telnetServer := telnet.NewServer(conf, sim, usersManager)
	if err = telnetServer.ListenAndServe(); err != nil {
		log.Fatal(err.Error())
	}

}

func loadState(loader state.Loader, usersManager *services.UsersManager, sim simulation.StateController) {
	var (
		users      []state.User
		characters []state.Character
		worlds     []state.World
		err        error
	)

	if users, characters, worlds, err = loader.Load(); err != nil {
		logging.Fatal(err.Error())
	}
	if usersManager.Load(users); err != nil {
		logging.Fatal(err.Error())
	}
	if sim.Load(characters, worlds); err != nil {
		logging.Fatal(err.Error())
	}
}

func startSaveSimulationTicker(u *services.UsersManager, s *simulation.Simulation, p state.Persister) {
	t := time.NewTicker(time.Minute)
	go func() {
		for range t.C {
			if err := u.Save(p); err != nil {
				logging.Warn(fmt.Sprintf("Failed to save users: %s", err.Error()))
			}
			if err := s.Save(p); err != nil {
				logging.Warn(fmt.Sprintf("Failed to save simulation state: %s", err.Error()))
			}
		}
	}()
}