Compare commits
No commits in common. "master" and "0e8fb2242477965d85a7adb32a799739334cf8cf" have entirely different histories.
master
...
0e8fb22424
10 changed files with 126 additions and 635 deletions
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -24,9 +24,4 @@ typedef enum {
|
|||
ALMOST,
|
||||
} e_status;
|
||||
|
||||
typedef enum {
|
||||
HUMAN,
|
||||
RANDOM,
|
||||
CLEVER,
|
||||
} e_tactic;
|
||||
#endif /*COMMON*/
|
||||
|
|
|
|||
17
include/ia.h
17
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
|
||||
|
|
@ -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 */
|
||||
#endif /* MODEL_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 */
|
||||
|
|
@ -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)
|
||||
|
|
|
|||
76
src/ia.c
76
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);
|
||||
}
|
||||
286
src/model.c
286
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
|
||||
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]) {
|
||||
p_ttt->winner = p_ttt->content[i];
|
||||
return;
|
||||
}
|
||||
}
|
||||
if ( p_ttt->winner == NOBODY ) {
|
||||
for(int i = 0; i < TICTACTOE_WIDTH; i++){
|
||||
|
||||
//lines
|
||||
for ( int i=0; i < TICTACTOE_SIZE; i=i+3 ) {
|
||||
if (p_ttt->content[i] != NOBODY
|
||||
&&p_ttt->content[i] == p_ttt->content[i+1]
|
||||
&& p_ttt->content[i] == p_ttt->content[i+2]) {
|
||||
p_ttt->winner = p_ttt->content[i];
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
//diagonale
|
||||
if ( p_ttt->content[0] != NOBODY
|
||||
&& p_ttt->content[0] == p_ttt->content[4]
|
||||
&& p_ttt->content[0] == p_ttt->content[8] ) {
|
||||
p_ttt->winner = p_ttt->content[0];
|
||||
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;
|
||||
}
|
||||
/*
|
||||
* 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;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// check if a move could be done, if not retuen BOTH (no winner)
|
||||
for (int i = 0; i < TICTACTOE_SIZE; i++){
|
||||
if ( p_ttt->content[i] == NOBODY ) {
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* column
|
||||
*/
|
||||
find = true;
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* line
|
||||
*/
|
||||
int line = i * TICTACTOE_WIDTH;
|
||||
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;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
p_ttt->winner = BOTH;
|
||||
|
||||
// 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 ) {
|
||||
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) {
|
||||
return NO;
|
||||
}
|
||||
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);
|
||||
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;
|
||||
if (is_move_valid(p_uttt, p_move) == YES) {
|
||||
// we can process things
|
||||
if ( p_uttt->inception_level == 1 ) {
|
||||
p_uttt->outer_tictactoe->content[p_move->outer_position] = p_move->player;
|
||||
}
|
||||
else {
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
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");
|
||||
return YES;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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 inception_level = 2;
|
||||
int cross_ai, round_ai = 0;
|
||||
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'},
|
||||
{"tactic_round", required_argument, 0, 'o'},
|
||||
{"cross-ai", required_argument, 0, 'x'},
|
||||
{"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);
|
||||
if ( tactic_cross == -1 ) {
|
||||
cross_ai = check_int_value(optarg, 0, 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);
|
||||
if ( tactic_round == -1 ) {
|
||||
round_ai = check_int_value(optarg, 0, 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_utictactoe *s = create_empty_utictactoe(inception_level);
|
||||
s_move *m = create_empty_move();
|
||||
p_view v = create_view(s);
|
||||
while (s->outer_tictactoe->winner == NOBODY) {
|
||||
m->player = get_next_player_to_play(s);
|
||||
m->outer_position = get_next_outer_position(s);
|
||||
if (m->player == PLAYER_X) {
|
||||
set_next_player_move(m, v, tactic_cross);
|
||||
} else {
|
||||
set_next_player_move(m, v, tactic_round);
|
||||
}
|
||||
play_move(s, m);
|
||||
}
|
||||
display_winner(v);
|
||||
getchar();//just to pause before quitting the program
|
||||
free_view(v);
|
||||
free_move(m);
|
||||
free_utictactoe(s);
|
||||
s_move *test_move = create_empty_move();
|
||||
free_move(test_move);
|
||||
s_tictactoe *test_ttt = create_empty_tictactoe();
|
||||
free_tictactoe(test_ttt);
|
||||
s_utictactoe *test_uttt = create_empty_utictactoe(1);
|
||||
free_utictactoe(test_uttt);
|
||||
test_uttt = create_empty_utictactoe(2);
|
||||
free_utictactoe(test_uttt);
|
||||
test_uttt = create_empty_utictactoe(3);
|
||||
free_utictactoe(test_uttt);
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
|
|
|||
276
src/view.c
276
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();
|
||||
}
|
||||
|
||||
Loading…
Add table
Add a link
Reference in a new issue