/// <summary>
/// Détruit la ward de la team adverse au héros passé en paramètre sur cet emplacement.
/// Retourne vrai si la ward a pu être détruite, false si aucune ward de la team
/// n'a été trouvée.
/// </summary>
public bool DestroyWard(EntityHero owner)
{
EntityType team = owner.Type;
if (team.HasFlag(EntityType.Team2))
{
if (m_team1Ward == null)
{
return(false);
}
m_team1WardOwner.WardCount--;
m_team1Ward.Die();
m_team1Ward = null;
}
else
{
if (m_team2Ward == null)
{
return(false);
}
m_team2WardOwner.WardCount--;
m_team2Ward.Die();
m_team2Ward = null;
}
return(true);
}
/// <summary>
/// Obtient les signaux à destination du héros passé en paramètre.
/// </summary>
/// <param name="hero"></param>
/// <returns></returns>
public List <Signals.Signal> GetSignals(Entities.EntityHero hero)
{
List <Signals.Signal> signals = new List <Signals.Signal>();
foreach (var signal in m_thisFrameSignals)
{
if (signal.SourceEntity != hero.ID)
{
if (signal.Team == (hero.Type & EntityType.Teams))
{
signals.Add(signal);
}
}
}
return(signals);
}
/// <summary>
/// Ajoute un héro à la scène.
/// /!\ Cet appel doit survenir avant l'appel à initialize.
/// </summary>
/// <param name="hero"></param>
public void AddHero(int clientId, Entities.EntityHero hero, Controlers.ControlerBase controler)
{
if (__initDone)
{
return;
}
// throw new Exceptions.IdiotProgrammerException("L'appel à AddHero est impossible quand la phase de jeu a été initialisée");
// Génère un id de contrôleur.
int controlerId = hero.ID;
// Mappe l'id du client à l'id du contrôleur.
m_clientIdToControlerId[clientId] = controlerId;
// Enregistre le contrôleur.
lock (ControlerLock)
Controlers.Add(controlerId, controler);
}
/// <summary>
/// Retourne la durée effective de l'altération d'état en prenant en compte les différents
/// bonus des altérations.
/// </summary>
public float GetDuration(EntityBase source)
{
float duration = BaseDuration;
// Application des bonus de rôles.
if (source is EntityHero)
{
RoleConstants constants = GameServer.GetScene().Constants.Roles;
EntityHero hero = (EntityHero)source;
switch (hero.Role)
{
case EntityHeroRole.Fighter:
if (Type.HasFlag(StateAlterationType.Stealth))
{
duration *= constants.FighterStealthDurationMultiplier;
}
break;
case EntityHeroRole.Mage:
if (Type.HasFlag(StateAlterationType.Silence))
{
duration *= constants.MageSilenceDurationMultiplier;
}
else if (Type.HasFlag(StateAlterationType.Root))
{
duration *= constants.MageRootDurationMultiplier;
}
else if (Type.HasFlag(StateAlterationType.Sight) | Type.HasFlag(StateAlterationType.TrueSight))
{
duration *= constants.MageSightDurationMultiplier;
}
break;
case EntityHeroRole.Tank:
if (Type.HasFlag(StateAlterationType.Stun))
{
duration *= constants.TankStunDurationMultiplier;
}
break;
}
}
return(duration);
}
/// <summary>
/// Pose une ward sur cet emplacement.
/// Retourne vrai si la ward a pu être posée.
/// </summary>
public bool PutWard(EntityHero owner)
{
// Vérifie que le nombre de ward max n'a pas été posé.
if (owner.WardCount >= GameServer.GetScene().Constants.Vision.MaxWardsPerHero)
{
return(false);
}
// Pose la ward
if (owner.Type.HasFlag(EntityType.Team1))
{
if (m_team1Ward != null)
{
return(false);
}
m_team1WardOwner = owner;
m_team1Ward = new EntityWard()
{
Type = EntityType.Team1 | EntityType.Ward, Position = Position
};
GameServer.GetMap().AddEntity(m_team1Ward);
}
else
{
if (m_team2Ward != null)
{
return(false);
}
m_team2WardOwner = owner;
m_team2Ward = new EntityWard()
{
Type = EntityType.Team2 | EntityType.Ward, Position = Position
};
GameServer.GetMap().AddEntity(m_team2Ward);
}
owner.WardCount++;
return(true);
}
/// <summary>
/// Calcule la valeur totale de l'altération d'état en fonction des différents scalings passés en
/// paramètres au moyen de "ratios".
///
/// Cette fonction garantit que les ratios ne seront calculés que pour les scalings demandés.
///
/// Par exemple, si scaling ratios ne contient pas SrcAd, source.GetAttackDamage() ne sera pas appelé.
/// </summary>
public float GetValue(EntityBase source, EntityBase destination, ScalingRatios ratios)
{
float totalValue = FlatValue;
if ((ratios & ScalingRatios.SrcAd) == ScalingRatios.SrcAd && SourcePercentADValue != 0)
{
totalValue += SourcePercentADValue * source.GetAttackDamage();
}
if ((ratios & ScalingRatios.SrcArmor) == ScalingRatios.SrcArmor && SourcePercentArmorValue != 0)
{
totalValue += SourcePercentArmorValue * source.GetArmor();
}
if ((ratios & ScalingRatios.SrcHP) == ScalingRatios.SrcHP && SourcePercentHPValue != 0)
{
totalValue += SourcePercentHPValue * source.GetHP();
}
if ((ratios & ScalingRatios.SrcMaxHP) == ScalingRatios.SrcMaxHP && SourcePercentMaxHPValue != 0)
{
totalValue += SourcePercentMaxHPValue * source.GetMaxHP();
}
if ((ratios & ScalingRatios.SrcAP) == ScalingRatios.SrcAP && SourcePercentAPValue != 0)
{
totalValue += SourcePercentAPValue * source.GetAbilityPower();
}
if ((ratios & ScalingRatios.SrcMR) == ScalingRatios.SrcMR && SourcePercentRMValue != 0)
{
totalValue += SourcePercentRMValue * source.GetMagicResist();
}
/*
* if ((ratios & ScalingRatios.DstAd) == ScalingRatios.DstAd)
* totalValue += DestPercentADValue * destination.GetAttackDamage();
* if ((ratios & ScalingRatios.DstArmor) == ScalingRatios.DstArmor)
* totalValue += DestPercentArmorValue * destination.GetArmor();
* if ((ratios & ScalingRatios.DstHP) == ScalingRatios.DstHP)
* totalValue += DestPercentHPValue * destination.GetHP();
* if ((ratios & ScalingRatios.DstMaxHP) == ScalingRatios.DstMaxHP)
* totalValue += DestPercentMaxHPValue * destination.GetMaxHP();
* if ((ratios & ScalingRatios.DstAP) == ScalingRatios.DstAP)
* totalValue += DestPercentAPValue * destination.GetAbilityPower();
* if ((ratios & ScalingRatios.SrcMR) == ScalingRatios.SrcMR)
* totalValue += DestPercentRMValue * destination.GetMagicResist();*/
// Application des bonus.
if (destination.Type.HasFlag(EntityType.Structure))
{
totalValue *= StructureBonus;
}
if (destination.Type.HasFlag(EntityType.Monster))
{
totalValue *= MonsterBonus;
}
if (destination.Type.HasFlag(EntityType.Virus))
{
totalValue *= VirusBonus;
}
// Application des bonus de rôles.
if (source is EntityHero)
{
RoleConstants constants = GameServer.GetScene().Constants.Roles;
EntityHero hero = (EntityHero)source;
switch (hero.Role)
{
case EntityHeroRole.Fighter:
if (Type.HasFlag(StateAlterationType.AttackSpeed))
{
totalValue *= constants.FighterAttackSpeedMultiplier;
}
else if (Type.HasFlag(StateAlterationType.AttackDamage))
{
totalValue *= constants.FighterAttackDamageMultiplier;
}
else if (Type.HasFlag(StateAlterationType.MagicDamageBuff))
{
totalValue *= constants.FighterMagicDamageMultiplier;
}
else if (Type.HasFlag(StateAlterationType.TrueDamage))
{
totalValue *= constants.FighterTrueDamageMultiplier;
}
break;
case EntityHeroRole.Mage:
if (Type.HasFlag(StateAlterationType.Heal))
{
totalValue *= constants.MageHealValueMultiplier;
}
else if (Type.HasFlag(StateAlterationType.Shield))
{
totalValue *= constants.MageShieldValueMultiplier;
}
break;
case EntityHeroRole.Tank:
if (Type.HasFlag(StateAlterationType.MoveSpeed))
{
totalValue *= constants.TankMoveSpeedBonusMultiplier;
}
else if (Type.HasFlag(StateAlterationType.ArmorBuff))
{
totalValue *= constants.TankArmorBonusMultiplier;
}
else if (Type.HasFlag(StateAlterationType.MagicResistBuff))
{
totalValue *= constants.TankRMBonusMultiplier;
}
break;
}
// Application du bonus des passifs uniques
switch (hero.UniquePassive)
{
case EntityUniquePassives.Altruistic:
// Soins augmentés
if (Type.HasFlag(StateAlterationType.Heal))
{
totalValue *= 1 + GameServer.GetScene().Constants.UniquePassives.AltruistHealBonus;
}
break;
}
}
return(totalValue);
// Note : ceci n'est pas équivalent au code ci dessous.
// Dans cette version les fonctions source.GetAttackDamage(), etc... sont toujours appelées.
/*
* return FlatValue +
* SourcePercentADValue * source.GetAttackDamage() * (int)(ratios & ScalingRatios.SrcAd) +
* SourcePercentArmorValue * source.GetArmor() * (int)(ratios & ScalingRatios.SrcArmor)+
* SourcePercentHPValue * source.HP * (int)(ratios & ScalingRatios.SrcHP) +
* SourcePercentMaxHPValue * source.MaxHP * (int)(ratios & ScalingRatios.SrcMaxHP) +
*
* DestPercentADValue * destination.GetAttackDamage() * (int)(ratios & ScalingRatios.DstAd) +
* DestPercentArmorValue * destination.GetArmor() * (int)(ratios & ScalingRatios.DstArmor) +
* DestPercentHPValue * destination.HP * (int)(ratios & ScalingRatios.DstHP) +
* DestPercentMaxHPValue * destination.MaxHP * (int)(ratios & ScalingRatios.DstMaxHP);*/
}
