WildEgo/server.pg
WildEgo/server.pg
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

change: Start moving to PG.

Browse Source 
remove: Auction.
This commit is contained in:
WildEgo 2025-05-31 17:58:32 +01:00
parent 7ee9c84bd3
commit 09b28e114e
37 changed files with 81 additions and 4284 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
.vscode/launch.json vendored Normal file
View File

@ -0,0 +1,12 @@
{
"configurations": [
{
"type": "cmake",
"request": "launch",
"name": "Debug portfile(s)",
"cmakeDebugType": "external",
"pipeName": "\\\\.\\pipe\\vcpkg_ext_portfile_dbg",
"preLaunchTask": "Debug vcpkg commands"
}
]
}

17
.vscode/settings.json vendored
View File

@ -1,3 +1,18 @@
{
"cmake.configureOnOpen": true
"cmake.configureOnOpen": true,
"files.associations": {
"array": "cpp",
"deque": "cpp",
"initializer_list": "cpp",
"list": "cpp",
"queue": "cpp",
"stack": "cpp",
"utility": "cpp",
"vector": "cpp",
"xhash": "cpp",
"xstring": "cpp",
"xtree": "cpp",
"xutility": "cpp"
},
"editor.formatOnSave": false
}

5
Dockerfile
View File

@ -1,3 +1,4 @@
# 22.04 is used due to python
FROM ubuntu:22.04 AS build
WORKDIR /app
@ -9,7 +10,7 @@ RUN echo 'deb [signed-by=/usr/share/keyrings/kitware-archive-keyring.gpg] https:
# Update the system and install various dependencies
RUN apt-get update && \
apt-get install -y git cmake ninja-build build-essential tar curl zip unzip pkg-config autoconf python3 \
libdevil-dev libncurses5-dev libbsd-dev
libdevil-dev libncurses5-dev libbsd-dev bison flex
# Arm specific
ENV VCPKG_FORCE_SYSTEM_BINARIES=1
@ -17,7 +18,7 @@ ENV VCPKG_FORCE_SYSTEM_BINARIES=1
# Install vcpkg and the required libraries
RUN git clone https://github.com/Microsoft/vcpkg.git
RUN bash ./vcpkg/bootstrap-vcpkg.sh
RUN ./vcpkg/vcpkg install cryptopp effolkronium-random libmariadb libevent lzo fmt spdlog argon2
RUN ./vcpkg/vcpkg install cryptopp effolkronium-random libevent lzo fmt spdlog argon2 libpq libpqxx
COPY . .

2
README.md
View File

@ -60,7 +60,7 @@ Install `vcpkg` according to the [latest instructions](https://vcpkg.io/en/getti
Build and install the required libraries:
```shell
vcpkg install cryptopp effolkronium-random libmariadb libevent lzo fmt spdlog argon2
vcpkg install cryptopp effolkronium-random libevent lzo fmt spdlog argon2 libpq
```
#### Building the binaries

335
src/common/auction_table.h
View File

@ -1,335 +0,0 @@
#ifndef __INC_AUCTION_TABLES_H__
#define __INC_AUCTION_TABLES_H__
#include "tables.h"
typedef struct _base_auction
{
public:
DWORD item_num;
TItemTable* item_proto;
int offer_price;
int price;
DWORD offer_id;
char shown_name[CHARACTER_NAME_MAX_LEN + 1];
BYTE empire;
time_t expired_time;
DWORD get_item_num () { return item_num; }
DWORD get_offer_id () { return offer_id; }
BYTE get_empire () { return empire; }
time_t get_expired_time () { return expired_time; }
bool is_expired ()
{
return (time(NULL) > expired_time);
}
int get_price () { return offer_price; }
} TAuctionSimpleItemInfo;
// 각 auction 정보들.
// primary key (item_id)
typedef struct _auction : public _base_auction
{
public:
DWORD item_id;
DWORD bidder_id;
_auction (){}
_auction (DWORD _item_num, int _offer_price, int _price, DWORD _offer_id,
char* _shown_name, time_t _expired_time, DWORD _item_id, DWORD _bidder_id, BYTE _empire)
{
item_num = _item_num;
offer_price= _offer_price;
price = _price;
offer_id = _offer_id;
memcpy(shown_name, _shown_name, strlen(_shown_name) + 1);
expired_time = _expired_time;
item_id = _item_id;
bidder_id = _bidder_id;
empire = _empire;
}
// 이 메소드들은 어떤 변수가 auction에서 어떤 역할을 하는지 까먹을 까봐
// 만들어놓았다.
// by rtsummit
DWORD get_item_id () { return item_id; }
DWORD get_bidder_id () { return bidder_id; }
int get_bid_price () { return offer_price; }
void set_bid_price (int new_price)
{
offer_price = new_price;
}
int get_impur_price () { return price; }
const char* get_bidder_name () { return shown_name; }
void set_bidder_name (const char* new_bidder_name)
{
memcpy(shown_name, new_bidder_name, strlen(new_bidder_name) + 1);
}
} TAuctionItemInfo;
// primary key (item_id)
typedef struct _sale : public _base_auction
{
_sale (){}
_sale (DWORD _item_num, int _offer_price, DWORD _offer_id,
char* _shown_name, DWORD _item_id, DWORD _wisher_id)
{
item_num = _item_num;
offer_price= _offer_price;
offer_id = _offer_id;
memcpy(shown_name, _shown_name, strlen(_shown_name) + 1);
item_id = _item_id;
wisher_id = _wisher_id;
}
DWORD item_id;
DWORD wisher_id;
} TSaleItemInfo;
// wish는 실제하는 아이템은 없다.
// primary key (item_num, wisher_id)
typedef struct _wish : public _base_auction
{
_wish (){}
_wish (DWORD _item_num, int _offer_price, DWORD _offer_id,
char* _shown_name, time_t _expired_time, BYTE _empire)
{
item_num = _item_num;
offer_price= _offer_price;
offer_id = _offer_id;
memcpy(shown_name, _shown_name, strlen(_shown_name) + 1);
expired_time = _expired_time;
empire = _empire;
}
} TWishItemInfo;
enum AuctionType {_AUCTION, _WISH_AUCTION, _MY_AUCTION, _MY_WISH_AUCTION, _AUCTION_MAX};
enum AuctionCmd {OPEN_AUCTION, OPEN_WISH_AUCTION, OPEN_MY_AUCTION, OPEN_MY_WISH_AUCTION,
AUCTION_BID, AUCTION_IMME_PUR, AUCTION_ENR_AUC, AUCTION_ENR_WISH, AUCTION_ENR_SALE,
AUCTION_GET_AUC, AUCTION_BUY_SOLD,
AUCTION_CANCEL_AUC, AUCTION_CANCEL_WISH, AUCTION_CANCEL_SALE,
AUCTION_DELETE_AUCTION_ITEM, AUCTION_DELETE_SALE_ITEM,
AUCTION_CHANGING_MONEY,
AUCTION_REBID, AUCTION_BID_CANCEL,
};
// 반드시 FAIL 앞에, 실패 류 들이 와야한다.
// 왜냐, <= AUCTION_FAIL 이런 CHECK을 할 거거든
// 반대로 SUCCESS 뒤에, 성공 류 들이 와야한다. 근데 성공류가 있긴 하려나...
enum AuctionResult { AUCTION_EXPIRED, AUCTION_NOT_EXPIRED, AUCTION_NOT_ENOUGH_MONEY,
AUCTION_SOLD, AUCTION_CANCEL, AUCTION_ALREADY_IN, AUCTION_NOT_IN, AUCTION_FAIL, AUCTION_SUCCESS };
enum AuctionSort { AUCTION_NO_ORDER,
AUCTION_ITEM_NAME_AC, AUCTION_ITEM_NAME_DC,
AUCTION_CATEGORY_AC, AUCTION_CATEGORY_DC,
AUCTION_TIME_AC, AUCTION_TIME_DC,
AUCTION_CHAR_NAME_AC, AUCTION_CHAR_NAME_DC,
AUCTION_PRICE_AC, AUCTION_PRICE_DC,
};
typedef struct command_get_auction_list
{
AuctionCmd cmd;
DWORD start_idx;
BYTE size;
} TPacketGDGetAuctionList;
typedef struct command_auction
{
void enroll_product (DWORD _item_id, BYTE _empire, int _bidPrice, int _impurPrice)
{
cmd = AUCTION_ENR_AUC;
item = _item_id;
empire = _empire;
price1 = _bidPrice;
price2 = _impurPrice;
}
void enroll_sale (DWORD _item_id, DWORD _wisher_id, int _salePrice)
{
cmd = AUCTION_ENR_SALE;
item = _item_id;
price1 = _salePrice;
player_id = _wisher_id;
}
void enroll_wish (DWORD _item_num, BYTE _empire, int _wishPrice)
{
cmd = AUCTION_ENR_WISH;
item = _item_num;
empire = _empire;
price1 = _wishPrice;
}
void bid (DWORD _item_id, int _bidPrice)
{
cmd = AUCTION_BID;
item = _item_id;
price1 = _bidPrice;
}
void impur (DWORD _item_id)
{
cmd = AUCTION_IMME_PUR;
item = _item_id;
}
void get_auctioned_item (DWORD _item_id)
{
cmd = AUCTION_GET_AUC;
item = _item_id;
}
void buy_sold_item (DWORD _item_id)
{
cmd = AUCTION_BUY_SOLD;
item = _item_id;
}
void cancel_auction (DWORD _item_id)
{
cmd = AUCTION_CANCEL_AUC;
item = _item_id;
}
void cancel_wish (DWORD _item_num)
{
cmd = AUCTION_CANCEL_WISH;
item = _item_num;
}
void cancel_sale (DWORD _item_id)
{
cmd = AUCTION_CANCEL_SALE;
item = _item_id;
}
void delete_auction_item (DWORD _item_id)
{
cmd = AUCTION_DELETE_AUCTION_ITEM;
item = _item_id;
}
void delete_sale_item (DWORD _item_id)
{
cmd = AUCTION_DELETE_SALE_ITEM;
item = _item_id;
}
void changing_money (int _money)
{
cmd = AUCTION_CHANGING_MONEY;
price1 = _money;
}
// bid랑 cmd만 다르다.
void rebid (DWORD _item_id, int _bidPrice)
{
cmd = AUCTION_REBID;
item = _item_id;
price1 = _bidPrice;
}
void bid_cancel (DWORD _item_id)
{
cmd = AUCTION_BID_CANCEL;
item = _item_id;
}
DWORD get_item () { return item; }
protected:
AuctionCmd cmd;
DWORD player_id;
DWORD item;
BYTE empire;
int price1;
int price2;
public:
AuctionCmd get_cmd() { return cmd; }
BYTE get_empire () { return empire; }
} TPacketGDCommnadAuction;
typedef struct result_auction
{
AuctionCmd cmd;
BYTE result;
DWORD target;
} TPacketDGResultAuction;
// wrapper struct
typedef struct auction_enroll_product : public command_auction
{
DWORD get_item_id() { return item; }
int get_bid_price() { return price1; }
int get_impur_price() { return price2; }
} AuctionEnrollProductInfo;
typedef struct auction_enroll_sale : public command_auction
{
DWORD get_item_id() { return item; }
DWORD get_wisher_id() { return player_id; }
int get_sale_price() { return price1; }
} AuctionEnrollSaleInfo;
typedef struct auction_enroll_wish : public command_auction
{
DWORD get_item_num() { return item; }
int get_wish_price() { return price1; }
} AuctionEnrollWishInfo;
typedef struct auction_bid : public command_auction
{
DWORD get_item_id() { return item; }
int get_bid_price() { return price1; }
} AuctionBidInfo;
typedef struct auction_impur : public command_auction
{
DWORD get_item_id() { return item; }
} AuctionImpurInfo;
//typedef struct get_auction_list
//
//bid
//{
// item_id;
// bidder_id;
// price;
//}
//impur
//{
// item_id;
// purchaser_id;
//}
//enroll_wish
//{
// item_num;
// wisher_id;
// wish_price;
//}
//enroll_sale
//{
// item_id;
// seller_id;
// sale_price;
//}
//
//return_packet
//{
// isSuccess;
//}
//
//
//get_auction_simple_item_info_list
//{
// auction_type;
// start_idx;
// size;
// conditions; 정렬은 승철님께 조언을 구해보자.ㅇㅇ
//}
//
//get_auction_detail_item_info
//{
// item_id;
//}
#endif

3
src/common/length.h
View File

@ -456,9 +456,6 @@ enum EWindows
MALL,
DRAGON_SOUL_INVENTORY,
BELT_INVENTORY,
#ifdef __AUCTION__
AUCTION,
#endif
GROUND
};

1
src/common/service.h
View File

@ -1,6 +1,5 @@
#ifndef __INC_SERVICE_H__
#define __INC_SERVICE_H__
//#define __AUCTION__
#define __PET_SYSTEM__
#endif

10
src/common/tables.h
View File

@ -130,12 +130,6 @@ enum
HEADER_GD_VALID_LOGOUT = 134,
// AUCTION
#ifdef __AUCTION__
HEADER_GD_GET_AUCTION_LIST = 135,
HEADER_GD_COMMAND_AUCTION = 136,
#endif
HEADER_GD_REQUEST_CHARGE_CASH = 137,
HEADER_GD_DELETE_AWARDID = 138, // delete gift notify icon
@ -262,9 +256,7 @@ enum
HEADER_DG_ACK_HORSE_NAME = 176,
HEADER_DG_NEED_LOGIN_LOG = 177,
#ifdef __AUCTION__
HEADER_DG_AUCTION_RESULT = 178,
#endif
HEADER_DG_RESULT_CHARGE_CASH = 179,
HEADER_DG_ITEMAWARD_INFORMER = 180, //gift notify
HEADER_DG_RESPOND_CHANNELSTATUS = 181,

2
src/db/CMakeLists.txt
View File

@ -1,4 +1,4 @@
cmake_minimum_required(VERSION 3.8)
cmake_minimum_required(VERSION 3.12)
project(db CXX)

719
src/db/src/AuctionManager.cpp
View File

