void DynProgProb::update () // updates dynamic prog probs
{
assert (getValueFct ());
assert (getDimInputProb ());
assert (getInputProb ());
const size_t ARRAY_FAC = 2;
assert (1 < ARRAY_FAC);
Int4 i = 0;
size_t j = 0;
const double *oldArray = 0;
double *array = 0;
Int4 value = 0;
Int4 valueBegin = 0;
Int4 valueLower = 0;
Int4 valueUpper = 0;
size_t arrayPos = 0;
oldArray = d_array_p [d_step % 2];
array = d_array_p [(d_step + 1) % 2];
valueLower = kMax_I4;
valueUpper = kMin_I4;
MemUtil::memZero (array, sizeof (double) * getArrayCapacity ());
for (i = getValueLower (); i < getValueUpper (); i++)
{
if (oldArray [getArrayPos (i)] == 0.0) continue;
for (j = 0; j < getDimInputProb (); j++)
{
if (getInputProb () [j] == 0.0) continue;
// adjust the reserve, if necessary
value = getValueFct () (i, j);
while (value < getValueBegin () || getValueEnd () <= value) {
valueBegin = getValueBegin ();
if (value < getValueBegin ()) valueBegin -= (ARRAY_FAC - 1) * getArrayCapacity ();
reserve (ARRAY_FAC * getArrayCapacity ());
setValueBegin (valueBegin);
oldArray = d_array_p [d_step % 2];
array = d_array_p [(d_step + 1) % 2];
}
if (value < valueLower) valueLower = value;
if (valueUpper < value) valueUpper = value;
// add the probability
assert (getValueBegin () <= i);
assert (i < getValueEnd ());
array [getArrayPos (value)] += oldArray [getArrayPos (i)] * getInputProb () [j];
}
}
d_valueLower = valueLower;
d_valueUpper = valueUpper + 1;
d_step++;
}
void DynProgProbLim::update () // updates dynamic prog probs
{
assert (getValueFct ());
assert (getDimInputProb ());
assert (getInputProb ());
assert (0 < getArrayCapacity ());
Int4 i = 0;
size_t j = 0;
const double *oldArray = 0;
double *array = 0;
Int4 value = 0;
Int4 valueLower = 0;
Int4 valueUpper = 0;
size_t arrayPos = 0;
double prob = 0.0;
oldArray = getArray () [getStep () % 2];
array = lgetArray () [(getStep () + 1) % 2];
valueLower = kMax_I4;
valueUpper = kMin_I4;
MemUtil::memZero (array, sizeof (double) * getArrayCapacity ());
for (i = getValueLower (); i < getValueUpper (); i++)
{
if (oldArray [getArrayPos (i)] == 0.0) continue;
for (j = 0; j < getDimInputProb (); j++)
{
if (getInputProb () [j] == 0.0) continue;
value = getValueFct () (i, j);
prob = oldArray [getArrayPos (i)] * getInputProb () [j];
if (value < getValueBegin () || getValueEnd () <= value)
{
d_probLost += prob;
}
else
{
if (value < valueLower) valueLower = value;
if (valueUpper < value) valueUpper = value;
// add the probability
assert (getValueBegin () <= i);
assert (i < getValueEnd ());
array [getArrayPos (value)] += prob;
}
}
}
lgetValueLower () = valueLower;
lgetValueUpper () = valueUpper + 1;
lgetStep ()++;
}
std::vector<sf::Vector2i> Pawn::validPositions(const InternalBoard &board) {
std::vector<sf::Vector2i> valid_positions = std::vector<sf::Vector2i> {};
/*
* Gambiarra para lidar com a promoção pra rainha
*
*/
// crise de identidade
if (maskGetType(type) == QUEEN) {
// se eu sou uma rainha então se comporte como uma rainha
return Queen::getPositions(board_pos.x, board_pos.y, type, board);
}
int modifier = type[0] ? -1 : 1;
auto x = board_pos.x;
auto y = board_pos.y;
if (!board[getArrayPos(x, y + modifier)]->getPiece()) { // se não tem nenhuma peça minha frente
if (y != 8) {
valid_positions.push_back(sf::Vector2i{x, y + modifier});
}
if (y <= 6) {
valid_positions.push_back(
sf::Vector2i{x, y + (modifier) * (first_move ? 2 : 1)/*Primeira jogada*/});
}
}
//diagonal esquerda
if (x > 0) {
Piece *target = board[getArrayPos(x - 1, y + modifier)]->getPiece();
if (target && target->getType()[0] != type[0]) {
// emplace back faz perfect forwarding direto pra dentro do container
valid_positions.emplace_back(x - 1, y + modifier);
}
}
//diagonal direita
if (x < 7) {
Piece *target = board[getArrayPos(x + 1, y + modifier)]->getPiece();
if (target && target->getType()[0] != type[0]) {
valid_positions.emplace_back(x + 1, y + modifier);
}
}
return valid_positions;
}
std::vector<sf::Vector2i> Piece::computeOffsetPositions(const InternalBoard &board, const sf::Vector2i &board_pos,
const PieceType &type,
std::array<std::array<int, 2>, 8> &offsets) {
auto valid = std::vector<sf::Vector2i>();
for (auto i: offsets) {
// garante que eu não passe dos limites
// das bordas
int x = i[0] + board_pos.x;
int y = i[1] + board_pos.y;
// pula posições inválidas
if (x < 0 || x > 7 || y < 0 || y > 7) {
continue;
}
Piece *piece = board[getArrayPos(x, y)]->getPiece();
if (piece) {
if (piece->getType()[0] != type[0]) {// se a peça contida aqui for inimiga é uma posição válida
valid.push_back(sf::Vector2i{x, y});
}
} else {
valid.push_back(sf::Vector2i{x, y});
}
}
return valid;
}
std::vector<sf::Vector2i> Bishop::getPositions(int x, int y, PieceType type, const InternalBoard &board) {
auto valid = std::vector<sf::Vector2i> {};
//lambdas \o/
auto valid_pos = [&type, &valid, &board](int j, int i) -> bool {
Piece *piece = board[getArrayPos(j, i)]->getPiece();
if (!piece) {
valid.push_back(sf::Vector2i{j, i});
return false; // não da break ainda
} else if (piece->getType()[0] != type[0]) {
valid.push_back(sf::Vector2i{j, i});
return true; // da break
} else {
return true; // da break
}
};
//diagonal positiva pra baixo
for (int j = x + 1, i = y + 1; j < 8 && i < 8; j++, i++) {
if (valid_pos(j, i)) {
break;
}
}
// diagonal positiva pra cima
for (int j = x - 1, i = y + 1; j > -1 && i < 8; j--, i++) {
if (valid_pos(j, i)) {
break;
}
}
//diagonal negativa pra cima
for (int j = x - 1, i = y - 1; j > -1 && i > -1; j--, i--) {
if (valid_pos(j, i)) {
break;
}
}
//diagonal positiva pra baixo
for (int j = x + 1, i = y - 1; j < 8 && i > -1; j++, i--) {
if (valid_pos(j, i)) {
break;
}
}
return valid;
}
std::vector<sf::Vector2i> Rook::getPositions(int x, int y, PieceType type, const InternalBoard &board) {
auto valid = std::vector<sf::Vector2i> {};
//esse algoritmo pode ser simplificado
// frente
//lambdas \o/
auto valid_pos = [&type, &valid, &board](int j, int i) -> bool {
Piece *piece = board[getArrayPos(j, i)]->getPiece();
if (!piece) {
valid.push_back(sf::Vector2i{j, i});
return false; // não da break ainda
} else if (piece->getType()[0] != type[0]) {
valid.push_back(sf::Vector2i{j, i});
return true; // da break
} else {
return true; // da break
}
};
for (int i = 1; i < 8; ++i) { // um passinho pra frente...
auto y1 = (y + i) > 7 ? 7 : (y + i); // verifica que eu não passei das bordas
if (valid_pos(x, y1)) break;
}
for (int i = 1; i < 8; ++i) { // um passinho pra trás...
auto y1 = (y - i) < 0 ? 0 : y - i;
if (valid_pos(x, y1)) break;
}
for (int i = 1; i < 8; ++i) { // girando, girando, girando pro lado
auto x1 = (x - i) < 0 ? 0 : x - i;
if (valid_pos(x1, y)) break;
}
for (int i = 1; i < 8; ++i) { // girando, girando, girando pro outro
auto x1 = (x + i) > 7 ? 7 : x + i;
if (valid_pos(x1, y)) break;
}
return valid;
}
bool nspArrayAppendArray(nsp_node *nn,nsp_node *arr) {
if(nn==NULL || nn->node_type!=NSP_NODE_MAP) {
return false;
}
int p=getArrayPos(nn);
if(p<0) {
return false;
}
nsp_node *k = nspCreateInt(p);
if(k==NULL) {
return false;
}
nsp_node *v = arr;
if(nspArrayAppendMap(nn,k,v)) {
return true;
}
return false;
}
bool nspArrayAppendString(nsp_node *nn,char *str) {
if(nn==NULL || nn->node_type!=NSP_NODE_MAP) {
return false;
}
int p=getArrayPos(nn);
if(p<0) {
return false;
}
nsp_node *k = nspCreateInt(p);
if(k==NULL) {
return false;
}
nsp_node *v = nspCreateString(str);
if(v==NULL) {
nsp_free_node(k);
return false;
}
if(nspArrayAppendMap(nn,k,v)) {
return true;
}
return false;
}
bool nspArrayAppendDouble(nsp_node *nn,double d) {
if(nn==NULL || nn->node_type!=NSP_NODE_MAP) {
return false;
}
int p=getArrayPos(nn);
if(p<0) {
return false;
}
nsp_node *k = nspCreateInt(p);
if(k==NULL) {
return false;
}
nsp_node *v = nspCreateDouble(d);
if(v==NULL) {
nsp_free_node(k);
return false;
}
if(nspArrayAppendMap(nn,k,v)) {
return true;
}
return false;
}
void DynProgProb::clear ( // initializes the "probabilities" with non-negative weights
Int4 valueLower_, // lower Int4 value corresponding to the "probability" array
Int4 valueUpper_, // one beyond present upper Int4 value corresponding to the "probability" array
const double *prob_) // "probabilities" prob [valueLower_, valueUpper_) corresponding to the Int4s
{
assert ((! prob_ && valueLower_ <= 0 && 0 <= valueUpper_) ||
(prob_ && valueLower_ < valueUpper_));
if (prob_)
{
for (size_t i = 0; i < static_cast <size_t> (valueUpper_ - valueLower_); i++)
{
assert (0.0 <= prob_ [i]);
}
clear (valueLower_, static_cast <size_t> (valueUpper_ - valueLower_));
d_valueLower = valueLower_;
d_valueUpper = valueUpper_;
MemUtil::memCpy (d_array_p [0], prob_, sizeof (double) * getArrayCapacity ());
return;
}
if (valueLower_ == 0 && valueUpper_ == 0)
{
clear (-static_cast <Int4> (ARRAY_CAPACITY / 2) + 1, ARRAY_CAPACITY);
}
else
{
clear (valueLower_, static_cast <size_t> (valueUpper_ - valueLower_));
}
d_valueLower = 0;
d_valueUpper = 1;
d_array_p [0][getArrayPos (0)] = 1.0;
return;
}
