2782 lines
42 KiB
Go
2782 lines
42 KiB
Go
package shared
|
|
|
|
type Game struct {
|
|
Contest string
|
|
ContestType string
|
|
RoomID int64
|
|
RoomType string
|
|
RoundID int64
|
|
Branch uint32
|
|
}
|
|
|
|
func (x *Game) GetContest() string {
|
|
if x != nil {
|
|
return x.Contest
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Game) GetContestType() string {
|
|
if x != nil {
|
|
return x.ContestType
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Game) GetRoomID() int64 {
|
|
if x != nil {
|
|
return x.RoomID
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Game) GetRoomType() string {
|
|
if x != nil {
|
|
return x.RoomType
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Game) GetRoundID() int64 {
|
|
if x != nil {
|
|
return x.RoundID
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Game) GetBranch() uint32 {
|
|
if x != nil {
|
|
return x.Branch
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type Srv struct {
|
|
Runtime string
|
|
Version string
|
|
SessionVersion string
|
|
SessionBranch uint32
|
|
Cluster string
|
|
}
|
|
|
|
func (x *Srv) GetRuntime() string {
|
|
if x != nil {
|
|
return x.Runtime
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Srv) GetVersion() string {
|
|
if x != nil {
|
|
return x.Version
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Srv) GetSessionVersion() string {
|
|
if x != nil {
|
|
return x.SessionVersion
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Srv) GetSessionBranch() uint32 {
|
|
if x != nil {
|
|
return x.SessionBranch
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Srv) GetCluster() string {
|
|
if x != nil {
|
|
return x.Cluster
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type Proc struct {
|
|
PublicGate string
|
|
CommitID string
|
|
BuildTime string
|
|
BootTime string
|
|
}
|
|
|
|
func (x *Proc) GetPublicGate() string {
|
|
if x != nil {
|
|
return x.PublicGate
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Proc) GetCommitID() string {
|
|
if x != nil {
|
|
return x.CommitID
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Proc) GetBuildTime() string {
|
|
if x != nil {
|
|
return x.BuildTime
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Proc) GetBootTime() string {
|
|
if x != nil {
|
|
return x.BootTime
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type Identifier struct {
|
|
ContextType string
|
|
LogType string
|
|
GroupID string
|
|
BatchID string
|
|
SeqID int64
|
|
LogID string
|
|
ProcessID string
|
|
SessionID int64
|
|
}
|
|
|
|
func (x *Identifier) GetContextType() string {
|
|
if x != nil {
|
|
return x.ContextType
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Identifier) GetLogType() string {
|
|
if x != nil {
|
|
return x.LogType
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Identifier) GetGroupID() string {
|
|
if x != nil {
|
|
return x.GroupID
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Identifier) GetBatchID() string {
|
|
if x != nil {
|
|
return x.BatchID
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Identifier) GetSeqID() int64 {
|
|
if x != nil {
|
|
return x.SeqID
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Identifier) GetLogID() string {
|
|
if x != nil {
|
|
return x.LogID
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Identifier) GetProcessID() string {
|
|
if x != nil {
|
|
return x.ProcessID
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Identifier) GetSessionID() int64 {
|
|
if x != nil {
|
|
return x.SessionID
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type Cli struct {
|
|
IsSimulator bool
|
|
PlayerName string
|
|
}
|
|
|
|
type User struct {
|
|
Nickname string
|
|
Avatar int64
|
|
CPF string
|
|
PixType string
|
|
PixAccount string
|
|
Name string
|
|
PhoneNumber string
|
|
}
|
|
|
|
func (x *User) GetNickname() string {
|
|
if x != nil {
|
|
return x.Nickname
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *User) GetAvatar() int64 {
|
|
if x != nil {
|
|
return x.Avatar
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *User) GetCPF() string {
|
|
if x != nil {
|
|
return x.CPF
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *User) GetPixType() string {
|
|
if x != nil {
|
|
return x.PixType
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *User) GetPixAccount() string {
|
|
if x != nil {
|
|
return x.PixAccount
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *User) GetName() string {
|
|
if x != nil {
|
|
return x.Name
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *User) GetPhoneNumber() string {
|
|
if x != nil {
|
|
return x.PhoneNumber
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type Char struct {
|
|
Category string
|
|
Group string
|
|
GroupBatch int64
|
|
CreateTime int64
|
|
LoginTime int64
|
|
LastLoginTime int64
|
|
ProcessTime int64
|
|
LastProcessTime int64
|
|
Newbie bool
|
|
Novice bool
|
|
NetworkPromotion string
|
|
ActiveDays int64
|
|
FirstRechargeTime int64
|
|
LatestRechargeTime int64
|
|
RechargeTimes int64
|
|
RechargeCurrency int64
|
|
PixRechargeCurrency int64
|
|
Branch uint32
|
|
BranchName string
|
|
Level int64
|
|
Exp int64
|
|
}
|
|
|
|
func (x *Char) GetCategory() string {
|
|
if x != nil {
|
|
return x.Category
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Char) GetGroup() string {
|
|
if x != nil {
|
|
return x.Group
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Char) GetGroupBatch() int64 {
|
|
if x != nil {
|
|
return x.GroupBatch
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Char) GetCreateTime() int64 {
|
|
if x != nil {
|
|
return x.CreateTime
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Char) GetLoginTime() int64 {
|
|
if x != nil {
|
|
return x.LoginTime
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Char) GetLastLoginTime() int64 {
|
|
if x != nil {
|
|
return x.LastLoginTime
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Char) GetProcessTime() int64 {
|
|
if x != nil {
|
|
return x.ProcessTime
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Char) GetLastProcessTime() int64 {
|
|
if x != nil {
|
|
return x.LastProcessTime
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Char) GetNewbie() bool {
|
|
if x != nil {
|
|
return x.Newbie
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *Char) GetNovice() bool {
|
|
if x != nil {
|
|
return x.Novice
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *Char) GetNetworkPromotion() string {
|
|
if x != nil {
|
|
return x.NetworkPromotion
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Char) GetActiveDays() int64 {
|
|
if x != nil {
|
|
return x.ActiveDays
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Char) GetFirstRechargeTime() int64 {
|
|
if x != nil {
|
|
return x.FirstRechargeTime
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Char) GetLatestRechargeTime() int64 {
|
|
if x != nil {
|
|
return x.LatestRechargeTime
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Char) GetRechargeTimes() int64 {
|
|
if x != nil {
|
|
return x.RechargeTimes
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Char) GetRechargeCurrency() int64 {
|
|
if x != nil {
|
|
return x.RechargeCurrency
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Char) GetPixRechargeCurrency() int64 {
|
|
if x != nil {
|
|
return x.PixRechargeCurrency
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Char) GetBranch() uint32 {
|
|
if x != nil {
|
|
return x.Branch
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Char) GetBranchName() string {
|
|
if x != nil {
|
|
return x.BranchName
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Char) GetLevel() int64 {
|
|
if x != nil {
|
|
return x.Level
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Char) GetExp() int64 {
|
|
if x != nil {
|
|
return x.Exp
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type Book struct {
|
|
Coin int64
|
|
}
|
|
|
|
func (x *Book) GetCoin() int64 {
|
|
if x != nil {
|
|
return x.Coin
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type Agg struct {
|
|
SlotsDailySpins int64
|
|
SlotsDailyWin int64
|
|
SlotsDailyBet int64
|
|
PersonalPool int64
|
|
}
|
|
|
|
func (x *Agg) GetSlotsDailySpins() int64 {
|
|
if x != nil {
|
|
return x.SlotsDailySpins
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Agg) GetSlotsDailyWin() int64 {
|
|
if x != nil {
|
|
return x.SlotsDailyWin
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Agg) GetSlotsDailyBet() int64 {
|
|
if x != nil {
|
|
return x.SlotsDailyBet
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type GameSort struct {
|
|
Game string
|
|
Sort int64
|
|
Type int64
|
|
Flag int64
|
|
Icon int64
|
|
Size int64
|
|
Jackpot bool
|
|
Switch bool
|
|
DisplayLimit int64
|
|
}
|
|
|
|
func (x *GameSort) GetGame() string {
|
|
if x != nil {
|
|
return x.Game
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *GameSort) GetSort() int64 {
|
|
if x != nil {
|
|
return x.Sort
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *GameSort) GetType() int64 {
|
|
if x != nil {
|
|
return x.Type
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *GameSort) GetFlag() int64 {
|
|
if x != nil {
|
|
return x.Flag
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *GameSort) GetIcon() int64 {
|
|
if x != nil {
|
|
return x.Icon
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *GameSort) GetSize() int64 {
|
|
if x != nil {
|
|
return x.Size
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *GameSort) GetJackpot() bool {
|
|
if x != nil {
|
|
return x.Jackpot
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *GameSort) GetSwitch() bool {
|
|
if x != nil {
|
|
return x.Switch
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *GameSort) GetDisplayLimit() int64 {
|
|
if x != nil {
|
|
return x.DisplayLimit
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type Settle struct {
|
|
Game string
|
|
WinCoin int64
|
|
Coin int64
|
|
}
|
|
|
|
func (x *Settle) GetGame() string {
|
|
if x != nil {
|
|
return x.Game
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Settle) GetWinCoin() int64 {
|
|
if x != nil {
|
|
return x.WinCoin
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Settle) GetCoin() int64 {
|
|
if x != nil {
|
|
return x.Coin
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// AwardStatus 奖励状态
|
|
type AwardStatus struct {
|
|
Status int64
|
|
Count int64
|
|
AdCount int64
|
|
}
|
|
|
|
func (x *AwardStatus) GetStatus() int64 {
|
|
if x != nil {
|
|
return x.Status
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *AwardStatus) GetCount() int64 {
|
|
if x != nil {
|
|
return x.Count
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *AwardStatus) GetAdCount() int64 {
|
|
if x != nil {
|
|
return x.AdCount
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// SigninAwardData 签到奖励状态
|
|
type SigninAwardData struct {
|
|
DayStatus []*AwardStatus // 奖励状态
|
|
NextAwardStartTime int64 // 下个奖励的开始时间
|
|
ActivityEndTime int64 // 活动结束时间
|
|
}
|
|
|
|
func (x *SigninAwardData) GetDayStatus() []*AwardStatus {
|
|
if x != nil {
|
|
return x.DayStatus
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *SigninAwardData) GetNextAwardStartTime() int64 {
|
|
if x != nil {
|
|
return x.NextAwardStartTime
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *SigninAwardData) GetActivityEndTime() int64 {
|
|
if x != nil {
|
|
return x.ActivityEndTime
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type SimplifiedMail struct {
|
|
ID int64 // 邮件ID
|
|
Title string // 邮件标题
|
|
Content string // 邮件内容
|
|
EndTime int64 // 邮件最后有效时间戳
|
|
Readed bool // 邮件是否已经查看过
|
|
Coin int64 // 邮件奖励
|
|
}
|
|
|
|
func (x *SimplifiedMail) GetID() int64 {
|
|
if x != nil {
|
|
return x.ID
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *SimplifiedMail) GetTitle() string {
|
|
if x != nil {
|
|
return x.Title
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *SimplifiedMail) GetContent() string {
|
|
if x != nil {
|
|
return x.Content
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *SimplifiedMail) GetEndTime() int64 {
|
|
if x != nil {
|
|
return x.EndTime
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *SimplifiedMail) GetReaded() bool {
|
|
if x != nil {
|
|
return x.Readed
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *SimplifiedMail) GetCoin() int64 {
|
|
if x != nil {
|
|
return x.Coin
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type Reconnect struct {
|
|
Interval int64
|
|
Times int64
|
|
}
|
|
|
|
func (x *Reconnect) GetInterval() int64 {
|
|
if x != nil {
|
|
return x.Interval
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Reconnect) GetTimes() int64 {
|
|
if x != nil {
|
|
return x.Times
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// ShopItem 商城物品
|
|
type ShopItem struct {
|
|
GoodsID string // 商品ID
|
|
PictureID int64 // 图片ID
|
|
ProductID string // 计费点
|
|
PayType string // 支付方式
|
|
Pay int64 // 支付金额(10000)
|
|
ReceiptPay int64 // 到账付费金币(10000)
|
|
Receipt int64 // 到账免费金币(10000)
|
|
Scene string // 付费场景
|
|
TriggerAfterSeconds int64
|
|
GiftRatio int64
|
|
}
|
|
|
|
func (x *ShopItem) GetGoodsID() string {
|
|
if x != nil {
|
|
return x.GoodsID
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *ShopItem) GetPictureID() int64 {
|
|
if x != nil {
|
|
return x.PictureID
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *ShopItem) GetProductID() string {
|
|
if x != nil {
|
|
return x.ProductID
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *ShopItem) GetPayType() string {
|
|
if x != nil {
|
|
return x.PayType
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *ShopItem) GetPay() int64 {
|
|
if x != nil {
|
|
return x.Pay
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *ShopItem) GetReceiptPay() int64 {
|
|
if x != nil {
|
|
return x.ReceiptPay
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *ShopItem) GetReceipt() int64 {
|
|
if x != nil {
|
|
return x.Receipt
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *ShopItem) GetScene() string {
|
|
if x != nil {
|
|
return x.Scene
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *ShopItem) GetTriggerAfterSeconds() int64 {
|
|
if x != nil {
|
|
return x.TriggerAfterSeconds
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *ShopItem) GetGiftRatio() int64 {
|
|
if x != nil {
|
|
return x.GiftRatio
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// PayType 支付方式
|
|
type PayType struct {
|
|
Type string // 付款平台 "Pix" "Google"
|
|
ItemList []*ShopItem // 商城物品
|
|
}
|
|
|
|
func (x *PayType) GetType() string {
|
|
if x != nil {
|
|
return x.Type
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *PayType) GetItemList() []*ShopItem {
|
|
if x != nil {
|
|
return x.ItemList
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type InviteAwardItem struct {
|
|
AwardType int64 // 奖励类型 1:注册奖励 2:充值奖励
|
|
AwardID string // 奖励ID
|
|
AwardTime int64 // 奖励时间
|
|
Status int64 // 奖励状态 0:未达到限制条件 1:可领取 2:领取过 3:已过期
|
|
GameID int64 // 被邀请玩家ID
|
|
PlayerName string // 被邀请玩家名称
|
|
PlayerID int64 // 被邀请玩家ID
|
|
Bonus int64 // 奖励金额
|
|
Recharge int64 // 充值金额
|
|
Rebate int64 // 返利比例
|
|
ID int64 // 该充值玩家的邀请人ID
|
|
}
|
|
|
|
func (x *InviteAwardItem) GetAwardType() int64 {
|
|
if x != nil {
|
|
return x.AwardType
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *InviteAwardItem) GetAwardID() string {
|
|
if x != nil {
|
|
return x.AwardID
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *InviteAwardItem) GetAwardTime() int64 {
|
|
if x != nil {
|
|
return x.AwardTime
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *InviteAwardItem) GetStatus() int64 {
|
|
if x != nil {
|
|
return x.Status
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *InviteAwardItem) GetGameID() int64 {
|
|
if x != nil {
|
|
return x.GameID
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *InviteAwardItem) GetPlayerName() string {
|
|
if x != nil {
|
|
return x.PlayerName
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *InviteAwardItem) GetPlayerID() int64 {
|
|
if x != nil {
|
|
return x.PlayerID
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *InviteAwardItem) GetBonus() int64 {
|
|
if x != nil {
|
|
return x.Bonus
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *InviteAwardItem) GetRecharge() int64 {
|
|
if x != nil {
|
|
return x.Recharge
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *InviteAwardItem) GetRebate() int64 {
|
|
if x != nil {
|
|
return x.Rebate
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *InviteAwardItem) GetID() int64 {
|
|
if x != nil {
|
|
return x.ID
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type InviteRankingItem struct {
|
|
Rank int64 // 上榜排名
|
|
Icon string // 头像
|
|
Name string // 姓名
|
|
Coin int64 // 上榜金额
|
|
}
|
|
|
|
func (x *InviteRankingItem) GetRank() int64 {
|
|
if x != nil {
|
|
return x.Rank
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *InviteRankingItem) GetIcon() string {
|
|
if x != nil {
|
|
return x.Icon
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *InviteRankingItem) GetName() string {
|
|
if x != nil {
|
|
return x.Name
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *InviteRankingItem) GetCoin() int64 {
|
|
if x != nil {
|
|
return x.Coin
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type LinkPositions struct {
|
|
|
|
// Indexes for Items that are linked
|
|
Positions []int64
|
|
}
|
|
|
|
func (x *LinkPositions) GetPositions() []int64 {
|
|
if x != nil {
|
|
return x.Positions
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type Feature struct {
|
|
NodeID int64
|
|
// Type is auto generated by reflect
|
|
Type string // Feature type
|
|
ID int64 // Feature ID
|
|
SpinType int64
|
|
FormationID int64
|
|
NodeType string
|
|
SeqID int64
|
|
Custom string // Feature Custom Info
|
|
Win int64 // Feature win coins
|
|
EffectiveWin int64
|
|
TotalWin int64
|
|
Lifetime int64
|
|
// feature is not visiable by client while Visiable is false
|
|
Visiable bool
|
|
// feature will be recover to next node in same formation ID while imageable
|
|
// is true
|
|
Imageable bool
|
|
Special any
|
|
}
|
|
|
|
func (x *Feature) GetNodeID() int64 {
|
|
if x != nil {
|
|
return x.NodeID
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Feature) GetType() string {
|
|
if x != nil {
|
|
return x.Type
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Feature) GetID() int64 {
|
|
if x != nil {
|
|
return x.ID
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Feature) GetSpinType() int64 {
|
|
if x != nil {
|
|
return x.SpinType
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Feature) GetFormationID() int64 {
|
|
if x != nil {
|
|
return x.FormationID
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Feature) GetNodeType() string {
|
|
if x != nil {
|
|
return x.NodeType
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Feature) GetSeqID() int64 {
|
|
if x != nil {
|
|
return x.SeqID
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Feature) GetCustom() string {
|
|
if x != nil {
|
|
return x.Custom
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Feature) GetWin() int64 {
|
|
if x != nil {
|
|
return x.Win
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Feature) GetEffectiveWin() int64 {
|
|
if x != nil {
|
|
return x.EffectiveWin
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Feature) GetTotalWin() int64 {
|
|
if x != nil {
|
|
return x.TotalWin
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Feature) GetLifetime() int64 {
|
|
if x != nil {
|
|
return x.Lifetime
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Feature) GetVisiable() bool {
|
|
if x != nil {
|
|
return x.Visiable
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *Feature) GetImageable() bool {
|
|
if x != nil {
|
|
return x.Imageable
|
|
}
|
|
return false
|
|
}
|
|
|
|
type Formation struct {
|
|
NodeID int64
|
|
SpinType int64
|
|
ID int64
|
|
NodeType string
|
|
SeqID int64
|
|
InitSymbols []int64
|
|
DisplaySymbols []int64
|
|
FinalSymbols []int64
|
|
LinkPositions []*LinkPositions
|
|
Win int64
|
|
EffectiveWin int64
|
|
TotalWin int64
|
|
ReelForm []int64
|
|
MatrixForm []int64
|
|
RandPositions []int64
|
|
RewardInfo []*RewardInfo
|
|
NewNodeType string
|
|
}
|
|
|
|
func (x *Formation) GetNodeID() int64 {
|
|
if x != nil {
|
|
return x.NodeID
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Formation) GetSpinType() int64 {
|
|
if x != nil {
|
|
return x.SpinType
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Formation) GetID() int64 {
|
|
if x != nil {
|
|
return x.ID
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Formation) GetNodeType() string {
|
|
if x != nil {
|
|
return x.NodeType
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Formation) GetSeqID() int64 {
|
|
if x != nil {
|
|
return x.SeqID
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Formation) GetInitSymbols() []int64 {
|
|
if x != nil {
|
|
return x.InitSymbols
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Formation) GetDisplaySymbols() []int64 {
|
|
if x != nil {
|
|
return x.DisplaySymbols
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Formation) GetFinalSymbols() []int64 {
|
|
if x != nil {
|
|
return x.FinalSymbols
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Formation) GetLinkPositions() []*LinkPositions {
|
|
if x != nil {
|
|
return x.LinkPositions
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Formation) GetWin() int64 {
|
|
if x != nil {
|
|
return x.Win
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Formation) GetEffectiveWin() int64 {
|
|
if x != nil {
|
|
return x.EffectiveWin
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Formation) GetTotalWin() int64 {
|
|
if x != nil {
|
|
return x.TotalWin
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Formation) GetReelForm() []int64 {
|
|
if x != nil {
|
|
return x.ReelForm
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Formation) GetMatrixForm() []int64 {
|
|
if x != nil {
|
|
return x.MatrixForm
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Formation) GetRandPositions() []int64 {
|
|
if x != nil {
|
|
return x.RandPositions
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type Node struct {
|
|
ID int64
|
|
Parent int64
|
|
Children []int64
|
|
Type string // eg: RootNode BaseNode etc.
|
|
SpinType int64
|
|
Formations []*Formation // for formations in array
|
|
Features []*Feature
|
|
Win int64
|
|
EffectiveWin int64
|
|
TotalWin int64
|
|
ChildrenWin int64
|
|
ChildrenTotalWin int64
|
|
ProgressValue int64
|
|
ProgressMax int64
|
|
Bet int64
|
|
SingleBet int64
|
|
NeedPrepare bool
|
|
Prepared bool
|
|
Class int64
|
|
ForceBet int64
|
|
BaseBet int64
|
|
NoBase bool
|
|
}
|
|
|
|
func (x *Node) GetID() int64 {
|
|
if x != nil {
|
|
return x.ID
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Node) GetParent() int64 {
|
|
if x != nil {
|
|
return x.Parent
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Node) GetChildren() []int64 {
|
|
if x != nil {
|
|
return x.Children
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Node) GetType() string {
|
|
if x != nil {
|
|
return x.Type
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Node) GetSpinType() int64 {
|
|
if x != nil {
|
|
return x.SpinType
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Node) GetFormations() []*Formation {
|
|
if x != nil {
|
|
return x.Formations
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Node) GetFeatures() []*Feature {
|
|
if x != nil {
|
|
return x.Features
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Node) GetWin() int64 {
|
|
if x != nil {
|
|
return x.Win
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Node) GetEffectiveWin() int64 {
|
|
if x != nil {
|
|
return x.EffectiveWin
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Node) GetTotalWin() int64 {
|
|
if x != nil {
|
|
return x.TotalWin
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Node) GetChildrenWin() int64 {
|
|
if x != nil {
|
|
return x.ChildrenWin
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Node) GetChildrenTotalWin() int64 {
|
|
if x != nil {
|
|
return x.ChildrenTotalWin
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Node) GetProgressValue() int64 {
|
|
if x != nil {
|
|
return x.ProgressValue
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Node) GetProgressMax() int64 {
|
|
if x != nil {
|
|
return x.ProgressMax
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Node) GetBet() int64 {
|
|
if x != nil {
|
|
return x.Bet
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Node) GetSingleBet() int64 {
|
|
if x != nil {
|
|
return x.SingleBet
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Node) GetNeedPrepare() bool {
|
|
if x != nil {
|
|
return x.NeedPrepare
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *Node) GetPrepared() bool {
|
|
if x != nil {
|
|
return x.Prepared
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *Node) GetClass() int64 {
|
|
if x != nil {
|
|
return x.Class
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Node) GetForceBet() int64 {
|
|
if x != nil {
|
|
return x.ForceBet
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Node) GetBaseBet() int64 {
|
|
if x != nil {
|
|
return x.BaseBet
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type UserData struct {
|
|
RecorderResult string
|
|
BuySpinForceWin bool
|
|
ForceChoice int64
|
|
}
|
|
|
|
func (x *UserData) GetRecorderResult() string {
|
|
if x != nil {
|
|
return x.RecorderResult
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *UserData) GetBuySpinForceWin() bool {
|
|
if x != nil {
|
|
return x.BuySpinForceWin
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *UserData) GetForceChoice() int64 {
|
|
if x != nil {
|
|
return x.ForceChoice
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type Act struct {
|
|
BetSizeIndex int64
|
|
BetLevelIndex int64
|
|
BetLineIndex int64
|
|
Choice int64
|
|
Stay bool
|
|
// Ratio Type
|
|
// 1 : 花更多的钱,下更多的注
|
|
// 2 : 花更多的钱,下同样的注
|
|
// 3 : 花同样的钱,下更多的注
|
|
RatioType int64
|
|
// Ratio:
|
|
// if r == 0; then r = 1 end
|
|
Ratio float64
|
|
Mode string // inner
|
|
Vector []int64 // inner
|
|
ExpectedWinCoin int64 // inner
|
|
EnableRandxTracker bool // inner
|
|
RecorderRandxTracker *RandxTracker // inner
|
|
VectorIndex int64 // inner
|
|
VectorType int64 // inner
|
|
Version int64
|
|
ClassId int64
|
|
PlayMode int
|
|
}
|
|
|
|
func (x *Act) GetBetIndex() int64 {
|
|
if x != nil {
|
|
return x.BetSizeIndex
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Act) GetCoinValueIndex() int64 {
|
|
if x != nil {
|
|
return x.BetLevelIndex
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Act) GetChoice() int64 {
|
|
if x != nil {
|
|
return x.Choice
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Act) GetStay() bool {
|
|
if x != nil {
|
|
return x.Stay
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *Act) GetRatioType() int64 {
|
|
if x != nil {
|
|
return x.RatioType
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Act) GetRatio() float64 {
|
|
if x != nil {
|
|
return x.Ratio
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Act) GetMode() string {
|
|
if x != nil {
|
|
return x.Mode
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Act) GetVector() []int64 {
|
|
if x != nil {
|
|
return x.Vector
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Act) GetExpectedWinCoin() int64 {
|
|
if x != nil {
|
|
return x.ExpectedWinCoin
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Act) GetEnableRandxTracker() bool {
|
|
if x != nil {
|
|
return x.EnableRandxTracker
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *Act) GetRecorderRandxTracker() *RandxTracker {
|
|
if x != nil {
|
|
return x.RecorderRandxTracker
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *Act) GetVectorIndex() int64 {
|
|
if x != nil {
|
|
return x.VectorIndex
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Act) GetVectorType() int64 {
|
|
if x != nil {
|
|
return x.VectorType
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Act) GetVersion() int64 {
|
|
if x != nil {
|
|
return x.Version
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type Coin struct {
|
|
Coin int64
|
|
}
|
|
|
|
func (x *Coin) GetCoin() int64 {
|
|
if x != nil {
|
|
return x.Coin
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type RandVector struct {
|
|
VectorType int64
|
|
Vector []int64
|
|
VectorIndex int64 // Vector 表里面的第index条记录
|
|
Index int64 // 本Vector序列的第几个
|
|
ExpectedWinCoin int64
|
|
EnableRandxTracker bool
|
|
RandxTracker *RandxTracker
|
|
RecorderRandxTracker *RandxTracker
|
|
}
|
|
|
|
func (x *RandVector) GetVectorType() int64 {
|
|
if x != nil {
|
|
return x.VectorType
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *RandVector) GetVector() []int64 {
|
|
if x != nil {
|
|
return x.Vector
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *RandVector) GetVectorIndex() int64 {
|
|
if x != nil {
|
|
return x.VectorIndex
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *RandVector) GetIndex() int64 {
|
|
if x != nil {
|
|
return x.Index
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *RandVector) GetExpectedWinCoin() int64 {
|
|
if x != nil {
|
|
return x.ExpectedWinCoin
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *RandVector) GetEnableRandxTracker() bool {
|
|
if x != nil {
|
|
return x.EnableRandxTracker
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *RandVector) GetRandxTracker() *RandxTracker {
|
|
if x != nil {
|
|
return x.RandxTracker
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *RandVector) GetRecorderRandxTracker() *RandxTracker {
|
|
if x != nil {
|
|
return x.RecorderRandxTracker
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type NodeTree struct {
|
|
Act *Act
|
|
BetCoin *Coin
|
|
WinCoin *Coin
|
|
Mode string
|
|
RandVector *RandVector
|
|
UserData *UserData
|
|
Step int64
|
|
Incr int64
|
|
Cursor int64
|
|
Next int64
|
|
Root int64
|
|
Closing []int64
|
|
Nodes []*Node
|
|
ImageFormations []*Formation
|
|
ImageFeatures []*Feature
|
|
LastNodeSettled bool
|
|
Round int64
|
|
RoundType int64
|
|
}
|
|
|
|
func (x *NodeTree) GetAct() *Act {
|
|
if x != nil {
|
|
return x.Act
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *NodeTree) GetBetCoin() *Coin {
|
|
if x != nil {
|
|
return x.BetCoin
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *NodeTree) GetWinCoin() *Coin {
|
|
if x != nil {
|
|
return x.WinCoin
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *NodeTree) GetMode() string {
|
|
if x != nil {
|
|
return x.Mode
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *NodeTree) GetRandVector() *RandVector {
|
|
if x != nil {
|
|
return x.RandVector
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *NodeTree) GetUserData() *UserData {
|
|
if x != nil {
|
|
return x.UserData
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *NodeTree) GetStep() int64 {
|
|
if x != nil {
|
|
return x.Step
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *NodeTree) GetIncr() int64 {
|
|
if x != nil {
|
|
return x.Incr
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *NodeTree) GetCursor() int64 {
|
|
if x != nil {
|
|
return x.Cursor
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *NodeTree) GetNext() int64 {
|
|
if x != nil {
|
|
return x.Next
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *NodeTree) GetRoot() int64 {
|
|
if x != nil {
|
|
return x.Root
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *NodeTree) GetClosing() []int64 {
|
|
if x != nil {
|
|
return x.Closing
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *NodeTree) GetNodes() []*Node {
|
|
if x != nil {
|
|
return x.Nodes
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *NodeTree) GetImageFormations() []*Formation {
|
|
if x != nil {
|
|
return x.ImageFormations
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *NodeTree) GetImageFeatures() []*Feature {
|
|
if x != nil {
|
|
return x.ImageFeatures
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *NodeTree) GetLastNodeSettled() bool {
|
|
if x != nil {
|
|
return x.LastNodeSettled
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *NodeTree) GetRound() int64 {
|
|
if x != nil {
|
|
return x.Round
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *NodeTree) GetRoundType() int64 {
|
|
if x != nil {
|
|
return x.RoundType
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type LiteFeature struct {
|
|
NodeID int64
|
|
FormationID int64
|
|
Type string
|
|
Custom string
|
|
Win int64
|
|
}
|
|
|
|
func (x *LiteFeature) GetNodeID() int64 {
|
|
if x != nil {
|
|
return x.NodeID
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *LiteFeature) GetFormationID() int64 {
|
|
if x != nil {
|
|
return x.FormationID
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *LiteFeature) GetType() string {
|
|
if x != nil {
|
|
return x.Type
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *LiteFeature) GetCustom() string {
|
|
if x != nil {
|
|
return x.Custom
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *LiteFeature) GetWin() int64 {
|
|
if x != nil {
|
|
return x.Win
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type LiteFormation struct {
|
|
ID int64
|
|
SpinType int64
|
|
NodeType string
|
|
NodeID int64
|
|
InitSymbols []int64
|
|
DisplaySymbols []int64
|
|
FinalSymbols []int64
|
|
LinkPositions []*LinkPositions
|
|
Win int64
|
|
RandPositions []int64
|
|
MatrixForm []int64
|
|
RewardInfo []*RewardInfo
|
|
NewNodeType string
|
|
}
|
|
|
|
func (x *LiteFormation) GetID() int64 {
|
|
if x != nil {
|
|
return x.ID
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *LiteFormation) GetSpinType() int64 {
|
|
if x != nil {
|
|
return x.SpinType
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *LiteFormation) GetNodeID() int64 {
|
|
if x != nil {
|
|
return x.NodeID
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *LiteFormation) GetInitSymbols() []int64 {
|
|
if x != nil {
|
|
return x.InitSymbols
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *LiteFormation) GetDisplaySymbols() []int64 {
|
|
if x != nil {
|
|
return x.DisplaySymbols
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *LiteFormation) GetFinalSymbols() []int64 {
|
|
if x != nil {
|
|
return x.FinalSymbols
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *LiteFormation) GetLinkPositions() []*LinkPositions {
|
|
if x != nil {
|
|
return x.LinkPositions
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *LiteFormation) GetWin() int64 {
|
|
if x != nil {
|
|
return x.Win
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *LiteFormation) GetRandPositions() []int64 {
|
|
if x != nil {
|
|
return x.RandPositions
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type LiteNode struct {
|
|
ID int64
|
|
Parent int64
|
|
Children []int64
|
|
Type string
|
|
SpinType int64
|
|
Win int64
|
|
TotalWin int64
|
|
ChildrenTotalWin int64
|
|
ProgressValue int64
|
|
ProgressMax int64
|
|
Bet int64
|
|
}
|
|
|
|
func (x *LiteNode) GetID() int64 {
|
|
if x != nil {
|
|
return x.ID
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *LiteNode) GetParent() int64 {
|
|
if x != nil {
|
|
return x.Parent
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *LiteNode) GetChildren() []int64 {
|
|
if x != nil {
|
|
return x.Children
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *LiteNode) GetType() string {
|
|
if x != nil {
|
|
return x.Type
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *LiteNode) GetSpinType() int64 {
|
|
if x != nil {
|
|
return x.SpinType
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *LiteNode) GetWin() int64 {
|
|
if x != nil {
|
|
return x.Win
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *LiteNode) GetTotalWin() int64 {
|
|
if x != nil {
|
|
return x.TotalWin
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *LiteNode) GetChildrenTotalWin() int64 {
|
|
if x != nil {
|
|
return x.ChildrenTotalWin
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *LiteNode) GetProgressValue() int64 {
|
|
if x != nil {
|
|
return x.ProgressValue
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *LiteNode) GetProgressMax() int64 {
|
|
if x != nil {
|
|
return x.ProgressMax
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *LiteNode) GetBet() int64 {
|
|
if x != nil {
|
|
return x.Bet
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type LiteNodeTree struct {
|
|
Step int64
|
|
Cursor int64
|
|
Next int64
|
|
Closing []int64
|
|
Theme string
|
|
Nodes []*LiteNode
|
|
Formations []*LiteFormation
|
|
Features []*LiteFeature
|
|
BetCoin *Coin
|
|
}
|
|
|
|
func (x *LiteNodeTree) GetStep() int64 {
|
|
if x != nil {
|
|
return x.Step
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *LiteNodeTree) GetCursor() int64 {
|
|
if x != nil {
|
|
return x.Cursor
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *LiteNodeTree) GetNext() int64 {
|
|
if x != nil {
|
|
return x.Next
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *LiteNodeTree) GetClosing() []int64 {
|
|
if x != nil {
|
|
return x.Closing
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *LiteNodeTree) GetNodes() []*LiteNode {
|
|
if x != nil {
|
|
return x.Nodes
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *LiteNodeTree) GetFormations() []*LiteFormation {
|
|
if x != nil {
|
|
return x.Formations
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *LiteNodeTree) GetFeatures() []*LiteFeature {
|
|
if x != nil {
|
|
return x.Features
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type SessionContext struct {
|
|
UID int64
|
|
}
|
|
|
|
func (x *SessionContext) GetUID() int64 {
|
|
if x != nil {
|
|
return x.UID
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type LogContext struct {
|
|
SessionContext *SessionContext
|
|
Identifier *Identifier
|
|
Game *Game
|
|
Srv *Srv
|
|
UID int64
|
|
Cli *Cli
|
|
User *User
|
|
Char *Char
|
|
Book *Book
|
|
Agg *Agg
|
|
}
|
|
|
|
func (x *LogContext) GetSessionContext() *SessionContext {
|
|
if x != nil {
|
|
return x.SessionContext
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *LogContext) GetIdentifier() *Identifier {
|
|
if x != nil {
|
|
return x.Identifier
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *LogContext) GetGame() *Game {
|
|
if x != nil {
|
|
return x.Game
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *LogContext) GetSrv() *Srv {
|
|
if x != nil {
|
|
return x.Srv
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *LogContext) GetUID() int64 {
|
|
if x != nil {
|
|
return x.UID
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *LogContext) GetCli() *Cli {
|
|
if x != nil {
|
|
return x.Cli
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *LogContext) GetUser() *User {
|
|
if x != nil {
|
|
return x.User
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *LogContext) GetChar() *Char {
|
|
if x != nil {
|
|
return x.Char
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *LogContext) GetBook() *Book {
|
|
if x != nil {
|
|
return x.Book
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *LogContext) GetAgg() *Agg {
|
|
if x != nil {
|
|
return x.Agg
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type Switch struct {
|
|
Name string
|
|
Switch int64
|
|
}
|
|
|
|
func (x *Switch) GetName() string {
|
|
if x != nil {
|
|
return x.Name
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *Switch) GetSwitch() int64 {
|
|
if x != nil {
|
|
return x.Switch
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type UserTagSwitch struct {
|
|
System string
|
|
UserTag1 bool
|
|
UserTag2 bool
|
|
}
|
|
|
|
func (x *UserTagSwitch) GetSystem() string {
|
|
if x != nil {
|
|
return x.System
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *UserTagSwitch) GetUserTag1() bool {
|
|
if x != nil {
|
|
return x.UserTag1
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *UserTagSwitch) GetUserTag2() bool {
|
|
if x != nil {
|
|
return x.UserTag2
|
|
}
|
|
return false
|
|
}
|
|
|
|
type BonusConfig struct {
|
|
ID string
|
|
Bonus int64
|
|
Countdown int64
|
|
CompletionMultiple int64
|
|
}
|
|
|
|
func (x *BonusConfig) GetID() string {
|
|
if x != nil {
|
|
return x.ID
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *BonusConfig) GetBonus() int64 {
|
|
if x != nil {
|
|
return x.Bonus
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *BonusConfig) GetCountdown() int64 {
|
|
if x != nil {
|
|
return x.Countdown
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *BonusConfig) GetCompletionMultiple() int64 {
|
|
if x != nil {
|
|
return x.CompletionMultiple
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type OnlineDailyDealsConfig struct {
|
|
Duration int64
|
|
ResetTime int64
|
|
}
|
|
|
|
func (x *OnlineDailyDealsConfig) GetDuration() int64 {
|
|
if x != nil {
|
|
return x.Duration
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *OnlineDailyDealsConfig) GetResetTime() int64 {
|
|
if x != nil {
|
|
return x.ResetTime
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type OnlineWeeklyDealsConfig struct {
|
|
Duration int64
|
|
ResetTime int64
|
|
}
|
|
|
|
func (x *OnlineWeeklyDealsConfig) GetDuration() int64 {
|
|
if x != nil {
|
|
return x.Duration
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *OnlineWeeklyDealsConfig) GetResetTime() int64 {
|
|
if x != nil {
|
|
return x.ResetTime
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type OnlineVipConfigRow struct {
|
|
Grade int64
|
|
RechargeAmount int64
|
|
PromotionReward int64
|
|
PromotionCoinType int64
|
|
WeeklyReward int64
|
|
WeeklyCoinType int64
|
|
MonthReward int64
|
|
MonthCoinType int64
|
|
CashbackProportion int64
|
|
CashbackDailyLimit int64
|
|
CashbackCoinType int64
|
|
ExclusiveCustomerService int64
|
|
}
|
|
|
|
func (x *OnlineVipConfigRow) GetGrade() int64 {
|
|
if x != nil {
|
|
return x.Grade
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *OnlineVipConfigRow) GetRechargeAmount() int64 {
|
|
if x != nil {
|
|
return x.RechargeAmount
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *OnlineVipConfigRow) GetPromotionReward() int64 {
|
|
if x != nil {
|
|
return x.PromotionReward
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *OnlineVipConfigRow) GetPromotionCoinType() int64 {
|
|
if x != nil {
|
|
return x.PromotionCoinType
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *OnlineVipConfigRow) GetWeeklyReward() int64 {
|
|
if x != nil {
|
|
return x.WeeklyReward
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *OnlineVipConfigRow) GetWeeklyCoinType() int64 {
|
|
if x != nil {
|
|
return x.WeeklyCoinType
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *OnlineVipConfigRow) GetMonthReward() int64 {
|
|
if x != nil {
|
|
return x.MonthReward
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *OnlineVipConfigRow) GetMonthCoinType() int64 {
|
|
if x != nil {
|
|
return x.MonthCoinType
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *OnlineVipConfigRow) GetCashbackProportion() int64 {
|
|
if x != nil {
|
|
return x.CashbackProportion
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *OnlineVipConfigRow) GetCashbackDailyLimit() int64 {
|
|
if x != nil {
|
|
return x.CashbackDailyLimit
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *OnlineVipConfigRow) GetCashbackCoinType() int64 {
|
|
if x != nil {
|
|
return x.CashbackCoinType
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *OnlineVipConfigRow) GetExclusiveCustomerService() int64 {
|
|
if x != nil {
|
|
return x.ExclusiveCustomerService
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type OnlineVip3ConfigRow struct {
|
|
Grade int64
|
|
RechargeAmount int64
|
|
Bet int64
|
|
PromotionReward int64
|
|
PromotionCoinType int64
|
|
WeeklyReward int64
|
|
WeeklyCoinType int64
|
|
MonthReward int64
|
|
MonthCoinType int64
|
|
CashbackProportion int64
|
|
CashbackDailyLimit int64
|
|
CashbackCoinType int64
|
|
ExclusiveCustomerService int64
|
|
LockLimit int64
|
|
}
|
|
|
|
func (x *OnlineVip3ConfigRow) GetGrade() int64 {
|
|
if x != nil {
|
|
return x.Grade
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *OnlineVip3ConfigRow) GetRechargeAmount() int64 {
|
|
if x != nil {
|
|
return x.RechargeAmount
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *OnlineVip3ConfigRow) GetBet() int64 {
|
|
if x != nil {
|
|
return x.Bet
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *OnlineVip3ConfigRow) GetPromotionReward() int64 {
|
|
if x != nil {
|
|
return x.PromotionReward
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *OnlineVip3ConfigRow) GetPromotionCoinType() int64 {
|
|
if x != nil {
|
|
return x.PromotionCoinType
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *OnlineVip3ConfigRow) GetWeeklyReward() int64 {
|
|
if x != nil {
|
|
return x.WeeklyReward
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *OnlineVip3ConfigRow) GetWeeklyCoinType() int64 {
|
|
if x != nil {
|
|
return x.WeeklyCoinType
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *OnlineVip3ConfigRow) GetMonthReward() int64 {
|
|
if x != nil {
|
|
return x.MonthReward
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *OnlineVip3ConfigRow) GetMonthCoinType() int64 {
|
|
if x != nil {
|
|
return x.MonthCoinType
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *OnlineVip3ConfigRow) GetCashbackProportion() int64 {
|
|
if x != nil {
|
|
return x.CashbackProportion
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *OnlineVip3ConfigRow) GetCashbackDailyLimit() int64 {
|
|
if x != nil {
|
|
return x.CashbackDailyLimit
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *OnlineVip3ConfigRow) GetCashbackCoinType() int64 {
|
|
if x != nil {
|
|
return x.CashbackCoinType
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *OnlineVip3ConfigRow) GetExclusiveCustomerService() int64 {
|
|
if x != nil {
|
|
return x.ExclusiveCustomerService
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *OnlineVip3ConfigRow) GetLockLimit() int64 {
|
|
if x != nil {
|
|
return x.LockLimit
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type Heartbeat struct {
|
|
Interval int64
|
|
Timeout int64
|
|
}
|
|
|
|
func (x *Heartbeat) GetInterval() int64 {
|
|
if x != nil {
|
|
return x.Interval
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Heartbeat) GetTimeout() int64 {
|
|
if x != nil {
|
|
return x.Timeout
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type RandxTrackerItem struct {
|
|
Tag string
|
|
Index int64
|
|
}
|
|
|
|
func (x *RandxTrackerItem) GetTag() string {
|
|
if x != nil {
|
|
return x.Tag
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *RandxTrackerItem) GetIndex() int64 {
|
|
if x != nil {
|
|
return x.Index
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type RandxTracker struct {
|
|
Items []*RandxTrackerItem
|
|
}
|
|
|
|
func (x *RandxTracker) GetItems() []*RandxTrackerItem {
|
|
if x != nil {
|
|
return x.Items
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type GameConfigItem struct {
|
|
Game string
|
|
EnterRechargeLimit int64
|
|
EnterCarryLimit int64
|
|
BetRechargeLimit int64
|
|
BetCarryLimit int64
|
|
WinAtMost int64
|
|
}
|
|
|
|
func (x *GameConfigItem) GetGame() string {
|
|
if x != nil {
|
|
return x.Game
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *GameConfigItem) GetEnterRechargeLimit() int64 {
|
|
if x != nil {
|
|
return x.EnterRechargeLimit
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *GameConfigItem) GetEnterCarryLimit() int64 {
|
|
if x != nil {
|
|
return x.EnterCarryLimit
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *GameConfigItem) GetBetRechargeLimit() int64 {
|
|
if x != nil {
|
|
return x.BetRechargeLimit
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *GameConfigItem) GetBetCarryLimit() int64 {
|
|
if x != nil {
|
|
return x.BetCarryLimit
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *GameConfigItem) GetWinAtMost() int64 {
|
|
if x != nil {
|
|
return x.WinAtMost
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type RecorderResult struct {
|
|
NewPoolValue int64
|
|
OldPoolValue int64
|
|
ReservePump int64
|
|
Poor bool
|
|
Cycle int64
|
|
CycleOverload bool
|
|
Exception bool
|
|
ExceptionType int64
|
|
Replay bool
|
|
Vector []int64
|
|
VectorType int64
|
|
VectorIndex int64
|
|
VectorMinRatio float64
|
|
VectorMaxRatio float64
|
|
ExpectedBetCoin int64
|
|
ExpectedWinCoin int64
|
|
SkipWinCheck bool
|
|
NoviceForceWin bool
|
|
SecondStageForceWin bool
|
|
PaidForceWin bool
|
|
BuySpinForceWin bool
|
|
ContinousZeroForceWin bool
|
|
PlayMode int
|
|
}
|
|
|
|
func (x *RecorderResult) GetNewPoolValue() int64 {
|
|
if x != nil {
|
|
return x.NewPoolValue
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *RecorderResult) GetOldPoolValue() int64 {
|
|
if x != nil {
|
|
return x.OldPoolValue
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *RecorderResult) GetReservePump() int64 {
|
|
if x != nil {
|
|
return x.ReservePump
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *RecorderResult) GetPoor() bool {
|
|
if x != nil {
|
|
return x.Poor
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *RecorderResult) GetCycle() int64 {
|
|
if x != nil {
|
|
return x.Cycle
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *RecorderResult) GetCycleOverload() bool {
|
|
if x != nil {
|
|
return x.CycleOverload
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *RecorderResult) GetException() bool {
|
|
if x != nil {
|
|
return x.Exception
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *RecorderResult) GetExceptionType() int64 {
|
|
if x != nil {
|
|
return x.ExceptionType
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *RecorderResult) GetReplay() bool {
|
|
if x != nil {
|
|
return x.Replay
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *RecorderResult) GetVector() []int64 {
|
|
if x != nil {
|
|
return x.Vector
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *RecorderResult) GetVectorType() int64 {
|
|
if x != nil {
|
|
return x.VectorType
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *RecorderResult) GetVectorIndex() int64 {
|
|
if x != nil {
|
|
return x.VectorIndex
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *RecorderResult) GetVectorMinRatio() float64 {
|
|
if x != nil {
|
|
return x.VectorMinRatio
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *RecorderResult) GetVectorMaxRatio() float64 {
|
|
if x != nil {
|
|
return x.VectorMaxRatio
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *RecorderResult) GetExpectedBetCoin() int64 {
|
|
if x != nil {
|
|
return x.ExpectedBetCoin
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *RecorderResult) GetExpectedWinCoin() int64 {
|
|
if x != nil {
|
|
return x.ExpectedWinCoin
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *RecorderResult) GetSkipWinCheck() bool {
|
|
if x != nil {
|
|
return x.SkipWinCheck
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *RecorderResult) GetNoviceForceWin() bool {
|
|
if x != nil {
|
|
return x.NoviceForceWin
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *RecorderResult) GetSecondStageForceWin() bool {
|
|
if x != nil {
|
|
return x.SecondStageForceWin
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *RecorderResult) GetPaidForceWin() bool {
|
|
if x != nil {
|
|
return x.PaidForceWin
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *RecorderResult) GetBuySpinForceWin() bool {
|
|
if x != nil {
|
|
return x.BuySpinForceWin
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *RecorderResult) GetContinousZeroForceWin() bool {
|
|
if x != nil {
|
|
return x.ContinousZeroForceWin
|
|
}
|
|
return false
|
|
}
|
|
|
|
type NoticeUpdate struct {
|
|
AppVersion string
|
|
}
|
|
|
|
func (x *NoticeUpdate) GetAppVersion() string {
|
|
if x != nil {
|
|
return x.AppVersion
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type Broadcast struct {
|
|
Type int64
|
|
Param []string
|
|
}
|
|
|
|
func (x *Broadcast) GetType() int64 {
|
|
if x != nil {
|
|
return x.Type
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Broadcast) GetParam() []string {
|
|
if x != nil {
|
|
return x.Param
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type Activity struct {
|
|
ActivityType int64
|
|
StartTime int64
|
|
EndTime int64
|
|
Round int64 // 当前多少轮
|
|
}
|
|
|
|
func (x *Activity) GetActivityType() int64 {
|
|
if x != nil {
|
|
return x.ActivityType
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Activity) GetStartTime() int64 {
|
|
if x != nil {
|
|
return x.StartTime
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Activity) GetEndTime() int64 {
|
|
if x != nil {
|
|
return x.EndTime
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *Activity) GetRound() int64 {
|
|
if x != nil {
|
|
return x.Round
|
|
}
|
|
return 0
|
|
}
|