Subversion Repositories or1k_old

/*

    Xroach - A game of skill.  Try to find the roaches under your windows.

    Copyright 1991 by J.T. Anderson

    jta@locus.com

    This program may be freely distributed provided that all

    copyright notices are retained.

    To build:

      cc -o xroach roach.c -lX11 [-lsocketorwhatever] [-lm] [-l...]

    Dedicated to Greg McFarlane.   (gregm@otc.otca.oz.au)

*/

//#include 

//#include 

//#include 

#include 

#include 

#include 

#include 

#include 

#define MWINCLUDECOLORS

#include "nano-X.h"

#include "XtoNX.h"

char Copyright[] = "Xroach\nCopyright 1991 J.T. Anderson";

#include "roachmap.h"

typedef unsigned long Pixel;

typedef int ErrorHandler();

#define SCAMPER_EVENT   99              // LASTEvent+1?

#if !defined(GRAB_SERVER)

#define GRAB_SERVER     0

#endif

STATIC_FUNCTIONS;

Display *display;

int screen;

Window rootWin;

unsigned int display_width, display_height;

int center_x, center_y;

GC gc;

char *display_name = NULL;

Pixel black, white;

int done = 0;

int eventBlock = 0;

int errorVal = 0;

typedef struct Roach {

    RoachMap *rp;

    int index;

    float x;

    float y;

    int intX;

    int intY;

    int hidden;

    int turnLeft;

    int steps;

} Roach;

Roach *roaches;

int maxRoaches = 10;

int curRoaches = 0;

float roachSpeed = 20.0;

Region rootVisible = 0;

void Usage(void);

void SigHandler(int sig);

void AddRoach(void);

void MoveRoach(int Rx);

void DrawRoaches(void);

void CoverRoot(void);

int CalcRootVisible(void);

int MarkHiddenRoaches(void);

//Pixel AllocNamedColor();

int

main(int ac, char **av)

{

    //XGCValues xgcv;

    int ax;

    char *arg;

    RoachMap *rp;

    int rx;

    float angle;

    XEvent ev;

    char *roachColor = "black";

    int nVis;

    int needCalc;

    /*

       Process command line options.

    */

    for (ax=1; ax

        arg = av[ax];

        if (strcmp(arg, "-display") == 0) {

            display_name = av[++ax];

        }

        else if (strcmp(arg, "-rc") == 0) {

            roachColor = av[++ax];

        }

        else if (strcmp(arg, "-speed") == 0) {

            roachSpeed = atof(av[++ax]);

        }

        else if (strcmp(arg, "-roaches") == 0) {

            maxRoaches = strtol(av[++ax], (char **)NULL, 0);

        }

        else {

            Usage();

        }

    }

    srand((int)time((long *)NULL));

    /*

       Catch some signals so we can erase any visible roaches.

    */

    signal(SIGKILL, SigHandler);

    signal(SIGINT, SigHandler);

    signal(SIGTERM, SigHandler);

    signal(SIGHUP, SigHandler);

    display = XOpenDisplay(display_name);

    if (display == NULL) {

        if (display_name == NULL) display_name = getenv("DISPLAY");

        (void) fprintf(stderr, "%s: cannot connect to server %s\n", av[0],

            display_name ? display_name : "(default)");

        exit(1);

    }

    screen = DefaultScreen(display);

    rootWin = RootWindow(display, screen);

    black = BlackPixel(display, screen);

    white = WhitePixel(display, screen);

    display_width = DisplayWidth(display, screen);

    display_height = DisplayHeight(display, screen);

    center_x = display_width / 2;

    center_y = display_height / 2;

    /*

       Create roach pixmaps at several orientations.

    */

    for (ax=0; ax<360; ax+=ROACH_ANGLE) {

        rx = ax / ROACH_ANGLE;

        angle = rx * 0.261799387799;

        rp = &roachPix[rx];

        //rp->pixmap = XCreateBitmapFromData(display, rootWin,

            //rp->roachBits, rp->width, rp->height);

        rp->pixmap = XCreatePixmapFromBitmapData(display, rootWin,

            rp->roachBits, rp->width, rp->height, BLACK, CYAN, 1);      //FIXME

        rp->sine = sin(angle);

        rp->cosine = cos(angle);

    }

    roaches = (Roach *)malloc(sizeof(Roach) * maxRoaches);

    gc = XCreateGC(display, rootWin, 0L, &xgcv);

    //XSetForeground(display, gc, AllocNamedColor(roachColor, black));

    //XSetFillStyle(display, gc, FillStippled);

    while (curRoaches < maxRoaches)

        AddRoach();

    XSelectInput(display, rootWin, ExposureMask | SubstructureNotifyMask);

    needCalc = 1;

    while (!done) {

        if (XPending(display)) {

            XNextEvent(display, &ev);

        }

        else {

            if (needCalc) {

                needCalc = CalcRootVisible();

            }

            nVis = MarkHiddenRoaches();

            if (nVis) {

                ev.type = SCAMPER_EVENT;

            }

            else {

                DrawRoaches();

                GrDelay(100);

                eventBlock = 1;

                XNextEvent(display, &ev);

                eventBlock = 0;

            }

        }

        switch (ev.type) {

            case SCAMPER_EVENT:

                for (rx=0; rx

                    if (!roaches[rx].hidden)

                        MoveRoach(rx);

                }

                DrawRoaches();

                GrDelay(100);

                XSync(display, False);

                break;

            case Expose:

            //case MapNotify:

            //case UnmapNotify:

            case ConfigureNotify:

                needCalc = 1;

                break;

        }

    }

    CoverRoot();

    XCloseDisplay(display);

    return 0;

}

