use icons (#93)

* cleanup

* log cleanup

* log cleanup

* log cleanup

* log cleanup

* log cleanup

* use icons

* use icons

* use icons

* use icons

* use icons

* use icons

* use icons

* use icons

* use icons

* use icons

* use icons

* use icons

* use icons

* player select

* player select

* player select

* player select

Author: zeitlinger

.github/workflows/release.yml

@@ -1,4 +1,4 @@
-name: Server - Release
+name: Release
 
 on:
   release:

client/assets/angry-face-svgrepo-com.png

@@ -1,5 +1,7 @@
 use crate::client::Features;
-use macroquad::prelude::{load_texture, load_ttf_font, Color, Image, RectOffset, Texture2D};
+use crate::resource_ui::ResourceType;
+use macroquad::prelude::{load_texture, load_ttf_font, Color, Image, ImageFormat, RectOffset};
+use macroquad::texture::Texture2D;
 use macroquad::ui::{root_ui, Skin};
 use server::map::Terrain;
 use server::unit::UnitType;
@@ -9,18 +11,113 @@ pub struct Assets {
     pub terrain: HashMap<Terrain, Texture2D>,
     pub units: HashMap<UnitType, Texture2D>,
     pub skin: Skin,
+
+    // mood icons
+    pub angry: Texture2D,
+    pub neutral: Texture2D,
+    pub happy: Texture2D,
+
+    // action icons
+    pub movement: Texture2D,
+    pub log: Texture2D,
+    pub end_turn: Texture2D,
+    pub advances: Texture2D,
+    pub redo: Texture2D,
+    pub reset: Texture2D,
+    pub undo: Texture2D,
+
+    // UI
+    pub zoom_in: Texture2D,
+    pub zoom_out: Texture2D,
+    pub up: Texture2D,
+    pub down: Texture2D,
+    pub left: Texture2D,
+    pub right: Texture2D,
+    pub victory_points: Texture2D,
+    pub active_player: Texture2D,
+
+    // Admin
+    pub import: Texture2D,
+    pub export: Texture2D,
+
     // pub cities: HashMap<CityType, Texture2D>,
-    // pub resources: HashMap<Resource, Texture2D>,
+    pub resources: HashMap<ResourceType, Texture2D>,
 }
 
 impl Assets {
     pub async fn new(features: &Features) -> Self {
+        let happy = load_png(include_bytes!("../assets/happy-emoji-svgrepo-com.png"));
         Self {
             terrain: Self::terrain(features).await,
             units: HashMap::new(),
             skin: Self::skin(features).await,
+
+            // mood icons
+            angry: load_png(include_bytes!("../assets/angry-face-svgrepo-com.png")),
+            neutral: load_png(include_bytes!("../assets/neutral-face-svgrepo-com.png")),
+            happy: happy.clone(),
+
+            // resource icons
+            resources: [
+                (
+                    ResourceType::Food,
+                    load_png(include_bytes!("../assets/wheat-grain-svgrepo-com.png")),
+                ),
+                (
+                    ResourceType::Wood,
+                    load_png(include_bytes!("../assets/wood-nature-svgrepo-com.png")),
+                ),
+                (
+                    ResourceType::Ore,
+                    load_png(include_bytes!("../assets/rock-svgrepo-com.png")),
+                ),
+                (
+                    ResourceType::Ideas,
+                    load_png(include_bytes!("../assets/light-bulb-idea-svgrepo-com.png")),
+                ),
+                (
+                    ResourceType::Gold,
+                    load_png(include_bytes!("../assets/gold-ingots-gold-svgrepo-com.png")),
+                ),
+                (ResourceType::MoodTokens, happy.clone()),
+                (
+                    ResourceType::CultureTokens,
+                    load_png(include_bytes!("../assets/theater-drama-svgrepo-com.png")),
+                ),
+            ]
+            .iter()
+            .cloned()
+            .collect(),
+
+            // action icons
+            advances: load_png(include_bytes!("../assets/lab-svgrepo-com.png")),
+            end_turn: load_png(include_bytes!("../assets/hour-glass-svgrepo-com.png")),
+            log: load_png(include_bytes!("../assets/scroll-svgrepo-com.png")),
+            movement: load_png(include_bytes!("../assets/walk-svgrepo-com.png")),
+            redo: load_png(include_bytes!("../assets/redo-svgrepo-com.png")),
+            reset: load_png(include_bytes!("../assets/reset-svgrepo-com.png")),
+            undo: load_png(include_bytes!("../assets/undo-svgrepo-com.png")),
+
+            // UI
+            zoom_in: load_png(include_bytes!("../assets/zoom-in-1462-svgrepo-com.png")),
+            zoom_out: load_png(include_bytes!("../assets/zoom-out-1460-svgrepo-com.png")),
+            up: load_png(include_bytes!("../assets/up-arrow-circle-svgrepo-com.png")),
+            down: load_png(include_bytes!(
+                "../assets/down-arrow-circle-svgrepo-com.png"
+            )),
+            left: load_png(include_bytes!(
+                "../assets/left-arrow-circle-svgrepo-com.png"
+            )),
+            right: load_png(include_bytes!(
+                "../assets/right-arrow-circle-svgrepo-com.png"
+            )),
+            victory_points: load_png(include_bytes!("../assets/trophy-cup-svgrepo-com.png")),
+            active_player: load_png(include_bytes!("../assets/triangle-svgrepo-com.png")),
+
+            // Admin
+            import: load_png(include_bytes!("../assets/import-3-svgrepo-com.png")),
+            export: load_png(include_bytes!("../assets/export-2-svgrepo-com.png")),
             // cities: HashMap::new(),
-            // resources: HashMap::new(),
         }
     }
 
@@ -142,3 +239,7 @@ impl Assets {
         }
     }
 }
