553 lines
19 KiB
C
553 lines
19 KiB
C
#include "ui_widgets.h"
|
|
|
|
#include "game_state.h"
|
|
#include "components.h"
|
|
|
|
#include <stdio.h>
|
|
|
|
f32 uiGetScale() {
|
|
// Assuming 16:9 aspect
|
|
f32 scaleX = GetScreenWidth() / 1280.0f;
|
|
f32 scaleY = GetScreenHeight() / 720.0f;
|
|
return BZ_MIN(scaleX, scaleY);
|
|
}
|
|
|
|
Font getFont() {
|
|
static const Game *game = NULL;
|
|
if (!game) {
|
|
game = ecs_singleton_get(ECS, Game);
|
|
}
|
|
return game->font;
|
|
}
|
|
|
|
BzUINode *uiPushDivParentPercentage(f32 xPercent, f32 yPercent) {
|
|
return bzUIPushDiv(UI, (BzUISize) {
|
|
.kind = BZ_UI_SIZE_REL_PARENT,
|
|
.value = xPercent,
|
|
}, (BzUISize) {
|
|
.kind = BZ_UI_SIZE_REL_PARENT,
|
|
.value = yPercent
|
|
});
|
|
}
|
|
|
|
void uiBaseLabel(const char *txt, Font font, f32 scl, Color color) {
|
|
BzUINode *node = bzUINodeMake(UI, bzUIKeyFromString(txt), &(BzUINodeDesc) {
|
|
.flags = BZ_UI_DRAW_TEXT | BZ_UI_DRAW_TEXT_SHADOW | BZ_UI_ALIGN_CENTER,
|
|
.semanticSize[BZ_UI_AXIS_X] = {
|
|
.kind = BZ_UI_SIZE_FIT,
|
|
},
|
|
.semanticSize[BZ_UI_AXIS_Y] = {
|
|
.kind = BZ_UI_SIZE_FIT
|
|
},
|
|
.padding = {5, 5, 5, 5},
|
|
});
|
|
bzUISetTextStyle(UI, node, (BzUITextStyle) {
|
|
.text = txt,
|
|
.font = font,
|
|
.fontSpacing = 2 * uiGetScale() * scl,
|
|
.fontSize = 62 * uiGetScale() * scl,
|
|
.normal = color,
|
|
.hover = color,
|
|
.active = color,
|
|
});
|
|
bzUISetTextShadowStyle(UI, node, (BzUITextShadowStyle) {
|
|
.offset[BZ_UI_AXIS_X] = 2 * uiGetScale() * scl,
|
|
.offset[BZ_UI_AXIS_Y] = 2 * uiGetScale() * scl,
|
|
.normal = BLACK,
|
|
.hover = BLACK,
|
|
.active = BLACK,
|
|
});
|
|
}
|
|
|
|
bool uiBaseTextButton(const char *txt, Font font, f32 scl, bool enabled) {
|
|
BzUINode *node = bzUINodeMake(UI, bzUIKeyFromString(txt), &(BzUINodeDesc) {
|
|
.flags = BZ_UI_DRAW_TEXT | BZ_UI_DRAW_TEXT_SHADOW | BZ_UI_ALIGN_CENTER,
|
|
.semanticSize[BZ_UI_AXIS_X] = {
|
|
.kind = BZ_UI_SIZE_FIT,
|
|
},
|
|
.semanticSize[BZ_UI_AXIS_Y] = {
|
|
.kind = BZ_UI_SIZE_FIT
|
|
},
|
|
.padding = {5, 0, 5, 0},
|
|
.margin = {5, 5, 5, 5},
|
|
});
|
|
bzUISetTextStyle(UI, node, (BzUITextStyle) {
|
|
.text = txt,
|
|
.font = font,
|
|
.fontSpacing = 2 * uiGetScale() * scl,
|
|
.fontSize = 62 * uiGetScale() * scl,
|
|
.normal = enabled ? WHITE : GRAY,
|
|
.hover = enabled ? GRAY : GRAY,
|
|
.active = enabled ? GRAY : LIGHTGRAY,
|
|
});
|
|
bzUISetTextShadowStyle(UI, node, (BzUITextShadowStyle) {
|
|
.offset[BZ_UI_AXIS_X] = 2 * uiGetScale() * scl,
|
|
.offset[BZ_UI_AXIS_Y] = 2 * uiGetScale() * scl,
|
|
.normal = BLACK,
|
|
.hover = BLACK,
|
|
.active = BLACK,
|
|
});
|
|
return bzUIGetInteraction(UI, node).clicked;
|
|
}
|
|
void uiBaseCheckbox(const char *txt, Font font, f32 scl, bool *check) {
|
|
BZ_ASSERT(check);
|
|
bzUIPushDiv(UI, (BzUISize) {BZ_UI_SIZE_CHILD_SUM}, (BzUISize) {BZ_UI_SIZE_CHILD_MAX});
|
|
bzUISetParentLayout(UI, (BzUILayout) {
|
|
BZ_UI_LAYOUT_FLEX_BOX,
|
|
BZ_UI_FLEX_DIR_ROW | BZ_UI_FLEX_ALIGN_CENTER | BZ_UI_FLEX_JUSTIFY_START
|
|
});
|
|
|
|
f32 size = 16 * uiGetScale() * scl;
|
|
BzUINode *checkbox = bzUINodeMake(UI, bzUIGetUniqueKey(UI), &(BzUINodeDesc) {
|
|
.flags = BZ_UI_CLICKABLE | BZ_UI_DRAW_BACKGROUND | BZ_UI_DRAW_BORDER,
|
|
.semanticSize[BZ_UI_AXIS_X] = (BzUISize) { BZ_UI_SIZE_PIXELS, size},
|
|
.semanticSize[BZ_UI_AXIS_Y] = (BzUISize) { BZ_UI_SIZE_PIXELS, size},
|
|
.margin = {0, 0, 10 * uiGetScale() * scl, 0 }
|
|
});
|
|
bzUISetBackgroundStyle(UI, checkbox, (BzUIBackgroundStyle) {
|
|
.normal = *check ? WHITE : BLACK,
|
|
.hover = GRAY,
|
|
.active = YELLOW,
|
|
});
|
|
bzUISetBorderStyle(UI, checkbox, (BzUIBorderStyle) {
|
|
.thickness = 5.0f * uiGetScale() * scl,
|
|
.normal = BLACK,
|
|
.hover = BLACK,
|
|
.active = BLACK,
|
|
});
|
|
|
|
if (bzUIGetInteraction(UI, checkbox).clicked) {
|
|
*check = !*check;
|
|
}
|
|
|
|
BzUINode *label = bzUINodeMake(UI, bzUIKeyFromString(txt), &(BzUINodeDesc) {
|
|
.flags = BZ_UI_DRAW_TEXT | BZ_UI_DRAW_TEXT_SHADOW | BZ_UI_ALIGN_CENTER,
|
|
.semanticSize[BZ_UI_AXIS_X] = {
|
|
.kind = BZ_UI_SIZE_FIT,
|
|
},
|
|
.semanticSize[BZ_UI_AXIS_Y] = {
|
|
.kind = BZ_UI_SIZE_FIT
|
|
},
|
|
});
|
|
bzUISetTextStyle(UI, label, (BzUITextStyle) {
|
|
.text = txt,
|
|
.font = font,
|
|
.fontSpacing = 2 * uiGetScale() * scl,
|
|
.fontSize = 32 * uiGetScale() * scl,
|
|
.normal = WHITE,
|
|
.hover = GRAY,
|
|
.active = YELLOW
|
|
});
|
|
bzUISetTextShadowStyle(UI, label, (BzUITextShadowStyle) {
|
|
.offset[BZ_UI_AXIS_X] = 2 * uiGetScale() * scl,
|
|
.offset[BZ_UI_AXIS_Y] = 2 * uiGetScale() * scl,
|
|
.normal = BLACK,
|
|
.hover = BLACK,
|
|
.active = BLACK,
|
|
});
|
|
if (bzUIGetInteraction(UI, label).clicked) {
|
|
*check = !*check;
|
|
}
|
|
|
|
bzUIPopParent(UI);
|
|
}
|
|
void uiBaseSlider(const char *txt, Font font, f32 scl, f32 *value, f32 min, f32 max) {
|
|
BZ_ASSERT(value);
|
|
bzUIPushDiv(UI, (BzUISize) {BZ_UI_SIZE_CHILD_SUM}, (BzUISize) {BZ_UI_SIZE_CHILD_MAX});
|
|
bzUISetParentLayout(UI, (BzUILayout) {
|
|
BZ_UI_LAYOUT_FLEX_BOX,
|
|
BZ_UI_FLEX_DIR_ROW | BZ_UI_FLEX_ALIGN_CENTER | BZ_UI_FLEX_JUSTIFY_SPACE_BETWEEN
|
|
});
|
|
|
|
uiBaseLabel(txt, font, 0.6 * scl, WHITE);
|
|
|
|
bzUIPushDiv(UI, (BzUISize) {BZ_UI_SIZE_CHILD_SUM}, (BzUISize) { BZ_UI_SIZE_CHILD_MAX});
|
|
bzUISetParentLayout(UI, (BzUILayout) {
|
|
BZ_UI_LAYOUT_FLEX_BOX,
|
|
BZ_UI_FLEX_DIR_ROW | BZ_UI_FLEX_ALIGN_CENTER | BZ_UI_FLEX_JUSTIFY_END
|
|
});
|
|
|
|
char buf[32];
|
|
snprintf(buf, sizeof(buf), "-##%s", txt);
|
|
if (uiBaseTextButton(buf, font, 0.6 * scl, true))
|
|
(*value)--;
|
|
*value = BZ_MAX(*value, min);
|
|
|
|
snprintf(buf, sizeof(buf), "%2.0f##%s", *value, txt);
|
|
uiBaseLabel(buf, font, 0.6 * scl, WHITE);
|
|
|
|
snprintf(buf, sizeof(buf), "+##%s", txt);
|
|
if (uiBaseTextButton(buf, font, 0.6 * scl, true))
|
|
(*value)++;
|
|
*value = BZ_MIN(*value, max);
|
|
bzUIPopParent(UI);
|
|
|
|
bzUIPopParent(UI);
|
|
}
|
|
|
|
void uiMainMenuLabel(const char *txt) {
|
|
uiBaseLabel(txt, getFont(), 1.8f, WHITE);
|
|
}
|
|
|
|
bool uiMainMenuButton(const char *txt, bool enabled) {
|
|
return uiBaseTextButton(txt, getFont(), 0.8f, enabled);
|
|
}
|
|
|
|
void uiSettingsLabel(const char *txt) {
|
|
uiBaseLabel(txt, getFont(), 0.8f, WHITE);
|
|
}
|
|
bool uiSettingsButton(const char *txt) {
|
|
return uiBaseTextButton(txt, getFont(), 0.7f, true);
|
|
}
|
|
void uiSettingsCheckbox(const char *txt, bool *check) {
|
|
uiBaseCheckbox(txt, getFont(), 1.0f, check);
|
|
}
|
|
void uiSettingsSlider(const char *txt, f32 *value) {
|
|
f32 val = *value * 10.0f;
|
|
uiBaseSlider(txt, getFont(), 1.0f, &val, 0, 10);
|
|
*value = val / 10.0f;
|
|
}
|
|
|
|
void uiGameResCount(i32 amount, i32 capacity, Rectangle icon, Texture2D texture) {
|
|
bzUIPushDiv(UI, (BzUISize) { BZ_UI_SIZE_CHILD_SUM },
|
|
(BzUISize) { BZ_UI_SIZE_CHILD_MAX });
|
|
bzUISetParentLayout(UI, (BzUILayout) {
|
|
BZ_UI_LAYOUT_FLEX_BOX,
|
|
BZ_UI_FLEX_DIR_ROW | BZ_UI_FLEX_ALIGN_CENTER
|
|
});
|
|
char buf[64];
|
|
BzUIKey id = bzUIGetUniqueKey(UI);
|
|
if (capacity == -1)
|
|
snprintf(buf, sizeof(buf), "%d##%d", amount, id);
|
|
else
|
|
snprintf(buf, sizeof(buf), "%d/%d##%d", amount, capacity, id);
|
|
const f32 scl = 0.4f;
|
|
Color color = WHITE;
|
|
if (capacity != -1 && amount >= capacity)
|
|
color = RED;
|
|
uiBaseLabel(buf, getFont(), scl, color);
|
|
|
|
BzUINode *iconNode = bzUINodeMake(UI, id, &(BzUINodeDesc) {
|
|
.flags = BZ_UI_DRAW_SPRITE | BZ_UI_ALIGN_CENTER,
|
|
.semanticSize[BZ_UI_AXIS_X] = {
|
|
BZ_UI_SIZE_PIXELS, 80 * scl * uiGetScale(),
|
|
},
|
|
.semanticSize[BZ_UI_AXIS_Y] = {
|
|
BZ_UI_SIZE_PIXELS, 80 * scl * uiGetScale(),
|
|
},
|
|
.margin = {0, 0, 20 * uiGetScale(), 0}
|
|
});
|
|
bzUISetSpriteStyle(UI, iconNode, (BzUISpriteStyle) {
|
|
.rec = icon,
|
|
.texture = texture,
|
|
.tintNormal = WHITE,
|
|
.tintHover = WHITE,
|
|
.tintActive = WHITE,
|
|
});
|
|
|
|
bzUIPopParent(UI);
|
|
}
|
|
|
|
void uiGameRecruit(const char *label, Rectangle rec, Texture2D tex, i32 numRecruiting,
|
|
f32 progress, bool canAfford, bool *selected, bool *hovered) {
|
|
f32 scl = uiGetScale();
|
|
BzUINode *btn = bzUINodeMake(UI, bzUIKeyFromString(label), &(BzUINodeDesc) {
|
|
.flags = BZ_UI_CLICKABLE | BZ_UI_ALIGN_CENTER | BZ_UI_DRAW_BORDER,
|
|
.margin[BZ_UI_AXIS_X] = 10.0f * scl,
|
|
.margin[BZ_UI_AXIS_Y] = 10.0f * scl,
|
|
.margin[BZ_UI_AXIS_Y * 2] = 10.0f * scl,
|
|
.semanticSize[BZ_UI_AXIS_X] = {BZ_UI_SIZE_CHILD_MAX},
|
|
.semanticSize[BZ_UI_AXIS_Y] = {BZ_UI_SIZE_CHILD_SUM},
|
|
});
|
|
if (rec.height > 16)
|
|
rec.y += 16;
|
|
rec.height = rec.width;
|
|
|
|
BzUIInteraction inter = bzUIGetInteraction(UI, btn);
|
|
|
|
Color bgColor = canAfford ? DARKBROWN : MAROON;
|
|
if (*selected || inter.hovering)
|
|
bgColor = canAfford ? BROWN : RED;
|
|
if (inter.clicked && canAfford)
|
|
*selected = true;
|
|
if (hovered)
|
|
*hovered = inter.hovering;
|
|
|
|
bzUISetBackgroundStyle(UI, btn, (BzUIBackgroundStyle) {
|
|
.roundness = 0.2f,
|
|
.active = bgColor,
|
|
.normal = bgColor,
|
|
.hover = bgColor,
|
|
});
|
|
bzUISetBorderStyle(UI, btn, (BzUIBorderStyle) {
|
|
.roundness = 0.2f,
|
|
.thickness = 5.0f * scl,
|
|
.normal = BLACK,
|
|
.hover = BLACK,
|
|
.active = BLACK,
|
|
});
|
|
bzUIPushParent(UI, btn);
|
|
bzUISetParentLayout(UI, (BzUILayout) {
|
|
.type = BZ_UI_LAYOUT_FLEX_BOX,
|
|
.flags = BZ_UI_FLEX_DIR_COLUMN | BZ_UI_FLEX_ALIGN_CENTER | BZ_UI_FLEX_JUSTIFY_START
|
|
});
|
|
|
|
BzUINode *tileSprite = bzUINodeMake(UI, bzUIGetUniqueKey(UI), &(BzUINodeDesc) {
|
|
.flags = BZ_UI_DRAW_SPRITE,
|
|
.semanticSize[BZ_UI_AXIS_X] = {BZ_UI_SIZE_PIXELS, rec.width * 5 * scl},
|
|
.semanticSize[BZ_UI_AXIS_Y] = {BZ_UI_SIZE_PIXELS, rec.height * 5 * scl},
|
|
});
|
|
bzUISetSpriteStyle(UI, tileSprite, (BzUISpriteStyle) {
|
|
.texture = tex,
|
|
.rec = rec,
|
|
.tintNormal = WHITE,
|
|
.tintHover = WHITE,
|
|
.tintActive = WHITE,
|
|
});
|
|
|
|
char text[128];
|
|
if (numRecruiting > 0) {
|
|
snprintf(text, sizeof(text), "%dx %s", numRecruiting, label);
|
|
} else {
|
|
snprintf(text, sizeof(text), "%s", label);
|
|
}
|
|
|
|
BzUINode *labelDisplay = bzUINodeMake(UI, bzUIGetUniqueKey(UI), &(BzUINodeDesc) {
|
|
.flags = BZ_UI_DRAW_TEXT | BZ_UI_DRAW_TEXT_SHADOW,
|
|
.semanticSize[BZ_UI_AXIS_X] = {BZ_UI_SIZE_FIT},
|
|
.semanticSize[BZ_UI_AXIS_Y] = {BZ_UI_SIZE_FIT},
|
|
});
|
|
bzUISetTextStyle(UI, labelDisplay, (BzUITextStyle) {
|
|
.font = getFont(),
|
|
.fontSize = 25.0f * scl,
|
|
.fontSpacing = 1.0f * scl,
|
|
.normal = WHITE,
|
|
.hover = WHITE,
|
|
.active = WHITE,
|
|
.text = text
|
|
});
|
|
bzUISetTextShadowStyle(UI, labelDisplay, (BzUITextShadowStyle) {
|
|
.offset = {1.0f * scl, 1.0f * scl},
|
|
.normal = BLACK,
|
|
.hover = BLACK,
|
|
.active = BLACK
|
|
});
|
|
|
|
if (progress > 0.0f) {
|
|
BzUINode *progressBar = bzUINodeMake(UI, bzUIGetUniqueKey(UI), &(BzUINodeDesc) {
|
|
.flags = BZ_UI_DRAW_BACKGROUND | BZ_UI_ALIGN_HORIZ_START,
|
|
.semanticSize[BZ_UI_AXIS_X] = {BZ_UI_SIZE_REL_PARENT, progress * 0.8f},
|
|
.semanticSize[BZ_UI_AXIS_Y] = {BZ_UI_SIZE_PIXELS, scl * 4}
|
|
});
|
|
bzUISetBackgroundStyle(UI, progressBar, (BzUIBackgroundStyle) {
|
|
.active = GREEN,
|
|
.hover = GREEN,
|
|
.normal = GREEN,
|
|
});
|
|
}
|
|
|
|
bzUIPopParent(UI);
|
|
}
|
|
void uiGameBuild(const char *label, Rectangle rec, Texture2D tex, bool canAfford, bool *selected, bool *hovered) {
|
|
f32 scl = uiGetScale();
|
|
BzUINode *btn = bzUINodeMake(UI, bzUIKeyFromString(label), &(BzUINodeDesc) {
|
|
.flags = BZ_UI_CLICKABLE | BZ_UI_ALIGN_CENTER | BZ_UI_DRAW_BORDER,
|
|
.margin[BZ_UI_AXIS_X] = 10.0f * scl,
|
|
.margin[BZ_UI_AXIS_Y] = 10.0f * scl,
|
|
.margin[BZ_UI_AXIS_Y * 2] = 10.0f * scl,
|
|
.semanticSize[BZ_UI_AXIS_X] = {BZ_UI_SIZE_CHILD_MAX},
|
|
.semanticSize[BZ_UI_AXIS_Y] = {BZ_UI_SIZE_CHILD_SUM},
|
|
});
|
|
if (rec.height > 16)
|
|
rec.y += 16;
|
|
rec.height = rec.width;
|
|
|
|
BzUIInteraction inter = bzUIGetInteraction(UI, btn);
|
|
|
|
Color bgColor = canAfford ? DARKBROWN : MAROON;
|
|
if (*selected || inter.hovering)
|
|
bgColor = canAfford ? BROWN : RED;
|
|
if (inter.clicked && canAfford)
|
|
*selected = true;
|
|
if (hovered)
|
|
*hovered = inter.hovering;
|
|
|
|
bzUISetBackgroundStyle(UI, btn, (BzUIBackgroundStyle) {
|
|
.roundness = 0.2f,
|
|
.active = bgColor,
|
|
.normal = bgColor,
|
|
.hover = bgColor,
|
|
});
|
|
bzUISetBorderStyle(UI, btn, (BzUIBorderStyle) {
|
|
.roundness = 0.2f,
|
|
.thickness = 5.0f * scl,
|
|
.normal = BLACK,
|
|
.hover = BLACK,
|
|
.active = BLACK,
|
|
});
|
|
bzUIPushParent(UI, btn);
|
|
bzUISetParentLayout(UI, (BzUILayout) {
|
|
.type = BZ_UI_LAYOUT_FLEX_BOX,
|
|
.flags = BZ_UI_FLEX_DIR_COLUMN | BZ_UI_FLEX_ALIGN_CENTER | BZ_UI_FLEX_JUSTIFY_START
|
|
});
|
|
|
|
BzUINode *tileSprite = bzUINodeMake(UI, bzUIGetUniqueKey(UI), &(BzUINodeDesc) {
|
|
.flags = BZ_UI_DRAW_SPRITE,
|
|
.semanticSize[BZ_UI_AXIS_X] = {BZ_UI_SIZE_PIXELS, rec.width * 5 * scl},
|
|
.semanticSize[BZ_UI_AXIS_Y] = {BZ_UI_SIZE_PIXELS, rec.height * 5 * scl},
|
|
});
|
|
bzUISetSpriteStyle(UI, tileSprite, (BzUISpriteStyle) {
|
|
.texture = tex,
|
|
.rec = rec,
|
|
.tintNormal = WHITE,
|
|
.tintHover = WHITE,
|
|
.tintActive = WHITE,
|
|
});
|
|
|
|
BzUINode *labelDisplay = bzUINodeMake(UI, bzUIGetUniqueKey(UI), &(BzUINodeDesc) {
|
|
.flags = BZ_UI_DRAW_TEXT | BZ_UI_DRAW_TEXT_SHADOW,
|
|
.semanticSize[BZ_UI_AXIS_X] = {BZ_UI_SIZE_FIT},
|
|
.semanticSize[BZ_UI_AXIS_Y] = {BZ_UI_SIZE_FIT},
|
|
});
|
|
bzUISetTextStyle(UI, labelDisplay, (BzUITextStyle) {
|
|
.font = getFont(),
|
|
.fontSize = 25.0f * scl,
|
|
.fontSpacing = 1.0f * scl,
|
|
.normal = WHITE,
|
|
.hover = WHITE,
|
|
.active = WHITE,
|
|
.text = label
|
|
});
|
|
bzUISetTextShadowStyle(UI, labelDisplay, (BzUITextShadowStyle) {
|
|
.offset = {1.0f * scl, 1.0f * scl},
|
|
.normal = BLACK,
|
|
.hover = BLACK,
|
|
.active = BLACK
|
|
});
|
|
|
|
bzUIPopParent(UI);
|
|
}
|
|
bool uiGameTrade(const char *label, Rectangle rec, Texture2D tex, bool canAfford) {
|
|
bool selected = false;
|
|
uiGameBuild(label, rec, tex, canAfford, &selected, NULL);
|
|
return selected;
|
|
}
|
|
bool uiGameUnit(const char *label, i32 count, Rectangle rec, Texture2D tex) {
|
|
if (rec.height > 16)
|
|
rec.y += 16;
|
|
rec.height = rec.width;
|
|
f32 scl = uiGetScale();
|
|
BzUINode *btn = bzUINodeMake(UI, bzUIKeyFromString(label), &(BzUINodeDesc) {
|
|
.flags = BZ_UI_CLICKABLE | BZ_UI_ALIGN_CENTER | BZ_UI_DRAW_BORDER,
|
|
.margin[BZ_UI_AXIS_X] = 10.0f * scl,
|
|
.margin[BZ_UI_AXIS_Y] = 10.0f * scl,
|
|
.margin[BZ_UI_AXIS_Y * 2] = 10.0f * scl,
|
|
.semanticSize[BZ_UI_AXIS_X] = {BZ_UI_SIZE_CHILD_MAX},
|
|
.semanticSize[BZ_UI_AXIS_Y] = {BZ_UI_SIZE_CHILD_SUM},
|
|
});
|
|
|
|
BzUIInteraction inter = bzUIGetInteraction(UI, btn);
|
|
|
|
Color bgColor = DARKBROWN;
|
|
if (inter.hovering)
|
|
bgColor = BROWN;
|
|
|
|
bzUISetBackgroundStyle(UI, btn, (BzUIBackgroundStyle) {
|
|
.roundness = 0.2f,
|
|
.active = bgColor,
|
|
.normal = bgColor,
|
|
.hover = bgColor,
|
|
});
|
|
bzUISetBorderStyle(UI, btn, (BzUIBorderStyle) {
|
|
.roundness = 0.2f,
|
|
.thickness = 5.0f * scl,
|
|
.normal = BLACK,
|
|
.hover = BLACK,
|
|
.active = BLACK,
|
|
});
|
|
bzUIPushParent(UI, btn);
|
|
bzUISetParentLayout(UI, (BzUILayout) {
|
|
.type = BZ_UI_LAYOUT_FLEX_BOX,
|
|
.flags = BZ_UI_FLEX_DIR_COLUMN | BZ_UI_FLEX_ALIGN_CENTER | BZ_UI_FLEX_JUSTIFY_START
|
|
});
|
|
|
|
BzUINode *tileSprite = bzUINodeMake(UI, bzUIGetUniqueKey(UI), &(BzUINodeDesc) {
|
|
.flags = BZ_UI_DRAW_SPRITE,
|
|
.semanticSize[BZ_UI_AXIS_X] = {BZ_UI_SIZE_PIXELS, rec.width * 5 * scl},
|
|
.semanticSize[BZ_UI_AXIS_Y] = {BZ_UI_SIZE_PIXELS, rec.height * 5 * scl},
|
|
});
|
|
bzUISetSpriteStyle(UI, tileSprite, (BzUISpriteStyle) {
|
|
.texture = tex,
|
|
.rec = rec,
|
|
.tintNormal = WHITE,
|
|
.tintHover = WHITE,
|
|
.tintActive = WHITE,
|
|
});
|
|
|
|
BzUINode *labelDisplay = bzUINodeMake(UI, bzUIGetUniqueKey(UI), &(BzUINodeDesc) {
|
|
.flags = BZ_UI_DRAW_TEXT | BZ_UI_DRAW_TEXT_SHADOW,
|
|
.semanticSize[BZ_UI_AXIS_X] = {BZ_UI_SIZE_FIT},
|
|
.semanticSize[BZ_UI_AXIS_Y] = {BZ_UI_SIZE_FIT},
|
|
});
|
|
char buf[128];
|
|
snprintf(buf, sizeof(buf), "%d", count);
|
|
bzUISetTextStyle(UI, labelDisplay, (BzUITextStyle) {
|
|
.font = getFont(),
|
|
.fontSize = 25.0f * scl,
|
|
.fontSpacing = 1.0f * scl,
|
|
.normal = WHITE,
|
|
.hover = WHITE,
|
|
.active = WHITE,
|
|
.text = buf
|
|
});
|
|
bzUISetTextShadowStyle(UI, labelDisplay, (BzUITextShadowStyle) {
|
|
.offset = {1.0f * scl, 1.0f * scl},
|
|
.normal = BLACK,
|
|
.hover = BLACK,
|
|
.active = BLACK
|
|
});
|
|
|
|
bzUIPopParent(UI);
|
|
return inter.clicked;
|
|
}
|
|
|
|
void uiGameTooltipCost(Vector2 pos, i32 costs[RES_COUNT], Texture2D tex) {
|
|
char text[RES_COUNT][32];
|
|
for (i32 i = 0; i < RES_COUNT; i++) {
|
|
snprintf(text[i], sizeof(text[i]), "%d", BZ_ABS(costs[i]));
|
|
}
|
|
|
|
Vector2 offset = pos;
|
|
const f32 fontSize = 32 * uiGetScale();
|
|
const f32 margin = 10 * uiGetScale();
|
|
offset.x += margin * 0.5f;
|
|
offset.y -= margin;
|
|
for (i32 i = 0; i < RES_COUNT; i++) {
|
|
EntityType entity = ENTITY_NONE;
|
|
switch (i) {
|
|
case RES_FOOD:
|
|
entity = ENTITY_APPLE;
|
|
break;
|
|
case RES_WOOD:
|
|
entity = ENTITY_WOOD;
|
|
break;
|
|
case RES_GOLD:
|
|
entity = ENTITY_GOLD;
|
|
break;
|
|
}
|
|
if (entity == ENTITY_NONE) continue;
|
|
if (costs[i] == 0) continue;
|
|
|
|
Vector2 size = MeasureTextEx(getFont(), text[i], fontSize, 1.0f);
|
|
Rectangle rec = getTextureRect(getEntityTile(entity));
|
|
DrawText(text[i], offset.x, offset.y, fontSize, WHITE);
|
|
const f32 texSize = size.y;
|
|
offset.x += size.x + margin * 0.8f;
|
|
DrawTexturePro(tex, rec, (Rectangle) {
|
|
offset.x, offset.y,
|
|
texSize, texSize
|
|
}, (Vector2) { 0, 0 }, 0.0f, WHITE);
|
|
offset.x += texSize + margin;
|
|
}
|
|
}
|