Logo Search packages:      
Sourcecode: acm4 version File versions  Download package

doEvents.c

/*
 *  acm : an aerial combat simulator for X
 *  Copyright (C) 1991-1994  Riley Rainey
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; version 2 dated June, 1991.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program;  if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave., Cambridge, MA 02139, USA.
 */
 
#include "pm.h"
#include <X11/Xutil.h>
#include <X11/keysym.h>
#include <stdio.h>

#define MAX_MAPPED_STRING_LEN 20
#define MAX_POPUP_STRING_LEN  40

extern int cur;

extern void resizePlayerWindow(), resizeChaserWindow(), redrawPanel();
extern int debug;
extern int newDrone();

extern void startBlackBoxRecording(), endBlackBoxRecording();
extern void startBlackBoxPlayback();
extern void radioFrequencyChanged();

void doEvents(c)
craft *c; 
{

      XEvent            ev;
      viewer            *u;
      int         player;

/*
 *  Process events for each player and any "back seaters"
 */

      player = 1;
      for (u=c->vl; u != (viewer *) NULL; u=u->next) {


#define mask      (-1L)

#ifndef REAL_DELTA_T
            if (cur % REDRAW_EVERY == 0)
#endif
                  getStick (c, u);

            while (XEventsQueued(u->dpy, QueuedAlready)) {

                if (XCheckWindowEvent (u->dpy, u->win, mask, &ev)) {

                  switch (ev.type) {

                  case KeyPress:
                          if ((c->type == CT_CHASER) ?
                            doKeyEventChaser(c, u, &ev, player) :
                            doKeyEvent (c, u, &ev, player) < 0)
                              return;
                        break;

                  case ButtonPress:
                        if (doButtonEvent (c, u, &ev, player) < 0)
                              return;
                        break;

                  case ButtonRelease:
                        if (doButtonReleaseEvent (c, u, &ev, player) < 0)
                              return;
                        break;

                  case ConfigureNotify:
                        if (c->type == CT_CHASER) {
                            resizeChaserWindow (c, u,
                              ev.xconfigure.width,
                              ev.xconfigure.height, 0);
                        }
                        else {
                            resizePlayerWindow (c, u,
                              ev.xconfigure.width,
                              ev.xconfigure.height, 0);
                        }
                        VResizeViewport (u->v, 12.0*25.4/1000.0,
                              u->scaleFactor, 0.5,
                              u->width,
                              u->height);
                        break;

                  case Expose:
                        redrawPanel (c, u);
                        ForceWindowRedraw (u->v->w);
                        break;

                  default:
                        break;
                  }

                }
                else if (XCheckTypedEvent (u->dpy, ClientMessage, &ev)) {
                  if (ev.xclient.message_type == u->protocolsAtom
                  && (ev.xclient.data.l[0] == u->deleteWindowAtom ||
                      ev.xclient.data.l[0] == u->closedownAtom)) {
                        if (c->type == CT_CHASER) {
                              killChaser (c);
                        }
                        else {
                              killPlayer (c);
                        }
                  }
                }

            }

            player = 0;

      }
}

/*ARGSUSED*/
int doButtonEvent (c, u, ev, player)
craft *c;
viewer      *u;
XEvent      *ev;
int   player; {

      if (ev->xbutton.button == Button2)
            fireWeapon (c);

      else if (ev->xbutton.button == Button3)
            selectWeapon (c);

      return 0;
}

/*ARGSUSED*/
int doButtonReleaseEvent (c, u, ev, player)
craft *c;
viewer      *u;
XEvent      *ev;
int   player; {

      if (ev->xbutton.button == Button2)
            ceaseFireWeapon (c);

      return 0;
}

