age_0_15: Vec<(u16, u16)>,

age_0_2: Vec<(u16, u16)>,

age_0_25: Vec<(u16, u16)>,

age_0_3: Vec<(u16, u16)>,

age_0_5: Vec<(u16, u16)>,

age_0_7: Vec<(u16, u16)>,

attached: Vec<(u16, u16)>,

axis_xyz: Vec<(u16, u16)>,

axis_xz: Vec<(u16, u16)>,

bites: Vec<(u16, u16)>,

cauldron_level: Vec<(u16, u16)>,

chest_kind: Vec<(u16, u16)>,

comparator_mode: Vec<(u16, u16)>,

conditional: Vec<(u16, u16)>,

delay: Vec<(u16, u16)>,

disarmed: Vec<(u16, u16)>,

distance: Vec<(u16, u16)>,

down: Vec<(u16, u16)>,

drag: Vec<(u16, u16)>,

east_connected: Vec<(u16, u16)>,

east_wire: Vec<(u16, u16)>,

eggs: Vec<(u16, u16)>,

enabled: Vec<(u16, u16)>,

extended: Vec<(u16, u16)>,

eye: Vec<(u16, u16)>,

face: Vec<(u16, u16)>,

facing_cardinal: Vec<(u16, u16)>,

facing_cardinal_and_down: Vec<(u16, u16)>,

facing_cubic: Vec<(u16, u16)>,

half_top_bottom: Vec<(u16, u16)>,

half_upper_lower: Vec<(u16, u16)>,

has_bottle_0: Vec<(u16, u16)>,

has_bottle_1: Vec<(u16, u16)>,

has_bottle_2: Vec<(u16, u16)>,

has_record: Vec<(u16, u16)>,

hatch: Vec<(u16, u16)>,

hinge: Vec<(u16, u16)>,

in_wall: Vec<(u16, u16)>,

instrument: Vec<(u16, u16)>,

inverted: Vec<(u16, u16)>,

layers: Vec<(u16, u16)>,

lit: Vec<(u16, u16)>,

locked: Vec<(u16, u16)>,

moisture: Vec<(u16, u16)>,

north_connected: Vec<(u16, u16)>,

north_wire: Vec<(u16, u16)>,

note: Vec<(u16, u16)>,

occupied: Vec<(u16, u16)>,

open: Vec<(u16, u16)>,

part: Vec<(u16, u16)>,

persistent: Vec<(u16, u16)>,

pickles: Vec<(u16, u16)>,

piston_kind: Vec<(u16, u16)>,

power: Vec<(u16, u16)>,

powered: Vec<(u16, u16)>,

powered_rail_shape: Vec<(u16, u16)>,

rail_shape: Vec<(u16, u16)>,

rotation: Vec<(u16, u16)>,

short: Vec<(u16, u16)>,

slab_kind: Vec<(u16, u16)>,

snowy: Vec<(u16, u16)>,

south_connected: Vec<(u16, u16)>,

south_wire: Vec<(u16, u16)>,

stage: Vec<(u16, u16)>,

stairs_shape: Vec<(u16, u16)>,

structure_block_mode: Vec<(u16, u16)>,

triggered: Vec<(u16, u16)>,

unstable: Vec<(u16, u16)>,

up: Vec<(u16, u16)>,

water_level: Vec<(u16, u16)>,

waterlogged: Vec<(u16, u16)>,

west_connected: Vec<(u16, u16)>,

west_wire: Vec<(u16, u16)>,

#[doc = "Retrieves the `age_0_15` value for the given block kind with the given state value.\n Returns the value of the property, or `None` if it does not exist."]

