feat: persist bootstrap characters across sessions

Author: MikelCalvo

internal/accountstore/store.go

@@ -0,0 +1,98 @@
+package accountstore
+
+import (
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/MikelCalvo/go-metin2-server/internal/loginticket"
+)
+
+var (
+	ErrStoreDirRequired = errors.New("account store dir is required")
+	ErrLoginRequired    = errors.New("account login is required")
+	ErrAccountNotFound  = errors.New("account not found")
+)
+
+type Account struct {
+	Login      string                `json:"login"`
+	Characters []loginticket.Character `json:"characters"`
+}
+
+type Store interface {
+	Load(login string) (Account, error)
+	Save(account Account) error
+}
+
+type FileStore struct {
+	dir string
+}
+
+func NewFileStore(dir string) *FileStore {
+	return &FileStore{dir: dir}
+}
+
+func (s *FileStore) Load(login string) (Account, error) {
+	if s.dir == "" {
+		return Account{}, ErrStoreDirRequired
+	}
+	if login == "" {
+		return Account{}, ErrLoginRequired
+	}
+
+	raw, err := os.ReadFile(s.accountPath(login))
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			return Account{}, ErrAccountNotFound
+		}
+		return Account{}, fmt.Errorf("read account: %w", err)
+	}
+
+	var account Account
+	if err := json.Unmarshal(raw, &account); err != nil {
+		return Account{}, fmt.Errorf("decode account: %w", err)
+	}
+	return account, nil
+}
+
+func (s *FileStore) Save(account Account) error {
+	if s.dir == "" {
+		return ErrStoreDirRequired
+	}
+	if account.Login == "" {
+		return ErrLoginRequired
+	}
+	if err := os.MkdirAll(s.dir, 0o755); err != nil {
+		return fmt.Errorf("create account store dir: %w", err)
+	}
+
+	temp, err := os.CreateTemp(s.dir, ".account-*.json")
+	if err != nil {
+		return fmt.Errorf("create account temp file: %w", err)
+	}
+	defer func() {
+		_ = temp.Close()
+		_ = os.Remove(temp.Name())
+	}()
+
+	if err := json.NewEncoder(temp).Encode(account); err != nil {
+		return fmt.Errorf("encode account: %w", err)
+	}
+	if err := temp.Close(); err != nil {
+		return fmt.Errorf("close account temp file: %w", err)
+	}
+	if err := os.Rename(temp.Name(), s.accountPath(account.Login)); err != nil {
+		return fmt.Errorf("commit account file: %w", err)
+	}
+	return nil
+}
+
+func (s *FileStore) accountPath(login string) string {
+	normalized := strings.ToLower(login)
+	filename := hex.EncodeToString([]byte(normalized)) + ".json"
+	return filepath.Join(s.dir, filename)
+}

internal/accountstore/store_test.go

@@ -0,0 +1,53 @@
+package accountstore
+
+import (
+	"errors"
+	"reflect"
+	"testing"
+
+	"github.com/MikelCalvo/go-metin2-server/internal/loginticket"
+)
+
+func TestFileStoreSaveThenLoadRoundTrip(t *testing.T) {
+	store := NewFileStore(t.TempDir())
+	want := Account{
+		Login: "mkmk",
+		Characters: []loginticket.Character{{
+			ID:         1,
+			VID:        0x01020304,
+			Name:       "MkmkWar",
+			Job:        0,
+			RaceNum:    0,
+			Level:      15,
+			ST:         6,
+			HT:         5,
+			DX:         4,
+			IQ:         3,
+			MainPart:   101,
+			HairPart:   201,
+			X:          1000,
+			Y:          2000,
+			Empire:     2,
+			SkillGroup: 1,
+		}},
+	}
+
+	if err := store.Save(want); err != nil {
+		t.Fatalf("save account: %v", err)
+	}
+	got, err := store.Load("mkmk")
+	if err != nil {
+		t.Fatalf("load account: %v", err)
+	}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("unexpected account:\n got: %#v\nwant: %#v", got, want)
+	}
+}
+
+func TestFileStoreLoadReturnsNotFoundForUnknownLogin(t *testing.T) {
+	store := NewFileStore(t.TempDir())
+	_, err := store.Load("ghost")
+	if !errors.Is(err, ErrAccountNotFound) {
+		t.Fatalf("expected ErrAccountNotFound, got %v", err)
+	}
+}

