input.c

/* Digger Remastered
   Copyright (c) Andrew Jenner 1998-2004 */

#include "def.h"
#include "input.h"
#include "main.h"
#include "sound.h"
#include "hardware.h"
#include "record.h"
#include "digger.h"
#include "game.h"
#ifdef _SDL
#include "sdl_kbd.h" 
#elif defined(_VGL)
#include "fbsd_kbd.h"
#endif

/* global variables first */
bool escape=false,firepflag=false,fire2pflag=false,pausef=false,mode_change=false;
bool krdf[NKEYS]={false,false,false,false,false,false,false,false,false,false,
               false,false,false,false,false,false,false,false};
static bool firepactive=false,fire2pactive=false;

static bool aleftpressed=false,arightpressed=false,
     auppressed=false,adownpressed=false,start=false,af1pressed=false;
static bool aleft2pressed=false,aright2pressed=false,
     aup2pressed=false,adown2pressed=false,af12pressed=false;
static bool anykeyf=false;

enum input_source {
  INPUT_SOURCE_PRIMARY = 0,
  INPUT_SOURCE_SECONDARY,
  INPUT_SOURCE_NETWORK
};

int16_t akeypressed;

static int16_t dynamicdir=-1,dynamicdir2=-1,staticdir=-1,staticdir2=-1,joyx=0,joyy=0;
static int16_t dynamicdirn[DIGGERS]={DIR_NONE,DIR_NONE},
      staticdirn[DIGGERS]={DIR_NONE,DIR_NONE};

static bool joybut1=false;

static int16_t keydir=0,keydir2=0,jleftthresh=0,jupthresh=0,jrightthresh=0,
      jdownthresh=0,joyanax=0,joyanay=0;

static bool joyflag=false;
static enum input_source slot_sources[DIGGERS]={INPUT_SOURCE_PRIMARY,
                                                INPUT_SOURCE_SECONDARY};
static uint8_t network_bits[DIGGERS]={0,0};
static bool ounpressed[DIGGERS]={false,false},odnpressed[DIGGERS]={false,false},
     olnpressed[DIGGERS]={false,false},ornpressed[DIGGERS]={false,false};

void readjoy(void);
static void apply_network_controls(int n);

/* The standard ASCII keyboard is also checked so that very short keypresses
   are not overlooked. The functions kbhit() (returns bool denoting whether or
   not there is a key in the buffer) and getkey() (wait until a key is in the
   buffer, then return it) are used. These functions are emulated on platforms
   which only provide an inkey() function (return the key in the buffer, unless
   there is none, in which case return -1. It is done this way around for
   historical reasons, there is no fundamental reason why it shouldn't be the
   other way around. */
void checkkeyb(void)
{
  int i,j,k=0;
  bool *aflagp[10]={&arightpressed,&auppressed,&aleftpressed,&adownpressed,
                    &af1pressed,&aright2pressed,&aup2pressed,&aleft2pressed,
                    &adown2pressed,&af12pressed};
  if (leftpressed)
    aleftpressed=true;
  if (rightpressed)
    arightpressed=true;
  if (uppressed)
    auppressed=true;
  if (downpressed)
    adownpressed=true;
  if (f1pressed)
    af1pressed=true;
  if (left2pressed)
    aleft2pressed=true;
  if (right2pressed)
    aright2pressed=true;
  if (up2pressed)
    aup2pressed=true;
  if (down2pressed)
    adown2pressed=true;
  if (f12pressed)
    af12pressed=true;

  while (kbhit()) {
    akeypressed=getkey(true);
    anykeyf=true;
    for (i=0;i<10;i++)
      for (j=2;j<5;j++)
        if (akeypressed==keycodes[i][j])
          *aflagp[i]=true;
    for (i=10;i<NKEYS;i++)
      for (j=0;j<5;j++)
        if (akeypressed==keycodes[i][j])
          k=i;
    switch (k) {
      case DKEY_CHT: /* Cheat! */
        if (!dgstate.gauntlet) {
          playing=false;
          drfvalid=false;
        }
        break;
      case DKEY_SUP: /* Increase speed */
        if (dgstate.ftime>10000l)
          dgstate.ftime-=10000l;
        break;
      case DKEY_SDN: /* Decrease speed */
        dgstate.ftime+=10000l;
        break;
      case DKEY_MTG: /* Toggle music */
        togglemusic();
        break;
      case DKEY_STG: /* Toggle sound */
        togglesound();
        break;
      case DKEY_EXT: /* Exit */
        escape=true;
        break;
      case DKEY_PUS: /* Pause */
        pausef=true;
        break;
      case DKEY_MCH: /* Mode change */
        mode_change=true;
        break;
      case DKEY_SDR: /* Save DRF */
        savedrf=true;
        break;
    }
    if (!mode_change)
      start=true;                                /* Change number of players */
  }
}

