int dosearch(void)
{
xchar x, y;
struct trap *trap;
struct monst *mtmp;
if (u.uswallow)
pline("What are you looking for? The exit?");
else
for (x = u.ux - 1; x < u.ux + 2; x++)
for (y = u.uy - 1; y < u.uy + 2; y++)
if (x != u.ux || y != u.uy) {
if (levl[x][y].typ == SDOOR) {
if (rn2(7))
continue;
levl[x][y].typ = DOOR;
levl[x][y].seen = 0; // force prl
prl(x, y);
nomul(0);
} else if (levl[x][y].typ == SCORR) {
if (rn2(7))
continue;
levl[x][y].typ = CORR;
levl[x][y].seen = 0; // force prl
prl(x, y);
nomul(0);
} else {
// Be careful not to find anything in an SCORR or SDOOR
if ((mtmp = m_at(x, y)) != NULL) {
if (mtmp->mimic) {
seemimic(mtmp);
pline("You find a mimic.");
return 1;
}
}
for (trap = ftrap; trap; trap = trap->ntrap) {
if (trap->tx == x && trap->ty == y && !trap->tseen && !rn2(8)) {
nomul(0);
pline("You find a%s.", traps[trap->ttyp]);
if (trap->ttyp == PIERC) {
deltrap(trap);
(void) makemon(PM_PIERCER, x, y);
return 1;
}
trap->tseen = 1;
if (!vism_at(x, y))
atl(x, y, '^');
}
}
}
}
return 1;
}
/* no texts here! */
void
fracture_rock(struct obj *obj)
{
obj->otyp = ROCK;
obj->quan = 7 + rn2(60);
obj->owt = weight(obj);
obj->olet = WEAPON_SYM;
if (cansee(obj->ox, obj->oy))
prl(obj->ox, obj->oy);
}
void
fracture_rock(struct obj *obj) /* fractured by pick-axe or wand of striking */
/* no texts here! */
{
obj->otyp = ROCK;
obj->quan = 7 + rn2(60);
obj->owt = weight(obj);
obj->olet = WEAPON_SYM;
if(cansee(obj->ox,obj->oy))
prl(obj->ox,obj->oy);
}
// ok, the SDOOR/SCORR part works. however, none of the rest is tested
// (traps, mimics, swallowed, etc)
void do_search() // was dosearch
{
Int8 x,y;
trap_t *trap;
monst_t *mtmp;
UChar floor_type, tmp_type;
if (you.uswallow) {
message("What are you looking for? The exit?");
return;
}
for (x = you.ux - 1 ; x <= you.ux + 1 ; x++)
for (y = you.uy - 1 ; y <= you.uy + 1 ; y++) {
if (x == you.ux && y == you.uy) continue;
floor_type = get_cell_type(floor_info[x][y]);
if (floor_type == SDOOR || floor_type == SCORR) {
if (rund(7)) continue;
tmp_type = (floor_type == SDOOR) ? DOOR : CORR;
set_cell_type(floor_info[x][y], tmp_type);
floor_info[x][y] &= ~SEEN_CELL; /* force prl */
prl(x,y);
nomul(0);
} else {
/* Be careful not to find anything in an SCORR or SDOOR */
mtmp = mon_at(x,y);
if (mtmp && (mtmp->bitflags & M_IS_MIMIC)) {
see_mimic(mtmp);
message("You find a mimic.");
return;
}
for (trap = ftrap ; trap ; trap = trap->ntrap)
if (trap->tx == x && trap->ty == y &&
!(get_trap_seen(trap->trap_info)) && !rund(8)) {
nomul(0);
tmp_type = get_trap_type(trap->trap_info);
StrPrintF(ScratchBuffer, "You find a%s.", traps[tmp_type]);
message(ScratchBuffer);
if (tmp_type == PIERC) {
deltrap(trap);
makemon(PM_PIERCER, x, y);
return;
}
trap->trap_info |= SEEN_TRAP;
if (!vism_at(x,y))
print(x, y, '^');
}
}
}
}
int
gd_move()
{
int x,y,dx,dy,gx,gy,nx,ny,typ;
struct fakecorridor *fcp;
struct rm *crm;
if(!guard || gdlevel != dlevel){
impossible("Where is the guard?");
return(2); /* died */
}
if(u.ugold || goldincorridor())
return(0); /* didnt move */
if(dist(guard->mx,guard->my) > 1 || EGD->gddone) {
restfakecorr();
return(0); /* didnt move */
}
x = guard->mx;
y = guard->my;
/* look around (hor & vert only) for accessible places */
for(nx = x-1; nx <= x+1; nx++) for(ny = y-1; ny <= y+1; ny++) {
if(nx == x || ny == y) if(nx != x || ny != y)
if(isok(nx,ny))
if(!IS_WALL(typ = (crm = &levl[nx][ny])->typ) && typ != POOL) {
int i;
for(i = EGD->fcbeg; i < EGD->fcend; i++)
if(EGD->fakecorr[i].fx == nx &&
EGD->fakecorr[i].fy == ny)
goto nextnxy;
if((i = inroom(nx,ny)) >= 0 && rooms[i].rtype == VAULT)
goto nextnxy;
/* seems we found a good place to leave him alone */
EGD->gddone = 1;
if(ACCESSIBLE(typ)) goto newpos;
crm->typ = (typ == SCORR) ? CORR : DOOR;
goto proceed;
}
nextnxy: ;
}
nx = x;
ny = y;
gx = EGD->gdx;
gy = EGD->gdy;
dx = (gx > x) ? 1 : (gx < x) ? -1 : 0;
dy = (gy > y) ? 1 : (gy < y) ? -1 : 0;
if(abs(gx-x) >= abs(gy-y)) nx += dx; else ny += dy;
while((typ = (crm = &levl[nx][ny])->typ) != 0) {
/* in view of the above we must have IS_WALL(typ) or typ == POOL */
/* must be a wall here */
if(isok(nx+nx-x,ny+ny-y) && typ != POOL &&
ZAP_POS(levl[nx+nx-x][ny+ny-y].typ)){
crm->typ = DOOR;
goto proceed;
}
if(dy && nx != x) {
nx = x; ny = y+dy;
continue;
}
if(dx && ny != y) {
ny = y; nx = x+dx; dy = 0;
continue;
}
/* I don't like this, but ... */
crm->typ = DOOR;
goto proceed;
}
crm->typ = CORR;
proceed:
if(cansee(nx,ny)) {
mnewsym(nx,ny);
prl(nx,ny);
}
fcp = &(EGD->fakecorr[EGD->fcend]);
if(EGD->fcend++ == FCSIZ) panic("fakecorr overflow");
fcp->fx = nx;
fcp->fy = ny;
fcp->ftyp = typ;
newpos:
if(EGD->gddone) nx = ny = 0;
guard->mx = nx;
guard->my = ny;
pmon(guard);
restfakecorr();
return(1);
}
int
dothrow()
{
struct obj *obj;
struct monst *mon;
int tmp;
obj = getobj("#)", "throw"); /* it is also possible to throw food */
/* (or jewels, or iron balls ... ) */
if(!obj || !getdir(1)) /* ask "in what direction?" */
return(0);
if(obj->owornmask & (W_ARMOR | W_RING)){
pline("You can't throw something you are wearing.");
return(0);
}
u_wipe_engr(2);
if(obj == uwep){
if(obj->cursed){
pline("Your weapon is welded to your hand.");
return(1);
}
if(obj->quan > 1)
setuwep(splitobj(obj, 1));
else
setuwep((struct obj *) 0);
}
else if(obj->quan > 1)
(void) splitobj(obj, 1);
freeinv(obj);
if(u.uswallow) {
mon = u.ustuck;
bhitpos.x = mon->mx;
bhitpos.y = mon->my;
} else if(u.dz) {
if(u.dz < 0) {
pline("%s hits the ceiling, then falls back on top of your head.",
Doname(obj)); /* note: obj->quan == 1 */
if(obj->olet == POTION_SYM)
potionhit(&youmonst, obj);
else {
if(uarmh) pline("Fortunately, you are wearing a helmet!");
losehp(uarmh ? 1 : rnd((int)(obj->owt)), "falling object");
dropy(obj);
}
} else {
pline("%s hits the floor.", Doname(obj));
if(obj->otyp == EXPENSIVE_CAMERA) {
pline("It is shattered in a thousand pieces!");
obfree(obj, Null(obj));
} else if(obj->otyp == EGG) {
pline("\"Splash!\"");
obfree(obj, Null(obj));
} else if(obj->olet == POTION_SYM) {
pline("The flask breaks, and you smell a peculiar odor ...");
potionbreathe(obj);
obfree(obj, Null(obj));
} else {
dropy(obj);
}
}
return(1);
} else if(obj->otyp == BOOMERANG) {
mon = boomhit(u.dx, u.dy);
if(mon == &youmonst) { /* the thing was caught */
(void) addinv(obj);
return(1);
}
} else {
if(obj->otyp == PICK_AXE && shkcatch(obj))
return(1);
mon = bhit(u.dx, u.dy, (obj->otyp == ICE_BOX) ? 1 :
(!Punished || obj != uball) ? 8 : !u.ustuck ? 5 : 1,
obj->olet, NULL, NULL, obj);
}
if(mon) {
/* awake monster if sleeping */
wakeup(mon);
if(obj->olet == WEAPON_SYM) {
tmp = -1+u.ulevel+mon->data->ac+abon();
if(obj->otyp < ROCK) {
if(!uwep ||
uwep->otyp != obj->otyp+(BOW-ARROW))
tmp -= 4;
else {
tmp += uwep->spe;
}
} else
if(obj->otyp == BOOMERANG) tmp += 4;
tmp += obj->spe;
if(u.uswallow || tmp >= rnd(20)) {
if(hmon(mon,obj,1) == TRUE){
/* mon still alive */
#ifndef NOWORM
cutworm(mon,bhitpos.x,bhitpos.y,obj->otyp);
#endif /* NOWORM */
} else mon = 0;
/* weapons thrown disappear sometimes */
if(obj->otyp < BOOMERANG && rn2(3)) {
/* check bill; free */
obfree(obj, (struct obj *) 0);
return(1);
}
} else miss(objects[obj->otyp].oc_name, mon);
} else if(obj->otyp == HEAVY_IRON_BALL) {
tmp = -1+u.ulevel+mon->data->ac+abon();
if(!Punished || obj != uball) tmp += 2;
if(u.utrap) tmp -= 2;
if(u.uswallow || tmp >= rnd(20)) {
if(hmon(mon,obj,1) == FALSE)
mon = 0; /* he died */
} else miss("iron ball", mon);
} else if(obj->olet == POTION_SYM && u.ulevel > rn2(15)) {
potionhit(mon, obj);
return(1);
} else {
if(cansee(bhitpos.x,bhitpos.y))
pline("You miss %s.",monnam(mon));
else pline("You miss it.");
if(obj->olet == FOOD_SYM && mon->data->mlet == 'd')
if(tamedog(mon,obj)) return(1);
if(obj->olet == GEM_SYM && mon->data->mlet == 'u' &&
!mon->mtame){
if(obj->dknown && objects[obj->otyp].oc_name_known){
if(objects[obj->otyp].g_val > 0){
u.uluck += 5;
goto valuable;
} else {
pline("%s is not interested in your junk.",
Monnam(mon));
}
} else { /* value unknown to @ */
u.uluck++;
valuable:
if(u.uluck > LUCKMAX) /* dan@ut-ngp */
u.uluck = LUCKMAX;
pline("%s graciously accepts your gift.",
Monnam(mon));
mpickobj(mon, obj);
rloc(mon);
return(1);
}
}
}
}
/* the code following might become part of dropy() */
if(obj->otyp == CRYSKNIFE)
obj->otyp = WORM_TOOTH;
obj->ox = bhitpos.x;
obj->oy = bhitpos.y;
obj->nobj = fobj;
fobj = obj;
/* prevent him from throwing articles to the exit and escaping */
/* subfrombill(obj); */
stackobj(obj);
if(Punished && obj == uball &&
(bhitpos.x != u.ux || bhitpos.y != u.uy)){
freeobj(uchain);
unpobj(uchain);
if(u.utrap){
if(u.utraptype == TT_PIT)
pline("The ball pulls you out of the pit!");
else {
long side =
rn2(3) ? LEFT_SIDE : RIGHT_SIDE;
pline("The ball pulls you out of the bear trap.");
pline("Your %s leg is severely damaged.",
(side == LEFT_SIDE) ? "left" : "right");
set_wounded_legs(side, 500+rn2(1000));
losehp(2, "thrown ball");
}
u.utrap = 0;
}
unsee();
uchain->nobj = fobj;
fobj = uchain;
u.ux = uchain->ox = bhitpos.x - u.dx;
u.uy = uchain->oy = bhitpos.y - u.dy;
setsee();
(void) inshop();
}
if(cansee(bhitpos.x, bhitpos.y)) prl(bhitpos.x,bhitpos.y);
return(1);
}
int
main(int argc, char *argv[])
{
myargc = argc;
myargv = argv;
prl(&ENCA_LANGUAGE_BE, "macwin isokoi 855866");
prl(&ENCA_LANGUAGE_BG, "1251mac");
prl(&ENCA_LANGUAGE_CS, "isowin 852kam");
prl(&ENCA_LANGUAGE_ET, "");
prl(&ENCA_LANGUAGE_HR, "isowin");
prl(&ENCA_LANGUAGE_HU, "isocork isowin[XXX]");
prl(&ENCA_LANGUAGE_LT, "winbalt lat4balt iso13win[XXX]");
prl(&ENCA_LANGUAGE_LV, "winbalt iso13win[XXX]");
prl(&ENCA_LANGUAGE_PL, "isowin balt13");
prl(&ENCA_LANGUAGE_RU, "macwin");
prl(&ENCA_LANGUAGE_SK, "isowin 852kam");
prl(&ENCA_LANGUAGE_SL, "");
prl(&ENCA_LANGUAGE_UK, "macwin isokoi ibm1125");
return 0;
}
void Text::RemoveProperty( short sprm, void* operand )
{
Prl prl( sprm, reinterpret_cast<unsigned char*>( operand ) );
properties.remove( prl );
}
void Text::AddProperty (short sprm, void* operand)
{
Prl prl( sprm, reinterpret_cast<unsigned char*>( operand ) );
properties.push_back( prl );
}
Module::ReturnType SubgraphPlanarizerUML::doCall(
PlanRepUML &pr,
int cc,
const EdgeArray<int> *pCostOrig,
int &crossingNumber)
{
OGDF_ASSERT(m_permutations >= 1);
PlanarSubgraphModule &subgraph = m_subgraph.get();
UMLEdgeInsertionModule &inserter = m_inserter.get();
unsigned int nThreads = min(m_maxThreads, (unsigned int)m_permutations);
int64_t startTime;
System::usedRealTime(startTime);
int64_t stopTime = (m_timeLimit >= 0) ? (startTime + int64_t(1000.0*m_timeLimit)) : -1;
//
// Compute subgraph
//
if(m_setTimeout)
subgraph.timeLimit(m_timeLimit);
pr.initCC(cc);
// gather generalization edges, which should all be in the planar subgraph
List<edge> preferedEdges;
for(edge e : pr.edges) {
if (pr.typeOf(e) == Graph::generalization)
preferedEdges.pushBack(e);
}
List<edge> delEdges;
ReturnType retValue;
if(pCostOrig) {
EdgeArray<int> costPG(pr);
for(edge e : pr.edges)
costPG[e] = (*pCostOrig)[pr.original(e)];
retValue = subgraph.call(pr, costPG, preferedEdges, delEdges);
} else
retValue = subgraph.call(pr, preferedEdges, delEdges);
if(isSolution(retValue) == false)
return retValue;
const int m = delEdges.size();
for(ListIterator<edge> it = delEdges.begin(); it.valid(); ++it)
*it = pr.original(*it);
//
// Permutation phase
//
int seed = rand();
minstd_rand rng(seed);
if(nThreads > 1) {
//
// Parallel implementation
//
ThreadMaster master(
pr, cc,
pCostOrig,
delEdges,
seed,
m_permutations - nThreads,
stopTime);
Array<Worker *> worker(nThreads-1);
Array<Thread> thread(nThreads-1);
for(unsigned int i = 0; i < nThreads-1; ++i) {
worker[i] = new Worker(i, &master, inserter.clone());
thread[i] = Thread(*worker[i]);
}
doWorkHelper(master, inserter, rng);
for(unsigned int i = 0; i < nThreads-1; ++i) {
thread[i].join();
delete worker[i];
}
master.restore(pr, crossingNumber);
} else {
//
// Sequential implementation
//
PlanRepLight prl(pr);
Array<edge> deletedEdges(m);
int j = 0;
for(ListIterator<edge> it = delEdges.begin(); it.valid(); ++it)
deletedEdges[j++] = *it;
bool foundSolution = false;
CrossingStructure cs;
for(int i = 1; i <= m_permutations; ++i)
{
int cr;
bool ok = doSinglePermutation(prl, cc, pCostOrig, deletedEdges, inserter, rng, cr);
if(ok && (foundSolution == false || cr < cs.weightedCrossingNumber())) {
foundSolution = true;
cs.init(prl, cr);
}
if(stopTime >= 0 && System::realTime() >= stopTime) {
if(foundSolution == false)
return retTimeoutInfeasible; // not able to find a solution...
break;
}
}
cs.restore(pr,cc); // restore best solution in PG
crossingNumber = cs.weightedCrossingNumber();
OGDF_ASSERT(isPlanar(pr) == true);
}
return retFeasible;
}
static int
dig()
{
struct rm *lev;
int dpx = dig_pos.x, dpy = dig_pos.y;
/* perhaps a nymph stole his pick-axe while he was busy digging */
/* or perhaps he teleported away */
if(u.uswallow || !uwep || uwep->otyp != PICK_AXE ||
dig_level != dlevel ||
((dig_down && (dpx != u.ux || dpy != u.uy)) ||
(!dig_down && dist(dpx,dpy) > 2)))
return(0);
dig_effort += 10 + abon() + uwep->spe + rn2(5);
if(dig_down) {
if(!xdnstair) {
pline("The floor here seems too hard to dig in.");
return(0);
}
if(dig_effort > 250) {
dighole();
return(0); /* done with digging */
}
if(dig_effort > 50) {
struct trap *ttmp = t_at(dpx,dpy);
if(!ttmp) {
ttmp = maketrap(dpx,dpy,PIT);
ttmp->tseen = 1;
pline("You have dug a pit.");
u.utrap = rn1(4,2);
u.utraptype = TT_PIT;
return(0);
}
}
} else
if (dig_effort > 100) {
char *digtxt;
struct obj *obj;
lev = &levl[dpx][dpy];
if ((obj = sobj_at(ENORMOUS_ROCK, dpx, dpy))) {
fracture_rock(obj);
digtxt = "The rock falls apart.";
} else if(!lev->typ || lev->typ == SCORR) {
lev->typ = CORR;
digtxt = "You succeeded in cutting away some rock.";
} else if(lev->typ == HWALL || lev->typ == VWALL
|| lev->typ == SDOOR) {
lev->typ = xdnstair ? DOOR : ROOM;
digtxt = "You just made an opening in the wall.";
} else
digtxt = "Now what exactly was it that you were digging in?";
mnewsym(dpx, dpy);
prl(dpx, dpy);
pline(digtxt); /* after mnewsym & prl */
return(0);
} else {
if(IS_WALL(levl[dpx][dpy].typ)) {
int rno = inroom(dpx,dpy);
if(rno >= 0 && rooms[rno].rtype >= 8) {
pline("This wall seems too hard to dig into.");
return(0);
}
}
pline("You hit the rock with all your might.");
}
return(1);
}
