aboutsummaryrefslogtreecommitdiff
path: root/src/analyzers/raids
diff options
context:
space:
mode:
Diffstat (limited to 'src/analyzers/raids')
-rw-r--r--src/analyzers/raids/mod.rs60
-rw-r--r--src/analyzers/raids/w3.rs34
-rw-r--r--src/analyzers/raids/w4.rs230
-rw-r--r--src/analyzers/raids/w5.rs90
-rw-r--r--src/analyzers/raids/w6.rs149
-rw-r--r--src/analyzers/raids/w7.rs111
6 files changed, 674 insertions, 0 deletions
diff --git a/src/analyzers/raids/mod.rs b/src/analyzers/raids/mod.rs
new file mode 100644
index 0000000..bb3824b
--- /dev/null
+++ b/src/analyzers/raids/mod.rs
@@ -0,0 +1,60 @@
+//! Analyzers for raid logs.
+//!
+//! Most of the fights can use the [`GenericRaid`][GenericRaid] analyzer. The exception to this are
+//! fights which have a Challenge Mote (Wing 4, Wing 5, Wing 6, Wing 7), and fights which need to
+//! use a different method to determine their outcome (Xera, Deimos, Soulless Horror, Conjured
+//! Amalgamate, Qadim).
+use crate::{
+ analyzers::{helpers, Analyzer, Outcome},
+ Log,
+};
+
+mod w3;
+pub use w3::Xera;
+
+mod w4;
+pub use w4::{Cairn, Deimos, MursaatOverseer, Samarog};
+
+mod w5;
+pub use w5::{Dhuum, SoullessHorror};
+
+mod w6;
+pub use w6::{ConjuredAmalgamate, LargosTwins, Qadim};
+
+mod w7;
+pub use w7::{CardinalAdina, CardinalSabir, QadimThePeerless};
+
+/// A generic raid analyzer that works for bosses without special interactions.
+///
+/// This analyzer always returns `false` for the Challenge Mote calculation.
+///
+/// The outcome of the fight is determined by whether the boss agent has a death event - which
+/// works for a lot of fights, but not all of them.
+#[derive(Debug, Clone, Copy)]
+pub struct GenericRaid<'log> {
+ log: &'log Log,
+}
+
+impl<'log> GenericRaid<'log> {
+ /// Create a new [`GenericRaid`] analyzer for the given log.
+ ///
+ /// **Do not** use this method unless you know what you are doing. Instead, rely on
+ /// [`Log::analyzer`]!
+ pub fn new(log: &'log Log) -> Self {
+ GenericRaid { log }
+ }
+}
+
+impl<'log> Analyzer for GenericRaid<'log> {
+ fn log(&self) -> &Log {
+ self.log
+ }
+
+ fn is_cm(&self) -> bool {
+ false
+ }
+
+ fn outcome(&self) -> Option<Outcome> {
+ Outcome::from_bool(helpers::boss_is_dead(self.log))
+ }
+}
diff --git a/src/analyzers/raids/w3.rs b/src/analyzers/raids/w3.rs
new file mode 100644
index 0000000..1b80b8d
--- /dev/null
+++ b/src/analyzers/raids/w3.rs
@@ -0,0 +1,34 @@
+use crate::{
+ analyzers::{helpers, Analyzer, Outcome},
+ Log,
+};
+
+/// Analyzer for the final fight of Wing 3, Xera.
+#[derive(Debug, Clone, Copy)]
+pub struct Xera<'log> {
+ log: &'log Log,
+}
+
+impl<'log> Xera<'log> {
+ /// Create a new [`Xera`] analyzer for the given log.
+ ///
+ /// **Do not** use this method unless you know what you are doing. Instead, rely on
+ /// [`Log::analyzer`]!
+ pub fn new(log: &'log Log) -> Self {
+ Xera { log }
+ }
+}
+
+impl<'log> Analyzer for Xera<'log> {
+ fn log(&self) -> &Log {
+ self.log
+ }
+
+ fn is_cm(&self) -> bool {
+ false
+ }
+
+ fn outcome(&self) -> Option<Outcome> {
+ Outcome::from_bool(helpers::players_exit_after_boss(self.log))
+ }
+}
diff --git a/src/analyzers/raids/w4.rs b/src/analyzers/raids/w4.rs
new file mode 100644
index 0000000..310b26f
--- /dev/null
+++ b/src/analyzers/raids/w4.rs
@@ -0,0 +1,230 @@
+//! Boss fight analyzers for Wing 4 (Bastion of the Penitent).
+use crate::{
+ analyzers::{helpers, Analyzer, Outcome},
+ EventKind, Log,
+};
+
+pub const CAIRN_CM_BUFF: u32 = 38_098;
+
+/// Analyzer for the first fight of Wing 4, Cairn.
+///
+/// The CM is detected by the presence of the buff representing the countdown before which you have
+/// to use your special action skill.
+#[derive(Debug, Clone, Copy)]
+pub struct Cairn<'log> {
+ log: &'log Log,
+}
+
+impl<'log> Cairn<'log> {
+ /// Create a new [`Cairn`] analyzer for the given log.
+ ///
+ /// **Do not** use this method unless you know what you are doing. Instead, rely on
+ /// [`Log::analyzer`]!
+ pub fn new(log: &'log Log) -> Self {
+ Cairn { log }
+ }
+}
+
+impl<'log> Analyzer for Cairn<'log> {
+ fn log(&self) -> &Log {
+ self.log
+ }
+
+ fn is_cm(&self) -> bool {
+ helpers::buff_present(self.log, CAIRN_CM_BUFF)
+ }
+
+ fn outcome(&self) -> Option<Outcome> {
+ Outcome::from_bool(helpers::boss_is_dead(self.log))
+ }
+}
+
+pub const MO_CM_HEALTH: u64 = 30_000_000;
+
+/// Analyzer for the second fight of Wing 4, Mursaat Overseer.
+///
+/// The CM is detected by the boss's health, which is higher in the challenge mote.
+#[derive(Debug, Clone, Copy)]
+pub struct MursaatOverseer<'log> {
+ log: &'log Log,
+}
+
+impl<'log> MursaatOverseer<'log> {
+ /// Create a new [`MursaatOverseer`] analyzer for the given log.
+ ///
+ /// **Do not** use this method unless you know what you are doing. Instead, rely on
+ /// [`Log::analyzer`]!
+ pub fn new(log: &'log Log) -> Self {
+ MursaatOverseer { log }
+ }
+}
+
+impl<'log> Analyzer for MursaatOverseer<'log> {
+ fn log(&self) -> &Log {
+ self.log
+ }
+
+ fn is_cm(&self) -> bool {
+ helpers::boss_health(self.log)
+ .map(|h| h >= MO_CM_HEALTH)
+ .unwrap_or(false)
+ }
+
+ fn outcome(&self) -> Option<Outcome> {
+ Outcome::from_bool(helpers::boss_is_dead(self.log))
+ }
+}
+
+pub const SAMAROG_CM_HEALTH: u64 = 40_000_000;
+
+/// Analyzer for the third fight of Wing 4, Samarog.
+///
+/// The CM is detected by the boss's health, which is higher in the challenge mote.
+#[derive(Debug, Clone, Copy)]
+pub struct Samarog<'log> {
+ log: &'log Log,
+}
+
+impl<'log> Samarog<'log> {
+ /// Create a new [`Samarog`] analyzer for the given log.
+ ///
+ /// **Do not** use this method unless you know what you are doing. Instead, rely on
+ /// [`Log::analyzer`]!
+ pub fn new(log: &'log Log) -> Self {
+ Samarog { log }
+ }
+}
+
+impl<'log> Analyzer for Samarog<'log> {
+ fn log(&self) -> &Log {
+ self.log
+ }
+
+ fn is_cm(&self) -> bool {
+ helpers::boss_health(self.log)
+ .map(|h| h >= SAMAROG_CM_HEALTH)
+ .unwrap_or(false)
+ }
+
+ fn outcome(&self) -> Option<Outcome> {
+ Outcome::from_bool(helpers::boss_is_dead(self.log))
+ }
+}
+
+pub const DEIMOS_CM_HEALTH: u64 = 42_000_000;
+
+/// Analyzer for the fourth fight of Wing 4, Deimos.
+///
+/// The CM is detected by the boss's health, which is higher in the challenge mote.
+#[derive(Debug, Clone, Copy)]
+pub struct Deimos<'log> {
+ log: &'log Log,
+}
+
+impl<'log> Deimos<'log> {
+ /// Create a new [`Deimos`] analyzer for the given log.
+ ///
+ /// **Do not** use this method unless you know what you are doing. Instead, rely on
+ /// [`Log::analyzer`]!
+ pub fn new(log: &'log Log) -> Self {
+ Deimos { log }
+ }
+}
+
+impl<'log> Analyzer for Deimos<'log> {
+ fn log(&self) -> &Log {
+ self.log
+ }
+
+ fn is_cm(&self) -> bool {
+ helpers::boss_health(self.log)
+ .map(|h| h >= DEIMOS_CM_HEALTH)
+ .unwrap_or(false)
+ }
+
+ fn outcome(&self) -> Option<Outcome> {
+ // The idea for Deimos is that we first need to figure out when the 10% split happens (if
+ // it even happens), then we can find the time when 10%-Deimos becomes untargetable and
+ // then we can compare this time to the player exit time.
+
+ let split_time = deimos_10_time(self.log);
+ // We never got to 10%, so this is a fail.
+ if split_time == 0 {
+ return Some(Outcome::Failure);
+ }
+
+ let at_address = deimos_at_address(self.log);
+ if at_address == 0 {
+ return Some(Outcome::Failure);
+ }
+
+ let mut player_exit = 0u64;
+ let mut at_exit = 0u64;
+ for event in self.log.events() {
+ match event.kind() {
+ EventKind::ExitCombat { agent_addr }
+ if self
+ .log
+ .agent_by_addr(*agent_addr)
+ .map(|a| a.kind().is_player())
+ .unwrap_or(false)
+ && event.time() >= player_exit =>
+ {
+ player_exit = event.time();
+ }
+
+ EventKind::Targetable {
+ agent_addr,
+ targetable,
+ } if *agent_addr == at_address && !targetable && event.time() >= at_exit => {
+ at_exit = event.time();
+ }
+
+ _ => (),
+ }
+ }
+
+ // Safety margin
+ Outcome::from_bool(player_exit > at_exit + 1000)
+ }
+}
+
+// Extracts the timestamp when Deimos's 10% phase started.
+//
+// This function may panic when passed non-Deimos logs!
+fn deimos_10_time(log: &Log) -> u64 {
+ let mut first_aware = 0u64;
+
+ for event in log.events() {
+ if let EventKind::Targetable { targetable, .. } = event.kind() {
+ if *targetable {
+ first_aware = event.time();
+ println!("First aware: {}", first_aware);
+ }
+ }
+ }
+
+ first_aware
+}
+
+// Returns the attack target address for the 10% Deimos phase.
+//
+// Returns 0 when the right attack target is not found.
+fn deimos_at_address(log: &Log) -> u64 {
+ for event in log.events().iter().rev() {
+ if let EventKind::AttackTarget {
+ agent_addr,
+ parent_agent_addr,
+ ..
+ } = event.kind()
+ {
+ let parent = log.agent_by_addr(*parent_agent_addr);
+ if let Some(parent) = parent {
+ if Some("Deimos") == parent.as_gadget().map(|g| g.name()) {
+ return *agent_addr;
+ }
+ }
+ }
+ }
+ 0
+}
diff --git a/src/analyzers/raids/w5.rs b/src/analyzers/raids/w5.rs
new file mode 100644
index 0000000..578cea8
--- /dev/null
+++ b/src/analyzers/raids/w5.rs
@@ -0,0 +1,90 @@
+//! Boss fight analyzers for Wing 5 (Hall of Chains)
+use crate::{
+ analyzers::{helpers, Analyzer, Outcome},
+ EventKind, Log,
+};
+
+pub const DESMINA_BUFF_ID: u32 = 47414;
+pub const DESMINA_MS_THRESHOLD: u64 = 11_000;
+pub const DESMINA_DEATH_BUFF: u32 = 895;
+
+/// Analyzer for the first fight of Wing 5, Soulless Horror (aka. Desmina).
+///
+/// The CM is detected by the time between applications of the Necrosis debuff, which is applied at
+/// a faster rate when the challenge mote is active.
+#[derive(Debug, Clone, Copy)]
+pub struct SoullessHorror<'log> {
+ log: &'log Log,
+}
+
+impl<'log> SoullessHorror<'log> {
+ /// Create a new [`SoullessHorror`] analyzer for the given log.
+ ///
+ /// **Do not** use this method unless you know what you are doing. Instead, rely on
+ /// [`Log::analyzer`]!
+ pub fn new(log: &'log Log) -> Self {
+ SoullessHorror { log }
+ }
+}
+
+impl<'log> Analyzer for SoullessHorror<'log> {
+ fn log(&self) -> &Log {
+ self.log
+ }
+
+ fn is_cm(&self) -> bool {
+ let tbb = helpers::time_between_buffs(self.log, DESMINA_BUFF_ID);
+ tbb > 0 && tbb <= DESMINA_MS_THRESHOLD
+ }
+
+ fn outcome(&self) -> Option<Outcome> {
+ Outcome::from_bool(self.log.events().iter().any(|event| {
+ if let EventKind::BuffApplication {
+ buff_id,
+ destination_agent_addr,
+ ..
+ } = event.kind()
+ {
+ self.log.is_boss(*destination_agent_addr) && *buff_id == DESMINA_DEATH_BUFF
+ } else {
+ false
+ }
+ }))
+ }
+}
+
+pub const DHUUM_CM_HEALTH: u64 = 40_000_000;
+
+/// Analyzer for the second fight of Wing 5, Dhuum.
+///
+/// The CM is detected by the boss's health, which is higher in the challenge mote.
+#[derive(Debug, Clone, Copy)]
+pub struct Dhuum<'log> {
+ log: &'log Log,
+}
+
+impl<'log> Dhuum<'log> {
+ /// Create a new [`Dhuum`] analyzer for the given log.
+ ///
+ /// **Do not** use this method unless you know what you are doing. Instead, rely on
+ /// [`Log::analyzer`]!
+ pub fn new(log: &'log Log) -> Self {
+ Dhuum { log }
+ }
+}
+
+impl<'log> Analyzer for Dhuum<'log> {
+ fn log(&self) -> &Log {
+ self.log
+ }
+
+ fn is_cm(&self) -> bool {
+ helpers::boss_health(self.log)
+ .map(|h| h >= DHUUM_CM_HEALTH)
+ .unwrap_or(false)
+ }
+
+ fn outcome(&self) -> Option<Outcome> {
+ Outcome::from_bool(helpers::boss_is_dead(self.log))
+ }
+}
diff --git a/src/analyzers/raids/w6.rs b/src/analyzers/raids/w6.rs
new file mode 100644
index 0000000..8701a63
--- /dev/null
+++ b/src/analyzers/raids/w6.rs
@@ -0,0 +1,149 @@
+//! Boss fight analyzers for Wing 6 (Mythwright Gambit)
+use crate::{
+ analyzers::{helpers, Analyzer, Outcome},
+ gamedata::{KENUT_ID, NIKARE_ID},
+ EventKind, Log,
+};
+
+pub const CA_CM_BUFF: u32 = 53_075;
+pub const ZOMMOROS_ID: u16 = 21_118;
+
+/// Analyzer for the first fight of Wing 6, Conjured Amalgamate.
+///
+/// The CM is detected by the presence of the buff that the player targeted by the laser has.
+#[derive(Debug, Clone, Copy)]
+pub struct ConjuredAmalgamate<'log> {
+ log: &'log Log,
+}
+
+impl<'log> ConjuredAmalgamate<'log> {
+ /// Create a new [`ConjuredAmalgamate`] analyzer for the given log.
+ ///
+ /// **Do not** use this method unless you know what you are doing. Instead, rely on
+ /// [`Log::analyzer`]!
+ pub fn new(log: &'log Log) -> Self {
+ ConjuredAmalgamate { log }
+ }
+}
+
+impl<'log> Analyzer for ConjuredAmalgamate<'log> {
+ fn log(&self) -> &Log {
+ self.log
+ }
+
+ fn is_cm(&self) -> bool {
+ helpers::buff_present(self.log, CA_CM_BUFF)
+ }
+
+ fn outcome(&self) -> Option<Outcome> {
+ for event in self.log.events() {
+ if let EventKind::Spawn { agent_addr } = event.kind() {
+ if self
+ .log
+ .agent_by_addr(*agent_addr)
+ .and_then(|a| a.as_character())
+ .map(|a| a.id() == ZOMMOROS_ID)
+ .unwrap_or(false)
+ {
+ return Some(Outcome::Success);
+ }
+ }
+ }
+ Some(Outcome::Failure)
+ }
+}
+
+pub const LARGOS_CM_HEALTH: u64 = 19_200_000;
+
+/// Analyzer for the second fight of Wing 6, Largos Twins.
+///
+/// The CM is detected by the boss's health, which is higher in the challenge mote.
+#[derive(Debug, Clone, Copy)]
+pub struct LargosTwins<'log> {
+ log: &'log Log,
+}
+
+impl<'log> LargosTwins<'log> {
+ /// Create a new [`LargosTwins`] analyzer for the given log.
+ ///
+ /// **Do not** use this method unless you know what you are doing. Instead, rely on
+ /// [`Log::analyzer`]!
+ pub fn new(log: &'log Log) -> Self {
+ LargosTwins { log }
+ }
+}
+
+impl<'log> Analyzer for LargosTwins<'log> {
+ fn log(&self) -> &Log {
+ self.log
+ }
+
+ fn is_cm(&self) -> bool {
+ helpers::boss_health(self.log)
+ .map(|h| h >= LARGOS_CM_HEALTH)
+ .unwrap_or(false)
+ }
+
+ fn outcome(&self) -> Option<Outcome> {
+ let mut nikare_dead = false;
+ let mut kenut_dead = false;
+
+ for event in self.log.events() {
+ if let EventKind::ChangeDead { agent_addr } = event.kind() {
+ let agent = if let Some(agent) = self
+ .log
+ .agent_by_addr(*agent_addr)
+ .and_then(|a| a.as_character())
+ {
+ agent
+ } else {
+ continue;
+ };
+
+ if agent.id() == NIKARE_ID {
+ nikare_dead = true;
+ } else if agent.id() == KENUT_ID {
+ kenut_dead = true;
+ }
+ }
+ }
+
+ Outcome::from_bool(kenut_dead && nikare_dead)
+ }
+}
+
+pub const QADIM_CM_HEALTH: u64 = 21_100_000;
+
+/// Analyzer for the third fight of Wing 6, Qadim.
+///
+/// The CM is detected by the boss's health, which is higher in the challenge mote.
+#[derive(Debug, Clone, Copy)]
+pub struct Qadim<'log> {
+ log: &'log Log,
+}
+
+impl<'log> Qadim<'log> {
+ /// Create a new [`Qadim`] analyzer for the given log.
+ ///
+ /// **Do not** use this method unless you know what you are doing. Instead, rely on
+ /// [`Log::analyzer`]!
+ pub fn new(log: &'log Log) -> Self {
+ Qadim { log }
+ }
+}
+
+impl<'log> Analyzer for Qadim<'log> {
+ fn log(&self) -> &Log {
+ self.log
+ }
+
+ fn is_cm(&self) -> bool {
+ helpers::boss_health(self.log)
+ .map(|h| h >= QADIM_CM_HEALTH)
+ .unwrap_or(false)
+ }
+
+ fn outcome(&self) -> Option<Outcome> {
+ Outcome::from_bool(helpers::players_exit_after_boss(self.log))
+ }
+}
diff --git a/src/analyzers/raids/w7.rs b/src/analyzers/raids/w7.rs
new file mode 100644
index 0000000..bdfadd6
--- /dev/null
+++ b/src/analyzers/raids/w7.rs
@@ -0,0 +1,111 @@
+//! Boss fight analyzers for Wing 6 (Mythwright Gambit)
+use crate::{
+ analyzers::{helpers, Analyzer, Outcome},
+ Log,
+};
+
+pub const ADINA_CM_HEALTH: u64 = 24_800_000;
+
+/// Analyzer for the first fight of Wing 7, Cardinal Adina.
+///
+/// The CM is detected by the boss's health, which is higher in the challenge mote.
+#[derive(Debug, Clone, Copy)]
+pub struct CardinalAdina<'log> {
+ log: &'log Log,
+}
+
+impl<'log> CardinalAdina<'log> {
+ /// Create a new [`CardinalAdina`] analyzer for the given log.
+ ///
+ /// **Do not** use this method unless you know what you are doing. Instead, rely on
+ /// [`Log::analyzer`]!
+ pub fn new(log: &'log Log) -> Self {
+ CardinalAdina { log }
+ }
+}
+
+impl<'log> Analyzer for CardinalAdina<'log> {
+ fn log(&self) -> &Log {
+ self.log
+ }
+
+ fn is_cm(&self) -> bool {
+ helpers::boss_health(self.log)
+ .map(|h| h >= ADINA_CM_HEALTH)
+ .unwrap_or(false)
+ }
+
+ fn outcome(&self) -> Option<Outcome> {
+ Outcome::from_bool(helpers::boss_is_dead(self.log))
+ }
+}
+
+pub const SABIR_CM_HEALTH: u64 = 32_400_000;
+
+/// Analyzer for the second fight of Wing 7, Cardinal Sabir.
+///
+/// The CM is detected by the boss's health, which is higher in the challenge mote.
+#[derive(Debug, Clone, Copy)]
+pub struct CardinalSabir<'log> {
+ log: &'log Log,
+}
+
+impl<'log> CardinalSabir<'log> {
+ /// Create a new [`CardinalSabir`] analyzer for the given log.
+ ///
+ /// **Do not** use this method unless you know what you are doing. Instead, rely on
+ /// [`Log::analyzer`]!
+ pub fn new(log: &'log Log) -> Self {
+ CardinalSabir { log }
+ }
+}
+
+impl<'log> Analyzer for CardinalSabir<'log> {
+ fn log(&self) -> &Log {
+ self.log
+ }
+
+ fn is_cm(&self) -> bool {
+ helpers::boss_health(self.log)
+ .map(|h| h >= SABIR_CM_HEALTH)
+ .unwrap_or(false)
+ }
+
+ fn outcome(&self) -> Option<Outcome> {
+ Outcome::from_bool(helpers::boss_is_dead(self.log))
+ }
+}
+
+pub const QADIMP_CM_HEALTH: u64 = 51_000_000;
+
+/// Analyzer for the final fight of Wing 7, Qadim The Peerless.
+#[derive(Debug, Clone, Copy)]
+pub struct QadimThePeerless<'log> {
+ log: &'log Log,
+}
+
+impl<'log> QadimThePeerless<'log> {
+ /// Create a new [`QadimThePeerless`] analyzer for the given log.
+ ///
+ /// **Do not** use this method unless you know what you are doing. Instead, rely on
+ /// [`Log::analyzer`]!
+ pub fn new(log: &'log Log) -> Self {
+ QadimThePeerless { log }
+ }
+}
+
+impl<'log> Analyzer for QadimThePeerless<'log> {
+ fn log(&self) -> &Log {
+ self.log
+ }
+
+ fn is_cm(&self) -> bool {
+ helpers::boss_health(self.log)
+ .map(|h| h >= QADIMP_CM_HEALTH)
+ .unwrap_or(false)
+ }
+
+ fn outcome(&self) -> Option<Outcome> {
+ Outcome::from_bool(helpers::boss_is_dead(self.log))
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-01 15:27:41 +0000