Пример #1
0
        public Order(Ability ability, Actor actor, Actor targetActor = null, Vector2? targetLocation = null)
        {
            if (ability == null)
                throw new ArgumentNullException("ability");

            if (targetActor == null && targetLocation == null)
                throw new ArgumentNullException("targetActor OR targetLocation");

            if (targetActor != null && targetLocation != null)
                throw new ArgumentException("Cannot specify both target actor and target location");

            if (ability.TargettingType == TargettingTypes.Hostile && targetActor.Faction == actor.Faction)
                throw new ArgumentException("Ability " + ability.Name + " must target hostile actors.");

            if (ability.TargettingType == TargettingTypes.Friendly && targetActor.Faction != actor.Faction)
                throw new ArgumentException("Ability " + ability.Name + " must target friendly actors.");

            if (ability.TargettingType == TargettingTypes.Self && targetActor != actor)
                throw new ArgumentException("Ability " + ability.Name + " must target self.");

            if (ability.TargettingType == TargettingTypes.Location && targetLocation == null)
                throw new ArgumentException("Ability " + ability.Name + " must target a location.");

            this.Ability = ability;
            this.TargetActor = targetActor;
            this.TargetLocation = targetLocation;
        }
Пример #2
0
 public TargetingStrategyButton(ContentControl container, Actor actor, TargetingStrategy strategy, Texture2D texture)
 {
     this.container = container;
     this.Actor = actor;
     this.TargetingStrategy = strategy;
     this.texture = texture;
 }
Пример #3
0
        public EquipmentScreen(Player player, IEnumerable<Actor> actors, Actor actor)
        {
            this.player = player;
            this.actors = new List<Actor>(actors);
            this.currentActor = actor;

            player.Inventory.Sort((i1, i2) => i1.ArmorClass.CompareTo(i2.ArmorClass));
        }
Пример #4
0
        public ActorModel(Actor actor, Texture2D texture, ContentManager contentManager, GraphicsDevice graphicsDevice, Effect effect)
        {
            this.contentManager = contentManager;
            this.graphicsDevice = graphicsDevice;
            this.effect = effect;
            this.texture = texture;

            this.Actor = actor;
        }
Пример #5
0
 public AbilityButton(ContentControl container, Actor actor, Ability ability, Texture2D texture, Texture2D blankTexture, SpriteFont font)
 {
     this.container = container;
     this.Actor = actor;
     this.Ability = ability;
     this.texture = texture;
     this.blankTexture = blankTexture;
     this.font = font;
 }
Пример #6
0
 public OrderButton(ContentControl container, Actor actor, Order order, Texture2D texture, Texture2D blankTexture, Texture2D targetTexture, SpriteFont font)
 {
     this.container = container;
     this.Actor = actor;
     this.Order = order;
     this.texture = texture;
     this.blankTexture = blankTexture;
     this.targetTexture = targetTexture;
     this.font = font;
 }
Пример #7
0
        public override void Execute(EncounterDefinition encounterDefinition, Battle battle)
        {
            var actorDefinition = encounterDefinition.Actors.SingleOrDefault(x => x.Id == ActorId);

            var actor = new Actor(actorDefinition)
            {
                Position = Position,
                Direction = Vector2.Normalize(new Vector2(-1, -1)),
                TargettingStrategy = TargettingStrategies.Threat,
            };

            battle.Actors.Add(actor);
        }
Пример #8
0
        public AdvancedActorModel(Actor actor, Model model, ContentManager contentManager)
        {
            this.contentManager = contentManager;
            this.Actor = actor;
            this.Model = model;

            var skinningData = model.Tag as SkinningData;
            AnimationPlayer = new AnimationPlayer(skinningData);
            if (skinningData.AnimationClips.ContainsKey("Stand"))
                AnimationPlayer.StartClip(skinningData.AnimationClips["Stand"], true);
            else
                AnimationPlayer.StartClip(skinningData.AnimationClips.First().Value, true);
            AnimationPlayer.Update(TimeSpan.FromSeconds(0), true, Matrix.Identity);
        }
