add sugarrush plugin

gamesrv/slotspkg/internal/exported/excel2go/base/sugar_rush.go

@@ -0,0 +1,924 @@
+//go:build !debug
+// +build !debug
+
+// <important: auto generate by excel-to-go converter, do not modify>
+package base
+
+import "mongo.games.com/game/gamesrv/slotspkg/internal/exported/excel2go/structs"
+
+func init() {
+	SugarRushBaseSymbolShowWeight = []*structs.SugarRushBaseSymbolShowWeight{
+		{
+			ID: 1,
+			ItemID: 1,
+			Weight: 8.5,
+		},
+		{
+			ID: 2,
+			ItemID: 2,
+			Weight: 0,
+		},
+		{
+			ID: 3,
+			ItemID: 3,
+			Weight: 80,
+		},
+		{
+			ID: 4,
+			ItemID: 4,
+			Weight: 120,
+		},
+		{
+			ID: 5,
+			ItemID: 5,
+			Weight: 120,
+		},
+		{
+			ID: 6,
+			ItemID: 6,
+			Weight: 150,
+		},
+		{
+			ID: 7,
+			ItemID: 7,
+			Weight: 160,
+		},
+		{
+			ID: 8,
+			ItemID: 8,
+			Weight: 160,
+		},
+		{
+			ID: 9,
+			ItemID: 9,
+			Weight: 160,
+		},
+	}
+
+	SugarRushBaseSymbolShowNumberWeight = []*structs.SugarRushBaseSymbolShowNumberWeight{
+		{
+			ID: 1,
+			ItemID: 1,
+			ShowNumberWeight: []float64{1, 0, 0, 0, 0, 0, 0},
+		},
+		{
+			ID: 2,
+			ItemID: 2,
+			ShowNumberWeight: []float64{0, 0, 0, 0, 0, 0, 0},
+		},
+		{
+			ID: 3,
+			ItemID: 3,
+			ShowNumberWeight: []float64{50, 30, 0, 0, 0, 0, 0},
+		},
+		{
+			ID: 4,
+			ItemID: 4,
+			ShowNumberWeight: []float64{50, 40, 1, 0, 0, 0, 0},
+		},
+		{
+			ID: 5,
+			ItemID: 5,
+			ShowNumberWeight: []float64{50, 50, 2, 0, 0, 0, 0},
+		},
+		{
+			ID: 6,
+			ItemID: 6,
+			ShowNumberWeight: []float64{50, 50, 2, 0, 0, 0, 0},
+		},
+		{
+			ID: 7,
+			ItemID: 7,
+			ShowNumberWeight: []float64{80, 50, 5, 0, 0, 0, 0},
+		},
+		{
+			ID: 8,
+			ItemID: 8,
+			ShowNumberWeight: []float64{80, 50, 5, 0, 0, 0, 0},
+		},
+		{
+			ID: 9,
+			ItemID: 9,
+			ShowNumberWeight: []float64{80, 50, 5, 0, 0, 0, 0},
+		},
+	}
+
+	SugarRushBetBetChangeList = map[int64]*structs.SugarRushBetBetChangeList{
+		0: {
+			Index: 0,
+			BetChangeList: 0.2,
+			BetSizeIndex: 0,
+			BetLevelIndex: 0,
+		},
+		1: {
+			Index: 1,
+			BetChangeList: 0.4,
+			BetSizeIndex: 0,
+			BetLevelIndex: 1,
+		},
+		2: {
+			Index: 2,
+			BetChangeList: 0.6,
+			BetSizeIndex: 0,
+			BetLevelIndex: 2,
+		},
+		3: {
+			Index: 3,
+			BetChangeList: 0.8,
+			BetSizeIndex: 0,
+			BetLevelIndex: 3,
+		},
+		4: {
+			Index: 4,
+			BetChangeList: 1,
+			BetSizeIndex: 0,
+			BetLevelIndex: 4,
+		},
+		5: {
+			Index: 5,
+			BetChangeList: 1.2,
+			BetSizeIndex: 0,
+			BetLevelIndex: 5,
+		},
+		6: {
+			Index: 6,
+			BetChangeList: 1.4,
+			BetSizeIndex: 0,
+			BetLevelIndex: 6,
+		},
+		7: {
+			Index: 7,
+			BetChangeList: 1.6,
+			BetSizeIndex: 0,
+			BetLevelIndex: 7,
+		},
+		8: {
+			Index: 8,
+			BetChangeList: 1.8,
+			BetSizeIndex: 0,
+			BetLevelIndex: 8,
+		},
+		9: {
+			Index: 9,
+			BetChangeList: 2,
+			BetSizeIndex: 0,
+			BetLevelIndex: 9,
+		},
+		10: {
+			Index: 10,
+			BetChangeList: 4,
+			BetSizeIndex: 1,
+			BetLevelIndex: 1,
+		},
+		11: {
+			Index: 11,
+			BetChangeList: 6,
+			BetSizeIndex: 1,
+			BetLevelIndex: 2,
+		},
+		12: {
+			Index: 12,
+			BetChangeList: 8,
+			BetSizeIndex: 1,
+			BetLevelIndex: 3,
+		},
+		13: {
+			Index: 13,
+			BetChangeList: 10,
+			BetSizeIndex: 1,
+			BetLevelIndex: 4,
+		},
+		14: {
+			Index: 14,
+			BetChangeList: 12,
+			BetSizeIndex: 1,
+			BetLevelIndex: 5,
+		},
+		15: {
+			Index: 15,
+			BetChangeList: 14,
+			BetSizeIndex: 1,
+			BetLevelIndex: 6,
+		},
+		16: {
+			Index: 16,
+			BetChangeList: 15,
+			BetSizeIndex: 4,
+			BetLevelIndex: 0,
+		},
+		17: {
+			Index: 17,
+			BetChangeList: 16,
+			BetSizeIndex: 1,
+			BetLevelIndex: 7,
+		},
+		18: {
+			Index: 18,
+			BetChangeList: 18,
+			BetSizeIndex: 1,
+			BetLevelIndex: 8,
+		},
+		19: {
+			Index: 19,
+			BetChangeList: 20,
+			BetSizeIndex: 1,
+			BetLevelIndex: 9,
+		},
+		20: {
+			Index: 20,
+			BetChangeList: 24,
+			BetSizeIndex: 2,
+			BetLevelIndex: 5,
+		},
+		21: {
+			Index: 21,
+			BetChangeList: 28,
+			BetSizeIndex: 2,
+			BetLevelIndex: 6,
+		},
+		22: {
+			Index: 22,
+			BetChangeList: 30,
+			BetSizeIndex: 3,
+			BetLevelIndex: 2,
+		},
+		23: {
+			Index: 23,
+			BetChangeList: 32,
+			BetSizeIndex: 2,
+			BetLevelIndex: 7,
+		},
+		24: {
+			Index: 24,
+			BetChangeList: 36,
+			BetSizeIndex: 2,
+			BetLevelIndex: 8,
+		},
+		25: {
+			Index: 25,
+			BetChangeList: 40,
+			BetSizeIndex: 2,
+			BetLevelIndex: 9,
+		},
+		26: {
+			Index: 26,
+			BetChangeList: 45,
+			BetSizeIndex: 4,
+			BetLevelIndex: 2,
+		},
+		27: {
+			Index: 27,
+			BetChangeList: 50,
+			BetSizeIndex: 3,
+			BetLevelIndex: 4,
+		},
+		28: {
+			Index: 28,
+			BetChangeList: 60,
+			BetSizeIndex: 3,
+			BetLevelIndex: 5,
+		},
+		29: {
+			Index: 29,
+			BetChangeList: 70,
+			BetSizeIndex: 3,
+			BetLevelIndex: 6,
+		},
+		30: {
+			Index: 30,
+			BetChangeList: 75,
+			BetSizeIndex: 4,
+			BetLevelIndex: 4,
+		},
+		31: {
+			Index: 31,
+			BetChangeList: 80,
+			BetSizeIndex: 3,
+			BetLevelIndex: 7,
+		},
+		32: {
+			Index: 32,
+			BetChangeList: 90,
+			BetSizeIndex: 3,
+			BetLevelIndex: 8,
+		},
+		33: {
+			Index: 33,
+			BetChangeList: 100,
+			BetSizeIndex: 3,
+			BetLevelIndex: 9,
+		},
+		34: {
+			Index: 34,
+			BetChangeList: 105,
+			BetSizeIndex: 4,
+			BetLevelIndex: 6,
+		},
+		35: {
+			Index: 35,
+			BetChangeList: 120,
+			BetSizeIndex: 4,
+			BetLevelIndex: 7,
+		},
+		36: {
+			Index: 36,
+			BetChangeList: 135,
+			BetSizeIndex: 4,
+			BetLevelIndex: 8,
+		},
+		37: {
+			Index: 37,
+			BetChangeList: 150,
+			BetSizeIndex: 4,
+			BetLevelIndex: 9,
+		},
+		38: {
+			Index: 38,
+			BetChangeList: 160,
+			BetSizeIndex: 5,
+			BetLevelIndex: 3,
+		},
+		39: {
+			Index: 39,
+			BetChangeList: 200,
+			BetSizeIndex: 5,
+			BetLevelIndex: 4,
+		},
+		40: {
+			Index: 40,
+			BetChangeList: 240,
+			BetSizeIndex: 5,
+			BetLevelIndex: 5,
+		},
+		41: {
+			Index: 41,
+			BetChangeList: 280,
+			BetSizeIndex: 5,
+			BetLevelIndex: 6,
+		},
+		42: {
+			Index: 42,
+			BetChangeList: 320,
+			BetSizeIndex: 5,
+			BetLevelIndex: 7,
+		},
+		43: {
+			Index: 43,
+			BetChangeList: 360,
+			BetSizeIndex: 5,
+			BetLevelIndex: 8,
+		},
+		44: {
+			Index: 44,
+			BetChangeList: 400,
+			BetSizeIndex: 5,
+			BetLevelIndex: 9,
+		},
+		45: {
+			Index: 45,
+			BetChangeList: 3,
+			BetSizeIndex: 6,
+			BetLevelIndex: 0,
+		},
+		46: {
+			Index: 46,
+			BetChangeList: 5,
+			BetSizeIndex: 7,
+			BetLevelIndex: 0,
+		},
+		47: {
+			Index: 47,
+			BetChangeList: 25,
+			BetSizeIndex: 8,
+			BetLevelIndex: 0,
+		},
+		48: {
+			Index: 48,
+			BetChangeList: 300,
+			BetSizeIndex: 9,
+			BetLevelIndex: 0,
+		},
+	}
+
+	SugarRushBetBetLevel = map[int64]*structs.SugarRushBetBetLevel{
+		0: {
+			Index: 0,
+			BetLevel: 1,
+		},
+		1: {
+			Index: 1,
+			BetLevel: 2,
+		},
+		2: {
+			Index: 2,
+			BetLevel: 3,
+		},
+		3: {
+			Index: 3,
+			BetLevel: 4,
+		},
+		4: {
+			Index: 4,
+			BetLevel: 5,
+		},
+		5: {
+			Index: 5,
+			BetLevel: 6,
+		},
+		6: {
+			Index: 6,
+			BetLevel: 7,
+		},
+		7: {
+			Index: 7,
+			BetLevel: 8,
+		},
+		8: {
+			Index: 8,
+			BetLevel: 9,
+		},
+		9: {
+			Index: 9,
+			BetLevel: 10,
+		},
+	}
+
+	SugarRushBetBetLine = map[int64]*structs.SugarRushBetBetLine{
+		0: {
+			Index: 0,
+			BetLine: 20,
+			BaseBet: 1,
+		},
+	}
+
+	SugarRushBetBetSize = map[int64]*structs.SugarRushBetBetSize{
+		0: {
+			Index: 0,
+			BetSize: 100,
+		},
+		1: {
+			Index: 1,
+			BetSize: 1000,
+		},
+		2: {
+			Index: 2,
+			BetSize: 2000,
+		},
+		3: {
+			Index: 3,
+			BetSize: 5000,
+		},
+		4: {
+			Index: 4,
+			BetSize: 7500,
+		},
+		5: {
+			Index: 5,
+			BetSize: 20000,
+		},
+		6: {
+			Index: 6,
+			BetSize: 1500,
+		},
+		7: {
+			Index: 7,
+			BetSize: 2500,
+		},
+		8: {
+			Index: 8,
+			BetSize: 12500,
+		},
+		9: {
+			Index: 9,
+			BetSize: 150000,
+		},
+	}
+
+	SugarRushBetFirstBet = map[int64]*structs.SugarRushBetFirstBet{
+		1: {
+			Index: 1,
+			BetSizeIndex: 1,
+			BetLevelIndex: 1,
+		},
+	}
+
+	SugarRushBuyFreeScatterShowWeight = []*structs.SugarRushBuyFreeScatterShowWeight{
+		{
+			ID: 1,
+			ScatterCount: 1,
+			Weight: 0,
+		},
+		{
+			ID: 2,
+			ScatterCount: 2,
+			Weight: 0,
+		},
+		{
+			ID: 3,
+			ScatterCount: 3,
+			Weight: 1900,
+		},
+		{
+			ID: 4,
+			ScatterCount: 4,
+			Weight: 99,
+		},
+		{
+			ID: 5,
+			ScatterCount: 5,
+			Weight: 1,
+		},
+		{
+			ID: 6,
+			ScatterCount: 6,
+			Weight: 0,
+		},
+		{
+			ID: 7,
+			ScatterCount: 7,
+			Weight: 0,
+		},
+	}
+
+	SugarRushFormation = []*structs.SugarRushFormation{
+		{
+			SpinType: 1,
+			NodeType: "BaseSpin",
+			ID: 1,
+			SeqID: 1,
+			Reel: "BaseSpin",
+			Matrix: "MatchForm7X7TypeA",
+			Symbol: "Default",
+			FirstInitMethod: 2,
+			OtherInitMethod: 3,
+			FirstInitSymbols: []int64{},
+			OtherInitSymbols: []int64{},
+		},
+		{
+			SpinType: 2,
+			NodeType: "FreeSpin",
+			ID: 2,
+			SeqID: 1,
+			Reel: "FreeSpin",
+			Matrix: "MatchForm7X7TypeA",
+			Symbol: "Default",
+			FirstInitMethod: 3,
+			OtherInitMethod: 3,
+			FirstInitSymbols: []int64{},
+			OtherInitSymbols: []int64{},
+		},
+	}
+
+	SugarRushFreeSymbolShowWeight = []*structs.SugarRushFreeSymbolShowWeight{
+		{
+			ID: 1,
+			ItemID: 1,
+			Weight: 8,
+		},
+		{
+			ID: 2,
+			ItemID: 2,
+			Weight: 0,
+		},
+		{
+			ID: 3,
+			ItemID: 3,
+			Weight: 100,
+		},
+		{
+			ID: 4,
+			ItemID: 4,
+			Weight: 120,
+		},
+		{
+			ID: 5,
+			ItemID: 5,
+			Weight: 120,
+		},
+		{
+			ID: 6,
+			ItemID: 6,
+			Weight: 150,
+		},
+		{
+			ID: 7,
+			ItemID: 7,
+			Weight: 150,
+		},
+		{
+			ID: 8,
+			ItemID: 8,
+			Weight: 150,
+		},
+		{
+			ID: 9,
+			ItemID: 9,
+			Weight: 150,
+		},
+	}
+
+	SugarRushFreeSymbolShowNumberWeight = []*structs.SugarRushFreeSymbolShowNumberWeight{
+		{
+			ID: 1,
+			ItemID: 1,
+			ShowNumberWeight: []float64{1, 0, 0, 0, 0, 0, 0},
+		},
+		{
+			ID: 2,
+			ItemID: 2,
+			ShowNumberWeight: []float64{0, 0, 0, 0, 0, 0, 0},
+		},
+		{
+			ID: 3,
+			ItemID: 3,
+			ShowNumberWeight: []float64{40, 50, 5, 0, 0, 0, 0},
+		},
+		{
+			ID: 4,
+			ItemID: 4,
+			ShowNumberWeight: []float64{50, 60, 6, 0, 0, 0, 0},
+		},
+		{
+			ID: 5,
+			ItemID: 5,
+			ShowNumberWeight: []float64{50, 60, 6, 0, 0, 0, 0},
+		},
+		{
+			ID: 6,
+			ItemID: 6,
+			ShowNumberWeight: []float64{80, 90, 9, 0, 0, 0, 0},
+		},
+		{
+			ID: 7,
+			ItemID: 7,
+			ShowNumberWeight: []float64{90, 100, 20, 0, 0, 0, 0},
+		},
+		{
+			ID: 8,
+			ItemID: 8,
+			ShowNumberWeight: []float64{90, 100, 20, 0, 0, 0, 0},
+		},
+		{
+			ID: 9,
+			ItemID: 9,
+			ShowNumberWeight: []float64{90, 100, 20, 0, 0, 0, 0},
+		},
+	}
+
+	SugarRushMultiplier = []*structs.SugarRushMultiplier{
+		{
+			ID: 1,
+			MatchTimes: 0,
+			Activate: 0,
+			Multiple: 0,
+		},
+		{
+			ID: 2,
+			MatchTimes: 1,
+			Activate: 0,
+			Multiple: 0,
+		},
+		{
+			ID: 3,
+			MatchTimes: 2,
+			Activate: 1,
+			Multiple: 2,
+		},
+		{
+			ID: 4,
+			MatchTimes: 3,
+			Activate: 1,
+			Multiple: 4,
+		},
+		{
+			ID: 5,
+			MatchTimes: 4,
+			Activate: 1,
+			Multiple: 8,
+		},
+		{
+			ID: 6,
+			MatchTimes: 5,
+			Activate: 1,
+			Multiple: 16,
+		},
+		{
+			ID: 7,
+			MatchTimes: 6,
+			Activate: 1,
+			Multiple: 32,
+		},
+		{
+			ID: 8,
+			MatchTimes: 7,
+			Activate: 1,
+			Multiple: 64,
+		},
+		{
+			ID: 9,
+			MatchTimes: 8,
+			Activate: 1,
+			Multiple: 128,
+		},
+	}
+
+	SugarRushOthers = []*structs.SugarRushOthers{
+		{
+			MaxScatterPerCol: 1,
+			BuyFreeTotalBetMultiplier: 100,
+			FallWeightMultiplier: 1,
+			FreespinMaxWin: 5000,
+		},
+	}
+
+	SugarRushReelBaseSpinRange = [][]int64{
+		{7, 7, 7, 7, 7, 7, 7},
+	}
+
+	SugarRushReelBaseSpinReel = [][]int64{
+		{5, 8, 8, 5, 8, 8, 7},
+		{6, 7, 4, 6, 7, 4, 3},
+		{5, 9, 5, 5, 9, 5, 9},
+		{3, 5, 6, 3, 5, 6, 6},
+		{9, 3, 7, 9, 3, 7, 9},
+		{6, 6, 8, 6, 6, 8, 3},
+		{9, 6, 9, 9, 6, 9, 5},
+	}
+
+	SugarRushReelBaseSpinWeight = [][]float64{
+		{1, 1, 1, 1, 1, 1, 1},
+		{1, 1, 1, 1, 1, 1, 1},
+		{1, 1, 1, 1, 1, 1, 1},
+		{1, 1, 1, 1, 1, 1, 1},
+		{1, 1, 1, 1, 1, 1, 1},
+		{1, 1, 1, 1, 1, 1, 1},
+		{1, 1, 1, 1, 1, 1, 1},
+	}
+
+	SugarRushReelFreeSpinRange = [][]int64{
+		{7, 7, 7, 7, 7, 7, 7},
+	}
+
+	SugarRushReelFreeSpinReel = [][]int64{
+		{1, 2, 3, 4, 5, 6, 7},
+		{1, 2, 3, 4, 5, 6, 7},
+		{1, 2, 3, 4, 5, 6, 7},
+		{1, 2, 3, 4, 5, 6, 7},
+		{1, 2, 3, 4, 5, 6, 7},
+		{1, 2, 3, 4, 5, 6, 7},
+		{1, 2, 3, 4, 5, 6, 7},
+	}
+
+	SugarRushReelFreeSpinWeight = [][]float64{
+		{1, 1, 1, 1, 1, 1, 1},
+		{1, 1, 1, 1, 1, 1, 1},
+		{1, 1, 1, 1, 1, 1, 1},
+		{1, 1, 1, 1, 1, 1, 1},
+		{1, 1, 1, 1, 1, 1, 1},
+		{1, 1, 1, 1, 1, 1, 1},
+		{1, 1, 1, 1, 1, 1, 1},
+	}
+
+	SugarRushScatter = map[int64]*structs.SugarRushScatter{
+		1: {
+			ScatterCount: 1,
+			FreeSpinBouts: 0,
+			FreeSpinExtraBouts: 0,
+			BasePayrate: 0,
+			FreePayrate: 0,
+		},
+		2: {
+			ScatterCount: 2,
+			FreeSpinBouts: 0,
+			FreeSpinExtraBouts: 0,
+			BasePayrate: 0,
+			FreePayrate: 0,
+		},
+		3: {
+			ScatterCount: 3,
+			FreeSpinBouts: 10,
+			FreeSpinExtraBouts: 10,
+			BasePayrate: 0,
+			FreePayrate: 0,
+		},
+		4: {
+			ScatterCount: 4,
+			FreeSpinBouts: 12,
+			FreeSpinExtraBouts: 12,
+			BasePayrate: 0,
+			FreePayrate: 0,
+		},
+		5: {
+			ScatterCount: 5,
+			FreeSpinBouts: 15,
+			FreeSpinExtraBouts: 15,
+			BasePayrate: 0,
+			FreePayrate: 0,
+		},
+		6: {
+			ScatterCount: 6,
+			FreeSpinBouts: 20,
+			FreeSpinExtraBouts: 20,
+			BasePayrate: 0,
+			FreePayrate: 0,
+		},
+		7: {
+			ScatterCount: 7,
+			FreeSpinBouts: 30,
+			FreeSpinExtraBouts: 30,
+			BasePayrate: 0,
+			FreePayrate: 0,
+		},
+	}
+
+	SugarRushSymbol = map[int64]*structs.SugarRushSymbol{
+		1: {
+			ID: 1,
+			Name: "Scatter",
+			IsWild: false,
+			Group: []int64{1},
+			PayRate: []int64{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},
+			ClientOrder: 0,
+			ClientDsc: "",
+		},
+		2: {
+			ID: 2,
+			Name: "无",
+			IsWild: false,
+			Group: []int64{2},
+			PayRate: []int64{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},
+			ClientOrder: 0,
+			ClientDsc: "",
+		},
+		3: {
+			ID: 3,
+			Name: "粉球",
+			IsWild: false,
+			Group: []int64{3},
+			PayRate: []int64{0, 0, 0, 0, 20, 30, 35, 40, 50, 100, 150, 300, 700, 1400, 3000, 3000, 3000, 3000, 3000, 3000, 3000, 3000, 3000, 3000, 3000, 3000, 3000, 3000, 3000, 3000, 3000, 3000, 3000, 3000, 3000, 3000, 3000, 3000, 3000, 3000, 3000, 3000, 3000, 3000, 3000, 3000, 3000, 3000, 3000},
+			ClientOrder: 1,
+			ClientDsc: "",
+		},
+		4: {
+			ID: 4,
+			Name: "橙心",
+			IsWild: false,
+			Group: []int64{4},
+			PayRate: []int64{0, 0, 0, 0, 15, 20, 25, 30, 40, 80, 120, 250, 600, 1200, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000, 2000},
+			ClientOrder: 2,
+			ClientDsc: "",
+		},
+		5: {
+			ID: 5,
+			Name: "紫豆",
+			IsWild: false,
+			Group: []int64{5},
+			PayRate: []int64{0, 0, 0, 0, 10, 15, 20, 25, 30, 60, 90, 200, 400, 800, 1200, 1200, 1200, 1200, 1200, 1200, 1200, 1200, 1200, 1200, 1200, 1200, 1200, 1200, 1200, 1200, 1200, 1200, 1200, 1200, 1200, 1200, 1200, 1200, 1200, 1200, 1200, 1200, 1200, 1200, 1200, 1200, 1200, 1200, 1200},
+			ClientOrder: 3,
+			ClientDsc: "",
+		},
+		6: {
+			ID: 6,
+			Name: "绿星",
+			IsWild: false,
+			Group: []int64{6},
+			PayRate: []int64{0, 0, 0, 0, 8, 10, 15, 20, 25, 40, 60, 100, 200, 400, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800},
+			ClientOrder: 4,
+			ClientDsc: "",
+		},
+		7: {
+			ID: 7,
+			Name: "红熊",
+			IsWild: false,
+			Group: []int64{7},
+			PayRate: []int64{0, 0, 0, 0, 6, 8, 10, 15, 20, 30, 50, 70, 160, 300, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600},
+			ClientOrder: 5,
+			ClientDsc: "",
+		},
+		8: {
+			ID: 8,
+			Name: "紫熊",
+			IsWild: false,
+			Group: []int64{8},
+			PayRate: []int64{0, 0, 0, 0, 5, 6, 8, 10, 15, 25, 40, 60, 120, 240, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500},
+			ClientOrder: 6,
+			ClientDsc: "",
+		},
+		9: {
+			ID: 9,
+			Name: "橙熊",
+			IsWild: false,
+			Group: []int64{9},
+			PayRate: []int64{0, 0, 0, 0, 4, 5, 6, 8, 10, 20, 30, 50, 100, 200, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 400},
+			ClientOrder: 7,
+			ClientDsc: "",
+		},
+	}
+
+	SugarRushSymbolBetRatio = []*structs.SugarRushSymbolBetRatio{
+		{
+			BetRatio: 1,
+		},
+	}
+
+}

