Rampoina
/
MegaGlest
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

- attempt to add hp regen to upgrades and attack-boost

This commit is contained in:
Mark Vejvoda 2011-07-22 07:05:47 +00:00
parent 3efe9e0263
commit 82a0f23487
5 changed files with 222 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
source/glest_game/type_instances/unit.cpp
View File

@ -1718,6 +1718,7 @@ bool Unit::applyAttackBoost(const AttackBoost *boost, const Unit *source) {
bool wasAlive = alive;
int prevMaxHp = totalUpgrade.getMaxHp();
int prevMaxHpRegen = totalUpgrade.getMaxHpRegeneration();
//printf("#1 wasAlive = %d hp = %d boosthp = %d\n",wasAlive,hp,boost->boostUpgrade.getMaxHp());
totalUpgrade.apply(&boost->boostUpgrade, this);
@ -1727,6 +1728,16 @@ bool Unit::applyAttackBoost(const AttackBoost *boost, const Unit *source) {
hp += (totalUpgrade.getMaxHp() - prevMaxHp);
addItemToVault(&this->hp,this->hp);
//regenerate hp upgrade / or boost
if(totalUpgrade.getMaxHpRegeneration() != 0) {
checkItemInVault(&this->hp,this->hp);
hp += (totalUpgrade.getMaxHpRegeneration() - prevMaxHpRegen);
if(hp > totalUpgrade.getMaxHp()) {
hp = totalUpgrade.getMaxHp();
}
addItemToVault(&this->hp,this->hp);
}
//printf("#2 wasAlive = %d hp = %d boosthp = %d\n",wasAlive,hp,boost->boostUpgrade.getMaxHp());
if(showUnitParticles == true) {
@ -1788,6 +1799,7 @@ void Unit::deapplyAttackBoost(const AttackBoost *boost, const Unit *source) {
bool wasAlive = alive;
int prevMaxHp = totalUpgrade.getMaxHp();
int prevMaxHpRegen = totalUpgrade.getMaxHpRegeneration();
totalUpgrade.deapply(&boost->boostUpgrade, this);
checkItemInVault(&this->hp,this->hp);
@ -1795,6 +1807,16 @@ void Unit::deapplyAttackBoost(const AttackBoost *boost, const Unit *source) {
hp -= (prevMaxHp - totalUpgrade.getMaxHp());
addItemToVault(&this->hp,this->hp);
//regenerate hp upgrade / or boost
if(totalUpgrade.getMaxHpRegeneration() != 0) {
checkItemInVault(&this->hp,this->hp);
hp -= (totalUpgrade.getMaxHpRegeneration() - prevMaxHpRegen);
if(hp > totalUpgrade.getMaxHp()) {
hp = totalUpgrade.getMaxHp();
}
addItemToVault(&this->hp,this->hp);
}
if(wasAlive == true) {
//printf("DE-APPLYING ATTACK BOOST wasalive = true to unit [%s - %d] from unit [%s - %d]\n",this->getType()->getName().c_str(),this->getId(),source->getType()->getName().c_str(),source->getId());
@ -1872,6 +1894,30 @@ void Unit::tick() {
}
}
//regenerate hp upgrade / or boost
if(type->getTotalMaxHpRegeneration(&totalUpgrade) >= 0) {
checkItemInVault(&this->hp,this->hp);
hp += type->getTotalMaxHpRegeneration(&totalUpgrade);
if(hp > type->getTotalMaxHp(&totalUpgrade)) {
hp = type->getTotalMaxHp(&totalUpgrade);
}
addItemToVault(&this->hp,this->hp);
}
// If we have negative regeneration then check if the unit should die
else {
bool decHpResult = decHp(-type->getTotalMaxHpRegeneration(&totalUpgrade));
if(decHpResult) {
Unit::game->getWorld()->getStats()->die(getFactionIndex());
game->getScriptManager()->onUnitDied(this);
}
StaticSound *sound= this->getType()->getFirstStOfClass(scDie)->getSound();
if(sound != NULL &&
(this->getFactionIndex() == Unit::game->getWorld()->getThisFactionIndex() ||
(game->getWorld()->getThisTeamIndex() == GameConstants::maxPlayers -1 + fpt_Observer))) {
SoundRenderer::getInstance().playFx(sound);
}
}
//stop DamageParticles
stopDamageParticles(false);
@ -1882,6 +1928,16 @@ void Unit::tick() {
ep = type->getTotalMaxEp(&totalUpgrade);
}
addItemToVault(&this->ep,this->ep);
//regenerate ep upgrade / or boost
checkItemInVault(&this->ep,this->ep);
//regenerate ep
ep += type->getTotalMaxEpRegeneration(&totalUpgrade);
if(ep > type->getTotalMaxEp(&totalUpgrade)){
ep = type->getTotalMaxEp(&totalUpgrade);
}
addItemToVault(&this->ep,this->ep);
}
}
@ -2045,16 +2101,24 @@ string Unit::getDesc() const {
//str += "\n"+lang.get("Hp")+ ": " + intToStr(hp) + "/" + intToStr(type->getTotalMaxHp(&totalUpgrade)) + " [" + floatToStr(getHpRatio()) + "] [" + floatToStr(animProgress) + "]";
str += "\n"+lang.get("Hp")+ ": " + intToStr(hp) + "/" + intToStr(type->getTotalMaxHp(&totalUpgrade));
if(type->getHpRegeneration()!=0){
str+= " (" + lang.get("Regeneration") + ": " + intToStr(type->getHpRegeneration()) + ")";
if(type->getHpRegeneration() != 0) {
str+= " (" + lang.get("Regeneration") + ": " + intToStr(type->getHpRegeneration());
if(type->getTotalMaxHpRegeneration(&totalUpgrade) != 0) {
str+= "/" + intToStr(type->getTotalMaxHpRegeneration(&totalUpgrade));
}
str+= ")";
}
//ep
if(getType()->getMaxEp()!=0){
str+= "\n" + lang.get("Ep")+ ": " + intToStr(ep) + "/" + intToStr(type->getTotalMaxEp(&totalUpgrade));
}
if(type->getEpRegeneration()!=0){
str+= " (" + lang.get("Regeneration") + ": " + intToStr(type->getEpRegeneration()) + ")";
if(type->getEpRegeneration() != 0) {
str+= " (" + lang.get("Regeneration") + ": " + intToStr(type->getEpRegeneration());
if(type->getTotalMaxEpRegeneration(&totalUpgrade) != 0) {
str += "/" + intToStr(type->getTotalMaxEpRegeneration(&totalUpgrade));
}
str+= ")";
}
//armor

14
source/glest_game/types/unit_type.cpp
View File

@ -708,6 +708,13 @@ int UnitType::getTotalMaxHp(const TotalUpgrade *totalUpgrade) const {
return result;
}
int UnitType::getTotalMaxHpRegeneration(const TotalUpgrade *totalUpgrade) const {
checkItemInVault(&(this->hpRegeneration),this->hpRegeneration);
int result = hpRegeneration + totalUpgrade->getMaxHpRegeneration();
result = max(0,result);
return result;
}
int UnitType::getTotalMaxEp(const TotalUpgrade *totalUpgrade) const {
checkItemInVault(&(this->maxEp),this->maxEp);
int result = maxEp + totalUpgrade->getMaxEp();
@ -715,6 +722,13 @@ int UnitType::getTotalMaxEp(const TotalUpgrade *totalUpgrade) const {
return result;
}
int UnitType::getTotalMaxEpRegeneration(const TotalUpgrade *totalUpgrade) const {
checkItemInVault(&(this->epRegeneration),this->epRegeneration);
int result = epRegeneration + totalUpgrade->getMaxEpRegeneration();
result = max(0,result);
return result;
}
int UnitType::getTotalArmor(const TotalUpgrade *totalUpgrade) const {
checkItemInVault(&(this->armor),this->armor);
int result = armor + totalUpgrade->getArmor();

2
source/glest_game/types/unit_type.h
View File

@ -188,7 +188,9 @@ public:
//get totals
int getTotalMaxHp(const TotalUpgrade *totalUpgrade) const;
int getTotalMaxHpRegeneration(const TotalUpgrade *totalUpgrade) const;
int getTotalMaxEp(const TotalUpgrade *totalUpgrade) const;
int getTotalMaxEpRegeneration(const TotalUpgrade *totalUpgrade) const;
int getTotalArmor(const TotalUpgrade *totalUpgrade) const;
int getTotalSight(const TotalUpgrade *totalUpgrade) const;

136
source/glest_game/types/upgrade_type.cpp
View File

@ -38,6 +38,8 @@ namespace Glest{ namespace Game{
// ==================== get ====================
const string VALUE_PERCENT_MULTIPLIER_KEY_NAME = "value-percent-multiplier";
const string VALUE_REGEN_KEY_NAME = "regeneration";
void UpgradeTypeBase::load(const XmlNode *upgradeNode) {
//values
@ -48,6 +50,13 @@ void UpgradeTypeBase::load(const XmlNode *upgradeNode) {
//printf("Found maxHpIsMultiplier = %d\n",maxHpIsMultiplier);
}
maxHpRegeneration = 0;
//maxHpRegenerationIsMultiplier = false;
if(upgradeNode->getChild("max-hp")->getAttribute(VALUE_REGEN_KEY_NAME,false) != NULL) {
maxHpRegeneration = upgradeNode->getChild("max-hp")->getAttribute(VALUE_REGEN_KEY_NAME)->getIntValue();
//printf("Found maxHpIsMultiplier = %d\n",maxHpIsMultiplier);
}
maxEpIsMultiplier = false;
maxEp= upgradeNode->getChild("max-ep")->getAttribute("value")->getIntValue();
@ -56,6 +65,13 @@ void UpgradeTypeBase::load(const XmlNode *upgradeNode) {
//printf("Found maxEpIsMultiplier = %d\n",maxEpIsMultiplier);
}
maxEpRegeneration = 0;
//maxEpRegenerationIsMultiplier = false;
if(upgradeNode->getChild("max-ep")->getAttribute(VALUE_REGEN_KEY_NAME,false) != NULL) {
maxEpRegeneration = upgradeNode->getChild("max-ep")->getAttribute(VALUE_REGEN_KEY_NAME)->getIntValue();
//printf("Found maxHpIsMultiplier = %d\n",maxHpIsMultiplier);
}
sightIsMultiplier = false;
sight= upgradeNode->getChild("sight")->getAttribute("value")->getIntValue();
@ -317,29 +333,76 @@ string UpgradeType::getReqDesc() const{
}
}
if(maxHp!=0){
str+= lang.get("Hp")+" +"+intToStr(maxHp);
if(maxHp != 0) {
if(maxHpIsMultiplier) {
str += lang.get("Hp") + " *" + intToStr(maxHp);
}
else {
str += lang.get("Hp") + " +" + intToStr(maxHp);
}
if(maxHpRegeneration != 0) {
str += " [" + intToStr(maxHpRegeneration) + "]";
}
}
if(sight!=0){
str+= lang.get("Sight")+" +"+intToStr(sight);
if(sight != 0) {
if(sightIsMultiplier) {
str+= lang.get("Sight") + " *" + intToStr(sight);
}
else {
str+= lang.get("Sight") + " +" + intToStr(sight);
}
}
if(maxEp!=0){
str+= lang.get("Ep")+" +"+intToStr(maxEp)+"\n";
if(maxEp != 0) {
if(maxEpIsMultiplier) {
str+= lang.get("Ep") + " *" + intToStr(maxEp)+"\n";
}
else {
str+= lang.get("Ep") + " +" + intToStr(maxEp)+"\n";
}
if(maxEpRegeneration != 0) {
str += " [" + intToStr(maxEpRegeneration) + "]";
}
}
if(attackStrength!=0){
str+= lang.get("AttackStrenght")+" +"+intToStr(attackStrength)+"\n";
if(attackStrength != 0) {
if(attackStrengthIsMultiplier) {
str+= lang.get("AttackStrenght") + " *" + intToStr(attackStrength)+"\n";
}
else {
str+= lang.get("AttackStrenght") + " +" + intToStr(attackStrength)+"\n";
}
}
if(attackRange!=0){
str+= lang.get("AttackDistance")+" +"+intToStr(attackRange)+"\n";
if(attackRange != 0) {
if(attackRangeIsMultiplier) {
str+= lang.get("AttackDistance") + " *" + intToStr(attackRange)+"\n";
}
else {
str+= lang.get("AttackDistance") + " +" + intToStr(attackRange)+"\n";
}
}
if(armor!=0){
str+= lang.get("Armor")+" +"+intToStr(armor)+"\n";
if(armor != 0) {
if(armorIsMultiplier) {
str+= lang.get("Armor") + " *" + intToStr(armor)+"\n";
}
else {
str+= lang.get("Armor") + " +" + intToStr(armor)+"\n";
}
}
if(moveSpeed!=0){
str+= lang.get("WalkSpeed")+"+ "+intToStr(moveSpeed)+"\n";
if(moveSpeed != 0) {
if(moveSpeedIsMultiplier) {
str+= lang.get("WalkSpeed") + " *" + intToStr(moveSpeed)+"\n";
}
else {
str+= lang.get("WalkSpeed") + " +" + intToStr(moveSpeed)+"\n";
}
}
if(prodSpeed!=0){
str+= lang.get("ProductionSpeed")+" +"+intToStr(prodSpeed)+"\n";
if(prodSpeed != 0) {
if(prodSpeedIsMultiplier) {
str+= lang.get("ProductionSpeed") + " *" + intToStr(prodSpeed)+"\n";
}
else {
str+= lang.get("ProductionSpeed") + " +" + intToStr(prodSpeed)+"\n";
}
}
return str;
@ -357,13 +420,30 @@ TotalUpgrade::TotalUpgrade() {
void TotalUpgrade::reset() {
maxHp= 0;
maxHpIsMultiplier=false;
maxHpRegeneration = 0;
maxEp= 0;
maxEpIsMultiplier = false;
maxEpRegeneration = 0;
sight=0;
sightIsMultiplier=false;
armor= 0;
armorIsMultiplier=false;
attackStrength= 0;
attackStrengthIsMultiplier=false;
attackRange= 0;
attackRangeIsMultiplier=false;
moveSpeed= 0;
moveSpeedIsMultiplier=false;
prodSpeed=0;
prodSpeedIsMultiplier=false;
}
void TotalUpgrade::sum(const UpgradeTypeBase *ut, const Unit *unit) {
@ -379,18 +459,30 @@ void TotalUpgrade::sum(const UpgradeTypeBase *ut, const Unit *unit) {
if(ut->getMaxHpIsMultiplier() == true) {
//printf("#1 Maxhp maxHp = %d, unit->getHp() = %d ut->getMaxHp() = %d\n",maxHp,unit->getHp(),ut->getMaxHp());
maxHp += ((double)unit->getHp() * ((double)ut->getMaxHp() / (double)100));
if(ut->getMaxHpRegeneration() != 0) {
maxHpRegeneration += ((double)unit->getType()->getHpRegeneration() * ((double)ut->getMaxHpRegeneration() / (double)100));
}
//printf("#1.1 Maxhp maxHp = %d, unit->getHp() = %d ut->getMaxHp() = %d\n",maxHp,unit->getHp(),ut->getMaxHp());
}
else {
//printf("#2 Maxhp maxHp = %d, unit->getHp() = %d ut->getMaxHp() = %d\n",maxHp,unit->getHp(),ut->getMaxHp());
maxHp += ut->getMaxHp();
if(ut->getMaxHpRegeneration() != 0) {
maxHpRegeneration += ut->getMaxHpRegeneration();
}
}
if(ut->getMaxEpIsMultiplier() == true) {
maxEp += ((double)unit->getEp() * ((double)ut->getMaxEp() / (double)100));
if(ut->getMaxHpRegeneration() != 0) {
maxEpRegeneration += ((double)unit->getType()->getEpRegeneration() * ((double)ut->getMaxEpRegeneration() / (double)100));
}
}
else {
maxEp += ut->getMaxEp();
if(ut->getMaxEpRegeneration() != 0) {
maxEpRegeneration += ut->getMaxEpRegeneration();
}
}
if(ut->getSightIsMultiplier() == true) {
@ -490,16 +582,28 @@ void TotalUpgrade::deapply(const UpgradeTypeBase *ut,const Unit *unit) {
if(ut->getMaxHpIsMultiplier() == true) {
maxHp -= ((double)unit->getHp() * ((double)ut->getMaxHp() / (double)100));
if(ut->getMaxHpRegeneration() != 0) {
maxHpRegeneration -= ((double)unit->getType()->getHpRegeneration() * ((double)ut->getMaxHpRegeneration() / (double)100));
}
}
else {
maxHp -= ut->getMaxHp();
if(ut->getMaxHpRegeneration() != 0) {
maxHpRegeneration -= ut->getMaxHpRegeneration();
}
}
if(ut->getMaxEpIsMultiplier() == true) {
maxEp -= ((double)unit->getEp() * ((double)ut->getMaxEp() / (double)100));
if(ut->getMaxEpRegeneration() != 0) {
maxEpRegeneration += ((double)unit->getType()->getEpRegeneration() * ((double)ut->getMaxEpRegeneration() / (double)100));
}
}
else {
maxEp -= ut->getMaxEp();
if(ut->getMaxEpRegeneration() != 0) {
maxEpRegeneration += ut->getMaxEpRegeneration();
}
}
if(ut->getSightIsMultiplier() == true) {

18
source/glest_game/types/upgrade_type.h
View File

@ -41,12 +41,16 @@ class UpgradeTypeBase {
protected:
int maxHp;
bool maxHpIsMultiplier;
int maxHpRegeneration;
//bool maxHpRegenerationIsMultiplier;
int sight;
bool sightIsMultiplier;
int maxEp;
bool maxEpIsMultiplier;
int maxEpRegeneration;
//bool maxEpRegenerationIsMultiplier;
int armor;
bool armorIsMultiplier;
@ -72,10 +76,17 @@ protected:
public:
int getMaxHp() const {return maxHp;}
bool getMaxHpIsMultiplier() const {return maxHpIsMultiplier;}
int getMaxHpRegeneration() const {return maxHpRegeneration;}
//bool getMaxHpRegenerationIsMultiplier() const {return maxHpRegenerationIsMultiplier;}
int getSight() const {return sight;}
bool getSightIsMultiplier() const {return sightIsMultiplier;}
int getMaxEp() const {return maxEp;}
bool getMaxEpIsMultiplier() const {return maxEpIsMultiplier;}
int getMaxEpRegeneration() const {return maxEpRegeneration;}
//bool getMaxEpRegenerationIsMultiplier() const {return maxEpRegenerationIsMultiplier;}
int getArmor() const {return armor;}
bool getArmorIsMultiplier() const {return armorIsMultiplier;}
@ -95,10 +106,17 @@ public:
result += "maxHp = " + intToStr(maxHp);
result += "maxHpIsMultiplier = " + intToStr(maxHpIsMultiplier);
result += "maxHpRegeneration = " + intToStr(maxHpRegeneration);
//result += "maxHpRegenerationIsMultiplier = " + intToStr(maxHpRegenerationIsMultiplier);
result += " sight = " + intToStr(sight);
result += "sightIsMultiplier = " + intToStr(sightIsMultiplier);
result += " maxEp = " + intToStr(maxEp);
result += "maxEpIsMultiplier = " + intToStr(maxEpIsMultiplier);
result += " maxEpRegeneration = " + intToStr(maxEpRegeneration);
//result += "maxEpRegenerationIsMultiplier = " + intToStr(maxEpRegenerationIsMultiplier);
result += " armor = " + intToStr(armor);
result += "armorIsMultiplier = " + intToStr(armorIsMultiplier);
result += " attackStrength = " + intToStr(attackStrength);