void STG::deletePatterns()
{
std::list<Pattern*>* active_patterns=player->active_patterns;
std::list<Pattern*>::iterator i = active_patterns->begin();
while (i != active_patterns->end())
{
Pattern*p=(Pattern*)*i;
if (isOutOfBounds(p->x,p->y) || p->destroyFlag())
{
active_patterns->erase(i++);
delete p;
}
else
{
++i;
}
}
active_patterns=enemy->active_patterns;
i = active_patterns->begin();
while (i != active_patterns->end())
{
Pattern*p=(Pattern*)*i;
if (isOutOfBounds(p->x,p->y) || p->destroyFlag())
{
active_patterns->erase(i++);
delete p;
}
else
{
++i;
}
}
}
void LedMatrixMAX7219Driver::setRow(unsigned char row, unsigned char value) {
if (!isOutOfBounds(0, row)) {
for (unsigned char i = 0; i < rows; i++) {
setLed(row, i, value);
}
}
}
static void setBit(const char *offsetStr, const char *bitStr, const char *valueStr) {
int offset = atoi(offsetStr);
if (absI(offset) == absI(ERROR_CODE)) {
scheduleMsg(&logger, "invalid offset [%s]", offsetStr);
return;
}
if (isOutOfBounds(offset)) {
return;
}
int bit = atoi(bitStr);
if (absI(bit) == absI(ERROR_CODE)) {
scheduleMsg(&logger, "invalid bit [%s]", bitStr);
return;
}
int value = atoi(valueStr);
if (absI(value) == absI(ERROR_CODE)) {
scheduleMsg(&logger, "invalid value [%s]", valueStr);
return;
}
int *ptr = (int *) (&((char *) engineConfiguration)[offset]);
*ptr ^= (-value ^ *ptr) & (1 << bit);
/**
* this response is part of dev console API
*/
scheduleMsg(&logger, "bit @%d/%d is %d", offset, bit, value);
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F);
}
/// <summary>
/// Processes the bullet
/// </summary>
void Bullet::process()
{
// Checks if its deleted
if (!getDeleted())
{
// If degrees is set (not -1), do rotational movement
if (deg != -1) // Rotational movement
{
double move_x = timeStep.asSeconds() * speedX * cos(deg) - sin(deg);
double move_y = timeStep.asSeconds() * speedY * sin(deg) + cos(deg);
this->sprite->move(move_x, move_y);
}
else // Linear movement.
{
this->sprite->setPosition(
sprite->getPosition().x + (timeStep.asSeconds() * speedX),
sprite->getPosition().y + (timeStep.asSeconds() * speedY));
}
// If the bullet is out of bounds, we set delete flag
if (isOutOfBounds())
{
setDeleted(true);
}
}
}
void LedMatrixMAX7219Driver::shiftRow(unsigned char row,
unsigned char direction) {
if (!isOutOfBounds(0, row)) {
for (unsigned char i = 0; i < cols; i++) {
shiftLed(i, row, direction);
}
}
}
CrosswordCell *CrosswordGrid::getCell( const int row, const int col ) const
{
// Check bounds conditions
if( isOutOfBounds( row, col ) )
return 0;
return dynamic_cast<CrosswordCell*>( item( row, col ) );
}
static void setInt(const int offset, const int value) {
if (isOutOfBounds(offset))
return;
int *ptr = (int *) (&((char *) engineConfiguration)[offset]);
*ptr = value;
getInt(offset);
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F);
}
/*
=================================================================================================================================================================
logic() performs logical stuff on the ghost
=================================================================================================================================================================
*/
void Ghost::logic(const sf::Vector2i mousePos, const int maxWidth, const int maxHeight, const sf::RenderWindow& window)
{
xPos = mGhostRect.getPosition().x / 40; //Set a variable for y position that is relative to the "tile map" (1px = 40px)
yPos = mGhostRect.getPosition().y / 40; //Set a variable that x position is relative to the "tile map" (1px = 40px)
goToMouse(mousePos, maxWidth, maxHeight, window); //Sets the sprites position to the mouse position (if possible)
isOutOfBounds(maxWidth, maxHeight); //Checks if the ghost somehow got out of bounds :/
snapToMap(); //Snaps the ghost to the tile grid
}
static void getFloat(int offset) {
if (isOutOfBounds(offset))
return;
float *ptr = (float *) (&((char *) engineConfiguration)[offset]);
float value = *ptr;
/**
* this response is part of dev console API
*/
scheduleMsg(&logger, "float @%d is %..100000f", offset, value);
}
static void getBit(int offset, int bit) {
if (isOutOfBounds(offset))
return;
int *ptr = (int *) (&((char *) engineConfiguration)[offset]);
int value = (*ptr >> bit) & 1;
/**
* this response is part of dev console API
*/
scheduleMsg(&logger, "bit @%d/%d is %d", offset, bit, value);
}
static void getShort(int offset) {
if (isOutOfBounds(offset))
return;
uint16_t *ptr = (uint16_t *) (&((char *) engineConfiguration)[offset]);
uint16_t value = *ptr;
/**
* this response is part of dev console API
*/
scheduleMsg(&logger, "short @%d is %d", offset, value);
}
/* Checks if direction is OK for moving (no collision, stc.) */
int dbDirSucceeded(t_Direction dir)
{
switch(dir)
{
case DIR_UP:
return (isCollision( currentLevel.DrunkenBots[0].posX,
currentLevel.DrunkenBots[0].posY-STEP) |
isOutOfBounds(currentLevel.DrunkenBots[0].posX,
currentLevel.DrunkenBots[0].posY-STEP)) ?
0 : 1;
break;
case DIR_RIGHT:
return (isCollision( currentLevel.DrunkenBots[0].posX+STEP,
currentLevel.DrunkenBots[0].posY) |
isOutOfBounds(currentLevel.DrunkenBots[0].posX+STEP,
currentLevel.DrunkenBots[0].posY)) ?
0 : 1;
break;
case DIR_DOWN:
return (isCollision( currentLevel.DrunkenBots[0].posX,
currentLevel.DrunkenBots[0].posY+STEP) |
isOutOfBounds(currentLevel.DrunkenBots[0].posX,
currentLevel.DrunkenBots[0].posY+STEP)) ?
0 : 1;
break;
case DIR_LEFT:
return (isCollision( currentLevel.DrunkenBots[0].posX-STEP,
currentLevel.DrunkenBots[0].posY) |
isOutOfBounds(currentLevel.DrunkenBots[0].posX-STEP,
currentLevel.DrunkenBots[0].posY)) ?
0 : 1;
break;
default: return 1;
}
return 1;
}
void TileMap::setTileColor(const glm::uvec2& pos, const fea::Color& color)
{
FEA_ASSERT(!isOutOfBounds(pos), "Trying to set color outside of the bounds of the tilemap! Setting at " + std::to_string(pos.x) + " " + std::to_string(pos.y) + ".");
uint32_t x = pos.x;
uint32_t y = pos.y;
uint32_t chunkX = x / mChunkSize.x;
uint32_t chunkY = y / mChunkSize.y;
uint32_t chunkIndex = chunkX + chunkY * mChunkGridSize.x;
mChunks[chunkIndex].setTileColors(x - chunkX * mChunkSize.x, y - chunkY * mChunkSize.y, color);
}
void Tiger::vectorTraceBack() {
// a predicate for removing nodes that lie off the grid
struct isOutOfBounds {
bool operator () (const Node& node) {
return ((node.x > GRID_WIDTH) || (node.y > GRID_HEIGHT));
}
};
do {
Uint16 currentX = path.top().x;
Uint16 currentY = path.top().y;
// initialise the vector with the points of the compass
std::vector<Node> adjNodes{
Node( currentX - 1, currentY ), // west
Node( currentX - 1, currentY - 1 ), // north west
Node( currentX, currentY - 1 ), // north
Node( currentX + 1, currentY - 1 ), // north east
Node( currentX + 1, currentY ), // east
Node( currentX + 1, currentY + 1 ), // south east
Node( currentX, currentY + 1 ), // south
Node( currentX - 1, currentY + 1 ), // south west
};
// remove all Nodes that lie outside the board
adjNodes.erase(std::remove_if(adjNodes.begin(), adjNodes.end(), isOutOfBounds()), adjNodes.end());
// get the indexes from the board
for (auto& node : adjNodes) { world->assignIndexTo(node); }
// remove nodes that are skiping over wall corners diagonaly
for (auto node = adjNodes.begin(); node != adjNodes.end();) {
if (skipsWallDiagonaly(*node)) {
node = adjNodes.erase(node);
} else {
node++;
}
}
// check if the start node is present
for (const auto& node : adjNodes) {
if (node.i == START) {
path.push(node);
break;
}
}
// find the Node with the lowest index
// assign if lower and valid ensures Nodes are not out of bounds
Node lowest = path.top();
for (const auto& node : adjNodes) { assignIfLowerAndWithinBounds(lowest, node); }
path.push(lowest);
} while (path.top().i != START && path.size() < MAX_PATH_SIZE);
}
/**
* Each row is a register
*/
void LedMatrixMAX7219Driver::setLed(unsigned char col, unsigned char row,
unsigned char value) {
unsigned char entry, mask = 0;
if (!isOutOfBounds(col, row)) {
entry = matrixData[col];
mask = 0x01 << row;
if (value) {
entry |= mask;
} else {
entry &= ~mask;
}
matrixData[col] = entry;
driver->writeRegister(registerMap[col], entry);
}
}
void LedMatrixMAX7219Driver::shiftCol(unsigned char col,
unsigned char direction) {
if (!isOutOfBounds(col, 0)) {
unsigned char current = matrixData[col];
matrixData[col] = ~current;
driver->writeRegister(registerMap[col], matrixData[col]);
if (direction == RIGHT) {
col++;
} else {
col--;
}
col %= cols;
matrixData[col] = current;
driver->writeRegister(registerMap[col], matrixData[col]);
}
}
static void setFloat(const char *offsetStr, const char *valueStr) {
int offset = atoi(offsetStr);
if (absI(offset) == absI(ERROR_CODE)) {
scheduleMsg(&logger, "invalid offset [%s]", offsetStr);
return;
}
if (isOutOfBounds(offset))
return;
float value = atoff(valueStr);
if (cisnan(value)) {
scheduleMsg(&logger, "invalid value [%s]", valueStr);
return;
}
float *ptr = (float *) (&((char *) engine->engineConfiguration)[offset]);
*ptr = value;
getFloat(offset);
}
/// <summary>
/// Processes the powerup
/// </summary>
void Powerup::process()
{
// Check if the powerup is deleted or not, if it is, we do not want to move it.
if (!getDeleted())
{
this->sprite->setPosition(
sprite->getPosition().x + (timeStep.asSeconds() * speedX),
sprite->getPosition().y + (timeStep.asSeconds() * speedY));
}
// Check if the powerup is out of bounds
if (isOutOfBounds())
{
setDeleted(true);
}
}
void TileMap::unsetTile(const glm::uvec2& pos)
{
FEA_ASSERT(!isOutOfBounds(pos), "Trying to unset tile outside of the bounds of the tilemap! Setting at " + std::to_string(pos.x) + " " + std::to_string(pos.y) + ".");
uint32_t x = pos.x;
uint32_t y = pos.y;
uint32_t chunkX = x / mChunkSize.x;
uint32_t chunkY = y / mChunkSize.y;
uint32_t chunkIndex = chunkX + chunkY * mChunkGridSize.x;
mChunks[chunkIndex].unsetTileTexCoords(x - chunkX * mChunkSize.x, y - chunkY * mChunkSize.y);
if(mAnimatedTiles.find(glm::uvec2(x, y)) != mAnimatedTiles.end())
{
mAnimatedTiles.erase(glm::uvec2(x, y));
}
}
void LedMatrixMAX7219Driver::shiftLed(unsigned char col, unsigned char row,
unsigned char direction) {
unsigned char led;
if (!isOutOfBounds(col, row)) {
led = getLed(col, row);
setLed(col, row, (led ? LedMatrixDriver::OFF : LedMatrixDriver::ON));
if (direction == LEFT) {
col--;
} else if (direction == RIGHT) {
col++;
} else if (direction == UP) {
row++;
} else {
row--;
}
setLed((col % cols), (row % rows), (
led ? LedMatrixDriver::ON : LedMatrixDriver::OFF));
}
}
void walkOfAKingInductiveStep(int x,int y,int energy)
{
int max_prize_found_yet = MINUS_INFINITY;
int direction_of_max_prize = NONE;
int cell_x;
int cell_y;
int cell_prize;
int cell_cost;
int cell_max_prize;
for(int direction=UP_LEFT; direction<=BOT_RIGHT; direction++)
{
cell_x = x + dx[direction];
cell_y = y + dy[direction];
if(isOutOfBounds(cell_x,cell_y))
{
continue;
}
cell_prize = prize[cell_x][cell_y];
cell_cost = cost[cell_x][cell_y];
if(cell_cost > energy)
{
continue;
}
cell_max_prize = add(cell_prize,max_prize[cell_x][cell_y][energy-cell_cost]);
if(cell_max_prize > max_prize_found_yet)
{
max_prize_found_yet = cell_max_prize;
direction_of_max_prize = direction;
}
}
max_prize[x][y][energy] = max_prize_found_yet;
path[x][y][energy] = direction_of_max_prize;
}
void TileMap::setTile(const glm::uvec2& pos, TileId id, int32_t orientation)
{
FEA_ASSERT(!isOutOfBounds(pos), "Trying to set tile outside of the bounds of the tilemap! Setting at " + std::to_string(pos.x) + " " + std::to_string(pos.y) + ".");
FEA_ASSERT(orientation <= 16, "Cannot pass other flags with the PRESERVE flag!");
uint32_t x = pos.x;
uint32_t y = pos.y;
uint32_t chunkX = x / mChunkSize.x;
uint32_t chunkY = y / mChunkSize.y;
uint32_t chunkIndex = chunkX + chunkY * mChunkGridSize.x;
FEA_ASSERT(mTileDefs.find(id) != mTileDefs.end(), "Trying to set tile '" + std::to_string(id) + "' which doesn't exist!");
const TileDefinition& tileDef = mTileDefs.at(id);
glm::vec2 texPos = (glm::vec2)tileDef.mTileTexPosition * mTextureTileSize;
float startX = texPos.x;
float startY = texPos.y;
float endX = texPos.x + mTextureTileSize.x;
float endY = texPos.y + mTextureTileSize.y;
mChunks[chunkIndex].setTileTexCoords(x - chunkX * mChunkSize.x, y - chunkY * mChunkSize.y,
glm::vec2(startX , startY),
glm::vec2(endX , endY ), orientation);
if(mAnimatedTiles.find(glm::uvec2(x, y)) != mAnimatedTiles.end())
{
mAnimatedTiles.erase(glm::uvec2(x, y));
}
if(tileDef.mTicksUntilChange > 0)
{
AnimatedTile animation(tileDef.mNextTile, tileDef.mTicksUntilChange);
mAnimatedTiles.emplace(glm::uvec2(x, y), animation);
}
}
// -------------------------------------------------------
//
// -------------------------------------------------------
void MoveByAction::update(SpriteArray& array,float dt,ActionEventBuffer& buffer) {
if (_buffer.size > 0) {
for (int i = 0; i < _buffer.size; ++i) {
Vector2f p = array.getPosition(_ids[i]);
p += _velocities[i] * dt;
if (isOutOfBounds(p, _velocities[i])) {
if (_bounce[i]) {
if (p.y < m_BoundingRect.bottom || p.y > m_BoundingRect.top) {
_velocities[i].y *= -1.0f;
}
if (p.x < m_BoundingRect.left || p.x > m_BoundingRect.right ) {
_velocities[i].x *= -1.0f;
}
rotateTo(array, i);
p += _velocities[i] * dt * 1.5f;
}
else {
buffer.add(_ids[i], AT_MOVE_BY, array.getType(_ids[i]));
}
}
array.setPosition(_ids[i], p);
}
}
}
bool Pig::update(std::vector<ZombiePig>& zombiePigs) {
bool avoidWall = false;
{ // Check if we are going out of bounds.
// Position of the next frame
const float MULT = 3.0f;
glm::vec2 nextPos = pos + vel * MULT;
const float ROTATE_ANGLE = 0.1f;
float angle = ROTATE_ANGLE;
//Out of bounds check on next frames position
if (isOutOfBounds(nextPos, screenWidth, screenHeight)) {
avoidWall = true;
// Run the algorithm that points us away from the wall
while (true) {
glm::vec2 clockwiseVel = glm::rotate(vel, angle);
glm::vec2 counterClockwiseVel = glm::rotate(vel, -angle);
if (isOutOfBounds(pos + clockwiseVel * MULT, screenWidth, screenHeight) == false) {
vel = clockwiseVel;
break;
}
if (isOutOfBounds(pos + counterClockwiseVel * MULT, screenWidth, screenHeight) == false) {
vel = counterClockwiseVel;
break;
}
// Rotate them some more and try again
angle += ROTATE_ANGLE;
// If angle went in a full circle, break
//if (angle > 2.0 * 3.14159265) break;
}
}
}
// Update position
pos += vel;
collideWithEdge();
float closestDistance2 = pow(300.0f, 2.0f);
ZombiePig* closestZombie = nullptr;
for (auto& zombie : zombiePigs) {
// Get X and Y distance
float dx = zombie.pos.x - pos.x;
float dy = zombie.pos.y - pos.y;
float adx = abs(dx);
float ady = abs(dy);
// Check if its the closest zombie.
float distance2 = adx * adx + ady * ady;
if (distance2 < closestDistance2) {
closestZombie = &zombie;
closestDistance2 = distance2;
}
// If pigs and zombie pigs have different size, need to change this.
if (adx <= zombie.width && ady <= zombie.height) {
// We have a collision
return true;
}
}
// Run away from closest zombie
if (!avoidWall && closestZombie) {
glm::vec2 dirVec = glm::normalize(pos - closestZombie->pos);
vel = glm::length(vel) * dirVec;
}
return false;
}
int loadTraps(int which)
{
FILE *f;
char *f_name = getFileName(which, FYPE_TRAPS);
if(f_name == NULL)
{
fprintf(stderr, "%s: f_name == NULL? (attempt to load something unknown)\n", __FUNCTION__);
return 1;
}
fprintf(stderr, " > In progress: %s\n", f_name);
if((f = fopen(f_name, "r")) == NULL)
{
fprintf(stderr, "%s: fopen failure\n", __FUNCTION__);
free(f_name);
return 1;
}
// It`s horrible, yeah. But i should be sure to be fully compatible
// with old 1.x Test Stuff content.
if(fscanf(f,
"[Idiots]\n%i:%i:%i:%i:%i:%i:%i:%i\n%i:%i:%i:%i:%i:%i:%i:%i\n\n[Drunken"
"Bot]\n%i:%i\n\n[Portals]\n%i:%i:%i:%i:%i:%i\n%i:%i:%i:%i:%i:%i\n\n[Tur"
"rets]\n%i:%i:%i\n%i:%i:%i",
¤tLevel.Idiots[0].posX, ¤tLevel.Idiots[1].posX,
¤tLevel.Idiots[2].posX, ¤tLevel.Idiots[3].posX,
¤tLevel.Idiots[4].posX, ¤tLevel.Idiots[5].posX,
¤tLevel.Idiots[6].posX, ¤tLevel.Idiots[7].posX,
¤tLevel.Idiots[0].posY, ¤tLevel.Idiots[1].posY,
¤tLevel.Idiots[2].posY, ¤tLevel.Idiots[3].posY,
¤tLevel.Idiots[4].posY, ¤tLevel.Idiots[5].posY,
¤tLevel.Idiots[6].posY, ¤tLevel.Idiots[7].posY,
¤tLevel.DrunkenBots[0].posX,
¤tLevel.DrunkenBots[0].posY,
¤tLevel.Portals[0].posX, ¤tLevel.Portals[1].posX, ¤tLevel.Portals[2].posX, ¤tLevel.Portals[0].destX,
¤tLevel.Portals[1].destX, ¤tLevel.Portals[2].destX, ¤tLevel.Portals[0].posY, ¤tLevel.Portals[1].posY,
¤tLevel.Portals[2].posY, ¤tLevel.Portals[0].destY, ¤tLevel.Portals[1].destY, ¤tLevel.Portals[2].destY,
¤tLevel.Turrets[0].posX,
¤tLevel.Turrets[1].posX,
¤tLevel.Turrets[2].posX,
¤tLevel.Turrets[0].posY,
¤tLevel.Turrets[1].posY,
¤tLevel.Turrets[2].posY
) != 36)
{
fprintf(stderr, "%s: fscanf: arguments mismatch\n", __FUNCTION__);
free(f_name);
return 1;
}
/* And enabling `em all (surely, if isn`t OBJ_DISABLED) */
int i = 0;
while(i < MAX_IDIOTS)
{
currentLevel.Idiots[i].posX *= STEP;
currentLevel.Idiots[i].posY *= STEP;
if(!isOutOfBounds(currentLevel.Idiots[i].posX,
currentLevel.Idiots[i].posY)) currentLevel.Idiots[i].isEnabled = 1;
i++;
}
i = 0;
while(i < MAX_PORTALS)
{
currentLevel.Portals[i].posX *= STEP;
currentLevel.Portals[i].posY *= STEP;
currentLevel.Portals[i].destX *= STEP;
currentLevel.Portals[i].destY *= STEP;
if(!isOutOfBounds(currentLevel.Portals[i].posX,
currentLevel.Portals[i].posY)) currentLevel.Portals[i].isEnabled = 1;
i++;
}
i = 0;
while(i < MAX_TURRETS)
{
currentLevel.Turrets[i].posX *= STEP;
currentLevel.Turrets[i].posY *= STEP;
if(!isOutOfBounds(currentLevel.Turrets[i].posX,
currentLevel.Turrets[i].posY)) currentLevel.Turrets[i].isEnabled = 1;
i++;
}
currentLevel.DrunkenBots[0].posX *= STEP;
currentLevel.DrunkenBots[0].posY *= STEP;
if(!isOutOfBounds(currentLevel.DrunkenBots[0].posX,
currentLevel.DrunkenBots[0].posY)) currentLevel.DrunkenBots[0].isEnabled = 1;
/* Finish it. */
free(f_name);
fclose(f);
return 0;
}
int loadItems(int which)
{
FILE *f;
char *f_name = getFileName(which, FYPE_ITEMS);
if(f_name == NULL)
{
fprintf(stderr, "%s: f_name == NULL? (attempt to load something unknown)\n", __FUNCTION__);
return 1;
}
fprintf(stderr, " > In progress: %s\n", f_name);
if((f = fopen(f_name, "r")) == NULL)
{
fprintf(stderr, "%s: fopen failure\n", __FUNCTION__);
free(f_name);
return 1;
}
if(
fscanf(f,
"[Keys]\n Key1X = %i\n Key1Y = %i\n Key2X = %i\n Key2Y = %i\n Key3X = %i\n "
"Key3Y = %i\n\n[1UP]\n 1UP1X = %i\n 1UP1Y = %i\n 1UP2X = %i\n 1UP2Y = %i\n 1UP3X = %i\n 1UP3Y = %i",
¤tLevel.Keys[0].posX, ¤tLevel.Keys[0].posY,
¤tLevel.Keys[1].posX, ¤tLevel.Keys[1].posY,
¤tLevel.Keys[2].posX, ¤tLevel.Keys[2].posY,
¤tLevel._1UPs[0].posX, ¤tLevel._1UPs[0].posY,
¤tLevel._1UPs[1].posX, ¤tLevel._1UPs[1].posY,
¤tLevel._1UPs[2].posX, ¤tLevel._1UPs[2].posY) != 12)
{
fprintf(stderr, "%s: fscanf: arguments mismatch\n", __FUNCTION__);
free(f_name);
return 1;
}
/* 'Enabling' objects */
int i = 0;
while(i < MAX_1UPS)
{
currentLevel.Keys[i].posX *= STEP;
currentLevel.Keys[i].posY *= STEP;
currentLevel._1UPs[i].posX *= STEP;
currentLevel._1UPs[i].posY *= STEP;
if(!isOutOfBounds(currentLevel.Keys[i].posX,
currentLevel.Keys[i].posY)) currentLevel.Keys[i].isEnabled = 1;
if(!isOutOfBounds(currentLevel._1UPs[i].posX,
currentLevel._1UPs[i].posY)) currentLevel._1UPs[i].isEnabled = 1;
i++;
}
free(f_name);
fclose(f);
return 0;
}
void LedMatrixMAX7219Driver::setCol(unsigned char col, unsigned char value) {
if (!isOutOfBounds(col, 0)) {
matrixData[col] = value;
driver->writeRegister(registerMap[col], value);
}
}