@ -1,719 +0,0 @@
#include "stdafx.h"
#ifdef __AUCTION__
#include "DBManager.h"
#include "Peer.h"
#include "AuctionManager.h"
void MyBidBoard::Boot (CPeer* peer)
{
peer->EncodeWORD(sizeof(DWORD) + sizeof(DWORD) + sizeof(int));
peer->EncodeWORD(Size());
for (TMyBidBoard::iterator pc_it = pc_map.begin(); pc_it != pc_map.end(); pc_it++)
{
TItemMap* item_map = pc_it->second;
for (TItemMap::iterator it = item_map->begin(); it != item_map->end(); it++)
{
peer->Encode(&(pc_it->first), sizeof(DWORD));
peer->Encode(&(it->first), sizeof(DWORD));
peer->Encode(&(it->second), sizeof(int));
}
}
}
size_t MyBidBoard::Size ()
{
size_t size = 0;
for (TMyBidBoard::iterator it = pc_map.begin(); it != pc_map.end(); it++)
{
size += it->second->size();
}
return size;
}
int MyBidBoard::GetMoney (DWORD player_id, DWORD item_id)
{
TMyBidBoard::iterator pc_it = pc_map.find (player_id);
if (pc_it == pc_map.end())
{
return -1;
}
TItemMap* item_map = pc_it->second;
TItemMap::iterator it = item_map->find (item_id);
if (it == item_map->end())
return -1;
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);
}
char szQuery[512];
snprintf(szQuery, sizeof(szQuery), "DELETE FROM my_bid WHERE player_id = %d and item_id = %d", player_id, item_id);
CDBManager::instance().AsyncQuery(szQuery);
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, money));
}
else
{
it->second = money;
}
char szQuery[512];
snprintf(szQuery, sizeof(szQuery), "REPLACE INTO my_bid VALUES (%d, %d, %d)", player_id, item_id, money);
CDBManager::instance().AsyncQuery(szQuery);
}
AuctionManager::AuctionManager()
{
}
AuctionManager::~AuctionManager()
{
}
void AuctionManager::Initialize()
{ auction_item_cache_map.clear();
LoadAuctionItem();
LoadAuctionInfo();
LoadSaleInfo();
LoadWishInfo();
LoadMyBidInfo();
}
void AuctionManager::LoadAuctionItem()
{
char szQuery[512];
snprintf(szQuery, sizeof(szQuery),
"SELECT id, owner_id, count, vnum, socket0, socket1, socket2, "
"attrtype0, attrvalue0, "
"attrtype1, attrvalue1, "
"attrtype2, attrvalue2, "
"attrtype3, attrvalue3, "
"attrtype4, attrvalue4, "
"attrtype5, attrvalue5, "
"attrtype6, attrvalue6 "
"FROM item WHERE window = 'AUCTION'");
SQLMsg *msg = CDBManager::instance().DirectQuery(szQuery);
MYSQL_RES *res = msg->Get()->pSQLResult;
if (!res)
{
return;
}
int rows;
if ((rows = mysql_num_rows(res)) <= 0) // 데이터 없음
{
return;
}
for (int i = 0; i < rows; ++i)
{
MYSQL_ROW row = mysql_fetch_row(res);
TPlayerItem item;
int cur = 0;
str_to_number(item.id, row[cur++]);
str_to_number(item.owner, row[cur++]);
item.window = AUCTION;
str_to_number(item.count, row[cur++]);
str_to_number(item.vnum, row[cur++]);
str_to_number(item.alSockets[0], row[cur++]);
str_to_number(item.alSockets[1], row[cur++]);
str_to_number(item.alSockets[2], row[cur++]);
for (int j = 0; j < ITEM_ATTRIBUTE_MAX_NUM; j++)
{
str_to_number(item.aAttr[j].bType, row[cur++]);
str_to_number(item.aAttr[j].sValue, row[cur++]);
}
InsertItemCache(&item, true);
}
return;
}
void AuctionManager::LoadAuctionInfo()
{
char szQuery[512];
snprintf(szQuery, sizeof(szQuery),
"select * from auction");
SQLMsg *msg = CDBManager::instance().DirectQuery(szQuery);
MYSQL_RES *res = msg->Get()->pSQLResult;
if (!res)
{
return;
}
int rows;
if ((rows = mysql_num_rows(res)) <= 0) // 데이터 없음
{
return;
}
for (int i = 0; i < rows; ++i)
{
MYSQL_ROW row = mysql_fetch_row(res);
TAuctionItemInfo auctionItemInfo;
int cur = 0;
str_to_number(auctionItemInfo.item_num, row[cur++]);
str_to_number(auctionItemInfo.offer_price, row[cur++]);
str_to_number(auctionItemInfo.price, row[cur++]);
str_to_number(auctionItemInfo.offer_id, row[cur++]);
memcpy (auctionItemInfo.shown_name, (char*)row[cur], strlen((char*)row[cur]) +1);
cur++;
str_to_number(auctionItemInfo.empire, row[cur++]);
str_to_number(auctionItemInfo.expired_time, row[cur++]);
str_to_number(auctionItemInfo.item_id, row[cur++]);
str_to_number(auctionItemInfo.bidder_id, row[cur++]);
InsertAuctionItemInfoCache(&auctionItemInfo, true);
}
return;
}
void AuctionManager::LoadSaleInfo()
{
char szQuery[512];
snprintf(szQuery, sizeof(szQuery),
"select * from sale");
SQLMsg *msg = CDBManager::instance().DirectQuery(szQuery);
MYSQL_RES *res = msg->Get()->pSQLResult;
if (!res)
{
return;
}
int rows;
if ((rows = mysql_num_rows(res)) <= 0) // 데이터 없음
{
return;
}
for (int i = 0; i < rows; ++i)
{
MYSQL_ROW row = mysql_fetch_row(res);
TSaleItemInfo saleItemInfo;
int cur = 0;
str_to_number(saleItemInfo.item_num, row[cur++]);
str_to_number(saleItemInfo.offer_price, row[cur++]);
str_to_number(saleItemInfo.price, row[cur++]);
str_to_number(saleItemInfo.offer_id, row[cur++]);
memcpy (saleItemInfo.shown_name, (char*)row[cur], strlen((char*)row[cur]) +1);
cur++;
str_to_number(saleItemInfo.empire, row[cur++]);
str_to_number(saleItemInfo.expired_time, row[cur++]);
str_to_number(saleItemInfo.item_id, row[cur++]);
str_to_number(saleItemInfo.wisher_id, row[cur++]);
InsertSaleItemInfoCache(&saleItemInfo, true);
}
return;
}
void AuctionManager::LoadWishInfo()
{
char szQuery[512];
snprintf(szQuery, sizeof(szQuery),
"select * from wish");
SQLMsg *msg = CDBManager::instance().DirectQuery(szQuery);
MYSQL_RES *res = msg->Get()->pSQLResult;
if (!res)
{
return;
}
int rows;
if ((rows = mysql_num_rows(res)) <= 0) // 데이터 없음
{
return;
}
for (int i = 0; i < rows; ++i)
{
MYSQL_ROW row = mysql_fetch_row(res);
TWishItemInfo wishItemInfo;
int cur = 0;
str_to_number(wishItemInfo.item_num, row[cur++]);
str_to_number(wishItemInfo.offer_price, row[cur++]);
str_to_number(wishItemInfo.price, row[cur++]);
str_to_number(wishItemInfo.offer_id, row[cur++]);
memcpy (wishItemInfo.shown_name, (char*)row[cur], strlen((char*)row[cur]) +1);
cur++;
str_to_number(wishItemInfo.empire, row[cur++]);
str_to_number(wishItemInfo.expired_time, row[cur++]);
InsertWishItemInfoCache(&wishItemInfo, true);
}
return;
}
void AuctionManager::LoadMyBidInfo ()
{
char szQuery[512];
snprintf(szQuery, sizeof(szQuery),
"select * from my_bid");
SQLMsg *msg = CDBManager::instance().DirectQuery(szQuery);
MYSQL_RES *res = msg->Get()->pSQLResult;
if (!res)
{
return;
}
int rows;
if ((rows = mysql_num_rows(res)) <= 0) // 데이터 없음
{
return;
}
for (int i = 0; i < rows; ++i)
{
MYSQL_ROW row = mysql_fetch_row(res);
int cur = 0;
DWORD player_id;
DWORD item_id;
int money;
str_to_number(player_id, row[cur++]);
str_to_number(item_id, row[cur++]);
str_to_number(money, row[cur++]);
InsertMyBid (player_id, item_id, money);
}
return;
}
inline CItemCache* AuctionManager::GetItemCache(DWORD item_id)
{
TItemCacheMap::iterator it = auction_item_cache_map.find (item_id);
if (it == auction_item_cache_map.end())
return NULL;
else
return it->second;
}
void AuctionManager::Boot(CPeer* peer)
{
peer->EncodeWORD(sizeof(TPlayerItem));
peer->EncodeWORD(auction_item_cache_map.size());
itertype(auction_item_cache_map) auction_item_cache_map_it = auction_item_cache_map.begin();
while (auction_item_cache_map_it != auction_item_cache_map.end())
peer->Encode((auction_item_cache_map_it++)->second->Get(), sizeof(TPlayerItem));
Auction.Boot(peer);
Sale.Boot(peer);
Wish.Boot(peer);
MyBid.Boot(peer);
}
bool AuctionManager::InsertItemCache(CItemCache *item_cache, bool bSkipQuery)
{
CItemCache* c = GetItemCache (item_cache->Get(false)->id);
if (c != NULL)
{
return false;
}
auction_item_cache_map.insert(TItemCacheMap::value_type(item_cache->Get(true)->id, item_cache));
item_cache->OnFlush();
return true;
}
bool AuctionManager::InsertItemCache(TPlayerItem * pNew, bool bSkipQuery)
{
CItemCache* c = GetItemCache (pNew->id);
if (c != NULL)
{
return false;
}
c = new CItemCache();
c->Put(pNew, bSkipQuery);
auction_item_cache_map.insert(TItemCacheMap::value_type(pNew->id, c));
c->Flush();
return true;
}
bool AuctionManager::DeleteItemCache(DWORD item_id)
{
CItemCache* c = GetItemCache (item_id);
if (c == NULL)
{
return false;
}
c->Delete();
return true;
}
AuctionResult AuctionManager::EnrollInAuction(CItemCache* item_cache, TAuctionItemInfo &item_info)
{
CItemCache* c = GetItemCache (item_info.item_id);
if (c != NULL)
{
SPDLOG_ERROR("item id : {} is already in AuctionManager", item_info.item_id);
return AUCTION_FAIL;
}
if (!Auction.InsertItemInfo (&item_info))
{
SPDLOG_ERROR("item id : {} is already in AuctionBoard", item_info.item_id);
return AUCTION_FAIL;
}
item_cache->Get()->window = AUCTION;
item_cache->Get()->pos = 9999999;
InsertItemCache (item_cache);
return AUCTION_SUCCESS;
}
AuctionResult AuctionManager::EnrollInSale(CItemCache* item_cache, TSaleItemInfo &item_info)
{
CItemCache* c = GetItemCache (item_info.item_id);
if (c != NULL)
{
SPDLOG_ERROR("item id : {} is already in AuctionManager", item_info.item_id);
return AUCTION_FAIL;
}
if (!Wish.GetItemInfoCache (WishBoard::Key (item_info.item_num, item_info.wisher_id)))
{
SPDLOG_ERROR("item_num : {}, wisher_id : {} is not in wish auction.", item_info.item_num, item_info.wisher_id);
return AUCTION_FAIL;
}
if (!Sale.InsertItemInfo (&item_info))
{
SPDLOG_ERROR("item id : {} is already in SaleBoard", item_info.item_id);
return AUCTION_FAIL;
}
item_cache->Get()->window = AUCTION;
item_cache->Get()->pos = 999999;
InsertItemCache (item_cache);
return AUCTION_SUCCESS;
}
AuctionResult AuctionManager::EnrollInWish(TWishItemInfo &item_info)
{
if (!Wish.InsertItemInfo (&item_info))
{
SPDLOG_ERROR("wisher_id : {}, item_num : {} is already in WishBoard", item_info.offer_id, item_info.item_num);
return AUCTION_FAIL;
}
return AUCTION_SUCCESS;
}
AuctionResult AuctionManager::Bid(DWORD bidder_id, const char* bidder_name, DWORD item_id, DWORD bid_price)
{
CItemCache* c = GetItemCache (item_id);
if (c == NULL)
{
SPDLOG_ERROR("item id : {} does not exist in auction.", item_id);
return AUCTION_FAIL;
}
if (MyBid.GetMoney (bidder_id, item_id) != 0)
{
return AUCTION_ALREADY_IN;
}
CAuctionItemInfoCache* item_cache = Auction.GetItemInfoCache(item_id);
TAuctionItemInfo* item_info = item_cache->Get(false);
if (item_info->is_expired())
{
return AUCTION_EXPIRED;
}
if ((double)bid_price < (double)item_info->get_bid_price() * 1.05)
{
return AUCTION_NOT_ENOUGH_MONEY;
}
item_info->set_bid_price(bid_price);
item_info->bidder_id = bidder_id;
item_info->set_bidder_name (bidder_name);
item_cache->OnFlush();
InsertMyBid (bidder_id, item_id, bid_price);
return AUCTION_SUCCESS;
}
AuctionResult AuctionManager::Impur(DWORD purchaser_id, const char* purchaser_name, DWORD item_id)
{
CItemCache* c = GetItemCache (item_id);
if (c == NULL)
{
SPDLOG_ERROR("item id : {} does not exist in auction.", item_id);
return AUCTION_FAIL;
}
CAuctionItemInfoCache* item_cache = Auction.GetItemInfoCache(item_id);
TAuctionItemInfo* item_info = item_cache->Get(false);
if (item_info->is_expired())
{
return AUCTION_EXPIRED;
}
// 즉구 해버렸으므로, 경매는 끝났다.
item_info->expired_time = 0;
item_info->bidder_id = purchaser_id;
item_info->set_bidder_name (purchaser_name);
item_info->set_bid_price (item_info->get_impur_price());
item_cache->OnFlush();
return AUCTION_SUCCESS;
}
AuctionResult AuctionManager::GetAuctionedItem (DWORD actor_id, DWORD item_id, TPlayerItem& item)
{
CItemCache* c = GetItemCache (item_id);
if (c == NULL)
{
SPDLOG_ERROR("item id : {} does not exist in auction.", item_id);
return AUCTION_FAIL;
}
CAuctionItemInfoCache* item_info_cache = Auction.GetItemInfoCache(item_id);
if (item_info_cache == NULL)
{
SPDLOG_ERROR("how can this accident happen?");
return AUCTION_FAIL;
}
TAuctionItemInfo* item_info = item_info_cache->Get(false);
if (!item_info->is_expired())
{
return AUCTION_NOT_EXPIRED;
}
memcpy(&item, c->Get(), sizeof(TPlayerItem));
return AUCTION_SUCCESS;
}
AuctionResult AuctionManager::BuySoldItem (DWORD actor_id, DWORD item_id, TPlayerItem& item)
{
CItemCache* c = GetItemCache (item_id);
if (c == NULL)
{
SPDLOG_ERROR("item id : {} does not exist in auction.", item_id);
return AUCTION_FAIL;
}
CSaleItemInfoCache* item_info_cache = Sale.GetItemInfoCache(item_id);
if (item_info_cache == NULL)
{
SPDLOG_ERROR("how can this accident happen?");
return AUCTION_FAIL;
}
TSaleItemInfo* item_info = item_info_cache->Get(false);
memcpy(&item, c->Get(), sizeof(TPlayerItem));
return AUCTION_SUCCESS;
}
AuctionResult AuctionManager::CancelAuction (DWORD actor_id, DWORD item_id, TPlayerItem& item)
{
CItemCache* c = GetItemCache (item_id);
if (c == NULL)
{
SPDLOG_ERROR("item id : {} does not exist in auction.", item_id);
return AUCTION_FAIL;
}
CAuctionItemInfoCache* item_info_cache = Auction.GetItemInfoCache(item_id);
if (item_info_cache == NULL)
{
SPDLOG_ERROR("how can this accident happen?");
return AUCTION_FAIL;
}
TAuctionItemInfo* item_info = item_info_cache->Get(false);
memcpy(&item, c->Get(), sizeof(TPlayerItem));
return AUCTION_SUCCESS;
}
AuctionResult AuctionManager::CancelWish (DWORD actor_id, DWORD item_num)
{
if (!Wish.DeleteItemInfoCache (WishBoard::Key (actor_id, item_num)))
{
return AUCTION_FAIL;
}
else
{
return AUCTION_SUCCESS;
}
}
AuctionResult AuctionManager::CancelSale (DWORD actor_id, DWORD item_id, TPlayerItem& item)
{
CItemCache* c = GetItemCache (item_id);
if (c == NULL)
{
SPDLOG_ERROR("item id : {} does not exist in auction.", item_id);
return AUCTION_FAIL;
}
CSaleItemInfoCache* item_info_cache = Sale.GetItemInfoCache(item_id);
if (item_info_cache == NULL)
{
SPDLOG_ERROR("how can this accident happen?");
return AUCTION_FAIL;
}
TSaleItemInfo* item_info = item_info_cache->Get(false);
memcpy(&item, c->Get(), sizeof(TPlayerItem));
return AUCTION_SUCCESS;
}
AuctionResult AuctionManager::DeleteAuctionItem (DWORD actor_id, DWORD item_id)
{
if (DeleteItemCache (item_id) == false)
{
SPDLOG_ERROR("item id : {} does not exist in auction.", item_id);
return AUCTION_FAIL;
}
if (Auction.DeleteItemInfoCache (item_id) == NULL)
{
SPDLOG_ERROR("how can this accident happen?");
return AUCTION_FAIL;
}
return AUCTION_SUCCESS;
}
AuctionResult AuctionManager::DeleteSaleItem (DWORD actor_id, DWORD item_id)
{
if (DeleteItemCache (item_id) == false)
{
SPDLOG_ERROR("item id : {} does not exist in auction.", item_id);
return AUCTION_FAIL;
}
if (Sale.DeleteItemInfoCache (item_id) == NULL)
{
SPDLOG_ERROR("how can this accident happen?");
return AUCTION_FAIL;
}
return AUCTION_SUCCESS;
}
AuctionResult AuctionManager::ReBid(DWORD bidder_id, const char* bidder_name, DWORD item_id, DWORD bid_price)
{
CItemCache* c = GetItemCache (item_id);
if (c == NULL)
{
SPDLOG_ERROR("item id : {} does not exist in auction.", item_id);
return AUCTION_FAIL;
}
int money = MyBid.GetMoney (bidder_id, item_id);
if (money == -1)
{
return AUCTION_NOT_IN;
}
CAuctionItemInfoCache* item_cache = Auction.GetItemInfoCache(item_id);
TAuctionItemInfo* item_info = item_cache->Get(false);
if (item_info->is_expired())
{
return AUCTION_EXPIRED;
}
if ((double)(bid_price + money) < (double)item_info->get_bid_price() * 1.05)
{
return AUCTION_NOT_ENOUGH_MONEY;
}
item_info->set_bid_price(bid_price + money);
item_info->bidder_id = bidder_id;
item_info->set_bidder_name (bidder_name);
item_cache->OnFlush();
InsertMyBid (bidder_id, item_id, money + bid_price);
return AUCTION_SUCCESS;
}
AuctionResult AuctionManager::BidCancel (DWORD bidder_id, DWORD item_id)
{
if (MyBid.Delete (bidder_id, item_id))
{
return AUCTION_SUCCESS;
}
else
{
return AUCTION_NOT_IN;
}
}
#endif

