game_sync/gamesrv/slotspkg/internal/module/player/method.go

package player

import (
	"fmt"
	"github.com/tomas-qstarrs/boost/dogfish"
	"github.com/tomas-qstarrs/boost/timex"
	"mongo.games.com/game/gamesrv/base"
	"mongo.games.com/game/gamesrv/slotspkg/internal/generic/errors"
	"mongo.games.com/game/gamesrv/slotspkg/internal/generic/global"
	"mongo.games.com/game/gamesrv/slotspkg/internal/generic/key"
	"mongo.games.com/game/gamesrv/slotspkg/internal/module/shared"
)

// Get gets player from session
func Get(s *base.SlotsSession) *Player {
	if s == nil {
		return nil
	}
	v := s.Value(key.SessionPlayer)
	if v == nil {
		return nil
	}
	return v.(*Player)
}

func Set(s *base.SlotsSession, p *Player) {
	s.Set(key.SessionPlayer, p)
}

func PushPlayer(s *base.SlotsSession) map[string]string {
	p := Get(s)

	Set(s, p)

	hash, err := p.Dump()
	if err != nil {
		panic(err)
	}

	return hash
}
func PullPlayer(s *base.SlotsSession, hash map[string]string) *Player {
	p := Get(s)
	if p == nil {
		//hash := db.PullPlayer(s.UID())

		// Create a new player from hash strings
		p = &Player{}
		err := p.Load(p, hash)
		if err != nil {
			panic(err)
		}

		Set(s, p)

		return p
	}

	if s.Bool(key.SessionReloadPlayer) {
		s.Set(key.SessionReloadPlayer, false)
		//hash := db.PullPlayer(s.UID())

		// Reload old player from hash strings
		err := p.Load(p, hash)
		if err != nil {
			panic(err)
		}

		return p
	}

	return p
}
func Init(s *base.SlotsSession) {
	p := Get(s)
	if p == nil {
		panic(errors.UIDInvalid.Error())
	}

	p.Init(s)
}

func (p *Player) Init(s *base.SlotsSession) {
	if p.UID.Get() == 0 {
		p.handleCreate(s)
	}

	p.handleLogin(s)

	CoinCenter.Sync(s)

}

func (p *Player) handleCreate(s *base.SlotsSession) {
	uid := s.UID()
	if uid == 0 {
		panic(errors.UIDInvalid.Error())
	}

	p.UID.Set(int64(uid))
	p.Char.CreateTime.Set(timex.Now().Unix())
}
func (p *Player) handleLogin(s *base.SlotsSession) {
	p.updateCli(s)
	p.updateChar(s)
	p.updateOthers(s)
}

func (p *Player) updateCli(s *base.SlotsSession) {
	sessionContext := s.Value(key.SessionContext).(*shared.SessionContext)
	// Cli
	p.Cli.Ops.Set(sessionContext.Ops)
	p.Cli.IsSimulator.Set(sessionContext.IsSimulator)
	p.Cli.IsSimulator.Set(sessionContext.IsSimulator)
	p.Cli.Ip.Set(sessionContext.Ip)

	p.Cli.PlayerName.Set(sessionContext.PlayerName)
}

func (p *Player) updateChar(s *base.SlotsSession) {
	DataSet(s).Update()

	p.Char.LastLoginTime.Set(p.Char.LoginTime.Get())
	p.Char.LoginTime.Set(timex.Now().Unix())
	p.Char.LastProcessTime.Set(p.Char.ProcessTime.Get())
	p.Char.ProcessTime.Set(global.ProcessTime)
	if !timex.IsSameDay(p.Char.LoginTime.Get(), p.Char.LastLoginTime.Get()) {
		p.Char.ActiveDays.Set(p.Char.ActiveDays.Get() + 1)
	}

	var category string
	if p.Char.Group.Get() == "" {
		category = p.Char.BranchName.Get()
	} else {
		category = fmt.Sprintf("%s_%s", p.Char.BranchName.Get(), p.Char.Group.Get())
	}
	p.Char.Category.Set(category)
	DataSet(s).Update()
}

func (p *Player) updateOthers(s *base.SlotsSession) {
	if !timex.IsSameDay(p.Char.LoginTime.Get(), p.Char.LastLoginTime.Get()) {
		p.Agg.SlotsDailyBet.Set(0)
		p.Agg.SlotsDailyWin.Set(0)
		p.Agg.SlotsDailySpins.Set(0)
	}
}

func (p *Player) GetTheme(theme string) *dogfish.JSON {
	return (*dogfish.JSON)(p.Field("Slots", theme))
}

func GetChar(s *base.SlotsSession) *shared.Char {
	p := Get(s)
	if p == nil {
		panic(errors.UIDInvalid.Error())
	}

	return p.GetChar()
}

func (p *Player) GetChar() *shared.Char {
	return &shared.Char{
		Category:        p.Char.Category.Get(),
		Group:           p.Char.Group.Get(),
		GroupBatch:      p.Char.GroupBatch.Get(),
		CreateTime:      p.Char.CreateTime.Get(),
		LoginTime:       p.Char.LoginTime.Get(),
		LastLoginTime:   p.Char.LastLoginTime.Get(),
		ProcessTime:     p.Char.ProcessTime.Get(),
		LastProcessTime: p.Char.LastProcessTime.Get(),
		ActiveDays:      p.Char.ActiveDays.Get(),
		Branch:          p.Char.Branch.Get(),
		BranchName:      p.Char.BranchName.Get(),
	}
}

func GetBook(s *base.SlotsSession) *shared.Book {
	p := Get(s)
	if p == nil {
		panic(errors.UIDInvalid.Error())
	}

	return p.GetBook()
}

func (p *Player) GetBook() *shared.Book {
	return &shared.Book{
		Coin: p.Book.Coin.Get(),
	}
}

func (p *Player) GetAgg() *shared.Agg {
	return &shared.Agg{
		SlotsDailySpins: p.Agg.SlotsDailySpins.Get(),
		SlotsDailyWin:   p.Agg.SlotsDailyWin.Get(),
		SlotsDailyBet:   p.Agg.SlotsDailyBet.Get(),
		PersonalPool:    p.Agg.PersonalPool.Get(),
	}
}

func (p *Player) Coin() int64 {
	return p.Book.Coin.Get()
}

func CategoryName(s *base.SlotsSession) string {
	p := Get(s)
	if p == nil {
		return key.Base
	}
	return p.CategoryName()
}

func (p *Player) CategoryName() string {
	return p.Char.Category.Get()
}

func BetWin(s *base.SlotsSession, betCoin DecCoin, winCoin IncCoin) {
	p := Get(s)
	if p == nil {
		panic(errors.UIDInvalid.Error())
	}
	p.BetWin(s, betCoin, winCoin)
}

func (p *Player) BetWin(s *base.SlotsSession, betCoin DecCoin, winCoin IncCoin) {
	if betCoin.GetCoin() > 0 {
		//总统计
		p.Agg.BetSum.Set(p.Agg.BetSum.Get() + betCoin.GetCoin())
		p.Agg.BetTimes.Set(p.Agg.BetTimes.Get() + 1)
		//p.Agg.PersonalPool.Set(p.Agg.PersonalPool.Get() + int64(float64(betCoin.GetCoin())*0.96))

		//每日
		p.Agg.BetTimesDaily.Set(p.Agg.BetTimesDaily.Get() + 1)
		p.Agg.BetSumDaily.Set(p.Agg.BetSumDaily.Get() + betCoin.GetCoin())
	}
	if winCoin.GetCoin() > 0 {
		//总统计
		p.Agg.WinSum.Set(p.Agg.WinSum.Get() + winCoin.GetCoin())
		//p.Agg.PersonalPool.Set(p.Agg.PersonalPool.Get() - winCoin.GetCoin())
		//每日
		p.Agg.WinSumDaily.Set(p.Agg.WinSumDaily.Get() + winCoin.GetCoin())
	}
}