《游戏服务端编程实践》9.3.3 商城与交易系统

// file: ch09/economy/shop.go
// tier: L1
// verify: go test ./ch09/economy/

package economy

import (
	"errors"
	"math"
	"sync"
)

var (
	ErrProductExists     = errors.New("shop: product already exists")
	ErrProductNotFound   = errors.New("shop: product not found")
	ErrProductInactive   = errors.New("shop: product inactive")
	ErrPurchaseLimit     = errors.New("shop: purchase limit reached")
	ErrOrderConflict     = errors.New("shop: order id reused with different content")
	ErrTradeExists       = errors.New("trade: id already exists")
	ErrTradeNotFound     = errors.New("trade: not found")
	ErrInvalidTradeState = errors.New("trade: invalid state transition")
	ErrItemNotOwned      = errors.New("trade: seller does not own the item")
)

type Product struct {
	ID             string
	Currency       Currency
	UnitPrice      int64
	LimitPerPlayer int // 0 表示不限购
	Active         bool
}

type Order struct {
	ID        string
	Player    string
	ProductID string
	Amount    int64
}

// Shop 用订单 ID 做幂等键：同一订单重放只返回原订单，不会重复扣款。
type Shop struct {
	mu        sync.Mutex
	products  map[string]Product
	orders    map[string]Order
	purchased map[string]int
}

func NewShop() *Shop {
	return &Shop{
		products:  make(map[string]Product),
		orders:    make(map[string]Order),
		purchased: make(map[string]int),
	}
}

func (s *Shop) AddProduct(p Product) error {
	if p.ID == "" || p.UnitPrice <= 0 || p.LimitPerPlayer < 0 {
		return ErrInvalidEntry
	}
	s.mu.Lock()
	defer s.mu.Unlock()
	if _, ok := s.products[p.ID]; ok {
		return ErrProductExists
	}
	s.products[p.ID] = p
	return nil
}

func (s *Shop) Buy(w *Wallet, orderID, player, productID string) (Order, error) {
	if orderID == "" || player == "" {
		return Order{}, ErrInvalidEntry
	}
	s.mu.Lock()
	defer s.mu.Unlock()
	if old, ok := s.orders[orderID]; ok {
		if old.Player == player && old.ProductID == productID {
			return old, nil
		}
		return Order{}, ErrOrderConflict
	}
	p, ok := s.products[productID]
	if !ok {
		return Order{}, ErrProductNotFound
	}
	if !p.Active {
		return Order{}, ErrProductInactive
	}
	key := player + "\x00" + productID
	if p.LimitPerPlayer > 0 && s.purchased[key] >= p.LimitPerPlayer {
		return Order{}, ErrPurchaseLimit
	}
	if err := w.Debit(p.Currency, p.UnitPrice); err != nil {
		return Order{}, err
	}
	o := Order{ID: orderID, Player: player, ProductID: productID, Amount: p.UnitPrice}
	s.orders[orderID] = o
	s.purchased[key]++
	return o, nil
}

// Inventory 按“玩家 + 物品”计数，用于演示交易托管。
type Inventory struct {
	items map[string]int
}

func NewInventory() *Inventory { return &Inventory{items: make(map[string]int)} }

func invKey(player, item string) string { return player + "\x00" + item }

func (inv *Inventory) Add(player, item string, n int) {
	if n > 0 {
		inv.items[invKey(player, item)] += n
	}
}

func (inv *Inventory) Remove(player, item string, n int) bool {
	k := invKey(player, item)
	if n <= 0 || inv.items[k] < n {
		return false
	}
	inv.items[k] -= n
	return true
}

func (inv *Inventory) Count(player, item string) int { return inv.items[invKey(player, item)] }

type TradeState int

const (
	TradeOpen TradeState = iota
	TradeEscrowed
	TradeCompleted
	TradeCancelled
)

type Trade struct {
	ID       string
	Seller   string
	Buyer    string
	Item     string
	Currency Currency
	Price    int64
	FeeBPS   int64
	State    TradeState
}