370
src/db/src/AuctionManager.h
View File

@ -1,370 +0,0 @@
#ifdef __AUCTION__
#ifndef __INC_AUCTION_MANAGER_H__
#define __INC_AUCTION_MANAGER_H__
#include <unordered_map>
#include "Cache.h"
#include <common/auction_table.h>
class CItemCache;
class CAuctionItemInfoCache;
class CSaleItemInfoCache;
class CWishItemInfoCache;
template<>
class hash<std::pair <DWORD, DWORD> >
{ // hash functor
public:
typedef std::pair <DWORD, DWORD> _Kty;
size_t operator()(const _Kty& _Keyval) const
{ // hash _Keyval to size_t value by pseudorandomizing transform
ldiv_t _Qrem = ldiv((size_t)_Keyval.first + (size_t)_Keyval.second, 127773);
_Qrem.rem = 16807 * _Qrem.rem - 2836 * _Qrem.quot;
if (_Qrem.rem < 0)
_Qrem.rem += 2147483647;
return ((size_t)_Qrem.rem);
}
};
class AuctionBoard
{
public:
typedef DWORD Key;
typedef CAuctionItemInfoCache ItemInfoCache;
typedef TAuctionItemInfo ItemInfo;
public:
AuctionBoard() {}
~AuctionBoard() {}
void Boot(CPeer* peer)
{
peer->EncodeWORD(sizeof(ItemInfo));
peer->EncodeWORD(item_cache_map.size());
TItemInfoCacheMap::iterator it = item_cache_map.begin();
while (it != item_cache_map.end())
peer->Encode((it++)->second->Get(), sizeof(ItemInfo));
}
size_t Size()
{
return item_cache_map.size();
}
ItemInfoCache* GetItemInfoCache (Key key)
{
TItemInfoCacheMap::iterator it = item_cache_map.find (key);
if (it == item_cache_map.end())
return NULL;
else
return it->second;
}
bool DeleteItemInfoCache (Key key)
{
TItemInfoCacheMap::iterator it = item_cache_map.find (key);
if (it == item_cache_map.end())
return false;
else
{
it->second->Delete();
item_cache_map.erase(it);
return true;
}
}
bool InsertItemInfo (ItemInfo *pNew, bool bSkipQuery = false)
{
ItemInfoCache* c = GetItemInfoCache (Key (pNew->item_id));
if (c != NULL)
{
return false;
}
c = new ItemInfoCache();
c->Put(pNew, bSkipQuery);
item_cache_map.insert(TItemInfoCacheMap::value_type(pNew->item_id, c));
c->Flush();
return true;
}
private:
typedef std::unordered_map <Key, ItemInfoCache *> TItemInfoCacheMap;
TItemInfoCacheMap item_cache_map;
};
class SaleBoard
{
public:
typedef DWORD Key;
typedef CSaleItemInfoCache ItemInfoCache;
typedef TSaleItemInfo ItemInfo;
SaleBoard() {}
~SaleBoard() {}
void Boot(CPeer* peer)
{
peer->EncodeWORD(sizeof(ItemInfo));
peer->EncodeWORD(item_cache_map.size());
TItemInfoCacheMap::iterator it = item_cache_map.begin();
while (it != item_cache_map.end())
peer->Encode((it++)->second->Get(), sizeof(ItemInfo));
}
size_t Size()
{
return item_cache_map.size();
}
ItemInfoCache* GetItemInfoCache (Key key)
{
TItemInfoCacheMap::iterator it = item_cache_map.find (key);
if (it == item_cache_map.end())
return NULL;
else
return it->second;
}
bool DeleteItemInfoCache (Key key)
{
TItemInfoCacheMap::iterator it = item_cache_map.find (key);
if (it == item_cache_map.end())
return false;
else
{
it->second->Delete();
item_cache_map.erase(it);
return true;
}
}
bool InsertItemInfo (ItemInfo *pNew, bool bSkipQuery = false)
{
ItemInfoCache* c = GetItemInfoCache (Key (pNew->item_id));
if (c != NULL)
{
return false;
}
c = new ItemInfoCache();
c->Put(pNew, bSkipQuery);
item_cache_map.insert(TItemInfoCacheMap::value_type(pNew->item_id, c));
c->Flush();
return true;
}
private:
typedef std::unordered_map <Key, ItemInfoCache *> TItemInfoCacheMap;
TItemInfoCacheMap item_cache_map;
};
class WishBoard
{
public:
typedef std::pair <DWORD, DWORD> Key;
typedef CWishItemInfoCache ItemInfoCache;
typedef TWishItemInfo ItemInfo;
WishBoard() {}
virtual ~WishBoard() {}
void Boot(CPeer* peer)
{
peer->EncodeWORD(sizeof(ItemInfo));
peer->EncodeWORD(item_cache_map.size());
TItemInfoCacheMap::iterator it = item_cache_map.begin();
while (it != item_cache_map.end())
peer->Encode((it++)->second->Get(), sizeof(ItemInfo));
}
size_t Size()
{
return item_cache_map.size();
}
ItemInfoCache* GetItemInfoCache (Key key)
{
TItemInfoCacheMap::iterator it = item_cache_map.find (key);
if (it == item_cache_map.end())
return NULL;
else
return it->second;
}
bool DeleteItemInfoCache (Key key)
{
TItemInfoCacheMap::iterator it = item_cache_map.find (key);
if (it == item_cache_map.end())
return false;
else
{
it->second->Delete();
item_cache_map.erase(it);
return true;
}
}
bool InsertItemInfo (ItemInfo *pNew, bool bSkipQuery = false)
{
ItemInfoCache* c = GetItemInfoCache (Key (pNew->item_num, pNew->offer_id));
if (c != NULL)
{
return false;
}
c = new ItemInfoCache();
c->Put(pNew, bSkipQuery);
item_cache_map.insert(TItemInfoCacheMap::value_type(Key (pNew->item_num, pNew->offer_id), c));
c->Flush();
return true;
}
private:
typedef std::unordered_map <Key, ItemInfoCache *> TItemInfoCacheMap;
TItemInfoCacheMap item_cache_map;
};
// pc가 입찰에 참여했던 경매를 관리.
class MyBidBoard
{
public:
MyBidBoard() {}
~MyBidBoard() {}
void Boot(CPeer* peer);
size_t Size();
int GetMoney (DWORD player_id, DWORD item_id);
bool Delete (DWORD player_id, DWORD item_id);
// 이미 있으면 덮어 씌운다.
void Insert (DWORD player_id, DWORD item_id, int money);
private:
typedef std::map <DWORD, int> TItemMap;
typedef std::unordered_map <DWORD, TItemMap*> TMyBidBoard;
TMyBidBoard pc_map;
};
class AuctionManager : public singleton <AuctionManager>
{
private:
// auction에 등록된 아이템들.
typedef std::unordered_map<DWORD, CItemCache *> TItemCacheMap;
TItemCacheMap auction_item_cache_map;
// auction에 등록된 정보 중 가격, 등등 아이템 테이블에 포함되지 않는 정보들을 관리하는 것들
AuctionBoard Auction;
SaleBoard Sale;
WishBoard Wish;
MyBidBoard MyBid;
public:
AuctionManager();
~AuctionManager();
void Initialize ();
void LoadAuctionItem ();
void LoadAuctionInfo ();
void LoadSaleInfo ();
void LoadWishInfo ();
void LoadMyBidInfo ();
void Boot(CPeer* peer);
bool InsertItemCache (CItemCache *item_cache, bool bSkipQuery = false);
bool InsertItemCache (TPlayerItem * pNew, bool bSkipQuery = false);
bool DeleteItemCache (DWORD item_id);
CItemCache* GetItemCache (DWORD item_id);
size_t GetAuctionItemSize()
{
return auction_item_cache_map.size();
}
size_t GetAuctionSize()
{
return Auction.Size();
}
size_t GetSaleSize()
{
return Sale.Size();
}
size_t GetWishSize()
{
return Wish.Size();
}
size_t GetMyBidSize()
{
return MyBid.Size();
}
void InsertAuctionItemInfoCache (TAuctionItemInfo *pNew, bool bSkipQuery = false)
{
Auction.InsertItemInfo (pNew, bSkipQuery);
}
CAuctionItemInfoCache* GetAuctionItemInfoCache (DWORD item_id)
{
return Auction.GetItemInfoCache(item_id);
}
void InsertSaleItemInfoCache (TSaleItemInfo *pNew, bool bSkipQuery = false)
{
Sale.InsertItemInfo (pNew, bSkipQuery);
}
CSaleItemInfoCache* GetSaleItemInfoCache (DWORD item_id)
{
return Sale.GetItemInfoCache(item_id);
}
void InsertWishItemInfoCache (TWishItemInfo *pNew, bool bSkipQuery = false)
{
Wish.InsertItemInfo (pNew, bSkipQuery);
}
CWishItemInfoCache* GetWishItemInfoCache (DWORD item_id, DWORD wisher_id)
{
return Wish.GetItemInfoCache(WishBoard::Key (item_id, wisher_id));
}
void InsertMyBid (DWORD player_id, DWORD item_id, DWORD money)
{
MyBid.Insert (player_id, item_id, money);
}
AuctionResult EnrollInAuction(CItemCache* item_cache, TAuctionItemInfo &item_info);
AuctionResult EnrollInSale(CItemCache* item_cache, TSaleItemInfo &item_info);
AuctionResult EnrollInWish(TWishItemInfo &item_info);
AuctionResult Bid(DWORD bidder_id, const char* bidder_name, DWORD item_id, DWORD bid_price);
AuctionResult Impur(DWORD purchaser_id, const char* purchaser_name, DWORD item_id);
AuctionResult GetAuctionedItem (DWORD actor_id, DWORD item_id, TPlayerItem& item);
AuctionResult BuySoldItem (DWORD actor_id, DWORD item_id, TPlayerItem& item);
AuctionResult CancelAuction (DWORD actor_id, DWORD item_id, TPlayerItem& item);
AuctionResult CancelWish (DWORD actor_id, DWORD item_num);
AuctionResult CancelSale (DWORD actor_id, DWORD item_id, TPlayerItem& item);
AuctionResult DeleteAuctionItem (DWORD actor_id, DWORD item_id);
AuctionResult DeleteSaleItem (DWORD actor_id, DWORD item_id);
AuctionResult ReBid(DWORD bidder_id, const char* bidder_name, DWORD item_id, DWORD bid_price);
AuctionResult BidCancel (DWORD bidder_id, DWORD item_id);
};
#endif
#endif

