#ifndef IGNORE_DEPEND
#include <math.h>
#include <string.h>
#include <iostream.h>
#include <fstream.h>
#endif

#include "input.h"


//////////////////////////////////////////////////////////////////////////////
// init functions
//
//
Input::Input() {
  UseToggle = false;
  InPlayerMode[0] = true;
  InPlayerMode[1] = true;
}

Input::~Input() {}

void Input::Init(char *inputFile) {
  for (int x=0; x<MAX_KEYS; x++) KeyPressed[x]=false;
  for (int x=0; x<NUM_SPEC_KEYS; x++) SpecialKeyPressed[x]=false;
  for (int x=0; x<NUM_MAPPED_KEYS; x++) ActionList[x] = -1;

  //read input file
  ifstream is(inputFile);
  if(!is.good()){
    cerr<<"Cannot open inputfile "<<inputFile <<"\nUsing default setting instead.\n";

    //read failed, use default mapping
    ActionList[GO_FORWARD] = 'w';
    ActionList[GO_BACKWARD] = 's';
    ActionList[GO_LEFT] = 'a';
    ActionList[GO_RIGHT] = 'd';
    ActionList[GO_UP] = '=';
    ActionList[GO_DOWN] = '\\';
    ActionList[TURN_LEFT] = 'q';
    ActionList[TURN_RIGHT] = 'e';
    ActionList[LOOK_UP] = 'r';
    ActionList[LOOK_DOWN] = 'f';
  
    ActionList[T_POS_X] = '8'; 
    ActionList[T_NEG_X] = '5'; 
    ActionList[T_POS_Y] = '4'; 
    ActionList[T_NEG_Y] = '6'; 
    ActionList[T_POS_Z] = '+'; 
    ActionList[T_NEG_Z] = '-'; 
    ActionList[R_POS_X] = '3'; 
    ActionList[R_NEG_X] = '1'; 
    ActionList[R_POS_Y] = '/'; 
    ActionList[R_NEG_Y] = '*'; 
    ActionList[R_POS_Z] = '7'; 
    ActionList[R_NEG_Z] = '9';  

    ActionList[TOGGLE] = 't';
    ActionList[ACTION] = 'g';
    ActionList[GLOW] = 'v';
    ActionList[MODE] = 'm';



    //read failed, use default mapping for player 2
    ActionList[GO_FORWARD2] = 'i';
    ActionList[GO_BACKWARD2] = 'k';
    ActionList[GO_LEFT2] = 'j';
    ActionList[GO_RIGHT2] = 'l';
    ActionList[GO_UP2] = '[';
    ActionList[GO_DOWN2] = ']';
    ActionList[TURN_LEFT2] = 'u';
    ActionList[TURN_RIGHT2] = 'o';
    ActionList[LOOK_UP2] = 'p';
    ActionList[LOOK_DOWN2] = ';';
  
    ActionList[T_POS_X2] = '8'; 
    ActionList[T_NEG_X2] = '5'; 
    ActionList[T_POS_Y2] = '4'; 
    ActionList[T_NEG_Y2] = '6'; 
    ActionList[T_POS_Z2] = '+'; 
    ActionList[T_NEG_Z2] = '-'; 
    ActionList[R_POS_X2] = '3'; 
    ActionList[R_NEG_X2] = '1'; 
    ActionList[R_POS_Y2] = '/'; 
    ActionList[R_NEG_Y2] = '*'; 
    ActionList[R_POS_Z2] = '7'; 
    ActionList[R_NEG_Z2] = '9';  

    ActionList[TOGGLE2] = '.';
    ActionList[ACTION2] = '\'';
    ActionList[GLOW2] = ',';
    ActionList[MODE2] = '/';

  }else{
    char *action = new char[256];
    char c;

    //read mapping
    while (is.good()){
      is>>action>>c;
      //cout<<"Mapping "<<action<<"["<<c<<"]\n";
      if(strcasecmp(action,"USE_TOGGLE")==0)  UseToggle = (c=='Y' || c=='y')?true:false;

      else if(strcasecmp(action, "GO_FORWARD")==0)      ActionList[GO_FORWARD] = c;
      else if(strcasecmp(action,"GO_BACKWARD")==0) ActionList[GO_BACKWARD] = c;
      else if(strcasecmp(action,"GO_LEFT")==0)     ActionList[GO_LEFT] = c;
      else if(strcasecmp(action,"GO_RIGHT")==0)    ActionList[GO_RIGHT] = c;
      else if(strcasecmp(action,"GO_UP")==0)       ActionList[GO_UP] = c;
      else if(strcasecmp(action,"GO_DOWN")==0)     ActionList[GO_DOWN] = c;
      else if(strcasecmp(action,"TURN_LEFT")==0)   ActionList[TURN_LEFT] = c;
      else if(strcasecmp(action,"TURN_RIGHT")==0)  ActionList[TURN_RIGHT] = c;
      else if(strcasecmp(action,"LOOK_UP")==0)     ActionList[LOOK_UP] = c;
      else if(strcasecmp(action,"LOOK_DOWN")==0)   ActionList[LOOK_DOWN] = c;
      else if(strcasecmp(action,"T_POS_X")==0)     ActionList[T_POS_X] = c;
      else if(strcasecmp(action,"T_NEG_X")==0)     ActionList[T_NEG_X] = c;
      else if(strcasecmp(action,"T_POS_Y")==0)     ActionList[T_POS_Y] = c;
      else if(strcasecmp(action,"T_NEG_Y")==0)     ActionList[T_NEG_Y] = c;
      else if(strcasecmp(action,"T_POS_Z")==0)     ActionList[T_POS_Z] = c;
      else if(strcasecmp(action,"T_NEG_Z")==0)     ActionList[T_NEG_Z] = c;
      else if(strcasecmp(action,"R_POS_X")==0)     ActionList[R_POS_X] = c;
      else if(strcasecmp(action,"R_NEG_X")==0)     ActionList[R_NEG_X] = c;
      else if(strcasecmp(action,"R_POS_Y")==0)     ActionList[R_POS_Y] = c;
      else if(strcasecmp(action,"R_NEG_Y")==0)     ActionList[R_NEG_Y] = c;
      else if(strcasecmp(action,"R_POS_Z")==0)     ActionList[R_POS_Z] = c;
      else if(strcasecmp(action,"R_NEG_Z")==0)     ActionList[R_NEG_Z] = c;
      else if(strcasecmp(action,"TOGGLE")==0)      ActionList[TOGGLE] = c;
      else if(strcasecmp(action,"ACTION")==0)      ActionList[ACTION] = c;
      else if(strcasecmp(action,"GLOW")==0)        ActionList[GLOW] = c;
      else if(strcasecmp(action,"MODE")==0)        ActionList[MODE] = c;


      else if(strcasecmp(action, "GO_FORWARD2")==0)      ActionList[GO_FORWARD2] = c;
      else if(strcasecmp(action,"GO_BACKWARD2")==0) ActionList[GO_BACKWARD2] = c;
      else if(strcasecmp(action,"GO_LEFT2")==0)     ActionList[GO_LEFT2] = c;
      else if(strcasecmp(action,"GO_RIGHT2")==0)    ActionList[GO_RIGHT2] = c;
      else if(strcasecmp(action,"GO_UP2")==0)       ActionList[GO_UP2] = c;
      else if(strcasecmp(action,"GO_DOWN2")==0)     ActionList[GO_DOWN2] = c;
      else if(strcasecmp(action,"TURN_LEFT2")==0)   ActionList[TURN_LEFT2] = c;
      else if(strcasecmp(action,"TURN_RIGHT2")==0)  ActionList[TURN_RIGHT2] = c;
      else if(strcasecmp(action,"LOOK_UP2")==0)     ActionList[LOOK_UP2] = c;
      else if(strcasecmp(action,"LOOK_DOWN2")==0)   ActionList[LOOK_DOWN2] = c;
      else if(strcasecmp(action,"T_POS_X2")==0)     ActionList[T_POS_X2] = c;
      else if(strcasecmp(action,"T_NEG_X2")==0)     ActionList[T_NEG_X2] = c;
      else if(strcasecmp(action,"T_POS_Y2")==0)     ActionList[T_POS_Y2] = c;
      else if(strcasecmp(action,"T_NEG_Y2")==0)     ActionList[T_NEG_Y2] = c;
      else if(strcasecmp(action,"T_POS_Z2")==0)     ActionList[T_POS_Z2] = c;
      else if(strcasecmp(action,"T_NEG_Z2")==0)     ActionList[T_NEG_Z2] = c;
      else if(strcasecmp(action,"R_POS_X2")==0)     ActionList[R_POS_X2] = c;
      else if(strcasecmp(action,"R_NEG_X2")==0)     ActionList[R_NEG_X2] = c;
      else if(strcasecmp(action,"R_POS_Y2")==0)     ActionList[R_POS_Y2] = c;
      else if(strcasecmp(action,"R_NEG_Y2")==0)     ActionList[R_NEG_Y2] = c;
      else if(strcasecmp(action,"R_POS_Z2")==0)     ActionList[R_POS_Z2] = c;
      else if(strcasecmp(action,"R_NEG_Z2")==0)     ActionList[R_NEG_Z2] = c;
      else if(strcasecmp(action,"TOGGLE2")==0)      ActionList[TOGGLE2] = c;
      else if(strcasecmp(action,"ACTION2")==0)      ActionList[ACTION2] = c;
      else if(strcasecmp(action,"GLOW2")==0)        ActionList[GLOW2] = c;
      else if(strcasecmp(action,"MODE2")==0)        ActionList[MODE2] = c;

      else cout<<"Unknown action"<<action<<endl;
    }
  }
}
  
