141 lines
4.3 KiB
Rust
141 lines
4.3 KiB
Rust
use std::collections::HashMap;
|
|
use std::fs;
|
|
|
|
use bevy::sprite::MaterialMesh2dBundle;
|
|
use bevy::{core_pipeline::smaa::SmaaSpecializedRenderPipelines, prelude::*};
|
|
use bevy::{prelude::*, scene::ScenePlugin};
|
|
use bevy_editor_pls::EditorPlugin;
|
|
use bevy_rapier2d::prelude::{Collider, *};
|
|
use readformat::{readf, readf1};
|
|
|
|
use crate::game::WORLD_DEPTH;
|
|
use crate::AppState;
|
|
|
|
#[derive(Component)]
|
|
struct Block;
|
|
|
|
#[derive(Event)]
|
|
pub struct PlayerSpawnEvent {
|
|
x: f32,
|
|
y: f32,
|
|
block_size: f32,
|
|
}
|
|
|
|
pub(super) fn scene_plugin(app: &mut App) {
|
|
app.add_plugins(EditorPlugin::default());
|
|
// app.add_systems(, )
|
|
app.add_systems(Startup, (import_text_world,));
|
|
}
|
|
|
|
#[derive(Default)]
|
|
pub struct WorldInfo {
|
|
block_size: f32,
|
|
blocks: Vec<(String, String)>,
|
|
}
|
|
|
|
pub(super) fn import_text_world(
|
|
mut commands: Commands,
|
|
assets: Res<AssetServer>,
|
|
mut meshes: ResMut<Assets<Mesh>>,
|
|
mut materials: ResMut<Assets<ColorMaterial>>,
|
|
) {
|
|
let world_string = fs::read_to_string("assets/world.txt").expect("need a world to load");
|
|
let [info_string, world_string] = &readf("info section\n{}\nworld section\n{}", &world_string)
|
|
.expect("world does not have sections")[..]
|
|
else {
|
|
unreachable!()
|
|
};
|
|
|
|
let mut wi = WorldInfo::default();
|
|
for line in info_string.lines() {
|
|
let [name, val] = &readf(" {} = {}", line).expect("invalid line in info section")[..]
|
|
else {
|
|
unreachable!()
|
|
};
|
|
|
|
match name.as_str() {
|
|
"block-size" => wi.block_size = val.parse().unwrap(),
|
|
x if x.starts_with(".") => {
|
|
let x = readf1(".{}", x).unwrap();
|
|
wi.blocks.push((x, val.to_owned()));
|
|
}
|
|
x => panic!("invalid setting {x}"),
|
|
}
|
|
}
|
|
|
|
for (current_y, line) in world_string.lines().rev().enumerate() {
|
|
let mut i = 0;
|
|
// try to match every defined block
|
|
'a: while i < line.len() {
|
|
if line[i..].starts_with(" ") {
|
|
i += 1;
|
|
continue;
|
|
}
|
|
for possible_block in wi.blocks.iter() {
|
|
if line[i..].starts_with(possible_block.0.as_str()) {
|
|
let len = possible_block.0.len();
|
|
|
|
let (tex, collider) = if let Some(s) = possible_block.1.strip_prefix("_") {
|
|
(s.to_owned(), false)
|
|
} else {
|
|
(possible_block.1.to_owned(), true)
|
|
};
|
|
|
|
let x = i as f32 * wi.block_size;
|
|
let y = current_y as f32 * wi.block_size;
|
|
if tex == "[player]" {
|
|
commands.trigger(PlayerSpawnEvent {
|
|
x,
|
|
y,
|
|
block_size: wi.block_size,
|
|
})
|
|
} else {
|
|
spawn_block(
|
|
&mut commands,
|
|
&mut meshes,
|
|
&mut materials,
|
|
&assets,
|
|
tex,
|
|
(x, y, len, wi.block_size),
|
|
collider,
|
|
);
|
|
}
|
|
println!("spawned {possible_block:?} at {x}, {y}");
|
|
|
|
i += len;
|
|
continue 'a;
|
|
}
|
|
}
|
|
panic!("unknown block in at {i},{current_y}");
|
|
}
|
|
}
|
|
}
|
|
|
|
fn spawn_block(
|
|
commands: &mut Commands,
|
|
meshes: &mut ResMut<Assets<Mesh>>,
|
|
materials: &mut ResMut<Assets<ColorMaterial>>,
|
|
assets: &Res<AssetServer>,
|
|
tex: String,
|
|
(x, y, len, block_size): (f32, f32, usize, f32),
|
|
collider: bool,
|
|
) {
|
|
let mut command = commands.spawn((
|
|
Block,
|
|
MaterialMesh2dBundle {
|
|
mesh: meshes
|
|
.add(Rectangle::new(block_size * len as f32, block_size))
|
|
.into(),
|
|
material: materials.add(assets.load(tex)),
|
|
transform: Transform::from_xyz(x, y, WORLD_DEPTH),
|
|
..Default::default()
|
|
},
|
|
));
|
|
if collider {
|
|
command.insert((
|
|
RigidBody::Fixed,
|
|
Collider::cuboid(block_size / 2.0 * len as f32, block_size / 2.0),
|
|
Velocity::default(),
|
|
));
|
|
}
|
|
}
|