From 96f3b3f33c49ee6b0374f862d116db229dedb458 Mon Sep 17 00:00:00 2001 From: Thomas Forgione Date: Sat, 30 Jul 2022 11:19:17 +0200 Subject: [PATCH] Working on cleaning --- src/engine/image.rs | 75 ---------------------------------- src/engine/map.rs | 16 ++++---- src/engine/mod.rs | 20 +-------- src/engine/scene.rs | 6 +-- src/engine/texture.rs | 95 +++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 108 insertions(+), 104 deletions(-) create mode 100644 src/engine/texture.rs diff --git a/src/engine/image.rs b/src/engine/image.rs index 18d248b..e127ae1 100644 --- a/src/engine/image.rs +++ b/src/engine/image.rs @@ -1,76 +1 @@ //! A module that makes it easier to deal with images. - -use std::cell::RefCell; -use std::rc::Rc; - -use wasm_bindgen::prelude::*; -use wasm_bindgen::JsCast; - -use web_sys::HtmlImageElement; - -use crate::{log, Result}; - -/// A wrapper to make it easier to manage HTML images. -pub struct Image { - /// The inner image. - pub inner: Rc>, -} - -/// The content of the image. -pub struct InnerImage { - /// The inner HtmlImageElement. - pub inner: HtmlImageElement, - - /// Whether the image has been loaded or not. - pub loaded: bool, -} - -impl Image { - /// Loads a new image from its src. - pub fn new(path: &str) -> Result { - let image = HtmlImageElement::new()?; - image.set_src(path); - - let image = Image { - inner: Rc::new(RefCell::new(InnerImage { - inner: image, - loaded: false, - })), - }; - - let clone = image.inner.clone(); - let path_clone = path.to_string(); - - let cb = Closure::::new(move |_event: web_sys::Event| { - log!("{} loaded", path_clone); - (*clone).borrow_mut().loaded = true; - }); - - image - .inner - .borrow() - .inner - .set_onload(Some(cb.as_ref().unchecked_ref())); - - cb.forget(); - - Ok(image) - } - - /// Returns whether the image is loaded. - pub fn is_loaded(&self) -> bool { - self.inner.borrow().loaded - } - - /// Renders the image on a context. - pub fn render( - &self, - x: f64, - y: f64, - context: &web_sys::CanvasRenderingContext2d, - ) -> Result<()> { - context.draw_image_with_html_image_element(&self.inner.borrow().inner, x, y)?; - - Ok(()) - } -} diff --git a/src/engine/map.rs b/src/engine/map.rs index 6afad40..ac83743 100644 --- a/src/engine/map.rs +++ b/src/engine/map.rs @@ -409,8 +409,8 @@ impl Map { /// Returns the new correct position. pub fn collides_bbox( &self, - old: FloatRect, - new: FloatRect, + old: Bbox, + new: Bbox, ) -> Option<(CollisionAxis, Vector2, Damage)> { let mut damage = Damage::None; @@ -432,7 +432,7 @@ impl Map { let tile_left = col as f32 * SPRITE_SIZE_F32; let tile_top = row as f32 * SPRITE_SIZE_F32; - let tile = FloatRect::new(tile_left, tile_top, SPRITE_SIZE_F32, SPRITE_SIZE_F32); + let tile = Bbox::new(tile_left, tile_top, SPRITE_SIZE_F32, SPRITE_SIZE_F32); if !overlap(new, tile) { continue; @@ -518,9 +518,9 @@ impl Map { } /// Checks if two boxes overlap. -pub fn overlap(box1: FloatRect, box2: FloatRect) -> bool { - box2.left < box1.left + box1.width - && box2.left + box2.width > box1.left - && box2.top < box1.top + box1.height - && box2.top + box2.height > box1.top +pub fn overlap(box1: Bbox, box2: Bbox) -> bool { + box2.position.x < box1.position.x + box1.size.x + && box2.position.x + box2.size.x > box1.position.x + && box2.position.y < box1.position.y + box1.size.y + && box2.position.y + box2.size.y > box1.position.y } diff --git a/src/engine/mod.rs b/src/engine/mod.rs index 0f2ee65..1d37d96 100644 --- a/src/engine/mod.rs +++ b/src/engine/mod.rs @@ -3,12 +3,11 @@ pub mod bbox; pub mod character; pub mod controls; -pub mod controls; pub mod event; -pub mod image; pub mod math; pub mod physics; pub mod scene; +pub mod texture; pub mod vector; use std::cell::RefCell; @@ -18,7 +17,7 @@ use wasm_bindgen::prelude::*; use wasm_bindgen::JsCast; use crate::engine::event::{Key, Keyboard}; -use crate::engine::image::Image; +use crate::engine::texture::TextureManager; use crate::{error_js, Result}; macro_rules! unwrap { @@ -206,18 +205,3 @@ impl InnerEngine { }) } } - -/// Our texture manager. -/// -/// It holds all our resources. -pub struct TextureManager { - rusty: Image, -} - -impl TextureManager { - /// Creates and start the loading of all our textures. - fn new() -> Result { - let rusty = Image::new("static/textures/rusty.png")?; - Ok(TextureManager { rusty }) - } -} diff --git a/src/engine/scene.rs b/src/engine/scene.rs index c153500..c79eb60 100644 --- a/src/engine/scene.rs +++ b/src/engine/scene.rs @@ -4,7 +4,7 @@ use std::time::Duration; use crate::engine::character::Character; use crate::engine::map::Map; -use crate::engine::texture::SPRITE_SIZE_F32; +use crate::engine::texture::SPRITE_SIZE; /// Contains everything needed to play. pub struct Scene { @@ -37,8 +37,8 @@ impl Scene { /// Adds a character to the scene. pub fn add(&mut self, character: Character) { let mut character = character; - character.position.x = self.map.entrance().1 as f32 * SPRITE_SIZE_F32; - character.position.y = self.map.entrance().0 as f32 * SPRITE_SIZE_F32; + character.position.x = self.map.entrance().1 * SPRITE_SIZE; + character.position.y = self.map.entrance().0 * SPRITE_SIZE; self.characters.push(character); } diff --git a/src/engine/texture.rs b/src/engine/texture.rs new file mode 100644 index 0000000..691aaa4 --- /dev/null +++ b/src/engine/texture.rs @@ -0,0 +1,95 @@ +//! This module holds everything related to textures. + +use std::cell::RefCell; +use std::rc::Rc; + +use wasm_bindgen::prelude::*; +use wasm_bindgen::JsCast; + +use web_sys::HtmlImageElement; + +use crate::{log, Result}; + +/// The size of sprites. +pub const SPRITE_SIZE: f64 = 32.0; + +/// A wrapper to make it easier to manage HTML images. +pub struct Image { + /// The inner image. + pub inner: Rc>, +} + +/// The content of the image. +pub struct InnerImage { + /// The inner HtmlImageElement. + pub inner: HtmlImageElement, + + /// Whether the image has been loaded or not. + pub loaded: bool, +} + +impl Image { + /// Loads a new image from its src. + pub fn new(path: &str) -> Result { + let image = HtmlImageElement::new()?; + image.set_src(path); + + let image = Image { + inner: Rc::new(RefCell::new(InnerImage { + inner: image, + loaded: false, + })), + }; + + let clone = image.inner.clone(); + let path_clone = path.to_string(); + + let cb = Closure::::new(move |_event: web_sys::Event| { + log!("{} loaded", path_clone); + (*clone).borrow_mut().loaded = true; + }); + + image + .inner + .borrow() + .inner + .set_onload(Some(cb.as_ref().unchecked_ref())); + + cb.forget(); + + Ok(image) + } + + /// Returns whether the image is loaded. + pub fn is_loaded(&self) -> bool { + self.inner.borrow().loaded + } + + /// Renders the image on a context. + pub fn render( + &self, + x: f64, + y: f64, + context: &web_sys::CanvasRenderingContext2d, + ) -> Result<()> { + context.draw_image_with_html_image_element(&self.inner.borrow().inner, x, y)?; + + Ok(()) + } +} + +/// Our texture manager. +/// +/// It holds all our resources. +pub struct TextureManager { + /// The main character sprite. + pub rusty: Image, +} + +impl TextureManager { + /// Creates and start the loading of all our textures. + pub fn new() -> Result { + let rusty = Image::new("static/textures/rusty.png")?; + Ok(TextureManager { rusty }) + } +}