//////////////////////////////////////////////////////////////////////////////////////////////////// /// /// @file CubeSystemParser.cpp /// @author hukim /// @brief [2010/08/24 by hukim] This is created.\n /// //////////////////////////////////////////////////////////////////////////////////////////////////// #include "StdAfx.h" #include "./CubeSystemParser.h" // header #include "PacketStruct_CG.h" #include "SCItemSlot.h" #include "SCItemSlotContainer.h" #include "ItemTypeList.h" #include "ItemInfoParser.h" #ifdef _NA_002253_20100811_CUBE_SYSTEM //////////////////////////////////////////////////////////////////////////////////////////////////// // REGION : Constructor & Destructor //////////////////////////////////////////////////////////////////////////////////////////////////// CubeSystemParser::CubeSystemParser() { } CubeSystemParser::~CubeSystemParser() { } //////////////////////////////////////////////////////////////////////////////////////////////////// // REGION : Implement //////////////////////////////////////////////////////////////////////////////////////////////////// namespace util { namespace internal { // 입력 재료 목록을 정렬한다. static bool PredicateInputMaterial( const CompositionInfo::MaterialInfo& prev_material, const CompositionInfo::MaterialInfo& next_material) { // 코드 순으로 정렬한다. if (prev_material.code_ != next_material.code_) { return prev_material.code_ < next_material.code_; } // 타입 순으로 정렬한다. if (prev_material.type_code_ != next_material.type_code_) { return prev_material.type_code_ < next_material.type_code_; } // 레벨 순으로 정렬한다. if (prev_material.level_ != next_material.level_) { return prev_material.level_ < next_material.level_; } // 개수 순으로 정렬한다. return prev_material.number_ < next_material.number_; } // 유효하지 않은 인벤토리 위치인가? static bool IsValidInventoryPosition(const SCItemSlotContainer& inventory, const POSTYPE inventory_position) { return (inventory_position >= 0 && inventory_position < inventory.GetMaxSlotNum()); } // 유효하지 않은 인벤토리 아이템인가? static bool IsValidInventoryItemState(const SCItemSlot& inventory_item) { #ifdef _SERVER return (!inventory_item.IsLocked() && !inventory_item.IsBlocked() && !inventory_item.IsUserBlocked() && inventory_item.IsContainValidItem()); #else return (!inventory_item.IsBlocked() && !inventory_item.IsUserBlocked() && inventory_item.IsContainValidItem()); #endif // _SERVER } // 입력 재료 목록을 얻는다. static bool GetInputMaterialList( SCItemSlotContainer& inventory, const MaterialInventoryPositionList& inventory_position_list, CompositionInfo::MaterialList& OUT input_material_list) { CompositionInfo::MaterialList::size_type material_index = 0; FOREACH_CONTAINER( const POSTYPE inventory_position, inventory_position_list, MaterialInventoryPositionList) { if (!IsValidInventoryPosition(inventory, inventory_position)) { continue; } SCItemSlot& inventory_item = static_cast(inventory.GetSlot(inventory_position)); if (!IsValidInventoryItemState(inventory_item)) { continue; } CompositionInfo::MaterialInfo& input_material = input_material_list[material_index]; input_material.is_used_ = false; input_material.code_ = inventory_item.GetItemCode(); input_material.type_code_ = inventory_item.GetItemInfo()->m_wType; input_material.level_ = inventory_item.GetItemInfo()->m_LV; input_material.number_ = inventory_item.GetNum(); input_material.ig_type_ = nsSlot::ItemTypeChanger::GetKindOfItemType(inventory_item); input_material.inventory_position_ = inventory_position; ++material_index; } if (material_index == 0) { return false; } input_material_list.set_size(material_index); // 입력한 재료를 코드/타입/레벨/개수 순으로 정렬한다. std::stable_sort(input_material_list.begin(), input_material_list.end(), PredicateInputMaterial); return true; } // 일치하는 합성을 정렬한다. static bool PredicateMatchedComposition( const MatchedCompositionInfo& prev_composition, const MatchedCompositionInfo& next_composition) { return (prev_composition.composition_->weight_) > (next_composition.composition_->weight_); } // 일치하는 합성을 얻는다. static bool GetMatchedComposition( const CompositionInfo::MaterialList& input_material_list, const CompositionInfo& composition, MatchedCompositionInfo& OUT matched_composition) { // 합성 재료 개수가 입력 재료 개수보다 많다면 if ((composition.material_list_).size() > input_material_list.size()) { // 일치할 수 없다. return false; } // 일치하는 재료 목록 크기를 초기화하고 합성 재료 목록 크기로 설정한다. MatchedCompositionInfo::MatchedMaterialList& matched_material_list = matched_composition.matched_material_list_; FOREACH_CONTAINER( MatchedCompositionInfo::MatchedMaterialInfo& matched_material, matched_material_list, MatchedCompositionInfo::MatchedMaterialList) { matched_material.Clear(); } matched_material_list.set_size((composition.material_list_).size()); // 입력 재료에 대해 CompositionInfo::MaterialList::const_iterator input_material_pos = input_material_list.begin(); while (input_material_pos != input_material_list.end()) { const CompositionInfo::MaterialInfo& input_material = *input_material_pos; MatchedCompositionInfo::MatchedMaterialList::iterator matched_material_pos = matched_material_list.begin(); // 합성 재료에 대해 FOREACH_CONTAINER( const CompositionInfo::MaterialInfo& composition_material, composition.material_list_, CompositionInfo::MaterialList) { MatchedCompositionInfo::MatchedMaterialInfo& matched_material = *matched_material_pos; ++matched_material_pos; // 이미 일치하는 재료를 찾았다면 if (matched_material.is_find_) { // 다음 재료를 검사한다. continue; } // 재료 코드가 일치하는지 검사한다. if (composition_material.code_ != CompositionInfo::kUnused) { if (composition_material.code_ != input_material.code_) { continue; } } // 재료 종류가 일치하는지 검사한다. if (composition_material.type_code_ != CompositionInfo::kUnused) { if (composition_material.type_code_ != input_material.type_code_) { continue; } } // 재료 레벨이 일치하는지 검사한다. if (composition_material.level_ != CompositionInfo::kUnused) { if (composition_material.level_ != input_material.level_) { continue; } } // 재료 아이템 타입이 일치하는지 검사한다. if (composition_material.ig_type_ != input_material.ig_type_) { continue; } matched_material.input_material_start_pos_ = &input_material; matched_material.is_mixed_input_material_ = false; // 다른 조건은 만족하는데 입력 재료 개수가 부족하다면 if (composition_material.number_ > input_material.number_) { // 코드가 같은 입력 재료들의 개수를 합쳐서 합성 재료 개수를 만족시킬 수 있는지 검사한다. int same_material_number = input_material.number_; CompositionInfo::MaterialList::const_iterator temp_input_material_pos = &input_material; while (++temp_input_material_pos != input_material_list.end()) { // 다음 입력 재료가 현재 입력 재료와 같은 코드인지 검사한다. const CompositionInfo::MaterialInfo& next_input_material = *temp_input_material_pos; if (next_input_material.code_ != input_material.code_) { break; } // 다음 입력 재료가 같은 코드의 재료라면 개수를 더해서 다시 검사한다. same_material_number += next_input_material.number_; if (composition_material.number_ > same_material_number) { continue; } // 여기까지 왔다면 같은 코드의 입력 재료를 모아서 합성 재료 하나를 만족 시킨다. matched_material.input_material_end_pos_ = temp_input_material_pos + 1; matched_material.is_mixed_input_material_ = true; break; } // 같은 코드의 재료를 합쳐도 개수가 부족하면 if (!matched_material.is_mixed_input_material_) { // 다음 재료를 검사한다. continue; } // 같은 코드의 입력 재료를 합쳐서 일치하는 재료 찾기에 성공했다면 // 입력 재료의 반복자를 합친 범위 만큼 증가시켜 준다. input_material_pos = temp_input_material_pos; } // 일치하는 재료를 발견했음을 설정한다. matched_material.composition_material_ = &composition_material; matched_material.is_find_ = true; } // 합성 재료에 대해 ++input_material_pos; } // 입력 재료에 대해 // 모든 일치하는 재료를 찾았는지 검사한다. FOREACH_CONTAINER( const MatchedCompositionInfo::MatchedMaterialInfo& matched_material, matched_material_list, MatchedCompositionInfo::MatchedMaterialList) { if (!matched_material.is_find_) { return false; } } matched_composition.composition_ = &composition; return true; } // 일치하는 합성 정보로부터 요청을 설정한다. static bool SetCompositionRequest( const MatchedCompositionList& matched_composition_list, MSG_CG_ITEM_COMPOSE_OR_DECOMPOSE_SYN& OUT request) { if (matched_composition_list.size() == 0) { return false; } // 일치한 합성 중 첫번째를 선택한다. const MatchedCompositionInfo& matched_composition = matched_composition_list[0]; const MatchedCompositionInfo::MatchedMaterialList& matched_material_list = matched_composition.matched_material_list_; // 합성 코드를 설정한다. request.reserved_code_ = (matched_composition.composition_)->code_; // 일치한 합성을 기준으로 요청을 만든다. MSG_CG_ITEM_COMPOSE_OR_DECOMPOSE_SYN::MaterialListSize request_material_index = 0; FOREACH_CONTAINER( const MatchedCompositionInfo::MatchedMaterialInfo& matched_material, matched_material_list, MatchedCompositionInfo::MatchedMaterialList) { // 같은 코드의 입력 재료를 합쳐서 합성 재료를 만족 시켰다면 if (matched_material.is_mixed_input_material_) { int same_material_number = 0; // 합친 입력 재료에 대해 CompositionInfo::MaterialList::const_iterator input_material_pos = matched_material.input_material_start_pos_; for (; input_material_pos != matched_material.input_material_end_pos_; ++input_material_pos) { const CompositionInfo::MaterialInfo& input_material = *input_material_pos; MSG_CG_ITEM_COMPOSE_OR_DECOMPOSE_SYN::MaterialInfo& request_material = (request.material_list_)[request_material_index]; { request_material.inventory_position_ = input_material.inventory_position_; request_material.matched_index_ = (matched_material.composition_material_)->column_number_ - 1; // 마지막 입력 재료라면 if (input_material_pos == (matched_material.input_material_end_pos_ - 1)) { // 합성 재료에 필요한 개수만큼만 요청 개수로 설정한다. request_material.selected_number_ = static_cast((matched_material.composition_material_)->number_ - same_material_number); } else { request_material.selected_number_ = input_material.number_; same_material_number += request_material.selected_number_; } } ++request_material_index; } continue; } // 입력 재료와 합성 재료가 1:1로 일치한다. MSG_CG_ITEM_COMPOSE_OR_DECOMPOSE_SYN::MaterialInfo& request_material = (request.material_list_)[request_material_index]; { request_material.inventory_position_ = (matched_material.input_material_start_pos_)->inventory_position_; request_material.selected_number_ = (matched_material.composition_material_)->number_; request_material.matched_index_ = (matched_material.composition_material_)->column_number_ - 1; } ++request_material_index; } request.material_list_size_ = request_material_index; return true; } // 보상의 아이템코드가 같은지 검사한다. static bool IsSameItemCode( const CompositionInfo::RewardInfo& reward, CompositionInfo::RewardInfo::RewardCode reward_code) { if (reward.type_ == CompositionInfo::RewardInfo::kItemCode) { return reward.code_ == reward_code; } return false; } // 합성 요청을 얻는다. static bool GetCompositionRequest( const CompositionMap& composition_map, SCItemSlotContainer& inventory, const MaterialInventoryPositionList& inventory_position_list, MSG_CG_ITEM_COMPOSE_OR_DECOMPOSE_SYN& OUT request) { // 인벤토리 아이템으로부터 합성정보를 탐색할 재료 목록을 생성한다. CompositionInfo::MaterialList input_material_list; if (!GetInputMaterialList(inventory, inventory_position_list, input_material_list)) { return false; } // 입력 재료에 일치하는 합성 목록을 얻는다. MatchedCompositionList matched_composition_list; { // 합성 목록의 합성에 대해 MatchedCompositionList::size_type matched_composition_index = 0; FOREACH_CONTAINER( const CompositionMap::value_type& composition_value, composition_map, CompositionMap) { // 일치하는 합성 목록이 다 찼다면 if (matched_composition_index >= _countof(matched_composition_list.elems) || matched_composition_list.full()) { // 찾기를 중지한다. break; } // 일치하는 합성을 찾는다. const CompositionInfo& composition = *(composition_value.second); MatchedCompositionInfo& matched_composition = matched_composition_list[matched_composition_index]; if (!GetMatchedComposition(input_material_list, composition, matched_composition)) { continue; } ++matched_composition_index; matched_composition_list.set_size(matched_composition_index); } // 일치하는 합성을 찾았는지 검사한다. if (matched_composition_index == 0) { return false; } } // 합성 목록을 조건이 더 구체적인 순으로 정렬한다. std::stable_sort( matched_composition_list.begin(), matched_composition_list.end(), PredicateMatchedComposition); return SetCompositionRequest(matched_composition_list, request); } } // internal } // util //////////////////////////////////////////////////////////////////////////////////////////////////// // REGION : Public //////////////////////////////////////////////////////////////////////////////////////////////////// void CubeSystemParser::Release() { ReleaseComposition(); } BOOL CubeSystemParser::LoadScript(eSCRIPT_CODE script_code, BOOL is_reload) { if (script_code == SCRIPT_CUBE_COMPOSE) { return (LoadComposition(!!is_reload) ? TRUE : FALSE); } else if (script_code == SCRIPT_CUBE_DECOMPOSE) { return (LoadDecomposition(!!is_reload) ? TRUE : FALSE); } return FALSE; } CompositionInfo* CubeSystemParser::FindComposition(const CompositionInfo::CompositionCode code) const { const CompositionMap::const_iterator& pos = composition_map_.find(code); if (pos != composition_map_.end()) { return pos->second; } return NULL; } // 분해 재료 목록을 얻는다. bool CubeSystemParser::GetDecompositionMaterialList( SCItemSlotContainer& inventory, const MaterialInventoryPositionList& inventory_position_list, DecompositionInfo::MaterialList& OUT material_list) const { DecompositionInfo::MaterialList::size_type material_index = 0; FOREACH_CONTAINER( const POSTYPE inventory_position, inventory_position_list, MaterialInventoryPositionList) { using namespace util::internal; // 인벤토리 위치를 검사한다. if (IsValidInventoryPosition(inventory, inventory_position) == false) { continue; } // 인벤토리 아이템 상태를 검사한다. SCItemSlot& inventory_item = static_cast(inventory.GetSlot(inventory_position)); if (IsValidInventoryItemState(inventory_item) == false) { continue; } // 무기나 방어구인지 검사한다. const BASE_ITEMINFO* const inventory_item_info = inventory_item.GetItemInfo(); if ((inventory_item_info->IsWeapon() == false) && (inventory_item_info->IsArmor() == false)) { continue; } // 캐시 아이템은 분해 목록에서 제외 시킨다. if (inventory_item_info->IsChargeItem() == true) { continue; } DecompositionInfo::MaterialInfo& material = material_list[material_index]; material.enchant_ = inventory_item.GetEnchant(); material.socket_number_ = inventory_item.GetSocketNum(); material.item_level_ = inventory_item.GetItemInfo()->m_LV; material.number_ = inventory_item.GetNum(); material.inventory_position_ = inventory_position; // 소켓 개수를 검사한다. if (material.socket_number_ > SOCKET_MAX) { continue; } BOOST_STATIC_ASSERT(DecompositionInfo::ZardInfo::kMaxSize >= 4); (material.zard_list_[0]).grade_ = DecompositionInfo::ZardInfo::kGradeLv1; (material.zard_list_[1]).grade_ = DecompositionInfo::ZardInfo::kGradeLv2; (material.zard_list_[2]).grade_ = DecompositionInfo::ZardInfo::kGradeLv3; (material.zard_list_[3]).grade_ = DecompositionInfo::ZardInfo::kGradeLv4; material.zard_list_.set_size(DecompositionInfo::ZardInfo::kMaxSize); for (DecompositionInfo::MaterialInfo::SocketNumber socket_index = 0; socket_index < material.socket_number_; ++socket_index) { // _NA_000251_20100727_SOCKET_SYSTEM const sSOCKET_OPTION* socket_option = inventory_item.GetSocketOption(static_cast(socket_index)); if (socket_option != NULL) { const eSOCKET_LEVEL zard_grade = socket_option->zard_grade; switch (zard_grade) { case kZardGrade1: (material.zard_list_[0]).number_++; break; case kZardGrade2: (material.zard_list_[1]).number_++; break; case kZardGrade3: (material.zard_list_[2]).number_++; break; case kZardGrade4: (material.zard_list_[3]).number_++; break; } } } ++material_index; } if (material_index == 0) { return false; } material_list.set_size(material_index); return true; } DecompositionInfo::DecompositionPoint CubeSystemParser::GetDecompositionPoint( const DecompositionInfo::MaterialList& material_list) const { const BYTE kEnchantPerPoint = 4; // 인첸트 1당 포인트 const BYTE kSocketNumberPerPoint = 2; // 소켓 1개당 포인트 const BYTE kItemLevelPerPoint = 2; // 아이템 레벨 1당 포인트 const BYTE kGradeLv1ZardPerPoint = 1; // 하급 쟈드 1당 포인트 const BYTE kGradeLv2ZardPerPoint = 3; // 중급 쟈드 1당 포인트 const BYTE kGradeLv3ZardPerPoint = 4; // 상급 쟈드 1당 포인트 const BYTE kGradeLv4ZardPerPoint = 10; // 최상급 쟈드 1당 포인트 DecompositionInfo::DecompositionPoint decomposition_point = 0; // 재료 목록의 재료에 대해 FOREACH_CONTAINER( const DecompositionInfo::MaterialInfo& material, material_list, DecompositionInfo::MaterialList) { // 인첸트 포인트를 계산한다. const DecompositionInfo::DecompositionPoint enchant_point = material.enchant_ * kEnchantPerPoint; // 소켓 포인트를 계산한다. const DecompositionInfo::DecompositionPoint socket_point = material.socket_number_ * kSocketNumberPerPoint; // 아이템 레벨 포인트를 계산한다. const DecompositionInfo::DecompositionPoint item_level_point = material.item_level_ * kItemLevelPerPoint; // 쟈드 포인트를 계산한다. DecompositionInfo::DecompositionPoint zard_point = 0; FOREACH_CONTAINER( const DecompositionInfo::ZardInfo& zard, material.zard_list_, DecompositionInfo::ZardList) { if (zard.number_ < 1) { continue; } switch (zard.grade_) { case DecompositionInfo::ZardInfo::kGradeLv1: zard_point += (zard.number_ * kGradeLv1ZardPerPoint); break; case DecompositionInfo::ZardInfo::kGradeLv2: zard_point += (zard.number_ * kGradeLv2ZardPerPoint); break; case DecompositionInfo::ZardInfo::kGradeLv3: zard_point += (zard.number_ * kGradeLv3ZardPerPoint); break; case DecompositionInfo::ZardInfo::kGradeLv4: zard_point += (zard.number_ * kGradeLv4ZardPerPoint); break; } } // 분해 포인트를 계산한다. decomposition_point += ((enchant_point + socket_point + zard_point + 1) * item_level_point); } return decomposition_point; } bool CubeSystemParser::GetDecompositionRewardList( const DecompositionInfo::DecompositionPoint decomposition_point, DecompositionInfo::RewardList& OUT reward_list) const { // 입력값을 검사한다. if (decomposition_point == 0 || !reward_list.empty()) { return false; } FOREACH_CONTAINER( const DecompositionInfo::RewardInfo& reward, decomposition_reward_list_, DecompositionInfo::RewardList) { // 반환할 보상 정보를 삽인한 후 reward_list.push_back(reward); // 보상 확률을 계산한다. DecompositionInfo::RewardInfo& new_reward = reward_list.back(); new_reward.ratio_ = reward.ratio_ * decomposition_point; } return true; } bool CubeSystemParser::GetRequest( SCItemSlotContainer& inventory, const bool is_composition, const MaterialInventoryPositionList& inventory_position_list, const POSTYPE using_item_position, MSG_CG_ITEM_COMPOSE_OR_DECOMPOSE_SYN& OUT request) const { // 인벤토리에 여유 공간이 없으면 시도할 필요가 없다. if (inventory.GetEmptySlotNum() == 0) { return false; } request.request_type_ = MSG_CG_ITEM_COMPOSE_OR_DECOMPOSE_SYN::kCubeRequest; request.is_composition_ = is_composition; // 큐브 시스템은 아이템을 사용해서 실행하기 때문에 큐브 아이템을 검사한다. { if (!util::internal::IsValidInventoryPosition(inventory, using_item_position)) { return false; } SCItemSlot& using_item = static_cast(inventory.GetSlot(using_item_position)); if (!util::internal::IsValidInventoryItemState(using_item)) { return false; } if ((using_item.GetItemInfo())->m_wType != eITEMTYPE_CUBE) { return false; } request.using_item_position_ = using_item_position; } // 합성 요청이라면 if (request.is_composition_) { return util::internal::GetCompositionRequest( composition_map_, inventory, inventory_position_list, request); } // 분해할 재료 목록을 얻는다. DecompositionInfo::MaterialList material_list; if (!GetDecompositionMaterialList(inventory, inventory_position_list, material_list)) { return false; } // 요청할 재료를 설정한다. MSG_CG_ITEM_COMPOSE_OR_DECOMPOSE_SYN::MaterialListSize material_index = 0; FOREACH_CONTAINER( const DecompositionInfo::MaterialInfo& material, material_list, DecompositionInfo::MaterialList) { MSG_CG_ITEM_COMPOSE_OR_DECOMPOSE_SYN::MaterialInfo& request_material = request.material_list_[material_index]; request_material.inventory_position_ = material.inventory_position_; request_material.selected_number_ = material.number_; request_material.matched_index_ = 0; ++material_index; } request.material_list_size_ = material_index; // 분해 포인트를 얻는다. const DecompositionInfo::DecompositionPoint decomposition_point = GetDecompositionPoint(material_list); if (decomposition_point == 0) { return false; } request.reserved_code_ = decomposition_point; return true; } //////////////////////////////////////////////////////////////////////////////////////////////////// // REGION : Private //////////////////////////////////////////////////////////////////////////////////////////////////// bool CubeSystemParser::LoadComposition(const bool is_reload) { // 스크립트를 다시 읽는다면 if (is_reload) { // 이전 합성 정보를 제거한다. ReleaseComposition(); } bool is_valid_script = true; const int row_size = GetRowSize(); for (int row = 0; row < row_size; row++) { // 합성 코드를 읽어와서 합성 정보를 찾는다. const CompositionInfo::CompositionCode composition_code = GetDataDWORD(_T("Code"), row); CompositionInfo* composition = FindComposition(composition_code); // 합성 정보를 찾을 수 없으면 if (composition == NULL) { // 새로운 합성 정보를 생성한다. composition = new CompositionInfo(composition_code); composition_map_[composition_code] = composition; } // 칼럼 개수를 검사한다. const CompositionInfo::ColumnNumber column_number = GetDataBYTE(_T("ColumnNumber"), row); if (column_number < 1 || column_number > max(CompositionInfo::MaterialInfo::kMaxSize, CompositionInfo::RewardInfo::kMaxSize)) { SUNLOG(eCRITICAL_LOG, _T("|%s|ColumnNumber(칼럼번호)는 1~%d 사이의 숫자로 입력해야 합니다.|현재줄 = %d, ColumnNumber = %d|"), __FUNCTION__, max(CompositionInfo::MaterialInfo::kMaxSize, CompositionInfo::RewardInfo::kMaxSize), row, column_number); is_valid_script = false; continue; } const CompositionInfo::ColumnNumber material_or_reward_index = column_number-1; // 재료 칼럼을 사용한다면 const int use_material = GetDataInt(_T("UseMaterial"), row); if (use_material == CompositionInfo::kUsed) { CompositionInfo::MaterialList& material_list = composition->material_list_; CompositionInfo::MaterialInfo& material = material_list[material_or_reward_index]; // 재료가 이미 설정되었다면 if (material.is_used_) { // 중복된 재료 칼럼이다. SUNLOG(eCRITICAL_LOG, _T("|%s|같은 합성정보안에서 재료의 ColumnNumber(칼럼번호)는 중복 될 수 없습니다.|현재줄 = %d, ColumnNumber = %d|"), __FUNCTION__, row, column_number); is_valid_script = false; continue; } // 재료 개수를 검사한다. const int material_number = GetDataInt(_T("MaterialNumber"), row); if (material_number < 1 || material_number > USHRT_MAX/*UCHAR_MAX*/) { SUNLOG(eCRITICAL_LOG, _T("|%s|MaterialNumber(재료개수)가 올바르지 않습니다.|현재줄 = %d, 재료개수 = %d|"), __FUNCTION__, row, material_number); is_valid_script = false; continue; } // 재료 정보를 읽어온다. material.is_used_ = true; material.column_number_ = column_number; material.code_ = GetDataDWORD(_T("MaterialCode"), row); material.type_code_ = GetDataDWORD(_T("MaterialTypeCode"), row); material.level_ = GetDataWORD(_T("MaterialLevel"), row); material.number_ = static_cast(material_number); material.ig_type_ = GetDataBYTE(_T("MaterialIGType"), row); // 읽어온 재료의 조건들 중 최소한 하나는 사용해야 한다. if (material.code_ == CompositionInfo::kUnused && material.type_code_ == CompositionInfo::kUnused && material.level_ == CompositionInfo::kUnused) { SUNLOG(eCRITICAL_LOG, _T("|%s|MaterialCode(재료코드),MaterialTypeCode(재료종류코드),MaterialLevel(재료레벨) 중에 최소한 하나는 입력해야 합니다.|현재줄 = %d|"), __FUNCTION__, row); is_valid_script = false; continue; } // 재료 아이템 타입 범위를 검사한다. if (material.ig_type_ < KindOfItemType::Default || material.ig_type_ >= KindOfItemType::Counts) { SUNLOG(eCRITICAL_LOG, _T("|%s|MaterialIGType(재료아이템타입) 값의 범위가 옳바르지 않습니다.|현재줄 = %d, MaterialIGType = %d|"), __FUNCTION__, row, material.ig_type_); is_valid_script = false; continue; } // 가중치를 계산한다. (코드 > 타입 코드 > 레벨 > 개수) { enum { kMaterialNumberWeight = 1, kMaterialLevelWeight, kMaterialTypeWeight, kMaterialCodeWeight }; if (material.code_ != CompositionInfo::kUnused) { composition->weight_ += kMaterialCodeWeight; } if (material.type_code_ != CompositionInfo::kUnused) { composition->weight_ += kMaterialTypeWeight; } if (material.level_ != CompositionInfo::kUnused) { composition->weight_ += kMaterialLevelWeight; } composition->weight_ += (material.number_ * kMaterialNumberWeight); } // 칼럼 번호가 목록 크기보다 크다면 새로 삽입된 것이므로 if (static_cast(column_number) > material_list.size()) { // 목록의 크기를 새로 설정한다. material_list.set_size(column_number); } } // 보상 칼럼을 사용한다면 const int use_reward = GetDataInt(_T("UseReward"), row); if (use_reward == CompositionInfo::kUsed) { CompositionInfo::RewardList& reward_list = composition->reward_list_; CompositionInfo::RewardInfo& reward = reward_list[material_or_reward_index]; // 보상이 이미 설정되었다면 if (reward.is_used_) { // 중복된 보상 칼럼이다. SUNLOG(eCRITICAL_LOG, _T("|%s|같은 합성정보안에서 보상의 ColumnNumber(칼럼번호)는 중복 될 수 없습니다.|현재줄 = %d, ColumnNumber = %d|"), __FUNCTION__, row, column_number); is_valid_script = false; continue; } // 보상 개수를 검사한다. const int reward_number = GetDataInt(_T("RewardNumber"), row); if (reward_number > UCHAR_MAX) { SUNLOG(eCRITICAL_LOG, _T("|%s|RewardNumber(보상개수)가 올바르지 않습니다.|현재줄 = %d, 보상개수 = %d|"), __FUNCTION__, row, reward_number); is_valid_script = false; continue; } // 보상 정보를 읽어온다. reward.is_used_ = true; reward.column_number_ = column_number; reward.type_ = GetDataInt(_T("RewardType"), row); reward.code_ = GetDataDWORD(_T("RewardCode"), row); reward.ig_type_ = GetDataBYTE(_T("RewardIGType"), row); reward.ratio_ = GetDataWORD(_T("RewardRatio"), row); reward.number_ = static_cast(reward_number); // 보상종류를 검사한다. if (reward.type_ != CompositionInfo::RewardInfo::kItemCode && reward.type_ != CompositionInfo::RewardInfo::kRewardCode) { SUNLOG(eCRITICAL_LOG, _T("|%s|RewardType(보상종류)은 아이템코드(%d)이거나 보상코드(%d)이어야 합니다.|현재줄 = %d, RewardType = %d|"), __FUNCTION__, CompositionInfo::RewardInfo::kItemCode, CompositionInfo::RewardInfo::kRewardCode, row, reward.type_); is_valid_script = false; continue; } // 보상코드는 보상 종류에 상관없이 반드시 입력 되어야 한다. if (reward.code_ == CompositionInfo::kUnused) { SUNLOG(eCRITICAL_LOG, _T("|%s|RewardCode(보상코드)는 RewardType(보상종류)에 해당하는 값을 반드시 입력해야 합니다.|현재줄 = %d|"), __FUNCTION__, row); is_valid_script = false; continue; } // 보상 아이템 타입 범위를 검사한다. if (reward.ig_type_ < KindOfItemType::Default || reward.ig_type_ >= KindOfItemType::Counts) { SUNLOG(eCRITICAL_LOG, _T("|%s|RewardIGType(보상아이템타입) 값의 범위가 옳바르지 않습니다.|현재줄 = %d, RewardIGType = %d|"), __FUNCTION__, row, reward.ig_type_); is_valid_script = false; continue; } // 보상종류가 아이템코드일때 if (reward.type_ == CompositionInfo::RewardInfo::kItemCode) { // 보상 확률은 0보다 작을 수 없다. if (reward.ratio_ < 0 || reward.ratio_ > CompositionInfo::RewardInfo::kMaxRewardRatioSize) { SUNLOG(eCRITICAL_LOG, _T("|%s|RewardType(보상종류)가 아이템코드(%d)일때 RewardRatio(보상확률)은 0~%d 사이의 값이어야 합니다.|현재줄 = %d|"), __FUNCTION__, CompositionInfo::RewardInfo::kItemCode, CompositionInfo::RewardInfo::kMaxRewardRatioSize, row); is_valid_script = false; continue; } // 보상 개수는 0보다 커야 한다. if (reward.number_ == 0) { SUNLOG(eCRITICAL_LOG, _T("|%s|RewardType(보상종류)가 아이템코드(%d)일때 RewardNumber(보상개수)는 0보다 커야 합니다.|현재줄 = %d|"), __FUNCTION__, CompositionInfo::RewardInfo::kItemCode, row); is_valid_script = false; continue; } } // 보상종류가 보상코드일때 if (reward.type_ == CompositionInfo::RewardInfo::kRewardCode) { // 보상확률은 0이 아니라면 if (reward.ratio_ != 0.0) { // 보정 가능하므로 보정한다. SUNLOG(eCRITICAL_LOG, _T("|%s|RewardType(보상종류)가 보상코드(%d)일때 RewardRatio(보상확률)는 0이어야 합니다.|현재줄 = %d|"), __FUNCTION__, CompositionInfo::RewardInfo::kRewardCode, row); reward.ratio_ = 0; } // 보상개수가 0이 아니라면 if (reward.number_ != 0) { // 보정 가능하므로 보정한다. SUNLOG(eCRITICAL_LOG, _T("|%s|RewardType(보상종류)가 보상코드(%d)일때 RewardNumber(보상개수)는 0이어야 합니다.|현재줄 = %d|"), __FUNCTION__, CompositionInfo::RewardInfo::kRewardCode, row); reward.number_ = 0; } } // 칼럼 번호가 목록 크기보다 크다면 새로 삽입된 것이므로 if (static_cast(column_number) > reward_list.size()) { // 목록의 크기를 새로 설정한다. reward_list.set_size(column_number); } } } // for (int row = 0; row < row_size; row++) // 스크립트를 미리 검증하자. // 보상 종류가 보상코드라면 복수의 보상 의미를 내포하고 있으므로 보상 코드일때는 오직 하나만 허용한다. // 하지만 보상 종류가 아이템코드라면 복수의 아이템코드를 허용한다. // 보상코드와 아이템코드의 조합은 허용하지 않는다. // 각 합성에 대해 FOREACH_CONTAINER( const CompositionMap::value_type& composition_value, composition_map_, CompositionMap) { const CompositionInfo* const composition = composition_value.second; // 합성 정보의 재료 개수가 최소 1개는 필요하다. if ((composition->material_list_).size() == 0) { SUNLOG(eCRITICAL_LOG, _T("|%s|합성 정보안에 재료가 최소한 하나 이상 필요합니다.|CompositionCode = %d|"), __FUNCTION__, composition->code_); is_valid_script = false; continue; } // 읽어들인 재료 목록을 검사한다. FOREACH_CONTAINER( const CompositionInfo::MaterialInfo& material, composition->material_list_, CompositionInfo::MaterialList) { // 재료가 사용 가능한지 검사한다. if (!material.is_used_) { SUNLOG(eCRITICAL_LOG, _T("|%s|재료가 사용안함으로 설정되어 있습니다.|CompositionCode = %d|ColumnNumber = %d|"), __FUNCTION__, composition->code_, material.column_number_); is_valid_script = false; break; } } // 읽어들인 보상 목록을 검사한다. bool is_find_reward_code = false; FOREACH_CONTAINER( const CompositionInfo::RewardInfo& reward, composition->reward_list_, CompositionInfo::RewardList) { // 보상이 사용 가능한지 검사한다. if (!reward.is_used_) { SUNLOG(eCRITICAL_LOG, _T("|%s|보상이 사용안함으로 설정되어 있습니다.|CompositionCode = %d|ColumnNumber = %d|"), __FUNCTION__, composition->code_, reward.column_number_); is_valid_script = false; break; } // 이미 보상코드가 하나 발견되었는데 if (is_find_reward_code) { // 다른 종류의 보상이 또 발견되었다. SUNLOG(eCRITICAL_LOG, _T("|%s|RewardType(보상종류)가 보상코드로 설정되어 있을 때는 오직 하나의 보상만 입력 가능합니다.|CompositionCode = %d|"), __FUNCTION__, composition->code_); is_valid_script = false; break; } if (reward.type_ == CompositionInfo::RewardInfo::kRewardCode) { is_find_reward_code = true; } // 보상의 아이템 코드가 보상목록에서 유일한지 검사한다. const CompositionInfo::RewardList::difference_type same_item_code_count = \ std::count_if(composition->reward_list_.begin(), composition->reward_list_.end(), boost::bind(&util::internal::IsSameItemCode, _1, reward.code_)); if (same_item_code_count > 1) { SUNLOG(eCRITICAL_LOG, _T("|%s|보상 목록에서 아이템 코드는 유일해야 합니다.|중복개수 = %d|"), __FUNCTION__, same_item_code_count); is_valid_script = false; break; } } // 보상 코드가 발견되었는데 보상이 하나가 아니다. if (is_find_reward_code && (composition->reward_list_).size() != 1) { SUNLOG(eCRITICAL_LOG, _T("|%s|RewardType(보상종류)가 보상코드로 설정되어 있을 때는 오직 하나의 보상만 입력 가능합니다.|CompositionCode = %d|"), __FUNCTION__, composition->code_); is_valid_script = false; } } // 각 합성에 대해 FASSERT(is_valid_script && _T("스크립트 鑒앴唐댄轎.")); return is_valid_script; } bool CubeSystemParser::LoadDecomposition(const bool is_reload) { if (is_reload) { decomposition_reward_list_.clear(); } bool is_valid_script = true; const int row_size = GetRowSize(); for (int row = 0; row < row_size; row++) { // 보상 정보를 읽어온다. DecompositionInfo::RewardInfo reward; { reward.type_ = GetDataInt(_T("DecRewardType"), row); reward.code_ = GetDataDWORD(_T("DecRewardCode"), row); reward.min_code_ = GetDataDWORD(_T("DecMinCode"), row); reward.max_code_ = GetDataDWORD(_T("DecMaxCode"), row); reward.ratio_ = GetDataWORD(_T("DecRewardRatio"), row); } // 보상종류를 검사한다. if (reward.type_ != DecompositionInfo::RewardInfo::kItemCode && reward.type_ != DecompositionInfo::RewardInfo::kZard) { SUNLOG(eCRITICAL_LOG, _T("|%s|DecRewardType(보상종류)은 아이템코드(%d)이거나 쟈드(%d) 이어야 합니다.|현재줄 = %d, DecRewardType = %d|"), __FUNCTION__, DecompositionInfo::RewardInfo::kItemCode, DecompositionInfo::RewardInfo::kZard, row, reward.type_); is_valid_script = false; continue; } // 보상코드를 검사한다. if (reward.code_ == DecompositionInfo::kUnused) { SUNLOG(eCRITICAL_LOG, _T("|%s|DecRewardCode(보상코드)에는 반드시 DecRewardType(보상종류)에 해당하는 코드를 입력해야 합니다.|현재줄 = %d|"), __FUNCTION__, row); is_valid_script = false; continue; } // 보상확률을 검사한다. if (reward.ratio_ <= 0 || reward.ratio_ > DecompositionInfo::RewardInfo::kMaxRewardRatioSize) { SUNLOG(eCRITICAL_LOG, _T("|%s|DecRewardRatio(보상확률)는 1~%d 사이의 값이어야 합니다.|현재줄 = %d|"), __FUNCTION__, DecompositionInfo::RewardInfo::kMaxRewardRatioSize, row); is_valid_script = false; continue; } // 보상종류가 쟈드일때 if (reward.type_ == DecompositionInfo::RewardInfo::kZard) { // 보상코드에 쟈드등급이 들어갔는지 검사한다. if (reward.code_ != DecompositionInfo::ZardInfo::kGradeLv1 && reward.code_ != DecompositionInfo::ZardInfo::kGradeLv2 && reward.code_ != DecompositionInfo::ZardInfo::kGradeLv3 && reward.code_ != DecompositionInfo::ZardInfo::kGradeLv4) { SUNLOG(eCRITICAL_LOG, _T("|%s|옳바른 쟈드 등급을 입력해야 합니다.|현재줄 = %d, DecRewardCode = %d|"), __FUNCTION__, row, reward.code_); is_valid_script = false; continue; } // 쟈드인 아이템의 최소 코드 범위가 입력되었는지 검사한다. if (reward.min_code_ == DecompositionInfo::kUnused) { SUNLOG(eCRITICAL_LOG, _T("|%s|DecMinCode 에는 쟈드 등급이 %d인 아이템들의 최소 아이템코드 범위를 입력해야 합니다.|현재줄 = %d|"), __FUNCTION__, reward.code_, row); is_valid_script = false; continue; } // 쟈드인 아이템의 최대 코드 범위가 입력되었는지 검사한다. if (reward.max_code_ == DecompositionInfo::kUnused) { SUNLOG(eCRITICAL_LOG, _T("|%s|DecMaxCode 에는 쟈드 등급이 %d인 아이템들의 최대 아이템코드 범위를 입력해야 합니다.|현재줄 = %d|"), __FUNCTION__, reward.code_, row); is_valid_script = false; continue; } // 최소 보상코드는 최대 보상 코드보다 클 수 없다. if (reward.min_code_ > reward.max_code_) { SUNLOG(eCRITICAL_LOG, _T("|%s|DecMinCode는 DecMaxCode 보다 클 수 없습니다.|DecMinCode = %d, DecMaxCode = %d, 현재줄 = %d|"), __FUNCTION__, reward.min_code_, reward.max_code_, row); is_valid_script = false; continue; } // 쟈드 보상 범위를 검사해서 유효한 범위만 얻는다. const ItemInfoParser* const item_info_parser = ItemInfoParser::Instance(); for (DecompositionInfo::RewardInfo::RewardCode zard_code = reward.min_code_; zard_code <= reward.max_code_; ++zard_code) { const BASE_ITEMINFO* const zard = item_info_parser->GetItemInfo(zard_code); if (zard == NULL) { continue; } if (zard->m_wType != eITEMTYPE_SOCKET_ZARD && zard->m_wType != eITEMTYPE_SOCKET_ZARD_RINGS) // xiaomi add bool CubeSystemParser::LoadDecomposition(const bool is_reload) { continue; } #ifdef _NA_006251_CUBESYSTEM_Decomposition_REWARD_REMOVE_CASH_ZARD if (zard->m_ChargeType == 1) // 캐시아이템일경우 ChargeType을 1로 설정 { // 캐시쟈드 아이템은 보상리스트에 포함시키지 않는다. continue; } #endif // _NA_006251_CUBESYSTEM_Decomposition_REWARD_REMOVE_CASH_ZARD (reward.zard_list).push_back(zard_code); } if ((reward.zard_list).empty()) { SUNLOG(eCRITICAL_LOG, _T("|%s|쟈드 보상 코드 범위가 유효하지 않습니다.|DecMinCode = %d, DecMaxCode = %d, 현재줄 = %d|"), __FUNCTION__, reward.min_code_, reward.max_code_, row); is_valid_script = false; continue; } } // 보상 목록에 삽입한다. decomposition_reward_list_.push_back(reward); } FASSERT(is_valid_script && _T("스크립트 鑒앴唐댄轎.")); return is_valid_script; } void CubeSystemParser::ReleaseComposition() { FOREACH_CONTAINER( const CompositionMap::value_type& composition_value, composition_map_, CompositionMap) { CompositionInfo* composition = composition_value.second; SAFE_DELETE(composition); } composition_map_.clear(); } #endif // _NA_002253_20100811_CUBE_SYSTEM