init

.gitignore

@@ -0,0 +1,3 @@
+/rubiks
+*.o
+

Makefile

@@ -0,0 +1,36 @@
+
+NAME=	rubiks
+
+SRC=	main.c				\
+		std.c				\
+		params.c			\
+		generator.c			\
+		rubiks.c			\
+		rubiks_transform.c	\
+		\
+		debug.c
+
+OBJ=$(SRC:.c=.o)
+
+CC=		clang
+
+CFLAGS=	-W -g3
+
+LDFLAGS=	-g3
+
+$(NAME):	$(OBJ)
+	$(CC) $(OBJ) -o $(NAME) $(LDFLAGS)
+
+all: $(NAME)
+
+clean:
+	$(RM) $(OBJ)
+
+fclean:	clean
+	$(RM) $(NAME)
+
+re:		fclean all
+
+.PHONY:	all clean fclean re
+
+

debug.c

@@ -0,0 +1,34 @@
+
+#include <stdio.h>
+#include "rubiks.h"
+
+void spatial_show(t_rubiks *rub)
+{
+	printf("    +---+\n");
+	printf("    |%c%c%c|\n", rub->grid[5][0][2], rub->grid[5][1][2], rub->grid[5][2][2]);
+	printf("    |%c%c%c|\n", rub->grid[5][0][1], rub->grid[5][1][1], rub->grid[5][2][1]);
+	printf("    |%c%c%c|\n", rub->grid[5][0][0], rub->grid[5][1][0], rub->grid[5][2][0]);
+	printf("    +---+\n");
+	printf("    |%c%c%c|\n", rub->grid[2][0][2], rub->grid[2][1][2], rub->grid[2][2][2]);
+	printf("    |%c%c%c|\n", rub->grid[2][0][1], rub->grid[2][1][1], rub->grid[2][2][1]);
+	printf("    |%c%c%c|\n", rub->grid[2][0][0], rub->grid[2][1][0], rub->grid[2][2][0]);
+	printf("+---+---+---+\n");
+	printf("|%c%c%c|%c%c%c|%c%c%c|\n",
+			rub->grid[3][0][2], rub->grid[3][1][2], rub->grid[3][2][2],
+			rub->grid[0][0][2], rub->grid[0][1][2], rub->grid[0][2][2],
+			rub->grid[1][0][2], rub->grid[1][1][2], rub->grid[1][2][2]);
+	printf("|%c%c%c|%c%c%c|%c%c%c|\n",
+			rub->grid[3][0][1], rub->grid[3][1][1], rub->grid[3][2][1],
+			rub->grid[0][0][1], rub->grid[0][1][1], rub->grid[0][2][1],
+			rub->grid[1][0][1], rub->grid[1][1][1], rub->grid[1][2][1]);
+	printf("|%c%c%c|%c%c%c|%c%c%c|\n",
+			rub->grid[3][0][1], rub->grid[3][1][0], rub->grid[3][2][0],
+			rub->grid[0][0][1], rub->grid[0][1][0], rub->grid[0][2][0],
+			rub->grid[1][0][1], rub->grid[1][1][0], rub->grid[1][2][0]);
+	printf("+---+---+---+\n");
+	printf("    |%c%c%c|\n", rub->grid[4][0][2], rub->grid[4][1][2], rub->grid[4][2][2]);
+	printf("    |%c%c%c|\n", rub->grid[4][0][1], rub->grid[4][1][1], rub->grid[4][2][1]);
+	printf("    |%c%c%c|\n", rub->grid[4][0][0], rub->grid[4][1][0], rub->grid[4][2][0]);
+	printf("+---+---+---+\n");
+}
+

generator.c

@@ -0,0 +1,27 @@
+
+#include <string.h>
+#include <stdlib.h>
+#include "rubiks.h"
+
+static int move_random(t_rubiks *r, char lastMove)
+{
+	char movment = -1;
+
+	do {
+		movment = rand() % 18;
+	} while (movment == lastMove);
+	rubik_apply(r, movment);
+	return movment;
+}
+
+void doGenerate(t_params *params, FILE *output)
+{
+	t_rubiks *rubiks = rubik_create("000000000111111111222222222333333333444444444555555555");
+	char lastMove = -1;
+	int i;
+
+	for (i=0; i < params->nbMovment; ++i)
+		lastMove = move_random(rubiks, lastMove);
+	free(rubiks);
+}
+

main.c

