data up

gamesrv/fortuneox/scenepolicy_fortuneox.go

@@ -408,7 +408,10 @@ func (this *SceneStateStartFortuneOx) OnPlayerOp(s *base.Scene, p *base.Player,
 					data = assemble.DataToCli(Response).(assemble.GameEnd)
 					var respinStatus int
 					if data.Results[0].ArrSpins[0].Special != nil {
-						respinStatus = data.Results[0].ArrSpins[0].Special.(SpinLock).ReSpinStatus
+						sp, _ := json.Marshal(data.Results[0].ArrSpins[0].Special)
+						var spinLock SpinLock
+						json.Unmarshal(sp, &spinLock)
+						respinStatus = spinLock.ReSpinStatus
 					}
 					if respinStatus == 0 || respinStatus == 1 {
 						//第一次触发或者正常模式

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

@@ -9,170 +9,170 @@ import "mongo.games.com/game/gamesrv/slotspkg/internal/exported/excel2go/structs
 func init() {
 	FortuneDragonBaseMultiplier = []*structs.FortuneDragonBaseMultiplier{
 		{
-			WinRateMin:        0,
-			WinRateMax:        0.01,
-			ItemIds:           []int64{200, 8, 9, 10},
+			WinRateMin: 0,
+			WinRateMax: 0.01,
+			ItemIds: []int64{200, 8, 9, 10},
 			MultiplierWeights: []int64{140, 10, 20, 10},
 		},
 		{
-			WinRateMin:        0.01,
-			WinRateMax:        1,
-			ItemIds:           []int64{200, 8, 9, 10},
+			WinRateMin: 0.01,
+			WinRateMax: 1,
+			ItemIds: []int64{200, 8, 9, 10},
 			MultiplierWeights: []int64{1689, 98, 176, 100},
 		},
 		{
-			WinRateMin:        1,
-			WinRateMax:        3,
-			ItemIds:           []int64{200, 8, 9, 10},
+			WinRateMin: 1,
+			WinRateMax: 3,
+			ItemIds: []int64{200, 8, 9, 10},
 			MultiplierWeights: []int64{60, 8, 10, 2},
 		},
 		{
-			WinRateMin:        3,
-			WinRateMax:        10,
-			ItemIds:           []int64{200, 8, 9, 10},
+			WinRateMin: 3,
+			WinRateMax: 10,
+			ItemIds: []int64{200, 8, 9, 10},
 			MultiplierWeights: []int64{2883, 100, 100, 250},
 		},
 		{
-			WinRateMin:        10,
-			WinRateMax:        20,
-			ItemIds:           []int64{200, 8, 9, 10},
+			WinRateMin: 10,
+			WinRateMax: 20,
+			ItemIds: []int64{200, 8, 9, 10},
 			MultiplierWeights: []int64{820, 1585, 100, 10},
 		},
 		{
-			WinRateMin:        20,
-			WinRateMax:        999999,
-			ItemIds:           []int64{200, 8, 9, 10},
+			WinRateMin: 20,
+			WinRateMax: 999999,
+			ItemIds: []int64{200, 8, 9, 10},
 			MultiplierWeights: []int64{2884, 8, 10, 287},
 		},
 	}
 
 	FortuneDragonBetBetChangeList = map[int64]*structs.FortuneDragonBetBetChangeList{
 		0: {
-			Index:         0,
+			Index: 0,
 			BetChangeList: 150000,
-			BetSizeIndex:  0,
+			BetSizeIndex: 0,
 			BetLevelIndex: 0,
 		},
 		1: {
-			Index:         1,
+			Index: 1,
 			BetChangeList: 300000,
-			BetSizeIndex:  0,
+			BetSizeIndex: 0,
 			BetLevelIndex: 1,
 		},
 		2: {
-			Index:         2,
+			Index: 2,
 			BetChangeList: 450000,
-			BetSizeIndex:  0,
+			BetSizeIndex: 0,
 			BetLevelIndex: 2,
 		},
 		3: {
-			Index:         3,
+			Index: 3,
 			BetChangeList: 500000,
-			BetSizeIndex:  1,
+			BetSizeIndex: 1,
 			BetLevelIndex: 0,
 		},
 		4: {
-			Index:         4,
+			Index: 4,
 			BetChangeList: 750000,
-			BetSizeIndex:  0,
+			BetSizeIndex: 0,
 			BetLevelIndex: 4,
 		},
 		5: {
-			Index:         5,
+			Index: 5,
 			BetChangeList: 1500000,
-			BetSizeIndex:  0,
+			BetSizeIndex: 0,
 			BetLevelIndex: 9,
 		},
 		6: {
-			Index:         6,
+			Index: 6,
 			BetChangeList: 2500000,
-			BetSizeIndex:  1,
+			BetSizeIndex: 1,
 			BetLevelIndex: 4,
 		},
 		7: {
-			Index:         7,
+			Index: 7,
 			BetChangeList: 4500000,
-			BetSizeIndex:  3,
+			BetSizeIndex: 3,
 			BetLevelIndex: 0,
 		},
 		8: {
-			Index:         8,
+			Index: 8,
 			BetChangeList: 5000000,
-			BetSizeIndex:  1,
+			BetSizeIndex: 1,
 			BetLevelIndex: 9,
 		},
 		9: {
-			Index:         9,
+			Index: 9,
 			BetChangeList: 7500000,
-			BetSizeIndex:  2,
+			BetSizeIndex: 2,
 			BetLevelIndex: 4,
 		},
 		10: {
-			Index:         10,
+			Index: 10,
 			BetChangeList: 15000000,
-			BetSizeIndex:  2,
+			BetSizeIndex: 2,
 			BetLevelIndex: 9,
 		},
 		11: {
-			Index:         11,
+			Index: 11,
 			BetChangeList: 22500000,
-			BetSizeIndex:  3,
+			BetSizeIndex: 3,
 			BetLevelIndex: 4,
 		},
 		12: {
-			Index:         12,
+			Index: 12,
 			BetChangeList: 45000000,
-			BetSizeIndex:  3,
+			BetSizeIndex: 3,
 			BetLevelIndex: 9,
 		},
 	}
 
 	FortuneDragonBetBetLevel = map[int64]*structs.FortuneDragonBetBetLevel{
 		0: {
-			Index:    0,
+			Index: 0,
 			BetLevel: 1,
 		},
 		1: {
-			Index:    1,
+			Index: 1,
 			BetLevel: 2,
 		},
 		2: {
-			Index:    2,
+			Index: 2,
 			BetLevel: 3,
 		},
 		3: {
-			Index:    3,
+			Index: 3,
 			BetLevel: 4,
 		},
 		4: {
-			Index:    4,
+			Index: 4,
 			BetLevel: 5,
 		},
 		5: {
-			Index:    5,
+			Index: 5,
 			BetLevel: 6,
 		},
 		6: {
-			Index:    6,
+			Index: 6,
 			BetLevel: 7,
 		},
 		7: {
-			Index:    7,
+			Index: 7,
 			BetLevel: 8,
 		},
 		8: {
-			Index:    8,
+			Index: 8,
 			BetLevel: 9,
 		},
 		9: {
-			Index:    9,
+			Index: 9,
 			BetLevel: 10,
 		},
 	}
 
 	FortuneDragonBetBetLine = map[int64]*structs.FortuneDragonBetBetLine{
 		0: {
-			Index:   0,
+			Index: 0,
 			BetLine: 5,
 			BaseBet: 1,
 		},
@@ -180,81 +180,81 @@ func init() {
 
 	FortuneDragonBetBetSize = map[int64]*structs.FortuneDragonBetBetSize{
 		0: {
-			Index:   0,
+			Index: 0,
 			BetSize: 300000000,
 		},
 		1: {
-			Index:   1,
+			Index: 1,
 			BetSize: 1000000000,
 		},
 		2: {
-			Index:   2,
+			Index: 2,
 			BetSize: 3000000000,
 		},
 		3: {
-			Index:   3,
+			Index: 3,
 			BetSize: 9000000000,
 		},
 	}
 
 	FortuneDragonBetFirstBet = map[int64]*structs.FortuneDragonBetFirstBet{
 		1: {
-			Index:         1,
-			BetSizeIndex:  1,
+			Index: 1,
+			BetSizeIndex: 1,
 			BetLevelIndex: 1,
 		},
 	}
 
 	FortuneDragonFormation = []*structs.FortuneDragonFormation{
 		{
-			SpinType:         1,
-			NodeType:         "BaseSpin",
-			ID:               1,
-			SeqID:            1,
-			Reel:             "BaseSpin",
-			Matrix:           "Line5Form3X3TypeB",
-			Symbol:           "Default",
-			FirstInitMethod:  2,
-			OtherInitMethod:  4,
+			SpinType: 1,
+			NodeType: "BaseSpin",
+			ID: 1,
+			SeqID: 1,
+			Reel: "BaseSpin",
+			Matrix: "Line5Form3X3TypeB",
+			Symbol: "Default",
+			FirstInitMethod: 2,
+			OtherInitMethod: 4,
 			FirstInitSymbols: []int64{},
 			OtherInitSymbols: []int64{},
 		},
 		{
-			SpinType:         3,
-			NodeType:         "FreeSpin",
-			ID:               1,
-			SeqID:            1,
-			Reel:             "FreeSpin",
-			Matrix:           "Line5Form3X3TypeB",
-			Symbol:           "Default",
-			FirstInitMethod:  2,
-			OtherInitMethod:  2,
+			SpinType: 3,
+			NodeType: "FreeSpin",
+			ID: 1,
+			SeqID: 1,
+			Reel: "FreeSpin",
+			Matrix: "Line5Form3X3TypeB",
+			Symbol: "Default",
+			FirstInitMethod: 2,
+			OtherInitMethod: 2,
 			FirstInitSymbols: []int64{},
 			OtherInitSymbols: []int64{},
 		},
 		{
-			SpinType:         1,
-			NodeType:         "SureWinBaseSpin",
-			ID:               1,
-			SeqID:            1,
-			Reel:             "SureWinBaseSpin",
-			Matrix:           "Line5Form3X3TypeB",
-			Symbol:           "Default",
-			FirstInitMethod:  2,
-			OtherInitMethod:  4,
+			SpinType: 1,
+			NodeType: "SureWinBaseSpin",
+			ID: 1,
+			SeqID: 1,
+			Reel: "SureWinBaseSpin",
+			Matrix: "Line5Form3X3TypeB",
+			Symbol: "Default",
+			FirstInitMethod: 2,
+			OtherInitMethod: 4,
 			FirstInitSymbols: []int64{},
 			OtherInitSymbols: []int64{},
 		},
 		{
-			SpinType:         3,
-			NodeType:         "SureWinFreeSpin",
-			ID:               1,
-			SeqID:            1,
-			Reel:             "SureWinFreeSpin",
-			Matrix:           "Line5Form3X3TypeB",
-			Symbol:           "Default",
-			FirstInitMethod:  2,
-			OtherInitMethod:  2,
+			SpinType: 3,
+			NodeType: "SureWinFreeSpin",
+			ID: 1,
+			SeqID: 1,
+			Reel: "SureWinFreeSpin",
+			Matrix: "Line5Form3X3TypeB",
+			Symbol: "Default",
+			FirstInitMethod: 2,
+			OtherInitMethod: 2,
 			FirstInitSymbols: []int64{},
 			OtherInitSymbols: []int64{},
 		},
@@ -278,11 +278,11 @@ func init() {
 	FortuneDragonFreeMultiplierCount = []*structs.FortuneDragonFreeMultiplierCount{
 		{
 			MultiplierCount: 2,
-			Weight:          3,
+			Weight: 3,
 		},
 		{
 			MultiplierCount: 3,
-			Weight:          1,
+			Weight: 1,
 		},
 	}
 
@@ -291,44 +291,44 @@ func init() {
 			ID: 1,
 			TypeWeight: map[int64]*structs.FortuneDragonMapRTPModeTypeWeight{
 				1: {
-					ID:     1,
+					ID: 1,
 					Weight: 1,
 				},
 			},
 			Desc: "96",
-			Rtp:  0.96,
+			Rtp: 0.96,
 		},
 		2: {
 			ID: 2,
 			TypeWeight: map[int64]*structs.FortuneDragonMapRTPModeTypeWeight{
 				1: {
-					ID:     1,
+					ID: 1,
 					Weight: 1,
 				},
 			},
 			Desc: "80",
-			Rtp:  0.8,
+			Rtp: 0.8,
 		},
 		3: {
 			ID: 3,
 			TypeWeight: map[int64]*structs.FortuneDragonMapRTPModeTypeWeight{
 				1: {
-					ID:     1,
+					ID: 1,
 					Weight: 1,
 				},
 			},
 			Desc: "120",
-			Rtp:  1.2,
+			Rtp: 1.2,
 		},
 	}
 
 	FortuneDragonOthers = []*structs.FortuneDragonOthers{
 		{
-			FreespinTriggerPro:        0.005,
-			FreeSpinCount:             8,
-			MaxWin:                    2500,
+			FreespinTriggerPro: 0.005,
+			FreeSpinCount: 8,
+			MaxWin: 2500,
 			SureWinFreespinTriggerPro: 0.0273,
-			SureWinBetMultiplier:      5,
+			SureWinBetMultiplier: 5,
 		},
 	}
 
@@ -398,103 +398,103 @@ func init() {
 
 	FortuneDragonSymbol = map[int64]*structs.FortuneDragonSymbol{
 		1: {
-			ID:          1,
-			Name:        "Wild",
-			IsWild:      true,
-			Group:       []int64{1},
-			PayRate:     []int64{0, 0, 100},
+			ID: 1,
+			Name: "Wild",
+			IsWild: true,
+			Group: []int64{1},
+			PayRate: []int64{0, 0, 100},
 			ClientOrder: 0,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		2: {
-			ID:          2,
-			Name:        "元宝",
-			IsWild:      false,
-			Group:       []int64{2},
-			PayRate:     []int64{0, 0, 50},
+			ID: 2,
+			Name: "元宝",
+			IsWild: false,
+			Group: []int64{2},
+			PayRate: []int64{0, 0, 50},
 			ClientOrder: 0,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		3: {
-			ID:          3,
-			Name:        "红包",
-			IsWild:      false,
-			Group:       []int64{3},
-			PayRate:     []int64{0, 0, 25},
+			ID: 3,
+			Name: "红包",
+			IsWild: false,
+			Group: []int64{3},
+			PayRate: []int64{0, 0, 25},
 			ClientOrder: 0,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		4: {
-			ID:          4,
-			Name:        "灯笼",
-			IsWild:      false,
-			Group:       []int64{4},
-			PayRate:     []int64{0, 0, 10},
+			ID: 4,
+			Name: "灯笼",
+			IsWild: false,
+			Group: []int64{4},
+			PayRate: []int64{0, 0, 10},
 			ClientOrder: 0,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		5: {
-			ID:          5,
-			Name:        "福炮",
-			IsWild:      false,
-			Group:       []int64{5},
-			PayRate:     []int64{0, 0, 5},
+			ID: 5,
+			Name: "福炮",
+			IsWild: false,
+			Group: []int64{5},
+			PayRate: []int64{0, 0, 5},
 			ClientOrder: 0,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		6: {
-			ID:          6,
-			Name:        "花结",
-			IsWild:      false,
-			Group:       []int64{6},
-			PayRate:     []int64{0, 0, 3},
+			ID: 6,
+			Name: "花结",
+			IsWild: false,
+			Group: []int64{6},
+			PayRate: []int64{0, 0, 3},
 			ClientOrder: 0,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		7: {
-			ID:          7,
-			Name:        "铜钱",
-			IsWild:      false,
-			Group:       []int64{7},
-			PayRate:     []int64{0, 0, 2},
+			ID: 7,
+			Name: "铜钱",
+			IsWild: false,
+			Group: []int64{7},
+			PayRate: []int64{0, 0, 2},
 			ClientOrder: 0,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		8: {
-			ID:          8,
-			Name:        "X2",
-			IsWild:      false,
-			Group:       []int64{8},
-			PayRate:     []int64{0, 0, 0},
+			ID: 8,
+			Name: "X2",
+			IsWild: false,
+			Group: []int64{8},
+			PayRate: []int64{0, 0, 0},
 			ClientOrder: 0,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		9: {
-			ID:          9,
-			Name:        "X5",
-			IsWild:      false,
-			Group:       []int64{8},
-			PayRate:     []int64{0, 0, 0},
+			ID: 9,
+			Name: "X5",
+			IsWild: false,
+			Group: []int64{8},
+			PayRate: []int64{0, 0, 0},
 			ClientOrder: 0,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		10: {
-			ID:          10,
-			Name:        "X10",
-			IsWild:      false,
-			Group:       []int64{8},
-			PayRate:     []int64{0, 0, 0},
+			ID: 10,
+			Name: "X10",
+			IsWild: false,
+			Group: []int64{8},
+			PayRate: []int64{0, 0, 0},
 			ClientOrder: 0,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		200: {
-			ID:          200,
-			Name:        "Empty",
-			IsWild:      false,
-			Group:       []int64{8},
-			PayRate:     []int64{0, 0, 0},
+			ID: 200,
+			Name: "Empty",
+			IsWild: false,
+			Group: []int64{8},
+			PayRate: []int64{0, 0, 0},
 			ClientOrder: 0,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 	}
 
@@ -504,4 +504,4 @@ func init() {
 		},
 	}
 
-}
+}

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

@@ -9,131 +9,131 @@ import "mongo.games.com/game/gamesrv/slotspkg/internal/exported/excel2go/structs
 func init() {
 	FortuneMouseBetBetChangeList = map[int64]*structs.FortuneMouseBetBetChangeList{
 		0: {
-			Index:         0,
+			Index: 0,
 			BetChangeList: 0.15,
-			BetSizeIndex:  0,
+			BetSizeIndex: 0,
 			BetLevelIndex: 0,
 		},
 		1: {
-			Index:         1,
+			Index: 1,
 			BetChangeList: 0.3,
-			BetSizeIndex:  0,
+			BetSizeIndex: 0,
 			BetLevelIndex: 1,
 		},
 		2: {
-			Index:         2,
+			Index: 2,
 			BetChangeList: 0.45,
-			BetSizeIndex:  0,
+			BetSizeIndex: 0,
 			BetLevelIndex: 2,
 		},
 		3: {
-			Index:         3,
+			Index: 3,
 			BetChangeList: 0.5,
-			BetSizeIndex:  1,
+			BetSizeIndex: 1,
 			BetLevelIndex: 0,
 		},
 		4: {
-			Index:         4,
+			Index: 4,
 			BetChangeList: 0.75,
-			BetSizeIndex:  0,
+			BetSizeIndex: 0,
 			BetLevelIndex: 4,
 		},
 		5: {
-			Index:         5,
+			Index: 5,
 			BetChangeList: 1.5,
-			BetSizeIndex:  0,
+			BetSizeIndex: 0,
 			BetLevelIndex: 9,
 		},
 		6: {
-			Index:         6,
+			Index: 6,
 			BetChangeList: 2.5,
-			BetSizeIndex:  1,
+			BetSizeIndex: 1,
 			BetLevelIndex: 4,
 		},
 		7: {
-			Index:         7,
+			Index: 7,
 			BetChangeList: 4.5,
-			BetSizeIndex:  3,
+			BetSizeIndex: 3,
 			BetLevelIndex: 0,
 		},
 		8: {
-			Index:         8,
+			Index: 8,
 			BetChangeList: 5,
-			BetSizeIndex:  1,
+			BetSizeIndex: 1,
 			BetLevelIndex: 9,
 		},
 		9: {
-			Index:         9,
+			Index: 9,
 			BetChangeList: 7.5,
-			BetSizeIndex:  2,
+			BetSizeIndex: 2,
 			BetLevelIndex: 4,
 		},
 		10: {
-			Index:         10,
+			Index: 10,
 			BetChangeList: 15,
-			BetSizeIndex:  2,
+			BetSizeIndex: 2,
 			BetLevelIndex: 9,
 		},
 		11: {
-			Index:         11,
+			Index: 11,
 			BetChangeList: 22.5,
-			BetSizeIndex:  3,
+			BetSizeIndex: 3,
 			BetLevelIndex: 4,
 		},
 		12: {
-			Index:         12,
+			Index: 12,
 			BetChangeList: 45,
-			BetSizeIndex:  3,
+			BetSizeIndex: 3,
 			BetLevelIndex: 9,
 		},
 	}
 
 	FortuneMouseBetBetLevel = map[int64]*structs.FortuneMouseBetBetLevel{
 		0: {
-			Index:    0,
+			Index: 0,
 			BetLevel: 1,
 		},
 		1: {
-			Index:    1,
+			Index: 1,
 			BetLevel: 2,
 		},
 		2: {
-			Index:    2,
+			Index: 2,
 			BetLevel: 3,
 		},
 		3: {
-			Index:    3,
+			Index: 3,
 			BetLevel: 4,
 		},
 		4: {
-			Index:    4,
+			Index: 4,
 			BetLevel: 5,
 		},
 		5: {
-			Index:    5,
+			Index: 5,
 			BetLevel: 6,
 		},
 		6: {
-			Index:    6,
+			Index: 6,
 			BetLevel: 7,
 		},
 		7: {
-			Index:    7,
+			Index: 7,
 			BetLevel: 8,
 		},
 		8: {
-			Index:    8,
+			Index: 8,
 			BetLevel: 9,
 		},
 		9: {
-			Index:    9,
+			Index: 9,
 			BetLevel: 10,
 		},
 	}
 
 	FortuneMouseBetBetLine = map[int64]*structs.FortuneMouseBetBetLine{
 		0: {
-			Index:   0,
+			Index: 0,
 			BetLine: 5,
 			BaseBet: 1,
 		},
@@ -141,55 +141,55 @@ func init() {
 
 	FortuneMouseBetBetSize = map[int64]*structs.FortuneMouseBetBetSize{
 		0: {
-			Index:   0,
+			Index: 0,
 			BetSize: 300,
 		},
 		1: {
-			Index:   1,
+			Index: 1,
 			BetSize: 1000,
 		},
 		2: {
-			Index:   2,
+			Index: 2,
 			BetSize: 3000,
 		},
 		3: {
-			Index:   3,
+			Index: 3,
 			BetSize: 9000,
 		},
 	}
 
 	FortuneMouseBetFirstBet = map[int64]*structs.FortuneMouseBetFirstBet{
 		1: {
-			Index:         1,
-			BetSizeIndex:  1,
+			Index: 1,
+			BetSizeIndex: 1,
 			BetLevelIndex: 1,
 		},
 	}
 
 	FortuneMouseFormation = []*structs.FortuneMouseFormation{
 		{
-			SpinType:         1,
-			NodeType:         "BaseSpin",
-			ID:               1,
-			SeqID:            1,
-			Reel:             "BaseSpin",
-			Matrix:           "Line5Form3X3TypeB",
-			Symbol:           "Default",
-			FirstInitMethod:  2,
-			OtherInitMethod:  4,
+			SpinType: 1,
+			NodeType: "BaseSpin",
+			ID: 1,
+			SeqID: 1,
+			Reel: "BaseSpin",
+			Matrix: "Line5Form3X3TypeB",
+			Symbol: "Default",
+			FirstInitMethod: 2,
+			OtherInitMethod: 4,
 			FirstInitSymbols: []int64{},
 			OtherInitSymbols: []int64{},
 		},
 		{
-			SpinType:         3,
-			NodeType:         "ReSpin",
-			ID:               1,
-			SeqID:            1,
-			Reel:             "ReSpin",
-			Matrix:           "Line5Form3X3TypeB",
-			Symbol:           "Default",
-			FirstInitMethod:  3,
-			OtherInitMethod:  3,
+			SpinType: 3,
+			NodeType: "ReSpin",
+			ID: 1,
+			SeqID: 1,
+			Reel: "ReSpin",
+			Matrix: "Line5Form3X3TypeB",
+			Symbol: "Default",
+			FirstInitMethod: 3,
+			OtherInitMethod: 3,
 			FirstInitSymbols: []int64{},
 			OtherInitSymbols: []int64{},
 		},
@@ -200,42 +200,42 @@ func init() {
 			ID: 1,
 			TypeWeight: map[int64]*structs.FortuneMouseMapRTPModeTypeWeight{
 				1: {
-					ID:     1,
+					ID: 1,
 					Weight: 1,
 				},
 			},
 			Desc: "96",
-			Rtp:  0.96,
+			Rtp: 0.96,
 		},
 		2: {
 			ID: 2,
 			TypeWeight: map[int64]*structs.FortuneMouseMapRTPModeTypeWeight{
 				1: {
-					ID:     1,
+					ID: 1,
 					Weight: 1,
 				},
 			},
 			Desc: "80",
-			Rtp:  0.8,
+			Rtp: 0.8,
 		},
 		3: {
 			ID: 3,
 			TypeWeight: map[int64]*structs.FortuneMouseMapRTPModeTypeWeight{
 				1: {
-					ID:     1,
+					ID: 1,
 					Weight: 1,
 				},
 			},
 			Desc: "120",
-			Rtp:  1.2,
+			Rtp: 1.2,
 		},
 	}
 
 	FortuneMouseOthers = []*structs.FortuneMouseOthers{
 		{
 			RespinTriggerPro: 0.0123,
-			MaxWin:           1000,
-			ExtraWin:         700,
+			MaxWin: 1000,
+			ExtraWin: 700,
 		},
 	}
 
@@ -273,37 +273,37 @@ func init() {
 
 	FortuneMouseSuperStackWeight = []*structs.FortuneMouseSuperStackWeight{
 		{
-			ID:     1,
+			ID: 1,
 			ItemID: 1,
 			Weight: 0,
 		},
 		{
-			ID:     2,
+			ID: 2,
 			ItemID: 2,
 			Weight: 3,
 		},
 		{
-			ID:     3,
+			ID: 3,
 			ItemID: 3,
 			Weight: 5,
 		},
 		{
-			ID:     4,
+			ID: 4,
 			ItemID: 4,
 			Weight: 7,
 		},
 		{
-			ID:     5,
+			ID: 5,
 			ItemID: 5,
 			Weight: 8,
 		},
 		{
-			ID:     6,
+			ID: 6,
 			ItemID: 6,
 			Weight: 9,
 		},
 		{
-			ID:     7,
+			ID: 7,
 			ItemID: 7,
 			Weight: 10,
 		},
@@ -311,76 +311,76 @@ func init() {
 
 	FortuneMouseSymbol = map[int64]*structs.FortuneMouseSymbol{
 		1: {
-			ID:          1,
-			Name:        "wild",
-			IsWild:      true,
-			Group:       []int64{1},
-			PayRate:     []int64{0, 0, 300},
+			ID: 1,
+			Name: "wild",
+			IsWild: true,
+			Group: []int64{1},
+			PayRate: []int64{0, 0, 300},
 			ClientOrder: 1,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		2: {
-			ID:          2,
-			Name:        "倒福",
-			IsWild:      false,
-			Group:       []int64{2},
-			PayRate:     []int64{0, 0, 100},
+			ID: 2,
+			Name: "倒福",
+			IsWild: false,
+			Group: []int64{2},
+			PayRate: []int64{0, 0, 100},
 			ClientOrder: 2,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		3: {
-			ID:          3,
-			Name:        "红包",
-			IsWild:      false,
-			Group:       []int64{3},
-			PayRate:     []int64{0, 0, 50},
+			ID: 3,
+			Name: "红包",
+			IsWild: false,
+			Group: []int64{3},
+			PayRate: []int64{0, 0, 50},
 			ClientOrder: 3,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		4: {
-			ID:          4,
-			Name:        "钱袋",
-			IsWild:      false,
-			Group:       []int64{4},
-			PayRate:     []int64{0, 0, 30},
+			ID: 4,
+			Name: "钱袋",
+			IsWild: false,
+			Group: []int64{4},
+			PayRate: []int64{0, 0, 30},
 			ClientOrder: 4,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		5: {
-			ID:          5,
-			Name:        "爆竹",
-			IsWild:      false,
-			Group:       []int64{5},
-			PayRate:     []int64{0, 0, 15},
+			ID: 5,
+			Name: "爆竹",
+			IsWild: false,
+			Group: []int64{5},
+			PayRate: []int64{0, 0, 15},
 			ClientOrder: 5,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		6: {
-			ID:          6,
-			Name:        "橘子",
-			IsWild:      false,
-			Group:       []int64{6},
-			PayRate:     []int64{0, 0, 5},
+			ID: 6,
+			Name: "橘子",
+			IsWild: false,
+			Group: []int64{6},
+			PayRate: []int64{0, 0, 5},
 			ClientOrder: 6,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		7: {
-			ID:          7,
-			Name:        "花生",
-			IsWild:      false,
-			Group:       []int64{7},
-			PayRate:     []int64{0, 0, 3},
+			ID: 7,
+			Name: "花生",
+			IsWild: false,
+			Group: []int64{7},
+			PayRate: []int64{0, 0, 3},
 			ClientOrder: 7,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		8: {
-			ID:          8,
-			Name:        "SuperStack",
-			IsWild:      false,
-			Group:       []int64{8},
-			PayRate:     []int64{0, 0, 0},
+			ID: 8,
+			Name: "SuperStack",
+			IsWild: false,
+			Group: []int64{8},
+			PayRate: []int64{0, 0, 0},
 			ClientOrder: 0,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 	}
 
@@ -390,4 +390,4 @@ func init() {
 		},
 	}
 
-}
+}

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

@@ -9,131 +9,131 @@ import "mongo.games.com/game/gamesrv/slotspkg/internal/exported/excel2go/structs
 func init() {
 	FortuneOxBetBetChangeList = map[int64]*structs.FortuneOxBetBetChangeList{
 		0: {
-			Index:         0,
+			Index: 0,
 			BetChangeList: 300000,
-			BetSizeIndex:  0,
+			BetSizeIndex: 0,
 			BetLevelIndex: 0,
 		},
 		1: {
-			Index:         1,
+			Index: 1,
 			BetChangeList: 600000,
-			BetSizeIndex:  0,
+			BetSizeIndex: 0,
 			BetLevelIndex: 1,
 		},
 		2: {
-			Index:         2,
+			Index: 2,
 			BetChangeList: 900000,
-			BetSizeIndex:  0,
+			BetSizeIndex: 0,
 			BetLevelIndex: 2,
 		},
 		3: {
-			Index:         3,
+			Index: 3,
 			BetChangeList: 1000000,
-			BetSizeIndex:  1,
+			BetSizeIndex: 1,
 			BetLevelIndex: 0,
 		},
 		4: {
-			Index:         4,
+			Index: 4,
 			BetChangeList: 1500000,
-			BetSizeIndex:  0,
+			BetSizeIndex: 0,
 			BetLevelIndex: 4,
 		},
 		5: {
-			Index:         5,
+			Index: 5,
 			BetChangeList: 3000000,
-			BetSizeIndex:  0,
+			BetSizeIndex: 0,
 			BetLevelIndex: 9,
 		},
 		6: {
-			Index:         6,
+			Index: 6,
 			BetChangeList: 5000000,
-			BetSizeIndex:  1,
+			BetSizeIndex: 1,
 			BetLevelIndex: 4,
 		},
 		7: {
-			Index:         7,
+			Index: 7,
 			BetChangeList: 9000000,
-			BetSizeIndex:  3,
+			BetSizeIndex: 3,
 			BetLevelIndex: 0,
 		},
 		8: {
-			Index:         8,
+			Index: 8,
 			BetChangeList: 10000000,
-			BetSizeIndex:  1,
+			BetSizeIndex: 1,
 			BetLevelIndex: 9,
 		},
 		9: {
-			Index:         9,
+			Index: 9,
 			BetChangeList: 15000000,
-			BetSizeIndex:  2,
+			BetSizeIndex: 2,
 			BetLevelIndex: 4,
 		},
 		10: {
-			Index:         10,
+			Index: 10,
 			BetChangeList: 30000000,
-			BetSizeIndex:  2,
+			BetSizeIndex: 2,
 			BetLevelIndex: 9,
 		},
 		11: {
-			Index:         11,
+			Index: 11,
 			BetChangeList: 45000000,
-			BetSizeIndex:  3,
+			BetSizeIndex: 3,
 			BetLevelIndex: 4,
 		},
 		12: {
-			Index:         12,
+			Index: 12,
 			BetChangeList: 90000000,
-			BetSizeIndex:  3,
+			BetSizeIndex: 3,
 			BetLevelIndex: 9,
 		},
 	}
 
 	FortuneOxBetBetLevel = map[int64]*structs.FortuneOxBetBetLevel{
 		0: {
-			Index:    0,
+			Index: 0,
 			BetLevel: 1,
 		},
 		1: {
-			Index:    1,
+			Index: 1,
 			BetLevel: 2,
 		},
 		2: {
-			Index:    2,
+			Index: 2,
 			BetLevel: 3,
 		},
 		3: {
-			Index:    3,
+			Index: 3,
 			BetLevel: 4,
 		},
 		4: {
-			Index:    4,
+			Index: 4,
 			BetLevel: 5,
 		},
 		5: {
-			Index:    5,
+			Index: 5,
 			BetLevel: 6,
 		},
 		6: {
-			Index:    6,
+			Index: 6,
 			BetLevel: 7,
 		},
 		7: {
-			Index:    7,
+			Index: 7,
 			BetLevel: 8,
 		},
 		8: {
-			Index:    8,
+			Index: 8,
 			BetLevel: 9,
 		},
 		9: {
-			Index:    9,
+			Index: 9,
 			BetLevel: 10,
 		},
 	}
 
 	FortuneOxBetBetLine = map[int64]*structs.FortuneOxBetBetLine{
 		0: {
-			Index:   0,
+			Index: 0,
 			BetLine: 10,
 			BaseBet: 1,
 		},
@@ -141,55 +141,55 @@ func init() {
 
 	FortuneOxBetBetSize = map[int64]*structs.FortuneOxBetBetSize{
 		0: {
-			Index:   0,
+			Index: 0,
 			BetSize: 300000000,
 		},
 		1: {
-			Index:   1,
+			Index: 1,
 			BetSize: 1000000000,
 		},
 		2: {
-			Index:   2,
+			Index: 2,
 			BetSize: 3000000000,
 		},
 		3: {
-			Index:   3,
+			Index: 3,
 			BetSize: 9000000000,
 		},
 	}
 
 	FortuneOxBetFirstBet = map[int64]*structs.FortuneOxBetFirstBet{
 		1: {
-			Index:         1,
-			BetSizeIndex:  1,
-			BetLevelIndex: 0,
+			Index: 1,
+			BetSizeIndex: 1,
+			BetLevelIndex: 1,
 		},
 	}
 
 	FortuneOxFormation = []*structs.FortuneOxFormation{
 		{
-			SpinType:         1,
-			NodeType:         "BaseSpin",
-			ID:               1,
-			SeqID:            1,
-			Reel:             "BaseSpin",
-			Matrix:           "Line10Form343TypeA",
-			Symbol:           "Default",
-			FirstInitMethod:  2,
-			OtherInitMethod:  4,
+			SpinType: 1,
+			NodeType: "BaseSpin",
+			ID: 1,
+			SeqID: 1,
+			Reel: "BaseSpin",
+			Matrix: "Line10Form343TypeA",
+			Symbol: "Default",
+			FirstInitMethod: 2,
+			OtherInitMethod: 4,
 			FirstInitSymbols: []int64{},
 			OtherInitSymbols: []int64{},
 		},
 		{
-			SpinType:         3,
-			NodeType:         "ReSpin",
-			ID:               1,
-			SeqID:            1,
-			Reel:             "ReSpin",
-			Matrix:           "Line10Form343TypeA",
-			Symbol:           "Default",
-			FirstInitMethod:  3,
-			OtherInitMethod:  3,
+			SpinType: 3,
+			NodeType: "ReSpin",
+			ID: 1,
+			SeqID: 1,
+			Reel: "ReSpin",
+			Matrix: "Line10Form343TypeA",
+			Symbol: "Default",
+			FirstInitMethod: 3,
+			OtherInitMethod: 3,
 			FirstInitSymbols: []int64{},
 			OtherInitSymbols: []int64{},
 		},
@@ -200,42 +200,42 @@ func init() {
 			ID: 1,
 			TypeWeight: map[int64]*structs.FortuneOxMapRTPModeTypeWeight{
 				1: {
-					ID:     1,
+					ID: 1,
 					Weight: 1,
 				},
 			},
 			Desc: "96",
-			Rtp:  0.96,
+			Rtp: 0.96,
 		},
 		2: {
 			ID: 2,
 			TypeWeight: map[int64]*structs.FortuneOxMapRTPModeTypeWeight{
 				1: {
-					ID:     1,
+					ID: 1,
 					Weight: 1,
 				},
 			},
 			Desc: "80",
-			Rtp:  0.8,
+			Rtp: 0.8,
 		},
 		3: {
 			ID: 3,
 			TypeWeight: map[int64]*structs.FortuneOxMapRTPModeTypeWeight{
 				1: {
-					ID:     1,
+					ID: 1,
 					Weight: 1,
 				},
 			},
 			Desc: "120",
-			Rtp:  1.2,
+			Rtp: 1.2,
 		},
 	}
 
 	FortuneOxOthers = []*structs.FortuneOxOthers{
 		{
 			RespinTriggerPro: 0.0107,
-			Multiplier:       10,
-			MaxWin:           2000,
+			Multiplier: 10,
+			MaxWin: 2000,
 		},
 	}
 
@@ -273,37 +273,37 @@ func init() {
 
 	FortuneOxSuperStack1Weight = []*structs.FortuneOxSuperStack1Weight{
 		{
-			ID:     1,
+			ID: 1,
 			ItemID: 1,
 			Weight: 0,
 		},
 		{
-			ID:     2,
+			ID: 2,
 			ItemID: 2,
 			Weight: 1,
 		},
 		{
-			ID:     3,
+			ID: 3,
 			ItemID: 3,
 			Weight: 4,
 		},
 		{
-			ID:     4,
+			ID: 4,
 			ItemID: 4,
 			Weight: 10,
 		},
 		{
-			ID:     5,
+			ID: 5,
 			ItemID: 5,
 			Weight: 15,
 		},
 		{
-			ID:     6,
+			ID: 6,
 			ItemID: 6,
 			Weight: 30,
 		},
 		{
-			ID:     7,
+			ID: 7,
 			ItemID: 7,
 			Weight: 40,
 		},
@@ -311,37 +311,37 @@ func init() {
 
 	FortuneOxSuperStack2Weight = []*structs.FortuneOxSuperStack2Weight{
 		{
-			ID:     1,
+			ID: 1,
 			ItemID: 1,
 			Weight: 0,
 		},
 		{
-			ID:     2,
+			ID: 2,
 			ItemID: 2,
 			Weight: 1,
 		},
 		{
-			ID:     3,
+			ID: 3,
 			ItemID: 3,
 			Weight: 2,
 		},
 		{
-			ID:     4,
+			ID: 4,
 			ItemID: 4,
 			Weight: 3,
 		},
 		{
-			ID:     5,
+			ID: 5,
 			ItemID: 5,
 			Weight: 4,
 		},
 		{
-			ID:     6,
+			ID: 6,
 			ItemID: 6,
 			Weight: 5,
 		},
 		{
-			ID:     7,
+			ID: 7,
 			ItemID: 7,
 			Weight: 6,
 		},
@@ -349,85 +349,85 @@ func init() {
 
 	FortuneOxSymbol = map[int64]*structs.FortuneOxSymbol{
 		1: {
-			ID:          1,
-			Name:        "wild",
-			IsWild:      true,
-			Group:       []int64{1},
-			PayRate:     []int64{0, 0, 200},
+			ID: 1,
+			Name: "wild",
+			IsWild: true,
+			Group: []int64{1},
+			PayRate: []int64{0, 0, 200},
 			ClientOrder: 1,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		2: {
-			ID:          2,
-			Name:        "元宝",
-			IsWild:      false,
-			Group:       []int64{2},
-			PayRate:     []int64{0, 0, 100},
+			ID: 2,
+			Name: "元宝",
+			IsWild: false,
+			Group: []int64{2},
+			PayRate: []int64{0, 0, 100},
 			ClientOrder: 2,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		3: {
-			ID:          3,
-			Name:        "金锦盒",
-			IsWild:      false,
-			Group:       []int64{3},
-			PayRate:     []int64{0, 0, 50},
+			ID: 3,
+			Name: "金锦盒",
+			IsWild: false,
+			Group: []int64{3},
+			PayRate: []int64{0, 0, 50},
 			ClientOrder: 3,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		4: {
-			ID:          4,
-			Name:        "钱袋",
-			IsWild:      false,
-			Group:       []int64{4},
-			PayRate:     []int64{0, 0, 20},
+			ID: 4,
+			Name: "钱袋",
+			IsWild: false,
+			Group: []int64{4},
+			PayRate: []int64{0, 0, 20},
 			ClientOrder: 4,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		5: {
-			ID:          5,
-			Name:        "红包",
-			IsWild:      false,
-			Group:       []int64{5},
-			PayRate:     []int64{0, 0, 10},
+			ID: 5,
+			Name: "红包",
+			IsWild: false,
+			Group: []int64{5},
+			PayRate: []int64{0, 0, 10},
 			ClientOrder: 5,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		6: {
-			ID:          6,
-			Name:        "橘子",
-			IsWild:      false,
-			Group:       []int64{6},
-			PayRate:     []int64{0, 0, 5},
+			ID: 6,
+			Name: "橘子",
+			IsWild: false,
+			Group: []int64{6},
+			PayRate: []int64{0, 0, 5},
 			ClientOrder: 6,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		7: {
-			ID:          7,
-			Name:        "炮竹",
-			IsWild:      false,
-			Group:       []int64{7},
-			PayRate:     []int64{0, 0, 3},
+			ID: 7,
+			Name: "炮竹",
+			IsWild: false,
+			Group: []int64{7},
+			PayRate: []int64{0, 0, 3},
 			ClientOrder: 7,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		8: {
-			ID:          8,
-			Name:        "SuperStack1",
-			IsWild:      false,
-			Group:       []int64{8},
-			PayRate:     []int64{0, 0, 0},
+			ID: 8,
+			Name: "SuperStack1",
+			IsWild: false,
+			Group: []int64{8},
+			PayRate: []int64{0, 0, 0},
 			ClientOrder: 0,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		9: {
-			ID:          9,
-			Name:        "SuperStack2",
-			IsWild:      false,
-			Group:       []int64{9},
-			PayRate:     []int64{0, 0, 0},
+			ID: 9,
+			Name: "SuperStack2",
+			IsWild: false,
+			Group: []int64{9},
+			PayRate: []int64{0, 0, 0},
 			ClientOrder: 0,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 	}
 
@@ -437,4 +437,4 @@ func init() {
 		},
 	}
 
-}
+}

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

@@ -9,131 +9,131 @@ import "mongo.games.com/game/gamesrv/slotspkg/internal/exported/excel2go/structs
 func init() {
 	FortuneRabbitBetBetChangeList = map[int64]*structs.FortuneRabbitBetBetChangeList{
 		0: {
-			Index:         0,
+			Index: 0,
 			BetChangeList: 300000,
-			BetSizeIndex:  0,
+			BetSizeIndex: 0,
 			BetLevelIndex: 0,
 		},
 		1: {
-			Index:         1,
+			Index: 1,
 			BetChangeList: 600000,
-			BetSizeIndex:  0,
+			BetSizeIndex: 0,
 			BetLevelIndex: 1,
 		},
 		2: {
-			Index:         2,
+			Index: 2,
 			BetChangeList: 900000,
-			BetSizeIndex:  0,
+			BetSizeIndex: 0,
 			BetLevelIndex: 2,
 		},
 		3: {
-			Index:         3,
+			Index: 3,
 			BetChangeList: 1000000,
-			BetSizeIndex:  1,
+			BetSizeIndex: 1,
 			BetLevelIndex: 0,
 		},
 		4: {
-			Index:         4,
+			Index: 4,
 			BetChangeList: 1500000,
-			BetSizeIndex:  0,
+			BetSizeIndex: 0,
 			BetLevelIndex: 4,
 		},
 		5: {
-			Index:         5,
+			Index: 5,
 			BetChangeList: 3000000,
-			BetSizeIndex:  0,
+			BetSizeIndex: 0,
 			BetLevelIndex: 9,
 		},
 		6: {
-			Index:         6,
+			Index: 6,
 			BetChangeList: 5000000,
-			BetSizeIndex:  1,
+			BetSizeIndex: 1,
 			BetLevelIndex: 4,
 		},
 		7: {
-			Index:         7,
+			Index: 7,
 			BetChangeList: 9000000,
-			BetSizeIndex:  3,
+			BetSizeIndex: 3,
 			BetLevelIndex: 0,
 		},
 		8: {
-			Index:         8,
+			Index: 8,
 			BetChangeList: 10000000,
-			BetSizeIndex:  1,
+			BetSizeIndex: 1,
 			BetLevelIndex: 9,
 		},
 		9: {
-			Index:         9,
+			Index: 9,
 			BetChangeList: 15000000,
-			BetSizeIndex:  2,
+			BetSizeIndex: 2,
 			BetLevelIndex: 4,
 		},
 		10: {
-			Index:         10,
+			Index: 10,
 			BetChangeList: 30000000,
-			BetSizeIndex:  2,
+			BetSizeIndex: 2,
 			BetLevelIndex: 9,
 		},
 		11: {
-			Index:         11,
+			Index: 11,
 			BetChangeList: 45000000,
-			BetSizeIndex:  3,
+			BetSizeIndex: 3,
 			BetLevelIndex: 4,
 		},
 		12: {
-			Index:         12,
+			Index: 12,
 			BetChangeList: 90000000,
-			BetSizeIndex:  3,
+			BetSizeIndex: 3,
 			BetLevelIndex: 9,
 		},
 	}
 
 	FortuneRabbitBetBetLevel = map[int64]*structs.FortuneRabbitBetBetLevel{
 		0: {
-			Index:    0,
+			Index: 0,
 			BetLevel: 1,
 		},
 		1: {
-			Index:    1,
+			Index: 1,
 			BetLevel: 2,
 		},
 		2: {
-			Index:    2,
+			Index: 2,
 			BetLevel: 3,
 		},
 		3: {
-			Index:    3,
+			Index: 3,
 			BetLevel: 4,
 		},
 		4: {
-			Index:    4,
+			Index: 4,
 			BetLevel: 5,
 		},
 		5: {
-			Index:    5,
+			Index: 5,
 			BetLevel: 6,
 		},
 		6: {
-			Index:    6,
+			Index: 6,
 			BetLevel: 7,
 		},
 		7: {
-			Index:    7,
+			Index: 7,
 			BetLevel: 8,
 		},
 		8: {
-			Index:    8,
+			Index: 8,
 			BetLevel: 9,
 		},
 		9: {
-			Index:    9,
+			Index: 9,
 			BetLevel: 10,
 		},
 	}
 
 	FortuneRabbitBetBetLine = map[int64]*structs.FortuneRabbitBetBetLine{
 		0: {
-			Index:   0,
+			Index: 0,
 			BetLine: 10,
 			BaseBet: 1,
 		},
@@ -141,156 +141,156 @@ func init() {
 
 	FortuneRabbitBetBetSize = map[int64]*structs.FortuneRabbitBetBetSize{
 		0: {
-			Index:   0,
+			Index: 0,
 			BetSize: 300000000,
 		},
 		1: {
-			Index:   1,
+			Index: 1,
 			BetSize: 1000000000,
 		},
 		2: {
-			Index:   2,
+			Index: 2,
 			BetSize: 3000000000,
 		},
 		3: {
-			Index:   3,
+			Index: 3,
 			BetSize: 9000000000,
 		},
 	}
 
 	FortuneRabbitBetFirstBet = map[int64]*structs.FortuneRabbitBetFirstBet{
 		1: {
-			Index:         1,
-			BetSizeIndex:  1,
+			Index: 1,
+			BetSizeIndex: 1,
 			BetLevelIndex: 0,
 		},
 	}
 
 	FortuneRabbitCashPrizeWeight = []*structs.FortuneRabbitCashPrizeWeight{
 		{
-			ID:          1,
-			PrizeValue:  0.5,
-			Weight:      150,
+			ID: 1,
+			PrizeValue: 0.5,
+			Weight: 150,
 			NoWinWeight: 100,
 		},
 		{
-			ID:          2,
-			PrizeValue:  1,
-			Weight:      25,
+			ID: 2,
+			PrizeValue: 1,
+			Weight: 25,
 			NoWinWeight: 25,
 		},
 		{
-			ID:          3,
-			PrizeValue:  2,
-			Weight:      9,
+			ID: 3,
+			PrizeValue: 2,
+			Weight: 9,
 			NoWinWeight: 9,
 		},
 		{
-			ID:          4,
-			PrizeValue:  5,
-			Weight:      55,
+			ID: 4,
+			PrizeValue: 5,
+			Weight: 55,
 			NoWinWeight: 55,
 		},
 		{
-			ID:          5,
-			PrizeValue:  10,
-			Weight:      6,
+			ID: 5,
+			PrizeValue: 10,
+			Weight: 6,
 			NoWinWeight: 12,
 		},
 		{
-			ID:          6,
-			PrizeValue:  20,
-			Weight:      3,
+			ID: 6,
+			PrizeValue: 20,
+			Weight: 3,
 			NoWinWeight: 9,
 		},
 		{
-			ID:          7,
-			PrizeValue:  30,
-			Weight:      0.6,
+			ID: 7,
+			PrizeValue: 30,
+			Weight: 0.6,
 			NoWinWeight: 6,
 		},
 		{
-			ID:          8,
-			PrizeValue:  50,
-			Weight:      1,
+			ID: 8,
+			PrizeValue: 50,
+			Weight: 1,
 			NoWinWeight: 3,
 		},
 		{
-			ID:          9,
-			PrizeValue:  100,
-			Weight:      0.39,
+			ID: 9,
+			PrizeValue: 100,
+			Weight: 0.39,
 			NoWinWeight: 0.9,
 		},
 		{
-			ID:          10,
-			PrizeValue:  500,
-			Weight:      0.01,
+			ID: 10,
+			PrizeValue: 500,
+			Weight: 0.01,
 			NoWinWeight: 0.1,
 		},
 	}
 
 	FortuneRabbitForceCashCountWeight = []*structs.FortuneRabbitForceCashCountWeight{
 		{
-			ID:     1,
-			Count:  5,
+			ID: 1,
+			Count: 5,
 			Weight: 80,
 		},
 		{
-			ID:     2,
-			Count:  6,
+			ID: 2,
+			Count: 6,
 			Weight: 15,
 		},
 		{
-			ID:     3,
-			Count:  7,
+			ID: 3,
+			Count: 7,
 			Weight: 5,
 		},
 		{
-			ID:     4,
-			Count:  8,
+			ID: 4,
+			Count: 8,
 			Weight: 0,
 		},
 		{
-			ID:     5,
-			Count:  9,
+			ID: 5,
+			Count: 9,
 			Weight: 0,
 		},
 		{
-			ID:     6,
-			Count:  10,
+			ID: 6,
+			Count: 10,
 			Weight: 0,
 		},
 		{
-			ID:     7,
-			Count:  11,
+			ID: 7,
+			Count: 11,
 			Weight: 0,
 		},
 	}
 
 	FortuneRabbitFormation = []*structs.FortuneRabbitFormation{
 		{
-			SpinType:         1,
-			NodeType:         "BaseSpin",
-			ID:               1,
-			SeqID:            1,
-			Reel:             "BaseSpin",
-			Matrix:           "Line10Form343TypeA",
-			Symbol:           "Default",
-			FirstInitMethod:  2,
-			OtherInitMethod:  4,
+			SpinType: 1,
+			NodeType: "BaseSpin",
+			ID: 1,
+			SeqID: 1,
+			Reel: "BaseSpin",
+			Matrix: "Line10Form343TypeA",
+			Symbol: "Default",
+			FirstInitMethod: 2,
+			OtherInitMethod: 4,
 			FirstInitSymbols: []int64{},
 			OtherInitSymbols: []int64{},
 		},
 		{
-			SpinType:         3,
-			NodeType:         "FreeSpin",
-			ID:               1,
-			SeqID:            1,
-			Reel:             "FreeSpin",
-			Matrix:           "Line10Form343TypeA",
-			Symbol:           "Default",
-			FirstInitMethod:  3,
-			OtherInitMethod:  3,
+			SpinType: 3,
+			NodeType: "FreeSpin",
+			ID: 1,
+			SeqID: 1,
+			Reel: "FreeSpin",
+			Matrix: "Line10Form343TypeA",
+			Symbol: "Default",
+			FirstInitMethod: 3,
+			OtherInitMethod: 3,
 			FirstInitSymbols: []int64{},
 			OtherInitSymbols: []int64{},
 		},
@@ -301,58 +301,58 @@ func init() {
 			ID: 1,
 			TypeWeight: map[int64]*structs.FortuneRabbitMapRTPModeTypeWeight{
 				1: {
-					ID:     1,
+					ID: 1,
 					Weight: 1,
 				},
 			},
 			Desc: "96",
-			Rtp:  0.96,
+			Rtp: 0.96,
 		},
 		2: {
 			ID: 2,
 			TypeWeight: map[int64]*structs.FortuneRabbitMapRTPModeTypeWeight{
 				2: {
-					ID:     2,
+					ID: 2,
 					Weight: 1,
 				},
 			},
 			Desc: "80",
-			Rtp:  0.8,
+			Rtp: 0.8,
 		},
 		3: {
 			ID: 3,
 			TypeWeight: map[int64]*structs.FortuneRabbitMapRTPModeTypeWeight{
 				3: {
-					ID:     3,
+					ID: 3,
 					Weight: 1,
 				},
 			},
 			Desc: "120",
-			Rtp:  1.2,
+			Rtp: 1.2,
 		},
 	}
 
 	FortuneRabbitOthers = []*structs.FortuneRabbitOthers{
 		{
 			FreespinTriggerPro: 0.0106,
-			FreeSpinCount:      8,
-			MaxWin:             5000,
+			FreeSpinCount: 8,
+			MaxWin: 5000,
 		},
 	}
 
 	FortuneRabbitOthersRTP120 = []*structs.FortuneRabbitOthersRTP120{
 		{
 			FreespinTriggerPro: 0.01785,
-			FreeSpinCount:      8,
-			MaxWin:             5000,
+			FreeSpinCount: 8,
+			MaxWin: 5000,
 		},
 	}
 
 	FortuneRabbitOthersRTP80 = []*structs.FortuneRabbitOthersRTP80{
 		{
 			FreespinTriggerPro: 0.00577,
-			FreeSpinCount:      8,
-			MaxWin:             5000,
+			FreeSpinCount: 8,
+			MaxWin: 5000,
 		},
 	}
 
@@ -390,85 +390,85 @@ func init() {
 
 	FortuneRabbitSymbol = map[int64]*structs.FortuneRabbitSymbol{
 		1: {
-			ID:          1,
-			Name:        "wild",
-			IsWild:      true,
-			Group:       []int64{1},
-			PayRate:     []int64{0, 0, 200},
+			ID: 1,
+			Name: "wild",
+			IsWild: true,
+			Group: []int64{1},
+			PayRate: []int64{0, 0, 200},
 			ClientOrder: 1,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		2: {
-			ID:          2,
-			Name:        "元宝",
-			IsWild:      false,
-			Group:       []int64{2},
-			PayRate:     []int64{0, 0, 100},
+			ID: 2,
+			Name: "元宝",
+			IsWild: false,
+			Group: []int64{2},
+			PayRate: []int64{0, 0, 100},
 			ClientOrder: 2,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		3: {
-			ID:          3,
-			Name:        "钱袋",
-			IsWild:      false,
-			Group:       []int64{3},
-			PayRate:     []int64{0, 0, 50},
+			ID: 3,
+			Name: "钱袋",
+			IsWild: false,
+			Group: []int64{3},
+			PayRate: []int64{0, 0, 50},
 			ClientOrder: 3,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		4: {
-			ID:          4,
-			Name:        "红包",
-			IsWild:      false,
-			Group:       []int64{4},
-			PayRate:     []int64{0, 0, 10},
+			ID: 4,
+			Name: "红包",
+			IsWild: false,
+			Group: []int64{4},
+			PayRate: []int64{0, 0, 10},
 			ClientOrder: 4,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		5: {
-			ID:          5,
-			Name:        "铜币",
-			IsWild:      false,
-			Group:       []int64{5},
-			PayRate:     []int64{0, 0, 5},
+			ID: 5,
+			Name: "铜币",
+			IsWild: false,
+			Group: []int64{5},
+			PayRate: []int64{0, 0, 5},
 			ClientOrder: 5,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		6: {
-			ID:          6,
-			Name:        "爆竹",
-			IsWild:      false,
-			Group:       []int64{6},
-			PayRate:     []int64{0, 0, 3},
+			ID: 6,
+			Name: "爆竹",
+			IsWild: false,
+			Group: []int64{6},
+			PayRate: []int64{0, 0, 3},
 			ClientOrder: 6,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		7: {
-			ID:          7,
-			Name:        "胡萝卜",
-			IsWild:      false,
-			Group:       []int64{7},
-			PayRate:     []int64{0, 0, 2},
+			ID: 7,
+			Name: "胡萝卜",
+			IsWild: false,
+			Group: []int64{7},
+			PayRate: []int64{0, 0, 2},
 			ClientOrder: 7,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		8: {
-			ID:          8,
-			Name:        "Cash",
-			IsWild:      false,
-			Group:       []int64{8},
-			PayRate:     []int64{0, 0, 0},
+			ID: 8,
+			Name: "Cash",
+			IsWild: false,
+			Group: []int64{8},
+			PayRate: []int64{0, 0, 0},
 			ClientOrder: 0,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		200: {
-			ID:          200,
-			Name:        "Empty",
-			IsWild:      false,
-			Group:       []int64{200},
-			PayRate:     []int64{0, 0, 0},
+			ID: 200,
+			Name: "Empty",
+			IsWild: false,
+			Group: []int64{200},
+			PayRate: []int64{0, 0, 0},
 			ClientOrder: 0,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 	}
 
@@ -478,4 +478,4 @@ func init() {
 		},
 	}
 
-}
+}

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

@@ -9,131 +9,131 @@ import "mongo.games.com/game/gamesrv/slotspkg/internal/exported/excel2go/structs
 func init() {
 	FortuneTigerBetBetChangeList = map[int64]*structs.FortuneTigerBetBetChangeList{
 		0: {
-			Index:         0,
-			BetChangeList: 0.15,
-			BetSizeIndex:  0,
+			Index: 0,
+			BetChangeList: 150000,
+			BetSizeIndex: 0,
 			BetLevelIndex: 0,
 		},
 		1: {
-			Index:         1,
-			BetChangeList: 0.3,
-			BetSizeIndex:  0,
+			Index: 1,
+			BetChangeList: 300000,
+			BetSizeIndex: 0,
 			BetLevelIndex: 1,
 		},
 		2: {
-			Index:         2,
-			BetChangeList: 0.45,
-			BetSizeIndex:  0,
+			Index: 2,
+			BetChangeList: 450000,
+			BetSizeIndex: 0,
 			BetLevelIndex: 2,
 		},
 		3: {
-			Index:         3,
-			BetChangeList: 0.5,
-			BetSizeIndex:  1,
+			Index: 3,
+			BetChangeList: 500000,
+			BetSizeIndex: 1,
 			BetLevelIndex: 0,
 		},
 		4: {
-			Index:         4,
-			BetChangeList: 0.75,
-			BetSizeIndex:  0,
+			Index: 4,
+			BetChangeList: 750000,
+			BetSizeIndex: 0,
 			BetLevelIndex: 4,
 		},
 		5: {
-			Index:         5,
-			BetChangeList: 1.5,
-			BetSizeIndex:  0,
+			Index: 5,
+			BetChangeList: 1500000,
+			BetSizeIndex: 0,
 			BetLevelIndex: 9,
 		},
 		6: {
-			Index:         6,
-			BetChangeList: 2.5,
-			BetSizeIndex:  1,
+			Index: 6,
+			BetChangeList: 2500000,
+			BetSizeIndex: 1,
 			BetLevelIndex: 4,
 		},
 		7: {
-			Index:         7,
-			BetChangeList: 4.5,
-			BetSizeIndex:  3,
+			Index: 7,
+			BetChangeList: 4500000,
+			BetSizeIndex: 3,
 			BetLevelIndex: 0,
 		},
 		8: {
-			Index:         8,
-			BetChangeList: 5,
-			BetSizeIndex:  1,
+			Index: 8,
+			BetChangeList: 5000000,
+			BetSizeIndex: 1,
 			BetLevelIndex: 9,
 		},
 		9: {
-			Index:         9,
-			BetChangeList: 7.5,
-			BetSizeIndex:  2,
+			Index: 9,
+			BetChangeList: 7500000,
+			BetSizeIndex: 2,
 			BetLevelIndex: 4,
 		},
 		10: {
-			Index:         10,
-			BetChangeList: 15,
-			BetSizeIndex:  2,
+			Index: 10,
+			BetChangeList: 15000000,
+			BetSizeIndex: 2,
 			BetLevelIndex: 9,
 		},
 		11: {
-			Index:         11,
-			BetChangeList: 22.5,
-			BetSizeIndex:  3,
+			Index: 11,
+			BetChangeList: 22500000,
+			BetSizeIndex: 3,
 			BetLevelIndex: 4,
 		},
 		12: {
-			Index:         12,
-			BetChangeList: 45,
-			BetSizeIndex:  3,
+			Index: 12,
+			BetChangeList: 45000000,
+			BetSizeIndex: 3,
 			BetLevelIndex: 9,
 		},
 	}
 
 	FortuneTigerBetBetLevel = map[int64]*structs.FortuneTigerBetBetLevel{
 		0: {
-			Index:    0,
+			Index: 0,
 			BetLevel: 1,
 		},
 		1: {
-			Index:    1,
+			Index: 1,
 			BetLevel: 2,
 		},
 		2: {
-			Index:    2,
+			Index: 2,
 			BetLevel: 3,
 		},
 		3: {
-			Index:    3,
+			Index: 3,
 			BetLevel: 4,
 		},
 		4: {
-			Index:    4,
+			Index: 4,
 			BetLevel: 5,
 		},
 		5: {
-			Index:    5,
+			Index: 5,
 			BetLevel: 6,
 		},
 		6: {
-			Index:    6,
+			Index: 6,
 			BetLevel: 7,
 		},
 		7: {
-			Index:    7,
+			Index: 7,
 			BetLevel: 8,
 		},
 		8: {
-			Index:    8,
+			Index: 8,
 			BetLevel: 9,
 		},
 		9: {
-			Index:    9,
+			Index: 9,
 			BetLevel: 10,
 		},
 	}
 
 	FortuneTigerBetBetLine = map[int64]*structs.FortuneTigerBetBetLine{
 		0: {
-			Index:   0,
+			Index: 0,
 			BetLine: 5,
 			BaseBet: 1,
 		},
@@ -141,55 +141,55 @@ func init() {
 
 	FortuneTigerBetBetSize = map[int64]*structs.FortuneTigerBetBetSize{
 		0: {
-			Index:   0,
-			BetSize: 300,
+			Index: 0,
+			BetSize: 300000000,
 		},
 		1: {
-			Index:   1,
-			BetSize: 1000,
+			Index: 1,
+			BetSize: 1000000000,
 		},
 		2: {
-			Index:   2,
-			BetSize: 3000,
+			Index: 2,
+			BetSize: 3000000000,
 		},
 		3: {
-			Index:   3,
-			BetSize: 9000,
+			Index: 3,
+			BetSize: 9000000000,
 		},
 	}
 
 	FortuneTigerBetFirstBet = map[int64]*structs.FortuneTigerBetFirstBet{
 		1: {
-			Index:         1,
-			BetSizeIndex:  1,
+			Index: 1,
+			BetSizeIndex: 1,
 			BetLevelIndex: 1,
 		},
 	}
 
 	FortuneTigerFormation = []*structs.FortuneTigerFormation{
 		{
-			SpinType:         1,
-			NodeType:         "BaseSpin",
-			ID:               1,
-			SeqID:            1,
-			Reel:             "BaseSpin",
-			Matrix:           "Line5Form3X3TypeB",
-			Symbol:           "Default",
-			FirstInitMethod:  4,
-			OtherInitMethod:  4,
+			SpinType: 1,
+			NodeType: "BaseSpin",
+			ID: 1,
+			SeqID: 1,
+			Reel: "BaseSpin",
+			Matrix: "Line5Form3X3TypeB",
+			Symbol: "Default",
+			FirstInitMethod: 4,
+			OtherInitMethod: 4,
 			FirstInitSymbols: []int64{},
 			OtherInitSymbols: []int64{},
 		},
 		{
-			SpinType:         3,
-			NodeType:         "ReSpin",
-			ID:               1,
-			SeqID:            1,
-			Reel:             "ReSpin",
-			Matrix:           "Line5Form3X3TypeB",
-			Symbol:           "Default",
-			FirstInitMethod:  3,
-			OtherInitMethod:  3,
+			SpinType: 3,
+			NodeType: "ReSpin",
+			ID: 1,
+			SeqID: 1,
+			Reel: "ReSpin",
+			Matrix: "Line5Form3X3TypeB",
+			Symbol: "Default",
+			FirstInitMethod: 3,
+			OtherInitMethod: 3,
 			FirstInitSymbols: []int64{},
 			OtherInitSymbols: []int64{},
 		},
@@ -200,42 +200,42 @@ func init() {
 			ID: 1,
 			TypeWeight: map[int64]*structs.FortuneTigerMapRTPModeTypeWeight{
 				1: {
-					ID:     1,
+					ID: 1,
 					Weight: 1,
 				},
 			},
 			Desc: "96",
-			Rtp:  0.96,
+			Rtp: 0.96,
 		},
 		2: {
 			ID: 2,
 			TypeWeight: map[int64]*structs.FortuneTigerMapRTPModeTypeWeight{
 				1: {
-					ID:     1,
+					ID: 1,
 					Weight: 1,
 				},
 			},
 			Desc: "80",
-			Rtp:  0.8,
+			Rtp: 0.8,
 		},
 		3: {
 			ID: 3,
 			TypeWeight: map[int64]*structs.FortuneTigerMapRTPModeTypeWeight{
 				1: {
-					ID:     1,
+					ID: 1,
 					Weight: 1,
 				},
 			},
 			Desc: "120",
-			Rtp:  1.2,
+			Rtp: 1.2,
 		},
 	}
 
 	FortuneTigerOthers = []*structs.FortuneTigerOthers{
 		{
 			RespinTriggerPro: 0.0104,
-			Multiplier:       10,
-			MaxWin:           2500,
+			Multiplier: 10,
+			MaxWin: 2500,
 		},
 	}
 
@@ -273,37 +273,37 @@ func init() {
 
 	FortuneTigerSuperStackWeight = []*structs.FortuneTigerSuperStackWeight{
 		{
-			ID:     1,
+			ID: 1,
 			ItemID: 1,
 			Weight: 0,
 		},
 		{
-			ID:     2,
+			ID: 2,
 			ItemID: 2,
 			Weight: 0.66,
 		},
 		{
-			ID:     3,
+			ID: 3,
 			ItemID: 3,
 			Weight: 3.34,
 		},
 		{
-			ID:     4,
+			ID: 4,
 			ItemID: 4,
 			Weight: 11,
 		},
 		{
-			ID:     5,
+			ID: 5,
 			ItemID: 5,
 			Weight: 15,
 		},
 		{
-			ID:     6,
+			ID: 6,
 			ItemID: 6,
 			Weight: 20,
 		},
 		{
-			ID:     7,
+			ID: 7,
 			ItemID: 7,
 			Weight: 50,
 		},
@@ -311,85 +311,85 @@ func init() {
 
 	FortuneTigerSymbol = map[int64]*structs.FortuneTigerSymbol{
 		1: {
-			ID:          1,
-			Name:        "wild",
-			IsWild:      true,
-			Group:       []int64{1},
-			PayRate:     []int64{0, 0, 250},
+			ID: 1,
+			Name: "wild",
+			IsWild: true,
+			Group: []int64{1},
+			PayRate: []int64{0, 0, 250},
 			ClientOrder: 1,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		2: {
-			ID:          2,
-			Name:        "元宝",
-			IsWild:      false,
-			Group:       []int64{2},
-			PayRate:     []int64{0, 0, 100},
+			ID: 2,
+			Name: "元宝",
+			IsWild: false,
+			Group: []int64{2},
+			PayRate: []int64{0, 0, 100},
 			ClientOrder: 2,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		3: {
-			ID:          3,
-			Name:        "玉饰",
-			IsWild:      false,
-			Group:       []int64{3},
-			PayRate:     []int64{0, 0, 25},
+			ID: 3,
+			Name: "玉饰",
+			IsWild: false,
+			Group: []int64{3},
+			PayRate: []int64{0, 0, 25},
 			ClientOrder: 3,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		4: {
-			ID:          4,
-			Name:        "福袋",
-			IsWild:      false,
-			Group:       []int64{4},
-			PayRate:     []int64{0, 0, 10},
+			ID: 4,
+			Name: "福袋",
+			IsWild: false,
+			Group: []int64{4},
+			PayRate: []int64{0, 0, 10},
 			ClientOrder: 4,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		5: {
-			ID:          5,
-			Name:        "红包",
-			IsWild:      false,
-			Group:       []int64{5},
-			PayRate:     []int64{0, 0, 8},
+			ID: 5,
+			Name: "红包",
+			IsWild: false,
+			Group: []int64{5},
+			PayRate: []int64{0, 0, 8},
 			ClientOrder: 5,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		6: {
-			ID:          6,
-			Name:        "爆竹",
-			IsWild:      false,
-			Group:       []int64{6},
-			PayRate:     []int64{0, 0, 5},
+			ID: 6,
+			Name: "爆竹",
+			IsWild: false,
+			Group: []int64{6},
+			PayRate: []int64{0, 0, 5},
 			ClientOrder: 6,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		7: {
-			ID:          7,
-			Name:        "橘子",
-			IsWild:      false,
-			Group:       []int64{7},
-			PayRate:     []int64{0, 0, 3},
+			ID: 7,
+			Name: "橘子",
+			IsWild: false,
+			Group: []int64{7},
+			PayRate: []int64{0, 0, 3},
 			ClientOrder: 7,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		8: {
-			ID:          8,
-			Name:        "SuperStack",
-			IsWild:      false,
-			Group:       []int64{8},
-			PayRate:     []int64{0, 0, 0},
+			ID: 8,
+			Name: "SuperStack",
+			IsWild: false,
+			Group: []int64{8},
+			PayRate: []int64{0, 0, 0},
 			ClientOrder: 0,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 		200: {
-			ID:          200,
-			Name:        "Empty",
-			IsWild:      false,
-			Group:       []int64{200},
-			PayRate:     []int64{0, 0, 0},
+			ID: 200,
+			Name: "Empty",
+			IsWild: false,
+			Group: []int64{200},
+			PayRate: []int64{0, 0, 0},
 			ClientOrder: 0,
-			ClientDsc:   "",
+			ClientDsc: "",
 		},
 	}
 
@@ -399,4 +399,4 @@ func init() {
 		},
 	}
 
-}
+}

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

@@ -9,8 +9,8 @@ import "mongo.games.com/game/gamesrv/slotspkg/internal/exported/excel2go/structs
 func init() {
 	MatrixFeaturesForm15X1TypeA = []*structs.MatrixFeaturesForm15X1TypeA{
 		{
-			Type:      "FeatureForm15X1TypeA",
-			LinkType:  2,
+			Type: "FeatureForm15X1TypeA",
+			LinkType: 2,
 			Direction: 0,
 			LineCount: 100,
 			Lines: [][]int64{
@@ -22,8 +22,8 @@ func init() {
 
 	MatrixFeaturesForm19X1TypeA = []*structs.MatrixFeaturesForm19X1TypeA{
 		{
-			Type:      "FeatureForm19X1TypeA",
-			LinkType:  2,
+			Type: "FeatureForm19X1TypeA",
+			LinkType: 2,
 			Direction: 0,
 			LineCount: 100,
 			Lines: [][]int64{
@@ -35,8 +35,8 @@ func init() {
 
 	MatrixFeaturesForm20X1TypeA = []*structs.MatrixFeaturesForm20X1TypeA{
 		{
-			Type:      "FeatureForm20X1TypeA",
-			LinkType:  2,
+			Type: "FeatureForm20X1TypeA",
+			LinkType: 2,
 			Direction: 0,
 			LineCount: 100,
 			Lines: [][]int64{
@@ -48,8 +48,8 @@ func init() {
 
 	MatrixFeaturesForm25X1TypeA = []*structs.MatrixFeaturesForm25X1TypeA{
 		{
-			Type:      "FeatureForm25X1TypeA",
-			LinkType:  2,
+			Type: "FeatureForm25X1TypeA",
+			LinkType: 2,
 			Direction: 0,
 			LineCount: 100,
 			Lines: [][]int64{
@@ -61,8 +61,8 @@ func init() {
 
 	MatrixFeaturesForm30X1TypeA = []*structs.MatrixFeaturesForm30X1TypeA{
 		{
-			Type:      "FeatureForm30X1TypeA",
-			LinkType:  2,
+			Type: "FeatureForm30X1TypeA",
+			LinkType: 2,
 			Direction: 0,
 			LineCount: 100,
 			Lines: [][]int64{
@@ -74,8 +74,8 @@ func init() {
 
 	MatrixFeaturesForm35X1TypeA = []*structs.MatrixFeaturesForm35X1TypeA{
 		{
-			Type:      "FeatureForm35X1TypeA",
-			LinkType:  2,
+			Type: "FeatureForm35X1TypeA",
+			LinkType: 2,
 			Direction: 0,
 			LineCount: 100,
 			Lines: [][]int64{
@@ -87,8 +87,8 @@ func init() {
 
 	MatrixFeaturesForm40X1 = []*structs.MatrixFeaturesForm40X1{
 		{
-			Type:      "FeatureForm40X1",
-			LinkType:  2,
+			Type: "FeatureForm40X1",
+			LinkType: 2,
 			Direction: 0,
 			LineCount: 0,
 			Lines: [][]int64{
@@ -100,8 +100,8 @@ func init() {
 
 	MatrixFeaturesForm40X1TypeA = []*structs.MatrixFeaturesForm40X1TypeA{
 		{
-			Type:      "FeatureForm40X1",
-			LinkType:  2,
+			Type: "FeatureForm40X1",
+			LinkType: 2,
 			Direction: 0,
 			LineCount: 0,
 			Lines: [][]int64{
@@ -113,8 +113,8 @@ func init() {
 
 	MatrixFeaturesForm7X1TypeA = []*structs.MatrixFeaturesForm7X1TypeA{
 		{
-			Type:      "FeatureForm15X1TypeA",
-			LinkType:  2,
+			Type: "FeatureForm15X1TypeA",
+			LinkType: 2,
 			Direction: 0,
 			LineCount: 50,
 			Lines: [][]int64{
@@ -126,8 +126,8 @@ func init() {
 
 	MatrixLine100Form12X5TypeA = []*structs.MatrixLine100Form12X5TypeA{
 		{
-			Type:      "Line100Form12X5TypeA",
-			LinkType:  0,
+			Type: "Line100Form12X5TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 100,
 			Lines: [][]int64{
@@ -238,8 +238,8 @@ func init() {
 
 	MatrixLine100Form6X5TypeA = []*structs.MatrixLine100Form6X5TypeA{
 		{
-			Type:      "Line100Form6X5TypeA",
-			LinkType:  0,
+			Type: "Line100Form6X5TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 100,
 			Lines: [][]int64{
@@ -350,8 +350,8 @@ func init() {
 
 	MatrixLine10Form343TypeA = []*structs.MatrixLine10Form343TypeA{
 		{
-			Type:      "Line10Form343TypeA",
-			LinkType:  0,
+			Type: "Line10Form343TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 10,
 			Lines: [][]int64{
@@ -372,8 +372,8 @@ func init() {
 
 	MatrixLine10Form3X5TypeA = []*structs.MatrixLine10Form3X5TypeA{
 		{
-			Type:      "Line10Form3X5TypeA",
-			LinkType:  0,
+			Type: "Line10Form3X5TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 10,
 			Lines: [][]int64{
@@ -394,8 +394,8 @@ func init() {
 
 	MatrixLine1Form3X3TypeA = []*structs.MatrixLine1Form3X3TypeA{
 		{
-			Type:      "Line1Form3X3TypeA",
-			LinkType:  0,
+			Type: "Line1Form3X3TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 1,
 			Lines: [][]int64{
@@ -407,8 +407,8 @@ func init() {
 
 	MatrixLine1Form3X3TypeB = []*structs.MatrixLine1Form3X3TypeB{
 		{
-			Type:      "Line1Form3X3TypeB",
-			LinkType:  0,
+			Type: "Line1Form3X3TypeB",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 1,
 			Lines: [][]int64{
@@ -420,8 +420,8 @@ func init() {
 
 	MatrixLine1Form5X5TypeA = []*structs.MatrixLine1Form5X5TypeA{
 		{
-			Type:      "Line1Form5X5TypeA",
-			LinkType:  0,
+			Type: "Line1Form5X5TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 1,
 			Lines: [][]int64{
@@ -433,8 +433,8 @@ func init() {
 
 	MatrixLine20Form3X5TypeA = []*structs.MatrixLine20Form3X5TypeA{
 		{
-			Type:      "Line20Form3X5TypeA",
-			LinkType:  0,
+			Type: "Line20Form3X5TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 20,
 			Lines: [][]int64{
@@ -465,8 +465,8 @@ func init() {
 
 	MatrixLine25Form36666TypeA = []*structs.MatrixLine25Form36666TypeA{
 		{
-			Type:      "Line25Form36666TypeA",
-			LinkType:  0,
+			Type: "Line25Form36666TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 25,
 			Lines: [][]int64{
@@ -502,8 +502,8 @@ func init() {
 
 	MatrixLine25Form3X5TypeA = []*structs.MatrixLine25Form3X5TypeA{
 		{
-			Type:      "Line25Form3X5TypeA",
-			LinkType:  0,
+			Type: "Line25Form3X5TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 25,
 			Lines: [][]int64{
@@ -539,8 +539,8 @@ func init() {
 
 	MatrixLine25Form3X5TypeB = []*structs.MatrixLine25Form3X5TypeB{
 		{
-			Type:      "Line25Form3X5TypeB",
-			LinkType:  0,
+			Type: "Line25Form3X5TypeB",
+			LinkType: 0,
 			Direction: 2,
 			LineCount: 25,
 			Lines: [][]int64{
@@ -576,8 +576,8 @@ func init() {
 
 	MatrixLine25Form3X5TypeC = []*structs.MatrixLine25Form3X5TypeC{
 		{
-			Type:      "Line25Form3X5TypeC",
-			LinkType:  0,
+			Type: "Line25Form3X5TypeC",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 25,
 			Lines: [][]int64{
@@ -613,8 +613,8 @@ func init() {
 
 	MatrixLine25Form3X5TypeD = []*structs.MatrixLine25Form3X5TypeD{
 		{
-			Type:      "Line25Form3X5TypeD",
-			LinkType:  0,
+			Type: "Line25Form3X5TypeD",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 25,
 			Lines: [][]int64{
@@ -650,8 +650,8 @@ func init() {
 
 	MatrixLine25Form3X5TypeE = []*structs.MatrixLine25Form3X5TypeE{
 		{
-			Type:      "Line25Form3X5TypeE",
-			LinkType:  0,
+			Type: "Line25Form3X5TypeE",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 25,
 			Lines: [][]int64{
@@ -687,8 +687,8 @@ func init() {
 
 	MatrixLine30Form3X5TypeA = []*structs.MatrixLine30Form3X5TypeA{
 		{
-			Type:      "Line30Form3X5TypeA",
-			LinkType:  0,
+			Type: "Line30Form3X5TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 30,
 			Lines: [][]int64{
@@ -729,8 +729,8 @@ func init() {
 
 	MatrixLine30Form3X5TypeB = []*structs.MatrixLine30Form3X5TypeB{
 		{
-			Type:      "Line30Form3X5TypeB",
-			LinkType:  0,
+			Type: "Line30Form3X5TypeB",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 30,
 			Lines: [][]int64{
@@ -771,8 +771,8 @@ func init() {
 
 	MatrixLine30Form3X5TypeC = []*structs.MatrixLine30Form3X5TypeC{
 		{
-			Type:      "Line30Form3X5TypeC",
-			LinkType:  0,
+			Type: "Line30Form3X5TypeC",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 30,
 			Lines: [][]int64{
@@ -813,8 +813,8 @@ func init() {
 
 	MatrixLine30Form3X5TypeD = []*structs.MatrixLine30Form3X5TypeD{
 		{
-			Type:      "Line30Form3X5TypeD",
-			LinkType:  0,
+			Type: "Line30Form3X5TypeD",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 30,
 			Lines: [][]int64{
@@ -855,8 +855,8 @@ func init() {
 
 	MatrixLine30Form3X5TypeE = []*structs.MatrixLine30Form3X5TypeE{
 		{
-			Type:      "Line30Form3X5TypeE",
-			LinkType:  0,
+			Type: "Line30Form3X5TypeE",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 30,
 			Lines: [][]int64{
@@ -897,8 +897,8 @@ func init() {
 
 	MatrixLine30Form3X6TypeA = []*structs.MatrixLine30Form3X6TypeA{
 		{
-			Type:      "Line30Form3X6TypeA",
-			LinkType:  0,
+			Type: "Line30Form3X6TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 30,
 			Lines: [][]int64{
@@ -939,8 +939,8 @@ func init() {
 
 	MatrixLine30Form4X5TypeA = []*structs.MatrixLine30Form4X5TypeA{
 		{
-			Type:      "Line30Form4X5TypeA",
-			LinkType:  0,
+			Type: "Line30Form4X5TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 30,
 			Lines: [][]int64{
@@ -981,8 +981,8 @@ func init() {
 
 	MatrixLine30Form4X5TypeB = []*structs.MatrixLine30Form4X5TypeB{
 		{
-			Type:      "Line30Form4X5TypeB",
-			LinkType:  0,
+			Type: "Line30Form4X5TypeB",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 30,
 			Lines: [][]int64{
@@ -1023,8 +1023,8 @@ func init() {
 
 	MatrixLine3Form3X3TypeA = []*structs.MatrixLine3Form3X3TypeA{
 		{
-			Type:      "Line3Form3X3TypeA",
-			LinkType:  0,
+			Type: "Line3Form3X3TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 3,
 			Lines: [][]int64{
@@ -1038,8 +1038,8 @@ func init() {
 
 	MatrixLine40Form34543TypeA = []*structs.MatrixLine40Form34543TypeA{
 		{
-			Type:      "Line40Form34543TypeA",
-			LinkType:  0,
+			Type: "Line40Form34543TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 40,
 			Lines: [][]int64{
@@ -1090,8 +1090,8 @@ func init() {
 
 	MatrixLine40Form3X5TypeA = []*structs.MatrixLine40Form3X5TypeA{
 		{
-			Type:      "Line40Form3X5TypeA",
-			LinkType:  0,
+			Type: "Line40Form3X5TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 40,
 			Lines: [][]int64{
@@ -1142,8 +1142,8 @@ func init() {
 
 	MatrixLine40Form3X5TypeB = []*structs.MatrixLine40Form3X5TypeB{
 		{
-			Type:      "Line40Form3X5TypeB",
-			LinkType:  0,
+			Type: "Line40Form3X5TypeB",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 40,
 			Lines: [][]int64{
@@ -1194,8 +1194,8 @@ func init() {
 
 	MatrixLine40Form3X5TypeC = []*structs.MatrixLine40Form3X5TypeC{
 		{
-			Type:      "Line40Form3X5TypeC",
-			LinkType:  0,
+			Type: "Line40Form3X5TypeC",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 40,
 			Lines: [][]int64{
@@ -1246,8 +1246,8 @@ func init() {
 
 	MatrixLine40Form3X5TypeD = []*structs.MatrixLine40Form3X5TypeD{
 		{
-			Type:      "Line40Form3X5TypeD",
-			LinkType:  0,
+			Type: "Line40Form3X5TypeD",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 40,
 			Lines: [][]int64{
@@ -1298,8 +1298,8 @@ func init() {
 
 	MatrixLine40Form4X5TypeA = []*structs.MatrixLine40Form4X5TypeA{
 		{
-			Type:      "Line40Form4X5TypeA",
-			LinkType:  0,
+			Type: "Line40Form4X5TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 40,
 			Lines: [][]int64{
@@ -1350,8 +1350,8 @@ func init() {
 
 	MatrixLine40Form4X5TypeB = []*structs.MatrixLine40Form4X5TypeB{
 		{
-			Type:      "Line40Form4X5TypeA",
-			LinkType:  0,
+			Type: "Line40Form4X5TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 40,
 			Lines: [][]int64{
@@ -1402,8 +1402,8 @@ func init() {
 
 	MatrixLine40Form4X5TypeC = []*structs.MatrixLine40Form4X5TypeC{
 		{
-			Type:      "Line40Form4X5TypeC",
-			LinkType:  0,
+			Type: "Line40Form4X5TypeC",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 40,
 			Lines: [][]int64{
@@ -1454,8 +1454,8 @@ func init() {
 
 	MatrixLine40Form4X6TypeA = []*structs.MatrixLine40Form4X6TypeA{
 		{
-			Type:      "Line40Form4X6TypeA",
-			LinkType:  0,
+			Type: "Line40Form4X6TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 40,
 			Lines: [][]int64{
@@ -1506,8 +1506,8 @@ func init() {
 
 	MatrixLine50Form3X5TypeA = []*structs.MatrixLine50Form3X5TypeA{
 		{
-			Type:      "Line50Form3X5TypeA",
-			LinkType:  0,
+			Type: "Line50Form3X5TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 50,
 			Lines: [][]int64{
@@ -1568,8 +1568,8 @@ func init() {
 
 	MatrixLine50Form3X5TypeB = []*structs.MatrixLine50Form3X5TypeB{
 		{
-			Type:      "Line50Form3X5TypeB",
-			LinkType:  0,
+			Type: "Line50Form3X5TypeB",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 50,
 			Lines: [][]int64{
@@ -1630,8 +1630,8 @@ func init() {
 
 	MatrixLine50Form3X5TypeC = []*structs.MatrixLine50Form3X5TypeC{
 		{
-			Type:      "Line50Form3X5TypeC",
-			LinkType:  0,
+			Type: "Line50Form3X5TypeC",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 50,
 			Lines: [][]int64{
@@ -1692,8 +1692,8 @@ func init() {
 
 	MatrixLine50Form3X5TypeD = []*structs.MatrixLine50Form3X5TypeD{
 		{
-			Type:      "Line50Form3X5TypeD",
-			LinkType:  0,
+			Type: "Line50Form3X5TypeD",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 50,
 			Lines: [][]int64{
@@ -1754,8 +1754,8 @@ func init() {
 
 	MatrixLine50Form3X5TypeE = []*structs.MatrixLine50Form3X5TypeE{
 		{
-			Type:      "Line50Form3X5TypeE",
-			LinkType:  0,
+			Type: "Line50Form3X5TypeE",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 50,
 			Lines: [][]int64{
@@ -1816,8 +1816,8 @@ func init() {
 
 	MatrixLine50Form3X5TypeF = []*structs.MatrixLine50Form3X5TypeF{
 		{
-			Type:      "Line50Form3X5TypeF",
-			LinkType:  0,
+			Type: "Line50Form3X5TypeF",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 50,
 			Lines: [][]int64{
@@ -1878,8 +1878,8 @@ func init() {
 
 	MatrixLine50Form3X5TypeG = []*structs.MatrixLine50Form3X5TypeG{
 		{
-			Type:      "Line50Form3X5TypeG",
-			LinkType:  0,
+			Type: "Line50Form3X5TypeG",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 50,
 			Lines: [][]int64{
@@ -1940,8 +1940,8 @@ func init() {
 
 	MatrixLine50Form3X5TypeH = []*structs.MatrixLine50Form3X5TypeH{
 		{
-			Type:      "Line50Form3X5TypeH",
-			LinkType:  0,
+			Type: "Line50Form3X5TypeH",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 50,
 			Lines: [][]int64{
@@ -2002,8 +2002,8 @@ func init() {
 
 	MatrixLine50Form45454TypeA = []*structs.MatrixLine50Form45454TypeA{
 		{
-			Type:      "Line50Form45454TypeA",
-			LinkType:  0,
+			Type: "Line50Form45454TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 50,
 			Lines: [][]int64{
@@ -2064,8 +2064,8 @@ func init() {
 
 	MatrixLine50Form4X5TypeA = []*structs.MatrixLine50Form4X5TypeA{
 		{
-			Type:      "Line50Form4X5TypeA",
-			LinkType:  0,
+			Type: "Line50Form4X5TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 50,
 			Lines: [][]int64{
@@ -2126,8 +2126,8 @@ func init() {
 
 	MatrixLine50Form4X5TypeB = []*structs.MatrixLine50Form4X5TypeB{
 		{
-			Type:      "Line50Form4X5TypeB",
-			LinkType:  0,
+			Type: "Line50Form4X5TypeB",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 50,
 			Lines: [][]int64{
@@ -2188,8 +2188,8 @@ func init() {
 
 	MatrixLine50Form4X5TypeC = []*structs.MatrixLine50Form4X5TypeC{
 		{
-			Type:      "Line50Form4X5TypeC",
-			LinkType:  0,
+			Type: "Line50Form4X5TypeC",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 50,
 			Lines: [][]int64{
@@ -2250,8 +2250,8 @@ func init() {
 
 	MatrixLine50Form4X5TypeD = []*structs.MatrixLine50Form4X5TypeD{
 		{
-			Type:      "Line50Form4X5TypeD",
-			LinkType:  0,
+			Type: "Line50Form4X5TypeD",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 50,
 			Lines: [][]int64{
@@ -2312,8 +2312,8 @@ func init() {
 
 	MatrixLine50Form4X5TypeE = []*structs.MatrixLine50Form4X5TypeE{
 		{
-			Type:      "Line50Form4X5TypeE",
-			LinkType:  0,
+			Type: "Line50Form4X5TypeE",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 50,
 			Lines: [][]int64{
@@ -2374,8 +2374,8 @@ func init() {
 
 	MatrixLine50Form4X5TypeF = []*structs.MatrixLine50Form4X5TypeF{
 		{
-			Type:      "Line50Form4X5TypeF",
-			LinkType:  0,
+			Type: "Line50Form4X5TypeF",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 50,
 			Lines: [][]int64{
@@ -2436,8 +2436,8 @@ func init() {
 
 	MatrixLine50Form4X6TypeA = []*structs.MatrixLine50Form4X6TypeA{
 		{
-			Type:      "Line50Form4X6TypeA",
-			LinkType:  0,
+			Type: "Line50Form4X6TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 50,
 			Lines: [][]int64{
@@ -2498,8 +2498,8 @@ func init() {
 
 	MatrixLine50Form5X5TypeA = []*structs.MatrixLine50Form5X5TypeA{
 		{
-			Type:      "Line50Form5X5TypeA",
-			LinkType:  0,
+			Type: "Line50Form5X5TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 50,
 			Lines: [][]int64{
@@ -2560,8 +2560,8 @@ func init() {
 
 	MatrixLine50Form5X5TypeB = []*structs.MatrixLine50Form5X5TypeB{
 		{
-			Type:      "Line50Form5X5TypeB",
-			LinkType:  0,
+			Type: "Line50Form5X5TypeB",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 50,
 			Lines: [][]int64{
@@ -2622,8 +2622,8 @@ func init() {
 
 	MatrixLine50Form5X5TypeC = []*structs.MatrixLine50Form5X5TypeC{
 		{
-			Type:      "Line50Form5X5TypeC",
-			LinkType:  0,
+			Type: "Line50Form5X5TypeC",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 50,
 			Lines: [][]int64{
@@ -2684,8 +2684,8 @@ func init() {
 
 	MatrixLine50Form6X5TypeA = []*structs.MatrixLine50Form6X5TypeA{
 		{
-			Type:      "Line50Form6X5TypeA",
-			LinkType:  0,
+			Type: "Line50Form6X5TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 50,
 			Lines: [][]int64{
@@ -2746,8 +2746,8 @@ func init() {
 
 	MatrixLine5Form3X3TypeA = []*structs.MatrixLine5Form3X3TypeA{
 		{
-			Type:      "Line5Form3X3TypeA",
-			LinkType:  0,
+			Type: "Line5Form3X3TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 5,
 			Lines: [][]int64{
@@ -2763,8 +2763,8 @@ func init() {
 
 	MatrixLine5Form3X3TypeB = []*structs.MatrixLine5Form3X3TypeB{
 		{
-			Type:      "Line5Form3X3TypeB",
-			LinkType:  0,
+			Type: "Line5Form3X3TypeB",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 5,
 			Lines: [][]int64{
@@ -2780,8 +2780,8 @@ func init() {
 
 	MatrixLine60Form33633TypeA = []*structs.MatrixLine60Form33633TypeA{
 		{
-			Type:      "Line60Form33633TypeA",
-			LinkType:  0,
+			Type: "Line60Form33633TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 60,
 			Lines: [][]int64{
@@ -2852,8 +2852,8 @@ func init() {
 
 	MatrixLine60Form8X5TypeA = []*structs.MatrixLine60Form8X5TypeA{
 		{
-			Type:      "Line60Form8X5TypeA",
-			LinkType:  0,
+			Type: "Line60Form8X5TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 60,
 			Lines: [][]int64{
@@ -2924,8 +2924,8 @@ func init() {
 
 	MatrixLine65Form6X5TypeA = []*structs.MatrixLine65Form6X5TypeA{
 		{
-			Type:      "Line65Form6X5TypeA",
-			LinkType:  0,
+			Type: "Line65Form6X5TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 65,
 			Lines: [][]int64{
@@ -3001,8 +3001,8 @@ func init() {
 
 	MatrixLine70Form9X5TypeA = []*structs.MatrixLine70Form9X5TypeA{
 		{
-			Type:      "Line70Form9X5TypeA",
-			LinkType:  0,
+			Type: "Line70Form9X5TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 70,
 			Lines: [][]int64{
@@ -3083,8 +3083,8 @@ func init() {
 
 	MatrixLine75Form5X6TypeA = []*structs.MatrixLine75Form5X6TypeA{
 		{
-			Type:      "Line75Form5X6TypeA",
-			LinkType:  0,
+			Type: "Line75Form5X6TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 75,
 			Lines: [][]int64{
@@ -3170,8 +3170,8 @@ func init() {
 
 	MatrixLine75Form6X5TypeA = []*structs.MatrixLine75Form6X5TypeA{
 		{
-			Type:      "Line75Form6X5TypeA",
-			LinkType:  0,
+			Type: "Line75Form6X5TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 75,
 			Lines: [][]int64{
@@ -3257,8 +3257,8 @@ func init() {
 
 	MatrixLine80Form10X5TypeA = []*structs.MatrixLine80Form10X5TypeA{
 		{
-			Type:      "Line80Form10X5TypeA",
-			LinkType:  0,
+			Type: "Line80Form10X5TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 80,
 			Lines: [][]int64{
@@ -3349,8 +3349,8 @@ func init() {
 
 	MatrixLine80Form3X5TypeA = []*structs.MatrixLine80Form3X5TypeA{
 		{
-			Type:      "Line80Form3X5TypeA",
-			LinkType:  0,
+			Type: "Line80Form3X5TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 80,
 			Lines: [][]int64{
@@ -3441,8 +3441,8 @@ func init() {
 
 	MatrixLine80Form4X6TypeA = []*structs.MatrixLine80Form4X6TypeA{
 		{
-			Type:      "Line80Form4X6TypeA",
-			LinkType:  0,
+			Type: "Line80Form4X6TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 80,
 			Lines: [][]int64{
@@ -3533,8 +3533,8 @@ func init() {
 
 	MatrixLine80Form7X5TypeA = []*structs.MatrixLine80Form7X5TypeA{
 		{
-			Type:      "Line80Form7X5TypeA",
-			LinkType:  0,
+			Type: "Line80Form7X5TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 80,
 			Lines: [][]int64{
@@ -3625,8 +3625,8 @@ func init() {
 
 	MatrixLine90Form11X5TypeA = []*structs.MatrixLine90Form11X5TypeA{
 		{
-			Type:      "Line90Form11X5TypeA",
-			LinkType:  0,
+			Type: "Line90Form11X5TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 90,
 			Lines: [][]int64{
@@ -3727,8 +3727,8 @@ func init() {
 
 	MatrixLine95Form8X5TypeA = []*structs.MatrixLine95Form8X5TypeA{
 		{
-			Type:      "Line95Form8X5TypeA",
-			LinkType:  0,
+			Type: "Line95Form8X5TypeA",
+			LinkType: 0,
 			Direction: 0,
 			LineCount: 95,
 			Lines: [][]int64{
@@ -3834,8 +3834,8 @@ func init() {
 
 	MatrixMatchForm7X7TypeA = []*structs.MatrixMatchForm7X7TypeA{
 		{
-			Type:      "MatchForm7X7",
-			LinkType:  4,
+			Type: "MatchForm7X7",
+			LinkType: 4,
 			Direction: 0,
 			LineCount: 20,
 			Lines: [][]int64{
@@ -3847,8 +3847,8 @@ func init() {
 
 	MatrixSameForm5X6TypeA = []*structs.MatrixSameForm5X6TypeA{
 		{
-			Type:      "SameForm5X6",
-			LinkType:  3,
+			Type: "SameForm5X6",
+			LinkType: 3,
 			Direction: 0,
 			LineCount: 20,
 			Lines: [][]int64{
@@ -3860,8 +3860,8 @@ func init() {
 
 	MatrixSameForm5X6TypeB = []*structs.MatrixSameForm5X6TypeB{
 		{
-			Type:      "SameForm5X6TypeB",
-			LinkType:  3,
+			Type: "SameForm5X6TypeB",
+			LinkType: 3,
 			Direction: 0,
 			LineCount: 25,
 			Lines: [][]int64{
@@ -3873,8 +3873,8 @@ func init() {
 
 	MatrixWaysForm333331 = []*structs.MatrixWaysForm333331{
 		{
-			Type:      "WaysForm333331",
-			LinkType:  1,
+			Type: "WaysForm333331",
+			LinkType: 1,
 			Direction: 0,
 			LineCount: 100,
 			Lines: [][]int64{
@@ -3886,8 +3886,8 @@ func init() {
 
 	MatrixWaysForm33555 = []*structs.MatrixWaysForm33555{
 		{
-			Type:      "WaysForm33555",
-			LinkType:  1,
+			Type: "WaysForm33555",
+			LinkType: 1,
 			Direction: 0,
 			LineCount: 100,
 			Lines: [][]int64{
@@ -3899,8 +3899,8 @@ func init() {
 
 	MatrixWaysForm344444 = []*structs.MatrixWaysForm344444{
 		{
-			Type:      "WaysForm344444",
-			LinkType:  1,
+			Type: "WaysForm344444",
+			LinkType: 1,
 			Direction: 0,
 			LineCount: 100,
 			Lines: [][]int64{
@@ -3912,8 +3912,8 @@ func init() {
 
 	MatrixWaysForm3X5TypeA = []*structs.MatrixWaysForm3X5TypeA{
 		{
-			Type:      "WaysForm3X5TypeA",
-			LinkType:  1,
+			Type: "WaysForm3X5TypeA",
+			LinkType: 1,
 			Direction: 0,
 			LineCount: 100,
 			Lines: [][]int64{
@@ -3925,8 +3925,8 @@ func init() {
 
 	MatrixWaysForm44668 = []*structs.MatrixWaysForm44668{
 		{
-			Type:      "WaysForm44668",
-			LinkType:  1,
+			Type: "WaysForm44668",
+			LinkType: 1,
 			Direction: 0,
 			LineCount: 100,
 			Lines: [][]int64{
@@ -3938,8 +3938,8 @@ func init() {
 
 	MatrixWaysForm4X5TypeA = []*structs.MatrixWaysForm4X5TypeA{
 		{
-			Type:      "WaysForm4X5TypeA",
-			LinkType:  1,
+			Type: "WaysForm4X5TypeA",
+			LinkType: 1,
 			Direction: 0,
 			LineCount: 100,
 			Lines: [][]int64{
@@ -3951,8 +3951,8 @@ func init() {
 
 	MatrixWaysForm4X5TypeB = []*structs.MatrixWaysForm4X5TypeB{
 		{
-			Type:      "WaysForm4X5TypeB",
-			LinkType:  1,
+			Type: "WaysForm4X5TypeB",
+			LinkType: 1,
 			Direction: 0,
 			LineCount: 60,
 			Lines: [][]int64{
@@ -3962,4 +3962,4 @@ func init() {
 		},
 	}
 
-}
+}