////////////////////////////////////////////////////////////////////////////////////////////////////////
// player action functions
//
//
void Input::GoForward(int id){
  vector3f temp, dir = vector3f(1,0,0)*s_pWorld->players[id].speed;

  if ((s_pWorld->players[id].hp>=0)&&(s_pWorld->eventer.incutscene(id)==false)) {
    temp=s_pWorld->players[id].loc+dir.rotate_z(toRadian(s_pWorld->players[id].theta));
    if (s_pWorld->course.CheckCollision(V3COMP(s_pWorld->players[id].loc), V3COMP(temp),10000+id)==false) {
      if ( ((int)(s_pWorld->players[id].loc.x)!=(int)(temp.x)) || 
           ((int)(s_pWorld->players[id].loc.y)!=(int)(temp.y)) ) {
        s_pWorld->course.MoveDynamicObject(  (int)(s_pWorld->players[id].loc.x), 
                                             (int)(s_pWorld->players[id].loc.y),
                                             (int)(temp.x) ,(int)(temp.y) );
      }
      //s_pWorld->players[id].loc+=dir.rotate_z(toRadian(s_pWorld->players[id].theta));
      s_pWorld->players[id].loc=temp;
      s_pWorld->SetPlayerFrame(id, 1);
    } 

    //added section
    else {//try partial motion
          //try y only
      temp.x=s_pWorld->players[id].loc.x;
      if (s_pWorld->course.CheckCollision(V3COMP(s_pWorld->players[id].loc), V3COMP(temp),10000+id)==false) {
        if ( ((int)(s_pWorld->players[id].loc.x)!=(int)(temp.x)) || 
             ((int)(s_pWorld->players[id].loc.y)!=(int)(temp.y)) ) {
          s_pWorld->course.MoveDynamicObject(  (int)(s_pWorld->players[id].loc.x), 
                                               (int)(s_pWorld->players[id].loc.y),
                                               (int)(temp.x) ,(int)(temp.y) );
        }
        s_pWorld->players[id].loc=temp;//+=dir.rotate_z(toRadian(s_pWorld->players[id].theta));
        s_pWorld->SetPlayerFrame(id, 1);     
      }
        
      //try x only
      temp=s_pWorld->players[id].loc+dir.rotate_z(toRadian(s_pWorld->players[id].theta));
      temp.y=s_pWorld->players[id].loc.y;
      if (s_pWorld->course.CheckCollision(V3COMP(s_pWorld->players[id].loc), V3COMP(temp),10000+id)==false) {
        if ( ((int)(s_pWorld->players[id].loc.x)!=(int)(temp.x)) || 
             ((int)(s_pWorld->players[id].loc.y)!=(int)(temp.y)) ) {
          s_pWorld->course.MoveDynamicObject(  (int)(s_pWorld->players[id].loc.x), 
                                               (int)(s_pWorld->players[id].loc.y),
                                               (int)(temp.x) ,(int)(temp.y) );
        }
        s_pWorld->players[id].loc=temp;//+=dir.rotate_z(toRadian(s_pWorld->players[id].theta));
        s_pWorld->SetPlayerFrame(id, 1);
      }
    }
    //end addition
  }
}