@@ -0,0 +1,43 @@
+
+#include <time.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "rubiks.h"
+
+int generate(char **params, char *av0)
+{
+	t_params p;
+	FILE *f;
+	int i;
+
+	srand(time(NULL));
+	if (!parse_params(params, &p, av0))
+	{
+		xfree(p.output);
+		return -1;
+	}
+	if (p.output == NULL)
+		f = stdout;
+	else if ((f = fopen(p.output, "a+")) == NULL)
+	{
+		fprintf(stderr, "Cannot open %s for writting\n", p.output);
+		free(p.output);
+		return -1;
+	}
+	for (i=0; i < p.count; i++)
+		doGenerate(&p, f);
+	xfree(p.output);
+	return 0;
+}
+
+int main(int ac, char **av)
+{
+	(void) ac;
+	if (av[1] && (!strcmp(av[1], "generate") || !strcmp(av[1], "gen")))
+		return generate(&av[2], av[0]);
+	fprintf(stderr, "Expected valid action\n");
+	usage(av[0]);
+	return -1;
+}
+

params.c

@@ -0,0 +1,73 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include "rubiks.h"
+
+void usage(char *av0)
+{
+	printf("Usage: %s action [-o filename] [-c count=20] [-move movment=20]\n", av0);
+	printf("\taction: generate|gen create a new grid\n");
+}
+
+
+static int getInt(char *params, char *av0)
+{
+	int varNum;
+
+	if (!params)
+	{
+		fprintf(stderr, "Expected number\n");
+		usage(av0);
+		return -1;
+	}
+	if ((varNum = atoi(params)) <= 0)
+	{
+		fprintf(stderr, "Invalid number\n");
+		usage(av0);
+		return -1;
+	}
+	return varNum;
+}
+
+int parse_params(char **params, t_params *p, char *av0)
+{
+	int varNum;
+	p->count = 20;
+	p->output = NULL;
+	p->nbMovment = 20;
+
+	for (int i=0; params[i]; ++i)
+	{
+		if (!strcmp(params[i], "-o"))
+		{
+			if (!params[i+1])
+			{
+				fprintf(stderr, "Error: expected filename\n");
+				usage(av0);
+				return 0;
+			}
+			p->output = strdup(params[i+1]);
+			i++;
+		}
+		else if (!strcmp(params[i], "-c"))
+		{
+			if ((p->count = getInt(params[1+i], av0)) == -1)
+				return -1;
+			i++;
+		}
+		else if (!strcmp(params[i], "-move"))
+		{
+			if ((p->nbMovment = getInt(params[1+i], av0)) == -1)
+				return -1;
+			i++;
+		}
+		else
+		{
+			fprintf(stderr, "Invalid token: %s\n", params[i]);
+			usage(av0);
+			return -1;
+		}
+	}
+	return 1;
+}
+

rubiks.c

@@ -0,0 +1,97 @@
+
+#include <stdlib.h>
+#include <string.h>
+#include "rubiks.h"
+
+/**
+ * Transform: [ axis, offset, dir ]
+ * Axis: X | Y | Z
+ *             5
+ *          +---+
+ *    +Y   / 2 /|
+ * 	  |   +---+1/
+ * 	  |  3| 0 |/
+ * 	  |   +---+
+ *          4 
+ * 	     	---> +X
+ *    /
+ *   /
+ * -Z 
+ *
+ *        +--+
+ *        |5 |
+ *        +--+
+ *        |2 |
+ *     +--+--+--+
+ *     |3 |0 |1 |
+ *  Y  +--+--+--+
+ *        |4 |
+ *  |     +--+
+ *  |
+ *  +--> X
+ *
+ *  offset: '1' >= '3'
+ *  dir: '+' : '-' (+: trigonometric direction)
+**/
+void rubik_applyVect(t_rubiks *r, char v[3])
+{
+	rubik_applyX(r, (char[]) { 'X', '0', '+' });
+	spatial_show(r);
+	rubik_applyX(r, (char[]) { 'X', '1', '+' });
+	spatial_show(r);
+	rubik_applyX(r, (char[]) { 'X', '2', '+' });
+	spatial_show(r);
+	exit(0);
+
+	return;
+	switch (v[0])
+	{
+		case 'X':
+			rubik_applyX(r, v); break;
+		case 'Y':
+			rubik_applyY(r, v); break;
+		case 'Z':
+			rubik_applyZ(r, v); break;
+		default:
+			break;
+	}
+}
+
+void rubik_apply(t_rubiks *r, char m)
+{
+	char mov[3] = { 0, 0, 0 };
+	int init_m = (int) m;
+
+	mov[2] = (char)(m % 2) ? '+' : '-';
+	m /= 2;
+	mov[1] = '0' + ((char)(m % 3));
+	m /= 3;
+	mov[0] = 'X' + ((char)(m % 3));
+	rubik_applyVect(r, mov);
+}
+
+t_rubiks *rubik_createempty()
+{
+	t_rubiks *result;
+	int i;
+
+	result = (t_rubiks *)malloc(sizeof(*result));
+	bzero(result, sizeof(*result));
+	return result;
+}
+
+t_rubiks *rubik_create(char matrix[54])
+{
+	t_rubiks *result;
+	int i;
+
+	for (i=0; i < 54; i++)
+		if (matrix[i] < '0' || matrix[i] > '5')
+			return NULL;
+	if (matrix[54] != '\0')
+		return NULL;
+	result = (t_rubiks *)malloc(sizeof(*result));
+	memcpy(result->grid, matrix, sizeof(*matrix) * 54);
+	return result;
+}
+

