Skip to content

Free games for graphing calculators: NumWorks, TI-Nspire CX, Casio fx-CG50 and soon TI-84 Plus CE. Balatro, Celeste, Hollow Knight, Minecraft and more.

18.2 KB
Raw Blame
/* The Final Earth 2: drawing the user interface (the original's
 * gui.NinePatch, graphics.BitmapText, gui.MaterialsCostDisplay and
 * gui.IconListDisplay), as a list of primitives drawn by one band function,
 * and the texts' numbers (common.Localize.lo, MathExtensions). */
#include <math.h>
#include "uii.h"

UiFrame *uf;

/* the original's 9-patches: each is a 1-pixel border round a fill (colours and alphas from its sprite) */
/* rgb565_near, as a constant */
#define NEAR565(c) ((uint16_t)(((((c) >> 16 & 255) * 31 + 127) / 255) << 11 | ((((c) >> 8 & 255) * 63 + 127) / 255) << 5 | \
                               (((c) & 255) * 31 + 127) / 255))
#define BOX(b, f, ba, fa) {NEAR565(b), NEAR565(f), ba, fa}
const Box boxes[BX_COUNT] = {
  [BX_WINDOW] = BOX(0x000000, 0xFFFFFF, 255, 180),
  [BX_WINDOW_OPAQUE] = BOX(0x000000, 0xF4F4F4, 255, 250),
  [BX_TOOLTIP] = BOX(0x969696, 0xF2F2F2, 230, 230),
  [BX_INFO] = BOX(0x000000, 0xFFFFFF, 255, 180),
  [BX_HINTINFO] = BOX(0x4D9600, 0xC3FF7F, 230, 230),
  [BX_ACTIVE] = BOX(0x94BA8D, 0xFFFFFF, 255, 255),
  [BX_DISABLED] = BOX(0xDBDBDB, 0xFFFFFF, 255, 255),
  [BX_BUTTON] = BOX(0x000000, 0xFFFFFF, 255, 255),
  [BX_BUTTON_HOVER] = BOX(0x7F7F7F, 0xFFFFFF, 255, 255),
  [BX_BUTTON_DOWN] = BOX(0xBCBCBC, 0xFFFFFF, 255, 255),
  [BX_TRANS] = BOX(0x000000, 0xFFFFFF, 255, 180),
  [BX_TRANS_HOVER] = BOX(0x969696, 0xFFFFFF, 255, 180),
  [BX_TRANS_DOWN] = BOX(0xFFFFFF, 0xFFFFFF, 255, 180),
  [BX_BLD] = BOX(0x000000, 0xFFFFFF, 255, 128),
  [BX_BLD_HOVER] = BOX(0x7F7F7F, 0xFFFFFF, 255, 128),
  [BX_BLD_DOWN] = BOX(0xFFFFFF, 0xFFFFFF, 255, 128),
  [BX_TRANSB] = BOX(0x000000, 0xFFFFFF, 255, 128),
  [BX_TRANSB_HOVER] = BOX(0x969696, 0xFFFFFF, 255, 128),
  [BX_TRANSB_DOWN] = BOX(0xFFFFFF, 0xFFFFFF, 255, 128),
  [BX_CHECKED] = BOX(0x94BA8D, 0xFFFFFF, 255, 255),
  [BX_CHECKED_HOVER] = BOX(0xB6CCB1, 0xFFFFFF, 255, 255),
  [BX_CHECKED_DOWN] = BOX(0xD8E2D5, 0xFFFFFF, 255, 255),
  [BX_ACTIVABLE] = BOX(0x000000, 0xFFFFFF, 255, 255),
  [BX_ACTIVABLE_HOVER] = BOX(0x7F7F7F, 0xFFFFFF, 255, 255),
  [BX_ACTIVABLE_DOWN] = BOX(0x94BA8D, 0xFFFFFF, 255, 255),
  [BX_GRAY] = BOX(0x404040, 0xE0E0E0, 255, 255),
  [BX_GRAY_HOVER] = BOX(0x7F7F7F, 0xE0E0E0, 255, 255),
  [BX_GRAY_DOWN] = BOX(0xBCBCBC, 0xE0E0E0, 255, 255),
  [BX_SCROLL] = BOX(0x000000, 0x000000, 255, 0),
  [BX_HANDLE] = BOX(0x000000, 0xFFFFFF, 255, 255),
};

