[Feature] Item tiers and new skills (Onslaught, Ruse and Momentum) from 12.80

schema.sql

@@ -131,6 +131,7 @@ CREATE TABLE IF NOT EXISTS `players` (
     `bonus_rerolls` bigint(21) NOT NULL DEFAULT '0',
     `prey_wildcard` bigint(21) NOT NULL DEFAULT '0',
     `task_points` bigint(21) NOT NULL DEFAULT '0',
+    `forge_dusts` bigint(21) NOT NULL DEFAULT '0',
     `quickloot_fallback` tinyint(1) DEFAULT '0',
     `lookmountbody` tinyint(3) unsigned NOT NULL DEFAULT '0',
     `lookmountfeet` tinyint(3) unsigned NOT NULL DEFAULT '0',

src/creatures/combat/combat.cpp

@@ -838,14 +838,16 @@ void Combat::CombatFunc(Creature* caster, const Position& pos, const AreaCombat*
 	}
 	//
 	CombatDamage tmpDamage;
-    if(data) {
-        tmpDamage.origin = data->origin;
-        tmpDamage.primary.type = data->primary.type;
-        tmpDamage.primary.value = data->primary.value;
-        tmpDamage.secondary.type = data->secondary.type;
-        tmpDamage.secondary.value = data->secondary.value;
-        tmpDamage.critical = data->critical;
-    }
+	if (data) {
+		tmpDamage.origin = data->origin;
+		tmpDamage.primary.type = data->primary.type;
+		tmpDamage.primary.value = data->primary.value;
+		tmpDamage.secondary.type = data->secondary.type;
+		tmpDamage.secondary.value = data->secondary.value;
+		tmpDamage.critical = data->critical;
+		tmpDamage.fatal = data->fatal;
+	}
+
 	tmpDamage.affected = affected;
 	for (Tile* tile : tileList) {
 		if (canDoCombat(caster, tile, params.aggressive) != RETURNVALUE_NOERROR) {
@@ -919,6 +921,16 @@ void Combat::doCombatHealth(Creature* caster, Creature* target, CombatDamage& da
 			damage.primary.value += (damage.primary.value * caster->getPlayer()->getSkillLevel(SKILL_CRITICAL_HIT_DAMAGE ))/100;
 			damage.secondary.value += (damage.secondary.value * caster->getPlayer()->getSkillLevel(SKILL_CRITICAL_HIT_DAMAGE ))/100;
 		}
+
+		// fatal hit (onslaught)
+		if (caster->getPlayer()->getInventoryItem(CONST_SLOT_LEFT) != nullptr) {
+			double_t fatalChance = caster->getPlayer()->getInventoryItem(CONST_SLOT_LEFT)->getFatalChance();
+			if (damage.primary.type != COMBAT_HEALING && fatalChance > 0 && uniform_random(1, 100) <= fatalChance) {
+				damage.fatal = true;
+				damage.primary.value += static_cast<int32_t>(std::round(damage.primary.value * 1.6));
+				damage.secondary.value += static_cast<int32_t>(std::round(damage.secondary.value * 1.6));
+			}
+		}
 	}
 	if (canCombat) {
 		if (target && caster && params.distanceEffect != CONST_ANI_NONE) {
@@ -936,12 +948,22 @@ void Combat::doCombatHealth(Creature* caster, const Position& position, const Ar
 {
 		if(caster && caster->getPlayer()){
 			// Critical damage
-			uint16_t chance = caster->getPlayer()->getSkillLevel(SKILL_CRITICAL_HIT_CHANCE);
-			if (damage.primary.type != COMBAT_HEALING && chance != 0 && uniform_random(1, 100) <= chance) {
+			if (uint16_t chance = caster->getPlayer()->getSkillLevel(SKILL_CRITICAL_HIT_CHANCE);
+			damage.primary.type != COMBAT_HEALING && chance != 0 && uniform_random(1, 100) <= chance) {
 				damage.critical = true;
 				damage.primary.value += (damage.primary.value * caster->getPlayer()->getSkillLevel(SKILL_CRITICAL_HIT_DAMAGE ))/100;
 				damage.secondary.value += (damage.secondary.value * caster->getPlayer()->getSkillLevel(SKILL_CRITICAL_HIT_DAMAGE ))/100;
 			}
+
+			// fatal hit (onslaught)
+			if (caster->getPlayer()->getInventoryItem(CONST_SLOT_LEFT) != nullptr) {
+				double_t fatalChance = caster->getPlayer()->getInventoryItem(CONST_SLOT_LEFT)->getFatalChance();
+				if (damage.primary.type != COMBAT_HEALING && fatalChance > 0 && uniform_random(1, 100) <= fatalChance) {
+					damage.fatal = true;
+					damage.primary.value += static_cast<int32_t>(std::round(damage.primary.value * 1.6));
+					damage.secondary.value += static_cast<int32_t>(std::round(damage.secondary.value * 1.6));
+				}
+			}
 		}
 	CombatFunc(caster, position, area, params, CombatHealthFunc, &damage);
 }

src/creatures/creatures_definitions.hpp

@@ -411,7 +411,8 @@ enum BlockType_t : uint8_t {
 	BLOCK_NONE,
 	BLOCK_DEFENSE,
 	BLOCK_ARMOR,
-	BLOCK_IMMUNITY
+	BLOCK_IMMUNITY,
+	BLOCK_DODGE
 };
 
 enum BestiaryType_t : uint8_t {
@@ -756,6 +757,7 @@ struct CombatDamage {
 	int affected;
 	bool extension;
 	std::string exString;
+	bool fatal;
 
 	CombatDamage() {
 		origin = ORIGIN_NONE;
@@ -765,6 +767,7 @@ struct CombatDamage {
 		affected = 1;
 		extension = false;
 		exString = "";
+		fatal = false;
 	}
 };
 

src/creatures/players/player.cpp

@@ -1984,6 +1984,31 @@ void Player::onThink(uint32_t interval)
 		addMessageBuffer();
 	}
 
+	// momentum(cooldown resets), checks and eligibility (chance to trigger every 2 seconds)
+	if (getInventoryItem(CONST_SLOT_HEAD) != nullptr) {
+		double_t chance = getInventoryItem(CONST_SLOT_HEAD)->getMomentumChance();
+		if (getZone() != ZONE_PROTECTION && hasCondition(CONDITION_INFIGHT) && ((OTSYS_TIME()/1000) % 2) == 0 && chance > 0 && uniform_random(1, 100) <= chance) {
+			bool triggered = false;
+			auto it = conditions.begin(); auto end = conditions.end();
+			while (it != end) {
+				ConditionType_t type = (*it)->getType();
+				uint32_t spellId = (*it)->getSubId();
+				int32_t ticks = (*it)->getTicks();
+				int32_t newTicks = (ticks <= 2000) ? 0 : ticks - 2000;
+				triggered = true;
+				if (type == CONDITION_SPELLCOOLDOWN || (type == CONDITION_SPELLGROUPCOOLDOWN && spellId > SPELLGROUP_SUPPORT)) {
+					(*it)->setTicks(newTicks);
+					type == CONDITION_SPELLGROUPCOOLDOWN ? sendSpellGroupCooldown(static_cast<SpellGroup_t>(spellId), newTicks) : sendSpellCooldown(static_cast<uint8_t>(spellId), newTicks);
+				}
+				++it;
+			}
+			if (triggered) {
+				g_game().addMagicEffect(getPosition(), CONST_ME_HOURGLASS);
+				sendTextMessage(MESSAGE_ATTENTION, "Momentum was triggered.");
+			}
+		}
+	}
+
 	if (!getTile()->hasFlag(TILESTATE_NOLOGOUT) && !isAccessPlayer() && !isExerciseTraining()) {
 		idleTime += interval;
 		const int32_t kickAfterMinutes = g_configManager().getNumber(KICK_AFTER_MINUTES);

src/creatures/players/player.h

@@ -1504,7 +1504,7 @@ class Player final : public Creature, public Cylinder
 
 		void sendOpenStash(bool isNpc = false) {
 			if (client && ((getLastDepotId() != -1) || isNpc)) {
-        		client->sendOpenStash();
+				client->sendOpenStash();
 			}
 		}
 		bool isStashExhausted() const;
@@ -2033,6 +2033,36 @@ class Player final : public Creature, public Cylinder
 			return nullptr;
 		}
 
+		void sendOpenForge() const {
+			if (client) {
+				client->sendOpenForge();
+			}
+		}
+
+		void setForgeSlivers(uint64_t amount) {
+			forgeSlivers = amount;
+		}
+
+		void setForgeCores(uint64_t amount) {
+			forgeCores = amount;
+		}
+
+		void setForgeDusts(uint64_t amount) {
+			forgeDusts = amount;
+			if (client) {
+				client->sendResourcesBalance(getMoney(), getBankBalance(), getPreyCards(), getTaskHuntingPoints(), getForgeDusts());
+			}
+		}
+
+		uint64_t getForgeDusts() const {
+			return forgeDusts;
+		}
+		uint64_t getForgeSlivers() const {
+			return forgeSlivers;
+		}
+		uint64_t getForgeCores() const {
+			return forgeCores;
+		}
 
 	private:
 		std::forward_list<Condition*> getMuteConditions() const;
@@ -2155,6 +2185,9 @@ class Player final : public Creature, public Cylinder
 		uint64_t lastQuestlogUpdate = 0;
 		uint64_t preyCards = 0;
 		uint64_t taskHuntingPoints = 0;
+		uint64_t forgeDusts = 0;
+		uint64_t forgeSlivers = 0;
+		uint64_t forgeCores = 0;
 		int64_t lastFailedFollow = 0;
 		int64_t skullTicks = 0;
 		int64_t lastWalkthroughAttempt = 0;

src/game/game.cpp

@@ -5540,6 +5540,8 @@ bool Game::combatBlockHit(CombatDamage& damage, Creature* attacker, Creature* ta
 			addMagicEffect(targetPos, CONST_ME_POFF);
 		} else if (blockType == BLOCK_ARMOR) {
 			addMagicEffect(targetPos, CONST_ME_BLOCKHIT);
+		} else if (blockType == BLOCK_DODGE) {
+			addMagicEffect(targetPos, CONST_ME_DODGE);
 		} else if (blockType == BLOCK_IMMUNITY) {
 			uint8_t hitEffect = 0;
 			switch (combatType) {
@@ -5571,6 +5573,18 @@ bool Game::combatBlockHit(CombatDamage& damage, Creature* attacker, Creature* ta
 		}
 	};
 
+	// dodge (ruse)
+	if (const Player* targetPlayer = target->getPlayer()) {
+		if (targetPlayer->getInventoryItem(CONST_SLOT_ARMOR) != nullptr) {
+			double_t chance = targetPlayer->getInventoryItem(CONST_SLOT_ARMOR)->getDodgeChance();
+			if (chance > 0 && uniform_random(1, 100) <= chance) {
+				sendBlockEffect(BLOCK_DODGE, damage.primary.type, target->getPosition());
+				targetPlayer->sendTextMessage(MESSAGE_ATTENTION, "You dodged an attack. (Ruse)");
+				return true;
+			}
+		}
+	}
+
 	bool canHeal = false;
 		CombatDamage damageHeal;
 		damageHeal.primary.type = COMBAT_HEALING;
@@ -5931,7 +5945,9 @@ bool Game::combatChangeHealth(Creature* attacker, Creature* target, CombatDamage
 		SpectatorHashSet spectators;
 		map.getSpectators(spectators, targetPos, true, true);
 
-		if (damage.critical) {
+		if (damage.fatal) {
+			addMagicEffect(spectators, targetPos, CONST_ME_FATAL);
+		} else if (damage.critical) {
 			addMagicEffect(spectators, targetPos, CONST_ME_CRITICAL_DAMAGE);
 		}
 
@@ -6236,6 +6252,9 @@ bool Game::combatChangeHealth(Creature* attacker, Creature* target, CombatDamage
 					if (damage.extension) {
 						ss << " " << damage.exString;
 					}
+					if (damage.fatal) {
+						ss << " (Onslaught)";
+					}
 					message.type = MESSAGE_DAMAGE_DEALT;
 					message.text = ss.str();
 				} else if (tmpPlayer == targetPlayer) {

src/io/iologindata.cpp

@@ -292,6 +292,7 @@ bool IOLoginData::loadPlayer(Player* player, DBResult_ptr result)
 
   player->addPreyCards(result->getNumber<uint64_t>("prey_wildcard"));
   player->addTaskHuntingPoints(result->getNumber<uint16_t>("task_points"));
+  player->setForgeDusts(result->getNumber<uint64_t>("forge_dusts"));
 
   player->lastLoginSaved = result->getNumber<time_t>("lastlogin");
   player->lastLogout = result->getNumber<time_t>("lastlogout");
@@ -878,6 +879,7 @@ bool IOLoginData::savePlayer(Player* player)
 
   query << "`prey_wildcard` = " << player->getPreyCards() << ',';
   query << "`task_points` = " << player->getTaskHuntingPoints() << ',';
+  query << "`forge_dusts` = " << player->getForgeDusts() << ',';
 
   query << "`cap` = " << (player->capacity / 100) << ',';
   query << "`sex` = " << static_cast<uint16_t>(player->sex) << ',';

src/items/item.cpp

@@ -773,6 +773,16 @@ Attr_ReadValue Item::readAttr(AttrTypes_t attr, PropStream& propStream)
 			break;
 		}
 
+		case ATTR_TIER: {
+			uint8_t tier;
+			if (!propStream.read<uint8_t>(tier)) {
+				return ATTR_READ_ERROR;
+			}
+
+			setIntAttr(ITEM_ATTRIBUTE_TIER, tier);
+			break;
+		}
+
 		default:
 			return ATTR_READ_ERROR;
 	}
@@ -943,6 +953,11 @@ void Item::serializeAttr(PropWriteStream& propWriteStream) const
 		propWriteStream.write<uint8_t>(ATTR_IMBUEMENT_TYPE);
 		propWriteStream.writeString(getStrAttr(ITEM_ATTRIBUTE_IMBUEMENT_TYPE));
 	}
+
+	if (hasAttribute(ITEM_ATTRIBUTE_TIER)) {
+		propWriteStream.write<uint8_t>(ATTR_TIER);
+		propWriteStream.write<uint8_t>(getTier());
+	}
 }
 
 bool Item::hasProperty(ItemProperty prop) const
@@ -2286,6 +2301,20 @@ std::string Item::getDescription(const ItemType& it, int32_t lookDistance,
 
 	s << parseImbuementDescription(item);
 
+	if (uint16_t classification = item->getClassification(); classification > 1) {
+		s << std::endl << "Classification: " << classification << " Tier: " << item->getTier();
+		if (item->getTier() != 0) {
+			s  << " (";
+			if (it.weaponType != WEAPON_NONE) {
+				s << item->getFatalChance() << "% Onslaught).";
+			} else if (g_game().getObjectCategory(item) == OBJECTCATEGORY_HELMETS) {
+				s << item->getMomentumChance() << "% Momentum).";
+			} else if (g_game().getObjectCategory(item) == OBJECTCATEGORY_ARMORS) {
+				s << item->getDodgeChance() << "% Ruse).";
+			}
+		}
+	}
+
 	if (lookDistance <= 1) {
 		if (item) {
 			const uint32_t weight = item->getWeight();

src/items/item.h

@@ -484,6 +484,7 @@ class ItemAttributes
 			checkTypes |= ITEM_ATTRIBUTE_OPENCONTAINER;
 			checkTypes |= ITEM_ATTRIBUTE_QUICKLOOTCONTAINER;
 			checkTypes |= ITEM_ATTRIBUTE_DURATION_TIMESTAMP;
+			checkTypes |= ITEM_ATTRIBUTE_TIER;
 			return (type & static_cast<ItemAttrTypes>(checkTypes)) != 0;
 		}
 		static bool isStrAttrType(ItemAttrTypes type) {
@@ -950,6 +951,31 @@ class Item : virtual public Thing
 			return items[id].isQuiver();
 		}
 
+		double_t calculateTierBonus(uint8_t tier, double_t x, double_t y) const {
+			return x * tier + y * ((tier - 1) * (tier - 1));
+		}
+
+		double_t getDodgeChance() const {
+			if (getTier() == 0) {
+				return 0;
+			}
+			return calculateTierBonus(getTier(), 0.5, 0.03);
+		}
+
+		double_t getFatalChance() const {
+			if (getTier() == 0) {
+				return 0;
+			}
+			return calculateTierBonus(getTier(), 0.5, 0.05);
+		}
+
+		double_t getMomentumChance() const {
+			if (getTier() == 0) {
+				return 0;
+			}
+			return calculateTierBonus(getTier(), 2, 0.05);
+		}
+
 		const std::string& getName() const {
 			if (hasAttribute(ITEM_ATTRIBUTE_NAME)) {
 				return getStrAttr(ITEM_ATTRIBUTE_NAME);
@@ -1096,6 +1122,21 @@ class Item : virtual public Thing
 			return false;
 		}
 
+		uint16_t getTier() const {
+			if (hasAttribute(ITEM_ATTRIBUTE_TIER)) {
+				return getIntAttr(ITEM_ATTRIBUTE_TIER);
+			}
+			return 0;
+		}
+		void setTier(uint8_t tier) {
+			if (items[id].upgradeClassification) {
+				setIntAttr(ITEM_ATTRIBUTE_TIER, tier);
+			}
+		}
+		uint16_t getClassification() const {
+			return items[id].upgradeClassification;
+		}
+
 	protected:
 		std::string getWeightDescription(uint32_t weight) const;
 

src/items/items_definitions.hpp

@@ -242,7 +242,8 @@ enum AttrTypes_t {
 	ATTR_OPENCONTAINER = 36,
 	ATTR_CUSTOM_ATTRIBUTES = 37,
 	ATTR_QUICKLOOTCONTAINER = 38,
-	ATTR_IMBUEMENT_TYPE = 39
+	ATTR_IMBUEMENT_TYPE = 39,
+	ATTR_TIER = 40
 };
 
 enum ImbuementTypes_t : int64_t {
@@ -316,6 +317,8 @@ enum ItemAttrTypes : uint32_t {
 	ITEM_ATTRIBUTE_QUICKLOOTCONTAINER = 1 << 26,
 	ITEM_ATTRIBUTE_DURATION_TIMESTAMP = 1 << 27,
 	ITEM_ATTRIBUTE_IMBUEMENT_TYPE = 1 << 28,
+	ITEM_ATTRIBUTE_TIER = 1 << 29,
+
 	ITEM_ATTRIBUTE_CUSTOM = 1U << 31
 };