void Input::GoBackward(int id){
  vector3f temp, dir = vector3f(1,0,0)*s_pWorld->players[id].speed;

  if ((s_pWorld->players[id].hp>=0)&&(s_pWorld->eventer.incutscene(id)==false)) {
    temp=s_pWorld->players[id].loc-dir.rotate_z(toRadian(s_pWorld->players[id].theta));
    if (s_pWorld->course.CheckCollision(V3COMP(s_pWorld->players[id].loc), V3COMP(temp), 10000+id)==false) {
      if ( ((int)(s_pWorld->players[id].loc.x)!=(int)(temp.x)) || 
           ((int)(s_pWorld->players[id].loc.y)!=(int)(temp.y)) ) {
        s_pWorld->course.MoveDynamicObject(  (int)(s_pWorld->players[id].loc.x), 
                                             (int)(s_pWorld->players[id].loc.y),
                                             (int)(temp.x) ,(int)(temp.y) );
      }
      s_pWorld->players[id].loc-=dir.rotate_z(toRadian(s_pWorld->players[id].theta));
      s_pWorld->SetPlayerFrame(id, -1);
    }
  }
}

void Input::GoLeft(int id){
vector3f temp, dir = vector3f(1,0,0)*s_pWorld->players[id].speed;

  if ((s_pWorld->players[id].hp>=0)&&(s_pWorld->eventer.incutscene(id)==false)) {
    temp=s_pWorld->players[id].loc+dir.rotate_z(toRadian(s_pWorld->players[id].theta+90));
    if (s_pWorld->course.CheckCollision(V3COMP(s_pWorld->players[id].loc),  V3COMP(temp), 10000+id)==false) {
      if ( ((int)(s_pWorld->players[id].loc.x)!=(int)(temp.x)) || 
           ((int)(s_pWorld->players[id].loc.y)!=(int)(temp.y)) ) {
        s_pWorld->course.MoveDynamicObject(  (int)(s_pWorld->players[id].loc.x), 
                                             (int)(s_pWorld->players[id].loc.y),
                                             (int)(temp.x) ,(int)(temp.y) );
      }
      s_pWorld->players[id].loc+=dir.rotate_z(toRadian(s_pWorld->players[id].theta+90));
    }
  }
}

