Reverting some hate stuff so things work again

zone/hate_list.cpp

@@ -48,10 +48,10 @@ HateList::~HateList()
 void HateList::IsEntityInFrenzyMode()
 {
 	auto iterator = list.begin();
-	while (iterator != list.end()) {
-		if ((*iterator)->entity_on_hatelist->GetHPRatio() >= 20) {
+	while (iterator != list.end())
+	{
+		if ((*iterator)->entity_on_hatelist->GetHPRatio() >= 20)
 			(*iterator)->is_entity_frenzy = false;
-		}
 		++iterator;
 	}
 }
@@ -59,49 +59,51 @@ void HateList::IsEntityInFrenzyMode()
 void HateList::WipeHateList()
 {
 	auto iterator = list.begin();
-	while (iterator != list.end()) {
+
+	while (iterator != list.end())
+	{
 		Mob* m = (*iterator)->entity_on_hatelist;
-		if (m) {
+		if (m)
+		{
 			parse->EventNPC(EVENT_HATE_LIST, owner->CastToNPC(), m, "0", 0);
-			if (m->IsClient()) {
+
+			if (m->IsClient())
 				m->CastToClient()->DecrementAggroCount();
 		}
-		}
 		delete (*iterator);
 		iterator = list.erase(iterator);
+
 	}
 }
 
 bool HateList::IsEntOnHateList(Mob *mob)
 {
-	if (Find(mob)) {
+	if (Find(mob))
 		return true;
-	}
 	return false;
 }
 
 struct_HateList *HateList::Find(Mob *ent)
 {
 	auto iterator = list.begin();
-	while (iterator != list.end()) {
-		if ((*iterator)->entity_on_hatelist == ent) {
+	while (iterator != list.end())
+	{
+		if ((*iterator)->entity_on_hatelist == ent)
 			return (*iterator);
-		}
 		++iterator;
 	}
 	return nullptr;
 }
 
-void HateList::SetHateAmountOnEnt(Mob* other, uint32 in_hate, uint32 in_damage)
+void HateList::SetHateAmountOnEnt(Mob* other, uint32 in_hate, uint32 in_dam)
 {
-	struct_HateList *hate_list = Find(other);
-	if (hate_list) {
-		if (in_damage > 0) {
-			hate_list->hatelist_damage = in_damage;
-		}
-		if (in_hate > 0) {
-			hate_list->stored_hate_amount = in_hate;
-		}
+	struct_HateList *p = Find(other);
+	if (p)
+	{
+		if (in_dam > 0)
+			p->hatelist_damage = in_dam;
+		if (in_hate > 0)
+			p->stored_hate_amount = in_hate;
 	}
 }
 
@@ -111,25 +113,36 @@ Mob* HateList::GetDamageTopOnHateList(Mob* hater)
 	Group* grp = nullptr;
 	Raid* r = nullptr;
 	uint32 dmg_amt = 0;
+
 	auto iterator = list.begin();
-	while (iterator != list.end()) {
+	while (iterator != list.end())
+	{
 		grp = nullptr;
 		r = nullptr;
+
 		if ((*iterator)->entity_on_hatelist && (*iterator)->entity_on_hatelist->IsClient()){
 			r = entity_list.GetRaidByClient((*iterator)->entity_on_hatelist->CastToClient());
 		}
+
 		grp = entity_list.GetGroupByMob((*iterator)->entity_on_hatelist);
+
 		if ((*iterator)->entity_on_hatelist && r){
-			if (r->GetTotalRaidDamage(hater) >= dmg_amt) {
+			if (r->GetTotalRaidDamage(hater) >= dmg_amt)
+			{
 				current = (*iterator)->entity_on_hatelist;
 				dmg_amt = r->GetTotalRaidDamage(hater);
 			}
-		} else if ((*iterator)->entity_on_hatelist != nullptr && grp != nullptr) {
-			if (grp->GetTotalGroupDamage(hater) >= dmg_amt) {
+		}
+		else if ((*iterator)->entity_on_hatelist != nullptr && grp != nullptr)
+		{
+			if (grp->GetTotalGroupDamage(hater) >= dmg_amt)
+			{
 				current = (*iterator)->entity_on_hatelist;
 				dmg_amt = grp->GetTotalGroupDamage(hater);
 			}
-		} else if ((*iterator)->entity_on_hatelist != nullptr && (uint32)(*iterator)->hatelist_damage >= dmg_amt) {
+		}
+		else if ((*iterator)->entity_on_hatelist != nullptr && (uint32)(*iterator)->hatelist_damage >= dmg_amt)
+		{
 			current = (*iterator)->entity_on_hatelist;
 			dmg_amt = (*iterator)->hatelist_damage;
 		}
@@ -138,285 +151,323 @@ Mob* HateList::GetDamageTopOnHateList(Mob* hater)
 	return current;
 }
 
-Mob* HateList::GetClosestEntOnHateList(Mob *hater)
-{
-	Mob* close_entity = nullptr;
-	float close_distance = 99999.9f;
-	float this_distance;
+Mob* HateList::GetClosestEntOnHateList(Mob *hater) {
+	Mob* close = nullptr;
+	float closedist = 99999.9f;
+	float thisdist;
+
 	auto iterator = list.begin();
 	while (iterator != list.end()) {
-		this_distance = (*iterator)->entity_on_hatelist->DistNoRootNoZ(*hater);
-		if ((*iterator)->entity_on_hatelist != nullptr && this_distance <= close_distance) {
-			close_distance = this_distance;
-			close_entity = (*iterator)->entity_on_hatelist;
+		thisdist = (*iterator)->entity_on_hatelist->DistNoRootNoZ(*hater);
+		if ((*iterator)->entity_on_hatelist != nullptr && thisdist <= closedist) {
+			closedist = thisdist;
+			close = (*iterator)->entity_on_hatelist;
 		}
 		++iterator;
 	}
-	if ((!close_entity && hater->IsNPC()) || (close_entity && close_entity->DivineAura())) {
-		close_entity = hater->CastToNPC()->GetHateTop();
-	}
-	return close_entity;
+
+	if ((!close && hater->IsNPC()) || (close && close->DivineAura()))
+		close = hater->CastToNPC()->GetHateTop();
+
+	return close;
 }
 
-// #include <iostream>
-void HateList::AddEntToHateList(Mob *in_entity, uint32 in_hate, int32 in_damage, bool in_is_entity_frenzy, bool iAddIfNotExist)
+
+// a few comments added, rearranged code for readability
+void HateList::AddEntToHateList(Mob *ent, int32 in_hate, int32 in_dam, bool bFrenzy, bool iAddIfNotExist)
 {
-	// std::cout << "AddEntToHateList name: " << owner->GetCleanName() << " in_hate " << in_hate << " in_damage " << in_damage << std::endl;
+	if (!ent)
+		return;
 
-	if (!in_entity) {
+	if (ent->IsCorpse())
 		return;
-	}
-	if (in_entity->IsCorpse()) {
-		return;
-	}
-	if (in_entity->IsClient() && in_entity->CastToClient()->IsDead()) {
-		return;
-	}
-	struct_HateList *hate_list = Find(in_entity);
-	if (hate_list) {
-		hate_list->hatelist_damage += (in_damage >= 0) ? in_damage : 0;
-		hate_list->stored_hate_amount += in_hate;
-		hate_list->is_entity_frenzy = in_is_entity_frenzy;
-	} else if (iAddIfNotExist) {
-		hate_list = new struct_HateList;
-		hate_list->entity_on_hatelist = in_entity;
-		hate_list->hatelist_damage = (in_damage >= 0) ? in_damage : 0;
-		hate_list->stored_hate_amount = in_hate;
-		hate_list->is_entity_frenzy = in_is_entity_frenzy;
-		list.push_back(hate_list);
-		parse->EventNPC(EVENT_HATE_LIST, owner->CastToNPC(), in_entity, "1", 0);
-		if (in_entity->IsClient()) {
-			if (owner->CastToNPC()->IsRaidTarget()) {
-				in_entity->CastToClient()->SetEngagedRaidTarget(true);
-			}
-			in_entity->CastToClient()->IncrementAggroCount();
-		}
-	}
-}
 
-bool HateList::RemoveEntFromHateList(Mob *in_entity)
+	if (ent->IsClient() && ent->CastToClient()->IsDead())
+		return;
+
+	struct_HateList *p = Find(ent);
+	if (p)
 	{
-	if (!in_entity) {
+		p->hatelist_damage += (in_dam >= 0) ? in_dam : 0;
+		p->stored_hate_amount += in_hate;
+		p->is_entity_frenzy = bFrenzy;
+	}
+	else if (iAddIfNotExist) {
+		p = new struct_HateList;
+		p->entity_on_hatelist = ent;
+		p->hatelist_damage = (in_dam >= 0) ? in_dam : 0;
+		p->stored_hate_amount = in_hate;
+		p->is_entity_frenzy = bFrenzy;
+		list.push_back(p);
+		parse->EventNPC(EVENT_HATE_LIST, owner->CastToNPC(), ent, "1", 0);
+
+		if (ent->IsClient()) {
+			if (owner->CastToNPC()->IsRaidTarget())
+				ent->CastToClient()->SetEngagedRaidTarget(true);
+			ent->CastToClient()->IncrementAggroCount();
+		}
+	}
+}
+
+bool HateList::RemoveEntFromHateList(Mob *ent)
+{
+	if (!ent)
 		return false;
-	}
+
 	bool found = false;
 	auto iterator = list.begin();
-	while (iterator != list.end()) {
-		if ((*iterator)->entity_on_hatelist == in_entity) {
-			if (in_entity) {
-				parse->EventNPC(EVENT_HATE_LIST, owner->CastToNPC(), in_entity, "0", 0);
-			}
+
+	while (iterator != list.end())
+	{
+		if ((*iterator)->entity_on_hatelist == ent)
+		{
+			if (ent)
+				parse->EventNPC(EVENT_HATE_LIST, owner->CastToNPC(), ent, "0", 0);
 			found = true;
-			if (in_entity && in_entity->IsClient()) {
-				in_entity->CastToClient()->DecrementAggroCount();
-			}
+
+
+			if (ent && ent->IsClient())
+				ent->CastToClient()->DecrementAggroCount();
+
 			delete (*iterator);
 			iterator = list.erase(iterator);
-		} else {
-			++iterator;
+
 		}
+		else
+			++iterator;
 	}
 	return found;
 }
 
-void HateList::DoFactionHits(int32 npc_faction_level_id)
-{
-	if (npc_faction_level_id <= 0) {
+void HateList::DoFactionHits(int32 nfl_id) {
+	if (nfl_id <= 0)
 		return;
-	}
 	auto iterator = list.begin();
-	while (iterator != list.end()) {
-		Client *client;
-		if ((*iterator)->entity_on_hatelist && (*iterator)->entity_on_hatelist->IsClient()) {
-			client = (*iterator)->entity_on_hatelist->CastToClient();
-		} else {
-			client = nullptr;
-		}
-		if (client) {
-			client->SetFactionLevel(client->CharacterID(), npc_faction_level_id, client->GetBaseClass(), client->GetBaseRace(), client->GetDeity());
-		}
+	while (iterator != list.end())
+	{
+		Client *p;
+
+		if ((*iterator)->entity_on_hatelist && (*iterator)->entity_on_hatelist->IsClient())
+			p = (*iterator)->entity_on_hatelist->CastToClient();
+		else
+			p = nullptr;
+
+		if (p)
+			p->SetFactionLevel(p->CharacterID(), nfl_id, p->GetBaseClass(), p->GetBaseRace(), p->GetDeity());
 		++iterator;
 	}
 }
 
-int HateList::GetSummonedPetCountOnHateList(Mob *hater)
-{
+int HateList::GetSummonedPetCountOnHateList(Mob *hater) {
+
+	//Function to get number of 'Summoned' pets on a targets hate list to allow calculations for certian spell effects.
+	//Unclear from description that pets are required to be 'summoned body type'. Will not require at this time.
 	int petcount = 0;
 	auto iterator = list.begin();
 	while (iterator != list.end()) {
-		if ((*iterator)->entity_on_hatelist != nullptr && (*iterator)->entity_on_hatelist->IsNPC() && 	((*iterator)->entity_on_hatelist->CastToNPC()->IsPet() || ((*iterator)->entity_on_hatelist->CastToNPC()->GetSwarmOwner() > 0))) {
+
+		if ((*iterator)->entity_on_hatelist != nullptr && (*iterator)->entity_on_hatelist->IsNPC() && ((*iterator)->entity_on_hatelist->CastToNPC()->IsPet() || ((*iterator)->entity_on_hatelist->CastToNPC()->GetSwarmOwner() > 0)))
+		{
 			++petcount;
 		}
+
 		++iterator;
 	}
+
 	return petcount;
 }
 
-Mob *HateList::GetEntWithMostHateInRange(Mob *entity_as_center)
+Mob *HateList::GetEntWithMostHateInRange(Mob *center)
 {
-	/* Hack fix for zone shutdown crashes on some servers */
-	if (!zone->IsLoaded()) {
+	// hack fix for zone shutdown crashes on some servers
+	if (!zone->IsLoaded())
 		return nullptr;
-	}
 
-	Mob* entity_with_most_hate = nullptr;
-	int32 hate_status = -1;
-	uint32 temp_hate_tracker = 0;
+	Mob* top = nullptr;
+	int32 hate = -1;
 
-	if (entity_as_center == nullptr) {
+	if (center == nullptr)
 		return nullptr;
-	}
+
 	if (RuleB(Aggro, SmartAggroList)){
-		Mob* top_client_type_in_range = nullptr;
-		int32 hate_client_type_in_range = -1;
+		Mob* topClientTypeInRange = nullptr;
+		int32 hateClientTypeInRange = -1;
 		int skipped_count = 0;
+
 		auto iterator = list.begin();
-		while (iterator != list.end()) {
-			struct_HateList *hate_list = (*iterator);
-			int16 aggro_mod = 0;
-			if (!hate_list) {
+		while (iterator != list.end())
+		{
+			struct_HateList *cur = (*iterator);
+			int16 aggroMod = 0;
+
+			if (!cur){
 				++iterator;
 				continue;
 			}
-			if (!hate_list->entity_on_hatelist) {
+
+			if (!cur->entity_on_hatelist){
 				++iterator;
 				continue;
 			}
-			if (entity_as_center->IsNPC() && entity_as_center->CastToNPC()->IsUnderwaterOnly() && zone->HasWaterMap()) {
-				if (!zone->watermap->InLiquid(hate_list->entity_on_hatelist->GetX(), hate_list->entity_on_hatelist->GetY(), hate_list->entity_on_hatelist->GetZ())) {
+
+			if (center->IsNPC() && center->CastToNPC()->IsUnderwaterOnly() && zone->HasWaterMap()) {
+				if (!zone->watermap->InLiquid(cur->entity_on_hatelist->GetX(), cur->entity_on_hatelist->GetY(), cur->entity_on_hatelist->GetZ())) {
 					skipped_count++;
 					++iterator;
 					continue;
 				}
 			}
-			if (hate_list->entity_on_hatelist->Sanctuary()) {
-				if (hate_status == -1) {
-					entity_with_most_hate = hate_list->entity_on_hatelist;
-					hate_status = 1;
+
+			if (cur->entity_on_hatelist->Sanctuary()) {
+				if (hate == -1)
+				{
+					top = cur->entity_on_hatelist;
+					hate = 1;
 				}
 				++iterator;
 				continue;
 			}
-			if (hate_list->entity_on_hatelist->DivineAura() || hate_list->entity_on_hatelist->IsMezzed() || hate_list->entity_on_hatelist->IsFeared()) {
-				if (hate_status == -1) {
-					entity_with_most_hate = hate_list->entity_on_hatelist;
-					hate_status = 0;
+
+			if (cur->entity_on_hatelist->DivineAura() || cur->entity_on_hatelist->IsMezzed() || cur->entity_on_hatelist->IsFeared()){
+				if (hate == -1)
+				{
+					top = cur->entity_on_hatelist;
+					hate = 0;
 				}
 				++iterator;
 				continue;
 			}
-			uint32 current_stored_hate = hate_list->stored_hate_amount;
-			if (hate_list->entity_on_hatelist->IsClient()) {
-				if (hate_list->entity_on_hatelist->CastToClient()->IsSitting()) {
-					aggro_mod += RuleI(Aggro, SittingAggroMod);
+
+			int32 currentHate = cur->stored_hate_amount;
+
+			if (cur->entity_on_hatelist->IsClient()){
+
+				if (cur->entity_on_hatelist->CastToClient()->IsSitting()){
+					aggroMod += RuleI(Aggro, SittingAggroMod);
 				}
-				if (entity_as_center) {
-					if (entity_as_center->GetTarget() == hate_list->entity_on_hatelist) {
-						aggro_mod += RuleI(Aggro, CurrentTargetAggroMod);
-					}
-					if (RuleI(Aggro, MeleeRangeAggroMod) != 0) {
-						if (entity_as_center->CombatRange(hate_list->entity_on_hatelist)) {
-							aggro_mod += RuleI(Aggro, MeleeRangeAggroMod);
-							if (current_stored_hate > hate_client_type_in_range || hate_list->is_entity_frenzy) {
-								hate_client_type_in_range = current_stored_hate;
-								top_client_type_in_range = hate_list->entity_on_hatelist;
+
+				if (center){
+					if (center->GetTarget() == cur->entity_on_hatelist)
+						aggroMod += RuleI(Aggro, CurrentTargetAggroMod);
+					if (RuleI(Aggro, MeleeRangeAggroMod) != 0)
+					{
+						if (center->CombatRange(cur->entity_on_hatelist)){
+							aggroMod += RuleI(Aggro, MeleeRangeAggroMod);
+
+							if (currentHate > hateClientTypeInRange || cur->is_entity_frenzy){
+								hateClientTypeInRange = currentHate;
+								topClientTypeInRange = cur->entity_on_hatelist;
 							}
 						}
 					}
 				}
+
 			}
 			else{
-				if (entity_as_center) {
-					if (entity_as_center->GetTarget() == hate_list->entity_on_hatelist) {
-						aggro_mod += RuleI(Aggro, CurrentTargetAggroMod);
-					}
-					if (RuleI(Aggro, MeleeRangeAggroMod) != 0) {
-						if (entity_as_center->CombatRange(hate_list->entity_on_hatelist)) {
-							aggro_mod += RuleI(Aggro, MeleeRangeAggroMod);
+				if (center){
+					if (center->GetTarget() == cur->entity_on_hatelist)
+						aggroMod += RuleI(Aggro, CurrentTargetAggroMod);
+					if (RuleI(Aggro, MeleeRangeAggroMod) != 0)
+					{
+						if (center->CombatRange(cur->entity_on_hatelist)){
+							aggroMod += RuleI(Aggro, MeleeRangeAggroMod);
 						}
 					}
 				}
 			}
-			if (hate_list->entity_on_hatelist->GetMaxHP() != 0 && ((hate_list->entity_on_hatelist->GetHP() * 100 / hate_list->entity_on_hatelist->GetMaxHP()) < 20)) {
-				aggro_mod += RuleI(Aggro, CriticallyWoundedAggroMod);
+
+			if (cur->entity_on_hatelist->GetMaxHP() != 0 && ((cur->entity_on_hatelist->GetHP() * 100 / cur->entity_on_hatelist->GetMaxHP()) < 20)){
+				aggroMod += RuleI(Aggro, CriticallyWoundedAggroMod);
 			}
-			if (aggro_mod) {
-				current_stored_hate += (current_stored_hate * aggro_mod / 100);
+
+			if (aggroMod){
+				currentHate += (currentHate * aggroMod / 100);
 			}
-			if (current_stored_hate > temp_hate_tracker || hate_list->is_entity_frenzy) {
-				temp_hate_tracker = current_stored_hate;
-				entity_with_most_hate = hate_list->entity_on_hatelist;
+
+			if (currentHate > hate || cur->is_entity_frenzy){
+				hate = currentHate;
+				top = cur->entity_on_hatelist;
 			}
+
 			++iterator;
 		}
-		if (top_client_type_in_range != nullptr && entity_with_most_hate != nullptr) {
-			bool is_top_client_type = entity_with_most_hate->IsClient();
+
+		if (topClientTypeInRange != nullptr && top != nullptr) {
+			bool isTopClientType = top->IsClient();
 #ifdef BOTS
-			if (!is_top_client_type) {
-				if (entity_with_most_hate->IsBot()) {
-					is_top_client_type = true;
-					top_client_type_in_range = entity_with_most_hate;
+			if (!isTopClientType) {
+				if (top->IsBot()) {
+					isTopClientType = true;
+					topClientTypeInRange = top;
 				}
 			}
 #endif //BOTS
-			if (!is_top_client_type) {
-				if (entity_with_most_hate->IsMerc()) {
-					is_top_client_type = true;
-					top_client_type_in_range = entity_with_most_hate;
+
+			if (!isTopClientType) {
+				if (top->IsMerc()) {
+					isTopClientType = true;
+					topClientTypeInRange = top;
 				}
 			}
-			if (!is_top_client_type) {
-				if (entity_with_most_hate->GetSpecialAbility(ALLOW_TO_TANK)) {
-					is_top_client_type = true;
-					top_client_type_in_range = entity_with_most_hate;
+
+			if (!isTopClientType) {
+				if (top->GetSpecialAbility(ALLOW_TO_TANK)){
+					isTopClientType = true;
+					topClientTypeInRange = top;
 				}
 			}
-			if (!is_top_client_type) {
-				return top_client_type_in_range ? top_client_type_in_range : nullptr;
+
+			if (!isTopClientType)
+				return topClientTypeInRange ? topClientTypeInRange : nullptr;
+
+			return top ? top : nullptr;
 		}
-			return entity_with_most_hate ? entity_with_most_hate : nullptr;
-		} else {
-			if (entity_with_most_hate == nullptr && skipped_count > 0) {
-				return entity_as_center->GetTarget() ? entity_as_center->GetTarget() : nullptr;
+		else {
+			if (top == nullptr && skipped_count > 0) {
+				return center->GetTarget() ? center->GetTarget() : nullptr;
 			}
-			return entity_with_most_hate ? entity_with_most_hate : nullptr;
+			return top ? top : nullptr;
 		}
 	}
-	/* Process not so smart aggro list */
 	else{
 		auto iterator = list.begin();
 		int skipped_count = 0;
-		while (iterator != list.end()) {
-			struct_HateList *hate_list = (*iterator);
-			if (entity_as_center->IsNPC() && entity_as_center->CastToNPC()->IsUnderwaterOnly() && zone->HasWaterMap()) {
-				if (!zone->watermap->InLiquid(hate_list->entity_on_hatelist->GetX(), hate_list->entity_on_hatelist->GetY(), hate_list->entity_on_hatelist->GetZ())) {
+		while (iterator != list.end())
+		{
+			struct_HateList *cur = (*iterator);
+			if (center->IsNPC() && center->CastToNPC()->IsUnderwaterOnly() && zone->HasWaterMap()) {
+				if (!zone->watermap->InLiquid(cur->entity_on_hatelist->GetX(), cur->entity_on_hatelist->GetY(), cur->entity_on_hatelist->GetZ())) {
 					skipped_count++;
 					++iterator;
 					continue;
 				}
 			}
-			if (hate_list->entity_on_hatelist != nullptr && ((hate_list->stored_hate_amount > temp_hate_tracker) || hate_list->is_entity_frenzy )) {
-				entity_with_most_hate = hate_list->entity_on_hatelist;
-				temp_hate_tracker = hate_list->stored_hate_amount;
+
+			if (cur->entity_on_hatelist != nullptr && ((cur->stored_hate_amount > hate) || cur->is_entity_frenzy))
+			{
+				top = cur->entity_on_hatelist;
+				hate = cur->stored_hate_amount;
 			}
 			++iterator;
 		}
-		if (entity_with_most_hate == nullptr && skipped_count > 0) {
-			return entity_as_center->GetTarget() ? entity_as_center->GetTarget() : nullptr;
+		if (top == nullptr && skipped_count > 0) {
+			return center->GetTarget() ? center->GetTarget() : nullptr;
 		}
-		return entity_with_most_hate ? entity_with_most_hate : nullptr;
+		return top ? top : nullptr;
 	}
 	return nullptr;
 }
 
-Mob *HateList::GetEntWithMostHateOnList()
-{
+Mob *HateList::GetEntWithMostHateInRange(){
 	Mob* top = nullptr;
-	uint32 hate = 0;
+	int32 hate = -1;
+
 	auto iterator = list.begin();
-	while (iterator != list.end()) {
+	while (iterator != list.end())
+	{
 		struct_HateList *cur = (*iterator);
-		if (cur->entity_on_hatelist != nullptr && (cur->stored_hate_amount > hate)) {
+		if (cur->entity_on_hatelist != nullptr && (cur->stored_hate_amount > hate))
+		{
 			top = cur->entity_on_hatelist;
 			hate = cur->stored_hate_amount;
 		}
@@ -429,94 +480,107 @@ Mob *HateList::GetEntWithMostHateOnList()
 Mob *HateList::GetRandomEntOnHateList()
 {
 	int count = list.size();
-	if (count == 0) { //If we don't have any entries it'll crash getting a random 0, -1 position.
+	if (count == 0) //If we don't have any entries it'll crash getting a random 0, -1 position.
 		return NULL;
-	}
-	if (count == 1) { //No need to do all that extra work if we only have one hate entry
-		if (*list.begin()) { // Just in case tHateEntry is invalidated somehow...
+
+	if (count == 1) //No need to do all that extra work if we only have one hate entry
+	{
+		if (*list.begin()) // Just in case tHateEntry is invalidated somehow...
 			return (*list.begin())->entity_on_hatelist;
-		}
+
 		return NULL;
 	}
+
 	auto iterator = list.begin();
 	int random = zone->random.Int(0, count - 1);
-	for (int i = 0; i < random; i++) {
+	for (int i = 0; i < random; i++)
 		++iterator;
-	}
+
 	return (*iterator)->entity_on_hatelist;
 }
 
-uint32 HateList::GetEntHateAmount(Mob *ent, bool damage /*= false*/)
+int32 HateList::GetEntHateAmount(Mob *ent, bool damage)
 {
-	struct_HateList *hate_list;
-	hate_list = Find(ent);
-	if ( hate_list && damage) {
-		return hate_list->hatelist_damage;
-	} else if (hate_list) {
-		return hate_list->stored_hate_amount;
-	} else {
+	struct_HateList *p;
+
+	p = Find(ent);
+
+	if (p && damage)
+		return p->hatelist_damage;
+	else if (p)
+		return p->stored_hate_amount;
+	else
 		return 0;
 }
-}
 
-bool HateList::IsHateListEmpty()
-{
+//looking for any mob with hate > -1
+bool HateList::IsHateListEmpty() {
 	return(list.size() == 0);
 }
 
+// Prints hate list to a client
 void HateList::PrintHateListToClient(Client *c)
 {
 	auto iterator = list.begin();
-	while (iterator != list.end()) {
-		struct_HateList *hate_list = (*iterator);
-
+	while (iterator != list.end())
+	{
+		struct_HateList *e = (*iterator);
 		c->Message(0, "- name: %s, damage: %d, hate: %d",
-		           (hate_list->entity_on_hatelist && hate_list->entity_on_hatelist->GetName()) ? hate_list->entity_on_hatelist->GetName() : "(null)",
-		           hate_list->hatelist_damage, hate_list->stored_hate_amount);
+			(e->entity_on_hatelist && e->entity_on_hatelist->GetName()) ? e->entity_on_hatelist->GetName() : "(null)",
+			e->hatelist_damage, e->stored_hate_amount);
+
 		++iterator;
 	}
 }
 
-int HateList::AreaRampage(Mob *in_caster, Mob *in_target, int in_count, ExtraAttackOptions *options)
+int HateList::AreaRampage(Mob *caster, Mob *target, int count, ExtraAttackOptions *opts)
 {
-	if (!in_target || !in_caster) {
+	if (!target || !caster)
 		return 0;
-	}
+
 	int ret = 0;
 	std::list<uint32> id_list;
 	auto iterator = list.begin();
-	while (iterator != list.end()) {
+	while (iterator != list.end())
+	{
 		struct_HateList *h = (*iterator);
 		++iterator;
-		if (h && h->entity_on_hatelist && h->entity_on_hatelist != in_caster) {
-			if (in_caster->CombatRange(h->entity_on_hatelist)) {
+		if (h && h->entity_on_hatelist && h->entity_on_hatelist != caster)
+		{
+			if (caster->CombatRange(h->entity_on_hatelist))
+			{
 				id_list.push_back(h->entity_on_hatelist->GetID());
 				++ret;
 			}
 		}
 	}
+
 	std::list<uint32>::iterator iter = id_list.begin();
-	while (iter != id_list.end()) {
+	while (iter != id_list.end())
+	{
 		Mob *cur = entity_list.GetMobID((*iter));
-		if (cur) {
-			for (int i = 0; i < in_count; ++i) {
-				in_caster->Attack(cur, MainPrimary, false, false, false, options);
+		if (cur)
+		{
+			for (int i = 0; i < count; ++i) {
+				caster->Attack(cur, MainPrimary, false, false, false, opts);
 			}
 		}
 		iter++;
 	}
+
 	return ret;
 }
 
 void HateList::SpellCast(Mob *caster, uint32 spell_id, float range, Mob* ae_center)
 {
-	if (!caster) {
+	if (!caster)
 		return;
-	}
+
 	Mob* center = caster;
-	if (ae_center) {
+
+	if (ae_center)
 		center = ae_center;
-	}
+
 	//this is slower than just iterating through the list but avoids
 	//crashes when people kick the bucket in the middle of this call
 	//that invalidates our iterator but there's no way to know sadly
@@ -526,27 +590,34 @@ void HateList::SpellCast(Mob *caster, uint32 spell_id, float range, Mob* ae_cent
 	float min_range2 = spells[spell_id].min_range * spells[spell_id].min_range;
 	float dist_targ = 0;
 	auto iterator = list.begin();
-	while (iterator != list.end()) {
+	while (iterator != list.end())
+	{
 		struct_HateList *h = (*iterator);
-		if (range > 0) {
+		if (range > 0)
+		{
 			dist_targ = center->DistNoRoot(*h->entity_on_hatelist);
-			if (dist_targ <= range && dist_targ >= min_range2) {
+			if (dist_targ <= range && dist_targ >= min_range2)
+			{
 				id_list.push_back(h->entity_on_hatelist->GetID());
 				h->entity_on_hatelist->CalcSpellPowerDistanceMod(spell_id, dist_targ);
 			}
-		} else {
+		}
+		else
+		{
 			id_list.push_back(h->entity_on_hatelist->GetID());
 			h->entity_on_hatelist->CalcSpellPowerDistanceMod(spell_id, 0, caster);
 		}
 		++iterator;
 	}
+
 	std::list<uint32>::iterator iter = id_list.begin();
-	while (iter != id_list.end()) {
+	while (iter != id_list.end())
+	{
 		Mob *cur = entity_list.GetMobID((*iter));
-		if (cur) {
+		if (cur)
+		{
 			caster->SpellOnTarget(spell_id, cur);
 		}
 		iter++;
 	}
 }
-

zone/hate_list.h

@@ -1,5 +1,5 @@
 /*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2015 EQEMu Development Team (http://eqemu.org)
+Copyright (C) 2001-2002 EQEMu Development Team (http://eqemu.org)
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -25,10 +25,10 @@ class Mob;
 class Raid;
 struct ExtraAttackOptions;
 
-struct struct_HateList {
+struct struct_HateList
+{
 	Mob *entity_on_hatelist;
-	uint32 hatelist_damage; 
-	uint32 stored_hate_amount;
+	int32 hatelist_damage, stored_hate_amount;
 	bool is_entity_frenzy;
 };
 
@@ -38,41 +38,47 @@ class HateList
 	HateList();
 	~HateList();
 
-		Mob *GetClosestEntOnHateList(Mob *hater);
-		Mob *GetDamageTopOnHateList(Mob *hater);
-		Mob *GetRandomEntOnHateList();
-		Mob *GetEntWithMostHateInRange(Mob *center);
-		Mob* GetEntWithMostHateOnList();
-
-		bool IsEntOnHateList(Mob *mob);
-		bool IsHateListEmpty();
+	// adds a mob to the hatelist
+	void AddEntToHateList(Mob *ent, int32 in_hate = 0, int32 in_dam = 0, bool bFrenzy = false, bool iAddIfNotExist = true);
+	// sets existing hate
+	void SetHateAmountOnEnt(Mob *other, uint32 in_hate, uint32 in_dam);
+	// removes mobs from hatelist
 	bool RemoveEntFromHateList(Mob *ent);
-
-		int AreaRampage(Mob *caster, Mob *target, int count, ExtraAttackOptions *opts);
+	// Remove all
+	void WipeHateList();
+	// ???
+	void DoFactionHits(int32 nfl_id);
+	// Gets Hate amount for mob
+	int32 GetEntHateAmount(Mob *ent, bool damage = false);
+	// gets top hated mob
+	Mob *GetEntWithMostHateInRange(Mob *center);
+	// gets any on the list
+	Mob *GetRandomEntOnHateList();
+	// get closest mob or nullptr if list empty
+	Mob *GetClosestEntOnHateList(Mob *hater);
+	// gets top mob or nullptr if hate list empty
+	Mob *GetDamageTopOnHateList(Mob *hater);
+	// used to check if mob is on hatelist
+	bool IsEntOnHateList(Mob *);
+	// used to remove or add frenzy hate
+	void IsEntityInFrenzyMode();
+	//Gets the target with the most hate regardless of things like frenzy etc.
+	Mob* GetEntWithMostHateInRange();
+	// Count 'Summoned' pets on hatelist
 	int GetSummonedPetCountOnHateList(Mob *hater);
 
-		uint32 GetEntHateAmount(Mob *in_entity, bool damage = false);
+	int AreaRampage(Mob *caster, Mob *target, int count, ExtraAttackOptions *opts);
 
-		void AddEntToHateList(Mob *in_entity, uint32 in_hate = 0, int32 in_damage = 0, bool in_is_frenzied = false, bool add_to_hate_list_if_not_exist = true);
-		void DoFactionHits(int32 npc_faction_level_id);
-		void IsEntityInFrenzyMode();
-		void PrintHateListToClient(Client *c);
-		void SetHateAmountOnEnt(Mob *other, uint32 in_hate, uint32 in_dam);
 	void SpellCast(Mob *caster, uint32 spell_id, float range, Mob *ae_center = nullptr);
-		void WipeHateList(); 
 
+	bool IsHateListEmpty();
+	void PrintHateListToClient(Client *c);
 
-		/* For accessing the hate list via perl; don't use for anything else */
-		std::list<struct_HateList*>& GetHateList()
-		{
-			return list;
-		}
+	//For accessing the hate list via perl; don't use for anything else
+	std::list<struct_HateList*>& GetHateList() { return list; }
 
-		/* Setting owner*/
-		void SetOwner(Mob *new_owner)
-		{
-			owner = new_owner;
-		}
+	//setting owner
+	void SetOwner(Mob *newOwner) { owner = newOwner; }
 
 protected:
 	struct_HateList* Find(Mob *ent);

zone/mob.h

@@ -463,7 +463,7 @@ public:
 	Mob* GetHateTop() { return hate_list.GetEntWithMostHateInRange(this);}
 	Mob* GetHateDamageTop(Mob* other) { return hate_list.GetDamageTopOnHateList(other);}
 	Mob* GetHateRandom() { return hate_list.GetRandomEntOnHateList();}
-	Mob* GetHateMost() { return hate_list.GetEntWithMostHateOnList();}
+	Mob* GetHateMost() { return hate_list.GetEntWithMostHateInRange();}
 	bool IsEngaged() { return(!hate_list.IsHateListEmpty()); }
 	bool HateSummon();
 	void FaceTarget(Mob* MobToFace = 0);