Implement Go server template

Author: juho05

README.md

@@ -27,7 +27,7 @@ codegame --help
 - Create a new client
   - Go
 - Create a new game server
-  - not implemented
+  - Go
 
 ## Installation
 

commands/new.go

@@ -58,7 +58,25 @@ func New() error {
 }
 
 func newServer(projectName string) error {
-	return cli.Error("Not implemented.")
+	var language string
+	if pflag.NArg() >= 3 {
+		language = strings.ToLower(pflag.Arg(2))
+	} else {
+		var err error
+		language, err = cli.Select("In which language do you want to write your project?", []string{"Go"}, []string{"go"})
+		if err != nil {
+			return err
+		}
+	}
+
+	var err error
+	switch language {
+	case "go":
+		err = newGoServer(projectName)
+	default:
+		return cli.Error("Unsupported language: %s", language)
+	}
+	return err
 }
 
 func newClient(projectName string) error {
@@ -109,15 +127,11 @@ func newClient(projectName string) error {
 
 	switch language {
 	case "go":
-		err = newClientGo(projectName, url, cgVersion)
+		err = newGoClient(projectName, url, cgVersion)
 	default:
 		return cli.Error("Unsupported language: %s", language)
 	}
-	if err != nil {
-		return err
-	}
-
-	return nil
+	return err
 }
 
 func getCodeGameInfo(baseURL string) (string, string, error) {

commands/new_go.go

@@ -13,38 +13,55 @@ import (
 	"github.com/code-game-project/codegame-cli/external"
 )
 
-//go:embed templates/main.go.tmpl
-var goMainTemplate string
+//go:embed templates/go/client/main.go.tmpl
+var goClientMainTemplate string
 
-func newClientGo(projectName, serverURL, cgVersion string) error {
-	err := createGoTemplate(projectName, serverURL)
+//go:embed templates/go/server/main.go.tmpl
+var goServerMainTemplate string
+
+//go:embed templates/go/server/game.go.tmpl
+var goServerGameTemplate string
+
+//go:embed templates/go/server/events.cge.tmpl
+var goServerCGETemplate string
+
+//go:embed templates/go/server/events.go.tmpl
+var goServerEventsTemplate string
+
+func newGoClient(projectName, serverURL, cgVersion string) error {
+	err := createGoClientTemplate(projectName, serverURL)
 	if err != nil {
 		return err
 	}
 
-	err = installGoLibrary(projectName, cgVersion)
+	err = installGoClientLibrary(projectName, cgVersion)
 	if err != nil {
 		return err
 	}
 
 	cli.Begin("Cleaning up...")
-	err = external.ExecuteInDir(projectName, "go", "mod", "tidy")
-	if err != nil {
-		return err
-	}
 
 	if !external.IsInstalled("goimports") {
 		cli.Warn("Failed to add import statements: 'goimports' is not installed!")
 		return nil
 	}
 
 	external.ExecuteInDir(projectName, "goimports", "-w", "main.go")
+
+	out, err := external.ExecuteInDirHidden(projectName, "go", "mod", "tidy")
+	if err != nil {
+		if out != "" {
+			cli.Error(out)
+		}
+		return err
+	}
+
 	cli.Finish()
 
 	return nil
 }
 
-func createGoTemplate(projectName, serverURL string) error {
+func createGoClientTemplate(projectName, serverURL string) error {
 	module, err := cli.Input("Project module path:")
 	if err != nil {
 		return err
@@ -59,7 +76,7 @@ func createGoTemplate(projectName, serverURL string) error {
 		return err
 	}
 
-	tmpl, err := template.New("main.go").Parse(goMainTemplate)
+	tmpl, err := template.New("main.go").Parse(goClientMainTemplate)
 	if err != nil {
 		return err
 	}
@@ -81,17 +98,18 @@ func createGoTemplate(projectName, serverURL string) error {
 	return err
 }
 
-func installGoLibrary(projectName, cgVersion string) error {
+func installGoClientLibrary(projectName, cgVersion string) error {
 	cli.Begin("Fetching correct client library version...")
 
 	clientVersion := external.ClientVersionFromCGVersion("code-game-project", "go-client", cgVersion)
 
 	if clientVersion == "latest" {
-		out, err := external.ExecuteInDirHidden(projectName, "go", "get")
-		if err != nil && out != "" {
-			cli.Error(out)
+		var err error
+		clientVersion, err = external.LatestGithubTag("code-game-project", "go-client")
+		if err != nil {
+			return err
 		}
-		return err
+		clientVersion = strings.TrimPrefix(strings.Join(strings.Split(clientVersion, ".")[:2], "."), "v")
 	}
 
 	majorVersion := strings.Split(clientVersion, ".")[0]
@@ -115,3 +133,148 @@ func installGoLibrary(projectName, cgVersion string) error {
 	cli.Finish()
 	return nil
 }
+
+func newGoServer(projectName string) error {
+	err := createGoServerTemplate(projectName)
+	if err != nil {
+		return err
+	}
+
+	err = installGoServerLibrary(projectName)
+	if err != nil {
+		return err
+	}
+
+	cli.Begin("Cleaning up...")
+
+	if !external.IsInstalled("goimports") {
+		cli.Warn("Failed to add import statements: 'goimports' is not installed!")
+		return nil
+	}
+
+	external.ExecuteInDir(projectName, "goimports", "-w", "main.go")
+	packageDir := strings.ReplaceAll(strings.ReplaceAll(projectName, "_", ""), "-", "")
+	external.ExecuteInDir(projectName, "goimports", "-w", filepath.Join(packageDir, "game.go"))
+
+	out, err := external.ExecuteInDirHidden(projectName, "go", "mod", "tidy")
+	if err != nil {
+		if out != "" {
+			cli.Error(out)
+		}
+		return err
+	}
+
+	cli.Finish()
+
+	return nil
+}
+
+func createGoServerTemplate(projectName string) error {
+	module, err := cli.Input("Project module path:")
+	if err != nil {
+		return err
+	}
+
+	cli.Begin("Creating project template...")
+	out, err := external.ExecuteInDirHidden(projectName, "go", "mod", "init", module)
+	if err != nil {
+		if out != "" {
+			cli.Error(out)
+		}
+		return err
+	}
+
+	cgeVersion, err := external.LatestCGEVersion()
+	if err != nil {
+		return err
+	}
+
+	err = executeGoServerTemplate(goServerMainTemplate, "main.go", projectName, cgeVersion)
+	if err != nil {
+		return err
+	}
+
+	err = executeGoServerTemplate(goServerCGETemplate, "events.cge", projectName, cgeVersion)
+	if err != nil {
+		return err
+	}
+
+	packageName := strings.ReplaceAll(strings.ReplaceAll(projectName, "_", ""), "-", "")
+
+	err = executeGoServerTemplate(goServerGameTemplate, filepath.Join(packageName, "game.go"), projectName, cgeVersion)
+	if err != nil {
+		return err
+	}
+
+	err = executeGoServerTemplate(goServerEventsTemplate, filepath.Join(packageName, "events.go"), projectName, cgeVersion)
+	if err != nil {
+		return err
+	}
+
+	cli.Finish()
+	return nil
+}
+
+func executeGoServerTemplate(templateText, fileName, projectName, cgeVersion string) error {
+	tmpl, err := template.New(fileName).Parse(templateText)
+	if err != nil {
+		return err
+	}
+
+	err = os.MkdirAll(filepath.Join(projectName, filepath.Dir(fileName)), 0755)
+	if err != nil {
+		return err
+	}
+
+	file, err := os.Create(filepath.Join(projectName, fileName))
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
+	type data struct {
+		Name          string
+		PackageName   string
+		SnakeCaseName string
+		CGEVersion    string
+	}
+
+	return tmpl.Execute(file, data{
+		Name:          projectName,
+		PackageName:   strings.ReplaceAll(strings.ReplaceAll(projectName, "_", ""), "-", ""),
+		SnakeCaseName: strings.ReplaceAll(projectName, "-", "_"),
+		CGEVersion:    cgeVersion,
+	})
+}
+
+func installGoServerLibrary(projectName string) error {
+	cli.Begin("Fetching latest server library version...")
+	tag, err := external.LatestGithubTag("code-game-project", "go-server")
+	if err != nil {
+		return err
+	}
+	majorVersion := strings.TrimPrefix(strings.Split(tag, ".")[0], "v")
+
+	path := "github.com/code-game-project/go-server/cg"
+	if majorVersion != "0" && majorVersion != "1" {
+		path = fmt.Sprintf("github.com/code-game-project/go-server/v%s/cg", majorVersion)
+	}
+	cli.Finish()
+
+	cli.Begin("Installing dependencies...")
+
+	out, err := external.ExecuteInDirHidden(projectName, "go", "get", path)
+	if err != nil {
+		cli.Error(out)
+		return err
+	}
+
+	out, err = external.ExecuteInDirHidden(projectName, "go", "get", "github.com/spf13/pflag")
+	if err != nil {
+		cli.Error(out)
+		return err
+	}
+
+	cli.Finish()
+	return nil
+}

commands/templates/main.go.tmpl renamed to commands/templates/go/client/main.go.tmpl

@@ -0,0 +1,3 @@
+name {{.SnakeCaseName}}
+version {{.CGEVersion}}
+

commands/templates/go/server/events.cge.tmpl

@@ -0,0 +1,2 @@
+package {{.PackageName}}
+

commands/templates/go/server/events.go.tmpl

@@ -0,0 +1,31 @@
+package {{.PackageName}}
+
+type Game struct {
+	cg     *cg.Game
+}
+
+func NewGame(cgGame *cg.Game) *Game {
+	game := &Game{
+		cg:     cgGame,
+	}
+	return game
+}
+
+func (g *Game) Run() {
+	for g.cg.Running() {
+		event, ok := g.cg.WaitForNextEvent()
+		if !ok {
+			break
+		}
+		g.handleEvent(event.Player, event.Event)
+	}
+}
+
+func (g *Game) handleEvent(player *cg.Player, event cg.Event) {
+	switch event.Name {
+	default:
+		player.Send(player.Id, cg.EventError, cg.EventErrorData{
+			Message: fmt.Sprintf("unexpected event: %s", event.Name),
+		})
+	}
+}

commands/templates/go/server/game.go.tmpl

@@ -0,0 +1,27 @@
+package main
+
+func main() {
+	var port int
+	pflag.IntVarP(&port, "port", "p", 0, "The network port of the game server.")
+	pflag.Parse()
+
+	if port == 0 {
+		portStr, ok := os.LookupEnv("CG_PORT")
+		if ok {
+			port, _ = strconv.Atoi(portStr)
+		}
+	}
+
+	if port == 0 {
+		port = 80
+	}
+
+	server := cg.NewServer("{{.Name}}", cg.ServerConfig{
+		Port:                    port,
+		CGEFilepath:             "events.cge",
+	})
+
+	server.Run(func(cgGame *cg.Game) {
+	    {{.PackageName}}.NewGame(cgGame).Run()
+	})
+}