mirror/openmw
1
0
Fork 0
mirror of https://github.com/OpenMW/openmw.git synced 2025-01-21 06:53:53 +00:00
Code Issues Releases Wiki Activity

Merge remote-tracking branch 'origin/launcher-model' into launcher-model

Browse source 
Conflicts:
	apps/launcher/datafilespage.cpp
This commit is contained in:
Pieter van der Kloet 2012-10-22 14:59:43 +02:00
commit ab8894e07a
39 changed files with 1211 additions and 390 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
CMakeLists.txt
View file

@ -306,7 +306,7 @@ endif()
# Compiler settings # Compiler settings
if (CMAKE_COMPILER_IS_GNUCC) if (CMAKE_COMPILER_IS_GNUCC)
add_definitions (-Wall -Wextra -Wno-unused-parameter -Wno-reorder) add_definitions (-Wall -Wextra -Wno-unused-parameter -Wno-reorder -std=c++0x -pedantic)
# Silence warnings in OGRE headers. Remove once OGRE got fixed! # Silence warnings in OGRE headers. Remove once OGRE got fixed!
add_definitions (-Wno-ignored-qualifiers) add_definitions (-Wno-ignored-qualifiers)

2
apps/esmtool/CMakeLists.txt
View file

@ -1,5 +1,7 @@
set(ESMTOOL set(ESMTOOL
esmtool.cpp esmtool.cpp
labels.hpp
labels.cpp
record.hpp record.hpp
record.cpp record.cpp
) )

881
apps/esmtool/labels.cpp Normal file
View 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
View 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

313
apps/esmtool/record.cpp
View file

