void GameLogic::updateMoveList_() {
Command command;
for (int idx = 0; idx <= 1; idx++) {
moveList_[idx].clear();
Coordinate currentHeadCoord = worldModel_.players[idx].body.back();
Coordinate nextHeadCoord = getUpdatedHeadPosition(currentHeadCoord, Direction::UP);
if (isValidCoordinate(nextHeadCoord) &&
field_[nextHeadCoord.x][nextHeadCoord.y] == kEmpty) {
command.direction = Direction::UP;
moveList_[idx].push_back(command);
}
nextHeadCoord = getUpdatedHeadPosition(currentHeadCoord, Direction::DOWN);
if (isValidCoordinate(nextHeadCoord) &&
field_[nextHeadCoord.x][nextHeadCoord.y] == kEmpty) {
command.direction = Direction::DOWN;
moveList_[idx].push_back(command);
}
nextHeadCoord = getUpdatedHeadPosition(currentHeadCoord, Direction::LEFT);
if (isValidCoordinate(nextHeadCoord) &&
field_[nextHeadCoord.x][nextHeadCoord.y] == kEmpty) {
command.direction = Direction::LEFT;
moveList_[idx].push_back(command);
}
nextHeadCoord = getUpdatedHeadPosition(currentHeadCoord, Direction::RIGHT);
if (isValidCoordinate(nextHeadCoord) &&
field_[nextHeadCoord.x][nextHeadCoord.y] == kEmpty) {
command.direction = Direction::RIGHT;
moveList_[idx].push_back(command);
}
}
}
std::vector<Node *> Path::loadKernel()
{
std::vector<Node *> candidates;
if(currentNode == NULL)
return candidates;
int x = currentNode->x;
int y = currentNode->y;
int r,g,b;
int offset = kernelSize / 2;
int ki,kj;
ki = kj = 0;
for(int i=y-offset, ki=0; i<y+offset+1; ++i, ki++)
{
for(int j=x-offset, kj=0; j<x+offset+1; ++j, kj++)
{
kernel->setPixel(ki,kj,0,0,0);
if(isValidCoordinate(img, i,j))
{
img->getPixel(i,j,r,g,b);
if(getNode(i,j) != NULL && !getNode(i,j)->visited)
{
candidates.push_back(getNode(i,j));
}
}
}
}
return candidates;
}
bool GameLogic::update(Command command, int32_t playerId) {
size_t idx = 0;
if(playerId == player1_){
idx = 0;
}
else if(playerId == player2_){
idx = 1;
}
else {
return false;
}
Coordinate nextHeadPosition = getUpdatedHeadPosition(
worldModel_.players[idx].body.back(), command.direction);
worldModel_.players[idx].body.push_back(nextHeadPosition);
if (isValidCoordinate(nextHeadPosition) &&
field_[nextHeadPosition.x][nextHeadPosition.y] == kEmpty) {
field_[nextHeadPosition.x][nextHeadPosition.y] = playerId;
}
else {
if (winner_ == std::to_string(kNoWinner)) {
winner_ = (player1_ == playerId) ? std::to_string(player2_) : std::to_string(player1_);
}
else {
winner_ = std::to_string(kNoWinner); // tie
}
hasFinished_ = true;
}
return true;
}
void Grid::drawVerticalLines(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *) const {
QVector<QLineF> lines;
for (int x = minimalXCoordinate(); x <= maximalXCoordinate(); x++) {
bool started = false;
int startY;
for (int y = minimalYCoordinate(x); y <= maximalYCoordinate(x); y++) {
if (!started && isValidCoordinate(x, y)) {
started = true;
startY = y;
}
if (started && !isValidCoordinate(x, y + 1)) {
started = false;
lines.push_back(QLineF(getFieldPosition(x, startY), getFieldPosition(x, y)));
}
}
}
painter->drawLines(lines);
}
void Grid::drawRightDiagonalLines(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *) const {
QVector<QLineF> lines;
for (int sum = minimalXCoordinate() + minimalYCoordinate(); sum < maximalXCoordinate() + maximalYCoordinate(); sum++) {
bool started = false;
int startX;
for (int x = minimalXCoordinate(); x <= maximalXCoordinate(); x++) {
if (!started && isValidCoordinate(x, sum -x)) {
started = true;
startX = x;
}
if (started && !isValidCoordinate(x + 1, sum - x - 1)) {
started = false;
QPointF startPoint = getFieldPosition(startX, sum - startX);
QPointF endPoint = getFieldPosition(x, sum - x);
lines.push_back(QLineF(startPoint, endPoint));
}
}
}
painter->drawLines(lines);
}
void Grid::drawHandicapSpots(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *) const {
painter->setBrush(Qt::black);
QList<QPair<int,int> > points = getHandicapCoordinates();
QPair<int, int> point;
foreach(point, points)
{
if (isValidCoordinate(point.first, point.second))
painter->drawEllipse(getFieldPosition(point.first, point.second),
s_handicapSpotRadius , s_handicapSpotRadius);
}
}
void Grid::drawFieldsShape(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) const {
QTransform transform = painter->transform();
for (int x = minimalXCoordinate(); x <= maximalXCoordinate(); x++) {
for (int y = minimalYCoordinate(x); y <= maximalYCoordinate(x); y++) {
if (isValidCoordinate(x, y)) {
painter->setTransform(transform);
painter->translate(getFieldPosition(x, y));
painter->drawPath(getPath());
}
}
}
}
int Bot::evaluateCell(const Point& p) const {
int mark = 1;
Point p2 = neighboringBurningCell(p);
Point next = getCellOfLine(p, p2);
Point saver = p;
while (isValidCoordinate(next, desk_)) {
if (visibleOrSunksNeighbor(next)) {
break;
}
p2 = saver;
saver = next;
next = getCellOfLine(saver, p2);
mark++;
}
return mark;
}
bool allNeighborsWhite(ENapi::Image *img, int y, int x, int area)
{
int r,g,b;
int offset = area / 2;
for(int i=y-offset; i<y+offset+1; ++i)
{
for(int j=x-offset; j<x+offset+1; ++j)
{
if(isValidCoordinate(img, i,j))
{
img->getPixel(i,j,r,g,b);
if(r != 255)
return false;
}
}
}
return true;
}
void COMMAND_INFO() {
int x, y;
do {
printf("Enter the coordinate of the cell: ");
scanf("%d %d", &x, &y);
} while (!isValidCoordinate(x, y));
Grid *grid = GetGrid(MakePOINT(x, y));
Type type = GetType(*grid);
Player *gridOwner = GetOwner(*grid);
Unit *unit = GetUnit(*grid);
printf("== Cell Info ==\n");
if (type == Normal) {
printf("Normal\n");
} else if (type == Tower) {
printf("Tower\n");
} else if (type == Castle) {
printf("Castle\n");
} else if (type == Village) {
printf("Village\n");
}
printf("Owned by Player %d\n", GetPlayerIndex(*gridOwner));
if (unit) {
Player *unitOwner = GetPlayerFromColor(GetUnitColor(*unit));
char unitClassName[11];
UnitClassName(GetUnitClass(*unit), unitClassName);
printf("== Unit Info ==\n");
printf("%s\n", unitClassName);
printf("Owned by Player %d\n", GetPlayerIndex(*unitOwner));
printf("Health %d/%d | ATK %d\n",
GetHealth(*unit),
GetMaximumHealth(*unit),
GetAttack(*unit)
);
}
printf("\n");
}
