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
}