handle player's last access time

server/src/application/application.go

@@ -4,13 +4,15 @@ import (
 	"sirlab.de/go/knyt/applicationConfig"
 	"sirlab.de/go/knyt/game"
 	"sirlab.de/go/knyt/user"
+	"time"
 )
 
 func NewApplication(config applicationConfig.ApplicationConfig) (*Application, error) {
 	app := Application{
-		config: config,
+		config:      config,
-		users:  make(map[string]*user.User),
+		users:       make(map[string]*user.User),
-		games:  make(map[string]*game.Game),
+		games:       make(map[string]*game.Game),
+		playerATime: make(map[string]time.Time),
 	}
 
 	if err := app.loadUsers(); err != nil {

server/src/application/playerATime.go

@@ -0,0 +1,16 @@
+package application
+
+import (
+	"fmt"
+	"sirlab.de/go/knyt/user"
+	"time"
+)
+
+func (app *Application) updatePlayerATime(usr *user.User) {
+	usrId := usr.GetId()
+
+	app.mu.Lock()
+	fmt.Printf("updatePlayerATime \"%v\"\n", app.playerATime[usrId])
+	app.playerATime[usrId] = time.Now()
+	app.mu.Unlock()
+}

server/src/application/struct.go

@@ -5,11 +5,13 @@ import (
 	"sirlab.de/go/knyt/game"
 	"sirlab.de/go/knyt/user"
 	"sync"
+	"time"
 )
 
 type Application struct {
-	mu     sync.Mutex
+	mu          sync.Mutex
-	config applicationConfig.ApplicationConfig
+	config      applicationConfig.ApplicationConfig
-	users  map[string]*user.User
+	users       map[string]*user.User
-	games  map[string]*game.Game
+	games       map[string]*game.Game
+	playerATime map[string]time.Time
 }

server/src/application/syncHandler.go

@@ -21,7 +21,7 @@ func (app *Application) SyncHandler(usr *user.User, w http.ResponseWriter, r *ht
 		return
 	}
 
-	gm.UpdatePlayerTimestamp(usr)
+	app.updatePlayerATime(usr)
 
 	eng := gm.GetEngine()
 	eng.SyncHandler(w, r)

server/src/game/game.go

@@ -5,8 +5,6 @@ import (
 	"fmt"
 	"os"
 	"sirlab.de/go/knyt/engine"
-	"sirlab.de/go/knyt/user"
-	"time"
 )
 
 func NewGameFromFile(id, fileName string) (*Game, error) {
@@ -20,10 +18,9 @@ func NewGameFromFile(id, fileName string) (*Game, error) {
 		return nil, fmt.Errorf("%s: %v\n", fileName, err)
 	} else {
 		gm := Game{
-			id:              id,
+			id:   id,
-			name:            gmJson.Name,
+			name: gmJson.Name,
-			eng:             engine.NewEngine(id),
+			eng:  engine.NewEngine(id),
-			playerTimestamp: make(map[string]time.Time),
 		}
 
 		go gm.eng.Run()
@@ -33,36 +30,42 @@ func NewGameFromFile(id, fileName string) (*Game, error) {
 }
 
 func (gm *Game) GetId() string {
+	gm.mu.Lock()
+	defer gm.mu.Unlock()
+
 	return gm.id
 }
 
+func (gm *Game) GetName() string {
+	gm.mu.Lock()
+	defer gm.mu.Unlock()
+
+	return gm.name
+}
+
 func (gm *Game) GetEngine() *engine.Engine {
+	gm.mu.Lock()
+	defer gm.mu.Unlock()
+
 	return gm.eng
 }
 
-func (gm *Game) UpdatePlayerTimestamp(usr *user.User) {
+// func (gm *Game) GetActivePlayers() []string {
-	gm.mu.Lock()
+// 	gm.mu.Lock()
-	defer gm.mu.Unlock()
+// 	defer gm.mu.Unlock()
-
+//
-	gm.playerTimestamp[usr.GetId()] = time.Now()
+// 	players := make([]string, 0)
-}
+//
-
+// 	now := time.Now()
-func (gm *Game) GetActivePlayers() []string {
+// 	for usrId, timestamp := range gm.playerTimestamp {
-	gm.mu.Lock()
+// 		elapsed := now.Sub(timestamp)
-	defer gm.mu.Unlock()
+//
-
+// 		fmt.Printf("%s: %.0f\n", usrId, elapsed.Seconds())
-	players := make([]string, 0)
+//
-
+// 		if elapsed.Seconds() < 30.0 {
-	now := time.Now()
+// 			players = append(players, usrId)
-	for usrId, timestamp := range gm.playerTimestamp {
+// 		}
-		elapsed := now.Sub(timestamp)
+// 	}
-
+//
-		fmt.Printf("%s: %.0f\n", usrId, elapsed.Seconds())
+// 	return players
-
+// }
-		if elapsed.Seconds() < 30.0 {
-			players = append(players, usrId)
-		}
-	}
-
-	return players
-}

server/src/game/struct.go

@@ -3,15 +3,13 @@ package game
 import (
 	"sirlab.de/go/knyt/engine"
 	"sync"
-	"time"
 )
 
 type Game struct {
-	mu              sync.Mutex
+	mu   sync.Mutex
-	id              string
+	id   string
-	name            string
+	name string
-	eng             *engine.Engine
+	eng  *engine.Engine
-	playerTimestamp map[string]time.Time
 }
 
 type GameJson struct {