public override void OnFinishTurn(Action action) { // Make some noise. LastNoise = action.Noise; HeroClass.FinishedTurn(action); }
/// This is called when another monster in sight of this one has damaged the /// hero. public void _viewHeroDamage(Action action, int damage) { var fear = 50.0 * damage / Health.Max; _modifyFear(action, -fear); Debugger.Instance.logMonster(this, "Witness " + damage + $" / {Health.Max} decreases fear by {fear} to {Fear}"); }
/// Called when this Actor has been killed by [attackNoun]. public override void OnDied(Noun attackNoun) { // Try to keep dropped items from overlapping. var flow = new Flow(Game.CurrentStage, Position, null, false, true); Func <VectorBase, bool> predicateNearestWhere = delegate(VectorBase position) { if (Rng.Instance.OneIn(5)) { return(true); } return(Game.CurrentStage.ItemAt(position) == null); }; // A "Delefate" with no return type Action <Item> myBreedDrop = delegate(Item item) { var itemPos = Position; if (Game.CurrentStage.ItemAt(Position) != null) { itemPos = flow.NearestWhere(predicateNearestWhere); } item.Position = itemPos; Game.CurrentStage.Items.Add(item); Log("{1} drop[s] {2}.", this, item); }; Breed.Drop.SpawnDrop(new AddItem(myBreedDrop)); Game.CurrentStage.removeActor(this); Debugger.Instance.removeMonster(this); }
public override void KilledMonster(Action action, Monster monster) { var weapon = Hero.Equipment.Weapon; TrainedStat stat; string name; if (weapon != null) { stat = Combat; name = "combat"; if (!Masteries.ContainsKey(weapon.type.category)) { Masteries.Add(weapon.type.category, NewMasteryStat()); } var mastery = Masteries[weapon.type.category]; if (mastery.Increment(monster.Breed.MaxHealth)) { action.Game.Log.Gain("{1} [have|has] reached ${weapon.type.category} mastery level ${mastery.level}.", Hero); } } else { stat = Fighting; name = "fighting"; } // Base it on the health of the monster to discourage the player from just // killing piles of weak monsters. if (stat.Increment(monster.Breed.MaxHealth)) { action.Game.Log.Gain($"{Hero.NounText} [have|has] reached {name} level {stat.Level}."); } }
//public override void OnKilled(Action.Action action, Monster defender) public override void OnKilled(Action action, Actor defender) { var monster = (Monster)defender; ExperienceCents += monster.ExperienceCents / Level; RefreshLevel(true); HeroClass.KilledMonster(action, monster); }
/// Processes one turn of the condition. public void Update(Action action) { if (IsActive) { turnsRemaining--; if (IsActive) { OnUpdate(action); } else { OnDeactivate(); Intensity = 0; } } }
/// Fear decays over time, more quickly the farther the monster is from the /// hero. private void DecayFear(Action action) { // TODO: Poison should slow the decay of fear. var fearDecay = 5.0 + (Position - Game.Hero.Position).kingLength(); // Fear decays more quickly if out of sight. if (!IsVisible) { fearDecay = 5.0 + fearDecay * 2.0; } // The closer the monster is to death, the less quickly it gets over fear. fearDecay = 2.0 + fearDecay * Health.Current / Health.Max; _modifyFear(action, -fearDecay); Debugger.Instance.logMonster(this, "Decay fear by " + fearDecay + " to " + Fear); }
/// Inflicting damage decreases fear. public override void OnDamage(Action action, Actor defender, int damage) { // The greater the power of the hit, the more emboldening it is. var fear = 100.0 * damage / Game.Hero.Health.Max; _modifyFear(action, -fear); Debugger.Instance.logMonster(this, "Hit for " + damage + " / " + Game.Hero.Health.Max + " decreases fear by " + fear + " to " + Fear); Func <Monster, bool> myWitness = delegate(Monster witness) { witness._viewHeroDamage(action, damage); return(true); }; // Nearby monsters may witness it. _updateWitnesses(myWitness); }
public void FinishTurn(Action action) { Energy.Spend(); if (Conditions != null) { foreach (var condition in Conditions) { condition.Update(action); } } if (IsAlive) { OnFinishTurn(action); } }
/// This is called when another monster in sight of this one has taken /// damage. private void _viewMonsterDamage(Action action, Monster monster, int damage) { var fear = 50.0 * damage / Health.Max; if (Breed.Flags.Contains("protective") && monster.Breed == Breed) { // Seeing its own kind get hurt enrages it. fear *= -2.0; } else if (Breed.Flags.Contains("berzerk")) { // Seeing any monster get hurt enrages it. fear *= -1.0; } _modifyFear(action, fear); Debugger.Instance.logMonster(this, "Witness " + damage + " / " + Health.Max + " increases fear by " + fear + " to " + Fear); }
/// Modifies fear and then determines if it's has crossed the threshold to /// cause a state change. private void _modifyFear(Action action, double offset) { // Don't add effects if the monster already died. if (!IsAlive) { return; } if (Breed.Flags.Contains("fearless")) { return; } // If it can't run, there's no point in being afraid. if (Breed.Flags.Contains("immobile")) { return; } Fear = Math.Max(0.0, Fear + offset); if (State is AwakeState && Fear > _frightenThreshold) { // Clamp the fear. This is mainly to ensure that a bunch of monsters // don't all get over their fear at the exact same time later. Since the // threshold is randomized, this will make the delay before growing // courageous random too. Fear = _frightenThreshold; Log("{1} is afraid!", this); changeState(new AfraidState()); action.AddEvent(EventType.Fear, this); return; } if (State is AfraidState && Fear <= 0.0) { Log("{1} grows courageous!", this); changeState(new AwakeState()); action.AddEvent(EventType.Courage, this); } }
public override void TookDamage(Action action, Actor attacker, int damage) { // Getting hit increases fury. Hero.Charge.Current = Math.Min(100, Hero.Charge.Current + 200 * damage / Hero.Health.Max); // Indirect damage doesn't increase toughness. if (attacker == null) { return; } // Reduce damage by armor (again). This is so that toughness increases // much more slowly as the hero wears more armor. damage = (int)Math.Floor(damage * ArmorUtilities.GetArmorMultiplier(Hero.Armor - Toughness.Level) * 10); if (Toughness.Increment(damage)) { action.Game.Log.Gain("{1} [have|has] reached toughness level " + Toughness.Level + ".", Hero); } }
/// Taking damage increases fear. public override void OnDamaged(Action action, Actor attacker, int damage) { // The greater the power of the hit, the more frightening it is. var fear = 100.0 * damage / Health.Max; // Getting hurt enrages it. if (Breed.Flags.Contains("berzerk")) { fear *= -3.0; } _modifyFear(action, fear); Debugger.Instance.logMonster(this, "Hit for " + damage + $" / {Health.Max} increases fear by {fear} to {Fear}"); Func <Monster, bool> myWitness = delegate(Monster witness) { witness._viewMonsterDamage(action, this, damage); return(true); }; // Nearby monsters may witness it. _updateWitnesses(myWitness); }
/// Reduces the actor's health by [damage], and handles its death. Returns /// `true` if the actor died. public bool TakeDamage(Action action, int damage, Noun attackNoun, Actor attacker = null) { Health.Current -= damage; action.Log("{1} takes {2} damage.", this.NounText, damage.ToString()); OnDamaged(action, attacker, damage); if (Health.Current > 0) { return(false); } action.AddEvent(EventType.Die, element: ElementFactory.Instance.None, other: null, pos: null, dir: null, actor: this); action.Log("{1} kill[s] {2}.", attackNoun, this); if (attacker != null) { attacker.OnKilled(action, this); } OnDied(attackNoun); return(true); }
public void SetNextAction(Action action) { Behavior = new ActionBehavior(action); }
/// Called when the [Hero] has finished taking a turn. public abstract void FinishedTurn(Action action);
public override void OnDamaged(Action action, Actor attacker, int damage) { HeroClass.TookDamage(action, attacker, damage); }
public void OnUpdate(Action action) { }
/// Called when this actor has successfully hit this [defender]. public virtual void OnDamage(Action action, Actor defender, int damage) { // Do nothing. }
/// Called when the [Hero] has killed [monster]. public abstract void KilledMonster(Action action, Monster monster);
public override void OnFinishTurn(Action action) { DecayFear(action); }
/// Called when this Actor has completed a turn. public virtual void OnFinishTurn(Action action) { // Do nothing. }
public override void FinishedTurn(Action action) { // Fury decays over time. Hero.Charge.Current = Math.Floor(Hero.Charge.Current * 0.9); }
/// Called when [attacker] has successfully hit this actor. /// /// [attacker] may be `null` if the damage is not the direct result of an /// attack (for example, poison). public virtual void OnDamaged(Action action, Actor attacker, int damage) { // Do nothing. }
/// Called when this Actor has killed [defender]. public virtual void OnKilled(Action action, Actor defender) { // Do nothing. }
/// Called when the [Hero] has taken [damage] from [attacker]. public abstract void TookDamage(Action action, Actor attacker, int damage);