Пример #9
0
        public Shadow(GraphicsDevice graphicsDevice, Effect effect, Texture2D texture, Actor actor)
        {
            this.graphicsDevice = graphicsDevice;
            this.effect = effect;
            this.texture = texture;
            this.actor = actor;

            vertices = new VertexPositionTexture[6];
            vertices[0] = new VertexPositionTexture(new Vector3(-1, 0, -1), new Vector2(0, 0));
            vertices[1] = new VertexPositionTexture(new Vector3(1, 0, -1), new Vector2(1, 0));
            vertices[2] = new VertexPositionTexture(new Vector3(-1, 0, 1), new Vector2(0, 1));
            vertices[3] = new VertexPositionTexture(new Vector3(1, 0, -1), new Vector2(1, 0));
            vertices[4] = new VertexPositionTexture(new Vector3(1, 0, 1), new Vector2(1, 1));
            vertices[5] = new VertexPositionTexture(new Vector3(-1, 0, 1), new Vector2(0, 1));
        }
Пример #10
0
        public AbilityAnimation(Actor actor, GraphicsDevice graphicsDevice, Effect billboardEffect, Texture2D texture)
        {
            this.actor = actor;
            this.graphicsDevice = graphicsDevice;
            this.billboardEffect = billboardEffect;
            this.texture = texture;

            vertices = new VertexPositionTexture[6];
            vertices[0] = new VertexPositionTexture(new Vector3(-1, 0, -1), new Vector2(0, 0));
            vertices[1] = new VertexPositionTexture(new Vector3(1, 0, -1), new Vector2(1, 0));
            vertices[2] = new VertexPositionTexture(new Vector3(-1, 0, 1), new Vector2(0, 1));
            vertices[3] = new VertexPositionTexture(new Vector3(1, 0, -1), new Vector2(1, 0));
            vertices[4] = new VertexPositionTexture(new Vector3(1, 0, 1), new Vector2(1, 1));
            vertices[5] = new VertexPositionTexture(new Vector3(-1, 0, 1), new Vector2(0, 1));
        }
Пример #11
0
        private Color GetAbilityColor(Actor actor, Ability ability)
        {
            if (actor != null)
            {
                if (ability.ManaCost != 0 && actor.ResourceType != ActorResourceTypes.Mana)
                    return Color.Salmon;

                if (ability.EnergyCost != 0 && actor.ResourceType != ActorResourceTypes.Energy)
                    return Color.Salmon;
            }

            return Color.LightGray;
        }
Пример #12
0
 private void BuyAbility(Actor actor, Ability ability)
 {
     if (actor != null && ability != null)
     {
         //player.Gold -= actor.Cost;
         actor.Abilities.Add(ability);
         availableAbilities.Remove(ability);
     }
 }
Пример #13
0
 public static float DistanceFrom(this Vector2 position, Actor actor)
 {
     return (actor.Position - position).Length();
 }
Пример #14
0
 public static float DistanceFrom(this Actor actor, Actor target)
 {
     return (target.Position - actor.Position).Length();
 }
Пример #15
0
        public void TargetActor(Actor target)
        {
            if (IsAlive && PlayerControlled)
            {
                Targets.Clear();
                Orders.Clear();
                OrderedDestination = null;

                if (!Targets.Contains(target))
                    Targets.Enqueue(target);
            }
        }
Пример #16
0
        private void FindMouseOverActor(MouseState mouseState, Vector2 mouseWorldLocation)
        {
            if (mouseState.X > 0 && mouseState.X < 150 && mouseState.Y > 0 && mouseState.Y < 50 * battle.Actors.Count)
                mouseOverActor = battle.Actors[mouseState.Y / 50];
            else
                mouseOverActor = null;

            foreach (var actor in battle.Actors.Where(x => x.IsAlive))
            {
                if ((actor.Position - mouseWorldLocation).Length() < actor.Diameter)
                    mouseOverActor = actor;
            }
        }
Пример #17
0
        private void UpdateAbilityList(Actor actor)
        {
            //var index = abilitiesListBox.SelectedIndex;

            //abilitiesListBox.Items.Clear();

            //if (actor != null)
            //{
            //    actor.Abilities.ForEach(ability =>
            //    {
            //        abilitiesListBox.Items.Add(
            //            ability,
            //            new AbilityTooltip(actor, ability),
            //            Color.Yellow);
            //    });
            //}
            //abilitiesListBox.SelectedIndex = index;
        }
Пример #18
0
        private bool ValidLocationAreaTarget(Actor actor, Actor target, Ability ability, Vector2 location)
        {
            if (target.Faction == actor.Faction && ability.TargettingType == TargettingTypes.Hostile)
                return false;

            if (target.Faction != actor.Faction && ability.TargettingType == TargettingTypes.Friendly)
                return false;

            if (target.Faction == actor.Faction && ability.TargettingType == TargettingTypes.Location)
                return false;

            if (target.DistanceFrom(location) <= ability.Area + target.Radius)
                return true;

            return false;
        }