rubiks.h

@@ -0,0 +1,38 @@
+#pragma one
+
+#include <stdio.h>
+
+typedef struct {
+	char *output;
+	int count;
+	int nbMovment;
+}	t_params;
+
+typedef struct {
+	char grid[6][3][3];
+}	t_rubiks;
+
+/* params.c */
+void usage(char*);
+int parse_params(char **, t_params *, char *);
+
+/* generator.c */
+void doGenerate(t_params *, FILE *);
+
+/* std */
+void xfree(void *);
+
+/* rubiks_transform.c */
+void rubik_applyX(t_rubiks *, char[3]);
+void rubik_applyY(t_rubiks *, char[3]);
+void rubik_applyZ(t_rubiks *, char[3]);
+
+/* rubiks.c */
+t_rubiks *rubik_create(char [54]);
+t_rubiks *rubik_createempty();
+void rubik_applyVect(t_rubiks *, char [3]);
+void rubik_apply(t_rubiks *, char movment);
+
+/* debug.h */
+void spatial_show(t_rubiks *);
+

rubiks_transform.c

@@ -0,0 +1,185 @@
+
+#include <string.h>
+#include "rubiks.h"
+
+void rubik_applyX(t_rubiks *rubiks, char move[3])
+{
+	char tmpMatrix[3][3];
+
+	memcpy(tmpMatrix, rubiks->grid[3], sizeof(tmpMatrix));
+	memcpy(rubiks->grid[3], rubiks->grid[5], sizeof(tmpMatrix));
+	memcpy(rubiks->grid[5], rubiks->grid[1], sizeof(tmpMatrix));
+	memcpy(rubiks->grid[1], rubiks->grid[0], sizeof(tmpMatrix));
+	memcpy(rubiks->grid[0], tmpMatrix, sizeof(tmpMatrix));
+	memcpy(tmpMatrix, rubiks->grid[2], sizeof(tmpMatrix));
+	rubiks->grid[2][0][0] = tmpMatrix[0][2];
+	rubiks->grid[2][0][1] = tmpMatrix[1][2];
+	rubiks->grid[2][0][2] = tmpMatrix[2][2];
+	rubiks->grid[2][1][0] = tmpMatrix[0][1];
+	rubiks->grid[2][1][1] = tmpMatrix[1][1];
+	rubiks->grid[2][1][2] = tmpMatrix[2][1];
+	rubiks->grid[2][2][0] = tmpMatrix[0][0];
+	rubiks->grid[2][2][1] = tmpMatrix[1][0];
+	rubiks->grid[2][2][2] = tmpMatrix[2][0];
+	memcpy(tmpMatrix, rubiks->grid[4], sizeof(tmpMatrix));
+	rubiks->grid[4][0][0] = tmpMatrix[2][0];
+	rubiks->grid[4][1][0] = tmpMatrix[2][1];
+	rubiks->grid[4][2][0] = tmpMatrix[2][2];
+	rubiks->grid[4][0][1] = tmpMatrix[1][0];
+	rubiks->grid[4][1][1] = tmpMatrix[1][1];
+	rubiks->grid[4][2][1] = tmpMatrix[1][2];
+	rubiks->grid[4][0][2] = tmpMatrix[0][0];
+	rubiks->grid[4][1][2] = tmpMatrix[0][1];
+	rubiks->grid[4][2][2] = tmpMatrix[0][2];
+	memcpy(tmpMatrix, rubiks->grid[3], sizeof(tmpMatrix));
+	rubiks->grid[3][0][0] = tmpMatrix[2][2];
+	rubiks->grid[3][1][0] = tmpMatrix[1][2];
+	rubiks->grid[3][2][0] = tmpMatrix[0][2];
+	rubiks->grid[3][0][1] = tmpMatrix[2][1];
+	rubiks->grid[3][1][1] = tmpMatrix[1][1];
+	rubiks->grid[3][2][1] = tmpMatrix[0][1];
+	rubiks->grid[3][0][2] = tmpMatrix[2][0];
+	rubiks->grid[3][1][2] = tmpMatrix[1][0];
+	rubiks->grid[3][2][2] = tmpMatrix[0][0];
+
+	rubik_applyZ(rubiks, (char [3]) { 'Z', move[1], move[2] == '+' ? '-' : '+' });
+
+	memcpy(tmpMatrix, rubiks->grid[0], sizeof(tmpMatrix));
+	memcpy(rubiks->grid[0], rubiks->grid[1], sizeof(tmpMatrix));
+	memcpy(rubiks->grid[1], rubiks->grid[5], sizeof(tmpMatrix));
+	memcpy(rubiks->grid[5], rubiks->grid[3], sizeof(tmpMatrix));
+	memcpy(rubiks->grid[3], tmpMatrix, sizeof(tmpMatrix));
+	memcpy(tmpMatrix, rubiks->grid[2], sizeof(tmpMatrix));
+	rubiks->grid[2][0][0] = tmpMatrix[2][0];
+	rubiks->grid[2][1][0] = tmpMatrix[2][1];
+	rubiks->grid[2][2][0] = tmpMatrix[2][2];
+	rubiks->grid[2][0][1] = tmpMatrix[1][0];
+	rubiks->grid[2][1][1] = tmpMatrix[1][1];
+	rubiks->grid[2][2][1] = tmpMatrix[1][2];
+	rubiks->grid[2][0][2] = tmpMatrix[0][0];
+	rubiks->grid[2][1][2] = tmpMatrix[0][1];
+	rubiks->grid[2][2][2] = tmpMatrix[0][2];
+	memcpy(tmpMatrix, rubiks->grid[4], sizeof(tmpMatrix));
+	rubiks->grid[4][0][0] = tmpMatrix[0][2];
+	rubiks->grid[4][1][0] = tmpMatrix[0][1];
+	rubiks->grid[4][2][0] = tmpMatrix[0][0];
+	rubiks->grid[4][0][1] = tmpMatrix[1][2];
+	rubiks->grid[4][1][1] = tmpMatrix[1][1];
+	rubiks->grid[4][2][1] = tmpMatrix[1][0];
+	rubiks->grid[4][0][2] = tmpMatrix[0][2];
+	rubiks->grid[4][1][2] = tmpMatrix[0][1];
+	rubiks->grid[4][2][2] = tmpMatrix[0][0];
+	memcpy(tmpMatrix, rubiks->grid[5], sizeof(tmpMatrix));
+	rubiks->grid[5][0][0] = tmpMatrix[2][2];
+	rubiks->grid[5][1][0] = tmpMatrix[1][2];
+	rubiks->grid[5][2][0] = tmpMatrix[0][2];
+	rubiks->grid[5][0][1] = tmpMatrix[2][1];
+	rubiks->grid[5][1][1] = tmpMatrix[1][1];
+	rubiks->grid[5][2][1] = tmpMatrix[0][1];
+	rubiks->grid[5][0][2] = tmpMatrix[2][0];
+	rubiks->grid[5][1][2] = tmpMatrix[1][0];
+	rubiks->grid[5][2][2] = tmpMatrix[0][0];
+}
+
+void rubik_applyY(t_rubiks *rubiks, char move[3])
+{
+		/* TODO */
+	(void)rubiks;
+	(void)move;
+}
+
+void rubik_applyZ(t_rubiks *rubiks, char move[3])
+{
+	char tmp;
+	char tmpv[3];
+
+	const char axis = move[1] - '0';
+	if (move[2] == '-')
+	{
+		int i;
+
+		for (i=0; i < 3; ++i)
+			rubik_applyZ(rubiks, (char [3]) { move[0], move[1], '+' });
+		return;
+	}
+	if (axis == 0)
+	{
+		tmp = rubiks->grid[0][0][0];
+		rubiks->grid[0][0][0] = rubiks->grid[0][0][2];
+		rubiks->grid[0][0][2] = rubiks->grid[0][2][2];
+		rubiks->grid[0][2][2] = rubiks->grid[0][2][0];
+		rubiks->grid[0][2][0] = tmp;
+		tmp = rubiks->grid[0][1][0];
+		rubiks->grid[0][1][0] = rubiks->grid[0][0][1];
+		rubiks->grid[0][0][1] = rubiks->grid[0][1][2];
+		rubiks->grid[0][1][2] = rubiks->grid[0][2][1];
+		rubiks->grid[0][2][1] = tmp;
+
+		memcpy(tmpv, (char[3]) { rubiks->grid[1][0][0], rubiks->grid[1][0][1], rubiks->grid[1][0][2] }, sizeof(tmpv) * 3);
+		rubiks->grid[1][0][0] = rubiks->grid[4][0][2];
+		rubiks->grid[1][0][1] = rubiks->grid[4][1][2];
+		rubiks->grid[1][0][2] = rubiks->grid[4][2][2];
+
+		rubiks->grid[4][0][2] = rubiks->grid[3][2][2];
+		rubiks->grid[4][1][2] = rubiks->grid[3][2][1];
+		rubiks->grid[4][2][2] = rubiks->grid[3][2][0];
+
+		rubiks->grid[3][2][0] = rubiks->grid[2][0][0];
+		rubiks->grid[3][2][1] = rubiks->grid[2][1][0];
+		rubiks->grid[3][2][2] = rubiks->grid[2][2][0];
+
+		rubiks->grid[2][0][0] = tmpv[2];
+		rubiks->grid[2][1][0] = tmpv[1];
+		rubiks->grid[2][2][0] = tmpv[0];
+	}
+	else if (axis == 1)
+	{
+		memcpy(tmpv, (char[3]) { rubiks->grid[1][1][0], rubiks->grid[1][1][1], rubiks->grid[1][1][2] }, sizeof(tmpv) * 3);
+		rubiks->grid[1][1][0] = rubiks->grid[4][0][1];
+		rubiks->grid[1][1][1] = rubiks->grid[4][1][1];
+		rubiks->grid[1][1][2] = rubiks->grid[4][2][1];
+
+		rubiks->grid[4][0][1] = rubiks->grid[3][1][2];
+		rubiks->grid[4][1][1] = rubiks->grid[3][1][1];
+		rubiks->grid[4][2][1] = rubiks->grid[3][1][0];
+
+		rubiks->grid[3][1][0] = rubiks->grid[2][0][1];
+		rubiks->grid[3][1][1] = rubiks->grid[2][1][1];
+		rubiks->grid[3][1][2] = rubiks->grid[2][2][1];
+
+		rubiks->grid[2][0][1] = tmpv[2];
+		rubiks->grid[2][1][1] = tmpv[1];
+		rubiks->grid[2][2][1] = tmpv[0];
+	}
+	else if (axis == 2)
+	{
+		memcpy(tmpv, (char[3]) { rubiks->grid[1][2][0], rubiks->grid[1][2][1], rubiks->grid[1][2][2] }, sizeof(tmpv) * 3);
+		rubiks->grid[1][2][0] = rubiks->grid[4][0][0];
+		rubiks->grid[1][2][1] = rubiks->grid[4][1][0];
+		rubiks->grid[1][2][2] = rubiks->grid[4][2][0];
+
+		rubiks->grid[4][0][0] = rubiks->grid[3][0][2];
+		rubiks->grid[4][1][0] = rubiks->grid[3][0][1];
+		rubiks->grid[4][2][0] = rubiks->grid[3][0][0];
+
+		rubiks->grid[3][0][0] = rubiks->grid[2][0][2];
+		rubiks->grid[3][0][1] = rubiks->grid[2][1][2];
+		rubiks->grid[3][0][2] = rubiks->grid[2][2][2];
+
+		rubiks->grid[2][0][2] = tmpv[2];
+		rubiks->grid[2][1][2] = tmpv[1];
+		rubiks->grid[2][2][2] = tmpv[0];
+
+		tmp = rubiks->grid[5][0][0];
+		rubiks->grid[5][0][0] = rubiks->grid[5][0][2];
+		rubiks->grid[5][0][2] = rubiks->grid[5][2][2];
+		rubiks->grid[5][2][2] = rubiks->grid[5][2][0];
+		rubiks->grid[5][2][0] = tmp;
+		tmp = rubiks->grid[5][1][0];
+		rubiks->grid[5][1][0] = rubiks->grid[5][0][1];
+		rubiks->grid[5][0][1] = rubiks->grid[5][1][2];
+		rubiks->grid[5][1][2] = rubiks->grid[5][2][1];
+		rubiks->grid[5][2][1] = tmp;
+	}
+}
+

std.c

@@ -0,0 +1,9 @@
+#include <stdlib.h>
+#include "rubiks.h"
+
+void xfree(void *ptr)
+{
+	if (ptr)
+		free(ptr);
+}
+