/* Joystick not yet implemented. It will be, though, using gethrt on platform
   DOSPC. */
void readjoy(void)
{
}

void detectjoy(void)
{
  joyflag=false;
  staticdir=dynamicdir=DIR_NONE;
}

/* Contrary to some beliefs, you don't need a separate OS call to flush the
   keyboard buffer. */
void flushkeybuf(void)
{
  while (kbhit())
    getkey(true);
  aleftpressed=arightpressed=auppressed=adownpressed=af1pressed=false;
  aleft2pressed=aright2pressed=aup2pressed=adown2pressed=af12pressed=false;
}

uint8_t
input_snapshot_primary_controls(void)
{
  uint8_t bits = 0;

  if (auppressed || uppressed)
    bits |= INPUT_CTRL_UP;
  if (adownpressed || downpressed)
    bits |= INPUT_CTRL_DOWN;
  if (arightpressed || rightpressed)
    bits |= INPUT_CTRL_RIGHT;
  if (aleftpressed || leftpressed)
    bits |= INPUT_CTRL_LEFT;
  if (af1pressed || f1pressed)
    bits |= INPUT_CTRL_FIRE;
  aleftpressed=arightpressed=auppressed=adownpressed=af1pressed=false;
  return (bits);
}

bool
input_consume_anykey(void)
{
  bool anykey;

  anykey = anykeyf;
  anykeyf = false;
  return (anykey);
}

void
input_reset_network(void)
{
  int i;

  for (i = 0; i < DIGGERS; i++) {
    slot_sources[i] = (i == 0) ? INPUT_SOURCE_PRIMARY : INPUT_SOURCE_SECONDARY;
    network_bits[i] = 0;
    ounpressed[i] = odnpressed[i] = olnpressed[i] = ornpressed[i] = false;
    dynamicdirn[i] = staticdirn[i] = DIR_NONE;
  }
}

void
input_enable_network_mode(void)
{
  int i;

  input_reset_network();
  for (i = 0; i < DIGGERS; i++)
    slot_sources[i] = INPUT_SOURCE_NETWORK;
}

void
input_set_network_controls(int slot, uint8_t bits)
{

  if (slot < 0 || slot >= DIGGERS)
    return;
  network_bits[slot] = bits;
}

void clearfire(int n)
{
  if (n==0)
    af1pressed=false;
  else
    af12pressed=false;
}

bool oupressed=false,odpressed=false,olpressed=false,orpressed=false;
bool ou2pressed=false,od2pressed=false,ol2pressed=false,or2pressed=false;

void
input_reset_directions(void)
{
  int i;

  firepflag=false;
  fire2pflag=false;
  firepactive=false;
  fire2pactive=false;
  dynamicdir=dynamicdir2=DIR_NONE;
  staticdir=staticdir2=DIR_NONE;
  keydir=keydir2=DIR_NONE;
  oupressed=odpressed=olpressed=orpressed=false;
  ou2pressed=od2pressed=ol2pressed=or2pressed=false;
  for (i=0; i<DIGGERS; i++) {
    dynamicdirn[i]=DIR_NONE;
    staticdirn[i]=DIR_NONE;
    ounpressed[i]=odnpressed[i]=olnpressed[i]=ornpressed[i]=false;
  }
}

void
input_advance_fire_state(void)
{

  firepactive=firepflag;
  fire2pactive=fire2pflag;
}

bool
input_get_fire_active(int n)
{

  return (n == 0) ? firepactive : fire2pactive;
}

