use bevy::prelude::*;
//コンポーネント作成
#[derive(Component)]
struct Component1{}

//エンティティ作成関数
fn add_EntityName_function(mut commands: Commands){
  commands.spawn().insert(Component1).insert(Component...);
}

fn main(){
  //add_startup_system()にエンティティ作成関数を渡すことで晴れて実体化
  App::new().add_startup_system(add_EntityName_function).run();
}

fn print_cards(query: Query<(&Suit,&Value)>){
  for (suit, value) in query.iter() {
    let s_string = match suit{
      Suit::Spade => "♠",
      Suit::Heart => "♥",
      Suit::Diamond => "♦",
      Suit::Club => "♣",
      _ => " ",
    };
    let v_string = match value{
      Value(1_u8)  => "A".to_string(),
      Value(2..=9)  => value.0.to_string(),
      Value(10_u8) => "T".to_string(),
      Value(11_u8) => "J".to_string(),
      Value(12_u8) => "Q".to_string(),
      Value(13_u8) => "K".to_string(),
      _ => " ".to_string(),
    };
    print!("[{},{}]",s_string,v_string);
  }
}

pub struct CardPlugin;
impl Plugin for CardPlugin{
  fn build(&self, app: &mut App){
  app.add_startup_system(add_card_deck)
       .add_system(print_cards);
  }
}
//以下コンポーネントやシステム関数を羅列

use bevy::prelude::*;
mod card_plugin;
use  card_plugin::CardPlugin;

fn main(){
  App::new().add_plugin(CardPlugin).run();
}

fn main(){
  //bevy 0.5
  App::build().run();
  //bevy 0.6
  App::new().run;
}

//普通のコンポーネントは"Table"ストレージらしい
#[derive(Component)]
struct Hoge;

//ストレージを変更する場合こう書く
#[derive(Component)]
#[component(storage = "SparseSet")]
struct Foo;

//この書き方でも可
struct Hyaaaa;
impl Component for Hyaaaa{
    type Storage = TableStorage;
}

//イベントの宣言
struct EventName(/*送るアイテム、Entityが一般的？*/);

//イベント発生を伝える側
fn event_check(mut event: EventWriter<EventName>,...){
  if /*何かの条件を満たしているときに*/{
    event.send(EventName(send_item));
  }
}

//イベント発生したときに処理をする側
fn event_action(mut event: EventReader<EventName>){
  for item in event.iter(){
   //処理
  }
}

//イベント登録
fn main(){
  App::new()
         .add_event::<EventName>()
         .add_system(event_chack)
         .add_system(event_action)
         .run();
}

fn level_reset(
  mut event: EventWriter<LevelReset>,
  mut query: Query<&mut PlayerExp>
){
  for entity in event.iter(){
    if let Ok(mut exp) =query.get_mut(entity.0){
      exp.0 =0;
      }
   }
}

package
 |_cargo.toml
 |_src
 |_assets
    |_fonts
       |_ fontdata.ttf
       |_ fontdata.otf

fn setup(mut commands){
  commands.spawn_bundle(ButtonBundle{});
}

package_name
 |_Cargo.toml 
 |_src
    |_main.rs
    |_lib.rs
    |_plugins.rs
    |_plugins
       |_module_name.rs

pub mod module_name;

pub mod plugins;

use package_name::plugins::module_name::*;

            transform : Transform{
                translation : Vec3::new(0.0,0.0,10.0), 
                rotation : Quat::from_rotation_z(0.0),
                scale : Vec3::splat(2.0),
            },

fn maptile_setup(
    mut commands: Commands, //いつもの
    asset_server: Res<AssetServer>, //アセット使用のため
    mut texture_atlases: ResMut<Assets<TextureAtlas>>, //アニメーションとかマップタイルとかはテクスチャアトラスで管理できる
) {
    //画像そのものに対するハンドルを取得
    let texture_handle = asset_server.load("textures/player.png");
   //画像をスライスしたもの(TextureAtlas)を作成
    let texture_atlas = 
      TextureAtlas::from_grid(
          texture_handle, 
          Vec2::new(/*一マスの大きさ*/16.0, 16.0), /*列数*/7,/*行数*/ 1);
    //テクスチャアトラスのハンドルを作成
    let texture_atlas_handle = texture_atlases.add(texture_atlas);

   //いつもの
    commands
        .spawn_bundle(SpriteSheetBundle {
            texture_atlas: texture_atlas_handle,
            transform : Transform{
                translation : Vec3::new(0.0,0.0,10.0),
                rotation : Quat::from_rotation_z(0.0),
                scale : Vec3::splat(2.0),
            },
            ..Default::default()
        });
}