type TradeManager struct {
	mu     sync.Mutex
	trades map[string]*Trade
}

func NewTradeManager() *TradeManager { return &TradeManager{trades: make(map[string]*Trade)} }

func bpsFee(amount, bps int64) int64 {
	return amount/10000*bps + (amount%10000)*bps/10000
}

func (t *Trade) total() int64 { return t.Price + bpsFee(t.Price, t.FeeBPS) }

// Open 只登记交易意向，不移动任何资产。
func (m *TradeManager) Open(id, seller, buyer, item string, currency Currency, price, feeBPS int64) (Trade, error) {
	if id == "" || seller == "" || buyer == "" || item == "" || seller == buyer {
		return Trade{}, ErrInvalidEntry
	}
	if price <= 0 || feeBPS < 0 || feeBPS > 10000 {
		return Trade{}, ErrInvalidEntry
	}
	if price > math.MaxInt64-bpsFee(price, feeBPS) {
		return Trade{}, ErrAmountOverflow
	}
	m.mu.Lock()
	defer m.mu.Unlock()
	if _, ok := m.trades[id]; ok {
		return Trade{}, ErrTradeExists
	}
	t := &Trade{ID: id, Seller: seller, Buyer: buyer, Item: item, Currency: currency, Price: price, FeeBPS: feeBPS}
	m.trades[id] = t
	return *t, nil
}

// Escrow 先校验买方余额和卖方物品，再一次性扣款并移走物品。
func (m *TradeManager) Escrow(id string, inv *Inventory, buyer *Wallet) error {
	m.mu.Lock()
	defer m.mu.Unlock()
	t, ok := m.trades[id]
	if !ok {
		return ErrTradeNotFound
	}
	if t.State != TradeOpen {
		return ErrInvalidTradeState
	}
	if buyer.Balance(t.Currency) < t.total() {
		return ErrInsufficientBalance
	}
	if inv.Count(t.Seller, t.Item) < 1 {
		return ErrItemNotOwned
	}
	if err := buyer.Debit(t.Currency, t.total()); err != nil {
		return err
	}
	inv.Remove(t.Seller, t.Item, 1)
	t.State = TradeEscrowed
	return nil
}

// Complete 把托管物品交给买方，货款给卖方，手续费销毁。
func (m *TradeManager) Complete(id string, inv *Inventory, sellerWallet *Wallet) error {
	m.mu.Lock()
	defer m.mu.Unlock()
	t, ok := m.trades[id]
	if !ok {
		return ErrTradeNotFound
	}
	if t.State != TradeEscrowed {
		return ErrInvalidTradeState
	}
	if sellerWallet.Balance(t.Currency) > math.MaxInt64-t.Price {
		return ErrAmountOverflow
	}
	if err := sellerWallet.Credit(t.Currency, t.Price); err != nil {
		return err
	}
	inv.Add(t.Buyer, t.Item, 1)
	t.State = TradeCompleted
	return nil
}

// Cancel 撤销交易：未托管只改状态，已托管则退款并退回物品。
func (m *TradeManager) Cancel(id string, inv *Inventory, buyerWallet *Wallet) error {
	m.mu.Lock()
	defer m.mu.Unlock()
	t, ok := m.trades[id]
	if !ok {
		return ErrTradeNotFound
	}
	switch t.State {
	case TradeOpen:
		t.State = TradeCancelled
		return nil
	case TradeEscrowed:
		if buyerWallet.Balance(t.Currency) > math.MaxInt64-t.total() {
			return ErrAmountOverflow
		}
		if err := buyerWallet.Credit(t.Currency, t.total()); err != nil {
			return err
		}
		inv.Add(t.Seller, t.Item, 1)
		t.State = TradeCancelled
		return nil
	default:
		return ErrInvalidTradeState
	}
}

cd .local/checks/gs-practice-lab && gofmt -l ch09/economy && go vet ./ch09/economy/ && go test ./ch09/economy/ -count=1

ok  	gspractice/ch09/economy	0.xxx s