95
src/db/src/Cache.cpp
View File

@ -4,9 +4,6 @@
#include "QID.h"
#include "ClientManager.h"
#ifdef __AUCTION__
#include "AuctionManager.h"
#endif
#include "Main.h"
extern CPacketInfo g_item_info;
@ -18,7 +15,6 @@ extern int g_iItemPriceListTableCacheFlushSeconds;
// END_OF_MYSHOP_PRICE_LIST
//
extern int g_item_count;
const int auctionMinFlushSec = 1800;
CItemCache::CItemCache()
{
@ -267,94 +263,3 @@ void CItemPriceListTableCache::OnFlush()
m_bNeedQuery = false;
}
// END_OF_MYSHOP_PRICE_LIST
#ifdef __AUCTION__
CAuctionItemInfoCache::CAuctionItemInfoCache()
{
m_expireTime = MIN (auctionMinFlushSec, g_iItemCacheFlushSeconds);
}
CAuctionItemInfoCache::~CAuctionItemInfoCache()
{
}
void CAuctionItemInfoCache::Delete()
{
if (m_data.item_num == 0)
return;
SPDLOG_TRACE("CAuctionItemInfoCache::Delete : DELETE {}", m_data.item_id);
m_data.item_num = 0;
m_bNeedQuery = true;
m_lastUpdateTime = time(0);
OnFlush();
delete this;
}
void CAuctionItemInfoCache::OnFlush()
{
char szQuery[QUERY_MAX_LEN];
if (m_data.item_num == 0)
{
snprintf(szQuery, sizeof(szQuery), "DELETE FROM auction where item_id = %d", m_data.item_id);
CDBManager::instance().AsyncQuery(szQuery);
}
else
{
snprintf(szQuery, sizeof(szQuery), "REPLACE INTO auction VALUES (%u, %d, %d, %u, \"%s\", %u, %u, %u, %u)",
m_data.item_num, m_data.offer_price, m_data.price, m_data.offer_id, m_data.shown_name, (DWORD)m_data.empire, (DWORD)m_data.expired_time,
m_data.item_id, m_data.bidder_id);
CDBManager::instance().AsyncQuery(szQuery);
}
}
CSaleItemInfoCache::CSaleItemInfoCache()
{
m_expireTime = MIN (auctionMinFlushSec, g_iItemCacheFlushSeconds);
}
CSaleItemInfoCache::~CSaleItemInfoCache()
{
}
void CSaleItemInfoCache::Delete()
{
}
void CSaleItemInfoCache::OnFlush()
{
char szQuery[QUERY_MAX_LEN];
snprintf(szQuery, sizeof(szQuery), "REPLACE INTO sale VALUES (%u, %d, %d, %u, \"%s\", %u, %u, %u, %u)",
m_data.item_num, m_data.offer_price, m_data.price, m_data.offer_id, m_data.shown_name, (DWORD)m_data.empire, (DWORD)m_data.expired_time,
m_data.item_id, m_data.wisher_id);
CDBManager::instance().AsyncQuery(szQuery);
}
CWishItemInfoCache::CWishItemInfoCache()
{
m_expireTime = MIN (auctionMinFlushSec, g_iItemCacheFlushSeconds);
}
CWishItemInfoCache::~CWishItemInfoCache()
{
}
void CWishItemInfoCache::Delete()
{
}
void CWishItemInfoCache::OnFlush()
{
char szQuery[QUERY_MAX_LEN];
snprintf(szQuery, sizeof(szQuery), "REPLACE INTO wish VALUES (%u, %d, %d, %u, \"%s\", %u, %d)",
m_data.item_num, m_data.offer_price, m_data.price, m_data.offer_id, m_data.shown_name, (DWORD)m_data.empire, (DWORD)m_data.expired_time);
CDBManager::instance().AsyncQuery(szQuery);
}
#endif

36
src/db/src/Cache.h
View File

@ -3,7 +3,6 @@
#define __INC_DB_CACHE_H__
#include <common/cache.h>
#include <common/auction_table.h>
class CItemCache : public cache<TPlayerItem>
{
@ -59,39 +58,4 @@ class CItemPriceListTableCache : public cache< TItemPriceListTable >
static const int s_nMinFlushSec; ///< Minimum cache expire time
};
// END_OF_MYSHOP_PRICE_LIST
#ifdef __AUCTION__
class CAuctionItemInfoCache : public cache <TAuctionItemInfo>
{
public:
typedef TWishItemInfo value_type;
CAuctionItemInfoCache();
virtual ~CAuctionItemInfoCache();
void Delete();
virtual void OnFlush();
};
class CSaleItemInfoCache : public cache <TSaleItemInfo>
{
public:
typedef TWishItemInfo value_type;
CSaleItemInfoCache();
virtual ~CSaleItemInfoCache();
void Delete();
virtual void OnFlush();
};
class CWishItemInfoCache : public cache <TWishItemInfo>
{
public:
typedef TWishItemInfo value_type;
CWishItemInfoCache();
virtual ~CWishItemInfoCache();
void Delete();
virtual void OnFlush();
};
#endif
#endif

699
src/db/src/ClientManager.cpp
View File

