Comparar texto

Encuentra la diferencia entre dos archivos de texto

Editor live

Ocultar sin cambios

Sin ajuste de línea

Vista

Nivel de detalle

Resaltado de sintaxis

Diffchecker Desktop La forma más segura de usar Diffchecker. ¡Obtén la app de Diffchecker Desktop: tus diffs nunca salen de tu computadora!Obtener Desktop

Untitled diff

Creado hace 9 añosEl diff nunca expira

0 eliminaciones

Líneas
Total
Eliminado

Caracteres
Total
Eliminado

Para continuar usando esta función, actualice a Diffchecker Pro Ver precios

180 líneas

8 adiciones

Líneas
Total
Añadido

Caracteres
Total
Añadido

Para continuar usando esta función, actualice a Diffchecker Pro Ver precios

188 líneas

void Player::death(Creature* lastHitCreature)

{

loginPosition = town->getTemplePosition();

if (skillLoss) {

uint8_t unfairFightReduction = 100;

bool lastHitPlayer = Player::lastHitIsPlayer(lastHitCreature);

if (lastHitPlayer) {

uint32_t sumLevels = 0;

uint32_t inFightTicks = g_config.getNumber(ConfigManager::PZ_LOCKED);

for (const auto& it : damageMap) {

CountBlock_t cb = it.second;

if ((OTSYS_TIME() - cb.ticks) <= inFightTicks) {

Player* damageDealer = g_game.getPlayerByID(it.first);

if (damageDealer) {

sumLevels += damageDealer->getLevel();

}

if (sumLevels > level) {

double reduce = level / static_cast<double>(sumLevels);

unfairFightReduction = std::max<uint8_t>(20, std::floor((reduce * 100) + 0.5));

}

//Magic level loss

uint64_t sumMana = 0;

uint64_t lostMana = 0;

//sum up all the mana

for (uint32_t i = 1; i <= magLevel; ++i) {

sumMana += vocation->getReqMana(i);

}

sumMana += manaSpent;

double deathLossPercent = getLostPercent() * (unfairFightReduction / 100.);

lostMana = static_cast<uint64_t>(sumMana * deathLossPercent);

while (lostMana > manaSpent && magLevel > 0) {

lostMana -= manaSpent;

manaSpent = vocation->getReqMana(magLevel);

magLevel--;

}

manaSpent -= lostMana;

uint64_t nextReqMana = vocation->getReqMana(magLevel + 1);

if (nextReqMana > vocation->getReqMana(magLevel)) {

magLevelPercent = Player::getPercentLevel(manaSpent, nextReqMana);

} else {

magLevelPercent = 0;

}

//Skill loss

for (uint8_t i = SKILL_FIRST; i <= SKILL_LAST; ++i) { //for each skill

uint64_t sumSkillTries = 0;

for (uint16_t c = 11; c <= skills[i].level; ++c) { //sum up all required tries for all skill levels

sumSkillTries += vocation->getReqSkillTries(i, c);

}

sumSkillTries += skills[i].tries;

uint32_t lostSkillTries = static_cast<uint32_t>(sumSkillTries * deathLossPercent);

while (lostSkillTries > skills[i].tries) {

lostSkillTries -= skills[i].tries;

if (skills[i].level <= 10) {

skills[i].level = 10;

skills[i].tries = 0;

lostSkillTries = 0;

break;

}

skills[i].tries = vocation->getReqSkillTries(i, skills[i].level);

skills[i].level--;

}

skills[i].tries = std::max<int32_t>(0, skills[i].tries - lostSkillTries);

skills[i].percent = Player::getPercentLevel(skills[i].tries, vocation->getReqSkillTries(i, skills[i].level));

}

//Level loss

uint64_t expLoss = static_cast<uint64_t>(experience * deathLossPercent);

g_events->eventPlayerOnLoseExperience(this, expLoss);

if (expLoss != 0) {

uint32_t oldLevel = level;

if (vocation->getId() == VOCATION_NONE || level > 7) {

experience -= expLoss;

}

while (level > 1 && experience < Player::getExpForLevel(level)) {

--level;

healthMax = std::max<int32_t>(0, healthMax - vocation->getHPGain());

manaMax = std::max<int32_t>(0, manaMax - vocation->getManaGain());

capacity = std::max<int32_t>(0, capacity - vocation->getCapGain());

}

if (oldLevel != level) {

std::ostringstream ss;

ss << "You were downgraded from Level " << oldLevel << " to Level " << level << '.';

sendTextMessage(MESSAGE_EVENT_ADVANCE, ss.str());

if (passiveDamageBonus > 0)

{

passiveDamageBonus--;

std::ostringstream msgPassive;

msgPassive << "Your passive damage bonus has reduced from " << passiveDamageBonus + 1 << "% to " << passiveDamageBonus << "%.";

sendTextMessage(MESSAGE_EVENT_ADVANCE, msgPassive.str());

}

uint64_t currLevelExp = Player::getExpForLevel(level);

uint64_t nextLevelExp = Player::getExpForLevel(level + 1);

if (nextLevelExp > currLevelExp) {

levelPercent = Player::getPercentLevel(experience - currLevelExp, nextLevelExp - currLevelExp);

} else {

levelPercent = 0;

}

std::bitset<6> bitset(blessings);

if (bitset[5]) {

if (lastHitPlayer) {

bitset.reset(5);

blessings = bitset.to_ulong();

} else {

blessings = 32;

}

} else {

blessings = 0;

}

sendStats();

sendSkills();

sendReLoginWindow(unfairFightReduction);

if (getSkull() == SKULL_BLACK) {

health = 40;

mana = 0;

} else {

health = healthMax;

mana = manaMax;

}

auto it = conditions.begin(), end = conditions.end();

while (it != end) {

Condition* condition = *it;

if (condition->isPersistent()) {

it = conditions.erase(it);

condition->endCondition(this);

onEndCondition(condition->getType());

delete condition;

} else {

++it;

}

} else {

setSkillLoss(true);

auto it = conditions.begin(), end = conditions.end();

while (it != end) {

Condition* condition = *it;

if (condition->isPersistent()) {

it = conditions.erase(it);

condition->endCondition(this);

onEndCondition(condition->getType());

delete condition;

} else {

++it;

}

health = healthMax;

g_game.internalTeleport(this, getTemplePosition(), true);

g_game.addCreatureHealth(this);

onThink(EVENT_CREATURE_THINK_INTERVAL);

onIdleStatus();

sendStats();

}

Diferencias guardadas

Texto original

Abrir archivo

void Player::death(Creature* lastHitCreature)
{
	loginPosition = town->getTemplePosition();

if (skillLoss) {
		uint8_t unfairFightReduction = 100;
		bool lastHitPlayer = Player::lastHitIsPlayer(lastHitCreature);

if (lastHitPlayer) {
			uint32_t sumLevels = 0;
			uint32_t inFightTicks = g_config.getNumber(ConfigManager::PZ_LOCKED);
			for (const auto& it : damageMap) {
				CountBlock_t cb = it.second;
				if ((OTSYS_TIME() - cb.ticks) <= inFightTicks) {
					Player* damageDealer = g_game.getPlayerByID(it.first);
					if (damageDealer) {
						sumLevels += damageDealer->getLevel();
					}
				}
			}

if (sumLevels > level) {
				double reduce = level / static_cast<double>(sumLevels);
				unfairFightReduction = std::max<uint8_t>(20, std::floor((reduce * 100) + 0.5));
			}
		}

//Magic level loss
		uint64_t sumMana = 0;
		uint64_t lostMana = 0;

//sum up all the mana
		for (uint32_t i = 1; i <= magLevel; ++i) {
			sumMana += vocation->getReqMana(i);
		}

sumMana += manaSpent;

double deathLossPercent = getLostPercent() * (unfairFightReduction / 100.);

lostMana = static_cast<uint64_t>(sumMana * deathLossPercent);

while (lostMana > manaSpent && magLevel > 0) {
			lostMana -= manaSpent;
			manaSpent = vocation->getReqMana(magLevel);
			magLevel--;
		}

manaSpent -= lostMana;

uint64_t nextReqMana = vocation->getReqMana(magLevel + 1);
		if (nextReqMana > vocation->getReqMana(magLevel)) {
			magLevelPercent = Player::getPercentLevel(manaSpent, nextReqMana);
		} else {
			magLevelPercent = 0;
		}

//Skill loss
		for (uint8_t i = SKILL_FIRST; i <= SKILL_LAST; ++i) { //for each skill
			uint64_t sumSkillTries = 0;
			for (uint16_t c = 11; c <= skills[i].level; ++c) { //sum up all required tries for all skill levels
				sumSkillTries += vocation->getReqSkillTries(i, c);
			}

sumSkillTries += skills[i].tries;

uint32_t lostSkillTries = static_cast<uint32_t>(sumSkillTries * deathLossPercent);
			while (lostSkillTries > skills[i].tries) {
				lostSkillTries -= skills[i].tries;

if (skills[i].level <= 10) {
					skills[i].level = 10;
					skills[i].tries = 0;
					lostSkillTries = 0;
					break;
				}

skills[i].tries = vocation->getReqSkillTries(i, skills[i].level);
				skills[i].level--;
			}

skills[i].tries = std::max<int32_t>(0, skills[i].tries - lostSkillTries);
			skills[i].percent = Player::getPercentLevel(skills[i].tries, vocation->getReqSkillTries(i, skills[i].level));
		}

//Level loss
		uint64_t expLoss = static_cast<uint64_t>(experience * deathLossPercent);
		g_events->eventPlayerOnLoseExperience(this, expLoss);

if (expLoss != 0) {
			uint32_t oldLevel = level;

if (vocation->getId() == VOCATION_NONE || level > 7) {
				experience -= expLoss;
			}

while (level > 1 && experience < Player::getExpForLevel(level)) {
				--level;
				healthMax = std::max<int32_t>(0, healthMax - vocation->getHPGain());
				manaMax = std::max<int32_t>(0, manaMax - vocation->getManaGain());
				capacity = std::max<int32_t>(0, capacity - vocation->getCapGain());
			}

if (oldLevel != level) {
				std::ostringstream ss;
				ss << "You were downgraded from Level " << oldLevel << " to Level " << level << '.';
				sendTextMessage(MESSAGE_EVENT_ADVANCE, ss.str());
			}

uint64_t currLevelExp = Player::getExpForLevel(level);
			uint64_t nextLevelExp = Player::getExpForLevel(level + 1);
			if (nextLevelExp > currLevelExp) {
				levelPercent = Player::getPercentLevel(experience - currLevelExp, nextLevelExp - currLevelExp);
			} else {
				levelPercent = 0;
			}
		}

std::bitset<6> bitset(blessings);
		if (bitset[5]) {
			if (lastHitPlayer) {
				bitset.reset(5);
				blessings = bitset.to_ulong();
			} else {
				blessings = 32;
			}
		} else {
			blessings = 0;
		}

sendStats();
		sendSkills();
		sendReLoginWindow(unfairFightReduction);

if (getSkull() == SKULL_BLACK) {
			health = 40;
			mana = 0;
		} else {
			health = healthMax;
			mana = manaMax;
		}

auto it = conditions.begin(), end = conditions.end();
		while (it != end) {
			Condition* condition = *it;
			if (condition->isPersistent()) {
				it = conditions.erase(it);

condition->endCondition(this);
				onEndCondition(condition->getType());
				delete condition;
			} else {
				++it;
			}
		}
	} else {
		setSkillLoss(true);

auto it = conditions.begin(), end = conditions.end();
		while (it != end) {
			Condition* condition = *it;
			if (condition->isPersistent()) {
				it = conditions.erase(it);

condition->endCondition(this);
				onEndCondition(condition->getType());
				delete condition;
			} else {
				++it;
			}
		}

health = healthMax;
		g_game.internalTeleport(this, getTemplePosition(), true);
		g_game.addCreatureHealth(this);
		onThink(EVENT_CREATURE_THINK_INTERVAL);
		onIdleStatus();
		sendStats();
	}
}

Texto modificado

Abrir archivo

void Player::death(Creature* lastHitCreature)
{
	loginPosition = town->getTemplePosition();

if (skillLoss) {
		uint8_t unfairFightReduction = 100;
		bool lastHitPlayer = Player::lastHitIsPlayer(lastHitCreature);

if (sumLevels > level) {
				double reduce = level / static_cast<double>(sumLevels);
				unfairFightReduction = std::max<uint8_t>(20, std::floor((reduce * 100) + 0.5));
			}
		}

//Magic level loss
		uint64_t sumMana = 0;
		uint64_t lostMana = 0;

//sum up all the mana
		for (uint32_t i = 1; i <= magLevel; ++i) {
			sumMana += vocation->getReqMana(i);
		}

sumMana += manaSpent;

double deathLossPercent = getLostPercent() * (unfairFightReduction / 100.);

lostMana = static_cast<uint64_t>(sumMana * deathLossPercent);

while (lostMana > manaSpent && magLevel > 0) {
			lostMana -= manaSpent;
			manaSpent = vocation->getReqMana(magLevel);
			magLevel--;
		}

manaSpent -= lostMana;

sumSkillTries += skills[i].tries;

uint32_t lostSkillTries = static_cast<uint32_t>(sumSkillTries * deathLossPercent);
			while (lostSkillTries > skills[i].tries) {
				lostSkillTries -= skills[i].tries;

if (skills[i].level <= 10) {
					skills[i].level = 10;
					skills[i].tries = 0;
					lostSkillTries = 0;
					break;
				}

skills[i].tries = vocation->getReqSkillTries(i, skills[i].level);
				skills[i].level--;
			}

skills[i].tries = std::max<int32_t>(0, skills[i].tries - lostSkillTries);
			skills[i].percent = Player::getPercentLevel(skills[i].tries, vocation->getReqSkillTries(i, skills[i].level));
		}

//Level loss
		uint64_t expLoss = static_cast<uint64_t>(experience * deathLossPercent);
		g_events->eventPlayerOnLoseExperience(this, expLoss);

if (expLoss != 0) {
			uint32_t oldLevel = level;

if (vocation->getId() == VOCATION_NONE || level > 7) {
				experience -= expLoss;
			}

if (oldLevel != level) {
				std::ostringstream ss;
				ss << "You were downgraded from Level " << oldLevel << " to Level " << level << '.';
				sendTextMessage(MESSAGE_EVENT_ADVANCE, ss.str());

if (passiveDamageBonus > 0)
				{
					passiveDamageBonus--;
					std::ostringstream msgPassive;
					msgPassive << "Your passive damage bonus has reduced from " << passiveDamageBonus + 1 << "% to " << passiveDamageBonus << "%.";
					sendTextMessage(MESSAGE_EVENT_ADVANCE, msgPassive.str());
				}
			}

sendStats();
		sendSkills();
		sendReLoginWindow(unfairFightReduction);

if (getSkull() == SKULL_BLACK) {
			health = 40;
			mana = 0;
		} else {
			health = healthMax;
			mana = manaMax;
		}

auto it = conditions.begin(), end = conditions.end();
		while (it != end) {
			Condition* condition = *it;
			if (condition->isPersistent()) {
				it = conditions.erase(it);

condition->endCondition(this);
				onEndCondition(condition->getType());
				delete condition;
			} else {
				++it;
			}
		}
	} else {
		setSkillLoss(true);

auto it = conditions.begin(), end = conditions.end();
		while (it != end) {
			Condition* condition = *it;
			if (condition->isPersistent()) {
				it = conditions.erase(it);

condition->endCondition(this);
				onEndCondition(condition->getType());
				delete condition;
			} else {
				++it;
			}
		}

health = healthMax;
		g_game.internalTeleport(this, getTemplePosition(), true);
		g_game.addCreatureHealth(this);
		onThink(EVENT_CREATURE_THINK_INTERVAL);
		onIdleStatus();
		sendStats();
	}
}