#!/usr/bin/python
|
# -*- coding: GBK -*-
|
#
|
##@package E:/GameSVN/U3DGame/ProjectSServer/ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/GameWorldLogic/FBProcess/FBCommon.py
|
# @todo:
|
#
|
# @author: Alee
|
# @date 2017-10-24 ÏÂÎç09:18:54
|
# @version 1.0
|
#
|
# @note:
|
#
|
#---------------------------------------------------------------------
|
#------------------------------------------------------------------------------
|
import GameWorld
|
import IPY_GameWorld
|
import PlayerControl
|
import ItemCommon
|
import NPCCommon
|
import ReadChConfig
|
import ChPyNetSendPack
|
import NetPackCommon
|
import IpyGameDataPY
|
import ShareDefine
|
import PyGameData
|
import GameObj
|
import FBLogic
|
import ChConfig
|
import PlayerGoldInvest
|
import ObjPool
|
|
import random
|
import json
|
import math
|
#---------------------------------------------------------------------
|
#È«¾Ö±äÁ¿
|
Def_VSFB_CanEnter = 'VSFB_CanEnter' #¿ÉÒÔ½øÈë
|
Def_VSFB_IsClose = 'VSFB_IsClose' #¸±±¾¹Ø±Õ
|
Def_VSFB_NotFamilyID = 'VSFB_NotFamilyID' #½ñÈÕ¶ÔÕ½Î޴˼Ò×åID
|
Def_VSFB_NotFight = 'VSFB_NotFight' #½ñÈÕÎÞ¶ÔÕ½ÐÅÏ¢
|
|
#¸±±¾°ïÖúÐÅϢͨÓÃkey
|
Help_lineID = 'lineID' #¹¦ÄÜÏß·ID
|
Help_step = 'step' #µ±Ç°¸±±¾²½Ö裬´Ó1¿ªÊ¼£¬1~n
|
Help_wheel = 'wheel' #µ±Ç°²¨Êý(¹Ø¿¨±àºÅ)£¬´Ó1¿ªÊ¼£¬1~n
|
Help_wheelTotal = 'wheelTotal' #×ܲ¨Êý(¹Ø¿¨±àºÅ)£¬´Ó1¿ªÊ¼£¬1~n
|
Help_npc = 'npc' #NPCÒÑ»÷ɱ¸öÊý [{"NPCID":150,"killCnt":100}]
|
Help_npcTotal = 'npcTotal' #NPC×ÜÒÑ»÷ɱ¸öÊý
|
Help_npcTotalNeed = 'npcTotalNeed' #NPC×ÜÐè»÷ɱ¸öÊý
|
Help_exp = 'exp' #ÒÑ»ñµÃ¾Ñé
|
Help_expPoint = 'expPoint' #ÒÑ»ñµÃ¾Ñéµã
|
Help_money = 'money' #ÒÑ»ñµÃÇ® [{"moneyType":3,"moneyValue":1000}]
|
Help_score = 'score' #ÒÑ»ñµÃ»ý·Ö
|
Help_grade = 'grade' #ÆÀ¼¶(5-S,4-A,3-B,2-C,1-D)
|
Help_leaderID = 'leaderID' #¶É½ÙÍæ¼ÒID
|
Help_isHelp = 'isHelp' #±¾´ÎÊÇ·ñÊÇÖúÕ½
|
Help_helpCount = 'helpCount' #¸Ã¸±±¾½ñÈÕÒÑÖúÕ½´ÎÊý
|
Help_relation = 'relation' #¸Ã¸±±¾¹Øϵ¼Ó³ÉÐÅÏ¢ [ÓÅÏȹØϵ, ×ܼӳÉ]
|
Help_robotJob = 'robotJob' #»úÆ÷ÈËÖ°Òµ {"ObjID":job, ...}
|
Help_isAuto = 'isAuto' #ÊÇ·ñ×Ô¶¯ÕÙ»½
|
Help_hasRefreshBoss = 'hasRefreshBoss' #ÊÇ·ñÒÑË¢ÐÂboss
|
Help_gsItemInfo = 'gsItemInfo' #¾Û»ê¸±±¾ÎïÆ·ÐÅÏ¢ {"²¨Êý":[[{"ItemID":101, "ItemCount":10}]]}
|
|
#¸±±¾½áËãÐÅϢͨÓÃkey
|
Over_dataMapID = 'dataMapID' #Êý¾ÝµØͼID
|
Over_lineID = 'lineID' #¹¦ÄÜÏß·ID
|
Over_isPass = 'isPass' #ÊÇ·ñ¹ý¹Ø0»ò1
|
Over_isSweep = 'isSweep' #ÊÇ·ñɨµ´
|
Over_exp = 'exp' #»ñµÃ¾Ñé
|
Over_expPoint = 'expPoint' #»ñµÃ¾Ñéµã
|
Over_extraExp = 'extraExp' #»ñµÃ¶îÍâ¾Ñé
|
Over_extraExpPoint = 'extraExpPoint' #»ñµÃ¶îÍâ¾Ñéµã
|
Over_money = 'money' #»ñµÃÇ® [{"moneyType":3,"moneyValue":1000}]
|
Over_sp = 'sp' #»ñµÃspÖµ
|
Over_costTime = 'costTime' #ºÄʱ£¬ºÁÃë
|
Over_rank = 'rank' #ºÄʱ£¬ºÁÃë
|
Over_npcTotal = 'npcTotal' #NPC×ÜÒÑ»÷ɱ¸öÊý
|
Over_wheel = 'wheel' #µ±Ç°²¨Êý(¹Ø¿¨±àºÅ)£¬´Ó1¿ªÊ¼£¬1~n
|
Over_grade = 'grade' #ÆÀ¼¶(5-S,4-A,3-B,2-C,1-D)
|
Over_itemInfo = 'itemInfo' #ÎïÆ·Áбí [{"ItemID":101, "ItemCount":10, "IsBind":1, "IsSuite":1, "UserData":"×Ô¶¨ÒåÊôÐÔ×Ö·û´®"}]
|
Over_succItemInfo = 'succItemInfo' #ÎïÆ·Áбí
|
Over_firstPassItem = 'firstPassItem' #ÎïÆ·Áбí
|
Over_score = 'score' #ÒÑ»ñµÃ»ý·Ö
|
Over_extrScore = 'extrScore' #ÒÑ»ñµÃ¶îÍâ»ý·Ö
|
Over_enterLV = 'enterLV' #½øÈëʱµÈ¼¶
|
Over_leaderID = 'leaderID' #¶É½ÙÍæ¼ÒID
|
Over_helpPlayer = 'helpPlayer' #ÖúÕ½Íæ¼ÒÐÅÏ¢ {"Íæ¼ÒID":{Íæ¼ÒÐÅÏ¢key:value, ...}, ...}
|
Over_ownerID = 'ownerID' #¹éÊôÍæ¼ÒID
|
Over_ownerName = 'ownerName' #¹éÊôÍæ¼ÒÃû
|
Over_isAssist = 'isAssist' #ÊÇ·ñÐÖú
|
|
#¸±±¾ÐÐΪ
|
(
|
Def_FbActionEncourage, # ¹ÄÎè
|
Def_FbActionChangeLine, # ±ä¸üÌôÕ½µÄ¹¦ÄÜÏß
|
) = range(2)
|
|
#---------------------------------------------------------------------
|
## GameFB pyÊý¾Ý»º´æ, ÿÌõÐéÄâ·ÖÏßÊý¾Ý¶ÀÁ¢¹ÜÀí£¬¸±±¾ÓÐÐèÒªÓÃʱ±ØÐëÏÈ SetGameFBData
|
def SetGameFBData(attrKey, data): setattr(PyGameData, "GFBD_%s_%s" % (attrKey, GameWorld.GetGameWorld().GetLineID()), data)
|
def GetGameFBData(attrKey): return getattr(PyGameData, "GFBD_%s_%s" % (attrKey, GameWorld.GetGameWorld().GetLineID()))
|
#---------------------------------------------------------------------
|
def GetFBIpyData(mapID):
|
mapID = GetRecordMapID(mapID)
|
return IpyGameDataPY.GetIpyGameDataNotLog("FBFunc", mapID)
|
def GetFBLineIpyData(mapID, lineID, isDefaultLine=True):
|
mapID = GetRecordMapID(mapID)
|
fbLineIpyData = IpyGameDataPY.GetIpyGameDataNotLog("FBLine", mapID, lineID)
|
if not fbLineIpyData and isDefaultLine:
|
#GameWorld.DebugLog("ûÓÐÖ¸¶¨¹¦ÄÜÏß·µÄÔòĬÈÏÈ¡0£¬ÔÙûÓеĻ°¾ÍÊDz»ÐèÒªµÄmapID=%s, lineID=%s" % (mapID, lineID))
|
fbLineIpyData = IpyGameDataPY.GetIpyGameDataNotLog("FBLine", mapID, 0)
|
return fbLineIpyData
|
|
def GetFBLineEnterPosInfo(mapID, lineID, fbLineIpyData=None):
|
# ×ø±êÐÅÏ¢
|
return [10,10]
|
def GetPassAwardList(mapID, lineID):
|
# ¹ý¹Ø½±Àø
|
fbLineIpyData = GetFBLineIpyData(mapID, lineID)
|
return [] if not fbLineIpyData else fbLineIpyData.GetPassAwardList()
|
def GetSweepAwardList(mapID, lineID, sweepCnt):
|
# ɨµ´½±Àø
|
fbLineIpyData = GetFBLineIpyData(mapID, lineID)
|
if not fbLineIpyData:
|
return []
|
awardItemList = fbLineIpyData.GetSweepAwardList()
|
if not awardItemList:
|
awardItemList = fbLineIpyData.GetPassAwardList()
|
|
sweepItemList = []
|
for itemInfo in awardItemList:
|
itemID, itemCount = itemInfo[:2]
|
sweepItemList.append([itemID, itemCount * sweepCnt])
|
return sweepItemList
|
|
def GetFBFuncOpenState(dataMapID):
|
## »ñÈ¡¸±±¾¿ªÆô״̬ @return: 0-¹Ø±Õ£»1-¿ªÆô
|
# ÓÐÅäÖÿª·Åʱ¼äÏÞÖƵģ¬ÓÉGameServer¾ö¶¨
|
if dataMapID in PyGameData.FBEnterTimeLimiitMapID:
|
return GameWorld.GetGameWorld().GetGameWorldDictByKey(ShareDefine.Def_Notify_WorldKey_FBCanEnter % dataMapID)
|
|
return 1
|
|
def GetFBHasOpenToday(dataMapID, dayStr):
|
#»ñÈ¡¸±±¾µ±ÌìÊÇ·ñÓпªÆô¹ý '0314'´ú±í3ÔÂ14ºÅ
|
if dataMapID not in PyGameData.FBOpenTimeRecord:
|
return
|
return dayStr in PyGameData.FBOpenTimeRecord[dataMapID]
|
|
def IsFBPass(curPlayer, mapID, lineID):
|
## ¸±±¾Ïß·ÊÇ·ñÒѹý¹Ø
|
if mapID == ChConfig.Def_FBMapID_Main:
|
return PlayerControl.IsMainLevelPass(curPlayer, lineID)
|
|
if mapID in ChConfig.PassByStarMapIDList:
|
grade = GameWorld.GetDictValueByBit(curPlayer, ChConfig.Def_Player_Dict_FBStar, lineID, False, [mapID])
|
if grade:
|
return True
|
else:
|
passLineID = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FBPassLineID % mapID)
|
if passLineID >= lineID:
|
return True
|
|
return False
|
|
def SetFBPass(curPlayer, mapID, funcLineID, isNotify=True):
|
passLineID = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FBPassLineID % mapID)
|
if funcLineID > passLineID:
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FBPassLineID % mapID, funcLineID)
|
if isNotify:
|
Sync_FBPlayerFBInfoData(curPlayer, mapID)
|
return
|
|
def CheckCanEnterFBComm(curPlayer, mapID, lineID, fbIpyData, fbLineIpyData, reqEnterCnt=1, isNotify=True, isTeamAsk=False):
|
# ¿É·ñ½øÈ븱±¾Í¨Óüì²é, ɨµ´Í¨ÓÃ
|
playerID = curPlayer.GetPlayerID()
|
|
# ×ܱíͨÓüì²é
|
if fbIpyData:
|
#¿ª·þÌ쿪·Å¼ì²é
|
#if not GetFBFuncOpenState(mapID):
|
# GameWorld.Log("µ±Ç°Ê±¼ä먦·Å¸Ã¸±±¾!mapID=%s" % (mapID), playerID)
|
# if isNotify:
|
# PlayerControl.NotifyCode(curPlayer, "FBIsNotOpen")
|
# return ShareDefine.EntFBAskRet_FBClose
|
|
#½øÈë´ÎÊýÅжÏ
|
canEnter, notifyMark = __CheckCanEnterFBByTime(curPlayer, mapID, lineID, fbIpyData, reqEnterCnt, isTeamAsk)
|
if not canEnter:
|
if notifyMark:
|
PlayerControl.NotifyCode(curPlayer, notifyMark, [mapID])
|
return ShareDefine.EntFBAskRet_NoEnterCnt
|
|
# ¹¦ÄÜÏß·ͨÓüì²é
|
if fbLineIpyData:
|
#µÈ¼¶ÅжÏ
|
curLV = curPlayer.GetLV()
|
lvLimitMin = fbLineIpyData.GetLVLimitMin()
|
if lvLimitMin and curLV < lvLimitMin:
|
GameWorld.Log("Íæ¼ÒµÈ¼¶²»×ã, ÎÞ·¨½øÈ븱±¾!mapID=%s,lineID=%s,curLV(%s) < lvLimitMin(%s)"
|
% (mapID, lineID, curLV, lvLimitMin), playerID)
|
if isNotify:
|
PlayerControl.NotifyCode(curPlayer, "FbLV", [mapID])
|
return ShareDefine.EntFBAskRet_LVLimit
|
|
#ÃÅƱÅжÏ
|
#if not GetFBEnterTicket(curPlayer, mapID, lineID, fbLineIpyData, reqEnterCnt, isTeamAsk)[0]:
|
# if isNotify:
|
# PlayerControl.NotifyCode(curPlayer, "GeRen_chenxin_157069", [mapID])
|
# return ShareDefine.EntFBAskRet_NoTicket
|
|
return ShareDefine.EntFBAskRet_OK
|
|
def __CheckCanEnterFBByTime(curPlayer, mapID, lineID, fbIpyData, reqEnterCnt, isTeamAsk):
|
#½øÈë´ÎÊýÅжÏ
|
maxTimes = fbIpyData.GetDayTimes()
|
if not maxTimes:
|
return True, ""
|
|
#playerID = curPlayer.GetPlayerID()
|
enterCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FbEnterCnt % mapID)
|
maxCnt = GetEnterFBMaxCnt(curPlayer, mapID)
|
if enterCnt + reqEnterCnt <= maxCnt:
|
return True, ""
|
|
if mapID in ChConfig.UnPassFreeMapIDList and not IsFBPass(curPlayer, mapID, lineID):
|
return True, ""
|
|
# ### ÒÔÏÂÊǵ½´ï´ÎÊýÉÏÏÞºóµÄ´¦Àí
|
# fbType = GameWorld.GetMap().GetMapFBTypeByMapID(mapID)
|
#
|
# # µ¥È˸±±¾´ïµ½´ÎÊýºó²»¿ÉÔÙ½øÈë
|
# if fbType == IPY_GameWorld.fbtSingle:
|
# #GameWorld.Log("ÒÑ´ïµ½µ±ÈÕ×î´ó½øÈë´ÎÊý!µ¥È˸±±¾ mapID=%s,enterCnt=%s,reqEnterCnt=%s,maxTimes=%s,maxCnt=%s"
|
# # % (mapID, enterCnt, reqEnterCnt, maxTimes, maxCnt), playerID)
|
# return False, "GeRen_chenxin_268121"
|
#
|
# # ×é¶Ó¸±±¾
|
# if fbType == IPY_GameWorld.fbtTeam:
|
# # ¿ÉÖúÕ½µÄ²»¿Éµ¥È˽øÈëÖúÕ½£¬¿É·¢ÆðÆ¥Åä
|
# if not isTeamAsk and (not curPlayer.GetTeamID() or curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_TeamMemCount) <= 1):
|
# #GameWorld.Log("ÒÑ´ïµ½µ±ÈÕ×î´ó½øÈë´ÎÊý!×é¶Ó¸±±¾²»¿Éµ¥ÈËÖúÕ½£¡ mapID=%s,enterCnt=%s,reqEnterCnt=%s,maxTimes=%s,maxCnt=%s"
|
# # % (mapID, enterCnt, reqEnterCnt, maxTimes, maxCnt), playerID)
|
# return False, "TeamSingleEnter"
|
#
|
# if mapID not in ChConfig.Def_NoLimitEnterCntMap:
|
# #GameWorld.Log("ÒÑ´ïµ½µ±ÈÕ×î´ó½øÈë´ÎÊý! mapID=%s,enterCnt=%s,reqEnterCnt=%s,maxTimes=%s,maxCnt=%s"
|
# # % (mapID, enterCnt, reqEnterCnt, maxTimes, maxCnt), playerID)
|
# return False, "GeRen_chenxin_268121"
|
|
GameWorld.DebugLog("¿É½øÈë´ÎÊý²»×ã: mapID=%s, lineID=%s, enterCnt(%s) + reqEnterCnt(%s) <= maxCnt=%s"
|
% (mapID, lineID, enterCnt, reqEnterCnt, maxCnt))
|
return False, "GeRen_chenxin_268121"
|
|
## »ñÈ¡¸±±¾½øÈëÃÅƱÐÅÏ¢
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param mapID µØͼid
|
# @param lineID Ïß·id
|
# @return [ÊÇ·ñ¿É½ø, [[ÃÅƱË÷ÒýÁбí, delCnt], ...], ɾ³ý¸öÊý, ÊÇ·ñÓаó¶¨, ¿ÛÇ®ÐÅÏ¢]
|
def GetFBEnterTicket(curPlayer, mapID, lineID=0, fbLineIpyData=None, reqEnterCnt=1, isTeamAsk=False):
|
#ÃÅƱÅжÏ
|
return True, [], 0, False, []
|
# if not fbLineIpyData:
|
# fbLineIpyData = GetFBLineIpyData(mapID, lineID)
|
#
|
# ticketID = fbLineIpyData.GetTicketID()
|
# if not ticketID:
|
# return True, [], 0, False, []
|
#
|
# ticketCostCntList = fbLineIpyData.GetTicketCostCnt()
|
# if not ticketCostCntList:
|
# GameWorld.ErrLog("ûÓÐÅäÖÃÃÅƱÏûºÄ!mapID=%s,lineID=%s" % (mapID, lineID), curPlayer.GetPlayerID())
|
# return False, [], 0, False, []
|
#
|
# enterCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FbEnterCnt % mapID)
|
# costCnt = ticketCostCntList[-1] if enterCnt >= len(ticketCostCntList) else ticketCostCntList[enterCnt]
|
# totalCostCnt = costCnt*reqEnterCnt
|
# if not totalCostCnt:
|
# GameWorld.ErrLog("ûÓÐÅäÖÃÃÅƱÏûºÄ!mapID=%s,lineID=%s" % (mapID, lineID), curPlayer.GetPlayerID())
|
# return False, [], 0, False, []
|
#
|
# itemPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptItem)
|
# enough, indexList, hasBind, lackCnt = ItemCommon.GetItem_FromPack_ByID_ExEx(ticketID, itemPack, totalCostCnt)
|
# if not enough:
|
# ticketPrice = fbLineIpyData.GetTicketPrice()
|
# if ticketPrice and not isTeamAsk: #×é¶Ó½ø×é¶Ó¸±±¾Ê±±ØÐëÒªÓÐÃÅƱµÀ¾ß
|
# costMoney = ticketPrice * lackCnt
|
# costMoneyList = PlayerControl.HaveMoneyEx(curPlayer, ShareDefine.TYPE_Price_Gold_Paper_Money, costMoney)
|
# return bool(costMoneyList), indexList, totalCostCnt, hasBind, costMoneyList
|
# GameWorld.DebugLog("ÃÅƱ²»×ã, ÎÞ·¨½øÈ븱±¾!mapID=%s,lineID=%s,ticketID=%s,reqEnterCnt=%s,totalCostCnt=%s"
|
# % (mapID, lineID, ticketID, reqEnterCnt, totalCostCnt), curPlayer.GetPlayerID())
|
# return False, [], 0, False, []
|
#
|
# return enough, indexList, totalCostCnt, hasBind, []
|
|
## »ñÈ¡¸±±¾½øÈëÃÅƱÐÅÏ¢
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param mapID µØͼid
|
# @param lineID Ïß·id
|
# @return ÊÇ·ñ³É¹¦¿Û³ý, ÊÇ·ñʹÓÃÁË°ó¶¨ÃÅƱ
|
def DelFBEnterTicket(curPlayer, mapID, lineID=0, enterCnt=1):
|
isEnough, indexList, delCnt, hasBind, costMoneyList = GetFBEnterTicket(curPlayer, mapID, lineID, None, enterCnt)
|
if not isEnough:
|
return False, hasBind
|
if costMoneyList:
|
infoDict = {"MapID":mapID, "LineID":lineID, 'EnterCount':enterCnt}
|
for moneyType, moneyNum in costMoneyList:
|
if not PlayerControl.PayMoney(curPlayer, moneyType, moneyNum, ChConfig.Def_Cost_EnterFB, infoDict):
|
return False, hasBind
|
if not indexList:
|
return True, hasBind
|
itemPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptItem)
|
ItemCommon.ReduceItem(curPlayer, itemPack, indexList, delCnt, False, "FBTicket")
|
return True, hasBind
|
|
|
## »ñÈ¡¸±±¾Íæ¼ÒÊý¾Ý¿â×ÖµäÐÅÏ¢Öµ
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param key ×Öµäkey
|
# @param defaultValue ĬÈÏÖµ
|
# @return
|
def GetFBPDictValue(curPlayer, key, defaultValue=0):
|
return curPlayer.NomalDictGetProperty(key, defaultValue, ChConfig.Def_PDictType_FB)
|
|
## ÉèÖø±±¾Íæ¼ÒÊý¾Ý¿â×ÖµäÐÅÏ¢Öµ
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param key ×Öµäkey
|
# @param value ÉèÖõÄÖµ
|
# @return
|
def SetFBPDictValue(curPlayer, key, value):
|
PlayerControl.NomalDictSetProperty(curPlayer, key, value, ChConfig.Def_PDictType_FB)
|
return
|
|
def UpdFBLineNPCStrengthenLV(playerID, isLeave):
|
'''¶¯Ì¬¸üи±±¾NPC³É³¤µÈ¼¶
|
'''
|
attrStrengthenInfo = ReadChConfig.GetEvalChConfig("NPCAttrStrengthen")
|
if not attrStrengthenInfo:
|
return
|
|
mapID = GetRecordMapID(GameWorld.GetMap().GetMapID())
|
if mapID not in attrStrengthenInfo[NPCCommon.NPCAttr_DynNPCLVMap]:
|
#GameWorld.DebugLog("·Ç¶¯Ì¬¸üи±±¾NPC³É³¤µÈ¼¶µÄµØͼ!")
|
return
|
|
maxLV = 0
|
totalLV = 0
|
playerCnt = 0
|
copyMapPlayerManager = GameWorld.GetMapCopyPlayerManager()
|
for i in xrange(copyMapPlayerManager.GetPlayerCount()):
|
curPlayer = copyMapPlayerManager.GetPlayerByIndex(i)
|
if curPlayer == None or curPlayer.IsEmpty():
|
continue
|
if isLeave and curPlayer.GetPlayerID() == playerID:
|
continue
|
curLV = curPlayer.GetLV()
|
totalLV += curLV
|
playerCnt += 1
|
if maxLV < curLV:
|
maxLV = curLV
|
if not playerCnt:
|
return
|
averageLV = totalLV / playerCnt
|
gameFB = GameWorld.GetGameFB()
|
gameFB.SetGameFBDict(ChConfig.Def_FB_NPCStrengthenAverageLV, averageLV)
|
gameFB.SetGameFBDict(ChConfig.Def_FB_NPCStrengthenMaxLV, maxLV)
|
GameWorld.Log("NPC³É³¤¶¯Ì¬µÈ¼¶±ä¸ü: isLeave=%s,totalLV=%s,playerCnt=%s,averageLV=%s,maxLV=%s"
|
% (isLeave, totalLV, playerCnt, averageLV, maxLV), playerID)
|
return True
|
|
def UpdFBLineNPCStrengthenPlayerCnt(playerID, isLeave):
|
'''¶¯Ì¬¸üи±±¾NPC³É³¤ÈËÊý
|
'''
|
attrStrengthenInfo = ReadChConfig.GetEvalChConfig("NPCAttrStrengthen")
|
if not attrStrengthenInfo:
|
return
|
|
mapID = GetRecordMapID(GameWorld.GetMap().GetMapID())
|
coefficientDict = attrStrengthenInfo[NPCCommon.NPCAttr_DynPCCoefficientMap]
|
if mapID not in coefficientDict:
|
#GameWorld.DebugLog("·Ç¶¯Ì¬¸üи±±¾NPC³É³¤ÈËÊýµÄµØͼ!")
|
return
|
isRefreshNPCAttrNow = coefficientDict[mapID] # ÊÇ·ñÂíÉÏË¢ÐÂÊôÐÔ
|
gameFB = GameWorld.GetGameFB()
|
playerCount = GameWorld.GetMapCopyPlayerManager().GetPlayerCount()
|
if isLeave:
|
playerCount = max(1, playerCount - 1)
|
gameFB.SetGameFBDict(ChConfig.Def_FB_NPCStrengthenPlayerCnt, playerCount)
|
GameWorld.Log("NPC³É³¤¶¯Ì¬ÈËÊý±ä¸ü: playerCount=%s,isLeave=%s,isRefreshNPCAttrNow=%s"
|
% (playerCount, isLeave, isRefreshNPCAttrNow), playerID)
|
|
if isRefreshNPCAttrNow:
|
#GameWorld.DebugLog(" Á¢ÂíË¢ÐÂNPCÊôÐÔ!")
|
gameNPCManager = GameWorld.GetNPCManager()
|
for index in xrange(gameNPCManager.GetNPCCount()):
|
curNPC = gameNPCManager.GetNPCByIndex(index)
|
if curNPC.GetID() == 0:
|
continue
|
if curNPC.GetType() in [IPY_GameWorld.ntFunctionNPC, IPY_GameWorld.ntPet]:
|
continue
|
NPCCommon.DoNPCAttrStrengthen(curNPC, False, True)
|
|
return True
|
|
def SetNPCDropDoCountRate(gameFB, doCountRate, doCountAdd):
|
## ÉèÖùÖÎïµôÂäÖ´ÐдÎÊýÍò·ÖÂÊ
|
''' ÉèÖùÖÎïµôÂäÖ´ÐдÎÊýÍò·ÖÂÊ ¼° ¹Ì¶¨¼Ó³É´ÎÊýÖµ
|
@param doCountRate: ´ÎÊýÍò·ÖÂÊ
|
@param doCountAdd: ´ÎÊý¹Ì¶¨Öµ
|
'''
|
gameFB.SetGameFBDict(ChConfig.Def_FB_DropDoCountRate, doCountRate)
|
gameFB.SetGameFBDict(ChConfig.Def_FB_DropDoCountAdd, doCountAdd)
|
GameWorld.Log("ÉèÖùÖÎïµôÂäÖ´ÐдÎÊýÐÅÏ¢: doCountRate=%s, doCountAdd=%s" % (doCountRate, doCountAdd))
|
return
|
|
def GetHadSetFBPropertyMark():
|
#ÊÇ·ñÒѾÉèÖùý¸±±¾Ïß·ÊôÐÔ
|
return GameWorld.GetGameFB().GetGameFBDictByKey(ChConfig.Map_FBDict_PropertyMark) > 0
|
## »ñÈ¡¸±±¾ÊôÐÔmark
|
# @param
|
# @return
|
def GetFBPropertyMark():
|
return GameWorld.GetGameFB().GetGameFBDictByKey(ChConfig.Map_FBDict_PropertyMark) - 1 # ȡֵʱ-1
|
|
## »ñÈ¡¸±±¾ÊôÐÔmark
|
# @param propertyMark
|
# @return
|
def SetFBPropertyMark(propertyMark, setPlayer=None):
|
GameWorld.GetGameFB().SetGameFBDict(ChConfig.Map_FBDict_PropertyMark, propertyMark + 1) # ´æ´¢Ê±+1²ÅÄÜÅжÏÊÇ·ñ´æ´¢¹ý
|
# if setPlayer != None:
|
# PlayerControl.SetFBFuncLineID(setPlayer, propertyMark)
|
# GameWorld.DebugLog("SetFBPropertyMark ÉèÖÃÍæ¼Ò¸±±¾¹¦ÄÜÏß·ID: %s" % propertyMark, setPlayer.GetPlayerID())
|
# return
|
#
|
# playerManager = GameWorld.GetMapCopyPlayerManager()
|
# for index in xrange(playerManager.GetPlayerCount()):
|
# curPlayer = playerManager.GetPlayerByIndex(index)
|
# if not curPlayer.GetPlayerID():
|
# continue
|
# PlayerControl.SetFBFuncLineID(curPlayer, propertyMark)
|
# GameWorld.DebugLog("SetFBPropertyMark ¹ã²¥Íæ¼Ò¸±±¾¹¦ÄÜÏß·ID: %s" % propertyMark, curPlayer.GetPlayerID())
|
return
|
|
## ÊÇ·ñÒѾ¿Û³ýÈ볡ȯ/½øÈë´ÎÊýµÈ
|
# @param
|
# @return
|
def GetHadDelTicket(curPlayer):
|
return GameWorld.GetGameFB().GetPlayerGameFBDictByKey(curPlayer.GetID(), ChConfig.FBPlayerDict_IsDelTicket)
|
|
## ÉèÖÃÒѾ¿Û³ýÈ볡ȯ
|
# @param propertyMark
|
# @return
|
def SetHadDelTicket(curPlayer, delSign=1):
|
GameWorld.GetGameFB().SetPlayerGameFBDict(curPlayer.GetID(), ChConfig.FBPlayerDict_IsDelTicket, delSign)
|
return
|
|
def GetCurSingleFBPlayer():
|
''' »ñÈ¡µ±Ç°µ¥È˸±±¾Íæ¼Ò '''
|
curPlayer = None
|
playerManager = GameWorld.GetMapCopyPlayerManager()
|
if playerManager.GetPlayerCount() > 0:
|
curPlayer = playerManager.GetPlayerByIndex(0)
|
return curPlayer
|
|
def GetFBJoinType(curPlayer, isHelpFight):
|
## »ñÈ¡¸±±¾²ÎÓëÀàÐÍ
|
if isHelpFight:
|
return ChConfig.FB_JoinType_Help
|
if curPlayer.GetTeamID() and GameWorld.GetGameFB().GetGameFBDictByKey(ChConfig.Def_FB_TeamPlayerCount) > 1:
|
return ChConfig.FB_JoinType_Multi
|
return ChConfig.FB_JoinType_Single
|
|
#---------------------------------------------------------------------
|
##¡¡»ñµÃ¸±±¾Ê£Óàʱ¼ä
|
# @param tick µ±Ç°Ê±¼ä
|
# @return Ê£Óàʱ¼ä
|
# @remarks º¯ÊýÏêϸ˵Ã÷.
|
def GetFB_RemainTime(tick):
|
lastTick = tick - GameWorld.GetGameWorld().GetOpenFBTick()
|
existTime = GameWorld.GetMap().GetExistTime()
|
return existTime - lastTick
|
#---------------------------------------------------------------------
|
def UpdateFBGrade(tick, gradeTimeList, curPlayer=None, timeType=IPY_GameWorld.tttFlagTake):
|
'''¸üе±Ç°¸±±¾ÐǼ¶¡¢ÆÀ¼¶
|
@param gradeTimeList: ÆÀ¼¶·Ö¶Îʱ¼äÁÐ±í£¬µ¥Î»Ãë [×î¸ßÆÀ¼¶¿ÉÓÃʱ¼ä, ϼ¶¿ÉÓÃʱ¼ä, ..., ×îµÍ¼¶¿ÉÓÃʱ¼ä]
|
@param curPlayer: ´¥·¢µÄÍæ¼Ò£¬Ò»°ãÊÇDoEnterʱµ÷Ó㬻áͬ²½¸üÐÂÒ»´Î¸±±¾ÆÀ¼¶²¢½«ÐÅϢ֪ͨ¸ÃÍæ¼Ò
|
@note: ÐǼ¶£º1-1ÐÇ£»2-2ÐÇ ... [60, 20, 10]
|
ÆÀ¼¶£º1-D£»2-C£»3-B£»4-A£»5-S; [60, 30, 30, 20, 10]
|
'''
|
lowest = 1
|
gameFB = GameWorld.GetGameFB()
|
curGrade = gameFB.GetGameFBDictByKey(ChConfig.Def_FB_Grade)
|
#×îºóÒ»¸öÆÀ¼¶ÁË£¬²»ÔÙ´¦Àí
|
if curGrade == lowest:
|
if curPlayer:
|
FBLogic.DoFBHelp(curPlayer, tick)
|
return curGrade
|
|
useSecond = int((tick - gameFB.GetFBStepTick()) / 1000.0) # Õ½¶·½×¶ÎÒѺÄ×ÜÃëÊý
|
diffSecond = 0
|
updGrade = len(gradeTimeList)
|
gSecondTotal = 0
|
for gSecond in gradeTimeList:
|
gSecondTotal += gSecond
|
diffSecond = gSecondTotal - useSecond
|
# »¹ÔÚµ±Ç°ÆÀ¼¶¶Î
|
if diffSecond > 0:
|
break
|
updGrade -= 1 # ÓÃʱ³¬¹ýµ±Ç°ÆÀ¼¶¶Î£¬½µ¼¶
|
updGrade = max(lowest, updGrade) # ±£µ××îµÍ¼¶
|
if curGrade == updGrade and not curPlayer:
|
return curGrade
|
gameFB.SetGameFBDict(ChConfig.Def_FB_Grade, updGrade)
|
|
GameWorld.DebugLog("UpdateFBGrade useSecond=%s,gradeTimeList=%s,curGrade=%s,updGrade=%s,diffSecond=%s"
|
% (useSecond, gradeTimeList, curGrade, updGrade, diffSecond))
|
if curPlayer:
|
FBLogic.DoFBHelp(curPlayer, tick)
|
if updGrade != lowest:
|
curPlayer.Sync_TimeTick(timeType, 0, diffSecond * 1000, True)
|
else:
|
playerManager = GameWorld.GetMapCopyPlayerManager()
|
for index in xrange(playerManager.GetPlayerCount()):
|
curPlayer = playerManager.GetPlayerByIndex(index)
|
if not curPlayer:
|
continue
|
FBLogic.DoFBHelp(curPlayer, tick)
|
if updGrade != lowest:
|
curPlayer.Sync_TimeTick(timeType, 0, diffSecond * 1000, True)
|
return updGrade
|
|
def NotifyFBOver(curPlayer, dataMapID, lineID, isPass, overDict={}):
|
## ֪ͨÍæ¼Ò¸±±¾×ܽá, ¸Ãº¯Êýͳһ¼¸¸ö±Ø´ø²ÎÊý
|
overDict.update({Over_dataMapID:dataMapID, Over_lineID:lineID, Over_isPass:int(isPass)})
|
overMsg = json.dumps(overDict, ensure_ascii=False)
|
curPlayer.Frm_FBEnd(overMsg)
|
GameWorld.DebugLog("NotifyFBOver: %s" % overMsg, curPlayer.GetPlayerID())
|
return
|
|
def NotifyFBHelp(curPlayer, lineID, helpDict={}):
|
## ֪ͨÍæ¼Ò¸±±¾°ïÖúÐÅÏ¢, ¸Ãº¯Êýͳһ¼¸¸ö±Ø´ø²ÎÊý
|
helpDict.update({Help_lineID:lineID})
|
helpMsg = json.dumps(helpDict, ensure_ascii=False)
|
curPlayer.Frm_FBHelp(helpMsg)
|
GameWorld.DebugLog("NotifyFBHelp: %s" % helpMsg, curPlayer.GetPlayerID())
|
return
|
|
## ֪ͨÍæ¼Ò¸±±¾×ܽá
|
# @param curPlayer ±»Í¨ÖªµÄÍæ¼Ò
|
# @param msgDict ½áÊøÐÅÏ¢×Öµä
|
# @return None
|
def Notify_FB_Over(curPlayer, msgDict):
|
msgDict = json.dumps(msgDict, ensure_ascii=False)
|
curPlayer.Frm_FBEnd('%s' % msgDict)
|
return
|
|
def Notify_FBHelp(curPlayer, helpDict):
|
## ֪ͨÍæ¼Ò¸±±¾°ïÖúÐÅÏ¢
|
helpDict = json.dumps(helpDict, ensure_ascii=False)
|
curPlayer.Frm_FBHelp('%s' % str(helpDict))
|
return
|
|
def GetJsonItemList(itemList):
|
## [[itemID,itemCount,isAuctionItem], curItem] -> [{"ItemID":101, "Count":10, "IsAuctionItem":1, "UserData":"×Ô¶¨ÒåÊôÐÔ×Ö·û´®"}]
|
jsonItemList = []
|
for itemInfo in itemList:
|
itemDict = {}
|
if isinstance(itemInfo, list) or isinstance(itemInfo, tuple):
|
infolen = len(itemInfo)
|
if infolen > 0:
|
itemDict['ItemID'] = itemInfo[0]
|
if infolen > 1:
|
itemDict['Count'] = itemInfo[1]
|
#if infolen > 2:
|
# itemDict['IsAuctionItem'] = int(itemInfo[2])
|
elif isinstance(itemInfo, int):
|
itemDict['ItemID'] = itemInfo
|
elif isinstance(itemInfo, dict):
|
itemDict = itemInfo
|
else: #ÎïƷʵÀý
|
if not ItemCommon.CheckItemCanUse(itemInfo):
|
continue
|
itemDict['ItemID'] = itemInfo.GetItemTypeID()
|
itemDict['Count'] = itemInfo.GetCount()
|
#itemDict['IsAuctionItem'] = ItemControler.GetIsAuctionItem(itemInfo)
|
#itemDict['IsSuite'] = int(itemInfo.GetIsSuite())
|
itemDict['UserData'] = itemInfo.GetUserData()
|
jsonItemList.append(itemDict)
|
return jsonItemList
|
|
def GetJsonMoneyList(moneyDict):
|
## {moneyType:moneyValue} -> [{"moneyType":3,"moneyValue":1000}]
|
moneyList = []
|
for moneyType, moneyValue in moneyDict.items():
|
moneyList.append({"moneyType":moneyType, "moneyValue":moneyValue})
|
return moneyList
|
|
def GetJsonNPCKillList(npcDict):
|
## {npcid:killcnt} -> [{"NPCID":150,"killCnt":100}]
|
killList = []
|
for npcid, killCnt in npcDict.items():
|
killList.append({"NPCID":npcid, "killCnt":killCnt})
|
return killList
|
|
def GetJsonNPCHPPerList(npcDict):
|
## {npcid:HPPer} -> [{"NPCID":150,"HPPer":100}]
|
killList = []
|
for npcid, HPPer in npcDict.items():
|
killList.append({"NPCID":npcid, "HPPer":HPPer})
|
return killList
|
|
def OnPickUpItem(curPlayer, curItem, tick, overFunc):
|
mapItemType = curItem.GetType()
|
if mapItemType != ChConfig.Def_ItemType_Money:
|
playerID = curPlayer.GetID()
|
isEquip = ItemCommon.CheckItemIsEquip(curItem)
|
jsonItem = ItemCommon.GetJsonItem(curItem)
|
if playerID in PyGameData.g_fbPickUpItemDict:
|
if isEquip:
|
PyGameData.g_fbPickUpItemDict[playerID].append(jsonItem)
|
else:
|
isIn = False
|
for itemInfo in PyGameData.g_fbPickUpItemDict[playerID]:
|
if not isinstance(itemInfo, dict):
|
continue
|
if itemInfo["ItemID"] == jsonItem["ItemID"] and itemInfo.get("IsBind") == jsonItem.get("IsBind"):
|
itemInfo["Count"] = itemInfo.get("Count", 1)+ jsonItem.get("Count", 1)
|
isIn = True
|
break
|
if not isIn:
|
PyGameData.g_fbPickUpItemDict[playerID].append(jsonItem)
|
else:
|
PyGameData.g_fbPickUpItemDict[playerID] = [jsonItem]
|
|
if overFunc == None:
|
return
|
|
playerItemCount = 0
|
mapItemManager = GameWorld.GetMapItemManager()
|
for index in xrange(mapItemManager.GetMapItemCount()):
|
mapItem = mapItemManager.GetMapItemByIndex(index)
|
if not mapItem or mapItem.IsEmpty():
|
continue
|
|
# »¹ÓÐÊôÓÚ×Ô¼ºµÄ¶«Î÷û¼ñ²»Í¨Öª½áÊø
|
if mapItem.GetOwnerID() == curPlayer.GetPlayerID():
|
playerItemCount += 1
|
|
isItemAllPickUp = (playerItemCount <= 1)
|
if isItemAllPickUp:
|
overFunc(curPlayer, tick)
|
|
return
|
#---------------------------------------------------------------------
|
def SyncDynamicBarrierState(barrierPointList, state, curPlayer=None):
|
'''ͬ²½¶¯Ì¬ÕÏ°ÎïÊÇ·ñÓÐЧÐÔ
|
@param barrierPointList: ÕÏ°ÎïµãÁбí [[aPosX,aPosY,bPosX,bPosY,angle¿ÉÑ¡], [aPosX,aPosY,bPosX,bPosY,angle¿ÉÑ¡], ...]
|
@param state: ÊÇ·ñÓÐЧ
|
@param curPlayer: Ö¸¶¨Í¨ÖªÄ¿±êÍæ¼Ò£¬ÎªNoneʱ¹ã²¥±¾µØͼËùÓÐÍæ¼Ò
|
'''
|
barrierStatePack = ChPyNetSendPack.tagMCDynamicBarrierState()
|
barrierStatePack.Clear()
|
barrierStatePack.State = state
|
barrierStatePack.BarrierList = []
|
for posInfo in barrierPointList:
|
aPosX, aPosY, bPosX, bPosY = posInfo[:4]
|
angle = posInfo[4] if len(posInfo) > 4 else 0
|
barrier = ChPyNetSendPack.tagMCDynamicBarrier()
|
barrier.APosX = aPosX
|
barrier.APosY = aPosY
|
barrier.BPosX = bPosX
|
barrier.BPosY = bPosY
|
barrier.Angle = angle
|
barrierStatePack.BarrierList.append(barrier)
|
barrierStatePack.Count = len(barrierStatePack.BarrierList)
|
if curPlayer:
|
NetPackCommon.SendFakePack(curPlayer, barrierStatePack)
|
else:
|
playManager = GameWorld.GetMapCopyPlayerManager()
|
for i in range(playManager.GetPlayerCount()):
|
curPlayer = playManager.GetPlayerByIndex(i)
|
if not curPlayer:
|
continue
|
NetPackCommon.SendFakePack(curPlayer, barrierStatePack)
|
return
|
|
## ÃÅÏÔÒþ
|
# @param doorIDList npcÁбí
|
# @param type 1£ºÃſɼû£» ÆäËû£ºÃŲ»¿É¼û
|
# @return None
|
# @remarks Ö§³Ö¹âǽIDÖظ´
|
def OpenOrCloseDoorEx(doorIDList, type, isReborn=False):
|
gameNPCManager = GameWorld.GetNPCManager()
|
|
for i in xrange(gameNPCManager.GetNPCCount()):
|
curNPC = gameNPCManager.GetNPCByIndex(i)
|
if curNPC == None:
|
continue
|
npcID = curNPC.GetNPCID()
|
if npcID not in doorIDList:
|
continue
|
|
curType = curNPC.GetVisible()
|
|
#---Ãſɼû---
|
if type == 1:
|
if curType:
|
continue
|
|
if isReborn:
|
tick = GameWorld.GetGameWorld().GetTick()
|
NPCCommon.NPCControl(curNPC).DoNPCReborn(tick)
|
curNPC.SetVisible(True)
|
continue
|
|
#---ÃŲ»¿É¼û---
|
if not curType:
|
continue
|
|
curNPC.SetVisible(False)
|
|
return
|
|
## ÃÅÏÔÒþ
|
# @param doorIDList npcÁбí
|
# @param type 1£ºÃſɼû£» ÆäËû£ºÃŲ»¿É¼û
|
# @return None
|
# @remarks ½öÖ§³Ö¹âǽID²»Öظ´µÄ
|
def OpenOrCloseDoor(doorIDList, type, isReborn=False):
|
gameNPCManager = GameWorld.GetNPCManager()
|
|
for npcID in doorIDList:
|
curNPC = gameNPCManager.FindGameNPCByNPCID(npcID)
|
if curNPC == None:
|
GameWorld.ErrLog('¸±±¾ÎÞ·¨²éÕÒ, ÃÅID = %s' % (npcID))
|
continue
|
|
curType = curNPC.GetVisible()
|
|
#---Ãſɼû---
|
if type == 1:
|
if curType:
|
continue
|
|
if isReborn:
|
tick = GameWorld.GetGameWorld().GetTick()
|
NPCCommon.NPCControl(curNPC).DoNPCReborn(tick)
|
curNPC.SetVisible(True)
|
continue
|
|
#---ÃŲ»¿É¼û---
|
if not curType:
|
continue
|
|
curNPC.SetVisible(False)
|
|
return
|
#---------------------------------------------------------------------
|
## ³õʼ»¯¸±±¾»ý·ÖÅÅÐаæ(×î´ó´ÎÊý)
|
# @param maxCount ×î´ó´ÎÊý
|
# @return None
|
# @remarks º¯ÊýÏêϸ˵Ã÷.
|
def InitBillBoard(maxCount):
|
GameWorld.GetGameFB().Broadcast_FbBillboard(maxCount)
|
return
|
#---------------------------------------------------------------------
|
## ³õʼ»¯Íæ¼Ò¸±±¾»ý·ÖÅÅÐаñ
|
# @param curPlayer µ±Ç°Íæ¼Ò
|
# @return None
|
# @remarks º¯ÊýÏêϸ˵Ã÷.
|
def InitBillBoardPlayer(curPlayer):
|
curPlayerID = curPlayer.GetPlayerID()
|
curPlayerName = curPlayer.GetName()
|
playerBillBoard = GameWorld.GetGameFB().GetFbBillBoardPlayer(curPlayerID)
|
playerBillBoard.SetPlayerID(curPlayerID)
|
playerBillBoard.SetPlayerName(curPlayerName)
|
# playerBillBoard.SetCountry(curPlayer.GetCountry())
|
playerBillBoard.SetPoint(0)
|
return
|
#---------------------------------------------------------------------
|
## Ôö¼Ó/¼õÉÙÍæ¼Ò¸±±¾»ý·ÖÅÅÐаñ
|
# @param curPlayer µ±Ç°Íæ¼Ò
|
# @param type ²Ù×÷ÀàÐÍ type = 1,¼Ó,,2,¼õ
|
# @param value ²Ù×÷Öµ
|
# @return None
|
# @remarks º¯ÊýÏêϸ˵Ã÷.
|
def AddorReduceBillBoard(curPlayer , type , value):
|
playerBillBoard = GameWorld.GetGameFB().GetFbBillBoardPlayer(curPlayer.GetPlayerID())
|
#Ôö¼Ó»ý·Ö
|
if type == 1:
|
point = min((playerBillBoard.GetPoint() + value), 65535)
|
#¼õÉÙ»ý·Ö
|
else:
|
point = max((playerBillBoard.GetPoint() - value), 0)
|
|
playerBillBoard.SetPoint(point)
|
return point
|
#---------------------------------------------------------------------
|
## ÉèÖÃÅÅÐаñÍæ¼Ò¹ú¼®
|
# @param curPlayer µ±Ç°Íæ¼Ò
|
# @return None
|
# @remarks º¯ÊýÏêϸ˵Ã÷.
|
def SetCountryBillBoard(curPlayer, country):
|
playerBillBoard = GameWorld.GetGameFB().GetFbBillBoardPlayer(curPlayer.GetPlayerID())
|
playerBillBoard.SetCountry(country)
|
return
|
|
#---------------------------------------------------------------------
|
## »ñµÃµ±Ç°Íæ¼ÒµÄ¸±±¾»ý·ÖÅÅÐаñ
|
# @param curPlayer µ±Ç°Íæ¼Ò
|
# @return None
|
# @remarks º¯ÊýÏêϸ˵Ã÷.
|
def GetPlayerBillBoardPoint(curPlayer):
|
playerBillBoard = GameWorld.GetGameFB().GetFbBillBoardPlayer(curPlayer.GetPlayerID())
|
return playerBillBoard.GetPoint()
|
#---------------------------------------------------------------------
|
## »ñµÃÍæ¼ÒÔÚ¸±±¾»ý·ÖÅÅÐаñÖеÄλÖÃ
|
# @param curPlayer µ±Ç°Íæ¼Ò
|
# @return None
|
# @remarks º¯ÊýÏêϸ˵Ã÷.
|
def GetPlayerIndex_InBillBoard(curPlayer):
|
playerBillBoard = GameWorld.GetGameFB().GetFbBillBoardPlayer(curPlayer.GetPlayerID())
|
return playerBillBoard.GetBillboardIndex()
|
#---------------------------------------------------------------------
|
## ˢлý·ÖÅÅÐаñ
|
# @param maxCount ÅÅÐаñ×î´ó¸öÊý
|
# @return None
|
# @remarks º¯ÊýÏêϸ˵Ã÷.
|
def NotifyBillBoard(maxCount):
|
gameFB = GameWorld.GetGameFB()
|
#ÅÅÐòÅÅÐаñ
|
gameFB.SortFbBillBoardPlayer()
|
#֪ͨ¿Í»§¶Ë
|
gameFB.Broadcast_FbBillboard(maxCount)
|
return
|
#---------------------------------------------------------------------
|
## ÉèÖø±±¾×´Ì¬
|
# @param step ²½ÖèÊý
|
# @param tick µ±Ç°Ê±¼ä
|
# @return None
|
# @remarks º¯ÊýÏêϸ˵Ã÷.
|
def SetFBStep(step, tick):
|
gameFB = GameWorld.GetGameFB()
|
gameFB.SetFBStep(step)
|
gameFB.SetFBStepTick(tick)
|
GameWorld.Log("SetFBStep %s, tick=%s" % (step, tick), GameWorld.GetGameWorld().GetPropertyID())
|
return
|
#---------------------------------------------------------------------
|
## ¸ø¿Í»§¶Ëµ¯ÏûÏ¢
|
# @param keepTime ³ÖÐøʱ¼äs
|
# @param msgType ASCIIÂë TFbSystemMessageType
|
# @param msg ÏûÏ¢
|
# @return None
|
# @remarks º¯ÊýÏêϸ˵Ã÷.
|
def Sync_FbSystemMessage(keepTime , msgType , msg):
|
playerManager = GameWorld.GetMapCopyPlayerManager()
|
|
for i in range(playerManager.GetPlayerCount()):
|
curPlayer = playerManager.GetPlayerByIndex(i)
|
if not curPlayer.GetPlayerID():
|
continue
|
|
#(int keepTime, int msgType, char * msg)
|
#msgType -> IPY_GameWorld.fmtUseSystemMessage , IPY_GameWorld.fmtUseAscII
|
curPlayer.Sync_FbSystemMessage(keepTime , msgType , msg)
|
|
return
|
#---------------------------------------------------------------------
|
## ¸ø¿Í»§¶Ë·¢ËÍ֪ͨÍæ¼Òµ¹¼ÆʱÐÅÏ¢
|
# @param msgType ÈçIPY_GameWorld.tttWaitStart
|
# @param msgTick ¿ªÊ¼µÄtick
|
# @param npcID
|
# @param isContinue ³ÖÐø֪ͨ
|
# @return None
|
# @remarks º¯ÊýÏêϸ˵Ã÷.
|
def Sync_Player_TimeTick(msgType , msgTick , npcID=0 , isContinue=True):
|
playerManager = GameWorld.GetMapCopyPlayerManager()
|
|
for index in range(0 , playerManager.GetPlayerCount()):
|
curPlayer = playerManager.GetPlayerByIndex(index)
|
if not curPlayer.GetPlayerID():
|
continue
|
|
curPlayer.Sync_TimeTick(msgType , npcID, msgTick, isContinue)
|
|
return
|
|
## ¸ø¿Í»§¶Ë·¢ËÍ֪ͨÍæ¼Òµ¹¼ÆʱÐÅÏ¢
|
# @param msgType ÈçIPY_GameWorld.tttWaitStart
|
# @param msgTick ¿ªÊ¼µÄtick
|
# @param isSendPrevMsg ÊÇ·ñ·¢ËÍÇå¿ÕÉÏÒ»¸öµ¹¼ÆʱÐÅÏ¢ÀàÐÍ
|
# @param npcID
|
# @param isContinue ³ÖÐø֪ͨ
|
# @return None
|
# @remarks º¯ÊýÏêϸ˵Ã÷.
|
def Sync_Player_TimeTickEx(msgType , msgTick , isSendPrevMsg, npcID=0 , isContinue=True):
|
prevMsgType = None
|
if isSendPrevMsg:
|
prevMsgType = GameWorld.GetGameFB().GetGameFBDictByKey(ChConfig.Map_FBDict_PrevFBTimeType)
|
if prevMsgType and prevMsgType != msgType: # ÓÐÉÏÒ»¸öÐÅÏ¢£¬ÇÒÓ뵱ǰÐÅÏ¢²»Í¬²Å·¢
|
isSendPrevMsg = True
|
else:
|
isSendPrevMsg = False
|
|
GameWorld.Log("Sync_Player_TimeTickEx() prevMsgType=%s,msgType=%s" % (prevMsgType, msgType))
|
GameWorld.GetGameFB().SetGameFBDict(ChConfig.Map_FBDict_PrevFBTimeType, msgType)
|
|
playerManager = GameWorld.GetMapCopyPlayerManager()
|
|
for index in range(0 , playerManager.GetPlayerCount()):
|
curPlayer = playerManager.GetPlayerByIndex(index)
|
if not curPlayer.GetPlayerID():
|
continue
|
|
if isSendPrevMsg and prevMsgType:
|
curPlayer.Sync_TimeTick(prevMsgType , npcID, 0, isContinue)
|
curPlayer.Sync_TimeTick(msgType , npcID, msgTick, isContinue)
|
|
return
|
#---------------------------------------------------------------------
|
## »ñµÃÊÇ·ñ¿ÉÒÔ½øÈë¶ÔÕ½¸±±¾
|
# @param familyID ¼Ò×åID
|
# @return ×Ö·û´® Èç'VSFB_CanEnter'
|
# @remarks º¯ÊýÏêϸ˵Ã÷.
|
def GetCanEnterVSFB(familyID):
|
gameWorld = GameWorld.GetGameWorld()
|
|
todayNotFight = True
|
|
for index in range(gameWorld.GetGameWorldCount()):
|
gameFB = gameWorld.GetGameFBByFbIndex(index)
|
|
familyVsManager = gameFB.GetFamilyVS()
|
attackID = familyVsManager.GetFamilyID()
|
defenceID = familyVsManager.GetVSFamilyID()
|
#½ñÈÕÓÐÈüÊÂ
|
if attackID or defenceID:
|
todayNotFight = False
|
|
#²»ÊÇÕⳡս¶·
|
if familyID not in [ attackID , defenceID ]:
|
continue
|
|
if gameWorld.GetOpenStateByFbIndex(index) != IPY_GameWorld.fbosOpen:
|
#¸±±¾ÒѹرÕ
|
return Def_VSFB_IsClose
|
|
#¿ÉÒÔ½øÈë
|
return Def_VSFB_CanEnter
|
|
#½ñÈÕÎÞÈüÊÂ
|
if todayNotFight:
|
return Def_VSFB_NotFight
|
|
#ÎÞ·¨²éÕÒ¶ÔÕ½¼Ò×å
|
return Def_VSFB_NotFamilyID
|
#---------------------------------------------------------------------
|
## »ñµÃÖ¸¶¨Ïß·µÄ¸±±¾¹ÜÀíÆ÷¼°Ïß·
|
# @param familyID ¼Ò×åID
|
# @return None , None or gameFB , index
|
# @remarks º¯ÊýÏêϸ˵Ã÷.
|
def Get_VS_Line_GameFB(familyID):
|
gameWorld = GameWorld.GetGameWorld()
|
|
for index in range(gameWorld.GetGameWorldCount()):
|
gameFB = gameWorld.GetGameFBByFbIndex(index)
|
|
familyVsManager = gameFB.GetFamilyVS()
|
attackID = familyVsManager.GetFamilyID()
|
defenceID = familyVsManager.GetVSFamilyID()
|
|
if familyID in [ attackID , defenceID ]:
|
return gameFB , index
|
|
return None , None
|
#---------------------------------------------------------------------
|
## »ñµÃÖ¸¶¨Ïß·Íæ¼Ò¹ÜÀíÆ÷
|
# @param Ïß·Ë÷Òý
|
# @return Íæ¼Ò¹ÜÀíÆ÷ IPY_MapCopyPlayerManager
|
# @remarks º¯ÊýÏêϸ˵Ã÷.
|
def Get_Line_PlayerManager(lineIndex):
|
return GameWorld.GetGameWorld().GetMapCopyPlayerManagerByFbIndex(lineIndex)
|
|
#---------------------------------------------------------------------
|
## »ñµÃ×é¶Ó¸±±¾,µØͼ¹ÜÀíÆ÷
|
# @param teamID ¶ÓÎéID
|
# @return None or gameWorld ÐÂʵÀý»¯µÄIPY_GameWorld
|
# @remarks º¯ÊýÏêϸ˵Ã÷.
|
def Get_TeamFB_Line_GameFB(teamID):
|
gameMap = GameWorld.GetMap()
|
#²»ÊÇ×é¶Ó¸±±¾, ÔÊÐí½øÈë
|
if gameMap.GetMapFBType() != IPY_GameWorld.fbtTeam:
|
GameWorld.Log('###µ÷Óú¯ÊýÒì³£ Get_TeamFB_Line_GameFB = %s' % (gameMap.GetMapFBType()))
|
return
|
|
#и±±¾, ÔÊÐí½øÈë
|
if not teamID:
|
return
|
|
gameWorldManager = GameWorld.GetGameWorld()
|
|
for index in range(gameWorldManager.GetGameWorldCount()):
|
gameWorld = IPY_GameWorld.IPY_GameWorld(index)
|
|
if gameWorld.GetPropertyID() != teamID:
|
continue
|
|
return gameWorld
|
|
return
|
|
#---------------------------------------------------------------------
|
##¼ì²éµ±Ç°¸±±¾×´Ì¬ÊÇ·ñ¿ÉÒÔ½øÈë
|
# @param teamID ×é¶ÓID
|
# @return ²¼¶ûÖµ
|
# @remarks
|
def CheckFBStateCanEnter(askStruct):
|
gameMapFBType = GameWorld.GetMap().GetMapFBType()
|
|
#---×é¶Ó¸±±¾¼ì²é---
|
if gameMapFBType == IPY_GameWorld.fbtTeam:
|
gameWorld = Get_TeamFB_Line_GameFB(askStruct.GetTeamID())
|
if not gameWorld:
|
#¿ÉÒÔ½øÈë
|
return True
|
|
if gameWorld.GetCloseFBTick() > 0:
|
#²»¿É½øÈë
|
return False
|
|
if askStruct.GetTeamLV() == IPY_GameWorld.tmlLeader:
|
'''ÔÒò£º
|
¶Ó³¤Í˳ö×é¶Ó¸±±¾£¬ÆäËû¶ÓÔ±»¹ÔÚÀïÃ棬´Ëʱ¸±±¾²»»á±»¹Ø±Õ
|
¶Ó³¤ÔÚ¶ÓÎéID²»±äµÄÇé¿öÏÂÓÖ×éÁËÆäËûÈË£¬È»ºóÓÖÏë½øÈ¥¸Ã¸±±¾£¬ÄÇôÕâʱ»á½øÈë֮ǰ¶ÓÔ±»¹ÔÚµÄÄÇÌõ¶ÓÎé·ÖÏߣ¬µ¼Ö¶ÓÎéÏß·´íÂÒ
|
ËùÒÔ´Ë´¦²»ÔÊÐí¸Ã¶Ó³¤½øÈ룬²¢ÌáʾÆäµÈ´ý»òÖØн¨¶Ó½øÈë
|
|
FBinCantEnter ¸±±¾ÇåÀíÖУ¬ÇëµÈ´ý¹Ø±Õ»òÖØд´½¨¶ÓÎé½øÈë
|
'''
|
return False, "FBinCantEnter"
|
|
#¸±±¾Ôڵȴý¹Ø±Õ״̬²»ÔÊÐíÍæ¼Ò½øÈë
|
return (gameWorld.GetOpenState() != IPY_GameWorld.fbosWaitForClose)
|
|
#¿ÉÒÔ½øÈë
|
return True
|
#---------------------------------------------------------------------
|
def Sync_FBNPC(mapID=0, npcIDList=[], curPlayer=None):
|
## ͬ²½µ±Ç°¸±±¾NPC¸ø¸±±¾ÖеÄËùÓÐÍæ¼Ò
|
if not mapID:
|
mapID = GameWorld.GetMap().GetMapID()
|
mapID = GetRecordMapID(mapID)
|
npcCntDict = {}
|
gameNPCManager = GameWorld.GetNPCManager()
|
for index in xrange(gameNPCManager.GetNPCCount()):
|
curNPC = gameNPCManager.GetNPCByIndex(index)
|
npcID = curNPC.GetNPCID()
|
if not npcID:
|
continue
|
if curNPC.GetGameNPCObjType() == IPY_GameWorld.gnotPet:
|
continue
|
if npcIDList and npcID not in npcIDList:
|
continue
|
npcCntDict[npcID] = npcCntDict.get(npcID, 0) + 1
|
|
if curPlayer:
|
NPCCommon.SyncNPCCntInfo(curPlayer, mapID, npcCntDict)
|
else:
|
playerManager = GameWorld.GetMapCopyPlayerManager()
|
for i in xrange(playerManager.GetPlayerCount()):
|
curPlayer = playerManager.GetPlayerByIndex(i)
|
if curPlayer.GetID() == 0:
|
continue
|
NPCCommon.SyncNPCCntInfo(curPlayer, mapID, npcCntDict)
|
return npcCntDict
|
|
##»ñµÃµØͼÉϵÄNPCÁбí
|
# @param ÎÞ²ÎÊý
|
# @return ·µ»ØÖµ, NPCʵÀýÁбí[curNPC,curNPC,,,,,]
|
# @remarks »ñµÃµØͼÉϵÄNPCÁбí
|
def GetMapNPCList():
|
gameNPCList = []
|
gameNPCManager = GameWorld.GetNPCManager()
|
|
for index in range(gameNPCManager.GetNPCCount()):
|
curNPC = gameNPCManager.GetNPCByIndex(index)
|
|
if curNPC.GetID() == 0:
|
continue
|
|
#@warning: ³èÎïÉè¼ÆΪδ³öÕ½NPC, ÕâÀïÒª¹ýÂË
|
if curNPC.GetGameNPCObjType() == IPY_GameWorld.gnotPet:
|
continue
|
|
gameNPCList.append(curNPC)
|
|
return gameNPCList
|
|
#---------------------------------------------------------------------
|
##»ñµÃµØͼÉϵÄϵͳNPCÊýÁ¿
|
# @param ÎÞ²ÎÊý
|
# @return NPCÁбí
|
# @remarks ¿Í»§¶Ë·â°üÏìÓ¦
|
def GetMapSystemNPCList():
|
#»ñÈ¡µØͼ¹«¹²NPCÁбí
|
findNPCList = []
|
|
#¸ù¾Ý¸±±¾ÐèÇó, ¹ýÂËNPC
|
gameNPCManager = GameWorld.GetNPCManager()
|
for index in range(gameNPCManager.GetNPCCount()):
|
curNPC = gameNPCManager.GetNPCByIndex(index)
|
|
if curNPC.GetID() == 0 or GameObj.GetHP(curNPC) <= 0:
|
continue
|
|
if curNPC.GetGameNPCObjType() == IPY_GameWorld.gnotPet:
|
continue
|
|
#ÕÙ»½ÊÞÌØÊâÅжÏ
|
if curNPC.GetGameNPCObjType() == IPY_GameWorld.gnotSummon:
|
curNPCDetail = GameWorld.GetObjDetail(curNPC)
|
|
if curNPCDetail == None:
|
continue
|
|
curNPCOwner = curNPCDetail.GetOwner()
|
|
if curNPCOwner != None and curNPCOwner.GetGameObjType() == IPY_GameWorld.gotPlayer:
|
#Íæ¼ÒµÄÕÙ»½ÊÞ²»¼Ç¼
|
continue
|
|
#·ûºÏÌõ¼þµÄ±¾µØͼµÄNPCÁбí
|
findNPCList.append(curNPC)
|
|
return findNPCList
|
#---------------------------------------------------------------------
|
##Ç¿ÖÆT³ö¸±±¾ÖÐËùÓеÄÍæ¼Ò
|
# @param ÎÞ²ÎÊý
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks
|
def DoLogic_FBKickAllPlayer():
|
playerManager = GameWorld.GetMapCopyPlayerManager()
|
|
for i in range(0, playerManager.GetPlayerCount()):
|
curPlayer = playerManager.GetPlayerByIndex(i)
|
|
if curPlayer.GetID() == 0:
|
continue
|
|
#Íæ¼ÒÖ÷¶¯À뿪¸±±¾
|
PlayerControl.PlayerLeaveFB(curPlayer)
|
|
return
|
#---------------------------------------------------------------------
|
|
##»ñµÃµØͼÉϵÄϵͳNPCÊýÁ¿(²»°üº¬npcµÄÕлÃÊÞ£¬ Ö»ÓÃÓÚÇå³ýfb¹Ö)
|
# @param ÎÞ²ÎÊý
|
# @return NPCÁбí
|
# @remarks ¿Í»§¶Ë·â°üÏìÓ¦
|
def GetMapSystemNPCListEx():
|
#»ñÈ¡µØͼ¹«¹²NPCÁбí
|
gameNPCList = GetMapNPCList()
|
findNPCList = []
|
|
#¸ù¾Ý¸±±¾ÐèÇó, ¹ýÂËNPC
|
for curNPC in gameNPCList:
|
#ʬÌå²»´¦Àí
|
if GameObj.GetHP(curNPC) <= 0:
|
continue
|
|
#ÕÙ»½ÊÞÌØÊâÅжÏ
|
if curNPC.GetGameNPCObjType() == IPY_GameWorld.gnotSummon:
|
|
curNPCDetail = GameWorld.GetObjDetail(curNPC)
|
if curNPCDetail == None:
|
continue
|
|
curNPCOwner = curNPCDetail.GetOwner()
|
if curNPCOwner != None and curNPCOwner.GetGameObjType() in (IPY_GameWorld.gotPlayer,
|
IPY_GameWorld.gotNPC):
|
continue
|
|
#·ûºÏÌõ¼þµÄ±¾µØͼµÄNPCÁбí
|
findNPCList.append(curNPC)
|
|
return findNPCList
|
|
|
##Çå³ý¸±±¾npc
|
# @param ÎÞ²ÎÊý
|
# @return ·µ»ØÖµÎÞÒâÒå
|
def ClearFBNPC(ignoreIDList=[]):
|
|
#»÷ɱËùÓи±±¾ÕÙ»½³öÀ´µÄNPC
|
for curNPC in GetMapSystemNPCListEx():
|
if curNPC == None:
|
continue
|
|
if curNPC.GetType() in [IPY_GameWorld.ntFunctionNPC, IPY_GameWorld.ntPet]:
|
#³èÎï ¹¦ÄÜNPC³ýÍâ
|
continue
|
|
if curNPC.GetNPCID() in ignoreIDList:
|
#ºöÂÔÁбí
|
continue
|
|
NPCCommon.SetDeadEx(curNPC)
|
return
|
|
##Çå³ý¸±±¾npc
|
# @param ÎÞ²ÎÊý
|
# @return ·µ»ØÖµÎÞÒâÒå
|
def ClearFBNPCEx(clearNPCIDList):
|
|
#»÷ɱËùÓи±±¾ÕÙ»½³öÀ´µÄNPC
|
for curNPC in GetMapSystemNPCListEx():
|
if curNPC == None:
|
continue
|
|
if curNPC.GetType() in [IPY_GameWorld.ntFunctionNPC, IPY_GameWorld.ntPet]:
|
#³èÎï ¹¦ÄÜNPC³ýÍâ
|
continue
|
|
if curNPC.GetNPCID() not in clearNPCIDList:
|
#ºöÂÔÁбí
|
continue
|
|
NPCCommon.SetDeadEx(curNPC)
|
return
|
|
##»ñÈ¡¸±±¾NPC¸öÊý
|
# @param npcIDList: Ҫͳ¼ÆµÄNPCIDÁбí
|
# @param npcIDList: ²»°üº¬µÄNPCIDÁбí
|
# @return ¸öÊý
|
def GetFBNPCCnt(npcIDList=[], ignoreIDList=[]):
|
|
npcCnt = 0
|
for curNPC in GetMapSystemNPCListEx():
|
if curNPC == None:
|
continue
|
|
if curNPC.GetType() in [IPY_GameWorld.ntFunctionNPC, IPY_GameWorld.ntPet]:
|
continue
|
|
npcID = curNPC.GetNPCID()
|
if npcIDList and npcID not in npcIDList:
|
continue
|
|
if ignoreIDList and npcID in ignoreIDList:
|
continue
|
|
npcCnt += 1
|
|
return npcCnt
|
|
##ÉèÖõØͼËæ»úË¢¹Ö
|
# @param refreshMark: Ë¢¹Ö±êʶµãmark
|
# @param npcID: Ë¢¹ÖNPCID
|
# @param needRefreshCnt: ÐèҪˢµÄ¸öÊý
|
# @param perMaxCnt: ÿ¸öµã×î´óË¢¹ÖÊý
|
# @return
|
def SetRandomRefreshMapNPC(refreshMark, npcID, needRefreshCnt, perMaxCnt):
|
gameFB = GameWorld.GetGameFB()
|
|
npcIDKey = ChConfig.Map_NPC_RandomMapNPCID % refreshMark
|
needCntKey = ChConfig.Map_NPC_RandomMapNPCNeedCnt % refreshMark
|
perMaxCntKey = ChConfig.Map_NPC_RandomMapNPCPerMaxCnt % refreshMark
|
|
gameFB.SetGameFBDict(npcIDKey, npcID)
|
gameFB.SetGameFBDict(needCntKey, needRefreshCnt)
|
gameFB.SetGameFBDict(perMaxCntKey, perMaxCnt)
|
return
|
|
## ---------------------------------- TD ---------------------------------------
|
# TDË¢¹ÖÅäÖÃ
|
(
|
Def_TDCfg_NextWheelTime, # Ç¿ÖƽøÈëÏÂÒ»´ó²¨Ê±¼ä(ÀÛ¼Æʱ¼ä)
|
Def_TDCfg_PrepareTime, # ´ó²¨¿ªÊ¼Ç°×¼±¸Ê±¼ä
|
Def_TDCfg_SmallWheelSpace, # С²¨Ë¢¹Ö¼ä¸ôʱ¼ä
|
Def_TDCfg_NotifyMark, # ´ó²¨Ë¢¹Ö¸±±¾¹ã²¥mark
|
) = range(4)
|
|
## ¿ªÆôTDË¢¹ÖµãË¢¹Ö
|
# @param rMark: Ë¢¹Ö±êʶµãmark
|
# @param fileNum: Ë¢¹ÖÎļþ±ê¼Ç
|
# @param sign: Ë¢¹ÖÎļþÄÚ²ãNPC×é±ê¼Ç
|
# @param tick:
|
# @param isNotify: ÊÇ·ñ¹ã²¥
|
# @return
|
def OpenTDNPCRefresh(rMark, fileNum, sign, tick, isNotify):
|
gameFB = GameWorld.GetGameFB()
|
gameFB.SetGameFBDict(ChConfig.Map_TDNPC_RefreshFileNum % rMark, fileNum)
|
gameFB.SetGameFBDict(ChConfig.Map_TDNPC_RefreshSignKey % rMark, sign)
|
gameFB.SetGameFBDict(ChConfig.Map_TDNPC_RefreshStartTick % rMark, tick)
|
|
gameFB.SetGameFBDict(ChConfig.Map_TDNPC_RefreshBigWheelNum % rMark, 0)
|
gameFB.SetGameFBDict(ChConfig.Map_TDNPC_RefreshSmallWheelNum % rMark, 0)
|
gameFB.SetGameFBDict(ChConfig.Map_TDNPC_CurWheelStartTick % rMark, tick)
|
gameFB.SetGameFBDict(ChConfig.Map_TDNPC_CurWheelIsOver % rMark, 0)
|
gameFB.SetGameFBDict(ChConfig.Map_TDNPC_AllWheelIsOver % rMark, 0)
|
gameFB.SetGameFBDict(ChConfig.Map_TDNPC_NPCCnt % rMark, 0)
|
gameFB.SetGameFBDict(ChConfig.Map_TDNPC_NPCBossCnt % rMark, 0)
|
|
if isNotify:
|
__TDStartRefreshNotify(gameFB, fileNum, 0, sign)
|
return
|
|
## ¹Ø±ÕTDË¢¹ÖµãË¢¹Ö
|
# @param rMark: Ë¢¹Ö±êʶµãmark
|
# @param isResetNPC: ÊÇ·ñÖØÖÃNPC¸öÊý
|
# @return
|
def CloseTDNPCRefresh(rMark, isResetNPC=True):
|
gameFB = GameWorld.GetGameFB()
|
gameFB.SetGameFBDict(ChConfig.Map_TDNPC_RefreshFileNum % rMark, 0)
|
gameFB.SetGameFBDict(ChConfig.Map_TDNPC_RefreshSignKey % rMark, 0)
|
gameFB.SetGameFBDict(ChConfig.Map_TDNPC_RefreshStartTick % rMark, 0)
|
|
gameFB.SetGameFBDict(ChConfig.Map_TDNPC_RefreshBigWheelNum % rMark, 0)
|
gameFB.SetGameFBDict(ChConfig.Map_TDNPC_RefreshSmallWheelNum % rMark, 0)
|
gameFB.SetGameFBDict(ChConfig.Map_TDNPC_CurWheelStartTick % rMark, 0)
|
gameFB.SetGameFBDict(ChConfig.Map_TDNPC_CurWheelIsOver % rMark, 0)
|
|
if isResetNPC:
|
gameFB.SetGameFBDict(ChConfig.Map_TDNPC_NPCCnt % rMark, 0)
|
gameFB.SetGameFBDict(ChConfig.Map_TDNPC_NPCBossCnt % rMark, 0)
|
return
|
|
## ¼ì²éTDË¢¹ÖµãÊÇ·ñÈ«²¿Ë¢¹Ö½áÊø
|
# @param rMarkList: ¼ì²é±êʶµãÁбí
|
# @return
|
def IsTDNPCRefreshOver(rMarkList):
|
gameFB = GameWorld.GetGameFB()
|
for rMark in rMarkList:
|
if not gameFB.GetGameFBDictByKey(ChConfig.Map_TDNPC_AllWheelIsOver % rMark):
|
return False
|
|
return True
|
|
## ¼ì²éTDË¢¹Öµã´ó²¨ÊÇ·ñË¢¹Ö½áÊø
|
# @param rMarkList: ¼ì²é±êʶµãÁбí
|
# @return
|
def IsTDWheelRefreshOver(rMarkList):
|
gameFB = GameWorld.GetGameFB()
|
for rMark in rMarkList:
|
if not gameFB.GetGameFBDictByKey(ChConfig.Map_TDNPC_CurWheelIsOver % rMark):
|
return False
|
return True
|
|
## ¼ì²éTD±¾´ó²¨Ë¢µÄ¹ÖÊÇ·ñÈ«²¿±»»÷ɱ
|
def IsTDNPCCurWheelAllKilled(rMarkList):
|
gameFB = GameWorld.GetGameFB()
|
for rMark in rMarkList:
|
npcCnt = gameFB.GetGameFBDictByKey(ChConfig.Map_TDNPC_NPCCnt % rMark)
|
curWheelIsOver = gameFB.GetGameFBDictByKey(ChConfig.Map_TDNPC_CurWheelIsOver % rMark)
|
# »¹ÓÐ¹Ö »ò ±¾²¨¹Ö»¹Ã»Ë¢Íê
|
if npcCnt > 0 or not curWheelIsOver:
|
return False
|
|
return True
|
|
## ¼ì²éÊÇ·ñÇ¿ÖƽøÈëÏÂÒ»²¨
|
# @param rMark: ±êʶµã
|
# @param tick:
|
# @return
|
def CheckForceEnterNextWheel(rMark, tick):
|
gameFB = GameWorld.GetGameFB()
|
startTick = gameFB.GetGameFBDictByKey(ChConfig.Map_TDNPC_RefreshStartTick % rMark)
|
curWheelNum = gameFB.GetGameFBDictByKey(ChConfig.Map_TDNPC_RefreshBigWheelNum % rMark)
|
|
fileNum = gameFB.GetGameFBDictByKey(ChConfig.Map_TDNPC_RefreshFileNum % rMark)
|
if fileNum <= 0:
|
return False
|
|
refreshCfgList = ReadChConfig.GetEvalChConfig("TD_%s_Cfg" % fileNum)
|
if curWheelNum >= len(refreshCfgList):
|
return False
|
|
wheelInfoList = refreshCfgList[curWheelNum]
|
forceNextWheelTime = wheelInfoList[Def_TDCfg_NextWheelTime]
|
passTick = tick - startTick
|
# 0ĬÈÏΪ²»Åжϣ¬Èç×îºóÒ»¹ØÖ±½ÓÌî0
|
return forceNextWheelTime > 0 and passTick >= forceNextWheelTime
|
|
## ÉèÖýøÈëÏÂÒ»²¨
|
# @param rMark: ±êʶµã
|
# @param tick:
|
# @return
|
def SetEnterTDNextWheel(rMark, tick, isNotify):
|
gameFB = GameWorld.GetGameFB()
|
curWheelNum = gameFB.GetGameFBDictByKey(ChConfig.Map_TDNPC_RefreshBigWheelNum % rMark)
|
nextWheelNum = curWheelNum + 1
|
|
gameFB.SetGameFBDict(ChConfig.Map_TDNPC_RefreshBigWheelNum % rMark, nextWheelNum)
|
gameFB.SetGameFBDict(ChConfig.Map_TDNPC_RefreshSmallWheelNum % rMark, 0)
|
gameFB.SetGameFBDict(ChConfig.Map_TDNPC_CurWheelStartTick % rMark, tick)
|
gameFB.SetGameFBDict(ChConfig.Map_TDNPC_CurWheelIsOver % rMark, 0)
|
|
fileNum = gameFB.GetGameFBDictByKey(ChConfig.Map_TDNPC_RefreshFileNum % rMark)
|
if fileNum > 0 and isNotify:
|
signKey = gameFB.GetGameFBDictByKey(ChConfig.Map_TDNPC_RefreshSignKey % rMark)
|
__TDStartRefreshNotify(gameFB, fileNum, nextWheelNum, signKey)
|
|
GameWorld.DebugLog("TD ½øÈëÏÂÒ»²¨£ºfileNum=%s,rMark=%s,nextWheelNum=%s" % (fileNum, rMark, nextWheelNum))
|
return
|
|
## ¿ªÊ¼Ë¢¹Ö¹ã²¥
|
# @param rMark: ±êʶµã
|
# @param fileNum:
|
# @return
|
def __TDStartRefreshNotify(gameFB, fileNum, wheelNum, sign):
|
if fileNum <= 0:
|
return
|
refreshNPCDict = ReadChConfig.GetEvalChConfig("TD_%s_NPCID" % fileNum)
|
refreshNPCList = refreshNPCDict.get(sign,[])
|
if wheelNum >= len(refreshNPCList):
|
return
|
npcid = refreshNPCList[wheelNum][0][0][0]
|
refreshCfgList = ReadChConfig.GetEvalChConfig("TD_%s_Cfg" % fileNum)
|
if wheelNum < len(refreshCfgList):
|
wheelInfoList = refreshCfgList[wheelNum]
|
notifyMark = wheelInfoList[Def_TDCfg_NotifyMark]
|
if notifyMark:
|
# 0´ú±íµÚÒ»²¨
|
PlayerControl.FBNotify(notifyMark, [npcid])
|
return
|
|
|
## ¸üбêʶµã¹ÖÎï¸öÊý
|
# @param curNPC: NPCʵÀý
|
# @param value: ¸üÐÂÖµ, Ö§³ÖÕý¸ºÊý
|
# @return
|
def UpdTDNPCCnt(curNPC, value):
|
gameFB = GameWorld.GetGameFB()
|
rMark = curNPC.GetDictByKey(ChConfig.Def_NPC_Dict_FromRefreshMark)
|
|
curMarkNPCBossCntKey = ChConfig.Map_TDNPC_NPCBossCnt % rMark
|
bossCnt = gameFB.GetGameFBDictByKey(curMarkNPCBossCntKey)
|
isBoss = ChConfig.IsGameBoss(curNPC)
|
if isBoss:
|
bossCnt = max(0, bossCnt + value)
|
gameFB.SetGameFBDict(curMarkNPCBossCntKey, bossCnt)
|
|
curMarkNPCCntKey = ChConfig.Map_TDNPC_NPCCnt % rMark
|
npcCnt = gameFB.GetGameFBDictByKey(curMarkNPCCntKey)
|
updCnt = npcCnt + value
|
updCnt = max(0, updCnt)
|
gameFB.SetGameFBDict(curMarkNPCCntKey, updCnt)
|
GameWorld.DebugLog("UpdTDNPCCnt rMark=%s,updCnt=%s,bossCnt=%s,isBoss=%s" % (rMark, updCnt, bossCnt, isBoss))
|
return updCnt
|
|
## ֪ͨϲ¨Ë¢¹Öʱ¼ä
|
# @param curPlayer:Noneʱ¹ã²¥¸±±¾ÖÐËùÓÐÍæ¼Ò
|
# @param rMark:
|
# @param msgType:
|
# @param tick:ʱ¼ä´Á
|
# @return
|
def Sync_TDNextWheelTick(curPlayer, rMark, msgType, tick, msgID=0):
|
gameFB = GameWorld.GetGameFB()
|
|
curWheelNum = gameFB.GetGameFBDictByKey(ChConfig.Map_TDNPC_RefreshBigWheelNum % rMark)
|
|
fileNum = gameFB.GetGameFBDictByKey(ChConfig.Map_TDNPC_RefreshFileNum % rMark)
|
if fileNum <= 0:
|
return -1
|
|
refreshCfgList = ReadChConfig.GetEvalChConfig("TD_%s_Cfg" % fileNum)
|
if curWheelNum >= len(refreshCfgList):
|
return -1
|
|
wheelInfoList = refreshCfgList[curWheelNum]
|
nextWheelTime = wheelInfoList[Def_TDCfg_NextWheelTime]
|
|
if nextWheelTime <= 0:
|
prepareTime = wheelInfoList[Def_TDCfg_PrepareTime]
|
if not prepareTime:
|
return -1
|
curWheelStartTick = gameFB.GetGameFBDictByKey(ChConfig.Map_TDNPC_CurWheelStartTick % rMark)
|
passTick = tick - curWheelStartTick
|
nextWheelRemainTick = max(prepareTime - passTick, 0)
|
else:
|
startTick = gameFB.GetGameFBDictByKey(ChConfig.Map_TDNPC_RefreshStartTick % rMark)
|
passTick = tick - startTick
|
nextWheelRemainTick = max(nextWheelTime - passTick, 0)
|
# IPY_GameWorld.tttFlagTake
|
if curPlayer == None:
|
Sync_Player_TimeTick(msgType, nextWheelRemainTick, msgID)
|
else:
|
curPlayer.Sync_TimeTick(msgType, msgID, nextWheelRemainTick, True)
|
return nextWheelRemainTick
|
|
def GetTDCfgNPCCntInfo(fileNum, sign=0):
|
npcCountDict = {}
|
refreshNPCDict = ReadChConfig.GetEvalChConfig("TD_%s_NPCID" % fileNum)
|
refreshNPCList = refreshNPCDict.get(sign,[])
|
for wheelNPCList in refreshNPCList:
|
for smallWhellNPCInfo in wheelNPCList:
|
for npcID, npcCount in smallWhellNPCInfo:
|
npcCountDict[npcID] = npcCountDict.get(npcID, 0) + npcCount
|
return npcCountDict
|
|
## ---------------------------------- TD ---------------------------------------
|
def GetEnterFBMaxCnt(curPlayer, mapID):
|
## »ñÈ¡¸±±¾×î´ó¿É½øÈë´ÎÊý: »ù±¾´ÎÊý + ¹ã¸æ´ÎÊý + ¹ºÂò´ÎÊý + ʹÓõÀ¾ßÔö¼Ó´ÎÊý + ÆäËû
|
fbIpyData = GetFBIpyData(mapID)
|
if not fbIpyData:
|
return 0
|
maxTimes = fbIpyData.GetDayTimes()
|
adCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FBADCnt % mapID)
|
buyCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FBBuyCnt % mapID)
|
itemCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FBItemCnt % mapID)
|
investFBCnt = PlayerGoldInvest.GetAddFBCnt(curPlayer, mapID)
|
maxCnt = maxTimes + adCnt + buyCnt + itemCnt + investFBCnt
|
return maxCnt
|
|
def GetEnterFBCount(curPlayer, fbID, lineBit=-1):
|
## Íæ¼Ò½øÈ븱±¾´ÎÊý
|
fbID = GetRecordMapID(fbID)
|
enterCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FbEnterCnt % fbID)
|
if lineBit >= 0:
|
return GameWorld.GetDataByDigitPlace(enterCnt, lineBit)
|
return enterCnt
|
|
def AddFBCntByItem(curPlayer, itemID, mapID, addCnt):
|
## ÎïÆ·Ôö¼Ó¸±±¾´ÎÊý
|
mapID = GetRecordMapID(mapID)
|
itemAddCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FBItemCnt % mapID)
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FBItemCnt % mapID, itemAddCnt + addCnt)
|
Sync_FBPlayerFBInfoData(curPlayer, mapID)
|
PlayerControl.NotifyCode(curPlayer, 'AddActivityCount_1', [itemID, mapID, addCnt])
|
return
|
|
def AddEnterFBCount(curPlayer, fbID, addCount=1, lineBit=-1, isFree=False):
|
## Ôö¼ÓÍæ¼Ò½øÈ븱±¾´ÎÊý
|
## @param isFree: ÊÇ·ñÃâ·Ñ½øÈëµÄ£¬Ãâ·ÑµÄ²»Ôö¼Óʵ¼Ê½øÈë´ÎÊý£¬µ«ÐèÒª´¥·¢½øÈë´ÎÊý¶îÍâ´¦Àí£¬Èç»îÔ¾¡¢³É¾ÍµÈ
|
#addCountEx = addCount
|
addCount = 0 if isFree else addCount
|
fbID = GetRecordMapID(fbID)
|
enterCntKey = ChConfig.Def_Player_Dict_FbEnterCnt % fbID
|
enterCnt = curPlayer.NomalDictGetProperty(enterCntKey)
|
if lineBit >= 0:
|
curLineEnterCnt = GameWorld.GetDataByDigitPlace(enterCnt, lineBit)
|
updEnterCnt = min(9, curLineEnterCnt + addCount)
|
updValue = GameWorld.ChangeDataByDigitPlace(enterCnt, lineBit, updEnterCnt)
|
PlayerControl.NomalDictSetProperty(curPlayer, enterCntKey, updValue)
|
else:
|
maxCnt = GetEnterFBMaxCnt(curPlayer, fbID)
|
if enterCnt >= maxCnt:
|
return False
|
updCnt = min(maxCnt, enterCnt + addCount)
|
addCount = updCnt-enterCnt
|
PlayerControl.NomalDictSetProperty(curPlayer, enterCntKey, updCnt)
|
|
#PlayerActivity.OnEnterFBActivity(curPlayer, fbID, updCnt, addCountEx)
|
#PlayerSuccess.AddEnterFBSuccess(curPlayer, fbID, addCountEx)
|
updValue = updCnt
|
GameWorld.DebugLog(" AddEnterFBCount fbID=%s, addCount=%s, lineBit=%s, enterCnt=%s,updValue=%s"
|
% (fbID, addCount, lineBit, enterCnt, updValue), curPlayer.GetPlayerID())
|
Sync_FBPlayerFBInfoData(curPlayer, fbID)
|
return True
|
|
def FBOnWeek(curPlayer, onWeekType):
|
return
|
|
def FBOnDay(curPlayer, onDayType):
|
GameWorld.Log("¸±±¾¹ýÌì´¦Àí,FBOnDay...", curPlayer.GetPlayerID())
|
if onDayType != ShareDefine.Def_OnEventType:
|
return
|
FBLogic.OnFBPlayerOnDay(curPlayer, onDayType) # ÔÚÖØÖôÎÊý֮ǰ£¬¿ÉÓÃÓÚ´¦Àí×ÊÔ´ÕÒ»Ø
|
|
mapIDInfo = []
|
ipyDataMgr = IpyGameDataPY.IPY_Data()
|
for i in xrange(ipyDataMgr.GetFBFuncCount()):
|
ipyData = ipyDataMgr.GetFBFuncByIndex(i)
|
mapID = ipyData.GetDataMapID()
|
enterCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FbEnterCnt % mapID)
|
# ûÓÐÈÕ´ÎÊýÏÞÖƵIJ»´¦Àí
|
if not enterCnt and not ipyData.GetDayTimes() and not ipyData.GetPayCntMax():
|
continue
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FbEnterCnt % mapID, 0)
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FBADCnt % mapID, 0)
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FBBuyCnt % mapID, 0)
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FBItemCnt % mapID, 0)
|
mapIDInfo.append(mapID)
|
|
if mapIDInfo:
|
Sync_FBPlayerFBInfoData(curPlayer, mapIDInfo)
|
|
return
|
|
## Íæ¼ÒͨÓø±±¾µÇ¼´¦Àí
|
# @param curPlayer: Íæ¼ÒʵÀý
|
# @return: None
|
def FBOnLogin(curPlayer):
|
FBLogic.OnFBPlayerOnLogin(curPlayer)
|
Sync_FBPlayerFBInfoData(curPlayer)
|
return
|
|
#//A5 75 ¹ºÂò¸±±¾½øÈë´ÎÊý#tagCMBuyEnterCount
|
#
|
#struct tagCMBuyEnterCount
|
#{
|
# tagHead Head;
|
# DWORD FBID; // ¸±±¾ID
|
#};
|
def BuyFBEnterCount(playerIndex, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(playerIndex)
|
mapID = clientData.FBID
|
ipyData = GetFBIpyData(mapID)
|
if not ipyData:
|
return
|
canBuyCnt = ipyData.GetPayCntMax()
|
canBuyCnt += PlayerGoldInvest.GetAddFBBuyCnt(curPlayer, mapID)
|
hasBuyCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FBBuyCnt % mapID)
|
GameWorld.DebugLog("¹ºÂò¸±±¾½øÈë´ÎÊý: mapID=%s,canBuyCnt=%s,hasBuyCnt=%s" % (mapID, canBuyCnt, hasBuyCnt))
|
if hasBuyCnt >= canBuyCnt:
|
GameWorld.DebugLog("¸±±¾¹ºÂò´ÎÊýÒѾÓÃÍê! mapID=%s,hasBuyCnt=%s >= canBuyCnt=%s" % (mapID, hasBuyCnt, canBuyCnt))
|
return
|
costType = ipyData.GetPayMoneyType()
|
payMoneyList = ipyData.GetPayMoneyValues()
|
if not costType or not payMoneyList:
|
GameWorld.DebugLog("ûÓÐÅäÖùºÂò¸±±¾´ÎÊýÏûºÄ»õ±ÒÊý! mapID=%s,costType=%s,payMoneyList=%s" % (mapID, costType, payMoneyList))
|
return
|
costMoney = payMoneyList[hasBuyCnt] if len(payMoneyList) > hasBuyCnt else payMoneyList[-1]
|
if not PlayerControl.PayMoney(curPlayer, costType, costMoney, ChConfig.Def_Cost_BuyFBCnt, {"MapID":mapID}):
|
return
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FBBuyCnt % mapID, hasBuyCnt + 1)
|
Sync_FBPlayerFBInfoData(curPlayer, mapID)
|
return
|
|
def AddFBADCnt(curPlayer, mapID):
|
fbIpyData = GetFBIpyData(mapID)
|
if not fbIpyData:
|
return
|
adCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FBADCnt % mapID)
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FBADCnt % mapID, adCnt + 1)
|
Sync_FBPlayerFBInfoData(curPlayer, mapID)
|
return
|
|
## »ñÈ¡¼Ç¼ֵµÄmapID
|
# @param mapID ËùÒª²éµÄmapID
|
# @return
|
# @remarks Ò»°ãÓÃÓÚ¼¸ÕŵØͼ¹«ÓÃÒ»·Ý´æ´¢¼Ç¼£¬Èç×é¶Ó¸±±¾½øÈë´ÎÊý£¬CDʱ¼äµÈÊý¾ÝÐè¹²Ïí
|
def GetRecordMapID(mapID):
|
# DataMapIDDict = IpyGameDataPY.GetConfigEx("DataMapIDDict")
|
# if not DataMapIDDict:
|
# mIDToDataMapIDDict = {} # ³¡¾°ID¶ÔÓ¦¹¦ÄܵØͼID
|
# dMapIDDict = {}
|
# ipyDataMgr = IpyGameDataPY.IPY_Data()
|
# for i in xrange(ipyDataMgr.GetFBLineCount()):
|
# ipyData = ipyDataMgr.GetFBLineByIndex(i)
|
# dMapID = ipyData.GetDataMapID()
|
# mID = ipyData.GetMapID()
|
# mIDList= dMapIDDict.get(dMapID, [])
|
# if mID not in mIDList:
|
# mIDList.append(mID)
|
# dMapIDDict[dMapID] = mIDList
|
#
|
# dMIDList= mIDToDataMapIDDict.get(mID, [])
|
# if dMapID not in dMIDList:
|
# dMIDList.append(dMapID)
|
# mIDToDataMapIDDict[mID] = dMIDList
|
#
|
# unMIDList = []
|
# for mID, dMIDList in mIDToDataMapIDDict.items():
|
# if len(dMIDList) > 1:
|
# unMIDList.append(mID)
|
# #GameWorld.DebugLog("----------- ͬ¸ö³¡¾°¶ÔÓ¦µ½¶à¸ö¹¦ÄܵØͼµÄ£¬ÊÓΪÎÞÒâÒåµÄµØͼ! mID=%s, to dMIDList=%s" % (mID, dMIDList))
|
# for dMapID, mIDList in dMapIDDict.items():
|
# for unMID in unMIDList:
|
# if unMID in mIDList:
|
# mIDList.remove(unMID)
|
# if len(mIDList) <= 1:
|
# dMapIDDict.pop(dMapID)
|
# DataMapIDDict = IpyGameDataPY.SetConfigEx("DataMapIDDict", dMapIDDict)
|
# #GameWorld.Log("¼ÓÔØDataMapIDDict=%s" % DataMapIDDict)
|
#
|
# for dataMapID, mapIDList in DataMapIDDict.items():
|
# if mapID in mapIDList:
|
# return dataMapID
|
return mapID
|
|
def GetGeneralTrainMapIDList():
|
## »ñȡͨÓÃÑø³É¸±±¾
|
GeneralTrainMapIDList = IpyGameDataPY.GetConfigEx("GeneralTrainMapIDList")
|
if not GeneralTrainMapIDList:
|
GeneralTrainMapIDList = []
|
ipyDataMgr = IpyGameDataPY.IPY_Data()
|
for i in xrange(ipyDataMgr.GetFBGeneralTrainCount()):
|
ipyData = ipyDataMgr.GetFBGeneralTrainByIndex(i)
|
dMapID = ipyData.GetDataMapID()
|
if dMapID not in GeneralTrainMapIDList:
|
GeneralTrainMapIDList.append(dMapID)
|
GeneralTrainMapIDList = IpyGameDataPY.SetConfigEx("GeneralTrainMapIDList", GeneralTrainMapIDList)
|
#GameWorld.Log("¼ÓÔØGeneralTrainMapIDList=%s" % GeneralTrainMapIDList)
|
|
return GeneralTrainMapIDList
|
|
def Sync_FBPlayerFBInfoData(curPlayer, mapIDInfo=None):
|
## ֪ͨ¸öÈËͨÓø±±¾ÐÅÏ¢
|
if not mapIDInfo:
|
ipyDataMgr = IpyGameDataPY.IPY_Data()
|
mapIDList = [ipyDataMgr.GetFBFuncByIndex(i).GetDataMapID() for i in xrange(ipyDataMgr.GetFBFuncCount())]
|
else:
|
if type(mapIDInfo) not in [int, list]:
|
return
|
mapIDList = [mapIDInfo] if type(mapIDInfo) == int else mapIDInfo
|
|
clientPack = ObjPool.GetPoolMgr().acquire(ChPyNetSendPack.tagSCFBInfoList)
|
clientPack.FBDataList = []
|
|
for mapID in mapIDList:
|
fbInfo = ObjPool.GetPoolMgr().acquire(ChPyNetSendPack.tagSCFBInfo)
|
fbInfo.MapID = mapID
|
fbInfo.EnterCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FbEnterCnt % mapID)
|
fbInfo.ADAddCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FBADCnt % mapID)
|
fbInfo.BuyAddCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FBBuyCnt % mapID)
|
fbInfo.ItemAddCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FBItemCnt % mapID)
|
fbInfo.PassLineID = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FBPassLineID % mapID)
|
for keyNum in range(ChConfig.Def_FBStar_MaxKeyCnt):
|
gradeValue = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FBStar % (mapID, keyNum))
|
fbInfo.PassGrade.append(gradeValue)
|
fbInfo.PassGradeCnt = len(fbInfo.PassGrade)
|
clientPack.FBDataList.append(fbInfo)
|
|
clientPack.FBDataCnt = len(clientPack.FBDataList)
|
NetPackCommon.SendFakePack(curPlayer, clientPack)
|
return
|
|
## ¸ù¾ÝÈËÊý·Ö×é
|
# @param playerCnt: Íæ¼ÒÊý
|
# @param groupCnt: ·Ö³É¼¸×é
|
# @return: [[×é1Ë÷ÒýÁбí],[×é2Ë÷ÒýÁбí],[×é3Ë÷ÒýÁбí],...]
|
# @remarks: °´ÕÕͷβÏÈ×éºÏ£¬ÔÙ½øÐÐËæ»ú×éºÏµÄ·½Ê½£¬¶àÓàÈËÊýËæ»ú·Ö×é
|
##È磺10ÈË·Ö3×é, ÏÈ0,5Ò»×飻1,4Ò»×飻2,3Ò»×飻ÔÙÓë6,11Ò»×é;7,10Ò»×é; 8,9Ò»×飻Ëæ»ú×éºÏ
|
##10,11Ϊ²»´æÔÚµÄÈËÊýË÷Òý£¬²»»á¼ÓÈë·Ö×飬¹Ê×îÖÕ·ÖΪÁ½×é3¸ö£¬Ò»×é4¸ö£»
|
##Ë÷ÒýÅÅÐòÒ»°ãΪս¶·Á¦ÅÅÐò
|
def GetGroupList(playerCnt, groupCnt):
|
groupList = []
|
for i in xrange(groupCnt):
|
groupList.append([])
|
|
setp = groupCnt * 2
|
for i in xrange(0, playerCnt, setp):
|
|
tmpList = []
|
for g in xrange(groupCnt):
|
tmpGroup = []
|
aIndex = i + g
|
if aIndex < playerCnt:
|
tmpGroup.append(aIndex)
|
bIndex = i + setp - (g + 1)
|
if bIndex < playerCnt:
|
tmpGroup.append(bIndex)
|
|
tmpList.append(tmpGroup)
|
|
random.shuffle(tmpList)
|
for gi, group in enumerate(groupList):
|
group.extend(tmpList[gi])
|
|
return groupList
|
|
def GetCrossDynamicLineMapZoneID():
|
## »ñÈ¡¿ç·þ¶¯Ì¬Ïß·µØͼ±¾Ïß·¿ç·þ·ÖÇø
|
return GameWorld.GetGameWorld().GetPropertyID() / 100000
|
|
def GetCrossDynamicLineMapFuncLineID():
|
## »ñÈ¡¿ç·þ¶¯Ì¬Ïß·µØͼ±¾Ïß·¹¦ÄÜÏß·ID
|
return GameWorld.GetGameWorld().GetPropertyID() % 100000 / 100
|
|
