#ifndef IGNORE_DEPEND
#include <GL/glut.h>
#include <iostream.h>
#endif

#include "world.h"

void World::ResetPlayer(int i, bool init, int gamemode){
  players[i].loc.set(0,0,0);
  players[i].theta=0;
  players[i].phi= 0;
  players[i].speed = 0.14;//0.1;
  players[i].angle = 1;

  players[i].glowing=BASE_GLOW;
  players[i].hp=BASE_HP;

  if(npc.numModels>i)  players[i].model = i;
  else  players[i].model = -1;
  players[i].frame = 0;
   
  //if this is a real player or just reseting player pos
  if (!init || i<=gamemode)
    course.SetStartLocation(&(players[i]),i, init);
}

void World::ResetCamera(int i){
  cameras[i].at.set(0,0,0);
  cameras[i].eye.set(0,0,0);
  cameras[i].up.set(0,0,1);
  cameras[i].dir.set(-3,0,0);
  cameras[i].mode = ATTACHED_CAMERA;
}

bool World::Init(int gamemode, char *skyboxPath, char*courseFilename, char* npcFilename, char *eventFilename) {
  bool bError = false;
  levelover1=false;
  levelover2=false;
  goaltype=0;
  goalx=0;
  goaly=0;
  goaldistance=2.0;

  // initalize skybox data
  //if (!skybox.Init(skyboxPath)) {
  //  cerr << "World: ERROR initializing skybox" << endl;
  //  bError = true;
  //}


  // initalize course data
  if (!course.Init(courseFilename)) {
    cerr << "World: ERROR initializing course" << endl;
    bError = true;
  }

  if (!npc.Init(npcFilename, &chats, &course)){
    cerr <<"World: ERROR initializing npc"<<endl;
    bError = true;
  }

  course.thenpcs=&npc;

  if (!eventer.Init(eventFilename, &course)) {
    cerr << "World: ERROR intializing event"<<endl;
    bError=true;
  }

  // initalize players and camera
  for (int i=0; i<MAXPLAYERS; i++) {
    ResetPlayer(i, true, gamemode);
    ResetCamera(i);
  }
  
  

  cout<<"World has inited"<<endl;
  return (!bError);
}

void World::SetPlayerFrame(int ID, int delta){
  if(delta == 0) 
    players[ID].frame = 0;
  else{
    int totalFrames = npc.GetNumFrames(players[ID].model);
    if(totalFrames > 1){
      players[ID].frame += delta%(totalFrames-1);
      if(players[ID].frame < 0)                         //-1 becomes 30
        players[ID].frame +=  totalFrames; 
      else if(players[ID].frame > totalFrames-1) //31 becomes 1
        players[ID].frame -=  totalFrames-1;
      else if(players[ID].frame == 0)                   //0 becomes 1 or 30
        players[ID].frame = (delta > 0)?1:totalFrames-1;
    }else
      players[ID].frame = 0;
  }
}

void World::RenderPlayer(int ID){
  glPushMatrix();
  glColor3f(1,1,1);
  glTranslatef(V3COMP(players[ID].loc));
  glRotatef(players[ID].theta, 0,0,1);
  //glRotatef(players[ID].phi, 0,1,0);

  if (players[ID].glowing>=0) {
    GLfloat globalambient[]={0.4,0.4,0.2,1.0};
    glLightModelfv(GL_LIGHT_MODEL_AMBIENT, globalambient);
  }

  npc.RenderModel(players[ID].model, players[ID].frame);
  GLfloat globalambientdefault[]={0.2,0.2,0.2,1.0};
  glLightModelfv(GL_LIGHT_MODEL_AMBIENT, globalambientdefault);

  glPopMatrix();
}

void World::Render(int numplayers, int playerID){
  //if (!skybox.Render()) 
  //cerr << "World: ERROR rendering skybox" << endl;

  if (!course.Render())
    cerr << "World: ERROR rendering course" << endl;

  if (!npc.RenderAll(&cameras[playerID]))
    cerr << "World: ERROR rendering npc" <<endl;

  //draw players
  glPushMatrix();
  RenderPlayer(0);
  if (numplayers>1) RenderPlayer(1);
  glPopMatrix();
  npc.SetDefaultMaterial();  

/*
  //draw a marker at the goal
  glPushMatrix();
  glColor3f(1,0.7,0);
  glTranslatef(goalx,goaly,3);
  glDisable(GL_LIGHTING);
  glutSolidTeapot(0.3);
  glPopMatrix();
*/
}


void World::StartGlowing(int player) {
  if (players[player].glowing<=BASE_GLOW) {
    players[player].glowing=FULL_GLOW;
    
    if (  (players[0].loc.x-players[1].loc.x)*(players[0].loc.x-players[1].loc.x) + (players[0].loc.x-players[1].loc.y)*(players[0].loc.x-players[1].loc.y) < GLOWDISTANCE*GLOWDISTANCE) {
      //in range, so whack the other player
      if (player==0) players[1].hp-=GLOW_DAMAGE;
      if (player==1) players[0].hp-=GLOW_DAMAGE;
    }
    
  }
  
}


