+#![feature(try_blocks)]

+use std::time::Duration;

+

+use bevy::{

+ DefaultPlugins,

+ app::App,

+ camera::ScalingMode,

+ ecs::{event::Trigger, observer::ObservedBy, resource::IsResource},

+ input::{common_conditions::input_just_pressed, keyboard::KeyboardInput},

+ prelude::*,

+ window::{Window, WindowPlugin},

+};

+use bevy_ecs_tilemap::{helpers::square_grid::neighbors::Neighbors, prelude::*};

+use bevy_inspector_egui::{bevy_egui::EguiPlugin, quick::WorldInspectorPlugin};

+use rand::{rng, seq::IteratorRandom};

+

+use crate::picking::TilemapPickingPlugin;

+

+const W: usize = 20;

+const H: usize = 10;

+const BOMB_COUNT: usize = 30;

+fn main() -> AppExit {

+ App::new()

+ .add_plugins(

+ DefaultPlugins

+ .set(WindowPlugin {

+ primary_window: Some(Window {

+ title: "Minesweeper!".into(),

+ ..default()

+ }),

+ ..default()

+ })

+ .set(ImagePlugin::default_linear()),

+ )

+ .insert_resource(Grid(ge()))

+ .add_plugins(TilemapPlugin)

+ // .add_plugins(EguiPlugin::default())

+ // .add_plugins(WorldInspectorPlugin::new())

+ .add_plugins(TilemapPickingPlugin)

+ .add_systems(Startup, startup)

+ // .add_systems(Update, movement)

+ .add_observer(|_: On<End>, q: Query<&mut TileTextureIndex, With<Bomb>>| {

+ for mut lem in q {

+ if lem.0 == 1 {

+ return;

+ }

+ if lem.0 != 12 {

+ lem.0 = 11;

+ }

+ }

+ })

+ .add_observer(

+ |_: On<End>, q: Query<&mut TileTextureIndex, (Without<Bomb>, With<Flag>)>| {

+ for mut lem in q {

+ lem.0 = 13;

+ }

+ },

+ )

+ .add_observer(

+ |_: On<End>, q: Query<Entity, (With<TilePos>, With<ObservedBy>)>, mut c: Commands| {

+ // println!("{q:?}");

+ for lem in q {

+ c.entity(lem).remove::<ObservedBy>();

+ }

+ },

+ )

+ .add_systems(Update, reload.run_if(input_just_pressed(KeyCode::KeyR)))

+ .run()

+}

+#[derive(Resource)]

+struct Grid([[u8; W]; W]);

+#[derive(EntityEvent, Debug, Clone, Reflect)]

+struct Zero(Entity);

+#[derive(Event, Debug, Clone, Reflect)]

+struct End;

+#[derive(Component)]

+struct Bomb;

+#[derive(Component)]

+struct Flag;

+#[derive(Component)]

+struct Murderable;

+

+macro_rules! all {

+ () => {

+ (0..W).flat_map(|x| (0..H).map(move |y| (x, y)))

+ };

+}

+

+fn reveal<E: EntityEvent>()

+-> impl Fn(On<E>, Query<(&TilePos, &mut TileTextureIndex)>, Res<Grid>, Query<&TileStorage>, Commands)

+{

+ move |ev, mut tile, ge, store, mut cmds| {

+ let Ok((&tp @ TilePos { x, y }, mut sp)) = tile.get_mut(ev.event_target()) else {

+ return;

+ };

+ *sp = TileTextureIndex(match ge.0[y as usize][x as usize] {

+ 0 if (sp.0 != 10 && sp.0 == 0) => {

+ let map_size = TilemapSize {

+ x: W as u32,

+ y: H as u32,

+ };

+ for lem in Neighbors::get_square_neighboring_positions(&tp, &map_size, false)

+ .entities(store.single().unwrap())

+ .iter()

+ {

+ cmds.trigger(Zero(*lem));

+ }

+ 10

+ }

+ n @ 1..=8 => 1 + n as u32,

+ _ => return,

+ });

+ }

+}

+fn clicked()