void Input::GoRight(int id){
  vector3f temp, dir = vector3f(1,0,0)*s_pWorld->players[id].speed;

  if ((s_pWorld->players[id].hp>=0)&&(s_pWorld->eventer.incutscene(id)==false)) {
    temp=s_pWorld->players[id].loc-dir.rotate_z(toRadian(s_pWorld->players[id].theta+90));
    if (s_pWorld->course.CheckCollision(V3COMP(s_pWorld->players[id].loc), V3COMP(temp), 10000+id)==false) {
      if ( ((int)(s_pWorld->players[id].loc.x)!=(int)(temp.x)) || 
           ((int)(s_pWorld->players[id].loc.y)!=(int)(temp.y)) ) {
        s_pWorld->course.MoveDynamicObject(  (int)(s_pWorld->players[id].loc.x), 
                                             (int)(s_pWorld->players[id].loc.y),
                                             (int)(temp.x) ,(int)(temp.y) );
      }
      s_pWorld->players[id].loc-=dir.rotate_z(toRadian(s_pWorld->players[id].theta+90));
    }
  }
}

void Input::TurnLeft(int id, float angle){
  s_pWorld->players[id].theta+=angle;
  if (s_pWorld->players[id].theta>=360.0)
    s_pWorld->players[id].theta-=360.0;
}      