+
+fn load_png(bytes: &[u8]) -> Texture2D {
+    Texture2D::from_file_with_format(bytes, Some(ImageFormat::Png))
+}

client/assets/down-arrow-circle-svgrepo-com.png

@@ -16,7 +16,7 @@ use crate::happiness_ui::{increase_happiness_dialog, increase_happiness_menu};
 use crate::hex_ui::pixel_to_coordinate;
 use crate::log_ui::show_log;
 use crate::map_ui::{draw_map, show_tile_menu};
-use crate::player_ui::{show_global_controls, show_globals};
+use crate::player_ui::{player_select, show_global_controls, show_top_center, show_top_left};
 use crate::status_phase_ui::raze_city_confirm_dialog;
 use crate::{combat_ui, dialog_ui, influence_ui, move_ui, recruit_unit_ui, status_phase_ui};
 
@@ -47,7 +47,7 @@ pub fn render_and_update(
 }
 
 fn render(game: &Game, state: &mut State, features: &Features) -> StateUpdate {
-    clear_background(BLACK);
+    clear_background(WHITE);
 
     let player = &state.shown_player(game);
 
@@ -64,8 +64,13 @@ fn render(game: &Game, state: &mut State, features: &Features) -> StateUpdate {
         draw_map(game, state);
     }
     let mut updates = StateUpdates::new();
-    updates.add(show_globals(game, player));
+    show_top_left(game, player);
+    show_top_center(game, player, state);
+    updates.add(player_select(game, player, state));
     updates.add(show_global_controls(game, state, features));
+    if !matches!(state.active_dialog, ActiveDialog::None) || state.active_dialog.is_map_dialog() {
+        updates.clear();
+    }
 
     if player.can_control {
         if let Some(u) = &state.pending_update {

client/assets/export-2-svgrepo-com.png

@@ -206,6 +206,10 @@ impl StateUpdates {
         }
     }
 
+    pub fn clear(&mut self) {
+        self.updates.clear();
+    }
+
     pub fn result(self) -> StateUpdate {
         self.updates
             .into_iter()

client/assets/gold-ingots-gold-svgrepo-com.png

@@ -1,35 +1,90 @@
-use crate::client_state::ShownPlayer;
+use crate::client_state::{ShownPlayer, State};
+use macroquad::color::WHITE;
 use macroquad::math::{vec2, Vec2};
+use macroquad::prelude::*;
 use macroquad::ui::root_ui;
 
+pub const ICON_SIZE: f32 = 30.;
+
+pub const MARGIN: f32 = 10.;
+
+pub fn icon_offset(i: i8) -> f32 {
+    f32::from(i) * 1.4 * ICON_SIZE
+}
+
+pub fn icon_pos(x: i8, y: i8) -> Vec2 {
+    vec2(icon_offset(x), icon_offset(y))
+}
+
 pub fn top_left_label(p: Vec2, label: &str) {
-    root_ui().label(p, label);
+    root_ui().label(p + vec2(-40., 0.), label);
 }
 
 pub fn top_center_label(player: &ShownPlayer, p: Vec2, label: &str) {
     root_ui().label(vec2(player.screen_size.x / 2.0, 0.) + p, label);
 }
 
-pub fn right_center_label(player: &ShownPlayer, p: Vec2, label: &str) {
-    root_ui().label(
-        vec2(player.screen_size.x, player.screen_size.y / 2.0) + p,
-        label,
-    );
+pub fn top_center_texture(state: &State, texture: &Texture2D, p: Vec2) -> bool {
+    relative_texture(state, texture, vec2(state.screen_size.x / 2., MARGIN), p)
 }
 
-pub fn right_center_button(player: &ShownPlayer, p: Vec2, label: &str) -> bool {
-    root_ui().button(
-        vec2(player.screen_size.x, player.screen_size.y / 2.0) + p,
-        label,
+pub fn top_right_texture(state: &State, texture: &Texture2D, p: Vec2) -> bool {
+    relative_texture(
+        state,
+        texture,
+        vec2(state.screen_size.x - MARGIN, MARGIN),
+        p,
+    )
+}
+
+pub fn bottom_left_texture(state: &State, texture: &Texture2D, p: Vec2) -> bool {
+    relative_texture(
+        state,
+        texture,
+        vec2(MARGIN, state.screen_size.y - MARGIN),
+        p,
     )
 }
 
 pub fn bottom_left_button(player: &ShownPlayer, p: Vec2, label: &str) -> bool {
-    root_ui().button(vec2(0., player.screen_size.y) + p, label)
+    root_ui().button(vec2(MARGIN, player.screen_size.y - MARGIN) + p, label)
+}
+
+pub fn bottom_right_texture(state: &State, texture: &Texture2D, p: Vec2) -> bool {
+    relative_texture(
+        state,
+        texture,
+        vec2(state.screen_size.x - MARGIN, state.screen_size.y - MARGIN),
+        p,
+    )
+}
+
+fn relative_texture(state: &State, texture: &Texture2D, anchor: Vec2, offset: Vec2) -> bool {
+    let origin = anchor + offset;
+    set_default_camera();
+    draw_texture_ex(
+        texture,
+        origin.x,
+        origin.y,
+        WHITE,
+        DrawTextureParams {
+            dest_size: Some(vec2(ICON_SIZE, ICON_SIZE)),
+            ..Default::default()
+        },
+    );
+
+    let pressed = left_mouse_button(Rect::new(origin.x, origin.y, ICON_SIZE, ICON_SIZE));
+    set_camera(&state.camera);
+    pressed
 }
 
-pub fn bottom_right_button(player: &ShownPlayer, p: Vec2, label: &str) -> bool {
-    root_ui().button(vec2(player.screen_size.x, player.screen_size.y) + p, label)
+pub fn left_mouse_button(rect: Rect) -> bool {
+    if is_mouse_button_pressed(MouseButton::Left) {
+        let (x, y) = mouse_position();
+        rect.contains(vec2(x, y))
+    } else {
+        false
+    }
 }
 
 pub fn cancel_pos(player: &ShownPlayer) -> Vec2 {

client/assets/happy-emoji-svgrepo-com.png

@@ -2,10 +2,11 @@ use crate::client::Features;
 use crate::client_state::{ActiveDialog, ShownPlayer, State, StateUpdate, OFFSET, ZOOM};
 use crate::happiness_ui::start_increase_happiness;
 use crate::layout_ui::{
-    bottom_left_button, bottom_right_button, right_center_button, right_center_label,
-    top_center_label, top_left_label,
+    bottom_left_button, bottom_left_texture, bottom_right_texture, icon_pos, left_mouse_button,
+    top_center_label, top_center_texture, top_left_label, top_right_texture, ICON_SIZE,
 };
-use macroquad::math::vec2;
+use crate::resource_ui::ResourceType;
+use macroquad::math::{u32, vec2};
 use macroquad::prelude::*;
 use macroquad::ui::{root_ui, Ui};
 use server::action::Action;
@@ -14,12 +15,7 @@ use server::player::Player;
 use server::playing_actions::PlayingAction;
 use server::resource_pile::ResourcePile;
 
-pub fn show_globals(game: &Game, player: &ShownPlayer) -> StateUpdate {
-    show_top_left(game);
-    show_top_center(game, player);
-
-    let mut y = -100.;
-
+pub fn player_select(game: &Game, player: &ShownPlayer, state: &State) -> StateUpdate {
     let i = game
         .players
         .iter()
@@ -28,77 +24,147 @@ pub fn show_globals(game: &Game, player: &ShownPlayer) -> StateUpdate {
     let mut players: Vec<_> = game.players.iter().map(|p| p.index).collect();
     players.rotate_left(i);
 
+    let mut y = (players.len() as f32 * -ICON_SIZE) / 2.;
+
     for p in players {
-        let p = game.get_player(p);
-        let shown = player.index == p.index;
-        let prefix = if shown { "* " } else { "" };
-        let name = p.get_name();
-        let x = -200.;
-        let label = format!("{prefix}{name}");
-        if shown {
-            right_center_label(player, vec2(x, y), &label);
-        } else if right_center_button(player, vec2(x, y), &label) {
-            return StateUpdate::SetShownPlayer(p.index);
+        let pl = game.get_player(p);
+        let shown = player.index == pl.index;
+        let pos = vec2(player.screen_size.x, player.screen_size.y / 2.0) + vec2(-20., y);
+
+        let color = player_color(pl.index);
+        set_default_camera();
+
+        let w = if shown { ICON_SIZE + 10. } else { ICON_SIZE };
+        let x = pos.x - w + ICON_SIZE;
+        draw_rectangle(x, pos.y, w, ICON_SIZE, color);
+        draw_rectangle_lines(x, pos.y, w, ICON_SIZE, 2.0, BLACK);
+        let text = format!("{}", pl.victory_points());
+
+        draw_text(&text, pos.x + 5., pos.y + 20., 20.0, BLACK);
+
+        let active = game.active_player();
+        if active == pl.index {
+            draw_texture_ex(
+                &state.assets.active_player,
+                x - 25.,
+                pos.y + 5.,
+                WHITE,
+                DrawTextureParams {
+                    dest_size: Some(vec2(20., 20.)),
+                    ..Default::default()
+                },
+            );
+        }
+
+        set_camera(&state.camera);
+
+        if !shown && left_mouse_button(Rect::new(x, pos.y, w, ICON_SIZE)) {
+            return StateUpdate::SetShownPlayer(pl.index);
         }
-        y += 40.;
+
+        y += ICON_SIZE;
     }
 
     StateUpdate::None
 }
 
-fn show_top_center(game: &Game, player: &ShownPlayer) {
+pub fn resource_label(
+    player: &ShownPlayer,
+    state: &State,
+    label: &str,
+    resource_type: ResourceType,
+    p: Vec2,
+) {
+    top_icon_with_label(
+        player,
+        state,
+        label,
+        &state.assets.resources[&resource_type],
+        p,
+    );
+}
+
+pub fn top_icon_with_label(
+    player: &ShownPlayer,
+    state: &State,
+    label: &str,
+    texture: &Texture2D,
+    p: Vec2,
+) {
+    top_center_texture(state, texture, p);
+    top_center_label(player, p + vec2(-30. - label.len() as f32 * 5., 40.), label);
+}
+
+pub fn show_top_center(game: &Game, player: &ShownPlayer, state: &State) {
     let p = game.get_player(player.index);
 
-    top_center_label(player, vec2(-400., 0.), &resource_ui(p, "Fd", |r| r.food));
-    top_center_label(player, vec2(-320., 0.), &resource_ui(p, "Wd", |r| r.wood));
-    top_center_label(player, vec2(-240., 0.), &resource_ui(p, "Ore", |r| r.ore));
-    top_center_label(player, vec2(-160., 0.), &resource_ui(p, "Id", |r| r.ideas));
-    top_center_label(
+    resource_label(
         player,
-        vec2(-80., 0.),
-        &resource_ui(p, "Gld", |r| r.gold as u32),
+        state,
+        &resource_ui(p, |r| r.food),
+        ResourceType::Food,
+        icon_pos(-4, 0),
     );
-    top_center_label(
+    resource_label(
         player,
-        vec2(0., 0.),
-        &resource_ui(p, "Md", |r| r.mood_tokens),
+        state,
+        &resource_ui(p, |r| r.wood),
+        ResourceType::Wood,
+        icon_pos(-3, 0),
     );
-    top_center_label(
+    resource_label(
         player,
-        vec2(80., 0.),
-        &resource_ui(p, "Cul", |r| r.culture_tokens),
+        state,
+        &resource_ui(p, |r| r.ore),
+        ResourceType::Ore,
+        icon_pos(-2, 0),
     );
-
-    top_center_label(
+    resource_label(
         player,
-        vec2(170., 0.),
-        &format!("Civ {}", p.civilization.name),
+        state,
+        &resource_ui(p, |r| r.ideas),
+        ResourceType::Ideas,
+        icon_pos(-1, 0),
     );
-    top_center_label(
+    resource_label(
         player,
-        vec2(250., 0.),
-        &format!("VP {}", p.victory_points()),
+        state,
+        &resource_ui(p, |r| r.gold as u32),
+        ResourceType::Gold,
+        icon_pos(0, 0),
     );
-    top_center_label(
+    resource_label(
         player,
-        vec2(300., 0.),
-        &format!(
-            "Ldr {}",
-            if let Some(l) = &p.active_leader {
-                &l.name
-            } else {
-                "-"
-            }
-        ),
+        state,
+        &resource_ui(p, |r| r.mood_tokens),
+        ResourceType::MoodTokens,
+        icon_pos(1, 0),
+    );
+    resource_label(
+        player,
+        state,
+        &resource_ui(p, |r| r.culture_tokens),
+        ResourceType::CultureTokens,
+        icon_pos(2, 0),
+    );
+
+    top_icon_with_label(
+        player,
+        state,
+        &format!("{}", &p.victory_points()),
+        &state.assets.victory_points,
+        icon_pos(3, 0),
     );
+
     show_wonders(game, player, &mut root_ui());
 }
 
-fn show_top_left(game: &Game) {
+pub fn show_top_left(game: &Game, player: &ShownPlayer) {
     let mut y = 0.;
     let mut label = |label: String| {
-        top_left_label(vec2(0., y), &label);
-        y += 30.;
+        let p = vec2(0., y * 25.);
+        y += 1.;
+        top_left_label(p, &label);
     };
 
     match &game.state {
@@ -110,31 +176,42 @@ fn show_top_left(game: &Game) {
         _ => label(format!("Round {}", game.round)),
     }
 
-    let current = game.current_player_index;
-    label(format!("Playing {}", &game.get_player(current).get_name()));
+    let p = game.get_player(player.index);
 
-    match &game.state {
-        GameState::StatusPhase(_) | GameState::Finished => {}
-        _ => label(format!("Actions {}", game.actions_left)),
-    }
+    label(p.get_name());
 
-    match &game.state {
-        GameState::Movement { .. } => label("Movement".to_string()),
-        GameState::CulturalInfluenceResolution(_) => {
-            label("Cultural Influence Resolution".to_string());
+    label(format!("Civ {}", p.civilization.name));
+
+    label(format!(
+        "Leader {}",
+        if let Some(l) = &p.active_leader {
+            &l.name
+        } else {
+            "-"
         }
-        GameState::Combat(c) => label(format!("Combat Round {} Phase {:?}", c.round, c.phase)),
-        GameState::PlaceSettler { .. } => label("Place Settler".to_string()),
-        _ => {}
-    }
+    ));
 
-    if let Some(m) = moves_left(&game.state) {
-        label(format!("Moves left {m}"));
-    }
+    if game.current_player_index == p.index {
+        label("Your turn".to_string());
+
+        match &game.state {
+            GameState::StatusPhase(_) | GameState::Finished => {}
+            _ => label(format!("Actions {}", game.actions_left)),
+        }
+
+        match &game.state {
+            GameState::Movement { .. } => label("Movement".to_string()),
+            GameState::CulturalInfluenceResolution(_) => {
+                label("Cultural Influence Resolution".to_string());
+            }
+            GameState::Combat(c) => label(format!("Combat Round {} Phase {:?}", c.round, c.phase)),
+            GameState::PlaceSettler { .. } => label("Place Settler".to_string()),
+            _ => {}
+        }
 
-    let active = game.active_player();
-    if active != current {
-        label(format!("Active {}", game.get_player(active).get_name()));
+        if let Some(m) = moves_left(&game.state) {
+            label(format!("Moves left {m}"));
+        }
     }
 }
 
@@ -176,54 +253,55 @@ pub fn show_wonders(game: &Game, player: &ShownPlayer, ui: &mut Ui) {
     }
 }
 
-fn resource_ui(player: &Player, name: &str, f: impl Fn(&ResourcePile) -> u32) -> String {
+fn resource_ui(player: &Player, f: impl Fn(&ResourcePile) -> u32) -> String {
     let r: &ResourcePile = &player.resources;
     let l: &ResourcePile = &player.resource_limit;
-    format!("{name} {}/{}", f(r), f(l))
+    format!("{}/{}", f(r), f(l))
 }
 
 pub fn show_global_controls(game: &Game, state: &mut State, features: &Features) -> StateUpdate {
     let player = &state.shown_player(game);
 
-    if bottom_left_button(player, vec2(0., -50.), "+") {
+    let assets = &state.assets;
+    if bottom_left_texture(state, &assets.zoom_in, icon_pos(1, -1)) {
         state.zoom *= 1.1;
         return StateUpdate::None;
     }
-    if bottom_left_button(player, vec2(70., -50.), "-") {
+    if bottom_left_texture(state, &assets.zoom_out, icon_pos(0, -1)) {
         state.zoom /= 1.1;
         return StateUpdate::None;
     }
-    if bottom_left_button(player, vec2(140., -50.), "0") {
+    if bottom_left_texture(state, &assets.reset, icon_pos(2, -1)) {
         state.zoom = ZOOM;
         state.offset = OFFSET;
         return StateUpdate::None;
     }
-    if bottom_left_button(player, vec2(210., -80.), "") {
-        state.offset += vec2(-0.1, 0.);
+    if bottom_left_texture(state, &assets.up, icon_pos(4, -2)) {
+        state.offset += vec2(0., 0.1);
         return StateUpdate::None;
     }
-    if bottom_left_button(player, vec2(310., -80.), "") {
-        state.offset += vec2(0.1, 0.);
+    if bottom_left_texture(state, &assets.down, icon_pos(4, -1)) {
+        state.offset += vec2(0., -0.1);
         return StateUpdate::None;
     }
-    if bottom_left_button(player, vec2(260., -110.), "") {
-        state.offset += vec2(0., 0.1);
+    if bottom_left_texture(state, &assets.left, icon_pos(3, -1)) {
+        state.offset += vec2(-0.1, 0.);
         return StateUpdate::None;
     }
-    if bottom_left_button(player, vec2(260., -50.), "") {
-        state.offset += vec2(0., -0.1);
+    if bottom_left_texture(state, &assets.right, icon_pos(5, -1)) {
+        state.offset += vec2(0.1, 0.);
         return StateUpdate::None;
     }
 
-    if game.can_undo() && bottom_right_button(player, vec2(-400., -50.), "Undo") {
+    if game.can_undo() && bottom_right_texture(state, &assets.undo, icon_pos(-6, -1)) {
         return StateUpdate::Execute(Action::Undo);
     }
-    if game.can_redo() && bottom_right_button(player, vec2(-300., -50.), "Redo") {
+    if game.can_redo() && bottom_right_texture(state, &assets.redo, icon_pos(-5, -1)) {
         return StateUpdate::Execute(Action::Redo);
     }
     if player.can_control
         && matches!(game.state, GameState::Playing)
-        && bottom_right_button(player, vec2(-180., -50.), "End Turn")
+        && bottom_right_texture(state, &assets.end_turn, icon_pos(-4, -1))
     {
         let left = game.actions_left;
         return StateUpdate::execute_with_warning(
@@ -236,16 +314,17 @@ pub fn show_global_controls(game: &Game, state: &mut State, features: &Features)
         );
     }
 
-    if player.can_play_action && bottom_left_button(player, vec2(0., -170.), "Move") {
+    if player.can_play_action && bottom_left_texture(state, &assets.movement, icon_pos(0, -3)) {
         return StateUpdate::execute(Action::Playing(PlayingAction::MoveUnits));
     }
-    if player.can_play_action && bottom_left_button(player, vec2(0., -140.), "Inc. Hap.") {
+    if player.can_play_action && bottom_left_texture(state, &assets.happy, icon_pos(0, -2)) {
         return start_increase_happiness(game, player);
     }
-    if bottom_left_button(player, vec2(0., -110.), "Advances") {
+    if top_right_texture(state, &assets.advances, icon_pos(-2, 0)) {
         return StateUpdate::OpenDialog(ActiveDialog::AdvanceMenu);
     };
-    if bottom_left_button(player, vec2(0., -80.), "Log") {
+
+    if top_right_texture(state, &assets.log, icon_pos(-1, 0)) {
         return StateUpdate::OpenDialog(ActiveDialog::Log);
     };
     let d = state.game_state_dialog(game, &ActiveDialog::None);
@@ -257,10 +336,10 @@ pub fn show_global_controls(game: &Game, state: &mut State, features: &Features)
     }
 
     if features.import_export {
-        if bottom_right_button(player, vec2(-300., -100.), "Import") {
+        if bottom_right_texture(state, &assets.import, icon_pos(-2, -3)) {
             return StateUpdate::Import;
         };
-        if bottom_right_button(player, vec2(-150., -100.), "Export") {
+        if bottom_right_texture(state, &assets.export, icon_pos(-1, -3)) {
             return StateUpdate::Export;
         };
     }