/* ---------------------------------------------------------------- the list */
static UiPrim *prim(uint8_t kind, int x, int y, int w, int h) {
  if (!uf) return NULL;
  if (kind != PR_CLIP) {
    /* outside the clip: nothing to draw (text: its line, give or take) */
    int y0 = y, y1 = y + h;
    if (kind == PR_TEXT) y0 -= 4, y1 += 4;
    if (y1 <= uf->cy0 || y0 >= uf->cy1 || x >= uf->cx1 || x + w <= uf->cx0) return NULL;
  }
  if (uf->n >= UI_PRIMS) {
    uf->dropped++;
    return NULL;
  }
  UiPrim *p = &uf->p[uf->n++];
  memset(p, 0, sizeof *p);
  p->kind = kind;
  p->x = (int16_t)x;
  p->y = (int16_t)y;
  p->w = (int16_t)w;
  p->h = (int16_t)h;
  p->a1 = p->a2 = 255;
  return p;
}

void ui_clip(int x, int y, int w, int h) {
  if (!uf) return;
  int x1 = x + w, y1 = y + h;
  if (x < 0) x = 0;
  if (y < 0) y = 0;
  if (x1 > SCREEN_W) x1 = SCREEN_W;
  if (y1 > SCREEN_H) y1 = SCREEN_H;
  if (uf->n && uf->p[uf->n - 1].kind == PR_CLIP) uf->n--;   /* a clip nothing used */
  uf->cx0 = (int16_t)x, uf->cy0 = (int16_t)y, uf->cx1 = (int16_t)x1, uf->cy1 = (int16_t)y1;
  prim(PR_CLIP, x, y, x1 - x, y1 - y);
}
void ui_noclip(void) { ui_clip(0, 0, SCREEN_W, SCREEN_H); }

void ui_rect(int x, int y, int w, int h, uint16_t c, uint8_t a) {
  if (w <= 0 || h <= 0 || !a) return;
  UiPrim *p = prim(PR_RECT, x, y, w, h);
  if (p) p->c1 = c, p->a1 = a;
}

void ui_box(int x, int y, int w, int h, int box) {
  if (w <= 0 || h <= 0) return;
  UiPrim *p = prim(PR_BOX, x, y, w, h);
  if (!p) return;
  const Box *b = &boxes[box];
  p->c1 = b->border, p->c2 = b->fill, p->a1 = b->ba, p->a2 = b->fa;
}

/* a box added now (so it is under what follows) whose height comes later; never culled */
UiPrim *ui_box_later(int x, int y, int w, int box) {
  if (!uf || uf->n >= UI_PRIMS) {
    if (uf) uf->dropped++;
    return NULL;
  }
  UiPrim *p = &uf->p[uf->n++];
  memset(p, 0, sizeof *p);
  p->kind = PR_BOX;
  p->x = (int16_t)x, p->y = (int16_t)y, p->w = (int16_t)w, p->h = 0;
  const Box *b = &boxes[box];
  p->c1 = b->border, p->c2 = b->fill, p->a1 = b->ba, p->a2 = b->fa;
  return p;
}

