slotopol

Documentation

Index

• Variables
• func CalcStat(ctx context.Context, mrtp float64) float64
• func EldoradoSpawn(bet float64, spins int) (any, float64)
• func ExpEldorado()
• func ExpMonopoly()
• func MonopolySpawn(bet float64) (any, float64)
• type Game
  • func NewGame() *Game
  • func (g *Game) Clone() slot.SlotGame
  • func (g *Game) Cost() (float64, bool)
  • 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, fund, mrtp float64)
  • func (g *Game) Spin(mrtp float64)
• type MonCell
• type WinElSeg
• type WinMonCell

Variables

var BetLines = slot.BetLinesMgj

Bet lines

var Eldorado = []float64{
	1000,
	10,
	25,
	100,
	10,
	50,
	300,
	10,
	50,
	200,
	10,
	25,
	100,
	25,
	10,
	100,
	10,
	50,
	10,
	25,
}

Average gain = 106

var Emje float64 // Eldorado game 1 spin calculated expectation

var Emjm float64 // Monopoly game calculated expectation

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

var JackMap = slot.ReadMap[float64](jack)

var LineBonus = [13][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, 0},
	{0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0},
	{0, 0, 0, 0, mje9},
	{0, 0, 0, 0, mjm},
}

Lined bonus games

var LinePay = [13][5]float64{
	{},
	{0, 2, 5, 15, 100},
	{0, 2, 5, 15, 100},
	{0, 0, 5, 15, 100},
	{0, 0, 5, 15, 100},
	{0, 0, 5, 15, 100},
	{0, 0, 5, 15, 100},
	{0, 0, 5, 15, 100},
	{0, 2, 5, 15, 100},
	{0, 2, 5, 15, 100},
	{0, 10, 100, 2000, 10000},
	{},
	{},
}

Lined payment.

var Monopoly = []MonCell{
	{5, 0, false},
	{15, 0, false},
	{15, 0, false},
	{30, 0, false},
	{30, 0, false},
	{10, 0, true},
	{0, 0, false},
	{0, 1, false},
	{50, 0, false},
	{50, 0, false},
	{0, 0, false},
	{20, 0, true},
	{0, 4, false},
	{80, 0, false},
	{80, 0, false},
	{30, 0, true},
	{0, 7, false},
	{120, 0, false},
	{120, 0, false},
	{200, 0, false},
}

count = 279936, sum = 80231330, avr = 286.60597422268, zerocount = 1, p(zero) = 0.00035722450845908% variance = 15529.19650266, sigma = 124.61619679103, limits = 161.98977743165...411.22217101371

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

var ScatPay = [5]float64{0, 5, 8, 20, 1000} // 1 dollar

Scatters payment.

Functions

func CalcStat

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

func EldoradoSpawn

func EldoradoSpawn(bet float64, spins int) (any, float64)

func ExpEldorado

func ExpEldorado()

Eldorado expectation.

func ExpMonopoly

func ExpMonopoly()

func MonopolySpawn

func MonopolySpawn(bet float64) (any, float64)

Types

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) Cost

func (g *Game) Cost() (float64, bool)

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, fund, mrtp float64)

func (*Game) Spin

func (g *Game) Spin(mrtp float64)

type MonCell

type MonCell struct {
	Mult float64 `json:"mult" yaml:"mult" xml:"mult,attr"` // bet multiplier
	Jump int     `json:"jump" yaml:"jump" xml:"jump,attr"` // jump position, or 0 if no jump
	Dice bool    `json:"dice" yaml:"dice" xml:"dice,attr"` // is here multiply on dice value
}

type WinElSeg

type WinElSeg struct {
	Pos  int     `json:"pos" yaml:"pos" xml:"pos,attr"`    // segment number, starts from 1
	Pay  float64 `json:"pay" yaml:"pay" xml:"pay,attr"`    // pay by this segment
	Mult float64 `json:"mult" yaml:"mult" xml:"mult,attr"` // bet multiplier
}

type WinMonCell

type WinMonCell struct {
	MonCell `yaml:",inline"`
	Pos     int     `json:"pos" yaml:"pos" xml:"pos,attr"` // cell number, starts from 1
	Pay     float64 `json:"pay" yaml:"pay" xml:"pay,attr"` // pay by this cell
}