Struct Character 

pub struct Character {
    pub body: Body,
    pub space: Handle<Space>,
    /* private fields */
}

A Character:

• knows what Space it is looking at, by Handle,
• knows where it is located and how it collides via a Body which it owns and steps, and
• handles the parts of input management that are associated with universe state (controlling velocity, holding tools).

Serialization stability warning

This type implements serde::Serialize and serde::Deserialize, but serialization support is still experimental (as is the game data model in general). We do not guarantee that future versions of all-is-cubes will be able to deserialize data which is serialized by this version.

Additionally, the serialization schema is designed with serde_json in mind. It is not guaranteed that using a different data format crate, which may use a different subset of the information exposed via serde::Serialize, will produce stable results.

Fields

body: Body

Position, collision, and look direction.

space: Handle<Space>

Refers to the Space to be viewed and collided with.

Implementations

impl Character

pub fn spawn(spawn: &Spawn, space: Handle<Space>) -> Self

Constructs a Character within/looking at the given space with the initial state specified by spawn.

pub fn spawn_default( read_ticket: ReadTicket<'_>, space: Handle<Space>, ) -> Result<Self, HandleError>

Constructs a Character within/looking at the given space with the initial state specified by Space::spawn.

pub fn view<'t>( handle: &Handle<Self>, read_ticket: ReadTicket<'t>, ) -> Result<(&'t Handle<Space>, ViewTransform, f32), HandleError>

Computes the view transform for this character’s eye; translation and rotation from the camera coordinate system (whose look direction is the -Z axis) to the Space’s coordinate system.

See the documentation for [ViewTransform] for the interpretation of this transform.

In addition to the transform it also returns the Space to be viewed and the automatic exposure value.

TODO: This return value should really be a struct, but we are somewhat in the middle of refactoring how Character is built and this particular tuple is an interim measure.

pub fn inventory(&self) -> &Inventory

Returns the character’s current inventory.

pub fn selected_slots(&self) -> [Ix; 3]

Returns the character’s currently selected inventory slots.

The indices of this array are buttons (e.g. mouse buttons), and the values are inventory slot indices.

pub fn set_selected_slot(&mut self, which_selection: usize, slot: Ix)

Changes which inventory slot is currently selected.

pub fn click( read_ticket: ReadTicket<'_>, this: Handle<Character>, cursor: Option<&Cursor>, button: usize, ) -> Result<UniverseTransaction, ToolError>

Use this character’s selected tool on the given cursor.

Return an error if:

• The tool is not usable.
• The cursor does not refer to the same space as this character occupies.

Trait Implementations

impl Debug for Character

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Character

Available on crate feature save only.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Listen for Character

Registers a listener for mutations of this character.

type Msg = CharacterChange

The type of message which may be obtained from this source.

type Listener = <Notifier<<Character as Listen>::Msg, Arc<dyn Listener<<Character as Listen>::Msg> + Sync + Send>> as Listen>::Listener

The type which all added listeners must be convertible to.

fn listen_raw(&self, listener: Self::Listener)

Subscribe the given Listener to this source of messages.

fn listen<L>(&self, listener: L)

where L: IntoListener<Self::Listener, Self::Msg>, Self: Sized,

Subscribe the given Listener to this source of messages.

impl Serialize for Character

Available on crate feature save only.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Transactional for Character

type Transaction = CharacterTransaction

The type of transaction which should be used with Self.

fn transact<'c, F, O>( &mut self, f: F, ) -> Result<O, ExecuteError<Self::Transaction>>

where F: FnOnce(&mut Self::Transaction, &Self) -> Result<O, <Self::Transaction as Merge>::Conflict>, Self::Transaction: Transaction<Target = Self, Context<'c> = (), Output = NoOutput> + Default,

Convenience method for building and then applying a transaction to self, equivalent to the following steps:

impl UTransactional for Character

fn bind( target: Handle<Self>, transaction: Self::Transaction, ) -> UniverseTransaction

Specify the target of the transaction as a Handle, and erase its type, so that it can be combined with other transactions in the same universe.

impl UniverseMember for Character

type Read<'ticket> = Read<'ticket>

Type returned by Handle::<T>::read() which is the way to read the T value after it has been inserted into the Universe.

impl VisitHandles for Character

fn visit_handles(&self, visitor: &mut dyn HandleVisitor)

For each Handle contained within self that is reachable without traversing another Handle, call visitor with a reference to it.