static bool Prefix(UnitAttack __instance, AttackHandInfo attack)
{
var combatManeuver = Rulebook.Trigger(new RuleCheckCombatManeuverReplaceAttack(__instance.Executor, __instance.Target, attack)).Result;
if (combatManeuver == CombatManeuver.None)
{
return(true);
}
var lastAttackRule = new RuleAttackWithWeapon(__instance.Executor, __instance.Target, attack.Weapon, attack.AttackBonusPenalty)
{
IsRend = __instance.IsRend(__instance.PlannedAttack),
IsFirstAttack = (attack.AttackNumber == 0),
IsFullAttack = __instance.IsFullAttack,
IsCharge = __instance.IsCharge,
AttackNumber = attack.AttackNumber,
AttacksCount = ((List <AttackHandInfo>)unitattack_get_m_AllAttacks(__instance)).Count
};
unitattack_set_LastAttackRule(__instance, lastAttackRule);
attack.Target = __instance.Target;
attack.IsHit = __instance.Executor.TriggerAttackReplacementCombatManeuver(__instance.Target, attack.Weapon, attack.AttackBonusPenalty, combatManeuver);
return(false);
}
static bool Prefix(RuleCheckCastingDefensively __instance, RulebookEventContext context)
{
if (__instance.Spell.Blueprint.GetComponent <AbilityKineticist>() == null)
{
return(true);
}
var kineticist_part = __instance.Initiator.Get <UnitPartKineticist>();
if (kineticist_part == null)
{
return(true);
}
var tr = Harmony12.Traverse.Create(__instance);
var rule = Rulebook.Trigger <RuleCalculateAbilityParams>(new RuleCalculateAbilityParams(__instance.Initiator, __instance.Spell));
var ability_params = rule.Result;
tr.Property("DC").SetValue(15 + ability_params.SpellLevel * 2);
var bonus_concentration = Helpers.GetField <int>(rule, "m_BonusConcentration");
tr.Property("Concentration").SetValue(bonus_concentration + kineticist_part.ClassLevel + kineticist_part.MainStatBonus);
tr.Property("ResultRollRaw").SetValue(RulebookEvent.Dice.D20);
return(false);
}
public override void RunAction()
{
try
{
//Log.Append($"{GetType().Name}.RunAction()");
var context = Buff.Context.SourceAbilityContext;
var ability = context.Ability;
//Log.Append($" ability {ability} caster {context.Caster.CharacterName} fact {ability.Fact}");
//Log.Append($" spellbook {ability.Spellbook?.Blueprint} main target {context.MainTarget}");
//Log.Flush();
var spellData = new AbilityData(Spell, context.Caster.Descriptor, ability.Fact, ability.Spellbook?.Blueprint);
spellData.OverrideSpellLevel = Context.Params.SpellLevel;
var castSpell = new RuleCastSpell(spellData, context.MainTarget);
// Disable spell failure: we already cast the spell.
castSpell.IsCutscene = true;
castSpell = Rulebook.Trigger(castSpell);
if (IsInstant)
{
castSpell.ExecutionProcess.InstantDeliver();
}
}
catch (Exception e)
{
Log.Error(e);
}
}
public static void ApplyInstantRest(UnitEntityData unitEntityData)
{
if (unitEntityData.Descriptor.State.IsFinallyDead)
{
unitEntityData.Descriptor.Resurrect();
unitEntityData.Position = Game.Instance.Player.MainCharacter.Value.Position;
}
RestController.RemoveNegativeEffects(unitEntityData.Descriptor);
RestController.ApplyRest(unitEntityData.Descriptor);
Rulebook.Trigger(new RuleHealDamage(unitEntityData, unitEntityData, new DiceFormula(),
unitEntityData.Descriptor.Stats.HitPoints.ModifiedValue));
foreach (var attribute in StatTypeHelper.Attributes)
{
Rulebook.Trigger(new RuleHealStatDamage(unitEntityData, unitEntityData, attribute));
}
foreach (var attribute in unitEntityData.Stats.Attributes)
{
attribute.Damage = 0;
attribute.Drain = 0;
}
RestoreAllItemCharges();
}
public override void OnEventAboutToTrigger(RuleHealDamage evt)
{
var context = Helpers.GetMechanicsContext()?.SourceAbilityContext;
var spell = context?.SourceAbility;
// According to the ability description, it must be from a healing spell
// (not a supernatural ability like Energy Body, Channel Energy, etc.)
Log.Append($"Spirit Boost: spell {spell?.name}, type {spell?.Type}, descriptor {spell.SpellDescriptor}");
if (spell != null && spell.Type == AbilityType.Spell && !(evt is RuleHealDamageWithOverflow) &&
(spell.SpellDescriptor & SpellDescriptor.RestoreHP) != 0)
{
// Disable the original heal roll.
// We need to simulate it so we can get the temporary HP amount.
evt.Modifier = 0;
// Trigger the heal and collect the overflow heal amount, if any.
int amount = Rulebook.Trigger(new RuleHealDamageWithOverflow(evt)).OverflowHealing;
if (amount > 0)
{
var oracleLevel = Owner.Progression.GetClassLevel(OracleClass.oracle);
amount = Math.Min(amount, oracleLevel);
context[HitPointValueToUpdate] = amount;
var duration = oracleLevel.Rounds().Seconds;
Log.Write($"Spirit Boost: apply {amount} temporary HP to {evt.Target.CharacterName} for {duration}, spell was {spell.name}");
evt.Target.Buffs.AddBuff(HitPointBuff, context, duration);
}
}
}
public List <Discipline> ReadXmlDisciplines()
{
var file = UtilityHelper.ReadStreamFromFile("OldRulebook.data");
var rulebook = new Rulebook();
var serializer = new XmlSerializer(rulebook.GetType());
rulebook = (Rulebook)serializer.Deserialize(file);
foreach (var rulebookDiscipline in rulebook.Disciplines)
{
var glossarySection = rulebookDiscipline.Chapters.SelectMany(o => o.Sections)
.First(o => o.Name == "Glossary");
var glossary = rulebookDiscipline.GlossaryList;
foreach (var glossaryItem in glossary)
{
glossarySection.Rules.Add(new Rule()
{
RuleId = glossaryItem.GlossaryId,
Name = glossaryItem.Name,
Description = glossaryItem.Definition,
DisciplineId = rulebookDiscipline.DisciplineId
});
}
}
return(rulebook.Disciplines);
}
public override void RunAction()
{
var target = this.Target.Unit;
var initiator = this.Context.MaybeCaster;
if (!InspectUnitsHelper.IsInspectAllow(target))
{
return;
}
BlueprintUnit blueprintForInspection = target.Descriptor.BlueprintForInspection;
InspectUnitsManager.UnitInfo info = Game.Instance.Player.InspectUnitsManager.GetInfo(blueprintForInspection);
StatType statType = !(bool)((UnityEngine.Object)info.Blueprint.Type) ? StatType.SkillLoreNature : info.Blueprint.Type.KnowledgeStat;
if (info == null)
{
return;
}
ModifiableValueSkill stat = initiator.Stats.GetStat <ModifiableValueSkill>(statType);
int?nullable1;
int?nullable2;
if (stat == null)
{
nullable1 = new int?();
nullable2 = nullable1;
}
else
{
nullable2 = new int?(stat.BaseValue);
}
nullable1 = nullable2;
int dc = info.DC;
int bonus = value.Calculate(this.Context);
if ((!nullable1.HasValue ? 0 : nullable1.Value) > 0 || (bool)initiator.Descriptor.State.Features.MakeKnowledgeCheckUntrained)
{
var skill_check = new RuleSkillCheck(initiator, statType, dc);
skill_check.AddTemporaryModifier(initiator.Stats.GetStat(statType).AddModifier(bonus, null, descriptor));
skill_check.IgnoreDifficultyBonusToDC = true;
int rollResult = Rulebook.Trigger <RuleSkillCheck>(skill_check).RollResult;
Common.AddBattleLogMessage($"{initiator.CharacterName} DC {dc} monster lore check: {rollResult}");
if (dc <= rollResult && action_on_success != null)
{
action_on_success.Run();
}
if (info.KnownPartsCount < 4)
{
info.SetCheck(rollResult, initiator);
EventBus.RaiseEvent <IKnowledgeHandler>((Action <IKnowledgeHandler>)(h => h.HandleKnowledgeUpdated(info)));
}
}
}
private void applySpell(SpellSlot spell_slot, AbilityExecutionContext context, TargetWrapper target)
{
var spell = getSpellOrVariant(spell_slot.Spell);
spendSpellSlot(spell_slot);
spell.SpendMaterialComponent();
Rulebook.Trigger <RuleCastSpell>(new RuleCastSpell(spell, target));
}
static bool Prefix(UnitBody __instance)
{
__instance.Owner.Unit.SetFreeEquipmentChange(Rulebook.Trigger(new RuleCheckFreeActionEquip(__instance.Owner.Unit)
{
IsHandsEquipmentSetChange = true
}).IsFreeAction);
return(true);
}
void Start()
{
pm = GameObject.Find("PlayerManager").GetComponent <PlayerManager>();
rulebook = GameObject.Find("DifficultyManager").GetComponent <Rulebook>();
playerlvl = pm.getPlayerLevel();
playerExp = pm.getPlayerExperiencePoints();
}
public void releaseSpellOnTarget(TargetWrapper target)
{
if (spell != null && (spell.CanTarget(target) || ignore_target_checkers))
{
Rulebook.Trigger <RuleCastSpell>(new RuleCastSpell(spell, target));
Common.AddBattleLogMessage($"{this.Owner.CharacterName} released {spell.Blueprint.Name} from {this.Fact.Name}.");
spell = null;
}
}
public void OnEventDidTrigger(RuleDealDamage evt)
{
var spell = Buff.Context.SourceAbilityContext?.Ability;
if (spell != null && !Rulebook.Trigger(new RuleCheckConcentration(evt.Target, spell, evt)).Success)
{
RemoveBuff();
}
}
private void Awake()
{
// get the GameManager script component
em = GameObject.Find("EnemyManager").GetComponent <EnemyManager>();
player = GameObject.FindGameObjectWithTag("Player");
pl = GameObject.Find("PlayerManager").GetComponent <PlayerLevel>();
rulebook = GameObject.Find("DifficultyManager").GetComponent <Rulebook>();
ws = GameObject.Find("DifficultyManager").GetComponent <WeightSystem>();
}
public Rulebook ConfigureRulebooks()
{
var rulebook = new Rulebook();
// Load Rulebook.data file
var xmlReader = new XmlReader();
_allDisciplines = xmlReader.ReadXmlDisciplines();
_allSections = _allDisciplines.SelectMany(o => o.Chapters).SelectMany(o => o.Sections).ToList();
_allRules = _allSections.SelectMany(o => o.Rules).ToList();
_allSubRules = _allRules.SelectMany(o => o.SubRules).ToList();
// Load New Properties
foreach (var discipline in _allDisciplines)
{
Console.WriteLine($"{discipline.Name} has started compiling...");
// Add Glossaries (DisciplineId needs populating)
discipline.GlossaryList.ForEach(o => o.DisciplineId = discipline.DisciplineId);
_allGlossaries.AddRange(discipline.GlossaryList);
foreach (var chapter in discipline.Chapters)
{
Console.WriteLine($"--{chapter.Name} has started compiling...");
foreach (var section in chapter.Sections)
{
Console.WriteLine($"-- >>{section.Name} has started compiling...");
section.SearchableString = UtilityHelper.CreateSearchableString(section);
foreach (var rule in section.Rules)
{
rule.SearchableString = UtilityHelper.CreateSearchableString(rule);
rule.SpanList = CreateSpanList(rule.Description, rule.DisciplineId);
foreach (var subRule in rule.SubRules)
{
subRule.SearchableString = UtilityHelper.CreateSearchableString(subRule);
subRule.SpanList = CreateSpanList(subRule.Description, rule.DisciplineId);
}
}
Console.WriteLine($"-- >>{section.Name} has finished compiling...");
}
Console.WriteLine($"--{chapter.Name} has finished compiling...");
}
Console.WriteLine($"{discipline.Name} has finished compiling...");
}
rulebook.Disciplines = _allDisciplines;
return(rulebook);
}
static bool Prefix(RulePartySkillCheck __instance, bool isTrigger, ref int ___m_D20, ref int ___m_StatValue, StatType ___m_StatType, int ___m_DifficultyClass)
{
___m_StatValue = int.MinValue;
var tr = Harmony12.Traverse.Create(__instance);
tr.Property("Roller").SetValue(null);
RuleSkillCheck selected_evt = null;
foreach (UnitEntityData unitEntityData in Game.Instance.Player.Party)
{
if (unitEntityData.Descriptor.State.CanAct)
{
ModifiableValue stat = unitEntityData.Stats.GetStat(___m_StatType);
ModifiableValueAttributeStat valueAttributeStat = stat as ModifiableValueAttributeStat;
int num = valueAttributeStat != null ? valueAttributeStat.Bonus : stat.ModifiedValue;
RuleSkillCheck evt = new RuleSkillCheck(unitEntityData, ___m_StatType, ___m_DifficultyClass)
{
Voice = __instance.Voice,
EnsureSuccess = __instance.EnsureSuccess
};
if (isTrigger)
{
evt.Silent = true;;
Rulebook.Trigger <RuleSkillCheck>(evt);
num += (int)evt.Bonus;
}
if (___m_StatValue < num)
{
___m_StatValue = num;
tr.Property("Roller").SetValue(unitEntityData);
selected_evt = evt;
}
}
}
if (__instance.Roller == null)
{
UberDebug.Log("Roller is null, in the party skillcheck", (object[])Array.Empty <object>());
}
else
{
if (!isTrigger)
{
selected_evt.Calculate();
}
else
{
selected_evt.Silent = false;
EventBus.RaiseEvent <IRollSkillCheckHandler>((Action <IRollSkillCheckHandler>)(h => h.HandleOnRuleSkillCheck(selected_evt)));
//Game.Instance?.UI?.BattleLogManager?.HandleUnitSkillCheckRolled(selected_evt);
}
___m_D20 = selected_evt.D20;
}
return(false);
}
public void DoIt2()
{
var rulesReader = new RulesReader();
var glossaryReader = new GlossaryReader();
var xmlParser = new XmlParser();
var rulebook = new Rulebook()
{
Disciplines = new List <Discipline>()
};
var root = AppDomain.CurrentDomain.BaseDirectory;
string[] filenames = { "ActionAir", "Handgun", "Shotgun", "Rifle", "MiniRifle", "PCC" };
string[] languageNames = { "English", "Brazilian" };
var converts = new Dictionary <string, RulesReader.ConversionResult>();
var glossaries = new Dictionary <string, List <Glossary> >();
foreach (var languageName in languageNames)
{
var rootPath = $"{root}/{languageName}";
if (!Directory.Exists(rootPath))
{
continue;
}
foreach (var filename in filenames)
{
if (File.Exists($"{rootPath}/{filename}.txt"))
{
converts.Add(filename, rulesReader.ConvertFromTxtFile($"{rootPath}/{filename}.txt"));
}
if (File.Exists($"{rootPath}/{filename} - Glossary.txt"))
{
glossaries.Add(filename, glossaryReader.ConvertFromTxtFile($"{rootPath}/{filename} - Glossary.txt"));
}
}
var disciplines = new List <Discipline>();
foreach (var convert in converts)
{
var glossaryList = glossaries[convert.Key];
disciplines.Add(rulesReader.CreateRuleChapters(convert.Value, convert.Key, glossaryList));
}
rulebook.Disciplines.AddRange(disciplines);
}
xmlParser.CreateXmlRulebook(rulebook);
}
private void UpdateStateIcons()
{
UnitEntityData currentUnit;
_markIsThisRound.SetActive(Unit != null && !_isCurrent && Unit.GetTimeToNextTurn() < Mod.Core.Combat.TimeToNextRound);
_iconIsFlatFooted.SetActive(ShowIsFlatFootedIconOnUI &&
Unit != null && !_isCurrent && (currentUnit = CurrentUnit()) != null &&
Rulebook.Trigger(new RuleCheckTargetFlatFooted(currentUnit, Unit)).IsFlatFooted);
_iconIsUnableToAct.SetActive(Unit != null && !Unit.IsAbleToAct());
_iconIsSurprising.SetActive(Unit != null && !_isCurrent && Unit.IsSurprising());
}
public static RulebookDTO Map(Rulebook rulebook)
{
var rulebookDTO = new RulebookDTO
{
Id = rulebook.Id,
Title = rulebook.Title,
PublishYear = rulebook.PublishYear
};
return(rulebookDTO);
}
private void applySpell(SpellSlot spell_slot, AbilityExecutionContext context, TargetWrapper target)
{
var spell = getSpellOrVariant(spell_slot.Spell);
spendSpellSlot(spell_slot);
spell.SpendMaterialComponent();
var rule_cast_spell = new RuleCastSpell(spell, target);
rule_cast_spell.Context.AttackRoll = Rulebook.CurrentContext.AllEvents.LastOfType <RuleAttackWithWeapon>()?.AttackRoll;
Rulebook.Trigger <RuleCastSpell>(rule_cast_spell);
}
public override void OnEventAboutToTrigger(RuleCalculateDamage evt)
{
var initiator = evt.Initiator;
var target = evt.Target;
var rule = Rulebook.Trigger(new RuleCheckTargetFlatFooted(initiator, target));
if (evt.Target.CombatState.IsFlanked || rule.IsFlatFooted)
{
base.Owner.Ensure <UnitPartStudiedTarget>().SetTarget(target.Descriptor);
}
}
static void Postfix(RuleCalculateCMD __instance)
{
//add attacker dependent ac bonuses/penalties
var rule_ac = new RuleCalculateAC(__instance.Initiator, __instance.Target, AttackType.Touch);
var ac = Rulebook.Trigger <RuleCalculateAC>(rule_ac).TargetAC;
int delta_ac = ac - (__instance.IsTargetFlatFooted ? __instance.Target.Stats.AC.FlatFootedTouch : __instance.Target.Stats.AC.Touch);
var tr = Harmony12.Traverse.Create(__instance);
tr.Property("Result").SetValue(__instance.Result + delta_ac);
}
public void playerTooManyDeaths_Test()
{
Rulebook rulebook = new Rulebook();
Rulebook rb = rulebook;
rb.playerDeathTimer = 10.0f;
rb.rulebookPlayerDeath = 5;
Assert.Throws <NullReferenceException>(() => rb.PlayerTooManyDeaths());
Assert.That(rb.rulebookPlayerDeath, Is.EqualTo(0));
}
static RuleAttackWithWeapon performAttackOrManeuver(RuleAttackWithWeapon attack_rule)
{
var attack_replacement_part = attack_rule.Initiator.Get <UnitPartAttackReplacementWithAction>();
if (attack_replacement_part != null && attack_replacement_part.maybeReplaceAttackWithAction(attack_rule))
{
return(attack_rule);
}
else
{
return(Rulebook.Trigger <RuleAttackWithWeapon>(attack_rule));
}
}
public override void OnTurnOn()
{
base.OnTurnOn();
RuleCalculateAttacksCount calculateAttacksCount = Rulebook.Trigger <RuleCalculateAttacksCount>(new RuleCalculateAttacksCount(this.Owner.Unit)
{
ForceIterativeNaturealAttacks = true
});
this.m_MainAttacksCount = calculateAttacksCount.PrimaryHand.MainAttacks;
this.m_PenalizedAttacksCount = calculateAttacksCount.PrimaryHand.PenalizedAttacks;
this.m_AttackPenalty = 0;
}
public void notEnoughEnemyDamage()
{
Rulebook rulebook = new Rulebook();
Rulebook rb = rulebook;
rb.notEnoughEnemyDamageTimer = 30.0f;
rb.rulebookIsPlayerNotHitEnough = 1;
Assert.Throws <NullReferenceException>(() => rb.NotEnoughEnemyDamage());
Assert.That(rb.notEnoughEnemyDamageTimer, Is.EqualTo(0.0f));
Assert.That(rb.rulebookIsPlayerNotHitEnough, Is.EqualTo(0));
}
public void playerKillsDeathCheck_Test()
{
Rulebook rulebook = new Rulebook();
Rulebook rb = rulebook;
rb.playerDeaths = 0;
rb.playerDeathCheck = 0;
rb.playerKillsDeathCounter = 20;
Assert.Throws <NullReferenceException>(() => rb.PlayerKillsDeathsCheck());
Assert.That(rb.playerKillsDeathCounter, Is.EqualTo(0));
}
public void playerHitCheck()
{
Rulebook rulebook = new Rulebook();
Rulebook rb = rulebook;
rb.playerHitTimer = 16.0f;
rb.enemyHitPlayer = 5;
rb.enemyDamageHits = 5;
Assert.Throws <NullReferenceException>(() => rb.PlayerHitCheck());
Assert.That(rb.playerHitTimer, Is.EqualTo(0.0f));
}
public void tooManyPlayerHits()
{
Rulebook rulebook = new Rulebook();
Rulebook rb = rulebook;
rb.tooManyPlayerHitsTimer = 5.0f;
rb.isPlayerHitTooMuch = 4;
Assert.Throws <NullReferenceException>(() => rb.TooManyPlayerHits());
Assert.That(rb.tooManyPlayerHitsTimer, Is.EqualTo(0.0f));
Assert.That(rb.isPlayerHitTooMuch, Is.EqualTo(0));
}
static void Postfix(UnitCombatState __instance, UnitEntityData target, ref bool __result)
{
if (Mod.Enabled && FixAcrobaticsMobility && __result)
{
if (target.Descriptor.State.HasCondition(UnitCondition.UseMobilityToNegateAttackOfOpportunity))
{
if (Rulebook.Trigger(new RuleSkillCheck(target, StatType.SkillMobility,
Rulebook.Trigger(new RuleCalculateCMD(target, __instance.Unit, CombatManeuver.None)).Result)).IsPassed)
{
__result = false;
}
}
}
}
static bool Prefix(RuleCalculateAC __instance, RulebookEventContext context)
{
Cover cover = Rulebook.Trigger(new RuleCheckSoftCover(__instance.Initiator, __instance.Target, __instance.AttackType)).Result;
if (cover == Cover.Full)
{
__instance.AddBonus(4, SoftCoverFact);
}
else if (cover == Cover.Partial)
{
__instance.AddBonus(2, SoftCoverPartialFact);
}
return(true);
}
