/** @ingroup test
* @brief Teste les positions
*
*/
void test_position(void)
{
assert(position_est_valide(position(0, 0, 19)));
assert(! position_est_valide(POSITION_INVALIDE));
int taille = 19;
int max = taille - 1;
(void) max;
#define TEST(dir, x, y) position_est_valide(position_##dir( position(x, y, taille)))
assert(!TEST(gauche, 0, 0));
assert(TEST(droite, 0, 0));
assert(!TEST(haut, 0, 0));
assert(TEST(bas, 0, 0));
assert(TEST(gauche, max, 0));
assert(!TEST(droite, max, 0));
assert(!TEST(haut, max, 0));
assert(TEST(bas, max, 0));
assert(TEST(gauche, max, max));
assert(!TEST(droite, max, max));
assert(TEST(haut, max, max));
assert(!TEST(bas, max, max));
assert(!TEST(gauche, 0, max));
assert(TEST(droite, 0, max));
assert(TEST(haut, 0, max));
assert(!TEST(bas, 0, max));
#undef TEST
}
s_Coup cli_convertir_coup(const Partie partie, const char* str, bool* valide)
{
(void) partie;
int taille = plateau_get_taille(partie->plateau);
s_Coup coup = str2coup(str, taille, valide);
if (*valide) {
if (! position_est_valide(coup.position)) {
*valide = false;
}
}
return coup;
}
static void event_jouer(struct state* state, SDL_Event event)
{
struct jouerdata* jouer = state->data;
utiliser_event_textinput(jouer->nom_partie, event);
if (jouer->nom_partie->active) {
afficher_sauvegarder(jouer);
return; // ne pas interférer entre la saisie et les raccourcis claviers
}
if (event.type == SDL_MOUSEMOTION) {
jouer->hovered = get_position_depuis_ecran(jouer, event.motion.x, event.motion.y);
} else if (event.type == SDL_MOUSEBUTTONUP) {
int b = event.button.button;
if (b == 1) {
Position pos = get_position_depuis_ecran(jouer, event.motion.x, event.motion.y);
if (position_est_valide(pos)) {
s_Coup coup = {pos};
partie_jouer_coup(jouer->partie, coup);
afficher_sauvegarder(jouer);
}
} else if (b == 2) {
s_Coup coup;
coup.position = POSITION_INVALIDE;
partie_jouer_coup(jouer->partie, coup);
afficher_sauvegarder(jouer);
} else if (b == 4) {
partie_annuler_coup(jouer->partie);
afficher_sauvegarder(jouer);
} else if (b == 5) {
partie_rejouer_coup(jouer->partie);
afficher_sauvegarder(jouer);
}
} else if (event.type == SDL_KEYDOWN) {
if (event.key.keysym.sym == SDLK_p) {
s_Coup coup = {POSITION_INVALIDE};
partie_jouer_coup(jouer->partie, coup);
afficher_sauvegarder(jouer);
} else if (event.key.keysym.sym == SDLK_a) {
partie_annuler_coup(jouer->partie);
afficher_sauvegarder(jouer);
} else if (event.key.keysym.sym == SDLK_r) {
partie_rejouer_coup(jouer->partie);
afficher_sauvegarder(jouer);
}
}
utiliser_event_bouton(jouer->passer_son_tour, event);
utiliser_event_bouton(jouer->sauvegarder, event);
utiliser_event_bouton(jouer->retour_menu, event);
}
Territoire determiner_territoire(Plateau plateau, Position position)
{
Territoire territoire = creer_ensemble_colore(VIDE);
EnsemblePosition territoire_positions = ensemble_colore_positions(territoire);
EnsemblePosition possibles = creer_ensemble_position();
Couleur couleur = VIDE;
bool couleur_connue = false;
ensemble_position_ajouter(possibles, position);
/// @todo remplacer par une pile.
while (!ensemble_position_vide(possibles)) {
Position courante = ensemble_position_supprimer_tete(possibles);
Couleur c = plateau_get_at(plateau, courante);
if (c == VIDE) {
if (!territoire_appartient(territoire, courante)) {
ensemble_position_ajouter(territoire_positions, courante);
const Position a_tester[] = {
position_gauche(courante),
position_droite(courante),
position_haut(courante),
position_bas(courante),
};
for (int p = 0; p < 4; p++) {
if (position_est_valide(a_tester[p]))
ensemble_position_ajouter(possibles, a_tester[p]);
}
}
} else {
// si la case n'est pas vide, elle est à coté du territoire
// on regarde sa couleur
if (!couleur_connue) { // le territoire n'a pas encore de couleur défini
couleur = c;
couleur_connue = true;
} else if (couleur != c) // le territoire est entouré par deux couleurs différentes
couleur = VIDE;
}
}
ensemble_colore_set_couleur(territoire, couleur);
detruire_ensemble_position(possibles);
return territoire;
}
static void afficher_jouer(struct state* state, SDL_Surface* surface)
{
struct jouerdata* jouer = state->data;
Partie partie = jouer->partie;
int taille = jouer->taille;
int x1 = W * .2;
int y1 = H * .2;
int w = MAX(W * .8 - x1, H * .8 - y1);
w -= w % (taille);
int pixel_par_case = w / (taille);
int interbordure = 2;
int bordure = (w - pixel_par_case * (taille - 1)) / 2;
// bois
set_color(240, 174, 95);
draw_rect(surface, x1, y1, w, w);
// dessin des interbordures
set_color(30, 30, 30);
for (int x = 0; x < taille; x++) {
draw_rect(surface,
x1 + bordure + x * pixel_par_case - interbordure / 2,
y1 + bordure,
interbordure, pixel_par_case * (taille - 1));
}
for (int y = 0; y < taille; y++) {
draw_rect(surface,
x1 + bordure,
y1 + bordure + y * pixel_par_case - interbordure / 2,
pixel_par_case * (taille - 1), interbordure);
}
int taille_stone = taille == 9 ? 30 : taille == 13 ? 24 : 16;
int taille_stone2 = taille_stone / 4;
Position hov = jouer->hovered;
Chaine chaine = position_est_valide(hov) ?
plateau_determiner_chaine(partie->plateau, hov) : NULL;
Libertes libertes = chaine ? determiner_libertes(partie->plateau, chaine) : NULL;
EnsemblePosition yeux = chaine ? lesYeuxDeLaChaine(chaine, partie->plateau) : NULL;
for (int x = 0; x < taille; x++) {
for (int y = 0; y < taille; y++) {
Position pos = position(x, y, taille);
Couleur c = plateau_get(partie->plateau, x, y);
bool draw = false;
if (c != VIDE) {
if (c == BLANC) {
set_color(210, 210, 210);
} else {
set_color(40, 40, 40);
}
draw = true;
} else if (position_est_valide(hov) && hov.x == x && hov.y == y) {
if (partie->joueur_courant == JOUEUR_BLANC) {
set_color(240, 240, 240);
} else {
set_color(20, 20, 20);
}
draw = true;
}
int marge = (taille == 9 ? 2 : 3);
if (draw) {
// affichage de la pierre
int sx, sy;
get_position_vers_ecran(jouer, x, y, &sx, &sy);
sx -= taille_stone / 2;
sy -= taille_stone / 2;
draw_rect(surface, sx, sy, taille_stone, taille_stone);
} else if ((get_marge(x, taille) == marge || x == taille / 2)
&& (get_marge(y, taille) == marge || y == taille / 2)) {
// affichage du hoshi
int sx, sy;
get_position_vers_ecran(jouer, x, y, &sx, &sy);
set_color(0, 0, 0);
draw_rect(surface, sx - 3, sy - 3, 6, 6);
}
// affichage d'indicateurs d'aide
draw = false;
if (chaine && gosh_appartient(chaine, pos)) {
set_color(120, 120, 120);
draw = true;
} else if (yeux && gosh_appartient(yeux, pos)) {
set_color(255, 130, 130);
draw = true;
} else if (libertes && gosh_appartient(libertes, pos)) {
set_color(200, 40, 40);
draw = true;
}
if (draw) {
int sx, sy;
get_position_vers_ecran(jouer, x, y, &sx, &sy);
sx -= taille_stone2 / 2;
sy -= taille_stone2 / 2;
draw_rect(surface, sx, sy, taille_stone2, taille_stone2);
}
}
}
if (chaine)
detruire_chaine(chaine);
if (libertes)
detruire_libertes(libertes);
if (yeux)
detruire_ensemble_position(yeux);
if (!partie->finie) {
if (partie_en_cours_de_handicap(partie)) {
afficher_label(surface, jouer->handicap);
} else {
afficher_label(surface, jouer->au_tour_de[partie->joueur_courant]);
}
} else {
afficher_label(surface, jouer->partie_finie);
afficher_label(surface, jouer->score);
}
afficher_bouton(surface, jouer->retour_menu);
afficher_bouton(surface, jouer->passer_son_tour);
afficher_textinput(surface, jouer->nom_partie);
afficher_bouton(surface, jouer->sauvegarder);
}