void ui_spr_ex(uint16_t spr, int sx, int sy, int w, int h, int x, int y, uint8_t flags, uint8_t alpha, uint16_t tint) {
  if (!spr || w <= 0 || h <= 0 || !alpha) return;
  UiPrim *p = prim(PR_SPR, x, y, w, h);
  if (!p) return;
  p->c1 = spr, p->c2 = tint, p->a1 = alpha, p->f = flags;
  p->u.part.sx = (int16_t)sx, p->u.part.sy = (int16_t)sy;
}
void ui_spr(uint16_t spr, int x, int y) { ui_spr_ex(spr, 0, 0, spr_w(spr), spr_h(spr), x, y, 0, 255, GFX_NO_TINT); }
void ui_keys(int x, int y, int cw, int h, const char *chars, int n, int focused, bool down) {
  if (!uf || uf->ntext + n > UI_TEXT) {
    if (uf) uf->dropped++;
    return;
  }
  UiPrim *p = prim(PR_KEYS, x, y, cw * n, h);
  if (!p) return;
  memcpy(uf->text + uf->ntext, chars, (size_t)n);
  p->u.s = uf->text + uf->ntext;
  uf->ntext += n;
  p->f = (uint8_t)n, p->a1 = (uint8_t)cw, p->a2 = (uint8_t)focused, p->c1 = down;
}
void ui_ring(int x, int y, int w, int h, int t, uint16_t c) {
  ui_rect(x - t, y - t, w + 2 * t, t, c, 255);
  ui_rect(x - t, y + h, w + 2 * t, t, c, 255);
  ui_rect(x - t, y, t, h, c, 255);
  ui_rect(x + w, y, t, h, c, 255);
}
void ui_spr_small(uint16_t spr, int x, int y) {
  UiPrim *p = prim(PR_SPR_SMALL, x, y, (spr_w(spr) * 3 + 4) / 5, (spr_h(spr) * 3 + 4) / 5);
  if (p) p->c1 = spr;
}
void ui_frame(uint16_t spr, int fw, int i, int x, int y, uint8_t flags, uint8_t alpha) {
  ui_spr_ex(spr, (fw + 2) * i, 0, fw, spr_h(spr), x, y, flags, alpha, GFX_NO_TINT);
}

int ui_text_n(uint8_t font, int x, int y, const char *s, int n, uint16_t color, uint8_t alpha, bool keep) {
  if (!s) return 0;
  if (n < 0) n = (int)strlen(s);
  int w = gfx_text_width_n(font, s, n);
  if (!n || !uf) return w;
  UiPrim *p = prim(PR_TEXT, x, y, w, ui_line_h(font));
  if (!p) return w;
  if (!keep) {
    if (uf->ntext + n > UI_TEXT) {
      uf->dropped++;
      uf->n--;
      return w;
    }
    memcpy(uf->text + uf->ntext, s, (size_t)n);
    s = uf->text + uf->ntext;
    uf->ntext += n;
  }
  p->u.s = s;
  p->w = (int16_t)n;
  p->f = font;
  p->c1 = color;
  p->a1 = alpha;
  return w;
}

void ui_text_rot(uint8_t font, int x, int y, const char *s, uint16_t color) {
  int n = (int)strlen(s), w = gfx_text_width(font, s);
  UiPrim *p = prim(PR_TEXTROT, x - ui_line_h(font) - 4, y, ui_line_h(font) + 8, w);
  if (!p || uf->ntext + n > UI_TEXT) {
    if (p) uf->n--, uf->dropped++;
    return;
  }
  memcpy(uf->text + uf->ntext, s, (size_t)n);
  p->u.s = uf->text + uf->ntext;
  uf->ntext += n;
  p->x = (int16_t)x, p->w = (int16_t)n, p->f = font, p->c1 = color;
}

int ui_text_w(uint8_t font, const char *s) { return s ? gfx_text_width(font, s) : 0; }

int ui_para(uint8_t font, int x, int y, int max_w, const char *s, uint16_t color, bool keep, int *width) {
  int lh = ui_line_h(font), h = 0, widest = 0;
  if (!s) s = "";
  const char *p = s;
  do {
    int lw;
    const char *next;
    int n = gfx_text_wrap(font, p, max_w, &lw, &next);
    if (y != INT16_MIN) ui_text_n(font, x, y + h, p, n, color, 255, keep);
    if (lw > widest) widest = lw;
    h += lh;
    p = next;
  } while (*p);
  if (width) *width = widest;
  return h;
}

