gemba 0.1.1 → 0.2.0

data/vendor/rcheevos/src/rcheevos/format.c

@@ -0,0 +1,330 @@
+#include "rc_internal.h"
+
+#include "../rc_compat.h"
+
+#include <string.h>
+#include <stdio.h>
+#include <ctype.h>
+
+int rc_parse_format(const char* format_str) {
+  switch (*format_str++) {
+    case 'F':
+      if (!strcmp(format_str, "RAMES")) {
+        return RC_FORMAT_FRAMES;
+      }
+      if (!strncmp(format_str, "LOAT", 4) && format_str[4] >= '1' && format_str[4] <= '6' && format_str[5] == '\0') {
+        return RC_FORMAT_FLOAT1 + (format_str[4] - '1');
+      }
+      if (!strncmp(format_str, "IXED", 4) && format_str[4] >= '1' && format_str[4] <= '3' && format_str[5] == '\0') {
+        return RC_FORMAT_FIXED1 + (format_str[4] - '1');
+      }
+
+      break;
+
+    case 'T':
+      if (!strcmp(format_str, "IME")) {
+        return RC_FORMAT_FRAMES;
+      }
+      if (!strcmp(format_str, "IMESECS")) {
+        return RC_FORMAT_SECONDS;
+      }
+      if (!strcmp(format_str, "HOUSANDS")) {
+        return RC_FORMAT_THOUSANDS;
+      }
+      if (!strcmp(format_str, "ENS")) {
+        return RC_FORMAT_TENS;
+      }
+
+      break;
+
+    case 'S':
+      if (!strcmp(format_str, "ECS")) {
+        return RC_FORMAT_SECONDS;
+      }
+      if (!strcmp(format_str, "CORE")) {
+        return RC_FORMAT_SCORE;
+      }
+      if (!strcmp(format_str, "ECS_AS_MINS")) {
+        return RC_FORMAT_SECONDS_AS_MINUTES;
+      }
+
+      break;
+
+    case 'M':
+      if (!strcmp(format_str, "ILLISECS")) {
+        return RC_FORMAT_CENTISECS;
+      }
+      if (!strcmp(format_str, "INUTES")) {
+        return RC_FORMAT_MINUTES;
+      }
+
+      break;
+
+    case 'P':
+      if (!strcmp(format_str, "OINTS")) {
+        return RC_FORMAT_SCORE;
+      }
+
+      break;
+
+    case 'V':
+      if (!strcmp(format_str, "ALUE")) {
+        return RC_FORMAT_VALUE;
+      }
+
+      break;
+
+    case 'U':
+      if (!strcmp(format_str, "NSIGNED")) {
+        return RC_FORMAT_UNSIGNED_VALUE;
+      }
+
+      break;
+
+    case 'O':
+      if (!strcmp(format_str, "THER")) {
+        return RC_FORMAT_SCORE;
+      }
+
+      break;
+
+    case 'H':
+      if (!strcmp(format_str, "UNDREDS")) {
+        return RC_FORMAT_HUNDREDS;
+      }
+
+      break;
+  }
+
+  return RC_FORMAT_VALUE;
+}
+
+static int rc_format_value_minutes(char* buffer, size_t size, uint32_t minutes) {
+  uint32_t hours;
+
+    hours = minutes / 60;
+    minutes -= hours * 60;
+    return snprintf(buffer, size, "%uh%02u", hours, minutes);
+}
+
+static int rc_format_value_seconds(char* buffer, size_t size, uint32_t seconds) {
+  uint32_t hours, minutes;
+
+  /* apply modulus math to split the seconds into hours/minutes/seconds */
+  minutes = seconds / 60;
+  seconds -= minutes * 60;
+  if (minutes < 60) {
+    return snprintf(buffer, size, "%u:%02u", minutes, seconds);
+  }
+
+  hours = minutes / 60;
+  minutes -= hours * 60;
+  return snprintf(buffer, size, "%uh%02u:%02u", hours, minutes, seconds);
+}
+
+static int rc_format_value_centiseconds(char* buffer, size_t size, uint32_t centiseconds) {
+  uint32_t seconds;
+  int chars, chars2;
+
+  /* modulus off the centiseconds */
+  seconds = centiseconds / 100;
+  centiseconds -= seconds * 100;
+
+  chars = rc_format_value_seconds(buffer, size, seconds);
+  if (chars > 0) {
+    chars2 = snprintf(buffer + chars, size - chars, ".%02u", centiseconds);
+    if (chars2 > 0) {
+      chars += chars2;
+    } else {
+      chars = chars2;
+    }
+  }
+
+  return chars;
+}
+
+static int rc_format_value_fixed(char* buffer, size_t size, const char* format, int32_t value, int32_t factor)
+{
+  if (value >= 0)
+    return snprintf(buffer, size, format, value / factor, value % factor);
+
+  return snprintf(buffer, size, format, value / factor, (-value) % factor);
+}
+
+static int rc_format_value_padded(char* buffer, size_t size, const char* format, int32_t value)
+{
+  if (value == 0)
+    return snprintf(buffer, size, "0");
+
+  return snprintf(buffer, size, format, value);
+}
+
+static int rc_format_insert_commas(int chars, char* buffer, size_t size)
+{
+  int to_insert;
+  char* src = buffer;
+  char* ptr;
+  char* dst = &buffer[chars];
+  if (chars == 0)
+    return 0;
+
+  /* ignore leading negative sign */
+  if (*src == '-')
+    src++;
+
+  /* determine how many digits are present in the leading number */
+  ptr = src;
+  while (ptr < dst && isdigit((int)*ptr))
+    ++ptr;
+
+  /* determine how many commas are needed */
+  to_insert = (int)((ptr - src - 1) / 3);
+  if (to_insert == 0) /* no commas needed */
+    return chars;
+
+  /* if there's not enough room to insert the commas, leave string as-is, but return wanted space */
+  chars += to_insert;
+  if (chars >= (int)size)
+    return chars;
+
+  /* move the trailing part of the string */
+  memmove(ptr + to_insert, ptr, dst - ptr + 1);
+
+  /* shift blocks of three digits at a time, inserting commas in front of them */
+  src = ptr - 1;
+  dst = src + to_insert;
+  while (to_insert > 0) {
+    *dst-- = *src--;
+    *dst-- = *src--;
+    *dst-- = *src--;
+    *dst-- = ',';
+
+    --to_insert;
+  }
+
+  return chars;
+}
+
+int rc_format_typed_value(char* buffer, size_t size, const rc_typed_value_t* value, int format) {
+  int chars;
+  rc_typed_value_t converted_value;
+
+  memcpy(&converted_value, value, sizeof(converted_value));
+
+  switch (format) {
+    default:
+    case RC_FORMAT_VALUE:
+      rc_typed_value_convert(&converted_value, RC_VALUE_TYPE_SIGNED);
+      chars = snprintf(buffer, size, "%d", converted_value.value.i32);
+      break;
+
+    case RC_FORMAT_FRAMES:
+      /* 60 frames per second = 100 centiseconds / 60 frames; multiply frames by 100 / 60 */
+      rc_typed_value_convert(&converted_value, RC_VALUE_TYPE_UNSIGNED);
+      chars = rc_format_value_centiseconds(buffer, size, converted_value.value.u32 * 10 / 6);
+      break;
+
+    case RC_FORMAT_CENTISECS:
+      rc_typed_value_convert(&converted_value, RC_VALUE_TYPE_UNSIGNED);
+      chars = rc_format_value_centiseconds(buffer, size, converted_value.value.u32);
+      break;
+
+    case RC_FORMAT_SECONDS:
+      rc_typed_value_convert(&converted_value, RC_VALUE_TYPE_UNSIGNED);
+      chars = rc_format_value_seconds(buffer, size, converted_value.value.u32);
+      break;
+
+    case RC_FORMAT_SECONDS_AS_MINUTES:
+      rc_typed_value_convert(&converted_value, RC_VALUE_TYPE_UNSIGNED);
+      chars = rc_format_value_minutes(buffer, size, converted_value.value.u32 / 60);
+      break;
+
+    case RC_FORMAT_MINUTES:
+      rc_typed_value_convert(&converted_value, RC_VALUE_TYPE_UNSIGNED);
+      chars = rc_format_value_minutes(buffer, size, converted_value.value.u32);
+      break;
+
+    case RC_FORMAT_SCORE:
+      rc_typed_value_convert(&converted_value, RC_VALUE_TYPE_SIGNED);
+      return snprintf(buffer, size, "%06d", converted_value.value.i32);
+
+    case RC_FORMAT_FLOAT1:
+      rc_typed_value_convert(&converted_value, RC_VALUE_TYPE_FLOAT);
+      chars = snprintf(buffer, size, "%.1f", converted_value.value.f32);
+      break;
+
+    case RC_FORMAT_FLOAT2:
+      rc_typed_value_convert(&converted_value, RC_VALUE_TYPE_FLOAT);
+      chars = snprintf(buffer, size, "%.2f", converted_value.value.f32);
+      break;
+
+    case RC_FORMAT_FLOAT3:
+      rc_typed_value_convert(&converted_value, RC_VALUE_TYPE_FLOAT);
+      chars = snprintf(buffer, size, "%.3f", converted_value.value.f32);
+      break;
+
+    case RC_FORMAT_FLOAT4:
+      rc_typed_value_convert(&converted_value, RC_VALUE_TYPE_FLOAT);
+      chars = snprintf(buffer, size, "%.4f", converted_value.value.f32);
+      break;
+
+    case RC_FORMAT_FLOAT5:
+      rc_typed_value_convert(&converted_value, RC_VALUE_TYPE_FLOAT);
+      chars = snprintf(buffer, size, "%.5f", converted_value.value.f32);
+      break;
+
+    case RC_FORMAT_FLOAT6:
+      rc_typed_value_convert(&converted_value, RC_VALUE_TYPE_FLOAT);
+      chars = snprintf(buffer, size, "%.6f", converted_value.value.f32);
+      break;
+
+    case RC_FORMAT_FIXED1:
+      rc_typed_value_convert(&converted_value, RC_VALUE_TYPE_SIGNED);
+      chars = rc_format_value_fixed(buffer, size, "%d.%u", converted_value.value.i32, 10);
+      break;
+
+    case RC_FORMAT_FIXED2:
+      rc_typed_value_convert(&converted_value, RC_VALUE_TYPE_SIGNED);
+      chars = rc_format_value_fixed(buffer, size, "%d.%02u", converted_value.value.i32, 100);
+      break;
+
+    case RC_FORMAT_FIXED3:
+      rc_typed_value_convert(&converted_value, RC_VALUE_TYPE_SIGNED);
+      chars = rc_format_value_fixed(buffer, size, "%d.%03u", converted_value.value.i32, 1000);
+      break;
+
+    case RC_FORMAT_TENS:
+      rc_typed_value_convert(&converted_value, RC_VALUE_TYPE_SIGNED);
+      chars = rc_format_value_padded(buffer, size, "%d0", converted_value.value.i32);
+      break;
+
+    case RC_FORMAT_HUNDREDS:
+      rc_typed_value_convert(&converted_value, RC_VALUE_TYPE_SIGNED);
+      chars = rc_format_value_padded(buffer, size, "%d00", converted_value.value.i32);
+      break;
+
+    case RC_FORMAT_THOUSANDS:
+      rc_typed_value_convert(&converted_value, RC_VALUE_TYPE_SIGNED);
+      chars = rc_format_value_padded(buffer, size, "%d000", converted_value.value.i32);
+      break;
+
+    case RC_FORMAT_UNSIGNED_VALUE:
+      rc_typed_value_convert(&converted_value, RC_VALUE_TYPE_UNSIGNED);
+      chars = snprintf(buffer, size, "%u", converted_value.value.u32);
+      break;
+
+    case RC_FORMAT_UNFORMATTED:
+      rc_typed_value_convert(&converted_value, RC_VALUE_TYPE_UNSIGNED);
+      return snprintf(buffer, size, "%u", converted_value.value.u32);
+  }
+
+  return rc_format_insert_commas(chars, buffer, size);
+}
+
+int rc_format_value(char* buffer, int size, int32_t value, int format) {
+  rc_typed_value_t typed_value;
+
+  typed_value.value.i32 = value;
+  typed_value.type = RC_VALUE_TYPE_SIGNED;
+  return rc_format_typed_value(buffer, size, &typed_value, format);
+}

