SimplePathfinderWidget.C

Go to the documentation of this file.

// $Id $

// SimpleTerrain Widget Implementation
#include "SimplePathfinderWidget.H"
#include "SimplePathfinder.H"
#include "GfxModule.H"
#include "GfxGlobal.H"
#include "Profiler.H"
#include "PathfindTask.H"

#include "Game.H"
#include "GameStateModule.H"

using namespace std;
using boost::shared_ptr;

typedef TerrainBase::Loc Loc;

//===================================================================

SimplePathfinderOverlay::SimplePathfinderOverlay(const SimplePathfinder &terrain, GfxModule &gfxm_)
  : dot(gfxm_), gfxm(&gfxm_)
{
  enabled = true;
  terrain_p = &terrain;
}

//-------------------------------------------------------------------

bool SimplePathfinderOverlay::handle_event(const Event &e)
{
  if (e.get_who() == GfxModule::FROM) {
    if (e.get_what() == GfxModule::DRAW_MSG) {
      draw();
      return true;
    }
  }
  return false;
}

//-------------------------------------------------------------------

void SimplePathfinderOverlay::draw()
{
  PROFILE("TerrainOverlay");
  //glDisable(GL_TEXTURE_2D);

  if (!enabled) return;
  
  //bool draw_air = false;
  
  if(!terrain_p->initiated) return;
  //   shared_ptr<const ST_Terrain::PFEngine::Map> map;
  //   if (forcefield_p){
  //     if (!forcefield_p->pfEngine) return;
  //     map = draw_air ? forcefield_p->pfEngine->get_air_map() : forcefield_p->pfEngine->get_ground_map();
  //   }
  //   else{
  //     if (!terrain_p->pfEngine) return;
  //     map =  draw_air ? terrain_p->pfEngine->get_air_map() : terrain_p->pfEngine->get_ground_map();
  //   }
    
  
  //if (!st_terrain->pfEngine) return;

  //shared_ptr<const ST_Terrain::PFEngine::Map> map = draw_air ? st_terrain->pfEngine->get_air_map() : st_terrain->pfEngine->get_ground_map();

  sint4 map_width = terrain_p->tiles_x * terrain_p->tile_points;
  sint4 map_height = terrain_p->tiles_y * terrain_p->tile_points;
  
  sint4 gw = gfxm->get_game().get_map().get_width();
  sint4 gh = gfxm->get_game().get_map().get_height();
  
  real4 dx = (real4)gw / (real4)(map_width);
  real4 dy = (real4)gh / (real4)(map_height);

//   {
//     PROFILE("draw tiles");
// #if 1
//     dot.begin_squares();
//     FORS (xi, map_width) {
//       FORS (yi, map_height) {
//         if ((*map)(xi, yi).max_size > 0 || (*map)(xi, yi).cost != 0 ) {
          
//           Vec3<real4> c;
//           real4 v = (*map)(xi, yi).max_size / 20.0;
//           c = Vec3<real4>(v, 0, 0);
//             //          if ((*map)(xi, yi).max_size < 1) c = Vec3<real4>(1, 0, 0);
//             //          if ((*map)(xi, yi).cost > 0)     c = Vec3<real4>(0, 1, 1);

//           real4 x1 = (xi-0.5) * dx;
//           real4 x2 = (xi+0.5) * dx;
//           real4 y1 = (yi-0.5) * dy;
//           real4 y2 = (yi+0.5) * dy;
          
//           dot.draw_square(x1, y1, x2, y2, c);
//         }
//       }
//     }
//     dot.end_squares();
// #endif
//   }
 
  {
    PROFILE("draw lines");
 
    const std::list<PathfindTask> &tasks = terrain_p->tasks;
    
    Vec3<real4> c(1,0,0);
      
    dot.begin_lines();
 
    FORALL (tasks, j) {
      if (j->isPending) continue;
      //const UnitPath &upath = *j->path;
      const Vector<Loc> &path = j->path.locs;
      
      real4 x1, y1;
      if (path.size() > 1) {
    x1 = path[0].x;
    y1 = path[0].y;
    x1 *= dx;
    y1 *= dy;

    for (uint4 i = 1; i < path.size(); ++i) {
      real4 x2 = path[i].x;
      real4 y2 = path[i].y;
      x2 *= dx;
      y2 *= dy;
      //  std::cout << "drawing lines\n";
      dot.draw_line(x1, y1, x2, y2, c, 1.0);
          
      x1 = x2;
      y1 = y2;
    }
      }
    }
 
    
    dot.end_lines();
      
  }
    
  //glEnable(GL_TEXTURE_2D);
}

//===================================================================
//===================================================================

SimplePathfinderWidget::SimplePathfinderWidget(const SimplePathfinder &terrain, GfxModule *gfxm)
{
  if (gfxm) {
    overlay = new SimplePathfinderOverlay(terrain, *gfxm);
    gfxm->add_handler(overlay);
    overlay->enable();
  } else {
    overlay = 0;
  }

  draw_tiles = true;
  draw_air = false;
  wwidth = 0;
  wheight = 0;

  set_name("Path Widget");
  terrain_p = &terrain;
  
}


//-------------------------------------------------------------------

SimplePathfinderWidget::~SimplePathfinderWidget()
{
  if (overlay) delete overlay;
}

//===================================================================