const char *ui_color_prefix(const char *s, uint16_t *color) {
  if (!s) return "";
  if (!strncmp(s, "[red]", 5)) return *color = C_RED, s + 5;
  if (!strncmp(s, "[blue]", 6)) return *color = C_BLUE, s + 6;
  if (!strncmp(s, "[green]", 7)) return *color = C_GREEN, s + 7;
  if (!strncmp(s, "[white]", 7)) return *color = C_WHITE, s + 7;
  return s;
}

/* ---------------------------------------------------------------- the band function */
static void draw_box(const GfxBand *b, const UiPrim *p) {
  int x0 = p->x, x1 = p->x + p->w, y0 = p->y, y1 = p->y + p->h;
  for (int y = y0 > b->cy0 ? y0 : b->cy0; y < y1 && y < b->cy1; y++) {
    if (y == y0 || y == y1 - 1) {
      gfx_band_span(b, y, x0, x1, p->c1, p->a1);
    } else {
      gfx_band_span(b, y, x0, x0 + 1, p->c1, p->a1);
      gfx_band_span(b, y, x0 + 1, x1 - 1, p->c2, p->a2);
      gfx_band_span(b, y, x1 - 1, x1, p->c1, p->a1);
    }
  }
}

/* PR_SPR_SMALL: row by row, the sprite's row (5/3 as far down) is drawn over what is under its pixels, then each
 * screen pixel takes the nearest of them */
static void draw_small(const GfxBand *b, const UiPrim *p) {
  int sw = spr_w(p->c1), sh = spr_h(p->c1);
  if (sw > SCREEN_W) return;
  uint16_t line[SCREEN_W];
  GfxBand one = {line, 0, 1, 0, 0, sw, 1, 1};
  int x0 = p->x > b->cx0 ? p->x : b->cx0, x1 = p->x + p->w < b->cx1 ? p->x + p->w : b->cx1;
  for (int y = p->y > b->cy0 ? p->y : b->cy0; y < p->y + p->h && y < b->cy1; y++) {
    int sy = (y - p->y) * 5 / 3;
    if (sy >= sh || x0 >= x1) continue;
    uint16_t *row = b->px + (y - b->y0) * SCREEN_W;
    for (int sx = 0; sx < sw; sx++) {
      int dx = p->x + sx * 3 / 5;
      line[sx] = dx >= 0 && dx < SCREEN_W ? row[dx] : 0;
    }
    gfx_band_sprite(&one, p->c1, 0, sy, sw, 1, 0, 0, 0, 255, GFX_NO_TINT);
    for (int x = x0; x < x1; x++) row[x] = line[(x - p->x) * 5 / 3 < sw ? (x - p->x) * 5 / 3 : sw - 1];
  }
}

/* PR_KEYS: each key a button (spr_button's normal, hover or down 9-patch) round its character */
static void draw_keys(const GfxBand *b, const UiPrim *p) {
  for (int i = 0; i < p->f; i++) {
    UiPrim k = *p;
    int box = i == p->a2 ? (p->c1 ? BX_BUTTON_DOWN : BX_BUTTON_HOVER) : BX_BUTTON;
    k.x = (int16_t)(p->x + i * p->a1), k.w = p->a1;
    k.c1 = boxes[box].border, k.c2 = boxes[box].fill, k.a1 = boxes[box].ba, k.a2 = boxes[box].fa;
    draw_box(b, &k);
    int tw = gfx_text_width_n(FONT_STANDARD, p->u.s + i, 1);
    gfx_band_text(b, FONT_STANDARD, k.x + (p->a1 - tw) / 2, p->y + 1, p->u.s + i, 1, C_BLACK, 255, false);
  }
}

