CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.5)
-set(CMAKE_C_FLAGS "-std=c99 -lncurses -g -Wall")
+set(CMAKE_C_FLAGS "-std=c99 -g -Wall")
 set(CMAKE_INSTALL_PREFIX ".") 
-include_directories(include)
 #set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin)
+include_directories(include)
 project(utictactoe)
-add_executable(${PROJECT_NAME}  src/utictactoe.c src/model.c src/view.c)
+add_executable(${PROJECT_NAME}  src/utictactoe.c src/model.c)

include/common.h

@@ -24,9 +24,4 @@ typedef enum {
   ALMOST,
 } e_status;
 
-typedef enum {
-  HUMAN,
-  RANDOM,
-  CLEVER,
-} e_tactic;
 #endif /*COMMON*/

include/ia.h

@@ -1,17 +0,0 @@
-#ifndef IA_H
-#define IA_H
-#include "common.h"
-#include "model.h"
-/*!
- * This function modify the move in parameter in order to get a valid move (1) randomly if tactic is 0 or 
- * (2) in a clever way if tactic is 1 in the corresponding utictactoe u.
- *
- * \param p_uttt a pointer on a s_utictactoe.
- * \param p_move a pointer on a s_move to be modified.
- * \param tactic an e_tactic set to 0 for random strategy and 1 for clever one.
- */
-void best_move(s_utictactoe* p_uttt, s_move* p_move, e_tactic tactic);
-
-s_tictactoe * clone_ttt( s_tictactoe * p_ttt );
-e_location get_best_random_position( s_tictactoe * p_uttt, e_player player);
-#endif

include/model.h

@@ -192,5 +192,4 @@ e_status play_move(s_utictactoe *p_uttt, s_move *p_move);
 /*Given usefull functions*/
 void draw_utictactoe(s_utictactoe *p_uttt);
 void draw_utictactoe_history(s_utictactoe *p_uttt);
-void save_a_utictactoe_to_file(FILE *p_f, s_utictactoe *p_uttt);
 #endif /* MODEL_H */

include/view.h

@@ -1,39 +0,0 @@
-#ifndef VIEW_H
-#define VIEW_H
-#include <ncurses.h>
-#include "common.h"
-#include "model.h"
-
-typedef struct view * p_view; 
-
-/*!
- * This function allocates dynamically a struct view in order to handle the corresponding u_tictactoe.
- *
- * \param p_uttt a pointer on a s_utictactoe.
- * \return a reference to the s_utictactoe memory space allocated, NULL in case
- * of allocation problem.
- */
-p_view  create_view(s_utictactoe * p_uttt);
-
-void draw_ttt(WINDOW * w, s_tictactoe * t);
-//e_location display_ttt( WINDOW * w, s_tictactoe * ttt);
-e_location coord_to_elocation( int x, int y);
-int elocation_to_coord(e_location l);
-/*!
- * This function retrieves a valid move proposal from the user using the corresponding view.
- *
- * \param p_move a pointer on a s_move to be modified.
- * \param v a pointer on the view to use.
- */
-void set_next_player_move(s_move * p_move, p_view v, e_tactic tactic);
-
-void display_winner(p_view v);
-/*!
- * This function free all the memory used by a given view which
- * reference is given.
- *
- * \param v a pointer on a view to be freed.
- */
-void free_view(p_view v);
-
-#endif /* VIEW_H */

src/CMakeLists.txt

@@ -1,6 +1,7 @@
 cmake_minimum_required(VERSION 3.5)
-set(CMAKE_C_FLAGS "-std=c99 -lncurses -g -Wall")
+set(CMAKE_C_FLAGS "-std=c99 -g -Wall")
 set(CMAKE_INSTALL_PREFIX ".") 
 include_directories(../include)
+
 project(utictactoe)
-add_executable(${PROJECT_NAME}  utictactoe.c model.c view.c ia.c)
+add_executable(${PROJECT_NAME}  utictactoe.c model.c)

src/ia.c

