minorPiece.h
Go to the documentation of this file.
/* testEval.h
*/
#ifndef EVAL_ML_MINORPIECE_H
#define EVAL_ML_MINORPIECE_H
#include "osl/eval/midgame.h"
#include "osl/eval/weights.h"
#include "osl/eval/evalStagePair.h"
#include "osl/numEffectState.h"
#include <cstdlib>
namespace osl
{
namespace eval
{
namespace ml
{
class PawnDrop
{
public:
enum { ONE_DIM = 9, DIM = ONE_DIM * 2};
static void setUp(const Weights &weights,int stage);
};
class PawnDropY
{
public:
enum { ONE_DIM = 81, DIM = ONE_DIM * 2};
static void setUp(const Weights &weights,int stage);
};
class PawnDropBoth
{
friend class PawnDrop;
friend class PawnDropY;
friend class PawnDropX;
friend class PawnDropPawnStand;
friend class PawnDropPawnStandX;
friend class PawnDropPawnStandY;
friend class PawnDropNonDrop;
friend class PawnStateKingRelative;
private:
enum { BOTH_ON_BOARD, SELF_ON_BOARD, OPP_ON_BOARD, BOTH_ON_STAND };
static CArray<MultiInt, 9> attack_table, defense_table;
static CArray<MultiInt, 81> attack_y_table, defense_y_table;
static CArray<MultiInt, 90> x_table;
static CArray<MultiInt, 18> stand_table;
static CArray<MultiInt, 90> x_stand_table;
static CArray<MultiInt, 162> y_stand_table;
static CArray<MultiInt, 10> drop_non_drop_table;
static CArray<MultiInt, 36> state_king_relative_table;
template <Player Owner>
static int indexY(const Piece king, int x)
{
assert(Owner == king.owner());
const int king_y = (Owner == BLACK ?
king.square().y() : 10 - king.square().y());
return std::abs(x - king.square().x()) * 9 + king_y - 1;
}
static int index(const Square king, int x)
{
return std::abs(x - king.x());
}
template <bool Attack>
static int indexX(const Piece king, int x)
{
const int king_x = king.square().x();
const int target_x = (king_x > 5 ? 10 - king_x : king_x);
if (king_x >= 6 || (king.owner() == WHITE && king_x == 5))
x = 10 - x;
return (x - 1) * 5 + target_x - 1 + (Attack ? 0 : 45);
}
public:
static MultiInt value(
int attack_index, int defense_index,
int attack_index_y, int defense_index_y,
int attack_index_x, int defense_index_x)
{
return (attack_table[attack_index] +
defense_table[defense_index] +
attack_y_table[attack_index_y] +
defense_y_table[defense_index_y] +
x_table[attack_index_x] +
x_table[defense_index_x]);
}
static MultiInt standValue(
int attack_index, int defense_index,
int attack_index_y, int defense_index_y,
int attack_index_x, int defense_index_x)
{
return (stand_table[attack_index] +
stand_table[defense_index + 9] +
y_stand_table[attack_index_y] +
y_stand_table[defense_index_y + 81] +
x_stand_table[attack_index_x] +
x_stand_table[defense_index_x]);
}
static MultiInt eval(const NumEffectState &state);
template<Player P>
static MultiInt evalWithUpdate(const NumEffectState &state,
Move moved,
MultiInt &last_value)
{
const Player altP=alt(P);
Ptype captured = moved.capturePtype();
if (moved.ptype() == KING ||
(moved.isDrop() && moved.ptype() == PAWN &&
!state.hasPieceOnStand<PAWN>(P)) ||
(captured != PTYPE_EMPTY &&
unpromote(captured) == PAWN &&
state.countPiecesOnStand<PAWN>(P) == 1))
{
return eval(state);
}
MultiInt result(last_value);
const CArray<Square, 2> king_bw = {{ state.kingSquare<BLACK>(), state.kingSquare<WHITE>() }};
const CArray<Square, 2> kings = {{ king_bw[playerToIndex(P)], king_bw[playerToIndex(alt(P))] }};
const CArray<Piece, 2> king_piece = {{ state.kingPiece(P),
state.kingPiece(alt(P)) }};
if (moved.oldPtype() == PAWN)
{
if (moved.isDrop())
{
const int attack_index = index(kings[1], moved.to().x());
const int defense_index = index(kings[0], moved.to().x());
const int attack_index_x =
indexX<true>(king_piece[1], moved.to().x());
const int defense_index_x =
indexX<false>(king_piece[0], moved.to().x());
const int attack_index_y = indexY<altP>(king_piece[1], moved.to().x());
const int defense_index_y = indexY<P>(king_piece[0], moved.to().x());
const int index_x = (moved.to().x() > 5 ? 10 -
moved.to().x() : moved.to().x());
if (state.isPawnMaskSet<altP>(moved.to().x()))
{
if (P == BLACK)
{
result -= drop_non_drop_table[index_x - 1 + 5];
result += drop_non_drop_table[index_x - 1];
result -=
state_king_relative_table[std::abs(king_bw[BLACK].x() - moved.to().x()) +
OPP_ON_BOARD * 9];
result +=
state_king_relative_table[std::abs(king_bw[WHITE].x() - moved.to().x()) +
SELF_ON_BOARD * 9];
}
else
{
result -= drop_non_drop_table[index_x - 1];
result += drop_non_drop_table[index_x - 1 + 5];
result -=
state_king_relative_table[std::abs(king_bw[BLACK].x() - moved.to().x()) +
SELF_ON_BOARD * 9];
result +=
state_king_relative_table[std::abs(king_bw[WHITE].x() - moved.to().x()) +
OPP_ON_BOARD * 9];
}
result +=
state_king_relative_table[std::abs(king_bw[BLACK].x() -
moved.to().x()) +
BOTH_ON_BOARD * 9];
result -=
state_king_relative_table[std::abs(king_bw[WHITE].x() -
moved.to().x()) +
BOTH_ON_BOARD * 9];
}
else
{
result -=
state_king_relative_table[std::abs(king_bw[BLACK].x() -
moved.to().x()) +
BOTH_ON_STAND * 9];
result +=
state_king_relative_table[std::abs(king_bw[WHITE].x() -
moved.to().x()) +
BOTH_ON_STAND * 9];
if (P == BLACK)
{
result += drop_non_drop_table[index_x - 1];
result -= drop_non_drop_table[index_x - 1 + 5];
result +=
state_king_relative_table[std::abs(king_bw[BLACK].x() - moved.to().x()) +
SELF_ON_BOARD * 9];
result -=
state_king_relative_table[std::abs(king_bw[WHITE].x() - moved.to().x()) +
OPP_ON_BOARD * 9];
}
else
{
result += drop_non_drop_table[index_x - 1 + 5];
result -= drop_non_drop_table[index_x - 1];
result +=
state_king_relative_table[std::abs(king_bw[BLACK].x() - moved.to().x()) +
OPP_ON_BOARD * 9];
result -=
state_king_relative_table[std::abs(king_bw[WHITE].x() - moved.to().x()) +
SELF_ON_BOARD * 9];
}
}
if (P == BLACK)
{
result -= value(attack_index, defense_index, attack_index_y,
defense_index_y, attack_index_x, defense_index_x);
if (state.hasPieceOnStand<PAWN>(P))
{
result -= standValue(attack_index, defense_index, attack_index_y,
defense_index_y, attack_index_x, defense_index_x);
}
}
else
{
result += value(attack_index, defense_index, attack_index_y,
defense_index_y, attack_index_x, defense_index_x);
if (state.hasPieceOnStand<PAWN>(P))
{
result += standValue(attack_index, defense_index, attack_index_y,
defense_index_y, attack_index_x, defense_index_x);
}
}
}
if (moved.isPromotion())
{
const int attack_index = index(kings[1], moved.to().x());
const int defense_index = index(kings[0], moved.to().x());
const int attack_index_x =
indexX<true>(king_piece[1], moved.to().x());
const int defense_index_x =
indexX<false>(king_piece[0], moved.to().x());
const int attack_index_y = indexY<altP>(king_piece[1], moved.to().x());
const int defense_index_y = indexY<P>(king_piece[0], moved.to().x());
if (P == BLACK)
{
result += value(attack_index, defense_index, attack_index_y,
defense_index_y, attack_index_x, defense_index_x);
if (state.hasPieceOnStand<PAWN>(P))
{
result += standValue(attack_index, defense_index, attack_index_y,
defense_index_y, attack_index_x, defense_index_x);
}
}
else
{
result -= value(attack_index, defense_index, attack_index_y,
defense_index_y, attack_index_x, defense_index_x);
if (state.hasPieceOnStand<PAWN>(P))
{
result -= standValue(attack_index, defense_index, attack_index_y,
defense_index_y, attack_index_x, defense_index_x);
}
}
const int index_x = (moved.to().x() > 5 ? 10 -
moved.to().x() : moved.to().x());
if (state.isPawnMaskSet<altP>(moved.to().x()))
{
result -=
state_king_relative_table[std::abs(king_bw[BLACK].x() - moved.to().x()) +
BOTH_ON_BOARD * 9];
result +=
state_king_relative_table[std::abs(king_bw[WHITE].x() - moved.to().x()) +
BOTH_ON_BOARD * 9];
if (P == BLACK)
{
result += drop_non_drop_table[index_x - 1 + 5];
result -= drop_non_drop_table[index_x - 1];
result +=
state_king_relative_table[std::abs(king_bw[BLACK].x() - moved.to().x()) +
OPP_ON_BOARD * 9];
result -=
state_king_relative_table[std::abs(king_bw[WHITE].x() - moved.to().x()) +
SELF_ON_BOARD * 9];
}
else
{
result += drop_non_drop_table[index_x - 1];
result -= drop_non_drop_table[index_x - 1 + 5];
result +=
state_king_relative_table[std::abs(king_bw[BLACK].x() - moved.to().x()) +
SELF_ON_BOARD * 9];
result -=
state_king_relative_table[std::abs(king_bw[WHITE].x() - moved.to().x()) +
OPP_ON_BOARD * 9];
}
}
else
{
result +=
state_king_relative_table[std::abs(king_bw[BLACK].x() - moved.to().x()) +
BOTH_ON_STAND * 9];
result -=
state_king_relative_table[std::abs(king_bw[WHITE].x() - moved.to().x()) +
BOTH_ON_STAND * 9];
if (captured == PAWN)
{
result -=
state_king_relative_table[std::abs(king_bw[BLACK].x() - moved.to().x()) +
BOTH_ON_BOARD * 9];
result +=
state_king_relative_table[std::abs(king_bw[WHITE].x() - moved.to().x()) +
BOTH_ON_BOARD * 9];
}
else
{
if (P == BLACK)
{
result -= drop_non_drop_table[index_x - 1];
result += drop_non_drop_table[index_x - 1 + 5];
result -=
state_king_relative_table[std::abs(king_bw[BLACK].x() - moved.to().x()) +
SELF_ON_BOARD * 9];
result +=
state_king_relative_table[std::abs(king_bw[WHITE].x() - moved.to().x()) +
OPP_ON_BOARD * 9];
}
else
{
result -= drop_non_drop_table[index_x - 1 + 5];
result += drop_non_drop_table[index_x - 1];
result -=
state_king_relative_table[std::abs(king_bw[BLACK].x() - moved.to().x()) +
OPP_ON_BOARD * 9];
result +=
state_king_relative_table[std::abs(king_bw[WHITE].x() - moved.to().x()) +
SELF_ON_BOARD * 9];
}
}
}
}
}
if (captured == PAWN)
{
const int attack_index = index(kings[0], moved.to().x());
const int defense_index = index(kings[1], moved.to().x());
const int attack_index_x =
indexX<true>(king_piece[0], moved.to().x());
const int defense_index_x =
indexX<false>(king_piece[1], moved.to().x());
const int attack_index_y = indexY<P>(king_piece[0], moved.to().x());
const int defense_index_y = indexY<altP>(king_piece[1], moved.to().x());
if (P == BLACK)
{
result -= value(attack_index, defense_index, attack_index_y,
defense_index_y, attack_index_x, defense_index_x);
if (state.hasPieceOnStand<PAWN>(alt(P)))
{
result -= standValue(attack_index, defense_index, attack_index_y,
defense_index_y, attack_index_x, defense_index_x);
}
}
else
{
result += value(attack_index, defense_index, attack_index_y,
defense_index_y, attack_index_x, defense_index_x);
if (state.hasPieceOnStand<PAWN>(alt(moved.player())))
{
result += standValue(attack_index, defense_index, attack_index_y,
defense_index_y, attack_index_x, defense_index_x);
}
}
if (!(moved.ptype() == PPAWN && moved.isPromotion())) // promote is already handled above
{
const int index_x =
(moved.to().x() > 5 ? 10 - moved.to().x() : moved.to().x());
if (state.isPawnMaskSet<P>(moved.to().x()))
{
result -=
state_king_relative_table[std::abs(king_bw[BLACK].x() -
moved.to().x()) +
BOTH_ON_BOARD * 9];
result +=
state_king_relative_table[std::abs(king_bw[WHITE].x() -
moved.to().x()) +
BOTH_ON_BOARD * 9];
if (P == BLACK)
{
result += drop_non_drop_table[index_x - 1];
result -= drop_non_drop_table[index_x - 1 + 5];
result +=
state_king_relative_table[std::abs(king_bw[BLACK].x() -
moved.to().x()) +
SELF_ON_BOARD * 9];
result -=
state_king_relative_table[std::abs(king_bw[WHITE].x() -
moved.to().x()) +
OPP_ON_BOARD * 9];
}
else
{
result += drop_non_drop_table[index_x - 1 + 5];
result -= drop_non_drop_table[index_x - 1];
result +=
state_king_relative_table[std::abs(king_bw[BLACK].x() -
moved.to().x()) +
OPP_ON_BOARD * 9];
result -=
state_king_relative_table[std::abs(king_bw[WHITE].x() -
moved.to().x()) +
SELF_ON_BOARD * 9];
}
}
else
{
if (P == BLACK)
{
result -= drop_non_drop_table[index_x - 1 + 5];
result += drop_non_drop_table[index_x - 1];
result -=
state_king_relative_table[std::abs(king_bw[BLACK].x() - moved.to().x()) +
OPP_ON_BOARD * 9];
result +=
state_king_relative_table[std::abs(king_bw[WHITE].x() - moved.to().x()) +
SELF_ON_BOARD * 9];
}
else
{
result -= drop_non_drop_table[index_x - 1];
result += drop_non_drop_table[index_x - 1 + 5];
result -=
state_king_relative_table[std::abs(king_bw[BLACK].x() - moved.to().x()) +
SELF_ON_BOARD * 9];
result +=
state_king_relative_table[std::abs(king_bw[WHITE].x() - moved.to().x()) +
OPP_ON_BOARD * 9];
}
result +=
state_king_relative_table[std::abs(king_bw[BLACK].x() - moved.to().x()) +
BOTH_ON_STAND * 9];
result -=
state_king_relative_table[std::abs(king_bw[WHITE].x() - moved.to().x()) +
BOTH_ON_STAND * 9];
}
}
}
return result;
}
};
class PawnDropX
{
public:
enum { ONE_DIM = 90, DIM = ONE_DIM * EvalStages };
static void setUp(const Weights &weights);
};
class PawnDropPawnStand
{
public:
enum { ONE_DIM = 18, DIM = ONE_DIM * EvalStages };
static void setUp(const Weights &weights);
};
class PawnDropPawnStandX
{
public:
enum { ONE_DIM = 90, DIM = ONE_DIM * EvalStages };
static void setUp(const Weights &weights);
};
class PawnDropPawnStandY
{
public:
enum { ONE_DIM = 162, DIM = ONE_DIM * EvalStages };
static void setUp(const Weights &weights);
};
class PawnDropNonDrop
{
public:
enum { ONE_DIM = 10, DIM = ONE_DIM * EvalStages };
static void setUp(const Weights &weights);
};
class PawnStateKingRelative
{
public:
enum { ONE_DIM = 36, DIM = ONE_DIM * EvalStages };
static void setUp(const Weights &weights);
};
class NoPawnOnStand
{
public:
enum { DIM = 1 };
private:
static MultiInt weight;
public:
static void setUp(const Weights &weights,int stage);
static MultiInt eval(const NumEffectState &state, int black_pawn_count)
{
if (black_pawn_count > 9 && !state.hasPieceOnStand<PAWN>(WHITE))
return -weight;
else if (black_pawn_count < 9 && !state.hasPieceOnStand<PAWN>(BLACK))
return weight;
return MultiInt();
}
};
struct PawnAdvanceUtil
{
static int index(Player P, Square pos)
{
return (P == BLACK ? (pos.y() - 1) : (9 - pos.y()));
}
static bool cantAdvance(const NumEffectState &state, const Piece pawn)
{
return cantAdvance(state, pawn.ptypeO(), pawn.square());
}
static bool cantAdvance(const NumEffectState &state,
const PtypeO ptypeO, const Square position)
{
assert(getPtype(ptypeO) == PAWN);
return state.pieceAt(Board_Table.nextSquare(getOwner(ptypeO),
position,
U)).isOnBoardByOwner(getOwner(ptypeO));
}
};
struct PawnAdvanceAll : public PawnAdvanceUtil
{
template <osl::Player P>
static void adjust(int index, MultiInt& values);
template<Player P>
static void evalWithUpdateBang(const NumEffectState &state, Move moved,
MultiInt& last_value);
};
class PawnAdvance : public PawnAdvanceUtil
{
public:
enum { DIM = 9 };
private:
static CArray<MultiInt, 9> table;
friend struct PawnAdvanceAll;
public:
static void setUp(const Weights &weights,int stage);
static MultiInt eval(const NumEffectState &state);
};
class SilverFeatures
{
public:
static MultiInt eval(const NumEffectState &state);
protected:
template <Player P>
static int indexRetreat(Square pos)
{
return (P == BLACK ? (pos.y() - 1) : (9 - pos.y()));
}
template<Player P>
static bool canRetreat(const NumEffectState &state,
const Piece silver);
template <Player P>
static MultiInt evalOne(const NumEffectState &state,
const Piece silver,
const CArray<Square, 2> &kings)
{
MultiInt result;
if (!canRetreat<P>(state,silver))
{
result += retreat_table[indexRetreat<P>(silver.square())];
}
const Square up =
silver.square() + DirectionPlayerTraits<U, P>::offset();
if (up.isOnBoard())
{
const Piece up_piece = state.pieceAt(up);
if (up_piece.isEmpty() &&
(state.hasEffectByPtypeStrict<PAWN>(alt(P), up) ||
!state.isPawnMaskSet<alt(P)>(silver.square().x())))
{
const int x_diff =
std::abs(kings[P].x() - silver.square().x());
const int y_diff = (P == BLACK ?
silver.square().y() - kings[P].y() :
kings[P].y() - silver.square().y());
result += head_table[x_diff + 9 * (y_diff + 8)];
}
}
return result;
}
static CArray<MultiInt, 153> head_table;
static CArray<MultiInt, 9> retreat_table;
};
class SilverHeadPawnKingRelative : public SilverFeatures
{
public:
enum { ONE_DIM = 153, DIM = ONE_DIM * EvalStages };
static void setUp(const Weights &weights);
};
class SilverRetreat : public SilverFeatures
{
public:
enum { DIM = 9 };
static void setUp(const Weights &weights,int stage);
};
class GoldFeatures
{
public:
static MultiInt eval(const NumEffectState &state);
protected:
template <Player P>
static int indexRetreat(Square pos)
{
return (P == BLACK ? (pos.y() - 1) : (9 - pos.y()));
}
static int indexSideX(Square pos)
{
return (pos.x() > 5 ? 9 - pos.x() : pos.x() - 1);
}
template <Player P>
static int indexSideY(Square pos)
{
return (P == BLACK ? (pos.y() - 1) : (9 - pos.y())) + 5;
}
template<Player P>
static bool canRetreat(const NumEffectState &state,
const Piece gold);
template<Player P>
static bool canMoveToSide(const NumEffectState &state,
const Piece gold)
{
Square r = gold.square() + DirectionPlayerTraits<R, P>::offset();
Square l = gold.square() + DirectionPlayerTraits<L, P>::offset();
// check effect is from lesser pieces?
if ((!r.isOnBoard() ||
state.pieceAt(r).isOnBoardByOwner(gold.owner()) ||
state.hasEffectAt(alt(gold.owner()), r)) &&
(!l.isOnBoard() ||
state.pieceAt(l).isOnBoardByOwner(gold.owner()) ||
state.hasEffectAt(alt(gold.owner()), l)))
{
return false;
}
return true;
}
template <Player P>
static MultiInt evalOne(const NumEffectState &state,
const Piece gold,
const CArray<Square, 2> &kings)
{
assert(P==gold.owner());
MultiInt result;
if (!canRetreat<P>(state, gold))
{
result += retreat_table[indexRetreat<P>(gold.square())];
}
if (!canMoveToSide<P>(state, gold))
{
result += side_table[indexSideX(gold.square())] +
side_table[indexSideY<P>(gold.square())];
}
const Square uur = gold.square().neighbor<P,UUR>();
const Square uul = gold.square().neighbor<P,UUL>();
if ((state.pieceAt(uul).isEmpty() && !state.hasEffectAt(P, uul))
|| (state.pieceAt(uur).isEmpty() && !state.hasEffectAt(P, uur)))
{
assert(state.kingSquare(gold.owner()) == kings[gold.owner()]);
const Square king = kings[P];
const int x_diff = std::abs(king.x() - gold.square().x());
const int y_diff = (P == BLACK ?
gold.square().y() - king.y() :
king.y() - gold.square().y());
result += knight_table[x_diff + 9 * (y_diff + 8)];
}
return result;
}
static CArray<MultiInt, 153> knight_table;
static CArray<MultiInt, 9> retreat_table;
static CArray<MultiInt, 14> side_table;
};
class GoldKnightKingRelative : public GoldFeatures
{
public:
enum { ONE_DIM = 153, DIM = ONE_DIM * EvalStages };
static void setUp(const Weights &weights);
};
class GoldRetreat : public GoldFeatures
{
public:
enum { DIM = 9 };
static void setUp(const Weights &weights,int stage);
};
class GoldSideMove : public GoldFeatures
{
public:
enum { ONE_DIM = 14, DIM = ONE_DIM * EvalStages };
static void setUp(const Weights &weights);
};
class KnightAdvance
{
public:
enum { DIM = 9 };
private:
static CArray<MultiInt, 9> table;
static int index(Player P, Square pos)
{
return (P == BLACK ? (pos.y() - 1) : (9 - pos.y()));
}
template<Player P>
static bool cantAdvance(const NumEffectState &state,
const Piece knight);
public:
static void setUp(const Weights &weights,int stage);
static MultiInt eval(const NumEffectState &state);
};
class AllGold
{
public:
enum { DIM = 1 };
static void setUp(const Weights &weights,int stage);
static MultiInt eval(int black_major_count)
{
if (black_major_count == 4)
return weight;
else if (black_major_count == 0)
return -weight;
return MultiInt();
}
private:
static MultiInt weight;
};
class PtypeY
{
public:
enum { DIM = PTYPE_SIZE * 9 };
static void setUp(const Weights &weights,int stage);
static MultiInt eval(const NumEffectState &state);
template<Player P>
static MultiInt evalWithUpdate(const NumEffectState &, Move moved,
MultiInt const& last_value);
private:
static CArray<MultiInt, 144> table;
static int index(const Piece piece)
{
return index(piece.owner(), piece.ptype(), piece.square());
}
static int index(const Player player, const Ptype ptype, const Square pos)
{
const int y = (player == BLACK ? pos.y() : 10 - pos.y()) - 1;
return ptype * 9 + y;
}
};
class PtypeX
{
public:
enum { DIM = PTYPE_SIZE * 5 };
static void setUp(const Weights &weights,int stage);
static MultiInt eval(const NumEffectState &state);
template<Player P>
static MultiInt evalWithUpdate(const NumEffectState &, Move moved,
MultiInt const& last_value);
private:
static CArray<MultiInt, 80> table;
static int index(const Piece piece)
{
return index(piece.owner(), piece.ptype(), piece.square());
}
static int index(const Player, const Ptype ptype, const Square pos)
{
const int x = (pos.x() > 5 ? 10 - pos.x() : pos.x()) - 1;
return ptype * 5 + x;
}
};
class KnightCheck
{
friend class KnightCheckY;
public:
enum { DIM = 1 };
static void setUp(const Weights &weights,int stage);
static MultiInt eval(const NumEffectState &state);
template <Player Defense>
static bool canCheck(const NumEffectState &state)
{
const Square king = state.kingSquare<Defense>();
const Player offense = alt(Defense);
const Square ul =
king + DirectionPlayerTraits<UUL, Defense>::offset();
const Square ur =
king + DirectionPlayerTraits<UUR, Defense>::offset();
if (ul.isOnBoard())
{
const Piece p = state.pieceAt(ul);
if (!state.hasEffectAt<Defense>(ul) &&
((p.isEmpty() && state.hasPieceOnStand<KNIGHT>(offense)) ||
(!p.isOnBoardByOwner<offense>() &&
state.hasEffectByPtypeStrict<KNIGHT>(offense, ul))))
return true;
}
if (ur.isOnBoard())
{
const Piece p = state.pieceAt(ur);
if (!state.hasEffectAt<Defense>(ur) &&
((p.isEmpty() && state.hasPieceOnStand<KNIGHT>(offense)) ||
(!p.isOnBoardByOwner<offense>() &&
state.hasEffectByPtypeStrict<KNIGHT>(offense, ur))))
return true;
}
return false;
}
static MultiInt value(int index_y) { return weight + y_table[index_y]; }
private:
static MultiInt weight;
template <Player King>
static int indexY(int y)
{
return (King == BLACK ? y - 1 : 9 - y) ;
}
static CArray<MultiInt, 9> y_table;
};
class KnightCheckY
{
public:
enum { ONE_DIM = 9, DIM = ONE_DIM * EvalStages };
static void setUp(const Weights &weights);
};
class KnightHead
{
friend class KnightHeadOppPiecePawnOnStand;
public:
enum { ONE_DIM = 9, DIM = ONE_DIM * EvalStages};
static void setUp(const Weights &weights);
static MultiInt eval(const NumEffectState &state);
private:
static CArray<MultiInt, 9> table;
static CArray<MultiInt, 144> opp_table;
};
class KnightHeadOppPiecePawnOnStand
{
public:
enum { ONE_DIM = 9 * 16, DIM = ONE_DIM * EvalStages};
static void setUp(const Weights &weights);
private:
};
class PawnPtypeOPtypeO
{
friend class PawnPtypeOPtypeOY;
public:
enum { ONE_DIM = 1024, DIM = ONE_DIM * EvalStages };
static void setUp(const Weights &weights);
static MultiInt eval(const NumEffectState &state);
template<Player P>
static MultiInt evalWithUpdate(const NumEffectState &state,
Move moved,
const CArray2d<int, 2, 9> &pawns,
const MultiInt &last_value);
private:
static int index(Player P, PtypeO up, PtypeO up_up)
{
if (P == WHITE)
{
up = altIfPiece(up);
up_up = altIfPiece(up_up);
}
return (up - PTYPEO_MIN) * 32 + (up_up - PTYPEO_MIN);
}
static int indexY(Player P, PtypeO up, PtypeO up_up, int y)
{
const int y_index = (P == BLACK ? y - 1 : 9 - y);
return index(P, up, up_up) + 1024 * y_index;
}
static CArray<MultiInt, 1024> table;
static CArray<MultiInt, 9216> y_table;
};
class PromotedMinorPieces
{
friend class PromotedMinorPiecesY;
public:
enum { ONE_DIM = 9, DIM = ONE_DIM * EvalStages };
static void setUp(const Weights &weights);
static MultiInt eval(const NumEffectState &state);
static MultiInt evalWithUpdate(
const NumEffectState &state,
Move moved,
const MultiInt &last_values);
template <int Sign>
static void adjust(int index, int index_attack, int index_defense,
MultiInt &result);
private:
template <Player P>
static void evalOne(const NumEffectState &state,
const PieceMask promoted,
MultiInt &result);
template <bool attack, Player owner>
static int indexY(const Square king, int x_diff)
{
const int y = (owner == BLACK ? king.y() : 10 - king.y());
return x_diff + (y - 1) * 9 + (attack ? 0 : 81);
}
static CArray<MultiInt, 9> table;
static CArray<MultiInt, 162> y_table;
};
class NonPawnAttacked
{
friend class NonPawnAttackedKingRelative;
public:
enum { ONE_DIM = 64, DIM = ONE_DIM * EvalStages };
static void setUp(const Weights &weights);
static void eval(const NumEffectState &state, MultiIntPair& out);
template<Player P>
static void evalWithUpdateBang(
const NumEffectState &state,
Move moved,
const CArray<PieceMask, 2> &effected_mask,
MultiIntPair &last_value_and_out);
template <int Sign>
static void adjust(int black_turn_king_attack,
int black_turn_king_defense,
int white_turn_king_attack,
int white_turn_king_defense,
MultiIntPair &result);
private:
static int index(bool same_turn, bool has_support, Ptype ptype)
{
return ptype + (same_turn ? 0 : PTYPE_SIZE) +
(has_support ? 0 : PTYPE_SIZE * 2);
}
template <bool Attack>
static int indexK(Square king, bool same_turn, bool has_support,
Square position, Player owner, Ptype ptype)
{
const int x_diff = std::abs(position.x() - king.x());
const int y_diff = (owner == BLACK ?
position.y() - king.y() :
king.y() - position.y());
return ((ptype + (same_turn ? 0 : PTYPE_SIZE) +
(has_support ? 0 : PTYPE_SIZE * 2)) * 9 + x_diff) * 17 +
y_diff + 8 + (Attack ? 0 : 9792);
}
template <bool Attack>
static int indexK(Square king, bool same_turn, bool has_support,
Piece piece)
{
return indexK<Attack>(king, same_turn, has_support,
piece.square(), piece.owner(),
piece.ptype());
}
template <Player Attacked>
static void updateEffectChanged(
const NumEffectState &state,
const CArray<PieceMask, 2> &effected_mask,
const CArray<PieceMask, 2> &new_mask,
int moved_piece_number,
MultiIntPair &result)
{
CArray<Square, 2> kings = {{ state.kingSquare<BLACK>(),
state.kingSquare<WHITE>() }};
// old without, new with
PieceMask black_old = (~effected_mask[alt(Attacked)]) & new_mask[alt(Attacked)] & state.piecesOnBoard(Attacked);
black_old.reset(moved_piece_number);
while (black_old.any())
{
const Piece piece = state.pieceOf(black_old.takeOneBit());
const bool has_support =
new_mask[Attacked].test(piece.number());
const int index_king_black_turn_attack =
indexK<true>(kings[alt(Attacked)], Attacked == BLACK, has_support, piece);
const int index_king_white_turn_attack =
indexK<true>(kings[alt(Attacked)], Attacked == WHITE, has_support, piece);
const int index_king_black_turn_defense =
indexK<false>(kings[Attacked], Attacked == BLACK, has_support, piece);
const int index_king_white_turn_defense =
indexK<false>(kings[Attacked], Attacked == WHITE, has_support, piece);
adjust<Attacked == BLACK ? 1 : -1>(
index_king_black_turn_attack, index_king_black_turn_defense,
index_king_white_turn_attack, index_king_white_turn_defense,
result);
}
// old with, new without
PieceMask black_new = effected_mask[alt(Attacked)] & (~new_mask[alt(Attacked)]) & state.piecesOnBoard(Attacked);
black_new.reset(moved_piece_number);
while (black_new.any())
{
const Piece piece = state.pieceOf(black_new.takeOneBit());
const bool has_support =
effected_mask[Attacked].test(piece.number());
const int index_king_black_turn_attack =
indexK<true>(kings[alt(Attacked)], Attacked == BLACK, has_support, piece);
const int index_king_white_turn_attack =
indexK<true>(kings[alt(Attacked)], Attacked == WHITE, has_support, piece);
const int index_king_black_turn_defense =
indexK<false>(kings[Attacked], Attacked == BLACK, has_support, piece);
const int index_king_white_turn_defense =
indexK<false>(kings[Attacked], Attacked == WHITE, has_support, piece);
adjust<Attacked == BLACK ? -1 : 1>(
index_king_black_turn_attack, index_king_black_turn_defense,
index_king_white_turn_attack, index_king_white_turn_defense,
result);
}
// old with, new with, self with, self without
PieceMask black_self_old = effected_mask[alt(Attacked)] & new_mask[alt(Attacked)] &
effected_mask[Attacked] & (~new_mask[Attacked]) & state.piecesOnBoard(Attacked);
black_self_old.reset(moved_piece_number);
while (black_self_old.any())
{
const Piece piece = state.pieceOf(black_self_old.takeOneBit());
const int index_king_black_turn_attack =
indexK<true>(kings[alt(Attacked)], Attacked == BLACK, false, piece);
const int index_king_white_turn_attack =
indexK<true>(kings[alt(Attacked)], Attacked == WHITE, false, piece);
const int index_king_black_turn_defense =
indexK<false>(kings[Attacked], Attacked == BLACK, false, piece);
const int index_king_white_turn_defense =
indexK<false>(kings[Attacked], Attacked == WHITE, false, piece);
const int index_king_black_turn_attack_old =
indexK<true>(kings[alt(Attacked)], Attacked == BLACK, true, piece);
const int index_king_white_turn_attack_old =
indexK<true>(kings[alt(Attacked)], Attacked == WHITE, true, piece);
const int index_king_black_turn_defense_old =
indexK<false>(kings[Attacked], Attacked == BLACK, true, piece);
const int index_king_white_turn_defense_old =
indexK<false>(kings[Attacked], Attacked == WHITE, true, piece);
adjust<Attacked == BLACK ? -1 : 1>(
index_king_black_turn_attack_old, index_king_black_turn_defense_old,
index_king_white_turn_attack_old, index_king_white_turn_defense_old,
result);
adjust<Attacked == BLACK ? 1 : -1>(
index_king_black_turn_attack, index_king_black_turn_defense,
index_king_white_turn_attack, index_king_white_turn_defense,
result);
}
// old with, new with, self without, self with
PieceMask black_self_new = effected_mask[alt(Attacked)] & new_mask[alt(Attacked)] &
(~effected_mask[Attacked]) & new_mask[Attacked] & state.piecesOnBoard(Attacked);
black_self_new.reset(moved_piece_number);
while (black_self_new.any())
{
const Piece piece = state.pieceOf(black_self_new.takeOneBit());
const int index_king_black_turn_attack =
indexK<true>(kings[alt(Attacked)], Attacked == BLACK, true, piece);
const int index_king_white_turn_attack =
indexK<true>(kings[alt(Attacked)], Attacked == WHITE, true, piece);
const int index_king_black_turn_defense =
indexK<false>(kings[Attacked], Attacked == BLACK, true, piece);
const int index_king_white_turn_defense =
indexK<false>(kings[Attacked], Attacked == WHITE, true, piece);
const int index_king_black_turn_attack_old =
indexK<true>(kings[alt(Attacked)], Attacked == BLACK, false, piece);
const int index_king_white_turn_attack_old =
indexK<true>(kings[alt(Attacked)], Attacked == WHITE, false, piece);
const int index_king_black_turn_defense_old =
indexK<false>(kings[Attacked], Attacked == BLACK, false, piece);
const int index_king_white_turn_defense_old =
indexK<false>(kings[Attacked], Attacked == WHITE, false, piece);
adjust<Attacked == BLACK ? -1 : 1>(
index_king_black_turn_attack_old, index_king_black_turn_defense_old,
index_king_white_turn_attack_old, index_king_white_turn_defense_old,
result);
adjust<Attacked == BLACK ? 1 : -1>(
index_king_black_turn_attack, index_king_black_turn_defense,
index_king_white_turn_attack, index_king_white_turn_defense,
result);
}
}
static CArray<MultiInt, 64> table;
static CArray<MultiInt, 19584> king_table;
};
class NonPawnAttackedKingRelative
{
public:
enum { ONE_DIM = 19584, DIM = ONE_DIM * EvalStages};
static void setUp(const Weights &weights);
};
class PromotedMinorPiecesY
{
public:
enum { ONE_DIM = 162, DIM = ONE_DIM * EvalStages };
static void setUp(const Weights &weights);
};
class PawnPtypeOPtypeOY
{
public:
enum { ONE_DIM = 9216, DIM = ONE_DIM * EvalStages };
static void setUp(const Weights &weights);
};
class NonPawnAttackedPtype
{
public:
enum { ONE_DIM = 1024, DIM = ONE_DIM * EvalStages};
static void setUp(const Weights &weights);
static void eval(const NumEffectState &state,
CArray<PieceMask, 40> &attacked_mask,
MultiIntPair& out);
template<Player P>
static void evalWithUpdateBang(
const NumEffectState &state,
Move moved,
const CArray<PieceMask, 2> &effected_mask,
CArray<PieceMask, 40> &attacked_mask,
MultiIntPair &last_value_and_out);
private:
static int index(bool same_turn, bool has_support, Ptype ptype,
Ptype attack_ptype)
{
return (ptype + (same_turn ? 0 : PTYPE_SIZE) +
(has_support ? 0 : PTYPE_SIZE * 2)) * 16 + attack_ptype;
}
template <int Sign>
static void adjust(int black, int white, MultiIntPair &result)
{
if(Sign>0){
result[BLACK] += table[black];
result[WHITE] += table[white];
}
else{
result[BLACK] -= table[black];
result[WHITE] -= table[white];
}
}
template <bool Plus>
static void evalOnePiece(const Player player,
const Ptype ptype,
const Ptype attack_ptype,
bool with_support,
MultiIntPair &result)
{
const int index_black_turn = index(BLACK == player, with_support,
ptype, attack_ptype);
const int index_white_turn = index(WHITE == player, with_support,
ptype, attack_ptype);
if (Plus)
adjust<1>(index_black_turn, index_white_turn, result);
else
adjust<-1>(index_black_turn, index_white_turn, result);
}
template <Player P>
static void updateChanged(const NumEffectState &state,
const Piece p,
Move moved,
int captured_number,
const CArray<PieceMask, 2> &effected_mask,
const CArray<PieceMask, 2> &new_mask,
CArray<PieceMask, 40> &attacked_mask,
MultiIntPair &result)
{
// old without, new with
PieceMask old = (~effected_mask[alt(P)]) & new_mask[alt(P)] & state.piecesOnBoard(P);
old.reset(p.number());
while (old.any())
{
const Piece piece = state.pieceOf(old.takeOneBit());
const bool has_support =
new_mask[P].test(piece.number());
PieceMask attacking =
state.effectSetAt(piece.square()) &
state.piecesOnBoard(alt(P));
attacked_mask[piece.number()] = attacking;
while (attacking.any())
{
const Piece attack = state.pieceOf(attacking.takeOneBit());
evalOnePiece<P == BLACK>(P, piece.ptype(), attack.ptype(),
has_support, result);
}
}
// old with, new without
PieceMask new_without = effected_mask[alt(P)] & (~new_mask[alt(P)]) & state.piecesOnBoard(P);
new_without.reset(p.number());
while (new_without.any())
{
const Piece piece = state.pieceOf(new_without.takeOneBit());
const bool has_support =
effected_mask[P].test(piece.number());
PieceMask attacking = attacked_mask[piece.number()];
if (moved.isPromotion() && attacking.test(p.number()))
{
evalOnePiece<P != BLACK>(P, piece.ptype(), moved.oldPtype(),
has_support, result);
attacking.reset(p.number());
}
if (captured_number != -1 && attacking.test(captured_number))
{
evalOnePiece<P != BLACK>(P, piece.ptype(), moved.capturePtype(),
has_support, result);
attacking.reset(captured_number);
}
while (attacking.any())
{
const Piece attack = state.pieceOf(attacking.takeOneBit());
evalOnePiece<P != BLACK>(P, piece.ptype(), attack.ptype(),
has_support, result);
}
}
// old with, new with, self with, self without
PieceMask self_old = effected_mask[alt(P)] &
new_mask[alt(P)] &
effected_mask[P] & (~new_mask[P]) & state.piecesOnBoard(P);
self_old.reset(p.number());
while (self_old.any())
{
const Piece piece = state.pieceOf(self_old.takeOneBit());
PieceMask old_attacking = attacked_mask[piece.number()];
if (moved.isPromotion() && old_attacking.test(p.number()))
{
evalOnePiece<P != BLACK>(P, piece.ptype(), moved.oldPtype(),
true, result);
old_attacking.reset(p.number());
}
if (captured_number != -1 && old_attacking.test(captured_number))
{
evalOnePiece<P != BLACK>(P, piece.ptype(), moved.capturePtype(),
true, result);
old_attacking.reset(captured_number);
}
while (old_attacking.any())
{
const Piece attack = state.pieceOf(old_attacking.takeOneBit());
evalOnePiece<P != BLACK>(P, piece.ptype(), attack.ptype(),
true, result);
}
PieceMask new_attacking = state.effectSetAt(piece.square())
& state.piecesOnBoard(alt(P));
attacked_mask[piece.number()] = new_attacking;
while (new_attacking.any())
{
const Piece attack = state.pieceOf(new_attacking.takeOneBit());
evalOnePiece<P == BLACK>(P, piece.ptype(), attack.ptype(),
false, result);
}
}
// old with, new with, self without, self with
PieceMask self_new_with = effected_mask[alt(P)] &
new_mask[alt(P)] &
(~effected_mask[P]) & new_mask[P] & state.piecesOnBoard(P);
self_new_with.reset(p.number());
while (self_new_with.any())
{
const Piece piece = state.pieceOf(self_new_with.takeOneBit());
PieceMask old_attacking = attacked_mask[piece.number()];
if (moved.isPromotion() && old_attacking.test(p.number()))
{
evalOnePiece<P != BLACK>(P, piece.ptype(), moved.oldPtype(),
false, result);
old_attacking.reset(p.number());
}
if (captured_number != -1 && old_attacking.test(captured_number))
{
evalOnePiece<P != BLACK>(P, piece.ptype(), moved.capturePtype(),
false, result);
old_attacking.reset(captured_number);
}
while (old_attacking.any())
{
const Piece attack = state.pieceOf(old_attacking.takeOneBit());
evalOnePiece<P != BLACK>(P, piece.ptype(), attack.ptype(),
false, result);
}
PieceMask new_attacking = state.effectSetAt(piece.square())
& state.piecesOnBoard(alt(P));
attacked_mask[piece.number()] = new_attacking;
while (new_attacking.any())
{
const Piece attack = state.pieceOf(new_attacking.takeOneBit());
evalOnePiece<P == BLACK>(P, piece.ptype(), attack.ptype(),
true, result);
}
}
// old with, new with, support unchanged, attack changed
PieceMask effected = effected_mask[P];
effected ^= new_mask[P];
effected = ~effected;
PieceMask attack_changed = effected_mask[alt(P)] &
new_mask[alt(P)] &
effected & state.piecesOnBoard(P) &
state.effectedChanged(alt(P));
attack_changed.reset(p.number());
while (attack_changed.any())
{
const Piece attacked = state.pieceOf(attack_changed.takeOneBit());
PieceMask attack_old_mask = attacked_mask[attacked.number()];
PieceMask attack_new_mask = state.effectSetAt(attacked.square()) & state.piecesOnBoard(alt(P));
if (captured_number != -1 &&
attack_old_mask.test(captured_number))
{
evalOnePiece<P != BLACK>(P, attacked.ptype(),
moved.capturePtype(),
new_mask[P].test(attacked.number()),
result);
attack_old_mask.reset(captured_number);
}
if (moved.isPromotion() &&
attack_old_mask.test(p.number()))
{
evalOnePiece<P != BLACK>(P, attacked.ptype(),
moved.oldPtype(),
new_mask[P].test(attacked.number()),
result);
attack_old_mask.reset(p.number());
}
if (moved.isPromotion() &&
attack_new_mask.test(p.number()))
{
evalOnePiece<P == BLACK>(P, attacked.ptype(),
moved.ptype(),
new_mask[P].test(attacked.number()),
result);
attack_new_mask.reset(p.number());
}
PieceMask gone = attack_old_mask & (~attack_new_mask);
while (gone.any())
{
const Piece attacking = state.pieceOf(gone.takeOneBit());
evalOnePiece<P != BLACK>(P, attacked.ptype(),
attacking.ptype(),
effected_mask[P].test(attacked.number()),
result);
}
PieceMask added = (~attack_old_mask) & attack_new_mask;
while (added.any())
{
const Piece attacking = state.pieceOf(added.takeOneBit());
evalOnePiece<P == BLACK>(P, attacked.ptype(),
attacking.ptype(),
new_mask[P].test(attacked.number()),
result);
}
attacked_mask[attacked.number()] = state.effectSetAt(attacked.square()) & state.piecesOnBoard(alt(P));
}
}
static CArray<MultiInt, 1024> table;
};
class NonPawnAttackedPtypePair
{
public:
enum {
ONE_DIM = (PTYPE_SIZE * 2 * PTYPE_SIZE)*(PTYPE_SIZE * 2 * PTYPE_SIZE),
DIM = ONE_DIM * EvalStages,
};
static void setUp(const Weights &weights);
template <Player Owner>
static MultiInt evalOne(const NumEffectState &state);
static MultiInt eval(const NumEffectState &state);
static int index1(const NumEffectState &state, Piece piece)
{
const Ptype attack_ptype
= state.findCheapAttack(alt(piece.owner()), piece.square()).ptype();
const bool has_support = state.hasEffectAt(piece.owner(),
piece.square());
return (piece.ptype() +
(has_support ? 0 : PTYPE_SIZE)) * PTYPE_SIZE + attack_ptype;
}
static int index2(int i0, int i1)
{
return i0 * PTYPE_SIZE * 2 * PTYPE_SIZE + i1;
}
static CArray<MultiInt, ONE_DIM> table;
};
class PtypeCount
{
friend class PtypeCountXY;
friend class PtypeCountXYAttack;
public:
enum { ONE_DIM = 160, DIM = ONE_DIM * EvalStages };
static void setUp(const Weights &weights);
template<osl::Player P,osl::Ptype T>
static MultiInt evalPlayerPtype(const CArray2d<int, 2, PTYPE_SIZE> &ptype_count,
const CArray2d<int, 2, PTYPE_SIZE> &ptype_board_count,
const osl::CArray<int,2> &kings_x,
const osl::CArray<int,2> &kings_y);
static void eval(const NumEffectState &state,
const CArray2d<int, 2, PTYPE_SIZE> &ptype_count,
const CArray2d<int, 2, PTYPE_SIZE> &ptype_board_count,
MultiInt &out);
template<Player P>
static void evalWithUpdateBang(
const NumEffectState &state,
Move last_move,
CArray2d<int, 2, PTYPE_SIZE> &ptype_count,
CArray2d<int, 2, PTYPE_SIZE> &ptype_board_count,
MultiInt &last_value_and_out,unsigned int &ptypeo_mask);
private:
static int indexCount(Ptype ptype, int count)
{
return Ptype_Table.getIndexMin(unpromote(ptype)) +
(isPromoted(ptype) ? 40 : 0) +
count - 1;
}
static int indexBoardCount(Ptype ptype, int count)
{
return Ptype_Table.getIndexMin(unpromote(ptype)) +
(isPromoted(ptype) ? 40 : 0) + 80 +
count - 1;
}
static int indexCountX(Ptype ptype, int count, int x)
{
return x - 1 + 5 *
(Ptype_Table.getIndexMin(unpromote(ptype)) +
(isPromoted(ptype) ? 40 : 0) +
count - 1);
}
static int indexCountY(Ptype ptype, int count, int y)
{
return y - 1 + 9 *
(Ptype_Table.getIndexMin(unpromote(ptype)) +
(isPromoted(ptype) ? 40 : 0) +
count - 1) + 800;
}
static int indexBoardCountX(Ptype ptype, int count, int x)
{
return x - 1 + 5 *
(Ptype_Table.getIndexMin(unpromote(ptype)) +
(isPromoted(ptype) ? 40 : 0) +
count - 1) + 400;
}
static int indexBoardCountY(Ptype ptype, int count, int y)
{
return y - 1 + 9 *
(Ptype_Table.getIndexMin(unpromote(ptype)) +
(isPromoted(ptype) ? 40 : 0) +
count - 1) + 720 + 800;
}
template<Ptype T>
static int indexCount(int count)
{
return PtypeTraits<T>::indexMin+ (isPromoted(T) ? 40 : 0) +
count - 1;
}
template<Ptype T>
static int indexBoardCount(int count)
{
return PtypeTraits<T>::indexMin+(isPromoted(T) ? 40 : 0)+ 80 +
count - 1;
}
template<Ptype T>
static int indexCountX(int count, int x)
{
return x - 1 + 5 *
(PtypeTraits<T>::indexMin+(isPromoted(T) ? 40 : 0) +
count - 1);
}
template<Ptype T>
static int indexCountY(int count, int y)
{
return y - 1 + 9 *
(PtypeTraits<T>::indexMin+(isPromoted(T) ? 40 : 0) +
count - 1) + 800;
}
template<Ptype T>
static int indexBoardCountX(int count, int x)
{
return x - 1 + 5 *
(PtypeTraits<T>::indexMin+(isPromoted(T) ? 40 : 0) +
count - 1) + 400;
}
template<Ptype T>
static int indexBoardCountY(int count, int y)
{
return y - 1 + 9 *
(PtypeTraits<T>::indexMin+(isPromoted(T) ? 40 : 0) +
count - 1) + 720 + 800;
}
static MultiInt valueAll(Ptype ptype, int count, int my_king_x, int my_king_y, int op_king_x, int op_king_y)
{
assert(count>0);
return
xy_table_diff[indexCountX(ptype, count, my_king_x)]+
xy_table_diff[indexCountY(ptype, count, my_king_y)]+
xy_attack_table_diff[indexCountX(ptype,count, op_king_x)]+
xy_attack_table_diff[indexCountY(ptype, count, op_king_y)];
}
static MultiInt valueBoardAll(Ptype ptype, int count, int my_king_x, int my_king_y, int op_king_x, int op_king_y)
{
assert(count>0);
return
xy_table_diff[indexBoardCountX(ptype, count, my_king_x)]+
xy_table_diff[indexBoardCountY(ptype, count, my_king_y)]+
xy_attack_table_diff[indexBoardCountX(ptype,count, op_king_x)]+
xy_attack_table_diff[indexBoardCountY(ptype, count, op_king_y)];
}
static CArray<MultiInt, 160> table;
static CArray<MultiInt, 2240> xy_table;
static CArray<MultiInt, 2240> xy_attack_table;
static CArray<MultiInt, 2240> xy_table_diff;
static CArray<MultiInt, 2240> xy_attack_table_diff;
};
class PtypeCountXY
{
public:
enum { ONE_DIM = 2240, DIM = ONE_DIM * EvalStages };
static void setUp(const Weights &weights);
};
class PtypeCountXYAttack
{
public:
enum { ONE_DIM = 2240, DIM = ONE_DIM * EvalStages };
static void setUp(const Weights &weights);
};
class LanceEffectPieceKingRelative
{
public:
enum { ONE_DIM = 9792, DIM = ONE_DIM * EvalStages };
static void setUp(const Weights &weights);
static MultiInt eval(const NumEffectState &state);
private:
static int index(Player p, Square pos, Square king,
PtypeO ptypeO, bool attack)
{
const int y_diff = (p == BLACK ? king.y() - pos.y() : pos.y() - king.y());
const int x_diff = std::abs(king.x() - pos.x());
if (p == WHITE)
{
ptypeO = alt(ptypeO);
}
return y_diff + 8 + x_diff * 17 + (ptypeO - PTYPEO_MIN) * 17 * 9 +
(attack ? 0 : 4896);
}
static CArray<MultiInt, 9792> table;
};
class PtypeYPawnY
{
public:
enum { ONE_DIM = 1440, DIM = ONE_DIM * EvalStages };
static MultiInt eval(const NumEffectState &state,
const CArray2d<int, 2, 9> &pawns);
template<Player P>
static void evalWithUpdateBang(const NumEffectState &state,
Move moved,
const CArray2d<int, 2, 9> &pawns,
MultiInt& last_value);
static void setUp(const Weights &weights);
private:
static int index(Player player, Ptype ptype, int y, int pawn_y)
{
if (player == WHITE)
{
y = 10 - y;
pawn_y = (10 - pawn_y) % 10;
}
return pawn_y + 10 * (y - 1 + 9 * ptype);
}
static CArray<MultiInt, 1440> table;
};
class GoldAndSilverNearKing
{
friend class GoldAndSilverNearKingCombination;
public:
enum { ONE_DIM = 1215, DIM = ONE_DIM * EvalStages };
static void setUp(const Weights &weights);
static MultiInt eval(const NumEffectState &state,
const CArray2d<int, 2, 3> &gs_count);
private:
template <Player Defense>
static int index(const Square king, int distance0, int count)
{
int king_x = (king.x() > 5 ? 10 - king.x() : king.x());
int king_y = (Defense == WHITE ? 10 - king.y() : king.y());
return king_x - 1 + 5 * (king_y - 1+ 9 * (distance0 + 3 * count));
}
template <Player P>
static MultiInt evalOne(const NumEffectState &state,
const CArray2d<int, 2, 3> &gs_count);
template <Player Defense>
static int indexCombination(const Square king, int count0,
int count1, int count2)
{
int king_x = (king.x() > 5 ? 10 - king.x() : king.x());
int king_y = (Defense == WHITE ? 10 - king.y() : king.y());
return king_x + 5 * (king_y + 9 * (std::min(5,count0) + 6 *
(std::min(5,count1) + 6 * std::min(5,count2))));
}
static CArray<MultiInt, 1215> table;
static CArray<MultiInt, 9720> combination_table;
};
class GoldAndSilverNearKingCombination
{
public:
enum { ONE_DIM = 9720, DIM = ONE_DIM * EvalStages };
static void setUp(const Weights &weights);
private:
};
class PtypeCombination
{
public:
enum { ONE_DIM = 8192, DIM = ONE_DIM * EvalStages };
static void setUp(const Weights &weights);
static MultiInt eval(unsigned int ptypeo_mask);
private:
template <Player P>
static MultiInt evalOne(unsigned int ptypeo_mask)
{
int index = 0;
if (P==BLACK) index=((ptypeo_mask>>19)&0x1fc0)|((ptypeo_mask>>18)&0x3f);
else index=((ptypeo_mask>>3)&0x1fc0)|((ptypeo_mask>>2)&0x3f);
if (P == BLACK)
return table[index];
else
return -table[index];
}
static CArray<MultiInt, 8192> table;
};
class SilverFork
{
static std::pair<int,int> matchRook(const NumEffectState& state, Piece rook,
const CArray<bool,2>& has_silver,
Square& silver_drop);
static std::pair<int,int> matchGold(const NumEffectState& state, Piece gold,
const CArray<bool,2>& has_silver,
Square& silver_drop);
public:
enum { ONE_DIM = 5*2, DIM = ONE_DIM * EvalStages };
static void setUp(const Weights &weights);
static MultiIntPair eval(const NumEffectState& state,
CArray<std::pair<Square,int>,2>& silver_drop);
static CArray<MultiInt, ONE_DIM> table;
};
class BishopRookFork
{
public:
enum {
DROP_DIM = PTYPE_SIZE*PTYPE_SIZE,
ONE_DIM = 2*DROP_DIM*2, DIM = ONE_DIM * EvalStages
};
static const Square isBishopForkSquare(const NumEffectState& state, Player defense, const Square a, const Square b, bool maybe_empty=false);
static const Square isRookForkSquare(const NumEffectState& state, Player defense, const Square a, const Square b);
static int bishopIndex(Ptype a, Ptype b) { return a * PTYPE_SIZE + b; }
static int rookIndex(Ptype a, Ptype b) { return bishopIndex(a,b) + DROP_DIM; }
static void setUp(const Weights &weights);
template <Player Defense>
static MultiIntPair evalOne(const NumEffectState& state, const PieceVector& target,
std::pair<Square,int>& bishop_drop,
std::pair<Square,int>& rook_drop);
static MultiIntPair eval(const NumEffectState& state,
CArray<std::pair<Square,int>,2>& bishop_drop,
CArray<std::pair<Square,int>,2>& rook_drop);
static CArray<MultiInt, ONE_DIM> table;
private:
static const Square findDropInLine
(const NumEffectState& state, Player defense,
const Square a, const Square b, Piece king);
static bool testCenter(const NumEffectState& state, Player defense,
const Square a, const Square b, Piece king,
Square center, bool maybe_empty=false);
};
class KnightFork
{
public:
enum {
DROP_DIM = PTYPE_SIZE*PTYPE_SIZE, ONE_DIM = DROP_DIM*2*2,
DIM = ONE_DIM * EvalStages
};
static void setUp(const Weights &weights);
template <Player Defense>
static MultiIntPair evalOne(const NumEffectState& state,
bool has_knight,
BoardMask& knight_fork_squares,
std::pair<Square,int>& knight_drop);
static MultiIntPair eval(const NumEffectState& state,
CArray<BoardMask,2>& knight_fork_squares,
CArray<std::pair<Square,int>,2>& knight_drop);
template <Player P>
static MultiIntPair evalWithUpdate(const NumEffectState& state,
Move moved,
CArray<BoardMask,2>& knight_fork_squares,
CArray<std::pair<Square,int>,2>& knight_drop);
static CArray<MultiInt, ONE_DIM> table;
static bool isForkSquare(const NumEffectState& state, Player defense,
int y, int x0, int x1);
static int index(Ptype a, Ptype b)
{
return a * PTYPE_SIZE + b;
}
static bool isTarget(Ptype ptype)
{
ptype = unpromote(ptype);
return ptype != PAWN && ptype != LANCE && ptype != KNIGHT;
}
private:
template <Player P, Player Defense>
static void updateSquares
(const NumEffectState& state, Move moved,
BoardMask& knight_fork_squares);
template <osl::Player Defense>
static MultiIntPair accumulate
(const NumEffectState& state,
bool has_knight, const BoardMask& knight_fork_squares,
std::pair<Square,int>& knight_drop);
};
class SilverAdvance26
{
public:
enum { ONE_DIM = 1, DIM = ONE_DIM*EvalStages };
static void setUp(const Weights &weights);
static MultiInt eval(const NumEffectState &state);
private:
static CArray<MultiInt, ONE_DIM> table;
};
class Promotion37
{
public:
enum { ONE_DIM = PTYPE_SIZE, DIM = ONE_DIM*EvalStages };
static void setUp(const Weights &weights);
static MultiInt eval(const NumEffectState &state);
template<Player P>
static MultiInt evalOne(const NumEffectState &state, int rank);
template<Player P>
static MultiInt evalWithUpdate(const NumEffectState &, Move moved,
MultiInt const& last_value);
static CArray<MultiInt, ONE_DIM> table;
};
}
}
}
#endif // EVAL_ML_MINORPIECE_H
// ;;; Local Variables:
// ;;; mode:c++
// ;;; c-basic-offset:2
// ;;; End:
osl::CArray
Definition container.h:20
osl::Move
圧縮していない moveの表現 .
Definition basic_type.h:1052
osl::Move::isPromotion
bool isPromotion() const
Definition basic_type.h:1147
osl::Move::ptype
Ptype ptype() const
Definition basic_type.h:1155
osl::Move::player
Player player() const
Definition basic_type.h:1195
osl::Move::isDrop
bool isDrop() const
Definition basic_type.h:1150
osl::Move::capturePtype
Ptype capturePtype() const
Definition basic_type.h:1180
osl::Move::oldPtype
Ptype oldPtype() const
移動前のPtype, i.e., 成る手だった場合成る前
Definition basic_type.h:1174
osl::Move::to
const Square to() const
Definition basic_type.h:1132
osl::NumEffectState
利きを持つ局面
Definition numEffectState.h:34
osl::NumEffectState::effectSetAt
const NumBitmapEffect effectSetAt(Square sq) const
Definition numEffectState.h:258
osl::NumEffectState::effectedChanged
const PieceMask effectedChanged(Player pl) const
前の指手でeffectedMask(pl)が変化したか.
Definition numEffectState.h:137
osl::NumEffectState::hasEffectAt
bool hasEffectAt(Square target) const
対象とするマスにあるプレイヤーの利きがあるかどうか.
Definition numEffectState.h:324
osl::NumEffectState::findCheapAttack
const Piece findCheapAttack(Player P, Square square) const
Definition numEffectState.h:560
osl::NumEffectState::piecesOnBoard
const PieceMask & piecesOnBoard(Player p) const
Definition numEffectState.h:63
osl::NumEffectState::hasEffectByPtypeStrict
bool hasEffectByPtypeStrict(Player attack, Square target) const
target に ptype の利きがあるか?
Definition numEffectState.h:363
osl::PieceMask
駒番号のビットセット.
Definition pieceMask.h:21
osl::PieceMask::test
bool test(int num) const
Definition pieceMask.h:45
osl::PieceMask::any
bool any() const
Definition pieceMask.h:57
osl::PieceMask::reset
void reset(int num)
Definition pieceMask.h:54
osl::PieceVector
Definition container.h:305
osl::Piece
駒.
Definition basic_type.h:788
osl::Piece::ptypeO
PtypeO ptypeO() const
Definition basic_type.h:824
osl::Piece::ptype
Ptype ptype() const
Definition basic_type.h:821
osl::Piece::square
const Square square() const
Definition basic_type.h:832
osl::Piece::isEmpty
bool isEmpty() const
Definition basic_type.h:913
osl::Piece::owner
Player owner() const
Definition basic_type.h:963
osl::Piece::isOnBoardByOwner
bool isOnBoardByOwner() const
piece がプレイヤーPの持ち物でかつボード上にある駒の場合は true.
Definition basic_type.h:852
osl::Piece::number
int number() const
Definition basic_type.h:828
osl::SimpleState::hasPieceOnStand
bool hasPieceOnStand(Player player, Ptype ptype) const
Definition simpleState.h:191
osl::SimpleState::kingPiece
const Piece kingPiece() const
Definition simpleState.h:83
osl::SimpleState::pieceOf
const Piece pieceOf(int num) const
Definition simpleState.h:76
osl::SimpleState::kingSquare
Square kingSquare() const
Definition simpleState.h:94
osl::SimpleState::isPawnMaskSet
bool isPawnMaskSet(Player player, int x) const
Definition simpleState.h:146
osl::SimpleState::countPiecesOnStand
int countPiecesOnStand(Player pl, Ptype ptype) const
持駒の枚数を数える
Definition simpleState.h:182
osl::SimpleState::pieceAt
const Piece pieceAt(Square sq) const
Definition simpleState.h:167
osl::Square
Definition basic_type.h:532
osl::Square::y
int y() const
将棋としてのY座標を返す.
Definition basic_type.h:567
osl::Square::neighbor
const Square neighbor() const
Definition basic_type.h:746
osl::Square::isOnBoard
bool isOnBoard() const
盤面上を表すかどうかの判定． 1<=x() && x()<=9 && 1<=y() && y()<=9 Squareの内部表現に依存する．
Definition basic_type.h:583
osl::Square::x
int x() const
将棋としてのX座標を返す.
Definition basic_type.h:563
osl::container::BoardMask
11 x 12
Definition boardMask.h:21
osl::container::PieceMask64::takeOneBit
int takeOneBit()
Definition pieceMask64.h:82
osl::eval::ml::AllGold
Definition minorPiece.h:715
osl::eval::ml::AllGold::weight
static MultiInt weight
Definition minorPiece.h:729
osl::eval::ml::AllGold::eval
static MultiInt eval(int black_major_count)
Definition minorPiece.h:719
osl::eval::ml::AllGold::DIM
@ DIM
Definition minorPiece.h:717
osl::eval::ml::AllGold::setUp
static void setUp(const Weights &weights, int stage)
Definition minorPiece.cc:507
osl::eval::ml::BishopRookFork
Definition minorPiece.h:1639
osl::eval::ml::BishopRookFork::isRookForkSquare
static const Square isRookForkSquare(const NumEffectState &state, Player defense, const Square a, const Square b)
Definition minorPiece.cc:2522
osl::eval::ml::BishopRookFork::bishopIndex
static int bishopIndex(Ptype a, Ptype b)
Definition minorPiece.h:1647
osl::eval::ml::BishopRookFork::DIM
@ DIM
Definition minorPiece.h:1643
osl::eval::ml::BishopRookFork::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:1643
osl::eval::ml::BishopRookFork::DROP_DIM
@ DROP_DIM
Definition minorPiece.h:1642
osl::eval::ml::BishopRookFork::rookIndex
static int rookIndex(Ptype a, Ptype b)
Definition minorPiece.h:1648
osl::eval::ml::BishopRookFork::eval
static MultiIntPair eval(const NumEffectState &state, CArray< std::pair< Square, int >, 2 > &bishop_drop, CArray< std::pair< Square, int >, 2 > &rook_drop)
Definition minorPiece.cc:2608
osl::eval::ml::BishopRookFork::evalOne
static MultiIntPair evalOne(const NumEffectState &state, const PieceVector &target, std::pair< Square, int > &bishop_drop, std::pair< Square, int > &rook_drop)
osl::eval::ml::BishopRookFork::testCenter
static bool testCenter(const NumEffectState &state, Player defense, const Square a, const Square b, Piece king, Square center, bool maybe_empty=false)
Definition minorPiece.cc:2480
osl::eval::ml::BishopRookFork::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:2443
osl::eval::ml::BishopRookFork::isBishopForkSquare
static const Square isBishopForkSquare(const NumEffectState &state, Player defense, const Square a, const Square b, bool maybe_empty=false)
Definition minorPiece.cc:2495
osl::eval::ml::BishopRookFork::findDropInLine
static const Square findDropInLine(const NumEffectState &state, Player defense, const Square a, const Square b, Piece king)
Definition minorPiece.cc:2461
osl::eval::ml::BishopRookFork::table
static CArray< MultiInt, ONE_DIM > table
Definition minorPiece.h:1657
osl::eval::ml::GoldAndSilverNearKingCombination
Definition minorPiece.h:1596
osl::eval::ml::GoldAndSilverNearKingCombination::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:2217
osl::eval::ml::GoldAndSilverNearKingCombination::DIM
@ DIM
Definition minorPiece.h:1598
osl::eval::ml::GoldAndSilverNearKingCombination::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:1598
osl::eval::ml::GoldAndSilverNearKing
Definition minorPiece.h:1564
osl::eval::ml::GoldAndSilverNearKing::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:2207
osl::eval::ml::GoldAndSilverNearKing::DIM
@ DIM
Definition minorPiece.h:1567
osl::eval::ml::GoldAndSilverNearKing::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:1567
osl::eval::ml::GoldAndSilverNearKing::index
static int index(const Square king, int distance0, int count)
Definition minorPiece.h:1573
osl::eval::ml::GoldAndSilverNearKing::combination_table
static CArray< MultiInt, 9720 > combination_table
Definition minorPiece.h:1592
osl::eval::ml::GoldAndSilverNearKing::GoldAndSilverNearKingCombination
friend class GoldAndSilverNearKingCombination
Definition minorPiece.h:1565
osl::eval::ml::GoldAndSilverNearKing::table
static CArray< MultiInt, 1215 > table
Definition minorPiece.h:1591
osl::eval::ml::GoldAndSilverNearKing::evalOne
static MultiInt evalOne(const NumEffectState &state, const CArray2d< int, 2, 3 > &gs_count)
osl::eval::ml::GoldAndSilverNearKing::indexCombination
static int indexCombination(const Square king, int count0, int count1, int count2)
Definition minorPiece.h:1583
osl::eval::ml::GoldFeatures
Definition minorPiece.h:600
osl::eval::ml::GoldFeatures::indexSideX
static int indexSideX(Square pos)
Definition minorPiece.h:609
osl::eval::ml::GoldFeatures::side_table
static CArray< MultiInt, 14 > side_table
Definition minorPiece.h:672
osl::eval::ml::GoldFeatures::evalOne
static MultiInt evalOne(const NumEffectState &state, const Piece gold, const CArray< Square, 2 > &kings)
Definition minorPiece.h:640
osl::eval::ml::GoldFeatures::eval
static MultiInt eval(const NumEffectState &state)
Definition minorPiece.cc:397
osl::eval::ml::GoldFeatures::indexRetreat
static int indexRetreat(Square pos)
Definition minorPiece.h:605
osl::eval::ml::GoldFeatures::knight_table
static CArray< MultiInt, 153 > knight_table
Definition minorPiece.h:670
osl::eval::ml::GoldFeatures::canMoveToSide
static bool canMoveToSide(const NumEffectState &state, const Piece gold)
Definition minorPiece.h:622
osl::eval::ml::GoldFeatures::indexSideY
static int indexSideY(Square pos)
Definition minorPiece.h:614
osl::eval::ml::GoldFeatures::canRetreat
static bool canRetreat(const NumEffectState &state, const Piece gold)
Definition minorPiece.cc:423
osl::eval::ml::GoldFeatures::retreat_table
static CArray< MultiInt, 9 > retreat_table
Definition minorPiece.h:671
osl::eval::ml::GoldKnightKingRelative
Definition minorPiece.h:676
osl::eval::ml::GoldKnightKingRelative::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:377
osl::eval::ml::GoldKnightKingRelative::DIM
@ DIM
Definition minorPiece.h:678
osl::eval::ml::GoldKnightKingRelative::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:678
osl::eval::ml::GoldRetreat
Definition minorPiece.h:683
osl::eval::ml::GoldRetreat::setUp
static void setUp(const Weights &weights, int stage)
Definition minorPiece.cc:443
osl::eval::ml::GoldRetreat::DIM
@ DIM
Definition minorPiece.h:685
osl::eval::ml::GoldSideMove
Definition minorPiece.h:690
osl::eval::ml::GoldSideMove::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:387
osl::eval::ml::GoldSideMove::DIM
@ DIM
Definition minorPiece.h:692
osl::eval::ml::GoldSideMove::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:692
osl::eval::ml::KnightAdvance
Definition minorPiece.h:697
osl::eval::ml::KnightAdvance::setUp
static void setUp(const Weights &weights, int stage)
Definition minorPiece.cc:476
osl::eval::ml::KnightAdvance::cantAdvance
static bool cantAdvance(const NumEffectState &state, const Piece knight)
Definition minorPiece.cc:457
osl::eval::ml::KnightAdvance::DIM
@ DIM
Definition minorPiece.h:699
osl::eval::ml::KnightAdvance::table
static CArray< MultiInt, 9 > table
Definition minorPiece.h:701
osl::eval::ml::KnightAdvance::index
static int index(Player P, Square pos)
Definition minorPiece.h:702
osl::eval::ml::KnightCheckY
Definition minorPiece.h:824
osl::eval::ml::KnightCheckY::DIM
@ DIM
Definition minorPiece.h:826
osl::eval::ml::KnightCheckY::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:826
osl::eval::ml::KnightCheckY::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:642
osl::eval::ml::KnightCheck
Definition minorPiece.h:777
osl::eval::ml::KnightCheck::setUp
static void setUp(const Weights &weights, int stage)
Definition minorPiece.cc:636
osl::eval::ml::KnightCheck::DIM
@ DIM
Definition minorPiece.h:780
osl::eval::ml::KnightCheck::weight
static MultiInt weight
Definition minorPiece.h:814
osl::eval::ml::KnightCheck::canCheck
static bool canCheck(const NumEffectState &state)
Definition minorPiece.h:784
osl::eval::ml::KnightCheck::y_table
static CArray< MultiInt, 9 > y_table
Definition minorPiece.h:820
osl::eval::ml::KnightCheck::value
static MultiInt value(int index_y)
Definition minorPiece.h:812
osl::eval::ml::KnightCheck::indexY
static int indexY(int y)
Definition minorPiece.h:816
osl::eval::ml::KnightCheck::KnightCheckY
friend class KnightCheckY
Definition minorPiece.h:778
osl::eval::ml::KnightFork
Definition minorPiece.h:1668
osl::eval::ml::KnightFork::isForkSquare
static bool isForkSquare(const NumEffectState &state, Player defense, int y, int x0, int x1)
osl::eval::ml::KnightFork::table
static CArray< MultiInt, ONE_DIM > table
Definition minorPiece.h:1688
osl::eval::ml::KnightFork::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:1671
osl::eval::ml::KnightFork::DIM
@ DIM
Definition minorPiece.h:1672
osl::eval::ml::KnightFork::DROP_DIM
@ DROP_DIM
Definition minorPiece.h:1671
osl::eval::ml::KnightFork::eval
static MultiIntPair eval(const NumEffectState &state, CArray< BoardMask, 2 > &knight_fork_squares, CArray< std::pair< Square, int >, 2 > &knight_drop)
Definition minorPiece.cc:2737
osl::eval::ml::KnightFork::evalWithUpdate
static MultiIntPair evalWithUpdate(const NumEffectState &state, Move moved, CArray< BoardMask, 2 > &knight_fork_squares, CArray< std::pair< Square, int >, 2 > &knight_drop)
osl::eval::ml::KnightFork::updateSquares
static void updateSquares(const NumEffectState &state, Move moved, BoardMask &knight_fork_squares)
Definition minorPiece.cc:2787
osl::eval::ml::KnightFork::evalOne
static MultiIntPair evalOne(const NumEffectState &state, bool has_knight, BoardMask &knight_fork_squares, std::pair< Square, int > &knight_drop)
osl::eval::ml::KnightFork::index
static int index(Ptype a, Ptype b)
Definition minorPiece.h:1692
osl::eval::ml::KnightFork::accumulate
static MultiIntPair accumulate(const NumEffectState &state, bool has_knight, const BoardMask &knight_fork_squares, std::pair< Square, int > &knight_drop)
osl::eval::ml::KnightFork::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:2651
osl::eval::ml::KnightFork::isTarget
static bool isTarget(Ptype ptype)
Definition minorPiece.h:1696
osl::eval::ml::KnightHeadOppPiecePawnOnStand
Definition minorPiece.h:843
osl::eval::ml::KnightHeadOppPiecePawnOnStand::DIM
@ DIM
Definition minorPiece.h:845
osl::eval::ml::KnightHeadOppPiecePawnOnStand::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:845
osl::eval::ml::KnightHeadOppPiecePawnOnStand::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:1376
osl::eval::ml::KnightHead
Definition minorPiece.h:831
osl::eval::ml::KnightHead::opp_table
static CArray< MultiInt, 144 > opp_table
Definition minorPiece.h:839
osl::eval::ml::KnightHead::KnightHeadOppPiecePawnOnStand
friend class KnightHeadOppPiecePawnOnStand
Definition minorPiece.h:832
osl::eval::ml::KnightHead::DIM
@ DIM
Definition minorPiece.h:834
osl::eval::ml::KnightHead::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:834
osl::eval::ml::KnightHead::table
static CArray< MultiInt, 9 > table
Definition minorPiece.h:838
osl::eval::ml::KnightHead::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:1366
osl::eval::ml::LanceEffectPieceKingRelative
Definition minorPiece.h:1517
osl::eval::ml::LanceEffectPieceKingRelative::index
static int index(Player p, Square pos, Square king, PtypeO ptypeO, bool attack)
Definition minorPiece.h:1523
osl::eval::ml::LanceEffectPieceKingRelative::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:1519
osl::eval::ml::LanceEffectPieceKingRelative::DIM
@ DIM
Definition minorPiece.h:1519
osl::eval::ml::LanceEffectPieceKingRelative::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:1967
osl::eval::ml::LanceEffectPieceKingRelative::table
static CArray< MultiInt, 9792 > table
Definition minorPiece.h:1535
osl::eval::ml::NoPawnOnStand
Definition minorPiece.h:481
osl::eval::ml::NoPawnOnStand::DIM
@ DIM
Definition minorPiece.h:483
osl::eval::ml::NoPawnOnStand::setUp
static void setUp(const Weights &weights, int stage)
Definition minorPiece.cc:204
osl::eval::ml::NoPawnOnStand::eval
static MultiInt eval(const NumEffectState &state, int black_pawn_count)
Definition minorPiece.h:488
osl::eval::ml::NoPawnOnStand::weight
static MultiInt weight
Definition minorPiece.h:485
osl::eval::ml::NonPawnAttackedKingRelative
Definition minorPiece.h:1079
osl::eval::ml::NonPawnAttackedKingRelative::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:1081
osl::eval::ml::NonPawnAttackedKingRelative::DIM
@ DIM
Definition minorPiece.h:1081
osl::eval::ml::NonPawnAttackedKingRelative::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:1111
osl::eval::ml::NonPawnAttackedPtypePair
Definition minorPiece.h:1348
osl::eval::ml::NonPawnAttackedPtypePair::index2
static int index2(int i0, int i1)
Definition minorPiece.h:1367
osl::eval::ml::NonPawnAttackedPtypePair::table
static CArray< MultiInt, ONE_DIM > table
Definition minorPiece.h:1371
osl::eval::ml::NonPawnAttackedPtypePair::index1
static int index1(const NumEffectState &state, Piece piece)
Definition minorPiece.h:1358
osl::eval::ml::NonPawnAttackedPtypePair::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:1643
osl::eval::ml::NonPawnAttackedPtypePair::eval
static MultiInt eval(const NumEffectState &state)
Definition minorPiece.cc:1685
osl::eval::ml::NonPawnAttackedPtypePair::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:1351
osl::eval::ml::NonPawnAttackedPtypePair::DIM
@ DIM
Definition minorPiece.h:1352
osl::eval::ml::NonPawnAttackedPtypePair::evalOne
static MultiInt evalOne(const NumEffectState &state)
osl::eval::ml::NonPawnAttackedPtype
Definition minorPiece.h:1100
osl::eval::ml::NonPawnAttackedPtype::evalWithUpdateBang
static void evalWithUpdateBang(const NumEffectState &state, Move moved, const CArray< PieceMask, 2 > &effected_mask, CArray< PieceMask, 40 > &attacked_mask, MultiIntPair &last_value_and_out)
Definition minorPiece.cc:1506
osl::eval::ml::NonPawnAttackedPtype::evalOnePiece
static void evalOnePiece(const Player player, const Ptype ptype, const Ptype attack_ptype, bool with_support, MultiIntPair &result)
Definition minorPiece.h:1134
osl::eval::ml::NonPawnAttackedPtype::table
static CArray< MultiInt, 1024 > table
Definition minorPiece.h:1344
osl::eval::ml::NonPawnAttackedPtype::updateChanged
static void updateChanged(const NumEffectState &state, const Piece p, Move moved, int captured_number, const CArray< PieceMask, 2 > &effected_mask, const CArray< PieceMask, 2 > &new_mask, CArray< PieceMask, 40 > &attacked_mask, MultiIntPair &result)
Definition minorPiece.h:1150
osl::eval::ml::NonPawnAttackedPtype::DIM
@ DIM
Definition minorPiece.h:1102
osl::eval::ml::NonPawnAttackedPtype::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:1102
osl::eval::ml::NonPawnAttackedPtype::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:1442
osl::eval::ml::NonPawnAttackedPtype::index
static int index(bool same_turn, bool has_support, Ptype ptype, Ptype attack_ptype)
Definition minorPiece.h:1115
osl::eval::ml::NonPawnAttackedPtype::adjust
static void adjust(int black, int white, MultiIntPair &result)
Definition minorPiece.h:1122
osl::eval::ml::NonPawnAttacked
Definition minorPiece.h:910
osl::eval::ml::NonPawnAttacked::king_table
static CArray< MultiInt, 19584 > king_table
Definition minorPiece.h:1075
osl::eval::ml::NonPawnAttacked::adjust
static void adjust(int black_turn_king_attack, int black_turn_king_defense, int white_turn_king_attack, int white_turn_king_defense, MultiIntPair &result)
Definition minorPiece.cc:1135
osl::eval::ml::NonPawnAttacked::indexK
static int indexK(Square king, bool same_turn, bool has_support, Square position, Player owner, Ptype ptype)
Definition minorPiece.h:935
osl::eval::ml::NonPawnAttacked::table
static CArray< MultiInt, 64 > table
Definition minorPiece.h:1074
osl::eval::ml::NonPawnAttacked::index
static int index(bool same_turn, bool has_support, Ptype ptype)
Definition minorPiece.h:929
osl::eval::ml::NonPawnAttacked::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:1102
osl::eval::ml::NonPawnAttacked::updateEffectChanged
static void updateEffectChanged(const NumEffectState &state, const CArray< PieceMask, 2 > &effected_mask, const CArray< PieceMask, 2 > &new_mask, int moved_piece_number, MultiIntPair &result)
Definition minorPiece.h:956
osl::eval::ml::NonPawnAttacked::indexK
static int indexK(Square king, bool same_turn, bool has_support, Piece piece)
Definition minorPiece.h:947
osl::eval::ml::NonPawnAttacked::evalWithUpdateBang
static void evalWithUpdateBang(const NumEffectState &state, Move moved, const CArray< PieceMask, 2 > &effected_mask, MultiIntPair &last_value_and_out)
Definition minorPiece.cc:1240
osl::eval::ml::NonPawnAttacked::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:913
osl::eval::ml::NonPawnAttacked::DIM
@ DIM
Definition minorPiece.h:913
osl::eval::ml::NonPawnAttacked::NonPawnAttackedKingRelative
friend class NonPawnAttackedKingRelative
Definition minorPiece.h:911
osl::eval::ml::PawnAdvance
Definition minorPiece.h:528
osl::eval::ml::PawnAdvance::DIM
@ DIM
Definition minorPiece.h:530
osl::eval::ml::PawnAdvance::PawnAdvanceAll
friend struct PawnAdvanceAll
Definition minorPiece.h:533
osl::eval::ml::PawnAdvance::eval
static MultiInt eval(const NumEffectState &state)
Definition minorPiece.cc:221
osl::eval::ml::PawnAdvance::table
static CArray< MultiInt, 9 > table
Definition minorPiece.h:532
osl::eval::ml::PawnAdvance::setUp
static void setUp(const Weights &weights, int stage)
Definition minorPiece.cc:214
osl::eval::ml::PawnDropBoth
Definition minorPiece.h:33
osl::eval::ml::PawnDropBoth::indexY
static int indexY(const Piece king, int x)
Definition minorPiece.h:53
osl::eval::ml::PawnDropBoth::PawnDropPawnStandY
friend class PawnDropPawnStandY
Definition minorPiece.h:39
osl::eval::ml::PawnDropBoth::PawnDropPawnStandX
friend class PawnDropPawnStandX
Definition minorPiece.h:38
osl::eval::ml::PawnDropBoth::PawnDropPawnStand
friend class PawnDropPawnStand
Definition minorPiece.h:37
osl::eval::ml::PawnDropBoth::defense_y_table
static CArray< MultiInt, 81 > defense_y_table
Definition minorPiece.h:45
osl::eval::ml::PawnDropBoth::index
static int index(const Square king, int x)
Definition minorPiece.h:60
osl::eval::ml::PawnDropBoth::PawnDropY
friend class PawnDropY
Definition minorPiece.h:35
osl::eval::ml::PawnDropBoth::PawnStateKingRelative
friend class PawnStateKingRelative
Definition minorPiece.h:41
osl::eval::ml::PawnDropBoth::x_stand_table
static CArray< MultiInt, 90 > x_stand_table
Definition minorPiece.h:48
osl::eval::ml::PawnDropBoth::evalWithUpdate
static MultiInt evalWithUpdate(const NumEffectState &state, Move moved, MultiInt &last_value)
Definition minorPiece.h:100
osl::eval::ml::PawnDropBoth::value
static MultiInt value(int attack_index, int defense_index, int attack_index_y, int defense_index_y, int attack_index_x, int defense_index_x)
Definition minorPiece.h:74
osl::eval::ml::PawnDropBoth::OPP_ON_BOARD
@ OPP_ON_BOARD
Definition minorPiece.h:43
osl::eval::ml::PawnDropBoth::BOTH_ON_STAND
@ BOTH_ON_STAND
Definition minorPiece.h:43
osl::eval::ml::PawnDropBoth::BOTH_ON_BOARD
@ BOTH_ON_BOARD
Definition minorPiece.h:43
osl::eval::ml::PawnDropBoth::SELF_ON_BOARD
@ SELF_ON_BOARD
Definition minorPiece.h:43
osl::eval::ml::PawnDropBoth::x_table
static CArray< MultiInt, 90 > x_table
Definition minorPiece.h:46
osl::eval::ml::PawnDropBoth::y_stand_table
static CArray< MultiInt, 162 > y_stand_table
Definition minorPiece.h:49
osl::eval::ml::PawnDropBoth::PawnDropX
friend class PawnDropX
Definition minorPiece.h:36
osl::eval::ml::PawnDropBoth::attack_y_table
static CArray< MultiInt, 81 > attack_y_table
Definition minorPiece.h:45
osl::eval::ml::PawnDropBoth::attack_table
static CArray< MultiInt, 9 > attack_table
Definition minorPiece.h:44
osl::eval::ml::PawnDropBoth::PawnDropNonDrop
friend class PawnDropNonDrop
Definition minorPiece.h:40
osl::eval::ml::PawnDropBoth::state_king_relative_table
static CArray< MultiInt, 36 > state_king_relative_table
Definition minorPiece.h:51
osl::eval::ml::PawnDropBoth::standValue
static MultiInt standValue(int attack_index, int defense_index, int attack_index_y, int defense_index_y, int attack_index_x, int defense_index_x)
Definition minorPiece.h:86
osl::eval::ml::PawnDropBoth::PawnDrop
friend class PawnDrop
Definition minorPiece.h:34
osl::eval::ml::PawnDropBoth::eval
static MultiInt eval(const NumEffectState &state)
Definition minorPiece.cc:100
osl::eval::ml::PawnDropBoth::drop_non_drop_table
static CArray< MultiInt, 10 > drop_non_drop_table
Definition minorPiece.h:50
osl::eval::ml::PawnDropBoth::defense_table
static CArray< MultiInt, 9 > defense_table
Definition minorPiece.h:44
osl::eval::ml::PawnDropBoth::stand_table
static CArray< MultiInt, 18 > stand_table
Definition minorPiece.h:47
osl::eval::ml::PawnDropBoth::indexX
static int indexX(const Piece king, int x)
Definition minorPiece.h:65
osl::eval::ml::PawnDropNonDrop
Definition minorPiece.h:467
osl::eval::ml::PawnDropNonDrop::DIM
@ DIM
Definition minorPiece.h:469
osl::eval::ml::PawnDropNonDrop::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:469
osl::eval::ml::PawnDropNonDrop::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:82
osl::eval::ml::PawnDropPawnStandX
Definition minorPiece.h:454
osl::eval::ml::PawnDropPawnStandX::DIM
@ DIM
Definition minorPiece.h:456
osl::eval::ml::PawnDropPawnStandX::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:456
osl::eval::ml::PawnDropPawnStandX::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:65
osl::eval::ml::PawnDropPawnStandY
Definition minorPiece.h:460
osl::eval::ml::PawnDropPawnStandY::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:73
osl::eval::ml::PawnDropPawnStandY::DIM
@ DIM
Definition minorPiece.h:462
osl::eval::ml::PawnDropPawnStandY::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:462
osl::eval::ml::PawnDropPawnStand
Definition minorPiece.h:448
osl::eval::ml::PawnDropPawnStand::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:450
osl::eval::ml::PawnDropPawnStand::DIM
@ DIM
Definition minorPiece.h:450
osl::eval::ml::PawnDropPawnStand::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:56
osl::eval::ml::PawnDropX
Definition minorPiece.h:441
osl::eval::ml::PawnDropX::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:6
osl::eval::ml::PawnDropX::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:443
osl::eval::ml::PawnDropX::DIM
@ DIM
Definition minorPiece.h:443
osl::eval::ml::PawnDropY
Definition minorPiece.h:26
osl::eval::ml::PawnDropY::DIM
@ DIM
Definition minorPiece.h:28
osl::eval::ml::PawnDropY::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:28
osl::eval::ml::PawnDropY::setUp
static void setUp(const Weights &weights, int stage)
Definition minorPiece.cc:47
osl::eval::ml::PawnDrop
Definition minorPiece.h:19
osl::eval::ml::PawnDrop::DIM
@ DIM
Definition minorPiece.h:21
osl::eval::ml::PawnDrop::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:21
osl::eval::ml::PawnDrop::setUp
static void setUp(const Weights &weights, int stage)
Definition minorPiece.cc:38
osl::eval::ml::PawnPtypeOPtypeOY
Definition minorPiece.h:1093
osl::eval::ml::PawnPtypeOPtypeOY::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:1095
osl::eval::ml::PawnPtypeOPtypeOY::DIM
@ DIM
Definition minorPiece.h:1095
osl::eval::ml::PawnPtypeOPtypeOY::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:682
osl::eval::ml::PawnPtypeOPtypeO
Definition minorPiece.h:851
osl::eval::ml::PawnPtypeOPtypeO::PawnPtypeOPtypeOY
friend class PawnPtypeOPtypeOY
Definition minorPiece.h:852
osl::eval::ml::PawnPtypeOPtypeO::index
static int index(Player P, PtypeO up, PtypeO up_up)
Definition minorPiece.h:863
osl::eval::ml::PawnPtypeOPtypeO::indexY
static int indexY(Player P, PtypeO up, PtypeO up_up, int y)
Definition minorPiece.h:872
osl::eval::ml::PawnPtypeOPtypeO::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:854
osl::eval::ml::PawnPtypeOPtypeO::DIM
@ DIM
Definition minorPiece.h:854
osl::eval::ml::PawnPtypeOPtypeO::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:672
osl::eval::ml::PawnPtypeOPtypeO::y_table
static CArray< MultiInt, 9216 > y_table
Definition minorPiece.h:878
osl::eval::ml::PawnPtypeOPtypeO::evalWithUpdate
static MultiInt evalWithUpdate(const NumEffectState &state, Move moved, const CArray2d< int, 2, 9 > &pawns, const MultiInt &last_value)
Definition minorPiece.cc:727
osl::eval::ml::PawnPtypeOPtypeO::table
static CArray< MultiInt, 1024 > table
Definition minorPiece.h:877
osl::eval::ml::PawnStateKingRelative
Definition minorPiece.h:474
osl::eval::ml::PawnStateKingRelative::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:476
osl::eval::ml::PawnStateKingRelative::DIM
@ DIM
Definition minorPiece.h:476
osl::eval::ml::PawnStateKingRelative::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:91
osl::eval::ml::PromotedMinorPiecesY
Definition minorPiece.h:1086
osl::eval::ml::PromotedMinorPiecesY::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:974
osl::eval::ml::PromotedMinorPiecesY::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:1088
osl::eval::ml::PromotedMinorPiecesY::DIM
@ DIM
Definition minorPiece.h:1088
osl::eval::ml::PromotedMinorPieces
Definition minorPiece.h:882
osl::eval::ml::PromotedMinorPieces::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:964
osl::eval::ml::PromotedMinorPieces::indexY
static int indexY(const Square king, int x_diff)
Definition minorPiece.h:901
osl::eval::ml::PromotedMinorPieces::table
static CArray< MultiInt, 9 > table
Definition minorPiece.h:906
osl::eval::ml::PromotedMinorPieces::PromotedMinorPiecesY
friend class PromotedMinorPiecesY
Definition minorPiece.h:883
osl::eval::ml::PromotedMinorPieces::adjust
static void adjust(int index, int index_attack, int index_defense, MultiInt &result)
Definition minorPiece.cc:985
osl::eval::ml::PromotedMinorPieces::evalWithUpdate
static MultiInt evalWithUpdate(const NumEffectState &state, Move moved, const MultiInt &last_values)
Definition minorPiece.cc:1084
osl::eval::ml::PromotedMinorPieces::evalOne
static void evalOne(const NumEffectState &state, const PieceMask promoted, MultiInt &result)
Definition minorPiece.cc:995
osl::eval::ml::PromotedMinorPieces::y_table
static CArray< MultiInt, 162 > y_table
Definition minorPiece.h:907
osl::eval::ml::PromotedMinorPieces::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:885
osl::eval::ml::PromotedMinorPieces::DIM
@ DIM
Definition minorPiece.h:885
osl::eval::ml::Promotion37
Definition minorPiece.h:1724
osl::eval::ml::Promotion37::evalWithUpdate
static MultiInt evalWithUpdate(const NumEffectState &, Move moved, MultiInt const &last_value)
osl::eval::ml::Promotion37::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:1726
osl::eval::ml::Promotion37::DIM
@ DIM
Definition minorPiece.h:1726
osl::eval::ml::Promotion37::evalOne
static MultiInt evalOne(const NumEffectState &state, int rank)
osl::eval::ml::Promotion37::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:2986
osl::eval::ml::Promotion37::table
static CArray< MultiInt, ONE_DIM > table
Definition minorPiece.h:1735
osl::eval::ml::PtypeCombination
Definition minorPiece.h:1604
osl::eval::ml::PtypeCombination::DIM
@ DIM
Definition minorPiece.h:1606
osl::eval::ml::PtypeCombination::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:1606
osl::eval::ml::PtypeCombination::evalOne
static MultiInt evalOne(unsigned int ptypeo_mask)
Definition minorPiece.h:1611
osl::eval::ml::PtypeCombination::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:2261
osl::eval::ml::PtypeCombination::table
static CArray< MultiInt, 8192 > table
Definition minorPiece.h:1621
osl::eval::ml::PtypeCountXYAttack
Definition minorPiece.h:1510
osl::eval::ml::PtypeCountXYAttack::DIM
@ DIM
Definition minorPiece.h:1512
osl::eval::ml::PtypeCountXYAttack::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:1512
osl::eval::ml::PtypeCountXYAttack::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:1752
osl::eval::ml::PtypeCountXY
Definition minorPiece.h:1504
osl::eval::ml::PtypeCountXY::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:1710
osl::eval::ml::PtypeCountXY::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:1506
osl::eval::ml::PtypeCountXY::DIM
@ DIM
Definition minorPiece.h:1506
osl::eval::ml::PtypeCount
Definition minorPiece.h:1375
osl::eval::ml::PtypeCount::indexCountX
static int indexCountX(Ptype ptype, int count, int x)
Definition minorPiece.h:1410
osl::eval::ml::PtypeCount::indexBoardCountX
static int indexBoardCountX(Ptype ptype, int count, int x)
Definition minorPiece.h:1424
osl::eval::ml::PtypeCount::xy_attack_table
static CArray< MultiInt, 2240 > xy_attack_table
Definition minorPiece.h:1498
osl::eval::ml::PtypeCount::indexBoardCount
static int indexBoardCount(int count)
Definition minorPiece.h:1445
osl::eval::ml::PtypeCount::PtypeCountXYAttack
friend class PtypeCountXYAttack
Definition minorPiece.h:1377
osl::eval::ml::PtypeCount::evalPlayerPtype
static MultiInt evalPlayerPtype(const CArray2d< int, 2, PTYPE_SIZE > &ptype_count, const CArray2d< int, 2, PTYPE_SIZE > &ptype_board_count, const osl::CArray< int, 2 > &kings_x, const osl::CArray< int, 2 > &kings_y)
osl::eval::ml::PtypeCount::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:1701
osl::eval::ml::PtypeCount::xy_table_diff
static CArray< MultiInt, 2240 > xy_table_diff
Definition minorPiece.h:1499
osl::eval::ml::PtypeCount::indexCountY
static int indexCountY(int count, int y)
Definition minorPiece.h:1458
osl::eval::ml::PtypeCount::valueBoardAll
static MultiInt valueBoardAll(Ptype ptype, int count, int my_king_x, int my_king_y, int op_king_x, int op_king_y)
Definition minorPiece.h:1487
osl::eval::ml::PtypeCount::indexBoardCountY
static int indexBoardCountY(Ptype ptype, int count, int y)
Definition minorPiece.h:1431
osl::eval::ml::PtypeCount::DIM
@ DIM
Definition minorPiece.h:1379
osl::eval::ml::PtypeCount::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:1379
osl::eval::ml::PtypeCount::eval
static void eval(const NumEffectState &state, const CArray2d< int, 2, PTYPE_SIZE > &ptype_count, const CArray2d< int, 2, PTYPE_SIZE > &ptype_board_count, MultiInt &out)
Definition minorPiece.cc:1843
osl::eval::ml::PtypeCount::indexCountX
static int indexCountX(int count, int x)
Definition minorPiece.h:1451
osl::eval::ml::PtypeCount::indexCount
static int indexCount(Ptype ptype, int count)
Definition minorPiece.h:1398
osl::eval::ml::PtypeCount::table
static CArray< MultiInt, 160 > table
Definition minorPiece.h:1496
osl::eval::ml::PtypeCount::indexCount
static int indexCount(int count)
Definition minorPiece.h:1439
osl::eval::ml::PtypeCount::indexCountY
static int indexCountY(Ptype ptype, int count, int y)
Definition minorPiece.h:1417
osl::eval::ml::PtypeCount::PtypeCountXY
friend class PtypeCountXY
Definition minorPiece.h:1376
osl::eval::ml::PtypeCount::indexBoardCount
static int indexBoardCount(Ptype ptype, int count)
Definition minorPiece.h:1404
osl::eval::ml::PtypeCount::xy_table
static CArray< MultiInt, 2240 > xy_table
Definition minorPiece.h:1497
osl::eval::ml::PtypeCount::indexBoardCountY
static int indexBoardCountY(int count, int y)
Definition minorPiece.h:1472
osl::eval::ml::PtypeCount::evalWithUpdateBang
static void evalWithUpdateBang(const NumEffectState &state, Move last_move, CArray2d< int, 2, PTYPE_SIZE > &ptype_count, CArray2d< int, 2, PTYPE_SIZE > &ptype_board_count, MultiInt &last_value_and_out, unsigned int &ptypeo_mask)
Definition minorPiece.cc:1888
osl::eval::ml::PtypeCount::valueAll
static MultiInt valueAll(Ptype ptype, int count, int my_king_x, int my_king_y, int op_king_x, int op_king_y)
Definition minorPiece.h:1478
osl::eval::ml::PtypeCount::indexBoardCountX
static int indexBoardCountX(int count, int x)
Definition minorPiece.h:1465
osl::eval::ml::PtypeCount::xy_attack_table_diff
static CArray< MultiInt, 2240 > xy_attack_table_diff
Definition minorPiece.h:1500
osl::eval::ml::PtypeX
Definition minorPiece.h:755
osl::eval::ml::PtypeX::index
static int index(const Piece piece)
Definition minorPiece.h:765
osl::eval::ml::PtypeX::evalWithUpdate
static MultiInt evalWithUpdate(const NumEffectState &, Move moved, MultiInt const &last_value)
Definition minorPiece.cc:605
osl::eval::ml::PtypeX::setUp
static void setUp(const Weights &weights, int stage)
Definition minorPiece.cc:579
osl::eval::ml::PtypeX::index
static int index(const Player, const Ptype ptype, const Square pos)
Definition minorPiece.h:769
osl::eval::ml::PtypeX::DIM
@ DIM
Definition minorPiece.h:757
osl::eval::ml::PtypeX::table
static CArray< MultiInt, 80 > table
Definition minorPiece.h:764
osl::eval::ml::PtypeYPawnY
Definition minorPiece.h:1539
osl::eval::ml::PtypeYPawnY::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:2034
osl::eval::ml::PtypeYPawnY::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:1541
osl::eval::ml::PtypeYPawnY::DIM
@ DIM
Definition minorPiece.h:1541
osl::eval::ml::PtypeYPawnY::evalWithUpdateBang
static void evalWithUpdateBang(const NumEffectState &state, Move moved, const CArray2d< int, 2, 9 > &pawns, MultiInt &last_value)
Definition minorPiece.cc:2076
osl::eval::ml::PtypeYPawnY::index
static int index(Player player, Ptype ptype, int y, int pawn_y)
Definition minorPiece.h:1551
osl::eval::ml::PtypeYPawnY::table
static CArray< MultiInt, 1440 > table
Definition minorPiece.h:1560
osl::eval::ml::PtypeY
Definition minorPiece.h:733
osl::eval::ml::PtypeY::setUp
static void setUp(const Weights &weights, int stage)
Definition minorPiece.cc:517
osl::eval::ml::PtypeY::DIM
@ DIM
Definition minorPiece.h:735
osl::eval::ml::PtypeY::index
static int index(const Piece piece)
Definition minorPiece.h:743
osl::eval::ml::PtypeY::evalWithUpdate
static MultiInt evalWithUpdate(const NumEffectState &, Move moved, MultiInt const &last_value)
Definition minorPiece.cc:543
osl::eval::ml::PtypeY::table
static CArray< MultiInt, 144 > table
Definition minorPiece.h:742
osl::eval::ml::PtypeY::index
static int index(const Player player, const Ptype ptype, const Square pos)
Definition minorPiece.h:747
osl::eval::ml::SilverAdvance26
Definition minorPiece.h:1714
osl::eval::ml::SilverAdvance26::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:1716
osl::eval::ml::SilverAdvance26::DIM
@ DIM
Definition minorPiece.h:1716
osl::eval::ml::SilverAdvance26::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:2936
osl::eval::ml::SilverAdvance26::table
static CArray< MultiInt, ONE_DIM > table
Definition minorPiece.h:1720
osl::eval::ml::SilverFeatures
Definition minorPiece.h:540
osl::eval::ml::SilverFeatures::eval
static MultiInt eval(const NumEffectState &state)
Definition minorPiece.cc:312
osl::eval::ml::SilverFeatures::retreat_table
static CArray< MultiInt, 9 > retreat_table
Definition minorPiece.h:582
osl::eval::ml::SilverFeatures::head_table
static CArray< MultiInt, 153 > head_table
Definition minorPiece.h:581
osl::eval::ml::SilverFeatures::indexRetreat
static int indexRetreat(Square pos)
Definition minorPiece.h:545
osl::eval::ml::SilverFeatures::evalOne
static MultiInt evalOne(const NumEffectState &state, const Piece silver, const CArray< Square, 2 > &kings)
Definition minorPiece.h:553
osl::eval::ml::SilverFeatures::canRetreat
static bool canRetreat(const NumEffectState &state, const Piece silver)
Definition minorPiece.cc:335
osl::eval::ml::SilverFork
Definition minorPiece.h:1624
osl::eval::ml::SilverFork::DIM
@ DIM
Definition minorPiece.h:1632
osl::eval::ml::SilverFork::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:1632
osl::eval::ml::SilverFork::matchGold
static std::pair< int, int > matchGold(const NumEffectState &state, Piece gold, const CArray< bool, 2 > &has_silver, Square &silver_drop)
Definition minorPiece.cc:2333
osl::eval::ml::SilverFork::matchRook
static std::pair< int, int > matchRook(const NumEffectState &state, Piece rook, const CArray< bool, 2 > &has_silver, Square &silver_drop)
Definition minorPiece.cc:2303
osl::eval::ml::SilverFork::table
static CArray< MultiInt, ONE_DIM > table
Definition minorPiece.h:1636
osl::eval::ml::SilverFork::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:2432
osl::eval::ml::SilverHeadPawnKingRelative
Definition minorPiece.h:586
osl::eval::ml::SilverHeadPawnKingRelative::setUp
static void setUp(const Weights &weights)
Definition minorPiece.cc:302
osl::eval::ml::SilverHeadPawnKingRelative::DIM
@ DIM
Definition minorPiece.h:588
osl::eval::ml::SilverHeadPawnKingRelative::ONE_DIM
@ ONE_DIM
Definition minorPiece.h:588
osl::eval::ml::SilverRetreat
Definition minorPiece.h:593
osl::eval::ml::SilverRetreat::setUp
static void setUp(const Weights &weights, int stage)
Definition minorPiece.cc:361
osl::eval::ml::SilverRetreat::DIM
@ DIM
Definition minorPiece.h:595
evalStagePair.h
midgame.h
osl::eval::ml
Definition eval_pieceStand.cc:470
osl::eval
Definition eval_pieceStand.cc:468
osl
Definition additionalEffect.h:6
osl::Ptype
Ptype
駒の種類を4ビットでコード化する
Definition basic_type.h:84
osl::PPAWN
@ PPAWN
Definition basic_type.h:87
osl::PAWN
@ PAWN
Definition basic_type.h:95
osl::KING
@ KING
Definition basic_type.h:93
osl::KNIGHT
@ KNIGHT
Definition basic_type.h:97
osl::PTYPE_EMPTY
@ PTYPE_EMPTY
Definition basic_type.h:85
osl::LANCE
@ LANCE
Definition basic_type.h:96
osl::Ptype_Table
const PtypeTable Ptype_Table
Definition tables.cc:97
osl::CArray2d
CArray< CArray< T, Capacity2 >, Capacity1 > CArray2d
Definition container.h:95
osl::PTYPE_SIZE
const int PTYPE_SIZE
Definition basic_type.h:107
osl::getPtype
Ptype getPtype(PtypeO ptypeO)
Definition basic_type.h:217
osl::MultiIntPair
QuadIntPair MultiIntPair
Definition midgame.h:14
osl::unpromote
Ptype unpromote(Ptype ptype)
ptypeがpromote後の型の時に，promote前の型を返す． promoteしていない型の時はそのまま返す
Definition basic_type.h:157
osl::playerToIndex
constexpr int playerToIndex(Player player)
Definition basic_type.h:16
osl::Board_Table
const BoardTable Board_Table
Definition tables.cc:95
osl::getOwner
Player getOwner(PtypeO ptypeO)
Definition basic_type.h:256
osl::UUR
@ UUR
Definition basic_type.h:323
osl::UUL
@ UUL
Definition basic_type.h:322
osl::U
@ U
Definition basic_type.h:314
osl::isPromoted
bool isPromoted(Ptype ptype)
ptypeがpromote後の型かどうかのチェック
Definition basic_type.h:137
osl::MultiInt
QuadInt MultiInt
Definition midgame.h:13
osl::Player
Player
Definition basic_type.h:8
osl::WHITE
@ WHITE
Definition basic_type.h:10
osl::BLACK
@ BLACK
Definition basic_type.h:9
osl::PtypeO
PtypeO
Player + Ptype [-15, 15] PtypeO の O は Owner の O.
Definition basic_type.h:199
osl::PTYPEO_MIN
@ PTYPEO_MIN
Definition basic_type.h:200
osl::EvalStages
const int EvalStages
Definition midgame.h:12
osl::alt
constexpr Player alt(Player player)
Definition basic_type.h:13
osl::altIfPiece
PtypeO altIfPiece(PtypeO ptypeO)
Pieceの時にはowner を反転する
Definition basic_type.h:281
osl::captured
PtypeO captured(PtypeO ptypeO)
unpromoteすると共に，ownerを反転する．
Definition basic_type.h:264
numEffectState.h
osl::DirectionPlayerTraits
Definition directionTraits.h:242
osl::PtypeTraits
Definition ptypeTraits.h:12
osl::eval::ml::PawnAdvanceAll
Definition minorPiece.h:519
osl::eval::ml::PawnAdvanceAll::evalWithUpdateBang
static void evalWithUpdateBang(const NumEffectState &state, Move moved, MultiInt &last_value)
Definition minorPiece.cc:253
osl::eval::ml::PawnAdvanceAll::adjust
static void adjust(int index, MultiInt &values)
Definition minorPiece.cc:243
osl::eval::ml::PawnAdvanceUtil
Definition minorPiece.h:500
osl::eval::ml::PawnAdvanceUtil::cantAdvance
static bool cantAdvance(const NumEffectState &state, const Piece pawn)
Definition minorPiece.h:505
osl::eval::ml::PawnAdvanceUtil::index
static int index(Player P, Square pos)
Definition minorPiece.h:501
osl::eval::ml::PawnAdvanceUtil::cantAdvance
static bool cantAdvance(const NumEffectState &state, const PtypeO ptypeO, const Square position)
Definition minorPiece.h:509
osl::eval::ml::Weights
Definition weights.h:18
weights.h