void Input::TurnRight(int id, float angle){
  s_pWorld->players[id].theta-=angle;
  if (s_pWorld->players[id].theta<0)  
    s_pWorld->players[id].theta+=360.0;
}

void Input::LookUp(int id){
  s_pWorld->players[id].phi+=s_pWorld->players[id].angle;
  if (s_pWorld->players[id].phi>179.8) 
    s_pWorld->players[id].phi=179.8;
  if (s_pWorld->players[id].phi>=360.0)
    s_pWorld->players[id].phi-=360.0;
}

void Input::LookDown(int id){
  s_pWorld->players[id].phi-=s_pWorld->players[id].angle;
  if (s_pWorld->players[id].phi<0.2) 
    s_pWorld->players[id].phi=0.2;
  if (s_pWorld->players[id].phi<0)
    s_pWorld->players[id].phi+=360.0;  
}

void Input::GoUp(int id){
  vector3f temp = s_pWorld->players[id].loc;
  temp.z+=s_pWorld->players[id].speed;
  if ((s_pWorld->players[id].hp>=0)&&(s_pWorld->eventer.incutscene(id)==false)) {
    if (s_pWorld->course.CheckCollision(V3COMP(s_pWorld->players[id].loc), V3COMP(temp), 10000+id)==false)
      s_pWorld->players[id].loc.z+=s_pWorld->players[id].speed;
  }
}

void Input::GoDown(int id){
 vector3f temp = s_pWorld->players[id].loc;
 temp.z-=s_pWorld->players[id].speed;
 if ((s_pWorld->players[id].hp>=0)&&(s_pWorld->eventer.incutscene(id)==false)) {
   if (s_pWorld->course.CheckCollision(V3COMP(s_pWorld->players[id].loc), V3COMP(temp), 10000+id)==false)
     s_pWorld->players[id].loc.z-=s_pWorld->players[id].speed;
 }
}

//////////////////////////////////////////////////////////////////////////////////////
// camera control functions
//
//

//go forward/backward
void Input::TranslateX(int id, int sign){
  vector3f dir = s_pWorld->cameras[id].at - s_pWorld->cameras[id].eye;
  dir.normalize();
  dir*=(s_pWorld->players[id].speed);
  s_pWorld->cameras[id].at+=dir*sign;
  s_pWorld->cameras[id].eye+=dir*sign;
}

//go left/right
void Input::TranslateY(int id, int sign){
  //rotate <at> by 90 deg along <up>
  vector3f dir = RotateAxisAngle(s_pWorld->cameras[id].at, 
                                 (float)(toRadian(90)), 
                                 s_pWorld->cameras[id].eye, 
                                 s_pWorld->cameras[id].eye+s_pWorld->cameras[id].up);
  dir -= s_pWorld->cameras[id].eye;
  dir.normalize();
  dir*=s_pWorld->players[id].speed;
  s_pWorld->cameras[id].at+=dir*sign;
  s_pWorld->cameras[id].eye+=dir*sign;
}