Пример #19
0
 private void SpawnProjectile(Actor actor, Actor target, Ability ability)
 {
     Projectiles.Add(new Projectile
     {
         Ability = ability,
         Owner = actor,
         Target = target,
         Position = new Vector3(actor.Position, actor.Radius),
         Speed = ability.SpawnsProjectile.Speed,
         ModelName = ability.SpawnsProjectile.ModelName,
         TextureName = ability.SpawnsProjectile.TextureName
     });
 }
Пример #20
0
        private bool ValidPointBlankAreaTarget(Actor actor, Actor target, Ability ability)
        {
            if (target.Faction == actor.Faction && ability.TargettingType == TargettingTypes.Hostile)
                return false;

            if (target.Faction != actor.Faction && ability.TargettingType == TargettingTypes.Friendly)
                return false;

            if (target.DistanceFrom(actor) <= ability.Area + target.Radius)
                return true;

            return false;
        }
Пример #21
0
        private Color GetRangeColor(Actor actor)
        {
            if (actor.CurrentOrder == null)
                return Color.LightGray;

            var target = actor.CurrentOrder.GetTargetLocation();
            if (target.DistanceFrom(actor).In(ability.Range + actor.Radius + actor.CurrentOrder.GetTargetRadius()))
                return Color.LightGray;

            return Color.Tomato;
        }
Пример #22
0
 private void IssueOrder(Actor actor, Order order)
 {
     if (isPaused)
         actor.Orders.Add(order);
     else
         actor.Orders.Insert(0, order);
 }
Пример #23
0
 private void SellAbility(Actor actor, Ability ability)
 {
     if (actor != null && ability != null && actor.Abilities.Contains(ability))
     {
         //player.Gold += actor.Cost / 4;
         actor.Abilities.Remove(ability);
         availableAbilities.Add(ability);
     }
 }
Пример #24
0
        private bool UseOrder(Turn turn, Actor actor, Order order)
        {
            var ability = order.Ability;

            if (!ability.Cooldown.IsReady)
                return false;

            if (ability.DamageType == DamageTypes.SingleTarget)
            {
                var abilityTarget = order.TargetActor;

                if (abilityTarget != null && abilityTarget.IsAlive)
                {
                    if (ability.TargettingType == TargettingTypes.Hostile && actor.Faction == abilityTarget.Faction)
                        return false;

                    if (ability.TargettingType == TargettingTypes.Friendly && actor.Faction != abilityTarget.Faction)
                        return false;

                    if (order.GetTargetLocation().DistanceFrom(actor).In(ability.Range + actor.Radius + abilityTarget.Radius))
                    {
                        actor.CurrentOrder = order;
                        actor.CastingProgress = new Cooldown(ability.Duration);
                        actor.CastingProgress.Incur();
                        if (ability.IsChanneled)
                        {
                            actor.ChannelProgress = new Cooldown(1.0f);
                            actor.ChannelProgress.Incur();
                        }

                        return true;
                    }
                }
            }
            else if (ability.DamageType == DamageTypes.PointBlankArea)
            {
                    actor.CurrentOrder = order;
                    actor.CastingProgress = new Cooldown(ability.Duration);
                    actor.CastingProgress.Incur();
                    if (ability.IsChanneled)
                    {
                        actor.ChannelProgress = new Cooldown(1.0f);
                        actor.ChannelProgress.Incur();
                    }

                    return true;
            }
            else if (ability.DamageType == DamageTypes.Cleave)
            {
                var primaryTarget = order.TargetActor;

                if (primaryTarget != null && primaryTarget.IsAlive)
                {
                    if (ability.TargettingType == TargettingTypes.Hostile && actor.Faction == primaryTarget.Faction)
                        return false;

                    if (ability.TargettingType == TargettingTypes.Friendly && actor.Faction != primaryTarget.Faction)
                        return false;

                    if (order.GetTargetLocation().DistanceFrom(actor).In(ability.Range + actor.Radius + order.GetTargetRadius()))
                    {
                        actor.CurrentOrder = order;
                        actor.CastingProgress = new Cooldown(ability.Duration);
                        actor.CastingProgress.Incur();
                        if (ability.IsChanneled)
                        {
                            actor.ChannelProgress = new Cooldown(1.0f);
                            actor.ChannelProgress.Incur();
                        }

                        return true;
                    }
                }
            }
            else if (ability.DamageType == DamageTypes.Location)
            {
                if (order.GetTargetLocation().DistanceFrom(actor).In(ability.Range + actor.Radius))
                {
                    actor.CurrentOrder = order;
                    actor.CastingProgress = new Cooldown(ability.Duration);
                    actor.CastingProgress.Incur();
                    if (ability.IsChanneled)
                    {
                        actor.ChannelProgress = new Cooldown(1.0f);
                        actor.ChannelProgress.Incur();
                    }

                    return true;
                }
            }

            return false;
        }
