forked from mirror/openmw-tes3mp
Merge remote-tracking branch 'cfcohen/master'
This commit is contained in:
Marc Zinnschlag
commit
e4c3a75639
4 changed files with 1159 additions and 101 deletions
|
|
@ -1,5 +1,7 @@
|
|||
set(ESMTOOL
|
||||
esmtool.cpp
|
||||
labels.hpp
|
||||
labels.cpp
|
||||
record.hpp
|
||||
record.cpp
|
||||
)
|
||||
|
|
|
|||
881
apps/esmtool/labels.cpp
Normal file
881
apps/esmtool/labels.cpp
Normal file
|
|
@ -0,0 +1,881 @@
|
|||
#include "labels.hpp"
|
||||
|
||||
#include <components/esm/loadbody.hpp>
|
||||
#include <components/esm/loadcell.hpp>
|
||||
#include <components/esm/loadcont.hpp>
|
||||
#include <components/esm/loadcrea.hpp>
|
||||
#include <components/esm/loadlevlist.hpp>
|
||||
#include <components/esm/loadligh.hpp>
|
||||
#include <components/esm/loadmgef.hpp>
|
||||
#include <components/esm/loadnpc.hpp>
|
||||
#include <components/esm/loadrace.hpp>
|
||||
#include <components/esm/loadspel.hpp>
|
||||
#include <components/esm/loadweap.hpp>
|
||||
#include <components/esm/aipackage.hpp>
|
||||
|
||||
#include <iostream>
|
||||
#include <boost/format.hpp>
|
||||
|
||||
std::string bodyPartLabel(char idx)
|
||||
{
|
||||
const char *bodyPartLabels[] = {
|
||||
"Head",
|
||||
"Hair",
|
||||
"Neck",
|
||||
"Cuirass",
|
||||
"Groin",
|
||||
"Skirt",
|
||||
"Right Hand",
|
||||
"Left Hand",
|
||||
"Right Wrist",
|
||||
"Left Wrist",
|
||||
"Shield",
|
||||
"Right Forearm",
|
||||
"Left Forearm",
|
||||
"Right Upperarm",
|
||||
"Left Upperarm",
|
||||
"Right Foot",
|
||||
"Left Foot",
|
||||
"Right Ankle",
|
||||
"Left Ankle",
|
||||
"Right Knee",
|
||||
"Left Knee",
|
||||
"Right Leg",
|
||||
"Left Leg",
|
||||
"Right Shoulder",
|
||||
"Left Shoulder",
|
||||
"Weapon",
|
||||
"Tail"
|
||||
};
|
||||
|
||||
if ((int)idx >= 0 && (int)(idx) <= 26)
|
||||
return bodyPartLabels[(int)(idx)];
|
||||
else
|
||||
return "Invalid";
|
||||
}
|
||||
|
||||
std::string meshPartLabel(char idx)
|
||||
{
|
||||
const char *meshPartLabels[] = {
|
||||
"Head",
|
||||
"Hair",
|
||||
"Neck",
|
||||
"Chest",
|
||||
"Groin",
|
||||
"Hand",
|
||||
"Wrist",
|
||||
"Forearm",
|
||||
"Upperarm",
|
||||
"Foot",
|
||||
"Ankle",
|
||||
"Knee",
|
||||
"Upper Leg",
|
||||
"Clavicle",
|
||||
"Tail"
|
||||
};
|
||||
|
||||
if ((int)(idx) >= 0 && (int)(idx) <= ESM::BodyPart::MP_Tail)
|
||||
return meshPartLabels[(int)(idx)];
|
||||
else
|
||||
return "Invalid";
|
||||
}
|
||||
|
||||
std::string meshTypeLabel(char idx)
|
||||
{
|
||||
const char *meshTypeLabels[] = {
|
||||
"Skin",
|
||||
"Clothing",
|
||||
"Armor"
|
||||
};
|
||||
|
||||
if ((int)(idx) >= 0 && (int)(idx) <= ESM::BodyPart::MT_Armor)
|
||||
return meshTypeLabels[(int)(idx)];
|
||||
else
|
||||
return "Invalid";
|
||||
}
|
||||
|
||||
std::string clothingTypeLabel(int idx)
|
||||
{
|
||||
const char *clothingTypeLabels[] = {
|
||||
"Pants",
|
||||
"Shoes",
|
||||
"Shirt",
|
||||
"Belt",
|
||||
"Robe",
|
||||
"Right Glove",
|
||||
"Left Glove",
|
||||
"Skirt",
|
||||
"Ring",
|
||||
"Amulet"
|
||||
};
|
||||
|
||||
if (idx >= 0 && idx <= 9)
|
||||
return clothingTypeLabels[idx];
|
||||
else
|
||||
return "Invalid";
|
||||
}
|
||||
|
||||
std::string armorTypeLabel(int idx)
|
||||
{
|
||||
const char *armorTypeLabels[] = {
|
||||
"Helmet",
|
||||
"Cuirass",
|
||||
"Left Pauldron",
|
||||
"Right Pauldron",
|
||||
"Greaves",
|
||||
"Boots",
|
||||
"Left Gauntlet",
|
||||
"Right Gauntlet",
|
||||
"Shield",
|
||||
"Left Bracer",
|
||||
"Right Bracer"
|
||||
};
|
||||
|
||||
if (idx >= 0 && idx <= 10)
|
||||
return armorTypeLabels[idx];
|
||||
else
|
||||
return "Invalid";
|
||||
}
|
||||
|
||||
std::string dialogTypeLabel(int idx)
|
||||
{
|
||||
const char *dialogTypeLabels[] = {
|
||||
"Topic",
|
||||
"Voice",
|
||||
"Greeting",
|
||||
"Persuasion",
|
||||
"Journal"
|
||||
};
|
||||
|
||||
if (idx >= 0 && idx <= 4)
|
||||
return dialogTypeLabels[idx];
|
||||
else if (idx == -1)
|
||||
return "Deleted";
|
||||
else
|
||||
return "Invalid";
|
||||
}
|
||||
|
||||
std::string questStatusLabel(int idx)
|
||||
{
|
||||
const char *questStatusLabels[] = {
|
||||
"None",
|
||||
"Name",
|
||||
"Finished",
|
||||
"Restart",
|
||||
"Deleted"
|
||||
};
|
||||
|
||||
if (idx >= 0 && idx <= 4)
|
||||
return questStatusLabels[idx];
|
||||
else
|
||||
return "Invalid";
|
||||
}
|
||||
|
||||
std::string creatureTypeLabel(int idx)
|
||||
{
|
||||
const char *creatureTypeLabels[] = {
|
||||
"Creature",
|
||||
"Daedra",
|
||||
"Undead",
|
||||
"Humanoid",
|
||||
};
|
||||
|
||||
if (idx >= 0 && idx <= 3)
|
||||
return creatureTypeLabels[idx];
|
||||
else
|
||||
return "Invalid";
|
||||
}
|
||||
|
||||
std::string soundTypeLabel(int idx)
|
||||
{
|
||||
const char *soundTypeLabels[] = {
|
||||
"Left Foot",
|
||||
"Right Foot",
|
||||
"Swim Left",
|
||||
"Swim Right",
|
||||
"Moan",
|
||||
"Roar",
|
||||
"Scream",
|
||||
"Land"
|
||||
};
|
||||
|
||||
if (idx >= 0 && idx <= 7)
|
||||
return soundTypeLabels[idx];
|
||||
else
|
||||
return "Invalid";
|
||||
}
|
||||
|
||||
std::string weaponTypeLabel(int idx)
|
||||
{
|
||||
const char *weaponTypeLabels[] = {
|
||||
"Short Blade One Hand",
|
||||
"Long Blade One Hand",
|
||||
"Long Blade Two Hand",
|
||||
"Blunt One Hand",
|
||||
"Blunt Two Close",
|
||||
"Blunt Two Wide",
|
||||
"Spear Two Wide",
|
||||
"Axe One Hand",
|
||||
"Axe Two Hand",
|
||||
"Marksman Bow",
|
||||
"Marksman Crossbow",
|
||||
"Marksman Thrown",
|
||||
"Arrow",
|
||||
"Bolt"
|
||||
};
|
||||
|
||||
if (idx >= 0 && idx <= 13)
|
||||
return weaponTypeLabels[idx];
|
||||
else
|
||||
return "Invalid";
|
||||
}
|
||||
|
||||
std::string aiTypeLabel(int type)
|
||||
{
|
||||
if (type == ESM::AI_Wander) return "Wander";
|
||||
else if (type == ESM::AI_Travel) return "Travel";
|
||||
else if (type == ESM::AI_Follow) return "Follow";
|
||||
else if (type == ESM::AI_Escort) return "Escort";
|
||||
else if (type == ESM::AI_Activate) return "Activate";
|
||||
else return "Invalid";
|
||||
}
|
||||
|
||||
std::string magicEffectLabel(int idx)
|
||||
{
|
||||
const char* magicEffectLabels [] = {
|
||||
"Water Breathing",
|
||||
"Swift Swim",
|
||||
"Water Walking",
|
||||
"Shield",
|
||||
"Fire Shield",
|
||||
"Lightning Shield",
|
||||
"Frost Shield",
|
||||
"Burden",
|
||||
"Feather",
|
||||
"Jump",
|
||||
"Levitate",
|
||||
"SlowFall",
|
||||
"Lock",
|
||||
"Open",
|
||||
"Fire Damage",
|
||||
"Shock Damage",
|
||||
"Frost Damage",
|
||||
"Drain Attribute",
|
||||
"Drain Health",
|
||||
"Drain Magicka",
|
||||
"Drain Fatigue",
|
||||
"Drain Skill",
|
||||
"Damage Attribute",
|
||||
"Damage Health",
|
||||
"Damage Magicka",
|
||||
"Damage Fatigue",
|
||||
"Damage Skill",
|
||||
"Poison",
|
||||
"Weakness to Fire",
|
||||
"Weakness to Frost",
|
||||
"Weakness to Shock",
|
||||
"Weakness to Magicka",
|
||||
"Weakness to Common Disease",
|
||||
"Weakness to Blight Disease",
|
||||
"Weakness to Corprus Disease",
|
||||
"Weakness to Poison",
|
||||
"Weakness to Normal Weapons",
|
||||
"Disintegrate Weapon",
|
||||
"Disintegrate Armor",
|
||||
"Invisibility",
|
||||
"Chameleon",
|
||||
"Light",
|
||||
"Sanctuary",
|
||||
"Night Eye",
|
||||
"Charm",
|
||||
"Paralyze",
|
||||
"Silence",
|
||||
"Blind",
|
||||
"Sound",
|
||||
"Calm Humanoid",
|
||||
"Calm Creature",
|
||||
"Frenzy Humanoid",
|
||||
"Frenzy Creature",
|
||||
"Demoralize Humanoid",
|
||||
"Demoralize Creature",
|
||||
"Rally Humanoid",
|
||||
"Rally Creature",
|
||||
"Dispel",
|
||||
"Soultrap",
|
||||
"Telekinesis",
|
||||
"Mark",
|
||||
"Recall",
|
||||
"Divine Intervention",
|
||||
"Almsivi Intervention",
|
||||
"Detect Animal",
|
||||
"Detect Enchantment",
|
||||
"Detect Key",
|
||||
"Spell Absorption",
|
||||
"Reflect",
|
||||
"Cure Common Disease",
|
||||
"Cure Blight Disease",
|
||||
"Cure Corprus Disease",
|
||||
"Cure Poison",
|
||||
"Cure Paralyzation",
|
||||
"Restore Attribute",
|
||||
"Restore Health",
|
||||
"Restore Magicka",
|
||||
"Restore Fatigue",
|
||||
"Restore Skill",
|
||||
"Fortify Attribute",
|
||||
"Fortify Health",
|
||||
"Fortify Magicka",
|
||||
"Fortify Fatigue",
|
||||
"Fortify Skill",
|
||||
"Fortify Maximum Magicka",
|
||||
"Absorb Attribute",
|
||||
"Absorb Health",
|
||||
"Absorb Magicka",
|
||||
"Absorb Fatigue",
|
||||
"Absorb Skill",
|
||||
"Resist Fire",
|
||||
"Resist Frost",
|
||||
"Resist Shock",
|
||||
"Resist Magicka",
|
||||
"Resist Common Disease",
|
||||
"Resist Blight Disease",
|
||||
"Resist Corprus Disease",
|
||||
"Resist Poison",
|
||||
"Resist Normal Weapons",
|
||||
"Resist Paralysis",
|
||||
"Remove Curse",
|
||||
"Turn Undead",
|
||||
"Summon Scamp",
|
||||
"Summon Clannfear",
|
||||
"Summon Daedroth",
|
||||
"Summon Dremora",
|
||||
"Summon Ancestral Ghost",
|
||||
"Summon Skeletal Minion",
|
||||
"Summon Bonewalker",
|
||||
"Summon Greater Bonewalker",
|
||||
"Summon Bonelord",
|
||||
"Summon Winged Twilight",
|
||||
"Summon Hunger",
|
||||
"Summon Golden Saint",
|
||||
"Summon Flame Atronach",
|
||||
"Summon Frost Atronach",
|
||||
"Summon Storm Atronach",
|
||||
"Fortify Attack",
|
||||
"Command Creature",
|
||||
"Command Humanoid",
|
||||
"Bound Dagger",
|
||||
"Bound Longsword",
|
||||
"Bound Mace",
|
||||
"Bound Battle Axe",
|
||||
"Bound Spear",
|
||||
"Bound Longbow",
|
||||
"EXTRA SPELL",
|
||||
"Bound Cuirass",
|
||||
"Bound Helm",
|
||||
"Bound Boots",
|
||||
"Bound Shield",
|
||||
"Bound Gloves",
|
||||
"Corprus",
|
||||
"Vampirism",
|
||||
"Summon Centurion Sphere",
|
||||
"Sun Damage",
|
||||
"Stunted Magicka",
|
||||
"Summon Fabricant",
|
||||
"sEffectSummonCreature01",
|
||||
"sEffectSummonCreature02",
|
||||
"sEffectSummonCreature03",
|
||||
"sEffectSummonCreature04",
|
||||
"sEffectSummonCreature05"
|
||||
};
|
||||
if (idx >= 0 && idx <= 143)
|
||||
return magicEffectLabels[idx];
|
||||
else
|
||||
return "Invalid";
|
||||
}
|
||||
|
||||
std::string attributeLabel(int idx)
|
||||
{
|
||||
const char* attributeLabels [] = {
|
||||
"Strength",
|
||||
"Intelligence",
|
||||
"Willpower",
|
||||
"Agility",
|
||||
"Speed",
|
||||
"Endurance",
|
||||
"Personality",
|
||||
"Luck"
|
||||
};
|
||||
if (idx >= 0 && idx <= 7)
|
||||
return attributeLabels[idx];
|
||||
else
|
||||
return "Invalid";
|
||||
}
|
||||
|
||||
std::string spellTypeLabel(int idx)
|
||||
{
|
||||
const char* spellTypeLabels [] = {
|
||||
"Spells",
|
||||
"Abilities",
|
||||
"Blight Disease",
|
||||
"Disease",
|
||||
"Curse",
|
||||
"Powers"
|
||||
};
|
||||
if (idx >= 0 && idx <= 5)
|
||||
return spellTypeLabels[idx];
|
||||
else
|
||||
return "Invalid";
|
||||
}
|
||||
|
||||
std::string specializationLabel(int idx)
|
||||
{
|
||||
const char* specializationLabels [] = {
|
||||
"Combat",
|
||||
"Magic",
|
||||
"Stealth"
|
||||
};
|
||||
if (idx >= 0 && idx <= 2)
|
||||
return specializationLabels[idx];
|
||||
else
|
||||
return "Invalid";
|
||||
}
|
||||
|
||||
std::string skillLabel(int idx)
|
||||
{
|
||||
const char* skillLabels [] = {
|
||||
"Block",
|
||||
"Armorer",
|
||||
"Medium Armor",
|
||||
"Heavy Armor",
|
||||
"Blunt Weapon",
|
||||
"Long Blade",
|
||||
"Axe",
|
||||
"Spear",
|
||||
"Athletics",
|
||||
"Enchant",
|
||||
"Destruction",
|
||||
"Alteration",
|
||||
"Illusion",
|
||||
"Conjuration",
|
||||
"Mysticism",
|
||||
"Restoration",
|
||||
"Alchemy",
|
||||
"Unarmored",
|
||||
"Security",
|
||||
"Sneak",
|
||||
"Acrobatics",
|
||||
"Light Armor",
|
||||
"Short Blade",
|
||||
"Marksman",
|
||||
"Mercantile",
|
||||
"Speechcraft",
|
||||
"Hand-to-hand"
|
||||
};
|
||||
if (idx >= 0 && idx <= 27)
|
||||
return skillLabels[idx];
|
||||
else
|
||||
return "Invalid";
|
||||
}
|
||||
|
||||
std::string apparatusTypeLabel(int idx)
|
||||
{
|
||||
const char* apparatusTypeLabels [] = {
|
||||
"Mortar",
|
||||
"Alembic",
|
||||
"Calcinator",
|
||||
"Retort",
|
||||
};
|
||||
if (idx >= 0 && idx <= 3)
|
||||
return apparatusTypeLabels[idx];
|
||||
else
|
||||
return "Invalid";
|
||||
}
|
||||
|
||||
std::string rangeTypeLabel(int idx)
|
||||
{
|
||||
const char* rangeTypeLabels [] = {
|
||||
"Self",
|
||||
"Touch",
|
||||
"Target"
|
||||
};
|
||||
if (idx >= 0 && idx <= 3)
|
||||
return rangeTypeLabels[idx];
|
||||
else
|
||||
return "Invalid";
|
||||
}
|
||||
|
||||
std::string schoolLabel(int idx)
|
||||
{
|
||||
const char* schoolLabels [] = {
|
||||
"Alteration",
|
||||
"Conjuration",
|
||||
"Destruction",
|
||||
"Illusion",
|
||||
"Mysticism",
|
||||
"Restoration"
|
||||
};
|
||||
if (idx >= 0 && idx <= 5)
|
||||
return schoolLabels[idx];
|
||||
else
|
||||
return "Invalid";
|
||||
}
|
||||
|
||||
std::string enchantTypeLabel(int idx)
|
||||
{
|
||||
const char* enchantTypeLabels [] = {
|
||||
"Cast Once",
|
||||
"Cast When Strikes",
|
||||
"Cast When Used",
|
||||
"Constant Effect"
|
||||
};
|
||||
if (idx >= 0 && idx <= 3)
|
||||
return enchantTypeLabels[idx];
|
||||
else
|
||||
return "Invalid";
|
||||
}
|
||||
|
||||
std::string ruleFunction(int idx)
|
||||
{
|
||||
std::string ruleFunctions[] = {
|
||||
"Reaction Low",
|
||||
"Reaction High",
|
||||
"Rank Requirement",
|
||||
"NPC? Reputation",
|
||||
"Health Percent",
|
||||
"Player Reputation",
|
||||
"NPC Level",
|
||||
"Player Health Percent",
|
||||
"Player Magicka",
|
||||
"Player Fatigue",
|
||||
"Player Attribute Strength",
|
||||
"Player Skill Block",
|
||||
"Player Skill Armorer",
|
||||
"Player Skill Medium Armor",
|
||||
"Player Skill Heavy Armor",
|
||||
"Player Skill Blunt Weapon",
|
||||
"Player Skill Long Blade",
|
||||
"Player Skill Axe",
|
||||
"Player Skill Spear",
|
||||
"Player Skill Athletics",
|
||||
"Player Skill Enchant",
|
||||
"Player Skill Destruction",
|
||||
"Player Skill Alteration",
|
||||
"Player Skill Illusion",
|
||||
"Player Skill Conjuration",
|
||||
"Player Skill Mysticism",
|
||||
"Player SKill Restoration",
|
||||
"Player Skill Alchemy",
|
||||
"Player Skill Unarmored",
|
||||
"Player Skill Security",
|
||||
"Player Skill Sneak",
|
||||
"Player Skill Acrobatics",
|
||||
"Player Skill Light Armor",
|
||||
"Player Skill Short Blade",
|
||||
"Player Skill Marksman",
|
||||
"Player Skill Mercantile",
|
||||
"Player Skill Speechcraft",
|
||||
"Player Skill Hand to Hand",
|
||||
"Player Gender",
|
||||
"Player Expelled from Faction",
|
||||
"Player Diseased (Common)",
|
||||
"Player Diseased (Blight)",
|
||||
"Player Clothing Modifier",
|
||||
"Player Crime Level",
|
||||
"Player Same Sex",
|
||||
"Player Same Race",
|
||||
"Player Same Faction",
|
||||
"Faction Rank Difference",
|
||||
"Player Detected",
|
||||
"Alarmed",
|
||||
"Choice Selected",
|
||||
"Player Attribute Intelligence",
|
||||
"Player Attribute Willpower",
|
||||
"Player Attribute Agility",
|
||||
"Player Attribute Speed",
|
||||
"Player Attribute Endurance",
|
||||
"Player Attribute Personality",
|
||||
"Player Attribute Luck",
|
||||
"Player Diseased (Corprus)",
|
||||
"Weather",
|
||||
"Player is a Vampire",
|
||||
"Player Level",
|
||||
"Attacked",
|
||||
"NPC Talked to Player",
|
||||
"Player Health",
|
||||
"Creature Target",
|
||||
"Friend Hit",
|
||||
"Fight",
|
||||
"Hello",
|
||||
"Alarm",
|
||||
"Flee",
|
||||
"Should Attack",
|
||||
//Unkown but causes NPCs to growl and roar.
|
||||
"UNKNOWN 72"
|
||||
};
|
||||
if (idx >= 0 && idx <= 72)
|
||||
return ruleFunctions[idx];
|
||||
else
|
||||
return "Invalid";
|
||||
}
|
||||
|
||||
// The "unused flag bits" should probably be defined alongside the
|
||||
// defined bits in the ESM component. The names of the flag bits are
|
||||
// very inconsistent.
|
||||
|
||||
std::string bodyPartFlags(int flags)
|
||||
{
|
||||
std::string properties = "";
|
||||
if (flags == 0) properties += "[None] ";
|
||||
if (flags & ESM::BodyPart::BPF_Female) properties += "Female ";
|
||||
if (flags & ESM::BodyPart::BPF_Playable) properties += "Playable ";
|
||||
int unused = (0xFFFFFFFF ^
|
||||
(ESM::BodyPart::BPF_Female|
|
||||
ESM::BodyPart::BPF_Playable));
|
||||
if (flags & unused) properties += "Invalid ";
|
||||
properties += str(boost::format("(0x%08X)") % flags);
|
||||
return properties;
|
||||
}
|
||||
|
||||
std::string cellFlags(int flags)
|
||||
{
|
||||
std::string properties = "";
|
||||
if (flags == 0) properties += "[None] ";
|
||||
if (flags & ESM::Cell::HasWater) properties += "HasWater ";
|
||||
if (flags & ESM::Cell::Interior) properties += "Interior ";
|
||||
if (flags & ESM::Cell::NoSleep) properties += "NoSleep ";
|
||||
if (flags & ESM::Cell::QuasiEx) properties += "QuasiEx ";
|
||||
// This used value is not in the ESM component.
|
||||
if (flags & 0x00000040) properties += "Unknown ";
|
||||
int unused = (0xFFFFFFFF ^
|
||||
(ESM::Cell::HasWater|
|
||||
ESM::Cell::Interior|
|
||||
ESM::Cell::NoSleep|
|
||||
ESM::Cell::QuasiEx|
|
||||
0x00000040));
|
||||
if (flags & unused) properties += "Invalid ";
|
||||
properties += str(boost::format("(0x%08X)") % flags);
|
||||
return properties;
|
||||
}
|
||||
|
||||
std::string containerFlags(int flags)
|
||||
{
|
||||
std::string properties = "";
|
||||
if (flags == 0) properties += "[None] ";
|
||||
if (flags & ESM::Container::Unknown) properties += "Unknown ";
|
||||
if (flags & ESM::Container::Organic) properties += "Organic ";
|
||||
if (flags & ESM::Container::Respawn) properties += "Respawn ";
|
||||
int unused = (0xFFFFFFFF ^
|
||||
(ESM::Container::Unknown|
|
||||
ESM::Container::Organic|
|
||||
ESM::Container::Respawn));
|
||||
if (flags & unused) properties += "Invalid ";
|
||||
properties += str(boost::format("(0x%08X)") % flags);
|
||||
return properties;
|
||||
}
|
||||
|
||||
std::string creatureFlags(int flags)
|
||||
{
|
||||
std::string properties = "";
|
||||
if (flags == 0) properties += "[None] ";
|
||||
if (flags & ESM::Creature::None) properties += "All ";
|
||||
if (flags & ESM::Creature::Walks) properties += "Walks ";
|
||||
if (flags & ESM::Creature::Swims) properties += "Swims ";
|
||||
if (flags & ESM::Creature::Flies) properties += "Flies ";
|
||||
if (flags & ESM::Creature::Biped) properties += "Biped ";
|
||||
if (flags & ESM::Creature::Respawn) properties += "Respawn ";
|
||||
if (flags & ESM::Creature::Weapon) properties += "Weapon ";
|
||||
if (flags & ESM::Creature::Skeleton) properties += "Skeleton ";
|
||||
if (flags & ESM::Creature::Metal) properties += "Metal ";
|
||||
if (flags & ESM::Creature::Essential) properties += "Essential ";
|
||||
int unused = (0xFFFFFFFF ^
|
||||
(ESM::Creature::None|
|
||||
ESM::Creature::Walks|
|
||||
ESM::Creature::Swims|
|
||||
ESM::Creature::Flies|
|
||||
ESM::Creature::Biped|
|
||||
ESM::Creature::Respawn|
|
||||
ESM::Creature::Weapon|
|
||||
ESM::Creature::Skeleton|
|
||||
ESM::Creature::Metal|
|
||||
ESM::Creature::Essential));
|
||||
if (flags & unused) properties += "Invalid ";
|
||||
properties += str(boost::format("(0x%08X)") % flags);
|
||||
return properties;
|
||||
}
|
||||
|
||||
std::string landFlags(int flags)
|
||||
{
|
||||
std::string properties = "";
|
||||
// The ESM component says that this first four bits are used, but
|
||||
// only the first three bits are used as far as I can tell.
|
||||
// There's also no enumeration of the bit in the ESM component.
|
||||
if (flags == 0) properties += "[None] ";
|
||||
if (flags & 0x00000001) properties += "Unknown1 ";
|
||||
if (flags & 0x00000004) properties += "Unknown3 ";
|
||||
if (flags & 0x00000002) properties += "Unknown2 ";
|
||||
if (flags & 0xFFFFFFF8) properties += "Invalid ";
|
||||
properties += str(boost::format("(0x%08X)") % flags);
|
||||
return properties;
|
||||
}
|
||||
|
||||
std::string leveledListFlags(int flags)
|
||||
{
|
||||
std::string properties = "";
|
||||
if (flags == 0) properties += "[None] ";
|
||||
if (flags & ESM::LeveledListBase::AllLevels) properties += "AllLevels ";
|
||||
// This flag apparently not present on creature lists...
|
||||
if (flags & ESM::LeveledListBase::Each) properties += "Each ";
|
||||
int unused = (0xFFFFFFFF ^
|
||||
(ESM::LeveledListBase::AllLevels|
|
||||
ESM::LeveledListBase::Each));
|
||||
if (flags & unused) properties += "Invalid ";
|
||||
properties += str(boost::format("(0x%08X)") % flags);
|
||||
return properties;
|
||||
}
|
||||
|
||||
std::string lightFlags(int flags)
|
||||
{
|
||||
std::string properties = "";
|
||||
if (flags == 0) properties += "[None] ";
|
||||
if (flags & ESM::Light::Dynamic) properties += "Dynamic ";
|
||||
if (flags & ESM::Light::Fire) properties += "Fire ";
|
||||
if (flags & ESM::Light::Carry) properties += "Carry ";
|
||||
if (flags & ESM::Light::Flicker) properties += "Flicker ";
|
||||
if (flags & ESM::Light::FlickerSlow) properties += "FlickerSlow ";
|
||||
if (flags & ESM::Light::Pulse) properties += "Pulse ";
|
||||
if (flags & ESM::Light::PulseSlow) properties += "PulseSlow ";
|
||||
if (flags & ESM::Light::Negative) properties += "Negative ";
|
||||
if (flags & ESM::Light::OffDefault) properties += "OffDefault ";
|
||||
int unused = (0xFFFFFFFF ^
|
||||
(ESM::Light::Dynamic|
|
||||
ESM::Light::Fire|
|
||||
ESM::Light::Carry|
|
||||
ESM::Light::Flicker|
|
||||
ESM::Light::FlickerSlow|
|
||||
ESM::Light::Pulse|
|
||||
ESM::Light::PulseSlow|
|
||||
ESM::Light::Negative|
|
||||
ESM::Light::OffDefault));
|
||||
if (flags & unused) properties += "Invalid ";
|
||||
properties += str(boost::format("(0x%08X)") % flags);
|
||||
return properties;
|
||||
}
|
||||
|
||||
std::string magicEffectFlags(int flags)
|
||||
{
|
||||
std::string properties = "";
|
||||
if (flags == 0) properties += "[None] ";
|
||||
// Enchanting & SpellMaking occur on the same list of effects.
|
||||
// "EXTRA SPELL" appears in the construction set under both the
|
||||
// spell making and enchanting tabs as an allowed effect. Since
|
||||
// most of the effects without this flags are defective in various
|
||||
// ways, it's still very unclear what these flag bits are.
|
||||
if (flags & ESM::MagicEffect::SpellMaking) properties += "SpellMaking ";
|
||||
if (flags & ESM::MagicEffect::Enchanting) properties += "Enchanting ";
|
||||
if (flags & 0x00000040) properties += "RangeNoSelf ";
|
||||
if (flags & 0x00000080) properties += "RangeTouch ";
|
||||
if (flags & 0x00000100) properties += "RangeTarget ";
|
||||
if (flags & 0x00001000) properties += "Unknown2 ";
|
||||
if (flags & 0x00000001) properties += "AffectSkill ";
|
||||
if (flags & 0x00000002) properties += "AffectAttribute ";
|
||||
if (flags & ESM::MagicEffect::NoDuration) properties += "NoDuration ";
|
||||
if (flags & 0x00000008) properties += "NoMagnitude ";
|
||||
if (flags & 0x00000010) properties += "Negative ";
|
||||
if (flags & 0x00000020) properties += "Unknown1 ";
|
||||
// ESM componet says 0x800 is negative, but none of the magic
|
||||
// effects have this flags set.
|
||||
if (flags & ESM::MagicEffect::Negative) properties += "Unused ";
|
||||
// Since only Chameleon has this flag it could be anything
|
||||
// that uniquely distinguishes Chameleon.
|
||||
if (flags & 0x00002000) properties += "Chameleon ";
|
||||
if (flags & 0x00004000) properties += "Bound ";
|
||||
if (flags & 0x00008000) properties += "Summon ";
|
||||
// Calm, Demoralize, Frenzy, Lock, Open, Rally, Soultrap, Turn Unded
|
||||
if (flags & 0x00010000) properties += "Unknown3 ";
|
||||
if (flags & 0x00020000) properties += "Absorb ";
|
||||
if (flags & 0xFFFC0000) properties += "Invalid ";
|
||||
properties += str(boost::format("(0x%08X)") % flags);
|
||||
return properties;
|
||||
}
|
||||
|
||||
std::string npcFlags(int flags)
|
||||
{
|
||||
std::string properties = "";
|
||||
if (flags == 0) properties += "[None] ";
|
||||
// Mythicmods and the ESM component differ. Mythicmods says
|
||||
// 0x8=None and 0x10=AutoCalc, while our code defines 0x8 as
|
||||
// AutoCalc. The former seems to be correct. All Bethesda
|
||||
// records have bit 0x8 set. A suspiciously large portion of
|
||||
// females have autocalc turned off.
|
||||
if (flags & ESM::NPC::Autocalc) properties += "Unknown ";
|
||||
if (flags & 0x00000010) properties += "Autocalc ";
|
||||
if (flags & ESM::NPC::Female) properties += "Female ";
|
||||
if (flags & ESM::NPC::Respawn) properties += "Respawn ";
|
||||
if (flags & ESM::NPC::Essential) properties += "Essential ";
|
||||
// These two flags do not appear on any NPCs and may have been
|
||||
// confused with the flags for creatures.
|
||||
if (flags & ESM::NPC::Skeleton) properties += "Skeleton ";
|
||||
if (flags & ESM::NPC::Metal) properties += "Metal ";
|
||||
// Whether corpses persist is a bit that is unaccounted for,
|
||||
// however the only unknown bit occurs on ALL records, and
|
||||
// relatively few NPCs have this bit set.
|
||||
int unused = (0xFFFFFFFF ^
|
||||
(ESM::NPC::Autocalc|
|
||||
0x00000010|
|
||||
ESM::NPC::Female|
|
||||
ESM::NPC::Respawn|
|
||||
ESM::NPC::Essential|
|
||||
ESM::NPC::Skeleton|
|
||||
ESM::NPC::Metal));
|
||||
if (flags & unused) properties += "Invalid ";
|
||||
properties += str(boost::format("(0x%08X)") % flags);
|
||||
return properties;
|
||||
}
|
||||
|
||||
std::string raceFlags(int flags)
|
||||
{
|
||||
std::string properties = "";
|
||||
if (flags == 0) properties += "[None] ";
|
||||
// All races have the playable flag set in Bethesda files.
|
||||
if (flags & ESM::Race::Playable) properties += "Playable ";
|
||||
if (flags & ESM::Race::Beast) properties += "Beast ";
|
||||
int unused = (0xFFFFFFFF ^
|
||||
(ESM::Race::Playable|
|
||||
ESM::Race::Beast));
|
||||
if (flags & unused) properties += "Invalid ";
|
||||
properties += str(boost::format("(0x%08X)") % flags);
|
||||
return properties;
|
||||
}
|
||||
|
||||
std::string spellFlags(int flags)
|
||||
{
|
||||
std::string properties = "";
|
||||
if (flags == 0) properties += "[None] ";
|
||||
if (flags & ESM::Spell::F_Autocalc) properties += "Autocalc ";
|
||||
if (flags & ESM::Spell::F_PCStart) properties += "PCStart ";
|
||||
if (flags & ESM::Spell::F_Always) properties += "Always ";
|
||||
int unused = (0xFFFFFFFF ^
|
||||
(ESM::Spell::F_Autocalc|
|
||||
ESM::Spell::F_PCStart|
|
||||
ESM::Spell::F_Always));
|
||||
if (flags & unused) properties += "Invalid ";
|
||||
properties += str(boost::format("(0x%08X)") % flags);
|
||||
return properties;
|
||||
}
|
||||
|
||||
std::string weaponFlags(int flags)
|
||||
{
|
||||
std::string properties = "";
|
||||
if (flags == 0) properties += "[None] ";
|
||||
// The interpretation of the flags are still unclear to me.
|
||||
// Apparently you can't be Silver without being Magical? Many of
|
||||
// the "Magical" weapons don't have enchantments of any sort.
|
||||
if (flags & ESM::Weapon::Magical) properties += "Magical ";
|
||||
if (flags & ESM::Weapon::Silver) properties += "Silver ";
|
||||
int unused = (0xFFFFFFFF ^
|
||||
(ESM::Weapon::Magical|
|
||||
ESM::Weapon::Silver));
|
||||
if (flags & unused) properties += "Invalid ";
|
||||
properties += str(boost::format("(0x%08X)") % flags);
|
||||
return properties;
|
||||
}
|
||||
64
apps/esmtool/labels.hpp
Normal file
64
apps/esmtool/labels.hpp
Normal file
|
|
@ -0,0 +1,64 @@
|
|||
#ifndef OPENMW_ESMTOOL_LABELS_H
|
||||
#define OPENMW_ESMTOOL_LABELS_H
|
||||
|
||||
#include <string>
|
||||
|
||||
std::string bodyPartLabel(char idx);
|
||||
std::string meshPartLabel(char idx);
|
||||
std::string meshTypeLabel(char idx);
|
||||
std::string clothingTypeLabel(int idx);
|
||||
std::string armorTypeLabel(int idx);
|
||||
std::string dialogTypeLabel(int idx);
|
||||
std::string questStatusLabel(int idx);
|
||||
std::string creatureTypeLabel(int idx);
|
||||
std::string soundTypeLabel(int idx);
|
||||
std::string weaponTypeLabel(int idx);
|
||||
|
||||
// This function's a bit different because the types are record types,
|
||||
// not consecutive values.
|
||||
std::string aiTypeLabel(int type);
|
||||
|
||||
// This one's also a bit different, because it enumerates dialog
|
||||
// select rule functions, not types. Structurally, it still converts
|
||||
// indexes to strings for display.
|
||||
std::string ruleFunction(int idx);
|
||||
|
||||
// The labels below here can all be loaded from GMSTs, but are not
|
||||
// currently because among other things, that requires loading the
|
||||
// GMSTs before dumping any of the records.
|
||||
|
||||
// If the data format supported ordered lists of GMSTs (post 1.0), the
|
||||
// lists could define the valid values, their localization strings,
|
||||
// and the indexes for referencing the types in other records in the
|
||||
// database. Then a single label function could work for all types.
|
||||
|
||||
std::string magicEffectLabel(int idx);
|
||||
std::string attributeLabel(int idx);
|
||||
std::string spellTypeLabel(int idx);
|
||||
std::string specializationLabel(int idx);
|
||||
std::string skillLabel(int idx);
|
||||
std::string apparatusTypeLabel(int idx);
|
||||
std::string rangeTypeLabel(int idx);
|
||||
std::string schoolLabel(int idx);
|
||||
std::string enchantTypeLabel(int idx);
|
||||
|
||||
// The are the flag functions that convert a bitmask into a list of
|
||||
// human readble strings representing the set bits.
|
||||
|
||||
std::string bodyPartFlags(int flags);
|
||||
std::string cellFlags(int flags);
|
||||
std::string containerFlags(int flags);
|
||||
std::string creatureFlags(int flags);
|
||||
std::string landFlags(int flags);
|
||||
std::string leveledListFlags(int flags);
|
||||
std::string lightFlags(int flags);
|
||||
std::string magicEffectFlags(int flags);
|
||||
std::string npcFlags(int flags);
|
||||
std::string raceFlags(int flags);
|
||||
std::string spellFlags(int flags);
|
||||
std::string weaponFlags(int flags);
|
||||
|
||||
// Missing flags functions:
|
||||
// aiServicesFlags, possibly more
|
||||
|
||||
#endif
|
||||
|
|
@ -1,54 +1,126 @@
|
|||
#include "record.hpp"
|
||||
#include "labels.hpp"
|
||||
|
||||
#include <iostream>
|
||||
#include <boost/format.hpp>
|
||||
|
||||
void printAIPackage(ESM::AIPackage p)
|
||||
{
|
||||
if (p.mType == ESM::AI_Wander)
|
||||
{
|
||||
std::cout << " AIType Wander:" << std::endl;
|
||||
std::cout << " Distance: " << p.mWander.mDistance << std::endl;
|
||||
std::cout << " Duration: " << p.mWander.mDuration << std::endl;
|
||||
std::cout << " Time of Day: " << (int)p.mWander.mTimeOfDay << std::endl;
|
||||
if (p.mWander.mUnk != 1)
|
||||
std::cout << " Unknown: " << (int)p.mWander.mUnk << std::endl;
|
||||
std::cout << " AI Type: " << aiTypeLabel(p.mType)
|
||||
<< " (" << boost::format("0x%08X") % p.mType << ")" << std::endl;
|
||||
if (p.mType == ESM::AI_Wander)
|
||||
{
|
||||
std::cout << " Distance: " << p.mWander.mDistance << std::endl;
|
||||
std::cout << " Duration: " << p.mWander.mDuration << std::endl;
|
||||
std::cout << " Time of Day: " << (int)p.mWander.mTimeOfDay << std::endl;
|
||||
if (p.mWander.mUnk != 1)
|
||||
std::cout << " Unknown: " << (int)p.mWander.mUnk << std::endl;
|
||||
|
||||
std::cout << " Idle: ";
|
||||
for (int i = 0; i != 8; i++)
|
||||
std::cout << (int)p.mWander.mIdle[i] << " ";
|
||||
std::cout << std::endl;
|
||||
}
|
||||
else if (p.mType == ESM::AI_Travel)
|
||||
{
|
||||
std::cout << " Travel Coordinates: (" << p.mTravel.mX << ","
|
||||
<< p.mTravel.mY << "," << p.mTravel.mZ << ")" << std::endl;
|
||||
std::cout << " Travel Unknown: " << (int)p.mTravel.mUnk << std::endl;
|
||||
}
|
||||
else if (p.mType == ESM::AI_Follow || p.mType == ESM::AI_Escort)
|
||||
{
|
||||
std::cout << " Follow Coordinates: (" << p.mTarget.mX << ","
|
||||
<< p.mTarget.mY << "," << p.mTarget.mZ << ")" << std::endl;
|
||||
std::cout << " Duration: " << p.mTarget.mDuration << std::endl;
|
||||
std::cout << " Target ID: " << p.mTarget.mId.toString() << std::endl;
|
||||
std::cout << " Unknown: " << (int)p.mTarget.mUnk << std::endl;
|
||||
}
|
||||
else if (p.mType == ESM::AI_Activate)
|
||||
{
|
||||
std::cout << " Name: " << p.mActivate.mName.toString() << std::endl;
|
||||
std::cout << " Activate Unknown: " << (int)p.mActivate.mUnk << std::endl;
|
||||
}
|
||||
else {
|
||||
std::cout << " BadPackage: " << boost::format("0x%08x") % p.mType << std::endl;
|
||||
}
|
||||
|
||||
if (p.mCellName != "")
|
||||
std::cout << " Cell Name: " << p.mCellName << std::endl;
|
||||
}
|
||||
|
||||
std::cout << " Idle: ";
|
||||
for (int i = 0; i != 8; i++)
|
||||
std::cout << (int)p.mWander.mIdle[i] << " ";
|
||||
std::cout << std::endl;
|
||||
}
|
||||
else if (p.mType == ESM::AI_Travel)
|
||||
{
|
||||
std::cout << " AIType Travel:" << std::endl;
|
||||
std::cout << " Travel Coordinates: (" << p.mTravel.mX << ","
|
||||
<< p.mTravel.mY << "," << p.mTravel.mZ << ")" << std::endl;
|
||||
std::cout << " Travel Unknown: " << (int)p.mTravel.mUnk << std::endl;
|
||||
}
|
||||
else if (p.mType == ESM::AI_Follow || p.mType == ESM::AI_Escort)
|
||||
{
|
||||
if (p.mType == ESM::AI_Follow) std::cout << " AIType Follow:" << std::endl;
|
||||
else std::cout << " AIType Escort:" << std::endl;
|
||||
std::string ruleString(ESM::DialInfo::SelectStruct ss)
|
||||
{
|
||||
std::string rule = ss.mSelectRule;
|
||||
|
||||
if (rule.length() < 5)
|
||||
return "INVALID";
|
||||
|
||||
char type = rule[1];
|
||||
char indicator = rule[2];
|
||||
|
||||
std::string type_str = "INVALID";
|
||||
std::string func_str = str(boost::format("INVALID=%s") % rule.substr(1,3));
|
||||
int func;
|
||||
std::istringstream iss(rule.substr(2,2));
|
||||
iss >> func;
|
||||
|
||||
std::cout << " Follow Coordinates: (" << p.mTarget.mX << ","
|
||||
<< p.mTarget.mY << "," << p.mTarget.mZ << ")" << std::endl;
|
||||
std::cout << " Duration: " << p.mTarget.mDuration << std::endl;
|
||||
std::cout << " Target ID: " << p.mTarget.mId.toString() << std::endl;
|
||||
std::cout << " Unknown: " << (int)p.mTarget.mUnk << std::endl;
|
||||
}
|
||||
else if (p.mType == ESM::AI_Activate)
|
||||
{
|
||||
std::cout << " AIType Activate:" << std::endl;
|
||||
std::cout << " Name: " << p.mActivate.mName.toString() << std::endl;
|
||||
std::cout << " Activate Unknown: " << (int)p.mActivate.mUnk << std::endl;
|
||||
}
|
||||
else {
|
||||
std::cout << " BadPackage: " << boost::format("0x%08x") % p.mType << std::endl;
|
||||
}
|
||||
switch(type)
|
||||
{
|
||||
case '1':
|
||||
type_str = "Function";
|
||||
func_str = ruleFunction(func);
|
||||
break;
|
||||
case '2':
|
||||
if (indicator == 's') type_str = "Global short";
|
||||
else if (indicator == 'l') type_str = "Global long";
|
||||
else if (indicator == 'f') type_str = "Global float";
|
||||
break;
|
||||
case '3':
|
||||
if (indicator == 's') type_str = "Local short";
|
||||
else if (indicator == 'l') type_str = "Local long";
|
||||
else if (indicator == 'f') type_str = "Local float";
|
||||
break;
|
||||
case '4': if (indicator == 'J') type_str = "Journal"; break;
|
||||
case '5': if (indicator == 'I') type_str = "Item type"; break;
|
||||
case '6': if (indicator == 'D') type_str = "NPC Dead"; break;
|
||||
case '7': if (indicator == 'X') type_str = "Not ID"; break;
|
||||
case '8': if (indicator == 'F') type_str = "Not Faction"; break;
|
||||
case '9': if (indicator == 'C') type_str = "Not Class"; break;
|
||||
case 'A': if (indicator == 'R') type_str = "Not Race"; break;
|
||||
case 'B': if (indicator == 'L') type_str = "Not Cell"; break;
|
||||
case 'C': if (indicator == 's') type_str = "Not Local"; break;
|
||||
}
|
||||
|
||||
// Append the variable name to the function string if any.
|
||||
if (type != '1') func_str = rule.substr(5);
|
||||
|
||||
// In the previous switch, we assumed that the second char was X
|
||||
// for all types not qual to one. If this wasn't true, go back to
|
||||
// the error message.
|
||||
if (type != '1' && rule[3] != 'X')
|
||||
func_str = str(boost::format("INVALID=%s") % rule.substr(1,3));
|
||||
|
||||
if (p.mCellName != "")
|
||||
std::cout << " Cell Name: " << p.mCellName << std::endl;
|
||||
char oper = rule[4];
|
||||
std::string oper_str = "??";
|
||||
switch (oper)
|
||||
{
|
||||
case '0': oper_str = "=="; break;
|
||||
case '1': oper_str = "!="; break;
|
||||
case '2': oper_str = "< "; break;
|
||||
case '3': oper_str = "<="; break;
|
||||
case '4': oper_str = "> "; break;
|
||||
case '5': oper_str = ">="; break;
|
||||
}
|
||||
|
||||
std::string value_str = "??";
|
||||
if (ss.mType == ESM::VT_Int)
|
||||
value_str = str(boost::format("%d") % ss.mI);
|
||||
else if (ss.mType == ESM::VT_Float)
|
||||
value_str = str(boost::format("%f") % ss.mF);
|
||||
|
||||
std::string result = str(boost::format("%-12s %-32s %2s %s")
|
||||
% type_str % func_str % oper_str % value_str);
|
||||
return result;
|
||||
}
|
||||
|
||||
void printEffectList(ESM::EffectList effects)
|
||||
|
|
@ -57,12 +129,16 @@ void printEffectList(ESM::EffectList effects)
|
|||
std::vector<ESM::ENAMstruct>::iterator eit;
|
||||
for (eit = effects.mList.begin(); eit != effects.mList.end(); eit++)
|
||||
{
|
||||
std::cout << " Effect[" << i << "]: " << eit->mEffectID << std::endl;
|
||||
std::cout << " Effect[" << i << "]: " << magicEffectLabel(eit->mEffectID)
|
||||
<< " (" << eit->mEffectID << ")" << std::endl;
|
||||
if (eit->mSkill != -1)
|
||||
std::cout << " Skill: " << (int)eit->mSkill << std::endl;
|
||||
std::cout << " Skill: " << skillLabel(eit->mSkill)
|
||||
<< " (" << (int)eit->mSkill << ")" << std::endl;
|
||||
if (eit->mAttribute != -1)
|
||||
std::cout << " Attribute: " << (int)eit->mAttribute << std::endl;
|
||||
std::cout << " Range: " << eit->mRange << std::endl;
|
||||
std::cout << " Attribute: " << attributeLabel(eit->mAttribute)
|
||||
<< " (" << (int)eit->mAttribute << ")" << std::endl;
|
||||
std::cout << " Range: " << rangeTypeLabel(eit->mRange)
|
||||
<< " (" << eit->mRange << ")" << std::endl;
|
||||
// Area is always zero if range type is "Self"
|
||||
if (eit->mRange != ESM::RT_Self)
|
||||
std::cout << " Area: " << eit->mArea << std::endl;
|
||||
|
|
@ -331,7 +407,8 @@ void Record<ESM::Armor>::print()
|
|||
std::cout << " Script: " << mData.mScript << std::endl;
|
||||
if (mData.mEnchant != "")
|
||||
std::cout << " Enchantment: " << mData.mEnchant << std::endl;
|
||||
std::cout << " Type: " << mData.mData.mType << std::endl;
|
||||
std::cout << " Type: " << armorTypeLabel(mData.mData.mType)
|
||||
<< " (" << mData.mData.mType << ")" << std::endl;
|
||||
std::cout << " Weight: " << mData.mData.mWeight << std::endl;
|
||||
std::cout << " Value: " << mData.mData.mValue << std::endl;
|
||||
std::cout << " Health: " << mData.mData.mHealth << std::endl;
|
||||
|
|
@ -340,7 +417,8 @@ void Record<ESM::Armor>::print()
|
|||
std::vector<ESM::PartReference>::iterator pit;
|
||||
for (pit = mData.mParts.mParts.begin(); pit != mData.mParts.mParts.end(); pit++)
|
||||
{
|
||||
std::cout << " Body Part: " << (int)(pit->mPart) << std::endl;
|
||||
std::cout << " Body Part: " << bodyPartLabel(pit->mPart)
|
||||
<< " (" << (int)(pit->mPart) << ")" << std::endl;
|
||||
std::cout << " Male Name: " << pit->mMale << std::endl;
|
||||
if (pit->mFemale != "")
|
||||
std::cout << " Female Name: " << pit->mFemale << std::endl;
|
||||
|
|
@ -354,7 +432,8 @@ void Record<ESM::Apparatus>::print()
|
|||
std::cout << " Model: " << mData.mModel << std::endl;
|
||||
std::cout << " Icon: " << mData.mIcon << std::endl;
|
||||
std::cout << " Script: " << mData.mScript << std::endl;
|
||||
std::cout << " Type: " << mData.mData.mType << std::endl;
|
||||
std::cout << " Type: " << apparatusTypeLabel(mData.mData.mType)
|
||||
<< " (" << (int)mData.mData.mType << ")" << std::endl;
|
||||
std::cout << " Weight: " << mData.mData.mWeight << std::endl;
|
||||
std::cout << " Value: " << mData.mData.mValue << std::endl;
|
||||
std::cout << " Quality: " << mData.mData.mQuality << std::endl;
|
||||
|
|
@ -365,9 +444,11 @@ void Record<ESM::BodyPart>::print()
|
|||
{
|
||||
std::cout << " Name: " << mData.mName << std::endl;
|
||||
std::cout << " Model: " << mData.mModel << std::endl;
|
||||
std::cout << " Type: " << (int)mData.mData.mType << std::endl;
|
||||
std::cout << " Flags: " << (int)mData.mData.mFlags << std::endl;
|
||||
std::cout << " Part: " << (int)mData.mData.mPart << std::endl;
|
||||
std::cout << " Type: " << meshTypeLabel(mData.mData.mType)
|
||||
<< " (" << (int)mData.mData.mType << ")" << std::endl;
|
||||
std::cout << " Flags: " << bodyPartFlags(mData.mData.mFlags) << std::endl;
|
||||
std::cout << " Part: " << meshPartLabel(mData.mData.mPart)
|
||||
<< " (" << (int)mData.mData.mPart << ")" << std::endl;
|
||||
std::cout << " Vampire: " << (int)mData.mData.mVampire << std::endl;
|
||||
}
|
||||
|
||||
|
|
@ -413,7 +494,7 @@ void Record<ESM::Cell>::print()
|
|||
std::cout << " Name: " << mData.mName << std::endl;
|
||||
if (mData.mRegion != "")
|
||||
std::cout << " Region: " << mData.mRegion << std::endl;
|
||||
std::cout << " Flags: " << (int)mData.mData.mFlags << std::endl;
|
||||
std::cout << " Flags: " << cellFlags(mData.mData.mFlags) << std::endl;
|
||||
|
||||
std::cout << " Coordinates: " << " (" << mData.getGridX() << ","
|
||||
<< mData.getGridY() << ")" << std::endl;
|
||||
|
|
@ -441,13 +522,18 @@ void Record<ESM::Class>::print()
|
|||
std::cout << " Description: " << mData.mDescription << std::endl;
|
||||
std::cout << " Playable: " << mData.mData.mIsPlayable << std::endl;
|
||||
std::cout << " AutoCalc: " << mData.mData.mCalc << std::endl;
|
||||
std::cout << " Attribute1: " << mData.mData.mAttribute[0] << std::endl;
|
||||
std::cout << " Attribute2: " << mData.mData.mAttribute[1] << std::endl;
|
||||
std::cout << " Specialization: " << mData.mData.mSpecialization << std::endl;
|
||||
std::cout << " Attribute1: " << attributeLabel(mData.mData.mAttribute[0])
|
||||
<< " (" << mData.mData.mAttribute[0] << ")" << std::endl;
|
||||
std::cout << " Attribute2: " << attributeLabel(mData.mData.mAttribute[1])
|
||||
<< " (" << mData.mData.mAttribute[1] << ")" << std::endl;
|
||||
std::cout << " Specialization: " << specializationLabel(mData.mData.mSpecialization)
|
||||
<< " (" << mData.mData.mSpecialization << ")" << std::endl;
|
||||
for (int i = 0; i != 5; i++)
|
||||
std::cout << " Major Skill: " << mData.mData.mSkills[i][0] << std::endl;
|
||||
std::cout << " Major Skill: " << skillLabel(mData.mData.mSkills[i][0])
|
||||
<< " (" << mData.mData.mSkills[i][0] << ")" << std::endl;
|
||||
for (int i = 0; i != 5; i++)
|
||||
std::cout << " Minor Skill: " << mData.mData.mSkills[i][1] << std::endl;
|
||||
std::cout << " Minor Skill: " << skillLabel(mData.mData.mSkills[i][1])
|
||||
<< " (" << mData.mData.mSkills[i][1] << ")" << std::endl;
|
||||
}
|
||||
|
||||
template<>
|
||||
|
|
@ -460,10 +546,20 @@ void Record<ESM::Clothing>::print()
|
|||
std::cout << " Script: " << mData.mScript << std::endl;
|
||||
if (mData.mEnchant != "")
|
||||
std::cout << " Enchantment: " << mData.mEnchant << std::endl;
|
||||
std::cout << " Type: " << mData.mData.mType << std::endl;
|
||||
std::cout << " Type: " << clothingTypeLabel(mData.mData.mType)
|
||||
<< " (" << mData.mData.mType << ")" << std::endl;
|
||||
std::cout << " Weight: " << mData.mData.mWeight << std::endl;
|
||||
std::cout << " Value: " << mData.mData.mValue << std::endl;
|
||||
// mEnchant also in CTDTstruct?
|
||||
std::cout << " Enchantment Points: " << mData.mData.mEnchant << std::endl;
|
||||
std::vector<ESM::PartReference>::iterator pit;
|
||||
for (pit = mData.mParts.mParts.begin(); pit != mData.mParts.mParts.end(); pit++)
|
||||
{
|
||||
std::cout << " Body Part: " << bodyPartLabel(pit->mPart)
|
||||
<< " (" << (int)(pit->mPart) << ")" << std::endl;
|
||||
std::cout << " Male Name: " << pit->mMale << std::endl;
|
||||
if (pit->mFemale != "")
|
||||
std::cout << " Female Name: " << pit->mFemale << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
template<>
|
||||
|
|
@ -473,7 +569,7 @@ void Record<ESM::Container>::print()
|
|||
std::cout << " Model: " << mData.mModel << std::endl;
|
||||
if (mData.mScript != "")
|
||||
std::cout << " Script: " << mData.mScript << std::endl;
|
||||
std::cout << " Flags: " << mData.mFlags << std::endl;
|
||||
std::cout << " Flags: " << containerFlags(mData.mFlags) << std::endl;
|
||||
std::cout << " Weight: " << mData.mWeight << std::endl;
|
||||
std::vector<ESM::ContItem>::iterator cit;
|
||||
for (cit = mData.mInventory.mList.begin(); cit != mData.mInventory.mList.end(); cit++)
|
||||
|
|
@ -487,11 +583,12 @@ void Record<ESM::Creature>::print()
|
|||
std::cout << " Name: " << mData.mName << std::endl;
|
||||
std::cout << " Model: " << mData.mModel << std::endl;
|
||||
std::cout << " Script: " << mData.mScript << std::endl;
|
||||
std::cout << " Flags: " << mData.mFlags << std::endl;
|
||||
std::cout << " Flags: " << creatureFlags(mData.mFlags) << std::endl;
|
||||
std::cout << " Original: " << mData.mOriginal << std::endl;
|
||||
std::cout << " Scale: " << mData.mScale << std::endl;
|
||||
|
||||
std::cout << " Type: " << mData.mData.mType << std::endl;
|
||||
std::cout << " Type: " << creatureTypeLabel(mData.mData.mType)
|
||||
<< " (" << mData.mData.mType << ")" << std::endl;
|
||||
std::cout << " Level: " << mData.mData.mLevel << std::endl;
|
||||
|
||||
std::cout << " Attributes:" << std::endl;
|
||||
|
|
@ -547,7 +644,8 @@ void Record<ESM::Creature>::print()
|
|||
template<>
|
||||
void Record<ESM::Dialogue>::print()
|
||||
{
|
||||
std::cout << " Type: " << (int)mData.mType << std::endl;
|
||||
std::cout << " Type: " << dialogTypeLabel(mData.mType)
|
||||
<< " (" << (int)mData.mType << ")" << std::endl;
|
||||
// Sadly, there are no DialInfos, because the loader dumps as it
|
||||
// loads, rather than loading and then dumping. :-( Anyone mind if
|
||||
// I change this?
|
||||
|
|
@ -569,7 +667,8 @@ void Record<ESM::Door>::print()
|
|||
template<>
|
||||
void Record<ESM::Enchantment>::print()
|
||||
{
|
||||
std::cout << " Type: " << mData.mData.mType << std::endl;
|
||||
std::cout << " Type: " << enchantTypeLabel(mData.mData.mType)
|
||||
<< " (" << mData.mData.mType << ")" << std::endl;
|
||||
std::cout << " Cost: " << mData.mData.mCost << std::endl;
|
||||
std::cout << " Charge: " << mData.mData.mCharge << std::endl;
|
||||
std::cout << " AutoCalc: " << mData.mData.mAutocalc << std::endl;
|
||||
|
|
@ -583,11 +682,14 @@ void Record<ESM::Faction>::print()
|
|||
std::cout << " Hidden: " << mData.mData.mIsHidden << std::endl;
|
||||
if (mData.mData.mUnknown != -1)
|
||||
std::cout << " Unknown: " << mData.mData.mUnknown << std::endl;
|
||||
std::cout << " Attribute1: " << mData.mData.mAttribute1 << std::endl;
|
||||
std::cout << " Attribute2: " << mData.mData.mAttribute2 << std::endl;
|
||||
std::cout << " Attribute1: " << attributeLabel(mData.mData.mAttribute1)
|
||||
<< " (" << mData.mData.mAttribute1 << ")" << std::endl;
|
||||
std::cout << " Attribute2: " << attributeLabel(mData.mData.mAttribute2)
|
||||
<< " (" << mData.mData.mAttribute2 << ")" << std::endl;
|
||||
for (int i = 0; i != 6; i++)
|
||||
if (mData.mData.mSkillID[i] != -1)
|
||||
std::cout << " Skill: " << mData.mData.mSkillID[i] << std::endl;
|
||||
std::cout << " Skill: " << skillLabel(mData.mData.mSkillID[i])
|
||||
<< " (" << mData.mData.mSkillID[i] << ")" << std::endl;
|
||||
for (int i = 0; i != 10; i++)
|
||||
if (mData.mRanks[i] != "")
|
||||
{
|
||||
|
|
@ -683,13 +785,14 @@ void Record<ESM::DialInfo>::print()
|
|||
// std::cout << "-------------------------------------------" << std::endl;
|
||||
}
|
||||
|
||||
std::cout << " Quest Status: " << mData.mQuestStatus << std::endl;
|
||||
std::cout << " Quest Status: " << questStatusLabel(mData.mQuestStatus)
|
||||
<< " (" << mData.mQuestStatus << ")" << std::endl;
|
||||
std::cout << " Unknown1: " << mData.mData.mUnknown1 << std::endl;
|
||||
std::cout << " Unknown2: " << (int)mData.mData.mUnknown2 << std::endl;
|
||||
|
||||
std::vector<ESM::DialInfo::SelectStruct>::iterator sit;
|
||||
for (sit = mData.mSelects.begin(); sit != mData.mSelects.end(); sit++)
|
||||
std::cout << " Select Rule: " << sit->mType << " " << sit->mSelectRule << std::endl;
|
||||
std::cout << " Select Rule: " << ruleString(*sit) << std::endl;
|
||||
}
|
||||
|
||||
template<>
|
||||
|
|
@ -706,9 +809,12 @@ void Record<ESM::Ingredient>::print()
|
|||
{
|
||||
// A value of -1 means no effect
|
||||
if (mData.mData.mEffectID[i] == -1) continue;
|
||||
std::cout << " Effect: " << mData.mData.mEffectID[i] << std::endl;
|
||||
std::cout << " Skill: " << mData.mData.mSkills[i] << std::endl;
|
||||
std::cout << " Attribute: " << mData.mData.mAttributes[i] << std::endl;
|
||||
std::cout << " Effect: " << magicEffectLabel(mData.mData.mEffectID[i])
|
||||
<< " (" << mData.mData.mEffectID[i] << ")" << std::endl;
|
||||
std::cout << " Skill: " << skillLabel(mData.mData.mSkills[i])
|
||||
<< " (" << mData.mData.mSkills[i] << ")" << std::endl;
|
||||
std::cout << " Attribute: " << attributeLabel(mData.mData.mAttributes[i])
|
||||
<< " (" << mData.mData.mAttributes[i] << ")" << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -716,7 +822,7 @@ template<>
|
|||
void Record<ESM::Land>::print()
|
||||
{
|
||||
std::cout << " Coordinates: (" << mData.mX << "," << mData.mY << ")" << std::endl;
|
||||
std::cout << " Flags: " << mData.mFlags << std::endl;
|
||||
std::cout << " Flags: " << landFlags(mData.mFlags) << std::endl;
|
||||
std::cout << " HasData: " << mData.mHasData << std::endl;
|
||||
std::cout << " DataTypes: " << mData.mDataTypes << std::endl;
|
||||
|
||||
|
|
@ -739,7 +845,7 @@ template<>
|
|||
void Record<ESM::CreatureLevList>::print()
|
||||
{
|
||||
std::cout << " Chance for None: " << (int)mData.mChanceNone << std::endl;
|
||||
std::cout << " Flags: " << mData.mFlags << std::endl;
|
||||
std::cout << " Flags: " << leveledListFlags(mData.mFlags) << std::endl;
|
||||
std::cout << " Number of items: " << mData.mList.size() << std::endl;
|
||||
std::vector<ESM::LeveledListBase::LevelItem>::iterator iit;
|
||||
for (iit = mData.mList.begin(); iit != mData.mList.end(); iit++)
|
||||
|
|
@ -751,7 +857,7 @@ template<>
|
|||
void Record<ESM::ItemLevList>::print()
|
||||
{
|
||||
std::cout << " Chance for None: " << (int)mData.mChanceNone << std::endl;
|
||||
std::cout << " Flags: " << mData.mFlags << std::endl;
|
||||
std::cout << " Flags: " << leveledListFlags(mData.mFlags) << std::endl;
|
||||
std::cout << " Number of items: " << mData.mList.size() << std::endl;
|
||||
std::vector<ESM::LeveledListBase::LevelItem>::iterator iit;
|
||||
for (iit = mData.mList.begin(); iit != mData.mList.end(); iit++)
|
||||
|
|
@ -770,7 +876,7 @@ void Record<ESM::Light>::print()
|
|||
std::cout << " Icon: " << mData.mIcon << std::endl;
|
||||
if (mData.mScript != "")
|
||||
std::cout << " Script: " << mData.mScript << std::endl;
|
||||
std::cout << " Flags: " << mData.mData.mFlags << std::endl;
|
||||
std::cout << " Flags: " << lightFlags(mData.mData.mFlags) << std::endl;
|
||||
std::cout << " Weight: " << mData.mData.mWeight << std::endl;
|
||||
std::cout << " Value: " << mData.mData.mValue << std::endl;
|
||||
std::cout << " Sound: " << mData.mSound << std::endl;
|
||||
|
|
@ -802,6 +908,7 @@ void Record<ESM::Probe>::print()
|
|||
std::cout << " Icon: " << mData.mIcon << std::endl;
|
||||
if (mData.mScript != "")
|
||||
std::cout << " Script: " << mData.mScript << std::endl;
|
||||
// BUG? No Type Label?
|
||||
std::cout << " Type: " << mData.mType << std::endl;
|
||||
std::cout << " Weight: " << mData.mData.mWeight << std::endl;
|
||||
std::cout << " Value: " << mData.mData.mValue << std::endl;
|
||||
|
|
@ -835,10 +942,11 @@ void Record<ESM::LandTexture>::print()
|
|||
template<>
|
||||
void Record<ESM::MagicEffect>::print()
|
||||
{
|
||||
std::cout << " Index: " << mData.mIndex << std::endl;
|
||||
std::cout << " Index: " << magicEffectLabel(mData.mIndex)
|
||||
<< " (" << mData.mIndex << ")" << std::endl;
|
||||
std::cout << " Description: " << mData.mDescription << std::endl;
|
||||
std::cout << " Icon: " << mData.mIcon << std::endl;
|
||||
std::cout << " Flags: " << mData.mData.mFlags << std::endl;
|
||||
std::cout << " Flags: " << magicEffectFlags(mData.mData.mFlags) << std::endl;
|
||||
std::cout << " Particle Texture: " << mData.mParticle << std::endl;
|
||||
if (mData.mCasting != "")
|
||||
std::cout << " Casting Static: " << mData.mCasting << std::endl;
|
||||
|
|
@ -856,7 +964,8 @@ void Record<ESM::MagicEffect>::print()
|
|||
std::cout << " Area Static: " << mData.mArea << std::endl;
|
||||
if (mData.mAreaSound != "")
|
||||
std::cout << " Area Sound: " << mData.mAreaSound << std::endl;
|
||||
std::cout << " School: " << mData.mData.mSchool << std::endl;
|
||||
std::cout << " School: " << schoolLabel(mData.mData.mSchool)
|
||||
<< " (" << mData.mData.mSchool << ")" << std::endl;
|
||||
std::cout << " Base Cost: " << mData.mData.mBaseCost << std::endl;
|
||||
std::cout << " Speed: " << mData.mData.mSpeed << std::endl;
|
||||
std::cout << " Size: " << mData.mData.mSize << std::endl;
|
||||
|
|
@ -893,7 +1002,7 @@ void Record<ESM::NPC>::print()
|
|||
std::cout << " Script: " << mData.mScript << std::endl;
|
||||
if (mData.mFaction != "")
|
||||
std::cout << " Faction: " << mData.mFaction << std::endl;
|
||||
std::cout << " Flags: " << mData.mFlags << std::endl;
|
||||
std::cout << " Flags: " << npcFlags(mData.mFlags) << std::endl;
|
||||
|
||||
// Seriously?
|
||||
if (mData.mNpdt52.mGold == -10)
|
||||
|
|
@ -929,7 +1038,7 @@ void Record<ESM::NPC>::print()
|
|||
|
||||
std::cout << " Skills:" << std::endl;
|
||||
for (int i = 0; i != 27; i++)
|
||||
std::cout << " " << i << " = "
|
||||
std::cout << " " << skillLabel(i) << ": "
|
||||
<< (int)((unsigned char)mData.mNpdt52.mSkills[i]) << std::endl;
|
||||
|
||||
std::cout << " Health: " << mData.mNpdt52.mHealth << std::endl;
|
||||
|
|
@ -1018,7 +1127,7 @@ void Record<ESM::Race>::print()
|
|||
{
|
||||
std::cout << " Name: " << mData.mName << std::endl;
|
||||
std::cout << " Description: " << mData.mDescription << std::endl;
|
||||
std::cout << " Flags: " << mData.mData.mFlags << std::endl;
|
||||
std::cout << " Flags: " << raceFlags(mData.mData.mFlags) << std::endl;
|
||||
|
||||
std::cout << " Male:" << std::endl;
|
||||
std::cout << " Strength: "
|
||||
|
|
@ -1067,8 +1176,10 @@ void Record<ESM::Race>::print()
|
|||
for (int i = 0; i != 7; i++)
|
||||
// Not all races have 7 skills.
|
||||
if (mData.mData.mBonus[i].mSkill != -1)
|
||||
std::cout << " Skill: " << mData.mData.mBonus[i].mSkill
|
||||
<< " = " << mData.mData.mBonus[i].mBonus << std::endl;
|
||||
std::cout << " Skill: "
|
||||
<< skillLabel(mData.mData.mBonus[i].mSkill)
|
||||
<< " (" << mData.mData.mBonus[i].mSkill << ") = "
|
||||
<< mData.mData.mBonus[i].mBonus << std::endl;
|
||||
|
||||
std::vector<std::string>::iterator sit;
|
||||
for (sit = mData.mPowers.mList.begin(); sit != mData.mPowers.mList.end(); sit++)
|
||||
|
|
@ -1130,18 +1241,15 @@ void Record<ESM::Script>::print()
|
|||
template<>
|
||||
void Record<ESM::Skill>::print()
|
||||
{
|
||||
std::cout << " ID: " << mData.mIndex << std::endl;
|
||||
|
||||
const char *spec = 0;
|
||||
int specId = mData.mData.mSpecialization;
|
||||
if (specId == 0) {
|
||||
spec = "Combat";
|
||||
} else if (specId == 1) {
|
||||
spec = "Magic";
|
||||
} else {
|
||||
spec = "Stealth";
|
||||
}
|
||||
std::cout << " Type: " << spec << std::endl;
|
||||
std::cout << " ID: " << skillLabel(mData.mIndex)
|
||||
<< " (" << mData.mIndex << ")" << std::endl;
|
||||
std::cout << " Description: " << mData.mDescription << std::endl;
|
||||
std::cout << " Governing Attribute: " << attributeLabel(mData.mData.mAttribute)
|
||||
<< " (" << mData.mData.mAttribute << ")" << std::endl;
|
||||
std::cout << " Specialization: " << specializationLabel(mData.mData.mSpecialization)
|
||||
<< " (" << mData.mData.mSpecialization << ")" << std::endl;
|
||||
for (int i = 0; i != 4; i++)
|
||||
std::cout << " UseValue[" << i << "]:" << mData.mData.mUseValue[i] << std::endl;
|
||||
}
|
||||
|
||||
template<>
|
||||
|
|
@ -1149,7 +1257,8 @@ void Record<ESM::SoundGenerator>::print()
|
|||
{
|
||||
std::cout << " Creature: " << mData.mCreature << std::endl;
|
||||
std::cout << " Sound: " << mData.mSound << std::endl;
|
||||
std::cout << " Type: " << mData.mType << std::endl;
|
||||
std::cout << " Type: " << soundTypeLabel(mData.mType)
|
||||
<< " (" << mData.mType << ")" << std::endl;
|
||||
}
|
||||
|
||||
template<>
|
||||
|
|
@ -1166,8 +1275,9 @@ template<>
|
|||
void Record<ESM::Spell>::print()
|
||||
{
|
||||
std::cout << " Name: " << mData.mName << std::endl;
|
||||
std::cout << " Type: " << mData.mData.mType << std::endl;
|
||||
std::cout << " Flags: " << mData.mData.mFlags << std::endl;
|
||||
std::cout << " Type: " << spellTypeLabel(mData.mData.mType)
|
||||
<< " (" << mData.mData.mType << ")" << std::endl;
|
||||
std::cout << " Flags: " << spellFlags(mData.mData.mFlags) << std::endl;
|
||||
std::cout << " Cost: " << mData.mData.mCost << std::endl;
|
||||
printEffectList(mData.mEffects);
|
||||
}
|
||||
|
|
@ -1199,8 +1309,9 @@ void Record<ESM::Weapon>::print()
|
|||
std::cout << " Script: " << mData.mScript << std::endl;
|
||||
if (mData.mEnchant != "")
|
||||
std::cout << " Enchantment: " << mData.mEnchant << std::endl;
|
||||
std::cout << " Type: " << mData.mData.mType << std::endl;
|
||||
std::cout << " Flags: " << mData.mData.mFlags << std::endl;
|
||||
std::cout << " Type: " << weaponTypeLabel(mData.mData.mType)
|
||||
<< " (" << mData.mData.mType << ")" << std::endl;
|
||||
std::cout << " Flags: " << weaponFlags(mData.mData.mFlags) << std::endl;
|
||||
std::cout << " Weight: " << mData.mData.mWeight << std::endl;
|
||||
std::cout << " Value: " << mData.mData.mValue << std::endl;
|
||||
std::cout << " Health: " << mData.mData.mHealth << std::endl;
|
||||
|
|
|
|||
Loading…
Reference in a new issue