void MoveMap(Map *map)
{
Object *o = TO_OBJECT(GetPlayer());
float x = CX(o);
float y = CY(o);
float width = (float)ENGINE_WIDTH;
float height = (float)ENGINE_HEIGTH;
if (x + width / 2.0f > map->width * BLOCK_WIDTH) {
map->x = map->width * BLOCK_WIDTH - width;
}
if (x - width / 2.0f >= 0 &&
x + width / 2.0f < map->width * BLOCK_WIDTH) {
map->x = x - width / 2.0f;
}
/*
if (y + height / 2.0f > map->height * BLOCK_HEIGHT) {
map->y = map->height * BLOCK_HEIGHT - height;
}
if (y - height / 2.0f >= 0 &&
y + height / 2.0f < map->height * BLOCK_HEIGHT) {
map->y = y - height / 2.0f;
}
*/
}
void on_paint( object painter ) {
int point, ix, iy;
mapping sp;
sp = query_spots();
foreach( point : sp ) {
if( CX(point) > environment()->query_map_xdim() ||
CY(point) > environment()->query_map_ydim() ) {
remove_spot(point);
continue;
}
painter->paint( CX(point), CY(point), '*', query_active()?11:8, LAYER_TERRAIN );
}
}
/** Draw the exit. This adds the capability of drawing a closed (+) door.
*/
void on_paint( object painter ) {
int p;
mapping draw_shape = MCALL(exit_shape());
if( !draw_shape ) return;
foreach( p : draw_shape )
painter->paint( CX(p)-4096, CY(p)-4096, query_dir()=="up"?'<':'>', 0x0F, LAYER_ROUGH );
}
int check_direction( int dir ) {
int pos, tile;
if( !dir ) {
msg("You have to specify a direction when building a mine (i.e. 'build mine to the north').");
return -1;
}
set_direction(SINVERT_C(dir));
// Multiply up.
dir = SMAKE_C(SCX(dir)*5, SCY(dir)*3, 0);
pos = OFFSET_C(this_player()->query_coord(), dir);
// Snap to grid
pos = MAKE_C(((CX(pos)-1) / 5) * 5 + 1, ((CY(pos)-1) / 3) * 3 + 1, 0);
// Now check to see if the tiletype is valid. Query the center of the tile
// to make life a bit easier.
tile = environment(this_player())->get_tiletype(CX(pos)+2, CY(pos)+1);
if( !tile ) {
msg("You can't build off the edge of the map.");
return -1;
}
tile -= '0'; // get_tiletype uses the zbuffer, which offsets by '0' ...
if( tile != LAYER_MOUNTAIN ) {
//debug("tile=="+as_string(tile)+", pos = "+MAKE_CSTR(pos));
msg( "Mines must be built against a mountain face. Find a mountainous place." );
return -1;
}
// Offset horizontally a bit to make the entrance stick out...
if( SCX(dir) )
pos = OFFSET_C(pos, SMAKE_C(-SCX(dir) / 5,0,0));
// If facing south, adjust to find the entrance.
// The mountain tiles have funny patterns, and this helps
// to compensate.
if( query_direction() == SMAKE_C(0,1,0) ) {
pos = MAKE_C(CX(pos), CY(pos)-1, CZ(pos) );
while( environment(this_player())->get_tiletype(CX(pos)+2, CY(pos)+3) == '0' + LAYER_MOUNTAIN ) {
pos = MAKE_C(CX(pos),CY(pos)+1,CZ(pos));
}
}
// This is a north-facing version to snug the mine up as close as it can go.
if( query_direction() == SMAKE_C(0,-1,0) ) {
pos = MAKE_C(CX(pos), CY(pos)-1, CZ(pos) );
while( environment(this_player())->get_tiletype(CX(pos)+2, CY(pos)) != '0' + LAYER_MOUNTAIN ) {
pos = MAKE_C(CX(pos),CY(pos)+1,CZ(pos));
}
}
set_coord( pos );
return 0;
}
void on_map_paint( object painter ) {
int point;
mapping wallmap;
wallmap = query_spots();
foreach( point : wallmap ) {
painter->paint_shape( CX(point), CY(point), ">--->\n>--->\n>--->", 0x70, LAYER_TERRAIN );
}
}
void on_map_paint( object painter ) {
int ipos;
foreach( ipos : query_spots() ) {
painter->paint( query_x() + CX(ipos),
query_y() + CY(ipos),
'#',
0x03,
LAYER_WALL );
}
}
void Demos::CK_logo(Adafruit_SSD1306& d)
{
#define K 1024 // wave // scale ofs
#define CX(x) { x = w-cx; x = ( (x*(K +ax*Cos(8*w +tt[0])/SY*Sin(7*w +tt[1])/SY) /K) +cx)/8 +6; }
#define CY(y) { y = w-cy; y = ( (y*(K +ay*Cos(9*w+ x*73+tt[2])/SY*Sin(6*w+ x*52+tt[3])/SY) /K) +cy)/9 -1; }
const uint tt[4] = {t*7,t*5,t*8,t*5};
for (int w2=0; w2<2; ++w2)
{
const int cx = cw[ckCur][w2], cy = cw[ckCur][2+w2],
ax = cw[ckCur][4+w2], ay = cw[ckCur][6+w2];
int a=0,w, i=0,rst=1,
x1=0,y1=0,x=0,y=0;
do
{ w = w2 ? word2[a++] : word1[a++];
if (w<=0) { rst=1; i=0; }
else
if (rst) switch(i)
{ case 0: CX(x) ++i; break;
case 1: CY(y) rst=0; i=0; break; }
else switch(i)
{ case 0: x1=x; CX(x) ++i; break;
case 1: y1=y; CY(y) i=2; break; }
if (i==2)
{ i=0; d.drawLine(x1,y1, x,y, WHITE); }
}
while (w >= 0);
}
if (iInfo > 0)
{
d.setCursor(0,8);
d.print("Cur "); d.println(ckCur);
d.print("Spd "); d.println(ckSpeed);
}
t += ckSpeed;
delay(6);
}
CY CY::operator+ (CY &other) {
int len1 = this.num;
int len2 = other.num;
if (len1 != len2)
return CY(NULL, -1);
CX arr[len1];
CY result;
result.pArray = arr;
result.num = len1;
for (int i = 0; i < len1; ++i) {
result.pArray[i].Name = this.pArray[i].Name +
other.pArray[i].Name;
result.pArray[i].Weight = this.pArray[i].Weight +
other.pArray[i].Weight;
}
return result;
}
static int
getcoord(int atcpu)
{
int ny, nx, c;
if (atcpu)
cgoto(cury, curx);
else
pgoto(cury, curx);
(void) refresh();
for (;;) {
if (atcpu) {
(void) mvprintw(CYBASE + BDEPTH + 1, CXBASE + 11, "(%d, %c)",
curx, 'A' + cury);
cgoto(cury, curx);
} else {
(void) mvprintw(PYBASE + BDEPTH + 1, PXBASE + 11, "(%d, %c)",
curx, 'A' + cury);
pgoto(cury, curx);
}
switch (c = getch()) {
case 'k':
case '8':
case KEY_UP:
ny = cury + BDEPTH - 1;
nx = curx;
break;
case 'j':
case '2':
case KEY_DOWN:
ny = cury + 1;
nx = curx;
break;
case 'h':
case '4':
case KEY_LEFT:
ny = cury;
nx = curx + BWIDTH - 1;
break;
case 'l':
case '6':
case KEY_RIGHT:
ny = cury;
nx = curx + 1;
break;
case 'y':
case '7':
case KEY_A1:
ny = cury + BDEPTH - 1;
nx = curx + BWIDTH - 1;
break;
case 'b':
case '1':
case KEY_C1:
ny = cury + 1;
nx = curx + BWIDTH - 1;
break;
case 'u':
case '9':
case KEY_A3:
ny = cury + BDEPTH - 1;
nx = curx + 1;
break;
case 'n':
case '3':
case KEY_C3:
ny = cury + 1;
nx = curx + 1;
break;
case FF:
nx = curx;
ny = cury;
(void) clearok(stdscr, TRUE);
(void) refresh();
break;
#ifdef NCURSES_MOUSE_VERSION
case KEY_MOUSE:
{
MEVENT myevent;
getmouse(&myevent);
if (atcpu
&& myevent.y >= CY(0) && myevent.y <= CY(BDEPTH)
&& myevent.x >= CX(0) && myevent.x <= CX(BDEPTH)) {
curx = CXINV(myevent.x);
cury = CYINV(myevent.y);
return (' ');
} else {
beep();
continue;
}
}
/* no fall through */
#endif /* NCURSES_MOUSE_VERSION */
default:
if (atcpu)
(void) mvaddstr(CYBASE + BDEPTH + 1, CXBASE + 11, " ");
else
(void) mvaddstr(PYBASE + BDEPTH + 1, PXBASE + 11, " ");
return (c);
}
curx = nx % BWIDTH;
cury = ny % BDEPTH;
}
}
/*
psz the population size
n the generations number to run
pc the cross over probability
pm the mutation probability
*/
chro_ptr ga(mic_matrix M,int psz,int n,float pc,float pm)
{
srand((double)time(NULL));
population pop;
pop.n=psz;
pop.acu=(float*)malloc(sizeof(float)*pop.n);
if(pop.acu==NULL)
{
puts("GA acu memory error!");
exit(1);
}
int i=0;
for(i=0;i<pop.n;i++)
{
pop.acu[i]=0;
}
pop.pc=pc;
pop.pm=pm;
ini_pop(M,&pop);
population *S=ini_tmpop(pop);
int T=pop.n;
int Gn=0;
int N=n;
do
{//代数不够或者没达到最优解
//#define check_ga
#ifdef check_ga
printf("The %d generation's best %f.\n",Gn,pop.m[0].sig);
#endif
int n=0;
cal_acu(&pop);
do
{//种群的成员数不够
chro_ptr father=sel_one(pop);
chro_ptr mother=sel_one(pop);
cpy_chro(father,&(S->m[n]));
cpy_chro(mother,&(S->m[n+1]));
if(CY(pop))
{
cross_over(&(S->m[n]),&(S->m[n+1]));
}
if(MT(pop))
{
mutation(&(S->m[n]));
}
if(MT(pop))
{
mutation(&(S->m[n+1]));
}
n+=2;
}while(n<T);
update_pop(S,M);
elitist_sel(&pop,S);
}while(++Gn<N);
chro_ptr bst=(chro_ptr)malloc(sizeof(chrosome));
bst->l=pop.m[0].l;
bst->chro=(int *)malloc(sizeof(int)*(bst->l));
cpy_chro(&(pop.m[0]),bst);
brk_pop(&pop);
brk_pop(S);
return bst;
}
/* Subroutine */ int zdrot_(integer *n, doublecomplex *cx, integer *incx,
doublecomplex *cy, integer *incy, doublereal *c, doublereal *s)
{
/* System generated locals */
integer i__1, i__2, i__3, i__4;
doublecomplex z__1, z__2, z__3;
/* Local variables */
static integer i;
static doublecomplex ctemp;
static integer ix, iy;
/* applies a plane rotation, where the cos and sin (c and s) are real
and the vectors cx and cy are complex.
jack dongarra, linpack, 3/11/78.
=====================================================================
Parameter adjustments
Function Body */
#define CY(I) cy[(I)-1]
#define CX(I) cx[(I)-1]
if (*n <= 0) {
return 0;
}
if (*incx == 1 && *incy == 1) {
goto L20;
}
/* code for unequal increments or equal increments not equal
to 1 */
ix = 1;
iy = 1;
if (*incx < 0) {
ix = (-(*n) + 1) * *incx + 1;
}
if (*incy < 0) {
iy = (-(*n) + 1) * *incy + 1;
}
i__1 = *n;
for (i = 1; i <= *n; ++i) {
i__2 = ix;
z__2.r = *c * CX(ix).r, z__2.i = *c * CX(ix).i;
i__3 = iy;
z__3.r = *s * CY(iy).r, z__3.i = *s * CY(iy).i;
z__1.r = z__2.r + z__3.r, z__1.i = z__2.i + z__3.i;
ctemp.r = z__1.r, ctemp.i = z__1.i;
i__2 = iy;
i__3 = iy;
z__2.r = *c * CY(iy).r, z__2.i = *c * CY(iy).i;
i__4 = ix;
z__3.r = *s * CX(ix).r, z__3.i = *s * CX(ix).i;
z__1.r = z__2.r - z__3.r, z__1.i = z__2.i - z__3.i;
CY(iy).r = z__1.r, CY(iy).i = z__1.i;
i__2 = ix;
CX(ix).r = ctemp.r, CX(ix).i = ctemp.i;
ix += *incx;
iy += *incy;
/* L10: */
}
return 0;
/* code for both increments equal to 1 */
L20:
i__1 = *n;
for (i = 1; i <= *n; ++i) {
i__2 = i;
z__2.r = *c * CX(i).r, z__2.i = *c * CX(i).i;
i__3 = i;
z__3.r = *s * CY(i).r, z__3.i = *s * CY(i).i;
z__1.r = z__2.r + z__3.r, z__1.i = z__2.i + z__3.i;
ctemp.r = z__1.r, ctemp.i = z__1.i;
i__2 = i;
i__3 = i;
z__2.r = *c * CY(i).r, z__2.i = *c * CY(i).i;
i__4 = i;
z__3.r = *s * CX(i).r, z__3.i = *s * CX(i).i;
z__1.r = z__2.r - z__3.r, z__1.i = z__2.i - z__3.i;
CY(i).r = z__1.r, CY(i).i = z__1.i;
i__2 = i;
CX(i).r = ctemp.r, CX(i).i = ctemp.i;
/* L30: */
}
return 0;
} /* zdrot_ */
/* ======================================================= *\
* PIE
*
* Notes:
* always drawn from 12:00 position clockwise
* 'missing' slices don't get labels
* sum(val[0], ... val[num_points-1]) is assumed to be 100%
\* ======================================================= */
void
GDC_out_pie( short IMGWIDTH,
short IMGHEIGHT,
FILE *img_fptr, /* open file pointer */
GDCPIE_TYPE type,
int num_points,
char *lbl[], /* data labels */
float val[] ) /* data */
{
int i;
gdImagePtr im;
int BGColor,
LineColor,
PlotColor,
EdgeColor,
EdgeColorShd;
CREATE_ARRAY1( SliceColor, int, num_points ); /* int SliceColor[num_points] */
CREATE_ARRAY1( SliceColorShd, int, num_points ); /* int SliceColorShd[num_points] */
float rad = 0.0; /* radius */
float ellipsex = 1.0;
float ellipsey = 1.0 - (float)GDCPIE_perspective/100.0;
float tot_val = 0.0;
float pscl;
int cx, /* affects PX() */
cy; /* affects PY() */
/* ~ 1% for a size of 100 pixs */
/* label sizes will more dictate this */
float min_grphable = ( GDCPIE_other_threshold < 0?
100.0/(float)MIN(IMGWIDTH,IMGHEIGHT):
(float)GDCPIE_other_threshold )/100.0;
short num_slices1 = 0,
num_slices2 = 0;
char any_too_small = FALSE;
CREATE_ARRAY1( others, char, num_points ); /* char others[num_points] */
CREATE_ARRAY2( slice_angle, float, 3, num_points ); /* float slice_angle[3][num_points] */
/* must be used with others[] */
char threeD = ( type == GDC_3DPIE );
int xdepth_3D = 0, /* affects PX() */
ydepth_3D = 0; /* affects PY() */
int do3Dx = 0, /* reserved for macro use */
do3Dy = 0;
CREATE_ARRAY2( pct_lbl, char, num_points, 16 ); /* sizeof or strlen (GDCPIE_percent_fmt)? */
CREATE_ARRAY1( pct_ftsz, struct fnt_sz_t, num_points ); /* struct fnt_sz_t lbl_ftsz[num_points] */
CREATE_ARRAY1( lbl_ftsz, struct fnt_sz_t, num_points ); /* struct fnt_sz_t lbl_ftsz[num_points] */
#ifdef HAVE_LIBFREETYPE
char *gdcpie_title_font = GDCPIE_title_font;
char *gdcpie_label_font = GDCPIE_label_font;
double gdcpie_title_ptsize = GDCPIE_title_ptsize;
double gdcpie_label_ptsize = GDCPIE_label_ptsize;
#else
char *gdcpie_title_font = NULL;
char *gdcpie_label_font = NULL;
double gdcpie_title_ptsize = 0.0;
double gdcpie_label_ptsize = 0.0;
#endif
/* GDCPIE_3d_angle = MOD_360(90-GDCPIE_3d_angle+360); */
pie_3D_rad = TO_RAD( GDCPIE_3d_angle );
xdepth_3D = threeD? (int)( cos((double)MOD_2PI(M_PI_2-pie_3D_rad+2.0*M_PI)) * GDCPIE_3d_depth ): 0;
ydepth_3D = threeD? (int)( sin((double)MOD_2PI(M_PI_2-pie_3D_rad+2.0*M_PI)) * GDCPIE_3d_depth ): 0;
/* xdepth_3D = threeD? (int)( cos(pie_3D_rad) * GDCPIE_3d_depth ): 0; */
/* ydepth_3D = threeD? (int)( sin(pie_3D_rad) * GDCPIE_3d_depth ): 0; */
load_font_conversions();
/* ----- get total value ----- */
for( i=0; i<num_points; ++i )
tot_val += val[i];
/* ----- pie sizing ----- */
/* ----- make width room for labels, depth, etc.: ----- */
/* ----- determine pie's radius ----- */
{
int title_hgt = GDCPIE_title? 1 /* title? horizontal text line */
+ GDCfnt_sz( GDCPIE_title,
GDCPIE_title_size,
gdcpie_title_font, gdcpie_title_ptsize, 0.0, NULL ).h
+ 2:
0;
float last = 0.0;
float label_explode_limit = 0.0;
int cheight,
cwidth;
/* maximum: no labels, explosions */
/* gotta start somewhere */
rad = (float)MIN( (IMGWIDTH/2)/ellipsex-(1+ABS(xdepth_3D)), (IMGHEIGHT/2)/ellipsey-(1+ABS(ydepth_3D))-title_hgt );
/* ok fix center, i.e., no floating re labels, explosion, etc. */
cx = IMGWIDTH/2 /* - xdepth_3D */ ;
cy = (IMGHEIGHT-title_hgt)/2 + title_hgt /* + ydepth_3D */ ;
cheight = (IMGHEIGHT- title_hgt)/2 /* - ydepth_3D */ ;
cwidth = cx;
/* walk around pie. determine spacing to edge */
for( i=0; i<num_points; ++i )
{
float this_pct = val[i]/tot_val; /* should never be > 100% */
float this = this_pct*(2.0*M_PI); /* pie-portion */
if( (this_pct > min_grphable) || /* too small */
(!GDCPIE_missing || !GDCPIE_missing[i]) ) /* still want angles */
{
int this_explode = GDCPIE_explode? GDCPIE_explode[i]: 0;
double this_sin;
double this_cos;
slice_angle[0][i] = this/2.0+last; /* mid-point on full pie */
slice_angle[1][i] = last; /* 1st on full pie */
slice_angle[2][i] = this+last; /* 2nd on full pie */
this_sin = ellipsex*sin( (double)slice_angle[0][i] );
this_cos = ellipsey*cos( (double)slice_angle[0][i] );
if( !GDCPIE_missing || !(GDCPIE_missing[i]) )
{
short lbl_wdth = 0,
lbl_hgt = 0;
float this_y_explode_limit,
this_x_explode_limit;
/* start slice label height, width */
/* accounting for PCT placement, font */
pct_ftsz[i].h = 0;
pct_ftsz[i].w = 0;
if( GDCPIE_percent_fmt &&
GDCPIE_percent_labels != GDCPIE_PCT_NONE )
{
sprintf( pct_lbl[i], GDCPIE_percent_fmt, this_pct * 100.0 );
pct_ftsz[i] = GDCfnt_sz( pct_lbl[i],
GDCPIE_label_size,
gdcpie_label_font, gdcpie_label_ptsize, 0.0, NULL );
lbl_wdth = pct_ftsz[i].w;
lbl_hgt = pct_ftsz[i].h;
}
if( lbl && lbl[i] )
{
lbl_ftsz[i] = GDCfnt_sz( lbl[i],
GDCPIE_label_size,
gdcpie_label_font, gdcpie_label_ptsize, 0.0, NULL );
if( GDCPIE_percent_labels == GDCPIE_PCT_ABOVE ||
GDCPIE_percent_labels == GDCPIE_PCT_BELOW )
{
lbl_wdth = MAX( pct_ftsz[i].w, lbl_ftsz[i].w );
lbl_hgt = pct_ftsz[i].h + lbl_ftsz[i].h + 1;
}
else
if( GDCPIE_percent_labels == GDCPIE_PCT_RIGHT ||
GDCPIE_percent_labels == GDCPIE_PCT_LEFT )
{
lbl_wdth = pct_ftsz[i].w + lbl_ftsz[i].w + 1;
lbl_hgt = MAX( pct_ftsz[i].h, lbl_ftsz[i].h );
}
else /* GDCPIE_PCT_NONE */
{
lbl_wdth = lbl_ftsz[i].w;
lbl_hgt = lbl_ftsz[i].h;
}
}
else
lbl_wdth = lbl_hgt = 0;
/* end label height, width */
/* diamiter limited by this point's: explosion, label */
/* (radius to box @ slice_angle) - (explode) - (projected label size) */
/* radius constraint due to labels */
this_y_explode_limit = (float)this_cos==0.0? FLT_MAX:
( (float)( (double)cheight/ABS(this_cos) ) -
(float)( this_explode + (lbl&&lbl[i]? GDCPIE_label_dist: 0) ) -
(float)( lbl_hgt/2 ) / (float)ABS(this_cos) );
this_x_explode_limit = (float)this_sin==0.0? FLT_MAX:
( (float)( (double)cwidth/ABS(this_sin) ) -
(float)( this_explode + (lbl&&lbl[i]? GDCPIE_label_dist: 0) ) -
(float)( lbl_wdth ) / (float)ABS(this_sin) );
rad = MIN( rad, this_y_explode_limit );
rad = MIN( rad, this_x_explode_limit );
/* ok at this radius (which is most likely larger than final) */
/* adjust for inter-label spacing */
/* if( lbl[i] && *lbl[i] ) */
/* { */
/* char which_edge = slice_angle[0][i] > M_PI? +1: -1; // which semi */
/* last_label_yedge = cheight - (int)( (rad + // top or bottom of label */
/* (float)(this_explode + */
/* (float)GDCPIE_label_dist)) * (float)this_cos ) + */
/* ( (GDC_fontc[GDCPIE_label_size].h+1)/2 + */
/* GDC_label_spacing )*which_edge; */
/* } */
/* radius constriant due to exploded depth */
/* at each edge of the slice, and the middle */
/* this is really stupid */
/* this section uses a different algorithm then above, but does the same thing */
/* could be combined, but each is ugly enough! */
/* PROTECT /0 */
if( threeD )
{
short j;
int this_y_explode_pos;
int this_x_explode_pos;
/* first N E S W (actually no need for N) */
if( (slice_angle[1][i] < M_PI_2 && M_PI_2 < slice_angle[2][i]) && /* E */
(this_x_explode_pos=OX(i,M_PI_2,1)) > cx+cwidth )
rad -= (float)ABS( (double)(1+this_x_explode_pos-(cx+cwidth))/sin(M_PI_2) );
if( (slice_angle[1][i] < 3.0*M_PI_2 && 3.0*M_PI_2 < slice_angle[2][i]) && /* W */
(this_x_explode_pos=OX(i,3.0*M_PI_2,1)) < cx-cwidth )
rad -= (float)ABS( (double)(this_x_explode_pos-(cx+cwidth))/sin(3.0*M_PI_2) );
if( (slice_angle[1][i] < M_PI && M_PI < slice_angle[2][i]) && /* S */
(this_y_explode_pos=OY(i,M_PI,1)) > cy+cheight )
rad -= (float)ABS( (double)(1+this_y_explode_pos-(cy+cheight))/cos(M_PI) );
for( j=0; j<3; ++j )
{
this_y_explode_pos = IY(i,j,1);
if( this_y_explode_pos < cy-cheight )
rad -= (float)ABS( (double)((cy-cheight)-this_y_explode_pos)/cos((double)slice_angle[j][i]) );
if( this_y_explode_pos > cy+cheight )
rad -= (float)ABS( (double)(1+this_y_explode_pos-(cy+cheight))/cos((double)slice_angle[j][i]) );
this_x_explode_pos = IX(i,j,1);
if( this_x_explode_pos < cx-cwidth )
rad -= (float)ABS( (double)((cx-cwidth)-this_x_explode_pos)/sin((double)slice_angle[j][i]) );
if( this_x_explode_pos > cx+cwidth )
rad -= (float)ABS( (double)(1+this_x_explode_pos-(cx+cwidth))/sin((double)slice_angle[j][i]) );
}
}
}
others[i] = FALSE;
}
else
{
others[i] = TRUE;
slice_angle[0][i] = -FLT_MAX;
}
last += this;
}
}
/* ----- go ahead and start the image ----- */
im = gdImageCreate( IMGWIDTH, IMGHEIGHT );
/* --- allocate the requested colors --- */
BGColor = clrallocate( im, GDCPIE_BGColor );
LineColor = clrallocate( im, GDCPIE_LineColor );
PlotColor = clrallocate( im, GDCPIE_PlotColor );
if( GDCPIE_EdgeColor != GDC_NOCOLOR )
{
EdgeColor = clrallocate( im, GDCPIE_EdgeColor );
if( threeD )
EdgeColorShd = clrshdallocate( im, GDCPIE_EdgeColor );
}
/* --- set color for each slice --- */
for( i=0; i<num_points; ++i )
if( GDCPIE_Color )
{
unsigned long slc_clr = GDCPIE_Color[i];
SliceColor[i] = clrallocate( im, slc_clr );
if( threeD )
SliceColorShd[i] = clrshdallocate( im, slc_clr );
}
else
{
SliceColor[i] = PlotColor;
if( threeD )
SliceColorShd[i] = clrshdallocate( im, GDCPIE_PlotColor );
}
pscl = (2.0*M_PI)/tot_val;
/* ----- calc: smallest a slice can be ----- */
/* 1/2 circum / num slices per side. */
/* determined by number of labels that'll fit (height) */
/* scale to user values */
/* ( M_PI / (IMGHEIGHT / (SFONTHGT+1)) ) */
/* min_grphable = tot_val / */
/* ( 2.0 * (float)IMGHEIGHT / (float)(SFONTHGT+1+TFONTHGT+2) ); */
if( threeD )
{
/* draw background shaded pie */
{
float rad1 = rad * 3.0/4.0;
for( i=0; i<num_points; ++i )
if( !(others[i]) &&
(!GDCPIE_missing || !GDCPIE_missing[i]) )
{
int edge_color = GDCPIE_EdgeColor == GDC_NOCOLOR? SliceColorShd[i]:
EdgeColorShd;
gdImageLine( im, CX(i,1), CY(i,1), IX(i,1,1), IY(i,1,1), edge_color );
gdImageLine( im, CX(i,1), CY(i,1), IX(i,2,1), IY(i,2,1), edge_color );
gdImageArc( im, CX(i,1), CY(i,1),
(int)(rad*ellipsex*2.0), (int)(rad*ellipsey*2.0),
TO_INT_DEG_FLOOR(slice_angle[1][i])+270,
TO_INT_DEG_CEIL(slice_angle[2][i])+270,
edge_color );
/* gdImageFilledArc( im, CX(i,1), CY(i,1), */
/* rad*ellipsex*2, rad*ellipsey*2, */
/* TO_INT_DEG_FLOOR(slice_angle[1][i])+270, */
/* TO_INT_DEG_CEIL(slice_angle[2][i])+270, */
/* SliceColorShd[i], */
/* gdPie ); */
/* attempt to fill, if slice is wide enough */
if( (ABS(IX(i,1,1)-IX(i,2,1)) + ABS(IY(i,1,1)-IY(i,2,1))) > 2 )
{
float rad = rad1; /* local override */
gdImageFillToBorder( im, IX(i,0,1), IY(i,0,1), edge_color, SliceColorShd[i] );
}
}
}
/* fill in connection to foreground pie */
/* this is where we earn our keep */
{
int t,
num_slice_angles = 0;
CREATE_ARRAY1( tmp_slice, struct tmp_slice_t, 4*num_points+4 ); /* should only need 2*num_points+2 */
for( i=0; i<num_points; ++i )
if( !GDCPIE_missing || !GDCPIE_missing[i] )
{
if( RAD_DIST1(slice_angle[1][i]) < RAD_DIST2(slice_angle[0][i]) )
tmp_slice[num_slice_angles].hidden = FALSE;
else
tmp_slice[num_slice_angles].hidden = TRUE;
tmp_slice[num_slice_angles].i = i;
tmp_slice[num_slice_angles].slice = slice_angle[0][i];
tmp_slice[num_slice_angles++].angle = slice_angle[1][i];
if( RAD_DIST1(slice_angle[2][i]) < RAD_DIST2(slice_angle[0][i]) )
tmp_slice[num_slice_angles].hidden = FALSE;
else
tmp_slice[num_slice_angles].hidden = TRUE;
tmp_slice[num_slice_angles].i = i;
tmp_slice[num_slice_angles].slice = slice_angle[0][i];
tmp_slice[num_slice_angles++].angle = slice_angle[2][i];
/* identify which 2 slices (i) have a tangent parallel to depth angle */
if( slice_angle[1][i]<MOD_2PI(pie_3D_rad+M_PI_2) && slice_angle[2][i]>MOD_2PI(pie_3D_rad+M_PI_2) )
{
tmp_slice[num_slice_angles].i = i;
tmp_slice[num_slice_angles].hidden = FALSE;
tmp_slice[num_slice_angles].slice = slice_angle[0][i];
tmp_slice[num_slice_angles++].angle = MOD_2PI( pie_3D_rad+M_PI_2 );
}
if( slice_angle[1][i]<MOD_2PI(pie_3D_rad+3.0*M_PI_2) && slice_angle[2][i]>MOD_2PI(pie_3D_rad+3.0*M_PI_2) )
{
tmp_slice[num_slice_angles].i = i;
tmp_slice[num_slice_angles].hidden = FALSE;
tmp_slice[num_slice_angles].slice = slice_angle[0][i];
tmp_slice[num_slice_angles++].angle = MOD_2PI( pie_3D_rad+3.0*M_PI_2 );
}
}
qsort( tmp_slice, num_slice_angles, sizeof(struct tmp_slice_t), ocmpr );
for( t=0; t<num_slice_angles; ++t )
{
gdPoint gdp[4];
i = tmp_slice[t].i;
gdp[0].x = CX(i,0); gdp[0].y = CY(i,0);
gdp[1].x = CX(i,1); gdp[1].y = CY(i,1);
gdp[2].x = OX(i,tmp_slice[t].angle,1); gdp[2].y = OY(i,tmp_slice[t].angle,1);
gdp[3].x = OX(i,tmp_slice[t].angle,0); gdp[3].y = OY(i,tmp_slice[t].angle,0);
if( !(tmp_slice[t].hidden) )
gdImageFilledPolygon( im, gdp, 4, SliceColorShd[i] );
else
{
rad -= 2.0; /* no peeking */
gdp[0].x = OX(i,slice_angle[0][i],0); gdp[0].y = OY(i,slice_angle[0][i],0);
gdp[1].x = OX(i,slice_angle[0][i],1); gdp[1].y = OY(i,slice_angle[0][i],1);
rad += 2.0;
gdp[2].x = OX(i,slice_angle[1][i],1); gdp[2].y = OY(i,slice_angle[1][i],1);
gdp[3].x = OX(i,slice_angle[1][i],0); gdp[3].y = OY(i,slice_angle[1][i],0);
gdImageFilledPolygon( im, gdp, 4, SliceColorShd[i] );
gdp[2].x = OX(i,slice_angle[2][i],1); gdp[2].y = OY(i,slice_angle[2][i],1);
gdp[3].x = OX(i,slice_angle[2][i],0); gdp[3].y = OY(i,slice_angle[2][i],0);
gdImageFilledPolygon( im, gdp, 4, SliceColorShd[i] );
}
if( GDCPIE_EdgeColor != GDC_NOCOLOR )
{
gdImageLine( im, CX(i,0), CY(i,0), CX(i,1), CY(i,1), EdgeColorShd );
gdImageLine( im, OX(i,tmp_slice[t].angle,0), OY(i,tmp_slice[t].angle,0),
OX(i,tmp_slice[t].angle,1), OY(i,tmp_slice[t].angle,1),
EdgeColorShd );
}
}
FREE_ARRAY1( tmp_slice );
}
}
/* ----- pie face ----- */
{
/* float last = 0.0; */
float rad1 = rad * 3.0/4.0;
for( i=0; i<num_points; ++i )
if( !others[i] &&
(!GDCPIE_missing || !GDCPIE_missing[i]) )
{
int edge_color = GDCPIE_EdgeColor == GDC_NOCOLOR? SliceColor[i]:
EdgeColorShd;
/* last += val[i]; */
/* EXPLODE_CX_CY( slice_angle[0][i], i ); */
gdImageLine( im, CX(i,0), CY(i,0), IX(i,1,0), IY(i,1,0), edge_color );
gdImageLine( im, CX(i,0), CY(i,0), IX(i,2,0), IY(i,2,0), edge_color );
gdImageArc( im, CX(i,0), CY(i,0),
(int)(rad*ellipsex*2.0), (int)(rad*ellipsey*2.0),
(TO_INT_DEG_FLOOR(slice_angle[1][i])+270)%360,
(TO_INT_DEG_CEIL(slice_angle[2][i])+270)%360,
edge_color );
/* antialiasing here */
/* likely only on the face? */
/* bugs in gd2.0.0 */
/* arc doesn't honor deg>360 */
/* arcs from gdImageFilledArc() don't match with gdImageArc() */
/* angles are off */
/* doesn't always fill completely */
/* gdImageFilledArc( im, CX(i,0), CY(i,0), */
/* (int)(rad*ellipsex*2.0), (int)(rad*ellipsey*2.0), */
/* (TO_INT_DEG_FLOOR(slice_angle[1][i])+270)%360, */
/* (TO_INT_DEG_CEIL(slice_angle[2][i])+270)%360, */
/* SliceColor[i], */
/* gdPie ); */
/* attempt to fill, if slice is wide enough */
{
float rad = rad1; /* local override */
if( (ABS(IX(i,1,1)-IX(i,2,1)) + ABS(IY(i,1,1)-IY(i,2,1))) > 2 )
{
gdImageFillToBorder( im, IX(i,0,0), IY(i,0,0), edge_color, SliceColor[i] );
}
/* catch missed pixels on narrow slices */
gdImageLine( im, CX(i,0), CY(i,0), IX(i,0,0), IY(i,0,0), SliceColor[i] );
}
}
}
if( GDCPIE_title )
{
struct fnt_sz_t tftsz = GDCfnt_sz( GDCPIE_title,
GDCPIE_title_size,
gdcpie_title_font, gdcpie_title_ptsize, 0.0, NULL );
GDCImageStringNL( im,
&GDC_fontc[GDCPIE_title_size],
gdcpie_title_font, gdcpie_title_ptsize,
0.0,
IMGWIDTH/2 - tftsz.w/2,
1,
GDCPIE_title,
LineColor,
GDC_JUSTIFY_CENTER,
NULL );
}
/* labels */
if( lbl )
{
float liner = rad;
rad += GDCPIE_label_dist;
for( i=0; i<num_points; ++i )
{
if( !others[i] &&
(!GDCPIE_missing || !GDCPIE_missing[i]) )
{
int lblx, pctx,
lbly, pcty,
linex, liney;
lbly = (liney = IY(i,0,0))-lbl_ftsz[i].h / 2;
lblx = pctx = linex = IX(i,0,0);
if( slice_angle[0][i] > M_PI ) /* which semicircle */
{
lblx -= lbl_ftsz[i].w;
pctx = lblx;
++linex;
}
else
--linex;
switch( GDCPIE_percent_labels )
{
case GDCPIE_PCT_LEFT: if( slice_angle[0][i] > M_PI )
pctx -= lbl_ftsz[i].w-1;
else
lblx += pct_ftsz[i].w+1;
pcty = IY(i,0,0) - ( 1+pct_ftsz[i].h ) / 2;
break;
case GDCPIE_PCT_RIGHT: if( slice_angle[0][i] > M_PI )
lblx -= pct_ftsz[i].w-1;
else
pctx += lbl_ftsz[i].w+1;
pcty = IY(i,0,0) - ( 1+pct_ftsz[i].h ) / 2;
break;
case GDCPIE_PCT_ABOVE: lbly += (1+pct_ftsz[i].h) / 2;
pcty = lbly - pct_ftsz[i].h;
break;
case GDCPIE_PCT_BELOW: lbly -= (1+pct_ftsz[i].h) / 2;
pcty = lbly + lbl_ftsz[i].h;
break;
case GDCPIE_PCT_NONE:
default:;
}
if( GDCPIE_percent_labels != GDCPIE_PCT_NONE )
GDCImageStringNL( im,
&GDC_fontc[GDCPIE_label_size],
gdcpie_label_font, gdcpie_label_ptsize,
0.0,
slice_angle[0][i] <= M_PI? pctx:
pctx+lbl_ftsz[i].w-pct_ftsz[i].w,
pcty,
pct_lbl[i],
LineColor,
GDC_JUSTIFY_CENTER,
NULL );
if( lbl[i] )
GDCImageStringNL( im,
&GDC_fontc[GDCPIE_label_size],
gdcpie_label_font, gdcpie_label_ptsize,
0.0,
lblx,
lbly,
lbl[i],
LineColor,
slice_angle[0][i] <= M_PI? GDC_JUSTIFY_LEFT:
GDC_JUSTIFY_RIGHT,
NULL );
if( GDCPIE_label_line )
{
float rad = liner;
gdImageLine( im, linex, liney, IX(i,0,0), IY(i,0,0), LineColor );
}
}
}
rad -= GDCPIE_label_dist;
}
fflush( img_fptr );
switch( GDC_image_type )
{
#ifdef HAVE_JPEG
case GDC_JPEG: gdImageJpeg( im, img_fptr, GDC_jpeg_quality ); break;
#endif
case GDC_WBMP: gdImageWBMP( im, PlotColor, img_fptr ); break;
case GDC_GIF: gdImageGif( im, img_fptr); break;
case GDC_PNG:
default: gdImagePng( im, img_fptr );
}
FREE_ARRAY1( lbl_ftsz );
FREE_ARRAY1( pct_ftsz );
FREE_ARRAY2( pct_lbl );
FREE_ARRAY2( slice_angle );
FREE_ARRAY1( others );
FREE_ARRAY1( SliceColorShd );
FREE_ARRAY1( SliceColor );
gdImageDestroy(im);
return;
}
/* Subroutine */ int zlacrt_(integer *n, doublecomplex *cx, integer *incx,
doublecomplex *cy, integer *incy, doublecomplex *c, doublecomplex *s)
{
/* -- LAPACK auxiliary routine (version 2.0) --
Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
Courant Institute, Argonne National Lab, and Rice University
October 31, 1992
Purpose
=======
ZLACRT applies a plane rotation, where the cos and sin (C and S) are
complex and the vectors CX and CY are complex.
Arguments
=========
N (input) INTEGER
The number of elements in the vectors CX and CY.
CX (input/output) COMPLEX*16 array, dimension (N)
On input, the vector X.
On output, CX is overwritten with C*X + S*Y.
INCX (input) INTEGER
The increment between successive values of CY. INCX <> 0.
CY (input/output) COMPLEX*16 array, dimension (N)
On input, the vector Y.
On output, CY is overwritten with -S*X + C*Y.
INCY (input) INTEGER
The increment between successive values of CY. INCX <> 0.
C (input) COMPLEX*16
S (input) COMPLEX*16
C and S define a complex rotation
[ C S ]
[ -S C ]
where C*C + S*S = 1.0.
=====================================================================
Parameter adjustments
Function Body */
/* System generated locals */
integer i__1, i__2, i__3, i__4;
doublecomplex z__1, z__2, z__3;
/* Local variables */
static integer i;
static doublecomplex ctemp;
static integer ix, iy;
#define CY(I) cy[(I)-1]
#define CX(I) cx[(I)-1]
if (*n <= 0) {
return 0;
}
if (*incx == 1 && *incy == 1) {
goto L20;
}
/* Code for unequal increments or equal increments not equal to 1 */
ix = 1;
iy = 1;
if (*incx < 0) {
ix = (-(*n) + 1) * *incx + 1;
}
if (*incy < 0) {
iy = (-(*n) + 1) * *incy + 1;
}
i__1 = *n;
for (i = 1; i <= *n; ++i) {
i__2 = ix;
z__2.r = c->r * CX(ix).r - c->i * CX(ix).i, z__2.i = c->r * CX(
ix).i + c->i * CX(ix).r;
i__3 = iy;
z__3.r = s->r * CY(iy).r - s->i * CY(iy).i, z__3.i = s->r * CY(
iy).i + s->i * CY(iy).r;
z__1.r = z__2.r + z__3.r, z__1.i = z__2.i + z__3.i;
ctemp.r = z__1.r, ctemp.i = z__1.i;
i__2 = iy;
i__3 = iy;
z__2.r = c->r * CY(iy).r - c->i * CY(iy).i, z__2.i = c->r * CY(
iy).i + c->i * CY(iy).r;
i__4 = ix;
z__3.r = s->r * CX(ix).r - s->i * CX(ix).i, z__3.i = s->r * CX(
ix).i + s->i * CX(ix).r;
z__1.r = z__2.r - z__3.r, z__1.i = z__2.i - z__3.i;
CY(iy).r = z__1.r, CY(iy).i = z__1.i;
i__2 = ix;
CX(ix).r = ctemp.r, CX(ix).i = ctemp.i;
ix += *incx;
iy += *incy;
/* L10: */
}
return 0;
/* Code for both increments equal to 1 */
L20:
i__1 = *n;
for (i = 1; i <= *n; ++i) {
i__2 = i;
z__2.r = c->r * CX(i).r - c->i * CX(i).i, z__2.i = c->r * CX(
i).i + c->i * CX(i).r;
i__3 = i;
z__3.r = s->r * CY(i).r - s->i * CY(i).i, z__3.i = s->r * CY(
i).i + s->i * CY(i).r;
z__1.r = z__2.r + z__3.r, z__1.i = z__2.i + z__3.i;
ctemp.r = z__1.r, ctemp.i = z__1.i;
i__2 = i;
i__3 = i;
z__2.r = c->r * CY(i).r - c->i * CY(i).i, z__2.i = c->r * CY(
i).i + c->i * CY(i).r;
i__4 = i;
z__3.r = s->r * CX(i).r - s->i * CX(i).i, z__3.i = s->r * CX(
i).i + s->i * CX(i).r;
z__1.r = z__2.r - z__3.r, z__1.i = z__2.i - z__3.i;
CY(i).r = z__1.r, CY(i).i = z__1.i;
i__2 = i;
CX(i).r = ctemp.r, CX(i).i = ctemp.i;
/* L30: */
}
return 0;
} /* zlacrt_ */
static void
play(void)
/* play the game */
{
bool keyhelp; /* TRUE if keystroke help is up */
int i, j, count;
int lastcol = 0; /* last location visited */
int lastrow = 0;
int ny = 0, nx = 0;
int review = 0; /* review history */
int rw = 0, col = 0; /* current row and column */
do {
/* clear screen and draw board */
werase(boardwin);
werase(helpwin);
werase(msgwin);
dosquares();
help1();
wnoutrefresh(stdscr);
wnoutrefresh(helpwin);
wnoutrefresh(msgwin);
wnoutrefresh(boardwin);
doupdate();
movecount = 0;
for (i = 0; i < BDEPTH; i++) {
for (j = 0; j < BWIDTH; j++) {
board[i][j] = FALSE;
unmarkcell(i, j);
}
}
memset(history, 0, sizeof(history));
history[0].y = history[0].x = -1;
history[1].y = history[1].x = -1;
lastrow = lastcol = -2;
movecount = 1;
trialcount = 1;
keyhelp = FALSE;
show_help(&keyhelp);
for (;;) {
if (rw != lastrow || col != lastcol) {
if (lastrow >= 0 && lastcol >= 0) {
cellmove(lastrow, lastcol);
if (board[lastrow][lastcol])
waddch(boardwin, trail);
else
waddch(boardwin, oldch);
}
cellmove(rw, col);
oldch = winch(boardwin);
lastrow = rw;
lastcol = col;
}
cellmove(rw, col);
waddch(boardwin, plus);
cellmove(rw, col);
wrefresh(msgwin);
switch (wgetch(boardwin)) {
case 'k':
case '8':
case KEY_UP:
ny = rw + BDEPTH - 1;
nx = col;
break;
case 'j':
case '2':
case KEY_DOWN:
ny = rw + 1;
nx = col;
break;
case 'h':
case '4':
case KEY_LEFT:
ny = rw;
nx = col + BWIDTH - 1;
break;
case 'l':
case '6':
case KEY_RIGHT:
ny = rw;
nx = col + 1;
break;
case 'y':
case '7':
case KEY_A1:
ny = rw + BDEPTH - 1;
nx = col + BWIDTH - 1;
break;
case 'b':
case '1':
case KEY_C1:
ny = rw + 1;
nx = col + BWIDTH - 1;
break;
case 'u':
case '9':
case KEY_A3:
ny = rw + BDEPTH - 1;
nx = col + 1;
break;
case 'n':
case '3':
case KEY_C3:
ny = rw + 1;
nx = col + 1;
break;
#ifdef NCURSES_MOUSE_VERSION
case KEY_MOUSE:
{
MEVENT myevent;
getmouse(&myevent);
if (myevent.y >= CY(0) && myevent.y <= CY(BDEPTH)
&& myevent.x >= CX(0) && myevent.x <= CX(BWIDTH)) {
nx = CXINV(myevent.x);
ny = CYINV(myevent.y);
ungetch('\n');
break;
} else {
beep();
continue;
}
}
#endif /* NCURSES_MOUSE_VERSION */
case KEY_B2:
case '\n':
case ' ':
review = 0;
if (evalmove(rw, col)) {
drawmove(trail,
history[movecount - 1].y,
history[movecount - 1].x,
rw, col);
history[movecount].y = (short) rw;
history[movecount].x = (short) col;
movecount++;
trialcount++;
if (!chkmoves(rw, col)) {
if (completed() < 0) {
waddstr(msgwin, "\nYou won.");
} else {
waddstr(msgwin,
"\nNo further moves are possible.");
}
}
} else {
beep();
}
break;
case KEY_UNDO:
case KEY_BACKSPACE:
case '\b':
review = 0;
if (movecount <= 0) {
no_previous_move();
} else if (movecount <= 1) {
ny = history[movecount].y;
nx = history[movecount].x;
if (nx < 0 || ny < 0) {
ny = lastrow;
nx = lastcol;
}
movecount = 0;
board[ny][nx] = FALSE;
oldch = minus;
drawmove(' ', ny, nx, -1, -1);
movecount = 1;
trialcount = 1;
no_previous_move();
} else {
int oldy = history[movecount - 1].y;
int oldx = history[movecount - 1].x;
if (!board[rw][col]) {
cellmove(rw, col);
waddch(boardwin, ' ');
}
board[oldy][oldx] = FALSE;
--movecount;
ny = history[movecount - 1].y;
nx = history[movecount - 1].x;
if (nx < 0 || ny < 0) {
ny = oldy;
nx = oldx;
}
drawmove(' ', oldy, oldx, ny, nx);
/* avoid problems if we just changed the current cell */
cellmove(lastrow, lastcol);
oldch = winch(boardwin);
}
break;
case 'a':
nx = col;
ny = rw;
find_next_move(&ny, &nx);
break;
case 'F':
if (review > 0) {
review--;
ny = history[movecount - review - 1].y;
nx = history[movecount - review - 1].x;
} else {
beep();
}
break;
case 'B':
if (review < movecount - 2) {
review++;
ny = history[movecount - review - 1].y;
nx = history[movecount - review - 1].x;
} else {
beep();
}
break;
case KEY_REDO:
case '\f':
case 'r':
clearok(curscr, TRUE);
wnoutrefresh(stdscr);
wnoutrefresh(boardwin);
wnoutrefresh(msgwin);
wnoutrefresh(helpwin);
doupdate();
break;
case 'q':
case 'x':
goto dropout;
case '?':
show_help(&keyhelp);
break;
default:
beep();
break;
}
col = nx % BWIDTH;
rw = ny % BDEPTH;
}
dropout:
if ((count = completed()) < 0)
wprintw(msgwin, "\nYou won. Care to try again? ");
else
wprintw(msgwin, "\n%d squares filled. Try again? ", count);
wclrtoeol(msgwin);
} while
(tolower(wgetch(msgwin)) == 'y');
}
/* Subroutine */ int crot_(integer *n, complex *cx, integer *incx, complex *
cy, integer *incy, real *c, complex *s)
{
/* -- LAPACK auxiliary routine (version 2.0) --
Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
Courant Institute, Argonne National Lab, and Rice University
October 31, 1992
Purpose
=======
CROT applies a plane rotation, where the cos (C) is real and the
sin (S) is complex, and the vectors CX and CY are complex.
Arguments
=========
N (input) INTEGER
The number of elements in the vectors CX and CY.
CX (input/output) COMPLEX array, dimension (N)
On input, the vector X.
On output, CX is overwritten with C*X + S*Y.
INCX (input) INTEGER
The increment between successive values of CY. INCX <> 0.
CY (input/output) COMPLEX array, dimension (N)
On input, the vector Y.
On output, CY is overwritten with -CONJG(S)*X + C*Y.
INCY (input) INTEGER
The increment between successive values of CY. INCX <> 0.
C (input) REAL
S (input) COMPLEX
C and S define a rotation
[ C S ]
[ -conjg(S) C ]
where C*C + S*CONJG(S) = 1.0.
=====================================================================
Parameter adjustments
Function Body */
/* System generated locals */
integer i__1, i__2, i__3, i__4;
complex q__1, q__2, q__3, q__4;
/* Builtin functions */
void r_cnjg(complex *, complex *);
/* Local variables */
static integer i;
static complex stemp;
static integer ix, iy;
#define CY(I) cy[(I)-1]
#define CX(I) cx[(I)-1]
if (*n <= 0) {
return 0;
}
if (*incx == 1 && *incy == 1) {
goto L20;
}
/* Code for unequal increments or equal increments not equal to 1 */
ix = 1;
iy = 1;
if (*incx < 0) {
ix = (-(*n) + 1) * *incx + 1;
}
if (*incy < 0) {
iy = (-(*n) + 1) * *incy + 1;
}
i__1 = *n;
for (i = 1; i <= *n; ++i) {
i__2 = ix;
q__2.r = *c * CX(ix).r, q__2.i = *c * CX(ix).i;
i__3 = iy;
q__3.r = s->r * CY(iy).r - s->i * CY(iy).i, q__3.i = s->r * CY(
iy).i + s->i * CY(iy).r;
q__1.r = q__2.r + q__3.r, q__1.i = q__2.i + q__3.i;
stemp.r = q__1.r, stemp.i = q__1.i;
i__2 = iy;
i__3 = iy;
q__2.r = *c * CY(iy).r, q__2.i = *c * CY(iy).i;
r_cnjg(&q__4, s);
i__4 = ix;
q__3.r = q__4.r * CX(ix).r - q__4.i * CX(ix).i, q__3.i = q__4.r *
CX(ix).i + q__4.i * CX(ix).r;
q__1.r = q__2.r - q__3.r, q__1.i = q__2.i - q__3.i;
CY(iy).r = q__1.r, CY(iy).i = q__1.i;
i__2 = ix;
CX(ix).r = stemp.r, CX(ix).i = stemp.i;
ix += *incx;
iy += *incy;
/* L10: */
}
return 0;
/* Code for both increments equal to 1 */
L20:
i__1 = *n;
for (i = 1; i <= *n; ++i) {
i__2 = i;
q__2.r = *c * CX(i).r, q__2.i = *c * CX(i).i;
i__3 = i;
q__3.r = s->r * CY(i).r - s->i * CY(i).i, q__3.i = s->r * CY(
i).i + s->i * CY(i).r;
q__1.r = q__2.r + q__3.r, q__1.i = q__2.i + q__3.i;
stemp.r = q__1.r, stemp.i = q__1.i;
i__2 = i;
i__3 = i;
q__2.r = *c * CY(i).r, q__2.i = *c * CY(i).i;
r_cnjg(&q__4, s);
i__4 = i;
q__3.r = q__4.r * CX(i).r - q__4.i * CX(i).i, q__3.i = q__4.r *
CX(i).i + q__4.i * CX(i).r;
q__1.r = q__2.r - q__3.r, q__1.i = q__2.i - q__3.i;
CY(i).r = q__1.r, CY(i).i = q__1.i;
i__2 = i;
CX(i).r = stemp.r, CX(i).i = stemp.i;
/* L30: */
}
return 0;
} /* crot_ */
if( !mappingp(landmarks) ) landmarks = ([ ]);
return landmarks[name];
}
string get_landmark_description( int pos ) {
string *desc, ilandname, base_phrase;
int ilandpos;
if( !mappingp(landmarks) || sizeof(landmarks) == 0 ) return "No landmarks visible.";
desc = ({ });
foreach( ilandname, ilandpos : landmarks ) {
int dist, dx, dy;
string dir;
dx = SCX(ilandpos) - CX(pos);
dy = SCY(ilandpos) - CY(pos);
// If on top of the landmark, don't print it...
if( dx == 0 && dy == 0 )
return "This is " + ilandname + ".";
dist = abs(dx) + abs(dy); // Manhattan distance
if( abs(dx) > 2 * abs(dy) ) { // east/west
if( dx < 0 ) dir = "west";
else dir = "east";
}
else if( abs(dy) > 2 * abs(dx) ) { // north/south
if( dy < 0 ) dir = "north";
else dir = "south";
}
else { // Corner directions
if( dx < 0 && dy < 0 ) dir = "northwest";
else if( dx > 0 && dy < 0 ) dir = "northeast";
