xland/ 42755 1753 1753 0 6464513264 12030 5ustar wolfpackwolfpackxland/Graph.c100600 1753 1753 16660 6227441777 13357 0ustar wolfpackwolfpack#include /* $XConsortium: Graph.c,v 1.2 88/10/25 17:40:25 swick Exp $ */ /* Copyright Massachusetts Institute of Technology 1987, 1988 */ /* this is a modification of the template widget provided by the */ /* XConsortium. */ /* Programmer Dan Bennett */ /* The Graph Widget is the property of Kent State University */ #include #include #include #include "Graph.h" #include "GraphP.h" #include "globals.h" static char defaultTranslations[]= ": cmap() \n\ : uncmap() "; static XtResource resources[] = { #define offset(field) XtOffset(GraphWidget, graph.field) /* {name, class, type, size, offset, default_type, default_addr}, */ {XtNforeground,XtCForeground,XtRPixel, sizeof(Pixel), offset(foreground), XtRString, "XtDefaultForeground"}, {XtNbackground,XtCBackground,XtRPixel, sizeof(Pixel), offset(background), XtRString, "XtDefaultBackground"}, #undef offset }; /*******************************************************/ /* this solution (Adding a translation to map and unamp*/ /* is incorrect according to the X11R4 standards but */ /* I can't get the reccomended method to work. */ /*******************************************************/ static void CMAP(),UNCMAP(); static XtActionsRec actionsList[]= { {"cmap", CMAP}, {"uncmap", UNCMAP}, }; static void CMAP(wid,event,params,num_params) GraphWidget wid; XEvent *event; String *params; Cardinal *num_params; { XInstallColormap(XtDisplay(wid),wid->core.colormap); } static void UNCMAP(wid,event,params,num_params) GraphWidget wid; XEvent *event; String *params; Cardinal *num_params; { XUninstallColormap(XtDisplay(wid),wid->core.colormap); } void XGPCopyArea(wid,slx,sly,swd,shg,dlx,dly) GraphWidget wid; Position slx,sly,swd,shg,dlx,dly; { XCopyArea(XtDisplay(wid),wid->core.background_pixmap,XtWindow(wid), wid->graph.XGPgc,slx,sly,swd,shg, dlx,dly); } void redisplay_picture(wid) GraphWidget wid; { XSetForeground(XtDisplay(wid),wid->graph.XGPgc,0); XFillRectangle(XtDisplay(wid),wid->core.background_pixmap, wid->graph.XGPgc,0,0,wid->core.width,wid->core.height); } void XGPDrawPoint(wid,x,y,len1,len2,multfact,col) int col,x,y,len1,len2,multfact; GraphWidget wid; { if ((even(x) & even(y)) | (!even(x)& !even(y))){ XSetForeground(XtDisplay(wid),wid->graph.XGPgc,col); XDrawRectangle(XtDisplay(wid),wid->core.background_pixmap ,wid->graph.XGPgc,x*multfact,y*multfact,multfact, multfact); XFillRectangle(XtDisplay(wid),wid->core.background_pixmap, wid->graph.XGPgc,x*multfact,y*multfact,multfact, multfact); } XSetForeground(XtDisplay(wid),wid->graph.XGPgc,wid->graph.background); /* XGPCopyArea(wid,x*multfact,y*multfact,len1,len2,x*multfact,y*multfact); */ XGPCopyArea(wid,x*multfact,y*multfact,multfact+1,multfact+1,x*multfact,y*multfact); } void DrawPoint(wid,x,y,len,multfact,col) int col,x,y,len,multfact; GraphWidget wid; { if ((even(x) & even(y)) | (!even(x)& !even(y))){ XSetForeground(XtDisplay(wid),wid->graph.XGPgc,col); XDrawRectangle(XtDisplay(wid),wid->core.background_pixmap,wid->graph.XGPgc,x*multfact,y*multfact,multfact,multfact); XFillRectangle(XtDisplay(wid),wid->core.background_pixmap,wid->graph.XGPgc,x*multfact,y*multfact,multfact,multfact); } XSetForeground(XtDisplay(wid),wid->graph.XGPgc,wid->graph.background); } void displaypicture(pic,wid,len,hei,multfact) int pic[MAX_WORLD_X][MAX_WORLD_Y]; int len,hei,multfact; GraphWidget wid; { int x,y; for(x=0;xcore.width,wid->core.height,0,0); } static void XGPInitialize(junk,new) GraphWidget junk,new; { } void XGPInit(wid) GraphWidget wid; { XGPInitialize(NULL,wid); } static void XGPRealize(w,valueMask, attributes) GraphWidget w; Mask *valueMask; XSetWindowAttributes *attributes; { XGCValues values; Display *disp; int scrnnum; (widgetClassRec.core_class.realize)(w,valueMask,attributes); /*******************************************************************/ /* find the display and the screen number, then finally point to */ /* the default colormap of the wm */ /*******************************************************************/ disp = XtDisplay(w); scrnnum = XDefaultScreen(disp); /* w->core.colormap = XCreateColormap(disp,XtWindow(w) ,DefaultVisual(disp,scrnnum),AllocNone);*/ /*******************************************************************/ /* get a pixmap to draw in so that all is nice and purdy */ /*******************************************************************/ w->core.background_pixmap = XCreatePixmap(disp,XtWindow(w),w->core.width,w->core.height,XDefaultDepthOfScreen(XtScreen(w))); w->graph.XGPgc = XtGetGC(w,GCForeground|GCBackground,&values); redisplay_picture(w); } extern int widget_height,widget_width,box_size; extern Widget thegraph; extern int uimage[MAX_WORLD_X][MAX_WORLD_Y]; #define MAX(x,y) (x > y ? x : y) static void XGPResize(w,event) GraphWidget w; XEvent *event; { if (XtIsRealized(w) != True) return; else { if (bcmp(w->core.name,"hello",6) == 0){ if ((w->core.width/X_Size) < (w->core.height/Y_Size)) box_size = w->core.width/X_Size; else box_size = w->core.height/Y_Size; } redisplay_picture(w); XFreePixmap(XtDisplay(w),w->core.background_pixmap); w->core.background_pixmap = XCreatePixmap(XtDisplay(w),XtWindow(w),w->core.width,w->core.height,XDefaultDepthOfScreen(XtScreen(w))); if (bcmp(w->core.name,"hello",6) == 0) displaypicture(uimage,thegraph,X_Size,Y_Size,box_size); } } static void XGPExpose(wid,event) GraphWidget wid; XEvent *event; { XGPCopyArea(wid,0,0,wid->core.width,wid->core.height,0,0); } GraphClassRec graphClassRec = { { /* core fields */ /* superclass */ (WidgetClass) &widgetClassRec, /* class_name */ "Graph", /* widget_size */ sizeof(GraphRec), /* class_initialize */ NULL, /* class_part_initialize */ NULL, /* class_inited */ FALSE, /* initialize */ XGPInitialize, /* initialize_hook */ NULL, /* realize */ XGPRealize, /* actions */ actionsList, /* num_actions */ XtNumber(actionsList), /* resources */ resources, /* num_resources */ XtNumber(resources), /* xrm_class */ NULLQUARK, /* compress_motion */ FALSE, /* compress_exposure */ TRUE, /* compress_enterleave */ TRUE, /* visible_interest */ TRUE, /* destroy */ NULL, /* resize */ XGPResize, /* expose */ XGPExpose, /* set_values */ NULL, /* set_values_hook */ NULL, /* set_values_almost */ XtInheritSetValuesAlmost, /* get_values_hook */ NULL, /* accept_focus */ NULL, /* version */ XtVersion, /* callback_private */ NULL, /* tm_table */ defaultTranslations, /* query_geometry */ XtInheritQueryGeometry, /* display_accelerator */ XtInheritDisplayAccelerator, /* extension */ NULL }, { /* graph fields */ /* empty */ 0 } }; WidgetClass graphWidgetClass = (WidgetClass)&graphClassRec; xland/GraphColor.c100600 1753 1753 1313 6227441777 14323 0ustar wolfpackwolfpack#include "GraphP.h" /* Programmed by Dan Bennett */ /* Property of Kent State University */ unsigned long MakeColor(wid,name) GraphWidget wid; char *name; { XColor exact,close; Display *disp; Screen *scrn; int scrnnum; disp = XtDisplay(wid); scrnnum = XDefaultScreen(disp); scrn = XScreenOfDisplay(disp,scrnnum); if (XLookupColor(disp,wid->core.colormap,name,&exact,&close) == 1) { if(XAllocColor(disp,wid->core.colormap,&exact)) return(exact.pixel); else return(wid->graph.foreground); } else return(wid->graph.foreground); } xland/xland.c100600 1753 1753 61546 6227441777 13427 0ustar wolfpackwolfpack/* * land.c * * new version of empcre * Create the land masses in the game. * * Original created by James W. Anderson, 1987 * Revised by Dave Pare, 1989 * */ /* * This program was written by Dan Bennett and Yasser Doleh * The Graph Widget is the property of Kent State University * * This contains code from land.c as noted above */ #include #include #include #include #include "Command.h" #include "Form.h" #include "Graph.h" #include #include #include #include "globals.h" #include "misc.h" #include "sect.h" #include "file.h" #include #define MIN(x,y) ((x) < (y) ? (x) : (y)) char SaveFileName[80]; int mono = 0, last_x,last_y; int X_Size, Y_Size; #define rnd(x) (random() % (x)) Widget thegraph,button[3],EXACTB,value, toplevel; Widget box, Quit, Stop, Clear, UnDo, Save, Load, TITLE; void DoPoint(),UnDoPoint(),CountIt(),fillit(),DoAction(); static XtActionsRec actionList[] = {{"draw",DoPoint}, {"nodraw",UnDoPoint}, {"fillit",fillit}, {"CountIt",CountIt}, {"move",DoAction}}; int RED,GREEN,BLUE,BLACK,WHITE; int Current_Color; int Draw_Mode; int Exact = False; #define BIGV 256 /* used in making altitude */ #define SMALLV 128 /* ex-ocean: rnd(SMALLV) - rnd(BIGV) */ #define LANDMIN 1 /* altitude for normal land */ #define MOUNTMIN 108 /* altitude for mountains */ #define SECTRANGE 3 /* smoothing area */ int sectrange = SECTRANGE; int world[MAX_WORLD_X][MAX_WORLD_Y]; int uimage[MAX_WORLD_X][MAX_WORLD_Y]; int buimage[MAX_WORLD_X][MAX_WORLD_Y]; int tmp[MAX_WORLD_X][MAX_WORLD_Y]; int widget_height,widget_width,box_size; #define LMIN 0 #define LMAX 254 flood_fill(x,y,color,n) int x,y,color,n; { if (n>6) return; /* Don't fill more than 6 levels at a time */ if (((x-1)) & ((y-1))) if (uimage[x][y] == BLUE){ uimage[x][y] = color; XGPDrawPoint(thegraph,x,y,X_Size,Y_Size,box_size,color); flood_fill(x-1,y-1,color,n+1); flood_fill(x-1,y+1,color,n+1); flood_fill(x+1,y-1,color,n+1); flood_fill(x+1,y+1,color,n+1); flood_fill(x-2,y,color,n+1); flood_fill(x+2,y,color,n+1); } } flood_count(x,y) int x,y; { register int total=0; if (((x-1)) & ((y-1))) if (tmp[x][y] == GREEN){ total += 1; tmp[x][y] = -1; total += flood_count(x-1,y-1); total += flood_count(x-1,y+1); total += flood_count(x+1,y-1); total += flood_count(x+1,y+1); total += flood_count(x-2,y); total += flood_count(x+2,y); return(total); } return(0); } flood_repair(x,y,n) int x,y,n; { if (n>6) return; /* Only repair 6, since we only fill 10 */ if (((x-1)) & ((y-1))) if (uimage[x][y] == -1){ uimage[x][y] = GREEN; flood_repair(x-1,y-1,n+1); flood_repair(x-1,y+1,n+1); flood_repair(x+1,y-1,n+1); flood_repair(x+1,y+1,n+1); flood_repair(x-2,y,n+1); flood_repair(x+2,y,n+1); } } void fillit(w,event,params,num_params) Widget w; XEvent *event; String *params; int num_params; { int x,y; bzero(buimage,MAX_WORLD_X*MAX_WORLD_Y*sizeof(int)); bcopy(uimage,buimage,MAX_WORLD_X*MAX_WORLD_Y*sizeof(int)); x = (int) event->xmotion.x/ box_size; y = (int) event->xmotion.y/ box_size; if ((even(x) & !even(y)) | (even(y)& !even(x))) y++; flood_fill(x,y,Current_Color,0); } void CountIt(w,event,params,num_params) Widget w; XEvent *event; String *params; int num_params; { int x,y,z=0; Arg args[4]; char *sprintf(), buf[80]; x = (int) event->xmotion.x/ box_size; y = (int) event->xmotion.y/ box_size; if ((even(x) & !even(y)) | (even(y)& !even(x))) y++; bzero(tmp,MAX_WORLD_X*MAX_WORLD_Y*sizeof(int)); bcopy(uimage,tmp,MAX_WORLD_X*MAX_WORLD_Y*sizeof(int)); z=flood_count(x,y); sprintf(buf,"%3d Sectors",z); XtSetArg(args[0],XtNlabel,(XtArgVal) buf); XtSetValues(value,args,1); XtRealizeWidget(value); } make_altitude(world) register int world[MAX_WORLD_X][MAX_WORLD_Y]; { register int x, y,r; for (x = 0; x < X_Size; x++) for (y = 0; y < Y_Size; y++){ if (((x ^ y) & 1)){ continue; } else{ r = rnd(100)+1; if (uimage[x][y] == BLUE){ if(Exact) world[x][y] = -1-rnd(100); else{ if (r < 5) world[x][y] = rnd(107)+1; else if (r > 99) world[x][y] = 108+rnd(10); else world[x][y] = -1-rnd(100); } } else if (uimage[x][y] == RED){ if(Exact) world[x][y] = 108+rnd(10); else{ if (r < 2) world[x][y] = rnd(107)+1; else if (r > 99) world[x][y] = -1-rnd(100); else world[x][y] = 108+rnd(10); } } else{ if(Exact) world[x][y] = rnd(107)+1; else{ if (r < 5) world[x][y] = -1-rnd(100); else if (r > 96) world[x][y] = 108+rnd(10); else world[x][y] = rnd(107)+1; } } } } } make_sects(world, s) register int world[MAX_WORLD_X][MAX_WORLD_Y]; struct sctstr *s; { register struct sctstr *sct; register int i; register int x, y; int elev[12+12+3]; /* # sects from -12 to 12 in steps of 10 elev */ int range; int rangesq; int total; int sum; for (i = 0; i < 12+12+3; i++) elev[i] = 0; sum = 0; sct = s; for (y = 0; y < Y_Size; y++) for (x = 0; x < (X_Size/2); x++, sct++){ sct->sct_x = x*2 + (y & 01); sct->sct_y = y; sct->sct_dist_x = x*2 + (y & 01); sct->sct_dist_y = y; total = world[sct->sct_x][sct->sct_y]; if (total < LANDMIN) sct->sct_type = SCT_WATER; else if (total < MOUNTMIN) sct->sct_type = SCT_RURAL; else sct->sct_type = SCT_MOUNT; if (Exact) switch (sct->sct_type){ case SCT_WATER: if (uimage[sct->sct_x][sct->sct_y] != BLUE){ fprintf(stderr,"Sector %d,%d is water, should be %d (%d)!\n",sct->sct_x,sct->sct_y,uimage[sct->sct_x][sct->sct_y],total); fflush(stderr); if (uimage[sct->sct_x][sct->sct_y] == GREEN){ sct->sct_type = SCT_RURAL; total = 50; } if (uimage[sct->sct_x][sct->sct_y] == RED){ sct->sct_type = SCT_MOUNT; total = 120; } } break; case SCT_RURAL: if (uimage[sct->sct_x][sct->sct_y] !=GREEN){ fprintf(stderr,"Sector %d,%d is rural, should be %d (%d)!\n",sct->sct_x,sct->sct_y,uimage[sct->sct_x][sct->sct_y],total); fflush(stderr); if (uimage[sct->sct_x][sct->sct_y] == BLUE){ sct->sct_type = SCT_WATER; total = -50; } if (uimage[sct->sct_x][sct->sct_y] == RED){ sct->sct_type = SCT_MOUNT; total = 120; } } break; case SCT_MOUNT: if (uimage[sct->sct_x][sct->sct_y] != RED){ fprintf(stderr,"Sector %d,%d is mountain, should be %d (%d)!\n",sct->sct_x,sct->sct_y,uimage[sct->sct_x][sct->sct_y],total); fflush(stderr); if (uimage[sct->sct_x][sct->sct_y] == BLUE){ sct->sct_type = SCT_WATER; total = -50; } if (uimage[sct->sct_x][sct->sct_y] == GREEN){ sct->sct_type = SCT_RURAL; total = 50; } } break; } sct->sct_elev = total; sct->sct_newtype = sct->sct_type; sum += total; if (total < -129) elev[0]++; else if (total > 129) elev[26]++; else elev[13+total/10]++; } for (i = 0; i < 12+12+3; i++) if (elev[i] != 0) printf("%4d sectors elevation %4d to %4d\n", elev[i], 10*i - 140, 10*i - 130); } void stopit(wid,cdat,rdat) Widget wid; caddr_t cdat,rdat; { exit(0); } void quitit(wid,cdat,rdat) Widget wid; caddr_t cdat,rdat; { struct sctstr xx; char *sectors; register int n; int x, y; int i, j; long now; int fd; int left; int big,total; total=(Y_Size)*(X_Size/2)*sizeof(struct sctstr); if ((sectors=malloc(total)) == NULL){ fprintf(stderr,"Can't get a lousy %d bytes, damnit!\n",MAX_WORLD_X*MAX_WORLD_Y*sizeof(struct sctstr)); fflush(stderr); exit(-1); } bzero(sectors,total); fd = open("xland.sector.dat", O_RDWR|O_CREAT|O_TRUNC, 0660); if (fd < 0) perror("xland.sector.dat"); time(&now); srandom(now+getpid()); printf("Making altitude\n"); fflush(stdout); make_altitude(world); printf("Creating sectors\n"); fflush(stdout); make_sects(world, sectors); printf("Writing sectors\n"); fflush(stdout); n = write(fd, sectors, total); if (n < 0) perror("xland.sector.dat"); if (n != total) printf("%s: partial write\n", "xland.sector.dat"); close(fd); exit(0); } typedef enum plates { OCEAN, MOUNTAIN, LAND } plate_e; load_sectors(fn) char *fn; { FILE* fp; int x,y,q; if ((fp = fopen(fn,"r")) == NULL){ fprintf(stderr,"Cannot open %s\n",fn); fflush(stderr); return; } fscanf(fp,"%dx%d\n",&x,&y); if ((x != X_Size) || (y != Y_Size)){ fprintf(stderr,"Save file is made for a %dx%d world, not %dx%d!\n",x,y,X_Size,Y_Size); return; } bzero(uimage,MAX_WORLD_X*MAX_WORLD_Y*sizeof(int)); for(y=0;yxmotion.x/box_size; y = (int) event->xmotion.y/box_size; if (((x/2)<(X_Size/2))&&((y/2)<(Y_Size/2))){ buimage[x][y] = uimage[x][y]; uimage[x][y]=z=Current_Color; XGPDrawPoint(w,x,y,X_Size,Y_Size,box_size,z); } } void UnDoPoint(w,event,params,num_params) Widget w; XEvent *event; String *params; int num_params; { Draw_Mode = False; } void DoAction(w,event,params,num_params) Widget w; XEvent *event; String *params; int num_params; { int x,y,z; if (Draw_Mode) { x = (int) event->xmotion.x/box_size; y = (int) event->xmotion.y/box_size; if (((x/2)<(X_Size/2))&&((y/2)<(Y_Size/2))){ buimage[x][y] = uimage[x][y]; uimage[x][y]=z=Current_Color; XGPDrawPoint(w,x,y,X_Size,Y_Size,box_size,z); } } } roll(c) int c; { if (c == GREEN) return(BLUE); if (c == BLUE) return(RED); if (c == RED) return(GREEN); } main(argc,argv) int argc; char *argv[]; { Arg args[10]; int i,j,x,good=0,y,SaveFile=0; XtTranslations trans; static char trans_string[]=": draw()\n \ : nodraw()\n \ ,: CountIt()\n \ ,: fillit()\n \ :move()\n"; static XtCallbackRec action[][2]= {{{ocean,NULL},{NULL,NULL}}, {{mountain,NULL},{NULL,NULL}}, {{wilderness,NULL},{NULL,NULL}}}; static XtCallbackRec quiter[][2]= { {{quitit,NULL}, {NULL,NULL}}, {{DoExact,NULL},{NULL,NULL}}, {{undoit,NULL}, {NULL,NULL}}, {{saveit,NULL}, {NULL,NULL}}, {{stopit,NULL}, {NULL,NULL}}, {{ClearIt,NULL},{NULL,NULL}}, {{loadit,NULL}, {NULL,NULL}}}; Exact=1; bzero(SaveFileName,80); bcopy("xland.save",SaveFileName,10); bzero(world,sizeof(int)*MAX_WORLD_X*MAX_WORLD_Y); bzero(uimage,sizeof(int)*MAX_WORLD_X*MAX_WORLD_Y); bzero(buimage,sizeof(int)*MAX_WORLD_X*MAX_WORLD_Y); if (strncmp(argv[0],"mxland",6) == 0) mono = 1; x=1; while (x < argc){ if (argv[x][0] != '-'){ x++; continue; } switch(argv[x][1]){ case 'M': x++; y=0; if (!isdigit(argv[x][y])){ printf("Usage: %s -M [-G] [-S name] [-N]\n",argv[0]); printf("\n\t-G = Generate map from save file only. Don't start X\n"); printf("\t-S = Set save file name\n"); printf("\t-N = Not exact. Add miscellaneous small islands\n"); exit(0); } good=0; while (y [-G] [-S name] [-N]\n",argv[0]); printf("\n\t-G = Generate map from save file only. Don't start X\n"); printf("\t-S = Set save file name\n"); printf("\t-N = Not exact. Add miscellaneous small islands\n"); exit(0); break; case 'S': x++; if (argv[x][0] == '-'){ printf("Usage: %s -M [-G] [-S name] [-N]\n",argv[0]); printf("\n\t-G = Generate map from save file only. Don't start X\n"); printf("\t-S = Set save file name\n"); printf("\t-N = Not exact. Add miscellaneous small islands\n"); exit(0); } bzero(SaveFileName,80); bcopy(argv[x],SaveFileName,strlen(argv[x])); break; case 'G': SaveFile=1; break; case 'N': Exact=0; break; default: x++; break; } x++; } if (!good){ printf("Usage: %s -M [-G] [-S name] [-N]\n",argv[0]); printf("\n\t-G = Generate map from save file only. Don't start X\n"); printf("\n\t-S = Set save file name\n"); printf("\n\t-N = Not exact. Add miscellaneous small islands\n"); exit(0); } if ((X_Size < 16) || (Y_Size < 16)){ fprintf(stderr,"Real men don't play with worlds with dimensions smaller than 16!\n"); fflush(stderr); exit(-1); } if (SaveFile){ BLUE=1; RED=2; GREEN=3; load_sectors(SaveFileName); quitit(NULL,NULL,NULL); } toplevel = XtInitialize(argv[0],"FOURIER",NULL,0,&argc,argv); XtSetArg(args[0],XtNborderWidth,0); box = XtCreateManagedWidget("FOURIER",formWidgetClass,toplevel,args,1); XtSetArg(args[0],XtNlabel,(XtArgVal) "Empire Land Map Maker"); TITLE = XtCreateManagedWidget("label",labelWidgetClass,box,args,1); XtSetArg(args[0],XtNlabel,(XtArgVal) "Quit - Make Sector File"); XtSetArg(args[1],XtNcallback,quiter[0]); XtSetArg(args[2],XtNfromHoriz,TITLE); Quit = XtCreateManagedWidget("label",commandWidgetClass,box,args,3); XtSetArg(args[0],XtNlabel,(XtArgVal) "Stop - DO NOT MAKE SECTOR FILE"); XtSetArg(args[1],XtNfromHoriz,Quit); XtSetArg(args[2],XtNcallback,quiter[4]); Stop= XtCreateManagedWidget("label",commandWidgetClass,box,args,3); XtSetArg(args[0],XtNlabel,(XtArgVal) "OCEAN"); XtSetArg(args[1],XtNcallback,action[0]); XtSetArg(args[2],XtNfromVert,TITLE); button[0] = XtCreateManagedWidget("label",commandWidgetClass,box,args,3); XtSetArg(args[0],XtNlabel,(XtArgVal) "MOUNTAIN"); XtSetArg(args[1],XtNfromHoriz,button[0]); XtSetArg(args[2],XtNcallback,action[1]); XtSetArg(args[3],XtNfromVert,TITLE); button[1] = XtCreateManagedWidget("label",commandWidgetClass,box,args,4); XtSetArg(args[0],XtNlabel,(XtArgVal) "LAND"); XtSetArg(args[1],XtNfromHoriz,button[1]); XtSetArg(args[2],XtNcallback,action[2]); XtSetArg(args[3],XtNfromVert,TITLE); button[2] = XtCreateManagedWidget("label",commandWidgetClass,box,args,4); XtSetArg(args[0],XtNlabel,(XtArgVal) "000 Sectors"); XtSetArg(args[1],XtNfromHoriz,button[2]); XtSetArg(args[2],XtNfromVert,TITLE); value = XtCreateManagedWidget("label",labelWidgetClass,box,args,3); XtSetArg(args[0],XtNlabel,(XtArgVal) "Exact"); XtSetArg(args[1],XtNfromHoriz,value); XtSetArg(args[2],XtNcallback,quiter[1]); XtSetArg(args[3],XtNfromVert,TITLE); EXACTB = XtCreateManagedWidget("label",commandWidgetClass,box,args,4); XtSetArg(args[0],XtNlabel,(XtArgVal) "UnDo"); XtSetArg(args[1],XtNfromHoriz,EXACTB); XtSetArg(args[2],XtNcallback,quiter[2]); XtSetArg(args[3],XtNfromVert,TITLE); UnDo = XtCreateManagedWidget("label",commandWidgetClass,box,args,4); XtSetArg(args[0],XtNlabel,(XtArgVal) "Save"); XtSetArg(args[1],XtNfromHoriz,UnDo); XtSetArg(args[2],XtNcallback,quiter[3]); XtSetArg(args[3],XtNfromVert,TITLE); Save = XtCreateManagedWidget("label",commandWidgetClass,box,args,4); XtSetArg(args[0],XtNlabel,(XtArgVal) "Load"); XtSetArg(args[1],XtNfromHoriz,Save); XtSetArg(args[2],XtNcallback,quiter[6]); XtSetArg(args[3],XtNfromVert,TITLE); Load = XtCreateManagedWidget("label",commandWidgetClass,box,args,4); XtSetArg(args[0],XtNlabel,(XtArgVal) "Clear"); XtSetArg(args[1],XtNfromHoriz,Load); XtSetArg(args[2],XtNcallback,quiter[5]); XtSetArg(args[3],XtNfromVert,TITLE); Clear = XtCreateManagedWidget("label",commandWidgetClass,box,args,4); box_size = MIN(800/X_Size,800/Y_Size); XtSetArg(args[0],XtNheight,Y_Size*box_size); XtSetArg(args[1],XtNwidth,X_Size*box_size); XtSetArg(args[2],XtNfromVert,button[0]); thegraph = XtCreateManagedWidget("hello",graphWidgetClass,box,args,3); XtAddActions(actionList,XtNumber(actionList)); trans = XtParseTranslationTable(trans_string); XtOverrideTranslations(thegraph,trans); XtRealizeWidget(toplevel); BLACK = MakeColor(thegraph,"BLACK"); WHITE = MakeColor(thegraph,"WHITE"); if (mono){ RED = MakeColor(thegraph,"BLACK"); GREEN = MakeColor(thegraph,"BLACK"); BLUE = MakeColor(thegraph,"WHITE"); }else{ RED = MakeColor(thegraph,"RED"); GREEN = MakeColor(thegraph,"Green"); BLUE = MakeColor(thegraph,"Blue"); } Current_Color = RED; ClearIt(thegraph,NULL,NULL); wilderness(button[1],NULL,NULL); Exact = (Exact == 1 ? 0 : 1); DoExact(EXACTB,NULL,NULL); XtMainLoop(); } xland/xlandutil.c100600 1753 1753 27115 6227441777 14317 0ustar wolfpackwolfpack/* * land.c * * new version of empcre * Create the land masses in the game. * * Original created by James W. Anderson, 1987 * Revised by Dave Pare, 1989 * */ /* * This program was written by Dan Bennett and Yasser Doleh * The Graph Widget is the property of Kent State University * * This contains code from land.c as noted above */ #include #include #include #include "globals.h" #include "misc.h" #include "sect.h" #include "file.h" #include char SaveFileName[80]; int X_Size, Y_Size; #define rnd(x) (random() % (x)) int RED,GREEN,BLUE,BLACK,WHITE; int Exact = 0; #define BIGV 256 /* used in making altitude */ #define SMALLV 128 /* ex-ocean: rnd(SMALLV) - rnd(BIGV) */ #define LANDMIN 1 /* altitude for normal land */ #define MOUNTMIN 108 /* altitude for mountains */ #define SECTRANGE 3 /* smoothing area */ int sectrange = SECTRANGE; int world[MAX_WORLD_X][MAX_WORLD_Y]; int uimage[MAX_WORLD_X][MAX_WORLD_Y]; int buimage[MAX_WORLD_X][MAX_WORLD_Y]; int tmp[MAX_WORLD_X][MAX_WORLD_Y]; #define LMIN 0 #define LMAX 254 make_altitude(world) register int world[MAX_WORLD_X][MAX_WORLD_Y]; { register int x, y,r; for (y = 0; y < Y_Size; y++) for (x = 0; x < X_Size; x++){ if (((x ^ y) & 1)){ continue; } else{ r = rnd(100)+1; if (uimage[x][y] == BLUE){ if(Exact) world[x][y] = -1-rnd(100); else{ if (r < 5) world[x][y] = rnd(107)+1; else if (r > 99) world[x][y] = 108+rnd(10); else world[x][y] = -1-rnd(100); } } else if (uimage[x][y] == RED){ if(Exact) world[x][y] = 108+rnd(10); else{ if (r < 2) world[x][y] = rnd(107)+1; else if (r > 99) world[x][y] = -1-rnd(100); else world[x][y] = 108+rnd(10); } } else{ if(Exact) world[x][y] = rnd(107)+1; else{ if (r < 5) world[x][y] = -1-rnd(100); else if (r > 96) world[x][y] = 108+rnd(10); else world[x][y] = rnd(107+1); } } } } } make_sects(world, s) register int world[MAX_WORLD_X][MAX_WORLD_Y]; struct sctstr *s; { register struct sctstr *sct; register int i; register int x, y; int elev[12+12+3]; /* # sects from -12 to 12 in steps of 10 elev */ int range; int rangesq; int total; int sum; for (i = 0; i < 12+12+3; i++) elev[i] = 0; sum = 0; sct = s; for (y = 0; y < Y_Size; y++) for (x = 0; x < (X_Size/2); x++, sct++){ sct->sct_x = x*2 + (y & 01); sct->sct_y = y; sct->sct_dist_x = x*2 + (y & 01); sct->sct_dist_y = y; total = world[sct->sct_x][sct->sct_y]; if (total < LANDMIN) sct->sct_type = SCT_WATER; else if (total < MOUNTMIN) sct->sct_type = SCT_RURAL; else sct->sct_type = SCT_MOUNT; if (Exact) switch (sct->sct_type){ case SCT_WATER: if (uimage[sct->sct_x][sct->sct_y] != BLUE){ fprintf(stderr,"Sector %d,%d is water, should be %d (%d)!\n",sct->sct_x,sct->sct_y,uimage[sct->sct_x][sct->sct_y],total); fflush(stderr); if (uimage[sct->sct_x][sct->sct_y] == GREEN){ sct->sct_type = SCT_RURAL; total = 50; } if (uimage[sct->sct_x][sct->sct_y] == RED){ sct->sct_type = SCT_MOUNT; total = 120; } } break; case SCT_RURAL: if (uimage[sct->sct_x][sct->sct_y] !=GREEN){ fprintf(stderr,"Sector %d,%d is rural, should be %d (%d)!\n",sct->sct_x,sct->sct_y,uimage[sct->sct_x][sct->sct_y],total); fflush(stderr); if (uimage[sct->sct_x][sct->sct_y] == BLUE){ sct->sct_type = SCT_WATER; total = -50; } if (uimage[sct->sct_x][sct->sct_y] == RED){ sct->sct_type = SCT_MOUNT; total = 120; } } break; case SCT_MOUNT: if (uimage[sct->sct_x][sct->sct_y] != RED){ fprintf(stderr,"Sector %d,%d is mountain, should be %d (%d)!\n",sct->sct_x,sct->sct_y,uimage[sct->sct_x][sct->sct_y],total); fflush(stderr); if (uimage[sct->sct_x][sct->sct_y] == BLUE){ sct->sct_type = SCT_WATER; total = -50; } if (uimage[sct->sct_x][sct->sct_y] == GREEN){ sct->sct_type = SCT_RURAL; total = 50; } } break; } sct->sct_elev = total; sct->sct_newtype = sct->sct_type; sum += total; if (total < -129) elev[0]++; else if (total > 129) elev[26]++; else elev[13+total/10]++; } for (i = 0; i < 12+12+3; i++) if (elev[i] != 0) printf("%4d sectors elevation %4d to %4d\n", elev[i], 10*i - 140, 10*i - 130); } void quitit() { struct sctstr xx; char *sectors; register int n; int x, y; int i, j; long now; int fd; int left; int big,total; total=(Y_Size)*(X_Size/2)*sizeof(struct sctstr); if ((sectors=malloc(total)) == NULL){ fprintf(stderr,"Can't get a lousy %d bytes, damnit!\n",MAX_WORLD_X*MAX_WORLD_Y*sizeof(struct sctstr)); fflush(stderr); exit(-1); } bzero(sectors,total); fd = open("xland.sector.dat", O_RDWR|O_CREAT|O_TRUNC, 0660); if (fd < 0) perror("xland.sector.dat"); time(&now); srandom(now+getpid()); printf("Making altitude\n"); fflush(stdout); make_altitude(world); printf("Creating sectors\n"); fflush(stdout); make_sects(world, sectors); printf("Writing sectors\n"); fflush(stdout); n = write(fd, sectors, total); if (n < 0) perror("xland.sector.dat"); if (n != total) printf("%s: partial write\n", "xland.sector.dat"); close(fd); exit(0); } typedef enum plates { OCEAN, MOUNTAIN, LAND } plate_e; load_sectors(fn) char *fn; { FILE* fp; int x,y,q; if ((fp = fopen(fn,"r")) == NULL){ fprintf(stderr,"Cannot open %s\n",fn); fflush(stderr); return; } fscanf(fp,"%dx%d\n",&x,&y); if ((x != X_Size) || (y != Y_Size)){ fprintf(stderr,"Save file is made for a %dx%d world, not %dx%d!\n",x,y,X_Size,Y_Size); return; } for(y=0;y [-G] [-S name] [-N]\n",argv[0]); printf("\n\t-G = Generate map from save file only. Don't start X\n"); printf("\t-S = Set save file name\n"); printf("\t-N = Not exact. Add miscellaneous small islands\n"); exit(0); } good=0; while (y [-G] [-S name] [-N]\n",argv[0]); printf("\n\t-G = Generate map from save file only. Don't start X\n"); printf("\t-S = Set save file name\n"); printf("\t-N = Not exact. Add miscellaneous small islands\n"); exit(0); break; case 'S': x++; if (argv[x][0] == '-'){ printf("Usage: %s -M [-G] [-S name] [-N]\n",argv[0]); printf("\n\t-G = Generate map from save file only. Don't start X\n"); printf("\t-S = Set save file name\n"); printf("\t-N = Not exact. Add miscellaneous small islands\n"); exit(0); } bzero(SaveFileName,80); bcopy(argv[x],SaveFileName,strlen(argv[x])); break; case 'G': SaveFile=1; break; case 'N': Exact=0; break; default: x++; break; } x++; } if (!good){ printf("Usage: %s -M [-G] [-S name] [-N]\n",argv[0]); printf("\n\t-G = Generate map from save file only. Don't start X\n"); printf("\t-S = Set save file name\n"); printf("\t-N = Not exact. Add miscellaneous small islands\n"); exit(0); } if ((X_Size < 16) || (Y_Size < 16)){ fprintf(stderr,"Real men don't play with worlds with dimensions smaller than 16!\n"); fflush(stderr); exit(-1); } BLUE=0; RED=1; GREEN=2; load_sectors(SaveFileName); quitit(); } xland/Makefile100600 1753 1753 737 6227441777 13550 0ustar wolfpackwolfpackCC = cc CFLAGS = -O2 LIB1 = -ll -lm -lXaw -lXmu -lXt -lX11 INC = /usr/include/Xw OBJS = Graph.o GraphColor.o xland.o SRCS = Graph.c GraphColor.c xland : xlandutil xland.c $(OBJS) $(CC) -o xland $(OBJS) $(CFLAGS) $(LIB1) rm -f mxland ln xland mxland xlandutil: xlandutil.o $(CC) -o xlandutil xlandutil.o $(CFLAGS) -lm .c.o : $(CC) -c $< $(CFLAGS) clean : rm -f *.o core xland land.output xland.o : xland.c Graph.o : Graph.h GraphP.h GraphColor.o : Graph.h GraphP.h xland/README100600 1753 1753 11075 6227441777 13025 0ustar wolfpackwolfpack[Xland was originally created by Dan Bennet. This is a version I hacked ---ts] Xland is a land creation program for empire version 1.x. It allows a diety to create a world. It requires a X terminal which can display at least 5 colors. (I suspect you could hack it to work with four but less would be a problem) You may also use monochrome mode by using mxland instead of xland. (both are made when you compile) There is one command line argument, the size of the world in the form XxY. (For example 32x32, 64x64, 128x256, etc). Xland works well up to about 256x256. After that, the boxes become too small to see, unless you have a very high resolution screen. (But heck, real men don't play in worlds that big, right?) The world is initalized to all ocean. Pressing the left mouse button will allow a diety to "draw" contents, islands, and ocean. The middle button will count the size of the island under the mouse. The right button will flood-fill the current land type onto the current area (maximum of 20 sectors so that you don't accidentally fill the whole map). Ocean - select ocean as current land type to draw with Land - select land as the current land type to draw with Mountain - select mountains as current land type to draw with Clear - reset the world to ocean Exact - make the world the exact shape drawn. The default value for this button is on. If this mode is off, the world will be close to what you draw but not exactly the same. (It will create a lot of 1-2 sector islands, and modify a few of the sectors you drew) UnDo - undo last fill. Save - save the current world to xland.output Load - load the map in the file xland.output Quit - Make the world with the current map. The output sector file will be put in xland.sector.dat. This file can be used directly as an EMPIRE sector file. Once you have made a sector file with xland, you can simply move it into your empire data directory (rename it to sector, the file empire uses), run ore, and you're all set. (Ore works properly, since xland sets elevation levels appropriately for all sectors. Hand designating sectors as the deity does not set them appropriately, which is why ore does not work on a map such as that.) One caveat. You MUST run xland on a machine with the same type sizes as the machine you're running Empire on. If one machine thinks ints are 2 byts and the other thinks they're 4, you got problems. The easiest way is to run them on the same machine, or same make of machine, of course. Otherwise, try it and see... [The following comments come from Dan Bennet] FILES Graph* various files for the Graph Widget. OK OK this was part of my masters thesis and I want to use it wherever I can. Makefile (I dont really want to convert this to gnumake) xland.c the program. I suppose that this belongs to Kent State but you should feel free to hack this at will [I did. :-) --ts]. Jeff Bailey is cordinating the KSU empire stuff so you should probably send worthwhile hacks, bug reports, and suggestions for improvements back to me or him. bennett@mcs.kent.edu bailey@mcs.kent.edu doleh@mcs.kent.edu empire@mcs.kent.edu Dan Bennett -------------------------------------------------------------------------------- Dan, Significant CHANGES from the original: Ok. I took out most of the buttons, as I didn't want a thing that made land kind of like I wanted, I wanted to make land EXACTLY as I wanted. So, there are now buttons for land, mountain, and ocean. I made a load button, so that xland can save a map it, and then load it back and work on it again. The exact button didn't really work before, now it does. The window can now be resized, and will work correctly, adjusting the size of the boxes for the sectors. Oh, I also took out some of the global arrays to make it compile faster and smaller, and re-did the commenting style, and I couldn't stand it. (Commenting styles are very personal... I just happen to use a different one) I took out the includes of the empire files, to permit its use on a machine that doesn't have source on-line. This can be a source of problems, as the .h files in this directory need to match the .h files in the empire version you're using. Oh, well, it seemed like a good trade-off. BTW, I don't really know much X programming, so most of this is just hacks... Hopefully I haven't introduced any portability problems (your code compiled beautifully on my Tek 4317) Tom P.S. Things I'd still like to add when I have the time: 1) Make it save in a file of your choice (dialog box) 2) Make it write the sector file in a file of your choice (dialog box) xland/Command.h100600 1753 1753 5627 6227441777 13662 0ustar wolfpackwolfpack/* $Header: Command.h,v 1.3 88/11/08 17:47:07 davidsc Exp $ */ /* * $XConsortium: Command.h,v 1.17 88/10/23 13:28:49 swick Exp $ */ /*********************************************************** Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts, and the Massachusetts Institute of Technology, Cambridge, Massachusetts. All Rights Reserved Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the names of Digital or MIT not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ******************************************************************/ #ifndef _XtCommand_h #define _XtCommand_h /*********************************************************************** * * Command Widget * ***********************************************************************/ #include "Label.h" /* Resources: Name Class RepType Default Value ---- ----- ------- ------------- background Background Pixel XtDefaultBackground bitmap Pixmap Pixmap None border BorderColor Pixel XtDefaultForeground borderWidth BorderWidth Dimension 1 callback Callback Pointer NULL cursor Cursor Cursor None destroyCallback Callback Pointer NULL font Font XFontStructx* XtDefaultFont foreground Foreground Pixel XtDefaultForeground height Height Dimension text height highlightThickness Thickness Dimension 2 insensitiveBorder Insensitive Pixmap Gray internalHeight Height Dimension 2 internalWidth Width Dimension 4 justify Justify XtJustify XtJustifyCenter label Label String NULL mappedWhenManaged MappedWhenManaged Boolean True resize Resize Boolean True sensitive Sensitive Boolean True width Width Dimension text width x Position Position 0 y Position Position 0 */ #define XtNcallback "callback" #define XtNhighlightThickness "highlightThickness" #define XtNtranslations "translations" extern WidgetClass commandWidgetClass; typedef struct _CommandClassRec *CommandWidgetClass; typedef struct _CommandRec *CommandWidget; #endif _XtCommand_h /* DON'T ADD STUFF AFTER THIS */ xland/Constraint.h100600 1753 1753 3213 6227441777 14415 0ustar wolfpackwolfpack/* $Header: Constraint.h,v 1.3 88/11/08 18:21:43 davidsc Exp $ */ /* $XConsortium: Constraint.h,v 1.8 88/09/06 16:27:20 jim Exp $ */ /* $oHeader: Constraint.h,v 1.2 88/08/18 15:54:18 asente Exp $ */ /*********************************************************** Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts, and the Massachusetts Institute of Technology, Cambridge, Massachusetts. All Rights Reserved Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the names of Digital or MIT not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ******************************************************************/ #ifndef _XtConstraint_h #define _XtConstraint_h typedef struct _ConstraintClassRec *ConstraintWidgetClass; #ifndef CONSTRAINT externalref WidgetClass constraintWidgetClass; #endif #endif _XtConstraint_h /* DON'T ADD STUFF AFTER THIS #endif */ xland/Form.h100600 1753 1753 7341 6227442000 13156 0ustar wolfpackwolfpack/* $Header: Form.h,v 1.4 88/11/08 17:51:05 davidsc Exp $ */ /* $XConsortium: Form.h,v 1.16 88/10/23 13:39:30 swick Exp $ */ /*********************************************************** Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts, and the Massachusetts Institute of Technology, Cambridge, Massachusetts. All Rights Reserved Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the names of Digital or MIT not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ******************************************************************/ #ifndef _Form_h #define _Form_h #include /*********************************************************************** * * Form Widget * ***********************************************************************/ /* Parameters: Name Class RepType Default Value ---- ----- ------- ------------- background Background Pixel XtDefaultBackground border BorderColor Pixel XtDefaultForeground borderWidth BorderWidth Dimension 1 defaultDistance Thickness int 4 destroyCallback Callback Pointer NULL height Height Dimension computed at realize mappedWhenManaged MappedWhenManaged Boolean True sensitive Sensitive Boolean True width Width Dimension computed at realize x Position Position 0 y Position Position 0 */ /* Constraint parameters: Name Class RepType Default Value ---- ----- ------- ------------- bottom Edge XtEdgeType XtRubber fromHoriz Widget Widget (left edge of form) fromVert Widget Widget (top of form) horizDistance Thickness int defaultDistance left Edge XtEdgeType XtRubber resizable Boolean Boolean False right Edge XtEdgeType XtRubber top Edge XtEdgeType XtRubber vertDistance Thickness int defaultDistance */ #define XtNdefaultDistance "defaultDistance" #define XtNtop "top" #define XtNbottom "bottom" #define XtNleft "left" #define XtNright "right" #define XtNfromHoriz "fromHoriz" #define XtNfromVert "fromVert" #define XtNhorizDistance "horizDistance" #define XtNvertDistance "vertDistance" #define XtNresizable "resizable" #define XtCEdge "Edge" #define XtCWidget "Widget" #define XtRWidget "Widget" #ifndef _XtEdgeType_e #define _XtEdgeType_e typedef enum { XtChainTop, /* Keep this edge a constant distance from the top of the form */ XtChainBottom, /* Keep this edge a constant distance from the bottom of the form */ XtChainLeft, /* Keep this edge a constant distance from the left of the form */ XtChainRight, /* Keep this edge a constant distance from the right of the form */ XtRubber /* Keep this edge a proportional distance from the edges of the form*/ } XtEdgeType; #endif _XtEdgeType_e typedef struct _FormClassRec *FormWidgetClass; typedef struct _FormRec *FormWidget; extern WidgetClass formWidgetClass; #endif _Form_h xland/Graph.h100600 1753 1753 3426 6227442000 13314 0ustar wolfpackwolfpack/* $XConsortium: Graph.h,v 1.2 88/10/25 17:22:09 swick Exp $ */ /* Copyright Massachusetts Institute of Technology 1987, 1988 */ /* Programmed by Dan Bennett */ #ifndef _Graph_h #define _Graph_h /**************************************************************** * * Graph widget * ****************************************************************/ /* Resources: Name Class RepType Default Value ---- ----- ------- ------------- background Background Pixel XtDefaultBackground border BorderColor Pixel XtDefaultForeground borderWidth BorderWidth Dimension 1 destroyCallback Callback Pointer NULL height Height Dimension 0 mappedWhenManaged MappedWhenManaged Boolean True sensitive Sensitive Boolean True width Width Dimension 0 x Position Position 0 y Position Position 0 font Font XFontStruct* XtDefaultFont foreground Foreground Pixel XtDefaultForeground buisy Buisy Callback NULL response Response Callback NULL */ /* define any special resource names here that are not in */ #ifndef XtNforeground #define XtNforeground "foreground" #define XtNbackground "background" #endif #ifndef XtCForeground #define XtCForeground "Foreground" #define XtCBackground "Background" #endif extern void displaypicture(); /* declare specific GraphWidget class and instance datatypes */ typedef struct _GraphClassRec* GraphWidgetClass; typedef struct _GraphRec* GraphWidget; /* declare the class constant */ extern WidgetClass graphWidgetClass; #define even(x) ((x&1) != 1 ) #endif _Graph_h xland/GraphP.h100600 1753 1753 1705 6227442000 13432 0ustar wolfpackwolfpack/* $XConsortium: GraphP.h,v 1.2 88/10/25 17:37:59 swick Exp $ */ /* Copyright Massachusetts Institute of Technology 1987, 1988 */ #ifndef _GraphP_h #define _GraphP_h /* include superclass private header file */ #include #include #include "Graph.h" /* define unique representation types not found in */ #define XtRGraphResource "GraphResource" #ifndef TRUE #define TRUE 1 #endif #ifndef FALSE #define FALSE 0 #endif #define OutOfMemmory 1 typedef struct { int empty; } GraphClassPart; typedef struct _GraphClassRec { CoreClassPart core_class; GraphClassPart graph_class; } GraphClassRec; extern GraphClassRec graphClassRec; typedef struct { /*resources */ int empty; Pixel foreground, background, fghold,bghold; GC XGPgc; } GraphPart; typedef struct _GraphRec { CorePart core; GraphPart graph; } GraphRec; #endif _GraphP_h xland/Label.h100600 1753 1753 6005 6227442000 13266 0ustar wolfpackwolfpack/* $Header: Label.h,v 1.3 88/11/08 17:54:55 davidsc Exp $ */ /* * $XConsortium: Label.h,v 1.20 88/10/23 13:45:42 swick Exp $ */ /*********************************************************** Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts, and the Massachusetts Institute of Technology, Cambridge, Massachusetts. All Rights Reserved Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the names of Digital or MIT not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ******************************************************************/ #ifndef _XtLabel_h #define _XtLabel_h /*********************************************************************** * * Label Widget * * ***********************************************************************/ #include "Simple.h" /* Resources: Name Class RepType Default Value ---- ----- ------- ------------- background Background Pixel XtDefaultBackground bitmap Pixmap Pixmap None border BorderColor Pixel XtDefaultForeground borderWidth BorderWidth Dimension 1 cursor Cursor Cursor None destroyCallback Callback XtCallbackList NULL font Font XFontStruct* XtDefaultFont foreground Foreground Pixel XtDefaultForeground height Height Dimension text height insensitiveBorder Insensitive Pixmap Gray internalHeight Height Dimension 2 internalWidth Width Dimension 4 justify Justify XtJustify XtJustifyCenter label Label String NULL mappedWhenManaged MappedWhenManaged Boolean True resize Resize Boolean True sensitive Sensitive Boolean True width Width Dimension text width x Position Position 0 y Position Position 0 */ #include "Xmu.h" #define XtNbitmap "bitmap" #define XtNforeground "foreground" #define XtNlabel "label" #define XtNfont "font" #define XtNinternalWidth "internalWidth" #define XtNinternalHeight "internalHeight" #define XtNresize "resize" #define XtCResize "Resize" #define XtCBitmap "Bitmap" /* Class record constants */ extern WidgetClass labelWidgetClass; typedef struct _LabelClassRec *LabelWidgetClass; typedef struct _LabelRec *LabelWidget; #endif _XtLabel_h /* DON'T ADD STUFF AFTER THIS #endif */ xland/Simple.h100600 1753 1753 2400 6227442000 13473 0ustar wolfpackwolfpack/* $Header: Simple.h,v 1.3 88/11/08 18:04:08 davidsc Exp $ */ /* $XConsortium: Simple.h,v 1.6 88/10/23 14:31:50 swick Exp $ */ /* Copyright Massachusetts Institute of Technology 1987 */ #ifndef _Simple_h #define _Simple_h /**************************************************************** * * Simple widgets * ****************************************************************/ /* Resources: Name Class RepType Default Value ---- ----- ------- ------------- background Background Pixel XtDefaultBackground border BorderColor Pixel XtDefaultForeground borderWidth BorderWidth Dimension 1 cursor Cursor Cursor None destroyCallback Callback Pointer NULL height Height Dimension 0 insensitiveBorder Insensitive Pixmap Gray mappedWhenManaged MappedWhenManaged Boolean True sensitive Sensitive Boolean True width Width Dimension 0 x Position Position 0 y Position Position 0 */ #define XtNcursor "cursor" #define XtNinsensitiveBorder "insensitiveBorder" #define XtCCursor "Cursor" #define XtCInsensitive "Insensitive" typedef struct _SimpleClassRec *SimpleWidgetClass; typedef struct _SimpleRec *SimpleWidget; extern WidgetClass simpleWidgetClass; #endif _Simple_h xland/Xmu.h100600 1753 1753 10126 6227442000 13037 0ustar wolfpackwolfpack/* $Header: Xmu.h,v 1.2 88/11/08 18:16:28 davidsc Exp $ */ /* * $XConsortium: Xmu.h,v 1.11 88/10/21 17:44:07 jim Exp $ * * Copyright 1988 by the Massachusetts Institute of Technology * * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose and without fee is hereby granted, provided * that the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of M.I.T. not be used in advertising * or publicity pertaining to distribution of the software without specific, * written prior permission. M.I.T. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * The X Window System is a Trademark of MIT. * * The interfaces described by this header file are for miscellaneous utilities * and are not part of the Xlib standard. */ #ifndef _XMU_H_ #define _XMU_H_ #include typedef struct _AtomRec* AtomPtr; #ifdef _Atoms_c_ #define globalref #else #define globalref extern #endif /*_Atoms_c_*/ globalref AtomPtr _XA_TEXT, _XA_TIMESTAMP, _XA_LIST_LENGTH, _XA_LENGTH, _XA_TARGETS, _XA_CHARACTER_POSITION, _XA_DELETE, _XA_HOSTNAME, _XA_IP_ADDRESS, _XA_DECNET_ADDRESS, _XA_USER, _XA_CLASS, _XA_NAME, _XA_CLIENT_WINDOW, _XA_ATOM_PAIR, _XA_SPAN, _XA_NET_ADDRESS, _XA_NULL, _XA_FILENAME, _XA_OWNER_OS, _XA_CLIPBOARD; /* * types and constants */ typedef enum { XtJustifyLeft, /* justify text to left side of button */ XtJustifyCenter, /* justify text in center of button */ XtJustifyRight /* justify text to right side of button */ } XtJustify; typedef enum {XtorientHorizontal, XtorientVertical} XtOrientation; #define XtNbackingStore "backingStore" #define XtCBackingStore "BackingStore" #define XtRBackingStore "BackingStore" /* BackingStore constants */ #define XtEnotUseful "notUseful" #define XtEwhenMapped "whenMapped" #define XtEalways "always" #define XtEdefault "default" /* Justify constants */ #define XtEleft "left" #define XtEcenter "center" #define XtEright "right" /* * public entry points */ Boolean XmuConvertStandardSelection( /* Widget, Time, Atom*, ... */ ); void XmuCopyISOLatin1Lowered(); void XmuDrawRoundedRectangle(); Pixmap XmuCreatePixmapFromBitmap(); void XmuCvtFunctionToCallback(); void XmuCvtStringToBackingStore(); void XmuCvtStringToCursor(); void XmuCvtStringToJustify(); void XmuCvtStringToOrientation(); void XmuCvtStringToPixmap(); void XmuCvtStringToWidget(); AtomPtr XmuMakeAtom( /* char* */ ); Atom XmuInternAtom( /* Display*, AtomPtr */ ); void XmuInternStrings( /* Display*, String*, Cardinal, Atom* */); char *XmuGetAtomName( /* Display*, Atom */ ); char *XmuNameOfAtom( /* AtomPtr */ ); int XmuReadBitmapDataFromFile(); int XmuPrintDefaultErrorMessage(); #ifndef _Atoms_c_ #define XA_ATOM_PAIR(d) XmuInternAtom(d, _XA_ATOM_PAIR) #define XA_CHARACTER_POSITION(d) XmuInternAtom(d, _XA_CHARACTER_POSITION) #define XA_CLASS(d) XmuInternAtom(d, _XA_CLASS) #define XA_CLIENT_WINDOW(d) XmuInternAtom(d, _XA_CLIENT_WINDOW) #define XA_CLIPBOARD(d) XmuInternAtom(d, _XA_CLIPBOARD) #define XA_DECNET_ADDRESS(d) XmuInternAtom(d, _XA_DECNET_ADDRESS) #define XA_DELETE(d) XmuInternAtom(d, _XA_DELETE) #define XA_FILENAME(d) XmuInternAtom(d, _XA_FILENAME) #define XA_HOSTNAME(d) XmuInternAtom(d, _XA_HOSTNAME) #define XA_IP_ADDRESS(d) XmuInternAtom(d, _XA_IP_ADDRESS) #define XA_LENGTH(d) XmuInternAtom(d, _XA_LENGTH) #define XA_LIST_LENGTH(d) XmuInternAtom(d, _XA_LIST_LENGTH) #define XA_NAME(d) XmuInternAtom(d, _XA_NAME) #define XA_NET_ADDRESS(d) XmuInternAtom(d, _XA_NET_ADDRESS) #define XA_NULL(d) XmuInternAtom(d, _XA_NULL) #define XA_OWNER_OS(d) XmuInternAtom(d, _XA_OWNER_OS) #define XA_SPAN(d) XmuInternAtom(d, _XA_SPAN) #define XA_TARGETS(d) XmuInternAtom(d, _XA_TARGETS) #define XA_TEXT(d) XmuInternAtom(d, _XA_TEXT) #define XA_TIMESTAMP(d) XmuInternAtom(d, _XA_TIMESTAMP) #define XA_USER(d) XmuInternAtom(d, _XA_USER) #endif /*_Atoms_c_*/ #endif /* _XMU_H_ */ xland/file.h100600 1753 1753 2777 6227442000 13202 0ustar wolfpackwolfpack/* * file.h * * Describes Empire files and their contents. * * $Revision: 1.5 $ $Date: 89/09/17 14:50:23 $ */ struct empfile { s_char *name; /* file name (e.g., "treaty") */ s_char *file; /* file path */ int flags; /* misc stuff */ int mode; /* O_flags */ int size; /* size of object */ int (*postread)(); /* specific massage routines for items */ int (*prewrite)(); int varoffs[3]; /* struct offs for nv, vtype, vamt */ int maxvars; /* max # vars for type */ int fd; /* file descriptor */ int baseid; /* starting item in cache */ int cids; /* # ids in cache */ int csize; /* size of cache in bytes */ caddr_t cache; /* pointer to cache */ int fids; /* # of ids in file */ struct castr *cadef; /* ca defs selection list */ }; #define EFF_COM bit(0) /* item has commodities attached */ #define EFF_XY bit(1) /* has location */ #define EFF_MEM bit(2) /* stored entirely in-memory */ #define EFF_OWNER bit(3) /* has concept of owner */ #define EFF_GROUP bit(4) /* has concept of group */ #define EF_SECTOR 0 #define EF_NEWS 1 #define EF_LOAN 2 #define EF_SHIP 3 #define EF_PLANE 4 #define EF_TREATY 5 #define EF_NUKE 6 #define EF_TRADE 7 #define EF_POWER 8 #define EF_NATION 9 #define EF_LAND 10 #define EF_MAX 11 struct fileinit { int (*postread)(); int (*prewrite)(); struct castr *cadef; }; extern struct castr *ef_cadef(); extern int ef_read(); extern int ef_nbread(); extern s_char *ef_ptr(); extern s_char *ef_nameof(); extern time_t ef_mtime(); extern struct empfile empfile[]; xland/globals.h100600 1753 1753 113 6227442000 13644 0ustar wolfpackwolfpack#define MAX_WORLD_X 512 #define MAX_WORLD_Y 512 extern int X_Size, Y_Size; xland/misc.h100600 1753 1753 4430 6227442000 13202 0ustar wolfpackwolfpack/* * misc.h * * defines which don't really belong anywhere, * but have to go somewhere! * * $Revision: 1.4 $ $Date: 89/06/01 14:18:30 $ */ #include #include #include #ifdef hpux #include #else #include #endif #include "options.h" #define MAXNOC 100 #define WORLD_X 192 #define WORLD_Y 96 #define ETUS 60 /* Defined here.. may be overridden later, but things still use this define */ typedef u_char natid; /* also change NSC_NATID in nsc.h */ #if !defined(aix) && !defined(sgi) #ifndef ultrix /* already defined in ultrix */ typedef char s_char; /* change to signed char for aix */ #endif ultrix #else typedef signed char s_char; #endif /* !aix && !sgi */ typedef short coord; /* also change NSC_COORD in nsc.h */ /* * watch it; your compiler might not like this. * If you think this is bogus, look at /usr/include/struct.h */ #define OFFSET(stype, oset) ((int)(&(((struct stype *)0)->oset))) #define SETOFF(sinst, oset) ((s_char *) (sinst) + (oset)) #ifndef bit #define bit(x) (1<<(x)) #endif #define minutes(x) (60*(x)) #define hours(x) (60*60*(x)) #define days(x) (60*60*24*(x)) typedef void (*voidfunc)(); /* return codes from command routines */ #define RET_OK 0 /* command completed sucessfully */ #define RET_FAIL 1 /* command completed unsucessfully [?] */ #define RET_SYN 2 /* syntax error in command */ #define RET_SYS 3 /* system error (missing file, etc) */ #define MAX_DISTPATH_LEN 10 /* Has to go somewhere */ /* * references to library functions which aren't related to any * particular object, and are of general interest */ extern long random(); extern double dmax(); extern double dmin(); extern s_char *fmt(); extern s_char *copy(); extern s_char *numstr(); extern s_char *esplur(); extern s_char *splur(); extern s_char *iesplur(); extern s_char *plur(); extern s_char *getstarg(); extern s_char *getstring(); /* * frequently used libc functions */ extern s_char *malloc(); extern s_char *calloc(); #if (!defined (aix) && !defined (sgi)) extern s_char *ctime(); extern s_char *strncpy(); extern s_char *strcpy(); #ifndef NeXT extern s_char *index(); extern s_char *rindex(); #endif /* NeXT */ #endif /* !aix && !sgi*/ extern time_t time(); extern double atof(); extern s_char *sprintf(); xland/sect.h100600 1753 1753 7605 6227442001 13215 0ustar wolfpackwolfpack/* * sect.h * * things having to do with sectors * * from PSL Empire, 1985 * $Revision: 1.6 $ $Date: 89/06/01 14:18:51 $ */ /* * each "point" of MAXSCTV costs 32k for 128x128. * MAXSCTV = 20 ==> 655k for the commodities alone! * * If you set this to I_MAX*3, you'll never run ou * of slots, which is nice. (You'll eat a lot of * space, tho) */ #define MAXSCTV 42 struct sctstr { coord sct_x; /* x coord of sector */ coord sct_y; /* y coord of sector */ natid sct_own; /* owner's country num */ u_char sct_type; /* sector type */ u_char sct_effic; /* 0% to 100% */ u_char sct_mobil; /* mobility units */ u_char sct_loyal; /* updates until civilans "converted" */ u_char sct_terr; /* territory id # of sector */ coord sct_dist_x; /* Dist sector */ coord sct_dist_y; short sct_elev; /* elevation/depth */ short sct_avail; /* available workforce for "other things" */ short sct_fill; /* gunk */ u_char sct_work; /* pct of civ actually working */ u_char sct_flags; /* sector flags */ u_char sct_newtype; /* for changing designations */ u_char sct_min; /* ease of mining ore */ u_char sct_gmin; /* amount of gold ore */ u_char sct_fertil; /* fertility of soil */ u_char sct_oil; /* oil content */ u_char sct_uran; /* uranium ore content */ natid sct_oldown; /* old owner of sector (for liberation) */ u_char sct_updated; /* Has this sect been updated? */ u_char sct_off; /* Should this sector produce? */ u_char sct_nv; /* current number of variables */ u_char sct_vtype[MAXSCTV]; u_short sct_vamt[MAXSCTV]; }; struct dchrstr { int d_mnem; /* map symbol */ int d_prd; /* product vtype */ int d_mcst; /* movement cost */ int d_flg; /* movement cost */ int d_pkg; /* type of packaging in these sects */ int d_ostr; /* offensive strength */ int d_dstr; /* defensive strength */ int d_value; /* resale ("collect") value */ int d_cost; /* cost to designate the sect */ int d_build; /* cost multiplier for eff */ int d_lcms; /* lcm's needed per point of eff */ int d_hcms; /* hcm's needed per point of eff */ s_char *d_name; /* full name of sector type */ }; #define NPKG 0 /* no special packaging */ #define WPKG 1 /* "warehouse" packaging */ #define UPKG 2 /* "urban" packaging */ #define BPKG 3 /* "bank" packaging */ /* for d_flg */ #define NAVOK 1 /* ships can always navigate */ #define NAV_02 2 /* requires 2% effic to navigate */ #define NAV_60 3 /* requires 60% effic to navigate */ /* sector types (must agree with order in dchr, empglb.c) */ #define SCT_WATER 0 /* basics */ #define SCT_MOUNT 1 #define SCT_SANCT 2 #define SCT_WASTE 3 #define SCT_RURAL 4 #define SCT_CAPIT 5 #define SCT_URAN 6 #define SCT_PARK 7 #define SCT_ARMSF 8 /* industries */ #define SCT_AMMOF 9 #define SCT_MINE 10 #define SCT_GMINE 11 #define SCT_HARBR 12 #define SCT_WAREH 13 #define SCT_AIRPT 14 #define SCT_AGRI 15 #define SCT_OIL 16 #define SCT_LIGHT 17 #define SCT_HEAVY 18 #define SCT_FORTR 19 /* military/scientific */ #define SCT_TECH 20 #define SCT_RSRCH 21 #define SCT_NUKE 22 #define SCT_LIBR 23 #define SCT_HIWAY 24 /* communications */ #define SCT_RADAR 25 #define SCT_HEADQ 26 /* headquarters */ #define SCT_BHEAD 27 #define SCT_BSPAN 28 #define SCT_BANK 29 /* financial */ #define SCT_REFINE 30 /* refinery */ #define SCT_ENLIST 31 /* enlistment center */ #define SCT_MAXDEF 31 /* highest sector type in header files */ #define getsect(x, y, p) \ ef_nbread(EF_SECTOR, sctoff((int) x, (int) y), (caddr_t)p) #define putsect(p) \ ef_nbwrite(EF_SECTOR, sctoff((int) (p)->sct_x, \ (int) (p)->sct_y), (caddr_t)p) #define getsectp(x, y) \ (struct sctstr *) ef_ptr(EF_SECTOR, sctoff((int)x, (int)y)) #define getsectid(id) \ (struct sctstr *) ef_ptr(EF_SECTOR, id) /* things relating to sectors */ extern int sctoff(); extern double landgun(); extern int sct_maxno; extern struct dchrstr dchr[]; #define MIN_MOBCOST 0.01 /* lowest cost a sector can have to move into */ xland/options.h100600 1753 1753 10103 6227442000 13754 0ustar wolfpackwolfpack/* * options.h * * Define which "optional" features should be enabled. * */ /* Stuff from KSU & Greyhelm --ts */ #define SNEAK_ATTACK /* Allows sneak attacks */ #define WIRE /* Splits teles and annos */ /* #define BAN */ #define BANFILE EMPPATH(data/ban) /* file with banned users */ #define AUTHFILE EMPPATH(data/auth) /* file with users authorized to be deity */ #define MOVEMAP /* Show explore-style map for move */ #define NEWREPORT /* Doesn't show visitors, sancts */ /*#define BLITZ*/ /* Sets a couple of things. BTU's always max when you log in.. changing name doesn't take any btus or $$ enables BLITZ updates, also turns on NOFOOD, below */ #define START_UNITS 2 /* How many free start units you get. Types are specified in lib/global/constants.c */ /* These are from ts */ /*#define NONUKES /* eliminates nukes */ #define DAVYJONES /* Nuking water affects 1 hex, sanct/waste no effect */ #define SWEEP_PLANES /* Planes that can sweep mines */ #define MINE_PLANES /* Planes that can lay mines */ #define RETREAT /* retreat paths for ships/fleets */ #define OWNASSAULT /* can assault your own sects to reinforce */ #define ALLYHARBORWORK /* Allies work on your ships */ #define ALLYUPGRADE /* Allies can upgrade your ships */ #define WING_LOAD /* can load an entire wing of planes at once */ #define PARAFLAG /* only planes with the para flag can paratroop */ #define STEALTHV /* Give each plane a stealth rating */ #define HARBOR_POLICE /* allow boarding of enemy ships in your harbors */ #define ASW_PLANES /* planes that kill subs */ #define SHIPTORP /* Allows ships to torp ships */ #define REALM_IN_NAT /* have realms in nation command */ #define NEWFISH /* fishing is 10x as good */ #define FUEL /* Ships use fuel to move */ #define TRADESHIPS #define NEWPOWER /* Better power formula */ #define SHIPCHOPPERS /* Some non-carriers can carry choppers */ #define XLIGHT /* some planes are extra-light, can be on non-carriers*/ #define SEMILAND /* enable semi-landing ships */ #define NOMOBCOST /* No mob cost for firing from ships */ #define GODNAMES /* Attach deity name to telegrams (for multiple gods) */ #define TACARGO /* Allow cargo ships to bomb if they also are tactical*/ #define NOGODS /* Deity countries don't appear in power reports */ /* #define BABY_NUKES /* Nukes only affect 1 hex */ #define SUPER_BARS /* Bars can't be destroyed by fire */ #define EASY_BRIDGES /* Bridges can be built anywhere */ #define BETTERARMOR /* Ships armor affect shelling */ #define ALL_BLEED /* Tech bleeds to everyone */ #define DRNUKE /* Need research to make nukes */ /*#define SLOW_WAR /* Declaring war takes time */ #define CARRIER_WORK /* mil on carriers work on damaged planes */ /* #define NO_PLAGUE /* Plague is disabled */ #define NEW_STARVE /* UW's starve, then civs, then mil */ #define NEW_WORK /* Work is changed in proportion to the # of civs mvd */ #define STOP /* Can start/stop work in a sector */ #define RES_POP /* population is limited by research */ /*#define GRAB_THINGS /* units will grab things they need to build */ #define ALLYHARBOR /**/ #define SHOWPLANE /**/ #define DROPANY /**/ #define REJECTS /**/ #define BMAP /**/ #define AUTONAV /**/ #define SCUTTLE /**/ #define CONVASAT /**/ /* #define ORBIT /**/ #define ABM /**/ #define GRIND /**/ #define PINPOINTMISSILE /**/ /* #define FALLOUT /**/ #define SAIL /**/ #define NUKEFAILDETONATE /**/ /* #define MISSINGMISSILES /**/ #define SHIPNAMES /**/ /* #define NEUTRON /**/ #define NONUKESUB /**/ /*#define BETTERABM /* ABM's will be launched to intercept ANY */ /* non-allied nuke in range */ #define RANGEEDIT /**/ #define MISSDEF /**/ #define SHIPSAM /**/ #define UPDATESCHED /**/ #ifdef UPDATESCHED #define DEMANDUPDATE /* NOTE! Depends on UPDATESCHED! Don't use without it! */ #endif /* UPDATESCHED */ #ifdef BLITZ #define NOFOOD /* automatically have no food for blitzes */ #endif /* BLITZ */ /*#define NOFOOD /**/ #define BIND /**/ #define MERC #ifdef TRADESHIPS #endif /* TRADESHIPS */ #ifndef SLOW_WAR #undef SNEAK_ATTACK /* SNEAK_ATTACK is only useful with SLOW_WAR */ #endif /* SLOW_WAR */ xland/sun4/ 42755 1753 1753 0 6313377440 12716 5ustar wolfpackwolfpack