SimpleTerrainWidget.C

Go to the documentation of this file.

// $Id $

// SimpleTerrain Widget Implementation
#include "SimpleTerrainWidget.H"
#include "ST_PFEngine.H"
#include "GfxModule.H"
#include "GfxGlobal.H"
#include "Profiler.H"

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

using namespace std;
using boost::shared_ptr;

namespace SimpleTerrain {

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

SimpleTerrainOverlay::SimpleTerrainOverlay(const ST_Terrain &terrain, GfxModule &gfxm_)
  : dot(gfxm_), gfxm(&gfxm_)
{
  enabled = false;
  terrain_p = &terrain;
  forcefield_p = 0;
}
SimpleTerrainOverlay::SimpleTerrainOverlay(const ST_ForceField &terrain, GfxModule &gfxm_)
  : dot(gfxm_), gfxm(&gfxm_)
{
  //  enabled = false;
  enabled = true;
  forcefield_p = &terrain;
  terrain_p = 0;
}

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

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

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

void SimpleTerrainOverlay::draw()
{
  PROFILE("TerrainOverlay");

  if (!enabled) return;

  bool draw_air = false;

  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 = map->get_w();
  sint4 map_height = map->get_h();
  
  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-1);
  real4 dy = (real4)gh / (real4)(map_height-1);

  {
    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");
    if (terrain_p){     
      const std::list<ST_Task> &tasks = terrain_p->tasks;

      Vec3<real4> c(1,1,1);

      dot.begin_lines();
      FORALL (tasks, j) {
    if (!j->path) continue;
    const UnitPath &upath = *j->path;
    const Vector<Loc> &path = upath.path;
      
    real4 x1, y1;
    if (path.size() > 1) {
      x1 = map->world2x(path[0].x);
      y1 = map->world2y(path[0].y);
      x1 *= dx;
      y1 *= dy;

      for (uint4 i = 1; i < path.size(); ++i) {
        real4 x2 = map->world2x(path[i].x);
        real4 y2 = map->world2y(path[i].y);
        x2 *= dx;
        y2 *= dy;
          
        dot.draw_line(x1, y1, x2, y2, c, 1.0);
          
        x1 = x2;
        y1 = y2;
      }
    }
      }
    
      dot.end_lines();
    }
    else{
      const std::list<FF_Task> &tasks = forcefield_p->tasks;

      Vec3<real4> c(1,1,1);

      dot.begin_lines();
      FORALL (tasks, j) {
    if (!j->path) continue;
    const UnitPath_FF &upath = *j->path;
    const Vector<Loc> &path = upath.path;
      
    real4 x1, y1;
    if (path.size() > 1) {
      x1 = map->world2x(path[0].x);
      y1 = map->world2y(path[0].y);
      x1 *= dx;
      y1 *= dy;

      for (uint4 i = 1; i < path.size(); ++i) {
        real4 x2 = map->world2x(path[i].x);
        real4 y2 = map->world2y(path[i].y);
        x2 *= dx;
        y2 *= dy;
          
        dot.draw_line(x1, y1, x2, y2, c, 1.0);
          
        x1 = x2;
        y1 = y2;
      }
    }
      }
    
      dot.end_lines();
    }
  }
    
  glEnable(GL_TEXTURE_2D);
}

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

SimpleTerrainWidget::SimpleTerrainWidget(const ST_Terrain &terrain, GfxModule *gfxm)
{
  if (gfxm) {
    overlay = new SimpleTerrainOverlay(terrain, *gfxm);
    gfxm->add_handler(overlay);
    //    overlay->enable();
  } else {
    overlay = 0;
  }

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

  set_name("ST_Terrain");
  terrain_p = &terrain;
  forcefield_p = 0;
}

SimpleTerrainWidget::SimpleTerrainWidget(const ST_ForceField &terrain, GfxModule *gfxm)
{
  if (gfxm) {
    overlay = new SimpleTerrainOverlay(terrain, *gfxm);
    gfxm->add_handler(overlay);
    overlay->enable();
  } else {
    overlay = 0;
  }

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

  set_name("ST_ForceField");
  forcefield_p = &terrain;
  terrain_p = 0;
}

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

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

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

stype SimpleTerrainWidget::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 SimpleTerrainWidget::draw()
{
  if (!!off) return stype();
  
  shared_ptr<const ST_Terrain::PFEngine::Map> map;
  

  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 = map->get_w();
  wheight = map->get_h();
  
  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
  if (terrain_p){
    const std::list<ST_Task> &tasks = terrain_p->tasks;
    FORALL (tasks, j) {
      if (!j->path) continue;
      const UnitPath &upath = *j->path;
      const Vector<Loc> &path = upath.path;

      glColor4f(1, 1, 1, 1);
      glBegin(GL_LINE_STRIP);

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

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

      sint4 wux = map->world2x(ux);
      sint4 wuy = map->world2y(uy);
    
      glVertex2f(x+(wux*xd),    y+h-(wuy*yd)-yd);
      glVertex2f(x+(wux*xd)+xd, y+h-(wuy*yd)-yd);
      glVertex2f(x+(wux*xd)+xd, y+h-(wuy*yd)   );
      glVertex2f(x+(wux*xd),    y+h-(wuy*yd)   );
    
      glEnd();
    }
  }
  else{ //st_terrain is a ST_ForceField
    const std::list<FF_Task> &tasks = forcefield_p->tasks;
    FORALL (tasks, j) {
      if (!j->path) continue;
      const UnitPath_FF &upath = *j->path;
      const Vector<Loc> &path = upath.path;

      glColor4f(1, 1, 1, 1);
      glBegin(GL_LINE_STRIP);

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

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

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

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

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

#if 0
  void SimpleTerrainWidget::set_env(Environment* env_){
    env = env_;
    wwidth = map->get_w();
    wheight = map->get_h();
  }
#endif

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

}