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

Cleaned up generated exd stuff

Browse source
This commit is contained in:
Mordred Admin 2018-02-14 12:31:47 +01:00
parent 8bcd5f8fe5
commit df61b53d1a
31 changed files with 4265 additions and 8497 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

File diff suppressed because it is too large Load diff

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

@ -11,6 +11,7 @@
#include <ExdCat.h>
#include <Exd.h>
#include <set>
#include <boost/make_shared.hpp>
namespace Core {
namespace Data {
@ -244,7 +245,9 @@ struct Omen;
struct OnlineStatus;
struct Opening;
struct Orchestrion;
struct OrchestrionCategory;
struct OrchestrionPath;
struct OrchestrionUiparam;
struct ParamGrow;
struct Pet;
struct PetAction;
@ -286,6 +289,9 @@ struct SpecialShopItemCategory;
struct Stain;
struct Status;
struct Story;
struct SubmarineExploration;
struct SubmarinePart;
struct SubmarineRank;
struct SwitchTalk;
struct TerritoryType;
struct TextCommand;
@ -490,7 +496,6 @@ struct Aetheryte
uint16_t placeName;
uint16_t aethernetName;
uint16_t territory;
uint32_t destination;
bool isAetheryte;
uint8_t aethernetGroup;
uint16_t map;
@ -2297,6 +2302,7 @@ struct Leve
int32_t placeNameStart;
int32_t placeNameIssued;
uint8_t classJobCategory;
int32_t journalGenre;
int32_t placeNameStartZone;
int32_t iconCityState;
int32_t dataId;
@ -2640,6 +2646,13 @@ struct Orchestrion
Orchestrion( uint32_t row_id, Core::Data::ExdDataGenerated* exdData );
};
struct OrchestrionCategory
{
std::string name;
OrchestrionCategory( uint32_t row_id, Core::Data::ExdDataGenerated* exdData );
};
struct OrchestrionPath
{
std::string file;
@ -2647,6 +2660,14 @@ struct OrchestrionPath
OrchestrionPath( uint32_t row_id, Core::Data::ExdDataGenerated* exdData );
};
struct OrchestrionUiparam
{
uint8_t orchestrionCategory;
uint16_t order;
OrchestrionUiparam( uint32_t row_id, Core::Data::ExdDataGenerated* exdData );
};
struct ParamGrow
{
int32_t expToNext;
@ -3117,6 +3138,41 @@ struct Story
Story( uint32_t row_id, Core::Data::ExdDataGenerated* exdData );
};
struct SubmarineExploration
{
std::string destination;
std::string location;
uint8_t rankReq;
uint8_t ceruleumTankReq;
uint16_t durationmin;
uint8_t distanceForSurvey;
uint32_t expReward;
SubmarineExploration( uint32_t row_id, Core::Data::ExdDataGenerated* exdData );
};
struct SubmarinePart
{
uint8_t slot;
uint8_t rank;
uint8_t components;
int16_t surveillance;
int16_t retrieval;
int16_t speed;
int16_t range;
int16_t favor;
uint8_t repairMaterials;
SubmarinePart( uint32_t row_id, Core::Data::ExdDataGenerated* exdData );
};
struct SubmarineRank
{
uint32_t expToNext;
SubmarineRank( uint32_t row_id, Core::Data::ExdDataGenerated* exdData );
};
struct SwitchTalk
{
std::vector< uint32_t > quest;
@ -3666,7 +3722,9 @@ struct WorldDCGroupType
xiv::exd::Exd m_OnlineStatusDat;
xiv::exd::Exd m_OpeningDat;
xiv::exd::Exd m_OrchestrionDat;
xiv::exd::Exd m_OrchestrionCategoryDat;
xiv::exd::Exd m_OrchestrionPathDat;
xiv::exd::Exd m_OrchestrionUiparamDat;
xiv::exd::Exd m_ParamGrowDat;
xiv::exd::Exd m_PetDat;
xiv::exd::Exd m_PetActionDat;
@ -3708,6 +3766,9 @@ struct WorldDCGroupType
xiv::exd::Exd m_StainDat;
xiv::exd::Exd m_StatusDat;
xiv::exd::Exd m_StoryDat;
xiv::exd::Exd m_SubmarineExplorationDat;
xiv::exd::Exd m_SubmarinePartDat;
xiv::exd::Exd m_SubmarineRankDat;
xiv::exd::Exd m_SwitchTalkDat;
xiv::exd::Exd m_TerritoryTypeDat;
xiv::exd::Exd m_TextCommandDat;
@ -3743,607 +3804,326 @@ struct WorldDCGroupType
using AchievementPtr = boost::shared_ptr< Achievement >;
AchievementPtr getAchievement( uint32_t AchievementId );
using AchievementCategoryPtr = boost::shared_ptr< AchievementCategory >;
AchievementCategoryPtr getAchievementCategory( uint32_t AchievementCategoryId );
using AchievementKindPtr = boost::shared_ptr< AchievementKind >;
AchievementKindPtr getAchievementKind( uint32_t AchievementKindId );
using ActionPtr = boost::shared_ptr< Action >;
ActionPtr getAction( uint32_t ActionId );
using ActionCategoryPtr = boost::shared_ptr< ActionCategory >;
ActionCategoryPtr getActionCategory( uint32_t ActionCategoryId );
using ActionComboRoutePtr = boost::shared_ptr< ActionComboRoute >;
ActionComboRoutePtr getActionComboRoute( uint32_t ActionComboRouteId );
using ActionIndirectionPtr = boost::shared_ptr< ActionIndirection >;
ActionIndirectionPtr getActionIndirection( uint32_t ActionIndirectionId );
using ActionProcStatusPtr = boost::shared_ptr< ActionProcStatus >;
ActionProcStatusPtr getActionProcStatus( uint32_t ActionProcStatusId );
using ActionTimelinePtr = boost::shared_ptr< ActionTimeline >;
ActionTimelinePtr getActionTimeline( uint32_t ActionTimelineId );
using ActionTransientPtr = boost::shared_ptr< ActionTransient >;
ActionTransientPtr getActionTransient( uint32_t ActionTransientId );
using AddonPtr = boost::shared_ptr< Addon >;
AddonPtr getAddon( uint32_t AddonId );
using AdventurePtr = boost::shared_ptr< Adventure >;
AdventurePtr getAdventure( uint32_t AdventureId );
using AdventureExPhasePtr = boost::shared_ptr< AdventureExPhase >;
AdventureExPhasePtr getAdventureExPhase( uint32_t AdventureExPhaseId );
using AetherCurrentPtr = boost::shared_ptr< AetherCurrent >;
AetherCurrentPtr getAetherCurrent( uint32_t AetherCurrentId );
using AetherialWheelPtr = boost::shared_ptr< AetherialWheel >;
AetherialWheelPtr getAetherialWheel( uint32_t AetherialWheelId );
using AetherytePtr = boost::shared_ptr< Aetheryte >;
AetherytePtr getAetheryte( uint32_t AetheryteId );
using AirshipExplorationLevelPtr = boost::shared_ptr< AirshipExplorationLevel >;
AirshipExplorationLevelPtr getAirshipExplorationLevel( uint32_t AirshipExplorationLevelId );
using AirshipExplorationLogPtr = boost::shared_ptr< AirshipExplorationLog >;
AirshipExplorationLogPtr getAirshipExplorationLog( uint32_t AirshipExplorationLogId );
using AirshipExplorationParamTypePtr = boost::shared_ptr< AirshipExplorationParamType >;
AirshipExplorationParamTypePtr getAirshipExplorationParamType( uint32_t AirshipExplorationParamTypeId );
using AirshipExplorationPartPtr = boost::shared_ptr< AirshipExplorationPart >;
AirshipExplorationPartPtr getAirshipExplorationPart( uint32_t AirshipExplorationPartId );
using AirshipExplorationPointPtr = boost::shared_ptr< AirshipExplorationPoint >;
AirshipExplorationPointPtr getAirshipExplorationPoint( uint32_t AirshipExplorationPointId );
using AnimaWeapon5Ptr = boost::shared_ptr< AnimaWeapon5 >;
AnimaWeapon5Ptr getAnimaWeapon5( uint32_t AnimaWeapon5Id );
using AnimaWeapon5ParamPtr = boost::shared_ptr< AnimaWeapon5Param >;
AnimaWeapon5ParamPtr getAnimaWeapon5Param( uint32_t AnimaWeapon5ParamId );
using AnimaWeapon5PatternGroupPtr = boost::shared_ptr< AnimaWeapon5PatternGroup >;
AnimaWeapon5PatternGroupPtr getAnimaWeapon5PatternGroup( uint32_t AnimaWeapon5PatternGroupId );
using AnimaWeapon5SpiritTalkPtr = boost::shared_ptr< AnimaWeapon5SpiritTalk >;
AnimaWeapon5SpiritTalkPtr getAnimaWeapon5SpiritTalk( uint32_t AnimaWeapon5SpiritTalkId );
using AnimaWeapon5SpiritTalkParamPtr = boost::shared_ptr< AnimaWeapon5SpiritTalkParam >;
AnimaWeapon5SpiritTalkParamPtr getAnimaWeapon5SpiritTalkParam( uint32_t AnimaWeapon5SpiritTalkParamId );
using AnimaWeapon5TradeItemPtr = boost::shared_ptr< AnimaWeapon5TradeItem >;
AnimaWeapon5TradeItemPtr getAnimaWeapon5TradeItem( uint32_t AnimaWeapon5TradeItemId );
using AnimaWeaponFUITalkPtr = boost::shared_ptr< AnimaWeaponFUITalk >;
AnimaWeaponFUITalkPtr getAnimaWeaponFUITalk( uint32_t AnimaWeaponFUITalkId );
using AnimaWeaponFUITalkParamPtr = boost::shared_ptr< AnimaWeaponFUITalkParam >;
AnimaWeaponFUITalkParamPtr getAnimaWeaponFUITalkParam( uint32_t AnimaWeaponFUITalkParamId );
using AnimaWeaponIconPtr = boost::shared_ptr< AnimaWeaponIcon >;
AnimaWeaponIconPtr getAnimaWeaponIcon( uint32_t AnimaWeaponIconId );
using AnimaWeaponItemPtr = boost::shared_ptr< AnimaWeaponItem >;
AnimaWeaponItemPtr getAnimaWeaponItem( uint32_t AnimaWeaponItemId );
using AquariumFishPtr = boost::shared_ptr< AquariumFish >;
AquariumFishPtr getAquariumFish( uint32_t AquariumFishId );
using AquariumWaterPtr = boost::shared_ptr< AquariumWater >;
AquariumWaterPtr getAquariumWater( uint32_t AquariumWaterId );
using AttackTypePtr = boost::shared_ptr< AttackType >;
AttackTypePtr getAttackType( uint32_t AttackTypeId );
using BalloonPtr = boost::shared_ptr< Balloon >;
BalloonPtr getBalloon( uint32_t BalloonId );
using BaseParamPtr = boost::shared_ptr< BaseParam >;
BaseParamPtr getBaseParam( uint32_t BaseParamId );
using BattleLevePtr = boost::shared_ptr< BattleLeve >;
BattleLevePtr getBattleLeve( uint32_t BattleLeveId );
using BeastRankBonusPtr = boost::shared_ptr< BeastRankBonus >;
BeastRankBonusPtr getBeastRankBonus( uint32_t BeastRankBonusId );
using BeastReputationRankPtr = boost::shared_ptr< BeastReputationRank >;
BeastReputationRankPtr getBeastReputationRank( uint32_t BeastReputationRankId );
using BeastTribePtr = boost::shared_ptr< BeastTribe >;
BeastTribePtr getBeastTribe( uint32_t BeastTribeId );
using BehaviorPtr = boost::shared_ptr< Behavior >;
BehaviorPtr getBehavior( uint32_t BehaviorId );
using BGMPtr = boost::shared_ptr< BGM >;
BGMPtr getBGM( uint32_t BGMId );
using BNpcAnnounceIconPtr = boost::shared_ptr< BNpcAnnounceIcon >;
BNpcAnnounceIconPtr getBNpcAnnounceIcon( uint32_t BNpcAnnounceIconId );
using BNpcBasePtr = boost::shared_ptr< BNpcBase >;
BNpcBasePtr getBNpcBase( uint32_t BNpcBaseId );
using BNpcCustomizePtr = boost::shared_ptr< BNpcCustomize >;
BNpcCustomizePtr getBNpcCustomize( uint32_t BNpcCustomizeId );
using BNpcNamePtr = boost::shared_ptr< BNpcName >;
BNpcNamePtr getBNpcName( uint32_t BNpcNameId );
using BuddyActionPtr = boost::shared_ptr< BuddyAction >;
BuddyActionPtr getBuddyAction( uint32_t BuddyActionId );
using BuddyEquipPtr = boost::shared_ptr< BuddyEquip >;
BuddyEquipPtr getBuddyEquip( uint32_t BuddyEquipId );
using BuddyItemPtr = boost::shared_ptr< BuddyItem >;
BuddyItemPtr getBuddyItem( uint32_t BuddyItemId );
using BuddyRankPtr = boost::shared_ptr< BuddyRank >;
BuddyRankPtr getBuddyRank( uint32_t BuddyRankId );
using BuddySkillPtr = boost::shared_ptr< BuddySkill >;
BuddySkillPtr getBuddySkill( uint32_t BuddySkillId );
using CabinetPtr = boost::shared_ptr< Cabinet >;
CabinetPtr getCabinet( uint32_t CabinetId );
using CabinetCategoryPtr = boost::shared_ptr< CabinetCategory >;
CabinetCategoryPtr getCabinetCategory( uint32_t CabinetCategoryId );
using CalendarPtr = boost::shared_ptr< Calendar >;
CalendarPtr getCalendar( uint32_t CalendarId );
using CharaMakeCustomizePtr = boost::shared_ptr< CharaMakeCustomize >;
CharaMakeCustomizePtr getCharaMakeCustomize( uint32_t CharaMakeCustomizeId );
using CharaMakeTypePtr = boost::shared_ptr< CharaMakeType >;
CharaMakeTypePtr getCharaMakeType( uint32_t CharaMakeTypeId );
using ChocoboRacePtr = boost::shared_ptr< ChocoboRace >;
ChocoboRacePtr getChocoboRace( uint32_t ChocoboRaceId );
using ChocoboRaceAbilityPtr = boost::shared_ptr< ChocoboRaceAbility >;
ChocoboRaceAbilityPtr getChocoboRaceAbility( uint32_t ChocoboRaceAbilityId );
using ChocoboRaceAbilityTypePtr = boost::shared_ptr< ChocoboRaceAbilityType >;
ChocoboRaceAbilityTypePtr getChocoboRaceAbilityType( uint32_t ChocoboRaceAbilityTypeId );
using ChocoboRaceItemPtr = boost::shared_ptr< ChocoboRaceItem >;
ChocoboRaceItemPtr getChocoboRaceItem( uint32_t ChocoboRaceItemId );
using ChocoboRaceRankPtr = boost::shared_ptr< ChocoboRaceRank >;
ChocoboRaceRankPtr getChocoboRaceRank( uint32_t ChocoboRaceRankId );
using ChocoboRaceStatusPtr = boost::shared_ptr< ChocoboRaceStatus >;
ChocoboRaceStatusPtr getChocoboRaceStatus( uint32_t ChocoboRaceStatusId );
using ChocoboRaceTerritoryPtr = boost::shared_ptr< ChocoboRaceTerritory >;
ChocoboRaceTerritoryPtr getChocoboRaceTerritory( uint32_t ChocoboRaceTerritoryId );
using ChocoboTaxiStandPtr = boost::shared_ptr< ChocoboTaxiStand >;
ChocoboTaxiStandPtr getChocoboTaxiStand( uint32_t ChocoboTaxiStandId );
using ClassJobPtr = boost::shared_ptr< ClassJob >;
ClassJobPtr getClassJob( uint32_t ClassJobId );
using ClassJobCategoryPtr = boost::shared_ptr< ClassJobCategory >;
ClassJobCategoryPtr getClassJobCategory( uint32_t ClassJobCategoryId );
using CompanionPtr = boost::shared_ptr< Companion >;
CompanionPtr getCompanion( uint32_t CompanionId );
using CompanionMovePtr = boost::shared_ptr< CompanionMove >;
CompanionMovePtr getCompanionMove( uint32_t CompanionMoveId );
using CompanionTransientPtr = boost::shared_ptr< CompanionTransient >;
CompanionTransientPtr getCompanionTransient( uint32_t CompanionTransientId );
using CompanyActionPtr = boost::shared_ptr< CompanyAction >;
CompanyActionPtr getCompanyAction( uint32_t CompanyActionId );
using CompanyCraftDraftPtr = boost::shared_ptr< CompanyCraftDraft >;
CompanyCraftDraftPtr getCompanyCraftDraft( uint32_t CompanyCraftDraftId );
using CompanyCraftDraftCategoryPtr = boost::shared_ptr< CompanyCraftDraftCategory >;
CompanyCraftDraftCategoryPtr getCompanyCraftDraftCategory( uint32_t CompanyCraftDraftCategoryId );
using CompanyCraftManufactoryStatePtr = boost::shared_ptr< CompanyCraftManufactoryState >;
CompanyCraftManufactoryStatePtr getCompanyCraftManufactoryState( uint32_t CompanyCraftManufactoryStateId );
using CompanyCraftPartPtr = boost::shared_ptr< CompanyCraftPart >;
CompanyCraftPartPtr getCompanyCraftPart( uint32_t CompanyCraftPartId );
using CompanyCraftProcessPtr = boost::shared_ptr< CompanyCraftProcess >;
CompanyCraftProcessPtr getCompanyCraftProcess( uint32_t CompanyCraftProcessId );
using CompanyCraftSequencePtr = boost::shared_ptr< CompanyCraftSequence >;
CompanyCraftSequencePtr getCompanyCraftSequence( uint32_t CompanyCraftSequenceId );
using CompanyCraftSupplyItemPtr = boost::shared_ptr< CompanyCraftSupplyItem >;
CompanyCraftSupplyItemPtr getCompanyCraftSupplyItem( uint32_t CompanyCraftSupplyItemId );
using CompanyCraftTypePtr = boost::shared_ptr< CompanyCraftType >;
CompanyCraftTypePtr getCompanyCraftType( uint32_t CompanyCraftTypeId );
using CompleteJournalPtr = boost::shared_ptr< CompleteJournal >;
CompleteJournalPtr getCompleteJournal( uint32_t CompleteJournalId );
using CompleteJournalCategoryPtr = boost::shared_ptr< CompleteJournalCategory >;
CompleteJournalCategoryPtr getCompleteJournalCategory( uint32_t CompleteJournalCategoryId );
using ContentExActionPtr = boost::shared_ptr< ContentExAction >;
ContentExActionPtr getContentExAction( uint32_t ContentExActionId );
using ContentFinderConditionPtr = boost::shared_ptr< ContentFinderCondition >;
ContentFinderConditionPtr getContentFinderCondition( uint32_t ContentFinderConditionId );
using ContentFinderConditionTransientPtr = boost::shared_ptr< ContentFinderConditionTransient >;
ContentFinderConditionTransientPtr getContentFinderConditionTransient( uint32_t ContentFinderConditionTransientId );
using ContentMemberTypePtr = boost::shared_ptr< ContentMemberType >;
ContentMemberTypePtr getContentMemberType( uint32_t ContentMemberTypeId );
using ContentRoulettePtr = boost::shared_ptr< ContentRoulette >;
ContentRoulettePtr getContentRoulette( uint32_t ContentRouletteId );
using ContentTypePtr = boost::shared_ptr< ContentType >;
ContentTypePtr getContentType( uint32_t ContentTypeId );
using CraftActionPtr = boost::shared_ptr< CraftAction >;
CraftActionPtr getCraftAction( uint32_t CraftActionId );
using CraftLevePtr = boost::shared_ptr< CraftLeve >;
CraftLevePtr getCraftLeve( uint32_t CraftLeveId );
using CraftTypePtr = boost::shared_ptr< CraftType >;
CraftTypePtr getCraftType( uint32_t CraftTypeId );
using CurrencyPtr = boost::shared_ptr< Currency >;
CurrencyPtr getCurrency( uint32_t CurrencyId );
using CustomTalkPtr = boost::shared_ptr< CustomTalk >;
CustomTalkPtr getCustomTalk( uint32_t CustomTalkId );
using CutscenePtr = boost::shared_ptr< Cutscene >;
CutscenePtr getCutscene( uint32_t CutsceneId );
using CutScreenImagePtr = boost::shared_ptr< CutScreenImage >;
CutScreenImagePtr getCutScreenImage( uint32_t CutScreenImageId );
using DailySupplyItemPtr = boost::shared_ptr< DailySupplyItem >;
DailySupplyItemPtr getDailySupplyItem( uint32_t DailySupplyItemId );
using DeepDungeonBanPtr = boost::shared_ptr< DeepDungeonBan >;
DeepDungeonBanPtr getDeepDungeonBan( uint32_t DeepDungeonBanId );
using DeepDungeonDangerPtr = boost::shared_ptr< DeepDungeonDanger >;
DeepDungeonDangerPtr getDeepDungeonDanger( uint32_t DeepDungeonDangerId );
using DeepDungeonEquipmentPtr = boost::shared_ptr< DeepDungeonEquipment >;
DeepDungeonEquipmentPtr getDeepDungeonEquipment( uint32_t DeepDungeonEquipmentId );
using DeepDungeonFloorEffectUIPtr = boost::shared_ptr< DeepDungeonFloorEffectUI >;
DeepDungeonFloorEffectUIPtr getDeepDungeonFloorEffectUI( uint32_t DeepDungeonFloorEffectUIId );
using DeepDungeonItemPtr = boost::shared_ptr< DeepDungeonItem >;
DeepDungeonItemPtr getDeepDungeonItem( uint32_t DeepDungeonItemId );
using DeepDungeonStatusPtr = boost::shared_ptr< DeepDungeonStatus >;
DeepDungeonStatusPtr getDeepDungeonStatus( uint32_t DeepDungeonStatusId );
using DefaultTalkPtr = boost::shared_ptr< DefaultTalk >;
DefaultTalkPtr getDefaultTalk( uint32_t DefaultTalkId );
using DeliveryQuestPtr = boost::shared_ptr< DeliveryQuest >;
DeliveryQuestPtr getDeliveryQuest( uint32_t DeliveryQuestId );
using DisposalShopPtr = boost::shared_ptr< DisposalShop >;
DisposalShopPtr getDisposalShop( uint32_t DisposalShopId );
using DisposalShopFilterTypePtr = boost::shared_ptr< DisposalShopFilterType >;
DisposalShopFilterTypePtr getDisposalShopFilterType( uint32_t DisposalShopFilterTypeId );
using DisposalShopItemPtr = boost::shared_ptr< DisposalShopItem >;
DisposalShopItemPtr getDisposalShopItem( uint32_t DisposalShopItemId );
using DpsChallengePtr = boost::shared_ptr< DpsChallenge >;
DpsChallengePtr getDpsChallenge( uint32_t DpsChallengeId );
using DpsChallengeOfficerPtr = boost::shared_ptr< DpsChallengeOfficer >;
DpsChallengeOfficerPtr getDpsChallengeOfficer( uint32_t DpsChallengeOfficerId );
using DpsChallengeTransientPtr = boost::shared_ptr< DpsChallengeTransient >;
DpsChallengeTransientPtr getDpsChallengeTransient( uint32_t DpsChallengeTransientId );
using EmotePtr = boost::shared_ptr< Emote >;
EmotePtr getEmote( uint32_t EmoteId );
using EmoteCategoryPtr = boost::shared_ptr< EmoteCategory >;
EmoteCategoryPtr getEmoteCategory( uint32_t EmoteCategoryId );
using ENpcBasePtr = boost::shared_ptr< ENpcBase >;
ENpcBasePtr getENpcBase( uint32_t ENpcBaseId );
using ENpcResidentPtr = boost::shared_ptr< ENpcResident >;
ENpcResidentPtr getENpcResident( uint32_t ENpcResidentId );
using EObjPtr = boost::shared_ptr< EObj >;
EObjPtr getEObj( uint32_t EObjId );
using EquipRaceCategoryPtr = boost::shared_ptr< EquipRaceCategory >;
EquipRaceCategoryPtr getEquipRaceCategory( uint32_t EquipRaceCategoryId );
using EquipSlotCategoryPtr = boost::shared_ptr< EquipSlotCategory >;
EquipSlotCategoryPtr getEquipSlotCategory( uint32_t EquipSlotCategoryId );
using EventActionPtr = boost::shared_ptr< EventAction >;
EventActionPtr getEventAction( uint32_t EventActionId );
using EventIconPriorityPtr = boost::shared_ptr< EventIconPriority >;
EventIconPriorityPtr getEventIconPriority( uint32_t EventIconPriorityId );
using EventIconTypePtr = boost::shared_ptr< EventIconType >;
EventIconTypePtr getEventIconType( uint32_t EventIconTypeId );
using EventItemPtr = boost::shared_ptr< EventItem >;
EventItemPtr getEventItem( uint32_t EventItemId );
using EventItemHelpPtr = boost::shared_ptr< EventItemHelp >;
EventItemHelpPtr getEventItemHelp( uint32_t EventItemHelpId );
using ExVersionPtr = boost::shared_ptr< ExVersion >;
ExVersionPtr getExVersion( uint32_t ExVersionId );
using FatePtr = boost::shared_ptr< Fate >;
FatePtr getFate( uint32_t FateId );
using FCActivityPtr = boost::shared_ptr< FCActivity >;
FCActivityPtr getFCActivity( uint32_t FCActivityId );
using FCActivityCategoryPtr = boost::shared_ptr< FCActivityCategory >;
FCActivityCategoryPtr getFCActivityCategory( uint32_t FCActivityCategoryId );
using FCAuthorityPtr = boost::shared_ptr< FCAuthority >;
FCAuthorityPtr getFCAuthority( uint32_t FCAuthorityId );
using FCAuthorityCategoryPtr = boost::shared_ptr< FCAuthorityCategory >;
FCAuthorityCategoryPtr getFCAuthorityCategory( uint32_t FCAuthorityCategoryId );
using FCChestNamePtr = boost::shared_ptr< FCChestName >;
FCChestNamePtr getFCChestName( uint32_t FCChestNameId );
using FccShopPtr = boost::shared_ptr< FccShop >;
FccShopPtr getFccShop( uint32_t FccShopId );
using FCHierarchyPtr = boost::shared_ptr< FCHierarchy >;
FCHierarchyPtr getFCHierarchy( uint32_t FCHierarchyId );
using FCProfilePtr = boost::shared_ptr< FCProfile >;
FCProfilePtr getFCProfile( uint32_t FCProfileId );
using FCReputationPtr = boost::shared_ptr< FCReputation >;
FCReputationPtr getFCReputation( uint32_t FCReputationId );
using FCRightsPtr = boost::shared_ptr< FCRights >;
FCRightsPtr getFCRights( uint32_t FCRightsId );
using FishingSpotPtr = boost::shared_ptr< FishingSpot >;
FishingSpotPtr getFishingSpot( uint32_t FishingSpotId );
using FishParameterPtr = boost::shared_ptr< FishParameter >;
FishParameterPtr getFishParameter( uint32_t FishParameterId );
using GardeningSeedPtr = boost::shared_ptr< GardeningSeed >;
GardeningSeedPtr getGardeningSeed( uint32_t GardeningSeedId );
using GatheringConditionPtr = boost::shared_ptr< GatheringCondition >;
GatheringConditionPtr getGatheringCondition( uint32_t GatheringConditionId );
using GatheringExpPtr = boost::shared_ptr< GatheringExp >;
GatheringExpPtr getGatheringExp( uint32_t GatheringExpId );
using GatheringItemPtr = boost::shared_ptr< GatheringItem >;
GatheringItemPtr getGatheringItem( uint32_t GatheringItemId );
using GatheringItemLevelConvertTablePtr = boost::shared_ptr< GatheringItemLevelConvertTable >;
GatheringItemLevelConvertTablePtr getGatheringItemLevelConvertTable( uint32_t GatheringItemLevelConvertTableId );
using GatheringItemPointPtr = boost::shared_ptr< GatheringItemPoint >;
GatheringItemPointPtr getGatheringItemPoint( uint32_t GatheringItemPointId );
using GatheringNotebookListPtr = boost::shared_ptr< GatheringNotebookList >;
GatheringNotebookListPtr getGatheringNotebookList( uint32_t GatheringNotebookListId );
using GatheringPointPtr = boost::shared_ptr< GatheringPoint >;
GatheringPointPtr getGatheringPoint( uint32_t GatheringPointId );
using GatheringPointBasePtr = boost::shared_ptr< GatheringPointBase >;
GatheringPointBasePtr getGatheringPointBase( uint32_t GatheringPointBaseId );
using GatheringPointBonusPtr = boost::shared_ptr< GatheringPointBonus >;
GatheringPointBonusPtr getGatheringPointBonus( uint32_t GatheringPointBonusId );
using GatheringPointBonusTypePtr = boost::shared_ptr< GatheringPointBonusType >;
GatheringPointBonusTypePtr getGatheringPointBonusType( uint32_t GatheringPointBonusTypeId );
using GatheringPointNamePtr = boost::shared_ptr< GatheringPointName >;
GatheringPointNamePtr getGatheringPointName( uint32_t GatheringPointNameId );
using GatheringSubCategoryPtr = boost::shared_ptr< GatheringSubCategory >;
GatheringSubCategoryPtr getGatheringSubCategory( uint32_t GatheringSubCategoryId );
using GatheringTypePtr = boost::shared_ptr< GatheringType >;
GatheringTypePtr getGatheringType( uint32_t GatheringTypeId );
using GcArmyExpeditionPtr = boost::shared_ptr< GcArmyExpedition >;
GcArmyExpeditionPtr getGcArmyExpedition( uint32_t GcArmyExpeditionId );
using GcArmyExpeditionMemberBonusPtr = boost::shared_ptr< GcArmyExpeditionMemberBonus >;
GcArmyExpeditionMemberBonusPtr getGcArmyExpeditionMemberBonus( uint32_t GcArmyExpeditionMemberBonusId );
using GcArmyExpeditionTypePtr = boost::shared_ptr< GcArmyExpeditionType >;
GcArmyExpeditionTypePtr getGcArmyExpeditionType( uint32_t GcArmyExpeditionTypeId );
using GcArmyMemberGrowPtr = boost::shared_ptr< GcArmyMemberGrow >;
GcArmyMemberGrowPtr getGcArmyMemberGrow( uint32_t GcArmyMemberGrowId );
using GcArmyTrainingPtr = boost::shared_ptr< GcArmyTraining >;
GcArmyTrainingPtr getGcArmyTraining( uint32_t GcArmyTrainingId );
using GCRankGridaniaFemaleTextPtr = boost::shared_ptr< GCRankGridaniaFemaleText >;
GCRankGridaniaFemaleTextPtr getGCRankGridaniaFemaleText( uint32_t GCRankGridaniaFemaleTextId );
using GCRankGridaniaMaleTextPtr = boost::shared_ptr< GCRankGridaniaMaleText >;
GCRankGridaniaMaleTextPtr getGCRankGridaniaMaleText( uint32_t GCRankGridaniaMaleTextId );
using GCRankLimsaFemaleTextPtr = boost::shared_ptr< GCRankLimsaFemaleText >;
GCRankLimsaFemaleTextPtr getGCRankLimsaFemaleText( uint32_t GCRankLimsaFemaleTextId );
using GCRankLimsaMaleTextPtr = boost::shared_ptr< GCRankLimsaMaleText >;
GCRankLimsaMaleTextPtr getGCRankLimsaMaleText( uint32_t GCRankLimsaMaleTextId );
using GCRankUldahFemaleTextPtr = boost::shared_ptr< GCRankUldahFemaleText >;
GCRankUldahFemaleTextPtr getGCRankUldahFemaleText( uint32_t GCRankUldahFemaleTextId );
using GCRankUldahMaleTextPtr = boost::shared_ptr< GCRankUldahMaleText >;
GCRankUldahMaleTextPtr getGCRankUldahMaleText( uint32_t GCRankUldahMaleTextId );
using GCScripShopCategoryPtr = boost::shared_ptr< GCScripShopCategory >;
GCScripShopCategoryPtr getGCScripShopCategory( uint32_t GCScripShopCategoryId );
using GCScripShopItemPtr = boost::shared_ptr< GCScripShopItem >;
GCScripShopItemPtr getGCScripShopItem( uint32_t GCScripShopItemId );
using GCShopPtr = boost::shared_ptr< GCShop >;
GCShopPtr getGCShop( uint32_t GCShopId );
using GCShopItemCategoryPtr = boost::shared_ptr< GCShopItemCategory >;
GCShopItemCategoryPtr getGCShopItemCategory( uint32_t GCShopItemCategoryId );
using GCSupplyDutyPtr = boost::shared_ptr< GCSupplyDuty >;
GCSupplyDutyPtr getGCSupplyDuty( uint32_t GCSupplyDutyId );
using GCSupplyDutyRewardPtr = boost::shared_ptr< GCSupplyDutyReward >;
GCSupplyDutyRewardPtr getGCSupplyDutyReward( uint32_t GCSupplyDutyRewardId );
using GeneralActionPtr = boost::shared_ptr< GeneralAction >;
GeneralActionPtr getGeneralAction( uint32_t GeneralActionId );
using GilShopPtr = boost::shared_ptr< GilShop >;
GilShopPtr getGilShop( uint32_t GilShopId );
using GilShopItemPtr = boost::shared_ptr< GilShopItem >;
GilShopItemPtr getGilShopItem( uint32_t GilShopItemId );
using GoldSaucerTextDataPtr = boost::shared_ptr< GoldSaucerTextData >;
GoldSaucerTextDataPtr getGoldSaucerTextData( uint32_t GoldSaucerTextDataId );
using GrandCompanyPtr = boost::shared_ptr< GrandCompany >;
GrandCompanyPtr getGrandCompany( uint32_t GrandCompanyId );
using GrandCompanyRankPtr = boost::shared_ptr< GrandCompanyRank >;
GrandCompanyRankPtr getGrandCompanyRank( uint32_t GrandCompanyRankId );
using GuardianDeityPtr = boost::shared_ptr< GuardianDeity >;
GuardianDeityPtr getGuardianDeity( uint32_t GuardianDeityId );
using GuildleveAssignmentPtr = boost::shared_ptr< GuildleveAssignment >;
GuildleveAssignmentPtr getGuildleveAssignment( uint32_t GuildleveAssignmentId );
using GuildOrderGuidePtr = boost::shared_ptr< GuildOrderGuide >;
GuildOrderGuidePtr getGuildOrderGuide( uint32_t GuildOrderGuideId );
using GuildOrderOfficerPtr = boost::shared_ptr< GuildOrderOfficer >;
GuildOrderOfficerPtr getGuildOrderOfficer( uint32_t GuildOrderOfficerId );
using HouseRetainerPosePtr = boost::shared_ptr< HouseRetainerPose >;
HouseRetainerPosePtr getHouseRetainerPose( uint32_t HouseRetainerPoseId );
using HousingFurniturePtr = boost::shared_ptr< HousingFurniture >;
HousingFurniturePtr getHousingFurniture( uint32_t HousingFurnitureId );
using HousingYardObjectPtr = boost::shared_ptr< HousingYardObject >;
HousingYardObjectPtr getHousingYardObject( uint32_t HousingYardObjectId );
using InstanceContentPtr = boost::shared_ptr< InstanceContent >;
InstanceContentPtr getInstanceContent( uint32_t InstanceContentId );
using InstanceContentBuffPtr = boost::shared_ptr< InstanceContentBuff >;
InstanceContentBuffPtr getInstanceContentBuff( uint32_t InstanceContentBuffId );
using InstanceContentTextDataPtr = boost::shared_ptr< InstanceContentTextData >;
InstanceContentTextDataPtr getInstanceContentTextData( uint32_t InstanceContentTextDataId );
using InstanceContentTypePtr = boost::shared_ptr< InstanceContentType >;
InstanceContentTypePtr getInstanceContentType( uint32_t InstanceContentTypeId );
using ItemPtr = boost::shared_ptr< Item >;
ItemPtr getItem( uint32_t ItemId );
using ItemActionPtr = boost::shared_ptr< ItemAction >;
ItemActionPtr getItemAction( uint32_t ItemActionId );
using ItemFoodPtr = boost::shared_ptr< ItemFood >;
ItemFoodPtr getItemFood( uint32_t ItemFoodId );
using ItemSearchCategoryPtr = boost::shared_ptr< ItemSearchCategory >;
ItemSearchCategoryPtr getItemSearchCategory( uint32_t ItemSearchCategoryId );
using ItemSeriesPtr = boost::shared_ptr< ItemSeries >;
ItemSeriesPtr getItemSeries( uint32_t ItemSeriesId );
using ItemSpecialBonusPtr = boost::shared_ptr< ItemSpecialBonus >;
ItemSpecialBonusPtr getItemSpecialBonus( uint32_t ItemSpecialBonusId );
using ItemUICategoryPtr = boost::shared_ptr< ItemUICategory >;
ItemUICategoryPtr getItemUICategory( uint32_t ItemUICategoryId );
using JournalCategoryPtr = boost::shared_ptr< JournalCategory >;
JournalCategoryPtr getJournalCategory( uint32_t JournalCategoryId );
using JournalGenrePtr = boost::shared_ptr< JournalGenre >;
JournalGenrePtr getJournalGenre( uint32_t JournalGenreId );
using JournalSectionPtr = boost::shared_ptr< JournalSection >;
JournalSectionPtr getJournalSection( uint32_t JournalSectionId );
using LevePtr = boost::shared_ptr< Leve >;
LevePtr getLeve( uint32_t LeveId );
using LeveAssignmentTypePtr = boost::shared_ptr< LeveAssignmentType >;
LeveAssignmentTypePtr getLeveAssignmentType( uint32_t LeveAssignmentTypeId );
using LeveClientPtr = boost::shared_ptr< LeveClient >;
LeveClientPtr getLeveClient( uint32_t LeveClientId );
using LevelPtr = boost::shared_ptr< Level >;
LevelPtr getLevel( uint32_t LevelId );
using LeveRewardItemPtr = boost::shared_ptr< LeveRewardItem >;
LeveRewardItemPtr getLeveRewardItem( uint32_t LeveRewardItemId );
using LeveRewardItemGroupPtr = boost::shared_ptr< LeveRewardItemGroup >;
LeveRewardItemGroupPtr getLeveRewardItemGroup( uint32_t LeveRewardItemGroupId );
using LeveVfxPtr = boost::shared_ptr< LeveVfx >;
LeveVfxPtr getLeveVfx( uint32_t LeveVfxId );
using LogFilterPtr = boost::shared_ptr< LogFilter >;
LogFilterPtr getLogFilter( uint32_t LogFilterId );
using LogKindPtr = boost::shared_ptr< LogKind >;
LogKindPtr getLogKind( uint32_t LogKindId );
using LogKindCategoryTextPtr = boost::shared_ptr< LogKindCategoryText >;
LogKindCategoryTextPtr getLogKindCategoryText( uint32_t LogKindCategoryTextId );
using LogMessagePtr = boost::shared_ptr< LogMessage >;
LogMessagePtr getLogMessage( uint32_t LogMessageId );
using MacroIconPtr = boost::shared_ptr< MacroIcon >;
MacroIconPtr getMacroIcon( uint32_t MacroIconId );
using MacroIconRedirectOldPtr = boost::shared_ptr< MacroIconRedirectOld >;
MacroIconRedirectOldPtr getMacroIconRedirectOld( uint32_t MacroIconRedirectOldId );
using MainCommandPtr = boost::shared_ptr< MainCommand >;
MainCommandPtr getMainCommand( uint32_t MainCommandId );
using MainCommandCategoryPtr = boost::shared_ptr< MainCommandCategory >;
MainCommandCategoryPtr getMainCommandCategory( uint32_t MainCommandCategoryId );
using MapPtr = boost::shared_ptr< Map >;
MapPtr getMap( uint32_t MapId );
using MapMarkerPtr = boost::shared_ptr< MapMarker >;
MapMarkerPtr getMapMarker( uint32_t MapMarkerId );
using MapSymbolPtr = boost::shared_ptr< MapSymbol >;
MapSymbolPtr getMapSymbol( uint32_t MapSymbolId );
using MasterpieceSupplyDutyPtr = boost::shared_ptr< MasterpieceSupplyDuty >;
MasterpieceSupplyDutyPtr getMasterpieceSupplyDuty( uint32_t MasterpieceSupplyDutyId );
using MasterpieceSupplyMultiplierPtr = boost::shared_ptr< MasterpieceSupplyMultiplier >;
MasterpieceSupplyMultiplierPtr getMasterpieceSupplyMultiplier( uint32_t MasterpieceSupplyMultiplierId );
using MateriaPtr = boost::shared_ptr< Materia >;
MateriaPtr getMateria( uint32_t MateriaId );
using MinionRacePtr = boost::shared_ptr< MinionRace >;
MinionRacePtr getMinionRace( uint32_t MinionRaceId );
using MinionRulesPtr = boost::shared_ptr< MinionRules >;
MinionRulesPtr getMinionRules( uint32_t MinionRulesId );
using MinionSkillTypePtr = boost::shared_ptr< MinionSkillType >;
MinionSkillTypePtr getMinionSkillType( uint32_t MinionSkillTypeId );
using MobHuntTargetPtr = boost::shared_ptr< MobHuntTarget >;
MobHuntTargetPtr getMobHuntTarget( uint32_t MobHuntTargetId );
using ModelCharaPtr = boost::shared_ptr< ModelChara >;
ModelCharaPtr getModelChara( uint32_t ModelCharaId );
using MonsterNotePtr = boost::shared_ptr< MonsterNote >;
MonsterNotePtr getMonsterNote( uint32_t MonsterNoteId );
using MonsterNoteTargetPtr = boost::shared_ptr< MonsterNoteTarget >;
MonsterNoteTargetPtr getMonsterNoteTarget( uint32_t MonsterNoteTargetId );
using MountPtr = boost::shared_ptr< Mount >;
MountPtr getMount( uint32_t MountId );
using MountActionPtr = boost::shared_ptr< MountAction >;
MountActionPtr getMountAction( uint32_t MountActionId );
using NpcEquipPtr = boost::shared_ptr< NpcEquip >;
NpcEquipPtr getNpcEquip( uint32_t NpcEquipId );
using OmenPtr = boost::shared_ptr< Omen >;
OmenPtr getOmen( uint32_t OmenId );
using OnlineStatusPtr = boost::shared_ptr< OnlineStatus >;
OnlineStatusPtr getOnlineStatus( uint32_t OnlineStatusId );
using OpeningPtr = boost::shared_ptr< Opening >;
OpeningPtr getOpening( uint32_t OpeningId );
using OrchestrionPtr = boost::shared_ptr< Orchestrion >;
OrchestrionPtr getOrchestrion( uint32_t OrchestrionId );
using OrchestrionCategoryPtr = boost::shared_ptr< OrchestrionCategory >;
using OrchestrionPathPtr = boost::shared_ptr< OrchestrionPath >;
OrchestrionPathPtr getOrchestrionPath( uint32_t OrchestrionPathId );
using OrchestrionUiparamPtr = boost::shared_ptr< OrchestrionUiparam >;
using ParamGrowPtr = boost::shared_ptr< ParamGrow >;
ParamGrowPtr getParamGrow( uint32_t ParamGrowId );
using PetPtr = boost::shared_ptr< Pet >;
PetPtr getPet( uint32_t PetId );
using PetActionPtr = boost::shared_ptr< PetAction >;
PetActionPtr getPetAction( uint32_t PetActionId );
using PicturePtr = boost::shared_ptr< Picture >;
PicturePtr getPicture( uint32_t PictureId );
using PlaceNamePtr = boost::shared_ptr< PlaceName >;
PlaceNamePtr getPlaceName( uint32_t PlaceNameId );
using QuestPtr = boost::shared_ptr< Quest >;
QuestPtr getQuest( uint32_t QuestId );
using QuestRewardOtherPtr = boost::shared_ptr< QuestRewardOther >;
QuestRewardOtherPtr getQuestRewardOther( uint32_t QuestRewardOtherId );
using QuickChatPtr = boost::shared_ptr< QuickChat >;
QuickChatPtr getQuickChat( uint32_t QuickChatId );
using QuickChatTransientPtr = boost::shared_ptr< QuickChatTransient >;
QuickChatTransientPtr getQuickChatTransient( uint32_t QuickChatTransientId );
using RacePtr = boost::shared_ptr< Race >;
RacePtr getRace( uint32_t RaceId );
using RacingChocoboItemPtr = boost::shared_ptr< RacingChocoboItem >;
RacingChocoboItemPtr getRacingChocoboItem( uint32_t RacingChocoboItemId );
using RacingChocoboNamePtr = boost::shared_ptr< RacingChocoboName >;
RacingChocoboNamePtr getRacingChocoboName( uint32_t RacingChocoboNameId );
using RacingChocoboNameCategoryPtr = boost::shared_ptr< RacingChocoboNameCategory >;
RacingChocoboNameCategoryPtr getRacingChocoboNameCategory( uint32_t RacingChocoboNameCategoryId );
using RacingChocoboNameInfoPtr = boost::shared_ptr< RacingChocoboNameInfo >;
RacingChocoboNameInfoPtr getRacingChocoboNameInfo( uint32_t RacingChocoboNameInfoId );
using RacingChocoboParamPtr = boost::shared_ptr< RacingChocoboParam >;
RacingChocoboParamPtr getRacingChocoboParam( uint32_t RacingChocoboParamId );
using RecipePtr = boost::shared_ptr< Recipe >;
RecipePtr getRecipe( uint32_t RecipeId );
using RecipeElementPtr = boost::shared_ptr< RecipeElement >;
RecipeElementPtr getRecipeElement( uint32_t RecipeElementId );
using RecipeLevelTablePtr = boost::shared_ptr< RecipeLevelTable >;
RecipeLevelTablePtr getRecipeLevelTable( uint32_t RecipeLevelTableId );
using RecipeNotebookListPtr = boost::shared_ptr< RecipeNotebookList >;
RecipeNotebookListPtr getRecipeNotebookList( uint32_t RecipeNotebookListId );
using RelicPtr = boost::shared_ptr< Relic >;
RelicPtr getRelic( uint32_t RelicId );
using Relic3Ptr = boost::shared_ptr< Relic3 >;
Relic3Ptr getRelic3( uint32_t Relic3Id );
using RelicItemPtr = boost::shared_ptr< RelicItem >;
RelicItemPtr getRelicItem( uint32_t RelicItemId );
using RelicNotePtr = boost::shared_ptr< RelicNote >;
RelicNotePtr getRelicNote( uint32_t RelicNoteId );
using RelicNoteCategoryPtr = boost::shared_ptr< RelicNoteCategory >;
RelicNoteCategoryPtr getRelicNoteCategory( uint32_t RelicNoteCategoryId );
using RetainerTaskPtr = boost::shared_ptr< RetainerTask >;
RetainerTaskPtr getRetainerTask( uint32_t RetainerTaskId );
using RetainerTaskNormalPtr = boost::shared_ptr< RetainerTaskNormal >;
RetainerTaskNormalPtr getRetainerTaskNormal( uint32_t RetainerTaskNormalId );
using RetainerTaskParameterPtr = boost::shared_ptr< RetainerTaskParameter >;
RetainerTaskParameterPtr getRetainerTaskParameter( uint32_t RetainerTaskParameterId );
using RetainerTaskRandomPtr = boost::shared_ptr< RetainerTaskRandom >;
RetainerTaskRandomPtr getRetainerTaskRandom( uint32_t RetainerTaskRandomId );
using SalvagePtr = boost::shared_ptr< Salvage >;
SalvagePtr getSalvage( uint32_t SalvageId );
using SatisfactionNpcPtr = boost::shared_ptr< SatisfactionNpc >;
SatisfactionNpcPtr getSatisfactionNpc( uint32_t SatisfactionNpcId );
using SatisfactionSupplyPtr = boost::shared_ptr< SatisfactionSupply >;
SatisfactionSupplyPtr getSatisfactionSupply( uint32_t SatisfactionSupplyId );
using SatisfactionSupplyRewardPtr = boost::shared_ptr< SatisfactionSupplyReward >;
SatisfactionSupplyRewardPtr getSatisfactionSupplyReward( uint32_t SatisfactionSupplyRewardId );
using ScreenImagePtr = boost::shared_ptr< ScreenImage >;
ScreenImagePtr getScreenImage( uint32_t ScreenImageId );
using SecretRecipeBookPtr = boost::shared_ptr< SecretRecipeBook >;
SecretRecipeBookPtr getSecretRecipeBook( uint32_t SecretRecipeBookId );
using SpearfishingItemPtr = boost::shared_ptr< SpearfishingItem >;
SpearfishingItemPtr getSpearfishingItem( uint32_t SpearfishingItemId );
using SpearfishingNotebookPtr = boost::shared_ptr< SpearfishingNotebook >;
SpearfishingNotebookPtr getSpearfishingNotebook( uint32_t SpearfishingNotebookId );
using SpecialShopPtr = boost::shared_ptr< SpecialShop >;
SpecialShopPtr getSpecialShop( uint32_t SpecialShopId );
using SpecialShopItemCategoryPtr = boost::shared_ptr< SpecialShopItemCategory >;
SpecialShopItemCategoryPtr getSpecialShopItemCategory( uint32_t SpecialShopItemCategoryId );
using StainPtr = boost::shared_ptr< Stain >;
StainPtr getStain( uint32_t StainId );
using StatusPtr = boost::shared_ptr< Status >;
StatusPtr getStatus( uint32_t StatusId );
using StoryPtr = boost::shared_ptr< Story >;
StoryPtr getStory( uint32_t StoryId );
using SubmarineExplorationPtr = boost::shared_ptr< SubmarineExploration >;
using SubmarinePartPtr = boost::shared_ptr< SubmarinePart >;
using SubmarineRankPtr = boost::shared_ptr< SubmarineRank >;
using SwitchTalkPtr = boost::shared_ptr< SwitchTalk >;
SwitchTalkPtr getSwitchTalk( uint32_t SwitchTalkId );
using TerritoryTypePtr = boost::shared_ptr< TerritoryType >;
TerritoryTypePtr getTerritoryType( uint32_t TerritoryTypeId );
using TextCommandPtr = boost::shared_ptr< TextCommand >;
TextCommandPtr getTextCommand( uint32_t TextCommandId );
using TitlePtr = boost::shared_ptr< Title >;
TitlePtr getTitle( uint32_t TitleId );
using TomestonesPtr = boost::shared_ptr< Tomestones >;
TomestonesPtr getTomestones( uint32_t TomestonesId );
using TomestonesItemPtr = boost::shared_ptr< TomestonesItem >;
TomestonesItemPtr getTomestonesItem( uint32_t TomestonesItemId );
using TopicSelectPtr = boost::shared_ptr< TopicSelect >;
TopicSelectPtr getTopicSelect( uint32_t TopicSelectId );
using TownPtr = boost::shared_ptr< Town >;
TownPtr getTown( uint32_t TownId );
using TraitPtr = boost::shared_ptr< Trait >;
TraitPtr getTrait( uint32_t TraitId );
using TraitRecastPtr = boost::shared_ptr< TraitRecast >;
TraitRecastPtr getTraitRecast( uint32_t TraitRecastId );
using TraitTransientPtr = boost::shared_ptr< TraitTransient >;
TraitTransientPtr getTraitTransient( uint32_t TraitTransientId );
using TreasureHuntRankPtr = boost::shared_ptr< TreasureHuntRank >;
TreasureHuntRankPtr getTreasureHuntRank( uint32_t TreasureHuntRankId );
using TribePtr = boost::shared_ptr< Tribe >;
TribePtr getTribe( uint32_t TribeId );
using TripleTriadPtr = boost::shared_ptr< TripleTriad >;
TripleTriadPtr getTripleTriad( uint32_t TripleTriadId );
using TripleTriadCardPtr = boost::shared_ptr< TripleTriadCard >;
TripleTriadCardPtr getTripleTriadCard( uint32_t TripleTriadCardId );
using TripleTriadCardRarityPtr = boost::shared_ptr< TripleTriadCardRarity >;
TripleTriadCardRarityPtr getTripleTriadCardRarity( uint32_t TripleTriadCardRarityId );
using TripleTriadCardResidentPtr = boost::shared_ptr< TripleTriadCardResident >;
TripleTriadCardResidentPtr getTripleTriadCardResident( uint32_t TripleTriadCardResidentId );
using TripleTriadCardTypePtr = boost::shared_ptr< TripleTriadCardType >;
TripleTriadCardTypePtr getTripleTriadCardType( uint32_t TripleTriadCardTypeId );
using TripleTriadCompetitionPtr = boost::shared_ptr< TripleTriadCompetition >;
TripleTriadCompetitionPtr getTripleTriadCompetition( uint32_t TripleTriadCompetitionId );
using TripleTriadRulePtr = boost::shared_ptr< TripleTriadRule >;
TripleTriadRulePtr getTripleTriadRule( uint32_t TripleTriadRuleId );
using TutorialPtr = boost::shared_ptr< Tutorial >;
TutorialPtr getTutorial( uint32_t TutorialId );
using TutorialDPSPtr = boost::shared_ptr< TutorialDPS >;
TutorialDPSPtr getTutorialDPS( uint32_t TutorialDPSId );
using TutorialHealerPtr = boost::shared_ptr< TutorialHealer >;
TutorialHealerPtr getTutorialHealer( uint32_t TutorialHealerId );
using TutorialTankPtr = boost::shared_ptr< TutorialTank >;
TutorialTankPtr getTutorialTank( uint32_t TutorialTankId );
using WarpPtr = boost::shared_ptr< Warp >;
WarpPtr getWarp( uint32_t WarpId );
using WeatherPtr = boost::shared_ptr< Weather >;
WeatherPtr getWeather( uint32_t WeatherId );
using WeatherGroupPtr = boost::shared_ptr< WeatherGroup >;
WeatherGroupPtr getWeatherGroup( uint32_t WeatherGroupId );
using WeatherRatePtr = boost::shared_ptr< WeatherRate >;
WeatherRatePtr getWeatherRate( uint32_t WeatherRateId );
using WeeklyBingoOrderDataPtr = boost::shared_ptr< WeeklyBingoOrderData >;
WeeklyBingoOrderDataPtr getWeeklyBingoOrderData( uint32_t WeeklyBingoOrderDataId );
using WeeklyBingoRewardDataPtr = boost::shared_ptr< WeeklyBingoRewardData >;
WeeklyBingoRewardDataPtr getWeeklyBingoRewardData( uint32_t WeeklyBingoRewardDataId );
using WeeklyBingoTextPtr = boost::shared_ptr< WeeklyBingoText >;
WeeklyBingoTextPtr getWeeklyBingoText( uint32_t WeeklyBingoTextId );
using WorldDCGroupTypePtr = boost::shared_ptr< WorldDCGroupType >;
WorldDCGroupTypePtr getWorldDCGroupType( uint32_t WorldDCGroupTypeId );
template< class T >
boost::shared_ptr< T > get( uint32_t id )
{
try
{
auto info = boost::make_shared< T >( id, this );
return info;
}
catch( ... )
{
return nullptr;
}
return nullptr;
}
std::set< uint32_t > m_AchievementIdList;
@ -4573,7 +4353,9 @@ struct WorldDCGroupType
std::set< uint32_t > m_OnlineStatusIdList;
std::set< uint32_t > m_OpeningIdList;
std::set< uint32_t > m_OrchestrionIdList;
std::set< uint32_t > m_OrchestrionCategoryIdList;
std::set< uint32_t > m_OrchestrionPathIdList;
std::set< uint32_t > m_OrchestrionUiparamIdList;
std::set< uint32_t > m_ParamGrowIdList;
std::set< uint32_t > m_PetIdList;
std::set< uint32_t > m_PetActionIdList;
@ -4615,6 +4397,9 @@ struct WorldDCGroupType
std::set< uint32_t > m_StainIdList;
std::set< uint32_t > m_StatusIdList;
std::set< uint32_t > m_StoryIdList;
std::set< uint32_t > m_SubmarineExplorationIdList;
std::set< uint32_t > m_SubmarinePartIdList;
std::set< uint32_t > m_SubmarineRankIdList;
std::set< uint32_t > m_SwitchTalkIdList;
std::set< uint32_t > m_TerritoryTypeIdList;
std::set< uint32_t > m_TextCommandIdList;
@ -6011,12 +5796,24 @@ const std::set< uint32_t >& getOrchestrionIdList()
loadIdList( m_OrchestrionDat, m_OrchestrionIdList );
return m_OrchestrionIdList;
}
const std::set< uint32_t >& getOrchestrionCategoryIdList()
{
if( m_OrchestrionCategoryIdList.size() == 0 )
loadIdList( m_OrchestrionCategoryDat, m_OrchestrionCategoryIdList );
return m_OrchestrionCategoryIdList;
}
const std::set< uint32_t >& getOrchestrionPathIdList()
{
if( m_OrchestrionPathIdList.size() == 0 )
loadIdList( m_OrchestrionPathDat, m_OrchestrionPathIdList );
return m_OrchestrionPathIdList;
}
const std::set< uint32_t >& getOrchestrionUiparamIdList()
{
if( m_OrchestrionUiparamIdList.size() == 0 )
loadIdList( m_OrchestrionUiparamDat, m_OrchestrionUiparamIdList );
return m_OrchestrionUiparamIdList;
}
const std::set< uint32_t >& getParamGrowIdList()
{
if( m_ParamGrowIdList.size() == 0 )
@ -6263,6 +6060,24 @@ const std::set< uint32_t >& getStoryIdList()
loadIdList( m_StoryDat, m_StoryIdList );
return m_StoryIdList;
}
const std::set< uint32_t >& getSubmarineExplorationIdList()
{
if( m_SubmarineExplorationIdList.size() == 0 )
loadIdList( m_SubmarineExplorationDat, m_SubmarineExplorationIdList );
return m_SubmarineExplorationIdList;
}
const std::set< uint32_t >& getSubmarinePartIdList()
{
if( m_SubmarinePartIdList.size() == 0 )
loadIdList( m_SubmarinePartDat, m_SubmarinePartIdList );
return m_SubmarinePartIdList;
}
const std::set< uint32_t >& getSubmarineRankIdList()
{
if( m_SubmarineRankIdList.size() == 0 )
loadIdList( m_SubmarineRankDat, m_SubmarineRankIdList );
return m_SubmarineRankIdList;
}
const std::set< uint32_t >& getSwitchTalkIdList()
{
if( m_SwitchTalkIdList.size() == 0 )

6
src/servers/sapphire_api/PlayerMinimal.cpp
View file

@ -220,7 +220,7 @@ namespace Core {
// CharacterId, ClassIdx, Exp, Lvl
auto stmtClass = g_charaDb.getPreparedStatement( Db::CharaDbStatements::CHARA_CLASS_INS );
stmtClass->setInt( 1, m_id );
stmtClass->setInt( 2, g_exdDataGen.getClassJob( m_class )->expArrayIndex );
stmtClass->setInt( 2, g_exdDataGen.get< Core::Data::ClassJob >( m_class )->expArrayIndex );
stmtClass->setInt( 3, 0 );
stmtClass->setInt( 4, 1 );
g_charaDb.directExecute( stmtClass );
@ -292,14 +292,14 @@ namespace Core {
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SETUP EQUIPMENT / STARTING GEAR
auto classJobInfo = g_exdDataGen.getClassJob( m_class );
auto classJobInfo = g_exdDataGen.get< Core::Data::ClassJob >( m_class );
uint32_t weaponId = classJobInfo->itemStartingWeapon;
uint64_t uniqueId = getNextUId64();
uint8_t race = customize[CharaLook::Race];
uint8_t gender = customize[CharaLook::Gender];
auto raceInfo = g_exdDataGen.getRace( race );
auto raceInfo = g_exdDataGen.get< Core::Data::Race >( race );
uint32_t body;
uint32_t hands;

2
src/servers/sapphire_api/main.cpp
View file

@ -241,7 +241,7 @@ std::string buildHttpResponse( uint16_t rCode, const std::string& content = "",
void getZoneName( shared_ptr<HttpServer::Response> response, shared_ptr<HttpServer::Request> request )
{
string number = request->path_match[1];
auto info = g_exdDataGen.getTerritoryType( atoi( number.c_str() ) );
auto info = g_exdDataGen.get< Core::Data::TerritoryType >( atoi( number.c_str() ) );
std::string responseStr = "Not found!";
if( info )
responseStr = info->name + ", " + info->bg;

2
src/servers/sapphire_zone/Action/ActionCast.cpp
View file

@ -31,7 +31,7 @@ Core::Action::ActionCast::ActionCast( Entity::ActorPtr pActor, Entity::ActorPtr
m_startTime = 0;
m_id = actionId;
m_handleActionType = HandleActionType::Spell;
m_castTime = g_exdDataGen.getAction( actionId )->cast100ms * 100; // TODO: Add security checks.
m_castTime = g_exdDataGen.get< Core::Data::Action >( actionId )->cast100ms * 100; // TODO: Add security checks.
m_pSource = pActor;
m_pTarget = pTarget;
m_bInterrupt = false;

2
src/servers/sapphire_zone/Action/ActionTeleport.cpp
View file

@ -26,7 +26,7 @@ Core::Action::ActionTeleport::ActionTeleport( Entity::ActorPtr pActor, uint16_t
m_startTime = 0;
m_id = 5;
m_handleActionType = HandleActionType::Teleport;
m_castTime = g_exdDataGen.getAction( 5 )->cast100ms * 100; // TODO: Add security checks.
m_castTime = g_exdDataGen.get< Core::Data::Action >( 5 )->cast100ms * 100; // TODO: Add security checks.
m_pSource = pActor;
m_bInterrupt = false;
m_targetAetheryte = targetZone;

2
src/servers/sapphire_zone/Action/EventAction.cpp
View file

@ -28,7 +28,7 @@ Core::Action::EventAction::EventAction( Entity::ActorPtr pActor, uint32_t eventI
m_handleActionType = HandleActionType::Event;
m_eventId = eventId;
m_id = action;
m_castTime = g_exdDataGen.getEventAction( action )->castTime * 1000; // TODO: Add security checks.
m_castTime = g_exdDataGen.get< Core::Data::EventAction >( action )->castTime * 1000; // TODO: Add security checks.
m_onActionFinishClb = finishRef;
m_onActionInterruptClb = interruptRef;
m_pSource = pActor;

2
src/servers/sapphire_zone/Actor/Actor.cpp
View file

@ -671,7 +671,7 @@ void Core::Entity::Actor::handleScriptSkill( uint32_t type, uint16_t actionId, u
getAsPlayer()->sendDebug( "Handle script skill type: " + std::to_string( type ) );
}
auto actionInfoPtr = g_exdDataGen.getAction( actionId );
auto actionInfoPtr = g_exdDataGen.get< Core::Data::Action >( actionId );
// Todo: Effect packet generator. 90% of this is basically setting params and it's basically unreadable.
// Prepare packet. This is seemingly common for all packets in the action handler.

2
src/servers/sapphire_zone/Actor/BattleNpc.cpp
View file

@ -418,7 +418,7 @@ void Core::Entity::BattleNpc::onDeath()
auto levelDiff = static_cast< int32_t >( this->m_level ) - level;
auto cappedLevelDiff = Math::Util::clamp( levelDiff, 1, 6 );
auto expNeeded = g_exdDataGen.getParamGrow( m_level + cappedLevelDiff - 1 )->expToNext;
auto expNeeded = g_exdDataGen.get< Core::Data::ParamGrow >( m_level + cappedLevelDiff - 1 )->expToNext;
int32_t exp = 0;
// todo: arbitrary numbers pulled out of my ass

35
src/servers/sapphire_zone/Actor/Player.cpp
View file

@ -210,9 +210,9 @@ void Core::Entity::Player::calculateStats()
uint8_t level = getLevel();
uint8_t job = static_cast< uint8_t >( getClass() );
auto classInfo = g_exdDataGen.getClassJob( job );
auto tribeInfo = g_exdDataGen.getTribe( tribe );
auto paramGrowthInfo = g_exdDataGen.getParamGrow( level );
auto classInfo = g_exdDataGen.get< Core::Data::ClassJob >( job );
auto tribeInfo = g_exdDataGen.get< Core::Data::Tribe >( tribe );
auto paramGrowthInfo = g_exdDataGen.get< Core::Data::ParamGrow >( level );
// TODO: put formula somewhere else...
float base = Math::CalcStats::calculateBaseStat( getAsPlayer() );
@ -290,7 +290,7 @@ void Core::Entity::Player::sendStats()
void Core::Entity::Player::teleport( uint16_t aetheryteId, uint8_t type )
{
auto data = g_exdDataGen.getAetheryte( aetheryteId );
auto data = g_exdDataGen.get< Core::Data::Aetheryte >( aetheryteId );
if( data == nullptr )
{
@ -299,7 +299,7 @@ void Core::Entity::Player::teleport( uint16_t aetheryteId, uint8_t type )
setStateFlag( PlayerStateFlag::BetweenAreas );
auto z_pos = g_territoryMgr.getTerritoryPosition( data->destination );
auto z_pos = g_territoryMgr.getTerritoryPosition( data->territory );
Common::FFXIVARR_POSITION3 pos;
pos.x = 0;
@ -313,7 +313,8 @@ void Core::Entity::Player::teleport( uint16_t aetheryteId, uint8_t type )
rot = z_pos->getTargetRotation();
}
sendDebug( "Teleport: " + g_exdDataGen.getPlaceName( data->placeName )->name + " " + g_exdDataGen.getPlaceName( data->aethernetName )->name +
sendDebug( "Teleport: " + g_exdDataGen.get< Core::Data::PlaceName >( data->placeName )->name + " " +
g_exdDataGen.get< Core::Data::PlaceName >( data->aethernetName )->name +
"(" + std::to_string( data->territory ) + ")" );
// TODO: this should be simplified and a type created in server_common/common.h.
@ -492,7 +493,7 @@ void Core::Entity::Player::discover( int16_t map_id, int16_t sub_id )
int32_t offset = 4;
auto info = g_exdDataGen.getMap( g_exdDataGen.getTerritoryType( getCurrentZone()->getTerritoryId() )->map );
auto info = g_exdDataGen.get< Core::Data::Map >( g_exdDataGen.get< Core::Data::TerritoryType >( getCurrentZone()->getTerritoryId() )->map );
if( info->discoveryArrayByte )
offset = 4 + 2 * info->discoveryIndex;
else
@ -507,7 +508,7 @@ void Core::Entity::Player::discover( int16_t map_id, int16_t sub_id )
uint16_t level = getLevel();
uint32_t exp = ( g_exdDataGen.getParamGrow( level )->expToNext * 5 / 100 );
uint32_t exp = ( g_exdDataGen.get< Core::Data::ParamGrow >( level )->expToNext * 5 / 100 );
gainExp( exp );
@ -584,9 +585,9 @@ void Core::Entity::Player::gainExp( uint32_t amount )
uint16_t level = getLevel();
uint32_t neededExpToLevel = g_exdDataGen.getParamGrow( level )->expToNext;
uint32_t neededExpToLevel = g_exdDataGen.get< Core::Data::ParamGrow >( level )->expToNext;
uint32_t neededExpToLevelplus1 = g_exdDataGen.getParamGrow( level + 1 )->expToNext;
uint32_t neededExpToLevelplus1 = g_exdDataGen.get< Core::Data::ParamGrow >( level + 1 )->expToNext;
queuePacket( ActorControlPacket143( getId(), GainExpMsg, static_cast< uint8_t >( getClass() ), amount ) );
@ -670,25 +671,25 @@ void Core::Entity::Player::sendStatusUpdate( bool toSelf )
uint8_t Core::Entity::Player::getLevel() const
{
uint8_t classJobIndex = g_exdDataGen.getClassJob( static_cast< uint8_t >( getClass() ) )->expArrayIndex;
uint8_t classJobIndex = g_exdDataGen.get< Core::Data::ClassJob >( static_cast< uint8_t >( getClass() ) )->expArrayIndex;
return static_cast< uint8_t >( m_classArray[classJobIndex] );
}
uint8_t Core::Entity::Player::getLevelForClass( Common::ClassJob pClass ) const
{
uint8_t classJobIndex = g_exdDataGen.getClassJob( static_cast< uint8_t >( pClass ) )->expArrayIndex;
uint8_t classJobIndex = g_exdDataGen.get< Core::Data::ClassJob >( static_cast< uint8_t >( pClass ) )->expArrayIndex;
return static_cast< uint8_t >( m_classArray[classJobIndex] );
}
uint32_t Core::Entity::Player::getExp() const
{
uint8_t classJobIndex = g_exdDataGen.getClassJob( static_cast< uint8_t >( getClass() ) )->expArrayIndex;
uint8_t classJobIndex = g_exdDataGen.get< Core::Data::ClassJob >( static_cast< uint8_t >( getClass() ) )->expArrayIndex;
return m_expArray[classJobIndex];
}
void Core::Entity::Player::setExp( uint32_t amount )
{
uint8_t classJobIndex = g_exdDataGen.getClassJob( static_cast< uint8_t >( getClass() ) )->expArrayIndex;
uint8_t classJobIndex = g_exdDataGen.get< Core::Data::ClassJob >( static_cast< uint8_t >( getClass() ) )->expArrayIndex;
m_expArray[classJobIndex] = amount;
}
@ -728,13 +729,13 @@ void Core::Entity::Player::setClassJob( Common::ClassJob classJob )
void Core::Entity::Player::setLevel( uint8_t level )
{
uint8_t classJobIndex = g_exdDataGen.getClassJob( static_cast< uint8_t >( getClass() ) )->expArrayIndex;
uint8_t classJobIndex = g_exdDataGen.get< Core::Data::ClassJob >( static_cast< uint8_t >( getClass() ) )->expArrayIndex;
m_classArray[classJobIndex] = level;
}
void Core::Entity::Player::setLevelForClass( uint8_t level, Common::ClassJob classjob )
{
uint8_t classJobIndex = g_exdDataGen.getClassJob( static_cast< uint8_t >( classjob ) )->expArrayIndex;
uint8_t classJobIndex = g_exdDataGen.get< Core::Data::ClassJob >( static_cast< uint8_t >( classjob ) )->expArrayIndex;
if( m_classArray[classJobIndex] == 0 )
insertDbClass( classJobIndex );
@ -884,7 +885,7 @@ const uint8_t* Core::Entity::Player::getStateFlags() const
bool Core::Entity::Player::actionHasCastTime( uint32_t actionId ) //TODO: Add logic for special cases
{
auto actionInfoPtr = g_exdDataGen.getAction( actionId );
auto actionInfoPtr = g_exdDataGen.get< Core::Data::Action >( actionId );
if( actionInfoPtr->preservesCombo )
return false;

4
src/servers/sapphire_zone/Actor/PlayerQuest.cpp
View file

@ -1015,13 +1015,13 @@ void Core::Entity::Player::removeQuestsCompleted( uint32_t questId )
bool Core::Entity::Player::giveQuestRewards( uint32_t questId, uint32_t optionalChoice )
{
uint32_t playerLevel = getLevel();
auto questInfo = g_exdDataGen.getQuest( questId );
auto questInfo = g_exdDataGen.get< Core::Data::Quest >( questId );
if( !questInfo )
return false;
auto paramGrowth = g_exdDataGen.getParamGrow( questInfo->classJobLevel0 );
auto paramGrowth = g_exdDataGen.get< Core::Data::ParamGrow >( questInfo->classJobLevel0 );
// TODO: use the correct formula, this one is wrong
uint32_t exp = ( questInfo->expFactor * paramGrowth->questExpModifier * ( 45 + 5 * questInfo->classJobLevel0 ) ) / 100;

2
src/servers/sapphire_zone/Actor/PlayerSql.cpp
View file

@ -456,7 +456,7 @@ void Core::Entity::Player::updateSql()
void Core::Entity::Player::updateDbClass() const
{
uint8_t classJobIndex = g_exdDataGen.getClassJob( static_cast<uint8_t>( getClass() ) )->expArrayIndex;
uint8_t classJobIndex = g_exdDataGen.get< Core::Data::ClassJob >( static_cast<uint8_t>( getClass() ) )->expArrayIndex;
//Exp = ?, Lvl = ? WHERE CharacterId = ? AND ClassIdx = ?
auto stmtS = g_charaDb.getPreparedStatement( Db::CHARA_CLASS_UP );

2
src/servers/sapphire_zone/DebugCommand/DebugCommandHandler.cpp
View file

@ -481,7 +481,7 @@ void Core::DebugCommandHandler::get( char * data, Entity::Player& player, boost:
if( ( subCommand == "pos" ) )
{
int16_t map_id = g_exdDataGen.getTerritoryType( player.getCurrentZone()->getTerritoryId() )->map;
int16_t map_id = g_exdDataGen.get< Core::Data::TerritoryType >( player.getCurrentZone()->getTerritoryId() )->map;
player.sendNotice( "Pos:\n" +
std::to_string( player.getPos().x ) + "\n" +

10
src/servers/sapphire_zone/Event/EventHelper.cpp
View file

@ -17,7 +17,7 @@ std::string Core::Event::getEventName( uint32_t eventId )
{
case Event::EventHandler::EventHandlerType::Quest:
{
auto questInfo = g_exdDataGen.getQuest( eventId );
auto questInfo = g_exdDataGen.get< Core::Data::Quest >( eventId );
if( !questInfo )
return unknown + "Quest";
@ -28,7 +28,7 @@ std::string Core::Event::getEventName( uint32_t eventId )
}
case Event::EventHandler::EventHandlerType::CustomTalk:
{
auto customTalkInfo = g_exdDataGen.getCustomTalk( eventId );
auto customTalkInfo = g_exdDataGen.get< Core::Data::CustomTalk >( eventId );
if( !customTalkInfo )
return unknown + "CustomTalk";
@ -39,14 +39,14 @@ std::string Core::Event::getEventName( uint32_t eventId )
}
case Event::EventHandler::EventHandlerType::Opening:
{
auto openingInfo = g_exdDataGen.getOpening( eventId );
auto openingInfo = g_exdDataGen.get< Core::Data::Opening >( eventId );
if( openingInfo )
return openingInfo->name;
return unknown + "Opening";
}
case Event::EventHandler::EventHandlerType::Aetheryte:
{
auto aetherInfo = g_exdDataGen.getAetheryte( eventId & 0xFFFF );
auto aetherInfo = g_exdDataGen.get< Core::Data::Aetheryte >( eventId & 0xFFFF );
if( aetherInfo->isAetheryte )
return "Aetheryte";
return "Aethernet";
@ -65,7 +65,7 @@ std::string Core::Event::getEventName( uint32_t eventId )
uint32_t Core::Event::mapEventActorToRealActor( uint32_t eventActorId )
{
auto levelInfo = g_exdDataGen.getLevel( eventActorId );
auto levelInfo = g_exdDataGen.get< Core::Data::Level >( eventActorId );
if( levelInfo )
return levelInfo->objectKey;

6
src/servers/sapphire_zone/Inventory/Inventory.cpp
View file

@ -135,7 +135,7 @@ Core::ItemPtr Core::Inventory::getItemAt( uint16_t containerId, uint8_t slotId )
Core::ItemPtr Core::Inventory::createItem( uint32_t catalogId, uint8_t quantity )
{
auto itemInfo = g_exdDataGen.getItem( catalogId );
auto itemInfo = g_exdDataGen.get< Core::Data::Item >( catalogId );
uint8_t itemAmount = quantity;
@ -473,7 +473,7 @@ bool Core::Inventory::isObtainable( uint32_t catalogId, uint8_t quantity )
int16_t Core::Inventory::addItem( uint16_t inventoryId, int8_t slotId, uint32_t catalogId, uint8_t quantity )
{
auto itemInfo = g_exdDataGen.getItem( catalogId );
auto itemInfo = g_exdDataGen.get< Core::Data::Item >( catalogId );
// if item data doesn't exist or it's a blank field
if( !itemInfo || itemInfo->levelItem == 0 )
@ -656,7 +656,7 @@ Core::ItemPtr Core::Inventory::loadItem( uint64_t uId )
try
{
auto itemInfo = g_exdDataGen.getItem( itemRes->getUInt( 1 ) );
auto itemInfo = g_exdDataGen.get< Core::Data::Item >( itemRes->getUInt( 1 ) );
bool isHq = itemRes->getUInt( 3 ) == 1 ? true : false;
ItemPtr pItem( new Item( uId,
itemRes->getUInt( 1 ),

2
src/servers/sapphire_zone/Inventory/Item.cpp
View file

@ -24,7 +24,7 @@ Core::Item::Item( uint64_t uId, uint32_t catalogId, uint64_t model1, uint64_t mo
m_model2( model2 ),
m_isHq( isHq )
{
auto itemInfo = g_exdDataGen.getItem( catalogId );
auto itemInfo = g_exdDataGen.get< Core::Data::Item >( catalogId );
m_delayMs = itemInfo->delayms;
m_physicalDmg = itemInfo->damagePhys;
m_magicalDmg = itemInfo->damageMag;

4
src/servers/sapphire_zone/Math/CalcBattle.cpp
View file

@ -30,8 +30,8 @@ extern Core::Data::ExdDataGenerated g_exdDataGen;
uint32_t CalcBattle::calculateHealValue( PlayerPtr pPlayer, uint32_t potency )
{
auto classInfo = g_exdDataGen.getClassJob( static_cast< uint8_t >( pPlayer->getClass() ) );
auto paramGrowthInfo = g_exdDataGen.getParamGrow( pPlayer->getLevel() );
auto classInfo = g_exdDataGen.get< Core::Data::ClassJob >( static_cast< uint8_t >( pPlayer->getClass() ) );
auto paramGrowthInfo = g_exdDataGen.get< Core::Data::ParamGrow >( pPlayer->getLevel() );
if ( !classInfo || !paramGrowthInfo )
return 0;

8
src/servers/sapphire_zone/Math/CalcStats.cpp
View file

@ -61,8 +61,8 @@ uint32_t CalcStats::calculateMaxHp( PlayerPtr pPlayer )
// Is there any way to pull reliable BaseHP without having to manually use a pet for every level, and using the values from a table?
// More info here: https://docs.google.com/spreadsheets/d/1de06KGT0cNRUvyiXNmjNgcNvzBCCQku7jte5QxEQRbs/edit?usp=sharing
auto classInfo = g_exdDataGen.getClassJob( static_cast< uint8_t >( pPlayer->getClass() ) );
auto paramGrowthInfo = g_exdDataGen.getParamGrow( pPlayer->getLevel() );
auto classInfo = g_exdDataGen.get< Core::Data::ClassJob >( static_cast< uint8_t >( pPlayer->getClass() ) );
auto paramGrowthInfo = g_exdDataGen.get< Core::Data::ParamGrow >( pPlayer->getLevel() );
if ( !classInfo || !paramGrowthInfo )
return 0;
@ -94,8 +94,8 @@ uint32_t CalcStats::calculateMaxHp( PlayerPtr pPlayer )
uint32_t CalcStats::calculateMaxMp( PlayerPtr pPlayer )
{
auto classInfo = g_exdDataGen.getClassJob( static_cast< uint8_t >( pPlayer->getClass() ) );
auto paramGrowthInfo = g_exdDataGen.getParamGrow( pPlayer->getLevel() );
auto classInfo = g_exdDataGen.get< Core::Data::ClassJob >( static_cast< uint8_t >( pPlayer->getClass() ) );
auto paramGrowthInfo = g_exdDataGen.get< Core::Data::ParamGrow >( pPlayer->getLevel() );
if ( !classInfo || !paramGrowthInfo )
return 0;

4
src/servers/sapphire_zone/Network/Handlers/ActionHandler.cpp
View file

@ -200,11 +200,11 @@ void Core::Network::GameConnection::actionHandler( const Packets::GamePacket& in
case 0xCA: // Teleport
{
// TODO: only register this action if enough gil is in possession
auto targetAetheryte = g_exdDataGen.getAetheryte( param11 );
auto targetAetheryte = g_exdDataGen.get< Core::Data::Aetheryte >( param11 );
if( targetAetheryte )
{
auto fromAetheryte = g_exdDataGen.getAetheryte( g_exdDataGen.getTerritoryType( player.getZoneId() )->aetheryte );
auto fromAetheryte = g_exdDataGen.get< Core::Data::Aetheryte >( g_exdDataGen.get< Core::Data::TerritoryType >( player.getZoneId() )->aetheryte );
// calculate cost - does not apply for favorite points or homepoints neither checks for aether tickets
auto cost = static_cast< uint16_t > ( ( sqrt( pow( fromAetheryte->aetherstreamX - targetAetheryte->aetherstreamX, 2 ) +

2
src/servers/sapphire_zone/Network/Handlers/CFHandlers.cpp
View file

@ -70,7 +70,7 @@ void Core::Network::GameConnection::cfRegisterDuty( const Packets::GamePacket& i
cfCancelPacket.data().state2 = 1; // Your registration is withdrawn.
queueOutPacket( cfCancelPacket );
auto cfCondition = g_exdDataGen.getContentFinderCondition( contentId1 );
auto cfCondition = g_exdDataGen.get< Core::Data::ContentFinderCondition >( contentId1 );
if( !cfCondition )
return;

4
src/servers/sapphire_zone/Network/Handlers/EventHandlers.cpp
View file

@ -52,7 +52,7 @@ void Core::Network::GameConnection::eventHandlerTalk( const Packets::GamePacket&
if( !g_scriptMgr.onTalk( player, actorId, eventId ) &&
eventType == Event::EventHandler::EventHandlerType::Quest )
{
auto questInfo = g_exdDataGen.getQuest( eventId );
auto questInfo = g_exdDataGen.get< Core::Data::Quest >( eventId );
if ( questInfo )
player.sendUrgent( "Quest not implemented: " + questInfo->name + " (" + questInfo->id + ")" );
}
@ -87,7 +87,7 @@ void Core::Network::GameConnection::eventHandlerEmote( const Packets::GamePacket
if( !g_scriptMgr.onEmote( player, actorId, eventId, static_cast< uint8_t >( emoteId ) ) &&
eventType == Event::EventHandler::EventHandlerType::Quest )
{
auto questInfo = g_exdDataGen.getQuest( eventId );
auto questInfo = g_exdDataGen.get< Core::Data::Quest >( eventId );
if( questInfo )
player.sendUrgent( "Quest not implemented: " + questInfo->name );
}

4
src/servers/sapphire_zone/Network/Handlers/SkillHandler.cpp
View file

@ -60,7 +60,7 @@ void Core::Network::GameConnection::skillHandler( const Packets::GamePacket& inP
std::string actionIdStr = boost::str( boost::format( "%|04X|" ) % action );
player.sendDebug( "---------------------------------------" );
player.sendDebug( "ActionHandler ( " + actionIdStr + " | " +
g_exdDataGen.getAction( action )->name +
g_exdDataGen.get< Core::Data::Action >( action )->name +
" | " + std::to_string( targetId ) + " )" );
player.queuePacket( ActorControlPacket142( player.getId(), ActorControlType::ActionStart, 0x01, action ) );
@ -100,7 +100,7 @@ void Core::Network::GameConnection::skillHandler( const Packets::GamePacket& inP
}
else if( action < 3000000 ) // item action
{
auto info = g_exdDataGen.getEventItem( action );
auto info = g_exdDataGen.get< Core::Data::EventItem >( action );
if( info )
{
g_log.debug( info->name );

2
src/servers/sapphire_zone/Script/ScriptManager.cpp
View file

@ -154,7 +154,7 @@ bool Core::Scripting::ScriptManager::onTalk( Entity::Player& player, uint64_t ac
// aethernet/aetherytes need to be handled separately
if( eventType == Event::EventHandler::EventHandlerType::Aetheryte )
{
auto aetherInfo = g_exdDataGen.getAetheryte( eventId & 0xFFFF );
auto aetherInfo = g_exdDataGen.get< Core::Data::Aetheryte >( eventId & 0xFFFF );
scriptId = EVENTSCRIPT_AETHERYTE_ID;
if( !aetherInfo->isAetheryte )
scriptId = EVENTSCRIPT_AETHERNET_ID;

2
src/servers/sapphire_zone/StatusEffect/StatusEffect.cpp
View file

@ -30,7 +30,7 @@ Core::StatusEffect::StatusEffect::StatusEffect( uint32_t id, Entity::ActorPtr so
, m_tickRate( tickRate )
, m_lastTick( 0 )
{
auto entry = g_exdDataGen.getStatus( id );
auto entry = g_exdDataGen.get< Core::Data::Status >( id );
m_name = entry->name;
std::replace( m_name.begin(), m_name.end(), ' ', '_' );

8
src/servers/sapphire_zone/Zone/TerritoryMgr.cpp
View file

@ -25,7 +25,7 @@ void Core::TerritoryMgr::loadTerritoryTypeDetailCache()
for( auto id : idList )
{
auto teri1 = g_exdDataGen.getTerritoryType( id );
auto teri1 = g_exdDataGen.get< Core::Data::TerritoryType >( id );
if( !teri1->name.empty() )
m_territoryTypeDetailCacheMap[id] = teri1;
@ -106,7 +106,7 @@ bool Core::TerritoryMgr::createDefaultTerritories()
if( territoryInfo->name.empty() )
continue;
auto pPlaceName = g_exdDataGen.getPlaceName( territoryInfo->placeName );
auto pPlaceName = g_exdDataGen.get< Core::Data::PlaceName >( territoryInfo->placeName );
if( !pPlaceName || pPlaceName->name.empty() || !isDefaultTerritory( territoryId ) )
continue;
@ -142,7 +142,7 @@ Core::ZonePtr Core::TerritoryMgr::createTerritoryInstance( uint32_t territoryTyp
return nullptr;
auto pTeri = getTerritoryDetail( territoryTypeId );
auto pPlaceName = g_exdDataGen.getPlaceName( pTeri->placeName );
auto pPlaceName = g_exdDataGen.get< Core::Data::PlaceName >( pTeri->placeName );
if( !pTeri || !pPlaceName )
return nullptr;
@ -160,7 +160,7 @@ Core::ZonePtr Core::TerritoryMgr::createTerritoryInstance( uint32_t territoryTyp
Core::ZonePtr Core::TerritoryMgr::createInstanceContent( uint32_t instanceContentId )
{
auto pInstanceContent = g_exdDataGen.getInstanceContent( instanceContentId );
auto pInstanceContent = g_exdDataGen.get< Core::Data::InstanceContent >( instanceContentId );
if( !pInstanceContent )
return nullptr;

2
src/servers/sapphire_zone/Zone/Zone.cpp
View file

@ -62,7 +62,7 @@ Core::Zone::Zone( uint16_t territoryId, uint32_t guId, const std::string& intern
m_lastMobUpdate = 0;
m_weatherOverride = 0;
m_territoryTypeInfo = g_exdDataGen.getTerritoryType( territoryId );
m_territoryTypeInfo = g_exdDataGen.get< Core::Data::TerritoryType >( territoryId );
uint8_t weatherRateId = m_territoryTypeInfo->weatherRate > g_exdDataGen.getWeatherRateIdList().size() ?
uint8_t{ 0 } : m_territoryTypeInfo->weatherRate;

1
src/tools/exd_struct_gen/ExdData.h.tmpl
View file

@ -11,6 +11,7 @@
#include <ExdCat.h>
#include <Exd.h>
#include <set>
#include <boost/make_shared.hpp>
namespace Core {
namespace Data {

121
src/tools/exd_struct_gen/ex.json
View file

@ -532,10 +532,6 @@
"target": "TerritoryType"
}
},
{
"index": 11,
"name": "Destination"
},
{
"index": 15,
"name": "IsAetheryte"
@ -5888,6 +5884,14 @@
"target": "ClassJobCategory"
}
},
{
"index": 13,
"name": "JournalGenre",
"converter": {
"type": "link",
"target": "JournalGenre"
}
},
{
"index": 15,
"name": "PlaceName{StartZone}",
@ -6952,6 +6956,15 @@
}
]
},
{
"sheet": "OrchestrionCategory",
"defaultColumn": "Name",
"definitions": [
{
"name": "Name"
}
]
},
{
"sheet": "OrchestrionPath",
"definitions": [
@ -6960,6 +6973,22 @@
}
]
},
{
"sheet": "OrchestrionUiparam",
"definitions": [
{
"name": "OrchestrionCategory",
"converter": {
"type": "link",
"target": "OrchestrionCategory"
}
},
{
"index": 1,
"name": "Order"
}
]
},
{
"sheet": "ParamGrow",
"definitions": [
@ -8789,6 +8818,90 @@
"isGenericReferenceTarget": true,
"definitions": []
},
{
"sheet": "SubmarineExploration",
"defaultColumn": "Destination",
"definitions": [
{
"name": "Destination"
},
{
"index": 1,
"name": "Location"
},
{
"index": 5,
"name": "RankReq"
},
{
"index": 6,
"name": "CeruleumTankReq"
},
{
"index": 7,
"name": "Duration<min>"
},
{
"index": 8,
"name": "DistanceForSurvey"
},
{
"index": 9,
"name": "ExpReward"
}
]
},
{
"sheet": "SubmarinePart",
"defaultColumn": "Slot",
"definitions": [
{
"name": "Slot"
},
{
"index": 1,
"name": "Rank"
},
{
"index": 2,
"name": "Components"
},
{
"index": 3,
"name": "Surveillance"
},
{
"index": 4,
"name": "Retrieval"
},
{
"index": 5,
"name": "Speed"
},
{
"index": 6,
"name": "Range"
},
{
"index": 7,
"name": "Favor"
},
{
"index": 9,
"name": "RepairMaterials"
}
]
},
{
"sheet": "SubmarineRank",
"defaultColumn": "Slot",
"definitions": [
{
"index": 1,
"name": "ExpToNext"
}
]
},
{
"sheet": "SwitchTalk",
"isGenericReferenceTarget": true,

45
src/tools/exd_struct_gen/main.cpp
View file

@ -31,8 +31,8 @@ Core::Logger g_log;
Core::Data::ExdData g_exdData;
bool skipUnmapped = true;
//const std::string datLocation( "/opt/sapphire_3_15_0/bin/sqpack" );
std::string datLocation( "C:\\SquareEnix\\FINAL FANTASY XIV - A Realm Reborn\\game\\sqpack\\ffxiv" );
std::string datLocation( "/opt/sapphire_3_15_0/bin/sqpack" );
//std::string datLocation( "C:\\SquareEnix\\FINAL FANTASY XIV - A Realm Reborn\\game\\sqpack\\ffxiv" );
std::map< uint8_t, std::string > g_typeMap;
@ -48,9 +48,7 @@ std::string generateIdListDecl( const std::string &exd )
std::string generateDirectGetters( const std::string& exd )
{
return " using " + exd + "Ptr = boost::shared_ptr< " + exd + " >;\n" +
" " + exd + "Ptr get" + exd + "( uint32_t " + exd + "Id );\n";
return " using " + exd + "Ptr = boost::shared_ptr< " + exd + " >;\n";
}
std::string generateIdListGetter( const std::string &exd )
@ -77,25 +75,9 @@ std::string generateSetDatAccessCall( const std::string &exd )
return " m_" + exd + "Dat = setupDatAccess( \"" + exd + "\", " + lang + " );\n";
}
std::string generateDirectGetterDef( const std::string& exd )
std::string generateDirectGetterDef()
{
std::string result = "";
result =
"Core::Data::ExdDataGenerated::" + exd + "Ptr\n"
" Core::Data::ExdDataGenerated::get" + exd + "( uint32_t " + exd + "Id )\n"
"{\n"
" try\n"
" {\n"
" auto row = m_" + exd + "Dat.get_row( " + exd + "Id );\n"
" auto info = boost::make_shared< " + exd + " >( " + exd + "Id, this );\n"
" return info;\n"
" }\n"
" catch( ... )\n"
" {\n"
" return nullptr;\n"
" }\n"
" return nullptr;\n"
"}\n";
return result;
}
std::map< uint32_t, std::string > indexToNameMap;
@ -342,11 +324,28 @@ int main( int argc, char** argv )
idListsDecl += generateIdListDecl( name );
getterDecl += generateDirectGetters( name );
datAccCall += generateSetDatAccessCall( name );
getterDef += generateDirectGetterDef( name );
constructorDecl += generateConstructorsDecl( name );
idListGetters += generateIdListGetter( name );
}
getterDecl +=
"\n template< class T >\n"
" boost::shared_ptr< T > get( uint32_t id )\n"
" {\n"
" try\n"
" {\n"
" auto info = boost::make_shared< T >( id, this );\n"
" return info;\n"
" }\n"
" catch( ... )\n"
" {\n"
" return nullptr;\n"
" }\n"
" return nullptr;\n"
" }\n";
getterDef += generateDirectGetterDef();
// for all sheets in the json i guess....
std::string result;

1
src/tools/exd_struct_test/ExdData.h.tmpl
View file

@ -10,6 +10,7 @@
#include <ExdData.h>
#include <ExdCat.h>
#include <Exd.h>
#include <boost/make_shared.hpp>
namespace Core {
namespace Data {

12
src/tools/exd_struct_test/main.cpp
View file

@ -9,7 +9,7 @@
#include <iostream>
#include <cctype>
#include <set>
#include <common/Exd/ExdDataGenerated.h>
#include "ExdDataGenerated.h"
#include <common/Logging/Logger.h>
#include <boost/range/algorithm/remove_if.hpp>
#include <boost/algorithm/string/classification.hpp>
@ -25,8 +25,8 @@ Core::Logger g_log;
Core::Data::ExdDataGenerated g_exdData;
//const std::string datLocation( "/opt/sapphire_3_15_0/bin/sqpack" );
const std::string datLocation( "C:\\SquareEnix\\FINAL FANTASY XIV - A Realm Reborn\\game\\sqpack\\ffxiv" );
const std::string datLocation( "/opt/sapphire_3_15_0/bin/sqpack" );
//const std::string datLocation( "C:\\SquareEnix\\FINAL FANTASY XIV - A Realm Reborn\\game\\sqpack\\ffxiv" );
int main()
@ -41,14 +41,16 @@ int main()
return 0;
}
g_log.info( "getting id list " );
auto idList = g_exdData.getTerritoryTypeIdList();
g_log.info( "getting id list done" );
for( auto id : idList )
{
auto teri1 = g_exdData.getTerritoryType( id );
auto teri1 = g_exdData.get<Core::Data::TerritoryType>( id );
g_log.info( teri1->name );
g_log.info( teri1->bg );
}
return 0;