@@ -1,76 +0,0 @@
-#include "common.h"
-#include "model.h"
-#include "view.h"
-#include "ia.h"
-
-void best_move (s_utictactoe * p_uttt, s_move * m ,e_tactic tactic)
-{
-    //do{
-        if ( p_uttt->inception_level == 1 ) {
-            m->outer_position = get_best_random_position(
-                    p_uttt->outer_tictactoe,
-                    m->player
-                );
-        }
-        else {
-            m->outer_position = get_next_outer_position(p_uttt);
-            if ( m->outer_position == FREE ) {
-                do {
-                    m->outer_position = (e_location)(TOPLEFT + rand() % TICTACTOE_SIZE);
-                } while(p_uttt->inner_tictactoes[m->outer_position]->winner != NOBODY);
-            }
-
-            m->inner_position = get_best_random_position(
-                    p_uttt->inner_tictactoes[m->outer_position],
-                    m->player
-            );
-        }
-    //} while (is_move_valid(p_uttt,m) != YES);
-    return;
-}
-
-s_tictactoe * clone_ttt( s_tictactoe * p_ttt ) {
-    s_tictactoe * t = create_empty_tictactoe();
-    for (int i=0; i<TICTACTOE_SIZE; i++){
-        t->content[i] = p_ttt->content[i];
-    }
-    return t;
-}
-
-e_location get_best_random_position (s_tictactoe * p_ttt, e_player player) {
-    mvwprintw(stdscr, 13, 0, "                                  ");
-    s_tictactoe * c_ttt = clone_ttt(p_ttt);
-    e_player opponent = ( player == PLAYER_O )?PLAYER_X:PLAYER_O;
-
-    // Check if IA player can win
-    for(int i=0; i<TICTACTOE_SIZE; i++) {
-        if(c_ttt->content[i] == NOBODY) {
-            c_ttt->content[i] = player;
-            set_tictactoe_winner(c_ttt);
-            if ( c_ttt->winner != NOBODY ) {
-                free_tictactoe(c_ttt);
-                mvwprintw(stdscr, 13, 0, "Je vais gagner                    ");  
-                return i;
-            }
-            c_ttt->content[i] = NOBODY;
-        }
-    }
-
-    // avoid loosing
-    for(int i=0; i<TICTACTOE_SIZE; i++) {
-        if(c_ttt->content[i] == NOBODY) {
-            c_ttt->content[i] = opponent;
-            set_tictactoe_winner(c_ttt);
-            if ( c_ttt->winner != NOBODY ) {
-                free_tictactoe(c_ttt);
-                mvwprintw(stdscr, 13, 0, "Je ne peux pas te laisser gagner!");  
-                return i;
-            } 
-            c_ttt->content[i] = NOBODY;
-        }
-    }
-
-    // We have not a winnner move...
-    free_tictactoe(c_ttt);
-    return (e_location)(rand() % TICTACTOE_SIZE);
-}

src/model.c

@@ -1,50 +1,5 @@
 #include "model.h"
 
-// Define shorts positions
-char * get_short_position(e_location pos){
-    switch(pos) {
-        case TOPLEFT:
-            return "TL";
-        case TOPCENTER:
-            return "TC";
-        case TOPRIGHT:
-            return "TR";
-        case MIDLEFT:
-            return "ML";
-        case MIDCENTER:
-            return "MC";
-        case MIDRIGHT:
-            return "MR";
-        case BOTTOMLEFT:
-            return "BL";
-        case BOTTOMCENTER:
-            return "BC";
-        case BOTTOMRIGHT:
-            return "BR";
-        case FREE:
-            return "FR";
-        case NONE:
-            return "NO";
-        default:
-            return "NO";
-    }
-}
-
-char get_short_player(e_player player){
-    switch(player){
-        case PLAYER_O:
-            return 'O';
-        case PLAYER_X:
-            return 'X';
-        case NOBODY:
-            return '.';
-        case BOTH:
-            return '#';
-        default:
-            return NO;
-    }
-}
-
 
 /*
  * Create empty move
@@ -215,154 +170,113 @@ e_status is_move_valid(s_utictactoe *p_uttt, s_move *p_move) {
 }
 
 void set_tictactoe_winner(s_tictactoe *p_ttt){
+    bool find;
+    int next;
 
-    // columns
+    if ( p_ttt->winner == NOBODY ) {
         for(int i = 0; i < TICTACTOE_WIDTH; i++){
-        if (p_ttt->content[i] != NOBODY
+
-                &&p_ttt->content[i] == p_ttt->content[i+3]
+            /*
-                && p_ttt->content[i] == p_ttt->content[i+6]) {
+             * Test for first diagonale
+             */
+            if ( p_ttt->content[i] != NOBODY ) {
+                // if case 0 we need to test diagonale
+                if ( i == 0 ){
+                    int next;
+                    find = true;
+                    for (int l = 1; l < TICTACTOE_WIDTH; l++) {
+                        // Maybe it is overkill to test diagonal but...
+                        // ... no need to rewrite if we update TICTACTOE_WIDTH
+                        next = l * TICTACTOE_WIDTH + l;
+                        if ( p_ttt->content[i] != p_ttt ->content[next]) {
+                            find = false;
+                            break;
+                        }
+                    }
+                    if (find == true) {
+                        p_ttt->winner = p_ttt->content[i];
+                        return;
+                    }
+                }
+            }
+
+            /*
+             * second diagonal, from the end of line
+             */
+            if ( i == TICTACTOE_WIDTH - 1 ) {
+                find = true;
+                for ( int l = 1; l < TICTACTOE_WIDTH; l++){
+                    next = (TICTACTOE_WIDTH - 1) * l;
+                    if ( p_ttt->content[i] == p_ttt->content[next] ) {
+                        find = false;
+                        break;
+                    }
+                }
+                if ( find == true ){
                     p_ttt->winner = p_ttt->content[i];
                     return;
                 }
             }
 