data/vendor/rcheevos/src/rcheevos/lboard.c

@@ -0,0 +1,287 @@
+#include "rc_internal.h"
+
+enum {
+  RC_LBOARD_START    = 1 << 0,
+  RC_LBOARD_CANCEL   = 1 << 1,
+  RC_LBOARD_SUBMIT   = 1 << 2,
+  RC_LBOARD_VALUE    = 1 << 3,
+  RC_LBOARD_PROGRESS = 1 << 4,
+  RC_LBOARD_COMPLETE = RC_LBOARD_START | RC_LBOARD_CANCEL | RC_LBOARD_SUBMIT | RC_LBOARD_VALUE
+};
+
+void rc_parse_lboard_internal(rc_lboard_t* self, const char* memaddr, rc_parse_state_t* parse) {
+  int found;
+
+  self->progress = 0;
+  found = 0;
+
+  for (;;)
+  {
+    if ((memaddr[0] == 's' || memaddr[0] == 'S') &&
+        (memaddr[1] == 't' || memaddr[1] == 'T') &&
+        (memaddr[2] == 'a' || memaddr[2] == 'A') && memaddr[3] == ':') {
+      if ((found & RC_LBOARD_START) != 0) {
+        parse->offset = RC_DUPLICATED_START;
+        return;
+      }
+
+      memaddr += 4;
+      if (*memaddr && *memaddr != ':') {
+        found |= RC_LBOARD_START;
+        rc_parse_trigger_internal(&self->start, &memaddr, parse);
+      }
+    }
+    else if ((memaddr[0] == 'c' || memaddr[0] == 'C') &&
+             (memaddr[1] == 'a' || memaddr[1] == 'A') &&
+             (memaddr[2] == 'n' || memaddr[2] == 'N') && memaddr[3] == ':') {
+      if ((found & RC_LBOARD_CANCEL) != 0) {
+        parse->offset = RC_DUPLICATED_CANCEL;
+        return;
+      }
+
+      memaddr += 4;
+      if (*memaddr && *memaddr != ':') {
+        found |= RC_LBOARD_CANCEL;
+        rc_parse_trigger_internal(&self->cancel, &memaddr, parse);
+      }
+    }
+    else if ((memaddr[0] == 's' || memaddr[0] == 'S') &&
+             (memaddr[1] == 'u' || memaddr[1] == 'U') &&
+             (memaddr[2] == 'b' || memaddr[2] == 'B') && memaddr[3] == ':') {
+      if ((found & RC_LBOARD_SUBMIT) != 0) {
+        parse->offset = RC_DUPLICATED_SUBMIT;
+        return;
+      }
+
+      memaddr += 4;
+      if (*memaddr && *memaddr != ':') {
+        found |= RC_LBOARD_SUBMIT;
+        rc_parse_trigger_internal(&self->submit, &memaddr, parse);
+      }
+    }
+    else if ((memaddr[0] == 'v' || memaddr[0] == 'V') &&
+             (memaddr[1] == 'a' || memaddr[1] == 'A') &&
+             (memaddr[2] == 'l' || memaddr[2] == 'L') && memaddr[3] == ':') {
+      if ((found & RC_LBOARD_VALUE) != 0) {
+        parse->offset = RC_DUPLICATED_VALUE;
+        return;
+      }
+
+      memaddr += 4;
+      if (*memaddr && *memaddr != ':') {
+        found |= RC_LBOARD_VALUE;
+        rc_parse_value_internal(&self->value, &memaddr, parse);
+      }
+    }
+    else if ((memaddr[0] == 'p' || memaddr[0] == 'P') &&
+             (memaddr[1] == 'r' || memaddr[1] == 'R') &&
+             (memaddr[2] == 'o' || memaddr[2] == 'O') && memaddr[3] == ':') {
+      if ((found & RC_LBOARD_PROGRESS) != 0) {
+        parse->offset = RC_DUPLICATED_PROGRESS;
+        return;
+      }
+
+      memaddr += 4;
+      if (*memaddr && *memaddr != ':') {
+        found |= RC_LBOARD_PROGRESS;
+
+        self->progress = RC_ALLOC(rc_value_t, parse);
+        rc_parse_value_internal(self->progress, &memaddr, parse);
+      }
+    }
+
+    /* encountered an error parsing one of the parts */
+    if (parse->offset < 0)
+      return;
+
+    /* end of string, or end of quoted string - stop processing */
+    if (memaddr[0] == '\0' || memaddr[0] == '\"')
+      break;
+
+    /* expect two colons between fields */
+    if (memaddr[0] != ':' || memaddr[1] != ':') {
+      parse->offset = RC_INVALID_LBOARD_FIELD;
+      return;
+    }
+
+    memaddr += 2;
+  }
+
+  if ((found & RC_LBOARD_COMPLETE) != RC_LBOARD_COMPLETE) {
+    if ((found & RC_LBOARD_START) == 0) {
+      parse->offset = RC_MISSING_START;
+    }
+    else if ((found & RC_LBOARD_CANCEL) == 0) {
+      parse->offset = RC_MISSING_CANCEL;
+    }
+    else if ((found & RC_LBOARD_SUBMIT) == 0) {
+      parse->offset = RC_MISSING_SUBMIT;
+    }
+    else if ((found & RC_LBOARD_VALUE) == 0) {
+      parse->offset = RC_MISSING_VALUE;
+    }
+
+    return;
+  }
+
+  self->state = RC_LBOARD_STATE_WAITING;
+  self->has_memrefs = 0;
+}
+
+int rc_lboard_size(const char* memaddr) {
+  rc_lboard_with_memrefs_t* lboard;
+  rc_preparse_state_t preparse;
+  rc_init_preparse_state(&preparse);
+
+  lboard = RC_ALLOC(rc_lboard_with_memrefs_t, &preparse.parse);
+  rc_parse_lboard_internal(&lboard->lboard, memaddr, &preparse.parse);
+  rc_preparse_alloc_memrefs(NULL, &preparse);
+
+  rc_destroy_preparse_state(&preparse);
+  return preparse.parse.offset;
+}
+
+rc_lboard_t* rc_parse_lboard(void* buffer, const char* memaddr, void* unused_L, int unused_funcs_idx) {
+  rc_lboard_with_memrefs_t* lboard;
+  rc_preparse_state_t preparse;
+
+  (void)unused_L;
+  (void)unused_funcs_idx;
+
+  if (!buffer || !memaddr)
+    return 0;
+
+  rc_init_preparse_state(&preparse);
+  lboard = RC_ALLOC(rc_lboard_with_memrefs_t, &preparse.parse);
+  rc_parse_lboard_internal(&lboard->lboard, memaddr, &preparse.parse);
+
+  rc_reset_parse_state(&preparse.parse, buffer);
+  lboard = RC_ALLOC(rc_lboard_with_memrefs_t, &preparse.parse);
+  rc_preparse_alloc_memrefs(&lboard->memrefs, &preparse);
+
+  rc_parse_lboard_internal(&lboard->lboard, memaddr, &preparse.parse);
+  lboard->lboard.has_memrefs = 1;
+
+  rc_destroy_preparse_state(&preparse);
+  return (preparse.parse.offset >= 0) ? &lboard->lboard : NULL;
+}
+
+static void rc_update_lboard_memrefs(rc_lboard_t* self, rc_peek_t peek, void* ud) {
+  if (self->has_memrefs) {
+    rc_lboard_with_memrefs_t* lboard = (rc_lboard_with_memrefs_t*)self;
+    rc_update_memref_values(&lboard->memrefs, peek, ud);
+  }
+}
+
+int rc_evaluate_lboard(rc_lboard_t* self, int32_t* value, rc_peek_t peek, void* peek_ud, void* unused_L) {
+  int start_ok, cancel_ok, submit_ok;
+
+  rc_update_lboard_memrefs(self, peek, peek_ud);
+
+  if (self->state == RC_LBOARD_STATE_INACTIVE || self->state == RC_LBOARD_STATE_DISABLED)
+    return RC_LBOARD_STATE_INACTIVE;
+
+  /* these are always tested once every frame, to ensure hit counts work properly */
+  start_ok = rc_test_trigger(&self->start, peek, peek_ud, unused_L);
+  cancel_ok = rc_test_trigger(&self->cancel, peek, peek_ud, unused_L);
+  submit_ok = rc_test_trigger(&self->submit, peek, peek_ud, unused_L);
+
+  switch (self->state)
+  {
+    case RC_LBOARD_STATE_WAITING:
+    case RC_LBOARD_STATE_TRIGGERED:
+    case RC_LBOARD_STATE_CANCELED:
+      /* don't activate/reactivate until the start condition becomes false */
+      if (start_ok) {
+        *value = 0;
+        return RC_LBOARD_STATE_INACTIVE; /* just return inactive for all of these */
+      }
+
+      /* start condition is false, allow the leaderboard to start on future frames */
+      self->state = RC_LBOARD_STATE_ACTIVE;
+      break;
+
+    case RC_LBOARD_STATE_ACTIVE:
+      /* leaderboard attempt is not in progress. if the start condition is true and the cancel condition is not, start the attempt */
+      if (start_ok && !cancel_ok) {
+        if (submit_ok) {
+          /* start and submit are both true in the same frame, just submit without announcing the leaderboard is available */
+          self->state = RC_LBOARD_STATE_TRIGGERED;
+        }
+        else if (!self->start.requirement && !self->start.alternative) {
+          /* start trigger is empty. assume the leaderboard is in development and ignore */
+        }
+        else {
+          /* start the leaderboard attempt */
+          self->state = RC_LBOARD_STATE_STARTED;
+        }
+
+        /* reset any hit counts in the value */
+        if (self->progress)
+          rc_reset_value(self->progress);
+
+        rc_reset_value(&self->value);
+      }
+      break;
+
+    case RC_LBOARD_STATE_STARTED:
+      /* leaderboard attempt in progress */
+      if (cancel_ok) {
+        /* cancel condition is true, abort the attempt */
+        self->state = RC_LBOARD_STATE_CANCELED;
+      }
+      else if (submit_ok) {
+        /* submit condition is true, submit the current value */
+        self->state = RC_LBOARD_STATE_TRIGGERED;
+      }
+      break;
+  }
+
+  /* Calculate the value */
+  switch (self->state) {
+    case RC_LBOARD_STATE_STARTED:
+      if (self->progress) {
+        *value = rc_evaluate_value(self->progress, peek, peek_ud, unused_L);
+        break;
+      }
+      /* fallthrough */ /* to RC_LBOARD_STATE_TRIGGERED */
+
+    case RC_LBOARD_STATE_TRIGGERED:
+      *value = rc_evaluate_value(&self->value, peek, peek_ud, unused_L);
+      break;
+
+    default:
+      *value = 0;
+      break;
+  }
+
+  return self->state;
+}
+
+int rc_lboard_state_active(int state) {
+  switch (state)
+  {
+    case RC_LBOARD_STATE_DISABLED:
+    case RC_LBOARD_STATE_INACTIVE:
+      return 0;
+
+    default:
+      return 1;
+  }
+}
+
+void rc_reset_lboard(rc_lboard_t* self) {
+  if (!self)
+    return;
+
+  self->state = RC_LBOARD_STATE_WAITING;
+
+  rc_reset_trigger(&self->start);
+  rc_reset_trigger(&self->submit);
+  rc_reset_trigger(&self->cancel);
+
+  if (self->progress)
+    rc_reset_value(self->progress);
+
+  rc_reset_value(&self->value);
+}