@ -18,9 +18,6 @@
#include "Monarch.h"
#include "ItemIDRangeManager.h"
#include "Cache.h"
#ifdef __AUCTION__
#include "AuctionManager.h"
#endif
extern int g_iPlayerCacheFlushSeconds;
extern int g_iItemCacheFlushSeconds;
extern int g_test_server;
@ -349,13 +346,6 @@ void CClientManager::QUERY_BOOT(CPeer* peer, TPacketGDBoot * p)
sizeof(WORD) + sizeof(WORD) + sizeof(building::TLand) * m_vec_kLandTable.size() +
sizeof(WORD) + sizeof(WORD) + sizeof(building::TObjectProto) * m_vec_kObjectProto.size() +
sizeof(WORD) + sizeof(WORD) + sizeof(building::TObject) * m_map_pkObjectTable.size() +
#ifdef __AUCTION__
sizeof(WORD) + sizeof(WORD) + sizeof(TPlayerItem) * AuctionManager::instance().GetAuctionItemSize() +
sizeof(WORD) + sizeof(WORD) + sizeof(TAuctionItemInfo) * AuctionManager::instance().GetAuctionSize() +
sizeof(WORD) + sizeof(WORD) + sizeof(TSaleItemInfo) * AuctionManager::instance().GetSaleSize() +
sizeof(WORD) + sizeof(WORD) + sizeof(TWishItemInfo) * AuctionManager::instance().GetWishSize() +
sizeof(WORD) + sizeof(WORD) + (sizeof(DWORD) + sizeof(DWORD) + sizeof(int)) * AuctionManager::instance().GetMyBidSize() +
#endif
sizeof(time_t) +
sizeof(WORD) + sizeof(WORD) + sizeof(TItemIDRangeTable)*2 +
//ADMIN_MANAGER
@ -437,10 +427,6 @@ void CClientManager::QUERY_BOOT(CPeer* peer, TPacketGDBoot * p)
while (it != m_map_pkObjectTable.end())
peer->Encode((it++)->second, sizeof(building::TObject));
// Auction Boot
#ifdef __AUCTION__
AuctionManager::instance().Boot (peer);
#endif
time_t now = time(0);
peer->Encode(&now, sizeof(time_t));
@ -1392,13 +1378,6 @@ void CClientManager::QUERY_ITEM_SAVE(CPeer * pkPeer, const char * c_pData)
CDBManager::instance().ReturnQuery(szQuery, QID_ITEM_SAVE, pkPeer->GetHandle(), NULL);
}
#ifdef __AUCTION__
else if (p->window == AUCTION)
{
SPDLOG_ERROR("invalid window. how can you enter this route?");
return ;
}
#endif
else
{
SPDLOG_TRACE("QUERY_ITEM_SAVE => PutItemCache() owner {} id {} vnum {} ", p->owner, p->id, p->vnum);
@ -2483,60 +2462,6 @@ void CClientManager::ProcessPackets(CPeer * peer)
case HEADER_GD_REQUEST_CHANNELSTATUS:
RequestChannelStatus(peer, dwHandle);
break;
#ifdef __AUCTION__
case HEADER_GD_COMMAND_AUCTION:
{
TPacketGDCommnadAuction* auction_data = (TPacketGDCommnadAuction*)data;
switch (auction_data->get_cmd())
{
case AUCTION_ENR_AUC:
EnrollInAuction (peer, dwHandle, (AuctionEnrollProductInfo*)data);
break;
case AUCTION_ENR_SALE:
EnrollInSale (peer, dwHandle, (AuctionEnrollSaleInfo*)data);
break;
case AUCTION_ENR_WISH:
EnrollInWish (peer, dwHandle, (AuctionEnrollWishInfo*)data);
break;
case AUCTION_BID:
AuctionBid (peer, dwHandle, (AuctionBidInfo*)data);
break;
case AUCTION_IMME_PUR:
AuctionImpur (peer, dwHandle, (AuctionImpurInfo*)data);
break;
case AUCTION_GET_AUC:
AuctionGetAuctionedItem (peer, dwHandle, auction_data->get_item());
break;
case AUCTION_BUY_SOLD:
AuctionBuySoldItem (peer, dwHandle, auction_data->get_item());
break;
case AUCTION_CANCEL_AUC:
AuctionCancelAuction (peer, dwHandle, auction_data->get_item());
break;
case AUCTION_CANCEL_WISH:
AuctionCancelWish (peer, dwHandle, auction_data->get_item());
break;
case AUCTION_CANCEL_SALE:
AuctionCancelSale (peer, dwHandle, auction_data->get_item());
break;
case AUCTION_DELETE_AUCTION_ITEM:
AuctionDeleteAuctionItem (peer, dwHandle, auction_data->get_item());
break;
case AUCTION_DELETE_SALE_ITEM:
AuctionDeleteSaleItem (peer, dwHandle, auction_data->get_item());
break;
case AUCTION_REBID:
AuctionReBid (peer, dwHandle, (AuctionBidInfo*)data);
break;
// case AUCTION_BID_CANCEL:
// AuctionBidCancel (peer, dwHandle, data->get_item());
default :
break;
}
}
break;
#endif
default:
SPDLOG_ERROR("Unknown header (header: {} handle: {} length: {})", header, dwHandle, dwLength);
break;
@ -4037,627 +3962,3 @@ void CClientManager::ChargeCash(const TRequestChargeCash* packet)
CDBManager::Instance().AsyncQuery(szQuery, SQL_ACCOUNT);
}
#ifdef __AUCTION__
void CClientManager::EnrollInAuction (CPeer * peer, DWORD owner_id, AuctionEnrollProductInfo* data)
{
TPlayerTableCacheMap::iterator it = m_map_playerCache.find (owner_id);
if (it == m_map_playerCache.end())
{
SPDLOG_ERROR("Invalid Player id {}. how can you get it?", owner_id);
return;
}
CItemCache* c = GetItemCache (data->get_item_id());
if (c == NULL)
{
SPDLOG_ERROR("Item {} doesn't exist in db cache.", data->get_item_id());
return;
}
TPlayerItem* item = c->Get(false);
if (item->owner != owner_id)
{
SPDLOG_ERROR("Player id {} doesn't have item {}.", owner_id, data->get_item_id());
return;
}
// 현재 시각 + 24시간 후.
time_t expired_time = time(0) + 24 * 60 * 60;
TAuctionItemInfo auctioned_item_info (item->vnum, data->get_bid_price(),
data->get_impur_price(), owner_id, "", expired_time, data->get_item_id(), 0, data->get_empire());
AuctionResult result = AuctionManager::instance().EnrollInAuction( c, auctioned_item_info );
if (result <= AUCTION_FAIL)
{
TPacketDGResultAuction enroll_result;
enroll_result.cmd = AUCTION_ENR_AUC;
enroll_result.target = data->get_item_id();
enroll_result.result = result;
peer->EncodeHeader(HEADER_DG_AUCTION_RESULT, owner_id, sizeof(TPacketDGResultAuction) + sizeof(TPlayerItem));
peer->Encode(&enroll_result, sizeof(TPacketDGResultAuction));
peer->Encode(c->Get(false), sizeof(TPlayerItem));
}
else
{
// 아이템 케시를 Auction에 등록 했으니 ClientManager에서는 뺀다.
TItemCacheSetPtrMap::iterator it = m_map_pkItemCacheSetPtr.find(item->owner);
if (it != m_map_pkItemCacheSetPtr.end())
{
it->second->erase(c);
}
m_map_itemCache.erase(item->id);
SPDLOG_DEBUG("Enroll In Auction Success. owner_id item_id {} {}", owner_id, item->id);
TPacketDGResultAuction enroll_result;
enroll_result.cmd = AUCTION_ENR_AUC;
enroll_result.target = data->get_item_id();
enroll_result.result = result;
for (TPeerList::iterator it = m_peerList.begin(); it != m_peerList.end(); it++)
{
(*it)->EncodeHeader(HEADER_DG_AUCTION_RESULT, owner_id, sizeof(TPacketDGResultAuction) + sizeof(TPlayerItem) + sizeof(TAuctionItemInfo));
(*it)->Encode(&enroll_result, sizeof(TPacketDGResultAuction));
(*it)->Encode(c->Get(false), sizeof(TPlayerItem));
(*it)->Encode(&auctioned_item_info, sizeof(TAuctionItemInfo));
}
}
return;
}
void CClientManager::EnrollInSale (CPeer * peer, DWORD owner_id, AuctionEnrollSaleInfo* data)
{
TPlayerTableCacheMap::iterator it = m_map_playerCache.find (owner_id);
if (it == m_map_playerCache.end())
{
SPDLOG_ERROR("Invalid Player id {}. how can you get it?", owner_id);
return;
}
CPlayerTableCache* player_cache = it->second;
TPlayerTable* player = player_cache->Get(false);
CItemCache* c = GetItemCache (data->get_item_id());
if (c == NULL)
{
SPDLOG_ERROR("Item {} doesn't exist in db cache.", data->get_item_id());
return;
}
TPlayerItem* item = c->Get(false);
if (item->owner != owner_id)
{
SPDLOG_ERROR("Player id {} doesn't have item {}.", owner_id, data->get_item_id());
return;
}
// 현재 시각 + 24시간 후.
time_t expired_time = time(0) + 24 * 60 * 60;
TSaleItemInfo sold_item_info (item->vnum, data->get_sale_price(),
owner_id, player->name, data->get_item_id(), data->get_wisher_id());
AuctionResult result = AuctionManager::instance().EnrollInSale( c, sold_item_info );
if (result <= AUCTION_FAIL)
{
TPacketDGResultAuction enroll_result;
enroll_result.cmd = AUCTION_ENR_SALE;
enroll_result.target = data->get_item_id();
enroll_result.result = result;
peer->EncodeHeader(HEADER_DG_AUCTION_RESULT, owner_id, sizeof(TPacketDGResultAuction) + sizeof(TPlayerItem));
peer->Encode(&enroll_result, sizeof(TPacketDGResultAuction));
peer->Encode(c->Get(false), sizeof(TPlayerItem));
}
else
{
// 아이템 케시를 Auction에 등록 했으니 ClientManager에서는 뺀다.
TItemCacheSetPtrMap::iterator it = m_map_pkItemCacheSetPtr.find(item->owner);
if (it != m_map_pkItemCacheSetPtr.end())
{
it->second->erase(c);
}
m_map_itemCache.erase(item->id);
SPDLOG_DEBUG("Enroll In Sale Success. owner_id item_id {} {}", owner_id, item->id);
TPacketDGResultAuction enroll_result;
enroll_result.cmd = AUCTION_ENR_SALE;
enroll_result.target = data->get_item_id();
enroll_result.result = result;
for (TPeerList::iterator it = m_peerList.begin(); it != m_peerList.end(); it++)
{
(*it)->EncodeHeader(HEADER_DG_AUCTION_RESULT, owner_id, sizeof(TPacketDGResultAuction) + sizeof(TPlayerItem) + sizeof(TSaleItemInfo));
(*it)->Encode(&enroll_result, sizeof(TPacketDGResultAuction));
(*it)->Encode(c->Get(false), sizeof(TPlayerItem));
(*it)->Encode(&sold_item_info, sizeof(TSaleItemInfo));
}
}
return;
}
void CClientManager::EnrollInWish (CPeer * peer, DWORD wisher_id, AuctionEnrollWishInfo* data)
{
TPlayerTableCacheMap::iterator it = m_map_playerCache.find (wisher_id);
if (it == m_map_playerCache.end())
{
SPDLOG_ERROR("Invalid Player id {}. how can you get it?", wisher_id);
return;
}
CPlayerTableCache* player_cache = it->second;
TPlayerTable* player = player_cache->Get(false);
// 현재 시각 + 24시간 후.
time_t expired_time = time(0) + 24 * 60 * 60;
TWishItemInfo wished_item_info (data->get_item_num(), data->get_wish_price(), wisher_id, player->name, expired_time, data->get_empire());
AuctionResult result = AuctionManager::instance().EnrollInWish ( wished_item_info );
if (result <= AUCTION_FAIL)
{
SPDLOG_DEBUG("Enroll In Wish Success. wisher_id item_num {} {}", wisher_id, data->get_item_num());
TPacketDGResultAuction enroll_result;
enroll_result.cmd = AUCTION_ENR_WISH;
enroll_result.target = data->get_item_num();
enroll_result.result = result;
peer->EncodeHeader(HEADER_DG_AUCTION_RESULT, wisher_id, sizeof(TPacketDGResultAuction));
peer->Encode(&enroll_result, sizeof(TPacketDGResultAuction));
}
else
{
SPDLOG_DEBUG("Enroll In Wish Fail. wisher_id item_num {} {}", wisher_id, data->get_item_num());
TPacketDGResultAuction enroll_result;
enroll_result.cmd = AUCTION_ENR_WISH;
enroll_result.target = data->get_item_num();
enroll_result.result = result;
for (TPeerList::iterator it = m_peerList.begin(); it != m_peerList.end(); it++)
{
(*it)->EncodeHeader(HEADER_DG_AUCTION_RESULT, wisher_id, sizeof(TPacketDGResultAuction) + sizeof(TWishItemInfo));
(*it)->Encode(&enroll_result, sizeof(TPacketDGResultAuction));
(*it)->Encode(&wished_item_info, sizeof(TWishItemInfo));
}
}
return;
}
void CClientManager::AuctionBid (CPeer * peer, DWORD bidder_id, AuctionBidInfo* data)
{
TPlayerTableCacheMap::iterator it = m_map_playerCache.find (bidder_id);
if (it == m_map_playerCache.end())
{
SPDLOG_ERROR("Invalid Player id {}. how can you get it?", bidder_id);
return;
}
CPlayerTableCache* player_cache = it->second;
TPlayerTable* player = player_cache->Get(false);
AuctionResult result = AuctionManager::instance().Bid(bidder_id, player->name, data->get_item_id(), data->get_bid_price());
if (result == AUCTION_FAIL)
{
SPDLOG_DEBUG("Bid Fail. bidder_id item_id {} {}", bidder_id, data->get_item_id());
}
else
{
SPDLOG_DEBUG("Bid Success. bidder_id item_id {} {}", bidder_id, data->get_item_id());
}
if (result <= AUCTION_FAIL)
{
TPacketDGResultAuction enroll_result;
enroll_result.cmd = AUCTION_BID;
enroll_result.target = data->get_bid_price();
enroll_result.result = result;
peer->EncodeHeader(HEADER_DG_AUCTION_RESULT, bidder_id, sizeof(TPacketDGResultAuction) + sizeof(AuctionBidInfo));
peer->Encode(&enroll_result, sizeof(TPacketDGResultAuction));
}
else
{
TPacketDGResultAuction enroll_result;
enroll_result.cmd = AUCTION_BID;
enroll_result.target = data->get_item_id();
enroll_result.result = result;
TAuctionItemInfo* auctioned_item_info = AuctionManager::instance().GetAuctionItemInfoCache(data->get_item_id())->Get(false);
for (TPeerList::iterator it = m_peerList.begin(); it != m_peerList.end(); it++)
{
(*it)->EncodeHeader(HEADER_DG_AUCTION_RESULT, bidder_id, sizeof(TPacketDGResultAuction) + sizeof(TAuctionItemInfo));
(*it)->Encode(&enroll_result, sizeof(TPacketDGResultAuction));
(*it)->Encode(auctioned_item_info, sizeof(TAuctionItemInfo));
}
}
return;
}
void CClientManager::AuctionImpur (CPeer * peer, DWORD purchaser_id, AuctionImpurInfo* data)
{
TPlayerTableCacheMap::iterator it = m_map_playerCache.find (purchaser_id);
if (it == m_map_playerCache.end())
{
SPDLOG_ERROR("Invalid Player id {}. how can you get it?", purchaser_id);
return;
}
CPlayerTableCache* player_cache = it->second;
TPlayerTable* player = player_cache->Get(false);
AuctionResult result = AuctionManager::instance().Impur(purchaser_id, player->name, data->get_item_id());
if (result == AUCTION_FAIL)
{
SPDLOG_DEBUG("Impur Fail. purchaser_id item_id {} {}", purchaser_id, data->get_item_id());
}
else
{
SPDLOG_DEBUG("Impur Success. purchaser_id item_id {} {}", purchaser_id, data->get_item_id());
}
if (result <= AUCTION_FAIL)
{
TPacketDGResultAuction enroll_result;
enroll_result.cmd = AUCTION_IMME_PUR;
enroll_result.target = data->get_item_id();
enroll_result.result = result;
peer->EncodeHeader(HEADER_DG_AUCTION_RESULT, purchaser_id, sizeof(TPacketDGResultAuction));
peer->Encode(&enroll_result, sizeof(TPacketDGResultAuction));
}
else
{
TPacketDGResultAuction enroll_result;
enroll_result.cmd = AUCTION_IMME_PUR;
enroll_result.target = data->get_item_id();
enroll_result.result = result;
TAuctionItemInfo* auctioned_item_info = AuctionManager::instance().GetAuctionItemInfoCache(data->get_item_id())->Get(false);
for (TPeerList::iterator it = m_peerList.begin(); it != m_peerList.end(); it++)
{
(*it)->EncodeHeader(HEADER_DG_AUCTION_RESULT, purchaser_id, sizeof(TPacketDGResultAuction) + sizeof(TAuctionItemInfo));
(*it)->Encode(&enroll_result, sizeof(TPacketDGResultAuction));
(*it)->Encode(auctioned_item_info, sizeof(TAuctionItemInfo));
}
}
return;
}
void CClientManager::AuctionGetAuctionedItem (CPeer * peer, DWORD actor_id, DWORD item_id)
{
TPlayerTableCacheMap::iterator it = m_map_playerCache.find (actor_id);
AuctionResult result = AUCTION_FAIL;
if (it == m_map_playerCache.end())
{
SPDLOG_ERROR("Invalid Player id {}. how can you get it?", actor_id);
return;
}
TPlayerItem item;
result = AuctionManager::instance().GetAuctionedItem(actor_id, item_id, item);
if (result <= AUCTION_FAIL)
{
TPacketDGResultAuction enroll_result;
enroll_result.cmd = AUCTION_GET_AUC;
enroll_result.target = item_id;
enroll_result.result = result;
peer->EncodeHeader (HEADER_DG_AUCTION_RESULT, actor_id, sizeof(TPacketDGResultAuction));
peer->Encode (&enroll_result, sizeof(TPacketDGResultAuction));
}
else
{
TPacketDGResultAuction enroll_result;
enroll_result.cmd = AUCTION_GET_AUC;
enroll_result.target = item_id;
enroll_result.result = result;
for (TPeerList::iterator it = m_peerList.begin(); it != m_peerList.end(); it++)
{
(*it)->EncodeHeader (HEADER_DG_AUCTION_RESULT, actor_id, sizeof(TPacketDGResultAuction) + sizeof(TPlayerItem));
(*it)->Encode (&enroll_result, sizeof(TPacketDGResultAuction));
(*it)->Encode (&item, sizeof(TPlayerItem));
}
}
return;
}
void CClientManager::AuctionBuySoldItem (CPeer * peer, DWORD actor_id, DWORD item_id)
{
TPlayerTableCacheMap::iterator it = m_map_playerCache.find (actor_id);
AuctionResult result = AUCTION_FAIL;
if (it == m_map_playerCache.end())
{
SPDLOG_ERROR("Invalid Player id {}. how can you get it?", actor_id);
return;
}
TPlayerItem item;
result = AuctionManager::instance().BuySoldItem(actor_id, item_id, item);
if (result <= AUCTION_FAIL)
{
TPacketDGResultAuction enroll_result;
enroll_result.cmd = AUCTION_BUY_SOLD;
enroll_result.target = item_id;
enroll_result.result = result;
peer->EncodeHeader (HEADER_DG_AUCTION_RESULT, actor_id, sizeof(TPacketDGResultAuction));
peer->Encode (&enroll_result, sizeof(TPacketDGResultAuction));
}
else
{
TPacketDGResultAuction enroll_result;
enroll_result.cmd = AUCTION_BUY_SOLD;
enroll_result.target = item_id;
enroll_result.result = result;
for (TPeerList::iterator it = m_peerList.begin(); it != m_peerList.end(); it++)
{
(*it)->EncodeHeader (HEADER_DG_AUCTION_RESULT, actor_id, sizeof(TPacketDGResultAuction) + sizeof(TPlayerItem));
(*it)->Encode (&enroll_result, sizeof(TPacketDGResultAuction));
(*it)->Encode (&item, sizeof(TPlayerItem));
}
}
return;
}
void CClientManager::AuctionCancelAuction (CPeer * peer, DWORD actor_id, DWORD item_id)
{
TPlayerTableCacheMap::iterator it = m_map_playerCache.find (actor_id);
AuctionResult result = AUCTION_FAIL;
if (it == m_map_playerCache.end())
{
SPDLOG_ERROR("Invalid Player id {}. how can you get it?", actor_id);
return;
}
TPlayerItem item;
result = AuctionManager::instance().CancelAuction(actor_id, item_id, item);
if (result <= AUCTION_FAIL)
{
TPacketDGResultAuction enroll_result;
enroll_result.cmd = AUCTION_CANCEL_AUC;
enroll_result.target = item_id;
enroll_result.result = result;
peer->EncodeHeader (HEADER_DG_AUCTION_RESULT, actor_id, sizeof(TPacketDGResultAuction));
peer->Encode (&enroll_result, sizeof(TPacketDGResultAuction));
}
else
{
TPacketDGResultAuction enroll_result;
enroll_result.cmd = AUCTION_CANCEL_AUC;
enroll_result.target = item_id;
enroll_result.result = result;
for (TPeerList::iterator it = m_peerList.begin(); it != m_peerList.end(); it++)
{
(*it)->EncodeHeader (HEADER_DG_AUCTION_RESULT, actor_id, sizeof(TPacketDGResultAuction) + sizeof(TPlayerItem));
(*it)->Encode (&enroll_result, sizeof(TPacketDGResultAuction));
(*it)->Encode (&item, sizeof(TPlayerItem));
}
}
return;
}
void CClientManager::AuctionCancelWish (CPeer * peer, DWORD actor_id, DWORD item_num)
{
TPlayerTableCacheMap::iterator it = m_map_playerCache.find (actor_id);
AuctionResult result = AUCTION_FAIL;
if (it == m_map_playerCache.end())
{
SPDLOG_ERROR("Invalid Player id {}. how can you get it?", actor_id);
return;
}
TPlayerItem item;
result = AuctionManager::instance().CancelWish(actor_id, item_num);
if (result <= AUCTION_FAIL)
{
TPacketDGResultAuction enroll_result;
enroll_result.cmd = AUCTION_CANCEL_WISH;
enroll_result.target = item_num;
enroll_result.result = result;
peer->EncodeHeader (HEADER_DG_AUCTION_RESULT, actor_id, sizeof(TPacketDGResultAuction));
peer->Encode (&enroll_result, sizeof(TPacketDGResultAuction));
}
else
{
TPacketDGResultAuction enroll_result;
enroll_result.cmd = AUCTION_CANCEL_WISH;
enroll_result.target = item_num;
enroll_result.result = result;
for (TPeerList::iterator it = m_peerList.begin(); it != m_peerList.end(); it++)
{
(*it)->EncodeHeader (HEADER_DG_AUCTION_RESULT, actor_id, sizeof(TPacketDGResultAuction));
(*it)->Encode (&enroll_result, sizeof(TPacketDGResultAuction));
}
}
return;
}
void CClientManager::AuctionCancelSale (CPeer * peer, DWORD actor_id, DWORD item_id)
{
TPlayerTableCacheMap::iterator it = m_map_playerCache.find (actor_id);
AuctionResult result = AUCTION_FAIL;
if (it == m_map_playerCache.end())
{
SPDLOG_ERROR("Invalid Player id {}. how can you get it?", actor_id);
return;
}
TPlayerItem item;
result = AuctionManager::instance().CancelSale(actor_id, item_id, item);
if (result <= AUCTION_FAIL)
{
TPacketDGResultAuction enroll_result;
enroll_result.cmd = AUCTION_CANCEL_SALE;
enroll_result.target = item_id;
enroll_result.result = result;
peer->EncodeHeader (HEADER_DG_AUCTION_RESULT, actor_id, sizeof(TPacketDGResultAuction));
peer->Encode (&enroll_result, sizeof(TPacketDGResultAuction));
}
else
{
TPacketDGResultAuction enroll_result;
enroll_result.cmd = AUCTION_CANCEL_SALE;
enroll_result.target = item_id;
enroll_result.result = result;
for (TPeerList::iterator it = m_peerList.begin(); it != m_peerList.end(); it++)
{
(*it)->EncodeHeader (HEADER_DG_AUCTION_RESULT, actor_id, sizeof(TPacketDGResultAuction) + sizeof(TPlayerItem));
(*it)->Encode (&enroll_result, sizeof(TPacketDGResultAuction));
(*it)->Encode (&item, sizeof(TPlayerItem));
}
}
return;
}
void CClientManager::AuctionDeleteAuctionItem (CPeer * peer, DWORD actor_id, DWORD item_id)
{
TPlayerTableCacheMap::iterator it = m_map_playerCache.find (actor_id);
AuctionResult result = AUCTION_FAIL;
if (it == m_map_playerCache.end())
{
SPDLOG_ERROR("Invalid Player id {}. how can you get it?", actor_id);
return;
}
AuctionManager::instance().DeleteAuctionItem (actor_id, item_id);
}
void CClientManager::AuctionDeleteSaleItem (CPeer * peer, DWORD actor_id, DWORD item_id)
{
TPlayerTableCacheMap::iterator it = m_map_playerCache.find (actor_id);
AuctionResult result = AUCTION_FAIL;
if (it == m_map_playerCache.end())
{
SPDLOG_ERROR("Invalid Player id {}. how can you get it?", actor_id);
return;
}
AuctionManager::instance().DeleteSaleItem (actor_id, item_id);
}
// ReBid는 이전 입찰금액에 더해서 입찰한다.
// ReBid에선 data->bid_price가 이전 입찰가에 더해져서
// 그 금액으로 rebid하는 것.
// 이렇게 한 이유는 rebid에 실패 했을 때,
// 유저의 호주머니에서 뺀 돈을 돌려주기 편하게 하기 위함이다.
void CClientManager::AuctionReBid (CPeer * peer, DWORD bidder_id, AuctionBidInfo* data)
{
TPlayerTableCacheMap::iterator it = m_map_playerCache.find (bidder_id);
if (it == m_map_playerCache.end())
{
SPDLOG_ERROR("Invalid Player id {}. how can you get it?", bidder_id);
return;
}
CPlayerTableCache* player_cache = it->second;
TPlayerTable* player = player_cache->Get(false);
AuctionResult result = AuctionManager::instance().ReBid(bidder_id, player->name, data->get_item_id(), data->get_bid_price());
if (result == AUCTION_FAIL)
{
SPDLOG_DEBUG("ReBid Fail. bidder_id item_id {} {}", bidder_id, data->get_item_id());
}
else
{
SPDLOG_DEBUG("ReBid Success. bidder_id item_id {} {}", bidder_id, data->get_item_id());
}
// 이건 FAIL이 떠서는 안돼.
// FAIL이 뜰 수가 없는게, MyBid에 있는 bidder_id에 대한 컨텐츠는 bidder_id만이 접근 할 수 있거든?
// 그러므로 다른 것이 다 정상적으로 작동한다고 가정 한다면
// 한 게임 서버 내에서 bidder_id로 MyBid를 수정한다 할 지라도, 그건 동기화 문제가 없어.
// 다른 게임 서버에 똑같은 bidder_id를 가진 놈이 있을 수가 없으니까.
// 그러므로 그 게임 서버에서 BidCancel 명령을 db에 날렸다는 것은,
// 이미 그 부분에 대해서는 검사가 완벽하다는 것이야.
// 그래도 혹시나 싶어서, 디버깅을 위해 fail 코드를 남겨둔다.
if (result <= AUCTION_FAIL)
{
TPacketDGResultAuction enroll_result;
enroll_result.cmd = AUCTION_REBID;
enroll_result.target = data->get_item_id();
enroll_result.result = result;
peer->EncodeHeader(HEADER_DG_AUCTION_RESULT, bidder_id, sizeof(TPacketDGResultAuction) + sizeof(int));
peer->Encode(&enroll_result, sizeof(TPacketDGResultAuction));
peer->EncodeDWORD(data->get_bid_price());
}
else
{
TPacketDGResultAuction enroll_result;
enroll_result.cmd = AUCTION_REBID;
enroll_result.target = data->get_item_id();
enroll_result.result = result;
TAuctionItemInfo* auctioned_item_info = AuctionManager::instance().GetAuctionItemInfoCache(data->get_item_id())->Get(false);
for (TPeerList::iterator it = m_peerList.begin(); it != m_peerList.end(); it++)
{
(*it)->EncodeHeader(HEADER_DG_AUCTION_RESULT, bidder_id, sizeof(TPacketDGResultAuction) + sizeof(TAuctionItemInfo));
(*it)->Encode(&enroll_result, sizeof(TPacketDGResultAuction));
(*it)->Encode(auctioned_item_info, sizeof(TAuctionItemInfo));
}
}
return;
}
void CClientManager::AuctionBidCancel (CPeer * peer, DWORD bidder_id, DWORD item_id)
{
AuctionResult result = AuctionManager::instance().BidCancel (bidder_id, item_id);
// 이건 FAIL이 떠서는 안돼.
// FAIL이 뜰 수가 없는게, MyBid에 있는 bidder_id에 대한 컨텐츠는 bidder_id만이 접근 할 수 있거든?
// 그러므로 다른 것이 다 정상적으로 작동한다고 가정 한다면
// 한 게임 서버 내에서 bidder_id로 MyBid를 수정한다 할 지라도, 그건 동기화 문제가 없어.
// 다른 게임 서버에 똑같은 bidder_id를 가진 놈이 있을 수가 없으니까.
// 그러므로 그 게임 서버에서 BidCancel 명령을 db에 날렸다는 것은,
// 이미 그 부분에 대해서는 검사가 완벽하다는 것이야.
// 그래도 혹시나 싶어서, 디버깅을 위해 fail 코드를 남겨둔다.
if (result <= AUCTION_FAIL)
{
TPacketDGResultAuction enroll_result;
enroll_result.cmd = AUCTION_BID_CANCEL;
enroll_result.target = item_id;
enroll_result.result = result;
peer->EncodeHeader(HEADER_DG_AUCTION_RESULT, bidder_id, sizeof(TPacketDGResultAuction));
peer->Encode(&enroll_result, sizeof(TPacketDGResultAuction));
}
else
{
TPacketDGResultAuction enroll_result;
enroll_result.cmd = AUCTION_BID_CANCEL;
enroll_result.target = item_id;
enroll_result.result = result;
peer->EncodeHeader(HEADER_DG_AUCTION_RESULT, bidder_id, sizeof(TPacketDGResultAuction));
peer->Encode(&enroll_result, sizeof(TPacketDGResultAuction));
}
}
#endif

17
src/db/src/ClientManager.h
View File

@ -9,7 +9,6 @@
#include <common/stl.h>
#include <common/building.h>
#include <common/auction_table.h>
#include "Peer.h"
#include "DBManager.h"
@ -540,22 +539,6 @@ class CClientManager : public singleton<CClientManager>
void DeleteAwardId(TPacketDeleteAwardID* data);
void UpdateChannelStatus(TChannelStatus* pData);
void RequestChannelStatus(CPeer* peer, DWORD dwHandle);
#ifdef __AUCTION__
void EnrollInAuction (CPeer * peer, DWORD owner_id, AuctionEnrollProductInfo* data);
void EnrollInSale (CPeer * peer, DWORD owner_id, AuctionEnrollSaleInfo* data);
void EnrollInWish (CPeer * peer, DWORD wisher_id, AuctionEnrollWishInfo* data);
void AuctionBid (CPeer * peer, DWORD bidder_id, AuctionBidInfo* data);
void AuctionImpur (CPeer * peer, DWORD purchaser_id, AuctionImpurInfo* data);
void AuctionGetAuctionedItem (CPeer * peer, DWORD actor_id, DWORD item_id);
void AuctionBuySoldItem (CPeer * peer, DWORD actor_id, DWORD item_id);
void AuctionCancelAuction (CPeer * peer, DWORD actor_id, DWORD item_id);
void AuctionCancelWish (CPeer * peer, DWORD actor_id, DWORD item_num);
void AuctionCancelSale (CPeer * peer, DWORD actor_id, DWORD item_id);
void AuctionDeleteAuctionItem (CPeer * peer, DWORD actor_id, DWORD item_id);
void AuctionDeleteSaleItem (CPeer * peer, DWORD actor_id, DWORD item_id);
void AuctionReBid (CPeer * peer, DWORD bidder_id, AuctionBidInfo* data);
void AuctionBidCancel (CPeer * peer, DWORD bidder_id, DWORD item_id);
#endif
};
template<class Func>

9
src/db/src/Main.cpp
View File

@ -11,9 +11,6 @@
#include "Monarch.h"
#include "ItemIDRangeManager.h"
#include <version.h>
#ifdef __AUCTION__
#include "AuctionManager.h"
#endif
#include <signal.h>
void SetTablePostfix(const char* c_pszTablePostfix);
@ -72,18 +69,12 @@ int main()
marriage::CManager MarriageManager;
CMonarch Monarch;
CItemIDRangeManager ItemIDRangeManager;
#ifdef __AUCTION__
AuctionManager auctionManager;
#endif
if (!Start())
return 1;
GuildManager.Initialize();
MarriageManager.Initialize();
ItemIDRangeManager.Build();
#ifdef __AUCTION__
AuctionManager::instance().Initialize();
#endif
SPDLOG_DEBUG("Metin2DBCacheServer Start");
CClientManager::instance().MainLoop();

27
src/game/CMakeLists.txt
View File

@ -1,4 +1,4 @@
cmake_minimum_required(VERSION 3.8)
cmake_minimum_required(VERSION 3.12)
project(game CXX)
@ -26,32 +26,33 @@ target_compile_options(${PROJECT_NAME} PUBLIC -fsigned-char)
# vcpkg dependencies
#
# MariaDB
find_package(unofficial-libmariadb REQUIRED)
target_link_libraries(${PROJECT_NAME} unofficial::libmariadb)
# PostgreSQL with libpqxx (stable vcpkg package)
find_package(PostgreSQL REQUIRED)
find_package(libpqxx CONFIG REQUIRED)
target_link_libraries(${PROJECT_NAME} PRIVATE libpqxx::pqxx)
# Argon2
find_package(unofficial-argon2 CONFIG REQUIRED)
target_link_libraries(${PROJECT_NAME} unofficial::argon2::libargon2)
target_link_libraries(${PROJECT_NAME} PRIVATE unofficial::argon2::libargon2)
# Crypto++
find_package(cryptopp CONFIG REQUIRED)
target_link_libraries(${PROJECT_NAME} cryptopp::cryptopp)
target_link_libraries(${PROJECT_NAME} PRIVATE cryptopp::cryptopp)
# Libevent
find_package(Libevent CONFIG REQUIRED)
target_link_libraries(${PROJECT_NAME} libevent::core libevent::extra libevent::pthreads)
target_link_libraries(${PROJECT_NAME} PRIVATE libevent::core libevent::extra libevent::pthreads)
# LZO
find_package(LZO REQUIRED)
if (LZO_FOUND)
include_directories(${LZO_INCLUDE_DIR})
target_link_libraries(${PROJECT_NAME} ${LZO_LIBRARIES})
target_link_libraries(${PROJECT_NAME} PRIVATE ${LZO_LIBRARIES})
endif (LZO_FOUND)
# effolkronium/random
find_package(effolkronium_random CONFIG REQUIRED)
target_link_libraries(${PROJECT_NAME} effolkronium_random)
target_link_libraries(${PROJECT_NAME} PRIVATE effolkronium_random)
#
# System-provided dependencies
@ -60,18 +61,18 @@ target_link_libraries(${PROJECT_NAME} effolkronium_random)
# DevIL
find_package(DevIL REQUIRED)
include_directories(${IL_INCLUDE_DIR})
target_link_libraries(${PROJECT_NAME} ${IL_LIBRARIES})
target_link_libraries(${PROJECT_NAME} PRIVATE ${IL_LIBRARIES})
# Pthreads
set(THREADS_PREFER_PTHREAD_FLAG ON)
find_package(Threads REQUIRED)
target_link_libraries(${PROJECT_NAME} Threads::Threads)
target_link_libraries(${PROJECT_NAME} PRIVATE Threads::Threads)
# LibBSD
target_link_libraries(${PROJECT_NAME} bsd)
target_link_libraries(${PROJECT_NAME} PRIVATE bsd)
#
# Project-provided dependencies
#
target_link_libraries(${PROJECT_NAME} libgame libpoly libsql libthecore liblua)
target_link_libraries(${PROJECT_NAME} PRIVATE libgame libpoly libsql libthecore liblua)

1377
src/game/src/auction_manager.cpp
View File

File diff suppressed because it is too large Load Diff

218
src/game/src/auction_manager.h
View File

