2024-08-03 00:03:44 -05:00
use crate ::View ;
2024-08-02 16:32:28 -05:00
use crate ::{ inspector ::HideFromInspector , prelude ::* } ;
2024-08-03 00:03:44 -05:00
use bevy ::tasks ::{ block_on , futures_lite ::future , AsyncComputeTaskPool , Task } ;
2024-08-02 16:43:30 -05:00
use bevy_ecs_tilemap ::prelude ::* ;
2024-08-02 13:40:43 -05:00
use rand ::prelude ::* ;
use rand_pcg ::Pcg64 ;
use rand_seeder ::Seeder ;
2024-08-03 00:03:44 -05:00
use std ::sync ::mpsc ::{ channel , Receiver } ;
use std ::sync ::Mutex ;
2024-08-02 13:40:43 -05:00
#[ derive(Component, Debug) ]
pub struct Tilemap ;
2024-08-03 00:03:44 -05:00
#[ derive(Component, Debug) ]
pub struct TileChan ( Mutex < Receiver < TileBundle > > ) ;
2024-08-02 23:31:32 -05:00
2024-08-02 23:32:41 -05:00
#[ derive(Component, Debug) ]
pub struct TileInit ( Task < ( ) > ) ;
2024-08-02 16:32:28 -05:00
2024-08-02 23:32:41 -05:00
pub fn init ( mut commands : Commands , assets : Res < AssetServer > ) {
2024-08-02 17:04:16 -05:00
// TODO: I'm pretty determined to not have this sieze up the game despite the large number of entities being added. Should work with a "loading" screen and doing this in the background?
2024-08-02 13:40:43 -05:00
2024-08-02 16:32:28 -05:00
let mut rng : Pcg64 = Seeder ::from ( " default_seed " ) . make_rng ( ) ;
2024-08-02 16:43:30 -05:00
let size = TilemapSize ::new ( 1024 , 1024 ) ;
2024-08-02 23:16:54 -05:00
let tile_size = TilemapTileSize ::new ( 16. , 16. ) ;
let grid_size = TilemapGridSize ::new ( 16. , 16. ) ;
let map_type = TilemapType ::Square ;
let texture = TilemapTexture ::Single ( assets . load ( " img/Tileset Grass.png " ) ) ;
let storage = TileStorage ::empty ( size ) ;
let tilemap = commands
. spawn ( (
Tilemap ,
Name ::new ( " Tilemap " ) ,
TilemapBundle {
grid_size ,
map_type ,
size ,
storage ,
texture ,
tile_size ,
transform : get_tilemap_center_transform ( & size , & grid_size , & map_type , f32 ::MIN ) ,
.. Default ::default ( )
} ,
) )
. id ( ) ;
2024-08-02 22:53:52 -05:00
2024-08-02 23:16:54 -05:00
let pool = AsyncComputeTaskPool ::get ( ) ;
2024-08-03 00:03:44 -05:00
let ( tx , rx ) = channel ::< TileBundle > ( ) ;
2024-08-02 23:16:54 -05:00
let task = pool . spawn ( async move {
for x in 0 .. size . x {
for y in 0 .. size . y {
let position = TilePos ::new ( x , y ) ;
let texture_index = TileTextureIndex ( if rng . gen_range ( 0 .. 1000 ) > 925 {
rng . gen_range ( 0 .. ( 16 * 8 ) )
} else {
0
2024-08-02 17:04:16 -05:00
} ) ;
2024-08-02 23:32:41 -05:00
tx . send ( TileBundle {
2024-08-02 23:16:54 -05:00
position ,
tilemap_id : TilemapId ( tilemap ) ,
texture_index ,
2024-08-02 23:32:41 -05:00
.. Default ::default ( )
} )
. unwrap ( ) ;
2024-08-02 23:16:54 -05:00
}
2024-08-02 17:04:16 -05:00
}
2024-08-03 00:03:44 -05:00
return ( ) ;
2024-08-02 23:16:54 -05:00
} ) ;
2024-08-03 00:03:44 -05:00
commands
. entity ( tilemap )
. insert ( ( TileInit ( task ) , TileChan ( Mutex ::new ( rx ) ) ) ) ;
2024-08-02 21:43:30 -05:00
}
2024-08-02 17:04:16 -05:00
2024-08-03 00:19:54 -05:00
const MAX_TILES_TO_LOAD_IN_ONE_UPDATE : usize = 5_000 ;
2024-08-03 00:03:44 -05:00
pub fn tile_loaders (
mut commands : Commands ,
2024-08-03 00:19:54 -05:00
mut query : Query < ( Entity , & mut TileStorage ) , With < Tilemap > > ,
mut chan : Query < & TileChan , With < Tilemap > > ,
2024-08-03 00:03:44 -05:00
mut tasks : Query < & mut TileInit > ,
mut app_state : ResMut < NextState < View > > ,
) {
2024-08-02 23:16:54 -05:00
// TODO: to avoid locking up the universe we only want to handle a certain number per iteration (Update)
2024-08-03 00:19:54 -05:00
let mut tiles_done = true ;
let ( tilemap , mut storage ) = query . single_mut ( ) ;
if let Ok ( chan ) = chan . get_single_mut ( ) {
let chan = chan . 0. lock ( ) . unwrap ( ) ;
tiles_done = false ;
let mut counter = 0 ;
loop {
match chan . recv ( ) {
Ok ( ev ) = > {
let ref_position = & ev . position ;
let tile = commands . spawn ( ( HideFromInspector , ev ) ) . id ( ) ;
storage . set ( ref_position , tile ) ;
counter + = 1 ;
if counter > = MAX_TILES_TO_LOAD_IN_ONE_UPDATE {
info! ( " Finished {}! " , counter ) ;
break ;
}
}
Err ( _ ) = > {
commands . entity ( tilemap ) . remove ::< TileChan > ( ) ;
if counter > 0 {
info! ( " Finished {counter}! Probably finishing mapgen soon... " ) ;
}
// the channel is likely closed, so let's note that and be done
tiles_done = true ;
2024-08-03 00:03:44 -05:00
break ;
}
}
}
}
2024-08-02 21:43:30 -05:00
for mut task in & mut tasks {
2024-08-03 00:03:44 -05:00
let poll = future ::poll_once ( & mut task . 0 ) ;
if block_on ( poll ) . is_some ( ) {
2024-08-03 00:19:54 -05:00
// task is done, remove it so we don't poll it again
2024-08-03 00:03:44 -05:00
commands . entity ( tilemap ) . remove ::< TileInit > ( ) ;
2024-08-02 16:43:30 -05:00
}
}
2024-08-03 00:03:44 -05:00
if tasks . iter ( ) . peekable ( ) . peek ( ) . is_none ( ) & & tiles_done {
app_state . set ( View ::InGame ) ;
}
2024-08-02 21:43:30 -05:00
}
2024-08-02 16:43:30 -05:00
2024-08-02 13:40:43 -05:00
pub fn exit ( mut commands : Commands , q : Query < Entity , With < Tilemap > > ) {
for id in q . iter ( ) {
commands . entity ( id ) . despawn_recursive ( ) ;
}
}