int xhx_get_tast_callback(sprite_t * p, uint32_t id, char * buf, int len)
{
typedef struct {
uint32_t ret_state;
}__attribute__((packed)) xhx_get_task_cbk_pack_t;
xhx_get_task_cbk_pack_t* cbk_pack = (xhx_get_task_cbk_pack_t*)buf;
uint32_t flag = *(uint32_t*)p->session;
uint32_t msgbuf[] = {p->id, 1};
if (flag == 2) {
msglog(statistic_logfile, 0x0409BD98, get_now_tv()->tv_sec, msgbuf, sizeof(msgbuf));
if (cbk_pack->ret_state == 2) { //花宝猪任务接取成功，向小花仙switch发消息
uint32_t type = 1;
send_request_to_xhxserver(XHX_SWITCH_PROTO_USER_SET_VALUE, NULL, 4, &type, p->id);
msglog(statistic_logfile, 0x0409BD99, get_now_tv()->tv_sec, msgbuf, sizeof(msgbuf));
} else if (cbk_pack->ret_state == 4) {//已经成功洗礼过
cbk_pack->ret_state = 2;
}
}
int l = sizeof(protocol_t);
PKG_UINT32(msg, cbk_pack->ret_state, l);
init_proto_head(msg, p->waitcmd, l);
return send_to_self(p, msg, l, 1);
}
int homeland_harvest_fruits_callback(sprite_t* p, uint32_t id, char* buf, int len)
{
CHECK_BODY_LEN(len, 12);
uint32_t number = *(uint32_t*)p->session;
uint32_t old_cultivate_skill = calculation_level_from_skill(p->cultivate_skill);
int cultiv_diff = *(uint32_t*)buf - p->cultivate_skill;
notify_skill_change(p, cultiv_diff, 0);
DEBUG_LOG("qianshu %u %u", cultiv_diff, p->id);
p->cultivate_skill = *(uint32_t*)buf;
uint32_t new_cultivate_skill = calculation_level_from_skill(p->cultivate_skill);
level_change_and_send_postcard(new_cultivate_skill, old_cultivate_skill, 1000109, p->id);
uint32_t itmid = *(uint32_t*)(buf + 4);
uint32_t count = *(uint32_t*)(buf + 8);
DEBUG_LOG("HARVEST FRUITS CALLBACK\t[%u itmid=%u count=%u]", p->id, itmid, count);
msglog(statistic_logfile, 0x04040109,get_now_tv()->tv_sec, &(p->id), 4);
uint32_t msgbuff[2] = {p->id, 1};
msglog(statistic_logfile, 0x0405BEA3, get_now_tv()->tv_sec, msgbuff, sizeof(msgbuff));
int i = sizeof(protocol_t);
PKG_UINT32(msg, number, i);
PKG_UINT32(msg, itmid, i);
PKG_UINT32(msg, count, i);
init_proto_head(msg, p->waitcmd, i);
send_to_map(p, msg, i, 1);
return 0;
}
int make_candy_cmd(sprite_t* p, const uint8_t *body, int bodylen)
{
CHECK_BODY_LEN(bodylen, 8);
int j = 0;
uint32_t pos, type, count;
UNPKG_UINT32(body, pos, j);
UNPKG_UINT16(body, type, j);
UNPKG_UINT16(body, count, j);
if (pos > 3) {
return send_to_self_error(p, p->waitcmd, -ERR_candy_invaild_sit, 1);
}
if (type > MAX_TYPE)
ERROR_RETURN(("bad R4 type\t[%u %u]", p->id, type), -1);
if (count > 100000 || count == 0)
return send_to_self_error(p, p->waitcmd, -ERR_too_much_to_exchange, 1);
if(type == 0){
uint32_t msg_buff[2] = {p->id, 1};
msglog(statistic_logfile, 0x0409C3DF, get_now_tv()->tv_sec, msg_buff, sizeof(msg_buff));
}
else if(type == 1){
uint32_t msg_buff[2] = {p->id, 1};
msglog(statistic_logfile, 0x0409C3E1, get_now_tv()->tv_sec, msg_buff, sizeof(msg_buff));
}
else if( type == 2){
uint32_t msg_buff[2] = {p->id, 1};
msglog(statistic_logfile, 0x0409C3E0, get_now_tv()->tv_sec, msg_buff, sizeof(msg_buff));
}
*(uint32_t*)p->session = pos;
*(uint16_t*)(p->session + 4) = type;
*(uint16_t*)(p->session + 6) = count;
return send_request_to_db(SVR_PROTO_GET_CANDY_TIMES, p, 0, NULL, p->id);
}
int add_item_in_friendship_box_callback(sprite_t *p, uint32_t id, const char *body, int bodylen)
{
response_proto_head(p, p->waitcmd, 0);
uint32_t msg_buff[1] = {p->id};
msglog(statistic_logfile, 0x02100501,get_now_tv()->tv_sec, msg_buff, sizeof(msg_buff));
uint32_t msgbuff[2] = {1, p->id};
msglog(statistic_logfile, 0x02103301,get_now_tv()->tv_sec, msgbuff, sizeof(msgbuff));
return 0;
}
int exchange_foot_print_msglog(sprite_t *p, uint32_t gameid, uint32_t i)
{
uint32_t count = 1;
if (gameid == 17)
{
msglog(statistic_logfile, 0x04040601 + i, now.tv_sec, &count, 4);
}
else if (gameid == 18)
{
msglog(statistic_logfile, 0x04040605 + i, now.tv_sec, &count, 4);
}
return 0;
}
int Cuser_ocean_attire::add_attire_msglog(userid_t userid, uint32_t itemid,
uint32_t count, uint32_t type)
{
uint32_t msg_id = 0;
if(type == 1){//获取
if(itemid >= 1593000 && itemid <= 1593029){
msg_id = 0x0409BDE3 + itemid - 1593000;
}
}
else{//消耗
if(itemid >= 1613108 && itemid <= 1613113){
msg_id = 0x0409BDAF + itemid - 1613108;
}
}
if(msg_id > 0){
struct MSG{
uint32_t uid;
uint32_t cnt;
};
MSG msg = { 0 };
msg.uid = userid;
msg.cnt = count;
msglog(this->msglog_file, msg_id, time(NULL), &msg, sizeof(msg));
}
return 0;
}
/*
* @brief 吃月饼 callback
*/
int user_eat_mooncake_callback(sprite_t* p, uint32_t id, char* buf, int len)
{
typedef struct {
uint32_t left_cnt;
uint32_t item_id;
uint32_t count;
}__attribute__((packed)) eat_mooncake_cbk_pack_t;
CHECK_BODY_LEN(len, sizeof(eat_mooncake_cbk_pack_t));
eat_mooncake_cbk_pack_t* cbk_pack = (eat_mooncake_cbk_pack_t*)buf;
uint32_t daytype = *(uint32_t*)p->session;
uint32_t limit_cnt = (daytype == 50002) ? 100 : 30;
if (cbk_pack->left_cnt <= limit_cnt) {
int32_t db_buff[] = {daytype, limit_cnt, 1};
send_request_to_db(SVR_PROTO_SET_STH_DONE, NULL, 12, db_buff, p->id);
uint32_t msgbuf[2] = {p->id, 1};
msglog(statistic_logfile, 0x0409B47C, get_now_tv()->tv_sec, msgbuf, sizeof(msgbuf));
}
cbk_pack->left_cnt = limit_cnt - cbk_pack->left_cnt;
int l = sizeof(protocol_t);
PKG_UINT32(msg, cbk_pack->left_cnt, l);
PKG_UINT32(msg, cbk_pack->item_id, l);
PKG_UINT32(msg, cbk_pack->count, l);
init_proto_head(msg, p->waitcmd, l);
return send_to_self(p, msg, l, 1);
}
/* ARGSUSED */
void
sigtrace_dump(int s)
{
trace_dump();
if (signal(s, sigtrace_dump) == SIG_ERR)
msglog("signal: %s", rip_strerror(errno));
}
void initBooterLog(void)
{
msgbuf = malloc(BOOTER_LOG_SIZE);
bzero(msgbuf, BOOTER_LOG_SIZE);
cursor = msgbuf;
msglog("%s\n", "Chameleon " I386BOOT_CHAMELEONVERSION " (svn-r" I386BOOT_CHAMELEONREVISION ")" " [" I386BOOT_BUILDDATE "]");
}
int get_weekend_continue_login_count_callback(sprite_t* p, uint32_t id, char* buf, int len)
{
uint32_t week_count = 0;
uint32_t week_last = 0;
unpkg_host_uint32_uint32((uint8_t *)buf, &week_count, &week_last);
if (p->waitcmd == PROTO_GET_WEEKEND_CONTINUE_LOGIN_COUNT)
{
uint32_t info_m[2] = {p->id, 1};
msglog(statistic_logfile, 0x04041008+week_count-1, now.tv_sec, info_m, sizeof(info_m));
response_proto_uint32(p, p->waitcmd, week_count, 0);
return 0;
}
uint32_t week_client = 0;
uint32_t index = 0;
week_client = *(uint32_t *)p->session;
index = *(uint32_t *)(p->session + 4);
if (week_count > 10)
{
week_count = 10;
}
if (week_client != week_count)
{
return send_to_self_error(p, p->waitcmd, -ERR_invalid_session, 1);
}
uint32_t day_count = 0;
day_count = weekend_bonus[week_client].item_count;
return db_set_sth_done(p, 40006, day_count, p->id);
}
int filter_method_frame(int is_inbound, int sesno, struct amqp09_frame_header *hdr, uint8_t *payload, struct statistics *stats)
{
struct amqp09_method_header *mtd = (struct amqp09_method_header *)payload;
struct _method_filters *filter;
for(filter = method_filters; filter->descr != NULL; filter++)
{
if(filter->class == ntohs(mtd->class) &&
filter->method == ntohs(mtd->method))
{
if(is_verbose)
msglog(is_inbound, "[%i.%i] METHOD %s\n", sesno, ntohs(hdr->channel), filter->descr);
if(is_inbound)
{
if(filter->func_in)
return filter->func_in(payload+4, ntohl(hdr->size)-4);
else
return 1; /* pass */
}
else /* !is_inbound */
{
if(filter->func_out)
return filter->func_out(payload+4, ntohl(hdr->size)-4);
else
return 1; /* pass */
}
}
}
msglog(is_inbound, "[%i.%i] unknown method(%i.%i)\n", sesno, ntohs(hdr->channel),
ntohs(mtd->class), ntohs(mtd->method));
return 0; /* trash frame */
}
/**
* @brief 记录统计信息
* @param stat_id 统计id号
* @param data 统计数据
* @param len 数据长度
*/
inline void statistic_msglog(uint32_t stat_id, const void* data, size_t len)
{
int msgret = msglog(stat_file, stat_id, get_now_tv()->tv_sec, data, len);
if (msgret != 0) {
WARN_LOG("statistic log error: stat_id=%X ret=%d", stat_id, msgret);
}
}
void initBooterLog(void)
{
msgbuf = malloc(BOOTER_LOG_SIZE);
bzero(msgbuf, BOOTER_LOG_SIZE);
cursor = msgbuf;
msglog("%s\n", "Chameleon " I386BOOT_CHAMELEONVERSION " - myHack " I386BOOT_MYHACKVERSION " [" I386BOOT_BUILDDATE "]");
}
int homeland_plant_cmd(sprite_t* p, uint8_t* body, int len)
{
CHECK_VALID_ID(p->id);
CHECK_BODY_LEN(len, 16);
if (!p->tiles || !IS_JY_MAP(p->tiles->id))
ERROR_RETURN(("not in JY\t[uid=%u]", p->id), -1);
uint32_t tmp_buf[4]={0};;
int j = 0;
UNPKG_UINT32(body, tmp_buf[0], j); // background id
UNPKG_UINT32(body, tmp_buf[1], j); // itemid
UNPKG_UINT32(body, tmp_buf[2], j); // x grid
UNPKG_UINT32(body, tmp_buf[3], j); // y grid
if (!is_grid_valid(tmp_buf[0], tmp_buf[2], tmp_buf[3])) {
ERROR_RETURN(("error grid\t[uid=%u bg=%u itmid=%u x=%u y=%u]", p->id, tmp_buf[0], tmp_buf[1], tmp_buf[2], tmp_buf[3]), -1);
}
uint32_t msgbuff[2] = {p->id, 1};
msglog(statistic_logfile, 0x0405BEA2, get_now_tv()->tv_sec, msgbuff, sizeof(msgbuff));
DEBUG_LOG("PLANT SEED\t[uid=%u bakgrid=%u itemid=%u x=%u y=%u]", p->id, tmp_buf[0], tmp_buf[1], tmp_buf[2], tmp_buf[3]);
return db_homeland_plant(p, &tmp_buf[1]);
}
int plant_pasture_grass_callback(sprite_t *p, uint32_t id, char *buf, int len)
{
typedef struct ret_grass_info{
uint32_t grassid;
uint32_t index;
} ret_grass_t;
CHECK_BODY_LEN_GE(len, sizeof(uint32_t));
uint32_t grass_count = 0;
uint32_t l = 0;
int offset = sizeof(protocol_t);
UNPKG_H_UINT32(buf, grass_count, l);
DEBUG_LOG("=================================count:%u", grass_count);
PKG_UINT32(msg, grass_count, offset);
uint32_t expect_len = grass_count * sizeof(ret_grass_t) + sizeof(uint32_t);
CHECK_BODY_LEN(len, expect_len);
uint32_t k = 0;
ret_grass_t grass_info;
for(; k < grass_count; ++k){
UNPKG_H_UINT32(buf, grass_info.grassid, l);
UNPKG_H_UINT32(buf, grass_info.index, l);
PKG_UINT32(msg, grass_info.grassid, offset);
PKG_UINT32(msg, grass_info.index, offset);
}
uint32_t msgbuff[2] = { id, 1 };
msglog(statistic_logfile, 0x0408B3D5, get_now_tv()->tv_sec, msgbuff, sizeof(msgbuff));
init_proto_head(msg, p->waitcmd, offset);
return send_to_self(p, msg, offset, 1);
}
void initBooterLog(void)
{
msgbuf = malloc(BOOTER_LOG_SIZE);
bzero(msgbuf, BOOTER_LOG_SIZE);
cursor = msgbuf;
msglog("%s\n", "Enoch (Modules) (r" I386BOOT_CHAMELEONREVISION ")" " [" I386BOOT_BUILDDATE "]");
}
/*
* @brief 每次玩家进入
* @param sprite_t* p 玩家指针
* @return 无
*/
void Cmatch::init(sprite_t *p)
{
DEBUG_LOG("p->id: %u", p->id);
if(m_wait_player == 0){
m_wait_player = p;
}
else{
if(p == m_wait_player){
return;
}
else{
DEBUG_LOG("wait_id: %u", m_wait_player->id);
free_game_group( p->group );
p->group = m_wait_player->group;
m_wait_player->group->players[1] = p;
m_wait_player->group->count = 2;
#ifndef TW_VER
{
//part in
uint32_t msgbuff[2]= { p->id, 1 };
msglog( statistic_file, 0x0409C3C0, get_now_tv()->tv_sec, &msgbuff, sizeof(msgbuff) );
}
#endif
c_link* game = new c_link(m_wait_player->group, p, m_wait_player);
m_wait_player->group->game_handler = game;
//DEBUG_LOG("game address: %x",game);
m_wait_player = 0;
}
}
}
int purchase_pasture_milk_callback(sprite_t *p, uint32_t id, char *buf, int len)
{
CHECK_BODY_LEN(len, sizeof(uint32_t) * 2);
uint32_t milk_storage, day_count;
uint32_t l = 0;
uint32_t offset = sizeof(protocol_t);
UNPKG_H_UINT32(buf, milk_storage, l);
PKG_UINT32(msg, milk_storage, offset);
purchase_award_t awards;
memset(&awards, 0, sizeof(purchase_award_t));
UNPKG_H_UINT32(buf, day_count, l);
if(day_count <= 3){
awards.count = 2;
awards.items[0].itemid = 1270044;
awards.items[0].count = 1;
awards.items[1].itemid = 190293;
awards.items[1].count = 1;
uint32_t msgbuff_1[2] = { id, 1 };
msglog(statistic_logfile, 0x0408B3EF, get_now_tv()->tv_sec, msgbuff_1, sizeof(msgbuff_1));
}
else if(day_count > 3 && day_count <= 7){
awards.count = 2;
awards.items[0].itemid = 180073;
awards.items[0].count = 1;
awards.items[1].itemid = 0;
awards.items[1].count = 500;
}
else{
awards.count = 1;
awards.items[0].itemid = 0;
awards.items[0].count = 500;
}
PKG_UINT32(msg, awards.count, offset);
uint32_t k =0;
for(; k < awards.count; ++k){
db_exchange_single_item_op(p, 202, awards.items[k].itemid, awards.items[k].count, 0);
PKG_UINT32(msg, awards.items[k].itemid, offset);
PKG_UINT32(msg, awards.items[k].count, offset);
}
uint32_t msgbuff_2[2] = { id, 1 };
msglog(statistic_logfile, 0x0408B3D9, get_now_tv()->tv_sec, msgbuff_2, sizeof(msgbuff_2));
init_proto_head(msg, p->waitcmd, offset);
return send_to_self(p, msg, offset, 1);
}
/* ARGSUSED */
void
sigtrace_more(int s)
{
new_tracelevel++;
sigtrace_pat = "SIGUSR1: %s";
if (signal(s, sigtrace_more) == SIG_ERR)
msglog("signal: %s", rip_strerror(errno));
}
/* ARGSUSED */
void
sigtrace_less(int s)
{
new_tracelevel--;
sigtrace_pat = "SIGUSR2: %s";
if (signal(s, sigtrace_less) == SIG_ERR)
msglog("signal: %s", rip_strerror(errno));
}
int charparty_auction_item_callback(sprite_t* p, uint32_t id, char* buf, int len)
{
typedef struct auction_back_s
{
uint32_t result;
uint32_t old_user_id;
uint32_t old_user_prize;
}__attribute__((packed)) auction_back_t;
CHECK_BODY_LEN( len, sizeof(auction_back_t) );
auction_back_t* back = (auction_back_t*)buf;
if( CHPAR_OK == back->result )
{
uint32_t prize = *(uint32_t*)p->session;
//冻结竞价款
p->yxb -= prize;
int sendlen = 0;
uint8_t buff[128];
PKG_H_UINT32( buff, 1, sendlen );
PKG_H_UINT32( buff, 0, sendlen );
PKG_H_UINT32( buff, 203, sendlen );
PKG_H_UINT32( buff, 0, sendlen );
pkg_item_kind( p, buff, 0, &sendlen );
PKG_H_UINT32( buff, 0, sendlen );
PKG_H_UINT32( buff, prize, sendlen );
send_request_to_db( SVR_PROTO_EXCHG_ITEM, NULL, sendlen, buff, p->id );
//先前的竞拍者存在，则把押金返还给他
if( back->old_user_prize > 0 )
{
int sendlen = 0;
uint8_t buff[128];
PKG_H_UINT32( buff, 0, sendlen );
PKG_H_UINT32( buff, 1, sendlen );
PKG_H_UINT32( buff, 203, sendlen );
PKG_H_UINT32( buff, 0, sendlen );
item_kind_t* ik_gold = find_kind_of_item(0);
item_t* it_gold = get_item( ik_gold, 0 );
pkg_item_kind( p, buff, 0, &sendlen );
PKG_H_UINT32( buff, 0, sendlen );
PKG_H_UINT32( buff, back->old_user_prize, sendlen );
PKG_H_UINT32( buff, it_gold->max, sendlen );
send_request_to_db( SVR_PROTO_EXCHG_ITEM, NULL, sendlen, buff, back->old_user_id );
//通知玩家游戏币返还
//DEBUG_LOG( "Notice Palyer:[%u] Update Money", back->old_user_id );
sendlen = 0;
PKG_H_UINT32( buff, back->old_user_id, sendlen );
PKG_H_UINT32( buff, back->old_user_prize, sendlen );
tell_flash_some_msg_across_svr( NULL, CBMT_UPDATE_MONEY, sendlen, (char*)buff );
}
//统计 成功出价竞拍
{
uint32_t msgbuff[2]= {p->id, 1};
msglog(statistic_logfile, 0x0409C2D7, get_now_tv()->tv_sec, msgbuff, sizeof(msgbuff));
}
}
response_proto_uint32( p, p->waitcmd, back->result, 0 );
return 0;
}
int play_with_milk_cow_callback(sprite_t *p, uint32_t id, char *buf, int len)
{
typedef struct ret_cow_info{
uint32_t id;
uint32_t cowid;
uint32_t hp;
uint32_t mood;
uint32_t clean;
uint32_t is_milk;
uint32_t eat_date;
uint32_t milk_storage;
uint32_t day_count;
uint32_t oper_id;
} ret_cow_t;
CHECK_BODY_LEN(len, sizeof(ret_cow_t));
ret_cow_t *cow_info = (ret_cow_t *)buf;
uint32_t offset = sizeof(protocol_t);
PKG_UINT32(msg, cow_info->id, offset);
PKG_UINT32(msg, cow_info->cowid, offset);
PKG_UINT32(msg, cow_info->hp, offset);
PKG_UINT32(msg, cow_info->mood, offset);
PKG_UINT32(msg, cow_info->clean, offset);
PKG_UINT32(msg, cow_info->is_milk, offset);
PKG_UINT32(msg, cow_info->milk_storage, offset);
PKG_UINT32(msg, cow_info->day_count, offset);
PKG_UINT32(msg, cow_info->oper_id, offset);
uint32_t msgbuff[2] = { id, 1 };
if(cow_info->oper_id == 1){
msglog(statistic_logfile, 0x0408B3D6, get_now_tv()->tv_sec, msgbuff, sizeof(msgbuff));
}
else if(cow_info->oper_id == 2){
msglog(statistic_logfile, 0x0408B3D7, get_now_tv()->tv_sec, msgbuff, sizeof(msgbuff));
}
else if(cow_info->oper_id == 3){
msglog(statistic_logfile, 0x0408B3D8, get_now_tv()->tv_sec, msgbuff, sizeof(msgbuff));
}
init_proto_head(msg, p->waitcmd, offset);
return send_to_self(p, msg, offset, 1);
}
int filter_header_frame(int is_inbound, int sesno, struct amqp09_frame_header *hdr, uint8_t *payload, struct statistics *stats)
{
if(is_verbose)
msglog(is_inbound, "[%i.%i] HEADER\n", sesno, ntohs(hdr->channel));
/* Messages always have a content header and zero or more content body frames. */
stats->message_count++;
return 1; /* pass */
}
int add_foot_print_count(sprite_t *p, uint32_t itemid, uint32_t count)
{
if (itemid >= 1352000 && itemid <= 1352011)
{
msglog(statistic_logfile, 0x04040200, now.tv_sec, &count, 4);
DEBUG_LOG("---add_foot_print_count itemid %d count %d--", itemid, count);
return send_request_to_db(SVR_PROTO_ROOMINFO_FOOTPRINT_ADD_COUNT, NULL, 4, &count, p->id);
}
return 0;
}
void statistic_msglog(uint32_t offset, void *data, size_t len)
{
time_t now;
time(&now);
char* file = g_ds_ini.statistic_file;
int msgret = msglog(file, offset, now, data, len);
if (msgret != 0) {
ERROR_LOG( "statistic log error\t[message type=%x return=%d]", offset, msgret);
}
return;
}
int hang_christmas_scok_callback(sprite_t* p, uint32_t id, const char *buf, int len)
{
uint32_t count;
int i = 0;
UNPKG_H_UINT32(buf, count, i);
uint32_t ret_state = 0;
if (count == 0) {
ret_state = 2;
return reply_hang_christmas_sock(p, ret_state);
}
uint32_t friend_id = *(uint32_t*)p->session;
uint32_t all_cnt = *(uint32_t*)(p->session + 4);
typedef struct {
uint32_t type;
uint32_t userid;
}__attribute__((packed)) db_hang_christmas_scok_package_t;
db_hang_christmas_scok_package_t package = {0};
{//跟别人挂的记录
package.type = 1;
package.userid = friend_id;
send_request_to_db(SVR_PROTO_HANG_CHRISTMAS_SOCK, NULL, sizeof(package), &package, p->id);
}
{//别人挂的记录
package.type = 2;
package.userid = p->id;
send_request_to_db(SVR_PROTO_HANG_CHRISTMAS_SOCK, NULL, sizeof(package), &package, friend_id);
}
{//top10设置
typedef struct {
uint32_t userid;
uint32_t all_cnt;
}__attribute__((packed)) db_christmas_scok_top10_package_t;
db_christmas_scok_top10_package_t top10_package= {0};
top10_package.userid = friend_id;
top10_package.all_cnt = all_cnt + 1;
DEBUG_LOG("hand christmas sock: uid[%u] fid[%u] cnt[%u]", p->id, friend_id, top10_package.all_cnt);
send_request_to_db(SVR_PROTO_SET_CHRISTMAS_SOCK_TOP10, NULL, sizeof(top10_package), &top10_package, p->id);
}
uint32_t msgbuf[4] = {0};
if (ISVIP(p->flag)) {
msgbuf[0] = p->id;
msgbuf[1] = 1;
} else {
msgbuf[2] = p->id;
msgbuf[3] = 1;
}
msglog(statistic_logfile, 0x0409BF24, get_now_tv()->tv_sec, msgbuf, sizeof(msgbuf));
return reply_hang_christmas_sock(p, ret_state);
}
int homeland_plant_callback(sprite_t* p, uint32_t id, char* buf, int len)
{
CHECK_BODY_LEN(len, sizeof(plant_attr_t));
add_cultivate_exp(p, 2);
plant_attr_t* plant = (plant_attr_t*)(buf);
DEBUG_LOG ("HOMELAND PLANT CALLBACK\t[%u %u %u]", p->id, id, plant->number);
msglog(statistic_logfile, 0x04040109,get_now_tv()->tv_sec, &(p->id), 4);
return rsp_plant_attr(p, plant, id);
}
/*
* @brief 获得自己的月饼数量 callback
*/
int get_swap_mooncake_callback2(sprite_t* p, get_mooncake_cbk_pack_t* cbk_pack)
{
if (cbk_pack->sytle_id == 0 || cbk_pack->sytle_id > 3) { //判断是否吃过月饼
return send_to_self_error(p, p->waitcmd, -ERR_swap_mooncake_not_enough, 1);
}
uint32_t uid = *(uint32_t*)p->session;
uint32_t swap_cnt = *(uint32_t*)(p->session + 4);
uint32_t swap_item = *(uint32_t*)(p->session + 8);
// DEBUG_LOG("swap mooncake cbk2: mid[%u], uid[%u], itmid[%u], itmcnt[%u]", p->id, uid, cbk_pack->item_id, cbk_pack->count);
if (swap_cnt > cbk_pack->count || swap_item == cbk_pack->item_id) { //判断自己要兑换的月饼数量是否足够
return send_to_self_error(p, p->waitcmd, -ERR_swap_mooncake_not_enough, 1);
}
db_swap_mooncake(p->id, cbk_pack->item_id, swap_item, swap_cnt);
db_swap_mooncake(uid, swap_item, cbk_pack->item_id, swap_cnt);
uint32_t msgbuf[2] = {p->id, 1};
msglog(statistic_logfile, 0x0409B480, get_now_tv()->tv_sec, msgbuf, sizeof(msgbuf));
msgbuf[0] = uid;
msglog(statistic_logfile, 0x0409B480, get_now_tv()->tv_sec, msgbuf, sizeof(msgbuf));
int l = sizeof(protocol_t);
PKG_UINT32(msg, 1, l);
PKG_UINT32(msg, swap_item, l);
PKG_UINT32(msg, swap_cnt, l);
init_proto_head(msg, p->waitcmd, l);
send_to_self(p, msg, l, 1);
sprite_t* s = get_sprite(uid);
if (uid == p->id || s == NULL) {
//return send_to_self_error(p, p->waitcmd, -ERR_swap_mooncake_state_err, 1);
return 0;
}
l = sizeof(protocol_t);
PKG_UINT32(msg, 1, l);
PKG_UINT32(msg, cbk_pack->item_id, l);
PKG_UINT32(msg, swap_cnt, l);
return send_to_self(s, msg, l, 0);
}
/*
*@ get work number, process db's reply
*/
int set_work_num_callback(sprite_t* p, uint32_t id, char* buf, int len)
{
CHECK_BODY_LEN(len, 4);
uint32_t total_count = *(uint32_t*)buf;
DEBUG_LOG("SET WORK NUM CALLBACK\t[%u %u]", p->id, total_count);
if (total_count == 6) {
uint32_t type = 2; // level 2
p->engineer = 2;
return db_set_engineer_level(p, &type);
}
if (total_count == 30) {
uint32_t type = 3; // level 3
p->engineer = 3;
return db_set_engineer_level(p, &type);
}
if (total_count == 60) {
uint32_t type = 4; // level 3
p->engineer = 4;
return db_set_engineer_level(p, &type);
}
uint32_t work_type = *(uint32_t*)p->session;
if (work_type == 1)
{
uint32_t info_m[2] = {1, p->id};
msglog(statistic_logfile, 0x04040001, now.tv_sec, info_m, sizeof(info_m));
}
else if (work_type == 2)
{
uint32_t info_m[2] = {1, p->id};
msglog(statistic_logfile, 0x04040000, now.tv_sec, info_m, sizeof(info_m));
}
response_proto_uint32_uint32(p, p->waitcmd, p->yxb, 0, 0);
return 0;
}
int donate_food_item_callback(sprite_t* p, uint32_t id, char* buf, int len)
{
uint32_t prize_cnt = *(uint32_t*)p->session;
response_proto_uint32( p, p->waitcmd, prize_cnt, 0 );
uint32_t msgbuff[] = {p->id, 1};
msglog(statistic_logfile, 0x0409C2FE, get_now_tv()->tv_sec, msgbuff, sizeof(msgbuff));
const uint32_t day_type = 50015;
int32_t db_buff[] = {day_type, DONATE_FOOD_DAY_LIMIT_CNT, 1};
send_request_to_db(SVR_PROTO_SET_STH_DONE, NULL, sizeof(db_buff), db_buff, p->id);
return 0;
}
