game_sync/gamesrv/slotspkg/slots/entity/reset.go

package entity

import (
	"github.com/tomas-qstarrs/boost/randx"
	"mongo.games.com/game/gamesrv/slotspkg/internal/generic/key"
)

func (e *Entity) ResetFormations() {
	for index, formationSeqDesc := range e.NodeDesc.FormationSeqsDesc {
		e.CursorNode().Formations[index].ID = formationSeqDesc.ID
		e.CursorNode().Formations[index].SeqID = formationSeqDesc.SeqID
	}
}

func (e *Entity) ResetBaseBet() {
	if !e.CursorNode().NoBase {
		if e.CursorNode().GetType() == key.BaseSpin {
			e.CursorNode().BaseBet = e.ActBet()
		} else {
			e.CursorNode().BaseBet = e.ParentNode().BaseBet
		}
	} else {
		if e.CursorNode().GetType() == key.FreeSpin && e.CursorNode().GetProgressValue() == 0 {
			e.CursorNode().BaseBet = e.ActBet()
		}
	}
}

func (e *Entity) ResetNextBaseBet() {
	if !e.NextNode().NoBase {
		if e.NextNode().GetType() == key.BaseSpin {
			e.NextNode().BaseBet = e.ActBet()
		} else {
			e.NextNode().BaseBet = e.GetNode(e.NextNode().Parent).BaseBet
		}
	} else {
		if e.NextNode().GetType() == key.FreeSpin && e.NextNode().GetProgressValue() == 0 {
			e.NextNode().BaseBet = e.ActBet()
		}
	}
}

// SelectNextClass gets map class for machine
func (e *Entity) SelectNextClass() {
	//s := e.Session
	//p := e.Player

	id := e.NodeTree.Act.ClassId
	//logx.Error("================= SelectClass ==============", id)

	///////////////

	rtpModes := e.NodeDesc.GetThemeRTPModes()
	if r, ok := rtpModes[id]; ok {
		var weight []int64
		var ids []int64
		for _, typeWeight := range r.TypeWeight {
			ids = append(ids, typeWeight.ID)
			weight = append(weight, typeWeight.Weight)
		}
		id3 := randx.RandWeight(e.Randx(), weight)
		class := ids[id3]
		e.NextNode().Class = class
	} else if len(rtpModes) > 0 {
		var weight []int64
		for _, typeWeight := range rtpModes[0].TypeWeight {
			weight = append(weight, typeWeight.Weight)
		}
		e.NextNode().Class = rtpModes[0].TypeWeight[int64(randx.RandWeight(e.Randx(), weight))].ID
	} else {
		e.NextNode().Class = 0
	}
}

// SelectClass gets map class for machine
func (e *Entity) SelectClass() {
	//s := e.Session
	//p := e.Player

	//todo
	id := e.Randx().Int63n(3) + 1
	id = 2
	//logx.Error("================= SelectClass ==============", id)

	///////////////

	rtpModes := e.NodeDesc.GetThemeRTPModes()
	if r, ok := rtpModes[id]; ok {
		var weight []int64
		var ids []int64
		for _, typeWeight := range r.TypeWeight {
			ids = append(ids, typeWeight.ID)
			weight = append(weight, typeWeight.Weight)
		}
		id3 := randx.RandWeight(e.Randx(), weight)
		class := ids[id3]
		e.CursorNode().Class = class
	} else if len(rtpModes) > 0 {
		var weight []int64
		for _, typeWeight := range rtpModes[0].TypeWeight {
			weight = append(weight, typeWeight.Weight)
		}
		e.CursorNode().Class = rtpModes[0].TypeWeight[int64(randx.RandWeight(e.Randx(), weight))].ID
	} else {
		e.CursorNode().Class = 0
	}
}

// ResetNextClass must be before origin formations
func (e *Entity) ResetNextClass() {
	if e.NextNode().GetType() == key.BaseSpin && e.NodeTree.Act.PlayMode == key.PlayModeClass {
		if !e.CheatNextClass() {
			e.SelectNextClass()
		}
	} else {
		e.NextNode().Class = e.ParentNode().Class
	}

	e.NodeDesc.Class = e.NextNode().Class
}

// ResetClass must be before origin formations
func (e *Entity) ResetClass() {
	if e.CursorNode().GetType() == key.BaseSpin && e.NodeTree.Act.PlayMode == key.PlayModeClass {
		if !e.CheatClass() {
			e.SelectClass()
		}
	} else {
		e.CursorNode().Class = e.ParentNode().Class
	}

	e.NodeDesc.Class = e.CursorNode().Class
}

func (e *Entity) ResetSingleBet() {
	if !e.CursorNode().NoBase {
		if e.CursorNode().ForceBet > 0 {
			e.CursorNode().SingleBet = e.ParentNode().SingleBet * e.CursorNode().ForceBet / e.CursorNode().BaseBet
		} else if e.CursorNode().Type == key.BaseSpin {
			e.CursorNode().SingleBet = e.CursorNode().BaseBet / e.getLineCount()
		} else {
			e.CursorNode().SingleBet = e.ParentNode().SingleBet
		}
	} else {
		if e.CursorNode().GetType() == key.FreeSpin && e.CursorNode().GetProgressValue() == 0 {
			e.CursorNode().SingleBet = e.CursorNode().BaseBet / e.getLineCount()
		}
	}
}

// ResetBet using in client display & big win
func (e *Entity) ResetBet() {
	if e.CursorNode().Bet > 0 {
		return
	}
	if !e.CursorNode().NoBase {
		if e.CursorNode().ForceBet > 0 {
			e.CursorNode().Bet = e.CursorNode().ForceBet
		} else if e.CursorNode().Type == key.BaseSpin {
			e.CursorNode().Bet = e.CursorNode().BaseBet
		} else {
			e.CursorNode().Bet = e.ParentNode().Bet
		}
	} else {
		if e.CursorNode().GetType() == key.FreeSpin && e.CursorNode().GetProgressValue() == 0 {
			e.CursorNode().Bet = e.CursorNode().BaseBet
		}
	}
}

func (e *Entity) CheatClass() bool {
	v, ok := e.Data[key.MachineClass]
	if !ok {
		return false
	}
	class := v.(int64)
	if class == 0 {
		return false
	}
	e.CursorNode().Class = class
	delete(e.Data, key.MachineClass)
	return true
}
func (e *Entity) CheatNextClass() bool {
	v, ok := e.Data[key.MachineClass]
	if !ok {
		return false
	}
	class := v.(int64)
	if class == 0 {
		return false
	}
	e.NextNode().Class = class
	delete(e.Data, key.MachineClass)
	return true
}