-    //lines
+            /*
-    for ( int i=0; i < TICTACTOE_SIZE; i=i+3 ) {
+             * column
-        if (p_ttt->content[i] != NOBODY
+             */
-                &&p_ttt->content[i] == p_ttt->content[i+1]
+            find = true;
-                && p_ttt->content[i] == p_ttt->content[i+2]) {
+            for (int c = 1; c < TICTACTOE_WIDTH; c++ ) {
+                next = TICTACTOE_WIDTH * c + i;
+                if ( p_ttt->content[i] != p_ttt->content[next]) {
+                    find = false;
+                    break;
+                }
+                if ( find == true ){
                     p_ttt->winner = p_ttt->content[i];
                     return;
                 }
             }
 
-    //diagonale
+            /*
-    if ( p_ttt->content[0] != NOBODY
+             * line
-            && p_ttt->content[0] == p_ttt->content[4]
+             */
-            && p_ttt->content[0] == p_ttt->content[8] ) {
+            int line = i * TICTACTOE_WIDTH;
-        p_ttt->winner = p_ttt->content[0];
+            if (p_ttt->content[line] != NOBODY){
+                find = true;
+                for ( int l = 1; l < TICTACTOE_WIDTH; l++ ) {
+                    next = line + l;
+                    if ( p_ttt->content[line] != p_ttt->content[next] ) {
+                        find = false;
+                        break;
+                    }
+                }
+                if ( find == true ) {
+                    p_ttt->winner = p_ttt->content[line];
                     return;
                 }
-    //diagonale
+            }
-    if ( p_ttt->content[2] != NOBODY
-            && p_ttt->content[2] == p_ttt->content[4]
-            && p_ttt->content[2] == p_ttt->content[6] ) {
-        p_ttt->winner = p_ttt->content[2];
-        return;
         }
 
         // check if a move could be done, if not retuen BOTH (no winner)
+        find = false;
         for (int i = 0; i < TICTACTOE_SIZE; i++){
             if ( p_ttt->content[i] == NOBODY ) {
-            return;
+                find = true;
+                break;
             }
         }
+        if ( find == false ) {
             p_ttt->winner = BOTH;
         }
+    } 
+}
 
 e_status play_move(s_utictactoe *p_uttt, s_move *p_move) {
-    if (is_move_valid(p_uttt, p_move) == NO) {
+    if (is_move_valid(p_uttt, p_move) == YES) {
-        return NO;
+        // we can process things
-    }
+        if ( p_uttt->inception_level == 1 ) {
-    list_element_s_move *value  = (list_element_s_move*)
-        malloc(sizeof(list_element_s_move));
-
-    // we need to create a s_move in memory...
-    // and affect p_move
-    value->last_move = create_empty_move();
-
-    value->last_move->inner_position = p_move->inner_position;
-    value->last_move->outer_position = p_move->outer_position;
-    value->last_move->player = p_move->player;
-    if ( p_uttt->history == NULL ) {
-        value->next = NULL;
-    }
-    else {
-        value->next = p_uttt->history;
-    }
-    p_uttt->history = value;
-
-    if ( p_uttt->inception_level != 1 ) {
-        p_uttt->inner_tictactoes[p_move->outer_position]->content[p_move->inner_position] = p_move->player;
-        set_tictactoe_winner(p_uttt->inner_tictactoes[p_move->outer_position]);
-        
-        //check if we have a winner in inner_ttt then set player to outer 
-        p_uttt->outer_tictactoe->content[p_move->outer_position] = p_uttt->inner_tictactoes[p_move->outer_position]->winner;
-    }
-    else {
             p_uttt->outer_tictactoe->content[p_move->outer_position] = p_move->player;
         }
-    set_tictactoe_winner(p_uttt->outer_tictactoe);
+        else {
+            
+        }
+    }
     return YES;
 }
-
-void save_a_utictactoe_to_file(FILE *p_f, s_utictactoe *p_uttt){
-    assert(p_f);
-    assert(p_uttt);
-    fprintf(p_f, "%d\n", p_uttt->inception_level);
-    if(p_uttt->history){
-        list_element_s_move * c_hist = p_uttt->history;
-        while (c_hist != NULL){
-            if(c_hist->last_move){
-                fprintf(p_f, "%s %s %c\n", 
-                    get_short_position(c_hist->last_move->inner_position), 
-                    get_short_position(c_hist->last_move->outer_position), 
-                    get_short_player(c_hist->last_move->player));
-            }
-            c_hist = c_hist->next;
-        }
-    }
-}
-void draw_ith_line_of_ttt(s_tictactoe *p_ttt, uint line) {
-  assert(p_ttt);
-  printf("%c%c%c", p_ttt->content[line * TICTACTOE_WIDTH],
-         p_ttt->content[line * TICTACTOE_WIDTH + 1],
-         p_ttt->content[line * TICTACTOE_WIDTH + 2]);
-}
-
-void draw_tictactoe(s_tictactoe *p_ttt) {
-  assert(p_ttt);
-  for (uint line = 0; line < TICTACTOE_WIDTH; line++) {
-    draw_ith_line_of_ttt(p_ttt, line);
-    printf("\n");
-  }
-}
-
-void draw_utictactoe_history(s_utictactoe *p_uttt) {
-  assert(p_uttt);
-  char *e_location_name[] = {"TL", "TC", "TR", "ML",   "MC",  "MR",
-                             "BL", "BC", "BR", "FREE", "NONE"};
-  list_element_s_move *tmp = p_uttt->history;
-  while (tmp != NULL) {
-    if (tmp->last_move) {
-      printf(" - %s %s %c \n", e_location_name[tmp->last_move->inner_position],
-             e_location_name[tmp->last_move->outer_position],
-             tmp->last_move->player);
-    }
-    tmp = tmp->next;
-  }
-}
-
-void draw_utictactoe(s_utictactoe *p_uttt) {
-  assert(p_uttt);
-  if (p_uttt->inception_level == 1) {
-    draw_tictactoe(p_uttt->outer_tictactoe);
-  } else {
-    for (uint id_ttt = 0; id_ttt < TICTACTOE_SIZE;
-         id_ttt = id_ttt + TICTACTOE_WIDTH) {
-      for (uint line = 0; line < TICTACTOE_WIDTH; line++) {
-        draw_ith_line_of_ttt(p_uttt->inner_tictactoes[id_ttt], line);
-        printf("|");
-        draw_ith_line_of_ttt(p_uttt->inner_tictactoes[id_ttt + 1], line);
-        printf("|");
-        draw_ith_line_of_ttt(p_uttt->inner_tictactoes[id_ttt + 2], line);
-        printf("\n");
-      }
-      if (id_ttt + TICTACTOE_WIDTH < TICTACTOE_SIZE) {
-        printf("-----------");
-        printf("\n");
-      }
-    }
-  }
-  printf("\n####\n");
-}

src/utictactoe.c

@@ -8,8 +8,6 @@
 #include "utictactoe.h"
 #include "common.h"
 #include "model.h"
-#include "view.h"
-#include "ia.h"
 
 #define OPTIONAL_ARGUMENT_IS_PRESENT \
      ((optarg == NULL && optind < argc && argv[optind][0] != '-') \
@@ -47,15 +45,15 @@ int check_int_value ( char *value, int min, int max){
 
 int main(int argc, char* argv[]) {
     int optc;
-    e_tactic tactic_cross = HUMAN, tactic_round = HUMAN;
+    int cross_ai, round_ai = 0;
-    int inception_level = 2;
+    int inception_level = 0;
     bool verbose, contest_mode = false;
     char * contest_file;
     static struct option long_opts[] =
         {
           {"inception-level",   optional_argument,  0, 'i'},
-          {"tactic_cross",      required_argument,  0, 'x'},
+          {"cross-ai",          required_argument,  0, 'x'},
-          {"tactic_round",      required_argument,  0, 'o'},
+          {"round-ai",          required_argument,  0, 'o'},
           {"contest",           required_argument,  0, 'c'},
           {"verbose",           no_argument,        0, 'v'},
           {"version",           no_argument,        0, 'V'},
@@ -81,8 +79,8 @@ int main(int argc, char* argv[]) {
         case 'x':
             printf ("cross ai\n");
             if ( optarg ) {
-                tactic_cross = check_int_value(optarg, 0, 2);
+                cross_ai = check_int_value(optarg, 0, 1);
-                if ( tactic_cross == -1 ) {
+                if ( cross_ai == -1 ) {
                     fprintf(stderr, "Error: incorrect cross ai value\n");
                     exit (EXIT_FAILURE);
                 }
@@ -97,8 +95,8 @@ int main(int argc, char* argv[]) {
         case 'o':
             printf ("round ai\n");
             if ( optarg ) {
-                tactic_round = check_int_value(optarg, 0, 2);
+                round_ai = check_int_value(optarg, 0, 1);
-                if ( tactic_round == -1 ) {
+                if ( round_ai == -1 ) {
                     fprintf(stderr, "Error: incorrect round ai value\n");
                     exit (EXIT_FAILURE);
                 }
@@ -142,23 +140,15 @@ int main(int argc, char* argv[]) {
             exit (EXIT_FAILURE);
         }
     }
-    srand(time(NULL));
+    s_move *test_move = create_empty_move();
-    s_utictactoe *s = create_empty_utictactoe(inception_level);
+    free_move(test_move);
-    s_move *m = create_empty_move();
+    s_tictactoe *test_ttt = create_empty_tictactoe();
-    p_view v = create_view(s);
+    free_tictactoe(test_ttt);
-    while (s->outer_tictactoe->winner == NOBODY) {
+    s_utictactoe *test_uttt = create_empty_utictactoe(1);
-        m->player = get_next_player_to_play(s);
+    free_utictactoe(test_uttt);
-        m->outer_position = get_next_outer_position(s);
+    test_uttt = create_empty_utictactoe(2);
-        if (m->player == PLAYER_X) {
+    free_utictactoe(test_uttt);
-            set_next_player_move(m, v, tactic_cross);
+    test_uttt = create_empty_utictactoe(3);
-        } else {
+    free_utictactoe(test_uttt);
-            set_next_player_move(m, v, tactic_round);
+    return EXIT_SUCCESS;
-        }
-        play_move(s, m);
-    }
-    display_winner(v);
-    getchar();//just to pause before quitting the program
-    free_view(v);
-    free_move(m);
-    free_utictactoe(s);
 }

src/view.c

@@ -1,276 +0,0 @@
-#include "common.h"
-#include "model.h"
-#include "view.h"
-#include "ia.h"
-
-struct view{
-    s_utictactoe * p_uttt;
-    WINDOW* w_uttt;
-    WINDOW* w_ttt;
-}; 
-
-
-p_view create_view(s_utictactoe * u)
-{
-    p_view v = (p_view) malloc(sizeof(p_view));
-    v->p_uttt = u;
-
-    int p_left = 4;
-    int p_top = 2;
-    
-    initscr();
-    raw();
-    noecho();
-    start_color();
-    keypad(stdscr, TRUE);
-    init_pair(1, COLOR_BLACK,COLOR_WHITE);
-    init_pair(2, COLOR_BLACK,COLOR_RED);
-    curs_set( 0 );
-
-    mvwprintw(stdscr,0,0,"Inception level %d", u->inception_level);
-    // Create the outer win
-    WINDOW * w_outer = subwin(stdscr, 9, 11, p_top, p_left);
-    box(w_outer, ACS_VLINE, ACS_HLINE);
-    draw_ttt(w_outer, u->outer_tictactoe);
-    v->w_uttt = w_outer;
-
-    // If needed, create the inner ttt
-    if ( u->inception_level == 2 ){
-        int r,c;
-        getmaxyx(w_outer, r, c);
-        WINDOW * w_inner = subwin(stdscr, 9, 11, p_top, p_left + c);
-        box(w_inner, ACS_VLINE, ACS_HLINE);
-        //draw_ttt(w_innera);
-        //wrefresh(w_inner);
-        v->w_ttt = w_inner;
-    }
-    wrefresh(w_outer);
-    wrefresh(stdscr);
-    
-    return v;  
-}
-
-void draw_ttt(WINDOW * w, s_tictactoe * u){
-    int x,y;
-    int i = 0;
-    for( y = 2; y < 7; y++){
-        if ( y % 2 == 0){
-            for(x = 3; x < 8 ;x++){
-                if (x % 2 != 0) {
-                    mvwprintw(w,y,x,"%c", (u->content[i] == NOBODY)?'.':u->content[i]);
-                    i++;
-                }
-                else { mvwprintw(w,y,x,"|"); }
-            }
-        }
-        else { mvwprintw(w,y,3,"-----"); }
-    }
-}
-
-void set_next_player_move(s_move * m, p_view v, e_tactic tactic )
-{
-
-    // computer player
-    if(tactic != HUMAN) {
-        best_move(v->p_uttt, m, tactic);
-        return ;
-    }
-
-    char * s="Player to play:%c";
-    int in_x = 3, out_x = 3;
-    int out_y = 2, in_y = 2;
-    bool outer_selected, played = false;
-    int ch=-1;
-    int p_x, p_y, p_yx = 0;
-    if ( v->p_uttt->inception_level == 2 && m->outer_position != FREE ) {
-            p_yx = elocation_to_coord(m->outer_position);
-            p_y = p_yx/10;
-            p_x = p_yx - ( p_y * 10);
-    }
-    while(played == false){
-        // debug print
-        // mvwprintw(stdscr, 20,0, " position out: y:%d x:%d, in: y:%d x:%d\n", out_y, out_x, in_y, in_x);
-        
-        mvwprintw(stdscr,1,0,s, m->player); 
-        draw_ttt(v->w_uttt, v->p_uttt->outer_tictactoe);
-
-        // Need to draw the second tictac toe if we have an inecption level
-        if ( v->p_uttt->inception_level == 2 ) {
-            draw_ttt(v->w_ttt, v->p_uttt->inner_tictactoes[coord_to_elocation(out_y, out_x)]);
-
-            // and mark the current active inner ttt with red cursor
-            if ( m->outer_position != FREE && v->p_uttt->inception_level == 2) {
-                wattron(v->w_uttt, COLOR_PAIR(2)); 
-                mvwaddch(v->w_uttt ,p_y, p_x, 
-                    v->p_uttt->outer_tictactoe->content[m->outer_position]
-                    );
-                wattroff(v->w_uttt, COLOR_PAIR(2)); 
-            }
-        }
-
-        // inner_cursor cursor
-        if ( outer_selected == true ) {
-            wattron(v->w_ttt, COLOR_PAIR(1));
-                mvwaddch(v->w_ttt ,in_y, in_x, 
-                v->p_uttt->inner_tictactoes[coord_to_elocation(out_y, out_x)]->content[coord_to_elocation(in_y, in_x)]
-            );
-            wattroff(v->w_ttt, COLOR_PAIR(1)); 
-        }
-
-        // outer_cursor cursor
-        wattron(v->w_uttt, COLOR_PAIR(1));
-            mvwaddch(v->w_uttt ,out_y, out_x, 
-            v->p_uttt->outer_tictactoe->content[coord_to_elocation(out_y, out_x)]
-        );
-        wattroff(v->w_uttt, COLOR_PAIR(1)); 
-        
-        // refresh screen
-        wrefresh(v->w_uttt);
-        if (v->p_uttt->inception_level == 2) wrefresh(v->w_ttt);
-        wrefresh(stdscr); 
-        
-        ch = wgetch(stdscr);
-
-        switch(ch)
-	    {	
-            case KEY_BACKSPACE:
-            case 127:
-            case '\b':
-                // if we are in inner TTT window, go back to outer
-                if ( outer_selected == true && v->p_uttt->inception_level == 2 ) {
-                    outer_selected = false;
-                }
-                else {
-                    // If not Exit programm, but we need to do it properly.
-                    free_utictactoe(v->p_uttt);
-                    free_move(m);
-                    free_view(v);
-                    exit(1);
-                }
-                break;
-            case KEY_RIGHT:
-                if ( outer_selected ) {
-                    if(in_x < 7) { in_x+=2; }
-                }
-                else {
-                    if(out_x < 7) { out_x+=2; }
-                }
-                break;
-            case KEY_LEFT:
-                if ( outer_selected ) {
-                    if( in_x > 3 ) { in_x-=2; }
-                }
-                else {
-                    if ( out_x > 3 ) { out_x-=2; }
-                }
-                break;
-            case KEY_UP:
-                if ( outer_selected ) {
-                    if ( in_y > 2 ) { in_y-=2; }
-                }
-                else {
-                    if ( out_y > 2 ) { out_y-=2; }
-                }
-                break;
-            case KEY_DOWN: 
-                if ( outer_selected ) {
-                    if ( in_y < 6 ) { in_y+=2; }
-                }
-                else {
-                    if ( out_y < 6 ) { out_y+=2; }
-                }
-                break;
-            case '\n':
-                if ( v->p_uttt->inception_level == 1 ) {
-                    m->outer_position = coord_to_elocation( out_y, out_x);
-                    return;
-                }
-                else {
-                    if ( outer_selected == true ) {
-                        m->outer_position = coord_to_elocation( out_y, out_x);
-                        m->inner_position = coord_to_elocation( in_y, in_x);
-                        return;
-                    }
-                    else {
-                        if ( coord_to_elocation( out_y, out_x ) == m->outer_position || m->outer_position == FREE){
-                            outer_selected = true;
-                        }
-                    }
-                }
-                break;
-	    }
-    }
-
-}
-
-e_location coord_to_elocation( int y, int x) {
-    if ( y == 2 && x == 3 ){ return TOPLEFT; }
-    if ( y == 2 && x == 5 ){ return TOPCENTER; }
-    if ( y == 2 && x == 7 ){ return TOPRIGHT; }
-    if ( y == 4 && x == 3 ){ return MIDLEFT; }
-    if ( y == 4 && x == 5 ){ return MIDCENTER; }
-    if ( y == 4 && x == 7 ){ return MIDRIGHT; }
-    if ( y == 6 && x == 3 ){ return BOTTOMLEFT; }
-    if ( y == 6 && x == 5 ){ return BOTTOMCENTER; }
-    if ( y == 6 && x == 7 ){ return BOTTOMRIGHT; }
-    return NONE;
-}
-
-int elocation_to_coord(e_location l){
-    switch(l){
-        case TOPLEFT:
-            return 23;
-            break;
-        case TOPCENTER:
-            return 25;
-            break;
-        case TOPRIGHT:
-            return 27;
-            break;
-        case MIDLEFT:
-            return 43;
-            break;
-        case MIDCENTER:
-            return 45;
-            break;
-        case MIDRIGHT:
-            return 47;
-            break;
-        case BOTTOMLEFT:
-            return 63;
-            break;
-        case BOTTOMCENTER:
-            return 65;
-            break;
-        case BOTTOMRIGHT:
-            return 67;
-            break;
-        default:
-            return NONE;
-    }
-}
-
-void display_winner(p_view v){   
-    int ch = ' ';
-    draw_ttt(v->w_uttt, v->p_uttt->outer_tictactoe);
-    wrefresh(v->w_uttt);
-    if (v->p_uttt->inception_level == 2){
-        draw_ttt(v->w_ttt, v->p_uttt->inner_tictactoes[TOPLEFT]);
-    }
-    wrefresh(stdscr);
-    do {
-        mvwprintw(stdscr, 1, 0, "le gagnant est : %c, apputez sur 'entree' pour quitter", 
-            v->p_uttt->outer_tictactoe->winner);
-        ch = wgetch(stdscr);
-    } while (ch != '\n');
-
-} 
-void free_view(p_view v){
-    delwin(v->w_uttt);
-    v->w_uttt = NULL;
-    delwin(v->w_ttt);
-    v->w_ttt = NULL;
-    v->w_uttt = NULL;
-    endwin();
-}
-