263 lines
8.2 KiB
C++
263 lines
8.2 KiB
C++
#include "stdafx.h"
|
|
#ifdef _NA_008679_20160202_REWORK_BATTLEGROUND
|
|
|
|
#include "./BattleGroundOpenTimeManager.h"
|
|
|
|
#include <time.h>
|
|
#include <UserSessions/UserManager.h>
|
|
|
|
BattleGroundOpenTimeManager::BattleGroundOpenTimeManager(BattleGroundManager* mgr)
|
|
{
|
|
loaded_ = false;
|
|
update_timer_.SetTimer(kUpdateInterval);
|
|
ZeroMemory(¤t_mode_, sizeof(current_mode_));
|
|
|
|
owner_manager = mgr;
|
|
}
|
|
|
|
BattleGroundOpenTimeManager::~BattleGroundOpenTimeManager()
|
|
{
|
|
}
|
|
|
|
BOOL BattleGroundOpenTimeManager::CanReservationTime()
|
|
{
|
|
if (current_mode_.time_mode == ns_func::eCOUNTDOWN_5MINUTES)
|
|
{
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
void BattleGroundOpenTimeManager::Update(const util::TimeInfoPerFrame& time_info, ns_func::eBATTLEGROUND_TIMEMODE& time_mode)
|
|
{
|
|
if (update_timer_.IsExpired() == false)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//current_mode가 없으면
|
|
// 현재 시간에 맞는 time node를 가져온다
|
|
const BattleGroundTimeInfoParser* parser = BattleGroundTimeInfoParser::Instance();
|
|
if (current_mode_.time_mode == ns_func::eNONE)
|
|
{
|
|
if (parser->GetCurrentTimeNode(time_info, time_info.system_time.wDayOfWeek + 1, ¤t_mode_) == false)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// 현재 이벤트 진행중..
|
|
if (current_mode_.day_flag != 0 && current_mode_.IsInRange(time_info.acm_time_) == true)
|
|
{
|
|
return;
|
|
}
|
|
// 현재 이벤트 시간이 지났다면.. 다음 타임 찾기..
|
|
else if (current_mode_.IsInRange(time_info.acm_time_) == false)
|
|
{
|
|
if (parser->GetCurrentTimeNode(time_info, current_mode_.day_flag, ¤t_mode_) == false)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (current_mode_.check_event == false)
|
|
{
|
|
// first event
|
|
ExecuteNotifier();
|
|
}
|
|
|
|
time_mode = current_mode_.time_mode;
|
|
}
|
|
|
|
void BattleGroundOpenTimeManager::ExecuteNotifier()
|
|
{
|
|
assert(current_mode_.check_event == false);
|
|
MSG_CG_ETC_BATTLE_OPEN_TIME_NOTICE_BY_CODE_BRD msg_brd;
|
|
msg_brd.m_NoticeCode = current_mode_.string_code;
|
|
UserManager::Instance()->SendMessageToAllUsers(&msg_brd, sizeof(msg_brd));
|
|
|
|
current_mode_.check_event = true;
|
|
}
|
|
|
|
bool BattleGroundOpenTimeManager::SetupMessage(const util::TimeInfoPerFrame& time_info,
|
|
MSG_CG_BATTLE_GROUND_GET_OPEN_TIME_ACK* const msg_ack) const
|
|
{
|
|
// JOIN State
|
|
if (current_mode_.time_mode == ns_func::eCOUNTDOWN_5MINUTES) {
|
|
msg_ack->join_state = kJoinStateAdmission;
|
|
}
|
|
else {
|
|
msg_ack->join_state = kJoinStateNonadmission;
|
|
}
|
|
|
|
//JOIN Time
|
|
BattleGroundTimeInfoParser* parser = BattleGroundTimeInfoParser::Instance();
|
|
ns_func::BattleGroundTimeNode open_time_node;
|
|
|
|
bool result = parser->GetLatestEventTimeNode(time_info, &open_time_node, ns_func::eCOUNTDOWN_5MINUTES);
|
|
if (result == true)
|
|
{
|
|
uint16_t cur_day = time_info.system_time.wDayOfWeek + 1;
|
|
|
|
// 현재시간
|
|
//현재시간 timeinfo -> tm형식 변환
|
|
tm cur_time_struct;
|
|
util::YYYYMMDDHHMMSSToTMStructure(time_info.wz_yyyymmddhhmmss_, &cur_time_struct);
|
|
cur_time_struct.tm_year -= 1900;
|
|
cur_time_struct.tm_mon -= 1;
|
|
time_t cur_time_val = mktime(&cur_time_struct);
|
|
|
|
//오픈상태 -> 클로즈되는 타임을 전달
|
|
//클로즈상태 -> 오픈될 타임을 전달
|
|
tm next_time_struct = cur_time_struct;
|
|
next_time_struct.tm_wday = open_time_node.day_flag - 1;
|
|
next_time_struct.tm_sec = 0;
|
|
|
|
if (cur_day != open_time_node.day_flag)
|
|
{
|
|
uint16_t elapsed_day = 0;
|
|
if (open_time_node.day_flag < cur_day) {
|
|
elapsed_day = abs((open_time_node.day_flag + 7) - cur_day );
|
|
}
|
|
else {
|
|
elapsed_day = abs(open_time_node.day_flag - cur_day );
|
|
}
|
|
next_time_struct.tm_mday += elapsed_day;
|
|
}
|
|
|
|
if (msg_ack->join_state == kJoinStateAdmission)
|
|
{
|
|
next_time_struct.tm_hour = current_mode_.end_time / 60;
|
|
next_time_struct.tm_min = current_mode_.end_time % 60;
|
|
}
|
|
else
|
|
{
|
|
next_time_struct.tm_hour = open_time_node.start_time / 60;
|
|
next_time_struct.tm_min = open_time_node.start_time % 60;
|
|
}
|
|
|
|
time_t next_time_val = mktime(&next_time_struct);
|
|
|
|
double diff_val = difftime(next_time_val, cur_time_val);
|
|
msg_ack->join_time = static_cast<DWORD>(diff_val) * 1000;
|
|
}
|
|
|
|
return true;
|
|
|
|
//==================================================================================
|
|
/*
|
|
typedef BattleGroundTimeInfoParser::FirstEventList FirstEventList;
|
|
const ns_func::BattleGroundTimeNode::AcmTmFmt k24hours = \
|
|
BattleGroundTimeInfoParser::k24hours;
|
|
const BattleGroundTimeInfoParser* parser = BattleGroundTimeInfoParser::Instance();
|
|
const FirstEventList& first_event_list = parser->GetFirstEventList();
|
|
FirstEventList::const_iterator it = first_event_list.begin(),
|
|
end = first_event_list.end();
|
|
int cur_time = time_info.acm_time_;
|
|
WORD cur_day = time_info.system_time.wDayOfWeek + 1;
|
|
|
|
bool last_event = false;
|
|
const ns_func::BattleGroundTimeNode* time_node = *it;
|
|
for ( ; it != end; ++it)
|
|
{
|
|
const ns_func::BattleGroundTimeNode* time_node_in_loop = *it;
|
|
const bool delimeter = (time_node_in_loop->time_mode == time_node_in_loop->eNONE); // 대기 이벤트
|
|
|
|
const int open_time = time_node_in_loop->start_time;
|
|
const int close_time = delimeter ?
|
|
time_node_in_loop->end_time: // 대기 이벤트..
|
|
time_node_in_loop->end_time + 5; // 시작 이벤트..
|
|
|
|
WORD yesterday = cur_day-1;
|
|
if (yesterday < 1)
|
|
yesterday = 7;
|
|
|
|
if (cur_day == time_node_in_loop->day_flag &&
|
|
(cur_time >= open_time && cur_time < close_time))
|
|
{
|
|
time_node = time_node_in_loop;
|
|
break;
|
|
}
|
|
|
|
else if (yesterday == time_node_in_loop->day_flag &&
|
|
close_time < open_time &&
|
|
cur_time < open_time && cur_time < open_time
|
|
)
|
|
{
|
|
time_node = time_node_in_loop;
|
|
break;
|
|
}
|
|
|
|
else if (yesterday == time_node_in_loop->day_flag &&
|
|
cur_time + k24hours >= open_time && cur_time + k24hours < close_time)
|
|
{
|
|
time_node = time_node_in_loop;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (time_node->time_mode == time_node->eNONE)
|
|
{
|
|
if (it == end || it == end - 1)
|
|
{
|
|
last_event = true;
|
|
time_node = first_event_list.front();
|
|
}
|
|
else
|
|
time_node = *(++it);
|
|
}
|
|
else
|
|
time_node = *it;
|
|
|
|
int open_time = time_node->start_time;
|
|
int close_time = time_node->end_time + 5;
|
|
|
|
if (cur_time >= open_time && cur_time < close_time ||
|
|
cur_time + k24hours >= open_time && cur_time + k24hours < close_time)
|
|
{
|
|
msg_ack->join_state = kJoinStateAdmission;
|
|
}
|
|
else
|
|
{
|
|
msg_ack->join_state = kJoinStateNonadmission;
|
|
};
|
|
|
|
if (open_time > k24hours)
|
|
open_time -= k24hours;
|
|
if (close_time > k24hours)
|
|
close_time -= k24hours;
|
|
|
|
msg_ack->join_time = 0;
|
|
|
|
struct tm cur_time_struct;
|
|
util::YYYYMMDDHHMMSSToTMStructure(time_info.wz_yyyymmddhhmmss_, &cur_time_struct);
|
|
cur_time_struct.tm_year -= 1900;
|
|
cur_time_struct.tm_mon -= 1;
|
|
struct tm next_time_struct = cur_time_struct;
|
|
// test value {
|
|
cur_time_struct.tm_hour = cur_time / 60;
|
|
cur_time_struct.tm_min = cur_time % 60;
|
|
// }
|
|
time_t cur_time_val = mktime(&cur_time_struct);
|
|
//
|
|
if (msg_ack->join_state == kJoinStateAdmission)
|
|
{
|
|
next_time_struct.tm_hour = close_time / 60;
|
|
next_time_struct.tm_min = close_time % 60;
|
|
}
|
|
else if (msg_ack->join_state == kJoinStateNonadmission)
|
|
{
|
|
next_time_struct.tm_hour = open_time / 60;
|
|
next_time_struct.tm_min = open_time % 60;
|
|
};
|
|
time_t open_time_val = mktime(&next_time_struct);
|
|
double diff_val = difftime(open_time_val, cur_time_val);
|
|
msg_ack->join_time = static_cast<DWORD>(diff_val) * 1000;
|
|
|
|
return true;
|
|
*/
|
|
}
|
|
|
|
#endif //_NA_008679_20160202_REWORK_BATTLEGROUND
|