+-> impl Fn(On<Pointer<Press>>, Query<(&TilePos, &mut TileTextureIndex)>, Res<Grid>, Commands) {

+ move |ev, mut tile, ge, mut cmds| {

+ let Ok((&TilePos { x, y }, mut sp)) = tile.get_mut(ev.event_target()) else {

+ return;

+ };

+ let real = ge.0[y as usize][x as usize];

+ sp.0 = match ev.event().button {

+ PointerButton::Primary if sp.0 == 0 => match real {

+ 255 => {

+ cmds.trigger(End);

+ 12

+ }

+ 0 => {

+ cmds.trigger(Zero(ev.event_target()));

+ return;

+ }

+ n @ 1..=8 => 1 + n as u32,

+ _ => 10,

+ },

+ PointerButton::Secondary if sp.0 < 2 => {

+ if sp.0 == 0 {

+ cmds.entity(ev.event_target()).insert(Flag);

+ } else {

+ cmds.entity(ev.event_target()).remove::<Flag>();

+ }

+ (!(sp.0 != 0)) as u32

+ }

+ _ => return,

+ };

+ }

+}

+fn reload(

+ mut commands: Commands,

+ mut gr: ResMut<Grid>,

+ asset_server: Res<AssetServer>,

+ q: Query<Entity, With<Murderable>>,

+) {

+ gr.0 = ge();

+ for lem in q {

+ commands.entity(lem).despawn();

+ }

+ startup(commands, gr.into(), asset_server);

+}

+fn startup(mut commands: Commands, ge: Res<Grid>, asset_server: Res<AssetServer>) {

+ // commands.spawn(Camera2d);

+ commands.spawn((

+ Camera2d,

+ Projection::Orthographic(OrthographicProjection {

+ scaling_mode: ScalingMode::AutoMin {

+ min_width: (W as f32 + 4.) * 256.,

+ min_height: (H as f32 + 4.) * 256.,

+ },

+ ..OrthographicProjection::default_2d()

+ }),

+ Murderable,

+ ));

+ let texture_handle: Handle<Image> = asset_server.load("tiles.png");

+

+ let map_size = TilemapSize {

+ x: W as u32,

+ y: H as u32,

+ };

+

+ let mut tile_storage = TileStorage::empty(map_size);

+ let tilemap_entity = commands.spawn_empty().insert(Murderable).id();

+ let tilemap_id = TilemapId(tilemap_entity);

+

+ for (x, y) in all!() {

+ let position = TilePos {

+ x: x as u32,

+ y: y as u32,

+ };

+ let mut e = commands.spawn((

+ TileBundle {

+ texture_index: TileTextureIndex(0),

+ position,

+ tilemap_id,

+ ..default()

+ },

+ Murderable,

+ ));

+ if ge.0[y][x] == 255 {

+ e.insert(Bomb);

+ }

+ let tile_entity = e.observe(clicked()).observe(reveal::<Zero>()).id();

+ tile_storage.set(&position, tile_entity);

+ }

+

+ let tile_size = TilemapTileSize { x: 256.0, y: 256.0 };

+ let grid_size = tile_size.into();

+

+ commands.entity(tilemap_entity).insert((

+ TilemapBundle {

+ grid_size,

+ size: map_size,

+ storage: tile_storage,

+ texture: TilemapTexture::Single(texture_handle),

+ tile_size,

+ map_type: TilemapType::Square,

+ anchor: TilemapAnchor::Center,

+

+ ..Default::default()

+ },

+ Murderable,

+ ));

+}

+

+fn ge() -> [[u8; W]; W] {

+ let mut g = [[0u8; W]; W];

+

+ for (x, y) in all!().sample(&mut rng(), BOMB_COUNT) {

+ g[y][x] = 255;

+ let lems = aoc::util::nb((x, y));

+ lems.into_iter().for_each(|(x, y)| {

+ try {

+ let lem = g.get_mut(y)?.get_mut(x)?;

+ *lem = lem.saturating_add(1);

+ };

+ });

+ }

+

+ g

+}

+mod picking;