mirror of
https://github.com/mat-1/azalea.git
synced 2025-08-02 06:16:04 +00:00
make BlockState::id private
This commit is contained in:
parent
6a83a6fa38
commit
2aa046c4b5
12 changed files with 132 additions and 139 deletions
|
|
@ -552,7 +552,7 @@ pub fn make_block_states(input: TokenStream) -> TokenStream {
|
|||
from_block_to_state_match_inner.extend(quote! {
|
||||
#block_struct_name {
|
||||
#from_block_to_state_combination_match_inner
|
||||
} => BlockState { id: #state_id },
|
||||
} => BlockState::new_const(#state_id),
|
||||
});
|
||||
|
||||
if is_default {
|
||||
|
|
@ -626,7 +626,7 @@ pub fn make_block_states(input: TokenStream) -> TokenStream {
|
|||
azalea_registry::Block::#block_name_pascal_case => Box::new(#block_struct_name::default()),
|
||||
});
|
||||
from_registry_block_to_blockstate_match.extend(quote! {
|
||||
azalea_registry::Block::#block_name_pascal_case => BlockState { id: #default_state_id },
|
||||
azalea_registry::Block::#block_name_pascal_case => BlockState::new_const(#default_state_id),
|
||||
});
|
||||
from_registry_block_to_blockstates_match.extend(quote! {
|
||||
azalea_registry::Block::#block_name_pascal_case => BlockStates::from(#first_state_id..=#last_state_id),
|
||||
|
|
@ -646,7 +646,7 @@ pub fn make_block_states(input: TokenStream) -> TokenStream {
|
|||
let block_id = block.name.to_string();
|
||||
|
||||
let from_block_to_state_match = if block.properties_and_defaults.is_empty() {
|
||||
quote! { BlockState { id: #first_state_id } }
|
||||
quote! { BlockState::new_const(#first_state_id) }
|
||||
} else {
|
||||
quote! {
|
||||
match self {
|
||||
|
|
@ -762,7 +762,7 @@ pub fn make_block_states(input: TokenStream) -> TokenStream {
|
|||
type Value = #value;
|
||||
|
||||
fn try_from_block_state(block_state: BlockState) -> Option<Self::Value> {
|
||||
match block_state.id {
|
||||
match block_state.id() {
|
||||
#enum_inner_generated
|
||||
_ => None
|
||||
}
|
||||
|
|
@ -788,7 +788,7 @@ pub fn make_block_states(input: TokenStream) -> TokenStream {
|
|||
|
||||
impl From<BlockState> for Box<dyn Block> {
|
||||
fn from(block_state: BlockState) -> Self {
|
||||
let b = block_state.id;
|
||||
let b = block_state.id();
|
||||
match b {
|
||||
#from_state_to_block_match
|
||||
_ => panic!("Invalid block state: {}", b),
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
use std::{
|
||||
fmt::{self, Debug},
|
||||
hint::assert_unchecked,
|
||||
io::{self, Cursor, Write},
|
||||
};
|
||||
|
||||
|
|
@ -27,7 +28,7 @@ pub type BlockStateIntegerRepr = u16;
|
|||
pub struct BlockState {
|
||||
/// The protocol ID for the block state. IDs may change every
|
||||
/// version, so you shouldn't hard-code them or store them in databases.
|
||||
pub id: BlockStateIntegerRepr,
|
||||
id: BlockStateIntegerRepr,
|
||||
}
|
||||
|
||||
impl BlockState {
|
||||
|
|
@ -35,12 +36,21 @@ impl BlockState {
|
|||
/// 0.
|
||||
pub const AIR: BlockState = BlockState { id: 0 };
|
||||
|
||||
/// Create a new BlockState and panic if the block is not a valid state.
|
||||
///
|
||||
/// You should probably use [`BlockState::try_from`] instead.
|
||||
#[inline]
|
||||
pub(crate) const fn new_const(id: BlockStateIntegerRepr) -> Self {
|
||||
assert!(Self::is_valid_state(id));
|
||||
Self { id }
|
||||
}
|
||||
|
||||
/// Whether the block state is possible to exist in vanilla Minecraft.
|
||||
///
|
||||
/// It's equivalent to checking that the state ID is not greater than
|
||||
/// [`Self::MAX_STATE`].
|
||||
#[inline]
|
||||
pub fn is_valid_state(state_id: BlockStateIntegerRepr) -> bool {
|
||||
pub const fn is_valid_state(state_id: BlockStateIntegerRepr) -> bool {
|
||||
state_id <= Self::MAX_STATE
|
||||
}
|
||||
|
||||
|
|
@ -50,6 +60,13 @@ impl BlockState {
|
|||
pub fn is_air(&self) -> bool {
|
||||
self == &Self::AIR
|
||||
}
|
||||
|
||||
/// Returns the protocol ID for the block state. IDs may change every
|
||||
/// version, so you shouldn't hard-code them or store them in databases.
|
||||
#[inline]
|
||||
pub const fn id(&self) -> BlockStateIntegerRepr {
|
||||
self.id
|
||||
}
|
||||
}
|
||||
|
||||
impl TryFrom<u32> for BlockState {
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@ impl From<RangeInclusive<BlockStateIntegerRepr>> for BlockStates {
|
|||
fn from(range: RangeInclusive<BlockStateIntegerRepr>) -> Self {
|
||||
let mut set = HashSet::with_capacity((range.end() - range.start() + 1) as usize);
|
||||
for id in range {
|
||||
set.insert(BlockState { id });
|
||||
set.insert(BlockState::try_from(id).unwrap_or_default());
|
||||
}
|
||||
Self { set }
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4910,19 +4910,21 @@ static SHAPE760: LazyLock<VoxelShape> =
|
|||
impl BlockWithShape for BlockState {
|
||||
fn collision_shape(&self) -> &'static VoxelShape {
|
||||
COLLISION_SHAPES_MAP
|
||||
.get(self.id as usize)
|
||||
.get(self.id() as usize)
|
||||
.unwrap_or(&&SHAPE1)
|
||||
}
|
||||
fn outline_shape(&self) -> &'static VoxelShape {
|
||||
OUTLINE_SHAPES_MAP.get(self.id as usize).unwrap_or(&&SHAPE1)
|
||||
OUTLINE_SHAPES_MAP
|
||||
.get(self.id() as usize)
|
||||
.unwrap_or(&&SHAPE1)
|
||||
}
|
||||
|
||||
fn is_collision_shape_empty(&self) -> bool {
|
||||
matches!(self.id, 0|29..=42|45..=84|86..=117|1987..=2034|2047..=2050|2054..=2056|2109..=2136|2401..=2918|3042..=4337|4342..=4349|4366..=4589|4622..=4685|4758..=4777|4858..=4913|4922..=5385|5450..=5705|5802..=5827|5892..=5905|5908..=5911|5916..=5950|5978..=5993|6037..=6041|6043..=6044|7056..=7239|7368..=7369|7372..=7373|7376..=7377|7380..=7381|7384..=7385|7388..=7389|7392..=7393|7396..=7397|8169..=8172|8190|8305..=8448|8709|8712|9033|9036|9380..=9563|9588..=9635|9952..=9983|10129..=10152|11256..=11287|11636..=11967|12205..=12206|12209..=12210|12213..=12214|12217..=12218|12221..=12222|12225..=12226|12229..=12230|12233..=12234|12237..=12238|12241..=12242|12245..=12246|12249..=12250|12253..=12254|12257..=12258|12261..=12262|12265..=12266|12269..=12270|12273..=12274|12277..=12278|12281..=12282|12285..=12286|12289..=12290|12293..=12294|12297..=12298|12301..=12302|12305..=12306|12309..=12310|12313..=12314|12317..=12318|12321..=12322|12325..=12326|12329..=12330|12333..=12334|12337..=12338|12341..=12342|12345..=12346|12349..=12350|12353..=12354|12357..=12358|12361..=12362|12365..=12366|12369..=12370|12373..=12374|12377..=12378|12381..=12382|12385..=12386|12389..=12390|12393..=12394|12429..=12430|12433..=12434|12437..=12438|12441..=12442|12445..=12446|12449..=12450|12453..=12454|12457..=12458|12461..=12462|12465..=12466|12469..=12470|12473..=12474|12477..=12478|12481..=12482|12485..=12486|12489..=12490|13518..=13519|13522|13524|13526|13528|13530..=13535|13537|13572|13783..=13809|13836..=13955|13967|13981..=13984|15189|15192|15513|15516|15837|15840|16161|16164|16485|16488|16809|16812|17133|17136|17457|17460|17781|17784|18105|18108|18429|18432|18753|18756|19077|19080|19598..=19601|19615|19617..=19618|19632|19634..=19688|19703..=19706|19899..=19900|19903..=19904|19907..=19908|19911..=19912|19915..=19916|19919..=19920|19923..=19924|19927..=19928|19931..=19932|19935..=19936|19939..=19940|19943..=19944|19947..=19948|19951..=19952|19955..=19956|19959..=19960|20123..=20170|20299..=20378|20575|20578|20995|20998|21400..=21425|21432|21435|22202|22205|22613|22616|23025|23028|23346|23828..=23955|25797..=25851|25855..=25870|25910..=25911|25918..=25919|25926..=25927|25934..=25961|26060|26063|26471|26474|26882|26885|27293|27296|27632)
|
||||
matches!(self.id(), 0|29..=42|45..=84|86..=117|1987..=2034|2047..=2050|2054..=2056|2109..=2136|2401..=2918|3042..=4337|4342..=4349|4366..=4589|4622..=4685|4758..=4777|4858..=4913|4922..=5385|5450..=5705|5802..=5827|5892..=5905|5908..=5911|5916..=5950|5978..=5993|6037..=6041|6043..=6044|7056..=7239|7368..=7369|7372..=7373|7376..=7377|7380..=7381|7384..=7385|7388..=7389|7392..=7393|7396..=7397|8169..=8172|8190|8305..=8448|8709|8712|9033|9036|9380..=9563|9588..=9635|9952..=9983|10129..=10152|11256..=11287|11636..=11967|12205..=12206|12209..=12210|12213..=12214|12217..=12218|12221..=12222|12225..=12226|12229..=12230|12233..=12234|12237..=12238|12241..=12242|12245..=12246|12249..=12250|12253..=12254|12257..=12258|12261..=12262|12265..=12266|12269..=12270|12273..=12274|12277..=12278|12281..=12282|12285..=12286|12289..=12290|12293..=12294|12297..=12298|12301..=12302|12305..=12306|12309..=12310|12313..=12314|12317..=12318|12321..=12322|12325..=12326|12329..=12330|12333..=12334|12337..=12338|12341..=12342|12345..=12346|12349..=12350|12353..=12354|12357..=12358|12361..=12362|12365..=12366|12369..=12370|12373..=12374|12377..=12378|12381..=12382|12385..=12386|12389..=12390|12393..=12394|12429..=12430|12433..=12434|12437..=12438|12441..=12442|12445..=12446|12449..=12450|12453..=12454|12457..=12458|12461..=12462|12465..=12466|12469..=12470|12473..=12474|12477..=12478|12481..=12482|12485..=12486|12489..=12490|13518..=13519|13522|13524|13526|13528|13530..=13535|13537|13572|13783..=13809|13836..=13955|13967|13981..=13984|15189|15192|15513|15516|15837|15840|16161|16164|16485|16488|16809|16812|17133|17136|17457|17460|17781|17784|18105|18108|18429|18432|18753|18756|19077|19080|19598..=19601|19615|19617..=19618|19632|19634..=19688|19703..=19706|19899..=19900|19903..=19904|19907..=19908|19911..=19912|19915..=19916|19919..=19920|19923..=19924|19927..=19928|19931..=19932|19935..=19936|19939..=19940|19943..=19944|19947..=19948|19951..=19952|19955..=19956|19959..=19960|20123..=20170|20299..=20378|20575|20578|20995|20998|21400..=21425|21432|21435|22202|22205|22613|22616|23025|23028|23346|23828..=23955|25797..=25851|25855..=25870|25910..=25911|25918..=25919|25926..=25927|25934..=25961|26060|26063|26471|26474|26882|26885|27293|27296|27632)
|
||||
}
|
||||
|
||||
fn is_collision_shape_full(&self) -> bool {
|
||||
matches!(self.id, 1..=21|26..=28|85|118..=156|160..=188|192..=245|249..=447|476..=1730|2041..=2046|2063..=2068|2093..=2108|2137..=2400|2919|4338..=4341|4358..=4365|5912..=5915|5958..=5959|5977|5994..=5995|6028|6030..=6036|6042|6045..=6052|6124..=6139|6780..=6983|7054..=7055|7640..=7641|8056|8199|8201..=8202|8295..=8296|8449|8690..=8702|10032..=10033|10044..=10048|10153..=10180|11253..=11255|11352..=11354|11599..=11600|11605..=11606|11611..=11616|11633..=11635|11968..=11970|12055..=12056|12061..=12062|12067..=12068|12073..=12074|12079..=12080|12085..=12086|12091..=12092|12103..=12104|12109..=12110|12115..=12116|12121..=12122|12127..=12128|12133..=12134|12139..=12140|12145..=12146|12151..=12152|12157..=12158|12163..=12164|12169..=12170|12175..=12176|12181..=12182|12187..=12188|12193..=12194|12199..=12204|13427..=13436|13517|13538..=13571|13573..=13782|13810|13826..=13835|13964|15109..=15110|15115..=15116|15121..=15122|15127..=15128|15133..=15134|15139..=15140|15145..=15146|15151..=15152|15157..=15158|15163..=15164|15169..=15170|15175..=15176|15181..=15182|19427..=19460|19489|19602..=19614|19616|19619..=19631|19633|19689..=19690|19695..=19696|19701..=19702|20379..=20394|20409..=20472|20474..=20482|20487..=20488|20897..=20902|20907..=20908|21313|21398..=21399|21750..=21752|22059..=22060|22109|22114..=22115|22520|22525..=22526|22931..=22932|22937..=22938|23343..=23345|23827|23956..=23957|23966..=23983|24308..=24309|24314..=24315|24320..=24321|24326..=24335|24660..=24661|24666..=24667|24672..=24673|24678..=24679|25704..=25751|25796|25903|25962|25964..=25967|26052..=26053|26378|26463..=26464|26789|26874..=26875|27200|27285..=27286|27611..=27620|27623..=27631|27633|27650..=27703)
|
||||
matches!(self.id(), 1..=21|26..=28|85|118..=156|160..=188|192..=245|249..=447|476..=1730|2041..=2046|2063..=2068|2093..=2108|2137..=2400|2919|4338..=4341|4358..=4365|5912..=5915|5958..=5959|5977|5994..=5995|6028|6030..=6036|6042|6045..=6052|6124..=6139|6780..=6983|7054..=7055|7640..=7641|8056|8199|8201..=8202|8295..=8296|8449|8690..=8702|10032..=10033|10044..=10048|10153..=10180|11253..=11255|11352..=11354|11599..=11600|11605..=11606|11611..=11616|11633..=11635|11968..=11970|12055..=12056|12061..=12062|12067..=12068|12073..=12074|12079..=12080|12085..=12086|12091..=12092|12103..=12104|12109..=12110|12115..=12116|12121..=12122|12127..=12128|12133..=12134|12139..=12140|12145..=12146|12151..=12152|12157..=12158|12163..=12164|12169..=12170|12175..=12176|12181..=12182|12187..=12188|12193..=12194|12199..=12204|13427..=13436|13517|13538..=13571|13573..=13782|13810|13826..=13835|13964|15109..=15110|15115..=15116|15121..=15122|15127..=15128|15133..=15134|15139..=15140|15145..=15146|15151..=15152|15157..=15158|15163..=15164|15169..=15170|15175..=15176|15181..=15182|19427..=19460|19489|19602..=19614|19616|19619..=19631|19633|19689..=19690|19695..=19696|19701..=19702|20379..=20394|20409..=20472|20474..=20482|20487..=20488|20897..=20902|20907..=20908|21313|21398..=21399|21750..=21752|22059..=22060|22109|22114..=22115|22520|22525..=22526|22931..=22932|22937..=22938|23343..=23345|23827|23956..=23957|23966..=23983|24308..=24309|24314..=24315|24320..=24321|24326..=24335|24660..=24661|24666..=24667|24672..=24673|24678..=24679|25704..=25751|25796|25903|25962|25964..=25967|26052..=26053|26378|26463..=26464|26789|26874..=26875|27200|27285..=27286|27611..=27620|27623..=27631|27633|27650..=27703)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@ impl AzaleaRead for BlockStateWithPosition {
|
|||
|
||||
impl AzaleaWrite for BlockStateWithPosition {
|
||||
fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
|
||||
let data = ((self.state.id as u64) << 12)
|
||||
let data = ((self.state.id() as u64) << 12)
|
||||
| ((u64::from(self.pos.x) << 8) | (u64::from(self.pos.z) << 4) | u64::from(self.pos.y));
|
||||
u64::azalea_write_var(&data, buf)?;
|
||||
Ok(())
|
||||
|
|
|
|||
|
|
@ -476,25 +476,18 @@ impl AzaleaWrite for Section {
|
|||
|
||||
impl Section {
|
||||
pub fn get(&self, pos: ChunkSectionBlockPos) -> BlockState {
|
||||
// TODO: use the unsafe method and do the check earlier
|
||||
let state = self
|
||||
.states
|
||||
.get(pos.x as usize, pos.y as usize, pos.z as usize);
|
||||
// if there's an unknown block assume it's air
|
||||
BlockState::try_from(state).unwrap_or(BlockState::AIR)
|
||||
self.states
|
||||
.get(pos.x as usize, pos.y as usize, pos.z as usize)
|
||||
}
|
||||
|
||||
pub fn get_and_set(&mut self, pos: ChunkSectionBlockPos, state: BlockState) -> BlockState {
|
||||
let previous_state =
|
||||
self.states
|
||||
.get_and_set(pos.x as usize, pos.y as usize, pos.z as usize, state.id);
|
||||
// if there's an unknown block assume it's air
|
||||
BlockState::try_from(previous_state).unwrap_or(BlockState::AIR)
|
||||
self.states
|
||||
.get_and_set(pos.x as usize, pos.y as usize, pos.z as usize, state)
|
||||
}
|
||||
|
||||
pub fn set(&mut self, pos: ChunkSectionBlockPos, state: BlockState) {
|
||||
self.states
|
||||
.set(pos.x as usize, pos.y as usize, pos.z as usize, state.id);
|
||||
.set(pos.x as usize, pos.y as usize, pos.z as usize, state);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,17 +1,13 @@
|
|||
use azalea_block::{BlockStates, block_state::BlockState};
|
||||
use azalea_block::BlockStates;
|
||||
use azalea_core::position::{BlockPos, ChunkPos};
|
||||
|
||||
use crate::{ChunkStorage, Instance, iterators::ChunkIterator, palette::Palette};
|
||||
|
||||
fn palette_maybe_has_block(palette: &Palette, block_states: &BlockStates) -> bool {
|
||||
match &palette {
|
||||
Palette::SingleValue(id) => block_states.contains(&BlockState { id: *id }),
|
||||
Palette::Linear(ids) => ids
|
||||
.iter()
|
||||
.any(|&id| block_states.contains(&BlockState { id })),
|
||||
Palette::Hashmap(ids) => ids
|
||||
.iter()
|
||||
.any(|&id| block_states.contains(&BlockState { id })),
|
||||
Palette::SingleValue(id) => block_states.contains(id),
|
||||
Palette::Linear(ids) => ids.iter().any(|id| block_states.contains(id)),
|
||||
Palette::Hashmap(ids) => ids.iter().any(|id| block_states.contains(id)),
|
||||
Palette::Global => true,
|
||||
}
|
||||
}
|
||||
|
|
@ -62,7 +58,6 @@ impl Instance {
|
|||
|
||||
for i in 0..4096 {
|
||||
let block_state = section.states.get_at_index(i);
|
||||
let block_state = BlockState { id: block_state };
|
||||
|
||||
if block_states.contains(&block_state) {
|
||||
let (section_x, section_y, section_z) = section.states.coords_from_index(i);
|
||||
|
|
@ -190,7 +185,6 @@ impl Iterator for FindBlocks<'_> {
|
|||
|
||||
for i in 0..4096 {
|
||||
let block_state = section.states.get_at_index(i);
|
||||
let block_state = BlockState { id: block_state };
|
||||
|
||||
if self.block_states.contains(&block_state) {
|
||||
let (section_x, section_y, section_z) = section.states.coords_from_index(i);
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
use std::io::{Cursor, Write};
|
||||
|
||||
use azalea_block::block_state::BlockStateIntegerRepr;
|
||||
use azalea_buf::{AzaleaRead, AzaleaReadVar, AzaleaWrite, AzaleaWriteVar, BufReadError};
|
||||
use azalea_block::BlockState;
|
||||
use azalea_buf::{AzaleaRead, AzaleaWrite, BufReadError};
|
||||
use tracing::warn;
|
||||
|
||||
use crate::BitStorage;
|
||||
|
|
@ -28,7 +28,7 @@ pub struct PalettedContainer {
|
|||
|
||||
impl PalettedContainer {
|
||||
pub fn new(container_type: PalettedContainerKind) -> Self {
|
||||
let palette = Palette::SingleValue(0);
|
||||
let palette = Palette::SingleValue(BlockState::AIR);
|
||||
let size = container_type.size();
|
||||
let storage = BitStorage::new(0, size, Some(Box::new([]))).unwrap();
|
||||
|
||||
|
|
@ -105,7 +105,7 @@ impl PalettedContainer {
|
|||
/// This function panics if the index is greater than or equal to the number
|
||||
/// of things in the storage. (So for block states, it must be less than
|
||||
/// 4096).
|
||||
pub fn get_at_index(&self, index: usize) -> BlockStateIntegerRepr {
|
||||
pub fn get_at_index(&self, index: usize) -> BlockState {
|
||||
// first get the palette id
|
||||
let paletted_value = self.storage.get(index);
|
||||
// and then get the value from that id
|
||||
|
|
@ -113,35 +113,39 @@ impl PalettedContainer {
|
|||
}
|
||||
|
||||
/// Returns the value at the given coordinates.
|
||||
pub fn get(&self, x: usize, y: usize, z: usize) -> BlockStateIntegerRepr {
|
||||
pub fn get(&self, x: usize, y: usize, z: usize) -> BlockState {
|
||||
// let paletted_value = self.storage.get(self.get_index(x, y, z));
|
||||
// self.palette.value_for(paletted_value as usize)
|
||||
self.get_at_index(self.index_from_coords(x, y, z))
|
||||
}
|
||||
|
||||
/// Sets the id at the given coordinates and return the previous id
|
||||
pub fn get_and_set(
|
||||
&mut self,
|
||||
x: usize,
|
||||
y: usize,
|
||||
z: usize,
|
||||
value: BlockStateIntegerRepr,
|
||||
) -> BlockStateIntegerRepr {
|
||||
pub fn get_and_set(&mut self, x: usize, y: usize, z: usize, value: BlockState) -> BlockState {
|
||||
let paletted_value = self.id_for(value);
|
||||
self.storage
|
||||
.get_and_set(self.index_from_coords(x, y, z), paletted_value as u64)
|
||||
as BlockStateIntegerRepr
|
||||
let block_state_id = self
|
||||
.storage
|
||||
.get_and_set(self.index_from_coords(x, y, z), paletted_value as u64);
|
||||
// error in debug mode
|
||||
#[cfg(debug_assertions)]
|
||||
if block_state_id > BlockState::MAX_STATE.into() {
|
||||
warn!(
|
||||
"Old block state from get_and_set {block_state_id} was greater than max state {}",
|
||||
BlockState::MAX_STATE
|
||||
);
|
||||
}
|
||||
|
||||
BlockState::try_from(block_state_id as u32).unwrap_or_default()
|
||||
}
|
||||
|
||||
/// Sets the id at the given index and return the previous id. You probably
|
||||
/// want `.set` instead.
|
||||
pub fn set_at_index(&mut self, index: usize, value: BlockStateIntegerRepr) {
|
||||
pub fn set_at_index(&mut self, index: usize, value: BlockState) {
|
||||
let paletted_value = self.id_for(value);
|
||||
self.storage.set(index, paletted_value as u64);
|
||||
}
|
||||
|
||||
/// Sets the id at the given coordinates and return the previous id
|
||||
pub fn set(&mut self, x: usize, y: usize, z: usize, value: BlockStateIntegerRepr) {
|
||||
pub fn set(&mut self, x: usize, y: usize, z: usize, value: BlockState) {
|
||||
self.set_at_index(self.index_from_coords(x, y, z), value);
|
||||
}
|
||||
|
||||
|
|
@ -170,7 +174,7 @@ impl PalettedContainer {
|
|||
}
|
||||
}
|
||||
|
||||
fn on_resize(&mut self, bits_per_entry: u8, value: BlockStateIntegerRepr) -> usize {
|
||||
fn on_resize(&mut self, bits_per_entry: u8, value: BlockState) -> usize {
|
||||
// in vanilla this is always true, but it's sometimes false in purpur servers
|
||||
// assert!(bits_per_entry <= 5, "bits_per_entry must be <= 5");
|
||||
let mut new_data = self.create_or_reuse_data(bits_per_entry);
|
||||
|
|
@ -187,7 +191,7 @@ impl PalettedContainer {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn id_for(&mut self, value: BlockStateIntegerRepr) -> usize {
|
||||
pub fn id_for(&mut self, value: BlockState) -> usize {
|
||||
match &mut self.palette {
|
||||
Palette::SingleValue(v) => {
|
||||
if *v != value {
|
||||
|
|
@ -209,7 +213,8 @@ impl PalettedContainer {
|
|||
}
|
||||
}
|
||||
Palette::Hashmap(palette) => {
|
||||
// TODO? vanilla keeps this in memory as a hashmap, but also i don't care
|
||||
// TODO? vanilla keeps this in memory as a hashmap, but it should be benchmarked
|
||||
// before changing it
|
||||
if let Some(index) = palette.iter().position(|v| *v == value) {
|
||||
return index;
|
||||
}
|
||||
|
|
@ -221,7 +226,7 @@ impl PalettedContainer {
|
|||
self.on_resize(self.bits_per_entry + 1, value)
|
||||
}
|
||||
}
|
||||
Palette::Global => value as usize,
|
||||
Palette::Global => value.id() as usize,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -247,21 +252,21 @@ pub enum PaletteKind {
|
|||
#[derive(Clone, Debug)]
|
||||
pub enum Palette {
|
||||
/// ID of the corresponding entry in its global palette
|
||||
SingleValue(BlockStateIntegerRepr),
|
||||
SingleValue(BlockState),
|
||||
// in vanilla this keeps a `size` field that might be less than the length, but i'm not sure
|
||||
// it's actually needed?
|
||||
Linear(Vec<BlockStateIntegerRepr>),
|
||||
Hashmap(Vec<BlockStateIntegerRepr>),
|
||||
Linear(Vec<BlockState>),
|
||||
Hashmap(Vec<BlockState>),
|
||||
Global,
|
||||
}
|
||||
|
||||
impl Palette {
|
||||
pub fn value_for(&self, id: usize) -> BlockStateIntegerRepr {
|
||||
pub fn value_for(&self, id: usize) -> BlockState {
|
||||
match self {
|
||||
Palette::SingleValue(v) => *v,
|
||||
Palette::Linear(v) => v[id],
|
||||
Palette::Linear(v) => v.get(id).copied().unwrap_or_default(),
|
||||
Palette::Hashmap(v) => v.get(id).copied().unwrap_or_default(),
|
||||
Palette::Global => id as BlockStateIntegerRepr,
|
||||
Palette::Global => BlockState::try_from(id as u32).unwrap_or_default(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -270,13 +275,13 @@ impl AzaleaWrite for Palette {
|
|||
fn azalea_write(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
|
||||
match self {
|
||||
Palette::SingleValue(value) => {
|
||||
value.azalea_write_var(buf)?;
|
||||
value.azalea_write(buf)?;
|
||||
}
|
||||
Palette::Linear(values) => {
|
||||
values.azalea_write_var(buf)?;
|
||||
values.azalea_write(buf)?;
|
||||
}
|
||||
Palette::Hashmap(values) => {
|
||||
values.azalea_write_var(buf)?;
|
||||
values.azalea_write(buf)?;
|
||||
}
|
||||
Palette::Global => {}
|
||||
}
|
||||
|
|
@ -305,22 +310,16 @@ impl PaletteKind {
|
|||
Ok(match self {
|
||||
// since they're read as varints it's actually fine to just use BlockStateIntegerRepr
|
||||
// instead of the correct type (u32)
|
||||
PaletteKind::SingleValue => {
|
||||
Palette::SingleValue(BlockStateIntegerRepr::azalea_read_var(buf)?)
|
||||
}
|
||||
PaletteKind::Linear => {
|
||||
Palette::Linear(Vec::<BlockStateIntegerRepr>::azalea_read_var(buf)?)
|
||||
}
|
||||
PaletteKind::Hashmap => {
|
||||
Palette::Hashmap(Vec::<BlockStateIntegerRepr>::azalea_read_var(buf)?)
|
||||
}
|
||||
PaletteKind::SingleValue => Palette::SingleValue(BlockState::azalea_read(buf)?),
|
||||
PaletteKind::Linear => Palette::Linear(Vec::<BlockState>::azalea_read(buf)?),
|
||||
PaletteKind::Hashmap => Palette::Hashmap(Vec::<BlockState>::azalea_read(buf)?),
|
||||
PaletteKind::Global => Palette::Global,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn as_empty_palette(&self) -> Palette {
|
||||
match self {
|
||||
PaletteKind::SingleValue => Palette::SingleValue(0),
|
||||
PaletteKind::SingleValue => Palette::SingleValue(BlockState::AIR),
|
||||
PaletteKind::Linear => Palette::Linear(Vec::new()),
|
||||
PaletteKind::Hashmap => Palette::Hashmap(Vec::new()),
|
||||
PaletteKind::Global => Palette::Global,
|
||||
|
|
@ -361,13 +360,14 @@ mod tests {
|
|||
let mut palette_container = PalettedContainer::new(PalettedContainerKind::BlockStates);
|
||||
|
||||
assert_eq!(palette_container.bits_per_entry, 0);
|
||||
assert_eq!(palette_container.get_at_index(0), 0);
|
||||
assert_eq!(palette_container.get_at_index(0), BlockState::AIR);
|
||||
assert_eq!(
|
||||
PaletteKind::from(&palette_container.palette),
|
||||
PaletteKind::SingleValue
|
||||
);
|
||||
palette_container.set_at_index(0, 1);
|
||||
assert_eq!(palette_container.get_at_index(0), 1);
|
||||
let block_state_1 = BlockState::try_from(1_u32).unwrap();
|
||||
palette_container.set_at_index(0, block_state_1);
|
||||
assert_eq!(palette_container.get_at_index(0), block_state_1);
|
||||
assert_eq!(
|
||||
PaletteKind::from(&palette_container.palette),
|
||||
PaletteKind::Linear
|
||||
|
|
@ -378,34 +378,38 @@ mod tests {
|
|||
fn test_resize_0_bits_to_5() {
|
||||
let mut palette_container = PalettedContainer::new(PalettedContainerKind::BlockStates);
|
||||
|
||||
palette_container.set_at_index(0, 0); // 0 bits
|
||||
let set = |pc: &mut PalettedContainer, i, v: u32| {
|
||||
pc.set_at_index(i, BlockState::try_from(v).unwrap());
|
||||
};
|
||||
|
||||
set(&mut palette_container, 0, 0); // 0 bits
|
||||
assert_eq!(palette_container.bits_per_entry, 0);
|
||||
|
||||
palette_container.set_at_index(1, 1); // 1 bit
|
||||
set(&mut palette_container, 1, 1); // 1 bit
|
||||
assert_eq!(palette_container.bits_per_entry, 1);
|
||||
|
||||
palette_container.set_at_index(2, 2); // 2 bits
|
||||
set(&mut palette_container, 2, 2); // 2 bits
|
||||
assert_eq!(palette_container.bits_per_entry, 2);
|
||||
palette_container.set_at_index(3, 3);
|
||||
set(&mut palette_container, 3, 3);
|
||||
|
||||
palette_container.set_at_index(4, 4); // 3 bits
|
||||
set(&mut palette_container, 4, 4); // 3 bits
|
||||
assert_eq!(palette_container.bits_per_entry, 3);
|
||||
palette_container.set_at_index(5, 5);
|
||||
palette_container.set_at_index(6, 6);
|
||||
palette_container.set_at_index(7, 7);
|
||||
set(&mut palette_container, 5, 5);
|
||||
set(&mut palette_container, 6, 6);
|
||||
set(&mut palette_container, 7, 7);
|
||||
|
||||
palette_container.set_at_index(8, 8); // 4 bits
|
||||
set(&mut palette_container, 8, 8); // 4 bits
|
||||
assert_eq!(palette_container.bits_per_entry, 4);
|
||||
palette_container.set_at_index(9, 9);
|
||||
palette_container.set_at_index(10, 10);
|
||||
palette_container.set_at_index(11, 11);
|
||||
palette_container.set_at_index(12, 12);
|
||||
palette_container.set_at_index(13, 13);
|
||||
palette_container.set_at_index(14, 14);
|
||||
palette_container.set_at_index(15, 15);
|
||||
set(&mut palette_container, 9, 9);
|
||||
set(&mut palette_container, 10, 10);
|
||||
set(&mut palette_container, 11, 11);
|
||||
set(&mut palette_container, 12, 12);
|
||||
set(&mut palette_container, 13, 13);
|
||||
set(&mut palette_container, 14, 14);
|
||||
set(&mut palette_container, 15, 15);
|
||||
assert_eq!(palette_container.bits_per_entry, 4);
|
||||
|
||||
palette_container.set_at_index(16, 16); // 5 bits
|
||||
set(&mut palette_container, 16, 16); // 5 bits
|
||||
assert_eq!(palette_container.bits_per_entry, 5);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -27,16 +27,16 @@ impl MiningCache {
|
|||
let mut water_block_state_range_min = BlockStateIntegerRepr::MAX;
|
||||
let mut water_block_state_range_max = BlockStateIntegerRepr::MIN;
|
||||
for state in water_block_states {
|
||||
water_block_state_range_min = water_block_state_range_min.min(state.id);
|
||||
water_block_state_range_max = water_block_state_range_max.max(state.id);
|
||||
water_block_state_range_min = water_block_state_range_min.min(state.id());
|
||||
water_block_state_range_max = water_block_state_range_max.max(state.id());
|
||||
}
|
||||
let water_block_state_range = water_block_state_range_min..=water_block_state_range_max;
|
||||
|
||||
let mut lava_block_state_range_min = BlockStateIntegerRepr::MAX;
|
||||
let mut lava_block_state_range_max = BlockStateIntegerRepr::MIN;
|
||||
for state in lava_block_states {
|
||||
lava_block_state_range_min = lava_block_state_range_min.min(state.id);
|
||||
lava_block_state_range_max = lava_block_state_range_max.max(state.id);
|
||||
lava_block_state_range_min = lava_block_state_range_min.min(state.id());
|
||||
lava_block_state_range_max = lava_block_state_range_max.max(state.id());
|
||||
}
|
||||
let lava_block_state_range = lava_block_state_range_min..=lava_block_state_range_max;
|
||||
|
||||
|
|
@ -65,7 +65,7 @@ impl MiningCache {
|
|||
azalea_registry::Block::RedConcretePowder.into(),
|
||||
azalea_registry::Block::BlackConcretePowder.into(),
|
||||
];
|
||||
falling_blocks.sort_unstable_by_key(|block| block.id);
|
||||
falling_blocks.sort_unstable_by_key(|block| block.id());
|
||||
|
||||
Self {
|
||||
block_state_id_costs: UnsafeCell::new(IntMap::default()),
|
||||
|
|
@ -84,7 +84,7 @@ impl MiningCache {
|
|||
// SAFETY: mining is single-threaded, so this is safe
|
||||
let block_state_id_costs = unsafe { &mut *self.block_state_id_costs.get() };
|
||||
|
||||
if let Some(cost) = block_state_id_costs.get(&block.id) {
|
||||
if let Some(cost) = block_state_id_costs.get(&block.id()) {
|
||||
*cost
|
||||
} else {
|
||||
let best_tool_result = best_tool_in_hotbar_for_block(block, inventory_menu);
|
||||
|
|
@ -92,7 +92,7 @@ impl MiningCache {
|
|||
|
||||
cost += BLOCK_BREAK_ADDITIONAL_PENALTY;
|
||||
|
||||
block_state_id_costs.insert(block.id, cost);
|
||||
block_state_id_costs.insert(block.id(), cost);
|
||||
cost
|
||||
}
|
||||
}
|
||||
|
|
@ -101,14 +101,14 @@ impl MiningCache {
|
|||
// this already runs in about 1 nanosecond, so if you wanna try optimizing it at
|
||||
// least run the benchmarks (in benches/checks.rs)
|
||||
|
||||
self.water_block_state_range.contains(&block.id)
|
||||
|| self.lava_block_state_range.contains(&block.id)
|
||||
self.water_block_state_range.contains(&block.id())
|
||||
|| self.lava_block_state_range.contains(&block.id())
|
||||
|| is_waterlogged(block)
|
||||
}
|
||||
|
||||
pub fn is_falling_block(&self, block: BlockState) -> bool {
|
||||
self.falling_blocks
|
||||
.binary_search_by_key(&block.id, |block| block.id)
|
||||
.binary_search_by_key(&block.id(), |block| block.id())
|
||||
.is_ok()
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -194,8 +194,7 @@ impl CachedWorld {
|
|||
let mut passable_bitset = FixedBitSet::<{ 4096_usize.div_ceil(8) }>::new();
|
||||
let mut solid_bitset = FixedBitSet::<{ 4096_usize.div_ceil(8) }>::new();
|
||||
for i in 0..4096 {
|
||||
let block_state_id = section.get_at_index(i);
|
||||
let block_state = BlockState::try_from(block_state_id).unwrap_or(BlockState::AIR);
|
||||
let block_state = section.get_at_index(i);
|
||||
if is_block_state_passable(block_state) {
|
||||
passable_bitset.set(i);
|
||||
}
|
||||
|
|
@ -304,9 +303,7 @@ impl CachedWorld {
|
|||
let west_is_in_same_section = section_block_pos.x != 0;
|
||||
|
||||
let Some(mining_cost) = self.with_section(section_pos, |section| {
|
||||
let block_state =
|
||||
BlockState::try_from(section.get_at_index(u16::from(section_block_pos) as usize))
|
||||
.unwrap_or_default();
|
||||
let block_state = section.get_at_index(u16::from(section_block_pos) as usize);
|
||||
let mining_cost = mining_cache.cost_for(block_state);
|
||||
|
||||
if mining_cost == f32::INFINITY {
|
||||
|
|
@ -316,10 +313,7 @@ impl CachedWorld {
|
|||
|
||||
// if there's a falling block or liquid above this block, abort
|
||||
if up_is_in_same_section {
|
||||
let up_block = BlockState::try_from(
|
||||
section.get_at_index(u16::from(section_block_pos.up(1)) as usize),
|
||||
)
|
||||
.unwrap_or_default();
|
||||
let up_block = section.get_at_index(u16::from(section_block_pos.up(1)) as usize);
|
||||
if mining_cache.is_liquid(up_block) || mining_cache.is_falling_block(up_block) {
|
||||
return f32::INFINITY;
|
||||
}
|
||||
|
|
@ -327,10 +321,8 @@ impl CachedWorld {
|
|||
|
||||
// if there's a liquid to the north of this block, abort
|
||||
if north_is_in_same_section {
|
||||
let north_block = BlockState::try_from(
|
||||
section.get_at_index(u16::from(section_block_pos.north(1)) as usize),
|
||||
)
|
||||
.unwrap_or_default();
|
||||
let north_block =
|
||||
section.get_at_index(u16::from(section_block_pos.north(1)) as usize);
|
||||
if mining_cache.is_liquid(north_block) {
|
||||
return f32::INFINITY;
|
||||
}
|
||||
|
|
@ -338,10 +330,8 @@ impl CachedWorld {
|
|||
|
||||
// liquid to the east
|
||||
if east_is_in_same_section {
|
||||
let east_block = BlockState::try_from(
|
||||
section.get_at_index(u16::from(section_block_pos.east(1)) as usize),
|
||||
)
|
||||
.unwrap_or_default();
|
||||
let east_block =
|
||||
section.get_at_index(u16::from(section_block_pos.east(1)) as usize);
|
||||
if mining_cache.is_liquid(east_block) {
|
||||
return f32::INFINITY;
|
||||
}
|
||||
|
|
@ -349,10 +339,8 @@ impl CachedWorld {
|
|||
|
||||
// liquid to the south
|
||||
if south_is_in_same_section {
|
||||
let south_block = BlockState::try_from(
|
||||
section.get_at_index(u16::from(section_block_pos.south(1)) as usize),
|
||||
)
|
||||
.unwrap_or_default();
|
||||
let south_block =
|
||||
section.get_at_index(u16::from(section_block_pos.south(1)) as usize);
|
||||
if mining_cache.is_liquid(south_block) {
|
||||
return f32::INFINITY;
|
||||
}
|
||||
|
|
@ -360,10 +348,8 @@ impl CachedWorld {
|
|||
|
||||
// liquid to the west
|
||||
if west_is_in_same_section {
|
||||
let west_block = BlockState::try_from(
|
||||
section.get_at_index(u16::from(section_block_pos.west(1)) as usize),
|
||||
)
|
||||
.unwrap_or_default();
|
||||
let west_block =
|
||||
section.get_at_index(u16::from(section_block_pos.west(1)) as usize);
|
||||
if mining_cache.is_liquid(west_block) {
|
||||
return f32::INFINITY;
|
||||
}
|
||||
|
|
@ -391,10 +377,7 @@ impl CachedWorld {
|
|||
let check_should_avoid_this_block = |pos: BlockPos, check: &dyn Fn(BlockState) -> bool| {
|
||||
let block_state = self
|
||||
.with_section(ChunkSectionPos::from(pos), |section| {
|
||||
BlockState::try_from(
|
||||
section.get_at_index(u16::from(ChunkSectionBlockPos::from(pos)) as usize),
|
||||
)
|
||||
.unwrap_or_default()
|
||||
section.get_at_index(u16::from(ChunkSectionBlockPos::from(pos)) as usize)
|
||||
})
|
||||
.unwrap_or_default();
|
||||
check(block_state)
|
||||
|
|
|
|||
|
|
@ -151,18 +151,18 @@ pub trait BlockWithShape {{
|
|||
|
||||
impl BlockWithShape for BlockState {{
|
||||
fn collision_shape(&self) -> &'static VoxelShape {{
|
||||
COLLISION_SHAPES_MAP.get(self.id as usize).unwrap_or(&&SHAPE1)
|
||||
COLLISION_SHAPES_MAP.get(self.id() as usize).unwrap_or(&&SHAPE1)
|
||||
}}
|
||||
fn outline_shape(&self) -> &'static VoxelShape {{
|
||||
OUTLINE_SHAPES_MAP.get(self.id as usize).unwrap_or(&&SHAPE1)
|
||||
OUTLINE_SHAPES_MAP.get(self.id() as usize).unwrap_or(&&SHAPE1)
|
||||
}}
|
||||
|
||||
fn is_collision_shape_empty(&self) -> bool {{
|
||||
matches!(self.id, {empty_shape_match_code})
|
||||
matches!(self.id(), {empty_shape_match_code})
|
||||
}}
|
||||
|
||||
fn is_collision_shape_full(&self) -> bool {{
|
||||
matches!(self.id, {block_shape_match_code})
|
||||
matches!(self.id(), {block_shape_match_code})
|
||||
}}
|
||||
}}
|
||||
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ def to_snake_case(name: str):
|
|||
|
||||
|
||||
def to_camel_case(name: str):
|
||||
s = re.sub('[_ ](\w)', lambda m: m.group(1).upper(),
|
||||
s = re.sub(r'[_ ](\w)', lambda m: m.group(1).upper(),
|
||||
name.replace('.', '_').replace('/', '_'))
|
||||
s = upper_first_letter(s)
|
||||
# if the first character is a number, we need to add an underscore
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue