AlgorithmConfig* FireworksConfig::createAlgorithmConfig(ParseBlock& block)
{
AlgorithmConfig *c_ = new FireworksConfig;
FireworksConfig *c = dynamic_cast<FireworksConfig *>(c_);
Checker *check = getChecker();
init();
try {
block.checkUsing(check);
c->init(block);
c->am = block("am").as<int>();
c->bm = block("bm").as<int>();
c->m = block("m").as<int>();
c->mm = block("mm").as<int>();
if (block.hasProperty("amplitude_mult")) {
c->amplitude_mult = block("amplitude_mult").as<double>();
}
if (block.hasProperty("A_min")) {
c->A_min = block("A_min").as<double>();
}
if (block.hasProperty("new_mapping")) {
c->new_mapping = block("new_mapping").as<bool>();
}if (block.hasProperty("efwa_selection")) {
c->efwa_selection = block("efwa_selection").as<bool>();
}
} catch (std::runtime_error &e) {
std::cerr << "SwarmConfig::init() --> error while loading data from block. Content: " << e.what() << std::endl;
throw(e);
}
delete check;
return c_;
}
bool BaseAI::startTurn()
{
static bool initialized = false;
int count = 0;
count = getPlayerCount(c);
players.clear();
players.resize(count);
for(int i = 0; i < count; i++)
{
players[i] = Player(getPlayer(c, i));
}
count = getCheckerCount(c);
checkers.clear();
checkers.resize(count);
for(int i = 0; i < count; i++)
{
checkers[i] = Checker(getChecker(c, i));
}
if(!initialized)
{
initialized = true;
init();
}
return run();
}
bool CheckerBoard::isSimpleKillTurn(BoardCoord oldCoord, BoardCoord newCoord)
{
if(isChecker(newCoord)) return false;
boost::shared_ptr<Checker> current = getChecker(oldCoord);
int dY = newCoord.y-oldCoord.y;
int dX = newCoord.x-oldCoord.x;
int possible_dY;
if(!(((dX == -2)||(dX == 2))&&(((dY == -2)||(dY == 2))))) return false;
int enemyPos_X = (newCoord.x+oldCoord.x)/2;
int enemyPos_Y = (newCoord.y+oldCoord.y)/2;
if(!isChecker(BoardCoord(enemyPos_X,enemyPos_Y))) return false;
boost::shared_ptr<Checker> enemy = getChecker(BoardCoord(enemyPos_X, enemyPos_Y));
if(enemy->getColor() != getOppositeColor(current->getColor())) return false;
return true;
}
bool CheckerBoard::isQueenKillTurn(BoardCoord oldCoord, BoardCoord newCoord)
{
if(isChecker(newCoord)) return false;
if(!oldCoord.isValid()||!newCoord.isValid()) return false;
int dY = m_abs(newCoord.y-oldCoord.y);
int dX = m_abs(newCoord.x-oldCoord.x);
int sign_dX = m_sign(newCoord.x-oldCoord.x);
int sign_dY = m_sign(newCoord.y-oldCoord.y);
if(dX != dY) return false;
int x = oldCoord.x;
int y = oldCoord.y;
boost::shared_ptr<Checker> active = getChecker(oldCoord);
boost::shared_ptr<Checker> current;
int countEnemy = 0;
for(int i=1; i < dX; ++i)
{
if(isChecker(BoardCoord::convertToBoardCoord(x+i*sign_dX, y+i*sign_dY)))
{
std::cout<<"isChecker"<<x+i<<";"<<y+i<<std::endl;
current = getChecker(BoardCoord::convertToBoardCoord(x+i*sign_dX, y+i*sign_dY));
if(current->getColor() != active->getColor())
countEnemy++;
else
return false;
}
}
if(countEnemy != 1)
return false;
return true;
}
void GeneticConfig::init(ParseBlock& block)
{
Checker *check = getChecker();
init();
try {
block.checkUsing(check);
resolution::CostConfig::init(block);
if (block.hasProperty("initializer_type")) {
initializer_type = block("initializer_type").value;
}
if (block.hasProperty("crossover_type")) {
crossover_type = block("crossover_type").as<string>();
}
if (block.hasProperty("custom_evolution")) {
custom_evolution = block("custom_evolution").as<bool>();
}
if (block.hasProperty("mutator_type")) {
mutator_type = block("mutator_type").as<string>();
}
if (block.hasProperty("search_ratio")) {
search_ratio = block("search_ratio").as<double>();
}
if (block.hasProperty("max_checks")) {
max_checks = block("max_checks").as<int>();
}
if (block.hasProperty("mutation_probability")) {
pMutation = block("mutation_probability").as<double>();
}
if (block.hasProperty("mutation_deviation")) {
mutation_dev = block("mutation_deviation").as<double>();
}
if (block.hasProperty("crossover_probability")) {
pCrossover = block("crossover_probability").as<double>();
}
} catch (std::exception &e) {
std::cerr << "GeneticConfig::init() --> error while loading data from block\n";
throw(e);
}
delete check;
}
bool CheckerBoard::moveChecker(const BoardCoord oldPos, const BoardCoord newPos)
{
boost::shared_ptr<Checker> activeChecker = getChecker(oldPos);
if( (newPos.y == 0)&&(activeChecker->getColor() == Checker::WHITE) )
activeChecker->makeQueen();
if( (newPos.y == 7)&&(activeChecker->getColor() == Checker::BLACK) )
activeChecker->makeQueen();
activeChecker->setSpritePosition(newPos);
m_board[newPos.x][newPos.y].ptrChecker.swap(activeChecker);
m_board[oldPos.x][oldPos.y].status = BoardPiece::FREE;
m_board[newPos.x][newPos.y].status = BoardPiece::OCCUPIED;
}
bool CheckerBoard::isThereRequiredTurns(Checker::Color playerColor)
{
for(int i = 0; i < m_board.size(); ++i)
for(int j = 0; j < m_board.size(); ++j)
{
if(isChecker(BoardCoord(i,j)))
{
if(getChecker(BoardCoord(i,j))->getColor() == playerColor)
{
if(isThereRequerdTurnForChecker(BoardCoord(i,j)))
return true;
}
}
}
return false;
}
CheckerBoard::TurnType CheckerBoard::getTurnType(BoardCoord oldCoord, BoardCoord newCoord)
{
if(!(oldCoord.isValid()&&(newCoord.isValid()))) return INVALID_TURN;
if( (newCoord.x + newCoord.y) % 2 != 1) return INVALID_TURN;
if(m_board[newCoord.x][newCoord.y].status == BoardPiece::OCCUPIED ) return INVALID_TURN;
boost::shared_ptr<Checker> active = getChecker(oldCoord);
if(isThereRequiredTurns(active->getColor()))
{
if(active->getType() == Checker::SIMPLE)
{
if(isSimpleKillTurn(oldCoord, newCoord))
return SIMPLE_KILL_TURN;
}
if(active->getType() == Checker::QUEEN)
{
if(isQueenKillTurn(oldCoord, newCoord))
return QUEEN_KILL_TURN;
}
return INVALID_TURN;
}
else
{
if(active->getType() == Checker::SIMPLE)
{
if(isSimpleTurn(oldCoord, newCoord))
return SIMPLE_TURN;
}
if(active->getType() == Checker::QUEEN)
{
if(isQueenTurn(oldCoord, newCoord))
return QUEEN_TURN;
}
}
return INVALID_TURN;
}
int main (int argc, char **argv)
{
int result = 0;
checkersCache.push_back (new ServiceChecker);
checkersCache.push_back (new ProcessChecker);
AbstractChecker *checker = getChecker (argc, argv);
if (checker) {
result = checker->check (argc, argv);
std::cout << checker->lastError() << std::endl;
}
deleteAll (checkersCache);
return result;
}
void ThermalModelSimple::init(ParseBlock &b) {
Checker *check = getChecker();
try {
b.checkUsing(check);
// Get updraft info
ParseBlock::Blocks *updrafts = b.getBlocks("updraft");
updraft_vector.clear();
ParseBlock::Blocks::iterator it = updrafts->begin();
for ( ; it != updrafts->end(); it++) {
Updraft aux(**it);
updraft_vector.push_back(aux);
}
} catch (exception &e) {
cerr << "ThermalModelSimple::ThermalModelSimple --> Error: could not load the data.\n";
throw(e);
}
delete check;
}
bool CheckerBoard::isThereRequerdTurnForChecker(BoardCoord oldCoord)
{
if(!isChecker(oldCoord)) return false;
if(getChecker(oldCoord)->getType() == Checker::SIMPLE)
{
boost::array<boost::array<int, 2>, 4> dXdY;
dXdY[0][0] = 2; dXdY[0][1] = 2;
dXdY[1][0] = -2; dXdY[1][1] = -2;
dXdY[2][0] = -2; dXdY[2][1] = 2;
dXdY[3][0] = 2; dXdY[3][1] = -2;
int x = oldCoord.x;
int y = oldCoord.y;
BoardCoord newCoord;
for(int i=0; i<dXdY.size(); ++i)
{
newCoord = BoardCoord(x + dXdY[i][0], y + dXdY[i][1]);
if(newCoord.isValid())
{
if(isSimpleKillTurn(oldCoord, newCoord))
{
return true;
}
}
}
}
if(getChecker(oldCoord)->getType() == Checker::QUEEN)
{
std::cout<<"QUEEN"<<std::endl;
boost::array<boost::array<int, 2>, 4> dXdY;
dXdY[0][0] = 1; dXdY[0][1] = 1;
dXdY[1][0] = -1; dXdY[1][1] = -1;
dXdY[2][0] = -1; dXdY[2][1] = 1;
dXdY[3][0] = 1; dXdY[3][1] = -1;
Checker::Color playerColor = getChecker(oldCoord)->getColor();
for(int i=0; i<dXdY.size(); ++i)
{
bool enemy = false;
int x = oldCoord.x;
int y = oldCoord.y;
x += dXdY[i][0];
y += dXdY[i][1];
BoardCoord newCoord(x,y);
while(newCoord.isValid())
{
if(isChecker(newCoord))
{
if((getChecker(newCoord)->getColor() == playerColor)||enemy)
{
enemy = false;
break;
}
else
enemy = true;
}
else
{
if(enemy)
{
return true;
}
}
newCoord.x += dXdY[i][0];
newCoord.y += dXdY[i][1];
}
}
}
return false;
}