gamesrv/slotspkg/internal/exported/excel2go/base/var.go

@@ -250,6 +250,28 @@ var (
 	PrizeModelPrizeModelTypeB = map[int64]*structs.PrizeModelPrizeModelTypeB{}
 	SimulatorFSMultiLevel = []*structs.SimulatorFSMultiLevel{}
 	SimulatorMultiLevel = []*structs.SimulatorMultiLevel{}
+	SugarRushBaseSymbolShowWeight = []*structs.SugarRushBaseSymbolShowWeight{}
+	SugarRushBaseSymbolShowNumberWeight = []*structs.SugarRushBaseSymbolShowNumberWeight{}
+	SugarRushBetBetChangeList = map[int64]*structs.SugarRushBetBetChangeList{}
+	SugarRushBetBetLevel = map[int64]*structs.SugarRushBetBetLevel{}
+	SugarRushBetBetLine = map[int64]*structs.SugarRushBetBetLine{}
+	SugarRushBetBetSize = map[int64]*structs.SugarRushBetBetSize{}
+	SugarRushBetFirstBet = map[int64]*structs.SugarRushBetFirstBet{}
+	SugarRushBuyFreeScatterShowWeight = []*structs.SugarRushBuyFreeScatterShowWeight{}
+	SugarRushFormation = []*structs.SugarRushFormation{}
+	SugarRushFreeSymbolShowWeight = []*structs.SugarRushFreeSymbolShowWeight{}
+	SugarRushFreeSymbolShowNumberWeight = []*structs.SugarRushFreeSymbolShowNumberWeight{}
+	SugarRushMultiplier = []*structs.SugarRushMultiplier{}
+	SugarRushOthers = []*structs.SugarRushOthers{}
+	SugarRushReelBaseSpinRange = [][]int64{}
+	SugarRushReelBaseSpinReel = [][]int64{}
+	SugarRushReelBaseSpinWeight = [][]float64{}
+	SugarRushReelFreeSpinRange = [][]int64{}
+	SugarRushReelFreeSpinReel = [][]int64{}
+	SugarRushReelFreeSpinWeight = [][]float64{}
+	SugarRushScatter = map[int64]*structs.SugarRushScatter{}
+	SugarRushSymbolBetRatio = []*structs.SugarRushSymbolBetRatio{}
+	SugarRushSymbol = map[int64]*structs.SugarRushSymbol{}
 	TestBetBetChangeList = map[int64]*structs.TestBetBetChangeList{}
 	TestBetBetLevel = map[int64]*structs.TestBetBetLevel{}
 	TestBetBetLine = map[int64]*structs.TestBetBetLine{}

gamesrv/slotspkg/internal/exported/excel2go/storage/storage.go

@@ -309,6 +309,28 @@ func StoragesLoading(data map[string]string) {
 	Load(data, "Base.PrizeModel/PrizeModelTypeB.Default", &base.PrizeModelPrizeModelTypeB)
 	Load(data, "Base.Simulator.FSMultiLevel", &base.SimulatorFSMultiLevel)
 	Load(data, "Base.Simulator.MultiLevel", &base.SimulatorMultiLevel)
+	Load(data, "Base.SugarRush/BaseSymbolShow.Weight", &base.SugarRushBaseSymbolShowWeight)
+	Load(data, "Base.SugarRush/BaseSymbolShowNumber.Weight", &base.SugarRushBaseSymbolShowNumberWeight)
+	Load(data, "Base.SugarRush/Bet.BetChangeList", &base.SugarRushBetBetChangeList)
+	Load(data, "Base.SugarRush/Bet.BetLevel", &base.SugarRushBetBetLevel)
+	Load(data, "Base.SugarRush/Bet.BetLine", &base.SugarRushBetBetLine)
+	Load(data, "Base.SugarRush/Bet.BetSize", &base.SugarRushBetBetSize)
+	Load(data, "Base.SugarRush/Bet.FirstBet", &base.SugarRushBetFirstBet)
+	Load(data, "Base.SugarRush/BuyFreeScatterShow.Weight", &base.SugarRushBuyFreeScatterShowWeight)
+	Load(data, "Base.SugarRush/Formation.Default", &base.SugarRushFormation)
+	Load(data, "Base.SugarRush/FreeSymbolShow.Weight", &base.SugarRushFreeSymbolShowWeight)
+	Load(data, "Base.SugarRush/FreeSymbolShowNumber.Weight", &base.SugarRushFreeSymbolShowNumberWeight)
+	Load(data, "Base.SugarRush/Multiplier.Default", &base.SugarRushMultiplier)
+	Load(data, "Base.SugarRush/Others.Default", &base.SugarRushOthers)
+	Load(data, "Base.SugarRush/ReelBaseSpin.Range", &base.SugarRushReelBaseSpinRange)
+	Load(data, "Base.SugarRush/ReelBaseSpin.Reel", &base.SugarRushReelBaseSpinReel)
+	Load(data, "Base.SugarRush/ReelBaseSpin.Weight", &base.SugarRushReelBaseSpinWeight)
+	Load(data, "Base.SugarRush/ReelFreeSpin.Range", &base.SugarRushReelFreeSpinRange)
+	Load(data, "Base.SugarRush/ReelFreeSpin.Reel", &base.SugarRushReelFreeSpinReel)
+	Load(data, "Base.SugarRush/ReelFreeSpin.Weight", &base.SugarRushReelFreeSpinWeight)
+	Load(data, "Base.SugarRush/Scatter.Default", &base.SugarRushScatter)
+	Load(data, "Base.SugarRush/Symbol.BetRatio", &base.SugarRushSymbolBetRatio)
+	Load(data, "Base.SugarRush/Symbol.Default", &base.SugarRushSymbol)
 	Load(data, "Base.Test/Bet.BetChangeList", &base.TestBetBetChangeList)
 	Load(data, "Base.Test/Bet.BetLevel", &base.TestBetBetLevel)
 	Load(data, "Base.Test/Bet.BetLine", &base.TestBetBetLine)
@@ -571,6 +593,28 @@ func StoragesMapping() {
 	Set("Base", "PrizeModel/PrizeModelTypeB", "Default", base.PrizeModelPrizeModelTypeB)
 	Set("Base", "Simulator", "FSMultiLevel", base.SimulatorFSMultiLevel)
 	Set("Base", "Simulator", "MultiLevel", base.SimulatorMultiLevel)
+	Set("Base", "SugarRush/BaseSymbolShow", "Weight", base.SugarRushBaseSymbolShowWeight)
+	Set("Base", "SugarRush/BaseSymbolShowNumber", "Weight", base.SugarRushBaseSymbolShowNumberWeight)
+	Set("Base", "SugarRush/Bet", "BetChangeList", base.SugarRushBetBetChangeList)
+	Set("Base", "SugarRush/Bet", "BetLevel", base.SugarRushBetBetLevel)
+	Set("Base", "SugarRush/Bet", "BetLine", base.SugarRushBetBetLine)
+	Set("Base", "SugarRush/Bet", "BetSize", base.SugarRushBetBetSize)
+	Set("Base", "SugarRush/Bet", "FirstBet", base.SugarRushBetFirstBet)
+	Set("Base", "SugarRush/BuyFreeScatterShow", "Weight", base.SugarRushBuyFreeScatterShowWeight)
+	Set("Base", "SugarRush/Formation", "Default", base.SugarRushFormation)
+	Set("Base", "SugarRush/FreeSymbolShow", "Weight", base.SugarRushFreeSymbolShowWeight)
+	Set("Base", "SugarRush/FreeSymbolShowNumber", "Weight", base.SugarRushFreeSymbolShowNumberWeight)
+	Set("Base", "SugarRush/Multiplier", "Default", base.SugarRushMultiplier)
+	Set("Base", "SugarRush/Others", "Default", base.SugarRushOthers)
+	Set("Base", "SugarRush/ReelBaseSpin", "Range", base.SugarRushReelBaseSpinRange)
+	Set("Base", "SugarRush/ReelBaseSpin", "Reel", base.SugarRushReelBaseSpinReel)
+	Set("Base", "SugarRush/ReelBaseSpin", "Weight", base.SugarRushReelBaseSpinWeight)
+	Set("Base", "SugarRush/ReelFreeSpin", "Range", base.SugarRushReelFreeSpinRange)
+	Set("Base", "SugarRush/ReelFreeSpin", "Reel", base.SugarRushReelFreeSpinReel)
+	Set("Base", "SugarRush/ReelFreeSpin", "Weight", base.SugarRushReelFreeSpinWeight)
+	Set("Base", "SugarRush/Scatter", "Default", base.SugarRushScatter)
+	Set("Base", "SugarRush/Symbol", "BetRatio", base.SugarRushSymbolBetRatio)
+	Set("Base", "SugarRush/Symbol", "Default", base.SugarRushSymbol)
 	Set("Base", "Test/Bet", "BetChangeList", base.TestBetBetChangeList)
 	Set("Base", "Test/Bet", "BetLevel", base.TestBetBetLevel)
 	Set("Base", "Test/Bet", "BetLine", base.TestBetBetLine)
@@ -626,6 +670,11 @@ func LinksMapping() {
 	Link("GatesOfOlympus/ReelBaseSpin1", "Weight/1", "GatesOfOlympus/ReelBaseSpin1", "Weight")
 	Link("GatesOfOlympus/ReelBaseSpin1", "Weight/2", "GatesOfOlympus/ReelBaseSpin1", "Weight")
 	Link("GatesOfOlympus/ReelBaseSpin1", "Weight/3", "GatesOfOlympus/ReelBaseSpin1", "Weight")
+	Link("SugarRush/MatrixMatchForm7X7TypeA", "Default", "Matrix/MatchForm7X7TypeA", "Default")
+	Link("SugarRush/PrizeModel", "Default", "PrizeModel/PrizeModelTypeB", "Default")
+	Link("SugarRush/ReelBaseSpin", "Weight/1", "SugarRush/ReelBaseSpin", "Weight")
+	Link("SugarRush/ReelBaseSpin", "Weight/2", "SugarRush/ReelBaseSpin", "Weight")
+	Link("SugarRush/ReelBaseSpin", "Weight/3", "SugarRush/ReelBaseSpin", "Weight")
 	Link("Test/MatrixLine1Form3X3TypeA", "Default", "Matrix/Line1Form3X3TypeA", "Default")
 	Link("Test/PrizeModel", "Default", "PrizeModel/PrizeModelTypeB", "Default")
 	Link("Test/ReelBaseSpin", "Weight/1", "Test/ReelBaseSpin", "Weight")

gamesrv/slotspkg/internal/exported/excel2go/structs/structs.go

@@ -261,6 +261,32 @@ type (
 		Min int64
 		Max int64
 	}
+	// SugarRushBaseSymbolShowNumberWeight comment
+	SugarRushBaseSymbolShowNumberWeight struct {
+		ID int64
+		ItemID int64
+		ShowNumberWeight []float64
+	}
+	// SugarRushBuyFreeScatterShowWeight comment
+	SugarRushBuyFreeScatterShowWeight struct {
+		ID int64
+		ScatterCount int64
+		Weight float64
+	}
+	// SugarRushMultiplier comment
+	SugarRushMultiplier struct {
+		ID int64
+		MatchTimes int64
+		Activate int64
+		Multiple int64
+	}
+	// SugarRushOthers comment
+	SugarRushOthers struct {
+		MaxScatterPerCol int64
+		BuyFreeTotalBetMultiplier int64
+		FallWeightMultiplier int64
+		FreespinMaxWin int64
+	}
 	// SuperStackWeight comment
 	SuperStackWeight struct {
 		ID int64
@@ -834,6 +860,42 @@ type (
 	// SimulatorMultiLevel comment
 	SimulatorMultiLevel = SimulatorFSMultiLevel
 
+	// SugarRushBaseSymbolShowWeight comment
+	SugarRushBaseSymbolShowWeight = SuperStackWeight
+
+	// SugarRushBetBetChangeList comment
+	SugarRushBetBetChangeList = BetChangeList
+
+	// SugarRushBetBetLevel comment
+	SugarRushBetBetLevel = BetLevel
+
+	// SugarRushBetBetLine comment
+	SugarRushBetBetLine = BetLine
+
+	// SugarRushBetBetSize comment
+	SugarRushBetBetSize = BetSize
+
+	// SugarRushBetFirstBet comment
+	SugarRushBetFirstBet = FirstBet
+
+	// SugarRushFormation comment
+	SugarRushFormation = Formation
+
+	// SugarRushFreeSymbolShowNumberWeight comment
+	SugarRushFreeSymbolShowNumberWeight = SugarRushBaseSymbolShowNumberWeight
+
+	// SugarRushFreeSymbolShowWeight comment
+	SugarRushFreeSymbolShowWeight = SuperStackWeight
+
+	// SugarRushScatter comment
+	SugarRushScatter = Scatter
+
+	// SugarRushSymbol comment
+	SugarRushSymbol = Symbol
+
+	// SugarRushSymbolBetRatio comment
+	SugarRushSymbolBetRatio = SymbolBetRatio
+
 	// TestBetBetChangeList comment
 	TestBetBetChangeList = BetChangeList
 

gamesrv/slotspkg/internal/generic/key/theme.go

@@ -8,6 +8,7 @@ const (
 	FortuneMouse   = "FortuneMouse"
 	CashMania      = "CashMania"
 	GatesOfOlympus = "GatesOfOlympus"
+	SugarRush      = "SugarRush"
 	Test           = "Test"
 )
 const (
@@ -34,16 +35,6 @@ var GameMap = map[uint]string{
 	GameId_GatesOfOlympus: GatesOfOlympus,
 	GameId_Test:           Test,
 }
-var GameMapTheme = map[string]uint{
-	FortuneTiger:   GameId_Tiger,
-	FortuneDragon:  GameId_Dragon,
-	FortuneRabbit:  GameId_Rabbit,
-	FortuneOx:      GameId_OX,
-	FortuneMouse:   GameId_Mouse,
-	CashMania:      GameId_Cash_Mania,
-	GatesOfOlympus: GameId_GatesOfOlympus,
-	Test:           GameId_Test,
-}
 var GameKeyMap = map[int64]uint{
 	0:   GameId_Min,
 	308: GameId_Tiger,

gamesrv/slotspkg/slots/plugin/init.go

@@ -9,6 +9,7 @@ import (
 	"mongo.games.com/game/gamesrv/slotspkg/slots/plugin/fortunerabbit"
 	"mongo.games.com/game/gamesrv/slotspkg/slots/plugin/fortunetiger"
 	"mongo.games.com/game/gamesrv/slotspkg/slots/plugin/gatesofolympus"
+	"mongo.games.com/game/gamesrv/slotspkg/slots/plugin/sugarrush"
 	"mongo.games.com/game/gamesrv/slotspkg/slots/plugin/test"
 	"mongo.games.com/game/gamesrv/slotspkg/slots/reg"
 )
@@ -22,6 +23,7 @@ func Init() {
 	reg.Register(fortunemouse.Plugins...)
 	reg.Register(cashmania.Plugins...)
 	reg.Register(gatesofolympus.Plugins...)
+	reg.Register(sugarrush.Plugins...)
 	reg.Register(test.Plugins...)
 
 	if global.Mock {
@@ -31,6 +33,7 @@ func Init() {
 		reg.Register(fortunedragon.SimulatorPlugins...)
 		reg.Register(cashmania.SimulatorPlugins...)
 		reg.Register(gatesofolympus.SimulatorPlugins...)
+		reg.Register(sugarrush.SimulatorPlugins...)
 		reg.Register(test.SimulatorPlugins...)
 	}
 }
@@ -44,6 +47,7 @@ func Close() {
 	reg.Deregister(fortunemouse.Plugins...)
 	reg.Deregister(cashmania.Plugins...)
 	reg.Deregister(gatesofolympus.Plugins...)
+	reg.Deregister(sugarrush.Plugins...)
 	reg.Deregister(test.Plugins...)
 	if global.Mock {
 		reg.Deregister(fortuneox.SimulatorPlugins...)
@@ -52,6 +56,7 @@ func Close() {
 		reg.Deregister(fortunedragon.SimulatorPlugins...)
 		reg.Deregister(cashmania.SimulatorPlugins...)
 		reg.Deregister(gatesofolympus.SimulatorPlugins...)
+		reg.Deregister(sugarrush.SimulatorPlugins...)
 		reg.Deregister(test.SimulatorPlugins...)
 	}
 }

gamesrv/slotspkg/slots/plugin/sugarrush/base.go

@@ -0,0 +1,419 @@
+package sugarrush
+
+import (
+	"github.com/tomas-qstarrs/boost/mathx"
+	"github.com/tomas-qstarrs/boost/randx"
+	"mongo.games.com/game/gamesrv/slotspkg/internal/generic/key"
+	"mongo.games.com/game/gamesrv/slotspkg/internal/module/shared"
+	"mongo.games.com/game/gamesrv/slotspkg/slots/intf"
+	"mongo.games.com/game/gamesrv/slotspkg/slots/plugin/generic"
+)
+
+// PluginBaseSpin is derived from generic.PluginBase
+type PluginBaseSpin struct {
+	generic.PluginBase
+}
+
+// Theme implements generic.PluginBase.Theme
+func (p *PluginBaseSpin) Theme() string {
+	return key.SugarRush
+}
+
+type CustomEliminate struct {
+	LinkPositions    []*shared.LinkPositions
+	AppendSymbols    [][]int64
+	FormattedSymbols [][]int64
+	LinePays         []float64
+	LineMultis       []int64
+	WinCoins         []int64
+	MaxWin           bool
+}
+
+type CustomPay struct {
+	Pay int64
+}
+
+type CustomMulti struct {
+	MultiTable [][]int64
+}
+
+type Col struct {
+	Values []int64
+}
+
+type Formation struct {
+	Cols []Col
+}
+
+// Customs implements generic.PluginBase.Customs
+func (p *PluginBaseSpin) Customs() []interface{} {
+	return []interface{}{
+		&CustomPay{},
+		&CustomEliminate{},
+		&MultiTable{},
+		&CustomMulti{},
+	}
+}
+
+// AfterBaseSpin is called after base spin
+func (p *PluginBaseSpin) AfterBaseSpin(m intf.Master) {
+
+}
+
+func (f *Formation) AddFreeSpin(m intf.Master) {
+	if m.Cursor().GetType() != key.BaseSpin {
+		return
+	}
+	scatterCount := Descx(m).RandScatterCount()
+	// get current count
+	currentCount := int64(0)
+	for _, col := range f.Cols {
+		for _, v := range col.Values {
+			if v == SymbolScatter {
+				currentCount++
+			}
+		}
+	}
+
+	// get col not has scatter
+	colNotHasScatter := make([]int64, 0)
+	for i, col := range f.Cols {
+		hasScatter := false
+		for _, v := range col.Values {
+			if v == SymbolScatter {
+				hasScatter = true
+				break
+			}
+		}
+		if !hasScatter {
+			colNotHasScatter = append(colNotHasScatter, int64(i))
+		}
+	}
+
+	needCount := scatterCount - currentCount
+	if needCount <= 0 {
+		needCount = 0
+	}
+
+	// rand new scatter for col not has scatter
+	randx.RandShuffle(m.Randx(), colNotHasScatter)
+	for i := int64(0); i < needCount; i++ {
+		col := colNotHasScatter[i]
+		f.Cols[col].Values[randx.RandRangeInt63n(m.Randx(), 0, 6)] = SymbolScatter
+	}
+}
+
+func (f *Formation) fillCol(m intf.Master, col int64, eliminate bool, isFree bool) []int64 {
+	appendValues := make([]int64, 0)
+	values := f.Cols[col].Values
+	left := ReelHeight - int64(len(values))
+	scatterCount := int64(0)
+	for _, v := range values {
+		if v == SymbolScatter {
+			scatterCount++
+			break
+		}
+	}
+
+	topItemID := int64(0)
+	isTop := false
+	if len(values) > 0 && eliminate {
+		topItemID = values[0]
+		isTop = true
+	}
+
+	for left > 0 {
+		itemID := Descx(m).RandItemID(topItemID, isFree, isTop)
+		if isTop {
+			isTop = false
+		}
+		topItemID = itemID
+
+		itemCount := Descx(m).RandItemCount(itemID, left, isFree)
+		if SymbolScatter == itemID {
+			itemCount = mathx.Min(itemCount, Descx(m).GetOtherConfig().MaxScatterPerCol-scatterCount)
+		}
+
+		if SymbolScatter == itemID {
+			scatterCount += itemCount
+		}
+
+		for i := int64(0); i < itemCount; i++ {
+			// append at head
+			values = append([]int64{itemID}, values...)
+			appendValues = append([]int64{itemID}, appendValues...)
+		}
+
+		left -= itemCount
+	}
+	f.Cols[col].Values = values
+	return appendValues
+}
+
+func (f *Formation) fillCols(m intf.Master, eliminate bool, isFree bool) [][]int64 {
+	newSymbols := make([][]int64, ReelWidth)
+	for j := int64(0); j < ReelWidth; j++ {
+		newSymbols[j] = f.fillCol(m, j, eliminate, isFree)
+	}
+	return newSymbols
+}
+
+func (f *Formation) GetValues() [][]int64 {
+	values := make([][]int64, ReelHeight)
+	for j := int64(0); j < ReelWidth; j++ {
+		for i := int64(0); i < ReelHeight; i++ {
+			values[j] = append(values[j], f.Cols[j].Values[i])
+		}
+	}
+	return values
+}
+
+func createFormation() *Formation {
+	formation := &Formation{}
+	for i := 0; i < 7; i++ {
+		formation.Cols = make([]Col, 7)
+	}
+	return formation
+}
+
+func (p *PluginBaseSpin) RandFormation(m intf.Master) [][]int64 {
+	formation := &Formation{
+		Cols: make([]Col, 7),
+	}
+	for i := 0; i < 7; i++ {
+		formation.Cols[i] = Col{
+			Values: make([]int64, 0),
+		}
+		formation.fillCol(m, int64(i), false, m.Cursor().GetType() == key.FreeSpin)
+	}
+
+	// 购买freespin
+	if m.Exists(key.MachineRoundType) && m.Value(key.MachineRoundType).(int64) == RoundTypeBuyFreeSpin {
+		formation.AddFreeSpin(m)
+	}
+
+	return formation.GetValues()
+}
+
+func DumpReel(symbols [][]int64) {
+	// str := ""
+	// for row := int64(0); row < 7; row++ {
+	// 	for col := int64(0); col < 7; col++ {
+	// 		str += fmt.Sprintf("%d ", symbols[col][row])
+	// 	}
+	// 	str += "\n"
+	// }
+	// log.Infof("reel: \n%s\n", str)
+}
+
+func IsPositionLinked(linkPositions []*shared.LinkPositions, row int64, col int64) bool {
+	for _, positions := range linkPositions {
+		for _, position := range positions.Positions {
+			if position == col*7+row {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+type MultiTable struct {
+	Multi [][]int64
+	Count [][]int64
+}
+
+func (t *MultiTable) Clear() {
+	for i := 0; i < 7; i++ {
+		for j := 0; j < 7; j++ {
+			t.Multi[i][j] = 0
+			t.Count[i][j] = 0
+		}
+	}
+}
+
+func (t *MultiTable) Update(m intf.Master, linkPositions []*shared.LinkPositions) {
+	for _, positions := range linkPositions {
+		for _, position := range positions.Positions {
+			t.Count[position/7][position%7]++
+		}
+	}
+	// update multi
+	for i := 0; i < 7; i++ {
+		for j := 0; j < 7; j++ {
+			t.Multi[i][j] = Descx(m).GetMulti(t.Count[i][j])
+		}
+	}
+}
+
+func calcMulti(linkPositions *shared.LinkPositions, multiTable *MultiTable) int64 {
+	totalMulti := int64(0)
+
+	for _, p := range linkPositions.Positions {
+		if multiTable.Multi[p/7][p%7] > 1 {
+			totalMulti += multiTable.Multi[p/7][p%7]
+		}
+	}
+
+	if totalMulti < 1 {
+		totalMulti = 1
+	}
+
+	return totalMulti
+}
+
+func (p *PluginBaseSpin) Eliminate(m intf.Master, customPay *CustomPay, multiTable *MultiTable) bool {
+	cursorFormation := m.CursorFormation()
+	formattedSymbols := cursorFormation.GetReelFormattedSymbols()
+	DumpReel(formattedSymbols)
+	// 清空基础赢钱
+	cursorFormation.SetWin(0)
+
+	// 根据赔付计算multi type
+	linkPositions, _, linePays := m.TryLinkMatrixSymbols(1, formattedSymbols)
+	DumpReel(multiTable.Multi)
+	lineMultis := make([]int64, len(linePays))
+
+	symbols := cursorFormation.GetReelFormattedSymbols()
+	success := mathx.Sum(linePays) > 0
+
+	// erase
+	formation := createFormation()
+	for j := int64(0); j < 7; j++ {
+		for i := int64(0); i < 7; i++ {
+			if !IsPositionLinked(linkPositions, i, j) {
+				formation.Cols[j].Values = append(formation.Cols[j].Values, symbols[j][i])
+			}
+		}
+	}
+
+	appendFormattedSymbols := formation.fillCols(m, true, m.Cursor().GetType() == key.FreeSpin)
+
+	lineNum := len(linePays)
+	winCoins := make([]int64, lineNum)
+	totalPay := int64(0)
+
+	for lineIdx, pay := range linePays {
+		multi := calcMulti(linkPositions[lineIdx], multiTable)
+		lineMultis[lineIdx] = multi
+		winCoins[lineIdx] = int64(float64(m.Cursor().GetSingleBet()) * pay * float64(multi))
+		totalPay += winCoins[lineIdx]
+	}
+
+	isMaxWin := false
+
+	maxValue := Descx(m).GetOtherConfig().FreespinMaxWin * m.Cursor().GetBet()
+	currentWin := m.TotalWin() + customPay.Pay
+
+	// log.Infof("Eliminate totalPay: %d, currentWin: %d, maxValue: %d", totalPay, currentWin, maxValue)
+
+	if m.Cursor().GetType() == key.FreeSpin {
+		if currentWin+totalPay >= maxValue {
+			success = false
+			isMaxWin = true
+			totalPay = maxValue - currentWin
+			m.SetProgressLeft(0)
+		}
+	}
+
+	// 添加后续feature，这里是消除
+	m.AddCursorFeature(&CustomEliminate{
+		LinkPositions:    linkPositions,
+		AppendSymbols:    appendFormattedSymbols,
+		FormattedSymbols: formattedSymbols,
+		LinePays:         linePays,
+		LineMultis:       lineMultis,
+		WinCoins:         winCoins,
+		MaxWin:           isMaxWin,
+	}).SetLifetime(1)
+
+	DumpReel(formation.GetValues())
+	cursorFormation.SetFormattedSymbols(formation.GetValues())
+
+	// 累加pay
+	customPay.Pay += totalPay
+	multiTable.Update(m, linkPositions)
+
+	// add new
+	return success
+}
+
+func (p *PluginBaseSpin) BeforeSpin(m intf.Master) {
+	m.AddCursorFeature(&CustomPay{}).SetLifetime(1)
+}
+
+func (p *PluginBaseSpin) Spin(m intf.Master, isFree bool) {
+	// 生成轴
+	symbols := p.RandFormation(m)
+	DumpReel(symbols)
+	formation := m.CursorFormation()
+	formation.SetFormattedSymbols(symbols)
+	customPay := m.CursorCustom(&CustomPay{}).(*CustomPay)
+
+	table := getMultiTable(m)
+
+	// 存储 Formation元素
+	formation.SetFormattedDisplaySymbols(symbols)
+
+	// 消除
+	n := 0
+	for p.Eliminate(m, customPay, table) {
+		n++
+		if n > 1000 {
+			break
+		}
+	}
+
+	if customPay.Pay > 0 {
+		m.CursorFeature(&CustomPay{}).SetWin(customPay.Pay)
+	}
+
+	m.AddCursorFeature(&CustomMulti{
+		MultiTable: table.Multi,
+	}).SetLifetime(1)
+
+	formattedSymbols := formation.GetReelFormattedSymbols()
+	formation.SetFormattedFinalSymbols(formattedSymbols)
+}
+
+func (p *PluginBaseSpin) CheckFreeLimit(m intf.Master) {
+
+}
+
+// AfterSpin implements generic.PluginBase.AfterSpin
+func (p *PluginBaseSpin) AfterSpin(m intf.Master) {
+	p.Spin(m, m.Cursor().GetType() == key.FreeSpin)
+
+	switch m.Cursor().GetType() {
+	case key.BaseSpin:
+		p.AfterBaseSpin(m)
+	case key.FreeSpin:
+		p.AfterFreeSpin(m)
+		p.CheckFreeLimit(m)
+	}
+}
+
+// AfterFreeSpin is called after free spin
+func (p *PluginBaseSpin) AfterFreeSpin(m intf.Master) {
+
+}
+
+func (p *PluginBaseSpin) OnLeaveNode(m intf.Master) {
+	if m.Next().GetType() == key.FreeSpin || m.Next().GetType() == key.BaseSpin {
+		getMultiTable(m).Clear()
+	}
+}
+
+func getMultiTable(m intf.Master) *MultiTable {
+	if len(m.RootFeatures(&MultiTable{})) == 0 {
+		table := &MultiTable{
+			Multi: make([][]int64, 7),
+			Count: make([][]int64, 7),
+		}
+		for i := 0; i < 7; i++ {
+			table.Multi[i] = make([]int64, 7)
+			table.Count[i] = make([]int64, 7)
+		}
+		m.AddRootFeature(table)
+	}
+	return m.RootCustom(&MultiTable{}).(*MultiTable)
+}

gamesrv/slotspkg/slots/plugin/sugarrush/choose_wheel.go

@@ -0,0 +1,31 @@
+package sugarrush
+
+import (
+	"mongo.games.com/game/gamesrv/slotspkg/internal/generic/key"
+	"mongo.games.com/game/gamesrv/slotspkg/slots/intf"
+	"mongo.games.com/game/gamesrv/slotspkg/slots/plugin/generic"
+)
+
+type PluginChooseWheel struct {
+	generic.PluginBase
+}
+
+func (p *PluginChooseWheel) Theme() string {
+	return key.SugarRush
+}
+
+func (p *PluginChooseWheel) OnStepBegin(m intf.Master) {
+	isFreeSpin := m.Next().GetType() == key.FreeSpin
+	typ := m.Choice()
+
+	if !isFreeSpin {
+		if typ == RoundTypeBuyFreeSpin {
+			m.SetRatio(key.MachineRatioMoreCoinSameBet, 100)
+		}
+	}
+
+	// 设置日志中的RoundType
+	if m.Next().GetType() == key.BaseSpin {
+		m.Set(key.MachineRoundType, typ)
+	}
+}

gamesrv/slotspkg/slots/plugin/sugarrush/common.go

@@ -0,0 +1,12 @@
+package sugarrush
+
+const (
+	ReelWidth     = int64(7)
+	ReelHeight    = int64(7)
+	SymbolScatter = int64(1)
+)
+const (
+	RoundTypeBaseSpin    = iota
+	RoundTypeMoreScatter // 25% more cost
+	RoundTypeBuyFreeSpin // 10000% more cost
+)

gamesrv/slotspkg/slots/plugin/sugarrush/descx.go

@@ -0,0 +1,165 @@
+package sugarrush
+
+import (
+	"github.com/tomas-qstarrs/boost/randx"
+	"mongo.games.com/game/gamesrv/slotspkg/internal/exported/excel2go/structs"
+	"mongo.games.com/game/gamesrv/slotspkg/internal/generic/errors"
+	"mongo.games.com/game/gamesrv/slotspkg/slots/desc"
+	"mongo.games.com/game/gamesrv/slotspkg/slots/intf"
+)
+
+type descx struct {
+	*randx.Randx
+	*desc.NodeDesc
+}
+
+func Descx(m intf.Master) *descx {
+	return &descx{
+		Randx:    m.Randx(),
+		NodeDesc: m.Desc(),
+	}
+}
+
+func (n descx) GetOtherConfig() *structs.SugarRushOthers {
+	v := n.DefaultSheet("Others")
+
+	values, ok := v.([]*structs.SugarRushOthers)
+	if !ok {
+		panic(errors.ConfigTypeError.Error())
+	}
+	return values[0]
+}
+
+func (n descx) GetMulti(count int64) int64 {
+	v := n.DefaultSheet("Multiplier")
+	values, ok := v.([]*structs.SugarRushMultiplier)
+	if !ok {
+		panic(errors.ConfigTypeError.Error())
+	}
+	for _, v := range values {
+		if v.MatchTimes == count {
+			return v.Multiple
+		}
+	}
+	// return last one
+	return values[len(values)-1].Multiple
+}
+
+func (n descx) RandScatterCount() int64 {
+	v := n.Sheet("BuyFreeScatterShow", "Weight")
+
+	values, ok := v.([]*structs.SugarRushBuyFreeScatterShowWeight)
+	if !ok {
+		panic(errors.ConfigTypeError.Error())
+	}
+
+	weights := make([]float64, 0)
+	for _, v := range values {
+		weights = append(weights, v.Weight)
+	}
+	index := randx.RandWeight(n.Randx, weights)
+
+	return values[index].ScatterCount
+}
+
+func (n descx) RandItemID(topItemID int64, isFree bool, isTop bool) int64 {
+	if isFree {
+		v := n.Sheet("FreeSymbolShow", "Weight")
+
+		values, ok := v.([]*structs.SugarRushFreeSymbolShowWeight)
+		if !ok {
+			panic(errors.ConfigTypeError.Error())
+		}
+
+		typeWeights := make([]float64, 0)
+
+		for _, v := range values {
+			if v.ItemID == topItemID {
+				if isTop {
+					typeWeights = append(typeWeights, v.Weight*float64(n.GetOtherConfig().FallWeightMultiplier))
+				} else {
+					typeWeights = append(typeWeights, 0)
+				}
+			} else {
+				typeWeights = append(typeWeights, v.Weight)
+			}
+		}
+
+		value := randx.RandWeight(n.Randx, typeWeights)
+		return values[value].ItemID
+	}
+
+	v := n.Sheet("BaseSymbolShow", "Weight")
+
+	values, ok := v.([]*structs.SugarRushBaseSymbolShowWeight)
+	if !ok {
+		panic(errors.ConfigTypeError.Error())
+	}
+
+	typeWeights := make([]float64, 0)
+
+	for _, v := range values {
+		if v.ItemID == topItemID {
+			if isTop {
+				typeWeights = append(typeWeights, v.Weight*float64(n.GetOtherConfig().FallWeightMultiplier))
+			} else {
+				typeWeights = append(typeWeights, 0)
+			}
+		} else {
+			typeWeights = append(typeWeights, v.Weight)
+		}
+	}
+
+	value := randx.RandWeight(n.Randx, typeWeights)
+	return values[value].ItemID
+}
+
+func (n descx) RandItemCount(itemID int64, left int64, isFree bool) int64 {
+	if isFree {
+		v := n.Sheet("FreeSymbolShowNumber", "Weight")
+
+		values, ok := v.([]*structs.SugarRushFreeSymbolShowNumberWeight)
+		if !ok {
+			panic(errors.ConfigTypeError.Error())
+		}
+
+		for _, v := range values {
+			if v.ItemID == itemID {
+				typeWeights := make([]float64, 0)
+				typeWeights = append(typeWeights, v.ShowNumberWeight...)
+
+				value := randx.RandWeight(n.Randx, typeWeights)
+				count := int64(value) + 1
+				if count > left {
+					return left
+				}
+				return count
+			}
+		}
+
+		return 0
+	}
+
+	v := n.Sheet("BaseSymbolShowNumber", "Weight")
+
+	values, ok := v.([]*structs.SugarRushBaseSymbolShowNumberWeight)
+	if !ok {
+		panic(errors.ConfigTypeError.Error())
+	}
+
+	for _, v := range values {
+		if v.ItemID == itemID {
+			typeWeights := make([]float64, 0)
+			typeWeights = append(typeWeights, v.ShowNumberWeight...)
+
+			value := randx.RandWeight(n.Randx, typeWeights)
+			count := int64(value) + 1
+			if count > left {
+				return left
+			}
+			return count
+		}
+	}
+
+	return 0
+}

gamesrv/slotspkg/slots/plugin/sugarrush/free_spin.go

@@ -0,0 +1,89 @@
+package sugarrush
+
+import (
+	"github.com/tomas-qstarrs/boost/mathx"
+	"mongo.games.com/game/gamesrv/slotspkg/internal/generic/key"
+	"mongo.games.com/game/gamesrv/slotspkg/slots/intf"
+	"mongo.games.com/game/gamesrv/slotspkg/slots/plugin/generic"
+)
+
+// PluginFreeSpin is derived from generic.PluginBase
+type PluginFreeSpin struct {
+	generic.PluginScatter
+}
+
+// Theme implements generic.PluginBase.Theme
+func (p *PluginFreeSpin) Theme() string {
+	return key.SugarRush
+}
+
+// Customs implements generic.PluginBase.Customs
+func (p *PluginFreeSpin) Customs() []interface{} {
+	return []interface{}{}
+}
+
+// AfterSpin implements generic.PluginBase.AfterSpin
+func (p *PluginFreeSpin) AfterSpin(m intf.Master) {
+	switch m.Cursor().GetType() {
+	case key.BaseSpin:
+		p.AfterBaseSpin(m)
+	case key.FreeSpin:
+		p.AfterFreeSpin(m)
+	}
+}
+
+// AfterBaseSpin is called after base spin
+func (p *PluginFreeSpin) AfterBaseSpin(m intf.Master) {
+	addTimes, win := p.GetScatterInfo(m, false)
+	if addTimes > 0 {
+		m.AddNodeOnCursor(key.FreeSpin, addTimes)
+	}
+	if win > 0 {
+		m.AddCursorFeature(&generic.CustomScatterWin{}).SetWin(win)
+	}
+}
+
+// AfterFreeSpin is called after free spin
+func (p *PluginFreeSpin) AfterFreeSpin(m intf.Master) {
+	addTimes, win := p.GetScatterInfo(m, true)
+	if addTimes > 0 {
+		m.AddProgress(addTimes)
+		m.AddCursorFeature(&generic.CustomExtraFreeSpin{ExtraTimes: addTimes}).SetLifetime(1)
+	}
+	if win > 0 {
+		m.AddCursorFeature(&generic.CustomScatterWin{}).SetWin(win)
+	}
+}
+
+// GetScatterInfo gets add free spin times & pay rate
+func (p *PluginFreeSpin) GetScatterInfo(m intf.Master, inFreeSpin bool) (int64, int64) {
+	var scatterCount int64
+	symbols := m.CursorFormation().GetFinalSymbols()
+	scatterSymbols := p.Scatters(m)
+	for _, scatterSymbol := range scatterSymbols {
+		scatterCount += int64(mathx.Count(scatterSymbol, symbols))
+	}
+
+	if scatterCount == 0 {
+		return 0, 0
+	}
+
+	freeSpinCount := generic.Descx(m).FreeSpin(inFreeSpin, scatterCount)
+
+	payRate := generic.Descx(m).ScatterPayRate(inFreeSpin, scatterCount)
+
+	win := m.Bet() * payRate
+
+	return freeSpinCount, win
+}
+
+// OnStepEnd is called on finalizing a step
+func (p *PluginFreeSpin) OnStepEnd(m intf.Master) {
+	nextType := m.Next().GetType()
+
+	if m.Cursor().GetType() == key.FreeSpin && nextType == key.BaseSpin {
+		formation := m.NodeFormation(m.Next().GetID())
+		initSymbols := m.CursorFormation().GetFinalSymbols()
+		formation.SetInitSymbols(initSymbols)
+	}
+}

gamesrv/slotspkg/slots/plugin/sugarrush/init.go

@@ -0,0 +1,9 @@
+package sugarrush
+
+var Plugins = []interface{}{
+	&PluginBaseSpin{},
+	&PluginFreeSpin{},
+	&PluginChooseWheel{},
+}
+
+var SimulatorPlugins = []interface{}{}