Struct OverlordState

pub struct OverlordState {

    pub character_state: CharacterState,
    pub blocked_character_ids: Vec<Uuid>,
    pub active_fight: Option<ActiveFight>,
    pub pvp_state: Option<PVPState>,
    pub connection_store: HashMap<String, i64>,
    pub quest_groups: QuestsGroups,
    pub incoming_gifts: Vec<Gift>,
    pub incoming_mails: Vec<Mail>,
    pub patron: Option<Patron>,
    pub referral_daily_reward_claimed: Option<bool>,
    pub auto_chest: AutoChest,
    pub arena: Arena,
    pub dungeons: Dungeons,
    pub offers_info: OffersInfo,
    pub permissions: Vec<UserPermissions>,
    pub party: Party,
    pub progress_pass: ProgressPassState,
}

Fields

character_state: CharacterState

blocked_character_ids: Vec<Uuid>

active_fight: Option<ActiveFight>

pvp_state: Option<PVPState>

connection_store: HashMap<String, i64>

quest_groups: QuestsGroups

incoming_gifts: Vec<Gift>

incoming_mails: Vec<Mail>

patron: Option<Patron>

referral_daily_reward_claimed: Option<bool>

auto_chest: AutoChest

arena: Arena

dungeons: Dungeons

offers_info: OffersInfo

permissions: Vec<UserPermissions>

party: Party

progress_pass: ProgressPassState

Implementations

impl OverlordState

pub fn claim_vassal_reward( &mut self, vassal_id: Uuid, claim_time: DateTime<Utc>, ) -> Result<()>

pub fn claim_suzerain_reward(&mut self, claim_time: DateTime<Utc>) -> Result<()>

pub fn compute_description_values_for_ability( &self, ability: &Ability, behaviors: &BehaviorRegistry, config: &GameConfig, ) -> Vec<f64>

pub fn compute_description_values_for_talent( &self, talent_template: &TalentTemplate, level: i64, ) -> Vec<f64>

pub fn compute_description_values_template( &self, ability_template: &AbilityTemplate, behaviors: &BehaviorRegistry, config: &GameConfig, ) -> Vec<f64>

pub fn compute_afk_reward( &self, game_config: &GameConfig, behaviors: &BehaviorRegistry, ) -> Vec<BundleElement>

pub fn compute_afk_instant_reward( &self, game_config: &GameConfig, behaviors: &BehaviorRegistry, ) -> Vec<BundleElement>

pub fn compute_bundle_reward( &self, game_config: &GameConfig, behaviors: &BehaviorRegistry, bundle_id: BundleId, ) -> Vec<BundleElement>

pub fn calculate_item_power( &self, item: Item, game_config: &GameConfig, behaviors: &BehaviorRegistry, ) -> Result<i64>

pub fn get_active_fight_player(&self) -> Option<&Entity>

pub fn get_active_fight_player_mut(&mut self) -> Option<&mut Entity>

Trait Implementations

impl Clone for OverlordState

fn clone(&self) -> OverlordState

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for OverlordState

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for OverlordState

fn default() -> OverlordState

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for OverlordState

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl EventHandler<OverlordEvent, OverlordState> for PureEventHandler

type Context = ()

async fn create_context_for_batch( &self, _state: &OverlordState, ) -> Result<Self::Context>

async fn handle_event( &mut self, _ctx: &Self::Context, event: &OverlordEvent, meta: EventMeta, prev_state: &OverlordState, state: OverlordState, ) -> Result<EventHandleResult<OverlordEvent, OverlordState>>

One call per event. prev_state is the System’s state before this event (same data as state, by reference — avoids an extra clone for the compute_fields diff). Impls are responsible for: pure state mutation -> compute_fields fold (diff vs prev_state, runs for failed results too; prepend emitted events) -> DB persistence / validation -> analytics deferral. Err(_) aborts the whole batch (txn rollback). “Soft” failures must be returned as Ok(EventHandleResult::fail(...)).

fn compute_fields( &self, state: &mut OverlordState, prev_state: &OverlordState, ) -> Vec<OverlordEvent>

Can be used to compute fields that arent stored in database, but computed from stored data. Also can emit events on some logical data changes. This events eventually can change state. Sync, no DB. Called by impls inside handle_event and by System::apply_state_with_compute_fields.