//go up/down
void Input::TranslateZ(int id, int sign){
  vector3f dir = s_pWorld->cameras[id].up;
  dir.normalize();
  dir*=s_pWorld->players[id].speed;
  s_pWorld->cameras[id].at+=dir*sign;
  s_pWorld->cameras[id].eye+=dir*sign;
}

//look (rotate) side ways - roll 
void Input::RotateX(int id, int sign){
  vector3f dir = RotateAxisAngle(s_pWorld->cameras[id].eye+s_pWorld->cameras[id].up,
                                 (float)(toRadian(sign*s_pWorld->players[id].angle)),
                                 s_pWorld->cameras[id].eye,
                                 s_pWorld->cameras[id].at);
  s_pWorld->cameras[id].up.set(dir-s_pWorld->cameras[id].eye);
}

//look (rotate) up/down - pitch
void Input::RotateY(int id, int sign){
  //find y (sign vector)
  vector3f yaxis = cross(s_pWorld->cameras[id].at-s_pWorld->cameras[id].eye, 
                         s_pWorld->cameras[id].up);
  //rotate <at>
  vector3f dir = RotateAxisAngle(s_pWorld->cameras[id].at, 
                                 (float)(toRadian(sign*s_pWorld->players[id].angle)),
                                 s_pWorld->cameras[id].eye, 
                                 s_pWorld->cameras[id].eye+yaxis);
  s_pWorld->cameras[id].at.set(dir);
  //rotate <up>
  dir = RotateAxisAngle(s_pWorld->cameras[id].eye+s_pWorld->cameras[id].up,
                        (float)(toRadian(sign*s_pWorld->players[id].angle)), 
                        s_pWorld->cameras[id].eye, 
                        s_pWorld->cameras[id].eye+yaxis);
  s_pWorld->cameras[id].up.set(dir-s_pWorld->cameras[id].eye);
}

//look (rotate) left/right - yaw
void Input::RotateZ(int id, int sign){
  vector3f dir = RotateAxisAngle(s_pWorld->cameras[id].at, 
                                 (float)(toRadian(sign*s_pWorld->players[id].angle)),
                                 s_pWorld->cameras[id].eye,
                                 s_pWorld->cameras[id].eye+s_pWorld->cameras[id].up);
  s_pWorld->cameras[id].at.set(dir);
}


///////////////////////////////////////////////////////////////////////////////////////
// key and mouse listeners
//
//

