Enum EpisodeState 

#[repr(u32)]
pub enum EpisodeState {
    Running = 0,
    Terminal = 1,
    Interrupted = 2,
    Initial = 3,
}

Variants

Running = 0

Episode is running.

Terminal = 1

The episode has been terminated due to something the agent did.

The backend may use terminal masking for this state. In that case the agent will behave as if from this state it cannot receive any more rewards.

This state is useful if the agent for example has died or in some other way ended up in a non-recoverable state.

The agent will receive a ark_api::Response::EndOfEpisode when evaluating an observation with this state. This agent is considered removed from the simulation and you may not send in an observation with the same id again.

Interrupted = 2

The episode has been terminated due to an external reason that the agent cannot control.

This is useful for things like timeouts that aren’t necessarily due to bad behavior of the agent. No terminal masking will be used in this case.

The agent will receive a ark_api::Response::EndOfEpisode when evaluating an observation with this state. This agent is considered removed from the simulation and you may not send in an observation with the same id again.

Initial = 3

First frame of the episode.

The first observation that an agent sends to the engine must always be marked with this episode state.

Trait Implementations

impl CheckedBitPattern for EpisodeState

type Bits = u32

Self must have the same layout as the specified Bits except for the possible invalid bit patterns being checked during is_valid_bit_pattern.

fn is_valid_bit_pattern(bits: &Self::Bits) -> bool

If this function returns true, then it must be valid to reinterpret bits as &Self.

impl Clone for EpisodeState

fn clone(&self) -> EpisodeState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EpisodeState

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

Formats the value using the given formatter.

impl From<EpisodeState> for u32

fn from(enum_value: EpisodeState) -> Self

Converts to this type from the input type.

impl Hash for EpisodeState

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for EpisodeState

fn eq(&self, other: &EpisodeState) -> 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 TryFrom<u32> for EpisodeState

type Error = TryFromPrimitiveError<EpisodeState>

The type returned in the event of a conversion error.

fn try_from(number: u32) -> Result<Self, TryFromPrimitiveError<Self>>

Performs the conversion.

impl TryFromPrimitive for EpisodeState

const NAME: &'static str = "EpisodeState"

type Primitive = u32

fn try_from_primitive( number: Self::Primitive, ) -> Result<Self, TryFromPrimitiveError<Self>>

impl Copy for EpisodeState

impl Eq for EpisodeState

impl NoUninit for EpisodeState

impl StructuralPartialEq for EpisodeState