bool CollisionManager::getPlaceMeetingObject(int id, std::string name)
{
SDL_Rect rA, rB;
Entity *eA = Engine::getInstance()->findEntity(id);
rA = eA->getBBox();
std::vector<Entity*> entities = Engine::getInstance()->getEntityList();
std::vector<Entity*>::iterator iter;
Entity *entity;
iter = entities.begin();
while (iter != entities.end()) {
entity = *iter;
if (entity->getName() == name) {
rB = entity->getBBox();
if (getIntersect(rA, rB)) {
return true;
}
}
iter++;
}
return false;
}
Tile* CollisionManager::getPointMeetingTile(int x, int y, int gridSize)
{
SDL_Rect rA, rB;
rA.x = x;
rA.w = 1;
rA.y = y;
rA.h = 1;
std::vector<Tile*> tiles = Engine::getInstance()->getTileList();
std::vector<Tile*>::iterator iter;
Tile *tile;
iter = tiles.begin();
while (iter != tiles.end()) {
tile = *iter;
rB.x = tile->getX();
rB.w = gridSize;
rB.y = tile->getY();
rB.h = gridSize;
if (getIntersect(rA, rB)) {
return tile;
}
iter++;
}
return NULL;
}
Entity* CollisionManager::getPointMeetingEntity(int x, int y)
{
SDL_Rect rA, rB;
rA.x = x;
rA.w = 1;
rA.y = y;
rA.h = 1;
std::vector<Entity*> entities = Engine::getInstance()->getEntityList();
std::vector<Entity*>::iterator iter;
Entity *entity;
iter = entities.begin();
while (iter != entities.end()) {
entity = *iter;
rB = entity->getBBox();
if (getIntersect(rA, rB)) {
return entity;
}
iter++;
}
return NULL;
}
bool CollisionManager::getPlaceMeetingSolid(int x, int y, int id)
{
SDL_Rect rA, rB;
Entity *eA = Engine::getInstance()->findEntity(id);
rA.x = x;
rA.w = eA->getWBBox();
rA.y = y;
rA.h = eA->getHBBox();
std::vector<Entity*> entities = Engine::getInstance()->getEntityList();
std::vector<Entity*>::iterator iter;
Entity *entity;
iter = entities.begin();
while (iter != entities.end()) {
entity = *iter;
if (entity->getSolid()) {
rB = entity->getBBox();
if (getIntersect(rA, rB)) {
return true;
}
}
iter++;
}
return false;
}
bool CollisionManager::getPlaceMeetingFamily(int id, std::string family)
{
SDL_Rect rA, rB;
Entity *eA = Engine::getInstance()->findEntity(id);
rA.x = eA->getXBBox();
rA.w = eA->getWBBox();
rA.y = eA->getYBBox();
rA.h = eA->getHBBox();
std::vector<Entity*> entities = Engine::getInstance()->getEntityList();
std::vector<Entity*>::iterator iter;
Entity *entity;
iter = entities.begin();
while (iter != entities.end()) {
entity = *iter;
if (entity->getFamily() == family) {
rB.x = entity->getXBBox();
rB.w = entity->getWBBox();
rB.y = entity->getYBBox();
rB.h = entity->getHBBox();
if (getIntersect(rA, rB)) {
return true;
}
}
iter++;
}
return false;
}
double getEdgeLen(int x1, int y1, int z1, int x2, int y2, int z2){
bool inside1, inside2;
double dl;
inside1 = isInside(x1, y1, z1);
inside2 = isInside(x2, y2, z2);
if (!inside1 & !inside2) return 0;
if ( inside1 & inside2) return 1.;
dl = getIntersect(x1, y1, z1, x2, y2, z2);
// printf("dl = %g inside1 = %d\n", dl, inside1);
return (inside1) ? dl : 1. - dl;
}
void solve()
{
scanf("%lf%lf%lf%lf%lf%lf%lf", &dx, &dy, &r, &xA, &yA, &xB, &yB);
xA -= dx, xB -= dx;
yA -= dy, yB -= dy;
calcCore(core[0], core[1]);
for(int t = 0; t < 2; t ++)
getIntersect(core[t].y, -core[t].x, 0, pnt[t * 2], pnt[t * 2 + 1]);
double bigAgl = 10e100;
int res;
for(int t = 0; t < 4; t ++)
{
double agl = calcCosAgl(pnt[t]);
if(agl < bigAgl)
bigAgl = agl, res = t;
}
printf("%.6lf %.6lf\n", pnt[res].x + dx , pnt[res].y + dy);
}
bool CollisionManager::getPointMeetingInstance(int x, int y, int id)
{
SDL_Rect rA, rB;
Entity *e = Engine::getInstance()->findEntity(id);
rA = e->getBBox();
rB.x = x;
rB.w = 1;
rB.y = y;
rB.h = 1;
if (getIntersect(rA, rB)) {
return true;
} else {
return false;
}
}
bool CollisionManager::getPlaceMeetingInstance(int x, int y, int idA, int idB)
{
SDL_Rect rA, rB;
Entity *eA = Engine::getInstance()->findEntity(idA);
Entity *eB = Engine::getInstance()->findEntity(idB);
rA.x = x;
rA.w = eA->getWBBox();
rA.y = y;
rA.h = eA->getHBBox();
rB = eB->getBBox();
if (getIntersect(rA, rB)) {
return true;
} else {
return false;
}
}
bool CollisionManager::getCollisionBBox(Entity *a, Entity *b)
{
SDL_Rect rA, rB;
rA.x = a->getX();
rA.w = a->getWidth();
rA.y = a->getY();
rA.h = a->getHeight();
rB.x = b->getX();
rB.w = b->getWidth();
rB.y = b->getY();
rB.h = b->getHeight();
if (getIntersect(rA, rB)) {
return true;
} else {
return false;
}
}
void setStencil(Geometry *geometry, int mu, int k, enum direction wind)
{
register int l, m, n;
int l0, m0, k0, countXZ, countYZ, count, Nvalid;
bool_t *valid;
double rx, ry, rz, frac1, frac2, muz, dz, longfracx, longfracy,
svalid;
Stencil *st;
Longchar *lc;
Intersect *vis;
/* --- Fill interpolation stencil:
Determine largest grid coordinate with x1_grid < x1_intersect
and x2_grid < x2_intersect, then fill stencil with addresses
of interpolation points surrounding the point of intersection.
-- -------------- */
if (wind == UPWIND) {
st = &geometry->stencil_uw[mu][k];
dz = geometry->z[k - 1] - geometry->z[k];
} else {
st = &geometry->stencil_dw[mu][k];
dz = geometry->z[k] - geometry->z[k + 1];
}
muz = sqrt(1.0 - (SQ(geometry->mux[mu]) + SQ(geometry->muy[mu])));
rx = geometry->mux[mu] / geometry->dx;
ry = geometry->muy[mu] / geometry->dy;
rz = muz / dz;
/* --- Calculate quadrant ray point to -- -------------- */
st->quadrant = getQuadrant(geometry->mux[mu], geometry->muy[mu], wind);
/* --- Determine which is the nearest plane in direction of ray - - */
st->plane = getIntersect(rx, ry, rz);
/* --- Determine fractions and distance between gridpoint and
point where ray intersects nearest plane -- -------------- */
calcFrac(&frac1, &frac2, rx, ry, rz, st->plane, wind);
st->ds = calcDistance(frac1, frac2, st->plane,
geometry->dx, geometry->dy, dz);
switch (st->plane){
case XY:
st->zbase[0] = (wind == UPWIND) ? k - 1 : k + 1;
l0 = floor(frac1);
frac1 -= l0;
m0 = floor(frac2);
frac2 -= m0;
switch (input.interpolate_3D) {
case LINEAR_3D:
st->xbase[0] = l0;
st->xbase[1] = l0 + 1;
st->xkernel[0] = 1.0 - frac1;
st->xkernel[1] = frac1;
st->ybase[0] = m0;
st->ybase[1] = m0 + 1;
st->ykernel[0] = 1.0 - frac2;
st->ykernel[1] = frac2;
break;
case BICUBIC_3D:
for (l = 0; l < NCC; l++) st->xbase[l] = l0 - 1 + l;
cc_kernel(frac1, st->xkernel);
for (m = 0; m < NCC; m++) st->ybase[m] = m0 - 1 + m;
cc_kernel(frac2, st->ykernel);
}
break;
case XZ:
st->ybase[0] = (st->quadrant == 1 || st->quadrant == 2) ? 1 : -1;
l0 = floor(frac1);
frac1 -= l0;
if (frac2 < 0.0) {
k0 = k + 1;
frac2 += 1.0;
} else
k0 = k;
st->xbase[0] = l0;
st->xbase[1] = l0 + 1;
st->xkernel[0] = 1.0 - frac1;
st->xkernel[1] = frac1;
st->zbase[0] = k0;
st->zbase[1] = k0 - 1;
st->zkernel[0] = 1.0 - frac2;
st->zkernel[1] = frac2;
break;
case YZ:
st->xbase[0] = (st->quadrant == 1 || st->quadrant == 4) ? 1 : -1;
m0 = floor(frac1);
frac1 -= m0;
if (frac2 < 0.0) {
k0 = k + 1;
frac2 += 1.0;
} else
k0 = k;
st->ybase[0] = m0;
st->ybase[1] = m0 + 1;
st->ykernel[0] = 1.0 - frac1;
st->ykernel[1] = frac1;
st->zbase[0] = k0;
st->zbase[1] = k0 - 1;
st->zkernel[0] = 1.0 - frac2;
st->zkernel[1] = frac2;
}
st->longchar = NULL;
/* --- If XZ or YZ plane is hit first, fill long characteristic
structures -- -------------- */
if (st->plane == YZ || st->plane == XZ) {
if (wind == UPWIND) {
longfracx = rx / rz;
longfracy = ry / rz;
} else {
longfracx = -rx / rz;
longfracy = -ry / rz;
}
/* --- Determine number of crossings of YZ and XZ planes,
respectively, before XY plane is crossed -- -------------- */
countYZ = (int) floor(fabs(longfracx));
countXZ = (int) floor(fabs(longfracy));
/* --- Tabulate the vertical intersects -- -------------- */
vis = (Intersect *) malloc((countYZ + countXZ) * sizeof(Intersect));
count = 0;
for (l = 0; l < countYZ; l++) {
vis[count].plane = YZ;
vis[count].s = ((l+1) * geometry->dx) / fabs(geometry->mux[mu]);
vis[count].x = geometry->mux[mu] * vis[count].s;
vis[count].y = geometry->muy[mu] * vis[count].s;
vis[count].z = muz * vis[count].s;
count++;
}
for (m = 0; m < countXZ; m++) {
vis[count].plane = XZ;
vis[count].s = ((m+1) * geometry->dy) / fabs(geometry->muy[mu]);
vis[count].x = geometry->mux[mu] * vis[count].s;
vis[count].y = geometry->muy[mu] * vis[count].s;
vis[count].z = muz * vis[count].s;
count++;
}
/* --- Sort the intersections according to distance s from the
point of origin -- -------------- */
qsort(vis, count, sizeof(Intersect), sascend);
/* --- Determine if any of the intersections appear too close to
one another, for instance when they occur on an intersection
between YZ and XZ planes -- -------------- */
Nvalid = count;
valid = (bool_t *) malloc(Nvalid * sizeof(bool_t));
valid[0] = TRUE;
for (n = 1; n < count; n++) {
if ((vis[n].s - vis[n-1].s) <
MIN_FRAC * MIN(geometry->dx, geometry->dy)) {
valid[n] = FALSE;
Nvalid--;
} else
valid[n] = TRUE;
}
st->longchar = (Longchar *) malloc(sizeof(Longchar));
lc = st->longchar;
lc->Nst = Nvalid + 1;
lc->stencil = (Stencil *) malloc(lc->Nst * sizeof(Stencil));
/* --- The first stencil to be stored is the intersection with
the horizontal XY plane, ds is the distance to the first
valid vertical intersection -- -------------- */
lc->stencil[0].plane = XY;
n = count;
do {
n--;
lc->stencil[0].ds = dz / muz - vis[n].s;
} while (!valid[n]);
svalid = vis[n].s;
l0 = floor(longfracx);
frac1 = longfracx - l0;
m0 = floor(longfracy);
frac2 = longfracy - m0;
switch (input.interpolate_3D) {
case LINEAR_3D:
lc->stencil[0].xbase[0] = l0;
lc->stencil[0].xbase[1] = l0 + 1;
lc->stencil[0].xkernel[0] = 1.0 - frac1;
lc->stencil[0].xkernel[1] = frac1;
lc->stencil[0].ybase[0] = m0;
lc->stencil[0].ybase[1] = m0 + 1;
lc->stencil[0].ykernel[0] = 1.0 - frac2;
lc->stencil[0].ykernel[1] = frac2;
break;
case BICUBIC_3D:
for (l = 0; l < NCC; l++) lc->stencil[0].xbase[l] = l0 - 1 + l;
cc_kernel(frac1, lc->stencil[0].xkernel);
for (m = 0; m < NCC; m++) lc->stencil[0].ybase[m] = m0 - 1 + m;
cc_kernel(frac2, lc->stencil[0].ykernel);
}
lc->stencil[0].zbase[0] = (wind == UPWIND) ? k - 1 : k + 1;
count = 1;
for (n = (countXZ + countYZ)-1; n >= 0; n--) {
if (valid[n]) {
lc->stencil[count].plane = vis[n].plane;
if (count == Nvalid)
lc->stencil[count].ds = svalid;
else {
lc->stencil[count].ds = svalid - vis[n-1].s;
svalid = vis[n-1].s;
}
switch (vis[n].plane) {
case XZ:
l0 = floor(vis[n].x / geometry->dx);
lc->stencil[count].xbase[0] = l0;
lc->stencil[count].xbase[1] = l0 + 1;
frac1 = vis[n].x / geometry->dx - l0;
lc->stencil[count].xkernel[0] = 1.0 - frac1;
lc->stencil[count].xkernel[1] = frac1;
lc->stencil[count].ybase[0] =
(int) round(vis[n].y / geometry->dy);
break;
case YZ:
lc->stencil[count].xbase[0] =
(int) round(vis[n].x / geometry->dx);
m0 = floor(vis[n].y / geometry->dy);
lc->stencil[count].ybase[0] = m0;
lc->stencil[count].ybase[1] = m0 + 1;
frac1 = vis[n].y / geometry->dy - m0;
lc->stencil[count].ykernel[0] = 1.0 - frac1;
lc->stencil[count].ykernel[1] = frac1;
}
if (wind == UPWIND) {
lc->stencil[count].zbase[0] = k;
lc->stencil[count].zbase[1] = k - 1;
frac2 = vis[n].z / dz;
} else {
lc->stencil[count].zbase[0] = k + 1;
lc->stencil[count].zbase[1] = k;
frac2 = 1.0 - vis[n].z / dz;
}
lc->stencil[count].zkernel[0] = 1.0 - frac2;
lc->stencil[count].zkernel[1] = frac2;
count++;
}
}
/* --- Free temporary arrays -- -------------- */
free(vis);
free(valid);
/* --- Store total number of long characteristics to be used - -- */
if (st->plane == YZ)
geometry->Nlongchar += geometry->Ny;
else
geometry->Nlongchar += geometry->Nx;
}
}
int main()
{
struct list *l1 , *l2 , *l3 ;
l1 = malloc(sizeof(struct list)) ;
l2 = malloc(sizeof(struct list)) ;
l3 = malloc(sizeof(struct list)) ;
l1 -> data = 1 ;
l2 -> data = 10 ;
l3 -> data = 100 ;
l1 -> next = NULL ;
l2 -> next = NULL ;
l3 -> next = NULL ;
int i ;
for(i = 2 ; i < 7 ; i++)
{
struct list *newNode = malloc(sizeof(struct list)) ;
newNode -> data = i ;
newNode -> next = l1 ;
l1 = newNode ;
}
for(i = 2 ; i < 5 ; i++)
{
struct list *newNode = malloc(sizeof(struct list)) ;
newNode -> data = i*10 ;
newNode -> next = l2 ;
l2 = newNode ;
}
for(i = 2 ; i < 4 ; i++)
{
struct list *newNode = malloc(sizeof(struct list)) ;
newNode -> data = i*100 ;
newNode -> next = l3 ;
l3 = newNode ;
}
struct list *ptr , *ptr2 , *ptr3 ;
ptr = l1 ;
ptr2 = l2 ;
ptr3 = l3 ;
while(ptr -> next != NULL)
{
ptr = ptr -> next ;
}
while(ptr2 -> next != NULL)
{
ptr2 = ptr2 -> next ;
}
ptr -> next = ptr3 ;
ptr2 -> next = ptr3 ;
display(l1) ;
findMid(l1) ; // this function find the mid element of the list with a single scan
printf("\n");
display(l2) ;
// here we have two lists that combined with third list
ptr = l1 ;
ptr2 = l2 ;
int flag = 0 ;
while(ptr -> next != NULL)
{
ptr2 = l2 ;
while(ptr2 -> next != NULL) // we find the intersecting node in complexity of O(nm) ;
{
if(ptr2 == ptr)
{
flag = 1 ;
break ;
}
ptr2 = ptr2 -> next ;
}
if(flag == 1)
break ;
ptr = ptr -> next ;
}
printf("Both linked list joined at : %d\n", ptr -> data );
// another approach to find the interecting node with complexity of max(O(n) , O(m))
getIntersect(l1 , l2) ;
}
bool check(segment a, segment b, segment c) {
point p;
getIntersect(a, b, p);
return (c.b - c.a) / (p - c.a) > 0;
}