void Input::KeyDown(unsigned char key, int x, int y) {
  int keyID = -1, keyID2 = -1;
  int playerID = 0;
  char msg[1024];

  for (int i = 0; i<NUM_MAPPED_KEYS; i++) 
    if (key == ActionList[i]){
      if(keyID==-1) keyID = i;
      else keyID2 = i;
    }  

  if(keyID >= GO_FORWARD2) playerID = 1;

  //invalid key mapping, no point going thru the function
  if (keyID == -1) return;

  /////////////////////////////////////////////////////
  // general control keys
  //
  if (UseToggle && (keyID == TOGGLE || keyID == TOGGLE2)){
    //if UseToggle is enabled, then you can toggle mode
    InPlayerMode[playerID] = !InPlayerMode[playerID];
    if(InPlayerMode[playerID]) 
      s_pWorld->cameras[playerID].mode = ATTACHED_CAMERA;
    else
      s_pWorld->cameras[playerID].mode = DETACHED_CAMERA;

    sprintf(msg, "Player[%i] control in %s", playerID, 
            (InPlayerMode[playerID])?"Player Mode - Attached Camera":"Camera Mode - Detached Camera");
    s_pWorld->eventer.manualmessage(playerID, 5000, msg);
    
  }else if (InPlayerMode[playerID] && (keyID == MODE || keyID == MODE2)){ 
    //change camera mode, only effective in player model
    s_pWorld->cameras[0].mode++;
    s_pWorld->cameras[0].mode%=NUM_CAMERA_MODE;

    switch(s_pWorld->cameras[playerID].mode){
    case ATTACHED_CAMERA: 
      sprintf(msg, "Player[%i] camera in Attached Mode", playerID); break;
    case TAILING_CAMERA:
      sprintf(msg, "Player[%i] camera in Tailing Mode", playerID); break;
    case DETACHED_CAMERA:
      sprintf(msg, "Player[%i] camera in Detached Mode", playerID); break;
    case ADJUST_CAMERA:
      sprintf(msg, "Player[%i] camera in Adjust Mode: position saved, toggle again to continue", playerID); break; 
    default:
      sprintf(msg, "ERROR: Player[%i] invalid camera mode ID=%d", playerID, s_pWorld->cameras[playerID].mode); break;
    }
    s_pWorld->eventer.manualmessage(playerID, 5000, msg);

  }else if (keyID == ACTION || keyID == ACTION2){
    s_pWorld->actionbutton(playerID);
  } else if (key==ActionList[GLOW] || key==ActionList[GLOW2]) {
    s_pWorld->StartGlowing(playerID);
  }



  ////////////////////////////////////////////////////
  // player control keys
  //
  if(!UseToggle || (UseToggle && InPlayerMode[playerID])){
    if(keyID == GO_FORWARD || keyID == GO_FORWARD2)          
      GoForward(playerID);
    else if (keyID == GO_BACKWARD || keyID == GO_BACKWARD2)   
      GoBackward(playerID);
    else if (keyID == GO_LEFT || keyID == GO_LEFT2)       
      GoLeft(playerID);
    else if (keyID == GO_RIGHT || keyID == GO_RIGHT2)      
      GoRight(playerID);
    else if (keyID == TURN_LEFT || keyID == TURN_LEFT2)
      TurnLeft(playerID, s_pWorld->players[playerID].angle);
    else if (keyID == TURN_RIGHT || keyID == TURN_RIGHT2)
      TurnRight(playerID, s_pWorld->players[playerID].angle);
    else if (keyID == LOOK_UP || keyID == LOOK_UP2)
      LookUp(playerID);
    else if (keyID == LOOK_DOWN || keyID == LOOK_DOWN2)
      LookDown(playerID);
    else if (keyID == GO_UP || keyID == GO_UP)
      GoUp(playerID);
    else if (keyID == GO_DOWN || keyID == GO_DOWN)
      GoDown(playerID);
  }


  /////////////////////////////////////////////////////
  // camera control keys
  //  
  if(!UseToggle || (UseToggle && !InPlayerMode[playerID])){
    int KEY = (keyID2>0)?keyID2:keyID;
    if (      KEY == T_POS_X  || KEY == T_NEG_X ||
              KEY == T_POS_X2 || KEY == T_NEG_X2 ){
      TranslateX(playerID, (KEY == T_POS_X || KEY == T_POS_X2)?1:-1);
    }else if (KEY == T_POS_Y  || KEY == T_NEG_Y ||
              KEY == T_POS_Y2 || KEY == T_NEG_Y2 ){
      TranslateY(playerID, (KEY == T_POS_Y || KEY == T_POS_Y2)?1:-1);
    }else if (KEY == T_POS_Z  || KEY == T_NEG_Z ||
              KEY == T_POS_Z2 || KEY == T_NEG_Z2 ){
      TranslateZ(playerID, (KEY == T_POS_Z || KEY == T_POS_Z2)?1:-1);
    }else if (KEY == R_POS_X  || KEY == R_NEG_X ||
              KEY == R_POS_X2 || KEY == R_NEG_X2 ){
      RotateX(playerID, (KEY == R_POS_X || KEY == R_POS_X2)?1:-1);
    }else if (KEY == R_POS_Y  || KEY == R_NEG_Y ||
              KEY == R_POS_Y2 || KEY == R_NEG_Y2 ){
      RotateY(playerID, (KEY == R_POS_Y || KEY == R_POS_Y2)?1:-1);
    }else if (KEY == R_POS_Z  || KEY == R_NEG_Z || 
              KEY == R_POS_Z2 || KEY == R_NEG_Z2 ){
      RotateZ(playerID, (KEY == R_POS_Z || KEY == R_POS_Z2)?1:-1);
    }
  }

///////////////////////////////////////////////////////
  KeyPressed[(int)key]=true;
}



