# -*- coding:utf-8 -*-

matchTips = {
    "infos":[
        "当积分相同时，按报名先后顺序确定名次。",
        "除海选赛阶段，只有力争第一才可以晋级！",
        "天生我材必有用，有用就得斗地主！",
        "忽如一夜春风来，千人万人牌桌开！",
        "普通场获得勋章时，记得领取相应奖励哦。",
        "万人比赛火热上线，记得要关注哦。",
        "海选阶段要稳打，低于基础分会被淘汰哟！",
    ],
    "interval":5
}

match_conf_610 = {
    "desc":"开赛时间：满18人开赛\n赛制：ASS打立出局+定局淘汰\n报名费用：免费",
    "table.seat.count":3,
    "tips":matchTips,
    # 比赛开始条件定义
    "start":{
        "type":1, # 人满开赛
        "user.size":18, # 人满开赛的人数
        "maxplaytime":60 * 60, # 预订的比赛的最大时间，用于终止无法结束的比赛
        "fee.type":1, # 比赛开赛时，如果用户不在线，是否返还用户参赛费， 1--返还 0--不返还
    },
    # 报名费定义
    "fees":[
        {"name":"CHIP", "count":0}
    ],
    "stages":[
        {
            "type":1, # ASS 赛制
            "name":"18强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":1, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":4, # 最多打多少副牌
            "rise.user.refer":10, # 晋级参考人数, 参与人数<=此数时，当前阶段结束
            "rise.user.count":6, # 晋级人数
            "lose.user.chip":0.25, # <游戏基数%25被淘汰， 如果>1, 那么<此数值倍淘汰
            "chip.user":9000, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.3.base":0, # 开方放大发时的计算基准值
            "chip.base":1000, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":160, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.25, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是>=100的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
       {
            "type":2, # 淘汰 赛制
            "name":"6强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2, # 固定打多少副牌
            "rise.user.count":3, # 晋级人数
            "chip.user":3, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.3.base":300, # 开方放大发时的计算基准值
            "chip.base":100, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60*60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
       {
            "type":2, # 淘汰 赛制
            "name":"决赛", #
            "animation.type":3, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2, # 固定打多少副牌
            "rise.user.count":1, # 晋级人数
            "chip.user":2, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.base":100, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.user.2.rate":0.3, # 百分比带入时的带入比例
            "chip.times":60*60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        }
    ],
    "rank.rewards":[
        {
            "ranking":{"start":1, "end":1},
            "rewards":[
                {"name":"CHIP", "count":1000},
                {"name":"COUPON", "count":5},
                {"name":"EXP", "count":180}
            ],
            "desc":"1000金币+5个奖券"
        },
        {
            "ranking":{"start":2, "end":2},
            "rewards":[
                {"name":"CHIP", "count":700},
                {"name":"EXP", "count":90}
            ],
            "desc":"700金币"
        },
        {
            "ranking":{"start":3, "end":3},
            "rewards":[
                {"name":"CHIP", "count":400},
                {"name":"EXP", "count":90}
            ],
            "desc":"400金币"
        },
        {
            "ranking":{"start":4, "end":6},
            "rewards":[
                {"name":"CHIP", "count":100},
                {"name":"EXP", "count":60}
            ],
            "desc":"100金币"
        },
    ]
}

match_conf_611 = {
    "desc":"开赛时间：满9人开赛\n报名费用：2000金币\n赛制：定局淘汰(共2局,每局2副牌)",
    "table.seat.count":3,
    "tips":matchTips,
    # 比赛开始条件定义
    "start":{
        "type":1, # 人满开赛
        "user.size":9, # 人满开赛的人数
        "maxplaytime":60 * 60, # 预订的比赛的最大时间，用于终止无法结束的比赛
        "fee.type":1, # 比赛开赛时，如果用户不在线，是否返还用户参赛费， 1--返还 0--不返还
    },
    # 报名费定义
    "fees":[
        {"name":"CHIP", "count":2000}
    ],
    "stages":[
        {
            "type":2, # 淘汰 赛制
            "name":"9强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":1, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2, # 固定打多少副牌
            "rise.user.count":6, # 晋级人数
            "chip.user":3000, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.3.base":0, # 开方放大发时的计算基准值
            "chip.base":300, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":160, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.25, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2, # 淘汰 赛制
            "name":"决赛", #
            "animation.type":3, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2, # 固定打多少副牌
            "rise.user.count":3, # 晋级人数
            "chip.user":2, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3, # 开方放大发时的计算基准值
            "chip.base":100, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60*60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2, # 淘汰 赛制
            "name":"决赛", #
            "animation.type":3, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2, # 固定打多少副牌
            "rise.user.count":1, # 晋级人数
            "chip.user":2, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3, # 开方放大发时的计算基准值
            "chip.base":100, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60*60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        }
    ],
    "rank.rewards":[
        {
            "ranking":{"start":1, "end":1},
            "rewards":[
                {"name":"CHIP", "count":7000},
                {"name":"COUPON", "count":15},
                {"name":"EXP", "count":100}
            ],
            "desc":"7000金币+15个奖券"
        },
        {
            "ranking":{"start":2, "end":2},
            "rewards":[
                {"name":"CHIP", "count":4000},
                {"name":"EXP", "count":60}
            ],
            "desc":"4000金币"
        },
        {
            "ranking":{"start":3, "end":3},
            "rewards":[
                {"name":"CHIP", "count":2000},
                {"name":"EXP", "count":60}
            ],
            "desc":"2000金币"
        },
    ]
}

match_conf_612 = {
    "desc":"开赛时间：满3人开赛\n赛制：定局淘汰(共1局,每局2副牌)\n报名费用：5000金币",
    "table.seat.count":3,
    "tips":matchTips,
    # 比赛开始条件定义
    "start":{
        "type":1, # 人满开赛
        "user.size":3, # 人满开赛的人数
        "maxplaytime":60 * 60, # 预订的比赛的最大时间，用于终止无法结束的比赛
        "fee.type":1, # 比赛开赛时，如果用户不在线，是否返还用户参赛费， 1--返还 0--不返还
    },
    # 报名费定义
    "fees":[
        {"name":"CHIP", "count":5000}
    ],
    "stages":[
        {
            "type":2, # 淘汰 赛制
            "name":"决赛", #
            "animation.type":3, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":1, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2, # 固定打多少副牌
            "rise.user.count":1, # 晋级人数
            "chip.user":1000, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.3.base":0, # 开方放大发时的计算基准值
            "chip.base":100, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60*60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        }
    ],
    "rank.rewards":[
        {
            "ranking":{"start":1, "end":1},
            "rewards":[
                {"name":"CHIP", "count":10000},
                {"name":"EXP", "count":200}
            ],
            "desc":"10000金币"
        },
        {
            "ranking":{"start":2, "end":2},
            "rewards":[
                {"name":"CHIP", "count":3500},
                {"name":"EXP", "count":60}
            ],
            "desc":"3500金币"
        },
    ]
}

match_conf_614 = {
    "desc":"开赛时间：满120人开赛\n报名费用：一张参赛券",
    "table.seat.count":3,
    "tips":matchTips,
    # 比赛开始条件定义
    # 比赛开始条件定义
    "start":{
        "type":2,  # 定时赛
        "prepare.times":10, # 比赛准备时间
        "start.speed":6, # 比赛开赛时间
        "signin.times":60 * 15, # 比赛报名的时间限制，比赛开赛前多长时间内可以报名，0--不限制，>0 开赛前n秒内可以报名
        "user.minsize":18,  # 最低开赛的人数，否则比赛取消
        "user.groupsize":120,  # 比赛开始时的每组人数
        "user.next.group":0.5,  # 如果报名人数超过分组人数时，超过多少分组数加1
        "user.maxsize":1200,  # 最多开赛的人数，到达次数，不允许报名
        "maxplaytime":2 * 60 * 60,  # 预订的比赛的最大时间，用于终止无法结束的比赛
        "fee.type":1, # 比赛开赛时，如果用户不在线，是否返还用户参赛费， 1--返还 0--不返还
        "times":{
            "times_in_day":{"first":"00:00", "interval":10, "count":200},
            "days":{"first":"", "interval":"1d", "count":100},
        }
    },
    # 报名费定义
    "fees":[
        {"name":"CARDMATCH", "count":1}
    ],
    "stages":[
        {
             "type":1, # ASS 赛制
             "name":"海选赛", #
             "animation.type":0, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
             "seat.principles":1, # 1-随机 2-蛇型 3-种子 4-进入时间
             "card.count":8, # 最多打多少副牌
             "rise.user.refer":32, # 晋级参考人数, 参与人数<=此数时，当前阶段结束
             "rise.user.count":24, # 晋级人数
             "lose.user.chip":0.25, # <游戏基数%25被淘汰， 如果>1, 那么<此数值倍淘汰
             "chip.user":10000, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
             "chip.user.2.rate":0, # 百分比时携带的比例
             "chip.user.3.base":0, # 开方放大发时的计算基准值
             "chip.base":1000, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
             "chip.times":70, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
             "chip.grow":0.4, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是>=100的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
             "type":2, # 淘汰 赛制
             "name":"24强赛", #
             "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
             "seat.principles":2, # 1-随机 2-蛇型 3-种子 4-进入时间
             "card.count":2, # 固定打多少副牌
             "rise.user.count":12, # 晋级人数
             "chip.user":3, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
             "chip.user.3.base":300, # 百分比时的计算基准值
             "chip.base":100, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
             "chip.times":60*60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
             "chip.grow":0.5, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
         },
       {
            "type":2, # 淘汰 赛制
             "name":"12强赛", #
             "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2, # 固定打多少副牌
            "rise.user.count":6, # 晋级人数
            "chip.user":2, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3, # 开方放大发时的计算基准值
            "chip.base":100, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60*60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
       {
            "type":2, # 淘汰 赛制
             "name":"决赛", #
             "animation.type":2, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2, # 固定打多少副牌
            "rise.user.count":3, # 晋级人数
            "chip.user":2, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3, # 开方放大发时的计算基准值
            "chip.base":100, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60*60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
       {
            "type":2, # 淘汰 赛制
             "name":"决赛", #
             "animation.type":3, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":3, # 固定打多少副牌
            "rise.user.count":1, # 晋级人数
            "chip.user":2, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3, # 开方放大发时的计算基准值
            "chip.base":100, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60*60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
    ],
    "rank.rewards":[
        {
            "ranking":{"start":1, "end":1},
            "rewards":[
                {"name":"COUPON", "count":200},
                {"name":"EXP", "count":300}
            ],
            "desc":"200奖券"
        },
        {
            "ranking":{"start":2, "end":2},
            "rewards":[
                {"name":"CHIP", "count":5000},
                {"name":"EXP", "count":150}
            ],
            "desc":"5000金币"
        },
        {
            "ranking":{"start":3, "end":3},
            "rewards":[
                {"name":"CHIP", "count":2000},
                {"name":"EXP", "count":120}
            ],
            "desc":"2000金币"
        },
        {
            "ranking":{"start":4, "end":5},
            "rewards":[
                {"name":"CHIP", "count":1200},
                {"name":"EXP", "count":120}
            ],
            "desc":"1200金币"
        },
        {
            "ranking":{"start":6, "end":9},
            "rewards":[
                {"name":"CHIP", "count":600},
                {"name":"EXP", "count":90}
            ],
            "desc":"600金币"
        },
        {
            "ranking":{"start":10, "end":18},
            "rewards":[
                {"name":"CHIP", "count":300},
                {"name":"EXP", "count":90}
            ],
            "desc":"300金币"
        },
        {
            "ranking":{"start":19, "end":27},
            "rewards":[
                {"name":"CHIP", "count":200},
                {"name":"EXP", "count":60}
            ],
            "desc":"200金币"
        },
        {
            "ranking":{"start":28, "end":60},
            "rewards":[
                {"name":"CHIP", "count":100},
                {"name":"EXP", "count":60}
            ],
            "desc":"100金币"
        },
    ]
}

match_conf_615 = {
    "desc":"开赛时间：每日八场 \n报名费用：5000金币",
    "table.seat.count":3,
    "tips":matchTips,
    # 比赛开始条件定义
    "start":{
        "type":2,  # 定时赛
        "signin.times":60 * 30, # 比赛报名的时间限制，比赛开赛前多长时间内可以报名，0--不限制，>0 开赛前n秒内可以报名
        "user.minsize":222,  # 最低开赛的人数，否则比赛取消
        "user.groupsize":4000,  # 比赛开始时的每组人数
        "user.next.group":0,  # 如果报名人数超过分组人数时，超过多少分组数加1
        "user.maxsize":4000,  # 最多开赛的人数，到达次数，不允许报名
        "maxplaytime":2 * 60 * 60,  # 预订的比赛的最大时间，用于终止无法结束的比赛
        "fee.type":0, # 比赛开赛时，如果用户不在线，是否返还用户参赛费， 1--返还 0--不返还
        "times":{
            "times_in_day":{"list":["12:30", "21:00", "21:40", "22:30"]},
            "days":{"first":"","interval":"1d","count":100},
        }
    },
    # 报名费定义
    "fees":[
        {"name":"CHIP", "count":5000}
    ],
    "stages":[
        {
            "type":1, # ASS 赛制
            "name":"海选赛", #
            "animation.type":0, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":1, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":6, # 最多打多少副牌
            "rise.user.refer":200, # 晋级参考人数, 参与人数<=此数时，当前阶段结束
            "rise.user.count":96, # 晋级人数
            "lose.user.chip":0.25, # <游戏基数%25被淘汰， 如果>1, 那么<此数值倍淘汰
            "chip.user":12000, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0, # 百分比时携带的比例
            "chip.user.3.base":0, # 开方放大发时的计算基准值
            "chip.base":1000, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":80, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.3, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是>=100的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2, # 淘汰 赛制
            "name":"96强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2, # 固定打多少副牌
            "rise.user.count":48, # 晋级人数
            "chip.user":3, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.3.base":300, # 百分比代入值
            "chip.base":100, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2, # 淘汰 赛制
            "name":"48强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2, # 固定打多少副牌
            "rise.user.count":24, # 晋级人数
            "chip.user":2, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3, # 百分比代入值
            "chip.base":100, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2, # 淘汰 赛制
            "name":"24强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2, # 固定打多少副牌
            "rise.user.count":12, # 晋级人数
            "chip.user":2, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3, # 百分比代入值
            "chip.base":100, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2, # 淘汰 赛制
            "name":"12强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2, # 固定打多少副牌
            "rise.user.count":6, # 晋级人数
            "chip.user":2, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3, # 百分比代入值
            "chip.base":100, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2, # 淘汰 赛制
            "name":"6强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2, # 固定打多少副牌
            "rise.user.count":3, # 晋级人数
            "chip.user":2, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3, # 百分比代入值
            "chip.base":100, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2, # 淘汰 赛制
            "name":"决赛", #
            "animation.type":3, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2, # 固定打多少副牌
            "rise.user.count":1, # 晋级人数
            "chip.user":2, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3, # 百分比代入值
            "chip.base":100, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
    ],
    "rank.rewards":[
        {
            "ranking":{"start":1, "end":1},
            "rewards":[
                {"name":"COUPON", "count":10000},
                {"name":"EXP", "count":2000}
            ],
            "desc":"10000奖券"
        },
        {
            "ranking":{"start":2, "end":2},
            "rewards":[
                {"name":"CHIP", "count":300000},
                {"name":"EXP", "count":1000}
            ],
            "desc":"30万金币"
        },
        {
            "ranking":{"start":3, "end":3},
            "rewards":[
                {"name":"CHIP", "count":100000},
                {"name":"EXP", "count":1000}
            ],
            "desc":"10万金币"
        },
        {
            "ranking":{"start":4, "end":5},
            "rewards":[
                {"name":"CHIP", "count":50000},
                {"name":"EXP", "count":500}
            ],
            "desc":"5万金币"
        },
        {
            "ranking":{"start":6, "end":9},
            "rewards":[
                {"name":"CHIP", "count":30000},
                {"name":"EXP", "count":300}
            ],
            "desc":"3万金币"
        },
        {
            "ranking":{"start":10, "end":18},
            "rewards":[
                {"name":"CHIP", "count":10000},
                {"name":"EXP", "count":200}
            ],
            "desc":"1万金币"
        },
        {
            "ranking":{"start":19, "end":27},
            "rewards":[
                {"name":"CHIP", "count":5000},
                {"name":"EXP", "count":150}
            ],
            "desc":"5000金币"
        },
        {
            "ranking":{"start":28, "end":40},
            "rewards":[
                {"name":"CHIP", "count":3000},
                {"name":"EXP", "count":90}
            ],
            "desc":"3000金币"
        },
        {
            "ranking":{"start":41, "end":60},
            "rewards":[
                {"name":"CHIP", "count":1000},
                {"name":"EXP", "count":60}
            ],
            "desc":"1000金币"
        },
        {
            "ranking":{"start":61, "end":100},
            "rewards":[
                {"name":"CHIP", "count":500},
                {"name":"EXP", "count":60}
            ],
            "desc":"500金币"
        },
        {
            "ranking":{"start":101, "end":200},
            "rewards":[
                {"name":"CHIP", "count":200},
                {"name":"EXP", "count":60}
            ],
            "desc":"200金币"
        },
    ]
}

match_conf_619 = {
    "desc":"开赛时间：18:30\n报名费用：免费",
    "table.seat.count":3,
    "tips":matchTips,
    # 比赛开始条件定义
    "start":{
        "type":2,  # 定时赛
        "signin.times":60 * 30, # 比赛报名的时间限制，比赛开赛前多长时间内可以报名，0--不限制，>0 开赛前n秒内可以报名
        "user.minsize":3,  # 最低开赛的人数，否则比赛取消
        "user.groupsize":4000,  # 比赛开始时的每组人数
        "user.next.group":0,  # 如果报名人数超过分组人数时，超过多少分组数加1
        "user.maxsize":4000,  # 最多开赛的人数，到达次数，不允许报名
        "maxplaytime":2 * 60 * 60,  # 预订的比赛的最大时间，用于终止无法结束的比赛
        "fee.type":0, # 比赛开赛时，如果用户不在线，是否返还用户参赛费， 1--返还 0--不返还
        "times":{
            "times_in_day":{"list":["18:30"]},
            "days":{"first":"","interval":"1d","count":100},
        }
    },
    # 报名费定义
    "fees":[
        {"name":"CHIP", "count":0}
    ],
    "stages":[
        {
            "type":1, # ASS 赛制
            "name":"海选赛", #
            "animation.type":0, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":1, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":15, # 最多打多少副牌
            "rise.user.refer":30, # 晋级参考人数, 参与人数<=此数时，当前阶段结束
            "rise.user.count":24, # 晋级人数
            "lose.user.chip":0.25, # <游戏基数%25被淘汰， 如果>1, 那么<此数值倍淘汰
            "chip.user":12000, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0, # 百分比时携带的比例
            "chip.user.3.base":0, # 开方放大发时的计算基准值
            "chip.base":1000, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是>=100的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
       {
            "type":2, # 淘汰 赛制
            "name":"24强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":3, # 固定打多少副牌
            "rise.user.count":12, # 晋级人数
            "chip.user":3, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.3.base":300, # 开方放大发时的计算基准值
            "chip.base":100, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
       {
            "type":2, # 淘汰 赛制
            "name":"12强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":3, # 固定打多少副牌
            "rise.user.count":6, # 晋级人数
            "chip.user":2, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.2, # 开方放大发时的计算基准值
            "chip.base":100, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
       {
            "type":2, # 淘汰 赛制
            "name":"6强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":3, # 固定打多少副牌
            "rise.user.count":3, # 晋级人数
            "chip.user":2, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.2, # 开方放大发时的计算基准值
            "chip.base":100, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
       {
            "type":2, # 淘汰 赛制
            "name":"决赛", #
            "animation.type":3, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":3, # 固定打多少副牌
            "rise.user.count":1, # 晋级人数
            "chip.user":2, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.2, # 开方放大发时的计算基准值
            "chip.base":100, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
    ],
    "rank.rewards":[
        {
            "ranking":{"start":1, "end":1},
            "rewards":[
                {"name":"EXP", "count":3000}
            ],
            "desc":"500元+筹码礼盒+扑克2副"
        },
        {
            "ranking":{"start":2, "end":2},
            "rewards":[
                {"name":"COUPON", "count":30000},
                {"name":"EXP", "count":1500}
            ],
            "desc":"30000奖券+扑克2副"
        },
        {
            "ranking":{"start":3, "end":3},
            "rewards":[
                {"name":"COUPON", "count":10000},
                {"name":"EXP", "count":1500}
            ],
            "desc":"10000奖券+扑克2副"
        },
        {
            "ranking":{"start":4, "end":10},
            "rewards":[
                {"name":"COUPON", "count":5500},
                {"name":"EXP", "count":800}
            ],
            "desc":"5500奖券+扑克1副"
        },
        {
            "ranking":{"start":11, "end":20},
            "rewards":[
                {"name":"CHIP", "count":100000},
                {"name":"EXP", "count":500}
            ],
            "desc":"10万金币"
        },
    ]
}

match_conf_622 = {
    "desc":"开赛时间：每天六场\n报名费用：1000金币 ",
    "table.seat.count":3,
    "tips":matchTips,
    # 比赛开始条件定义
    "start":{
        "type":2,  # 定时赛
        "signin.times":60 * 30, # 比赛报名的时间限制，比赛开赛前多长时间内可以报名，0--不限制，>0 开赛前n秒内可以报名
        "user.minsize":24,  # 最低开赛的人数，否则比赛取消
        "user.groupsize":4000,  # 比赛开始时的每组人数
        "user.next.group":0,  # 如果报名人数超过分组人数时，超过多少分组数加1
        "user.maxsize":4000,  # 最多开赛的人数，到达次数，不允许报名
        "maxplaytime":2 * 60 * 60,  # 预订的比赛的最大时间，用于终止无法结束的比赛
        "fee.type":1, # 比赛开赛时，如果用户不在线，是否返还用户参赛费， 1--返还 0--不返还
        "times":{
            "times_in_day":{"list":["20:00", "20:20", "20:40",
                                    "21:00", "21:20", "21:40"]},
            "days":{"first":"","interval":"1d","count":100},
        }
    },
    # 报名费定义
    "fees":[
        {"name":"CHIP", "count":1000}
    ],
    "stages":[
        {
            "type":1, # ASS 赛制
            "name":"海选赛", #
            "animation.type":0, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":1, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":15, # 最多打多少副牌
            "rise.user.refer":30, # 晋级参考人数, 参与人数<=此数时，当前阶段结束
            "rise.user.count":24, # 晋级人数
            "lose.user.chip":0.25, # <游戏基数%25被淘汰， 如果>1, 那么<此数值倍淘汰
            "chip.user":12000, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0, # 百分比时携带的比例
            "chip.user.3.base":0, # 开方放大发时的计算基准值
            "chip.base":1000, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是>=100的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
       {
            "type":2, # 淘汰 赛制
            "name":"24强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":3, # 固定打多少副牌
            "rise.user.count":12, # 晋级人数
            "chip.user":3, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.3.base":300, # 开方放大发时的计算基准值
            "chip.base":100, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
       {
            "type":2, # 淘汰 赛制
            "name":"12强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":3, # 固定打多少副牌
            "rise.user.count":6, # 晋级人数
            "chip.user":2, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.2, # 开方放大发时的计算基准值
            "chip.base":100, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
       {
            "type":2, # 淘汰 赛制
            "name":"6强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":3, # 固定打多少副牌
            "rise.user.count":3, # 晋级人数
            "chip.user":2, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.2, # 开方放大发时的计算基准值
            "chip.base":100, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
       {
            "type":2, # 淘汰 赛制
            "name":"决赛", #
            "animation.type":3, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":3, # 固定打多少副牌
            "rise.user.count":1, # 晋级人数
            "chip.user":2, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.2, # 开方放大发时的计算基准值
            "chip.base":100, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
    ],
    "rank.rewards":[
        {
            "ranking":{"start":1, "end":1},
            "rewards":[
            ],
            "desc":"六瓶啤酒券+决赛票"
        },
        {
            "ranking":{"start":2, "end":2},
            "rewards":[
                {"name":"CHIP", "count":1500}
            ],
            "desc":"金币1500"
        },
        {
            "ranking":{"start":3, "end":3},
            "rewards":[
                {"name":"CHIP", "count":800}
            ],
            "desc":"金币800"
        },
    ]              
}

match_conf_626 = {
    "desc":"开赛时间：每日五场 \n报名费用：免费参与",
    "table.seat.count":3,
    "tips":matchTips,
    # 比赛开始条件定义
    "start":{
        "type":2,  # 定时赛
        "signin.times":60 * 10, # 比赛报名的时间限制，比赛开赛前多长时间内可以报名，0--不限制，>0 开赛前n秒内可以报名
        "user.minsize":222,  # 最低开赛的人数，否则比赛取消
        "user.groupsize":4000,  # 比赛开始时的每组人数
        "user.next.group":0,  # 如果报名人数超过分组人数时，超过多少分组数加1
        "user.maxsize":4000,  # 最多开赛的人数，到达次数，不允许报名
        "maxplaytime":2 * 60 * 60,  # 预订的比赛的最大时间，用于终止无法结束的比赛
        "fee.type":1, # 比赛开赛时，如果用户不在线，是否返还用户参赛费， 1--返还 0--不返还
        "times":{
            "times_in_day":{"list":["12:20", "20:15", "20:30",
                                    "20:45", "21:00"]},
            "days":{"first":"","interval":"1d","count":100},
        }
    },
    # 报名费定义
    "fees":[
    ],
    "stages":[
        {
            "type":1, # ASS 赛制
            "name":"海选赛", #
            "animation.type":0, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":1, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":10, # 最多打多少副牌
            "rise.user.refer":210, # 晋级参考人数, 参与人数<=此数时，当前阶段结束
            "rise.user.count":192, # 晋级人数
            "lose.user.chip":0.25, # <游戏基数%25被淘汰， 如果>1, 那么<此数值倍淘汰
            "chip.user":12000, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0, # 百分比时携带的比例
            "chip.user.3.base":0, # 开方放大发时的计算基准值
            "chip.base":1000, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":80, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.4, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是>=100的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2, # 淘汰 赛制
            "name":"192强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2, # 固定打多少副牌
            "rise.user.count":96, # 晋级人数
            "chip.user":3, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.3.base":300, # 开方放大发时的计算基准值
            "chip.base":100, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2, # 淘汰 赛制
            "name":"96强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2, # 固定打多少副牌
            "rise.user.count":48, # 晋级人数
            "chip.user":2, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3, # 百分比代入值
            "chip.base":100, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2, # 淘汰 赛制
            "name":"48强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2, # 固定打多少副牌
            "rise.user.count":24, # 晋级人数
            "chip.user":2, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3, # 百分比代入值
            "chip.base":100, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2, # 淘汰 赛制
            "name":"24强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2, # 固定打多少副牌
            "rise.user.count":12, # 晋级人数
            "chip.user":2, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3, # 百分比代入值
            "chip.base":100, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2, # 淘汰 赛制
            "name":"12强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2, # 固定打多少副牌
            "rise.user.count":6, # 晋级人数
            "chip.user":2, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3, # 百分比代入值
            "chip.base":100, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2, # 淘汰 赛制
            "name":"6强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2, # 固定打多少副牌
            "rise.user.count":3, # 晋级人数
            "chip.user":2, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3, # 百分比代入值
            "chip.base":100, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2, # 淘汰 赛制
            "name":"决赛", #
            "animation.type":3, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2, # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2, # 固定打多少副牌
            "rise.user.count":1, # 晋级人数
            "chip.user":2, # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3, # 百分比代入值
            "chip.base":100, # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60, # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5, # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
    ],
    "rank.rewards":[
        {
            "ranking":{"start":1, "end":1},
            "rewards":[
                {"name":"COUPON", "count":10000},
                {"name":"EXP", "count":2000}
            ],
            "desc":"10000个奖券"
        },
        {
            "ranking":{"start":2, "end":2},
            "rewards":[
                {"name":"CHIP", "count":300000},
                {"name":"EXP", "count":1000}
            ],
            "desc":"30万金币"
        },
        {
            "ranking":{"start":3, "end":3},
            "rewards":[
                {"name":"CHIP", "count":100000},
                {"name":"EXP", "count":1000}
            ],
            "desc":"10万金币"
        },
        {
            "ranking":{"start":4, "end":5},
            "rewards":[
                {"name":"CHIP", "count":50000},
                {"name":"EXP", "count":500}
            ],
            "desc":"5万金币"
        },
        {
            "ranking":{"start":6, "end":9},
            "rewards":[
                {"name":"CHIP", "count":30000},
                {"name":"EXP", "count":300}
            ],
            "desc":"3万金币"
        },
        {
            "ranking":{"start":10, "end":18},
            "rewards":[
                {"name":"CHIP", "count":10000},
                {"name":"EXP", "count":200}
            ],
            "desc":"1万金币"
        },
        {
            "ranking":{"start":19, "end":27},
            "rewards":[
                {"name":"CHIP", "count":5000},
                {"name":"EXP", "count":150}
            ],
            "desc":"5000金币"
        },
        {
            "ranking":{"start":28, "end":40},
            "rewards":[
                {"name":"CHIP", "count":3000},
                {"name":"EXP", "count":90}
            ],
            "desc":"3000金币"
        },
        {
            "ranking":{"start":41, "end":60},
            "rewards":[
                {"name":"CHIP", "count":1000},
                {"name":"EXP", "count":60}
            ],
            "desc":"1000金币"
        },
        {
            "ranking":{"start":61, "end":100},
            "rewards":[
                {"name":"CHIP", "count":500},
                {"name":"EXP", "count":60}
            ],
            "desc":"500金币"
        },
        {
            "ranking":{"start":101, "end":200},
            "rewards":[
                {"name":"CHIP", "count":200},
                {"name":"EXP", "count":60}
            ],
            "desc":"200金币"
        },
    ]
}

match_conf_627 = {
    "desc":"开赛时间：满18人开赛 \n报名费用：5000金币",
    "table.seat.count":3,
    "tips":matchTips,
    # 比赛开始条件定义
    "start":{
        "type":1,  # 定时赛
        "user.size":18,  # 最低开赛的人数，否则比赛取消
        "maxplaytime":2 * 60 * 60,  # 预订的比赛的最大时间，用于终止无法结束的比赛
        "fee.type":0, # 比赛开赛时，如果用户不在线，是否返还用户参赛费， 1--返还 0--不返还
    },
    # 报名费定义
    "fees":[
        {"name":"CHIP", "count":0}
    ],
    "stages":[
        {
            "type":1,  # ASS 赛制
            "name":"18强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":1,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":4,  # 最多打多少副牌
            "rise.user.refer":10,  # 晋级参考人数, 参与人数<=此数时，当前阶段结束
            "rise.user.count":6,  # 晋级人数
            "lose.user.chip":0.25,  # <游戏基数%25被淘汰， 如果>1, 那么<此数值倍淘汰
            "chip.user":9000,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.3.base":0,  # 开方放大发时的计算基准值
            "chip.base":1000,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":160,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.25,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是>=100的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
       {
            "type":2,  # 淘汰 赛制
            "name":"6强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":3,  # 晋级人数
            "chip.user":3,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.3.base":300,  # 开方放大发时的计算基准值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60*60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
       {
            "type":2,  # 淘汰 赛制
            "name":"决赛", #
            "animation.type":3, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":1,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.user.2.rate":0.3,  # 百分比带入时的带入比例
            "chip.times":60*60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        }
    ],
    "rank.rewards":[
        {
            "ranking":{"start":1, "end":1},
            "rewards":[
                {"name":"CHIP", "count":1000}
            ],
            "desc":"1000金币+360彩票券"
        },
        {
            "ranking":{"start":2, "end":2},
            "rewards":[
                {"name":"CHIP", "count":700}
            ],
            "desc":"700金币+360彩票券"
        },
        {
            "ranking":{"start":3, "end":3},
            "rewards":[
                {"name":"CHIP", "count":400}
            ],
            "desc":"400金币+360彩票券"
        },
        {
            "ranking":{"start":4, "end":6},
            "rewards":[
                {"name":"CHIP", "count":100}
            ],
            "desc":"100金币+360彩票券"
        },
    ]
}

match_conf_632 = {
    "desc":"开赛时间：每日五场 \n报名费用：免费参与",
    "table.seat.count":3,
    "tips":matchTips,
    # 比赛开始条件定义
    "start":{
        "type":2,  # 定时赛
        "signin.times":60 * 10, # 比赛报名的时间限制，比赛开赛前多长时间内可以报名，0--不限制，>0 开赛前n秒内可以报名
        "user.minsize":222,  # 最低开赛的人数，否则比赛取消
        "user.groupsize":6000,  # 比赛开始时的每组人数
        "user.next.group":0,  # 如果报名人数超过分组人数时，超过多少分组数加1
        "user.maxsize":6000,  # 最多开赛的人数，到达次数，不允许报名
        "maxplaytime":2 * 60 * 60,  # 预订的比赛的最大时间，用于终止无法结束的比赛
        "fee.type":0, # 比赛开赛时，如果用户不在线，是否返还用户参赛费， 1--返还 0--不返还
        "times":{
            "times_in_day":{"list":["12:45", "20:15", "21:45", "22:45", "23:15"]},
            "days":{"first":"","interval":"1d","count":100},
        }
    },
    # 报名费定义
    "fees":[
        {"name":"CHIP", "count":0}
    ],
    "stages":[
        {
            "type":1,  # ASS 赛制
            "name":"海选赛", #
            "animation.type":0, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":1,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":10,  # 最多打多少副牌
            "rise.user.refer":210,  # 晋级参考人数, 参与人数<=此数时，当前阶段结束
            "rise.user.count":192,  # 晋级人数
            "lose.user.chip":0.25,  # <游戏基数%25被淘汰， 如果>1, 那么<此数值倍淘汰
            "chip.user":12000,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0,  # 百分比时携带的比例
            "chip.user.3.base":0,  # 开方放大发时的计算基准值
            "chip.base":1000,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":80,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.4,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是>=100的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"192强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":96,  # 晋级人数
            "chip.user":3,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.3.base":300,  # 开方放大发时的计算基准值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"96强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":48,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"48强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":24,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"24强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":12,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"12强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":6,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"6强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":3,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"决赛", #
            "animation.type":3, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":1,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
    ],
    "rank.rewards":[
        {
            "ranking":{"start":1, "end":1},
            "rewards":[
                {"name":"COUPON", "count":10000}
            ],
            "desc":"10000奖券"
        },
        {
            "ranking":{"start":2, "end":2},
            "rewards":[
                {"name":"CHIP", "count":300000}
            ],
            "desc":"30万金币"
        },
        {
            "ranking":{"start":3, "end":3},
            "rewards":[
                {"name":"CHIP", "count":100000}
            ],
            "desc":"10万金币"
        },
        {
            "ranking":{"start":4, "end":5},
            "rewards":[
                {"name":"CHIP", "count":50000}
            ],
            "desc":"5万金币"
        },
        {
            "ranking":{"start":6, "end":9},
            "rewards":[
                {"name":"CHIP", "count":30000}
            ],
            "desc":"3万金币"
        },
        {
            "ranking":{"start":10, "end":18},
            "rewards":[
                {"name":"CHIP", "count":10000}
            ],
            "desc":"1万金币"
        },
        {
            "ranking":{"start":19, "end":27},
            "rewards":[
                {"name":"CHIP", "count":5000}
            ],
            "desc":"5000金币"
        },
        {
            "ranking":{"start":28, "end":40},
            "rewards":[
                {"name":"CHIP", "count":3000}
            ],
            "desc":"3000金币"
        },
        {
            "ranking":{"start":41, "end":60},
            "rewards":[
                {"name":"CHIP", "count":1000}
            ],
            "desc":"1000金币"
        },
        {
            "ranking":{"start":61, "end":100},
            "rewards":[
                {"name":"CHIP", "count":500}
            ],
            "desc":"500金币"
        },
        {
            "ranking":{"start":101, "end":200},
            "rewards":[
                {"name":"CHIP", "count":200}
            ],
            "desc":"200金币"
        },
    ]
}

match_conf_633 = {
    "desc":"开赛时间：20:30 \n报名费用：免费参与",
    "table.seat.count":3,
    "tips":matchTips,
    # 比赛开始条件定义
    "start":{
        "type":2,  # 定时赛
        "prepare.times":10, # 比赛准备时间
        "start.speed":6, # 比赛开赛时间
        "signin.times":60 * 20, # 比赛报名的时间限制，比赛开赛前多长时间内可以报名，0--不限制，>0 开赛前n秒内可以报名
        "user.minsize":500,  # 最低开赛的人数，否则比赛取消
        "user.groupsize":12000,  # 比赛开始时的每组人数
        "user.next.group":0,  # 如果报名人数超过分组人数时，超过多少分组数加1
        "user.maxsize":12000,  # 最多开赛的人数，到达次数，不允许报名
        "maxplaytime":2 * 60 * 60,  # 预订的比赛的最大时间，用于终止无法结束的比赛
        "fee.type":0, # 比赛开赛时，如果用户不在线，是否返还用户参赛费， 1--返还 0--不返还
        "times":{
            "times_in_day":{"list":["20:30"]},
            "days":{"list":["20150123", "20150124", "20150125", "20150126",
                            "20150127", "20150128", "20150130"]},
        }
    },
    # 报名费定义
    "fees":[
        {"name":"CHIP", "count":0}
    ],
    "stages":[
        {
            "type":1,  # ASS 赛制
            "name":"海选赛", #
            "animation.type":0, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":1,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":10,  # 最多打多少副牌
            "rise.user.refer":1000,  # 晋级参考人数, 参与人数<=此数时，当前阶段结束
            "rise.user.count":192,  # 晋级人数
            "lose.user.chip":0.25,  # <游戏基数%25被淘汰， 如果>1, 那么<此数值倍淘汰
            "chip.user":12000,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0,  # 百分比时携带的比例
            "chip.user.3.base":0,  # 开方放大发时的计算基准值
            "chip.base":1000,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":80,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.4,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是>=100的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"192强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":96,  # 晋级人数
            "chip.user":3,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.3.base":300,  # 开方放大发时的计算基准值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"96强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":48,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"48强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":24,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"24强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":12,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"12强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":6,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"6强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":3,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"决赛", #
            "animation.type":3, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":1,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
    ],
    "rank.rewards":[
        {
            "ranking":{"start":1, "end":1},
            "rewards":[
            ],
            "desc":"三开门品牌冰箱"
        },
        {
            "ranking":{"start":2, "end":2},
            "rewards":[
                {"name":"CHIP", "count":5000000}
            ],
            "desc":"500万金币"
        },
        {
            "ranking":{"start":3, "end":3},
            "rewards":[
                {"name":"CHIP", "count":2000000}
            ],
            "desc":"200万金币"
        },
        {
            "ranking":{"start":4, "end":5},
            "rewards":[
                {"name":"CHIP", "count":500000}
            ],
            "desc":"50万金币"
        },
        {
            "ranking":{"start":6, "end":9},
            "rewards":[
                {"name":"CHIP", "count":200000}
            ],
            "desc":"20万金币"
        },
        {
            "ranking":{"start":10, "end":18},
            "rewards":[
                {"name":"CHIP", "count":80000}
            ],
            "desc":"8万金币"
        },
        {
            "ranking":{"start":19, "end":27},
            "rewards":[
                {"name":"CHIP", "count":50000}
            ],
            "desc":"5万金币"
        },
        {
            "ranking":{"start":28, "end":60},
            "rewards":[
                {"name":"CHIP", "count":30000}
            ],
            "desc":"3万金币"
        },
        {
            "ranking":{"start":61, "end":100},
            "rewards":[
                {"name":"CHIP", "count":20000}
            ],
            "desc":"2万金币"
        },
        {
            "ranking":{"start":101, "end":1000},
            "rewards":[
                {"name":"CHIP", "count":10000}
            ],
            "desc":"1万金币"
        },
        {
            "ranking":{"start":1001, "end":5000},
            "rewards":[
                {"name":"CHIP", "count":2000}
            ],
            "desc":"2千金币"
        },
        {
            "ranking":{"start":5001, "end":10000},
            "rewards":[
                {"name":"CHIP", "count":1000}
            ],
            "desc":"1千金币"
        },
    ]
}

match_conf_634 = {
    "desc":"开赛时间：每日五场 \n报名费用：免费参与",
    "table.seat.count":3,
    "tips":matchTips,
    # 比赛开始条件定义
    "start":{
            "type":2,  # 定时赛
            "signin.times":60 * 10, # 比赛报名的时间限制，比赛开赛前多长时间内可以报名，0--不限制，>0 开赛前n秒内可以报名
            "user.minsize":40,  # 最低开赛的人数，否则比赛取消
            "user.groupsize":4000,  # 比赛开始时的每组人数
            "user.next.group":0,  # 如果报名人数超过分组人数时，超过多少分组数加1
            "user.maxsize":4000,  # 最多开赛的人数，到达次数，不允许报名
            "maxplaytime":2 * 60 * 60,  # 预订的比赛的最大时间，用于终止无法结束的比赛
            "fee.type":0, # 比赛开赛时，如果用户不在线，是否返还用户参赛费， 1--返还 0--不返还
            "times":{
                "times_in_day":{"list":["18:40"]},
                #"times_in_day":{"first":"00:00", "interval":2, "count":1000},
                "days":{"first":"", "interval":"1d", "count":100},
            }
    },
    # 报名费定义
    "fees":[
        {"name":"CHIP", "count":0}
    ],
    "stages":[{
                    "type":1,  # ASS 赛制
                    "name":"海选赛", #
                    "animation.type":0, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
                    "seat.principles":1,  # 1-随机 2-蛇型 3-种子 4-进入时间
                    "card.count":5,  # 最多打多少副牌
                    "rise.user.refer":30,  # 晋级参考人数, 参与人数<=此数时，当前阶段结束
                    "rise.user.count":24,  # 晋级人数
                    "lose.user.chip":0.25,  # <游戏基数%25被淘汰， 如果>1, 那么<此数值倍淘汰
                    "chip.user":10000,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
                    "chip.user.2.rate":0,  # 百分比时携带的比例
                    "chip.user.3.base":0,  # 开方放大发时的计算基准值
                    "chip.base":1000,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
                    "chip.times":80,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
                    "chip.grow":0.4,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是>=100的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
                },
                {
                    "type":2,  # 淘汰 赛制
                    "name":"24强赛", #
                    "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
                    "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
                    "card.count":2,  # 固定打多少副牌
                    "rise.user.count":12,  # 晋级人数
                    "chip.user":3,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
                    "chip.user.3.base":300,  # 开方放大发时的计算基准值
                    "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
                    "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
                    "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
                },
                {
                    "type":2,  # 淘汰 赛制
                    "name":"12强赛", #
                    "animation.type":3, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
                    "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
                    "card.count":2,  # 固定打多少副牌
                    "rise.user.count":6,  # 晋级人数
                    "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
                    "chip.user.2.rate":0.3,  # 百分比代入值
                    "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
                    "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
                    "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
                },
                {
                    "type":2,  # 淘汰 赛制
                    "name":"6强赛", #
                    "animation.type":3, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
                    "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
                    "card.count":2,  # 固定打多少副牌
                    "rise.user.count":3,  # 晋级人数
                    "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
                    "chip.user.2.rate":0.3,  # 百分比代入值
                    "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
                    "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
                    "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
                },
                {
                    "type":2,  # 淘汰 赛制
                    "name":"决赛", #
                    "animation.type":2, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
                    "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
                    "card.count":2,  # 固定打多少副牌
                    "rise.user.count":1,  # 晋级人数
                    "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
                    "chip.user.2.rate":0.3,  # 百分比代入值
                    "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
                    "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
                    "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
                },
               ],
    "rank.rewards":[
        {
            "ranking":{"start":1, "end":1},
            "rewards":[
            ],
            "desc":"羊年生肖蓝牙音箱一台"
        },
        {
            "ranking":{"start":2, "end":2},
            "rewards":[
            ],
            "desc":"星巴克羊年限定纪念杯"
        },
        {
            "ranking":{"start":3, "end":3},
            "rewards":[
            ],
            "desc":"罗技m105鼠标一个"
        },
        {
            "ranking":{"start":4, "end":5},
            "rewards":[
            ],
            "desc":"龙猫抱枕"
        },
        {
            "ranking":{"start":6, "end":10},
            "rewards":[
            ],
            "desc":"镭拓鼠标垫"
        },
    ]
}

match_conf_635 = {
    "desc":"开赛时间：20:30 \n报名费用：免费参与",
    "table.seat.count":3,
    "tips":matchTips,
    # 比赛开始条件定义
    "start":{
        "type":2,  # 定时赛
        "prepare.times":10, # 比赛准备时间
        "start.speed":6, # 比赛开赛时间
        "signin.times":60 * 20, # 比赛报名的时间限制，比赛开赛前多长时间内可以报名，0--不限制，>0 开赛前n秒内可以报名
        "user.minsize":500,  # 最低开赛的人数，否则比赛取消
        "user.groupsize":12000,  # 比赛开始时的每组人数
        "user.next.group":0,  # 如果报名人数超过分组人数时，超过多少分组数加1
        "user.maxsize":12000,  # 最多开赛的人数，到达次数，不允许报名
        "maxplaytime":2 * 60 * 60,  # 预订的比赛的最大时间，用于终止无法结束的比赛
        "fee.type":0, # 比赛开赛时，如果用户不在线，是否返还用户参赛费， 1--返还 0--不返还
        "times":{
            "times_in_day":{"list":["20:13", "21:14"]},
            "days":{"list":["20150212", "20150213", "20150214"]},
        }
    },
    # 报名费定义
    "fees":[
        {"name":"CHIP", "count":1314}
    ],
    "stages":[
        {
            "type":1,  # ASS 赛制
            "name":"海选赛", #
            "animation.type":0, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":1,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":10,  # 最多打多少副牌
            "rise.user.refer":3000,  # 晋级参考人数, 参与人数<=此数时，当前阶段结束
            "rise.user.count":192,  # 晋级人数
            "lose.user.chip":0.25,  # <游戏基数%25被淘汰， 如果>1, 那么<此数值倍淘汰
            "chip.user":12000,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0,  # 百分比时携带的比例
            "chip.user.3.base":0,  # 开方放大发时的计算基准值
            "chip.base":1000,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.4,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是>=100的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"192强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":96,  # 晋级人数
            "chip.user":3,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.3.base":300,  # 开方放大发时的计算基准值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"96强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":48,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.2,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"48强赛", #
            "animation.type":2, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":24,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.2,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"24强赛", #
            "animation.type":2, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":12,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.2,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"12强赛", #
            "animation.type":3, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":6,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"6强赛", #
            "animation.type":3, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":3,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"决赛", #
            "animation.type":3, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":3,  # 固定打多少副牌
            "rise.user.count":1,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.2,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
    ],
    "rank.rewards":[
        {
            "ranking":{"start":1, "end":1},
            "rewards":[
            ],
            "desc":"500元购物卡"
        },
        {
            "ranking":{"start":2, "end":2},
            "rewards":[
            ],
            "desc":"300元购物卡"
        },
        {
            "ranking":{"start":3, "end":3},
            "rewards":[
            ],
            "desc":"200元购物卡"
        },
        {
            "ranking":{"start":4, "end":5},
            "rewards":[
                {"name":"CHIP", "count":500000}
            ],
            "desc":"50万金币"
        },
        {
            "ranking":{"start":6, "end":9},
            "rewards":[
                {"name":"CHIP", "count":200000}
            ],
            "desc":"20万金币"
        },
        {
            "ranking":{"start":10, "end":18},
            "rewards":[
                {"name":"CHIP", "count":80000}
            ],
            "desc":"8万金币"
        },
        {
            "ranking":{"start":19, "end":27},
            "rewards":[
                {"name":"CHIP", "count":50000}
            ],
            "desc":"5万金币"
        },
        {
            "ranking":{"start":28, "end":60},
            "rewards":[
                {"name":"CHIP", "count":30000}
            ],
            "desc":"3万金币"
        },
        {
            "ranking":{"start":61, "end":100},
            "rewards":[
                {"name":"CHIP", "count":20000}
            ],
            "desc":"2万金币"
        },
        {
            "ranking":{"start":101, "end":1000},
            "rewards":[
                {"name":"CHIP", "count":10000}
            ],
            "desc":"1万金币"
        },
        {
            "ranking":{"start":1001, "end":5000},
            "rewards":[
                {"name":"CHIP", "count":2000}
            ],
            "desc":"2千金币"
        },
        {
            "ranking":{"start":5001, "end":10000},
            "rewards":[
                {"name":"CHIP", "count":1000}
            ],
            "desc":"1千金币"
        },
    ]
}

match_conf_636 = {
    "desc":"开赛时间：满99人开赛 \n报名费用：免费参与",
    "table.seat.count":3,
    "tips":matchTips,
    # 比赛开始条件定义
    "start":{
        "type":1,  # 定时赛
        "user.size":99,  # 最低开赛的人数，否则比赛取消
        "maxplaytime":2 * 60 * 60,  # 预订的比赛的最大时间，用于终止无法结束的比赛
        "fee.type":0, # 比赛开赛时，如果用户不在线，是否返还用户参赛费， 1--返还 0--不返还
    },
    # 报名费定义
    "fees":[
        {"name":"CHIP", "count":999}
    ],
    "stages":[
        {
            "type":1,  # ASS 赛制
            "name":"海选赛", #
            "animation.type":0, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":1,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":6,  # 最多打多少副牌
            "rise.user.refer":30,  # 晋级参考人数, 参与人数<=此数时，当前阶段结束
            "rise.user.count":24,  # 晋级人数
            "lose.user.chip":0.25,  # <游戏基数%25被淘汰， 如果>1, 那么<此数值倍淘汰
            "chip.user":10000,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0,  # 百分比时携带的比例
            "chip.user.3.base":0,  # 开方放大发时的计算基准值
            "chip.base":1000,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.3,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是>=100的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"24强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":12,  # 晋级人数
            "chip.user":3,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.3.base":300,  # 开方放大发时的计算基准值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"12强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":6,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.2,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"6强赛", #
            "animation.type":2, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":3,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.2,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"决赛", #
            "animation.type":3, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":3,  # 固定打多少副牌
            "rise.user.count":1,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.2,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
    ],
    "rank.rewards":[
        {
            "ranking":{"start":1, "end":1},
            "rewards":[
                {"name":"COUPON", "count":500}
            ],
            "desc":"500奖券"
        },
        {
            "ranking":{"start":2, "end":2},
            "rewards":[
                {"name":"CHIP", "count":20000}
            ],
            "desc":"20000金币"
        },
        {
            "ranking":{"start":3, "end":3},
            "rewards":[
                {"name":"CHIP", "count":8000}
            ],
            "desc":"8000金币"
        },
        {
            "ranking":{"start":4, "end":5},
            "rewards":[
                {"name":"CHIP", "count":4000}
            ],
            "desc":"4000金币"
        },
        {
            "ranking":{"start":6, "end":10},
            "rewards":[
                {"name":"CHIP", "count":2000}
            ],
            "desc":"2000金币"
        },
        {
            "ranking":{"start":11, "end":24},
            "rewards":[
                {"name":"CHIP", "count":1000}
            ],
            "desc":"1000金币"
        },
        {
            "ranking":{"start":25, "end":30},
            "rewards":[
                {"name":"CHIP", "count":800}
            ],
            "desc":"800金币"
        },
    ]
}

match_conf_637 = {
    "desc":"开赛时间：21:00 \n报名费用：888金币",
    "table.seat.count":3,
    "tips":matchTips,
    # 比赛开始条件定义
    "start":{
        "type":2,  # 定时赛
        "prepare.times":10, # 比赛准备时间
        "start.speed":6, # 比赛开赛时间
        "signin.times":60 * 20, # 比赛报名的时间限制，比赛开赛前多长时间内可以报名，0--不限制，>0 开赛前n秒内可以报名
        "user.minsize":500,  # 最低开赛的人数，否则比赛取消
        "user.groupsize":12000,  # 比赛开始时的每组人数
        "user.next.group":0,  # 如果报名人数超过分组人数时，超过多少分组数加1
        "user.maxsize":12000,  # 最多开赛的人数，到达次数，不允许报名
        "maxplaytime":2 * 60 * 60,  # 预订的比赛的最大时间，用于终止无法结束的比赛
        "fee.type":0, # 比赛开赛时，如果用户不在线，是否返还用户参赛费， 1--返还 0--不返还
        "times":{
            "times_in_day":{"list":["21:00"]},
            "days":{"list":["20150216", "20150217", "20150218", "20150219",
                            "20150220", "20150221", "20150222", "20150223",
                            "20150224", "20150225", "20150228",
                            ]},
        }
    },
    # 报名费定义
    "fees":[
        {"name":"CHIP", "count":888}
    ],
    "stages":[
        {
            "type":1,  # ASS 赛制
            "name":"海选赛", #
            "animation.type":0, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":1,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":10,  # 最多打多少副牌
            "rise.user.refer":3000,  # 晋级参考人数, 参与人数<=此数时，当前阶段结束
            "rise.user.count":192,  # 晋级人数
            "lose.user.chip":0.25,  # <游戏基数%25被淘汰， 如果>1, 那么<此数值倍淘汰
            "chip.user":12000,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0,  # 百分比时携带的比例
            "chip.user.3.base":0,  # 开方放大发时的计算基准值
            "chip.base":1000,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.4,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是>=100的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"192强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":96,  # 晋级人数
            "chip.user":3,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.3.base":300,  # 开方放大发时的计算基准值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"96强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":48,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.2,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"48强赛", #
            "animation.type":2, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":24,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.2,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"24强赛", #
            "animation.type":2, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":12,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.2,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"12强赛", #
            "animation.type":3, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":6,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"6强赛", #
            "animation.type":3, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":3,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"决赛", #
            "animation.type":3, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":3,  # 固定打多少副牌
            "rise.user.count":1,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.2,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
    ],
    "rank.rewards":[
        {
            "ranking":{"start":1, "end":1},
            "rewards":[
            ],
            "desc":"40寸品牌电视"
        },
        {
            "ranking":{"start":2, "end":2},
            "rewards":[
                {"name":"CHIP", "count":5000000}
            ],
            "desc":"500万金币"
        },
        {
            "ranking":{"start":3, "end":3},
            "rewards":[
                {"name":"CHIP", "count":2000000}
            ],
            "desc":"200万金币"
        },
        {
            "ranking":{"start":4, "end":5},
            "rewards":[
                {"name":"CHIP", "count":500000}
            ],
            "desc":"50万金币"
        },
        {
            "ranking":{"start":6, "end":9},
            "rewards":[
                {"name":"CHIP", "count":200000}
            ],
            "desc":"20万金币"
        },
        {
            "ranking":{"start":10, "end":18},
            "rewards":[
                {"name":"CHIP", "count":80000}
            ],
            "desc":"8万金币"
        },
        {
            "ranking":{"start":19, "end":27},
            "rewards":[
                {"name":"CHIP", "count":50000}
            ],
            "desc":"5万金币"
        },
        {
            "ranking":{"start":28, "end":60},
            "rewards":[
                {"name":"CHIP", "count":30000}
            ],
            "desc":"3万金币"
        },
        {
            "ranking":{"start":61, "end":100},
            "rewards":[
                {"name":"CHIP", "count":20000}
            ],
            "desc":"2万金币"
        },
        {
            "ranking":{"start":101, "end":1000},
            "rewards":[
                {"name":"CHIP", "count":10000}
            ],
            "desc":"1万金币"
        },
        {
            "ranking":{"start":1001, "end":5000},
            "rewards":[
                {"name":"CHIP", "count":2000}
            ],
            "desc":"2千金币"
        },
        {
            "ranking":{"start":5001, "end":10000},
            "rewards":[
                {"name":"CHIP", "count":1000}
            ],
            "desc":"1千金币"
        },
    ]
}

match_conf_638= {
    "desc":"开赛时间：22:15 \n报名费用：免费",
    "table.seat.count":3,
    "tips":matchTips,
    # 比赛开始条件定义
    "start":{
        "type":2,  # 定时赛
        "prepare.times":10, # 比赛准备时间
        "start.speed":6, # 比赛开赛时间
        "signin.times":60 * 15, # 比赛报名的时间限制，比赛开赛前多长时间内可以报名，0--不限制，>0 开赛前n秒内可以报名
        "user.minsize":500,  # 最低开赛的人数，否则比赛取消
        "user.groupsize":12000,  # 比赛开始时的每组人数
        "user.next.group":0,  # 如果报名人数超过分组人数时，超过多少分组数加1
        "user.maxsize":12000,  # 最多开赛的人数，到达次数，不允许报名
        "maxplaytime":2 * 60 * 60,  # 预订的比赛的最大时间，用于终止无法结束的比赛
        "fee.type":0, # 比赛开赛时，如果用户不在线，是否返还用户参赛费， 1--返还 0--不返还
        "times":{
            "times_in_day":{"list":["22:15"]},
            "days":{"list":["20150402", "20150403", "20150404", "20150405",
                            "20150406", "20150407", "20150408", "20150409",
                            "20150412"
                            ]},
        }
    },
    # 报名费定义
    "fees":[
        {"name":"CHIP", "count":0}
    ],
    "stages":[
        {
            "type":1,  # ASS 赛制
            "name":"海选赛", #
            "animation.type":0, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":1,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":10,  # 最多打多少副牌
            "rise.user.refer":210,  # 晋级参考人数, 参与人数<=此数时，当前阶段结束
            "rise.user.count":192,  # 晋级人数
            "lose.user.chip":0.25,  # <游戏基数%25被淘汰， 如果>1, 那么<此数值倍淘汰
            "chip.user":12000,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0,  # 百分比时携带的比例
            "chip.user.3.base":0,  # 开方放大发时的计算基准值
            "chip.base":1000,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":80,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.4,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是>=100的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"192强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":96,  # 晋级人数
            "chip.user":3,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.3.base":300,  # 开方放大发时的计算基准值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"96强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":48,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"48强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":24,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"24强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":12,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"12强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":6,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"6强赛", #
            "animation.type":1, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":3,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
        {
            "type":2,  # 淘汰 赛制
            "name":"决赛", #
            "animation.type":3, #0 海选赛; 1 N强赛; 2 决赛; 3 vs动画; 4 配桌动画
            "seat.principles":2,  # 1-随机 2-蛇型 3-种子 4-进入时间
            "card.count":2,  # 固定打多少副牌
            "rise.user.count":1,  # 晋级人数
            "chip.user":2,  # 当前阶段用户的初始游戏基数, 0-无变化 1-平方根 2-百分比 3-开方放大发 >10-重置当前所有用户的游戏基数
            "chip.user.2.rate":0.3,  # 百分比代入值
            "chip.base":100,  # 当前阶段游戏基数,如果<=0则继承上一个阶段的值，否则重置
            "chip.times":60 * 60,  # 游戏基数增长时间，单位秒,如果<=0则继承上一个阶段的值，否则重置
            "chip.grow":0.5,  # 当前阶段游戏基数增长的比率0.25意味25%增长，如果是大于99的整数，则为固定的增长, 如果<=0则继承上一个阶段的值，否则重置
        },
    ],
    "rank.rewards":[
        {
            "ranking":{"start":1, "end":1},
            "rewards":[
            ],
            "desc":"200元购物卡"
        },
        {
            "ranking":{"start":2, "end":2},
            "rewards":[
                {"name":"CHIP", "count":500000}
            ],
            "desc":"50万金币"
        },
        {
            "ranking":{"start":3, "end":3},
            "rewards":[
                {"name":"CHIP", "count":200000}
            ],
            "desc":"20万金币"
        },
        {
            "ranking":{"start":4, "end":6},
            "rewards":[
                {"name":"CHIP", "count":80000}
            ],
            "desc":"8万金币"
        },
        {
            "ranking":{"start":7, "end":12},
            "rewards":[
                {"name":"CHIP", "count":30000}
            ],
            "desc":"3万金币"
        },
        {
            "ranking":{"start":13, "end":24},
            "rewards":[
                {"name":"CHIP", "count":20000}
            ],
            "desc":"2万金币"
        },
        {
            "ranking":{"start":25, "end":48},
            "rewards":[
                {"name":"CHIP", "count":8000}
            ],
            "desc":"8000金币"
        },
        {
            "ranking":{"start":49, "end":92},
            "rewards":[
                {"name":"CHIP", "count":5000}
            ],
            "desc":"5000金币"
        },
        {
            "ranking":{"start":93, "end":192},
            "rewards":[
                {"name":"CHIP", "count":2000}
            ],
            "desc":"2000金币"
        },
        {
            "ranking":{"start":193, "end":1000},
            "rewards":[
                {"name":"CHIP", "count":800}
            ],
            "desc":"800金币"
        },
        {
            "ranking":{"start":1001, "end":5000},
            "rewards":[
                {"name":"CHIP", "count":300}
            ],
            "desc":"300金币"
        },
        {
            "ranking":{"start":5001, "end":10000},
            "rewards":[
                {"name":"CHIP", "count":100}
            ],
            "desc":"100金币"
        },
    ]
}
