void debug_check_entity_solidity(const level& lvl, const entity& e)
{
if(!e.allow_level_collisions() && entity_collides_with_level(lvl, e, MOVE_NONE, NULL)) {
const solid_info* s = e.solid();
ASSERT_LOG(s, "ENTITY COLLIDES BUT DOES NOT HAVE SOLID");
const frame& f = e.current_frame();
const rect& area = s->area();
int min_x = INT_MIN, max_x = INT_MIN, min_y = INT_MIN, max_y = INT_MIN;
std::set<point> solid_points;
foreach(const const_solid_map_ptr& m, s->solid()) {
const std::vector<point>& points = m->dir(MOVE_NONE);
foreach(const point& p, points) {
const int x = e.x() + (e.face_right() ? p.x : (f.width() - 1 - p.x));
const int y = e.y() + p.y;
if(min_x == INT_MIN || x < min_x) {
min_x = x;
}
if(max_x == INT_MIN || x > max_x) {
max_x = x;
}
if(min_y == INT_MIN || y < min_y) {
min_y = y;
}
if(max_y == INT_MIN || y > max_y) {
max_y = y;
}
solid_points.insert(point(x, y));
}
}
std::cerr << "COLLIDING OBJECT MAP:\n";
for(int y = min_y - 5; y < max_y + 5; ++y) {
for(int x = min_x - 5; x < max_x + 5; ++x) {
const bool lvl_solid = lvl.solid(x, y, NULL);
const bool char_solid = solid_points.count(point(x, y));
if(lvl_solid && char_solid) {
std::cerr << "X";
} else if(lvl_solid) {
std::cerr << "L";
} else if(char_solid) {
std::cerr << "C";
} else {
std::cerr << "-";
}
}
std::cerr << "\n";
}
std::cerr << "\n";
ASSERT_LOG(false, "ENTITY " << e.debug_description() << " COLLIDES WITH LEVEL");
}
}
bool non_solid_entity_collides_with_level(const level& lvl, const entity& e)
{
const frame& f = e.current_frame();
if(!lvl.may_be_solid_in_rect(rect(e.x(), e.y(), f.width(), f.height()))) {
return false;
}
for(int y = 0; y < f.height(); ++y) {
for(int x = 0; x < f.width(); ++x) {
if(!f.is_alpha(e.face_right() ? x : f.width() - x - 1, y, e.time_in_frame(), true)) {
if(lvl.solid(e.x() + x, e.y() + y)) {
return true;
}
}
}
}
return false;
}
bool entity_collides_with_level(const level& lvl, const entity& e, MOVE_DIRECTION dir, collision_info* info)
{
const solid_info* s = e.solid();
if(!s) {
return false;
}
if(e.face_right() == false) {
if(dir == MOVE_RIGHT) {
dir = MOVE_LEFT;
} else if(dir == MOVE_LEFT) {
dir = MOVE_RIGHT;
}
}
const frame& f = e.current_frame();
const rect& area = s->area();
if(e.face_right()) {
rect solid_area(e.x() + area.x(), e.y() + area.y(), area.w(), area.h());
if(!lvl.may_be_solid_in_rect(solid_area)) {
return false;
}
} else {
rect solid_area(e.x() + f.width() - area.x() - area.w(), e.y() + area.y(), area.w(), area.h());
if(!lvl.may_be_solid_in_rect(solid_area)) {
return false;
}
}
foreach(const const_solid_map_ptr& m, s->solid()) {
if(lvl.solid(e, m->dir(dir), info ? &info->surf_info : NULL)) {
if(info) {
info->read_surf_info();
}
return true;
}
}
return false;
}
int entity_collides_with_level_count(const level& lvl, const entity& e, MOVE_DIRECTION dir)
{
const solid_info* s = e.solid();
if(!s) {
return 0;
}
const frame& f = e.current_frame();
int count = 0;
foreach(const const_solid_map_ptr& m, s->solid()) {
const std::vector<point>& points = m->dir(dir);
foreach(const point& p, points) {
const int xpos = e.face_right() ? e.x() + p.x : e.x() + f.width() - 1 - p.x;
if(lvl.solid(xpos, e.y() + p.y)) {
++count;
}
}
}
return count;
}
bool non_solid_entity_collides_with_level(const level& lvl, const entity& e)
{
const frame& f = e.current_frame();
if(!lvl.may_be_solid_in_rect(rect(e.x(), e.y(), f.width(), f.height()))) {
return false;
}
const int increment = e.face_right() ? 2 : -2;
for(int y = 0; y < f.height(); y += 2) {
std::vector<bool>::const_iterator i = f.get_alpha_itor(0, y, e.time_in_frame(), e.face_right());
for(int x = 0; x < f.width(); x += 2) {
if(i == f.get_alpha_buf().end() || i == f.get_alpha_buf().begin()) {
continue;
}
if(!*i && lvl.solid(e.x() + x, e.y() + y)) {
return true;
}
i += increment;
}
}
return false;
}
bool point_standable(const level& lvl, const entity& e, int x, int y, collision_info* info, ALLOW_PLATFORM allow_platform)
{
if(allow_platform == SOLID_AND_PLATFORMS && lvl.standable(x, y, info ? &info->surf_info : NULL) ||
allow_platform != SOLID_AND_PLATFORMS && lvl.solid(x, y, info ? &info->surf_info : NULL)) {
if(info) {
info->read_surf_info();
}
if(info && !lvl.solid(x, y)) {
info->platform = true;
}
return true;
}
const point pt(x, y);
const std::vector<entity_ptr>& chars = lvl.get_solid_chars();
for(std::vector<entity_ptr>::const_iterator i = chars.begin();
i != chars.end(); ++i) {
const entity_ptr& obj = *i;
if(&e == obj.get()) {
continue;
}
if(allow_platform == SOLID_AND_PLATFORMS || obj->solid_platform()) {
const rect& platform_rect = obj->platform_rect_at(pt.x);
if(point_in_rect(pt, platform_rect) && obj->platform()) {
if(info) {
info->collide_with = obj;
info->friction = obj->surface_friction();
info->traction = obj->surface_traction();
info->adjust_y = y - platform_rect.y();
info->platform = !obj->solid_platform();
}
return true;
}
}
if((e.weak_solid_dimensions()&obj->solid_dimensions()) == 0 &&
(e.solid_dimensions()&obj->weak_solid_dimensions()) == 0) {
continue;
}
if(!point_in_rect(pt, obj->solid_rect())) {
continue;
}
const frame& f = obj->current_frame();
const int xpos = obj->face_right() ? x - obj->x() : obj->x() + f.width() - x - 1;
const solid_info* solid = obj->solid();
if(solid && solid->solid_at(x - obj->x(), y - obj->y(), info ? &info->collide_with_area_id : NULL)) {
if(info) {
info->collide_with = obj;
info->friction = obj->surface_friction();
info->traction = obj->surface_traction();
}
return true;
}
}
return false;
}
