gyges 1.1.0

A library for the board game Gygès.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

//! Structures to represent moves, lists of moves, and move generation.
//! 
//! This module contains the move, rootmove structures.
//! 

pub mod move_list;

pub mod movegen;
pub mod movegen_consts;

use std::fmt::Display;

use crate::core::*;

/// Designates the type of move.
/// 
/// A move can either be a drop or a bounce.
/// A drop is a move that has three stages: the staring position, a piece that is replaced, and where that piece is dropped.
/// A bounce is a move that only has two stages: the starting position and the ending position.
#[derive(PartialEq, Debug, Clone, Copy)]
pub enum MoveType {
    Drop,
    Bounce,
    None

}

/// Structure that defines a move
/// 
/// A move has the data which represents how the move effects the board. 
/// The format of each of the tuples in the data array is a (Piece, Square) and it directly means put that piece at that square.
#[derive(PartialEq, Debug, Clone, Copy)]
pub struct Move {
    pub data: [(Piece, SQ); 3],
    pub flag: MoveType,

}

impl Move {
    /// Create a new move from its individual components.
    pub fn new(data: [(Piece, SQ); 3], flag: MoveType) -> Move {
        Move {
            data,
            flag,

        }

    }

    /// Creates a new null move.
    pub fn new_null() -> Move {
        Move {
            data: [(Piece::None, SQ::NONE); 3],
            flag: MoveType::None,

        }

    }

    /// Checks if a move is null.
    pub fn is_null(&self) -> bool {
        self.data == [(Piece::None, SQ::NONE); 3] && self.flag == MoveType::None

    }

    /// Checks if a move wins the game
    pub fn is_win(&self) -> bool {
        if self.flag == MoveType::Bounce {
            self.data[1].1 == SQ::P1_GOAL || self.data[1].1 == SQ::P2_GOAL

        } else {
             self.data[2].1 == SQ::P1_GOAL || self.data[2].1 == SQ::P2_GOAL

        }

    }

}

impl Display for Move {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        if self.flag == MoveType::Bounce {
            write!(f, "({}, {}) : ({}, {})", self.data[0].0, self.data[0].1, self.data[1].0, self.data[1].1)

        } else {
            write!(f, "({}, {}) : ({}, {}) : ({}, {})", self.data[0].0, self.data[0].1, self.data[1].0, self.data[1].1, self.data[2].0, self.data[2].1)

        }

    }

}

/// Structure that defines a rootmove.
/// 
/// A rootmove is a move that can store other data associated with the root of a search tree. This data includes the ply of the move and  
/// the score of the move.
#[derive(PartialEq, Debug, Clone, Copy)]
pub struct RootMove {
    pub mv: Move,
    pub score: f64,
    pub threats: usize,
    pub ply: i8

}

impl RootMove {
    /// Creates a rootmove from its indivudal components.
    pub fn new(mv: Move, score: f64, ply: i8, threats: usize) -> RootMove {
        RootMove {
            mv,
            score,
            ply,
            threats,

        }

    }

    /// Creates a null rootmove.
    pub fn new_null() -> RootMove {
        RootMove {
            mv: Move::new_null(),
            score: 0.0,
            ply: 0,
            threats: 0,

        }

    }

    /// Checks if a rootmove is null.
    pub fn is_null(&self) -> bool {
        self.mv.is_null() && self.score == 0.0 && self.ply == 0

    }

    /// Sets the score and the search ply of a rootmove.
    pub fn set_score_and_ply(&mut self, score: f64, ply: i8) {
        self.score = score;
        self.ply = ply;

    }

}

impl Display for RootMove {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        if self.mv.flag == MoveType::Bounce {
            write!(f, "{}|{}", self.mv.data[0].1, self.mv.data[1].1)

        } else {
            write!(f, "{}|{}|{}", self.mv.data[0].1, self.mv.data[1].1, self.mv.data[2].1)

        }

    }

}