#!/usr/bin/python
|
# -*- coding: GBK -*-
|
#-------------------------------------------------------------------------------
|
#
|
##@package AuctionHouse
|
#
|
# @todo:ÅÄÂôÐÐ
|
# @author hxp
|
# @date 2019-03-04
|
# @version 1.0
|
#
|
# ÏêϸÃèÊö: ÅÄÂôÐÐ
|
#
|
#-------------------------------------------------------------------------------
|
#"""Version = 2019-03-04 17:00"""
|
#-------------------------------------------------------------------------------
|
import GameWorld
|
import PyDataManager
|
import PlayerControl
|
import DataRecordPack
|
import PyGameDataStruct
|
import PlayerCompensation
|
import IPY_PlayerDefine
|
import ChPyNetSendPack
|
import PlayerDBGSEvent
|
import IpyGameDataPY
|
import NetPackCommon
|
import PlayerBourse
|
import PlayerFamily
|
import ShareDefine
|
import PyGameData
|
import ChConfig
|
|
import random
|
import datetime
|
import operator
|
import time
|
import math
|
import json
|
|
# ÅÄÂô¼Ç¼ÀàÐͶ¨Òå
|
AuctionRecordTypeList = (
|
AuctionRecordType_MyAuction, # ÎÒµÄÅÄÆ·
|
AuctionRecordType_FamilyAuction, # ÏÉÃËÅÄÆ·
|
AuctionRecordType_MyBid, # ÎҵľºÅÄ
|
) = range(3)
|
|
# ÅÄÂô¼Ç¼½á¹û¶¨Òå
|
AuctionRecordResultList = (
|
AuctionRecordResult_SellFail, # Á÷ÅÄ
|
AuctionRecordResult_SellOK, # ÅÄÂô³É½»
|
AuctionRecordResult_Recycle, # ϵͳ»ØÊÕ
|
AuctionRecordResult_BidOK, # ¾º¼Û³É¹¦
|
AuctionRecordResult_BidFail, # ¾º¼Ûʧ°Ü
|
AuctionRecordResult_MoveToWorld, # ÏÉÃËÅÄƷתÒƵ½È«·þÅÄÆ·
|
AuctionRecordResult_Unsell, # ϼÜ
|
) = range(7)
|
|
# µ±Ç°ÅÄÆ·¹éÀà 0-È«·þÅÄÆ· 1-ÏÉÃË˽ÓÐÅÄÆ·
|
AuctionType_World = 0
|
AuctionType_Family = 1
|
|
'''
|
¾º¼ÛÁ÷³Ì:
|
1. MapServer ÏÈÑéÖ¤¼Û¸ñÊÇ·ñ¹»
|
2. GameServer ÑéÖ¤ÊÇ·ñ¿ÉÒÔ¾º¼Û
|
3. MapServer ¿Û³ýÍæ¼Ò»õ±Ò
|
4. GameServer ½øÐоº¼Û£¬±ä¸üÏ´ξº¼Û¼Û¸ñ
|
|
»ùÓÚÒÔÉÏÁ÷³Ì£¬ËùÒÔÍæ¼Ò¾º¼ÛʱÐèÏÈËø¶¨ÎïÆ·£¬·ÀÖ¹¾º¼ÛÁ÷³ÌδÍê½áʱÆäËûÍæ¼ÒÇëÇ󾺼ÛͬһÅÄÆ·ÅжϾº¼Û¼Û¸ñ´íÎó
|
Ëø¶¨Ê±³¤Í¬ÑùÊÊÓÃÓÚÅÄÆ·¾º¼Ûʱ¼ä½áÊøʱµÄ±£»¤Ê±¼ä
|
'''
|
BiddingQueryLockTick = 10000
|
|
#ÅÄÂôÐÐ״̬¿ª¹Ø
|
def GetAuctionHouseState(): return PlayerBourse.GetOpenState()
|
|
def OnPlayerLogin(curPlayer):
|
Sync_PlayerAuctionItemInfo(curPlayer)
|
Sync_FamilyAuctionItemInfo(curPlayer, curPlayer.GetFamilyID())
|
Sync_PlayerBiddingItemInfo(curPlayer)
|
Sync_PlayerAttentionAuctionItemID(curPlayer, False)
|
return
|
|
def OnPlayerLeaveServer(curPlayer):
|
playerID = curPlayer.GetPlayerID()
|
auctionItemMgr = PyDataManager.GetAuctionItemManager()
|
auctionItemMgr.myAttentionItemDict.pop(playerID, None)
|
return
|
|
##--------------------------------------- ÅÄÂô¼Ç¼ -------------------------------------------------
|
def GetMyAuctionItemRecord(playerID):
|
## »ñÈ¡ÎÒµÄÅÄÆ·¼Ç¼
|
return PyDataManager.GetAuctionRecordManager().myAuctionItemRecordDict.get(playerID, [])
|
|
def GetMyBiddingItemRecord(playerID):
|
## »ñÈ¡ÎҵľºÅļǼ
|
return PyDataManager.GetAuctionRecordManager().myBidItemRecordDict.get(playerID, [])
|
|
def GetFamilyAuctionItemRecord(familyID):
|
## »ñÈ¡ÏÉÃËÅÄÆ·¼Ç¼
|
return PyDataManager.GetAuctionRecordManager().familyAuctionItemRecordDict.get(familyID, [])
|
|
def AddAuctionRecord(auctionItem, recordResult):
|
''' Ìí¼ÓÅÄÂôÐмǼ
|
@param auctionItem: Ïà¹ØµÄÅÄƷʵÀý
|
@param recordResult: ¼Ç¼½á¹û 0-Á÷ÅÄ 1-ÅÄÂô³É½» 2-»ØÊÕ 3-¾º¼Û³É¹¦ 4-¾º¼Ûʧ°Ü
|
'''
|
if not auctionItem:
|
return
|
|
playerID, familyID, bidderID = auctionItem.PlayerID, auctionItem.FamilyID, auctionItem.BidderID
|
recordPlayerID, recordFamilyID = 0, 0
|
|
if recordResult in [AuctionRecordResult_BidOK, AuctionRecordResult_BidFail]:
|
recordType = AuctionRecordType_MyBid
|
recordPlayerID = bidderID
|
else:
|
if familyID:
|
recordType = AuctionRecordType_FamilyAuction
|
recordFamilyID = familyID
|
else:
|
recordType = AuctionRecordType_MyAuction
|
recordPlayerID = playerID
|
|
if not recordPlayerID and not recordFamilyID:
|
return
|
|
newRecordData = PyGameDataStruct.tagDBAuctionRecord()
|
newRecordData.ItemGUID = auctionItem.ItemGUID
|
newRecordData.PlayerID = recordPlayerID
|
newRecordData.FamilyID = recordFamilyID
|
newRecordData.RecordType = recordType
|
newRecordData.RecordResult = recordResult
|
newRecordData.RecordTime = GameWorld.GetCurrentDataTimeStr()
|
newRecordData.BidderPrice = auctionItem.BidderPrice
|
newRecordData.BidderName = auctionItem.BidderName
|
newRecordData.ItemID = auctionItem.ItemID
|
newRecordData.Count = auctionItem.Count
|
newRecordData.UserData = auctionItem.UserData
|
newRecordData.UserDataLen = auctionItem.UserDataLen
|
AddNewAuctionRecord(newRecordData)
|
|
if recordFamilyID:
|
Sync_PlayerAuctionRecordInfo(None, recordType, newRecordData, recordFamilyID)
|
elif recordPlayerID:
|
recordPlayer = GameWorld.GetPlayerManager().FindPlayerByID(recordPlayerID)
|
if recordPlayer and not PlayerControl.GetIsTJG(recordPlayer):
|
Sync_PlayerAuctionRecordInfo(recordPlayer, recordType, newRecordData)
|
return
|
|
def AddNewAuctionRecord(newRecordData):
|
playerID = newRecordData.PlayerID
|
familyID = newRecordData.FamilyID
|
recordType = newRecordData.RecordType
|
if recordType == AuctionRecordType_MyAuction:
|
keyID = playerID
|
recordDict = PyDataManager.GetAuctionRecordManager().myAuctionItemRecordDict
|
elif recordType == AuctionRecordType_FamilyAuction:
|
keyID = familyID
|
recordDict = PyDataManager.GetAuctionRecordManager().familyAuctionItemRecordDict
|
elif recordType == AuctionRecordType_MyBid:
|
keyID = playerID
|
recordDict = PyDataManager.GetAuctionRecordManager().myBidItemRecordDict
|
else:
|
return
|
recordList = recordDict.get(keyID, [])
|
maxCount = min(50, IpyGameDataPY.GetFuncCfg("AuctionHouse", 3))
|
if len(recordList) >= maxCount:
|
del recordList[0]
|
recordList.append(newRecordData)
|
recordDict[keyID] = recordList
|
return
|
##-------------------------------------- ÅÄÂô¹Ø×¢ ------------------------------------------------
|
|
def GetPlayerAuctionAttention(attentionMgr, playerID):
|
## »ñÈ¡Íæ¼Ò¹Ø×¢µÄÎïÆ·IDÁбí
|
if playerID not in attentionMgr.playerAttentionDict:
|
return []
|
attentionObj = attentionMgr.playerAttentionDict[playerID]
|
attentionItemIDList = attentionObj.AttentionItemIDList
|
return attentionItemIDList
|
|
def AddPlayerAuctionAttention(attentionMgr, playerID, itemID):
|
## Ìí¼ÓÍæ¼Ò¹Ø×¢µÄÎïÆ·ID
|
if playerID not in attentionMgr.playerAttentionDict:
|
dbData = PyGameDataStruct.tagDBAuctionAttention()
|
dbData.PlayerID = playerID
|
__InitAuctionAttentionAttrEx(dbData)
|
attentionMgr.playerAttentionDict[playerID] = dbData
|
attentionObj = attentionMgr.playerAttentionDict[playerID]
|
attentionItemIDList = attentionObj.AttentionItemIDList
|
if len(attentionItemIDList) >= IpyGameDataPY.GetFuncCfg("AuctionHouse", 5):
|
GameWorld.DebugLog("¹Ø×¢ÅÄÆ·Êý´ïµ½ÉÏÏÞ!", playerID)
|
return
|
if itemID in attentionItemIDList:
|
return True
|
attentionItemIDList.append(itemID)
|
attentionObj.AttentionInfo = str(attentionItemIDList)
|
attentionObj.AttentionLen = len(attentionObj.AttentionInfo)
|
return True
|
|
def DelPlayerAuctionAttention(attentionMgr, playerID, itemID):
|
## ɾ³ýÍæ¼Ò¹Ø×¢µÄÎïÆ·ID
|
if playerID not in attentionMgr.playerAttentionDict:
|
return
|
attentionObj = attentionMgr.playerAttentionDict[playerID]
|
attentionItemIDList = attentionObj.AttentionItemIDList
|
if itemID not in attentionItemIDList:
|
return
|
attentionItemIDList.remove(itemID)
|
attentionObj.AttentionInfo = str(attentionItemIDList)
|
attentionObj.AttentionLen = len(attentionObj.AttentionInfo)
|
return True
|
|
def OnLoadAuctionAttentionDataEx(attentionData):
|
## ¼ÓÔØÅÄÂô¹Ø×¢±íʱ¸½¼Ó´¦Àí
|
__InitAuctionAttentionAttrEx(attentionData)
|
return
|
|
def __InitAuctionAttentionAttrEx(attentionData):
|
## ³õʼ»¯ÅÄÂô¹ØעʵÀý¸½¼ÓÊôÐÔ
|
setattr(attentionData, "AttentionItemIDList", [])
|
if attentionData.AttentionInfo.startswith("[") and attentionData.AttentionInfo.endswith("]"):
|
attentionData.AttentionItemIDList = json.loads(attentionData.AttentionInfo)
|
return
|
|
##-------------------------------------------------------------------------------------------------
|
def OnGameServerInitOK():
|
## ·þÎñÆ÷Æô¶¯³É¹¦
|
|
allAuctionItemByEndTimeList = PyDataManager.GetAuctionItemManager().allAuctionItemByEndTimeList
|
# ÓÉÓÚ·þÎñÆ÷δÆô¶¯³É¹¦Ê±È¡²»µ½ÕýÈ·µÄ¿ª·þÌ죬ËùÒÔÆô¶¯³É¹¦ºóË¢ÐÂÒ»ÏÂÅÄƷϵͳ»Ø¹ºÊ±¼ä
|
for auctionItem in allAuctionItemByEndTimeList:
|
__SetAuctionItemSysBuyTime(auctionItem)
|
|
__SortAuctionitem()
|
return
|
|
def OnLoadAuctionItemDataEx(dbData):
|
## ¼ÓÔØÅÄÂôÎïÆ·±íʱ¸½¼Ó´¦Àí
|
__InitAuctionItemAttrEx(dbData)
|
playerID = dbData.PlayerID
|
familyID = dbData.FamilyID
|
bidderID = dbData.BidderID
|
|
pyAuctionItemMgr = PyDataManager.GetAuctionItemManager()
|
pyAuctionItemMgr.allAuctionItemByEndTimeList.append(dbData)
|
|
if dbData.AuctionType == AuctionType_World:
|
pyAuctionItemMgr.worldAuctionItemList.append(dbData)
|
__OnCalcWorldAuctionItemCount(dbData, 1)
|
|
if familyID:
|
familyItemList = pyAuctionItemMgr.familyAuctionItemDict.get(familyID, [])
|
familyItemList.append(dbData)
|
pyAuctionItemMgr.familyAuctionItemDict[familyID] = familyItemList
|
|
if playerID:
|
myItemList = pyAuctionItemMgr.myAuctionItemDict.get(playerID, [])
|
myItemList.append(dbData)
|
pyAuctionItemMgr.myAuctionItemDict[playerID] = myItemList
|
|
if str(playerID) in dbData.BidderIDInfo:
|
if playerID == bidderID:
|
nowBidItemList = pyAuctionItemMgr.nowBiddingAuctionItemDict.get(playerID, [])
|
nowBidItemList.append(dbData)
|
pyAuctionItemMgr.nowBiddingAuctionItemDict[playerID] = nowBidItemList
|
else:
|
hisBidItemList = pyAuctionItemMgr.hisBiddingAuctionItemDict.get(playerID, [])
|
hisBidItemList.append(dbData)
|
pyAuctionItemMgr.hisBiddingAuctionItemDict[playerID] = hisBidItemList
|
|
return
|
|
def OnLoadAuctionItemDataOK():
|
## ¼ÓÔØÅÄÂôÎïÆ·±íÍê³ÉºóµÄ´¦Àí
|
__SortAuctionitem()
|
return
|
|
def __InitAuctionItemAttrEx(auctionItem, ipyData=None):
|
## ³õʼ»¯ÅÄƷʵÀý¸½¼ÓÊôÐÔ
|
if not ipyData:
|
ipyData = IpyGameDataPY.GetIpyGameData("AuctionItem", auctionItem.ItemID)
|
setattr(auctionItem, "Sortpriority", 99999 - (0 if not ipyData else ipyData.GetSortpriority())) # ÅÅÐòÓÅÏȼ¶¹é×é
|
setattr(auctionItem, "BiddingQueryID", 0) # µ±Ç°ÕýÔÚ¾º¼ÛµÄÍæ¼ÒID
|
setattr(auctionItem, "BiddingQueryTick", 0) # µ±Ç°ÕýÔÚ¾º¼ÛµÄtick
|
setattr(auctionItem, "EndTime", 0) # ½áÊø¾º¼ÛtimeÖµ
|
setattr(auctionItem, "SysBuyTime", 0) # ϵͳһ¿Ú¼Ûʱ¼ä
|
|
__SetAuctionItemSysBuyTime(auctionItem)
|
__SetAuctionItemEndTime(auctionItem, ipyData)
|
return True
|
|
def __SetAuctionItemSysBuyTime(auctionItem):
|
## ¸üÐÂϵͳһ¿Ú¼Û¸ÃÅÄƷʱ¼ä
|
if not GameWorld.GetGameWorld().GetDictByKey(ChConfig.Def_WorldKey_GameWorldInitOK):
|
#GameWorld.DebugLog("·þÎñÆ÷δÆô¶¯ºÃ£¬È¡²»µ½ÕýÈ·µÄ¿ª·þÌ죬²»´¦ÀíÅÄƷϵͳ»Ø¹ºÊ±¼ä!")
|
return
|
#itemGUID = auctionItem.ItemGUID
|
itemID = auctionItem.ItemID
|
itemType = auctionItem.ItemType
|
playerID = auctionItem.PlayerID
|
familyID = auctionItem.FamilyID
|
if not playerID and not familyID:
|
#GameWorld.DebugLog("¸ÃÅÄƷΪϵͳÉϼܵÄÅÄÆ·£¬²»ÉèÖÃϵͳһ¿Ú¼Ûʱ¼ä! GUID=%s,itemID=%s" % (itemGUID, itemID))
|
return
|
|
if familyID:
|
#GameWorld.DebugLog("¸ÃÅÄƷΪÏÉÃËÅÄÆ·£¬²»ÉèÖÃϵͳһ¿Ú¼Ûʱ¼ä! GUID=%s,itemID=%s,familyID=%s" % (itemGUID, itemID, familyID))
|
return
|
|
# ×¢Ò⣺ ÒòΪGameServerû´«ÊÇ·ñÌ××°£¬ËùÒÔÔÝʱ°´²ß»®µÄID¹æÔòÀ´´¦Àí£¬×îºóһλ´ú±íÊÇ·ñÌ××°
|
if itemID % 10 != 0:
|
#GameWorld.DebugLog("¸ÃÅÄƷΪÌ××°ÅÄÆ·£¬²»ÉèÖÃϵͳһ¿Ú¼Ûʱ¼ä! itemID=%s" % (itemID))
|
return
|
|
if auctionItem.BidderID:
|
#GameWorld.DebugLog("¸ÃÅÄÆ·ÒѾÓÐÈ˾º¼Û£¬²»ÉèÖÃϵͳһ¿Ú¼Ûʱ¼ä! itemID=%s,bidderID=%s" % (itemID, auctionItem.BidderID))
|
return
|
|
classLV = auctionItem.ItemClassLV
|
classSysBuyRateDict = IpyGameDataPY.GetFuncEvalCfg("AuctionItemSystem", 5)
|
if classLV in classSysBuyRateDict:
|
sysBuyRate = classSysBuyRateDict[classLV]
|
if not GameWorld.CanHappen(sysBuyRate, 100):
|
#GameWorld.DebugLog("¸ÃÅÄÆ·½×¸ÅÂʲ»»ØÊÕ£¬²»ÉèÖÃϵͳһ¿Ú¼Ûʱ¼ä! itemID=%s,classLV=%s,sysBuyRate=%s" % (itemID, classLV, sysBuyRate))
|
return
|
|
canSysBuyItemTypeList = IpyGameDataPY.GetFuncEvalCfg("AuctionItemSystem", 2)
|
if itemType not in canSysBuyItemTypeList:
|
#GameWorld.DebugLog("¸ÃÅÄÆ·ÀàÐͲ»¿É±»ÏµÍ³Ò»¿Ú¼Û£¬²»ÉèÖÃϵͳһ¿Ú¼Ûʱ¼ä! itemID=%s,itemType=%s" % (itemID, itemType))
|
return
|
|
sysBuyTimeRange = {}
|
openServerDay = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_ServerDay) + 1
|
oscDaySysBuyTimeRangeDict = IpyGameDataPY.GetFuncEvalCfg("AuctionItemSystem", 1, {})
|
openServerDayList = oscDaySysBuyTimeRangeDict.keys()
|
openServerDayList.sort()
|
for oscDay in openServerDayList:
|
if openServerDay <= oscDay:
|
sysBuyTimeRange = oscDaySysBuyTimeRangeDict[oscDay]
|
break
|
if len(sysBuyTimeRange) != 2:
|
#GameWorld.DebugLog("¸Ã¿ª·þÌìûÓÐÅäÖÃϵͳÖмäÉ̻عºÖ§³Ö! openServerDay=%s, %s" % (openServerDay, oscDaySysBuyTimeRangeDict))
|
return
|
randMinutes = random.randint(sysBuyTimeRange[0], sysBuyTimeRange[1])
|
addTimeStr = auctionItem.AddTime
|
addTime = GameWorld.ChangeTimeStrToNum(addTimeStr)
|
auctionItem.SysBuyTime = addTime + randMinutes * 60
|
pyAuctionItemMgr = PyDataManager.GetAuctionItemManager()
|
pyAuctionItemMgr.sysBuyoutItemByTimeList.append(auctionItem)
|
#GameWorld.DebugLog("¸üÐÂÅÄƷϵͳһ¿Ú¼Ûʱ¼ä: GUID=%s,itemID=%s,addTime=%s(%s),openServerDay=%s,randMinutes=%s(%s),sysBuyTime=%s"
|
# % (itemGUID, itemID, addTime, addTimeStr, openServerDay, randMinutes, sysBuyTimeRange, auctionItem.SysBuyTime))
|
return
|
|
def __SetAuctionItemEndTime(auctionItem, ipyData):
|
## ¸üÐÂÅÄÆ·½áÊø¾º¼ÛtimeÖµ
|
if not ipyData:
|
return
|
addTimeStr = auctionItem.AddTime
|
auctionType = auctionItem.AuctionType
|
addTime = GameWorld.ChangeTimeStrToNum(addTimeStr)
|
noticeMinutes = ipyData.GetNoticeSaleMinutes()
|
saleMinutes = ipyData.GetFamilySaleMinutes() if auctionType == AuctionType_Family else ipyData.GetWorldSaleMinutes()
|
auctionItem.EndTime = addTime + (noticeMinutes + saleMinutes) * 60
|
|
__AddAuctionItemEndTimeByBid(auctionItem)
|
return
|
|
def __AddAuctionItemEndTimeByBid(auctionItem):
|
# ¸ù¾Ý×îºóÒ»´Î¾º¼Ûʱ¼ä½øÐмÓʱ
|
if not auctionItem.BidderPrice:
|
return
|
bidTime = GameWorld.ChangeTimeStrToNum(auctionItem.BiddingTime)
|
endTime = bidTime + IpyGameDataPY.GetFuncCfg("AuctionHouse", 4)
|
if endTime <= auctionItem.EndTime:
|
return
|
GameWorld.DebugLog("ÅÄÆ·¼Óʱ: EndTime=%s,updEndTime=%s" % (auctionItem.EndTime, endTime))
|
auctionItem.EndTime = endTime
|
return True
|
|
def __GetAuctionItemDRDict(auctionItem):
|
drDict = {"GUID":auctionItem.ItemGUID, "PlayerID":auctionItem.PlayerID, "FamilyID":auctionItem.FamilyID,
|
"ItemID":auctionItem.ItemID, "Count":auctionItem.Count, "AuctionType":auctionItem.AuctionType,
|
"AddTime":auctionItem.AddTime, "BiddingTime":auctionItem.BiddingTime, "BidderID":auctionItem.BidderID,
|
"BidderPrice":auctionItem.BidderPrice, "UserData":auctionItem.UserData,
|
"EndTime":"" if not auctionItem.EndTime else GameWorld.ChangeTimeNumToStr(auctionItem.EndTime),
|
"FamilyPlayerIDInfo":auctionItem.FamilyPlayerIDInfo, "BidderIDInfo":auctionItem.BidderIDInfo}
|
return drDict
|
|
def GetAuctionItem(itemGUID):
|
## »ñÈ¡ÅÄƷʵÀý
|
return PyDataManager.GetAuctionItemManager().allAuctionItemDict.get(itemGUID)
|
|
def GetPlayerAuctionItemList(playerID):
|
## Íæ¼ÒÅÄÂôÖеÄÅÄÆ·Áбí
|
return PyDataManager.GetAuctionItemManager().myAuctionItemDict.get(playerID, [])
|
|
def GetFamilyAuctionItemList(familyID):
|
## ÏÉÃËÅÄÂôÖеÄÅÄÆ·Áбí
|
return PyDataManager.GetAuctionItemManager().familyAuctionItemDict.get(familyID, [])
|
|
def IsFamilyMemberBiddingAuctionItem(familyID, memberID):
|
## ÏÉÃ˳ÉÔ±ÊÇ·ñ×î¸ß¾º¼ÛÅÄÆ·ÖÐ
|
familyAuctionItemList = GetFamilyAuctionItemList(familyID)
|
for auctionItem in familyAuctionItemList:
|
if auctionItem.BidderID == memberID:
|
return True
|
return False
|
|
def __OnCalcWorldAuctionItemCount(auctionItem, changeCount):
|
## ÊÀ½çÅÄÆ·ÊýÁ¿±ä¸üͳ¼Æ´¦Àí
|
|
if auctionItem.AuctionType != AuctionType_World:
|
return
|
|
auctionItemMgr = PyDataManager.GetAuctionItemManager()
|
itemID = auctionItem.ItemID
|
#GameWorld.DebugLog("ÊÀ½çÅÄÆ·ÊýÁ¿±ä¸üͳ¼Æ: itemID=%s,changeCount=%s" % (itemID, changeCount))
|
|
itemIDStr = str(itemID)
|
classLV = auctionItem.ItemClassLV
|
jobLimit = auctionItem.ItemJobLimit
|
# ͳ¼ÆÓÐÖ°ÒµÏÞÖƵľ³½ç×°±¸
|
if jobLimit and classLV and len(itemIDStr) == 7:
|
color = int(itemIDStr[3:4])
|
isSuit = int(itemIDStr[-1])
|
jobEquipKey = (jobLimit, classLV, color, isSuit) # Ö°Òµ,½×,ÑÕÉ«,ÊÇ·ñÌ××°
|
befCount = auctionItemMgr.worldAuctionJobEquipCountDict.get(jobEquipKey, 0)
|
updCount = max(befCount + changeCount, 0)
|
auctionItemMgr.worldAuctionJobEquipCountDict[jobEquipKey] = updCount
|
#GameWorld.DebugLog(" Ö°Òµ¾³½ç×°±¸ÊýÁ¿±ä¸ü: jobLimit=%s,classLV=%s,color=%s,isSuit=%s,befCount=%s,updCount=%s"
|
# % (jobLimit, classLV, color, isSuit, befCount, updCount))
|
# ÆäËûµÄÖ±½ÓÓÃitemIDͳ¼Æ
|
else:
|
befCount = auctionItemMgr.worldAuctionItemCountDict.get(itemID, 0)
|
updCount = max(befCount + changeCount, 0)
|
auctionItemMgr.worldAuctionItemCountDict[itemID] = updCount
|
#GameWorld.DebugLog(" ÎïÆ·IDÊýÁ¿±ä¸ü: itemID=%s,befCount=%s,updCount=%s" % (itemID, befCount, updCount))
|
|
return
|
|
def __GetAuctionSystemItemInfo():
|
key = "AuctionSystemItem"
|
openServerDay = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_ServerDay) + 1
|
AuctionSystemItem = IpyGameDataPY.GetConfigEx(key)
|
reloadSign = openServerDay
|
if AuctionSystemItem and AuctionSystemItem[0] == reloadSign:
|
GameWorld.DebugLog("ÒѾ¼ÓÔعý±¾ÈÕϵͳÅÄÆ·´¦ÀíÐÅÏ¢£¡openServerDay=%s" % openServerDay)
|
return AuctionSystemItem[1]
|
|
# ÒòΪºóÃæµÄʱ¼äÅж϶¼ÊǾ«È·µ½·ÖµÄ£¬¶ø´¦Àí´ËÂß¼µÄʱºò¿ÉÄܲ»ÊÇ0Ã룬ËùÒÔÕâÀïµÄdatetimeÈ¡µ±Ç°Ê±¼ä¾«È·µ½·ÖµÄ
|
serverTime = GameWorld.GetServerTime()
|
curDateStr = "%d-%d-%d" % (serverTime.year, serverTime.month, serverTime.day)
|
curDateTimeStr = "%d-%d-%d %02d:%02d:00" % (serverTime.year, serverTime.month, serverTime.day, serverTime.hour, serverTime.minute)
|
curDateTime = datetime.datetime.strptime(curDateTimeStr, ChConfig.TYPE_Time_Format)
|
|
GameWorld.Log("===== ¼ÓÔر¾ÈÕϵͳÅÄÆ·ÐÅÏ¢: %s,openServerDay=%s =====" % (curDateTime, openServerDay))
|
addSystemAuctionItemInfo = []
|
ipyDataMgr = IpyGameDataPY.IPY_Data()
|
for index in xrange(ipyDataMgr.GetAuctionSystemItemCount()):
|
ipyData = ipyDataMgr.GetAuctionSystemItemByIndex(index)
|
cfgID = ipyData.GetCfgID()
|
startDateStr = ipyData.GetStartDate()
|
endDateStr = ipyData.GetEndDate()
|
startTimeStr = ipyData.GetStartTime()
|
endTimeStr = ipyData.GetEndTime()
|
auctionCount = ipyData.GetAuctionCount()
|
randMinuteRange = ipyData.GetRandMinuteRange()
|
replenishAuctionCount = ipyData.GetReplenishAuctionCount()
|
|
GameWorld.DebugLog("cfgID=%s,startDateStr=%s,endDateStr=%s,startTimeStr=%s,endTimeStr=%s,auctionCount=%s,randMinuteRange=%s,replenishAuctionCount=%s"
|
% (cfgID, startDateStr, endDateStr, startTimeStr, endTimeStr, auctionCount, randMinuteRange, replenishAuctionCount))
|
|
if not startDateStr:
|
startDateStr = curDateStr
|
elif startDateStr.isdigit():
|
startServerDay = int(startDateStr)
|
openServerDateTime = curDateTime + datetime.timedelta(days=(startServerDay-openServerDay))
|
startDateStr = "%d-%d-%d" % (openServerDateTime.year, openServerDateTime.month, openServerDateTime.day)
|
|
if not endDateStr:
|
endDateStr = curDateStr
|
elif endDateStr.isdigit():
|
endServerDay = int(endDateStr)
|
endServerDateTime = curDateTime + datetime.timedelta(days=(endServerDay-openServerDay))
|
endDateStr = "%d-%d-%d" % (endServerDateTime.year, endServerDateTime.month, endServerDateTime.day)
|
|
startDate = datetime.datetime.strptime("%s 00:00:00" % (startDateStr), ChConfig.TYPE_Time_Format)
|
endDate = datetime.datetime.strptime("%s 23:59:00" % (endDateStr), ChConfig.TYPE_Time_Format)
|
if serverTime < startDate or serverTime > endDate:
|
GameWorld.DebugLog(" ²»ÔÚÉϼÜÈÕÆÚÄÚ£¬²»´¦Àí!")
|
continue
|
|
if not startTimeStr:
|
startTimeStr = "00:00"
|
if not endTimeStr:
|
endTimeStr = "23:59"
|
startDatetime = datetime.datetime.strptime("%s %s:00" % (curDateStr, startTimeStr), ChConfig.TYPE_Time_Format)
|
endDatetime = datetime.datetime.strptime("%s %s:00" % (curDateStr, endTimeStr), ChConfig.TYPE_Time_Format)
|
if serverTime >= endDatetime:
|
GameWorld.DebugLog(" Òѳ¬¹ý½ñÈÕµÄÉϼÜʱ¼ä¶Î£¬²»´¦Àí!")
|
continue
|
if serverTime > startDatetime:
|
startDatetime = curDateTime
|
|
addAuctionItemDatetimeList = []
|
nextAddAuctionItemDatetime = startDatetime
|
for _ in xrange(auctionCount):
|
if len(randMinuteRange) == 2:
|
nextAddMinutes = random.randint(randMinuteRange[0], randMinuteRange[1])
|
elif len(randMinuteRange) == 1:
|
nextAddMinutes = randMinuteRange[0]
|
else:
|
continue
|
nextAddAuctionItemDatetime += datetime.timedelta(minutes=nextAddMinutes)
|
if nextAddAuctionItemDatetime > endDatetime:
|
break
|
GameWorld.DebugLog(" Ìí¼ÓÉϼÜϵͳÅÄƷʱ¼ä: nextAddMinutes=%s %s" % (nextAddMinutes, nextAddAuctionItemDatetime))
|
addAuctionItemDatetimeList.append(nextAddAuctionItemDatetime)
|
|
# ¶¯Ì¬²¹³äÅÄƷģʽ
|
if replenishAuctionCount:
|
GameWorld.DebugLog(" Ìí¼Ó¶¯Ì¬²¹³äϵͳÅÄÆ·¼Æ»®: %s" % replenishAuctionCount)
|
# Ö¸¶¨ÉϼÜÅÄƷģʽ
|
elif addAuctionItemDatetimeList:
|
GameWorld.DebugLog(" Ìí¼ÓÉϼÜϵͳÅÄƷʱ¼ä¼Æ»®: %s" % addAuctionItemDatetimeList)
|
else:
|
continue
|
addSystemAuctionItemInfo.append([cfgID, ipyData, startDatetime, endDatetime, addAuctionItemDatetimeList])
|
|
AuctionSystemItem = IpyGameDataPY.SetConfigEx(key, [reloadSign, addSystemAuctionItemInfo])
|
GameWorld.Log("±¾ÈÕϵͳÅÄÆ·ÐÅÏ¢¼ÓÔØÍê±Ï!reloadSign=%s" % (reloadSign))
|
GameWorld.Log("±¾ÈÕϵͳÅÄÆ·ÉϼÜʱ¼äÐÅÏ¢: %s" % addSystemAuctionItemInfo)
|
GameWorld.Log("=============================================================")
|
return AuctionSystemItem[1]
|
|
def OnAuctionItemMinuteProcess(tick):
|
## ÅÄÂôÐÐÅÄÆ·¶¨Ê±´¦Àí£¬Ã¿Õû·ÖÖÓ´¥·¢Ò»´Î
|
|
# ÕâÀïʱ¼äÐ辫ȷµ½·ÖÖÓ£¬²»È»ºóÃæµÄ±È½Ï»áÆ¥Åä²»µ½
|
curDateTime = GameWorld.GetServerTime()
|
curDateTime = datetime.datetime.strptime("%d-%d-%d %d:%d:00" % (curDateTime.year, curDateTime.month, curDateTime.day,
|
curDateTime.hour, curDateTime.minute), ChConfig.TYPE_Time_Format)
|
|
randMailKey = ""
|
sysAuctionItemListDict = IpyGameDataPY.GetConfigEx("SysWaitAuctionItemListDict") # ϵͳµÈ´ýÉϼܵÄÅÄÆ·Áбí×Öµä {cfgID:[´ýÉϼÜÅÄÆ·Áбí], ...}
|
if not sysAuctionItemListDict:
|
sysAuctionItemListDict = {}
|
|
curTime = int(time.time())
|
addItemTime = curTime
|
openJobList = IpyGameDataPY.GetFuncEvalCfg("OpenJob", 1)
|
auctionItemMgr = PyDataManager.GetAuctionItemManager()
|
curWorldLV = PlayerDBGSEvent.GetDBGSTrig_ByKey(ShareDefine.Def_Notify_WorldKey_WorldAverageLv)
|
addSystemAuctionItemInfo = __GetAuctionSystemItemInfo()
|
for cfgID, ipyData, startDatetime, endDatetime, addAuctionItemDatetimeList in addSystemAuctionItemInfo:
|
#cfgID = ipyData.GetCfgID()
|
if cfgID in sysAuctionItemListDict:
|
#GameWorld.DebugLog(" ¶ÓÁÐÖл¹ÓÐδ´¦ÀíµÄÅÄƷʱ²»´¦Àí£¬·ÀÖ¹Öظ´Ìí¼Ó£¡cfgID=%s" % (cfgID))
|
continue
|
worldLVRange = ipyData.GetWorldLVRange()
|
if worldLVRange and len(worldLVRange) == 2:
|
worldLVMin, worldLVMax = worldLVRange
|
if curWorldLV < worldLVMin or curWorldLV > worldLVMax:
|
#GameWorld.DebugLog(" ²»Âú×㵱ǰÊÀ½çµÈ¼¶·¶Î§Ìõ¼þ£¬²»´¦Àí¸ÃϵͳÉϼÜÅÄÆ·¼Æ»®£¡cfgID=%s,curWorldLV=%s" % (cfgID, curWorldLV))
|
continue
|
|
if curDateTime < startDatetime or curDateTime > endDatetime:
|
#GameWorld.DebugLog(" ²»Ôڹ涨µÄʱ¼äÄÚ£¬²»´¦Àí¸ÃϵͳÉϼÜÅÄÆ·¼Æ»®£¡cfgID=%s" % (cfgID))
|
continue
|
|
randSecondRange = ipyData.GetAddRandSecondRange()
|
if len(randSecondRange) != 2:
|
#GameWorld.DebugLog(" Ëæ»úÉϼÜÃëÊý¸ñʽ´íÎ󣬲»´¦Àí¸ÃϵͳÉϼÜÅÄÆ·¼Æ»®£¡cfgID=%s" % (cfgID))
|
continue
|
|
addItemInfoList = []
|
replenishAuctionCount = ipyData.GetReplenishAuctionCount()
|
# ¶¯Ì¬Ä£Ê½
|
if replenishAuctionCount:
|
replenishCDSeconds = ipyData.GetReplenishCDMinutes() * 60
|
lastReplenishTime = auctionItemMgr.worldAuctionReplenishTimeDict.get(cfgID, 0)
|
if curTime - lastReplenishTime < replenishCDSeconds:
|
continue
|
auctionItemMgr.worldAuctionReplenishTimeDict[cfgID] = curTime
|
|
replenishItemID = ipyData.GetReplenishItemID()
|
if replenishItemID:
|
curItemIDCount = auctionItemMgr.worldAuctionItemCountDict.get(replenishItemID, 0)
|
if curItemIDCount >= replenishAuctionCount:
|
continue
|
addItemIDCount = replenishAuctionCount - curItemIDCount
|
GameWorld.DebugLog(" ¶¯Ì¬²¹³äÅÄÆ·¶ÓÁÐ: cfgID=%s,replenishItemID=%s,addItemIDCount=%s" % (cfgID, replenishItemID, addItemIDCount))
|
for _ in xrange(addItemIDCount):
|
addItemInfoList.append(replenishItemID)
|
else:
|
replenishEquipPlaces = ipyData.GetReplenishEquipPlaces()
|
rpClassLV, rpColor, rpIsSuit = ipyData.GetReplenishEquipInfo()
|
rpStar = 0
|
for job in openJobList:
|
jobEquipKey = (job, rpClassLV, rpColor, rpIsSuit)
|
curJobEquipCount = auctionItemMgr.worldAuctionJobEquipCountDict.get(jobEquipKey, 0)
|
if curJobEquipCount >= replenishAuctionCount:
|
continue
|
addEquipCount = replenishAuctionCount - curJobEquipCount
|
GameWorld.DebugLog(" ¶¯Ì¬²¹³äÅÄÆ·¶ÓÁÐ: cfgID=%s,addEquipCount=%s,job=%s" % (cfgID, addEquipCount, job))
|
for _ in xrange(addEquipCount):
|
addItemInfoList.append([rpClassLV, rpColor, replenishEquipPlaces, rpIsSuit, rpStar, [job]])
|
|
random.shuffle(addItemInfoList) # ¶¯Ì¬Ä£Ê½´ýÌí¼ÓÅÄÆ·´òÂÒÏÂ˳Ðò£¬·ÀÖ¹ÅúÁ¿Ìí¼ÓͬһְҵÎïÆ·
|
|
# Ö¸¶¨Ä£Ê½
|
elif curDateTime in addAuctionItemDatetimeList:
|
|
addCountWeightList = ipyData.GetItemCountWeightList()
|
auctionItemWeightList = ipyData.GetAuctionItemWeightList()
|
|
addCount = GameWorld.GetResultByWeightList(addCountWeightList)
|
GameWorld.DebugLog(" Ö¸¶¨²¹³äÅÄÆ·¶ÓÁÐ: cfgID=%s,addCount=%s" % (cfgID, addCount))
|
for _ in xrange(addCount):
|
itemInfo = GameWorld.GetResultByWeightList(auctionItemWeightList)
|
if itemInfo != None:
|
addItemInfoList.append(itemInfo)
|
|
randMailKeyList = ipyData.GetRandMailKeyList()
|
if randMailKeyList:
|
randMailKey = random.choice(randMailKeyList)
|
|
sysWaitAuctionItemList = []
|
for itemInfo in addItemInfoList:
|
randSeconds = random.randint(randSecondRange[0], randSecondRange[1])
|
addItemTime = addItemTime + randSeconds
|
sysWaitAuctionItemList.append([addItemTime, itemInfo])
|
sysAuctionItemListDict[cfgID] = sysWaitAuctionItemList
|
|
IpyGameDataPY.SetConfigEx("SysWaitAuctionItemListDict", sysAuctionItemListDict)
|
#GameWorld.DebugLog("µÈ´ýϵͳÉϼܵÄÅÄÆ·Áбí: %s" % sysAuctionItemListDict)
|
|
# Ëæ»úÓʼþ֪ͨ
|
if randMailKey:
|
playerIDList = []
|
addItemList = []
|
playerManager = GameWorld.GetPlayerManager()
|
for i in xrange(playerManager.GetActivePlayerCount()):
|
player = playerManager.GetActivePlayerAt(i)
|
if player == None:
|
continue
|
if PlayerControl.GetIsTJG(player):
|
continue
|
playerIDList.append(player.GetPlayerID())
|
PlayerCompensation.SendMailByKey(randMailKey, playerIDList, addItemList)
|
|
return
|
|
def __DoSysWaitAddAuctionItem(tick):
|
SysWaitAuctionItemListDict = IpyGameDataPY.GetConfigEx("SysWaitAuctionItemListDict") # ϵͳµÈ´ýÉϼܵÄÅÄÆ·Áбí
|
if not SysWaitAuctionItemListDict:
|
return
|
|
curTime = int(time.time())
|
for cfgID, sysAuctionItemList in SysWaitAuctionItemListDict.items():
|
doCount = len(sysAuctionItemList)
|
while doCount > 0 and sysAuctionItemList:
|
doCount -= 1
|
addItemTime, itemInfo = sysAuctionItemList[0]
|
if curTime < addItemTime:
|
#GameWorld.DebugLog("δµ½ÏµÍ³µÈ´ýÉϼܵÄÅÄƷʱ¼ä£¬²»´¦Àí! curTime=%s,sysAuctionItemList=%s" % (curTime, sysAuctionItemList))
|
break
|
sysAuctionItemList.pop(0)
|
GameWorld.DebugLog("ϵͳµÈ´ýÉϼܵÄÅÄƷʱ¼äÒѵ½£¬¿ÉÉϼÜ! curTime=%s >= addItemTime=%s,itemInfo=%s,sysAuctionItemList=%s" % (curTime, addItemTime, itemInfo, sysAuctionItemList))
|
DoAddSystemAuctionItem([itemInfo])
|
|
if not sysAuctionItemList:
|
SysWaitAuctionItemListDict.pop(cfgID)
|
|
return
|
|
def OnAuctionItemTimeProcess(curTime, tick):
|
## ÅÄÂôÐÐÅÄÆ·¶¨Ê±´¦Àí£¬Ã¿Ãë´¥·¢Ò»´Î
|
|
__DoSysBuyoutItemByTime(curTime)
|
|
__DoSysWaitAddAuctionItem(tick)
|
|
allAuctionItemByEndTimeList = PyDataManager.GetAuctionItemManager().allAuctionItemByEndTimeList
|
if not allAuctionItemByEndTimeList:
|
return
|
|
index = 0
|
endItemList = [] # ½áÊø¾º¼ÛµÄÅÄÆ·Áбí
|
moveToWorldItemList = [] # תÒƵ½È«·þÅÄÂôµÄÏÉÃËÅÄÆ·Áбí
|
doCount = len(allAuctionItemByEndTimeList)
|
while doCount > 0 and allAuctionItemByEndTimeList:
|
doCount -= 1
|
auctionItem = allAuctionItemByEndTimeList[index]
|
if curTime <= auctionItem.EndTime:
|
break
|
if auctionItem.BiddingQueryTick and tick - auctionItem.BiddingQueryTick < BiddingQueryLockTick:
|
index += 1
|
continue
|
allAuctionItemByEndTimeList.pop(index)
|
|
# ûÓÐÈ˾º¼ÛµÄÏÉÃËÅÄÆ·
|
if not auctionItem.BidderPrice and auctionItem.FamilyID and auctionItem.AuctionType == AuctionType_Family:
|
moveToWorldItemList.append(auctionItem)
|
else:
|
endItemList.append(auctionItem)
|
|
__EndAuctionItem(endItemList, "ByTime")
|
__MoveFamilyAuctionItemToWorld(moveToWorldItemList)
|
return
|
|
def __DoSysBuyoutItemByTime(curTime):
|
## ϵͳһ¿Ú¼ÛÅÄÆ·
|
|
sysBuyoutItemByTimeList = PyDataManager.GetAuctionItemManager().sysBuyoutItemByTimeList
|
if not sysBuyoutItemByTimeList:
|
return
|
|
sysAuctionItemList = []
|
color = 4 # ¹Ì¶¨³ÈÉ«
|
isSuit = 0 # ¹Ì¶¨·ÇÌ××°
|
star = 0 # ¹Ì¶¨0ÐÇ
|
|
endItemList = [] # ½áÊø¾º¼ÛµÄÅÄÆ·Áбí
|
doCount = len(sysBuyoutItemByTimeList)
|
while doCount > 0 and sysBuyoutItemByTimeList:
|
doCount -= 1
|
auctionItem = sysBuyoutItemByTimeList[0]
|
if curTime <= auctionItem.SysBuyTime:
|
break
|
sysBuyoutItemByTimeList.pop(0)
|
|
if auctionItem.BidderPrice or auctionItem.BidderID:
|
continue
|
|
classLV = auctionItem.ItemClassLV
|
if not classLV:
|
continue
|
|
itemID = auctionItem.ItemID
|
ipyData = IpyGameDataPY.GetIpyGameData("AuctionItem", itemID)
|
if not ipyData:
|
continue
|
buyoutPrice = ipyData.GetBuyoutPrice()
|
if not buyoutPrice:
|
continue
|
|
buyoutPrice *= auctionItem.Count
|
auctionItem.BidderPrice = buyoutPrice # ûÈ˾º¼ÛµÄϵͳֱ½ÓÒ»¿Ú¼Û»ØÊÕ
|
endItemList.append(auctionItem)
|
|
# Éú³Éϵͳ²¹ÉϼܵÄ×°±¸ÐÅÏ¢
|
randPlaceList = IpyGameDataPY.GetFuncEvalCfg("AuctionItemSystem", 4)
|
if not randPlaceList:
|
curPlace = itemID % 1000 / 10 # µ¹Êý2¡¢3λ´ú±í²¿Î»
|
placeList = [curPlace]
|
else:
|
placeList = randPlaceList
|
|
totalPlayerCount = 0
|
jobWeightList = []
|
openJobList = IpyGameDataPY.GetFuncEvalCfg("OpenJob", 1)
|
for job in openJobList:
|
jobPlayerCount = len(PyGameData.g_onedayJobPlayerLoginoffTimeDict.get(job, {}))
|
jobPlayerCount = max(1, jobPlayerCount) # ÈËÊýĬÈÏÖÁÉÙ1¸ö
|
totalPlayerCount += jobPlayerCount
|
jobWeightList.append([jobPlayerCount, job])
|
GameWorld.DebugLog("Ö°ÒµÈËÊý: job=%s,count=%s" % (job, jobPlayerCount))
|
|
maxJobPer = IpyGameDataPY.GetFuncCfg("AuctionItemSystem", 3) # µ¥Ö°Òµ×î´ó°Ù·Ö±È
|
if maxJobPer and maxJobPer < 100 and totalPlayerCount:
|
minJobPer = 100 - maxJobPer # µ¥Ö°ÒµÖÁÉٰٷֱÈ
|
for jobWeightInfo in jobWeightList:
|
jobPlayerCount = jobWeightInfo[0]
|
jobPer = int(jobPlayerCount * 100.0 / totalPlayerCount)
|
jobPer = min(max(minJobPer, jobPer), maxJobPer)
|
jobWeightInfo[0] = jobPer
|
GameWorld.DebugLog("Ëæ»úÉϼÜÖ°Òµ×°±¸±ÈÖØ: jobWeightList=%s" % jobWeightList)
|
job = GameWorld.GetResultByWeightList(jobWeightList)
|
itemJobList = [job] if job != None else openJobList
|
sysAuctionItemList.append([classLV, color, placeList, isSuit, star, itemJobList])
|
|
if not endItemList:
|
return
|
|
__EndAuctionItem(endItemList, "SysBuyout")
|
|
# ϵͳ»ØÊÕÅÄÆ·ºóÁ¢¼´°´¹æÔò²¹ÉϼÜÅÄÆ·
|
if sysAuctionItemList:
|
DoAddSystemAuctionItem(sysAuctionItemList)
|
|
return
|
|
|
def __MoveFamilyAuctionItemToWorld(auctionItemList):
|
## ÏÉÃËÅÄƷתÒƵ½È«·þ
|
if not auctionItemList:
|
return
|
|
curTimeStr = GameWorld.GetCurrentDataTimeStr()
|
attentionMgr = PyDataManager.GetAuctionAttentionManager()
|
auctionItemMgr = PyDataManager.GetAuctionItemManager()
|
notifyWorldAddItemList = [] # ÐÂÔöÈ«·þÅÄƷ֪ͨ [[itemGUID, itemID, playerID], ...]
|
|
for auctionItem in auctionItemList:
|
itemGUID = auctionItem.ItemGUID
|
itemID = auctionItem.ItemID
|
itemCount = auctionItem.Count
|
playerID = auctionItem.PlayerID
|
familyID = auctionItem.FamilyID
|
|
ipyData = IpyGameDataPY.GetIpyGameData("AuctionItem", itemID)
|
auctionItem.AuctionType = AuctionType_World
|
auctionItem.AddTime = curTimeStr
|
__SetAuctionItemEndTime(auctionItem, ipyData)
|
|
auctionItemMgr.allAuctionItemByEndTimeList.append(auctionItem)
|
auctionItemMgr.worldAuctionItemList.append(auctionItem)
|
__OnCalcWorldAuctionItemCount(auctionItem, 1)
|
notifyWorldAddItemList.append([itemGUID, itemID, playerID])
|
|
AddAuctionRecord(auctionItem, AuctionRecordResult_MoveToWorld)
|
|
# Ìí¼Ó½øÎҵĹØ×¢
|
for attentionPlayerID, attentionList in auctionItemMgr.myAttentionItemDict.items():
|
if itemID not in GetPlayerAuctionAttention(attentionMgr, attentionPlayerID):
|
continue
|
if auctionItem not in attentionList:
|
attentionList.append(auctionItem)
|
|
if ipyData.GetNeedWorldNotify():
|
PlayerControl.WorldNotify(0, "Paimai4", [itemID, ipyData.GetNoticeSaleMinutes()])
|
|
drDict = {"AuctionItemInfo":__GetAuctionItemDRDict(auctionItem)}
|
DR_AuctionHouse(None, "FamilyToWorld", drDict)
|
|
GameWorld.DebugLog("ÏÉÃËÅÄƷתÒƵ½È«·þ: itemID=%s,itemCount=%s,familyID=%s,itemGUID=%s"
|
% (itemID, itemCount, familyID, itemGUID))
|
|
__SortAuctionitem()
|
__SyncRefreshAuctionItem(auctionItemList)
|
__NotifyAuctionPlayerAddItem(notifyWorldAddItemList)
|
return
|
|
def __SortAuctionitem(isSortWorldItem=True):
|
''' Ë¢ÐÂÈ«²¿ÅÄÆ·ÅÅÐò
|
ºó¶ËÅÅÐò
|
1.È«·þÅÄÆ·£º ÒòΪȫ·þÅÄÆ·ÊýÁ¿±È½Ï´ó£¬²ÉÓÃÖ»²éѯָ¶¨¸öÊýÅÄÆ·£¬ËùÒÔÖ»ÄÜÓɺó¶ËÅÅÐòºóͬ²½
|
2.È«²¿ÅÄÆ·¾º¼Û½áÊøʱ¼ä£ººó¶ËÐèÒª´¦Àí¾º¼Û½áÊø
|
|
Ç°¶ËÅÅÐò£º
|
1.¸öÈËÅÄÆ·£º¸öÊý½ÏÉÙ£¬È«²¿Í¬²½£¬ÓÉÇ°¶Ë×Ô¼ºÅÅÐò
|
2.ÏÉÃËÅÄÆ·£º¸öÊý½ÏÉÙ£¬È«²¿Í¬²½£¬ÓÉÇ°¶Ë×Ô¼ºÅÅÐò
|
3.¾º¼ÛÅÄÆ·£º¸öÊý½ÏÉÙ£¬È«²¿Í¬²½£¬ÓÉÇ°¶Ë×Ô¼ºÕûºÏÅÅÐò£¬Çø·Ö×î¸ß¾º¼Û¡¢ÀúÊ·¾º¼Û
|
4.¹Ø×¢ÅÄÆ·£º¸öÊý½ÏÉÙ£¬È«²¿Í¬²½£¬ÓÉÇ°¶Ë×Ô¼ºÅÅÐò
|
|
´¥·¢ÅÅÐòʱ»ú£º
|
1-ÉϼÜÐÂÈ«·þÅÄÆ·
|
2-ÏÉÃËÅÄƷתÒÆÈ«·þÅÄÆ·£¬Ï൱ÓÚÉϼÜÐÂÈ«·þÅÄÆ·
|
3-¾º¼ÛÅÄÆ·´¥·¢¼Óʱʱ£¬ÐèÒª¶Ô½áÊøʱ¼äÖØÅÅ£¬¾º¼Û¼ÓʱµÄÖ»´¥·¢¼Óʱ£¬¶ÔÈ«·þÅÄÆ·µÄÅÅÐòûÓÐÓ°Ï죬¹Ê¿É²»ÖØÅÄÈ«·þÅÄÆ·
|
'''
|
auctionItemMgr = PyDataManager.GetAuctionItemManager()
|
auctionItemMgr.allAuctionItemByEndTimeList.sort(key=operator.attrgetter("EndTime"))
|
if isSortWorldItem:
|
auctionItemMgr.worldAuctionItemList.sort(key=operator.attrgetter("Sortpriority", "AddTime"))
|
auctionItemMgr.worldAuctionItemQueryDict = {} # ÖØÖÃÈ«·þÅÄÆ·Ìõ¼þ²éѯ£¬Ï´ÎÓÐÍæ¼Ò²éѯʱÔÙÖØÐÂË¢ÐÂ
|
auctionItemMgr.sysBuyoutItemByTimeList.sort(key=operator.attrgetter("SysBuyTime"))
|
return
|
|
def __EndAuctionItem(endItemList, endEvent, funcAutoBuyout=False, buyPlayer=None):
|
''' ½áÊøÅÄÆ·¾ºÅÄ
|
@param delItemStateDict: ɾ³ýµÄÅÄÆ·¾ºÅÄ״̬
|
'''
|
if not endItemList:
|
return 0
|
|
auctionItemMgr = PyDataManager.GetAuctionItemManager()
|
clearAuctionItemList = []
|
for auctionItem in endItemList:
|
if not auctionItem:
|
continue
|
|
itemGUID = auctionItem.ItemGUID
|
itemID = auctionItem.ItemID
|
itemCount = auctionItem.Count
|
playerID = auctionItem.PlayerID
|
familyID = auctionItem.FamilyID
|
bidderID = auctionItem.BidderID # µ±Ç°¾º¼ÛÍæ¼ÒID
|
bidderPrice = auctionItem.BidderPrice # µ±Ç°¾º¼Û£¬ÓÐÈ˾º¼ÛµÄ»°´ú±í¾ºÅijɹ¦
|
endType = ""
|
# ÓÐÈ˾º¼Û£¬³É½»
|
if bidderPrice:
|
endType = "OK"
|
|
# ¾ºÅijɹ¦Óʼþ£¬·¢·ÅÎïÆ·
|
if bidderID:
|
mailTypeKey = "PaimaiMail3"
|
paramList = [bidderPrice]
|
detail = {"ItemGUID":itemGUID}
|
addItemList = [{"ItemID":itemID, "Count":itemCount, "IsAuctionItem":False, "UserData":auctionItem.UserData}]
|
if funcAutoBuyout:
|
# ¹¦ÄÜ×Ô¶¯¹ºÂòµÄ²»¸øÎïÆ·£¬Óɹ¦Äܸù¾Ý¹¦ÄÜÐèÇó´¦Àí
|
pass
|
## Èç¹ûÓÐÍæ¼ÒµÄ£¬Ö±½Ó¸øµ½±³°ü
|
elif buyPlayer and buyPlayer.GetPlayerID() == bidderID:
|
mailInfo = [mailTypeKey, addItemList, paramList, detail]
|
resultMsg = str([itemGUID, itemID, itemCount, auctionItem.UserData, mailInfo])
|
buyPlayer.MapServer_QueryPlayerResult(0, 0, "AuctionHouseGiveItem", resultMsg, len(resultMsg))
|
else:
|
PlayerCompensation.SendMailByKey(mailTypeKey, [bidderID], addItemList, paramList, detail=detail)
|
AddAuctionRecord(auctionItem, AuctionRecordResult_BidOK)
|
|
# ÅÄÂô³É¹¦ÊÕÒ棬¶¼ÒÔÍæ¼ÒÊÕÒæÏòÉÏÈ¡Õû
|
if familyID and auctionItem.FamilyPlayerIDInfo:
|
familyPlayerIDList = json.loads(auctionItem.FamilyPlayerIDInfo)
|
if familyPlayerIDList:
|
taxRate = IpyGameDataPY.GetFuncCfg("AuctionTaxrate", 2) # ÏÉÃËÅÄÆ·Ë°ÂÊ°Ù·Ö±È
|
personMaxRate = IpyGameDataPY.GetFuncCfg("AuctionTaxrate", 3) # ÏÉÃËÅÄÆ·¸öÈË×î´óÊÕÒæ°Ù·Ö±È
|
taxGold = max(1, int(bidderPrice * taxRate / 100.0)) # ×îÉÙÊÕË°1
|
giveTotalGold = max(0, bidderPrice - taxGold)
|
giveMaxGold = int(math.ceil(giveTotalGold * personMaxRate / 100.0))
|
memCount = len(familyPlayerIDList)
|
giveGoldAverage = min(giveMaxGold, int(math.ceil(giveTotalGold * 1.0 / memCount))) # ÓÐÊÕÒæµÄÈËƽ·Ö
|
|
# ÏÉÃËÅÄÆ·ÊÕÒæÓʼþ
|
detail = {"ItemGUID":itemGUID, "ItemID":itemID, "Count":itemCount, "BidderPrice":bidderPrice, "FamilyPlayerIDList":familyPlayerIDList}
|
paramList = [itemID, itemID, bidderPrice, taxRate, giveGoldAverage, personMaxRate]
|
PlayerCompensation.SendMailByKey("PaimaiMail8", familyPlayerIDList, [], paramList, goldPaper=giveGoldAverage,
|
detail=detail, moneySource=ChConfig.Def_GiveMoney_AuctionGain)
|
else:
|
GameWorld.ErrLog("ÏÉÃËÅÄƷûÓÐÈË»ñµÃÊÕÒæ!familyID=%s,itemID=%s,itemGUID=%s" % (familyID, itemID, itemGUID))
|
|
elif playerID:
|
taxRate = IpyGameDataPY.GetFuncCfg("AuctionTaxrate", 1) # È«·þÅÄÆ·Ë°ÂÊ°Ù·Ö±È
|
taxGold = max(1, int(bidderPrice * taxRate / 100.0)) # ×îÉÙÊÕË°1
|
givePlayerGold = max(0, bidderPrice - taxGold)
|
|
# ¸öÈËÅÄÂôÊÕÒæÓʼþ
|
detail = {"ItemGUID":itemGUID, "ItemID":itemID, "Count":itemCount, "BidderPrice":bidderPrice}
|
paramList = [itemID, itemID, bidderPrice, taxRate, givePlayerGold]
|
PlayerCompensation.SendMailByKey("PaimaiMail7", [playerID], [], paramList, goldPaper=givePlayerGold,
|
detail=detail, moneySource=ChConfig.Def_GiveMoney_AuctionGain)
|
|
else:
|
GameWorld.Log("ϵͳÅÄÆ·³É½»: itemGUID=%s,itemID=%s" % (itemGUID, itemID))
|
|
AddAuctionRecord(auctionItem, AuctionRecordResult_SellOK)
|
|
#²ß»®ÐèÇóÆÁ±Îµô³É½»¹ã²¥
|
#ipyData = IpyGameDataPY.GetIpyGameData("AuctionItem", itemID)
|
#if ipyData and ipyData.GetNeedWorldNotify():
|
# PlayerControl.WorldNotify(0, "Paimai6", [auctionItem.BidderName, bidderID, auctionItem.AuctionType, bidderPrice, itemID])
|
else:
|
# ÏÉÃËÅÄÆ·»ØÊÕ
|
if familyID:
|
endType = "Recycle"
|
AddAuctionRecord(auctionItem, AuctionRecordResult_Recycle)
|
# ¸öÈËÅÄÆ·Á÷ÅÄ£¬ÎïÆ··µ»¹
|
elif playerID:
|
endType = "Return"
|
|
# ·µ»¹ÎïÆ·Óʼþ
|
paramList = []
|
detail = {"ItemGUID":itemGUID}
|
addItemList = [{"ItemID":itemID, "Count":itemCount, "IsAuctionItem":True, "UserData":auctionItem.UserData}]
|
# ϼÜ
|
if endEvent == "Unsell":
|
PlayerCompensation.SendMailByKey("PaimaiMail9", [playerID], addItemList, paramList, detail=detail)
|
AddAuctionRecord(auctionItem, AuctionRecordResult_Unsell)
|
else:
|
PlayerCompensation.SendMailByKey("PaimaiMail4", [playerID], addItemList, paramList, detail=detail)
|
AddAuctionRecord(auctionItem, AuctionRecordResult_SellFail)
|
else:
|
endType = "SystemDelete"
|
GameWorld.Log("ϵͳÅÄÆ·Á÷ÅÄ: itemGUID=%s,itemID=%s" % (itemGUID, itemID))
|
|
drDict = {"AuctionItemInfo":__GetAuctionItemDRDict(auctionItem), "EndType":endType, "EndEvent":endEvent}
|
DR_AuctionHouse(None, "EndAuctionItem", drDict)
|
|
GameWorld.DebugLog("½áÊø¾ºÅÄ: itemID=%s,itemCount=%s,familyID=%s,endType=%s,endEvent=%s,itemGUID=%s"
|
% (itemID, itemCount, familyID, endType, endEvent, itemGUID), playerID)
|
|
auctionItemMgr.allAuctionItemDict.pop(itemGUID, None)
|
|
if auctionItem in auctionItemMgr.allAuctionItemByEndTimeList:
|
auctionItemMgr.allAuctionItemByEndTimeList.remove(auctionItem)
|
|
if auctionItem in auctionItemMgr.worldAuctionItemList:
|
auctionItemMgr.worldAuctionItemList.remove(auctionItem)
|
__OnCalcWorldAuctionItemCount(auctionItem, -1)
|
|
for queryItemList in auctionItemMgr.worldAuctionItemQueryDict.values():
|
if auctionItem in queryItemList:
|
queryItemList.remove(auctionItem)
|
|
if familyID and familyID in auctionItemMgr.familyAuctionItemDict:
|
familyItemList = auctionItemMgr.familyAuctionItemDict[familyID]
|
if auctionItem in familyItemList:
|
familyItemList.remove(auctionItem)
|
|
if auctionItem in auctionItemMgr.sysBuyoutItemByTimeList:
|
auctionItemMgr.sysBuyoutItemByTimeList.remove(auctionItem)
|
|
for nowBiddingItemList in auctionItemMgr.nowBiddingAuctionItemDict.values():
|
if auctionItem in nowBiddingItemList:
|
nowBiddingItemList.remove(auctionItem)
|
|
for hisBiddingItemList in auctionItemMgr.hisBiddingAuctionItemDict.values():
|
if auctionItem in hisBiddingItemList:
|
hisBiddingItemList.remove(auctionItem)
|
|
if playerID and playerID in auctionItemMgr.myAuctionItemDict:
|
playerItemList = auctionItemMgr.myAuctionItemDict[playerID]
|
if auctionItem in playerItemList:
|
playerItemList.remove(auctionItem)
|
|
for attentionItemList in auctionItemMgr.myAttentionItemDict.values():
|
if auctionItem in attentionItemList:
|
attentionItemList.remove(auctionItem)
|
|
clearItem = ChPyNetSendPack.tagGCClearAuctionItem()
|
clearItem.ItemGUID = itemGUID
|
clearAuctionItemList.append(clearItem)
|
|
if not clearAuctionItemList:
|
return 0
|
clearCount = len(clearAuctionItemList)
|
|
clientPack = ChPyNetSendPack.tagGCClearAuctionItemInfo()
|
clientPack.ClearAuctionItemList = clearAuctionItemList
|
clientPack.ClearCount = len(clientPack.ClearAuctionItemList)
|
|
playerManager = GameWorld.GetPlayerManager()
|
for i in xrange(playerManager.GetActivePlayerCount()):
|
player = playerManager.GetActivePlayerAt(i)
|
if player == None:
|
continue
|
if PlayerControl.GetIsTJG(player):
|
continue
|
NetPackCommon.SendFakePack(player, clientPack)
|
|
return clearCount
|
|
def MapServer_AuctionHouseLogic(curPlayer, msgList, tick):
|
## µØͼÍæ¼ÒÅÄÂô´¦Àí
|
|
playerID = 0 if not curPlayer else curPlayer.GetPlayerID()
|
queryType, queryData = msgList
|
result = []
|
|
GameWorld.Log("ÊÕµ½µØͼÅÄÂôÐÐÐÅÏ¢: queryType=%s,queryData=%s" % (queryType, queryData), playerID)
|
if not GetAuctionHouseState():
|
if curPlayer:
|
PlayerControl.NotifyCode(curPlayer, "AuctionHouseClose")
|
return
|
|
# ²éѯÍæ¼Ò¿É·ñÉϼÜ
|
if queryType == "AddAuctionItemQuery":
|
canSell = __CheckPlayerCanAddAuctionItem(curPlayer)
|
if not canSell:
|
return
|
result = [canSell]
|
|
# Ö´ÐÐÉϼÜÎïÆ·
|
elif queryType == "AddAuctionItem":
|
addAuctionItemList = queryData
|
__AddAuctionItemByList(curPlayer, addAuctionItemList)
|
return
|
|
# ²éѯÍæ¼Ò¿É·ñ¾º¼ÛÎïÆ·
|
elif queryType == "BidAuctionItemQuery":
|
itemGUID, biddingPrice = queryData
|
itemID, errInfo = __DoPlayerBidAuctionItem(curPlayer, itemGUID, biddingPrice, tick, True)
|
GameWorld.DebugLog(" itemID=%s,errInfo=%s" % (itemID, errInfo), playerID)
|
if errInfo:
|
return
|
if not itemID:
|
return
|
result = [itemID]
|
|
# Ö´ÐÐÍæ¼Ò¾º¼ÛÎïÆ·
|
elif queryType == "BidAuctionItem":
|
itemGUID, biddingPrice = queryData
|
itemID, errInfo = __DoPlayerBidAuctionItem(curPlayer, itemGUID, biddingPrice, tick, False)
|
if errInfo:
|
GameWorld.DebugLog(" errInfo=%s" % errInfo, playerID)
|
drDict = {"ItemGUID":itemGUID, "BiddingPrice":biddingPrice, "ErrInfo":errInfo}
|
DR_AuctionHouse(curPlayer, "BidAuctionItemError", drDict)
|
|
return
|
|
# ϼÜÅÄÆ·
|
elif queryType == "UnsellAuctionItem":
|
itemGUID = queryData[0]
|
__DoUnsellAuctionItem(curPlayer, itemGUID)
|
return
|
|
# ÉýÐÇ×Ô¶¯¹ºÂò
|
elif queryType == "EquipStarAutoBuy":
|
buyResult = __DoEquipStarAutoBuyEquip(curPlayer, queryData, tick)
|
if buyResult == None:
|
return
|
result = buyResult
|
|
elif queryType == "ClearAuctionItem":
|
__DoGMClearAuctionItem(curPlayer)
|
return
|
|
elif queryType == "PrintAuctionItem":
|
__DoGMPrintAuctionItem(curPlayer)
|
return
|
|
resultMsg = str([queryType, queryData, result])
|
if curPlayer:
|
curPlayer.MapServer_QueryPlayerResult(0, 0, "AuctionHouse", resultMsg, len(resultMsg))
|
return
|
|
def __CheckPlayerCanAddAuctionItem(curPlayer):
|
## ¼ì²éÍæ¼Ò¿É·ñÉϼÜÅÄÆ·
|
playerID = curPlayer.GetPlayerID()
|
maxSellCount = IpyGameDataPY.GetFuncCfg("AuctionHouse", 2)
|
if maxSellCount:
|
playerAuctionItemList = GetPlayerAuctionItemList(playerID)
|
playerSellCount = len(playerAuctionItemList)
|
canSell = playerSellCount < maxSellCount
|
if not canSell:
|
PlayerControl.NotifyCode(curPlayer, "SellCountLimit")
|
return canSell
|
return True
|
|
def __AddAuctionItemByList(curPlayer, addAuctionItemList):
|
''' ÅúÁ¿Ìí¼ÓÅÄÆ·
|
@param curPlayer: ¿ÉÄÜΪNone
|
'''
|
|
isSortWorldItem = False
|
notifyAddItemList = [] # ÐÂÔöÅÄƷ֪ͨ [[itemGUID, itemID, playerID], ...]
|
notifyFamilyAddItemDict = {} # ÐÂÔöÏÉÃËÅÄƷ֪ͨ {familyID:[auctionItem, ...], ...}
|
for playerID, familyID, familyPlayerIDList, itemData in addAuctionItemList:
|
#ϵͳÅÄÆ·Íæ¼ÒID¡¢ÏÉÃËID¶¼Îª0£¬¿ÉÉϼܣ¬ÕâÀï²»ÔÙÏÞÖÆ
|
#if not playerID and not familyID:
|
# continue
|
|
auctionItem = __DoAddAuctionItem(curPlayer, playerID, familyID, familyPlayerIDList, itemData)
|
if not auctionItem:
|
continue
|
|
itemGUID = auctionItem.ItemGUID
|
itemID = auctionItem.ItemID
|
notifyAddItemList.append([itemGUID, itemID, playerID])
|
if familyID:
|
familyAddItemList = notifyFamilyAddItemDict.get(familyID, [])
|
familyAddItemList.append(auctionItem)
|
notifyFamilyAddItemDict[familyID] = familyAddItemList
|
else:
|
isSortWorldItem = True
|
|
if notifyAddItemList:
|
__SortAuctionitem(isSortWorldItem=isSortWorldItem)
|
|
# ֪ͨÐÂÔöÏÉÃËÅÄÆ·
|
for familyID, familyAddItemList in notifyFamilyAddItemDict.items():
|
Sync_FamilyAuctionItemInfo(None, familyID, familyAddItemList)
|
|
# ֪ͨÅÄÆ·¹Ø×¢Íæ¼Ò
|
__NotifyAuctionPlayerAddItem(notifyAddItemList)
|
return
|
|
def __DoAddAuctionItem(curPlayer, playerID, familyID, familyPlayerIDList, itemData):
|
## Ìí¼ÓÅÄÆ·
|
itemID = itemData.get("ItemID", 0)
|
ipyData = IpyGameDataPY.GetIpyGameData("AuctionItem", itemID)
|
if not ipyData:
|
return
|
|
itemGUID = itemData.get("GUID", "")
|
auctionItem = PyGameDataStruct.tagDBAuctionItem()
|
auctionItem.ItemGUID = itemGUID
|
auctionItem.PlayerID = playerID
|
auctionItem.FamilyID = familyID
|
auctionItem.ItemID = itemID
|
auctionItem.Count = itemData.get("ItemCount", 0)
|
auctionItem.AddTime = GameWorld.GetCurrentDataTimeStr()
|
auctionItem.ItemType = itemData.get("ItemType", 0)
|
auctionItem.ItemJobLimit = itemData.get("ItemJobLimit", 0)
|
auctionItem.ItemClassLV = itemData.get("ItemClassLV", 0)
|
auctionItem.UserData = itemData.get("UserData", "")
|
auctionItem.UserDataLen = len(auctionItem.UserData)
|
auctionItem.FamilyPlayerIDInfo = str(familyPlayerIDList)
|
auctionItem.FamilyPlayerIDLen = len(auctionItem.FamilyPlayerIDInfo)
|
auctionItem.AuctionType = AuctionType_Family if familyID else AuctionType_World
|
GameWorld.Log("ÉϼÜÅÄÆ·: playerID=%s,familyID=%s,itemID=%s,auctionType=%s" % (playerID, familyID, itemID, auctionItem.AuctionType))
|
|
if not __InitAuctionItemAttrEx(auctionItem):
|
return
|
|
auctionItemMgr = PyDataManager.GetAuctionItemManager()
|
auctionItemMgr.allAuctionItemDict[auctionItem.ItemGUID] = auctionItem
|
auctionItemMgr.allAuctionItemByEndTimeList.append(auctionItem)
|
|
if familyID:
|
familyItemList = auctionItemMgr.familyAuctionItemDict.get(familyID, [])
|
familyItemList.append(auctionItem)
|
auctionItemMgr.familyAuctionItemDict[familyID] = familyItemList
|
else:
|
auctionItemMgr.worldAuctionItemList.append(auctionItem)
|
__OnCalcWorldAuctionItemCount(auctionItem, 1)
|
|
# Ìí¼Ó½øÎÒµÄÅÄÂô
|
if playerID:
|
myAuctionItemList = auctionItemMgr.myAuctionItemDict.get(playerID, [])
|
myAuctionItemList.append(auctionItem)
|
auctionItemMgr.myAuctionItemDict[playerID] = myAuctionItemList
|
if curPlayer:
|
Sync_PlayerAuctionItemInfo(curPlayer, auctionItem)
|
|
# Ìí¼Ó½øÎҵĹØ×¢
|
attentionMgr = PyDataManager.GetAuctionAttentionManager()
|
for attentionPlayerID, attentionList in auctionItemMgr.myAttentionItemDict.items():
|
if itemID not in GetPlayerAuctionAttention(attentionMgr, attentionPlayerID):
|
continue
|
if auctionItem not in attentionList:
|
attentionList.append(auctionItem)
|
|
if ipyData.GetNeedWorldNotify():
|
PlayerControl.WorldNotify(0, "Paimai4", [itemID, ipyData.GetNoticeSaleMinutes()])
|
|
drDict = {"AuctionItemInfo":__GetAuctionItemDRDict(auctionItem)}
|
DR_AuctionHouse(curPlayer, "AddAuctionItem", drDict)
|
GameWorld.DebugLog("ÉϼÜÅÄÆ·: playerID=%s,familyID=%s,%s" % (playerID, familyID, drDict), playerID)
|
GameWorld.DebugLog("¸üÐÂÅÄÆ·Êý: %s" % len(auctionItemMgr.allAuctionItemDict))
|
return auctionItem
|
|
def __NotifyAuctionPlayerAddItem(notifyAddItemList):
|
## ֪ͨ¹Ø×¢ÎïÆ·µÄÍæ¼ÒÐÂÉϼÜÎïÆ·ÁË
|
if not notifyAddItemList:
|
return
|
attentionMgr = PyDataManager.GetAuctionAttentionManager()
|
playerManager = GameWorld.GetPlayerManager()
|
for i in xrange(playerManager.GetActivePlayerCount()):
|
player = playerManager.GetActivePlayerAt(i)
|
if player == None:
|
continue
|
if PlayerControl.GetIsTJG(player):
|
continue
|
playerAttentionIDList = GetPlayerAuctionAttention(attentionMgr, player.GetPlayerID())
|
if not playerAttentionIDList:
|
continue
|
infoPack = None
|
for itemGUID, itemID, playerID in notifyAddItemList:
|
if playerID and playerID == player.GetPlayerID():
|
# ×Ô¼ºÉϼܵÄÎïÆ·²»Í¨Öª
|
continue
|
if itemID not in playerAttentionIDList:
|
continue
|
if not infoPack:
|
infoPack = ChPyNetSendPack.tagGCAddAuctionItemInfo()
|
itemInfo = ChPyNetSendPack.tagGCAddAuctionItem()
|
itemInfo.ItemGUID = itemGUID
|
itemInfo.ItemID = itemID
|
infoPack.AddAuctionItemList.append(itemInfo)
|
|
if infoPack:
|
infoPack.AddCount = len(infoPack.AddAuctionItemList)
|
NetPackCommon.SendFakePack(player, infoPack)
|
return
|
|
def __DoUnsellAuctionItem(curPlayer, itemGUID):
|
## ϼÜÅÄÆ·
|
auctionItem = GetAuctionItem(itemGUID)
|
if not auctionItem:
|
# ÅÄÆ·²»´æÔÚ
|
PlayerControl.NotifyCode(curPlayer, "Paimai3")
|
return
|
playerID = curPlayer.GetPlayerID()
|
itemID = auctionItem.ItemID
|
if auctionItem.FamilyID:
|
GameWorld.ErrLog("ÏÉÃËÅÄÆ·ÎÞ·¨Ï¼ܣ¡itemGUID=%s,itemID=%s,itemFamilyID=%s"
|
% (itemGUID, itemID, auctionItem.FamilyID), playerID)
|
return
|
if auctionItem.PlayerID != playerID:
|
GameWorld.ErrLog("²»ÊÇÍæ¼Ò×Ô¼ºµÄÅÄÆ·ÎÞ·¨Ï¼ܣ¡itemGUID=%s,itemID=%s,itemPlayerID=%s"
|
% (itemGUID, itemID, auctionItem.PlayerID), playerID)
|
return
|
if auctionItem.BidderPrice:
|
# ¾º¼ÛÖеÄÅÄÆ·²»ÄÜϼÜ
|
PlayerControl.NotifyCode(curPlayer, "Paimai9")
|
return
|
|
__EndAuctionItem([auctionItem], "Unsell")
|
return
|
|
def __DoPlayerBidAuctionItem(curPlayer, itemGUID, biddingPrice, tick, isOnlyCheck, funcAutoBuyout=False):
|
''' Íæ¼Ò¾º¼ÛÎïÆ·
|
@param curPlayer: ¾º¼ÛµÄÍæ¼Ò
|
@param itemGUID: ÅÄÆ·GUID
|
@param biddingPrice: ¾º¼Û
|
@param isOnlyCheck: ÊÇ·ñ½ö¼ì²é¿É·ñ¾º¼Û
|
@param funcAutoBuyout: ÊÇ·ñ¹¦ÄÜ×Ô¶¯¹ºÂò
|
'''
|
|
errInfo = ""
|
itemID = 0
|
|
auctionItem = GetAuctionItem(itemGUID)
|
if not auctionItem:
|
# ÅÄÆ·²»´æÔÚ
|
PlayerControl.NotifyCode(curPlayer, "Paimai3")
|
errInfo = "not auctionItem"
|
return itemID, errInfo
|
itemID = auctionItem.ItemID
|
ipyData = IpyGameDataPY.GetIpyGameData("AuctionItem", itemID)
|
if not ipyData:
|
errInfo = "not ipyData"
|
return itemID, errInfo
|
playerID = curPlayer.GetPlayerID()
|
addTimeStr = auctionItem.AddTime
|
auctionType = auctionItem.AuctionType # 0-È«·þÅÄÆ·£¬1-ÏÉÃËÅÄÆ·
|
addTime = GameWorld.ChangeTimeStrToNum(addTimeStr)
|
curTime = int(time.time())
|
passMinutes = (curTime - addTime) / 60
|
noticeMinutes = ipyData.GetNoticeSaleMinutes()
|
if passMinutes < noticeMinutes:
|
GameWorld.ErrLog("ÅÄÆ·ÉÐ먦·Å¾º¼Û! itemGUID=%s,itemID=%s,addTimeStr=%s" % (itemGUID, itemID, addTimeStr), playerID)
|
errInfo = "in notice time"
|
return itemID, errInfo
|
if auctionType == AuctionType_Family:
|
itemFamilyID = auctionItem.FamilyID
|
playerFamilyID = curPlayer.GetFamilyID()
|
if not playerFamilyID or playerFamilyID != itemFamilyID:
|
GameWorld.ErrLog("¸ÃÅÄƷΪÏÉÃË˽ÓÐÅÄÆ·£¬·Ç±¾ÏÉÃËÈËÔ±²»¿É¾ºÅÄ! itemGUID=%s,itemID=%s,itemFamilyID=%s,playerFamilyID=%s"
|
% (itemGUID, itemID, itemFamilyID, playerFamilyID), playerID)
|
errInfo = "is family auction item"
|
return itemID, errInfo
|
if curTime > auctionItem.EndTime:
|
GameWorld.ErrLog("ÅÄÆ·ÒѽáÊø¾º¼Û! itemGUID=%s,itemID=%s,addTimeStr=%s" % (itemGUID, itemID, addTimeStr), playerID)
|
errInfo = "end bid"
|
return itemID, errInfo
|
|
nextPrice = ipyData.GetBasePrice() * auctionItem.Count if not auctionItem.BidderPrice else (auctionItem.BidderPrice + ipyData.GetBiddingAdd() * auctionItem.Count)
|
buyoutPrice = ipyData.GetBuyoutPrice() * auctionItem.Count # ÔÊÐíûÓÐÒ»¿Ú¼ÛµÄ£¬´ú±í¿ÉÒÔÒ»Ö±¾º¼Û
|
nextPrice = nextPrice if not buyoutPrice else min(nextPrice, buyoutPrice) # ²»³¬¹ýÒ»¿Ú¼Û
|
if not (biddingPrice == nextPrice or (buyoutPrice and biddingPrice == buyoutPrice)):
|
# ¾º¼Û¼Û¸ñ´íÎó
|
PlayerControl.NotifyCode(curPlayer, "Paimai2")
|
errInfo = "bid price error! biddingPrice=%s,nextPrice=%s,buyoutPrice=%s,itemGUID=%s,itemID=%s" % (biddingPrice, nextPrice, buyoutPrice, itemGUID, itemID)
|
return itemID, errInfo
|
|
if isOnlyCheck:
|
queryTick = auctionItem.BiddingQueryTick
|
if queryTick and tick - queryTick < BiddingQueryLockTick:
|
# ÓÐÍæ¼ÒÕýÔÚ¾º¼Û£¬ÇëÉÔµÈ
|
PlayerControl.NotifyCode(curPlayer, "Paimai1")
|
errInfo = "other player bidding"
|
return itemID, errInfo
|
auctionItem.BiddingQueryID = playerID
|
auctionItem.BiddingQueryTick = tick
|
return itemID, errInfo
|
|
if not funcAutoBuyout and auctionItem.BiddingQueryID != playerID:
|
PlayerControl.NotifyCode(curPlayer, "Paimai2")
|
errInfo = "bidding player error"
|
return itemID, errInfo
|
|
lastBidderID = auctionItem.BidderID
|
lastBidderPrice = auctionItem.BidderPrice
|
itemCount = auctionItem.Count
|
|
isBuyout = buyoutPrice and biddingPrice >= buyoutPrice # ´óÓÚµÈÓÚÒ»¿Ú¼Û£¬Ö±½Ó³É½»
|
|
auctionItemMgr = PyDataManager.GetAuctionItemManager()
|
nowBiddingAuctionItemDict = auctionItemMgr.nowBiddingAuctionItemDict
|
hisBiddingAuctionItemDict = auctionItemMgr.hisBiddingAuctionItemDict
|
|
# Óʼþ·µ»¹Éϸö¾º¼ÛÕß
|
if lastBidderID and lastBidderPrice:
|
detail = {"ItemID":itemID, "ItemGUID":itemGUID, "Count":itemCount}
|
if isBuyout:
|
# ¾ºÅÄʧ°Ü£¬½ö֪ͨ
|
paramList = [itemID, itemID, lastBidderPrice]
|
PlayerCompensation.SendMailByKey("PaimaiMail2", [lastBidderID], [], paramList, goldPaper=lastBidderPrice,
|
detail=detail, moneySource=ChConfig.Def_GiveMoney_AuctionBidReturn)
|
else:
|
# ¾ºÅÄʧ°Ü£¬¿É¼ÌÐø¾º¼ÛÓʼþ
|
paramList = [itemID, itemID, lastBidderPrice, itemGUID]
|
PlayerCompensation.SendMailByKey("PaimaiMail1", [lastBidderID], [], paramList, goldPaper=lastBidderPrice,
|
detail=detail, moneySource=ChConfig.Def_GiveMoney_AuctionBidReturn)
|
AddAuctionRecord(auctionItem, AuctionRecordResult_BidFail)
|
|
isSyncBiddingItem = False
|
nowBiddingAuctionItemList = nowBiddingAuctionItemDict.get(lastBidderID, [])
|
if auctionItem in nowBiddingAuctionItemList:
|
nowBiddingAuctionItemList.remove(auctionItem)
|
nowBiddingAuctionItemDict[lastBidderID] = nowBiddingAuctionItemList
|
isSyncBiddingItem = True
|
hisBiddingAuctionItemList = hisBiddingAuctionItemDict.get(lastBidderID, [])
|
if auctionItem not in hisBiddingAuctionItemList:
|
hisBiddingAuctionItemList.append(auctionItem)
|
hisBiddingAuctionItemDict[lastBidderID] = hisBiddingAuctionItemList
|
isSyncBiddingItem = True
|
if isSyncBiddingItem:
|
lastBidder = GameWorld.GetPlayerManager().FindPlayerByID(lastBidderID)
|
if lastBidder and not PlayerControl.GetIsTJG(lastBidder):
|
Sync_PlayerBiddingItemInfo(lastBidder, auctionItem)
|
|
# ¸üоº¼ÛÐÅÏ¢
|
auctionItem.BiddingQueryID = 0
|
auctionItem.BiddingQueryTick = 0
|
auctionItem.BiddingTime = GameWorld.GetCurrentDataTimeStr()
|
auctionItem.BidderID = playerID
|
auctionItem.BidderName = curPlayer.GetName()
|
auctionItem.BidderPrice = biddingPrice
|
isSyncBiddingItem = False
|
nowBiddingAuctionItemList = nowBiddingAuctionItemDict.get(playerID, [])
|
if auctionItem not in nowBiddingAuctionItemList:
|
nowBiddingAuctionItemList.append(auctionItem)
|
nowBiddingAuctionItemDict[playerID] = nowBiddingAuctionItemList
|
isSyncBiddingItem = True
|
hisBiddingAuctionItemList = hisBiddingAuctionItemDict.get(playerID, [])
|
if auctionItem in hisBiddingAuctionItemList:
|
hisBiddingAuctionItemList.remove(auctionItem)
|
hisBiddingAuctionItemDict[playerID] = hisBiddingAuctionItemList
|
isSyncBiddingItem = True
|
if isSyncBiddingItem:
|
Sync_PlayerBiddingItemInfo(curPlayer, auctionItem)
|
|
# Ìí¼ÓÀúÊ·¾º¼ÛÕß
|
if str(playerID) not in auctionItem.BidderIDInfo:
|
auctionItem.BidderIDInfo += "%s|" % playerID
|
auctionItem.BidderIDLen = len(auctionItem.BidderIDInfo)
|
|
GameWorld.DebugLog("Íæ¼Ò¾º¼ÛÅÄÆ·: itemGUID=%s,itemID=%s,isBuyout=%s,lastBidderID=%s,lastBidderPrice=%s,bidderIDInfo=%s"
|
% (itemGUID, itemID, isBuyout, lastBidderID, lastBidderPrice, auctionItem.BidderIDInfo), playerID)
|
|
if auctionItem in auctionItemMgr.sysBuyoutItemByTimeList:
|
auctionItemMgr.sysBuyoutItemByTimeList.remove(auctionItem)
|
#GameWorld.DebugLog("ÅÄÆ·ÓÐÈ˾º¼ÛÁË£¬ÒƳýϵͳһ¿Ú¼ÛÅÄÆ·Áбí!")
|
|
if isBuyout:
|
__EndAuctionItem([auctionItem], "Buyout", funcAutoBuyout, buyPlayer=curPlayer)
|
else:
|
if __AddAuctionItemEndTimeByBid(auctionItem):
|
__SortAuctionitem(isSortWorldItem=False)
|
|
drDict = {"AuctionItemInfo":__GetAuctionItemDRDict(auctionItem)}
|
DR_AuctionHouse(curPlayer, "BidAuctionItem", drDict)
|
|
__SyncRefreshAuctionItem([auctionItem])
|
|
return itemID, errInfo
|
|
def __DoEquipStarAutoBuyEquip(curPlayer, queryData, tick):
|
## ÉýÐÇ×Ô¶¯¹ºÂò
|
classLV, equipPlace, curPartStar, equipPackIndex, isAutoBuyPreview, curRate, delEquipGUIDDict, delItemInfoDict, lackItemCostMoney, playerGoldPaper = queryData
|
GameWorld.DebugLog("ÉýÐÇ×Ô¶¯¹ºÂò×°±¸: classLV=%s, equipPlace=%s, curPartStar=%s, equipPackIndex=%s" % (classLV, equipPlace, curPartStar, equipPackIndex))
|
GameWorld.DebugLog(" ÊÇ·ñÔ¤ÀÀ %s, curRate=%s,lackItemCostMoney=%s, playerGoldPaper=%s" % (isAutoBuyPreview, curRate, lackItemCostMoney, playerGoldPaper))
|
nextStar = curPartStar + 1
|
ipyData = IpyGameDataPY.GetIpyGameData("EquipStarUp", classLV, equipPlace, nextStar)
|
if not ipyData:
|
return
|
costEquipPlaceList = ipyData.GetCostEquipPlace()
|
costEquipColorList = ipyData.GetCostEquipColor()
|
isJobLimit = ipyData.GetIsJobLimit()
|
unSuitRate = ipyData.GetUnSuitRate()
|
|
curTime = int(time.time())
|
fullRate = IpyGameDataPY.GetFuncCfg("EquipStarRate", 4)
|
autoBuyOtherClassItemDict = {}
|
buyEquipCostMoney = 0
|
autoBuyItemList = []
|
auctionItemMgr = PyDataManager.GetAuctionItemManager()
|
#GameWorld.DebugLog("ÊÀ½çÅÄÆ·¸öÊý: %s" % len(auctionItemMgr.worldAuctionItemList))
|
for i, worldAuctionItem in enumerate(auctionItemMgr.worldAuctionItemList):
|
|
itemID = worldAuctionItem.ItemID
|
aucItemJob = worldAuctionItem.ItemJobLimit
|
if not aucItemJob:
|
#GameWorld.DebugLog(" %s ְҵͨÓõÄ, ²»¹ºÂò!itemID=%s" % (i, itemID))
|
continue
|
if isJobLimit and aucItemJob != curPlayer.GetJob():
|
#GameWorld.DebugLog(" %s Ö°Òµ²»¿ÉÓÃ, ²»¹ºÂò!itemID=%s,aucItemJob=%s != %s" % (i, itemID, aucItemJob, curPlayer.GetJob()))
|
continue
|
|
itemIDStr = str(itemID)
|
aucItemColor = int(itemIDStr[3:4])
|
aucItemPlace = int(itemIDStr[4:6])
|
aucItemIsSuit = int(itemIDStr[-1])
|
|
if aucItemColor not in costEquipColorList:
|
#GameWorld.DebugLog(" %s ÑÕÉ«ÏÞÖÆ, ²»¹ºÂò£¡itemID=%s,aucItemColor=%s not in %s" % (i, itemID, aucItemColor, costEquipColorList))
|
continue
|
if aucItemPlace not in costEquipPlaceList:
|
#GameWorld.DebugLog(" %s ×°±¸Î»ÏÞÖÆ, ²»¹ºÂò£¡itemID=%s,aucItemPlace=%s not in %s" % (i, itemID, aucItemPlace, costEquipPlaceList))
|
continue
|
if aucItemIsSuit:
|
#Ì××°²»ÔÊÐí×Ô¶¯¹ºÂò
|
#GameWorld.DebugLog(" %s Ì××°, ²»¹ºÂò£¡itemID=%s" % (i, itemID))
|
continue
|
|
aucIpyData = IpyGameDataPY.GetIpyGameData("AuctionItem", itemID)
|
if not aucIpyData:
|
continue
|
buyoutPrice = aucIpyData.GetBuyoutPrice()
|
if not buyoutPrice:
|
#GameWorld.DebugLog(" %s ûÓÐÒ»¿Ú¼Û, ²»¹ºÂò£¡itemID=%s,buyoutPrice=%s" % (i, itemID, buyoutPrice))
|
continue
|
|
if curTime > worldAuctionItem.EndTime:
|
#GameWorld.DebugLog(" %s ÅÄÆ·ÒѽáÊø¾º¼Û, ²»¹ºÂò£¡itemID=%s" % (i, itemID))
|
continue
|
|
noticeMinutes = aucIpyData.GetNoticeSaleMinutes()
|
if noticeMinutes:
|
addTimeStr = worldAuctionItem.AddTime
|
addTime = GameWorld.ChangeTimeStrToNum(addTimeStr)
|
passMinutes = (curTime - addTime) / 60
|
if passMinutes < noticeMinutes:
|
#GameWorld.DebugLog(" %s ÅÄÆ·ÉÐ먦·Å¾º¼Û, ²»¹ºÂò£¡itemID=%s" % (i, itemID))
|
continue
|
|
aucItemClassLV = worldAuctionItem.ItemClassLV
|
# ±¾½×µÄÖ±½Ó´¦Àí
|
if aucItemClassLV == classLV:
|
autoBuyItemList.append([worldAuctionItem, buyoutPrice])
|
curRate += unSuitRate
|
buyEquipCostMoney += buyoutPrice
|
GameWorld.DebugLog(" %s ±¾½×ÓÅÏȹºÂò£¡itemID=%s,classLV=%s,curRate=%s,buyoutPrice=%s,buyEquipCostMoney=%s"
|
% (i, itemID, classLV, curRate, buyoutPrice, buyEquipCostMoney))
|
if curRate >= fullRate:
|
curRate = 100
|
GameWorld.DebugLog(" ×Ô¶¯¹ºÂò±¾½×¸ÅÂÊÒÑÂú×㣡curRate=%s" % (curRate))
|
break
|
|
# ÆäËû½×µÄÐèÒª°´½×µÄÓÅÏȼ¶½øÐд¦Àí
|
else:
|
if aucItemClassLV not in autoBuyOtherClassItemDict:
|
autoBuyOtherClassItemDict[aucItemClassLV] = []
|
classItemList = autoBuyOtherClassItemDict[aucItemClassLV]
|
classItemList.append([worldAuctionItem, buyoutPrice])
|
GameWorld.DebugLog(" %s ·Ç±¾½×, Ôݲ»´¦Àí! itemID=%s,aucItemClassLV=%s" % (i, itemID, aucItemClassLV))
|
|
# δÂú¸ÅÂÊʱÔÙ¹ºÂòÆäËû½×
|
if curRate < 100:
|
lowClassList, highClassList = [], []
|
for othClassLV in autoBuyOtherClassItemDict.keys():
|
if othClassLV <= classLV:
|
lowClassList.append(othClassLV)
|
else:
|
highClassList.append(othClassLV)
|
lowClassList.sort(reverse=True)
|
highClassList.sort()
|
buyClassLVList = lowClassList + highClassList
|
GameWorld.DebugLog("±¾½×¸ÅÂÊδÂú£¬¼ì²é¹ºÂòÆäËû½×! curRate=%s,buyClassLVList=%s" % (curRate, buyClassLVList))
|
|
diffClassChangeRatePerInfo = IpyGameDataPY.GetFuncEvalCfg("EquipStarRate", 1)
|
unSuitRateRange = IpyGameDataPY.GetFuncEvalCfg("EquipStarRate", 2)
|
for othClassLV in buyClassLVList:
|
classItemList = autoBuyOtherClassItemDict[othClassLV]
|
for worldAuctionItem, buyoutPrice in classItemList:
|
baseRate = unSuitRate
|
minRate, maxRate = unSuitRateRange
|
|
costClassLV = worldAuctionItem.ItemClassLV
|
itemID = worldAuctionItem.ItemID
|
|
#Í̸߽×
|
if costClassLV > classLV:
|
diffClassChangeRatePer = diffClassChangeRatePerInfo[0] * (costClassLV - classLV)
|
addRate = int(math.ceil(round(baseRate * (100 + diffClassChangeRatePer) /100.0, 2)))
|
GameWorld.DebugLog(" ÍÌ¸ß½× itemID=%s,costClassLV=%s,classLV=%s,baseRate=%s,diffClassChangeRatePer=%s,addRate=%s"
|
% (itemID, costClassLV, classLV, baseRate, diffClassChangeRatePer, addRate))
|
#Í̵ͽ×
|
elif costClassLV < classLV:
|
diffClassChangeRatePer = diffClassChangeRatePerInfo[1] * (classLV - costClassLV)
|
addRate = int(math.ceil(round(baseRate * (100 - diffClassChangeRatePer) /100.0, 2)))
|
GameWorld.DebugLog(" ÍÌµÍ½× itemID=%s,costClassLV=%s,classLV=%s,baseRate=%s,diffClassChangeRatePer=%s,addRate=%s"
|
% (itemID, costClassLV, classLV, baseRate, diffClassChangeRatePer, addRate))
|
else:
|
addRate = baseRate
|
addRate = max(minRate, min(addRate, maxRate))
|
|
autoBuyItemList.append([worldAuctionItem, buyoutPrice])
|
curRate += addRate
|
buyEquipCostMoney += buyoutPrice
|
GameWorld.DebugLog(" curRate=%s,buyoutPrice=%s,buyEquipCostMoney=%s" % (curRate, buyoutPrice, buyEquipCostMoney))
|
if curRate >= fullRate:
|
GameWorld.DebugLog(" ×Ô¶¯¹ºÂò²¹³äÆäËû½×¸ÅÂÊÒÑÂú×㣡curRate=%s" % (curRate))
|
curRate = 100
|
break
|
if curRate >= fullRate:
|
break
|
|
totalCostMoney = lackItemCostMoney + buyEquipCostMoney
|
GameWorld.DebugLog(" lackItemCostMoney=%s,buyEquipCostMoney=%s,totalCostMoney=%s,curRate=%s" % (lackItemCostMoney, buyEquipCostMoney, totalCostMoney, curRate))
|
if isAutoBuyPreview:
|
__SyncEquipStarAutoBuyCostInfo(curPlayer, classLV, equipPlace, curPartStar, curRate, totalCostMoney)
|
return
|
|
if curRate < 100:
|
# ×Ô¶¯¹ºÂò±ØÐëÂú¸ÅÂÊ
|
# ÒòΪȷÈϹºÂò²»ÊÇʵʱµÄ£¬ËùÒÔ´æÔÚÅÄÂôÐÐÔ¤ÀÀÏûºÄ×°±¸¿ÉÄܱ»ÆäËûÍæ¼ÒÂò×ßµ¼ÖÂÎÞ·¨Âú¸Ï¿£¬ËùÒÔÕâÀïÐèÒª²¹Í¬²½Ò»´Î
|
__SyncEquipStarAutoBuyCostInfo(curPlayer, classLV, equipPlace, curPartStar, curRate, totalCostMoney)
|
PlayerControl.NotifyCode(curPlayer, "AutoBuyEquipLackEquip")
|
return
|
|
if playerGoldPaper < totalCostMoney:
|
# ÒòΪȷÈϹºÂò²»ÊÇʵʱµÄ£¬ËùÒÔ´æÔÚÅÄÂôÐÐÔ¤ÀÀÏûºÄµÄ¼Û¸ñÓëʵ¼Ê¹ºÂò¿ÉÄܳöÏÖÏûºÄ¼Û¸ñ²»Ò»ÖµÄÇé¿ö£¬ËùÒÔÕâÀïÐèÒª²¹Í¬²½Ò»´Î
|
__SyncEquipStarAutoBuyCostInfo(curPlayer, classLV, equipPlace, curPartStar, curRate, totalCostMoney)
|
PlayerControl.NotifyCode(curPlayer, "AutoBuyEquipLackMoney", [IPY_PlayerDefine.TYPE_Price_Gold_Paper])
|
return
|
|
for worldAuctionItem, buyoutPrice in autoBuyItemList:
|
# ÕâÀïÈÏΪһ¶¨¿ÉÒÔ¹ºÂò³É¹¦£¬²»¶Ô·µ»ØÖµ×ö´¦Àí£¬¼´Ê¹ÎÞ·¨¹ºÂòÒ²ÈÏΪ¹ºÂò³É¹¦£¬Íæ¼ÒµÄÏûºÄÕÕ³£¿Û³ý
|
__DoPlayerBidAuctionItem(curPlayer, worldAuctionItem.ItemGUID, buyoutPrice, tick, False, funcAutoBuyout=True)
|
|
return classLV, equipPlace, curPartStar, equipPackIndex, curRate, delEquipGUIDDict, delItemInfoDict, lackItemCostMoney, buyEquipCostMoney
|
|
def __SyncEquipStarAutoBuyCostInfo(curPlayer, classLV, equipPlace, curPartStar, curRate, totalCostMoney):
|
## ֪ͨ×Ô¶¯¹ºÂòÔ¤ÀÀ½á¹û
|
costInfo = ChPyNetSendPack.tagGCEquipStarAutoBuyCostInfo()
|
costInfo.ClassLV = classLV
|
costInfo.EquipPlace = equipPlace
|
costInfo.CurStar = curPartStar
|
costInfo.CurRate = curRate
|
costInfo.AutoBuyCostMoney = totalCostMoney
|
NetPackCommon.SendFakePack(curPlayer, costInfo)
|
return
|
|
def __SyncRefreshAuctionItem(auctionItemList):
|
''' // B5 08 ÅÄÂôÐÐË¢ÐÂÅÄÆ· #tagGCRefreshAuctionItemInfo
|
1-ÏÉÃËÅÄƷתÒƵ½È«·þʱ֪ͨ£» 2-ÅÄÆ·ÓÐÈ˾º¼ÛʱˢÐÂ
|
'''
|
|
refreshAuctionItemList = []
|
|
for auctionItem in auctionItemList:
|
refreshItem = ChPyNetSendPack.tagGCRefreshAuctionItem()
|
refreshItem.ItemGUID = auctionItem.ItemGUID
|
refreshItem.AuctionType = auctionItem.AuctionType
|
refreshItem.AddTime = auctionItem.AddTime
|
refreshItem.BidderID = auctionItem.BidderID
|
refreshItem.BidderPrice = auctionItem.BidderPrice
|
refreshItem.BiddingTime = auctionItem.BiddingTime
|
refreshAuctionItemList.append(refreshItem)
|
|
if not refreshAuctionItemList:
|
return
|
|
clientPack = ChPyNetSendPack.tagGCRefreshAuctionItemInfo()
|
clientPack.RefreshAuctionItemList = refreshAuctionItemList
|
clientPack.RefreshCount = len(clientPack.RefreshAuctionItemList)
|
playerManager = GameWorld.GetPlayerManager()
|
for i in xrange(playerManager.GetActivePlayerCount()):
|
player = playerManager.GetActivePlayerAt(i)
|
if player == None:
|
continue
|
if PlayerControl.GetIsTJG(player):
|
continue
|
NetPackCommon.SendFakePack(player, clientPack)
|
|
return
|
|
def __DoGMClearAuctionItem(curPlayer):
|
if curPlayer.GetGMLevel() != 90:
|
return
|
|
allAuctionItemByEndTimeList = PyDataManager.GetAuctionItemManager().allAuctionItemByEndTimeList
|
if not allAuctionItemByEndTimeList:
|
GameWorld.DebugAnswer(curPlayer, "µ±Ç°Ã»ÓÐÅÄÆ·!")
|
return
|
|
endItemList = []
|
for auctionItem in allAuctionItemByEndTimeList:
|
endItemList.append(auctionItem)
|
|
clearCount = __EndAuctionItem(endItemList, "GMClear")
|
|
GameWorld.DebugAnswer(curPlayer, "Çå¿ÕÅÄÆ·Êý=%s" % clearCount)
|
return
|
|
def __DoGMPrintAuctionItem(curPlayer):
|
if curPlayer.GetGMLevel() != 90:
|
return
|
|
auctionItemMgr = PyDataManager.GetAuctionItemManager()
|
allAuctionItemByEndTimeList = auctionItemMgr.allAuctionItemByEndTimeList
|
GameWorld.DebugLog("TimeList×ÜÅÄÆ·Êý: =%s" % len(allAuctionItemByEndTimeList))
|
for i, auctionItem in enumerate(allAuctionItemByEndTimeList):
|
GameWorld.DebugLog(" i=%s, %s" % (i, __GetAuctionItemDRDict(auctionItem)))
|
|
GameWorld.DebugLog("AllDict×ÜÅÄÆ·Êý: %s" % len(auctionItemMgr.allAuctionItemDict))
|
|
GameWorld.DebugLog("È«·þÅÄÆ·¸öÊý: %s" % len(auctionItemMgr.worldAuctionItemList))
|
|
GameWorld.DebugLog("ϵͳһ¿Ú¼ÛÅÄÆ·¸öÊý: %s" % len(auctionItemMgr.sysBuyoutItemByTimeList))
|
|
for familyID, familyItemList in auctionItemMgr.familyAuctionItemDict.items():
|
GameWorld.DebugLog("ÏÉÃËÅÄÆ·¸öÊý: familyID=%s, %s" % (familyID, len(familyItemList)))
|
|
for playerID, myItemList in auctionItemMgr.myAuctionItemDict.items():
|
GameWorld.DebugLog("Íæ¼ÒÅÄÆ·¸öÊý: playerID=%s, %s" % (playerID, len(myItemList)))
|
|
for playerID, nowBiddingItemList in auctionItemMgr.nowBiddingAuctionItemDict.items():
|
GameWorld.DebugLog("Íæ¼Ò×î¸ß¾º¼ÛÅÄÆ·¸öÊý: playerID=%s, %s" % (playerID, len(nowBiddingItemList)))
|
|
for playerID, hisBiddingItemList in auctionItemMgr.hisBiddingAuctionItemDict.items():
|
GameWorld.DebugLog("Íæ¼ÒÀúÊ·¾º¼ÛÅÄÆ·¸öÊý: playerID=%s, %s" % (playerID, len(hisBiddingItemList)))
|
|
for playerID, attentionItemList in auctionItemMgr.myAttentionItemDict.items():
|
GameWorld.DebugLog("Íæ¼Ò¹Ø×¢ÅÄÆ·¸öÊý: playerID=%s, %s" % (playerID, len(attentionItemList)))
|
|
return
|
|
#// B5 10 ÅÄÂôÐвéѯÅÄÂôÖеÄÎïÆ· #tagCGQueryAuctionItem
|
#
|
#struct tagCGQueryAuctionItem
|
#{
|
# tagHead Head;
|
# BYTE Job; //¹ýÂËÖ°Òµ£¬0Ϊ²»ÏÞÖÆ
|
# BYTE ItemTypeCount;
|
# DWORD ItemTypeList[ItemTypeCount]; //Ö¸¶¨µÄÎïÆ·ÀàÐÍ
|
# BYTE ClassLV; //¹ýÂ˽×Êý£¬0Ϊ²»ÏÞÖÆ
|
# BYTE SpecItemIDCount; //Ö¸¶¨ÎïÆ·ID¸öÊý
|
# DWORD SpecItemIDList[SpecItemIDCount]; //Ö¸¶¨ÎïÆ·ID
|
# char FromItemGUID[40]; //´ÓÄĸöÎïÆ·¿ªÊ¼²éѯ
|
# BYTE QueryDir; //²éѯ·½Ïò£¬1-Íùºó²é£¬2-ÍùÇ°²é
|
# BYTE QueryCount; //²éѯ¸öÊý£¬0Ϊȫ²¿
|
#};
|
def OnQueryAuctionItem(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
job = clientData.Job
|
itemTypeList = clientData.ItemTypeList
|
classLV = clientData.ClassLV
|
specItemIDList = clientData.SpecItemIDList
|
fromItemGUID = clientData.FromItemGUID
|
queryDir = clientData.QueryDir
|
queryCount = clientData.QueryCount
|
__Sync_WorldAuctionItemQueryResult(curPlayer, job, itemTypeList, classLV, specItemIDList, fromItemGUID, queryDir, queryCount)
|
return
|
|
#// B5 17 ÅÄÂôÐвéѯ¶¨Î»Ä¿±êÅÄÆ· #tagCGQueryTagAuctionItem
|
#
|
#struct tagCGQueryTagAuctionItem
|
#{
|
# tagHead Head;
|
# char ItemGUID[40];
|
# DWORD ItemID;
|
#};
|
def OnQueryTagAuctionItem(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
tagItemGUID = clientData.ItemGUID
|
queryDir = 3
|
__Sync_WorldAuctionItemQueryResult(curPlayer, fromItemGUID=tagItemGUID, queryDir=queryDir, isNotify=True)
|
return
|
|
def __Sync_WorldAuctionItemQueryResult(curPlayer, job=0, itemTypeList=[], classLV=0, specItemIDList=[], fromItemGUID="", queryDir=1, queryCount=10, isNotify=False):
|
## ¸ù¾Ý¹ýÂËÌõ¼þͬ²½È«·þÅÄÆ·ÁÐ±í£¬Ä¿Ç°½öÈ«·þÅÄÆ·ÐèҪͨ¹ý²éѯ·þÎñÆ÷»ñµÃ£¬¸öÈËÅÄÆ·¼°ÏÉÃËÅÄÆ·ÓÉÓÚ¸öÊý½ÏÉÙÖ±½ÓÓÉÉÏÏß»ò±ä¸üʱÖ÷¶¯Í¬²½
|
|
fromAuctionItem = None
|
if fromItemGUID:
|
fromAuctionItem = GetAuctionItem(fromItemGUID)
|
if not fromAuctionItem:
|
GameWorld.DebugLog("²éѯµÄÄ¿±êÅÄÆ·²»´æÔÚ! fromItemGUID=%s" % fromItemGUID)
|
if isNotify:
|
PlayerControl.NotifyCode(curPlayer, "Paimai5")
|
return
|
|
# {(job, (itemType, ...), itemClassLV, (itemID, ...)):[tagDBAuctionItem, ...], ...}
|
queryKey = (job, tuple(itemTypeList), classLV, tuple(specItemIDList))
|
auctionItemMgr = PyDataManager.GetAuctionItemManager()
|
worldAuctionItemQueryDict = auctionItemMgr.worldAuctionItemQueryDict
|
if queryKey not in worldAuctionItemQueryDict:
|
# ÔØÈë¶ÔÓ¦²éѯÌõ¼þÅÄÆ·»º´æ
|
auctionItemQueryList = []
|
for worldAuctionItem in auctionItemMgr.worldAuctionItemList:
|
if job and worldAuctionItem.ItemJobLimit != job and worldAuctionItem.ItemJobLimit:
|
continue
|
if itemTypeList and worldAuctionItem.ItemType not in itemTypeList:
|
continue
|
if classLV and worldAuctionItem.ItemClassLV != classLV:
|
continue
|
if specItemIDList and worldAuctionItem.ItemID not in specItemIDList:
|
continue
|
auctionItemQueryList.append(worldAuctionItem)
|
worldAuctionItemQueryDict[queryKey] = auctionItemQueryList
|
else:
|
auctionItemQueryList = worldAuctionItemQueryDict[queryKey]
|
queryTotalCount = len(auctionItemQueryList)
|
|
fromIndex = 0
|
if fromAuctionItem:
|
if fromAuctionItem not in auctionItemQueryList:
|
GameWorld.ErrLog("²éѯµÄÄ¿±êÅÄÆ·²»ÔÚËùÔڵĹýÂ˵ÄÌõ¼þÀï! fromItemGUID=%s" % fromItemGUID)
|
if isNotify:
|
PlayerControl.NotifyCode(curPlayer, "Paimai5")
|
return
|
fromIndex = auctionItemQueryList.index(fromAuctionItem)
|
|
# ÏòÇ°²é£¬ÆäËûµÄĬÈÏÏòºó²é
|
if queryDir == 2:
|
startIndex = max(0, fromIndex - queryCount + 1)
|
syncItemList = auctionItemQueryList[startIndex:fromIndex + 1]
|
queryRemainlCount = startIndex
|
# Ïòºó²é
|
else:
|
syncItemList = auctionItemQueryList[fromIndex:fromIndex + queryCount]
|
queryRemainlCount = max(0, queryTotalCount - fromIndex - queryCount)
|
|
clientPack = ChPyNetSendPack.tagGCAuctionItemInfo()
|
clientPack.Job = job
|
clientPack.ItemTypeList = itemTypeList
|
clientPack.ItemTypeCount = len(clientPack.ItemTypeList)
|
clientPack.ClassLV = classLV
|
clientPack.SpecItemIDList = specItemIDList
|
clientPack.SpecItemIDCount = len(clientPack.SpecItemIDList)
|
clientPack.FromItemGUID = fromItemGUID
|
clientPack.QueryDir = queryDir
|
clientPack.QueryCount = queryCount
|
clientPack.QueryRemainlCount = queryRemainlCount
|
clientPack.AuctionItemList = []
|
for auctionItem in syncItemList:
|
itemInfo = ChPyNetSendPack.tagGCAuctionItem()
|
itemInfo.ItemGUID = auctionItem.ItemGUID
|
itemInfo.FamilyID = auctionItem.FamilyID
|
itemInfo.ItemID = auctionItem.ItemID
|
itemInfo.ItemCount = auctionItem.Count
|
itemInfo.AddTime = auctionItem.AddTime
|
itemInfo.BidderPrice = auctionItem.BidderPrice
|
itemInfo.BiddingTime = auctionItem.BiddingTime
|
itemInfo.UserData = auctionItem.UserData
|
itemInfo.UserDataLen = auctionItem.UserDataLen
|
clientPack.AuctionItemList.append(itemInfo)
|
clientPack.AuctionItemCount = len(clientPack.AuctionItemList)
|
NetPackCommon.SendFakePack(curPlayer, clientPack)
|
return
|
|
#// B5 12 ÅÄÂôÐвéѯÅÄÂô¼Ç¼ #tagCGQueryAuctionRecord
|
#
|
#struct tagCGQueryAuctionRecord
|
#{
|
# tagHead Head;
|
# BYTE RecordType; //¼Ç¼ÀàÐÍ 0-ÎÒµÄÅÄÆ·¼Ç¼ 1-ÏÉÃËÅÄÆ·¼Ç¼ 2-ÎҵľºÅļǼ
|
#};
|
def OnQueryAuctionRecord(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
recordType = clientData.RecordType
|
Sync_PlayerAuctionRecordInfo(curPlayer, recordType, None, curPlayer.GetFamilyID())
|
return
|
|
#// B5 16 ÅÄÂôÐвéѯ¹Ø×¢ÖеÄÅÄÆ· #tagCGQueryAttentionAuctionItem
|
#
|
#struct tagCGQueryAttentionAuctionItem
|
#{
|
# tagHead Head;
|
#};
|
def OnQueryAttentionAuctionItem(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
playerID = curPlayer.GetPlayerID()
|
|
auctionItemMgr = PyDataManager.GetAuctionItemManager()
|
myAttentionItemDict = auctionItemMgr.myAttentionItemDict
|
if playerID in myAttentionItemDict:
|
attentionItemList = myAttentionItemDict[playerID]
|
else:
|
attentionItemList = []
|
attentionMgr = PyDataManager.GetAuctionAttentionManager()
|
attentionItemIDList = GetPlayerAuctionAttention(attentionMgr, playerID)
|
if attentionItemIDList:
|
for auctionItem in auctionItemMgr.worldAuctionItemList:
|
if auctionItem.ItemID not in attentionItemIDList:
|
continue
|
attentionItemList.append(auctionItem)
|
myAttentionItemDict[playerID] = attentionItemList
|
|
clientPack = ChPyNetSendPack.tagGCAttentionAuctionItemInfo()
|
clientPack.AuctionItemList = []
|
for attentionItem in attentionItemList:
|
itemObj = ChPyNetSendPack.tagGCAttentionAuctionItem()
|
itemObj.ItemGUID = attentionItem.ItemGUID
|
itemObj.FamilyID = attentionItem.FamilyID
|
itemObj.ItemID = attentionItem.ItemID
|
itemObj.ItemCount = attentionItem.Count
|
itemObj.AddTime = attentionItem.AddTime
|
itemObj.BidderPrice = attentionItem.BidderPrice
|
itemObj.BiddingTime = attentionItem.BiddingTime
|
itemObj.UserData = attentionItem.UserData
|
itemObj.UserDataLen = attentionItem.UserDataLen
|
clientPack.AuctionItemList.append(itemObj)
|
clientPack.AuctionItemCount = len(clientPack.AuctionItemList)
|
NetPackCommon.SendFakePack(curPlayer, clientPack)
|
return
|
|
#// B5 18 ÅÄÂôÐÐÐ޸ĹØ×¢ÎïÆ· #tagCGAttentionAuctionItemChange
|
#
|
#struct tagCGAttentionAuctionItemChange
|
#{
|
# tagHead Head;
|
# DWORD ItemID;
|
# BYTE IsAttention; //ÊÇ·ñ¹Ø×¢£¬È¡Ïû¹Ø×¢·¢0
|
#};
|
def OnAttentionAuctionItemChange(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
playerID = curPlayer.GetPlayerID()
|
itemID = clientData.ItemID
|
isAttention = clientData.IsAttention
|
|
attentionMgr = PyDataManager.GetAuctionAttentionManager()
|
if isAttention:
|
if not AddPlayerAuctionAttention(attentionMgr, playerID, itemID):
|
return
|
else:
|
if not DelPlayerAuctionAttention(attentionMgr, playerID, itemID):
|
return
|
Sync_PlayerAttentionAuctionItemID(curPlayer, True)
|
|
# ¹Ø×¢ÐÅÏ¢±ä¸ü£¬Çå¿Õ¹Ø×¢ÅÄƷʵÀý»º´æ
|
auctionItemMgr = PyDataManager.GetAuctionItemManager()
|
auctionItemMgr.myAttentionItemDict.pop(playerID, None)
|
return
|
|
def Sync_FamilyAuctionItemInfo(curPlayer, familyID, itemInfoList=[]):
|
# // B5 05 ÅÄÂôÐÐÏÉÃËÅÄÂôÖеÄÎïÆ·ÐÅÏ¢ #tagGCFamilyAuctionItemInfo
|
|
if not familyID:
|
return
|
|
if not itemInfoList:
|
itemInfoList = GetFamilyAuctionItemList(familyID)
|
|
if not itemInfoList:
|
return
|
|
itemInfoPack = ChPyNetSendPack.tagGCFamilyAuctionItemInfo()
|
itemInfoPack.AuctionItemList = []
|
for auctionItem in itemInfoList:
|
packItem = ChPyNetSendPack.tagGCFamilyAuctionItem()
|
packItem.ItemGUID = auctionItem.ItemGUID
|
packItem.FamilyID = auctionItem.FamilyID
|
packItem.ItemID = auctionItem.ItemID
|
packItem.ItemCount = auctionItem.Count
|
packItem.AddTime = auctionItem.AddTime
|
packItem.BidderPrice = auctionItem.BidderPrice
|
packItem.BiddingTime = auctionItem.BiddingTime
|
packItem.UserData = auctionItem.UserData
|
packItem.UserDataLen = auctionItem.UserDataLen
|
packItem.FamilyPlayerIDInfo = auctionItem.FamilyPlayerIDInfo
|
packItem.FamilyPlayerIDLen = auctionItem.FamilyPlayerIDLen
|
packItem.AuctionType = auctionItem.AuctionType
|
itemInfoPack.AuctionItemList.append(packItem)
|
itemInfoPack.AuctionItemCount = len(itemInfoPack.AuctionItemList)
|
|
if curPlayer:
|
NetPackCommon.SendFakePack(curPlayer, itemInfoPack)
|
else:
|
PlayerFamily.SendFamilyFakePack(familyID, itemInfoPack)
|
return
|
|
def Sync_PlayerAuctionItemInfo(curPlayer, auctionItem=None):
|
# // B5 02 ÅÄÂôÐÐÍæ¼ÒÅÄÂôÖеÄÎïÆ·ÐÅÏ¢ #tagGCPlayerAuctionItemInfo
|
|
if auctionItem:
|
syncItemList = [auctionItem]
|
else:
|
syncItemList = GetPlayerAuctionItemList(curPlayer.GetPlayerID())
|
|
if not syncItemList:
|
return
|
|
itemInfoPack = ChPyNetSendPack.tagGCPlayerAuctionItemInfo()
|
itemInfoPack.AuctionItemList = []
|
for auctionItem in syncItemList:
|
packItem = ChPyNetSendPack.tagGCPlayerAuctionItem()
|
packItem.ItemGUID = auctionItem.ItemGUID
|
packItem.FamilyID = auctionItem.FamilyID
|
packItem.ItemID = auctionItem.ItemID
|
packItem.ItemCount = auctionItem.Count
|
packItem.AddTime = auctionItem.AddTime
|
packItem.BidderPrice = auctionItem.BidderPrice
|
packItem.BiddingTime = auctionItem.BiddingTime
|
packItem.UserData = auctionItem.UserData
|
packItem.UserDataLen = auctionItem.UserDataLen
|
itemInfoPack.AuctionItemList.append(packItem)
|
itemInfoPack.AuctionItemCount = len(itemInfoPack.AuctionItemList)
|
NetPackCommon.SendFakePack(curPlayer, itemInfoPack)
|
return
|
|
def Sync_PlayerAuctionRecordInfo(curPlayer, recordType, newRecordData=None, familyID=0):
|
## B5 03 ÅÄÂôÐÐÍæ¼ÒÅÄÂô¼Ç¼ #tagGCPlayerAuctionRecordInfo
|
if recordType == AuctionRecordType_MyAuction and curPlayer:
|
syncRecordList = [newRecordData] if newRecordData else GetMyAuctionItemRecord(curPlayer.GetPlayerID())
|
elif recordType == AuctionRecordType_FamilyAuction and familyID:
|
syncRecordList = [newRecordData] if newRecordData else GetFamilyAuctionItemRecord(familyID)
|
elif recordType == AuctionRecordType_MyBid and curPlayer:
|
syncRecordList = [newRecordData] if newRecordData else GetMyBiddingItemRecord(curPlayer.GetPlayerID())
|
else:
|
return
|
|
clientPack = ChPyNetSendPack.tagGCPlayerAuctionRecordInfo()
|
clientPack.AuctionRecordList = []
|
for recordData in syncRecordList:
|
record = ChPyNetSendPack.tagGCPlayerAuctionRecord()
|
record.ItemGUID = recordData.ItemGUID
|
record.FamilyID = recordData.FamilyID
|
record.RecordType = recordData.RecordType
|
record.RecordResult = recordData.RecordResult
|
record.RecordTime = recordData.RecordTime
|
record.BidderPrice = recordData.BidderPrice
|
record.BidderName = recordData.BidderName
|
record.ItemID = recordData.ItemID
|
record.ItemCount = recordData.Count
|
record.UserData = recordData.UserData
|
record.UserDataLen = recordData.UserDataLen
|
clientPack.AuctionRecordList.append(record)
|
clientPack.Count = len(clientPack.AuctionRecordList)
|
|
if curPlayer:
|
NetPackCommon.SendFakePack(curPlayer, clientPack)
|
elif familyID and recordType == AuctionRecordType_FamilyAuction:
|
PlayerFamily.SendFamilyFakePack(familyID, clientPack)
|
return
|
|
def Sync_PlayerBiddingItemInfo(curPlayer, auctionItem=None):
|
#// B5 10 ÅÄÂôÐÐÍæ¼Ò¾º¼ÛÖеÄÎïÆ·ÐÅÏ¢ #tagGCBiddingItemInfo
|
# ÉÏÏßͬ²½¡¢Íæ¼ÒÏà¹ØµÄ¾º¼ÛÅÄÆ·¾º¼Û±ä¸üʱͬ²½
|
|
if auctionItem:
|
syncItemList = [auctionItem]
|
else:
|
playerID = curPlayer.GetPlayerID()
|
auctionItemMgr = PyDataManager.GetAuctionItemManager()
|
nowBiddingAuctionItemList = auctionItemMgr.nowBiddingAuctionItemDict.get(playerID, [])
|
hisBiddingAuctionItemList = auctionItemMgr.hisBiddingAuctionItemDict.get(playerID, [])
|
syncItemList = nowBiddingAuctionItemList + hisBiddingAuctionItemList
|
|
if not syncItemList:
|
return
|
|
itemInfoPack = ChPyNetSendPack.tagGCBiddingItemInfo()
|
itemInfoPack.AuctionItemList = []
|
for auctionItem in syncItemList:
|
packItem = ChPyNetSendPack.tagGCBiddingItem()
|
packItem.ItemGUID = auctionItem.ItemGUID
|
packItem.FamilyID = auctionItem.FamilyID
|
packItem.ItemID = auctionItem.ItemID
|
packItem.ItemCount = auctionItem.Count
|
packItem.AddTime = auctionItem.AddTime
|
packItem.BidderID = auctionItem.BidderID
|
packItem.BidderPrice = auctionItem.BidderPrice
|
packItem.BiddingTime = auctionItem.BiddingTime
|
packItem.UserData = auctionItem.UserData
|
packItem.UserDataLen = auctionItem.UserDataLen
|
itemInfoPack.AuctionItemList.append(packItem)
|
itemInfoPack.AuctionItemCount = len(itemInfoPack.AuctionItemList)
|
NetPackCommon.SendFakePack(curPlayer, itemInfoPack)
|
return
|
|
def Sync_PlayerAttentionAuctionItemID(curPlayer, isForce=False):
|
# // B5 07 ÅÄÂôÐйØ×¢µÄÎïÆ·ID #tagGCAttentionAuctionItemID
|
attentionMgr = PyDataManager.GetAuctionAttentionManager()
|
attentionItemIDList = GetPlayerAuctionAttention(attentionMgr, curPlayer.GetPlayerID())
|
if not attentionItemIDList and not isForce:
|
return
|
clientPack = ChPyNetSendPack.tagGCAttentionAuctionItemID()
|
clientPack.AttentionItemIDList = attentionItemIDList
|
clientPack.AttentionCount = len(clientPack.AttentionItemIDList)
|
NetPackCommon.SendFakePack(curPlayer, clientPack)
|
return
|
|
def DR_AuctionHouse(curPlayer, eventName, drDict):
|
# accID = "" if not curPlayer else curPlayer.GetAccID()
|
# playerID = 0 if not curPlayer else curPlayer.GetPlayerID()
|
# dataDict = {"EventName":eventName, "PlayerID":playerID, "AccID":accID}
|
# dataDict.update(drDict)
|
# DataRecordPack.SendEventPack("AuctionHouse", dataDict, curPlayer)
|
return
|
|
def DoAddFamilyAuctionItem(mapID, familyAuctionItemDict):
|
''' ÉϼÜÏÉÃËÅÄÆ·£¬ÒòΪÏÉÃËÅÄƷĬÈÏÉϼܣ¬ËùÒÔʹÓÃÅúÁ¿ÉϼÜ
|
@param familyAuctionItemDict: {ÏÉÃËID:[[ÏíÊÜÊÕÒæµÄ³ÉÔ±ID, ...], [[ÅÄÆ·ID,¸öÊý], [ÅÄÆ·ID,¸öÊý,ÊÇ·ñÅÄÆ·], ...]], ...}
|
'''
|
GameWorld.Log("·¢Ë͵ØͼÉϼÜÏÉÃËÅÄÆ·: mapID=%s, %s" % (mapID, familyAuctionItemDict))
|
GameWorld.SendMapServerMsgEx(ShareDefine.Def_Notify_WorldKey_AddFamilyAuctionItem, [mapID, familyAuctionItemDict])
|
return
|
|
def DoAddSystemAuctionItem(sysAuctionItemList):
|
''' ÉϼÜϵͳÅÄÆ·
|
@param sysAuctionItemList: [ÎïÆ·ID, [½×,ÑÕÉ«,[²¿Î», ...],ÊÇ·ñÌ××°,ÐǼ¶,[¿ÉÑ¡²ÎÊýÖ°Òµ, ...]], ...]
|
'''
|
mapID = ChConfig.Def_FBMapID_MainCity
|
GameWorld.Log("·¢Ë͵ØͼÉϼÜϵͳÅÄÆ·: mapID=%s, %s" % (mapID, sysAuctionItemList))
|
GameWorld.SendMapServerMsgEx(ShareDefine.Def_Notify_WorldKey_AddSystemAuctionItem, [mapID, sysAuctionItemList])
|
return
|
|
