#include "SunClientPrecompiledHeader.h" #include "AutobotCondition.h" #include "Autobot/Autobot.h" #include "SCItemSlot.h" #include "Hero.h" #include "Pet.h" #include "Map.h" #include "Monster.h" #include "ObjectManager.h" #include "SkillInfoParser.h" #include "SkillSlot.h" #include "BattleScene.h" #include "ItemManager.h" #include "Item.h" #include "Interface/uiPartyMan/uiPartyMan.h" #include "InventoryDialog.h" #include "AutomaticInfoParser.h" #include "ItemInfoParser.h" bool CanTradeSell(SCItemSlot* pItemSlot, const BASE_ITEMINFO *pItemInfo, eITEM_TRADESELL_TYPE trade_sell_type); //------------------------------------------------------------------------------ //! AutobotCondition //------------------------------------------------------------------------------ AutobotCondition::ItemType AutobotCondition::ConvertPickupItemType(const BASE_ITEMINFO* item_info) { if (item_info == NULL) { return kItem_All; } if (item_info->IsWeapon() == TRUE) { return kItem_Weapon; } else if (item_info->IsArmor() == TRUE) { return kItem_Armor; } else if (item_info->m_wType == eITEMTYPE_AC) { return kItem_AC; } else if (item_info->m_wType == eITEMTYPE_QUEST) { return kItem_Quest; } else if ((item_info->m_wType == eITEMTYPE_ENCHANT) || (item_info->m_wType == eITEMTYPE_CRYSTAL) || (item_info->m_wType == eITEMTYPE_SOCKET_ZARD) ) { return kItem_Stone; } return kItem_Normal; } //------------------------------------------------------------------------------ AutobotCondition::ItemType AutobotCondition::ConvertPickupItemType(Item& item) { if (item.IsMoney() == TRUE) { return kItem_Heim; } return ConvertPickupItemType(item.GetItemSlot().GetItemInfo()); } //------------------------------------------------------------------------------ AutobotCondition::ItemType AutobotCondition::ConvertPickupItemType(eAUTO_HUNTING_TYPE hunting_type) { switch (hunting_type) { case eAUTO_PICKUP_ALL: return kItem_All; case eAUTO_PICKUP_NORMAL: return kItem_Normal; case eAUTO_PICKUP_QUEST: return kItem_Quest; case eAUTO_PICKUP_STONE: return kItem_Stone; case eAUTO_PICKUP_WEAPON: return kItem_Weapon; case eAUTO_PICKUP_ARMOR: return kItem_Armor; case eAUTO_PICKUP_AC: return kItem_AC; case eAUTO_PICKUP_HEIM: return kItem_Heim; //case eAUTO_PICKUP_ITEMTYPE: case eAUTO_SELL_ALL: return kItem_All; case eAUTO_SELL_NORMAL: return kItem_Normal; case eAUTO_SELL_QUEST: return kItem_Quest; case eAUTO_SELL_STONE: return kItem_Stone; case eAUTO_SELL_WEAPON: return kItem_Weapon; case eAUTO_SELL_ARMOR: return kItem_Armor; case eAUTO_SELL_AC: return kItem_AC; } return kItem_Max; } //------------------------------------------------------------------------------ //! AutobotCondition_Pickup //------------------------------------------------------------------------------ void AutobotCondition_Pickup::Clear() { pickupitem_set().clear(); } //------------------------------------------------------------------------------ bool AutobotCondition_Pickup::Insert(AutobotCondition::ItemType item_type) { pickupitem_set().insert(item_type); return true; } //------------------------------------------------------------------------------ void AutobotCondition_Pickup::Remove(AutobotCondition::ItemType item_type) { ConditionPickupItemSet::iterator iter = pickupitem_set().find(item_type); if (iter != pickupitem_set().end()) { pickupitem_set().erase(iter); } } //------------------------------------------------------------------------------ bool AutobotCondition_Pickup::IsPossiblePickup(Item& item) { return IsPossiblePickup(ConvertPickupItemType(item)); } //------------------------------------------------------------------------------ bool AutobotCondition_Pickup::IsPossiblePickup(ItemType item_type) { if (pickupitem_set().find(kItem_All) != pickupitem_set().end()) { return true; } return HasItemType(item_type); } //------------------------------------------------------------------------------ bool AutobotCondition_Pickup::HasItemType(ItemType item_type) { return (pickupitem_set().find(item_type) != pickupitem_set().end()); } //------------------------------------------------------------------------------ void AutobotCondition_Pickup::Save(FILE* fp) { int count = pickupitem_set().size(); ConditionPickupItemSet::iterator begin = pickupitem_set().begin(); ConditionPickupItemSet::iterator end = pickupitem_set().end(); fwrite(&count, sizeof(int), 1, fp); for (; begin != end; ++begin) { AutobotCondition::ItemType item_type = *begin; fwrite(&item_type, sizeof(item_type), 1, fp); } } //------------------------------------------------------------------------------ void AutobotCondition_Pickup::Load(FILE* fp, int file_version) { int count = 0; fread(&count, sizeof(int), 1, fp); AutobotCondition::ItemType item_type = kItem_Max; for (int i = 0; i < count; ++i) { fread(&item_type, sizeof(item_type), 1, fp); Insert(item_type); } } //------------------------------------------------------------------------------ void AutobotCondition_Pickup::CheckValid(SLOTCODE item_code) { for (int i = static_cast(eAUTO_PICKUP_ALL); i <= static_cast(eAUTO_PICKUP_HEIM); ++i) { eAUTO_HUNTING_TYPE hunting_type = static_cast(i); if (AutomaticInfoParser::Instance()->CheckItemCodeInAutomaticInfo(hunting_type, item_code) == false) { ItemType item_type = ConvertPickupItemType(hunting_type); pickupitem_set().erase(item_type); } } } //------------------------------------------------------------------------------ void AutobotCondition_Pickup::SaveToBuffer(ArchiveOfStream& ar) { BYTE count = static_cast(pickupitem_set().size()); ar << count; ConditionPickupItemSet::iterator begin = pickupitem_set().begin(); ConditionPickupItemSet::iterator end = pickupitem_set().end(); for (; begin != end; ++begin) { BYTE item_type = static_cast(*begin); ar << item_type; } } //------------------------------------------------------------------------------ void AutobotCondition_Pickup::LoadFromBuffer(ArchiveOfStream& ar, int file_version) { BYTE count = 0; ar >> count; BYTE item_type = 0; for (int i = 0; i < static_cast(count); ++i) { ar >> item_type; Insert(static_cast(item_type)); } } //------------------------------------------------------------------------------ bool AutobotCondition_Pickup::SendCheck(AutobotCondition_Pickup& dummy) { if (pickupitem_set().size() != dummy.pickupitem_set().size()) { return true; } else { ConditionPickupItemSet::iterator begin = pickupitem_set().begin(); ConditionPickupItemSet::iterator end = pickupitem_set().end(); ConditionPickupItemSet::iterator dummy_begin = dummy.pickupitem_set().begin(); ConditionPickupItemSet::iterator dummy_end = dummy.pickupitem_set().end(); for (; begin != end; ++begin, ++dummy_begin) { if (*begin != *dummy_begin) { return true; } } } return false; } void AutobotCondition_Pickup::CopyData(AutobotCondition_Pickup& sorce) { Clear(); ConditionPickupItemSet::iterator begin = sorce.pickupitem_set().begin(); ConditionPickupItemSet::iterator end = sorce.pickupitem_set().end(); for (; begin != end; ++begin) { Insert(*begin); } } //------------------------------------------------------------------------------ //!AutobotCondition_Recall //------------------------------------------------------------------------------ void AutobotCondition_Recall::Clear() { inventory_full_percent_ = 0.0f; warning_dura_ = 0; heal_item_num_ = 0; feed_item_num_ = 0; is_return_field_ = true; } //------------------------------------------------------------------------------ bool AutobotCondition_Recall::IsReturnVillage() { if ((warning_dura() > 0) && ItemManager::Instance()->IsExistRepairItem(SI_EQUIPMENT, warning_dura())) { return true; } SCSlotContainer* slot_container = ItemManager::Instance()->GetContainer(SI_INVENTORY); if (slot_container != NULL) { float full_percent = 100.0f - (static_cast(slot_container->GetEmptySlotNum()) / static_cast(slot_container->GetMaxSlotNum()) * 100.0f); if ((inventory_full_percent() > 0.0f) && (inventory_full_percent() <= full_percent)) { return true; } if ((heal_item_num() > 0) && (heal_item_num() > ItemManager::Instance()->GetItemCount(SI_INVENTORY, eITEMTYPE_WASTE, eITEMWASTE_HPPOTION))) { return true; } if ((feed_item_num() > 0) && (feed_item_num() > ItemManager::Instance()->GetItemCount(SI_INVENTORY, eITEMTYPE_PET_FEED, eITEMWASTE_PET_FEED))) { return true; } } return false; } //------------------------------------------------------------------------------ void AutobotCondition_Recall::Save(FILE* fp) { fwrite(&inventory_full_percent_, sizeof(float), 1, fp); fwrite(&warning_dura_, sizeof(DURATYPE), 1, fp); fwrite(&heal_item_num_, sizeof(NUMTYPE), 1, fp); fwrite(&feed_item_num_, sizeof(NUMTYPE), 1, fp); fwrite(&is_return_field_, sizeof(is_return_field_), 1, fp); } //------------------------------------------------------------------------------ void AutobotCondition_Recall::Load(FILE* fp, int file_version) { fread(&inventory_full_percent_, sizeof(float), 1, fp); fread(&warning_dura_, sizeof(DURATYPE), 1, fp); fread(&heal_item_num_, sizeof(NUMTYPE), 1, fp); fread(&feed_item_num_, sizeof(NUMTYPE), 1, fp); if (AutobotCondition::kAutobotFileVersion >= 110) { fread(&is_return_field_, sizeof(is_return_field_), 1, fp); } } //------------------------------------------------------------------------------ void AutobotCondition_Recall::CheckValid(SLOTCODE item_code) { if (AutomaticInfoParser::Instance()->CheckItemCodeInAutomaticInfo(eAUTO_RETURNSCROLL_INVEN, item_code) == false) { inventory_full_percent_ = 0.0f; } if (AutomaticInfoParser::Instance()->CheckItemCodeInAutomaticInfo(eAUTO_RETURNSCROLL_POTION, item_code) == false) { heal_item_num_ = 0; } if (AutomaticInfoParser::Instance()->CheckItemCodeInAutomaticInfo(eAUTO_RETURNSCROLL_PET_FEED, item_code) == false) { feed_item_num_ = 0; } if (AutomaticInfoParser::Instance()->CheckItemCodeInAutomaticInfo(eAUTO_RETURNSCROLL_DURATION, item_code) == false) { warning_dura_ = 0; } if (AutomaticInfoParser::Instance()->CheckItemCodeInAutomaticInfo(eAUTO_RETURNSCROLL_RETURNFIELD, item_code) == false) { //! AutobotCondition::kAutobotFileVersion >= 110 //! 추가된변수 기본이 돌아가는것임 is_return_field_ = true; } } //------------------------------------------------------------------------------ void AutobotCondition_Recall::SaveToBuffer(ArchiveOfStream& ar) { BYTE inventory_full_percent = static_cast(inventory_full_percent_); DURATYPE warning_dura = warning_dura_; NUMTYPE heal_item_num = heal_item_num_; NUMTYPE feed_item_num = feed_item_num_; ar << inventory_full_percent; ar << warning_dura; ar << heal_item_num; ar << feed_item_num; ar << is_return_field(); } //------------------------------------------------------------------------------ void AutobotCondition_Recall::LoadFromBuffer(ArchiveOfStream& ar, int file_version) { BYTE inventory_full_percent = 0; DURATYPE warning_dura = 0; NUMTYPE heal_item_num = 0; NUMTYPE feed_item_num = 0; ar >> inventory_full_percent; ar >> warning_dura; ar >> heal_item_num; ar >> feed_item_num; //! AutobotCondition::kAutobotFileVersion >= 110 if (AutobotCondition::kAutobotFileVersion >= 110) { ar >> is_return_field_; } inventory_full_percent_ = static_cast(inventory_full_percent); warning_dura_ = warning_dura; heal_item_num_ = heal_item_num; feed_item_num_ = feed_item_num; } //------------------------------------------------------------------------------ bool AutobotCondition_Recall::SendCheck(AutobotCondition_Recall& dummy) { if ((inventory_full_percent() != dummy.inventory_full_percent()) || (warning_dura() != dummy.warning_dura()) || (heal_item_num() != dummy.heal_item_num()) || (feed_item_num() != dummy.feed_item_num()) || (is_return_field() != dummy.is_return_field())) { return true; } return false; } void AutobotCondition_Recall::CopyData(AutobotCondition_Recall& sorce) { Clear(); set_inventory_full_percent(sorce.inventory_full_percent()); set_warning_dura(sorce.warning_dura()); set_heal_item_num(sorce.heal_item_num()); set_feed_item_num(sorce.feed_item_num()); if (AutobotCondition::kAutobotFileVersion >= 110) { set_return_field(sorce.is_return_field()); } } //------------------------------------------------------------------------------ //!AutobotCondition_Recovery //------------------------------------------------------------------------------ void AutobotCondition_Recovery::Clear() { hp_potion_percent_ = 0.0f; mp_potion_percent_ = 0.0f; feed_potion_percent_ = 0.0f; immediate_potion_percent_ = 0.0f; relax_hp_percent_ = 0.0f; relax_mp_percent_ = 0.0f; } //------------------------------------------------------------------------------ bool AutobotCondition_Recovery::IsRelax() { return ((g_pHero->GetHP_Percent() < relax_hp_percent_) || (g_pHero->GetMP_Percent() < relax_mp_percent_)); } //------------------------------------------------------------------------------ bool AutobotCondition_Recovery::check_hp_potion() { return (g_pHero->GetHP_Percent() < hp_potion_percent_); } //------------------------------------------------------------------------------ bool AutobotCondition_Recovery::check_mp_potion() { return (g_pHero->GetMP_Percent() < mp_potion_percent_); } //------------------------------------------------------------------------------ bool AutobotCondition_Recovery::check_immediate_potion() { return (g_pHero->GetHP_Percent() < immediate_potion_percent_); } //------------------------------------------------------------------------------ bool AutobotCondition_Recovery::check_feed_potion() { Pet* pet = static_cast(g_ObjectManager.GetObject(g_pHero->GetPetObjectKey())); if ((pet != NULL) && (pet->IsKindOfObject(PET_OBJECT) == TRUE)) { float percent = static_cast(pet->GetPet()->byFullness) / static_cast(C_PET_MAX_GAUGE) * 100.0f; return (percent < feed_potion_percent_); } return false; } //------------------------------------------------------------------------------ void AutobotCondition_Recovery::Save(FILE* fp) { fwrite(&hp_potion_percent_, sizeof(float), 1, fp); fwrite(&immediate_potion_percent_, sizeof(float), 1, fp); fwrite(&mp_potion_percent_, sizeof(float), 1, fp); fwrite(&feed_potion_percent_, sizeof(float), 1, fp); fwrite(&relax_hp_percent_, sizeof(float), 1, fp); fwrite(&relax_mp_percent_, sizeof(float), 1, fp); } //------------------------------------------------------------------------------ void AutobotCondition_Recovery::Load(FILE* fp, int file_version) { fread(&hp_potion_percent_, sizeof(float), 1, fp); fread(&immediate_potion_percent_, sizeof(float), 1, fp); fread(&mp_potion_percent_, sizeof(float), 1, fp); fread(&feed_potion_percent_, sizeof(float), 1, fp); fread(&relax_hp_percent_, sizeof(float), 1, fp); fread(&relax_mp_percent_, sizeof(float), 1, fp); } //------------------------------------------------------------------------------ void AutobotCondition_Recovery::CheckValid(SLOTCODE item_code) { if (AutomaticInfoParser::Instance()->CheckItemCodeInAutomaticInfo(eAUTO_CURE_HP, item_code) == false) { hp_potion_percent_ = 0.0f; } if (AutomaticInfoParser::Instance()->CheckItemCodeInAutomaticInfo(eAUTO_CURE_MPSP, item_code) == false) { mp_potion_percent_ = 0.0f; } if (AutomaticInfoParser::Instance()->CheckItemCodeInAutomaticInfo(eAUTO_CURE_INSTANT, item_code) == false) { feed_potion_percent_ = 0.0f; } if (AutomaticInfoParser::Instance()->CheckItemCodeInAutomaticInfo(eAUTO_CURE_PET_FEED, item_code) == false) { immediate_potion_percent_ = 0.0f; } if (AutomaticInfoParser::Instance()->CheckItemCodeInAutomaticInfo(eAUTO_CURE_SITDOWN_HP, item_code) == false) { relax_hp_percent_ = 0.0f; } if (AutomaticInfoParser::Instance()->CheckItemCodeInAutomaticInfo(eAUTO_CURE_SITDOWN_MP, item_code) == false) { relax_mp_percent_ = 0.0f; } } //------------------------------------------------------------------------------ void AutobotCondition_Recovery::SaveToBuffer(ArchiveOfStream& ar) { BYTE hp_potion_percent = static_cast(hp_potion_percent_); BYTE immediate_potion_percent = static_cast(immediate_potion_percent_); BYTE mp_potion_percent = static_cast(mp_potion_percent_); BYTE feed_potion_percent = static_cast(feed_potion_percent_); BYTE relax_hp_percent = static_cast(relax_hp_percent_); BYTE relax_mp_percent = static_cast(relax_mp_percent_); ar << hp_potion_percent; ar << immediate_potion_percent; ar << mp_potion_percent; ar << feed_potion_percent; ar << relax_hp_percent; ar << relax_mp_percent; } //------------------------------------------------------------------------------ void AutobotCondition_Recovery::LoadFromBuffer(ArchiveOfStream& ar, int file_version) { BYTE hp_potion_percent = 0; BYTE immediate_potion_percent = 0; BYTE mp_potion_percent = 0; BYTE feed_potion_percent = 0; BYTE relax_hp_percent = 0; BYTE relax_mp_percent = 0; ar >> hp_potion_percent; ar >> immediate_potion_percent; ar >> mp_potion_percent; ar >> feed_potion_percent; ar >> relax_hp_percent; ar >> relax_mp_percent; hp_potion_percent_ = static_cast(hp_potion_percent); immediate_potion_percent_ = static_cast(immediate_potion_percent); mp_potion_percent_ = static_cast(mp_potion_percent); feed_potion_percent_ = static_cast(feed_potion_percent); relax_hp_percent_ = static_cast(relax_hp_percent); relax_mp_percent_ = static_cast(relax_mp_percent); } //------------------------------------------------------------------------------ bool AutobotCondition_Recovery::SendCheck(AutobotCondition_Recovery& dummy) { if ((hp_potion_percent_ != dummy.hp_potion_percent()) || (immediate_potion_percent_ != dummy.immediate_potion_percent()) || (mp_potion_percent_ != dummy.mp_potion_percent()) || (feed_potion_percent_ != dummy.feed_potion_percent()) || (relax_hp_percent_ != dummy.relax_hp_percent()) || (relax_mp_percent_ != dummy.relax_mp_percent())) { return true; } return false; } void AutobotCondition_Recovery::CopyData(AutobotCondition_Recovery& sorce) { Clear(); hp_potion_percent_ = sorce.hp_potion_percent(); immediate_potion_percent_ = sorce.immediate_potion_percent(); mp_potion_percent_ = sorce.mp_potion_percent(); feed_potion_percent_ = sorce.feed_potion_percent(); relax_hp_percent_ = sorce.relax_hp_percent(); relax_mp_percent_ = sorce.relax_mp_percent(); } //------------------------------------------------------------------------------ //! AutobotCondition_Skill //------------------------------------------------------------------------------ AutobotCondition_Skill::AutobotCondition_Skill() { Clear(); } //------------------------------------------------------------------------------ void AutobotCondition_Skill::Clear() { attack_skill_vector_.clear(); interval_skill_vector_.clear(); } //------------------------------------------------------------------------------ int AutobotCondition_Skill::GetAttackCount() { int skill_count = 0; ConditionAttackSkillVector::iterator begin = attack_skill_vector().begin(); ConditionAttackSkillVector::iterator end = attack_skill_vector().end(); for (; begin != end; ++begin) { if (begin->slot_type == ST_SKILL) { ++skill_count; } } return skill_count; } //------------------------------------------------------------------------------ SLOTCODE AutobotCondition_Skill::GetAttackSkill() { ConditionAttackSkillVector::iterator begin = attack_skill_vector().begin(); ConditionAttackSkillVector::iterator end = attack_skill_vector().end(); for (; begin != end; ++begin) { Slot* slot = &(*begin); if (slot->slot_type == ST_SKILL) { if (slot->slot_code == eACTION_START_SKILL_CODE) { return slot->slot_code; } else if (g_pHero->CanUseSkill(slot->slot_code, FALSE) == TRUE) { return slot->slot_code; } } } return 0; } //------------------------------------------------------------------------------ AutobotCondition_Skill::Slot* AutobotCondition_Skill::GetIntervalSkill() { DWORD current_time = clock_function::GetTickCount(); ConditionIntervalSkillVector::iterator begin = interval_skill_vector().begin(); ConditionIntervalSkillVector::iterator end = interval_skill_vector().end(); for (; begin != end; ++begin) { Slot* slot = &(*begin); if (slot->IsValid() == false) { continue; } if (current_time > (slot->last_use_millisecond + slot->interval_millisecond)) { if (slot->slot_type == ST_ITEM) { SCItemSlot* item_slot = ItemManager::Instance()->FindFirstItemSlot(SI_INVENTORY, slot->slot_code); if (item_slot == NULL) { slot->Reset(); continue; } if (item_slot->GetNum() <= 0) { slot->Reset(); continue; } if (g_pHero->CanUseItem(item_slot->GetItemInfo(), FALSE) == FALSE) { continue; } return slot; } else if (slot->slot_type == ST_SKILL) { if (g_pHero->CanUseSkill(slot->slot_code, FALSE) == FALSE) { continue; } return slot; } } } return NULL; } //------------------------------------------------------------------------------ bool AutobotCondition_Skill::InsertAttackSkill(eSlotContainerIndex container_index, eSlotType slot_type, SLOTCODE slot_code) { Slot slot; slot.container_index = container_index; slot.slot_type = slot_type; slot.slot_code = slot_code; slot.interval_millisecond = 0; slot.last_use_millisecond = 0; return InsertAttackSkill(slot); } //------------------------------------------------------------------------------ bool AutobotCondition_Skill::InsertAttackSkill(Slot& slot) { attack_skill_vector().push_back(slot); return true; } //------------------------------------------------------------------------------ bool AutobotCondition_Skill::InsertIntervalSkill(eSlotContainerIndex container_index, eSlotType slot_type, SLOTCODE slot_code, DWORD interval_millisecond) { Slot slot; slot.container_index = container_index; slot.slot_type = slot_type; slot.slot_code = slot_code; slot.interval_millisecond = interval_millisecond; slot.last_use_millisecond = 0; return InsertIntervalSkill(slot); } //------------------------------------------------------------------------------ bool AutobotCondition_Skill::InsertIntervalSkill(Slot& slot) { interval_skill_vector().push_back(slot); return true; } //------------------------------------------------------------------------------ void AutobotCondition_Skill::Save(FILE* fp) { { int count = attack_skill_vector().size(); ConditionAttackSkillVector::iterator begin = attack_skill_vector().begin(); ConditionAttackSkillVector::iterator end = attack_skill_vector().end(); fwrite(&count, sizeof(int), 1, fp); for (; begin != end; ++begin) { Slot slot = *begin; fwrite(&slot, sizeof(slot), 1, fp); } } { int count = interval_skill_vector().size(); ConditionIntervalSkillVector::iterator begin = interval_skill_vector().begin(); ConditionIntervalSkillVector::iterator end = interval_skill_vector().end(); fwrite(&count, sizeof(int), 1, fp); for (; begin != end; ++begin) { Slot slot = *begin; fwrite(&slot, sizeof(slot), 1, fp); } } } //------------------------------------------------------------------------------ void AutobotCondition_Skill::Load(FILE* fp, int file_version) { { int count = 0; fread(&count, sizeof(int), 1, fp); Slot slot; for (int i = 0; i < count; ++i) { fread(&slot, sizeof(slot), 1, fp); InsertAttackSkill(slot); } } { int count = 0; fread(&count, sizeof(int), 1, fp); Slot slot; for (int i = 0; i < count; ++i) { fread(&slot, sizeof(slot), 1, fp); InsertIntervalSkill(slot); } } } //------------------------------------------------------------------------------ void AutobotCondition_Skill::CheckValid(SLOTCODE item_code) { // } //------------------------------------------------------------------------------ void AutobotCondition_Skill::SaveToBuffer(ArchiveOfStream& ar) { BYTE count = 0; BYTE container_index = 0; BYTE slot_type = 0; SLOTCODE slot_code = 0; DWORD interval_millisecond = 0; { count = static_cast(attack_skill_vector().size()); ar << count; ConditionAttackSkillVector::iterator begin = attack_skill_vector().begin(); ConditionAttackSkillVector::iterator end = attack_skill_vector().end(); for (; begin != end; ++begin) { container_index = static_cast(begin->container_index); slot_type = static_cast(begin->slot_type); slot_code = begin->slot_code; ar << container_index; ar << slot_type; ar << slot_code; } } { count = static_cast(interval_skill_vector().size()); ar << count; ConditionIntervalSkillVector::iterator begin = interval_skill_vector().begin(); ConditionIntervalSkillVector::iterator end = interval_skill_vector().end(); for (; begin != end; ++begin) { container_index = static_cast(begin->container_index); slot_type = static_cast(begin->slot_type); slot_code = begin->slot_code; interval_millisecond = begin->interval_millisecond; ar << container_index; ar << slot_type; ar << slot_code; ar << interval_millisecond; } } } //------------------------------------------------------------------------------ void AutobotCondition_Skill::LoadFromBuffer(ArchiveOfStream& ar, int file_version) { BYTE count = 0; BYTE container_index = 0; BYTE slot_type = 0; SLOTCODE slot_code = 0; DWORD interval_millisecond = 0; { ar >> count; for (int i = 0; i < static_cast(count); ++i) { ar >> container_index; ar >> slot_type; ar >> slot_code; if ((container_index > SI_TEMPINVENTORY) && (container_index < SI_MAX_TOTAL)) { InsertAttackSkill(static_cast(container_index), static_cast(slot_type), slot_code); } } } { ar >> count; for (int i = 0; i < static_cast(count); ++i) { ar >> container_index; ar >> slot_type; ar >> slot_code; ar >> interval_millisecond; if ((container_index > SI_TEMPINVENTORY) && (container_index < SI_MAX_TOTAL)) { InsertIntervalSkill(static_cast(container_index), static_cast(slot_type), slot_code, interval_millisecond); } } } } //------------------------------------------------------------------------------ bool AutobotCondition_Skill::SendCheck(AutobotCondition_Skill& dummy) { if (attack_skill_vector().size() != dummy.attack_skill_vector().size()) { return true; } else { ConditionAttackSkillVector::iterator begin = attack_skill_vector().begin(); ConditionAttackSkillVector::iterator end = attack_skill_vector().end(); ConditionAttackSkillVector::iterator dummy_begin = dummy.attack_skill_vector().begin(); ConditionAttackSkillVector::iterator dummy_end = dummy.attack_skill_vector().end(); for (; begin != end; ++begin, ++dummy_begin) { if ((begin->container_index != dummy_begin->container_index) || (begin->slot_type != dummy_begin->slot_type) || (begin->slot_code != dummy_begin->slot_code)) { return true; } } } if (interval_skill_vector().size() != dummy.interval_skill_vector().size()) { return true; } else { ConditionIntervalSkillVector::iterator begin = interval_skill_vector().begin(); ConditionIntervalSkillVector::iterator end = interval_skill_vector().end(); ConditionIntervalSkillVector::iterator dummy_begin = dummy.interval_skill_vector().begin(); ConditionIntervalSkillVector::iterator dummy_end = dummy.interval_skill_vector().end(); for (; begin != end; ++begin, ++dummy_begin) { if ((begin->container_index != dummy_begin->container_index) || (begin->slot_type != dummy_begin->slot_type) || (begin->slot_code != dummy_begin->slot_code)) { return true; } } } return false; } void AutobotCondition_Skill::CopyData(AutobotCondition_Skill& sorce) { Clear(); ConditionAttackSkillVector::iterator attack_begin = sorce.attack_skill_vector().begin(); ConditionAttackSkillVector::iterator attack_end = sorce.attack_skill_vector().end(); for (; attack_begin != attack_end; ++attack_begin) { InsertAttackSkill(*attack_begin); } ConditionIntervalSkillVector::iterator interval_begin = sorce.interval_skill_vector().begin(); ConditionIntervalSkillVector::iterator interval_end = sorce.interval_skill_vector().end(); for (; interval_begin != interval_end; ++interval_begin) { InsertIntervalSkill(*interval_begin); } } //------------------------------------------------------------------------------ //! AutobotCondition_Revival //------------------------------------------------------------------------------ void AutobotCondition_Revival::Clear() { revival_type_ = kRevival_Stay; } //------------------------------------------------------------------------------ void AutobotCondition_Revival::Save(FILE* fp) { fwrite(&revival_type_, sizeof(revival_type_), 1, fp); } //------------------------------------------------------------------------------ void AutobotCondition_Revival::Load(FILE* fp, int file_version) { fread(&revival_type_, sizeof(revival_type_), 1, fp); } //------------------------------------------------------------------------------ void AutobotCondition_Revival::CheckValid(SLOTCODE item_code) { if (AutomaticInfoParser::Instance()->CheckItemCodeInAutomaticInfo(eAUTO_REBIRTH_VILIAGE, item_code) == false) { if (revival_type_ == kRevival_Village) { revival_type_ = kRevival_Stay; } } if (AutomaticInfoParser::Instance()->CheckItemCodeInAutomaticInfo(eAUTO_REBIRTH_WAITING, item_code) == false) { revival_type_ = kRevival_Stay; //if (revival_type_ == kRevival_Stay) //{ // revival_type_ = kRevival_Max; //} } if (AutomaticInfoParser::Instance()->CheckItemCodeInAutomaticInfo(eAUTO_REBIRTH, item_code) == false) { if (revival_type_ == kRevival_Resurrection) { revival_type_ = kRevival_Stay; } } } //------------------------------------------------------------------------------ void AutobotCondition_Revival::SaveToBuffer(ArchiveOfStream& ar) { BYTE revival = static_cast(revival_type()); ar << revival; } //------------------------------------------------------------------------------ void AutobotCondition_Revival::LoadFromBuffer(ArchiveOfStream& ar, int file_version) { BYTE revival = 0; ar >> revival; set_revival_type(static_cast(revival)); } //------------------------------------------------------------------------------ bool AutobotCondition_Revival::SendCheck(AutobotCondition_Revival& dummy) { if (revival_type() != dummy.revival_type()) { return true; } return false; } void AutobotCondition_Revival::CopyData(AutobotCondition_Revival& sorce) { Clear(); set_revival_type(sorce.revival_type()); } //------------------------------------------------------------------------------ //!AutobotCondition_Shop //------------------------------------------------------------------------------ void AutobotCondition_Shop::Clear() { buyitem_map_.clear(); sellitem_set_.clear(); repair_ = false; } //------------------------------------------------------------------------------ bool AutobotCondition_Shop::IsSellItem(SCItemSlot* inventory_item_slot) { if ((inventory_item_slot == NULL) || (inventory_item_slot->GetItemInfo() == NULL)) { return false; } // 귀환아이템은 판매하지 않는다 if( inventory_item_slot->GetCode() == 7241 ) { return false; } AutobotCondition::ItemType item_type = ConvertPickupItemType(inventory_item_slot->GetItemInfo()); ConditionSellItemSet::iterator end = sellitem_set().end(); if ((sellitem_set().find(kItem_All) != end) || (sellitem_set().find(item_type) != end)) { if (CanTradeSell(inventory_item_slot, inventory_item_slot->GetItemInfo(), eITEM_TRADESELL_SELL) == true) { return true; } } return false; } //------------------------------------------------------------------------------ bool AutobotCondition_Shop::IsSellItem(AutobotCondition::ItemType item_type) { ConditionSellItemSet::iterator iter = sellitem_set().find(item_type); if (iter != sellitem_set().end()) { return true; } return false; } //------------------------------------------------------------------------------ bool AutobotCondition_Shop::IsBuyItem(SCItemSlot* shop_item_slot) { if ((shop_item_slot == NULL) || (shop_item_slot->GetItemInfo() == NULL)) { return false; } ConditionBuyItemMap::iterator iter = buyitem_map().find(shop_item_slot->GetItemInfo()->m_Code); if (iter != buyitem_map().end()) { return (iter->second > shop_item_slot->GetNum()); } return false; } //------------------------------------------------------------------------------ bool AutobotCondition_Shop::InsertSellItem(AutobotCondition::ItemType item_type) { sellitem_set().insert(item_type); return true; } //------------------------------------------------------------------------------ bool AutobotCondition_Shop::InsertBuyItem(SLOTCODE slot_code, NUMTYPE count) { buyitem_map().insert(std::make_pair(slot_code, count)); return true; } //------------------------------------------------------------------------------ void AutobotCondition_Shop::Save(FILE* fp) { { int count = sellitem_set().size(); ConditionSellItemSet::iterator begin = sellitem_set().begin(); ConditionSellItemSet::iterator end = sellitem_set().end(); fwrite(&count, sizeof(int), 1, fp); for (; begin != end; ++begin) { AutobotCondition::ItemType item_type = *begin; fwrite(&item_type, sizeof(item_type), 1, fp); } } { int count = buyitem_map().size(); ConditionBuyItemMap::iterator begin = buyitem_map().begin(); ConditionBuyItemMap::iterator end = buyitem_map().end(); fwrite(&count, sizeof(int), 1, fp); for (; begin != end; ++begin) { SLOTCODE slot_code = begin->first; NUMTYPE slot_num = begin->second; fwrite(&slot_code, sizeof(slot_code), 1, fp); fwrite(&slot_num, sizeof(slot_num), 1, fp); } } fwrite(&repair_, sizeof(repair_), 1, fp); } //------------------------------------------------------------------------------ void AutobotCondition_Shop::Load(FILE* fp, int file_version) { { int count = 0; fread(&count, sizeof(int), 1, fp); AutobotCondition::ItemType item_type = kItem_Max; for (int i = 0; i < count; ++i) { fread(&item_type, sizeof(item_type), 1, fp); InsertSellItem(item_type); } } { int count = 0; fread(&count, sizeof(int), 1, fp); SLOTCODE slot_code = 0; NUMTYPE slot_num = 0; for (int i = 0; i < count; ++i) { fread(&slot_code, sizeof(slot_code), 1, fp); fread(&slot_num, sizeof(slot_num), 1, fp); InsertBuyItem(slot_code, slot_num); } } fread(&repair_, sizeof(repair_), 1, fp); } //------------------------------------------------------------------------------ NUMTYPE AutobotCondition_Shop::GetBuyItemCount(SLOTCODE item_code) { ConditionBuyItemMap::iterator iter = buyitem_map().find(item_code); if (iter != buyitem_map().end()) { return iter->second; } return 0; } //------------------------------------------------------------------------------ void AutobotCondition_Shop::EraseBuyItemByWasteType(eWASTETYPE waste_type) { ConditionBuyItemMap::iterator begin = buyitem_map().begin(); ConditionBuyItemMap::iterator end = buyitem_map().end(); for (; begin != end; ++begin) { const BASE_ITEMINFO* item_info = ItemInfoParser::Instance()->GetItemInfo(begin->first); if ((item_info != NULL) && (item_info->m_byWasteType == waste_type)) { begin = buyitem_map().erase(begin); } } } //------------------------------------------------------------------------------ void AutobotCondition_Shop::CheckValid(SLOTCODE item_code) { // 팔기 for (int i = static_cast(eAUTO_SELL_ALL); i <= static_cast(eAUTO_SELL_AC); ++i) { eAUTO_HUNTING_TYPE hunting_type = static_cast(i); if (AutomaticInfoParser::Instance()->CheckItemCodeInAutomaticInfo(hunting_type, item_code) == false) { ItemType item_type = ConvertPickupItemType(hunting_type); sellitem_set().erase(item_type); } } // 사기 if (AutomaticInfoParser::Instance()->CheckItemCodeInAutomaticInfo(eAUTO_BUY_RETURNSCROLL, item_code) == false) { EraseBuyItemByWasteType(eITEMWASTE_RETURNSCROLL); } if (AutomaticInfoParser::Instance()->CheckItemCodeInAutomaticInfo(eAUTO_BUY_PET_FEED, item_code) == false) { EraseBuyItemByWasteType(eITEMWASTE_PET_FEED); } if ((AutomaticInfoParser::Instance()->CheckItemCodeInAutomaticInfo(eAUTO_BUY_POTION_LEVEL, item_code) == false) || (AutomaticInfoParser::Instance()->CheckItemCodeInAutomaticInfo(eAUTO_BUY_POTION_COUNT, item_code) == false)) { EraseBuyItemByWasteType(eITEMWASTE_HPPOTION); } if (AutomaticInfoParser::Instance()->CheckItemCodeInAutomaticInfo(eAUTO_BUY_DURATION, item_code) == false) { repair_ = false; } } //------------------------------------------------------------------------------ void AutobotCondition_Shop::SaveToBuffer(ArchiveOfStream& ar) { { BYTE count = static_cast(sellitem_set().size()); ar << count; ConditionSellItemSet::iterator begin = sellitem_set().begin(); ConditionSellItemSet::iterator end = sellitem_set().end(); for (; begin != end; ++begin) { BYTE item_type = static_cast(*begin); ar << item_type; } } { BYTE count = static_cast(buyitem_map().size()); ar << count; ConditionBuyItemMap::iterator begin = buyitem_map().begin(); ConditionBuyItemMap::iterator end = buyitem_map().end(); for (; begin != end; ++begin) { SLOTCODE slot_code = begin->first; NUMTYPE num_type = begin->second; ar << slot_code; ar << num_type; } } ar << repair_; } //------------------------------------------------------------------------------ void AutobotCondition_Shop::LoadFromBuffer(ArchiveOfStream& ar, int file_version) { { BYTE count = 0; ar >> count; BYTE item_type = 0; for (int i = 0; i < static_cast(count); ++i) { ar >> item_type; InsertSellItem(static_cast(item_type)); } } { BYTE count = 0; ar >> count; SLOTCODE slot_code = 0; NUMTYPE num_type = 0; for (int i = 0; i < static_cast(count); ++i) { ar >> slot_code; ar >> num_type; InsertBuyItem(slot_code, num_type); } } ar >> repair_; } //------------------------------------------------------------------------------ bool AutobotCondition_Shop::SendCheck(AutobotCondition_Shop& dummy) { if (sellitem_set().size() != dummy.sellitem_set().size()) { return true; } else { ConditionSellItemSet::iterator begin = sellitem_set().begin(); ConditionSellItemSet::iterator end = sellitem_set().end(); ConditionSellItemSet::iterator dummy_begin = dummy.sellitem_set().begin(); ConditionSellItemSet::iterator dummy_end = dummy.sellitem_set().end(); for (; begin != end; ++begin, ++dummy_begin) { if (*begin != *dummy_begin) { return true; } } } if (buyitem_map().size() != dummy.buyitem_map().size()) { return true; } else { ConditionBuyItemMap::iterator begin = buyitem_map().begin(); ConditionBuyItemMap::iterator end = buyitem_map().end(); ConditionBuyItemMap::iterator dummy_begin = dummy.buyitem_map().begin(); ConditionBuyItemMap::iterator dummy_end = dummy.buyitem_map().end(); for (; begin != end; ++begin, ++dummy_begin) { if ((begin->first != dummy_begin->first) || (begin->second != dummy_begin->second)) { return true; } } } if (IsRepair() != dummy.IsRepair()) { return true; } return false; } void AutobotCondition_Shop::CopyData(AutobotCondition_Shop& sorce) { Clear(); ConditionSellItemSet::iterator sell_begin = sorce.sellitem_set().begin(); ConditionSellItemSet::iterator sell_end = sorce.sellitem_set().end(); for (; sell_begin != sell_end; ++sell_begin) { InsertSellItem(*sell_begin); } ConditionBuyItemMap::iterator buy_begin = sorce.buyitem_map().begin(); ConditionBuyItemMap::iterator buy_end = sorce.buyitem_map().end(); for (; buy_begin != buy_end; ++buy_begin) { InsertBuyItem(buy_begin->first, buy_begin->second); } SetRepair(sorce.IsRepair()); } //------------------------------------------------------------------------------ //! AutobotCondition_Hunting //------------------------------------------------------------------------------ AutobotCondition_Hunting::AutobotCondition_Hunting() { Clear(); } //------------------------------------------------------------------------------ void AutobotCondition_Hunting::Clear() { hunting_type_ = kHuntingType_Max; target_range_ = 23.0f; party_follow_no_ = 0; area_range_ = 10; area_position_.x = 0.0f; area_position_.y = 0.0f; area_position_.z = 0.0f; avoid_monster_set_.clear(); } //------------------------------------------------------------------------------ bool AutobotCondition_Hunting::NextFollowPlayer(DWORD without_object_key) { uiPartyMan* party_manager = GET_DIALOG_MANAGER(uiPartyMan, UIMAN_PARTY); if (party_manager != NULL) { STLX_VECTOR::iterator begin = party_manager->GetPartyListRef().begin(); STLX_VECTOR::iterator end = party_manager->GetPartyListRef().end(); int follow_no = 0; for (; begin != end; ++begin) { if ((begin->Get().m_dwMemberKey != g_pHero->GetObjectKey()) && (begin->Get().m_dwMemberKey != without_object_key)) { set_party_follow_no(follow_no); return true; } ++follow_no; } } return false; } //------------------------------------------------------------------------------ DWORD AutobotCondition_Hunting::GetFollowPlayer() { if (hunting_type() != kHuntingType_Party) { return 0; } int index = party_follow_no(); uiPartyMan* party_manager = GET_DIALOG_MANAGER(uiPartyMan, UIMAN_PARTY); if ((party_manager == NULL) || (index < 0) || (index >= party_manager->GetPartyNum())) { return 0; } return party_manager->GetParty(index).Get().m_dwMemberKey; } //------------------------------------------------------------------------------ bool AutobotCondition_Hunting::GetFollowPlayerPosition(OUT WzVector& pos) { if (hunting_type() != kHuntingType_Party) { return 0; } int index = party_follow_no(); uiPartyMan* party_manager = GET_DIALOG_MANAGER(uiPartyMan, UIMAN_PARTY); if ((party_manager == NULL) || (index < 0) || (index >= party_manager->GetPartyNum())) { return 0; } PartyNaviInfo* party_navi_info = party_manager->GetPartyNaviInfo(); DWORD object_key = party_manager->GetParty(index).Get().m_dwMemberKey; NAVINODE NaviNode; if ((party_navi_info->GetNaviInfo(object_key, &NaviNode) == true) && (g_pMap->GetCurrentFieldID() == NaviNode.fieldCode)) { pos.x = NaviNode.posX; pos.y = NaviNode.posY; pos.z = NaviNode.posZ; return true; } return false; } //------------------------------------------------------------------------------ bool AutobotCondition_Hunting::IsAvoidMonster(DWORD object_key) { Object* object = g_ObjectManager.GetObject(object_key); if ((object == NULL) || (object->IsKindOfObject(MONSTER_OBJECT) == FALSE)) { return false; } eNPC_GRADE monster_grade = static_cast(static_cast(object)->GetMonsterInfo()->m_byGrade); return IsAvoidMonster(monster_grade); } //------------------------------------------------------------------------------ bool AutobotCondition_Hunting::IsAvoidMonster(eNPC_GRADE npc_grade) { if (avoid_monster_set().find(npc_grade) != avoid_monster_set().end()) { return true; } return false; } //------------------------------------------------------------------------------ bool AutobotCondition_Hunting::IsMonsterInValidArea(DWORD object_key) { if (hunting_type() != kHuntingType_Area) { return true; } Object* object = g_ObjectManager.GetObject(object_key); if ((object == NULL) || (object->IsKindOfObject(MONSTER_OBJECT) == FALSE)) { return false; } return IsValidArea(object->GetPosition()); } //------------------------------------------------------------------------------ bool AutobotCondition_Hunting::IsValidArea(WzVector& pos) { if (hunting_type() != kHuntingType_Area) { return true; } WzVector gab = area_position() - pos; gab.y = 0.0f; return (VectorLength(&gab) <= area_range()); } //------------------------------------------------------------------------------ void AutobotCondition_Hunting::Save(FILE* fp) { int count = avoid_monster_set().size(); ConditionAvoidMonsterSet::iterator begin = avoid_monster_set().begin(); ConditionAvoidMonsterSet::iterator end = avoid_monster_set().end(); fwrite(&count, sizeof(int), 1, fp); for (; begin != end; ++begin) { eNPC_GRADE npc_grade = (*begin); fwrite(&npc_grade, sizeof(npc_grade), 1, fp); } fwrite(&target_range_, sizeof(target_range_), 1, fp); fwrite(&hunting_type_, sizeof(hunting_type_), 1, fp); fwrite(&party_follow_no_, sizeof(party_follow_no_), 1, fp); fwrite(&area_position_, sizeof(area_position_), 1, fp); fwrite(&area_range_, sizeof(area_range_), 1, fp); } //------------------------------------------------------------------------------ void AutobotCondition_Hunting::Load(FILE* fp, int file_version) { int count = 0; fread(&count, sizeof(int), 1, fp); eNPC_GRADE npc_grade = eNPC_GRADE_MAX; for (int i = 0; i < count; ++i) { fread(&npc_grade, sizeof(npc_grade), 1, fp); avoid_monster_set().insert(npc_grade); } fread(&target_range_, sizeof(target_range_), 1, fp); fread(&hunting_type_, sizeof(hunting_type_), 1, fp); fread(&party_follow_no_, sizeof(party_follow_no_), 1, fp); fread(&area_position_, sizeof(area_position_), 1, fp); fread(&area_range_, sizeof(area_range_), 1, fp); } //------------------------------------------------------------------------------ void AutobotCondition_Hunting::CheckValid(SLOTCODE item_code) { if (AutomaticInfoParser::Instance()->CheckItemCodeInAutomaticInfo(eAUTO_RANGE_FIELD, item_code) == false) { if (hunting_type_ == kHuntingType_Free) { hunting_type_ = kHuntingType_Max; } } if (AutomaticInfoParser::Instance()->CheckItemCodeInAutomaticInfo(eAUTO_RANGE_PARTY, item_code) == false) { if (hunting_type_ == kHuntingType_Party) { hunting_type_ = kHuntingType_Max; } } if (AutomaticInfoParser::Instance()->CheckItemCodeInAutomaticInfo(eAUTO_RANGE_USER, item_code) == false) { if (hunting_type_ == kHuntingType_Area) { hunting_type_ = kHuntingType_Max; } } if (AutomaticInfoParser::Instance()->CheckItemCodeInAutomaticInfo(eAUTO_RANGE_USER, item_code) == false) { avoid_monster_set_.clear(); } } //------------------------------------------------------------------------------ void AutobotCondition_Hunting::SaveToBuffer(ArchiveOfStream& ar) { BYTE count = static_cast(avoid_monster_set().size()); ar << count; ConditionAvoidMonsterSet::iterator begin = avoid_monster_set().begin(); ConditionAvoidMonsterSet::iterator end = avoid_monster_set().end(); for (; begin != end; ++begin) { BYTE npc_grade = static_cast(*begin); ar << npc_grade; } BYTE hunting = static_cast(hunting_type()); BYTE area = static_cast(area_range()); ar << hunting; ar << area; } //------------------------------------------------------------------------------ void AutobotCondition_Hunting::LoadFromBuffer(ArchiveOfStream& ar, int file_version) { BYTE count = 0; ar >> count; BYTE npc_grade = 0; for (int i = 0; i < static_cast(count); ++i) { ar >> npc_grade; avoid_monster_set().insert(static_cast(npc_grade)); } BYTE hunting = 0; BYTE area = 0; ar >> hunting; ar >> area; set_hunting_type(static_cast(hunting)); set_area_range(static_cast(area)); } //------------------------------------------------------------------------------ bool AutobotCondition_Hunting::SendCheck(AutobotCondition_Hunting& dummy) { if (avoid_monster_set().size() != dummy.avoid_monster_set().size()) { return true; } else { ConditionAvoidMonsterSet::iterator begin = avoid_monster_set().begin(); ConditionAvoidMonsterSet::iterator end = avoid_monster_set().end(); ConditionAvoidMonsterSet::iterator dummy_begin = dummy.avoid_monster_set().begin(); ConditionAvoidMonsterSet::iterator dummy_end = dummy.avoid_monster_set().end(); for (; begin != end; ++begin, ++dummy_begin) { if (*begin != *dummy_begin) { return true; } } } if ((hunting_type() != dummy.hunting_type()) || (area_range() != dummy.area_range())) { return true; } return false; } void AutobotCondition_Hunting::CopyData(AutobotCondition_Hunting& sorce) { Clear(); ConditionAvoidMonsterSet::iterator begin = sorce.avoid_monster_set().begin(); ConditionAvoidMonsterSet::iterator end = sorce.avoid_monster_set().end(); for (; begin != end; ++begin) { avoid_monster_set().insert(*begin); } set_hunting_type(sorce.hunting_type()); set_area_range(sorce.area_range()); } //------------------------------------------------------------------------------ //! AutobotCondition_Community //------------------------------------------------------------------------------ void AutobotCondition_Community::Clear() { ZeroMemory(channel_level_, sizeof(channel_level_)); ZeroMemory(channel_name_, sizeof(channel_name_)); shouting_type_ = kShouting_Max; shouting_second_ = 0; ZeroMemory(shouting_message_, sizeof(shouting_second_)); party_type_ = kParty_Stay; save_chat_message_ = false; } //------------------------------------------------------------------------------ void AutobotCondition_Community::set_channel(TCHAR* level, TCHAR* name) { if (level == NULL || name == NULL) { return; } strncpy(channel_level_, level, MAX_ROOMTITLE_LENGTH); strncpy(channel_name_, name, MAX_ROOMTITLE_LENGTH); } //------------------------------------------------------------------------------ void AutobotCondition_Community::set_shouting(ShoutingType shout_type, int second, TCHAR* message) { if (message == NULL) { return; } shouting_type_ = shout_type; shouting_second_ = second; strncpy(shouting_message_, message, MAX_CHAT_LEN); } //------------------------------------------------------------------------------ void AutobotCondition_Community::Save(FILE* fp) { fwrite(&channel_level_, sizeof(channel_level_), 1, fp); fwrite(&channel_name_, sizeof(channel_name_), 1, fp); fwrite(&shouting_type_, sizeof(shouting_type_), 1, fp); fwrite(&shouting_second_, sizeof(shouting_second_), 1, fp); fwrite(&shouting_message_, sizeof(shouting_message_), 1, fp); fwrite(&party_type_, sizeof(party_type_), 1, fp); fwrite(&save_chat_message_, sizeof(save_chat_message_), 1, fp); } //------------------------------------------------------------------------------ void AutobotCondition_Community::Load(FILE* fp, int file_version) { fread(&channel_level_, sizeof(channel_level_), 1, fp); fread(&channel_name_, sizeof(channel_name_), 1, fp); fread(&shouting_type_, sizeof(shouting_type_), 1, fp); fread(&shouting_second_, sizeof(shouting_second_), 1, fp); fread(&shouting_message_, sizeof(shouting_message_), 1, fp); fread(&party_type_, sizeof(party_type_), 1, fp); fread(&save_chat_message_, sizeof(save_chat_message_), 1, fp); } //------------------------------------------------------------------------------ bool AutobotCondition_Community::IsShouting() { if ((shouting_type() == kShouting_Normal) || (shouting_type() == kShouting_World)) { if ((shouting_second() > 0) && (_tcslen(shouting_message()) > 0)) { return true; } } return false; } //------------------------------------------------------------------------------ bool AutobotCondition_Community::IsChannel() { if ((_tcslen(channel_level()) > 0) && (_tcslen(channel_name()) > 0)) { return true; } return false; } //------------------------------------------------------------------------------ void AutobotCondition_Community::CheckValid(SLOTCODE item_code) { if (AutomaticInfoParser::Instance()->CheckItemCodeInAutomaticInfo(eAUTO_COMMUNITY_PARTY_JOIN, item_code) == false) { if (party_type_ == kParty_Agree) { party_type_ = kParty_Stay; } } if (AutomaticInfoParser::Instance()->CheckItemCodeInAutomaticInfo(eAUTO_COMMUNITY_PARTY_BLOCK, item_code) == false) { if (party_type_ == kParty_Ignore) { party_type_ = kParty_Stay; } } if (AutomaticInfoParser::Instance()->CheckItemCodeInAutomaticInfo(eAUTO_COMMUNITY_SAVE_CHAT, item_code) == false) { save_chat_message_ = false; } if (AutomaticInfoParser::Instance()->CheckItemCodeInAutomaticInfo(eAUTO_COMMUNITY_SHOUT, item_code) == false) { shouting_type_ = kShouting_None; } if (AutomaticInfoParser::Instance()->CheckItemCodeInAutomaticInfo(eAUTO_COMMUNITY_CHANNEL, item_code) == false) { ZeroMemory(channel_level_, sizeof(channel_level_)); ZeroMemory(channel_name_, sizeof(channel_name_)); } } //------------------------------------------------------------------------------ void AutobotCondition_Community::SaveToBuffer(ArchiveOfStream& ar) { BYTE len = 0; len = (BYTE)strlen(channel_level()); ar << len; if (len > 0) { ar.Write(channel_level(), len); } len = (BYTE)strlen(channel_name()); ar << len; if (len > 0) { ar.Write(channel_name(), len); } ar << shouting_type(); ar << shouting_second(); len = strlen(shouting_message()); ar << len; if (len > 0) { ar.Write(shouting_message(), len); } ar << party_type(); ar << is_save_chat_message(); } //------------------------------------------------------------------------------ void AutobotCondition_Community::LoadFromBuffer(ArchiveOfStream& ar, int file_version) { BYTE len = 0; ar >> len; if (len > 0) { ar.Read(channel_level_, len); } ar >> len; if (len > 0) { ar.Read(channel_name_, len); } ar >> shouting_type_; ar >> shouting_second_; ar >> len; if (len > 0) { ar.Read(shouting_message_, len); } if (len + 1 < MAX_CHAT_LEN) { shouting_message_[len + 1] = 0; } ar >> party_type_; ar >> save_chat_message_; } //------------------------------------------------------------------------------ bool AutobotCondition_Community::SendCheck(AutobotCondition_Community& dummy) { if ((strcmp(channel_level(), dummy.channel_level()) != 0) || (strcmp(channel_name(), dummy.channel_name()) != 0) || (shouting_type() != dummy.shouting_type()) || (shouting_second() != dummy.shouting_second()) || (strcmp(shouting_message(), dummy.shouting_message()) != 0) || (party_type() != dummy.party_type()) || (is_save_chat_message() != dummy.is_save_chat_message())) { return true; } return false; } void AutobotCondition_Community::CopyData(AutobotCondition_Community& sorce) { Clear(); strncpy(channel_level(), sorce.channel_level(), MAX_ROOMTITLE_LENGTH); strncpy(channel_name(), sorce.channel_name(), MAX_ROOMTITLE_LENGTH); set_shouting(sorce.shouting_type(), sorce.shouting_second(), sorce.shouting_message()); set_party_type(sorce.party_type()); set_save_chat_message(sorce.is_save_chat_message()); }