bool piece_attack_king(const board_t * board, int piece, int from, int king) {
const inc_t * inc_ptr;
int code;
const int * delta_ptr;
int delta, inc;
int to;
int sq;
ASSERT(board!=NULL);
ASSERT(piece_is_ok(piece));
ASSERT(SQUARE_IS_OK(from));
ASSERT(SQUARE_IS_OK(king));
inc_ptr = PIECE_INC(piece);
code = PieceCode[piece];
ASSERT(code>=0&&code<4);
if (PIECE_IS_SLIDER(piece)) {
for (delta_ptr = PieceDeltaDelta[code][DeltaOffset+(king-from)]; (delta=*delta_ptr) != DeltaNone; delta_ptr++) {
ASSERT(delta_is_ok(delta));
inc = DeltaIncLine[DeltaOffset+delta];
ASSERT(inc!=IncNone);
to = from + delta;
sq = from;
do {
sq += inc;
// if (sq == to && SQUARE_IS_OK(to)) {
// ASSERT(DISTANCE(to,king)==1);
// return true;
if (DISTANCE(sq,king)<=2){
return true;
}
} while (board->square[sq] == Empty);
}
} else { // non-slider
for (delta_ptr = PieceDeltaDelta[code][DeltaOffset+(king-from)]; (delta=*delta_ptr) != DeltaNone; delta_ptr++) {
ASSERT(delta_is_ok(delta));
to = from + delta;
if (SQUARE_IS_OK(to)) {
ASSERT(DISTANCE(to,king)==1);
return true;
}
}
}
return false;
}
float Myron::getTriangleArea(float x0,float y0,float x1,float y1,float x2,float y2){
#define DISTANCE(x,y,xx,yy) (sqrt((x-xx)*(x-xx)+(y-yy)*(y-yy)))
double a = DISTANCE(x0,y0,x1,y1);
double b = DISTANCE(x1,y1,x2,y2);
double c = DISTANCE(x2,y2,x0,y0);
double s = 0.5*(a+b+c);
return (float)sqrt(s*(s-a)*(s-b)*(s-c));
}
/*********************************************************************
* @fn hwLight_XyToSat
*
* @brief Set saturation parameter according to x,y coordinates
* relative distance from white point.
*
* @param x - x of xyY
* @param y - y of xyY
* @param hue - current saturated hue matching xy
*
* @return saturation value to be set
*/
static uint8 hwLight_XyToSat(uint16 x, uint16 y, uint8 hue)
{
uint32 xyDeltas, hueDeltas;
//we try to avoid polor to cartesan conversion using proportional scaling
xyDeltas = ((uint32)DISTANCE(x, WHITE_POINT_X) + DISTANCE(y, WHITE_POINT_Y));
hueDeltas = ((uint32)DISTANCE(hueToX[hue], WHITE_POINT_X) + DISTANCE(hueToY[hue], WHITE_POINT_Y));
return ( (hueDeltas) ? ((xyDeltas * COLOR_SAT_MAX) / hueDeltas) : COLOR_SAT_MAX );
}
coord *
can_shoot(coord *er, coord *ee, coord *dir)
{
int ery, erx, eey, eex;
/* Make sure we are chasing the player */
if (!ce((*ee), hero))
return(NULL);
/* They must be in the same room */
if (roomin(*er) != roomin(hero))
return(NULL);
ery = er->y;
erx = er->x;
eey = ee->y;
eex = ee->x;
/* Will shoot unless next to player, then 80% prob will fight */
if ((DISTANCE(*er,*ee) < 4) && (rnd(100) < 80))
return(NULL);
/* Do we have a straight shot? */
if (!straight_shot(ery, erx, eey, eex, dir))
return(NULL);
else
return(dir);
}
int
cansee(int y, int x)
{
struct room *rer;
coord tp;
if (on(player, ISBLIND))
return FALSE;
tp.y = y;
tp.x = x;
rer = roomin(tp);
/*
* We can only see if the hero in the same room as the coordinate and
* the room is lit or if it is close.
*/
return ((rer != NULL &&
rer == roomin(hero) &&
(!(rer->r_flags & ISDARK) || (rer->r_flags & HASFIRE)) &&
(levtype != MAZELEV || /* Maze level needs direct line */
maze_view(tp.y, tp.x))) ||
DISTANCE(tp,hero) < see_dist);
}
void
listen(void)
{
struct linked_list *item;
struct thing *tp;
int thief_bonus = -50;
int mcount = 0;
if (player.t_ctype == C_THIEF)
thief_bonus = 10;
for (item = mlist; item != NULL; item = next(item))
{
tp = THINGPTR(item);
if (DISTANCE(hero, tp->t_pos) < 81
&& rnd(70) < (thief_bonus + 4 * pstats.s_dext +
6 * pstats.s_lvl))
{
msg("You hear a%s %s nearby.",
vowelstr(monsters[tp->t_index].m_name),
monsters[tp->t_index].m_name);
mcount++;
}
}
if (mcount == 0)
msg("You hear nothing.");
}
coor xaeBlockScene::collisionCheck(HTEXTURE hTex, int x, int y, int w, int h)
{
if(!m_bClothes[y / h][x / w]) return coor(-1, -1);
int nTexWidth = m_pHGE->Texture_GetWidth(hTex);
DWORD* pPix = m_pHGE->Texture_Lock(hTex);
for(int i = 0; i < h; i++)
{
for(int j = 0; j < w; j++)
{
/** 某一个点不透明 */
if((y + i) * nTexWidth + x + j >= nTexWidth * 600) break;
if(pPix[(y + i) * nTexWidth + x + j] != 0xffff00ff)
{
/** 在圆的半径里 */
if(DISTANCE(x + j, y + i, m_fBallX, m_fBallY) < (g_Setting.Block.m_nBallLength / 2))
{
m_pHGE->Texture_Unlock(hTex);
return coor(x + j, y + i);
}
}
}
}
m_pHGE->Texture_Unlock(hTex);
return coor(-1, -1);
}
void recel_tracer_next(recel_tracer *t)
{
char dx = t->dx, dy = t->dy;
int32_t x0 = t->x + dx * t->n, y0 = t->y + dy * t->n;
tracer_invariant(t);
if (DISTANCE(x0 + dx - dy, y0 + dy + dx) >= t->level)
{
x0 = x0 + dx - dy;
y0 = y0 + dy + dx;
char dx1, dy1;
dx1 = - dy;
dy1 = + dx;
dx = dx1;
dy = dy1;
}
else
{
char dx1, dy1;
dx1 = + dy;
dy1 = - dx;
dx = dx1;
dy = dy1;
}
int32_t x1 = x0 + dx, y1 = y0 + dy, n = 0;
while (DISTANCE(x1, y1) >= t->level &&
DISTANCE(x1 - dy, y1 + dx) < t->level)
{
x1 += dx;
y1 += dy;
n += 1;
}
t->x = x0;
t->y = y0;
t->dx = dx;
t->dy = dy;
t->n = n;
tracer_invariant(t);
}
bool recel_tracer_begin(recel_tracer *t, int32_t x, int32_t y)
{
uint32_t level = DISTANCE(x, y);
assert (level > 0);
if (level == 1)
return 0;
char dx = 0, dy = 0;
if (DISTANCE(x - 1, y) < level)
dy = 1;
else if (DISTANCE(x, y + 1) < level)
dx = 1;
else if (DISTANCE(x + 1, y) < level)
dy = -1;
else if (DISTANCE(x, y - 1) < level)
dx = -1;
else
return 0;
// Maximize line
int32_t x0 = x - dx, y0 = y - dy, n = 0;
while (DISTANCE(x0, y0) >= level &&
DISTANCE(x0 - dy, y0 + dx) < level)
{
x0 -= dx;
y0 -= dy;
n += 1;
}
int32_t x1 = x + dx, y1 = y + dy;
while (DISTANCE(x1, y1) >= level &&
DISTANCE(x1 - dy, y1 + dx) < level)
{
x1 += dx;
y1 += dy;
n += 1;
}
t->level = level;
t->x = x0 + dx;
t->y = y0 + dy;
t->dx = dx;
t->dy = dy;
t->n = n;
tracer_invariant(t);
return 1;
}
/*
* Function: K_OS
*
* The program compute the value of formula (47) in J. Chem. Phys. 84(7),3963
*
* %Latex formula
* \begin{equation}
* K(\alpha_1, alpha_2, \mathbf{A}, \mathbf{B})
* = \frac{\sqrt{2}\pi^{\fact{5}{4}}}{\alpha_1 + \alpha_2}
* exp\left(-\frac{\alpha_1\alpha_2}{\alpha_1 + \alpha_2}
* \mathbf{AB}^2 \right)
* \end{equation}
*/
inline double K_OS(const GTO_PARTIAL *gp1,const GTO_PARTIAL *gp2,const COORD *c)
{
int i = gp1->cid;
int j = gp2->cid;
double AB = DISTANCE(c[i], c[j]);
double zeta = gp1->alpha + gp2->alpha;
return M_SQRT2 * PI_1_25 / zeta * exp(-gp1->alpha * gp2->alpha / zeta * AB);
}
/*********************************************************************
* @fn hwLight_UpdateColorMode
*
* @brief Calculates the new xy of hue/sat value on color mode change
*
* @param NewColorMode - Color Mode Attribute value
*
* @return none
*/
void hwLight_UpdateColorMode(uint8 NewColorMode)
{
uint8 idx, chosenIdx=0;
uint32 currDist=0, minDist = 0xFFFFF;
if( NewColorMode != zclColor_ColorMode )
{
if( NewColorMode == COLOR_MODE_CURRENT_X_Y )
{
//update the current xy values from hue and sat
zclColor_CurrentX = hueToX[zclColor_CurrentHue];
zclColor_CurrentY = hueToY[zclColor_CurrentHue];
hwLight_satToXy( &zclColor_CurrentX, &zclColor_CurrentY, zclColor_CurrentSaturation );
}
else if( NewColorMode == COLOR_MODE_CURRENT_HUE_SATURATION )
{
//update the current hue/sat values from xy
//Loop thrugh hueToX/Y tables and look for the value closest to the
//zclColor_CurrentX and zclColor_CurrentY
for( idx = 0; idx != 0xFF; idx++ )
{
currDist = ( (uint32)DISTANCE(hueToX[idx], zclColor_CurrentX)
+ DISTANCE(hueToY[idx], zclColor_CurrentY) );
if ( currDist < minDist )
{
chosenIdx = idx;
minDist = currDist;
}
}
zclColor_CurrentHue = chosenIdx;
zclColor_EnhancedCurrentHue = (uint16)zclColor_CurrentHue << 8;
zclColor_CurrentSaturation = hwLight_XyToSat( zclColor_CurrentX, zclColor_CurrentY, zclColor_CurrentHue );
}
else //do nothing COLOR_MODE_COLOR_TEMPERATURE not supported
{
}
}
return;
}
void moveto(int x, int y) {
point_t p = { x, y };
plugin_print("meph", "moving to %i/%i\n", (word) p.x, (word) p.y);
int t = DISTANCE(bot.location, p) * 80;
d2gs_send(0x03, "%w %w", (word) p.x, (word) p.y);
plugin_debug("pes", "sleeping for %ims\n", t);
msleep(t > 3000 ? 3000 : t);
}
bool
Player::canSee(const sf::Vector2u& pos) const
{
bool can;
can = (DISTANCE(m_position, pos) <= m_class->getCharacteristicLevel(Class::perception));
if (can)
{
// TODO check for walls
}
return (can);
}
static bool kbpk_draw (int wp, int wb, int bk) {
ASSERT(SQUARE_IS_OK(wp));
ASSERT(SQUARE_IS_OK(wb));
ASSERT(SQUARE_IS_OK(bk));
if (SQUARE_FILE(wp) == FileA
&& DISTANCE(bk,A8) <= 1
&& SQUARE_COLOUR(wb) != SQUARE_COLOUR(A8)) {
return true;
}
return false;
}
void Mouse(int button, int state, int cursorX, int cursorY)
{
if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN)
{
printf("%d, %d\n", cursorX, cursorY);
float x = 0, y = 0;
coorTrans(cursorX, cursorY, x, y);
if(DISTANCE(x, y, cx, cy) < r)
{
selected = !selected;
DrawCircle();
}
}
}
int kxk_eval(const position_t *pos) {
int winner = pos->material[WHITE]? WHITE : BLACK;
int loser = winner^1;
int result;
result = (pos->material[winner]
+ MateTable[KingSquare(pos, loser)]
+ DistanceBonus[DISTANCE(KingSquare(pos, winner),
KingSquare(pos, loser))]);
if(HasQueens(pos, winner) || HasRooks(pos, winner) ||
pos->material[winner] >= 8*P_VALUE)
result += KNOWN_WIN;
return (winner == pos->side)? result : -result;
}
void
electrificate(void)
{
int affect_dist = 4 + player.t_stats.s_lvl / 4;
struct linked_list *item, *nitem;
for (item = mlist; item != NULL; item = nitem)
{
struct thing *tp = THINGPTR(item);
char *mname = monsters[tp->t_index].m_name;
nitem = next(item);
if (DISTANCE(tp->t_pos, hero) < affect_dist)
{
int damage = roll(2, player.t_stats.s_lvl);
debug("Charge does %d (%d)", damage, tp->t_stats.s_hpt - damage);
if (on(*tp, NOBOLT))
continue;
if ((tp->t_stats.s_hpt -= damage) <= 0)
{
msg("The %s is killed by an electric shock.", mname);
killed(&player, item, NOMESSAGE, POINTS);
continue;
}
if (rnd(tp->t_stats.s_intel / 5) == 0)
{
turn_on(*tp, ISFLEE);
msg("The %s is shocked by electricity.", mname);
}
else
msg("The %s is zapped by your electricity.", mname);
summon_help(tp, NOFORCE);
turn_off(*tp, ISFRIENDLY);
turn_off(*tp, ISCHARMED);
turn_on(*tp, ISRUN);
turn_off(*tp, ISDISGUISE);
chase_it(&tp->t_pos, &player);
fighting = after = running = FALSE;
}
}
}
void CVoronoi::Generate(int nWidth, int nHeight, byte* szData) {
float fDistance, fTmp;
auto end = m_List.end();
for (int j=0; j<nHeight; ++j) {
for (int i=0; i<nWidth; ++i) {
fDistance = CVoronoi::s_fInfinite;
auto ite = m_List.begin();
for (; end!=ite; ++ite) {
fTmp = DISTANCE((float)i, (float)j, (float)ite->x, (float)ite->y);
if (fTmp < fDistance) {
szData[i+nWidth*j] = ite->data;
fDistance = fTmp;
}
}
}
}
}
int
cansee(int y, int x)
{
struct room *rer;
coord tp;
if (on(player, ISBLIND))
return FALSE;
tp.y = y;
tp.x = x;
rer = roomin(&tp);
/*
* We can only see if the hero in the same room as
* the coordinate and the room is lit or if it is close.
*/
return (rer != NULL && rer == roomin(&hero) && !(rer->r_flags&ISDARK)) ||
DISTANCE(y, x, hero.y, hero.x) < 3;
}
duration_t Duration(Segment *segmentp,Way *wayp,Profile *profile)
{
speed_t speed1=wayp->speed;
speed_t speed2=profile->speed[HIGHWAY(wayp->type)];
distance_t distance=DISTANCE(segmentp->distance);
if(speed1==0)
{
if(speed2==0)
return(hours_to_duration(10));
else
return distance_speed_to_duration(distance,speed2);
}
else /* if(speed1!=0) */
{
if(speed2==0)
return distance_speed_to_duration(distance,speed1);
else if(speed1<=speed2)
return distance_speed_to_duration(distance,speed1);
else
return distance_speed_to_duration(distance,speed2);
}
}
void smooth_traj_goto_target(struct smooth_traj_dest* next_point, float target_x, float target_y)
{
// Compute the angle and distance to send to the control system
//float angle_ref, remaining_dist;
// if the robot is close to the end, and he has to have a specified angle
/*if ((next_point_distance < SMOOTH_TRAJ_DEFAULT_PRECISION_D_MM && !IS_UNDEFINED_ANGLE(next_point->a))
&& (next_id == traj.last_id || (next_id != traj.last_id && ABS(next_point->a - position_get_angle_rad()) > SMOOTH_TRAJ_DEFAULT_PRECISION_A_RAD)))
{
angle_ref = next_point->a;
remaining_dist = 0.f;
}
else*/
float angle_ref = atan2f(-(target_x - position_get_x_mm()), target_y - position_get_y_mm());
float remaining_dist = DISTANCE(position_get_x_mm(), position_get_y_mm(), target_x, target_y);
//printf("tar x:%d y:%d dist:%f a:%f\r\n", (int)target_x, (int)target_y, (double)next1_dist, (double)angle_ref);
// go backward
if (next_point->movement != NORMAL)
{
// just asserv in distance
if (next_point->movement == BACKWARD){
control_system_set_distance_mm_ref(position_get_distance_mm() - remaining_dist);
}
else if (next_point->movement == FORWARD){
control_system_set_distance_mm_ref(position_get_distance_mm() + remaining_dist);
}
}
else
{
control_system_set_distance_mm_ref(position_get_distance_mm() + remaining_dist);
control_system_set_angle_rad_ref(angle_ref);
}
}
static void tracer_invariant(recel_tracer *t)
{
int32_t x0 = t->x, y0 = t->y;
char dx = t->dx, dy = t->dy;
assert (dx == 0 || dy == 0);
assert (!(dx == 0 && dy == 0));
int32_t x1 = x0 + dx * t->n, y1 = y0 + dy * t->n;
// Line is in shape
assert (DISTANCE(x0, y0) >= t->level);
assert (DISTANCE(x1, y1) >= t->level);
// Extremities are corner
assert (DISTANCE(x0 - dx, y0 - dy) < t->level ||
DISTANCE(x0 - dy, y0 + dx) < t->level);
assert (DISTANCE(x1 + dx, y1 + dy) < t->level ||
DISTANCE(x1 - dy, y1 + dx) < t->level);
}
int
chase(struct thing *tp, coord *ee)
{
int x, y;
int dist, thisdist;
struct linked_list *item;
struct object *obj;
coord *er = &tp->t_pos;
int ch;
/*
* If the thing is confused, let it move randomly. Invisible
* Stalkers are slightly confused all of the time, and bats are
* quite confused all the time
*/
if ((on(*tp, ISHUH) && rnd(10) < 8) || (tp->t_type == 'I' && rnd(100) < 20)
|| (tp->t_type == 'B' && rnd(100) < 50))
{
/*
* get a valid random move
*/
ch_ret = *rndmove(tp);
dist = DISTANCE(ch_ret.y, ch_ret.x, ee->y, ee->x);
/*
* Small chance that it will become un-confused
*/
if (rnd(1000) < 50)
tp->t_flags &= ~ISHUH;
}
/*
* Otherwise, find the empty spot next to the chaser that is
* closest to the chasee.
*/
else
{
int ey, ex;
/*
* This will eventually hold where we move to get closer
* If we can't find an empty spot, we stay where we are.
*/
dist = DISTANCE(er->y, er->x, ee->y, ee->x);
ch_ret = *er;
ey = er->y + 1;
ex = er->x + 1;
for (x = er->x - 1; x <= ex; x++)
for (y = er->y - 1; y <= ey; y++)
{
coord tryp;
tryp.x = x;
tryp.y = y;
if (!diag_ok(er, &tryp))
continue;
ch = winat(y, x);
if (step_ok(ch))
{
/*
* If it is a scroll, it might be a scare monster scroll
* so we need to look it up to see what type it is.
*/
if (ch == SCROLL)
{
for (item = lvl_obj; item != NULL; item = next(item))
{
obj = (struct object *) ldata(item);
if (y == obj->o_pos.y && x == obj->o_pos.x)
break;
}
if (item != NULL && obj->o_which == S_SCARE)
continue;
}
/*
* If we didn't find any scrolls at this place or it
* wasn't a scare scroll, then this place counts
*/
thisdist = DISTANCE(y, x, ee->y, ee->x);
if (thisdist < dist)
{
ch_ret = tryp;
dist = thisdist;
}
}
}
}
return (dist != 0);
}
void
wanderer(void)
{
int i, cnt = 0;
struct room *hr = roomin(hero);
struct linked_list *item;
struct thing *tp;
coord cp;
char *loc;
int which;
/* Find a place for it -- avoid the player's room */
do
{
do
{
cnt++;
i = rnd_room();
}
while (!(hr != &rooms[i] || levtype == MAZELEV
|| levtype == THRONE || cnt > 5000));
rnd_pos(&rooms[i], &cp);
}
while(!step_ok(cp.y, cp.x, NOMONST, NULL));
/* Create a new wandering monster */
item = new_item(sizeof *tp);
which = randmonster(TRUE, FALSE);
new_monster(item, which, &cp, FALSE);
tp = THINGPTR(item);
tp->t_pos = cp; /* Assign the position to the monster */
chase_it(&tp->t_pos, &player);
i = rnd(7);
if (on(*tp, ISSWARM) && i < 5)
cnt = roll(2, 4);
else if (on(*tp, ISFLOCK) && i < 5)
cnt = roll(1, 4);
else
cnt = 0;
for (i = 1; i <= cnt; i++)
{
struct linked_list *ip = creat_mons(tp, which, NOMESSAGE);
if (ip != NULL)
{
struct thing *mp = THINGPTR(ip);
if (on(*tp, ISFRIENDLY))
turn_on(*mp, ISFRIENDLY);
else
turn_off(*mp, ISFRIENDLY);
}
}
if (cnt > 0)
{
if (on(*tp, LOWCAST) || on(*tp, MEDCAST) || on(*tp, HIGHCAST))
turn_on(*tp, CANCAST);
tp->t_stats.s_hpt += roll(2, 8);
tp->t_stats.s_lvl += roll(2, 3);
tp->t_stats.s_arm -= roll(1, 6);
tp->t_stats.s_str += roll(2, 3);
tp->t_stats.s_intel += roll(2, 3);
tp->t_stats.s_exp += roll(2, 8) * monsters[which].m_add_exp;
}
i = DISTANCE(cp, hero);
if (i < 20)
loc = "very close to you";
else if (i < 400)
loc = "nearby";
else
loc = "in the distance";
if (wizard)
msg("Started a wandering %s.", monsters[tp->t_index].m_name);
else if (on(*tp, ISUNDEAD) && (player.t_ctype == C_CLERIC ||
player.t_ctype == C_PALADIN || is_wearing(R_PIETY)))
msg("You sense a new ungodly monster %s.", loc);
else if (on(player, CANHEAR) || (player.t_ctype == C_THIEF &&
rnd(20) == 0))
msg("You hear a new %s moving %s.",
monsters[tp->t_index].m_name, loc);
else if (on(player, CANSCENT) || (player.t_ctype == C_THIEF &&
rnd(20) == 0))
msg("You smell a new %s %s.", monsters[tp->t_index].m_name,
loc);
}
void PruneStraightHighwayNodes(NodesX *nodesx,SegmentsX *segmentsx,WaysX *waysx,distance_t maximum)
{
index_t i;
index_t npruned=0;
index_t nalloc;
BitMask *checked;
index_t *nodes,*segments;
double *lats,*lons;
double maximumf;
if(nodesx->number==0 || segmentsx->number==0 || waysx->number==0)
return;
/* Print the start message */
printf_first("Pruning Straight Highway Nodes: Nodes=0 Pruned=0");
/* Map into memory / open the files */
#if !SLIM
nodesx->data=MapFile(nodesx->filename_tmp);
segmentsx->data=MapFileWriteable(segmentsx->filename_tmp);
waysx->data=MapFile(waysx->filename_tmp);
#else
nodesx->fd=SlimMapFile(nodesx->filename_tmp);
segmentsx->fd=SlimMapFileWriteable(segmentsx->filename_tmp);
waysx->fd=SlimMapFile(waysx->filename_tmp);
InvalidateNodeXCache(nodesx->cache);
InvalidateSegmentXCache(segmentsx->cache);
InvalidateWayXCache(waysx->cache);
#endif
checked=AllocBitMask(nodesx->number);
logassert(checked,"Failed to allocate memory (try using slim mode?)"); /* Check AllocBitMask() worked */
nodes =(index_t*)malloc((nalloc=1024)*sizeof(index_t));
segments=(index_t*)malloc( nalloc *sizeof(index_t));
logassert(nodes,"Failed to allocate memory (try using slim mode?)"); /* Check malloc() worked */
logassert(segments,"Failed to allocate memory (try using slim mode?)"); /* Check malloc() worked */
lats=(double*)malloc(nalloc*sizeof(double));
lons=(double*)malloc(nalloc*sizeof(double));
logassert(lats,"Failed to allocate memory (try using slim mode?)"); /* Check malloc() worked */
logassert(lons,"Failed to allocate memory (try using slim mode?)"); /* Check malloc() worked */
/* Loop through the nodes and find stretches of simple highway for possible modification */
maximumf=distance_to_km(maximum);
for(i=0;i<nodesx->number;i++)
{
int lowerbounded=0,upperbounded=0;
index_t lower=nalloc/2,current=nalloc/2,upper=nalloc/2;
if(IsBitSet(checked,i))
goto endloop;
if(segmentsx->firstnode[i]==NO_SEGMENT)
goto endloop;
/* Find all connected nodes */
nodes[current]=i;
do
{
index_t node1=NO_NODE,node2=NO_NODE;
index_t segment1=NO_SEGMENT,segment2=NO_SEGMENT;
index_t way1=NO_WAY,way2=NO_WAY;
int segcount=0;
NodeX *nodex;
/* Get the node data */
nodex=LookupNodeX(nodesx,nodes[current],1);
lats[current]=latlong_to_radians(nodex->latitude);
lons[current]=latlong_to_radians(nodex->longitude);
/* Count the segments at the node if not forced to be an end node */
if(IsBitSet(checked,nodes[current]))
;
else if(nodex->flags&NODE_MINIRNDBT)
;
else if(nodex->flags&NODE_TURNRSTRCT2 || nodex->flags&NODE_TURNRSTRCT)
;
else
{
SegmentX *segmentx;
/* Count the segments connected to the node */
segmentx=FirstSegmentX(segmentsx,nodes[current],3);
while(segmentx)
{
segcount++;
if(node1==NO_NODE)
{
segment1=IndexSegmentX(segmentsx,segmentx);
node1=OtherNode(segmentx,nodes[current]);
way1=segmentx->way;
}
else if(node2==NO_NODE)
{
segment2=IndexSegmentX(segmentsx,segmentx);
node2=OtherNode(segmentx,nodes[current]);
way2=segmentx->way;
}
else
break;
segmentx=NextSegmentX(segmentsx,segmentx,nodes[current]);
}
}
/* Check if allowed due to one-way properties */
if(segcount==2)
{
SegmentX *segmentx1,*segmentx2;
segmentx1=LookupSegmentX(segmentsx,segment1,1);
segmentx2=LookupSegmentX(segmentsx,segment2,2);
if(!IsOneway(segmentx1) && !IsOneway(segmentx2))
;
else if(IsOneway(segmentx1) && IsOneway(segmentx2))
{
if(IsOnewayTo(segmentx1,nodes[current]) && !IsOnewayFrom(segmentx2,nodes[current])) /* S1 is one-way but S2 doesn't continue */
segcount=0;
if(IsOnewayFrom(segmentx1,nodes[current]) && !IsOnewayTo(segmentx2,nodes[current])) /* S1 is one-way but S2 doesn't continue */
segcount=0;
}
else
segcount=0;
}
/* Check if allowed due to highway properties and node restrictions */
if(segcount==2)
{
WayX *wayx1,*wayx2;
wayx1=LookupWayX(waysx,way1,1);
wayx2=LookupWayX(waysx,way2,2);
if(WaysCompare(&wayx1->way,&wayx2->way))
segcount=0;
if(wayx1->way.name!=wayx2->way.name)
segcount=0;
if((nodex->allow&wayx1->way.allow)!=wayx1->way.allow)
segcount=0;
if((nodex->allow&wayx2->way.allow)!=wayx2->way.allow)
segcount=0;
}
/* Update the lists */
if(segcount==2)
{
/* Make space in the lists */
if(upper==(nalloc-1))
{
nodes =(index_t*)realloc(nodes ,(nalloc+=1024)*sizeof(index_t));
segments=(index_t*)realloc(segments, nalloc *sizeof(index_t));
lats=(double*)realloc(lats,nalloc*sizeof(double));
lons=(double*)realloc(lons,nalloc*sizeof(double));
}
if(lower==0) /* move everything up by one */
{
memmove(nodes+1 ,nodes ,(1+upper-lower)*sizeof(index_t));
memmove(segments+1,segments,(1+upper-lower)*sizeof(index_t));
memmove(lats+1,lats,(1+upper-lower)*sizeof(double));
memmove(lons+1,lons,(1+upper-lower)*sizeof(double));
current++;
lower++;
upper++;
}
if(lower==upper) /* first */
{
lower--;
nodes[lower]=node1;
segments[lower]=segment1;
upper++;
nodes[upper]=node2;
segments[upper-1]=segment2;
segments[upper]=NO_SEGMENT;
current--;
}
else if(current==lower)
{
lower--;
if(nodes[current+1]==node2)
{
nodes[lower]=node1;
segments[lower]=segment1;
}
else /* if(nodes[current+1]==node1) */
{
nodes[lower]=node2;
segments[lower]=segment2;
}
current--;
}
else /* if(current==upper) */
{
upper++;
if(nodes[current-1]==node2)
{
nodes[upper]=node1;
segments[upper-1]=segment1;
}
else /* if(nodes[current-1]==node1) */
{
nodes[upper]=node2;
segments[upper-1]=segment2;
}
segments[upper]=NO_SEGMENT;
current++;
}
if(nodes[upper]==nodes[lower])
{
if(!lowerbounded && !upperbounded)
{
nodex=LookupNodeX(nodesx,nodes[lower],1);
lats[lower]=latlong_to_radians(nodex->latitude);
lons[lower]=latlong_to_radians(nodex->longitude);
}
lats[upper]=lats[lower];
lons[upper]=lons[lower];
lowerbounded=1;
upperbounded=1;
}
}
else /* if(segment!=2) */
{
if(current==upper)
upperbounded=1;
if(current==lower)
{
lowerbounded=1;
current=upper;
}
}
}
while(!(lowerbounded && upperbounded));
/* Mark the nodes */
for(current=lower;current<=upper;current++)
SetBit(checked,nodes[current]);
/* Check for straight highway */
for(;lower<(upper-1);lower++)
{
for(current=upper;current>(lower+1);current--)
{
SegmentX *segmentx;
distance_t dist=0;
double dist1,dist2,dist3,distp;
index_t c;
dist3=distance(lats[lower],lons[lower],lats[current],lons[current]);
for(c=lower+1;c<current;c++)
{
dist1=distance(lats[lower] ,lons[lower] ,lats[c],lons[c]);
dist2=distance(lats[current],lons[current],lats[c],lons[c]);
/* Use law of cosines (assume flat Earth) */
if(dist3==0)
distp=dist1; /* == dist2 */
else if((dist1+dist2)<dist3)
distp=0;
else
{
double dist3a=(dist1*dist1-dist2*dist2+dist3*dist3)/(2.0*dist3);
double dist3b=dist3-dist3a;
if(dist3a>=0 && dist3b>=0)
distp=sqrt(dist1*dist1-dist3a*dist3a);
else if(dist3a>0)
distp=dist2;
else /* if(dist3b>0) */
distp=dist1;
}
if(distp>maximumf) /* gone too far */
break;
}
if(c<current) /* not finished */
continue;
/* Delete some segments and shift along */
for(c=lower+1;c<current;c++)
{
segmentx=LookupSegmentX(segmentsx,segments[c],1);
dist+=DISTANCE(segmentx->distance);
prune_segment(segmentsx,segmentx);
npruned++;
}
segmentx=LookupSegmentX(segmentsx,segments[lower],1);
if(nodes[lower]==nodes[current]) /* loop; all within maximum distance */
{
prune_segment(segmentsx,segmentx);
npruned++;
}
else
{
segmentx->distance+=dist;
if(segmentx->node1==nodes[lower])
modify_segment(segmentsx,segmentx,nodes[lower],nodes[current]);
else /* if(segmentx->node2==nodes[lower]) */
modify_segment(segmentsx,segmentx,nodes[current],nodes[lower]);
}
lower=current-1;
break;
}
}
endloop:
if(!((i+1)%10000))
printf_middle("Pruning Straight Highway Nodes: Nodes=%"Pindex_t" Pruned=%"Pindex_t,i+1,npruned);
}
/* Unmap from memory / close the files */
free(checked);
free(nodes);
free(segments);
free(lats);
free(lons);
#if !SLIM
nodesx->data=UnmapFile(nodesx->data);
segmentsx->data=UnmapFile(segmentsx->data);
waysx->data=UnmapFile(waysx->data);
#else
nodesx->fd=SlimUnmapFile(nodesx->fd);
segmentsx->fd=SlimUnmapFile(segmentsx->fd);
waysx->fd=SlimUnmapFile(waysx->fd);
#endif
/* Print the final message */
printf_last("Pruned Straight Highway Nodes: Nodes=%"Pindex_t" Pruned=%"Pindex_t,nodesx->number,npruned);
}
void PruneShortSegments(NodesX *nodesx,SegmentsX *segmentsx,WaysX *waysx,distance_t minimum)
{
index_t i;
index_t nshort=0,npruned=0;
if(nodesx->number==0 || segmentsx->number==0 || waysx->number==0)
return;
/* Print the start message */
printf_first("Pruning Short Segments: Segments=0 Short=0 Pruned=0");
/* Map into memory / open the files */
#if !SLIM
nodesx->data=MapFileWriteable(nodesx->filename_tmp);
segmentsx->data=MapFileWriteable(segmentsx->filename_tmp);
waysx->data=MapFile(waysx->filename_tmp);
#else
nodesx->fd=SlimMapFileWriteable(nodesx->filename_tmp);
segmentsx->fd=SlimMapFileWriteable(segmentsx->filename_tmp);
waysx->fd=SlimMapFile(waysx->filename_tmp);
InvalidateNodeXCache(nodesx->cache);
InvalidateSegmentXCache(segmentsx->cache);
InvalidateWayXCache(waysx->cache);
#endif
/* Loop through the segments and find the short ones for possible modification */
for(i=0;i<segmentsx->number;i++)
{
SegmentX *segmentx2=LookupSegmentX(segmentsx,i,2);
if(IsPrunedSegmentX(segmentx2))
goto endloop;
/*
:
Initial state: ..N3 -------- N2
: S2
:
Final state: ..N3
:
= OR =
: :
Initial state: ..N1 -------- N2 ---- N3 -------- N4..
: S1 S2 S3 :
: :
Final state: ..N1 ------------ N3 ------------ N4..
: S1 S3 :
Not if N1 is the same as N4.
Must not delete N2 (or N3) if S2 (or S3) has different one-way properties from S1.
Must not delete N2 (or N3) if S2 (or S3) has different highway properties from S1.
Must combine N2, S2 and N3 disallowed transports into new N3.
Must not delete N2 (or N3) if it is a mini-roundabout.
Must not delete N2 (or N3) if it is involved in a turn restriction.
= OR =
: :
Initial state: ..N1 -------- N2 ---- N3..
: S1 S2 :
: :
Final state: ..N1 ------------ N3..
: S1 :
Not if N1 is the same as N3.
Not if S1 has different one-way properties from S2.
Not if S1 has different highway properties from S2.
Not if N2 disallows transports allowed on S1 and S2.
Not if N2 is a mini-roundabout.
Not if N2 is involved in a turn restriction.
*/
if(DISTANCE(segmentx2->distance)<=minimum)
{
index_t node1=NO_NODE,node2,node3,node4=NO_NODE;
index_t segment1=NO_SEGMENT,segment2=i,segment3=NO_SEGMENT;
SegmentX *segmentx;
int segcount2=0,segcount3=0;
nshort++;
node2=segmentx2->node1;
node3=segmentx2->node2;
/* Count the segments connected to N2 */
segmentx=FirstSegmentX(segmentsx,node2,4);
while(segmentx)
{
segcount2++;
if(segment1==NO_SEGMENT)
{
index_t segment=IndexSegmentX(segmentsx,segmentx);
if(segment!=segment2)
{
segment1=segment;
node1=OtherNode(segmentx,node2);
}
}
else if(segcount2>2)
break;
segmentx=NextSegmentX(segmentsx,segmentx,node2);
}
/* Count the segments connected to N3 */
segmentx=FirstSegmentX(segmentsx,node3,4);
while(segmentx)
{
segcount3++;
if(segment3==NO_SEGMENT)
{
index_t segment=IndexSegmentX(segmentsx,segmentx);
if(segment!=segment2)
{
segment3=segment;
node4=OtherNode(segmentx,node3);
}
}
else if(segcount3>2)
break;
segmentx=NextSegmentX(segmentsx,segmentx,node3);
}
/* Check which case we are handling (and canonicalise) */
if(segcount2>2 && segcount3>2) /* none of the cases in diagram - too complicated */
{
goto endloop;
}
else if(segcount2==1 || segcount3==1) /* first case in diagram - prune segment */
{
prune_segment(segmentsx,segmentx2);
}
else if(segcount2==2 && segcount3==2) /* second case in diagram - modify one segment and prune segment */
{
SegmentX *segmentx1,*segmentx3;
WayX *wayx1,*wayx2,*wayx3;
NodeX *nodex2,*nodex3,*newnodex;
index_t newnode;
int join12=1,join23=1;
/* Check if pruning would collapse a loop */
if(node1==node4)
goto endloop;
/* Check if allowed due to one-way properties */
segmentx1=LookupSegmentX(segmentsx,segment1,1);
segmentx3=LookupSegmentX(segmentsx,segment3,3);
if(!IsOneway(segmentx1) && !IsOneway(segmentx2))
;
else if(IsOneway(segmentx1) && IsOneway(segmentx2))
{
if(IsOnewayTo(segmentx1,node2) && !IsOnewayFrom(segmentx2,node2)) /* S1 is one-way but S2 doesn't continue */
join12=0;
if(IsOnewayFrom(segmentx1,node2) && !IsOnewayTo(segmentx2,node2)) /* S1 is one-way but S2 doesn't continue */
join12=0;
}
else
join12=0;
if(!IsOneway(segmentx3) && !IsOneway(segmentx2))
;
else if(IsOneway(segmentx3) && IsOneway(segmentx2))
{
if(IsOnewayTo(segmentx3,node3) && !IsOnewayFrom(segmentx2,node3)) /* S3 is one-way but S2 doesn't continue */
join23=0;
if(IsOnewayFrom(segmentx3,node3) && !IsOnewayTo(segmentx2,node3)) /* S3 is one-way but S2 doesn't continue */
join23=0;
}
else
join23=0;
if(!join12 && !join23)
goto endloop;
/* Check if allowed due to highway properties */
wayx1=LookupWayX(waysx,segmentx1->way,1);
wayx2=LookupWayX(waysx,segmentx2->way,2);
wayx3=LookupWayX(waysx,segmentx3->way,3);
if(WaysCompare(&wayx1->way,&wayx2->way))
join12=0;
if(WaysCompare(&wayx3->way,&wayx2->way))
join23=0;
if(!join12 && !join23)
goto endloop;
/* Check if allowed due to mini-roundabout and turn restriction */
nodex2=LookupNodeX(nodesx,node2,2);
nodex3=LookupNodeX(nodesx,node3,3);
if(nodex2->flags&NODE_MINIRNDBT)
join12=0;
if(nodex3->flags&NODE_MINIRNDBT)
join23=0;
if(!join12 && !join23)
goto endloop;
if(nodex2->flags&NODE_TURNRSTRCT2 || nodex2->flags&NODE_TURNRSTRCT)
join12=0;
if(nodex3->flags&NODE_TURNRSTRCT2 || nodex3->flags&NODE_TURNRSTRCT)
join23=0;
if(!join12 && !join23)
goto endloop;
/* New node properties */
if(join12)
{
newnode=node3;
newnodex=nodex3;
}
else /* if(join23) */
{
newnode=node2;
newnodex=nodex2;
}
newnodex->allow=nodex2->allow&nodex3->allow; /* combine the restrictions of the two nodes */
newnodex->allow&=~((~wayx2->way.allow)&wayx3->way.allow); /* disallow anything blocked by segment2 */
newnodex->allow&=~((~wayx2->way.allow)&wayx1->way.allow); /* disallow anything blocked by segment2 */
newnodex->latitude =(nodex2->latitude +nodex3->latitude )/2;
newnodex->longitude=(nodex2->longitude+nodex3->longitude)/2;
PutBackNodeX(nodesx,newnodex);
/* Modify segments */
segmentx1->distance+=DISTANCE(segmentx2->distance)/2;
segmentx3->distance+=DISTANCE(segmentx2->distance)-DISTANCE(segmentx2->distance)/2;
if(segmentx1->node1==node1)
{
if(segmentx1->node2!=newnode)
modify_segment(segmentsx,segmentx1,node1,newnode);
else
PutBackSegmentX(segmentsx,segmentx1);
}
else /* if(segmentx1->node2==node1) */
{
if(segmentx1->node1!=newnode)
modify_segment(segmentsx,segmentx1,newnode,node1);
else
PutBackSegmentX(segmentsx,segmentx1);
}
if(segmentx3->node1==node4)
{
if(segmentx3->node2!=newnode)
modify_segment(segmentsx,segmentx3,node4,newnode);
else
PutBackSegmentX(segmentsx,segmentx3);
}
else /* if(segmentx3->node2==node4) */
{
if(segmentx3->node1!=newnode)
modify_segment(segmentsx,segmentx3,newnode,node4);
else
PutBackSegmentX(segmentsx,segmentx3);
}
ReLookupSegmentX(segmentsx,segmentx2);
prune_segment(segmentsx,segmentx2);
}
else /* third case in diagram - prune one segment */
{
SegmentX *segmentx1;
WayX *wayx1,*wayx2;
NodeX *nodex2;
if(segcount3==2) /* not as in diagram, shuffle things round */
{
index_t temp;
temp=segment1; segment1=segment3; segment3=temp;
temp=node1; node1=node4; node4=temp;
temp=node2; node2=node3; node3=temp;
}
/* Check if pruning would collapse a loop */
if(node1==node3)
goto endloop;
/* Check if allowed due to one-way properties */
segmentx1=LookupSegmentX(segmentsx,segment1,1);
if(!IsOneway(segmentx1) && !IsOneway(segmentx2))
;
else if(IsOneway(segmentx1) && IsOneway(segmentx2))
{
if(IsOnewayTo(segmentx1,node2) && !IsOnewayFrom(segmentx2,node2)) /* S1 is one-way but S2 doesn't continue */
goto endloop;
if(IsOnewayFrom(segmentx1,node2) && !IsOnewayTo(segmentx2,node2)) /* S1 is one-way but S2 doesn't continue */
goto endloop;
}
else
goto endloop;
/* Check if allowed due to highway properties */
wayx1=LookupWayX(waysx,segmentx1->way,1);
wayx2=LookupWayX(waysx,segmentx2->way,2);
if(WaysCompare(&wayx1->way,&wayx2->way))
goto endloop;
/* Check if allowed due to mini-roundabout and turn restriction */
nodex2=LookupNodeX(nodesx,node2,2);
if(nodex2->flags&NODE_MINIRNDBT)
goto endloop;
if(nodex2->flags&NODE_TURNRSTRCT2 || nodex2->flags&NODE_TURNRSTRCT)
goto endloop;
/* Check if allowed due to node restrictions */
if((nodex2->allow&wayx1->way.allow)!=wayx1->way.allow)
goto endloop;
if((nodex2->allow&wayx2->way.allow)!=wayx2->way.allow)
goto endloop;
/* Modify segments */
segmentx1->distance+=DISTANCE(segmentx2->distance);
if(segmentx1->node1==node1)
modify_segment(segmentsx,segmentx1,node1,node3);
else /* if(segmentx1->node2==node1) */
modify_segment(segmentsx,segmentx1,node3,node1);
ReLookupSegmentX(segmentsx,segmentx2);
prune_segment(segmentsx,segmentx2);
}
npruned++;
}
endloop:
if(!((i+1)%10000))
printf_middle("Pruning Short Segments: Segments=%"Pindex_t" Short=%"Pindex_t" Pruned=%"Pindex_t,i+1,nshort,npruned);
}
/* Unmap from memory / close the files */
#if !SLIM
nodesx->data=UnmapFile(nodesx->data);
segmentsx->data=UnmapFile(segmentsx->data);
waysx->data=UnmapFile(waysx->data);
#else
nodesx->fd=SlimUnmapFile(nodesx->fd);
segmentsx->fd=SlimUnmapFile(segmentsx->fd);
waysx->fd=SlimUnmapFile(waysx->fd);
#endif
/* Print the final message */
printf_last("Pruned Short Segments: Segments=%"Pindex_t" Short=%"Pindex_t" Pruned=%"Pindex_t,segmentsx->number,nshort,npruned);
}
void PruneIsolatedRegions(NodesX *nodesx,SegmentsX *segmentsx,WaysX *waysx,distance_t minimum)
{
WaysX *newwaysx;
WayX tmpwayx;
transport_t transport;
BitMask *connected,*region;
index_t *regionsegments,*othersegments;
index_t nallocregionsegments,nallocothersegments;
if(nodesx->number==0 || segmentsx->number==0)
return;
/* Map into memory / open the files */
#if !SLIM
nodesx->data=MapFile(nodesx->filename_tmp);
segmentsx->data=MapFileWriteable(segmentsx->filename_tmp);
waysx->data=MapFile(waysx->filename_tmp);
#else
nodesx->fd=SlimMapFile(nodesx->filename_tmp);
segmentsx->fd=SlimMapFileWriteable(segmentsx->filename_tmp);
waysx->fd=SlimMapFile(waysx->filename_tmp);
InvalidateNodeXCache(nodesx->cache);
InvalidateSegmentXCache(segmentsx->cache);
InvalidateWayXCache(waysx->cache);
#endif
newwaysx=NewWayList(0,0);
CloseFileBuffered(newwaysx->fd);
newwaysx->fd=SlimMapFileWriteable(newwaysx->filename_tmp);
connected=AllocBitMask(segmentsx->number);
region =AllocBitMask(segmentsx->number);
logassert(connected,"Failed to allocate memory (try using slim mode?)"); /* Check AllocBitMask() worked */
logassert(region,"Failed to allocate memory (try using slim mode?)"); /* Check AllocBitMask() worked */
regionsegments=(index_t*)malloc((nallocregionsegments=1024)*sizeof(index_t));
othersegments =(index_t*)malloc((nallocothersegments =1024)*sizeof(index_t));
logassert(regionsegments,"Failed to allocate memory (try using slim mode?)"); /* Check malloc() worked */
logassert(othersegments,"Failed to allocate memory (try using slim mode?)"); /* Check malloc() worked */
/* Loop through the transport types */
for(transport=Transport_None+1;transport<Transport_Count;transport++)
{
index_t i,j;
index_t nregions=0,npruned=0,nadjusted=0;
const char *transport_str=TransportName(transport);
transports_t transports=TRANSPORTS(transport);
if(!(waysx->allow&transports))
continue;
/* Print the start message */
printf_first("Pruning Isolated Regions (%s): Segments=0 Adjusted=0 Pruned=0",transport_str);
/* Loop through the segments and find the disconnected ones */
ClearAllBits(connected,segmentsx->number);
ClearAllBits(region ,segmentsx->number);
for(i=0;i<segmentsx->number;i++)
{
index_t nregionsegments=0,nothersegments=0;
distance_t total=0;
SegmentX *segmentx;
WayX *wayx;
if(IsBitSet(connected,i))
goto endloop;
segmentx=LookupSegmentX(segmentsx,i,1);
if(IsPrunedSegmentX(segmentx))
goto endloop;
if(segmentx->way<waysx->number)
wayx=LookupWayX(waysx,segmentx->way,1);
else
SlimFetch(newwaysx->fd,(wayx=&tmpwayx),sizeof(WayX),(segmentx->way-waysx->number)*sizeof(WayX));
if(!(wayx->way.allow&transports))
goto endloop;
othersegments[nothersegments++]=i;
SetBit(region,i);
do
{
index_t thissegment,nodes[2];
thissegment=othersegments[--nothersegments];
if(nregionsegments==nallocregionsegments)
regionsegments=(index_t*)realloc(regionsegments,(nallocregionsegments+=1024)*sizeof(index_t));
regionsegments[nregionsegments++]=thissegment;
segmentx=LookupSegmentX(segmentsx,thissegment,1);
nodes[0]=segmentx->node1;
nodes[1]=segmentx->node2;
total+=DISTANCE(segmentx->distance);
for(j=0;j<2;j++)
{
NodeX *nodex=LookupNodeX(nodesx,nodes[j],1);
if(!(nodex->allow&transports))
continue;
segmentx=FirstSegmentX(segmentsx,nodes[j],1);
while(segmentx)
{
index_t segment=IndexSegmentX(segmentsx,segmentx);
if(segment!=thissegment)
{
if(segmentx->way<waysx->number)
wayx=LookupWayX(waysx,segmentx->way,1);
else
SlimFetch(newwaysx->fd,(wayx=&tmpwayx),sizeof(WayX),(segmentx->way-waysx->number)*sizeof(WayX));
if(wayx->way.allow&transports)
{
/* Already connected - finish */
if(IsBitSet(connected,segment))
{
total=minimum;
goto foundconnection;
}
/* Not in region - add to list */
if(!IsBitSet(region,segment))
{
if(nothersegments==nallocothersegments)
othersegments=(index_t*)realloc(othersegments,(nallocothersegments+=1024)*sizeof(index_t));
othersegments[nothersegments++]=segment;
SetBit(region,segment);
}
}
}
segmentx=NextSegmentX(segmentsx,segmentx,nodes[j]);
}
}
}
while(nothersegments>0 && total<minimum);
foundconnection:
/* Prune the segments or mark them as connected */
if(total<minimum) /* not connected - delete them */
{
nregions++;
for(j=0;j<nregionsegments;j++)
{
SegmentX *segmentx;
WayX *wayx,tmpwayx;
SetBit(connected,regionsegments[j]); /* not really connected, but don't need to check again */
ClearBit(region,regionsegments[j]);
segmentx=LookupSegmentX(segmentsx,regionsegments[j],1);
if(segmentx->way<waysx->number)
wayx=LookupWayX(waysx,segmentx->way,1);
else
SlimFetch(newwaysx->fd,(wayx=&tmpwayx),sizeof(WayX),(segmentx->way-waysx->number)*sizeof(WayX));
if(wayx->way.allow==transports)
{
prune_segment(segmentsx,segmentx);
npruned++;
}
else
{
if(segmentx->way<waysx->number) /* create a new way */
{
tmpwayx=*wayx;
tmpwayx.way.allow&=~transports;
segmentx->way=waysx->number+newwaysx->number;
SlimReplace(newwaysx->fd,&tmpwayx,sizeof(WayX),(segmentx->way-waysx->number)*sizeof(WayX));
newwaysx->number++;
PutBackSegmentX(segmentsx,segmentx);
}
else /* modify the existing one */
{
tmpwayx.way.allow&=~transports;
SlimReplace(newwaysx->fd,&tmpwayx,sizeof(WayX),(segmentx->way-waysx->number)*sizeof(WayX));
}
nadjusted++;
}
}
}
else /* connected - mark as part of the main region */
{
for(j=0;j<nregionsegments;j++)
{
SetBit(connected,regionsegments[j]);
ClearBit(region,regionsegments[j]);
}
for(j=0;j<nothersegments;j++)
{
SetBit(connected,othersegments[j]);
ClearBit(region,othersegments[j]);
}
}
endloop:
if(!((i+1)%10000))
printf_middle("Pruning Isolated Regions (%s): Segments=%"Pindex_t" Adjusted=%"Pindex_t" Pruned=%"Pindex_t" (%"Pindex_t" Regions)",transport_str,i+1,nadjusted,npruned,nregions);
}
/* Print the final message */
printf_last("Pruned Isolated Regions (%s): Segments=%"Pindex_t" Adjusted=%"Pindex_t" Pruned=%"Pindex_t" (%"Pindex_t" Regions)",transport_str,segmentsx->number,nadjusted,npruned,nregions);
}
/* Unmap from memory / close the files */
free(region);
free(connected);
free(regionsegments);
free(othersegments);
#if !SLIM
nodesx->data=UnmapFile(nodesx->data);
segmentsx->data=UnmapFile(segmentsx->data);
waysx->data=UnmapFile(waysx->data);
#else
nodesx->fd=SlimUnmapFile(nodesx->fd);
segmentsx->fd=SlimUnmapFile(segmentsx->fd);
waysx->fd=SlimUnmapFile(waysx->fd);
#endif
SlimUnmapFile(newwaysx->fd);
waysx->number+=newwaysx->number;
waysx->fd=OpenFileBufferedAppend(waysx->filename_tmp);
newwaysx->fd=ReOpenFileBuffered(newwaysx->filename_tmp);
while(!ReadFileBuffered(newwaysx->fd,&tmpwayx,sizeof(WayX)))
WriteFileBuffered(waysx->fd,&tmpwayx,sizeof(WayX));
CloseFileBuffered(waysx->fd);
CloseFileBuffered(newwaysx->fd);
FreeWayList(newwaysx,0);
}
bool capture_is_good(int move, const board_t * board, bool in_pv) {
#else
static bool capture_is_good(int move, const board_t * board, bool in_pv) {
#endif
int piece, capture;
int see_value; // WHM 11/22/08
ASSERT(move_is_ok(move));
ASSERT(board!=NULL);
ASSERT(move_is_tactical(move,board));
// special cases
if (MOVE_IS_EN_PASSANT(move)) return true;
if (move_is_under_promote(move)) return false; // REMOVE ME? Keep, looks good to me. WHM;
// if (MOVE_IS_PROMOTE(move)) return true; // WHM; promote-to-queen, measures a little weaker
// too many garbage lines going nuts.
// captures and queen promotes
capture = board->square[MOVE_TO(move)];
piece = board->square[MOVE_FROM(move)];
if (capture != Empty) {
// capture
ASSERT(move_is_capture(move,board));
if (MOVE_IS_PROMOTE(move)) return true; // capture a piece on Rank8 and promote to queen
if (VALUE_PIECE(capture) >= VALUE_PIECE(piece)) return true;
}
// return see_move(move,board) >= 0; WHM 11/22/08
// WHM 11/22/08 START
see_value = see_move(move,board);
if (see_value >= 0) return true;
if (TryNodePVQueenPromotes) {
if (in_pv && MOVE_IS_PROMOTE(move)) {
ASSERT(!move_is_under_promote(move));
return true; // WHM:
}
}
if (TryKingAttackSacs || TryKingBoxSacs || TryPasserSacs) {
if (in_pv && see_value > -ValueBishop && capture != Empty) {
ASSERT(COLOUR_IS(capture,COLOUR_OPP(board->turn)));
// king attack sacs.
if (TryKingAttackSacs) {
if (narrow_piece_attack_king(board, piece, MOVE_TO(move), KING_POS(board,COLOUR_OPP(board->turn)))) {
return true;
}
}
// sacrifice attacks around the narrow/close king box can be examined more fully. Rybka lessons.
if (TryKingBoxSacs) {
if (DISTANCE(MOVE_TO(move),KING_POS(board,COLOUR_OPP(board->turn))) <= 1) {
return true;
}
}
// passer sacrifices...
if (TryPasserSacs) {
if (PIECE_IS_PAWN(capture) && PAWN_RANK(MOVE_TO(move),COLOUR_OPP(board->turn)) >= Rank6) {
return true;
}
}
}
} // WHM 11/22/08 END
return false;
}
daemon
runners(daemon_arg *arg)
{
struct linked_list *item;
struct thing *tp;
NOOP(arg);
for (item = mlist; item != NULL; item = next_mons)
{
curr_mons = item;
next_mons = next(curr_mons);
tp = THINGPTR(item);
if (on(*tp, ISHELD) && rnd(tp->t_stats.s_str +
tp->t_stats.s_lvl) > 10 + rnd(50))
{
turn_off(*tp, ISHELD);
turn_off(*tp, ISDISGUISE);
turn_on(*tp, ISRUN);
tp->t_ischasing = TRUE;
tp->t_chasee = &player;
tp->t_horde = NULL;
if (tp->t_stats.s_hpt < rnd(tp->maxstats.s_hpt))
turn_on(*tp, ISFLEE);
if (cansee(tp->t_pos.y, tp->t_pos.x))
msg("The %s breaks free!", monsters[tp->t_index].m_name);
}
if (off(*tp, ISHELD) && on(*tp, ISRUN))
{
int flee = FALSE;
flee = on(*tp, ISFLEE) ||
( (tp->t_chasee == &player) &&
on(player, ISINWALL) &&
off(*tp, CANINWALL) && off(*tp, ISFAMILIAR) );
if (off(*tp, ISSLOW) || tp->t_turn)
{
daemon_arg targ;
targ.thingptr = tp;
doctor(&targ);
do_chase(tp, flee);
}
if (curr_mons && (on(*tp, ISHASTE) ||
((on(*tp, CANFLY) || on(*tp, ISFAST)) &&
DISTANCE(hero, tp->t_pos) >= 4)))
{
daemon_arg targ;
targ.thingptr = tp;
doctor(&targ);
do_chase(tp, flee);
}
if (curr_mons)
{
tp->t_turn ^= TRUE;
tp->t_wasshot ^= FALSE; /* Not shot anymore */
}
}
}
curr_mons = next_mons = NULL;
return;
}
int
do_chase(struct thing *th)
{
struct room *rer, *ree; /* room of chaser, room of chasee */
int mindist = 32767, i, dist;
int stoprun = FALSE; /* TRUE means we are there */
int sch;
coord this; /* Temporary destination for chaser */
rer = roomin(&th->t_pos); /* Find room of chaser */
ree = roomin(th->t_dest); /* Find room of chasee */
/*
* We don't count doors as inside rooms for this routine
*/
if (CMVWINCH(stdscr, th->t_pos.y, th->t_pos.x) == DOOR)
rer = NULL;
this = *th->t_dest;
/*
* If the object of our desire is in a different room,
* than we are and we ar not in a corridor, run to the
* door nearest to our goal.
*/
if (rer != NULL && rer != ree)
for (i = 0; i < rer->r_nexits; i++) /* loop through doors */
{
dist = DISTANCE(th->t_dest->y, th->t_dest->x,
rer->r_exit[i].y, rer->r_exit[i].x);
if (dist < mindist) /* minimize distance */
{
this = rer->r_exit[i];
mindist = dist;
}
}
/*
* this now contains what we want to run to this time
* so we run to it. If we hit it we either want to fight it
* or stop running
*/
if (!chase(th, &this))
{
if (ce(this, hero))
{
return( attack(th) );
}
else if (th->t_type != 'F')
stoprun = TRUE;
}
else if (th->t_type == 'F')
return(0);
mvwaddrawch(cw, th->t_pos.y, th->t_pos.x, th->t_oldch);
sch = CMVWINCH(cw, ch_ret.y, ch_ret.x);
if (rer != NULL && (rer->r_flags & ISDARK) && sch == FLOOR
&& DISTANCE(ch_ret.y, ch_ret.x, th->t_pos.y, th->t_pos.x) < 3
&& off(player, ISBLIND))
th->t_oldch = ' ';
else
th->t_oldch = sch;
if (cansee(unc(ch_ret)) && !on(*th, ISINVIS))
mvwaddrawch(cw, ch_ret.y, ch_ret.x, th->t_type);
mvwaddrawch(mw, th->t_pos.y, th->t_pos.x, ' ');
mvwaddrawch(mw, ch_ret.y, ch_ret.x, th->t_type);
th->t_pos = ch_ret;
/*
* And stop running if need be
*/
if (stoprun && ce(th->t_pos, *(th->t_dest)))
th->t_flags &= ~ISRUN;
return(0);
}