use bevy::prelude::*;
fn main(){
  App::new()
    .init_resource::<TilePng>() 
    .add_plugins(DefaultPlugins)
    .add_startup_system(tile_load.label("load"))
    .add_startup_system(map_setup.after("load"))
    .add_startup_system(player_setup)
    .run();
}

use rand::Rng;
fn map()-> Vec<Vec<u32>>{
  const MAX_WIDTH:u32 =20;
  const MAX_HEIGHT:u32=20;

  let mut rng = rand::thread_rng();
  let width = rng.gen_range(4..=MAX_WIDTH);
  let height= rng.gen_range(4..=MAX_HEIGHT);

  let step = (rng.gen_range(1..width),rng.gen_range(1..height));

  let mut map:Vec<Vec<u32>> = Vec::new();
  for x in 0..=width{
    let mut columns:Vec<u32> =Vec::new();
    for y in 0..=height{
      let tile_type:u32 = match (x,y) {
        (x,y) if (x,y) ==step => 1, // (_,_)if (x,y)==stepと同じ
        (0,_)|(_,0) => 2,
        (x,_) if x ==width => 2,
        (_,y) if y ==height => 2,
        (_,_) => 0,
      };
      columns.push(tile_type);
    }
    map.push(columns);
  }
  map
}

#[cfg(test)]
#[test]
fn test_map_check(){
  let mapped = map();
  for x in mapped.iter(){
    for y in x.iter(){
      print!("{} ",*y);
    }
    println!("");
  }
}
// 生成例
2 2 2 2 2 2 2 2 2 2 
2 0 0 0 0 0 0 0 0 2 
2 0 0 0 0 0 0 0 0 2 
2 0 0 0 1 0 0 0 0 2 
2 0 0 0 0 0 0 0 0 2 
2 2 2 2 2 2 2 2 2 2 

fn map_setup(
    mut commands:Commands,
    texture_atlas_handle: Res<TileAtlasHandles>,
  ){
    let map_data =map_make();
    for (x,vec) in map_data.iter().enumerate() {
        for (y,item) in vec.iter().enumerate(){
  
            let position = Vec2::new(x as f32, y as f32);
            let tile_size = Vec2::splat(32.0);
            commands.spawn_bundle(SpriteSheetBundle{
                texture_atlas: texture_atlas_handle.handle.as_weak(),
                transform: Transform{
                    translation : (position * tile_size).extend(0.0),
                    rotation : Quat::from_rotation_z(0.0),
                    scale : Vec3::splat(2.0),                    
                },
                sprite: TextureAtlasSprite{
                    index : *item as usize,
                    ..Default::default()
                },
                ..Default::default()                
            })
            .insert(match item {
                2 => TileType::Wall,
                _ => TileType::Floor,
            });
        }
    }
  }

fn key_input(keyboard_input: Res<Input<KeyCode>>)
{
  if keyboard_input.just_pressed(KeyCode::Up){
    println!("pressed Up");
 }
}

fn player_move_input(
    keyboard_input: Res<Input<KeyCode>>,
    mut move_event: EventWriter<MoveEvent>, 
){
    if !keyboard_input.is_changed(){
        return;
    }else if keyboard_input.just_pressed(KeyCode::Left){
        move_event.send(MoveEvent(Dimension::Left));
    }else if keyboard_input.just_pressed(KeyCode::Right){
        move_event.send(MoveEvent(Dimension::Right));
    }else if keyboard_input.just_pressed(KeyCode::Up){
        move_event.send(MoveEvent(Dimension::Up));
    }else if keyboard_input.just_pressed(KeyCode::Down){
        move_event.send(MoveEvent(Dimension::Down));
    }
}

fn player_next_position(
  mut move_event: EventReader<MoveEvent>,
  query: Query<&Transform,With<Player>>,
  mut next_pos: ResMut<NextPos>,    
){
  for mv in move_event.iter(){
    let x_move = match mv.0{
      Dimension::Left => -1.0*TILE_WIDTH,
      Dimension::Right => 1.0*TILE_WIDTH,
      _ => 0.0,
    };
    let y_move = match mv.0{
      Dimension::Up => 1.0*TILE_HEIGHT,
      Dimension::Down => -1.0*TILE_HEIGHT,
      _ => 0.0,
    };
    let transform = query.single();
    let trans = transform.translation;
    next_pos.x=Some(trans.x+x_move);
    next_pos.y=Some(trans.y+y_move);
    return;
  }
}

