def faction_donate(self, msgtype, body):
p = self.player
if not p.factionID:
return fail_msg(msgtype, msgTips.FAIL_MSG_FACTION_HAS_NOT_FACTION)
if p.todayfp_donate >= p.todayfp_donate_max:
return fail_msg(msgtype,
msgTips.FAIL_MSG_FACTION_EXCEED_DAILY_DONATE_LIMIT)
req = poem_pb.FactionDonate()
req.ParseFromString(body)
config = get_config(FactionDonateConfig)[1]
fp = req.gold / config.arg1 * config.arg2
if req.gold < config.arg1 or \
req.gold % 10 != 0 or \
(p.todayfp_donate + fp) > p.todayfp_donate_max:
return fail_msg(msgtype,
msgTips.FAIL_MSG_FACTION_DONATE_AMOUNT_INVALID)
try:
cc = get_config(FactionDonateConfig)[3]
apply_reward(p, {'fp': fp / cc.arg1 * cc.arg2},
cost={'gold': req.gold},
type=RewardType.DonateFaction)
except AttrNotEnoughError:
return fail_msg(msgtype, msgTips.FAIL_MSG_FACTION_NOT_ENOUGH_GOLD)
totalfp = Faction.incr_attribute(p.factionID, 'totalfp', fp)
p.totalfp += fp
p.todayfp_donate += fp
p.save()
p.sync()
rsp = poem_pb.FactionDonateResponse()
rsp.totalfp = totalfp
return success_msg(msgtype, rsp)
def faction_info(self, msgtype, body):
p = self.player
factionID = p.factionID
if not factionID:
return fail_msg(msgtype, msgTips.FAIL_MSG_FACTION_HAS_NOT_FACTION)
info = get_faction_info(p.factionID)
if not info:
p.factionID = 0
p.save()
p.sync()
return fail_msg(msgtype, msgTips.FAIL_MSG_FACTION_HAS_NOT_FACTION)
if info['dflag']:
if info['leaderID'] == p.entityID:
# 检查解散公会
if p.dismissCD:
if p.dismissCD < int(time.time()):
faction = Faction.simple_load(factionID, ['name'])
faction.delete()
FactionnameIndexing.unregister(faction.name)
FactionRankRanking.del_key(factionID)
clean_faction(p.entityID)
p.dismissCD = 0
p.save()
p.sync()
return fail_msg(
msgtype,
msgTips.FAIL_MSG_FACTION_ALREADY_DISMISSED)
if not info:
return fail_msg(msgtype, msgTips.FAIL_MSG_FACTION_NOT_THIS_FACTION)
rsp = poem_pb.FactionInfo(**info)
return success_msg(msgtype, rsp)
def faction_accept_invite(self, msgtype, body):
p = self.player
if p.factionID:
return fail_msg(msgtype,
msgTips.FAIL_MSG_FACTION_ALREADY_HAD_FACTION)
if is_applied(p):
return fail_msg(msgtype, msgTips.FAIL_MSG_FACTION_ALREADY_APPLYED)
req = poem_pb.AcceptInvite()
req.ParseFromString(body)
try:
faction = Faction.load(req.factionID)
except EntityNotFoundError:
safe_remove(self.player.inviteFactionSet, req.factionID)
return fail_msg(msgtype, msgTips.FAIL_MSG_FACTION_NOT_THIS_FACTION)
if req.isaccept:
if not isrecommend(req.factionID):
return fail_msg(msgtype,
msgTips.FAIL_MSG_FACTION_MEMBERS_LIMIT_EXCEED)
join_faction(p.entityID, faction.factionID)
else:
safe_remove(self.player.inviteFactionSet, req.factionID)
safe_remove(faction.inviteset, self.player.entityID)
faction.save()
p.save()
p.sync()
return success_msg(msgtype, '')
def friend_gift(self, msgtype, body):
p = self.player
req = poem_pb.GiftFriend()
req.ParseFromString(body)
logger.debug(req)
count = len(req.ids)
if p.friend_gift_used_count + count > p.friend_gift_max_count:
return fail_msg(msgtype, reason="次数不足，无法赠送能量")
for i in req.ids:
if i not in p.friendset:
return fail_msg(msgtype, reason="该玩家还不是你的好友")
if i in p.friendgiftedset:
return fail_msg(msgtype, reason="已经给该玩家赠送过能量")
sp = 1
money = 1000
rewards = {"sp": sp, "money": money}
for i in req.ids:
proxy.gift_friend(i, p.name, rewards)
p.friend_gift_used_count += 1
p.friendgiftedset.add(i)
self_rewards = {"sp": sp * count, "money": money * count}
apply_reward(p, self_rewards, type=RewardType.GiftFriend)
p.save()
p.sync()
rsp = poem_pb.GiftFriendResponse(ids=req.ids)
build_reward_msg(rsp, self_rewards)
return success_msg(msgtype, rsp)
def user_out(self, msgtype, body):
req = rainbow_pb.KickOutRequest()
req.ParseFromString(body)
room_obj = g_roomManager.get_room(self.player.room_id)
if not room_obj:
return fail_msg(msgtype, msgTips.FAIL_MSG_ROOM_NOT_EXIST)
if room_obj.master_entity_id != self.player.entityID:
return fail_msg(msgtype, msgTips.FAIL_MSG_ROOM_KICK_OUT_PERMISSION_DENY)
rsp_user_kick_out = rainbow_pb.UserKickOut()
rsp_user_kick_out.kick_out_id = req.kick_out_id
msg = success_msg(msgid.ROOM_USER_BEEN_KICK_OUT, rsp_user_kick_out)
for role in room_obj.roles:
if role.entityID == 0:
continue
p = g_entityManager.get_player(role.entityID)
if p:
if p.entityID == req.kick_out_id:
p.room_id = 0
p.pos_index = 0
p.save()
g_playerManager.sendto(role.entityID, msg)
if role.entityID == req.kick_out_id:
role.entityID = 0
role.username = ''
return success_msg(msgtype, '')
def flowerboss_friendfb_reborn(self, msgtype, body):
req = poem_pb.RebornFriendfb()
req.ParseFromString(body)
p = self.player
try:
hp, fbID = simple_load_friendfb(req.friendfbID, 'hp', 'fbID')
except DoesNotExistsException:
return fail_msg(msgtype,
msgTips.FAIL_MSG_FRIENDFB_ALREADY_DISAPPEARED)
if hp <= 0:
return fail_msg(msgtype, reason='BOSS已经被击杀了')
if not player_is_dead(p, req.friendfbID):
return fail_msg(msgtype, reason="无须复活")
count = p.friendfb_reborn_counts[req.friendfbID] =\
p.friendfb_reborn_counts.get(req.friendfbID, 0) + 1
cost = get_cons_value("FlowerBossRebornCost") * count
try:
apply_reward(p, {},
cost={"gold": cost},
type=RewardType.FriendfbReborn)
except AttrNotEnoughError:
return fail_msg(msgtype, reason="钻石不足")
p.friendfb_deads.remove(req.friendfbID)
if fbID in p.friendfb_deadtimes:
del p.friendfb_deadtimes[fbID]
p.friendfb_buff = get_cons_value("GveBuffAddition")
p.save()
p.sync()
return success_msg(msgtype, "")
def send_message(self, msgtype, body):
req = poem_pb.SendMessageRequest()
req.ParseFromString(body)
p = self.player
if not g_chatManager.check_limited((p.entityID, req.type)):
return fail_msg(msgtype,
msgTips.FAIL_MSG_CHAT_SPEAK_TOO_FREQUENTLY)
if req.type == ChatType.Faction:
if not p.factionID:
return fail_msg(msgtype, reason="未加入公会")
if req.type == ChatType.Group:
if not p.groupID:
return fail_msg(msgtype, reason="未加入同门")
content = trie.trie_replace(dirty_words_trie, req.content, u'*')
assert req.type in (ChatType.World, ChatType.Faction, ChatType.Group)
if p.chat_blocked:
m = Message(type=req.type,
content=content,
name=p.name,
entityID=p.entityID,
prototypeID=p.prototypeID,
is_faction_leader=p.faction_is_leader)
return success_msg(msgid.RECV_MESSAGE, m)
g_chatManager.send(req.type,
content,
p.name,
p.entityID,
prototypeID=p.prototypeID,
is_faction_leader=p.faction_is_leader,
borderID=p.borderID)
return success_msg(msgtype, '')
def friend_invite_list(self, msgtype, body):
p = self.player
if not p.factionID:
return success_msg(msgtype, "")
req = poem_pb.InviteFriendList()
req.ParseFromString(body)
logger.debug(req)
try:
ownerID, fbID = simple_load_friendfb(req.friendfbID, 'ownerID',
'fbID')
except DoesNotExistsException:
return fail_msg(msgtype,
msgTips.FAIL_MSG_FRIENDFB_ALREADY_DISAPPEARED)
if p.entityID != ownerID:
return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
invitees = load_friendfb_invitees(req.friendfbID)
# invitees 起码会有发现者
assert invitees, "impossible"
fields = ['entityID', 'name', 'prototypeID', 'level', "borderID"]
# 过滤已经邀请的好友(2016-02-18 改会公会成员)
f = Faction.simple_load(p.factionID, ["memberset"])
rs = Player.batch_load(list(set(f.memberset) - invitees), fields)
rsp = poem_pb.InviteFriendListResponse()
config = get_config(FriendfbConfig)[fbID]
for each in rs:
info = {}
if each.level < config.openlv:
continue
for f in fields:
info[f] = getattr(each, f)
info['id'] = info['entityID']
rsp.friends.add(**info)
return success_msg(msgtype, rsp)
def city_dungeon_start_fight(self, msgtype, body):
p = self.player
if not p.factionID:
return fail_msg(msgtype, msgTips.FAIL_MSG_FACTION_HAS_NOT_FACTION)
if not g_campaignManager.city_dungeon_campaign.is_open():
return fail_msg(msgtype, msgTips.FAIL_MSG_CITY_CAMPAIGN_CLOSED)
# {{ 自动复活， 使用每日PVP的
now = int(time.time())
if (now > p.daily_dead_cd and p.daily_dead_resume < p.daily_dead_cd)\
or not p.daily_dead_cd:
lineup = p.lineups.get(LineupType.City, [])
for each in lineup:
pet = p.pets.get(each)
if pet:
pet.daily_dead = False
pet.daily_restHP = 0
pet.save()
pet.sync()
p.daily_dead_resume = now
p.daily_dead_cd = now
# }}
p.save()
p.sync()
if now < p.daily_dead_cd:
return fail_msg(msgtype, reason="你已经死亡")
rsp = poem_pb.CityDungeonStartFightResponse()
rsp.mg = g_cityDungeon.get_mg(p)
rsp.verify_code = PlayerFightLock.lock(p.entityID, force=True)
return success_msg(msgtype, rsp)
def dlc_dispatch(self, msgtype, body):
p = self.player
req = poem_pb.DlcDispatchRequest()
req.ParseFromString(body)
# 检查关卡开启
if not validate_prevs(p, req.fbID):
return fail_msg(msgtype, reason="前置未通")
if not validate_dlc_fb(p, req.fbID):
return fail_msg(msgtype, reason="此关已通")
# 校验精灵
if not validate_start(p, req.fbID, req.pets):
return fail_msg(msgtype, reason="精灵校验失败")
pets = []
now = int(time.time())
for pp in req.pets:
if pp:
pet = p.pets.get(pp)
if not pet or max(pet.dispatched - now, 0):
return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
pets.append(pet)
config = get_config(DlcFbInfoConfig)[req.fbID]
for pet in pets:
pet.dispatched = now + config.cd
pet.save()
pet.sync()
p.dlc_dispatch[req.fbID] = {"pets": req.pets, "time": now + config.cd}
dd = dict(p.dlc_dispatch[req.fbID])
dd["cd"] = max(dd["time"] - now, 0)
rsp = poem_pb.DlcDispatchInfo(**dd)
p.save()
p.sync()
return success_msg(msgtype, rsp)
def dlc_done_task(self, msgtype, body):
p = self.player
today = datedate.today()
req = poem_pb.DlcTaskDoneRequest()
req.ParseFromString(body)
# logger.debug(req)
dlc_task = get_config(DlcTaskConfig).get(req.taskID)
if not dlc_task:
return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
campaign = g_dlcCampaignManager.campaigns.get(dlc_task.dlcID)
if not campaign or not campaign.is_open() or\
is_done(p, req.taskID, today):
return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
now = int(time.time())
cd = p.dlc_tasks_cd.get(dlc_task.dlcID, 0)
if max(cd - now, 0):
return fail_msg(msgtype, reason="cd中")
try:
apply_reward(
p, {}, cost={"gold": dlc_task.gold},
type=RewardType.DlcDoneTask)
except AttrNotEnoughError:
return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
done_task(p, req.taskID, today)
from task.manager import on_dlc_score
on_dlc_score(p)
p.save()
p.sync()
return success_msg(msgtype, '')
def giftkey(self, msgtype, body):
from protocol.poem_pb import Giftkey, GiftkeyResponse
from config.configs import get_config, GiftkeyConfig
from reward.manager import open_reward, build_reward_msg, RewardType
from giftkey import use_key, InvalidGiftkeyError, ExceedUseCountError, ExceedDeallineError
player = self.player
req = Giftkey()
req.ParseFromString(body)
try:
giftID = use_key(player, req.key)
except InvalidGiftkeyError:
return fail_msg(msgtype, reason='无效的兑换码')
except ExceedUseCountError:
return fail_msg(msgtype, reason='已经达到最大兑换次数了')
except ExceedDeallineError:
return fail_msg(msgtype, reason='已经超过有效期了')
gift = get_config(GiftkeyConfig)[giftID]
reward = open_reward(RewardType.Giftkey, gift)
result = reward.apply(player)
player.save()
player.sync()
rsp = GiftkeyResponse()
build_reward_msg(rsp, result)
gm_logger.info(
{'giftkey': {
'entityID': player.entityID,
'giftkey': req.key
}})
return success_msg(msgtype, rsp)
def maze_case_recv(self, msgtype, body):
p = self.player
req = poem_pb.MazeEventRequest()
req.ParseFromString(body)
index = req.index or 0
try:
event = p.mazes[index]
except IndexError:
return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
count = 1
cost = {}
if req.treble:
count = 3
cost = {"gold": p.maze_case_cost}
if event.get("type") != MazeEventType.Case:
return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
drop = event.get("argv", 0)
drops = [drop] * count
if drop:
reward = open_reward(RewardType.MazeDrop, *drops)
if cost:
reward.cost_after(p, **cost)
result = reward.apply(p)
p.mazes.remove(event)
p.touch_mazes()
p.save()
p.sync()
rsp = poem_pb.MazeCaseResponse()
build_reward_msg(rsp, result)
return success_msg(msgtype, rsp)
def group_create(self, msgtype, body):
p = self.player
if p.groupID:
return fail_msg(msgtype, msgTips.FAIL_MSG_GROUP_ALREADY_JOINED)
req = poem_pb.GroupCreate()
req.ParseFromString(body)
name, err = validate_name(req.name)
if err:
return fail_msg(msgtype, err)
try:
GroupnameIndexing.register(0, name) # 占位
except DuplicateIndexException:
return fail_msg(
msgtype, msgTips.FAIL_MSG_GROUP_DUPLICATE_FACTION_NAME)
try:
g = Group.create(
name=name, leaderID=p.entityID)
g.save()
except EntityExistsException:
GroupnameIndexing.unregister(name)
return fail_msg(msgtype, msgTips.FAIL_MSG_GROUP_CREATE_FAIL)
err = join_group(p.entityID, g.groupID)
if err:
GroupnameIndexing.unregister(name)
return fail_msg(msgtype, err)
GroupnameIndexing.pool.execute(
'HSET', GroupnameIndexing.key, name, g.groupID) # 更新
recommend(g.groupID)
p.save()
p.sync()
return success_msg(msgtype, '')
def gve_reborn(self, msgtype, body):
p = self.player
if not gve_is_open(p):
return fail_msg(msgtype, msgTips.FAIL_MSG_GROUP_GVE_NOT_OPEN)
if gve_is_end(p):
return fail_msg(msgtype, msgTips.FAIL_MSG_GROUP_GVE_ALREADY_END)
end_time = g_campaignManager.gve_campaign.get_end_time()
if p.gve_state != GveEntity.GveEntityStateDead:
return fail_msg(msgtype, reason="没有死亡")
if p.gve_reborn_rest_count <= 0:
return fail_msg(msgtype, reason="没有复活次数了")
try:
apply_reward(
p, {},
cost={"gold": get_cons_value("GveRebornCost")},
type=RewardType.GveReborn)
except AttrNotEnoughError:
return fail_msg(msgtype, reason="钻石不足")
count = int(Group.pool.execute(
"SREM", "gve_deads_g{%s}" % p.groupID, p.entityID))
g = Group.simple_load(
p.groupID, ["gve_end_cd", "gve_activateds"])
g.gve_activateds.load()
if count < len(g.gve_activateds):
g.gve_end_cd = end_time
g.save()
p.gve_state = GveEntity.GveEntityStateNormal
p.gve_buff = get_cons_value("GveBuffAddition")
p.gve_reborn_rest_count -= 1
sync_gve_entity(g.gve_activateds, p.entityID)
p.save()
p.sync()
return success_msg(msgtype, "")
def vip_packs_buy(self, msgtype, body):
req = poem_pb.VipPacksBuyRequest()
req.ParseFromString(body)
p = self.player
from entity.manager import save_guide
save_guide(p, req.guide_type) # 保存新手引导进度
now = int(time.time())
today = datedate.fromtimestamp(now)
config = get_config(VipPacksConfig).get(req.ID)
if not config:
return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
if config.gift_type != VipPackType.Daily:
if now < config.gift_starttime or now > config.gift_lasttime:
return fail_msg(msgtype, msgTips.FAIL_MSG_VIP_PACKS_EXPIRED)
rest = get_vip_pack_rest_count(p, req.ID, today=today)
if rest != -1 and rest <= 0:
return fail_msg(msgtype, reason="次数不足")
if p.vip < config.vip_level:
return fail_msg(msgtype, reason="VIP不足")
cost = parse_reward([{
'count': config.discount_price,
'type': config.discount_price_type}])
gain = parse_reward(config.rewards)
try:
apply_reward(p, gain, cost=cost, type=RewardType.VipPacks)
except AttrNotEnoughError:
return fail_msg(msgtype, reason="消耗不足")
set_vip_packs_limits(p, config.ID, now)
p.vip_packs_today_bought_count += 1
p.save()
p.sync()
return success_msg(msgtype, "")
def mall_open(self, msgtype, body):
p = self.player
req = poem_pb.MallOpen()
req.ParseFromString(body)
logger.debug(req)
cost = 0
if req.type == MallType.Golden:
if p.mall_golden_open_cost:
cost = p.mall_golden_open_cost
f = 'mall_golden_opened'
n = 'OpenGoldenMallCost'
elif req.type == MallType.Silver:
if p.mall_silver_open_cost:
cost = p.mall_silver_open_cost
f = 'mall_silver_opened'
n = 'OpenSilverMallCost'
if not cost:
return fail_msg(msgtype, reason="不满足开启条件")
try:
apply_reward(
p, {}, {'gold': get_cons_value(n)}, type=RewardType.MallOpen)
except AttrNotEnoughError:
return fail_msg(msgtype, reason="钻石不足")
setattr(p, f, True)
refresh_mall(p, req.type)
p.save()
p.sync()
return success_msg(msgtype, '')
def resolve_gold(self, msgtype, body):
# 炼银处理
from config.configs import get_config
from config.configs import VipConfig
from config.configs import GoldenFingerConfig
from config.configs import GoldFingerLvLimitConfig
p = self.player
items = get_config(GoldenFingerConfig)
vipcfg = get_config(VipConfig)
resolvegold = get_config(GoldFingerLvLimitConfig)[1]
golden_finger_count = vipcfg[p.vip].golden_finger_count
cur_time = p.resolvegold_time + 1
if p.level < resolvegold.openlv:
return fail_msg(msgtype, reason='等级不足')
if p.resolvegold_time >= golden_finger_count:
return fail_msg(msgtype, reason='炼银次数已用尽')
item = items[cur_time]
if p.gold < item.golden:
return fail_msg(msgtype, reason='钻石不足')
from reward.base import apply_reward
from reward.constants import RewardType
cost = dict(gold=item.golden)
reward = dict(money=item.silver)
apply_reward(p, reward, cost, type=RewardType.ResolveGold)
p.resolvegold_time += 1
from task.manager import on_golden_finger
on_golden_finger(p)
p.save()
p.sync()
return self.resolve_gold_msg(msgtype, "")
def trigger_chest_recv(self, msgtype, body):
p = self.player
if not check_trigger_event_type(p, EventType.Chest):
return fail_msg(msgtype, reason="无触发事件或错误的事件类型")
req = poem_pb.TriggerChestRecvRequest()
req.ParseFromString(body)
config = get_config(TriggerEventConfig)[p.trigger_event]
chest = get_config(TriggerChestConfig).get(config.event_param)
if not chest:
return fail_msg(msgtype, reason="不存在的宝箱")
if req.is_double:
cost = {"gold": get_cons_value("TriggerChestDoubleCost")}
gain = {}
for i in range(get_cons_value("TriggerChestMultiple")):
gain = combine_reward([chest.reward], [], data=gain)
else:
cost = {}
gain = parse_reward([chest.reward])
try:
apply_reward(p, gain, cost=cost, type=RewardType.TriggerChest)
except AttrNotEnoughError:
return fail_msg(msgtype, reason="钻石不足")
p.trigger_event = 0
p.save()
p.sync()
rsp = poem_pb.TriggerChestRecv()
build_reward_msg(rsp, gain)
return success_msg(msgtype, rsp)
def login(self, msgtype, body):
limited, message = self.access_limited()
if limited:
return fail_msg(msgtype, reason=message)
req = poem_pb.LoginWorldRequest()
req.ParseFromString(body)
if not req.verify_code:
logger.error(
'invalid verify_code %s, body %r', req.verify_code, body)
return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
session = SessionStore(get_session_pool(), str(req.verify_code))
if not req.userID or session.uid != req.userID:
return fail_msg(msgtype, reason="登录超时，请重试")
self.userID = req.userID
# get role list
user = User.load(self.userID)
rsp = poem_pb.LoginWorldResponse()
entityIDs = user.roles.get(settings.REGION['ID'])
if not entityIDs:
return success_msg(msgtype, rsp)
# if len(entityIDs) == 1:
# entityID = entityIDs[0]
# else:
# entityID = req.entityID
if not req.entityID:
entityID = min(entityIDs)
else:
entityID = req.entityID
rsp.roles.add(id=entityID)
rsp.need_rename = PlayerDuplicateNamesIndexing.exists(entityID)
logger.debug(rsp)
return success_msg(msgtype, rsp)
def trigger_chests_recv(self, msgtype, body):
p = self.player
if not check_trigger_event_type(p, EventType.Chests):
return fail_msg(msgtype, reason="无触发事件或错误的事件类型")
config = get_config(TriggerEventConfig)[p.trigger_event]
chest = get_config(TriggerChestsConfig).get(config.event_param)
if len(p.trigger_chests) > 0:
cost = {"gold": get_cons_value("TriggerChestsMoreCost")}
else:
cost = {}
rests = set(range(len(chest.rewards))) - p.trigger_chests
if not rests:
return fail_msg(msgtype, reason="已经没有宝箱了")
index = choice_one(list(rests))
is_best = False
if index == 0:
p.trigger_event = 0
is_best = True
gain = parse_reward([chest.rewards[index]])
try:
apply_reward(p, gain, cost=cost, type=RewardType.TriggerChests)
except AttrNotEnoughError:
return fail_msg(msgtype, reason="钻石不足")
p.trigger_chests.add(index)
p.save()
p.sync()
rsp = poem_pb.TriggerChestsRecv(is_best=is_best)
build_reward_msg(rsp, gain)
return success_msg(msgtype, rsp)
def gem_compose(self, msgtype, body):
req = poem_pb.GemComposeRequest()
req.ParseFromString(body)
p = self.player
config = get_config(GemConfig).get(req.gemID, None)
if not config:
return fail_msg(msgtype, code=msgTips.FAIL_MSG_INVALID_REQUEST)
if config.gupr <= 0:
return fail_msg(msgtype, code=msgTips.FAIL_MSG_INVALID_REQUEST)
have = p.gems.get(config.ID, 0)
if have >= config.compose_consume:
count = have / config.compose_consume if req.all else 1
cost = config.compose_consume * count
cost = parse_reward(
[dict(type=RewardItemType.Gem, arg=config.ID, count=cost)])
reward = parse_reward(
[dict(type=RewardItemType.Gem, arg=config.gupr, count=count)])
result = apply_reward(p,
reward,
cost=cost,
type=RewardType.GemCompose)
else:
return fail_msg(msgtype, reason='宝石不足')
p.save()
p.sync()
return success_msg(msgtype, '')
def trigger_store_buy(self, msgtype, body):
p = self.player
if not check_trigger_event_type(p, EventType.Store):
return fail_msg(msgtype, reason="无触发事件或错误的事件类型")
config = get_config(TriggerEventConfig)[p.trigger_event]
goods = get_config(TriggerStoreConfig).get(config.event_param)
if not goods:
return fail_msg(msgtype, reason="没有这个商品")
cost = parse_reward([{
'count': goods.discount_price,
'type': goods.discount_price_type}])
gain = parse_reward([goods.reward])
try:
apply_reward(p, gain, cost=cost, type=RewardType.TriggerStore)
except AttrNotEnoughError as e:
if e.attr == "gold":
return fail_msg(msgtype, reason="钻石不足")
elif e.attr == "money":
return fail_msg(msgtype, reason="金币不足")
else:
return fail_msg(msgtype, reason="消耗不足")
p.trigger_event = 0
p.save()
p.sync()
return success_msg(msgtype, "")
def faction_invite_infos(self, msgtype, body):
factionID = self.player.factionID
if not factionID:
return fail_msg(msgtype, msgTips.FAIL_MSG_FACTION_HAS_NOT_FACTION)
faction = Faction.simple_load(factionID, ['leaderID', 'inviteset'])
if self.player.entityID != faction.leaderID:
return fail_msg(msgtype,
msgTips.FAIL_MSG_FACTION_PERMISSION_DENIED)
memberIDs = faction.inviteset
thumbs = g_entityManager.get_players_info(memberIDs, [
'entityID',
'name',
'career',
'prototypeID',
'totalfp',
'level',
'todayfp',
'lastlogin',
])
rsp = poem_pb.MemberInfos()
now = int(time.time())
for thumb in thumbs:
last = int(time.mktime(thumb['lastlogin'].timetuple()))
thumb['time'] = now - last
# rs = get_lineup_details_atk(thumb['entityID'])
detail = get_opponent_detail(thumb["entityID"])
thumb.update(detail)
rsp.members.add(**thumb)
return success_msg(msgtype, rsp)
def dlc_dispatch_end(self, msgtype, body):
p = self.player
req = poem_pb.DlcDispatchEndRequest()
req.ParseFromString(body)
# 检查关卡开启
if not validate_prevs(p, req.fbID):
return fail_msg(msgtype, reason="前置未通")
if not validate_dlc_fb(p, req.fbID):
return fail_msg(msgtype, reason="此关已通")
dispatch = p.dlc_dispatch.get(req.fbID)
if not dispatch:
return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
now = int(time.time())
if now < dispatch["time"]:
return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
reward = apply_dlc_reward(req.fbID, isfirst=is_first(p, req.fbID))
apply_reward(p, reward, type=RewardType.DlcDispatch)
set_dlc_progress(p, req.fbID)
set_fb_score(p, req.fbID, 1) # FIXME
from task.manager import on_end_dlc_fb
from task.manager import on_dlc_score
from task.manager import on_end_spec_fb_count
from task.manager import on_end_fb_count
on_end_spec_fb_count(p, req.fbID)
on_end_fb_count(p, req.fbID)
on_end_dlc_fb(p, req.fbID)
on_dlc_score(p)
p.save()
p.sync()
rsp = poem_pb.DlcDispatchEnd()
build_reward_msg(rsp, reward)
return success_msg(msgtype, rsp)
def breed(self, msgtype, body):
from protocol.poem_pb import BreedRequest
req = BreedRequest()
req.ParseFromString(body)
player = self.player
from entity.manager import save_guide
save_guide(player, req.guide_type) # 保存新手引导进度
c = req.count or 1
pet = player.pets.get(req.petID)
if not pet:
return fail_msg(msgtype, reason='精灵不存在')
if pet.level + c > pet.max_level:
return fail_msg(msgtype, reason='超过最大等级')
# info = get_config(PetConfig)[pet.prototypeID]
# money, soul = breed_cost(info.cexp, pet.level, pet.level + c)
cost = {}
for level in range(pet.level, pet.level + c):
linfo = get_config(PetLevelOrSkillLevelUpConfig)[level]
combine_reward([linfo.units_cost1, linfo.units_cost2], {},
data=cost)
try:
apply_reward(player, None, cost=cost, type=RewardType.BreedPet)
except AttrNotEnoughError:
return fail_msg(msgtype, reason="金币或水晶不足")
pet.level += c
pet.save()
from task.manager import on_breed
on_breed(player, pet)
# player.update_power()
player.save()
pet.sync()
player.sync()
return success_msg(msgtype, '')
def friend_friendfb_end(self, msgtype, body):
p = self.player
req = poem_pb.EndFriendfb()
req.ParseFromString(body)
if not PlayerFightLock.unlock(p.entityID, req.verify_code):
return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
assert p.cache_friendfbID, "impossible"
rsp = poem_pb.EndFriendfbResponse()
try:
createtime, hp, fbID = simple_load_friendfb(
p.cache_friendfbID, 'createtime', 'hp', 'fbID')
except DoesNotExistsException:
error_code = msgTips.FAIL_MSG_FRIENDFB_ALREADY_DISAPPEARED
else:
if hp <= 0:
error_code = msgTips.FAIL_MSG_FRIENDFB_ALREADY_DEAD
# return fail_msg(msgtype, reason='BOSS已经被击杀了')
else:
from pvp.manager import send_fight_verify
from fightverifier.direct_verifier import verify
send_fight_verify(p, req.fight)
if not verify(p, req.fight):
return fail_msg(msgtype,
msgTips.FAIL_MSG_FIGHT_VERIFY_FAILED)
error_code = 0
now = int(time.time())
if if_boss(p.cache_friendfbID) and\
not if_boss_campaign_opened(p.cache_friendfbID) or \
not if_boss(p.cache_friendfbID) and \
now > createtime + FRIENDFB_INTERVAL:
error_code = msgTips.FAIL_MSG_FRIENDFB_ALREADY_DISAPPEARED # NOQA
else:
info = get_config(FriendfbConfig)[fbID]
if info.drop:
r = open_reward(RewardType.Friendfb, info.drop)
result = r.apply(p)
build_reward_msg(rsp, result)
damage = max(req.fight.total_damage or 0, 0)
hp = hurt_boss(p, fbID, p.cache_friendfbID, damage)
if hp <= 0:
if if_boss(p.cache_friendfbID):
# 提前发奖
bc = get_boss_campaign(p.cache_friendfbID)
proxy.notify_boss_campaign_end(bc.config.ID)
entityID = bc.get_by_rank(1)
proxy.sync_on_task_change(entityID,
TaskCond.FriendfbFirst,
p.cache_friendfbID)
else:
give_reward(p.cache_friendfbID)
on_friendfb_count(p, fbID)
else:
p.friendfb_deads.add(p.cache_friendfbID)
p.friendfb_deadtimes[fbID] = now
p.friendfb_buff = 0
p.save()
p.sync()
rsp.error_code = error_code
return success_msg(msgtype, rsp)
def city_dungeon_panel(self, msgtype, body):
p = self.player
if not p.factionID:
return fail_msg(msgtype, msgTips.FAIL_MSG_FACTION_HAS_NOT_FACTION)
if not g_campaignManager.city_dungeon_campaign.is_open():
return fail_msg(msgtype, msgTips.FAIL_MSG_CITY_CAMPAIGN_CLOSED)
rsp = poem_pb.CityDungeonPanel()
g_cityDungeon.get_panel(p, rsp)
return success_msg(msgtype, rsp)
def inner(self, msgtype, body):
l = self.player.level
if level and l < level:
return fail_msg(msgtype, reason="等级不足")
config = get_config(LevelupConfig).get(l, None)
if tag and config:
flag = bool(getattr(config, tag, True))
if not flag:
return fail_msg(msgtype, reason="等级不足")
return f(self, msgtype, body)
def trigger_task_info(self, msgtype, body):
p = self.player
if not check_trigger_event_type(p, EventType.Task):
return fail_msg(msgtype, reason="无触发事件或错误的事件类型")
config = get_config(TriggerEventConfig)[p.trigger_event]
task = get_config(TaskConfig).get(config.event_param)
if not task:
return fail_msg(msgtype, reason="不存在的任务")
rsp = poem_pb.TriggerTaskInfo(task_name=task.title)
return success_msg(msgtype, rsp)