stype SimplePathfinderWidget::event_key_down(stype key, stype /*mod*/, stype x, stype y)
{
  if (is_outside(x,y)) return stype();
  cout << "event_key_down" << endl;
  
//   shared_ptr<const ST_Terrain::PFEngine::Map> map;

//   if (forcefield_p){  
//     map = draw_air ? forcefield_p->pfEngine->get_air_map() : forcefield_p->pfEngine->get_ground_map();
//   }
//   else{
//     map =  draw_air ? terrain_p->pfEngine->get_air_map() : terrain_p->pfEngine->get_ground_map();
//   }
    
  
 //  shared_ptr<const ST_Terrain::PFEngine::Map> map = draw_air ? st_terrain->pfEngine->get_air_map() : st_terrain->pfEngine->get_ground_map();

  char index = (char)key.to_int();
  
  switch(index){
    
  case '\t':
    if (overlay) {
      if (overlay->is_enabled()) {
        overlay->disable();
      } else {
        overlay->enable();
      }
    }
    return stype(1);

  case 't':
    draw_tiles = !draw_tiles;
    return stype(1);
    
  case 'a':
    draw_air = !draw_air;
    //    map = draw_air ? air_map : gnd_map;
    return stype(1);
    
//   case 'p':
//     FORS (y, map->get_h()) {
//       FORS (x, map->get_w()) {
//         if ((*map)(x,y).max_size >= 0) cout << " ";
//         cout << (int)((*map)(x, y).max_size);
//       }
//       cout << endl;
//     }
//   case 'c':
//     FORS (y, map->get_h()) {
//       FORS (x, map->get_w()) {
//         cout << " ";
//         cout << (int)((*map)(x, y).cost);
//       }
//       cout << endl;
//     }
//     return stype(1);
    
  default:
    break;
  }

  return stype();
}

//===================================================================

stype SimplePathfinderWidget::draw()
{
  if (!!off) return stype();
  
  // shared_ptr<const ST_Terrain::PFEngine::Map> map;
  
   if (!terrain_p->initiated) return stype();

//   if (forcefield_p){
//     if(!forcefield_p->pfEngine) return stype();
//     map = draw_air ? forcefield_p->pfEngine->get_air_map() : forcefield_p->pfEngine->get_ground_map();
//   }
//   else{
//     if(!terrain_p->pfEngine) return stype();
//     map =  draw_air ? terrain_p->pfEngine->get_air_map() : terrain_p->pfEngine->get_ground_map();
//   }
  
  //shared_ptr<const ST_Terrain::PFEngine::Map> map = draw_air ? st_terrain->pfEngine->get_air_map() : st_terrain->pfEngine->get_ground_map();

  wwidth = terrain_p->tiles_x * terrain_p->tile_points;
  wheight = terrain_p ->tiles_x * terrain_p->tile_points;
  
  sint4 x = this->x.to_int();
  sint4 y = this->y.to_int();
  sint4 w = this->w.to_int();
  sint4 h = this->h.to_int();

  real8 xd = (real8)w/(real8)wwidth;
  real8 yd = (real8)h/(real8)wheight;

  //draw_grid(wwidth, wheight);
  
  //   FORS (xi, wwidth) {
  //     FORS (yi, wheight) {
  //       if ((*map)(xi, yi).max_size <= 0 || (*map)(xi, yi).cost != 0 ) {
  //         if ((*map)(xi, yi).max_size < 1) glColor4f(1, 0, 0,  1.0);
  //         if ((*map)(xi, yi).cost > 0)     glColor4f(0, 1, 1,  1.0);
  //         glBegin(GL_QUADS);
        
  //         glVertex2f( x+xi*xd    , y+h-yi*yd   -yd );
  //         glVertex2f( x+xi*xd+xd , y+h-yi*yd   -yd );
  //         glVertex2f( x+xi*xd+xd , y+h-yi*yd+yd-yd );
  //         glVertex2f( x+xi*xd    , y+h-yi*yd+yd-yd );
        
  //         glEnd();
  //       }
  //     }
  //   }
  
#if 1
  
  const std::list<PathfindTask> &tasks = terrain_p->tasks;
  FORALL (tasks, j) {
    if (j->isPending) continue;

    const Vector<Loc> &path = j->path.locs;
   
    glColor4f(1, 1, 1, 1);
    glBegin(GL_LINE_STRIP);

    FORALL (path, i) {
      sint4 wix = i->x;
      sint4 wiy = i->y;
      glVertex2f((real8)x+         ((real8)wix * xd),
         (real8)y+(real8)h-((real8)wiy * yd));
    }

    glEnd();
    
    //unit
    const Object *obj = *(j->task.objs.begin());
    sint4 ux, uy;
    obj->get_center(ux, uy);
    
    glColor4f(1, 1, 1, 1);
    glBegin(GL_QUADS);

    //sint4 wux = ux;
    //sint4 wuy = uy;
    
    glVertex2f(x+(ux*xd),    y+h-(uy*yd)-yd);
    glVertex2f(x+(ux*xd)+xd, y+h-(uy*yd)-yd);
    glVertex2f(x+(ux*xd)+xd, y+h-(uy*yd)   );
    glVertex2f(x+(ux*xd),    y+h-(uy*yd)   );
    
    glEnd();
  }

  

#endif
    
  glEnable(GL_TEXTURE_2D);
  
  return stype();
}


//===================================================================