From e42586384a5fab0c00e4b89b3b4c2e70541b0261 Mon Sep 17 00:00:00 2001
From: Elias Stepanik <eliasstepanik@proton.me>
Date: Tue, 22 Oct 2024 23:19:16 +0200
Subject: [PATCH] Working

---
 assets/fonts/minecraft_font.ttf | Bin 0 -> 15700 bytes
 src/components/player.rs        |  73 ++++++++++++++++++++++
 src/components/tilemap.rs       |  83 +++++++++++++++++++++++++
 src/components/ui.rs            |  50 +++++++++++++++
 src/components/world.rs         | 106 ++++++++++++++++++++++++++++++++
 5 files changed, 312 insertions(+)
 create mode 100644 assets/fonts/minecraft_font.ttf
 create mode 100644 src/components/player.rs
 create mode 100644 src/components/tilemap.rs
 create mode 100644 src/components/ui.rs
 create mode 100644 src/components/world.rs

diff --git a/assets/fonts/minecraft_font.ttf b/assets/fonts/minecraft_font.ttf
new file mode 100644
index 0000000000000000000000000000000000000000..61b4610bd20cd58a9782bd5e1cc8f217a9858f30
GIT binary patch
literal 15700
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

literal 0
HcmV?d00001

diff --git a/src/components/player.rs b/src/components/player.rs
new file mode 100644
index 0000000..3b68f38
--- /dev/null
+++ b/src/components/player.rs
@@ -0,0 +1,73 @@
+use bevy::input::ButtonInput;
+use bevy::log::info;
+use bevy::prelude::{Camera, Camera2dBundle, Commands, Component, GlobalTransform, KeyCode, Query, Res, Time, Transform, Vec3, With, Without};
+use bevy::utils::default;
+
+#[derive(Component)]
+pub struct Player {
+    pub speed: f32,
+    pub position: Vec3,
+}
+
+impl Player {
+    pub fn new(speed: f32, position: Vec3) -> Self {
+        Player { speed, position }
+    }
+}
+
+pub fn setup(mut commands: Commands) {
+    // Setup camera
+    info!("Adding Camera");
+    commands.spawn(Camera2dBundle {
+        transform: Transform {
+            scale: Vec3::splat(0.5), // Zoom in by reducing the scale (smaller scale means a larger view)
+            ..default()
+        },
+        ..default()
+    });
+
+
+    // Setup player with initial position
+    info!("Spawning player");
+    commands.spawn((
+        Player::new(500.0, Vec3::new(0.0, 0.0, 0.0)), // Initial player speed and position
+        Transform::from_translation(Vec3::new(0.0, 0.0, 0.0)),
+        GlobalTransform::default(),
+    ));
+}
+
+pub fn update_movement(
+    keyboard_input: Res<ButtonInput<KeyCode>>,
+    time: Res<Time>,
+    mut query: Query<(&mut Player, &mut Transform)>,
+    mut camera_query: Query<&mut Transform, (With<Camera>, Without<Player>)>,
+) {
+    let delta_time = time.delta_seconds(); // Get the time elapsed between frames
+
+    for (mut player, mut player_transform) in query.iter_mut() {
+        // Update the player position based on input
+        if keyboard_input.pressed(KeyCode::KeyW) {
+            player.position.y += player.speed * delta_time;
+        }
+        if keyboard_input.pressed(KeyCode::KeyS) {
+            player.position.y -= player.speed * delta_time;
+        }
+        if keyboard_input.pressed(KeyCode::KeyA) {
+            player.position.x -= player.speed * delta_time;
+        }
+        if keyboard_input.pressed(KeyCode::KeyD) {
+            player.position.x += player.speed * delta_time;
+        }
+
+        // Update the player's transform
+        player_transform.translation = player.position;
+    }
+
+    // Update the camera transform to match the player's position
+    if let Ok(mut camera_transform) = camera_query.get_single_mut() {
+        if let Ok((player, _)) = query.get_single() {
+            camera_transform.translation.x = player.position.x;
+            camera_transform.translation.y = player.position.y;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/components/tilemap.rs b/src/components/tilemap.rs
new file mode 100644
index 0000000..3e4d9c8
--- /dev/null
+++ b/src/components/tilemap.rs
@@ -0,0 +1,83 @@
+use std::collections::HashMap;
+use bevy::prelude::*;
+use noise::{NoiseFn, Perlin};
+use crate::components::world::CHUNK_SIZE;
+
+pub struct Chunk {
+    pub tiles: Vec<Tile>,
+    pub chunk_coords: (i64, i64),
+    pub tile_entities: Vec<Entity>, // List of entity IDs for the tiles in this chunk
+}
+impl Chunk {
+    pub(crate) fn new(chunk_coords: (i64, i64)) -> Self {
+        info!("Generating chunk at coordinates: {:?}", chunk_coords);
+
+        let perlin = Perlin::new(1321231231);
+        let mut tiles = Vec::new();
+
+        for x in 0..CHUNK_SIZE {
+            for y in 0..CHUNK_SIZE {
+                let world_x = chunk_coords.0 * CHUNK_SIZE as i64 + x as i64;
+                let world_y = chunk_coords.1 * CHUNK_SIZE as i64 + y as i64;
+
+                let noise_value = perlin.get([world_x as f64 * 0.1, world_y as f64 * 0.1]);
+
+                let tile_type = if noise_value > 0.5 {
+                    TileType::Grass
+                } else if noise_value > 0.0 {
+                    TileType::Dirt
+                } else {
+                    TileType::Water
+                };
+
+                tiles.push(Tile {
+                    tile_type,
+                    position: Vec2::new(x as f32, y as f32),
+                });
+            }
+        }
+
+        Chunk {
+            tiles,
+            chunk_coords,
+            tile_entities: Vec::new(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TileType {
+    Grass,
+    Dirt,
+    Water,
+}
+
+pub struct Tile {
+    pub(crate) tile_type: TileType,
+    pub(crate) position: Vec2, // Position within the chunk
+}
+
+#[derive(Resource)]
+pub struct TileMap {
+    pub(crate) chunks: HashMap<(i64, i64), Chunk>,
+}
+
+impl TileMap {
+    pub(crate) fn new() -> Self {
+        TileMap {
+            chunks: HashMap::new(),
+        }
+    }
+
+    pub(crate) fn load_chunk(&mut self, chunk_coords: (i64, i64)) {
+        // Load or generate the chunk at chunk_coords
+        if !self.chunks.contains_key(&chunk_coords) {
+            let new_chunk = Chunk::new(chunk_coords);
+            self.chunks.insert(chunk_coords, new_chunk);
+        }
+    }
+
+    fn unload_chunk(&mut self, chunk_coords: (i64, i64)) {
+        self.chunks.remove(&chunk_coords);
+    }
+}
diff --git a/src/components/ui.rs b/src/components/ui.rs
new file mode 100644
index 0000000..e4045a0
--- /dev/null
+++ b/src/components/ui.rs
@@ -0,0 +1,50 @@
+use bevy::asset::AssetServer;
+use bevy::prelude::{default, Camera, Color, Commands, Component, Query, Res, Text, TextBundle, TextStyle, Transform, Val, With};
+use bevy::ui::{PositionType, Style};
+use crate::components::player::Player;
+
+#[derive(Component)]
+pub struct SpeedDisplay;
+
+pub fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
+
+    // Spawn UI text for debugging speed
+    commands.spawn((
+        TextBundle {
+            text: Text::from_section(
+                "Speed: 5.0", // Initial text
+                TextStyle {
+                    font: asset_server.load("fonts/minecraft_font.ttf"), // Load a font
+                    font_size: 40.0,
+                    color: Color::WHITE,
+                },
+            ),
+            style: Style {
+                position_type: PositionType::Absolute,
+                top: Val::Px(10.0),
+                left: Val::Px(10.0),
+                ..default()
+            },
+            ..default()
+        },
+        SpeedDisplay,
+    ));
+}
+
+pub fn update(
+    player_query: Query<&Player>,
+    mut query_text: Query<&mut Text, With<SpeedDisplay>>,
+) {
+    let player = player_query.single();
+    let mut text = query_text.single_mut();
+
+    // Update the text with the current speed and position
+    text.sections[0].value = format!(
+        "Speed: {:.2}\nPosition: ({:.2}, {:.2}, {:.2})",
+        player.speed,
+        player.position.x,
+        player.position.y,
+        player.position.z,
+    );
+
+}
diff --git a/src/components/world.rs b/src/components/world.rs
new file mode 100644
index 0000000..64f6bd5
--- /dev/null
+++ b/src/components/world.rs
@@ -0,0 +1,106 @@
+use bevy::input::keyboard::KeyboardInput;
+use bevy::prelude::*;
+use bevy::render::mesh::PrimitiveTopology;
+use bevy::render::render_asset::RenderAssetUsages;
+use bevy::sprite::{MaterialMesh2dBundle, Mesh2dHandle};
+use crate::components::tilemap::{Chunk, TileMap, TileType};
+
+pub const CHUNK_SIZE: i32 = 64;
+
+pub(crate) fn chunk_loader_system(
+    mut commands: Commands,
+    mut tile_map: ResMut<TileMap>,
+    camera_query: Query<&Transform, With<Camera>>,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<ColorMaterial>>,
+) {
+    // Get the camera position
+    let camera_transform = camera_query.single();
+    let camera_position = camera_transform.translation;
+
+    // Calculate the chunk coordinates based on the camera's position
+    let chunk_x = (camera_position.x / (CHUNK_SIZE as f32 * 2.0)).floor() as i64;
+    let chunk_y = (camera_position.y / (CHUNK_SIZE as f32 * 2.0)).floor() as i64;
+
+    let load_radius = 5; // Number of chunks to load around the camera
+
+    // Load chunks within the radius of the camera position
+    for x in (chunk_x - load_radius)..=(chunk_x + load_radius) {
+        for y in (chunk_y - load_radius)..=(chunk_y + load_radius) {
+            if !tile_map.chunks.contains_key(&(x, y)) {
+                let mut new_chunk = Chunk::new((x, y));
+                render_chunk(&mut new_chunk, &mut commands, &mut meshes, &mut materials);
+                tile_map.chunks.insert((x, y), new_chunk);
+            }
+        }
+    }
+
+    // Unload chunks that are outside the load radius
+    let chunks_to_unload: Vec<(i64, i64)> = tile_map
+        .chunks
+        .keys()
+        .filter(|&&(x, y)| (x - chunk_x).abs() > load_radius || (y - chunk_y).abs() > load_radius)
+        .cloned()
+        .collect();
+
+    for chunk_coords in chunks_to_unload {
+        if let Some(chunk) = tile_map.chunks.remove(&chunk_coords) {
+            for entity in chunk.tile_entities {
+                commands.entity(entity).despawn();
+            }
+        }
+    }
+}
+
+fn render_chunk(
+    chunk: &mut Chunk,
+    commands: &mut Commands,
+    meshes: &mut ResMut<Assets<Mesh>>,
+    materials: &mut ResMut<Assets<ColorMaterial>>,
+) {
+    let tile_size = 2.0; // Each tile is 2x2 units in size
+    let mut mesh = Mesh::new(PrimitiveTopology::TriangleList, RenderAssetUsages::default());
+
+    // Define vertices and uvs
+    let half_size = tile_size / 2.0;
+    let positions = vec![
+        [half_size, half_size, 0.0],
+        [half_size, -half_size, 0.0],
+        [-half_size, -half_size, 0.0],
+        [-half_size, half_size, 0.0],
+    ];
+
+    let indices = vec![0, 1, 3, 1, 2, 3];
+
+    mesh.insert_attribute(Mesh::ATTRIBUTE_POSITION, positions);
+    mesh.insert_indices(bevy::render::mesh::Indices::U32(indices));
+
+    let mesh_handle = meshes.add(mesh);
+
+    // Define materials for each TileType
+    let grass_material = materials.add(ColorMaterial::from(Color::rgb(0.1, 0.8, 0.1)));
+    let dirt_material = materials.add(ColorMaterial::from(Color::rgb(0.5, 0.3, 0.1)));
+    let water_material = materials.add(ColorMaterial::from(Color::rgb(0.1, 0.1, 0.8)));
+
+    // Spawn each tile within the chunk
+    for tile in &chunk.tiles {
+        let material_handle = match tile.tile_type {
+            TileType::Grass => grass_material.clone(),
+            TileType::Dirt => dirt_material.clone(),
+            TileType::Water => water_material.clone(),
+        };
+
+        let entity = commands.spawn(MaterialMesh2dBundle {
+            mesh: Mesh2dHandle(mesh_handle.clone()),
+            material: material_handle,
+            transform: Transform::from_translation(Vec3::new(
+                tile.position.x * tile_size + chunk.chunk_coords.0 as f32 * CHUNK_SIZE as f32 * tile_size,
+                tile.position.y * tile_size + chunk.chunk_coords.1 as f32 * CHUNK_SIZE as f32 * tile_size,
+                0.0,
+            )),
+            ..default()
+        }).id();
+
+        chunk.tile_entities.push(entity);
+    }
+}
\ No newline at end of file