void Octree::doCollisions()
{
std::set<std::pair<OctreeObject*, OctreeObject*>, OctreeObjectPairLess> l;
getUnitUnitColl(l);
for(auto it = l.begin(); it != l.end(); ++it)
{
auto o = it->first;
auto o2 = it->second;
Location bot1 = o->bb_bot();
Location top1 = o->bb_top();
Location bot2 = o2->bb_bot();
Location top2 = o2->bb_top();
if (Collision::boxBox(bot1, top1, bot2, top2))
{
if(top1.y < top2.y)
{
o->collides(*o2);
o2->collides(*o);
}
else
{
o2->collides(*o);
o->collides(*o2);
}
}
}
}
void Physics::step( real_t dt )
{
// step the world forward by dt. Need to detect collisions, apply
// forces, and integrate positions and orientations.
for(size_t i=0; i<num_spheres(); i++){
//Update Spheres boundbox
Vector3 upper = spheres[i]->position + Vector3(spheres[i]->radius, spheres[i]->radius, spheres[i]->radius);
Vector3 lower = spheres[i]->position - Vector3(spheres[i]->radius, spheres[i]->radius, spheres[i]->radius);
spheres[i]->bound = BoundBox(lower, upper);
for(size_t j=0; j<num_spheres(); j++){
if(i!=j){
collides(*spheres[i], *spheres[j], collision_damping);
}
}
for(size_t j=0; j<num_planes(); j++){
collides(*spheres[i], *planes[j], collision_damping);
}
for(size_t j=0; j<num_triangles(); j++){
collides(*spheres[i], *triangles[j], collision_damping);
}
for(size_t j=0; j<num_models(); j++){
collides(*spheres[i], *models[j], collision_damping);
}
//RK4 Position & Orientation
rk4_update(*spheres[i], dt);
spheres[i]->clear_force();
}
}
// LOOK OUT FOR A CREATURE THAT IS WILLING TO REPLICATE
void Creature::searchPartner(std::vector<Creature*>& creatures)
{
for(int i = 0; i < creatures.size(); ++i)
{
// I DON'T HAVE A PARTNER YET :(
if(partner == NULL || !partner->isReadyToReplicate() || !collides(partner))
{
// FOUND ONE THAT IS LEGIT?
if( creatures[i] != this && collides(creatures[i])
&& creatures[i]->isReadyToReplicate() && !creatures[i]->isReplicating()
&& (creatures[i]->getPartner() == NULL || creatures[i]->getPartner() == this))
{
// YAY I FOUND A PARTNER -> MOVE TOWARDS PARTNER
moveAction.setTargetPosition((creatures[i]->getPosition() + position) / 2.f);
sight.setFillColor(sf::Color(255, 255, 0, 100));
partner = creatures[i];
movingToPartner = true;
}
}
// I ALREADY HAVE A PARTNER :)
else
{
// MOVE TOWARD CREATURE
moveAction.setTargetPosition((partner->getPosition() + position) / 2.f);
sight.setFillColor(sf::Color(255, 255, 0, 100));
movingToPartner = true;
}
}
// UNHIGHLIGHT
if(!movingToPartner)
{
sight.setFillColor(sf::Color(200, 200, 200, 50));
}
}
void Follower::detectCollision()
{
//bounding sphere for follower
BoundingSphere followerSphere = BoundingSphere(mPosition, mRadius);
D3DXVECTOR3 movement;
bool wall = false;
//collision with walls or obstacles in level
for (Mesh* M : gCurrentLevel->getWorldGeometry())
{
for (AxisAlignedBoundingBox AABB : M->getBoundsBoxList())
{
if (collides(AABB, followerSphere, movement))
{
mPosition += movement;
wall = true;
}
}
}
//collide with player unless there is a wall in the way
if (!wall)
{
BoundingSphere playerSphere = BoundingSphere(gPlayer->getPosition(), gPlayer->getRadius());
if (collides(followerSphere, playerSphere, movement))
{
mPosition += movement;
}
}
}
void Simulation::checkCollisions() {
const QPolygonF& objectPolygon = object_.polygon();
const QPolygonF fingertip1 = gripper_.fingertip1Polygon();
const QPolygonF fingertip2 = gripper_.fingertip2Polygon();
bool collided = false;
if(objectPolygon.boundingRect().intersects(fingertip1.boundingRect())) {
// Detailed collision check between object and fingertip 1
collided = collides(objectPolygon, fingertip1) ? true : collided;
}
if(objectPolygon.boundingRect().intersects(fingertip2.boundingRect())) {
// Detailed collision check between object and fingertip 2
collided = collides(objectPolygon, fingertip2) ? true : collided;
}
if(collided) {
// Do nothing
}
else {
// Mark the areas around the fingertips as clear
info_.markClear(gripper_.fingertip1Polygon());
info_.markClear(gripper_.fingertip2Polygon());
}
}
void Enemy::detectCollision()
{
//bounding sphere for follower
BoundingSphere mySphere = BoundingSphere(mPosition, mRadius);
D3DXVECTOR3 movement;
bool wall = false;
//collision with walls or obstacles in level
for (Mesh* M : gCurrentLevel->getWorldGeometry())
{
for (AxisAlignedBoundingBox AABB : M->getBoundsBoxList())
{
if (collides(AABB, mySphere, movement))
{
mPosition += movement;
wall = true;
}
}
}
//collide with other enemies unless there is was wall in the way
if (!wall)
{
for (Enemy* E : gCurrentLevel->getSpawner()->getEnemies())
{
BoundingSphere otherSphere = BoundingSphere(E->getPosition(), E->getRadius());
if (collides(mySphere, otherSphere, movement))
{
mPosition += (movement / 2);
E->move(-(movement / 2));
}
}
}
}
bool AABBCollider::collides(Collider* pCollider) const {
AABBCollider* aabb(static_cast<AABBCollider*>(pCollider));
if (aabb)
return collides(*aabb);
PointCollider* point(static_cast<PointCollider*>(pCollider));
if (point)
return collides(*point);
return Collider::collides(pCollider);
}
void GameState::update()
{
//spawn enemies
spawnDelay += sfw::getDeltaTime();
if (spawnDelay > spawnRate)
{
spawnDelay = 0;
spawnRate *= .98f;
spawnEnemy(randRange(BOUNDS_LEFT, BOUNDS_RIGHT), BOUNDS_TOP);
}
//updating
player.update();
for (int i = 0; i < bullets.size(); ++i)
bullets[i].update();
for (int i = 0; i < enemies.size(); ++i)
enemies[i].update();
//Collision
//player v bullets/enemies
for (int i = 0; i < bullets.size(); ++i)
collides(player, bullets[i]);
for (int i = 0; i < enemies.size(); ++i)
collides(player, enemies[i]);
//bullet v enemies
for (int i = 0; i < enemies.size(); ++i)
for (int j = 0; j < bullets.size(); ++j)
collides(enemies[i], bullets[j]);
for (int i = 0; i < bullets.size(); ++i)
for (int j = 0; j < bullets.size(); ++j)
collides(bullets[i], bullets[j]);
if (appState == GAME)
{
if (!player.active)
{
std::fstream fout("scores.dat",std::ios_base::out | std::ios_base::app);
fout << score << std::endl;
fout.close();
appState = VICTORY;
}
if (sfw::getKey('P'))
appState = PAUSE;
}
}
void _checkCollisions(Entity *entity, CellList* list) {
if(list) {
float posX = entity->pos.x;
float posY = entity->pos.y;
int sizeX = entity->size.x;
int sizeY = entity->size.y;
EntityPtr *ents = list->_list;
for(int i=0; i<list->index; i++) {
if(ents[i] != entity) {
Vec2d *pos2 = &ents[i]->pos;
Vec2di *size2 = &ents[i]->size;
if(collides(posX, posY,
posX + sizeX, posY + sizeY,
pos2->x, pos2->y,
pos2->x + size2->x, pos2->y + size2->y)) {
if(entity == playerEntity) {
removeObject(ents[i]);
}
}
}
}
}
}
/* Perform a Monte Carlo sweep */
static TaskSignal monteCarloTaskTick(void *state)
{
assert(state != NULL);
MonteCarloState *mcs = (MonteCarloState*) state;
MonteCarloConfig *mcc = &mcs->conf;
assert(mcc->delta > 0);
for (int i = 0; i < world.numParticles; i++) {
Particle *p = &world.particles[randIndex(world.numParticles)];
Vec3 oldPos = p->pos;
p->pos.x += mcc->delta * (rand01() - 1/2.0);
p->pos.y += mcc->delta * (rand01() - 1/2.0);
if (!world.twoDimensional)
p->pos.z += mcc->delta * (rand01() - 1/2.0);
reboxParticle(p);
if (collides(p)) {
/* Back to old position! */
p->pos = oldPos;
reboxParticle(p);
} else {
mcs->accepted++;
}
}
mcs->attempted += world.numParticles;
return TASK_OK;
}
void Projectile::midstep(Gamestate *state, double frametime)
{
if (isrectangular())
{
if (state->currentmap->collides(getrect(), std::atan2(vspeed, hspeed)))
{
oncollision(state);
}
for (auto p : state->playerlist)
{
// DEBUGTOOL: Replace this check with checking whether p is on enemy team
if (p != owner)
{
Character *c = state->get<Player>(p)->getcharacter(state);
if (c != 0)
{
if (collides(state, state->get<Player>(p)->character, std::atan2(vspeed, hspeed)))
{
oncollision(state, c);
}
}
}
}
}
}
void SurfaceObject::blit(Active * obj)
{
use_fbo_blit = true;
if (!collides(0, 0, selected_image->width, selected_image->height,
dest_x, dest_y, dest_x+dest_width, dest_y+dest_height))
return;
Image * img = obj->image;
int scale_x = SURFACE_FBO_WIDTH / selected_image->width;
int scale_y = SURFACE_FBO_HEIGHT / selected_image->height;
int index = blit_images.size();
blit_images.resize(index+1);
blit_images[index].x = dest_x * scale_x;
blit_images[index].y = dest_y * scale_y;
dest_width *= scale_x;
dest_height *= scale_y;
int img_w = src_width;
if (img_w == -1)
img_w = img->width;
int img_h = src_height;
if (img_h == -1)
img_h = img->height;
blit_images[index].scale_x = dest_width / double(img_w);
blit_images[index].scale_y = dest_height / double(img_h);
blit_images[index].scroll_x = 0;
blit_images[index].scroll_y = 0;
if (blit_effect != 1 && blit_effect != 11) {
std::cout << "Unsupported blit effect: " << blit_effect << std::endl;
blit_images[index].effect = 1;
} else
blit_images[index].effect = blit_effect;
blit_images[index].image = img;
}
void Physics::detect_collisions()
{
for (size_t i = 0; i < num_spheres(); i++) {
for (size_t j = 0; j < num_spheres(); j++) {
if (i != j) {
collides(*(spheres[i]), *(spheres[j]), collision_damping);
}
}
for (size_t j = 0; j < num_planes(); j++) {
collides(*(spheres[i]), *(planes[j]), collision_damping);
}
for (size_t j = 0; j < num_triangles(); j++) {
collides(*(spheres[i]), *(triangles[j]), collision_damping);
}
}
}
//takes the corner of the -x/-z corner and int size
//since the map for this is always flat and square
//works best when map size is divisible by GRID_SIZE
//This only works effectively if done after all the addWorldGeometry
void AStar::initPathfinding()
{
D3DXVECTOR3 corner = gCurrentLevel->getNegCorner();
//set up path nodes for enemy path finding
//place path nodes every GRID_SIZE units except
//in places where it would collide
UINT iterationsX = (UINT)gCurrentLevel->getSize().x / GRID_SIZE;
UINT iterationsZ = (UINT)gCurrentLevel->getSize().z / GRID_SIZE;
for (UINT x = 0; x < iterationsX; ++x)
{
for (UINT z = 0; z < iterationsZ; ++z)
{
bool canPlace = true;
//for each mesh in the current map
for (Mesh* M : gCurrentLevel->getWorldGeometry())
{
//for each AABB in that mesh
for (AxisAlignedBoundingBox AABB : M->getBoundsBoxList())
{
//find the center of the node to compare with
D3DXVECTOR3 nodeCenter = D3DXVECTOR3(corner.x + (float)(x * GRID_SIZE),
0.0f, corner.z + (float)(z * GRID_SIZE));
//make a bounding sphere with it
BoundingSphere PS = BoundingSphere(nodeCenter, CLOSE_RADIUS);
//if the AABB collides with that sphere, we can't place one here
if (collides(AABB, PS))
{
canPlace = false;
break;
}
if (!canPlace)
break;
}
if (!canPlace)
break;
}
//if no obstruction was found, place the node
if (canPlace)
{
D3DXVECTOR3 position = D3DXVECTOR3(corner.x, 0.0f/*SAM:50.0f*/, corner.z)
+ D3DXVECTOR3((float)(x * GRID_SIZE), 0.0f, (float)(z * GRID_SIZE));
#ifdef DEBUG_PATHS
//set up the mesh if in debug
PathNode* pn = new PathNode(L"Content/Models/ball.x", position, D3DXVECTOR3(2.0f, 2.0f, 2.0f));
#else
//use no mesh if not in debug, this saves a lot of time loading
PathNode* pn = new PathNode(position);
#endif
//add new node
mPathNodes.push_back(pn);
}
}
}
//connect the nodes to their closest neighbors
connectPathfinding();
}
bool Enemy::noticeFollower()
{
bool returnBool = false;
D3DXVECTOR3 followerPos = gFollower->getPosition();
float distanceSq = D3DXVec3LengthSq(&(mPosition - followerPos));
if (distanceSq > mSightRangeSq)//if not within range, they can't see follower
{
bAttackFollower = false;
return false;
}
// they are close enough to hear the follower through a wall or behind them
if (distanceSq < mHearRangeSq)
returnBool = true;
//if the follower would be behind the enemy, they don't get a chance to see them
//current enemy rotation is mRotation.y
//find rotation towards follower
D3DXVECTOR3 toFollower = gFollower->getPosition() - mPosition;
float followerDirection = atan2(toFollower.x, toFollower.z);
//if not within VISION_RANGE degrees/PI radians of each other
//this only applies if the player has not injured them. If player has, they are more
//watchful
if (mHealth == mHealthMax && returnBool == false)
{
//1.57 ~ 1/2 * PI 6.28 ~ 2 * PI
if ((fabs(followerDirection - mRotation.y) > 1.57) &&
((fabs(followerDirection - 6.28)) + mRotation.y > 1.57) &&
((fabs(mRotation.y - 6.28)) + followerDirection > 1.57))
{
bAttackFollower = false;
return false;
}
}
//if they are between max hearing and max sight range, see if they are line of sight to player
//make a line segment between enemy and player location
//only take into account x and z here since map is flat, will save time
LineSegment line3D(mPosition, followerPos);
for (Mesh* M : gCurrentLevel->getWorldGeometry())
{
for (AxisAlignedBoundingBox AABB : M->getBoundsBoxList())
{
//if further out than sight range, no point in checking it
if (D3DXVec3LengthSq(&(AABB.mMin - mPosition)) > mSightRangeSq)
continue;
//see if it collides with the line
if (collides(AABB, line3D))
{
bAttackPlayer = false;
return returnBool;
}
}
}
//if it gets through the above checks, then it can see the player
mLoseSightFollower = 0.0f;
bAttackFollower = true;
bSeenPlayer = true;
return true;
}
static void
recursefindpack(Rectangle * const current,
Coord const currentsz,
Coord * const best,
unsigned int const minarea,
unsigned int * const maxareaP,
unsigned int const depth,
unsigned int const n,
unsigned int const xinc,
unsigned int const yinc,
unsigned int const quality,
unsigned int const qfactor) {
if (depth == n) {
if (currentsz.x * currentsz.y < *maxareaP) {
unsigned int i;
for (i = 0; i < n; ++i)
best[i] = current[i].ul;
*maxareaP = currentsz.x * currentsz.y;
}
} else {
unsigned int i;
Rectangle * const newP = ¤t[depth];
for (i = 0; ; ++i) {
for (newP->ul.x = 0, newP->ul.y = i * yinc;
newP->ul.y <= i * yinc;) {
Coord c;
c.x = MAX(lr(*newP).x, currentsz.x);
c.y = MAX(lr(*newP).y, currentsz.y);
pm_message("current = (%u.%u, %u.%u) new = (%u.%u, %u.%u)",
current[0].ul.x, current[0].size.x,
current[0].ul.y, current[0].size.y,
newP->ul.x, newP->size.x,
newP->ul.y, newP->size.y);
if (!collides(*newP, current, depth)) {
pm_message("Depth %u: Doesn't collide at i=%u", depth,i);
recursefindpack(current, c, best, minarea, maxareaP,
depth + 1, n, xinc, yinc,
quality, qfactor);
if (*maxareaP <= minarea)
return;
}
if (newP->ul.x == (i - 1) * xinc)
newP->ul.y = 0;
if (newP->ul.x < i * xinc)
newP->ul.x += xinc;
else
newP->ul.y += yinc;
}
}
}
}
//This game starts the game the setting of speed is done by using the clock() function
void startgame(int snakeXY[][MAX_SIZE], int foodXY[], int consolewidth, int consoleheight, int snakelength, int dir, int score, int speed) {
int isgameover = 0;
clock_t endwait;
int waittime = CLOCKS_PER_SEC-(speed)*(CLOCKS_PER_SEC/10);
waittime = waittime / 2.5;
int tempscore = 10 * speed;
int olddir;
int newdir = 1;
endwait = clock() + waittime;
do {
if(newdir) {
olddir = dir;
dir = checkkey(dir);
}
if(olddir != dir)
newdir = 0;
if(clock() >= endwait) {
displaymovement(snakeXY,snakelength,dir);
newdir = 1;
if(checkeatfood(snakeXY, foodXY)) {
foodcreate(foodXY, consolewidth, consoleheight, snakeXY, snakelength);
snakelength++;
score = score + speed; // I have incremented the score with the speed ( 9 gets the most score)
if( score >= 10*speed+tempscore) {
speed = speed * 2;
tempscore = score;
if(speed <= 9)
waittime = waittime - (CLOCKS_PER_SEC);
else if(waittime >= 40)
waittime = waittime - (CLOCKS_PER_SEC);
}
scoreboard(score, speed);
}
endwait = clock() + waittime;
}
isgameover = collides(snakeXY, consolewidth, consoleheight, snakelength);
if(snakelength >= MAX_SIZE-5) {
isgameover = 2;
score+=1500;
}
} while(!isgameover);
switch(isgameover) {
case 1:
gameoverscreen();
break;
default: ;
break;
}
}
int move(int move, int* board) {
int slid = slides(move, board, 1);
int collided = collides(move, board, 1);
if (collided) {
slides(move, board, 1);
}
return slid || collided;
}
bool collides(Collision& col1, Collision& col2)
{
if (collides(col1.bounding_boxes, col1.x, col1.y,
col2.bounding_boxes, col2.x, col2.y))
return true;
// As we implement more collisions, check each combination with the appropriate function
// here
return false;
}
void Particle::update(float delta)
{
std::uniform_real_distribution<> dist(-0.5f, -0.15f);
velocity.x -= glm::sign(velocity.x) * 10.0f * delta;
velocity.y += gravity * delta;
position += velocity * delta;
//position.x += velocity.x * delta;
//position.y = glm::min(position.y + velocity.y * delta, 1000.0f - size*2);
for (auto it = game->blocks.begin(); it != game->blocks.end(); ++it)
{
if (!it->alive)
continue;
glm::vec2 pos = it->getPosition();
if (collides(position.x, position.y, size*2, size*2, pos.x, pos.y, 50.0f, 50.0f))
{
if (pos.y - position.y < size)
{
position.y = pos.y - size;
velocity.y *= (float)dist(game->random);
}
else
{
position.x = pos.x + (position.x < pos.x ? -50 : 50);
velocity.x *= (float)dist(game->random);
}
}
}
if (position.x < 0)
{
position.x = 0.0f;
velocity.x *= (float)dist(game->random);
game->bound[0] = 1.0f;
}
else if (position.x > 3200.0f - size * 2)
{
position.x = 3200.0f - size * 2;
velocity.x *= (float)dist(game->random);
game->bound[1] = 1.0f;
}
if (position.y > 1000.0f - size * 2)
{
position.y = 1000.0f - size * 2;
velocity.y *= (float)dist(game->random);
}
duration -= delta;
}
// 'Versuchen' Alien zu töten (wenn schon tot, false zurückgeben)
int killEnemy(Game *g, int x, int y)
{
if (!g->enemyContainer.enemys[x][y].dead) {
SDL_Rect p_rect = {g->player.shot->posx, g->player.shot->posy, PLAYER_SHOT_WIDTH, PLAYER_SHOT_HEIGHT};
SDL_Rect e_rect;
e_rect.x = g->enemyContainer.posx + (x * FIELD_WIDTH) + (x * FIELD_MARGIN * 2) - FIELD_MARGIN;
e_rect.y = g->enemyContainer.posy + (y * FIELD_HEIGHT) + (y * FIELD_MARGIN * 2) - FIELD_MARGIN;
e_rect.w = FIELD_WIDTH;
e_rect.h = FIELD_HEIGHT;
// Überscheiden die Umrisse sich?
if (!collides(p_rect, e_rect)) {
return false;
}
// Schuss überschreiben
SDL_FillRect(g->screen, &p_rect, SDL_MapRGB(g->screen->format, 0, 0, 0));
// Speicher freimachen
free(g->player.shot);
// Pointer auf NULL setzen
g->player.shot = NULL;
// Alien tot
g->enemyContainer.enemys[x][y].dead = true;
// Alien löschen
SDL_FillRect(g->screen, &e_rect, SDL_MapRGB(g->screen->format, 0, 0, 0));
// Zähler dekrementieren
g->enemyContainer.aliveCount--;
// Punkte gutschreiben
if (g->enemyContainer.enemys[x][y].type == 3) {
g->score += ALIEN_3_POINTS;
} else if (g->enemyContainer.enemys[x][y].type == 2) {
g->score += ALIEN_2_POINTS;
} else if (g->enemyContainer.enemys[x][y].type == 1) {
g->score += ALIEN_1_POINTS;
}
// Anzeigen
updateScore(g);
// Alle tot -> neues Level
if (g->enemyContainer.aliveCount == 0) {
startNewLevel(g);
}
return true;
} else {
return false;
}
}
bool Bearpaw::
collides(R3Scene *scene, R3Node *node)
{
if (bbox.intersects(node->bbox)) {
return true;
}
for (unsigned int i = 0; i < node->children.size(); i++) {
if (collides(scene, node->children[i])) {
return true;
}
}
return false;
}
void Physics::step( real_t dt )
{
// Check collision between every sphere and other objects.
for (size_t i = 0; i < num_spheres(); i++) {
for (size_t j = 0; j < num_planes(); j++)
collides(*spheres[i], *planes[j], collision_damping);
for (size_t j = 0; j < num_triangles(); j++)
collides(*spheres[i], *triangles[j], collision_damping);
for (size_t j = i + 1; j < num_spheres(); j++) {
collides(*spheres[i], *spheres[j], collision_damping);
}
}
std::vector<State> states(num_spheres());
for (size_t i = 0; i < num_spheres(); i++) {
states[i].position = spheres[i]->position;
states[i].velocity = spheres[i]->velocity;
states[i].angular_velocity = spheres[i]->angular_velocity;
// Step dt using rk4 integral.
rk4_integrate(states[i], spheres[i], dt);
}
// Update every sphere's state after rk4 integral.
for (size_t i = 0; i < num_spheres(); i++) {
spheres[i]->position = states[i].position;
spheres[i]->velocity = states[i].velocity;
spheres[i]->angular_velocity = states[i].angular_velocity;
spheres[i]->update_orientation(states[i].angular_position);
spheres[i]->sphere->orientation = spheres[i]->orientation;
spheres[i]->sphere->position = states[i].position;
// Update the offset vector of this sphere in every spring it is attached to.
for (size_t j = 0; j < spheres[i]->spring_ptrs.size(); j++) {
spheres[i]->spring_ptrs[j]->update_offset(spheres[i], states[i].angular_position);
}
}
}
void Enemy::process(std::shared_ptr<Entity> e) {
if(collides(e)) {
std::shared_ptr<Explosion> exp = std::dynamic_pointer_cast<Explosion>(e);
if(exp) {
remove();
} else {
std::shared_ptr<Mine> mine = std::dynamic_pointer_cast<Mine>(e);
if(mine && mine->anti_enemy) {
mine->trip();
}
}
}
}
int is_impossible(int* board) {
int impossible = TRUE;
for (int m=0; m<4; m++) {
if (slides(m, board, 0)) {
impossible = FALSE;
break;
}
if (collides(m, board, 0)) {
impossible = FALSE;
break;
}
}
return impossible;
}
bool collides(std::vector<BoundingBox>& boxes1, int x1, int y1,
std::vector<BoundingBox>& boxes2, int x2, int y2)
{
std::vector<BoundingBox>::iterator it1;
std::vector<BoundingBox>::iterator it2;
for (it1 = boxes1.begin(); it1 != boxes1.end(); it1++)
{
for (it2 = boxes2.begin(); it2 != boxes2.end(); it2++)
{
if ( collides(*it1, x1, y1, *it2, x2, y2) )
return true;
}
}
return false;
}
static void fillWorld(void)
{
double ws = world.worldSize;
for (int i = 0; i < world.numParticles; i++) {
Particle *p = &world.particles[i];
p->pos = (Vec3) {0, 0, 0};
addToGrid(p);
do {
p->pos.x = ws * (rand01() - 1/2.0);
p->pos.y = ws * (rand01() - 1/2.0);
if (!world.twoDimensional)
p->pos.z = ws * (rand01() - 1/2.0);
reboxParticle(p);
} while (collides(p));
}
}
bl particle::iterate( vector& _vector, const map2d::layer* _layer, f32 _f32_gravity, bl _bl_fixed,
f32 _f32_rate )
{
translation translation_iteration;
if( collides( translation_iteration, _layer, _bl_fixed, _f32_rate ) )
{
_vector = translation_iteration.vector_collision;
if( translation_iteration.get_collision_distance() - ENG2D_PRECISION > 0.f )
position() = get_moved( direction, translation_iteration.get_collision_distance() - ENG2D_PRECISION );
f32 d = direction;
f32 c = translation_iteration.line_collision.get_normal_direction();
f32 b = c - d;
direction = c + b - math<f32>::radians_05();
vector vector_offset = get_offset(true);
const map2d::tile* tile_map = &_layer->get( _vector );
vector_offset.x *= ( 1.f - roughness ) * ( 1.f - tile_map->get_friction() );
vector_offset.y *= hardness * ( 1.f - tile_map->get_restitution() );
set_offset( vector_offset, true );
return true;
}
else
{
position() = get_moved( direction, get_distance( _bl_fixed, _f32_rate ) );
if( _bl_fixed )
{
shift_offset_y( _f32_gravity * _layer->get_gravity(), true, _f32_rate );
}
else
{
shift_offset_y( _f32_gravity * _layer->get_gravity() * ( sys::delta() * 1000.0 ), true, _f32_rate );
}
return false;
} }
bool rocks_in_space::collides(const collision& col_a, const collision& col_b)
{
auto delta = col_a.m_position - col_b.m_position;
if (delta.magnitude() > (col_a.m_radius + col_b.m_radius))
{
return false;
}
auto segment_start = col_a.m_path.m_vertices[col_a.m_path.m_count - 1];
return &col_a.m_path.m_vertices[col_a.m_path.m_count] != std::find_if(&col_a.m_path.m_vertices[0], &col_a.m_path.m_vertices[col_a.m_path.m_count], [&](const auto& v)
{
if (collides(col_b, { { segment_start + col_a.m_position, v + col_a.m_position } }))
{
return true;
}
segment_start += v;
return false;
});
}
bool DynamicObjectMagicRayLogicCalculator::checkIfMagicRayCollidesWithEnemiesAndUpdateEnemies()
{
bool isColliding = false;
std::map<int, AvatarModel*>::iterator enemiesIt = m_levelModel->getEnemyModels().begin();
while(enemiesIt != m_levelModel->getEnemyModels().end())
{
if(collides(enemiesIt->second->getRect()))
{
if(!isColliding) isColliding = true;
enemiesIt->second->setLifePoints(enemiesIt->second->getLifePoints()- m_dynamicObjectModel->getDamagePoints());
}
enemiesIt++;
}
return isColliding;
}