void World::UpdateState() {
  //cout<<"World updates state"<<endl;
  npc.ExecuteAI();
  //cout<<"updating world state, player1event is "<<eventer.player1event<<endl;
  //process events for the players:
  eventer.detectevents(0,players[0].loc.x,players[0].loc.y);
  if (eventer.player1event!=-1)
    eventer.checktime(0);//playerid, current time

  eventer.detectevents(1,players[1].loc.x,players[1].loc.y);
  if (eventer.player2event!=-1)
    eventer.checktime(1);


  //now do the player battle things
  if (  (players[0].loc.x-players[1].loc.x)*(players[0].loc.x-players[1].loc.x) + (players[0].loc.y-players[1].loc.y)*(players[0].loc.y-players[1].loc.y) < GLOWDISTANCE*GLOWDISTANCE) {
    //people are being glowed at, so do the damage
    if (players[0].glowing>=0) players[1].hp-=GLOW_AREA_DAMAGE;
    if (players[1].glowing>=0) players[0].hp-=GLOW_AREA_DAMAGE;
    //cout<<"glow damage from area"<<endl;
  } //else cout<<"no glow damage from area: "<<(players[0].loc.x-players[1].loc.x)*(players[0].loc.x-players[1].loc.x)<<"+"<<(players[0].loc.y-players[1].loc.y)*(players[0].loc.y-players[1].loc.y<<">="<<GLOWDISTANCE*GLOWDISTANCE<<endl;

  for (int x=0; x<2; x++) {
    if (players[x].glowing>BASE_GLOW) players[x].glowing--;
    if (players[x].hp<BASE_HP) players[x].hp++;

    if (players[x].hp<0) {
      eventer.manualmessage(x,1000,"Warning! Damage taken, must repair!");
    }
  }


}

PlayerState World::GetPlayer(int which) {
  //cout<<"World returns a player"<<endl;
  if (which>MAXPLAYERS) {
    cerr<<"WARNING GetPlayer called on a player ("<<which
        <<") greater than MAXPLAYERS: "<<MAXPLAYERS
        <<" ; setting which to 0 for this one"<<endl;
    which=0;
  }
  PlayerState returnval;
  returnval.loc.set(players[which].loc);
  returnval.phi=players[which].phi;
  returnval.theta=players[which].theta;
  returnval.speed = players[which].speed;
  returnval.angle = players[which].angle;
  return returnval;
}


int World::GetCourseSize() {
  return course.GetSize();
}



void World::actionbutton(int who) {

//****************************************************************************
    if (chats.CheckTalking(who)==false) {//no conversation, so lets start another if theres someone to talk to
      int targetxbase=(int)(players[who].loc.x+cos(players[who].theta/57.296));
      int targetybase=(int)(players[who].loc.y+sin(players[who].theta/57.296));
      cout<<"considering action at "<<targetxbase<<","<<targetybase<<endl;

      //try the target square first
      if (!((targetxbase<0)||(targetybase<0)||(targetxbase>=course.coursewidth)||(targetybase>=course.courseheight))) {

        if ( ((course.coursemap[targetybase*(course.coursewidth)+targetxbase]).contents>-1)&&
             (course.coursemap[targetybase*(course.coursewidth)+targetxbase]).contents<10000) {
          //attempt to converse with the object in that square, which is not a player
          cout<<"value at targetx,targety, times width "<<course.coursewidth<<" is "
              <<(course.coursemap[targetybase*(course.coursewidth)+targetxbase]).contents<<", that's index "
              <<targetybase*(course.coursewidth)+targetxbase<<endl;
          npc.doconversation((course.coursemap[targetybase*(course.coursewidth)+targetxbase]).contents,who);
          return;
        }
      }

          //now try adjacent squares
      for (int targety=targetybase-1; targety<targetybase+2; targety++) 
        for (int targetx=targetxbase-1; targetx<targetxbase+2; targetx++) {
          if ((targetx==targetxbase) && (targety==targetybase)) continue;

          if ((targetx<0)||(targety<0)||(targetx>=course.coursewidth)||(targety>=course.courseheight)) continue;

          if ( ((course.coursemap[targety*(course.coursewidth)+targetx]).contents>-1)&&
               (course.coursemap[targety*(course.coursewidth)+targetx]).contents<10000) {
            //attempt to converse with the object in that square, which is not a player
            cout<<"value at targetx,targety, times width "<<course.coursewidth<<" is "
                <<(course.coursemap[targety*(course.coursewidth)+targetx]).contents<<", that's index "
                <<targety*(course.coursewidth)+targetx<<endl;
            npc.doconversation((course.coursemap[targety*(course.coursewidth)+targetx]).contents,who);
            return;
          }
        }

    } else {//in one already, so continue
      chats.ContinueMessage(who);
    }



}



bool World::Finished(int numplayers) {

  if (levelover1==false)
  if (sqrt( (players[0].loc.x-goalx)*(players[0].loc.x-goalx)+(players[0].loc.y-goaly)*(players[0].loc.y-goaly) )<goaldistance) {
    cerr<<"Player 1 has reached the goal!!!!"<<endl;
    eventer.manualmessage(0,8000000,"YAY! Congratulations, you have found  panties!!");
    levelover1=true;
  }
  if (levelover2==false)
  if (sqrt( (players[1].loc.x-goalx)*(players[1].loc.x-goalx)+(players[1].loc.y-goaly)*(players[1].loc.y-goaly) )<goaldistance) {
    cerr<<"Player 2 has reached the goal!!!!"<<endl;
    eventer.manualmessage(1,8000000,"YAY! Congratulations, you have found  panties!!");
    cerr<<"Player 2 has reached the goal!!!!"<<endl;
    levelover2=true;
  }

  if (levelover1 && (levelover2 || (numplayers<2))) 
    return true;
  else return false;


}

void World::SetGoal(int gtype, float gx, float gy, float gd) {
  goaltype=gtype;
  goalx=gx;
  goaly=gy;
  goaldistance=gd;
}