@ -1,54 +1,126 @@
#include "record.hpp" #include "record.hpp"
#include "labels.hpp"
#include <iostream> #include <iostream>
#include <boost/format.hpp> #include <boost/format.hpp>
void printAIPackage(ESM::AIPackage p) void printAIPackage(ESM::AIPackage p)
{ {
if (p.mType == ESM::AI_Wander) std::cout << " AI Type: " << aiTypeLabel(p.mType)
{ << " (" << boost::format("0x%08X") % p.mType << ")" << std::endl;
std::cout << " AIType Wander:" << 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 << " Distance: " << p.mWander.mDistance << std::endl;
std::cout << " Time of Day: " << (int)p.mWander.mTimeOfDay << std::endl; std::cout << " Duration: " << p.mWander.mDuration << std::endl;
if (p.mWander.mUnk != 1) std::cout << " Time of Day: " << (int)p.mWander.mTimeOfDay << std::endl;
std::cout << " Unknown: " << (int)p.mWander.mUnk << std::endl; if (p.mWander.mUnk != 1)
std::cout << " Unknown: " << (int)p.mWander.mUnk << std::endl;
std::cout << " Idle: "; std::cout << " Idle: ";
for (int i = 0; i != 8; i++) for (int i = 0; i != 8; i++)
std::cout << (int)p.mWander.mIdle[i] << " "; std::cout << (int)p.mWander.mIdle[i] << " ";
std::cout << std::endl; std::cout << std::endl;
} }
else if (p.mType == ESM::AI_Travel) else if (p.mType == ESM::AI_Travel)
{ {
std::cout << " AIType Travel:" << std::endl; std::cout << " Travel Coordinates: (" << p.mTravel.mX << ","
std::cout << " Travel Coordinates: (" << p.mTravel.mX << "," << p.mTravel.mY << "," << p.mTravel.mZ << ")" << std::endl;
<< p.mTravel.mY << "," << p.mTravel.mZ << ")" << std::endl; std::cout << " Travel Unknown: " << (int)p.mTravel.mUnk << std::endl;
std::cout << " Travel Unknown: " << (int)p.mTravel.mUnk << std::endl; }
} else if (p.mType == ESM::AI_Follow || p.mType == ESM::AI_Escort)
else if (p.mType == ESM::AI_Follow || p.mType == ESM::AI_Escort) {
{ std::cout << " Follow Coordinates: (" << p.mTarget.mX << ","
if (p.mType == ESM::AI_Follow) std::cout << " AIType Follow:" << std::endl; << p.mTarget.mY << "," << p.mTarget.mZ << ")" << std::endl;
else std::cout << " AIType Escort:" << 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;
}
std::cout << " Follow Coordinates: (" << p.mTarget.mX << "," if (p.mCellName != "")
<< p.mTarget.mY << "," << p.mTarget.mZ << ")" << std::endl; std::cout << " Cell Name: " << p.mCellName << 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;
}
if (p.mCellName != "") std::string ruleString(ESM::DialInfo::SelectStruct ss)
std::cout << " Cell Name: " << p.mCellName << std::endl; {
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;
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));
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) void printEffectList(ESM::EffectList effects)
@ -57,12 +129,16 @@ void printEffectList(ESM::EffectList effects)
std::vector<ESM::ENAMstruct>::iterator eit; std::vector<ESM::ENAMstruct>::iterator eit;
for (eit = effects.mList.begin(); eit != effects.mList.end(); 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) 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) if (eit->mAttribute != -1)
std::cout << " Attribute: " << (int)eit->mAttribute << std::endl; std::cout << " Attribute: " << attributeLabel(eit->mAttribute)
std::cout << " Range: " << eit->mRange << std::endl; << " (" << (int)eit->mAttribute << ")" << std::endl;
std::cout << " Range: " << rangeTypeLabel(eit->mRange)
<< " (" << eit->mRange << ")" << std::endl;
// Area is always zero if range type is "Self" // Area is always zero if range type is "Self"
if (eit->mRange != ESM::RT_Self) if (eit->mRange != ESM::RT_Self)
std::cout << " Area: " << eit->mArea << std::endl; std::cout << " Area: " << eit->mArea << std::endl;
@ -331,7 +407,8 @@ void Record<ESM::Armor>::print()
std::cout << " Script: " << mData.mScript << std::endl; std::cout << " Script: " << mData.mScript << std::endl;
if (mData.mEnchant != "") if (mData.mEnchant != "")
std::cout << " Enchantment: " << mData.mEnchant << std::endl; 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 << " Weight: " << mData.mData.mWeight << std::endl;
std::cout << " Value: " << mData.mData.mValue << std::endl; std::cout << " Value: " << mData.mData.mValue << std::endl;
std::cout << " Health: " << mData.mData.mHealth << 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; std::vector<ESM::PartReference>::iterator pit;
for (pit = mData.mParts.mParts.begin(); pit != mData.mParts.mParts.end(); 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; std::cout << " Male Name: " << pit->mMale << std::endl;
if (pit->mFemale != "") if (pit->mFemale != "")
std::cout << " Female Name: " << pit->mFemale << std::endl; 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 << " Model: " << mData.mModel << std::endl;
std::cout << " Icon: " << mData.mIcon << std::endl; std::cout << " Icon: " << mData.mIcon << std::endl;
std::cout << " Script: " << mData.mScript << 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 << " Weight: " << mData.mData.mWeight << std::endl;
std::cout << " Value: " << mData.mData.mValue << std::endl; std::cout << " Value: " << mData.mData.mValue << std::endl;
std::cout << " Quality: " << mData.mData.mQuality << 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 << " Name: " << mData.mName << std::endl;
std::cout << " Model: " << mData.mModel << std::endl; std::cout << " Model: " << mData.mModel << std::endl;
std::cout << " Type: " << (int)mData.mData.mType << std::endl; std::cout << " Type: " << meshTypeLabel(mData.mData.mType)
std::cout << " Flags: " << (int)mData.mData.mFlags << std::endl; << " (" << (int)mData.mData.mType << ")" << std::endl;
std::cout << " Part: " << (int)mData.mData.mPart << 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; 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; std::cout << " Name: " << mData.mName << std::endl;
if (mData.mRegion != "") if (mData.mRegion != "")
std::cout << " Region: " << mData.mRegion << std::endl; 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() << "," std::cout << " Coordinates: " << " (" << mData.getGridX() << ","
<< mData.getGridY() << ")" << std::endl; << mData.getGridY() << ")" << std::endl;
@ -441,13 +522,18 @@ void Record<ESM::Class>::print()
std::cout << " Description: " << mData.mDescription << std::endl; std::cout << " Description: " << mData.mDescription << std::endl;
std::cout << " Playable: " << mData.mData.mIsPlayable << std::endl; std::cout << " Playable: " << mData.mData.mIsPlayable << std::endl;
std::cout << " AutoCalc: " << mData.mData.mCalc << std::endl; std::cout << " AutoCalc: " << mData.mData.mCalc << std::endl;
std::cout << " Attribute1: " << mData.mData.mAttribute[0] << std::endl; std::cout << " Attribute1: " << attributeLabel(mData.mData.mAttribute[0])
std::cout << " Attribute2: " << mData.mData.mAttribute[1] << std::endl; << " (" << mData.mData.mAttribute[0] << ")" << std::endl;
std::cout << " Specialization: " << mData.mData.mSpecialization << 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++) 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++) 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<> template<>
@ -460,10 +546,20 @@ void Record<ESM::Clothing>::print()
std::cout << " Script: " << mData.mScript << std::endl; std::cout << " Script: " << mData.mScript << std::endl;
if (mData.mEnchant != "") if (mData.mEnchant != "")
std::cout << " Enchantment: " << mData.mEnchant << std::endl; 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 << " Weight: " << mData.mData.mWeight << std::endl;
std::cout << " Value: " << mData.mData.mValue << 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<> template<>
@ -473,7 +569,7 @@ void Record<ESM::Container>::print()
std::cout << " Model: " << mData.mModel << std::endl; std::cout << " Model: " << mData.mModel << std::endl;
if (mData.mScript != "") if (mData.mScript != "")
std::cout << " Script: " << mData.mScript << std::endl; 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::cout << " Weight: " << mData.mWeight << std::endl;
std::vector<ESM::ContItem>::iterator cit; std::vector<ESM::ContItem>::iterator cit;
for (cit = mData.mInventory.mList.begin(); cit != mData.mInventory.mList.end(); 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 << " Name: " << mData.mName << std::endl;
std::cout << " Model: " << mData.mModel << std::endl; std::cout << " Model: " << mData.mModel << std::endl;
std::cout << " Script: " << mData.mScript << 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 << " Original: " << mData.mOriginal << std::endl;
std::cout << " Scale: " << mData.mScale << 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 << " Level: " << mData.mData.mLevel << std::endl;
std::cout << " Attributes:" << std::endl; std::cout << " Attributes:" << std::endl;
@ -547,7 +644,8 @@ void Record<ESM::Creature>::print()
template<> template<>
void Record<ESM::Dialogue>::print() 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 // Sadly, there are no DialInfos, because the loader dumps as it
// loads, rather than loading and then dumping. :-( Anyone mind if // loads, rather than loading and then dumping. :-( Anyone mind if
// I change this? // I change this?
@ -569,7 +667,8 @@ void Record<ESM::Door>::print()
template<> template<>
void Record<ESM::Enchantment>::print() 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 << " Cost: " << mData.mData.mCost << std::endl;
std::cout << " Charge: " << mData.mData.mCharge << std::endl; std::cout << " Charge: " << mData.mData.mCharge << std::endl;
std::cout << " AutoCalc: " << mData.mData.mAutocalc << 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; std::cout << " Hidden: " << mData.mData.mIsHidden << std::endl;
if (mData.mData.mUnknown != -1) if (mData.mData.mUnknown != -1)
std::cout << " Unknown: " << mData.mData.mUnknown << std::endl; std::cout << " Unknown: " << mData.mData.mUnknown << std::endl;
std::cout << " Attribute1: " << mData.mData.mAttribute1 << std::endl; std::cout << " Attribute1: " << attributeLabel(mData.mData.mAttribute1)
std::cout << " Attribute2: " << mData.mData.mAttribute2 << std::endl; << " (" << mData.mData.mAttribute1 << ")" << std::endl;
std::cout << " Attribute2: " << attributeLabel(mData.mData.mAttribute2)
<< " (" << mData.mData.mAttribute2 << ")" << std::endl;
for (int i = 0; i != 6; i++) for (int i = 0; i != 6; i++)
if (mData.mData.mSkillID[i] != -1) 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++) for (int i = 0; i != 10; i++)
if (mData.mRanks[i] != "") if (mData.mRanks[i] != "")
{ {
@ -683,13 +785,14 @@ void Record<ESM::DialInfo>::print()
// std::cout << "-------------------------------------------" << std::endl; // 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 << " Unknown1: " << mData.mData.mUnknown1 << std::endl;
std::cout << " Unknown2: " << (int)mData.mData.mUnknown2 << std::endl; std::cout << " Unknown2: " << (int)mData.mData.mUnknown2 << std::endl;
std::vector<ESM::DialInfo::SelectStruct>::iterator sit; std::vector<ESM::DialInfo::SelectStruct>::iterator sit;
for (sit = mData.mSelects.begin(); sit != mData.mSelects.end(); 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<> template<>
@ -706,9 +809,12 @@ void Record<ESM::Ingredient>::print()
{ {
// A value of -1 means no effect // A value of -1 means no effect
if (mData.mData.mEffectID[i] == -1) continue; if (mData.mData.mEffectID[i] == -1) continue;
std::cout << " Effect: " << mData.mData.mEffectID[i] << std::endl; std::cout << " Effect: " << magicEffectLabel(mData.mData.mEffectID[i])
std::cout << " Skill: " << mData.mData.mSkills[i] << std::endl; << " (" << mData.mData.mEffectID[i] << ")" << std::endl;
std::cout << " Attribute: " << mData.mData.mAttributes[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() void Record<ESM::Land>::print()
{ {
std::cout << " Coordinates: (" << mData.mX << "," << mData.mY << ")" << std::endl; 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 << " HasData: " << mData.mHasData << std::endl;
std::cout << " DataTypes: " << mData.mDataTypes << std::endl; std::cout << " DataTypes: " << mData.mDataTypes << std::endl;
@ -739,7 +845,7 @@ template<>
void Record<ESM::CreatureLevList>::print() void Record<ESM::CreatureLevList>::print()
{ {
std::cout << " Chance for None: " << (int)mData.mChanceNone << std::endl; 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::cout << " Number of items: " << mData.mList.size() << std::endl;
std::vector<ESM::LeveledListBase::LevelItem>::iterator iit; std::vector<ESM::LeveledListBase::LevelItem>::iterator iit;
for (iit = mData.mList.begin(); iit != mData.mList.end(); iit++) for (iit = mData.mList.begin(); iit != mData.mList.end(); iit++)
@ -751,7 +857,7 @@ template<>
void Record<ESM::ItemLevList>::print() void Record<ESM::ItemLevList>::print()
{ {
std::cout << " Chance for None: " << (int)mData.mChanceNone << std::endl; 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::cout << " Number of items: " << mData.mList.size() << std::endl;
std::vector<ESM::LeveledListBase::LevelItem>::iterator iit; std::vector<ESM::LeveledListBase::LevelItem>::iterator iit;
for (iit = mData.mList.begin(); iit != mData.mList.end(); 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; std::cout << " Icon: " << mData.mIcon << std::endl;
if (mData.mScript != "") if (mData.mScript != "")
std::cout << " Script: " << mData.mScript << std::endl; 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 << " Weight: " << mData.mData.mWeight << std::endl;
std::cout << " Value: " << mData.mData.mValue << std::endl; std::cout << " Value: " << mData.mData.mValue << std::endl;
std::cout << " Sound: " << mData.mSound << 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; std::cout << " Icon: " << mData.mIcon << std::endl;
if (mData.mScript != "") if (mData.mScript != "")
std::cout << " Script: " << mData.mScript << std::endl; std::cout << " Script: " << mData.mScript << std::endl;
// BUG? No Type Label?
std::cout << " Type: " << mData.mType << std::endl; std::cout << " Type: " << mData.mType << std::endl;
std::cout << " Weight: " << mData.mData.mWeight << std::endl; std::cout << " Weight: " << mData.mData.mWeight << std::endl;
std::cout << " Value: " << mData.mData.mValue << std::endl; std::cout << " Value: " << mData.mData.mValue << std::endl;
@ -835,10 +942,11 @@ void Record<ESM::LandTexture>::print()
template<> template<>
void Record<ESM::MagicEffect>::print() 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 << " Description: " << mData.mDescription << std::endl;
std::cout << " Icon: " << mData.mIcon << 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; std::cout << " Particle Texture: " << mData.mParticle << std::endl;
if (mData.mCasting != "") if (mData.mCasting != "")
std::cout << " Casting Static: " << mData.mCasting << std::endl; 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; std::cout << " Area Static: " << mData.mArea << std::endl;
if (mData.mAreaSound != "") if (mData.mAreaSound != "")
std::cout << " Area Sound: " << mData.mAreaSound << std::endl; 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 << " Base Cost: " << mData.mData.mBaseCost << std::endl;
std::cout << " Speed: " << mData.mData.mSpeed << std::endl; std::cout << " Speed: " << mData.mData.mSpeed << std::endl;
std::cout << " Size: " << mData.mData.mSize << 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; std::cout << " Script: " << mData.mScript << std::endl;
if (mData.mFaction != "") if (mData.mFaction != "")
std::cout << " Faction: " << mData.mFaction << std::endl; std::cout << " Faction: " << mData.mFaction << std::endl;
std::cout << " Flags: " << mData.mFlags << std::endl; std::cout << " Flags: " << npcFlags(mData.mFlags) << std::endl;
// Seriously? // Seriously?
if (mData.mNpdt52.mGold == -10) if (mData.mNpdt52.mGold == -10)
@ -929,7 +1038,7 @@ void Record<ESM::NPC>::print()
std::cout << " Skills:" << std::endl; std::cout << " Skills:" << std::endl;
for (int i = 0; i != 27; i++) for (int i = 0; i != 27; i++)
std::cout << " " << i << " = " std::cout << " " << skillLabel(i) << ": "
<< (int)((unsigned char)mData.mNpdt52.mSkills[i]) << std::endl; << (int)((unsigned char)mData.mNpdt52.mSkills[i]) << std::endl;
std::cout << " Health: " << mData.mNpdt52.mHealth << 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 << " Name: " << mData.mName << std::endl;
std::cout << " Description: " << mData.mDescription << 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 << " Male:" << std::endl;
std::cout << " Strength: " std::cout << " Strength: "
@ -1067,8 +1176,10 @@ void Record<ESM::Race>::print()
for (int i = 0; i != 7; i++) for (int i = 0; i != 7; i++)
// Not all races have 7 skills. // Not all races have 7 skills.
if (mData.mData.mBonus[i].mSkill != -1) if (mData.mData.mBonus[i].mSkill != -1)
std::cout << " Skill: " << mData.mData.mBonus[i].mSkill std::cout << " Skill: "
<< " = " << mData.mData.mBonus[i].mBonus << std::endl; << skillLabel(mData.mData.mBonus[i].mSkill)
<< " (" << mData.mData.mBonus[i].mSkill << ") = "
<< mData.mData.mBonus[i].mBonus << std::endl;
std::vector<std::string>::iterator sit; std::vector<std::string>::iterator sit;
for (sit = mData.mPowers.mList.begin(); sit != mData.mPowers.mList.end(); sit++) for (sit = mData.mPowers.mList.begin(); sit != mData.mPowers.mList.end(); sit++)
@ -1130,18 +1241,15 @@ void Record<ESM::Script>::print()
template<> template<>
void Record<ESM::Skill>::print() void Record<ESM::Skill>::print()
{ {
std::cout << " ID: " << mData.mIndex << std::endl; std::cout << " ID: " << skillLabel(mData.mIndex)
<< " (" << mData.mIndex << ")" << std::endl;
const char *spec = 0; std::cout << " Description: " << mData.mDescription << std::endl;
int specId = mData.mData.mSpecialization; std::cout << " Governing Attribute: " << attributeLabel(mData.mData.mAttribute)
if (specId == 0) { << " (" << mData.mData.mAttribute << ")" << std::endl;
spec = "Combat"; std::cout << " Specialization: " << specializationLabel(mData.mData.mSpecialization)
} else if (specId == 1) { << " (" << mData.mData.mSpecialization << ")" << std::endl;
spec = "Magic"; for (int i = 0; i != 4; i++)
} else { std::cout << " UseValue[" << i << "]:" << mData.mData.mUseValue[i] << std::endl;
spec = "Stealth";
}
std::cout << " Type: " << spec << std::endl;
} }
template<> template<>
@ -1149,7 +1257,8 @@ void Record<ESM::SoundGenerator>::print()
{ {
std::cout << " Creature: " << mData.mCreature << std::endl; std::cout << " Creature: " << mData.mCreature << std::endl;
std::cout << " Sound: " << mData.mSound << 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<> template<>
@ -1166,8 +1275,9 @@ template<>
void Record<ESM::Spell>::print() void Record<ESM::Spell>::print()
{ {
std::cout << " Name: " << mData.mName << std::endl; std::cout << " Name: " << mData.mName << std::endl;
std::cout << " Type: " << mData.mData.mType << std::endl; std::cout << " Type: " << spellTypeLabel(mData.mData.mType)
std::cout << " Flags: " << mData.mData.mFlags << std::endl; << " (" << mData.mData.mType << ")" << std::endl;
std::cout << " Flags: " << spellFlags(mData.mData.mFlags) << std::endl;
std::cout << " Cost: " << mData.mData.mCost << std::endl; std::cout << " Cost: " << mData.mData.mCost << std::endl;
printEffectList(mData.mEffects); printEffectList(mData.mEffects);
} }
@ -1199,8 +1309,9 @@ void Record<ESM::Weapon>::print()
std::cout << " Script: " << mData.mScript << std::endl; std::cout << " Script: " << mData.mScript << std::endl;
if (mData.mEnchant != "") if (mData.mEnchant != "")
std::cout << " Enchantment: " << mData.mEnchant << std::endl; std::cout << " Enchantment: " << mData.mEnchant << std::endl;
std::cout << " Type: " << mData.mData.mType << std::endl; std::cout << " Type: " << weaponTypeLabel(mData.mData.mType)
std::cout << " Flags: " << mData.mData.mFlags << std::endl; << " (" << mData.mData.mType << ")" << std::endl;
std::cout << " Flags: " << weaponFlags(mData.mData.mFlags) << std::endl;
std::cout << " Weight: " << mData.mData.mWeight << std::endl; std::cout << " Weight: " << mData.mData.mWeight << std::endl;
std::cout << " Value: " << mData.mData.mValue << std::endl; std::cout << " Value: " << mData.mData.mValue << std::endl;
std::cout << " Health: " << mData.mData.mHealth << std::endl; std::cout << " Health: " << mData.mData.mHealth << std::endl;

35
apps/launcher/CMakeLists.txt
View file

@ -1,54 +1,51 @@
set(LAUNCHER set(LAUNCHER
datafilespage.cpp datafilespage.cpp
filedialog.cpp
graphicspage.cpp graphicspage.cpp
lineedit.cpp
main.cpp main.cpp
maindialog.cpp maindialog.cpp
naturalsort.cpp
playpage.cpp playpage.cpp
pluginsmodel.cpp
pluginsview.cpp
launcher.rc
model/datafilesmodel.cpp model/datafilesmodel.cpp
model/modelitem.cpp model/modelitem.cpp
model/esm/esmfile.cpp model/esm/esmfile.cpp
utils/filedialog.cpp
utils/naturalsort.cpp
utils/lineedit.cpp
launcher.rc
) )
set(LAUNCHER_HEADER set(LAUNCHER_HEADER
combobox.hpp
datafilespage.hpp datafilespage.hpp
filedialog.hpp
graphicspage.hpp graphicspage.hpp
lineedit.hpp
maindialog.hpp maindialog.hpp
naturalsort.hpp
playpage.hpp playpage.hpp
pluginsmodel.hpp
pluginsview.hpp
model/datafilesmodel.hpp model/datafilesmodel.hpp
model/modelitem.hpp model/modelitem.hpp
model/esm/esmfile.hpp model/esm/esmfile.hpp
utils/combobox.hpp
utils/lineedit.hpp
utils/filedialog.hpp
utils/naturalsort.hpp
) )
# Headers that must be pre-processed # Headers that must be pre-processed
set(LAUNCHER_HEADER_MOC set(LAUNCHER_HEADER_MOC
combobox.hpp
datafilespage.hpp datafilespage.hpp
filedialog.hpp
graphicspage.hpp graphicspage.hpp
lineedit.hpp
maindialog.hpp maindialog.hpp
playpage.hpp playpage.hpp
pluginsmodel.hpp
pluginsview.hpp
model/datafilesmodel.hpp model/datafilesmodel.hpp
model/modelitem.hpp model/modelitem.hpp
model/esm/esmfile.hpp model/esm/esmfile.hpp
utils/combobox.hpp
utils/lineedit.hpp
utils/filedialog.hpp
) )
source_group(launcher FILES ${LAUNCHER} ${LAUNCHER_HEADER} ${LAUNCHER_HEADER_MOC}) source_group(launcher FILES ${LAUNCHER} ${LAUNCHER_HEADER} ${LAUNCHER_HEADER_MOC})
@ -87,7 +84,7 @@ add_executable(omwlauncher
target_link_libraries(omwlauncher target_link_libraries(omwlauncher
${Boost_LIBRARIES} ${Boost_LIBRARIES}
${OGRE_LIBRARIES} ${OGRE_LIBRARIES}
${OGRE_STATIC_PLUGINS} ${OGRE_STATIC_PLUGINS}
${QT_LIBRARIES} ${QT_LIBRARIES}
components components
) )

10
apps/launcher/datafilespage.cpp
View file

@ -6,11 +6,12 @@
#include "model/datafilesmodel.hpp" #include "model/datafilesmodel.hpp"
#include "model/esm/esmfile.hpp" #include "model/esm/esmfile.hpp"
#include "combobox.hpp" #include "utils/combobox.hpp"
#include "utils/filedialog.hpp"
#include "utils/lineedit.hpp"
#include "utils/naturalsort.hpp"
#include "datafilespage.hpp" #include "datafilespage.hpp"
#include "filedialog.hpp"
#include "lineedit.hpp"
#include "naturalsort.hpp"
#include <boost/version.hpp> #include <boost/version.hpp>
/** /**
@ -112,6 +113,7 @@ DataFilesPage::DataFilesPage(Files::ConfigurationManager &cfg, QWidget *parent)
mPluginsTable->setVerticalScrollMode(QAbstractItemView::ScrollPerItem); mPluginsTable->setVerticalScrollMode(QAbstractItemView::ScrollPerItem);
mPluginsTable->horizontalHeader()->setStretchLastSection(true); mPluginsTable->horizontalHeader()->setStretchLastSection(true);
mPluginsTable->horizontalHeader()->hide(); mPluginsTable->horizontalHeader()->hide();
mPluginsTable->verticalHeader()->setDefaultSectionSize(height); mPluginsTable->verticalHeader()->setDefaultSectionSize(height);
mPluginsTable->verticalHeader()->setResizeMode(QHeaderView::Fixed); mPluginsTable->verticalHeader()->setResizeMode(QHeaderView::Fixed);
mPluginsTable->setColumnHidden(1, true); mPluginsTable->setColumnHidden(1, true);

1
apps/launcher/datafilespage.hpp
View file

@ -6,7 +6,6 @@
#include <components/files/collections.hpp> #include <components/files/collections.hpp>
#include "combobox.hpp"
class QTableView; class QTableView;
class QSortFilterProxyModel; class QSortFilterProxyModel;

3
apps/launcher/graphicspage.cpp
View file

@ -9,8 +9,9 @@
#include <components/files/ogreplugin.hpp> #include <components/files/ogreplugin.hpp>
#include <components/settings/settings.hpp> #include <components/settings/settings.hpp>
#include "utils/naturalsort.hpp"
#include "graphicspage.hpp" #include "graphicspage.hpp"
#include "naturalsort.hpp"
QString getAspect(int x, int y) QString getAspect(int x, int y)
{ {

2
apps/launcher/maindialog.cpp
View file

@ -1,5 +1,7 @@
#include <QtGui> #include <QtGui>
#include "utils/combobox.hpp"
#include "maindialog.hpp" #include "maindialog.hpp"
#include "playpage.hpp" #include "playpage.hpp"
#include "graphicspage.hpp" #include "graphicspage.hpp"

3
apps/launcher/model/datafilesmodel.cpp
View file

@ -6,8 +6,9 @@
#include "esm/esmfile.hpp" #include "esm/esmfile.hpp"
#include "../utils/naturalsort.hpp"
#include "datafilesmodel.hpp" #include "datafilesmodel.hpp"
#include "../naturalsort.hpp"
DataFilesModel::DataFilesModel(QObject *parent) : DataFilesModel::DataFilesModel(QObject *parent) :
QAbstractTableModel(parent) QAbstractTableModel(parent)

149
apps/launcher/pluginsmodel.cpp
View file

@ -1,149 +0,0 @@
#include <QMimeData>
#include <QBitArray>
#include <limits>
#include "pluginsmodel.hpp"
PluginsModel::PluginsModel(QObject *parent) : QStandardItemModel(parent)
{
}
void decodeDataRecursive(QDataStream &stream, QStandardItem *item)
{
int colCount, childCount;
stream >> *item;
stream >> colCount >> childCount;
item->setColumnCount(colCount);
int childPos = childCount;
while(childPos > 0) {
childPos--;
QStandardItem *child = new QStandardItem();
decodeDataRecursive(stream, child);
item->setChild( childPos / colCount, childPos % colCount, child);
}
}
bool PluginsModel::dropMimeData(const QMimeData *data, Qt::DropAction action,
int row, int column, const QModelIndex &parent)
{
// Code largely based on QStandardItemModel::dropMimeData
// check if the action is supported
if (!data || !(action == Qt::CopyAction || action == Qt::MoveAction))
return false;
// check if the format is supported
QString format = QLatin1String("application/x-qstandarditemmodeldatalist");
if (!data->hasFormat(format))
return QAbstractItemModel::dropMimeData(data, action, row, column, parent);
if (row > rowCount(parent))
row = rowCount(parent);
if (row == -1)
row = rowCount(parent);
if (column == -1)
column = 0;
// decode and insert
QByteArray encoded = data->data(format);
QDataStream stream(&encoded, QIODevice::ReadOnly);
//code based on QAbstractItemModel::decodeData
// adapted to work with QStandardItem
int top = std::numeric_limits<int>::max();
int left = std::numeric_limits<int>::max();
int bottom = 0;
int right = 0;
QVector<int> rows, columns;
QVector<QStandardItem *> items;
while (!stream.atEnd()) {
int r, c;
QStandardItem *item = new QStandardItem();
stream >> r >> c;
decodeDataRecursive(stream, item);
rows.append(r);
columns.append(c);
items.append(item);
top = qMin(r, top);
left = qMin(c, left);
bottom = qMax(r, bottom);
right = qMax(c, right);
}
// insert the dragged items into the table, use a bit array to avoid overwriting items,
// since items from different tables can have the same row and column
int dragRowCount = 0;
int dragColumnCount = right - left + 1;
// Compute the number of continuous rows upon insertion and modify the rows to match
QVector<int> rowsToInsert(bottom + 1);
for (int i = 0; i < rows.count(); ++i)
rowsToInsert[rows.at(i)] = 1;
for (int i = 0; i < rowsToInsert.count(); ++i) {
if (rowsToInsert[i] == 1){
rowsToInsert[i] = dragRowCount;
++dragRowCount;
}
}
for (int i = 0; i < rows.count(); ++i)
rows[i] = top + rowsToInsert[rows[i]];
QBitArray isWrittenTo(dragRowCount * dragColumnCount);
// make space in the table for the dropped data
int colCount = columnCount(parent);
if (colCount < dragColumnCount + column) {
insertColumns(colCount, dragColumnCount + column - colCount, parent);
colCount = columnCount(parent);
}
insertRows(row, dragRowCount, parent);
row = qMax(0, row);
column = qMax(0, column);
QStandardItem *parentItem = itemFromIndex (parent);
if (!parentItem)
parentItem = invisibleRootItem();
QVector<QPersistentModelIndex> newIndexes(items.size());
// set the data in the table
for (int j = 0; j < items.size(); ++j) {
int relativeRow = rows.at(j) - top;
int relativeColumn = columns.at(j) - left;
int destinationRow = relativeRow + row;
int destinationColumn = relativeColumn + column;
int flat = (relativeRow * dragColumnCount) + relativeColumn;
// if the item was already written to, or we just can't fit it in the table, create a new row
if (destinationColumn >= colCount || isWrittenTo.testBit(flat)) {
destinationColumn = qBound(column, destinationColumn, colCount - 1);
destinationRow = row + dragRowCount;
insertRows(row + dragRowCount, 1, parent);
flat = (dragRowCount * dragColumnCount) + relativeColumn;
isWrittenTo.resize(++dragRowCount * dragColumnCount);
}
if (!isWrittenTo.testBit(flat)) {
newIndexes[j] = index(destinationRow, destinationColumn, parentItem->index());
isWrittenTo.setBit(flat);
}
}
for(int k = 0; k < newIndexes.size(); k++) {
if (newIndexes.at(k).isValid()) {
parentItem->setChild(newIndexes.at(k).row(), newIndexes.at(k).column(), items.at(k));
} else {
delete items.at(k);
}
}
// The important part, tell the view what is dropped
emit indexesDropped(newIndexes);
return true;
}

21
apps/launcher/pluginsmodel.hpp
View file

@ -1,21 +0,0 @@
#ifndef PLUGINSMODEL_H
#define PLUGINSMODEL_H
#include <QStandardItemModel>
class PluginsModel : public QStandardItemModel
{
Q_OBJECT
public:
PluginsModel(QObject *parent = 0);
~PluginsModel() {};
bool dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent);
signals:
void indexesDropped(QVector<QPersistentModelIndex> indexes);
};
#endif

41
apps/launcher/pluginsview.cpp
View file

@ -1,41 +0,0 @@
#include <QSortFilterProxyModel>
#include "pluginsview.hpp"
PluginsView::PluginsView(QWidget *parent) : QTableView(parent)
{
setSelectionBehavior(QAbstractItemView::SelectRows);
setSelectionMode(QAbstractItemView::ExtendedSelection);
setEditTriggers(QAbstractItemView::NoEditTriggers);
setAlternatingRowColors(true);
setDragEnabled(true);
setDragDropMode(QAbstractItemView::InternalMove);
setDropIndicatorShown(true);
setDragDropOverwriteMode(false);
setContextMenuPolicy(Qt::CustomContextMenu);
}
void PluginsView::startDrag(Qt::DropActions supportedActions)
{
selectionModel()->select( selectionModel()->selection(),
QItemSelectionModel::Select | QItemSelectionModel::Rows );
QAbstractItemView::startDrag( supportedActions );
}
void PluginsView::setModel(QSortFilterProxyModel *model)
{
QTableView::setModel(model);
qRegisterMetaType< QVector<QPersistentModelIndex> >();
connect(model->sourceModel(), SIGNAL(indexesDropped(QVector<QPersistentModelIndex>)),
this, SLOT(selectIndexes(QVector<QPersistentModelIndex>)), Qt::QueuedConnection);
}
void PluginsView::selectIndexes( QVector<QPersistentModelIndex> aIndexes )
{
selectionModel()->clearSelection();
foreach( QPersistentModelIndex pIndex, aIndexes )
selectionModel()->select( pIndex, QItemSelectionModel::Select | QItemSelectionModel::Rows );
}

29
apps/launcher/pluginsview.hpp
View file

@ -1,29 +0,0 @@
#ifndef PLUGINSVIEW_H
#define PLUGINSVIEW_H
#include <QTableView>
#include "pluginsmodel.hpp"
class QSortFilterProxyModel;
class PluginsView : public QTableView
{
Q_OBJECT
public:
PluginsView(QWidget *parent = 0);
PluginsModel* model() const
{ return qobject_cast<PluginsModel*>(QAbstractItemView::model()); }
void startDrag(Qt::DropActions supportedActions);
void setModel(QSortFilterProxyModel *model);
public slots:
void selectIndexes(QVector<QPersistentModelIndex> aIndexes);
};
Q_DECLARE_METATYPE(QVector<QPersistentModelIndex>);
#endif

0
apps/launcher/combobox.hpp → apps/launcher/utils/combobox.hpp
View file

0
apps/launcher/filedialog.cpp → apps/launcher/utils/filedialog.cpp
View file

0
apps/launcher/filedialog.hpp → apps/launcher/utils/filedialog.hpp
View file

0
apps/launcher/lineedit.cpp → apps/launcher/utils/lineedit.cpp
View file

0
apps/launcher/lineedit.hpp → apps/launcher/utils/lineedit.hpp
View file

0
apps/launcher/naturalsort.cpp → apps/launcher/utils/naturalsort.cpp
View file

0
apps/launcher/naturalsort.hpp → apps/launcher/utils/naturalsort.hpp
View file

8
apps/mwiniimporter/importer.cpp
View file

@ -78,7 +78,7 @@ MwIniImporter::multistrmap MwIniImporter::loadIniFile(std::string filename) {
multistrmap::iterator it; multistrmap::iterator it;
if((it = map.find(key)) == map.end()) { if((it = map.find(key)) == map.end()) {
map.insert( std::make_pair<std::string, std::vector<std::string> > (key, std::vector<std::string>() ) ); map.insert( std::make_pair (key, std::vector<std::string>() ) );
} }
map[key].push_back(value); map[key].push_back(value);
} }
@ -115,7 +115,7 @@ MwIniImporter::multistrmap MwIniImporter::loadCfgFile(std::string filename) {
multistrmap::iterator it; multistrmap::iterator it;
if((it = map.find(key)) == map.end()) { if((it = map.find(key)) == map.end()) {
map.insert( std::make_pair<std::string, std::vector<std::string> > (key, std::vector<std::string>() ) ); map.insert( std::make_pair (key, std::vector<std::string>() ) );
} }
map[key].push_back(value); map[key].push_back(value);
} }
@ -152,12 +152,12 @@ void MwIniImporter::mergeFallback(multistrmap &cfg, multistrmap &ini) {
} }
} }
} }
}; }
void MwIniImporter::insertMultistrmap(multistrmap &cfg, std::string key, std::string value) { void MwIniImporter::insertMultistrmap(multistrmap &cfg, std::string key, std::string value) {
multistrmap::iterator it = cfg.find(key); multistrmap::iterator it = cfg.find(key);
if(it == cfg.end()) { if(it == cfg.end()) {
cfg.insert(std::make_pair<std::string, std::vector<std::string> >(key, std::vector<std::string>() )); cfg.insert(std::make_pair (key, std::vector<std::string>() ));
} }
cfg[key].push_back(value); cfg[key].push_back(value);
} }

2
apps/openmw/main.cpp
View file

@ -68,7 +68,7 @@ void validate(boost::any &v, std::vector<std::string> const &tokens, FallbackMap
if((mapIt = map->mMap.find(key)) == map->mMap.end()) if((mapIt = map->mMap.find(key)) == map->mMap.end())
{ {
map->mMap.insert(std::make_pair<std::string,std::string>(key,value)); map->mMap.insert(std::make_pair (key,value));
} }
} }
} }

2
apps/openmw/mwbase/soundmanager.hpp
View file

@ -37,7 +37,7 @@ namespace MWBase
Play_Normal = 0, /* tracked, non-looping, multi-instance, environment */ Play_Normal = 0, /* tracked, non-looping, multi-instance, environment */
Play_Loop = 1<<0, /* Sound will continually loop until explicitly stopped */ Play_Loop = 1<<0, /* Sound will continually loop until explicitly stopped */
Play_NoEnv = 1<<1, /* Do not apply environment effects (eg, underwater filters) */ Play_NoEnv = 1<<1, /* Do not apply environment effects (eg, underwater filters) */
Play_NoTrack = 1<<2, /* (3D only) Play the sound at the given object's position Play_NoTrack = 1<<2 /* (3D only) Play the sound at the given object's position
* but do not keep it updated (the sound will not move with * but do not keep it updated (the sound will not move with
* the object and will not stop when the object is deleted. */ * the object and will not stop when the object is deleted. */
}; };

2
apps/openmw/mwmechanics/drawstate.hpp
View file

@ -8,7 +8,7 @@ namespace MWMechanics
{ {
DrawState_Weapon = 0, DrawState_Weapon = 0,
DrawState_Spell = 1, DrawState_Spell = 1,
DrawState_Nothing = 2, DrawState_Nothing = 2
}; };
} }

4
apps/openmw/mwrender/globalmap.cpp
View file

@ -53,7 +53,7 @@ namespace MWRender
{ {
Ogre::Image image; Ogre::Image image;
Ogre::uchar data[mWidth * mHeight * 3]; std::vector<Ogre::uchar> data (mWidth * mHeight * 3);
for (int x = mMinX; x <= mMaxX; ++x) for (int x = mMinX; x <= mMaxX; ++x)
{ {
@ -150,7 +150,7 @@ namespace MWRender
} }
} }
image.loadDynamicImage (data, mWidth, mHeight, Ogre::PF_B8G8R8); image.loadDynamicImage (&data[0], mWidth, mHeight, Ogre::PF_B8G8R8);
//image.save (mCacheDir + "/GlobalMap.png"); //image.save (mCacheDir + "/GlobalMap.png");

2
apps/openmw/mwrender/water.hpp
View file

@ -23,7 +23,7 @@ namespace Ogre
class Entity; class Entity;
class Vector3; class Vector3;
struct RenderTargetEvent; struct RenderTargetEvent;
}; }
namespace MWRender { namespace MWRender {

2
apps/openmw/mwscript/scriptmanagerimp.hpp
View file

@ -74,6 +74,6 @@ namespace MWScript
///< Return index of the variable of the given name and type in the given script. Will ///< Return index of the variable of the given name and type in the given script. Will
/// throw an exception, if there is no such script or variable or the type does not match. /// throw an exception, if there is no such script or variable or the type does not match.
}; };
}; }
#endif #endif

2
apps/openmw/mwsound/mpgsnd_decoder.hpp
View file

@ -52,6 +52,6 @@ namespace MWSound
#ifndef DEFAULT_DECODER #ifndef DEFAULT_DECODER
#define DEFAULT_DECODER (::MWSound::MpgSnd_Decoder) #define DEFAULT_DECODER (::MWSound::MpgSnd_Decoder)
#endif #endif
}; }
#endif #endif

2
apps/openmw/mwsound/openal_output.hpp
View file

@ -66,6 +66,6 @@ namespace MWSound
#ifndef DEFAULT_OUTPUT #ifndef DEFAULT_OUTPUT
#define DEFAULT_OUTPUT (::MWSound::OpenAL_Output) #define DEFAULT_OUTPUT (::MWSound::OpenAL_Output)
#endif #endif
}; }
#endif #endif

2
apps/openmw/mwsound/soundmanagerimp.hpp
View file

@ -26,7 +26,7 @@ namespace MWSound
enum Environment { enum Environment {
Env_Normal, Env_Normal,
Env_Underwater, Env_Underwater
}; };
class SoundManager : public MWBase::SoundManager class SoundManager : public MWBase::SoundManager

2
components/esm/aipackage.hpp
View file

@ -60,7 +60,7 @@ namespace ESM
AI_Travel = 0x545f4941, AI_Travel = 0x545f4941,
AI_Follow = 0x465f4941, AI_Follow = 0x465f4941,
AI_Escort = 0x455f4941, AI_Escort = 0x455f4941,
AI_Activate = 0x415f4941, AI_Activate = 0x415f4941
}; };
/// \note Used for storaging packages in a single container /// \note Used for storaging packages in a single container

4
components/esm/esmwriter.cpp
View file

@ -138,11 +138,11 @@ void ESMWriter::writeHNString(const std::string& name, const std::string& data)
void ESMWriter::writeHNString(const std::string& name, const std::string& data, int size) void ESMWriter::writeHNString(const std::string& name, const std::string& data, int size)
{ {
assert(data.size() <= size); assert(static_cast<int> (data.size()) <= size);
startSubRecord(name); startSubRecord(name);
writeHString(data); writeHString(data);
if (data.size() < size) if (static_cast<int> (data.size()) < size)
{ {
for (int i = data.size(); i < size; ++i) for (int i = data.size(); i < size; ++i)
write("\0",1); write("\0",1);

4
components/esm_store/reclists.hpp
View file

@ -331,7 +331,7 @@ namespace ESMS
// Find land for the given coordinates. Return null if no mData. // Find land for the given coordinates. Return null if no mData.
Land *search(int x, int y) const Land *search(int x, int y) const
{ {
LandMap::const_iterator itr = lands.find(std::make_pair<int, int>(x, y)); LandMap::const_iterator itr = lands.find(std::make_pair (x, y));
if ( itr == lands.end() ) if ( itr == lands.end() )
{ {
return NULL; return NULL;
@ -350,7 +350,7 @@ namespace ESMS
land->load(esm); land->load(esm);
// Store the structure // Store the structure
lands[std::make_pair<int, int>(land->mX, land->mY)] = land; lands[std::make_pair (land->mX, land->mY)] = land;
} }
}; };

1
credits.txt
View file

@ -16,6 +16,7 @@ Alexander Olofsson (Ace)
Artem Kotsynyak (greye) Artem Kotsynyak (greye)
athile athile
BrotherBrick BrotherBrick
Cory F. Cohen (cfcohen)
Cris Mihalache (Mirceam) Cris Mihalache (Mirceam)
Douglas Diniz (Dgdiniz) Douglas Diniz (Dgdiniz)
Eli2 Eli2

2
extern/shiny vendored

@ -1 +1 @@
Subproject commit b9ed0f2f3f10915aafd083248a1d6a37293c0db0 Subproject commit f17c4ebab0e7a1f3bbb25fd9b3dbef2bd742536a

2
libs/openengine/bullet/CMotionState.cpp
View file

@ -16,7 +16,7 @@ namespace Physic
pEng = eng; pEng = eng;
tr.setIdentity(); tr.setIdentity();
pName = name; pName = name;
}; }
void CMotionState::getWorldTransform(btTransform &worldTrans) const void CMotionState::getWorldTransform(btTransform &worldTrans) const
{ {

2
libs/openengine/bullet/physic.cpp
View file

@ -626,4 +626,4 @@ namespace Physic
shape->Shape->getAabb(trans, min, max); shape->Shape->getAabb(trans, min, max);
} }
}}; }}