static void
apply_network_controls(int n)
{
  bool un=false,dn=false,ln=false,rn=false;

  if ((network_bits[n] & INPUT_CTRL_UP) != 0)
    un=true;
  if ((network_bits[n] & INPUT_CTRL_DOWN) != 0)
    dn=true;
  if ((network_bits[n] & INPUT_CTRL_LEFT) != 0)
    ln=true;
  if ((network_bits[n] & INPUT_CTRL_RIGHT) != 0)
    rn=true;
  if ((network_bits[n] & INPUT_CTRL_FIRE) != 0) {
    if (n==0)
      firepflag=true;
    else
      fire2pflag=true;
  }
  else if (n==0)
    firepflag=false;
  else
    fire2pflag=false;
  if (un && !ounpressed[n])
    staticdirn[n]=dynamicdirn[n]=DIR_UP;
  if (dn && !odnpressed[n])
    staticdirn[n]=dynamicdirn[n]=DIR_DOWN;
  if (ln && !olnpressed[n])
    staticdirn[n]=dynamicdirn[n]=DIR_LEFT;
  if (rn && !ornpressed[n])
    staticdirn[n]=dynamicdirn[n]=DIR_RIGHT;
  if ((ounpressed[n] && !un && dynamicdirn[n]==DIR_UP) ||
      (odnpressed[n] && !dn && dynamicdirn[n]==DIR_DOWN) ||
      (olnpressed[n] && !ln && dynamicdirn[n]==DIR_LEFT) ||
      (ornpressed[n] && !rn && dynamicdirn[n]==DIR_RIGHT)) {
    dynamicdirn[n]=DIR_NONE;
    if (un) dynamicdirn[n]=staticdirn[n]=DIR_UP;
    if (dn) dynamicdirn[n]=staticdirn[n]=DIR_DOWN;
    if (ln) dynamicdirn[n]=staticdirn[n]=DIR_LEFT;
    if (rn) dynamicdirn[n]=staticdirn[n]=DIR_RIGHT;
  }
  ounpressed[n]=un;
  odnpressed[n]=dn;
  olnpressed[n]=ln;
  ornpressed[n]=rn;
  if (n==0) {
    keydir=staticdirn[n];
    if (dynamicdirn[n]!=DIR_NONE)
      keydir=dynamicdirn[n];
  }
  else {
    keydir2=staticdirn[n];
    if (dynamicdirn[n]!=DIR_NONE)
      keydir2=dynamicdirn[n];
  }
  staticdirn[n]=DIR_NONE;
}

void readdirect(int n)
{
  int16_t j;
  bool u=false,d=false,l=false,r=false;
  bool u2=false,d2=false,l2=false,r2=false;

  if (slot_sources[n]==INPUT_SOURCE_PRIMARY) {
    if (auppressed || uppressed) { u=true; auppressed=false; }
    if (adownpressed || downpressed) { d=true; adownpressed=false; }
    if (aleftpressed || leftpressed) { l=true; aleftpressed=false; }
    if (arightpressed || rightpressed) { r=true; arightpressed=false; }
    if (f1pressed || af1pressed) {
      if (n == 0)
        firepflag=true;
      else
        fire2pflag=true;
      af1pressed=false;
    }
    else if (n == 0)
      firepflag=false;
    else
      fire2pflag=false;
    if (u && !oupressed)
      staticdir=dynamicdir=DIR_UP;
    if (d && !odpressed)
      staticdir=dynamicdir=DIR_DOWN;
    if (l && !olpressed)
      staticdir=dynamicdir=DIR_LEFT;
    if (r && !orpressed)
      staticdir=dynamicdir=DIR_RIGHT;
    if ((oupressed && !u && dynamicdir==DIR_UP) ||
        (odpressed && !d && dynamicdir==DIR_DOWN) ||
        (olpressed && !l && dynamicdir==DIR_LEFT) ||
        (orpressed && !r && dynamicdir==DIR_RIGHT)) {
      dynamicdir=DIR_NONE;
      if (u) dynamicdir=staticdir=2;
      if (d) dynamicdir=staticdir=6;
      if (l) dynamicdir=staticdir=4;
      if (r) dynamicdir=staticdir=0;
    }
    oupressed=u;
    odpressed=d;
    olpressed=l;
    orpressed=r;
    if (n == 0) {
      keydir=staticdir;
      if (dynamicdir!=DIR_NONE)
        keydir=dynamicdir;
    }
    else {
      keydir2=staticdir;
      if (dynamicdir!=DIR_NONE)
        keydir2=dynamicdir;
    }
    staticdir=DIR_NONE;
  }
  else if (slot_sources[n]==INPUT_SOURCE_SECONDARY) {
    if (aup2pressed || up2pressed) { u2=true; aup2pressed=false; }
    if (adown2pressed || down2pressed) { d2=true; adown2pressed=false; }
    if (aleft2pressed || left2pressed) { l2=true; aleft2pressed=false; }
    if (aright2pressed || right2pressed) { r2=true; aright2pressed=false; }
    if (f12pressed || af12pressed) {
      if (n == 0)
        firepflag=true;
      else
        fire2pflag=true;
      af12pressed=false;
    }
    else if (n == 0)
      firepflag=false;
    else
      fire2pflag=false;
    if (u2 && !ou2pressed)
      staticdir2=dynamicdir2=DIR_UP;
    if (d2 && !od2pressed)
      staticdir2=dynamicdir2=DIR_DOWN;
    if (l2 && !ol2pressed)
      staticdir2=dynamicdir2=DIR_LEFT;
    if (r2 && !or2pressed)
      staticdir2=dynamicdir2=DIR_RIGHT;
    if ((ou2pressed && !u2 && dynamicdir2==DIR_UP) ||
        (od2pressed && !d2 && dynamicdir2==DIR_DOWN) ||
        (ol2pressed && !l2 && dynamicdir2==DIR_LEFT) ||
        (or2pressed && !r2 && dynamicdir2==DIR_RIGHT)) {
      dynamicdir2=DIR_NONE;
      if (u2) dynamicdir2=staticdir2=2;
      if (d2) dynamicdir2=staticdir2=6;
      if (l2) dynamicdir2=staticdir2=4;
      if (r2) dynamicdir2=staticdir2=0;
    }
    ou2pressed=u2;
    od2pressed=d2;
    ol2pressed=l2;
    or2pressed=r2;
    if (n == 0) {
      keydir=staticdir2;
      if (dynamicdir2!=DIR_NONE)
        keydir=dynamicdir2;
    }
    else {
      keydir2=staticdir2;
      if (dynamicdir2!=DIR_NONE)
        keydir2=dynamicdir2;
    }
    staticdir2=DIR_NONE;
  }
  else {
    apply_network_controls(n);
  }

  if (joyflag) {
    incpenalty();
    incpenalty();
    joyanay=0;
    joyanax=0;
    for (j=0;j<4;j++) {
      readjoy();
      joyanax+=joyx;
      joyanay+=joyy;
    }
    joyx=joyanax>>2;
    joyy=joyanay>>2;
    if (joybut1)
      firepflag=true;
    else
      firepflag=false;
  }
}

