Struct otter_nodejs_tests::GenericSimpleShape

pub struct GenericSimpleShape<Desc, Outl> {
    pub desc: Desc,
    pub edges: IndexVec<FaceId, Html>,
    pub edge_width: f64,
    pub itemname: String,
    pub outline: Outl,
    /* private fields */
}

Fields

desc: Desc

edges: IndexVec<FaceId, Html>

edge_width: f64

itemname: String

outline: Outl

Implementations

impl<Desc, Outl> GenericSimpleShape<Desc, Outl> where
    Outl: 'static + OutlineTrait,
    Desc: 'static + Debug + Send + Sync, 

pub fn count_faces(&self) -> u8

pub fn itemname(&self) -> &str

pub fn new(
    desc: Desc,
    outline: Outl,
    def_itemname: &str,
    common: &SimpleCommon
) -> Result<GenericSimpleShape<Desc, Outl>, SpecError>

pub fn svg_piece_raw(
    &self,
    f: &mut Html,
    face: FaceId,
    stroke_attrs_hook: &mut dyn FnMut(&mut Html)
) -> Result<(), InternalError>

Trait Implementations

impl<Desc, Outl> Debug for GenericSimpleShape<Desc, Outl> where
    Desc: Debug,
    Outl: Debug, 

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

Formats the value using the given formatter.

impl<Desc, Outl> DerivedDynCast<ConcreteDynCastConfig<dyn OutlineTrait + 'static, dyn OutlineTrait + 'static>, <dyn OutlineTrait + 'static as GetDynCastConfig<dyn OutlineTrait + 'static>>::Config> for GenericSimpleShape<Desc, Outl> where
    Desc: 'static + Debug + Send + Sync,
    Outl: OutlineTrait + 'static, 

fn derived_dyn_cast_ref(
    &self
) -> Result<&(dyn OutlineTrait + 'static), &(dyn OutlineTrait + 'static)>

Cast a shared reference of this trait object to another trait object.

fn derived_dyn_cast_mut(
    &mut self
) -> Result<&mut (dyn OutlineTrait + 'static), &mut (dyn OutlineTrait + 'static)>

Cast a mutable/unique reference of this trait object to another trait object.

fn derived_dyn_cast_boxed(
    self: Box<GenericSimpleShape<Desc, Outl>, Global>
) -> Result<Box<dyn OutlineTrait + 'static, Global>, Box<dyn OutlineTrait + 'static, Global>>

Cast a boxed trait object to another trait object.

fn derived_dyn_cast_rc(
    self: Rc<GenericSimpleShape<Desc, Outl>>
) -> Result<Rc<dyn OutlineTrait + 'static>, Rc<dyn OutlineTrait + 'static>>

Cast a reference counted trait object to another trait object.

fn derived_dyn_cast_arc(
    self: Arc<GenericSimpleShape<Desc, Outl>>
) -> Result<Arc<dyn OutlineTrait + 'static>, Arc<dyn OutlineTrait + 'static>>

Cast an atomically reference counted trait object to another trait object.

impl<'de, Desc, Outl> Deserialize<'de> for GenericSimpleShape<Desc, Outl> where
    Desc: Deserialize<'de>,
    Outl: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<GenericSimpleShape<Desc, Outl>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl DynCast<<dyn PieceBaseTrait + 'static as GetDynCastConfig<dyn PieceBaseTrait + 'static>>::Config> for GenericSimpleShape<Html, Outline>

fn dyn_cast_ref(
    &self
) -> Result<&<<dyn PieceBaseTrait + 'static as GetDynCastConfig<dyn PieceBaseTrait + 'static>>::Config as DynCastConfig>::Target, &<<dyn PieceBaseTrait + 'static as GetDynCastConfig<dyn PieceBaseTrait + 'static>>::Config as DynCastConfig>::Source>

Cast a shared reference of this trait object to another trait object.

fn dyn_cast_mut(
    &mut self
) -> Result<&mut <<dyn PieceBaseTrait + 'static as GetDynCastConfig<dyn PieceBaseTrait + 'static>>::Config as DynCastConfig>::Target, &mut <<dyn PieceBaseTrait + 'static as GetDynCastConfig<dyn PieceBaseTrait + 'static>>::Config as DynCastConfig>::Source>

Cast a mutable/unique reference of this trait object to another trait object.

fn dyn_cast_boxed(
    self: Box<GenericSimpleShape<Html, Outline>, Global>
) -> Result<Box<<<dyn PieceBaseTrait + 'static as GetDynCastConfig<dyn PieceBaseTrait + 'static>>::Config as DynCastConfig>::Target, Global>, Box<<<dyn PieceBaseTrait + 'static as GetDynCastConfig<dyn PieceBaseTrait + 'static>>::Config as DynCastConfig>::Source, Global>>

Cast a boxed trait object to another trait object.

fn dyn_cast_rc(
    self: Rc<GenericSimpleShape<Html, Outline>>
) -> Result<Rc<<<dyn PieceBaseTrait + 'static as GetDynCastConfig<dyn PieceBaseTrait + 'static>>::Config as DynCastConfig>::Target>, Rc<<<dyn PieceBaseTrait + 'static as GetDynCastConfig<dyn PieceBaseTrait + 'static>>::Config as DynCastConfig>::Source>>

Cast a reference counted trait object to another trait object.

