/// <summary>
/// Indique au système de récompenses que des PVs d'un shield ont été consommés.
/// </summary>
/// <param name="shieldOwner">Entité dont le shield a été partiellement consommé.</param>
/// <param name="shieldProvider">Entité ayant fourni le shield.</param>
/// <param name="shieldAmount">Quantité de PVs enlevés au bouclier.</param>
public void NotifyShieldConsumption(EntityHero shieldOwner, EntityHero shieldProvider, float shieldAmount)
{
if (shieldProvider.Role == EntityHeroRole.Mage)
{
shieldProvider.PA += shieldAmount * GameServer.GetScene().Constants.Rewards.MagePAPerShieldHPConsumed;
}
}
/// <summary>
/// Indique au système de récompenses que des dégâts ont été infligés à une entité.
/// </summary>
/// <param name="source">Entité infligeant les dégâts.</param>
/// <param name="destination">Entité subissant les dégâts.</param>
/// <param name="damageAmount">Nombre de dégâts bruts subis par l'entité destination.</param>
public void NotifyDamageDealt(EntityBase source, EntityBase destination, float damageAmount)
{
EntityHero dst = destination as EntityHero;
EntityHero src = source as EntityHero;
if (src != null && dst != null)
{
AddAttacker(dst, src);
RewardConstants constants = GameServer.GetScene().Constants.Rewards;
// Distribue des PAs au Tank
if (dst.Role == EntityHeroRole.Tank)
{
// Vérifie qu'il y a des héros alliés en combat
EntityCollection inrange = GameServer.GetMap().Entities.GetAliveEntitiesInRange(dst.Position, constants.TankPAPerHPLostRange);
inrange = inrange.GetEntitiesByType((dst.Type & EntityType.Teams) | EntityType.Player);
if (inrange.Count != 0)
{
dst.PA += damageAmount * constants.TankPAPerHPLost;
}
}
// Distribues des PAs à l'attaquant si c'est un combattant.
if (src.Role == EntityHeroRole.Fighter)
{
src.PA += damageAmount * constants.FighterPAPerDamageDealt;
}
}
}
public void Init(EntityBase entity)
{
this.m_EntityHero = entity;
this.m_EntitySelf = this.m_EntityHero as EntityHero;
this.m_JoyData.name = "AttackJoy";
this.child = this.m_EntityHero.Child;
}
/// <summary>
/// Tente une upgrade du spell.
/// </summary>
public SpellUpgradeResult Upgrade()
{
if (!CanUpgrade)
{
return(SpellUpgradeResult.AlreadyMaxLevel);
}
EntityHero hero = SourceCaster as EntityHero;
if (hero != null)
{
float price = GameServer.GetScene().Constants.ActiveSpells.SpellUpgradeCost[Level];;
bool priceOK = hero.PA >= Level * price;
if (!priceOK)
{
return(SpellUpgradeResult.NotEnoughPA);
}
hero.PA -= price;
Level++;
return(SpellUpgradeResult.Success);
}
return(SpellUpgradeResult.AlreadyMaxLevel);
}
/// <summary>
/// Vends un consommable dans le slot donné du héros donné.
/// </summary>
public ShopTransactionResult SellConsummable(EntityHero hero, int slot)
{
// Vérifie la distance au shop.
float dst = Vector2.Distance(hero.Position, m_owner.Position);
if (dst > m_shopRange)
{
return(ShopTransactionResult.NotInShopRange);
}
// Slot out of range : erreur
if (slot < 0 || slot >= hero.Consummables.Length)
{
return(ShopTransactionResult.ProvidedSlotDoesNotExist);
}
// Consommable vide ?
bool emptySlot = hero.Consummables[slot].Model.ConsummableType == ConsummableType.Empty;
if (emptySlot)
{
return(ShopTransactionResult.NoItemToSell);
}
if (hero.Consummables[slot].Count <= 0)
{
return(ShopTransactionResult.NoItemToSell);
}
ConsummableModel model = hero.Consummables[slot].Model;
hero.PA += model.Price;
hero.Consummables[slot].Count--;
return(ShopTransactionResult.Success);
}
/// <summary>
/// Donne un buff au possesseur du consommable qui révèle les wards environnantes lors de la première utilisation.
/// La 2e utilisation supprime la ward la plus proche (si l'effet est encore actif).
/// </summary>
public override ConsummableUseResult Use(EntityHero owner)
{
if (!UsingStarted)
{
// Permet au héros de révéler les wards.
owner.AddAlteration(new StateAlteration("unward-consummable",
owner, new StateAlterationModel()
{
Type = StateAlterationType.WardSight,
BaseDuration = GameServer.GetScene().Constants.Vision.WardRevealDuration,
}, new StateAlterationParameters(), StateAlterationSource.Consumable));
RemainingTime = GameServer.GetScene().Constants.Vision.WardRevealDuration;
UsingStarted = true;
return(ConsummableUseResult.Success);
}
else
{
EntityWardPlacement nearest = GameServer.GetMap().Entities.
GetEntitiesByType(EntityType.WardPlacement).
GetAliveEntitiesInRange(owner.Position, owner.VisionRange, 0).
NearestFrom(owner.Position) as EntityWardPlacement;
// Détruire la ward détruit aussi le consommable.
if (nearest != null)
{
nearest.DestroyWard(owner);
owner.Stats.TotalWardsDestroyed++;
return(ConsummableUseResult.SuccessAndDestroyed);
}
}
return(ConsummableUseResult.Fail);
}
protected override void OnDeInit()
{
if (GameLogic.Self != null)
{
EntityHero self = GameLogic.Self;
self.OnHitted = (Action <EntityBase, long>)Delegate.Remove(self.OnHitted, new Action <EntityBase, long>(this.OnHitted));
}
}
/// <summary>
/// Crée une nouvelle instance de ShopInterface à partir du shop donné.
/// </summary>
/// <param name="shop"></param>
public ShopInterface(DeveloperConsole console, GuiManager mgr, EntityHero hero, Shop shop) : base(mgr)
{
Shop = shop;
Hero = hero;
m_console = console;
m_models = new Dictionary <GuiButton, EquipmentModel>();
SetupControls();
}
/// <summary>
/// Indique au système de récompenses qu'une unité a été tuée.
/// </summary>
/// <param name="unit">Unité tuée.</param>
/// <param name="killer">Unité ayant porté le dernier coup.</param>
public void NotifyUnitDeath(EntityBase unit, EntityHero killer)
{
RewardConstants constants = GameServer.GetScene().Constants.Rewards;
// Si l'unité est un Virus, on offre une récompense aux héros proches.
if (unit.Type.HasFlag(EntityType.Virus) || unit.Type.HasFlag(EntityType.Monster))
{
if (killer != null)
{
if (unit.Type.HasFlag(EntityType.Virus))
{
killer.Stats.TotalVirusSlain++;
}
if (unit.Type.HasFlag(EntityType.Monster))
{
killer.Stats.TotalNeutralMonstersSlain++;
}
}
foreach (EntityHero hero in m_allHeroes)
{
// Si le héros est dans l'équipe adverse du Virus/monstre tué.
if (!hero.Type.HasFlag(unit.Type & EntityType.Teams))
{
if (Vector2.DistanceSquared(hero.Position, unit.Position) <=
constants.VirusDeathRewardRange * constants.VirusDeathRewardRange)
{
hero.PA += constants.VirusDeathReward;
}
}
}
}
else if (unit.Type.HasFlag(EntityType.Tower))
{
foreach (EntityHero hero in m_allHeroes)
{
// Si le héros est dans l'équipe adverse de la tour tuée
// Applique le bonus du combattant lors de la destruction d'une tour.
if (!hero.Type.HasFlag(unit.Type & EntityType.Teams) &&
hero.Role == EntityHeroRole.Tank)
{
if (Vector2.DistanceSquared(hero.Position, unit.Position) <=
constants.TankTowerDestructionBonusRange * constants.TankTowerDestructionBonusRange)
{
hero.PA += constants.TankTowerDestructionBonus;
}
}
}
}
// Récompense du HUNTER
if (killer != null)
{
if (unit.Type.HasFlag(EntityType.Monster) && killer.UniquePassive == EntityUniquePassives.Hunter)
{
killer.PA += GameServer.GetScene().Constants.UniquePassives.HunterBonusGold;
}
}
}
/// <summary>
/// Vends l'équipement du type donné possédé par le héros pour un certain pourcentage
/// de sa valeur d'origine.
/// </summary>
public ShopTransactionResult Sell(EntityHero hero, EquipmentType equipKind)
{
EquipmentModel model = null;
// Vérifie la distance au shop.
float dst = Vector2.Distance(hero.Position, m_owner.Position);
if (dst > m_shopRange)
{
return(ShopTransactionResult.NotInShopRange);
}
switch (equipKind)
{
//case EquipmentType.Amulet: model = (hero.Amulet == null ? null : hero.Amulet.Model); hero.Amulet = null; break;
case EquipmentType.Armor: model = (hero.Armor == null ? null : hero.Armor.Model); hero.Armor = null; break;
case EquipmentType.Boots: model = (hero.Boots == null ? null : hero.Boots.Model); hero.Boots = null; break;
case EquipmentType.Weapon: model = (hero.Weapon == null ? null : hero.Weapon.Model); hero.Weapon = null; break;
case EquipmentType.WeaponEnchant:
if (hero.Weapon == null)
{
model = null;
}
else if (hero.Weapon.Enchant == null)
{
model = null;
}
else
{
model = hero.Weapon.Enchant;
}
if (model != null)
{
hero.Weapon.Enchant = null;
}
break;
case EquipmentType.Consummable: return(ShopTransactionResult.ItemDoesNotExist);
}
// Vérifie que le héros possède un équipement.
if (model == null)
{
return(ShopTransactionResult.NoItemToSell);
}
float factor = GameServer.GetScene().Constants.Structures.Shops.SellingPriceFactor;
hero.PA += factor * model.Price;
return(ShopTransactionResult.Success);
}
/// <summary>
/// Mets à jour le consommable.
/// Retourne true si le consommable doit être détruit.
/// </summary>
public virtual bool Update(GameTime time, EntityHero owner)
{
RemainingTime -= (float)time.ElapsedGameTime.TotalSeconds;
if (RemainingTime <= 0)
{
RemainingTime = 0;
}
return(false);
}
/// <summary>
/// Crée un nouveau contrôleur ayant le contrôle sur le héros donné.
/// </summary>
/// <param name="hero"></param>
public HumanControler(GameClient client, EntityHero hero) : base(hero)
{
m_client = client;
m_hero = hero;
EnhancedGuiManager = new EnhancedGui.GuiManager();
m_lobbyControler = new LobbyControler(client);
m_pickPhaseControler = new PickPhaseControler(client);
HeroName = "Nameless Hero !";
}
private void BeAbsorb(EntityHero _entity)
{
if ((!this.bStartAbsorb && (_entity != null)) && !_entity.GetIsDead())
{
this.AbsorbEntity = _entity;
this.bStartAbsorb = true;
this.mAbsorbTime = Updater.AliveTime;
}
}
/// <summary>
/// Indique au système de récompenses qu'une entité a reçu un buff.
/// </summary>
/// <param name="source">Entité ayant donné le buff.</param>
/// <param name="destination">Entité ayant reçu le buff.</param>
public void NotifyBuffReception(EntityBase source, EntityBase destination, StateAlterationModel alteration)
{
EntityHero dst = destination as EntityHero;
EntityHero src = source as EntityHero;
if (src != null && dst != null)
{
AddAssistant(dst, src);
}
}
/// <summary>
/// Crée une nouvelle instance de ConsummableStack.
/// </summary>
public ConsummableStack(EntityHero owner, ConsummableType type)
{
m_owner = owner;
Count = 1;
Model = GameServer.GetScene().ShopDB.GetConsummableModelByType(type);
if (Model == null)
{
throw new NotImplementedException("Modèle de consommable " + type + " non implémenté.");
}
}
protected override void OnInit()
{
EntityHero entity = base.m_Entity as EntityHero;
if ((entity != null) && (entity.FootDirection != null))
{
this.footDirection = (base.m_Entity as EntityHero).FootDirection.transform.Find("Direction").gameObject;
this.footDirection.SetActive(false);
}
}
/// <summary>
/// Retourne une liste de bottes disponibles pour le héros donné.
/// </summary>
public List <EquipmentModel> GetBoots(EntityHero hero)
{
List <EquipmentModel> items = new List <EquipmentModel>();
foreach (var item in m_database.Boots)
{
// TODO : un filtre éventuel.
items.Add(item);
}
return(items);
}
/// <summary>
/// Mets à jour le consommable.
/// </summary>
/// <returns>True si le consommable doit être supprimé.</returns>
public override bool Update(GameTime time, EntityHero owner)
{
base.Update(time, owner);
if (RemainingTime <= 0 && UsingStarted)
{
return(true);
}
return(false);
}
/// <summary>
/// Callback appelé lorsqu'un client se connecte au serveur.
/// </summary>
/// <param name="clientId"></param>
void CommandServer_ClientConnected(int clientId, string name)
{
// Crée le héros lié à ce client.
EntityHero hero = new EntityHero()
{
Type = EntityType.Team2Player, HP = 5000, Position = new Vector2(15 + clientId * 5, 15)
};
AddHero(clientId, hero, new Controlers.IAControler(hero)
{
HeroName = name
});
}
private void BeAbsorb(EntityHero _entity)
{
if (!this.bStartAbsorb && (_entity != null))
{
this.lastDis = 2.147484E+09f;
this.AbsorbEntity = _entity;
this.bStartAbsorb = true;
this.startscalez = 0f;
this.SetTrailScaleZ(this.startscalez);
this.mAbsorbStartTime = Updater.AliveTime;
this.mAbsoryUpdateTime = this.mAbsorbStartTime;
this.OnAbsorbStart();
}
}
/// <summary>
/// Upgrade l'équipement du type donné.
/// </summary>
public ShopTransactionResult UpgradeEquip(EntityHero hero, EquipmentType type)
{
switch (type)
{
case EquipmentType.Armor:
return(UpgradeArmor(hero));
case EquipmentType.Weapon:
return(UpgradeWeapon(hero));
case EquipmentType.Boots:
return(UpgradeBoots(hero));
}
return(ShopTransactionResult.UnavailableItem);
}
private void CreatePlayer()
{
GameObject obj2 = Object.Instantiate <GameObject>(ResourceManager.Load <GameObject>("Game/Player/PlayerNode"));
obj2.transform.parent = GameNode.m_Battle.transform;
int id = 0x3e9;
GameLogic.SelfAttribute.Init();
EntityHero component = obj2.GetComponent <EntityHero>();
component.Init(id);
component.transform.position = new Vector3(0f, 1000f, 0f);
GameLogic.SelfAttribute.InitBabies();
CameraControlM.Instance.ResetCameraPosition();
}
/// <summary>
/// Ajoute un assistant au héros donné.
/// </summary>
void AddAssistant(EntityHero hero, EntityHero assistant)
{
if (!m_assistants.ContainsKey(hero))
{
m_assistants.Add(hero, new EntityMemory());
}
if (!m_assistants[hero].ContainsKey(assistant))
{
m_assistants[hero].Add(assistant, new EntityMemoryRemainingTime(ASSIST_MEMORY));
}
else
{
m_assistants[hero][assistant].RemainingTime = ASSIST_MEMORY;
}
}
/// <summary>
/// Ajoute un attaqueur au héros donné.
/// </summary>
void AddAttacker(EntityHero hero, EntityHero attacker)
{
if (!m_attackers.ContainsKey(hero))
{
m_attackers.Add(hero, new EntityMemory());
}
if (!m_attackers[hero].ContainsKey(attacker))
{
m_attackers[hero].Add(attacker, new EntityMemoryRemainingTime(ASSIST_MEMORY));
}
else
{
m_attackers[hero][attacker].RemainingTime = ASSIST_MEMORY;
}
}
/// <summary>
/// Achète un consommable pour le héros donné, et le place dans le slot donné.
/// </summary>
public ShopTransactionResult PurchaseConsummable(EntityHero hero, int consummableId, int slot)
{
EquipmentModel equip = GetEquipmentById(consummableId);
if (equip == null || equip.Type != EquipmentType.Consummable)
{
return(ShopTransactionResult.ItemDoesNotExist);
}
ConsummableModel model = (ConsummableModel)equip;
if (equip.Price > hero.PA)
{
return(ShopTransactionResult.NotEnoughMoney);
}
float dst = Vector2.Distance(hero.Position, m_owner.Position);
if (dst > m_shopRange)
{
return(ShopTransactionResult.NotInShopRange);
}
// Slot out of range : erreur
if (slot < 0 || slot >= hero.Consummables.Length)
{
return(ShopTransactionResult.ProvidedSlotDoesNotExist);
}
bool emptySlot = hero.Consummables[slot].Model.ConsummableType == ConsummableType.Empty;
// Si un consommable d'un autre type est dans le slot, erreur
if (!emptySlot && (hero.Consummables[slot].Model.ConsummableType != model.ConsummableType))
{
return(ShopTransactionResult.NoSlotAvailableOnHero);
}
// Dépassement de la stack du consommable : erreur
if (hero.Consummables[slot].Count >= hero.Consummables[slot].Model.MaxStackSize)
{
return(ShopTransactionResult.StackOverflow);
}
// Achat !!
hero.Consummables[slot].Model = model;
hero.Consummables[slot].Count++;
hero.PA -= equip.Price;
return(ShopTransactionResult.Success);
}
/// <summary>
/// Place la ward sur l'emplacement à ward le plus proche du héros.
/// </summary>
public override ConsummableUseResult Use(EntityHero owner)
{
EntityWardPlacement nearest = GameServer.GetMap().Entities.
GetEntitiesByType(EntityType.WardPlacement).
GetAliveEntitiesInRange(owner.Position, GameServer.GetScene().Constants.Vision.WardPutRange, 0).
NearestFrom(owner.Position) as EntityWardPlacement;
// Pose la ward.
if (nearest != null)
{
nearest.PutWard(owner);
owner.Stats.TotalWardsUsed++;
UsingStarted = true;
return(ConsummableUseResult.SuccessAndDestroyed);
}
return(ConsummableUseResult.Fail);
}
/// <summary>
/// Initialise le contrôleur.
/// </summary>
void SetupControler()
{
if (!SpectateMode)
{
EntityHero hero = new EntityHero();
hero.Position = new Vector2(10, 10);
hero.Role = EntityHeroRole.Fighter;
hero.UniquePassive = EntityUniquePassives.Unshakable;
hero.Type = EntityType.Player | EntityType.Team1;
m_controler = new HumanControler(this, hero);
m_server.GetSrvScene().AddHero(GameServer.__INTERNAl_CLIENT_ID, hero, m_controler);
}
else
{
m_controler = new HumanControler(this, null);
}
m_controler.IsInSpectateMode = SpectateMode;
}
public Components.ShopInterface add_shop(int heroId)
{
if (heroId >= GameServer.GetMap().Heroes.Count || heroId < 0)
{
puts("Le héros " + heroId + " n'existe pas.");
}
// Héros
EntityHero entity = GameServer.GetMap().Heroes[heroId];
// Shop
var shops = GameServer.GetMap().Entities.GetEntitiesByType(EntityType.Shop | (entity.Type & EntityType.Teams));
if (shops.Count <= 0)
{
puts("Aucun shop n'existe pour la " + (entity.Type & EntityType.Teams) + "...");
}
return(new ShopInterface(m_console, m_baseControler.EnhancedGuiManager, entity, ((EntityShop)shops.First().Value).Shop));
}
/// <summary>
/// Indique au système de récompenses qu'une entité a été soignée.
/// </summary>
/// <param name="source">Entité ayant donné le heal.</param>
/// <param name="destination">Entité ayant reçu le heal.</param>
/// <param name="healAmount">Quantité de PVs soignés.</param>
public void NotifyHeal(EntityBase source, EntityBase destination, float healAmount)
{
EntityHero dst = destination as EntityHero;
EntityHero src = source as EntityHero;
if (src != null && dst != null)
{
AddAssistant(dst, src);
// Donne des HP au mage pour le soin, si l'entité soignée est
// en combat.
if (src.Role == EntityHeroRole.Mage)
{
if (dst.GetRecentlyAgressiveEntities().Count != 0)
{
src.PA += healAmount * GameServer.GetScene().Constants.Rewards.MageAssistBonus;
}
}
}
}
/// <summary>
/// Demande au shop de procéder si possible à l'upgrade de l'arme du héros donné.
/// </summary>
public ShopTransactionResult UpgradeWeapon(EntityHero hero)
{
// Vérifie la distance au shop.
float dst = Vector2.Distance(hero.Position, m_owner.Position);
if (dst > m_shopRange)
{
return(ShopTransactionResult.NotInShopRange);
}
// Le héros a-t-il une arme ?
if (hero.Weapon == null)
{
return(ShopTransactionResult.UnavailableItem);
}
// Vérification du niveau.
int nextLevel = hero.Weapon.Level + 1;
if (nextLevel >= hero.Weapon.Model.Upgrades.Count)
{
return(ShopTransactionResult.AlreadyMaxLevel);
}
// Vérification de l'argent disponible.
float price = hero.Weapon.Model.Upgrades[nextLevel].Cost;
if (price > hero.PA)
{
return(ShopTransactionResult.NotEnoughMoney);
}
// Si c'est bon : on procède.
hero.PA -= price;
hero.Weapon.Upgrade();
return(ShopTransactionResult.Success);
}
