Protector Code

/*
    Protector -- a UCI chess engine

    Copyright (C) 2009-2010 Raimund Heid (Raimund_Heid@yahoo.com)

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

#ifndef _movegeneration_h_
#define _movegeneration_h_

#define CONTINUE 0
#define ABORT 1

#include "protector.h"
#include "position.h"
#include <stdlib.h>

extern const Move NO_MOVE;
extern const Move NULLMOVE;

typedef enum
{
   MGS_INITIALIZE,
   MGS_FINISHED,
   MGS_GOOD_CAPTURES_AND_PROMOTIONS,
   MGS_GOOD_CAPTURES_AND_PROMOTIONS_PURE,
   MGS_GOOD_CAPTURES,
   MGS_KILLER_MOVES,
   MGS_REST,
   MGS_BAD_CAPTURES,
   MGS_ESCAPES,
   MGS_CHECKS,
   MGS_SAFE_CHECKS,
   MGS_DANGEROUS_PAWN_ADVANCES
}
MovegenerationStage;

extern int MG_SCHEME_STANDARD, MG_SCHEME_ESCAPE, MG_SCHEME_CHECKS,
   MG_SCHEME_QUIESCENCE_WITH_CHECKS, MG_SCHEME_QUIESCENCE, MG_SCHEME_CAPTURES;

extern MovegenerationStage moveGenerationStage[100];

/**
 * Check if the specified move is pseudo-legal.
 */
bool moveIsPseudoLegal(const Position * position, const Move move);

/**
 * Check if the specified move is legal.
 */
bool moveIsLegal(const Position * position, const Move move);

/**
 * Get the number of the available pieces moves.
 */
int getNumberOfPieceMoves(const Position * position, const Color color,
                          const int sufficientNumberOfMoves);

/**
 * Get the static exchange eval of the specified move.
 */
int seeMoveRec(Position * position, const Move,
               Bitboard attackers[2], const int minValue);

/**
 * Check if the king can escape a check situation.
 */
bool kingCanEscape(Position * position);

/**
 * Generate moves leading out of check.
 */
void generateEscapes(Movelist * movelist);

/**
 * Generate only check moves.
 */
void generateChecks(Movelist * movelist, bool allChecks);

/**
 * Generate all moves except captures and promotions and the hashmove.
 */
void generateRestMoves(Movelist * movelist);

/**
 * Generate captures and promotions.
 */
void generateSpecialMoves(Movelist * movelist);

/**
 * Generate captures and promotions.
 */
void generateSpecialMovesPure(Movelist * movelist);

/**
 * Generate captures.
 */
void generateCaptures(Movelist * movelist);

/**
 * Generate pawn advances to the seventh rank.
 */
void generateDangerousPawnAdvances(Movelist * movelist);

/**
 * Initialize this module.
 *
 * @return 0 if no errors occurred.
 */
int initializeModuleMovegeneration(void);

/**
 * Test this module.
 *
 * @return 0 if all tests succeed.
 */
int testModuleMovegeneration(void);

/**
 * Get the legal moves of the specified variation.
 */
void getLegalMoves(Variation * variation, Movelist * movelist);

/**
 * Get the result of the current position.
 */
Gameresult getGameresult(Variation * variation);

/**
 * Preset the moves of the specified movelist in order to ensure a stable
 * sort process.
 */
void initializeMoveValues(Movelist * movelist);

/**
 * Check if a movelist contains a specific move.
 */
bool listContainsMove(const Movelist * movelist, const Move move);

/**
 * Check if a movelist contains a specific move.
 */
bool listContainsSimpleMove(Movelist * movelist, Square from, Square to);

/**
 * Add a move at the specified position.
 */
void addMoveAtPosition(Movelist * movelist, const Move move,
                       const int insertPosition);

/**
 * Delete the move at the specified position.
 */
void deleteMoveAtPosition(Movelist * movelist, const int position);

/**
 * Check if the given simple move (no capture, no promotion, no castling)
 * is a check.
 */
bool simpleMoveIsCheck(const Position * position, const Move move);

void registerKillerMove(PlyInfo * plyInfo, Move killerMove);
bool passiveKingIsSafe(Position * position);
bool activeKingIsSafe(Position * position);
int seeMove(Position * position, const Move move);
int compareMoves(const void *move1, const void *move2);
void sortMoves(Movelist * movelist);
void initQuiescenceMovelist(Movelist * movelist,
                            Position * position, PlyInfo * plyInfo,
                            UINT16 * historyValue, const Move hashMove,
                            const int restDepth, const bool check);
void initStandardMovelist(Movelist * movelist, Position * position,
                          PlyInfo * plyInfo, UINT16 * historyValue,
                          const Move hashMove, const bool check);
void initPreQuiescenceMovelist(Movelist * movelist,
                               Position * position,
                               PlyInfo * plyInfo,
                               UINT16 * historyValue,
                               const Move hashMove, const bool check);
void initCaptureMovelist(Movelist * movelist,
                         Position * position, PlyInfo * plyInfo,
                         UINT16 * historyValue, const Move hashMove,
                         const bool check);
void initCheckMovelist(Movelist * movelist, Position * position,
                       UINT16 * historyValue);
void initMovelist(Movelist * movelist, Position * position);
Move getNextMove(Movelist * movelist);
void deferMove(Movelist * movelist, Move move);

#endif