Add simple debug hit rate counter
[stockfish] / src / position.h
1 /*
2   Glaurung, a UCI chess playing engine.
3   Copyright (C) 2004-2008 Tord Romstad
4
5   Glaurung is free software: you can redistribute it and/or modify
6   it under the terms of the GNU General Public License as published by
7   the Free Software Foundation, either version 3 of the License, or
8   (at your option) any later version.
9   
10   Glaurung is distributed in the hope that it will be useful,
11   but WITHOUT ANY WARRANTY; without even the implied warranty of
12   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13   GNU General Public License for more details.
14   
15   You should have received a copy of the GNU General Public License
16   along with this program.  If not, see <http://www.gnu.org/licenses/>.
17 */
18
19
20 #if !defined(POSITION_H_INCLUDED)
21 #define POSITION_H_INCLUDED
22
23 ////
24 //// Includes
25 ////
26
27 #include "bitboard.h"
28 #include "color.h"
29 #include "direction.h"
30 #include "move.h"
31 #include "piece.h"
32 #include "phase.h"
33 #include "square.h"
34 #include "value.h"
35
36
37 ////
38 //// Constants
39 ////
40
41 /// FEN string for the initial position:
42 const std::string StartPosition = 
43   "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
44
45 /// Maximum number of plies per game (220 should be enough, because the
46 /// maximum search depth is 100, and during position setup we reset the
47 /// move counter for every non-reversible move):
48 const int MaxGameLength = 220;
49
50
51 ////
52 //// Types
53 ////
54
55 /// Castle rights, encoded as bit fields:
56
57 enum CastleRights {
58   NO_CASTLES = 0, 
59   WHITE_OO = 1, BLACK_OO = 2, 
60   WHITE_OOO = 4, BLACK_OOO = 8,
61   ALL_CASTLES = 15
62 };
63
64
65 /// The UndoInfo struct stores information we need to restore a Position
66 /// object to its previous state when we retract a move.  Whenever a move
67 /// is made on the board (by calling Position::do_move), an UndoInfo object
68 /// must be passed as a parameter.  When the move is unmade (by calling
69 /// Position::undo_move), the same UndoInfo object must be passed again.
70
71 struct UndoInfo {
72   int castleRights;
73   Square epSquare;
74   Bitboard checkersBB;
75   Key key, pawnKey, materialKey;
76   int rule50;
77   Move lastMove;
78   PieceType capture;
79   Value mgValue, egValue;
80 };
81
82
83 /// The position data structure.  A position consists of the following data:
84 ///    
85 ///    * For each piece type, a bitboard representing the squares occupied
86 ///      by pieces of that type.
87 ///    * For each color, a bitboard representing the squares occupiecd by
88 ///      pieces of that color.
89 ///    * A bitboard of all occupied squares.
90 ///    * A bitboard of all checking pieces.
91 ///    * A 64-entry array of pieces, indexed by the squares of the board.
92 ///    * The current side to move.
93 ///    * Information about the castling rights for both sides.
94 ///    * The initial files of the kings and both pairs of rooks.  This is
95 ///      used to implement the Chess960 castling rules.
96 ///    * The en passant square (which is SQ_NONE if no en passant capture is
97 ///      possible).
98 ///    * The squares of the kings for both sides.
99 ///    * The last move played.
100 ///    * Hash keys for the position itself, the current pawn structure, and
101 ///      the current material situation.
102 ///    * Hash keys for all previous positions in the game (for detecting
103 ///      repetition draws.
104 ///    * A counter for detecting 50 move rule draws.
105
106 class Position {
107
108   friend class MaterialInfo;
109
110 public:
111   // Constructors
112   Position();
113   Position(const Position &pos);
114   Position(const std::string &fen);
115
116   // Text input/output
117   void from_fen(const std::string &fen);
118   const std::string to_fen() const;
119   void print() const;
120
121   // Copying
122   void copy(const Position &pos);
123   void flipped_copy(const Position &pos);
124
125   // The piece on a given square
126   Piece piece_on(Square s) const;
127   PieceType type_of_piece_on(Square s) const;
128   Color color_of_piece_on(Square s) const;
129   bool square_is_empty(Square s) const;
130   bool square_is_occupied(Square s) const;
131   Value midgame_value_of_piece_on(Square s) const;
132   Value endgame_value_of_piece_on(Square s) const;
133
134   // Side to move
135   Color side_to_move() const;
136
137   // Bitboard representation of the position
138   Bitboard empty_squares() const;
139   Bitboard occupied_squares() const;
140   Bitboard pieces_of_color(Color c) const;
141   Bitboard pieces_of_type(PieceType pt) const;
142   Bitboard pieces_of_color_and_type(Color c, PieceType pt) const;
143   Bitboard pawns() const;
144   Bitboard knights() const;
145   Bitboard bishops() const;
146   Bitboard rooks() const;
147   Bitboard queens() const;
148   Bitboard kings() const;
149   Bitboard rooks_and_queens() const;
150   Bitboard bishops_and_queens() const;
151   Bitboard sliders() const;
152   Bitboard pawns(Color c) const;
153   Bitboard knights(Color c) const;
154   Bitboard bishops(Color c) const;
155   Bitboard rooks(Color c) const;
156   Bitboard queens(Color c) const;
157   Bitboard kings(Color c) const;
158   Bitboard rooks_and_queens(Color c) const;
159   Bitboard bishops_and_queens(Color c) const;
160   Bitboard sliders_of_color(Color c) const;
161
162   // Number of pieces of each color and type
163   int piece_count(Color c, PieceType pt) const;
164   int pawn_count(Color c) const;
165   int knight_count(Color c) const;
166   int bishop_count(Color c) const;
167   int rook_count(Color c) const;
168   int queen_count(Color c) const;
169
170   // The en passant square:
171   Square ep_square() const;
172
173   // Current king position for each color
174   Square king_square(Color c) const;
175
176   // Castling rights.
177   bool can_castle_kingside(Color c) const;
178   bool can_castle_queenside(Color c) const;
179   bool can_castle(Color c) const;
180   Square initial_kr_square(Color c) const;
181   Square initial_qr_square(Color c) const;
182
183   // Attack bitboards
184   Bitboard sliding_attacks(Square s, Direction d) const;
185   Bitboard ray_attacks(Square s, SignedDirection d) const;
186   Bitboard pawn_attacks(Color c, Square s) const;
187   Bitboard white_pawn_attacks(Square s) const;
188   Bitboard black_pawn_attacks(Square s) const;
189   Bitboard knight_attacks(Square s) const;
190   Bitboard bishop_attacks(Square s) const;
191   Bitboard rook_attacks(Square s) const;
192   Bitboard queen_attacks(Square s) const;
193   Bitboard king_attacks(Square s) const;
194
195   // Bitboards for pinned pieces and discovered check candidates
196   Bitboard discovered_check_candidates(Color c) const;
197   Bitboard pinned_pieces(Color c) const;
198
199   // Checking pieces
200   Bitboard checkers() const;
201
202   // Piece lists:
203   Square piece_list(Color c, PieceType pt, int index) const;
204   Square pawn_list(Color c, int index) const;
205   Square knight_list(Color c, int index) const;
206   Square bishop_list(Color c, int index) const;
207   Square rook_list(Color c, int index) const;
208   Square queen_list(Color c, int index) const;
209
210   // Attack information for a given square
211   bool square_is_attacked(Square s, Color c) const;
212   Bitboard attacks_to(Square s) const;
213   Bitboard attacks_to(Square s, Color c) const;
214   bool is_check() const;
215   bool piece_attacks_square(Square f, Square t) const;
216   bool white_pawn_attacks_square(Square f, Square t) const;
217   bool black_pawn_attacks_square(Square f, Square t) const;
218   bool knight_attacks_square(Square f, Square t) const;
219   bool bishop_attacks_square(Square f, Square t) const;
220   bool rook_attacks_square(Square f, Square t) const;
221   bool queen_attacks_square(Square f, Square t) const;
222   bool king_attacks_square(Square f, Square t) const;
223
224   // Properties of moves
225   bool move_is_legal(Move m) const;
226   bool move_is_legal(Move m, Bitboard pinned) const;
227   bool move_is_check(Move m) const;
228   bool move_is_check(Move m, Bitboard dcCandidates) const;
229   bool move_is_capture(Move m) const;
230   bool move_is_pawn_push_to_7th(Move m) const;
231   bool move_is_passed_pawn_push(Move m) const;
232   bool move_was_passed_pawn_push(Move m) const;
233   bool move_attacks_square(Move m, Square s) const;
234
235   // Information about pawns
236   bool pawn_is_passed(Color c, Square s) const;
237   bool pawn_is_isolated(Color c, Square s) const;
238   bool pawn_is_doubled(Color c, Square s) const;
239
240   // Open and half-open files
241   bool file_is_open(File f) const;
242   bool file_is_half_open(Color c, File f) const;
243
244   // Weak squares
245   bool square_is_weak(Square s, Color c) const;
246
247   // Doing and undoing moves
248   void backup(UndoInfo &u) const;
249   void restore(const UndoInfo &u);
250   void do_move(Move m, UndoInfo &u);
251   void do_move(Move m, UndoInfo &u, Bitboard dcCandidates);
252   void undo_move(Move m, const UndoInfo &u);
253   void do_null_move(UndoInfo &u);
254   void undo_null_move(const UndoInfo &u);
255
256   // Static exchange evaluation
257   int see(Square from, Square to) const;
258   int see(Move m) const;
259
260   // Accessing hash keys
261   Key get_key() const;
262   Key get_pawn_key() const;
263   Key get_material_key() const;
264
265   // Incremental evaluation
266   Value mg_value() const;
267   Value eg_value() const;
268   Value non_pawn_material(Color c) const;
269   Phase game_phase() const;
270
271   // Game termination checks
272   bool is_mate();
273   bool is_draw() const;
274
275   // Check if one side threatens a mate in one
276   bool has_mate_threat(Color c);
277
278   // Number of plies since the last non-reversible move
279   int rule_50_counter() const;
280
281   // Other properties of the position
282   bool opposite_colored_bishops() const;
283   bool has_pawn_on_7th(Color c) const;
284
285   // Reset the gamePly variable to 0
286   void reset_game_ply();
287   
288   // Position consistency check, for debugging
289   bool is_ok() const;
290
291   // Static member functions:
292   static void init_zobrist();
293   static void init_piece_square_tables();
294
295 private:
296   // Initialization helper functions (used while setting up a position)
297   void clear();
298   void put_piece(Piece p, Square s);
299   void allow_oo(Color c);
300   void allow_ooo(Color c);
301
302   // Helper functions for doing and undoing moves
303   void do_castle_move(Move m);
304   void do_promotion_move(Move m, UndoInfo &u);
305   void do_ep_move(Move m);
306   void undo_castle_move(Move m);
307   void undo_promotion_move(Move m, const UndoInfo &u);
308   void undo_ep_move(Move m);
309   void find_checkers();
310
311   // Computing hash keys from scratch (for initialization and debugging)
312   Key compute_key() const;
313   Key compute_pawn_key() const;
314   Key compute_material_key() const;
315
316   // Computing incremental evaluation scores and material counts
317   Value mg_pst(Color c, PieceType pt, Square s) const;
318   Value eg_pst(Color c, PieceType pt, Square s) const;
319   Value compute_mg_value() const;
320   Value compute_eg_value() const;
321   Value compute_non_pawn_material(Color c) const;
322
323   // Bitboards
324   Bitboard byColorBB[2], byTypeBB[8];
325   Bitboard checkersBB;
326
327   // Board
328   Piece board[64];
329
330   // Piece counts
331   int pieceCount[2][8]; // [color][pieceType]
332   
333   // Piece lists
334   Square pieceList[2][8][16]; // [color][pieceType][index]
335   int index[64];
336
337   // Other info
338   Color sideToMove;
339   int castleRights;
340   File initialKFile, initialKRFile, initialQRFile;
341   Square epSquare;
342   Square kingSquare[2];
343   Move lastMove;
344   Key key, pawnKey, materialKey, history[MaxGameLength];
345   int rule50, gamePly;
346   Value mgValue, egValue;
347   Value npMaterial[2];
348
349   // Static variables
350   static int castleRightsMask[64];
351   static Key zobrist[2][8][64];
352   static Key zobEp[64];
353   static Key zobCastle[16];
354   static Key zobMaterial[2][8][16];
355   static Key zobSideToMove;
356   static Value MgPieceSquareTable[16][64];
357   static Value EgPieceSquareTable[16][64];
358 };
359
360
361 ////
362 //// Inline functions
363 ////
364
365 inline Piece Position::piece_on(Square s) const {
366   return board[s];
367 }
368
369 inline Color Position::color_of_piece_on(Square s) const {
370   return color_of_piece(this->piece_on(s));
371 }
372
373 inline PieceType Position::type_of_piece_on(Square s) const {
374   return type_of_piece(this->piece_on(s));
375 }
376
377 inline bool Position::square_is_empty(Square s) const {
378   return this->piece_on(s) == EMPTY;
379 }
380
381 inline bool Position::square_is_occupied(Square s) const {
382   return !this->square_is_empty(s);
383 }
384
385 inline Value Position::midgame_value_of_piece_on(Square s) const {
386   return piece_value_midgame(this->piece_on(s));
387 }
388
389 inline Value Position::endgame_value_of_piece_on(Square s) const {
390   return piece_value_endgame(this->piece_on(s));
391 }
392
393 inline Color Position::side_to_move() const {
394   return sideToMove;
395 }
396
397 inline Bitboard Position::occupied_squares() const {
398   return byTypeBB[0];
399 }
400
401 inline Bitboard Position::empty_squares() const {
402   return ~(this->occupied_squares());
403 }
404
405 inline Bitboard Position::pieces_of_color(Color c) const {
406   return byColorBB[c];
407 }
408
409 inline Bitboard Position::pieces_of_type(PieceType pt) const {
410   return byTypeBB[pt];
411 }
412
413 inline Bitboard Position::pieces_of_color_and_type(Color c, PieceType pt)
414   const {
415   return this->pieces_of_color(c) & this->pieces_of_type(pt);
416 }
417
418 inline Bitboard Position::pawns() const {
419   return this->pieces_of_type(PAWN);
420 }
421
422 inline Bitboard Position::knights() const {
423   return this->pieces_of_type(KNIGHT);
424 }
425
426 inline Bitboard Position::bishops() const {
427   return this->pieces_of_type(BISHOP);
428 }
429
430 inline Bitboard Position::rooks() const {
431   return this->pieces_of_type(ROOK);
432 }
433
434 inline Bitboard Position::queens() const {
435   return this->pieces_of_type(QUEEN);
436 }
437
438 inline Bitboard Position::kings() const {
439   return this->pieces_of_type(KING);
440 }
441
442 inline Bitboard Position::rooks_and_queens() const {
443   return this->rooks() | this->queens();
444 }
445
446 inline Bitboard Position::bishops_and_queens() const {
447   return this->bishops() | this->queens();
448 }
449
450 inline Bitboard Position::sliders() const {
451   return this->bishops() | this->queens() | this->rooks();
452 }
453
454 inline Bitboard Position::pawns(Color c) const {
455   return this->pieces_of_color_and_type(c, PAWN);
456 }
457
458 inline Bitboard Position::knights(Color c) const {
459   return this->pieces_of_color_and_type(c, KNIGHT);
460 }
461
462 inline Bitboard Position::bishops(Color c) const {
463   return this->pieces_of_color_and_type(c, BISHOP);
464 }
465
466 inline Bitboard Position::rooks(Color c) const {
467   return this->pieces_of_color_and_type(c, ROOK);
468 }
469
470 inline Bitboard Position::queens(Color c) const {
471   return this->pieces_of_color_and_type(c, QUEEN);
472 }
473
474 inline Bitboard Position::kings(Color c) const {
475   return this->pieces_of_color_and_type(c, KING);
476 }
477
478 inline Bitboard Position::rooks_and_queens(Color c) const {
479   return this->rooks_and_queens() & this->pieces_of_color(c);
480 }
481
482 inline Bitboard Position::bishops_and_queens(Color c) const {
483   return this->bishops_and_queens() & this->pieces_of_color(c);
484 }
485
486 inline Bitboard Position::sliders_of_color(Color c) const {
487   return this->sliders() & this->pieces_of_color(c);
488 }
489
490 inline int Position::piece_count(Color c, PieceType pt) const {
491   return pieceCount[c][pt];
492 }
493
494 inline int Position::pawn_count(Color c) const {
495   return this->piece_count(c, PAWN);
496 }
497
498 inline int Position::knight_count(Color c) const {
499   return this->piece_count(c, KNIGHT);
500 }
501
502 inline int Position::bishop_count(Color c) const {
503   return this->piece_count(c, BISHOP);
504 }
505
506 inline int Position::rook_count(Color c) const {
507   return this->piece_count(c, ROOK);
508 }
509
510 inline int Position::queen_count(Color c) const {
511   return this->piece_count(c, QUEEN);
512 }
513
514 inline Square Position::piece_list(Color c, PieceType pt, int index) const {
515   return pieceList[c][pt][index];
516 }
517
518 inline Square Position::pawn_list(Color c, int index) const {
519   return this->piece_list(c, PAWN, index);
520 }
521
522 inline Square Position::knight_list(Color c, int index) const {
523   return this->piece_list(c, KNIGHT, index);
524 }
525
526 inline Square Position::bishop_list(Color c, int index) const {
527   return this->piece_list(c, BISHOP, index);
528 }
529
530 inline Square Position::rook_list(Color c, int index) const {
531   return this->piece_list(c, ROOK, index);
532 }
533
534 inline Square Position::queen_list(Color c, int index) const {
535   return this->piece_list(c, QUEEN, index);
536 }
537
538 inline Square Position::ep_square() const {
539   return epSquare;
540 }
541
542 inline Square Position::king_square(Color c) const {
543   return kingSquare[c];
544 }
545
546 inline bool Position::can_castle_kingside(Color side) const {
547   return castleRights & (1+int(side));
548 }
549
550 inline bool Position::can_castle_queenside(Color side) const {
551   return castleRights & (4+4*int(side));
552 }
553
554 inline bool Position::can_castle(Color side) const {
555   return can_castle_kingside(side) || can_castle_queenside(side);
556 }
557
558 inline Square Position::initial_kr_square(Color c) const {
559   return relative_square(c, make_square(initialKRFile, RANK_1));
560 }
561
562 inline Square Position::initial_qr_square(Color c) const {
563   return relative_square(c, make_square(initialQRFile, RANK_1));
564 }
565
566 inline Bitboard Position::pawn_attacks(Color c, Square s) const {
567   return StepAttackBB[pawn_of_color(c)][s];
568 }
569
570 inline Bitboard Position::white_pawn_attacks(Square s) const {
571   return this->pawn_attacks(WHITE, s);
572 }
573
574 inline Bitboard Position::black_pawn_attacks(Square s) const {
575   return this->pawn_attacks(BLACK, s);
576 }
577
578 inline Bitboard Position::knight_attacks(Square s) const {
579   return StepAttackBB[KNIGHT][s];
580 }
581
582 inline Bitboard Position::rook_attacks(Square s) const {
583   return rook_attacks_bb(s, this->occupied_squares());
584 }
585
586 inline Bitboard Position::bishop_attacks(Square s) const {
587   return bishop_attacks_bb(s, this->occupied_squares());
588 }
589
590 inline Bitboard Position::queen_attacks(Square s) const {
591   return this->rook_attacks(s) | this->bishop_attacks(s);
592 }
593
594 inline Bitboard Position::king_attacks(Square s) const {
595   return StepAttackBB[KING][s];
596 }
597
598 inline Bitboard Position::checkers() const {
599   return checkersBB;
600 }
601
602 inline bool Position::is_check() const {
603   return this->checkers() != EmptyBoardBB;
604 }
605
606 inline bool Position::white_pawn_attacks_square(Square f, Square t) const {
607   return bit_is_set(this->white_pawn_attacks(f), t);
608 }
609
610 inline bool Position::black_pawn_attacks_square(Square f, Square t) const {
611   return bit_is_set(this->black_pawn_attacks(f), t);
612 }
613
614 inline bool Position::knight_attacks_square(Square f, Square t) const {
615   return bit_is_set(this->knight_attacks(f), t);
616 }
617
618 inline bool Position::bishop_attacks_square(Square f, Square t) const {
619   return bit_is_set(this->bishop_attacks(f), t);
620 }
621
622 inline bool Position::rook_attacks_square(Square f, Square t) const {
623   return bit_is_set(this->rook_attacks(f), t);
624 }
625
626 inline bool Position::queen_attacks_square(Square f, Square t) const {
627   return bit_is_set(this->queen_attacks(f), t);
628 }
629
630 inline bool Position::king_attacks_square(Square f, Square t) const {
631   return bit_is_set(this->king_attacks(f), t);
632 }
633
634 inline bool Position::pawn_is_passed(Color c, Square s) const {
635   return !(this->pawns(opposite_color(c)) & passed_pawn_mask(c, s));
636 }
637
638 inline bool Position::pawn_is_isolated(Color c, Square s) const {
639   return !(this->pawns(c) & neighboring_files_bb(s));
640 }
641
642 inline bool Position::pawn_is_doubled(Color c, Square s) const {
643   return this->pawns(c) & squares_behind(c, s);
644 }
645
646 inline bool Position::file_is_open(File f) const {
647   return !(this->pawns() & file_bb(f));
648 }
649
650 inline bool Position::file_is_half_open(Color c, File f) const {
651   return !(this->pawns(c) & file_bb(f));
652 }
653
654 inline bool Position::square_is_weak(Square s, Color c) const {
655   return !(this->pawns(c) & outpost_mask(opposite_color(c), s));
656 }
657                                 
658 inline Key Position::get_key() const {
659   return key;
660 }
661
662 inline Key Position::get_pawn_key() const {
663   return pawnKey;
664 }
665
666 inline Key Position::get_material_key() const {
667   return materialKey;
668 }
669
670 inline Value Position::mg_pst(Color c, PieceType pt, Square s) const {
671   return MgPieceSquareTable[piece_of_color_and_type(c, pt)][s];
672 }
673
674 inline Value Position::eg_pst(Color c, PieceType pt, Square s) const {
675   return EgPieceSquareTable[piece_of_color_and_type(c, pt)][s];
676 }
677
678 inline Value Position::mg_value() const {
679   return mgValue;
680 }
681
682 inline Value Position::eg_value() const {
683   return egValue;
684 }
685
686 inline Value Position::non_pawn_material(Color c) const {
687   return npMaterial[c];
688 }
689
690 inline Phase Position::game_phase() const {
691
692   // The purpose of the Value(325) terms below is to make sure the difference
693   // between MidgameLimit and EndgameLimit is a power of 2, which should make
694   // the division at the end of the function a bit faster.
695
696   static const Value MidgameLimit =
697     2*QueenValueMidgame+2*RookValueMidgame+6*BishopValueMidgame+Value(325);
698   static const Value EndgameLimit = 4*RookValueMidgame-Value(325);
699   Value npm = this->non_pawn_material(WHITE) + this->non_pawn_material(BLACK);
700   
701   if(npm >= MidgameLimit)
702     return PHASE_MIDGAME;
703   else if(npm <= EndgameLimit)
704     return PHASE_ENDGAME;
705   else
706     return Phase(((npm - EndgameLimit) * 128) / (MidgameLimit - EndgameLimit));
707 }
708
709 inline bool Position::move_is_pawn_push_to_7th(Move m) const {
710   Color c = this->side_to_move();
711   return 
712     this->piece_on(move_from(m)) == pawn_of_color(c) &&
713     pawn_rank(c, move_to(m)) == RANK_7;
714 }
715
716 inline bool Position::move_is_passed_pawn_push(Move m) const {
717   Color c = this->side_to_move();
718   return 
719     this->piece_on(move_from(m)) == pawn_of_color(c) &&
720     this->pawn_is_passed(c, move_to(m));
721 }
722  
723 inline bool Position::move_was_passed_pawn_push(Move m) const {
724   Color c = opposite_color(this->side_to_move());
725   return 
726     this->piece_on(move_to(m)) == pawn_of_color(c) &&
727     this->pawn_is_passed(c, move_to(m));
728 }
729
730 inline int Position::rule_50_counter() const {
731   return rule50;
732 }
733
734 inline bool Position::opposite_colored_bishops() const {
735   return
736     this->bishop_count(WHITE) == 1 && this->bishop_count(BLACK) == 1 &&
737     square_color(this->bishop_list(WHITE, 0)) !=
738     square_color(this->bishop_list(BLACK, 0));
739 }
740
741 inline bool Position::has_pawn_on_7th(Color c) const {
742   return this->pawns(c) & relative_rank_bb(c, RANK_7);
743 }
744                         
745
746 #endif // !defined(POSITION_H_INCLUDED)