fn next_tile(
  query: Query<(&Transform,&TileType)>,
  next_pos: Res<NextPos>,
  mut next_tile: ResMut<NextTile>,
){
  if next_pos.x ==None || next_pos.y ==None{
      return
  }

  let next = (next_pos.x.unwrap(),next_pos.y.unwrap());
  for (tile_pos,tile_type) in query.iter(){
    if (tile_pos.translation.x,tile_pos.translation.y)== next {
      next_tile.0 = match tile_type{
        TileType::Floor => Some(TileType::Floor),
        TileType::Step => Some(TileType::Step),
        TileType::Wall => Some(TileType::Wall),
      };
      return          
    }
  }
}

fn player_move_system(
    mut query: Query<&mut Transform,With<Player>>,
    mut step_ev: EventWriter<StepOnEvent>,
    next_pos: Res<NextPos>,
    next_tile: Res<NextTile>,
){
  let next = match next_tile.0{
    Some(TileType::Wall) => TileType::Wall,
    Some(TileType::Floor) => TileType::Floor,    
    Some(TileType::Step) => TileType::Step,
    _ => return,        
  };
  match next{
    TileType::Wall =>{
      return
    },
    TileType::Floor =>{
      let mut transform = query.single_mut();
      let translation =&mut transform.translation;
      translation.x =next_pos.x.unwrap();
      translation.y =next_pos.y.unwrap();
      return
    }
    TileType::Step =>{
      let mut transform = query.single_mut();
      let translation =&mut transform.translation;
      translation.x =next_pos.x.unwrap();
      translation.y =next_pos.y.unwrap();
      step_ev.send(StepOnEvent(true));
      return
    }
  }
}

fn resource_reset(
  mut next_pos: ResMut<NextPos>,
  mut next_tile: ResMut<NextTile>,
){
  next_pos.x =None;
  next_pos.y =None;
  next_tile.0 =None; 
}

pub struct PlayerPlugin;
impl Plugin for PlayerPlugin{
  fn build(&self,app: &mut App){
    app
      .add_startup_system(player_setup)
      .insert_resource(NextPos{x:None,y:None})
      .insert_resource(NextTile(None))      
      .add_event::<MoveEvent>()
      .add_event::<StepOnEvent>()
      .add_system(player_move_input.label("input"))
      .add_system(player_next_position.label("pos_set").after("input"))
      .add_system(next_tile.label("set_end").after("pos_set"))
      .add_system(player_move_system.label("move").after("set_end"))
      .add_system(player_move_animate.label("move").after("set_end"))
      .add_system(step_on.label("move_end").after("move"))
      .add_system(move_res_reset.after("move_end"));
  }
}

fn player_pos(map: &Vec<Vec<u32>>)->(usize,usize){
   let mut floors: Vec<(usize,usize)> = Vec::new();
   for (x, vec) in map.iter().enumerate(){
     for (y, item) in vec.iter().enumerate(){
      if *item == 0 {
        floors.push((x,y));
      }
    }
  }

  //実際のプレイヤー位置決定処理はここから
  let mut rng = rand::thread_rng();
  let pos_index = rng.gen_range(0..floors.len());
  let pos = floors[pos_index];
  return pos
}

fn enemys_pos.rs(floors:&Vec<(usize,usize)>) ->Vec<(usize,usize)>{
  let mut rng = rand::thread_rng();
  let enemys = rng.gen_range(1..MAX_ENEMY);
  let mut enemys_pos:Vec<(usize,usize)> = Vec::new();
  loop {
    let pos_index = rng.gen_range(0..floors.len());
    let pos = floors[pos_index];
    enemys_pos.push(pos);
    if enemys_pos.len() == enemy_spon {
      break
    }
  }
  enemys_pos
}

#[derive(Component)]
struct PlayerCamera;

fn camera_setup(mut commands: Commands){
      commands.spawn_bundle(OrthographicCameraBundle::new_2d())
            .insert(PlayerCamera);
}

fn player_camera(
  mut camera: Query<&mut Transform,(With<PlayerCamera>,Without<Player>)>,
  player: Query<&Transform,With<Player>>,
){
  let player = player.get_single();
  if let Ok(player_pos) = player{
    let next_pos = player_pos.translation;
    let mut camera = camera.single_mut();
    camera.translation.x = next_pos.x;
    camera.translation.y = next_pos.y;
  }
}

