forked from metin2/server
1379 lines
33 KiB
C++
1379 lines
33 KiB
C++
#include "stdafx.h"
|
||
#ifdef __AUCTION__
|
||
|
||
#include "desc_client.h"
|
||
#include "desc_manager.h"
|
||
#include "buffer_manager.h"
|
||
#include "packet.h"
|
||
#include "char.h"
|
||
#include "char_manager.h"
|
||
#include "item_manager.h"
|
||
#include "log.h"
|
||
#include "db.h"
|
||
#include <boost/bind.hpp>
|
||
#include "item.h"
|
||
#include "desc_client.h"
|
||
#include <common/tables.h>
|
||
#include "protocol.h"
|
||
#include "auction_manager.h"
|
||
extern int auction_server;
|
||
|
||
const char* auction_table_name [_AUCTION_MAX] = {"auction", "wish_auction", "my_auction", "my_wish_auction"};
|
||
|
||
bool CompareItemInfoByItemNameAC (TAuctionItemInfo* i, TAuctionItemInfo* j)
|
||
{
|
||
return (strcmp (i->item_proto->szLocaleName, j->item_proto->szLocaleName) < 0);
|
||
}
|
||
|
||
bool CompareItemInfoByItemNameDC (TAuctionItemInfo* i, TAuctionItemInfo* j)
|
||
{
|
||
return (strcmp (i->item_proto->szLocaleName, j->item_proto->szLocaleName) > 0);
|
||
}
|
||
|
||
bool CompareItemInfoByCategoryAC (TAuctionItemInfo* i, TAuctionItemInfo* j)
|
||
{
|
||
return (i->item_proto->bType < j->item_proto->bType);
|
||
}
|
||
|
||
bool CompareItemInfoByCategoryDC (TAuctionItemInfo* i, TAuctionItemInfo* j)
|
||
{
|
||
return (i->item_proto->bType > j->item_proto->bType);
|
||
}
|
||
|
||
bool CompareItemInfoByTimeAC (TAuctionItemInfo* i, TAuctionItemInfo* j)
|
||
{
|
||
return (i->expired_time > j->expired_time);
|
||
}
|
||
|
||
bool CompareItemInfoByTimeDC (TAuctionItemInfo* i, TAuctionItemInfo* j)
|
||
{
|
||
return (i->expired_time < j->expired_time);
|
||
}
|
||
|
||
bool CompareItemInfoByCharNameAC (TAuctionItemInfo* i, TAuctionItemInfo* j)
|
||
{
|
||
return (strcmp (i->shown_name, j->shown_name) < 0);
|
||
}
|
||
|
||
bool CompareItemInfoByCharNameDC (TAuctionItemInfo* i, TAuctionItemInfo* j)
|
||
{
|
||
return (strcmp (i->shown_name, j->shown_name) > 0);
|
||
}
|
||
|
||
bool CompareItemInfoByPriceAC (TAuctionItemInfo* i, TAuctionItemInfo* j)
|
||
{
|
||
return (i->get_price() < j->get_price());
|
||
}
|
||
|
||
bool CompareItemInfoByPriceDC (TAuctionItemInfo* i, TAuctionItemInfo* j)
|
||
{
|
||
return (i->get_price() > j->get_price());
|
||
}
|
||
|
||
void AuctionBoard::Sort(TItemInfoVec& vec, BYTE order)
|
||
{
|
||
switch (order)
|
||
{
|
||
case AUCTION_ITEM_NAME_AC:
|
||
std::stable_sort (vec.begin(), vec.end(), CompareItemInfoByItemNameAC);
|
||
break;
|
||
case AUCTION_ITEM_NAME_DC:
|
||
std::stable_sort (vec.begin(), vec.end(), CompareItemInfoByItemNameDC);
|
||
break;
|
||
case AUCTION_CATEGORY_AC:
|
||
std::stable_sort (vec.begin(), vec.end(), CompareItemInfoByCategoryAC);
|
||
break;
|
||
case AUCTION_CATEGORY_DC:
|
||
std::stable_sort (vec.begin(), vec.end(), CompareItemInfoByCategoryDC);
|
||
break;
|
||
case AUCTION_TIME_AC:
|
||
std::stable_sort (vec.begin(), vec.end(), CompareItemInfoByTimeAC);
|
||
break;
|
||
case AUCTION_TIME_DC:
|
||
std::stable_sort (vec.begin(), vec.end(), CompareItemInfoByTimeDC);
|
||
break;
|
||
case AUCTION_CHAR_NAME_AC:
|
||
std::stable_sort (vec.begin(), vec.end(), CompareItemInfoByCharNameAC);
|
||
break;
|
||
case AUCTION_CHAR_NAME_DC:
|
||
std::stable_sort (vec.begin(), vec.end(), CompareItemInfoByCharNameDC);
|
||
break;
|
||
case AUCTION_PRICE_AC:
|
||
std::stable_sort (vec.begin(), vec.end(), CompareItemInfoByPriceAC);
|
||
break;
|
||
case AUCTION_PRICE_DC:
|
||
std::stable_sort (vec.begin(), vec.end(), CompareItemInfoByPriceDC);
|
||
break;
|
||
}
|
||
}
|
||
|
||
bool AuctionBoard::InsertItemInfo (TAuctionItemInfo* item_info)
|
||
{
|
||
TAuctionItemInfo* c = GetItemInfo (item_info->item_id);
|
||
if (c != NULL)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
c = new TAuctionItemInfo();
|
||
memcpy (c, item_info, sizeof(TAuctionItemInfo));
|
||
|
||
c->item_proto = ITEM_MANAGER::instance().GetTable(c->item_num);
|
||
item_map.insert(TItemInfoMap::value_type(item_info->item_id, c));
|
||
|
||
DWORD offer_id = item_info->get_offer_id();
|
||
|
||
TPCMap::iterator pc_it = offer_map.find (offer_id);
|
||
TItemMap* item_map;
|
||
if (pc_it == offer_map.end())
|
||
{
|
||
item_map = new TItemMap();
|
||
offer_map.insert(TPCMap::value_type (offer_id, item_map));
|
||
}
|
||
else
|
||
{
|
||
item_map = pc_it->second;
|
||
}
|
||
DWORD item_id = item_info->item_id;
|
||
TItemMap::iterator item_it = item_map->find (item_id);
|
||
if (item_it == item_map->end())
|
||
{
|
||
item_map->insert (TItemMap::value_type (item_id, c));
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
#ifdef FAST_SORT
|
||
SortByItemName::iterator it = item_name_map.find (std::string (c->item_proto->szName));
|
||
TItemInfoVec* vec;
|
||
|
||
if (it == item_name_map.end())
|
||
{
|
||
vec = new TItemInfoVec();
|
||
item_name_map.insert (SortByItemName::value_type (std::string (c->item_proto->szName), vec));
|
||
}
|
||
else
|
||
{
|
||
vec = it->second;
|
||
}
|
||
vec.push_back (c);
|
||
|
||
return true;
|
||
#endif
|
||
}
|
||
|
||
bool AuctionBoard::UpdateItemInfo (TAuctionItemInfo* item_info)
|
||
{
|
||
TAuctionItemInfo* c = GetItemInfo (item_info->item_id);
|
||
if (c == NULL)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
memcpy (c, item_info, sizeof(TAuctionItemInfo));
|
||
return true;
|
||
}
|
||
|
||
bool AuctionBoard::DeleteItemInfo (DWORD key)
|
||
{
|
||
TItemInfoMap::iterator it = item_map.find (key);
|
||
if (it == item_map.end())
|
||
return false;
|
||
else
|
||
{
|
||
TAuctionItemInfo* item_info = it->second;
|
||
delete item_info;
|
||
item_map.erase(it);
|
||
return true;
|
||
}
|
||
}
|
||
|
||
TAuctionItemInfo* AuctionBoard::GetItemInfo (DWORD key)
|
||
{
|
||
TItemInfoMap::iterator it = item_map.find (key);
|
||
if (it == item_map.end())
|
||
return NULL;
|
||
else
|
||
return it->second;
|
||
}
|
||
|
||
void AuctionBoard::YourItemInfoList (TItemInfoVec& vec, DWORD player_id, int start_idx, BYTE size)
|
||
{
|
||
int pass = 0;
|
||
vec.clear();
|
||
TPCMap::iterator offer_it = offer_map.find (player_id);
|
||
if (offer_it == offer_map.end())
|
||
return;
|
||
TItemMap* item_map = offer_it->second;
|
||
for (TItemMap::iterator item_it = item_map->begin(); item_it != item_map->end() && vec.size() < size; item_it++)
|
||
{
|
||
if (pass >= start_idx)
|
||
{
|
||
vec.push_back (item_it->second);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 0~1, 2~3, 4~5, 6~7, 8~9
|
||
// ¦<><C2A6><EFBFBD><EFBFBD> descending, Ȧ<><C8A6><EFBFBD><EFBFBD> accending.
|
||
struct FCheckGradeSatisfied
|
||
{
|
||
BYTE grade;
|
||
|
||
bool operator() (int item_level)
|
||
{
|
||
switch (grade)
|
||
{
|
||
case 0:
|
||
return true;
|
||
break;
|
||
case 1:
|
||
if (item_level <= GRADE_LOW)
|
||
{
|
||
return true;
|
||
}
|
||
break;
|
||
case 2:
|
||
if (GRADE_LOW < item_level && item_level <= GRADE_MID)
|
||
{
|
||
return true;
|
||
}
|
||
break;
|
||
case 3:
|
||
if (GRADE_MID < item_level && item_level <= GRADE_HIGH)
|
||
{
|
||
return true;
|
||
}
|
||
break;
|
||
default:
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
};
|
||
|
||
void AuctionBoard::SortedItemInfos (TItemInfoVec& vec, BYTE grade, BYTE category, int start_idx, BYTE size, BYTE order[5])
|
||
{
|
||
FCheckGradeSatisfied f_grade = { grade };
|
||
vec.clear();
|
||
int pass = 0;
|
||
switch (order[4])
|
||
{
|
||
#ifdef FAST_SORT
|
||
case AUCTION_ITEM_NAME_AC:
|
||
for (SortByItemName::iterator it = item_name_map.begin(); it != item_name_map.end() && vec.size() < size; it++)
|
||
{
|
||
TItemInfoVec& temp = *(it->second);
|
||
|
||
pass += temp.size();
|
||
if (pass < start_idx)
|
||
{
|
||
continue;
|
||
}
|
||
for (uint i = 0; i < temp.size(); i++)
|
||
{
|
||
bool check_grade = (grade == 0);
|
||
for (int j = 0; j < ITEM_LIMIT_MAX_NUM; j++)
|
||
{
|
||
if (temp[i]->item_proto->aLimits[j].bType == LIMIT_LEVEL)
|
||
{
|
||
check_grade = f_grade (temp[i]->item_proto->aLimits[j].lValue);
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (check_grade)
|
||
{
|
||
vec.push_back (temp[i]);
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
#endif
|
||
default :
|
||
for (TItemInfoMap::iterator it = item_map.begin(); it != item_map.end(); it++)
|
||
{
|
||
vec.push_back (it->second);
|
||
}
|
||
break;
|
||
}
|
||
for (int i = 0; i < 5; i++)
|
||
{
|
||
Sort (vec, order[i]);
|
||
}
|
||
}
|
||
|
||
TSaleItemInfo* SaleBoard::GetItemInfo (DWORD item_id)
|
||
{
|
||
TItemInfoMap::iterator it = item_map.find (item_id);
|
||
if (it == item_map.end())
|
||
return NULL;
|
||
|
||
return it->second;
|
||
}
|
||
|
||
bool SaleBoard::DeleteItemInfo (DWORD item_id)
|
||
{
|
||
TItemInfoMap::iterator it = item_map.find (item_id);
|
||
if (it == item_map.end())
|
||
return false;
|
||
|
||
TSaleItemInfo* item_info = it->second;
|
||
DeleteFromPCMap (wisher_map, item_info->wisher_id, item_info->item_id);
|
||
DeleteFromPCMap (seller_map, item_info->offer_id, item_info->item_id);
|
||
|
||
delete item_info;
|
||
item_map.erase(it);
|
||
return true;
|
||
}
|
||
|
||
bool SaleBoard::DeleteFromPCMap (TPCMap& pc_map, DWORD player_id, DWORD item_id)
|
||
{
|
||
TPCMap::iterator pc_it = pc_map.find (player_id);
|
||
if (pc_it == pc_map.end())
|
||
{
|
||
return false;
|
||
}
|
||
TItemMap* item_map = pc_it->second;
|
||
TItemMap::iterator item_it = item_map->find (item_id);
|
||
if (item_it == item_map->end())
|
||
{
|
||
return false;
|
||
}
|
||
item_map->erase (item_it);
|
||
return true;
|
||
}
|
||
|
||
bool SaleBoard::InsertItemInfo (TSaleItemInfo* item_info)
|
||
{
|
||
TSaleItemInfo* c = GetItemInfo (DWORD (item_info->item_id));
|
||
if (c != NULL)
|
||
{
|
||
return false;
|
||
}
|
||
c = new TSaleItemInfo ();
|
||
memcpy (c, item_info, sizeof(TSaleItemInfo));
|
||
|
||
c->item_proto = ITEM_MANAGER::instance().GetTable(c->item_num);
|
||
|
||
InsertInPCMap (wisher_map, item_info->wisher_id, item_info);
|
||
InsertInPCMap (seller_map, item_info->offer_id, item_info);
|
||
|
||
return true;
|
||
}
|
||
|
||
bool SaleBoard::InsertInPCMap (TPCMap& pc_map, DWORD player_id, TSaleItemInfo* item_info)
|
||
{
|
||
TPCMap::iterator pc_it = pc_map.find (player_id);
|
||
TItemMap* item_map;
|
||
if (pc_it == pc_map.end())
|
||
{
|
||
item_map = new TItemMap();
|
||
pc_map.insert(TPCMap::value_type (player_id, item_map));
|
||
}
|
||
else
|
||
{
|
||
item_map = pc_it->second;
|
||
}
|
||
DWORD item_id = item_info->item_id;
|
||
TItemMap::iterator item_it = item_map->find (item_id);
|
||
if (item_it == item_map->end())
|
||
{
|
||
item_map->insert (TItemMap::value_type (item_id, item_info));
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
void SaleBoard::WisherItemInfoList (TItemInfoVec& vec, DWORD wisher_id, int start_idx, BYTE size)
|
||
{
|
||
int pass = 0;
|
||
vec.clear();
|
||
TPCMap::iterator wish_it = wisher_map.find (wisher_id);
|
||
if (wish_it == wisher_map.end())
|
||
return;
|
||
TItemMap* item_map = wish_it->second;
|
||
for (TItemMap::iterator item_it = item_map->begin(); item_it != item_map->end() && vec.size() < size; item_it++)
|
||
{
|
||
if (pass >= start_idx)
|
||
{
|
||
vec.push_back (item_it->second);
|
||
}
|
||
}
|
||
}
|
||
|
||
TWishItemInfo* WishBoard::GetItemInfo (DWORD wisher_id, DWORD item_num)
|
||
{
|
||
TPCMap::iterator wish_it = wisher_map.find (wisher_id);
|
||
if (wish_it == wisher_map.end())
|
||
return NULL;
|
||
|
||
TItemMap* item_map = wish_it->second;
|
||
TItemMap::iterator item_it = item_map->find (item_num);
|
||
if (item_it == item_map->end())
|
||
return NULL;
|
||
else
|
||
{
|
||
return item_it->second;
|
||
}
|
||
}
|
||
|
||
bool WishBoard::DeleteItemInfo (DWORD wisher_id, DWORD item_num)
|
||
{
|
||
TPCMap::iterator wish_it = wisher_map.find (wisher_id);
|
||
if (wish_it == wisher_map.end())
|
||
return false;
|
||
|
||
TItemMap* item_map = wish_it->second;
|
||
TItemMap::iterator item_it = item_map->find (item_num);
|
||
if (item_it == item_map->end())
|
||
return false;
|
||
else
|
||
{
|
||
delete item_it->second;
|
||
item_map->erase (item_it);
|
||
return true;
|
||
}
|
||
}
|
||
|
||
bool WishBoard::InsertItemInfo (TWishItemInfo* item_info)
|
||
{
|
||
DWORD wisher_id = item_info->offer_id;
|
||
DWORD item_num = item_info->item_num;
|
||
|
||
TPCMap::iterator wish_it = wisher_map.find (wisher_id);
|
||
TItemMap* item_map;
|
||
if (wish_it == wisher_map.end())
|
||
{
|
||
item_map = new TItemMap();
|
||
wisher_map.insert (TPCMap::value_type (wisher_id, item_map));
|
||
}
|
||
else
|
||
{
|
||
item_map = wish_it->second;
|
||
}
|
||
|
||
TItemMap::iterator item_it = item_map->find (item_num);
|
||
if (item_it == item_map->end())
|
||
{
|
||
TWishItemInfo* c = new TWishItemInfo();
|
||
memcpy (c, item_info, sizeof(TWishItemInfo));
|
||
|
||
c->item_proto = ITEM_MANAGER::instance().GetTable(c->item_num);
|
||
item_map->insert (TItemMap::value_type (item_num, c));
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
std::pair <int, bool> MyBidBoard::GetMoney (DWORD player_id, DWORD item_id)
|
||
{
|
||
TMyBidBoard::iterator pc_it = pc_map.find (player_id);
|
||
if (pc_it == pc_map.end())
|
||
{
|
||
return BidInfo (-1, false);
|
||
}
|
||
TItemMap* item_map = pc_it->second;
|
||
TItemMap::iterator it = item_map->find (item_id);
|
||
if (it == item_map->end())
|
||
return BidInfo (-1, false);
|
||
else
|
||
return it->second;
|
||
}
|
||
|
||
bool MyBidBoard::Delete (DWORD player_id, DWORD item_id)
|
||
{
|
||
TMyBidBoard::iterator pc_it = pc_map.find (player_id);
|
||
if (pc_it == pc_map.end())
|
||
{
|
||
return false;
|
||
}
|
||
TItemMap* item_map = pc_it->second;
|
||
TItemMap::iterator it = item_map->find (item_id);
|
||
if (it == item_map->end())
|
||
return false;
|
||
else
|
||
{
|
||
item_map->erase(it);
|
||
return true;
|
||
}
|
||
}
|
||
|
||
void MyBidBoard::Insert (DWORD player_id, DWORD item_id, int money)
|
||
{
|
||
TMyBidBoard::iterator pc_it = pc_map.find (player_id);
|
||
TItemMap* item_map;
|
||
if (pc_it == pc_map.end())
|
||
{
|
||
item_map = new TItemMap();
|
||
pc_map.insert (TMyBidBoard::value_type (player_id, item_map));
|
||
}
|
||
else
|
||
item_map = pc_it->second;
|
||
|
||
TItemMap::iterator it = item_map->find (item_id);
|
||
if (it == item_map->end())
|
||
{
|
||
item_map->insert (TItemMap::value_type (item_id, std::pair <int, bool> (money, false)));
|
||
}
|
||
else
|
||
{
|
||
it->second = BidInfo (money, false);
|
||
}
|
||
}
|
||
|
||
void MyBidBoard::Lock (DWORD player_id, DWORD item_id)
|
||
{
|
||
TMyBidBoard::iterator pc_it = pc_map.find (player_id);
|
||
if (pc_it == pc_map.end())
|
||
{
|
||
return;
|
||
}
|
||
TItemMap* item_map = pc_it->second;
|
||
TItemMap::iterator it = item_map->find (item_id);
|
||
if (it == item_map->end())
|
||
return;
|
||
else
|
||
it->second.second = true;
|
||
}
|
||
|
||
void MyBidBoard::UnLock (DWORD player_id, DWORD item_id)
|
||
{
|
||
TMyBidBoard::iterator pc_it = pc_map.find (player_id);
|
||
if (pc_it == pc_map.end())
|
||
{
|
||
return;
|
||
}
|
||
TItemMap* item_map = pc_it->second;
|
||
TItemMap::iterator it = item_map->find (item_id);
|
||
if (it == item_map->end())
|
||
return;
|
||
else
|
||
it->second.second = false;
|
||
}
|
||
|
||
void MyBidBoard::YourBidInfo (TItemVec& vec, DWORD bidder_id, int start_idx, int size)
|
||
{
|
||
vec.clear();
|
||
TMyBidBoard::iterator pc_it = pc_map.find (bidder_id);
|
||
if (pc_it == pc_map.end())
|
||
return;
|
||
TItemMap* item_map = pc_it->second;
|
||
int pass = 0;
|
||
for (TItemMap::iterator it = item_map->begin(); it != item_map->end() && vec.size() < size; it++, pass++)
|
||
{
|
||
if (pass >= start_idx)
|
||
{
|
||
vec.push_back (it->first);
|
||
}
|
||
}
|
||
}
|
||
|
||
void AuctionManager::Boot (const char* &data, WORD size)
|
||
{
|
||
if (decode_2bytes(data) != sizeof(TPlayerItem))
|
||
{
|
||
sys_err("TPlayerItem table size error");
|
||
thecore_shutdown();
|
||
return;
|
||
}
|
||
data += 2;
|
||
|
||
size = decode_2bytes(data);
|
||
data += 2;
|
||
|
||
TPlayerItem* item = (TPlayerItem*) data;
|
||
data += size * sizeof(TPlayerItem);
|
||
if (auction_server)
|
||
{
|
||
for (WORD i = 0; i < size; ++i, ++item)
|
||
{
|
||
InsertItem (item);
|
||
}
|
||
|
||
}
|
||
if (decode_2bytes(data) != sizeof(TAuctionItemInfo))
|
||
{
|
||
sys_err("TAuctionItemInfo table size error");
|
||
thecore_shutdown();
|
||
return;
|
||
}
|
||
data += 2;
|
||
|
||
size = decode_2bytes(data);
|
||
data += 2;
|
||
|
||
TAuctionItemInfo* auction_item_info = (TAuctionItemInfo*) data;
|
||
data += size * sizeof(TAuctionItemInfo);
|
||
if (auction_server)
|
||
{
|
||
for (WORD i = 0; i < size; ++i, ++auction_item_info)
|
||
{
|
||
Auction.InsertItemInfo (auction_item_info);
|
||
}
|
||
}
|
||
if (decode_2bytes(data) != sizeof(TSaleItemInfo))
|
||
{
|
||
sys_err("TSaleItemInfo table size error");
|
||
thecore_shutdown();
|
||
return;
|
||
}
|
||
data += 2;
|
||
|
||
size = decode_2bytes(data);
|
||
data += 2;
|
||
|
||
TSaleItemInfo* sale_item_info = (TSaleItemInfo*) data;
|
||
data += size * sizeof(TSaleItemInfo);
|
||
if (auction_server)
|
||
{
|
||
for (WORD i = 0; i < size; ++i, ++sale_item_info)
|
||
{
|
||
Sale.InsertItemInfo (sale_item_info);
|
||
}
|
||
}
|
||
|
||
if (decode_2bytes(data) != sizeof(TWishItemInfo))
|
||
{
|
||
sys_err("TWishItemInfo table size error");
|
||
thecore_shutdown();
|
||
return;
|
||
}
|
||
data += 2;
|
||
|
||
size = decode_2bytes(data);
|
||
data += 2;
|
||
|
||
TWishItemInfo* wish_item_info = (TWishItemInfo*) data;
|
||
data += size * sizeof(TWishItemInfo);
|
||
if (auction_server)
|
||
{
|
||
for (WORD i = 0; i < size; ++i, ++wish_item_info)
|
||
{
|
||
Wish.InsertItemInfo (wish_item_info);
|
||
}
|
||
}
|
||
|
||
if (decode_2bytes(data) != (sizeof(DWORD) + sizeof(DWORD) + sizeof(int)))
|
||
{
|
||
sys_err("my_bid table size error");
|
||
thecore_shutdown();
|
||
return;
|
||
}
|
||
data += 2;
|
||
|
||
size = decode_2bytes(data);
|
||
data += 2;
|
||
|
||
if (auction_server)
|
||
{
|
||
for (WORD i = 0; i < size; i++)
|
||
{
|
||
DWORD player_id = *((DWORD*) data);
|
||
data += sizeof(DWORD);
|
||
DWORD item_id = *((DWORD*) data);
|
||
data += sizeof(DWORD);
|
||
int money = *((int*) data);
|
||
data += sizeof(int);
|
||
MyBid.Insert (player_id, item_id, money);
|
||
}
|
||
}
|
||
else
|
||
data += size * (sizeof(DWORD) + sizeof(DWORD) + sizeof(int));
|
||
}
|
||
|
||
bool AuctionManager::InsertItem (LPITEM item)
|
||
{
|
||
TItemMap::iterator it = auction_item_map.find (item->GetID());
|
||
if (it != auction_item_map.end())
|
||
return false;
|
||
auction_item_map.insert(TItemMap::value_type (item->GetID(), item));
|
||
return true;
|
||
}
|
||
|
||
bool AuctionManager::InsertItem (TPlayerItem* player_item)
|
||
{
|
||
if (player_item->window != AUCTION)
|
||
return false;
|
||
LPITEM item = ITEM_MANAGER::instance().CreateItem(player_item->vnum, player_item->count, player_item->id, false, -1, true);
|
||
|
||
if (!item)
|
||
{
|
||
sys_err("cannot create item vnum %d id %u",player_item->vnum, player_item->id);
|
||
return false;
|
||
}
|
||
|
||
item->SetSkipSave(true);
|
||
|
||
if (!InsertItem(item))
|
||
{
|
||
M2_DESTROY_ITEM(item);
|
||
return false;
|
||
}
|
||
item->SetSockets(player_item->alSockets);
|
||
item->SetAttributes(player_item->aAttr);
|
||
item->SetWindow(AUCTION);
|
||
|
||
return true;
|
||
}
|
||
|
||
LPITEM AuctionManager::GetInventoryItem (DWORD item_id)
|
||
{
|
||
TItemMap::iterator it = auction_item_map.find (item_id);
|
||
if (it == auction_item_map.end())
|
||
return NULL;
|
||
else
|
||
return it->second;
|
||
}
|
||
|
||
bool AuctionManager::DeleteItem (DWORD item_id)
|
||
{
|
||
TItemMap::iterator it = auction_item_map.find (item_id);
|
||
if (it == auction_item_map.end())
|
||
return false;
|
||
else
|
||
{
|
||
auction_item_map.erase (it);
|
||
return true;
|
||
}
|
||
}
|
||
//
|
||
//bool AuctionManager::InsertAuctionMoney (DWORD player_id, int money)
|
||
//{
|
||
// TAuctionMoneyMap::iterator it = auction_item_map.find (player_id);
|
||
// if (it == auction_item_map.end())
|
||
// return false;
|
||
// auction_item_map.insert (TAuctionMoneyMap::value_type (player_id, money));
|
||
//}
|
||
//
|
||
//bool AuctionManager::ChangeAuctionMoney (DWORD player_id, int changing_amount)
|
||
//{
|
||
// TAuctionMoneyMap::iterator it = auction_item_map.find (player_id);
|
||
// if (it == auction_item_map.end())
|
||
// return false;
|
||
// if (it->second + changing_amount < 0)
|
||
// {
|
||
// sys_err ("Cannot have money under 0.");
|
||
// return false;
|
||
// }
|
||
//
|
||
// TPacketGDCommnadAuction pack_cm;
|
||
// pack_cm.changing_money (it->second);
|
||
//
|
||
// db_clientdesc->DBPacket(HEADER_GD_COMMAND_AUCTION, player_id, &pack_cm, sizeof(TPacketGDCommnadAuction));
|
||
//}
|
||
|
||
|
||
bool AuctionManager::InsertAuctionItemInfo (TAuctionItemInfo* item_info)
|
||
{
|
||
return Auction.InsertItemInfo (item_info);
|
||
}
|
||
|
||
bool AuctionManager::InsertSaleItemInfo (TSaleItemInfo* item_info)
|
||
{
|
||
return Sale.InsertItemInfo (item_info);
|
||
}
|
||
|
||
bool AuctionManager::InsertWishItemInfo (TWishItemInfo* item_info)
|
||
{
|
||
return Wish.InsertItemInfo (item_info);
|
||
}
|
||
|
||
void AuctionManager::YourBidItemInfoList (AuctionBoard::TItemInfoVec& vec, DWORD bidder_id, int start_idx, int size)
|
||
{
|
||
vec.clear();
|
||
MyBidBoard::TItemVec item_id_vec;
|
||
MyBid.YourBidInfo (item_id_vec, bidder_id, 0, 6);
|
||
for (int i = 0; i < item_id_vec.size(); i++)
|
||
{
|
||
TAuctionItemInfo* item_info = Auction.GetItemInfo(item_id_vec[i]);
|
||
if (item_info != NULL)
|
||
{
|
||
vec.push_back (item_info);
|
||
}
|
||
else
|
||
{
|
||
// expired <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>⼭ <20>־<EFBFBD><D6BE><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
|
||
}
|
||
}
|
||
}
|
||
|
||
void AuctionManager::get_auction_list (LPCHARACTER ch, int start_idx, int size, int cond)
|
||
{
|
||
BYTE order[5] = {0,};
|
||
AuctionBoard::TItemInfoVec vec;
|
||
switch (cond)
|
||
{
|
||
case 0:
|
||
order[4] = AUCTION_ITEM_NAME_AC;
|
||
order[3] = AUCTION_PRICE_DC;
|
||
Auction.SortedItemInfos (vec, 0, 0, 0, 12, order);
|
||
|
||
// SortedItemInfos
|
||
break;
|
||
case 1:
|
||
order[4] = AUCTION_PRICE_DC;
|
||
order[3] = AUCTION_ITEM_NAME_DC;
|
||
Auction.SortedItemInfos (vec, 0, 0, 5, 12, order);
|
||
|
||
break;
|
||
case 2:
|
||
order[4] = AUCTION_CHAR_NAME_DC;
|
||
order[3] = AUCTION_ITEM_NAME_DC;
|
||
order[2] = AUCTION_TIME_AC;
|
||
Auction.SortedItemInfos (vec, 0, 0, 0, 12, order);
|
||
|
||
break;
|
||
|
||
}
|
||
for (uint i = 0; i < vec.size(); i++)
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, "%s item id : %d price : %d", vec[i]->item_proto->szName, vec[i]->get_item_id(), vec[i]->get_price());
|
||
}
|
||
}
|
||
|
||
void AuctionManager::get_my_auction_list (LPCHARACTER ch, int start_idx, int size)
|
||
{
|
||
AuctionBoard::TItemInfoVec auction_vec;
|
||
Auction.YourItemInfoList (auction_vec, ch->GetPlayerID(), 0, 6);
|
||
|
||
for (uint i = 0; i < auction_vec.size(); i++)
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, "%s item id : %d price : %d", auction_vec[i]->item_proto->szName, auction_vec[i]->get_item_id(), auction_vec[i]->get_price());
|
||
}
|
||
SaleBoard::TItemInfoVec wish_vec;
|
||
Sale.WisherItemInfoList (wish_vec, ch->GetPlayerID(), 0, 6);
|
||
for (uint i = 0; i < auction_vec.size(); i++)
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, "%s item id : %d price : %d", wish_vec[i]->item_proto->szName, wish_vec[i]->item_id,
|
||
wish_vec[i]->get_price());
|
||
}
|
||
}
|
||
|
||
void AuctionManager::get_my_purchase_list (LPCHARACTER ch, int start_idx, int size)
|
||
{
|
||
AuctionBoard::TItemInfoVec auction_vec;
|
||
YourBidItemInfoList (auction_vec, ch->GetPlayerID(), 0, 6);
|
||
|
||
for (uint i = 0; i < auction_vec.size(); i++)
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, "%s item id : %d price : %d", auction_vec[i]->item_proto->szName, auction_vec[i]->get_item_id(), auction_vec[i]->get_price());
|
||
}
|
||
|
||
//WishBoard::TItemInfoVec wish_vec;
|
||
//Wish.WisherItemInfoList (wish_vec, ch->GetPlayerID(), 0, 6);
|
||
//for (uint i = 0; i < auction_vec.size(); i++)
|
||
//{
|
||
// ch->ChatPacket(CHAT_TYPE_INFO, "%s item id : %d price : %d", wish_vec[i]->item_proto->szName, wish_vec[i]->item_id,
|
||
// wish_vec[i]->get_price());
|
||
//}
|
||
}
|
||
|
||
void AuctionManager::enroll_auction (LPCHARACTER ch, LPITEM item, BYTE empire, int bidPrice, int immidiatePurchasePrice)
|
||
{
|
||
if (ch != item->GetOwner())
|
||
{
|
||
sys_err ("Item %d's owner is %s, not %s",ch->GetName(), item->GetOwner()->GetName());
|
||
return;
|
||
}
|
||
if (item->IsEquipped())
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD>.");
|
||
return;
|
||
}
|
||
|
||
if (GetAuctionItemInfo (item->GetID()))
|
||
{
|
||
sys_err ("Item %d is already in auction.", item->GetID());
|
||
ch->ChatPacket(CHAT_TYPE_INFO, "<EFBFBD>̹<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ž<EFBFBD>. <20><><EFBFBD><EFBFBD>ü <20><><EFBFBD><EFBFBD>?");
|
||
return;
|
||
}
|
||
|
||
if (item->GetWindow() == AUCTION)
|
||
{
|
||
sys_err ("Item %d is already in auction.", item->GetID());
|
||
ch->ChatPacket(CHAT_TYPE_INFO, "<EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD>..");
|
||
return;
|
||
}
|
||
|
||
TPacketGDCommnadAuction pack_ea;
|
||
pack_ea.enroll_product (item->GetID(), empire, bidPrice, immidiatePurchasePrice);
|
||
|
||
item->SetSkipSave(true);
|
||
item->RemoveFromCharacter();
|
||
M2_DESTROY_ITEM (item);
|
||
|
||
db_clientdesc->DBPacket(HEADER_GD_COMMAND_AUCTION, ch->GetPlayerID(), &pack_ea, sizeof(TPacketGDCommnadAuction));
|
||
}
|
||
|
||
void AuctionManager::enroll_sale (LPCHARACTER ch, LPITEM item, DWORD wisher_id, int salePrice)
|
||
{
|
||
if (ch != item->GetOwner())
|
||
{
|
||
sys_err ("Item %d's owner is %s, not %s",ch->GetName(), item->GetOwner()->GetName());
|
||
return;
|
||
}
|
||
if (item->IsEquipped())
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD>.");
|
||
return;
|
||
}
|
||
|
||
if (GetSaleItemInfo (item->GetID()))
|
||
{
|
||
sys_err ("Item %d is already in auction.", item->GetID());
|
||
ch->ChatPacket(CHAT_TYPE_INFO, "<EFBFBD>̹<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ž<EFBFBD>. <20><><EFBFBD><EFBFBD>ü <20><><EFBFBD><EFBFBD>?");
|
||
return;
|
||
}
|
||
|
||
if (item->GetWindow() == AUCTION)
|
||
{
|
||
sys_err ("Item %d is already in auction.", item->GetID());
|
||
ch->ChatPacket(CHAT_TYPE_INFO, "<EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD>..");
|
||
return;
|
||
}
|
||
|
||
TPacketGDCommnadAuction pack_es;
|
||
pack_es.enroll_sale (item->GetID(), wisher_id, salePrice);
|
||
|
||
item->SetSkipSave(true);
|
||
item->RemoveFromCharacter();
|
||
M2_DESTROY_ITEM (item);
|
||
|
||
db_clientdesc->DBPacket(HEADER_GD_COMMAND_AUCTION, ch->GetPlayerID(), &pack_es, sizeof(TPacketGDCommnadAuction));
|
||
}
|
||
|
||
void AuctionManager::enroll_wish (LPCHARACTER ch, DWORD item_num, BYTE empire, int wishPrice)
|
||
{
|
||
TPacketGDCommnadAuction pack_ew;
|
||
pack_ew.enroll_wish (item_num, empire, wishPrice);
|
||
db_clientdesc->DBPacket(HEADER_GD_COMMAND_AUCTION, ch->GetPlayerID(), &pack_ew, sizeof(TPacketGDCommnadAuction));
|
||
}
|
||
|
||
// fixme
|
||
void AuctionManager::bid (LPCHARACTER ch, DWORD item_id, int bid_price)
|
||
{
|
||
std::pair <int, bool> mb = MyBid.GetMoney(ch->GetPlayerID(), item_id);
|
||
if (mb.first != -1)
|
||
{
|
||
ch->ChatPacket (CHAT_TYPE_INFO, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>϶<EFBFBD> <20><><EFBFBD>̴<EFBFBD>.");
|
||
}
|
||
if (ch->GetGold() < bid_price)
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>");
|
||
return;
|
||
}
|
||
|
||
ch->PointChange(POINT_GOLD, -bid_price, false);
|
||
|
||
TPacketGDCommnadAuction pack_bid;
|
||
pack_bid.bid (item_id, bid_price);
|
||
db_clientdesc->DBPacket(HEADER_GD_COMMAND_AUCTION, ch->GetPlayerID(), &pack_bid, sizeof(TPacketGDCommnadAuction));
|
||
}
|
||
|
||
// fixme
|
||
// <20>ݵ<EFBFBD><DDB5><EFBFBD> <20><>!!!
|
||
void AuctionManager::immediate_purchase (LPCHARACTER ch, DWORD item_id)
|
||
{
|
||
TAuctionItemInfo* item_info = GetAuctionItemInfo (item_id);
|
||
|
||
if (item_info == NULL)
|
||
{
|
||
sys_err ("Invild item id : %d", item_id);
|
||
return;
|
||
}
|
||
|
||
if (item_info->get_impur_price() == 0)
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, "<EFBFBD>ﱸ <20><> <20><> <20><><EFBFBD><EFBFBD>");
|
||
return;
|
||
}
|
||
|
||
if (ch->GetGold() < item_info->get_impur_price())
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>");
|
||
return;
|
||
}
|
||
|
||
ch->PointChange(POINT_GOLD, -item_info->get_impur_price(), false);
|
||
|
||
TPacketGDCommnadAuction pack_impur;
|
||
pack_impur.impur (item_id);
|
||
db_clientdesc->DBPacket(HEADER_GD_COMMAND_AUCTION, ch->GetPlayerID(), &pack_impur, sizeof(TPacketGDCommnadAuction));
|
||
}
|
||
|
||
// <20><><EFBFBD><EFBFBD>
|
||
void AuctionManager::get_auctioned_item (LPCHARACTER ch, DWORD item_id, DWORD item_num)
|
||
{
|
||
TItemTable* proto = ITEM_MANAGER::instance().GetTable(item_num);
|
||
int pos = ch->GetEmptyInventory(proto->bSize);
|
||
|
||
if (pos == -1)
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, "<EFBFBD>ڸ<EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>");
|
||
return;
|
||
}
|
||
|
||
//TAuctionItemInfo*
|
||
// if (Auction.GetItemInfo (item_id))
|
||
// {
|
||
|
||
// }
|
||
|
||
TPacketGDCommnadAuction pack_gai;
|
||
pack_gai.get_auctioned_item (item_id);
|
||
db_clientdesc->DBPacket(HEADER_GD_COMMAND_AUCTION, ch->GetPlayerID(), &pack_gai, sizeof(TPacketGDCommnadAuction));
|
||
}
|
||
|
||
void AuctionManager::buy_sold_item (LPCHARACTER ch, DWORD item_id)
|
||
{
|
||
TPacketGDCommnadAuction pack_bsi;
|
||
pack_bsi.buy_sold_item (item_id);
|
||
db_clientdesc->DBPacket(HEADER_GD_COMMAND_AUCTION, ch->GetPlayerID(), &pack_bsi, sizeof(TPacketGDCommnadAuction));
|
||
}
|
||
|
||
void AuctionManager::cancel_auction (LPCHARACTER ch, DWORD item_id)
|
||
{
|
||
TPacketGDCommnadAuction pack_ca;
|
||
pack_ca.cancel_auction (item_id);
|
||
db_clientdesc->DBPacket(HEADER_GD_COMMAND_AUCTION, ch->GetPlayerID(), &pack_ca, sizeof(TPacketGDCommnadAuction));
|
||
}
|
||
|
||
void AuctionManager::cancel_wish (LPCHARACTER ch, DWORD item_num)
|
||
{
|
||
TPacketGDCommnadAuction pack_cw;
|
||
pack_cw.cancel_wish (item_num);
|
||
db_clientdesc->DBPacket(HEADER_GD_COMMAND_AUCTION, ch->GetPlayerID(), &pack_cw, sizeof(TPacketGDCommnadAuction));
|
||
}
|
||
|
||
void AuctionManager::cancel_sale (LPCHARACTER ch, DWORD item_id)
|
||
{
|
||
TPacketGDCommnadAuction pack_cs;
|
||
pack_cs.cancel_sale (item_id);
|
||
db_clientdesc->DBPacket(HEADER_GD_COMMAND_AUCTION, ch->GetPlayerID(), &pack_cs, sizeof(TPacketGDCommnadAuction));
|
||
}
|
||
|
||
void AuctionManager::rebid (LPCHARACTER ch, DWORD item_id, int bid_price)
|
||
{
|
||
std::pair <int, bool> mb = MyBid.GetMoney (ch->GetPlayerID(), item_id);
|
||
int money = mb.first;
|
||
bool lock = mb.second;
|
||
if (money == -1)
|
||
{
|
||
sys_err ("Do bid first. How can you rebid? pid %d, item_id %d",ch->GetPlayerID(), item_id);
|
||
return;
|
||
}
|
||
|
||
if (lock)
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>̾<EFBFBD>.");
|
||
return;
|
||
}
|
||
|
||
if (ch->GetGold() + money < bid_price)
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>");
|
||
return;
|
||
}
|
||
|
||
MyBid.Lock (ch->GetPlayerID(), item_id);
|
||
|
||
ch->PointChange(POINT_GOLD, -(bid_price - money), false);
|
||
|
||
TPacketGDCommnadAuction pack_rebid;
|
||
pack_rebid.rebid (item_id, (bid_price - money));
|
||
db_clientdesc->DBPacket(HEADER_GD_COMMAND_AUCTION, ch->GetPlayerID(), &pack_rebid, sizeof(TPacketGDCommnadAuction));
|
||
}
|
||
|
||
void AuctionManager::bid_cancel (LPCHARACTER ch, DWORD item_id)
|
||
{
|
||
std::pair <int, bool> mb = MyBid.GetMoney (ch->GetPlayerID(), item_id);
|
||
int money = mb.first;
|
||
bool lock = mb.second;
|
||
if (money == -1)
|
||
{
|
||
sys_err ("Do bid first. How can you bid cancel? pid %d, item_id %d",ch->GetPlayerID(), item_id);
|
||
return;
|
||
}
|
||
|
||
if (lock)
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>̾<EFBFBD>.");
|
||
return;
|
||
}
|
||
|
||
TAuctionItemInfo* item_info = GetAuctionItemInfo(item_id);
|
||
if (item_info->get_bidder_id() == ch->GetPlayerID())
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, "<EFBFBD>ϰ<EFBFBD> <20>ְ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ھ<EFBFBD>. <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.");
|
||
return;
|
||
}
|
||
|
||
MyBid.Delete (ch->GetPlayerID(), item_id);
|
||
ch->PointChange(POINT_GOLD, money, true);
|
||
|
||
TPacketGDCommnadAuction pack_bc;
|
||
pack_bc.bid_cancel (item_id);
|
||
db_clientdesc->DBPacket(HEADER_GD_COMMAND_AUCTION, ch->GetPlayerID(), &pack_bc, sizeof(TPacketGDCommnadAuction));
|
||
}
|
||
|
||
// <20><>
|
||
void AuctionManager::recv_result_auction (DWORD commander_id, TPacketDGResultAuction* cmd_result)
|
||
{
|
||
LPCHARACTER ch = CHARACTER_MANAGER::instance().FindByPID(commander_id);
|
||
switch (cmd_result->cmd)
|
||
{
|
||
case AUCTION_ENR_AUC:
|
||
switch (cmd_result->result)
|
||
{
|
||
case AUCTION_SUCCESS:
|
||
{
|
||
cmd_result++;
|
||
TPlayerItem* player_item = (TPlayerItem*)cmd_result;
|
||
|
||
InsertItem (player_item);
|
||
player_item++;
|
||
|
||
TAuctionItemInfo* item_info = (TAuctionItemInfo*)player_item;
|
||
|
||
Auction.InsertItemInfo (item_info);
|
||
if (ch != NULL)
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>忡 <20><><EFBFBD><EFBFBD><EFBFBD>߾<EFBFBD>.");
|
||
}
|
||
break;
|
||
}
|
||
case AUCTION_FAIL:
|
||
{
|
||
if (ch != NULL)
|
||
{
|
||
cmd_result++;
|
||
TPlayerItem* player_item = (TPlayerItem*)cmd_result;
|
||
LPITEM item = ITEM_MANAGER::instance().CreateItem(player_item->vnum, player_item->count, player_item->id);
|
||
|
||
LPCHARACTER ch = CHARACTER_MANAGER::instance().FindByPID (player_item->owner);
|
||
|
||
ch->AutoGiveItem (item, true);
|
||
ch->ChatPacket(CHAT_TYPE_INFO, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>忡 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>߾<EFBFBD>.");
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
break;
|
||
case AUCTION_ENR_SALE:
|
||
switch (cmd_result->result)
|
||
{
|
||
case AUCTION_SUCCESS:
|
||
{
|
||
cmd_result++;
|
||
TPlayerItem* player_item = (TPlayerItem*)cmd_result;
|
||
|
||
InsertItem (player_item);
|
||
player_item++;
|
||
|
||
TSaleItemInfo* item_info = (TSaleItemInfo*)player_item;
|
||
|
||
Sale.InsertItemInfo (item_info);
|
||
if (ch != NULL)
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, "<EFBFBD>Ǹ<EFBFBD><EFBFBD>忡 <20><><EFBFBD><EFBFBD><EFBFBD>߾<EFBFBD>.");
|
||
}
|
||
break;
|
||
}
|
||
case AUCTION_FAIL:
|
||
{
|
||
if (ch != NULL)
|
||
{
|
||
cmd_result++;
|
||
TPlayerItem* player_item = (TPlayerItem*)cmd_result;
|
||
LPITEM item = ITEM_MANAGER::instance().CreateItem(player_item->vnum, player_item->count, player_item->id);
|
||
|
||
|
||
ch->AutoGiveItem (item, true);
|
||
ch->ChatPacket(CHAT_TYPE_INFO, "<EFBFBD>Ǹ<EFBFBD><EFBFBD>忡 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>߾<EFBFBD>.");
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
break;
|
||
case AUCTION_ENR_WISH:
|
||
switch (cmd_result->result)
|
||
{
|
||
case AUCTION_SUCCESS:
|
||
{
|
||
cmd_result++;
|
||
TWishItemInfo* item_info = (TWishItemInfo*)cmd_result;
|
||
|
||
Wish.InsertItemInfo (item_info);
|
||
if (ch != NULL)
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, "<EFBFBD><EFBFBD><EFBFBD>ϴٿ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>߾<EFBFBD>.");
|
||
}
|
||
break;
|
||
}
|
||
case AUCTION_FAIL:
|
||
{
|
||
if (ch != NULL)
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, "<EFBFBD><EFBFBD><EFBFBD>ϴٿ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>߾<EFBFBD>.");
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
break;
|
||
case AUCTION_BID:
|
||
if (cmd_result->result <= AUCTION_FAIL)
|
||
{
|
||
|
||
}
|
||
else
|
||
{
|
||
cmd_result++;
|
||
TAuctionItemInfo* new_item_info = (TAuctionItemInfo*)cmd_result;
|
||
TAuctionItemInfo* old_item_info = Auction.GetItemInfo (new_item_info->get_item_id());
|
||
memcpy (old_item_info, new_item_info, sizeof(TAuctionItemInfo));
|
||
MyBid.Insert(new_item_info->bidder_id, new_item_info->item_id, new_item_info->get_bid_price());
|
||
if (ch != NULL)
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>߾<EFBFBD>.");
|
||
}
|
||
}
|
||
break;
|
||
case AUCTION_IMME_PUR:
|
||
if (cmd_result->result <= AUCTION_FAIL)
|
||
{
|
||
}
|
||
else
|
||
{
|
||
cmd_result++;
|
||
TAuctionItemInfo* new_item_info = (TAuctionItemInfo*)cmd_result;
|
||
TAuctionItemInfo* old_item_info = Auction.GetItemInfo (new_item_info->get_item_id());
|
||
memcpy (old_item_info, new_item_info, sizeof(TAuctionItemInfo));
|
||
if (ch != NULL)
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, "<EFBFBD>ﱸ <20>ع<EFBFBD><D8B9>Ⱦ<EFBFBD>.");
|
||
}
|
||
}
|
||
break;
|
||
case AUCTION_GET_AUC:
|
||
case AUCTION_BUY_SOLD:
|
||
case AUCTION_CANCEL_AUC:
|
||
case AUCTION_CANCEL_SALE:
|
||
if (cmd_result->result <= AUCTION_FAIL)
|
||
{
|
||
}
|
||
else
|
||
{
|
||
BYTE cmd = cmd_result->cmd;
|
||
cmd_result++;
|
||
TPlayerItem* player_item = (TPlayerItem*)cmd_result;
|
||
|
||
DWORD item_id = player_item->id;
|
||
|
||
if (ch != NULL)
|
||
{
|
||
LPITEM item = ITEM_MANAGER::instance().CreateItem(player_item->vnum, player_item->count, item_id);
|
||
ch->AutoGiveItem (item, true);
|
||
ch->ChatPacket(CHAT_TYPE_INFO, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ծ<EFBFBD>.");
|
||
if (cmd == AUCTION_GET_AUC || cmd == AUCTION_CANCEL_AUC)
|
||
{
|
||
TPacketGDCommnadAuction pack_dai;
|
||
pack_dai.delete_auction_item (item_id);
|
||
db_clientdesc->DBPacket(HEADER_GD_COMMAND_AUCTION, ch->GetPlayerID(), &pack_dai, sizeof(TPacketGDCommnadAuction));
|
||
}
|
||
else if (cmd == AUCTION_BUY_SOLD || cmd == AUCTION_CANCEL_SALE)
|
||
{
|
||
TPacketGDCommnadAuction pack_dsi;
|
||
pack_dsi.delete_sale_item (item_id);
|
||
db_clientdesc->DBPacket(HEADER_GD_COMMAND_AUCTION, ch->GetPlayerID(), &pack_dsi, sizeof(TPacketGDCommnadAuction));
|
||
}
|
||
}
|
||
}
|
||
case AUCTION_DELETE_AUCTION_ITEM:
|
||
case AUCTION_DELETE_SALE_ITEM:
|
||
{
|
||
AuctionCmd cmd = cmd_result->cmd;
|
||
cmd_result++;
|
||
TPlayerItem* player_item = (TPlayerItem*)cmd_result;
|
||
|
||
DWORD item_id = player_item->id;
|
||
|
||
if (!GetInventoryItem(player_item->id))
|
||
{
|
||
sys_err ("AUCTION_CMD %d : invalid item_id %d", cmd, item_id);
|
||
break;
|
||
}
|
||
|
||
if (cmd == AUCTION_DELETE_AUCTION_ITEM)
|
||
{
|
||
if (!GetAuctionItemInfo(item_id))
|
||
{
|
||
DeleteItem (item_id);
|
||
Auction.DeleteItemInfo (item_id);
|
||
}
|
||
}
|
||
else if (cmd == AUCTION_DELETE_SALE_ITEM)
|
||
{
|
||
if (!GetSaleItemInfo(item_id))
|
||
{
|
||
DeleteItem (item_id);
|
||
Sale.DeleteItemInfo (item_id);
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
case AUCTION_CANCEL_WISH:
|
||
if (cmd_result->result <= AUCTION_FAIL)
|
||
{
|
||
}
|
||
else
|
||
{
|
||
if (!Wish.DeleteItemInfo (commander_id, cmd_result->target))
|
||
{
|
||
sys_err ("Cannot cancel wish, invalid player_id : %d, item_num : %d", commander_id, cmd_result->target);
|
||
}
|
||
else if (ch != NULL)
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>߾<EFBFBD>.");
|
||
}
|
||
}
|
||
break;
|
||
case AUCTION_REBID:
|
||
if (cmd_result->result <= AUCTION_FAIL)
|
||
{
|
||
BYTE result = cmd_result->result;
|
||
DWORD item_id = cmd_result->target;
|
||
cmd_result++;
|
||
int restore_money = *((int*)cmd_result);
|
||
ch->PointChange(POINT_GOLD, restore_money, true);
|
||
|
||
MyBid.UnLock (commander_id, item_id);
|
||
}
|
||
else
|
||
{
|
||
// insert<72>ϸ<EFBFBD> lock<63><6B> Ǯ<><C7AE><EFBFBD><EFBFBD>.
|
||
DWORD item_id = cmd_result->target;
|
||
cmd_result++;
|
||
TAuctionItemInfo* auction_info = (TAuctionItemInfo*)cmd_result;
|
||
ch->PointChange(POINT_GOLD, 0, true);
|
||
|
||
MyBid.Insert (commander_id, item_id, auction_info->get_bid_price());
|
||
Auction.UpdateItemInfo (auction_info);
|
||
}
|
||
break;
|
||
case AUCTION_BID_CANCEL:
|
||
if (cmd_result->result <= AUCTION_FAIL)
|
||
{
|
||
}
|
||
else
|
||
{
|
||
MyBid.Delete (commander_id, cmd_result->target);
|
||
}
|
||
}
|
||
}
|
||
|
||
#endif
|