Пример #1
0
void Pet::UpdateMaxHealth()
{
    UnitMods unitMod = UNIT_MOD_HEALTH;
    float stamina = GetStat(STAT_STAMINA) - GetCreateStat(STAT_STAMINA);

    float value   = GetModifierValue(unitMod, BASE_VALUE) + GetCreateHealth();
    value  *= GetModifierValue(unitMod, BASE_PCT);
    value  += GetModifierValue(unitMod, TOTAL_VALUE) + stamina * 10.0f;
    value  *= GetModifierValue(unitMod, TOTAL_PCT);

    SetMaxHealth((uint32)value);
}
Пример #2
0
void cOcelot::OnRightClicked(cPlayer & a_Player)
{
	if (!IsTame())
	{
		if (
			IsBegging() &&
			((a_Player.GetPosition() - GetPosition()).Length() <= 3)
		)
		{
			cItems Items;
			GetBreedingItems(Items);
			if (Items.ContainsType(a_Player.GetEquippedItem().m_ItemType))
			{
				if (!a_Player.IsGameModeCreative())
				{
					a_Player.GetInventory().RemoveOneEquippedItem();
				}

				auto & Random = GetRandomProvider();

				if (Random.RandBool(1.0 / 3.0))
				{
					// Taming succeeded
					SetIsBegging(false);

					SetMaxHealth(20);
					SetIsTame(true);
					SetOwner(a_Player.GetName(), a_Player.GetUUID());
					SetCatType(static_cast<eCatType>(Random.RandInt<int>(1, 3)));
					m_World->BroadcastEntityStatus(*this, esWolfTamed);
					m_World->BroadcastParticleEffect("heart", static_cast<Vector3f>(GetPosition()), Vector3f{}, 0, 5);
				}
				else
				{
					// Taming failed
					m_World->BroadcastEntityStatus(*this, esWolfTaming);
					m_World->BroadcastParticleEffect("smoke", static_cast<Vector3f>(GetPosition()), Vector3f{}, 0, 5);
				}
			}
		}
		else
		{
			super::OnRightClicked(a_Player);
		}
	}
	else if (a_Player.GetUUID() == m_OwnerUUID)
	{
		super::OnRightClicked(a_Player);
		SetIsSitting(!IsSitting());
	}
	m_World->BroadcastEntityMetadata(*this);
}
Пример #3
0
cMinecart::cMinecart(ePayload a_Payload, double a_X, double a_Y, double a_Z) :
    super(etMinecart, a_X, a_Y, a_Z, 0.98, 0.7),
    m_Payload(a_Payload),
    m_LastDamage(0),
    m_DetectorRailPosition(0, 0, 0),
    m_bIsOnDetectorRail(false)
{
    SetMass(20.f);
    SetMaxHealth(6);
    SetHealth(6);
    SetWidth(1);
    SetHeight(0.9);
}
Пример #4
0
void CASW_Item_Crate::Spawn()
{
	DisableAutoFade();
	SetModelName( AllocPooledString( ASW_ITEM_CRATE_MODEL ) );
	Precache();
	SetModel( ASW_ITEM_CRATE_MODEL );
	AddSpawnFlags(SF_PHYSPROP_AIMTARGET);
	BaseClass::Spawn();
	m_nSkin = 2;
	SetHealth(30);
	SetMaxHealth(30);
	m_takedamage = DAMAGE_YES;
}
Пример #5
0
cPickup::cPickup(double a_PosX, double a_PosY, double a_PosZ, const cItem & a_Item, bool IsPlayerCreated, float a_SpeedX /* = 0.f */, float a_SpeedY /* = 0.f */, float a_SpeedZ /* = 0.f */)
	: cEntity(etPickup, a_PosX, a_PosY, a_PosZ, 0.2, 0.2)
	, m_Timer(0)
	, m_Item(a_Item)
	, m_bCollected(false)
	, m_bIsPlayerCreated(IsPlayerCreated)
{
	SetGravity(-16.0f);
	SetAirDrag(0.02f);
	SetMaxHealth(5);
	SetHealth(5);
	SetSpeed(a_SpeedX, a_SpeedY, a_SpeedZ);
}
Пример #6
0
cSlime::cSlime(int a_Size) :
	super("Slime",
		mtSlime,
		Printf("mob.slime.%s", GetSizeName(a_Size).c_str()),
		Printf("mob.slime.%s", GetSizeName(a_Size).c_str()),
		0.6 * a_Size,
		0.6 * a_Size
	),
	m_Size(a_Size)
{
	SetMaxHealth(a_Size * a_Size);
	SetAttackDamage(a_Size);
}
Пример #7
0
void AMech_RPGCharacter::SetupWithLoadout() {
	SetMaxHealth(startingLoadout.maxHealth);
	SetHealth(GetMaxHealth());
	SetDefenceModifier(startingLoadout.defenceModifier);
	SetHealthChangeModifier(startingLoadout.damageModifier);
	SetCanMove(startingLoadout.canMove);
	SetCanAttack(startingLoadout.canAttack);
	SetCanBeDamaged(startingLoadout.canBeDamaged);
	SetHealthRegen(startingLoadout.healthRegen);
	SetTeam(startingLoadout.team);
	SetSpeedModifier(startingLoadout.movementModifier);
	SetSpeed(startingLoadout.speed);
}
Пример #8
0
//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CObjectSentrygun::Spawn()
{
	m_iPitchPoseParameter = -1;
	m_iYawPoseParameter = -1;

	SetModel( SENTRY_MODEL_PLACEMENT );
	
	m_takedamage = DAMAGE_YES;

	m_iUpgradeLevel = 1;
	m_iUpgradeMetal = 0;
	m_iUpgradeMetalRequired = SENTRYGUN_UPGRADE_METAL;

	SetMaxHealth( SENTRYGUN_MAX_HEALTH );
	SetHealth( SENTRYGUN_MAX_HEALTH );

	// Rotate Details
	m_iRightBound = 45;
	m_iLeftBound = 315;
	m_iBaseTurnRate = 6;
	m_flFieldOfView = VIEW_FIELD_NARROW;

	// Give the Gun some ammo
	m_iAmmoShells = 0;
	m_iAmmoRockets = 0;
	m_iMaxAmmoShells = SENTRYGUN_MAX_SHELLS_1;
	m_iMaxAmmoRockets = SENTRYGUN_MAX_ROCKETS;

	m_iAmmoType = GetAmmoDef()->Index( "TF_AMMO_PRIMARY" );

	// Start searching for enemies
	m_hEnemy = NULL;

	// Pipes explode when they hit this
	m_takedamage = DAMAGE_AIM;

	m_flLastAttackedTime = 0;

	m_flHeavyBulletResist = SENTRYGUN_MINIGUN_RESIST_LVL_1;

	BaseClass::Spawn();

	SetViewOffset( SENTRYGUN_EYE_OFFSET_LEVEL_1 );

	UTIL_SetSize( this, SENTRYGUN_MINS, SENTRYGUN_MAXS );

	m_iState.Set( SENTRY_STATE_INACTIVE );

	SetContextThink( &CObjectSentrygun::SentryThink, gpGlobals->curtime + SENTRY_THINK_DELAY, SENTRYGUN_CONTEXT );
}
Пример #9
0
void cWolf::OnRightClicked(cPlayer & a_Player)
{
	if (!IsTame() && !IsAngry())
	{
		if (a_Player.GetEquippedItem().m_ItemType == E_ITEM_BONE)
		{
			if (!a_Player.IsGameModeCreative())
			{
				a_Player.GetInventory().RemoveOneEquippedItem();
			}

			if (m_World->GetTickRandomNumber(7) == 0)
			{
				SetMaxHealth(20);
				SetIsTame(true);
				SetOwner(a_Player.GetName());
				m_World->BroadcastEntityStatus(*this, ENTITY_STATUS_WOLF_TAMED);
			}
			else
			{
				m_World->BroadcastEntityStatus(*this, ENTITY_STATUS_WOLF_TAMING);
			}
		}
	}
	else if (IsTame())
	{
		if (a_Player.GetName() == m_OwnerName) // Is the player the owner of the dog?
		{
			if (a_Player.GetEquippedItem().m_ItemType == E_ITEM_DYE)
			{
				SetCollarColor(15 - a_Player.GetEquippedItem().m_ItemDamage);
				if (!a_Player.IsGameModeCreative())
				{
					a_Player.GetInventory().RemoveOneEquippedItem();
				}
			} 
			else if (IsSitting()) 
			{
				SetIsSitting(false);
			}
			else
			{
				SetIsSitting(true);
			}
		}
	}
	
	m_World->BroadcastEntityMetadata(*this);
}
Пример #10
0
void Pet::UpdateMaxHealth()
{
    if (!CanModifyStats())
        return;

    UnitMods unitMod = UNIT_MOD_HEALTH;
    float staminaBonus = (GetStat(STAT_STAMINA) - GetCreateStat(STAT_STAMINA)) * (CalculateScalingData()->healthScale / 100.0f);

    float value   = GetModifierValue(unitMod, BASE_VALUE) + GetCreateHealth() + staminaBonus;
    value  *= GetModifierValue(unitMod, BASE_PCT);
    value  += GetModifierValue(unitMod, TOTAL_VALUE);
    value  *= GetModifierValue(unitMod, TOTAL_PCT);

    SetMaxHealth((uint32)value);
}
void CASW_Barrel_Explosive::InitHealth()
{
	m_iMinHealthDmg = 0;
	m_iHealth = asw_barrel_health_base.GetInt();
	const float flHealthGrowth = asw_barrel_health_growth.GetFloat();
	m_iHealth = m_iHealth + m_iHealth * flHealthGrowth * ( ASWGameRules()->GetMissionDifficulty() - 1 );
	SetMaxHealth( m_iHealth );

	m_iExplosionDamage = 200.0f;
	/*
	int iExplosiveDamage = 120.0f;
	m_iExplosionDamage = iExplosiveDamage + iExplosiveDamage * flHealthGrowth * ( ASWGameRules()->GetMissionDifficulty() - 1 );
	//SetExplosiveRadius( 160.0f );
	*/
}
//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CNPC_CombineShot::Spawn(void)
{
	Precache();
	SetModel( "models/combine_soldier_shotgunner.mdl" );

	//Give him a random amount of grenades on spawn
	if (combine_shot_spawnwithgrenades.GetBool())
	{
		if (g_pGameRules->IsSkillLevel(SKILL_HARD))
		{
			m_iNumGrenades = random->RandomInt(2, 3);
		}
		else if (g_pGameRules->IsSkillLevel(SKILL_VERYHARD))
		{
			m_iNumGrenades = random->RandomInt(4, 6);
		}
		else if (g_pGameRules->IsSkillLevel(SKILL_NIGHTMARE))
		{
			m_iNumGrenades = random->RandomInt(8, 12);
		}
		else
		{
			m_iNumGrenades = random->RandomInt(0, 2);
		}
	}

	m_fIsElite = false;
	m_fIsAce = false;

	SetHealth( sk_combine_shot_health.GetFloat() );
	SetMaxHealth( sk_combine_shot_health.GetFloat() );
	SetKickDamage( sk_combine_shot_kick.GetFloat() );

	CapabilitiesAdd( bits_CAP_ANIMATEDFACE );
	CapabilitiesAdd( bits_CAP_MOVE_SHOOT );
	CapabilitiesAdd( bits_CAP_DOORS_GROUP );

	BaseClass::Spawn();

#if HL2_EPISODIC
	if (m_iUseMarch && !HasSpawnFlags(SF_NPC_START_EFFICIENT))
	{
		Msg( "Soldier %s is set to use march anim, but is not an efficient AI. The blended march anim can only be used for dead-ahead walks!\n", GetDebugName() );
	}
#endif
}
Пример #13
0
void GuardianSummon::Load(CreatureProto* proto, Unit* owner, LocationVector & position, uint32 spellid, int32 summonslot)
{
	Summon::Load(proto, owner, position, spellid, summonslot);

	SetPowerType(POWER_TYPE_MANA);
	SetMaxPower(POWER_TYPE_MANA, GetMaxPower(POWER_TYPE_MANA) + 28 + 10 * getLevel());
	SetPower(POWER_TYPE_MANA, GetPower(POWER_TYPE_MANA) + 28 + 10 * getLevel());
	setLevel(owner->getLevel());
	SetMaxHealth(GetMaxHealth() + 28 + 30 * getLevel());
	SetHealth(GetMaxHealth());
	SetType(CREATURE_TYPE_GUARDIAN);

	m_aiInterface->Init(this, AITYPE_PET , MOVEMENTTYPE_NONE, owner);
	m_aiInterface->SetUnitToFollow(owner);
	m_aiInterface->SetFollowDistance(3.0f);

	m_noRespawn = true;
}
//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CNPC_WpnScanner::Spawn( void )
{
	Precache();
	SetModel( STRING( GetModelName() ) );

	SetHealth( sk_wpnscanner_health.GetInt() );
	SetMaxHealth( GetHealth() );

	CapabilitiesAdd( bits_CAP_INNATE_MELEE_ATTACK1 );

	m_iMuzzleAttachment = LookupAttachment( "light" );

	BaseClass::Spawn();

	m_flAttackNearDist = 250;
	m_flAttackFarDist = 700;
	m_flAttackRange = 750;
}
Пример #15
0
//-----------------------------------------------------------------------------
// Raises the Sentrygun one level
//-----------------------------------------------------------------------------
void CObjectSentrygun::StartUpgrading( void )
{
	// Increase level
	m_iUpgradeLevel++;

	// more health
	int iMaxHealth = GetMaxHealth();
	SetMaxHealth( iMaxHealth * 1.2 );
	SetHealth( iMaxHealth * 1.2 );

	EmitSound( "Building_Sentrygun.Built" );
		
	switch( m_iUpgradeLevel )
	{
	case 2:
		SetModel( SENTRY_MODEL_LEVEL_2_UPGRADE );
		m_flHeavyBulletResist = SENTRYGUN_MINIGUN_RESIST_LVL_2;
		SetViewOffset( SENTRYGUN_EYE_OFFSET_LEVEL_2 );
		m_iMaxAmmoShells = SENTRYGUN_MAX_SHELLS_2;
		break;
	case 3:
		SetModel( SENTRY_MODEL_LEVEL_3_UPGRADE );
		m_iAmmoRockets = SENTRYGUN_MAX_ROCKETS;
		m_flHeavyBulletResist = SENTRYGUN_MINIGUN_RESIST_LVL_3;
		SetViewOffset( SENTRYGUN_EYE_OFFSET_LEVEL_3 );
		m_iMaxAmmoShells = SENTRYGUN_MAX_SHELLS_3;
		break;
	default:
		Assert(0);
		break;
	}

	// more ammo capability
	m_iAmmoShells = m_iMaxAmmoShells;

	m_iState.Set( SENTRY_STATE_UPGRADING );

	SetActivity( ACT_OBJ_UPGRADING );

	m_flUpgradeCompleteTime = gpGlobals->curtime + SENTRY_UPGRADE_DURATION;

	RemoveAllGestures();
}
Пример #16
0
void Totem::Summon(Unit* owner)
{
    // Mana Tide Totem should have 10% of caster's health
    if (GetSpell() == 16191)
    {
        SetMaxHealth(owner->GetMaxHealth()*10/100);
        SetHealth(GetMaxHealth());
    }

    owner->GetMap()->Add((Creature*)this);

    // select totem model in dependent from owner team
    CreatureInfo const *cinfo = GetCreatureInfo();
    if (owner->GetTypeId() == TYPEID_PLAYER && cinfo)
    {
        uint32 display_id = sObjectMgr.ChooseDisplayId(((Player*)owner)->GetTeam(), cinfo);
        CreatureModelInfo const *minfo = sObjectMgr.GetCreatureModelRandomGender(display_id);
        if (minfo)
            display_id = minfo->modelid;
        SetDisplayId(display_id);
    }

    AIM_Initialize();

    if (owner->GetTypeId() == TYPEID_UNIT && ((Creature*)owner)->AI())
        ((Creature*)owner)->AI()->JustSummoned((Creature*)this);

    // there are some totems, which exist just for their visual appeareance
    if (!GetSpell())
        return;

    switch(m_type)
    {
        case TOTEM_PASSIVE:
            CastSpell(this, GetSpell(), true);
            break;
        case TOTEM_STATUE:
            CastSpell(GetOwner(), GetSpell(), true);
            break;
        default: break;
    }
}
Пример #17
0
void Guardian::UpdateMaxHealth()
{
    UnitMods unitMod = UNIT_MOD_HEALTH;
    float stamina = GetStat(STAT_STAMINA) - GetCreateStat(STAT_STAMINA);

    float multiplicator;
    switch (GetEntry())
    {
        case ENTRY_BLOODWORM:       multiplicator = 1.0f;   break;
        case ENTRY_WATER_ELEMENTAL: multiplicator = 7.5;  break;
        default:                    multiplicator = 14.0f;  break;
    }

    float value = GetModifierValue(unitMod, BASE_VALUE) + GetCreateHealth();
    value *= GetModifierValue(unitMod, BASE_PCT);
    value += GetModifierValue(unitMod, TOTAL_VALUE) + stamina * multiplicator;
    value *= GetModifierValue(unitMod, TOTAL_PCT);

    SetMaxHealth((uint32)value);
}
Пример #18
0
void Guardian::UpdateMaxHealth()
{
    UnitMods unitMod = UNIT_MOD_HEALTH;
    float stamina = GetStat(STAT_STAMINA) - GetCreateStat(STAT_STAMINA);

    uint32 basehealth = 0;
    if (Unit* owner = GetCharmerOrOwner())
        basehealth = owner->GetMaxHealth();

    float multiplicator;
    switch (GetEntry())
    {
        case ENTRY_IMP:                 multiplicator = 0.30f;   break;
        case ENTRY_VOIDWALKER:          multiplicator = 0.50f;  break;
        case ENTRY_SUCCUBUS:            multiplicator = 0.45f;   break;
        case ENTRY_FELHUNTER:           multiplicator = 0.70f; break;
        case ENTRY_FELGUARD:            multiplicator = 0.75f;  break;
        case ENTRY_BLOODWORM:           multiplicator = 0.10f;   break;
        case ENTRY_GHOUL:               multiplicator = 0.75f;  break;
        case ENTRY_GARGOYLE:            multiplicator = 0.75f;  break;
        case ENTRY_WATER_ELEMENTAL:     multiplicator = 0.50f;  break;
        default:                        multiplicator = 0.70f;  break;
    }

    basehealth *= multiplicator;

    float value = GetModifierValue(unitMod, BASE_VALUE) + basehealth;
    value *= GetModifierValue(unitMod, BASE_PCT);
    value += GetModifierValue(unitMod, TOTAL_VALUE) + stamina * 10;
    value *= GetModifierValue(unitMod, TOTAL_PCT);

    // Glyph of Voidwalker
    if (GetEntry() == ENTRY_VOIDWALKER)
    {
        if (Player * owner = GetSpellModOwner())
            if (AuraEffect * auraEff = owner->GetAuraEffect(56247, 0))
                AddPct(value, auraEff->GetAmount());
    }

    SetMaxHealth((uint32)value);
}
Пример #19
0
CHeavyInfantry::CHeavyInfantry(void) : CEnemy(WEP_PISTOL)
{
    SetEnemyID(ENEMY_HEAVY);
    SetMaxHealth(200);
    SetHealth(GetMaxHealth());
//	SetImageID(CSGD_TextureManager::GetInstance()->LoadTexture("Resource\\Graphics\\HeavyInfantry_editor.png"));
    SetAnimation(CAnimationManager::GetInstance()->LoadAnimation("Resource\\Data\\Animations\\JeG_HeavyInfantry.bin"));
    GetAnimation()->currAnimation->Play();
    SetMoneyReward(25);
    SetRepReward(10);
    SetWidth(32);
    SetHeight(32);
    SetArmor(25);
    SetSpeed(25.0f);
    CEventSystem::GetInstance()->RegisterClient("big.bang",this);
    CEventSystem::GetInstance()->RegisterClient("form.up",this);
    CEventSystem::GetInstance()->RegisterClient("engage.player",this);
    CEventSystem::GetInstance()->RegisterClient("over.here",this);
    CEventSystem::GetInstance()->RegisterClient("player.detected",this);
    CEventSystem::GetInstance()->RegisterClient("fire.bullet",this);
}
Пример #20
0
void Guardian::UpdateMaxHealth()
{
    UnitMods unitMod = UNIT_MOD_HEALTH;
    float stamina = GetStat(STAT_STAMINA) - GetCreateStat(STAT_STAMINA);

    float multiplicator;
    switch(GetEntry())
    {
    case ENTRY_IMP:
        multiplicator = 8.4f;
        break;
    case ENTRY_VOIDWALKER:
        multiplicator = 11.0f;
        break;
    case ENTRY_SUCCUBUS:
        multiplicator = 9.1f;
        break;
    case ENTRY_FELHUNTER:
        multiplicator = 9.5f;
        break;
    case ENTRY_FELGUARD:
        multiplicator = 11.0f;
        break;
    case ENTRY_GHOUL:
        multiplicator = 5.4f;
        break;
    default:
        multiplicator = 10.0f;
        break;
    }

    float value   = GetModifierValue(unitMod, BASE_VALUE) + GetCreateHealth();
    value  *= GetModifierValue(unitMod, BASE_PCT);
    value  += GetModifierValue(unitMod, TOTAL_VALUE) + stamina * multiplicator;
    value  *= GetModifierValue(unitMod, TOTAL_PCT);

    SetMaxHealth((uint32)value);
}
Пример #21
0
void Guardian::UpdateMaxHealth()
{
    UnitMods unitMod = UNIT_MOD_HEALTH;
    //Ghouls have no base hp. only the one gained from stamina
    float stamina = GetStat(STAT_STAMINA) - (GetEntry()==ENTRY_GHOUL ? 0.0f : GetCreateStat(STAT_STAMINA));

    float multiplicator;
    switch(GetEntry())
    {
        case ENTRY_IMP:         multiplicator = 8.4f;   break;
        case ENTRY_VOIDWALKER:  multiplicator = 11.0f;  break;
        case ENTRY_SUCCUBUS:    multiplicator = 9.1f;   break;
        case ENTRY_FELHUNTER:   multiplicator = 9.5f;   break;
        case ENTRY_FELGUARD:    multiplicator = 11.0f;  break;
        case ENTRY_GHOUL:       multiplicator = 10.0f;   break;
		case ENTRY_FIRE_ELEMENTAL:       multiplicator = 1.0f;  break;
		case ENTRY_EARTH_ELEMENTAL:       multiplicator = 20.0f;  break;
		default:
			{
			if (isGuardian() || isTotem())
				multiplicator = 0.0f;                 // Guardians and Totems gain no hp from the owner
			else
			    multiplicator = 10.0f;                // Pets, and Minions do get health from stamina
			break;
			}
    }
	if (isHunterPet())
		multiplicator = 10.0f;
    
	//Ghouls have no base hp. only the one gained from stamina
	float value   = (GetEntry()==ENTRY_GHOUL ? 0 : GetModifierValue(unitMod, BASE_VALUE) + GetCreateHealth());
    value  *= GetModifierValue(unitMod, BASE_PCT);
    value  += GetModifierValue(unitMod, TOTAL_VALUE) + stamina * multiplicator;
    value  *= GetModifierValue(unitMod, TOTAL_PCT);

    SetMaxHealth((uint32)value);
}
Пример #22
0
void CASW_Simple_Alien::Spawn(void)
{
	BaseClass::Spawn();
	Precache();

	// appearance
	SetModel( SWARM_NEW_DRONE_MODEL );
	m_flAnimTime = gpGlobals->curtime;	
	SetCycle( 0 );
	PlayRunningAnimation();

	// collision
	SetHullType( HULL_MEDIUMBIG ); 
	UTIL_SetSize(this, Vector(-19,-19,0), Vector(19,19,69));
	SetSolid( SOLID_BBOX );
	AddSolidFlags( FSOLID_NOT_STANDABLE );
	SetCollisionGroup( ASW_COLLISION_GROUP_ALIEN );	

	// movement
	SetMoveType( MOVETYPE_STEP );
	m_fArrivedTolerance = 30.0f;

	// health
	m_iHealth = ASWGameRules()->ModifyAlienHealthBySkillLevel(asw_drone_health.GetInt());

	SetMaxHealth(m_iHealth);
	m_takedamage		= DAMAGE_YES;
		
	// state
	SetState(ASW_SIMPLE_ALIEN_IDLING);
	SetSleeping(true);
	m_fLastThinkTime = gpGlobals->curtime;
	SetThink( &CASW_Simple_Alien::SleepThink );
	SetNextThink( gpGlobals->curtime + random->RandomFloat(0.01f, 0.2f) );

	UpdateSleeping();
}
Пример #23
0
void Pet::UpdateMaxHealth()
{
    UnitMods unitMod = UNIT_MOD_HEALTH;
    float stamina = GetStat(STAT_STAMINA) - GetCreateStat(STAT_STAMINA);
    float multiplicator;

    // nesocips warlock pet stats calculation
    switch(GetEntry())
    {
        case 416:   multiplicator = 8.4f;  break; // imp
        case 1860:                                // voidwalker
        case 17252: multiplicator = 11.0f; break; // felguard
        case 1863:  multiplicator = 9.1f;  break; // succubus
        case 417:   multiplicator = 9.5f;  break; // felhunter
        default:    multiplicator = 10.0f; break;
    }

    float value   = GetModifierValue(unitMod, BASE_VALUE) + GetCreateHealth();
    value  *= GetModifierValue(unitMod, BASE_PCT);
    value  += GetModifierValue(unitMod, TOTAL_VALUE) + stamina * multiplicator;
    value  *= GetModifierValue(unitMod, TOTAL_PCT);

    SetMaxHealth((uint32)value);
}
Пример #24
0
void Creature::UpdateMaxHealth()
{
    float value = GetTotalAuraModValue(UNIT_MOD_HEALTH);
    SetMaxHealth((uint32)value);
}
Пример #25
0
void cWolf::OnRightClicked(cPlayer & a_Player)
{
	const cItem & EquippedItem = a_Player.GetEquippedItem();
	const int EquippedItemType = EquippedItem.m_ItemType;

	if (!IsTame() && !IsAngry())
	{
		// If the player is holding a bone, try to tame the wolf:
		if (EquippedItemType == E_ITEM_BONE)
		{
			if (!a_Player.IsGameModeCreative())
			{
				a_Player.GetInventory().RemoveOneEquippedItem();
			}

			if (GetRandomProvider().RandBool(0.125))
			{
				// Taming succeeded
				SetMaxHealth(20);
				SetIsTame(true);
				SetOwner(a_Player.GetName(), a_Player.GetUUID());
				m_World->BroadcastEntityStatus(*this, esWolfTamed);
				m_World->BroadcastParticleEffect("heart", static_cast<Vector3f>(GetPosition()), Vector3f{}, 0, 5);
			}
			else
			{
				// Taming failed
				m_World->BroadcastEntityStatus(*this, esWolfTaming);
				m_World->BroadcastParticleEffect("smoke", static_cast<Vector3f>(GetPosition()), Vector3f{}, 0, 5);
			}
		}
	}
	else if (IsTame())
	{
		// Feed the wolf, restoring its health, or dye its collar:
		switch (EquippedItemType)
		{
			case E_ITEM_RAW_BEEF:
			case E_ITEM_STEAK:
			case E_ITEM_RAW_PORKCHOP:
			case E_ITEM_COOKED_PORKCHOP:
			case E_ITEM_RAW_CHICKEN:
			case E_ITEM_COOKED_CHICKEN:
			case E_ITEM_ROTTEN_FLESH:
			{
				if (m_Health < m_MaxHealth)
				{
					Heal(ItemHandler(EquippedItemType)->GetFoodInfo(&EquippedItem).FoodLevel);
					if (!a_Player.IsGameModeCreative())
					{
						a_Player.GetInventory().RemoveOneEquippedItem();
					}
				}
				break;
			}
			case E_ITEM_DYE:
			{
				if (a_Player.GetUUID() == m_OwnerUUID)  // Is the player the owner of the dog?
				{
					SetCollarColor(EquippedItem.m_ItemDamage);
					if (!a_Player.IsGameModeCreative())
					{
						a_Player.GetInventory().RemoveOneEquippedItem();
					}
				}
				break;
			}
			default:
			{
				if (a_Player.GetUUID() == m_OwnerUUID)  // Is the player the owner of the dog?
				{
					SetIsSitting(!IsSitting());
				}
			}
		}
	}

	m_World->BroadcastEntityMetadata(*this);
}
Пример #26
0
cWither::cWither(void) :
	super("Wither", mtWither, "mob.wither.hurt", "mob.wither.death", 0.9, 4.0),
	m_WitherInvulnerableTicks(220)
{
	SetMaxHealth(300);
}
Пример #27
0
//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CObjectSentrygun::CObjectSentrygun()
{
	SetMaxHealth( SENTRYGUN_MAX_HEALTH );
	m_iHealth = SENTRYGUN_MAX_HEALTH;
	SetType( OBJ_SENTRYGUN );
}
Пример #28
0
cPlayer::cPlayer(cClientHandle* a_Client, const AString & a_PlayerName)
	: super(etPlayer, 0.6, 1.8)
	, m_bVisible(true)
	, m_FoodLevel(MAX_FOOD_LEVEL)
	, m_FoodSaturationLevel(5)
	, m_FoodTickTimer(0)
	, m_FoodExhaustionLevel(0)
	, m_FoodPoisonedTicksRemaining(0)
	, m_LastJumpHeight(0)
	, m_LastGroundHeight(0)
	, m_bTouchGround(false)
	, m_Stance(0.0)
	, m_Inventory(*this)
	, m_CurrentWindow(NULL)
	, m_InventoryWindow(NULL)
	, m_Color('-')
	, m_GameMode(eGameMode_NotSet)
	, m_IP("")
	, m_ClientHandle(a_Client)
	, m_NormalMaxSpeed(1.0)
	, m_SprintingMaxSpeed(1.3)
	, m_FlyingMaxSpeed(1.0)
	, m_IsCrouched(false)
	, m_IsSprinting(false)
	, m_IsFlying(false)
	, m_IsSwimming(false)
	, m_IsSubmerged(false)
	, m_IsFishing(false)
	, m_CanFly(false)
	, m_EatingFinishTick(-1)
	, m_LifetimeTotalXp(0)
	, m_CurrentXp(0)
	, m_bDirtyExperience(false)
	, m_IsChargingBow(false)
	, m_BowCharge(0)
	, m_FloaterID(-1)
	, m_Team(NULL)
{
	LOGD("Created a player object for \"%s\" @ \"%s\" at %p, ID %d", 
		a_PlayerName.c_str(), a_Client->GetIPString().c_str(),
		this, GetUniqueID()
	);
	
	m_InventoryWindow = new cInventoryWindow(*this);
	m_CurrentWindow = m_InventoryWindow;
	m_InventoryWindow->OpenedByPlayer(*this);

	SetMaxHealth(MAX_HEALTH);
	m_Health = MAX_HEALTH;
	
	cTimer t1;
	m_LastPlayerListTime = t1.GetNowTime();
	
	m_PlayerName = a_PlayerName;

	if (!LoadFromDisk())
	{
		m_Inventory.Clear();
		cWorld * DefaultWorld = cRoot::Get()->GetDefaultWorld();
		SetPosX(DefaultWorld->GetSpawnX());
		SetPosY(DefaultWorld->GetSpawnY());
		SetPosZ(DefaultWorld->GetSpawnZ());
		
		LOGD("Player \"%s\" is connecting for the first time, spawning at default world spawn {%.2f, %.2f, %.2f}",
			a_PlayerName.c_str(), GetPosX(), GetPosY(), GetPosZ()
		);
	}

	m_LastJumpHeight = (float)(GetPosY());
	m_LastGroundHeight = (float)(GetPosY());
	m_Stance = GetPosY() + 1.62;

	if (m_GameMode == gmNotSet)
	{
		cWorld * World = cRoot::Get()->GetWorld(GetLoadedWorldName());
		if (World == NULL)
		{
			World = cRoot::Get()->GetDefaultWorld();
		}
		if (World->IsGameModeCreative())
		{
			m_CanFly = true;
		}
	}
	
	cRoot::Get()->GetServer()->PlayerCreated(this);
}
Пример #29
0
cPlayer::cPlayer(cClientHandle* a_Client, const AString & a_PlayerName)
    : super(etPlayer, 0.6, 1.8)
    , m_GameMode(eGameMode_NotSet)
    , m_IP("")
    , m_LastBlockActionTime( 0 )
    , m_LastBlockActionCnt( 0 )
    , m_AirLevel( MAX_AIR_LEVEL )
    , m_AirTickTimer( DROWNING_TICKS )
    , m_bVisible( true )
    , m_LastGroundHeight( 0 )
    , m_bTouchGround( false )
    , m_Stance( 0.0 )
    , m_Inventory(*this)
    , m_CurrentWindow(NULL)
    , m_InventoryWindow(NULL)
    , m_TimeLastPickupCheck( 0.f )
    , m_Color('-')
    , m_ClientHandle( a_Client )
    , m_FoodLevel(MAX_FOOD_LEVEL)
    , m_FoodSaturationLevel(5)
    , m_FoodTickTimer(0)
    , m_FoodExhaustionLevel(0)
    , m_FoodPoisonedTicksRemaining(0)
    , m_NormalMaxSpeed(0.1)
    , m_SprintingMaxSpeed(0.13)
    , m_IsCrouched(false)
    , m_IsSprinting(false)
    , m_IsSwimming(false)
    , m_IsSubmerged(false)
    , m_EatingFinishTick(-1)
    , m_IsChargingBow(false)
    , m_BowCharge(0)
    , m_CurrentXp(0)
    , m_LifetimeTotalXp(0)
    , m_bDirtyExperience(false)
{
    LOGD("Created a player object for \"%s\" @ \"%s\" at %p, ID %d",
         a_PlayerName.c_str(), a_Client->GetIPString().c_str(),
         this, GetUniqueID()
        );

    m_InventoryWindow = new cInventoryWindow(*this);
    m_CurrentWindow = m_InventoryWindow;
    m_InventoryWindow->OpenedByPlayer(*this);

    SetMaxHealth(MAX_HEALTH);
    m_Health = MAX_HEALTH;

    cTimer t1;
    m_LastPlayerListTime = t1.GetNowTime();

    m_TimeLastTeleportPacket = 0;
    m_TimeLastPickupCheck = 0;

    m_PlayerName = a_PlayerName;
    m_bDirtyPosition = true; // So chunks are streamed to player at spawn

    if (!LoadFromDisk())
    {
        m_Inventory.Clear();
        SetPosX(cRoot::Get()->GetDefaultWorld()->GetSpawnX());
        SetPosY(cRoot::Get()->GetDefaultWorld()->GetSpawnY());
        SetPosZ(cRoot::Get()->GetDefaultWorld()->GetSpawnZ());

        LOGD("Player \"%s\" is connecting for the first time, spawning at default world spawn {%.2f, %.2f, %.2f}",
             a_PlayerName.c_str(), GetPosX(), GetPosY(), GetPosZ()
            );
    }
    m_LastJumpHeight = (float)(GetPosY());
    m_LastGroundHeight = (float)(GetPosY());
    m_Stance = GetPosY() + 1.62;

    cRoot::Get()->GetServer()->PlayerCreated(this);
}
Пример #30
0
void TempSummon::InitStats(uint32 duration)
{
    ASSERT(!isPet());

    m_timer = duration;
    m_lifetime = duration;

    if (m_type == TEMPSUMMON_MANUAL_DESPAWN)
        m_type = (duration == 0) ? TEMPSUMMON_DEAD_DESPAWN : TEMPSUMMON_TIMED_DESPAWN;

    Unit* owner = GetSummoner();

    if (owner && isTrigger() && m_spells[0])
    {
        setFaction(owner->getFaction());
        SetLevel(owner->getLevel());
        if (owner->GetTypeId() == TYPEID_PLAYER)
            m_ControlledByPlayer = true;
    }

    if (!m_Properties)
        return;

    // Fix Force of Nature treants stats
    if (owner && owner->getClass() == CLASS_DRUID && owner->HasSpell(106737))
    {
        float damage = 0.0f;

        switch (GetEntry())
        {
        case ENTRY_TREANT_RESTO:
        case ENTRY_TREANT_BALANCE:
            SetMaxHealth(owner->CountPctFromMaxHealth(40));
            break;
        case ENTRY_TREANT_GUARDIAN:
            SetMaxHealth(owner->CountPctFromMaxHealth(40));
            // (Attack power / 14 * 2 * 0.75) * 0.2f
            damage = ((owner->GetTotalAttackPowerValue(BASE_ATTACK) / 14.0f) * 2.0f * 0.75f) * 0.2f;
            SetStatFloatValue(UNIT_FIELD_MINDAMAGE, damage);
            SetStatFloatValue(UNIT_FIELD_MAXDAMAGE, damage);
        case ENTRY_TREANT_FERAL:
            SetMaxHealth(owner->CountPctFromMaxHealth(40));
            // Attack power / 14 * 2 * 0.75
            damage = (owner->GetTotalAttackPowerValue(BASE_ATTACK) / 14.0f) * 2.0f * 0.75f;
            SetStatFloatValue(UNIT_FIELD_MINDAMAGE, damage);
            SetStatFloatValue(UNIT_FIELD_MAXDAMAGE, damage);
        default:
            break;
        }
    }

    if (owner)
    {
        if (uint32 slot = m_Properties->Slot)
        {
            if (owner->m_SummonSlot[slot] && owner->m_SummonSlot[slot] != GetGUID())
            {
                Creature* oldSummon = GetMap()->GetCreature(owner->m_SummonSlot[slot]);
                if (oldSummon && oldSummon->IsSummon())
                    oldSummon->ToTempSummon()->UnSummon();
            }
            owner->m_SummonSlot[slot] = GetGUID();
        }
    }

    if (m_Properties->Faction)
        setFaction(m_Properties->Faction);
    else if (IsVehicle() && owner) // properties should be vehicle
        setFaction(owner->getFaction());
}