mirrors/sapphire
1
Fork 0
mirror of https://github.com/SapphireServer/Sapphire.git synced 2025-04-29 15:47:46 +00:00
Code Activity

More boost removal

Browse source
This commit is contained in:
mordred 2018-10-24 13:14:14 +02:00
parent 0ad9a7e6c0
commit f5659f2c34
6 changed files with 440 additions and 1538 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/common/CMakeLists.txt
View file

@ -18,7 +18,7 @@ set( CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} )
add_library( common ${UTILS_PUBLIC_INCLUDE_FILES} ${UTILS_SOURCE_FILES} ) add_library( common ${UTILS_PUBLIC_INCLUDE_FILES} ${UTILS_SOURCE_FILES} )
set_target_properties( common PROPERTIES set_target_properties( common PROPERTIES
CXX_STANDARD 14 CXX_STANDARD 17
CXX_STANDARD_REQUIRED ON CXX_STANDARD_REQUIRED ON
CXX_EXTENSIONS ON CXX_EXTENSIONS ON
RUNTIME_OUTPUT_DIRECTORY_DEBUG "${CMAKE_CURRENT_SOURCE_DIR}/../../bin/" RUNTIME_OUTPUT_DIRECTORY_DEBUG "${CMAKE_CURRENT_SOURCE_DIR}/../../bin/"

726
src/common/Exd/ExdData.cpp
View file

@ -1,726 +0,0 @@
#include "ExdData.h"
#include <boost/make_shared.hpp>
#include <boost/variant.hpp>
/* TYPES !!
case DataType::boolean: 1
case DataType::int8: 2
case DataType::uint8: 3
case DataType::int16: 4
case DataType::uint16: 5
case DataType::int32: 6
case DataType::uint32: 7
case DataType::float32: 8
case DataType::uint64: 9
*/
Core::Data::ExdData::ExdData()
{
}
Core::Data::ExdData::~ExdData( void )
{
}
xiv::exd::Exd Core::Data::ExdData::setupDatAccess( const std::string& name, xiv::exd::Language lang )
{
auto& cat = m_exd_data->get_category( name );
return static_cast< xiv::exd::Exd >( cat.get_data_ln( lang ) );
};
bool Core::Data::ExdData::init( const std::string& path )
{
try
{
m_data = boost::make_shared< xiv::dat::GameData >( path );
m_exd_data = boost::make_shared< xiv::exd::ExdData >( *m_data );
m_questDat = setupDatAccess( "Quest", xiv::exd::Language::en );
m_openingDat = setupDatAccess( "Opening", xiv::exd::Language::none );
m_customTalkDat = setupDatAccess( "CustomTalk", xiv::exd::Language::en );
m_aetheryteDat = setupDatAccess( "Aetheryte", xiv::exd::Language::en );
m_levelDat = setupDatAccess( "Level", xiv::exd::Language::none );
m_placeNameDat = setupDatAccess( "PlaceName", xiv::exd::Language::en );
m_itemsDat = setupDatAccess( "Item", xiv::exd::Language::en );
m_classJobCatDat = setupDatAccess( "ClassJobCategory", xiv::exd::Language::en );
m_raceDat = setupDatAccess( "Race", xiv::exd::Language::en );
m_eventItemDat = setupDatAccess( "EventItem", xiv::exd::Language::en );
}
catch( std::runtime_error )
{
return false;
}
return true;
}
bool Core::Data::ExdData::loadZoneInfo()
{
auto territoryTypeData = setupDatAccess( "TerritoryType", xiv::exd::Language::none );
auto placeNameData = setupDatAccess( "PlaceName", xiv::exd::Language::en );
auto mapData = setupDatAccess( "Map", xiv::exd::Language::none );
auto weatherRate = setupDatAccess( "WeatherRate", xiv::exd::Language::none );
auto territoryTypeDataRows = territoryTypeData.get_rows();
for( auto row : territoryTypeDataRows )
{
auto& fields = row.second;
uint32_t id = row.first;
uint16_t place_id = getField< uint16_t >( fields, 5 );
uint16_t map_id = getField< uint16_t >( fields, 6 );
std::string zoneStr = getField< std::string >( fields, 0 );
if( zoneStr.empty() )
continue;
auto placeNameDataFields = placeNameData.get_row( place_id );
std::string zone_str = getField< std::string >( placeNameDataFields, 0 );
auto mapDataFields = mapData.get_row( map_id );
int16_t map_index = getField< int16_t >( mapDataFields, 12 );
bool is_two_bytes = getField< bool >( mapDataFields, 15 );
uint8_t weather_rate = getField< uint8_t >( fields, 12 ) > 75 ? 0 : getField< uint8_t >( fields, 12 );
auto weatherRateFields = weatherRate.get_row( weather_rate );
int32_t aetheryte_index = getField< int32_t >( fields, 23 );
uint8_t zoneType = getField< uint8_t >( fields, 9 );
ZoneInfo info{ 0 };
info.id = id;
info.zone_name = zoneStr;
info.zone_str = zone_str;
info.layout_id = id;
info.discovery_index = map_index;
info.is_two_byte = is_two_bytes;
info.map_id = map_id;
info.weather_rate = weather_rate; // TODO: deal with weather groups
info.aetheryte_index = aetheryte_index;
info.zone_type = zoneType;
uint8_t sumPc = 0;
for( size_t i = 0; i < 16; )
{
int32_t weatherId = getField< int32_t >( weatherRateFields, i );
if( weatherId == 0 )
break;
sumPc += getField< uint8_t >( weatherRateFields, i + 1 );
info.weather_rate_map[ sumPc ] = weatherId;
i += 2;
}
m_zoneInfoMap[ id ] = info;
}
return true;
}
bool Core::Data::ExdData::loadStatusEffectInfo()
{
auto StatusDat = setupDatAccess( "Status", xiv::exd::Language::en );
auto rows1 = StatusDat.get_rows();
for( auto row : rows1 )
{
auto& fields = row.second;
uint32_t id = row.first;
StatusEffectInfo info{ 0 };
info.id = id;
info.name = getField< std::string >( fields, 0 );
info.lock_movement = getField< bool >( fields, 7 ); // 7
info.lock_actions = getField< bool >( fields, 9 ); // 9
info.lock_control = getField< bool >( fields, 10 ); // 10
info.transfiguration = getField< bool >( fields, 11 ); // 11
info.can_dispel = getField< bool >( fields, 13 ); // 13
info.is_permanent = getField< bool >( fields, 15 ); // 15
info.inflicted_by_actor = getField< bool >( fields, 17 ); // 17
info.is_fc_buff = getField< bool >( fields, 21 ); // 21
info.invisibility = getField< bool >( fields, 22 ); // 22
m_statusEffectInfoMap[ id ] = info;
}
return true;
}
bool Core::Data::ExdData::loadAetheryteInfo()
{
auto AetheryteDat = setupDatAccess( "Aetheryte", xiv::exd::Language::en );
auto rows = AetheryteDat.get_rows();
for( auto row : rows )
{
auto& fields = row.second;
auto info = boost::make_shared< AetheryteInfo >();
info->id = row.first;
info->target_zone = getField< uint16_t >( fields, 10 );
info->isAetheryte = getField< bool >( fields, 15 );
uint16_t placename = getField< uint16_t >( fields, 8 );
auto placeNameInfo = getPlaceNameInfo( placename );
if( placeNameInfo )
{
info->placename = placeNameInfo->placename;
}
uint16_t placename_aethernet = getField< uint16_t >( fields, 9 );
auto placename_aethernetInfo = getPlaceNameInfo( placename_aethernet );
if( placename_aethernetInfo )
{
info->placename_aethernet = placename_aethernetInfo->placename;
}
info->levelId = getField< uint32_t >( fields, 11 );
info->map_coord_x = getField< int16_t >( fields, 20 );
info->map_coord_y = getField< int16_t >( fields, 21 );
m_aetheryteInfoMap.emplace( std::make_pair( info->id, info ) );
}
return true;
}
bool Core::Data::ExdData::loadClassJobInfo()
{
auto ClassJobDat = setupDatAccess( "ClassJob", xiv::exd::Language::en );
auto rows = ClassJobDat.get_rows();
for( auto row : rows )
{
auto& fields = row.second;
ClassJobInfo info{ 0 };
uint32_t id = row.first;
if( id == 0 )
continue;
std::string name = getField< std::string >( fields, 0 );
std::string short_name = getField< std::string >( fields, 1 );
int8_t exp_idx = getField< int8_t >( fields, 4 );
info.id = id;
info.name = name;
info.name_short = short_name;
info.exp_idx = exp_idx;
info.start_weapon_id = getField< int32_t >( fields, 28 );
info.mod_hp = getField< uint16_t >( fields, 9 );
info.mod_mpcpgp = getField< uint16_t >( fields, 10 );
info.mod_str = getField< uint16_t >( fields, 11 );
info.mod_vit = getField< uint16_t >( fields, 12 );
info.mod_dex = getField< uint16_t >( fields, 13 );
info.mod_int = getField< uint16_t >( fields, 14 );
info.mod_mnd = getField< uint16_t >( fields, 15 );
info.mod_pie = getField< uint16_t >( fields, 16 );
m_classJobInfoMap[ id ] = info;
}
return true;
}
bool Core::Data::ExdData::loadParamGrowInfo()
{
auto ParamGrowDat = setupDatAccess( "ParamGrow", xiv::exd::Language::none );
auto rows = ParamGrowDat.get_rows();
for( auto row : rows )
{
auto& fields = row.second;
ParamGrowthInfo info{ 0 };
uint32_t id = row.first;
info.level = id;
info.needed_exp = getField< int32_t >( fields, 0 );
info.mp_mod = getField< uint16_t >( fields, 3 ); // 3
info.mp_const = getField< int32_t >( fields, 4 ); // 4
info.base_secondary = getField< int32_t >( fields, 5 );// 5
info.quest_exp_mod = getField< uint8_t >( fields, 7 ); // 7
info.hp_mod = getField< uint16_t >( fields, 8 ); // 8
m_paramGrowthInfoMap[ id ] = info;
}
return true;
}
bool Core::Data::ExdData::loadTribeInfo()
{
auto tribeDat = setupDatAccess( "Tribe", xiv::exd::Language::en );
auto rows = tribeDat.get_rows();
for( auto row : rows )
{
auto& fields = row.second;
TribeInfo info{ 0 };
uint32_t id = row.first;
info.id = id;
info.name = getField< std::string >( fields, 0 );
info.mod_str = getField< int8_t >( fields, 4 );
info.mod_vit = getField< int8_t >( fields, 5 );
info.mod_dex = getField< int8_t >( fields, 6 );
info.mod_int = getField< int8_t >( fields, 7 );
info.mod_mnd = getField< int8_t >( fields, 8 );
info.mod_pie = getField< int8_t >( fields, 9 );
m_tribeInfoMap[ id ] = info;
}
return true;
}
bool Core::Data::ExdData::loadEventActionInfo()
{
auto EventActionDat = setupDatAccess( "EventAction", xiv::exd::Language::en );
auto rows = EventActionDat.get_rows();
for( auto row : rows )
{
auto& fields = row.second;
EventActionInfo info{ 0 };
uint32_t id = row.first;
if( id == 0 )
{
continue;
}
std::string name = getField< std::string >( fields, 0 );
uint8_t time = getField< uint8_t >( fields, 2 );
info.id = id;
info.name = name;
info.castTime = time * 1000;
m_EventActionInfoMap[ id ] = info;
}
return true;
}
bool Core::Data::ExdData::loadActionInfo()
{
auto ActionDat = setupDatAccess( "Action", xiv::exd::Language::en );
auto rows = ActionDat.get_rows();
for( auto row : rows )
{
auto& fields = row.second;
auto info = boost::make_shared< ActionInfo >();
uint32_t id = row.first;
if( id == 0 )
{
continue;
}
std::string name = getField< std::string >( fields, 0 ); // 0
uint8_t category = getField< uint8_t >( fields, 3 ); // 3
int8_t class_job = getField< int8_t >( fields, 10 ); // 10
uint8_t unlock_level = getField< uint8_t >( fields, 11 ); // 11
int8_t range = getField< int8_t >( fields, 14 ); // 13
bool can_target_self = getField< bool >( fields, 15 ); // 14
bool can_target_party = getField< bool >( fields, 16 ); // 15
bool can_target_friendly = getField< bool >( fields, 17 ); // 16
bool can_target_enemy = getField< bool >( fields, 18 ); // 17
bool is_ground_aoe = getField< bool >( fields, 21 ); // 20
// Column 23: Seems to be related to raising skills (Raise, Resurrection, Reanimate)
bool can_target_ko = getField< bool >( fields, 25 ); // 24
uint8_t aoe_type = getField< uint8_t >( fields, 27 ); // 26
uint8_t aoe_range = getField< uint8_t >( fields, 28 ); // 27
uint8_t aoe_width = getField< uint8_t >( fields, 29 ); // 28
uint8_t points_type = getField< uint8_t >( fields, 31 ); // 30
uint16_t points_cost = getField< uint16_t >( fields, 32 ); // 31
bool is_instant = getField< bool >( fields, 36 ); // 35
uint16_t cast_time = getField< uint16_t >( fields, 37 ); // 36
uint16_t recast_time = getField< uint16_t >( fields, 38 ); // 37
int8_t model = getField< int8_t >( fields, 40 ); // 39
uint8_t aspect = getField< uint8_t >( fields, 41 ); // 40
uint16_t toggle_status_id = getField< uint16_t >( fields, 43 ); // 42
bool affects_position = getField< bool >( fields, 48 ); // 47
bool no_effect_in_battle = getField< bool >( fields, 61 ); // 60
info->id = id;
info->name = name;
info->category = category;
info->class_job = class_job;
info->unlock_level = unlock_level;
info->range = range;
info->can_target_self = can_target_self;
info->can_target_party = can_target_party;
info->can_target_friendly = can_target_friendly;
info->can_target_enemy = can_target_enemy;
info->can_target_ko = can_target_ko;
info->is_ground_aoe = is_ground_aoe;
info->aoe_type = aoe_type;
info->aoe_range = aoe_range;
info->aoe_width = aoe_width;
info->points_type = points_type;
info->points_cost = points_cost;
info->is_instant = is_instant;
info->cast_time = cast_time * 100;
info->recast_time = recast_time * 100;
info->model = model;
info->aspect = aspect;
info->toggle_status_id = toggle_status_id;
info->affects_position = affects_position;
info->no_effect_in_battle = no_effect_in_battle;
// If action type is SingleTarget with an AoE radius set, or if action type isn't SingleTarget
info->is_aoe = ( info->aoe_type == 1 && info->aoe_width != 0 ) || ( info->aoe_type != 1 );
m_actionInfoMap.emplace( std::make_pair( info->id, info ) );
}
return true;
}
boost::shared_ptr< Core::Data::PlaceNameInfo >
Core::Data::ExdData::getPlaceNameInfo( uint32_t placeNameId )
{
try
{
auto row = m_placeNameDat.get_row( placeNameId );
auto info = boost::make_shared< PlaceNameInfo >();
info->id = placeNameId;
info->placename = getField< std::string >( row, 0 );
return info;
}
catch( ... )
{
return nullptr;
}
return nullptr;
}
boost::shared_ptr< Core::Data::ItemInfo >
Core::Data::ExdData::getItemInfo( uint32_t catalogId )
{
try
{
auto row = m_itemsDat.get_row( catalogId );
auto info = boost::make_shared< ItemInfo >();
info->id = catalogId;
info->name = getField< std::string >( row, 0 );
info->item_level = getField< uint16_t >( row, 11 );
info->required_level = getField< uint8_t >( row, 12 );
info->ui_category = getField< uint8_t >( row, 17 );
info->stack_size = getField< uint32_t >( row, 19 );
info->is_hqable = getField< bool >( row, 20 );
info->model_primary = getField< uint64_t >( row, 45 );
info->model_secondary = getField< uint64_t >( row, 46 );
info->physical_damage = getField< uint16_t >( row, 49 );
info->magical_damage = getField< uint16_t >( row, 50 );
info->delayMs = getField< uint16_t >( row, 51 );
info->is_unique = getField< int16_t >( row, 64 ) != 0 ? true : false;
info->is_untradeable = getField< uint8_t >( row, 65 ) != 0 ? true : false;
return info;
}
catch( ... )
{
return nullptr;
}
return nullptr;
}
boost::shared_ptr< Core::Data::AetheryteInfo >
Core::Data::ExdData::getAetheryteInfo( uint32_t aetheryteId )
{
try
{
return m_aetheryteInfoMap[ aetheryteId ];
}
catch( ... )
{
return nullptr;
}
return nullptr;
}
boost::shared_ptr< Core::Data::ActionInfo >
Core::Data::ExdData::getActionInfo( uint32_t actionId )
{
try
{
return m_actionInfoMap[ actionId ];
}
catch( ... )
{
return nullptr;
}
return nullptr;
}
boost::shared_ptr< Core::Data::CustomTalkInfo >
Core::Data::ExdData::getCustomTalkInfo( uint32_t customTalkId )
{
try
{
auto row = m_customTalkDat.get_row( customTalkId );
auto info = boost::make_shared< CustomTalkInfo >();
info->id = customTalkId;
info->name_intern = getField< std::string >( row, 2 );
return info;
}
catch( ... )
{
return nullptr;
}
return nullptr;
}
boost::shared_ptr< Core::Data::QuestInfo >
Core::Data::ExdData::getQuestInfo( uint32_t questId )
{
try
{
auto row = m_questDat.get_row( questId );
auto info = boost::make_shared< QuestInfo >();
info->id = questId;
info->name = getField< std::string >( row, 0 );
info->name_intern = getField< std::string >( row, 1 );
info->quest_level = getField< uint16_t >( row, 4 );
info->enpc_resident_start = getField< uint32_t >( row, 40 );
info->enpc_resident_end = getField< uint32_t >( row, 42 );
info->reward_exp_factor = getField< uint16_t >( row, 1439 );
info->reward_gil = getField< uint32_t >( row, 1440 );
info->reward_gc_seals = getField< uint16_t >( row, 1442 );
info->reward_item_type = getField< uint8_t >( row, 1449 );
for( uint32_t i = 0; i < 6; i++ )
{
uint32_t entry = getField< uint32_t >( row, i + 1450 );
if( entry > 0 )
info->reward_item.push_back( entry );
uint8_t entry1 = getField< uint8_t >( row, i + 1457 );
if( entry1 > 0 )
info->reward_item_count.push_back( entry1 );
uint8_t entry2 = getField< uint8_t >( row, i + 1464 );
if( entry2 > 0 )
info->reward_item_stain.push_back( entry2 );
}
for( uint32_t i = 0; i < 5; i++ )
{
uint32_t entry = getField< uint32_t >( row, i + 1471 );
if( entry > 0 )
info->reward_item_optional.push_back( entry );
uint8_t entry1 = getField< uint8_t >( row, i + 1476 );
if( entry1 > 0 )
info->reward_item_optional_count.push_back( entry1 );
uint8_t entry2 = getField< uint8_t >( row, i + 1486 );
if( entry2 > 0 )
info->reward_item_optional_stain.push_back( entry2 );
}
info->reward_emote = getField< uint8_t >( row, 1491 );
info->reward_action = getField< uint16_t >( row, 1492 );
info->reward_action_general1 = getField< uint8_t >( row, 1493 );
info->reward_action_general2 = getField< uint8_t >( row, 1494 );
info->reward_other = getField< uint8_t >( row, 1496 );
info->instanced_content_unlock = getField< uint32_t >( row, 1499 );
info->reward_tome_type = getField< uint8_t >( row, 1501 );
info->reward_tome_count = getField< uint8_t >( row, 1502 );
info->reward_reputation = getField< uint8_t >( row, 1503 );
for( uint32_t i = 0; i < 50; i++ )
{
std::string entry = getField< std::string >( row, i + 49 );
if( entry.size() > 0 )
{
info->script_entity.push_back( entry );
uint32_t entry1 = getField< uint32_t >( row, i + 99 );
info->script_value.push_back( entry1 );
}
}
return info;
}
catch( ... )
{
return nullptr;
}
return nullptr;
}
boost::shared_ptr< Core::Data::EventItemInfo >
Core::Data::ExdData::getEventItemInfo( uint32_t eventItemId )
{
try
{
auto row = m_eventItemDat.get_row( eventItemId );
auto info = boost::make_shared< EventItemInfo >();
info->id = eventItemId;
info->name = getField< std::string >( row, 0 );
info->eventId = getField< uint32_t >( row, 14 );
info->castTime = getField< uint8_t >( row, 15 ) * 1000;
return info;
}
catch( ... )
{
return nullptr;
}
return nullptr;
}
boost::shared_ptr< Core::Data::LevelInfo >
Core::Data::ExdData::getLevelInfo( uint32_t levelId )
{
try
{
auto row = m_levelDat.get_row( levelId );
auto info = boost::make_shared< LevelInfo >();
info->id = levelId;
info->x = getField< float >( row, 0 );
info->y = getField< float >( row, 1 );
info->z = getField< float >( row, 2 );
info->r = getField< float >( row, 3 );
info->actor_id = getField< uint32_t >( row, 6 );
info->zone_id = getField< uint16_t >( row, 9 );
return info;
}
catch( ... )
{
return nullptr;
}
return nullptr;
}
const std::vector< boost::shared_ptr< Core::Data::AetheryteInfo > >
Core::Data::ExdData::getAetheryteInfoForZone( uint16_t zoneId )
{
std::vector< boost::shared_ptr< AetheryteInfo > > aetheryteList;
for( auto& aetheryteInfo : m_aetheryteInfoMap )
{
if( aetheryteInfo.second->target_zone == zoneId )
{
aetheryteList.push_back( aetheryteInfo.second );
}
}
return aetheryteList;
}
boost::shared_ptr< Core::Data::OpeningInfo >
Core::Data::ExdData::getOpeningInfo( uint32_t openingId )
{
try
{
auto row = m_openingDat.get_row( openingId );
auto info = boost::make_shared< OpeningInfo >();
info->id = openingId;
info->name = getField< std::string >( row, 0 );
return info;
}
catch( ... )
{
return nullptr;
}
return nullptr;
}
boost::shared_ptr< Core::Data::RaceInfo >
Core::Data::ExdData::getRaceInfo( uint32_t raceId )
{
try
{
auto row = m_raceDat.get_row( raceId );
auto info = boost::make_shared< RaceInfo >();
info->id = raceId;
info->name = getField< std::string >( row, 0 );
info->male_body = getField< int32_t >( row, 2 );
info->male_hands = getField< int32_t >( row, 3 );
info->male_legs = getField< int32_t >( row, 4 );
info->male_feet = getField< int32_t >( row, 5 );
info->female_body = getField< int32_t >( row, 6 );
info->female_hands = getField< int32_t >( row, 7 );
info->female_legs = getField< int32_t >( row, 8 );
info->female_feet = getField< int32_t >( row, 9 );
return info;
}
catch( ... )
{
return nullptr;
}
return nullptr;
}

372
src/common/Exd/ExdData.h
View file

@ -1,372 +0,0 @@
#ifndef _EXDDATA_H
#define _EXDDATA_H
#include <GameData.h>
#include <File.h>
#include <ExdData.h>
#include <ExdCat.h>
#include <Exd.h>
/* TYPES !!
case DataType::boolean: 1
case DataType::int8: 2
case DataType::uint8: 3
case DataType::int16: 4
case DataType::uint16: 5
case DataType::int32: 6
case DataType::uint32: 7
case DataType::float32: 8
case DataType::uint64: 9
*/
namespace Core {
namespace Data {
struct ZoneInfo
{
uint16_t id;
std::string zone_str;
std::string zone_name;
uint32_t layout_id;
uint16_t map_id;
int16_t discovery_index;
bool is_two_byte;
uint16_t weather_rate;
std::map< uint8_t, int32_t > weather_rate_map;
int32_t aetheryte_index;
uint8_t zone_type;
};
struct ClassJobInfo
{
uint8_t id;
std::string name;
std::string name_short;
uint8_t exp_idx;
uint32_t start_weapon_id;
uint16_t mod_hp;
uint16_t mod_mpcpgp;
uint16_t mod_str;
uint16_t mod_vit;
uint16_t mod_dex;
uint16_t mod_int;
uint16_t mod_mnd;
uint16_t mod_pie;
};
struct QuestInfo
{
uint32_t id;
std::string name;
std::string name_intern;
uint16_t quest_level;
uint32_t enpc_resident_start;
uint32_t enpc_resident_end;
uint16_t reward_exp_factor;
uint32_t reward_gil;
uint16_t reward_gc_seals;
uint8_t reward_item_type;
std::vector< uint32_t > reward_item;
std::vector< uint8_t > reward_item_count;
std::vector< uint8_t > reward_item_stain;
std::vector< uint32_t > reward_item_optional;
std::vector< uint8_t > reward_item_optional_count;
std::vector< uint8_t > reward_item_optional_stain;
uint8_t reward_emote;
uint16_t reward_action;
uint8_t reward_action_general1;
uint8_t reward_action_general2;
uint8_t reward_other;
uint32_t instanced_content_unlock;
uint8_t reward_tome_type;
uint8_t reward_tome_count;
uint8_t reward_reputation;
std::vector< std::string > script_entity;
std::vector< uint32_t > script_value;
};
struct EventActionInfo
{
uint32_t id;
std::string name;
uint32_t castTime;
};
struct OpeningInfo
{
uint32_t id;
std::string name;
};
struct ParamGrowthInfo
{
uint32_t level;
uint32_t needed_exp;
int16_t hp_mod;
int32_t mp_const;
int16_t mp_mod;
int32_t base_secondary;
uint16_t quest_exp_mod;
};
struct CustomTalkInfo
{
uint32_t id;
std::string name_intern;
};
struct PlaceNameInfo
{
uint32_t id;
std::string placename;
};
struct AetheryteInfo
{
uint32_t id;
std::string placename;
std::string placename_aethernet;
int32_t target_zone;
int32_t levelId;
bool isAetheryte;
int16_t map_coord_x;
int16_t map_coord_y;
};
struct RaceInfo
{
uint32_t id;
std::string name;
uint32_t male_body;
uint32_t male_hands;
uint32_t male_legs;
uint32_t male_feet;
uint32_t female_body;
uint32_t female_hands;
uint32_t female_legs;
uint32_t female_feet;
int8_t mod_str;
int8_t mod_dex;
int8_t mod_vit;
int8_t mod_int;
int8_t mod_mnd;
int8_t mod_pie;
};
struct TribeInfo
{
uint32_t id;
std::string name;
int8_t mod_str;
int8_t mod_dex;
int8_t mod_vit;
int8_t mod_int;
int8_t mod_mnd;
int8_t mod_pie;
};
struct LevelInfo
{
uint32_t id;
float x;
float y;
float z;
float r;
uint32_t actor_id;
uint32_t zone_id;
};
struct ClassJobCategoryInfo
{
uint32_t id;
// should they add new jobs, this needs to be changed
bool can_equip[0x33];
};
struct ItemInfo
{
uint32_t id;
std::string name; //0
uint16_t item_level; //11
uint8_t required_level; //12
uint16_t unknown_category; //15
uint16_t ui_category; //17
uint32_t stack_size; //19
bool is_hqable; //20
uint64_t model_primary; //28
uint64_t model_secondary; //29
uint16_t physical_damage; //49
uint16_t magical_damage; //50
uint16_t delayMs; //51
uint32_t class_job_requirement; //58
bool is_unique; //72
bool is_untradeable; //73
uint32_t class_job_index; //86
};
struct ActionInfo
{
uint32_t id;
std::string name; // 0
uint16_t category; // 3
int8_t class_job; // 10
uint8_t unlock_level; // 11
int8_t range; // 13
bool can_target_self; // 14
bool can_target_party; // 15
bool can_target_friendly; // 16
bool can_target_enemy; // 17
bool is_ground_aoe; // 20
bool can_target_ko; // 24
uint8_t aoe_type; // 26
uint8_t aoe_range; // 27
uint8_t aoe_width; // 28
uint8_t points_type; // 30
uint16_t points_cost; // 31
bool is_instant; // 35
uint32_t cast_time; // 36
uint32_t recast_time; // 37
int8_t model; // 39
uint8_t aspect; // 40
uint16_t toggle_status_id; // 42
bool affects_position; // 47
bool no_effect_in_battle; // 60
bool is_aoe; // Internal only
};
struct EventItemInfo
{
uint32_t id;
std::string name; //0
uint32_t eventId;
uint32_t castTime;
};
struct StatusEffectInfo
{
uint32_t id;
std::string name; // 0
bool lock_movement; // 7
bool lock_actions; // 9
bool lock_control; // 10
bool transfiguration; // 11
bool can_dispel; // 13
bool is_permanent; // 15
bool inflicted_by_actor; // 17
bool is_fc_buff; // 21
bool invisibility; // 22
};
class ExdData
{
public:
ExdData();
~ExdData( void );
bool init( const std::string& path );
xiv::exd::Exd setupDatAccess( const std::string& name, xiv::exd::Language lang );
template< class T >
T getField( std::vector< xiv::exd::Field >& fields, uint32_t index )
{
return *boost::get< T >( &fields.at( index ) );
}
boost::shared_ptr< xiv::dat::GameData > m_data;
boost::shared_ptr< xiv::exd::ExdData > m_exd_data;
xiv::exd::Exd m_questDat;
xiv::exd::Exd m_openingDat;
xiv::exd::Exd m_customTalkDat;
xiv::exd::Exd m_aetheryteDat;
xiv::exd::Exd m_levelDat;
xiv::exd::Exd m_placeNameDat;
xiv::exd::Exd m_itemsDat;
xiv::exd::Exd m_classJobCatDat;
xiv::exd::Exd m_raceDat;
xiv::exd::Exd m_eventItemDat;
std::map< uint32_t, ZoneInfo > m_zoneInfoMap;
std::map< uint8_t, ClassJobInfo > m_classJobInfoMap;
std::map< uint32_t, ParamGrowthInfo > m_paramGrowthInfoMap;
std::map< uint16_t, EventActionInfo > m_EventActionInfoMap;
std::map< uint16_t, boost::shared_ptr< ActionInfo > > m_actionInfoMap;
std::map< uint16_t, StatusEffectInfo > m_statusEffectInfoMap;
std::map< uint32_t, boost::shared_ptr< AetheryteInfo > > m_aetheryteInfoMap;
std::map< uint32_t, TribeInfo > m_tribeInfoMap;
bool loadZoneInfo();
bool loadClassJobInfo();
bool loadParamGrowInfo();
bool loadEventActionInfo();
bool loadActionInfo();
bool loadStatusEffectInfo();
bool loadAetheryteInfo();
bool loadTribeInfo();
boost::shared_ptr< QuestInfo > getQuestInfo( uint32_t questId );
boost::shared_ptr< OpeningInfo > getOpeningInfo( uint32_t openingId );
boost::shared_ptr< CustomTalkInfo > getCustomTalkInfo( uint32_t customTalkId );
boost::shared_ptr< AetheryteInfo > getAetheryteInfo( uint32_t aetheryteId );
boost::shared_ptr< ActionInfo > getActionInfo( uint32_t actionId );
boost::shared_ptr< PlaceNameInfo > getPlaceNameInfo( uint32_t placeNameId );
boost::shared_ptr< ItemInfo > getItemInfo( uint32_t catalogId );
boost::shared_ptr< RaceInfo > getRaceInfo( uint32_t raceId );
boost::shared_ptr< EventItemInfo > getEventItemInfo( uint32_t eventItemId );
boost::shared_ptr< LevelInfo > getLevelInfo( uint32_t levelId );
const std::vector< boost::shared_ptr< AetheryteInfo > > getAetheryteInfoForZone( uint16_t zoneId );
};
}
}
#endif

8
src/common/Exd/ExdDataGenerated.cpp
View file

@ -1,7 +1,7 @@
#include "ExdDataGenerated.h" #include "ExdDataGenerated.h"
#include <boost/make_shared.hpp> #include <memory>
#include <boost/variant.hpp> #include <variant>
@ -5284,8 +5284,8 @@ bool Core::Data::ExdDataGenerated::init( const std::string& path )
{ {
try try
{ {
m_data = boost::make_shared< xiv::dat::GameData >( path ); m_data = std::make_shared< xiv::dat::GameData >( path );
m_exd_data = boost::make_shared< xiv::exd::ExdData >( *m_data ); m_exd_data = std::make_shared< xiv::exd::ExdData >( *m_data );
m_AchievementDat = setupDatAccess( "Achievement", xiv::exd::Language::en ); m_AchievementDat = setupDatAccess( "Achievement", xiv::exd::Language::en );
m_AchievementCategoryDat = setupDatAccess( "AchievementCategory", xiv::exd::Language::en ); m_AchievementCategoryDat = setupDatAccess( "AchievementCategory", xiv::exd::Language::en );

868
src/common/Exd/ExdDataGenerated.h
View file

@ -11,7 +11,7 @@
#include <ExdCat.h> #include <ExdCat.h>
#include <Exd.h> #include <Exd.h>
#include <set> #include <set>
#include <boost/make_shared.hpp> #include <variant>
namespace Core { namespace Core {
namespace Data { namespace Data {
@ -4808,13 +4808,13 @@ struct ZoneSharedGroup
template< class T > template< class T >
T getField( std::vector< xiv::exd::Field >& fields, uint32_t index ) T getField( std::vector< xiv::exd::Field >& fields, uint32_t index )
{ {
return *boost::get< T >( &fields.at( index ) ); return std::get< T >( fields.at( index ) );
} }
void loadIdList( xiv::exd::Exd& data, std::set< uint32_t >& outIdList ); void loadIdList( xiv::exd::Exd& data, std::set< uint32_t >& outIdList );
boost::shared_ptr< xiv::dat::GameData > m_data; std::shared_ptr< xiv::dat::GameData > m_data;
boost::shared_ptr< xiv::exd::ExdData > m_exd_data; std::shared_ptr< xiv::exd::ExdData > m_exd_data;
xiv::exd::Exd m_AchievementDat; xiv::exd::Exd m_AchievementDat;
xiv::exd::Exd m_AchievementCategoryDat; xiv::exd::Exd m_AchievementCategoryDat;
@ -5246,441 +5246,441 @@ struct ZoneSharedGroup
xiv::exd::Exd m_ZoneSharedGroupDat; xiv::exd::Exd m_ZoneSharedGroupDat;
using AchievementPtr = boost::shared_ptr< Achievement >; using AchievementPtr = std::shared_ptr< Achievement >;
using AchievementCategoryPtr = boost::shared_ptr< AchievementCategory >; using AchievementCategoryPtr = std::shared_ptr< AchievementCategory >;
using AchievementKindPtr = boost::shared_ptr< AchievementKind >; using AchievementKindPtr = std::shared_ptr< AchievementKind >;
using ActionPtr = boost::shared_ptr< Action >; using ActionPtr = std::shared_ptr< Action >;
using ActionCastTimelinePtr = boost::shared_ptr< ActionCastTimeline >; using ActionCastTimelinePtr = std::shared_ptr< ActionCastTimeline >;
using ActionCastVFXPtr = boost::shared_ptr< ActionCastVFX >; using ActionCastVFXPtr = std::shared_ptr< ActionCastVFX >;
using ActionCategoryPtr = boost::shared_ptr< ActionCategory >; using ActionCategoryPtr = std::shared_ptr< ActionCategory >;
using ActionComboRoutePtr = boost::shared_ptr< ActionComboRoute >; using ActionComboRoutePtr = std::shared_ptr< ActionComboRoute >;
using ActionIndirectionPtr = boost::shared_ptr< ActionIndirection >; using ActionIndirectionPtr = std::shared_ptr< ActionIndirection >;
using ActionParamPtr = boost::shared_ptr< ActionParam >; using ActionParamPtr = std::shared_ptr< ActionParam >;
using ActionProcStatusPtr = boost::shared_ptr< ActionProcStatus >; using ActionProcStatusPtr = std::shared_ptr< ActionProcStatus >;
using ActionTimelinePtr = boost::shared_ptr< ActionTimeline >; using ActionTimelinePtr = std::shared_ptr< ActionTimeline >;
using ActionTimelineMovePtr = boost::shared_ptr< ActionTimelineMove >; using ActionTimelineMovePtr = std::shared_ptr< ActionTimelineMove >;
using ActionTimelineReplacePtr = boost::shared_ptr< ActionTimelineReplace >; using ActionTimelineReplacePtr = std::shared_ptr< ActionTimelineReplace >;
using ActionTransientPtr = boost::shared_ptr< ActionTransient >; using ActionTransientPtr = std::shared_ptr< ActionTransient >;
using ActivityFeedButtonsPtr = boost::shared_ptr< ActivityFeedButtons >; using ActivityFeedButtonsPtr = std::shared_ptr< ActivityFeedButtons >;
using ActivityFeedCaptionsPtr = boost::shared_ptr< ActivityFeedCaptions >; using ActivityFeedCaptionsPtr = std::shared_ptr< ActivityFeedCaptions >;
using ActivityFeedGroupCaptionsPtr = boost::shared_ptr< ActivityFeedGroupCaptions >; using ActivityFeedGroupCaptionsPtr = std::shared_ptr< ActivityFeedGroupCaptions >;
using ActivityFeedImagesPtr = boost::shared_ptr< ActivityFeedImages >; using ActivityFeedImagesPtr = std::shared_ptr< ActivityFeedImages >;
using AddonPtr = boost::shared_ptr< Addon >; using AddonPtr = std::shared_ptr< Addon >;
using AddonHudPtr = boost::shared_ptr< AddonHud >; using AddonHudPtr = std::shared_ptr< AddonHud >;
using AdventurePtr = boost::shared_ptr< Adventure >; using AdventurePtr = std::shared_ptr< Adventure >;
using AdventureExPhasePtr = boost::shared_ptr< AdventureExPhase >; using AdventureExPhasePtr = std::shared_ptr< AdventureExPhase >;
using AetherCurrentPtr = boost::shared_ptr< AetherCurrent >; using AetherCurrentPtr = std::shared_ptr< AetherCurrent >;
using AetherCurrentCompFlgSetPtr = boost::shared_ptr< AetherCurrentCompFlgSet >; using AetherCurrentCompFlgSetPtr = std::shared_ptr< AetherCurrentCompFlgSet >;
using AetherialWheelPtr = boost::shared_ptr< AetherialWheel >; using AetherialWheelPtr = std::shared_ptr< AetherialWheel >;
using AetherytePtr = boost::shared_ptr< Aetheryte >; using AetherytePtr = std::shared_ptr< Aetheryte >;
using AetheryteSystemDefinePtr = boost::shared_ptr< AetheryteSystemDefine >; using AetheryteSystemDefinePtr = std::shared_ptr< AetheryteSystemDefine >;
using AirshipExplorationLevelPtr = boost::shared_ptr< AirshipExplorationLevel >; using AirshipExplorationLevelPtr = std::shared_ptr< AirshipExplorationLevel >;
using AirshipExplorationLogPtr = boost::shared_ptr< AirshipExplorationLog >; using AirshipExplorationLogPtr = std::shared_ptr< AirshipExplorationLog >;
using AirshipExplorationParamTypePtr = boost::shared_ptr< AirshipExplorationParamType >; using AirshipExplorationParamTypePtr = std::shared_ptr< AirshipExplorationParamType >;
using AirshipExplorationPartPtr = boost::shared_ptr< AirshipExplorationPart >; using AirshipExplorationPartPtr = std::shared_ptr< AirshipExplorationPart >;
using AirshipExplorationPointPtr = boost::shared_ptr< AirshipExplorationPoint >; using AirshipExplorationPointPtr = std::shared_ptr< AirshipExplorationPoint >;
using AnimaWeapon5Ptr = boost::shared_ptr< AnimaWeapon5 >; using AnimaWeapon5Ptr = std::shared_ptr< AnimaWeapon5 >;
using AnimaWeapon5ParamPtr = boost::shared_ptr< AnimaWeapon5Param >; using AnimaWeapon5ParamPtr = std::shared_ptr< AnimaWeapon5Param >;
using AnimaWeapon5PatternGroupPtr = boost::shared_ptr< AnimaWeapon5PatternGroup >; using AnimaWeapon5PatternGroupPtr = std::shared_ptr< AnimaWeapon5PatternGroup >;
using AnimaWeapon5SpiritTalkPtr = boost::shared_ptr< AnimaWeapon5SpiritTalk >; using AnimaWeapon5SpiritTalkPtr = std::shared_ptr< AnimaWeapon5SpiritTalk >;
using AnimaWeapon5SpiritTalkParamPtr = boost::shared_ptr< AnimaWeapon5SpiritTalkParam >; using AnimaWeapon5SpiritTalkParamPtr = std::shared_ptr< AnimaWeapon5SpiritTalkParam >;
using AnimaWeapon5TradeItemPtr = boost::shared_ptr< AnimaWeapon5TradeItem >; using AnimaWeapon5TradeItemPtr = std::shared_ptr< AnimaWeapon5TradeItem >;
using AnimaWeaponFUITalkPtr = boost::shared_ptr< AnimaWeaponFUITalk >; using AnimaWeaponFUITalkPtr = std::shared_ptr< AnimaWeaponFUITalk >;
using AnimaWeaponFUITalkParamPtr = boost::shared_ptr< AnimaWeaponFUITalkParam >; using AnimaWeaponFUITalkParamPtr = std::shared_ptr< AnimaWeaponFUITalkParam >;
using AnimaWeaponIconPtr = boost::shared_ptr< AnimaWeaponIcon >; using AnimaWeaponIconPtr = std::shared_ptr< AnimaWeaponIcon >;
using AnimaWeaponItemPtr = boost::shared_ptr< AnimaWeaponItem >; using AnimaWeaponItemPtr = std::shared_ptr< AnimaWeaponItem >;
using AquariumFishPtr = boost::shared_ptr< AquariumFish >; using AquariumFishPtr = std::shared_ptr< AquariumFish >;
using AquariumWaterPtr = boost::shared_ptr< AquariumWater >; using AquariumWaterPtr = std::shared_ptr< AquariumWater >;
using ArrayEventHandlerPtr = boost::shared_ptr< ArrayEventHandler >; using ArrayEventHandlerPtr = std::shared_ptr< ArrayEventHandler >;
using AttackTypePtr = boost::shared_ptr< AttackType >; using AttackTypePtr = std::shared_ptr< AttackType >;
using BacklightColorPtr = boost::shared_ptr< BacklightColor >; using BacklightColorPtr = std::shared_ptr< BacklightColor >;
using BalloonPtr = boost::shared_ptr< Balloon >; using BalloonPtr = std::shared_ptr< Balloon >;
using BaseParamPtr = boost::shared_ptr< BaseParam >; using BaseParamPtr = std::shared_ptr< BaseParam >;
using BattleLevePtr = boost::shared_ptr< BattleLeve >; using BattleLevePtr = std::shared_ptr< BattleLeve >;
using BeastRankBonusPtr = boost::shared_ptr< BeastRankBonus >; using BeastRankBonusPtr = std::shared_ptr< BeastRankBonus >;
using BeastReputationRankPtr = boost::shared_ptr< BeastReputationRank >; using BeastReputationRankPtr = std::shared_ptr< BeastReputationRank >;
using BeastTribePtr = boost::shared_ptr< BeastTribe >; using BeastTribePtr = std::shared_ptr< BeastTribe >;
using BehaviorPtr = boost::shared_ptr< Behavior >; using BehaviorPtr = std::shared_ptr< Behavior >;
using BGMPtr = boost::shared_ptr< BGM >; using BGMPtr = std::shared_ptr< BGM >;
using BGMFadePtr = boost::shared_ptr< BGMFade >; using BGMFadePtr = std::shared_ptr< BGMFade >;
using BGMSituationPtr = boost::shared_ptr< BGMSituation >; using BGMSituationPtr = std::shared_ptr< BGMSituation >;
using BGMSwitchPtr = boost::shared_ptr< BGMSwitch >; using BGMSwitchPtr = std::shared_ptr< BGMSwitch >;
using BGMSystemDefinePtr = boost::shared_ptr< BGMSystemDefine >; using BGMSystemDefinePtr = std::shared_ptr< BGMSystemDefine >;
using BNpcAnnounceIconPtr = boost::shared_ptr< BNpcAnnounceIcon >; using BNpcAnnounceIconPtr = std::shared_ptr< BNpcAnnounceIcon >;
using BNpcBasePtr = boost::shared_ptr< BNpcBase >; using BNpcBasePtr = std::shared_ptr< BNpcBase >;
using BNpcCustomizePtr = boost::shared_ptr< BNpcCustomize >; using BNpcCustomizePtr = std::shared_ptr< BNpcCustomize >;
using BNpcNamePtr = boost::shared_ptr< BNpcName >; using BNpcNamePtr = std::shared_ptr< BNpcName >;
using BNpcPartsPtr = boost::shared_ptr< BNpcParts >; using BNpcPartsPtr = std::shared_ptr< BNpcParts >;
using BuddyPtr = boost::shared_ptr< Buddy >; using BuddyPtr = std::shared_ptr< Buddy >;
using BuddyActionPtr = boost::shared_ptr< BuddyAction >; using BuddyActionPtr = std::shared_ptr< BuddyAction >;
using BuddyEquipPtr = boost::shared_ptr< BuddyEquip >; using BuddyEquipPtr = std::shared_ptr< BuddyEquip >;
using BuddyItemPtr = boost::shared_ptr< BuddyItem >; using BuddyItemPtr = std::shared_ptr< BuddyItem >;
using BuddyRankPtr = boost::shared_ptr< BuddyRank >; using BuddyRankPtr = std::shared_ptr< BuddyRank >;
using BuddySkillPtr = boost::shared_ptr< BuddySkill >; using BuddySkillPtr = std::shared_ptr< BuddySkill >;
using CabinetPtr = boost::shared_ptr< Cabinet >; using CabinetPtr = std::shared_ptr< Cabinet >;
using CabinetCategoryPtr = boost::shared_ptr< CabinetCategory >; using CabinetCategoryPtr = std::shared_ptr< CabinetCategory >;
using CalendarPtr = boost::shared_ptr< Calendar >; using CalendarPtr = std::shared_ptr< Calendar >;
using CharaMakeCustomizePtr = boost::shared_ptr< CharaMakeCustomize >; using CharaMakeCustomizePtr = std::shared_ptr< CharaMakeCustomize >;
using CharaMakeTypePtr = boost::shared_ptr< CharaMakeType >; using CharaMakeTypePtr = std::shared_ptr< CharaMakeType >;
using ChocoboRacePtr = boost::shared_ptr< ChocoboRace >; using ChocoboRacePtr = std::shared_ptr< ChocoboRace >;
using ChocoboRaceAbilityPtr = boost::shared_ptr< ChocoboRaceAbility >; using ChocoboRaceAbilityPtr = std::shared_ptr< ChocoboRaceAbility >;
using ChocoboRaceAbilityTypePtr = boost::shared_ptr< ChocoboRaceAbilityType >; using ChocoboRaceAbilityTypePtr = std::shared_ptr< ChocoboRaceAbilityType >;
using ChocoboRaceItemPtr = boost::shared_ptr< ChocoboRaceItem >; using ChocoboRaceItemPtr = std::shared_ptr< ChocoboRaceItem >;
using ChocoboRaceRankPtr = boost::shared_ptr< ChocoboRaceRank >; using ChocoboRaceRankPtr = std::shared_ptr< ChocoboRaceRank >;
using ChocoboRaceStatusPtr = boost::shared_ptr< ChocoboRaceStatus >; using ChocoboRaceStatusPtr = std::shared_ptr< ChocoboRaceStatus >;
using ChocoboRaceTerritoryPtr = boost::shared_ptr< ChocoboRaceTerritory >; using ChocoboRaceTerritoryPtr = std::shared_ptr< ChocoboRaceTerritory >;
using ChocoboRaceTutorialPtr = boost::shared_ptr< ChocoboRaceTutorial >; using ChocoboRaceTutorialPtr = std::shared_ptr< ChocoboRaceTutorial >;
using ChocoboRaceWeatherPtr = boost::shared_ptr< ChocoboRaceWeather >; using ChocoboRaceWeatherPtr = std::shared_ptr< ChocoboRaceWeather >;
using ChocoboTaxiPtr = boost::shared_ptr< ChocoboTaxi >; using ChocoboTaxiPtr = std::shared_ptr< ChocoboTaxi >;
using ChocoboTaxiStandPtr = boost::shared_ptr< ChocoboTaxiStand >; using ChocoboTaxiStandPtr = std::shared_ptr< ChocoboTaxiStand >;
using ClassJobPtr = boost::shared_ptr< ClassJob >; using ClassJobPtr = std::shared_ptr< ClassJob >;
using ClassJobCategoryPtr = boost::shared_ptr< ClassJobCategory >; using ClassJobCategoryPtr = std::shared_ptr< ClassJobCategory >;
using CompanionPtr = boost::shared_ptr< Companion >; using CompanionPtr = std::shared_ptr< Companion >;
using CompanionMovePtr = boost::shared_ptr< CompanionMove >; using CompanionMovePtr = std::shared_ptr< CompanionMove >;
using CompanionTransientPtr = boost::shared_ptr< CompanionTransient >; using CompanionTransientPtr = std::shared_ptr< CompanionTransient >;
using CompanyActionPtr = boost::shared_ptr< CompanyAction >; using CompanyActionPtr = std::shared_ptr< CompanyAction >;
using CompanyCraftDraftPtr = boost::shared_ptr< CompanyCraftDraft >; using CompanyCraftDraftPtr = std::shared_ptr< CompanyCraftDraft >;
using CompanyCraftDraftCategoryPtr = boost::shared_ptr< CompanyCraftDraftCategory >; using CompanyCraftDraftCategoryPtr = std::shared_ptr< CompanyCraftDraftCategory >;
using CompanyCraftManufactoryStatePtr = boost::shared_ptr< CompanyCraftManufactoryState >; using CompanyCraftManufactoryStatePtr = std::shared_ptr< CompanyCraftManufactoryState >;
using CompanyCraftPartPtr = boost::shared_ptr< CompanyCraftPart >; using CompanyCraftPartPtr = std::shared_ptr< CompanyCraftPart >;
using CompanyCraftProcessPtr = boost::shared_ptr< CompanyCraftProcess >; using CompanyCraftProcessPtr = std::shared_ptr< CompanyCraftProcess >;
using CompanyCraftSequencePtr = boost::shared_ptr< CompanyCraftSequence >; using CompanyCraftSequencePtr = std::shared_ptr< CompanyCraftSequence >;
using CompanyCraftSupplyItemPtr = boost::shared_ptr< CompanyCraftSupplyItem >; using CompanyCraftSupplyItemPtr = std::shared_ptr< CompanyCraftSupplyItem >;
using CompanyCraftTypePtr = boost::shared_ptr< CompanyCraftType >; using CompanyCraftTypePtr = std::shared_ptr< CompanyCraftType >;
using CompleteJournalPtr = boost::shared_ptr< CompleteJournal >; using CompleteJournalPtr = std::shared_ptr< CompleteJournal >;
using CompleteJournalCategoryPtr = boost::shared_ptr< CompleteJournalCategory >; using CompleteJournalCategoryPtr = std::shared_ptr< CompleteJournalCategory >;
using ContentCloseCyclePtr = boost::shared_ptr< ContentCloseCycle >; using ContentCloseCyclePtr = std::shared_ptr< ContentCloseCycle >;
using ContentExActionPtr = boost::shared_ptr< ContentExAction >; using ContentExActionPtr = std::shared_ptr< ContentExAction >;
using ContentFinderConditionPtr = boost::shared_ptr< ContentFinderCondition >; using ContentFinderConditionPtr = std::shared_ptr< ContentFinderCondition >;
using ContentFinderConditionTransientPtr = boost::shared_ptr< ContentFinderConditionTransient >; using ContentFinderConditionTransientPtr = std::shared_ptr< ContentFinderConditionTransient >;
using ContentGaugePtr = boost::shared_ptr< ContentGauge >; using ContentGaugePtr = std::shared_ptr< ContentGauge >;
using ContentGaugeColorPtr = boost::shared_ptr< ContentGaugeColor >; using ContentGaugeColorPtr = std::shared_ptr< ContentGaugeColor >;
using ContentMemberTypePtr = boost::shared_ptr< ContentMemberType >; using ContentMemberTypePtr = std::shared_ptr< ContentMemberType >;
using ContentNpcTalkPtr = boost::shared_ptr< ContentNpcTalk >; using ContentNpcTalkPtr = std::shared_ptr< ContentNpcTalk >;
using ContentRoulettePtr = boost::shared_ptr< ContentRoulette >; using ContentRoulettePtr = std::shared_ptr< ContentRoulette >;
using ContentRouletteOpenRulePtr = boost::shared_ptr< ContentRouletteOpenRule >; using ContentRouletteOpenRulePtr = std::shared_ptr< ContentRouletteOpenRule >;
using ContentRouletteRoleBonusPtr = boost::shared_ptr< ContentRouletteRoleBonus >; using ContentRouletteRoleBonusPtr = std::shared_ptr< ContentRouletteRoleBonus >;
using ContentsNotePtr = boost::shared_ptr< ContentsNote >; using ContentsNotePtr = std::shared_ptr< ContentsNote >;
using ContentTalkPtr = boost::shared_ptr< ContentTalk >; using ContentTalkPtr = std::shared_ptr< ContentTalk >;
using ContentTalkParamPtr = boost::shared_ptr< ContentTalkParam >; using ContentTalkParamPtr = std::shared_ptr< ContentTalkParam >;
using ContentTypePtr = boost::shared_ptr< ContentType >; using ContentTypePtr = std::shared_ptr< ContentType >;
using CraftActionPtr = boost::shared_ptr< CraftAction >; using CraftActionPtr = std::shared_ptr< CraftAction >;
using CraftLevePtr = boost::shared_ptr< CraftLeve >; using CraftLevePtr = std::shared_ptr< CraftLeve >;
using CraftTypePtr = boost::shared_ptr< CraftType >; using CraftTypePtr = std::shared_ptr< CraftType >;
using CreditPtr = boost::shared_ptr< Credit >; using CreditPtr = std::shared_ptr< Credit >;
using CreditCastPtr = boost::shared_ptr< CreditCast >; using CreditCastPtr = std::shared_ptr< CreditCast >;
using CurrencyPtr = boost::shared_ptr< Currency >; using CurrencyPtr = std::shared_ptr< Currency >;
using CustomTalkPtr = boost::shared_ptr< CustomTalk >; using CustomTalkPtr = std::shared_ptr< CustomTalk >;
using CutscenePtr = boost::shared_ptr< Cutscene >; using CutscenePtr = std::shared_ptr< Cutscene >;
using CutScreenImagePtr = boost::shared_ptr< CutScreenImage >; using CutScreenImagePtr = std::shared_ptr< CutScreenImage >;
using DailySupplyItemPtr = boost::shared_ptr< DailySupplyItem >; using DailySupplyItemPtr = std::shared_ptr< DailySupplyItem >;
using DeepDungeonPtr = boost::shared_ptr< DeepDungeon >; using DeepDungeonPtr = std::shared_ptr< DeepDungeon >;
using DeepDungeonBanPtr = boost::shared_ptr< DeepDungeonBan >; using DeepDungeonBanPtr = std::shared_ptr< DeepDungeonBan >;
using DeepDungeonDangerPtr = boost::shared_ptr< DeepDungeonDanger >; using DeepDungeonDangerPtr = std::shared_ptr< DeepDungeonDanger >;
using DeepDungeonEquipmentPtr = boost::shared_ptr< DeepDungeonEquipment >; using DeepDungeonEquipmentPtr = std::shared_ptr< DeepDungeonEquipment >;
using DeepDungeonFloorEffectUIPtr = boost::shared_ptr< DeepDungeonFloorEffectUI >; using DeepDungeonFloorEffectUIPtr = std::shared_ptr< DeepDungeonFloorEffectUI >;
using DeepDungeonItemPtr = boost::shared_ptr< DeepDungeonItem >; using DeepDungeonItemPtr = std::shared_ptr< DeepDungeonItem >;
using DeepDungeonLayerPtr = boost::shared_ptr< DeepDungeonLayer >; using DeepDungeonLayerPtr = std::shared_ptr< DeepDungeonLayer >;
using DeepDungeonMagicStonePtr = boost::shared_ptr< DeepDungeonMagicStone >; using DeepDungeonMagicStonePtr = std::shared_ptr< DeepDungeonMagicStone >;
using DeepDungeonMap5XPtr = boost::shared_ptr< DeepDungeonMap5X >; using DeepDungeonMap5XPtr = std::shared_ptr< DeepDungeonMap5X >;
using DeepDungeonRoomPtr = boost::shared_ptr< DeepDungeonRoom >; using DeepDungeonRoomPtr = std::shared_ptr< DeepDungeonRoom >;
using DeepDungeonStatusPtr = boost::shared_ptr< DeepDungeonStatus >; using DeepDungeonStatusPtr = std::shared_ptr< DeepDungeonStatus >;
using DefaultTalkPtr = boost::shared_ptr< DefaultTalk >; using DefaultTalkPtr = std::shared_ptr< DefaultTalk >;
using DefaultTalkLipSyncTypePtr = boost::shared_ptr< DefaultTalkLipSyncType >; using DefaultTalkLipSyncTypePtr = std::shared_ptr< DefaultTalkLipSyncType >;
using DeliveryQuestPtr = boost::shared_ptr< DeliveryQuest >; using DeliveryQuestPtr = std::shared_ptr< DeliveryQuest >;
using DisposalShopPtr = boost::shared_ptr< DisposalShop >; using DisposalShopPtr = std::shared_ptr< DisposalShop >;
using DisposalShopFilterTypePtr = boost::shared_ptr< DisposalShopFilterType >; using DisposalShopFilterTypePtr = std::shared_ptr< DisposalShopFilterType >;
using DisposalShopItemPtr = boost::shared_ptr< DisposalShopItem >; using DisposalShopItemPtr = std::shared_ptr< DisposalShopItem >;
using DpsChallengePtr = boost::shared_ptr< DpsChallenge >; using DpsChallengePtr = std::shared_ptr< DpsChallenge >;
using DpsChallengeOfficerPtr = boost::shared_ptr< DpsChallengeOfficer >; using DpsChallengeOfficerPtr = std::shared_ptr< DpsChallengeOfficer >;
using DpsChallengeTransientPtr = boost::shared_ptr< DpsChallengeTransient >; using DpsChallengeTransientPtr = std::shared_ptr< DpsChallengeTransient >;
using EmotePtr = boost::shared_ptr< Emote >; using EmotePtr = std::shared_ptr< Emote >;
using EmoteCategoryPtr = boost::shared_ptr< EmoteCategory >; using EmoteCategoryPtr = std::shared_ptr< EmoteCategory >;
using ENpcBasePtr = boost::shared_ptr< ENpcBase >; using ENpcBasePtr = std::shared_ptr< ENpcBase >;
using ENpcResidentPtr = boost::shared_ptr< ENpcResident >; using ENpcResidentPtr = std::shared_ptr< ENpcResident >;
using EObjPtr = boost::shared_ptr< EObj >; using EObjPtr = std::shared_ptr< EObj >;
using EObjNamePtr = boost::shared_ptr< EObjName >; using EObjNamePtr = std::shared_ptr< EObjName >;
using EquipRaceCategoryPtr = boost::shared_ptr< EquipRaceCategory >; using EquipRaceCategoryPtr = std::shared_ptr< EquipRaceCategory >;
using EquipSlotCategoryPtr = boost::shared_ptr< EquipSlotCategory >; using EquipSlotCategoryPtr = std::shared_ptr< EquipSlotCategory >;
using EurekaAethernetPtr = boost::shared_ptr< EurekaAethernet >; using EurekaAethernetPtr = std::shared_ptr< EurekaAethernet >;
using EurekaGrowDataPtr = boost::shared_ptr< EurekaGrowData >; using EurekaGrowDataPtr = std::shared_ptr< EurekaGrowData >;
using EurekaSphereElementAdjustPtr = boost::shared_ptr< EurekaSphereElementAdjust >; using EurekaSphereElementAdjustPtr = std::shared_ptr< EurekaSphereElementAdjust >;
using EventActionPtr = boost::shared_ptr< EventAction >; using EventActionPtr = std::shared_ptr< EventAction >;
using EventIconPriorityPtr = boost::shared_ptr< EventIconPriority >; using EventIconPriorityPtr = std::shared_ptr< EventIconPriority >;
using EventIconTypePtr = boost::shared_ptr< EventIconType >; using EventIconTypePtr = std::shared_ptr< EventIconType >;
using EventItemPtr = boost::shared_ptr< EventItem >; using EventItemPtr = std::shared_ptr< EventItem >;
using EventItemCastTimelinePtr = boost::shared_ptr< EventItemCastTimeline >; using EventItemCastTimelinePtr = std::shared_ptr< EventItemCastTimeline >;
using EventItemHelpPtr = boost::shared_ptr< EventItemHelp >; using EventItemHelpPtr = std::shared_ptr< EventItemHelp >;
using EventItemTimelinePtr = boost::shared_ptr< EventItemTimeline >; using EventItemTimelinePtr = std::shared_ptr< EventItemTimeline >;
using ExportedSGPtr = boost::shared_ptr< ExportedSG >; using ExportedSGPtr = std::shared_ptr< ExportedSG >;
using ExVersionPtr = boost::shared_ptr< ExVersion >; using ExVersionPtr = std::shared_ptr< ExVersion >;
using FatePtr = boost::shared_ptr< Fate >; using FatePtr = std::shared_ptr< Fate >;
using FCActivityPtr = boost::shared_ptr< FCActivity >; using FCActivityPtr = std::shared_ptr< FCActivity >;
using FCActivityCategoryPtr = boost::shared_ptr< FCActivityCategory >; using FCActivityCategoryPtr = std::shared_ptr< FCActivityCategory >;
using FCAuthorityPtr = boost::shared_ptr< FCAuthority >; using FCAuthorityPtr = std::shared_ptr< FCAuthority >;
using FCAuthorityCategoryPtr = boost::shared_ptr< FCAuthorityCategory >; using FCAuthorityCategoryPtr = std::shared_ptr< FCAuthorityCategory >;
using FCChestNamePtr = boost::shared_ptr< FCChestName >; using FCChestNamePtr = std::shared_ptr< FCChestName >;
using FccShopPtr = boost::shared_ptr< FccShop >; using FccShopPtr = std::shared_ptr< FccShop >;
using FCHierarchyPtr = boost::shared_ptr< FCHierarchy >; using FCHierarchyPtr = std::shared_ptr< FCHierarchy >;
using FCProfilePtr = boost::shared_ptr< FCProfile >; using FCProfilePtr = std::shared_ptr< FCProfile >;
using FCReputationPtr = boost::shared_ptr< FCReputation >; using FCReputationPtr = std::shared_ptr< FCReputation >;
using FCRightsPtr = boost::shared_ptr< FCRights >; using FCRightsPtr = std::shared_ptr< FCRights >;
using FieldMarkerPtr = boost::shared_ptr< FieldMarker >; using FieldMarkerPtr = std::shared_ptr< FieldMarker >;
using FishingRecordTypeTransientPtr = boost::shared_ptr< FishingRecordTypeTransient >; using FishingRecordTypeTransientPtr = std::shared_ptr< FishingRecordTypeTransient >;
using FishingSpotPtr = boost::shared_ptr< FishingSpot >; using FishingSpotPtr = std::shared_ptr< FishingSpot >;
using FishParameterPtr = boost::shared_ptr< FishParameter >; using FishParameterPtr = std::shared_ptr< FishParameter >;
using Frontline03Ptr = boost::shared_ptr< Frontline03 >; using Frontline03Ptr = std::shared_ptr< Frontline03 >;
using Frontline04Ptr = boost::shared_ptr< Frontline04 >; using Frontline04Ptr = std::shared_ptr< Frontline04 >;
using GardeningSeedPtr = boost::shared_ptr< GardeningSeed >; using GardeningSeedPtr = std::shared_ptr< GardeningSeed >;
using GatheringConditionPtr = boost::shared_ptr< GatheringCondition >; using GatheringConditionPtr = std::shared_ptr< GatheringCondition >;
using GatheringExpPtr = boost::shared_ptr< GatheringExp >; using GatheringExpPtr = std::shared_ptr< GatheringExp >;
using GatheringItemPtr = boost::shared_ptr< GatheringItem >; using GatheringItemPtr = std::shared_ptr< GatheringItem >;
using GatheringItemLevelConvertTablePtr = boost::shared_ptr< GatheringItemLevelConvertTable >; using GatheringItemLevelConvertTablePtr = std::shared_ptr< GatheringItemLevelConvertTable >;
using GatheringItemPointPtr = boost::shared_ptr< GatheringItemPoint >; using GatheringItemPointPtr = std::shared_ptr< GatheringItemPoint >;
using GatheringLevePtr = boost::shared_ptr< GatheringLeve >; using GatheringLevePtr = std::shared_ptr< GatheringLeve >;
using GatheringLeveRoutePtr = boost::shared_ptr< GatheringLeveRoute >; using GatheringLeveRoutePtr = std::shared_ptr< GatheringLeveRoute >;
using GatheringNotebookListPtr = boost::shared_ptr< GatheringNotebookList >; using GatheringNotebookListPtr = std::shared_ptr< GatheringNotebookList >;
using GatheringPointPtr = boost::shared_ptr< GatheringPoint >; using GatheringPointPtr = std::shared_ptr< GatheringPoint >;
using GatheringPointBasePtr = boost::shared_ptr< GatheringPointBase >; using GatheringPointBasePtr = std::shared_ptr< GatheringPointBase >;
using GatheringPointBonusPtr = boost::shared_ptr< GatheringPointBonus >; using GatheringPointBonusPtr = std::shared_ptr< GatheringPointBonus >;
using GatheringPointBonusTypePtr = boost::shared_ptr< GatheringPointBonusType >; using GatheringPointBonusTypePtr = std::shared_ptr< GatheringPointBonusType >;
using GatheringPointNamePtr = boost::shared_ptr< GatheringPointName >; using GatheringPointNamePtr = std::shared_ptr< GatheringPointName >;
using GatheringSubCategoryPtr = boost::shared_ptr< GatheringSubCategory >; using GatheringSubCategoryPtr = std::shared_ptr< GatheringSubCategory >;
using GatheringTypePtr = boost::shared_ptr< GatheringType >; using GatheringTypePtr = std::shared_ptr< GatheringType >;
using GcArmyCaptureTacticsPtr = boost::shared_ptr< GcArmyCaptureTactics >; using GcArmyCaptureTacticsPtr = std::shared_ptr< GcArmyCaptureTactics >;
using GcArmyExpeditionPtr = boost::shared_ptr< GcArmyExpedition >; using GcArmyExpeditionPtr = std::shared_ptr< GcArmyExpedition >;
using GcArmyExpeditionMemberBonusPtr = boost::shared_ptr< GcArmyExpeditionMemberBonus >; using GcArmyExpeditionMemberBonusPtr = std::shared_ptr< GcArmyExpeditionMemberBonus >;
using GcArmyExpeditionTypePtr = boost::shared_ptr< GcArmyExpeditionType >; using GcArmyExpeditionTypePtr = std::shared_ptr< GcArmyExpeditionType >;
using GcArmyMemberGrowPtr = boost::shared_ptr< GcArmyMemberGrow >; using GcArmyMemberGrowPtr = std::shared_ptr< GcArmyMemberGrow >;
using GcArmyTrainingPtr = boost::shared_ptr< GcArmyTraining >; using GcArmyTrainingPtr = std::shared_ptr< GcArmyTraining >;
using GCRankGridaniaFemaleTextPtr = boost::shared_ptr< GCRankGridaniaFemaleText >; using GCRankGridaniaFemaleTextPtr = std::shared_ptr< GCRankGridaniaFemaleText >;
using GCRankGridaniaMaleTextPtr = boost::shared_ptr< GCRankGridaniaMaleText >; using GCRankGridaniaMaleTextPtr = std::shared_ptr< GCRankGridaniaMaleText >;
using GCRankLimsaFemaleTextPtr = boost::shared_ptr< GCRankLimsaFemaleText >; using GCRankLimsaFemaleTextPtr = std::shared_ptr< GCRankLimsaFemaleText >;
using GCRankLimsaMaleTextPtr = boost::shared_ptr< GCRankLimsaMaleText >; using GCRankLimsaMaleTextPtr = std::shared_ptr< GCRankLimsaMaleText >;
using GCRankUldahFemaleTextPtr = boost::shared_ptr< GCRankUldahFemaleText >; using GCRankUldahFemaleTextPtr = std::shared_ptr< GCRankUldahFemaleText >;
using GCRankUldahMaleTextPtr = boost::shared_ptr< GCRankUldahMaleText >; using GCRankUldahMaleTextPtr = std::shared_ptr< GCRankUldahMaleText >;
using GCScripShopCategoryPtr = boost::shared_ptr< GCScripShopCategory >; using GCScripShopCategoryPtr = std::shared_ptr< GCScripShopCategory >;
using GCScripShopItemPtr = boost::shared_ptr< GCScripShopItem >; using GCScripShopItemPtr = std::shared_ptr< GCScripShopItem >;
using GCShopPtr = boost::shared_ptr< GCShop >; using GCShopPtr = std::shared_ptr< GCShop >;
using GCShopItemCategoryPtr = boost::shared_ptr< GCShopItemCategory >; using GCShopItemCategoryPtr = std::shared_ptr< GCShopItemCategory >;
using GCSupplyDutyPtr = boost::shared_ptr< GCSupplyDuty >; using GCSupplyDutyPtr = std::shared_ptr< GCSupplyDuty >;
using GCSupplyDutyRewardPtr = boost::shared_ptr< GCSupplyDutyReward >; using GCSupplyDutyRewardPtr = std::shared_ptr< GCSupplyDutyReward >;
using GeneralActionPtr = boost::shared_ptr< GeneralAction >; using GeneralActionPtr = std::shared_ptr< GeneralAction >;
using GFATEPtr = boost::shared_ptr< GFATE >; using GFATEPtr = std::shared_ptr< GFATE >;
using GilShopPtr = boost::shared_ptr< GilShop >; using GilShopPtr = std::shared_ptr< GilShop >;
using GilShopItemPtr = boost::shared_ptr< GilShopItem >; using GilShopItemPtr = std::shared_ptr< GilShopItem >;
using GoldSaucerArcadeMachinePtr = boost::shared_ptr< GoldSaucerArcadeMachine >; using GoldSaucerArcadeMachinePtr = std::shared_ptr< GoldSaucerArcadeMachine >;
using GoldSaucerTextDataPtr = boost::shared_ptr< GoldSaucerTextData >; using GoldSaucerTextDataPtr = std::shared_ptr< GoldSaucerTextData >;
using GrandCompanyPtr = boost::shared_ptr< GrandCompany >; using GrandCompanyPtr = std::shared_ptr< GrandCompany >;
using GrandCompanyRankPtr = boost::shared_ptr< GrandCompanyRank >; using GrandCompanyRankPtr = std::shared_ptr< GrandCompanyRank >;
using GuardianDeityPtr = boost::shared_ptr< GuardianDeity >; using GuardianDeityPtr = std::shared_ptr< GuardianDeity >;
using GuildleveAssignmentPtr = boost::shared_ptr< GuildleveAssignment >; using GuildleveAssignmentPtr = std::shared_ptr< GuildleveAssignment >;
using GuildleveAssignmentCategoryPtr = boost::shared_ptr< GuildleveAssignmentCategory >; using GuildleveAssignmentCategoryPtr = std::shared_ptr< GuildleveAssignmentCategory >;
using GuildOrderGuidePtr = boost::shared_ptr< GuildOrderGuide >; using GuildOrderGuidePtr = std::shared_ptr< GuildOrderGuide >;
using GuildOrderOfficerPtr = boost::shared_ptr< GuildOrderOfficer >; using GuildOrderOfficerPtr = std::shared_ptr< GuildOrderOfficer >;
using HairMakeTypePtr = boost::shared_ptr< HairMakeType >; using HairMakeTypePtr = std::shared_ptr< HairMakeType >;
using HouseRetainerPosePtr = boost::shared_ptr< HouseRetainerPose >; using HouseRetainerPosePtr = std::shared_ptr< HouseRetainerPose >;
using HousingAethernetPtr = boost::shared_ptr< HousingAethernet >; using HousingAethernetPtr = std::shared_ptr< HousingAethernet >;
using HousingEmploymentNpcListPtr = boost::shared_ptr< HousingEmploymentNpcList >; using HousingEmploymentNpcListPtr = std::shared_ptr< HousingEmploymentNpcList >;
using HousingEmploymentNpcRacePtr = boost::shared_ptr< HousingEmploymentNpcRace >; using HousingEmploymentNpcRacePtr = std::shared_ptr< HousingEmploymentNpcRace >;
using HousingFurniturePtr = boost::shared_ptr< HousingFurniture >; using HousingFurniturePtr = std::shared_ptr< HousingFurniture >;
using HousingPlacementPtr = boost::shared_ptr< HousingPlacement >; using HousingPlacementPtr = std::shared_ptr< HousingPlacement >;
using HousingPresetPtr = boost::shared_ptr< HousingPreset >; using HousingPresetPtr = std::shared_ptr< HousingPreset >;
using HousingYardObjectPtr = boost::shared_ptr< HousingYardObject >; using HousingYardObjectPtr = std::shared_ptr< HousingYardObject >;
using HowToPtr = boost::shared_ptr< HowTo >; using HowToPtr = std::shared_ptr< HowTo >;
using HowToCategoryPtr = boost::shared_ptr< HowToCategory >; using HowToCategoryPtr = std::shared_ptr< HowToCategory >;
using HowToPagePtr = boost::shared_ptr< HowToPage >; using HowToPagePtr = std::shared_ptr< HowToPage >;
using InstanceContentPtr = boost::shared_ptr< InstanceContent >; using InstanceContentPtr = std::shared_ptr< InstanceContent >;
using InstanceContentBuffPtr = boost::shared_ptr< InstanceContentBuff >; using InstanceContentBuffPtr = std::shared_ptr< InstanceContentBuff >;
using InstanceContentTextDataPtr = boost::shared_ptr< InstanceContentTextData >; using InstanceContentTextDataPtr = std::shared_ptr< InstanceContentTextData >;
using ItemPtr = boost::shared_ptr< Item >; using ItemPtr = std::shared_ptr< Item >;
using ItemActionPtr = boost::shared_ptr< ItemAction >; using ItemActionPtr = std::shared_ptr< ItemAction >;
using ItemFoodPtr = boost::shared_ptr< ItemFood >; using ItemFoodPtr = std::shared_ptr< ItemFood >;
using ItemSearchCategoryPtr = boost::shared_ptr< ItemSearchCategory >; using ItemSearchCategoryPtr = std::shared_ptr< ItemSearchCategory >;
using ItemSeriesPtr = boost::shared_ptr< ItemSeries >; using ItemSeriesPtr = std::shared_ptr< ItemSeries >;
using ItemSpecialBonusPtr = boost::shared_ptr< ItemSpecialBonus >; using ItemSpecialBonusPtr = std::shared_ptr< ItemSpecialBonus >;
using ItemUICategoryPtr = boost::shared_ptr< ItemUICategory >; using ItemUICategoryPtr = std::shared_ptr< ItemUICategory >;
using JournalCategoryPtr = boost::shared_ptr< JournalCategory >; using JournalCategoryPtr = std::shared_ptr< JournalCategory >;
using JournalGenrePtr = boost::shared_ptr< JournalGenre >; using JournalGenrePtr = std::shared_ptr< JournalGenre >;
using JournalSectionPtr = boost::shared_ptr< JournalSection >; using JournalSectionPtr = std::shared_ptr< JournalSection >;
using LevePtr = boost::shared_ptr< Leve >; using LevePtr = std::shared_ptr< Leve >;
using LeveAssignmentTypePtr = boost::shared_ptr< LeveAssignmentType >; using LeveAssignmentTypePtr = std::shared_ptr< LeveAssignmentType >;
using LeveClientPtr = boost::shared_ptr< LeveClient >; using LeveClientPtr = std::shared_ptr< LeveClient >;
using LevelPtr = boost::shared_ptr< Level >; using LevelPtr = std::shared_ptr< Level >;
using LeveRewardItemPtr = boost::shared_ptr< LeveRewardItem >; using LeveRewardItemPtr = std::shared_ptr< LeveRewardItem >;
using LeveRewardItemGroupPtr = boost::shared_ptr< LeveRewardItemGroup >; using LeveRewardItemGroupPtr = std::shared_ptr< LeveRewardItemGroup >;
using LeveVfxPtr = boost::shared_ptr< LeveVfx >; using LeveVfxPtr = std::shared_ptr< LeveVfx >;
using LogFilterPtr = boost::shared_ptr< LogFilter >; using LogFilterPtr = std::shared_ptr< LogFilter >;
using LogKindPtr = boost::shared_ptr< LogKind >; using LogKindPtr = std::shared_ptr< LogKind >;
using LogKindCategoryTextPtr = boost::shared_ptr< LogKindCategoryText >; using LogKindCategoryTextPtr = std::shared_ptr< LogKindCategoryText >;
using LogMessagePtr = boost::shared_ptr< LogMessage >; using LogMessagePtr = std::shared_ptr< LogMessage >;
using LotteryExchangeShopPtr = boost::shared_ptr< LotteryExchangeShop >; using LotteryExchangeShopPtr = std::shared_ptr< LotteryExchangeShop >;
using MacroIconPtr = boost::shared_ptr< MacroIcon >; using MacroIconPtr = std::shared_ptr< MacroIcon >;
using MacroIconRedirectOldPtr = boost::shared_ptr< MacroIconRedirectOld >; using MacroIconRedirectOldPtr = std::shared_ptr< MacroIconRedirectOld >;
using MainCommandPtr = boost::shared_ptr< MainCommand >; using MainCommandPtr = std::shared_ptr< MainCommand >;
using MainCommandCategoryPtr = boost::shared_ptr< MainCommandCategory >; using MainCommandCategoryPtr = std::shared_ptr< MainCommandCategory >;
using ManeuversArmorPtr = boost::shared_ptr< ManeuversArmor >; using ManeuversArmorPtr = std::shared_ptr< ManeuversArmor >;
using MapPtr = boost::shared_ptr< Map >; using MapPtr = std::shared_ptr< Map >;
using MapMarkerPtr = boost::shared_ptr< MapMarker >; using MapMarkerPtr = std::shared_ptr< MapMarker >;
using MapMarkerRegionPtr = boost::shared_ptr< MapMarkerRegion >; using MapMarkerRegionPtr = std::shared_ptr< MapMarkerRegion >;
using MapSymbolPtr = boost::shared_ptr< MapSymbol >; using MapSymbolPtr = std::shared_ptr< MapSymbol >;
using MarkerPtr = boost::shared_ptr< Marker >; using MarkerPtr = std::shared_ptr< Marker >;
using MasterpieceSupplyDutyPtr = boost::shared_ptr< MasterpieceSupplyDuty >; using MasterpieceSupplyDutyPtr = std::shared_ptr< MasterpieceSupplyDuty >;
using MasterpieceSupplyMultiplierPtr = boost::shared_ptr< MasterpieceSupplyMultiplier >; using MasterpieceSupplyMultiplierPtr = std::shared_ptr< MasterpieceSupplyMultiplier >;
using MateriaPtr = boost::shared_ptr< Materia >; using MateriaPtr = std::shared_ptr< Materia >;
using MinionRacePtr = boost::shared_ptr< MinionRace >; using MinionRacePtr = std::shared_ptr< MinionRace >;
using MinionRulesPtr = boost::shared_ptr< MinionRules >; using MinionRulesPtr = std::shared_ptr< MinionRules >;
using MinionSkillTypePtr = boost::shared_ptr< MinionSkillType >; using MinionSkillTypePtr = std::shared_ptr< MinionSkillType >;
using MobHuntOrderTypePtr = boost::shared_ptr< MobHuntOrderType >; using MobHuntOrderTypePtr = std::shared_ptr< MobHuntOrderType >;
using MobHuntTargetPtr = boost::shared_ptr< MobHuntTarget >; using MobHuntTargetPtr = std::shared_ptr< MobHuntTarget >;
using ModelCharaPtr = boost::shared_ptr< ModelChara >; using ModelCharaPtr = std::shared_ptr< ModelChara >;
using ModelStatePtr = boost::shared_ptr< ModelState >; using ModelStatePtr = std::shared_ptr< ModelState >;
using MonsterNotePtr = boost::shared_ptr< MonsterNote >; using MonsterNotePtr = std::shared_ptr< MonsterNote >;
using MonsterNoteTargetPtr = boost::shared_ptr< MonsterNoteTarget >; using MonsterNoteTargetPtr = std::shared_ptr< MonsterNoteTarget >;
using MountPtr = boost::shared_ptr< Mount >; using MountPtr = std::shared_ptr< Mount >;
using MountActionPtr = boost::shared_ptr< MountAction >; using MountActionPtr = std::shared_ptr< MountAction >;
using MountCustomizePtr = boost::shared_ptr< MountCustomize >; using MountCustomizePtr = std::shared_ptr< MountCustomize >;
using MountFlyingConditionPtr = boost::shared_ptr< MountFlyingCondition >; using MountFlyingConditionPtr = std::shared_ptr< MountFlyingCondition >;
using MountSpeedPtr = boost::shared_ptr< MountSpeed >; using MountSpeedPtr = std::shared_ptr< MountSpeed >;
using MountTransientPtr = boost::shared_ptr< MountTransient >; using MountTransientPtr = std::shared_ptr< MountTransient >;
using MoveTimelinePtr = boost::shared_ptr< MoveTimeline >; using MoveTimelinePtr = std::shared_ptr< MoveTimeline >;
using MoveVfxPtr = boost::shared_ptr< MoveVfx >; using MoveVfxPtr = std::shared_ptr< MoveVfx >;
using NpcEquipPtr = boost::shared_ptr< NpcEquip >; using NpcEquipPtr = std::shared_ptr< NpcEquip >;
using NpcYellPtr = boost::shared_ptr< NpcYell >; using NpcYellPtr = std::shared_ptr< NpcYell >;
using OmenPtr = boost::shared_ptr< Omen >; using OmenPtr = std::shared_ptr< Omen >;
using OnlineStatusPtr = boost::shared_ptr< OnlineStatus >; using OnlineStatusPtr = std::shared_ptr< OnlineStatus >;
using OpeningPtr = boost::shared_ptr< Opening >; using OpeningPtr = std::shared_ptr< Opening >;
using OrchestrionPtr = boost::shared_ptr< Orchestrion >; using OrchestrionPtr = std::shared_ptr< Orchestrion >;
using OrchestrionCategoryPtr = boost::shared_ptr< OrchestrionCategory >; using OrchestrionCategoryPtr = std::shared_ptr< OrchestrionCategory >;
using OrchestrionPathPtr = boost::shared_ptr< OrchestrionPath >; using OrchestrionPathPtr = std::shared_ptr< OrchestrionPath >;
using OrchestrionUiparamPtr = boost::shared_ptr< OrchestrionUiparam >; using OrchestrionUiparamPtr = std::shared_ptr< OrchestrionUiparam >;
using ParamGrowPtr = boost::shared_ptr< ParamGrow >; using ParamGrowPtr = std::shared_ptr< ParamGrow >;
using PartyContentCutscenePtr = boost::shared_ptr< PartyContentCutscene >; using PartyContentCutscenePtr = std::shared_ptr< PartyContentCutscene >;
using PerformPtr = boost::shared_ptr< Perform >; using PerformPtr = std::shared_ptr< Perform >;
using PerformTransientPtr = boost::shared_ptr< PerformTransient >; using PerformTransientPtr = std::shared_ptr< PerformTransient >;
using PetPtr = boost::shared_ptr< Pet >; using PetPtr = std::shared_ptr< Pet >;
using PetActionPtr = boost::shared_ptr< PetAction >; using PetActionPtr = std::shared_ptr< PetAction >;
using PicturePtr = boost::shared_ptr< Picture >; using PicturePtr = std::shared_ptr< Picture >;
using PlaceNamePtr = boost::shared_ptr< PlaceName >; using PlaceNamePtr = std::shared_ptr< PlaceName >;
using PlantPotFlowerSeedPtr = boost::shared_ptr< PlantPotFlowerSeed >; using PlantPotFlowerSeedPtr = std::shared_ptr< PlantPotFlowerSeed >;
using PreHandlerPtr = boost::shared_ptr< PreHandler >; using PreHandlerPtr = std::shared_ptr< PreHandler >;
using PublicContentPtr = boost::shared_ptr< PublicContent >; using PublicContentPtr = std::shared_ptr< PublicContent >;
using PublicContentCutscenePtr = boost::shared_ptr< PublicContentCutscene >; using PublicContentCutscenePtr = std::shared_ptr< PublicContentCutscene >;
using PublicContentTextDataPtr = boost::shared_ptr< PublicContentTextData >; using PublicContentTextDataPtr = std::shared_ptr< PublicContentTextData >;
using PvPActionPtr = boost::shared_ptr< PvPAction >; using PvPActionPtr = std::shared_ptr< PvPAction >;
using PvPActionSortPtr = boost::shared_ptr< PvPActionSort >; using PvPActionSortPtr = std::shared_ptr< PvPActionSort >;
using PvPRankPtr = boost::shared_ptr< PvPRank >; using PvPRankPtr = std::shared_ptr< PvPRank >;
using PvPSelectTraitPtr = boost::shared_ptr< PvPSelectTrait >; using PvPSelectTraitPtr = std::shared_ptr< PvPSelectTrait >;
using PvPTraitPtr = boost::shared_ptr< PvPTrait >; using PvPTraitPtr = std::shared_ptr< PvPTrait >;
using QuestPtr = boost::shared_ptr< Quest >; using QuestPtr = std::shared_ptr< Quest >;
using QuestClassJobRewardPtr = boost::shared_ptr< QuestClassJobReward >; using QuestClassJobRewardPtr = std::shared_ptr< QuestClassJobReward >;
using QuestClassJobSupplyPtr = boost::shared_ptr< QuestClassJobSupply >; using QuestClassJobSupplyPtr = std::shared_ptr< QuestClassJobSupply >;
using QuestRepeatFlagPtr = boost::shared_ptr< QuestRepeatFlag >; using QuestRepeatFlagPtr = std::shared_ptr< QuestRepeatFlag >;
using QuestRewardOtherPtr = boost::shared_ptr< QuestRewardOther >; using QuestRewardOtherPtr = std::shared_ptr< QuestRewardOther >;
using QuickChatPtr = boost::shared_ptr< QuickChat >; using QuickChatPtr = std::shared_ptr< QuickChat >;
using QuickChatTransientPtr = boost::shared_ptr< QuickChatTransient >; using QuickChatTransientPtr = std::shared_ptr< QuickChatTransient >;
using RacePtr = boost::shared_ptr< Race >; using RacePtr = std::shared_ptr< Race >;
using RacingChocoboItemPtr = boost::shared_ptr< RacingChocoboItem >; using RacingChocoboItemPtr = std::shared_ptr< RacingChocoboItem >;
using RacingChocoboNamePtr = boost::shared_ptr< RacingChocoboName >; using RacingChocoboNamePtr = std::shared_ptr< RacingChocoboName >;
using RacingChocoboNameCategoryPtr = boost::shared_ptr< RacingChocoboNameCategory >; using RacingChocoboNameCategoryPtr = std::shared_ptr< RacingChocoboNameCategory >;
using RacingChocoboNameInfoPtr = boost::shared_ptr< RacingChocoboNameInfo >; using RacingChocoboNameInfoPtr = std::shared_ptr< RacingChocoboNameInfo >;
using RacingChocoboParamPtr = boost::shared_ptr< RacingChocoboParam >; using RacingChocoboParamPtr = std::shared_ptr< RacingChocoboParam >;
using RecipePtr = boost::shared_ptr< Recipe >; using RecipePtr = std::shared_ptr< Recipe >;
using RecipeElementPtr = boost::shared_ptr< RecipeElement >; using RecipeElementPtr = std::shared_ptr< RecipeElement >;
using RecipeLevelTablePtr = boost::shared_ptr< RecipeLevelTable >; using RecipeLevelTablePtr = std::shared_ptr< RecipeLevelTable >;
using RecipeNotebookListPtr = boost::shared_ptr< RecipeNotebookList >; using RecipeNotebookListPtr = std::shared_ptr< RecipeNotebookList >;
using RecommendContentsPtr = boost::shared_ptr< RecommendContents >; using RecommendContentsPtr = std::shared_ptr< RecommendContents >;
using RelicPtr = boost::shared_ptr< Relic >; using RelicPtr = std::shared_ptr< Relic >;
using Relic3Ptr = boost::shared_ptr< Relic3 >; using Relic3Ptr = std::shared_ptr< Relic3 >;
using RelicItemPtr = boost::shared_ptr< RelicItem >; using RelicItemPtr = std::shared_ptr< RelicItem >;
using RelicNotePtr = boost::shared_ptr< RelicNote >; using RelicNotePtr = std::shared_ptr< RelicNote >;
using RelicNoteCategoryPtr = boost::shared_ptr< RelicNoteCategory >; using RelicNoteCategoryPtr = std::shared_ptr< RelicNoteCategory >;
using ResidentPtr = boost::shared_ptr< Resident >; using ResidentPtr = std::shared_ptr< Resident >;
using RetainerTaskPtr = boost::shared_ptr< RetainerTask >; using RetainerTaskPtr = std::shared_ptr< RetainerTask >;
using RetainerTaskLvRangePtr = boost::shared_ptr< RetainerTaskLvRange >; using RetainerTaskLvRangePtr = std::shared_ptr< RetainerTaskLvRange >;
using RetainerTaskNormalPtr = boost::shared_ptr< RetainerTaskNormal >; using RetainerTaskNormalPtr = std::shared_ptr< RetainerTaskNormal >;
using RetainerTaskParameterPtr = boost::shared_ptr< RetainerTaskParameter >; using RetainerTaskParameterPtr = std::shared_ptr< RetainerTaskParameter >;
using RetainerTaskRandomPtr = boost::shared_ptr< RetainerTaskRandom >; using RetainerTaskRandomPtr = std::shared_ptr< RetainerTaskRandom >;
using RPParameterPtr = boost::shared_ptr< RPParameter >; using RPParameterPtr = std::shared_ptr< RPParameter >;
using SalvagePtr = boost::shared_ptr< Salvage >; using SalvagePtr = std::shared_ptr< Salvage >;
using SatisfactionNpcPtr = boost::shared_ptr< SatisfactionNpc >; using SatisfactionNpcPtr = std::shared_ptr< SatisfactionNpc >;
using SatisfactionSupplyPtr = boost::shared_ptr< SatisfactionSupply >; using SatisfactionSupplyPtr = std::shared_ptr< SatisfactionSupply >;
using SatisfactionSupplyRewardPtr = boost::shared_ptr< SatisfactionSupplyReward >; using SatisfactionSupplyRewardPtr = std::shared_ptr< SatisfactionSupplyReward >;
using ScenarioTreePtr = boost::shared_ptr< ScenarioTree >; using ScenarioTreePtr = std::shared_ptr< ScenarioTree >;
using ScenarioTreeTipsPtr = boost::shared_ptr< ScenarioTreeTips >; using ScenarioTreeTipsPtr = std::shared_ptr< ScenarioTreeTips >;
using ScenarioTreeTipsClassQuestPtr = boost::shared_ptr< ScenarioTreeTipsClassQuest >; using ScenarioTreeTipsClassQuestPtr = std::shared_ptr< ScenarioTreeTipsClassQuest >;
using ScenarioTreeTipsQuestPtr = boost::shared_ptr< ScenarioTreeTipsQuest >; using ScenarioTreeTipsQuestPtr = std::shared_ptr< ScenarioTreeTipsQuest >;
using ScenarioTypePtr = boost::shared_ptr< ScenarioType >; using ScenarioTypePtr = std::shared_ptr< ScenarioType >;
using ScreenImagePtr = boost::shared_ptr< ScreenImage >; using ScreenImagePtr = std::shared_ptr< ScreenImage >;
using SecretRecipeBookPtr = boost::shared_ptr< SecretRecipeBook >; using SecretRecipeBookPtr = std::shared_ptr< SecretRecipeBook >;
using SkyIsland2MissionPtr = boost::shared_ptr< SkyIsland2Mission >; using SkyIsland2MissionPtr = std::shared_ptr< SkyIsland2Mission >;
using SkyIsland2MissionDetailPtr = boost::shared_ptr< SkyIsland2MissionDetail >; using SkyIsland2MissionDetailPtr = std::shared_ptr< SkyIsland2MissionDetail >;
using SkyIsland2MissionTypePtr = boost::shared_ptr< SkyIsland2MissionType >; using SkyIsland2MissionTypePtr = std::shared_ptr< SkyIsland2MissionType >;
using SkyIsland2RangeTypePtr = boost::shared_ptr< SkyIsland2RangeType >; using SkyIsland2RangeTypePtr = std::shared_ptr< SkyIsland2RangeType >;
using SpearfishingItemPtr = boost::shared_ptr< SpearfishingItem >; using SpearfishingItemPtr = std::shared_ptr< SpearfishingItem >;
using SpearfishingNotebookPtr = boost::shared_ptr< SpearfishingNotebook >; using SpearfishingNotebookPtr = std::shared_ptr< SpearfishingNotebook >;
using SpearfishingRecordPagePtr = boost::shared_ptr< SpearfishingRecordPage >; using SpearfishingRecordPagePtr = std::shared_ptr< SpearfishingRecordPage >;
using SpecialShopPtr = boost::shared_ptr< SpecialShop >; using SpecialShopPtr = std::shared_ptr< SpecialShop >;
using SpecialShopItemCategoryPtr = boost::shared_ptr< SpecialShopItemCategory >; using SpecialShopItemCategoryPtr = std::shared_ptr< SpecialShopItemCategory >;
using StainPtr = boost::shared_ptr< Stain >; using StainPtr = std::shared_ptr< Stain >;
using StainTransientPtr = boost::shared_ptr< StainTransient >; using StainTransientPtr = std::shared_ptr< StainTransient >;
using StatusPtr = boost::shared_ptr< Status >; using StatusPtr = std::shared_ptr< Status >;
using StatusHitEffectPtr = boost::shared_ptr< StatusHitEffect >; using StatusHitEffectPtr = std::shared_ptr< StatusHitEffect >;
using StatusLoopVFXPtr = boost::shared_ptr< StatusLoopVFX >; using StatusLoopVFXPtr = std::shared_ptr< StatusLoopVFX >;
using StoryPtr = boost::shared_ptr< Story >; using StoryPtr = std::shared_ptr< Story >;
using SubmarineExplorationPtr = boost::shared_ptr< SubmarineExploration >; using SubmarineExplorationPtr = std::shared_ptr< SubmarineExploration >;
using SubmarinePartPtr = boost::shared_ptr< SubmarinePart >; using SubmarinePartPtr = std::shared_ptr< SubmarinePart >;
using SubmarineRankPtr = boost::shared_ptr< SubmarineRank >; using SubmarineRankPtr = std::shared_ptr< SubmarineRank >;
using SwitchTalkPtr = boost::shared_ptr< SwitchTalk >; using SwitchTalkPtr = std::shared_ptr< SwitchTalk >;
using TerritoryTypePtr = boost::shared_ptr< TerritoryType >; using TerritoryTypePtr = std::shared_ptr< TerritoryType >;
using TextCommandPtr = boost::shared_ptr< TextCommand >; using TextCommandPtr = std::shared_ptr< TextCommand >;
using TitlePtr = boost::shared_ptr< Title >; using TitlePtr = std::shared_ptr< Title >;
using TomestonesPtr = boost::shared_ptr< Tomestones >; using TomestonesPtr = std::shared_ptr< Tomestones >;
using TomestonesItemPtr = boost::shared_ptr< TomestonesItem >; using TomestonesItemPtr = std::shared_ptr< TomestonesItem >;
using TopicSelectPtr = boost::shared_ptr< TopicSelect >; using TopicSelectPtr = std::shared_ptr< TopicSelect >;
using TownPtr = boost::shared_ptr< Town >; using TownPtr = std::shared_ptr< Town >;
using TraitPtr = boost::shared_ptr< Trait >; using TraitPtr = std::shared_ptr< Trait >;
using TraitRecastPtr = boost::shared_ptr< TraitRecast >; using TraitRecastPtr = std::shared_ptr< TraitRecast >;
using TraitTransientPtr = boost::shared_ptr< TraitTransient >; using TraitTransientPtr = std::shared_ptr< TraitTransient >;
using TransformationPtr = boost::shared_ptr< Transformation >; using TransformationPtr = std::shared_ptr< Transformation >;
using TreasurePtr = boost::shared_ptr< Treasure >; using TreasurePtr = std::shared_ptr< Treasure >;
using TreasureHuntRankPtr = boost::shared_ptr< TreasureHuntRank >; using TreasureHuntRankPtr = std::shared_ptr< TreasureHuntRank >;
using TribePtr = boost::shared_ptr< Tribe >; using TribePtr = std::shared_ptr< Tribe >;
using TripleTriadPtr = boost::shared_ptr< TripleTriad >; using TripleTriadPtr = std::shared_ptr< TripleTriad >;
using TripleTriadCardPtr = boost::shared_ptr< TripleTriadCard >; using TripleTriadCardPtr = std::shared_ptr< TripleTriadCard >;
using TripleTriadCardRarityPtr = boost::shared_ptr< TripleTriadCardRarity >; using TripleTriadCardRarityPtr = std::shared_ptr< TripleTriadCardRarity >;
using TripleTriadCardResidentPtr = boost::shared_ptr< TripleTriadCardResident >; using TripleTriadCardResidentPtr = std::shared_ptr< TripleTriadCardResident >;
using TripleTriadCardTypePtr = boost::shared_ptr< TripleTriadCardType >; using TripleTriadCardTypePtr = std::shared_ptr< TripleTriadCardType >;
using TripleTriadCompetitionPtr = boost::shared_ptr< TripleTriadCompetition >; using TripleTriadCompetitionPtr = std::shared_ptr< TripleTriadCompetition >;
using TripleTriadRulePtr = boost::shared_ptr< TripleTriadRule >; using TripleTriadRulePtr = std::shared_ptr< TripleTriadRule >;
using TutorialPtr = boost::shared_ptr< Tutorial >; using TutorialPtr = std::shared_ptr< Tutorial >;
using TutorialDPSPtr = boost::shared_ptr< TutorialDPS >; using TutorialDPSPtr = std::shared_ptr< TutorialDPS >;
using TutorialHealerPtr = boost::shared_ptr< TutorialHealer >; using TutorialHealerPtr = std::shared_ptr< TutorialHealer >;
using TutorialTankPtr = boost::shared_ptr< TutorialTank >; using TutorialTankPtr = std::shared_ptr< TutorialTank >;
using VaseFlowerPtr = boost::shared_ptr< VaseFlower >; using VaseFlowerPtr = std::shared_ptr< VaseFlower >;
using VFXPtr = boost::shared_ptr< VFX >; using VFXPtr = std::shared_ptr< VFX >;
using WarpPtr = boost::shared_ptr< Warp >; using WarpPtr = std::shared_ptr< Warp >;
using WarpConditionPtr = boost::shared_ptr< WarpCondition >; using WarpConditionPtr = std::shared_ptr< WarpCondition >;
using WarpLogicPtr = boost::shared_ptr< WarpLogic >; using WarpLogicPtr = std::shared_ptr< WarpLogic >;
using WeatherPtr = boost::shared_ptr< Weather >; using WeatherPtr = std::shared_ptr< Weather >;
using WeatherGroupPtr = boost::shared_ptr< WeatherGroup >; using WeatherGroupPtr = std::shared_ptr< WeatherGroup >;
using WeatherRatePtr = boost::shared_ptr< WeatherRate >; using WeatherRatePtr = std::shared_ptr< WeatherRate >;
using WeddingBGMPtr = boost::shared_ptr< WeddingBGM >; using WeddingBGMPtr = std::shared_ptr< WeddingBGM >;
using WeeklyBingoOrderDataPtr = boost::shared_ptr< WeeklyBingoOrderData >; using WeeklyBingoOrderDataPtr = std::shared_ptr< WeeklyBingoOrderData >;
using WeeklyBingoRewardDataPtr = boost::shared_ptr< WeeklyBingoRewardData >; using WeeklyBingoRewardDataPtr = std::shared_ptr< WeeklyBingoRewardData >;
using WeeklyBingoTextPtr = boost::shared_ptr< WeeklyBingoText >; using WeeklyBingoTextPtr = std::shared_ptr< WeeklyBingoText >;
using WeeklyLotBonusPtr = boost::shared_ptr< WeeklyLotBonus >; using WeeklyLotBonusPtr = std::shared_ptr< WeeklyLotBonus >;
using WorldPtr = boost::shared_ptr< World >; using WorldPtr = std::shared_ptr< World >;
using WorldDCGroupTypePtr = boost::shared_ptr< WorldDCGroupType >; using WorldDCGroupTypePtr = std::shared_ptr< WorldDCGroupType >;
using YKWPtr = boost::shared_ptr< YKW >; using YKWPtr = std::shared_ptr< YKW >;
using ZoneSharedGroupPtr = boost::shared_ptr< ZoneSharedGroup >; using ZoneSharedGroupPtr = std::shared_ptr< ZoneSharedGroup >;
template< class T > template< class T >
boost::shared_ptr< T > get( uint32_t id ) std::shared_ptr< T > get( uint32_t id )
{ {
try try
{ {
auto info = boost::make_shared< T >( id, this ); auto info = std::make_shared< T >( id, this );
return info; return info;
} }
catch( ... ) catch( ... )

2
src/common/Network/PacketContainer.h
View file

@ -12,7 +12,7 @@ namespace Core {
namespace Network { namespace Network {
namespace Packets { namespace Packets {
typedef boost::shared_ptr< FFXIVPacketBase > FFXIVPacketBasePtr; typedef std::shared_ptr< FFXIVPacketBase > FFXIVPacketBasePtr;
class PacketContainer class PacketContainer
{ {