void check_case(FILE *in)
{
int params[MAX_M];
int n, m;
int i, j;
read_int(in, 2, params);
n = params[0];
m = params[1];
check_int_range(n, 1, MAX_N, "n");
check_int_range(m, 1, MAX_M, "m");
check_EOL(in);
char appeared[MAX_N+1];
for (j = 1; j <= n; j++) {
appeared[j] = 0;
}
for (i = 0; i < m; i++) {
int p, s;
read_int(in, 2, params);
p = params[0];
s = params[1];
check_int_range(p, 1, MAX_P, "p");
check_int_range(s, 1, n, "s");
match_char(in, ' ');
read_int(in, s, params);
char used[MAX_N+1];
for (j = 1; j <= n; j++) {
used[j] = 0;
}
for (j = 0; j < s; j++) {
check_int_range(params[j], 1, n, "si");
if (used[params[j]]) {
fprintf(stderr, "Case %d: bundle %d has duplicate items\n",
get_case(), i+1);
exit(1);
}
used[params[j]] = 1;
appeared[params[j]] = 1;
}
check_EOL(in);
}
for (j = 1; j <= n; j++) {
if (!appeared[j]) {
fprintf(stderr, "Case %d: item %d does not appear in any bundle.\n",
get_case(), j);
exit(1);
}
}
}
/* supprime les possibilites des chiffres presents sur la ligne */
int calcul_ligne(SUDOKU grille, int ligne, int col){
int indcol, maj = 1;
if(get_case(grille, ligne, col) == 0){ /* si la case n'est pas encore trouvee */
for(indcol=1; indcol<10; indcol++){
if(get_case(grille, ligne, indcol) != 0 && get_possibilite_case(grille, ligne, col, get_case(grille, ligne, indcol)) != 0){ /* si la case actuelle a une possibilite correspondant a une chiffre de la ligne */
suppr_possibilite(grille, ligne, col, get_case(grille, ligne, indcol));
maj = 2;
}
}
}
return maj;
}
/*Detecteur de colision a améliorer!!*/
int check_colision(Pacman *pac, Fantome f)
{
SDL_Rect pac_case = get_case(pac->position, pac->cur_direction);
SDL_Rect ftm_case = get_case(f.position, f.cur_direction);
//S'ils sont sur la meme case alors colision /!\ En cas de changement de case entre 2 deplacements
//pas de colision détécté.
if(pac_case.x == ftm_case.x && pac_case.y == ftm_case.y)
{
if(f.invinsible) return 1; //Pacman se fait manger
else if(!f.dead) return 2; //Fantome se fait manger
else return 0; //Si Pac croise un fantome déja mort
}
else return 0;
}
int calcul_colonne(SUDOKU grille, int ligne, int col){
int indline, maj = 1;
if(get_case(grille, ligne, col) == 0){
for(indline=1; indline<10; indline++){
if(get_case(grille, indline, col) != 0 && get_possibilite_case(grille, ligne, col, get_case(grille, indline, col)) != 0){
suppr_possibilite(grille, ligne, col, get_case(grille, indline, col));
maj = 2;
}
}
}
return maj;
}
int main(int argc ,char* argv[])
{
char* a;
char* s;
char t;
if (argc != 2)
{
printf("cs50");
return 1;
}
for (int i = 0; i<strlen(argv[1]);i++)
{
if ( isdigit(argv[1][i]) != 0)
{
printf("you entered digit %c\n", argv[1][i]);
return 1;
}
}
s = GetString();
//allocate array to store shift amounts of each character in s
a = malloc(strlen(s) * sizeof(char));
int i,j;
for ( i = 0,j = 0;i < strlen(s);i++)
{
t = s[i];
//check if s[i] is a letter
if (isalpha(s[i]) != 0){
//check if the letter is lower or upper
t = get_case(t);
//get index of argv[1]
j = (j% strlen(argv[1]));
//store shift value in a[i]
a[i] = (argv[1][j] - get_case(argv[1][j])) % 26;
// print out one encrypted letter at a time
printf("%c", t + ((s[i] - t + a[i]) %26));
j++;
}
else
printf("%c",s[i]);
}
printf("\n");
}
char *dump_case(t_kernel *kernel, t_client *cl, t_pos pos)
{
t_case *c;
size_t i;
int nb;
char buffer[BUFFER_SIZE] = {0};
i = 0;
c = get_case(kernel, pos.y, pos.x);
if (!c)
return (NULL);
dump_player_case(pos, cl, c, buffer);
while (i < ITEM_TYPE)
{
nb = 0;
while (nb < c->inventory.items[i])
{
sprintf(buffer, "%s%s ", buffer, g_item_names[i]);
++nb;
}
++i;
}
buffer[strlen(buffer) - 1] = 0;
return (strdup(buffer));
}
int calcul_carre(SUDOKU grille, int ligne, int col){
int indcarline, indcarcol, ld, cd, maj = 1;
ld = 3*((ligne-1)/3)+1;
cd = 3*((col-1)/3)+1;
if(get_case(grille, ligne, col) == 0){
for(indcarline=ld; indcarline<ld+3; indcarline++){
for(indcarcol=cd; indcarcol<cd+3; indcarcol++){
if(get_case(grille, indcarline, indcarcol) != 0 && get_possibilite_case(grille, ligne, col, get_case(grille, indcarline, indcarcol)) != 0){
suppr_possibilite(grille, ligne, col, get_case(grille, indcarline, indcarcol));
maj = 2;
}
}
}
}
return maj;
}
static int get_rep(t_stck *s, t_fd *a, t_fd *b)
{
int x;
int y;
x = a->x - b->x;
x = (x > (s->map.x / 2)) ? x - s->map.x : x;
x = (x < (-(s->map.x / 2))) ? x + s->map.x : x;
y = a->y - b->y;
y = (y > (s->map.y / 2)) ? y - s->map.y : y;
y = (y < (-(s->map.y / 2))) ? y + s->map.y : y;
return (get_case(b, x, y));
}
int incantation(char **av, t_client *cl, t_kernel *kernel)
{
int check;
t_case *c;
(void)av;
check = 0;
c = get_case(kernel, cl->player->pos.y, cl->player->pos.x);
if (check_case_for_incantation(c, cl->player->level))
check = 1;
finish_elevation(c, cl->player->level + check);
send_finish_elevation_to_graphic(kernel, c, cl->player, check);
return (check_victory(kernel));
}
int aff_path(Map *map, Case *tab)
{
int i = 0;
SDL_Rect pos;
while (tab[i].x != -42 && (tab[i].x != map->pacman.pos.x/IMG || tab[i].y != map->pacman.pos.y/IMG))
i++;
while ((i = get_case(tab, i)) >= 0)
{
pos.x = tab[i].x*IMG;
pos.y = tab[i].y*IMG;
SDL_BlitSurface(map->select, NULL, map->ecran, &pos);
}
}
/* Voit si une action peut etre accomplie*/
void action(Pacman *pac, Fantome *ftm, score_message **msg_list)
{
int i, col;
SDL_Rect pos = get_case(pac->position, pac->cur_direction);
//Gagne une vie
if(pac->score && (pac->score)%10000 == 0 && pac->nb_lives < 5)
{
pac->nb_lives++;
pac->score+=100;
}
//Verifie si pacman et fantomes se rencontrent
for(i=0; i<NB_GHOST; i++) {
col=check_colision(pac, ftm[i]);
if(col==1) {
pac_death(pac); //Pacman est mort :(
for(i=0; i<NB_GHOST; i++) ghost_restart(ftm+i);
return;
}
if(col==2) {
ghost_death(ftm+i); //Fantome meurt
pac->ghost_eaten++;
pac->score+=200*(pac->ghost_eaten);
add_new_message(msg_list, 9+pac->ghost_eaten, pos);
return;
}
}
if( LEVEL[pos.y][pos.x].type == BONUS && dans_case(pac->position) )
{
if(LEVEL[pos.y][pos.x].elt_type==0) //Super Pac-gomme
{
set_ghosts_eatable(ftm);
pac->counter=SDL_GetTicks();
}
else if(LEVEL[pos.y][pos.x].elt_type==1) pac->score+=100; //Cerise
else if(LEVEL[pos.y][pos.x].elt_type==2) pac->score+=300; //Fraise
else if(LEVEL[pos.y][pos.x].elt_type==3) pac->score+=500; //Orange
else if(LEVEL[pos.y][pos.x].elt_type==4) pac->score+=700; //Pomme
else if(LEVEL[pos.y][pos.x].elt_type==5) pac->score+=1000; //Melon
else if(LEVEL[pos.y][pos.x].elt_type==6) pac->score+=2000; //Galboss
else if(LEVEL[pos.y][pos.x].elt_type==7) pac->score+=3000; //Cloche
else if(LEVEL[pos.y][pos.x].elt_type==8) { //Clé
pac->score+=5000;
pac->nb_keys++;
}
if(LEVEL[pos.y][pos.x].elt_type==9) POINTS--; //Pac-gomme
add_new_message(msg_list, LEVEL[pos.y][pos.x].elt_type, pos);
LEVEL[pos.y][pos.x].type=RIEN; //On l'a mangé bravo!
}
}
static int get_grid(unsigned char grille[9][9], const char *line, int n)
{
int i;
if (n == 0 || n == 10)
return ((strcmp(line, "|------------------|\n") != 0));
if (line[0] != '|' || line[19] != '|')
return (1);
i = 2;
while (i < 19)
{
if (get_case(grille, line[i], n - 1, (i / 2) - 1) || line[i - 1] != ' ')
return (1);
i = i + 2;
}
return (0);
}
void dump_map(t_kernel *kernel)
{
int x;
int y;
t_case *map_case;
for (x = 0; x < kernel->game.map->height; ++x)
{
for (y = 0; y < kernel->game.map->width; ++y)
{
map_case = get_case(kernel, y, x);
if (list_size(map_case->players))
printf("%d", (int)list_size(map_case->players));
else
printf(".");
}
printf("\n");
}
}
int cmd_incantation(char **av, t_client *cl, t_kernel *kernel)
{
t_case *c;
char **av2;
(void)av;
if (cl->player->level > MAX_LVL)
return (ko(cl->fd));
c = get_case(kernel, cl->player->pos.y, cl->player->pos.x);
if (!check_case_for_incantation(c, cl->player->level))
return (ko(cl->fd));
send_elevation_to_graphic(kernel, c, cl->player);
if (!(av2 = malloc(sizeof(*av2) * 2)))
return (-1);
if (!(av2[0] = strdup("elevation")))
return (-1);
av2[1] = NULL;
if (FALSE == add_action(300, cl->player, av2, 1))
return (-1);
return (launch_elevation(c));
}
/* Si, sur une meme ligne, deux case ont uniquement 2 possibilites et que ces possibilites sont identiques alors ces possibilites sont supprimees pour le reste de la ligne */
int calcul_2poss_ligne(SUDOKU grille, int ligne, int col){
int a, b, cpt, indcol, indcol2, indposs, maj = 1, poss[2], possc[2];
if(nb_possibilite(grille, ligne, col) == 2){
cpt = 0;
for(indposs=1; indposs<10; indposs++){ /* enregistrement des possibilites de la case en cours (si uniquement 2 possibilites) */
if(get_possibilite_case(grille, ligne, col, indposs) != 0){
poss[cpt] = indposs;
cpt++;
}
}
for(indcol=1; indcol<10; indcol++){ /* pour toute la ligne */
if(nb_possibilite(grille, ligne, indcol) == 2 && indcol != col){
cpt = 0;
for(indposs=1; indposs<10; indposs++){ /* enregistrement des possibilites de la sur la ligne de la case en cours (si uniquement 2 possibilites) */
if(get_possibilite_case(grille, ligne, indcol, indposs) != 0){
possc[cpt] = indposs;
cpt++;
}
}
if(poss[0] == possc[0] && poss[1] == possc[1]){ /* Si les possibilites sont identiques */
for(indcol2=1; indcol2<10; indcol2++){ /* On supprime ces possibilites pour le reste de la ligne */
if( indcol2 != col && indcol2 != indcol && get_case(grille, ligne, indcol2) == 0){
a = suppr_possibilite(grille, ligne, indcol2, poss[0]);
b = suppr_possibilite(grille, ligne, indcol2, poss[1]);
if(a != 0 || b != 0){
maj += 2;
}
}
}
}
}
}
}
return maj;
}
int calcul_2poss_colonne(SUDOKU grille, int ligne, int col){
int a, b, cpt, indline, indline2, indposs, maj = 1, poss[2], possc[2];
if(nb_possibilite(grille, ligne, col) == 2){
cpt = 0;
for(indposs=1; indposs<10; indposs++){
if(get_possibilite_case(grille, ligne, col, indposs) != 0){
poss[cpt] = indposs;
cpt++;
}
}
for(indline=1; indline<10; indline++){
if(nb_possibilite(grille, indline, col) == 2 && indline != ligne){
cpt = 0;
for(indposs=1; indposs<10; indposs++){
if(get_possibilite_case(grille, indline, col, indposs) != 0){
possc[cpt] = indposs;
cpt++;
}
}
if(poss[0] == possc[0] && poss[1] == possc[1]){
for(indline2=1; indline2<10; indline2++){
if( indline2 != ligne && indline2 != indline && get_case(grille, indline2, col) == 0){
a = suppr_possibilite(grille, indline2, col, poss[0]);
b = suppr_possibilite(grille, indline2, col, poss[1]);
if(a != 0 || b != 0){
maj += 2;
}
}
}
}
}
}
}
return maj;
}
/* met la valeur dans la case s'il reste une seule possibilite */
int set_val_possibilite_unique(SUDOKU grille, int ligne, int col){
int indposs, count = 0, val, maj = 1;
if(get_case(grille, ligne, col) == 0){
for(indposs=1; indposs<10; indposs++){
if(get_possibilite_case(grille, ligne, col, indposs) != 0){
val = get_possibilite_case(grille, ligne, col, indposs);
count++;
}
}
if(count == 1){
set_case(grille, ligne, col, val);
maj = 2;
}
else if(count == 0){
maj = 0;
}
}
return maj;
}
struct test_case *get_cases(int *num)
{
int i;
int size;
struct test_case *cases;
scanf("%d", num);
size = sizeof(struct test_case) * *num;
if ((cases = malloc(size)) == NULL) {
fprintf(stderr, "malloc failed\n");
return NULL;
}
memset(cases, 0, size);
for (i = 0; i < *num; i++) {
if (get_case(&cases[i]) < 0) {
return NULL;
}
}
return cases;
}
int calcul_2poss_carre(SUDOKU grille, int ligne, int col){
int a, b, cpt, indposs, indcarline, indcarcol, indcarline2, indcarcol2, ld, cd, maj = 1, poss[2], possc[2];
if(nb_possibilite(grille, ligne, col) == 2){
ld = 3*((ligne-1)/3)+1;
cd = 3*((col-1)/3)+1;
cpt = 0;
for(indposs=1; indposs<10; indposs++){ /* enregistrement des possibilites de la case en cours (si uniquement 2 possibilites) */
if(get_possibilite_case(grille, ligne, col, indposs) != 0){
poss[cpt] = indposs;
cpt++;
}
}
for(indcarline=ld; indcarline<ld+3; indcarline++){
for(indcarcol=cd; indcarcol<cd+3; indcarcol++){
if(nb_possibilite(grille, indcarline, indcarcol) == 2 && (indcarline != ligne || indcarcol != col)){
cpt = 0;
for(indposs=1; indposs<10; indposs++){
if(get_possibilite_case(grille, indcarline, indcarcol, indposs) != 0){
possc[cpt] = indposs;
cpt++;
}
}
if(poss[0] == possc[0] && poss[1] == possc[1]){
for(indcarline2=ld; indcarline2<ld+3; indcarline2++){
for(indcarcol2=cd; indcarcol2<cd+3; indcarcol2++){
if( (indcarline2 != ligne || indcarcol2 != col) && (indcarline2 != indcarline || indcarcol2 != indcarcol) && get_case(grille, indcarline2, indcarcol2) == 0){
a = suppr_possibilite(grille, indcarline2, indcarcol2, poss[0]);
b = suppr_possibilite(grille, indcarline2, indcarcol2, poss[1]);
if(a != 0 || b != 0){
maj += 2;
}
}
}
}
}
}
}
}
}
return maj;
}