app.add_system(player_move_system.label("move"))
     .add_system(player_camera.after("move"));

pub struct DungeonPlugin;
impl Plugin for DungeonPlugin{
  fn build(&self,app: &mut App){
    app
      .add_state(GameState::WorldMap)
      .add_system_set(
        SystemSet::on_update(GameState::WorldMap)
          .with_system(dungeon_select) //この関数がGameState::Dungeonに変更する
      )
      .add_system_set(
        SystemSet::on_exit(GameState::WorldMap)
          .with_system(data_save) //ダンジョン生成に必要な情報などをリソース化
      )
      .add_system_set(
        SystemSet::on_enter(GameState::Dungeon)
          .with_system(dungeon_data_load) //上記で用意された情報を読み込む
      )
      .add_system_set(
        SystemSet::on_update(GameState::Dungeon)
          .with_system(...)
      )
      .add_system_set(
        SystemSet::on_exit(GameState::Dungeon)
          .with_system(data_save) //ダンジョン終了処理
      )
      .add_system(...);
  }
}

pub struct DungeonPlugin;
impl Plugin for DungeonPlugin{
  fn build(&self,app: &mut App){
    app
      .add_state(GameState::WorldMap)
      .add_event::<Event>() //色んなイベント
      .add_system_set(
        SystemSet::on_update(GameState::WorldMap)
          .with_system(dungeon_select)
      )
      .add_system_set(
        SystemSet::on_exit(GameState::WorldMap)
          .with_system(data_save)
      )
      .add_system_set(
        SystemSet::on_enter(GameState::Dungeon) // 初回起動
          .with_system(dungeon_data_load.label("data_set"))
          .with_system(floorstate_push.after("data_set")) //FloorをPush
      )//Dungeonの上にFloorステートが乗るイメージ
      .add_system_set(
        SystemSet::on_enter(GameState::Floor)
          .with_system(map_make) //データをつくって
          .with_system(free_floor)  //床配列をつくって
          .with_system(pos_set)  //いろんな初期位置を決めて
          .with_system(map_draw) //色々描画(エンティティ作成)
      )
      .add_system_set(
        SystemSet::on_update(GameState::Floor)
          .with_system(player_input)//基本はプレイヤーの入力待ち
          .with_system(step_on_event)//
          .with_system(dungeon_exit_event)
    //この2つのイベントがFloorやDungeonを終了するトリガーになる
    //Dungeonステートは消えているわけではないので、受信できるはず...
      )
      .add_system_set(
        SystemSet::on_exit(GameState::Floor)
          .with_system(floor_data_save)
      )
      .add_system_set(
   //WorldMapステートに戻すか,またFloorステートをpopするか
  // on_resumeはスタックで非アクティブから復帰する時に一度だけ呼ばれる
        SystemSet::on_resume(GameState::Floor)
          .with_system(next_state)
      )
      .add_system_set(
        SystemSet::on_exit(GameState::Dungeon) //終了処理
          .with_system(dungeon_data_load.label("data_set"))
      );
  }
}

# comments

basic_strings = " string "
many_strings = """
strings
many strings
str str str"""

file_path = '\file\hoge\huges'
non_escape= '''
エスケープしない以外は"""で囲むのと同じ
'''

fileversion = 1
filename = "test toml"
saved_value = 0.01
is_valid = true 

nanikano_array = [ 0, 0, 0 ]
string_array = [
  "string1",
  "string2", #このコンマは書いても書かなくても許される
]
float_array = [
  0.1, 0.2, 0.3, #配列の中なので許される
]

[player]
name = "Kinoko"
level = 1
hp = 10

[enemy]
name = "Takenoko"

player.name = "Kinoko"
player.level = 1
player.hp =10

enemy.name ="Takenoko"

player = {name ="Kinoko", level =1, hp =10 }

//0.6
pub struct MapPlugin;
impl Plugin for MapPlugin{
    fn build(&self, app: &mut App){
        app
          .add_startup_system(tile_load.label("load"))
          .add_startup_system(map_setup.after("load"))
}

//0.7
pub struct MapPlugin;
impl Plugin for MapPlugin{
    fn build(&self, app: &mut App){
        app
          .add_startup_system(tile_load)
          .add_startup_system(map_setup.after(tile_load))
}

//0.6
 commands.spawn_bundle(sumple_bundle{
  ..Default::default()
})

//0.7
commands.spawn_bundle(sumple_bundle{
  ..default()
})