/// <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); }