static void ui_band(const GfxBand *band, void *ctx) {
  UiFrame *f = ctx;
  GfxBand b = *band;
  for (int i = 0; i < f->n; i++) {
    const UiPrim *p = &f->p[i];
    if (p->kind == PR_CLIP) {
      b.cx0 = p->x > band->cx0 ? p->x : band->cx0;
      b.cx1 = p->x + p->w < band->cx1 ? p->x + p->w : band->cx1;
      b.cy0 = p->y > band->cy0 ? p->y : band->cy0;
      b.cy1 = p->y + p->h < band->cy1 ? p->y + p->h : band->cy1;
      continue;
    }
    if (b.cy0 >= b.cy1 || b.cx0 >= b.cx1) continue;
    switch (p->kind) {
    case PR_RECT:
      if (p->y + p->h <= b.cy0 || p->y >= b.cy1) break;
      for (int y = p->y > b.cy0 ? p->y : b.cy0; y < p->y + p->h && y < b.cy1; y++)
        gfx_band_span(&b, y, p->x, p->x + p->w, p->c1, p->a1);
      break;
    case PR_BOX:
      if (p->y + p->h <= b.cy0 || p->y >= b.cy1) break;
      draw_box(&b, p);
      break;
    case PR_SPR:
      if (p->y + p->h <= b.cy0 || p->y >= b.cy1) break;
      gfx_band_sprite(&b, p->c1, p->u.part.sx, p->u.part.sy, p->w, p->h, p->x, p->y, p->f, p->a1, p->c2);
      break;
    case PR_TEXT:
      if (p->y + p->h + 6 <= b.cy0 || p->y - 6 >= b.cy1) break;
      gfx_band_text(&b, p->f, p->x, p->y, p->u.s, p->w, p->c1, p->a1, false);
      break;
    case PR_TEXTROT:
      if (p->y + p->h <= b.cy0 || p->y >= b.cy1) break;
      gfx_band_text(&b, p->f, p->x, p->y, p->u.s, p->w, p->c1, 255, true);
      break;
    case PR_SPR_SMALL:
      if (p->y + p->h <= b.cy0 || p->y >= b.cy1) break;
      draw_small(&b, p);
      break;
    case PR_KEYS:
      if (p->y + p->h + 6 <= b.cy0 || p->y - 6 >= b.cy1) break;
      draw_keys(&b, p);
      break;
    }
  }
}

void ui_frame_begin(UiFrame *f) {
  f->n = f->ntext = f->dropped = 0;
  f->tip.on = false;
  f->cx0 = f->cy0 = 0;
  f->cx1 = SCREEN_W, f->cy1 = SCREEN_H;
  uf = f;
}

int ui_peak_prims, ui_peak_text, ui_dropped_total;   /* for the tests */
int ui_redraws;   /* windows laid out again in the frame they changed size (tests) */

void ui_frame_end(void) {
  if (!uf) return;
  if (uf->n > ui_peak_prims) ui_peak_prims = uf->n;
  if (uf->ntext > ui_peak_text) ui_peak_text = uf->ntext;
  ui_dropped_total += uf->dropped;
  if (uf->n) {
    gfx_zoom(1);
    gfx_clip(0, 0, SCREEN_W, SCREEN_H);
    gfx_call(ui_band, uf, 0, SCREEN_H);
  }
}

/* ---------------------------------------------------------------- numbers and texts */
int fmt_int(char *out, int size, long v) {
  char tmp[24];
  int n = 0;
  unsigned long u = v < 0 ? (unsigned long)-v : (unsigned long)v;
  do tmp[n++] = (char)('0' + u % 10), u /= 10;
  while (u);
  if (v < 0) tmp[n++] = '-';
  int k = 0;
  while (n && k < size - 1) out[k++] = tmp[--n];
  out[k] = 0;
  return k;
}