Пример #25
0
        private void SellHero(Actor hero)
        {
            if (hero != null)
            {
                player.Gold += hero.Cost / 4;

                foreach (var item in hero.Equipment.ToArray())
                    hero.Unequip(player, item);

                player.Heroes.Remove(hero);
                //availableHeroes.Add(hero);
            }
        }
Пример #26
0
 public void QueueTargetActor(Actor target)
 {
     if (IsAlive && PlayerControlled)
     {
         if (!Targets.Contains(target))
             Targets.Enqueue(target);
     }
 }
Пример #27
0
        private void UpdateEquipmentList(Actor actor)
        {
            //var index = equipmentListBox.SelectedIndex;

            //equipmentListBox.Items.Clear();

            //if (actor != null)
            //{
            //    actor.Equipment.ForEach(item =>
            //    {
            //        equipmentListBox.Items.Add(
            //            item,
            //            new ItemTooltip(item) { ShowZeroValues = false },
            //            ItemTooltip.GetItemColor(item.Rarity));
            //    });
            //}
            //equipmentListBox.SelectedIndex = index;
        }
Пример #28
0
        public float CalculateHealing(Actor actor, Actor target)
        {
            var value = (actor.CurrentStatistics.For<AttackPower>().Value * AttackPowerScale + actor.CurrentStatistics.For<SpellPower>().Value * SpellPowerScale + Value);
            value = random.Between(value * actor.CurrentStatistics.For<Precision>().Chance, value);
            value = value * actor.CurrentStatistics.For<HealingDone>().Value;
            value = value * target.CurrentStatistics.For<HealingTaken>().Value;

            return value;
        }
Пример #29
0
        private void prevActorButton_Click()
        {
            var index = actors.IndexOf(currentActor);
            index = (index - 1 + actors.Count) % actors.Count;
            currentActor = actors[index];

            UpdateEquipmentList();
            UpdateInventoryList();
        }
Пример #30
0
        private void RunActorAuras(float deltaTime, Turn turn, Actor actor)
        {
            var damageDone = 0f;

            foreach (var aura in actor.Auras)
            {
                aura.Cooldown.Cool(deltaTime);
                aura.Duration -= deltaTime;

                if (aura.Cooldown.IsReady)
                {
                    var combatTable = new CombatTable(new Random(), aura.Owner.CurrentStatistics, actor.CurrentStatistics);
                    var roll = combatTable.Roll();
                    var damage = aura.Damage.CalculateDamage(aura.Owner, actor);
                    var healing = aura.Healing.CalculateHealing(aura.Owner, actor);
                    if (roll.IsCrit)
                    {
                        damage *= 2;
                        healing *= 2;
                    }

                    if (damage > 0)
                    {
                        damageDone += damage;
                        Event.Raise(new ActorTookDamage { Source = aura.Owner, Target = actor, Damage = damage, IsCrit = roll.IsCrit });
                        turn.Events.Add(new OldEvent(EventTypes.AuraDamage) { Actor = aura.Owner, Target = actor, Damage = damage });
                        actor.CurrentHealth -= damage;
                    }
                    if (healing > 0)
                    {
                        Event.Raise(new ActorWasHealed { Source = aura.Owner, Target = actor, Healing = healing, IsCrit = roll.IsCrit });
                        turn.Events.Add(new OldEvent(EventTypes.AuraHealing) { Actor = aura.Owner, Target = actor, Healing = healing });
                        actor.CurrentHealth += healing;
                    }
                    aura.Cooldown.Incur();
                }
            }

            if (damageDone > 0)
                actor.Auras.RemoveAll(x => x.BreaksOnDamage);

            actor.Auras.ForEach(aura =>
            {
                if (aura.Duration <= 0f)
                {
                    turn.Events.Add(new OldEvent(EventTypes.AuraExpired) { Actor = actor, Target = actor });
                }
            });

            actor.Auras.RemoveAll(aura => aura.Duration <= 0f);
        }