aztecgold

Documentation

Index

• Variables
• func AztecPyramidSpawn(bet float64) (any, float64)
• func CalcStat(ctx context.Context, mrtp float64) float64
• func ExpBonus()
• func ScatNum(scr *slot.Screen5x3) (n slot.Pos)
• func ScatPos(scr *slot.Screen5x3) (l slot.Linex)
• type Bonus
• type Cell
• type Game
  • func NewGame() *Game
  • func (g *Game) Clone() slot.SlotGame
  • func (g *Game) ScanLined(wins *slot.Wins)
  • func (g *Game) ScanScatters(wins *slot.Wins)
  • func (g *Game) Scanner(wins *slot.Wins)
  • func (g *Game) SetSel(sel int) error
  • func (g *Game) Spawn(wins slot.Wins)
  • func (g *Game) Spin(mrtp float64)
• type Pyramid
• type Row

Variables

var (
	Epyr  float64 // Expectation of pyramid choose by 4 tries
	Eroom float64 // Expectation of room episode
	Ebon  float64 // Expectation of whole bonus game
)

var BetLines = slot.BetLinesMgj

Bet lines

var Info = game.GameInfo{
	Aliases: []game.GameAlias{
		{Prov: "Megajack", Name: "Aztec Gold"},
	},
	GP: game.GPsel |
		game.GPfgno |
		game.GPscat |
		game.GPrwild,
	SX:  5,
	SY:  3,
	SN:  len(LinePay),
	LN:  len(BetLines),
	BN:  1,
	RTP: game.MakeRtpList(ReelsMap),
}

var Jackpot = [12][5]int{
	{0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0},
	{0, 0, 0, 0, jid},
	{0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0},
}

Jackpot win combinations.

var LinePay = [12][5]float64{
	{0, 0, 5, 10, 100},
	{0, 0, 5, 10, 100},
	{0, 0, 5, 10, 100},
	{0, 0, 5, 10, 100},
	{0, 0, 10, 20, 100},
	{0, 0, 20, 100, 500},
	{0, 0, 20, 100, 750},
	{0, 0, 20, 100, 1000},
	{0, 2, 25, 200, 10000},
	{},
	{},
	{},
}

Lined payment.

var ReelsMap = slot.ReadMap[*slot.Reels5x](reels)

var Room = [5][]Cell{
	{
		{10, 1},
		{11, 1},
		{12, 2},
		{13, 2},
		{14, 3},
		{15, 3},
		{16, 4},
		{10, 1},
		{11, 1},
		{12, 2},
		{13, 2},
		{14, 3},
		{15, 3},
		{10, 1},
		{11, 1},
		{12, 2},
		{13, 2},
		{14, 3},
		{10, 1},
		{11, 1},
		{12, 2},
		{13, 2},
		{0, 14},
	},
	{
		{15, 5},
		{16, 5},
		{17, 6},
		{18, 6},
		{19, 7},
		{20, 8},
		{21, 8},
		{15, 5},
		{16, 5},
		{17, 6},
		{18, 6},
		{19, 7},
		{20, 8},
		{15, 5},
		{16, 5},
		{17, 6},
		{18, 6},
		{19, 7},
		{15, 5},
		{16, 5},
		{17, 6},
		{18, 6},
		{0, 14},
	},
	{
		{20, 9},
		{21, 9},
		{22, 10},
		{23, 10},
		{24, 11},
		{25, 11},
		{26, 12},
		{20, 9},
		{21, 9},
		{22, 10},
		{23, 10},
		{24, 11},
		{25, 11},
		{20, 9},
		{21, 9},
		{22, 10},
		{23, 10},
		{24, 11},
		{20, 9},
		{21, 9},
		{22, 10},
		{23, 10},
		{0, 14},
	},
	{
		{50, 15},
		{50, 15},
		{100, 16},
		{0, 13},
		{0, 13},
		{0, 13},
		{0, 13},
		{0, 13},
		{0, 13},
		{0, 13},
		{0, 13},
		{0, 13},
		{0, 18},
	},
	{
		{250, 17},
		{0, 13},
		{0, 13},
		{0, 13},
		{0, 13},
		{0, 13},
		{0, 13},
		{0, 13},
		{0, 13},
		{0, 13},
		{0, 13},
		{0, 13},
		{0, 13},
		{0, 13},
		{0, 13},
		{0, 13},
		{0, 13},
		{0, 13},
		{0, 13},
	},
}

var ScatPay = [5]float64{0, 0, 2, 10, 50} // 10 scatter

Scatters payment.

Functions

func AztecPyramidSpawn

func AztecPyramidSpawn(bet float64) (any, float64)

func CalcStat

func CalcStat(ctx context.Context, mrtp float64) float64

func ExpBonus

func ExpBonus()

func ScatNum

func ScatNum(scr *slot.Screen5x3) (n slot.Pos)

func ScatPos

func ScatPos(scr *slot.Screen5x3) (l slot.Linex)

Types

type Bonus

type Bonus struct {
	Strike [att]Pyramid `json:"strike" yaml:"strike" xml:"strike"`
	Room   [5]Row       `json:"room" yaml:"room" xml:"room>row"`
}

type Cell

type Cell struct {
	Mult float64 `json:"mult" yaml:"mult" xml:"mult,attr"`
	Sym  byte    `json:"sym" yaml:"sym" xml:"sym,attr"`
}

type Game

type Game struct {
	slot.Slotx[slot.Screen5x3] `yaml:",inline"`
}

func NewGame

func NewGame() *Game

func (*Game) Clone

func (g *Game) Clone() slot.SlotGame

func (*Game) ScanLined

func (g *Game) ScanLined(wins *slot.Wins)

Lined symbols calculation.

func (*Game) ScanScatters

func (g *Game) ScanScatters(wins *slot.Wins)

Scatters calculation.

func (*Game) Scanner

func (g *Game) Scanner(wins *slot.Wins)

func (*Game) SetSel

func (g *Game) SetSel(sel int) error

func (*Game) Spawn

func (g *Game) Spawn(wins slot.Wins)

func (*Game) Spin

func (g *Game) Spin(mrtp float64)

type Pyramid

type Pyramid struct {
	Mult float64 `json:"mult" yaml:"mult" xml:"mult,attr"`
	Type byte    `json:"type" yaml:"type" xml:"type,attr"`
}

type Row

type Row struct {
	Sel  Cell    `json:"sel" yaml:"sel" xml:"sel"`
	Next [4]Cell `json:"next" yaml:"next" xml:"next>cell"`
}