void Input::KeyUp(unsigned char key, int x, int y) {
  KeyPressed[(int)key]=false;
  if(key == ActionList[GO_FORWARD]){
    s_pWorld->SetPlayerFrame(0, 0);
  }else if (key == ActionList[GO_BACKWARD]){ 
    s_pWorld->SetPlayerFrame(0, 0);
  }else if (key == ActionList[GO_FORWARD2]){
    s_pWorld->SetPlayerFrame(1, 0);
  }else if (key == ActionList[GO_BACKWARD2]){ 
    s_pWorld->SetPlayerFrame(1, 0);
  }
}

void Input::SKeyDown(int key, int x, int y) {
  ///////////////////////////////
  // special keys that is not maped by the file
  //
  if (key == RESET){
    InPlayerMode[0] = true;
    s_pWorld->ResetPlayer(0, false, 0);
    s_pWorld->ResetCamera(0);
    InPlayerMode[1] = true;
    s_pWorld->ResetPlayer(1, false, 0);
    s_pWorld->ResetCamera(1);

  }else if (key == PRINTSTATE){
    printf("player[0] state = (%2f,%2f,%2f) theta = %2f phi = %2f\n",
           V3COMP(s_pWorld->players[0].loc),
           s_pWorld->players[0].theta,
           s_pWorld->players[0].phi);
    printf("camera[0] state eye = (%2f,%2f,%2f) at = (%2f,%2f,%2f) up = (%2f,%2f,%2f) \n", 
           V3COMP(s_pWorld->cameras[0].eye), 
           V3COMP(s_pWorld->cameras[0].at),
           V3COMP(s_pWorld->cameras[0].up));
    cout<<"player 0 hp/glow: "<<s_pWorld->players[0].hp<<","<<s_pWorld->players[0].glowing<<endl;

    printf("player[1] state = (%2f,%2f,%2f) theta = %2f phi = %2f\n",
           V3COMP(s_pWorld->players[1].loc),
           s_pWorld->players[1].theta,
           s_pWorld->players[1].phi);
    printf("camera[1] state eye = (%2f,%2f,%2f) at = (%2f,%2f,%2f) up = (%2f,%2f,%2f) \n", 
           V3COMP(s_pWorld->cameras[1].eye), 
           V3COMP(s_pWorld->cameras[1].at),
           V3COMP(s_pWorld->cameras[1].up));
    cout<<"player 1 hp/glow: "<<s_pWorld->players[1].hp<<","<<s_pWorld->players[1].glowing<<endl;
  }
}

void Input::SKeyUp(int key, int x, int y) {}

void Input::MouseMotion(int x, int y) {}
void Input::PassiveMouseMotion(int x, int y) {}
void Input::MouseButton(int button, int state, int x, int y) {}

void Input::Repeats() {//repeats actions for anything held down
  for (int x=0; x<MAX_KEYS; x++) {
    if      (x == ActionList[TOGGLE]) {}
    else if (x == ActionList[MODE]) {}
    else if (x == ActionList[ACTION]) {}
    else if (x == ActionList[ACTION2]) {}
    else if(KeyPressed[x]==true) {
      KeyDown((unsigned char)x,0,0);
    }
  }

  for (int x=0; x<NUM_SPEC_KEYS; x++) {
    if (x == PRINTSTATE) {}
    else if (x == RESET) {}
    else if (SpecialKeyPressed[x]==true) {
      SKeyDown(x,0,0);
    }
  }
}