pub fn age_0_15(&self, kind: BlockKind, state: u16) -> Option<i32> {

let (offset_coefficient, stride) = self.age_0_15[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let x = crate::n_dimensional_index(state, offset_coefficient, stride);

Some({ x as i32 + 0i32 })

}

#[doc = "Updates the state value for the given block kind such that its `age_0_15` value is updated. Returns the new state,\n or `None` if the block does not have this property."]

pub fn set_age_0_15(&self, kind: BlockKind, state: u16, value: i32) -> Option<u16> {

let (offset_coefficient, stride) = self.age_0_15[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let old = crate::n_dimensional_index(state, offset_coefficient, stride) as i32;

let new = ({ value as u16 - 0u16 } as i32 - old) * stride as i32 + state as i32;

Some(new as u16)

}

#[doc = "Retrieves the `age_0_2` value for the given block kind with the given state value.\n Returns the value of the property, or `None` if it does not exist."]

pub fn age_0_2(&self, kind: BlockKind, state: u16) -> Option<i32> {

let (offset_coefficient, stride) = self.age_0_2[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let x = crate::n_dimensional_index(state, offset_coefficient, stride);

Some({ x as i32 + 0i32 })

}

#[doc = "Updates the state value for the given block kind such that its `age_0_2` value is updated. Returns the new state,\n or `None` if the block does not have this property."]

pub fn set_age_0_2(&self, kind: BlockKind, state: u16, value: i32) -> Option<u16> {

let (offset_coefficient, stride) = self.age_0_2[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let old = crate::n_dimensional_index(state, offset_coefficient, stride) as i32;

let new = ({ value as u16 - 0u16 } as i32 - old) * stride as i32 + state as i32;

Some(new as u16)

}

#[doc = "Retrieves the `age_0_25` value for the given block kind with the given state value.\n Returns the value of the property, or `None` if it does not exist."]

pub fn age_0_25(&self, kind: BlockKind, state: u16) -> Option<i32> {

let (offset_coefficient, stride) = self.age_0_25[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let x = crate::n_dimensional_index(state, offset_coefficient, stride);

Some({ x as i32 + 0i32 })

}

#[doc = "Updates the state value for the given block kind such that its `age_0_25` value is updated. Returns the new state,\n or `None` if the block does not have this property."]

pub fn set_age_0_25(&self, kind: BlockKind, state: u16, value: i32) -> Option<u16> {

let (offset_coefficient, stride) = self.age_0_25[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let old = crate::n_dimensional_index(state, offset_coefficient, stride) as i32;

let new = ({ value as u16 - 0u16 } as i32 - old) * stride as i32 + state as i32;

Some(new as u16)

}

#[doc = "Retrieves the `age_0_3` value for the given block kind with the given state value.\n Returns the value of the property, or `None` if it does not exist."]

pub fn age_0_3(&self, kind: BlockKind, state: u16) -> Option<i32> {

let (offset_coefficient, stride) = self.age_0_3[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let x = crate::n_dimensional_index(state, offset_coefficient, stride);

Some({ x as i32 + 0i32 })

}

#[doc = "Updates the state value for the given block kind such that its `age_0_3` value is updated. Returns the new state,\n or `None` if the block does not have this property."]

pub fn set_age_0_3(&self, kind: BlockKind, state: u16, value: i32) -> Option<u16> {

let (offset_coefficient, stride) = self.age_0_3[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let old = crate::n_dimensional_index(state, offset_coefficient, stride) as i32;

let new = ({ value as u16 - 0u16 } as i32 - old) * stride as i32 + state as i32;

Some(new as u16)

}

#[doc = "Retrieves the `age_0_5` value for the given block kind with the given state value.\n Returns the value of the property, or `None` if it does not exist."]

pub fn age_0_5(&self, kind: BlockKind, state: u16) -> Option<i32> {

let (offset_coefficient, stride) = self.age_0_5[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let x = crate::n_dimensional_index(state, offset_coefficient, stride);

Some({ x as i32 + 0i32 })

}

#[doc = "Updates the state value for the given block kind such that its `age_0_5` value is updated. Returns the new state,\n or `None` if the block does not have this property."]

pub fn set_age_0_5(&self, kind: BlockKind, state: u16, value: i32) -> Option<u16> {

let (offset_coefficient, stride) = self.age_0_5[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let old = crate::n_dimensional_index(state, offset_coefficient, stride) as i32;

let new = ({ value as u16 - 0u16 } as i32 - old) * stride as i32 + state as i32;

Some(new as u16)

}

#[doc = "Retrieves the `age_0_7` value for the given block kind with the given state value.\n Returns the value of the property, or `None` if it does not exist."]

pub fn age_0_7(&self, kind: BlockKind, state: u16) -> Option<i32> {

let (offset_coefficient, stride) = self.age_0_7[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let x = crate::n_dimensional_index(state, offset_coefficient, stride);

Some({ x as i32 + 0i32 })

}

#[doc = "Updates the state value for the given block kind such that its `age_0_7` value is updated. Returns the new state,\n or `None` if the block does not have this property."]

pub fn set_age_0_7(&self, kind: BlockKind, state: u16, value: i32) -> Option<u16> {

let (offset_coefficient, stride) = self.age_0_7[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let old = crate::n_dimensional_index(state, offset_coefficient, stride) as i32;

let new = ({ value as u16 - 0u16 } as i32 - old) * stride as i32 + state as i32;

Some(new as u16)

}

#[doc = "Retrieves the `attached` value for the given block kind with the given state value.\n Returns the value of the property, or `None` if it does not exist."]

pub fn attached(&self, kind: BlockKind, state: u16) -> Option<bool> {

let (offset_coefficient, stride) = self.attached[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let x = crate::n_dimensional_index(state, offset_coefficient, stride);

Some(if x == 0 { false } else { true })

}

#[doc = "Updates the state value for the given block kind such that its `attached` value is updated. Returns the new state,\n or `None` if the block does not have this property."]

pub fn set_attached(&self, kind: BlockKind, state: u16, value: bool) -> Option<u16> {

let (offset_coefficient, stride) = self.attached[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let old = crate::n_dimensional_index(state, offset_coefficient, stride) as i32;

let new = ({ value as u16 } as i32 - old) * stride as i32 + state as i32;

Some(new as u16)

}

#[doc = "Retrieves the `axis_xyz` value for the given block kind with the given state value.\n Returns the value of the property, or `None` if it does not exist."]

pub fn axis_xyz(&self, kind: BlockKind, state: u16) -> Option<AxisXyz> {

let (offset_coefficient, stride) = self.axis_xyz[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let x = crate::n_dimensional_index(state, offset_coefficient, stride);

Some(AxisXyz::try_from(x).expect("invalid block state"))

}

#[doc = "Updates the state value for the given block kind such that its `axis_xyz` value is updated. Returns the new state,\n or `None` if the block does not have this property."]

pub fn set_axis_xyz(&self, kind: BlockKind, state: u16, value: AxisXyz) -> Option<u16> {

let (offset_coefficient, stride) = self.axis_xyz[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let old = crate::n_dimensional_index(state, offset_coefficient, stride) as i32;

let new = ({ value as u16 } as i32 - old) * stride as i32 + state as i32;

Some(new as u16)

}

#[doc = "Retrieves the `axis_xz` value for the given block kind with the given state value.\n Returns the value of the property, or `None` if it does not exist."]

pub fn axis_xz(&self, kind: BlockKind, state: u16) -> Option<AxisXz> {

let (offset_coefficient, stride) = self.axis_xz[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let x = crate::n_dimensional_index(state, offset_coefficient, stride);

Some(AxisXz::try_from(x).expect("invalid block state"))

}

#[doc = "Updates the state value for the given block kind such that its `axis_xz` value is updated. Returns the new state,\n or `None` if the block does not have this property."]

pub fn set_axis_xz(&self, kind: BlockKind, state: u16, value: AxisXz) -> Option<u16> {

let (offset_coefficient, stride) = self.axis_xz[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let old = crate::n_dimensional_index(state, offset_coefficient, stride) as i32;

let new = ({ value as u16 } as i32 - old) * stride as i32 + state as i32;

Some(new as u16)

}

#[doc = "Retrieves the `bites` value for the given block kind with the given state value.\n Returns the value of the property, or `None` if it does not exist."]

pub fn bites(&self, kind: BlockKind, state: u16) -> Option<i32> {

let (offset_coefficient, stride) = self.bites[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let x = crate::n_dimensional_index(state, offset_coefficient, stride);

Some({ x as i32 + 0i32 })

}

#[doc = "Updates the state value for the given block kind such that its `bites` value is updated. Returns the new state,\n or `None` if the block does not have this property."]

pub fn set_bites(&self, kind: BlockKind, state: u16, value: i32) -> Option<u16> {

let (offset_coefficient, stride) = self.bites[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let old = crate::n_dimensional_index(state, offset_coefficient, stride) as i32;

let new = ({ value as u16 - 0u16 } as i32 - old) * stride as i32 + state as i32;

Some(new as u16)

}

#[doc = "Retrieves the `cauldron_level` value for the given block kind with the given state value.\n Returns the value of the property, or `None` if it does not exist."]

pub fn cauldron_level(&self, kind: BlockKind, state: u16) -> Option<i32> {

let (offset_coefficient, stride) = self.cauldron_level[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let x = crate::n_dimensional_index(state, offset_coefficient, stride);

Some({ x as i32 + 0i32 })

}

#[doc = "Updates the state value for the given block kind such that its `cauldron_level` value is updated. Returns the new state,\n or `None` if the block does not have this property."]

pub fn set_cauldron_level(&self, kind: BlockKind, state: u16, value: i32) -> Option<u16> {

let (offset_coefficient, stride) = self.cauldron_level[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let old = crate::n_dimensional_index(state, offset_coefficient, stride) as i32;

let new = ({ value as u16 - 0u16 } as i32 - old) * stride as i32 + state as i32;

Some(new as u16)

}

#[doc = "Retrieves the `chest_kind` value for the given block kind with the given state value.\n Returns the value of the property, or `None` if it does not exist."]

pub fn chest_kind(&self, kind: BlockKind, state: u16) -> Option<ChestKind> {

let (offset_coefficient, stride) = self.chest_kind[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let x = crate::n_dimensional_index(state, offset_coefficient, stride);

Some(ChestKind::try_from(x).expect("invalid block state"))

}

#[doc = "Updates the state value for the given block kind such that its `chest_kind` value is updated. Returns the new state,\n or `None` if the block does not have this property."]

pub fn set_chest_kind(&self, kind: BlockKind, state: u16, value: ChestKind) -> Option<u16> {

let (offset_coefficient, stride) = self.chest_kind[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let old = crate::n_dimensional_index(state, offset_coefficient, stride) as i32;

let new = ({ value as u16 } as i32 - old) * stride as i32 + state as i32;

Some(new as u16)

}

#[doc = "Retrieves the `comparator_mode` value for the given block kind with the given state value.\n Returns the value of the property, or `None` if it does not exist."]

pub fn comparator_mode(&self, kind: BlockKind, state: u16) -> Option<ComparatorMode> {

let (offset_coefficient, stride) = self.comparator_mode[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let x = crate::n_dimensional_index(state, offset_coefficient, stride);

Some(ComparatorMode::try_from(x).expect("invalid block state"))

}

#[doc = "Updates the state value for the given block kind such that its `comparator_mode` value is updated. Returns the new state,\n or `None` if the block does not have this property."]

pub fn set_comparator_mode(

&self,

kind: BlockKind,

state: u16,

value: ComparatorMode,

) -> Option<u16> {

let (offset_coefficient, stride) = self.comparator_mode[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let old = crate::n_dimensional_index(state, offset_coefficient, stride) as i32;

let new = ({ value as u16 } as i32 - old) * stride as i32 + state as i32;

Some(new as u16)

}

#[doc = "Retrieves the `conditional` value for the given block kind with the given state value.\n Returns the value of the property, or `None` if it does not exist."]

pub fn conditional(&self, kind: BlockKind, state: u16) -> Option<bool> {

let (offset_coefficient, stride) = self.conditional[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let x = crate::n_dimensional_index(state, offset_coefficient, stride);

Some(if x == 0 { false } else { true })

}

#[doc = "Updates the state value for the given block kind such that its `conditional` value is updated. Returns the new state,\n or `None` if the block does not have this property."]

pub fn set_conditional(&self, kind: BlockKind, state: u16, value: bool) -> Option<u16> {

let (offset_coefficient, stride) = self.conditional[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let old = crate::n_dimensional_index(state, offset_coefficient, stride) as i32;

let new = ({ value as u16 } as i32 - old) * stride as i32 + state as i32;

Some(new as u16)

}

#[doc = "Retrieves the `delay` value for the given block kind with the given state value.\n Returns the value of the property, or `None` if it does not exist."]

pub fn delay(&self, kind: BlockKind, state: u16) -> Option<i32> {

let (offset_coefficient, stride) = self.delay[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let x = crate::n_dimensional_index(state, offset_coefficient, stride);

Some({ x as i32 + 1i32 })

}

#[doc = "Updates the state value for the given block kind such that its `delay` value is updated. Returns the new state,\n or `None` if the block does not have this property."]

pub fn set_delay(&self, kind: BlockKind, state: u16, value: i32) -> Option<u16> {

let (offset_coefficient, stride) = self.delay[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let old = crate::n_dimensional_index(state, offset_coefficient, stride) as i32;

let new = ({ value as u16 - 1u16 } as i32 - old) * stride as i32 + state as i32;

Some(new as u16)

}

#[doc = "Retrieves the `disarmed` value for the given block kind with the given state value.\n Returns the value of the property, or `None` if it does not exist."]

pub fn disarmed(&self, kind: BlockKind, state: u16) -> Option<bool> {

let (offset_coefficient, stride) = self.disarmed[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let x = crate::n_dimensional_index(state, offset_coefficient, stride);

Some(if x == 0 { false } else { true })

}

#[doc = "Updates the state value for the given block kind such that its `disarmed` value is updated. Returns the new state,\n or `None` if the block does not have this property."]

pub fn set_disarmed(&self, kind: BlockKind, state: u16, value: bool) -> Option<u16> {

let (offset_coefficient, stride) = self.disarmed[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let old = crate::n_dimensional_index(state, offset_coefficient, stride) as i32;

let new = ({ value as u16 } as i32 - old) * stride as i32 + state as i32;

Some(new as u16)

}

#[doc = "Retrieves the `distance` value for the given block kind with the given state value.\n Returns the value of the property, or `None` if it does not exist."]

pub fn distance(&self, kind: BlockKind, state: u16) -> Option<i32> {

let (offset_coefficient, stride) = self.distance[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let x = crate::n_dimensional_index(state, offset_coefficient, stride);

Some({ x as i32 + 1i32 })

}

#[doc = "Updates the state value for the given block kind such that its `distance` value is updated. Returns the new state,\n or `None` if the block does not have this property."]

pub fn set_distance(&self, kind: BlockKind, state: u16, value: i32) -> Option<u16> {

let (offset_coefficient, stride) = self.distance[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let old = crate::n_dimensional_index(state, offset_coefficient, stride) as i32;

let new = ({ value as u16 - 1u16 } as i32 - old) * stride as i32 + state as i32;

Some(new as u16)

}

#[doc = "Retrieves the `down` value for the given block kind with the given state value.\n Returns the value of the property, or `None` if it does not exist."]

pub fn down(&self, kind: BlockKind, state: u16) -> Option<bool> {

let (offset_coefficient, stride) = self.down[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let x = crate::n_dimensional_index(state, offset_coefficient, stride);

Some(if x == 0 { false } else { true })

}

#[doc = "Updates the state value for the given block kind such that its `down` value is updated. Returns the new state,\n or `None` if the block does not have this property."]

pub fn set_down(&self, kind: BlockKind, state: u16, value: bool) -> Option<u16> {

let (offset_coefficient, stride) = self.down[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let old = crate::n_dimensional_index(state, offset_coefficient, stride) as i32;

let new = ({ value as u16 } as i32 - old) * stride as i32 + state as i32;

Some(new as u16)

}

#[doc = "Retrieves the `drag` value for the given block kind with the given state value.\n Returns the value of the property, or `None` if it does not exist."]

pub fn drag(&self, kind: BlockKind, state: u16) -> Option<bool> {

let (offset_coefficient, stride) = self.drag[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let x = crate::n_dimensional_index(state, offset_coefficient, stride);

Some(if x == 0 { false } else { true })

}

#[doc = "Updates the state value for the given block kind such that its `drag` value is updated. Returns the new state,\n or `None` if the block does not have this property."]

pub fn set_drag(&self, kind: BlockKind, state: u16, value: bool) -> Option<u16> {

let (offset_coefficient, stride) = self.drag[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let old = crate::n_dimensional_index(state, offset_coefficient, stride) as i32;

let new = ({ value as u16 } as i32 - old) * stride as i32 + state as i32;

Some(new as u16)

}

#[doc = "Retrieves the `east_connected` value for the given block kind with the given state value.\n Returns the value of the property, or `None` if it does not exist."]

pub fn east_connected(&self, kind: BlockKind, state: u16) -> Option<bool> {

let (offset_coefficient, stride) = self.east_connected[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let x = crate::n_dimensional_index(state, offset_coefficient, stride);

Some(if x == 0 { false } else { true })

}

#[doc = "Updates the state value for the given block kind such that its `east_connected` value is updated. Returns the new state,\n or `None` if the block does not have this property."]

pub fn set_east_connected(&self, kind: BlockKind, state: u16, value: bool) -> Option<u16> {

let (offset_coefficient, stride) = self.east_connected[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let old = crate::n_dimensional_index(state, offset_coefficient, stride) as i32;

let new = ({ value as u16 } as i32 - old) * stride as i32 + state as i32;

Some(new as u16)

}

#[doc = "Retrieves the `east_wire` value for the given block kind with the given state value.\n Returns the value of the property, or `None` if it does not exist."]

pub fn east_wire(&self, kind: BlockKind, state: u16) -> Option<EastWire> {

let (offset_coefficient, stride) = self.east_wire[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let x = crate::n_dimensional_index(state, offset_coefficient, stride);

Some(EastWire::try_from(x).expect("invalid block state"))

}

#[doc = "Updates the state value for the given block kind such that its `east_wire` value is updated. Returns the new state,\n or `None` if the block does not have this property."]

pub fn set_east_wire(&self, kind: BlockKind, state: u16, value: EastWire) -> Option<u16> {

let (offset_coefficient, stride) = self.east_wire[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let old = crate::n_dimensional_index(state, offset_coefficient, stride) as i32;

let new = ({ value as u16 } as i32 - old) * stride as i32 + state as i32;

Some(new as u16)

}

#[doc = "Retrieves the `eggs` value for the given block kind with the given state value.\n Returns the value of the property, or `None` if it does not exist."]

pub fn eggs(&self, kind: BlockKind, state: u16) -> Option<i32> {

let (offset_coefficient, stride) = self.eggs[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let x = crate::n_dimensional_index(state, offset_coefficient, stride);

Some({ x as i32 + 1i32 })

}

#[doc = "Updates the state value for the given block kind such that its `eggs` value is updated. Returns the new state,\n or `None` if the block does not have this property."]

pub fn set_eggs(&self, kind: BlockKind, state: u16, value: i32) -> Option<u16> {

let (offset_coefficient, stride) = self.eggs[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let old = crate::n_dimensional_index(state, offset_coefficient, stride) as i32;

let new = ({ value as u16 - 1u16 } as i32 - old) * stride as i32 + state as i32;

Some(new as u16)

}

#[doc = "Retrieves the `enabled` value for the given block kind with the given state value.\n Returns the value of the property, or `None` if it does not exist."]

pub fn enabled(&self, kind: BlockKind, state: u16) -> Option<bool> {

let (offset_coefficient, stride) = self.enabled[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let x = crate::n_dimensional_index(state, offset_coefficient, stride);

Some(if x == 0 { false } else { true })

}

#[doc = "Updates the state value for the given block kind such that its `enabled` value is updated. Returns the new state,\n or `None` if the block does not have this property."]

pub fn set_enabled(&self, kind: BlockKind, state: u16, value: bool) -> Option<u16> {

let (offset_coefficient, stride) = self.enabled[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let old = crate::n_dimensional_index(state, offset_coefficient, stride) as i32;

let new = ({ value as u16 } as i32 - old) * stride as i32 + state as i32;

Some(new as u16)

}

#[doc = "Retrieves the `extended` value for the given block kind with the given state value.\n Returns the value of the property, or `None` if it does not exist."]

pub fn extended(&self, kind: BlockKind, state: u16) -> Option<bool> {

let (offset_coefficient, stride) = self.extended[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let x = crate::n_dimensional_index(state, offset_coefficient, stride);

Some(if x == 0 { false } else { true })

}

#[doc = "Updates the state value for the given block kind such that its `extended` value is updated. Returns the new state,\n or `None` if the block does not have this property."]

pub fn set_extended(&self, kind: BlockKind, state: u16, value: bool) -> Option<u16> {

let (offset_coefficient, stride) = self.extended[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let old = crate::n_dimensional_index(state, offset_coefficient, stride) as i32;

let new = ({ value as u16 } as i32 - old) * stride as i32 + state as i32;

Some(new as u16)

}

#[doc = "Retrieves the `eye` value for the given block kind with the given state value.\n Returns the value of the property, or `None` if it does not exist."]

pub fn eye(&self, kind: BlockKind, state: u16) -> Option<bool> {

let (offset_coefficient, stride) = self.eye[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let x = crate::n_dimensional_index(state, offset_coefficient, stride);

Some(if x == 0 { false } else { true })

}

#[doc = "Updates the state value for the given block kind such that its `eye` value is updated. Returns the new state,\n or `None` if the block does not have this property."]

pub fn set_eye(&self, kind: BlockKind, state: u16, value: bool) -> Option<u16> {

let (offset_coefficient, stride) = self.eye[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let old = crate::n_dimensional_index(state, offset_coefficient, stride) as i32;

let new = ({ value as u16 } as i32 - old) * stride as i32 + state as i32;

Some(new as u16)

}

#[doc = "Retrieves the `face` value for the given block kind with the given state value.\n Returns the value of the property, or `None` if it does not exist."]

pub fn face(&self, kind: BlockKind, state: u16) -> Option<Face> {

let (offset_coefficient, stride) = self.face[kind as u16 as usize];

if offset_coefficient == 0 {

return None;

}

let x = crate::n_dimensional_index(state, offset_coefficient, stride);

Some(Face::try_from(x).expect("invalid block state"))

}

#[doc = "Updates the state value for the given block kind such that its `face` value is updated. Returns the new state,\n or `None` if the block does not have this property."]