Warlock

TemplePlus/action_sequence.cpp

@@ -1727,7 +1727,7 @@ int ActionSequenceSystem::TrimPathToRemainingMoveLength(D20Actn* d20a, float rem
 uint32_t ActionSequenceSystem::ActionCostNull(D20Actn* d20Actn, TurnBasedStatus* turnBasedStatus, ActionCostPacket* actionCostPacket)
 {
 	actionCostPacket->hourglassCost = 0;
-	actionCostPacket->chargeAfterPicker = 0;
+	actionCostPacket->attackCost = 0;
 	actionCostPacket->moveDistCost = 0;
 	return 0;
 }
@@ -3388,7 +3388,7 @@ BOOL ActionSequenceSystem::SimulsAdvance()
 
 int ActionSequenceSystem::ActionCostFullAttack(D20Actn* d20, TurnBasedStatus* tbStat, ActionCostPacket* acp)
 {
-	acp->chargeAfterPicker = 0;
+	acp->attackCost = 0;
 	acp->moveDistCost = 0;
 	acp->hourglassCost = 4;
 	int flags = d20->d20Caf;
@@ -3529,13 +3529,13 @@ int ActionSequenceSystem::ActionCostProcess(TurnBasedStatus* tbStat, D20Actn* d2
 	if (tbStat->surplusMoveDistance >= actCost.moveDistCost)
 	{
 		tbStat->surplusMoveDistance -= actCost.moveDistCost;
-		if ( actCost.chargeAfterPicker <= 0 
-			|| actCost.chargeAfterPicker + tbStat->attackModeCode <= tbStat->baseAttackNumCode + tbStat->numBonusAttacks)
+		if ( actCost.attackCost <= 0 
+			|| actCost.attackCost + tbStat->attackModeCode <= tbStat->baseAttackNumCode + tbStat->numBonusAttacks)
 		{
-			if ((int) tbStat->numBonusAttacks < actCost.chargeAfterPicker)
-				tbStat->attackModeCode += actCost.chargeAfterPicker;
+			if (actCost.attackCost > (int) tbStat->numBonusAttacks )
+				tbStat->attackModeCode += actCost.attackCost;
 			else
-				tbStat->numBonusAttacks -= actCost.chargeAfterPicker;
+				tbStat->numBonusAttacks -= actCost.attackCost;
 			if (tbStat->attackModeCode == tbStat->baseAttackNumCode && !tbStat->numBonusAttacks)
 				tbStat->tbsFlags &= ~TBSF_FullAttack;  
 			result = AEC_OK;
@@ -3799,12 +3799,13 @@ int ActionSequenceSystem::StdAttackTurnBasedStatusCheck(D20Actn* d20a, TurnBased
 		return AEC_TARGET_INVALID;
 	}
 
+	const int STD_ATK_HG_COST= 2;
 	if (hgState != -1)
-		hgState = turnBasedStatusTransitionMatrix[hgState][2];
+		hgState = turnBasedStatusTransitionMatrix[hgState][STD_ATK_HG_COST];
 	tbStat->hourglassState = hgState;
 
-	if (inventory.ItemWornAt(d20a->d20APerformer, 3) || dispatch.DispatchD20ActionCheck(d20a, tbStat, dispTypeGetCritterNaturalAttacksNum)  <= 0)
-		tbStat->attackModeCode = 0;
+	if (inventory.ItemWornAt(d20a->d20APerformer, EquipSlot::WeaponPrimary) || dispatch.DispatchD20ActionCheck(d20a, tbStat, dispTypeGetCritterNaturalAttacksNum) <= 0)
+		tbStat->attackModeCode = ATTACK_CODE_PRIMARY;
 	else
 		tbStat->attackModeCode = ATTACK_CODE_NATURAL_ATTACK;
 	tbStat->baseAttackNumCode = tbStat->attackModeCode + 1;
@@ -4325,12 +4326,15 @@ const char*actionErrorCodeStrings[] =
 	"AEC_NEED_A_STRAIGHT_LINE",
 	"AEC_NO_ACTIONS",
 	"AEC_NOT_IN_COMBAT",
-	"AEC_AREA_NOT_SAFE"
+	"AEC_AREA_NOT_SAFE",
+	"AEC_ABILITY_ON_COOLDOWN",
+	"AEC_ALREADY_USED_THIS_TURN",
+	"AEC_ALREADY_ACTIVE"
 };
 ostream & operator<<(ostream & str, ActionErrorCode aec)
 {
 	size_t i = (size_t)aec;
-	if (i <= AEC_AREA_NOT_SAFE) {
+	if (i <= AEC_ALREADY_ACTIVE) {
 		str << actionErrorCodeStrings[i];
 	}
 	else {

TemplePlus/action_sequence.h

@@ -48,7 +48,10 @@ enum ActionErrorCode : uint32_t
 	AEC_NEED_A_STRAIGHT_LINE,
 	AEC_NO_ACTIONS,
 	AEC_NOT_IN_COMBAT,
-	AEC_AREA_NOT_SAFE
+	AEC_AREA_NOT_SAFE,
+	AEC_ABILITY_ON_COOLDOWN,
+	AEC_ALREADY_USED_THIS_TURN,
+	AEC_ALREADY_ACTIVE
 };
 
 // Allows for direct use of ActionErrorCode in format() strings

TemplePlus/condition.cpp

@@ -338,6 +338,9 @@ class ConditionFunctionReplacement : public TempleFix {
 	void apply() override {
 		logger->info("Replacing Condition-related Functions");
 
+		replaceFunction<void()>(0x100E19A0, []() {
+			conds.hashmethods.ConditionHashtableInit(conds.mCondStructHashtable);
+			});
 		//dispTypeConditionAddPre
 		static int(__cdecl* orgTempAbilityLoss)(DispatcherCallbackArgs) = replaceFunction<int(__cdecl)(DispatcherCallbackArgs)>(0x100EA1F0, [](DispatcherCallbackArgs args) {
 			Stat statDamaged = (Stat)args.GetCondArg(0);
@@ -1794,16 +1797,16 @@ int __cdecl GlobalToHitBonus(DispatcherCallbackArgs args)
 		 && !d20Sys.d20Query(args.objHndCaller, DK_QUE_Polymorphed) )
 	{
 		int attackIdx = dispIo->attackPacket.dispKey - (ATTACK_CODE_NATURAL_ATTACK + 1);
-		int bonValue = 0; // temporarily used as an index value for obj_f_attack_bonus_idx field
+		int atkBonIdx = 0;
 		for (int i = 0,  j=0; i < 4; i++)
 		{
 			j += objects.getArrayFieldInt32(args.objHndCaller, obj_f_critter_attacks_idx, i); // number of attacks
 			if (attackIdx < j){
-				bonValue = i;
+				atkBonIdx = i;
 				break;
 			}
 		}
-		bonValue = objects.getArrayFieldInt32(args.objHndCaller, obj_f_attack_bonus_idx, bonValue);
+		int bonValue = objects.getArrayFieldInt32(args.objHndCaller, obj_f_attack_bonus_idx, atkBonIdx);
 		bonusSys.bonusAddToBonusList(&dispIo->bonlist, bonValue, 1, 118); // base attack
 	}
 
@@ -7410,3 +7413,25 @@ void CondStructNew::AddAoESpellRemover() {
 	AddHook(dispTypeD20Signal, DK_SIG_Spell_End, spCallbacks.AoeSpellRemove);
 }
 
+uint32_t CondHashSystem::ConditionHashtableInit(ToEEHashtable<CondStruct>* hashtable)
+{
+	const int VANILLA_COND_CAP = 1000;
+	return HashtableInit(hashtable, VANILLA_COND_CAP /*2023*/);
+}
+
+uint32_t CondHashSystem::CondStructAddToHashtable(CondStruct* condStruct, bool overriding)
+{
+
+	uint32_t key = StringHash(condStruct->condName);
+	CondStruct* condFound;
+	uint32_t result = HashtableSearch(condHashTable, key, &condFound);
+	if (result || overriding)
+	{
+		result = HashtableOverwriteItem(condHashTable, key, condStruct);
+	}
+	if (result == 3) { // over capacity
+		logger->error("Condition hashtable over capacity ({})! Trying to add {}", condHashTable->capacity, condStruct->condName);
+	}
+	return result;
+
+}

TemplePlus/condition.h

@@ -22,22 +22,9 @@ struct CondHashSystem : ToEEHashtableSystem < CondStruct >
 		temple::Dll::RegisterAddressPtr((void**)&condHashTable);
 	}
 
-	uint32_t ConditionHashtableInit(ToEEHashtable<CondStruct> * hashtable)
-	{
-		return HashtableInit(hashtable, 1000);
-	}
-
-	uint32_t CondStructAddToHashtable(CondStruct * condStruct, bool overriding = false)
-	{
-		uint32_t key = StringHash(condStruct->condName);
-		CondStruct * condFound;
-		uint32_t result = HashtableSearch(condHashTable, key, &condFound);
-		if (result || overriding)
-		{
-			result = HashtableOverwriteItem(condHashTable, key, condStruct);
-		}
-		return result;
-	}
+	uint32_t ConditionHashtableInit(ToEEHashtable<CondStruct>* hashtable);
+
+	uint32_t CondStructAddToHashtable(CondStruct* condStruct, bool overriding = false);
 
 	int GetCondStructHashkey(CondStruct* condStruct)
 	{

TemplePlus/config/config.cpp

@@ -129,6 +129,7 @@ static ConfigSetting configSettings[] = {
 	CONF_BOOL(antialiasing),
 	CONF_BOOL(softShadows),
 	CONF_BOOL(noSound),
+	//CONF_BOOL(showFps),
 	CONF_BOOL(featPrereqWarnings),
 	CONF_BOOL(spellAlreadyKnownWarnings),
 	CONF_BOOL(NPCsLevelLikePCs),

TemplePlus/d20.cpp

@@ -2984,7 +2984,7 @@ ActionErrorCode D20ActionCallbacks::ActionCheckTripAttack(D20Actn* d20a, TurnBas
 
 ActionErrorCode D20ActionCallbacks::ActionCostCastSpell(D20Actn * d20a, TurnBasedStatus * tbStat, ActionCostPacket * acp){
 	acp->hourglassCost = 0;
-	acp->chargeAfterPicker = 0;
+	acp->attackCost = 0;
 	acp->moveDistCost = 0.0f;
 	auto flags = d20a->d20Caf;
 	if ( (flags & D20CAF_FREE_ACTION) || !combatSys.isCombatActive()){
@@ -3048,7 +3048,7 @@ ActionErrorCode D20ActionCallbacks::ActionCostCastSpell(D20Actn * d20a, TurnBase
 }
 
 ActionErrorCode D20ActionCallbacks::ActionCostFullRound(D20Actn* d20a, TurnBasedStatus* tbStat, ActionCostPacket* acp){
-	acp->chargeAfterPicker = 0;
+	acp->attackCost = 0;
 	acp->moveDistCost = 0;
 	acp->hourglassCost = 4;
 	if ( (d20a->d20Caf & D20CAF_FREE_ACTION) || !combatSys.isCombatActive())
@@ -3876,7 +3876,7 @@ ActionErrorCode D20ActionCallbacks::TurnBasedStatusCheckPython(D20Actn* d20a, Tu
 }
 
 ActionErrorCode D20ActionCallbacks::ActionCostFullAttack(D20Actn * d20a, TurnBasedStatus * tbStat, ActionCostPacket * acp){
-	acp->chargeAfterPicker = 0;
+	acp->attackCost = 0;
 	acp->moveDistCost = 0;
 	acp->hourglassCost = 4;
 	//int flags = d20a->d20Caf;
@@ -3893,7 +3893,7 @@ ActionErrorCode D20ActionCallbacks::ActionCostFullAttack(D20Actn * d20a, TurnBas
 }
 
 ActionErrorCode D20ActionCallbacks::ActionCostPartialCharge(D20Actn * d20a, TurnBasedStatus * tbStat, ActionCostPacket * acp){
-	acp->chargeAfterPicker = 0;
+	acp->attackCost = 0;
 	acp->moveDistCost = 0;
 	acp->hourglassCost = 3;
 	if ((d20a->d20Caf & D20CAF_FREE_ACTION) || !combatSys.isCombatActive())
@@ -3907,6 +3907,10 @@ ActionErrorCode D20ActionCallbacks::ActionCostPython(D20Actn* d20a, TurnBasedSta
 	return (ActionErrorCode) d20Sys.GetPyActionCost(d20a, tbStat, acp);
 }
 
+/*
+0x100910F0
+Used in: Standard attack, Standard Ranged attack, Trip Attack, Touch Attack, Throw Weapon, Throw Grenade
+*/
 ActionErrorCode D20ActionCallbacks::ActionCostStandardAttack(D20Actn* d20a, TurnBasedStatus* tbStat, ActionCostPacket* acp){
 
 	if ( d20Sys.d20Query(d20a->d20APerformer, DK_QUE_HoldingCharge)
@@ -3917,12 +3921,12 @@ ActionErrorCode D20ActionCallbacks::ActionCostStandardAttack(D20Actn* d20a, Turn
 	}
 
 	acp->hourglassCost = 0;
-	acp->chargeAfterPicker = 0;
+	acp->attackCost = 0;
 	acp->moveDistCost = 0;
 
 	if (!(d20a->d20Caf & D20CAF_FREE_ACTION) && combatSys.isCombatActive())
 	{
-		acp->chargeAfterPicker = 1;
+		acp->attackCost = 1;
 
 		auto retainSurplusMoveDist = false;
 
@@ -3945,7 +3949,7 @@ ActionErrorCode D20ActionCallbacks::ActionCostStandardAttack(D20Actn* d20a, Turn
 ActionErrorCode D20ActionCallbacks::ActionCostMoveAction(D20Actn *d20, TurnBasedStatus *tbStat, ActionCostPacket *acp)
 {
 	acp->hourglassCost = 0;
-	acp->chargeAfterPicker = 0;
+	acp->attackCost = 0;
 	acp->moveDistCost = 0;
 	if (!(d20->d20Caf & D20CAF_FREE_ACTION) && combatSys.isCombatActive())
 	{
@@ -3961,7 +3965,7 @@ ActionErrorCode D20ActionCallbacks::ActionCostMoveAction(D20Actn *d20, TurnBased
 
 ActionErrorCode D20ActionCallbacks::ActionCostNull(D20Actn* d20a, TurnBasedStatus* tbStat, ActionCostPacket* acp){
 	acp->hourglassCost = 0;
-	acp->chargeAfterPicker = 0;
+	acp->attackCost = 0;
 	acp->moveDistCost = 0;
 	return AEC_OK;
 }
@@ -3973,21 +3977,21 @@ ActionErrorCode D20ActionCallbacks::ActionCostSwift(D20Actn* d20a, TurnBasedStat
 	}
 
 	acp->hourglassCost = 0;	
-	acp->chargeAfterPicker = 0;
+	acp->attackCost = 0;
 	acp->moveDistCost = 0;
 	tbStat->tbsFlags |= TBSF_SwiftActionPerformed;
 	return AEC_OK;
 }
 
 ActionErrorCode D20ActionCallbacks::ActionCostStandardAction(D20Actn*, TurnBasedStatus*, ActionCostPacket*acp){
 	acp->hourglassCost = 2;
-	acp->chargeAfterPicker = 0;
+	acp->attackCost = 0;
 	acp->moveDistCost = 0;
 	return AEC_OK;
 };
 
 ActionErrorCode D20ActionCallbacks::ActionCostWhirlwindAttack(D20Actn* d20a, TurnBasedStatus* tbStat, ActionCostPacket*acp) {
-	acp->chargeAfterPicker = 0;
+	acp->attackCost = 0;
 	acp->moveDistCost = 0;
 	acp->hourglassCost = 4;
 	if ( ( d20a->d20Caf & D20CAF_FREE_ACTION) || !combatSys.isCombatActive()){

TemplePlus/d20_class.cpp

@@ -136,12 +136,12 @@ bool D20ClassSystem::IsCompatibleWithAlignment(Stat classEnum, Alignment al){
 	return temple::GetRef<BOOL(__cdecl)(Stat, Alignment)>(0x10188170)(classEnum, al);
 }
 
-bool D20ClassSystem::IsNaturalCastingClass(Stat classEnum, objHndl handle){
+bool D20ClassSystem::IsNaturalCastingClass(Stat classEnum, objHndl handle) {
 	auto classSpec = classSpecs.find(classEnum);
 	if (classSpec == classSpecs.end())
 		return false;
-	
-	return classSpec->second.spellMemorizationType == SpellReadyingType::Innate;	
+
+	return classSpec->second.spellMemorizationType == SpellReadyingType::Innate || classSpec->second.spellMemorizationType == SpellReadyingType::AtWill;
 }
 
 bool D20ClassSystem::IsNaturalCastingClass(uint32_t classEnum){
@@ -157,6 +157,15 @@ bool D20ClassSystem::IsVancianCastingClass(Stat classEnum, objHndl handle )
 	return classSpec->second.spellMemorizationType == SpellReadyingType::Vancian;
 }
 
+bool D20ClassSystem::IsAtWillCastingClass(Stat classEnum)
+{
+	auto classSpec = classSpecs.find(classEnum);
+	if (classSpec == classSpecs.end())
+		return false;
+
+	return classSpec->second.spellMemorizationType == SpellReadyingType::AtWill;
+}
+
 bool D20ClassSystem::IsCastingClass(Stat classEnum, bool includeExtenders){
 	auto classSpec = classSpecs.find(classEnum);
 	if (classSpec == classSpecs.end())

TemplePlus/d20_class.h

@@ -101,6 +101,7 @@ class D20ClassSystem : temple::AddressTable
 	bool IsNaturalCastingClass(Stat classEnum, objHndl handle = objHndl::null);
 	bool IsNaturalCastingClass(uint32_t classEnum);
 	bool IsVancianCastingClass(Stat classEnum, objHndl handle = objHndl::null);
+	bool IsAtWillCastingClass(Stat classEnum);
 	bool IsCastingClass(Stat classEnum, bool includeExtenders = false);
 	bool HasSpellList(Stat classEnum); // does this class have its own spell list? (as opposed to extending another's like Mystic Theurge does), e.g. Blackguard, Assassin
 	bool IsLateCastingClass(Stat classEnum); // for classes like Ranger / Paladin that start casting on level 4

TemplePlus/d20_defs.h

@@ -109,10 +109,10 @@ enum class ActionCostType : int {
 struct ActionCostPacket
 {
 	int hourglassCost;
-	int chargeAfterPicker; // flag I think; is only set at stuff that requires using the picker it seems
+	int attackCost; // how many attacks does this consume when doing Full Attack? (0 if not relevant; haven't seen a value > 1)
 	float moveDistCost;
 
-	ActionCostPacket() { hourglassCost = 0; chargeAfterPicker = 0; moveDistCost = 0.0f; }
+	ActionCostPacket() { hourglassCost = 0; attackCost = 0; moveDistCost = 0.0f; }
 };
 //const auto TestSizeOfActionCostPacket = sizeof(ActionCostPacket); // should be 12 (0xC)