fn dyn_cast_arc(
    self: Arc<GenericSimpleShape<Html, Outline>>
) -> Result<Arc<<<dyn PieceBaseTrait + 'static as GetDynCastConfig<dyn PieceBaseTrait + 'static>>::Config as DynCastConfig>::Target>, Arc<<<dyn PieceBaseTrait + 'static as GetDynCastConfig<dyn PieceBaseTrait + 'static>>::Config as DynCastConfig>::Source>>

Cast an atomically reference counted trait object to another trait object.

impl InertPieceTrait for GenericSimpleShape<Html, Outline>

fn svg(
    &self,
    f: &mut Html,
    _vpid: VisiblePieceId,
    face: FaceId,
    &Option<Box<dyn PieceXData + 'static, Global>>
) -> Result<(), InternalError>

When used for occultated version of another object, face used is always default, regardless of nfaces. This is always the case for a piece whose PieceSpec::load returns Some for occultation, but which does not provide a nontrivial PieceSpec::load_inert.

fn describe_html(&self, FaceId) -> Result<Html, InternalError>

impl<Desc, Outl> OutlineTrait for GenericSimpleShape<Desc, Outl> where
    Outl: 'static + OutlineTrait,
    Desc: 'static + Debug + Send + Sync, 

fn outline_path(&self, scale: f64) -> Result<Html, InternalError>

fn surround_path(&self) -> Result<Html, InternalError>

fn thresh_dragraise(&self) -> Result<Option<i32>, InternalError>

fn bbox_approx(&self) -> Result<RectC<i32>, InternalError>

fn shape(&self) -> Option<Shape>

impl PieceBaseTrait for GenericSimpleShape<Html, Outline>

fn nfaces(&self) -> u8

By convention, occult face is nfaces-1

fn itemname(&self) -> &str

impl PieceTrait for GenericSimpleShape<Html, Outline>

fn svg_piece(
    &self,
    f: &mut Html,
    gpc: &GPiece,
    _gs: &GameState,
    _vpid: VisiblePieceId
) -> Result<(), InternalError>

fn describe_html(
    &self,
    gpc: &GPiece,
    _goccults: &GOccults
) -> Result<Html, InternalError>

fn add_ui_operations(
    &self,
    _y: ShowUnocculted,
    _upd: &mut Vec<UoDescription, Global>,
    _gs: &GameState,
    _gpc: &GPiece
) -> Result<(), InternalError>

fn ui_operation(
    &self,
    _y: ShowUnocculted,
    _a: ApiPieceOpArgs<'_>,
    _opname: &str,
    _wrc: WhatResponseToClientOp
) -> Result<OpOutcomeThunkGeneric<(PlayerId, PieceId), (PieceUpdate, Vec<Box<dyn FnOnce(&'r mut PrepareUpdatesBuffer<'_>) + 'static, Global>, Global>), ApiPieceOpError>, ApiPieceOpError>

fn ui_permit_flip(&self, _gpc: &GPiece) -> Result<bool, ApiPieceOpError>

Can return false to mean “I will handle it in ui_operation”

fn held_change_hook(
    &self,
    _ig: &InstanceRef,
    _gplayers: &DenseSlotMap<PlayerId, GPlayer>,
    _ipieces: &IPieces,
    _goccults: &GOccults,
    _gpieces: &mut GPieces,
    _tpiece: PieceId,
    _was_held: Option<PlayerId>
) -> Result<OpOutcomeThunkGeneric<(PlayerId,), Vec<Box<dyn FnOnce(&'r mut PrepareUpdatesBuffer<'_>) + 'static, Global>, Global>, InternalError>, InternalError>

Piece is responsible for dealing with the possibility that they may be occulted!

fn save_reloaded_hook(
    &self,
    _piece: PieceId,
    _gs: &mut GameState,
    _ig: &InstanceRef
) -> Result<(), InternalError>

fn loaded_hook_preview(&self, _gpc: &mut GPiece) -> Result<(), InternalError>

fn bbox_preview(&self) -> Result<RectC<i32>, InternalError>

fn delete_hook(
    &self,
    _p: &GPiece,
    _gs: &mut GameState
) -> ExecuteGameChangeUpdates

Not called if the whole game is destroyed. You can use Drop of course but it’s not usually much use since you don’t have a reference to the game or anything.

fn sortkey(&self) -> Option<&str>

fn occultation_notify_hook(
    &self,
    _piece: PieceId
) -> Vec<Box<dyn FnOnce(&'r mut PrepareUpdatesBuffer<'_>) + 'static, Global>, Global>

fn op_multigrab(
    &self,
    _a: ApiPieceOpArgs<'_>,
    _show: ShowUnocculted,
    _qty: u32,
    _new_z: ShouldSetZLevel
) -> Result<OpOutcomeThunkGeneric<(PlayerId, PieceId), (PieceUpdate, Vec<Box<dyn FnOnce(&'r mut PrepareUpdatesBuffer<'_>) + 'static, Global>, Global>), ApiPieceOpError>, ApiPieceOpError>

fn abs_bbox(&self, p: &GPiece) -> Result<RectC<i32>, InternalError>

impl<Desc, Outl> Serialize for GenericSimpleShape<Desc, Outl> where
    Desc: Serialize,
    Outl: Serialize, 

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

Serialize this value into the given Serde serializer.