diff --git a/CBash.suo b/CBash.suo index f66c25b..8e40dc8 100644 Binary files a/CBash.suo and b/CBash.suo differ diff --git a/CBash/CBash.cpp b/CBash/CBash.cpp index fcff26f..d81928e 100644 --- a/CBash/CBash.cpp +++ b/CBash/CBash.cpp @@ -549,7 +549,7 @@ CPPDLLEXTERN SINT32 CleanModMasters(ModFile *ModID) return -1; } -CPPDLLEXTERN SINT32 SaveMod(ModFile *ModID, const UINT32 SaveFlagsField) +CPPDLLEXTERN SINT32 SaveMod(ModFile *ModID, const UINT32 SaveFlagsField, STRING const DestinationName) { SINT32 err = 0; SaveFlags flags(SaveFlagsField); @@ -559,7 +559,7 @@ CPPDLLEXTERN SINT32 SaveMod(ModFile *ModID, const UINT32 SaveFlagsField) PROFILE_FUNC //ValidatePointer(CollectionID); //ValidatePointer(ModID); - err = ModID->Parent->SaveMod(ModID, flags); + err = ModID->Parent->SaveMod(ModID, flags, DestinationName); } catch(std::exception &ex) { diff --git a/CBash/CBash.h b/CBash/CBash.h index cc5a0a1..a457f6e 100644 --- a/CBash/CBash.h +++ b/CBash/CBash.h @@ -60,7 +60,7 @@ DLLEXTERN SINT32 AddMod(Collection *CollectionID, STRING const ModName, const UI DLLEXTERN SINT32 LoadMod(ModFile *ModID); DLLEXTERN SINT32 UnloadMod(ModFile *ModID); DLLEXTERN SINT32 CleanModMasters(ModFile *ModID); -DLLEXTERN SINT32 SaveMod(ModFile *ModID, const UINT32 SaveFlagsField); +DLLEXTERN SINT32 SaveMod(ModFile *ModID, const UINT32 SaveFlagsField, STRING const DestinationName); //////////////////////////////////////////////////////////////////////// //Mod info functions DLLEXTERN SINT32 GetAllNumMods(Collection *CollectionID); diff --git a/CBash/Collection.cpp b/CBash/Collection.cpp index 8560871..57728f5 100644 --- a/CBash/Collection.cpp +++ b/CBash/Collection.cpp @@ -208,7 +208,7 @@ ModFile * Collection::IsModAdded(STRING const &ModName) return NULL; } -SINT32 Collection::SaveMod(ModFile *&curModFile, SaveFlags &flags) +SINT32 Collection::SaveMod(ModFile *&curModFile, SaveFlags &flags, STRING const DestinationName) { if(!curModFile->Flags.IsSaveable) { @@ -233,13 +233,13 @@ SINT32 Collection::SaveMod(ModFile *&curModFile, SaveFlags &flags) _chdir(ModsDir); - STRING temp_name = GetTemporaryFileName(curModFile->ModName); //deleted when RenameOp is destroyed + STRING temp_name = GetTemporaryFileName(DestinationName != NULL ? DestinationName : curModFile->ModName); //deleted when RenameOp is destroyed //Save the mod to temp file curModFile->Save(temp_name, Expanders, flags.IsCloseCollection, indexer); //Delay renaming temp file to original filename until collection is closed //This way the file mapping can remain open and the entire file doesn't have to be loaded into memory - closing_ops.push_back(new RenameOp(temp_name, curModFile->FileName)); + closing_ops.push_back(new RenameOp(temp_name, DestinationName != NULL ? DestinationName : curModFile->FileName)); return 0; } diff --git a/CBash/Collection.h b/CBash/Collection.h index 05b5db0..d222139 100644 --- a/CBash/Collection.h +++ b/CBash/Collection.h @@ -81,7 +81,7 @@ class Collection SINT32 AddMod(STRING const &_FileName, ModFlags &flags, bool IsPreloading=false); ModFile * IsModAdded(STRING const &ModName); - SINT32 SaveMod(ModFile *&curModFile, SaveFlags &flags); + SINT32 SaveMod(ModFile *&curModFile, SaveFlags &flags, STRING const DestinationName); SINT32 Load(); void UndeleteRecords(std::vector > > &DeletedRecords); diff --git a/CBash/Common.cpp b/CBash/Common.cpp index 15ef44e..4bcc082 100644 --- a/CBash/Common.cpp +++ b/CBash/Common.cpp @@ -1016,14 +1016,14 @@ StringRecord& StringRecord::operator = (const StringRecord &rhs) } NonNullStringRecord::NonNullStringRecord(): - value(NULL), + _value(NULL), DiskSize(0) { // } NonNullStringRecord::NonNullStringRecord(const NonNullStringRecord &p): - value(NULL), + _value(NULL), DiskSize(0) { if(!p.IsLoaded()) @@ -1031,31 +1031,46 @@ NonNullStringRecord::NonNullStringRecord(const NonNullStringRecord &p): if(p.DiskSize) { - value = p.value; + _value = p._value; DiskSize = p.DiskSize; } else { UINT32 size = p.GetSize(); - value = new char[size]; - memcpy(value, p.value, size); + _value = new char[size]; + memcpy(_value, p._value, size); } } NonNullStringRecord::~NonNullStringRecord() { if(DiskSize == 0) - delete []value; + delete []_value; } UINT32 NonNullStringRecord::GetSize() const { - return value != NULL ? (DiskSize ? DiskSize : (UINT32)strlen(value)) : 0; + return _value != NULL ? (DiskSize ? DiskSize : (UINT32)strlen(_value)) : 0; + } + +STRING NonNullStringRecord::GetString() + { + if(DiskSize != 0) + { + //Have to sanitize the string before letting it be used + //The string needs a null terminator added, so load it from disk + STRING nvalue = new char[DiskSize + 1]; + nvalue[DiskSize] = 0x00; + memcpy(nvalue, _value, DiskSize); + _value = nvalue; + DiskSize = 0; + } + return _value; } bool NonNullStringRecord::IsLoaded() const { - return value != NULL; + return _value != NULL; } void NonNullStringRecord::Load() @@ -1067,8 +1082,8 @@ void NonNullStringRecord::Unload() { if(DiskSize == 0) { - delete []value; - value = NULL; + delete []_value; + _value = NULL; } } @@ -1081,14 +1096,14 @@ bool NonNullStringRecord::Read(unsigned char *&buffer, const UINT32 &subSize, co } if(CompressedOnDisk) { - value = new char[subSize + 1]; - value[subSize] = 0x00; - memcpy(value, buffer, subSize); + _value = new char[subSize + 1]; + _value[subSize] = 0x00; + memcpy(_value, buffer, subSize); } else { DiskSize = subSize; - value = (char *)buffer; + _value = (char *)buffer; } buffer += subSize; return true; @@ -1096,14 +1111,14 @@ bool NonNullStringRecord::Read(unsigned char *&buffer, const UINT32 &subSize, co void NonNullStringRecord::Write(UINT32 _Type, FileWriter &writer) { - if(value != NULL) - writer.record_write_subrecord(_Type, value, DiskSize ? DiskSize : (UINT32)strlen(value)); + if(_value != NULL) + writer.record_write_subrecord(_Type, _value, DiskSize ? DiskSize : (UINT32)strlen(_value)); } void NonNullStringRecord::ReqWrite(UINT32 _Type, FileWriter &writer) { - if(value != NULL) - writer.record_write_subrecord(_Type, value, DiskSize ? DiskSize : (UINT32)strlen(value)); + if(_value != NULL) + writer.record_write_subrecord(_Type, _value, DiskSize ? DiskSize : (UINT32)strlen(_value)); else { char null = 0x00; @@ -1118,19 +1133,19 @@ void NonNullStringRecord::Copy(STRING FieldValue) { DiskSize = 0; UINT32 size = (UINT32)strlen(FieldValue) + 1; - value = new char[size]; - memcpy(value, FieldValue, size); + _value = new char[size]; + memcpy(_value, FieldValue, size); } } bool NonNullStringRecord::equals(const NonNullStringRecord &other) const { - return cmps(value, other.value) == 0; + return cmps(_value, other._value) == 0; } bool NonNullStringRecord::equalsi(const NonNullStringRecord &other) const { - return icmps(value, other.value) == 0; + return icmps(_value, other._value) == 0; } NonNullStringRecord& NonNullStringRecord::operator = (const NonNullStringRecord &rhs) @@ -1140,15 +1155,15 @@ NonNullStringRecord& NonNullStringRecord::operator = (const NonNullStringRecord Unload(); if(rhs.DiskSize) { - value = rhs.value; + _value = rhs._value; DiskSize = rhs.DiskSize; } - else if(rhs.value != NULL) + else if(rhs._value != NULL) { DiskSize = 0; - UINT32 size = (UINT32)strlen(rhs.value) + 1; - value = new char[size]; - memcpy(value, rhs.value, size); + UINT32 size = (UINT32)strlen(rhs._value) + 1; + _value = new char[size]; + memcpy(_value, rhs._value, size); } } return *this; diff --git a/CBash/Common.h b/CBash/Common.h index df5d23c..7e70787 100644 --- a/CBash/Common.h +++ b/CBash/Common.h @@ -72,7 +72,7 @@ enum API_FieldTypes { UNKNOWN_OR_FORMID_OR_UINT32_FIELD, UNKNOWN_OR_SINT32_FIELD, UNKNOWN_OR_UINT32_FLAG_FIELD, - MGEFCODE_OR_UINT32_FIELD, + MGEFCODE_OR_CHAR4_FIELD, FORMID_OR_MGEFCODE_OR_ACTORVALUE_OR_UINT32_FIELD, RESOLVED_MGEFCODE_FIELD, STATIC_MGEFCODE_FIELD, @@ -650,15 +650,17 @@ class NonNullStringRecord { private: UINT32 DiskSize; + STRING _value; public: - STRING value; + __declspec(property(get=GetString)) STRING value; NonNullStringRecord(); NonNullStringRecord(const NonNullStringRecord &p); ~NonNullStringRecord(); UINT32 GetSize() const; + STRING GetString(); bool IsLoaded() const; void Load(); diff --git a/CBash/FalloutNewVegas/Records/API/MGEFRecordAPI.cpp b/CBash/FalloutNewVegas/Records/API/MGEFRecordAPI.cpp index c7063df..9f8f2ab 100644 --- a/CBash/FalloutNewVegas/Records/API/MGEFRecordAPI.cpp +++ b/CBash/FalloutNewVegas/Records/API/MGEFRecordAPI.cpp @@ -124,7 +124,7 @@ UINT32 MGEFRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) case 18: //associated return FORMID_FIELD; case 19: //schoolUnused - return SINT32_FIELD; + return UINT32_TYPE_FIELD; case 20: //resistType return SINT32_TYPE_FIELD; case 21: //numCounters @@ -231,7 +231,7 @@ void * MGEFRecord::GetField(FIELD_IDENTIFIERS, void **FieldValues) case 18: //associated return &DATA.value.associated; case 19: //schoolUnused - return &DATA.value.school; + return &DATA.value.schoolType; case 20: //resistType return &DATA.value.resistType; case 21: //numCounters @@ -367,7 +367,7 @@ bool MGEFRecord::SetField(FIELD_IDENTIFIERS, void *FieldValue, UINT32 ArraySize) DATA.value.associated = *(FORMID *)FieldValue; return true; case 19: //schoolUnused - DATA.value.school = *(SINT32 *)FieldValue; + DATA.value.schoolType = *(UINT32 *)FieldValue; break; case 20: //resistType DATA.value.resistType = *(SINT32 *)FieldValue; @@ -512,7 +512,7 @@ void MGEFRecord::DeleteField(FIELD_IDENTIFIERS) DATA.value.associated = defaultDATA.associated; return; case 19: //schoolUnused - DATA.value.school = defaultDATA.school; + DATA.value.schoolType = defaultDATA.schoolType; return; case 20: //resistType DATA.value.resistType = defaultDATA.resistType; diff --git a/CBash/FalloutNewVegas/Records/MGEFRecord.cpp b/CBash/FalloutNewVegas/Records/MGEFRecord.cpp index afd0692..1410745 100644 --- a/CBash/FalloutNewVegas/Records/MGEFRecord.cpp +++ b/CBash/FalloutNewVegas/Records/MGEFRecord.cpp @@ -28,7 +28,7 @@ MGEFRecord::MGEFDATA::MGEFDATA(): flags(0), baseCost(0.0f), associated(0), - school(0), + schoolType(0), resistType(-1), numCounters(0), light(0), @@ -595,6 +595,76 @@ void MGEFRecord::SetType(UINT32 Type) DATA.value.archType = Type; } +bool MGEFRecord::IsSchoolAlteration() + { + return (DATA.value.schoolType == eAlteration); + } + +void MGEFRecord::IsSchoolAlteration(bool value) + { + DATA.value.schoolType = value ? eAlteration : eConjuration; + } + +bool MGEFRecord::IsSchoolConjuration() + { + return (DATA.value.schoolType == eConjuration); + } + +void MGEFRecord::IsSchoolConjuration(bool value) + { + DATA.value.schoolType = value ? eConjuration : eAlteration; + } + +bool MGEFRecord::IsSchoolDestruction() + { + return (DATA.value.schoolType == eDestruction); + } + +void MGEFRecord::IsSchoolDestruction(bool value) + { + DATA.value.schoolType = value ? eDestruction : eAlteration; + } + +bool MGEFRecord::IsSchoolIllusion() + { + return (DATA.value.schoolType == eIllusion); + } + +void MGEFRecord::IsSchoolIllusion(bool value) + { + DATA.value.schoolType = value ? eIllusion : eAlteration; + } + +bool MGEFRecord::IsSchoolMysticism() + { + return (DATA.value.schoolType == eMysticism); + } + +void MGEFRecord::IsSchoolMysticism(bool value) + { + DATA.value.schoolType = value ? eMysticism : eAlteration; + } + +bool MGEFRecord::IsSchoolRestoration() + { + return (DATA.value.schoolType == eRestoration); + } + +void MGEFRecord::IsSchoolRestoration(bool value) + { + DATA.value.schoolType = value ? eRestoration : eAlteration; + } + +bool MGEFRecord::IsSchool(UINT32 Type) + { + return (DATA.value.schoolType == Type); + } + +void MGEFRecord::SetSchool(UINT32 Type) + { + DATA.value.schoolType = Type; + } + UINT32 MGEFRecord::GetType() { return REV32(MGEF); diff --git a/CBash/FalloutNewVegas/Records/MGEFRecord.h b/CBash/FalloutNewVegas/Records/MGEFRecord.h index 16c4631..e75eafc 100644 --- a/CBash/FalloutNewVegas/Records/MGEFRecord.h +++ b/CBash/FalloutNewVegas/Records/MGEFRecord.h @@ -33,7 +33,7 @@ class MGEFRecord : public FNVRecord //Base Effect UINT32 flags; FLOAT32 baseCost; //Unused FORMID associated; - SINT32 school; //Unused + UINT32 schoolType; //Unused SINT32 resistType; UINT16 numCounters; //According to OBME UINT8 unused1[2]; @@ -108,6 +108,17 @@ class MGEFRecord : public FNVRecord //Base Effect eLimbCondition = 35, eTurbo = 36 }; + + enum eSchools + { + eAlteration = 0, + eConjuration, + eDestruction, + eIllusion, + eMysticism, + eRestoration + }; + public: StringRecord EDID; //Editor ID StringRecord FULL; //Name @@ -213,6 +224,21 @@ class MGEFRecord : public FNVRecord //Base Effect bool IsType(UINT32 Type); void SetType(UINT32 Type); + bool IsSchoolAlteration(); + void IsSchoolAlteration(bool value); + bool IsSchoolConjuration(); + void IsSchoolConjuration(bool value); + bool IsSchoolDestruction(); + void IsSchoolDestruction(bool value); + bool IsSchoolIllusion(); + void IsSchoolIllusion(bool value); + bool IsSchoolMysticism(); + void IsSchoolMysticism(bool value); + bool IsSchoolRestoration(); + void IsSchoolRestoration(bool value); + bool IsSchool(UINT32 Type); + void SetSchool(UINT32 Type); + UINT32 GetFieldAttribute(DEFAULTED_FIELD_IDENTIFIERS, UINT32 WhichAttribute=0); void * GetField(DEFAULTED_FIELD_IDENTIFIERS, void **FieldValues=NULL); bool SetField(DEFAULTED_FIELD_IDENTIFIERS, void *FieldValue=NULL, UINT32 ArraySize=0); diff --git a/CBash/GenericChunks.cpp b/CBash/GenericChunks.cpp index 4c85ad1..81028c7 100644 --- a/CBash/GenericChunks.cpp +++ b/CBash/GenericChunks.cpp @@ -259,7 +259,7 @@ bool FNVSCHR::operator !=(const FNVSCHR &other) const } GENEFIT::GENEFIT(): - name(0), + name(REV32(FIDG)), //Fire Damage magnitude(0), area(0), duration(0), @@ -291,7 +291,7 @@ bool GENEFIT::operator !=(const GENEFIT &other) const GENSCIT::GENSCIT(): script(0), - school(0), + schoolType(0), //Alteration visual(0), flags(0) { @@ -306,7 +306,7 @@ GENSCIT::~GENSCIT() bool GENSCIT::operator ==(const GENSCIT &other) const { return (script == other.script && - school == other.school && + schoolType == other.schoolType && visual == other.visual && flags == other.flags); } @@ -412,6 +412,90 @@ bool OBMEEffect::operator !=(const OBMEEffect &other) const return !(*this == other); } +bool GENEffect::IsSchoolAlteration() + { + if(!SCIT.IsLoaded()) return false; + return (SCIT->schoolType == eAlteration); + } + +void GENEffect::IsSchoolAlteration(bool value) + { + if(!SCIT.IsLoaded()) return; + SCIT->schoolType = value ? eAlteration : eConjuration; + } + +bool GENEffect::IsSchoolConjuration() + { + if(!SCIT.IsLoaded()) return false; + return (SCIT->schoolType == eConjuration); + } + +void GENEffect::IsSchoolConjuration(bool value) + { + if(!SCIT.IsLoaded()) return; + SCIT->schoolType = value ? eConjuration : eAlteration; + } + +bool GENEffect::IsSchoolDestruction() + { + if(!SCIT.IsLoaded()) return false; + return (SCIT->schoolType == eDestruction); + } + +void GENEffect::IsSchoolDestruction(bool value) + { + if(!SCIT.IsLoaded()) return; + SCIT->schoolType = value ? eDestruction : eAlteration; + } + +bool GENEffect::IsSchoolIllusion() + { + if(!SCIT.IsLoaded()) return false; + return (SCIT->schoolType == eIllusion); + } + +void GENEffect::IsSchoolIllusion(bool value) + { + if(!SCIT.IsLoaded()) return; + SCIT->schoolType = value ? eIllusion : eAlteration; + } + +bool GENEffect::IsSchoolMysticism() + { + if(!SCIT.IsLoaded()) return false; + return (SCIT->schoolType == eMysticism); + } + +void GENEffect::IsSchoolMysticism(bool value) + { + if(!SCIT.IsLoaded()) return; + SCIT->schoolType = value ? eMysticism : eAlteration; + } + +bool GENEffect::IsSchoolRestoration() + { + if(!SCIT.IsLoaded()) return false; + return (SCIT->schoolType == eRestoration); + } + +void GENEffect::IsSchoolRestoration(bool value) + { + if(!SCIT.IsLoaded()) return; + SCIT->schoolType = value ? eRestoration : eAlteration; + } + +bool GENEffect::IsSchool(UINT32 Type) + { + if(!SCIT.IsLoaded()) return false; + return (SCIT->schoolType == Type); + } + +void GENEffect::SetSchool(UINT32 Type) + { + SCIT.Load(); + SCIT->schoolType = Type; + } + bool GENEffect::IsHostile() { if(!SCIT.IsLoaded()) return false; @@ -466,14 +550,14 @@ void GENEffect::IsRangeTarget(bool value) EFIT.value.rangeType = value ? eRangeTarget : eRangeSelf; } -bool GENEffect::IsRange(UINT32 Mask) +bool GENEffect::IsRange(UINT32 Type) { - return (EFIT.value.rangeType == Mask); + return (EFIT.value.rangeType == Type); } -void GENEffect::SetRange(UINT32 Mask) +void GENEffect::SetRange(UINT32 Type) { - EFIT.value.rangeType = Mask; + EFIT.value.rangeType = Type; } bool GENEffect::OBME_IsUsingHostileOverride() diff --git a/CBash/GenericChunks.h b/CBash/GenericChunks.h index 077ca17..3cba725 100644 --- a/CBash/GenericChunks.h +++ b/CBash/GenericChunks.h @@ -165,7 +165,7 @@ struct GENEFIT struct GENSCIT { FORMID_OR_MGEFCODE_OR_ACTORVALUE_OR_UINT32 script; - UINT32 school; + UINT32 schoolType; MGEFCODE_OR_UINT32 visual; UINT8 flags, unused1[3]; @@ -223,6 +223,16 @@ struct GENEffect StringRecord FULL; //Effect Name OptSubRecord OBME; //OBME Extended Data + enum eSCITSchools + { + eAlteration = 0, + eConjuration, + eDestruction, + eIllusion, + eMysticism, + eRestoration + }; + enum SCITFlags { fIsHostile = 0x01 @@ -235,6 +245,21 @@ struct GENEffect eRangeTarget = 2 }; + bool IsSchoolAlteration(); + void IsSchoolAlteration(bool value); + bool IsSchoolConjuration(); + void IsSchoolConjuration(bool value); + bool IsSchoolDestruction(); + void IsSchoolDestruction(bool value); + bool IsSchoolIllusion(); + void IsSchoolIllusion(bool value); + bool IsSchoolMysticism(); + void IsSchoolMysticism(bool value); + bool IsSchoolRestoration(); + void IsSchoolRestoration(bool value); + bool IsSchool(UINT32 Type); + void SetSchool(UINT32 Type); + enum OBMEOverrideFlags { fOBME_IsHostile = 0x00000001, @@ -300,8 +325,8 @@ struct GENEffect void IsRangeTouch(bool value); bool IsRangeTarget(); void IsRangeTarget(bool value); - bool IsRange(UINT32 Mask); - void SetRange(UINT32 Mask); + bool IsRange(UINT32 Type); + void SetRange(UINT32 Type); bool OBME_IsUsingHostileOverride(); void OBME_IsUsingHostileOverride(bool value); diff --git a/CBash/GenericRecord.cpp b/CBash/GenericRecord.cpp index 61228fb..6d8fd71 100644 --- a/CBash/GenericRecord.cpp +++ b/CBash/GenericRecord.cpp @@ -124,9 +124,9 @@ bool Record::IsParentMod() const Record * Record::GetParentRecord() const { - if(!IsParentMod()) - return (Record *)GetParent(); - return NULL; + if(IsParentMod()) + return NULL; + return (Record *)GetParent(); } ModFile * Record::GetParentMod() const diff --git a/CBash/Oblivion/Records/API/ALCHRecordAPI.cpp b/CBash/Oblivion/Records/API/ALCHRecordAPI.cpp index ccf7555..120a3f3 100644 --- a/CBash/Oblivion/Records/API/ALCHRecordAPI.cpp +++ b/CBash/Oblivion/Records/API/ALCHRecordAPI.cpp @@ -100,16 +100,12 @@ UINT32 ALCHRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) switch(WhichAttribute) { case 0: //fieldType - return MGEFCODE_OR_UINT32_FIELD; + return MGEFCODE_OR_CHAR4_FIELD; case 2: //WhichType if(Effects.value[ListIndex]->OBME.IsLoaded()) - { - if(Effects.value[ListIndex]->EFID.value >= 0x80000000) - return RESOLVED_MGEFCODE_FIELD; - return STATIC_MGEFCODE_FIELD; - } + return Effects.value[ListIndex]->EFID.value >= 0x80000000 ? RESOLVED_MGEFCODE_FIELD : STATIC_MGEFCODE_FIELD; else - return UINT32_FIELD; + return CHAR4_FIELD; default: return UNKNOWN_FIELD; } @@ -136,22 +132,18 @@ UINT32 ALCHRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) case 2: //It's a mgefCode, and not a formID at all. //Conditional resolution of mgefCode's based on JRoush's OBME mod //It's resolved just like a formID, except it uses the lower byte instead of the upper - if(Effects.value[ListIndex]->EFIT.value.actorValue >= 0x80000000) - return RESOLVED_MGEFCODE_FIELD; - return STATIC_MGEFCODE_FIELD; + return Effects.value[ListIndex]->EFIT.value.actorValue >= 0x80000000 ? RESOLVED_MGEFCODE_FIELD : STATIC_MGEFCODE_FIELD; case 3: //It's an actor value, and not a formID at all. //Conditional resolution of av's based on JRoush's OBME/AV mod(s) //It's resolved just like a formID - if(Effects.value[ListIndex]->EFIT.value.actorValue >= 0x800) - return RESOLVED_ACTORVALUE_FIELD; - return STATIC_ACTORVALUE_FIELD; + return Effects.value[ListIndex]->EFIT.value.actorValue >= 0x800 ? RESOLVED_ACTORVALUE_FIELD : STATIC_ACTORVALUE_FIELD; default: //It's not a formID, mgefCode, or fancied up actor value //so do nothing return UINT32_FIELD; } } else - return UINT32_FIELD; + return STATIC_ACTORVALUE_FIELD; default: return UNKNOWN_FIELD; } @@ -170,15 +162,11 @@ UINT32 ALCHRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) case 2: //It's a mgefCode, and not a formID at all. //Conditional resolution of mgefCode's based on JRoush's OBME mod //It's resolved just like a formID, except it uses the lower byte instead of the upper - if(Effects.value[ListIndex]->SCIT->script >= 0x80000000) - return RESOLVED_MGEFCODE_FIELD; - return STATIC_MGEFCODE_FIELD; + return Effects.value[ListIndex]->SCIT->script >= 0x80000000 ? RESOLVED_MGEFCODE_FIELD : STATIC_MGEFCODE_FIELD; case 3: //It's an actor value, and not a formID at all. //Conditional resolution of av's based on JRoush's OBME/AV mod(s) //It's resolved just like a formID - if(Effects.value[ListIndex]->SCIT->script >= 0x800) - return RESOLVED_ACTORVALUE_FIELD; - return STATIC_ACTORVALUE_FIELD; + return Effects.value[ListIndex]->SCIT->script >= 0x800 ? RESOLVED_ACTORVALUE_FIELD : STATIC_ACTORVALUE_FIELD; default: //It's not a formID, mgefCode, or fancied up actor value //so do nothing return UINT32_FIELD; @@ -190,21 +178,17 @@ UINT32 ALCHRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) return UNKNOWN_FIELD; } case 9: //school - return UINT32_FIELD; + return UINT32_TYPE_FIELD; case 10: //visual switch(WhichAttribute) { case 0: //fieldType - return MGEFCODE_OR_UINT32_FIELD; + return MGEFCODE_OR_CHAR4_FIELD; case 2: //WhichType if(Effects.value[ListIndex]->OBME.IsLoaded() && Effects.value[ListIndex]->SCIT.IsLoaded()) - { - if(Effects.value[ListIndex]->SCIT->visual >= 0x80000000) - return RESOLVED_MGEFCODE_FIELD; - return STATIC_MGEFCODE_FIELD; - } + return ((Effects.value[ListIndex]->SCIT->visual >= 0x80000000) ? RESOLVED_MGEFCODE_FIELD : STATIC_MGEFCODE_FIELD); else - return UINT32_FIELD; + return CHAR4_FIELD; default: return UNKNOWN_FIELD; } @@ -216,9 +200,7 @@ UINT32 ALCHRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) case 0: //fieldType return UINT8_ARRAY_FIELD; case 1: //fieldSize - if(Effects.value[ListIndex]->SCIT.IsLoaded()) - return 3; - return 0; + return Effects.value[ListIndex]->SCIT.IsLoaded() ? 3 : 0; default: return UNKNOWN_FIELD; } @@ -243,9 +225,7 @@ UINT32 ALCHRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) case 0: //fieldType return UINT8_ARRAY_FIELD; case 1: //fieldSize - if(Effects.value[ListIndex]->OBME.IsLoaded()) - return 0xA; - return 0; + return Effects.value[ListIndex]->OBME.IsLoaded() ? 0xA : 0; default: return UNKNOWN_FIELD; } @@ -264,11 +244,7 @@ UINT32 ALCHRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) return ACTORVALUE_FIELD; case 2: //WhichType if(Effects.value[ListIndex]->OBME.IsLoaded() && Effects.value[ListIndex]->OBME->EFIX.IsLoaded()) - { - if(Effects.value[ListIndex]->OBME->EFIX->resistAV >= 0x800) - return RESOLVED_ACTORVALUE_FIELD; - return STATIC_ACTORVALUE_FIELD; - } + return Effects.value[ListIndex]->OBME->EFIX->resistAV >= 0x800 ? RESOLVED_ACTORVALUE_FIELD : STATIC_ACTORVALUE_FIELD; else return UNKNOWN_FIELD; default: @@ -280,9 +256,7 @@ UINT32 ALCHRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) case 0: //fieldType return UINT8_ARRAY_FIELD; case 1: //fieldSize - if(Effects.value[ListIndex]->OBME.IsLoaded() && Effects.value[ListIndex]->OBME->EFIX.IsLoaded()) - return 0x10; - return 0; + return Effects.value[ListIndex]->OBME.IsLoaded() && Effects.value[ListIndex]->OBME->EFIX.IsLoaded() ? 0x10 : 0; default: return UNKNOWN_FIELD; } @@ -381,7 +355,7 @@ void * ALCHRecord::GetField(FIELD_IDENTIFIERS, void **FieldValues) case 8: //script return Effects.value[ListIndex]->SCIT.IsLoaded() ? &Effects.value[ListIndex]->SCIT->script : NULL; case 9: //school - return Effects.value[ListIndex]->SCIT.IsLoaded() ? &Effects.value[ListIndex]->SCIT->school : NULL; + return Effects.value[ListIndex]->SCIT.IsLoaded() ? &Effects.value[ListIndex]->SCIT->schoolType : NULL; case 10: //visual return Effects.value[ListIndex]->SCIT.IsLoaded() ? &Effects.value[ListIndex]->SCIT->visual : NULL; case 11: //flags @@ -533,7 +507,7 @@ bool ALCHRecord::SetField(FIELD_IDENTIFIERS, void *FieldValue, UINT32 ArraySize) return true; case 9: //school Effects.value[ListIndex]->SCIT.Load(); - Effects.value[ListIndex]->SCIT->school = *(UINT32 *)FieldValue; + Effects.value[ListIndex]->SCIT->schoolType = *(UINT32 *)FieldValue; break; case 10: //visual Effects.value[ListIndex]->SCIT.Load(); @@ -744,7 +718,7 @@ void ALCHRecord::DeleteField(FIELD_IDENTIFIERS) return; case 9: //school if(Effects.value[ListIndex]->SCIT.IsLoaded()) - Effects.value[ListIndex]->SCIT->school = defaultSCIT.school; + Effects.value[ListIndex]->SCIT->schoolType = defaultSCIT.schoolType; return; case 10: //visual if(Effects.value[ListIndex]->SCIT.IsLoaded()) diff --git a/CBash/Oblivion/Records/API/ENCHRecordAPI.cpp b/CBash/Oblivion/Records/API/ENCHRecordAPI.cpp index 756b87c..9da5abd 100644 --- a/CBash/Oblivion/Records/API/ENCHRecordAPI.cpp +++ b/CBash/Oblivion/Records/API/ENCHRecordAPI.cpp @@ -83,16 +83,12 @@ UINT32 ENCHRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) switch(WhichAttribute) { case 0: //fieldType - return MGEFCODE_OR_UINT32_FIELD; + return MGEFCODE_OR_CHAR4_FIELD; case 2: //WhichType if(Effects.value[ListIndex]->OBME.IsLoaded()) - { - if(Effects.value[ListIndex]->EFID.value >= 0x80000000) - return RESOLVED_MGEFCODE_FIELD; - return STATIC_MGEFCODE_FIELD; - } + return Effects.value[ListIndex]->EFID.value >= 0x80000000 ? RESOLVED_MGEFCODE_FIELD : STATIC_MGEFCODE_FIELD; else - return UINT32_FIELD; + return CHAR4_FIELD; default: return UNKNOWN_FIELD; } @@ -119,22 +115,18 @@ UINT32 ENCHRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) case 2: //It's a mgefCode, and not a formID at all. //Conditional resolution of mgefCode's based on JRoush's OBME mod //It's resolved just like a formID, except it uses the lower byte instead of the upper - if(Effects.value[ListIndex]->EFIT.value.actorValue >= 0x80000000) - return RESOLVED_MGEFCODE_FIELD; - return STATIC_MGEFCODE_FIELD; + return Effects.value[ListIndex]->EFIT.value.actorValue >= 0x80000000 ? RESOLVED_MGEFCODE_FIELD : STATIC_MGEFCODE_FIELD; case 3: //It's an actor value, and not a formID at all. //Conditional resolution of av's based on JRoush's OBME/AV mod(s) //It's resolved just like a formID - if(Effects.value[ListIndex]->EFIT.value.actorValue >= 0x800) - return RESOLVED_ACTORVALUE_FIELD; - return STATIC_ACTORVALUE_FIELD; + return Effects.value[ListIndex]->EFIT.value.actorValue >= 0x800 ? RESOLVED_ACTORVALUE_FIELD : STATIC_ACTORVALUE_FIELD; default: //It's not a formID, mgefCode, or fancied up actor value //so do nothing return UINT32_FIELD; } } else - return UINT32_FIELD; + return STATIC_ACTORVALUE_FIELD; default: return UNKNOWN_FIELD; } @@ -153,15 +145,11 @@ UINT32 ENCHRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) case 2: //It's a mgefCode, and not a formID at all. //Conditional resolution of mgefCode's based on JRoush's OBME mod //It's resolved just like a formID, except it uses the lower byte instead of the upper - if(Effects.value[ListIndex]->SCIT->script >= 0x80000000) - return RESOLVED_MGEFCODE_FIELD; - return STATIC_MGEFCODE_FIELD; + return Effects.value[ListIndex]->SCIT->script >= 0x80000000 ? RESOLVED_MGEFCODE_FIELD : STATIC_MGEFCODE_FIELD; case 3: //It's an actor value, and not a formID at all. //Conditional resolution of av's based on JRoush's OBME/AV mod(s) //It's resolved just like a formID - if(Effects.value[ListIndex]->SCIT->script >= 0x800) - return RESOLVED_ACTORVALUE_FIELD; - return STATIC_ACTORVALUE_FIELD; + return Effects.value[ListIndex]->SCIT->script >= 0x800 ? RESOLVED_ACTORVALUE_FIELD : STATIC_ACTORVALUE_FIELD; default: //It's not a formID, mgefCode, or fancied up actor value //so do nothing return UINT32_FIELD; @@ -173,21 +161,17 @@ UINT32 ENCHRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) return UNKNOWN_FIELD; } case 9: //school - return UINT32_FIELD; + return UINT32_TYPE_FIELD; case 10: //visual switch(WhichAttribute) { case 0: //fieldType - return MGEFCODE_OR_UINT32_FIELD; + return MGEFCODE_OR_CHAR4_FIELD; case 2: //WhichType if(Effects.value[ListIndex]->OBME.IsLoaded() && Effects.value[ListIndex]->SCIT.IsLoaded()) - { - if(Effects.value[ListIndex]->SCIT->visual >= 0x80000000) - return RESOLVED_MGEFCODE_FIELD; - return STATIC_MGEFCODE_FIELD; - } + return ((Effects.value[ListIndex]->SCIT->visual >= 0x80000000) ? RESOLVED_MGEFCODE_FIELD : STATIC_MGEFCODE_FIELD); else - return UINT32_FIELD; + return CHAR4_FIELD; default: return UNKNOWN_FIELD; } @@ -199,9 +183,7 @@ UINT32 ENCHRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) case 0: //fieldType return UINT8_ARRAY_FIELD; case 1: //fieldSize - if(Effects.value[ListIndex]->SCIT.IsLoaded()) - return 3; - return 0; + return Effects.value[ListIndex]->SCIT.IsLoaded() ? 3 : 0; default: return UNKNOWN_FIELD; } @@ -226,9 +208,7 @@ UINT32 ENCHRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) case 0: //fieldType return UINT8_ARRAY_FIELD; case 1: //fieldSize - if(Effects.value[ListIndex]->OBME.IsLoaded()) - return 0xA; - return 0; + return Effects.value[ListIndex]->OBME.IsLoaded() ? 0xA : 0; default: return UNKNOWN_FIELD; } @@ -247,11 +227,7 @@ UINT32 ENCHRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) return ACTORVALUE_FIELD; case 2: //WhichType if(Effects.value[ListIndex]->OBME.IsLoaded() && Effects.value[ListIndex]->OBME->EFIX.IsLoaded()) - { - if(Effects.value[ListIndex]->OBME->EFIX->resistAV >= 0x800) - return RESOLVED_ACTORVALUE_FIELD; - return STATIC_ACTORVALUE_FIELD; - } + return Effects.value[ListIndex]->OBME->EFIX->resistAV >= 0x800 ? RESOLVED_ACTORVALUE_FIELD : STATIC_ACTORVALUE_FIELD; else return UNKNOWN_FIELD; default: @@ -263,9 +239,7 @@ UINT32 ENCHRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) case 0: //fieldType return UINT8_ARRAY_FIELD; case 1: //fieldSize - if(Effects.value[ListIndex]->OBME.IsLoaded() && Effects.value[ListIndex]->OBME->EFIX.IsLoaded()) - return 0x10; - return 0; + return Effects.value[ListIndex]->OBME.IsLoaded() && Effects.value[ListIndex]->OBME->EFIX.IsLoaded() ? 0x10 : 0; default: return UNKNOWN_FIELD; } @@ -355,7 +329,7 @@ void * ENCHRecord::GetField(FIELD_IDENTIFIERS, void **FieldValues) case 8: //script return Effects.value[ListIndex]->SCIT.IsLoaded() ? &Effects.value[ListIndex]->SCIT->script : NULL; case 9: //school - return Effects.value[ListIndex]->SCIT.IsLoaded() ? &Effects.value[ListIndex]->SCIT->school : NULL; + return Effects.value[ListIndex]->SCIT.IsLoaded() ? &Effects.value[ListIndex]->SCIT->schoolType : NULL; case 10: //visual return Effects.value[ListIndex]->SCIT.IsLoaded() ? &Effects.value[ListIndex]->SCIT->visual : NULL; case 11: //flags @@ -492,7 +466,7 @@ bool ENCHRecord::SetField(FIELD_IDENTIFIERS, void *FieldValue, UINT32 ArraySize) return true; case 9: //school Effects.value[ListIndex]->SCIT.Load(); - Effects.value[ListIndex]->SCIT->school = *(UINT32 *)FieldValue; + Effects.value[ListIndex]->SCIT->schoolType = *(UINT32 *)FieldValue; break; case 10: //visual Effects.value[ListIndex]->SCIT.Load(); @@ -688,7 +662,7 @@ void ENCHRecord::DeleteField(FIELD_IDENTIFIERS) return; case 9: //school if(Effects.value[ListIndex]->SCIT.IsLoaded()) - Effects.value[ListIndex]->SCIT->school = defaultSCIT.school; + Effects.value[ListIndex]->SCIT->schoolType = defaultSCIT.schoolType; return; case 10: //visual if(Effects.value[ListIndex]->SCIT.IsLoaded()) diff --git a/CBash/Oblivion/Records/API/INGRRecordAPI.cpp b/CBash/Oblivion/Records/API/INGRRecordAPI.cpp index 22d69f9..e1aac50 100644 --- a/CBash/Oblivion/Records/API/INGRRecordAPI.cpp +++ b/CBash/Oblivion/Records/API/INGRRecordAPI.cpp @@ -100,16 +100,12 @@ UINT32 INGRRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) switch(WhichAttribute) { case 0: //fieldType - return MGEFCODE_OR_UINT32_FIELD; + return MGEFCODE_OR_CHAR4_FIELD; case 2: //WhichType if(Effects.value[ListIndex]->OBME.IsLoaded()) - { - if(Effects.value[ListIndex]->EFID.value >= 0x80000000) - return RESOLVED_MGEFCODE_FIELD; - return STATIC_MGEFCODE_FIELD; - } + return Effects.value[ListIndex]->EFID.value >= 0x80000000 ? RESOLVED_MGEFCODE_FIELD : STATIC_MGEFCODE_FIELD; else - return UINT32_FIELD; + return CHAR4_FIELD; default: return UNKNOWN_FIELD; } @@ -136,22 +132,18 @@ UINT32 INGRRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) case 2: //It's a mgefCode, and not a formID at all. //Conditional resolution of mgefCode's based on JRoush's OBME mod //It's resolved just like a formID, except it uses the lower byte instead of the upper - if(Effects.value[ListIndex]->EFIT.value.actorValue >= 0x80000000) - return RESOLVED_MGEFCODE_FIELD; - return STATIC_MGEFCODE_FIELD; + return Effects.value[ListIndex]->EFIT.value.actorValue >= 0x80000000 ? RESOLVED_MGEFCODE_FIELD : STATIC_MGEFCODE_FIELD; case 3: //It's an actor value, and not a formID at all. //Conditional resolution of av's based on JRoush's OBME/AV mod(s) //It's resolved just like a formID - if(Effects.value[ListIndex]->EFIT.value.actorValue >= 0x800) - return RESOLVED_ACTORVALUE_FIELD; - return STATIC_ACTORVALUE_FIELD; + return Effects.value[ListIndex]->EFIT.value.actorValue >= 0x800 ? RESOLVED_ACTORVALUE_FIELD : STATIC_ACTORVALUE_FIELD; default: //It's not a formID, mgefCode, or fancied up actor value //so do nothing return UINT32_FIELD; } } else - return UINT32_FIELD; + return STATIC_ACTORVALUE_FIELD; default: return UNKNOWN_FIELD; } @@ -170,15 +162,11 @@ UINT32 INGRRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) case 2: //It's a mgefCode, and not a formID at all. //Conditional resolution of mgefCode's based on JRoush's OBME mod //It's resolved just like a formID, except it uses the lower byte instead of the upper - if(Effects.value[ListIndex]->SCIT->script >= 0x80000000) - return RESOLVED_MGEFCODE_FIELD; - return STATIC_MGEFCODE_FIELD; + return Effects.value[ListIndex]->SCIT->script >= 0x80000000 ? RESOLVED_MGEFCODE_FIELD : STATIC_MGEFCODE_FIELD; case 3: //It's an actor value, and not a formID at all. //Conditional resolution of av's based on JRoush's OBME/AV mod(s) //It's resolved just like a formID - if(Effects.value[ListIndex]->SCIT->script >= 0x800) - return RESOLVED_ACTORVALUE_FIELD; - return STATIC_ACTORVALUE_FIELD; + return Effects.value[ListIndex]->SCIT->script >= 0x800 ? RESOLVED_ACTORVALUE_FIELD : STATIC_ACTORVALUE_FIELD; default: //It's not a formID, mgefCode, or fancied up actor value //so do nothing return UINT32_FIELD; @@ -190,21 +178,17 @@ UINT32 INGRRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) return UNKNOWN_FIELD; } case 9: //school - return UINT32_FIELD; + return UINT32_TYPE_FIELD; case 10: //visual switch(WhichAttribute) { case 0: //fieldType - return MGEFCODE_OR_UINT32_FIELD; + return MGEFCODE_OR_CHAR4_FIELD; case 2: //WhichType if(Effects.value[ListIndex]->OBME.IsLoaded() && Effects.value[ListIndex]->SCIT.IsLoaded()) - { - if(Effects.value[ListIndex]->SCIT->visual >= 0x80000000) - return RESOLVED_MGEFCODE_FIELD; - return STATIC_MGEFCODE_FIELD; - } + return ((Effects.value[ListIndex]->SCIT->visual >= 0x80000000) ? RESOLVED_MGEFCODE_FIELD : STATIC_MGEFCODE_FIELD); else - return UINT32_FIELD; + return CHAR4_FIELD; default: return UNKNOWN_FIELD; } @@ -216,9 +200,7 @@ UINT32 INGRRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) case 0: //fieldType return UINT8_ARRAY_FIELD; case 1: //fieldSize - if(Effects.value[ListIndex]->SCIT.IsLoaded()) - return 3; - return 0; + return Effects.value[ListIndex]->SCIT.IsLoaded() ? 3 : 0; default: return UNKNOWN_FIELD; } @@ -243,9 +225,7 @@ UINT32 INGRRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) case 0: //fieldType return UINT8_ARRAY_FIELD; case 1: //fieldSize - if(Effects.value[ListIndex]->OBME.IsLoaded()) - return 0xA; - return 0; + return Effects.value[ListIndex]->OBME.IsLoaded() ? 0xA : 0; default: return UNKNOWN_FIELD; } @@ -264,11 +244,7 @@ UINT32 INGRRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) return ACTORVALUE_FIELD; case 2: //WhichType if(Effects.value[ListIndex]->OBME.IsLoaded() && Effects.value[ListIndex]->OBME->EFIX.IsLoaded()) - { - if(Effects.value[ListIndex]->OBME->EFIX->resistAV >= 0x800) - return RESOLVED_ACTORVALUE_FIELD; - return STATIC_ACTORVALUE_FIELD; - } + return Effects.value[ListIndex]->OBME->EFIX->resistAV >= 0x800 ? RESOLVED_ACTORVALUE_FIELD : STATIC_ACTORVALUE_FIELD; else return UNKNOWN_FIELD; default: @@ -280,9 +256,7 @@ UINT32 INGRRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) case 0: //fieldType return UINT8_ARRAY_FIELD; case 1: //fieldSize - if(Effects.value[ListIndex]->OBME.IsLoaded() && Effects.value[ListIndex]->OBME->EFIX.IsLoaded()) - return 0x10; - return 0; + return Effects.value[ListIndex]->OBME.IsLoaded() && Effects.value[ListIndex]->OBME->EFIX.IsLoaded() ? 0x10 : 0; default: return UNKNOWN_FIELD; } @@ -381,7 +355,7 @@ void * INGRRecord::GetField(FIELD_IDENTIFIERS, void **FieldValues) case 8: //script return Effects.value[ListIndex]->SCIT.IsLoaded() ? &Effects.value[ListIndex]->SCIT->script : NULL; case 9: //school - return Effects.value[ListIndex]->SCIT.IsLoaded() ? &Effects.value[ListIndex]->SCIT->school : NULL; + return Effects.value[ListIndex]->SCIT.IsLoaded() ? &Effects.value[ListIndex]->SCIT->schoolType : NULL; case 10: //visual return Effects.value[ListIndex]->SCIT.IsLoaded() ? &Effects.value[ListIndex]->SCIT->visual : NULL; case 11: //flags @@ -533,7 +507,7 @@ bool INGRRecord::SetField(FIELD_IDENTIFIERS, void *FieldValue, UINT32 ArraySize) return true; case 9: //school Effects.value[ListIndex]->SCIT.Load(); - Effects.value[ListIndex]->SCIT->school = *(UINT32 *)FieldValue; + Effects.value[ListIndex]->SCIT->schoolType = *(UINT32 *)FieldValue; break; case 10: //visual Effects.value[ListIndex]->SCIT.Load(); @@ -744,7 +718,7 @@ void INGRRecord::DeleteField(FIELD_IDENTIFIERS) return; case 9: //school if(Effects.value[ListIndex]->SCIT.IsLoaded()) - Effects.value[ListIndex]->SCIT->school = defaultSCIT.school; + Effects.value[ListIndex]->SCIT->schoolType = defaultSCIT.schoolType; return; case 10: //visual if(Effects.value[ListIndex]->SCIT.IsLoaded()) diff --git a/CBash/Oblivion/Records/API/MGEFRecordAPI.cpp b/CBash/Oblivion/Records/API/MGEFRecordAPI.cpp index c2038e0..55cf552 100644 --- a/CBash/Oblivion/Records/API/MGEFRecordAPI.cpp +++ b/CBash/Oblivion/Records/API/MGEFRecordAPI.cpp @@ -66,7 +66,7 @@ UINT32 MGEFRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) case 13: //associated return FORMID_FIELD; case 14: //school - return SINT32_FIELD; + return UINT32_TYPE_FIELD; case 15: //resistValue return UINT32_FIELD; case 16: //numCounters @@ -127,7 +127,7 @@ UINT32 MGEFRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) switch(WhichAttribute) { case 0: //fieldType - return MGEFCODE_OR_UINT32_FIELD; + return MGEFCODE_OR_CHAR4_FIELD; case 2: //WhichType return ((ESCE.value[ListIndex] >= 0x80000000) ? RESOLVED_MGEFCODE_FIELD : STATIC_MGEFCODE_FIELD); default: @@ -135,7 +135,7 @@ UINT32 MGEFRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) } } else - return UINT32_FIELD; + return CHAR4_FIELD; default: return UNKNOWN_FIELD; } @@ -246,7 +246,7 @@ void * MGEFRecord::GetField(FIELD_IDENTIFIERS, void **FieldValues) case 13: //associated return &DATA.value.associated; case 14: //school - return &DATA.value.school; + return &DATA.value.schoolType; case 15: //resistValue return &DATA.value.resistValue; case 16: //numCounters @@ -360,7 +360,7 @@ bool MGEFRecord::SetField(FIELD_IDENTIFIERS, void *FieldValue, UINT32 ArraySize) DATA.value.associated = *(FORMID_OR_MGEFCODE_OR_ACTORVALUE_OR_UINT32 *)FieldValue; return true; case 14: //school - DATA.value.school = *(SINT32 *)FieldValue; + DATA.value.schoolType = *(UINT32 *)FieldValue; break; case 15: //resistValue DATA.value.resistValue = *(FORMID *)FieldValue; @@ -524,7 +524,7 @@ void MGEFRecord::DeleteField(FIELD_IDENTIFIERS) DATA.value.associated = defaultDATA.associated; return; case 14: //school - DATA.value.school = defaultDATA.school; + DATA.value.schoolType = defaultDATA.schoolType; return; case 15: //resistValue DATA.value.resistValue = defaultDATA.resistValue; diff --git a/CBash/Oblivion/Records/API/SGSTRecordAPI.cpp b/CBash/Oblivion/Records/API/SGSTRecordAPI.cpp index 75b4b38..07bc0ff 100644 --- a/CBash/Oblivion/Records/API/SGSTRecordAPI.cpp +++ b/CBash/Oblivion/Records/API/SGSTRecordAPI.cpp @@ -83,16 +83,12 @@ UINT32 SGSTRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) switch(WhichAttribute) { case 0: //fieldType - return MGEFCODE_OR_UINT32_FIELD; + return MGEFCODE_OR_CHAR4_FIELD; case 2: //WhichType if(Effects.value[ListIndex]->OBME.IsLoaded()) - { - if(Effects.value[ListIndex]->EFID.value >= 0x80000000) - return RESOLVED_MGEFCODE_FIELD; - return STATIC_MGEFCODE_FIELD; - } + return Effects.value[ListIndex]->EFID.value >= 0x80000000 ? RESOLVED_MGEFCODE_FIELD : STATIC_MGEFCODE_FIELD; else - return UINT32_FIELD; + return CHAR4_FIELD; default: return UNKNOWN_FIELD; } @@ -119,22 +115,18 @@ UINT32 SGSTRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) case 2: //It's a mgefCode, and not a formID at all. //Conditional resolution of mgefCode's based on JRoush's OBME mod //It's resolved just like a formID, except it uses the lower byte instead of the upper - if(Effects.value[ListIndex]->EFIT.value.actorValue >= 0x80000000) - return RESOLVED_MGEFCODE_FIELD; - return STATIC_MGEFCODE_FIELD; + return Effects.value[ListIndex]->EFIT.value.actorValue >= 0x80000000 ? RESOLVED_MGEFCODE_FIELD : STATIC_MGEFCODE_FIELD; case 3: //It's an actor value, and not a formID at all. //Conditional resolution of av's based on JRoush's OBME/AV mod(s) //It's resolved just like a formID - if(Effects.value[ListIndex]->EFIT.value.actorValue >= 0x800) - return RESOLVED_ACTORVALUE_FIELD; - return STATIC_ACTORVALUE_FIELD; + return Effects.value[ListIndex]->EFIT.value.actorValue >= 0x800 ? RESOLVED_ACTORVALUE_FIELD : STATIC_ACTORVALUE_FIELD; default: //It's not a formID, mgefCode, or fancied up actor value //so do nothing return UINT32_FIELD; } } else - return UINT32_FIELD; + return STATIC_ACTORVALUE_FIELD; default: return UNKNOWN_FIELD; } @@ -153,15 +145,11 @@ UINT32 SGSTRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) case 2: //It's a mgefCode, and not a formID at all. //Conditional resolution of mgefCode's based on JRoush's OBME mod //It's resolved just like a formID, except it uses the lower byte instead of the upper - if(Effects.value[ListIndex]->SCIT->script >= 0x80000000) - return RESOLVED_MGEFCODE_FIELD; - return STATIC_MGEFCODE_FIELD; + return Effects.value[ListIndex]->SCIT->script >= 0x80000000 ? RESOLVED_MGEFCODE_FIELD : STATIC_MGEFCODE_FIELD; case 3: //It's an actor value, and not a formID at all. //Conditional resolution of av's based on JRoush's OBME/AV mod(s) //It's resolved just like a formID - if(Effects.value[ListIndex]->SCIT->script >= 0x800) - return RESOLVED_ACTORVALUE_FIELD; - return STATIC_ACTORVALUE_FIELD; + return Effects.value[ListIndex]->SCIT->script >= 0x800 ? RESOLVED_ACTORVALUE_FIELD : STATIC_ACTORVALUE_FIELD; default: //It's not a formID, mgefCode, or fancied up actor value //so do nothing return UINT32_FIELD; @@ -173,21 +161,17 @@ UINT32 SGSTRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) return UNKNOWN_FIELD; } case 9: //school - return UINT32_FIELD; + return UINT32_TYPE_FIELD; case 10: //visual switch(WhichAttribute) { case 0: //fieldType - return MGEFCODE_OR_UINT32_FIELD; + return MGEFCODE_OR_CHAR4_FIELD; case 2: //WhichType if(Effects.value[ListIndex]->OBME.IsLoaded() && Effects.value[ListIndex]->SCIT.IsLoaded()) - { - if(Effects.value[ListIndex]->SCIT->visual >= 0x80000000) - return RESOLVED_MGEFCODE_FIELD; - return STATIC_MGEFCODE_FIELD; - } + return ((Effects.value[ListIndex]->SCIT->visual >= 0x80000000) ? RESOLVED_MGEFCODE_FIELD : STATIC_MGEFCODE_FIELD); else - return UINT32_FIELD; + return CHAR4_FIELD; default: return UNKNOWN_FIELD; } @@ -199,9 +183,7 @@ UINT32 SGSTRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) case 0: //fieldType return UINT8_ARRAY_FIELD; case 1: //fieldSize - if(Effects.value[ListIndex]->SCIT.IsLoaded()) - return 3; - return 0; + return Effects.value[ListIndex]->SCIT.IsLoaded() ? 3 : 0; default: return UNKNOWN_FIELD; } @@ -226,9 +208,7 @@ UINT32 SGSTRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) case 0: //fieldType return UINT8_ARRAY_FIELD; case 1: //fieldSize - if(Effects.value[ListIndex]->OBME.IsLoaded()) - return 0xA; - return 0; + return Effects.value[ListIndex]->OBME.IsLoaded() ? 0xA : 0; default: return UNKNOWN_FIELD; } @@ -247,11 +227,7 @@ UINT32 SGSTRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) return ACTORVALUE_FIELD; case 2: //WhichType if(Effects.value[ListIndex]->OBME.IsLoaded() && Effects.value[ListIndex]->OBME->EFIX.IsLoaded()) - { - if(Effects.value[ListIndex]->OBME->EFIX->resistAV >= 0x800) - return RESOLVED_ACTORVALUE_FIELD; - return STATIC_ACTORVALUE_FIELD; - } + return Effects.value[ListIndex]->OBME->EFIX->resistAV >= 0x800 ? RESOLVED_ACTORVALUE_FIELD : STATIC_ACTORVALUE_FIELD; else return UNKNOWN_FIELD; default: @@ -263,9 +239,7 @@ UINT32 SGSTRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) case 0: //fieldType return UINT8_ARRAY_FIELD; case 1: //fieldSize - if(Effects.value[ListIndex]->OBME.IsLoaded() && Effects.value[ListIndex]->OBME->EFIX.IsLoaded()) - return 0x10; - return 0; + return Effects.value[ListIndex]->OBME.IsLoaded() && Effects.value[ListIndex]->OBME->EFIX.IsLoaded() ? 0x10 : 0; default: return UNKNOWN_FIELD; } @@ -362,7 +336,7 @@ void * SGSTRecord::GetField(FIELD_IDENTIFIERS, void **FieldValues) case 8: //script return Effects.value[ListIndex]->SCIT.IsLoaded() ? &Effects.value[ListIndex]->SCIT->script : NULL; case 9: //school - return Effects.value[ListIndex]->SCIT.IsLoaded() ? &Effects.value[ListIndex]->SCIT->school : NULL; + return Effects.value[ListIndex]->SCIT.IsLoaded() ? &Effects.value[ListIndex]->SCIT->schoolType : NULL; case 10: //visual return Effects.value[ListIndex]->SCIT.IsLoaded() ? &Effects.value[ListIndex]->SCIT->visual : NULL; case 11: //flags @@ -504,7 +478,7 @@ bool SGSTRecord::SetField(FIELD_IDENTIFIERS, void *FieldValue, UINT32 ArraySize) return true; case 9: //school Effects.value[ListIndex]->SCIT.Load(); - Effects.value[ListIndex]->SCIT->school = *(UINT32 *)FieldValue; + Effects.value[ListIndex]->SCIT->schoolType = *(UINT32 *)FieldValue; break; case 10: //visual Effects.value[ListIndex]->SCIT.Load(); @@ -710,7 +684,7 @@ void SGSTRecord::DeleteField(FIELD_IDENTIFIERS) return; case 9: //school if(Effects.value[ListIndex]->SCIT.IsLoaded()) - Effects.value[ListIndex]->SCIT->school = defaultSCIT.school; + Effects.value[ListIndex]->SCIT->schoolType = defaultSCIT.schoolType; return; case 10: //visual if(Effects.value[ListIndex]->SCIT.IsLoaded()) diff --git a/CBash/Oblivion/Records/API/SPELRecordAPI.cpp b/CBash/Oblivion/Records/API/SPELRecordAPI.cpp index 42ce3ed..66dd00f 100644 --- a/CBash/Oblivion/Records/API/SPELRecordAPI.cpp +++ b/CBash/Oblivion/Records/API/SPELRecordAPI.cpp @@ -83,16 +83,12 @@ UINT32 SPELRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) switch(WhichAttribute) { case 0: //fieldType - return MGEFCODE_OR_UINT32_FIELD; + return MGEFCODE_OR_CHAR4_FIELD; case 2: //WhichType if(Effects.value[ListIndex]->OBME.IsLoaded()) - { - if(Effects.value[ListIndex]->EFID.value >= 0x80000000) - return RESOLVED_MGEFCODE_FIELD; - return STATIC_MGEFCODE_FIELD; - } + return Effects.value[ListIndex]->EFID.value >= 0x80000000 ? RESOLVED_MGEFCODE_FIELD : STATIC_MGEFCODE_FIELD; else - return UINT32_FIELD; + return CHAR4_FIELD; default: return UNKNOWN_FIELD; } @@ -119,22 +115,18 @@ UINT32 SPELRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) case 2: //It's a mgefCode, and not a formID at all. //Conditional resolution of mgefCode's based on JRoush's OBME mod //It's resolved just like a formID, except it uses the lower byte instead of the upper - if(Effects.value[ListIndex]->EFIT.value.actorValue >= 0x80000000) - return RESOLVED_MGEFCODE_FIELD; - return STATIC_MGEFCODE_FIELD; + return Effects.value[ListIndex]->EFIT.value.actorValue >= 0x80000000 ? RESOLVED_MGEFCODE_FIELD : STATIC_MGEFCODE_FIELD; case 3: //It's an actor value, and not a formID at all. //Conditional resolution of av's based on JRoush's OBME/AV mod(s) //It's resolved just like a formID - if(Effects.value[ListIndex]->EFIT.value.actorValue >= 0x800) - return RESOLVED_ACTORVALUE_FIELD; - return STATIC_ACTORVALUE_FIELD; + return Effects.value[ListIndex]->EFIT.value.actorValue >= 0x800 ? RESOLVED_ACTORVALUE_FIELD : STATIC_ACTORVALUE_FIELD; default: //It's not a formID, mgefCode, or fancied up actor value //so do nothing return UINT32_FIELD; } } else - return UINT32_FIELD; + return STATIC_ACTORVALUE_FIELD; default: return UNKNOWN_FIELD; } @@ -153,15 +145,11 @@ UINT32 SPELRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) case 2: //It's a mgefCode, and not a formID at all. //Conditional resolution of mgefCode's based on JRoush's OBME mod //It's resolved just like a formID, except it uses the lower byte instead of the upper - if(Effects.value[ListIndex]->SCIT->script >= 0x80000000) - return RESOLVED_MGEFCODE_FIELD; - return STATIC_MGEFCODE_FIELD; + return Effects.value[ListIndex]->SCIT->script >= 0x80000000 ? RESOLVED_MGEFCODE_FIELD : STATIC_MGEFCODE_FIELD; case 3: //It's an actor value, and not a formID at all. //Conditional resolution of av's based on JRoush's OBME/AV mod(s) //It's resolved just like a formID - if(Effects.value[ListIndex]->SCIT->script >= 0x800) - return RESOLVED_ACTORVALUE_FIELD; - return STATIC_ACTORVALUE_FIELD; + return Effects.value[ListIndex]->SCIT->script >= 0x800 ? RESOLVED_ACTORVALUE_FIELD : STATIC_ACTORVALUE_FIELD; default: //It's not a formID, mgefCode, or fancied up actor value //so do nothing return UINT32_FIELD; @@ -173,21 +161,17 @@ UINT32 SPELRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) return UNKNOWN_FIELD; } case 9: //school - return UINT32_FIELD; + return UINT32_TYPE_FIELD; case 10: //visual switch(WhichAttribute) { case 0: //fieldType - return MGEFCODE_OR_UINT32_FIELD; + return MGEFCODE_OR_CHAR4_FIELD; case 2: //WhichType if(Effects.value[ListIndex]->OBME.IsLoaded() && Effects.value[ListIndex]->SCIT.IsLoaded()) - { - if(Effects.value[ListIndex]->SCIT->visual >= 0x80000000) - return RESOLVED_MGEFCODE_FIELD; - return STATIC_MGEFCODE_FIELD; - } + return ((Effects.value[ListIndex]->SCIT->visual >= 0x80000000) ? RESOLVED_MGEFCODE_FIELD : STATIC_MGEFCODE_FIELD); else - return UINT32_FIELD; + return CHAR4_FIELD; default: return UNKNOWN_FIELD; } @@ -199,9 +183,7 @@ UINT32 SPELRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) case 0: //fieldType return UINT8_ARRAY_FIELD; case 1: //fieldSize - if(Effects.value[ListIndex]->SCIT.IsLoaded()) - return 3; - return 0; + return Effects.value[ListIndex]->SCIT.IsLoaded() ? 3 : 0; default: return UNKNOWN_FIELD; } @@ -226,9 +208,7 @@ UINT32 SPELRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) case 0: //fieldType return UINT8_ARRAY_FIELD; case 1: //fieldSize - if(Effects.value[ListIndex]->OBME.IsLoaded()) - return 0xA; - return 0; + return Effects.value[ListIndex]->OBME.IsLoaded() ? 0xA : 0; default: return UNKNOWN_FIELD; } @@ -247,11 +227,7 @@ UINT32 SPELRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) return ACTORVALUE_FIELD; case 2: //WhichType if(Effects.value[ListIndex]->OBME.IsLoaded() && Effects.value[ListIndex]->OBME->EFIX.IsLoaded()) - { - if(Effects.value[ListIndex]->OBME->EFIX->resistAV >= 0x800) - return RESOLVED_ACTORVALUE_FIELD; - return STATIC_ACTORVALUE_FIELD; - } + return Effects.value[ListIndex]->OBME->EFIX->resistAV >= 0x800 ? RESOLVED_ACTORVALUE_FIELD : STATIC_ACTORVALUE_FIELD; else return UNKNOWN_FIELD; default: @@ -263,9 +239,7 @@ UINT32 SPELRecord::GetFieldAttribute(FIELD_IDENTIFIERS, UINT32 WhichAttribute) case 0: //fieldType return UINT8_ARRAY_FIELD; case 1: //fieldSize - if(Effects.value[ListIndex]->OBME.IsLoaded() && Effects.value[ListIndex]->OBME->EFIX.IsLoaded()) - return 0x10; - return 0; + return Effects.value[ListIndex]->OBME.IsLoaded() && Effects.value[ListIndex]->OBME->EFIX.IsLoaded() ? 0x10 : 0; default: return UNKNOWN_FIELD; } @@ -355,7 +329,7 @@ void * SPELRecord::GetField(FIELD_IDENTIFIERS, void **FieldValues) case 8: //script return Effects.value[ListIndex]->SCIT.IsLoaded() ? &Effects.value[ListIndex]->SCIT->script : NULL; case 9: //school - return Effects.value[ListIndex]->SCIT.IsLoaded() ? &Effects.value[ListIndex]->SCIT->school : NULL; + return Effects.value[ListIndex]->SCIT.IsLoaded() ? &Effects.value[ListIndex]->SCIT->schoolType : NULL; case 10: //visual return Effects.value[ListIndex]->SCIT.IsLoaded() ? &Effects.value[ListIndex]->SCIT->visual : NULL; case 11: //flags @@ -492,7 +466,7 @@ bool SPELRecord::SetField(FIELD_IDENTIFIERS, void *FieldValue, UINT32 ArraySize) return true; case 9: //school Effects.value[ListIndex]->SCIT.Load(); - Effects.value[ListIndex]->SCIT->school = *(UINT32 *)FieldValue; + Effects.value[ListIndex]->SCIT->schoolType = *(UINT32 *)FieldValue; break; case 10: //visual Effects.value[ListIndex]->SCIT.Load(); @@ -688,7 +662,7 @@ void SPELRecord::DeleteField(FIELD_IDENTIFIERS) return; case 9: //school if(Effects.value[ListIndex]->SCIT.IsLoaded()) - Effects.value[ListIndex]->SCIT->school = defaultSCIT.school; + Effects.value[ListIndex]->SCIT->schoolType = defaultSCIT.schoolType; return; case 10: //visual if(Effects.value[ListIndex]->SCIT.IsLoaded()) diff --git a/CBash/Oblivion/Records/MGEFRecord.cpp b/CBash/Oblivion/Records/MGEFRecord.cpp index 844a10e..2a34a11 100644 --- a/CBash/Oblivion/Records/MGEFRecord.cpp +++ b/CBash/Oblivion/Records/MGEFRecord.cpp @@ -28,7 +28,7 @@ MGEFRecord::MGEFDATA::MGEFDATA(): flags(0), baseCost(0.0f), associated(0), - school(0), + schoolType(0), resistValue(0xFFFFFFFF), numCounters(0), light(0), @@ -54,7 +54,7 @@ bool MGEFRecord::MGEFDATA::operator ==(const MGEFDATA &other) const { return (flags == other.flags && associated == other.associated && - school == other.school && + schoolType == other.schoolType && resistValue == other.resistValue && numCounters == other.numCounters && light == other.light && @@ -789,6 +789,76 @@ void MGEFRecord::SetOBMEFlagMask(UINT32 Mask) OBME->OBME.value.flags = Mask; } +bool MGEFRecord::IsSchoolAlteration() + { + return (DATA.value.schoolType == eAlteration); + } + +void MGEFRecord::IsSchoolAlteration(bool value) + { + DATA.value.schoolType = value ? eAlteration : eConjuration; + } + +bool MGEFRecord::IsSchoolConjuration() + { + return (DATA.value.schoolType == eConjuration); + } + +void MGEFRecord::IsSchoolConjuration(bool value) + { + DATA.value.schoolType = value ? eConjuration : eAlteration; + } + +bool MGEFRecord::IsSchoolDestruction() + { + return (DATA.value.schoolType == eDestruction); + } + +void MGEFRecord::IsSchoolDestruction(bool value) + { + DATA.value.schoolType = value ? eDestruction : eAlteration; + } + +bool MGEFRecord::IsSchoolIllusion() + { + return (DATA.value.schoolType == eIllusion); + } + +void MGEFRecord::IsSchoolIllusion(bool value) + { + DATA.value.schoolType = value ? eIllusion : eAlteration; + } + +bool MGEFRecord::IsSchoolMysticism() + { + return (DATA.value.schoolType == eMysticism); + } + +void MGEFRecord::IsSchoolMysticism(bool value) + { + DATA.value.schoolType = value ? eMysticism : eAlteration; + } + +bool MGEFRecord::IsSchoolRestoration() + { + return (DATA.value.schoolType == eRestoration); + } + +void MGEFRecord::IsSchoolRestoration(bool value) + { + DATA.value.schoolType = value ? eRestoration : eAlteration; + } + +bool MGEFRecord::IsSchool(UINT32 Type) + { + return (DATA.value.schoolType == Type); + } + +void MGEFRecord::SetSchool(UINT32 Type) + { + DATA.value.schoolType = Type; + } + UINT32 MGEFRecord::GetType() { return REV32(MGEF); @@ -843,6 +913,7 @@ SINT32 MGEFRecord::ParseRecord(unsigned char *buffer, unsigned char *end_buffer, OBME->OBME.Read(buffer, subSize); break; case REV32(EDDX): + //Is switched with the normal EDID on read and write so that the EDID field is a char *as expected OBME.Load(); memcpy(&OBME->EDDX.value.mgefCode[0], EDID.value, sizeof(OBME->EDDX.value.mgefCode) - 1); OBME->EDDX.value.mgefCode[4] = 0x00; diff --git a/CBash/Oblivion/Records/MGEFRecord.h b/CBash/Oblivion/Records/MGEFRecord.h index 2c076f8..024a7c1 100644 --- a/CBash/Oblivion/Records/MGEFRecord.h +++ b/CBash/Oblivion/Records/MGEFRecord.h @@ -33,7 +33,7 @@ class MGEFRecord : public Record //Base Effect UINT32 flags; FLOAT32 baseCost; FORMID associated; - SINT32 school; + UINT32 schoolType; UINT32 resistValue; UINT16 numCounters; //According to OBME UINT8 unused1[2]; @@ -149,6 +149,16 @@ class MGEFRecord : public Record //Base Effect fOBME_IsHidden = 0x40000000 }; + enum eSchools + { + eAlteration = 0, + eConjuration, + eDestruction, + eIllusion, + eMysticism, + eRestoration + }; + public: StringRecord EDID; //Editor ID StringRecord FULL; //Name @@ -260,6 +270,21 @@ class MGEFRecord : public Record //Base Effect bool IsOBMEFlagMask(UINT32 Mask, bool Exact=false); void SetOBMEFlagMask(UINT32 Mask); + bool IsSchoolAlteration(); + void IsSchoolAlteration(bool value); + bool IsSchoolConjuration(); + void IsSchoolConjuration(bool value); + bool IsSchoolDestruction(); + void IsSchoolDestruction(bool value); + bool IsSchoolIllusion(); + void IsSchoolIllusion(bool value); + bool IsSchoolMysticism(); + void IsSchoolMysticism(bool value); + bool IsSchoolRestoration(); + void IsSchoolRestoration(bool value); + bool IsSchool(UINT32 Type); + void SetSchool(UINT32 Type); + UINT32 GetFieldAttribute(DEFAULTED_FIELD_IDENTIFIERS, UINT32 WhichAttribute=0); void * GetField(DEFAULTED_FIELD_IDENTIFIERS, void **FieldValues=NULL); bool SetField(DEFAULTED_FIELD_IDENTIFIERS, void *FieldValue=NULL, UINT32 ArraySize=0); diff --git a/CBash/Oblivion/Records/SPELRecord.h b/CBash/Oblivion/Records/SPELRecord.h index 8aaafe1..c590f69 100644 --- a/CBash/Oblivion/Records/SPELRecord.h +++ b/CBash/Oblivion/Records/SPELRecord.h @@ -41,7 +41,7 @@ class SPELRecord : public Record }; enum eManualFixing { - eBadScript = 0x0000C079 + eBadScript = 0x0100C079 }; enum flagsFlags diff --git a/CBash/TES4RecordAPI.cpp b/CBash/TES4RecordAPI.cpp index 669cbf5..0db3af2 100644 --- a/CBash/TES4RecordAPI.cpp +++ b/CBash/TES4RecordAPI.cpp @@ -209,6 +209,8 @@ bool TES4Record::SetField(FIELD_IDENTIFIERS, void *FieldValue, UINT32 ArraySize) SNAM.TruncateCopy((STRING)FieldValue, 512); break; case 12: //masters + //Good chance of breaking the plugin if called. Might be better to disallow. + //Or atleast try and fix things up on this side. for(UINT32 x = 0; x < MAST.size(); x++) delete []MAST[x]; diff --git a/release/CBash.dll b/release/CBash.dll index 4a271bb..1ca3225 100644 Binary files a/release/CBash.dll and b/release/CBash.dll differ diff --git a/release/CBashExe.exe b/release/CBashExe.exe index f7b334f..c625512 100644 Binary files a/release/CBashExe.exe and b/release/CBashExe.exe differ diff --git a/release/CBashExe.pdb b/release/CBashExe.pdb index c57c5f0..5762bb1 100644 Binary files a/release/CBashExe.pdb and b/release/CBashExe.pdb differ diff --git a/release/cint-template.py b/release/cint-template.py index bd0edc7..34c3d09 100644 --- a/release/cint-template.py +++ b/release/cint-template.py @@ -252,7 +252,7 @@ class API_FIELDS(object): 'FORMID', 'MGEFCODE', 'ACTORVALUE', 'FORMID_OR_UINT32', 'FORMID_OR_FLOAT32', 'UINT8_OR_UINT32', 'FORMID_OR_STRING', 'UNKNOWN_OR_FORMID_OR_UINT32', 'UNKNOWN_OR_SINT32', - 'UNKNOWN_OR_UINT32_FLAG', 'MGEFCODE_OR_UINT32', + 'UNKNOWN_OR_UINT32_FLAG', 'MGEFCODE_OR_CHAR4', 'FORMID_OR_MGEFCODE_OR_ACTORVALUE_OR_UINT32', 'RESOLVED_MGEFCODE', 'STATIC_MGEFCODE', 'RESOLVED_ACTORVALUE', 'STATIC_ACTORVALUE', 'CHAR', 'CHAR4', 'STRING', 'ISTRING', @@ -577,10 +577,16 @@ def __hash__(self): return hash(self.formID) def __eq__(self, x): - return x[1] == self.formID[1] and x[0] == self.formID[0] + try: + return x[1] == self.formID[1] and x[0] == self.formID[0] + except TypeError: + return False def __ne__(self, other): - return x[1] != self.formID[1] or x[0] != self.formID[0] + try: + return x[1] != self.formID[1] or x[0] != self.formID[0] + except TypeError: + return False def __getitem__(self, x): if x == 0: return self.formID[0] @@ -837,7 +843,7 @@ def __init__(self, master, objectID=None): self.actorValue = ActorValue.UnvalidatedActorValue(str(master), objectID) else: if objectID < 0x800: - self.actorValue = ActorValue.RawActorValue(master, objectID) #Static ActorValue. No resolution takes place. + self.actorValue = ActorValue.RawActorValue(objectID) #Static ActorValue. No resolution takes place. else: masterstr = _CGetLongIDName(master, objectID, 0) if masterstr: @@ -851,10 +857,16 @@ def __hash__(self): return hash(self.actorValue) def __eq__(self, x): - return x[1] == self.actorValue[1] and x[0] == self.actorValue[0] + try: + return x[1] == self.actorValue[1] and x[0] == self.actorValue[0] + except TypeError: + return False def __ne__(self, other): - return x[1] != self.actorValue[1] or x[0] != self.actorValue[0] + try: + return x[1] != self.actorValue[1] or x[0] != self.actorValue[0] + except TypeError: + return False def __getitem__(self, x): if x == 0: return self.actorValue[0] @@ -1108,12 +1120,13 @@ def GetShortMGEFCode(self, target): def __init__(self, master, objectID=None): """Initializes an OBME MGEFCode from these possible inputs: - CBash MGEFCode = (int(RecordID) , int(MGEFCode)) Internal use by CBash / cint only! - Long MGEFCode = (string(ModName) , int(ObjectID)) - MGEFCode = (MGEFCode() , None) - Raw MGEFCode = (int(MGEFCode) , None) - Raw MGEFCode = (string(MGEFCode), None) - Empty MGEFCode = (None , None))""" + CBash MGEFCode = (int(RecordID) , int(MGEFCode)) Internal use by CBash / cint only! + CBash Raw MGEFCode = (int(RecordID) , string(MGEFCode)) Internal use by CBash / cint only! + Long MGEFCode = (string(ModName) , int(ObjectID)) + MGEFCode = (MGEFCode() , None) + Raw MGEFCode = (int(MGEFCode) , None) + Raw MGEFCode = (string(MGEFCode), None) + Empty MGEFCode = (None , None))""" if objectID is None: if isinstance(master, MGEFCode): #initialize from MGEFCode @@ -1123,7 +1136,9 @@ def __init__(self, master, objectID=None): else: self.mgefCode = MGEFCode.RawMGEFCode(master) else: - if isinstance(master, (basestring, Path)): + if isinstance(objectID, basestring): + self.mgefCode = MGEFCode.RawMGEFCode(objectID) + elif isinstance(master, (basestring, Path)): self.mgefCode = MGEFCode.UnvalidatedMGEFCode(str(master), objectID) else: if objectID < 0x80000000: @@ -1141,7 +1156,10 @@ def __hash__(self): return hash(self.mgefCode) def __eq__(self, x): - return x[1] == self.mgefCode[1] and x[0] == self.mgefCode[0] + try: + return x[1] == self.mgefCode[1] and x[0] == self.mgefCode[0] + except TypeError: + return False def __ne__(self, other): return x[1] != self.mgefCode[1] or x[0] != self.mgefCode[0] @@ -1688,8 +1706,7 @@ def __get__(self, instance, owner): def __set__(self, instance, nValue): if nValue is None: _CDeleteField(instance._RecordID, self._FieldID, 0, 0, 0, 0, 0, 0) - else: - _CSetField(instance._RecordID, self._FieldID, 0, 0, 0, 0, 0, 0, byref(c_ulong(nValue.GetShortMGEFCode(instance))), 0) + else: _CSetField(instance._RecordID, self._FieldID, 0, 0, 0, 0, 0, 0, byref(c_ulong(nValue.GetShortMGEFCode(instance))), 0) class CBashFORMIDARRAY(object): def __init__(self, FieldID): @@ -1792,7 +1809,7 @@ def __set__(self, instance, nValue): value = value.GetShortFormID(instance) _CSetField(instance._RecordID, self._FieldID, x, 1, 0, 0, 0, 0, byref(c_ulong(value)), IsFormID) -class CBashMGEFCODE_OR_UINT32_ARRAY(object): +class CBashMGEFCODE_ARRAY(object): def __init__(self, FieldID, Size=None): self._FieldID = FieldID self._Size = Size @@ -1805,10 +1822,10 @@ def __get__(self, instance, owner): _CGetField(instance._RecordID, self._FieldID, 0, 0, 0, 0, 0, 0, byref(cRecords)) for x in range(numRecords): type = _CGetFieldAttribute(instance._RecordID, self._FieldID, x, 1, 0, 0, 0, 0, 2) - if type == API_FIELDS.UINT32: - values.append(cRecords.contents[x]) - elif type in (API_FIELDS.STATIC_MGEFCODE, API_FIELDS.RESOLVED_MGEFCODE): - values.append(MGEFCode(instance._RecordID, cRecords.contents[x])) + value = cRecords.contents[x] + if type == API_FIELDS.CHAR4: + value = cast(byref(value), POINTER(c_char * 4)).contents.value + values.append(MGEFCode(instance._RecordID, value)) return values def __set__(self, instance, nValue): @@ -1816,10 +1833,8 @@ def __set__(self, instance, nValue): else: length = len(nValue) if self._Size and length != self._Size: return - #They are either all MGEFCodes or all UINT32's, so it can be set in one operation - if len(nValue): - if isinstance(nValue[0], MGEFCode): - nValue = [x.GetShortMGEFCode(instance) for x in nValue] + if length: + nValue = [x.GetShortMGEFCode(instance) for x in nValue] else: nValue = [] cRecords = (c_ulong * length)(*nValue) @@ -2129,27 +2144,23 @@ def __set__(self, instance, nValue): nValue = nValue.GetShortFormID(instance) _CSetField(instance._RecordID, instance._FieldID, instance._ListIndex, self._ListFieldID, 0, 0, 0, 0, byref(c_ulong(nValue)), 0) -class CBashMGEFCODE_OR_UINT32_LIST(object): +class CBashMGEFCODE_LIST(object): def __init__(self, ListFieldID): self._ListFieldID = ListFieldID def __get__(self, instance, owner): - _CGetField.restype = POINTER(c_ulong) + type = _CGetFieldAttribute(instance._RecordID, instance._FieldID, instance._ListIndex, self._ListFieldID, 0, 0, 0, 0, 2) + if type == API_FIELDS.CHAR4: + _CGetField.restype = POINTER(c_char * 4) + elif type in (API_FIELDS.STATIC_MGEFCODE, API_FIELDS.RESOLVED_MGEFCODE): + _CGetField.restype = POINTER(c_ulong) retValue = _CGetField(instance._RecordID, instance._FieldID, instance._ListIndex, self._ListFieldID, 0, 0, 0, 0, 0) - if(retValue): - type = _CGetFieldAttribute(instance._RecordID, instance._FieldID, instance._ListIndex, self._ListFieldID, 0, 0, 0, 0, 2) - if type == API_FIELDS.UINT32: - return retValue.contents.value - elif type in (API_FIELDS.STATIC_MGEFCODE, API_FIELDS.RESOLVED_MGEFCODE): - return MGEFCode(instance._RecordID, retValue.contents.value) + if retValue: return MGEFCode(instance._RecordID, retValue.contents.value) return None def __set__(self, instance, nValue): if nValue is None: _CDeleteField(instance._RecordID, instance._FieldID, instance._ListIndex, self._ListFieldID, 0, 0, 0, 0) - else: - if isinstance(nValue, MGEFCode): - nValue = nValue.GetShortMGEFCode(instance) - _CSetField(instance._RecordID, instance._FieldID, instance._ListIndex, self._ListFieldID, 0, 0, 0, 0, byref(c_ulong(nValue)), 0) + else: _CSetField(instance._RecordID, instance._FieldID, instance._ListIndex, self._ListFieldID, 0, 0, 0, 0, byref(c_ulong(nValue.GetShortMGEFCode(instance))), 0) class CBashFORMID_OR_MGEFCODE_OR_ACTORVALUE_OR_UINT32_LIST(object): def __init__(self, ListFieldID): @@ -2174,11 +2185,11 @@ def __set__(self, instance, nValue): if nValue is None: _CDeleteField(instance._RecordID, instance._FieldID, instance._ListIndex, self._ListFieldID, 0, 0, 0, 0) else: type = _CGetFieldAttribute(instance._RecordID, instance._FieldID, instance._ListIndex, self._ListFieldID, 0, 0, 0, 0, 2) - if type == API_FIELDS.FORMID and isinstance(nValue, FormID): + if type == API_FIELDS.FORMID: nValue = nValue.GetShortFormID(instance) - elif type in (API_FIELDS.STATIC_MGEFCODE, API_FIELDS.RESOLVED_MGEFCODE) and isinstance(nValue, MGEFCode): + elif type in (API_FIELDS.STATIC_MGEFCODE, API_FIELDS.RESOLVED_MGEFCODE): nValue = nValue.GetShortMGEFCode(instance) - elif type in (API_FIELDS.STATIC_ACTORVALUE, API_FIELDS.RESOLVED_ACTORVALUE) and isinstance(nValue, ActorValue): + elif type in (API_FIELDS.STATIC_ACTORVALUE, API_FIELDS.RESOLVED_ACTORVALUE): nValue = nValue.GetShortActorValue(instance) _CSetField(instance._RecordID, instance._FieldID, instance._ListIndex, self._ListFieldID, 0, 0, 0, 0, byref(c_ulong(nValue)), 0) @@ -2860,19 +2871,29 @@ class VarX3(ListX3Component): class Effect(ListComponent): ##name0 and name are both are always the same value, so setting one will set both. They're basically aliases - MGEFCODE_OR_UINT32_LISTMACRO(name0, 1) - MGEFCODE_OR_UINT32_LISTMACRO(name, 2) + MGEFCODE_LISTMACRO(name0, 1) + MGEFCODE_LISTMACRO(name, 2) UINT32_LISTMACRO(magnitude, 3) UINT32_LISTMACRO(area, 4) UINT32_LISTMACRO(duration, 5) - UINT32_LISTMACRO(rangeType, 6) + UINT32_TYPE_LISTMACRO(rangeType, 6) OBMEFORMID_OR_MGEFCODE_OR_ACTORVALUE_OR_UINT32_LISTMACRO(actorValue, 7) OBMEFORMID_OR_MGEFCODE_OR_ACTORVALUE_OR_UINT32_LISTMACRO(script, 8) - UINT32_LISTMACRO(school, 9) - OBMEMGEFCODE_OR_UINT32_LISTMACRO(visual, 10) + UINT32_TYPE_LISTMACRO(schoolType, 9) + OBMEMGEFCODE_LISTMACRO(visual, 10) UINT8_FLAG_LISTMACRO(flags, 11) UINT8_ARRAY_LISTMACRO(unused1, 12, 3) OBMESTRING_LISTMACRO(full, 13) + BasicFlagMACRO(IsHostile, flags, 0x01) + BasicTypeMACRO(IsSelf, rangeType, 0, IsTouch) + BasicTypeMACRO(IsTouch, rangeType, 1, IsSelf) + BasicTypeMACRO(IsTarget, rangeType, 2, IsSelf) + BasicTypeMACRO(IsAlteration, schoolType, 0, IsConjuration) + BasicTypeMACRO(IsConjuration, schoolType, 1, IsAlteration) + BasicTypeMACRO(IsDestruction, schoolType, 2, IsAlteration) + BasicTypeMACRO(IsIllusion, schoolType, 3, IsAlteration) + BasicTypeMACRO(IsMysticism, schoolType, 4, IsAlteration) + BasicTypeMACRO(IsRestoration, schoolType, 5, IsAlteration) ##OBME Fields. Setting any of the below fields will make the mod require JRoush's OBME plugin for OBSE ##To see if OBME is in use, check the recordVersion field for a non-None value OBMEUINT8_LISTMACRO(recordVersion, 14) @@ -2890,10 +2911,6 @@ class Effect(ListComponent): OBMEFLOAT32_LISTMACRO(baseCost, 24) OBMEACTORVALUE_LISTMACRO(resistAV, 25) OBMEUINT8_ARRAY_LISTMACRO(reserved2, 26, 0x10) - BasicFlagMACRO(IsHostile, flags, 0x01) - BasicTypeMACRO(IsSelf, rangeType, 0, IsTouch) - BasicTypeMACRO(IsTouch, rangeType, 1, IsSelf) - BasicTypeMACRO(IsTarget, rangeType, 2, IsSelf) ##OBME Fields. Setting any of the below fields will make the mod require JRoush's OBME plugin for OBSE ##To see if OBME is in use, check the recordVersion field for a non-None value OBMEBasicFlagMACRO(IsUsingHostileOverride, efixOverrides, 0x00000001) @@ -2942,7 +2959,7 @@ class Effect(ListComponent): OBMEBasicFlagMACRO(IsExplodesWithForceOverride, efixFlags, 0x20000000) OBMEBasicFlagMACRO(IsHiddenOverride, efixFlags, 0x40000000) exportattrs = copyattrs = ['name', 'magnitude', 'area', 'duration', 'rangeType', - 'actorValue', 'script', 'school', 'visual', 'IsHostile', + 'actorValue', 'script', 'schoolType', 'visual', 'IsHostile', 'full'] copyattrsOBME = copyattrs + ['recordVersion', 'betaVersion', 'minorVersion', 'majorVersion', @@ -8607,10 +8624,10 @@ def bsb(self): return (blockNum, subBlockNum) #--Exterior cell else: - blockX = int(math.floor(self.posX or 0 / 8.0)) - blockY = int(math.floor(self.posY or 0 / 8.0)) - subblockX = int(math.floor(blockX / 4.0)) - subblockY = int(math.floor(blockY / 4.0)) + subblockX = int(math.floor((self.posX or 0) / 8.0)) + subblockY = int(math.floor((self.posY or 0) / 8.0)) + blockX = int(math.floor(subblockX / 4.0)) + blockY = int(math.floor(subblockY / 4.0)) return ((blockX, blockY), (subblockX, subblockY)) class SwappedImpact(ListComponent): @@ -10886,10 +10903,10 @@ def bsb(self): return (blockNum, subBlockNum) #--Exterior cell else: - blockX = int(math.floor(self.posX or 0 / 8.0)) - blockY = int(math.floor(self.posY or 0 / 8.0)) - subblockX = int(math.floor(blockX / 4.0)) - subblockY = int(math.floor(blockY / 4.0)) + subblockX = int(math.floor((self.posX or 0) / 8.0)) + subblockY = int(math.floor((self.posY or 0) / 8.0)) + blockX = int(math.floor(subblockX / 4.0)) + blockY = int(math.floor(subblockY / 4.0)) return ((blockX, blockY), (subblockX, subblockY)) STRING_MACRO(full, 5) @@ -11926,7 +11943,7 @@ class ObMGEFRecord(ObBaseRecord): UINT32_FLAG_EDIDMACRO(flags, 11) FLOAT32_EDIDMACRO(baseCost, 12) FORMID_EDIDMACRO(associated, 13) - SINT32_EDIDMACRO(school, 14) + UINT32_TYPE_EDIDMACRO(schoolType, 14) ##0xFFFFFFFF is None for resistValue UINT32_EDIDMACRO(resistValue, 15) UINT16_EDIDMACRO(numCounters, 16) @@ -11941,7 +11958,13 @@ class ObMGEFRecord(ObBaseRecord): FORMID_EDIDMACRO(areaSound, 25) FLOAT32_EDIDMACRO(cefEnchantment, 26) FLOAT32_EDIDMACRO(cefBarter, 27) - MGEFCODE_OR_UINT32_ARRAY_EDIDMACRO(counterEffects, 28) + MGEFCODE_ARRAY_EDIDMACRO(counterEffects, 28) + BasicTypeMACRO(IsAlteration, schoolType, 0, IsConjuration) + BasicTypeMACRO(IsConjuration, schoolType, 1, IsAlteration) + BasicTypeMACRO(IsDestruction, schoolType, 2, IsAlteration) + BasicTypeMACRO(IsIllusion, schoolType, 3, IsAlteration) + BasicTypeMACRO(IsMysticism, schoolType, 4, IsAlteration) + BasicTypeMACRO(IsRestoration, schoolType, 5, IsAlteration) #Note: the vanilla code discards mod changes to most flag bits # only those listed as changeable below may be edited by non-obme mods # comments garnered from JRoush's OBME @@ -12026,7 +12049,7 @@ def set_IsBoltType(self, nValue): OBMEBasicFlagMACRO(IsHidden, OBMEFlags, 0x40000000) copyattrs = ObBaseRecord.baseattrs + ['full', 'text', 'iconPath', 'modPath', 'modb', 'modt_p', 'flags', 'baseCost', - 'associated', 'school', 'resistValue', + 'associated', 'schoolType', 'resistValue', 'numCounters', 'light', 'projectileSpeed', 'effectShader', 'enchantEffect', 'castingSound', 'boltSound', 'hitSound', @@ -12034,7 +12057,7 @@ def set_IsBoltType(self, nValue): 'counterEffects'] exportattrs = ObBaseRecord.baseattrs + ['full', 'text', 'iconPath', 'modPath', 'modb', 'flags', 'baseCost', - 'associated', 'school', 'resistValue', + 'associated', 'schoolType', 'resistValue', 'numCounters', 'light', 'projectileSpeed', 'effectShader', 'enchantEffect', 'castingSound', 'boltSound', 'hitSound', @@ -13346,13 +13369,13 @@ def Load(self): def Unload(self): _CUnloadMod(self._ModID) - def save(self, CloseCollection=True, CleanMasters=True): + def save(self, CloseCollection=True, CleanMasters=True, DestinationName=None): flags = 0 if(CleanMasters): flags |= 0x00000001 if(CloseCollection): flags |= 0x00000002 - return _CSaveMod(self._ModID, c_ulong(flags)) + return _CSaveMod(self._ModID, c_ulong(flags), str(DestinationName)) @property def TES4(self): @@ -13574,13 +13597,13 @@ def Load(self): def Unload(self): _CUnloadMod(self._ModID) - def save(self, CloseCollection=True, CleanMasters=True): + def save(self, CloseCollection=True, CleanMasters=True, DestinationName=None): flags = 0 if(CleanMasters): flags |= 0x00000001 if(CloseCollection): flags |= 0x00000002 - return _CSaveMod(self._ModID, c_ulong(flags)) + return _CSaveMod(self._ModID, c_ulong(flags), str(DestinationName)) @property def TES4(self): diff --git a/release/cint.py b/release/cint.py index 059c70a..5232d86 100644 --- a/release/cint.py +++ b/release/cint.py @@ -252,7 +252,7 @@ class API_FIELDS(object): 'FORMID', 'MGEFCODE', 'ACTORVALUE', 'FORMID_OR_UINT32', 'FORMID_OR_FLOAT32', 'UINT8_OR_UINT32', 'FORMID_OR_STRING', 'UNKNOWN_OR_FORMID_OR_UINT32', 'UNKNOWN_OR_SINT32', - 'UNKNOWN_OR_UINT32_FLAG', 'MGEFCODE_OR_UINT32', + 'UNKNOWN_OR_UINT32_FLAG', 'MGEFCODE_OR_CHAR4', 'FORMID_OR_MGEFCODE_OR_ACTORVALUE_OR_UINT32', 'RESOLVED_MGEFCODE', 'STATIC_MGEFCODE', 'RESOLVED_ACTORVALUE', 'STATIC_ACTORVALUE', 'CHAR', 'CHAR4', 'STRING', 'ISTRING', @@ -577,10 +577,16 @@ def __hash__(self): return hash(self.formID) def __eq__(self, x): - return x[1] == self.formID[1] and x[0] == self.formID[0] + try: + return x[1] == self.formID[1] and x[0] == self.formID[0] + except TypeError: + return False def __ne__(self, other): - return x[1] != self.formID[1] or x[0] != self.formID[0] + try: + return x[1] != self.formID[1] or x[0] != self.formID[0] + except TypeError: + return False def __getitem__(self, x): if x == 0: return self.formID[0] @@ -837,7 +843,7 @@ def __init__(self, master, objectID=None): self.actorValue = ActorValue.UnvalidatedActorValue(str(master), objectID) else: if objectID < 0x800: - self.actorValue = ActorValue.RawActorValue(master, objectID) #Static ActorValue. No resolution takes place. + self.actorValue = ActorValue.RawActorValue(objectID) #Static ActorValue. No resolution takes place. else: masterstr = _CGetLongIDName(master, objectID, 0) if masterstr: @@ -851,10 +857,16 @@ def __hash__(self): return hash(self.actorValue) def __eq__(self, x): - return x[1] == self.actorValue[1] and x[0] == self.actorValue[0] + try: + return x[1] == self.actorValue[1] and x[0] == self.actorValue[0] + except TypeError: + return False def __ne__(self, other): - return x[1] != self.actorValue[1] or x[0] != self.actorValue[0] + try: + return x[1] != self.actorValue[1] or x[0] != self.actorValue[0] + except TypeError: + return False def __getitem__(self, x): if x == 0: return self.actorValue[0] @@ -1108,12 +1120,13 @@ def GetShortMGEFCode(self, target): def __init__(self, master, objectID=None): """Initializes an OBME MGEFCode from these possible inputs: - CBash MGEFCode = (int(RecordID) , int(MGEFCode)) Internal use by CBash / cint only! - Long MGEFCode = (string(ModName) , int(ObjectID)) - MGEFCode = (MGEFCode() , None) - Raw MGEFCode = (int(MGEFCode) , None) - Raw MGEFCode = (string(MGEFCode), None) - Empty MGEFCode = (None , None))""" + CBash MGEFCode = (int(RecordID) , int(MGEFCode)) Internal use by CBash / cint only! + CBash Raw MGEFCode = (int(RecordID) , string(MGEFCode)) Internal use by CBash / cint only! + Long MGEFCode = (string(ModName) , int(ObjectID)) + MGEFCode = (MGEFCode() , None) + Raw MGEFCode = (int(MGEFCode) , None) + Raw MGEFCode = (string(MGEFCode), None) + Empty MGEFCode = (None , None))""" if objectID is None: if isinstance(master, MGEFCode): #initialize from MGEFCode @@ -1123,7 +1136,9 @@ def __init__(self, master, objectID=None): else: self.mgefCode = MGEFCode.RawMGEFCode(master) else: - if isinstance(master, (basestring, Path)): + if isinstance(objectID, basestring): + self.mgefCode = MGEFCode.RawMGEFCode(objectID) + elif isinstance(master, (basestring, Path)): self.mgefCode = MGEFCode.UnvalidatedMGEFCode(str(master), objectID) else: if objectID < 0x80000000: @@ -1141,7 +1156,10 @@ def __hash__(self): return hash(self.mgefCode) def __eq__(self, x): - return x[1] == self.mgefCode[1] and x[0] == self.mgefCode[0] + try: + return x[1] == self.mgefCode[1] and x[0] == self.mgefCode[0] + except TypeError: + return False def __ne__(self, other): return x[1] != self.mgefCode[1] or x[0] != self.mgefCode[0] @@ -1688,8 +1706,7 @@ def __get__(self, instance, owner): def __set__(self, instance, nValue): if nValue is None: _CDeleteField(instance._RecordID, self._FieldID, 0, 0, 0, 0, 0, 0) - else: - _CSetField(instance._RecordID, self._FieldID, 0, 0, 0, 0, 0, 0, byref(c_ulong(nValue.GetShortMGEFCode(instance))), 0) + else: _CSetField(instance._RecordID, self._FieldID, 0, 0, 0, 0, 0, 0, byref(c_ulong(nValue.GetShortMGEFCode(instance))), 0) class CBashFORMIDARRAY(object): def __init__(self, FieldID): @@ -1792,7 +1809,7 @@ def __set__(self, instance, nValue): value = value.GetShortFormID(instance) _CSetField(instance._RecordID, self._FieldID, x, 1, 0, 0, 0, 0, byref(c_ulong(value)), IsFormID) -class CBashMGEFCODE_OR_UINT32_ARRAY(object): +class CBashMGEFCODE_ARRAY(object): def __init__(self, FieldID, Size=None): self._FieldID = FieldID self._Size = Size @@ -1805,10 +1822,10 @@ def __get__(self, instance, owner): _CGetField(instance._RecordID, self._FieldID, 0, 0, 0, 0, 0, 0, byref(cRecords)) for x in range(numRecords): type = _CGetFieldAttribute(instance._RecordID, self._FieldID, x, 1, 0, 0, 0, 0, 2) - if type == API_FIELDS.UINT32: - values.append(cRecords.contents[x]) - elif type in (API_FIELDS.STATIC_MGEFCODE, API_FIELDS.RESOLVED_MGEFCODE): - values.append(MGEFCode(instance._RecordID, cRecords.contents[x])) + value = cRecords.contents[x] + if type == API_FIELDS.CHAR4: + value = cast(byref(value), POINTER(c_char * 4)).contents.value + values.append(MGEFCode(instance._RecordID, value)) return values def __set__(self, instance, nValue): @@ -1816,10 +1833,8 @@ def __set__(self, instance, nValue): else: length = len(nValue) if self._Size and length != self._Size: return - #They are either all MGEFCodes or all UINT32's, so it can be set in one operation - if len(nValue): - if isinstance(nValue[0], MGEFCode): - nValue = [x.GetShortMGEFCode(instance) for x in nValue] + if length: + nValue = [x.GetShortMGEFCode(instance) for x in nValue] else: nValue = [] cRecords = (c_ulong * length)(*nValue) @@ -2129,27 +2144,23 @@ def __set__(self, instance, nValue): nValue = nValue.GetShortFormID(instance) _CSetField(instance._RecordID, instance._FieldID, instance._ListIndex, self._ListFieldID, 0, 0, 0, 0, byref(c_ulong(nValue)), 0) -class CBashMGEFCODE_OR_UINT32_LIST(object): +class CBashMGEFCODE_LIST(object): def __init__(self, ListFieldID): self._ListFieldID = ListFieldID def __get__(self, instance, owner): - _CGetField.restype = POINTER(c_ulong) + type = _CGetFieldAttribute(instance._RecordID, instance._FieldID, instance._ListIndex, self._ListFieldID, 0, 0, 0, 0, 2) + if type == API_FIELDS.CHAR4: + _CGetField.restype = POINTER(c_char * 4) + elif type in (API_FIELDS.STATIC_MGEFCODE, API_FIELDS.RESOLVED_MGEFCODE): + _CGetField.restype = POINTER(c_ulong) retValue = _CGetField(instance._RecordID, instance._FieldID, instance._ListIndex, self._ListFieldID, 0, 0, 0, 0, 0) - if(retValue): - type = _CGetFieldAttribute(instance._RecordID, instance._FieldID, instance._ListIndex, self._ListFieldID, 0, 0, 0, 0, 2) - if type == API_FIELDS.UINT32: - return retValue.contents.value - elif type in (API_FIELDS.STATIC_MGEFCODE, API_FIELDS.RESOLVED_MGEFCODE): - return MGEFCode(instance._RecordID, retValue.contents.value) + if retValue: return MGEFCode(instance._RecordID, retValue.contents.value) return None def __set__(self, instance, nValue): if nValue is None: _CDeleteField(instance._RecordID, instance._FieldID, instance._ListIndex, self._ListFieldID, 0, 0, 0, 0) - else: - if isinstance(nValue, MGEFCode): - nValue = nValue.GetShortMGEFCode(instance) - _CSetField(instance._RecordID, instance._FieldID, instance._ListIndex, self._ListFieldID, 0, 0, 0, 0, byref(c_ulong(nValue)), 0) + else: _CSetField(instance._RecordID, instance._FieldID, instance._ListIndex, self._ListFieldID, 0, 0, 0, 0, byref(c_ulong(nValue.GetShortMGEFCode(instance))), 0) class CBashFORMID_OR_MGEFCODE_OR_ACTORVALUE_OR_UINT32_LIST(object): def __init__(self, ListFieldID): @@ -2174,11 +2185,11 @@ def __set__(self, instance, nValue): if nValue is None: _CDeleteField(instance._RecordID, instance._FieldID, instance._ListIndex, self._ListFieldID, 0, 0, 0, 0) else: type = _CGetFieldAttribute(instance._RecordID, instance._FieldID, instance._ListIndex, self._ListFieldID, 0, 0, 0, 0, 2) - if type == API_FIELDS.FORMID and isinstance(nValue, FormID): + if type == API_FIELDS.FORMID: nValue = nValue.GetShortFormID(instance) - elif type in (API_FIELDS.STATIC_MGEFCODE, API_FIELDS.RESOLVED_MGEFCODE) and isinstance(nValue, MGEFCode): + elif type in (API_FIELDS.STATIC_MGEFCODE, API_FIELDS.RESOLVED_MGEFCODE): nValue = nValue.GetShortMGEFCode(instance) - elif type in (API_FIELDS.STATIC_ACTORVALUE, API_FIELDS.RESOLVED_ACTORVALUE) and isinstance(nValue, ActorValue): + elif type in (API_FIELDS.STATIC_ACTORVALUE, API_FIELDS.RESOLVED_ACTORVALUE): nValue = nValue.GetShortActorValue(instance) _CSetField(instance._RecordID, instance._FieldID, instance._ListIndex, self._ListFieldID, 0, 0, 0, 0, byref(c_ulong(nValue)), 0) @@ -2860,19 +2871,29 @@ class VarX3(ListX3Component): class Effect(ListComponent): ##name0 and name are both are always the same value, so setting one will set both. They're basically aliases - name0 = CBashMGEFCODE_OR_UINT32_LIST(1) - name = CBashMGEFCODE_OR_UINT32_LIST(2) + name0 = CBashMGEFCODE_LIST(1) + name = CBashMGEFCODE_LIST(2) magnitude = CBashGeneric_LIST(3, c_ulong) area = CBashGeneric_LIST(4, c_ulong) duration = CBashGeneric_LIST(5, c_ulong) rangeType = CBashGeneric_LIST(6, c_ulong) actorValue = CBashFORMID_OR_MGEFCODE_OR_ACTORVALUE_OR_UINT32_LIST(7) #OBME script = CBashFORMID_OR_MGEFCODE_OR_ACTORVALUE_OR_UINT32_LIST(8) #OBME - school = CBashGeneric_LIST(9, c_ulong) - visual = CBashMGEFCODE_OR_UINT32_LIST(10) #OBME + schoolType = CBashGeneric_LIST(9, c_ulong) + visual = CBashMGEFCODE_LIST(10) #OBME flags = CBashGeneric_LIST(11, c_ubyte) unused1 = CBashUINT8ARRAY_LIST(12, 3) full = CBashSTRING_LIST(13) #OBME + IsHostile = CBashBasicFlag('flags', 0x01) + IsSelf = CBashBasicType('rangeType', 0, 'IsTouch') + IsTouch = CBashBasicType('rangeType', 1, 'IsSelf') + IsTarget = CBashBasicType('rangeType', 2, 'IsSelf') + IsAlteration = CBashBasicType('schoolType', 0, 'IsConjuration') + IsConjuration = CBashBasicType('schoolType', 1, 'IsAlteration') + IsDestruction = CBashBasicType('schoolType', 2, 'IsAlteration') + IsIllusion = CBashBasicType('schoolType', 3, 'IsAlteration') + IsMysticism = CBashBasicType('schoolType', 4, 'IsAlteration') + IsRestoration = CBashBasicType('schoolType', 5, 'IsAlteration') ##OBME Fields. Setting any of the below fields will make the mod require JRoush's OBME plugin for OBSE ##To see if OBME is in use, check the recordVersion field for a non-None value recordVersion = CBashGeneric_LIST(14, c_ubyte) #OBME @@ -2890,10 +2911,6 @@ class Effect(ListComponent): baseCost = CBashFLOAT32_LIST(24) #OBME resistAV = CBashACTORVALUE_LIST(25) #OBME reserved2 = CBashUINT8ARRAY_LIST(26, 0x10) #OBME - IsHostile = CBashBasicFlag('flags', 0x01) - IsSelf = CBashBasicType('rangeType', 0, 'IsTouch') - IsTouch = CBashBasicType('rangeType', 1, 'IsSelf') - IsTarget = CBashBasicType('rangeType', 2, 'IsSelf') ##OBME Fields. Setting any of the below fields will make the mod require JRoush's OBME plugin for OBSE ##To see if OBME is in use, check the recordVersion field for a non-None value IsUsingHostileOverride = CBashBasicFlag('efixOverrides', 0x00000001) #OBME @@ -2942,7 +2959,7 @@ class Effect(ListComponent): IsExplodesWithForceOverride = CBashBasicFlag('efixFlags', 0x20000000) #OBME IsHiddenOverride = CBashBasicFlag('efixFlags', 0x40000000) #OBME exportattrs = copyattrs = ['name', 'magnitude', 'area', 'duration', 'rangeType', - 'actorValue', 'script', 'school', 'visual', 'IsHostile', + 'actorValue', 'script', 'schoolType', 'visual', 'IsHostile', 'full'] copyattrsOBME = copyattrs + ['recordVersion', 'betaVersion', 'minorVersion', 'majorVersion', @@ -9433,10 +9450,10 @@ def bsb(self): return (blockNum, subBlockNum) #--Exterior cell else: - blockX = int(math.floor(self.posX or 0 / 8.0)) - blockY = int(math.floor(self.posY or 0 / 8.0)) - subblockX = int(math.floor(blockX / 4.0)) - subblockY = int(math.floor(blockY / 4.0)) + subblockX = int(math.floor((self.posX or 0) / 8.0)) + subblockY = int(math.floor((self.posY or 0) / 8.0)) + blockX = int(math.floor(subblockX / 4.0)) + blockY = int(math.floor(subblockY / 4.0)) return ((blockX, blockY), (subblockX, subblockY)) class SwappedImpact(ListComponent): @@ -12002,10 +12019,10 @@ def bsb(self): return (blockNum, subBlockNum) #--Exterior cell else: - blockX = int(math.floor(self.posX or 0 / 8.0)) - blockY = int(math.floor(self.posY or 0 / 8.0)) - subblockX = int(math.floor(blockX / 4.0)) - subblockY = int(math.floor(blockY / 4.0)) + subblockX = int(math.floor((self.posX or 0) / 8.0)) + subblockY = int(math.floor((self.posY or 0) / 8.0)) + blockX = int(math.floor(subblockX / 4.0)) + blockY = int(math.floor(subblockY / 4.0)) return ((blockX, blockY), (subblockX, subblockY)) full = CBashSTRING(5) @@ -13164,7 +13181,7 @@ class ObMGEFRecord(ObBaseRecord): flags = CBashGeneric(11, c_ulong) baseCost = CBashFLOAT32(12) associated = CBashFORMID(13) - school = CBashGeneric(14, c_long) + schoolType = CBashGeneric(14, c_ulong) ##0xFFFFFFFF is None for resistValue resistValue = CBashGeneric(15, c_ulong) numCounters = CBashGeneric(16, c_ushort) @@ -13179,7 +13196,13 @@ class ObMGEFRecord(ObBaseRecord): areaSound = CBashFORMID(25) cefEnchantment = CBashFLOAT32(26) cefBarter = CBashFLOAT32(27) - counterEffects = CBashMGEFCODE_OR_UINT32_ARRAY(28) + counterEffects = CBashMGEFCODE_ARRAY(28) + IsAlteration = CBashBasicType('schoolType', 0, 'IsConjuration') + IsConjuration = CBashBasicType('schoolType', 1, 'IsAlteration') + IsDestruction = CBashBasicType('schoolType', 2, 'IsAlteration') + IsIllusion = CBashBasicType('schoolType', 3, 'IsAlteration') + IsMysticism = CBashBasicType('schoolType', 4, 'IsAlteration') + IsRestoration = CBashBasicType('schoolType', 5, 'IsAlteration') #Note: the vanilla code discards mod changes to most flag bits # only those listed as changeable below may be edited by non-obme mods # comments garnered from JRoush's OBME @@ -13264,7 +13287,7 @@ def set_IsBoltType(self, nValue): IsHidden = CBashBasicFlag('OBMEFlags', 0x40000000) #OBME copyattrs = ObBaseRecord.baseattrs + ['full', 'text', 'iconPath', 'modPath', 'modb', 'modt_p', 'flags', 'baseCost', - 'associated', 'school', 'resistValue', + 'associated', 'schoolType', 'resistValue', 'numCounters', 'light', 'projectileSpeed', 'effectShader', 'enchantEffect', 'castingSound', 'boltSound', 'hitSound', @@ -13272,7 +13295,7 @@ def set_IsBoltType(self, nValue): 'counterEffects'] exportattrs = ObBaseRecord.baseattrs + ['full', 'text', 'iconPath', 'modPath', 'modb', 'flags', 'baseCost', - 'associated', 'school', 'resistValue', + 'associated', 'schoolType', 'resistValue', 'numCounters', 'light', 'projectileSpeed', 'effectShader', 'enchantEffect', 'castingSound', 'boltSound', 'hitSound', @@ -14767,13 +14790,13 @@ def Load(self): def Unload(self): _CUnloadMod(self._ModID) - def save(self, CloseCollection=True, CleanMasters=True): + def save(self, CloseCollection=True, CleanMasters=True, DestinationName=None): flags = 0 if(CleanMasters): flags |= 0x00000001 if(CloseCollection): flags |= 0x00000002 - return _CSaveMod(self._ModID, c_ulong(flags)) + return _CSaveMod(self._ModID, c_ulong(flags), str(DestinationName)) @property def TES4(self): @@ -15275,13 +15298,13 @@ def Load(self): def Unload(self): _CUnloadMod(self._ModID) - def save(self, CloseCollection=True, CleanMasters=True): + def save(self, CloseCollection=True, CleanMasters=True, DestinationName=None): flags = 0 if(CleanMasters): flags |= 0x00000001 if(CloseCollection): flags |= 0x00000002 - return _CSaveMod(self._ModID, c_ulong(flags)) + return _CSaveMod(self._ModID, c_ulong(flags), str(DestinationName)) @property def TES4(self):