@ -1,218 +0,0 @@
#ifndef __INC_AUCTION_MANAGER_H
#define __INC_AUCTION_MANAGER_H
#include <libsql/include/AsyncSQL.h>
#include <common/auction_table.h>
#include <unordered_map>
#include <algorithm>
#define GRADE_LOW 30
#define GRADE_MID 60
#define GRADE_HIGH 90
template<>
class hash<std::pair <DWORD, DWORD> >
{ // hash functor
public:
typedef std::pair <DWORD, DWORD> _Kty;
size_t operator()(const _Kty& _Keyval) const
{ // hash _Keyval to size_t value by pseudorandomizing transform
ldiv_t _Qrem = ldiv((size_t)_Keyval.first + (size_t)_Keyval.second, 127773);
_Qrem.rem = 16807 * _Qrem.rem - 2836 * _Qrem.quot;
if (_Qrem.rem < 0)
_Qrem.rem += 2147483647;
return ((size_t)_Qrem.rem);
}
};
bool CompareItemInfoByItemNameAC (TAuctionItemInfo* i, TAuctionItemInfo* j);
bool CompareItemInfoByItemNameDC (TAuctionItemInfo* i, TAuctionItemInfo* j);
bool CompareItemInfoByCategoryAC (TAuctionItemInfo* i, TAuctionItemInfo* j);
bool CompareItemInfoByCategoryDC (TAuctionItemInfo* i, TAuctionItemInfo* j);
bool CompareItemInfoByTimeAC (TAuctionItemInfo* i, TAuctionItemInfo* j);
bool CompareItemInfoByTimeDC (TAuctionItemInfo* i, TAuctionItemInfo* j);
bool CompareItemInfoByCharNameAC (TAuctionItemInfo* i, TAuctionItemInfo* j);
bool CompareItemInfoByCharNameDC (TAuctionItemInfo* i, TAuctionItemInfo* j);
bool CompareItemInfoByPriceAC (TAuctionItemInfo* i, TAuctionItemInfo* j);
bool CompareItemInfoByPriceDC (TAuctionItemInfo* i, TAuctionItemInfo* j);
class AuctionBoard
{
public:
AuctionBoard() {}
~AuctionBoard() {}
TAuctionItemInfo* GetItemInfo (DWORD key);
bool DeleteItemInfo (DWORD key);
bool InsertItemInfo (TAuctionItemInfo* item_info);
bool UpdateItemInfo (TAuctionItemInfo* item_info);
private:
typedef std::unordered_map <DWORD, TAuctionItemInfo*> TItemInfoMap;
TItemInfoMap item_map;
typedef std::map <DWORD, TAuctionItemInfo*> TItemMap;
typedef std::unordered_map <DWORD, TItemMap*> TPCMap;
TPCMap offer_map;
// sorting을 위한 members
public:
typedef std::vector <TAuctionItemInfo*> TItemInfoVec;
private:
typedef std::map <std::string, TItemInfoVec*> SortByItemName;
SortByItemName item_name_map;
void Sort(TItemInfoVec& vec, BYTE order);
public:
void SortedItemInfos (TItemInfoVec& vec, BYTE grade, BYTE category, int start_idx, BYTE size, BYTE order[5]);
// 나의 경매장을 위한 함수.
void YourItemInfoList (TItemInfoVec& vec, DWORD player_id, int start_idx, BYTE size);
};
class SaleBoard
{
private:
typedef std::unordered_map <DWORD, TSaleItemInfo*> TItemInfoMap;
TItemInfoMap item_map;
typedef std::map <DWORD, TSaleItemInfo*> TItemMap;
typedef std::unordered_map <DWORD, TItemMap*> TPCMap;
TPCMap wisher_map;
TPCMap seller_map;
bool DeleteFromPCMap (TPCMap& pc_map, DWORD player_id, DWORD item_id);
bool InsertInPCMap (TPCMap& pc_map, DWORD player_id, TSaleItemInfo* item_info);
public:
SaleBoard() {}
~SaleBoard() {}
typedef std::vector <TSaleItemInfo*> TItemInfoVec;
void WisherItemInfoList (TItemInfoVec& vec, DWORD wisher_id, int start_idx, BYTE size);
TSaleItemInfo* GetItemInfo (DWORD key);
bool DeleteItemInfo (DWORD key);
bool InsertItemInfo (TSaleItemInfo* item_info);
};
class WishBoard
{
private:
typedef std::map <DWORD, TWishItemInfo*> TItemMap;
typedef std::unordered_map <DWORD, TItemMap*> TPCMap;
TPCMap wisher_map;
public:
typedef TWishItemInfo ItemInfo;
WishBoard() {}
~WishBoard() {}
TWishItemInfo* GetItemInfo (DWORD wisher_id, DWORD item_num);
bool DeleteItemInfo (DWORD wisher_id, DWORD item_num);
bool InsertItemInfo (TWishItemInfo* item_info);
};
class MyBidBoard
{
private:
typedef std::pair <int, bool> BidInfo;
typedef std::map <DWORD, BidInfo > TItemMap;
typedef std::unordered_map <DWORD, TItemMap*> TMyBidBoard;
// bidder_id가 key
TMyBidBoard pc_map;
public:
MyBidBoard() {}
~MyBidBoard() {}
typedef std::vector <DWORD> TItemVec;
void YourBidInfo (TItemVec& vec, DWORD bidder_id, int start_idx, int size);
BidInfo GetMoney (DWORD player_id, DWORD item_id);
bool Delete (DWORD player_id, DWORD item_id);
// 이미 있으면 덮어 씌운다.
void Insert (DWORD player_id, DWORD item_id, int money);
void Lock (DWORD player_id, DWORD item_id);
void UnLock (DWORD player_id, DWORD item_id);
};
class AuctionManager : public singleton <AuctionManager>
{
private :
typedef std::unordered_map<DWORD, LPITEM> TItemMap;
TItemMap auction_item_map;
// auction에 등록된 정보 중 가격, 등등 아이템 테이블에 포함되지 않는 정보들을 관리하는 것들
AuctionBoard Auction;
SaleBoard Sale;
WishBoard Wish;
MyBidBoard MyBid;
public:
bool InsertItem (LPITEM item);
bool InsertItem (TPlayerItem* player_item);
LPITEM GetInventoryItem (DWORD item_id);
bool DeleteItem (DWORD item_id);
bool InsertAuctionItemInfo (TAuctionItemInfo* item_info);
TAuctionItemInfo* GetAuctionItemInfo (DWORD item_id)
{
return Auction.GetItemInfo (item_id);
}
bool InsertSaleItemInfo (TSaleItemInfo* item_info);
TSaleItemInfo* GetSaleItemInfo (DWORD item_id)
{
return Sale.GetItemInfo (item_id);
}
bool InsertWishItemInfo (TWishItemInfo* item_info);
TWishItemInfo* GetWishItemInfo (DWORD wisher_id, DWORD item_id)
{
return Wish.GetItemInfo (wisher_id, item_id);
}
void YourBidItemInfoList (AuctionBoard::TItemInfoVec& vec, DWORD bidder_id, int start_idx, int size);
void Boot (const char* &pdata, WORD size);
void get_auction_list (LPCHARACTER ch, int start_idx, int size, int cond);
void get_my_auction_list (LPCHARACTER ch, int start_idx, int size);
void get_my_purchase_list (LPCHARACTER ch, int start_idx, int size);
void enroll_auction (LPCHARACTER ch, LPITEM item, BYTE empire, int bidPrice, int immidiatePurchasePrice);
void recv_result_auction (DWORD commander_id, TPacketDGResultAuction* cmd_result);
void bid (LPCHARACTER ch, DWORD item_id, int price);
void immediate_purchase (LPCHARACTER ch, DWORD item_id);
void enroll_sale (LPCHARACTER ch, LPITEM item, DWORD wisher_id, int salePrice);
void enroll_wish (LPCHARACTER ch, DWORD item_num, BYTE empire, int wishPrice);
void get_auctioned_item (LPCHARACTER ch, DWORD item_id, DWORD item_num);
void buy_sold_item (LPCHARACTER ch, DWORD item_id);
void cancel_auction (LPCHARACTER ch, DWORD item_id);
void cancel_wish (LPCHARACTER ch, DWORD item_num);
void cancel_sale (LPCHARACTER ch, DWORD item_id);
void rebid (LPCHARACTER ch, DWORD item_id, int price);
void bid_cancel (LPCHARACTER ch, DWORD item_id);
/*
void close_auction (LPCHARACTER ch);*/
};
#endif

5
src/game/src/auction_packet.h
View File

@ -1,5 +0,0 @@
typedef struct packet_auction_simple_item_info
{
BYTE header;
BYTE size;
} TPacketGCAuctionItemSimpleInfo;

4
src/game/src/char_item.cpp
View File

@ -44,10 +44,6 @@
#include "buff_on_attributes.h"
#include "belt_inventory_helper.h"
//auction_temp
#ifdef __AUCTION__
#include "auction_manager.h"
#endif
const int ITEM_BROKEN_METIN_VNUM = 28960;
// CHANGE_ITEM_ATTRIBUTES

41
src/game/src/cmd.cpp
View File

@ -229,27 +229,6 @@ ACMD(do_click_mall);
ACMD(do_ride);
ACMD(do_get_item_id_list);
ACMD(do_set_socket);
#ifdef __AUCTION__
// temp_auction 임시
ACMD(do_get_auction_list);
ACMD (do_get_my_auction_list);
ACMD (do_get_my_purchase_list);
ACMD(do_get_item_id_list);
ACMD(do_enroll_auction);
ACMD (do_auction_bid);
ACMD (do_auction_impur);
ACMD (do_enroll_wish);
ACMD (do_enroll_sale);
ACMD (do_get_auctioned_item);
ACMD (do_buy_sold_item);
ACMD (do_cancel_auction);
ACMD (do_cancel_wish);
ACMD (do_cancel_sale);
ACMD (do_rebid);
ACMD (do_bid_cancel);
#endif
// 코스츔 상태보기 및 벗기
ACMD(do_costume);
ACMD(do_set_stat);
@ -534,27 +513,7 @@ struct command_info cmd_info[] =
{ "item_id_list", do_get_item_id_list, 0, POS_DEAD, GM_LOW_WIZARD },
{ "set_socket", do_set_socket, 0, POS_DEAD, GM_LOW_WIZARD },
#ifdef __AUCTION__
// auction 임시
{ "auction_list", do_get_auction_list, 0, POS_DEAD, GM_PLAYER },
{ "my_auction_list", do_get_my_auction_list, 0, POS_DEAD, GM_PLAYER },
{ "my_purchase_list", do_get_my_purchase_list, 0, POS_DEAD, GM_PLAYER },
{ "enroll_auction", do_enroll_auction, 0, POS_DEAD, GM_PLAYER },
{ "bid", do_auction_bid, 0, POS_DEAD, GM_PLAYER },
{ "impur", do_auction_impur, 0, POS_DEAD, GM_PLAYER },
{ "enroll_wish", do_enroll_wish, 0, POS_DEAD, GM_PLAYER },
{ "enroll_sale", do_enroll_sale, 0, POS_DEAD, GM_PLAYER },
{ "get_auctioned_item", do_get_auctioned_item, 0, POS_DEAD, GM_PLAYER },
{ "buy_sold_item", do_buy_sold_item, 0, POS_DEAD, GM_PLAYER },
{ "cancel_auction", do_cancel_auction, 0, POS_DEAD, GM_PLAYER },
{ "cancel_wish", do_cancel_wish, 0, POS_DEAD, GM_PLAYER },
{ "cancel_sale", do_cancel_sale, 0, POS_DEAD, GM_PLAYER },
{ "rebid", do_rebid, 0, POS_DEAD, GM_PLAYER },
{ "bid_cancel", do_bid_cancel, 0, POS_DEAD, GM_PLAYER },
#endif
{ "costume", do_costume, 0, POS_DEAD, GM_PLAYER },
{ "tcon", do_set_stat, POINT_HT, POS_DEAD, GM_LOW_WIZARD },

186
src/game/src/cmd_general.cpp
View File

@ -33,9 +33,6 @@
#include <cryptopp/sha.h>
#include <cryptopp/hex.h>
#include <cryptopp/filters.h>
#ifdef __AUCTION__
#include "auction_manager.h"
#endif
extern int g_server_id;
@ -2377,186 +2374,3 @@ ACMD(do_ride)
// 타거나 내릴 수 없을때
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Please call your Horse first."));
}
#ifdef __AUCTION__
// temp_auction
ACMD(do_get_item_id_list)
{
for (int i = 0; i < INVENTORY_MAX_NUM; i++)
{
LPITEM item = ch->GetInventoryItem(i);
if (item != NULL)
ch->ChatPacket(CHAT_TYPE_INFO, "name : %s id : %d", item->GetProto()->szName, item->GetID());
}
}
// temp_auction
ACMD(do_enroll_auction)
{
char arg1[256];
char arg2[256];
char arg3[256];
char arg4[256];
two_arguments (two_arguments(argument, arg1, sizeof(arg1), arg2, sizeof(arg2)), arg3, sizeof(arg3), arg4, sizeof(arg4));
DWORD item_id = strtoul(arg1, NULL, 10);
BYTE empire = strtoul(arg2, NULL, 10);
int bidPrice = strtol(arg3, NULL, 10);
int immidiatePurchasePrice = strtol(arg4, NULL, 10);
LPITEM item = ITEM_MANAGER::instance().Find(item_id);
if (item == NULL)
return;
AuctionManager::instance().enroll_auction(ch, item, empire, bidPrice, immidiatePurchasePrice);
}
ACMD(do_enroll_wish)
{
char arg1[256];
char arg2[256];
char arg3[256];
one_argument (two_arguments(argument, arg1, sizeof(arg1), arg2, sizeof(arg2)), arg3, sizeof(arg3));
DWORD item_num = strtoul(arg1, NULL, 10);
BYTE empire = strtoul(arg2, NULL, 10);
int wishPrice = strtol(arg3, NULL, 10);
AuctionManager::instance().enroll_wish(ch, item_num, empire, wishPrice);
}
ACMD(do_enroll_sale)
{
char arg1[256];
char arg2[256];
char arg3[256];
one_argument (two_arguments(argument, arg1, sizeof(arg1), arg2, sizeof(arg2)), arg3, sizeof(arg3));
DWORD item_id = strtoul(arg1, NULL, 10);
DWORD wisher_id = strtoul(arg2, NULL, 10);
int salePrice = strtol(arg3, NULL, 10);
LPITEM item = ITEM_MANAGER::instance().Find(item_id);
if (item == NULL)
return;
AuctionManager::instance().enroll_sale(ch, item, wisher_id, salePrice);
}
// temp_auction
// packet으로 통신하게 하고, 이건 삭제해야한다.
ACMD(do_get_auction_list)
{
char arg1[256];
char arg2[256];
char arg3[256];
two_arguments (one_argument (argument, arg1, sizeof(arg1)), arg2, sizeof(arg2), arg3, sizeof(arg3));
AuctionManager::instance().get_auction_list (ch, strtoul(arg1, NULL, 10), strtoul(arg2, NULL, 10), strtoul(arg3, NULL, 10));
}
//
//ACMD(do_get_wish_list)
//{
// char arg1[256];
// char arg2[256];
// char arg3[256];
// two_arguments (one_argument (argument, arg1, sizeof(arg1)), arg2, sizeof(arg2), arg3, sizeof(arg3));
//
// AuctionManager::instance().get_wish_list (ch, strtoul(arg1, NULL, 10), strtoul(arg2, NULL, 10), strtoul(arg3, NULL, 10));
//}
ACMD (do_get_my_auction_list)
{
char arg1[256];
char arg2[256];
two_arguments (argument, arg1, sizeof(arg1), arg2, sizeof(arg2));
AuctionManager::instance().get_my_auction_list (ch, strtoul(arg1, NULL, 10), strtoul(arg2, NULL, 10));
}
ACMD (do_get_my_purchase_list)
{
char arg1[256];
char arg2[256];
two_arguments (argument, arg1, sizeof(arg1), arg2, sizeof(arg2));
AuctionManager::instance().get_my_purchase_list (ch, strtoul(arg1, NULL, 10), strtoul(arg2, NULL, 10));
}
ACMD (do_auction_bid)
{
char arg1[256];
char arg2[256];
two_arguments (argument, arg1, sizeof(arg1), arg2, sizeof(arg2));
AuctionManager::instance().bid (ch, strtoul(arg1, NULL, 10), strtoul(arg2, NULL, 10));
}
ACMD (do_auction_impur)
{
char arg1[256];
one_argument (argument, arg1, sizeof(arg1));
AuctionManager::instance().immediate_purchase (ch, strtoul(arg1, NULL, 10));
}
ACMD (do_get_auctioned_item)
{
char arg1[256];
char arg2[256];
two_arguments (argument, arg1, sizeof(arg1), arg2, sizeof(arg2));
AuctionManager::instance().get_auctioned_item (ch, strtoul(arg1, NULL, 10), strtoul(arg2, NULL, 10));
}
ACMD (do_buy_sold_item)
{
char arg1[256];
char arg2[256];
one_argument (argument, arg1, sizeof(arg1));
AuctionManager::instance().get_auctioned_item (ch, strtoul(arg1, NULL, 10), strtoul(arg2, NULL, 10));
}
ACMD (do_cancel_auction)
{
char arg1[256];
one_argument (argument, arg1, sizeof(arg1));
AuctionManager::instance().cancel_auction (ch, strtoul(arg1, NULL, 10));
}
ACMD (do_cancel_wish)
{
char arg1[256];
one_argument (argument, arg1, sizeof(arg1));
AuctionManager::instance().cancel_wish (ch, strtoul(arg1, NULL, 10));
}
ACMD (do_cancel_sale)
{
char arg1[256];
one_argument (argument, arg1, sizeof(arg1));
AuctionManager::instance().cancel_sale (ch, strtoul(arg1, NULL, 10));
}
ACMD (do_rebid)
{
char arg1[256];
char arg2[256];
two_arguments (argument, arg1, sizeof(arg1), arg2, sizeof(arg2));
AuctionManager::instance().rebid (ch, strtoul(arg1, NULL, 10), strtoul(arg2, NULL, 10));
}
ACMD (do_bid_cancel)
{
char arg1[256];
char arg2[256];
two_arguments (argument, arg1, sizeof(arg1), arg2, sizeof(arg2));
AuctionManager::instance().bid_cancel (ch, strtoul(arg1, NULL, 10));
}
#endif

