def clean_faction(entityID):
p = g_entityManager.get_player(entityID)
if not p:
p = Player.simple_load(entityID, ['factionID', 'applyFactions'])
if p.factionID:
faction = Faction.simple_load(p.factionID, ['memberset'])
if faction:
safe_remove(faction.memberset, p.entityID)
faction.save()
p.last_factionID = p.factionID
gm_logger.info({
'faction': {
'entityID': p.entityID,
'type': 'quit_faction',
'factionID': p.factionID,
}
})
p.factionID = 0
p.fp = 0
p.faction_name = ''
p.faction_level = 0
p.faction_is_leader = False
p.applyFactions.clear()
# p.applyFactionTime = 0
p.save()
if g_entityManager.get_player(entityID):
p.sync()
def join_faction(entityID, factionID):
faction = Faction.simple_load(factionID, [
"level", "name", "memberset", "inviteset", "applyset",
"strengthen_hp_level", "strengthen_at_level", "strengthen_ct_level",
"strengthen_df_level"
])
# recommend
level = FactionRankRanking.get_score(factionID) or 1
limit = get_config(FactionLimitConfig)[level].limit
if limit - len(faction.memberset) <= 1:
unrecommend(factionID)
clean_faction(entityID)
p = g_entityManager.get_player(entityID)
if not p:
p = Player.simple_load(entityID, [
'inviteFactionSet',
'factionID',
'last_factionID',
'strengthen_at_level',
'strengthen_hp_level',
'strengthen_ct_level',
'strengthen_df_level',
])
p.factionID = faction.factionID
p.faction_name = faction.name
p.faction_level = level
now = int(time.time())
p.joinFactionTime = now
# FIXME
for fid in p.inviteFactionSet:
f = Faction.simple_load(fid, ['inviteset'])
safe_remove(f.inviteset, p.entityID)
f.save()
p.inviteFactionSet.clear()
if p.factionID != p.last_factionID:
p.totalfp = 0
p.todayfp_donate = 0
p.todayfp_task = 0
p.todayfp_sp = 0
faction.memberset.add(p.entityID)
safe_remove(faction.applyset, p.entityID)
safe_remove(faction.inviteset, p.entityID)
if g_entityManager.get_player(entityID):
p.load_faction()
p.sync()
p.save()
faction.save()
gm_logger.info({
'faction': {
'entityID': p.entityID,
'type': 'join_faction',
'factionID': faction.factionID,
}
})
def quit_group(entityID, groupID):
g = Group.simple_load(groupID, ["leaderID", "members", "invites"])
if not g:
return msgTips.FAIL_MSG_GROUP_NOT_IN_THIS
g.members.load()
g.invites.load()
p = g_entityManager.get_player(entityID)
if not p:
p = Player.simple_load(entityID, ["groupID", "group_last_kicked_time"])
if not p.groupID:
return msgTips.FAIL_MSG_GROUP_HAS_NOT_JOINED # "未加入同门了"
if p.entityID not in g.members:
return msgTips.FAIL_MSG_GROUP_NOT_IN_THIS
del g.members[p.entityID]
if p.entityID in g.invites:
g.invites.remove(p.entityID)
if p.entityID == g.leaderID:
rest = sorted(g.members.items(), key=lambda v: v[1]["jointime"])
if rest:
new_leaderID, _ = rest[0]
g.leaderID = new_leaderID
recommend(groupID)
g.save()
p.groupID = 0
now = int(time.time())
p.group_last_kicked_time = now
p.save()
return SUCCESS
def update_player_group_damage(entityID, damage):
p = g_entityManager.get_player(entityID)
if not p:
return
p.gve_groupdamage = damage
p.save()
p.sync()
def join_group(entityID, groupID):
now = int(time.time())
p = g_entityManager.get_player(entityID)
if not p:
p = Player.simple_load(entityID, ["groupID", "group_last_kicked_time"])
if p.groupID:
return msgTips.FAIL_MSG_GROUP_ALREADY_JOINED
if now < p.group_last_kicked_time + ONE_DAY:
return msgTips.FAIL_MSG_GROUP_KICKED_RECENTLY
g = Group.simple_load(groupID, ["members", "applys"])
g.members.load()
g.applys.load()
if len(g.members) >= MAX_MEMBERS_COUNT:
return msgTips.FAIL_MSG_GROUP_LIMITED_EXCEED
if p.entityID in g.members:
return msgTips.FAIL_MSG_GROUP_ALREADY_JOINED_THIS
g.members[p.entityID] = {"jointime": now, "intimate": 0}
if len(g.members) >= MAX_MEMBERS_COUNT:
unrecommend(groupID)
g.applys.clear()
else:
recommend(groupID)
try:
del g.applys[p.entityID]
except KeyError:
pass
g.save()
p.groupID = groupID
p.save()
return SUCCESS
def run():
ranks = self.BossCampaignRanking.get_range_by_score(
"-inf", "+inf", withscores=True)
configs = get_config(FriendfbRewardConfig)
group = get_config(FriendfbRewardByFbIDConfig).get(
self.config.fbID, [])
configs = [configs[e.ID] for e in group]
rank = 1
for index, entityID in enumerate(ranks, 0):
if index % 2 == 1:
continue
for r in configs:
start, end = r.range
if rank >= start and (not end or rank <= end):
p = g_entityManager.get_player(entityID)
rewards = {
self.identification: {
"rewards": r.rewards,
"damage": ranks[rank],
"rank": rank
}
}
if p:
give_reward(p, rewards=rewards)
else:
keep_reward(entityID, rewards)
break
rank += 1
def discredit(manager, entityID, current_floor):
"""以当前派驻层向下查找可派驻层，暂存收益并派驻或结算派驻收益"""
now = int(time.time())
floor = manager.avail_floor(current_floor)
p = g_entityManager.get_player(entityID)
if p:
if floor:
# 可派驻，暂存当前派驻层收益
manager.stash_earnings(p)
p.climb_tower_accredit_floor = floor
p.climb_tower_accredit_stash_time = now
# 结束时间作为 score
score = int(p.climb_tower_accredit_cd)
# 取消当前层派驻
manager.floors[current_floor].idx.unregister(p.entityID)
manager.floors[floor].idx.register(p.entityID, score)
else:
# 取消派驻
manager.floors[current_floor].idx.unregister(p.entityID)
p.climb_tower_accredit_cd = now
# 结算派驻收益
manager.tally_up(p)
p.save()
p.sync()
def resetAttr(entityID, attrName):
from entity.manager import g_entityManager
entityID = int(entityID)
p = g_entityManager.get_player(entityID)
if not p:
from player.model import Player, OfflineAttrType
Player.add_offline_attr(entityID,
Player.getAttributeIDByName(attrName),
None,
type=OfflineAttrType.Reset)
return SUCCESS
else:
try:
f = p.fields[attrName]
if callable(f.default):
default = f.default()
else:
default = f.default
setattr(p, attrName, default)
p.save()
p.sync()
except:
import traceback
traceback.print_exc()
return FAILURE
return SUCCESS
def modifyfbId(playerId):
''' 修改用户副本进度 '''
from scene.constants import FbType
from scene.manager import set_fb_score, sync_scene_infos
from config.configs import get_config, FbInfoByTypeConfig, FbInfoConfig
from entity.manager import g_entityManager
player = g_entityManager.get_player(int(playerId))
if not player:
return FAILURE
fbID = int(request.GET.getone("fbId") or 0)
if not fbID:
configs = get_config(FbInfoByTypeConfig).get(FbType.Normal, [])\
+ get_config(FbInfoByTypeConfig).get(FbType.Guide, [])\
+ get_config(FbInfoByTypeConfig).get(FbType.Advanced, [])
for c in configs:
if c.ID not in player.fbscores:
set_fb_score(player, c.ID, 3)
else:
configs = get_config(FbInfoConfig)
if fbID in configs:
set_fb_and_prev_score(player, fbID, 3)
else:
return json.dumps('failure')
player.save()
sync_scene_infos(player, FbType.Normal)
sync_scene_infos(player, FbType.Advanced)
return SUCCESS
def lock_device_and_skip_guide(entityID):
from entity.manager import g_entityManager
from player.model import Player, OfflineAttrType
entityID = int(entityID)
deviceID = request.POST.getone('deviceID', '')
lock_level = int(request.POST.getone('lock_level', '50'))
role = g_entityManager.get_player(entityID)
if not role:
Player.add_offline_attr(entityID,
Player.getAttributeIDByName('skip_guide'),
True, OfflineAttrType.Set)
Player.add_offline_attr(entityID,
Player.getAttributeIDByName('lock_level'),
lock_level, OfflineAttrType.Set)
else:
role.skip_guide = True
role.lock_level = lock_level
role.save()
role.sync()
# lock device
if not role:
userID = Player.simple_load(entityID, ['userID']).userID
else:
userID = role.userID
from user.model import User
u = User.simple_load(userID, ['lock_device', 'imsi'])
u.lock_device = deviceID or u.imsi
u.save()
return SUCCESS
def get_lineup_info(playerID, attrs, type=None):
from player.model import Player
from pet.model import Pet
from entity.manager import g_entityManager
if not type:
type = LineupType.ATK
p = g_entityManager.get_player(playerID)
if p:
pets = [p.pets.get(i, None) for i in p.lineups.get(type, [])]
else:
# p = Player.batch_load([playerID], ['lineups'])[0] # FIXME
p = Player.simple_load(playerID, ["entityID", "lineups"])
p.lineups.load()
if p:
try:
pets = Pet.batch_load(p.lineups.get(type, []),
Pet.expend_fields(attrs))
except IndexError:
pets = []
result = []
for pos, pet in enumerate(pets):
if not pet:
continue
info = {n: getattr(pet, n) for n in attrs}
if type == LineupType.Daily:
if info.get("daily_restHP", 0):
info["restHP"] = info["daily_restHP"]
info['posIndex'] = pos
info['isTeamLeader'] = (pos == 0)
result.append(info)
return result
def process(self, msg, kwargs):
value = msg.items()[0][1]
entityID = value.get('entityID')
if entityID:
from entity.manager import g_entityManager
player = g_entityManager.get_player(entityID)
if player:
value.update(
playername=player.name,
username=player.username,
channel=player.channel,
userID=player.userID,
level=player.level,
vip=player.vip,
totalfp=player.totalfp,
fbprocess=player.fbprocess,
appid=player.appid,
UDID=player.UDID,
idfa=player.idfa,
IMEI=player.IMEI,
MAC=player.MAC,
)
value['worldID'] = REGION['ID'] # WORLD['ID']
value['sessionID'] = SESSION['ID']
value['_id'] = str(objectid.ObjectId())
return json.dumps(msg), kwargs
def user_out(self, msgtype, body):
req = rainbow_pb.KickOutRequest()
req.ParseFromString(body)
room_obj = g_gameManager.get_room(self.player.room_id)
if room_obj.master_entity_id != self.player.entityID:
return fail_msg(msgtype,
msgTips.FAIL_MSG_ROOM_KICK_OUT_PERMISSION_DENY)
rsp = rainbow_pb.KickOutResponse()
rsp.kick_out_id = req.kick_out_id
msg = success_msg(msgtype, rsp)
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.save()
p.sync()
# 发送踢人的消息
if role['entityID'] != self.player.entityID:
g_playerManager.sendto(role['entityID'], msg)
# 把这个位置空出来
if role['entityID'] == req.kick_out_id:
role['entityID'] = 0
role['username'] = ''
return msg
def pay_handler(entityID, username, goodsid, amount=None):
goodsid = str(goodsid) # 必须是字符串
label = username2label(username)
sdktype = username2type(username)
sdkconfigs = get_config(RechargeBySdktypeConfig).get(sdktype, [])
labconfigs = get_config(RechargeByLabelConfig).get(label, [])
configs = get_config(RechargeConfig)
ids = {e.id for e in sdkconfigs} & {e.id for e in labconfigs}
good = {configs[e].goodsid: configs[e] for e in ids}.get(goodsid)
if not good:
logger.error("error goodsid %r", goodsid)
return
p = g_entityManager.get_player(entityID)
if p:
level = p.level
reward = give_goods(p, good, amount=amount)
get_gold = reward.get("gold", 0)
else:
# patch 离线玩家，需要计算可获得金额
p = Player.simple_load(
entityID,
["userID", "level", "bought_recharges", "offline_recharges"])
level = p.level
if p.offline_recharges:
p.offline_recharges.append([good.id, amount])
else:
p.offline_recharges = [[good.id, amount]]
is_first = (good.id not in (p.bought_recharges or set())) \
and (good.id not in ({i for i, j in p.offline_recharges} or set()))
from reward.manager import open_reward, RewardType
reward = open_reward(RewardType.Recharge, good, is_first, amount)
rs = reward.apply_after() # 仅计算可获金额，并不发货
get_gold = rs.get("gold", 0)
p.save()
return {"username": username, "level": level, "get_gold": get_gold}
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 sync_apply(entityID):
player = g_entityManager.get_player(entityID)
if player:
faction = Faction.simple_load(player.factionID,
['applyset', 'leaderID'])
player.applyMemberSet = faction.applyset
player.sync()
return SUCCESS
def apply_friend(entityID, applyID):
now = int(time.time())
friend = g_entityManager.get_player(entityID)
if applyID in friend.friend_applys:
return msgTips.FAIL_MSG_FRIEND_ALREADY_APPLYED
friend.friend_applys[applyID] = {"applytime": now}
friend.save()
friend.sync()
return OK
def remove_apply_friend(entityID, applyID):
p = g_entityManager.get_player(entityID)
try:
del p.friend_applys[applyID]
except KeyError:
pass
p.save()
p.sync()
return True
def city_send_mail(entityID, title, content, rewards, key, ID):
if not int(Player.pool.execute(
"HSET", "city_rewards_recv_p{%d}" % entityID, key, "") or 0):
return
p = g_entityManager.get_player(entityID)
if not p:
p = Player.simple_load(entityID, ['factionID'])
rank = CityDungeonKillRanking.get_rank(p.factionID)
content = content.format(rank)
send_mail(entityID, title, content, addition=rewards, configID=ID)
def sync_daily_rank(entityID, history=None):
p = g_entityManager.get_player(entityID)
if p:
if history:
p.daily_histories.appendleft(history)
p.daily_histories.ltrim(0, MAX_HIST_LEN - 1)
p.daily_history_flag = True
p.clear_daily_win_count()
p.save()
p.sync()
def sync_faction(entityID, factionID, level, name):
from entity.manager import g_entityManager
p = g_entityManager.get_player(entityID)
if p.factionID == factionID:
p.faction_level = level
p.faction_name = name
from task.manager import on_faction_level
on_faction_level(p, level)
p.save()
p.sync()
return True
def get_equip_base_power(entityID, prototypeID, masterID, baseHP, baseATK,
baseDEF, baseCRI, baseEVA):
base = baseHP / 5 + baseATK + baseDEF * 2 + baseCRI * 15 + baseEVA * 25
from entity.manager import g_entityManager
p = g_entityManager.get_player(masterID)
if p:
pet_id = p.equipeds.get(entityID, 0)
if pet_id in p.lineups.get(LineupType.ATK, []):
p.clear_equip_power()
p.clear_power()
return base
def allow_friend(applyID, entityID):
applicant = g_entityManager.get_player(applyID)
if len(applicant.friendset) >= applicant.friend_max_count:
return False
if len(applicant.friendset) + 1 >= applicant.friend_max_count:
unrecommend(entityID)
unrecommendp(applicant)
add_friend(applyID, entityID)
from task.manager import on_friends_count
on_friends_count(applicant)
return True
def update_gve_entity_index(entityID):
p = g_entityManager.get_player(entityID)
if p:
g = Group.simple_load(p.groupID, ["gve_joineds"])
if g:
g.gve_joineds.load()
try:
p.gve_index = g.gve_joineds.index(entityID)
p.save()
except ValueError:
pass
def remove_friend(entityID, friendID):
p = g_entityManager.get_player(entityID)
try:
p.friendset.remove(friendID)
recommend(entityID)
recommendp(p)
except KeyError:
pass
p.save()
p.sync()
return True
def sync_products(entityID, history):
from entity.manager import g_entityManager
p = g_entityManager.get_player(entityID)
cc, _, _ = cost_player_products(p, history["booty"], history['type'])
if cc:
now = int(time.time())
p.mine_protect_time = now + 3600 * history['protect_time']
p.mine_rob_history.appendleft(history)
p.mine_rob_history_flag = True
p.save()
p.sync()
return 'SUCCESS'
def ranking_send_mail(entityID, title, content, rewards, key, ID):
if not int(
Player.pool.execute("HSET", "ranking_receiveds_p{%d}" % entityID,
key, "") or 0):
return
p = g_entityManager.get_player(entityID)
if p:
if key in p.rankingreceiveds:
return
p.ranking_receiveds.load()
send_mail(p.entityID, title, content, addition=rewards, configID=ID)
p.save()
p.sync()
def sync_loot_cost(entityID, history):
from entity.manager import g_entityManager
p = g_entityManager.get_player(entityID)
if not history["result"]: # lose
costed = cost_mats(entityID, history["loot"], history["count"])
if not costed:
return
now = int(time.time())
p.loot_protect_time = now + 3600
p.loot_history.appendleft(history)
p.loot_history.ltrim(0, 10)
p.save()
p.sync()
def add_climb_tower_history(entityID, history, fight=None):
history['ID'] = '%d:%d' % (history['time'], history['oppID'])
p = g_entityManager.get_player(entityID)
if p:
p.climb_tower_history.appendleft(history)
p.climb_tower_history.ltrim(0, HISTORY_LIMIT)
if fight: # clean fight history
p.climb_tower_fight_history[history['ID']] = fight
if len(p.climb_tower_fight_history) > HISTORY_LIMIT:
for key in sorted(p.climb_tower_fight_history)[:-HISTORY_LIMIT]:
del p.climb_tower_fight_history[key]
p.save()
p.sync()
def kick_group_member(entityID, groupID):
rs = quit_group(entityID, groupID)
dt = datetime.now()
g = Group.simple_load(groupID, ["name"])
title, content, ID = get_mail("GroupKick")
send_mail(entityID,
title,
content.format(dt.strftime(DATETIMEFMT), g.name),
configID=ID)
p = g_entityManager.get_player(entityID)
if p:
p.sync()
return rs