fn collect_due_scheduled(&mut self, current_tick: u64) -> Vec<OverlordEvent>

Events the handler scheduled internally that are due at current_tick. Drained alongside the delayed/cron plugins on every tick. Lets a handler own domain scheduling (e.g. the fight clock) so the same state drives both the live system and standalone simulations. Deliberately has no default body — every impl must state it explicitly.

async fn finalize_state( &self, _ctx: &Self::Context, _state: &mut OverlordState, ) -> Result<()>

async fn persist_in_memory_state( &self, _ctx: &Self::Context, _state: &OverlordState, ) -> Result<()>

Persist in-memory state to DB context before commit. Called by flush_state to save changes accumulated between batches.

fn event_needs_full_context(&self, _event: &E, _state: &S) -> bool

Whether handling event may touch the context’s backing resources (DB transaction, persistence). Handlers that support pure (DB-less) contexts override this for events whose handling is pure logic end-to-end; the default — true for every event — keeps the eager full-context behavior. state is the System state at dispatch time — handlers use it for state-dependent persistence (e.g. quest subscriptions that persist progress on otherwise-pure events).

fn create_pure_context_for_batch( &self, state: &S, ) -> impl Future<Output = Result<Self::Context, Error>> + Send

Create a context for a batch whose events all have event_needs_full_context == false. Defaults to the full context.

fn context_is_pure(&self, _ctx: &Self::Context) -> bool

Whether ctx is a pure (DB-less) context that must be upgraded via upgrade_context before handling a full-context event.

fn upgrade_context( &self, ctx: Self::Context, _state: &S, ) -> impl Future<Output = Result<Self::Context, Error>> + Send

where Self::Context: Send,

Upgrade a pure context into a full one, carrying over all state accumulated so far. Only called when context_is_pure is true.

impl From<OverlordState> for JsValue

where OverlordState: Serialize,

fn from(value: OverlordState) -> Self

Converts to this type from the input type.

impl IntoWasmAbi for OverlordState

where OverlordState: Serialize,

type Abi = <JsType as IntoWasmAbi>::Abi

The Wasm ABI type that this converts into when crossing the ABI boundary.

fn into_abi(self) -> Self::Abi

Convert self into Self::Abi so that it can be sent across the wasm ABI boundary.

impl JsonSchema for OverlordState

fn schema_name() -> String

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl OptionIntoWasmAbi for OverlordState

where OverlordState: Serialize,

fn none() -> Self::Abi

Returns an ABI instance indicating “none”, which JS will interpret as the None branch of this option.

impl PartialEq for OverlordState

fn eq(&self, other: &OverlordState) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for OverlordState

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl State for OverlordState

fn cmp_db_updated(&self, db_updated: &Self) -> bool

Compares version from database with local

fn is_ticker_paused(&self) -> bool

impl Tsify for OverlordState

const DECL: &'static str = "export interface OverlordState {\n character_state: CharacterState;\n blocked_character_ids: Uuid[];\n active_fight: ActiveFight | null;\n pvp_state: PVPState | null;\n connection_store: Record<string, number>;\n quest_groups: QuestsGroups;\n incoming_gifts: Gift[];\n incoming_mails: Mail[];\n patron: Patron | null;\n referral_daily_reward_claimed: boolean | null;\n auto_chest: AutoChest;\n arena: Arena;\n dungeons: Dungeons;\n offers_info: OffersInfo;\n permissions: UserPermissions[];\n party: Party;\n progress_pass: ProgressPassState;\n}"

const SERIALIZATION_CONFIG: SerializationConfig

type JsType = JsType

fn into_js(&self) -> Result<Self::JsType, Error>

where Self: Serialize,

fn from_js<T>(js: T) -> Result<Self, Error>

where T: Into<JsValue>, Self: DeserializeOwned,

impl VectorIntoWasmAbi for OverlordState

where OverlordState: Serialize,

type Abi = <JsType as VectorIntoWasmAbi>::Abi

fn vector_into_abi(vector: Box<[Self]>) -> Self::Abi

impl WasmDescribe for OverlordState

fn describe()

impl WasmDescribeVector for OverlordState

fn describe_vector()

impl Eq for OverlordState

impl StructuralPartialEq for OverlordState