#define USEPRT(msg) fprintf(stderr, msg)

void

Usage(void)

{

    USEPRT("Usage: nxroach [options]\n\n");

    USEPRT("Options:\n");

    USEPRT("       -display displayname\n");

    USEPRT("       -rc      roachcolor\n");

    USEPRT("       -roaches numroaches\n");

    USEPRT("       -speed   roachspeed\n");

    exit(1);

}

void

SigHandler(int sig)

{

    /*

       If we are blocked, no roaches are visible and we can just bail

       out.  If we are not blocked, then let the main procedure clean

       up the root window.

    */

    if (eventBlock) {

        XCloseDisplay(display);

        exit(0);

    }

    else {

        done = 1;

    }

}

/*

   Generate random integer between 0 and maxVal-1.

*/

int

RandInt(int maxVal)

{

        return rand() % maxVal;

}

/*

   Check for roach completely in specified rectangle.

*/

int

RoachInRect(roach, rx, ry, x, y, width, height)

Roach *roach;

int rx;

int ry;

int x;

int y;

unsigned int width;

unsigned int height;

{

    if (rx < x) return 0;

    if ((rx + roach->rp->width) > (x + width)) return 0;

    if (ry < y) return 0;

    if ((ry + roach->rp->height) > (y + height)) return 0;

    return 1;

}

/*

   Check for roach overlapping specified rectangle.

*/

int

RoachOverRect(roach, rx, ry, x, y, width, height)

Roach *roach;

int rx;

int ry;

int x;

int y;

unsigned int width;

unsigned int height;

{

    if (rx >= (x + width)) return 0;

    if ((rx + roach->rp->width) <= x) return 0;

    if (ry >= (y + height)) return 0;

    if ((ry + roach->rp->height) <= y) return 0;

    return 1;

}

/*

   Give birth to a roach.

*/

void

AddRoach(void)

{

    Roach *r;

    if (curRoaches < maxRoaches) {

        r = &roaches[curRoaches++];

        r->index = RandInt(ROACH_HEADINGS);

        r->rp = &roachPix[r->index];

        r->x = RandInt(display_width - r->rp->width);

        r->y = RandInt(display_height - r->rp->height);

        r->intX = -1;

        r->intY = -1;

        r->hidden = 0;

        r->steps = RandInt(200);

        r->turnLeft = RandInt(100) >= 50;

    }

}

/*

   Turn a roach.

*/

void

TurnRoach(roach)

Roach *roach;

{

    if (roach->index != (roach->rp - roachPix)) return;

    if (roach->turnLeft) {

        roach->index += (RandInt(30) / 10) + 1;

        if (roach->index >= ROACH_HEADINGS)

            roach->index -= ROACH_HEADINGS;

    }

    else {

        roach->index -= (RandInt(30) / 10) + 1;

        if (roach->index < 0)

            roach->index += ROACH_HEADINGS;

    }

}

/*

   Move a roach.

*/

void

MoveRoach(int rx)

{

    Roach *roach;

    Roach *r2;

    float newX;

    float newY;

    int ii;

    roach = &roaches[rx];

    newX = roach->x + (roachSpeed * roach->rp->cosine);

    newY = roach->y - (roachSpeed * roach->rp->sine);

    if (RoachInRect(roach, (int)newX, (int)newY,

                            0, 0, display_width, display_height)) {

        roach->x = newX;

        roach->y = newY;

        if (roach->steps-- <= 0) {

            TurnRoach(roach);

            roach->steps = RandInt(200);

        }

        for (ii=rx+1; ii

            r2 = &roaches[ii];

            if (RoachOverRect(roach, (int)newX, (int)newY,

                r2->intX, r2->intY, r2->rp->width, r2->rp->height)) {

                TurnRoach(roach);

            }

        }

    }

    else {

        TurnRoach(roach);

    }

}

/*

   Draw all roaches.

*/

void

DrawRoaches(void)

{

    Roach *roach;

    int rx;

    for (rx=0; rx

        roach = &roaches[rx];

        if (roach->intX >= 0) {

            XClearArea(display, rootWin, roach->intX, roach->intY,

                roach->rp->width, roach->rp->height, False);

        }

    }

    for (rx=0; rx

        roach = &roaches[rx];

        if (!roach->hidden) {

            roach->intX = roach->x;

            roach->intY = roach->y;

            roach->rp = &roachPix[roach->index];

            //XSetStipple(display, gc, roach->rp->pixmap);

            //XSetTSOrigin(display, gc, roach->intX, roach->intY);

            //XFillRectangle(display, rootWin, gc,

                //roach->intX, roach->intY, roach->rp->width, roach->rp->height);

            GrCopyArea(GR_ROOT_WINDOW_ID, gc, roach->intX, roach->intY,

                roach->rp->width, roach->rp->height, roach->rp->pixmap, 0, 0,

                MWROP_SRCCOPY);

        }

        else {

            roach->intX = -1;

        }

    }

}

