int main(int argc, char **argv)
{
int w;
int h;
int **tab;
int i;
int case_per_sec;
int score;
i = 0;
w = ft_atoi(argv[1]);
h = ft_atoi(argv[2]);
case_per_sec = ft_atoi(argv[3]);
tab = (int **)malloc(sizeof(int*) * w);
while (i < w)
{
tab[i] = (int *)malloc(sizeof(int) * h);
i++;
}
set_tab(tab, w, h);
puttab(tab,w, h);
score = snake(tab, w, h, case_per_sec);
ft_putstr("Game over !\nScore final: ");
ft_putnbr(score);
}
int updatetab(int **tab, int dir, t_snake *snake, t_point *apple, int w ,int h)
{
t_snake *tmp;
int x_end;
int y_end;
x_end = snake->end2->pos.x;
y_end = snake->end2->pos.y;
tmp = snake->end2;
tab[snake->end2->pos.x][snake->end2->pos.y] = ELEM_VOID;
while (tmp->mom)
{
tmp->pos.x = tmp->mom->pos.x;
tmp->pos.y = tmp->mom->pos.y;
tmp = tmp->mom;
}
if (dir == LEFT)
snake->pos.x--;
if (dir == RIGHT)
snake->pos.x++;
if (dir == UP)
snake->pos.y--;
if (dir == DOWN)
snake->pos.y++;
if (snake->pos.x == apple->x && snake->pos.y == apple->y) // si il y a une pomme
{
snake->score += snake->case_per_sec;
apple->x = rand_a_b(1, w - 1);
apple->y = rand_a_b(1, h - 1);
while (tab[apple->x][apple->y] == ELEM_SNAKE)
{
apple->x = rand_a_b(1, w);
apple->y = rand_a_b(1, h);
}
tab[apple->x][apple->y] = ELEM_APPLE;
snakeadd(snake, x_end, y_end);
}
if(tab[snake->pos.x][snake->pos.y] != ELEM_DIESE && tab[snake->pos.x][snake->pos.y] != ELEM_SNAKE)
{
snake->dir = dir;
while (snake)
{
tab[snake->pos.x][snake->pos.y] = ELEM_SNAKE;
snake = snake->next;
}
return (1);
}
puttab(tab, w, h);
return(0);
}
int snake(int **tab, int w, int h, int case_per_sec)
{
int i;
int keypress;
int dir;
t_snake *snake;
t_snake *snake2;
t_point apple;
snake = (t_snake*)malloc(sizeof(t_snake));
snake2 = (t_snake*)malloc(sizeof(t_snake));
snake->mom = NULL;
snake->pos.x = 5;
snake->pos.y = 4;
snake->case_per_sec = case_per_sec;
snake->score = 0;
snake->end2 = snake;
snake->next = NULL;
snakeadd(snake, 4, 4);
snakeadd(snake, 3, 4);
apple.x = 6;
apple.y = 5;
tab[apple.x][apple.y] = ELEM_APPLE;
i = 0;
dir = RIGHT;
while(1)
{
system("CLEAR");
keypress = getarrowkey();
if (keypress != 0)
dir = keypress;
if(!updatetab(tab, dir, snake, &apple, w, h))
return (snake->score);
puttab(tab, w, h);
ft_putstr("Score :");
ft_putnbr(snake->score);
usleep(1000000 / case_per_sec);
}
}
char *lineview(int win, int w, int y, int xskip, unsigned char *p, int tab, int lang)
{
int x = - xskip;
char s[130];
for (;;) {
if (*p == 0) {
break;
}
if (*p == 0x0a) {
p++;
break;
}
if (lang == 0) { /* ASCII */
if (*p == 0x09) {
x = puttab(x, w, xskip, s, tab);
} else {
if (0 <= x && x < w) {
s[x] = *p;
}
x++;
}
p++;
}
if (lang == 1) { /* SJIS */
if (*p == 0x09) {
x = puttab(x, w, xskip, s, tab);
p++;
} else if ((0x81 <= *p && *p <= 0x9f) || (0xe0 <= *p && *p <= 0xfc)) {
/* 전각 문자 */
if (x == -1) {
s[0] = ' ';
}
if (0 <= x && x < w - 1) {
s[x] = *p;
s[x + 1] = p[1];
}
if (x == w - 1) {
s[x] = ' ';
}
x += 2;
p += 2;
} else {
if (0 <= x && x < w) {
s[x] = *p;
}
x++;
p++;
}
}
if (lang == 2) { /* EUC */
if (*p == 0x09) {
x = puttab(x, w, xskip, s, tab);
p++;
} else if (0xa1 <= *p && *p <= 0xfe) {
/* 전각 문자 */
if (x == -1) {
s[0] = ' ';
}
if (0 <= x && x < w - 1) {
s[x] = *p;
s[x + 1] = p[1];
}
if (x == w - 1) {
s[x] = ' ';
}
x += 2;
p += 2;
} else {
if (0 <= x && x < w) {
s[x] = *p;
}
x++;
p++;
}
}
}
if (x > w) {
x = w;
}
if (x > 0) {
s[x] = 0;
api_putstrwin(win + 1, 8, y, 0, x, s);
}
return p;
}
void genobj( void )
{
int i;
int ntoken;
int this_token;
int any_token;
int action;
short *p;
a_pro *pro;
a_state *x;
a_reduce_action *rx;
a_reduce_action *default_reduction;
a_shift_action *tx;
a_sym *sym;
an_item *item;
unsigned max;
unsigned sum;
unsigned savings;
unsigned base;
unsigned rule_base;
short *state_base;
ntoken = 0;
for( i = 0; i < nterm; ++i ) {
this_token = symtab[i]->token;
if( this_token > ntoken ) {
ntoken = this_token;
}
}
for( i = nterm; i < nsym; ++i ) {
symtab[i]->token = ++ntoken;
}
any_token = ++ntoken;
state_base = CALLOC( nstate, short );
base = 0;
max = 0;
sum = 0;
for( i = 0; i < nstate; ++i ){
state_base[i] = base;
x = statetab[i];
for( tx = x->trans; sym = tx->sym; ++tx ) {
add_table( sym->idx, ACTION_SHIFT | tx->state->sidx );
++base;
}
default_reduction = NULL;
savings = 0;
for( rx = x->redun; rx->pro != NULL; ++rx ){
p = Members( rx->follow, setmembers );
if( p != setmembers ) {
if( p - setmembers > savings ) {
savings = p - setmembers;
if( default_reduction != NULL ) {
dump_reduction( default_reduction, &base );
}
default_reduction = rx;
} else {
dump_reduction( rx, &base );
}
}
}
if( default_reduction != NULL ) {
pro = default_reduction->pro;
action = ACTION_REDUCE | pro->pidx;
} else {
action = ACTION_SHIFT | 0;
}
add_table( any_token, action );
++base;
sum += base - state_base[i];
if( base - state_base[i] > max ) {
max = base - state_base[i];
}
}
printf( "avg: %u max: %u\n", sum / nstate, max );
dump_define( "YYANYTOKEN", any_token );
dump_define( "YYEOFTOKEN", eofsym->token );
dump_define( "YYSTART", startstate->sidx );
begin_table( "YYACTTYPE", "yybasetab" );
for( i = 0; i < nstate; ++i ) {
puttab( FITS_A_WORD, state_base[i] );
}
end_table();
begin_table( "YYCHKTYPE", "yychktab" );
for( i = 0; i < used; ++i ) {
puttab( FITS_A_BYTE, table[i].token );
}
end_table();
begin_table( "YYACTTYPE", "yyacttab" );
for( i = 0; i < used; ++i ) {
puttab( FITS_A_WORD, table[i].action );
}
end_table();
begin_table( "YYPLENTYPE", "yyplentab" );
for( i = 0; i < npro; ++i ) {
for( item = protab[i]->item; item->p.sym; ++item )
/* do nothing */;
puttab( FITS_A_BYTE, item - protab[i]->item );
}
end_table();
begin_table( "YYPLHSTYPE", "yyplhstab" );
for( i = 0; i < npro; ++i ) {
puttab( FITS_A_BYTE, protab[i]->sym->token );
}
end_table();
fprintf( actout, "#ifdef YYDEBUG\n" );
rule_base = 0;
begin_table( "unsigned short", "yyrulebase" );
for( i = 0; i < npro; ++i ) {
for( item = protab[i]->item; item->p.sym; ++item )
/* do nothing */;
puttab( FITS_A_WORD, rule_base );
rule_base += item - protab[i]->item;
}
end_table();
begin_table( "YYCHKTYPE", "yyrhstoks" );
for( i = 0; i < npro; ++i ) {
for( item = protab[i]->item; item->p.sym; ++item ) {
puttab( FITS_A_BYTE, item->p.sym->token );
}
}
end_table();
begin_table( "char YYFAR *", "yytoknames" );
fputc( '\n', actout );
for( i = 0; i < nsym; ++i ) {
fprintf( actout, "\"%s\",\n", symtab[ i ]->name );
}
fprintf( actout, "\"\"" );
end_table();
fprintf( actout, "#endif\n" );
}
void genobj( void )
{
value_size token_size;
action_n *actions, *parent, *other;
base_n *base;
token_n *p, *q, *r, *s;
token_n *tokens, *same, *diff, *test, *best;
set_size *mp;
token_n tokval, dtoken, ptoken, ntoken;
action_n actval, error, redun, new_action;
a_sym *sym;
a_pro *pro;
an_item *item;
a_state *x;
a_shift_action *tx;
a_reduce_action *rx;
index_n i, j;
set_size savings, min, *size;
set_size shift;
token_n parent_base;
unsigned num_default, num_parent;
if( fastflag ) {
GenFastTables();
return;
}
if( bigflag || compactflag ) {
token_size = FITS_A_WORD;
} else {
token_size = FITS_A_BYTE;
}
num_default = 0;
num_parent = 0;
ntoken = FirstNonTerminalTokenValue();
dtoken = ntoken++;
ptoken = ntoken++;
for( i = nterm; i < nsym; ++i ) {
symtab[i]->token = ntoken++;
}
actions = CALLOC( ntoken, action_n );
error = nstate + npro;
for( i = 0; i < ntoken; ++i ) {
actions[i] = error;
}
tokens = CALLOC( ntoken, token_n );
test = CALLOC( ntoken, token_n );
best = CALLOC( ntoken, token_n );
other = CALLOC( nstate, action_n );
parent = CALLOC( nstate, action_n );
size = CALLOC( nstate, set_size );
base = CALLOC( nstate, base_n );
same = NULL;
r = NULL;
diff = NULL;
used = 0;
avail = 0;
table = NULL;
shift = 0;
parent_base = 0;
for( i = nstate; i > 0; ) {
--i;
x = statetab[i];
q = tokens;
for( tx = x->trans; (sym = tx->sym) != NULL; ++tx ) {
*q++ = sym->token;
actions[sym->token] = tx->state->sidx;
}
savings = 0;
for( rx = x->redun; (pro = rx->pro) != NULL; ++rx ) {
redun = pro->pidx + nstate;
mp = Members( rx->follow );
if( (set_size)( mp - setmembers ) > savings ) {
savings = (set_size)( mp - setmembers );
r = q;
}
while( mp != setmembers ) {
--mp;
tokval = symtab[*mp]->token;
*q++ = tokval;
actions[tokval] = redun;
}
}
if( savings ) {
actval = actions[*r];
other[i] = actval;
*q++ = dtoken;
actions[dtoken] = actval;
p = r;
while( savings-- > 0 )
actions[*p++] = error;
while( p < q )
*r++ = *p++;
q = r;
++num_default;
} else {
other[i] = error;
}
r = q;
min = (set_size)( q - tokens );
size[i] = min;
parent[i] = nstate;
for( j = nstate; --j > i; ) {
if( abs( size[j] - size[i] ) < min ) {
x = statetab[j];
p = test;
q = test + ntoken;
for( tx = x->trans; (sym = tx->sym) != NULL; ++tx ) {
if( actions[sym->token] == tx->state->sidx ) {
*p++ = sym->token;
} else {
*--q = sym->token;
}
}
for( rx = x->redun; (pro = rx->pro) != NULL; ++rx ) {
redun = pro->pidx + nstate;
if( redun == other[j] )
redun = error;
for( mp = Members( rx->follow ); mp != setmembers; ) {
--mp;
tokval = symtab[*mp]->token;
if( actions[tokval] == redun ) {
*p++ = tokval;
} else {
*--q = tokval;
}
}
}
if( other[j] != error ) {
if( other[j] == other[i] ) {
*p++ = dtoken;
} else {
*--q = dtoken;
}
}
savings = (set_size)( size[i] + size[j] - 2 * ( p - test ) );
if( savings < min ) {
min = savings;
same = p;
diff = q;
s = test; test = best; best = s;
parent[i] = j;
}
}
}
if( min >= size[i] ) {
s = r;
} else {
++num_parent;
s = tokens;
p = same;
while( --p >= best )
actions[*p] = error;
for( q = tokens; q < r; ++q ) {
if( actions[*q] != error ) {
*s++ = *q;
}
}
p = best + ntoken;
while( --p >= diff ) {
if( actions[*p] == error ) {
*s++ = *p;
}
}
actval = parent[i];
*s++ = ptoken;
actions[ptoken] = actval;
}
base[i] = addtotable( tokens, s, actions, dtoken, ptoken );
while( --s >= tokens ) {
actions[*s] = error;
}
}
FREE( actions );
FREE( tokens );
FREE( test );
FREE( best );
FREE( other );
FREE( size );
putambigs( base );
putnum( "YYNOACTION", error - nstate + used );
putnum( "YYEOFTOKEN", eofsym->token );
putnum( "YYERRTOKEN", errsym->token );
putnum( "YYETOKEN", errsym->token );
if( compactflag ) {
parent_base = used + npro;
putnum( "YYPARENT", parent_base );
shift = 8;
for( i = 256; i < used; i <<= 1 ) {
++shift;
}
putnum( "YYPRODSIZE", shift );
} else {
putnum( "YYPTOKEN", ptoken );
putnum( "YYDTOKEN", dtoken );
}
putnum( "YYSTART", base[startstate->sidx] );
putnum( "YYSTOP", base[eofsym->enter->sidx] );
putnum( "YYERR", base[errstate->sidx] );
putnum( "YYUSED", used );
if( compactflag ) {
begtab( "YYPACKTYPE", "yyacttab" );
j = nstate;
for( i = 0; i < used; ++i ) {
new_action = table[i].action;
if( i == base[j - 1] ) {
--j;
// First element in each state is default/parent
if( parent[j] == nstate ) {
// No parent state
tokval = used + parent_base;
} else {
tokval = base[parent[j]] + parent_base;
}
// 0 indicates no default
if( new_action != 0 ) {
if( new_action < nstate ) {
// Shift
new_action = base[new_action];
} else {
// Reduce
new_action -= nstate; // convert to 0 based
new_action += used; // now convert to 'used' base
}
}
} else {
tokval = table[i].token;
if( new_action < nstate ) {
// Shift
new_action = base[new_action];
} else {
// Reduce
new_action -= nstate; // convert to 0 based
new_action += used; // now convert to 'used' base
}
}
putcompact( tokval, new_action );
}
endtab();
// Combine lengths & lhs into a single table
begtab( "YYPRODTYPE", "yyprodtab" );
for( i = 0; i < npro; ++i ) {
j = 0;
for( item = protab[i]->items; item->p.sym != NULL; ++item ) {
++j;
}
puttab( FITS_A_WORD, (j << shift) + protab[i]->sym->token );
}
endtab();
} else {
begtab( "YYCHKTYPE", "yychktab" );
for( i = 0; i < used; ++i ) {
puttab( token_size, Token( table + i ) );
}
endtab();
begtab( "YYACTTYPE", "yyacttab" );
for( i = 0; i < used; ++i ) {
j = Action( table + i );
if( j < nstate ) {
puttab( FITS_A_WORD, base[j] );
} else {
puttab( FITS_A_WORD, j - nstate + used );
}
}
endtab();
begtab( "YYPLENTYPE", "yyplentab" );
for( i = 0; i < npro; ++i ) {
for( item = protab[i]->items; item->p.sym != NULL; ) {
++item;
}
puttab( FITS_A_BYTE, (unsigned)( item - protab[i]->items ) );
}
endtab();
begtab( "YYPLHSTYPE", "yyplhstab" );
for( i = 0; i < npro; ++i ) {
puttab( token_size, protab[i]->sym->token );
}
endtab();
}
FREE( table );
FREE( base );
FREE( parent );
dumpstatistic( "bytes used in tables", bytesused );
dumpstatistic( "states with defaults", num_default );
dumpstatistic( "states with parents", num_parent );
puttokennames( dtoken, token_size );
FREE( protab );
FREE( symtab );
}
