#!/usr/bin/python
|
# -*- coding: GBK -*-
|
#-------------------------------------------------------------------------------
|
#
|
#-------------------------------------------------------------------------------
|
##@package PlayerControl
|
# @todo: Íæ¼Ò¿ØÖÆÆ÷
|
#
|
# @author Alee
|
# @date 2010-02-20 16:30
|
# @version 1.0
|
#
|
#---------------------------------------------------------------------
|
#"""Version = 2017-07-17 15:00"""
|
#---------------------------------------------------------------------
|
import GameWorld
|
import ChEquip
|
import SkillShell
|
import ChConfig
|
import EffGetSet
|
import PlayerHorse
|
import PlayerTeam
|
import SkillCommon
|
import MirrorAttack
|
import GameMap
|
import FBLogic
|
import GameWorldProcess
|
import NPCCommon
|
import ItemCommon
|
import ReadChConfig
|
import BuffSkill
|
import PetControl
|
import OperControlManager
|
import PlayerFamily
|
import ShareDefine
|
import PlayerViewCache
|
import PlayerBillboard
|
import GameServerRefresh
|
import IPY_GameWorld
|
import PlayerGameWallow
|
import ChPyNetSendPack
|
import NetPackCommon
|
import DataRecordPack
|
import CalcNoLineEffect
|
import CalcLineEffect
|
import PlayerEquipDecompose
|
import FormulaControl
|
import PlayerDienstgrad
|
import PlayerPrestigeSys
|
import OpenServerCampaign
|
import PlayerGodWeapon
|
import PlayerExpandPackCfgMgr
|
import PlayerActivity
|
import FBCommon
|
import PassiveBuffEffMng
|
import EventReport
|
import PlayerGatherSoul
|
import PlayerGatherTheSoul
|
import PlayerSuccess
|
import PlayerPet
|
import ItemControler
|
import GameFuncComm
|
import IpyGameDataPY
|
import PlayerRune
|
import PyGameData
|
import PlayerMagicWeapon
|
import PlayerFeastTravel
|
import PlayerActTurntable
|
import GameLogic_SealDemon
|
import GameLogic_ZhuXianBoss
|
import GameLogic_CrossDemonKing
|
import PlayerVip
|
import PlayerRefineStove
|
import PlayerFamilyTech
|
import PlayerFamilyZhenfa
|
import PlayerCostRebate
|
import PlayerActLunhuidian
|
import PlayerActGarbageSorting
|
import GY_Query_CrossRealmReg
|
import PlayerTongTianLing
|
import FunctionNPCCommon
|
import PlayerGoldInvest
|
import IPY_PlayerDefine
|
import CrossRealmPlayer
|
import CrossPlayerData
|
import NPCHurtManager
|
import ChNetSendPack
|
import PlayerLianTi
|
import PlayerCoat
|
import PlayerAssist
|
import PlayerState
|
import PlayerDogz
|
import PlayerFaQi
|
import PlayerLove
|
import PlayerGubao
|
import PlayerShentong
|
import PlayerOnline
|
import PlayerCharm
|
import PlayerTask
|
import PlayerFace
|
import PlayerMail
|
import ChPlayer
|
import GameObj
|
|
import random
|
import types
|
import math
|
import time
|
import json
|
#---------------------------------------------------------------------
|
#ÐÅÏ¢ÌáʾÁбí
|
NotifyCodeList = IPY_GameWorld.IPY_NotifyCodeList()
|
|
#buff×Ö¶ÎDieContinueλ±íʾ±êʶ
|
Def_Buff_Clear_Die = 0x1 # ËÀÍöÇå³ýbuff
|
Def_Buff_Clear_Disconnect = 0x2 # ÏÂÏßÇå³ýbuff
|
|
#---------------------------------------------------------------------
|
##¿Í»§¶Ë·¢ËÍÒƶ¯·â°ü¼ì²é
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param clientWorldTick ÉÏ´ÎÒƶ¯Ê±¼ä´Á
|
# @return ·µ»ØÖµÕæ, ¿ÉÒÔÒƶ¯
|
# @remarks ¿Í»§¶Ë·¢ËÍÒƶ¯·â°ü¼ì²é
|
def PlayerMoveCheckClientWorldTick(curPlayer, clientWorldTick, sendPack_PosX, sendPack_PosY):
|
gameWorldTick = GameWorld.GetGameWorld().GetTick()
|
Def_Max_Move_Tick = 5000
|
|
if abs(gameWorldTick - clientWorldTick) >= Def_Max_Move_Tick:
|
curPlayer.Sync_ClientTick()
|
#ʱ¼äÏà²î¹ý´ó£¬¿ÉÄÜÒòÍøÂçÒýÆð£¬À»Ø
|
GameWorld.DebugLog("PlayerMoveCheckClientWorldTick -- ·þÎñÆ÷tick %s-¿Í»§¶Ë%sʱ¼äÏà²î¹ý´ó£¬¿ÉÄÜÒòÍøÂçÒýÆð£¬À»Ø" % (
|
gameWorldTick, clientWorldTick), curPlayer.GetID())
|
return False
|
|
if gameWorldTick - curPlayer.GetDictByKey("CheckTick") > 60000:
|
# 1·ÖÖÓ¾ÀÕýÒ»´Îtick,ͬʱÓÃÓÚÕ½¶·ºÍÒƶ¯µÄ¼ì²é
|
curPlayer.SetMoveCount(0)
|
curPlayer.SetDict("CheckTick", gameWorldTick)
|
|
lastMoveTick = curPlayer.GetClientMoveTick()
|
if clientWorldTick < lastMoveTick:
|
#and GameWorld.GetGameWorld().GetTick() - curPlayer.GetLoginTick() > 15000:
|
#Íæ¼ÒµÇÈëʱ¼ä´óÓÚ15Ãë, ²Å»áÌß³öÍæ¼Ò
|
#2009.4.16. bug:
|
#Íæ¼ÒÇл»µØͼ, ·þÎñÆ÷»º´æ×ß··â°ü, µ½´ïеØͼ, »º´æÖеķâ°üÊÕµ½, ½á¹ûÌß³öÁËÍæ¼Ò
|
GameWorld.DebugLog('---clientWorldTick < lastMoveTick: %s, TickÌ«Âý' % curPlayer.GetAccID())
|
#curPlayer.Kick(IPY_GameWorld.disTickError)
|
errCnt = curPlayer.GetMoveCount()
|
curPlayer.SetMoveCount(errCnt + 1)
|
if errCnt > 5:
|
return False
|
|
# ÑéÖ¤Á½´Îtick¼ä¿ÉÄܲúÉúµÄ×ø±ê²î
|
dist = GameWorld.GetDist(curPlayer.GetPosX(), curPlayer.GetPosY(), sendPack_PosX, sendPack_PosY)
|
canMoveDist = math.ceil((clientWorldTick - lastMoveTick) / float(curPlayer.GetSpeed())) + 2
|
#if clientWorldTick - curPlayer.GetPlayerAttackTick() < GetAtkInterval(curPlayer):
|
# # ¹¥»÷²úÉúµÄλÒÆ¿ÉÄÜÒòΪ¹¥»÷Ëٶȸıä¶ø±ä¿ì£¬¹¥»÷ÆÚ¼äµÄÒƶ¯°üÔÊÐí¶àÒƶ¯1Ã×µÄËÙ¶È
|
# canMoveDist += 2
|
|
if dist > canMoveDist:
|
GameWorld.DebugLog("¾àÀë²î%s ×ø±êS/C:%s---ÑéÖ¤Á½´Îtick¼ä¿ÉÄܲúÉúµÄ×ø±ê²î%s %s - %s" % (dist, [curPlayer.GetPosX(),
|
curPlayer.GetPosY(), sendPack_PosX, sendPack_PosY], canMoveDist, clientWorldTick, lastMoveTick))
|
errCnt = curPlayer.GetMoveCount()
|
curPlayer.SetMoveCount(errCnt + 1)
|
if errCnt > 5:
|
return False
|
|
#ʱ¼ä²î
|
# curPlayer.UpdatePosByTick(gameWorldTick - clientWorldTick + gameWorldTick)
|
#curPlayer.UpdatePos()
|
return True
|
|
|
# notifyCnt ´ú±í¹ã²¥ÖÜΧÍæ¼ÒµÄÊýÁ¿£¬0Ϊȫ²¿¹ã²¥ -1Ϊָ¶¨ÁбíËæ»ú£¬ ÆäËûÊý×ÖΪָ¶¨Ö¸
|
def PyNotifyAll(curPlayer, sendPack, notifySelf=True, notifyCnt=0):
|
if notifyCnt == -1:
|
notifyCnt = 8
|
#GameWorld.DebugLog("PyNotifyAll %s"%notifyCnt)
|
|
curPlayer.NotifyAll(sendPack.GetBuffer(), sendPack.GetLength(), notifySelf, notifyCnt)
|
|
|
#---------------------------------------------------------------------
|
##Ö´ÐÐÍæ¼ÒÔÚÕÏ°µãÂß¼
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return ²¼¶ûÖµ, FlaseΪÍæ¼Ò²»ÔÚÕÏ°µãÖÐ
|
# @remarks Ö´ÐÐÍæ¼ÒÔÚÕÏ°µãÂß¼
|
def DoLogic_PlayerInBarrierPoint(curPlayer):
|
curPlayerPosX = curPlayer.GetPosX()
|
curPlayerPosY = curPlayer.GetPosY()
|
curPlayerID = curPlayer.GetID()
|
|
#---Íæ¼Ò²»ÔÚÕÏ°µãÖÐ---
|
if GameWorld.GetMap().CanMove(curPlayerPosX, curPlayerPosY):
|
return False
|
|
#---Íæ¼ÒÔÚÕÏ°µãÖÐ---
|
|
#ÔÚÕÏ°µã¸½¼þ2¸ñÑ°ÕÒºÏÊÊλÖÃ
|
curFindPos = GameMap.GetEmptyPlaceInArea(curPlayerPosX, curPlayerPosY, 3)
|
curFindPosX = curFindPos.GetPosX()
|
curFindPosY = curFindPos.GetPosY()
|
|
#Íæ¼ÒÎÞ·¿É×ß
|
if curFindPosX == curPlayerPosX and curFindPosY == curPlayerPosY:
|
curPlayer.StopMove()
|
#===============================================================================
|
# playerControl = PlayerControl(curPlayer)
|
# playerControl.SetToBornPlace()
|
#===============================================================================
|
GameWorld.Log("Íæ¼ÒÎÞ·¿É×ß, ´ò»ØÖØÉúµã!(%d,%d)" % (curPlayerPosX, curPlayerPosY), curPlayerID)
|
#ÕÏ°µãÖܱ߿ÉÒÔÒƶ¯, ½«Íæ¼ÒÖÃλ
|
else:
|
curPlayer.ResetPos(curFindPosX, curFindPosY)
|
curPlayer.StopMove()
|
GameWorld.Log("Íæ¼ÒÕ¾ÔÚÕÏ°µãÖÐ, Í£Ö¹Òƶ¯ (%d,%d)" % (curPlayerPosX, curPlayerPosY), curPlayerID)
|
|
return True
|
#---------------------------------------------------------------------
|
## ÏûÏ¢Ìáʾ
|
# @param curPlayer ÌáʾµÄÍæ¼Ò
|
# @param msgMark ÌáʾÐÅÏ¢Mark
|
# @param msgParamList ÐÅÏ¢²ÎÊýÁбí
|
# @return ÎÞ·µ»ØÖµ
|
# @remarks
|
def NotifyCode(curPlayer, msgMark, msgParamList=[]):
|
if curPlayer == None:
|
GameWorld.ErrLog('NotifyCode Player = None')
|
return
|
|
curPlayer.NotifyCode(msgMark, __GetNotifyCodeList(msgParamList))
|
return
|
|
## ÊÀ½ç¹ã²¥
|
# @param country ÌáʾµÄ¹ú¼Ò
|
# @param msgMark ÌáʾÐÅÏ¢Mark
|
# @param msgParamList ÐÅÏ¢²ÎÊýÁбí
|
# @param lineID:Ïß·ID£¨Ä¬ÈÏ0£¬±íʾȫ·þ¹ã²¥£©
|
# @param mergeMinOSD ¸ÃÌáʾÕë¶Ô¿ç·þ×Ó·þÓÐЧµÄ×îС¿ª·þÌì, >=0ʱÓÐÏÞÖÆ
|
# @param mergeMaxOSD ¸ÃÌáʾÕë¶Ô¿ç·þ×Ó·þÓÐЧµÄ×î´ó¿ª·þÌì, >=0ʱÓÐÏÞÖÆ
|
# @param mergeMapInfo ¸ÃÌáʾËùÊôµÄ¿ç·þ»î¶¯µØͼÐÅÏ¢, Ö÷ÒªÓÃÓÚ²»Í¬×Ó·þ¶ÔÓ¦Ëù¿çµÄ»î¶¯µØͼID
|
# @return ÎÞ·µ»ØÖµ
|
def WorldNotify(country, msgMark, msgParamList=[], lineID=0, mergeMinOSD=-1, mergeMaxOSD=-1, mergeMapInfo=[]):
|
#GameWorld.GetPlayerManager().BroadcastCountry_NotifyCode(country, 0, msgMark, __GetNotifyCodeList(msgParamList), lineID)
|
playerManager = GameWorld.GetPlayerManager()
|
for i in xrange(playerManager.OnlineCount()):
|
curPlayer = playerManager.OnlineAt(i)
|
if not GameWorld.IsNormalPlayer(curPlayer):
|
continue
|
NotifyCode(curPlayer, msgMark, msgParamList)
|
return
|
|
def GetCrossWorldNotifyInfo(country, msgMark, msgParamList=[]):
|
return {"Type":ShareDefine.CrossNotify_World, "Params":[country, msgMark, msgParamList]}
|
|
def GetCrossFamilyNotifyInfo(familyID, msgMark, msgParamList=[]):
|
return {"Type":ShareDefine.CrossNotify_Family, "Params":[familyID, msgMark, msgParamList]}
|
|
def CrossNotify(serverGroupIDList, crossNotifyList):
|
''' ¿ç·þ¹ã²¥ÐÅÏ¢Ìáʾ£¬Ö§³Öͬ²½¶àÌõ£¬Í¬Ê±Ò²½¨Òé¶àÌõÒ»Æðͬ²½
|
@param serverGroupIDList: ÐèҪͬ²½µ½µÄÄ¿±ê·þÎñÆ÷×éIDÁбí
|
@param crossNotifyList: ÐÅÏ¢ÌáʾÁÐ±í£¬Í¨¹ý GetCrossWorldNotifyInfo GetCrossFamilyNotifyInfo º¯Êý»ñµÃ·µ»ØÖµÌí¼Óµ½Áбí
|
'''
|
sendMsg = str([serverGroupIDList, crossNotifyList])
|
GameWorld.GetPlayerManager().GameServer_QueryPlayerResult(0, 0, 0, "CrossNotify", sendMsg, len(sendMsg))
|
return
|
|
#---------------------------------------------------------------------
|
## ¼Ò×å¹ã²¥
|
# @param familyID ÌáʾµÄ¼Ò×åID
|
# @param msgMark ÌáʾÐÅÏ¢Mark
|
# @param msgParamList ÐÅÏ¢²ÎÊýÁбí
|
# @return ÎÞ·µ»ØÖµ
|
# @remarks
|
def FamilyNotify(familyID, msgMark, msgParamList=[]):
|
#GameWorld.GetPlayerManager().BroadcastCountry_NotifyCode(0, familyID, msgMark, __GetNotifyCodeList(msgParamList))
|
PlayerFamily.NotifyAllFamilyMemberMsg(familyID, msgMark, msgParamList)
|
return
|
|
#---------------------------------------------------------------------
|
##±¾µØͼÄÚµÄ֪ͨ
|
# @param msgMark ÌáʾÐÅÏ¢Mark
|
# @param msgParamList ÐÅÏ¢²ÎÊýÁбí
|
# @return ÎÞ·µ»ØÖµ
|
# @remarks
|
def FBNotify(msgMark, msgParamList=[]):
|
GameWorld.GetMapCopyPlayerManager().BroadcastFB_NotifyCode(msgMark, __GetNotifyCodeList(msgParamList))
|
return
|
|
def FBFactionNotifySelf(faction, msgMark, msgParamList=[]):
|
## ¸±±¾×Ô¼ºÕóÓª¹ã²¥
|
copyMapPlayerManager = GameWorld.GetMapCopyPlayerManager()
|
for i in xrange(copyMapPlayerManager.GetPlayerCount()):
|
curPlayer = copyMapPlayerManager.GetPlayerByIndex(i)
|
if curPlayer == None or curPlayer.IsEmpty():
|
continue
|
if curPlayer.GetFaction() == faction:
|
NotifyCode(curPlayer, msgMark, msgParamList)
|
return
|
|
def FBFactionNotifyOther(faction, msgMark, msgParamList=[]):
|
## ¸±±¾ÆäËûÕóÓª¹ã²¥
|
copyMapPlayerManager = GameWorld.GetMapCopyPlayerManager()
|
for i in xrange(copyMapPlayerManager.GetPlayerCount()):
|
curPlayer = copyMapPlayerManager.GetPlayerByIndex(i)
|
if curPlayer == None or curPlayer.IsEmpty():
|
continue
|
if curPlayer.GetFaction() != faction:
|
NotifyCode(curPlayer, msgMark, msgParamList)
|
return
|
|
def FBFactionNotify(faction, selfMsgMark, selfMsgParamList, otherMsgMark, otherMsgParamList):
|
## ¸±±¾¹ã²¥×Ô¼º¼°ÆäËûÕóÓª£¬Çø·Ö¹ã²¥ÐÅÏ¢
|
copyMapPlayerManager = GameWorld.GetMapCopyPlayerManager()
|
for i in xrange(copyMapPlayerManager.GetPlayerCount()):
|
curPlayer = copyMapPlayerManager.GetPlayerByIndex(i)
|
if curPlayer == None or curPlayer.IsEmpty():
|
continue
|
if curPlayer.GetFaction() == faction:
|
NotifyCode(curPlayer, selfMsgMark, selfMsgParamList)
|
else:
|
NotifyCode(curPlayer, otherMsgMark, otherMsgParamList)
|
return
|
|
## ¶ÓÎé¹ã²¥
|
# @param teamID ¶ÓÎéID
|
# @param msgMark ÌáʾÐÅÏ¢Mark
|
# @param msgParamList ÐÅÏ¢²ÎÊýÁбí
|
# @return ÎÞ·µ»ØÖµ
|
def TeamNotify(teamID, msgMark, msgParamList=[]):
|
if teamID == 0:
|
return
|
|
sendMsg = '("%s", %s)' % (msgMark, msgParamList)
|
GameWorld.GetPlayerManager().GameServer_QueryPlayerResult(0, 0, teamID, 'TeamNotify', sendMsg, len(sendMsg))
|
return
|
|
#---------------------------------------------------------------------
|
def SendMailBatch(mailTypeKey, batchPlayerIDList, batchAddItemList=[], batchParamList=[], batchGold=[], batchGoldPaper=[], batchSilver=[], batchDetail=[], moneySource=ChConfig.Def_GiveMoney_Mail, crossMail=False):
|
## ɾ³ý¾É°æ·¢ËÍÓʼþ£¬Èç¹û¹¦ÄÜ»¹ÓÐÐèÒª£¬¿ÉʹÓÃа汾·¢ËÍÓʼþ PlayerMail
|
## ÅúÁ¿·¢ËÍÓʼþµÄÒ»°ãÊǻÀàÐ͹¦ÄÜ£¬Ò»°ã¶¼ÐèÒªÓõ½GameServer
|
## ËùÒÔÔÝʱ²»¼æÈÝʹÓÃа汾·¢ËÍÓʼþ£¬µÈÏàÓ¦¹¦ÄÜÓÐÐèҪʱÔÙͬ²½ÐÞ¸Ä
|
return
|
|
def SendMailByKey(mailTypeKey, playerIDList, addItemList, paramList=[], gold=0, goldPaper=0, silver=0, detail="", moneySource=ChConfig.Def_GiveMoney_Mail, crossMail=False):
|
## º¯ÊýÏȱ£Áô£¬Ö®ºó¹¦ÄÜÖ±½ÓʹÓà PlayerMail.SendMailByKey
|
for playerID in playerIDList:
|
PlayerMail.SendMailByKey(mailTypeKey, playerID, addItemList, paramList)
|
return
|
|
## ¹¹½¨ÏµÍ³Ìáʾ²ÎÊýÁбí
|
# @param msgParamList ÐÅÏ¢²ÎÊýÁбí
|
# @return ϵͳÌáʾ²ÎÊýÁбí IPY_NotifyCodeList
|
# @remarks
|
def __GetNotifyCodeList(msgParamList):
|
#ÏûÏ¢ÌáʾÁбí, ÏÈÇåÔÚÌí¼Ó
|
global NotifyCodeList
|
NotifyCodeList.Clear()
|
|
if not msgParamList:
|
return NotifyCodeList
|
|
for msg in msgParamList:
|
itemPythonType = type(msg)
|
|
if itemPythonType is types.IntType:
|
#PythonÒªÑéÖ¤ÕûÐͺͳ¤ÕûÐÍ
|
NotifyCodeList.AddInt(msg)
|
elif itemPythonType is types.LongType:
|
NotifyCodeList.AddStr(str(msg))
|
else:
|
NotifyCodeList.AddStr(msg)
|
|
return NotifyCodeList
|
#---------------------------------------------------------------------
|
##»ñµÃÍæ¼Òµ±Ç°ÀۼƵÄÀëÏß·ÖÖÓÊý
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return ÀۼƵķÖÖÓÊý
|
# @remarks ¿Í»§¶Ë·â°üÏìÓ¦
|
def GetPlayerLeaveServerMinute(curPlayer):
|
#µ±Ç°ÀëÏßʱ¼ä×Ö·û´«
|
logoffTimeStr = curPlayer.GetLogoffTime()
|
|
if logoffTimeStr == "" or logoffTimeStr == '0':
|
return 0
|
|
logoffTime = GameWorld.GetDateTimeByStr(logoffTimeStr)
|
loginTime = GameWorld.GetDateTimeByStr(GameWorld.GetCurrentDataTimeStr())
|
|
return GameWorld.GetDiff_Minute(loginTime, logoffTime)
|
|
##»ñµÃÍæ¼Òµ±Ç°ÀۼƵÄÀëÏßÃëÊý
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return ÀۼƵÄÃëÊý
|
# @remarks ¿Í»§¶Ë·â°üÏìÓ¦
|
def GetPlayerLeaveServerSecond(curPlayer):
|
#µ±Ç°ÀëÏßʱ¼ä×Ö·û´«
|
logoffTimeStr = curPlayer.GetLogoffTime()
|
|
if logoffTimeStr == "" or logoffTimeStr == '0':
|
return 0
|
|
logoffTime = GameWorld.GetDateTimeByStr(logoffTimeStr)
|
loginTime = GameWorld.GetDateTimeByStr(GameWorld.GetCurrentDataTimeStr())
|
|
diff_Time = loginTime - logoffTime
|
#ÌìÊý * 24Сʱ * 60 ·ÖÖÓ + Ãë
|
return diff_Time.days * 24 * 60 * 60 + diff_Time.seconds
|
|
|
##»ñµÃÍæ¼Òµ±Ç°Ê±¼ä¾àÀëÉÏ´ÎÀëÏßʱ¼äµÄÌìÊý
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return
|
def GetPlayerLastLeaveServerPastDay(curPlayer):
|
#µ±Ç°ÀëÏßʱ¼ä×Ö·û´«
|
logoffTimeStr = curPlayer.GetLogoffTime()
|
|
if logoffTimeStr == "" or logoffTimeStr == '0':
|
return 0
|
|
logoffTimeStr = logoffTimeStr.split()[0]
|
loginTimeStr = GameWorld.GetCurrentDataTimeStr().split()[0]
|
|
logoffTime = GameWorld.GetDateTimeByStr(logoffTimeStr, ChConfig.TYPE_Time_Format_Day)
|
loginTime = GameWorld.GetDateTimeByStr(loginTimeStr, ChConfig.TYPE_Time_Format_Day)
|
|
diffTime = loginTime - logoffTime
|
|
return diffTime.days
|
|
#---------------------------------------------------------------------
|
## ¼ì²éÍæ¼Ò״̬ÊÇ·ñ¿ÉÒÔ´«ËÍ
|
# @param curPlayer µ±Ç°Íæ¼Ò
|
# @return ²¼¶ûÖµ
|
# @remarks ¼ì²éÍæ¼Ò״̬ÊÇ·ñ¿ÉÒÔ´«ËÍ
|
def CheckPlayerTransport(curPlayer):
|
#ËÀÍö²»¿ÉʹÓÃ
|
if GameObj.GetHP(curPlayer) <= 0:
|
return False
|
|
#¼ì²éÍæ¼Ò״̬
|
if not CheckTransState(curPlayer):
|
return False
|
|
#¼ì²éÍæ¼ÒÊÇ·ñÔÚÆÕͨµØͼ
|
if GameWorld.GetMap().GetMapFBType() != IPY_GameWorld.fbtNull:
|
#²¿·Ö¸±±¾ÔÊÐí´«ËͳöÈ¥
|
if GameWorld.GetMap().GetMapID() not in IpyGameDataPY.GetFuncEvalCfg('DungeonDeliver', 1):
|
NotifyCode(curPlayer, "Carry_lhs_844170")
|
return False
|
|
if not GameWorld.IsCrossServer() and GetCrossMapID(curPlayer):
|
NotifyCode(curPlayer, "CrossMap10")
|
return False
|
|
if curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_ClientCustomScene):
|
GameWorld.Log("¿Í»§¶Ë×Ô¶¨Ò峡¾°ÏÂÎÞ·¨´«ËÍ!", curPlayer.GetPlayerID())
|
return False
|
|
return True
|
|
|
##µØͼÌØÊâÏÞÖƼì²é, ×°±¸¼ì²é
|
# @param curPlayer
|
# @return bool
|
def CheckEquipCanTrans(curPlayer, destMapID):
|
if destMapID != 10060:
|
return True
|
|
#Óгá°ò¿ÉÒÔÉÏÌì¿Õ
|
playerEquip = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptEquip)
|
curEquip = playerEquip.GetAt(IPY_GameWorld.retWing)
|
if curEquip and not curEquip.IsEmpty():
|
return True
|
|
#GeRen_lhs_861048
|
NotifyCode(curPlayer, "GeRen_lhs_861048", [destMapID])
|
return False
|
|
#---------------------------------------------------------------------
|
##֪ͨ¿Í»§¶Ë, Íæ¼ÒLoading¿ªÊ¼
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param prepareTime Loadingʱ¼ä
|
# @param prepareType LoadingÀàÐÍ
|
# @param prepareID LoadingNPCID, ĬÈÏΪ0, ²»ÉèÖÃ
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks ֪ͨ¿Í»§¶Ë, Íæ¼ÒLoading¿ªÊ¼
|
# ÌØÊâ˵Ã÷ChangePlayerAction -> SetPlayerAction ÖÐ ÔÚÀÌõ״̬»á֪ͨ Sync_PrepareEnd£¬Ä¬ÈϽø¶ÈÌõÀàÐÍ
|
# Sync_PrepareEnd ֪ͨ0²ÅËã½ø¶ÈÌõ³É¹¦£¬ÆäËûΪʧ°Ü£¬×Ôµ÷ÓÃÂ߼ʱÇë×¢Òâ
|
def Sync_PrepareBegin(curPlayer, prepareTime, prepareType, prepareID=0):
|
#ÖжÏÕ½¶·¶ÔÖÅ
|
ExitPlayerConfronting(curPlayer)
|
#´ò¶ÏÒƶ¯
|
curPlayer.StopMove()
|
#ÉèÖü¤»îÍæ¼Ò
|
SetIsNeedProcess(curPlayer, True)
|
#¿ªÊ¼Í¨ÖªLoading
|
curPlayer.SetPrepareTime(prepareTime)
|
curPlayer.SetPrepareState(prepareType)
|
curPlayer.SetPrepareID(prepareID)
|
curPlayer.Sync_PrepareBegin()
|
|
#¿ÕÏÐת±äΪÆäËû״̬Ôòɾ³ýÓÐÏÞÎÞµÐBUFF
|
tick = GameWorld.GetGameWorld().GetTick()
|
DelLimitSuperBuff(curPlayer, tick)
|
return
|
|
#---------------------------------------------------------------------
|
##Íæ¼Ò״̬¸Ä±ä
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param changeAction Çл»µÄ״̬
|
# @param forceChange ÊÇ·ñÇ¿ÖÆת»»
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks Íæ¼Ò״̬¸Ä±ä
|
def ChangePlayerAction(curPlayer, changeAction, forceChange=False):
|
curPlayerAction = curPlayer.GetPlayerAction()
|
|
if curPlayerAction == changeAction:
|
return
|
|
#״̬±ä¸üҪ֪ͨվÁ¢
|
DoPlayerStand(curPlayer)
|
|
#ÖжÏÕ½¶·¶ÔÖÅ
|
if changeAction in ChConfig.Def_PlayerCancelConfronting:
|
ExitPlayerConfronting(curPlayer)
|
|
#ʼþ״̬²»Çл», ±ÜÃâ¶Ô»°¿¨×¡
|
if curPlayerAction == IPY_GameWorld.paEvent and not forceChange:
|
if changeAction in [IPY_GameWorld.paNull, IPY_GameWorld.paAttack]:
|
GameWorld.DebugLog("²»Ç¿ÖÆת»»×´Ì¬ %s" % changeAction, curPlayer.GetID())
|
return
|
|
# ²É¼¯Çл»
|
if curPlayerAction == IPY_GameWorld.paPreparing:
|
DoExitPreparing(curPlayer)
|
|
curPlayer.SetPlayerAction(changeAction)
|
|
if changeAction == IPY_GameWorld.paNull:
|
return
|
|
#¿ÕÏÐת±äΪÆäËû״̬Ôòɾ³ýÓÐÏÞÎÞµÐBUFF
|
tick = GameWorld.GetGameWorld().GetTick()
|
DelLimitSuperBuff(curPlayer, tick)
|
|
return
|
|
##Í˳ö²É¼¯
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return ·µ»ØÖµÎÞÒâÒå
|
def DoExitPreparing(curPlayer):
|
NPCCommon.ClearCollectNPC(curPlayer)
|
tagObj = curPlayer.GetActionObj()
|
|
if tagObj == None:
|
#ûÓÐÄ¿±ê
|
GameWorld.Log("DoExitPreparing -> ûÓÐÄ¿±ê", curPlayer.GetPlayerID())
|
return
|
|
if tagObj.GetGameObjType() != IPY_GameWorld.gotNPC:
|
#̸»°¶ÔÏ󲻶Ô
|
GameWorld.Log("DoExitPreparing -> ²É¼¯¶ÔÏ󲻶Ô", curPlayer.GetPlayerID())
|
return
|
|
curNPC = GameWorld.GetNPCManager().GetNPCByIndex(tagObj.GetIndex())
|
if curNPC == None:
|
#ûÓÐÕâ¸öNPC
|
GameWorld.Log("DoExitPreparing ->ûÓÐÕâ¸öNPC", curPlayer.GetPlayerID())
|
return
|
|
curNPC_HurtList = curNPC.GetPlayerHurtList()
|
curNPC_HurtList.Clear()
|
return
|
|
## Íæ¼Ò״̬¸Ä±ä(½Å±¾×Ô¶¨Òåö¾Ù)
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param changeAction Çл»µÄ״̬
|
# @return None
|
def ChangePyPlayerAction(curPlayer, changeAction):
|
if GetPyPlayerAction(curPlayer, changeAction):
|
#ÒѾÊÇÕâ¸ö״̬
|
return
|
|
state = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_PyPlayerAction)
|
state = state | pow(2, changeAction)
|
|
NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_PyPlayerAction, state)
|
return
|
|
|
## »ñÈ¡ÊÇ·ñÓиÃ״̬
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param changeAction Çл»µÄ״̬
|
# @return ÊÇ·ñÓиÃ״̬
|
def GetPyPlayerAction(curPlayer, action):
|
receiveState = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_PyPlayerAction)
|
|
state = receiveState & pow(2, action)
|
#GameWorld.DebugLog("receiveState = %s, state = %s" % (receiveState, state))
|
return state != 0
|
|
## Çå³ýpy×Ô¶¨Òå״̬
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return ·µ»ØÖµÎÞÒâÒå
|
def ClearPyPlayerAction(curPlayer):
|
#Çå³ýpy×Ô¶¨Òå״̬
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_PyPlayerAction, 0)
|
return
|
|
#---------------------------------------------------------------------
|
##ÉèÖÃÍæ¼ÒÊÇ·ñ¼¤»î
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param isNeedProcess ÊÇ·ñ¼¤»î
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks ÉèÖÃÍæ¼ÒÊÇ·ñ¼¤»î
|
def SetIsNeedProcess(curPlayer, isNeedProcess):
|
curPlayerIsNeedProcess = curPlayer.GetIsNeedProcess()
|
|
if curPlayerIsNeedProcess == isNeedProcess:
|
return
|
|
curPlayer.SetIsNeedProcess(isNeedProcess)
|
GameWorld.GodLog(curPlayer, 'ÉèÖÃÍæ¼ÒÊÇ·ñ¼¤»î:%s' % isNeedProcess)
|
return
|
|
#---------------------------------------------------------------------
|
##Íæ¼ÒÊÇ·ñÔÚÕ½¶·×´Ì¬.
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return ²¼¶ûÖµ
|
# @remarks Íæ¼ÒÊÇ·ñÔÚÕ½¶·×´Ì¬
|
def IsPlayerInFight(curPlayer):
|
# #Ö÷¶¯¶ÔÖÅÖÐ
|
# if curPlayer.GetIsConfronting():
|
# return True
|
|
# ¹¥»÷ÖÐ
|
if curPlayer.GetPlayerAction() == IPY_GameWorld.paAttack:
|
return True
|
|
# # ½øÈëÕ½¶·×´Ì¬
|
# if curPlayer.IsBattleState():
|
# return True
|
|
return False
|
#---------------------------------------------------------------------
|
##×Ô¶¯½øÈëÕ½¶·¶ÔÖÅ //ÕâÀï²»¼ÓÏêϸÑéÖ¤
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks ×Ô¶¯½øÈëÕ½¶·¶ÔÖÅ //ÕâÀï²»¼ÓÏêϸÑéÖ¤
|
def AutoEnterPlayerConfronting(curPlayer):
|
#
|
# if curPlayer.GetIsConfronting():
|
# return
|
#
|
# actObj = curPlayer.GetActionObj()
|
#
|
# if not actObj:
|
# return
|
#
|
# curPlayer.SetIsConfronting(True)
|
# #֪ͨ¿Í»§¶Ë //0½øÈë;ÆäËûÍ˳ö
|
# curPlayer.View_PlayerBattle(actObj.GetID(), actObj.GetGameObjType(), 0)
|
#
|
# #Ìí¼Ó²âÊÔÐÅÏ¢
|
# GameWorld.GodLog(curPlayer, 'Server×Ô¶¯½øÈëÕ½¶·¶ÔÖųɹ¦')
|
return
|
|
#---------------------------------------------------------------------
|
##//¶ÔÍâ½Ó¿Ú, Öж϶ÔÖÅ
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks //¶ÔÍâ½Ó¿Ú, Öж϶ÔÖÅ
|
def ExitPlayerConfronting(curPlayer):
|
# if not curPlayer.GetIsConfronting():
|
# return
|
#
|
# #Í˳ö¶ÔÖÅ
|
# curPlayer.SetIsConfronting(False)
|
# #֪ͨ¿Í»§¶Ë //0½øÈë;ÆäËûÍ˳ö
|
# curPlayer.View_PlayerBattle(0, 0, 1)
|
#
|
# #Çå³ýÕ½³è³ðºÞ
|
# PetControl.ClearFightPetAngry(curPlayer)
|
#
|
# #Ìí¼Ó²âÊÔÐÅÏ¢
|
# GameWorld.GodLog(curPlayer, 'Í˳öÕ½¶·¶ÔÖųɹ¦')
|
return
|
|
#---------------------------------------------------------------------
|
##²É¼¯´ò¶Ï
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks ²É¼¯´ò¶Ï
|
def BreakPlayerCollect(curPlayer):
|
# #²É¼¯¶¼²»´ò¶Ï
|
# return
|
|
if curPlayer.GetPlayerAction() != IPY_GameWorld.paPreparing:
|
return
|
#GameWorld.Log(' ²É¼¯´ò¶Ï curPlayer.GetPrepareState()=%s'%curPlayer.GetPrepareState())
|
if curPlayer.GetPrepareState() not in [IPY_GameWorld.pstMissionCollecting, ShareDefine.Def_PstProduce]:
|
#¼´²»ÊÇÈÎÎñ²É¼¯Ò²²»ÊÇÉú²ú²É¼¯
|
return
|
|
#¸±±¾Öв»´ò¶Ï
|
#if GameWorld.GetMap().GetMapFBType() != IPY_GameWorld.fbtNull:
|
# return
|
|
tagObj = curPlayer.GetActionObj()
|
|
if tagObj == None:
|
#ûÓÐÄ¿±ê
|
#GameWorld.Log("BreakPlayerCollect -> ûÓÐÄ¿±ê", curPlayer.GetPlayerID())
|
return
|
|
if tagObj.GetGameObjType() != IPY_GameWorld.gotNPC:
|
#²É¼¯¶ÔÏ󲻶Ô
|
#GameWorld.Log("BreakPlayerCollect -> ²É¼¯¶ÔÏ󲻶Ô", curPlayer.GetPlayerID())
|
return
|
|
curNPC = GameWorld.GetNPCManager().GetNPCByIndex(tagObj.GetIndex())
|
if curNPC == None:
|
#ûÓÐÕâ¸öNPC
|
#GameWorld.Log("BreakPlayerCollect ->ûÓÐÕâ¸öNPC", curPlayer.GetPlayerID())
|
return
|
|
npcID = curNPC.GetNPCID()
|
collectNPCIpyData = IpyGameDataPY.GetIpyGameDataNotLog("CollectNPC", npcID)
|
if not collectNPCIpyData:
|
return
|
|
if not collectNPCIpyData.GetCanBreakCollect():
|
return
|
|
#È¡Ïû²É¼¯×´Ì¬
|
ChangePlayerAction(curPlayer, IPY_GameWorld.paNull)
|
|
if curPlayer.GetActionObj() != None:
|
curPlayer.SetActionObj(None)
|
return
|
|
#---------------------------------------------------------------------
|
##Íæ¼Ò´ò×ø
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param tick ʱ¼ä´Á
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks Íæ¼Ò´ò×ø
|
def DoPlayerSit(curPlayer, tick):
|
#ÒѾÔÚ´ò×ø״̬ÁË
|
if curPlayer.GetPlayerAction() == IPY_GameWorld.paSit:
|
return
|
|
#ֹ֪ͨͣÒƶ¯
|
curPlayer.StopMove()
|
#¼¤»îÍæ¼Ò״̬, »Ø¸´CDÊÇ3Ãë, Íæ¼Ò´ôÖÍΪ5Ãë, Òª¼¤»îÒ»ÏÂ
|
SetIsNeedProcess(curPlayer, True)
|
#Íæ¼Ò×øÏÂ
|
curPlayer.Sit()
|
|
#ÉèÖÃÕæÆø¿ªÊ¼»Ö¸´Ê±¼ä
|
#curPlayer.SetDict(ChConfig.Def_PlayerKey_SitForZhenQi, tick)
|
#ÉèÖøßЧÁ·¹¦¿ªÊ¼Ê±¼ä
|
#curPlayer.SetDict(ChConfig.Def_PlayerKey_EfficientSit, tick)
|
return
|
|
#---------------------------------------------------------------------
|
##Íæ¼ÒÕ¾Æð
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks Íæ¼ÒÕ¾Æð
|
def DoPlayerStand(curPlayer):
|
#²»ÔÚ´ò×ø״̬
|
if curPlayer.GetPlayerAction() != IPY_GameWorld.paSit:
|
return
|
|
curPlayer.Stand()
|
|
|
return
|
#---------------------------------------------------------------------
|
##Íæ¼Ò²¥·Å±íÇé
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks Íæ¼Ò²¥·Å±íÇé
|
def DoPlayerShowPlayerFace(curPlayer, faceType):
|
#Çå¿ÕÍæ¼Òµã»÷
|
curPlayer.SetActionObj(None)
|
#֪ͨÖжÏÕ½¶·¶ÔÖÅ
|
ExitPlayerConfronting(curPlayer)
|
#ֹ֪ͨͣÒƶ¯
|
curPlayer.StopMove()
|
#֪ͨ¿Í»§¶Ë²¥·Å±íÇé
|
curPlayer.View_ShowPlayerFace(faceType)
|
return
|
|
#---------------------------------------------------------------------
|
##Íæ¼ÒËÀÍö
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks Íæ¼ÒËÀÍö
|
def DoPlayerDead(curPlayer):
|
|
#ֹ֪ͨͣÒƶ¯
|
curPlayer.StopMove()
|
|
#Íæ¼ÒËÀÍö
|
curPlayer.SetDead(curPlayer.GetDictByKey(ChConfig.Def_NPCDead_KillerID),
|
curPlayer.GetDictByKey(ChConfig.Def_NPCDead_KillerType))
|
return
|
#---------------------------------------------------------------------
|
##Íæ¼ÒË¢ÐÂ×ø±ê
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param checkObj ¼ì²é¶ÔÏó
|
# @param posX Æðµã×ø±êX
|
# @param posY Æðµã×ø±êY
|
# @param canChangeClientPos ÊÇ·ñÖØÖõ½¿Í»§¶Ë×ø±êµã
|
# @return ·µ»ØÖµÕæ, ˢгɹ¦
|
# @remarks Íæ¼ÒË¢ÐÂ×ø±ê
|
def PlayerRefreshPos(curPlayer, checkObj, posX, posY, canChangeClientPos=True):
|
if not curPlayer.GetMapLoadOK():
|
#Ë¢ÐÂʧ°Ü
|
#×¢Òâ: Ò»¶¨ÒªÅжÏ, ÒòΪÔÚÍæ¼ÒʹÓü¼ÄܵÄʱºò»áË¢ÐÂÕâÀï
|
#Èç¹ûÍæ¼Ò¶ÁȡûÓгɹ¦, ¾Í²»´¦ÀíÕâ¸ö·â°ü
|
GameWorld.Log('µØͼûÓжÁÈ¡³É¹¦, Ë¢ÐÂʧ°Ü', curPlayer.GetPlayerID())
|
return False
|
|
if not curPlayer.GetSpeed():
|
GameWorld.Log("ûÓÐËٶȲ»ÄÜË¢ÐÂ×ø±ê!", curPlayer.GetPlayerID())
|
return False
|
|
curMap = GameWorld.GetMap()
|
|
#¼ì²éÍæ¼ÒͣϵÄ×ø±êÊÇ·ñÕýÈ·
|
needResetPos = False
|
|
if curMap.CanMove(posX, posY) != True:
|
#ÌßÍæ¼ÒÏÂÏß
|
#curPlayer.Kick(IPY_GameWorld.disPlayerPosError)
|
#°ÑÍæ¼Ò´ò»ØÖØÉúµã
|
# playerControl = PlayerControl(curPlayer)
|
# playerControl.SetToBornPlace()
|
#ÒÔÉÏ´¦ÀíÌ«¹ýÑϸñ, Ä¿Ç°²»Åж¨
|
#-----------------------------------------
|
#ÔÚÍæ¼ÒÖÜΧÕÒµ½Ò»¸ö¿É×ߵĵã, °ÑËû·Å¹ýÈ¥
|
resultPos = GameMap.GetEmptyPlaceInArea(posX, posY, ChConfig.Def_DropItemDist)
|
|
if resultPos.GetPosX() == posX and resultPos.GetPosY() == posY:
|
#Íæ¼ÒÖØÖÃλÖÃʧ°Ü
|
GameWorld.Log('Íæ¼ÒÖØÖÃλÖÃʧ°Ü, °ÑÍæ¼Ò´ò»ØÖØÉúµã posX = %s posY = %s' \
|
% (posX, posY), curPlayer.GetPlayerID())
|
#===============================================================================
|
# playerControl = PlayerControl(curPlayer)
|
# playerControl.SetToBornPlace()
|
#===============================================================================
|
#ÔÝʱÍêÈ«ÐÅÈοͻ§¶Ë×ø±ê£¬±ÜÃâ±ßÔµ»¯ÎÞ·¨¹¥»÷ÎÊÌâ
|
return False
|
|
GameWorld.Log("×ø±ê´íÎ󣬼ì²éÍæ¼ÒͣϵÄ×ø±êÊÇ·ñÕýÈ· posX = %d, posY = %d, ÖØÖÃλÖÃ:posX = %d, posY = %d" \
|
% (posX, posY, resultPos.GetPosX(), resultPos.GetPosY()), curPlayer.GetPlayerID())
|
|
posX = resultPos.GetPosX()
|
posY = resultPos.GetPosY()
|
|
#±ßÔµÕÏ°µãÈÿͻ§¶ËÐÐ×ߣ¬·þÎñ¶Ë¸Ä±äλÖò»Í¨Öª
|
#needResetPos = True
|
#checkObj.ResetPos(posX, posY)
|
|
#µ±Ç°¶ÔÏó×ø±ê
|
objPosX = checkObj.GetPosX()
|
objPosY = checkObj.GetPosY()
|
# objDestPosX = checkObj.GetDestPosX()
|
# objDestPosY = checkObj.GetDestPosY()
|
# objStartX = checkObj.GetStartPosX()
|
# objStartY = checkObj.GetStartPosY()
|
#¼ÆËãÍæ¼Ò·¢¹ýÀ´µÄֹͣλÖúͷþÎñÆ÷ÒÑÓÐ×ø±êµÄ¾àÀë
|
dist = GameWorld.GetDist(posX, posY, objPosX, objPosY)
|
|
#Òƶ¯µÄÌص㣺¿Í»§¶ËÒƶ¯Îª1Ã×С¼ä¸ô·¢°ü£¬·þÎñ¶ËµÄUpdatePos ¾³£ δִÐе¼ÖÂÎÞ·¨Òƶ¯£¬Òƶ¯ÐÐΪ±ä³É __FixPlayerPos-¡·ChangePos¿ØÖÆ
|
#Íâ²ãÒƶ¯tick ¿ØÖƼä¸ô·ÀÖ¹Íâ¹Ò°ü
|
if dist <= 3:
|
#µÚÒ»ÖÖÇé¿ö:¿Í»§¶ËºÍ·þÎñÆ÷¶Ë¾àÀë²î¾à·ûºÏÒªÇó
|
#λÖÿÉÒÔ½ÓÊÜ
|
__FixPlayerPos(checkObj, posX, posY, needResetPos, canChangeClientPos)
|
return True
|
else:
|
#¾àÀëÆ«²îÌ«´ó£¬À»ØλÖò»×öÌßÈËÂß¼
|
needResetPos = True
|
GameWorld.DebugLog('Client=(%s,%s), Server=(%s,%s), ²îÒì¾àÀë=%s' \
|
% (posX, posY, objPosX, objPosY, dist))
|
posX = objPosX
|
posY = objPosY
|
__FixPlayerPos(checkObj, posX, posY, needResetPos, canChangeClientPos)
|
return False
|
|
# ʵ¼Ê´Ëº¯ÊýÔÚ¶Ô»° ¹¥»÷ Òƶ¯¶¼»á×ß½øÀ´Åж¨
|
#===========================================================================
|
# curPlayer.SetMoveCount(curPlayer.GetMoveCount() + 1)
|
# if curPlayer.GetMoveCount() >= 10:
|
# curPlayer.SetMoveCount(0)
|
# curPlayer.SetMoveDistDiff(0)
|
# needResetPos = True
|
#
|
# if curPlayer.GetMoveDistDiff() >= 30:
|
# curPlayer.SetMoveCount(0)
|
# curPlayer.SetMoveDistDiff(0)
|
# needResetPos = True
|
#===========================================================================
|
__FixPlayerPos(checkObj, posX, posY, needResetPos, canChangeClientPos)
|
|
return True
|
#---------------------------------------------------------------------
|
##½ÃÕýÍæ¼Ò×ø±ê
|
# @param checkObj ¼ì²éµÄ¶ÔÏó
|
# @param changePosX ½ÃÕýµÄ×ø±êX
|
# @param changePosY ½ÃÕýµÄ×ø±êY
|
# @param needResetServerPos ÊÇ·ñ°´·þÎñÆ÷λÖÃÖØÖÃ
|
# @param needChangeClientPos ÊÇ·ñ°´¿Í»§¶ËλÖÃÖØÖÃ
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks ½ÃÕýÍæ¼Ò×ø±ê
|
def __FixPlayerPos(checkObj, changePosX, changePosY, needResetServerPos, needChangeClientPos):
|
#---°´·þÎñÆ÷λÖÃÖØÖÃ---
|
if needResetServerPos:
|
checkObj.ResetPos(changePosX, changePosY)
|
return
|
|
#---°´¿Í»§¶ËλÖÃÖØÖÃ---
|
if needChangeClientPos:
|
checkObj.ChangePos(changePosX, changePosY)
|
return
|
|
return
|
#---------------------------------------------------------------------
|
def OnDelayDeleteMirror(curPlayer, tick):
|
addTick = curPlayer.GetDictByKey("DelayDeleteMirror")
|
if not addTick:
|
return
|
if tick - addTick < 10000: # 10sºó»ØÊÕ
|
return
|
DeleteMirror(curPlayer, False)
|
return True
|
|
def DeleteMirror(curPlayer, isDelay=False):
|
''' »ØÊÕ¾µÏñÍæ¼Ò
|
'''
|
if not curPlayer.GetRealPlayerID():
|
return
|
playerID = curPlayer.GetPlayerID()
|
if isDelay:
|
#ÓÉÓÚϵͳ³¡´Î¿ìËÙÕ½¶·ÔÒò£¬Èç¹ûÁ¢Âí»ØÊÕ¿ÉÄܵ¼ÖÂij¸ö¹¦ÄܳöÏÖÎÊÌâ
|
#Èç±»¶¯¼¼ÄÜЧ¹û£¬Ö´ÐÐ˳ÐòµÄÔÒò£¬Èç»÷ɱºó -> ½áËã -> »ØÊÕÍæ¼Ò -> ´¥·¢±»¶¯¼¼ÄÜ£¬µ¼ÖÂÒì³£
|
GameWorld.DebugLog("¾µÏñÍæ¼ÒÉèÖÃÑÓ³Ù»ØÊÕ!", playerID)
|
SetPlayerSightLevel(curPlayer, playerID)
|
tick = GameWorld.GetGameWorld().GetTick()
|
curPlayer.SetDict("DelayDeleteMirror", tick)
|
return
|
GameWorld.DebugLog("¾µÏñÍæ¼Ò»ØÊÕ!", playerID)
|
PassiveBuffEffMng.OnPlayerLeaveMap(curPlayer)
|
#ɱËÀËùÓÐÕÙ»½µÄÁé
|
KillPlayerSummonNPC(curPlayer)
|
#ÕÙ»½»Ø³öÕ½µÄ³èÎï
|
PetControl.ReCallFightPet(curPlayer)
|
curPlayer.DeleteMirror()
|
return
|
|
##ɱËÀÍæ¼ÒËùÓеÄÕÙ»½ÊÞËÀÍö
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks ɱËÀÍæ¼ÒËùÓеÄÕÙ»½ÊÞËÀÍö
|
def KillPlayerSummonNPC(curPlayer):
|
#½«Éæ¼°µ½C++ÖÐÁбíɾ³ýµÄ¹¦ÄÜ,ͳһ¸Ä³É -> ¸´ÖÆPyÁбíºó,È»ºó½øÐÐɾ³ýÂß¼ (ÒòWhileÓм¸Âʽ«µ¼ÖÂËÀËø)
|
summon_List = []
|
for index in range(curPlayer.GetSummonCount()):
|
curSummonNPC = curPlayer.GetSummonNPCAt(index)
|
summon_List.append(curSummonNPC)
|
|
for summonNPC in summon_List:
|
NPCCommon.SetDeadEx(summonNPC)
|
return
|
#---------------------------------------------------------------------
|
##¼ì²éÍæ¼ÒͨÓõÄ״̬ת»»
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return ·µ»ØÖµÕæ, ÔÊÐíÇл»×´Ì¬
|
# @remarks ¼ì²éÍæ¼ÒͨÓõÄ״̬ת»»
|
def PlayerCanStateTransfer(curPlayer):
|
curPlayerAction = curPlayer.GetPlayerAction()
|
#Èç¹ûÍæ¼ÒÊÇ×øÏÂ״̬, ×Ô¶¯×ª»»ÎªÕ¾Á¢×´Ì¬
|
#DoPlayerStand(curPlayer)
|
|
return (curPlayerAction in ChConfig.Def_Player_Can_Transfer_State)
|
|
#------------------------------Íæ¼ÒÀ뿪·þÎñÆ÷µÄÂß¼------------------------------------
|
#---------------------------------------------------------------------
|
##ÆïÂíÏÂÏßÂß¼
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks ÆïÂíÏÂÏßÂß¼
|
def __RidingHorsePlayerDisconnect(curPlayer):
|
#ÔÚÆïÂí
|
if curPlayer.GetPlayerVehicle() == IPY_GameWorld.pvHorse:
|
#Ö´ÐÐÏÂÂíÂß¼
|
PlayerHorse.PlayerRideHorseDown(curPlayer, False)
|
|
return
|
#---------------------------------------------------------------------
|
##Íæ¼ÒÏÂÏß/Íæ¼ÒÇл»µØͼ¹«ÓÃÂß¼
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param tick ʱ¼ä´Á
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks Íæ¼ÒÏÂÏß/Íæ¼ÒÇл»µØͼ¹«ÓÃÂß¼
|
def __PlayerLeaveServerLogic(curPlayer, tick, isDisconnect):
|
#¸øÓèÍæ¼Ò²¹³¥
|
#PlayerExpiation.GivePlayerExpiation(curPlayer, tick)
|
|
#ˢм¼ÄÜÊ£Óàʱ¼ä
|
SkillCommon.RefreshAllSkillRemainTime(curPlayer, tick)
|
|
#¶ÓÎéÍæ¼ÒÍ˳öµØͼ
|
PlayerTeam.TeamPlayerLeaveMap(curPlayer, tick, isDisconnect)
|
|
#Í˳ö²É¼¯
|
NPCCommon.ClearCollectNPC(curPlayer)
|
|
#ÉèÖÃÍæ¼ÒµÄµØͼλÖÃ, Èç¹ûÊǸ±±¾, À뿪¸±±¾
|
# ¸±±¾¹æÔò:
|
# 1. Ò»¸ö¶ÓÎéÖ»ÓÐÒ»¸ö¸±±¾, Èç¹ûÓжÓÔ±µÄ¸±±¾ºÍ¶ÓÎ鸱±¾²»Ò»ÖÂ, Ôò´Ó¸±±¾ÖÐÌß³ö´Ë¶ÓÔ±
|
# 2. Íæ¼ÒÏÂÏßÔÙÉÏ, ¾ÍÀ뿪¸±±¾
|
# 3. Èç¹ûûÓÐÍæ¼Ò´æÔÚ, ¸±±¾»ØÊÕ
|
if GameWorld.GetMap().GetMapFBType() != 0:
|
#À뿪¸±±¾
|
fbIndex = GameWorld.GetGameWorld().GetCurGameWorldIndex()
|
exitFBType = 1 if isDisconnect else 2
|
PyGameData.g_lastExitFBType[fbIndex] = [exitFBType, tick]
|
#GameWorld.DebugLog("Íæ¼ÒÀ뿪¸±±¾£ºfbIndex=%s,exitFBType=%s, %s" % (fbIndex, exitFBType, PyGameData.g_lastExitFBType), curPlayer.GetPlayerID())
|
FBLogic.DoExitFBLogic(curPlayer, tick)
|
|
#Çå¿ÕËùÓв»ÊôÓÚ×Ô¼ºµÄ¹â»·
|
#__ClearNoMeAuraBuff(curPlayer)
|
|
#Çå¿ÕËùÓÐÀ뿪µØͼ²»ÐèÒª±£´æµÄBuff
|
__ClearLeaveNoSaveBuff(curPlayer)
|
|
#---±£´æÍæ¼ÒÔÚÏßʱ¼ä(°´ÃëËã)---
|
UpdateOnLineTime(curPlayer, tick)
|
|
PassiveBuffEffMng.OnPlayerLeaveMap(curPlayer)
|
|
#À뿪µØͼÇå¿Õ¶ñÒâ¹¥»÷×Ô¼ºÍæ¼ÒÐÅÏ¢
|
if curPlayer.GetPlayerID() in PyGameData.g_maliciousAttackDict:
|
PyGameData.g_maliciousAttackDict.pop(curPlayer.GetPlayerID())
|
|
PyGameData.g_needRefreshMapServerState = True # ÓÐÍæ¼ÒÀ뿪µØͼÉèÖÃÐèҪˢÐÂ
|
|
PlayerSuccess.FinishDelayAddSuccessProgress(curPlayer, tick)
|
playerID = curPlayer.GetPlayerID()
|
if not isDisconnect:
|
CrossPlayerData.ClearCrossSyncDataCache(curPlayer)
|
PyGameData.g_fbBuyBuffTimeDict.pop(playerID, None)
|
#Çå³ýµØͼÍæ¼Ò»º´æ
|
PyGameData.g_playerFuncAttrDict.pop(playerID, None)
|
PyGameData.g_playerEquipPartAttrDict.pop(playerID, None)
|
PyGameData.g_playerReqEnterFBEx.pop(playerID, None)
|
NPCCommon.ClearPriWoodPile(curPlayer)
|
#ÒƳýµØͼ»º´æµÄ¾³½çÄѶÈÍæ¼ÒIDÐÅÏ¢
|
for playerIDList in PyGameData.g_realmDiffPlayerDict.values():
|
if playerID in playerIDList:
|
playerIDList.remove(playerID)
|
return
|
|
##¸üб£´æÍæ¼ÒÔÚÏßʱ¼ä
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param tick ʱ¼ätick
|
# @return
|
def UpdateOnLineTime(curPlayer, tick):
|
#---±£´æÍæ¼ÒÔÚÏßʱ¼ä(°´ÃëËã)---
|
lastCalcTick = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_CalcOLTimeTick)
|
if lastCalcTick <= 0:
|
curPlayer.SetDict(ChConfig.Def_PlayerKey_CalcOLTimeTick, tick)
|
return
|
|
curPlayer.SetDict(ChConfig.Def_PlayerKey_CalcOLTimeTick, tick)
|
|
diffSec = (tick - lastCalcTick) / 1000
|
if diffSec > 0:
|
curPlayer.SetWeekOnlineTime(curPlayer.GetWeekOnlineTime() + diffSec)
|
curPlayer.SetOnlineTime(curPlayer.GetOnlineTime() + diffSec)
|
SyncOnLineTimeTotal(curPlayer)
|
|
return
|
|
##ͬ²½ÔÚÏßʱ¼ä
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return
|
def SyncOnLineTimeTotal(curPlayer):
|
sendPack = ChPyNetSendPack.tagMCOnLineTimeTotal()
|
sendPack.Clear()
|
sendPack.OnLineTimeTotal = curPlayer.GetOnlineTime()
|
NetPackCommon.SendFakePack(curPlayer, sendPack)
|
return
|
|
##ͬ²½×îºóÒ»´Î±³°ü¿ª¸ñÔÚÏßʱ¼ä
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param packType ±³°üÀàÐÍ
|
# @return
|
def SyncOnLineTimeLastOpenPack(curPlayer, packType):
|
return
|
sendPack = ChPyNetSendPack.tagMCOnlineTimeLastOpenPack()
|
sendPack.Clear()
|
sendPack.PackType = packType
|
sendPack.LastOnLineTime = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_LastAutoOpenPackTick % packType)
|
NetPackCommon.SendFakePack(curPlayer, sendPack)
|
return
|
|
##À뿪µØͼÇå¿Õ²»±£´æµÄBuff
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks À뿪µØͼÇå¿Õ²»±£´æµÄBuff
|
def __ClearLeaveNoSaveBuff(curPlayer):
|
#×°±¸BuffºÍ±»¶¯BuffÕâÀï²»Çå, Çл»µØͼºó»áÖØмÆËã
|
|
#Çå¿ÕËùÓг¡¾°ÀàBuff
|
curPlayer.GetMapBuff().Clear()
|
|
#2011-01-28 ÐÞ¸ÄΪ¿É±£´æ£¬¹Ê´Ë´¦²»É¾³ý
|
#Çå¿ÕËùÓпØÖÆÀàBUFF
|
#BUG: ¿ØÖÆÀàBUFF²»´æÊý¾Ý¿â£¬ÇеØͼºó²»Í¨ÖªÏûʧ£¬¿Í»§¶ËÎÞ·¨É¾³ý
|
#curPlayer.GetActionBuffManager().Clear()
|
return
|
|
|
## Çå³ýÏÂÏßÏûʧµÄbuff, ÔÚ¸üÐÂÅÅÐаñ֮ǰ
|
# @param curPlayer: Íæ¼ÒʵÀý
|
# @return
|
def __DisconnectClearBuff(curPlayer, tick):
|
|
#ÐèÒª¿¼ÂÇbuff,deBuff,aura,incBuff,mapBuff,³ýÁËequipBuff²»¿¼ÂÇ
|
PlayerClearBuff_Single(curPlayer, curPlayer.GetBuffState(), ClearBuffByDisconnect, tick)
|
PlayerClearBuff_Single(curPlayer, curPlayer.GetDeBuffState(), ClearBuffByDisconnect, tick)
|
PlayerClearBuff_Single(curPlayer, curPlayer.GetAura(), ClearBuffByDisconnect, tick)
|
PlayerClearBuff_Single(curPlayer, curPlayer.GetIncBuff(), ClearBuffByDisconnect, tick)
|
PlayerClearBuff_Single(curPlayer, curPlayer.GetMapBuff(), ClearBuffByDisconnect, tick)
|
PlayerClearBuff_Single(curPlayer, curPlayer.GetActionBuffManager(), ClearBuffByDisconnect, tick)
|
PlayerClearBuff_Single(curPlayer, curPlayer.GetProcessBuffState(), ClearBuffByDisconnect, tick)
|
PlayerClearBuff_Single(curPlayer, curPlayer.GetProcessDeBuffState(), ClearBuffByDisconnect, tick)
|
|
#BUFFЧ¹ûÔÚÍâ²ã¼ÆËã
|
#SkillShell.RefreshPlayerBuffOnAttrAddEffect(curPlayer)
|
return
|
|
#---------------------------------------------------------------------
|
##Íæ¼ÒÀ뿪·þÎñÆ÷
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param tick ʱ¼ä´Á
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks Íæ¼ÒÀ뿪·þÎñÆ÷
|
def PlayerLeaveServer(curPlayer, tick):
|
#³èÎïÏÂÏßÂß¼, ÕâÀïÒª½øÐÐÅÅÐаñ, ÓÅÏÈ×ö, ±ÜÃâÍæ¼Ò¹â»·µÈÊôÐÔÓ°Ïì³èÎïÊôÐÔʧЧ
|
PetControl.DoLogic_PetInfo_OnLeaveServer(curPlayer, tick)
|
|
#Çå³ýÏÂÏßÏûʧµÄbuff, ÔÚ¸üÐÂÅÅÐаñ֮ǰ
|
__DisconnectClearBuff(curPlayer, tick)
|
|
#Çå³ý»ØÊÕÕ½
|
#DelRecylcePack(curPlayer)
|
|
#ÖØÐÂˢнÇÉ«ÊôÐÔ
|
playerControl = PlayerControl(curPlayer)
|
playerControl.RefreshAllState()
|
|
#Íæ¼ÒÏÂÏ߸üÐÂÅÅÐаñ
|
PlayerBillboard.UpdatePlayerBillboardOnLeaveServer(curPlayer) #ÅÅÐаñÒÑʵʱ¸üУ¬¹ÊÏÂÏß²»ÔÙͬ²½
|
|
#Íæ¼ÒÏÂÏß֪ͨgameserver¼Ç¼»º´æ£¨·ÅÔÚÏÂÏ߸üÐÂÅÅÐаñÖ®ºó£¬·½±ãGameserverÅжÏÊÇ·ñÐèÒª´æÈëÊý¾Ý¿âÖУ©
|
PlayerViewCache.OnPlayerLogout(curPlayer)
|
PlayerFamily.OnPlayerLogout(curPlayer)
|
|
#Íæ¼ÒÏÂÏß/Íæ¼ÒÇл»µØͼ¹«ÓÃÂß¼
|
__PlayerLeaveServerLogic(curPlayer, tick, True)
|
#ÆïÂíÍæ¼ÒÏÂÏßÂß¼
|
__RidingHorsePlayerDisconnect(curPlayer)
|
#ÕÙ»½ÊÞËÀÍö
|
KillPlayerSummonNPC(curPlayer)
|
#¸üдӱ¾µØͼÀëÏßÐÅÏ¢
|
PyGameData.g_disconnectPlayer[curPlayer.GetPlayerID()] = [tick, curPlayer.GetPosX(), curPlayer.GetPosY()]
|
GameWorld.DebugLog("Íæ¼Ò´Ó±¾µØͼÀëÏß: %s" % PyGameData.g_disconnectPlayer, curPlayer.GetPlayerID())
|
return
|
|
def GetPlayerLeaveServerTick(playerID):
|
# »ñÈ¡Íæ¼Ò´Ó±¾µØͼÖÐÀëÏßʱµÄtick, ×î´óÖ§³Ö1Сʱ, Èç¹ûÓÐÐèÒª´óÓÚ1СʱµÄÇëµ÷Õû³¬Ê±ÏÞÖÆ
|
# ×¢: ·µ»ØֵΪ0ʱ£¬Ö»ÄÜ´ú±íÍæ¼Ò²»ÊÇÔÚ±¾µØͼÀëÏß1СʱÄÚ£¬²¢²»ÄÜ´ú±íÍæ¼Òµ±Ç°ÊÇ·ñÔÚÏß״̬£¬¿ÉÄÜÔÚÆäËûµØͼ
|
if playerID not in PyGameData.g_disconnectPlayer:
|
return 0
|
return PyGameData.g_disconnectPlayer[playerID][0]
|
|
def GetPlayerLeaveServerPos(playerID):
|
# »ñÈ¡Íæ¼Ò´Ó±¾µØͼÖÐÀëÏßʱµÄ×ø±ê
|
# ×¢£ºÊ¹Óñ¾º¯Êýʱ£¬Ò»¶¨ÒªÏÈʹÓú¯Êý GetPlayerLeaveServerTick È·±£ÊÇ´Ó±¾µØͼÖÐÀëÏߵIJſÉʹÓÃ
|
# @return: posX, posY
|
if playerID not in PyGameData.g_disconnectPlayer:
|
return 0, 0
|
return PyGameData.g_disconnectPlayer[playerID][1:3]
|
|
def RemoveTimeoutLeaveServerPlayerInfo(tick):
|
# Ôݶ¨Ã¿ÌìÁ賿5µãÖ´ÐÐÒ»´Î
|
for playerID, leaveInfo in PyGameData.g_disconnectPlayer.items():
|
leaveTick = leaveInfo[0]
|
if tick - leaveTick > 3600000: # Çå³ý³¬Ê±1СʱµÄ¼Ç¼
|
PyGameData.g_disconnectPlayer.pop(playerID)
|
return
|
|
def RemoveLeaveServerPlayerInfo(playerID):
|
# ÉÏÏßÒƳýÔÚ±¾µØͼÏÂÏߵļǼ
|
if playerID in PyGameData.g_disconnectPlayer:
|
PyGameData.g_disconnectPlayer.pop(playerID)
|
GameWorld.DebugLog("½øÈë±¾µØͼ£¬ÒƳýÉÏ´ÎÔÚ±¾µØͼÀëÏ߼Ǽ!", playerID)
|
return
|
|
|
##Çå³ý»ØÊÕÕ½
|
# @param None
|
# @return None
|
def DelRecylcePack(curPlayer):
|
backPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptRecycle)
|
|
for i in range(backPack.GetCount()):
|
curItem = backPack.GetAt(i)
|
|
if not curItem or curItem.IsEmpty():
|
continue
|
|
curItem.Clear()
|
|
NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_DelPackIndex, 0)
|
return
|
|
#---------------------------------------------------------------------
|
##Íæ¼Ò¿ªÊ¼Çл»µØͼ
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param tick ʱ¼ä´Á
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks Íæ¼Ò¿ªÊ¼Çл»µØͼ
|
def DoPlayerResetWorldPos(curPlayer, tick):
|
NotifyStartChangeMap(curPlayer) # ֪ͨ¿ªÊ¼Çл»µØͼ
|
|
#À뿪µØͼ·þÎñÆ÷
|
__PlayerLeaveServerLogic(curPlayer, tick, False)
|
|
FBLogic.DoPlayerChangeMapLogic(curPlayer, tick)
|
#summonList = list()
|
#ÕٻسèÎï
|
PetControl.ReCallFightPet(curPlayer)
|
#1. ɾ³ý×Ô¼º²»ÐèÒªµÄÕÙ»½ÊÞ(»ðÑæÖ®ÁéµÈ)
|
#±ØÐëÓÃwhile, ÒòΪÔÚÑ»·ÖÐҪɾ³ý
|
# ÕÙ»½ÊÞÇеØͼ²»´ø¹ýÈ¥
|
while curPlayer.GetSummonCount():
|
summonNPC = curPlayer.GetSummonNPCAt(0)
|
NPCCommon.SetDeadEx(summonNPC)
|
|
changeMapID = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_ChangeMapID)
|
# ¸üÐÂ×îºóÒ»´ÎÀ뿪µÄ·ÇÖÐÁ¢³£¹æµØͼ, ´ÓÖÐÁ¢µØͼÍ˳öʱÐèÒª»Øµ½¸ÃµØ·½£¬±ØÐëÔÚ DoResetWorldPosAndClear ֮ǰ¸üÐÂ
|
if GameWorld.GetMap().GetMapFBType() == IPY_GameWorld.fbtNull and curPlayer.GetMapID() not in IpyGameDataPY.GetFuncEvalCfg("MapLine", 4):
|
mapID = curPlayer.GetMapID()
|
posX = curPlayer.GetPosX()
|
posY = curPlayer.GetPosY()
|
lineID = curPlayer.GetClientLineID() # ³£¹æµØͼÓ÷ÖÏßID
|
NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FromMapID, mapID)
|
NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FromPosX, posX)
|
NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FromPosY, posY)
|
NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FromLineID, lineID)
|
GameWorld.DebugLog("×îºóÒ»´ÎÀ뿪µÄ·ÇÖÐÁ¢³£¹æµØͼ¸üÐÂ!mapID=%s,lineID=%s,Pos(%s,%s)" % (mapID, lineID, posX, posY))
|
# µ±Ç°ÊÇ¿É·µ»ØµÄ¸±±¾µØͼ ÇÒ Ä¿±êµØͼΪ¸±±¾
|
elif curPlayer.GetMapID() in ChConfig.Def_CanBackFBMap and curPlayer.GetMapID() != changeMapID \
|
and GameWorld.GetMap().GetMapFBTypeByMapID(changeMapID) != IPY_GameWorld.fbtNull:
|
mapID = curPlayer.GetMapID()
|
posX = curPlayer.GetPosX()
|
posY = curPlayer.GetPosY()
|
lineID = GetFBFuncLineID(curPlayer) # ¸±±¾Óù¦ÄÜÏß·ID
|
NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FromFBMapID, mapID)
|
NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FromFBPosX, posX)
|
NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FromFBPosY, posY)
|
NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FromFBLineID, lineID)
|
GameWorld.DebugLog("½øÈ븱±¾Ê±£¬×îºóÒ»´ÎÀ뿪µÄ¿É·µ»ØµÄ¸±±¾ID¸üÐÂ!mapID=%s,lineID=%s,Pos(%s,%s)" % (mapID, lineID, posX, posY))
|
|
# À뿪µØͼ
|
PlayerAssist.OnPlayerLeaveMap(curPlayer)
|
|
# ´Ó¸±±¾ÖÐÇÐͼ
|
if GameWorld.GetMap().GetMapFBType() != IPY_GameWorld.fbtNull:
|
#ĬÈÏ»ØÂúѪ
|
if GameObj.GetHP(curPlayer) > 0 and curPlayer.GetPlayerAction() != IPY_GameWorld.paDie and GameObj.GetHP(curPlayer) < GameObj.GetMaxHP(curPlayer):
|
GameObj.SetHPFull(curPlayer)
|
|
#2. µ÷ÓÃÇл»µØͼ½Ó¿Ú
|
curPlayer.DoResetWorldPosAndClear()
|
return
|
|
#---------------------------------------------------------------------
|
##Íæ¼ÒÀ뿪¸±±¾
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks Íæ¼ÒÀ뿪¸±±¾
|
def PlayerLeaveFB(curPlayer):
|
if not curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_RouteServerInitOK):
|
#RouteServerδ³õʼ»¯²»ÔÊÐíÇл»µØͼ, »º´æ´¦Àí
|
GameServerRefresh.Set_PlayerRouteServerInitOK_OnLeaveFB(curPlayer, 1)
|
return
|
|
GameWorld.Log("PlayerLeaveFB...", curPlayer.GetPlayerID())
|
if GameWorld.IsCrossServer():
|
CrossRealmPlayer.PlayerExitCrossServer(curPlayer)
|
return
|
|
funcLineID = 0
|
enterFBFree = False
|
#ÖÐÁ¢µØͼ»Øµ½ÉÏÒ»´Î·ÇÖÐÁ¢³£¹æµØͼ
|
if curPlayer.GetMapID() in IpyGameDataPY.GetFuncEvalCfg("MapLine", 4) or curPlayer.GetMapID() in ChConfig.Def_CanBackFBMap:
|
mapID = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FromMapID)
|
posX = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FromPosX)
|
posY = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FromPosY)
|
lineID = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FromLineID)
|
# ÖØÖÃ
|
NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FromMapID, 0)
|
# ÀϺÅÖ§³Ö£¬±¾À´¾ÍÔÚÖÐÁ¢µØͼµÄ£¬·µ»ØÐÂÊÖ´å
|
if not mapID:
|
# {Ö°Òµ:[dataMapID,posX,posY], ...}
|
createRoleMapDict = IpyGameDataPY.GetFuncEvalCfg("CreateRoleMap", 1, {})
|
if not createRoleMapDict:
|
return
|
job = curPlayer.GetJob()
|
lineID = 0
|
if job in createRoleMapDict:
|
mapID, posX, posY = createRoleMapDict[job]
|
else:
|
mapInfoList = createRoleMapDict.values()
|
mapID, posX, posY = mapInfoList[0]
|
#À뿪¸±±¾
|
else:
|
fromFBMapID = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FromFBMapID)
|
# »Øµ½ÉÏÒ»´Î¿É·µ»ØµÄ¸±±¾Àï
|
if fromFBMapID:
|
mapID = fromFBMapID
|
posX = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FromFBPosX)
|
posY = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FromFBPosY)
|
lineID = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FromFBLineID)
|
funcLineID = lineID # »Ø¸±±¾µÄÒªÖ¸¶¨¹¦ÄÜÏß·ID
|
enterFBFree = True # ·µ»ØµÄÃâ·Ñ½øÈë
|
# ÖØÖÃ
|
NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FromFBMapID, 0)
|
GameWorld.DebugLog("À뿪¸±±¾£¬·µ»Ø¿É֮ǰ¿É·µ»ØµÄ¸±±¾! fromFBMapID=%s,lineID=%s,posXY(%s,%s)" % (mapID, lineID, posX, posY))
|
else:
|
mapID = curPlayer.GetFromMapID()
|
posX = curPlayer.GetFromPosX()
|
posY = curPlayer.GetFromPosY()
|
lineID = curPlayer.GetFromLineID()
|
|
if mapID == curPlayer.GetMapID():
|
# Èç¹ûÔÚͬһÕŵØͼ, È¡DBÖØÉúµã, ÆÕͨµØͼÏÂÏßÖØÉÏʱFromMapID»á±»ÉèÖÃΪ±¾µØͼ
|
gameMap = GameWorld.GetMap()
|
mapID, posX, posY = gameMap.GetRebornMapID(), gameMap.GetRebornMapX(), gameMap.GetRebornMapY()
|
#posX, posY = GameMap.GetNearbyPosByDis(posX, posY, ChConfig.Def_RebornPos_Area_Range)
|
|
#copyMapID = curPlayer.GetCopyMapID()
|
GameWorld.Log("PlayerLeaveFB MapID = %d, PosX = %d, PosY = %d" % (mapID, posX, posY), curPlayer.GetPlayerID())
|
|
if GameWorldProcess.IsNoPlayerNeedCloseFB() and GameWorld.GetGameWorld().GetMapCopyPlayerManager().GetPlayerCount() == 1:
|
#Èç¹û¸±±¾ÖÐÖ»ÓÐÕâÒ»¸öÈË, ÄÇô°ÑÕâ¸ö¸±±¾ÉèÖÃΪÍæ¼Ò°²È«ÏÂÏß, ¹Ø±Õ¸±±¾
|
gameFB = GameWorld.GetGameFB()
|
gameFB.SetIsSafeClose(1)
|
|
#===============================================================================================
|
# #Èç¹ûÍæ¼ÒÊÇËÀÍö״̬£¬ÔòÏȸ´»î£¬ÊÖÓβ߻®²»Ï븴»îÍ˳ö
|
# if curPlayer.GetPlayerAction() == IPY_GameWorld.paDie:
|
# curPlayer.Reborn(ChConfig.rebornType_System)
|
# GameObj.SetHPFull(curPlayer)
|
# ChangePlayerAction(curPlayer, IPY_GameWorld.paNull)
|
#===============================================================================================
|
|
PlayerResetWorldPosFB(curPlayer, mapID, posX, posY, lineID, funcLineID=funcLineID, enterFBFree=enterFBFree)
|
|
#ÔÚ¿ÕÏлòÕßÒƶ¯×´Ì¬ÏÂ,²ÅÄÜËøËÀÍæ¼Ò
|
if curPlayer.GetPlayerAction() in [IPY_GameWorld.paNull] or curPlayer.IsMoving():
|
#°ÑÍæ¼ÒËøËÀ
|
curPlayer.BeginEvent()
|
|
return
|
|
#---------------------------------------------------------------------
|
|
def PlayerEnterCrossServer(curPlayer, mapID, lineID):
|
playerID = curPlayer.GetPlayerID()
|
GameWorld.Log("Íæ¼ÒÇëÇó½øÈë¿ç·þµØͼ: mapID=%s,lineID=%s" % (mapID, lineID), playerID)
|
if mapID not in ChConfig.Def_CrossMapIDList:
|
return
|
|
tick = GameWorld.GetGameWorld().GetTick()
|
lastRequestTick = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_RequestEnterCrossServerTick)
|
if lastRequestTick and tick - lastRequestTick < 5000:
|
GameWorld.DebugLog(" ÇëÇó½øÈë¿ç·þCDÖÐ!", playerID)
|
NotifyCode(curPlayer, "RequestEnterCrossServerCD")
|
return
|
|
crossRegisterMap = curPlayer.NomalDictGetProperty(ChConfig.Def_PlayerKey_CrossRegisterMap)
|
if crossRegisterMap:
|
GameWorld.ErrLog("¿ç·þÒѾÔÚÉÏ´«Êý¾Ý£¬²»Öظ´Ìá½»!crossRegisterMap=%s,mapID=%s" % (crossRegisterMap, mapID), playerID)
|
return
|
|
if GameWorld.IsCrossServer():
|
GameWorld.DebugLog("¿ç·þ·þÎñÆ÷²»ÔÊÐí¸Ã²Ù×÷!")
|
return
|
|
if GetCrossMapID(curPlayer):
|
GameWorld.ErrLog("Íæ¼Òµ±Ç°Îª¿ç·þ״̬£¬²»ÔÊÐíÔÙ´ÎÇëÇó½øÈë¿ç·þ!", curPlayer.GetPlayerID())
|
return
|
|
if not CrossRealmPlayer.IsCrossServerOpen():
|
NotifyCode(curPlayer, "CrossMatching18")
|
return
|
|
if GameObj.GetHP(curPlayer) <= 0:
|
NotifyCode(curPlayer, "CrossMap4")
|
return
|
|
if PlayerState.IsInPKState(curPlayer):
|
NotifyCode(curPlayer, "SingleEnterPK", [mapID])
|
return
|
|
fbIpyData = FBCommon.GetFBIpyData(mapID)
|
if fbIpyData:
|
fbLineIpyData = FBCommon.GetFBLineIpyData(mapID, lineID, False)
|
if not fbLineIpyData:
|
GameWorld.DebugLog("¸±±¾±íÕÒ²»µ½¸±±¾¶ÔÓ¦¹¦ÄÜÏß·!mapID=%s,lineID=%s" % (mapID, lineID))
|
return
|
ret = FBCommon.CheckCanEnterFBComm(curPlayer, mapID, lineID, fbIpyData, fbLineIpyData)
|
if ret != ShareDefine.EntFBAskRet_OK:
|
return
|
|
if not FBLogic.OnEnterFBEvent(curPlayer, mapID, lineID, tick):
|
GameWorld.DebugLog(" OnEnterFBEvent False!", curPlayer.GetPlayerID())
|
if mapID in [ChConfig.Def_FBMapID_CrossBattlefield]:
|
NotifyCode(curPlayer, "GeRen_chenxin_268121")
|
else:
|
NotifyCode(curPlayer, "SingleEnterDefaul")
|
return
|
|
# ÐèÒª¶¯Ì¬·Ö²¼Ïß·µÄµØͼ£¬·¢Ë͵½¿ç·þ·þÎñÆ÷½øÐзÖÅä
|
if mapID in ChConfig.Def_CrossDynamicLineMap:
|
extendInfo = {}
|
if mapID == ChConfig.Def_FBMapID_CrossDemonKing:
|
bossID = GameLogic_CrossDemonKing.GetCurFBLineBOSSID(mapID, lineID)
|
if not bossID:
|
return
|
extendInfo["BossID"] = bossID
|
|
msgDict = {"PlayerID":curPlayer.GetPlayerID(), "MapID":mapID, "FuncLineID":lineID, "LV":curPlayer.GetLV()}
|
if extendInfo:
|
msgDict.update(extendInfo)
|
GameWorld.SendMsgToCrossServer(ShareDefine.ClientServerMsg_EnterFB, msgDict)
|
else:
|
isSend = GY_Query_CrossRealmReg.RegisterEnterCrossServer(curPlayer, mapID, lineID=lineID)
|
if not isSend:
|
return
|
curPlayer.SetDict(ChConfig.Def_PlayerKey_RequestEnterCrossServerTick, tick)
|
return
|
|
##Íæ¼Ò½øÈ븱±¾
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param mapID µØͼID
|
# @param posX ×ø±êX
|
# @param posY ×ø±êY
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks Íæ¼Òµ¥¶À½øÈ븱±¾
|
def PlayerEnterFB(curPlayer, mapID, lineID, posX=0, posY=0, reqInfoEx=None):
|
mapID = FBCommon.GetRecordMapID(mapID)
|
playerID = curPlayer.GetPlayerID()
|
GameWorld.Log("Íæ¼ÒÇëÇó½øÈ븱±¾! mapID=%s,lineID=%s,posX=%s,posY=%s,reqInfoEx=%s" % (mapID, lineID, posX, posY, reqInfoEx), playerID)
|
|
#½øÈ븱±¾Í¨Óüì²é
|
fbIpyData = FBCommon.GetFBIpyData(mapID)
|
fbLineIpyData = FBCommon.GetFBLineIpyData(mapID, lineID)
|
sceneMapID = mapID if not fbLineIpyData else fbLineIpyData.GetMapID()
|
#¹ýÂË·â°üµØͼID
|
if not GameWorld.GetMap().IsMapIDExist(sceneMapID):
|
GameWorld.ErrLog('###·Ç·¨µØͼÊý¾Ý£¬sceneMapID: %s' % (sceneMapID), curPlayer.GetID())
|
return
|
tick = GameWorld.GetGameWorld().GetTick()
|
if CheckMoveToFB(curPlayer, mapID, lineID, fbIpyData, fbLineIpyData, tick) != ShareDefine.EntFBAskRet_OK:
|
return
|
# if mapID == ChConfig.Def_FBMapID_XMZZ:
|
# #ÏÉħ֮Õù
|
# GameLogic_XMZZ.XMZZStartFight(curPlayer)
|
# return
|
if posX == 0 and posY == 0:
|
ipyEnterPosInfo = FBCommon.GetFBLineEnterPosInfo(mapID, lineID, fbLineIpyData)
|
retPos = FBLogic.OnGetFBEnterPos(curPlayer, mapID, lineID, ipyEnterPosInfo, tick)
|
|
if not retPos:
|
GameWorld.ErrLog("δÕÒµ½½øÈ븱±¾×ø±ê£¡mapID=%s,lineID=%s" % (mapID, lineID))
|
return
|
|
posX, posY = retPos
|
|
if curPlayer.IsMoving():
|
curPlayer.StopMove()
|
|
fbID = 0 # ºó¶ËµÄÐéÄâÏß·
|
isSendToGameServer = False
|
mapFBType = GameWorld.GetMap().GetMapFBTypeByMapID(sceneMapID) # ÅжÏÊÇ·ñ×é¶Ó±¾ÐèÒªÒÔ³¡¾°µØͼÅжϣ¬ÒòΪ²ß»®¿ÉÄÜÉ趨²»Í¬¹¦ÄÜÏß·IDµÄ¸±±¾ÀàÐͲ»Ò»Ñù£¬±ÈÈçС¾³½ç¡¢´ó¾³½ç
|
if mapFBType == IPY_GameWorld.fbtTeam and curPlayer.GetTeamID():
|
if curPlayer.GetTeamLV() != IPY_GameWorld.tmlLeader:
|
GameWorld.Log("·Ç¶Ó³¤£¬ÎÞ·¨·¢Æð½øÈë×é¶Ó¸±±¾ÇëÇó!", curPlayer.GetPlayerID())
|
return
|
isSendToGameServer = True
|
if isSendToGameServer or mapID in ChConfig.Def_MapID_SendToGameServer \
|
or mapID in ReadChConfig.GetEvalChConfig("MapID_SendToGameServer"):
|
extendParamList = []
|
if mapID == ChConfig.Def_FBMapID_SealDemon:
|
newbielineList = IpyGameDataPY.GetFuncEvalCfg('SealDemonNewbieLine', 1)
|
# ÐÂÊÖÏß·ÌØÊâ´¦Àí£¬Ö±½Ó½øÈë
|
if lineID in newbielineList:
|
GameWorld.DebugLog("·âħ̳ÐéÄâÏß·ֻÄÜͨ¹ý×Ô¶¨Ò峡¾°½øÈëÌôÕ½£¡")
|
return
|
else:
|
bossID = GameLogic_SealDemon.CurFBLineBOSSID(lineID)
|
extendParamList = [bossID]
|
elif mapID == ChConfig.Def_FBMapID_ZhuXianBoss:
|
bossID = GameLogic_ZhuXianBoss.CurFBLineBOSSID(lineID)
|
extendParamList = [bossID, -1]
|
enterCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_EnterFbCntDay % ChConfig.Def_FBMapID_ZhuXianBoss)
|
if enterCnt >= FBCommon.GetEnterFBMaxCnt(curPlayer, ChConfig.Def_FBMapID_ZhuXianBoss):
|
if curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_ZhuXianBossHelpCnt):
|
extendParamList = [bossID, curPlayer.GetFamilyID()]
|
elif mapID == ChConfig.Def_FBMapID_DemonKing:
|
bossID = GameLogic_CrossDemonKing.GetCurFBLineBOSSID(mapID, lineID)
|
extendParamList = [bossID]
|
elif mapID in ChConfig.Def_MapID_LineIDToPropertyID:
|
enterCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_EnterFbCntDay % mapID)
|
extendParamList = [enterCnt]
|
elif mapID in ChConfig.MirrorBattleMapIDList:
|
reqInfoEx["sceneMapID"] = sceneMapID
|
extendParamList = [reqInfoEx]
|
SendToGameServerEnterFB(curPlayer, mapID, lineID, tick, extendParamList)
|
return
|
|
PlayerResetWorldPosFB(curPlayer, mapID, posX, posY, fbID, funcLineID=lineID)
|
return
|
|
##·¢Ë͵½GameServerÇëÇó½øÈ븱±¾
|
#@param curPlayer Íæ¼Ò
|
#@param mapID µØͼid
|
#@param lineID Ïß·id
|
#@param tick ʱ¼ä´Á
|
#@return ·µ»ØÖµÎÞÒâÒå
|
def SendToGameServerEnterFB(curPlayer, mapID, lineID, tick, extendParamList=[]):
|
#lineID = FBLogic.GetPlayerFBLineID(curPlayer, mapID, tick)
|
|
GameWorld.Log("SendToGameServerEnterFB mapID=%s,lineID=%s,extendParamList=%s"
|
% (mapID, lineID, extendParamList), curPlayer.GetID())
|
# »ñÈ¡Íæ¼ÒËùÊô·ÖÏß
|
if lineID == None:
|
lineID = FBLogic.GetPlayerFBLineID(curPlayer, mapID, tick)
|
|
#GameWorld.DebugLog("send GameServer_QueryPlayerByID")
|
# ÇëÇóGameServerÄ¿±ê¸±±¾GameWorldË÷Òý
|
sendMsg = [mapID, lineID]
|
sendMsg += extendParamList
|
sendMsg = "%s" % sendMsg
|
curPlayer.GameServer_QueryPlayerByID(ChConfig.queryType_EnterFB, 0, 'EnterFB', sendMsg, len(sendMsg))
|
return
|
|
##¼ì²éÍæ¼Ò״̬ÊÇ·ñ¿ÉÒÔÒƶ¯µ½¸±±¾
|
#@param curPlayer Íæ¼ÒʵÀý
|
#@return ·µ»ØÖµÎÞÒâÒå
|
#@remarks ¼ì²éÍæ¼Ò״̬ÊÇ·ñ¿ÉÒÔÒƶ¯µ½¸±±¾
|
def CheckMoveToFB(curPlayer, mapID, lineID, fbIpyData, fbLineIpyData, tick, isNotify=True, isTeamAsk=False):
|
'''ÅжϿɷñ½øÈ븱±¾£¬°üº¬ÊÖ¶¯¼°Æ¥Åä
|
@param isTeamAsk: ÊÇ·ñÊǶÓÎé½øÈëÇëÇóµÄ£¬Ò»°ãÊǶÓÎé״̬Ï£¬¶Ó³¤·¢Æð½øÈ븱±¾£¬ÐèÒª¼ì²é¶ÓÔ±¿É·ñ½øÈ룬´ËʱΪTrue£¬¿É×öһЩ¸½¼Ó´¦Àí
|
@note: ²ß»®ÒªÇóÌáʾ°´ÓÅÏȼ¶À´£¬¸±±¾×ÔÉíµÄÌõ¼þÏÞÖÆÓÅÏÈÌáʾ£¬ÆäËû¸½¼ÓÌáʾÓÅÏȼ¶½ÏµÍ
|
'''
|
ret = FBCommon.CheckCanEnterFBComm(curPlayer, mapID, lineID, fbIpyData, fbLineIpyData, 1, isNotify, isTeamAsk)
|
if ret != ShareDefine.EntFBAskRet_OK:
|
return ret
|
|
if GameObj.GetHP(curPlayer) <= 0:
|
GameWorld.Log("Íæ¼ÒÒѾËÀÍö, ÎÞ·¨½øÈ븱±¾!")
|
return ShareDefine.EntFBAskRet_Dead
|
|
## ¶ÓÎé¼ì²éµÄÇé¿ö£¬¶Ó³¤²»´¦Àí£¬Ö»´¦Àí¶ÓÔ±
|
if isTeamAsk and curPlayer.GetTeamLV() != IPY_GameWorld.tmlLeader:
|
# ºó¶ËÖ»×öboss״̬Ï£¬±»¶¯½øÈ븱±¾ÏÞÖÆ£¬·ÀÖ¹´òbossÖб»À½øÈ¥¸±±¾
|
# boss״̬µÄÆäËû´«ËÍÏÞÖÆÓÉÇ°¶Ë¿ØÖÆ£¬ÒòΪ²ß»®Òª¸ù¾Ý½çÃæÀ´´¦Àí£¬ÓÐЩ½çÃæÔÊÐí´«ËÍ£¬ÓÐЩ²»ÔÊÐí
|
if PlayerState.IsInBossState(curPlayer):
|
return ShareDefine.EntFBAskRet_BossState
|
|
## PK״̬¼ì²é
|
if PlayerState.IsInPKState(curPlayer):
|
if isNotify:
|
NotifyCode(curPlayer, "SingleEnterPK", [mapID])
|
return ShareDefine.EntFBAskRet_PKState
|
|
## ¿ç·þµØͼÖÐ
|
if GetCrossMapID(curPlayer) and mapID not in ChConfig.Def_CrossMapIDList:
|
if isNotify:
|
NotifyCode(curPlayer, "CrossMap5", [mapID])
|
return ShareDefine.EntFBAskRet_InCrossMap
|
|
#===============================================================================================
|
# # ÕâÀï²»×ö״̬ÏÞÖÆ£¬ÓÉÇ°¶Ë´¦Àí£¬ÒòΪ²ß»®Òª¸ù¾Ý½çÃæÀ´´¦Àí£¬Í¬Ò»´«Ë͹¦ÄÜÓпÉÄÜÔÚ²»Í¬½çÃæ
|
# # PK״̬¼ì²é
|
# if PlayerState.IsInPKState(curPlayer):
|
# if isNotify:
|
# NotifyCode(curPlayer, "SingleEnterPK", [mapID])
|
# return ShareDefine.EntFBAskRet_PKState
|
#
|
# # ´òboss״̬¼ì²é
|
# if PlayerState.IsInBossState(curPlayer):
|
# if isNotify:
|
# NotifyCode(curPlayer, "SingleEnterBoss", [mapID])
|
# return ShareDefine.EntFBAskRet_BossState
|
#===============================================================================================
|
|
playerAction = curPlayer.GetPlayerAction()
|
if playerAction == IPY_GameWorld.paPreparing:
|
if isNotify:
|
NotifyCode(curPlayer, "SingleEnterGather", [mapID])
|
return ShareDefine.EntFBAskRet_Preparing
|
|
if playerAction == IPY_GameWorld.paSit:
|
if isNotify:
|
NotifyCode(curPlayer, "Carry_lhs_697674")
|
return ShareDefine.EntFBAskRet_Sit
|
|
if curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_ClientCustomScene):
|
if isNotify:
|
NotifyCode(curPlayer, "Carry_lhs_697674")
|
GameWorld.Log("¿Í»§¶Ë×Ô¶¨Ò峡¾°ÏÂÎÞ·¨½øÈ븱±¾!", curPlayer.GetPlayerID())
|
return ShareDefine.EntFBAskRet_Other
|
|
if playerAction in ChConfig.Def_Player_Cannot_TransState:
|
#Carry_lhs_697674£ºÄúµ±Ç°Ëù´¦µÄ״̬²»ÄܽøÐд«ËÍ!
|
if isNotify:
|
NotifyCode(curPlayer, "Carry_lhs_697674")
|
return ShareDefine.EntFBAskRet_Other
|
|
for index in ChConfig.Def_Player_NotCan_EnterFbPyGameEvenState:
|
if GetPyPlayerAction(curPlayer, index):
|
#Carry_lhs_697674£ºÄúµ±Ç°Ëù´¦µÄ״̬²»ÄܽøÐд«ËÍ!
|
if isNotify:
|
NotifyCode(curPlayer, "Carry_lhs_697674")
|
return ShareDefine.EntFBAskRet_Other
|
|
#µ±Ç°µØͼ²»ÊÇÆÕͨµØͼ
|
if GameWorld.GetMap().GetMapFBType() != IPY_GameWorld.fbtNull:
|
canFBMoveToOther = False
|
fbEnableTransportMap = ReadChConfig.GetEvalChConfig("FBEnableTransportMap")
|
curMapID = GameWorld.GetMap().GetMapID()
|
if curMapID in fbEnableTransportMap and mapID in fbEnableTransportMap[curMapID]:
|
canFBMoveToOther = True
|
if curMapID in ChConfig.Def_CanBackFBMap:
|
canFBMoveToOther = True
|
toMapFBType = GameWorld.GetMap().GetMapFBTypeByMapID(mapID)
|
if toMapFBType == IPY_GameWorld.fbtNull:
|
if curMapID in IpyGameDataPY.GetFuncEvalCfg('DungeonDeliver', 1):
|
canFBMoveToOther = True
|
elif FBCommon.GetRecordMapID(curMapID) == FBCommon.GetRecordMapID(mapID):
|
if FBLogic.CanChangeSameDataMapFB(curPlayer, mapID, lineID):
|
canFBMoveToOther = True
|
|
if not canFBMoveToOther:
|
if isNotify:
|
NotifyCode(curPlayer, "SingleEnterDungeon", [mapID])
|
return ShareDefine.EntFBAskRet_InFB
|
|
if not FBLogic.OnEnterFBEvent(curPlayer, mapID, lineID, tick):
|
GameWorld.DebugLog(" OnEnterFBEvent False!", curPlayer.GetPlayerID())
|
if isNotify:
|
NotifyCode(curPlayer, "SingleEnterDefaul")
|
return ShareDefine.EntFBAskRet_Other
|
|
return ShareDefine.EntFBAskRet_OK
|
#---------------------------------------------------------------------
|
##Ë¢ÐÂÍæ¼ÒʱÖÓ£¬ÇеØͼÍæ¼ÒʱÖӼǼÇå¿Õ£¬´¦ÀíÏàÓ¦Âß¼
|
# @param curPlayer Íæ¼Ò
|
# @return ÎÞÒâÒå
|
# @remarks Ë¢ÐÂÍæ¼ÒʱÖÓ£¬ÇеØͼÍæ¼ÒʱÖӼǼÇå¿Õ£¬´¦ÀíÏàÓ¦Âß¼
|
def RefreshPlayerTick(curPlayer):
|
tick = GameWorld.GetGameWorld().GetTick()
|
|
#·À³ÁÃÔÇÐÏßʱ¼ä
|
PlayerGameWallow.DoLogic_WallowOnlineTime(curPlayer, tick)
|
return
|
|
|
#---------------------------------------------------------------------
|
|
def PlayerResetWorldPosFBLineID(curPlayer, mapID, posX, posY, funcLineID):
|
'''Íæ¼ÒÇл»µ½Ö¸¶¨¸±±¾¶ÔÓ¦µÄ¹¦ÄÜÏß·ID£¬ÊÊÓÃÓڶೡ¾°ºÏ²¢Ò»ÕŵØͼµÄÇé¿ö£¬ºó¶ËÐèÔÚͬһÕÅÎïÀíµØͼ²ÅÄÜʹÓøú¯Êý
|
ÓÉÓÚÇ°¶ËµØͼºÏ²¢µÄ³¡¾°¼ÓÔØÊÇ·Ö¿ªµÄ£¬ËùÒÔÔÚÇг¡¾°µÄʱºò²»ÄÜÖ±½ÓÉèÖÃ×ø±ê£¬ÒòΪǰ¶Ëʵ¼ÊÉϲ»´æÔÚ¸Ã×ø±ê
|
Íæ¼ÒÖ±½ÓÔÚµØͼÖÐÇл»¹¦ÄÜÏß·ID£¬´Ëʱǰ¶ËÐèÒª×ßÕý³£µÄÇÐͼÁ÷³Ì²ÅÄܼÓÔØÄ¿±ê¹¦ÄÜÏß·ID¶ÔÓ¦µÄ³¡¾°
|
¹ÊÕâÀï×ö¸öÐé¼ÙÇÐͼÁ÷³Ì
|
'''
|
if curPlayer.GetMapID() != mapID:
|
return
|
|
reqMapID = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_ReqFBMapID) # ÓÉÓÚºó¶ËµØͼ²»±äËùÒÔ²»ÐÞ¸ÄÖ±½Ó¶Á
|
NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_ReqFBFuncLine, funcLineID)
|
GameWorld.Log("Íæ¼Ò¸±±¾Öбä¸ü¹¦ÄÜÏß·ÐéÄâÇеØͼ: mapID=%s,posX=%s,posY=%s,funcLineID=%s"
|
% (mapID, posX, posY, funcLineID), curPlayer.GetPlayerID())
|
curPlayer.SetDict(ChConfig.Def_PlayerKey_ChangeMapID, mapID)
|
curPlayer.SetDict(ChConfig.Def_PlayerKey_ResetFBLinePosX, posX)
|
curPlayer.SetDict(ChConfig.Def_PlayerKey_ResetFBLinePosY, posY)
|
|
NotifyPrepareChangeMap(curPlayer)
|
NotifyStartChangeMap(curPlayer)
|
|
## ·¢ËÍ 04 01 ÈËÎïËùÔڵij¡¾°³õʼ»¯#tagPlayerMapInit
|
playerMapInit = ChNetSendPack.tagPlayerMapInit()
|
playerMapInit.Clear()
|
playerMapInit.MapID = mapID
|
playerMapInit.PosX = posX
|
playerMapInit.PosY = posY
|
NetPackCommon.SendFakePack(curPlayer, playerMapInit)
|
|
curPlayer.SetSight(0) # ÊÓÒ°ÖÃ0£¬Çгɹ¦ºó»Ö¸´ÊÓÒ°£¬·ÀÖ¹½ÓÏÂÀ´ÌáÇ°ÉèÖÃ×ø±êµ¼ÖÂÇ°¶ËÊÓÒ°Ë¢ÐÂÒì³£
|
curPlayer.ResetPos(posX, posY) # ÕâÀïÖ±½ÓÉèÖÃ×ø±ê£¬·Àֹǰ¶Ëδ¼ÓÔس¡¾°³É¹¦µôÏßµ¼ÖÂÖصǺó×ø±ê´íÎó
|
SetFBFuncLineID(curPlayer, reqMapID, funcLineID) # ÕâÀïÖ±½ÓÉèÖóÉÄ¿±ê¹¦ÄÜÏß·ID£¬·Àֹǰ¶Ëδ¼ÓÔس¡¾°³É¹¦µôÏßµ¼ÖÂÖصǺó¼ÓÔس¡¾°Òì³£
|
|
## ·¢ËÍ 01 09 ·þÎñÆ÷×¼±¸¾ÍÐ÷#tagServerPrepareOK
|
prepareOK = ChNetSendPack.tagServerPrepareOK()
|
prepareOK.Clear()
|
NetPackCommon.SendFakePack(curPlayer, prepareOK)
|
return
|
|
|
##Íæ¼ÒÇл»µ½Ö¸¶¨¸±±¾ID
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param mapID µØͼID
|
# @param posX ×ø±êX
|
# @param posY ×ø±êY
|
# @param FBID ¸±±¾ID, ÐéÄâÏß·ID
|
# @param msg Я´ýÐÅÏ¢
|
# @param canLock ÊÇ·ñËø¶¨Íæ¼Ò
|
# @param funcLineID ¸±±¾¹¦ÄÜÏß·ID£¬ÓÉÇ°¶ËÇëÇó
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks Íæ¼ÒÇл»µ½Ö¸¶¨¸±±¾ID
|
def PlayerResetWorldPosFB(curPlayer, mapID, posX, posY, fbID=0, msg='', canLock=True, funcLineID=0, enterFBFree=False):
|
'''
|
²ÎÊý˵Ã÷:
|
@param fbID:
|
´óÓÚ0µÄÕûÊý:
|
Èç¹û²ÎÊýmapIDÖ¸¶¨µÄµØͼ´æÔÚfbIDÖ¸¶¨µÄ·ÖÏߣ¬ÔòÖ±½Ó´«Ë͵½²ÎÊýmapIDËùÖ¸¶¨µÄµØͼµÄfbIDËùÖ¸¶¨µÄ·ÖÏߣ¬·ñÔòÔÚËùÓдæÔڵķÖÏßÖУ¬Ëæ»úÑ¡Ò»Ìõ·ÖÏß´«Èë¡£fbIDµÄ¼ÆËã¼ûÏÂÃæfbID=-1µÄ˵Ã÷¡£
|
-1£º
|
½Ó¿ÚÄÚ²¿×Ô¶¯Ìæ»»³Éµ±Ç°fbID£¬´«Èë²ÎÊýmapIDËùÖ¸¶¨µÄµØͼ£¨ÕâÀï²ÎÊýmapIDÆäʵÊÇDataMapID£©µÄͬһfbIDµÄµØͼ(Èç¹ûÓУ¬Ã»ÓÐÔòËæ»ú)¡£
|
Ï־͵±Ç°fbIDµÄ¼ÆËã,¾ÙÀý˵Ã÷,¼ÙÉèµØͼAºÍµØͼBÔÚMapID.txtÅäÖÃÈçÏ£º
|
MapName MapID DataMapID FBCount
|
µØͼA 101 101 3
|
µØͼB 102 101 3
|
¼´µØͼAºÍµØͼBÓй²Í¬µÄDataMapID,ÄÇôµØͼB½ø³ÌÄÚ²¿µÄµÚÒ»Ìõ·ÖÏߵĿͻ§¶ËID¾ÍÊÇ3(ËùÓзÖÏߵĿͻ§¶Ë·ÖÏßID:0¡¢1¡¢2¡¢3¡¢4¡¢5)
|
-2£º
|
Ö±½ÓËæ»ú´«µ½²ÎÊýmapIDËùÖ¸¶¨µÄµØͼµÄijһÄÚ²¿·ÖÏߣ¬ÕâÀïµÄijһÄÚ²¿·ÖÏßÏÞÓÚMapID.txtÖÐmapIDΪ´«Èë²ÎÊýmapIDµÄµØͼ½ø³ÌµÄ·ÖÏß¡£
|
|
@param funcLineID: ¹¦ÄÜÏß·ID
|
'''
|
tick = GameWorld.GetGameWorld().GetTick()
|
lastTransTick = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_TransTick)
|
#Ôݶ¨1Ãë
|
if tick - lastTransTick < 1000:
|
GameWorld.Log("Íæ¼ÒÇÐͼCDÖÐ: mapID=%s,posX=%s,posY=%s,fbID=%s,msg=%s,funcLineID=%s,tick=%s,lastTransTick=%s"
|
% (mapID, posX, posY, fbID, msg, funcLineID, tick, lastTransTick), curPlayer.GetPlayerID())
|
NotifyCode(curPlayer, "MapMoveCD")
|
return
|
curPlayer.SetDict(ChConfig.Def_PlayerKey_TransTick, tick)
|
|
mapID = FBCommon.GetRecordMapID(mapID)
|
fbLineIpyData = FBCommon.GetFBLineIpyData(mapID, funcLineID)
|
sceneMapID = mapID if not fbLineIpyData else fbLineIpyData.GetMapID()
|
|
# µØͼ·ÖÁ÷, ¼õÉÙµ¥µØͼѹÁ¦
|
FBMapShuntDict = ReadChConfig.GetEvalChConfig("FBMapShunt")
|
if mapID in FBMapShuntDict:
|
shuntList = FBMapShuntDict[mapID]
|
if shuntList:
|
sceneMapID = random.choice(shuntList)
|
GameWorld.DebugLog("µ¥È˵Øͼ·ÖÁ÷ sceneMapID=%s" % sceneMapID)
|
|
#´«ËÍʱ, Ëø¶¨Íæ¼Ò, ´«Ëͳɹ¦, ÔÚÄ¿±êµØͼ½âËø, ´«ËÍʧ°Ü, ÔÚ´«Ëͻص÷º¯ÊýPlayerChangeMapFailCallbackÖнâËø
|
if canLock:
|
curPlayer.BeginEvent()
|
|
#GameWorld.Log(1, "SetXP=%s"%(curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_RecordXPValue)))
|
#curPlayer.SetXP(curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_RecordXPValue))
|
#»ñÈ¡¸±±¾´«È븱±¾ÐèҪЯ´øµÄÐÅÏ¢
|
msg = FBLogic.GetPlayerResetWorldPosFBMsg(curPlayer, mapID, funcLineID)
|
|
NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_ReqFBMapID, mapID)
|
NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_ReqFBFuncLine, funcLineID)
|
GameWorld.Log("Íæ¼ÒÇëÇó¿ªÊ¼ÇÐͼ: sceneMapID=%s,posX=%s,posY=%s,fbID=%s,msg=%s,funcLineID=%s,tick=%s,lastTransTick=%s"
|
% (sceneMapID, posX, posY, fbID, msg, funcLineID, tick, lastTransTick), curPlayer.GetPlayerID())
|
if enterFBFree:
|
NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_EnterFBFree, 1)
|
GameWorld.DebugLog(" ±¾´ÎÃâ·Ñ½øÈ븱±¾!")
|
curPlayer.ResetWorldPosReq(sceneMapID, posX, posY, False, fbID, msg)
|
curPlayer.SetDict(ChConfig.Def_PlayerKey_ChangeMapID, sceneMapID)
|
curPlayer.SetDict(ChConfig.Def_PlayerKey_ChangeLineID, max(0, fbID))
|
|
#ÇеØͼ´¦ÀíÍæ¼ÒʱÖÓ¾ÀÕýÎÊÌ⣨ÐèҪһֱͨ¹ýÍæ¼ÒʱÖÓ¼ÆËãµÄ£©
|
RefreshPlayerTick(curPlayer)
|
NotifyPrepareChangeMap(curPlayer)
|
return
|
|
# ֪ͨ׼±¸Çл»µØͼ
|
def NotifyPrepareChangeMap(curPlayer):
|
curPlayer.SetVisible(False)
|
sendPack = ChPyNetSendPack.tagMCPrepareChangeMap()
|
sendPack.Clear()
|
sendPack.MapID = GameWorld.GetMapDataMapID(curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_ChangeMapID))
|
sendPack.FuncLineID = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_ReqFBFuncLine)
|
sendPack.FuncMapID = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_ReqFBMapID)
|
|
NetPackCommon.SendFakePack(curPlayer, sendPack)
|
GameWorld.Log("×¼±¸Çл»µØͼ", curPlayer.GetID())
|
return
|
|
# ֪ͨ¿ªÊ¼Çл»µØͼ
|
def NotifyStartChangeMap(curPlayer):
|
sendPack = ChPyNetSendPack.tagMCStartChangeMap()
|
sendPack.Clear()
|
sendPack.MapID = GameWorld.GetMapDataMapID(curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_ChangeMapID))
|
sendPack.FuncLineID = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_ReqFBFuncLine)
|
sendPack.FuncMapID = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_ReqFBMapID)
|
NetPackCommon.SendFakePack(curPlayer, sendPack)
|
|
GameWorld.Log("֪ͨ¿ªÊ¼Çл»µØͼ", curPlayer.GetID())
|
return
|
|
#---------------------------------------------------------------------
|
##Íæ¼Ò»»Ïß
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param changLineID Ïß·ID
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks Íæ¼Ò»»Ïß
|
def PlayerChangeLine(curPlayer, changLineID):
|
#---µØͼ·ÖÏß¼ì²é---
|
if GameWorld.GetGameWorld().GetLineID() == changLineID:
|
GameWorld.ErrLog('changLineID SameLine = %s' % (changLineID))
|
return
|
|
#---µØͼÊôÐÔ¼ì²é---
|
gameMap = GameWorld.GetMap()
|
|
#1. Ö»ÓÐÆÕͨµØͼ²ÅÄÜ»»Ïß
|
if gameMap.GetMapFBType() != IPY_GameWorld.fbtNull:
|
#GeRen_liubo_180377 <n color="0,255,0">¶Ô²»Æð£¬Ä¿Ç°¸ÃµØͼûÓпª·Å·ÖÁ÷£¬ÎÞ·¨Çл»Ïß·!</n> 256 -
|
NotifyCode(curPlayer, "GeRen_liubo_180377")
|
return
|
|
#2. »»ÏßµÄÄ¿µÄµØ±ØÐë´æÔÚ
|
if changLineID >= gameMap.GetMaxFbCount():
|
GameWorld.ErrLog("»»ÏßµÄÄ¿µÄµØ²»´æÔÚ = %s, %s" % (changLineID, gameMap.GetMaxFbCount()), curPlayer.GetID())
|
return
|
NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_PlayChangeLineID, changLineID + 1)
|
NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FuncChangeLineID, 0)
|
NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_HighChangeLineID, 0)
|
|
#---¿ªÊ¼Çл»Ïß·---
|
PlayerResetWorldPosFB(curPlayer, curPlayer.GetMapID(), curPlayer.GetPosX(), curPlayer.GetPosY(), changLineID)
|
|
GameWorld.Log('Íæ¼Ò = %s Çл»·ÖÏß = %s, Ëøס' % (curPlayer.GetName(), changLineID), curPlayer.GetID())
|
return
|
|
#---------------------------------------------------------------------
|
##Íæ¼ÒÇл»µØͼ
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param mapID µØͼID
|
# @param posX ×ø±êX
|
# @param posY ×ø±êY
|
# @param lineID Ïß·ID -1´ú±íµ±Ç°Ïß
|
# @param msg Çл»µØͼЯ´øµÄÐÅÏ¢
|
# @param canLock ÊÇ·ñ¿ÉÒÔËø¶¨Íæ¼Ò(´«Ë͵㲻¿ÉËø¶¨, ÒòΪҪ¿çµØͼѰ·)
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks Íæ¼ÒÇл»µØͼ
|
def PlayerResetWorldPos(curPlayer, mapID, posX, posY, lineID=-1, msg='', canLock=True, exData1=0):
|
#¸ü¸Ä: ËÀÍöÔÊÐíÇл»µØͼ, ÔÚ¸±±¾Öб»¹Ö´òËÀ, ¸±±¾Ê±¼äµ½, »ØÊÕ¸±±¾
|
# if GameObj.GetHP(curPlayer) <= 0 :
|
# GameWorld.Log("ËÀÍöÎÞ·¨Çл»µØͼ")
|
# return
|
|
gameWorld = GameWorld.GetGameWorld()
|
shuntLineID = GetResetWorldPosShuntLineID(curPlayer, gameWorld.GetMapID(), gameWorld.GetLineID(), mapID, lineID, exData1) # ·ÖÁ÷Ïß·ID
|
GameWorld.DebugLog("·ÖÁ÷ mapID=%s,lineID=%s,shuntLineID=%s" % (mapID, lineID, shuntLineID), curPlayer.GetPlayerID())
|
|
#---ͬµØͼID, ͬ·ÖÏß, ½öÇл»×ø±ê---
|
#lingID = -1, ´ú±íĬÈϵ±Ç°Ïß, ÈçÖ÷³Ç2´«Ëͽ£×Ú, µ½´ï½£×Ú2
|
if gameWorld.GetMapID() == mapID and (shuntLineID == -1 or gameWorld.GetLineID() == shuntLineID):
|
if exData1:
|
#bossµÄÓÃmove£¬Í¨ÖªÇ°¶Ë£¬ÓÉÇ°¶Ë·¢Æðmove
|
ChPlayer.NotifyPlayerMove(curPlayer, posX, posY, exData1)
|
else:
|
#ÖØÖÃ×ø±ê
|
GameWorld.ResetPlayerPos(curPlayer, posX, posY)
|
#@bug: ÔÚ°Ú̯Çø¿ìËÙ´«ËÍÖÁ·Ç°Ú̯Çø, ¿ÉÒÔ°Ú̯, ÕâÀïË¢ÐÂһϳ¡¾°Buff
|
SkillShell.ProcessMapBuff(curPlayer, GameWorld.GetGameWorld().GetTick())
|
return
|
|
#---²»Í¬µØͼIDÇл»µØͼ---
|
PlayerResetWorldPosFB(curPlayer, mapID, posX, posY, shuntLineID, msg, canLock)
|
|
#Èç¹ûÊÇ·þÎñÆ÷ÖÐ×îºóÒ»¸öÈËÀ뿪, Ôò¹Øµô¸±±¾
|
GameWorldProcess.OnPlayerLeaveMapCloseFB()
|
return
|
|
def GetResetWorldPosShuntLineID(curPlayer, curMapID, curLineID, tagMapID, tagLineID, bossID=0):
|
'''»ñÈ¡ÇÐͼÏß·ID
|
ÇÐÏßÓÐÈýÖÖÇé¿ö
|
1. Íæ¼ÒÊÖ¶¯Çл»Ïß·£¬ÓÅÏȼ¶×î¸ß
|
¼Ç¼key Def_Player_Dict_PlayChangeLineID£¬ ÀëÏß³¬¹ý±£»¤Ê±¼äºóÖØÖã¬È·±£¶ÏÏßÖØÁ¬Õý³£¼´¿É
|
|
2. ¹¦ÄÜÇл»µ½Ö¸¶¨Ïß·£¬Èç´òboss¡¢´«Ë͵½Ä¿±êÍæ¼ÒÏß·£¨±»»÷ɱÇйýÈ¥°ï棩
|
¼Ç¼key Def_Player_Dict_FuncChangeLineID£¬ ÀëÏß³¬¹ý±£»¤Ê±¼äºóÖØÖã¬È·±£¶ÏÏßÖØÁ¬Õý³£¼´¿É
|
|
3. ³£¹æÇÐͼ
|
Ïß·ѡÔñÓÅÏȼ¶: ÊÖ¶¯ÇÐÏ߼Ǽ > ¹¦ÄÜÇÐÏ߼Ǽ > ¸ßµÍÇÐÏ߼Ǽ > ϵͳ·ÖÁ÷ÇÐÏß¹æÔò
|
|
ϵͳ·ÖÁ÷ÇÐÏß¹æÔò: µ±Ç°µØͼÏß· ¶ÔÓ¦ Ä¿±êµØͼÏß·ÈËÊý Èç¹ûµ½´ï¶î¶¨Öµ²Å½øÐзÖÁ÷£¬·ÖÁ÷µ½ÈËÊý½ÏÉÙµÄÏß·
|
|
ÌØÊâboss·ÖÁ÷:
|
@param bossID: ·ÖÁ÷bossID
|
'''
|
if GameWorld.IsCrossServer():
|
return tagLineID
|
# ·Ç³£¹æµØͼ֮¼äµÄÇл»²»´¦Àí
|
if curMapID not in PyGameData.g_commMapLinePlayerCountDict or tagMapID not in PyGameData.g_commMapLinePlayerCountDict:
|
return tagLineID
|
tagLinePlayerCountDict = PyGameData.g_commMapLinePlayerCountDict[tagMapID] # ´Ë·ÖÏß°üº¬ËùÓзÖÏߣ¬º¬Î´¿ª·ÅµÄ¼°»î¶¯·ÖÏß
|
|
if bossID and tagMapID != ChConfig.Def_FBMapID_BossHome:
|
tagLineID = 0 # BossµÄ»°Î´·ÖÁ÷Ç°ÏÈÇ¿ÖÆ1Ïߣ¬¼´Îª0
|
playerID = curPlayer.GetPlayerID()
|
playChangeLineID = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_PlayChangeLineID)
|
funcChangeLineID = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FuncChangeLineID)
|
highChangeLineID = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_HighChangeLineID)
|
|
GameWorld.DebugLog("´¦Àí·ÖÁ÷,curMapID=%s,curLineID=%s,tagMapID=%s,tagLineID=%s,bossID=%s"
|
% (curMapID, curLineID, tagMapID, tagLineID, bossID), playerID)
|
# ÓÐÖ¸¶¨Ïß·£¬Ö±½Ó·µ»Ø£¬²»·ÖÁ÷
|
if tagLineID != -1:
|
# »¹Ã»Ö¸¶¨·ÖÏ߼ǼµÄÔòÒª¼Ç¼£¬ÒѾ¼Ç¼¹ýµÄ²»Öظ´¼Ç¼£¬Ö±µ½Ï´λص½ÔÏß·ºó²ÅÖØÖÃ0
|
if not playChangeLineID and not funcChangeLineID and not highChangeLineID:
|
NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FuncChangeLineID, curLineID + 1)
|
GameWorld.DebugLog("¹¦ÄÜÖ¸¶¨Çл»Ä¿±êÏß·£¬¼Ç¼µ±Ç°Ïß·ºóÐøÇÐÏß±¸ÓÃ! curLineID=%s,tagLineID=%s" % (curLineID, tagLineID), playerID)
|
|
if bossID and NPCCommon.IsMapNeedBossShunt(tagMapID):
|
bossShuntLineID = __GetBossShuntLineID(curPlayer, curMapID, curLineID, tagMapID, bossID, tagLinePlayerCountDict.keys())
|
if bossShuntLineID != -1:
|
tick = GameWorld.GetGameWorld().GetTick()
|
GameWorld.DebugLog("·ÖÁ÷boss, bossID=%s,bossShuntLineID=%s" % (bossID, bossShuntLineID), playerID)
|
NPCCommon.AddBossShuntRelatedPlayer(curPlayer, tagMapID, bossShuntLineID, bossID, tick)
|
return bossShuntLineID
|
return tagLineID
|
|
if curMapID == tagMapID:
|
GameWorld.DebugLog("ͬµØͼÇл»×ø±ê²»´¦Àí·ÖÁ÷£¡", playerID)
|
return tagLineID
|
|
# ¿ÉÒÔÓÃÀ´³£¹æ·ÖÁ÷µÄÏß·ÈËÊý×ÖµäÐÅÏ¢, ²¢²»ÊÇËùÓÐÏß·¶¼¿ÉÒÔÓÃÀ´×öÈËÊý·ÖÁ÷µÄ£¬±ÈÈçÖÐÁ¢µØͼÓжàÌõÏßÓÃÀ´·ÖÁ÷boss£¬µ«ÊÇÖ»ÓÐ1ÌõÏß¿ÉÓÃÀ´×ö³£¹æµÄÈËÊý·ÖÁ÷
|
mapLineDict = IpyGameDataPY.GetFuncCfg("MapLine", 1)
|
if tagMapID in mapLineDict:
|
tagMapMaxLine = mapLineDict[tagMapID]
|
tagLinePlayerCountShuntDict = {}
|
for k, v in tagLinePlayerCountDict.items():
|
if k >= tagMapMaxLine:
|
continue
|
tagLinePlayerCountShuntDict[k] = v
|
else:
|
tagLinePlayerCountShuntDict = tagLinePlayerCountDict
|
tagMapMaxLine = len(tagLinePlayerCountShuntDict)
|
GameWorld.DebugLog("Ä¿±êµØͼ¿ÉÓ÷ÖÁ÷Ïß·ÈËÊýÐÅÏ¢: tagMapID=%s,%s" % (tagMapID, tagLinePlayerCountShuntDict))
|
|
# ÓÐÖ÷¶¯Çл»¹ý
|
if playChangeLineID and playChangeLineID <= len(tagLinePlayerCountShuntDict):
|
GameWorld.DebugLog("ÓÐÖ÷¶¯Çл»¹ýÏß·!playChangeLineID=%s" % playChangeLineID, playerID)
|
return playChangeLineID - 1
|
|
# ¹¦ÄÜÓÐÖ¸¶¨Ïß·¹ý
|
if funcChangeLineID and funcChangeLineID <= len(tagLinePlayerCountShuntDict):
|
GameWorld.DebugLog("¹¦ÄÜÓÐÖ¸¶¨¹ýÏß·ÀúÊ·Ïß·,funcChangeLineID=%s" % funcChangeLineID, playerID)
|
NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FuncChangeLineID, 0) # ´¥·¢»ØÔÏß·ºóÖØÖÃ
|
return funcChangeLineID - 1
|
|
# ÓиßÏßÇеÍÏ߼Ǽ
|
if highChangeLineID and highChangeLineID <= len(tagLinePlayerCountShuntDict):
|
GameWorld.DebugLog("ÓиßÏßÇеÍÏßÀúÊ·Ïß·,highChangeLineID=%s" % highChangeLineID, playerID)
|
NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_HighChangeLineID, 0) # ´¥·¢»ØÔÏß·ºóÖØÖÃ
|
return highChangeLineID - 1
|
|
if curLineID not in tagLinePlayerCountShuntDict:
|
GameWorld.DebugLog("Ä¿±êµØͼ²»´æÔÚ¸ÃÏß·,curLineID=%s" % curLineID, playerID)
|
shuntLineID = __GetShuntLineID(curPlayer, tagMapID, tagLinePlayerCountShuntDict)
|
|
# Èç¹ûûÓд¥·¢·ÖÁ÷£¬ÔòÐè¼Ç¼Íæ¼Ò´Ó¸ßÏß·µØͼÇл»µ½µÍÏß·µØͼʱµÄ¸ßÏß·ID
|
if shuntLineID == -1 and not playChangeLineID and not funcChangeLineID and not highChangeLineID:
|
NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_HighChangeLineID, curLineID + 1)
|
GameWorld.DebugLog("¸ßÏßÇеÍÏߣ¬¼Ç¼µ±Ç°Ïß·ºóÐøÇÐÏß±¸ÓÃ! curLineID=%s,tagLineID=%s" % (curLineID, tagLineID), playerID)
|
|
else:
|
shuntLineID = __GetShuntLineID(curPlayer, tagMapID, tagLinePlayerCountShuntDict, curLineID)
|
|
if shuntLineID == -1 and (curLineID + 1) > tagMapMaxLine:
|
shuntLineID = tagMapMaxLine - 1
|
GameWorld.DebugLog("³£¹æ·ÖÁ÷ºóµÄlineIDΪ-1£¬µ«ÊÇÄ¿±êµØͼµ±Ç°Ïß·²»¿ÉÓ㡲»¿É´«Ë͵½¸ÃÏß·£¡curLineID=%s + 1 > tagMapMaxLine(%s), Ç¿ÖÆ·ÖÁ÷µ½Ïß·(shuntLineID=%s)"
|
% (curLineID, tagMapMaxLine, shuntLineID))
|
|
return shuntLineID
|
|
def __GetShuntLineID(curPlayer, tagMapID, tagLinePlayerCountShuntDict, curLineID=None):
|
# ÒÔÏÂ×ßϵͳ×Ô¶¯·ÖÁ÷Âß¼
|
playerID = curPlayer.GetPlayerID()
|
if curPlayer.GetLV() > IpyGameDataPY.GetFuncCfg("SetWorldPosShunt", 2):
|
GameWorld.DebugLog("³¬¹ýÖ¸¶¨µÈ¼¶²»·ÖÁ÷", playerID)
|
return -1
|
|
mapShuntDict = IpyGameDataPY.GetFuncEvalCfg("SetWorldPosShunt", 1) # {mapID:ÈËÊý, ...}
|
if tagMapID not in mapShuntDict:
|
GameWorld.DebugLog("Ä¿±êµØͼ²»ÐèÒª·ÖÁ÷", playerID)
|
return -1
|
lineMaxPlayerCount = mapShuntDict[tagMapID]
|
|
if curLineID != None:
|
tagLinePlayerCount = tagLinePlayerCountShuntDict[curLineID]
|
if tagLinePlayerCount < lineMaxPlayerCount:
|
GameWorld.DebugLog("δ´ïµ½¶î¶¨ÈËÊýÖµ,²»Ó÷ÖÁ÷,curLineID=%s,Ä¿±êµØͼµ±Ç°Ïß·ÈËÊý: %s/%s"
|
% (curLineID, tagLinePlayerCount, lineMaxPlayerCount), playerID)
|
return -1
|
|
# ·ÖÁ÷µ½ÈËÊý½ÏÉÙµÄÏß·
|
linePlayerList = [[playerCount, lineID] for lineID, playerCount in tagLinePlayerCountShuntDict.items()]
|
linePlayerList.sort() # ÉýÐòÅÅ, ÔòË÷Òý0µÄÏß·Ϊ×î¼ÑÑ¡Ôñ
|
shuntLineID = linePlayerList[0][1]
|
GameWorld.DebugLog("·ÖÁ÷µ½ÈËÊý½ÏÉÙµÄÏß·,tagMapID=%s,linePlayerList[count,lineID]=%s" % (tagMapID, linePlayerList), playerID)
|
return shuntLineID
|
|
def __GetBossShuntLineID(curPlayer, curMapID, curLineID, tagMapID, npcID, lineIDList):
|
'''»ñÈ¡Ä¿±êµØͼboss·ÖÁ÷Ïß·
|
¸ù¾ÝÈËÊý·ÖÁ÷Íæ¼Ò£¬ÓÅÏÈ·ÖÅäµ½»î×ŵÄÏß·
|
¶ÓÎéĬÈÏ·ÖÅäµ½¶ÓÎé¶ÓÔ±¶àµÄÄÇÌõÏß
|
ÐÖúĬÈÏ·ÖÅ䵽Ŀ±êÍæ¼ÒÏß·£¬ÓÅÏȼ¶×î¸ß
|
|
Ç°¶Ë£º
|
1.ÔÚÖÐÁ¢µØͼµÄʱºò£¬ÏÔʾµ±Ç°Ïß·BOSSµÄ״̬
|
2.ÔÚ³£¹æµØͼµÄʱºò£¬ÏÔʾÍæ¼Ò»÷ɱBOSSµÄCDʱ¼ä
|
3.±¾µØͼ²»»»Ïߣ¬60Ãë¹æÔò±£³Ö²»±ä
|
4.½øÈëBOSSÇøÓòÀˢÐÂBOSS״̬
|
|
Íæ¼ÒÔÚ·ÇÖÐÁ¢µØͼ£º
|
±¾µØͼ²»»»Ïߣ¬60Ãë¹æÔò±£³Ö²»±ä£¨£©
|
|
Íæ¼ÒÔÚÖÐÁ¢µØͼ
|
ûÓÐ60Ãë¹æÔò
|
Ö±½Ó·¢´«ËÍ°ü£¬Óɺó¶Ë¾ö¶¨£¨ÓжÓÔ±ÔÚ²»Í¬Ïß·´òͬһֻboss£¬Ôò´«ËÍ£¬·ñÔòmove£©
|
'''
|
playerID = curPlayer.GetPlayerID()
|
playerTeamID = curPlayer.GetTeamID()
|
|
hurtTeamLineID = -1
|
hurtTeamMemCount = -1
|
|
bossLinePlayerDict = {1:[-1, []], 0:[-1, []]} # {ÊÇ·ñ±»»÷ɱ:[¸Ã״̬ÈËÊý¿ÕµÄÏß·, [[Íæ¼ÒÊý, Ïß·], ...]], ...}
|
|
bossLineStateDict = PyGameData.g_bossShuntLineState.get(npcID, {})
|
|
haveAliveLine = False # ÊÇ·ñÓлî×ŵÄÏß·
|
activityMapLineDict = IpyGameDataPY.GetFuncEvalCfg("MapLine", 2, {})
|
|
GameWorld.DebugLog("Íæ¼Òboss·ÖÁ÷: playerTeamID=%s,tagMapID=%s,npcID=%s,lineIDList=%s,bossLineStateDict=%s,g_bossShuntPlayerInfo=%s"
|
% (playerTeamID, tagMapID, npcID, lineIDList, bossLineStateDict, PyGameData.g_bossShuntPlayerInfo), playerID)
|
if tagMapID in activityMapLineDict:
|
activityLineID = max(0, activityMapLineDict[tagMapID] - 1)
|
# ·Ç1ÏߵĻÏß·²»²ÎÓë·ÖÁ÷
|
if activityLineID != 0 and activityLineID in lineIDList:
|
lineIDList.remove(activityLineID)
|
GameWorld.DebugLog(" ·Ç1ÏߵĻÏß·²»²ÎÓë·ÖÁ÷: activityLineID=%s,lineIDList=%s" % (activityLineID, lineIDList), playerID)
|
|
assistTagPlayerID = GetAssistTagPlayerID(curPlayer)
|
for lineID in lineIDList:
|
key = (tagMapID, lineID)
|
# boss·ÖÁ÷Íæ¼ÒÐÅÏ¢{(mapID, lineID):{playerID:[bossID, teamID, relatedTick], ...}, ...}
|
shuntPlayerDict = PyGameData.g_bossShuntPlayerInfo.get(key, {})
|
if assistTagPlayerID and assistTagPlayerID in shuntPlayerDict:
|
GameWorld.DebugLog(" ·ÖÁ÷µ½ÐÖúÄ¿±êÍæ¼ÒÏß· assistTagPlayerID=%s,lineID=%s" % (assistTagPlayerID, lineID), playerID)
|
return lineID
|
playerCount = 0
|
teamPlayerCount = 0
|
for shuntPlayerID, shuntInfo in shuntPlayerDict.items():
|
bossID = shuntInfo[0]
|
if npcID != bossID:
|
continue
|
playerCount += 1
|
shuntTeamID = shuntInfo[1]
|
if playerTeamID and playerTeamID == shuntTeamID and shuntPlayerID != playerID:
|
teamPlayerCount += 1
|
|
if teamPlayerCount and teamPlayerCount > hurtTeamMemCount:
|
hurtTeamMemCount = teamPlayerCount
|
hurtTeamLineID = lineID
|
|
lineIsAlive = bossLineStateDict.get(lineID, 0)
|
lineBossIsDead = 1 if not lineIsAlive else 0 # µ±Ç°Ïß·bossÊÇ·ñËÀÍö
|
emptyLineID, linePlayerCountList = bossLinePlayerDict[lineBossIsDead]
|
if not playerCount and emptyLineID == -1:
|
emptyLineID = lineID
|
linePlayerCountList.append([playerCount, lineID])
|
bossLinePlayerDict[lineBossIsDead] = [emptyLineID, linePlayerCountList]
|
|
if not lineBossIsDead:
|
haveAliveLine = True
|
|
GameWorld.DebugLog(" lineID=%s,lineBossIsDead=%s,playerCount=%s,teamPlayerCount=%s,hurtTeamMemCount=%s,hurtTeamLineID=%s"
|
% (lineID, lineBossIsDead, playerCount, teamPlayerCount, hurtTeamMemCount, hurtTeamLineID), playerID)
|
|
if hurtTeamLineID >= 0:
|
GameWorld.DebugLog(" ·ÖÁ÷µ½¶ÓÓÑÈËÊý¶àµÄÏß· hurtTeamLineID=%s" % hurtTeamLineID, playerID)
|
return hurtTeamLineID
|
|
if curMapID == tagMapID and curMapID in IpyGameDataPY.GetFuncEvalCfg("MapLine", 4):
|
GameWorld.DebugLog(" ÖÐÁ¢µØͼÔÚ±¾µØͼÖÐĬÈϵ±Ç°Ïß· curLineID=%s" % curLineID, playerID)
|
return curLineID
|
|
shuntBossIsDead = 0 if haveAliveLine else 1 # ÓÅÏÈ·ÖÁ÷µ½»î×ŵÄÏß·
|
GameWorld.DebugLog(" boss״̬¶ÔÓ¦Ïß·ÈËÊý: haveAliveLine=%s, ״̬key0Ϊ»î×Å: %s" % (haveAliveLine, bossLinePlayerDict))
|
emptyLineID, linePlayerCountList = bossLinePlayerDict[shuntBossIsDead]
|
linePlayerCountList.sort() # ÉýÐò
|
playerCount, minPlayerCntLineID = linePlayerCountList[0]
|
bossShuntPlayerCountMax = IpyGameDataPY.GetFuncCfg("BossShunt", 2)
|
if playerCount >= bossShuntPlayerCountMax and emptyLineID >= 0:
|
GameWorld.DebugLog(" ·ÖÁ÷µ½¿ÕÐÂÏß· shuntBossIsDead=%s,emptyLineID=%s" % (shuntBossIsDead, emptyLineID), playerID)
|
return emptyLineID
|
|
GameWorld.DebugLog(" ·ÖÁ÷µ½ÈËÊý×îÉÙµÄÏß· shuntBossIsDead=%s,minPlayerCntLineID=%s,linePlayerCountList=%s"
|
% (shuntBossIsDead, minPlayerCntLineID, linePlayerCountList), playerID)
|
return minPlayerCntLineID
|
|
#---------------------------------------------------------------------
|
##È¡ºÏ·¨ÖØÉúµã
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param posX ÖØÉúµãx×ø±ê
|
# @param posy ÖØÉúµãy×ø±ê
|
# @param round ÖØÉúµã·¶Î§
|
# @return ÖØÉúµã(×ø±êx£¬ ×ø±êy)
|
# @remarks
|
def __GetLegitRebornPoint(curPlayer, posX, posY, round):
|
rebornPosX = 0
|
rebornPosY = 0
|
|
curMapID = curPlayer.GetMapID()
|
|
gameMap = GameWorld.GetMap()
|
|
#Ìí¼Ó×ø±êµãÒì³£¼ì²é(ÖØÉúµã×ø±ê³¬¹ýµØͼ±ß½ç)
|
if not gameMap.IsValidPos(posX, posY):
|
GameWorld.ErrLog('ÖØÉúµãÒì³££¬³¬¹ýµØͼ(%s)±ß½ç posX = %s, posY = %s, round = %s' \
|
% (curMapID, posX, posY, round))
|
|
else:
|
# Ëæ»úÈ¡µ½·ÇÕÏ°µã
|
rebornPosX, rebornPosY = GameMap.GetNearbyPosByDis(posX, posY, round)
|
|
#²¼µÄÖØÉúµã·¶Î§ÄÚÕÒ²»µ½·ÇÕÏ°µã
|
if rebornPosX <= 0 or rebornPosY <= 0:
|
GameWorld.Log("ÖØÉúµã·¶Î§ÄÚÕÒ²»µ½¸ÃµØͼ(%s)µÄ·ÇÕÏ°ÖØÉúµã posX = %s, posY = %s, round = %s" % \
|
(curMapID, posX, posY, round), curPlayer.GetPlayerID())
|
|
return (rebornPosX, rebornPosY)
|
|
|
#---------------------------------------------------------------------
|
##Ë¢ÐÂÍæ¼ÒµÄÖØÉúµãÐÅÏ¢
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param tick ʱ¼ä´Á
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks Ë¢ÐÂÍæ¼ÒµÄÖØÉúµãÐÅÏ¢
|
def RefreshRebornPoint(curPlayer, tick):
|
#---¸´»îµãË¢ÐÂÅжÏ˳Ðò1.µØͼ²¼¸´»îµã 2.tagChinMap.txtÄÚ¸´»îµã 3.´´½¨½ÇÉ«³õʼ³öÉúµã---
|
|
gameMap = GameWorld.GetMap()
|
|
# ³õʼ»¯ÖØÉúµØͼΪµ±Ç°Íæ¼ÒËùÔÚµØͼ
|
rebornMapID = curPlayer.GetMapID()
|
rebornPosX = curPlayer.GetRebornPosX()
|
rebornPosY = curPlayer.GetRebornPosY()
|
|
#---µØͼÉϲ¼µÄÖØÉúµãÅжÏ---
|
|
# µØͼÉÏÊÇ·ñÓв¼¸´»îˢеã
|
hasBornRefreshPoint = True
|
|
gameData = GameWorld.GetGameData()
|
bornRefreshCount = gameData.GetBornRefreshCount()
|
|
#Ò»°ãµØͼ²¼µÄÖØÉúµãÁбí,¸ù¾Ý¹ú¼®É¸Ñ¡
|
bornList = []
|
#¸±±¾µØͼ²¼µÄÖØÉúµãÁбí,²»É¸Ñ¡
|
fbBornList = []
|
|
# ûÓв¼ÖØÉúµã
|
if not bornRefreshCount:
|
GameWorld.Log("´ËµØͼûÓÐÖØÉúµã", curPlayer.GetPlayerID())
|
hasBornRefreshPoint = False
|
else:
|
#´´½¨ÖØÉúµãÁбí
|
for i in range(0, bornRefreshCount):
|
bornRefreshPoint = gameData.GetBornRefreshByIndex(i)
|
fbBornList.append(i)
|
|
if GameWorld.IsSameCountry(curPlayer, bornRefreshPoint):
|
bornList.append(i)
|
|
if not bornList:
|
GameWorld.Log("´ËµØͼûÓкÏÊÊÍæ¼ÒµÄÖØÉúµã", curPlayer.GetPlayerID())
|
hasBornRefreshPoint = False
|
|
#---¸ÃµØͼÓв¼ÖØÉúˢеã---
|
if hasBornRefreshPoint:
|
# Ëæ»ú»ñÈ¡ÖØÉúˢеã
|
bornIndex = random.choice(bornList)
|
bornRefreshPoint = gameData.GetBornRefreshByIndex(bornIndex)
|
|
bRP_PosX = bornRefreshPoint.GetPosX()
|
bRP_PosY = bornRefreshPoint.GetPosY()
|
bRP_RoundPos = bornRefreshPoint.GetRound()
|
|
rebornPosX, rebornPosY = __GetLegitRebornPoint(curPlayer, bRP_PosX, bRP_PosY, bRP_RoundPos)
|
|
#²¼µÄÖØÉúµã·¶Î§ÄÚÕÒ²»µ½ºÏ·¨ÖØÉúµã
|
if rebornPosX <= 0 or rebornPosY <= 0 or rebornMapID <= 0:
|
GameWorld.Log("µØͼÉϲ¼µÄÖØÉúµã·¶Î§ÄÚÕÒ²»µ½¸ÃµØͼ(%s)µÄºÏ·¨ÖØÉúµã" \
|
% curPlayer.GetMapID(), curPlayer.GetPlayerID())
|
# Òì³££¬Éè±ê־ΪFalse,´ÓtagChinMap.txt±íÄÚÕÒ¸´»îµã
|
hasBornRefreshPoint = False
|
|
# ÔÚtagChinMap.txt±íÄÚÊÇ·ñÄÜÕÒµ½¸´»îµã
|
hasBornPointInTxt = True
|
|
#---¸ÃµØͼûÓÐÖØÉúˢе㣬´ÓtagChinMap.txt±íÄÚÕÒ¸´»îµã---
|
if not hasBornRefreshPoint:
|
rebornMapID = gameMap.GetRebornMapID()
|
rebornPosX = gameMap.GetRebornMapX()
|
rebornPosY = gameMap.GetRebornMapY()
|
|
#ÑéÖ¤ÊÇ·ñ±¾µØͼ¸´»îµã ½øÐÐÂß¼´¦Àí, ·Ç±¾µØͼ¸´»îµãÎÞ·¨Åжϣ¬ ÒªÇó²ß»®Ò»¶¨ÅäÖÃÕýÈ·
|
if gameMap.GetMapID() == rebornMapID:
|
# Ëæ»úÈ¡µ½·ÇÕÏ°µã
|
rebornPosX, rebornPosY = __GetLegitRebornPoint(curPlayer, \
|
rebornPosX, rebornPosY, ChConfig.Def_RebornPos_Area_Range)
|
|
#tagChinMap.txt±íÉÏÕÒ²»µ½ºÏ·¨ÖØÉúµã
|
if rebornPosX <= 0 or rebornPosY <= 0 or rebornMapID <= 0:
|
GameWorld.Log("tagChinMap.txtÄÚÕÒ²»µ½¸ÃµØͼ(%s)µÄºÏ·¨ÖØÉúµã" \
|
% curPlayer.GetMapID(), curPlayer.GetPlayerID())
|
hasBornPointInTxt = False
|
|
#---ÔÚtagChinMap.txt±íÄÚÒ²ÕÒ²»µ½¸´»îµã,Ö±½ÓÖØÖõ½´´½¨½ÇɫʱµÄ³õʼµã---
|
if not hasBornPointInTxt:
|
curPlayerJob = curPlayer.GetJob()
|
|
#´´½¨Íæ¼ÒλÖöÁ±í{ Ö°Òµ:[(map,x,y),(map1,x1,y1)..] }
|
posList = ReadChConfig.GetEvalChConfig('Player_Reborn_Place')
|
|
pos = random.choice(posList[curPlayerJob])
|
rebornMapID = pos[0]
|
bornRange = 1
|
rebornPosX = pos[2] + random.randint(-bornRange, bornRange)
|
rebornPosY = pos[3] + random.randint(-bornRange, bornRange)
|
GameWorld.Log("""tagBornRefresh.txtºÍtagChinMap.txtÄÚ¶¼ÕÒ²»µ½¸ÃµØͼ(%s)
|
µÄºÏ·¨ÖØÉúµã£¬ÉèÖÃÍæ¼ÒÖØÉúµãΪ´´½¨½ÇɫʱµÄ³õʼµã%s-(%s,%s)""" % \
|
(curPlayer.GetMapID(), rebornMapID, rebornPosX, rebornPosY), curPlayer.GetPlayerID())
|
|
#Íæ¼Ò²»ÔÚ¸±±¾ÖÐ
|
if gameMap.GetMapFBType() == IPY_GameWorld.fbtNull:
|
# ÉèÖÃÒ»°ãµØͼÖØÉúµã
|
curPlayer.SetRebornMapID(rebornMapID)
|
curPlayer.SetRebornPosX(rebornPosX)
|
curPlayer.SetRebornPosY(rebornPosY)
|
GameWorld.Log("Íæ¼Ò%s,ÉèÖÃĬÈÏÖØÉúµãÍê±Ï mapID = %s-(%s,%s)" % (curPlayer.GetPlayerName(), rebornMapID, rebornPosX, rebornPosY), curPlayer.GetPlayerID())
|
return
|
|
#===============================================================================
|
# #´å³¤¼ÒµÄµØͼID
|
# cunZhangJiaMapID = 21
|
#
|
# #ÓÐÖØÉúµã
|
# #ÐÂÊÖ³¡ÅÂÍæ¼Ò¿¨ËÀÕÏ°µã£¬ÉèÖÃΪµ±Ç°×ø±ê
|
# if curPlayerMapID == cunZhangJiaMapID:
|
# curPlayer.SetRebornMapID( curPlayerMapID )
|
# curPlayer.SetRebornPosX( curPlayer.GetPosX() )
|
# curPlayer.SetRebornPosY( curPlayer.GetPosY() )
|
# return
|
#
|
# #À뿪ÐÂÊÖ³¡¾°ºó£¬ÖØÖÃÒ»´ÎÖØÉúµã£¬·ÀÖ¹Íæ¼ÒÔٻص½ÐÂÊÖ³¡¾°
|
# if curPlayerRebornMapID == cunZhangJiaMapID:
|
# curPlayer.SetRebornMapID( curPlayerMapID )
|
# curPlayer.SetRebornPosX( bornX )
|
# curPlayer.SetRebornPosY( bornY )
|
# return
|
#===============================================================================
|
|
#ÏÈÉèÖÃĬÈϵĸ±±¾ÖØÉúµã
|
curPlayer.SetFBRebornMapID(rebornMapID)
|
curPlayer.SetFBRebornPosX(rebornPosX)
|
curPlayer.SetFBRebornPosY(rebornPosY)
|
GameWorld.Log("Íæ¼Ò%s,ÉèÖø±±¾Ä¬ÈÏÖØÉúµãÍê±Ï mapID = %s-(%s,%s)" % (curPlayer.GetPlayerName(), rebornMapID, rebornPosX, rebornPosY), curPlayer.GetPlayerID())
|
|
# ÌØÊ⸱±¾¸´»îµãÂß¼
|
FBLogic.OnRebornPlace(curPlayer, fbBornList)
|
return
|
|
#---------------------------------------------------------------------
|
##»ñÈ¡¾ôλ
|
# @param curLV µÈ¼¶
|
# @return ·µ»ØÖµ, ¾ôλµÈ¼¶
|
# @remarks »ñÈ¡¾ôλ
|
def GetRank(curLV):
|
if curLV > 0 and curLV < 21:
|
return 1
|
else:
|
return (curLV - 1) / 10
|
|
#---------------------------------------------------------------------
|
##»ñµÃÖ¸¶¨·½Î»ÄÚ¶ÓÎé³ÉÔ±Áбí
|
# @param curTeam ¶ÓÎéʵÀý
|
# @param centerX ÆðµãX
|
# @param centerY ÆðµãY
|
# @param area ·¶
|
# @return ·µ»ØÖµ, ³ÉÔ±Áбí
|
# @remarks »ñµÃÖ¸¶¨·½Î»ÄÚ¶ÓÎé³ÉÔ±Áбí
|
def GetAreaTeamMember(curTeam, centerX, centerY, area=ChConfig.Def_Team_GetExpScreenDist, isLog=False):
|
playerlist = list()
|
|
if curTeam == None:
|
GameWorld.ErrLog("»ñÈ¡¶ÓÎéÇøÓò³ÉÔ±£¬¶ÓÎé²»´æÔÚ£¡")
|
return playerlist
|
|
playerIDList = []
|
#if isLog:
|
# GameWorld.Log("GetAreaTeamMember,teamID=%s,centerX=%s,centerY=%s,area=%s" % (curTeam.GetTeamID(), centerX, centerY, area))
|
|
#±éÀú¶ÓÎé,°ë¾¶ÎªÒ»ÆÁ°ëµÄ¾àÀëÄÚµÄËùÓжÓÎé/ÍŶӳÉÔ±£¬¿ÉÒÔ»ñµÃ¾Ñé
|
for i in range(0, curTeam.GetMemberCount()):
|
curTeamPlayer = curTeam.GetMember(i)
|
if curTeamPlayer == None or curTeamPlayer.GetPlayerID() == 0:
|
#if isLog:
|
# GameWorld.Log(" i=%s,³ÉÔ±²»´æÔÚ!" % (i))
|
continue
|
|
if GameObj.GetHP(curTeamPlayer) <= 0:
|
#if isLog:
|
# GameWorld.Log(" i=%s,³ÉԱѪÁ¿Îª0!playerID=%s" % (i, curTeamPlayer.GetPlayerID()))
|
continue
|
|
#===========================================================================================
|
# # ¶ÓÎéÒÑÓÉÿÌõÐéÄâÏß·¶À×Ô¹ÜÀí£¬´Ë´¦¿É²»ÔÙÅжÏ
|
# if curTeamPlayer.GetCopyMapID() != GameWorld.GetGameWorld().GetCopyMapID():
|
# if isLog:
|
# GameWorld.Log(" i=%s,³ÉÔ±ÐéÄâÏß·²»Í¬!playerID=%s,copyMapID=%s,mapCopyMapID=%s"
|
# % (i, curTeamPlayer.GetPlayerID(), curTeamPlayer.GetCopyMapID(), GameWorld.GetGameWorld().GetCopyMapID()))
|
# #¸±±¾ID²»Í¬
|
# continue
|
#===========================================================================================
|
|
if GameWorld.GetDist(centerX, centerY, curTeamPlayer.GetPosX(),
|
curTeamPlayer.GetPosY()) > area:
|
#if isLog:
|
# GameWorld.Log(" i=%s,³ÉÔ±²»ÔÚ·¶Î§ÄÚ!playerID=%s,centerPos(%s,%s),playerPos=(%s,%s),area=%s"
|
# % (i, curTeamPlayer.GetPlayerID(), centerX, centerY, curTeamPlayer.GetPosX(), curTeamPlayer.GetPosY(), area))
|
continue
|
|
playerlist.append(curTeamPlayer)
|
playerIDList.append(curTeamPlayer.GetPlayerID())
|
|
#if isLog:
|
# GameWorld.Log(" teamAreaPlayerIDList=%s" % (playerIDList))
|
return playerlist
|
|
def GetMapTeamMember(curTeam):
|
''' »ñȡͬµØͼÖеĶÓÔ± '''
|
|
playerlist = list()
|
if curTeam == None:
|
return playerlist
|
|
for i in xrange(curTeam.GetMemberCount()):
|
curTeamPlayer = curTeam.GetMember(i)
|
if curTeamPlayer == None or curTeamPlayer.GetPlayerID() == 0:
|
continue
|
playerlist.append(curTeamPlayer)
|
|
return playerlist
|
|
#---------------------------------------------------------------------
|
##»ñÈ¡Íæ¼Ò»õ±ÒÊý
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param TYPE_Price ,»õ±ÒÀàÐÍ
|
# @return
|
def GetMoney(curPlayer, TYPE_Price):
|
|
#½ð×Ó
|
if TYPE_Price == IPY_GameWorld.TYPE_Price_Gold_Money:
|
return curPlayer.GetGold()
|
|
#½ðƱ
|
elif TYPE_Price == IPY_GameWorld.TYPE_Price_Gold_Paper:
|
return curPlayer.GetGoldPaper()
|
|
#Òø×Ó
|
elif TYPE_Price == IPY_GameWorld.TYPE_Price_Silver_Money:
|
return GetSilver(curPlayer)
|
|
#񿮱
|
elif TYPE_Price == IPY_GameWorld.TYPE_Price_Silver_Paper:
|
return curPlayer.GetSilverPaper()
|
|
#´ú±Ò
|
elif TYPE_Price == ShareDefine.TYPE_Price_PayCoin:
|
return GetPayCoin(curPlayer)
|
|
#×Ô¶¨Òå»õ±Ò
|
elif TYPE_Price in ShareDefine.TYPE_Price_CurrencyDict:
|
return GetPlayerCurrency(curPlayer, TYPE_Price)
|
|
return 0
|
|
def GetMoneyReal(curPlayer, moneyType):
|
## »ñÈ¡»õ±Òʵ¼ÊÖµ£¬Ö§³Ö¸ºÖµ
|
moneyMinus = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_MoneyMinus % moneyType)
|
if moneyMinus != 0:
|
return -moneyMinus
|
return GetMoney(curPlayer, moneyType)
|
|
def SetMoney(curPlayer, moneyType, value):
|
## ÉèÖûõ±ÒÖµ£¬Ö§³Ö¸ºÖµ
|
if moneyType in ShareDefine.MoneyMinusRefreshDict:
|
moneyMinus = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_MoneyMinus % moneyType)
|
if value < 0:
|
if moneyMinus != value:
|
SetMoneyMinus(curPlayer, moneyType, value)
|
value = 0
|
else:
|
if moneyMinus != 0:
|
SetMoneyMinus(curPlayer, moneyType, 0)
|
|
#½ð×Ó
|
if moneyType == IPY_GameWorld.TYPE_Price_Gold_Money:
|
curPlayer.SetGold(value)
|
|
#½ðƱ
|
elif moneyType == IPY_GameWorld.TYPE_Price_Gold_Paper:
|
curPlayer.SetGoldPaper(value)
|
|
#Òø×Ó
|
elif moneyType == IPY_GameWorld.TYPE_Price_Silver_Money:
|
SetSilver(curPlayer, value)
|
|
#񿮱
|
elif moneyType == IPY_GameWorld.TYPE_Price_Silver_Paper:
|
curPlayer.SetSilverPaper(value)
|
|
#´ú±Ò
|
elif moneyType == ShareDefine.TYPE_Price_PayCoin:
|
SetPayCoin(curPlayer, value)
|
|
#×Ô¶¨Òå»õ±Ò
|
elif moneyType in ShareDefine.TYPE_Price_CurrencyDict:
|
SetPlayerCurrency(curPlayer, moneyType, value)
|
|
return
|
|
def SetMoneyMinus(curPlayer, moneyType, value):
|
value = abs(value) # ´æÖµ¼°Í¨ÖªÊ¹ÓÃÕýÊý
|
NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_MoneyMinus % moneyType, value)
|
#֪ͨ¿Í»§¶Ë
|
if moneyType not in ShareDefine.MoneyMinusRefreshDict:
|
return
|
refreshType = ShareDefine.MoneyMinusRefreshDict[moneyType]
|
if refreshType != None:
|
SendPropertyRefresh(curPlayer, refreshType, value)
|
return
|
|
## »ñÈ¡Íæ¼Ò²Ö¿â½ðÇ®Êý
|
# @param curPlayer: Íæ¼ÒʵÀý
|
# @param moneyType: ½ðÇ®ÀàÐÍ
|
# @return: Íæ¼ÒÉíÉϽðÇ®Êý
|
def GetWarehouseMoney(curPlayer, moneyType):
|
if moneyType == IPY_GameWorld.TYPE_Price_Gold_Money:
|
return curPlayer.GetWarehouseGold()
|
|
if moneyType == IPY_GameWorld.TYPE_Price_Gold_Paper:
|
return curPlayer.GetWarehouseGoldPaper()
|
|
if moneyType == IPY_GameWorld.TYPE_Price_Silver_Money:
|
return curPlayer.GetWarehouseSilver()
|
|
if moneyType == IPY_GameWorld.TYPE_Price_Silver_Paper:
|
return curPlayer.GetWarehouseSilverPaper()
|
|
GameWorld.ErrLog("GetWarehouseMoney, moneyType:%d Err" % (moneyType))
|
return 0
|
|
## »ñµÃ×Ô¶¨Òå»õ±Ò£¨»ý·Ö£©
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return
|
def GetPlayerCurrency(curPlayer, currencyType):
|
return curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_Currency % currencyType)
|
|
## ÉèÖÃ×Ô¶¨Òå»õ±Ò£¨»ý·Ö£©
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return
|
def SetPlayerCurrency(curPlayer, currencyType, value):
|
NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_Currency % currencyType, value)
|
#֪ͨ¿Í»§¶Ë
|
NotifyPlayerCurrency(curPlayer, currencyType, value)
|
return
|
|
def NotifyPlayerCurrency(curPlayer, currencyType, value=-1):
|
if currencyType not in ShareDefine.TYPE_Price_CurrencyDict:
|
return
|
refreshType = ShareDefine.TYPE_Price_CurrencyDict[currencyType]
|
if refreshType == None:
|
# ²»ÐèҪ֪ͨ¿Í»§¶Ë
|
return
|
if value < 0:
|
value = GetPlayerCurrency(curPlayer, currencyType)
|
SendPropertyRefresh(curPlayer, refreshType, value)
|
return
|
|
# ֪ͨÍæ¼ÒËùÓÐ×Ô¶¨Òå»õ±Ò
|
def NotifyPlayerAllCurrency(curPlayer):
|
notifyList = []
|
for currencyType in ShareDefine.TYPE_Price_CurrencyDict:
|
refreshType = ShareDefine.TYPE_Price_CurrencyDict[currencyType]
|
if refreshType == None:
|
# ²»ÐèҪ֪ͨ¿Í»§¶Ë
|
continue
|
|
#´Ë´¦¸ù¾ÝÐèÇóÈôValueΪ0 ¿É²»Í¨Öª¿Í»§¶Ë£¬¾ßÌ幦ÄÜÖÆ×÷Õß¾ö¶¨
|
value = GetPlayerCurrency(curPlayer, currencyType)
|
notifyStruct = ChPyNetSendPack.tagRefreshType()
|
notifyStruct.RefreshType = refreshType
|
notifyStruct.Value = value
|
notifyList.append(notifyStruct)
|
|
# ¸ºÖµ»õ±Ò
|
for moneyType, refreshType in ShareDefine.MoneyMinusRefreshDict.items():
|
if refreshType == None:
|
# ²»ÐèҪ֪ͨ¿Í»§¶Ë
|
continue
|
value = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_MoneyMinus % moneyType)
|
if not value:
|
continue
|
notifyStruct = ChPyNetSendPack.tagRefreshType()
|
notifyStruct.RefreshType = refreshType
|
notifyStruct.Value = value
|
notifyList.append(notifyStruct)
|
|
#ÊôÐÔ×éºÏ°ü ֪ͨ×Ô¼º
|
sendPack = ChPyNetSendPack.tagObjInfoListRefresh()
|
sendPack.Clear()
|
sendPack.ObjID = curPlayer.GetID()
|
sendPack.ObjType = curPlayer.GetGameObjType()
|
sendPack.Count = len(notifyList)
|
sendPack.RefreshType = notifyList
|
NetPackCommon.SendFakePack(curPlayer, sendPack)
|
return
|
|
def NotifyUseMoneyTotal(curPlayer, moneyTypeList=None):
|
if moneyTypeList:
|
notifyMoneyTypeList = moneyTypeList
|
else:
|
notifyMoneyTypeList = ShareDefine.UseTotalPriceTypeList
|
|
infoList = []
|
for moneyType in notifyMoneyTypeList:
|
useTotal = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_UseMoneyTotal % moneyType)
|
if not useTotal and moneyTypeList == None:
|
continue
|
info = ChPyNetSendPack.tagMCUseMoneyTotal()
|
info.MoneyType = moneyType
|
info.UseTotal = useTotal
|
infoList.append(info)
|
|
if not infoList:
|
return
|
|
clientPack = ChPyNetSendPack.tagMCUseMoneyTotalInfo()
|
clientPack.Clear()
|
clientPack.InfoList = infoList
|
clientPack.Count = len(clientPack.InfoList)
|
NetPackCommon.SendFakePack(curPlayer, clientPack)
|
return
|
|
##Íæ¼ÒÊÇ·ñÓÐÇ®¿î
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param TYPE_Price ,»õ±ÒÀàÐÍ
|
# @param Price ,»õ±Ò¼Û¸ñ
|
# @return ·µ»ØÖµÕæ, ͨ¹ý
|
# @remarks Íæ¼ÒÊÇ·ñÓÐÇ®¿î
|
def HaveMoney(curPlayer, TYPE_Price, Price, needNotify=True):
|
if Price < 0:
|
return False
|
|
needMoneyCount = 0
|
notifyCode = ''
|
#½ð×ÓÖ§¸¶
|
if TYPE_Price == IPY_GameWorld.TYPE_Price_Gold_Money:
|
needMoneyCount = curPlayer.GetGold()
|
notifyCode = "GoldErr"
|
|
#½ðƱ֧¸¶
|
elif TYPE_Price == IPY_GameWorld.TYPE_Price_Gold_Paper:
|
needMoneyCount = curPlayer.GetGoldPaper()
|
notifyCode = "GoldPaperErr"
|
|
#Òø×ÓÖ§¸¶
|
elif TYPE_Price == IPY_GameWorld.TYPE_Price_Silver_Money:
|
needMoneyCount = GetSilver(curPlayer)
|
notifyCode = "SilverErr"
|
|
#ÒøƱ֧¸¶
|
elif TYPE_Price == IPY_GameWorld.TYPE_Price_Silver_Paper:
|
needMoneyCount = curPlayer.GetSilverPaper()
|
notifyCode = "SilverPaperErr"
|
|
#´ú±ÒÖ§¸¶
|
elif TYPE_Price == ShareDefine.TYPE_Price_PayCoin:
|
needMoneyCount = GetPayCoinTotal(curPlayer)
|
|
#×Ô¶¨Òå»õ±Ò
|
elif TYPE_Price in ShareDefine.TYPE_Price_CurrencyDict:
|
needMoneyCount = GetPlayerCurrency(curPlayer, TYPE_Price)
|
else:
|
GameWorld.Log("¸¶·Ñ½ðÇ®Òì³£ TYPE_Price = %s" % (TYPE_Price), curPlayer.GetPlayerID())
|
return False
|
|
if needMoneyCount < Price:
|
lackPrice = Price - needMoneyCount # »¹È±¶àÉÙÇ®
|
tagMoneyInfo = GetEqualMoneyInfo(TYPE_Price, lackPrice)
|
if tagMoneyInfo:
|
tagMoneyType, tagMoneyValue = tagMoneyInfo
|
if HaveMoney(curPlayer, tagMoneyType, tagMoneyValue, False):
|
GameWorld.DebugLog("HaveMoney¿ÉʹÓõȼۻõ±Ò²¹×ã¿Û³ý: TYPE_Price=%s, Price=%s, lackPrice=%s, tagMoneyType=%s, tagMoneyValue=%s"
|
% (TYPE_Price, Price, lackPrice, tagMoneyType, tagMoneyValue), curPlayer.GetPlayerID())
|
return True
|
|
#---Ç®²»¹» ·µ»Ø¼ÙÈç¹ûÐèÒªÌáʾµÄ»° ÌáʾÐÅÏ¢---
|
if needMoneyCount < Price:
|
if needNotify and notifyCode:
|
NotifyCode(curPlayer, notifyCode)
|
GameWorld.DebugLog("»õ±Ò²»×ã: TYPE_Price=%s, Price=%s, curMoneyCount=%s" % (TYPE_Price, Price, needMoneyCount))
|
return False
|
|
return True
|
|
def GetEqualMoneyInfo(moneyType, needValue):
|
equalMoneyInfo = IpyGameDataPY.GetFuncEvalCfg("EqualValueMoney", 2, {})
|
if str(moneyType) not in equalMoneyInfo:
|
return
|
tagMoneyType = equalMoneyInfo[str(moneyType)]
|
exchangeMoneyInfo = IpyGameDataPY.GetFuncEvalCfg("EqualValueMoney", 1, {})
|
if str(tagMoneyType) not in exchangeMoneyInfo:
|
return
|
exchangeInfo = exchangeMoneyInfo[str(tagMoneyType)]
|
if moneyType != exchangeInfo[0]:
|
return
|
multiple = exchangeInfo[1]
|
tagMoneyValue = int(math.ceil(needValue / float(multiple)))
|
#GameWorld.DebugLog("µÈ¼Û»õ±ÒÐÅÏ¢: moneyType=%s,needValue=%s,multiple=%s,tagMoneyType=%s,tagMoneyValue=%s"
|
# % (moneyType, needValue, multiple, tagMoneyType, tagMoneyValue))
|
return tagMoneyType, tagMoneyValue
|
|
#---------------------------------------------------------------------
|
##Íæ¼ÒÊÇ·ñÓÐÇ®¿î
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param TYPE_Price ,»õ±ÒÀàÐÍ
|
# @param Price ,»õ±Ò¼Û¸ñ
|
# @return ·µ»ØÖµ[[type1,price1], [type2,price2]]
|
# @remarks Íæ¼ÒÊÇ·ñÓÐÇ®¿î
|
def HaveMoneyEx(curPlayer, TYPE_Price, Price, needNotify=True):
|
if Price < 0:
|
return []
|
if TYPE_Price == ShareDefine.TYPE_Price_Gold_Paper_Money:
|
TYPE_Price = IPY_GameWorld.TYPE_Price_Gold_Money #аæÎÞ°óÓñ£¬ÔÏÈ°óÓñÔÙÏÉÓñµÄ¿Û·¨¸Ä³É ¿ÛÏÉÓñ 2019/3/26
|
#âýÓ¢°æ£º »Ö¸´°óÓñ£¬µ«ÊDz»Ê¹ÓÃÏÈ°óÓñÔÙÏÉÓñµÄ¹æÔò£¬ÔÀ´ÏÈ°óÓñÔÙÏÉÓñµÄ¹æÔòÒ»ÑùΪĬÈÏ¿ÛÏÉÓñ 2019/10/8
|
|
if TYPE_Price in [IPY_GameWorld.TYPE_Price_Gold_Money, IPY_GameWorld.TYPE_Price_Gold_Paper,
|
IPY_GameWorld.TYPE_Price_Silver_Money, IPY_GameWorld.TYPE_Price_Silver_Paper]:
|
if HaveMoney(curPlayer, TYPE_Price, Price, needNotify):
|
return [[TYPE_Price, Price]]
|
return []
|
|
#ÏÈÀñȯÔÙÔª±¦
|
elif TYPE_Price == ShareDefine.TYPE_Price_Gold_Paper_Money:
|
goldPaper = curPlayer.GetGoldPaper() # Àñȯ
|
gold = curPlayer.GetGold() # Ôª±¦
|
|
if goldPaper + gold < Price: # Ç®²»¹»
|
if needNotify:
|
NotifyCode(curPlayer, "GoldErr")
|
return []
|
|
if goldPaper >= Price: # Ö»ÓÃÀñȯ¾Í¹»ÁË
|
return [[IPY_GameWorld.TYPE_Price_Gold_Paper, Price]]
|
needGold = Price - goldPaper # ÓÃÍêÀñȯ£¬»¹ÐèÒªÔª±¦
|
return [[IPY_GameWorld.TYPE_Price_Gold_Paper, goldPaper], [IPY_GameWorld.TYPE_Price_Gold_Money, needGold]]
|
# #ÓÃÕ½Ã˹±Ï׶È
|
# elif TYPE_Price == ShareDefine.TYPE_Price_Family_Contribution:
|
# return []
|
else:
|
GameWorld.Log("¸¶·Ñ½ðÇ®Òì³£ TYPE_Price = %s" % (TYPE_Price), curPlayer.GetPlayerID())
|
return []
|
|
return []
|
|
|
#---------------------------------------------------------------------
|
##Íæ¼Ò¸¶¿î
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param type_Price ,»õ±ÒÀàÐÍ
|
# @param price ,»õ±Ò¼Û¸ñ
|
# @param costType ,Ïû·ÑµãÀàÐÍ
|
# @param infoDict ,À©Õ¹ÐÅÏ¢, ×ÓÏû·Ñ¶ÔÏó¿ÉÒÔͨ¹ýÉèÖÃChConfig.Def_Cost_Reason_SonKey keyÖµ
|
# @param quantity ,ÊýÁ¿
|
# @param isMinus ,ÊÇ·ñÔÊÐí¿Û³É¸ºÖµ
|
# @return ·µ»ØÖµÕæ, ¸¶¿î³É¹¦
|
# @remarks Íæ¼Ò¸¶¿î
|
def PayMoney(curPlayer, type_Price, price, costType=ChConfig.Def_Cost_Unknown, infoDict={}, quantity=1, costVIPGold= -1, isNotify=True, isMinus=False):
|
if price == 0:
|
return True
|
if price < 0:
|
GameWorld.Log('###---¿ÛÇ®Òì³£ = %s' % (price), curPlayer.GetPlayerID())
|
return False
|
lostMoney = price
|
|
#20190917 »Ö¸´°óÓñ
|
# if type_Price == IPY_GameWorld.TYPE_Price_Gold_Paper:
|
# type_Price = IPY_GameWorld.TYPE_Price_Gold_Money #аæÎÞ°óÓñ£¬ÔÏÈ°óÓñÔÙÏÉÓñµÄ¿Û·¨¸Ä³É ¿ÛÏÉÓñ 2019/6/3
|
|
#½ð×ÓÖ§¸¶
|
if type_Price == IPY_GameWorld.TYPE_Price_Gold_Money:
|
curPlayerGold = GetMoneyReal(curPlayer, type_Price)
|
if curPlayerGold < price and not isMinus:
|
NotifyCode(curPlayer, "GoldErr")
|
return False
|
updPlayerGold = curPlayerGold - price
|
SetMoney(curPlayer, type_Price, updPlayerGold)
|
|
curBourseMoney = GetMoney(curPlayer, ShareDefine.TYPE_Price_BourseMoney)
|
updBourseMoney = curBourseMoney
|
#µ±Êǽ»Ò×Ëù¿Û·Ñ¡¢×êʯºì°üʱ£¬Ôò±Ø¶¨¿Û³ý½»Ò׶î¶È
|
if costType in ChConfig.UnUseInner_CostType:
|
updBourseMoney = max(0, curBourseMoney - price)
|
#ÆäËûÈç¹ûµ±Ç°½ð×ӱȽ»Ò׶î¶È»¹ÉÙ£¬ÔòÇ¿ÖƵ÷Õû½»Ò׶î¶ÈΪµ±Ç°½ð×ÓÊý(ÕâÖÖÇé¿öÒ»°ãÊǷǽ»Ò×ËùÏû·ÑµÄ£¬ÐèҪͬ²½¿Û³ý½»Ò×Ëù¿É¹ºÂò¶î¶È)
|
elif updPlayerGold < updBourseMoney:
|
updBourseMoney = updPlayerGold
|
updBourseMoney = max(0, updBourseMoney)
|
if updBourseMoney != curBourseMoney:
|
SetPlayerCurrency(curPlayer, ShareDefine.TYPE_Price_BourseMoney, updBourseMoney)
|
infoDict["BourseMoney"] = updBourseMoney
|
|
#½ðƱ֧¸¶
|
elif type_Price == IPY_GameWorld.TYPE_Price_Gold_Paper:
|
curPlayerGoldPaper = GetMoneyReal(curPlayer, type_Price)
|
if curPlayerGoldPaper < price and not isMinus:
|
NotifyCode(curPlayer, "GoldPaperErr")
|
return False
|
updGoldPaper = curPlayerGoldPaper - price
|
SetMoney(curPlayer, type_Price, updGoldPaper)
|
|
#Òø×ÓÖ§¸¶
|
elif type_Price == IPY_GameWorld.TYPE_Price_Silver_Money:
|
curPlayerSilver = GetSilver(curPlayer)
|
if curPlayerSilver < price:
|
NotifyCode(curPlayer, "SilverErr")
|
return False
|
#ÓÐ×ã¹»µÄǮ֧¸¶
|
SetSilver(curPlayer, curPlayerSilver - price)
|
|
#ÒøƱ֧¸¶
|
elif type_Price == IPY_GameWorld.TYPE_Price_Silver_Paper:
|
curPlayerSilverPaper = curPlayer.GetSilverPaper()
|
if curPlayerSilverPaper < price:
|
NotifyCode(curPlayer, "SilverPaperErr")
|
return False
|
#ÓÐ×ã¹»µÄǮ֧¸¶
|
curPlayer.SetSilverPaper(curPlayerSilverPaper - price)
|
|
#´ú±ÒÖ§¸¶
|
elif type_Price == ShareDefine.TYPE_Price_PayCoin:
|
curPlayerPayCoin = GetPayCoin(curPlayer)
|
curPayCoinDay = GetPlayerCurrency(curPlayer, ShareDefine.TYPE_Price_PayCoinDay)
|
payCoinTotal = curPlayerPayCoin + curPayCoinDay
|
if payCoinTotal < price:
|
return False
|
#ÓÐ×ã¹»µÄǮ֧¸¶
|
costPayCoinDay = price if (curPayCoinDay >= price) else curPayCoinDay
|
costPayCoin = price
|
if costPayCoinDay:
|
GameWorld.DebugLog("ÏÈ¿Û´ú±ÒʱЧ: curPayCoinDay=%s,price=%s,costPayCoinDay=%s" % (curPayCoinDay, price, costPayCoinDay))
|
SetPlayerCurrency(curPlayer, ShareDefine.TYPE_Price_PayCoinDay, curPayCoinDay - costPayCoinDay)
|
costPayCoin -= costPayCoinDay
|
GameWorld.DebugLog("ÔÙ¿Û´ú±Ò: costPayCoin=%s" % (costPayCoin))
|
#ʱЧ²»¹»¿Û³ý£¬ÔÙ¿Û·ÇʱЧ
|
if costPayCoin > 0:
|
SetPayCoin(curPlayer, curPlayerPayCoin - costPayCoin)
|
|
#×Ô¶¨Òå»õ±Ò
|
elif type_Price in ShareDefine.TYPE_Price_CurrencyDict:
|
curCurrency = GetPlayerCurrency(curPlayer, type_Price)
|
if curCurrency < price:
|
lostMoney = curCurrency
|
lackPrice = price - curCurrency # »¹È±¶àÉÙÇ®
|
tagMoneyInfo = GetEqualMoneyInfo(type_Price, lackPrice)
|
if tagMoneyInfo:
|
tagMoneyType, tagMoneyValue = tagMoneyInfo
|
if not PayMoney(curPlayer, tagMoneyType, tagMoneyValue, costType, infoDict, quantity, costVIPGold, isNotify, isMinus):
|
#GameWorld.Log("µÈ¼Û»õ±ÒÒ²²»×ã")
|
return False
|
GameWorld.Log("µÈ¼Û»õ±Ò²¹×ã¿Û³ý: type_Price%s, price=%s, curCurrency=%s, lackPrice=%s, tagMoneyType=%s, tagMoneyValue=%s"
|
% (type_Price, price, curCurrency, lackPrice, tagMoneyType, tagMoneyValue), curPlayer.GetPlayerID())
|
else:
|
GameWorld.DebugLog("»õ±Ò²»×ã! type_Price=%s,curCurrency=%s < %s" % (type_Price, curCurrency, price))
|
return False
|
#ÓÐ×ã¹»µÄǮ֧¸¶
|
SetPlayerCurrency(curPlayer, type_Price, curCurrency - lostMoney)
|
else:
|
GameWorld.Log("¸¶·Ñ½ðÇ®Òì³£ type_Price = %s" % (type_Price), curPlayer.GetPlayerID())
|
return False
|
|
#¸¶¿îÒÔºóºóÐø²Ù×÷
|
__PayMoneyAfter(curPlayer, type_Price, lostMoney, costType, infoDict, quantity, costVIPGold)
|
|
#֪ͨ¿Í»§¶Ëʧȥ½ðÇ®
|
if isNotify:
|
if type_Price == ShareDefine.TYPE_Price_PayCoin:
|
NotifyCode(curPlayer, "LostMoney", [type_Price, str(round(lostMoney/100.0, 2))])
|
else:
|
NotifyCode(curPlayer, "LostMoney", [type_Price, lostMoney])
|
return True
|
|
## ¸¶¿îÒÔºóºóÐø²Ù×÷
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param type_Price ,»õ±ÒÀàÐÍ
|
# @param price ,»õ±Ò¼Û¸ñ
|
# @param costType ,Ïû·ÑÀàÐÍ
|
# @param infoDict ,À©Õ¹ÐÅÏ¢
|
# @param quantity Ïû·ÑÊýÁ¿
|
# @return None
|
def __PayMoneyAfter(curPlayer, type_Price, price, costType, infoDict, quantity, costVIPGold):
|
if type_Price in ShareDefine.UseTotalPriceTypeList:
|
useTotal = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_UseMoneyTotal % type_Price)
|
useTotal = min(useTotal + price, ChConfig.Def_UpperLimit_DWord)
|
NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_UseMoneyTotal % type_Price, useTotal)
|
NotifyUseMoneyTotal(curPlayer, [type_Price])
|
|
#½ð×ÓÖ§¸¶
|
if type_Price == IPY_GameWorld.TYPE_Price_Gold_Money:
|
__PayMoneyAfterByGoldMoney(curPlayer, type_Price, price, costType, infoDict, costVIPGold)
|
|
#½ðƱ֧¸¶
|
elif type_Price == IPY_GameWorld.TYPE_Price_Gold_Paper:
|
__PayMoneyAfterByGoldPaper(curPlayer, price, costType, infoDict)
|
|
#Òø×ÓÖ§¸¶
|
elif type_Price == IPY_GameWorld.TYPE_Price_Silver_Money:
|
__PayMoneyAfterBySilverMoney(curPlayer, price)
|
|
#ÒøƱ֧¸¶
|
elif type_Price == IPY_GameWorld.TYPE_Price_Silver_Paper:
|
__PayMoneyAfterBySilverPaper(curPlayer, price)
|
|
#»îÔ¾¶È´¦Àí
|
PlayerActivity.OnPayMoneyActivity(curPlayer, type_Price, price)
|
#תÅ̻
|
PlayerActTurntable.OnPlayerUseGold(curPlayer, type_Price, price)
|
#Âֻصî
|
PlayerActLunhuidian.AddLunhuidianValue(curPlayer, PlayerActLunhuidian.AwardType_PayMoney, type_Price, price)
|
if type_Price == ShareDefine.TYPE_Price_Xiantao:
|
unXiantaoCntExp = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_UnXiantaoCntExp)
|
NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_UnXiantaoCntExp, unXiantaoCntExp + price)
|
unXiantaoCntEquip = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_UnXiantaoCntEquip)
|
NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_UnXiantaoCntEquip, unXiantaoCntEquip + price)
|
PlayerPrestigeSys.AddRealmTaskValue(curPlayer, PlayerPrestigeSys.RealmTaskType_UseXiantao, price)
|
unitPrice = price if quantity == 1 else int(math.ceil(price * 1.0 / quantity)) # µ¥¼Û
|
#reason_name = "Unknown" if not costType else costType
|
reason_name = costType
|
eventName = reason_name
|
if costType in ChConfig.Def_CostType_Dict:
|
eventName = ChConfig.Def_CostType_Dict[costType]
|
#===========================================================================
|
# isDivSonKey = False # ÊÇ·ñÇø·ÖÏû·Ñ¶ÔÏó
|
# if costType in ChConfig.Def_CostType_Dict:
|
# eventName, reason_name, isDivSonKey = ChConfig.Def_CostType_Dict[costType]
|
# if costType in ChConfig.CostGroupToGoldShop:
|
# reason_name = ChConfig.Def_CostType_Dict[ChConfig.Def_Cost_BuyStoreItem][1]
|
#
|
# if isDivSonKey and isinstance(infoDict, dict) and ChConfig.Def_Cost_Reason_SonKey in infoDict:
|
# reasonSon = infoDict[ChConfig.Def_Cost_Reason_SonKey]
|
# else:
|
# reasonSon = reason_name
|
# # ͳһ¸ñʽ: ¡¸Ïû·Ñ×é:Ïû·Ñ¶ÔÏó¡¹ ; ûÓÐÉèÖÃÏû·Ñ¶ÔÏóµÄĬÈÏΪÏû·Ñ×é
|
# reason_name = "%s:%s" % (reason_name, reasonSon)
|
#===========================================================================
|
|
# ³ý×êʯ¼°°ó×êÍ⣬δָ¶¨²Ù×÷ÀàÐ͵IJ»¼Ç¼
|
if type_Price not in [IPY_GameWorld.TYPE_Price_Gold_Money, IPY_GameWorld.TYPE_Price_Gold_Paper, ShareDefine.TYPE_Price_PayCoin] \
|
and costType == ChConfig.Def_Cost_Unknown:
|
#GameWorld.DebugLog("¸Ã»õ±ÒûÓÐÖ¸¶¨Ïû·ÑÀàÐͲ»¼Ç¼!type_Price=%s,costType=%s" % (type_Price, costType))
|
return
|
if type_Price == ShareDefine.TYPE_Price_PayCoin:
|
playerID = curPlayer.GetPlayerID()
|
nowMoney = GetMoneyReal(curPlayer, type_Price)
|
payCoinDay = GetMoney(curPlayer, ShareDefine.TYPE_Price_PayCoinDay)
|
infoDict["PlayerMoneyCount2"] = payCoinDay
|
orderInfo = infoDict.get("orderInfo", "")
|
GameWorld.Log("¼Ç¼ÏûºÄ´ú±Ò: eventName=%s,price=%s,nowMoney=%s,payCoinDay=%s,orderInfo=%s" % (eventName, price, nowMoney, payCoinDay, orderInfo), playerID)
|
GameWorld.AddPlayerRec(playerID, ShareDefine.Def_PlayerRecType_PayCoin, [2, price, nowMoney, payCoinDay], orderInfo, 1)
|
# Á÷ÏòÓà eventName
|
#if eventName:
|
if costType == ChConfig.Def_Cost_Treasure:
|
GameWorld.DebugLog("BT°æ±¾Ñ°±¦ÏûºÄ»õ±ÒÔÝʱ²»¼Ç¼Á÷Ïò: %s,type_Price=%s,price=%s" % (eventName, type_Price, price))
|
else:
|
DataRecordPack.DR_UseMoney(curPlayer, eventName, type_Price, price, infoDict) # Á÷Ïò
|
EventReport.WriteEvent_virtual_resource(curPlayer, type_Price, reason_name, quantity,
|
unitPrice, ShareDefine.Def_UserAction_Money_Use, infoDict)
|
#===========================================================================
|
# if type_Price == IPY_GameWorld.TYPE_Price_Gold_Money:
|
# EventReport.WriteEvent_virtual_cost(curPlayer, quantity, unitPrice, reason_name)
|
# elif type_Price in [IPY_GameWorld.TYPE_Price_Gold_Paper, IPY_GameWorld.TYPE_Price_Silver_Money]:
|
#
|
# # ½ð±Òδָ¶¨Ïû·ÑÀàÐ͵IJ»¼Ç¼
|
# if type_Price == IPY_GameWorld.TYPE_Price_Silver_Money and costType == ChConfig.Def_Cost_Unknown:
|
# return
|
# EventReport.WriteEvent_virtual_resource(curPlayer, type_Price, reason_name, quantity,
|
# unitPrice, ShareDefine.Def_UserAction_Money_Use)
|
#
|
# # ×Ô¶¨Òå¼Ç¼
|
# priceNameDict = {IPY_GameWorld.TYPE_Price_Gold_Money:["×êʯ", "GetGold", 0],
|
# IPY_GameWorld.TYPE_Price_Gold_Paper:["°ó×ê", "GetGoldPaper", 0],
|
# IPY_GameWorld.TYPE_Price_Silver_Money:["½ð±Ò", "GetSilver", ChConfig.Def_DRRecord_Min_Silver],
|
# }
|
# if type_Price in priceNameDict:
|
# typeName, moneyFuncName, minPrice = priceNameDict[type_Price]
|
# if minPrice <= 0 or price >= minPrice:
|
# EventReport.WriteEvent_pay_money(curPlayer, reason_name, typeName, price, getattr(curPlayer, moneyFuncName)())
|
#===========================================================================
|
return
|
|
## ¸¶¿îÒÔºóºóÐø²Ù×÷(½ð×Ó)
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param price ,»õ±Ò¼Û¸ñ
|
# @return None
|
def __PayMoneyAfterByGoldMoney(curPlayer, type_Price, price, costType, infoDict, costVIPGold):
|
|
|
# ³äÖµ»î¶¯Íæ¼ÒÏûºÄÔª±¦´¦Àí
|
#PlayerGoldAction.PlayerUseGold(curPlayer, price)
|
|
# Ïû·Ñ·µÀû
|
if costType not in ChConfig.CostRebate_DisableType:
|
PlayerCostRebate.AddCostRebateGold(curPlayer, costType, price, infoDict)
|
PlayerFeastTravel.AddFeastTravelTaskValue(curPlayer, ChConfig.Def_FeastTravel_UseGold, price)
|
PlayerActGarbageSorting.AddActGarbageTaskProgress(curPlayer, ChConfig.Def_GarbageTask_UseGold, price)
|
else:
|
GameWorld.DebugLog("²»¼ÆÈëÏû·Ñ»î¶¯µÄÏû·ÑÀàÐÍ!costType=%s" % costType, curPlayer.GetPlayerID())
|
|
# ʼþ»ã±¨
|
#===========================================================================
|
# if costType == ChConfig.Def_Cost_BourseBuy:
|
# # ½»Ò×Ëù¹ºÂòÎïÆ·£¬»ã±¨½»Ò××êʯ
|
# playerName = curPlayer.GetPlayerName()
|
# leftGold = curPlayer.GetGold()
|
# eventParam = "RoleID=%s,Price=%s,TradeType=Lost,LeftGold=%s" \
|
# % (playerName, price, leftGold)
|
# EventReport.EventReport(ShareDefine.Def_UserAction_TradeGold, eventParam, curPlayer)
|
# else:
|
# playerName = curPlayer.GetPlayerName()
|
# leftGold = curPlayer.GetGold()
|
# eventParam = "RoleID=%s,CostType=%s,ItemID=%s,Price=%s,LeftGold=%s" \
|
# % (playerName, costType, infoDict, price, leftGold)
|
# EventReport.EventReport(ShareDefine.Def_UserAction_UseGold, eventParam, curPlayer)
|
#===========================================================================
|
|
# ֪ͨԪ±¦Ïû·Ñ¼Ç¼
|
#__Sync_GoldCostReport(curPlayer, costType, price, expandValue)
|
return
|
|
|
## ֪ͨԪ±¦Ïû·Ñ¼Ç¼
|
# @param curPlayer: Íæ¼ÒʵÀý
|
# @param costType: Ïû·ÑµãÀàÐÍ
|
# @param price: Ïû·Ñ¶î¶È
|
# @param itemID: ÎïÆ·id£¬Ïû·ÑÀàÐÍΪÎïƷʱ¿ÉÌî
|
# @return None
|
def __Sync_GoldCostReport(curPlayer, costType, price, itemID=0):
|
sendPack = ChPyNetSendPack.tagMCGoldCostReport()
|
sendPack.Clear()
|
sendPack.CostType = costType
|
sendPack.Price = price
|
sendPack.ItemID = itemID
|
NetPackCommon.SendFakePack(curPlayer, sendPack)
|
return
|
|
|
## ¸¶¿îÒÔºóºóÐø²Ù×÷(½ðƱ)
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param price ,»õ±Ò¼Û¸ñ
|
# @return None
|
def __PayMoneyAfterByGoldPaper(curPlayer, price, costType, infoDict):
|
|
# ʼþ»ã±¨
|
#===========================================================================
|
# playerName = curPlayer.GetPlayerName()
|
# leftGoldPaper = curPlayer.GetGoldPaper()
|
# eventParam = "RoleID=%s,CostType=%s,ItemID=%s,Price=%s,LeftGoldPaper=%s" \
|
# % (playerName, costType, infoDict, price, leftGoldPaper)
|
# EventReport.EventReport(ShareDefine.Def_UserAction_UseGoldPaper, eventParam, curPlayer)
|
#===========================================================================
|
return
|
|
|
## ¸¶¿îÒÔºóºóÐø²Ù×÷(½ðƱ)
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param price ,»õ±Ò¼Û¸ñ
|
# @return None
|
def __PayMoneyAfterBySilverMoney(curPlayer, price):
|
return
|
|
|
## ¸¶¿îÒÔºóºóÐø²Ù×÷(½ðƱ)
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param price ,»õ±Ò¼Û¸ñ
|
# @return None
|
def __PayMoneyAfterBySilverPaper(curPlayer, price):
|
return
|
|
#---------------------------------------------------------------------
|
##Íæ¼Ò»ñµÃ½ðÇ®
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param value ,»õ±Ò¼Û¸ñ
|
# @param priceType ,»õ±ÒÀàÐÍ
|
# @return ·µ»ØÖµÕæ, ¸øÇ®³É¹¦
|
# @param isSysHint ÊÇ·ñϵͳÌáʾ£¨Ä¬ÈÏÊÇ£©
|
# @remarks Íæ¼Ò»ñµÃ½ðÇ®
|
def GiveMoney(curPlayer, priceType, value, giveType=ChConfig.Def_GiveMoney_Unknown, addDataDict={}, isSysHint=True, isGiveBourseMoney=True):
|
if value == 0:
|
return True
|
|
if value < 0:
|
GameWorld.Log('Íæ¼Ò»ñµÃ½ðÇ®Òì³£ £¬ value = %s , priceType = %s ,' % (value, priceType))
|
return
|
|
if GameWorld.IsCrossServer():
|
serverGroupID = GetPlayerServerGroupID(curPlayer)
|
msgInfo = {"PlayerID":curPlayer.GetPlayerID(), "MoneyType":priceType, "Value":value, "GiveType":giveType, "AddDataDict":addDataDict}
|
GameWorld.SendMsgToClientServer(ShareDefine.CrossServerMsg_GiveMoney, msgInfo, [serverGroupID])
|
return True
|
|
befMoney = GetMoney(curPlayer, priceType)
|
if priceType == IPY_GameWorld.TYPE_Price_Gold_Money:
|
updPlayerGold = GetMoneyReal(curPlayer, priceType) + value
|
if updPlayerGold > ChConfig.Def_PlayerTotalMoney_Gold:
|
#³¬¹ý½ðÇ®ÉÏÏÞ
|
NotifyCode(curPlayer, "MoneyIsFull", [priceType])
|
return
|
SetMoney(curPlayer, priceType, updPlayerGold)
|
|
if isGiveBourseMoney and updPlayerGold > 0:
|
GiveMoney(curPlayer, ShareDefine.TYPE_Price_BourseMoney, min(value, updPlayerGold))
|
addDataDict["BourseMoney"] = GetMoney(curPlayer, ShareDefine.TYPE_Price_BourseMoney)
|
|
elif priceType == IPY_GameWorld.TYPE_Price_Gold_Paper:
|
updPlayerGoldPaper = GetMoneyReal(curPlayer, priceType) + value
|
if updPlayerGoldPaper > ChConfig.Def_PlayerTotalMoney_Gold:
|
#³¬¹ý½ðÇ®ÉÏÏÞ
|
NotifyCode(curPlayer, "MoneyIsFull", [priceType])
|
return
|
SetMoney(curPlayer, priceType, updPlayerGoldPaper)
|
|
elif priceType == IPY_GameWorld.TYPE_Price_Silver_Money:
|
# ½ðǮ֧³Ö³¬¹ý20ÒÚ, Ôݲ»×öÉÏÏÞ¿ØÖÆ
|
# if curSilver + value > ChConfig.Def_PlayerTotalMoney_Silver:
|
# #³¬¹ý½ðÇ®ÉÏÏÞ
|
# NotifyCode(curPlayer, "MoneyIsFull", [priceType])
|
# return
|
SetSilver(curPlayer, GetSilver(curPlayer) + value)
|
|
|
elif priceType == IPY_GameWorld.TYPE_Price_Silver_Paper:
|
if curPlayer.GetSilverPaper() + value > ChConfig.Def_PlayerTotalMoney_Silver:
|
#³¬¹ý½ðÇ®ÉÏÏÞ
|
NotifyCode(curPlayer, "MoneyIsFull", [priceType])
|
return
|
|
curPlayer.SetSilverPaper(curPlayer.GetSilverPaper() + value)
|
|
elif priceType == ShareDefine.TYPE_Price_PayCoin:
|
SetPayCoin(curPlayer, GetPayCoin(curPlayer) + value)
|
|
#×Ô¶¨Òå»õ±Ò
|
elif priceType in ShareDefine.TYPE_Price_CurrencyDict:
|
curCurrency = GetPlayerCurrency(curPlayer, priceType)
|
if curCurrency >= ChConfig.Def_UpperLimit_DWord:
|
return
|
updValue = min(ChConfig.Def_UpperLimit_DWord, curCurrency + value)
|
SetPlayerCurrency(curPlayer, priceType, updValue)
|
if priceType == ShareDefine.TYPE_Price_RealmPoint:
|
PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_GetRealmPoint, value)
|
else:
|
GameWorld.ErrLog("½ðÇ®ÀàÐÍ´íÎó, priceType=%s,value=%s,giveType=%s" % (priceType, value, giveType), curPlayer.GetPlayerID())
|
DataRecordPack.DR_GiveMoneyError(curPlayer, priceType, value, giveType, addDataDict)
|
return
|
|
# ʱЧ´ú±ÒºóÐø´¦Àí¾ùÊÓΪ´ú±Ò£¬°üº¬ÏµÍ³Ìáʾ¡¢¼Ç¼¡¢Á÷ÏòµÈ
|
if priceType == ShareDefine.TYPE_Price_PayCoinDay:
|
priceType = ShareDefine.TYPE_Price_PayCoin
|
|
if isSysHint and priceType != ShareDefine.TYPE_Price_BourseMoney:
|
#֪ͨ¿Í»§¶ËµÃµ½½ðÇ®
|
if priceType == ShareDefine.TYPE_Price_PayCoin:
|
NotifyCode(curPlayer, "GetMoney", [priceType, str(round(value/100.0, 2))])
|
else:
|
NotifyCode(curPlayer, "GetMoney", [priceType, value])
|
__GiveMoneyAfter(curPlayer, priceType, value, giveType, addDataDict)
|
|
if befMoney == 0:
|
aftMoney = GetMoney(curPlayer, priceType)
|
if aftMoney > 0:
|
ItemControler.CheckGiveBindMoneyTypeItem(curPlayer, priceType)
|
|
return True
|
|
def __GiveMoneyAfter(curPlayer, priceType, value, giveType, addDataDict):
|
# ³ý×êʯ¼°°ó×êÍ⣬δָ¶¨²Ù×÷ÀàÐ͵IJ»¼Ç¼
|
|
PlayerTask.AddTaskValue(curPlayer, ChConfig.TaskType_GetMoney, value, [priceType])
|
|
if priceType not in [IPY_GameWorld.TYPE_Price_Gold_Money, IPY_GameWorld.TYPE_Price_Gold_Paper, ShareDefine.TYPE_Price_PayCoin] \
|
and giveType == ChConfig.Def_GiveMoney_Unknown:
|
#GameWorld.DebugLog("¸Ã»õ±ÒûÓÐÖ¸¶¨À´Ô´ÀàÐͲ»¼Ç¼!priceType=%s,giveType=%s" % (priceType, giveType))
|
return
|
eventName = giveType
|
if giveType in ChConfig.Def_GetType_Dict:
|
eventName = ChConfig.Def_GetType_Dict[giveType]
|
addDataDict["eventName"] = eventName
|
|
if priceType == ShareDefine.TYPE_Price_PayCoin:
|
playerID = curPlayer.GetPlayerID()
|
nowMoney = GetMoneyReal(curPlayer, priceType)
|
payCoinDay = GetMoney(curPlayer, ShareDefine.TYPE_Price_PayCoinDay)
|
addDataDict["PlayerMoneyCount2"] = payCoinDay
|
orderInfo = addDataDict.get("orderInfo", "")
|
GameWorld.Log("¼Ç¼»ñµÃ´ú±Ò: eventName=%s,value=%s,nowMoney=%s,payCoinDay=%s,orderInfo=%s" % (eventName, value, nowMoney, payCoinDay, orderInfo), playerID)
|
GameWorld.AddPlayerRec(playerID, ShareDefine.Def_PlayerRecType_PayCoin, [1, value, nowMoney, payCoinDay], orderInfo, 1)
|
|
if addDataDict.get("GiveItemEvent") == "Treasure":
|
GameWorld.DebugLog("BT°æ±¾Ñ°±¦¸ø»õ±ÒÔÝʱ²»¼Ç¼Á÷Ïò: %s,priceType=%s,price=%s" % (eventName, priceType, value))
|
else:
|
DataRecordPack.DR_GiveMoney(curPlayer, eventName, priceType, value, addDataDict)
|
EventReport.WriteEvent_virtual_resource(curPlayer, priceType, giveType, 1, value,
|
ShareDefine.Def_UserAction_Money_Get, addDataDict)
|
|
#===============================================================================
|
# reason_name = "Unknown" if not giveType else giveType
|
# eventName = reason_name
|
# if giveType in ChConfig.Def_GetType_Dict:
|
# eventName, reason_name = ChConfig.Def_GetType_Dict[giveType][:2]
|
# if isinstance(addDataDict, dict) and ChConfig.Def_Give_Reason_SonKey in addDataDict:
|
# reasonSon = addDataDict[ChConfig.Def_Give_Reason_SonKey]
|
# else:
|
# reasonSon = reason_name
|
# # ͳһ¸ñʽ: ¡¸»ñµÃ×é:»ñµÃÔÒò¡¹
|
# reason_name = "%s:%s" % (reason_name, reasonSon)
|
#
|
# # Á÷ÏòÓà eventName
|
# if eventName:
|
# DataRecordPack.DR_GiveMoney(curPlayer, eventName, priceType, value, addDataDict)
|
#
|
# if priceType == IPY_GameWorld.TYPE_Price_Gold_Money:
|
# playerName = curPlayer.GetPlayerName()
|
# eventParam = "RoleID=%s,AddGold=%s,LeftGold=%s,AddDataDict=%s" \
|
# % (playerName, value, curPlayer.GetGold(), addDataDict)
|
# EventReport.EventReport(ShareDefine.Def_UserAction_GameMakeGold, eventParam, curPlayer)
|
#
|
# elif priceType == IPY_GameWorld.TYPE_Price_Gold_Paper:
|
# playerName = curPlayer.GetPlayerName()
|
# eventParam = "RoleID=%s,AddGoldPaper=%s,LeftGoldPaper=%s,AddDataDict=%s" \
|
# % (playerName, value, curPlayer.GetGoldPaper(), addDataDict)
|
# EventReport.EventReport(ShareDefine.Def_UserAction_GameMakeGoldPaper, eventParam, curPlayer)
|
#
|
#
|
# if priceType == IPY_GameWorld.TYPE_Price_Gold_Money: #and eventName != "CoinToGold":
|
# EventReport.WriteEvent_virtual_reward(curPlayer, value, reason_name)
|
# # ¶þ¼¶»õ±Ò²ú³ö¼Ç¼, ÔÝÖ»¼Ç¼°ó×ê¡¢½ð±Ò
|
# elif priceType in [IPY_GameWorld.TYPE_Price_Gold_Paper, IPY_GameWorld.TYPE_Price_Silver_Money]:
|
# EventReport.WriteEvent_virtual_resource(curPlayer, priceType, reason_name, 1, value,
|
# ShareDefine.Def_UserAction_Money_Get)
|
#
|
# # ×Ô¶¨Òå¼Ç¼
|
# priceNameDict = {IPY_GameWorld.TYPE_Price_Gold_Money:["×êʯ", "GetGold", 0],
|
# IPY_GameWorld.TYPE_Price_Gold_Paper:["°ó×ê", "GetGoldPaper", 0],
|
# IPY_GameWorld.TYPE_Price_Silver_Money:["½ð±Ò", "GetSilver", ChConfig.Def_DRRecord_Min_Silver],
|
# }
|
# if priceType in priceNameDict:
|
# typeName, moneyFuncName, minPrice = priceNameDict[priceType]
|
# if minPrice <= 0 or value >= minPrice:
|
# EventReport.WriteEvent_give_money(curPlayer, reason_name, typeName, value, getattr(curPlayer, moneyFuncName)())
|
#===============================================================================
|
|
return
|
|
|
#---------------------------------------------------------------------
|
##Íæ¼ÒÄÜ·ñ»ñµÃ½ðÇ®
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param value ,»õ±Ò¼Û¸ñ
|
# @param type ,»õ±ÒÀàÐÍ
|
# @return ·µ»ØÖµÕæ, ͨ¹ý
|
# @remarks Íæ¼ÒÄÜ·ñ»ñµÃ½ðÇ®
|
def CanGiveMoney(curPlayer, priceType, value):
|
if value == 0:
|
return True
|
|
if priceType == IPY_GameWorld.TYPE_Price_Gold_Money:
|
if curPlayer.GetGold() + value > ChConfig.Def_PlayerTotalMoney_Gold:
|
#³¬¹ý½ðÇ®ÉÏÏÞ
|
NotifyCode(curPlayer, "MoneyIsFull", [priceType])
|
return False
|
elif priceType == IPY_GameWorld.TYPE_Price_Gold_Paper:
|
if curPlayer.GetGoldPaper() + value > ChConfig.Def_PlayerTotalMoney_Gold:
|
#³¬¹ý½ðÇ®ÉÏÏÞ
|
NotifyCode(curPlayer, "MoneyIsFull", [priceType])
|
return False
|
elif priceType == IPY_GameWorld.TYPE_Price_Silver_Money:
|
#½ð±ÒÖ§³Ö³¬¹ý20ÒÚ£¬Ôݲ»×öÉÏÏÞ¿ØÖÆ
|
pass
|
# if GetSilver(curPlayer) + value > ChConfig.Def_PlayerTotalMoney_Silver:
|
# #³¬¹ý½ðÇ®ÉÏÏÞ
|
# NotifyCode(curPlayer, "MoneyIsFull", [priceType])
|
# return False
|
elif priceType == IPY_GameWorld.TYPE_Price_Silver_Paper:
|
if curPlayer.GetSilverPaper() + value > ChConfig.Def_PlayerTotalMoney_Silver:
|
#³¬¹ý½ðÇ®ÉÏÏÞ
|
NotifyCode(curPlayer, "MoneyIsFull", [priceType])
|
return False
|
elif priceType == ShareDefine.TYPE_Price_PayCoin:
|
pass
|
elif priceType in ShareDefine.TYPE_Price_CurrencyDict:
|
curCurrency = GetPlayerCurrency(curPlayer, priceType)
|
if curCurrency + value > ChConfig.Def_UpperLimit_DWord:
|
return False
|
else:
|
|
GameWorld.Log("½ðÇ®ÀàÐÍ = %sÌî´íÀ²" % (priceType), curPlayer.GetPlayerID())
|
return False
|
|
return True
|
|
#---------------------------------------------------------------------
|
##Íæ¼Ò×Ô¶¯»ØѪ
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param tick ʱ¼ä´Á
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks Íæ¼Ò×Ô¶¯»ØѪ
|
def PlayerAutoRestoreHP(curPlayer, tick):
|
return
|
|
#---------------------------------------------------------------------
|
##Íæ¼Ò×Ô¶¯»Øħ
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param tick ʱ¼ä´Á
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks Íæ¼Ò×Ô¶¯»Øħ
|
def PlayerAutoRestoreMP(curPlayer, tick):
|
return
|
|
|
##»ñµÃµ±Ç°Íæ¼ÒµÄ²Î¿¼¾Ñé
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return ·µ»ØÖµ, ²Î¿¼¾Ñé
|
# @remarks »ñµÃµ±Ç°Íæ¼ÒµÄ²Î¿¼¾Ñé
|
def GetPlayerReExp(curPlayer):
|
return 0
|
#lvIpyData = GetPlayerLVIpyData(curPlayer.GetLV())
|
#if not lvIpyData:
|
# return 0
|
#return lvIpyData.GetReExp()
|
|
#---------------------------------------------------------------------
|
##Ôö¼ÓÍæ¼ÒµÄPKÖµ
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param tick ʱ¼ä´Á
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks Ôö¼ÓÍæ¼ÒµÄPKÖµ
|
def AddPlayerPKValue(curPlayer, tick):
|
curPlayerPKValue = curPlayer.GetPKValue()
|
maxPKValue = GetMaxPKValue()
|
if curPlayerPKValue >= maxPKValue:
|
#µ±Ç°PKÖµÒѵ½ÉÏÏÞ,²»Ìí¼Ó
|
return
|
|
#Ìí¼ÓµãÊý
|
addPoint = 1
|
changePKValue = ChangePKValue(curPlayer, addPoint, tick)
|
|
if changePKValue >= maxPKValue:
|
#PK_wll_0: ÄúɱÄõ¹ýÖØ£¬ÔÚºìÃû״̬ÏûʧǰÄú½«²»ÄܼÌÐø¶øÒѹ¥»÷ËûÈË
|
NotifyCode(curPlayer, "PK_lhs_202580")
|
|
return
|
|
def ChangePKValue(curPlayer, addValue, tick):
|
'''¸ü¸ÄPKÖµ'''
|
curPlayerPKValue = curPlayer.GetPKValue()
|
maxPKValue = GetMaxPKValue()
|
newPKValue = max(0, min(maxPKValue, curPlayerPKValue + addValue))
|
if newPKValue == curPlayerPKValue:
|
return newPKValue
|
|
GameWorld.DebugLog("¸üÐÂPKÖµ: curPlayerPKValue=%s,newPKValue=%s,addValue=%s" % (curPlayerPKValue, newPKValue, addValue), curPlayer.GetPlayerID())
|
if newPKValue == 0:
|
ClearPKValue(curPlayer)
|
else:
|
addBuffID = ChConfig.Def_SkillID_Red
|
curPlayer.SetPKValue(newPKValue)
|
findBuffInfo = SkillCommon.FindBuffByID(curPlayer, addBuffID)
|
redBuff = findBuffInfo[0]
|
addTimeValue = newPKValue - curPlayerPKValue
|
if not redBuff:
|
SkillCommon.AddBuffBySkillType_NoRefurbish(curPlayer, addBuffID, tick)
|
if newPKValue > 1:
|
findBuffInfo = SkillCommon.FindBuffByID(curPlayer, addBuffID)
|
redBuff = findBuffInfo[0]
|
addTimeValue = newPKValue - 1
|
|
if addTimeValue and redBuff:
|
__AddPKValueRedBuffTime(curPlayer, redBuff, addTimeValue)
|
return newPKValue
|
|
def __AddPKValueRedBuffTime(curPlayer, redBuff, addTimeValue):
|
'''Ôö¼ÓPKÖµ¶ÔÓ¦buffʱ³¤
|
@param addTimeValue: Ôö¼ÓµÄbuffµ¥Î»Ê±³¤´ÎÊý, Ö§³ÖÕý¸º
|
'''
|
buffSkill = redBuff.GetSkill()
|
if not buffSkill:
|
return
|
buffType = SkillCommon.GetBuffType(buffSkill)
|
addTime = buffSkill.GetLastTime() * addTimeValue # ÓÐÕý¸º
|
remainTime = redBuff.GetRemainTime()
|
resultTime = min(max(0, remainTime + addTime), ChConfig.Def_Max_Buff_RemainTime)
|
redBuff.SetRemainTime(resultTime)
|
BuffSkill.PYSync_RefreshBuff(curPlayer, redBuff, buffType)
|
GameWorld.DebugLog(" Ôö¼ÓºìÃûbuffʱ³¤: addTimeValue=%s,remainTime=%s,addTime=%s,resultTime=%s"
|
% (addTimeValue, remainTime, addTime, resultTime), curPlayer.GetPlayerID())
|
return
|
|
def RefreshPKValueByRedBuff(curPlayer):
|
## ˢкìÃû¶ÔÓ¦PKValue
|
curPKValue = curPlayer.GetPKValue()
|
if not curPKValue:
|
return
|
redBuff = SkillCommon.FindBuffByID(curPlayer, ChConfig.Def_SkillID_Red)[0]
|
if not redBuff:
|
curPlayer.SetPKValue(0)
|
return
|
buffSkill = redBuff.GetSkill()
|
if not buffSkill:
|
return
|
remainTime = redBuff.GetRemainTime()
|
perPKValueTime = buffSkill.GetLastTime()
|
pkValue = int(math.ceil(remainTime / float(perPKValueTime)))
|
if curPKValue != pkValue:
|
curPlayer.SetPKValue(pkValue)
|
GameWorld.DebugLog("¸üÐÂÍæ¼ÒPKÖµ: remainTime=%s,pkValue=%s" % (remainTime, pkValue), curPlayer.GetPlayerID())
|
return
|
|
def ClearPKValue(curPlayer):
|
'''Çå³ýPKÖµ'''
|
curPlayer.SetPKValue(0)
|
tick = GameWorld.GetGameWorld().GetTick()
|
BuffSkill.DelBuffBySkillID(curPlayer, ChConfig.Def_SkillID_Red, tick)
|
return
|
|
def GetMaxPKValue():
|
'''»ñÈ¡×î´óPKÖµ'''
|
return IpyGameDataPY.GetFuncCfg("PKConfig", 2)
|
|
#---------------------------------------------------------------------
|
##»ñµÃÍæ¼ÒÉý¼¶, »ñµÃµÄÊôÐÔµã
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return ·µ»ØÖµ, »ñµÃµÄÊôÐÔµã
|
# @remarks »ñµÃÍæ¼ÒÉý¼¶, »ñµÃµÄÊôÐÔµã
|
def GetLvUp_AddPoint(curPlayer):
|
curPlayerID = curPlayer.GetID()
|
curLV = curPlayer.GetLV() # µ±Ç°µÈ¼¶
|
|
addPointDict = IpyGameDataPY.GetFuncEvalCfg("LVUPAddPoint", 1, {})
|
addPoint = GameWorld.GetDictValueByRangeKey(addPointDict, curLV, 0)
|
|
if addPoint == None:
|
raise Exception('Íæ¼Ò»ñµÃÉý¼¶ÊôÐÔµãÒì³£, curLV = %s PlayerID = %s' % (curLV, curPlayerID))
|
return
|
return int(addPoint+ GetFabaoAddPoint(curPlayer) + GetTitleAddExtraPoint(curPlayer))
|
|
def GetAllPointByLV(curPlayer):
|
##»ñÈ¡µ±Ç°µÈ¼¶¿ÉµÃµ½ÊôÐÔµãÊý
|
openLV = GameFuncComm.GetFuncLimitLV(ShareDefine.GameFuncID_AddPoint)
|
curLV = curPlayer.GetLV()
|
if curLV < openLV:
|
return 0
|
# ³õʼµã+(Éý¼¶µã+·¨±¦Ð§¹û)*³ÆºÅЧ¹û±¶Êý+¾³½çµã
|
setFreePoint = IpyGameDataPY.GetFuncCfg("LVUPAddPoint", 2)
|
fabaoAddPoint = GetFabaoAddPoint(curPlayer)
|
titleAddPoint = GetTitleAddExtraPoint(curPlayer)
|
addPointDict = IpyGameDataPY.GetFuncEvalCfg("LVUPAddPoint", 1, {})
|
for rangLVs, point in addPointDict.items():
|
if curLV < rangLVs[0]:
|
continue
|
setFreePoint += (point + fabaoAddPoint + titleAddPoint) * (min(curLV, rangLVs[1]) - rangLVs[0] + 1)
|
|
#¾³½çÌáÉýµãÊý
|
setFreePoint += curPlayer.GetOfficialRank() * IpyGameDataPY.GetFuncCfg("LVUPAddPoint", 3)
|
return setFreePoint
|
|
def GetTitleAddExtraPoint(curPlayer):
|
# ³ÆºÅ¶îÍâÔö¼ÓÍæ¼Òÿ¼¶»ñµÃµÄÁé¸ùµã
|
titleID = IpyGameDataPY.GetFuncCfg("TitleAddPoint")
|
if titleID and curPlayer.GetDienstgradManager().GetDienstgrad(titleID):
|
return IpyGameDataPY.GetFuncCfg("TitleAddPoint", 2)
|
return 0
|
|
def GetFabaoAddPoint(curPlayer):
|
#·¨±¦¶îÍâÔö¼ÓÍæ¼Òÿ¼¶»ñµÃµÄÁé¸ùµã
|
mwID = IpyGameDataPY.GetFuncCfg('FabaoAddPoint', 1)
|
if not PlayerMagicWeapon.GetIsActiveMagicWeapon(curPlayer, mwID, lv=1):
|
return 0
|
return IpyGameDataPY.GetFuncCfg('FabaoAddPoint', 2)
|
|
def DoAddPointOpen(curPlayer):
|
'''¼Óµã¹¦ÄÜ¿ªÆô'''
|
beforeFreePoint = curPlayer.GetFreePoint()
|
|
setFreePoint = GetAllPointByLV(curPlayer)
|
curLV = curPlayer.GetLV()
|
addDataDict = {'beforeFreePoint':beforeFreePoint}
|
curPlayer.SetFreePoint(setFreePoint)
|
DataRecordPack.DR_Freepoint(curPlayer, "AddPointOpen", setFreePoint, addDataDict)
|
GameWorld.DebugLog(' ¼Óµã¹¦ÄÜ¿ªÆô´¦Àí beforeFreePoint=%s,curLV=%s, setFreePoint=%s'%(beforeFreePoint, curLV, setFreePoint), curPlayer.GetID())
|
return
|
|
|
#---------------------------------------------------------------------
|
###############################################################
|
#ÈËÎï¿ØÖÆÀà
|
|
## ÈËÎï¿ØÖÆÀà
|
#
|
# ÈËÎïËÀÍöµÈÂß¼´¦Àí
|
class PlayerControl:
|
__Player = None
|
|
#---------------------------------------------------------------------
|
## ³õʼ»¯
|
# @param self ÀàʵÀý
|
# @param iPlayer Íæ¼ÒʵÀý
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks ³õʼ»¯
|
def __init__(self, iPlayer):
|
self.__Player = iPlayer
|
|
## ¼Ó¾ÑéÖµ
|
# @param self ÀàʵÀý
|
# @param addExp Ìí¼ÓµÄ¾Ñé
|
# @param exp_rate ¾Ñ鱶ÂÊ
|
# @param expViewType ¾Ñé»ñµÃµÄÇþµÀ
|
# @param isSysHint ÊÇ·ñϵͳÌáʾ£¨Ä¬ÈÏÊÇ£©
|
# @return ²¼¶ûÖµ
|
def AddExp(self, addExp, expViewType=ShareDefine.Def_ViewExpType_Mission, isSysHint=True, addSkillID=0, expRateEx=0):
|
curPlayer = self.__Player
|
finalAddExp, expNotifyType = self.__AddExp(curPlayer, addExp, expViewType, isSysHint, addSkillID, expRateEx)
|
|
# ֪ͨ¿Í»§¶Ë¾ÑéÀ´Ô´
|
if finalAddExp:
|
sendPack = ChPyNetSendPack.tagMCAddExp()
|
sendPack.ExpPoint = finalAddExp / ChConfig.Def_PerPointValue
|
sendPack.Exp = finalAddExp % ChConfig.Def_PerPointValue
|
sendPack.Source = expNotifyType # ¿Í»§¶ËչʾÓÃ
|
NetPackCommon.SendFakePack(curPlayer, sendPack)
|
|
#¸±±¾»ñµÃ¾Ñé, ÎÞÂÛ»ñµÃ¶àÉÙ¾Ñé¾ùÐè֪ͨ, ÓÐЩ¸±±¾Âß¼ÐèҪͨ¹ý»ñµÃ¾Ñéʱ»ú´¦Àí
|
#if GameWorld.GetMap().GetMapFBType() != IPY_GameWorld.fbtNull:
|
# FBLogic.OnGetExp(curPlayer, finalAddExp, expViewType)
|
|
return finalAddExp
|
|
# ²ÎÊý addSkillID ±íʾÒòʲô¼¼ÄÜɱËÀNPC»ñµÃ¾Ñé
|
def __AddExp(self, curPlayer, addExp, expViewType, isSysHint, addSkillID=0, expRateEx=0):
|
if addExp <= 0:
|
# ²»½øÈë¼ÆËã
|
return addExp, expViewType
|
|
#È¡µÃÈËÎﵱǰ¾Ñé
|
curTotalExp = GetPlayerTotalExp(curPlayer)
|
|
maxLV = GetPlayerMaxLV(curPlayer)
|
maxLVExpStore = IpyGameDataPY.GetFuncCfg("PlayerMaxLV", 2)
|
|
curLV = curPlayer.GetLV()
|
|
# ¼ì²é×î´óµÈ¼¶£¬maxLVExpStore -1ʱ²»ÏÞÀۼƾÑéÉÏÏÞ
|
if curLV >= maxLV and curTotalExp >= maxLVExpStore and maxLVExpStore != -1:
|
self.__NotifyExpFull(curPlayer, "GeRen_admin_825676")
|
GameWorld.DebugLog("¾ÑéÒÑÂú£¡ÒÑÂú¼¶£¡curLV=%s,maxLV=%s,curTotalExp=%s >= maxLVExpStore=%s" % (curLV, maxLV, curTotalExp, maxLVExpStore), curPlayer.GetPlayerID())
|
return 0, expViewType
|
|
# ɱ¹Ö
|
if expViewType == ShareDefine.Def_ViewExpType_KillNPC:
|
exp_rate = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_TotalExpRate)
|
elif expViewType in [ShareDefine.Def_ViewExpType_GameEvent, ShareDefine.Def_ViewExpType_Sit]:
|
exp_rate = curPlayer.GetGameEventExpRate()
|
#exp_rate += GetFamilySitExpPer(curPlayer)
|
else:
|
exp_rate = max(GameWorld.GetGameWorld().GetExpRate(), ChConfig.Def_MaxRateValue)
|
|
exp_rate += expRateEx
|
#ÊäÈëµÄ¾ÑéÓпÉÄÜΪlongÐÍ
|
addExp = int(addExp * exp_rate / float(ChConfig.Def_MaxRateValue))
|
|
# ²»¿ÉÔÙÉý¼¶Ê±£¬Ôö¼ÓºóµÄ¾Ñé²»¿É³¬¹ý×î´ó¿É´æ´¢¾Ñé
|
if curLV >= maxLV and maxLVExpStore > 0:
|
addExp = min(addExp, max(0, maxLVExpStore - curTotalExp))
|
|
if addExp <= 0:
|
#ÎÞ·¨»ñµÃ¾Ñé
|
GameWorld.DebugLog("ÎÞ·¨»ñµÃ¾Ñé")
|
return 0, expViewType
|
|
#¸øÈËÎï¾Ñé ÏÈÉè¾ÑéºóÉý¼¶
|
totalExp = curTotalExp + addExp
|
curExp = totalExp % ChConfig.Def_PerPointValue
|
expPoint = totalExp / ChConfig.Def_PerPointValue
|
|
if curPlayer.GetExpPoint() != expPoint:
|
curPlayer.SetExpPoint(expPoint)
|
if curPlayer.GetTotalExp() != curExp:
|
curPlayer.SetTotalExp(curExp)
|
|
if curLV < maxLV:
|
self.PlayerLvUp()
|
|
#Ìí¼Ó¾Ñé³É¹¦
|
return addExp, expViewType
|
|
## ¾ÑéÂúÌáʾ
|
def __NotifyExpFull(self, curPlayer, expFullNotifyMark):
|
expFullNotifyState = curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_ExpFullNotify)
|
if not expFullNotifyState:
|
NotifyCode(curPlayer, expFullNotifyMark)
|
curPlayer.SetDict(ChConfig.Def_PlayerKey_ExpFullNotify, 1)
|
return
|
|
## ÈËÎïÉý¼¶ »ØÂúѪ »ØÂúħ£¬´¥·¢Ìí¼Ó¼¼ÄÜ£¬ÈÎÎñ£¬¼ÓÊôÐԵ㣨ÔÀ´²¿·Öº¯Êý²Ù×÷·ÅÔÚ¼Ó¾ÑéÖÐ ÏÖÔÚÌá³öÀ´£©
|
# @param handLvUp: ÊÇ·ñÊÇÊÖ¶¯Éý¼¶
|
# @return: None
|
# @remarks: Èç¹ûÊÇ×Ô¶¯Éý¼¶²»¸ø²ÎÊý ¶øÈç¹ûÊÇÊÖ¶¯Éý¼¶ÐèÒª¸ø²ÎÊý ÊÇÊÖ¶¯Éý¼¶ True
|
# 1-20¼¶×Ô¶¯Éý¼¶Ö±½Ó¼Óµã Ö®ºó±ØÐëÊÖ¶¯Éý¼¶ ¸ø×ÔÓÉÊôÐÔµã
|
def PlayerLvUp(self, handLvUp=False):
|
curPlayer = self.__Player
|
|
#if GameObj.GetHP(curPlayer) <= 0:
|
# #Íæ¼ÒËÀÍö²»¿ÉÉý¼¶
|
# return
|
|
lvIpyData = GetPlayerLVIpyData(curPlayer.GetLV())
|
if not lvIpyData:
|
return
|
lvUpNeedExp = GetLVUPTotalExpNeed(lvIpyData)
|
if lvUpNeedExp <= 0:
|
return
|
|
#Ôö¼Ó¾Ñé
|
curTotalExp = GetPlayerTotalExp(curPlayer)
|
#δ´ïµ½Éý¼¶¾Ñé
|
if curTotalExp < lvUpNeedExp:
|
return
|
playerNeedDoLVUp = False
|
curLV = curPlayer.GetLV()
|
maxLV = GetPlayerMaxLV(curPlayer)
|
|
curPlayer.BeginRefreshState()
|
#befXP = curPlayer.GetXP()
|
befLV = curPlayer.GetLV()
|
#befFreePoint = curPlayer.GetFreePoint()
|
|
while curTotalExp >= lvUpNeedExp and curLV < maxLV:
|
|
playerNeedDoLVUp = True
|
|
#---ÈËÎïÉý¼¶³É¹¦---
|
curLV = curLV + 1
|
|
isNotifyServer = True
|
if curLV < 50:
|
# ¼õÉÙÇ°ÆڵĹ㲥£¬³ÌÐò¿ØÖÆ
|
isNotifyServer = False
|
|
curPlayer.SetLV(curLV, isNotifyServer)
|
#EventReport.WriteEvent_level_up(curPlayer)
|
|
# ¼Ç¼Íæ¼ÒÉý¼¶
|
DataRecordPack.DR_PlayerUpgrade(curPlayer, curPlayer.GetLV(), GetPlayerTotalExp(curPlayer), lvUpNeedExp)
|
DataRecordPack.Cache_FightPowerChangeInfo(curPlayer, ChConfig.PowerDownType_LVUP, {'lv':curLV})
|
self.__GiveLVMailAward(curLV)
|
#self.__DoLVUPAddPoint() # Éý¼¶¼Óµã
|
#self.__DoLvUpAddSkill() # Éý¼¶¼Ó¼¼ÄÜ
|
|
lvIpyData = GetPlayerLVIpyData(curPlayer.GetLV())
|
|
#---ÊÇ·ñ¼ÌÐøÑ»·---
|
curTotalExp = curTotalExp - lvUpNeedExp
|
|
#»ñµÃÏÂÒ»¼¶µÄ¾Ñé±í
|
lvUpNeedExp = GetLVUPTotalExpNeed(lvIpyData)
|
|
if lvUpNeedExp <= 0:
|
break
|
|
curPlayer.EndRefreshState() # ½áÊøˢкó£¬Óбä¸üµÄÊôÐÔҪ֪ͨ¿Í»§¶ËµÄÐèÖØÐÂÉèÖÃÒ»´Î
|
#---------------------------------------------------
|
#ÓÐÉý¼¶, תÉúʱ¸ÕºÃÊÇתÉúµÈ¼¶»áĬÈÏ+1¼¶
|
if playerNeedDoLVUp:
|
aftLV = curPlayer.GetLV()
|
#aftFreePoint = curPlayer.GetFreePoint()
|
if aftLV > befLV:
|
curPlayer.SetLV(aftLV, False) # ÕâÀï²»ÔÙ֪ͨGameServer
|
PlayerTongTianLing.AddTongTianTaskValue(curPlayer, ChConfig.TTLTaskType_LVUp, aftLV - befLV)
|
PlayerTask.UpdTaskValue(curPlayer, ChConfig.TaskType_LV)
|
PlayerSuccess.UptateSuccessProgress(curPlayer, ShareDefine.SuccType_HeroLV, aftLV)
|
PlayerActivity.DoAddActivityByLV(curPlayer, befLV, aftLV)
|
|
#if aftFreePoint > befFreePoint:
|
# curPlayer.SetFreePoint(aftFreePoint)
|
PlayerGubao.DoGubaoAddFreePoint(curPlayer)
|
|
# Éý¼¶ÐèÒªÖ´ÐеÄÓÎÏ·¹¦ÄÜ´¦Àí
|
GameFuncComm.DoFuncOpenLogic(curPlayer)
|
#ChEquip.RefreshPlayerLingQiEquipAttr(curPlayer) # ÁéÆ÷ÊôÐÔ»áËæµÈ¼¶³É³¤
|
#if aftLV%10 == 0:
|
# # ¿ØÖÆÏÂˢдÎÊý
|
# PlayerPet.CalcPetItemAddPlayerAttr(curPlayer) # ³èÎïÓÐËæµÈ¼¶±ä»¯µÄ¼¼ÄÜ
|
|
PlayerOnline.CalcRoleBase(curPlayer)
|
PlayerOnline.GetOnlinePlayer(curPlayer).RefreshRoleAttr()
|
|
#½«ÑªÉèÖÃΪ×î´ó
|
#GameObj.SetHPFull(curPlayer)
|
#if curPlayer.GetMaxMP() > 0:
|
# curPlayer.SetMP(curPlayer.GetMaxMP())
|
|
FBLogic.OnPlayerLVUp(curPlayer)
|
# ¼Ç¼¿ª·þ»î¶¯³å¼¶Êý¾Ý
|
#OpenServerCampaign.UpdOpenServerCampaignRecordData(curPlayer, ShareDefine.Def_Campaign_Type_LV, curPlayer.GetLV())
|
#ÉñÃØÏÞ¹º
|
FunctionNPCCommon.MysticalLimitShopOpen(curPlayer, befLV, aftLV)
|
|
#²»ÐèÒª×öÉý¼¶ÈÎÎñ, ÉèÖÃÍæ¼Ò¾Ñé
|
SetPlayerTotalExp(curPlayer, curTotalExp)
|
return
|
|
def __GiveLVMailAward(self, curLV):
|
# ¸øµÈ¼¶Óʼþ½±Àø
|
mailLVAwardDict = IpyGameDataPY.GetFuncEvalCfg("MailLVAward", 1, {})
|
if curLV not in mailLVAwardDict:
|
return
|
mailTypeKey, mailItemList = mailLVAwardDict[curLV]
|
curPlayer = self.__Player
|
SendMailByKey(mailTypeKey, [curPlayer.GetPlayerID()], mailItemList, [curLV])
|
return
|
|
#---------------------------------------------------------------------
|
|
## Ë¢ÐÂÍæ¼ÒËùÓÐ״̬
|
# @param self ÀàʵÀý
|
# @param isForce ÊÇ·ñÇ¿ÖÆË¢ÐÂ
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks Ë¢ÐÂÍæ¼ÒËùÓÐ״̬
|
def RefreshAllState(self, isSyncBuff=False, billboardFunc=None, isForce=False):
|
return
|
|
## ÖؼÆË㲢ˢÐÂÍæ¼ÒËùÓÐ״̬, Ä¿Ç°Ö»ÓÃÓëÇл»µØͼ
|
# @param self ÀàʵÀý
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks Ë¢ÐÂÍæ¼ÒËùÓÐ״̬
|
def ReCalcAllState(self):
|
return
|
|
|
# BUFF²ãµ¥¶ÀË¢ÐÂÊôÐÔ£¬¹¦ÄÜÊôÐÔÈ¡»º´æ---------------------------------------------
|
def RefreshPlayerAttrByBuff(self, isForce=False):
|
curPlayer = self.__Player
|
curPlayer.SetDict(ChConfig.Def_Player_RefreshAttrByBuff, 1)
|
|
if isForce:
|
self.RefreshPlayerAttrByBuffEx()
|
return True
|
|
# BUFF²ãµ¥¶ÀË¢ÐÂÊôÐÔ
|
def RefreshPlayerAttrByBuffEx(self):
|
return
|
|
#===========================================================================
|
# #×°±¸ºÍBUFF Ч¹ûµÄ¼ÆËãÒƵ½Íâ²ã
|
# #RefreshPlayerBuffOnAttrAddEffect
|
# #RefreshPlayerEquipAttribute(curPlayer)
|
#===========================================================================
|
## Ë¢ÐÂÍæ¼ÒÊôÐÔµ÷Óô˺¯Êý£¬Á¢¼´Ë¢Ð¸ÄΪ֪ͨˢУ¬ÓÉProcessStatueͳһˢÐÂÒ»´Î
|
## ÅÅÐаñÀàµÄË¢ÐÂisForceÐèҪΪTrue
|
# @param self ÀàʵÀý
|
# @return ·µ»ØÖµÎÞÒâÒå
|
def RefreshPlayerAttrState(self, billboardFunc=None, isForce=False):
|
curPlayer = self.__Player
|
curPlayer.SetDict(ChConfig.Def_Player_RefreshAttr, 1)
|
|
if billboardFunc and billboardFunc not in PyGameData.g_refreshAttrBillboardFunc:
|
PyGameData.g_refreshAttrBillboardFunc.append(billboardFunc)
|
|
if isForce:
|
self.RefreshPlayerAttrStateEx()
|
|
return
|
|
def RefreshPlayerAttrStateEx(self):
|
''' ±¾ÏîÄ¿Ë¢ÊôÐÔ¹æÔò
|
ÊôÐÔ£º
|
1.¹Ì¶¨ÊôÐÔ£ºÈç¹¥»÷+100
|
2.°Ù·Ö±ÈÊôÐÔ£º Èç¹¥»÷+5%£¬°Ù·Ö±È¼Ó³É»ùÖµ½öΪ¹Ì¶¨ÊôÐÔ£¬°Ù·Ö±È¼Ó³ÉÊôÐÔÖµ²»±»³ýbuff°Ù·Ö±ÈÍâµÄÈκΰٷֱÈÊôÐÔ¶þ´Î¼Ó³É
|
|
²ã¼¶£º
|
1.ÊôÐԲ㼶£ºËùÓй¦ÄÜͬһ²ã¼¶
|
2.buff²ã¼¶£º°Ù·Ö±È¿É¶Ô¹¦ÄܰٷֱȼӳɵÄÊôÐÔ½øÐжþ´Î¼Ó³É
|
|
¹¦ÄÜÄ£¿é£º¶¨ÒåÒ»¸ö¹¦ÄÜ£¬±ÈÈçÁé¸ùÄ£¿é£¬Ò»¸öÄ£¿é¿ÉÄÜ°üº¬¶à¸ö¹¦Äܵã
|
¹¦Äܵ㣺ij¸öÄ£¿éϵĸ÷¸öÊôÐÔ¹¦Äܵ㣬ÈçÁé¸ùÄ£¿é¿ÉÄÜ°üº¬ Áé¸ù»ù´¡¡¢Áé¸ùÆ·ÖÊ Á½¸ö¹¦ÄܵãÊôÐÔ
|
|
°Ù·Ö±È¼Ó³ÉÖµ£º°Ù·Ö±È¼Ó³ÉÊôÐÔÖµ²»±»³ýbuff°Ù·Ö±ÈÍâµÄÈκΰٷֱÈÊôÐÔ2´Î¼Ó³É
|
1.¹¦ÄÜÄÚ²¿ÊôÐ԰ٷֱȼӳɣº¹¦ÄÜ°Ù·Ö±ÈÊôÐÔ¶Ô×Ô¼º¹¦Ä̶ܹ¨Öµ¼Ó³É
|
2.¹¦Äܽ»²æÊôÐ԰ٷֱȼӳɣº¹¦ÄÜ°Ù·Ö±ÈÊôÐÔ¶ÔÆäËû¹¦Ä̶ܹ¨Öµ¼Ó³É
|
3.¹¦Ä̶ܹ¨ÊôÐ԰ٷֱȼӳɣº¹¦ÄÜ°Ù·Ö±ÈÊôÐÔ¶ÔËùÓй¦Ä̶ܹ¨Öµ¼Ó³É
|
4.buff²ã¼¶°Ù·Ö±È£º¶ÔËùÓÐÊôÐÔ½øÐжþ´Î¼Ó³É
|
|
¼¼ÄÜÊôÐÔ£º¹Ì¶¨Öµ²»ÏíÊ̶ܹ¨°Ù·Ö±È¼Ó³É
|
|
buff²ã¼¶£º
|
1.²»ËãÕ½Á¦
|
2.ÏÈËã°Ù·Ö±È¼Ó³ÉÔټӹ̶¨Öµ
|
|
ÊôÐÔËã·¨£º
|
Ä£¿é¹Ì¶¨ÊôÐÔ = ¹¦ÄܵãA¹Ì¶¨Öµ + ¹¦ÄܵãB¹Ì¶¨Öµ + ...
|
¹Ì¶¨×ÜÊôÐÔ = Ä£¿éA¹Ì¶¨Öµ + Ä£¿éB¹Ì¶¨Öµ + ...
|
ÎÞbuff×ÜÊôÐÔ = ¹Ì¶¨×ÜÊôÐÔ + ÄÚ²¿°Ù·Ö±È¼Ó³ÉÖµ + ½»²æ°Ù·Ö±È¼Ó³É + ¹Ì¶¨×ÜÊôÐÔ°Ù·Ö±È¼Ó³É + ¼¼ÄܰٷֱȶԹ̶¨ÊôÐÔ¼Ó³É + ¼¼Ä̶ܹ¨Öµ
|
º¬buff×ÜÊôÐÔ = ÎÞbuff×ÜÊôÐÔ * buff°Ù·Ö±È¼Ó³É + buff¹Ì¶¨Öµ
|
'''
|
return
|
|
## Ë¢ÐÂÍæ¼Ò¼¼ÄÜÕ½¶·Á¦
|
# @param self ÀàʵÀý
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks Ë¢ÐÂÍæ¼Ò±»¶¯¼¼ÄÜBuff
|
def RefreshAllSkill(self):
|
return
|
|
## ¼¼ÄÜÉý¼¶Ë¢ÊôÐÔÕ½¶·Á¦´¦Àí
|
def RefreshSkillFightPowerEx(self, skillID, beforeFightPower, isRefreshState=True):
|
return
|
|
def RefreshSkillFightPowerByDel(self, delSkillID, isRefreshState=True):
|
return
|
|
## ¼ÆËã±»¶¯buffÊôÐÔ¼Ó³É
|
# @param self ÀàʵÀý
|
# @return
|
def CalcPassiveBuffAttr(self):
|
return
|
|
## Ë¢ÐÂÍæ¼ÒËùÓÐÐÐΪBUFF״̬
|
# @param self ÀàʵÀý
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks Ë¢ÐÂÍæ¼ÒËùÓÐÐÐΪBUFF״̬
|
def RefreshPlayerActionState(self):
|
return
|
|
#---------------------------------------------------------------------
|
## ½«Íæ¼ÒÉèÖõ½ÖØÉúµã
|
# @param self ÀàʵÀý
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks ½«Íæ¼ÒÉèÖõ½ÖØÉúµã
|
def SetToBornPlace(self):
|
curPlayer = self.__Player
|
mapFBType = GameWorld.GetMap().GetMapFBType()
|
#Íæ¼Ò²»ÔÚ¸±±¾ÖÐ
|
if mapFBType == IPY_GameWorld.fbtNull:
|
# gameMap = GameWorld.GetMap()
|
# rebornMapID = gameMap.GetRebornMapID()
|
# rebornPosX = gameMap.GetRebornMapX()
|
# rebornPosY = gameMap.GetRebornMapY()
|
#
|
# #ÑéÖ¤ÊÇ·ñ±¾µØͼ¸´»îµã ½øÐÐÂß¼´¦Àí
|
# if gameMap.GetMapID() == rebornMapID:
|
# posX, posY = GameMap.GetNearbyPosByDis(rebornPosX, rebornPosY, ChConfig.Def_RebornPos_Area_Range)
|
# else:
|
# posX, posY = rebornPosX, rebornPosY
|
#
|
# #ÕÒ²»µ½·ÇÕÏ°µã¸´»î£¬ÔòÉèΪÍæ¼ÒµÄÖØÉúµã¸´»î
|
# if posX <= 0 or posY <= 0 or rebornMapID <= 0:
|
# rebornMapID = curPlayer.GetRebornMapID()
|
# posX = curPlayer.GetRebornPosX()
|
# posY = curPlayer.GetRebornPosY()
|
rebornMapID = curPlayer.GetRebornMapID()
|
rebornPosX = curPlayer.GetRebornPosX()
|
rebornPosY = curPlayer.GetRebornPosY()
|
|
#Íæ¼ÒÔÚ¸±±¾ÖÐ
|
else:
|
rebornMapID = curPlayer.GetFBRebornMapID()
|
rebornPosX = curPlayer.GetFBRebornPosX()
|
rebornPosY = curPlayer.GetFBRebornPosY()
|
|
if rebornMapID == 0:
|
NotifyCode(curPlayer, "ObjectMapNonentity")
|
GameWorld.Log("ÈËÎïÖØÉúµØͼID = %sÒì³£!" % (rebornMapID) , curPlayer.GetPlayerID())
|
return
|
|
if rebornMapID == curPlayer.GetMapID():
|
GameWorld.ResetPlayerPos(curPlayer, rebornPosX, rebornPosY)
|
return
|
|
#°ÑÈËÎïÉèÖûØÖØÉúµã
|
PlayerResetWorldPos(curPlayer, rebornMapID, rebornPosX, rebornPosY)
|
return
|
|
#---------------------------------------------------------------------
|
## Íæ¼ÒËÀÍöÂß¼
|
# @param self ÀàʵÀý
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks Íæ¼ÒËÀÍöÂß¼
|
def SetDead(self):
|
#Ö÷½ÇÉèÖÃΪËÀÍö״̬
|
curPlayer = self.__Player
|
|
#֪ͨ¸±±¾Íæ¼ÒËÀÍö
|
FBLogic.DoPlayerDead(curPlayer)
|
|
#Íæ¼Ò״̬´¦Àí
|
ReSetPlayerState(curPlayer)
|
|
#Çå¿ÕËùÓÐËÀÍö²»±£ÁôµÄbuff
|
self.__PlayerDeadClearBuff()
|
|
#ɱËÀËùÓÐÕÙ»½µÄÁé
|
KillPlayerSummonNPC(curPlayer)
|
|
#ÕÙ»½»Ø³öÕ½µÄ³èÎï
|
PetControl.ReCallFightPet(curPlayer)
|
|
#Çå¿ÕʹÓü¼ÄܼǼ
|
curPlayer.ClearUseSkillRec()
|
|
#¸ÄΪ¸´»îµÄʱºòË¢ÐÂ״̬
|
#===============================================================================
|
# #Ë¢ÐÂ״̬
|
# self.RefreshAllState()
|
#===============================================================================
|
|
if GameObj.GetHP(curPlayer) != 0:
|
GameObj.SetHP(curPlayer, 0)
|
|
#Çå¿ÕÒƶ¯´íÎó¾àÀë
|
GameWorld.ClearPlayerPosCount(curPlayer)
|
|
#¼Ç¼Ö÷½ÇËÀÍö´ÎÊýºÍËÀÍöʱ¼ä
|
self.SetPlayerDeadCnt(curPlayer)
|
|
#ËÀÍö´¥·¢¼¼ÄÜ
|
tick = GameWorld.GetGameWorld().GetTick()
|
|
#֪ͨËÀÍö
|
DoPlayerDead(curPlayer)
|
|
GameObj.ClearPyPlayerState(curPlayer)
|
|
MirrorAttack.OnPlayerDead(curPlayer)
|
return
|
|
|
## ¼Ç¼Ö÷½ÇËÀÍö´ÎÊý
|
# @param self ÀàʵÀý
|
# @return ·µ»ØÖµÎÞÒâÒå
|
def SetPlayerDeadCnt(self, curPlayer):
|
#playerLv = curPlayer.GetLV()
|
#¼Ç¼ËÀÍöʱ¼ä
|
NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_DeadTime, int(time.time()))
|
#ÉíÉÏÓÐ5²ã¸´»îÆ£ÀÍbuffʱÔټǼ
|
findBuff = SkillCommon.FindBuffByID(curPlayer, ChConfig.Def_SkillID_ReviveTired)[0]
|
if not (findBuff and findBuff.GetSkill().GetSkillLV() == findBuff.GetSkill().GetSkillMaxLV()):
|
return
|
|
# if playerLv < int(ReadChConfig.GetEvalChConfig('BeginRecordDeadCntLV')):
|
# return
|
|
#ÉϴμǼµÄÍæ¼ÒËÀÍö´ÎÊý
|
# lastDeadCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_PlayerDeadCnt)
|
# #GameWorld.Log("ÉÏ´ÎÍæ¼ÒËÀÍö´ÎÊý=%s"%lastDeadCnt)
|
#
|
# #ËÀÍö´ÎÊý×î´óÀÛ¼ÓÖµ
|
# maxDeadCnt = int(ReadChConfig.GetEvalChConfig('PlayerDeadMaxCnt'))
|
#
|
# #»ñÈ¡ÉÏ´ÎËÀÍöʱ¼ä
|
# lastDeadTimeTick = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_DeadTime)
|
# #GameWorld.Log("»ñÈ¡ÉÏ´ÎËÀÍöʱ¼ä=%s"%lastDeadTimeTick)
|
#
|
# #ÿ¸ô¼¸ºÁÃë¼õÒ»´ÎËÀÍö´ÎÊý
|
# timeSpace = int(ReadChConfig.GetEvalChConfig('DelDeadCntTime'))
|
#
|
# #µ±Ç°Ê±¼ä
|
# curGameWorldTick = int(time.time())
|
# delCnt = max(curGameWorldTick - lastDeadTimeTick, 0) / timeSpace
|
#
|
# #GameWorld.Log("###delCnt=%s"%delCnt)
|
# #µ±Ç°ËÀÍö´ÎÊý(°üÀ¨Õâ´ÎËÀµÄ)
|
# curDeadCnt = min(max(lastDeadCnt - delCnt, 0) + 1, maxDeadCnt)
|
#
|
# #GameWorld.Log("###curDeadCnt=%s"%curDeadCnt)
|
# #GameWorld.Log("###curTimeTick=%s"%curGameWorldTick)
|
# #¼Ç¼µ±Ç°ËÀÍö´ÎÊý
|
# NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_PlayerDeadCnt, curDeadCnt)
|
|
#֪ͨËÀÍöʱ¼ä
|
self.NotifyPlayerDeadTime(curPlayer)
|
return
|
|
## ֪ͨÉÏ´ÎËÀÍöʱ¼ä
|
# @param self ÀàʵÀý
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks Íæ¼ÒËÀÍöÂß¼, ºìÃûµôÂä
|
def NotifyPlayerDeadTime(self, curPlayer):
|
#Èç¹ûÓÐ5²ã¸´»îÆ£ÀÍbuff ²¢ÇÒÊDZ»Íæ¼ÒɱËÀµÄÔò֪ͨ
|
findBuff = SkillCommon.FindBuffByID(curPlayer, ChConfig.Def_SkillID_ReviveTired)[0]
|
if findBuff and findBuff.GetSkill().GetSkillLV() == findBuff.GetSkill().GetSkillMaxLV():
|
if curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_IsAddReviveTired):
|
lastDeadTimeTick = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_DeadTime)
|
packData = ChPyNetSendPack.tagMCPlayerDeadTime()
|
packData.DeadTime = lastDeadTimeTick
|
NetPackCommon.SendFakePack(curPlayer, packData)
|
return
|
|
#---------------------------------------------------------------------
|
## Çå¿ÕËùÓеĿÉÒÔɾ³ýµÄbuff
|
# @param self ÀàʵÀý
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks Çå¿ÕËùÓеĿÉÒÔɾ³ýµÄbuff
|
def __PlayerDeadClearBuff(self):
|
curPlayer = self.__Player
|
tick = GameWorld.GetGameWorld().GetTick()
|
|
#ÐèÒª¿¼ÂÇbuff,deBuff,aura,incBuff,mapBuff,³ýÁËequipBuff²»¿¼ÂÇ
|
PlayerClearBuff_Single(curPlayer, curPlayer.GetBuffState(), ClearBuffByDie, tick)
|
PlayerClearBuff_Single(curPlayer, curPlayer.GetDeBuffState(), ClearBuffByDie, tick)
|
PlayerClearBuff_Single(curPlayer, curPlayer.GetAura(), ClearBuffByDie, tick)
|
PlayerClearBuff_Single(curPlayer, curPlayer.GetIncBuff(), ClearBuffByDie, tick)
|
PlayerClearBuff_Single(curPlayer, curPlayer.GetMapBuff(), ClearBuffByDie, tick)
|
PlayerClearBuff_Single(curPlayer, curPlayer.GetActionBuffManager(), ClearBuffByDie, tick)
|
PlayerClearBuff_Single(curPlayer, curPlayer.GetProcessBuffState(), ClearBuffByDie, tick)
|
PlayerClearBuff_Single(curPlayer, curPlayer.GetProcessDeBuffState(), ClearBuffByDie, tick)
|
|
return
|
|
#---------------------------------------------------------------------
|
## Çå¿Õbuff(²ÎÊý -> buff¹ÜÀíÆ÷)
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param buffState buff¹ÜÀíÆ÷
|
# @param tick ʱ¼ä´Á
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks Çå¿Õbuff(²ÎÊý -> buff¹ÜÀíÆ÷)
|
def PlayerClearBuff_Single(curPlayer, buffState, funcClearBuff, tick):
|
|
curPlayerID = curPlayer.GetPlayerID()
|
index = 0
|
buffSkillIDList = []
|
|
passiveEff = PassiveBuffEffMng.GetPassiveEffManager().GetPassiveEff(curPlayer)
|
while index < buffState.GetBuffCount():
|
curBuff = buffState.GetBuff(index)
|
#Òì³£
|
if not curBuff:
|
GameWorld.Log("###Íæ¼ÒÇå¿Õbuffʧ°Ü,Ë÷Òý = %s" % (index), curPlayerID)
|
index += 1
|
continue
|
|
#buff²»Ïûʧ
|
if funcClearBuff and funcClearBuff(curBuff):
|
index += 1
|
continue
|
|
#BuffSkill.DoBuffDisApper(curPlayer, curBuff, tick)
|
#buffSkillIDList.append([curBuff.GetSkill().GetSkillID(), curBuff.GetOwnerID(), curBuff.GetOwnerType()])
|
buffSkillIDList.append(curBuff.GetSkill().GetSkillID())
|
#GameWorld.DebugLog("ËÀÍöÇåÀí-----%s"%curBuff.GetSkill().GetSkillID())
|
if passiveEff:
|
passiveEff.DelBuffInfo(curBuff.GetSkill())
|
|
#ɾ³ýÕâ¸öbuff
|
buffState.DeleteBuffByIndex(index)
|
|
|
SkillShell.ClearBuffEffectBySkillIDList(curPlayer, buffState, buffSkillIDList)
|
return
|
|
|
## ËÀÍöbuffÊÇ·ñÏûʧ
|
# @param curBuff: buffʵÀý
|
# @return: ËÀÍöbuffÊÇ·ñÏûʧ
|
def ClearBuffByDie(curBuff):
|
skill = curBuff.GetSkill()
|
return skill.GetDieContinue() & Def_Buff_Clear_Die > 0
|
|
|
## ÏÂÏßbuffÊÇ·ñÏûʧ
|
# @param curBuff: buffʵÀý
|
# @return: ËÀÍöbuffÊÇ·ñÏûʧ
|
def ClearBuffByDisconnect(curBuff):
|
skill = curBuff.GetSkill()
|
return skill.GetDieContinue() & Def_Buff_Clear_Disconnect > 0
|
|
#---------------------------------------------------------------------
|
##´«Ëͼì²é(ÊÇ·ñ·Ç·¨µØͼ)
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param destMapID Ä¿±êµØͼID
|
# @return ·µ»ØÖµÕæ, ͨ¹ý
|
# @remarks ´«Ëͼì²é
|
def CheckTagCountry(curPlayer, destMapID):
|
gameMap = GameWorld.GetMap()
|
|
if not gameMap.IsMapIDExist(destMapID):
|
GameWorld.ErrLog('###·Ç·¨µØͼÊý¾Ý£¬mapID: %s' % (destMapID), curPlayer.GetPlayerID())
|
NotifyCode(curPlayer, "ObjectMapNonentity")
|
return False
|
|
#===============================================================================
|
# #ÐÂÊִ峡¾°²»ÔÊÐí½øÈëºÍ´«³ö
|
# if GameWorld.GetMap().GetMapID() == 21 or destMapID == 21:
|
# NotifyCode(curPlayer, "CS_VillageHead_Fail")
|
# return
|
#===============================================================================
|
|
#¼ì²éÍæ¼ÒÊÇ·ñ´«Ë͵йú×ø±ê
|
mapCountry = gameMap.GetCountryByMapID(destMapID)
|
|
if not GameWorld.IsSameCountry_Name(mapCountry, curPlayer.GetCountry()):
|
NotifyCode(curPlayer, "Enemy_State_No_Trans")
|
return False
|
|
#¼ì²é´«ËÍÖÁµÄµØͼÊÇ·ñÊÇÆÕͨµØͼ
|
if gameMap.GetMapFBTypeByMapID(destMapID) != IPY_GameWorld.fbtNull:
|
#¸±±¾ºÍ»î¶¯³¡¾°ÎÞ·¨´«ËÍ
|
NotifyCode(curPlayer, "Carry_lhs_306641")
|
return False
|
|
#¼ì²éÍæ¼ÒµÈ¼¶ÊÇ·ñ×ã¹»½øÈë´ËµØͼ
|
if not CanEnterMap(curPlayer, destMapID):
|
return False
|
|
#¼ì²é´ËµØͼÊÇ·ñΪָ¶¨·ÖÁ÷ÓµÓеÄ
|
mapLineID = GetPlayerLineID(curPlayer)
|
|
mapLineCheckDict = ReadChConfig.GetEvalChConfig('TransportMapLineCheck')
|
canEnterLineID = 0
|
|
for lineID, mapIDList in mapLineCheckDict.items():
|
if destMapID not in mapIDList:
|
continue
|
|
if mapLineID == lineID:
|
#´Ë·ÖÁ÷¿ÉÒÔ½øÈë
|
return True
|
|
#¼Ç¼һÏ¿ÉÒÔ½øÈëµÄÏß·
|
canEnterLineID = lineID
|
|
if canEnterLineID > 0:
|
#´Ë·ÖÁ÷²»¿É½øÈë
|
NotifyCode(curPlayer, "Carry_yeqian_0", [destMapID, canEnterLineID])
|
return False
|
|
#¿ÉÒÔ½øÈë
|
return True
|
#---------------------------------------------------------------------
|
##²éÍæ¼ÒµÈ¼¶ÊÇ·ñ×ã¹»½øÈë´ËµØͼ
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param destMapID Ä¿±êµØͼID
|
# @return ·µ»ØÖµÕæ, ͨ¹ý
|
# @remarks ²éÍæ¼ÒµÈ¼¶ÊÇ·ñ×ã¹»½øÈë´ËµØͼ
|
def CanEnterMap(curPlayer, destMapID, isShowSys=True):
|
#µØͼÌØÊâ¼ì²é
|
#if not CheckEquipCanTrans(curPlayer, destMapID):
|
#return False
|
|
if not CheckLVCanEnterMap(curPlayer, destMapID, isShowSys):
|
return False
|
|
return True
|
|
|
##²éÍæ¼ÒµÈ¼¶ÊÇ·ñ×ã¹»½øÈë´ËµØͼ
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param destMapID Ä¿±êµØͼID
|
# @return ·µ»ØÖµÕæ, ͨ¹ý
|
def CheckLVCanEnterMap(curPlayer, destMapID, isShowSys=True):
|
mapData = GameWorld.GetGameData().GetChinMap().GetMapByID(destMapID)
|
if not mapData:
|
return
|
enterLV = mapData.GetLV()
|
|
if curPlayer.GetLV() < enterLV:
|
#¶Ô²»Æ𣬸ó¡¾°ÐèÒªXX¼¶²ÅÄܽøÈë!
|
if isShowSys:
|
NotifyCode(curPlayer, "Carry_hwj35_0", [enterLV])
|
return False
|
openMapStep = mapData.GetTreasureID() #ÐèÒªÍê³ÉµÄÖ÷ÏßÈÎÎñID
|
if openMapStep and not IsMapOpen(curPlayer, openMapStep):
|
#GameWorld.DebugLog('¶Ô²»Æ𣬸ó¡¾°destMapID=%sÐèÒªÍê³ÉÖ÷ÏßÈÎÎñ%s²ÅÄܽøÈë!' % (destMapID, openMapStep))
|
return False
|
return True
|
|
|
def IsMapOpen(curPlayer, openMapStep):
|
# Ö÷ÏßÈÎÎñÍê³Éʱ»áÉèÖñêÖ¾¿É½øµØͼ±êÖ¾
|
return False
|
|
#---------------------------------------------------------------------
|
##¹ØÓÚ´«ËÍ ÑéÖ¤Íæ¼Ò״̬
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return ·µ»ØÖµÕæ, ͨ¹ý
|
# @remarks ¹ØÓÚ´«ËÍ ÑéÖ¤Íæ¼Ò״̬
|
def CheckTransState(curPlayer):
|
#¿ÉÒÔ½øÈë´«Ë͵Ä״̬
|
playerAction = curPlayer.GetPlayerAction()
|
if playerAction in ChConfig.Def_Player_Cannot_TransState:
|
#Carry_lhs_697674£ºÄúµ±Ç°Ëù´¦µÄ״̬²»ÄܽøÐд«ËÍ!
|
NotifyCode(curPlayer, "Carry_lhs_697674")
|
return False
|
|
#Òƶ¯Öв»Ö´Ðд˲Ù×÷
|
if curPlayer.IsMoving():
|
curPlayer.StopMove()
|
|
|
if playerAction == IPY_GameWorld.paSit:
|
DoPlayerStand(curPlayer)
|
|
#ÇëÇó´«ËÍ״̬, ÅжϷþÎñ¶ËÏÞÖÆ
|
if not OperControlManager.IsObjCanDoAction(
|
curPlayer,
|
ChConfig.Def_Obj_ActState_ServerAct,
|
IPY_GameWorld.oalTransmit
|
):
|
return False
|
|
return True
|
#---------------------------------------------------------------------
|
##Çå³ýÓÐÏÞÎÞµÐBUF
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param tick ʱ¼ä´Á
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks Çå³ýÓÐÏÞÎÞµÐBUF
|
def DelLimitSuperBuff(curPlayer, tick):
|
if curPlayer.GetCanAttack():
|
return
|
|
if not tick:
|
tick = GameWorld.GetGameWorld().GetTick()
|
|
if BuffSkill.DelBuffBySkillID(curPlayer, ChConfig.Def_SkillID_LimitSuperBuff, tick):
|
|
PlayerControl(curPlayer).RefreshPlayerAttrByBuff()
|
|
#---------------------------------------------------------------------
|
##ÌØÊâ״̬´¦Àí
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks ÌØÊâ״̬´¦Àí
|
def ReSetPlayerState(curPlayer):
|
tick = GameWorld.GetGameWorld().GetTick()
|
|
#---Íæ¼Ò״̬´¦Àí---
|
curPlayerAction = curPlayer.GetPlayerAction()
|
|
#Íæ¼Ò½»Ò×ÖÐ, À뿪½»Ò×
|
if curPlayerAction == IPY_GameWorld.paTrade:
|
pass
|
|
#Íæ¼Òʼþ״̬ÖÐ, Í˳öʼþ
|
elif curPlayerAction == IPY_GameWorld.paEvent:
|
pass
|
|
elif curPlayerAction == IPY_GameWorld.paGameEvent:
|
pass
|
|
if curPlayerAction == IPY_GameWorld.paPreparing:
|
DoExitPreparing(curPlayer)
|
|
#---Íæ¼Ò½»Í¨¹¤¾ß´¦Àí---
|
curPlayerVehicle = curPlayer.GetPlayerVehicle()
|
|
#Íæ¼ÒÆïÂíÖÐ, ÏÂÂí
|
if curPlayerVehicle == IPY_GameWorld.pvHorse:
|
#Ö´ÐÐÏÂÂíÂß¼
|
PlayerHorse.PlayerRideHorseDown(curPlayer, False)
|
|
#---ÆäËûϵͳ´¦Àí---
|
|
#ÖжÏÕ½¶·¶ÔÖÅ
|
ExitPlayerConfronting(curPlayer)
|
|
#Çå¿Õµ±Ç°¹¥»÷¶ÔÏó
|
curPlayer.SetActionObj(None)
|
return
|
#---------------------------------------------------------------------
|
##³õʼ»¯Öк͵Øͼ¶Áȡʱ²»À»Ø
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks ³õʼ»¯Öк͵Øͼ¶Áȡʱ²»À»Ø
|
def __CanPullPlayer(curPlayer):
|
if not curPlayer.GetInitOK():
|
return False
|
|
if curPlayer.GetIsLoginOff():
|
return False
|
|
return True
|
#------------------------------------------------------------------------------------
|
##·µ»ØÍæ¼Òµ±Ç°ÊÇ·ñÔÚ¿ÕÏÐ״̬
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return ÊÇ·ñÔÚ¿ÕÏÐ״̬
|
# @remarks ·µ»ØÍæ¼Òµ±Ç°ÊÇ·ñÔÚ¿ÕÏÐ״̬£¨²ß»®²ãÃæÉϵĿÕÏУ©
|
def IsPlanStateNull(curPlayer):
|
|
#·Ç¿ÕÏÐ״̬
|
if curPlayer.GetPlayerAction() != IPY_GameWorld.paNull:
|
return False
|
|
#Òƶ¯ÖÐ
|
if curPlayer.IsMoving():
|
return False
|
|
#Õ½¶·ÖÐ
|
if curPlayer.IsBattleState():
|
return False
|
|
# #¶ÔÖÅÖÐ
|
# if curPlayer.GetIsConfronting():
|
# return False
|
|
# #Ñ£ÔÎÖÐ
|
# if curPlayer.GetAbnormalState() == IPY_GameWorld.sctFaint:
|
# return False
|
|
return True
|
#------------------------------------------------------------------------------------
|
##³õʼ»¯Íæ¼Ò±³°ü.
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks ³õʼ»¯Íæ¼Ò±³°ü
|
def Init_ItemPack(curPlayer):
|
packType = IPY_GameWorld.rptItem
|
|
#³õʼ»¯Íæ¼Ò±³°ü
|
if packType not in ChConfig.Def_Type_CanBuyPack_PlayerDict.keys():
|
return
|
|
#»ñÈ¡Íæ¼Ò±³°ü
|
curPack = curPlayer.GetItemManager().GetPack(packType)
|
|
#ĬÈÏ14¸ñ×Ó + ¿ªÆôµÄ
|
keyName = ChConfig.Def_Type_CanBuyPack_PlayerDict.get(packType)[ChConfig.Def_PlayerPackDict_Index_Key]
|
count = ItemCommon.GetPackInitCount(packType) + curPlayer.NomalDictGetProperty(keyName)
|
curPack.SetCount(count)
|
|
#֪ͨ¿Í»§¶Ë±³°ü¸ñ×ÓÊýÄ¿
|
# curPlayer.Sync_ItemCount(curPack.GetCount())
|
curPack.Sync_PackCanUseCount()
|
return
|
|
#------------------------------------------------------------------------------------
|
##³õʼ»¯Íæ¼Ò²Ö¿â.
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks ³õʼ»¯Íæ¼Ò²Ö¿â
|
def Init_Warehouse(curPlayer):
|
|
packType = IPY_GameWorld.rptWarehouse
|
|
#³õʼ»¯Íæ¼Ò±³°ü
|
if packType not in ChConfig.Def_Type_CanBuyPack_PlayerDict.keys():
|
return
|
|
#»ñÈ¡Íæ¼Ò±³°ü
|
curPack = curPlayer.GetItemManager().GetPack(packType)
|
|
#ĬÈÏ42¸ñ×Ó + ¿ªÆôµÄ
|
keyName = ChConfig.Def_Type_CanBuyPack_PlayerDict.get(packType)[ChConfig.Def_PlayerPackDict_Index_Key]
|
count = ItemCommon.GetPackInitCount(packType) + curPlayer.NomalDictGetProperty(keyName)
|
|
curPack.SetCount(count)
|
|
#֪ͨ¿Í»§¶Ë
|
curPack.Sync_PackCanUseCount()
|
return
|
|
def Init_HeroPack(curPlayer):
|
packType = ShareDefine.rptHero
|
#»ñÈ¡Íæ¼Ò±³°ü
|
curPack = curPlayer.GetItemManager().GetPack(packType)
|
initCount = ItemCommon.GetPackInitCount(packType)
|
if packType in ChConfig.Def_Type_CanBuyPack_PlayerDict.keys():
|
keyName = ChConfig.Def_Type_CanBuyPack_PlayerDict.get(packType)[ChConfig.Def_PlayerPackDict_Index_Key]
|
initCount += curPlayer.NomalDictGetProperty(keyName)
|
curPack.SetCount(initCount)
|
#֪ͨ¿Í»§¶Ë±³°ü¸ñ×ÓÊýÄ¿
|
# curPlayer.Sync_ItemCount(curPack.GetCount())
|
curPack.Sync_PackCanUseCount()
|
return
|
|
|
##³õʼ»¯Ñ°±¦±³°ü
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return None
|
def Init_TreasurePack(curPlayer):
|
curPack = curPlayer.GetItemManager().GetPack(ShareDefine.rptTreasure)
|
curPack.SetCount(ItemCommon.GetPackInitCount(ShareDefine.rptTreasure))
|
|
#֪ͨ¿Í»§¶Ë
|
curPack.Sync_PackCanUseCount()
|
return
|
|
##³õʼ»¯Íæ¼ÒÊÕÄɹñ
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param packType ±³°üÀàÐÍ
|
# @return ·µ»ØÖµÎÞÒâÒå
|
def Init_CabinetCountByType(curPlayer, packType):
|
keyName = ChConfig.Def_Type_CanBuyPack_PlayerDict.get(packType)[ChConfig.Def_PlayerPackDict_Index_Key]
|
if keyName == None:
|
GameWorld.ErrLog("Init_Pack Error type=%s" % packType)
|
return
|
|
#³õʼ»¯Ê±×°ÎäÆ÷±³°ü
|
curPack = curPlayer.GetItemManager().GetPack(packType)
|
#ĬÈÏ14¸ñ×Ó + ¿ªÆôµÄ
|
count = ChConfig.Def_PackCnt_WeaponCoat + curPlayer.NomalDictGetProperty(keyName)
|
curPack.SetCount(count)
|
|
#֪ͨ¿Í»§¶Ë
|
curPack.Sync_PackCanUseCount()
|
return
|
|
#---------------------------------------------------------------------
|
def IsInOperationAction(curPlayer, actName, actIDKey, crossActName="", crossActIDKey=""):
|
## Íæ¼ÒÊÇ·ñÓÐÕýÔÚ½øÐÐÖÐÔËÓª»î¶¯£¬²»º¬²ÎÓë½áÊø½×¶Î
|
|
if crossActName and crossActIDKey:
|
playerActID = curPlayer.NomalDictGetProperty(crossActIDKey)
|
actInfo = CrossRealmPlayer.GetPlayerCrossActInfo(curPlayer, crossActName)
|
actID = actInfo.get(ShareDefine.ActKey_ID, 0)
|
cfgID = actInfo.get(ShareDefine.ActKey_CfgID, 0)
|
state = actInfo.get(ShareDefine.ActKey_State, 0)
|
stateJoin = actInfo.get(ShareDefine.ActKey_StateJoin, 0)
|
if state and stateJoin != ShareDefine.ActStateJoin_End and actID == playerActID:
|
GameWorld.DebugLog("%s»î¶¯Íæ¼ÒÕýÔÚ²ÎÓëÖÐ! cfgID=%s,actID=%s,stateJoin=%s"
|
% (crossActName, cfgID, actID, stateJoin), curPlayer.GetPlayerID())
|
return True
|
|
for actInfo in PyGameData.g_operationActionDict.get(actName, {}).values():
|
actNum = actInfo.get(ShareDefine.ActKey_ActNum, 0)
|
actID = actInfo.get(ShareDefine.ActKey_ID, 0)
|
state = actInfo.get(ShareDefine.ActKey_State, 0)
|
stateJoin = actInfo.get(ShareDefine.ActKey_StateJoin, 0)
|
playerActID = curPlayer.NomalDictGetProperty(actIDKey % actNum)
|
if state and stateJoin != ShareDefine.ActStateJoin_End and actID == playerActID:
|
GameWorld.DebugLog("%sÍæ¼ÒÕýÔÚ²ÎÓëÖÐ! actNum=%s,actID=%s,stateJoin=%s"
|
% (actName, actNum, actID, stateJoin), curPlayer.GetPlayerID())
|
return True
|
|
return False
|
|
def RefreshOperationAction_ExpRate():
|
playerManager = GameWorld.GetPlayerManager()
|
for i in xrange(playerManager.GetPlayerCount()):
|
curPlayer = playerManager.GetPlayerByIndex(i)
|
if curPlayer == None or not curPlayer.GetInitOK():
|
continue
|
Sync_ExpRateChange(curPlayer)
|
return
|
|
##֪ͨÍæ¼Ò¾Ñ鱶ÂÊ
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return ·µ»ØÖµÎÞÒâÒå
|
# @remarks ֪ͨÍæ¼Ò¾Ñ鱶ÂÊ
|
def Sync_ExpRateChange(curPlayer):
|
totalExpRate = GetPlayerExpRate(curPlayer)
|
fightExpRate = curPlayer.GetFightExpRate() # ϵͳ¼°¹¦ÄÜÀÛ¼Ó
|
fightExpRate += PlayerVip.GetPrivilegeValue(curPlayer, ChConfig.VIPPrivilege_FightExpRate) # VIP¼Ó³É
|
fightExpRate += PlayerGoldInvest.GetAddFightExpRate(curPlayer)
|
|
actExpRateInfo = PyGameData.g_operationActionDict.get(ShareDefine.OperationActionName_ExpRate, {})# ¶à±¶¾Ñé»î¶¯¼Ó³É
|
if actExpRateInfo.get(ShareDefine.ActKey_State):
|
actExpIpyData = IpyGameDataPY.GetIpyGameData("ActExpRate", actExpRateInfo.get(ShareDefine.ActKey_CfgID))
|
if actExpIpyData and curPlayer.GetLV() >= actExpIpyData.GetLVLimit():
|
fightExpRate += actExpIpyData.GetAddExpRate()
|
|
if curPlayer.GetMapID() not in [ChConfig.Def_FBMapID_FamilyInvade]: #ÊØÎÀÈ˻ʲ»¼Ó×é¶Ó¼Ó³É
|
fightExpRate += curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_TeamExpRate) # ×é¶Ó
|
|
#µØͼ¶à±¶¾Ñé¼Ó³É£¬Ä¬ÈÏÊÇ1±¶²»¼Ó³É
|
mapExpAddMultiple = max(0, FBCommon.GetAreaRewardMultiple(curPlayer) - 1)
|
fightExpRate += mapExpAddMultiple * ChConfig.Def_MaxRateValue
|
|
if totalExpRate != fightExpRate:
|
curPlayer.SetDict(ChConfig.Def_PlayerKey_TotalExpRate, fightExpRate)
|
curPlayer.Sync_CurExpRate(fightExpRate)
|
return
|
|
##»ñÈ¡Íæ¼ÒµÄ¾Ñ鱶ÂÊ
|
def GetPlayerExpRate(curPlayer): return curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_TotalExpRate)
|
def GetLimitExpRate(curPlayer, limitType=None):
|
''' »ñÈ¡ÊÜÏÞ¹¦ÄÜ×ܾÑ鱶ÂÊ
|
@param limitType: ÊÜÏ޵ŦÄÜÀàÐÍ
|
'''
|
totalExpRate = GetPlayerExpRate(curPlayer)
|
if limitType == None:
|
return totalExpRate
|
|
# ¿Û³ýÔöÖµbuffÖжÔÓ¦ÏÞÖƵļӳÉ
|
buffState = curPlayer.GetIncBuff()
|
for i in xrange(buffState.GetBuffCount()):
|
curBuff = buffState.GetBuff(i)
|
buffSkill = curBuff.GetSkill()
|
for j in range(buffSkill.GetEffectCount()):
|
curEffect = buffSkill.GetEffect(j)
|
effectID = curEffect.GetEffectID()
|
if effectID == 0:
|
break
|
|
if effectID != ChConfig.TYPE_Calc_AttrFightExpRate:
|
continue
|
|
effExpRate = curEffect.GetEffectValue(0)
|
calcType = curEffect.GetEffectValue(1)
|
limitTypeValue = curEffect.GetEffectValue(2) # °´Î»¼ÆËã
|
|
if calcType != ChConfig.EffCalcType_LinePlus or not limitTypeValue:
|
continue
|
|
if limitTypeValue & pow(2, limitType):
|
totalExpRate -= effExpRate
|
|
return totalExpRate
|
|
#===============================================================================
|
#---Íæ¼ÒÀ©Õ¹×Ö¶Î---
|
|
#---À©Õ¹×Ö¶Î2,3,5,9,12,13,14---
|
#---À©Õ¹×Ö¶Î1-Ö°Òµ½×¼¶£»4-µ±Ç°·À»¤Öµ£»6-ÍÇ®µã£»7-SPÕæÆøÖµ£»8-SPÕæÆøÖµÀ©Õ¹µã£»10-¿ç·þÔ¤ÈüÅÅλ£»11-¹Ù¾ôÐǼ¶£»---
|
# SetExAttr1 ~ SetExAttr14(DWORD uiExAttr10, bool bNotifyAll = false, bool bNotifyGameServer = false)
|
# @param bNotifyAll: ÊÇ·ñ¹ã²¥ËùÖÜΧÍæ¼Ò£¬Ä¬ÈÏfalse£¬Ö»»á·¢¸ø×Ô¼º
|
# @param bNotifyGameServer: ÊÇ·ñͬ²½GameServer£¬Ä¬ÈÏfalse
|
# SetExAttr15 ~ SetExAttr20(DWORD uiExAttr15)
|
# 15~20À©Õ¹ÊôÐÔͬ²½·â°ü£º0309 Ñ¡½ÇµÇ¼¼ò¶ÌÐÅÏ¢¡¢0434 ÖÜΧÍæ¼Ò³öÏÖ¡¢0102 µÇ¼µØͼÍæ¼ÒÐÅÏ¢£»
|
# ͬ²½Ç°¶Ë¼°GameServerÐèÒª×Ô¼ºÐ´Í¨Öª£¬ÉèÖú¯Êý×ÔÉí²»´ø֪ͨ²ÎÊý
|
#
|
# ·¢ËÍ0418°ü
|
# SendPropertyRefresh(int inputType, int inputValue, int inputValueEx, bool boardCast, bool includeSelf = true)
|
# @param : boardCast-ÊÇ·ñ¹ã²¥ÖÜΧÍæ¼Ò£»includeSelf-ÊÇ·ñ°üº¬×Ô¼º
|
#
|
# ֪ͨGsmeServer;
|
# SendGameServerRefreshState(int inputType, int inputValue, int inputValueEx)
|
|
def SendPropertyRefresh(curPlayer, inputType, value, boardCast=False):
|
''' ·¢ËÍ0418°ü
|
@param boardCast: ÊÇ·ñ¹ã²¥ÖÜΧÍæ¼Ò£¬Ò»¶¨»á·¢¸ø×Ô¼º
|
'''
|
curPlayer.SendPropertyRefresh(inputType, value % ShareDefine.Def_PerPointValue, value / ShareDefine.Def_PerPointValue, boardCast)
|
return
|
|
def SendGameServerRefreshState(curPlayer, inputType, value):
|
## ͬ²½ÊôÐÔµ½GameServer IPY_GRefreshPlayerProperty
|
curPlayer.SendGameServerRefreshState(inputType, value % ShareDefine.Def_PerPointValue, value / ShareDefine.Def_PerPointValue)
|
return
|
|
# ½ûÑÔ Í¨ÖªgameServer
|
def SetGMForbidenTalk(curPlayer, value):
|
''' ÉèÖÃÊÇ·ñ½ûÑÔ
|
@param value: 0-½â½û£»1-½ûÑÔ£»2-½ûÉ豸£»3-½âÉ豸
|
|
½ûÉ豸Á÷³Ì
|
1.ÏÈÉèÖÃ2֪ͨǰ¶ËдÈë½ûÉ豸¼Ç¼£¨Ç°¶Ë´¦Àíµ±Îª2ʱ±¾µØÉ豸±ê¼ÇΪ½ûÉ豸£©
|
2.ÔÙÉèÖÃ1£¬´Ëʱǰºó¶Ë״̬¾ùΪ1£¬¼´½ÇÉ«½ûÑÔ
|
|
½â½ûÉ豸Á÷³Ì
|
1.ÏÈÉèÖÃ3֪ͨǰ¶Ëɾ³ý½ûÉ豸¼Ç¼
|
2.ÔÙÉèÖÃ0£¬´Ëʱǰºó¶Ë״̬¾ùΪ1£¬¼´½ÇÉ«½â½û
|
'''
|
__SetGMForbidenTalkValue(curPlayer, value)
|
|
#ͬ²½ÉèÖÃÀëÏßDBÍæ¼ÒÕ˺Å״ֵ̬
|
accState = curPlayer.GetAccState()
|
if value == 2:
|
accState = accState | pow(2, ChConfig.Def_PysForbidTalkDevice)
|
accState = accState | pow(2, ChConfig.Def_PysForbidTalk)
|
elif value == 1:
|
accState = accState | pow(2, ChConfig.Def_PysForbidTalk)
|
elif value == 3:
|
if (accState & pow(2, ChConfig.Def_PysForbidTalkDevice)):
|
accState = accState ^ pow(2, ChConfig.Def_PysForbidTalkDevice)
|
if (accState & pow(2, ChConfig.Def_PysForbidTalk)):
|
accState = accState ^ pow(2, ChConfig.Def_PysForbidTalk)
|
elif (accState & pow(2, ChConfig.Def_PysForbidTalk)) > 0:
|
accState = accState ^ pow(2, ChConfig.Def_PysForbidTalk)
|
SetPlayerAccState(curPlayer, accState)
|
return
|
|
def __SetGMForbidenTalkValue(curPlayer, value):
|
curPlayer.SetGMForbidenTalk(value)
|
SendGameServerRefreshState(curPlayer, ShareDefine.CDBPlayerRefresh_ForbidenTalk, value)
|
SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_ForbidenTalk, value)
|
GameWorld.DebugLog("__SetGMForbidenTalkValue %s" % value, curPlayer.GetPlayerID())
|
return
|
|
def SetPlayerAccState(curPlayer, accState):
|
curPlayer.SetAccState(accState)
|
curPlayer.SetExAttr17(accState) # ͬ²½ÉèÖøÃÖµ 0309 ·â°üµÇ¼ʱÐèÒªÓõ½
|
SendGameServerRefreshState(curPlayer, ShareDefine.CDBPlayerRefresh_ExAttr17, accState)
|
SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_ExAttr17, accState)
|
GameWorld.DebugLog("SetPlayerAccState %s" % (accState), curPlayer.GetPlayerID())
|
return
|
|
def DoGMForbidenTalkOnLogin(curPlayer):
|
## ÀëÏßʱ±»½ûÑÔ£¬´ËʱDBµÄÕ˺Å״ֵ̬Ϊ½ûÑÔ״̬£¬µ«ÊÇGMOperÔÝʱûÓнûÑÔ²Ù×÷ÃüÁ¹ÊÉÏÏßʱ¼ì²éÉèÖÃÏÂÀëÏß½ûÑÔ״̬
|
## Ä¿Ç°ÀëÏßʱ±»½ûÑԵģ¬ÔÝʱֻ´¦ÀíAccState ExAttr17, GMOperÃüÁîÔݲ»´¦Àí£¬ËùÒÔΪÓÀ¾Ã½ûÑÔ
|
|
if curPlayer.GetAccState() & pow(2, ChConfig.Def_PysForbidTalkDevice):
|
GameWorld.Log("ÉÏÏßʱ½ÇɫΪ±»É豸½ûÑÔ״̬!", curPlayer.GetPlayerID())
|
__SetGMForbidenTalkValue(curPlayer, 2)
|
__SetGMForbidenTalkValue(curPlayer, 1)
|
elif curPlayer.GetAccState() & pow(2, ChConfig.Def_PysForbidTalk):
|
GameWorld.Log("ÉÏÏßʱ½ÇɫΪ±»½ûÑÔ״̬!", curPlayer.GetPlayerID())
|
__SetGMForbidenTalkValue(curPlayer, 1)
|
else:
|
SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_ForbidenTalk, 0)
|
return
|
|
def IsMainLevelPass(curPlayer, lvID):
|
## ÅжÏÍæ¼ÒÊÇ·ñ¹ý¹Øij¸öÖ÷Ï߹ؿ¨ID
|
# @param lvID: ¹Ø¿¨Î¨Ò»ID£¬Óë²ß»®Ô¼¶¨ºÃ = Õ½Ú*100+¹Ø¿¨±àºÅ
|
passChapterID, passLevelNum, _ = GetMainLevelPassInfo(curPlayer)
|
passValue = passChapterID * 100 + passLevelNum # ÒòΪpassµÄ¼Ç¼ÊÇ´ø²¨ÊýµÄ£¬¼´µ±Ç°¹Ø¿¨boss»¹Ã»¹ý¹Ø£¬ËùÒÔÖ»ÓдóÓڸüǼֵµÄ²ÅËã¹ý¹Ø
|
return passValue > lvID
|
|
## Ö÷Ï߹ؿ¨¹ý¹Ø½ø¶ÈÖµ = Õ½Ú*10000+¹Ø¿¨±àºÅ*100+µÚx²¨
|
def GetMainLevelPassValue(curPlayer): return curPlayer.GetExAttr1()
|
def SetMainLevelPassValue(curPlayer, value): curPlayer.SetExAttr1(value, False, False) # ²»Í¨ÖªGameServer
|
def SetMainLevelPassInfo(curPlayer, chapterID, levelNum, wave=0):
|
## ÉèÖÃÖ÷Ï߹ؿ¨¹ý¹Ø½ø¶È
|
# @param chapterID: Õ½ÚID
|
# @param levelNum: ¹Ø¿¨±àºÅ
|
# @param wave: µÚx²¨
|
value = ComMainLevelValue(chapterID, levelNum, wave)
|
SetMainLevelPassValue(curPlayer, value)
|
return value
|
def GetMainLevelPassInfo(curPlayer):
|
## »ñÈ¡Ö÷Ï߹ؿ¨¹ý¹Ø½ø¶ÈÐÅÏ¢
|
# @return: chapterID, levelNum, wave
|
return GetMainLevelValue(GetMainLevelPassValue(curPlayer))
|
|
## Ö÷Ï߹ؿ¨µ±Ç°½ø¶ÈÖµ = Õ½Ú*10000+¹Ø¿¨±àºÅ*100+µÚx²¨
|
def GetMainLevelNowValue(curPlayer): return curPlayer.GetExAttr2()
|
def SetMainLevelNowValue(curPlayer, value): curPlayer.SetExAttr2(value, False, False) # ²»Í¨ÖªGameServer
|
def SetMainLevelNowInfo(curPlayer, chapterID=1, levelNum=1, wave=1):
|
## ÉèÖÃÖ÷Ï߹ؿ¨µ±Ç°½ø¶È
|
# @param chapterID: Õ½ÚID
|
# @param levelNum: ¹Ø¿¨±àºÅ
|
# @param wave: µÚx²¨
|
value = ComMainLevelValue(chapterID, levelNum, wave)
|
SetMainLevelNowValue(curPlayer, value)
|
return value
|
def GetMainLevelNowInfo(curPlayer):
|
## »ñÈ¡Ö÷Ï߹ؿ¨µ±Ç°½ø¶ÈÐÅÏ¢
|
# @return: chapterID, levelNum, wave
|
return GetMainLevelValue(GetMainLevelNowValue(curPlayer))
|
|
def ComMainLevelValue(chapterID, levelNum, wave=0): return chapterID * 10000 + levelNum * 100 + wave
|
def GetMainLevelValue(value):
|
chapterID = value / 10000
|
levelNum = value % 10000 / 100
|
wave = value % 100
|
return chapterID, levelNum, wave
|
|
## ÐÖúÄ¿±êÍæ¼ÒID
|
def GetAssistTagPlayerID(curPlayer): return 0
|
|
## ¶ÓÎéÏà¹ØÉóºË¿ª¹Ø״̬, joinReqCheck-Èë¶ÓÉêÇëÊÇ·ñÐèÒªÉóºË; inviteCheck-×é¶ÓÑûÇëÊÇ·ñÐèÒªÉóºË;
|
def SetTeamCheckStateEx(curPlayer, joinReqCheck, inviteCheck): return SetTeamCheckState(curPlayer, joinReqCheck * 10 + inviteCheck)
|
def SetTeamCheckState(curPlayer, checkState): return
|
## ¸±±¾¹¦ÄÜÏß·ID, ÕâÀï×ödb´æ´¢£¬·ÀÖ¹Ôںϲ¢µØͼ¸±±¾ÖеôÏßÖØÉÏʱǰ¶ËÎÞ·¨¼ÓÔØÕýÈ·µÄ³¡¾°×ÊÔ´£¬µÇ¼¼ÓÔس¡¾°Ê±»úΪ0102°ü
|
def SetFBFuncLineID(curPlayer, mapID, funcLineID):
|
value = mapID * 1000 + funcLineID
|
if value != curPlayer.GetExAttr3():
|
curPlayer.SetExAttr3(value, False, True)
|
return
|
def GetFBFuncMapID(curPlayer): return curPlayer.GetExAttr3() / 1000
|
def GetFBFuncLineID(curPlayer): return curPlayer.GetExAttr3() % 1000
|
|
## ¿ç·þ״̬ËùÔÚµØͼID: 0-·Ç¿ç·þ״̬£¬·Ç0-¿ç·þ״̬¶ÔÓ¦µÄµØͼID
|
def GetCrossMapID(curPlayer): return curPlayer.GetExAttr5()
|
def SetCrossMapID(curPlayer, value):
|
curPlayer.SetExAttr5(value, False, True)
|
if not value:
|
CrossPlayerData.ClearCrossSyncDataCache(curPlayer)
|
return
|
|
## Ç°¶Ë×Ô¶¨Ò峡¾°
|
def GetCustomMapID(curPlayer): return curPlayer.GetExAttr14() / 1000
|
def GetCustomLineID(curPlayer): return curPlayer.GetExAttr14() % 1000
|
## ×Ô¶¨Ò峡¾°ºó¶ËÅжÏÒѽáËãºóÐèÖ±½ÓÖØÖÃΪ0£¬·Àֹǰ¶ËûÓÐÍ˳ö³¡¾°Ö±½ÓÏÂÏßµ¼ÖÂÊý¾ÝûÓÐÖØÖ㬿ÉÄÜÒý·¢¿ÉÒÔÖظ´½ø
|
def SetCustomMap(curPlayer, mapID, lineID):
|
value = mapID * 1000 + lineID
|
if value != curPlayer.GetExAttr14():
|
curPlayer.SetExAttr14(value, False, True)
|
return
|
|
## ÍÇ®µã, Ö§³ÖÍÇ®³¬20ÒÚ
|
def GetSilver(curPlayer): return curPlayer.GetExAttr6() * ChConfig.Def_PerPointValue + curPlayer.GetSilver()
|
def SetSilver(curPlayer, totalSilver):
|
silver = totalSilver % ChConfig.Def_PerPointValue
|
silverPoint = min(totalSilver / ChConfig.Def_PerPointValue, ChConfig.Def_UpperLimit_DWord)
|
if silver != curPlayer.GetSilver():
|
curPlayer.SetSilver(silver)
|
if silverPoint != curPlayer.GetExAttr6():
|
curPlayer.SetExAttr6(silverPoint)
|
return
|
|
##VIPµ½ÆÚʱ¼ä, ÐèҪͬ²½GameServer
|
def GetVIPExpireTime(curPlayer): return 0
|
def SetVIPExpireTime(curPlayer, expireTime): return
|
|
##×î½üÒ»´ÎÌáÉýVIPµÈ¼¶Ê±¼ä
|
def GetVIPLVUpTime(curPlayer): return 0
|
def SetVIPLVUpTime(curPlayer, lvUpTime): return
|
|
##ÁÄÌìÆøÅÝ¿ò
|
def GetChatBubbleBox(curPlayer): return curPlayer.GetExAttr10()
|
def SetChatBubbleBox(curPlayer, value): return curPlayer.SetExAttr10(value, False, True)
|
|
##ÓÎÏ·³äÖµÖ§¸¶´ú±Ò
|
def GetPayCoinTotal(curPlayer): return GetPayCoin(curPlayer) + GetPlayerCurrency(curPlayer, ShareDefine.TYPE_Price_PayCoinDay)
|
def GetPayCoin(curPlayer): return curPlayer.GetExAttr11()
|
def SetPayCoin(curPlayer, value): return curPlayer.SetExAttr11(min(value, ChConfig.Def_UpperLimit_DWord), False, False)
|
def PayCoinOnDay(curPlayer):
|
# ÿÈÕ¹ýÌìÇå³ýʱЧ´ú±Ò
|
payCoinDay = GetPlayerCurrency(curPlayer, ShareDefine.TYPE_Price_PayCoinDay)
|
if payCoinDay > 0:
|
PayMoney(curPlayer, ShareDefine.TYPE_Price_PayCoin, payCoinDay, "PayCoinOnDay")
|
return
|
|
## »ñÈ¡Åå´÷µÄ³ÆºÅID
|
def GetTitleID(curPlayer):
|
curDienstgradMgr = curPlayer.GetDienstgradManager()
|
return curDienstgradMgr.GetCurGradID()
|
|
##°éÂÂ
|
def GetCoupleID(curPlayer):
|
coupleInfo = GetCoupleInfo(curPlayer.GetPlayerID())
|
return coupleInfo[0] if coupleInfo else 0
|
def GetCoupleName(curPlayer):
|
coupleInfo = GetCoupleInfo(curPlayer.GetPlayerID())
|
return coupleInfo[1] if coupleInfo else ""
|
def GetCoupleJob(curPlayer):
|
coupleInfo = GetCoupleInfo(curPlayer.GetPlayerID())
|
return coupleInfo[2] if coupleInfo else 1
|
def GetBridePriceMaxID(curPlayer):
|
coupleInfo = GetCoupleInfo(curPlayer.GetPlayerID())
|
return coupleInfo[3] if coupleInfo else 0
|
def GetCoupleInfo(playerID):
|
if playerID not in PyGameData.g_coupleInfo:
|
return
|
return PyGameData.g_coupleInfo[playerID]
|
def SetCoupleInfo(playerID, coupleInfo):
|
if not coupleInfo:
|
PyGameData.g_coupleInfo.pop(playerID, None)
|
else:
|
PyGameData.g_coupleInfo[playerID] = coupleInfo
|
return
|
|
## Íæ¼ÒËùÊô·þÎñÆ÷×éID
|
def GetPlayerServerGroupID(curPlayer): return curPlayer.GetExAttr13()
|
def UpdPlayerServerGroupID(curPlayer):
|
# ¸üÐÂ×Ô¼ºµÄ·þÎñÆ÷×éID, ¿ç·þ·þÎñÆ÷²»´¦Àí
|
if GameWorld.IsCrossServer():
|
return
|
serverGroupID = GameWorld.GetServerGroupID()
|
if not serverGroupID:
|
return
|
playerServerGroupID = curPlayer.GetExAttr13()
|
if playerServerGroupID != serverGroupID:
|
curPlayer.SetExAttr13(serverGroupID, False, True)
|
GameWorld.DebugLog("¸üÐÂÍæ¼ÒËùÊô·þÎñÆ÷×éID: serverGroupID=%s" % serverGroupID)
|
return
|
|
# ¾³½çÄѶȵȼ¶
|
def GetRealmDifficulty(curPlayer): return 0
|
def SetRealmDifficulty(curPlayer, realmDifficulty):
|
''' ÉèÖþ³½çÄѶȵȼ¶£¬ÈκεØͼ¾ù¿ÉÑ¡Ôñ
|
'''
|
return
|
def GetDifficultyRealmLV(realmDifficulty): return 0
|
def GetMapRealmDifficulty(curPlayer):
|
## »ñÈ¡Íæ¼ÒÔÚ±¾µØͼÖеľ³½çÄѶȲ㼶£¬±ØÐëÔÚ¾³½çµØͼÇÒÓÐÑ¡Ôñ¾³½çÄѶȲÅË㣬·ñÔòΪĬÈÏ0£»¸ÃÄѶÈֵͬʱҲÊÇÊÓÒ°²ã¼¶
|
return 0
|
|
##Íæ¼ÒÀ뿪ÏÉÃËʱ¼ä£¨Ö÷¶¯»ò±»Ì߶¼Ë㣩
|
def GetLeaveFamilyTimeEx(curPlayer):return curPlayer.GetExAttr19()
|
def SetLeaveFamilyTimeEx(curPlayer, value):
|
curPlayer.SetExAttr19(value)
|
#curPlayer.SendGameServerRefreshState(ShareDefine.CDBPlayerRefresh_ExAttr19, value, 0)
|
curPlayer.SendPropertyRefresh(ShareDefine.CDBPlayerRefresh_ExAttr19, value, 0, False)
|
return
|
|
##×ÜÕ½¶·Á¦£¬Ö§³Ö³¬¹ý20E = ¸÷Ä£¿éÕ½Á¦×ܺÍ
|
def GetFightPower(curPlayer): return curPlayer.GetFightPowerEx() * ChConfig.Def_PerPointValue + curPlayer.GetFightPower()
|
def SetFightPower(curPlayer, value):
|
beforeFightPower = GetFightPower(curPlayer)
|
curPlayer.SetFightPower(value % ChConfig.Def_PerPointValue, value / ChConfig.Def_PerPointValue, False) # ²»Í¨ÖªGameServer bNotifyGameServer False
|
if value < beforeFightPower:
|
DataRecordPack.DR_FightPowerChangeInfo(curPlayer, beforeFightPower)
|
highestFightPower = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_FightPower_Highest)
|
highestFightPower += curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_FightPower_HighestEx) * ChConfig.Def_PerPointValue
|
if value > highestFightPower:
|
highestFightPower = value
|
NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_FightPower_Highest, highestFightPower % ChConfig.Def_PerPointValue)
|
NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_FightPower_HighestEx, highestFightPower / ChConfig.Def_PerPointValue)
|
|
GameWorld.DebugLog("×ÜÕ½Á¦: %s, ÀúÊ·×î¸ßÕ½Á¦: %s, beforeFightPower=%s" % (value, highestFightPower, beforeFightPower), curPlayer.GetPlayerID())
|
PlayerBillboard.UpdatePlayerFPTotalBillboard(curPlayer)
|
# ¼Ç¼¿ª·þ»î¶¯Êý¾Ý
|
#OpenServerCampaign.UpdOpenServerCampaignRecordData(curPlayer, ShareDefine.Def_Campaign_Type_FightPower, totalFightPower)
|
#if beforeFightPower != totalFightPower:
|
# CrossPlayerData.OnPlayerFightPowerChange(curPlayer)
|
return
|
|
## ÉèÖÃÄ£¿éÕ½¶·Á¦£¬Ö§³Ö³¬¹ý20E = Ä£¿é¹«Ê½Õ½Á¦ + ¼¼Äܸ½¼ÓÕ½Á¦ + ÆäËû¸½¼ÓÕ½Á¦
|
def SetMFPFightPower(curPlayer, mfpType, fightPower): return
|
## »ñÈ¡Ä£¿éÕ½¶·Á¦
|
def GetMFPFightPower(curPlayer, mfpType): return 0
|
|
## ÉèÖÃÄ£¿é¸½¼ÓÕ½¶·Á¦£¬Ö§³Ö³¬¹ý20E
|
def SetMFPExFightPower(curPlayer, mfpType, fightPower): return
|
## »ñÈ¡Ä£¿é¸½¼ÓÕ½¶·Á¦
|
def GetMFPExFightPower(curPlayer, mfpType): return 0
|
|
## ÉèÖÃÄ£¿é¼¼Äܸ½¼ÓÕ½¶·Á¦£¬Ö§³Ö³¬¹ý20E
|
def SetMFPSkillFightPower(curPlayer, mfpType, fightPower): return
|
## »ñÈ¡Ä£¿é¼¼Äܸ½¼ÓÕ½¶·Á¦
|
def GetMFPSkillFightPower(curPlayer, mfpType): return 0
|
|
#===============================================================================
|
##»ñÈ¡Íæ¼Ò·ÖÏßÐÅÏ¢
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return Íæ¼Òµ±Ç°·ÖÏßID
|
# @remarks
|
def GetPlayerLineID(curPlayer):
|
return curPlayer.GetLineID() + 1
|
|
|
##ÊÓÒ°ÑéÖ¤, Íâ¹ÒÊÓÒ°±äС²»»Ö¸´
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @param sight ÊÓÒ°·¶Î§
|
# @return ÎÞÒâÒå
|
def SetSight(curPlayer, sight):
|
#Íâ¹ÒºÅ ÊÓÒ°ÑéÖ¤
|
if curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_AutoCheckHack_State) \
|
== ChConfig.Def_AutoCheck_State_Danger:
|
|
if curPlayer.GetSight() > sight:
|
curPlayer.SetSight(sight)
|
|
return
|
|
curPlayer.SetSight(sight)
|
|
##»ñÈ¡¹¥»÷¼ä¸ô
|
# @param curPlayer Íæ¼ÒʵÀý
|
# @return ¹¥»÷¼ä¸ô
|
def GetAtkInterval(curPlayer):
|
atkInterval = curPlayer.GetAtkInterval()
|
|
#Íâ¹ÒºÅ ¹¥»÷¼ä¸ôÑéÖ¤
|
if curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_AutoCheckHack_State) \
|
== ChConfig.Def_AutoCheck_State_Danger:
|
atkInterval *= 100
|
|
return atkInterval
|
|
##Íæ¼ÒÔö¼ÓÕæÆø
|
# @param curPlayer Íæ¼Ò
|
# @param value Ôö¼ÓÊýÖµ
|
# @param canOverbrim ¿É·ñÒç³ö(ĬÈϲ»ÐÐ)
|
# @param isSysMsg ÊÇ·ñϵͳÌáʾ(ĬÈÏÐèÒª)
|
# @return None
|
def PlayerAddZhenQi(curPlayer, addValue, canOverbrim=False, isSysMsg=True, eventName="unknown", eventData=""):
|
if addValue <= 0:
|
return True
|
|
curZhenQi = GetZhenQi(curPlayer) # µ±Ç°ÕæÆø
|
|
value = curZhenQi + addValue
|
|
if value == curZhenQi:
|
#ÕæÆøֵûÓиıä
|
return False
|
|
#===============================================================================================
|
# if isSysMsg:
|
# #GeRen_chenxin_254483:»ñµÃÕæÆøÖµXXµã
|
# NotifyCode(curPlayer, "GeRen_chenxin_254483", [addValue])
|
#===============================================================================================
|
|
SetZhenQi(curPlayer, value)
|
#EventReport.WriteEvent_add_zhenqi(curPlayer, eventName, eventData, addValue, value)
|
return True
|
|
|
##Íæ¼Ò¼õÉÙÕæÆø
|
# @param curPlayer Íæ¼Ò
|
# @param lostValue ¼õÉÙÊýÖµ
|
# @return None
|
def PlayerLostZhenQi(curPlayer, lostValue, eventName="unknown", eventData=""):
|
if lostValue <= 0:
|
return True
|
|
curZhenQi = GetZhenQi(curPlayer) # µ±Ç°ÕæÆø
|
|
value = max(0, curZhenQi - lostValue)
|
if value < 0:
|
GameWorld.ErrLog("curZhenQi = %s, lostValue = %s" % (curZhenQi, lostValue))
|
return False
|
|
#GeRen_chenxin_365899:ÏûºÄÕæÆøÖµXXµã.
|
#NotifyCode(curPlayer, "GeRen_chenxin_365899", [lostValue])
|
|
SetZhenQi(curPlayer, value)
|
|
#EventReport.WriteEvent_lost_zhenqi(curPlayer, eventName, eventData, lostValue, value)
|
return True
|
|
## SPÕæÆøÖµ - ÔÝ·ÏÆú ExAttr7¡¢ExAttr8 ¸ÄΪר¾«Ñ¡Ôñ֪ͨ£¬ÓÃÓÚÇ°¶Ë±íÏÖÆäËûÍæ¼ÒµÄ²»Í¬×¨¾«ÌØЧ
|
def GetZhenQi(curPlayer): return 0
|
def SetZhenQi(curPlayer, totalZhenQi): return
|
|
#===============================================================================
|
# #@warning: ExAttr6~ExAttr10, ÐÂÔö2¸ö²¼¶ûĬÈϲÎÊý, ÊÇ·ñ֪ͨ¿Í»§¶Ë, ÊÇ·ñ֪ͨGameServer, ĬÈÏֵΪFalse
|
#===============================================================================
|
#---------------------------------------------------------------------------
|
|
##»ñÈ¡¿ÉÃâ·Ñ¿ªÆôµÄ¸ñ×ÓÊý
|
# @param curPlayer Íæ¼Ò¶ÔÏó
|
# @param packType ±³°üÀàÐÍ
|
# @param openCnt ʵ¼ÊÒª¿ªÆôµÄ¸ñ×ÓÊý
|
# @return »ñÈ¡¿ÉÃâ·Ñ¿ªÆôµÄ¸ñ×ÓÊý
|
def GetCanAutoOpenPackCount(curPlayer, packType, openCnt, tick):
|
if packType not in [IPY_GameWorld.rptItem, IPY_GameWorld.rptWarehouse]:
|
return 0
|
cfgObj = PlayerExpandPackCfgMgr.GetExpandPackCfg(curPlayer, packType)
|
#ÕÒ²»µ½ÕâÖÖ±³°üµÄÅäÖÃÐÅÏ¢¶ÔÏó
|
if not cfgObj:
|
return 0
|
#ÒѹºÂò»ò×Ô¶¯¿ªÆôµÄ¸ñ×ÓÊý
|
keyName = ChConfig.Def_Type_CanBuyPack_PlayerDict[packType][ChConfig.Def_PlayerPackDict_Index_Key]
|
curCount = curPlayer.NomalDictGetProperty(keyName)
|
|
# nextCountIndex = curCount + 1
|
# infoObj = cfgObj.GetAttrInfoByInex(nextCountIndex)
|
# if None == infoObj:
|
# return 0
|
# #¸üÐÂÏÂÍæ¼ÒµÄÔÚÏßʱ¼ä
|
# UpdateOnLineTime(curPlayer, tick)
|
# onlineTime = curPlayer.GetOnlineTime()
|
# #ÐèÒªµÄʱ¼ä
|
# needOnlineTime = infoObj["OnlineTime"]
|
# #×îºóÒ»´Î×Ô¶¯¿ªÆô±³°üµÄÔÚÏßʱ¼ätick
|
# lastAutoOpenPackTick = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_LastAutoOpenPackTick)
|
# if onlineTime - lastAutoOpenPackTick > needOnlineTime:
|
# return 1
|
# return 0
|
|
#×î´ó¿ÉÔö¼ÓµÄ±³°üÊý
|
maxCanAddCount = cfgObj.GetCanAddCount()
|
forCount = min(openCnt, maxCanAddCount - curCount)
|
|
#¿ÉÒÔÔÙÔö¼ÓµÄ¸ñ×ÓÊý
|
count = 0
|
#±éÀú¿ÉÔö¼ÓµÄ±³°ü¸ñ×ÓÊý
|
UpdateOnLineTime(curPlayer, tick)
|
onlineTime = curPlayer.GetOnlineTime()
|
lastAutoOpenPackTick = curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_LastAutoOpenPackTick % packType)
|
lastInfoObj = cfgObj.GetTotalAddAttrInfoByCount(curCount)
|
notOnlineTime = 0
|
if lastInfoObj:
|
notOnlineTime = lastInfoObj["OnlineTime"]
|
# GameWorld.Log("get online time = %s"%onlineTime)
|
for i in range(forCount):
|
nextCount = curCount + i + 1
|
infoObj = cfgObj.GetTotalAddAttrInfoByCount(nextCount)
|
if None == infoObj:
|
break
|
# (СÓÚ0µÄ²»¾ßÓÐÃâ·Ñ¿ªÆô¹¦ÄÜ)
|
if infoObj["OnlineTime"] < 0:
|
continue
|
needOnlineTime = infoObj["OnlineTime"] - notOnlineTime
|
# GameWorld.Log("get need online time = %s"%needOnlineTime)
|
#ÒªÇóµÄÔÚÏßʱ¼ä,´óÓÚµ±Ç°µÄÔÚÏßʱ¼ä,û°ì·¨¼Ó±³°ü¸ñ×Ó
|
if needOnlineTime > onlineTime - lastAutoOpenPackTick:
|
break
|
count += 1
|
return count
|
|
## »ñÈ¡Íæ¼Òµ±Ç°µÈ¼¶Éý¼¶ËùÐè×ܾÑé
|
# @param playerLv Íæ¼ÒµÈ¼¶
|
# @return ·µ»ØÖµ, Éý¼¶ÐèÒªµÄ×ܾÑé
|
def GetLVUPTotalNeedExp(curPlayer):
|
curLV = curPlayer.GetLV()
|
return GetTotalExpByPlayerLv(curLV)
|
|
## ¸ù¾ÝµÈ¼¶»ñµÃÉý¼¶ÐèÒªµÄ×ܾÑé
|
# @param playerLv Íæ¼ÒµÈ¼¶
|
# @return ·µ»ØÖµ, Éý¼¶ÐèÒªµÄ×ܾÑé
|
def GetTotalExpByPlayerLv(playerLV):
|
lvIpyData = GetPlayerLVIpyData(playerLV)
|
if not lvIpyData:
|
return 0
|
return GetLVUPTotalExpNeed(lvIpyData)
|
|
def GetPlayerLVIpyData(playerLV):
|
lvIpyData = IpyGameDataPY.GetIpyGameData("PlayerLV", playerLV)
|
if not lvIpyData:
|
GameWorld.ErrLog("¾Ñé±íÒì³£ lv= %s" % playerLV)
|
return
|
return lvIpyData
|
|
def GetLVUPTotalExpNeed(lvIpyData):
|
if not lvIpyData:
|
return 0
|
return lvIpyData.GetExp()
|
|
def GetPlayerMaxLV(curPlayer):
|
## »ñÈ¡Íæ¼Òʵ¼Ê¿ÉÉýµÄ×î´óµÈ¼¶
|
maxLV = IpyGameDataPY.GetFuncCfg("PlayerMaxLV", 1)
|
curRealmLV = curPlayer.GetOfficialRank()
|
realmIpyData = PlayerPrestigeSys.GetRealmIpyData(curRealmLV)
|
if not realmIpyData:
|
return 0
|
playerMaxLV = min(maxLV, realmIpyData.GetLVMax())
|
return playerMaxLV
|
|
## »ñµÃÍæ¼Òʵ¼ÊµÈ¼¶
|
# @param curPlayer Íæ¼Ò
|
# @return Íæ¼Òʵ¼ÊµÈ¼¶
|
def GetRealPlayerLv(curPlayer):
|
#µ±Ç°µÈ¼¶
|
realPlayerLv = curPlayer.GetLV()
|
#µ±Ç°Íæ¼Ò×ܾÑé
|
curTotalExp = GetPlayerTotalExp(curPlayer)
|
return GetRealPlayerLvEx(realPlayerLv, curTotalExp)
|
|
## »ñµÃÍæ¼Òʵ¼ÊµÈ¼¶
|
# @param realPlayerLv µ±Ç°µÈ¼¶
|
# @param curTotalExp ×ܾÑé
|
# @return Íæ¼Òʵ¼ÊµÈ¼¶
|
def GetRealPlayerLvEx(realPlayerLv, curTotalExp):
|
#Éý¼¶ËùÐè×ܾÑé
|
needTotalExp = GetTotalExpByPlayerLv(realPlayerLv)
|
if not needTotalExp:
|
return realPlayerLv
|
|
#Ä£ÄâÉý¼¶,»ñµÃʵ¼ÊµÈ¼¶
|
while curTotalExp >= needTotalExp:
|
realPlayerLv += 1
|
curTotalExp -= needTotalExp
|
needTotalExp = GetTotalExpByPlayerLv(realPlayerLv)
|
if not needTotalExp:
|
break
|
return realPlayerLv
|
|
## »ñÈ¡Íæ¼Òµ±Ç°×ܾÑé
|
def GetPlayerTotalExp(curPlayer):
|
totalExp = curPlayer.GetTotalExp() # δÂúÒ»¸ö¾ÑéµãµÄ¾Ñ飬·ÇÍæ¼Òʵ¼Ê×ܾÑé
|
expPoint = curPlayer.GetExpPoint()
|
totalMasterExp = expPoint * ChConfig.Def_PerPointValue + totalExp
|
return totalMasterExp
|
|
## ÉèÖÃÍæ¼Òµ±Ç°×ܾÑé, ת»¯Îª¾Ñéµã¼°¾Ñé
|
def SetPlayerTotalExp(curPlayer, totalExp):
|
curExp = totalExp % ChConfig.Def_PerPointValue
|
expPoint = totalExp / ChConfig.Def_PerPointValue
|
|
if curPlayer.GetExpPoint() != expPoint:
|
curPlayer.SetExpPoint(expPoint)
|
if curPlayer.GetTotalExp() != curExp:
|
curPlayer.SetTotalExp(curExp)
|
#GameWorld.DebugLog("SetPlayerTotalExp totalExp=%s,expPoint=%s,curExp=%s"
|
# % (totalExp, expPoint, curExp), curPlayer.GetPlayerID())
|
|
return
|
|
#------------------------------------------------------------------------------
|
|
## ֪ͨѡÖÐÄ¿±ê
|
# @param curPlayer: Íæ¼ÒʵÀý
|
# @return None
|
def Sync_SelectObj(curPlayer, objType, objID, isSelect):
|
selectObj = ChPyNetSendPack.tagMCNotifySelectObj()
|
selectObj.Clear()
|
selectObj.Type = objType
|
selectObj.ID = objID
|
selectObj.isSelect = isSelect
|
NetPackCommon.SendFakePack(curPlayer, selectObj)
|
return
|
|
|
## ͳ¼ÆÍæ¼ÒÊôÐÔ£¬ÀÛ¼Ó
|
# @param attrType ÊôÐÔÀàÐÍ£¬Ð§¹ûID»òÕß×Ö·û´®
|
# @param value ÊôÐÔÖµ
|
# @param allAttrList ÊôÐÔÁбí
|
# @return None
|
def CalcAttrDict_Type(attrType, value, allAttrList):
|
if value == 0:
|
return
|
|
#[ÊôÐÔË÷Òý, ÊÇ·ñ»ù´¡ÊôÐÔ£¬(·Ç)ÏßÐÔ]
|
attrInfo = ChConfig.ItemEffect_AttrDict.get(attrType, [])
|
if attrInfo == []:
|
return
|
|
index = ChConfig.Def_CalcAttrIndexDict[(attrInfo[1], attrInfo[2])]
|
|
attrDict = allAttrList[index]
|
for i in attrInfo[0]:
|
GameWorld.AddDictValue(attrDict, {i:value})
|
return
|
|
def CalcAttrDict_TypeEx(attrType, value, allAttrDict):
|
## ͳ¼ÆÍæ¼ÒÊôÐÔ£¬ÀÛ¼Ó
|
if value == 0:
|
return
|
|
#[ÊôÐÔË÷Òý, ÊÇ·ñ»ù´¡ÊôÐÔ£¬(·Ç)ÏßÐÔ]
|
attrInfo = ChConfig.ItemEffect_AttrDict.get(attrType, [])
|
if attrInfo == []:
|
return
|
for i in attrInfo[0]:
|
GameWorld.AddDictValue(allAttrDict, {i:value})
|
return
|
|
## ÅàÑø¾³½çµÈ¼¶
|
def GetTrainRealmLVReal(curPlayer, funcType):
|
trainRealmLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_TrainRealmLV % funcType)
|
return max(trainRealmLV, curPlayer.GetOfficialRank())
|
def SetTrainRealmLV(curPlayer, funcType, trainRealmLV):
|
NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_TrainRealmLV % funcType, trainRealmLV)
|
SyncTrainRealmLV(curPlayer, funcType)
|
return
|
def SyncTrainRealmLV(curPlayer, funcType=None):
|
if funcType == None:
|
syncFuncTypeList = range(1, 1 + 10)
|
else:
|
syncFuncTypeList = [funcType]
|
infoList = []
|
for fType in syncFuncTypeList:
|
trainRealmLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_TrainRealmLV % fType)
|
if not trainRealmLV and funcType == None:
|
continue
|
lvInfo = ChPyNetSendPack.tagMCTrainRealmLV()
|
lvInfo.FuncType = fType
|
lvInfo.TrainRealmLV = trainRealmLV
|
infoList.append(lvInfo)
|
if not infoList:
|
return
|
clientPack = ChPyNetSendPack.tagMCTrainRealmLVInfo()
|
clientPack.InfoList = infoList
|
clientPack.Count = len(clientPack.InfoList)
|
NetPackCommon.SendFakePack(curPlayer, clientPack)
|
return
|
|
## ÷ÈÁ¦µÈ¼¶
|
def GetCharmLV(curPlayer): return curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_CharmLV)
|
def SetCharmLV(curPlayer, charmLV):
|
NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_CharmLV, charmLV)
|
SendPropertyRefresh(curPlayer, ShareDefine.CDBPlayerRefresh_CharmLV, charmLV)
|
return
|
|
def GetTotalLingGenPoint(curPlayer):
|
# ×ÜÁé¸ùµãÊý(½ðľˮ»ðÍÁ+×ÔÓɵãÊý)
|
return 0
|
|
# Áé¸ù - ½ðľˮ»ðÍÁ
|
def GetMetal(curPlayer): return 0
|
def GetWood(curPlayer): return 0
|
def GetWater(curPlayer): return 0
|
def GetFire(curPlayer): return 0
|
def GetEarth(curPlayer): return 0
|
|
#---Íæ¼ÒÀ©Õ¹½Ó¿Ú, Õ½¶·ÊôÐÔ£¬²»´æÊý¾Ý¿â£¬Ö»Í¨Öª±¾ÈË---
|
|
## Íæ¼Ò¼õ¼¼ÄÜCD±ÈÀý
|
def GetReduceSkillCDPer(curPlayer): return 0
|
def SetReduceSkillCDPer(curPlayer, reducePer): return
|
|
# Ѫƿ»Ö¸´Ð§¹û
|
def GetHPCureEnhance(curPlayer): return 0
|
|
# ÏÉÃË»ÕÕÂID
|
def GetFamilyEmblemID(curPlayer): return curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_FamilyEmblemID)
|
def SetFamilyEmblemID(curPlayer, emblemID): NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_FamilyEmblemID, emblemID)
|
|
# ÏÉÃËְλ£¬Ê¹Óà GetReceivedSalary£¬ÒòΪFamilyMemberLVûÓÐÈë¿â
|
def GetFamilyMemberLV(curPlayer): return curPlayer.GetReceivedSalary()
|
def SetFamilyMemberLV(curPlayer, fmLV):
|
#ÒòΪÏÉÃËְλûÓдæDBPlayer£¬¶ø¿ç·þºóÓÖûÓÐFamilyÐÅÏ¢£¬ËùÒÔÕâÀï×ö¸ö´æ´¢£¬ÓÃÓÚ¿ç·þÓÃ
|
curPlayer.SetReceivedSalary(fmLV)
|
curPlayer.SetFamilyMemberLV(fmLV) # Ҳͬ²½ÉèÖøÃÖµ£¬·ÀÖ¹ÓÐЩµØ·½Ö±½Óµ÷Óà curPlayer.GetFamilyMemberLV()
|
return
|
|
#---µ±Ç°·À»¤Öµ£¬Ðè´æDB----
|
def GetProDef(curPlayer): return 0
|
def SetProDef(curPlayer, value): return
|
|
#---×î´ó·À»¤Öµ----
|
def GetMaxProDef(curPlayer): return 0
|
def SetMaxProDef(curPlayer, value): return
|
|
# ÿXÃë×Ô¶¯Ïûʧһ¸öÓ¡¼Ç£¬ ºÁÃë¼Ç¼
|
def GetLostYinjiTime(curPlayer): return 0
|
def SetLostYinjiTime(curPlayer, value): return
|
|
# µ±Ç°Ó¡¼ÇÊý
|
def GetYinjiCnt(curPlayer): return 0
|
def SetYinjiCnt(curPlayer, value): return
|
|
# ¼õÉÙÖ¸¶¨¼¼ÄÜ×éCD XX%
|
def GetTheFBSkillsCD(curPlayer): return 0
|
def SetTheFBSkillsCD(curPlayer, value): return
|
# ×ÆÉչ̶¨É˺¦
|
def GetBurnValue(curPlayer): return 0
|
def SetBurnValue(curPlayer, value): return
|
# ÑÓ³¤×ÆÉÕʱ¼ä°Ù·Ö±È
|
def GetBurnTimePer(curPlayer): return 0
|
def SetBurnTimePer(curPlayer, value): return
|
# ¼õÒƶ¯ËٶȰٷֱÈ
|
def GetSubSpeedPer(curPlayer): return 0
|
def SetSubSpeedPer(curPlayer, value): return
|
|
#-------------------------------------------------------------------------------
|
|
## ÉèÖñ£´æ¹¦ÄÜÊÂÏȼÆËãºÃµÄÊôÐÔÖµ
|
def SetCalcAttrListValue(curPlayer, funcIndex, allAttrList, insidePerAttrDict=None, customAttrDict=None):
|
# ÉèÖÃֵ֮ǰÏÈÇå¿ÕÖØÖÃ
|
# @param customAttrDict: ×Ô¶¨ÒåµÄÊôÐÔÐÅÏ¢£¬±ØÐëÊǸñʽ {"×Ô¶¨ÒåÊôÐÔÃèÊöÃûkey":ÊôÐÔÐÅÏ¢, ...} ×Ô¶¨ÒåÊôÐÔÃèÊöÃûkey - ½¨Ò鲻ͬ¹¦ÄܵãÖ®¼ä²»ÒªÖظ´
|
ClearCalcAttrListValue(curPlayer, funcIndex)
|
if insidePerAttrDict == None:
|
insidePerAttrDict = {}
|
if customAttrDict == None:
|
customAttrDict = {}
|
|
battleAttrDict = allAttrList[ChConfig.CalcAttr_Battle]
|
if ChConfig.TYPE_Calc_PerLVAtk in battleAttrDict:
|
# ÿ1¼¶¼ÓµÄ¹¥»÷Á¦²»Ò»¶¨Âú1µã£¬ËùÒÔÕâÀï°´Íò·ÖÂÊÀ´Ë㣬֧³ÖСÊýËã·¨
|
addAtk = int(curPlayer.GetLV() * battleAttrDict[ChConfig.TYPE_Calc_PerLVAtk] / float(ShareDefine.Def_MaxRateValue))
|
battleAttrDict[ChConfig.TYPE_Calc_AttrATKMin] = battleAttrDict.get(ChConfig.TYPE_Calc_AttrATKMin, 0) + addAtk
|
battleAttrDict[ChConfig.TYPE_Calc_AttrATKMax] = battleAttrDict.get(ChConfig.TYPE_Calc_AttrATKMax, 0) + addAtk
|
|
if ChConfig.TYPE_Calc_PerLVMaxHP in battleAttrDict:
|
# ÿ1¼¶¼ÓµÄÉúÃüÖµ²»»áÉÙÓÚ1µã£¬ËùÒÔÖ±½Ó³Ë
|
addMaxHP = curPlayer.GetLV() * battleAttrDict[ChConfig.TYPE_Calc_PerLVMaxHP]
|
battleAttrDict[ChConfig.TYPE_Calc_AttrMaxHP] = battleAttrDict.get(ChConfig.TYPE_Calc_AttrMaxHP, 0) + addMaxHP
|
|
playerID = curPlayer.GetPlayerID()
|
if playerID not in PyGameData.g_playerFuncAttrDict:
|
PyGameData.g_playerFuncAttrDict[playerID] = {}
|
funcAttrDict = PyGameData.g_playerFuncAttrDict[playerID]
|
funcAttrDict[funcIndex] = [allAttrList, insidePerAttrDict, customAttrDict]
|
#GameWorld.DebugLog("±£´æ¹¦ÄܵãÊôÐÔ: funcIndex=%s, %s, %s" % (funcIndex, allAttrList, insidePerAttrDict))
|
return
|
|
def GetCalcAttrListValue(curPlayer, funcIndex):
|
## »ñÈ¡¹¦ÄܵãÔ¤ÏȼÆËãµÄËù¼ÓÊôÐÔÖµ
|
attrList = [{} for _ in range(4)]
|
insidePerAttrDict = {}
|
customAttrDict = {}
|
if isinstance(funcIndex, int):
|
funcIndexList = [funcIndex]
|
elif isinstance(funcIndex, list):
|
funcIndexList = funcIndex
|
else:
|
return attrList, insidePerAttrDict, customAttrDict
|
|
playerID = curPlayer.GetPlayerID()
|
if playerID not in PyGameData.g_playerFuncAttrDict:
|
return attrList, insidePerAttrDict, customAttrDict
|
funcAttrDict = PyGameData.g_playerFuncAttrDict[playerID]
|
for funcIndex in funcIndexList:
|
if funcIndex not in funcAttrDict:
|
continue
|
funcAttrList, funcInsidePerAttrDict, funcCustomAttrDict = funcAttrDict[funcIndex]
|
for i, attrDict in enumerate(attrList):
|
curAttrDict = funcAttrList[i]
|
AddAttrDictValue(attrDict, curAttrDict)
|
customAttrDict.update(funcCustomAttrDict)
|
AddAttrDictValue(insidePerAttrDict, funcInsidePerAttrDict)
|
return attrList, insidePerAttrDict, customAttrDict
|
|
## ÖØÖûº´æ
|
def ClearCalcAttrListValue(curPlayer, funcIndex):
|
playerID = curPlayer.GetPlayerID()
|
if playerID not in PyGameData.g_playerFuncAttrDict:
|
return
|
funcAttrDict = PyGameData.g_playerFuncAttrDict[playerID]
|
funcAttrDict.pop(funcIndex, None)
|
return
|
|
def AddAttrListValue(attrList):
|
addAttrList = [{} for _ in range(4)]
|
for aList in attrList:
|
for i in ChConfig.CalcAttrIndexList:
|
AddAttrDictValue(addAttrList[i], aList[i])
|
return addAttrList
|
|
## ÊôÐÔÖµ×ÖµäÀÛ¼Ó
|
def AddAttrDictValue(dict1, dict2):
|
for key, value in dict2.items():
|
if key not in dict1:
|
dict1[key] = value
|
else:
|
aValue = dict1[key]
|
if key in ChConfig.TYPE_Calc_DeclineList:
|
# ÕâÖÖËã·¨µÄÊôÐÔÒ»°ãÊÇÍò·ÖÂʵģ¬×î´ó²»³¬¹ý°Ù·Ö°Ù£¬¹ÊÔÝĬÈÏÍò·ÖÂÊ, ÈôÓв»ÊÇÍò·ÖÂʵÄÊôÐÔÔÙ×ö´¦Àí
|
dict1[key] = 10000 - (10000 - aValue) * (10000 - value)
|
else:
|
dict1[key] = aValue + value
|
return
|
|
def GetLordAttr(curPlayer):
|
## »ñÈ¡Ö÷¹«ÊôÐÔ»ã×Ü
|
lordAttrDict = {"Atk":curPlayer.GetMaxAtk(), "Def":curPlayer.GetDef(), "MaxHP":GameObj.GetMaxHP(curPlayer),
|
"Hit":curPlayer.GetHit(), "Miss":curPlayer.GetMiss()}
|
return lordAttrDict
|
|
#-------------------------------------------------------------------------------
|
## ÉèÖÃÍæ¼Ò×ÖµäÖµ, ´æ¿â
|
def NomalDictSetProperty(curPlayer, key, value, dType=0):
|
if CrossPlayerData.IsNeedProcessCrossPlayer(curPlayer) and key not in \
|
[ChConfig.Def_PDict_FightPower_Total, ChConfig.Def_PDict_FightPower_TotalEx, ChConfig.Def_PlayerKey_CrossRegisterMap]:
|
playerID = curPlayer.GetPlayerID()
|
changeDict = PyGameData.g_crossPlayerDictChangeInfo.get(playerID, {})
|
changeDict[(key, dType)] = value
|
PyGameData.g_crossPlayerDictChangeInfo[playerID] = changeDict
|
|
if value == 0:
|
curPlayer.NomalDictDelProperty(key, dType)
|
return
|
# 2^31 - 1
|
curPlayer.NomalDictAddProperty(key, min(value, ChConfig.Def_UpperLimit_DWordEx), dType)
|
return
|
|
## ֪ͨף¸£Öµ
|
def Sync_BlessValue(curPlayer, blessType, value, multiple=0):
|
itemList = []
|
|
valuePack = ChPyNetSendPack.tagMCSyncSingleBlessValue()
|
valuePack.Clear()
|
valuePack.Type = blessType
|
valuePack.Value = value
|
valuePack.Multiple = multiple
|
itemList.append(valuePack)
|
|
sendPack = ChPyNetSendPack.tagMCSyncBlessValue()
|
sendPack.Clear()
|
sendPack.TypeCnt = len(itemList)
|
sendPack.BlessInfo = itemList
|
|
#֪ͨ¿Í»§¶Ë
|
NetPackCommon.SendFakePack(curPlayer, sendPack)
|
return
|
|
#ͬ²½ÉèÖà Íæ¼ÒºÍ³èÎï¼°ÒÑÕÙ»½µÄÕÙ»½ÊÞ ÊÓÒ°²ã
|
def SetPlayerSightLevel(curPlayer, sightLevel):
|
# µ±ÊÓÒ°ÉèÖÃ0ʱ£¬ÔÚ¾³½çµØͼÔò×Ô¶¯ÉèÖÃÒÑÑ¡ÔñµÄ¾³½çÄѶÈÊÓÒ°
|
if sightLevel == 0:
|
realmDifficulty = GetMapRealmDifficulty(curPlayer)
|
if realmDifficulty:
|
sightLevel = realmDifficulty
|
GameWorld.DebugLog("¾³½çµØͼ×Ô¶¯ÉèÖÃÒÑÑ¡ÔñµÄ¾³½çÄѶÈÊÓÒ°: sightLevel=%s" % sightLevel)
|
|
curPlayer.SetSightLevel(sightLevel)
|
rolePet = curPlayer.GetPetMgr().GetFightPet()
|
#ÎÞ³öÕ½³èÎï
|
if rolePet:
|
rolePet.SetSightLevel(sightLevel)
|
|
for i in range(curPlayer.GetSummonCount()):
|
curSummon = curPlayer.GetSummonNPCAt(i)
|
if not curSummon:
|
continue
|
curSummon.SetSightLevel(sightLevel)
|
return
|