/*

   Cover root window to erase roaches.

*/

void

CoverRoot(void)

{

    //XSetWindowAttributes xswa;

    //long wamask;

    Window roachWin;

#define CopyFromParent  0

#define InputOutput     0

    //xswa.background_pixmap = ParentRelative;

    //xswa.override_redirect = True;

    //wamask = CWBackPixmap | CWOverrideRedirect;

    roachWin = XCreateWindow(display, rootWin, 0, 0,

                    display_width, display_height, 0, CopyFromParent,

                    InputOutput, CopyFromParent, wamask, &xswa);

    XLowerWindow(display, roachWin);

    XMapWindow(display, roachWin);

    XFlush(display);

}

#if !GRAB_SERVER

#if 0

int

RoachErrors(dpy, err)

Display *dpy;

XErrorEvent *err;

{

    errorVal = err->error_code;

    return 0;

}

#endif

#endif /* GRAB_SERVER */

/*

   Calculate Visible region of root window.

*/

int

CalcRootVisible(void)

{

    Region covered;

    Region visible;

    Window *children;

    int nChildren;

    Window dummy;

    //XWindowAttributes wa;

    int wx;

    XRectangle rect;

    int winX, winY;

    unsigned int winHeight, winWidth;

    unsigned int borderWidth;

    unsigned int depth;

    GR_WINDOW_INFO info;

    /*

       If we don't grab the server, the XGetWindowAttribute or XGetGeometry

       calls can abort us.  On the other hand, the server grabs can make for

       some annoying delays.

    */

#if GRAB_SERVER

    //XGrabServer(display);

#else

    //XSetErrorHandler(RoachErrors);

#endif

    /*

       Get children of root.

    */

    XQueryTree(display, rootWin, &dummy, &dummy, &children, &nChildren);

    /*

       For each mapped child, add the window rectangle to the covered

       region.

    */

    covered = XCreateRegion();

    for (wx=0; wx

        //if (XEventsQueued(display, QueuedAlready)) return 1;

        //errorVal = 0;

        //XGetWindowAttributes(display, children[wx], &wa);

        //if (errorVal) continue;

        GrGetWindowInfo(children[wx], &info);

        //if (wa.map_state == IsViewable) {

        if (info.unmapcount == 0) {

            //XGetGeometry(display, children[wx], &dummy, &winX, &winY,

                //&winWidth, &winHeight, &borderWidth, &depth);

            //if (errorVal) continue;

            rect.x = info.x;

            rect.y = info.y;

            //rect.width = winWidth + (borderWidth * 2);

            //rect.height = winHeight + (borderWidth * 2);

            rect.width = info.width;

            rect.height = info.height;

            XUnionRectWithRegion(&rect, covered, covered);

        }

    }

    XFree((char *)children);

#if GRAB_SERVER

    //XUngrabServer(display);

#else

    //XSetErrorHandler((ErrorHandler *)NULL);

#endif

    /*

       Subtract the covered region from the root window region.

    */

    visible = XCreateRegion();

    rect.x = 0;

    rect.y = 0;

    rect.width = display_width;

    rect.height = display_height;

    XUnionRectWithRegion(&rect, visible, visible);

    XSubtractRegion(visible, covered, visible);

    XDestroyRegion(covered);

    /*

       Save visible region globally.

    */

    if (rootVisible)

        XDestroyRegion(rootVisible);

    rootVisible = visible;

    /*

       Mark all roaches visible.

    */

    for (wx=0; wx

        roaches[wx].hidden = 0;

    return 0;

}

/*

   Mark hidden roaches.

*/

int

MarkHiddenRoaches(void)

{

    int rx;

    Roach *r;

    int nVisible;

    nVisible = 0;

    for (rx=0; rx

        r = &roaches[rx];

        if (!r->hidden) {

            if (r->intX > 0 && XRectInRegion(rootVisible, r->intX, r->intY,

                            r->rp->width, r->rp->height) == RectangleOut) {

                r->hidden = 1;

            }

            else {

                nVisible++;

            }

        }

    }

    return nVisible;

}

#if 0

/*

   Allocate a color by name.

*/

Pixel

AllocNamedColor(colorName, dfltPix)

char *colorName;

Pixel dfltPix;

{

        Pixel pix;

        XColor scrncolor;

        XColor exactcolor;

        if (XAllocNamedColor(display, DefaultColormap(display, screen),

                colorName, &scrncolor, &exactcolor)) {

                pix = scrncolor.pixel;

        }

        else {

                pix = dfltPix;

        }

        return pix;

}

#endif