/* String(v) for the numbers the interface shows: integers, or up to 6 decimals (trailing zeros dropped) */
int fmt_num(char *out, int size, double v) {
  if (v != v) v = 0;
  bool neg = v < 0;
  if (neg) v = -v;
  double ip = floor(v);
  long frac = (long)((v - ip) * 1e6 + 0.5);
  if (frac >= 1000000) ip += 1, frac = 0;
  char tmp[40];
  int n = 0;
  if (neg && (ip > 0 || frac > 0)) tmp[n++] = '-';
  n += fmt_int(tmp + n, (int)sizeof tmp - n, ip > 2e9 ? 2000000000L : (long)ip);
  if (frac > 0) {
    char fd[7];
    for (int i = 5; i >= 0; i--) fd[i] = (char)('0' + frac % 10), frac /= 10;
    int last = 5;
    while (last >= 0 && fd[last] == '0') last--;
    tmp[n++] = '.';
    for (int i = 0; i <= last; i++) tmp[n++] = fd[i];
  }
  tmp[n] = 0;
  int k = 0;
  for (; k < n && k < size - 1; k++) out[k] = tmp[k];
  out[k] = 0;
  return k;
}

/* MathExtensions.floatFormat: v with at most that many decimals, as JavaScript shows it */
int ui_float_fmt(char *out, int size, double v, int decimals) {
  double m = pow(10, decimals);
  return fmt_num(out, size, round(v * m) / m);
}

/* MathExtensions.largeNumberFormat(Alt): thousands and millions shortened */
int fmt_large(char *out, int size, double v, bool alt) {
  char num[24];
  const char *suffix = "";
  if (v >= 1e6) v = (alt ? floor(v / 1e5) : floor(v / 1e5)) / 10, suffix = "M";
  else if (v >= 1e4) v = floor(v / 100) / 10, suffix = "k";
  fmt_num(num, sizeof num, v);
  out[0] = 0;
  str_cat(out, size, num);
  return (int)strlen(str_cat(out, size, suffix));
}

char *str_cat(char *dst, int size, const char *src) {
  int n = (int)strlen(dst);
  while (src && *src && n < size - 1) dst[n++] = *src++;
  dst[n] = 0;
  return dst;
}

const char *lo(char *buf, int size, const char *text, int n, const LoArg *args) {
  int o = 0;
  if (!text) text = "";
  for (const char *s = text; *s && o < size - 1;) {
    if (s[0] == '[' && s[1] >= '0' && s[1] <= '9' && s[2] == ']' && s[1] - '0' < n) {
      const LoArg *a = &args[s[1] - '0'];
      if (a->s) {
        for (const char *t = a->s; *t && o < size - 1;) buf[o++] = *t++;
      } else {
        o += fmt_num(buf + o, size - o, a->v);
      }
      s += 3;
    } else {
      buf[o++] = *s++;
    }
  }
  buf[o] = 0;
  return buf;
}
const char *lo_1(char *buf, int size, const char *text, LoArg a) { return lo(buf, size, text, 1, &a); }
const char *lo_2(char *buf, int size, const char *text, LoArg a, LoArg b) {
  LoArg v[2] = {a, b};
  return lo(buf, size, text, 2, v);
}
const char *lo_3(char *buf, int size, const char *text, LoArg a, LoArg b, LoArg c) {
  LoArg v[3] = {a, b, c};
  return lo(buf, size, text, 3, v);
}

