def compute(drop, obj, **kargs):
configs = get_config(DroppackConfig)
packs = configs[drop]
if not packs:
return
weight_packs = []
independent_packs = []
remain_packs = []
for pack in packs:
if pack.randomtype == RandomType.Weight:
weight_packs.append(pack)
else:
independent_packs.append(pack)
for pack in independent_packs:
prob = pack.dropProb / float(BASENUMBER)
if guess(prob):
remain_packs.append(pack)
if weight_packs:
dropProbs = [i.dropProb for i in weight_packs]
weighted = weighted_random3(weight_packs + [None],
dropProbs + [BASENUMBER - sum(dropProbs)])
if weighted:
remain_packs.append(weighted)
for pack in remain_packs:
add_pack(pack, obj, **kargs)
return
def lotteryHandler(reward, rsp, dropID, count):
configs = get_config(DroppackConfig)
packs = configs[dropID]
weight_packs = []
independent_packs = []
remain_packs = []
if count <= len(packs):
random.shuffle(packs)
packs = packs[:count]
for pack in packs:
if pack.randomtype == RandomType.Weight:
weight_packs.append(pack)
else:
independent_packs.append(pack)
for pack in independent_packs:
prob = pack.dropProb / float(BASENUMBER)
if guess(prob):
remain_packs.append(pack)
if weight_packs:
dropProbs = [i.dropProb for i in weight_packs]
weighted = weighted_random3(weight_packs, dropProbs)
if weighted:
remain_packs.append(weighted)
for pack in remain_packs:
add_pack(pack, reward)
if reward.computedDropPacks:
rsp.rewards.extend(build_reward(reward.computedDropPacks))
reward.clean_compute_droppacks()
random.shuffle(rsp.rewards)
return reward
def trigger_event(p):
if p.trigger_packs_flag:
return 0
prob = 0
triggers = get_config(TriggerAfterFbConfig)
for tg in triggers:
if p.trigger_event_sp >= tg.sp:
prob = tg.trigger_event_prob
else:
break
if not guess(prob):
return 0
configs = {
k: v
for k, v in get_config(TriggerEventConfig).items()
if p.level >= v.open_level
}
if not configs:
return 0
logger.debug("trigger_event_sp: %r", p.trigger_event_sp)
logger.debug("trigger event prob: %r", prob)
ID = weighted_random2([[k, v.prob] for k, v in configs.items()])
config = configs[ID]
logger.debug("%r", config)
if config.event_type == EventType.Fb:
logger.debug("EventType.Fb")
if p.is_pets_full():
logger.debug("pet full")
return 0
elif config.event_type == EventType.Chest:
logger.debug("EventType.Chest")
elif config.event_type == EventType.Chests:
logger.debug("EventType.Chests")
p.trigger_chests.clear()
elif config.event_type == EventType.Store:
logger.debug("EventType.Store")
elif config.event_type == EventType.Task:
logger.debug("EventType.Task")
taskID = config.event_param
if taskID in p.trigger_tasks:
tasks = {}
for k, v in configs.items():
if v.event_type == EventType.Task:
tasks[k, v.event_param] = v.prob
while tasks:
ID, taskID = weighted_random2(tasks.items())
if taskID not in p.trigger_tasks:
break
del tasks[ID, taskID]
if taskID in p.trigger_tasks: # 已经存在的任务，那么就不触发了
return 0
p.trigger_tasks.add(taskID)
p.trigger_event_sp = 0
p.trigger_event = ID
p.save()
p.sync()
return config.event_type
def get_hurts(monster):
prob = get_cons_value("TapCritProb") / float(100)
hurts = []
while sum(hurts) < monster.hp:
if guess(prob):
hurts.append(HURT_CRIT)
else:
hurts.append(HURT_NORM)
return hurts
def trigger_friendfb(p):
if p.trigger_packs_flag:
return None
now = datetime.now()
ts = time.mktime(now.timetuple())
if not p.friendfb_remain_count:
return None
lconfig = get_config(LevelupConfig).get(p.level)
if not lconfig or not lconfig.friendfb:
return None
if now.hour > 23 or now.hour < 9:
return None
last = p.friendfb_last_trigger_time
# 同一时间只存在一个秘境副本
if last and ts < last + FRIENDFB_INTERVAL:
return None
if not p.friendfb_triggered_count:
prob = 1
else:
prob = 0
triggers = get_config(TriggerAfterFbConfig)
for tg in triggers:
if p.friend_total_sp >= tg.sp:
prob = tg.friendfb_prob
else:
break
if not guess(prob):
return None
configs = get_config(FriendfbConfig)
samples = []
ffs_by_level = None
ffs_by_levels = get_config(FriendfbByLevelConfig)
for k in sorted(ffs_by_levels):
if p.level >= k:
ffs_by_level = ffs_by_levels[k]
if not ffs_by_level:
ffs_by_level = ffs_by_levels[min(ffs_by_levels)]
for ff in ffs_by_level:
if p.friendfb_last_trigger_fbID and \
p.friendfb_last_trigger_fbID == ff.fbID:
continue
ff = configs[ff.fbID]
samples.append([ff.fbID, ff.prob])
assert samples, "impossible"
fbID = weighted_random2(samples)
info = get_config(FriendfbConfig)[fbID]
friendfb = create_friendfb(p, info.fbID)
p.friendfb_list.add(friendfb['friendfbID'])
p.friend_total_sp = 0
p.friendfb_last_trigger_time = ts
p.friendfb_last_trigger_fbID = fbID
p.friendfb_triggered_count += 1
p.save()
p.sync()
return friendfb
def get_opponent_detail_by_strategy(self, player):
from config.configs import get_config, PvpDegreeConfig
configs = get_config(PvpDegreeConfig)
opps = []
score = player.totalbp
logger.debug("score: %d", score)
for config in configs:
logger.debug("start:%d, end:%d", config.start, config.end)
if score >= config.start and score < config.end:
logger.debug("prob:%f", config.prob)
if guess(config.prob):
logger.debug("guess:true")
opps = get_zombies_by_level(player.level)
break
if not opps:
opps = self.get_opponents_by_strategy(player.level, player.totalbp)
opps = filter(lambda s: s != player.entityID, opps)
logger.debug('random opps {}'.format(opps))
oppID = choice_one(opps)
assert oppID, 'not opp'
logger.debug("choose opp:%d", oppID)
return get_opponent_detail(oppID, type=LineupType.DEF)
def strengthen_equip(p, petID, equipID):
pet = p.pets.get(petID)
if not pet:
return msgTips.FAIL_MSG_INVALID_REQUEST, 0
equip = get_or_create_equip(p, pet, equipID)
if not equip:
return msgTips.FAIL_MSG_INVALID_REQUEST, 0
equip_config = get_config(NewEquipConfig).get(equip.prototypeID)
if not equip_config:
return msgTips.FAIL_MSG_INVALID_REQUEST, 0
binding = p.equipeds.get(equip.entityID)
if petID != binding:
return msgTips.FAIL_MSG_INVALID_REQUEST, 0
strengthen_configs = get_config(EquipStrengthenConfig)
strengthen_config = strengthen_configs.get(equip.level + 1)
if not strengthen_config:
return msgTips.FAIL_MSG_INVALID_REQUEST, 0
if p.level < strengthen_config.need_level:
return msgTips.FAIL_MSG_INVALID_REQUEST, 0
cost = {"money": strengthen_config.cost}
try:
apply_reward(p, {}, cost, type=RewardType.StrengthenEquip)
except AttrNotEnoughError:
return msgTips.FAIL_MSG_INVALID_REQUEST, 0
if guess(strengthen_config.rate / float(100)):
equip.level += 1
rollback = False
else:
equip.level = strengthen_config.rollback
rollback = True
update_ranking_equip(p, equip)
equip.save()
equip.sync()
from task.manager import on_strengthen_equip
on_strengthen_equip(p, equip)
p.save()
p.sync()
return SUCCESS, rollback
def fbHandler(reward, player, fbID, isfirst, rsp):
from config.configs import FbInfoConfig
from config.configs import SceneInfoConfig
from config.configs import RandomMonsterConfig
from config.configs import PetConfig
from config.configs import FbDropConfig
from scene.manager import get_monster_groups
from scene.constants import FbType
from campaign.manager import g_campaignManager
monsters = get_monster_groups(fbID)
sumsoul = 0
summoney = 0
petinfos = get_config(PetConfig)
randomms = get_config(RandomMonsterConfig)
config = get_config(FbInfoConfig)[fbID]
scene = get_config(SceneInfoConfig)[config.sceneID]
rewards = {}
drop_fields = ('itemfirst_id', 'itemdrops_id', 'exp_reward',
'monster_drop', 'gold_reward')
for i in drop_fields:
rewards[i] = getattr(config, i)
# 怪物掉落
droped_pets_count = 0 # 已经掉落葫芦数
layer_count = len(monsters.items())
mulriple = 1 # 倍数
if g_campaignManager.fb_drop_campaign.is_open():
cfg = g_campaignManager.fb_drop_campaign.get_current()
kind = (scene.type, scene.subtype)
flag = g_campaignManager.fb_drop_campaign.kind.get(kind, None)
if flag and flag & cfg.group > 0:
mulriple = cfg.reward_group
for layer, group in monsters.items():
monster_count = len(group)
for monsterindex, (monsterlevel, monsterID) in group.items():
if monsterID < 0: # 负数代表需要随机
sample = randomms[monsterID]
monsterID = weighted_random3(
sample.monsters + [None],
sample.weights + [BASENUMBER - sum(sample.weights)])
if not monsterID: # 可能不出现
continue
rsp.replaces.append(monsterID)
monster = petinfos[monsterID]
drop = rsp.drops.add(index=monsterindex, layer=layer)
# 必掉
# 金币 = sqrt(level)*coinUp/4+50
# 水晶 = sqrt(level)*expUp/7+30
money = monster.coinUp
soul = monster.expUp
# money = int(
# math.sqrt(monsterlevel) * monster.coinUp / float(4) + 50)
# soul = int(
# math.sqrt(monsterlevel) * monster.expUp / float(7) + 30)
drop.must.add(type=RewardItemType.Money, count=money)
drop.must.add(type=RewardItemType.Soul, count=soul)
summoney += money
sumsoul += soul
# boss
if layer == layer_count and monsterindex == monster_count:
alter_flag = False
if isfirst:
droppack = 0
else:
droppack = config.boss_drop
else:
if monster.dtype == 0:
# 从关卡配置中读取怪物掉落
droppack = rewards['monster_drop']
else:
# 从怪物表本身读取怪物掉落
droppack = monster.droppack
alter_flag = True
# 可能掉
# print monster.name
# print 'dtype', monster.dtype
# print 'droppack', droppack
if droppack:
pets = zip(
filter(lambda s: s,
[monster.drop1, monster.drop2, monster.drop3]),
[monster.num1, monster.num2, monster.num3])
if alter_flag:
if pets:
petID = weighted_random2(pets)
else:
petID = None
matID = monster.drop_piece
else:
petID = None
matID = None
if droped_pets_count >= 4: # 留一个位置给最后一波
if layer == layer_count:
skip_pet = (droped_pets_count >= 10)
else:
skip_pet = True
else:
skip_pet = False # not petID
compute(droppack,
reward,
itemID=petID,
matID=matID,
skip_pet=skip_pet)
if reward.computedDropPacks:
# 多倍掉落
if mulriple > 1:
for k, v in reward.computedDropPacks.items():
if isinstance(v, int):
reward.computedDropPacks[k] = v * mulriple
reward.attrReward[k] = v * mulriple
elif isinstance(v, (list, tuple)):
# computedDropPacks 并不是最终给的，所以要应用到 reward 上
reward.computedDropPacks[k] = [[
item, count * mulriple
] for (item, count) in v]
items = getattr(reward, k)
for (item,
count) in reward.computedDropPacks[k]:
for repl in items:
if repl[0] == item:
repl[1] += (mulriple - 1)
drop.maybe = build_reward(reward.computedDropPacks)
for m in drop.maybe:
if m.type in (RewardItemType.Pet, RewardItemType.Mat,
RewardItemType.Equip):
droped_pets_count += 1
reward.clean_compute_droppacks()
if summoney:
reward.attrReward['money'] = reward.attrReward.setdefault('money',
0) + summoney
# reward.attrReward['exp'] = reward.attrReward.setdefault('exp', 0)
if sumsoul:
reward.attrReward['soul'] = reward.attrReward.setdefault('soul',
0) + sumsoul
fb_exp = int(rewards['exp_reward'])
if fb_exp:
reward.attrReward['exp'] = reward.attrReward.setdefault('exp',
0) + fb_exp
rsp.rewards.add(type=RewardItemType.EXP, count=fb_exp)
fb_gold = int(rewards['gold_reward'])
if g_campaignManager.gold_campaign.is_open() and fb_gold:
reward.attrReward['gold'] = reward.attrReward.setdefault('gold',
0) + fb_gold
rsp.rewards.add(type=RewardItemType.Gold, count=fb_gold)
campaign_drop = 0
if config.type == FbType.Normal:
if g_campaignManager.normal_fb_campaign.is_open():
current = g_campaignManager.normal_fb_campaign.get_current()
if current:
campaign_drop = current.group
elif config.type == FbType.Advanced:
current = g_campaignManager.advanced_fb_campaign.get_current()
if current:
campaign_drop = current.group
if campaign_drop:
compute(campaign_drop, reward)
for each in build_reward(reward.computedDropPacks, cls=dict):
rsp.rewards.add(**each)
reward.clean_compute_droppacks()
# 关卡奖励
if isfirst: # 首通关卡
reward.clean_compute_droppacks()
# # 场景首通
# if all(
# map(lambda s: s in player.fbscores or s == fbID, scene.fbs)):
# # 是否该场景全通
# if scene.drop:
# compute(scene.drop, reward)
# rsp.first = build_reward(reward.computedDropPacks)
if rewards['itemfirst_id']: # 关卡首通
compute(rewards['itemfirst_id'], reward)
else:
if rewards['itemdrops_id']:
# 多倍掉落
reward.dropPacks = [[rewards['itemdrops_id'], mulriple]]
# 假概率掉落
config = get_config(FbDropConfig).get(fbID)
if config:
totalCount = player.fbscores.get(fbID, {}).get("totalCount", 0)
index = totalCount % len(config.probs)
prob = config.probs[index]
if guess(prob):
# 多倍掉落
reward.dropPacks.append([config.drop, mulriple])
return reward