14
src/game/src/config.cpp
View File

@ -47,9 +47,6 @@ DWORD g_dwTrafficProfileFlushCycle = 3600;
int test_server = 0;
int speed_server = 0;
#ifdef __AUCTION__
int auction_server = 0;
#endif
bool distribution_test_server = false;
bool china_event_server = false;
bool guild_mark_server = true;
@ -809,16 +806,7 @@ void config_init(const string& st_localeServiceName)
continue;
}
#ifdef __AUCTION__
TOKEN("auction_server")
{
printf("-----------------------------------------------\n");
printf("AUCTION_SERVER\n");
printf("-----------------------------------------------\n");
str_to_number(auction_server, value_string);
continue;
}
#endif
TOKEN("distribution_test_server")
{
str_to_number(distribution_test_server, value_string);

17
src/game/src/input_db.cpp
View File

@ -41,13 +41,7 @@
#include "DragonSoul.h"
#ifdef __AUCTION__
#include "auction_manager.h"
#endif
extern BYTE g_bAuthServer;
#ifdef __AUCTION__
extern int auction_server;
#endif
extern void gm_insert(const char * name, BYTE level);
extern BYTE gm_get_level(const char * name, const char * host, const char* account );
extern void gm_host_insert(const char * host);
@ -753,10 +747,7 @@ void CInputDB::Boot(const char* data)
for (WORD i = 0; i < size; ++i, ++kObj)
CManager::instance().LoadObject(kObj, true);
}
#ifdef __AUCTION__
// Auction
AuctionManager::instance().Boot(data);
#endif
set_global_time(*(time_t *) data);
data += sizeof(time_t);
@ -2246,12 +2237,6 @@ int CInputDB::Analyze(LPDESC d, BYTE bHeader, const char * c_pData)
case HEADER_DG_RESPOND_CHANNELSTATUS:
RespondChannelStatus(DESC_MANAGER::instance().FindByHandle(m_dwHandle), c_pData);
break;
#ifdef __AUCTION__
case HEADER_DG_AUCTION_RESULT:
if (auction_server)
AuctionManager::instance().recv_result_auction(m_dwHandle, (TPacketDGResultAuction*)c_pData);
break;
#endif
default:
return (-1);
}

46
src/game/src/item.cpp
View File

@ -1901,52 +1901,6 @@ bool CItem::OnAfterCreatedItem()
return true;
}
#ifdef __AUCTION__
// 경매장
// window를 경매장으로 한다.
bool CItem::MoveToAuction()
{
LPCHARACTER owner = GetOwner();
if (owner == NULL)
{
SPDLOG_ERROR("Item those owner is not exist cannot regist in auction");
return false;
}
if (GetWindow() == AUCTION)
{
SPDLOG_ERROR("Item is already in auction.");
}
SetWindow(AUCTION);
owner->SetItem(m_bCell, NULL);
Save();
ITEM_MANAGER::instance().FlushDelayedSave(this);
return true;
}
void CItem::CopyToRawData (TPlayerItem* new_item)
{
if (new_item != NULL)
return;
new_item->id = m_dwID;
new_item->window = m_bWindow;
new_item->pos = m_bCell;
new_item->count = m_dwCount;
new_item->vnum = GetVnum();
memcpy (new_item->alSockets, m_alSockets, sizeof (m_alSockets));
memcpy (new_item->aAttr, m_aAttr, sizeof (m_aAttr));
new_item->owner = m_pOwner->GetPlayerID();
}
#endif
bool CItem::IsDragonSoul()
{
return GetType() == ITEM_DS;

5
src/game/src/item.h
View File

@ -234,11 +234,6 @@ class CItem : public CEntity
void ClearMountAttributeAndAffect();
bool IsNewMountItem();
#ifdef __AUCTION__
// 경매장
bool MoveToAuction ();
void CopyToRawData (TPlayerItem* item);
#endif
// 독일에서 기존 캐시 아이템과 같지만, 교환 가능한 캐시 아이템을 만든다고 하여,
// 오리지널 아이템에, 교환 금지 플래그만 삭제한 새로운 아이템들을 새로운 아이템 대역에 할당하였다.
// 문제는 새로운 아이템도 오리지널 아이템과 같은 효과를 내야하는데,

36
src/game/src/log.cpp
View File

@ -123,11 +123,6 @@ void LogManager::HackLog(const char * c_pszHackName, LPCHARACTER ch)
}
}
void LogManager::HackCRCLog(const char * c_pszHackName, const char * c_pszLogin, const char * c_pszName, const char * c_pszIP, DWORD dwCRC)
{
Query("INSERT INTO hack_crc_log (time, login, name, ip, server, why, crc) VALUES(NOW(), '%s', '%s', '%s', '%s', '%s', %u)", c_pszLogin, c_pszName, c_pszIP, g_stHostname.c_str(), c_pszHackName, dwCRC);
}
void LogManager::GoldBarLog(DWORD dwPID, DWORD dwItemID, GOLDBAR_HOW eHow, const char* c_pszHint)
{
char szHow[32+1];
@ -294,34 +289,3 @@ void LogManager::DragonSlayLog(DWORD dwGuildID, DWORD dwDragonVnum, DWORD dwStar
get_table_postfix(),
dwGuildID, dwDragonVnum, dwStartTime, dwEndTime);
}
void LogManager::HackShieldLog(unsigned int ErrorCode, LPCHARACTER ch)
{
struct in_addr st_addr;
#ifndef __WIN32__
if (0 == inet_aton(ch->GetDesc()->GetHostName(), &st_addr))
#else
unsigned int in_address;
in_address = inet_addr(ch->GetDesc()->GetHostName());
st_addr.s_addr = in_address;
if (INADDR_NONE == in_address)
#endif
{
Query( "INSERT INTO hackshield_log(time, account_id, login, pid, name, reason, ip) "
"VALUES(NOW(), %u, '%s', %u, '%s', %u, 0)",
ch->GetDesc()->GetAccountTable().id, ch->GetDesc()->GetAccountTable().login,
ch->GetPlayerID(), ch->GetName(),
ErrorCode);
}
else
{
Query( "INSERT INTO hackshield_log(time, account_id, login, pid, name, reason, ip) "
"VALUES(NOW(), %u, '%s', %u, '%s', %u, inet_aton('%s'))",
ch->GetDesc()->GetAccountTable().id, ch->GetDesc()->GetAccountTable().login,
ch->GetPlayerID(), ch->GetName(),
ErrorCode,
ch->GetDesc()->GetHostName());
}
}

2
src/game/src/log.h
View File

@ -36,7 +36,6 @@ class LogManager : public singleton<LogManager>
void MoneyLog(BYTE type, DWORD vnum, int gold);
void HackLog(const char * c_pszHackName, const char * c_pszLogin, const char * c_pszName, const char * c_pszIP);
void HackLog(const char * c_pszHackName, LPCHARACTER ch);
void HackCRCLog(const char * c_pszHackName, const char * c_pszLogin, const char * c_pszName, const char * c_pszIP, DWORD dwCRC);
void GoldBarLog(DWORD dwPID, DWORD dwItemID, GOLDBAR_HOW eHow, const char * c_pszHint);
void CubeLog(DWORD dwPID, DWORD x, DWORD y, DWORD item_vnum, DWORD item_uid, int item_count, bool success);
void GMCommandLog(DWORD dwPID, const char * szName, const char * szIP, BYTE byChannel, const char * szCommand);
@ -50,7 +49,6 @@ class LogManager : public singleton<LogManager>
void QuestRewardLog(const char * c_pszQuestName, DWORD dwPID, DWORD dwLevel, int iValue1, int iValue2);
void DetailLoginLog(bool isLogin, LPCHARACTER ch);
void DragonSlayLog(DWORD dwGuildID, DWORD dwDragonVnum, DWORD dwStartTime, DWORD dwEndTime);
void HackShieldLog(unsigned int ErrorCode, LPCHARACTER ch);
private:
void Query(const char * c_pszFormat, ...);

11
src/game/src/main.cpp
View File

@ -61,10 +61,6 @@
#include <event2/listener.h>
#include <event2/dns.h>
#ifdef __AUCTION__
#include "auction_manager.h"
#endif
#ifdef USE_STACKTRACE
#include <execinfo.h>
#endif
@ -127,9 +123,6 @@ int g_shutdown_core_pulse;
bool g_bShutdown=false;
extern int speed_server;
#ifdef __AUCTION__
extern int auction_server;
#endif
extern void CancelReloadSpamEvent();
void ContinueOnFatalError()
@ -375,10 +368,6 @@ int main(int argc, char **argv)
CSpeedServerManager SSManager;
DSManager dsManager;
#ifdef __AUCTION__
AuctionManager auctionManager;
#endif
if (!start(argc, argv)) {
CleanUpForEarlyExit();
return 0;

8
src/libgame/CMakeLists.txt
View File

@ -1,4 +1,4 @@
cmake_minimum_required(VERSION 3.8)
cmake_minimum_required(VERSION 3.12)
project(libgame CXX)
@ -14,6 +14,12 @@ include_directories("include")
# Create shared library
add_library(${PROJECT_NAME} STATIC ${SOURCES})
# Set the default log level based on the build type
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
message(STATUS "This is a debug build. Log level will be set to 'trace' for target '${PROJECT_NAME}'.")
target_compile_definitions(${PROJECT_NAME} PRIVATE SPDLOG_ACTIVE_LEVEL=SPDLOG_LEVEL_TRACE)
endif()
# Find and link dependencies
# spdlog

2
src/liblua/CMakeLists.txt
View File

@ -1,4 +1,4 @@
cmake_minimum_required(VERSION 3.8)
cmake_minimum_required(VERSION 3.12)
project(liblua CXX)

2
src/libpoly/CMakeLists.txt
View File

@ -1,4 +1,4 @@
cmake_minimum_required(VERSION 3.8)
cmake_minimum_required(VERSION 3.12)
project(libpoly CXX)

17
src/libsql/CMakeLists.txt
View File

@ -1,4 +1,4 @@
cmake_minimum_required(VERSION 3.8)
cmake_minimum_required(VERSION 3.12)
project(libsql CXX)
@ -11,14 +11,21 @@ file(GLOB SOURCES
# Include header files
include_directories("include")
# Create shared library
# Create static library
add_library(${PROJECT_NAME} STATIC ${SOURCES})
# Set the default log level based on the build type
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
message(STATUS "This is a debug build. Log level will be set to 'trace' for target '${PROJECT_NAME}'.")
target_compile_definitions(${PROJECT_NAME} PRIVATE SPDLOG_ACTIVE_LEVEL=SPDLOG_LEVEL_TRACE)
endif()
# Find and link dependencies
# MariaDB
find_package(unofficial-libmariadb REQUIRED)
target_link_libraries(${PROJECT_NAME} PUBLIC unofficial::libmariadb)
# PostgreSQL with libpqxx (stable vcpkg package)
find_package(PostgreSQL REQUIRED)
find_package(libpqxx CONFIG REQUIRED)
target_link_libraries(${PROJECT_NAME} PRIVATE libpqxx::pqxx)
# spdlog
find_package(spdlog CONFIG REQUIRED)

5
src/libsql/include/CAsyncSQL.h
View File

@ -8,9 +8,8 @@
#include <queue>
#include <vector>
#include <map>
#include <mysql/mysql.h>
#include <mysql/errmsg.h>
#include <mysql/mysqld_error.h>
#include <iostream>
#include <pqxx/pqxx>
#include "CSemaphore.h"

8
src/libthecore/CMakeLists.txt
View File

@ -1,4 +1,4 @@
cmake_minimum_required(VERSION 3.8)
cmake_minimum_required(VERSION 3.12)
project(libthecore CXX)
@ -14,6 +14,12 @@ include_directories("include")
# Create shared library
add_library(${PROJECT_NAME} STATIC ${SOURCES})
# Set the default log level based on the build type
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
message(STATUS "This is a debug build. Log level will be set to 'trace' for target '${PROJECT_NAME}'.")
target_compile_definitions(${PROJECT_NAME} PRIVATE SPDLOG_ACTIVE_LEVEL=SPDLOG_LEVEL_TRACE)
endif()
# Find and link dependencies
# fmt

2
src/quest/CMakeLists.txt
View File

@ -1,4 +1,4 @@
cmake_minimum_required(VERSION 3.8)
cmake_minimum_required(VERSION 3.12)
project(quest CXX)