public void SetContext(Ailment ctx, double MaxBarSize)
{
Context = ctx;
SetAilmentInformation(MaxBarSize);
HookEvents();
StartVisibilityTimer();
}
public void UnhookEvents()
{
Dispatcher.Invoke(new Action(() =>
{
foreach (Monster_Widget.Parts.MonsterPart Part in MonsterPartsContainer.Children)
{
Part.UnhookEvents();
}
foreach (Monster_Widget.Parts.MonsterAilment Ailment in MonsterAilmentsContainer.Children)
{
Ailment.UnhookEvents();
}
MonsterAilmentsContainer.Children.Clear();
MonsterPartsContainer.Children.Clear();
}));
Context.OnMonsterSpawn -= OnMonsterSpawn;
Context.OnMonsterDespawn -= OnMonsterDespawn;
Context.OnMonsterDeath -= OnMonsterDespawn;
Context.OnMonsterCapture -= OnMonsterDespawn;
Context.OnHPUpdate -= OnMonsterUpdate;
Context.OnStaminaUpdate -= OnStaminaUpdate;
Context.OnEnrage -= OnEnrage;
Context.OnUnenrage -= OnUnenrage;
Context.OnEnrageTimerUpdate -= OnEnrageTimerUpdate;
Context.OnTargetted -= OnMonsterTargetted;
Context.OnCrownChange -= OnMonsterCrownChange;
Context.OnAlatreonElementShift -= OnAlatreonElementShift;
Context.OnMonsterAilmentsCreate -= OnMonsterAilmentsCreate;
Context = null;
}
public async Task <IActionResult> PutAilment([FromRoute] int id, [FromBody] Ailment ailment)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != ailment.Id)
{
return(BadRequest());
}
_context.Entry(ailment).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AilmentExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutAilment(string id, Ailment ailment)
{
if (id != ailment.Name)
{
return(BadRequest());
}
_context.Entry(ailment).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AilmentExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public static bool CanFight(this Ailment ailment)
{
return
(!ailment.HasFlag(Ailment.Petrified) &&
!ailment.HasFlag(Ailment.DeadCorpse) &&
!ailment.HasFlag(Ailment.DeadAshes) &&
!ailment.HasFlag(Ailment.DeadDust));
}
public Ailment ConvertToAilment()
{
var Ailment = new Ailment();
Ailment.Name = this.Name;
Ailment.Id = this.Id;
return(Ailment);
}
public void UnhookEvents()
{
Context.OnBuildupChange -= OnBuildupChange;
Context.OnDurationChange -= OnDurationChange;
Context.OnCounterChange -= OnCounterChange;
VisibilityTimer?.Dispose();
Context = null;
}
public ActionResult DeleteConfirmed(int id)
{
Ailment ailment = db.Ailments.Find(id);
db.Ailments.Remove(ailment);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public static bool CanOpenInventory(this Ailment ailment)
{
// TODO
return
(!ailment.HasFlag(Ailment.Crazy) &&
!ailment.HasFlag(Ailment.Panic) &&
!ailment.HasFlag(Ailment.Petrified));
}
public static bool CanTalk(this Ailment ailment)
{
return
(!ailment.HasFlag(Ailment.Crazy) && // TODO: correct?
!ailment.HasFlag(Ailment.Petrified) &&
!ailment.HasFlag(Ailment.DeadCorpse) &&
!ailment.HasFlag(Ailment.DeadAshes) &&
!ailment.HasFlag(Ailment.DeadDust));
}
private static void Burn(Ailment a, Enemy e)
{
if (e.burnClock == null)
{
e.burnClock = new Stopwatch();
}
e.burnClock.Start();
e.burnTime = (int)Ailment.ailmentData[a.Type][a.Level].speedMult * 1000;
}
public MonsterAilmentEventArgs(Ailment ailment)
{
Name = ailment.Name;
Duration = ailment.Duration;
MaxDuration = ailment.MaxDuration;
Buildup = ailment.Buildup;
MaxBuildup = ailment.MaxBuildup;
Counter = ailment.Counter;
}
private DataDrivenMechanicCollection CreateCollection()
=> new DataDrivenMechanicCollection(ModifierBuilder, BuilderFactories)
{
// speed
{ PercentMore, Stat.MovementSpeed, ActionSpeedValueForPercentMore },
{
PercentMore, Stat.CastRate, ActionSpeedValueForPercentMore,
Not(Or(With(Keyword.Totem), With(Keyword.Trap), With(Keyword.Mine)))
},
{ PercentMore, Stat.Totem.Speed, ActionSpeedValueForPercentMore },
{ PercentMore, Stat.Trap.Speed, ActionSpeedValueForPercentMore },
{ PercentMore, Stat.Mine.Speed, ActionSpeedValueForPercentMore },
{ BaseSet, Stat.Totem.Speed, Stat.Totem.BaseTime.Value.Invert },
{ BaseSet, Stat.Trap.Speed, Stat.Trap.BaseTime.Value.Invert },
{ BaseSet, Stat.Mine.Speed, Stat.Mine.BaseTime.Value.Invert },
// resistances
{
BaseAdd, dt => DamageTypeBuilders.From(dt).Resistance,
dt => DamageTypeBuilders.From(dt).Exposure.Value
},
// ailments
{
TotalOverride, MetaStats.AilmentDealtDamageType(Common.Builders.Effects.Ailment.Ignite),
(int)DamageType.Fire
},
{
TotalOverride, MetaStats.AilmentDealtDamageType(Common.Builders.Effects.Ailment.Bleed),
(int)DamageType.Physical
},
{
TotalOverride, MetaStats.AilmentDealtDamageType(Common.Builders.Effects.Ailment.Poison),
(int)DamageType.Chaos
},
{ TotalOverride, Ailment.Chill.On(Self), 1, Ailment.Freeze.IsOn(Self) },
{
PercentIncrease, Ailment.Shock.AddStat(Damage.Taken), Ailment.IncreasedDamageTakenFromShocks.Value
},
{ BaseSet, Ailment.IncreasedDamageTakenFromShocks.Maximum, 50 },
{ TotalOverride, Ailment.IncreasedDamageTakenFromShocks.Minimum, 1 },
{
PercentReduce, Ailment.Chill.AddStat(Stat.ActionSpeed),
Ailment.ReducedActionSpeedFromChill.Value
},
{ BaseSet, Ailment.ReducedActionSpeedFromChill.Maximum, 30 },
{ TotalOverride, Ailment.ReducedActionSpeedFromChill.Minimum, 1 },
{ BaseSet, a => Ailment.From(a).TickRateModifier, a => ValueFactory.Create(1) },
{ PercentMore, a => Ailment.From(a).Duration, a => 100 / Ailment.From(a).TickRateModifier.Value },
// stun (see https://pathofexile.gamepedia.com/Stun)
{
TotalOverride, MetaStats.EffectiveStunThreshold,
Effect.Stun.Threshold, EffectiveStunThresholdValue
},
// other
{ PercentMore, Stat.Radius, Stat.AreaOfEffect.Value.Select(Math.Sqrt, v => $"Sqrt({v})") },
{ PercentMore, Stat.Cooldown, 100 - 100 * Stat.CooldownRecoverySpeed.Value.Invert },
};
private void AddForSkillAndAilments(GivenStatCollection collection,
IFormBuilder form, IDamageRelatedStatBuilder stat, IDamageRelatedStatBuilder valueStat)
{
collection.Add(form, stat.WithSkills, valueStat.WithSkills.Value);
foreach (var ailment in Enums.GetValues <Ailment>())
{
var ailmentBuilder = Ailment.From(ailment);
collection.Add(form, stat.With(ailmentBuilder), valueStat.With(ailmentBuilder).Value);
}
}
public Diagnosis Diagnose(List <Symptom> symptoms)
{
///check symptoms against ailment dictionary
//ailment with the most symptoms == diagnosed ailment
Ailment ailment = null; //placeholder
var diagnosis = new DoctorDiagnosis();
diagnosis.UpdateAilment(this, ailment);
return(diagnosis);
}
public void ReceiveAilment(Ailment ailment)
{
if (CurrentAilments.ContainsKey(ailment.Name) ||
!isAilmentApplied(ailment))
{
return;
}
CurrentAilments.Add(ailment.Name, ailment);
}
public static bool CanMove(this Ailment ailment)
{
return
(!ailment.HasFlag(Ailment.Sleep) &&
!ailment.HasFlag(Ailment.Lamed) &&
!ailment.HasFlag(Ailment.Petrified) &&
!ailment.HasFlag(Ailment.DeadCorpse) &&
!ailment.HasFlag(Ailment.DeadAshes) &&
!ailment.HasFlag(Ailment.DeadDust));
}
public ActionResult Edit([Bind(Include = "Id,Name")] Ailment ailment)
{
if (ModelState.IsValid)
{
db.Entry(ailment).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(ailment));
}
public void SetContext(Ailment ctx, double MaxBarSize)
{
Context = ctx;
IsAilmentGroupEnabled = UserSettings.PlayerConfig.Overlay.MonstersComponent.EnabledAilmentGroups.Contains(Context.Group);
AilmentGroupColor = UserSettings.PlayerConfig.Overlay.MonstersComponent.EnableAilmentsBarColor ?
FindResource($"MONSTER_AILMENT_COLOR_{Context.Group}") as Brush :
FindResource("MONSTER_AILMENT_COLOR_UNKNOWN") as Brush;
SetAilmentInformation(MaxBarSize);
HookEvents();
StartVisibilityTimer();
}
public static bool CanSelect(this Ailment ailment)
{
return
(!ailment.HasFlag(Ailment.Sleep) &&
!ailment.HasFlag(Ailment.Panic) &&
!ailment.HasFlag(Ailment.Crazy) &&
!ailment.HasFlag(Ailment.Petrified) &&
!ailment.HasFlag(Ailment.DeadCorpse) &&
!ailment.HasFlag(Ailment.DeadAshes) &&
!ailment.HasFlag(Ailment.DeadDust));
}
public void SetContext(Ailment ctx, double MaxBarSize)
{
Context = ctx;
AilmentGroupColor = ComponentSettings.EnableAilmentsBarColor ?
FindResource($"MONSTER_AILMENT_COLOR_{Context.Group}") as Brush :
FindResource("MONSTER_AILMENT_COLOR_UNKNOWN") as Brush;
SetAilmentInformation(MaxBarSize);
HookEvents();
ApplySettings();
StartVisibilityTimer();
}
//{"ailment":{"main_symptom":"enfermo","date_of_detection":"2016-02-02","symptom_location":"brazo","colateral_symptom":"enfermo","clinical_history_id":1}} return id
/// <summary>
/// Crea un nuevo padecimiento
/// </summary>
/// <param name=""></param>
public static int CreateAilment(Ailment pAilment)
{
string param = "/ailment";
Ailment_Tr transaction = new Ailment_Tr();
transaction.ailment = pAilment;
string json = JsonConvert.SerializeObject(transaction);
RESTHelper.PostJSON(param, json);
return(0);
}
public void statusEffect(Ailment ailment, float ailmentChance)
{
bool ail = heroClass.getChance(ailmentChance);
if (ail)
{
ailed = true;
startAil = Time.time;
setAilment(ailment);
}
}
public void CmdApplyAilment(Ailment ailment, int intensity)
{
ApplyAilment(ailment, intensity);
NetworkServer.SendToAll(GameMsg.UpdateAilment, new GameMsg.MsgUpdateAilment()
{
updateType = GameMsg.MsgUpdateAilment.UpdateType.Apply,
pawnId = id,
ailmentId = ailment.GetId(),
intensity = intensity
});
}
private void AddAilmentSourceDamageTypeModifiers(GivenStatCollection collection)
{
foreach (var ailment in Enums.GetValues <Ailment>())
{
var ailmentBuilder = Ailment.From(ailment);
foreach (var damageType in Enums.GetValues <DamageType>())
{
collection.Add(TotalOverride, _stat.Damage(damageType).With(ailmentBuilder), 0,
ailmentBuilder.Source(DamageTypeBuilders.From(damageType)).IsSet.Not);
}
}
}
public async Task <IActionResult> PostAilment([FromBody] Ailment ailment)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.Ailments.Add(ailment);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetAilment", new { id = ailment.Id }, ailment));
}
/// <summary>
/// スキル効果値による状態異常付与
/// (自分のLUK * Lv / 相手のLUK * Lv) * Value
/// </summary>
/// <param name="fromUnit"></param>
/// <param name="toUnit"></param>
/// <param name="ailment"></param>
/// <param name="skill"></param>
/// <returns></returns>
public static string SetAilmentBySkillValue(Unit fromUnit, Unit toUnit, Ailment ailment, Skill skill)
{
string message = "";
int value = skill.ValueByLv[skill.SkillLevel];
int per = (fromUnit.Statuses[Status.Lv] * fromUnit.Statuses[Status.LUK]) /
(toUnit.Statuses[Status.Lv] * toUnit.Statuses[Status.LUK]) * (value / 100);
SetAilmentInProb(fromUnit, toUnit, ailment, per);
return(message);
}
public static bool CanParry(this Ailment ailment)
{
return
(!ailment.HasFlag(Ailment.Sleep) &&
!ailment.HasFlag(Ailment.Panic) &&
!ailment.HasFlag(Ailment.Exhausted) &&
!ailment.HasFlag(Ailment.Lamed) &&
!ailment.HasFlag(Ailment.Petrified) &&
!ailment.HasFlag(Ailment.DeadCorpse) &&
!ailment.HasFlag(Ailment.DeadAshes) &&
!ailment.HasFlag(Ailment.DeadDust));
}
void setAilment(Ailment ailment)
{
switch (ailment)
{
case Ailment.mired:
heroClass.getDamageModule().lowerAttribute(Attribute.Speed, 10);
return;
default:
return;
}
}
private Ailment BuildAilment(string ailmentName)
{
if (!AilmentAliasMapUtil.GetAilmentAliasMap.ContainsKey(ailmentName))
{
return(null);
}
Type typeOfAilment = AilmentAliasMapUtil.GetAilmentAliasMap[ailmentName];
var recoveryChance = DetermineChanceToRecover(typeOfAilment, ailmentName);
Ailment ailmentToReturn = (Ailment)Activator.CreateInstance(typeOfAilment, new object[] { ailmentName, _move.EffectChance, recoveryChance });
return(ailmentToReturn);
}
public Move(string name, string description, int damage, int accuracy, int uses, Ailment ailment, double ailmentChance, Kind kind, Type type)
{
Name = name;
Description = description;
BaseDamage = damage;
Accuracy = accuracy;
Uses = uses;
MaxUses = uses;
Ailment = ailment;
AilmentChance = ailmentChance;
Kind = kind;
Type = type;
}
public static bool CuresAilment(Ailment ailment)
{
switch (Cures)
{
case Cure.Sleep:
if (ailment == Ailment.Sleep)
return true;
break;
case Cure.Poisoned:
if (ailment == Ailment.Poisoned)
return true;
break;
case Cure.Burned:
if (ailment == Ailment.Burned)
return true;
break;
case Cure.Frozen:
if (ailment == Ailment.Frozen)
return true;
break;
case Cure.All: return true;
case Cure.Frenzied:
if (ailment == Ailment.Frenzied)
return true;
break;
}
return false;
}
/// <summary>
/// Monster with one type
/// </summary>
/// <param name="id">ID of the monster</param>
/// <param name="level">Level</param>
/// <param name="name">Name</param>
/// <param name="description">Short description of the monster</param>
/// <param name="maleChance">Chance for the monster to be male</param>
/// <param name="captureChance">Chance to capture this monster</param>
/// <param name="helditem">Item the monster is carrying</param>
/// <param name="stats">Stats the monster has</param>
/// <param name="type">Type which changes how much damage certain moves do</param>
/// <param name="abilities">All possible abilities the monster can have</param>
/// <param name="front">Texture that is shown when fighting against this monster</param>
/// <param name="back">Texture that is shown when you've send out this monster</param>
/// <param name="party">Texture that is shown in the party view</param>
public Monster(int id, int level, string name, string description, Type type, int maleChance, int captureChance, Item helditem, Stats stats, List<Ability> abilities,
Texture2D front, Texture2D back, Texture2D party, bool database = false)
{
Id = id;
if (!database) {
StatId = RandomId.GenerateStatsId();
UId = RandomId.GenerateRandomUId();
}
Level = level;
experience = level * level * 5;
RemainingExp = ((level + 1) * (level + 1) * 5) - experience;
Name = name;
Description = description;
PrimaryType = type;
SecondaryType = Type.None;
Gender = GetGender(maleChance);
CaptureChance = captureChance;
HeldItem = helditem;
Stats = stats;
PossibleAbilities = abilities;
Ability = GetAbility(abilities);
FrontSprite = front;
BackSprite = back;
PartySprite = party;
Ailment = Ailment.Normal;
GetMoves();
MaxHealth = Stats.Health;
}
public static Texture2D GetAilmentTexture(Ailment ailment)
{
switch (ailment) {
case Ailment.Sleep: return ContentLoader.SLP;
case Ailment.Poisoned: return ContentLoader.PSN;
case Ailment.Burned: return ContentLoader.BRN;
case Ailment.Dazzled: return ContentLoader.DZL;
case Ailment.Frozen: return ContentLoader.FRZ;
case Ailment.Frenzied: return ContentLoader.FZD;
case Ailment.Fainted: return ContentLoader.FNT;
}
return null;
}
