From bab22e1946a656088804b61cf765461b48744971 Mon Sep 17 00:00:00 2001 From: Sebastiano Tronto Date: Tue, 22 Apr 2025 16:12:21 +0200 Subject: Update tests for oriented_cube_t --- src/core/core.h | 1 + src/core/core_types.h | 4 +++ src/core/cube.h | 99 +++++++++++++++++++++++++++++---------------------- src/core/moves.h | 12 +++---- src/core/transform.h | 13 ++++--- 5 files changed, 75 insertions(+), 54 deletions(-) create mode 100644 src/core/core_types.h (limited to 'src/core') diff --git a/src/core/core.h b/src/core/core.h index fce1751..c211788 100644 --- a/src/core/core.h +++ b/src/core/core.h @@ -1,3 +1,4 @@ +#include "core_types.h" #include "constant_cubes.h" #include "cube.h" #include "moves.h" diff --git a/src/core/core_types.h b/src/core/core_types.h new file mode 100644 index 0000000..2ad8938 --- /dev/null +++ b/src/core/core_types.h @@ -0,0 +1,4 @@ +typedef struct { + cube_t cube; + uint8_t orientation; +} oriented_cube_t; diff --git a/src/core/cube.h b/src/core/cube.h index a045e55..76c3ff1 100644 --- a/src/core/cube.h +++ b/src/core/cube.h @@ -1,17 +1,33 @@ -STATIC cube_t solvedcube(void); +#define ZERO_ORIENTED_CUBE ((oriented_cube_t) {0}) +#define SOLVED_ORIENTED_CUBE \ + ((oriented_cube_t) { .cube = SOLVED_CUBE, .orientation = 0 }) + +STATIC oriented_cube_t solvedcube(void); STATIC cube_t cubefromarray(uint8_t [static 8], uint8_t [static 12]); -STATIC bool isconsistent(cube_t); -STATIC bool issolvable(cube_t); -STATIC bool issolved(cube_t); -STATIC bool iserror(cube_t); +STATIC bool isconsistent(oriented_cube_t); +STATIC bool issolvable(oriented_cube_t); +STATIC bool issolved(oriented_cube_t); +STATIC bool iserror(oriented_cube_t); STATIC void getcube_fix(long long *, long long *, long long *, long long *); STATIC cube_t getcube(int64_t, int64_t, int64_t, int64_t); -/* This is used only in tests, use SOLVED_CUBE directly everywhere else */ -STATIC cube_t +STATIC oriented_cube_t readcube(const char *); +STATIC int64_t writecube(oriented_cube_t, size_t n, char [n]); +STATIC uint8_t readco(const char *); +STATIC uint8_t readcp(const char *); +STATIC uint8_t readeo(const char *); +STATIC uint8_t readep(const char *); + +STATIC uint8_t b32toedge(char); +STATIC uint8_t b32tocorner(char); +STATIC char edgetob32(uint8_t); +STATIC char cornertob32(uint8_t); + +/* This is used only in tests, use SOLVED_ORIENTED_CUBE everywhere else */ +STATIC oriented_cube_t solvedcube(void) { - return SOLVED_CUBE; + return SOLVED_ORIENTED_CUBE; } STATIC cube_t @@ -24,12 +40,12 @@ cubefromarray(uint8_t c[static 8], uint8_t e[static 12]) } STATIC bool -isconsistent(cube_t cube) +isconsistent(oriented_cube_t cube) { uint8_t i, p, e, piece, corner[8], edge[12]; bool found[12]; - pieces(&cube, corner, edge); + pieces(&cube.cube, corner, edge); for (i = 0; i < 12; i++) found[i] = false; @@ -63,25 +79,29 @@ isconsistent(cube_t cube) if (!found[i]) goto inconsistent_cp; + if (cube.orientation >= 24) + goto inconsistent_orientation; + return true; inconsistent_ep: inconsistent_cp: inconsistent_eo: inconsistent_co: - /* We used to do more logging here, hence the 4 different labels */ +inconsistent_orientation: + /* We used to do more logging here, hence the different labels */ return false; } STATIC bool -issolvable(cube_t cube) +issolvable(oriented_cube_t cube) { uint8_t i, eo, co, piece, edge[12], corner[8], ep[12], cp[8]; DBG_ASSERT(isconsistent(cube), false, "issolvable: cube is inconsistent\n"); - pieces(&cube, corner, edge); + pieces(&cube.cube, corner, edge); for (i = 0; i < 12; i++) ep[i] = edge[i] & PBITS; for (i = 0; i < 8; i++) @@ -120,15 +140,15 @@ issolvable_co: } bool -issolved(cube_t cube) +issolved(oriented_cube_t cube) { - return equal(cube, SOLVED_CUBE); + return equal(cube.cube, SOLVED_CUBE); } bool -iserror(cube_t cube) +iserror(oriented_cube_t cube) { - return equal(cube, ZERO_CUBE); + return equal(cube.cube, ZERO_CUBE); } STATIC void @@ -175,21 +195,6 @@ getcube(int64_t ep, int64_t eo, int64_t cp, int64_t co) return cubefromarray(carr, earr); } - -/******************************************************************************/ - -STATIC cube_t readcube(const char *); -STATIC int64_t writecube(cube_t, size_t n, char [n]); -STATIC uint8_t readco(const char *); -STATIC uint8_t readcp(const char *); -STATIC uint8_t readeo(const char *); -STATIC uint8_t readep(const char *); - -STATIC uint8_t b32toedge(char); -STATIC uint8_t b32tocorner(char); -STATIC char edgetob32(uint8_t); -STATIC char cornertob32(uint8_t); - STATIC uint8_t readco(const char *str) { @@ -243,11 +248,11 @@ readep(const char *str) return UINT8_ERROR; } -STATIC cube_t +STATIC oriented_cube_t readcube(const char *buf) { int i; - uint8_t c[8], e[12]; + uint8_t c[8], e[12], orientation; for (i = 0; i < 8; i++) { c[i] = b32tocorner(buf[i]); @@ -258,14 +263,14 @@ readcube(const char *buf) } else { LOG("(char '%c')\n", buf[i]); } - return ZERO_CUBE; + return ZERO_ORIENTED_CUBE; } } if (buf[8] != '=') { LOG("Error reading separator: a single '=' " "must be used to separate edges and corners\n"); - return ZERO_CUBE; + return ZERO_ORIENTED_CUBE; } for (i = 0; i < 12; i++) { @@ -277,15 +282,25 @@ readcube(const char *buf) } else { LOG("(char '%c')\n", buf[i+9]); } - return ZERO_CUBE; + return ZERO_ORIENTED_CUBE; } } - return cubefromarray(c, e); + orientation = (uint8_t)(buf[22] - 'A'); + if (orientation >= 24) { + LOG("Error reading orientation: impossible value %" PRIu8 + " (%c)\n", orientation, buf[22]); + return ZERO_ORIENTED_CUBE; + } + + return (oriented_cube_t) { + .cube = cubefromarray(c, e), + .orientation = orientation + }; } STATIC int64_t -writecube(cube_t cube, size_t buf_size, char buf[buf_size]) +writecube(oriented_cube_t cube, size_t buf_size, char buf[buf_size]) { int i; uint8_t corner[8], edge[12]; @@ -297,7 +312,7 @@ writecube(cube_t cube, size_t buf_size, char buf[buf_size]) return NISSY_ERROR_BUFFER_SIZE; } - pieces(&cube, corner, edge); + pieces(&cube.cube, corner, edge); for (i = 0; i < 8; i++) buf[i] = cornertob32(corner[i]); @@ -307,9 +322,8 @@ writecube(cube_t cube, size_t buf_size, char buf[buf_size]) for (i = 0; i < 12; i++) buf[i+9] = edgetob32(edge[i]); -/* TODO */ buf[21] = '='; - buf[22] = 'A'; + buf[22] = (char)cube.orientation + 'A'; buf[23] = '\0'; return NISSY_OK; @@ -351,4 +365,3 @@ cornertob32(uint8_t corner) return val < 26 ? 'A' + (char)val : 'a' + (char)(val - 26); } -/******************************************************************************/ diff --git a/src/core/moves.h b/src/core/moves.h index 8f91167..7e80946 100644 --- a/src/core/moves.h +++ b/src/core/moves.h @@ -21,7 +21,7 @@ STATIC uint8_t inverse_move(uint8_t); STATIC void sortparallel_moves(size_t n, uint8_t [n]); STATIC bool are_lastmoves_singlecw(size_t n, const uint8_t [n]); -STATIC cube_t applymoves(cube_t, const char *); +STATIC oriented_cube_t applymoves(oriented_cube_t, const char *); #define FOREACH_READMOVE(ARG_BUF, ARG_MOVE, ARG_C, ARG_MAX, \ RET_ERROR, ARG_ACTION) \ @@ -319,17 +319,17 @@ are_lastmoves_singlecw(size_t n, const uint8_t moves[n]) return isbase(moves[n-1]) && (!two || isbase(moves[n-2])); } -STATIC cube_t -applymoves(cube_t cube, const char *buf) +STATIC oriented_cube_t +applymoves(oriented_cube_t cube, const char *buf) { int c; uint8_t m; - DBG_ASSERT(isconsistent(cube), ZERO_CUBE, + DBG_ASSERT(isconsistent(cube), ZERO_ORIENTED_CUBE, "move error: inconsistent cube\n"); - FOREACH_READMOVE(buf, m, c, -1, ZERO_CUBE, - cube = move(cube, m); + FOREACH_READMOVE(buf, m, c, -1, ZERO_ORIENTED_CUBE, + cube.cube = move(cube.cube, m); ) return cube; diff --git a/src/core/transform.h b/src/core/transform.h index 28b8d93..763a4ae 100644 --- a/src/core/transform.h +++ b/src/core/transform.h @@ -23,7 +23,7 @@ STATIC void writetrans(uint8_t, char [static NISSY_SIZE_TRANSFORMATION]); STATIC cube_t transform_edges(cube_t, uint8_t); STATIC cube_t transform_corners(cube_t, uint8_t); STATIC cube_t transform(cube_t, uint8_t); -STATIC cube_t applytrans(cube_t, const char *); +STATIC oriented_cube_t applytrans(oriented_cube_t, const char *); STATIC_INLINE uint8_t inverse_trans(uint8_t); STATIC uint8_t transform_move(uint8_t, uint8_t); STATIC uint64_t symmetry_mask(cube_t); @@ -367,12 +367,12 @@ transform(cube_t c, uint8_t t) } } -STATIC cube_t -applytrans(cube_t cube, const char *buf) +STATIC oriented_cube_t +applytrans(oriented_cube_t cube, const char *buf) { uint8_t t; - DBG_ASSERT(isconsistent(cube), ZERO_CUBE, + DBG_ASSERT(isconsistent(cube), ZERO_ORIENTED_CUBE, "transformation error: inconsistent cube\n"); t = readtrans(buf); @@ -380,7 +380,10 @@ applytrans(cube_t cube, const char *buf) if (t == UINT8_ERROR) LOG("Unknown transformation: %s\n", buf); - return transform(cube, t); + return (oriented_cube_t){ + .cube = transform(cube.cube, t), + .orientation = cube.orientation + }; } STATIC_INLINE uint8_t -- cgit v1.3