/*ARGSUSED*/
int doKeyEvent (c, u, ev, player)
craft *c;
viewer      *u;
XEvent      *ev;
int   player; 
{

      KeySym            keysym;
      XComposeStatus    compose;
      char        buffer[MAX_MAPPED_STRING_LEN];
      int         buflen = MAX_MAPPED_STRING_LEN;
#ifdef SPECIAL_KEYS
      FILE        *fp;
      craft       pentry;
#endif

      (void) XLookupString ((XKeyEvent *) ev, buffer, buflen, 
            &keysym, &compose);

      if (player) {

            switch (keysym) {

#ifdef sun
            case XK_R4:
#else
            case XK_Left:
#endif
                  if (c->flags & FL_NWS) {
                        c->curNWDef = c->curNWDef - c->cinfo->NWIncr;
                        if (c->curNWDef < - c->cinfo->maxNWDef)
                              c->curNWDef = - c->cinfo->maxNWDef;
                  }
                  else {
                        c->Sa =  c->Sa - 0.05;
                  }
                  break;

#ifdef sun
            case XK_R6:
#else
            case XK_Right:
#endif
                  if (c->flags & FL_NWS) {
                        c->curNWDef = c->curNWDef + c->cinfo->NWIncr;
                        if (c->curNWDef > c->cinfo->maxNWDef)
                              c->curNWDef = c->cinfo->maxNWDef;
                  }
                  else {
                        c->Sa = c->Sa + 0.05;
                  }
                  break;

#ifdef sun
            case XK_R2:
#else
            case XK_Up:
#endif
                  c->Se = c->Se - 0.01;
                  break;

#ifdef sun
            case XK_R5:
#else
            case XK_Down:
#endif
                  c->Se = c->Se + 0.01;
                  break;

            case XK_z:
            case XK_Z:
                  c->Sr = c->Sr + 0.01;
                  break;

            case XK_c:
            case XK_C:
                  c->Sr = c->Sr - 0.01;
                  break;

            case XK_x:
            case XK_X:
                  c->Sr = 0.0;
                  break;

#ifdef sun
            case XK_R7:
#else
            case XK_Home:
#endif
                  c->Se = 0.0;
                  c->Sr = 0.0;
                  c->Sa = 0.0;
                  break;

/*
 *  J  :  Adjust Elevator Trim
 */
            case XK_J:
            case XK_j:
                  c->SeTrim += c->Se;
                  break;

/*
 *  U  :  Set Elevator trim to the Takeoff setting
 */

            case XK_U:
            case XK_u:
                  c->SeTrim = c->cinfo->SeTrimTakeoff;
                  break;

            case XK_y:
            case XK_Y:
                  flapsUp (c);
                  break;

            case XK_h:
            case XK_H:
                  flapsDown (c);
                  break;

            case XK_w:
            case XK_W:
                  speedBrakeRetract (c);
                  break;

            case XK_s:
            case XK_S:
                  speedBrakeExtend (c);
                  break;

            case XK_2:
            case XK_KP_Subtract:
                  c->throttle = (c->throttle <= 6553) ? 6553 :
                        c->throttle - 512;
                  break;

            case XK_3:
            case XK_KP_Add:
                  c->throttle = (c->throttle >= 32768) ? 32768 :
                        c->throttle + 512;
                  break;

            case XK_4:
            case XK_Prior:
                  c->throttle = 32768;
                  break;

            case XK_1:
            case XK_Next:
                  c->throttle = 8192;
                  break;

            case XK_A:
            case XK_a:
                  c->flags ^= FL_AFTERBURNER;
                  break;

            case XK_7:
                  c->hsiSelect->obs_setting =
                        (c->hsiSelect->obs_setting + 20) % 360;
                  break;

            case XK_8:
                  c->hsiSelect->obs_setting =
                        (c->hsiSelect->obs_setting + 1) % 360;
                  break;

            case XK_9:
                  c->hsiSelect->frequency =
                        (c->hsiSelect->frequency + 20) %
                        VOR_CHANNEL_COUNT;
                  radioFrequencyChanged (c->hsiSelect);
                  break;

            case XK_0:
                  c->hsiSelect->frequency =
                        (c->hsiSelect->frequency + 1) %
                        VOR_CHANNEL_COUNT;
                  radioFrequencyChanged (c->hsiSelect);
                  break;

            case XK_B:
            case XK_b:
                  c->flags ^= FL_BRAKES;
                  break;

            case XK_G:
            case XK_g:
                  playSound (c, (c->flags & FL_GHANDLE_DN) ?
                        SoundGearUp : SoundGearDown);
                  c->flags ^= FL_GHANDLE_DN;
                  break;

            case XK_L:
            case XK_l:
                  newDrone (c);
                  break;

#ifdef sun
            case XK_Up:
#else
            case XK_KP_8:
#endif
                  c->viewDirection.x = 1.0;
                  c->viewDirection.y = 0.0;
                  c->viewDirection.z = 0.0;
                  c->viewUp.x = 0.0;
                  c->viewUp.y = 0.0;
                  c->viewUp.z = -1.0;
                  break;

/* look right */

#ifdef sun
            case XK_Right:
#else
            case XK_KP_6:
#endif
                  c->viewDirection.x = 0.0;
                  c->viewDirection.y = 1.0;
                  c->viewDirection.z = 0.0;
                  c->viewUp.x = 0.0;
                  c->viewUp.y = 0.0;
                  c->viewUp.z = -1.0;
                  break;

/* look left */

#ifdef sun
            case XK_Left:
#else
            case XK_KP_4:
#endif
                  c->viewDirection.x = 0.0;
                  c->viewDirection.y = -1.0;
                  c->viewDirection.z = 0.0;
                  c->viewUp.x = 0.0;
                  c->viewUp.y = 0.0;
                  c->viewUp.z = -1.0;
                  break;

/* look back */

#ifdef sun
            case XK_Down:
#else
            case XK_KP_2:
#endif
                  c->viewDirection.x = -1.0;
                  c->viewDirection.y = 0.0;
                  c->viewDirection.z = 0.0;
                  c->viewUp.x = 0.0;
                  c->viewUp.y = 0.0;
                  c->viewUp.z = -1.0;
                  break;

/* look up */

#ifdef sun
            case XK_R11:
#else
            case XK_KP_5:
#endif
                  c->viewDirection.x = 0.0;
                  c->viewDirection.y = 0.0;
                  c->viewDirection.z = -1.0;
                  c->viewUp.x = -1.0;
                  c->viewUp.y = 0.0;
                  c->viewUp.z = 0.0;
                  break;

            case XK_Q:
            case XK_q:
                  c->curRadarTarget = getRadarTarget (c, 1);
                  break;

            case XK_R:
            case XK_r:
                  switch (c->radarMode) {

                  case RM_STANDBY:
                        c->radarMode = RM_NORMAL;
                        break;

                  case RM_NORMAL:
                        c->radarMode = RM_ILS;
                        break;

                  case RM_ILS:
                        c->radarMode = RM_STANDBY;
                        break;
                  }
                  break;

            case XK_N:
            case XK_n:
                  c->flags ^= FL_CHASE_VIEW;
                  break;

#ifdef SPECIAL_KEYS

            case XK_o:
                  if (absorbDamage(c, 3) == 0) {
                        killPlayer (c);
                        return -1;
                  }
                  break;

            case XK_I:
                  fp = fopen ("./flight-state", "w");
                  fwrite ((char *) &ptbl[c->pIndex],
                        sizeof (craft), 1, fp);
                  fclose (fp);
                  break;

            case XK_i:
                  if (fp = fopen ("./flight-state", "r")) {
                        fread ((char *) &pentry, sizeof (craft), 1, fp);
                        fclose (fp);

                        c->flags = pentry.flags;
                        c->Sg = pentry.Sg;
                        c->prevSg = pentry.prevSg;
                        c->Cg = pentry.Cg;
                        c->trihedral = pentry.trihedral;
                        c->Itrihedral = pentry.Itrihedral;
                        c->curHeading = pentry.curHeading;
                        c->curPitch = pentry.curPitch;
                        c->curRoll = pentry.curRoll;
                        c->p = pentry.p;
                        c->q = pentry.q;
                        c->r = pentry.r;
                        c->damageBits = pentry.damageBits;
                        c->structurePts = pentry.structurePts;
                        c->damageCL = pentry.damageCL;
                        c->damageCM = pentry.damageCM;
                        c->curThrust = pentry.curThrust;
                        c->throttle = pentry.throttle;
                  }
                  else {
                        fprintf (stderr,
                              "unable to open ./flight-state\n");
                  }
                  break;

            case XK_semicolon:
                  debug ^= 1;
                  break;

#endif

            case XK_P:
            case XK_p:
                  killPlayer (c);
                  return -1;
/*NOTREACHED*/          break;

            case XK_braceleft:
                  startBlackBoxRecording();
                  break;

            case XK_braceright:
                  endBlackBoxRecording();
                  break;

            case XK_bracketleft:
                  startBlackBoxPlayback();
                  break;

            }

      }

      return 0;
}

Generated by  Doxygen 1.6.0   Back to index