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",
];
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(
world.resources.get::<Arc<GuiHandler>>(),
world,
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)?;
Self::rarity_icon_background(&snippet, "uncommon", color_settings.uncommon)?;
Self::rarity_icon_background(&snippet, "magical", color_settings.magical)?;
Self::rarity_icon_background(&snippet, "rare", color_settings.rare)?;
Self::rarity_icon_background(&snippet, "epic", color_settings.epic)?;
Self::rarity_icon_background(&snippet, "legendary", color_settings.legendary)?;
let color_settings = resources
.get::<ItemSettings>()
.rarity_color_settings
.clone();
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() {
let button: Arc<Button> = snippet.element(name)?;
button.set_info_icon(&world.resources.get::<EngineSettings>().controller_icon(
world.resources.get::<Context>(),
ControllerButton::RightStick,
)?)?;
button.set_info_icon(
gui_handler,
&engine_settings.controller_icon(context, ControllerButton::RightStick)?,
)?;
button.set_callback({
|| {
let reference = reference.clone();
move |world: &mut World| {
if let Some(menu) = reference.upgrade() {
let mut tabs = menu.tabs_mut();
let abilities = tabs.abilities::<A>();
abilities.right_side.ability_index = index;
abilities.update_page()?;
abilities.update_page(world)?;
}
Ok(())
@ -66,15 +76,13 @@ impl<A: Ability + 'static> AbilityPageRightSide<A> {
});
button.set_select_callback({
let engine = engine.clone();
let reference = reference.clone();
let weak_button = Arc::downgrade(&button);
move |selected| {
move |world, selected| {
if let Some(menu) = reference.upgrade() {
if selected {
engine.on_scene(|scene| {
let entity = scene.entity(hero)?;
let entity = unsafe { remove_life_time(world.entity(hero)?) };
let abilities = entity.get_component::<AbilitySlots<A>>()?;
if let Some(book) = abilities.book(index) {
@ -86,19 +94,17 @@ impl<A: Ability + 'static> AbilityPageRightSide<A> {
let statistics = entity.get_component::<Statistics>()?;
let gui = book.create_tooltip(
engine.gui_handler(),
statistics,
(target_x, target_y),
let gui =
book.create_tooltip(world, statistics, (target_x, target_y))?;
gui.enable(world)?;
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);
}
Ok(())
})?;
} else {
menu.remove_tooltip("active_ability");
}
@ -109,13 +115,11 @@ impl<A: Ability + 'static> AbilityPageRightSide<A> {
});
button.set_custom_callback({
let engine = engine.clone();
let reference = reference.clone();
move |button| match button {
move |world, button| match button {
ControllerButton::Y => {
engine.on_scene_mut(|scene| {
let entity = scene.entity_mut(hero)?;
let entity = world.entity_mut(hero)?;
let mut multi_mut = entity.multi_mut();
let abilities = multi_mut.get::<AbilitySlots<A>>()?;
@ -129,13 +133,10 @@ impl<A: Ability + 'static> AbilityPageRightSide<A> {
menu.tabs_mut()
.abilities::<A>()
.right_side
.refresh(&engine, hero)?;
.refresh(world, hero)?;
}
}
Ok(())
})?;
Ok(true)
}
@ -155,43 +156,61 @@ impl<A: Ability + 'static> AbilityPageRightSide<A> {
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)?;
icon.set_background(FillTypeInfo::Element(
icon.set_background(
gui_handler,
FillTypeInfo::Element(
ElementDescriptor::new(color, Color::Black, 2),
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)?;
icon.set_text(value)?;
icon.set_text(gui_handler, value)?;
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)?;
match image {
Some(image) => {
button.set_icon(&image)?;
button.set_icon(gui_handler, &image)?;
}
None => {
button.clear_icon()?;
button.clear_icon(gui_handler)?;
}
}
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 (_, rows) = grid.dimensions();
for y in 0..rows {
grid.detach(0, y)?;
grid.detach(world, 0, y)?;
}
if let Some(ability) = abilities.book(self.ability_index) {
@ -199,7 +218,7 @@ impl<A: Ability + 'static> AbilityPageRightSide<A> {
match addon.as_ref() {
Some(addon) => {
let addon_type_snippet = GuiSnippet::from_str(
engine.gui_handler(),
world,
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_value: Arc<Label> = addon_type_snippet.element("addon_value")?;
addon_icon.set_icon(&addon.icon())?;
addon_type.set_text(&format!("{}", addon.addon_type()))?;
addon_value.set_text(&addon.addon_type().val_as_str())?;
let gui_handler = world.resources.get_mut::<GuiHandler>();
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 => {
let empty_addon = GuiSnippet::from_str(
engine.gui_handler(),
world,
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(())
}
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.refresh(engine, hero)
self.refresh(world, hero)
}
}
impl<A: Ability + 'static> RightSide for AbilityPageRightSide<A> {
fn refresh(&mut self, engine: &Engine, hero: Entity) -> Result<()> {
engine.on_scene(|scene| {
let entity = scene.entity(hero)?;
fn refresh(&mut self, world: &mut World, hero: Entity) -> Result<()> {
let entity = unsafe { remove_life_time(world.entity(hero)?) };
let crafting = entity.get_component::<CraftingMaterials>()?;
self.update_crafting_count("common", crafting.count(Rarities::Common))?;
self.update_crafting_count("uncommon", crafting.count(Rarities::Uncommon))?;
self.update_crafting_count("magical", crafting.count(Rarities::Magical))?;
self.update_crafting_count("rare", crafting.count(Rarities::Rare))?;
self.update_crafting_count("epic", crafting.count(Rarities::Epic))?;
self.update_crafting_count("legendary", crafting.count(Rarities::Legendary))?;
let gui_handler = world.resources.get_mut::<GuiHandler>();
self.update_crafting_count(gui_handler, "common", crafting.count(Rarities::Common))?;
self.update_crafting_count(gui_handler, "uncommon", crafting.count(Rarities::Uncommon))?;
self.update_crafting_count(gui_handler, "magical", crafting.count(Rarities::Magical))?;
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>>()?;
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(())
})
}
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::{
content::{Content, ContentUpdate},
CharacterWindow,
content::{Content, ContentUpdate},
};
use super::AbilityPage;
impl<A: Ability + 'static> Content<A, AbilityAddon> {
fn show_addon_tooltip(
engine: &Arc<Engine>,
world: &mut World,
hero: Entity,
addon_index: usize,
reference: &Weak<CharacterWindow>,
(x, y, w, _h): (i32, i32, u32, u32),
) -> Result<()> {
engine.on_scene(|scene| {
let entity = scene.entity(hero)?;
let entity = unsafe { remove_life_time(world.entity(hero)?) };
let inventory = entity.get_component::<Inventory<A>>()?;
let target_x = x + w as i32;
let target_y = y;
let addon = inventory.addon_at(addon_index);
let gui = addon.create_tooltip(engine.gui_handler(), (target_x, target_y))?;
gui.enable()?;
gui.perform_single_check(x, y)?;
let gui = addon.create_tooltip(world, (target_x, target_y))?;
gui.enable(world)?;
gui.perform_single_check(world.resources.get_mut::<GuiHandler>(), x, y)?;
let window = reference.upgrade().unwrap();
window.add_tooltip(format!("addon_{addon_index}"), gui);
Ok(())
})
}
fn insert_addon(
engine: &Arc<Engine>,
world: &mut World,
hero: Entity,
addon_index: usize,
ability_page: &AbilityPage<A>,
) -> Result<()> {
engine.on_scene_mut(|scene| {
let entity = scene.entity_mut(hero)?;
let entity = world.entity_mut(hero)?;
let mut multi_mut = entity.multi_mut();
let inventory = multi_mut.get::<Inventory<A>>()?;
@ -63,25 +60,23 @@ impl<A: Ability + 'static> Content<A, AbilityAddon> {
}
Ok(())
})
}
}
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();
self.update_base(engine, |button, t, index| {
button.set_icon(&t.icon())?;
self.update_base(world, |world, button, t, index| {
button.set_icon(world.resources.get_mut::<GuiHandler>(), &t.icon())?;
button.set_custom_callback({
let engine = engine.clone();
let reference = reference.clone();
move |controller_button| {
move |world, controller_button| {
if let ControllerButton::X = controller_button {
CharacterWindow::salvage_from_inventory::<A, _, _>(
&engine,
world,
hero,
|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 abilities = tabs.abilities::<A>();
abilities.update_page()?;
abilities.update_page(world)?;
}
return Ok(true);
@ -101,17 +96,16 @@ impl<A: Ability + 'static> ContentUpdate for Content<A, AbilityAddon> {
});
button.set_callback({
let engine = engine.clone();
let reference = reference.clone();
move || {
move |world| {
if let Some(menu) = reference.upgrade() {
let mut tabs = menu.tabs_mut();
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(())
@ -120,14 +114,13 @@ impl<A: Ability + 'static> ContentUpdate for Content<A, AbilityAddon> {
button.set_select_callback({
let weak_button = Arc::downgrade(&button);
let engine = engine.clone();
let reference = reference.clone();
move |selected| {
move |world, selected| {
if selected {
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 {
let window = reference.upgrade().unwrap();
@ -142,20 +135,19 @@ impl<A: Ability + 'static> ContentUpdate for Content<A, AbilityAddon> {
})
}
fn select(&self) -> Result<()> {
self.select()
fn select(&self, world: &mut World) -> Result<()> {
self.select(world.resources.get_mut::<GuiHandler>())
}
}
impl<A: Ability + 'static> Content<A, AbilityBook<A>> {
fn equip_book(
engine: &Arc<Engine>,
world: &mut World,
hero: Entity,
book_index: usize,
ability_page: &AbilityPage<A>,
) -> Result<()> {
engine.on_scene_mut(|scene| {
let entity = scene.entity_mut(hero)?;
let entity = world.entity_mut(hero)?;
let mut multi_mut = entity.multi_mut();
let inventory = multi_mut.get::<Inventory<A>>()?;
@ -169,18 +161,16 @@ impl<A: Ability + 'static> Content<A, AbilityBook<A>> {
}
Ok(())
})
}
fn show_book_tooltip(
engine: &Arc<Engine>,
world: &mut World,
hero: Entity,
book_index: usize,
reference: &Weak<CharacterWindow>,
(x, y, w, _h): (i32, i32, u32, u32),
) -> Result<()> {
engine.on_scene(|scene| {
let entity = scene.entity(hero)?;
let entity = unsafe { remove_life_time(world.entity(hero)?) };
let inventory = entity.get_component::<Inventory<A>>()?;
let statistics = entity.get_component::<Statistics>()?;
@ -188,9 +178,8 @@ impl<A: Ability + 'static> Content<A, AbilityBook<A>> {
let target_y = y;
let book = inventory.book_at(book_index);
let gui =
book.create_tooltip(engine.gui_handler(), statistics, (target_x, target_y))?;
gui.enable()?;
let gui = book.create_tooltip(world, statistics, (target_x, target_y))?;
gui.enable(world)?;
let window = reference.upgrade().unwrap();
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_y = button_pos.1;
let compare_gui = selected_book.create_tooltip(
engine.gui_handler(),
statistics,
(target_x, target_y),
let compare_gui =
selected_book.create_tooltip(world, statistics, (target_x, target_y))?;
compare_gui.enable(world)?;
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);
}
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);
Ok(())
})
}
}
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();
self.update_base(engine, |button, t, index| {
button.set_icon(&t.icon())?;
self.update_base(world, |world, button, t, index| {
button.set_icon(world.resources.get_mut::<GuiHandler>(), &t.icon())?;
button.set_custom_callback({
let engine = engine.clone();
let reference = reference.clone();
move |controller_button| {
move |world, controller_button| {
if let ControllerButton::X = controller_button {
CharacterWindow::salvage_from_inventory::<A, _, _>(
&engine,
world,
hero,
|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 abilities = tabs.abilities::<A>();
abilities.update_page()?;
abilities.update_page(world)?;
}
return Ok(true);
@ -258,17 +247,16 @@ impl<A: Ability + 'static> ContentUpdate for Content<A, AbilityBook<A>> {
});
button.set_callback({
let engine = engine.clone();
let reference = reference.clone();
move || {
move |world| {
if let Some(menu) = reference.upgrade() {
let mut tabs = menu.tabs_mut();
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(())
@ -277,14 +265,13 @@ impl<A: Ability + 'static> ContentUpdate for Content<A, AbilityBook<A>> {
button.set_select_callback({
let weak_button = Arc::downgrade(&button);
let engine = engine.clone();
let reference = reference.clone();
move |selected| {
move |world, selected| {
if selected {
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 {
let window = reference.upgrade().unwrap();
@ -300,7 +287,7 @@ impl<A: Ability + 'static> ContentUpdate for Content<A, AbilityBook<A>> {
})
}
fn select(&self) -> Result<()> {
self.select()
fn select(&self, world: &mut World) -> Result<()> {
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> {
close: Weak<Button>,
engine: Arc<Engine>,
hero: Entity,
grid: Arc<Grid>,
@ -41,14 +40,15 @@ impl<A: Ability + 'static> AbilityPage<A> {
reference: Weak<CharacterWindow>,
close: &Arc<Button>,
) -> 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 left_base = GuiSnippet::from_str(
gui_handler,
world,
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())?;
@ -57,42 +57,52 @@ impl<A: Ability + 'static> AbilityPage<A> {
// abilities
let ability_mode = PageContent::new(
Content::new::<_, Self>(&engine, reference.clone(), {
let engine = engine.clone();
Content::new::<_, Self>(world, reference.clone(), {
let hero = hero.clone();
move || {
let mut data = Vec::new();
engine.on_scene(|scene| {
let hero_object = scene.entity(hero)?;
move |world| {
let hero_object = world.entity(hero)?;
let inventory = hero_object.get_component::<Inventory<A>>()?;
data = inventory.iter_books().cloned().collect();
Ok(())
})?;
let data = inventory.iter_books().cloned().collect();
Ok(data)
}
})?,
{
let ui = GuiSnippet::from_str(
engine.gui_handler(),
world,
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")?;
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")?;
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")?;
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")?;
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
},
@ -101,51 +111,57 @@ impl<A: Ability + 'static> AbilityPage<A> {
// addons
let addons_mode = PageContent::<A, _>::new(
Content::new::<_, Self>(&engine, reference.clone(), {
let engine = engine.clone();
Content::new::<_, Self>(world, reference.clone(), {
let hero = hero.clone();
move || {
let mut data = Vec::new();
engine.on_scene(|scene| {
let hero_object = scene.entity(hero)?;
move |world| {
let hero_object = world.entity(hero)?;
let inventory = hero_object.get_component::<Inventory<A>>()?;
data = inventory.iter_addons().cloned().collect();
Ok(())
})?;
let data = inventory.iter_addons().cloned().collect();
Ok(data)
}
})?,
{
let ui = GuiSnippet::from_str(
engine.gui_handler(),
world,
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")?;
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")?;
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")?;
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
},
EmptyRightSide,
);
let right_side = AbilityPageRightSide::new(&engine, &reference, hero)?;
let right_side = AbilityPageRightSide::new(world, hero, &reference)?;
Ok(Self {
close: Arc::downgrade(close),
engine: engine.clone(),
hero,
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 {
0 => println!("update ability view"),
1 => println!("update addon view"),
@ -170,15 +186,16 @@ impl<A: Ability + 'static> AbilityPage<A> {
}
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
.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
.attach(self.right_side.base().clone(), 1, 0, 1, 1)?;
.attach(world, self.right_side.base().clone(), 1, 0, 1, 1)?;
Ok(())
}
@ -190,14 +207,14 @@ impl<A: Ability + 'static> AbilityPage<A> {
let switch = {
let reference = reference.clone();
move |index| {
move |world: &mut World, index| {
if let Some(menu) = reference.upgrade() {
let mut tabs = menu.tabs_mut();
let me = tabs.abilities::<A>();
if 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 = switch.clone();
move || switch(0)
move |world: &mut World| switch(world, 0)
});
let switch_to_addons = Box::new({
let switch = switch.clone();
move || switch(1)
move |world: &mut World| switch(world, 1)
});
left_base.set_click_callbacks(vec![
@ -229,26 +246,26 @@ impl<A: Ability + 'static> Page for AbilityPage<A> {
println!("enable AbilityPage");
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())
}
fn disable(&mut self, world: &mut World) -> Result<()> {
fn disable(&mut self, _world: &mut World) -> Result<()> {
Ok(())
}
fn select(&self, world: &mut World) -> Result<()> {
let mode = &self.modes[self.current_mode];
mode.content().select()?;
mode.content().select(world)?;
if mode.content().is_empty() {
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<()> {
self.modes[self.current_mode]
.content_mut()
.next_tab(&self.engine, self.hero)
.next_tab(world, self.hero)
}
fn previous_tab(&mut self, world: &mut World) -> Result<()> {
self.modes[self.current_mode]
.content_mut()
.previous_tab(&self.engine, self.hero)
.previous_tab(world, self.hero)
}
fn event(&mut self, world: &mut World, button: ControllerButton) -> Result<bool> {
Ok(match button {
ControllerButton::LeftStick => {
self.current_mode = (self.current_mode + 1) % self.modes.len();
self.update_page()?;
self.select()?;
self.update_page(world)?;
self.select(world)?;
true
}
ControllerButton::RightStick => {
self.right_side.next_ability(&self.engine, self.hero)?;
self.right_side.next_ability(world, self.hero)?;
true
}

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

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

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

@ -242,18 +242,15 @@ impl<A: Ability + 'static> Content<A, Jewel> {
reference: &Weak<CharacterWindow>,
(x, y, w, _h): (i32, i32, u32, u32),
) -> Result<()> {
let entity = world.entity(hero)?;
let entity = unsafe { remove_life_time(world.entity(hero)?) };
let inventory = entity.get_component::<Inventory<A>>()?;
let target_x = x + w as i32;
let target_y = y;
let item_settings = world.resources.get_unchecked::<ItemSettings>();
let jewel = inventory.jewel_at(item_index);
let gui = jewel.create_tooltip(
world,
world.resources.get::<ItemSettings>(),
(target_x, target_y),
)?;
let gui = jewel.create_tooltip(world, item_settings, (target_x, target_y))?;
gui.enable(world)?;
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 reference_info = world.resources.get::<Option<ReferenceObject>>();
let reference_info = world.resources.get_unchecked::<Option<ReferenceObject>>();
if let Some(reference_info) = reference_info {
let tooltip = match reference_info {
ReferenceObject::Item { item, .. } => item.create_tooltip(
world,
world.entity(hero)?.get_component::<Attributes>()?,
(x + w as i32, y),
)?,
ReferenceObject::Jewel { jewel, .. } => jewel.create_tooltip(
world,
world.resources.get::<ItemSettings>(),
(x + w as i32, y),
)?,
ReferenceObject::Item { item, .. } => {
let attributes = unsafe { remove_life_time(world.entity(hero)?) }
.get_component::<Attributes>()?;
item.create_tooltip(world, attributes, (x + w as i32, y))?
}
ReferenceObject::Jewel { jewel, .. } => {
let item_settings = world.resources.get_unchecked::<ItemSettings>();
jewel.create_tooltip(world, item_settings, (x + w as i32, y))?
}
};
tooltip.enable(world)?;
@ -141,12 +142,14 @@ impl JewelRightSide {
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] {
let item_settings = world.resources.get_unchecked::<ItemSettings>();
let tooltip = lower_jewel.create_tooltip(
world,
world.resources.get::<ItemSettings>(),
item_settings,
(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() {
me.tab.store(index, SeqCst);
me.tab_content_grid
.attach(world, me.tab_mut().enable(world)?, 0, 0, 1, 1)?;
let child = me.tab_mut().enable(world)?;
me.tab_content_grid.attach(world, child, 0, 0, 1, 1)?;
me.tab().select(world)?;
}
@ -279,8 +279,8 @@ impl TopLevelGui for CharacterWindow {
fn enable(&self, world: &mut World) -> Result<()> {
self.menu_gui.enable(world)?;
self.tab_content_grid
.attach(world, self.tab_mut().enable(world)?, 0, 0, 1, 1)?;
let child = self.tab_mut().enable(world)?;
self.tab_content_grid.attach(world, child, 0, 0, 1, 1)?;
self.tab().select(world)?;
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);
// update tab content
self.tab_content_grid
.attach(world, self.tab_mut().enable(world)?, 0, 0, 1, 1)?;
let child = self.tab_mut().enable(world)?;
self.tab_content_grid.attach(world, child, 0, 0, 1, 1)?;
self.tab().select(world)?;
}
true => {
@ -371,8 +371,8 @@ impl TopGui for CharacterWindow {
}
// update tab content
self.tab_content_grid
.attach(world, self.tab_mut().enable(world)?, 0, 0, 1, 1)?;
let child = self.tab_mut().enable(world)?;
self.tab_content_grid.attach(world, child, 0, 0, 1, 1)?;
self.tab().select(world)?;
}
true => {