internal/minimal/factory.go

@@ -11,6 +11,7 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/MikelCalvo/go-metin2-server/internal/accountstore"
 	authflow "github.com/MikelCalvo/go-metin2-server/internal/auth"
 	"github.com/MikelCalvo/go-metin2-server/internal/authboot"
 	"github.com/MikelCalvo/go-metin2-server/internal/boot"
@@ -39,13 +40,24 @@ var (
 type loginKeyGenerator func() (uint32, error)
 
 func NewAuthSessionFactory() service.SessionFactory {
-	return newAuthSessionFactory(loginticket.NewFileStore(defaultTicketStoreDir()), randomLoginKey)
+	return newAuthSessionFactoryWithAccountStore(
+		loginticket.NewFileStore(defaultTicketStoreDir()),
+		accountstore.NewFileStore(defaultAccountStoreDir()),
+		randomLoginKey,
+	)
 }
 
 func newAuthSessionFactory(store loginticket.Store, generateLoginKey loginKeyGenerator) service.SessionFactory {
+	return newAuthSessionFactoryWithAccountStore(store, accountstore.NewFileStore(defaultAccountStoreDir()), generateLoginKey)
+}
+
+func newAuthSessionFactoryWithAccountStore(store loginticket.Store, accounts accountstore.Store, generateLoginKey loginKeyGenerator) service.SessionFactory {
 	if store == nil {
 		store = loginticket.NewFileStore(defaultTicketStoreDir())
 	}
+	if accounts == nil {
+		accounts = accountstore.NewFileStore(defaultAccountStoreDir())
+	}
 	if generateLoginKey == nil {
 		generateLoginKey = randomLoginKey
 	}
@@ -62,7 +74,11 @@ func newAuthSessionFactory(store loginticket.Store, generateLoginKey loginKeyGen
 						return authflow.Result{Accepted: false, FailureStatus: "WRONGPWD"}
 					}
 
-					loginKey, ok := issueLoginTicket(store, packet.Login, generateLoginKey)
+					characters, ok := loadOrCreateAccountCharacters(accounts, packet.Login)
+					if !ok {
+						return authflow.Result{Accepted: false, FailureStatus: "FAILED"}
+					}
+					loginKey, ok := issueLoginTicket(store, packet.Login, characters, generateLoginKey)
 					if !ok {
 						return authflow.Result{Accepted: false, FailureStatus: "FAILED"}
 					}
@@ -75,10 +91,18 @@ func newAuthSessionFactory(store loginticket.Store, generateLoginKey loginKeyGen
 }
 
 func NewGameSessionFactory(cfg config.Service) (service.SessionFactory, error) {
-	return newGameSessionFactory(cfg, loginticket.NewFileStore(defaultTicketStoreDir()))
+	return newGameSessionFactoryWithAccountStore(
+		cfg,
+		loginticket.NewFileStore(defaultTicketStoreDir()),
+		accountstore.NewFileStore(defaultAccountStoreDir()),
+	)
 }
 
 func newGameSessionFactory(cfg config.Service, store loginticket.Store) (service.SessionFactory, error) {
+	return newGameSessionFactoryWithAccountStore(cfg, store, accountstore.NewFileStore(defaultAccountStoreDir()))
+}
+
+func newGameSessionFactoryWithAccountStore(cfg config.Service, store loginticket.Store, accounts accountstore.Store) (service.SessionFactory, error) {
 	advertisedPort, err := parsePort(cfg.LegacyAddr)
 	if err != nil {
 		return nil, err
@@ -92,6 +116,9 @@ func newGameSessionFactory(cfg config.Service, store loginticket.Store) (service
 	if store == nil {
 		store = loginticket.NewFileStore(defaultTicketStoreDir())
 	}
+	if accounts == nil {
+		accounts = accountstore.NewFileStore(defaultAccountStoreDir())
+	}
 
 	return func() service.SessionFlow {
 		var sessionTicket loginticket.Ticket
@@ -127,6 +154,9 @@ func newGameSessionFactory(cfg config.Service, store loginticket.Store) (service
 					if !ok {
 						return worldentry.CreateResult{Accepted: false, FailureType: failureType}
 					}
+					if !saveAccountCharacters(accounts, sessionTicket.Login, sessionTicket.Characters) {
+						return worldentry.CreateResult{Accepted: false, FailureType: 0}
+					}
 					return worldentry.CreateResult{
 						Accepted: true,
 						Player:   ticketPlayerCreateSuccessPacket(created, packet.Index, advertisedAddr, advertisedPort),
@@ -190,7 +220,10 @@ func defaultKeyComplete() control.KeyCompletePacket {
 	}
 }
 
-func issueLoginTicket(store loginticket.Store, login string, generateLoginKey loginKeyGenerator) (uint32, bool) {
+func issueLoginTicket(store loginticket.Store, login string, characters []loginticket.Character, generateLoginKey loginKeyGenerator) (uint32, bool) {
+	if len(characters) == 0 {
+		characters = stubCharacters()
+	}
 	for range 8 {
 		loginKey, err := generateLoginKey()
 		if err != nil || loginKey == 0 {
@@ -200,7 +233,7 @@ func issueLoginTicket(store loginticket.Store, login string, generateLoginKey lo
 		err = store.Issue(loginticket.Ticket{
 			Login:      login,
 			LoginKey:   loginKey,
-			Characters: stubCharacters(),
+			Characters: cloneCharacters(characters),
 		})
 		if err == nil {
 			return loginKey, true
@@ -214,6 +247,40 @@ func issueLoginTicket(store loginticket.Store, login string, generateLoginKey lo
 	return 0, false
 }
 
+func loadOrCreateAccountCharacters(store accountstore.Store, login string) ([]loginticket.Character, bool) {
+	if store == nil {
+		return cloneCharacters(stubCharacters()), true
+	}
+	account, err := store.Load(login)
+	if err == nil {
+		return cloneCharacters(account.Characters), true
+	}
+	if !errors.Is(err, accountstore.ErrAccountNotFound) {
+		return nil, false
+	}
+	characters := cloneCharacters(stubCharacters())
+	if err := store.Save(accountstore.Account{Login: login, Characters: characters}); err != nil {
+		return nil, false
+	}
+	return cloneCharacters(characters), true
+}
+
+func saveAccountCharacters(store accountstore.Store, login string, characters []loginticket.Character) bool {
+	if store == nil {
+		return true
+	}
+	return store.Save(accountstore.Account{Login: login, Characters: cloneCharacters(characters)}) == nil
+}
+
+func cloneCharacters(characters []loginticket.Character) []loginticket.Character {
+	if len(characters) == 0 {
+		return nil
+	}
+	cloned := make([]loginticket.Character, len(characters))
+	copy(cloned, characters)
+	return cloned
+}
+
 func randomLoginKey() (uint32, error) {
 	var raw [4]byte
 	for range 8 {
@@ -549,6 +616,10 @@ func defaultTicketStoreDir() string {
 	return filepath.Join(os.TempDir(), "go-metin2-server-login-tickets")
 }
 
+func defaultAccountStoreDir() string {
+	return filepath.Join(os.TempDir(), "go-metin2-server-accounts")
+}
+
 func sequentialBytes32(start byte) [32]byte {
 	var out [32]byte
 	for i := range out {