#!/usr/bin/python
|
# -*- coding: GBK -*-
|
#
|
#
|
##@package PlayerBourse.py
|
#
|
# @todo:Íæ¼Ò½»Ò×Ëù¹ÜÀíÆ÷
|
#
|
# @author xmnathan
|
# @date 2010-01-01 21:30
|
# @version 1.5
|
# @note:
|
# @change: "2014-05-17 11:30" xmnathan Ôö¼Ó¿ª¹Ø
|
# @change: "2014-05-20 10:40" xmnathan Íæ¼Ò½»Ò×Ëù
|
# @change: "2014-05-21 20:00" xmnathan ÐÞÕý²éѯÊýÁ¿´íÎóµ¼Öµı¨´í
|
# @change: "2014-09-18 15:00" xmnathan Ôö¼Ó½»Ò×Á÷Ïò
|
# @change: "2014-10-20 18:00" xmnathan Ôö¼ÓÎïÆ·ÊÛ³ö²¹³¥ÓʼþÌáÐÑ
|
#------------------------------------------------------------------------------
|
"""Version = 2014-10-20 18:00"""
|
#------------------------------------------------------------------------------
|
import GameWorld
|
import IPY_GameServer
|
import ChGameToMapPyPack
|
import NetPackCommon
|
import datetime
|
import PlayerDBGSEvent
|
import CommFunc
|
import PlayerControl
|
import DataRecordPack
|
import IpyGameDataPY
|
import PyGameDataStruct
|
import PyDataManager
|
import ChPyNetSendPack
|
import PyGameData
|
|
import time
|
import json
|
|
|
g_lastSortTimeForQueryTypeDict = {} #¼Ç¼¶ÔÓ¦²éѯÀàÐÍÉϴθüÐÂ×ÓË÷ÒýÁбíʱ¼ä
|
g_dict_Of_QueryTypeIndexList = {} #´¢´æ¶ÔÓ¦²éѯÀàÐ͵ÄÅÅÐòÁбíµÄ×Öµä
|
|
Def_Bourse_Buy = 0 # ¹ºÂò
|
Def_Bourse_Sell = 1 # Âô³ö
|
|
#------------------------------------------------------------------------------
|
#½»Ò×Ëù״̬¿ª¹Ø
|
def GetOpenState():
|
BourseDefState = IpyGameDataPY.GetFuncCfg('BourseDefState')
|
return PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_BourseState, BourseDefState)
|
|
def SetOpenState(value):
|
PlayerDBGSEvent.SetDBGSTrig_ByKey(PlayerDBGSEvent.Def_BourseState, value > 0)
|
return
|
#------------------------------------------------------------------------------
|
|
##»ñÈ¡Ö¸¶¨²éѯÀàÐͶ¨ÒåÅäÖÃ
|
# @param queryType
|
# @return None
|
def GetBourseQueryTypeDefineDict(queryType):
|
BourseQueryTypeDict = IpyGameDataPY.GetConfigEx("BourseQueryTypeDict")
|
if BourseQueryTypeDict and queryType in BourseQueryTypeDict:
|
return BourseQueryTypeDict[queryType]
|
if not BourseQueryTypeDict:
|
BourseQueryTypeDict = {}
|
|
ipyData = IpyGameDataPY.GetIpyGameData('MarketQuery', queryType)
|
if not ipyData:
|
return {}
|
LimitInfo = ipyData.GetLimitInfo()
|
BourseQueryTypeDict[queryType] = LimitInfo
|
|
IpyGameDataPY.SetConfigEx("BourseQueryTypeDict", BourseQueryTypeDict)
|
return LimitInfo
|
|
#------------------------------------------------------------------------------
|
##1B 01 ²éѯÍæ¼Ò½»Ò×ËùÎïÆ· tagCGQueryPlayerBourseItem
|
# @param index
|
# @param tick
|
# @return None
|
def OnQueryPlayerBourseItem(index, tick):
|
if not GetOpenState():
|
return
|
GameWorld.GetPsycoFunc(__Func_QueryPlayerBourseItem)(index, tick)
|
return
|
|
##1B 01 ²éѯÍæ¼Ò½»Ò×ËùÎïÆ· tagCGQueryPlayerBourseItem
|
# @param index
|
# @param tick
|
# @return None
|
def __Func_QueryPlayerBourseItem(index, tick):
|
GameWorld.DebugLog("Bourse### QueryPlayerBourseItem in")
|
playerManager = GameWorld.GetPlayerManager()
|
curPlayer = playerManager.GetPlayerByIndex(index)
|
SyncPlayerBourseItem(curPlayer)
|
GameWorld.DebugLog("Bourse### QueryPlayerBourseItem out")
|
|
##²éѯÍæ¼Ò½»Ò×ËùÎïÆ·
|
# @param curPlayer
|
# @return None
|
def SyncPlayerBourseItem(curPlayer):
|
if not GetOpenState():
|
return
|
|
#֪ͨ¿Í»§¶ËÍæ¼Ò×Ô¼º¹Òµ¥ÎïÆ·Áбí
|
curPlayer.Sync_PlayerBourseItem()
|
return
|
|
def CheckPlayerEarnings(curPlayer):
|
##Íæ¼ÒÂô³öÎïÆ·ÊÕÒæ·¢·Å
|
curPlayerID = curPlayer.GetID()
|
bourseManager = GameWorld.GetBourseManager()
|
curPlayerItemCount = bourseManager.GetPlayerBourseItemCount(curPlayerID)
|
DelItemList = []
|
for i in xrange(curPlayerItemCount):
|
curBourseItemData = bourseManager.GetPlayerBourseItemByIndex(curPlayerID, i)
|
if not curBourseItemData:
|
continue
|
if curBourseItemData.GetIsSoldOut() and curBourseItemData.GetCustomerPlayerID() != 0 and \
|
curBourseItemData.GetCustomerPlayerID() != curBourseItemData.GetPlayerID():
|
if __GivePlayerBourseGains(curBourseItemData):
|
DelItemList.append(curBourseItemData.GetItemGUID())
|
|
for itemGUID in DelItemList:
|
bourseManager.DeleteByGUID(itemGUID)
|
return
|
|
## Íæ¼ÒµÇ¼
|
def OnPlayerLogin(curPlayer):
|
#֪ͨ½»Ò׼Ǽ
|
PyDataManager.GetBourseRecordManager().SyncBourseRecord(curPlayer, True)
|
#ÉÏÏß¼ì²éÂô³öµÄÎïÆ·¸øÂô¼ÒÊÕÒæ
|
CheckPlayerEarnings(curPlayer)
|
SyncPlayerBourseItem(curPlayer)
|
return
|
#------------------------------------------------------------------------------
|
##1B 05 ½»Ò×Ëù²éѯÉϼÜÎïÆ·#tagCGQueryBourseItemOnSale
|
# @param index
|
# @param tick
|
# @return None
|
def OnQueryBourseItemOnSale(index, tick):
|
if not GetOpenState():
|
return
|
GameWorld.GetPsycoFunc(__Func_QueryBourseItemOnSale)(index, tick)
|
return
|
|
##1B 05 ½»Ò×Ëù²éѯÉϼÜÎïÆ·#tagCGQueryBourseItemOnSale
|
# @param index
|
# @param tick
|
# @return None
|
def __Func_QueryBourseItemOnSale(index, tick):
|
return
|
|
#// B5 01 ½»Ò×Ëù²éѯÉϼÜÎïÆ·#tagCGPYQueryBourseItemOnSale
|
#
|
#struct tagCGPYQueryBourseItemOnSale
|
#{
|
# tagHead Head;
|
# DWORD QueryType; //²éѯµÄ·ÖÀà±êʶ
|
# char ItemName[33]; //ÎïÆ·Ãû£¨Ä£ºý²éѯ)
|
# DWORD ItemID; //ÎïÆ·ID
|
#};
|
def OnPYQueryBourseItemOnSale(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
queryType = clientData.QueryType
|
itemName = clientData.ItemName
|
itemID = clientData.ItemID
|
if itemName or itemID:
|
bourseManager = GameWorld.GetBourseManager()
|
bourseItemCount = bourseManager.Count()
|
|
#µ¹Ðò²éѯ,(×ܱí¸ù¾Ý²åÈëʱ¼äÅÅÐò£¬Ô½ÔçµÄÅÅÔÚԽǰÃæ)
|
bourseItemDataList = []
|
for i in xrange(bourseItemCount - 1, -1, -1):
|
curBourseItemData = bourseManager.At(i)
|
if CheckBourseItemDataSaleState(curBourseItemData):
|
continue
|
#GameWorld.Log("itemName=%s,curBourseItemData.GetItemName()=%s"%(itemName,curBourseItemData.GetItemName()))
|
if itemName and itemName in curBourseItemData.GetItemName():
|
bourseItemDataList.append(curBourseItemData)
|
continue
|
if itemID and itemID == curBourseItemData.GetItemTypeID():
|
bourseItemDataList.append(curBourseItemData)
|
continue
|
|
queryCount = len(bourseItemDataList)
|
curPlayer.Begin_AddBourseItemOnSale(queryType, 0, queryCount, queryCount)
|
for bourseItemData in bourseItemDataList:
|
curPlayer.Add_BourseItemOnSale(bourseItemData)
|
curPlayer.Sync_BourseItemOnSale()
|
if itemID: #Èç¹ûÊDzéѯIDµÄ£¬Í¬Ê±Í¨Öª¸ÃÎïÆ·µÄ×îгɽ»¼Û
|
PyDataManager.GetBourseItemLastPriceManager().SyncBourseItemPrice(curPlayer, itemID)
|
|
else:
|
#¸ù¾Ý²éѯÀàÐÍ»ñÈ¡ÏàÓ¦»õÆ·Áбí
|
queryTypeList = GetTypeList(queryType, tick)
|
queryTypeCount = len(queryTypeList) #²éѯµ½µÄÎïÆ·×ÜÊý
|
GameWorld.DebugLog("Bourse### QueryBourseItemOnSale queryTypeCount=%s, queryType=%s" % (queryTypeCount, queryType))
|
curPlayer.Begin_AddBourseItemOnSale(queryType, 0, queryTypeCount, queryTypeCount)
|
for i in xrange(queryTypeCount):
|
curPlayer.Add_BourseItemOnSale(queryTypeList[i])
|
|
curPlayer.Sync_BourseItemOnSale()
|
|
GameWorld.DebugLog("Bourse### QueryBourseItemOnSale out")
|
return
|
|
|
##»ñµÃÖ¸¶¨²éѯÀàÐ͵ĻõÆ·Áбí
|
# @param queryType
|
# @return queryTypeList
|
def GetTypeList(queryType, tick):
|
global g_lastSortTimeForQueryTypeDict
|
global g_dict_Of_QueryTypeIndexList
|
|
lastSortTick = g_lastSortTimeForQueryTypeDict.get(queryType, 0)
|
|
queryTypeList = g_dict_Of_QueryTypeIndexList.get(queryType, None)
|
Def_Sort_IndexList_Interval = IpyGameDataPY.GetFuncCfg('BourseUpdataCD') #Îå·ÖÖÓ¸üÐÂÒ»´Î×ÓË÷ÒýÁбí
|
if queryTypeList == None or tick - lastSortTick > Def_Sort_IndexList_Interval:
|
SortIndexList(queryType)#ÖØÐÂÅÅÐòÖ¸¶¨ÀàÐÍ
|
lastSortTick = tick
|
g_lastSortTimeForQueryTypeDict[queryType] = tick
|
|
return g_dict_Of_QueryTypeIndexList.get(queryType, [])
|
|
##¶ÔÖ¸¶¨ÀàÐ͵ÄË÷ÒýÁбí½øÐÐɸѡÅÅÐò
|
# @param queryType
|
# @return queryTypeList
|
def SortIndexList(queryType):
|
global g_dict_Of_QueryTypeIndexList
|
curQueryTypeList = []
|
bourseManager = GameWorld.GetBourseManager()
|
bourseItemCount = bourseManager.Count()
|
#µ¹Ðò²éѯ,(×ܱí¸ù¾Ý²åÈëʱ¼äÅÅÐò£¬Ô½ÔçµÄÅÅÔÚԽǰÃæ)
|
for index in xrange(bourseItemCount - 1, -1, -1):
|
curBourseItemData = bourseManager.At(index)
|
if CheckBourseItemDataSaleState(curBourseItemData):
|
continue
|
#¸ù¾ÝÌõ¼þɸѡÎïÆ·
|
if CheckQueryTypeItem(curBourseItemData, queryType):
|
curQueryTypeList.append(curBourseItemData)
|
|
g_dict_Of_QueryTypeIndexList[queryType] = curQueryTypeList
|
return
|
|
|
##¼ì²éÎïÆ·ÊÇ·ñ·ûºÏµ±Ç°ÀàÐÍɸѡÌõ¼þ
|
# @param curBourseItemData: ÎïƷʵÀý
|
# @return IsSoldOut
|
def CheckQueryTypeItem(curBourseItemData, queryType):
|
curDefineDict = GetBourseQueryTypeDefineDict(queryType)
|
if curDefineDict == {}:
|
return False
|
#Ö¸¶¨ÎïÆ·ID
|
SpecialItemIDList = curDefineDict.get("SpecialItemID", [])
|
if SpecialItemIDList:
|
if curBourseItemData.GetItemTypeID() not in SpecialItemIDList:
|
return False
|
#Ö¸¶¨ÎïÆ·ÀàÐÍ
|
ItemTypeList = curDefineDict.get("ItemType", [])
|
if ItemTypeList:
|
if curBourseItemData.GetType() not in ItemTypeList:
|
return False
|
#Ö¸¶¨×°±¸×°±¸Î»ÖÃ
|
EquipPlaceList = curDefineDict.get("EquipPlace", [])
|
if EquipPlaceList:
|
if curBourseItemData.GetEquipPlace() not in EquipPlaceList:
|
return False
|
#Ö¸¶¨Ê¹ÓÃÖ°Òµ
|
JobList = curDefineDict.get("Job", [])
|
if JobList:
|
JobLimit = curBourseItemData.GetJobLimit()
|
if JobLimit not in JobList:
|
return False
|
|
#Ö¸¶¨µÈ¼¶
|
LimitUseLV = curDefineDict.get("LimitUseLV", [])
|
if LimitUseLV:
|
if curBourseItemData.GetUseLV() not in LimitUseLV:
|
return False
|
|
#׿ԽÎïÆ·
|
ItemQuality = curDefineDict.get("ItemQuality", [])
|
if ItemQuality:
|
if curBourseItemData.GetItemQuality() not in ItemQuality:
|
return False
|
|
#Ì××°ÎïÆ·
|
# IsSuite = curDefineDict.get("IsSuite", [])
|
# if IsSuite:
|
# if curBourseItemData.GetIsSuite() not in IsSuite:
|
# return False
|
return True
|
|
|
#------------------------------------------------------------------------------
|
##¼ì²é¹Òµ¥ÎïÆ·ÊÇ·ñ³¬Ê±
|
# @param curBourseItemData: ÎïƷʵÀý
|
# @return IsSoldOut
|
def CheckBourseItemDataSaleState(curBourseItemData):
|
if curBourseItemData.GetIsSoldOut():
|
return True
|
|
return False
|
|
|
##»ñµÃÓëÏÖʵʱ¼ä²î¾àµÄ·ÖÖÓÊý
|
# @param compareTimeStr ±È½Ïʱ¼ä×Ö·û Èç"2010-05-26 11:21:25"
|
# @return ·µ»ØÖµ, Ïà²îµÄ·ÖÖÓÊý
|
# @remarks »ñµÃÓëÏÖʵʱ¼ä²î¾àµÄ·ÖÖÓÊý
|
def GetPastMinute(compareTimeStr):
|
curDataTime = datetime.datetime.today()
|
compareDataTime = GameWorld.GetDateTimeByStr(compareTimeStr)
|
if curDataTime == None or compareDataTime == None:
|
return 0
|
pastTimeDelta = curDataTime - compareDataTime
|
#ÌìÊý * 24Сʱ * 60 ·ÖÖÓ + Ãë / 60
|
return pastTimeDelta.days * 24 * 60 + pastTimeDelta.seconds / 60
|
#------------------------------------------------------------------------------
|
#//02 01 ѯÎÊÊÇ·ñ¿ÉÒÔÌí¼ÓÍæ¼Ò½»Ò×ËùÎïÆ·#tagMGCheckAddPlayerBourseItem
|
#{
|
#tagHead Head;
|
#DWORD PlayerID;
|
#BYTE ItemIndex; //ÎïÆ·ÔÚ±³°üÖÐË÷Òý
|
#WORD Count; //³öÊÛÊýÁ¿
|
#BYTE PriceType; //³öÊÛ¼Û¸ñÀàÐÍ
|
#DWORD PriceCount;//³öÊÛ¼Û¸ñ
|
#char Pwd[8]; //½»Ò×ÃÜÂë
|
#};
|
##//02 01 ѯÎÊÊÇ·ñ¿ÉÒÔÌí¼ÓÍæ¼Ò½»Ò×ËùÎïÆ·#tagMGCheckAddPlayerBourseItem
|
# @param routeIndex, mapID, curPackData, tick
|
# @return None
|
def OnMGCheckAddPlayerBourseItem(routeIndex, mapID, curPackData, tick):
|
GameWorld.DebugLog("Bourse### MGCheckAddPlayerBourseItem in,PlayerID %s" % curPackData.PlayerID)
|
if not GetOpenState():
|
return
|
GameWorld.DebugLog("Bourse### MGCheckAddPlayerBourseItem PlayerID=%s ItemIndex=%s Count=%s PriceType=%s PriceCount=%s" % (curPackData.PlayerID,
|
curPackData.ItemIndex, curPackData.Count, curPackData.PriceType, curPackData.PriceCount))
|
curPlayerID = curPackData.PlayerID
|
bourseManager = GameWorld.GetBourseManager()
|
count = bourseManager.GetPlayerBourseItemCount(curPlayerID)
|
GameWorld.DebugLog("Bourse### MGCheckAddPlayerBourseItem now count %s" % count)
|
BourseCountLimit = IpyGameDataPY.GetFuncCfg('BourseSaleLimit')
|
|
#//02 01 ²éѯÍæ¼ÒÊÇ·ñ¿ÉÒÔÌí¼Ó½»Ò×ËùÎïÆ·½á¹û#tagGMCheckAddPlayerBourseItemResult
|
sendPack = ChGameToMapPyPack.tagGMCheckAddPlayerBourseItemResult()
|
sendPack.PlayerID = curPlayerID
|
sendPack.ItemIndex = curPackData.ItemIndex
|
sendPack.Count = curPackData.Count
|
sendPack.PriceType = curPackData.PriceType
|
sendPack.PriceCount = curPackData.PriceCount
|
sendPack.Pwd = curPackData.Pwd
|
sendPack.Result = (count < BourseCountLimit) #·µ»Ø¿É·ñ¼ÌÐøÌí¼Ó
|
NetPackCommon.SendPyPackToMapServer(routeIndex, mapID, sendPack)
|
GameWorld.DebugLog("Bourse### MGCheckAddPlayerBourseItem out Result %s" % sendPack.Result)
|
return
|
|
##//02 02 Íæ¼Ò½»Ò×ËùÌí¼Ó³öÊÛµÄÎïÆ·#tagMGAddPlayerSellBourseItem
|
# @param routeIndex, mapID, curPackData, tick
|
# @return None
|
def OnMGAddPlayerSellBourseItem(routeIndex, mapID, curPackData, tick):
|
GameWorld.DebugLog("Bourse### MGAddPlayerSellBourseItem in")
|
if not GetOpenState():
|
return
|
GameWorld.DebugLog("Bourse### MGAddPlayerSellBourseItem PlayerID %s" % (curPackData.PlayerID))
|
curPlayerID = curPackData.PlayerID
|
bourseManager = GameWorld.GetBourseManager()
|
|
curBourseRoleItem = IPY_GameServer.IpyBourseRoleItem()
|
curBourseRoleItem.Count = curPackData.Count
|
curBourseRoleItem.ItemID = curPackData.ItemTypeID
|
curBourseRoleItem.UserData = curPackData.UserData
|
|
#GameWorld.DebugLog("Bourse### OnMGAddPlayerSellBourseItem UserData Src =¡¾%s¡¿ Des=¡¾%s¡¿"%(curPackData.UserData, curBourseRoleItem.UserData))
|
|
curBourseItem = bourseManager.AddItem(curPlayerID, curPackData.PlayerName, curBourseRoleItem)
|
|
#ÉèÖóöÊÛ¼Û¸ñ
|
curBourseItem.SetPriceType(curPackData.PriceType)
|
curBourseItem.SetPriceCount(curPackData.PriceCount)
|
#´¢´æÐèÒªÓõ½µÄϵͳ±íÊý¾Ý
|
curBourseItem.SetType(curPackData.Type)
|
curBourseItem.SetEquipPlace(curPackData.EquipPlace)
|
curBourseItem.SetLV(curPackData.LV)
|
curBourseItem.SetUseLV(curPackData.UseLV)
|
curBourseItem.SetJobLimit(curPackData.JobLimit)
|
curBourseItem.SetItemQuality(curPackData.ItemQuality)
|
curBourseItem.SetItemColor(curPackData.ItemColor)
|
curBourseItem.SetItemTypeID(curPackData.ItemTypeID)
|
curBourseItem.SetItemName(curPackData.ItemName.strip())
|
curBourseItem.SetPwd(curPackData.Pwd.strip())
|
curBourseItem.SetEquipGS(curPackData.EquipGS)
|
curBourseItem.SetOperateInfo(curPackData.OperateInfo)
|
#ÉèÖóöÊÛʱ¼ä
|
curBourseItem.SetOnSaleTime(GameWorld.GetCurrentDataTimeStr())
|
curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(curPlayerID)
|
if curPlayer:
|
#֪ͨ¿Í»§¶Ë Íæ¼Ò×Ô¼ºµÄ½»Ò×Æ·
|
SyncPlayerBourseItem(curPlayer)
|
#Á÷Ïò¼Ç¼
|
DataRecordPack.DR_BourseAddItem(curPlayerID, curBourseItem)
|
GameWorld.DebugLog("Bourse### MGAddPlayerSellBourseItem out")
|
return
|
#------------------------------------------------------------------------------
|
##//02 03 Íæ¼ÒѯÎʹºÂò½»Ò×ËùÎïÆ·#tagMGCheckBuyBourseItem
|
# @param routeIndex, mapID, curPackData, tick
|
# @return None
|
def OnMGCheckBuyBourseItem(routeIndex, mapID, curPackData, tick):
|
GameWorld.DebugLog("Bourse### MGCheckBuyBourseItem in, PlayerID %s" % curPackData.PlayerID)
|
if not GetOpenState():
|
return
|
bourseManager = GameWorld.GetBourseManager()
|
curBourseItem = bourseManager.FindByGUID(curPackData.ItemGUID)
|
if not curBourseItem:
|
#ÎïÆ·²»´æÔÚ
|
curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(curPackData.PlayerID)
|
if curPlayer:
|
PlayerControl.NotifyCode(curPlayer, "GeRen_liubo_403656")
|
GameWorld.DebugLog("Bourse### MGCheckBuyBourseItem ItemGUID %s No Found" % (curPackData.ItemGUID))
|
return
|
|
if curBourseItem.GetPlayerID() == curPackData.PlayerID:
|
#ÊÇ×Ô¼ºµÄ¶«Î÷ ²»ÄÜÂò
|
GameWorld.DebugLog("Bourse### MGCheckBuyBourseItem ItemGUID %s is SelfItem" % (curPackData.ItemGUID))
|
return
|
if curBourseItem.GetIsSoldOut():
|
#ÎïÆ·ÒÑÊÛ³ö
|
curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(curPackData.PlayerID)
|
if curPlayer:
|
PlayerControl.NotifyCode(curPlayer, "GeRen_liubo_403656")
|
GameWorld.DebugLog("Bourse### MGCheckBuyBourseItem ItemGUID %s is SoldOut" % (curPackData.ItemGUID))
|
return
|
#¼ì²é½»Ò×ÃÜÂë
|
if curBourseItem.GetPwd().strip() != curPackData.Pwd.strip():
|
curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(curPackData.PlayerID)
|
if curPlayer:
|
PlayerControl.NotifyCode(curPlayer, "BoursePasswordError")
|
GameWorld.DebugLog("Bourse### MGCheckBuyBourseItem ItemGUID %s pwd is error! %s != %s" % (curPackData.ItemGUID, curBourseItem.GetPwd(), curPackData.Pwd))
|
return
|
#ÎïÆ·½»Ò×Ëø¶¨×´Ì¬ÅжÏ
|
curTime = int(time.time())
|
if curPackData.ItemGUID in PyGameData.g_bourseItemTradingTimeDict:
|
if curTime - PyGameData.g_bourseItemTradingTimeDict.get(curPackData.ItemGUID, 0) < 10:
|
curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(curPackData.PlayerID)
|
if curPlayer:
|
PlayerControl.NotifyCode(curPlayer, "MarketNoPutaway5")
|
return
|
PyGameData.g_bourseItemTradingTimeDict[curPackData.ItemGUID] = curTime
|
|
#//02 02 Íæ¼Ò¹ºÂò½»Ò×ËùÎïÆ·²éѯ½á¹û#tagGMCheckBuyBourseItemResult
|
sendPack = ChGameToMapPyPack.tagGMCheckBuyBourseItemResult()
|
sendPack.PlayerID = curPackData.PlayerID
|
sendPack.ItemGUID = curPackData.ItemGUID
|
sendPack.PriceType = curBourseItem.GetPriceType()
|
sendPack.PriceCount = curBourseItem.GetPriceCount()
|
sendPack.ItemName = curBourseItem.GetItemName()
|
|
NetPackCommon.SendPyPackToMapServer(routeIndex, mapID, sendPack)
|
GameWorld.DebugLog("Bourse### MGCheckBuyBourseItem out")
|
return
|
|
|
##//02 04 Íæ¼ÒÈ·ÈϹºÂò½»Ò×ËùÎïÆ·#tagMGBuyBourseItemSure
|
# @param routeIndex, mapID, curPackData, tick
|
# @return None
|
def OnMGBuyBourseItemSure(routeIndex, mapID, curPackData, tick):
|
GameWorld.DebugLog("Bourse### MGBuyBourseItemSure in, PlayerID %s" % curPackData.PlayerID)
|
if not GetOpenState():
|
return
|
curPlayerID = curPackData.PlayerID
|
bourseManager = GameWorld.GetBourseManager()
|
curBourseItem = bourseManager.FindByGUID(curPackData.ItemGUID)
|
if not curBourseItem:
|
#ÎïÆ·²»´æÔÚ
|
GameWorld.Log("Íæ¼ÒÈ·ÈϹºÂò½»Ò×ËùÎïÆ· ÒѸ¶Ç®£¡£¬Bourse### MGBuyBourseItemSure ItemGUID %s No Found" % (curPackData.ItemGUID), curPlayerID)
|
return
|
|
if CheckBourseItemDataSaleState(curBourseItem):
|
GameWorld.Log("Íæ¼ÒÈ·ÈϹºÂò½»Ò×ËùÎïÆ· Bourse### MGBuyBourseItemSure ItemGUID %s SoldOut" % (curPackData.ItemGUID), curPlayerID)
|
return
|
if not curPackData.PlayerName: #Ϊ¿Õʱ´ú±íµØͼÅжϹºÂòʧ°Ü
|
PyGameData.g_bourseItemTradingTimeDict.pop(curPackData.ItemGUID, 0)
|
return
|
|
#¸øÎïÆ·//02 03 Íæ¼Ò»ñÈ¡½»Ò×ËùÎïÆ·½á¹û#tagGMGiveBourseItem
|
sendPack = GetGMGiveBourseItemPack(curPlayerID, curBourseItem)
|
NetPackCommon.SendPyPackToMapServer(routeIndex, mapID, sendPack)
|
#ÉèÖý»Ò×ƷΪÒÑÊÛ³ö״̬
|
curBourseItem.SetIsSoldOut(True)
|
curBourseItem.SetCustomerPlayerID(curPlayerID)
|
curBourseItem.SetCustomerPlayerName(curPackData.PlayerName)
|
soldOutTime = int(time.time())
|
curBourseItem.SetSoldOutTime(str(soldOutTime))
|
PyGameData.g_bourseItemTradingTimeDict.pop(curPackData.ItemGUID, 0)
|
#֪ͨ¹Ë¿Í¹ºÂòÎïƷ״̬±ä¸ü
|
curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(curPlayerID)
|
if curPlayer:
|
curPlayer.Begin_AddBourseItemOnSale(255, 0, 1, 1)
|
curPlayer.Add_BourseItemOnSale(curBourseItem)
|
curPlayer.Sync_BourseItemOnSale()
|
|
|
#¸üÐÂ×îгɽ»µ¥¼Û
|
unitPrice = curBourseItem.GetPriceCount() * 1.0 / curBourseItem.GetBourseRoleItem().Count
|
unitPrice = 200000000 if unitPrice < 1 else int(unitPrice) #200000000ÓÃÀ´´ú±í<1
|
PyDataManager.GetBourseItemLastPriceManager().UpdateBourseItemPrice(curBourseItem.GetItemTypeID(), unitPrice)
|
bourseRecordMgr = PyDataManager.GetBourseRecordManager()
|
curRoleItemData = curBourseItem.GetBourseRoleItem()
|
itemInfo = {"itemID":curRoleItemData.ItemID, "userData":curRoleItemData.UserData, "equipGS":curBourseItem.GetEquipGS(), "count":curRoleItemData.Count}
|
bourseRecordMgr.AddBourseRecord(curPlayerID, Def_Bourse_Buy, soldOutTime, itemInfo, 0, curBourseItem.GetPriceCount())
|
sellPlayerID = curBourseItem.GetPlayerID()
|
|
##Á÷Ïò¼Ç¼
|
DataRecordPack.DR_BourseBuyItem(curPlayerID, curBourseItem.GetPlayerID(), curBourseItem)
|
if __GivePlayerBourseGains(curBourseItem):
|
bourseManager.DeleteByGUID(curBourseItem.GetItemGUID())
|
|
curSellPlayer = GameWorld.GetPlayerManager().FindPlayerByID(sellPlayerID)
|
if curSellPlayer:
|
#Íæ¼ÒÔÚÏß Ë¢ÐÂÍæ¼Ò½»Ò×ËùÎïÆ·
|
SyncPlayerBourseItem(curSellPlayer)
|
|
GameWorld.DebugLog("Bourse### MGBuyBourseItemSure out ItemGUID %s" % (curPackData.ItemGUID))
|
return
|
|
def __GivePlayerBourseGains(curBourseItem):
|
##¶«Î÷Âô³ö£¬·¢ÖÁmapServer¸øÊÕÒæ
|
curPlayerID = curBourseItem.GetPlayerID()
|
curSellPlayer = GameWorld.GetPlayerManager().FindPlayerByID(curPlayerID)
|
if not curSellPlayer:
|
return
|
#¸øÇ®
|
curRoleItemData = curBourseItem.GetBourseRoleItem()
|
itemInfo = {"itemID":curRoleItemData.ItemID, "userData":curRoleItemData.UserData, "equipGS":curBourseItem.GetEquipGS(), "count":curRoleItemData.Count}
|
priceCount = curBourseItem.GetPriceCount()
|
priceType = curBourseItem.GetPriceType()
|
itemName = curBourseItem.GetItemName()
|
soldOutTime = GameWorld.ToIntDef(curBourseItem.GetSoldOutTime(), 0)
|
result = str([priceType, priceCount, itemName, soldOutTime, itemInfo])
|
curSellPlayer.MapServer_QueryPlayerResult(0, 0, "GivePlayerBourseGains", result, len(result))
|
|
#֪ͨÍæ¼Ò½»Ò×ËùÎïÆ·±ä¸ü
|
#SyncPlayerBourseItem(curSellPlayer)
|
return True
|
|
def OnGivePlayerBourseGainsResult(curPlayer, resultInfo):
|
#±£´æ½»Ò׼Ǽ
|
soldOutTime, taxMoney, giveMoney, itemInfo = resultInfo
|
bourseRecordMgr = PyDataManager.GetBourseRecordManager()
|
bourseRecordMgr.AddBourseRecord(curPlayer.GetID(), Def_Bourse_Sell, soldOutTime, itemInfo, taxMoney, giveMoney)
|
|
DataRecordPack.DR_BourseGiveGains(curPlayer.GetID(), itemInfo, giveMoney, taxMoney)
|
return
|
|
#------------------------------------------------------------------------------
|
##//02 05 ½»Ò×ËùÍæ¼ÒÈ¡ÏÂÕýÔÚ³öÊÛµÄÎïÆ·»ò³öÊÛÊÕÒæ#tagMGPlayerRecaptureBourseItem
|
# @param routeIndex, mapID, curPackData, tick
|
# @return None
|
def OnMGPlayerRecaptureBourseItem(routeIndex, mapID, curPackData, tick):
|
GameWorld.DebugLog("Bourse### MGPlayerRecaptureBourseItem in PlayerID %s ItemGUID %s" % (curPackData.PlayerID, curPackData.ItemGUID))
|
if not GetOpenState():
|
return
|
curPlayerID = curPackData.PlayerID
|
bourseManager = GameWorld.GetBourseManager()
|
|
curBourseItem = bourseManager.FindByGUID(curPackData.ItemGUID)
|
if not curBourseItem:
|
#ÎïÆ·²»´æÔÚ
|
GameWorld.DebugLog("Bourse### MGPlayerRecaptureBourseItem ItemGUID %s No Found" % (curPackData.ItemGUID))
|
return
|
|
if curBourseItem.GetPlayerID() != curPlayerID:
|
#²»ÊÇ×Ô¼ºµÄ¶«Î÷ ²»ÄÜÈ¡»Ø
|
GameWorld.DebugLog("Bourse### MGPlayerRecaptureBourseItem ItemGUID %s not belong to Player %s" % (curPackData.ItemGUID, curPlayerID))
|
return
|
if curBourseItem.GetIsSoldOut() and curBourseItem.GetCustomerPlayerID() != 0 and \
|
curBourseItem.GetCustomerPlayerID() != curBourseItem.GetPlayerID():
|
|
#¸øÇ®//02 04 Íæ¼Ò»ñµÃ½»Ò×ËùÊÕÒæ#tagGMGivePlayerBourseGains
|
# sendPack = ChGameToMapPyPack.tagGMGivePlayerBourseGains()
|
# sendPack.PlayerID = curPlayerID
|
# sendPack.MoneyType = curBourseItem.GetPriceType()
|
# sendPack.MoneyCount = curBourseItem.GetPriceCount()
|
# NetPackCommon.SendPyPackToMapServer(routeIndex, mapID, sendPack)
|
# ##Á÷Ïò¼Ç¼
|
# DataRecordPack.DR_BourseGiveGains(curPlayerID, curBourseItem)
|
GameWorld.DebugLog("Bourse### MGPlayerRecaptureBourseItem ItemGUID %s GivePlayerBourseGains" % (curPackData.ItemGUID))
|
else:
|
if curPackData.PackSpaceCount <= 0:
|
#Íæ¼Ò±³°ü¿Õ¼ä²»×ã ²»ÄܸøÎïÆ·
|
GameWorld.DebugLog("Bourse### MGPlayerRecaptureBourseItem PlayerID %s noSpaceCount" % curPlayerID)
|
return
|
#¸øÎïÆ·//02 03 Íæ¼Ò»ñÈ¡½»Ò×ËùÎïÆ·½á¹û#tagGMGiveBourseItem
|
sendPack = GetGMGiveBourseItemPack(curPlayerID, curBourseItem)
|
NetPackCommon.SendPyPackToMapServer(routeIndex, mapID, sendPack)
|
##Á÷Ïò¼Ç¼
|
DataRecordPack.DR_BourseCancelItem(curPlayerID, curBourseItem)
|
GameWorld.DebugLog("Bourse### MGPlayerRecaptureBourseItem ItemGUID %s GiveBourseItem" % (curPackData.ItemGUID))
|
|
#ɾ³ý½»Ò×Æ·
|
bourseManager.DeleteByGUID(curPackData.ItemGUID)
|
|
curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(curPlayerID)
|
if curPlayer:
|
#֪ͨÍæ¼Ò½»Ò×ËùÎïÆ·±ä¸ü
|
SyncPlayerBourseItem(curPlayer)
|
GameWorld.DebugLog("Bourse### MGPlayerRecaptureBourseItem out")
|
return
|
|
##¸ù¾Ý½»Ò×ËùÎïÆ·»ñÈ¡¸øÎïÆ··â°ü//02 03 Íæ¼Ò»ñÈ¡½»Ò×ËùÎïÆ·½á¹û#tagGMGiveBourseItem
|
# @param curPlayerID, curBourseItem
|
# @return sendPack
|
def GetGMGiveBourseItemPack(curPlayerID, curBourseItem):
|
#//02 03 Íæ¼Ò»ñÈ¡½»Ò×ËùÎïÆ·½á¹û#tagGMGiveBourseItem
|
sendPack = ChGameToMapPyPack.tagGMGiveBourseItem()
|
sendPack.PlayerID = curPlayerID
|
sendPack.ItemGUID = curBourseItem.GetItemGUID()
|
sendPack.PriceType = curBourseItem.GetPriceType()
|
sendPack.PriceCount = curBourseItem.GetPriceCount()
|
if curPlayerID == curBourseItem.GetPlayerID():
|
sendPack.PriceType = 0
|
sendPack.PriceCount = 0 #×Ô¼ºµÄ¶«Î÷ ²»Óø¶Ç®
|
curRoleItemData = curBourseItem.GetBourseRoleItem()
|
sendPack.ItemID = curRoleItemData.ItemID
|
sendPack.Count = curRoleItemData.Count
|
sendPack.UserData = curRoleItemData.UserData
|
sendPack.UserDataLen = len(curRoleItemData.UserData)
|
sendPack.EquipGS = curBourseItem.GetEquipGS()
|
return sendPack
|
|
#------------------------------------------------------------------------------
|
##УÑé¹ýÆÚ¹ý¾ÃÎïÆ·´¦Àí
|
# @param None
|
# @return None
|
def OverTimeItemsDeal():
|
BourseSaleTimeMinute = IpyGameDataPY.GetFuncCfg('BourseSaleLimit', 2)
|
|
DelItemDict = {}
|
bourseManager = GameWorld.GetBourseManager()
|
bourseItemCount = bourseManager.Count()
|
#µ¹Ðò²éѯ,(×ܱí¸ù¾Ý²åÈëʱ¼äÅÅÐò£¬Ô½ÔçµÄÅÅÔÚԽǰÃæ)
|
for index in xrange(bourseItemCount - 1, -1, -1):
|
curBourseItemData = bourseManager.At(index)
|
if CheckBourseItemDataSaleState(curBourseItemData):
|
#ÎïÆ·ÒѳöÊÛ״̬
|
continue
|
# if curBourseItemData.GetPlayerID() != curBourseItemData.GetCustomerPlayerID():
|
# #¹ºÂòÕßΪ³öÊÛÕß×Ô¼º
|
# continue
|
#УÑéÊÇ·ñ³¬Ê±
|
pastMinute = GetPastMinute(curBourseItemData.GetOnSaleTime())
|
if pastMinute < BourseSaleTimeMinute:
|
continue
|
#ÕÒµ½³¬Ê±ÒѾõÄÎïÆ·£¬É¾³ýÎïÆ·£¬·¢Ë͵½ÓʼþÖÐ
|
sellPlayerID = curBourseItemData.GetPlayerID()
|
bourseRoleItem = curBourseItemData.GetBourseRoleItem()
|
addItemList = []
|
curItemDict = {}
|
curItemDict['ItemID'] = curBourseItemData.GetItemTypeID()
|
curItemDict['Count'] = bourseRoleItem.Count
|
curItemDict['UserData'] = bourseRoleItem.UserData
|
|
addItemList.append(curItemDict)
|
GUID = curBourseItemData.GetItemGUID()
|
if sellPlayerID in DelItemDict:
|
DelItemDict[sellPlayerID].append(GUID)
|
else:
|
DelItemDict[sellPlayerID] = [GUID]
|
#Á÷Ïò¼Ç¼
|
DataRecordPack.DR_BourseDeleteOverTimeLongItem(sellPlayerID, GUID, curBourseItemData)
|
|
#½«ÎïÆ··¢Ë͵½²¹³¥ÓʼþÖÐ
|
SendOverTimeItemMail(sellPlayerID, GUID, addItemList)
|
|
#ÒƳý¸Ã½»Ò×ËùÎïÆ·
|
for sellPlayerID, itemGUIDList in DelItemDict.items():
|
for itemGUID in itemGUIDList:
|
bourseManager.DeleteByGUID(itemGUID)
|
curSellPlayer = GameWorld.GetPlayerManager().FindPlayerByID(sellPlayerID)
|
if curSellPlayer:
|
#Íæ¼ÒÔÚÏß Ë¢ÐÂÍæ¼Ò½»Ò×ËùÎïÆ·
|
SyncPlayerBourseItem(curSellPlayer)
|
return
|
|
|
|
##·¢Ë͹ýÆÚ¹ý¾ÃÎïÆ·µ½Óʼþ
|
# @param sellPlayerID, addItemList
|
# @return None
|
def SendOverTimeItemMail(sellPlayerID, GUID, addItemList):
|
import PlayerCompensation
|
|
PlayerCompensation.SendMailByKey('BourseTimeOut', [sellPlayerID], addItemList, [])
|
return
|
|
|
|
# ½»Ò×Ëù¼Ç¼¹ÜÀí
|
class BourseRecordManager(object):
|
|
maxRecord = IpyGameDataPY.GetFuncCfg("BourseMaxRecord") # ÿÈ˼Ǽ×î´óÊýÁ¿
|
|
def __init__(self):
|
self.BourseRecord = {} # {playerID:[record,..], ...} PyGameDataStruct.tagDBPyBourseRecord
|
return
|
|
def AddBourseRecord(self, playerID, tradeType, soldOutTime, itemInfo, taxMoney, giveMoney):
|
if not self.maxRecord:
|
return
|
|
recordList = self.BourseRecord.get(playerID, [])
|
if len(recordList) == self.maxRecord:
|
del recordList[0] #ɾ³ýµÚÒ»Ìõ¼Ç¼
|
|
|
userData = json.dumps(itemInfo, ensure_ascii=False)
|
|
record = PyGameDataStruct.tagDBPyBourseRecord()
|
record.clear()
|
record.PlayerID = playerID
|
record.Type = tradeType
|
record.Timestamp = soldOutTime#int(time.time())
|
record.TradeTax = taxMoney
|
record.TradeMoney = giveMoney
|
record.UserData = userData
|
record.UserDataLen = len(record.UserData)
|
recordList.append(record)
|
|
self.BourseRecord[playerID] = recordList
|
GameWorld.DebugLog("AddBourseRecord playerID=%s,tradeType=%s,userData=%s"
|
% (playerID, tradeType, userData), playerID)
|
|
# ͬ²½¿Í»§¶Ë
|
curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID)
|
if curPlayer:
|
self.SyncBourseRecord(curPlayer)
|
return True
|
|
|
def SyncBourseRecord(self, curPlayer, isAll=False):
|
'''
|
@param isAll: ÊÇ·ñÈ«²¿
|
'''
|
playerID = curPlayer.GetPlayerID()
|
recordList = self.BourseRecord.get(playerID, [])
|
syncList = recordList if isAll else [recordList[-1]]
|
if not syncList:
|
return
|
|
recordInfo = ChPyNetSendPack.tagGCBourseRecordInfo()
|
recordInfo.Clear()
|
recordInfo.RecordList = []
|
for syncRecord in syncList:
|
record = ChPyNetSendPack.tagGCBourseRecord()
|
record.Clear()
|
record.Type = syncRecord.Type
|
record.Timestamp = syncRecord.Timestamp
|
record.TradeTax = syncRecord.TradeTax
|
record.TradeMoney = syncRecord.TradeMoney
|
record.ItemData = syncRecord.UserData
|
record.ItemDataLen = len(record.ItemData)
|
recordInfo.RecordList.append(record)
|
recordInfo.Count = len(recordInfo.RecordList)
|
NetPackCommon.SendFakePack(curPlayer, recordInfo)
|
return
|
|
# ±£´æÊý¾Ý ´æÊý¾Ý¿âºÍrealtimebackup
|
def GetSaveData(self):
|
savaData = ""
|
cntData = ""
|
cnt = 0
|
for recordList in self.BourseRecord.values():
|
for record in recordList:
|
cnt += 1
|
savaData += record.getBuffer()
|
|
GameWorld.Log("SaveBourseRecord cnt :%s len=%s" % (cnt, len(savaData)))
|
return CommFunc.WriteDWORD(cntData, cnt) + savaData
|
|
# ´ÓÊý¾Ý¿âÔØÈëºÃÓÑÊý¾Ý
|
def LoadPyGameData(self, datas, pos, dataslen):
|
cnt, pos = CommFunc.ReadDWORD(datas, pos)
|
GameWorld.Log("LoadBourseRecord cnt :%s" % cnt)
|
|
self.BourseRecord = {}
|
|
for _ in xrange(cnt):
|
record = PyGameDataStruct.tagDBPyBourseRecord()
|
record.clear()
|
pos += record.readData(datas, pos, dataslen)
|
|
playerID = record.PlayerID
|
recordList = self.BourseRecord.get(playerID, [])
|
recordList.append(record)
|
self.BourseRecord[playerID] = recordList
|
|
return pos
|
|
# ½»Ò×ËùÎïÆ·×î½ü³É½»µ¥¼Û¹ÜÀí
|
class BourseItemLastPriceManager(object):
|
|
def __init__(self):
|
self.ItemLastPriceDict = {} # {itemid:price, ...} PyGameDataStruct.tagDBPyBourseItemLastPrice
|
return
|
|
def UpdateBourseItemPrice(self, itemid, price):
|
itemLastPrice = PyGameDataStruct.tagDBPyBourseItemLastPrice()
|
itemLastPrice.clear()
|
itemLastPrice.ItemID = itemid
|
itemLastPrice.LastPrice = price
|
self.ItemLastPriceDict[itemid] = itemLastPrice
|
|
GameWorld.DebugLog("¸üн»Ò×ËùÎïÆ·×îгɽ»µ¥¼Û itemid=%s,price=%s" % (itemid, price))
|
return
|
|
|
def SyncBourseItemPrice(self, curPlayer, itemID):
|
priceData = self.ItemLastPriceDict.get(itemID, None)
|
if not priceData:
|
return
|
|
priceInfo = ChPyNetSendPack.tagGCBourseItemPrice()
|
priceInfo.Clear()
|
priceInfo.ItemID = priceData.ItemID
|
priceInfo.Price = priceData.LastPrice
|
NetPackCommon.SendFakePack(curPlayer, priceInfo)
|
return
|
|
# ±£´æÊý¾Ý ´æÊý¾Ý¿âºÍrealtimebackup
|
def GetSaveData(self):
|
savaData = ""
|
cntData = ""
|
cnt = 0
|
for itemLastPrice in self.ItemLastPriceDict.values():
|
cnt += 1
|
savaData += itemLastPrice.getBuffer()
|
|
GameWorld.Log("SaveBourseItemLastPrice cnt :%s len=%s" % (cnt, len(savaData)))
|
return CommFunc.WriteDWORD(cntData, cnt) + savaData
|
|
# ´ÓÊý¾Ý¿âÔØÈëºÃÓÑÊý¾Ý
|
def LoadPyGameData(self, datas, pos, dataslen):
|
cnt, pos = CommFunc.ReadDWORD(datas, pos)
|
GameWorld.Log("LoadBourseItemLastPrice cnt :%s" % cnt)
|
|
self.ItemLastPriceDict = {}
|
|
for _ in xrange(cnt):
|
data = PyGameDataStruct.tagDBPyBourseItemLastPrice()
|
data.clear()
|
pos += data.readData(datas, pos, dataslen)
|
itemid = data.ItemID
|
self.ItemLastPriceDict[itemid] = data
|
|
return pos
|