/* ---------------------------------------------------------------- materials */
const uint16_t mat_icon[M_COUNT] = {
  [M_FOOD] = SPR_RESOURCE_FOOD, [M_WOOD] = SPR_RESOURCE_WOOD, [M_STONE] = SPR_RESOURCE_STONE,
  [M_MACHINEPARTS] = SPR_RESOURCE_MACHINEPARTS, [M_REFINEDMETAL] = SPR_RESOURCE_REFINEDMETAL,
  [M_COMPUTERCHIPS] = SPR_RESOURCE_COMPUTERCHIPS, [M_GRAPHENE] = SPR_RESOURCE_GRAPHENE,
  [M_ROCKETFUEL] = SPR_RESOURCE_ROCKETFUEL, [M_KNOWLEDGE] = SPR_RESOURCE_KNOWLEDGE,
};
/* lo(name): as the original names them in its texts */
const char *const mat_lname[M_COUNT] = {
  [M_FOOD] = L_food, [M_WOOD] = L_wood, [M_STONE] = L_stone, [M_MACHINEPARTS] = L_machine_parts,
  [M_REFINEDMETAL] = L_refined_metals, [M_COMPUTERCHIPS] = L_computer_chips, [M_CACAO] = "cacao",
  [M_CHOCOLATE] = "chocolate", [M_GRAPHENE] = L_graphene, [M_ROCKETFUEL] = L_rocketFuel, [M_KNOWLEDGE] = L_knowledge,
};
/* firstToUpper(lo(name)) */
const char *mat_title(int m, char *buf, int size) {
  buf[0] = 0;
  str_cat(buf, size, mat_lname[m]);
  if (buf[0] >= 'a' && buf[0] <= 'z') buf[0] = (char)(buf[0] - 32);
  return buf;
}

/* MaterialsCostDisplay.updateCostDisplay: food, wood, stone, machine parts, refined metal, computer chips,
 * graphene, rocket fuel, then knowledge (with the texts around it) */
int ui_cost(int x, int y, const float cost[M_COUNT], const char *before_k, const char *after_k, bool city_red) {
  static const uint8_t order[] = {M_FOOD, M_WOOD, M_STONE, M_MACHINEPARTS, M_REFINEDMETAL, M_COMPUTERCHIPS, M_CACAO,
                                  M_CHOCOLATE, M_GRAPHENE, M_ROCKETFUEL, M_KNOWLEDGE};
  bool draw = y != INT16_MIN;
  int xx = 0;
  bool any_before = false, shown_before_k = false;
  char num[48];
  if (!before_k) before_k = "";
  for (unsigned k = 0; k < sizeof order; k++) {
    int m = order[k];
    if (cost[m] <= 0) continue;
    if (m == M_KNOWLEDGE && *before_k && any_before) {
      if (draw) ui_text(FONT_STANDARD, x + xx, y - 1, before_k, C_BLACK);
      xx += ui_text_w(FONT_STANDARD, before_k) + 3;
      shown_before_k = true;
    }
    if (m == M_FOOD) xx -= 2;
    any_before = true;
    if (draw) ui_spr(mat_icon[m], x + xx, y);
    xx += 10 + 1;
    if (m == M_FOOD) xx -= 2;
    fmt_num(num, sizeof num, cost[m]);
    if (m == M_KNOWLEDGE && after_k) str_cat(num, sizeof num, after_k);
    bool red = city_red && city.materials.m[m] < cost[m];
    if (draw) ui_text(FONT_STANDARD, x + xx, y - 1, num, red ? C_RED : C_BLACK);
    xx += ui_text_w(FONT_STANDARD, num) + 3;
  }
  if (!shown_before_k && *before_k) {
    if (draw) ui_text(FONT_STANDARD, x + xx, y - 1, before_k, C_BLACK);
    xx += ui_text_w(FONT_STANDARD, before_k) + 3;
  }
  return xx;
}

int ui_icon_list(int x, int y, const IconText *it, int n) {
  int xx = 0;
  bool draw = y != INT16_MIN;
  for (int i = 0; i < n; i++) {
    if (draw) ui_spr(it[i].spr, x + xx, y);
    xx += spr_w(it[i].spr) + 2;
    uint16_t col = C_BLACK;
    const char *t = ui_color_prefix(it[i].text, &col);
    bool one = !strcmp(t, "1");
    if (one) xx--;
    if (draw) ui_text(FONT_STANDARD, x + xx, y - 1, t, col);
    if (one) xx--;
    xx += ui_text_w(FONT_STANDARD, t) + 3;
  }
  return xx;
}