/* Calibrate joystick while waiting at title screen. This works more
   effectively if the user waggles the joystick in the title screen. */
bool teststart(void)
{
  int16_t j;
  bool startf=false;
  if (joyflag) {
    readjoy();
    if (joybut1)
      startf=true;
  }
  if (start) {
    start=false;
    startf=true;
    joyflag=false;
  }
  if (!startf)
    return false;
  if (joyflag) {
    joyanay=0;
    joyanax=0;
    for (j=0;j<50;j++) {
      readjoy();
      joyanax+=joyx;
      joyanay+=joyy;
    }
    joyx=joyanax/50;
    joyy=joyanay/50;
    jleftthresh=joyx-35;
    if (jleftthresh<0)
      jleftthresh=0;
    jleftthresh+=10;
    jupthresh=joyy-35;
    if (jupthresh<0)
      jupthresh=0;
    jupthresh+=10;
    jrightthresh=joyx+35;
    if (jrightthresh>255)
      jrightthresh=255;
    jrightthresh-=10;
    jdownthresh=joyy+35;
    if (jdownthresh>255)
      jdownthresh=255;
    jdownthresh-=10;
    joyanax=joyx;
    joyanay=joyy;
  }
  return true;
}

/* Why the joystick reading is split between readdirect and getdir like this is a
   mystery to me. */
int16_t getdirect(int n)
{
  int16_t dir=((n==0) ? keydir : keydir2);
  if (joyflag) {
    dir=DIR_NONE;
    if (joyx<jleftthresh)
      dir=DIR_LEFT;
    if (joyx>jrightthresh)
      dir=DIR_RIGHT;
    if (joyx>=jleftthresh && joyx<=jrightthresh) {
      if (joyy<jupthresh)
        dir=DIR_UP;
      if (joyy>jdownthresh)
        dir=DIR_DOWN;
    }
  }
  if (n==0) {
    if (playing)
      playgetdir(&dir,&firepflag);
    recputdir(dir,firepflag);
  }
  else {
    if (playing)
      playgetdir(&dir,&fire2pflag);
    recputdir(dir,fire2pflag);
  }
  return dir;
}