hodasemi/rpg_base
1
0
Fork 0
Code Issues 1 Pull requests 2 Projects Releases Wiki Activity Actions

Get character window working

Browse source
This commit is contained in:
Michael Hübner 2025-03-05 10:31:16 +01:00
parent 0ed03f16af
commit 47e732377b
7 changed files with 347 additions and 315 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

163
character_window/src/abilities/ability_right_side.rs
View file

@ -28,37 +28,47 @@ impl<A: Ability + 'static> AbilityPageRightSide<A> {
"fourth_ability", "fourth_ability",
]; ];
pub fn new(world: &World, hero: Entity) -> Result<Self> { pub fn new(world: &mut World, hero: Entity, reference: &Weak<CharacterWindow>) -> Result<Self> {
let snippet = GuiSnippet::from_str( let snippet = GuiSnippet::from_str(
world.resources.get::<Arc<GuiHandler>>(), world,
include_str!("../../resources/abilities/right_side.xml"), include_str!("../../resources/abilities/right_side.xml"),
)?; )?;
let color_settings = world.resources.get::<ItemSettings>().rarity_color_settings; let mut resources = world.resources.multi_mut();
let gui_handler = resources.get::<GuiHandler>();
let engine_settings = resources.get::<EngineSettings>();
let context = resources.get::<Context>();
Self::rarity_icon_background(&snippet, "common", color_settings.common)?; let color_settings = resources
Self::rarity_icon_background(&snippet, "uncommon", color_settings.uncommon)?; .get::<ItemSettings>()
Self::rarity_icon_background(&snippet, "magical", color_settings.magical)?; .rarity_color_settings
Self::rarity_icon_background(&snippet, "rare", color_settings.rare)?; .clone();
Self::rarity_icon_background(&snippet, "epic", color_settings.epic)?;
Self::rarity_icon_background(&snippet, "legendary", color_settings.legendary)?; Self::rarity_icon_background(gui_handler, &snippet, "common", color_settings.common)?;
Self::rarity_icon_background(gui_handler, &snippet, "uncommon", color_settings.uncommon)?;
Self::rarity_icon_background(gui_handler, &snippet, "magical", color_settings.magical)?;
Self::rarity_icon_background(gui_handler, &snippet, "rare", color_settings.rare)?;
Self::rarity_icon_background(gui_handler, &snippet, "epic", color_settings.epic)?;
Self::rarity_icon_background(gui_handler, &snippet, "legendary", color_settings.legendary)?;
for (index, name) in Self::ABILITY_BUTTON_NAMES.iter().enumerate() { for (index, name) in Self::ABILITY_BUTTON_NAMES.iter().enumerate() {
let button: Arc<Button> = snippet.element(name)?; let button: Arc<Button> = snippet.element(name)?;
button.set_info_icon(&world.resources.get::<EngineSettings>().controller_icon( button.set_info_icon(
world.resources.get::<Context>(), gui_handler,
ControllerButton::RightStick, &engine_settings.controller_icon(context, ControllerButton::RightStick)?,
)?)?; )?;
button.set_callback({ button.set_callback({
|| { let reference = reference.clone();
move |world: &mut World| {
if let Some(menu) = reference.upgrade() { if let Some(menu) = reference.upgrade() {
let mut tabs = menu.tabs_mut(); let mut tabs = menu.tabs_mut();
let abilities = tabs.abilities::<A>(); let abilities = tabs.abilities::<A>();
abilities.right_side.ability_index = index; abilities.right_side.ability_index = index;
abilities.update_page()?; abilities.update_page(world)?;
} }
Ok(()) Ok(())
@ -66,15 +76,13 @@ impl<A: Ability + 'static> AbilityPageRightSide<A> {
}); });
button.set_select_callback({ button.set_select_callback({
let engine = engine.clone();
let reference = reference.clone(); let reference = reference.clone();
let weak_button = Arc::downgrade(&button); let weak_button = Arc::downgrade(&button);
move |selected| { move |world, selected| {
if let Some(menu) = reference.upgrade() { if let Some(menu) = reference.upgrade() {
if selected { if selected {
engine.on_scene(|scene| { let entity = unsafe { remove_life_time(world.entity(hero)?) };
let entity = scene.entity(hero)?;
let abilities = entity.get_component::<AbilitySlots<A>>()?; let abilities = entity.get_component::<AbilitySlots<A>>()?;
if let Some(book) = abilities.book(index) { if let Some(book) = abilities.book(index) {
@ -86,19 +94,17 @@ impl<A: Ability + 'static> AbilityPageRightSide<A> {
let statistics = entity.get_component::<Statistics>()?; let statistics = entity.get_component::<Statistics>()?;
let gui = book.create_tooltip( let gui =
engine.gui_handler(), book.create_tooltip(world, statistics, (target_x, target_y))?;
statistics, gui.enable(world)?;
(target_x, target_y), gui.perform_single_check(
world.resources.get_mut::<GuiHandler>(),
button_pos.0,
button_pos.1,
)?; )?;
gui.enable()?;
gui.perform_single_check(button_pos.0, button_pos.1)?;
menu.add_tooltip("active_ability", gui); menu.add_tooltip("active_ability", gui);
} }
Ok(())
})?;
} else { } else {
menu.remove_tooltip("active_ability"); menu.remove_tooltip("active_ability");
} }
@ -109,13 +115,11 @@ impl<A: Ability + 'static> AbilityPageRightSide<A> {
}); });
button.set_custom_callback({ button.set_custom_callback({
let engine = engine.clone();
let reference = reference.clone(); let reference = reference.clone();
move |button| match button { move |world, button| match button {
ControllerButton::Y => { ControllerButton::Y => {
engine.on_scene_mut(|scene| { let entity = world.entity_mut(hero)?;
let entity = scene.entity_mut(hero)?;
let mut multi_mut = entity.multi_mut(); let mut multi_mut = entity.multi_mut();
let abilities = multi_mut.get::<AbilitySlots<A>>()?; let abilities = multi_mut.get::<AbilitySlots<A>>()?;
@ -129,13 +133,10 @@ impl<A: Ability + 'static> AbilityPageRightSide<A> {
menu.tabs_mut() menu.tabs_mut()
.abilities::<A>() .abilities::<A>()
.right_side .right_side
.refresh(&engine, hero)?; .refresh(world, hero)?;
} }
} }
Ok(())
})?;
Ok(true) Ok(true)
} }
@ -155,43 +156,61 @@ impl<A: Ability + 'static> AbilityPageRightSide<A> {
self.ability_index self.ability_index
} }
fn rarity_icon_background(gui: &GuiSnippet, element: &str, color: Color) -> Result<()> { fn rarity_icon_background(
gui_handler: &mut GuiHandler,
gui: &GuiSnippet,
element: &str,
color: Color,
) -> Result<()> {
let icon: Arc<Icon> = gui.element(element)?; let icon: Arc<Icon> = gui.element(element)?;
icon.set_background(FillTypeInfo::Element( icon.set_background(
gui_handler,
FillTypeInfo::Element(
ElementDescriptor::new(color, Color::Black, 2), ElementDescriptor::new(color, Color::Black, 2),
DisplayableFillType::Square, DisplayableFillType::Square,
)) ),
)
} }
fn update_crafting_count(&self, element: &str, value: u32) -> Result<()> { fn update_crafting_count(
&self,
gui_handler: &mut GuiHandler,
element: &str,
value: u32,
) -> Result<()> {
let icon: Arc<Icon> = self.snippet.element(element)?; let icon: Arc<Icon> = self.snippet.element(element)?;
icon.set_text(value)?; icon.set_text(gui_handler, value)?;
Ok(()) Ok(())
} }
fn update_ability_icon(&self, element: &str, image: Option<Arc<Image>>) -> Result<()> { fn update_ability_icon(
&self,
gui_handler: &mut GuiHandler,
element: &str,
image: Option<Arc<Image>>,
) -> Result<()> {
let button: Arc<Button> = self.snippet.element(element)?; let button: Arc<Button> = self.snippet.element(element)?;
match image { match image {
Some(image) => { Some(image) => {
button.set_icon(&image)?; button.set_icon(gui_handler, &image)?;
} }
None => { None => {
button.clear_icon()?; button.clear_icon(gui_handler)?;
} }
} }
Ok(()) Ok(())
} }
fn update_active_ability(&self, engine: &Engine, abilities: &AbilitySlots<A>) -> Result<()> { fn update_active_ability(&self, world: &mut World, abilities: &AbilitySlots<A>) -> Result<()> {
let grid: Arc<Grid> = self.snippet.element("ability_content")?; let grid: Arc<Grid> = self.snippet.element("ability_content")?;
let (_, rows) = grid.dimensions(); let (_, rows) = grid.dimensions();
for y in 0..rows { for y in 0..rows {
grid.detach(0, y)?; grid.detach(world, 0, y)?;
} }
if let Some(ability) = abilities.book(self.ability_index) { if let Some(ability) = abilities.book(self.ability_index) {
@ -199,7 +218,7 @@ impl<A: Ability + 'static> AbilityPageRightSide<A> {
match addon.as_ref() { match addon.as_ref() {
Some(addon) => { Some(addon) => {
let addon_type_snippet = GuiSnippet::from_str( let addon_type_snippet = GuiSnippet::from_str(
engine.gui_handler(), world,
include_str!("../../resources/abilities/addon_type_snippet.xml"), include_str!("../../resources/abilities/addon_type_snippet.xml"),
)?; )?;
@ -207,19 +226,21 @@ impl<A: Ability + 'static> AbilityPageRightSide<A> {
let addon_type: Arc<Label> = addon_type_snippet.element("addon_type")?; let addon_type: Arc<Label> = addon_type_snippet.element("addon_type")?;
let addon_value: Arc<Label> = addon_type_snippet.element("addon_value")?; let addon_value: Arc<Label> = addon_type_snippet.element("addon_value")?;
addon_icon.set_icon(&addon.icon())?; let gui_handler = world.resources.get_mut::<GuiHandler>();
addon_type.set_text(&format!("{}", addon.addon_type()))?;
addon_value.set_text(&addon.addon_type().val_as_str())?;
grid.attach(addon_type_snippet, 0, index, 1, 1)?; addon_icon.set_icon(gui_handler, &addon.icon())?;
addon_type.set_text(gui_handler, &format!("{}", addon.addon_type()))?;
addon_value.set_text(gui_handler, &addon.addon_type().val_as_str())?;
grid.attach(world, addon_type_snippet, 0, index, 1, 1)?;
} }
None => { None => {
let empty_addon = GuiSnippet::from_str( let empty_addon = GuiSnippet::from_str(
engine.gui_handler(), world,
include_str!("../../resources/abilities/empty_addon_snippet.xml"), include_str!("../../resources/abilities/empty_addon_snippet.xml"),
)?; )?;
grid.attach(empty_addon, 0, index, 1, 1)?; grid.attach(world, empty_addon, 0, index, 1, 1)?;
} }
} }
} }
@ -228,36 +249,44 @@ impl<A: Ability + 'static> AbilityPageRightSide<A> {
Ok(()) Ok(())
} }
pub fn next_ability(&mut self, engine: &Arc<Engine>, hero: Entity) -> Result<()> { pub fn next_ability(&mut self, world: &mut World, hero: Entity) -> Result<()> {
self.ability_index = (self.ability_index + 1) % 4; self.ability_index = (self.ability_index + 1) % 4;
self.refresh(engine, hero) self.refresh(world, hero)
} }
} }
impl<A: Ability + 'static> RightSide for AbilityPageRightSide<A> { impl<A: Ability + 'static> RightSide for AbilityPageRightSide<A> {
fn refresh(&mut self, engine: &Engine, hero: Entity) -> Result<()> { fn refresh(&mut self, world: &mut World, hero: Entity) -> Result<()> {
engine.on_scene(|scene| { let entity = unsafe { remove_life_time(world.entity(hero)?) };
let entity = scene.entity(hero)?;
let crafting = entity.get_component::<CraftingMaterials>()?; let crafting = entity.get_component::<CraftingMaterials>()?;
self.update_crafting_count("common", crafting.count(Rarities::Common))?; let gui_handler = world.resources.get_mut::<GuiHandler>();
self.update_crafting_count("uncommon", crafting.count(Rarities::Uncommon))?;
self.update_crafting_count("magical", crafting.count(Rarities::Magical))?; self.update_crafting_count(gui_handler, "common", crafting.count(Rarities::Common))?;
self.update_crafting_count("rare", crafting.count(Rarities::Rare))?; self.update_crafting_count(gui_handler, "uncommon", crafting.count(Rarities::Uncommon))?;
self.update_crafting_count("epic", crafting.count(Rarities::Epic))?; self.update_crafting_count(gui_handler, "magical", crafting.count(Rarities::Magical))?;
self.update_crafting_count("legendary", crafting.count(Rarities::Legendary))?; self.update_crafting_count(gui_handler, "rare", crafting.count(Rarities::Rare))?;
self.update_crafting_count(gui_handler, "epic", crafting.count(Rarities::Epic))?;
self.update_crafting_count(
gui_handler,
"legendary",
crafting.count(Rarities::Legendary),
)?;
let abilities = entity.get_component::<AbilitySlots<A>>()?; let abilities = entity.get_component::<AbilitySlots<A>>()?;
for (index, name) in Self::ABILITY_BUTTON_NAMES.iter().enumerate() { for (index, name) in Self::ABILITY_BUTTON_NAMES.iter().enumerate() {
self.update_ability_icon(name, abilities.book(index).map(|book| book.icon()))?; self.update_ability_icon(
gui_handler,
name,
abilities.book(index).map(|book| book.icon()),
)?;
} }
self.update_active_ability(engine, abilities)?; self.update_active_ability(world, abilities)?;
Ok(()) Ok(())
})
} }
fn base(&self) -> &Arc<GuiSnippet> { fn base(&self) -> &Arc<GuiSnippet> {

111
character_window/src/abilities/content.rs
View file

@ -9,47 +9,44 @@ use rpg_components::items::ability_book::AbilityBook;
use crate::*; use crate::*;
use crate::{ use crate::{
content::{Content, ContentUpdate},
CharacterWindow, CharacterWindow,
content::{Content, ContentUpdate},
}; };
use super::AbilityPage; use super::AbilityPage;
impl<A: Ability + 'static> Content<A, AbilityAddon> { impl<A: Ability + 'static> Content<A, AbilityAddon> {
fn show_addon_tooltip( fn show_addon_tooltip(
engine: &Arc<Engine>, world: &mut World,
hero: Entity, hero: Entity,
addon_index: usize, addon_index: usize,
reference: &Weak<CharacterWindow>, reference: &Weak<CharacterWindow>,
(x, y, w, _h): (i32, i32, u32, u32), (x, y, w, _h): (i32, i32, u32, u32),
) -> Result<()> { ) -> Result<()> {
engine.on_scene(|scene| { let entity = unsafe { remove_life_time(world.entity(hero)?) };
let entity = scene.entity(hero)?;
let inventory = entity.get_component::<Inventory<A>>()?; let inventory = entity.get_component::<Inventory<A>>()?;
let target_x = x + w as i32; let target_x = x + w as i32;
let target_y = y; let target_y = y;
let addon = inventory.addon_at(addon_index); let addon = inventory.addon_at(addon_index);
let gui = addon.create_tooltip(engine.gui_handler(), (target_x, target_y))?; let gui = addon.create_tooltip(world, (target_x, target_y))?;
gui.enable()?; gui.enable(world)?;
gui.perform_single_check(x, y)?; gui.perform_single_check(world.resources.get_mut::<GuiHandler>(), x, y)?;
let window = reference.upgrade().unwrap(); let window = reference.upgrade().unwrap();
window.add_tooltip(format!("addon_{addon_index}"), gui); window.add_tooltip(format!("addon_{addon_index}"), gui);
Ok(()) Ok(())
})
} }
fn insert_addon( fn insert_addon(
engine: &Arc<Engine>, world: &mut World,
hero: Entity, hero: Entity,
addon_index: usize, addon_index: usize,
ability_page: &AbilityPage<A>, ability_page: &AbilityPage<A>,
) -> Result<()> { ) -> Result<()> {
engine.on_scene_mut(|scene| { let entity = world.entity_mut(hero)?;
let entity = scene.entity_mut(hero)?;
let mut multi_mut = entity.multi_mut(); let mut multi_mut = entity.multi_mut();
let inventory = multi_mut.get::<Inventory<A>>()?; let inventory = multi_mut.get::<Inventory<A>>()?;
@ -63,25 +60,23 @@ impl<A: Ability + 'static> Content<A, AbilityAddon> {
} }
Ok(()) Ok(())
})
} }
} }
impl<A: Ability + 'static> ContentUpdate for Content<A, AbilityAddon> { impl<A: Ability + 'static> ContentUpdate for Content<A, AbilityAddon> {
fn update(&mut self, engine: &Arc<Engine>, hero: Entity) -> Result<()> { fn update(&mut self, world: &mut World, hero: Entity) -> Result<()> {
let reference = self.reference.clone(); let reference = self.reference.clone();
self.update_base(engine, |button, t, index| { self.update_base(world, |world, button, t, index| {
button.set_icon(&t.icon())?; button.set_icon(world.resources.get_mut::<GuiHandler>(), &t.icon())?;
button.set_custom_callback({ button.set_custom_callback({
let engine = engine.clone();
let reference = reference.clone(); let reference = reference.clone();
move |controller_button| { move |world, controller_button| {
if let ControllerButton::X = controller_button { if let ControllerButton::X = controller_button {
CharacterWindow::salvage_from_inventory::<A, _, _>( CharacterWindow::salvage_from_inventory::<A, _, _>(
&engine, world,
hero, hero,
|inventory| inventory.remove_addon(index), |inventory| inventory.remove_addon(index),
)?; )?;
@ -90,7 +85,7 @@ impl<A: Ability + 'static> ContentUpdate for Content<A, AbilityAddon> {
let mut tabs = menu.tabs_mut(); let mut tabs = menu.tabs_mut();
let abilities = tabs.abilities::<A>(); let abilities = tabs.abilities::<A>();
abilities.update_page()?; abilities.update_page(world)?;
} }
return Ok(true); return Ok(true);
@ -101,17 +96,16 @@ impl<A: Ability + 'static> ContentUpdate for Content<A, AbilityAddon> {
}); });
button.set_callback({ button.set_callback({
let engine = engine.clone();
let reference = reference.clone(); let reference = reference.clone();
move || { move |world| {
if let Some(menu) = reference.upgrade() { if let Some(menu) = reference.upgrade() {
let mut tabs = menu.tabs_mut(); let mut tabs = menu.tabs_mut();
let abilities = tabs.abilities(); let abilities = tabs.abilities();
Self::insert_addon(&engine, hero, index, abilities)?; Self::insert_addon(world, hero, index, abilities)?;
abilities.update_page()?; abilities.update_page(world)?;
} }
Ok(()) Ok(())
@ -120,14 +114,13 @@ impl<A: Ability + 'static> ContentUpdate for Content<A, AbilityAddon> {
button.set_select_callback({ button.set_select_callback({
let weak_button = Arc::downgrade(&button); let weak_button = Arc::downgrade(&button);
let engine = engine.clone();
let reference = reference.clone(); let reference = reference.clone();
move |selected| { move |world, selected| {
if selected { if selected {
let button_pos = weak_button.upgrade().unwrap().position_extent(); let button_pos = weak_button.upgrade().unwrap().position_extent();
Self::show_addon_tooltip(&engine, hero, index, &reference, button_pos)?; Self::show_addon_tooltip(world, hero, index, &reference, button_pos)?;
} else { } else {
let window = reference.upgrade().unwrap(); let window = reference.upgrade().unwrap();
@ -142,20 +135,19 @@ impl<A: Ability + 'static> ContentUpdate for Content<A, AbilityAddon> {
}) })
} }
fn select(&self) -> Result<()> { fn select(&self, world: &mut World) -> Result<()> {
self.select() self.select(world.resources.get_mut::<GuiHandler>())
} }
} }
impl<A: Ability + 'static> Content<A, AbilityBook<A>> { impl<A: Ability + 'static> Content<A, AbilityBook<A>> {
fn equip_book( fn equip_book(
engine: &Arc<Engine>, world: &mut World,
hero: Entity, hero: Entity,
book_index: usize, book_index: usize,
ability_page: &AbilityPage<A>, ability_page: &AbilityPage<A>,
) -> Result<()> { ) -> Result<()> {
engine.on_scene_mut(|scene| { let entity = world.entity_mut(hero)?;
let entity = scene.entity_mut(hero)?;
let mut multi_mut = entity.multi_mut(); let mut multi_mut = entity.multi_mut();
let inventory = multi_mut.get::<Inventory<A>>()?; let inventory = multi_mut.get::<Inventory<A>>()?;
@ -169,18 +161,16 @@ impl<A: Ability + 'static> Content<A, AbilityBook<A>> {
} }
Ok(()) Ok(())
})
} }
fn show_book_tooltip( fn show_book_tooltip(
engine: &Arc<Engine>, world: &mut World,
hero: Entity, hero: Entity,
book_index: usize, book_index: usize,
reference: &Weak<CharacterWindow>, reference: &Weak<CharacterWindow>,
(x, y, w, _h): (i32, i32, u32, u32), (x, y, w, _h): (i32, i32, u32, u32),
) -> Result<()> { ) -> Result<()> {
engine.on_scene(|scene| { let entity = unsafe { remove_life_time(world.entity(hero)?) };
let entity = scene.entity(hero)?;
let inventory = entity.get_component::<Inventory<A>>()?; let inventory = entity.get_component::<Inventory<A>>()?;
let statistics = entity.get_component::<Statistics>()?; let statistics = entity.get_component::<Statistics>()?;
@ -188,9 +178,8 @@ impl<A: Ability + 'static> Content<A, AbilityBook<A>> {
let target_y = y; let target_y = y;
let book = inventory.book_at(book_index); let book = inventory.book_at(book_index);
let gui = let gui = book.create_tooltip(world, statistics, (target_x, target_y))?;
book.create_tooltip(engine.gui_handler(), statistics, (target_x, target_y))?; gui.enable(world)?;
gui.enable()?;
let window = reference.upgrade().unwrap(); let window = reference.upgrade().unwrap();
let abilities = entity.get_component::<AbilitySlots<A>>()?; let abilities = entity.get_component::<AbilitySlots<A>>()?;
@ -202,43 +191,43 @@ impl<A: Ability + 'static> Content<A, AbilityBook<A>> {
let target_x = button_pos.0 + button_pos.2 as i32 + 2; let target_x = button_pos.0 + button_pos.2 as i32 + 2;
let target_y = button_pos.1; let target_y = button_pos.1;
let compare_gui = selected_book.create_tooltip( let compare_gui =
engine.gui_handler(), selected_book.create_tooltip(world, statistics, (target_x, target_y))?;
statistics, compare_gui.enable(world)?;
(target_x, target_y), gui.perform_double_check(
&compare_gui,
world.resources.get_mut::<GuiHandler>(),
x,
2,
)?; )?;
compare_gui.enable()?;
gui.perform_double_check(&compare_gui, x, 2)?;
window.add_tooltip("active_book", compare_gui); window.add_tooltip("active_book", compare_gui);
} }
None => { None => {
gui.perform_single_check(x, y)?; gui.perform_single_check(world.resources.get_mut::<GuiHandler>(), x, y)?;
} }
} }
window.add_tooltip(format!("book_{book_index}"), gui); window.add_tooltip(format!("book_{book_index}"), gui);
Ok(()) Ok(())
})
} }
} }
impl<A: Ability + 'static> ContentUpdate for Content<A, AbilityBook<A>> { impl<A: Ability + 'static> ContentUpdate for Content<A, AbilityBook<A>> {
fn update(&mut self, engine: &Arc<Engine>, hero: Entity) -> Result<()> { fn update(&mut self, world: &mut World, hero: Entity) -> Result<()> {
let reference = self.reference.clone(); let reference = self.reference.clone();
self.update_base(engine, |button, t, index| { self.update_base(world, |world, button, t, index| {
button.set_icon(&t.icon())?; button.set_icon(world.resources.get_mut::<GuiHandler>(), &t.icon())?;
button.set_custom_callback({ button.set_custom_callback({
let engine = engine.clone();
let reference = reference.clone(); let reference = reference.clone();
move |controller_button| { move |world, controller_button| {
if let ControllerButton::X = controller_button { if let ControllerButton::X = controller_button {
CharacterWindow::salvage_from_inventory::<A, _, _>( CharacterWindow::salvage_from_inventory::<A, _, _>(
&engine, world,
hero, hero,
|inventory| inventory.remove_book(index), |inventory| inventory.remove_book(index),
)?; )?;
@ -247,7 +236,7 @@ impl<A: Ability + 'static> ContentUpdate for Content<A, AbilityBook<A>> {
let mut tabs = menu.tabs_mut(); let mut tabs = menu.tabs_mut();
let abilities = tabs.abilities::<A>(); let abilities = tabs.abilities::<A>();
abilities.update_page()?; abilities.update_page(world)?;
} }
return Ok(true); return Ok(true);
@ -258,17 +247,16 @@ impl<A: Ability + 'static> ContentUpdate for Content<A, AbilityBook<A>> {
}); });
button.set_callback({ button.set_callback({
let engine = engine.clone();
let reference = reference.clone(); let reference = reference.clone();
move || { move |world| {
if let Some(menu) = reference.upgrade() { if let Some(menu) = reference.upgrade() {
let mut tabs = menu.tabs_mut(); let mut tabs = menu.tabs_mut();
let abilities = tabs.abilities(); let abilities = tabs.abilities();
Self::equip_book(&engine, hero, index, abilities)?; Self::equip_book(world, hero, index, abilities)?;
abilities.update_page()?; abilities.update_page(world)?;
} }
Ok(()) Ok(())
@ -277,14 +265,13 @@ impl<A: Ability + 'static> ContentUpdate for Content<A, AbilityBook<A>> {
button.set_select_callback({ button.set_select_callback({
let weak_button = Arc::downgrade(&button); let weak_button = Arc::downgrade(&button);
let engine = engine.clone();
let reference = reference.clone(); let reference = reference.clone();
move |selected| { move |world, selected| {
if selected { if selected {
let button_pos = weak_button.upgrade().unwrap().position_extent(); let button_pos = weak_button.upgrade().unwrap().position_extent();
Self::show_book_tooltip(&engine, hero, index, &reference, button_pos)?; Self::show_book_tooltip(world, hero, index, &reference, button_pos)?;
} else { } else {
let window = reference.upgrade().unwrap(); let window = reference.upgrade().unwrap();
@ -300,7 +287,7 @@ impl<A: Ability + 'static> ContentUpdate for Content<A, AbilityBook<A>> {
}) })
} }
fn select(&self) -> Result<()> { fn select(&self, world: &mut World) -> Result<()> {
self.select() self.select(world.resources.get_mut::<GuiHandler>())
} }
} }

131
character_window/src/abilities/mod.rs
View file

@ -19,7 +19,6 @@ use crate::*;
pub struct AbilityPage<A: Ability + 'static> { pub struct AbilityPage<A: Ability + 'static> {
close: Weak<Button>, close: Weak<Button>,
engine: Arc<Engine>,
hero: Entity, hero: Entity,
grid: Arc<Grid>, grid: Arc<Grid>,
@ -41,14 +40,15 @@ impl<A: Ability + 'static> AbilityPage<A> {
reference: Weak<CharacterWindow>, reference: Weak<CharacterWindow>,
close: &Arc<Button>, close: &Arc<Button>,
) -> Result<Self> { ) -> Result<Self> {
let gui_handler = world.resources.get_mut::<GuiHandler>(); let gui_handler = world.resources.get_mut_unchecked::<GuiHandler>();
let grid = Grid::new(gui_handler, 2, 1, false)?; let grid = Grid::new(gui_handler, 2, 1, false)?;
let left_base = GuiSnippet::from_str( let left_base = GuiSnippet::from_str(
gui_handler, world,
include_str!("../../resources/abilities/left_side.xml"), include_str!("../../resources/abilities/left_side.xml"),
)?; )?;
grid.attach(gui_handler, left_base.clone(), 0, 0, 1, 1)?;
grid.attach(world, left_base.clone(), 0, 0, 1, 1)?;
Self::setup_content_switch(&left_base, reference.clone())?; Self::setup_content_switch(&left_base, reference.clone())?;
@ -57,42 +57,52 @@ impl<A: Ability + 'static> AbilityPage<A> {
// abilities // abilities
let ability_mode = PageContent::new( let ability_mode = PageContent::new(
Content::new::<_, Self>(&engine, reference.clone(), { Content::new::<_, Self>(world, reference.clone(), {
let engine = engine.clone();
let hero = hero.clone(); let hero = hero.clone();
move || { move |world| {
let mut data = Vec::new(); let hero_object = world.entity(hero)?;
engine.on_scene(|scene| {
let hero_object = scene.entity(hero)?;
let inventory = hero_object.get_component::<Inventory<A>>()?; let inventory = hero_object.get_component::<Inventory<A>>()?;
data = inventory.iter_books().cloned().collect(); let data = inventory.iter_books().cloned().collect();
Ok(())
})?;
Ok(data) Ok(data)
} }
})?, })?,
{ {
let ui = GuiSnippet::from_str( let ui = GuiSnippet::from_str(
engine.gui_handler(), world,
include_str!("../../resources/abilities/ability_tooltip.xml"), include_str!("../../resources/abilities/ability_tooltip.xml"),
)?; )?;
let mut resources = world.resources.multi_mut();
let gui_handler = resources.get::<GuiHandler>();
let engine_settings = resources.get::<EngineSettings>();
let context = resources.get::<Context>();
let equip: Arc<Label> = ui.element("equip")?; let equip: Arc<Label> = ui.element("equip")?;
equip.set_info_icon(&engine.controller_icon(ControllerButton::A)?)?; equip.set_info_icon(
gui_handler,
&engine_settings.controller_icon(context, ControllerButton::A)?,
)?;
let upgrade: Arc<Label> = ui.element("upgrade")?; let upgrade: Arc<Label> = ui.element("upgrade")?;
upgrade.set_info_icon(&engine.controller_icon(ControllerButton::Y)?)?; upgrade.set_info_icon(
gui_handler,
&engine_settings.controller_icon(context, ControllerButton::Y)?,
)?;
let salvage: Arc<Label> = ui.element("salvage")?; let salvage: Arc<Label> = ui.element("salvage")?;
salvage.set_info_icon(&engine.controller_icon(ControllerButton::X)?)?; salvage.set_info_icon(
gui_handler,
&engine_settings.controller_icon(context, ControllerButton::X)?,
)?;
let switch_mode: Arc<Label> = ui.element("switch_mode")?; let switch_mode: Arc<Label> = ui.element("switch_mode")?;
switch_mode.set_info_icon(&engine.controller_icon(ControllerButton::LeftStick)?)?; switch_mode.set_info_icon(
gui_handler,
&engine_settings.controller_icon(context, ControllerButton::LeftStick)?,
)?;
ui ui
}, },
@ -101,51 +111,57 @@ impl<A: Ability + 'static> AbilityPage<A> {
// addons // addons
let addons_mode = PageContent::<A, _>::new( let addons_mode = PageContent::<A, _>::new(
Content::new::<_, Self>(&engine, reference.clone(), { Content::new::<_, Self>(world, reference.clone(), {
let engine = engine.clone();
let hero = hero.clone(); let hero = hero.clone();
move || { move |world| {
let mut data = Vec::new(); let hero_object = world.entity(hero)?;
engine.on_scene(|scene| {
let hero_object = scene.entity(hero)?;
let inventory = hero_object.get_component::<Inventory<A>>()?; let inventory = hero_object.get_component::<Inventory<A>>()?;
data = inventory.iter_addons().cloned().collect(); let data = inventory.iter_addons().cloned().collect();
Ok(())
})?;
Ok(data) Ok(data)
} }
})?, })?,
{ {
let ui = GuiSnippet::from_str( let ui = GuiSnippet::from_str(
engine.gui_handler(), world,
include_str!("../../resources/abilities/addon_tooltip.xml"), include_str!("../../resources/abilities/addon_tooltip.xml"),
)?; )?;
let mut resources = world.resources.multi_mut();
let gui_handler = resources.get::<GuiHandler>();
let engine_settings = resources.get::<EngineSettings>();
let context = resources.get::<Context>();
let equip: Arc<Label> = ui.element("socket")?; let equip: Arc<Label> = ui.element("socket")?;
equip.set_info_icon(&engine.controller_icon(ControllerButton::A)?)?; equip.set_info_icon(
gui_handler,
&engine_settings.controller_icon(context, ControllerButton::A)?,
)?;
let salvage: Arc<Label> = ui.element("salvage")?; let salvage: Arc<Label> = ui.element("salvage")?;
salvage.set_info_icon(&engine.controller_icon(ControllerButton::X)?)?; salvage.set_info_icon(
gui_handler,
&engine_settings.controller_icon(context, ControllerButton::X)?,
)?;
let switch_mode: Arc<Label> = ui.element("switch_mode")?; let switch_mode: Arc<Label> = ui.element("switch_mode")?;
switch_mode.set_info_icon(&engine.controller_icon(ControllerButton::LeftStick)?)?; switch_mode.set_info_icon(
gui_handler,
&engine_settings.controller_icon(context, ControllerButton::LeftStick)?,
)?;
ui ui
}, },
EmptyRightSide, EmptyRightSide,
); );
let right_side = AbilityPageRightSide::new(&engine, &reference, hero)?; let right_side = AbilityPageRightSide::new(world, hero, &reference)?;
Ok(Self { Ok(Self {
close: Arc::downgrade(close), close: Arc::downgrade(close),
engine: engine.clone(),
hero, hero,
grid, grid,
@ -161,7 +177,7 @@ impl<A: Ability + 'static> AbilityPage<A> {
}) })
} }
fn update_page(&mut self) -> Result<()> { fn update_page(&mut self, world: &mut World) -> Result<()> {
match self.current_mode { match self.current_mode {
0 => println!("update ability view"), 0 => println!("update ability view"),
1 => println!("update addon view"), 1 => println!("update addon view"),
@ -170,15 +186,16 @@ impl<A: Ability + 'static> AbilityPage<A> {
} }
let mode = &mut self.modes[self.current_mode]; let mode = &mut self.modes[self.current_mode];
mode.content_mut().update(&self.engine, self.hero)?; mode.content_mut().update(world, self.hero)?;
self.tooltip.attach(mode.tooltip().clone(), 0, 0, 1, 1)?; self.tooltip
.attach(world, mode.tooltip().clone(), 0, 0, 1, 1)?;
self.content self.content
.attach(mode.content_mut().base().clone(), 0, 0, 1, 1)?; .attach(world, mode.content_mut().base().clone(), 0, 0, 1, 1)?;
self.right_side.refresh(&self.engine, self.hero)?; self.right_side.refresh(world, self.hero)?;
self.grid self.grid
.attach(self.right_side.base().clone(), 1, 0, 1, 1)?; .attach(world, self.right_side.base().clone(), 1, 0, 1, 1)?;
Ok(()) Ok(())
} }
@ -190,14 +207,14 @@ impl<A: Ability + 'static> AbilityPage<A> {
let switch = { let switch = {
let reference = reference.clone(); let reference = reference.clone();
move |index| { move |world: &mut World, index| {
if let Some(menu) = reference.upgrade() { if let Some(menu) = reference.upgrade() {
let mut tabs = menu.tabs_mut(); let mut tabs = menu.tabs_mut();
let me = tabs.abilities::<A>(); let me = tabs.abilities::<A>();
if me.current_mode != index { if me.current_mode != index {
me.current_mode = index; me.current_mode = index;
me.update_page()?; me.update_page(world)?;
} }
} }
@ -208,13 +225,13 @@ impl<A: Ability + 'static> AbilityPage<A> {
let switch_to_abilities = Box::new({ let switch_to_abilities = Box::new({
let switch = switch.clone(); let switch = switch.clone();
move || switch(0) move |world: &mut World| switch(world, 0)
}); });
let switch_to_addons = Box::new({ let switch_to_addons = Box::new({
let switch = switch.clone(); let switch = switch.clone();
move || switch(1) move |world: &mut World| switch(world, 1)
}); });
left_base.set_click_callbacks(vec![ left_base.set_click_callbacks(vec![
@ -229,26 +246,26 @@ impl<A: Ability + 'static> Page for AbilityPage<A> {
println!("enable AbilityPage"); println!("enable AbilityPage");
for mode in self.modes.iter_mut() { for mode in self.modes.iter_mut() {
mode.content_mut().refresh()?; mode.content_mut().refresh(world)?;
} }
self.update_page()?; self.update_page(world)?;
Ok(self.grid.clone()) Ok(self.grid.clone())
} }
fn disable(&mut self, world: &mut World) -> Result<()> { fn disable(&mut self, _world: &mut World) -> Result<()> {
Ok(()) Ok(())
} }
fn select(&self, world: &mut World) -> Result<()> { fn select(&self, world: &mut World) -> Result<()> {
let mode = &self.modes[self.current_mode]; let mode = &self.modes[self.current_mode];
mode.content().select()?; mode.content().select(world)?;
if mode.content().is_empty() { if mode.content().is_empty() {
if let Some(close) = self.close.upgrade() { if let Some(close) = self.close.upgrade() {
close.select()?; close.select(world.resources.get_mut::<GuiHandler>())?;
} }
} }
@ -258,26 +275,26 @@ impl<A: Ability + 'static> Page for AbilityPage<A> {
fn next_tab(&mut self, world: &mut World) -> Result<()> { fn next_tab(&mut self, world: &mut World) -> Result<()> {
self.modes[self.current_mode] self.modes[self.current_mode]
.content_mut() .content_mut()
.next_tab(&self.engine, self.hero) .next_tab(world, self.hero)
} }
fn previous_tab(&mut self, world: &mut World) -> Result<()> { fn previous_tab(&mut self, world: &mut World) -> Result<()> {
self.modes[self.current_mode] self.modes[self.current_mode]
.content_mut() .content_mut()
.previous_tab(&self.engine, self.hero) .previous_tab(world, self.hero)
} }
fn event(&mut self, world: &mut World, button: ControllerButton) -> Result<bool> { fn event(&mut self, world: &mut World, button: ControllerButton) -> Result<bool> {
Ok(match button { Ok(match button {
ControllerButton::LeftStick => { ControllerButton::LeftStick => {
self.current_mode = (self.current_mode + 1) % self.modes.len(); self.current_mode = (self.current_mode + 1) % self.modes.len();
self.update_page()?; self.update_page(world)?;
self.select()?; self.select(world)?;
true true
} }
ControllerButton::RightStick => { ControllerButton::RightStick => {
self.right_side.next_ability(&self.engine, self.hero)?; self.right_side.next_ability(world, self.hero)?;
true true
} }

55
character_window/src/character/mod.rs
View file

@ -28,23 +28,23 @@ impl CharacterPage {
hero_name: &str, hero_name: &str,
reference: &Weak<CharacterWindow>, reference: &Weak<CharacterWindow>,
) -> Result<Self> { ) -> Result<Self> {
let gui_handler = world.resources.get_mut::<GuiHandler>();
let snippet = GuiSnippet::from_str( let snippet = GuiSnippet::from_str(
gui_handler, world,
include_str!("../../resources/character/statistics.xml"), include_str!("../../resources/character/statistics.xml"),
)?; )?;
let grid: Arc<Grid> = snippet.element("statistic_tab")?; let grid: Arc<Grid> = snippet.element("statistic_tab")?;
let name: Arc<Label> = snippet.element("character_name")?; let name: Arc<Label> = snippet.element("character_name")?;
let gui_handler = world.resources.get_mut::<GuiHandler>();
name.set_text(gui_handler, hero_name)?; name.set_text(gui_handler, hero_name)?;
let strength: Arc<Button> = snippet.element("strength_field")?; let strength: Arc<Button> = snippet.element("strength_field")?;
strength.set_callback({ strength.set_callback({
let update_stats = Self::create_update_stats(hero, engine, reference); let update_stats = Self::create_update_stats(hero, reference.clone());
move |_world| { move |world| {
update_stats(|attributes| { update_stats(world, |attributes: &mut Attributes| {
attributes.add_strength(Strength::from(1)); attributes.add_strength(Strength::from(1));
}) })
} }
@ -52,10 +52,10 @@ impl CharacterPage {
let agility: Arc<Button> = snippet.element("agility_field")?; let agility: Arc<Button> = snippet.element("agility_field")?;
agility.set_callback({ agility.set_callback({
let update_stats = Self::create_update_stats(hero, engine, reference); let update_stats = Self::create_update_stats(hero, reference.clone());
move |_world| { move |world| {
update_stats(|attributes| { update_stats(world, |attributes: &mut Attributes| {
attributes.add_agility(Agility::from(1)); attributes.add_agility(Agility::from(1));
}) })
} }
@ -63,10 +63,10 @@ impl CharacterPage {
let intelligence: Arc<Button> = snippet.element("intelligence_field")?; let intelligence: Arc<Button> = snippet.element("intelligence_field")?;
intelligence.set_callback({ intelligence.set_callback({
let update_stats = Self::create_update_stats(hero, engine, reference); let update_stats = Self::create_update_stats(hero, reference.clone());
move |_world| { move |world| {
update_stats(|attributes| { update_stats(world, |attributes: &mut Attributes| {
attributes.add_intelligence(Intelligence::from(1)); attributes.add_intelligence(Intelligence::from(1));
}) })
} }
@ -106,10 +106,10 @@ impl CharacterPage {
let mana: Arc<Label> = self.snippet.element("mana_info")?; let mana: Arc<Label> = self.snippet.element("mana_info")?;
let mana_regen: Arc<Label> = self.snippet.element("mana_regen_info")?; let mana_regen: Arc<Label> = self.snippet.element("mana_regen_info")?;
let entity = world.entity(self.hero)?; let (entity, resources) = world.entity_resources(self.hero)?;
let statistics = entity.get_component::<Statistics>()?; let statistics = entity.get_component::<Statistics>()?;
let gui_handler = world.resources.get_mut::<GuiHandler>(); let gui_handler = resources.get_mut::<GuiHandler>();
air_def.set_text(gui_handler, &format!("{}", statistics.air_resistance.raw()))?; air_def.set_text(gui_handler, &format!("{}", statistics.air_resistance.raw()))?;
fire_def.set_text( fire_def.set_text(
@ -153,7 +153,7 @@ impl CharacterPage {
Ok(()) Ok(())
} }
fn update_attributes(&self, world: &World) -> Result<()> { fn update_attributes(&self, world: &mut World) -> Result<()> {
let level_label: Arc<Label> = self.snippet.element("level")?; let level_label: Arc<Label> = self.snippet.element("level")?;
let level_progress: Arc<ProgressBar> = self.snippet.element("level_progress")?; let level_progress: Arc<ProgressBar> = self.snippet.element("level_progress")?;
@ -162,12 +162,13 @@ impl CharacterPage {
let agility: Arc<Button> = self.snippet.element("agility_field")?; let agility: Arc<Button> = self.snippet.element("agility_field")?;
let intelligence: Arc<Button> = self.snippet.element("intelligence_field")?; let intelligence: Arc<Button> = self.snippet.element("intelligence_field")?;
let entity = world.entity(self.hero)?; let (entity, resources) = world.entity_resources(self.hero)?;
let mut resources = resources.multi_mut();
let level = entity.get_component::<Level>()?; let level = entity.get_component::<Level>()?;
let attributes = entity.get_component::<Attributes>()?; let attributes = entity.get_component::<Attributes>()?;
let gui_handler = world.resources.get_mut::<GuiHandler>(); let gui_handler = resources.get::<GuiHandler>();
level_label.set_text(gui_handler, format!("Level: {}", level.level()))?; level_label.set_text(gui_handler, format!("Level: {}", level.level()))?;
level_progress.set_text( level_progress.set_text(
@ -180,7 +181,7 @@ impl CharacterPage {
format!( format!(
"Attributes ({})", "Attributes ({})",
Self::available_attribute_points( Self::available_attribute_points(
world.resources.get::<AttributeSettings>(), resources.get::<AttributeSettings>(),
attributes, attributes,
level level
) )
@ -210,17 +211,15 @@ impl CharacterPage {
fn create_update_stats<F>( fn create_update_stats<F>(
hero: Entity, hero: Entity,
reference: &Weak<CharacterWindow>, reference: Weak<CharacterWindow>,
) -> impl Fn(&mut World, F) -> Result<()> + Clone ) -> impl Fn(&mut World, F) -> Result<()> + Clone
where where
F: Fn(&mut Attributes), F: Fn(&mut Attributes),
{ {
let reference = reference.clone();
move |world, upgrade: F| { move |world, upgrade: F| {
let mut upgraded = false; let mut upgraded = false;
let (resources, entity) = world.entity_resource(hero)?; let (entity, resources) = world.entity_resources(hero)?;
let mut multi_mut = entity.multi_mut(); let mut multi_mut = entity.multi_mut();
let attribute_settings = resources.get::<AttributeSettings>(); let attribute_settings = resources.get::<AttributeSettings>();
@ -255,31 +254,31 @@ impl Page for CharacterPage {
fn enable(&mut self, world: &mut World) -> Result<Arc<Grid>> { fn enable(&mut self, world: &mut World) -> Result<Arc<Grid>> {
println!("enable CharacterPage"); println!("enable CharacterPage");
self.refresh()?; self.refresh(world)?;
Ok(self.grid.clone()) Ok(self.grid.clone())
} }
fn disable(&mut self, world: &mut World) -> Result<()> { fn disable(&mut self, _world: &mut World) -> Result<()> {
Ok(()) Ok(())
} }
fn select(&self, world: &mut World) -> Result<()> { fn select(&self, world: &mut World) -> Result<()> {
let strength: Arc<Button> = self.snippet.element("strength_field")?; let strength: Arc<Button> = self.snippet.element("strength_field")?;
strength.select()?; strength.select(world.resources.get_mut::<GuiHandler>())?;
Ok(()) Ok(())
} }
fn next_tab(&mut self, world: &mut World) -> Result<()> { fn next_tab(&mut self, _world: &mut World) -> Result<()> {
Ok(()) Ok(())
} }
fn previous_tab(&mut self, world: &mut World) -> Result<()> { fn previous_tab(&mut self, _world: &mut World) -> Result<()> {
Ok(()) Ok(())
} }
fn event(&mut self, world: &mut World, _button: ControllerButton) -> Result<bool> { fn event(&mut self, _world: &mut World, _button: ControllerButton) -> Result<bool> {
Ok(false) Ok(false)
} }
} }

9
character_window/src/inventory/content.rs
View file

@ -242,18 +242,15 @@ impl<A: Ability + 'static> Content<A, Jewel> {
reference: &Weak<CharacterWindow>, reference: &Weak<CharacterWindow>,
(x, y, w, _h): (i32, i32, u32, u32), (x, y, w, _h): (i32, i32, u32, u32),
) -> Result<()> { ) -> Result<()> {
let entity = world.entity(hero)?; let entity = unsafe { remove_life_time(world.entity(hero)?) };
let inventory = entity.get_component::<Inventory<A>>()?; let inventory = entity.get_component::<Inventory<A>>()?;
let target_x = x + w as i32; let target_x = x + w as i32;
let target_y = y; let target_y = y;
let item_settings = world.resources.get_unchecked::<ItemSettings>();
let jewel = inventory.jewel_at(item_index); let jewel = inventory.jewel_at(item_index);
let gui = jewel.create_tooltip( let gui = jewel.create_tooltip(world, item_settings, (target_x, target_y))?;
world,
world.resources.get::<ItemSettings>(),
(target_x, target_y),
)?;
gui.enable(world)?; gui.enable(world)?;
gui.perform_single_check(world.resources.get_mut::<GuiHandler>(), x, y)?; gui.perform_single_check(world.resources.get_mut::<GuiHandler>(), x, y)?;

29
character_window/src/inventory/jewel_right_side.rs
View file

@ -93,20 +93,21 @@ impl JewelRightSide {
let (x, y, w, _h) = button.position_extent(); let (x, y, w, _h) = button.position_extent();
let reference_info = world.resources.get::<Option<ReferenceObject>>(); let reference_info = world.resources.get_unchecked::<Option<ReferenceObject>>();
if let Some(reference_info) = reference_info { if let Some(reference_info) = reference_info {
let tooltip = match reference_info { let tooltip = match reference_info {
ReferenceObject::Item { item, .. } => item.create_tooltip( ReferenceObject::Item { item, .. } => {
world, let attributes = unsafe { remove_life_time(world.entity(hero)?) }
world.entity(hero)?.get_component::<Attributes>()?, .get_component::<Attributes>()?;
(x + w as i32, y),
)?, item.create_tooltip(world, attributes, (x + w as i32, y))?
ReferenceObject::Jewel { jewel, .. } => jewel.create_tooltip( }
world, ReferenceObject::Jewel { jewel, .. } => {
world.resources.get::<ItemSettings>(), let item_settings = world.resources.get_unchecked::<ItemSettings>();
(x + w as i32, y),
)?, jewel.create_tooltip(world, item_settings, (x + w as i32, y))?
}
}; };
tooltip.enable(world)?; tooltip.enable(world)?;
@ -141,12 +142,14 @@ impl JewelRightSide {
let (x, y, w, _h) = button.position_extent(); let (x, y, w, _h) = button.position_extent();
let lower_info = world.resources.get::<LowerJewels>(); let lower_info = world.resources.get_unchecked::<LowerJewels>();
if let Some((lower_jewel, _)) = &lower_info.jewels[index] { if let Some((lower_jewel, _)) = &lower_info.jewels[index] {
let item_settings = world.resources.get_unchecked::<ItemSettings>();
let tooltip = lower_jewel.create_tooltip( let tooltip = lower_jewel.create_tooltip(
world, world,
world.resources.get::<ItemSettings>(), item_settings,
(x + w as i32, y), (x + w as i32, y),
)?; )?;

16
character_window/src/lib.rs
View file

@ -165,8 +165,8 @@ impl CharacterWindow {
if let Some(me) = weak_me.upgrade() { if let Some(me) = weak_me.upgrade() {
me.tab.store(index, SeqCst); me.tab.store(index, SeqCst);
me.tab_content_grid let child = me.tab_mut().enable(world)?;
.attach(world, me.tab_mut().enable(world)?, 0, 0, 1, 1)?; me.tab_content_grid.attach(world, child, 0, 0, 1, 1)?;
me.tab().select(world)?; me.tab().select(world)?;
} }
@ -279,8 +279,8 @@ impl TopLevelGui for CharacterWindow {
fn enable(&self, world: &mut World) -> Result<()> { fn enable(&self, world: &mut World) -> Result<()> {
self.menu_gui.enable(world)?; self.menu_gui.enable(world)?;
self.tab_content_grid let child = self.tab_mut().enable(world)?;
.attach(world, self.tab_mut().enable(world)?, 0, 0, 1, 1)?; self.tab_content_grid.attach(world, child, 0, 0, 1, 1)?;
self.tab().select(world)?; self.tab().select(world)?;
let mut resources = world.resources.multi_mut(); let mut resources = world.resources.multi_mut();
@ -345,8 +345,8 @@ impl TopGui for CharacterWindow {
self.tab.store((self.tab.load(SeqCst) + 1) % 3, SeqCst); self.tab.store((self.tab.load(SeqCst) + 1) % 3, SeqCst);
// update tab content // update tab content
self.tab_content_grid let child = self.tab_mut().enable(world)?;
.attach(world, self.tab_mut().enable(world)?, 0, 0, 1, 1)?; self.tab_content_grid.attach(world, child, 0, 0, 1, 1)?;
self.tab().select(world)?; self.tab().select(world)?;
} }
true => { true => {
@ -371,8 +371,8 @@ impl TopGui for CharacterWindow {
} }
// update tab content // update tab content
self.tab_content_grid let child = self.tab_mut().enable(world)?;
.attach(world, self.tab_mut().enable(world)?, 0, 0, 1, 1)?; self.tab_content_grid.attach(world, child, 0, 0, 1, 1)?;
self.tab().select(world)?; self.tab().select(world)?;
} }
true => { true => {